blob: e61631921e378ebf71e2bbac2b9172e78aee4045 [file] [log] [blame]
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001/*
2 * wpa_supplicant - SME
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -08003 * Copyright (c) 2009-2014, Jouni Malinen <j@w1.fi>
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07004 *
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -08005 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07007 */
8
9#include "includes.h"
10
11#include "common.h"
12#include "utils/eloop.h"
13#include "common/ieee802_11_defs.h"
14#include "common/ieee802_11_common.h"
15#include "eapol_supp/eapol_supp_sm.h"
16#include "common/wpa_common.h"
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080017#include "common/sae.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070018#include "rsn_supp/wpa.h"
19#include "rsn_supp/pmksa_cache.h"
20#include "config.h"
21#include "wpa_supplicant_i.h"
22#include "driver_i.h"
23#include "wpas_glue.h"
24#include "wps_supplicant.h"
25#include "p2p_supplicant.h"
26#include "notify.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070027#include "bss.h"
28#include "scan.h"
29#include "sme.h"
Dmitry Shmidt04949592012-07-19 12:16:46 -070030#include "hs20_supplicant.h"
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070031
32#define SME_AUTH_TIMEOUT 5
33#define SME_ASSOC_TIMEOUT 5
34
35static void sme_auth_timer(void *eloop_ctx, void *timeout_ctx);
36static void sme_assoc_timer(void *eloop_ctx, void *timeout_ctx);
Dmitry Shmidt04949592012-07-19 12:16:46 -070037static void sme_obss_scan_timeout(void *eloop_ctx, void *timeout_ctx);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -070038#ifdef CONFIG_IEEE80211W
39static void sme_stop_sa_query(struct wpa_supplicant *wpa_s);
40#endif /* CONFIG_IEEE80211W */
41
42
Dmitry Shmidtd5e49232012-12-03 15:08:10 -080043#ifdef CONFIG_SAE
44
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080045static int index_within_array(const int *array, int idx)
46{
47 int i;
48 for (i = 0; i < idx; i++) {
Dmitry Shmidtcce06662013-11-04 18:44:24 -080049 if (array[i] <= 0)
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080050 return 0;
51 }
52 return 1;
53}
54
55
56static int sme_set_sae_group(struct wpa_supplicant *wpa_s)
57{
58 int *groups = wpa_s->conf->sae_groups;
Dmitry Shmidtcce06662013-11-04 18:44:24 -080059 int default_groups[] = { 19, 20, 21, 25, 26, 0 };
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080060
Dmitry Shmidtcce06662013-11-04 18:44:24 -080061 if (!groups || groups[0] <= 0)
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080062 groups = default_groups;
63
64 /* Configuration may have changed, so validate current index */
65 if (!index_within_array(groups, wpa_s->sme.sae_group_index))
66 return -1;
67
68 for (;;) {
69 int group = groups[wpa_s->sme.sae_group_index];
70 if (group < 0)
71 break;
72 if (sae_set_group(&wpa_s->sme.sae, group) == 0) {
73 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Selected SAE group %d",
74 wpa_s->sme.sae.group);
75 return 0;
76 }
77 wpa_s->sme.sae_group_index++;
78 }
79
80 return -1;
81}
82
83
84static struct wpabuf * sme_auth_build_sae_commit(struct wpa_supplicant *wpa_s,
85 struct wpa_ssid *ssid,
86 const u8 *bssid)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -080087{
88 struct wpabuf *buf;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080089 size_t len;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -080090
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -080091 if (ssid->passphrase == NULL) {
92 wpa_printf(MSG_DEBUG, "SAE: No password available");
93 return NULL;
94 }
95
96 if (sme_set_sae_group(wpa_s) < 0) {
97 wpa_printf(MSG_DEBUG, "SAE: Failed to select group");
98 return NULL;
99 }
100
101 if (sae_prepare_commit(wpa_s->own_addr, bssid,
102 (u8 *) ssid->passphrase,
103 os_strlen(ssid->passphrase),
104 &wpa_s->sme.sae) < 0) {
105 wpa_printf(MSG_DEBUG, "SAE: Could not pick PWE");
106 return NULL;
107 }
108
109 len = wpa_s->sme.sae_token ? wpabuf_len(wpa_s->sme.sae_token) : 0;
110 buf = wpabuf_alloc(4 + SAE_COMMIT_MAX_LEN + len);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800111 if (buf == NULL)
112 return NULL;
113
114 wpabuf_put_le16(buf, 1); /* Transaction seq# */
115 wpabuf_put_le16(buf, WLAN_STATUS_SUCCESS);
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800116 sae_write_commit(&wpa_s->sme.sae, buf, wpa_s->sme.sae_token);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800117
118 return buf;
119}
120
121
122static struct wpabuf * sme_auth_build_sae_confirm(struct wpa_supplicant *wpa_s)
123{
124 struct wpabuf *buf;
125
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800126 buf = wpabuf_alloc(4 + SAE_CONFIRM_MAX_LEN);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800127 if (buf == NULL)
128 return NULL;
129
130 wpabuf_put_le16(buf, 2); /* Transaction seq# */
131 wpabuf_put_le16(buf, WLAN_STATUS_SUCCESS);
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800132 sae_write_confirm(&wpa_s->sme.sae, buf);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800133
134 return buf;
135}
136
137#endif /* CONFIG_SAE */
138
139
140static void sme_send_authentication(struct wpa_supplicant *wpa_s,
141 struct wpa_bss *bss, struct wpa_ssid *ssid,
142 int start)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700143{
144 struct wpa_driver_auth_params params;
145 struct wpa_ssid *old_ssid;
146#ifdef CONFIG_IEEE80211R
147 const u8 *ie;
148#endif /* CONFIG_IEEE80211R */
149#ifdef CONFIG_IEEE80211R
150 const u8 *md = NULL;
151#endif /* CONFIG_IEEE80211R */
152 int i, bssid_changed;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800153 struct wpabuf *resp = NULL;
Dmitry Shmidt09f57ba2014-06-10 16:07:13 -0700154 u8 ext_capab[18];
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800155 int ext_capab_len;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700156
157 if (bss == NULL) {
158 wpa_msg(wpa_s, MSG_ERROR, "SME: No scan result available for "
159 "the network");
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800160 wpas_connect_work_done(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700161 return;
162 }
163
164 wpa_s->current_bss = bss;
165
166 os_memset(&params, 0, sizeof(params));
167 wpa_s->reassociate = 0;
168
169 params.freq = bss->freq;
170 params.bssid = bss->bssid;
171 params.ssid = bss->ssid;
172 params.ssid_len = bss->ssid_len;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800173 params.p2p = ssid->p2p_group;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700174
175 if (wpa_s->sme.ssid_len != params.ssid_len ||
176 os_memcmp(wpa_s->sme.ssid, params.ssid, params.ssid_len) != 0)
177 wpa_s->sme.prev_bssid_set = 0;
178
179 wpa_s->sme.freq = params.freq;
180 os_memcpy(wpa_s->sme.ssid, params.ssid, params.ssid_len);
181 wpa_s->sme.ssid_len = params.ssid_len;
182
183 params.auth_alg = WPA_AUTH_ALG_OPEN;
184#ifdef IEEE8021X_EAPOL
185 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
186 if (ssid->leap) {
187 if (ssid->non_leap == 0)
188 params.auth_alg = WPA_AUTH_ALG_LEAP;
189 else
190 params.auth_alg |= WPA_AUTH_ALG_LEAP;
191 }
192 }
193#endif /* IEEE8021X_EAPOL */
194 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x",
195 params.auth_alg);
196 if (ssid->auth_alg) {
197 params.auth_alg = ssid->auth_alg;
198 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
199 "0x%x", params.auth_alg);
200 }
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800201#ifdef CONFIG_SAE
202 if (wpa_key_mgmt_sae(ssid->key_mgmt)) {
203 const u8 *rsn;
204 struct wpa_ie_data ied;
205
206 rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
207 if (rsn &&
208 wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ied) == 0) {
209 if (wpa_key_mgmt_sae(ied.key_mgmt)) {
210 wpa_dbg(wpa_s, MSG_DEBUG, "Using SAE auth_alg");
211 params.auth_alg = WPA_AUTH_ALG_SAE;
212 }
213 }
214 }
215#endif /* CONFIG_SAE */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700216
217 for (i = 0; i < NUM_WEP_KEYS; i++) {
218 if (ssid->wep_key_len[i])
219 params.wep_key[i] = ssid->wep_key[i];
220 params.wep_key_len[i] = ssid->wep_key_len[i];
221 }
222 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
223
224 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
225 os_memset(wpa_s->bssid, 0, ETH_ALEN);
226 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
227 if (bssid_changed)
228 wpas_notify_bssid_changed(wpa_s);
229
230 if ((wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
231 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800232 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700233 int try_opportunistic;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800234 try_opportunistic = (ssid->proactive_key_caching < 0 ?
235 wpa_s->conf->okc :
236 ssid->proactive_key_caching) &&
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700237 (ssid->proto & WPA_PROTO_RSN);
238 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
239 wpa_s->current_ssid,
240 try_opportunistic) == 0)
241 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1);
242 wpa_s->sme.assoc_req_ie_len = sizeof(wpa_s->sme.assoc_req_ie);
243 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
244 wpa_s->sme.assoc_req_ie,
245 &wpa_s->sme.assoc_req_ie_len)) {
246 wpa_msg(wpa_s, MSG_WARNING, "SME: Failed to set WPA "
247 "key management and encryption suites");
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800248 wpas_connect_work_done(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700249 return;
250 }
Dmitry Shmidt61d9df32012-08-29 16:22:06 -0700251 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
252 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
253 /*
254 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
255 * use non-WPA since the scan results did not indicate that the
256 * AP is using WPA or WPA2.
257 */
258 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
259 wpa_s->sme.assoc_req_ie_len = 0;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800260 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700261 wpa_s->sme.assoc_req_ie_len = sizeof(wpa_s->sme.assoc_req_ie);
262 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
263 wpa_s->sme.assoc_req_ie,
264 &wpa_s->sme.assoc_req_ie_len)) {
265 wpa_msg(wpa_s, MSG_WARNING, "SME: Failed to set WPA "
266 "key management and encryption suites (no "
267 "scan results)");
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800268 wpas_connect_work_done(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700269 return;
270 }
271#ifdef CONFIG_WPS
272 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
273 struct wpabuf *wps_ie;
274 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
275 if (wps_ie && wpabuf_len(wps_ie) <=
276 sizeof(wpa_s->sme.assoc_req_ie)) {
277 wpa_s->sme.assoc_req_ie_len = wpabuf_len(wps_ie);
278 os_memcpy(wpa_s->sme.assoc_req_ie, wpabuf_head(wps_ie),
279 wpa_s->sme.assoc_req_ie_len);
280 } else
281 wpa_s->sme.assoc_req_ie_len = 0;
282 wpabuf_free(wps_ie);
283 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
284#endif /* CONFIG_WPS */
285 } else {
286 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
287 wpa_s->sme.assoc_req_ie_len = 0;
288 }
289
290#ifdef CONFIG_IEEE80211R
291 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
292 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
293 md = ie + 2;
294 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
295 if (md) {
296 /* Prepare for the next transition */
297 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
298 }
299
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800300 if (md && wpa_key_mgmt_ft(ssid->key_mgmt)) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700301 if (wpa_s->sme.assoc_req_ie_len + 5 <
302 sizeof(wpa_s->sme.assoc_req_ie)) {
303 struct rsn_mdie *mdie;
304 u8 *pos = wpa_s->sme.assoc_req_ie +
305 wpa_s->sme.assoc_req_ie_len;
306 *pos++ = WLAN_EID_MOBILITY_DOMAIN;
307 *pos++ = sizeof(*mdie);
308 mdie = (struct rsn_mdie *) pos;
309 os_memcpy(mdie->mobility_domain, md,
310 MOBILITY_DOMAIN_ID_LEN);
311 mdie->ft_capab = md[MOBILITY_DOMAIN_ID_LEN];
312 wpa_s->sme.assoc_req_ie_len += 5;
313 }
314
315 if (wpa_s->sme.ft_used &&
316 os_memcmp(md, wpa_s->sme.mobility_domain, 2) == 0 &&
317 wpa_sm_has_ptk(wpa_s->wpa)) {
318 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Trying to use FT "
319 "over-the-air");
320 params.auth_alg = WPA_AUTH_ALG_FT;
321 params.ie = wpa_s->sme.ft_ies;
322 params.ie_len = wpa_s->sme.ft_ies_len;
323 }
324 }
325#endif /* CONFIG_IEEE80211R */
326
327#ifdef CONFIG_IEEE80211W
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800328 wpa_s->sme.mfp = ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
329 wpa_s->conf->pmf : ssid->ieee80211w;
330 if (wpa_s->sme.mfp != NO_MGMT_FRAME_PROTECTION) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700331 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
332 struct wpa_ie_data _ie;
333 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &_ie) == 0 &&
334 _ie.capabilities &
335 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
336 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Selected AP supports "
337 "MFP: require MFP");
338 wpa_s->sme.mfp = MGMT_FRAME_PROTECTION_REQUIRED;
339 }
340 }
341#endif /* CONFIG_IEEE80211W */
342
343#ifdef CONFIG_P2P
344 if (wpa_s->global->p2p) {
345 u8 *pos;
346 size_t len;
347 int res;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700348 pos = wpa_s->sme.assoc_req_ie + wpa_s->sme.assoc_req_ie_len;
349 len = sizeof(wpa_s->sme.assoc_req_ie) -
350 wpa_s->sme.assoc_req_ie_len;
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800351 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
352 ssid->p2p_group);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700353 if (res >= 0)
354 wpa_s->sme.assoc_req_ie_len += res;
355 }
356#endif /* CONFIG_P2P */
357
Dmitry Shmidt04949592012-07-19 12:16:46 -0700358#ifdef CONFIG_HS20
Dmitry Shmidt51b6ea82013-05-08 10:42:09 -0700359 if (is_hs20_network(wpa_s, ssid, bss)) {
Dmitry Shmidt04949592012-07-19 12:16:46 -0700360 struct wpabuf *hs20;
361 hs20 = wpabuf_alloc(20);
362 if (hs20) {
Dmitry Shmidtf21452a2014-02-26 10:55:25 -0800363 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
Dmitry Shmidtc2817022014-07-02 10:32:10 -0700364 size_t len;
365
Dmitry Shmidtf21452a2014-02-26 10:55:25 -0800366 wpas_hs20_add_indication(hs20, pps_mo_id);
Dmitry Shmidtc2817022014-07-02 10:32:10 -0700367 len = sizeof(wpa_s->sme.assoc_req_ie) -
368 wpa_s->sme.assoc_req_ie_len;
369 if (wpabuf_len(hs20) <= len) {
370 os_memcpy(wpa_s->sme.assoc_req_ie +
371 wpa_s->sme.assoc_req_ie_len,
372 wpabuf_head(hs20), wpabuf_len(hs20));
373 wpa_s->sme.assoc_req_ie_len += wpabuf_len(hs20);
374 }
Dmitry Shmidt04949592012-07-19 12:16:46 -0700375 wpabuf_free(hs20);
376 }
377 }
378#endif /* CONFIG_HS20 */
379
Dmitry Shmidt09f57ba2014-06-10 16:07:13 -0700380 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
381 sizeof(ext_capab));
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800382 if (ext_capab_len > 0) {
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800383 u8 *pos = wpa_s->sme.assoc_req_ie;
384 if (wpa_s->sme.assoc_req_ie_len > 0 && pos[0] == WLAN_EID_RSN)
385 pos += 2 + pos[1];
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800386 os_memmove(pos + ext_capab_len, pos,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800387 wpa_s->sme.assoc_req_ie_len -
388 (pos - wpa_s->sme.assoc_req_ie));
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800389 wpa_s->sme.assoc_req_ie_len += ext_capab_len;
390 os_memcpy(pos, ext_capab, ext_capab_len);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800391 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800392
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800393#ifdef CONFIG_SAE
394 if (params.auth_alg == WPA_AUTH_ALG_SAE) {
395 if (start)
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800396 resp = sme_auth_build_sae_commit(wpa_s, ssid,
397 bss->bssid);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800398 else
399 resp = sme_auth_build_sae_confirm(wpa_s);
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800400 if (resp == NULL) {
401 wpas_connect_work_done(wpa_s);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800402 return;
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800403 }
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800404 params.sae_data = wpabuf_head(resp);
405 params.sae_data_len = wpabuf_len(resp);
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800406 wpa_s->sme.sae.state = start ? SAE_COMMITTED : SAE_CONFIRMED;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800407 }
408#endif /* CONFIG_SAE */
409
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800410 wpa_supplicant_cancel_sched_scan(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700411 wpa_supplicant_cancel_scan(wpa_s);
412
413 wpa_msg(wpa_s, MSG_INFO, "SME: Trying to authenticate with " MACSTR
414 " (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),
415 wpa_ssid_txt(params.ssid, params.ssid_len), params.freq);
416
417 wpa_clear_keys(wpa_s, bss->bssid);
418 wpa_supplicant_set_state(wpa_s, WPA_AUTHENTICATING);
419 old_ssid = wpa_s->current_ssid;
420 wpa_s->current_ssid = ssid;
421 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
422 wpa_supplicant_initiate_eapol(wpa_s);
423 if (old_ssid != wpa_s->current_ssid)
424 wpas_notify_network_changed(wpa_s);
425
Dmitry Shmidtf9bdef92014-04-25 10:46:36 -0700426#ifdef CONFIG_P2P
427 /*
428 * If multi-channel concurrency is not supported, check for any
429 * frequency conflict. In case of any frequency conflict, remove the
430 * least prioritized connection.
431 */
432 if (wpa_s->num_multichan_concurrent < 2) {
433 int freq, num;
434 num = get_shared_radio_freqs(wpa_s, &freq, 1);
435 if (num > 0 && freq > 0 && freq != params.freq) {
436 wpa_printf(MSG_DEBUG,
437 "Conflicting frequency found (%d != %d)",
438 freq, params.freq);
439 if (wpas_p2p_handle_frequency_conflicts(wpa_s,
440 params.freq,
441 ssid) < 0) {
442 wpas_connection_failed(wpa_s, bss->bssid);
443 wpa_supplicant_mark_disassoc(wpa_s);
444 wpabuf_free(resp);
445 wpas_connect_work_done(wpa_s);
446 return;
447 }
448 }
449 }
450#endif /* CONFIG_P2P */
451
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700452 wpa_s->sme.auth_alg = params.auth_alg;
453 if (wpa_drv_authenticate(wpa_s, &params) < 0) {
454 wpa_msg(wpa_s, MSG_INFO, "SME: Authentication request to the "
455 "driver failed");
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800456 wpas_connection_failed(wpa_s, bss->bssid);
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -0800457 wpa_supplicant_mark_disassoc(wpa_s);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800458 wpabuf_free(resp);
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800459 wpas_connect_work_done(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700460 return;
461 }
462
463 eloop_register_timeout(SME_AUTH_TIMEOUT, 0, sme_auth_timer, wpa_s,
464 NULL);
465
466 /*
467 * Association will be started based on the authentication event from
468 * the driver.
469 */
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800470
471 wpabuf_free(resp);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700472}
473
474
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800475static void sme_auth_start_cb(struct wpa_radio_work *work, int deinit)
476{
477 struct wpa_connect_work *cwork = work->ctx;
478 struct wpa_supplicant *wpa_s = work->wpa_s;
479
480 if (deinit) {
Dmitry Shmidtbd14a572014-02-18 10:33:49 -0800481 if (work->started)
482 wpa_s->connect_work = NULL;
483
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800484 wpas_connect_work_free(cwork);
485 return;
486 }
487
488 wpa_s->connect_work = work;
489
Dmitry Shmidt2e425d62014-11-10 11:18:27 -0800490 if (cwork->bss_removed ||
491 !wpas_valid_bss_ssid(wpa_s, cwork->bss, cwork->ssid)) {
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800492 wpa_dbg(wpa_s, MSG_DEBUG, "SME: BSS/SSID entry for authentication not valid anymore - drop connection attempt");
493 wpas_connect_work_done(wpa_s);
494 return;
495 }
496
497 sme_send_authentication(wpa_s, cwork->bss, cwork->ssid, 1);
498}
499
500
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800501void sme_authenticate(struct wpa_supplicant *wpa_s,
502 struct wpa_bss *bss, struct wpa_ssid *ssid)
503{
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800504 struct wpa_connect_work *cwork;
505
506 if (bss == NULL || ssid == NULL)
507 return;
508 if (wpa_s->connect_work) {
509 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Reject sme_authenticate() call since connect_work exist");
510 return;
511 }
512
Dmitry Shmidtf21452a2014-02-26 10:55:25 -0800513 if (radio_work_pending(wpa_s, "sme-connect")) {
Dmitry Shmidtdf5a7e42014-04-02 12:59:59 -0700514 /*
515 * The previous sme-connect work might no longer be valid due to
516 * the fact that the BSS list was updated. In addition, it makes
517 * sense to adhere to the 'newer' decision.
518 */
519 wpa_dbg(wpa_s, MSG_DEBUG,
520 "SME: Remove previous pending sme-connect");
521 radio_remove_works(wpa_s, "sme-connect", 0);
Dmitry Shmidtf21452a2014-02-26 10:55:25 -0800522 }
523
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800524 cwork = os_zalloc(sizeof(*cwork));
525 if (cwork == NULL)
526 return;
527 cwork->bss = bss;
528 cwork->ssid = ssid;
529 cwork->sme = 1;
530
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800531#ifdef CONFIG_SAE
532 wpa_s->sme.sae.state = SAE_NOTHING;
533 wpa_s->sme.sae.send_confirm = 0;
Dmitry Shmidtcce06662013-11-04 18:44:24 -0800534 wpa_s->sme.sae_group_index = 0;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800535#endif /* CONFIG_SAE */
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800536
537 if (radio_add_work(wpa_s, bss->freq, "sme-connect", 1,
538 sme_auth_start_cb, cwork) < 0)
539 wpas_connect_work_free(cwork);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800540}
541
542
543#ifdef CONFIG_SAE
544
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800545static int sme_sae_auth(struct wpa_supplicant *wpa_s, u16 auth_transaction,
546 u16 status_code, const u8 *data, size_t len)
547{
548 wpa_dbg(wpa_s, MSG_DEBUG, "SME: SAE authentication transaction %u "
549 "status code %u", auth_transaction, status_code);
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800550
551 if (auth_transaction == 1 &&
552 status_code == WLAN_STATUS_ANTI_CLOGGING_TOKEN_REQ &&
553 wpa_s->sme.sae.state == SAE_COMMITTED &&
554 wpa_s->current_bss && wpa_s->current_ssid) {
555 wpa_dbg(wpa_s, MSG_DEBUG, "SME: SAE anti-clogging token "
556 "requested");
557 wpabuf_free(wpa_s->sme.sae_token);
558 wpa_s->sme.sae_token = wpabuf_alloc_copy(data, len);
559 sme_send_authentication(wpa_s, wpa_s->current_bss,
560 wpa_s->current_ssid, 1);
561 return 0;
562 }
563
564 if (auth_transaction == 1 &&
565 status_code == WLAN_STATUS_FINITE_CYCLIC_GROUP_NOT_SUPPORTED &&
566 wpa_s->sme.sae.state == SAE_COMMITTED &&
567 wpa_s->current_bss && wpa_s->current_ssid) {
568 wpa_dbg(wpa_s, MSG_DEBUG, "SME: SAE group not supported");
569 wpa_s->sme.sae_group_index++;
570 if (sme_set_sae_group(wpa_s) < 0)
571 return -1; /* no other groups enabled */
572 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Try next enabled SAE group");
573 sme_send_authentication(wpa_s, wpa_s->current_bss,
574 wpa_s->current_ssid, 1);
575 return 0;
576 }
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800577
578 if (status_code != WLAN_STATUS_SUCCESS)
579 return -1;
580
581 if (auth_transaction == 1) {
Dmitry Shmidtcce06662013-11-04 18:44:24 -0800582 int *groups = wpa_s->conf->sae_groups;
583
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800584 wpa_dbg(wpa_s, MSG_DEBUG, "SME SAE commit");
585 if (wpa_s->current_bss == NULL ||
586 wpa_s->current_ssid == NULL)
587 return -1;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800588 if (wpa_s->sme.sae.state != SAE_COMMITTED)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800589 return -1;
Dmitry Shmidtcce06662013-11-04 18:44:24 -0800590 if (groups && groups[0] <= 0)
591 groups = NULL;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800592 if (sae_parse_commit(&wpa_s->sme.sae, data, len, NULL, NULL,
Dmitry Shmidtcce06662013-11-04 18:44:24 -0800593 groups) != WLAN_STATUS_SUCCESS)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800594 return -1;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800595
596 if (sae_process_commit(&wpa_s->sme.sae) < 0) {
597 wpa_printf(MSG_DEBUG, "SAE: Failed to process peer "
598 "commit");
599 return -1;
600 }
601
602 wpabuf_free(wpa_s->sme.sae_token);
603 wpa_s->sme.sae_token = NULL;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800604 sme_send_authentication(wpa_s, wpa_s->current_bss,
605 wpa_s->current_ssid, 0);
606 return 0;
607 } else if (auth_transaction == 2) {
608 wpa_dbg(wpa_s, MSG_DEBUG, "SME SAE confirm");
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800609 if (wpa_s->sme.sae.state != SAE_CONFIRMED)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800610 return -1;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800611 if (sae_check_confirm(&wpa_s->sme.sae, data, len) < 0)
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800612 return -1;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800613 wpa_s->sme.sae.state = SAE_ACCEPTED;
614 sae_clear_temp_data(&wpa_s->sme.sae);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800615 return 1;
616 }
617
618 return -1;
619}
620#endif /* CONFIG_SAE */
621
622
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700623void sme_event_auth(struct wpa_supplicant *wpa_s, union wpa_event_data *data)
624{
625 struct wpa_ssid *ssid = wpa_s->current_ssid;
626
627 if (ssid == NULL) {
628 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Ignore authentication event "
629 "when network is not selected");
630 return;
631 }
632
633 if (wpa_s->wpa_state != WPA_AUTHENTICATING) {
634 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Ignore authentication event "
635 "when not in authenticating state");
636 return;
637 }
638
639 if (os_memcmp(wpa_s->pending_bssid, data->auth.peer, ETH_ALEN) != 0) {
640 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Ignore authentication with "
641 "unexpected peer " MACSTR,
642 MAC2STR(data->auth.peer));
643 return;
644 }
645
646 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Authentication response: peer=" MACSTR
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800647 " auth_type=%d auth_transaction=%d status_code=%d",
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700648 MAC2STR(data->auth.peer), data->auth.auth_type,
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800649 data->auth.auth_transaction, data->auth.status_code);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700650 wpa_hexdump(MSG_MSGDUMP, "SME: Authentication response IEs",
651 data->auth.ies, data->auth.ies_len);
652
653 eloop_cancel_timeout(sme_auth_timer, wpa_s, NULL);
654
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800655#ifdef CONFIG_SAE
656 if (data->auth.auth_type == WLAN_AUTH_SAE) {
657 int res;
658 res = sme_sae_auth(wpa_s, data->auth.auth_transaction,
659 data->auth.status_code, data->auth.ies,
660 data->auth.ies_len);
661 if (res < 0) {
662 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
663 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
664
665 }
666 if (res != 1)
667 return;
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800668
669 wpa_printf(MSG_DEBUG, "SME: SAE completed - setting PMK for "
670 "4-way handshake");
671 wpa_sm_set_pmk(wpa_s->wpa, wpa_s->sme.sae.pmk, PMK_LEN);
Dmitry Shmidtd5e49232012-12-03 15:08:10 -0800672 }
673#endif /* CONFIG_SAE */
674
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700675 if (data->auth.status_code != WLAN_STATUS_SUCCESS) {
676 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Authentication failed (status "
677 "code %d)", data->auth.status_code);
678
679 if (data->auth.status_code !=
680 WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG ||
681 wpa_s->sme.auth_alg == data->auth.auth_type ||
682 wpa_s->current_ssid->auth_alg == WPA_AUTH_ALG_LEAP) {
683 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700684 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700685 return;
686 }
687
Dmitry Shmidt97672262014-02-03 13:02:54 -0800688 wpas_connect_work_done(wpa_s);
689
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700690 switch (data->auth.auth_type) {
691 case WLAN_AUTH_OPEN:
692 wpa_s->current_ssid->auth_alg = WPA_AUTH_ALG_SHARED;
693
694 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Trying SHARED auth");
695 wpa_supplicant_associate(wpa_s, wpa_s->current_bss,
696 wpa_s->current_ssid);
697 return;
698
699 case WLAN_AUTH_SHARED_KEY:
700 wpa_s->current_ssid->auth_alg = WPA_AUTH_ALG_LEAP;
701
702 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Trying LEAP auth");
703 wpa_supplicant_associate(wpa_s, wpa_s->current_bss,
704 wpa_s->current_ssid);
705 return;
706
707 default:
708 return;
709 }
710 }
711
712#ifdef CONFIG_IEEE80211R
713 if (data->auth.auth_type == WLAN_AUTH_FT) {
714 union wpa_event_data edata;
715 os_memset(&edata, 0, sizeof(edata));
716 edata.ft_ies.ies = data->auth.ies;
717 edata.ft_ies.ies_len = data->auth.ies_len;
718 os_memcpy(edata.ft_ies.target_ap, data->auth.peer, ETH_ALEN);
719 wpa_supplicant_event(wpa_s, EVENT_FT_RESPONSE, &edata);
720 }
721#endif /* CONFIG_IEEE80211R */
722
723 sme_associate(wpa_s, ssid->mode, data->auth.peer,
724 data->auth.auth_type);
725}
726
727
728void sme_associate(struct wpa_supplicant *wpa_s, enum wpas_mode mode,
729 const u8 *bssid, u16 auth_type)
730{
731 struct wpa_driver_associate_params params;
732 struct ieee802_11_elems elems;
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -0800733#ifdef CONFIG_HT_OVERRIDES
734 struct ieee80211_ht_capabilities htcaps;
735 struct ieee80211_ht_capabilities htcaps_mask;
736#endif /* CONFIG_HT_OVERRIDES */
Dmitry Shmidt2f023192013-03-12 12:44:17 -0700737#ifdef CONFIG_VHT_OVERRIDES
738 struct ieee80211_vht_capabilities vhtcaps;
739 struct ieee80211_vht_capabilities vhtcaps_mask;
740#endif /* CONFIG_VHT_OVERRIDES */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700741
742 os_memset(&params, 0, sizeof(params));
743 params.bssid = bssid;
744 params.ssid = wpa_s->sme.ssid;
745 params.ssid_len = wpa_s->sme.ssid_len;
Dmitry Shmidt9ead16e2014-10-07 13:15:23 -0700746 params.freq.freq = wpa_s->sme.freq;
Dmitry Shmidt04949592012-07-19 12:16:46 -0700747 params.bg_scan_period = wpa_s->current_ssid ?
748 wpa_s->current_ssid->bg_scan_period : -1;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700749 params.wpa_ie = wpa_s->sme.assoc_req_ie_len ?
750 wpa_s->sme.assoc_req_ie : NULL;
751 params.wpa_ie_len = wpa_s->sme.assoc_req_ie_len;
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -0800752 params.pairwise_suite = wpa_s->pairwise_cipher;
753 params.group_suite = wpa_s->group_cipher;
Dmitry Shmidt15907092014-03-25 10:42:57 -0700754 params.key_mgmt_suite = wpa_s->key_mgmt;
755 params.wpa_proto = wpa_s->wpa_proto;
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -0800756#ifdef CONFIG_HT_OVERRIDES
757 os_memset(&htcaps, 0, sizeof(htcaps));
758 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
759 params.htcaps = (u8 *) &htcaps;
760 params.htcaps_mask = (u8 *) &htcaps_mask;
761 wpa_supplicant_apply_ht_overrides(wpa_s, wpa_s->current_ssid, &params);
762#endif /* CONFIG_HT_OVERRIDES */
Dmitry Shmidt2f023192013-03-12 12:44:17 -0700763#ifdef CONFIG_VHT_OVERRIDES
764 os_memset(&vhtcaps, 0, sizeof(vhtcaps));
765 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
766 params.vhtcaps = &vhtcaps;
767 params.vhtcaps_mask = &vhtcaps_mask;
768 wpa_supplicant_apply_vht_overrides(wpa_s, wpa_s->current_ssid, &params);
769#endif /* CONFIG_VHT_OVERRIDES */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700770#ifdef CONFIG_IEEE80211R
771 if (auth_type == WLAN_AUTH_FT && wpa_s->sme.ft_ies) {
772 params.wpa_ie = wpa_s->sme.ft_ies;
773 params.wpa_ie_len = wpa_s->sme.ft_ies_len;
774 }
775#endif /* CONFIG_IEEE80211R */
776 params.mode = mode;
777 params.mgmt_frame_protection = wpa_s->sme.mfp;
778 if (wpa_s->sme.prev_bssid_set)
779 params.prev_bssid = wpa_s->sme.prev_bssid;
780
781 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
782 " (SSID='%s' freq=%d MHz)", MAC2STR(params.bssid),
783 params.ssid ? wpa_ssid_txt(params.ssid, params.ssid_len) : "",
Dmitry Shmidt9ead16e2014-10-07 13:15:23 -0700784 params.freq.freq);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700785
786 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
787
788 if (params.wpa_ie == NULL ||
789 ieee802_11_parse_elems(params.wpa_ie, params.wpa_ie_len, &elems, 0)
790 < 0) {
791 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Could not parse own IEs?!");
792 os_memset(&elems, 0, sizeof(elems));
793 }
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800794 if (elems.rsn_ie) {
795 params.wpa_proto = WPA_PROTO_RSN;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700796 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.rsn_ie - 2,
797 elems.rsn_ie_len + 2);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800798 } else if (elems.wpa_ie) {
799 params.wpa_proto = WPA_PROTO_WPA;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700800 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.wpa_ie - 2,
801 elems.wpa_ie_len + 2);
Dmitry Shmidtf21452a2014-02-26 10:55:25 -0800802 } else if (elems.osen) {
803 params.wpa_proto = WPA_PROTO_OSEN;
804 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, elems.osen - 2,
805 elems.osen_len + 2);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800806 } else
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700807 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800808 if (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700809 params.p2p = 1;
810
811 if (wpa_s->parent->set_sta_uapsd)
812 params.uapsd = wpa_s->parent->sta_uapsd;
813 else
814 params.uapsd = -1;
815
816 if (wpa_drv_associate(wpa_s, &params) < 0) {
817 wpa_msg(wpa_s, MSG_INFO, "SME: Association request to the "
818 "driver failed");
819 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
Dmitry Shmidt04949592012-07-19 12:16:46 -0700820 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700821 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
822 return;
823 }
824
825 eloop_register_timeout(SME_ASSOC_TIMEOUT, 0, sme_assoc_timer, wpa_s,
826 NULL);
827}
828
829
830int sme_update_ft_ies(struct wpa_supplicant *wpa_s, const u8 *md,
831 const u8 *ies, size_t ies_len)
832{
833 if (md == NULL || ies == NULL) {
834 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Remove mobility domain");
835 os_free(wpa_s->sme.ft_ies);
836 wpa_s->sme.ft_ies = NULL;
837 wpa_s->sme.ft_ies_len = 0;
838 wpa_s->sme.ft_used = 0;
839 return 0;
840 }
841
842 os_memcpy(wpa_s->sme.mobility_domain, md, MOBILITY_DOMAIN_ID_LEN);
843 wpa_hexdump(MSG_DEBUG, "SME: FT IEs", ies, ies_len);
844 os_free(wpa_s->sme.ft_ies);
845 wpa_s->sme.ft_ies = os_malloc(ies_len);
846 if (wpa_s->sme.ft_ies == NULL)
847 return -1;
848 os_memcpy(wpa_s->sme.ft_ies, ies, ies_len);
849 wpa_s->sme.ft_ies_len = ies_len;
850 return 0;
851}
852
853
854static void sme_deauth(struct wpa_supplicant *wpa_s)
855{
856 int bssid_changed;
857
858 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
859
860 if (wpa_drv_deauthenticate(wpa_s, wpa_s->pending_bssid,
861 WLAN_REASON_DEAUTH_LEAVING) < 0) {
862 wpa_msg(wpa_s, MSG_INFO, "SME: Deauth request to the driver "
863 "failed");
864 }
865 wpa_s->sme.prev_bssid_set = 0;
866
867 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
868 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
869 os_memset(wpa_s->bssid, 0, ETH_ALEN);
870 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
871 if (bssid_changed)
872 wpas_notify_bssid_changed(wpa_s);
873}
874
875
876void sme_event_assoc_reject(struct wpa_supplicant *wpa_s,
877 union wpa_event_data *data)
878{
879 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Association with " MACSTR " failed: "
880 "status code %d", MAC2STR(wpa_s->pending_bssid),
881 data->assoc_reject.status_code);
882
883 eloop_cancel_timeout(sme_assoc_timer, wpa_s, NULL);
884
885 /*
886 * For now, unconditionally terminate the previous authentication. In
887 * theory, this should not be needed, but mac80211 gets quite confused
888 * if the authentication is left pending.. Some roaming cases might
889 * benefit from using the previous authentication, so this could be
890 * optimized in the future.
891 */
892 sme_deauth(wpa_s);
893}
894
895
896void sme_event_auth_timed_out(struct wpa_supplicant *wpa_s,
897 union wpa_event_data *data)
898{
899 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Authentication timed out");
900 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
Dmitry Shmidtc5ec7f52012-03-06 16:33:24 -0800901 wpa_supplicant_mark_disassoc(wpa_s);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700902}
903
904
905void sme_event_assoc_timed_out(struct wpa_supplicant *wpa_s,
906 union wpa_event_data *data)
907{
908 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Association timed out");
909 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
910 wpa_supplicant_mark_disassoc(wpa_s);
911}
912
913
914void sme_event_disassoc(struct wpa_supplicant *wpa_s,
Dmitry Shmidtc2ebb4b2013-07-24 12:57:51 -0700915 struct disassoc_info *info)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700916{
917 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Disassociation event received");
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -0800918 if (wpa_s->sme.prev_bssid_set) {
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700919 /*
920 * cfg80211/mac80211 can get into somewhat confused state if
921 * the AP only disassociates us and leaves us in authenticated
922 * state. For now, force the state to be cleared to avoid
923 * confusing errors if we try to associate with the AP again.
924 */
925 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Deauthenticate to clear "
926 "driver state");
927 wpa_drv_deauthenticate(wpa_s, wpa_s->sme.prev_bssid,
928 WLAN_REASON_DEAUTH_LEAVING);
929 }
930}
931
932
933static void sme_auth_timer(void *eloop_ctx, void *timeout_ctx)
934{
935 struct wpa_supplicant *wpa_s = eloop_ctx;
936 if (wpa_s->wpa_state == WPA_AUTHENTICATING) {
937 wpa_msg(wpa_s, MSG_DEBUG, "SME: Authentication timeout");
938 sme_deauth(wpa_s);
939 }
940}
941
942
943static void sme_assoc_timer(void *eloop_ctx, void *timeout_ctx)
944{
945 struct wpa_supplicant *wpa_s = eloop_ctx;
946 if (wpa_s->wpa_state == WPA_ASSOCIATING) {
947 wpa_msg(wpa_s, MSG_DEBUG, "SME: Association timeout");
948 sme_deauth(wpa_s);
949 }
950}
951
952
953void sme_state_changed(struct wpa_supplicant *wpa_s)
954{
955 /* Make sure timers are cleaned up appropriately. */
956 if (wpa_s->wpa_state != WPA_ASSOCIATING)
957 eloop_cancel_timeout(sme_assoc_timer, wpa_s, NULL);
958 if (wpa_s->wpa_state != WPA_AUTHENTICATING)
959 eloop_cancel_timeout(sme_auth_timer, wpa_s, NULL);
960}
961
962
963void sme_disassoc_while_authenticating(struct wpa_supplicant *wpa_s,
964 const u8 *prev_pending_bssid)
965{
966 /*
967 * mac80211-workaround to force deauth on failed auth cmd,
968 * requires us to remain in authenticating state to allow the
969 * second authentication attempt to be continued properly.
970 */
971 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Allow pending authentication "
972 "to proceed after disconnection event");
973 wpa_supplicant_set_state(wpa_s, WPA_AUTHENTICATING);
974 os_memcpy(wpa_s->pending_bssid, prev_pending_bssid, ETH_ALEN);
975
976 /*
977 * Re-arm authentication timer in case auth fails for whatever reason.
978 */
979 eloop_cancel_timeout(sme_auth_timer, wpa_s, NULL);
980 eloop_register_timeout(SME_AUTH_TIMEOUT, 0, sme_auth_timer, wpa_s,
981 NULL);
982}
983
984
985void sme_deinit(struct wpa_supplicant *wpa_s)
986{
987 os_free(wpa_s->sme.ft_ies);
988 wpa_s->sme.ft_ies = NULL;
989 wpa_s->sme.ft_ies_len = 0;
990#ifdef CONFIG_IEEE80211W
991 sme_stop_sa_query(wpa_s);
992#endif /* CONFIG_IEEE80211W */
Dmitry Shmidta54fa5f2013-01-15 13:53:35 -0800993#ifdef CONFIG_SAE
994 wpabuf_free(wpa_s->sme.sae_token);
995 wpa_s->sme.sae_token = NULL;
996 sae_clear_data(&wpa_s->sme.sae);
997#endif /* CONFIG_SAE */
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -0700998
999 eloop_cancel_timeout(sme_assoc_timer, wpa_s, NULL);
1000 eloop_cancel_timeout(sme_auth_timer, wpa_s, NULL);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001001 eloop_cancel_timeout(sme_obss_scan_timeout, wpa_s, NULL);
1002}
1003
1004
1005static void sme_send_2040_bss_coex(struct wpa_supplicant *wpa_s,
1006 const u8 *chan_list, u8 num_channels,
1007 u8 num_intol)
1008{
1009 struct ieee80211_2040_bss_coex_ie *bc_ie;
1010 struct ieee80211_2040_intol_chan_report *ic_report;
1011 struct wpabuf *buf;
1012
Dmitry Shmidtd11f0192014-03-24 12:09:47 -07001013 wpa_printf(MSG_DEBUG, "SME: Send 20/40 BSS Coexistence to " MACSTR
1014 " (num_channels=%u num_intol=%u)",
1015 MAC2STR(wpa_s->bssid), num_channels, num_intol);
1016 wpa_hexdump(MSG_DEBUG, "SME: 20/40 BSS Intolerant Channels",
1017 chan_list, num_channels);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001018
1019 buf = wpabuf_alloc(2 + /* action.category + action_code */
1020 sizeof(struct ieee80211_2040_bss_coex_ie) +
1021 sizeof(struct ieee80211_2040_intol_chan_report) +
1022 num_channels);
1023 if (buf == NULL)
1024 return;
1025
1026 wpabuf_put_u8(buf, WLAN_ACTION_PUBLIC);
1027 wpabuf_put_u8(buf, WLAN_PA_20_40_BSS_COEX);
1028
1029 bc_ie = wpabuf_put(buf, sizeof(*bc_ie));
1030 bc_ie->element_id = WLAN_EID_20_40_BSS_COEXISTENCE;
1031 bc_ie->length = 1;
1032 if (num_intol)
1033 bc_ie->coex_param |= WLAN_20_40_BSS_COEX_20MHZ_WIDTH_REQ;
1034
1035 if (num_channels > 0) {
1036 ic_report = wpabuf_put(buf, sizeof(*ic_report));
1037 ic_report->element_id = WLAN_EID_20_40_BSS_INTOLERANT;
1038 ic_report->length = num_channels + 1;
1039 ic_report->op_class = 0;
1040 os_memcpy(wpabuf_put(buf, num_channels), chan_list,
1041 num_channels);
1042 }
1043
1044 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
1045 wpa_s->own_addr, wpa_s->bssid,
1046 wpabuf_head(buf), wpabuf_len(buf), 0) < 0) {
1047 wpa_msg(wpa_s, MSG_INFO,
1048 "SME: Failed to send 20/40 BSS Coexistence frame");
1049 }
1050
1051 wpabuf_free(buf);
1052}
1053
1054
Dmitry Shmidt04949592012-07-19 12:16:46 -07001055int sme_proc_obss_scan(struct wpa_supplicant *wpa_s)
1056{
1057 struct wpa_bss *bss;
1058 const u8 *ie;
1059 u16 ht_cap;
1060 u8 chan_list[P2P_MAX_CHANNELS], channel;
1061 u8 num_channels = 0, num_intol = 0, i;
1062
1063 if (!wpa_s->sme.sched_obss_scan)
1064 return 0;
1065
1066 wpa_s->sme.sched_obss_scan = 0;
1067 if (!wpa_s->current_bss || wpa_s->wpa_state != WPA_COMPLETED)
1068 return 1;
1069
1070 /*
1071 * Check whether AP uses regulatory triplet or channel triplet in
1072 * country info. Right now the operating class of the BSS channel
1073 * width trigger event is "unknown" (IEEE Std 802.11-2012 10.15.12),
1074 * based on the assumption that operating class triplet is not used in
1075 * beacon frame. If the First Channel Number/Operating Extension
1076 * Identifier octet has a positive integer value of 201 or greater,
1077 * then its operating class triplet.
1078 *
1079 * TODO: If Supported Operating Classes element is present in beacon
1080 * frame, have to lookup operating class in Annex E and fill them in
1081 * 2040 coex frame.
1082 */
1083 ie = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_COUNTRY);
1084 if (ie && (ie[1] >= 6) && (ie[5] >= 201))
1085 return 1;
1086
1087 os_memset(chan_list, 0, sizeof(chan_list));
1088
1089 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1090 /* Skip other band bss */
Dmitry Shmidt4b060592013-04-29 16:42:49 -07001091 enum hostapd_hw_mode mode;
1092 mode = ieee80211_freq_to_chan(bss->freq, &channel);
1093 if (mode != HOSTAPD_MODE_IEEE80211G &&
1094 mode != HOSTAPD_MODE_IEEE80211B)
Dmitry Shmidt04949592012-07-19 12:16:46 -07001095 continue;
1096
1097 ie = wpa_bss_get_ie(bss, WLAN_EID_HT_CAP);
1098 ht_cap = (ie && (ie[1] == 26)) ? WPA_GET_LE16(ie + 2) : 0;
Dmitry Shmidtd11f0192014-03-24 12:09:47 -07001099 wpa_printf(MSG_DEBUG, "SME OBSS scan BSS " MACSTR
1100 " freq=%u chan=%u ht_cap=0x%x",
1101 MAC2STR(bss->bssid), bss->freq, channel, ht_cap);
Dmitry Shmidt04949592012-07-19 12:16:46 -07001102
1103 if (!ht_cap || (ht_cap & HT_CAP_INFO_40MHZ_INTOLERANT)) {
Dmitry Shmidtd11f0192014-03-24 12:09:47 -07001104 if (ht_cap & HT_CAP_INFO_40MHZ_INTOLERANT)
1105 num_intol++;
1106
Dmitry Shmidt04949592012-07-19 12:16:46 -07001107 /* Check whether the channel is already considered */
1108 for (i = 0; i < num_channels; i++) {
1109 if (channel == chan_list[i])
1110 break;
1111 }
1112 if (i != num_channels)
1113 continue;
1114
Dmitry Shmidt04949592012-07-19 12:16:46 -07001115 chan_list[num_channels++] = channel;
1116 }
1117 }
1118
1119 sme_send_2040_bss_coex(wpa_s, chan_list, num_channels, num_intol);
1120 return 1;
1121}
1122
1123
1124static struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
1125 u16 num_modes,
1126 enum hostapd_hw_mode mode)
1127{
1128 u16 i;
1129
1130 for (i = 0; i < num_modes; i++) {
1131 if (modes[i].mode == mode)
1132 return &modes[i];
1133 }
1134
1135 return NULL;
1136}
1137
1138
1139static void wpa_setband_scan_freqs_list(struct wpa_supplicant *wpa_s,
1140 enum hostapd_hw_mode band,
1141 struct wpa_driver_scan_params *params)
1142{
1143 /* Include only supported channels for the specified band */
1144 struct hostapd_hw_modes *mode;
1145 int count, i;
1146
1147 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, band);
1148 if (mode == NULL) {
1149 /* No channels supported in this band - use empty list */
1150 params->freqs = os_zalloc(sizeof(int));
1151 return;
1152 }
1153
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001154 params->freqs = os_calloc(mode->num_channels + 1, sizeof(int));
Dmitry Shmidt04949592012-07-19 12:16:46 -07001155 if (params->freqs == NULL)
1156 return;
1157 for (count = 0, i = 0; i < mode->num_channels; i++) {
1158 if (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED)
1159 continue;
1160 params->freqs[count++] = mode->channels[i].freq;
1161 }
1162}
1163
1164
1165static void sme_obss_scan_timeout(void *eloop_ctx, void *timeout_ctx)
1166{
1167 struct wpa_supplicant *wpa_s = eloop_ctx;
1168 struct wpa_driver_scan_params params;
1169
1170 if (!wpa_s->current_bss) {
1171 wpa_printf(MSG_DEBUG, "SME OBSS: Ignore scan request");
1172 return;
1173 }
1174
1175 os_memset(&params, 0, sizeof(params));
1176 wpa_setband_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211G, &params);
Dmitry Shmidt2271d3f2014-06-23 12:16:31 -07001177 params.low_priority = 1;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001178 wpa_printf(MSG_DEBUG, "SME OBSS: Request an OBSS scan");
1179
1180 if (wpa_supplicant_trigger_scan(wpa_s, &params))
1181 wpa_printf(MSG_DEBUG, "SME OBSS: Failed to trigger scan");
1182 else
1183 wpa_s->sme.sched_obss_scan = 1;
1184 os_free(params.freqs);
1185
1186 eloop_register_timeout(wpa_s->sme.obss_scan_int, 0,
1187 sme_obss_scan_timeout, wpa_s, NULL);
1188}
1189
1190
1191void sme_sched_obss_scan(struct wpa_supplicant *wpa_s, int enable)
1192{
1193 const u8 *ie;
1194 struct wpa_bss *bss = wpa_s->current_bss;
1195 struct wpa_ssid *ssid = wpa_s->current_ssid;
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001196 struct hostapd_hw_modes *hw_mode = NULL;
1197 int i;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001198
1199 eloop_cancel_timeout(sme_obss_scan_timeout, wpa_s, NULL);
1200 wpa_s->sme.sched_obss_scan = 0;
1201 if (!enable)
1202 return;
1203
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001204 /*
1205 * Schedule OBSS scan if driver is using station SME in wpa_supplicant
1206 * or it expects OBSS scan to be performed by wpa_supplicant.
1207 */
1208 if (!((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) ||
1209 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OBSS_SCAN)) ||
1210 ssid == NULL || ssid->mode != IEEE80211_MODE_INFRA)
1211 return;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001212
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001213 if (!wpa_s->hw.modes)
1214 return;
1215
1216 /* only HT caps in 11g mode are relevant */
1217 for (i = 0; i < wpa_s->hw.num_modes; i++) {
1218 hw_mode = &wpa_s->hw.modes[i];
1219 if (hw_mode->mode == HOSTAPD_MODE_IEEE80211G)
1220 break;
1221 }
1222
1223 /* Driver does not support HT40 for 11g or doesn't have 11g. */
1224 if (i == wpa_s->hw.num_modes || !hw_mode ||
1225 !(hw_mode->ht_capab & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
1226 return;
Dmitry Shmidt04949592012-07-19 12:16:46 -07001227
1228 if (bss == NULL || bss->freq < 2400 || bss->freq > 2500)
1229 return; /* Not associated on 2.4 GHz band */
1230
1231 /* Check whether AP supports HT40 */
1232 ie = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_HT_CAP);
1233 if (!ie || ie[1] < 2 ||
1234 !(WPA_GET_LE16(ie + 2) & HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
1235 return; /* AP does not support HT40 */
1236
1237 ie = wpa_bss_get_ie(wpa_s->current_bss,
1238 WLAN_EID_OVERLAPPING_BSS_SCAN_PARAMS);
1239 if (!ie || ie[1] < 14)
1240 return; /* AP does not request OBSS scans */
1241
1242 wpa_s->sme.obss_scan_int = WPA_GET_LE16(ie + 6);
1243 if (wpa_s->sme.obss_scan_int < 10) {
1244 wpa_printf(MSG_DEBUG, "SME: Invalid OBSS Scan Interval %u "
1245 "replaced with the minimum 10 sec",
1246 wpa_s->sme.obss_scan_int);
1247 wpa_s->sme.obss_scan_int = 10;
1248 }
1249 wpa_printf(MSG_DEBUG, "SME: OBSS Scan Interval %u sec",
1250 wpa_s->sme.obss_scan_int);
1251 eloop_register_timeout(wpa_s->sme.obss_scan_int, 0,
1252 sme_obss_scan_timeout, wpa_s, NULL);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001253}
1254
1255
1256#ifdef CONFIG_IEEE80211W
1257
1258static const unsigned int sa_query_max_timeout = 1000;
1259static const unsigned int sa_query_retry_timeout = 201;
1260
1261static int sme_check_sa_query_timeout(struct wpa_supplicant *wpa_s)
1262{
1263 u32 tu;
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -08001264 struct os_reltime now, passed;
1265 os_get_reltime(&now);
1266 os_reltime_sub(&now, &wpa_s->sme.sa_query_start, &passed);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001267 tu = (passed.sec * 1000000 + passed.usec) / 1024;
1268 if (sa_query_max_timeout < tu) {
1269 wpa_dbg(wpa_s, MSG_DEBUG, "SME: SA Query timed out");
1270 sme_stop_sa_query(wpa_s);
1271 wpa_supplicant_deauthenticate(
1272 wpa_s, WLAN_REASON_PREV_AUTH_NOT_VALID);
1273 return 1;
1274 }
1275
1276 return 0;
1277}
1278
1279
1280static void sme_send_sa_query_req(struct wpa_supplicant *wpa_s,
1281 const u8 *trans_id)
1282{
1283 u8 req[2 + WLAN_SA_QUERY_TR_ID_LEN];
1284 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Sending SA Query Request to "
1285 MACSTR, MAC2STR(wpa_s->bssid));
1286 wpa_hexdump(MSG_DEBUG, "SME: SA Query Transaction ID",
1287 trans_id, WLAN_SA_QUERY_TR_ID_LEN);
1288 req[0] = WLAN_ACTION_SA_QUERY;
1289 req[1] = WLAN_SA_QUERY_REQUEST;
1290 os_memcpy(req + 2, trans_id, WLAN_SA_QUERY_TR_ID_LEN);
1291 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
1292 wpa_s->own_addr, wpa_s->bssid,
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001293 req, sizeof(req), 0) < 0)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001294 wpa_msg(wpa_s, MSG_INFO, "SME: Failed to send SA Query "
1295 "Request");
1296}
1297
1298
1299static void sme_sa_query_timer(void *eloop_ctx, void *timeout_ctx)
1300{
1301 struct wpa_supplicant *wpa_s = eloop_ctx;
1302 unsigned int timeout, sec, usec;
1303 u8 *trans_id, *nbuf;
1304
1305 if (wpa_s->sme.sa_query_count > 0 &&
1306 sme_check_sa_query_timeout(wpa_s))
1307 return;
1308
Dmitry Shmidt61d9df32012-08-29 16:22:06 -07001309 nbuf = os_realloc_array(wpa_s->sme.sa_query_trans_id,
1310 wpa_s->sme.sa_query_count + 1,
1311 WLAN_SA_QUERY_TR_ID_LEN);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001312 if (nbuf == NULL)
1313 return;
1314 if (wpa_s->sme.sa_query_count == 0) {
1315 /* Starting a new SA Query procedure */
Dmitry Shmidtfb79edc2014-01-10 10:45:54 -08001316 os_get_reltime(&wpa_s->sme.sa_query_start);
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001317 }
1318 trans_id = nbuf + wpa_s->sme.sa_query_count * WLAN_SA_QUERY_TR_ID_LEN;
1319 wpa_s->sme.sa_query_trans_id = nbuf;
1320 wpa_s->sme.sa_query_count++;
1321
Dmitry Shmidt661b4f72014-09-29 14:58:27 -07001322 if (os_get_random(trans_id, WLAN_SA_QUERY_TR_ID_LEN) < 0) {
1323 wpa_printf(MSG_DEBUG, "Could not generate SA Query ID");
1324 return;
1325 }
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001326
1327 timeout = sa_query_retry_timeout;
1328 sec = ((timeout / 1000) * 1024) / 1000;
1329 usec = (timeout % 1000) * 1024;
1330 eloop_register_timeout(sec, usec, sme_sa_query_timer, wpa_s, NULL);
1331
1332 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Association SA Query attempt %d",
1333 wpa_s->sme.sa_query_count);
1334
1335 sme_send_sa_query_req(wpa_s, trans_id);
1336}
1337
1338
1339static void sme_start_sa_query(struct wpa_supplicant *wpa_s)
1340{
1341 sme_sa_query_timer(wpa_s, NULL);
1342}
1343
1344
Dmitry Shmidt1f69aa52012-01-24 16:10:04 -08001345static void sme_stop_sa_query(struct wpa_supplicant *wpa_s)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001346{
1347 eloop_cancel_timeout(sme_sa_query_timer, wpa_s, NULL);
1348 os_free(wpa_s->sme.sa_query_trans_id);
1349 wpa_s->sme.sa_query_trans_id = NULL;
1350 wpa_s->sme.sa_query_count = 0;
1351}
1352
1353
1354void sme_event_unprot_disconnect(struct wpa_supplicant *wpa_s, const u8 *sa,
1355 const u8 *da, u16 reason_code)
1356{
1357 struct wpa_ssid *ssid;
Dmitry Shmidt0c08fdc2014-06-20 10:16:40 -07001358 struct os_reltime now;
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001359
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001360 if (wpa_s->wpa_state != WPA_COMPLETED)
1361 return;
1362 ssid = wpa_s->current_ssid;
Dmitry Shmidtd5e49232012-12-03 15:08:10 -08001363 if (ssid == NULL ||
1364 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ?
1365 wpa_s->conf->pmf : ssid->ieee80211w) == NO_MGMT_FRAME_PROTECTION)
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001366 return;
1367 if (os_memcmp(sa, wpa_s->bssid, ETH_ALEN) != 0)
1368 return;
1369 if (reason_code != WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA &&
1370 reason_code != WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA)
1371 return;
1372 if (wpa_s->sme.sa_query_count > 0)
1373 return;
1374
Dmitry Shmidt0c08fdc2014-06-20 10:16:40 -07001375 os_get_reltime(&now);
1376 if (wpa_s->sme.last_unprot_disconnect.sec &&
1377 !os_reltime_expired(&now, &wpa_s->sme.last_unprot_disconnect, 10))
1378 return; /* limit SA Query procedure frequency */
1379 wpa_s->sme.last_unprot_disconnect = now;
1380
Dmitry Shmidt8d520ff2011-05-09 14:06:53 -07001381 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Unprotected disconnect dropped - "
1382 "possible AP/STA state mismatch - trigger SA Query");
1383 sme_start_sa_query(wpa_s);
1384}
1385
1386
1387void sme_sa_query_rx(struct wpa_supplicant *wpa_s, const u8 *sa,
1388 const u8 *data, size_t len)
1389{
1390 int i;
1391
1392 if (wpa_s->sme.sa_query_trans_id == NULL ||
1393 len < 1 + WLAN_SA_QUERY_TR_ID_LEN ||
1394 data[0] != WLAN_SA_QUERY_RESPONSE)
1395 return;
1396 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Received SA Query response from "
1397 MACSTR " (trans_id %02x%02x)", MAC2STR(sa), data[1], data[2]);
1398
1399 if (os_memcmp(sa, wpa_s->bssid, ETH_ALEN) != 0)
1400 return;
1401
1402 for (i = 0; i < wpa_s->sme.sa_query_count; i++) {
1403 if (os_memcmp(wpa_s->sme.sa_query_trans_id +
1404 i * WLAN_SA_QUERY_TR_ID_LEN,
1405 data + 1, WLAN_SA_QUERY_TR_ID_LEN) == 0)
1406 break;
1407 }
1408
1409 if (i >= wpa_s->sme.sa_query_count) {
1410 wpa_dbg(wpa_s, MSG_DEBUG, "SME: No matching SA Query "
1411 "transaction identifier found");
1412 return;
1413 }
1414
1415 wpa_dbg(wpa_s, MSG_DEBUG, "SME: Reply to pending SA Query received "
1416 "from " MACSTR, MAC2STR(sa));
1417 sme_stop_sa_query(wpa_s);
1418}
1419
1420#endif /* CONFIG_IEEE80211W */