blob: 4bbd2e4e7cc08f95659d7bc0ff7dece5d48ae7c3 [file] [log] [blame]
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001/*
2 * WPA Supplicant - Driver event processing
3 * Copyright (c) 2003-2011, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15#include "includes.h"
16
17#include "common.h"
18#include "eapol_supp/eapol_supp_sm.h"
19#include "rsn_supp/wpa.h"
20#include "eloop.h"
21#include "config.h"
22#include "l2_packet/l2_packet.h"
23#include "wpa_supplicant_i.h"
24#include "driver_i.h"
25#include "pcsc_funcs.h"
26#include "rsn_supp/preauth.h"
27#include "rsn_supp/pmksa_cache.h"
28#include "common/wpa_ctrl.h"
29#include "eap_peer/eap.h"
30#include "ap/hostapd.h"
31#include "p2p/p2p.h"
32#include "notify.h"
33#include "common/ieee802_11_defs.h"
34#include "common/ieee802_11_common.h"
35#include "crypto/random.h"
36#include "blacklist.h"
37#include "wpas_glue.h"
38#include "wps_supplicant.h"
39#include "ibss_rsn.h"
40#include "sme.h"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080041#include "gas_query.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070042#include "p2p_supplicant.h"
43#include "bgscan.h"
44#include "ap.h"
45#include "bss.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070046#include "scan.h"
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080047#include "offchannel.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070048
49
50static int wpa_supplicant_select_config(struct wpa_supplicant *wpa_s)
51{
52 struct wpa_ssid *ssid, *old_ssid;
53
54 if (wpa_s->conf->ap_scan == 1 && wpa_s->current_ssid)
55 return 0;
56
57 wpa_dbg(wpa_s, MSG_DEBUG, "Select network based on association "
58 "information");
59 ssid = wpa_supplicant_get_ssid(wpa_s);
60 if (ssid == NULL) {
61 wpa_msg(wpa_s, MSG_INFO,
62 "No network configuration found for the current AP");
63 return -1;
64 }
65
66 if (ssid->disabled) {
67 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is disabled");
68 return -1;
69 }
70
71 wpa_dbg(wpa_s, MSG_DEBUG, "Network configuration found for the "
72 "current AP");
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080073 if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070074 u8 wpa_ie[80];
75 size_t wpa_ie_len = sizeof(wpa_ie);
76 wpa_supplicant_set_suites(wpa_s, NULL, ssid,
77 wpa_ie, &wpa_ie_len);
78 } else {
79 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
80 }
81
82 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid)
83 eapol_sm_invalidate_cached_session(wpa_s->eapol);
84 old_ssid = wpa_s->current_ssid;
85 wpa_s->current_ssid = ssid;
86 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
87 wpa_supplicant_initiate_eapol(wpa_s);
88 if (old_ssid != wpa_s->current_ssid)
89 wpas_notify_network_changed(wpa_s);
90
91 return 0;
92}
93
94
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -080095void wpa_supplicant_stop_countermeasures(void *eloop_ctx, void *sock_ctx)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070096{
97 struct wpa_supplicant *wpa_s = eloop_ctx;
98
99 if (wpa_s->countermeasures) {
100 wpa_s->countermeasures = 0;
101 wpa_drv_set_countermeasures(wpa_s, 0);
102 wpa_msg(wpa_s, MSG_INFO, "WPA: TKIP countermeasures stopped");
103 wpa_supplicant_req_scan(wpa_s, 0, 0);
104 }
105}
106
107
108void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s)
109{
110 int bssid_changed;
111
112#ifdef CONFIG_IBSS_RSN
113 ibss_rsn_deinit(wpa_s->ibss_rsn);
114 wpa_s->ibss_rsn = NULL;
115#endif /* CONFIG_IBSS_RSN */
116
Dmitry Shmidtc55524a2011-07-07 11:18:38 -0700117#ifdef CONFIG_AP
118 wpa_supplicant_ap_deinit(wpa_s);
119#endif /* CONFIG_AP */
120
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700121 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
122 return;
123
124 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt43007fd2011-04-11 15:58:40 -0700125 wpa_s->conf->ap_scan = DEFAULT_AP_SCAN;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700126 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
127 os_memset(wpa_s->bssid, 0, ETH_ALEN);
128 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
129 wpa_s->current_bss = NULL;
130 wpa_s->assoc_freq = 0;
Dmitry Shmidtc55524a2011-07-07 11:18:38 -0700131#ifdef CONFIG_IEEE80211R
132#ifdef CONFIG_SME
133 if (wpa_s->sme.ft_ies)
134 sme_update_ft_ies(wpa_s, NULL, NULL, 0);
135#endif /* CONFIG_SME */
136#endif /* CONFIG_IEEE80211R */
137
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700138 if (bssid_changed)
139 wpas_notify_bssid_changed(wpa_s);
140
141 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
142 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
143 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt))
144 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
145 wpa_s->ap_ies_from_associnfo = 0;
146}
147
148
149static void wpa_find_assoc_pmkid(struct wpa_supplicant *wpa_s)
150{
151 struct wpa_ie_data ie;
152 int pmksa_set = -1;
153 size_t i;
154
155 if (wpa_sm_parse_own_wpa_ie(wpa_s->wpa, &ie) < 0 ||
156 ie.pmkid == NULL)
157 return;
158
159 for (i = 0; i < ie.num_pmkid; i++) {
160 pmksa_set = pmksa_cache_set_current(wpa_s->wpa,
161 ie.pmkid + i * PMKID_LEN,
162 NULL, NULL, 0);
163 if (pmksa_set == 0) {
164 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
165 break;
166 }
167 }
168
169 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID from assoc IE %sfound from "
170 "PMKSA cache", pmksa_set == 0 ? "" : "not ");
171}
172
173
174static void wpa_supplicant_event_pmkid_candidate(struct wpa_supplicant *wpa_s,
175 union wpa_event_data *data)
176{
177 if (data == NULL) {
178 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: No data in PMKID candidate "
179 "event");
180 return;
181 }
182 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID candidate event - bssid=" MACSTR
183 " index=%d preauth=%d",
184 MAC2STR(data->pmkid_candidate.bssid),
185 data->pmkid_candidate.index,
186 data->pmkid_candidate.preauth);
187
188 pmksa_candidate_add(wpa_s->wpa, data->pmkid_candidate.bssid,
189 data->pmkid_candidate.index,
190 data->pmkid_candidate.preauth);
191}
192
193
194static int wpa_supplicant_dynamic_keys(struct wpa_supplicant *wpa_s)
195{
196 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
197 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
198 return 0;
199
200#ifdef IEEE8021X_EAPOL
201 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
202 wpa_s->current_ssid &&
203 !(wpa_s->current_ssid->eapol_flags &
204 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
205 EAPOL_FLAG_REQUIRE_KEY_BROADCAST))) {
206 /* IEEE 802.1X, but not using dynamic WEP keys (i.e., either
207 * plaintext or static WEP keys). */
208 return 0;
209 }
210#endif /* IEEE8021X_EAPOL */
211
212 return 1;
213}
214
215
216/**
217 * wpa_supplicant_scard_init - Initialize SIM/USIM access with PC/SC
218 * @wpa_s: pointer to wpa_supplicant data
219 * @ssid: Configuration data for the network
220 * Returns: 0 on success, -1 on failure
221 *
222 * This function is called when starting authentication with a network that is
223 * configured to use PC/SC for SIM/USIM access (EAP-SIM or EAP-AKA).
224 */
225int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s,
226 struct wpa_ssid *ssid)
227{
228#ifdef IEEE8021X_EAPOL
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800229#ifdef PCSC_FUNCS
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700230 int aka = 0, sim = 0, type;
231
232 if (ssid->eap.pcsc == NULL || wpa_s->scard != NULL)
233 return 0;
234
235 if (ssid->eap.eap_methods == NULL) {
236 sim = 1;
237 aka = 1;
238 } else {
239 struct eap_method_type *eap = ssid->eap.eap_methods;
240 while (eap->vendor != EAP_VENDOR_IETF ||
241 eap->method != EAP_TYPE_NONE) {
242 if (eap->vendor == EAP_VENDOR_IETF) {
243 if (eap->method == EAP_TYPE_SIM)
244 sim = 1;
245 else if (eap->method == EAP_TYPE_AKA)
246 aka = 1;
247 }
248 eap++;
249 }
250 }
251
252 if (eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_SIM) == NULL)
253 sim = 0;
254 if (eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_AKA) == NULL)
255 aka = 0;
256
257 if (!sim && !aka) {
258 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to "
259 "use SIM, but neither EAP-SIM nor EAP-AKA are "
260 "enabled");
261 return 0;
262 }
263
264 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to use SIM "
265 "(sim=%d aka=%d) - initialize PCSC", sim, aka);
266 if (sim && aka)
267 type = SCARD_TRY_BOTH;
268 else if (aka)
269 type = SCARD_USIM_ONLY;
270 else
271 type = SCARD_GSM_SIM_ONLY;
272
273 wpa_s->scard = scard_init(type);
274 if (wpa_s->scard == NULL) {
275 wpa_msg(wpa_s, MSG_WARNING, "Failed to initialize SIM "
276 "(pcsc-lite)");
277 return -1;
278 }
279 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
280 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800281#endif /* PCSC_FUNCS */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700282#endif /* IEEE8021X_EAPOL */
283
284 return 0;
285}
286
287
288#ifndef CONFIG_NO_SCAN_PROCESSING
289static int wpa_supplicant_match_privacy(struct wpa_scan_res *bss,
290 struct wpa_ssid *ssid)
291{
292 int i, privacy = 0;
293
294 if (ssid->mixed_cell)
295 return 1;
296
297#ifdef CONFIG_WPS
298 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
299 return 1;
300#endif /* CONFIG_WPS */
301
302 for (i = 0; i < NUM_WEP_KEYS; i++) {
303 if (ssid->wep_key_len[i]) {
304 privacy = 1;
305 break;
306 }
307 }
308#ifdef IEEE8021X_EAPOL
309 if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
310 ssid->eapol_flags & (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
311 EAPOL_FLAG_REQUIRE_KEY_BROADCAST))
312 privacy = 1;
313#endif /* IEEE8021X_EAPOL */
314
Jouni Malinen75ecf522011-06-27 15:19:46 -0700315 if (wpa_key_mgmt_wpa(ssid->key_mgmt))
316 privacy = 1;
317
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700318 if (bss->caps & IEEE80211_CAP_PRIVACY)
319 return privacy;
320 return !privacy;
321}
322
323
324static int wpa_supplicant_ssid_bss_match(struct wpa_supplicant *wpa_s,
325 struct wpa_ssid *ssid,
326 struct wpa_scan_res *bss)
327{
328 struct wpa_ie_data ie;
329 int proto_match = 0;
330 const u8 *rsn_ie, *wpa_ie;
331 int ret;
332 int wep_ok;
333
334 ret = wpas_wps_ssid_bss_match(wpa_s, ssid, bss);
335 if (ret >= 0)
336 return ret;
337
338 /* Allow TSN if local configuration accepts WEP use without WPA/WPA2 */
339 wep_ok = !wpa_key_mgmt_wpa(ssid->key_mgmt) &&
340 (((ssid->key_mgmt & WPA_KEY_MGMT_NONE) &&
341 ssid->wep_key_len[ssid->wep_tx_keyidx] > 0) ||
342 (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA));
343
344 rsn_ie = wpa_scan_get_ie(bss, WLAN_EID_RSN);
345 while ((ssid->proto & WPA_PROTO_RSN) && rsn_ie) {
346 proto_match++;
347
348 if (wpa_parse_wpa_ie(rsn_ie, 2 + rsn_ie[1], &ie)) {
349 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - parse "
350 "failed");
351 break;
352 }
353
354 if (wep_ok &&
355 (ie.group_cipher & (WPA_CIPHER_WEP40 | WPA_CIPHER_WEP104)))
356 {
357 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on TSN "
358 "in RSN IE");
359 return 1;
360 }
361
362 if (!(ie.proto & ssid->proto)) {
363 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - proto "
364 "mismatch");
365 break;
366 }
367
368 if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) {
369 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - PTK "
370 "cipher mismatch");
371 break;
372 }
373
374 if (!(ie.group_cipher & ssid->group_cipher)) {
375 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - GTK "
376 "cipher mismatch");
377 break;
378 }
379
380 if (!(ie.key_mgmt & ssid->key_mgmt)) {
381 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - key mgmt "
382 "mismatch");
383 break;
384 }
385
386#ifdef CONFIG_IEEE80211W
387 if (!(ie.capabilities & WPA_CAPABILITY_MFPC) &&
388 ssid->ieee80211w == MGMT_FRAME_PROTECTION_REQUIRED) {
389 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - no mgmt "
390 "frame protection");
391 break;
392 }
393#endif /* CONFIG_IEEE80211W */
394
395 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on RSN IE");
396 return 1;
397 }
398
399 wpa_ie = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
400 while ((ssid->proto & WPA_PROTO_WPA) && wpa_ie) {
401 proto_match++;
402
403 if (wpa_parse_wpa_ie(wpa_ie, 2 + wpa_ie[1], &ie)) {
404 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - parse "
405 "failed");
406 break;
407 }
408
409 if (wep_ok &&
410 (ie.group_cipher & (WPA_CIPHER_WEP40 | WPA_CIPHER_WEP104)))
411 {
412 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on TSN "
413 "in WPA IE");
414 return 1;
415 }
416
417 if (!(ie.proto & ssid->proto)) {
418 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - proto "
419 "mismatch");
420 break;
421 }
422
423 if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) {
424 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - PTK "
425 "cipher mismatch");
426 break;
427 }
428
429 if (!(ie.group_cipher & ssid->group_cipher)) {
430 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - GTK "
431 "cipher mismatch");
432 break;
433 }
434
435 if (!(ie.key_mgmt & ssid->key_mgmt)) {
436 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - key mgmt "
437 "mismatch");
438 break;
439 }
440
441 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on WPA IE");
442 return 1;
443 }
444
445 if ((ssid->proto & (WPA_PROTO_WPA | WPA_PROTO_RSN)) &&
446 wpa_key_mgmt_wpa(ssid->key_mgmt) && proto_match == 0) {
447 wpa_dbg(wpa_s, MSG_DEBUG, " skip - no WPA/RSN proto match");
448 return 0;
449 }
450
451 if (!wpa_key_mgmt_wpa(ssid->key_mgmt)) {
452 wpa_dbg(wpa_s, MSG_DEBUG, " allow in non-WPA/WPA2");
453 return 1;
454 }
455
456 wpa_dbg(wpa_s, MSG_DEBUG, " reject due to mismatch with "
457 "WPA/WPA2");
458
459 return 0;
460}
461
462
463static int freq_allowed(int *freqs, int freq)
464{
465 int i;
466
467 if (freqs == NULL)
468 return 1;
469
470 for (i = 0; freqs[i]; i++)
471 if (freqs[i] == freq)
472 return 1;
473 return 0;
474}
475
476
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800477static int ht_supported(const struct hostapd_hw_modes *mode)
478{
479 if (!(mode->flags & HOSTAPD_MODE_FLAG_HT_INFO_KNOWN)) {
480 /*
481 * The driver did not indicate whether it supports HT. Assume
482 * it does to avoid connection issues.
483 */
484 return 1;
485 }
486
487 /*
488 * IEEE Std 802.11n-2009 20.1.1:
489 * An HT non-AP STA shall support all EQM rates for one spatial stream.
490 */
491 return mode->mcs_set[0] == 0xff;
492}
493
494
495static int rate_match(struct wpa_supplicant *wpa_s, struct wpa_scan_res *bss)
496{
497 const struct hostapd_hw_modes *mode = NULL, *modes;
498 const u8 scan_ie[2] = { WLAN_EID_SUPP_RATES, WLAN_EID_EXT_SUPP_RATES };
499 const u8 *rate_ie;
500 int i, j, k;
501
502 if (bss->freq == 0)
503 return 1; /* Cannot do matching without knowing band */
504
505 modes = wpa_s->hw.modes;
506 if (modes == NULL) {
507 /*
508 * The driver does not provide any additional information
509 * about the utilized hardware, so allow the connection attempt
510 * to continue.
511 */
512 return 1;
513 }
514
515 for (i = 0; i < wpa_s->hw.num_modes; i++) {
516 for (j = 0; j < modes[i].num_channels; j++) {
517 int freq = modes[i].channels[j].freq;
518 if (freq == bss->freq) {
519 if (mode &&
520 mode->mode == HOSTAPD_MODE_IEEE80211G)
521 break; /* do not allow 802.11b replace
522 * 802.11g */
523 mode = &modes[i];
524 break;
525 }
526 }
527 }
528
529 if (mode == NULL)
530 return 0;
531
532 for (i = 0; i < (int) sizeof(scan_ie); i++) {
533 rate_ie = wpa_scan_get_ie(bss, scan_ie[i]);
534 if (rate_ie == NULL)
535 continue;
536
537 for (j = 2; j < rate_ie[1] + 2; j++) {
538 int flagged = !!(rate_ie[j] & 0x80);
539 int r = (rate_ie[j] & 0x7f) * 5;
540
541 /*
542 * IEEE Std 802.11n-2009 7.3.2.2:
543 * The new BSS Membership selector value is encoded
544 * like a legacy basic rate, but it is not a rate and
545 * only indicates if the BSS members are required to
546 * support the mandatory features of Clause 20 [HT PHY]
547 * in order to join the BSS.
548 */
549 if (flagged && ((rate_ie[j] & 0x7f) ==
550 BSS_MEMBERSHIP_SELECTOR_HT_PHY)) {
551 if (!ht_supported(mode)) {
552 wpa_dbg(wpa_s, MSG_DEBUG,
553 " hardware does not support "
554 "HT PHY");
555 return 0;
556 }
557 continue;
558 }
559
560 if (!flagged)
561 continue;
562
563 /* check for legacy basic rates */
564 for (k = 0; k < mode->num_rates; k++) {
565 if (mode->rates[k] == r)
566 break;
567 }
568 if (k == mode->num_rates) {
569 /*
570 * IEEE Std 802.11-2007 7.3.2.2 demands that in
571 * order to join a BSS all required rates
572 * have to be supported by the hardware.
573 */
574 wpa_dbg(wpa_s, MSG_DEBUG, " hardware does "
575 "not support required rate %d.%d Mbps",
576 r / 10, r % 10);
577 return 0;
578 }
579 }
580 }
581
582 return 1;
583}
584
585
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700586static struct wpa_ssid * wpa_scan_res_match(struct wpa_supplicant *wpa_s,
587 int i, struct wpa_scan_res *bss,
588 struct wpa_ssid *group)
589{
590 const u8 *ssid_;
591 u8 wpa_ie_len, rsn_ie_len, ssid_len;
592 int wpa;
593 struct wpa_blacklist *e;
594 const u8 *ie;
595 struct wpa_ssid *ssid;
596
597 ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
598 ssid_ = ie ? ie + 2 : (u8 *) "";
599 ssid_len = ie ? ie[1] : 0;
600
601 ie = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
602 wpa_ie_len = ie ? ie[1] : 0;
603
604 ie = wpa_scan_get_ie(bss, WLAN_EID_RSN);
605 rsn_ie_len = ie ? ie[1] : 0;
606
607 wpa_dbg(wpa_s, MSG_DEBUG, "%d: " MACSTR " ssid='%s' "
608 "wpa_ie_len=%u rsn_ie_len=%u caps=0x%x level=%d%s",
609 i, MAC2STR(bss->bssid), wpa_ssid_txt(ssid_, ssid_len),
610 wpa_ie_len, rsn_ie_len, bss->caps, bss->level,
611 wpa_scan_get_vendor_ie(bss, WPS_IE_VENDOR_TYPE) ? " wps" : "");
612
613 e = wpa_blacklist_get(wpa_s, bss->bssid);
614 if (e) {
615 int limit = 1;
616 if (wpa_supplicant_enabled_networks(wpa_s->conf) == 1) {
617 /*
618 * When only a single network is enabled, we can
619 * trigger blacklisting on the first failure. This
620 * should not be done with multiple enabled networks to
621 * avoid getting forced to move into a worse ESS on
622 * single error if there are no other BSSes of the
623 * current ESS.
624 */
625 limit = 0;
626 }
627 if (e->count > limit) {
628 wpa_dbg(wpa_s, MSG_DEBUG, " skip - blacklisted "
629 "(count=%d limit=%d)", e->count, limit);
630 return NULL;
631 }
632 }
633
634 if (ssid_len == 0) {
635 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID not known");
636 return NULL;
637 }
638
639 wpa = wpa_ie_len > 0 || rsn_ie_len > 0;
640
641 for (ssid = group; ssid; ssid = ssid->pnext) {
642 int check_ssid = wpa ? 1 : (ssid->ssid_len != 0);
643
644 if (ssid->disabled) {
645 wpa_dbg(wpa_s, MSG_DEBUG, " skip - disabled");
646 continue;
647 }
648
649#ifdef CONFIG_WPS
650 if ((ssid->key_mgmt & WPA_KEY_MGMT_WPS) && e && e->count > 0) {
651 wpa_dbg(wpa_s, MSG_DEBUG, " skip - blacklisted "
652 "(WPS)");
653 continue;
654 }
655
656 if (wpa && ssid->ssid_len == 0 &&
657 wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))
658 check_ssid = 0;
659
660 if (!wpa && (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
661 /* Only allow wildcard SSID match if an AP
662 * advertises active WPS operation that matches
663 * with our mode. */
664 check_ssid = 1;
665 if (ssid->ssid_len == 0 &&
666 wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))
667 check_ssid = 0;
668 }
669#endif /* CONFIG_WPS */
670
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800671 if (ssid->bssid_set && ssid->ssid_len == 0 &&
672 os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) == 0)
673 check_ssid = 0;
674
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700675 if (check_ssid &&
676 (ssid_len != ssid->ssid_len ||
677 os_memcmp(ssid_, ssid->ssid, ssid_len) != 0)) {
678 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID mismatch");
679 continue;
680 }
681
682 if (ssid->bssid_set &&
683 os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0) {
684 wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID mismatch");
685 continue;
686 }
687
688 if (!wpa_supplicant_ssid_bss_match(wpa_s, ssid, bss))
689 continue;
690
691 if (!wpa &&
692 !(ssid->key_mgmt & WPA_KEY_MGMT_NONE) &&
693 !(ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
694 !(ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) {
695 wpa_dbg(wpa_s, MSG_DEBUG, " skip - non-WPA network "
696 "not allowed");
697 continue;
698 }
699
Jouni Malinen75ecf522011-06-27 15:19:46 -0700700 if (!wpa_supplicant_match_privacy(bss, ssid)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700701 wpa_dbg(wpa_s, MSG_DEBUG, " skip - privacy "
702 "mismatch");
703 continue;
704 }
705
Jouni Malinen75ecf522011-06-27 15:19:46 -0700706 if (bss->caps & IEEE80211_CAP_IBSS) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700707 wpa_dbg(wpa_s, MSG_DEBUG, " skip - IBSS (adhoc) "
708 "network");
709 continue;
710 }
711
712 if (!freq_allowed(ssid->freq_list, bss->freq)) {
713 wpa_dbg(wpa_s, MSG_DEBUG, " skip - frequency not "
714 "allowed");
715 continue;
716 }
717
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800718 if (!rate_match(wpa_s, bss)) {
719 wpa_dbg(wpa_s, MSG_DEBUG, " skip - rate sets do "
720 "not match");
721 continue;
722 }
723
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700724#ifdef CONFIG_P2P
725 /*
726 * TODO: skip the AP if its P2P IE has Group Formation
727 * bit set in the P2P Group Capability Bitmap and we
728 * are not in Group Formation with that device.
729 */
730#endif /* CONFIG_P2P */
731
732 /* Matching configuration found */
733 return ssid;
734 }
735
736 /* No matching configuration found */
737 return NULL;
738}
739
740
741static struct wpa_bss *
742wpa_supplicant_select_bss(struct wpa_supplicant *wpa_s,
743 struct wpa_scan_results *scan_res,
744 struct wpa_ssid *group,
745 struct wpa_ssid **selected_ssid)
746{
747 size_t i;
748
749 wpa_dbg(wpa_s, MSG_DEBUG, "Selecting BSS from priority group %d",
750 group->priority);
751
752 for (i = 0; i < scan_res->num; i++) {
753 struct wpa_scan_res *bss = scan_res->res[i];
754 const u8 *ie, *ssid;
755 u8 ssid_len;
756
757 *selected_ssid = wpa_scan_res_match(wpa_s, i, bss, group);
758 if (!*selected_ssid)
759 continue;
760
761 ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
762 ssid = ie ? ie + 2 : (u8 *) "";
763 ssid_len = ie ? ie[1] : 0;
764
765 wpa_dbg(wpa_s, MSG_DEBUG, " selected BSS " MACSTR
766 " ssid='%s'",
767 MAC2STR(bss->bssid), wpa_ssid_txt(ssid, ssid_len));
768 return wpa_bss_get(wpa_s, bss->bssid, ssid, ssid_len);
769 }
770
771 return NULL;
772}
773
774
775static struct wpa_bss *
776wpa_supplicant_pick_network(struct wpa_supplicant *wpa_s,
777 struct wpa_scan_results *scan_res,
778 struct wpa_ssid **selected_ssid)
779{
780 struct wpa_bss *selected = NULL;
781 int prio;
782
783 while (selected == NULL) {
784 for (prio = 0; prio < wpa_s->conf->num_prio; prio++) {
785 selected = wpa_supplicant_select_bss(
786 wpa_s, scan_res, wpa_s->conf->pssid[prio],
787 selected_ssid);
788 if (selected)
789 break;
790 }
791
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800792 if (selected == NULL && wpa_s->blacklist &&
793 !wpa_s->countermeasures) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700794 wpa_dbg(wpa_s, MSG_DEBUG, "No APs found - clear "
795 "blacklist and try again");
796 wpa_blacklist_clear(wpa_s);
797 wpa_s->blacklist_cleared++;
798 } else if (selected == NULL)
799 break;
800 }
801
802 return selected;
803}
804
805
806static void wpa_supplicant_req_new_scan(struct wpa_supplicant *wpa_s,
807 int timeout_sec, int timeout_usec)
808{
809 if (!wpa_supplicant_enabled_networks(wpa_s->conf)) {
810 /*
811 * No networks are enabled; short-circuit request so
812 * we don't wait timeout seconds before transitioning
813 * to INACTIVE state.
814 */
815 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
816 return;
817 }
818 wpa_supplicant_req_scan(wpa_s, timeout_sec, timeout_usec);
819}
820
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800821
Dmitry Shmidt44da0252011-08-23 12:30:30 -0700822int wpa_supplicant_connect(struct wpa_supplicant *wpa_s,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800823 struct wpa_bss *selected,
824 struct wpa_ssid *ssid)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700825{
826 if (wpas_wps_scan_pbc_overlap(wpa_s, selected, ssid)) {
827 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_OVERLAP
828 "PBC session overlap");
829#ifdef CONFIG_P2P
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800830 if (wpas_p2p_notif_pbc_overlap(wpa_s) == 1)
Dmitry Shmidt44da0252011-08-23 12:30:30 -0700831 return -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700832#endif /* CONFIG_P2P */
833
834#ifdef CONFIG_WPS
835 wpas_wps_cancel(wpa_s);
836#endif /* CONFIG_WPS */
Dmitry Shmidt44da0252011-08-23 12:30:30 -0700837 return -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700838 }
839
840 /*
841 * Do not trigger new association unless the BSSID has changed or if
842 * reassociation is requested. If we are in process of associating with
843 * the selected BSSID, do not trigger new attempt.
844 */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800845 if (wpa_s->reassociate ||
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700846 (os_memcmp(selected->bssid, wpa_s->bssid, ETH_ALEN) != 0 &&
847 ((wpa_s->wpa_state != WPA_ASSOCIATING &&
848 wpa_s->wpa_state != WPA_AUTHENTICATING) ||
849 os_memcmp(selected->bssid, wpa_s->pending_bssid, ETH_ALEN) !=
850 0))) {
851 if (wpa_supplicant_scard_init(wpa_s, ssid)) {
852 wpa_supplicant_req_new_scan(wpa_s, 10, 0);
Dmitry Shmidt44da0252011-08-23 12:30:30 -0700853 return 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700854 }
855 wpa_msg(wpa_s, MSG_DEBUG, "Request association: "
856 "reassociate: %d selected: "MACSTR " bssid: " MACSTR
857 " pending: " MACSTR " wpa_state: %s",
858 wpa_s->reassociate, MAC2STR(selected->bssid),
859 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
860 wpa_supplicant_state_txt(wpa_s->wpa_state));
861 wpa_supplicant_associate(wpa_s, selected, ssid);
862 } else {
863 wpa_dbg(wpa_s, MSG_DEBUG, "Already associated with the "
864 "selected AP");
865 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800866
Dmitry Shmidt44da0252011-08-23 12:30:30 -0700867 return 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700868}
869
870
871static struct wpa_ssid *
872wpa_supplicant_pick_new_network(struct wpa_supplicant *wpa_s)
873{
874 int prio;
875 struct wpa_ssid *ssid;
876
877 for (prio = 0; prio < wpa_s->conf->num_prio; prio++) {
878 for (ssid = wpa_s->conf->pssid[prio]; ssid; ssid = ssid->pnext)
879 {
880 if (ssid->disabled)
881 continue;
882 if (ssid->mode == IEEE80211_MODE_IBSS ||
883 ssid->mode == IEEE80211_MODE_AP)
884 return ssid;
885 }
886 }
887 return NULL;
888}
889
890
891/* TODO: move the rsn_preauth_scan_result*() to be called from notify.c based
892 * on BSS added and BSS changed events */
893static void wpa_supplicant_rsn_preauth_scan_results(
Jouni Malinen87fd2792011-05-16 18:35:42 +0300894 struct wpa_supplicant *wpa_s)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700895{
Jouni Malinen87fd2792011-05-16 18:35:42 +0300896 struct wpa_bss *bss;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700897
898 if (rsn_preauth_scan_results(wpa_s->wpa) < 0)
899 return;
900
Jouni Malinen87fd2792011-05-16 18:35:42 +0300901 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700902 const u8 *ssid, *rsn;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700903
Jouni Malinen87fd2792011-05-16 18:35:42 +0300904 ssid = wpa_bss_get_ie(bss, WLAN_EID_SSID);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700905 if (ssid == NULL)
906 continue;
907
Jouni Malinen87fd2792011-05-16 18:35:42 +0300908 rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700909 if (rsn == NULL)
910 continue;
911
Jouni Malinen87fd2792011-05-16 18:35:42 +0300912 rsn_preauth_scan_result(wpa_s->wpa, bss->bssid, ssid, rsn);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700913 }
914
915}
916
917
918static int wpa_supplicant_need_to_roam(struct wpa_supplicant *wpa_s,
919 struct wpa_bss *selected,
920 struct wpa_ssid *ssid,
921 struct wpa_scan_results *scan_res)
922{
923 size_t i;
924 struct wpa_scan_res *current_bss = NULL;
925 int min_diff;
926
927 if (wpa_s->reassociate)
928 return 1; /* explicit request to reassociate */
929 if (wpa_s->wpa_state < WPA_ASSOCIATED)
930 return 1; /* we are not associated; continue */
931 if (wpa_s->current_ssid == NULL)
932 return 1; /* unknown current SSID */
933 if (wpa_s->current_ssid != ssid)
934 return 1; /* different network block */
935
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800936 if (wpas_driver_bss_selection(wpa_s))
937 return 0; /* Driver-based roaming */
938
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700939 for (i = 0; i < scan_res->num; i++) {
940 struct wpa_scan_res *res = scan_res->res[i];
941 const u8 *ie;
942 if (os_memcmp(res->bssid, wpa_s->bssid, ETH_ALEN) != 0)
943 continue;
944
945 ie = wpa_scan_get_ie(res, WLAN_EID_SSID);
946 if (ie == NULL)
947 continue;
948 if (ie[1] != wpa_s->current_ssid->ssid_len ||
949 os_memcmp(ie + 2, wpa_s->current_ssid->ssid, ie[1]) != 0)
950 continue;
951 current_bss = res;
952 break;
953 }
954
955 if (!current_bss)
956 return 1; /* current BSS not seen in scan results */
957
Dmitry Shmidtefdec2e2011-08-16 11:55:46 -0700958#ifdef CONFIG_ROAMING
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700959 wpa_dbg(wpa_s, MSG_DEBUG, "Considering within-ESS reassociation");
960 wpa_dbg(wpa_s, MSG_DEBUG, "Current BSS: " MACSTR " level=%d",
961 MAC2STR(current_bss->bssid), current_bss->level);
962 wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS: " MACSTR " level=%d",
963 MAC2STR(selected->bssid), selected->level);
964
965 if (wpa_s->current_ssid->bssid_set &&
966 os_memcmp(selected->bssid, wpa_s->current_ssid->bssid, ETH_ALEN) ==
967 0) {
968 wpa_dbg(wpa_s, MSG_DEBUG, "Allow reassociation - selected BSS "
969 "has preferred BSSID");
970 return 1;
971 }
972
973 min_diff = 2;
974 if (current_bss->level < 0) {
975 if (current_bss->level < -85)
976 min_diff = 1;
977 else if (current_bss->level < -80)
978 min_diff = 2;
979 else if (current_bss->level < -75)
980 min_diff = 3;
981 else if (current_bss->level < -70)
982 min_diff = 4;
983 else
984 min_diff = 5;
985 }
986 if (abs(current_bss->level - selected->level) < min_diff) {
987 wpa_dbg(wpa_s, MSG_DEBUG, "Skip roam - too small difference "
988 "in signal level");
989 return 0;
990 }
991
992 return 1;
Dmitry Shmidtefdec2e2011-08-16 11:55:46 -0700993#else
994 return 0;
995#endif
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700996}
997
998/* Return < 0 if no scan results could be fetched. */
999static int _wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
1000 union wpa_event_data *data)
1001{
1002 struct wpa_bss *selected;
1003 struct wpa_ssid *ssid = NULL;
1004 struct wpa_scan_results *scan_res;
1005 int ap = 0;
1006
1007#ifdef CONFIG_AP
1008 if (wpa_s->ap_iface)
1009 ap = 1;
1010#endif /* CONFIG_AP */
1011
1012 wpa_supplicant_notify_scanning(wpa_s, 0);
1013
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001014#ifdef CONFIG_P2P
1015 if (wpa_s->p2p_cb_on_scan_complete && !wpa_s->global->p2p_disabled &&
1016 wpa_s->global->p2p != NULL) {
1017 wpa_s->p2p_cb_on_scan_complete = 0;
1018 if (p2p_other_scan_completed(wpa_s->global->p2p) == 1) {
1019 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Pending P2P operation "
1020 "stopped scan processing");
1021 return -1;
1022 }
1023 }
1024#endif /* CONFIG_P2P */
1025
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001026 scan_res = wpa_supplicant_get_scan_results(wpa_s,
1027 data ? &data->scan_info :
1028 NULL, 1);
1029 if (scan_res == NULL) {
1030 if (wpa_s->conf->ap_scan == 2 || ap)
1031 return -1;
1032 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to get scan results - try "
1033 "scanning again");
1034 wpa_supplicant_req_new_scan(wpa_s, 1, 0);
1035 return -1;
1036 }
1037
1038#ifndef CONFIG_NO_RANDOM_POOL
1039 size_t i, num;
1040 num = scan_res->num;
1041 if (num > 10)
1042 num = 10;
1043 for (i = 0; i < num; i++) {
1044 u8 buf[5];
1045 struct wpa_scan_res *res = scan_res->res[i];
1046 buf[0] = res->bssid[5];
1047 buf[1] = res->qual & 0xff;
1048 buf[2] = res->noise & 0xff;
1049 buf[3] = res->level & 0xff;
1050 buf[4] = res->tsf & 0xff;
1051 random_add_randomness(buf, sizeof(buf));
1052 }
1053#endif /* CONFIG_NO_RANDOM_POOL */
1054
1055 if (wpa_s->scan_res_handler) {
1056 void (*scan_res_handler)(struct wpa_supplicant *wpa_s,
1057 struct wpa_scan_results *scan_res);
1058
1059 scan_res_handler = wpa_s->scan_res_handler;
1060 wpa_s->scan_res_handler = NULL;
1061 scan_res_handler(wpa_s, scan_res);
1062
1063 wpa_scan_results_free(scan_res);
1064 return 0;
1065 }
1066
1067 if (ap) {
1068 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore scan results in AP mode");
1069#ifdef CONFIG_AP
1070 if (wpa_s->ap_iface->scan_cb)
1071 wpa_s->ap_iface->scan_cb(wpa_s->ap_iface);
1072#endif /* CONFIG_AP */
1073 wpa_scan_results_free(scan_res);
1074 return 0;
1075 }
1076
1077 wpa_dbg(wpa_s, MSG_DEBUG, "New scan results available");
1078 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS);
1079 wpas_notify_scan_results(wpa_s);
1080
1081 wpas_notify_scan_done(wpa_s, 1);
1082
1083 if ((wpa_s->conf->ap_scan == 2 && !wpas_wps_searching(wpa_s))) {
1084 wpa_scan_results_free(scan_res);
1085 return 0;
1086 }
1087
1088 if (wpa_s->disconnected) {
1089 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1090 wpa_scan_results_free(scan_res);
1091 return 0;
1092 }
1093
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001094 if (!wpas_driver_bss_selection(wpa_s) &&
1095 bgscan_notify_scan(wpa_s, scan_res) == 1) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001096 wpa_scan_results_free(scan_res);
1097 return 0;
1098 }
1099
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001100 selected = wpa_supplicant_pick_network(wpa_s, scan_res, &ssid);
1101
1102 if (selected) {
1103 int skip;
1104 skip = !wpa_supplicant_need_to_roam(wpa_s, selected, ssid,
1105 scan_res);
1106 wpa_scan_results_free(scan_res);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001107 if (skip) {
1108 wpa_supplicant_rsn_preauth_scan_results(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001109 return 0;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001110 }
1111
Dmitry Shmidt44da0252011-08-23 12:30:30 -07001112 if (wpa_supplicant_connect(wpa_s, selected, ssid) < 0) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001113 wpa_dbg(wpa_s, MSG_DEBUG, "Connect failed");
Dmitry Shmidt44da0252011-08-23 12:30:30 -07001114 return -1;
1115 }
Jouni Malinen87fd2792011-05-16 18:35:42 +03001116 wpa_supplicant_rsn_preauth_scan_results(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001117 } else {
1118 wpa_scan_results_free(scan_res);
1119 wpa_dbg(wpa_s, MSG_DEBUG, "No suitable network found");
1120 ssid = wpa_supplicant_pick_new_network(wpa_s);
1121 if (ssid) {
1122 wpa_dbg(wpa_s, MSG_DEBUG, "Setup a new network");
1123 wpa_supplicant_associate(wpa_s, NULL, ssid);
Jouni Malinen87fd2792011-05-16 18:35:42 +03001124 wpa_supplicant_rsn_preauth_scan_results(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001125 } else {
1126 int timeout_sec = wpa_s->scan_interval;
1127 int timeout_usec = 0;
1128#ifdef CONFIG_P2P
1129 if (wpa_s->p2p_in_provisioning) {
1130 /*
1131 * Use shorter wait during P2P Provisioning
1132 * state to speed up group formation.
1133 */
1134 timeout_sec = 0;
1135 timeout_usec = 250000;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001136 wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
1137 timeout_usec);
1138 return 0;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001139 }
1140#endif /* CONFIG_P2P */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001141 if (wpa_supplicant_req_sched_scan(wpa_s))
1142 wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
1143 timeout_usec);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001144 }
1145 }
1146 return 0;
1147}
1148
1149
1150static void wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
1151 union wpa_event_data *data)
1152{
1153 const char *rn, *rn2;
1154 struct wpa_supplicant *ifs;
1155
1156 if (_wpa_supplicant_event_scan_results(wpa_s, data) < 0) {
1157 /*
1158 * If no scan results could be fetched, then no need to
1159 * notify those interfaces that did not actually request
1160 * this scan.
1161 */
1162 return;
1163 }
1164
1165 /*
1166 * Check other interfaces to see if they have the same radio-name. If
1167 * so, they get updated with this same scan info.
1168 */
1169 if (!wpa_s->driver->get_radio_name)
1170 return;
1171
1172 rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
1173 if (rn == NULL || rn[0] == '\0')
1174 return;
1175
1176 wpa_dbg(wpa_s, MSG_DEBUG, "Checking for other virtual interfaces "
1177 "sharing same radio (%s) in event_scan_results", rn);
1178
1179 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
1180 if (ifs == wpa_s || !ifs->driver->get_radio_name)
1181 continue;
1182
1183 rn2 = ifs->driver->get_radio_name(ifs->drv_priv);
1184 if (rn2 && os_strcmp(rn, rn2) == 0) {
1185 wpa_printf(MSG_DEBUG, "%s: Updating scan results from "
1186 "sibling", ifs->ifname);
1187 _wpa_supplicant_event_scan_results(ifs, data);
1188 }
1189 }
1190}
1191
1192#endif /* CONFIG_NO_SCAN_PROCESSING */
1193
1194
1195static int wpa_supplicant_event_associnfo(struct wpa_supplicant *wpa_s,
1196 union wpa_event_data *data)
1197{
1198 int l, len, found = 0, wpa_found, rsn_found;
1199 const u8 *p;
1200
1201 wpa_dbg(wpa_s, MSG_DEBUG, "Association info event");
1202 if (data->assoc_info.req_ies)
1203 wpa_hexdump(MSG_DEBUG, "req_ies", data->assoc_info.req_ies,
1204 data->assoc_info.req_ies_len);
1205 if (data->assoc_info.resp_ies) {
1206 wpa_hexdump(MSG_DEBUG, "resp_ies", data->assoc_info.resp_ies,
1207 data->assoc_info.resp_ies_len);
1208#ifdef CONFIG_TDLS
1209 wpa_tdls_assoc_resp_ies(wpa_s->wpa, data->assoc_info.resp_ies,
1210 data->assoc_info.resp_ies_len);
1211#endif /* CONFIG_TDLS */
1212 }
1213 if (data->assoc_info.beacon_ies)
1214 wpa_hexdump(MSG_DEBUG, "beacon_ies",
1215 data->assoc_info.beacon_ies,
1216 data->assoc_info.beacon_ies_len);
1217 if (data->assoc_info.freq)
1218 wpa_dbg(wpa_s, MSG_DEBUG, "freq=%u MHz",
1219 data->assoc_info.freq);
1220
1221 p = data->assoc_info.req_ies;
1222 l = data->assoc_info.req_ies_len;
1223
1224 /* Go through the IEs and make a copy of the WPA/RSN IE, if present. */
1225 while (p && l >= 2) {
1226 len = p[1] + 2;
1227 if (len > l) {
1228 wpa_hexdump(MSG_DEBUG, "Truncated IE in assoc_info",
1229 p, l);
1230 break;
1231 }
1232 if ((p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 6 &&
1233 (os_memcmp(&p[2], "\x00\x50\xF2\x01\x01\x00", 6) == 0)) ||
1234 (p[0] == WLAN_EID_RSN && p[1] >= 2)) {
1235 if (wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, p, len))
1236 break;
1237 found = 1;
1238 wpa_find_assoc_pmkid(wpa_s);
1239 break;
1240 }
1241 l -= len;
1242 p += len;
1243 }
1244 if (!found && data->assoc_info.req_ies)
1245 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
1246
1247#ifdef CONFIG_IEEE80211R
1248#ifdef CONFIG_SME
1249 if (wpa_s->sme.auth_alg == WPA_AUTH_ALG_FT) {
1250 u8 bssid[ETH_ALEN];
1251 if (wpa_drv_get_bssid(wpa_s, bssid) < 0 ||
1252 wpa_ft_validate_reassoc_resp(wpa_s->wpa,
1253 data->assoc_info.resp_ies,
1254 data->assoc_info.resp_ies_len,
1255 bssid) < 0) {
1256 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of "
1257 "Reassociation Response failed");
1258 wpa_supplicant_deauthenticate(
1259 wpa_s, WLAN_REASON_INVALID_IE);
1260 return -1;
1261 }
1262 }
1263
1264 p = data->assoc_info.resp_ies;
1265 l = data->assoc_info.resp_ies_len;
1266
1267#ifdef CONFIG_WPS_STRICT
1268 if (p && wpa_s->current_ssid &&
1269 wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_WPS) {
1270 struct wpabuf *wps;
1271 wps = ieee802_11_vendor_ie_concat(p, l, WPS_IE_VENDOR_TYPE);
1272 if (wps == NULL) {
1273 wpa_msg(wpa_s, MSG_INFO, "WPS-STRICT: AP did not "
1274 "include WPS IE in (Re)Association Response");
1275 return -1;
1276 }
1277
1278 if (wps_validate_assoc_resp(wps) < 0) {
1279 wpabuf_free(wps);
1280 wpa_supplicant_deauthenticate(
1281 wpa_s, WLAN_REASON_INVALID_IE);
1282 return -1;
1283 }
1284 wpabuf_free(wps);
1285 }
1286#endif /* CONFIG_WPS_STRICT */
1287
1288 /* Go through the IEs and make a copy of the MDIE, if present. */
1289 while (p && l >= 2) {
1290 len = p[1] + 2;
1291 if (len > l) {
1292 wpa_hexdump(MSG_DEBUG, "Truncated IE in assoc_info",
1293 p, l);
1294 break;
1295 }
1296 if (p[0] == WLAN_EID_MOBILITY_DOMAIN &&
1297 p[1] >= MOBILITY_DOMAIN_ID_LEN) {
1298 wpa_s->sme.ft_used = 1;
1299 os_memcpy(wpa_s->sme.mobility_domain, p + 2,
1300 MOBILITY_DOMAIN_ID_LEN);
1301 break;
1302 }
1303 l -= len;
1304 p += len;
1305 }
1306#endif /* CONFIG_SME */
1307
1308 wpa_sm_set_ft_params(wpa_s->wpa, data->assoc_info.resp_ies,
1309 data->assoc_info.resp_ies_len);
1310#endif /* CONFIG_IEEE80211R */
1311
1312 /* WPA/RSN IE from Beacon/ProbeResp */
1313 p = data->assoc_info.beacon_ies;
1314 l = data->assoc_info.beacon_ies_len;
1315
1316 /* Go through the IEs and make a copy of the WPA/RSN IEs, if present.
1317 */
1318 wpa_found = rsn_found = 0;
1319 while (p && l >= 2) {
1320 len = p[1] + 2;
1321 if (len > l) {
1322 wpa_hexdump(MSG_DEBUG, "Truncated IE in beacon_ies",
1323 p, l);
1324 break;
1325 }
1326 if (!wpa_found &&
1327 p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 6 &&
1328 os_memcmp(&p[2], "\x00\x50\xF2\x01\x01\x00", 6) == 0) {
1329 wpa_found = 1;
1330 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, p, len);
1331 }
1332
1333 if (!rsn_found &&
1334 p[0] == WLAN_EID_RSN && p[1] >= 2) {
1335 rsn_found = 1;
1336 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, p, len);
1337 }
1338
1339 l -= len;
1340 p += len;
1341 }
1342
1343 if (!wpa_found && data->assoc_info.beacon_ies)
1344 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
1345 if (!rsn_found && data->assoc_info.beacon_ies)
1346 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
1347 if (wpa_found || rsn_found)
1348 wpa_s->ap_ies_from_associnfo = 1;
1349
Jouni Malinen87fd2792011-05-16 18:35:42 +03001350 if (wpa_s->assoc_freq && data->assoc_info.freq &&
1351 wpa_s->assoc_freq != data->assoc_info.freq) {
1352 wpa_printf(MSG_DEBUG, "Operating frequency changed from "
1353 "%u to %u MHz",
1354 wpa_s->assoc_freq, data->assoc_info.freq);
1355 wpa_supplicant_update_scan_results(wpa_s);
1356 }
1357
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001358 wpa_s->assoc_freq = data->assoc_info.freq;
1359
1360 return 0;
1361}
1362
1363
1364static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
1365 union wpa_event_data *data)
1366{
1367 u8 bssid[ETH_ALEN];
1368 int ft_completed;
1369 int bssid_changed;
1370 struct wpa_driver_capa capa;
1371
1372#ifdef CONFIG_AP
1373 if (wpa_s->ap_iface) {
1374 hostapd_notif_assoc(wpa_s->ap_iface->bss[0],
1375 data->assoc_info.addr,
1376 data->assoc_info.req_ies,
1377 data->assoc_info.req_ies_len,
1378 data->assoc_info.reassoc);
1379 return;
1380 }
1381#endif /* CONFIG_AP */
1382
1383 ft_completed = wpa_ft_is_completed(wpa_s->wpa);
1384 if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0)
1385 return;
1386
1387 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001388 if (wpa_drv_get_bssid(wpa_s, bssid) >= 0 &&
1389 os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001390 wpa_dbg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
1391 MACSTR, MAC2STR(bssid));
1392 random_add_randomness(bssid, ETH_ALEN);
1393 bssid_changed = os_memcmp(wpa_s->bssid, bssid, ETH_ALEN);
1394 os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
1395 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
1396 if (bssid_changed)
1397 wpas_notify_bssid_changed(wpa_s);
1398
1399 if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
1400 wpa_clear_keys(wpa_s, bssid);
1401 }
1402 if (wpa_supplicant_select_config(wpa_s) < 0) {
1403 wpa_supplicant_disassociate(
1404 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1405 return;
1406 }
1407 if (wpa_s->current_ssid) {
1408 struct wpa_bss *bss = NULL;
1409 struct wpa_ssid *ssid = wpa_s->current_ssid;
1410 if (ssid->ssid_len > 0)
1411 bss = wpa_bss_get(wpa_s, bssid,
1412 ssid->ssid, ssid->ssid_len);
1413 if (!bss)
1414 bss = wpa_bss_get_bssid(wpa_s, bssid);
1415 if (bss)
1416 wpa_s->current_bss = bss;
1417 }
1418 }
1419
1420#ifdef CONFIG_SME
1421 os_memcpy(wpa_s->sme.prev_bssid, bssid, ETH_ALEN);
1422 wpa_s->sme.prev_bssid_set = 1;
1423#endif /* CONFIG_SME */
1424
1425 wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
1426 if (wpa_s->current_ssid) {
1427 /* When using scanning (ap_scan=1), SIM PC/SC interface can be
1428 * initialized before association, but for other modes,
1429 * initialize PC/SC here, if the current configuration needs
1430 * smartcard or SIM/USIM. */
1431 wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
1432 }
1433 wpa_sm_notify_assoc(wpa_s->wpa, bssid);
1434 if (wpa_s->l2)
1435 l2_packet_notify_auth_start(wpa_s->l2);
1436
1437 /*
1438 * Set portEnabled first to FALSE in order to get EAP state machine out
1439 * of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE
1440 * state machine may transit to AUTHENTICATING state based on obsolete
1441 * eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to
1442 * AUTHENTICATED without ever giving chance to EAP state machine to
1443 * reset the state.
1444 */
1445 if (!ft_completed) {
1446 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
1447 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
1448 }
1449 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || ft_completed)
1450 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
1451 /* 802.1X::portControl = Auto */
1452 eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE);
1453 wpa_s->eapol_received = 0;
1454 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1455 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE ||
1456 (wpa_s->current_ssid &&
1457 wpa_s->current_ssid->mode == IEEE80211_MODE_IBSS)) {
1458 wpa_supplicant_cancel_auth_timeout(wpa_s);
1459 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1460 } else if (!ft_completed) {
1461 /* Timeout for receiving the first EAPOL packet */
1462 wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
1463 }
1464 wpa_supplicant_cancel_scan(wpa_s);
1465
1466 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1467 wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
1468 /*
1469 * We are done; the driver will take care of RSN 4-way
1470 * handshake.
1471 */
1472 wpa_supplicant_cancel_auth_timeout(wpa_s);
1473 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1474 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1475 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
1476 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
1477 wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
1478 /*
1479 * The driver will take care of RSN 4-way handshake, so we need
1480 * to allow EAPOL supplicant to complete its work without
1481 * waiting for WPA supplicant.
1482 */
1483 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1484 } else if (ft_completed) {
1485 /*
1486 * FT protocol completed - make sure EAPOL state machine ends
1487 * up in authenticated.
1488 */
1489 wpa_supplicant_cancel_auth_timeout(wpa_s);
1490 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
1491 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
1492 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
1493 }
1494
1495 if (wpa_s->pending_eapol_rx) {
1496 struct os_time now, age;
1497 os_get_time(&now);
1498 os_time_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
1499 if (age.sec == 0 && age.usec < 100000 &&
1500 os_memcmp(wpa_s->pending_eapol_rx_src, bssid, ETH_ALEN) ==
1501 0) {
1502 wpa_dbg(wpa_s, MSG_DEBUG, "Process pending EAPOL "
1503 "frame that was received just before "
1504 "association notification");
1505 wpa_supplicant_rx_eapol(
1506 wpa_s, wpa_s->pending_eapol_rx_src,
1507 wpabuf_head(wpa_s->pending_eapol_rx),
1508 wpabuf_len(wpa_s->pending_eapol_rx));
1509 }
1510 wpabuf_free(wpa_s->pending_eapol_rx);
1511 wpa_s->pending_eapol_rx = NULL;
1512 }
1513
1514 if ((wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
1515 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
1516 wpa_s->current_ssid && wpa_drv_get_capa(wpa_s, &capa) == 0 &&
1517 capa.flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE) {
1518 /* Set static WEP keys again */
1519 wpa_set_wep_keys(wpa_s, wpa_s->current_ssid);
1520 }
1521
1522#ifdef CONFIG_IBSS_RSN
1523 if (wpa_s->current_ssid &&
1524 wpa_s->current_ssid->mode == WPAS_MODE_IBSS &&
1525 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
1526 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE &&
1527 wpa_s->ibss_rsn == NULL) {
1528 wpa_s->ibss_rsn = ibss_rsn_init(wpa_s);
1529 if (!wpa_s->ibss_rsn) {
1530 wpa_msg(wpa_s, MSG_INFO, "Failed to init IBSS RSN");
1531 wpa_supplicant_deauthenticate(
1532 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
1533 return;
1534 }
1535
1536 ibss_rsn_set_psk(wpa_s->ibss_rsn, wpa_s->current_ssid->psk);
1537 }
1538#endif /* CONFIG_IBSS_RSN */
1539}
1540
1541
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001542static int disconnect_reason_recoverable(u16 reason_code)
1543{
1544 return reason_code == WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY ||
1545 reason_code == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA ||
1546 reason_code == WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA;
1547}
1548
1549
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001550static void wpa_supplicant_event_disassoc(struct wpa_supplicant *wpa_s,
1551 u16 reason_code)
1552{
1553 const u8 *bssid;
1554 int authenticating;
1555 u8 prev_pending_bssid[ETH_ALEN];
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001556 struct wpa_bss *fast_reconnect = NULL;
1557 struct wpa_ssid *fast_reconnect_ssid = NULL;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001558
1559 authenticating = wpa_s->wpa_state == WPA_AUTHENTICATING;
1560 os_memcpy(prev_pending_bssid, wpa_s->pending_bssid, ETH_ALEN);
1561
1562 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
1563 /*
1564 * At least Host AP driver and a Prism3 card seemed to be
1565 * generating streams of disconnected events when configuring
1566 * IBSS for WPA-None. Ignore them for now.
1567 */
1568 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - ignore in "
1569 "IBSS/WPA-None mode");
1570 return;
1571 }
1572
1573 if (wpa_s->wpa_state == WPA_4WAY_HANDSHAKE &&
1574 wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
1575 wpa_msg(wpa_s, MSG_INFO, "WPA: 4-Way Handshake failed - "
1576 "pre-shared key may be incorrect");
1577 }
1578 if (!wpa_s->auto_reconnect_disabled ||
1579 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001580 wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect enabled: try to "
1581 "reconnect (wps=%d wpa_state=%d)",
1582 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS,
1583 wpa_s->wpa_state);
1584 if (wpa_s->wpa_state == WPA_COMPLETED &&
1585 wpa_s->current_ssid &&
1586 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
1587 disconnect_reason_recoverable(reason_code)) {
1588 /*
1589 * It looks like the AP has dropped association with
1590 * us, but could allow us to get back in. Try to
1591 * reconnect to the same BSS without full scan to save
1592 * time for some common cases.
1593 */
1594 fast_reconnect = wpa_s->current_bss;
1595 fast_reconnect_ssid = wpa_s->current_ssid;
1596 } else if (wpa_s->wpa_state >= WPA_ASSOCIATING)
Dmitry Shmidt43007fd2011-04-11 15:58:40 -07001597 wpa_supplicant_req_scan(wpa_s, 0, 500000);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001598 else
1599 wpa_dbg(wpa_s, MSG_DEBUG, "Do not request new "
1600 "immediate scan");
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001601 } else {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001602 wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect disabled: do not "
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001603 "try to re-connect");
1604 wpa_s->reassociate = 0;
1605 wpa_s->disconnected = 1;
1606 }
1607 bssid = wpa_s->bssid;
1608 if (is_zero_ether_addr(bssid))
1609 bssid = wpa_s->pending_bssid;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001610 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
1611 wpas_connection_failed(wpa_s, bssid);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001612 wpa_sm_notify_disassoc(wpa_s->wpa);
1613 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_DISCONNECTED "bssid=" MACSTR
1614 " reason=%d",
1615 MAC2STR(bssid), reason_code);
1616 if (wpa_supplicant_dynamic_keys(wpa_s)) {
1617 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - remove keys");
1618 wpa_s->keys_cleared = 0;
1619 wpa_clear_keys(wpa_s, wpa_s->bssid);
1620 }
1621 wpa_supplicant_mark_disassoc(wpa_s);
1622
1623 if (authenticating && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
1624 sme_disassoc_while_authenticating(wpa_s, prev_pending_bssid);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001625
1626 if (fast_reconnect) {
1627#ifndef CONFIG_NO_SCAN_PROCESSING
1628 wpa_dbg(wpa_s, MSG_DEBUG, "Try to reconnect to the same BSS");
1629 if (wpa_supplicant_connect(wpa_s, fast_reconnect,
1630 fast_reconnect_ssid) < 0) {
1631 /* Recover through full scan */
1632 wpa_supplicant_req_scan(wpa_s, 0, 100000);
1633 }
1634#endif /* CONFIG_NO_SCAN_PROCESSING */
1635 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001636}
1637
1638
1639#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001640void wpa_supplicant_delayed_mic_error_report(void *eloop_ctx, void *sock_ctx)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001641{
1642 struct wpa_supplicant *wpa_s = eloop_ctx;
1643
1644 if (!wpa_s->pending_mic_error_report)
1645 return;
1646
1647 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Sending pending MIC error report");
1648 wpa_sm_key_request(wpa_s->wpa, 1, wpa_s->pending_mic_error_pairwise);
1649 wpa_s->pending_mic_error_report = 0;
1650}
1651#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
1652
1653
1654static void
1655wpa_supplicant_event_michael_mic_failure(struct wpa_supplicant *wpa_s,
1656 union wpa_event_data *data)
1657{
1658 int pairwise;
1659 struct os_time t;
1660
1661 wpa_msg(wpa_s, MSG_WARNING, "Michael MIC failure detected");
1662 pairwise = (data && data->michael_mic_failure.unicast);
1663 os_get_time(&t);
1664 if ((wpa_s->last_michael_mic_error &&
1665 t.sec - wpa_s->last_michael_mic_error <= 60) ||
1666 wpa_s->pending_mic_error_report) {
1667 if (wpa_s->pending_mic_error_report) {
1668 /*
1669 * Send the pending MIC error report immediately since
1670 * we are going to start countermeasures and AP better
1671 * do the same.
1672 */
1673 wpa_sm_key_request(wpa_s->wpa, 1,
1674 wpa_s->pending_mic_error_pairwise);
1675 }
1676
1677 /* Send the new MIC error report immediately since we are going
1678 * to start countermeasures and AP better do the same.
1679 */
1680 wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
1681
1682 /* initialize countermeasures */
1683 wpa_s->countermeasures = 1;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001684
1685 wpa_blacklist_add(wpa_s, wpa_s->bssid);
1686
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001687 wpa_msg(wpa_s, MSG_WARNING, "TKIP countermeasures started");
1688
1689 /*
1690 * Need to wait for completion of request frame. We do not get
1691 * any callback for the message completion, so just wait a
1692 * short while and hope for the best. */
1693 os_sleep(0, 10000);
1694
1695 wpa_drv_set_countermeasures(wpa_s, 1);
1696 wpa_supplicant_deauthenticate(wpa_s,
1697 WLAN_REASON_MICHAEL_MIC_FAILURE);
1698 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures,
1699 wpa_s, NULL);
1700 eloop_register_timeout(60, 0,
1701 wpa_supplicant_stop_countermeasures,
1702 wpa_s, NULL);
1703 /* TODO: mark the AP rejected for 60 second. STA is
1704 * allowed to associate with another AP.. */
1705 } else {
1706#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
1707 if (wpa_s->mic_errors_seen) {
1708 /*
1709 * Reduce the effectiveness of Michael MIC error
1710 * reports as a means for attacking against TKIP if
1711 * more than one MIC failure is noticed with the same
1712 * PTK. We delay the transmission of the reports by a
1713 * random time between 0 and 60 seconds in order to
1714 * force the attacker wait 60 seconds before getting
1715 * the information on whether a frame resulted in a MIC
1716 * failure.
1717 */
1718 u8 rval[4];
1719 int sec;
1720
1721 if (os_get_random(rval, sizeof(rval)) < 0)
1722 sec = os_random() % 60;
1723 else
1724 sec = WPA_GET_BE32(rval) % 60;
1725 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Delay MIC error "
1726 "report %d seconds", sec);
1727 wpa_s->pending_mic_error_report = 1;
1728 wpa_s->pending_mic_error_pairwise = pairwise;
1729 eloop_cancel_timeout(
1730 wpa_supplicant_delayed_mic_error_report,
1731 wpa_s, NULL);
1732 eloop_register_timeout(
1733 sec, os_random() % 1000000,
1734 wpa_supplicant_delayed_mic_error_report,
1735 wpa_s, NULL);
1736 } else {
1737 wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
1738 }
1739#else /* CONFIG_DELAYED_MIC_ERROR_REPORT */
1740 wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
1741#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
1742 }
1743 wpa_s->last_michael_mic_error = t.sec;
1744 wpa_s->mic_errors_seen++;
1745}
1746
1747
1748#ifdef CONFIG_TERMINATE_ONLASTIF
1749static int any_interfaces(struct wpa_supplicant *head)
1750{
1751 struct wpa_supplicant *wpa_s;
1752
1753 for (wpa_s = head; wpa_s != NULL; wpa_s = wpa_s->next)
1754 if (!wpa_s->interface_removed)
1755 return 1;
1756 return 0;
1757}
1758#endif /* CONFIG_TERMINATE_ONLASTIF */
1759
1760
1761static void
1762wpa_supplicant_event_interface_status(struct wpa_supplicant *wpa_s,
1763 union wpa_event_data *data)
1764{
1765 if (os_strcmp(wpa_s->ifname, data->interface_status.ifname) != 0)
1766 return;
1767
1768 switch (data->interface_status.ievent) {
1769 case EVENT_INTERFACE_ADDED:
1770 if (!wpa_s->interface_removed)
1771 break;
1772 wpa_s->interface_removed = 0;
1773 wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was added");
1774 if (wpa_supplicant_driver_init(wpa_s) < 0) {
1775 wpa_msg(wpa_s, MSG_INFO, "Failed to initialize the "
1776 "driver after interface was added");
1777 }
1778 break;
1779 case EVENT_INTERFACE_REMOVED:
1780 wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was removed");
1781 wpa_s->interface_removed = 1;
1782 wpa_supplicant_mark_disassoc(wpa_s);
1783 l2_packet_deinit(wpa_s->l2);
1784 wpa_s->l2 = NULL;
1785#ifdef CONFIG_IBSS_RSN
1786 ibss_rsn_deinit(wpa_s->ibss_rsn);
1787 wpa_s->ibss_rsn = NULL;
1788#endif /* CONFIG_IBSS_RSN */
1789#ifdef CONFIG_TERMINATE_ONLASTIF
1790 /* check if last interface */
1791 if (!any_interfaces(wpa_s->global->ifaces))
1792 eloop_terminate();
1793#endif /* CONFIG_TERMINATE_ONLASTIF */
1794 break;
1795 }
1796}
1797
1798
1799#ifdef CONFIG_PEERKEY
1800static void
1801wpa_supplicant_event_stkstart(struct wpa_supplicant *wpa_s,
1802 union wpa_event_data *data)
1803{
1804 if (data == NULL)
1805 return;
1806 wpa_sm_stkstart(wpa_s->wpa, data->stkstart.peer);
1807}
1808#endif /* CONFIG_PEERKEY */
1809
1810
1811#ifdef CONFIG_TDLS
1812static void wpa_supplicant_event_tdls(struct wpa_supplicant *wpa_s,
1813 union wpa_event_data *data)
1814{
1815 if (data == NULL)
1816 return;
1817 switch (data->tdls.oper) {
1818 case TDLS_REQUEST_SETUP:
1819 wpa_tdls_start(wpa_s->wpa, data->tdls.peer);
1820 break;
1821 case TDLS_REQUEST_TEARDOWN:
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001822 wpa_tdls_send_teardown(wpa_s->wpa, data->tdls.peer,
1823 data->tdls.reason_code);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001824 break;
1825 }
1826}
1827#endif /* CONFIG_TDLS */
1828
1829
1830#ifdef CONFIG_IEEE80211R
1831static void
1832wpa_supplicant_event_ft_response(struct wpa_supplicant *wpa_s,
1833 union wpa_event_data *data)
1834{
1835 if (data == NULL)
1836 return;
1837
1838 if (wpa_ft_process_response(wpa_s->wpa, data->ft_ies.ies,
1839 data->ft_ies.ies_len,
1840 data->ft_ies.ft_action,
1841 data->ft_ies.target_ap,
1842 data->ft_ies.ric_ies,
1843 data->ft_ies.ric_ies_len) < 0) {
1844 /* TODO: prevent MLME/driver from trying to associate? */
1845 }
1846}
1847#endif /* CONFIG_IEEE80211R */
1848
1849
1850#ifdef CONFIG_IBSS_RSN
1851static void wpa_supplicant_event_ibss_rsn_start(struct wpa_supplicant *wpa_s,
1852 union wpa_event_data *data)
1853{
1854 struct wpa_ssid *ssid;
1855 if (wpa_s->wpa_state < WPA_ASSOCIATED)
1856 return;
1857 if (data == NULL)
1858 return;
1859 ssid = wpa_s->current_ssid;
1860 if (ssid == NULL)
1861 return;
1862 if (ssid->mode != WPAS_MODE_IBSS || !wpa_key_mgmt_wpa(ssid->key_mgmt))
1863 return;
1864
1865 ibss_rsn_start(wpa_s->ibss_rsn, data->ibss_rsn_start.peer);
1866}
1867#endif /* CONFIG_IBSS_RSN */
1868
1869
1870#ifdef CONFIG_IEEE80211R
1871static void ft_rx_action(struct wpa_supplicant *wpa_s, const u8 *data,
1872 size_t len)
1873{
1874 const u8 *sta_addr, *target_ap_addr;
1875 u16 status;
1876
1877 wpa_hexdump(MSG_MSGDUMP, "FT: RX Action", data, len);
1878 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
1879 return; /* only SME case supported for now */
1880 if (len < 1 + 2 * ETH_ALEN + 2)
1881 return;
1882 if (data[0] != 2)
1883 return; /* Only FT Action Response is supported for now */
1884 sta_addr = data + 1;
1885 target_ap_addr = data + 1 + ETH_ALEN;
1886 status = WPA_GET_LE16(data + 1 + 2 * ETH_ALEN);
1887 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Received FT Action Response: STA "
1888 MACSTR " TargetAP " MACSTR " status %u",
1889 MAC2STR(sta_addr), MAC2STR(target_ap_addr), status);
1890
1891 if (os_memcmp(sta_addr, wpa_s->own_addr, ETH_ALEN) != 0) {
1892 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Foreign STA Address " MACSTR
1893 " in FT Action Response", MAC2STR(sta_addr));
1894 return;
1895 }
1896
1897 if (status) {
1898 wpa_dbg(wpa_s, MSG_DEBUG, "FT: FT Action Response indicates "
1899 "failure (status code %d)", status);
1900 /* TODO: report error to FT code(?) */
1901 return;
1902 }
1903
1904 if (wpa_ft_process_response(wpa_s->wpa, data + 1 + 2 * ETH_ALEN + 2,
1905 len - (1 + 2 * ETH_ALEN + 2), 1,
1906 target_ap_addr, NULL, 0) < 0)
1907 return;
1908
1909#ifdef CONFIG_SME
1910 {
1911 struct wpa_bss *bss;
1912 bss = wpa_bss_get_bssid(wpa_s, target_ap_addr);
1913 if (bss)
1914 wpa_s->sme.freq = bss->freq;
1915 wpa_s->sme.auth_alg = WPA_AUTH_ALG_FT;
1916 sme_associate(wpa_s, WPAS_MODE_INFRA, target_ap_addr,
1917 WLAN_AUTH_FT);
1918 }
1919#endif /* CONFIG_SME */
1920}
1921#endif /* CONFIG_IEEE80211R */
1922
1923
1924static void wpa_supplicant_event_unprot_deauth(struct wpa_supplicant *wpa_s,
1925 struct unprot_deauth *e)
1926{
1927#ifdef CONFIG_IEEE80211W
1928 wpa_printf(MSG_DEBUG, "Unprotected Deauthentication frame "
1929 "dropped: " MACSTR " -> " MACSTR
1930 " (reason code %u)",
1931 MAC2STR(e->sa), MAC2STR(e->da), e->reason_code);
1932 sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code);
1933#endif /* CONFIG_IEEE80211W */
1934}
1935
1936
1937static void wpa_supplicant_event_unprot_disassoc(struct wpa_supplicant *wpa_s,
1938 struct unprot_disassoc *e)
1939{
1940#ifdef CONFIG_IEEE80211W
1941 wpa_printf(MSG_DEBUG, "Unprotected Disassociation frame "
1942 "dropped: " MACSTR " -> " MACSTR
1943 " (reason code %u)",
1944 MAC2STR(e->sa), MAC2STR(e->da), e->reason_code);
1945 sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code);
1946#endif /* CONFIG_IEEE80211W */
1947}
1948
1949
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001950static void wnm_action_rx(struct wpa_supplicant *wpa_s, struct rx_action *rx)
1951{
1952 u8 action, mode;
1953 const u8 *pos, *end;
1954
1955 if (rx->data == NULL || rx->len == 0)
1956 return;
1957
1958 pos = rx->data;
1959 end = pos + rx->len;
1960 action = *pos++;
1961
1962 wpa_printf(MSG_DEBUG, "WNM: RX action %u from " MACSTR,
1963 action, MAC2STR(rx->sa));
1964 switch (action) {
1965 case WNM_BSS_TRANS_MGMT_REQ:
1966 if (pos + 5 > end)
1967 break;
1968 wpa_printf(MSG_DEBUG, "WNM: BSS Transition Management "
1969 "Request: dialog_token=%u request_mode=0x%x "
1970 "disassoc_timer=%u validity_interval=%u",
1971 pos[0], pos[1], WPA_GET_LE16(pos + 2), pos[4]);
1972 mode = pos[1];
1973 pos += 5;
1974 if (mode & 0x08)
1975 pos += 12; /* BSS Termination Duration */
1976 if (mode & 0x10) {
1977 char url[256];
1978 if (pos + 1 > end || pos + 1 + pos[0] > end) {
1979 wpa_printf(MSG_DEBUG, "WNM: Invalid BSS "
1980 "Transition Management Request "
1981 "(URL)");
1982 break;
1983 }
1984 os_memcpy(url, pos + 1, pos[0]);
1985 url[pos[0]] = '\0';
1986 wpa_msg(wpa_s, MSG_INFO, "WNM: ESS Disassociation "
1987 "Imminent - session_info_url=%s", url);
1988 }
1989 break;
1990 }
1991}
1992
1993
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001994void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
1995 union wpa_event_data *data)
1996{
1997 struct wpa_supplicant *wpa_s = ctx;
1998 u16 reason_code = 0;
1999
2000 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED &&
2001 event != EVENT_INTERFACE_ENABLED &&
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002002 event != EVENT_INTERFACE_STATUS &&
2003 event != EVENT_SCHED_SCAN_STOPPED) {
2004 wpa_dbg(wpa_s, MSG_DEBUG,
2005 "Ignore event %s (%d) while interface is disabled",
2006 event_to_string(event), event);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002007 return;
2008 }
2009
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002010#ifndef CONFIG_NO_STDOUT_DEBUG
2011{
2012 int level = MSG_DEBUG;
2013
2014 if (event == EVENT_RX_MGMT && data && data->rx_mgmt.frame &&
2015 data->rx_mgmt.frame_len >= 24) {
2016 const struct ieee80211_hdr *hdr;
2017 u16 fc;
2018 hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame;
2019 fc = le_to_host16(hdr->frame_control);
2020 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
2021 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON)
2022 level = MSG_EXCESSIVE;
2023 }
2024
2025 wpa_dbg(wpa_s, level, "Event %s (%d) received",
2026 event_to_string(event), event);
2027}
2028#endif /* CONFIG_NO_STDOUT_DEBUG */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002029
2030 switch (event) {
2031 case EVENT_AUTH:
2032 sme_event_auth(wpa_s, data);
2033 break;
2034 case EVENT_ASSOC:
2035 wpa_supplicant_event_assoc(wpa_s, data);
2036 break;
2037 case EVENT_DISASSOC:
2038 wpa_dbg(wpa_s, MSG_DEBUG, "Disassociation notification");
2039 if (data) {
2040 wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u",
2041 data->disassoc_info.reason_code);
2042 if (data->disassoc_info.addr)
2043 wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR,
2044 MAC2STR(data->disassoc_info.addr));
2045 }
2046#ifdef CONFIG_AP
2047 if (wpa_s->ap_iface && data && data->disassoc_info.addr) {
2048 hostapd_notif_disassoc(wpa_s->ap_iface->bss[0],
2049 data->disassoc_info.addr);
2050 break;
2051 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002052 if (wpa_s->ap_iface) {
2053 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore disassoc event in "
2054 "AP mode");
2055 break;
2056 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002057#endif /* CONFIG_AP */
2058 if (data) {
2059 reason_code = data->disassoc_info.reason_code;
2060 wpa_hexdump(MSG_DEBUG, "Disassociation frame IE(s)",
2061 data->disassoc_info.ie,
2062 data->disassoc_info.ie_len);
2063#ifdef CONFIG_P2P
2064 wpas_p2p_disassoc_notif(
2065 wpa_s, data->disassoc_info.addr, reason_code,
2066 data->disassoc_info.ie,
2067 data->disassoc_info.ie_len);
2068#endif /* CONFIG_P2P */
2069 }
2070 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
2071 sme_event_disassoc(wpa_s, data);
2072 /* fall through */
2073 case EVENT_DEAUTH:
2074 if (event == EVENT_DEAUTH) {
2075 wpa_dbg(wpa_s, MSG_DEBUG,
2076 "Deauthentication notification");
2077 if (data) {
2078 reason_code = data->deauth_info.reason_code;
2079 wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u",
2080 data->deauth_info.reason_code);
2081 if (data->deauth_info.addr) {
2082 wpa_dbg(wpa_s, MSG_DEBUG, " * address "
2083 MACSTR,
2084 MAC2STR(data->deauth_info.
2085 addr));
2086 }
2087 wpa_hexdump(MSG_DEBUG,
2088 "Deauthentication frame IE(s)",
2089 data->deauth_info.ie,
2090 data->deauth_info.ie_len);
2091#ifdef CONFIG_P2P
2092 wpas_p2p_deauth_notif(
2093 wpa_s, data->deauth_info.addr,
2094 reason_code,
2095 data->deauth_info.ie,
2096 data->deauth_info.ie_len);
2097#endif /* CONFIG_P2P */
2098 }
2099 }
2100#ifdef CONFIG_AP
2101 if (wpa_s->ap_iface && data && data->deauth_info.addr) {
2102 hostapd_notif_disassoc(wpa_s->ap_iface->bss[0],
2103 data->deauth_info.addr);
2104 break;
2105 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002106 if (wpa_s->ap_iface) {
2107 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore deauth event in "
2108 "AP mode");
2109 break;
2110 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002111#endif /* CONFIG_AP */
2112 wpa_supplicant_event_disassoc(wpa_s, reason_code);
2113 break;
2114 case EVENT_MICHAEL_MIC_FAILURE:
2115 wpa_supplicant_event_michael_mic_failure(wpa_s, data);
2116 break;
2117#ifndef CONFIG_NO_SCAN_PROCESSING
2118 case EVENT_SCAN_RESULTS:
2119 wpa_supplicant_event_scan_results(wpa_s, data);
2120 break;
2121#endif /* CONFIG_NO_SCAN_PROCESSING */
2122 case EVENT_ASSOCINFO:
2123 wpa_supplicant_event_associnfo(wpa_s, data);
2124 break;
2125 case EVENT_INTERFACE_STATUS:
2126 wpa_supplicant_event_interface_status(wpa_s, data);
2127 break;
2128 case EVENT_PMKID_CANDIDATE:
2129 wpa_supplicant_event_pmkid_candidate(wpa_s, data);
2130 break;
2131#ifdef CONFIG_PEERKEY
2132 case EVENT_STKSTART:
2133 wpa_supplicant_event_stkstart(wpa_s, data);
2134 break;
2135#endif /* CONFIG_PEERKEY */
2136#ifdef CONFIG_TDLS
2137 case EVENT_TDLS:
2138 wpa_supplicant_event_tdls(wpa_s, data);
2139 break;
2140#endif /* CONFIG_TDLS */
2141#ifdef CONFIG_IEEE80211R
2142 case EVENT_FT_RESPONSE:
2143 wpa_supplicant_event_ft_response(wpa_s, data);
2144 break;
2145#endif /* CONFIG_IEEE80211R */
2146#ifdef CONFIG_IBSS_RSN
2147 case EVENT_IBSS_RSN_START:
2148 wpa_supplicant_event_ibss_rsn_start(wpa_s, data);
2149 break;
2150#endif /* CONFIG_IBSS_RSN */
2151 case EVENT_ASSOC_REJECT:
2152 if (data->assoc_reject.bssid)
2153 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
2154 "bssid=" MACSTR " status_code=%u",
2155 MAC2STR(data->assoc_reject.bssid),
2156 data->assoc_reject.status_code);
2157 else
2158 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
2159 "status_code=%u",
2160 data->assoc_reject.status_code);
2161 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
2162 sme_event_assoc_reject(wpa_s, data);
2163 break;
2164 case EVENT_AUTH_TIMED_OUT:
2165 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
2166 sme_event_auth_timed_out(wpa_s, data);
2167 break;
2168 case EVENT_ASSOC_TIMED_OUT:
2169 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
2170 sme_event_assoc_timed_out(wpa_s, data);
2171 break;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002172 case EVENT_TX_STATUS:
2173 wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS dst=" MACSTR
2174 " type=%d stype=%d",
2175 MAC2STR(data->tx_status.dst),
2176 data->tx_status.type, data->tx_status.stype);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002177#ifdef CONFIG_AP
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002178 if (wpa_s->ap_iface == NULL) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002179#ifdef CONFIG_OFFCHANNEL
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002180 if (data->tx_status.type == WLAN_FC_TYPE_MGMT &&
2181 data->tx_status.stype == WLAN_FC_STYPE_ACTION)
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002182 offchannel_send_action_tx_status(
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002183 wpa_s, data->tx_status.dst,
2184 data->tx_status.data,
2185 data->tx_status.data_len,
2186 data->tx_status.ack ?
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002187 OFFCHANNEL_SEND_ACTION_SUCCESS :
2188 OFFCHANNEL_SEND_ACTION_NO_ACK);
2189#endif /* CONFIG_OFFCHANNEL */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002190 break;
2191 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002192#endif /* CONFIG_AP */
2193#ifdef CONFIG_OFFCHANNEL
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002194 wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS pending_dst="
2195 MACSTR, MAC2STR(wpa_s->parent->pending_action_dst));
2196 /*
2197 * Catch TX status events for Action frames we sent via group
2198 * interface in GO mode.
2199 */
2200 if (data->tx_status.type == WLAN_FC_TYPE_MGMT &&
2201 data->tx_status.stype == WLAN_FC_STYPE_ACTION &&
2202 os_memcmp(wpa_s->parent->pending_action_dst,
2203 data->tx_status.dst, ETH_ALEN) == 0) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002204 offchannel_send_action_tx_status(
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002205 wpa_s->parent, data->tx_status.dst,
2206 data->tx_status.data,
2207 data->tx_status.data_len,
2208 data->tx_status.ack ?
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002209 OFFCHANNEL_SEND_ACTION_SUCCESS :
2210 OFFCHANNEL_SEND_ACTION_NO_ACK);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002211 break;
2212 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002213#endif /* CONFIG_OFFCHANNEL */
2214#ifdef CONFIG_AP
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002215 switch (data->tx_status.type) {
2216 case WLAN_FC_TYPE_MGMT:
2217 ap_mgmt_tx_cb(wpa_s, data->tx_status.data,
2218 data->tx_status.data_len,
2219 data->tx_status.stype,
2220 data->tx_status.ack);
2221 break;
2222 case WLAN_FC_TYPE_DATA:
2223 ap_tx_status(wpa_s, data->tx_status.dst,
2224 data->tx_status.data,
2225 data->tx_status.data_len,
2226 data->tx_status.ack);
2227 break;
2228 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002229#endif /* CONFIG_AP */
2230 break;
2231#ifdef CONFIG_AP
2232 case EVENT_EAPOL_TX_STATUS:
2233 ap_eapol_tx_status(wpa_s, data->eapol_tx_status.dst,
2234 data->eapol_tx_status.data,
2235 data->eapol_tx_status.data_len,
2236 data->eapol_tx_status.ack);
2237 break;
2238 case EVENT_DRIVER_CLIENT_POLL_OK:
2239 ap_client_poll_ok(wpa_s, data->client_poll.addr);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002240 break;
2241 case EVENT_RX_FROM_UNKNOWN:
2242 if (wpa_s->ap_iface == NULL)
2243 break;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002244 ap_rx_from_unknown_sta(wpa_s, data->rx_from_unknown.addr,
2245 data->rx_from_unknown.wds);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002246 break;
2247 case EVENT_RX_MGMT:
2248 if (wpa_s->ap_iface == NULL) {
2249#ifdef CONFIG_P2P
2250 u16 fc, stype;
2251 const struct ieee80211_mgmt *mgmt;
2252 mgmt = (const struct ieee80211_mgmt *)
2253 data->rx_mgmt.frame;
2254 fc = le_to_host16(mgmt->frame_control);
2255 stype = WLAN_FC_GET_STYPE(fc);
2256 if (stype == WLAN_FC_STYPE_PROBE_REQ &&
2257 data->rx_mgmt.frame_len > 24) {
2258 const u8 *src = mgmt->sa;
2259 const u8 *ie = mgmt->u.probe_req.variable;
2260 size_t ie_len = data->rx_mgmt.frame_len -
2261 (mgmt->u.probe_req.variable -
2262 data->rx_mgmt.frame);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002263 wpas_p2p_probe_req_rx(wpa_s, src, mgmt->da,
2264 mgmt->bssid, ie, ie_len);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002265 break;
2266 }
2267#endif /* CONFIG_P2P */
2268 wpa_dbg(wpa_s, MSG_DEBUG, "AP: ignore received "
2269 "management frame in non-AP mode");
2270 break;
2271 }
2272 ap_mgmt_rx(wpa_s, &data->rx_mgmt);
2273 break;
2274#endif /* CONFIG_AP */
2275 case EVENT_RX_ACTION:
2276 wpa_dbg(wpa_s, MSG_DEBUG, "Received Action frame: SA=" MACSTR
2277 " Category=%u DataLen=%d freq=%d MHz",
2278 MAC2STR(data->rx_action.sa),
2279 data->rx_action.category, (int) data->rx_action.len,
2280 data->rx_action.freq);
2281#ifdef CONFIG_IEEE80211R
2282 if (data->rx_action.category == WLAN_ACTION_FT) {
2283 ft_rx_action(wpa_s, data->rx_action.data,
2284 data->rx_action.len);
2285 break;
2286 }
2287#endif /* CONFIG_IEEE80211R */
2288#ifdef CONFIG_IEEE80211W
2289#ifdef CONFIG_SME
2290 if (data->rx_action.category == WLAN_ACTION_SA_QUERY) {
2291 sme_sa_query_rx(wpa_s, data->rx_action.sa,
2292 data->rx_action.data,
2293 data->rx_action.len);
2294 break;
2295 }
2296#endif /* CONFIG_SME */
2297#endif /* CONFIG_IEEE80211W */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002298#ifdef CONFIG_GAS
2299 if (data->rx_action.category == WLAN_ACTION_PUBLIC &&
2300 gas_query_rx(wpa_s->gas, data->rx_action.da,
2301 data->rx_action.sa, data->rx_action.bssid,
2302 data->rx_action.data, data->rx_action.len,
2303 data->rx_action.freq) == 0)
2304 break;
2305#endif /* CONFIG_GAS */
2306 if (data->rx_action.category == WLAN_ACTION_WNM) {
2307 wnm_action_rx(wpa_s, &data->rx_action);
2308 break;
2309 }
2310#ifdef CONFIG_TDLS
2311 if (data->rx_action.category == WLAN_ACTION_PUBLIC &&
2312 data->rx_action.len >= 4 &&
2313 data->rx_action.data[0] == WLAN_TDLS_DISCOVERY_RESPONSE) {
2314 wpa_dbg(wpa_s, MSG_DEBUG, "TDLS: Received Discovery "
2315 "Response from " MACSTR,
2316 MAC2STR(data->rx_action.sa));
2317 break;
2318 }
2319#endif /* CONFIG_TDLS */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002320#ifdef CONFIG_P2P
2321 wpas_p2p_rx_action(wpa_s, data->rx_action.da,
2322 data->rx_action.sa,
2323 data->rx_action.bssid,
2324 data->rx_action.category,
2325 data->rx_action.data,
2326 data->rx_action.len, data->rx_action.freq);
2327#endif /* CONFIG_P2P */
2328 break;
2329 case EVENT_RX_PROBE_REQ:
2330 if (data->rx_probe_req.sa == NULL ||
2331 data->rx_probe_req.ie == NULL)
2332 break;
2333#ifdef CONFIG_AP
2334 if (wpa_s->ap_iface) {
2335 hostapd_probe_req_rx(wpa_s->ap_iface->bss[0],
2336 data->rx_probe_req.sa,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002337 data->rx_probe_req.da,
2338 data->rx_probe_req.bssid,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002339 data->rx_probe_req.ie,
2340 data->rx_probe_req.ie_len);
2341 break;
2342 }
2343#endif /* CONFIG_AP */
2344#ifdef CONFIG_P2P
2345 wpas_p2p_probe_req_rx(wpa_s, data->rx_probe_req.sa,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002346 data->rx_probe_req.da,
2347 data->rx_probe_req.bssid,
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002348 data->rx_probe_req.ie,
2349 data->rx_probe_req.ie_len);
2350#endif /* CONFIG_P2P */
2351 break;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002352 case EVENT_REMAIN_ON_CHANNEL:
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002353#ifdef CONFIG_OFFCHANNEL
2354 offchannel_remain_on_channel_cb(
2355 wpa_s, data->remain_on_channel.freq,
2356 data->remain_on_channel.duration);
2357#endif /* CONFIG_OFFCHANNEL */
2358#ifdef CONFIG_P2P
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002359 wpas_p2p_remain_on_channel_cb(
2360 wpa_s, data->remain_on_channel.freq,
2361 data->remain_on_channel.duration);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002362#endif /* CONFIG_P2P */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002363 break;
2364 case EVENT_CANCEL_REMAIN_ON_CHANNEL:
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002365#ifdef CONFIG_OFFCHANNEL
2366 offchannel_cancel_remain_on_channel_cb(
2367 wpa_s, data->remain_on_channel.freq);
2368#endif /* CONFIG_OFFCHANNEL */
2369#ifdef CONFIG_P2P
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002370 wpas_p2p_cancel_remain_on_channel_cb(
2371 wpa_s, data->remain_on_channel.freq);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002372#endif /* CONFIG_P2P */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002373 break;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002374#ifdef CONFIG_P2P
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002375 case EVENT_P2P_DEV_FOUND: {
2376 struct p2p_peer_info peer_info;
2377
2378 os_memset(&peer_info, 0, sizeof(peer_info));
2379 if (data->p2p_dev_found.dev_addr)
2380 os_memcpy(peer_info.p2p_device_addr,
2381 data->p2p_dev_found.dev_addr, ETH_ALEN);
2382 if (data->p2p_dev_found.pri_dev_type)
2383 os_memcpy(peer_info.pri_dev_type,
2384 data->p2p_dev_found.pri_dev_type,
2385 sizeof(peer_info.pri_dev_type));
2386 if (data->p2p_dev_found.dev_name)
2387 os_strlcpy(peer_info.device_name,
2388 data->p2p_dev_found.dev_name,
2389 sizeof(peer_info.device_name));
2390 peer_info.config_methods = data->p2p_dev_found.config_methods;
2391 peer_info.dev_capab = data->p2p_dev_found.dev_capab;
2392 peer_info.group_capab = data->p2p_dev_found.group_capab;
2393
2394 /*
2395 * FIX: new_device=1 is not necessarily correct. We should
2396 * maintain a P2P peer database in wpa_supplicant and update
2397 * this information based on whether the peer is truly new.
2398 */
2399 wpas_dev_found(wpa_s, data->p2p_dev_found.addr, &peer_info, 1);
2400 break;
2401 }
2402 case EVENT_P2P_GO_NEG_REQ_RX:
2403 wpas_go_neg_req_rx(wpa_s, data->p2p_go_neg_req_rx.src,
2404 data->p2p_go_neg_req_rx.dev_passwd_id);
2405 break;
2406 case EVENT_P2P_GO_NEG_COMPLETED:
2407 wpas_go_neg_completed(wpa_s, data->p2p_go_neg_completed.res);
2408 break;
2409 case EVENT_P2P_PROV_DISC_REQUEST:
2410 wpas_prov_disc_req(wpa_s, data->p2p_prov_disc_req.peer,
2411 data->p2p_prov_disc_req.config_methods,
2412 data->p2p_prov_disc_req.dev_addr,
2413 data->p2p_prov_disc_req.pri_dev_type,
2414 data->p2p_prov_disc_req.dev_name,
2415 data->p2p_prov_disc_req.supp_config_methods,
2416 data->p2p_prov_disc_req.dev_capab,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002417 data->p2p_prov_disc_req.group_capab,
2418 NULL, 0);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002419 break;
2420 case EVENT_P2P_PROV_DISC_RESPONSE:
2421 wpas_prov_disc_resp(wpa_s, data->p2p_prov_disc_resp.peer,
2422 data->p2p_prov_disc_resp.config_methods);
2423 break;
2424 case EVENT_P2P_SD_REQUEST:
2425 wpas_sd_request(wpa_s, data->p2p_sd_req.freq,
2426 data->p2p_sd_req.sa,
2427 data->p2p_sd_req.dialog_token,
2428 data->p2p_sd_req.update_indic,
2429 data->p2p_sd_req.tlvs,
2430 data->p2p_sd_req.tlvs_len);
2431 break;
2432 case EVENT_P2P_SD_RESPONSE:
2433 wpas_sd_response(wpa_s, data->p2p_sd_resp.sa,
2434 data->p2p_sd_resp.update_indic,
2435 data->p2p_sd_resp.tlvs,
2436 data->p2p_sd_resp.tlvs_len);
2437 break;
2438#endif /* CONFIG_P2P */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002439 case EVENT_EAPOL_RX:
2440 wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src,
2441 data->eapol_rx.data,
2442 data->eapol_rx.data_len);
2443 break;
2444 case EVENT_SIGNAL_CHANGE:
2445 bgscan_notify_signal_change(
2446 wpa_s, data->signal_change.above_threshold,
2447 data->signal_change.current_signal,
2448 data->signal_change.current_noise,
2449 data->signal_change.current_txrate);
2450 break;
2451 case EVENT_INTERFACE_ENABLED:
2452 wpa_dbg(wpa_s, MSG_DEBUG, "Interface was enabled");
2453 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002454 wpa_supplicant_update_mac_addr(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002455#ifdef CONFIG_AP
2456 if (!wpa_s->ap_iface) {
2457 wpa_supplicant_set_state(wpa_s,
2458 WPA_DISCONNECTED);
2459 wpa_supplicant_req_scan(wpa_s, 0, 0);
2460 } else
2461 wpa_supplicant_set_state(wpa_s,
2462 WPA_COMPLETED);
2463#else /* CONFIG_AP */
2464 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2465 wpa_supplicant_req_scan(wpa_s, 0, 0);
2466#endif /* CONFIG_AP */
2467 }
2468 break;
2469 case EVENT_INTERFACE_DISABLED:
2470 wpa_dbg(wpa_s, MSG_DEBUG, "Interface was disabled");
2471 wpa_supplicant_mark_disassoc(wpa_s);
2472 wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
2473 break;
2474 case EVENT_CHANNEL_LIST_CHANGED:
2475 if (wpa_s->drv_priv == NULL)
2476 break; /* Ignore event during drv initialization */
2477#ifdef CONFIG_P2P
2478 wpas_p2p_update_channel_list(wpa_s);
2479#endif /* CONFIG_P2P */
2480 break;
2481 case EVENT_INTERFACE_UNAVAILABLE:
2482#ifdef CONFIG_P2P
2483 wpas_p2p_interface_unavailable(wpa_s);
2484#endif /* CONFIG_P2P */
2485 break;
2486 case EVENT_BEST_CHANNEL:
2487 wpa_dbg(wpa_s, MSG_DEBUG, "Best channel event received "
2488 "(%d %d %d)",
2489 data->best_chan.freq_24, data->best_chan.freq_5,
2490 data->best_chan.freq_overall);
2491 wpa_s->best_24_freq = data->best_chan.freq_24;
2492 wpa_s->best_5_freq = data->best_chan.freq_5;
2493 wpa_s->best_overall_freq = data->best_chan.freq_overall;
2494#ifdef CONFIG_P2P
2495 wpas_p2p_update_best_channels(wpa_s, data->best_chan.freq_24,
2496 data->best_chan.freq_5,
2497 data->best_chan.freq_overall);
2498#endif /* CONFIG_P2P */
2499 break;
2500 case EVENT_UNPROT_DEAUTH:
2501 wpa_supplicant_event_unprot_deauth(wpa_s,
2502 &data->unprot_deauth);
2503 break;
2504 case EVENT_UNPROT_DISASSOC:
2505 wpa_supplicant_event_unprot_disassoc(wpa_s,
2506 &data->unprot_disassoc);
2507 break;
2508 case EVENT_STATION_LOW_ACK:
2509#ifdef CONFIG_AP
2510 if (wpa_s->ap_iface && data)
2511 hostapd_event_sta_low_ack(wpa_s->ap_iface->bss[0],
2512 data->low_ack.addr);
2513#endif /* CONFIG_AP */
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002514#ifdef CONFIG_TDLS
2515 if (data)
2516 wpa_tdls_disable_link(wpa_s->wpa, data->low_ack.addr);
2517#endif /* CONFIG_TDLS */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002518 break;
2519 case EVENT_IBSS_PEER_LOST:
2520#ifdef CONFIG_IBSS_RSN
2521 ibss_rsn_stop(wpa_s->ibss_rsn, data->ibss_peer_lost.peer);
2522#endif /* CONFIG_IBSS_RSN */
2523 break;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08002524 case EVENT_DRIVER_GTK_REKEY:
2525 if (os_memcmp(data->driver_gtk_rekey.bssid,
2526 wpa_s->bssid, ETH_ALEN))
2527 break;
2528 if (!wpa_s->wpa)
2529 break;
2530 wpa_sm_update_replay_ctr(wpa_s->wpa,
2531 data->driver_gtk_rekey.replay_ctr);
2532 break;
2533 case EVENT_SCHED_SCAN_STOPPED:
2534 wpa_s->sched_scanning = 0;
2535 wpa_supplicant_notify_scanning(wpa_s, 0);
2536
2537 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
2538 break;
2539
2540 /*
2541 * If we timed out, start a new sched scan to continue
2542 * searching for more SSIDs.
2543 */
2544 if (wpa_s->sched_scan_timed_out)
2545 wpa_supplicant_req_sched_scan(wpa_s);
2546 break;
2547 case EVENT_WPS_BUTTON_PUSHED:
2548#ifdef CONFIG_WPS
2549 wpas_wps_start_pbc(wpa_s, NULL, 0);
2550#endif /* CONFIG_WPS */
2551 break;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07002552 default:
2553 wpa_msg(wpa_s, MSG_INFO, "Unknown event %d", event);
2554 break;
2555 }
2556}