]> git.ipfire.org Git - thirdparty/hostap.git/blob - wpa_supplicant/wpa_supplicant.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Provide option to configure BSSID hint for a network
[thirdparty/hostap.git] / wpa_supplicant / wpa_supplicant.c
1 /*
2 * WPA Supplicant
3 * Copyright (c) 2003-2017, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 *
8 * This file implements functions for registering and unregistering
9 * %wpa_supplicant interfaces. In addition, this file contains number of
10 * functions for managing network connections.
11 */
12
13 #include "includes.h"
14 #ifdef CONFIG_MATCH_IFACE
15 #include <net/if.h>
16 #include <fnmatch.h>
17 #endif /* CONFIG_MATCH_IFACE */
18
19 #include "common.h"
20 #include "crypto/random.h"
21 #include "crypto/sha1.h"
22 #include "eapol_supp/eapol_supp_sm.h"
23 #include "eap_peer/eap.h"
24 #include "eap_peer/eap_proxy.h"
25 #include "eap_server/eap_methods.h"
26 #include "rsn_supp/wpa.h"
27 #include "eloop.h"
28 #include "config.h"
29 #include "utils/ext_password.h"
30 #include "l2_packet/l2_packet.h"
31 #include "wpa_supplicant_i.h"
32 #include "driver_i.h"
33 #include "ctrl_iface.h"
34 #include "pcsc_funcs.h"
35 #include "common/version.h"
36 #include "rsn_supp/preauth.h"
37 #include "rsn_supp/pmksa_cache.h"
38 #include "common/wpa_ctrl.h"
39 #include "common/ieee802_11_defs.h"
40 #include "common/hw_features_common.h"
41 #include "p2p/p2p.h"
42 #include "fst/fst.h"
43 #include "blacklist.h"
44 #include "wpas_glue.h"
45 #include "wps_supplicant.h"
46 #include "ibss_rsn.h"
47 #include "sme.h"
48 #include "gas_query.h"
49 #include "ap.h"
50 #include "p2p_supplicant.h"
51 #include "wifi_display.h"
52 #include "notify.h"
53 #include "bgscan.h"
54 #include "autoscan.h"
55 #include "bss.h"
56 #include "scan.h"
57 #include "offchannel.h"
58 #include "hs20_supplicant.h"
59 #include "wnm_sta.h"
60 #include "wpas_kay.h"
61 #include "mesh.h"
62
63 const char *const wpa_supplicant_version =
64 "wpa_supplicant v" VERSION_STR "\n"
65 "Copyright (c) 2003-2017, Jouni Malinen <j@w1.fi> and contributors";
66
67 const char *const wpa_supplicant_license =
68 "This software may be distributed under the terms of the BSD license.\n"
69 "See README for more details.\n"
70 #ifdef EAP_TLS_OPENSSL
71 "\nThis product includes software developed by the OpenSSL Project\n"
72 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
73 #endif /* EAP_TLS_OPENSSL */
74 ;
75
76 #ifndef CONFIG_NO_STDOUT_DEBUG
77 /* Long text divided into parts in order to fit in C89 strings size limits. */
78 const char *const wpa_supplicant_full_license1 =
79 "";
80 const char *const wpa_supplicant_full_license2 =
81 "This software may be distributed under the terms of the BSD license.\n"
82 "\n"
83 "Redistribution and use in source and binary forms, with or without\n"
84 "modification, are permitted provided that the following conditions are\n"
85 "met:\n"
86 "\n";
87 const char *const wpa_supplicant_full_license3 =
88 "1. Redistributions of source code must retain the above copyright\n"
89 " notice, this list of conditions and the following disclaimer.\n"
90 "\n"
91 "2. Redistributions in binary form must reproduce the above copyright\n"
92 " notice, this list of conditions and the following disclaimer in the\n"
93 " documentation and/or other materials provided with the distribution.\n"
94 "\n";
95 const char *const wpa_supplicant_full_license4 =
96 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
97 " names of its contributors may be used to endorse or promote products\n"
98 " derived from this software without specific prior written permission.\n"
99 "\n"
100 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
101 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
102 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
103 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
104 const char *const wpa_supplicant_full_license5 =
105 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
106 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
107 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
108 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
109 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
110 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
111 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
112 "\n";
113 #endif /* CONFIG_NO_STDOUT_DEBUG */
114
115 /* Configure default/group WEP keys for static WEP */
116 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
117 {
118 int i, set = 0;
119
120 for (i = 0; i < NUM_WEP_KEYS; i++) {
121 if (ssid->wep_key_len[i] == 0)
122 continue;
123
124 set = 1;
125 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
126 i, i == ssid->wep_tx_keyidx, NULL, 0,
127 ssid->wep_key[i], ssid->wep_key_len[i]);
128 }
129
130 return set;
131 }
132
133
134 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
135 struct wpa_ssid *ssid)
136 {
137 u8 key[32];
138 size_t keylen;
139 enum wpa_alg alg;
140 u8 seq[6] = { 0 };
141 int ret;
142
143 /* IBSS/WPA-None uses only one key (Group) for both receiving and
144 * sending unicast and multicast packets. */
145
146 if (ssid->mode != WPAS_MODE_IBSS) {
147 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
148 "IBSS/ad-hoc) for WPA-None", ssid->mode);
149 return -1;
150 }
151
152 if (!ssid->psk_set) {
153 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
154 "WPA-None");
155 return -1;
156 }
157
158 switch (wpa_s->group_cipher) {
159 case WPA_CIPHER_CCMP:
160 os_memcpy(key, ssid->psk, 16);
161 keylen = 16;
162 alg = WPA_ALG_CCMP;
163 break;
164 case WPA_CIPHER_GCMP:
165 os_memcpy(key, ssid->psk, 16);
166 keylen = 16;
167 alg = WPA_ALG_GCMP;
168 break;
169 case WPA_CIPHER_TKIP:
170 /* WPA-None uses the same Michael MIC key for both TX and RX */
171 os_memcpy(key, ssid->psk, 16 + 8);
172 os_memcpy(key + 16 + 8, ssid->psk + 16, 8);
173 keylen = 32;
174 alg = WPA_ALG_TKIP;
175 break;
176 default:
177 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
178 "WPA-None", wpa_s->group_cipher);
179 return -1;
180 }
181
182 /* TODO: should actually remember the previously used seq#, both for TX
183 * and RX from each STA.. */
184
185 ret = wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
186 os_memset(key, 0, sizeof(key));
187 return ret;
188 }
189
190
191 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
192 {
193 struct wpa_supplicant *wpa_s = eloop_ctx;
194 const u8 *bssid = wpa_s->bssid;
195 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
196 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
197 wpa_s->wpa_state == WPA_ASSOCIATING))
198 bssid = wpa_s->pending_bssid;
199 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
200 MAC2STR(bssid));
201 wpa_blacklist_add(wpa_s, bssid);
202 wpa_sm_notify_disassoc(wpa_s->wpa);
203 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
204 wpa_s->reassociate = 1;
205
206 /*
207 * If we timed out, the AP or the local radio may be busy.
208 * So, wait a second until scanning again.
209 */
210 wpa_supplicant_req_scan(wpa_s, 1, 0);
211 }
212
213
214 /**
215 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
216 * @wpa_s: Pointer to wpa_supplicant data
217 * @sec: Number of seconds after which to time out authentication
218 * @usec: Number of microseconds after which to time out authentication
219 *
220 * This function is used to schedule a timeout for the current authentication
221 * attempt.
222 */
223 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
224 int sec, int usec)
225 {
226 if (wpa_s->conf->ap_scan == 0 &&
227 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
228 return;
229
230 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
231 "%d usec", sec, usec);
232 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
233 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
234 }
235
236
237 /**
238 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
239 * @wpa_s: Pointer to wpa_supplicant data
240 *
241 * This function is used to cancel authentication timeout scheduled with
242 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
243 * been completed.
244 */
245 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
246 {
247 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
248 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
249 wpa_blacklist_del(wpa_s, wpa_s->bssid);
250 }
251
252
253 /**
254 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
255 * @wpa_s: Pointer to wpa_supplicant data
256 *
257 * This function is used to configure EAPOL state machine based on the selected
258 * authentication mode.
259 */
260 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
261 {
262 #ifdef IEEE8021X_EAPOL
263 struct eapol_config eapol_conf;
264 struct wpa_ssid *ssid = wpa_s->current_ssid;
265
266 #ifdef CONFIG_IBSS_RSN
267 if (ssid->mode == WPAS_MODE_IBSS &&
268 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
269 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
270 /*
271 * RSN IBSS authentication is per-STA and we can disable the
272 * per-BSSID EAPOL authentication.
273 */
274 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
275 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
276 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
277 return;
278 }
279 #endif /* CONFIG_IBSS_RSN */
280
281 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
282 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
283
284 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
285 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
286 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
287 else
288 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
289
290 os_memset(&eapol_conf, 0, sizeof(eapol_conf));
291 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
292 eapol_conf.accept_802_1x_keys = 1;
293 eapol_conf.required_keys = 0;
294 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
295 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
296 }
297 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
298 eapol_conf.required_keys |=
299 EAPOL_REQUIRE_KEY_BROADCAST;
300 }
301
302 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
303 eapol_conf.required_keys = 0;
304 }
305 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
306 eapol_conf.workaround = ssid->eap_workaround;
307 eapol_conf.eap_disabled =
308 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
309 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
310 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
311 eapol_conf.external_sim = wpa_s->conf->external_sim;
312
313 #ifdef CONFIG_WPS
314 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
315 eapol_conf.wps |= EAPOL_LOCAL_WPS_IN_USE;
316 if (wpa_s->current_bss) {
317 struct wpabuf *ie;
318 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
319 WPS_IE_VENDOR_TYPE);
320 if (ie) {
321 if (wps_is_20(ie))
322 eapol_conf.wps |=
323 EAPOL_PEER_IS_WPS20_AP;
324 wpabuf_free(ie);
325 }
326 }
327 }
328 #endif /* CONFIG_WPS */
329
330 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
331
332 #ifdef CONFIG_MACSEC
333 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE && ssid->mka_psk_set)
334 ieee802_1x_create_preshared_mka(wpa_s, ssid);
335 else
336 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
337 #endif /* CONFIG_MACSEC */
338 #endif /* IEEE8021X_EAPOL */
339 }
340
341
342 /**
343 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
344 * @wpa_s: Pointer to wpa_supplicant data
345 * @ssid: Configuration data for the network
346 *
347 * This function is used to configure WPA state machine and related parameters
348 * to a mode where WPA is not enabled. This is called as part of the
349 * authentication configuration when the selected network does not use WPA.
350 */
351 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
352 struct wpa_ssid *ssid)
353 {
354 int i;
355
356 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
357 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
358 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
359 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
360 else
361 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
362 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
363 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
364 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
365 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
366 wpa_s->group_cipher = WPA_CIPHER_NONE;
367 wpa_s->mgmt_group_cipher = 0;
368
369 for (i = 0; i < NUM_WEP_KEYS; i++) {
370 if (ssid->wep_key_len[i] > 5) {
371 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
372 wpa_s->group_cipher = WPA_CIPHER_WEP104;
373 break;
374 } else if (ssid->wep_key_len[i] > 0) {
375 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
376 wpa_s->group_cipher = WPA_CIPHER_WEP40;
377 break;
378 }
379 }
380
381 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
382 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
383 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
384 wpa_s->pairwise_cipher);
385 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
386 #ifdef CONFIG_IEEE80211W
387 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
388 wpa_s->mgmt_group_cipher);
389 #endif /* CONFIG_IEEE80211W */
390
391 pmksa_cache_clear_current(wpa_s->wpa);
392 }
393
394
395 void free_hw_features(struct wpa_supplicant *wpa_s)
396 {
397 int i;
398 if (wpa_s->hw.modes == NULL)
399 return;
400
401 for (i = 0; i < wpa_s->hw.num_modes; i++) {
402 os_free(wpa_s->hw.modes[i].channels);
403 os_free(wpa_s->hw.modes[i].rates);
404 }
405
406 os_free(wpa_s->hw.modes);
407 wpa_s->hw.modes = NULL;
408 }
409
410
411 static void free_bss_tmp_disallowed(struct wpa_supplicant *wpa_s)
412 {
413 struct wpa_bss_tmp_disallowed *bss, *prev;
414
415 dl_list_for_each_safe(bss, prev, &wpa_s->bss_tmp_disallowed,
416 struct wpa_bss_tmp_disallowed, list) {
417 dl_list_del(&bss->list);
418 os_free(bss);
419 }
420 }
421
422
423 void wpas_flush_fils_hlp_req(struct wpa_supplicant *wpa_s)
424 {
425 struct fils_hlp_req *req;
426
427 while ((req = dl_list_first(&wpa_s->fils_hlp_req, struct fils_hlp_req,
428 list)) != NULL) {
429 dl_list_del(&req->list);
430 wpabuf_free(req->pkt);
431 os_free(req);
432 }
433 }
434
435
436 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
437 {
438 int i;
439
440 bgscan_deinit(wpa_s);
441 autoscan_deinit(wpa_s);
442 scard_deinit(wpa_s->scard);
443 wpa_s->scard = NULL;
444 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
445 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
446 l2_packet_deinit(wpa_s->l2);
447 wpa_s->l2 = NULL;
448 if (wpa_s->l2_br) {
449 l2_packet_deinit(wpa_s->l2_br);
450 wpa_s->l2_br = NULL;
451 }
452 #ifdef CONFIG_TESTING_OPTIONS
453 l2_packet_deinit(wpa_s->l2_test);
454 wpa_s->l2_test = NULL;
455 os_free(wpa_s->get_pref_freq_list_override);
456 wpa_s->get_pref_freq_list_override = NULL;
457 #endif /* CONFIG_TESTING_OPTIONS */
458
459 if (wpa_s->conf != NULL) {
460 struct wpa_ssid *ssid;
461 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
462 wpas_notify_network_removed(wpa_s, ssid);
463 }
464
465 os_free(wpa_s->confname);
466 wpa_s->confname = NULL;
467
468 os_free(wpa_s->confanother);
469 wpa_s->confanother = NULL;
470
471 wpa_sm_set_eapol(wpa_s->wpa, NULL);
472 eapol_sm_deinit(wpa_s->eapol);
473 wpa_s->eapol = NULL;
474
475 rsn_preauth_deinit(wpa_s->wpa);
476
477 #ifdef CONFIG_TDLS
478 wpa_tdls_deinit(wpa_s->wpa);
479 #endif /* CONFIG_TDLS */
480
481 wmm_ac_clear_saved_tspecs(wpa_s);
482 pmksa_candidate_free(wpa_s->wpa);
483 wpa_sm_deinit(wpa_s->wpa);
484 wpa_s->wpa = NULL;
485 wpa_blacklist_clear(wpa_s);
486
487 wpa_bss_deinit(wpa_s);
488
489 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
490 wpa_supplicant_cancel_scan(wpa_s);
491 wpa_supplicant_cancel_auth_timeout(wpa_s);
492 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
493 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
494 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
495 wpa_s, NULL);
496 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
497
498 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
499
500 wpas_wps_deinit(wpa_s);
501
502 wpabuf_free(wpa_s->pending_eapol_rx);
503 wpa_s->pending_eapol_rx = NULL;
504
505 #ifdef CONFIG_IBSS_RSN
506 ibss_rsn_deinit(wpa_s->ibss_rsn);
507 wpa_s->ibss_rsn = NULL;
508 #endif /* CONFIG_IBSS_RSN */
509
510 sme_deinit(wpa_s);
511
512 #ifdef CONFIG_AP
513 wpa_supplicant_ap_deinit(wpa_s);
514 #endif /* CONFIG_AP */
515
516 wpas_p2p_deinit(wpa_s);
517
518 #ifdef CONFIG_OFFCHANNEL
519 offchannel_deinit(wpa_s);
520 #endif /* CONFIG_OFFCHANNEL */
521
522 wpa_supplicant_cancel_sched_scan(wpa_s);
523
524 os_free(wpa_s->next_scan_freqs);
525 wpa_s->next_scan_freqs = NULL;
526
527 os_free(wpa_s->manual_scan_freqs);
528 wpa_s->manual_scan_freqs = NULL;
529 os_free(wpa_s->select_network_scan_freqs);
530 wpa_s->select_network_scan_freqs = NULL;
531
532 os_free(wpa_s->manual_sched_scan_freqs);
533 wpa_s->manual_sched_scan_freqs = NULL;
534
535 wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
536
537 /*
538 * Need to remove any pending gas-query radio work before the
539 * gas_query_deinit() call because gas_query::work has not yet been set
540 * for works that have not been started. gas_query_free() will be unable
541 * to cancel such pending radio works and once the pending gas-query
542 * radio work eventually gets removed, the deinit notification call to
543 * gas_query_start_cb() would result in dereferencing freed memory.
544 */
545 if (wpa_s->radio)
546 radio_remove_works(wpa_s, "gas-query", 0);
547 gas_query_deinit(wpa_s->gas);
548 wpa_s->gas = NULL;
549
550 free_hw_features(wpa_s);
551
552 ieee802_1x_dealloc_kay_sm(wpa_s);
553
554 os_free(wpa_s->bssid_filter);
555 wpa_s->bssid_filter = NULL;
556
557 os_free(wpa_s->disallow_aps_bssid);
558 wpa_s->disallow_aps_bssid = NULL;
559 os_free(wpa_s->disallow_aps_ssid);
560 wpa_s->disallow_aps_ssid = NULL;
561
562 wnm_bss_keep_alive_deinit(wpa_s);
563 #ifdef CONFIG_WNM
564 wnm_deallocate_memory(wpa_s);
565 #endif /* CONFIG_WNM */
566
567 ext_password_deinit(wpa_s->ext_pw);
568 wpa_s->ext_pw = NULL;
569
570 wpabuf_free(wpa_s->last_gas_resp);
571 wpa_s->last_gas_resp = NULL;
572 wpabuf_free(wpa_s->prev_gas_resp);
573 wpa_s->prev_gas_resp = NULL;
574
575 os_free(wpa_s->last_scan_res);
576 wpa_s->last_scan_res = NULL;
577
578 #ifdef CONFIG_HS20
579 if (wpa_s->drv_priv)
580 wpa_drv_configure_frame_filters(wpa_s, 0);
581 hs20_deinit(wpa_s);
582 #endif /* CONFIG_HS20 */
583
584 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
585 wpabuf_free(wpa_s->vendor_elem[i]);
586 wpa_s->vendor_elem[i] = NULL;
587 }
588
589 wmm_ac_notify_disassoc(wpa_s);
590
591 wpa_s->sched_scan_plans_num = 0;
592 os_free(wpa_s->sched_scan_plans);
593 wpa_s->sched_scan_plans = NULL;
594
595 #ifdef CONFIG_MBO
596 wpa_s->non_pref_chan_num = 0;
597 os_free(wpa_s->non_pref_chan);
598 wpa_s->non_pref_chan = NULL;
599 #endif /* CONFIG_MBO */
600
601 free_bss_tmp_disallowed(wpa_s);
602
603 wpabuf_free(wpa_s->lci);
604 wpa_s->lci = NULL;
605 wpas_clear_beacon_rep_data(wpa_s);
606
607 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
608 #ifdef CONFIG_MESH
609 {
610 struct external_pmksa_cache *entry;
611
612 while ((entry = dl_list_last(&wpa_s->mesh_external_pmksa_cache,
613 struct external_pmksa_cache,
614 list)) != NULL) {
615 dl_list_del(&entry->list);
616 os_free(entry->pmksa_cache);
617 os_free(entry);
618 }
619 }
620 #endif /* CONFIG_MESH */
621 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
622
623 wpas_flush_fils_hlp_req(wpa_s);
624
625 wpabuf_free(wpa_s->ric_ies);
626 wpa_s->ric_ies = NULL;
627 }
628
629
630 /**
631 * wpa_clear_keys - Clear keys configured for the driver
632 * @wpa_s: Pointer to wpa_supplicant data
633 * @addr: Previously used BSSID or %NULL if not available
634 *
635 * This function clears the encryption keys that has been previously configured
636 * for the driver.
637 */
638 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
639 {
640 int i, max;
641
642 #ifdef CONFIG_IEEE80211W
643 max = 6;
644 #else /* CONFIG_IEEE80211W */
645 max = 4;
646 #endif /* CONFIG_IEEE80211W */
647
648 /* MLME-DELETEKEYS.request */
649 for (i = 0; i < max; i++) {
650 if (wpa_s->keys_cleared & BIT(i))
651 continue;
652 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
653 NULL, 0);
654 }
655 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
656 !is_zero_ether_addr(addr)) {
657 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
658 0);
659 /* MLME-SETPROTECTION.request(None) */
660 wpa_drv_mlme_setprotection(
661 wpa_s, addr,
662 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
663 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
664 }
665 wpa_s->keys_cleared = (u32) -1;
666 }
667
668
669 /**
670 * wpa_supplicant_state_txt - Get the connection state name as a text string
671 * @state: State (wpa_state; WPA_*)
672 * Returns: The state name as a printable text string
673 */
674 const char * wpa_supplicant_state_txt(enum wpa_states state)
675 {
676 switch (state) {
677 case WPA_DISCONNECTED:
678 return "DISCONNECTED";
679 case WPA_INACTIVE:
680 return "INACTIVE";
681 case WPA_INTERFACE_DISABLED:
682 return "INTERFACE_DISABLED";
683 case WPA_SCANNING:
684 return "SCANNING";
685 case WPA_AUTHENTICATING:
686 return "AUTHENTICATING";
687 case WPA_ASSOCIATING:
688 return "ASSOCIATING";
689 case WPA_ASSOCIATED:
690 return "ASSOCIATED";
691 case WPA_4WAY_HANDSHAKE:
692 return "4WAY_HANDSHAKE";
693 case WPA_GROUP_HANDSHAKE:
694 return "GROUP_HANDSHAKE";
695 case WPA_COMPLETED:
696 return "COMPLETED";
697 default:
698 return "UNKNOWN";
699 }
700 }
701
702
703 #ifdef CONFIG_BGSCAN
704
705 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
706 {
707 const char *name;
708
709 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
710 name = wpa_s->current_ssid->bgscan;
711 else
712 name = wpa_s->conf->bgscan;
713 if (name == NULL || name[0] == '\0')
714 return;
715 if (wpas_driver_bss_selection(wpa_s))
716 return;
717 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
718 return;
719 #ifdef CONFIG_P2P
720 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
721 return;
722 #endif /* CONFIG_P2P */
723
724 bgscan_deinit(wpa_s);
725 if (wpa_s->current_ssid) {
726 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
727 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
728 "bgscan");
729 /*
730 * Live without bgscan; it is only used as a roaming
731 * optimization, so the initial connection is not
732 * affected.
733 */
734 } else {
735 struct wpa_scan_results *scan_res;
736 wpa_s->bgscan_ssid = wpa_s->current_ssid;
737 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
738 0);
739 if (scan_res) {
740 bgscan_notify_scan(wpa_s, scan_res);
741 wpa_scan_results_free(scan_res);
742 }
743 }
744 } else
745 wpa_s->bgscan_ssid = NULL;
746 }
747
748
749 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
750 {
751 if (wpa_s->bgscan_ssid != NULL) {
752 bgscan_deinit(wpa_s);
753 wpa_s->bgscan_ssid = NULL;
754 }
755 }
756
757 #endif /* CONFIG_BGSCAN */
758
759
760 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
761 {
762 if (autoscan_init(wpa_s, 0))
763 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
764 }
765
766
767 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
768 {
769 autoscan_deinit(wpa_s);
770 }
771
772
773 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
774 {
775 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
776 wpa_s->wpa_state == WPA_SCANNING) {
777 autoscan_deinit(wpa_s);
778 wpa_supplicant_start_autoscan(wpa_s);
779 }
780 }
781
782
783 /**
784 * wpa_supplicant_set_state - Set current connection state
785 * @wpa_s: Pointer to wpa_supplicant data
786 * @state: The new connection state
787 *
788 * This function is called whenever the connection state changes, e.g.,
789 * association is completed for WPA/WPA2 4-Way Handshake is started.
790 */
791 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
792 enum wpa_states state)
793 {
794 enum wpa_states old_state = wpa_s->wpa_state;
795
796 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
797 wpa_supplicant_state_txt(wpa_s->wpa_state),
798 wpa_supplicant_state_txt(state));
799
800 if (state == WPA_INTERFACE_DISABLED) {
801 /* Assure normal scan when interface is restored */
802 wpa_s->normal_scans = 0;
803 }
804
805 if (state == WPA_COMPLETED) {
806 wpas_connect_work_done(wpa_s);
807 /* Reinitialize normal_scan counter */
808 wpa_s->normal_scans = 0;
809 }
810
811 #ifdef CONFIG_P2P
812 /*
813 * P2PS client has to reply to Probe Request frames received on the
814 * group operating channel. Enable Probe Request frame reporting for
815 * P2P connected client in case p2p_cli_probe configuration property is
816 * set to 1.
817 */
818 if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid &&
819 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
820 wpa_s->current_ssid->p2p_group) {
821 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) {
822 wpa_dbg(wpa_s, MSG_DEBUG,
823 "P2P: Enable CLI Probe Request RX reporting");
824 wpa_s->p2p_cli_probe =
825 wpa_drv_probe_req_report(wpa_s, 1) >= 0;
826 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) {
827 wpa_dbg(wpa_s, MSG_DEBUG,
828 "P2P: Disable CLI Probe Request RX reporting");
829 wpa_s->p2p_cli_probe = 0;
830 wpa_drv_probe_req_report(wpa_s, 0);
831 }
832 }
833 #endif /* CONFIG_P2P */
834
835 if (state != WPA_SCANNING)
836 wpa_supplicant_notify_scanning(wpa_s, 0);
837
838 if (state == WPA_COMPLETED && wpa_s->new_connection) {
839 struct wpa_ssid *ssid = wpa_s->current_ssid;
840 int fils_hlp_sent = 0;
841
842 #ifdef CONFIG_SME
843 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
844 wpa_auth_alg_fils(wpa_s->sme.auth_alg))
845 fils_hlp_sent = 1;
846 #endif /* CONFIG_SME */
847 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
848 wpa_auth_alg_fils(wpa_s->auth_alg))
849 fils_hlp_sent = 1;
850
851 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
852 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
853 MACSTR " completed [id=%d id_str=%s%s]",
854 MAC2STR(wpa_s->bssid),
855 ssid ? ssid->id : -1,
856 ssid && ssid->id_str ? ssid->id_str : "",
857 fils_hlp_sent ? " FILS_HLP_SENT" : "");
858 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
859 wpas_clear_temp_disabled(wpa_s, ssid, 1);
860 wpa_blacklist_clear(wpa_s);
861 wpa_s->extra_blacklist_count = 0;
862 wpa_s->new_connection = 0;
863 wpa_drv_set_operstate(wpa_s, 1);
864 #ifndef IEEE8021X_EAPOL
865 wpa_drv_set_supp_port(wpa_s, 1);
866 #endif /* IEEE8021X_EAPOL */
867 wpa_s->after_wps = 0;
868 wpa_s->known_wps_freq = 0;
869 wpas_p2p_completed(wpa_s);
870
871 sme_sched_obss_scan(wpa_s, 1);
872 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
873 state == WPA_ASSOCIATED) {
874 wpa_s->new_connection = 1;
875 wpa_drv_set_operstate(wpa_s, 0);
876 #ifndef IEEE8021X_EAPOL
877 wpa_drv_set_supp_port(wpa_s, 0);
878 #endif /* IEEE8021X_EAPOL */
879 sme_sched_obss_scan(wpa_s, 0);
880 }
881 wpa_s->wpa_state = state;
882
883 #ifdef CONFIG_BGSCAN
884 if (state == WPA_COMPLETED)
885 wpa_supplicant_start_bgscan(wpa_s);
886 else if (state < WPA_ASSOCIATED)
887 wpa_supplicant_stop_bgscan(wpa_s);
888 #endif /* CONFIG_BGSCAN */
889
890 if (state == WPA_AUTHENTICATING)
891 wpa_supplicant_stop_autoscan(wpa_s);
892
893 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
894 wpa_supplicant_start_autoscan(wpa_s);
895
896 if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
897 wmm_ac_notify_disassoc(wpa_s);
898
899 if (wpa_s->wpa_state != old_state) {
900 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
901
902 /*
903 * Notify the P2P Device interface about a state change in one
904 * of the interfaces.
905 */
906 wpas_p2p_indicate_state_change(wpa_s);
907
908 if (wpa_s->wpa_state == WPA_COMPLETED ||
909 old_state == WPA_COMPLETED)
910 wpas_notify_auth_changed(wpa_s);
911 }
912 }
913
914
915 void wpa_supplicant_terminate_proc(struct wpa_global *global)
916 {
917 int pending = 0;
918 #ifdef CONFIG_WPS
919 struct wpa_supplicant *wpa_s = global->ifaces;
920 while (wpa_s) {
921 struct wpa_supplicant *next = wpa_s->next;
922 if (wpas_wps_terminate_pending(wpa_s) == 1)
923 pending = 1;
924 #ifdef CONFIG_P2P
925 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
926 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
927 wpas_p2p_disconnect(wpa_s);
928 #endif /* CONFIG_P2P */
929 wpa_s = next;
930 }
931 #endif /* CONFIG_WPS */
932 if (pending)
933 return;
934 eloop_terminate();
935 }
936
937
938 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
939 {
940 struct wpa_global *global = signal_ctx;
941 wpa_supplicant_terminate_proc(global);
942 }
943
944
945 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
946 {
947 enum wpa_states old_state = wpa_s->wpa_state;
948
949 wpa_s->pairwise_cipher = 0;
950 wpa_s->group_cipher = 0;
951 wpa_s->mgmt_group_cipher = 0;
952 wpa_s->key_mgmt = 0;
953 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
954 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
955
956 if (wpa_s->wpa_state != old_state)
957 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
958 }
959
960
961 /**
962 * wpa_supplicant_reload_configuration - Reload configuration data
963 * @wpa_s: Pointer to wpa_supplicant data
964 * Returns: 0 on success or -1 if configuration parsing failed
965 *
966 * This function can be used to request that the configuration data is reloaded
967 * (e.g., after configuration file change). This function is reloading
968 * configuration only for one interface, so this may need to be called multiple
969 * times if %wpa_supplicant is controlling multiple interfaces and all
970 * interfaces need reconfiguration.
971 */
972 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
973 {
974 struct wpa_config *conf;
975 int reconf_ctrl;
976 int old_ap_scan;
977
978 if (wpa_s->confname == NULL)
979 return -1;
980 conf = wpa_config_read(wpa_s->confname, NULL);
981 if (conf == NULL) {
982 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
983 "file '%s' - exiting", wpa_s->confname);
984 return -1;
985 }
986 wpa_config_read(wpa_s->confanother, conf);
987
988 conf->changed_parameters = (unsigned int) -1;
989
990 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
991 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
992 os_strcmp(conf->ctrl_interface,
993 wpa_s->conf->ctrl_interface) != 0);
994
995 if (reconf_ctrl && wpa_s->ctrl_iface) {
996 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
997 wpa_s->ctrl_iface = NULL;
998 }
999
1000 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1001 if (wpa_s->current_ssid) {
1002 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
1003 wpa_s->own_disconnect_req = 1;
1004 wpa_supplicant_deauthenticate(wpa_s,
1005 WLAN_REASON_DEAUTH_LEAVING);
1006 }
1007
1008 /*
1009 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
1010 * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
1011 */
1012 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1013 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE) {
1014 /*
1015 * Clear forced success to clear EAP state for next
1016 * authentication.
1017 */
1018 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
1019 }
1020 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1021 wpa_sm_set_config(wpa_s->wpa, NULL);
1022 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
1023 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1024 rsn_preauth_deinit(wpa_s->wpa);
1025
1026 old_ap_scan = wpa_s->conf->ap_scan;
1027 wpa_config_free(wpa_s->conf);
1028 wpa_s->conf = conf;
1029 if (old_ap_scan != wpa_s->conf->ap_scan)
1030 wpas_notify_ap_scan_changed(wpa_s);
1031
1032 if (reconf_ctrl)
1033 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1034
1035 wpa_supplicant_update_config(wpa_s);
1036
1037 wpa_supplicant_clear_status(wpa_s);
1038 if (wpa_supplicant_enabled_networks(wpa_s)) {
1039 wpa_s->reassociate = 1;
1040 wpa_supplicant_req_scan(wpa_s, 0, 0);
1041 }
1042 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
1043 return 0;
1044 }
1045
1046
1047 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
1048 {
1049 struct wpa_global *global = signal_ctx;
1050 struct wpa_supplicant *wpa_s;
1051 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1052 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
1053 sig);
1054 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
1055 wpa_supplicant_terminate_proc(global);
1056 }
1057 }
1058
1059 if (wpa_debug_reopen_file() < 0) {
1060 /* Ignore errors since we cannot really do much to fix this */
1061 wpa_printf(MSG_DEBUG, "Could not reopen debug log file");
1062 }
1063 }
1064
1065
1066 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
1067 struct wpa_ssid *ssid,
1068 struct wpa_ie_data *ie)
1069 {
1070 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
1071 if (ret) {
1072 if (ret == -2) {
1073 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
1074 "from association info");
1075 }
1076 return -1;
1077 }
1078
1079 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
1080 "cipher suites");
1081 if (!(ie->group_cipher & ssid->group_cipher)) {
1082 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
1083 "cipher 0x%x (mask 0x%x) - reject",
1084 ie->group_cipher, ssid->group_cipher);
1085 return -1;
1086 }
1087 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
1088 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
1089 "cipher 0x%x (mask 0x%x) - reject",
1090 ie->pairwise_cipher, ssid->pairwise_cipher);
1091 return -1;
1092 }
1093 if (!(ie->key_mgmt & ssid->key_mgmt)) {
1094 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
1095 "management 0x%x (mask 0x%x) - reject",
1096 ie->key_mgmt, ssid->key_mgmt);
1097 return -1;
1098 }
1099
1100 #ifdef CONFIG_IEEE80211W
1101 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
1102 wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
1103 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
1104 "that does not support management frame protection - "
1105 "reject");
1106 return -1;
1107 }
1108 #endif /* CONFIG_IEEE80211W */
1109
1110 return 0;
1111 }
1112
1113
1114 /**
1115 * wpa_supplicant_set_suites - Set authentication and encryption parameters
1116 * @wpa_s: Pointer to wpa_supplicant data
1117 * @bss: Scan results for the selected BSS, or %NULL if not available
1118 * @ssid: Configuration data for the selected network
1119 * @wpa_ie: Buffer for the WPA/RSN IE
1120 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
1121 * used buffer length in case the functions returns success.
1122 * Returns: 0 on success or -1 on failure
1123 *
1124 * This function is used to configure authentication and encryption parameters
1125 * based on the network configuration and scan result for the selected BSS (if
1126 * available).
1127 */
1128 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
1129 struct wpa_bss *bss, struct wpa_ssid *ssid,
1130 u8 *wpa_ie, size_t *wpa_ie_len)
1131 {
1132 struct wpa_ie_data ie;
1133 int sel, proto;
1134 const u8 *bss_wpa, *bss_rsn, *bss_osen;
1135
1136 if (bss) {
1137 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
1138 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1139 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
1140 } else
1141 bss_wpa = bss_rsn = bss_osen = NULL;
1142
1143 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
1144 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
1145 (ie.group_cipher & ssid->group_cipher) &&
1146 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1147 (ie.key_mgmt & ssid->key_mgmt)) {
1148 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1149 proto = WPA_PROTO_RSN;
1150 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
1151 wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie) == 0 &&
1152 (ie.group_cipher & ssid->group_cipher) &&
1153 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1154 (ie.key_mgmt & ssid->key_mgmt)) {
1155 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1156 proto = WPA_PROTO_WPA;
1157 #ifdef CONFIG_HS20
1158 } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN)) {
1159 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1160 /* TODO: parse OSEN element */
1161 os_memset(&ie, 0, sizeof(ie));
1162 ie.group_cipher = WPA_CIPHER_CCMP;
1163 ie.pairwise_cipher = WPA_CIPHER_CCMP;
1164 ie.key_mgmt = WPA_KEY_MGMT_OSEN;
1165 proto = WPA_PROTO_OSEN;
1166 #endif /* CONFIG_HS20 */
1167 } else if (bss) {
1168 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1169 wpa_dbg(wpa_s, MSG_DEBUG,
1170 "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1171 ssid->proto, ssid->pairwise_cipher, ssid->group_cipher,
1172 ssid->key_mgmt);
1173 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1174 MAC2STR(bss->bssid),
1175 wpa_ssid_txt(bss->ssid, bss->ssid_len),
1176 bss_wpa ? " WPA" : "",
1177 bss_rsn ? " RSN" : "",
1178 bss_osen ? " OSEN" : "");
1179 if (bss_rsn) {
1180 wpa_hexdump(MSG_DEBUG, "RSN", bss_rsn, 2 + bss_rsn[1]);
1181 if (wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie)) {
1182 wpa_dbg(wpa_s, MSG_DEBUG,
1183 "Could not parse RSN element");
1184 } else {
1185 wpa_dbg(wpa_s, MSG_DEBUG,
1186 "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1187 ie.pairwise_cipher, ie.group_cipher,
1188 ie.key_mgmt);
1189 }
1190 }
1191 if (bss_wpa) {
1192 wpa_hexdump(MSG_DEBUG, "WPA", bss_wpa, 2 + bss_wpa[1]);
1193 if (wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie)) {
1194 wpa_dbg(wpa_s, MSG_DEBUG,
1195 "Could not parse WPA element");
1196 } else {
1197 wpa_dbg(wpa_s, MSG_DEBUG,
1198 "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1199 ie.pairwise_cipher, ie.group_cipher,
1200 ie.key_mgmt);
1201 }
1202 }
1203 return -1;
1204 } else {
1205 if (ssid->proto & WPA_PROTO_OSEN)
1206 proto = WPA_PROTO_OSEN;
1207 else if (ssid->proto & WPA_PROTO_RSN)
1208 proto = WPA_PROTO_RSN;
1209 else
1210 proto = WPA_PROTO_WPA;
1211 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1212 os_memset(&ie, 0, sizeof(ie));
1213 ie.group_cipher = ssid->group_cipher;
1214 ie.pairwise_cipher = ssid->pairwise_cipher;
1215 ie.key_mgmt = ssid->key_mgmt;
1216 #ifdef CONFIG_IEEE80211W
1217 ie.mgmt_group_cipher =
1218 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
1219 WPA_CIPHER_AES_128_CMAC : 0;
1220 #endif /* CONFIG_IEEE80211W */
1221 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1222 "based on configuration");
1223 } else
1224 proto = ie.proto;
1225 }
1226
1227 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1228 "pairwise %d key_mgmt %d proto %d",
1229 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
1230 #ifdef CONFIG_IEEE80211W
1231 if (ssid->ieee80211w) {
1232 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1233 ie.mgmt_group_cipher);
1234 }
1235 #endif /* CONFIG_IEEE80211W */
1236
1237 wpa_s->wpa_proto = proto;
1238 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1239 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1240 !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)));
1241
1242 if (bss || !wpa_s->ap_ies_from_associnfo) {
1243 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1244 bss_wpa ? 2 + bss_wpa[1] : 0) ||
1245 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1246 bss_rsn ? 2 + bss_rsn[1] : 0))
1247 return -1;
1248 }
1249
1250 #ifdef CONFIG_NO_WPA
1251 wpa_s->group_cipher = WPA_CIPHER_NONE;
1252 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1253 #else /* CONFIG_NO_WPA */
1254 sel = ie.group_cipher & ssid->group_cipher;
1255 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1256 if (wpa_s->group_cipher < 0) {
1257 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1258 "cipher");
1259 return -1;
1260 }
1261 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1262 wpa_cipher_txt(wpa_s->group_cipher));
1263
1264 sel = ie.pairwise_cipher & ssid->pairwise_cipher;
1265 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1266 if (wpa_s->pairwise_cipher < 0) {
1267 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1268 "cipher");
1269 return -1;
1270 }
1271 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1272 wpa_cipher_txt(wpa_s->pairwise_cipher));
1273 #endif /* CONFIG_NO_WPA */
1274
1275 sel = ie.key_mgmt & ssid->key_mgmt;
1276 #ifdef CONFIG_SAE
1277 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1278 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
1279 #endif /* CONFIG_SAE */
1280 if (0) {
1281 #ifdef CONFIG_SUITEB192
1282 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
1283 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1284 wpa_dbg(wpa_s, MSG_DEBUG,
1285 "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)");
1286 #endif /* CONFIG_SUITEB192 */
1287 #ifdef CONFIG_SUITEB
1288 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1289 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1290 wpa_dbg(wpa_s, MSG_DEBUG,
1291 "WPA: using KEY_MGMT 802.1X with Suite B");
1292 #endif /* CONFIG_SUITEB */
1293 #ifdef CONFIG_FILS
1294 #ifdef CONFIG_IEEE80211R
1295 } else if (sel & WPA_KEY_MGMT_FT_FILS_SHA384) {
1296 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384;
1297 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA384");
1298 } else if (sel & WPA_KEY_MGMT_FT_FILS_SHA256) {
1299 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256;
1300 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA256");
1301 #endif /* CONFIG_IEEE80211R */
1302 } else if (sel & WPA_KEY_MGMT_FILS_SHA384) {
1303 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA384;
1304 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA384");
1305 } else if (sel & WPA_KEY_MGMT_FILS_SHA256) {
1306 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA256;
1307 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA256");
1308 #endif /* CONFIG_FILS */
1309 #ifdef CONFIG_IEEE80211R
1310 } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1311 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1312 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1313 } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1314 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1315 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1316 #endif /* CONFIG_IEEE80211R */
1317 #ifdef CONFIG_SAE
1318 } else if (sel & WPA_KEY_MGMT_SAE) {
1319 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1320 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1321 } else if (sel & WPA_KEY_MGMT_FT_SAE) {
1322 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1323 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1324 #endif /* CONFIG_SAE */
1325 #ifdef CONFIG_IEEE80211W
1326 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1327 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1328 wpa_dbg(wpa_s, MSG_DEBUG,
1329 "WPA: using KEY_MGMT 802.1X with SHA256");
1330 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1331 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1332 wpa_dbg(wpa_s, MSG_DEBUG,
1333 "WPA: using KEY_MGMT PSK with SHA256");
1334 #endif /* CONFIG_IEEE80211W */
1335 } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1336 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1337 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1338 } else if (sel & WPA_KEY_MGMT_PSK) {
1339 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1340 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1341 } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1342 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1343 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1344 #ifdef CONFIG_HS20
1345 } else if (sel & WPA_KEY_MGMT_OSEN) {
1346 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1347 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1348 #endif /* CONFIG_HS20 */
1349 #ifdef CONFIG_OWE
1350 } else if (sel & WPA_KEY_MGMT_OWE) {
1351 wpa_s->key_mgmt = WPA_KEY_MGMT_OWE;
1352 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT OWE");
1353 #endif /* CONFIG_OWE */
1354 } else {
1355 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1356 "authenticated key management type");
1357 return -1;
1358 }
1359
1360 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1361 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1362 wpa_s->pairwise_cipher);
1363 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1364
1365 #ifdef CONFIG_IEEE80211W
1366 sel = ie.mgmt_group_cipher;
1367 if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1368 !(ie.capabilities & WPA_CAPABILITY_MFPC))
1369 sel = 0;
1370 if (sel & WPA_CIPHER_AES_128_CMAC) {
1371 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1372 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1373 "AES-128-CMAC");
1374 } else if (sel & WPA_CIPHER_BIP_GMAC_128) {
1375 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1376 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1377 "BIP-GMAC-128");
1378 } else if (sel & WPA_CIPHER_BIP_GMAC_256) {
1379 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1380 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1381 "BIP-GMAC-256");
1382 } else if (sel & WPA_CIPHER_BIP_CMAC_256) {
1383 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1384 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1385 "BIP-CMAC-256");
1386 } else {
1387 wpa_s->mgmt_group_cipher = 0;
1388 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1389 }
1390 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1391 wpa_s->mgmt_group_cipher);
1392 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1393 wpas_get_ssid_pmf(wpa_s, ssid));
1394 #endif /* CONFIG_IEEE80211W */
1395
1396 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1397 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1398 return -1;
1399 }
1400
1401 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
1402 int psk_set = 0;
1403
1404 if (ssid->psk_set) {
1405 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL,
1406 NULL);
1407 psk_set = 1;
1408 }
1409 #ifndef CONFIG_NO_PBKDF2
1410 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1411 ssid->passphrase) {
1412 u8 psk[PMK_LEN];
1413 pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1414 4096, psk, PMK_LEN);
1415 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1416 psk, PMK_LEN);
1417 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL, NULL);
1418 psk_set = 1;
1419 os_memset(psk, 0, sizeof(psk));
1420 }
1421 #endif /* CONFIG_NO_PBKDF2 */
1422 #ifdef CONFIG_EXT_PASSWORD
1423 if (ssid->ext_psk) {
1424 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1425 ssid->ext_psk);
1426 char pw_str[64 + 1];
1427 u8 psk[PMK_LEN];
1428
1429 if (pw == NULL) {
1430 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1431 "found from external storage");
1432 return -1;
1433 }
1434
1435 if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1436 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1437 "PSK length %d in external storage",
1438 (int) wpabuf_len(pw));
1439 ext_password_free(pw);
1440 return -1;
1441 }
1442
1443 os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1444 pw_str[wpabuf_len(pw)] = '\0';
1445
1446 #ifndef CONFIG_NO_PBKDF2
1447 if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1448 {
1449 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1450 4096, psk, PMK_LEN);
1451 os_memset(pw_str, 0, sizeof(pw_str));
1452 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1453 "external passphrase)",
1454 psk, PMK_LEN);
1455 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1456 NULL);
1457 psk_set = 1;
1458 os_memset(psk, 0, sizeof(psk));
1459 } else
1460 #endif /* CONFIG_NO_PBKDF2 */
1461 if (wpabuf_len(pw) == 2 * PMK_LEN) {
1462 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1463 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1464 "Invalid PSK hex string");
1465 os_memset(pw_str, 0, sizeof(pw_str));
1466 ext_password_free(pw);
1467 return -1;
1468 }
1469 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1470 NULL);
1471 psk_set = 1;
1472 os_memset(psk, 0, sizeof(psk));
1473 } else {
1474 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1475 "PSK available");
1476 os_memset(pw_str, 0, sizeof(pw_str));
1477 ext_password_free(pw);
1478 return -1;
1479 }
1480
1481 os_memset(pw_str, 0, sizeof(pw_str));
1482 ext_password_free(pw);
1483 }
1484 #endif /* CONFIG_EXT_PASSWORD */
1485
1486 if (!psk_set) {
1487 wpa_msg(wpa_s, MSG_INFO,
1488 "No PSK available for association");
1489 return -1;
1490 }
1491 } else
1492 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1493
1494 return 0;
1495 }
1496
1497
1498 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1499 {
1500 *pos = 0x00;
1501
1502 switch (idx) {
1503 case 0: /* Bits 0-7 */
1504 break;
1505 case 1: /* Bits 8-15 */
1506 break;
1507 case 2: /* Bits 16-23 */
1508 #ifdef CONFIG_WNM
1509 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */
1510 *pos |= 0x08; /* Bit 19 - BSS Transition */
1511 #endif /* CONFIG_WNM */
1512 break;
1513 case 3: /* Bits 24-31 */
1514 #ifdef CONFIG_WNM
1515 *pos |= 0x02; /* Bit 25 - SSID List */
1516 #endif /* CONFIG_WNM */
1517 #ifdef CONFIG_INTERWORKING
1518 if (wpa_s->conf->interworking)
1519 *pos |= 0x80; /* Bit 31 - Interworking */
1520 #endif /* CONFIG_INTERWORKING */
1521 break;
1522 case 4: /* Bits 32-39 */
1523 #ifdef CONFIG_INTERWORKING
1524 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1525 *pos |= 0x01; /* Bit 32 - QoS Map */
1526 #endif /* CONFIG_INTERWORKING */
1527 break;
1528 case 5: /* Bits 40-47 */
1529 #ifdef CONFIG_HS20
1530 if (wpa_s->conf->hs20)
1531 *pos |= 0x40; /* Bit 46 - WNM-Notification */
1532 #endif /* CONFIG_HS20 */
1533 #ifdef CONFIG_MBO
1534 *pos |= 0x40; /* Bit 46 - WNM-Notification */
1535 #endif /* CONFIG_MBO */
1536 break;
1537 case 6: /* Bits 48-55 */
1538 break;
1539 case 7: /* Bits 56-63 */
1540 break;
1541 case 8: /* Bits 64-71 */
1542 if (wpa_s->conf->ftm_responder)
1543 *pos |= 0x40; /* Bit 70 - FTM responder */
1544 if (wpa_s->conf->ftm_initiator)
1545 *pos |= 0x80; /* Bit 71 - FTM initiator */
1546 break;
1547 case 9: /* Bits 72-79 */
1548 #ifdef CONFIG_FILS
1549 *pos |= 0x01;
1550 #endif /* CONFIG_FILS */
1551 break;
1552 }
1553 }
1554
1555
1556 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1557 {
1558 u8 *pos = buf;
1559 u8 len = 10, i;
1560
1561 if (len < wpa_s->extended_capa_len)
1562 len = wpa_s->extended_capa_len;
1563 if (buflen < (size_t) len + 2) {
1564 wpa_printf(MSG_INFO,
1565 "Not enough room for building extended capabilities element");
1566 return -1;
1567 }
1568
1569 *pos++ = WLAN_EID_EXT_CAPAB;
1570 *pos++ = len;
1571 for (i = 0; i < len; i++, pos++) {
1572 wpas_ext_capab_byte(wpa_s, pos, i);
1573
1574 if (i < wpa_s->extended_capa_len) {
1575 *pos &= ~wpa_s->extended_capa_mask[i];
1576 *pos |= wpa_s->extended_capa[i];
1577 }
1578 }
1579
1580 while (len > 0 && buf[1 + len] == 0) {
1581 len--;
1582 buf[1] = len;
1583 }
1584 if (len == 0)
1585 return 0;
1586
1587 return 2 + len;
1588 }
1589
1590
1591 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1592 struct wpa_bss *test_bss)
1593 {
1594 struct wpa_bss *bss;
1595
1596 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1597 if (bss == test_bss)
1598 return 1;
1599 }
1600
1601 return 0;
1602 }
1603
1604
1605 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1606 struct wpa_ssid *test_ssid)
1607 {
1608 struct wpa_ssid *ssid;
1609
1610 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1611 if (ssid == test_ssid)
1612 return 1;
1613 }
1614
1615 return 0;
1616 }
1617
1618
1619 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1620 struct wpa_ssid *test_ssid)
1621 {
1622 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1623 return 0;
1624
1625 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1626 }
1627
1628
1629 void wpas_connect_work_free(struct wpa_connect_work *cwork)
1630 {
1631 if (cwork == NULL)
1632 return;
1633 os_free(cwork);
1634 }
1635
1636
1637 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1638 {
1639 struct wpa_connect_work *cwork;
1640 struct wpa_radio_work *work = wpa_s->connect_work;
1641
1642 if (!work)
1643 return;
1644
1645 wpa_s->connect_work = NULL;
1646 cwork = work->ctx;
1647 work->ctx = NULL;
1648 wpas_connect_work_free(cwork);
1649 radio_work_done(work);
1650 }
1651
1652
1653 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1654 {
1655 struct os_reltime now;
1656 u8 addr[ETH_ALEN];
1657
1658 os_get_reltime(&now);
1659 if (wpa_s->last_mac_addr_style == style &&
1660 wpa_s->last_mac_addr_change.sec != 0 &&
1661 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1662 wpa_s->conf->rand_addr_lifetime)) {
1663 wpa_msg(wpa_s, MSG_DEBUG,
1664 "Previously selected random MAC address has not yet expired");
1665 return 0;
1666 }
1667
1668 switch (style) {
1669 case 1:
1670 if (random_mac_addr(addr) < 0)
1671 return -1;
1672 break;
1673 case 2:
1674 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1675 if (random_mac_addr_keep_oui(addr) < 0)
1676 return -1;
1677 break;
1678 default:
1679 return -1;
1680 }
1681
1682 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1683 wpa_msg(wpa_s, MSG_INFO,
1684 "Failed to set random MAC address");
1685 return -1;
1686 }
1687
1688 os_get_reltime(&wpa_s->last_mac_addr_change);
1689 wpa_s->mac_addr_changed = 1;
1690 wpa_s->last_mac_addr_style = style;
1691
1692 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1693 wpa_msg(wpa_s, MSG_INFO,
1694 "Could not update MAC address information");
1695 return -1;
1696 }
1697
1698 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1699 MAC2STR(addr));
1700
1701 return 0;
1702 }
1703
1704
1705 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1706 {
1707 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1708 !wpa_s->conf->preassoc_mac_addr)
1709 return 0;
1710
1711 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1712 }
1713
1714
1715 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit);
1716
1717 /**
1718 * wpa_supplicant_associate - Request association
1719 * @wpa_s: Pointer to wpa_supplicant data
1720 * @bss: Scan results for the selected BSS, or %NULL if not available
1721 * @ssid: Configuration data for the selected network
1722 *
1723 * This function is used to request %wpa_supplicant to associate with a BSS.
1724 */
1725 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1726 struct wpa_bss *bss, struct wpa_ssid *ssid)
1727 {
1728 struct wpa_connect_work *cwork;
1729 int rand_style;
1730
1731 wpa_s->own_disconnect_req = 0;
1732
1733 /*
1734 * If we are starting a new connection, any previously pending EAPOL
1735 * RX cannot be valid anymore.
1736 */
1737 wpabuf_free(wpa_s->pending_eapol_rx);
1738 wpa_s->pending_eapol_rx = NULL;
1739
1740 if (ssid->mac_addr == -1)
1741 rand_style = wpa_s->conf->mac_addr;
1742 else
1743 rand_style = ssid->mac_addr;
1744
1745 wmm_ac_clear_saved_tspecs(wpa_s);
1746 wpa_s->reassoc_same_bss = 0;
1747 wpa_s->reassoc_same_ess = 0;
1748
1749 if (wpa_s->last_ssid == ssid) {
1750 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1751 wpa_s->reassoc_same_ess = 1;
1752 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1753 wmm_ac_save_tspecs(wpa_s);
1754 wpa_s->reassoc_same_bss = 1;
1755 }
1756 }
1757
1758 if (rand_style > 0 && !wpa_s->reassoc_same_ess) {
1759 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1760 return;
1761 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1762 } else if (rand_style == 0 && wpa_s->mac_addr_changed) {
1763 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1764 wpa_msg(wpa_s, MSG_INFO,
1765 "Could not restore permanent MAC address");
1766 return;
1767 }
1768 wpa_s->mac_addr_changed = 0;
1769 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1770 wpa_msg(wpa_s, MSG_INFO,
1771 "Could not update MAC address information");
1772 return;
1773 }
1774 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1775 }
1776 wpa_s->last_ssid = ssid;
1777
1778 #ifdef CONFIG_IBSS_RSN
1779 ibss_rsn_deinit(wpa_s->ibss_rsn);
1780 wpa_s->ibss_rsn = NULL;
1781 #else /* CONFIG_IBSS_RSN */
1782 if (ssid->mode == WPAS_MODE_IBSS &&
1783 !(ssid->key_mgmt & (WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPA_NONE))) {
1784 wpa_msg(wpa_s, MSG_INFO,
1785 "IBSS RSN not supported in the build");
1786 return;
1787 }
1788 #endif /* CONFIG_IBSS_RSN */
1789
1790 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1791 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1792 #ifdef CONFIG_AP
1793 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1794 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1795 "mode");
1796 return;
1797 }
1798 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1799 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1800 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1801 wpas_p2p_ap_setup_failed(wpa_s);
1802 return;
1803 }
1804 wpa_s->current_bss = bss;
1805 #else /* CONFIG_AP */
1806 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1807 "the build");
1808 #endif /* CONFIG_AP */
1809 return;
1810 }
1811
1812 if (ssid->mode == WPAS_MODE_MESH) {
1813 #ifdef CONFIG_MESH
1814 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
1815 wpa_msg(wpa_s, MSG_INFO,
1816 "Driver does not support mesh mode");
1817 return;
1818 }
1819 if (bss)
1820 ssid->frequency = bss->freq;
1821 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
1822 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
1823 return;
1824 }
1825 wpa_s->current_bss = bss;
1826 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_STARTED "ssid=\"%s\" id=%d",
1827 wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
1828 ssid->id);
1829 #else /* CONFIG_MESH */
1830 wpa_msg(wpa_s, MSG_ERROR,
1831 "mesh mode support not included in the build");
1832 #endif /* CONFIG_MESH */
1833 return;
1834 }
1835
1836 #ifdef CONFIG_TDLS
1837 if (bss)
1838 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1839 bss->ie_len);
1840 #endif /* CONFIG_TDLS */
1841
1842 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1843 ssid->mode == IEEE80211_MODE_INFRA) {
1844 sme_authenticate(wpa_s, bss, ssid);
1845 return;
1846 }
1847
1848 if (wpa_s->connect_work) {
1849 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1850 return;
1851 }
1852
1853 if (radio_work_pending(wpa_s, "connect")) {
1854 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1855 return;
1856 }
1857
1858 #ifdef CONFIG_SME
1859 if (ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) {
1860 /* Clear possibly set auth_alg, if any, from last attempt. */
1861 wpa_s->sme.auth_alg = WPA_AUTH_ALG_OPEN;
1862 }
1863 #endif /* CONFIG_SME */
1864
1865 wpas_abort_ongoing_scan(wpa_s);
1866
1867 cwork = os_zalloc(sizeof(*cwork));
1868 if (cwork == NULL)
1869 return;
1870
1871 cwork->bss = bss;
1872 cwork->ssid = ssid;
1873
1874 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1875 wpas_start_assoc_cb, cwork) < 0) {
1876 os_free(cwork);
1877 }
1878 }
1879
1880
1881 static int bss_is_ibss(struct wpa_bss *bss)
1882 {
1883 return (bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) ==
1884 IEEE80211_CAP_IBSS;
1885 }
1886
1887
1888 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
1889 const struct wpa_ssid *ssid)
1890 {
1891 enum hostapd_hw_mode hw_mode;
1892 struct hostapd_hw_modes *mode = NULL;
1893 u8 channel;
1894 int i;
1895
1896 hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel);
1897 if (hw_mode == NUM_HOSTAPD_MODES)
1898 return 0;
1899 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1900 if (wpa_s->hw.modes[i].mode == hw_mode) {
1901 mode = &wpa_s->hw.modes[i];
1902 break;
1903 }
1904 }
1905
1906 if (!mode)
1907 return 0;
1908
1909 return mode->vht_capab != 0;
1910 }
1911
1912
1913 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
1914 const struct wpa_ssid *ssid,
1915 struct hostapd_freq_params *freq)
1916 {
1917 enum hostapd_hw_mode hw_mode;
1918 struct hostapd_hw_modes *mode = NULL;
1919 int ht40plus[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1920 184, 192 };
1921 int vht80[] = { 36, 52, 100, 116, 132, 149 };
1922 struct hostapd_channel_data *pri_chan = NULL, *sec_chan = NULL;
1923 u8 channel;
1924 int i, chan_idx, ht40 = -1, res, obss_scan = 1;
1925 unsigned int j, k;
1926 struct hostapd_freq_params vht_freq;
1927 int chwidth, seg0, seg1;
1928 u32 vht_caps = 0;
1929
1930 freq->freq = ssid->frequency;
1931
1932 for (j = 0; j < wpa_s->last_scan_res_used; j++) {
1933 struct wpa_bss *bss = wpa_s->last_scan_res[j];
1934
1935 if (ssid->mode != WPAS_MODE_IBSS)
1936 break;
1937
1938 /* Don't adjust control freq in case of fixed_freq */
1939 if (ssid->fixed_freq)
1940 break;
1941
1942 if (!bss_is_ibss(bss))
1943 continue;
1944
1945 if (ssid->ssid_len == bss->ssid_len &&
1946 os_memcmp(ssid->ssid, bss->ssid, bss->ssid_len) == 0) {
1947 wpa_printf(MSG_DEBUG,
1948 "IBSS already found in scan results, adjust control freq: %d",
1949 bss->freq);
1950 freq->freq = bss->freq;
1951 obss_scan = 0;
1952 break;
1953 }
1954 }
1955
1956 /* For IBSS check HT_IBSS flag */
1957 if (ssid->mode == WPAS_MODE_IBSS &&
1958 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
1959 return;
1960
1961 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
1962 wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
1963 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
1964 wpa_printf(MSG_DEBUG,
1965 "IBSS: WEP/TKIP detected, do not try to enable HT");
1966 return;
1967 }
1968
1969 hw_mode = ieee80211_freq_to_chan(freq->freq, &channel);
1970 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1971 if (wpa_s->hw.modes[i].mode == hw_mode) {
1972 mode = &wpa_s->hw.modes[i];
1973 break;
1974 }
1975 }
1976
1977 if (!mode)
1978 return;
1979
1980 #ifdef CONFIG_HT_OVERRIDES
1981 if (ssid->disable_ht) {
1982 freq->ht_enabled = 0;
1983 return;
1984 }
1985 #endif /* CONFIG_HT_OVERRIDES */
1986
1987 freq->ht_enabled = ht_supported(mode);
1988 if (!freq->ht_enabled)
1989 return;
1990
1991 /* Setup higher BW only for 5 GHz */
1992 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
1993 return;
1994
1995 for (chan_idx = 0; chan_idx < mode->num_channels; chan_idx++) {
1996 pri_chan = &mode->channels[chan_idx];
1997 if (pri_chan->chan == channel)
1998 break;
1999 pri_chan = NULL;
2000 }
2001 if (!pri_chan)
2002 return;
2003
2004 /* Check primary channel flags */
2005 if (pri_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
2006 return;
2007
2008 #ifdef CONFIG_HT_OVERRIDES
2009 if (ssid->disable_ht40)
2010 return;
2011 #endif /* CONFIG_HT_OVERRIDES */
2012
2013 /* Check/setup HT40+/HT40- */
2014 for (j = 0; j < ARRAY_SIZE(ht40plus); j++) {
2015 if (ht40plus[j] == channel) {
2016 ht40 = 1;
2017 break;
2018 }
2019 }
2020
2021 /* Find secondary channel */
2022 for (i = 0; i < mode->num_channels; i++) {
2023 sec_chan = &mode->channels[i];
2024 if (sec_chan->chan == channel + ht40 * 4)
2025 break;
2026 sec_chan = NULL;
2027 }
2028 if (!sec_chan)
2029 return;
2030
2031 /* Check secondary channel flags */
2032 if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
2033 return;
2034
2035 freq->channel = pri_chan->chan;
2036
2037 if (ht40 == -1) {
2038 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS))
2039 return;
2040 } else {
2041 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS))
2042 return;
2043 }
2044 freq->sec_channel_offset = ht40;
2045
2046 if (obss_scan) {
2047 struct wpa_scan_results *scan_res;
2048
2049 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
2050 if (scan_res == NULL) {
2051 /* Back to HT20 */
2052 freq->sec_channel_offset = 0;
2053 return;
2054 }
2055
2056 res = check_40mhz_5g(mode, scan_res, pri_chan->chan,
2057 sec_chan->chan);
2058 switch (res) {
2059 case 0:
2060 /* Back to HT20 */
2061 freq->sec_channel_offset = 0;
2062 break;
2063 case 1:
2064 /* Configuration allowed */
2065 break;
2066 case 2:
2067 /* Switch pri/sec channels */
2068 freq->freq = hw_get_freq(mode, sec_chan->chan);
2069 freq->sec_channel_offset = -freq->sec_channel_offset;
2070 freq->channel = sec_chan->chan;
2071 break;
2072 default:
2073 freq->sec_channel_offset = 0;
2074 break;
2075 }
2076
2077 wpa_scan_results_free(scan_res);
2078 }
2079
2080 wpa_printf(MSG_DEBUG,
2081 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
2082 freq->channel, freq->sec_channel_offset);
2083
2084 if (!drv_supports_vht(wpa_s, ssid))
2085 return;
2086
2087 /* For IBSS check VHT_IBSS flag */
2088 if (ssid->mode == WPAS_MODE_IBSS &&
2089 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
2090 return;
2091
2092 vht_freq = *freq;
2093
2094 #ifdef CONFIG_VHT_OVERRIDES
2095 if (ssid->disable_vht) {
2096 freq->vht_enabled = 0;
2097 return;
2098 }
2099 #endif /* CONFIG_VHT_OVERRIDES */
2100
2101 vht_freq.vht_enabled = vht_supported(mode);
2102 if (!vht_freq.vht_enabled)
2103 return;
2104
2105 /* setup center_freq1, bandwidth */
2106 for (j = 0; j < ARRAY_SIZE(vht80); j++) {
2107 if (freq->channel >= vht80[j] &&
2108 freq->channel < vht80[j] + 16)
2109 break;
2110 }
2111
2112 if (j == ARRAY_SIZE(vht80))
2113 return;
2114
2115 for (i = vht80[j]; i < vht80[j] + 16; i += 4) {
2116 struct hostapd_channel_data *chan;
2117
2118 chan = hw_get_channel_chan(mode, i, NULL);
2119 if (!chan)
2120 return;
2121
2122 /* Back to HT configuration if channel not usable */
2123 if (chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
2124 return;
2125 }
2126
2127 chwidth = VHT_CHANWIDTH_80MHZ;
2128 seg0 = vht80[j] + 6;
2129 seg1 = 0;
2130
2131 if (ssid->max_oper_chwidth == VHT_CHANWIDTH_80P80MHZ) {
2132 /* setup center_freq2, bandwidth */
2133 for (k = 0; k < ARRAY_SIZE(vht80); k++) {
2134 /* Only accept 80 MHz segments separated by a gap */
2135 if (j == k || abs(vht80[j] - vht80[k]) == 16)
2136 continue;
2137 for (i = vht80[k]; i < vht80[k] + 16; i += 4) {
2138 struct hostapd_channel_data *chan;
2139
2140 chan = hw_get_channel_chan(mode, i, NULL);
2141 if (!chan)
2142 continue;
2143
2144 if (chan->flag & (HOSTAPD_CHAN_DISABLED |
2145 HOSTAPD_CHAN_NO_IR |
2146 HOSTAPD_CHAN_RADAR))
2147 continue;
2148
2149 /* Found a suitable second segment for 80+80 */
2150 chwidth = VHT_CHANWIDTH_80P80MHZ;
2151 vht_caps |=
2152 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
2153 seg1 = vht80[k] + 6;
2154 }
2155
2156 if (chwidth == VHT_CHANWIDTH_80P80MHZ)
2157 break;
2158 }
2159 } else if (ssid->max_oper_chwidth == VHT_CHANWIDTH_160MHZ) {
2160 if (freq->freq == 5180) {
2161 chwidth = VHT_CHANWIDTH_160MHZ;
2162 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2163 seg0 = 50;
2164 } else if (freq->freq == 5520) {
2165 chwidth = VHT_CHANWIDTH_160MHZ;
2166 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2167 seg0 = 114;
2168 }
2169 }
2170
2171 if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq,
2172 freq->channel, freq->ht_enabled,
2173 vht_freq.vht_enabled,
2174 freq->sec_channel_offset,
2175 chwidth, seg0, seg1, vht_caps) != 0)
2176 return;
2177
2178 *freq = vht_freq;
2179
2180 wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
2181 freq->center_freq1, freq->center_freq2, freq->bandwidth);
2182 }
2183
2184
2185 #ifdef CONFIG_FILS
2186 static size_t wpas_add_fils_hlp_req(struct wpa_supplicant *wpa_s, u8 *ie_buf,
2187 size_t ie_buf_len)
2188 {
2189 struct fils_hlp_req *req;
2190 size_t rem_len, hdr_len, hlp_len, len, ie_len = 0;
2191 const u8 *pos;
2192 u8 *buf = ie_buf;
2193
2194 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
2195 list) {
2196 rem_len = ie_buf_len - ie_len;
2197 pos = wpabuf_head(req->pkt);
2198 hdr_len = 1 + 2 * ETH_ALEN + 6;
2199 hlp_len = wpabuf_len(req->pkt);
2200
2201 if (rem_len < 2 + hdr_len + hlp_len) {
2202 wpa_printf(MSG_ERROR,
2203 "FILS: Cannot fit HLP - rem_len=%lu to_fill=%lu",
2204 (unsigned long) rem_len,
2205 (unsigned long) (2 + hdr_len + hlp_len));
2206 break;
2207 }
2208
2209 len = (hdr_len + hlp_len) > 255 ? 255 : hdr_len + hlp_len;
2210 /* Element ID */
2211 *buf++ = WLAN_EID_EXTENSION;
2212 /* Length */
2213 *buf++ = len;
2214 /* Element ID Extension */
2215 *buf++ = WLAN_EID_EXT_FILS_HLP_CONTAINER;
2216 /* Destination MAC address */
2217 os_memcpy(buf, req->dst, ETH_ALEN);
2218 buf += ETH_ALEN;
2219 /* Source MAC address */
2220 os_memcpy(buf, wpa_s->own_addr, ETH_ALEN);
2221 buf += ETH_ALEN;
2222 /* LLC/SNAP Header */
2223 os_memcpy(buf, "\xaa\xaa\x03\x00\x00\x00", 6);
2224 buf += 6;
2225 /* HLP Packet */
2226 os_memcpy(buf, pos, len - hdr_len);
2227 buf += len - hdr_len;
2228 pos += len - hdr_len;
2229
2230 hlp_len -= len - hdr_len;
2231 ie_len += 2 + len;
2232 rem_len -= 2 + len;
2233
2234 while (hlp_len) {
2235 len = (hlp_len > 255) ? 255 : hlp_len;
2236 if (rem_len < 2 + len)
2237 break;
2238 *buf++ = WLAN_EID_FRAGMENT;
2239 *buf++ = len;
2240 os_memcpy(buf, pos, len);
2241 buf += len;
2242 pos += len;
2243
2244 hlp_len -= len;
2245 ie_len += 2 + len;
2246 rem_len -= 2 + len;
2247 }
2248 }
2249
2250 return ie_len;
2251 }
2252 #endif /* CONFIG_FILS */
2253
2254
2255 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
2256 {
2257 struct wpa_connect_work *cwork = work->ctx;
2258 struct wpa_bss *bss = cwork->bss;
2259 struct wpa_ssid *ssid = cwork->ssid;
2260 struct wpa_supplicant *wpa_s = work->wpa_s;
2261 u8 *wpa_ie;
2262 size_t max_wpa_ie_len = 200;
2263 size_t wpa_ie_len;
2264 int use_crypt, ret, i, bssid_changed;
2265 int algs = WPA_AUTH_ALG_OPEN;
2266 unsigned int cipher_pairwise, cipher_group;
2267 struct wpa_driver_associate_params params;
2268 int wep_keys_set = 0;
2269 int assoc_failed = 0;
2270 struct wpa_ssid *old_ssid;
2271 u8 prev_bssid[ETH_ALEN];
2272 #ifdef CONFIG_HT_OVERRIDES
2273 struct ieee80211_ht_capabilities htcaps;
2274 struct ieee80211_ht_capabilities htcaps_mask;
2275 #endif /* CONFIG_HT_OVERRIDES */
2276 #ifdef CONFIG_VHT_OVERRIDES
2277 struct ieee80211_vht_capabilities vhtcaps;
2278 struct ieee80211_vht_capabilities vhtcaps_mask;
2279 #endif /* CONFIG_VHT_OVERRIDES */
2280 #ifdef CONFIG_FILS
2281 const u8 *realm, *username, *rrk;
2282 size_t realm_len, username_len, rrk_len;
2283 u16 next_seq_num;
2284 #endif /* CONFIG_FILS */
2285
2286 if (deinit) {
2287 if (work->started) {
2288 wpa_s->connect_work = NULL;
2289
2290 /* cancel possible auth. timeout */
2291 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
2292 NULL);
2293 }
2294 wpas_connect_work_free(cwork);
2295 return;
2296 }
2297
2298 wpa_s->connect_work = work;
2299
2300 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
2301 wpas_network_disabled(wpa_s, ssid)) {
2302 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2303 wpas_connect_work_done(wpa_s);
2304 return;
2305 }
2306
2307 os_memcpy(prev_bssid, wpa_s->bssid, ETH_ALEN);
2308 os_memset(&params, 0, sizeof(params));
2309 wpa_s->reassociate = 0;
2310 wpa_s->eap_expected_failure = 0;
2311 if (bss &&
2312 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
2313 #ifdef CONFIG_IEEE80211R
2314 const u8 *ie, *md = NULL;
2315 #endif /* CONFIG_IEEE80211R */
2316 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
2317 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
2318 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
2319 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
2320 os_memset(wpa_s->bssid, 0, ETH_ALEN);
2321 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2322 if (bssid_changed)
2323 wpas_notify_bssid_changed(wpa_s);
2324 #ifdef CONFIG_IEEE80211R
2325 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
2326 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
2327 md = ie + 2;
2328 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
2329 if (md) {
2330 /* Prepare for the next transition */
2331 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
2332 }
2333 #endif /* CONFIG_IEEE80211R */
2334 #ifdef CONFIG_WPS
2335 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
2336 wpa_s->conf->ap_scan == 2 &&
2337 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
2338 /* Use ap_scan==1 style network selection to find the network
2339 */
2340 wpas_connect_work_done(wpa_s);
2341 wpa_s->scan_req = MANUAL_SCAN_REQ;
2342 wpa_s->reassociate = 1;
2343 wpa_supplicant_req_scan(wpa_s, 0, 0);
2344 return;
2345 #endif /* CONFIG_WPS */
2346 } else {
2347 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
2348 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2349 if (bss)
2350 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2351 else
2352 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2353 }
2354 if (!wpa_s->pno)
2355 wpa_supplicant_cancel_sched_scan(wpa_s);
2356
2357 wpa_supplicant_cancel_scan(wpa_s);
2358
2359 /* Starting new association, so clear the possibly used WPA IE from the
2360 * previous association. */
2361 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
2362
2363 #ifdef IEEE8021X_EAPOL
2364 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2365 if (ssid->leap) {
2366 if (ssid->non_leap == 0)
2367 algs = WPA_AUTH_ALG_LEAP;
2368 else
2369 algs |= WPA_AUTH_ALG_LEAP;
2370 }
2371 }
2372
2373 #ifdef CONFIG_FILS
2374 /* Clear FILS association */
2375 wpa_sm_set_reset_fils_completed(wpa_s->wpa, 0);
2376
2377 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) &&
2378 ssid->eap.erp && wpa_key_mgmt_fils(ssid->key_mgmt) &&
2379 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, &username,
2380 &username_len, &realm, &realm_len,
2381 &next_seq_num, &rrk, &rrk_len) == 0) {
2382 algs = WPA_AUTH_ALG_FILS;
2383 params.fils_erp_username = username;
2384 params.fils_erp_username_len = username_len;
2385 params.fils_erp_realm = realm;
2386 params.fils_erp_realm_len = realm_len;
2387 params.fils_erp_next_seq_num = next_seq_num;
2388 params.fils_erp_rrk = rrk;
2389 params.fils_erp_rrk_len = rrk_len;
2390 }
2391 #endif /* CONFIG_FILS */
2392 #endif /* IEEE8021X_EAPOL */
2393
2394 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2395 if (ssid->auth_alg) {
2396 algs = ssid->auth_alg;
2397 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
2398 "0x%x", algs);
2399 }
2400
2401 #ifdef CONFIG_FILS
2402 if (algs == WPA_AUTH_ALG_FILS) {
2403 struct fils_hlp_req *req;
2404
2405 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
2406 list) {
2407 max_wpa_ie_len += 3 + 2 * ETH_ALEN + 6 +
2408 wpabuf_len(req->pkt) +
2409 2 + 2 * wpabuf_len(req->pkt) / 255;
2410 }
2411 }
2412 #endif /* CONFIG_FILS */
2413 wpa_ie = os_malloc(max_wpa_ie_len);
2414 if (!wpa_ie) {
2415 wpa_printf(MSG_ERROR,
2416 "Failed to allocate connect IE buffer for %lu bytes",
2417 (unsigned long) max_wpa_ie_len);
2418 wpas_connect_work_done(wpa_s);
2419 return;
2420 }
2421
2422 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
2423 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
2424 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
2425 int try_opportunistic;
2426 const u8 *cache_id = NULL;
2427
2428 try_opportunistic = (ssid->proactive_key_caching < 0 ?
2429 wpa_s->conf->okc :
2430 ssid->proactive_key_caching) &&
2431 (ssid->proto & WPA_PROTO_RSN);
2432 #ifdef CONFIG_FILS
2433 if (wpa_key_mgmt_fils(ssid->key_mgmt))
2434 cache_id = wpa_bss_get_fils_cache_id(bss);
2435 #endif /* CONFIG_FILS */
2436 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2437 ssid, try_opportunistic,
2438 cache_id) == 0)
2439 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2440 wpa_ie_len = max_wpa_ie_len;
2441 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2442 wpa_ie, &wpa_ie_len)) {
2443 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2444 "key management and encryption suites");
2445 wpas_connect_work_done(wpa_s);
2446 os_free(wpa_ie);
2447 return;
2448 }
2449 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
2450 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
2451 /*
2452 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2453 * use non-WPA since the scan results did not indicate that the
2454 * AP is using WPA or WPA2.
2455 */
2456 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2457 wpa_ie_len = 0;
2458 wpa_s->wpa_proto = 0;
2459 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
2460 wpa_ie_len = max_wpa_ie_len;
2461 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2462 wpa_ie, &wpa_ie_len)) {
2463 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2464 "key management and encryption suites (no "
2465 "scan results)");
2466 wpas_connect_work_done(wpa_s);
2467 os_free(wpa_ie);
2468 return;
2469 }
2470 #ifdef CONFIG_WPS
2471 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
2472 struct wpabuf *wps_ie;
2473 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
2474 if (wps_ie && wpabuf_len(wps_ie) <= max_wpa_ie_len) {
2475 wpa_ie_len = wpabuf_len(wps_ie);
2476 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
2477 } else
2478 wpa_ie_len = 0;
2479 wpabuf_free(wps_ie);
2480 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2481 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
2482 params.wps = WPS_MODE_PRIVACY;
2483 else
2484 params.wps = WPS_MODE_OPEN;
2485 wpa_s->wpa_proto = 0;
2486 #endif /* CONFIG_WPS */
2487 } else {
2488 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2489 wpa_ie_len = 0;
2490 wpa_s->wpa_proto = 0;
2491 }
2492
2493 #ifdef CONFIG_P2P
2494 if (wpa_s->global->p2p) {
2495 u8 *pos;
2496 size_t len;
2497 int res;
2498 pos = wpa_ie + wpa_ie_len;
2499 len = max_wpa_ie_len - wpa_ie_len;
2500 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2501 ssid->p2p_group);
2502 if (res >= 0)
2503 wpa_ie_len += res;
2504 }
2505
2506 wpa_s->cross_connect_disallowed = 0;
2507 if (bss) {
2508 struct wpabuf *p2p;
2509 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
2510 if (p2p) {
2511 wpa_s->cross_connect_disallowed =
2512 p2p_get_cross_connect_disallowed(p2p);
2513 wpabuf_free(p2p);
2514 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2515 "connection",
2516 wpa_s->cross_connect_disallowed ?
2517 "disallows" : "allows");
2518 }
2519 }
2520
2521 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2522 #endif /* CONFIG_P2P */
2523
2524 if (bss) {
2525 wpa_ie_len += wpas_supp_op_class_ie(wpa_s, bss->freq,
2526 wpa_ie + wpa_ie_len,
2527 max_wpa_ie_len -
2528 wpa_ie_len);
2529 }
2530
2531 /*
2532 * Workaround: Add Extended Capabilities element only if the AP
2533 * included this element in Beacon/Probe Response frames. Some older
2534 * APs seem to have interoperability issues if this element is
2535 * included, so while the standard may require us to include the
2536 * element in all cases, it is justifiable to skip it to avoid
2537 * interoperability issues.
2538 */
2539 if (ssid->p2p_group)
2540 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
2541 else
2542 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
2543
2544 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
2545 u8 ext_capab[18];
2546 int ext_capab_len;
2547 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2548 sizeof(ext_capab));
2549 if (ext_capab_len > 0) {
2550 u8 *pos = wpa_ie;
2551 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
2552 pos += 2 + pos[1];
2553 os_memmove(pos + ext_capab_len, pos,
2554 wpa_ie_len - (pos - wpa_ie));
2555 wpa_ie_len += ext_capab_len;
2556 os_memcpy(pos, ext_capab, ext_capab_len);
2557 }
2558 }
2559
2560 #ifdef CONFIG_HS20
2561 if (is_hs20_network(wpa_s, ssid, bss)) {
2562 struct wpabuf *hs20;
2563
2564 hs20 = wpabuf_alloc(20);
2565 if (hs20) {
2566 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2567 size_t len;
2568
2569 wpas_hs20_add_indication(hs20, pps_mo_id);
2570 len = max_wpa_ie_len - wpa_ie_len;
2571 if (wpabuf_len(hs20) <= len) {
2572 os_memcpy(wpa_ie + wpa_ie_len,
2573 wpabuf_head(hs20), wpabuf_len(hs20));
2574 wpa_ie_len += wpabuf_len(hs20);
2575 }
2576 wpabuf_free(hs20);
2577
2578 hs20_configure_frame_filters(wpa_s);
2579 }
2580 }
2581 #endif /* CONFIG_HS20 */
2582
2583 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2584 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2585 size_t len;
2586
2587 len = max_wpa_ie_len - wpa_ie_len;
2588 if (wpabuf_len(buf) <= len) {
2589 os_memcpy(wpa_ie + wpa_ie_len,
2590 wpabuf_head(buf), wpabuf_len(buf));
2591 wpa_ie_len += wpabuf_len(buf);
2592 }
2593 }
2594
2595 #ifdef CONFIG_FST
2596 if (wpa_s->fst_ies) {
2597 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2598
2599 if (wpa_ie_len + fst_ies_len <= max_wpa_ie_len) {
2600 os_memcpy(wpa_ie + wpa_ie_len,
2601 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2602 wpa_ie_len += fst_ies_len;
2603 }
2604 }
2605 #endif /* CONFIG_FST */
2606
2607 #ifdef CONFIG_MBO
2608 if (bss && wpa_bss_get_vendor_ie(bss, MBO_IE_VENDOR_TYPE)) {
2609 int len;
2610
2611 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
2612 max_wpa_ie_len - wpa_ie_len);
2613 if (len >= 0)
2614 wpa_ie_len += len;
2615 }
2616 #endif /* CONFIG_MBO */
2617
2618 #ifdef CONFIG_FILS
2619 if (algs == WPA_AUTH_ALG_FILS) {
2620 size_t len;
2621
2622 len = wpas_add_fils_hlp_req(wpa_s, wpa_ie + wpa_ie_len,
2623 max_wpa_ie_len - wpa_ie_len);
2624 wpa_ie_len += len;
2625 }
2626 #endif /* CONFIG_FILS */
2627
2628 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2629 use_crypt = 1;
2630 cipher_pairwise = wpa_s->pairwise_cipher;
2631 cipher_group = wpa_s->group_cipher;
2632 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2633 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2634 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2635 use_crypt = 0;
2636 if (wpa_set_wep_keys(wpa_s, ssid)) {
2637 use_crypt = 1;
2638 wep_keys_set = 1;
2639 }
2640 }
2641 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2642 use_crypt = 0;
2643
2644 #ifdef IEEE8021X_EAPOL
2645 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2646 if ((ssid->eapol_flags &
2647 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
2648 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
2649 !wep_keys_set) {
2650 use_crypt = 0;
2651 } else {
2652 /* Assume that dynamic WEP-104 keys will be used and
2653 * set cipher suites in order for drivers to expect
2654 * encryption. */
2655 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
2656 }
2657 }
2658 #endif /* IEEE8021X_EAPOL */
2659
2660 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2661 /* Set the key before (and later after) association */
2662 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2663 }
2664
2665 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2666 if (bss) {
2667 params.ssid = bss->ssid;
2668 params.ssid_len = bss->ssid_len;
2669 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set ||
2670 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
2671 wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
2672 MACSTR " freq=%u MHz based on scan results "
2673 "(bssid_set=%d wps=%d)",
2674 MAC2STR(bss->bssid), bss->freq,
2675 ssid->bssid_set,
2676 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS);
2677 params.bssid = bss->bssid;
2678 params.freq.freq = bss->freq;
2679 }
2680 params.bssid_hint = bss->bssid;
2681 params.freq_hint = bss->freq;
2682 params.pbss = bss_is_pbss(bss);
2683 } else {
2684 if (ssid->bssid_hint_set)
2685 params.bssid_hint = ssid->bssid_hint;
2686
2687 params.ssid = ssid->ssid;
2688 params.ssid_len = ssid->ssid_len;
2689 params.pbss = (ssid->pbss != 2) ? ssid->pbss : 0;
2690 }
2691
2692 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
2693 wpa_s->conf->ap_scan == 2) {
2694 params.bssid = ssid->bssid;
2695 params.fixed_bssid = 1;
2696 }
2697
2698 /* Initial frequency for IBSS/mesh */
2699 if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) &&
2700 ssid->frequency > 0 && params.freq.freq == 0)
2701 ibss_mesh_setup_freq(wpa_s, ssid, &params.freq);
2702
2703 if (ssid->mode == WPAS_MODE_IBSS) {
2704 params.fixed_freq = ssid->fixed_freq;
2705 if (ssid->beacon_int)
2706 params.beacon_int = ssid->beacon_int;
2707 else
2708 params.beacon_int = wpa_s->conf->beacon_int;
2709 }
2710
2711 params.wpa_ie = wpa_ie;
2712 params.wpa_ie_len = wpa_ie_len;
2713 params.pairwise_suite = cipher_pairwise;
2714 params.group_suite = cipher_group;
2715 params.key_mgmt_suite = wpa_s->key_mgmt;
2716 params.wpa_proto = wpa_s->wpa_proto;
2717 params.auth_alg = algs;
2718 wpa_s->auth_alg = params.auth_alg;
2719 params.mode = ssid->mode;
2720 params.bg_scan_period = ssid->bg_scan_period;
2721 for (i = 0; i < NUM_WEP_KEYS; i++) {
2722 if (ssid->wep_key_len[i])
2723 params.wep_key[i] = ssid->wep_key[i];
2724 params.wep_key_len[i] = ssid->wep_key_len[i];
2725 }
2726 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
2727
2728 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2729 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2730 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
2731 params.passphrase = ssid->passphrase;
2732 if (ssid->psk_set)
2733 params.psk = ssid->psk;
2734 }
2735
2736 if (wpa_s->conf->key_mgmt_offload) {
2737 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
2738 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
2739 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
2740 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
2741 params.req_key_mgmt_offload =
2742 ssid->proactive_key_caching < 0 ?
2743 wpa_s->conf->okc : ssid->proactive_key_caching;
2744 else
2745 params.req_key_mgmt_offload = 1;
2746
2747 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2748 params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
2749 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
2750 ssid->psk_set)
2751 params.psk = ssid->psk;
2752 }
2753
2754 params.drop_unencrypted = use_crypt;
2755
2756 #ifdef CONFIG_IEEE80211W
2757 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
2758 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
2759 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2760 struct wpa_ie_data ie;
2761 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
2762 ie.capabilities &
2763 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
2764 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2765 "MFP: require MFP");
2766 params.mgmt_frame_protection =
2767 MGMT_FRAME_PROTECTION_REQUIRED;
2768 }
2769 }
2770 #endif /* CONFIG_IEEE80211W */
2771
2772 params.p2p = ssid->p2p_group;
2773
2774 if (wpa_s->p2pdev->set_sta_uapsd)
2775 params.uapsd = wpa_s->p2pdev->sta_uapsd;
2776 else
2777 params.uapsd = -1;
2778
2779 #ifdef CONFIG_HT_OVERRIDES
2780 os_memset(&htcaps, 0, sizeof(htcaps));
2781 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
2782 params.htcaps = (u8 *) &htcaps;
2783 params.htcaps_mask = (u8 *) &htcaps_mask;
2784 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, &params);
2785 #endif /* CONFIG_HT_OVERRIDES */
2786 #ifdef CONFIG_VHT_OVERRIDES
2787 os_memset(&vhtcaps, 0, sizeof(vhtcaps));
2788 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
2789 params.vhtcaps = &vhtcaps;
2790 params.vhtcaps_mask = &vhtcaps_mask;
2791 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, &params);
2792 #endif /* CONFIG_VHT_OVERRIDES */
2793
2794 #ifdef CONFIG_P2P
2795 /*
2796 * If multi-channel concurrency is not supported, check for any
2797 * frequency conflict. In case of any frequency conflict, remove the
2798 * least prioritized connection.
2799 */
2800 if (wpa_s->num_multichan_concurrent < 2) {
2801 int freq, num;
2802 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2803 if (num > 0 && freq > 0 && freq != params.freq.freq) {
2804 wpa_printf(MSG_DEBUG,
2805 "Assoc conflicting freq found (%d != %d)",
2806 freq, params.freq.freq);
2807 if (wpas_p2p_handle_frequency_conflicts(
2808 wpa_s, params.freq.freq, ssid) < 0) {
2809 wpas_connect_work_done(wpa_s);
2810 os_free(wpa_ie);
2811 return;
2812 }
2813 }
2814 }
2815 #endif /* CONFIG_P2P */
2816
2817 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
2818 wpa_s->current_ssid)
2819 params.prev_bssid = prev_bssid;
2820
2821 ret = wpa_drv_associate(wpa_s, &params);
2822 os_free(wpa_ie);
2823 if (ret < 0) {
2824 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2825 "failed");
2826 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2827 /*
2828 * The driver is known to mean what is saying, so we
2829 * can stop right here; the association will not
2830 * succeed.
2831 */
2832 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2833 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2834 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2835 return;
2836 }
2837 /* try to continue anyway; new association will be tried again
2838 * after timeout */
2839 assoc_failed = 1;
2840 }
2841
2842 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2843 /* Set the key after the association just in case association
2844 * cleared the previously configured key. */
2845 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2846 /* No need to timeout authentication since there is no key
2847 * management. */
2848 wpa_supplicant_cancel_auth_timeout(wpa_s);
2849 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2850 #ifdef CONFIG_IBSS_RSN
2851 } else if (ssid->mode == WPAS_MODE_IBSS &&
2852 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2853 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2854 /*
2855 * RSN IBSS authentication is per-STA and we can disable the
2856 * per-BSSID authentication.
2857 */
2858 wpa_supplicant_cancel_auth_timeout(wpa_s);
2859 #endif /* CONFIG_IBSS_RSN */
2860 } else {
2861 /* Timeout for IEEE 802.11 authentication and association */
2862 int timeout = 60;
2863
2864 if (assoc_failed) {
2865 /* give IBSS a bit more time */
2866 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2867 } else if (wpa_s->conf->ap_scan == 1) {
2868 /* give IBSS a bit more time */
2869 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2870 }
2871 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2872 }
2873
2874 if (wep_keys_set &&
2875 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2876 /* Set static WEP keys again */
2877 wpa_set_wep_keys(wpa_s, ssid);
2878 }
2879
2880 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2881 /*
2882 * Do not allow EAP session resumption between different
2883 * network configurations.
2884 */
2885 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2886 }
2887 old_ssid = wpa_s->current_ssid;
2888 wpa_s->current_ssid = ssid;
2889
2890 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2891 wpa_s->current_bss = bss;
2892 #ifdef CONFIG_HS20
2893 hs20_configure_frame_filters(wpa_s);
2894 #endif /* CONFIG_HS20 */
2895 }
2896
2897 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2898 wpa_supplicant_initiate_eapol(wpa_s);
2899 if (old_ssid != wpa_s->current_ssid)
2900 wpas_notify_network_changed(wpa_s);
2901 }
2902
2903
2904 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2905 const u8 *addr)
2906 {
2907 struct wpa_ssid *old_ssid;
2908
2909 wpas_connect_work_done(wpa_s);
2910 wpa_clear_keys(wpa_s, addr);
2911 old_ssid = wpa_s->current_ssid;
2912 wpa_supplicant_mark_disassoc(wpa_s);
2913 wpa_sm_set_config(wpa_s->wpa, NULL);
2914 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2915 if (old_ssid != wpa_s->current_ssid)
2916 wpas_notify_network_changed(wpa_s);
2917 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2918 }
2919
2920
2921 /**
2922 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2923 * @wpa_s: Pointer to wpa_supplicant data
2924 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2925 *
2926 * This function is used to request %wpa_supplicant to deauthenticate from the
2927 * current AP.
2928 */
2929 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2930 int reason_code)
2931 {
2932 u8 *addr = NULL;
2933 union wpa_event_data event;
2934 int zero_addr = 0;
2935
2936 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2937 " pending_bssid=" MACSTR " reason=%d state=%s",
2938 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2939 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2940
2941 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2942 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2943 wpa_s->wpa_state == WPA_ASSOCIATING))
2944 addr = wpa_s->pending_bssid;
2945 else if (!is_zero_ether_addr(wpa_s->bssid))
2946 addr = wpa_s->bssid;
2947 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2948 /*
2949 * When using driver-based BSS selection, we may not know the
2950 * BSSID with which we are currently trying to associate. We
2951 * need to notify the driver of this disconnection even in such
2952 * a case, so use the all zeros address here.
2953 */
2954 addr = wpa_s->bssid;
2955 zero_addr = 1;
2956 }
2957
2958 #ifdef CONFIG_TDLS
2959 wpa_tdls_teardown_peers(wpa_s->wpa);
2960 #endif /* CONFIG_TDLS */
2961
2962 #ifdef CONFIG_MESH
2963 if (wpa_s->ifmsh) {
2964 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
2965 wpa_s->ifname);
2966 wpa_supplicant_leave_mesh(wpa_s);
2967 }
2968 #endif /* CONFIG_MESH */
2969
2970 if (addr) {
2971 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2972 os_memset(&event, 0, sizeof(event));
2973 event.deauth_info.reason_code = (u16) reason_code;
2974 event.deauth_info.locally_generated = 1;
2975 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2976 if (zero_addr)
2977 addr = NULL;
2978 }
2979
2980 wpa_supplicant_clear_connection(wpa_s, addr);
2981 }
2982
2983 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2984 struct wpa_ssid *ssid)
2985 {
2986 if (!ssid || !ssid->disabled || ssid->disabled == 2)
2987 return;
2988
2989 ssid->disabled = 0;
2990 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2991 wpas_notify_network_enabled_changed(wpa_s, ssid);
2992
2993 /*
2994 * Try to reassociate since there is no current configuration and a new
2995 * network was made available.
2996 */
2997 if (!wpa_s->current_ssid && !wpa_s->disconnected)
2998 wpa_s->reassociate = 1;
2999 }
3000
3001
3002 /**
3003 * wpa_supplicant_add_network - Add a new network
3004 * @wpa_s: wpa_supplicant structure for a network interface
3005 * Returns: The new network configuration or %NULL if operation failed
3006 *
3007 * This function performs the following operations:
3008 * 1. Adds a new network.
3009 * 2. Send network addition notification.
3010 * 3. Marks the network disabled.
3011 * 4. Set network default parameters.
3012 */
3013 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s)
3014 {
3015 struct wpa_ssid *ssid;
3016
3017 ssid = wpa_config_add_network(wpa_s->conf);
3018 if (!ssid)
3019 return NULL;
3020 wpas_notify_network_added(wpa_s, ssid);
3021 ssid->disabled = 1;
3022 wpa_config_set_network_defaults(ssid);
3023
3024 return ssid;
3025 }
3026
3027
3028 /**
3029 * wpa_supplicant_remove_network - Remove a configured network based on id
3030 * @wpa_s: wpa_supplicant structure for a network interface
3031 * @id: Unique network id to search for
3032 * Returns: 0 on success, or -1 if the network was not found, -2 if the network
3033 * could not be removed
3034 *
3035 * This function performs the following operations:
3036 * 1. Removes the network.
3037 * 2. Send network removal notification.
3038 * 3. Update internal state machines.
3039 * 4. Stop any running sched scans.
3040 */
3041 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id)
3042 {
3043 struct wpa_ssid *ssid;
3044 int was_disabled;
3045
3046 ssid = wpa_config_get_network(wpa_s->conf, id);
3047 if (!ssid)
3048 return -1;
3049 wpas_notify_network_removed(wpa_s, ssid);
3050
3051 if (wpa_s->last_ssid == ssid)
3052 wpa_s->last_ssid = NULL;
3053
3054 if (ssid == wpa_s->current_ssid || !wpa_s->current_ssid) {
3055 #ifdef CONFIG_SME
3056 wpa_s->sme.prev_bssid_set = 0;
3057 #endif /* CONFIG_SME */
3058 /*
3059 * Invalidate the EAP session cache if the current or
3060 * previously used network is removed.
3061 */
3062 eapol_sm_invalidate_cached_session(wpa_s->eapol);
3063 }
3064
3065 if (ssid == wpa_s->current_ssid) {
3066 wpa_sm_set_config(wpa_s->wpa, NULL);
3067 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3068
3069 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3070 wpa_s->own_disconnect_req = 1;
3071 wpa_supplicant_deauthenticate(wpa_s,
3072 WLAN_REASON_DEAUTH_LEAVING);
3073 }
3074
3075 was_disabled = ssid->disabled;
3076
3077 if (wpa_config_remove_network(wpa_s->conf, id) < 0)
3078 return -2;
3079
3080 if (!was_disabled && wpa_s->sched_scanning) {
3081 wpa_printf(MSG_DEBUG,
3082 "Stop ongoing sched_scan to remove network from filters");
3083 wpa_supplicant_cancel_sched_scan(wpa_s);
3084 wpa_supplicant_req_scan(wpa_s, 0, 0);
3085 }
3086
3087 return 0;
3088 }
3089
3090
3091 /**
3092 * wpa_supplicant_enable_network - Mark a configured network as enabled
3093 * @wpa_s: wpa_supplicant structure for a network interface
3094 * @ssid: wpa_ssid structure for a configured network or %NULL
3095 *
3096 * Enables the specified network or all networks if no network specified.
3097 */
3098 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
3099 struct wpa_ssid *ssid)
3100 {
3101 if (ssid == NULL) {
3102 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3103 wpa_supplicant_enable_one_network(wpa_s, ssid);
3104 } else
3105 wpa_supplicant_enable_one_network(wpa_s, ssid);
3106
3107 if (wpa_s->reassociate && !wpa_s->disconnected &&
3108 (!wpa_s->current_ssid ||
3109 wpa_s->wpa_state == WPA_DISCONNECTED ||
3110 wpa_s->wpa_state == WPA_SCANNING)) {
3111 if (wpa_s->sched_scanning) {
3112 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
3113 "new network to scan filters");
3114 wpa_supplicant_cancel_sched_scan(wpa_s);
3115 }
3116
3117 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
3118 wpa_s->scan_req = NORMAL_SCAN_REQ;
3119 wpa_supplicant_req_scan(wpa_s, 0, 0);
3120 }
3121 }
3122 }
3123
3124
3125 /**
3126 * wpa_supplicant_disable_network - Mark a configured network as disabled
3127 * @wpa_s: wpa_supplicant structure for a network interface
3128 * @ssid: wpa_ssid structure for a configured network or %NULL
3129 *
3130 * Disables the specified network or all networks if no network specified.
3131 */
3132 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
3133 struct wpa_ssid *ssid)
3134 {
3135 struct wpa_ssid *other_ssid;
3136 int was_disabled;
3137
3138 if (ssid == NULL) {
3139 if (wpa_s->sched_scanning)
3140 wpa_supplicant_cancel_sched_scan(wpa_s);
3141
3142 for (other_ssid = wpa_s->conf->ssid; other_ssid;
3143 other_ssid = other_ssid->next) {
3144 was_disabled = other_ssid->disabled;
3145 if (was_disabled == 2)
3146 continue; /* do not change persistent P2P group
3147 * data */
3148
3149 other_ssid->disabled = 1;
3150
3151 if (was_disabled != other_ssid->disabled)
3152 wpas_notify_network_enabled_changed(
3153 wpa_s, other_ssid);
3154 }
3155 if (wpa_s->current_ssid) {
3156 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3157 wpa_s->own_disconnect_req = 1;
3158 wpa_supplicant_deauthenticate(
3159 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3160 }
3161 } else if (ssid->disabled != 2) {
3162 if (ssid == wpa_s->current_ssid) {
3163 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3164 wpa_s->own_disconnect_req = 1;
3165 wpa_supplicant_deauthenticate(
3166 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3167 }
3168
3169 was_disabled = ssid->disabled;
3170
3171 ssid->disabled = 1;
3172
3173 if (was_disabled != ssid->disabled) {
3174 wpas_notify_network_enabled_changed(wpa_s, ssid);
3175 if (wpa_s->sched_scanning) {
3176 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
3177 "to remove network from filters");
3178 wpa_supplicant_cancel_sched_scan(wpa_s);
3179 wpa_supplicant_req_scan(wpa_s, 0, 0);
3180 }
3181 }
3182 }
3183 }
3184
3185
3186 /**
3187 * wpa_supplicant_select_network - Attempt association with a network
3188 * @wpa_s: wpa_supplicant structure for a network interface
3189 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
3190 */
3191 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
3192 struct wpa_ssid *ssid)
3193 {
3194
3195 struct wpa_ssid *other_ssid;
3196 int disconnected = 0;
3197
3198 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
3199 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3200 wpa_s->own_disconnect_req = 1;
3201 wpa_supplicant_deauthenticate(
3202 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3203 disconnected = 1;
3204 }
3205
3206 if (ssid)
3207 wpas_clear_temp_disabled(wpa_s, ssid, 1);
3208
3209 /*
3210 * Mark all other networks disabled or mark all networks enabled if no
3211 * network specified.
3212 */
3213 for (other_ssid = wpa_s->conf->ssid; other_ssid;
3214 other_ssid = other_ssid->next) {
3215 int was_disabled = other_ssid->disabled;
3216 if (was_disabled == 2)
3217 continue; /* do not change persistent P2P group data */
3218
3219 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
3220 if (was_disabled && !other_ssid->disabled)
3221 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
3222
3223 if (was_disabled != other_ssid->disabled)
3224 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
3225 }
3226
3227 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
3228 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
3229 /* We are already associated with the selected network */
3230 wpa_printf(MSG_DEBUG, "Already associated with the "
3231 "selected network - do nothing");
3232 return;
3233 }
3234
3235 if (ssid) {
3236 wpa_s->current_ssid = ssid;
3237 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3238 wpa_s->connect_without_scan =
3239 (ssid->mode == WPAS_MODE_MESH) ? ssid : NULL;
3240
3241 /*
3242 * Don't optimize next scan freqs since a new ESS has been
3243 * selected.
3244 */
3245 os_free(wpa_s->next_scan_freqs);
3246 wpa_s->next_scan_freqs = NULL;
3247 } else {
3248 wpa_s->connect_without_scan = NULL;
3249 }
3250
3251 wpa_s->disconnected = 0;
3252 wpa_s->reassociate = 1;
3253
3254 if (wpa_s->connect_without_scan ||
3255 wpa_supplicant_fast_associate(wpa_s) != 1) {
3256 wpa_s->scan_req = NORMAL_SCAN_REQ;
3257 wpas_scan_reset_sched_scan(wpa_s);
3258 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
3259 }
3260
3261 if (ssid)
3262 wpas_notify_network_selected(wpa_s, ssid);
3263 }
3264
3265
3266 /**
3267 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
3268 * @wpa_s: wpa_supplicant structure for a network interface
3269 * @pkcs11_engine_path: PKCS #11 engine path or NULL
3270 * @pkcs11_module_path: PKCS #11 module path or NULL
3271 * Returns: 0 on success; -1 on failure
3272 *
3273 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
3274 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
3275 * module path fails the paths will be reset to the default value (NULL).
3276 */
3277 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
3278 const char *pkcs11_engine_path,
3279 const char *pkcs11_module_path)
3280 {
3281 char *pkcs11_engine_path_copy = NULL;
3282 char *pkcs11_module_path_copy = NULL;
3283
3284 if (pkcs11_engine_path != NULL) {
3285 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
3286 if (pkcs11_engine_path_copy == NULL)
3287 return -1;
3288 }
3289 if (pkcs11_module_path != NULL) {
3290 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
3291 if (pkcs11_module_path_copy == NULL) {
3292 os_free(pkcs11_engine_path_copy);
3293 return -1;
3294 }
3295 }
3296
3297 os_free(wpa_s->conf->pkcs11_engine_path);
3298 os_free(wpa_s->conf->pkcs11_module_path);
3299 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
3300 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
3301
3302 wpa_sm_set_eapol(wpa_s->wpa, NULL);
3303 eapol_sm_deinit(wpa_s->eapol);
3304 wpa_s->eapol = NULL;
3305 if (wpa_supplicant_init_eapol(wpa_s)) {
3306 /* Error -> Reset paths to the default value (NULL) once. */
3307 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
3308 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
3309 NULL);
3310
3311 return -1;
3312 }
3313 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3314
3315 return 0;
3316 }
3317
3318
3319 /**
3320 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
3321 * @wpa_s: wpa_supplicant structure for a network interface
3322 * @ap_scan: AP scan mode
3323 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
3324 *
3325 */
3326 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
3327 {
3328
3329 int old_ap_scan;
3330
3331 if (ap_scan < 0 || ap_scan > 2)
3332 return -1;
3333
3334 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3335 wpa_printf(MSG_INFO,
3336 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3337 }
3338
3339 #ifdef ANDROID
3340 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
3341 wpa_s->wpa_state >= WPA_ASSOCIATING &&
3342 wpa_s->wpa_state < WPA_COMPLETED) {
3343 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
3344 "associating", wpa_s->conf->ap_scan, ap_scan);
3345 return 0;
3346 }
3347 #endif /* ANDROID */
3348
3349 old_ap_scan = wpa_s->conf->ap_scan;
3350 wpa_s->conf->ap_scan = ap_scan;
3351
3352 if (old_ap_scan != wpa_s->conf->ap_scan)
3353 wpas_notify_ap_scan_changed(wpa_s);
3354
3355 return 0;
3356 }
3357
3358
3359 /**
3360 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
3361 * @wpa_s: wpa_supplicant structure for a network interface
3362 * @expire_age: Expiration age in seconds
3363 * Returns: 0 if succeed or -1 if expire_age has an invalid value
3364 *
3365 */
3366 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
3367 unsigned int bss_expire_age)
3368 {
3369 if (bss_expire_age < 10) {
3370 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
3371 bss_expire_age);
3372 return -1;
3373 }
3374 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
3375 bss_expire_age);
3376 wpa_s->conf->bss_expiration_age = bss_expire_age;
3377
3378 return 0;
3379 }
3380
3381
3382 /**
3383 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
3384 * @wpa_s: wpa_supplicant structure for a network interface
3385 * @expire_count: number of scans after which an unseen BSS is reclaimed
3386 * Returns: 0 if succeed or -1 if expire_count has an invalid value
3387 *
3388 */
3389 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
3390 unsigned int bss_expire_count)
3391 {
3392 if (bss_expire_count < 1) {
3393 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
3394 bss_expire_count);
3395 return -1;
3396 }
3397 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
3398 bss_expire_count);
3399 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
3400
3401 return 0;
3402 }
3403
3404
3405 /**
3406 * wpa_supplicant_set_scan_interval - Set scan interval
3407 * @wpa_s: wpa_supplicant structure for a network interface
3408 * @scan_interval: scan interval in seconds
3409 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
3410 *
3411 */
3412 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
3413 int scan_interval)
3414 {
3415 if (scan_interval < 0) {
3416 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
3417 scan_interval);
3418 return -1;
3419 }
3420 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3421 scan_interval);
3422 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3423
3424 return 0;
3425 }
3426
3427
3428 /**
3429 * wpa_supplicant_set_debug_params - Set global debug params
3430 * @global: wpa_global structure
3431 * @debug_level: debug level
3432 * @debug_timestamp: determines if show timestamp in debug data
3433 * @debug_show_keys: determines if show keys in debug data
3434 * Returns: 0 if succeed or -1 if debug_level has wrong value
3435 */
3436 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
3437 int debug_timestamp, int debug_show_keys)
3438 {
3439
3440 int old_level, old_timestamp, old_show_keys;
3441
3442 /* check for allowed debuglevels */
3443 if (debug_level != MSG_EXCESSIVE &&
3444 debug_level != MSG_MSGDUMP &&
3445 debug_level != MSG_DEBUG &&
3446 debug_level != MSG_INFO &&
3447 debug_level != MSG_WARNING &&
3448 debug_level != MSG_ERROR)
3449 return -1;
3450
3451 old_level = wpa_debug_level;
3452 old_timestamp = wpa_debug_timestamp;
3453 old_show_keys = wpa_debug_show_keys;
3454
3455 wpa_debug_level = debug_level;
3456 wpa_debug_timestamp = debug_timestamp ? 1 : 0;
3457 wpa_debug_show_keys = debug_show_keys ? 1 : 0;
3458
3459 if (wpa_debug_level != old_level)
3460 wpas_notify_debug_level_changed(global);
3461 if (wpa_debug_timestamp != old_timestamp)
3462 wpas_notify_debug_timestamp_changed(global);
3463 if (wpa_debug_show_keys != old_show_keys)
3464 wpas_notify_debug_show_keys_changed(global);
3465
3466 return 0;
3467 }
3468
3469
3470 /**
3471 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
3472 * @wpa_s: Pointer to wpa_supplicant data
3473 * Returns: A pointer to the current network structure or %NULL on failure
3474 */
3475 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
3476 {
3477 struct wpa_ssid *entry;
3478 u8 ssid[SSID_MAX_LEN];
3479 int res;
3480 size_t ssid_len;
3481 u8 bssid[ETH_ALEN];
3482 int wired;
3483
3484 res = wpa_drv_get_ssid(wpa_s, ssid);
3485 if (res < 0) {
3486 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
3487 "driver");
3488 return NULL;
3489 }
3490 ssid_len = res;
3491
3492 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
3493 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
3494 "driver");
3495 return NULL;
3496 }
3497
3498 wired = wpa_s->conf->ap_scan == 0 &&
3499 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
3500
3501 entry = wpa_s->conf->ssid;
3502 while (entry) {
3503 if (!wpas_network_disabled(wpa_s, entry) &&
3504 ((ssid_len == entry->ssid_len &&
3505 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
3506 (!entry->bssid_set ||
3507 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3508 return entry;
3509 #ifdef CONFIG_WPS
3510 if (!wpas_network_disabled(wpa_s, entry) &&
3511 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
3512 (entry->ssid == NULL || entry->ssid_len == 0) &&
3513 (!entry->bssid_set ||
3514 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3515 return entry;
3516 #endif /* CONFIG_WPS */
3517
3518 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
3519 entry->ssid_len == 0 &&
3520 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
3521 return entry;
3522
3523 entry = entry->next;
3524 }
3525
3526 return NULL;
3527 }
3528
3529
3530 static int select_driver(struct wpa_supplicant *wpa_s, int i)
3531 {
3532 struct wpa_global *global = wpa_s->global;
3533
3534 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
3535 global->drv_priv[i] = wpa_drivers[i]->global_init(global);
3536 if (global->drv_priv[i] == NULL) {
3537 wpa_printf(MSG_ERROR, "Failed to initialize driver "
3538 "'%s'", wpa_drivers[i]->name);
3539 return -1;
3540 }
3541 }
3542
3543 wpa_s->driver = wpa_drivers[i];
3544 wpa_s->global_drv_priv = global->drv_priv[i];
3545
3546 return 0;
3547 }
3548
3549
3550 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
3551 const char *name)
3552 {
3553 int i;
3554 size_t len;
3555 const char *pos, *driver = name;
3556
3557 if (wpa_s == NULL)
3558 return -1;
3559
3560 if (wpa_drivers[0] == NULL) {
3561 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
3562 "wpa_supplicant");
3563 return -1;
3564 }
3565
3566 if (name == NULL) {
3567 /* default to first driver in the list */
3568 return select_driver(wpa_s, 0);
3569 }
3570
3571 do {
3572 pos = os_strchr(driver, ',');
3573 if (pos)
3574 len = pos - driver;
3575 else
3576 len = os_strlen(driver);
3577
3578 for (i = 0; wpa_drivers[i]; i++) {
3579 if (os_strlen(wpa_drivers[i]->name) == len &&
3580 os_strncmp(driver, wpa_drivers[i]->name, len) ==
3581 0) {
3582 /* First driver that succeeds wins */
3583 if (select_driver(wpa_s, i) == 0)
3584 return 0;
3585 }
3586 }
3587
3588 driver = pos + 1;
3589 } while (pos);
3590
3591 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
3592 return -1;
3593 }
3594
3595
3596 /**
3597 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
3598 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3599 * with struct wpa_driver_ops::init()
3600 * @src_addr: Source address of the EAPOL frame
3601 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3602 * @len: Length of the EAPOL data
3603 *
3604 * This function is called for each received EAPOL frame. Most driver
3605 * interfaces rely on more generic OS mechanism for receiving frames through
3606 * l2_packet, but if such a mechanism is not available, the driver wrapper may
3607 * take care of received EAPOL frames and deliver them to the core supplicant
3608 * code by calling this function.
3609 */
3610 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
3611 const u8 *buf, size_t len)
3612 {
3613 struct wpa_supplicant *wpa_s = ctx;
3614
3615 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3616 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
3617
3618 #ifdef CONFIG_TESTING_OPTIONS
3619 if (wpa_s->ignore_auth_resp) {
3620 wpa_printf(MSG_INFO, "RX EAPOL - ignore_auth_resp active!");
3621 return;
3622 }
3623 #endif /* CONFIG_TESTING_OPTIONS */
3624
3625 #ifdef CONFIG_PEERKEY
3626 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
3627 wpa_s->current_ssid->peerkey &&
3628 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
3629 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
3630 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
3631 return;
3632 }
3633 #endif /* CONFIG_PEERKEY */
3634
3635 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3636 (wpa_s->last_eapol_matches_bssid &&
3637 #ifdef CONFIG_AP
3638 !wpa_s->ap_iface &&
3639 #endif /* CONFIG_AP */
3640 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3641 /*
3642 * There is possible race condition between receiving the
3643 * association event and the EAPOL frame since they are coming
3644 * through different paths from the driver. In order to avoid
3645 * issues in trying to process the EAPOL frame before receiving
3646 * association information, lets queue it for processing until
3647 * the association event is received. This may also be needed in
3648 * driver-based roaming case, so also use src_addr != BSSID as a
3649 * trigger if we have previously confirmed that the
3650 * Authenticator uses BSSID as the src_addr (which is not the
3651 * case with wired IEEE 802.1X).
3652 */
3653 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3654 "of received EAPOL frame (state=%s bssid=" MACSTR ")",
3655 wpa_supplicant_state_txt(wpa_s->wpa_state),
3656 MAC2STR(wpa_s->bssid));
3657 wpabuf_free(wpa_s->pending_eapol_rx);
3658 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3659 if (wpa_s->pending_eapol_rx) {
3660 os_get_reltime(&wpa_s->pending_eapol_rx_time);
3661 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3662 ETH_ALEN);
3663 }
3664 return;
3665 }
3666
3667 wpa_s->last_eapol_matches_bssid =
3668 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3669
3670 #ifdef CONFIG_AP
3671 if (wpa_s->ap_iface) {
3672 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3673 return;
3674 }
3675 #endif /* CONFIG_AP */
3676
3677 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3678 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3679 "no key management is configured");
3680 return;
3681 }
3682
3683 if (wpa_s->eapol_received == 0 &&
3684 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3685 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3686 wpa_s->wpa_state != WPA_COMPLETED) &&
3687 (wpa_s->current_ssid == NULL ||
3688 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3689 /* Timeout for completing IEEE 802.1X and WPA authentication */
3690 int timeout = 10;
3691
3692 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3693 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3694 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3695 /* Use longer timeout for IEEE 802.1X/EAP */
3696 timeout = 70;
3697 }
3698
3699 #ifdef CONFIG_WPS
3700 if (wpa_s->current_ssid && wpa_s->current_bss &&
3701 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3702 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3703 /*
3704 * Use shorter timeout if going through WPS AP iteration
3705 * for PIN config method with an AP that does not
3706 * advertise Selected Registrar.
3707 */
3708 struct wpabuf *wps_ie;
3709
3710 wps_ie = wpa_bss_get_vendor_ie_multi(
3711 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3712 if (wps_ie &&
3713 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3714 timeout = 10;
3715 wpabuf_free(wps_ie);
3716 }
3717 #endif /* CONFIG_WPS */
3718
3719 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3720 }
3721 wpa_s->eapol_received++;
3722
3723 if (wpa_s->countermeasures) {
3724 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3725 "EAPOL packet");
3726 return;
3727 }
3728
3729 #ifdef CONFIG_IBSS_RSN
3730 if (wpa_s->current_ssid &&
3731 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3732 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3733 return;
3734 }
3735 #endif /* CONFIG_IBSS_RSN */
3736
3737 /* Source address of the incoming EAPOL frame could be compared to the
3738 * current BSSID. However, it is possible that a centralized
3739 * Authenticator could be using another MAC address than the BSSID of
3740 * an AP, so just allow any address to be used for now. The replies are
3741 * still sent to the current BSSID (if available), though. */
3742
3743 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3744 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3745 wpa_s->key_mgmt != WPA_KEY_MGMT_OWE &&
3746 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3747 return;
3748 wpa_drv_poll(wpa_s);
3749 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3750 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3751 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3752 /*
3753 * Set portValid = TRUE here since we are going to skip 4-way
3754 * handshake processing which would normally set portValid. We
3755 * need this to allow the EAPOL state machines to be completed
3756 * without going through EAPOL-Key handshake.
3757 */
3758 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3759 }
3760 }
3761
3762
3763 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3764 {
3765 if ((!wpa_s->p2p_mgmt ||
3766 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3767 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3768 l2_packet_deinit(wpa_s->l2);
3769 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3770 wpa_drv_get_mac_addr(wpa_s),
3771 ETH_P_EAPOL,
3772 wpa_supplicant_rx_eapol, wpa_s, 0);
3773 if (wpa_s->l2 == NULL)
3774 return -1;
3775 } else {
3776 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3777 if (addr)
3778 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3779 }
3780
3781 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3782 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3783 return -1;
3784 }
3785
3786 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3787
3788 return 0;
3789 }
3790
3791
3792 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
3793 const u8 *buf, size_t len)
3794 {
3795 struct wpa_supplicant *wpa_s = ctx;
3796 const struct l2_ethhdr *eth;
3797
3798 if (len < sizeof(*eth))
3799 return;
3800 eth = (const struct l2_ethhdr *) buf;
3801
3802 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3803 !(eth->h_dest[0] & 0x01)) {
3804 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3805 " (bridge - not for this interface - ignore)",
3806 MAC2STR(src_addr), MAC2STR(eth->h_dest));
3807 return;
3808 }
3809
3810 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3811 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
3812 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
3813 len - sizeof(*eth));
3814 }
3815
3816
3817 /**
3818 * wpa_supplicant_driver_init - Initialize driver interface parameters
3819 * @wpa_s: Pointer to wpa_supplicant data
3820 * Returns: 0 on success, -1 on failure
3821 *
3822 * This function is called to initialize driver interface parameters.
3823 * wpa_drv_init() must have been called before this function to initialize the
3824 * driver interface.
3825 */
3826 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
3827 {
3828 static int interface_count = 0;
3829
3830 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
3831 return -1;
3832
3833 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
3834 MAC2STR(wpa_s->own_addr));
3835 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
3836 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3837
3838 if (wpa_s->bridge_ifname[0]) {
3839 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
3840 "interface '%s'", wpa_s->bridge_ifname);
3841 wpa_s->l2_br = l2_packet_init_bridge(
3842 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
3843 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
3844 if (wpa_s->l2_br == NULL) {
3845 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
3846 "connection for the bridge interface '%s'",
3847 wpa_s->bridge_ifname);
3848 return -1;
3849 }
3850 }
3851
3852 if (wpa_s->conf->ap_scan == 2 &&
3853 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3854 wpa_printf(MSG_INFO,
3855 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3856 }
3857
3858 wpa_clear_keys(wpa_s, NULL);
3859
3860 /* Make sure that TKIP countermeasures are not left enabled (could
3861 * happen if wpa_supplicant is killed during countermeasures. */
3862 wpa_drv_set_countermeasures(wpa_s, 0);
3863
3864 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
3865 wpa_drv_flush_pmkid(wpa_s);
3866
3867 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
3868 wpa_s->prev_scan_wildcard = 0;
3869
3870 if (wpa_supplicant_enabled_networks(wpa_s)) {
3871 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
3872 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3873 interface_count = 0;
3874 }
3875 #ifndef ANDROID
3876 if (!wpa_s->p2p_mgmt &&
3877 wpa_supplicant_delayed_sched_scan(wpa_s,
3878 interface_count % 3,
3879 100000))
3880 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
3881 100000);
3882 #endif /* ANDROID */
3883 interface_count++;
3884 } else
3885 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
3886
3887 return 0;
3888 }
3889
3890
3891 static int wpa_supplicant_daemon(const char *pid_file)
3892 {
3893 wpa_printf(MSG_DEBUG, "Daemonize..");
3894 return os_daemonize(pid_file);
3895 }
3896
3897
3898 static struct wpa_supplicant *
3899 wpa_supplicant_alloc(struct wpa_supplicant *parent)
3900 {
3901 struct wpa_supplicant *wpa_s;
3902
3903 wpa_s = os_zalloc(sizeof(*wpa_s));
3904 if (wpa_s == NULL)
3905 return NULL;
3906 wpa_s->scan_req = INITIAL_SCAN_REQ;
3907 wpa_s->scan_interval = 5;
3908 wpa_s->new_connection = 1;
3909 wpa_s->parent = parent ? parent : wpa_s;
3910 wpa_s->p2pdev = wpa_s->parent;
3911 wpa_s->sched_scanning = 0;
3912
3913 dl_list_init(&wpa_s->bss_tmp_disallowed);
3914 dl_list_init(&wpa_s->fils_hlp_req);
3915
3916 return wpa_s;
3917 }
3918
3919
3920 #ifdef CONFIG_HT_OVERRIDES
3921
3922 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
3923 struct ieee80211_ht_capabilities *htcaps,
3924 struct ieee80211_ht_capabilities *htcaps_mask,
3925 const char *ht_mcs)
3926 {
3927 /* parse ht_mcs into hex array */
3928 int i;
3929 const char *tmp = ht_mcs;
3930 char *end = NULL;
3931
3932 /* If ht_mcs is null, do not set anything */
3933 if (!ht_mcs)
3934 return 0;
3935
3936 /* This is what we are setting in the kernel */
3937 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
3938
3939 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
3940
3941 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3942 long v;
3943
3944 errno = 0;
3945 v = strtol(tmp, &end, 16);
3946
3947 if (errno == 0) {
3948 wpa_msg(wpa_s, MSG_DEBUG,
3949 "htcap value[%i]: %ld end: %p tmp: %p",
3950 i, v, end, tmp);
3951 if (end == tmp)
3952 break;
3953
3954 htcaps->supported_mcs_set[i] = v;
3955 tmp = end;
3956 } else {
3957 wpa_msg(wpa_s, MSG_ERROR,
3958 "Failed to parse ht-mcs: %s, error: %s\n",
3959 ht_mcs, strerror(errno));
3960 return -1;
3961 }
3962 }
3963
3964 /*
3965 * If we were able to parse any values, then set mask for the MCS set.
3966 */
3967 if (i) {
3968 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
3969 IEEE80211_HT_MCS_MASK_LEN - 1);
3970 /* skip the 3 reserved bits */
3971 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
3972 0x1f;
3973 }
3974
3975 return 0;
3976 }
3977
3978
3979 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
3980 struct ieee80211_ht_capabilities *htcaps,
3981 struct ieee80211_ht_capabilities *htcaps_mask,
3982 int disabled)
3983 {
3984 le16 msk;
3985
3986 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3987
3988 if (disabled == -1)
3989 return 0;
3990
3991 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3992 htcaps_mask->ht_capabilities_info |= msk;
3993 if (disabled)
3994 htcaps->ht_capabilities_info &= msk;
3995 else
3996 htcaps->ht_capabilities_info |= msk;
3997
3998 return 0;
3999 }
4000
4001
4002 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
4003 struct ieee80211_ht_capabilities *htcaps,
4004 struct ieee80211_ht_capabilities *htcaps_mask,
4005 int factor)
4006 {
4007 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
4008
4009 if (factor == -1)
4010 return 0;
4011
4012 if (factor < 0 || factor > 3) {
4013 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
4014 "Must be 0-3 or -1", factor);
4015 return -EINVAL;
4016 }
4017
4018 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
4019 htcaps->a_mpdu_params &= ~0x3;
4020 htcaps->a_mpdu_params |= factor & 0x3;
4021
4022 return 0;
4023 }
4024
4025
4026 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
4027 struct ieee80211_ht_capabilities *htcaps,
4028 struct ieee80211_ht_capabilities *htcaps_mask,
4029 int density)
4030 {
4031 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
4032
4033 if (density == -1)
4034 return 0;
4035
4036 if (density < 0 || density > 7) {
4037 wpa_msg(wpa_s, MSG_ERROR,
4038 "ampdu_density: %d out of range. Must be 0-7 or -1.",
4039 density);
4040 return -EINVAL;
4041 }
4042
4043 htcaps_mask->a_mpdu_params |= 0x1C;
4044 htcaps->a_mpdu_params &= ~(0x1C);
4045 htcaps->a_mpdu_params |= (density << 2) & 0x1C;
4046
4047 return 0;
4048 }
4049
4050
4051 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
4052 struct ieee80211_ht_capabilities *htcaps,
4053 struct ieee80211_ht_capabilities *htcaps_mask,
4054 int disabled)
4055 {
4056 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
4057
4058 set_disable_ht40(htcaps, disabled);
4059 set_disable_ht40(htcaps_mask, 0);
4060
4061 return 0;
4062 }
4063
4064
4065 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
4066 struct ieee80211_ht_capabilities *htcaps,
4067 struct ieee80211_ht_capabilities *htcaps_mask,
4068 int disabled)
4069 {
4070 /* Masking these out disables SGI */
4071 le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
4072 HT_CAP_INFO_SHORT_GI40MHZ);
4073
4074 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
4075
4076 if (disabled)
4077 htcaps->ht_capabilities_info &= ~msk;
4078 else
4079 htcaps->ht_capabilities_info |= msk;
4080
4081 htcaps_mask->ht_capabilities_info |= msk;
4082
4083 return 0;
4084 }
4085
4086
4087 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
4088 struct ieee80211_ht_capabilities *htcaps,
4089 struct ieee80211_ht_capabilities *htcaps_mask,
4090 int disabled)
4091 {
4092 /* Masking these out disables LDPC */
4093 le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
4094
4095 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
4096
4097 if (disabled)
4098 htcaps->ht_capabilities_info &= ~msk;
4099 else
4100 htcaps->ht_capabilities_info |= msk;
4101
4102 htcaps_mask->ht_capabilities_info |= msk;
4103
4104 return 0;
4105 }
4106
4107
4108 void wpa_supplicant_apply_ht_overrides(
4109 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4110 struct wpa_driver_associate_params *params)
4111 {
4112 struct ieee80211_ht_capabilities *htcaps;
4113 struct ieee80211_ht_capabilities *htcaps_mask;
4114
4115 if (!ssid)
4116 return;
4117
4118 params->disable_ht = ssid->disable_ht;
4119 if (!params->htcaps || !params->htcaps_mask)
4120 return;
4121
4122 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
4123 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
4124 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
4125 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
4126 ssid->disable_max_amsdu);
4127 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
4128 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
4129 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
4130 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
4131 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
4132
4133 if (ssid->ht40_intolerant) {
4134 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
4135 htcaps->ht_capabilities_info |= bit;
4136 htcaps_mask->ht_capabilities_info |= bit;
4137 }
4138 }
4139
4140 #endif /* CONFIG_HT_OVERRIDES */
4141
4142
4143 #ifdef CONFIG_VHT_OVERRIDES
4144 void wpa_supplicant_apply_vht_overrides(
4145 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4146 struct wpa_driver_associate_params *params)
4147 {
4148 struct ieee80211_vht_capabilities *vhtcaps;
4149 struct ieee80211_vht_capabilities *vhtcaps_mask;
4150
4151 if (!ssid)
4152 return;
4153
4154 params->disable_vht = ssid->disable_vht;
4155
4156 vhtcaps = (void *) params->vhtcaps;
4157 vhtcaps_mask = (void *) params->vhtcaps_mask;
4158
4159 if (!vhtcaps || !vhtcaps_mask)
4160 return;
4161
4162 vhtcaps->vht_capabilities_info = host_to_le32(ssid->vht_capa);
4163 vhtcaps_mask->vht_capabilities_info = host_to_le32(ssid->vht_capa_mask);
4164
4165 #ifdef CONFIG_HT_OVERRIDES
4166 /* if max ampdu is <= 3, we have to make the HT cap the same */
4167 if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) {
4168 int max_ampdu;
4169
4170 max_ampdu = (ssid->vht_capa &
4171 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >>
4172 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT;
4173
4174 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
4175 wpa_set_ampdu_factor(wpa_s,
4176 (void *) params->htcaps,
4177 (void *) params->htcaps_mask,
4178 max_ampdu);
4179 }
4180 #endif /* CONFIG_HT_OVERRIDES */
4181
4182 #define OVERRIDE_MCS(i) \
4183 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
4184 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
4185 host_to_le16(3 << 2 * (i - 1)); \
4186 vhtcaps->vht_supported_mcs_set.tx_map |= \
4187 host_to_le16(ssid->vht_tx_mcs_nss_ ##i << \
4188 2 * (i - 1)); \
4189 } \
4190 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
4191 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
4192 host_to_le16(3 << 2 * (i - 1)); \
4193 vhtcaps->vht_supported_mcs_set.rx_map |= \
4194 host_to_le16(ssid->vht_rx_mcs_nss_ ##i << \
4195 2 * (i - 1)); \
4196 }
4197
4198 OVERRIDE_MCS(1);
4199 OVERRIDE_MCS(2);
4200 OVERRIDE_MCS(3);
4201 OVERRIDE_MCS(4);
4202 OVERRIDE_MCS(5);
4203 OVERRIDE_MCS(6);
4204 OVERRIDE_MCS(7);
4205 OVERRIDE_MCS(8);
4206 }
4207 #endif /* CONFIG_VHT_OVERRIDES */
4208
4209
4210 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
4211 {
4212 #ifdef PCSC_FUNCS
4213 size_t len;
4214
4215 if (!wpa_s->conf->pcsc_reader)
4216 return 0;
4217
4218 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
4219 if (!wpa_s->scard)
4220 return 1;
4221
4222 if (wpa_s->conf->pcsc_pin &&
4223 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
4224 scard_deinit(wpa_s->scard);
4225 wpa_s->scard = NULL;
4226 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
4227 return -1;
4228 }
4229
4230 len = sizeof(wpa_s->imsi) - 1;
4231 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
4232 scard_deinit(wpa_s->scard);
4233 wpa_s->scard = NULL;
4234 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
4235 return -1;
4236 }
4237 wpa_s->imsi[len] = '\0';
4238
4239 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
4240
4241 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
4242 wpa_s->imsi, wpa_s->mnc_len);
4243
4244 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
4245 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
4246 #endif /* PCSC_FUNCS */
4247
4248 return 0;
4249 }
4250
4251
4252 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
4253 {
4254 char *val, *pos;
4255
4256 ext_password_deinit(wpa_s->ext_pw);
4257 wpa_s->ext_pw = NULL;
4258 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
4259
4260 if (!wpa_s->conf->ext_password_backend)
4261 return 0;
4262
4263 val = os_strdup(wpa_s->conf->ext_password_backend);
4264 if (val == NULL)
4265 return -1;
4266 pos = os_strchr(val, ':');
4267 if (pos)
4268 *pos++ = '\0';
4269
4270 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
4271
4272 wpa_s->ext_pw = ext_password_init(val, pos);
4273 os_free(val);
4274 if (wpa_s->ext_pw == NULL) {
4275 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
4276 return -1;
4277 }
4278 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
4279
4280 return 0;
4281 }
4282
4283
4284 #ifdef CONFIG_FST
4285
4286 static const u8 * wpas_fst_get_bssid_cb(void *ctx)
4287 {
4288 struct wpa_supplicant *wpa_s = ctx;
4289
4290 return (is_zero_ether_addr(wpa_s->bssid) ||
4291 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
4292 }
4293
4294
4295 static void wpas_fst_get_channel_info_cb(void *ctx,
4296 enum hostapd_hw_mode *hw_mode,
4297 u8 *channel)
4298 {
4299 struct wpa_supplicant *wpa_s = ctx;
4300
4301 if (wpa_s->current_bss) {
4302 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
4303 channel);
4304 } else if (wpa_s->hw.num_modes) {
4305 *hw_mode = wpa_s->hw.modes[0].mode;
4306 } else {
4307 WPA_ASSERT(0);
4308 *hw_mode = 0;
4309 }
4310 }
4311
4312
4313 static int wpas_fst_get_hw_modes(void *ctx, struct hostapd_hw_modes **modes)
4314 {
4315 struct wpa_supplicant *wpa_s = ctx;
4316
4317 *modes = wpa_s->hw.modes;
4318 return wpa_s->hw.num_modes;
4319 }
4320
4321
4322 static void wpas_fst_set_ies_cb(void *ctx, const struct wpabuf *fst_ies)
4323 {
4324 struct wpa_supplicant *wpa_s = ctx;
4325
4326 wpa_hexdump_buf(MSG_DEBUG, "FST: Set IEs", fst_ies);
4327 wpa_s->fst_ies = fst_ies;
4328 }
4329
4330
4331 static int wpas_fst_send_action_cb(void *ctx, const u8 *da, struct wpabuf *data)
4332 {
4333 struct wpa_supplicant *wpa_s = ctx;
4334
4335 if (os_memcmp(wpa_s->bssid, da, ETH_ALEN) != 0) {
4336 wpa_printf(MSG_INFO, "FST:%s:bssid=" MACSTR " != da=" MACSTR,
4337 __func__, MAC2STR(wpa_s->bssid), MAC2STR(da));
4338 return -1;
4339 }
4340 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
4341 wpa_s->own_addr, wpa_s->bssid,
4342 wpabuf_head(data), wpabuf_len(data),
4343 0);
4344 }
4345
4346
4347 static const struct wpabuf * wpas_fst_get_mb_ie_cb(void *ctx, const u8 *addr)
4348 {
4349 struct wpa_supplicant *wpa_s = ctx;
4350
4351 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4352 return wpa_s->received_mb_ies;
4353 }
4354
4355
4356 static void wpas_fst_update_mb_ie_cb(void *ctx, const u8 *addr,
4357 const u8 *buf, size_t size)
4358 {
4359 struct wpa_supplicant *wpa_s = ctx;
4360 struct mb_ies_info info;
4361
4362 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4363
4364 if (!mb_ies_info_by_ies(&info, buf, size)) {
4365 wpabuf_free(wpa_s->received_mb_ies);
4366 wpa_s->received_mb_ies = mb_ies_by_info(&info);
4367 }
4368 }
4369
4370
4371 static const u8 * wpas_fst_get_peer_first(void *ctx,
4372 struct fst_get_peer_ctx **get_ctx,
4373 Boolean mb_only)
4374 {
4375 struct wpa_supplicant *wpa_s = ctx;
4376
4377 *get_ctx = NULL;
4378 if (!is_zero_ether_addr(wpa_s->bssid))
4379 return (wpa_s->received_mb_ies || !mb_only) ?
4380 wpa_s->bssid : NULL;
4381 return NULL;
4382 }
4383
4384
4385 static const u8 * wpas_fst_get_peer_next(void *ctx,
4386 struct fst_get_peer_ctx **get_ctx,
4387 Boolean mb_only)
4388 {
4389 return NULL;
4390 }
4391
4392 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
4393 struct fst_wpa_obj *iface_obj)
4394 {
4395 iface_obj->ctx = wpa_s;
4396 iface_obj->get_bssid = wpas_fst_get_bssid_cb;
4397 iface_obj->get_channel_info = wpas_fst_get_channel_info_cb;
4398 iface_obj->get_hw_modes = wpas_fst_get_hw_modes;
4399 iface_obj->set_ies = wpas_fst_set_ies_cb;
4400 iface_obj->send_action = wpas_fst_send_action_cb;
4401 iface_obj->get_mb_ie = wpas_fst_get_mb_ie_cb;
4402 iface_obj->update_mb_ie = wpas_fst_update_mb_ie_cb;
4403 iface_obj->get_peer_first = wpas_fst_get_peer_first;
4404 iface_obj->get_peer_next = wpas_fst_get_peer_next;
4405 }
4406 #endif /* CONFIG_FST */
4407
4408 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
4409 const struct wpa_driver_capa *capa)
4410 {
4411 struct wowlan_triggers *triggers;
4412 int ret = 0;
4413
4414 if (!wpa_s->conf->wowlan_triggers)
4415 return 0;
4416
4417 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
4418 if (triggers) {
4419 ret = wpa_drv_wowlan(wpa_s, triggers);
4420 os_free(triggers);
4421 }
4422 return ret;
4423 }
4424
4425
4426 enum wpa_radio_work_band wpas_freq_to_band(int freq)
4427 {
4428 if (freq < 3000)
4429 return BAND_2_4_GHZ;
4430 if (freq > 50000)
4431 return BAND_60_GHZ;
4432 return BAND_5_GHZ;
4433 }
4434
4435
4436 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
4437 {
4438 int i;
4439 unsigned int band = 0;
4440
4441 if (freqs) {
4442 /* freqs are specified for the radio work */
4443 for (i = 0; freqs[i]; i++)
4444 band |= wpas_freq_to_band(freqs[i]);
4445 } else {
4446 /*
4447 * freqs are not specified, implies all
4448 * the supported freqs by HW
4449 */
4450 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4451 if (wpa_s->hw.modes[i].num_channels != 0) {
4452 if (wpa_s->hw.modes[i].mode ==
4453 HOSTAPD_MODE_IEEE80211B ||
4454 wpa_s->hw.modes[i].mode ==
4455 HOSTAPD_MODE_IEEE80211G)
4456 band |= BAND_2_4_GHZ;
4457 else if (wpa_s->hw.modes[i].mode ==
4458 HOSTAPD_MODE_IEEE80211A)
4459 band |= BAND_5_GHZ;
4460 else if (wpa_s->hw.modes[i].mode ==
4461 HOSTAPD_MODE_IEEE80211AD)
4462 band |= BAND_60_GHZ;
4463 else if (wpa_s->hw.modes[i].mode ==
4464 HOSTAPD_MODE_IEEE80211ANY)
4465 band = BAND_2_4_GHZ | BAND_5_GHZ |
4466 BAND_60_GHZ;
4467 }
4468 }
4469 }
4470
4471 return band;
4472 }
4473
4474
4475 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
4476 const char *rn)
4477 {
4478 struct wpa_supplicant *iface = wpa_s->global->ifaces;
4479 struct wpa_radio *radio;
4480
4481 while (rn && iface) {
4482 radio = iface->radio;
4483 if (radio && os_strcmp(rn, radio->name) == 0) {
4484 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
4485 wpa_s->ifname, rn);
4486 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4487 return radio;
4488 }
4489
4490 iface = iface->next;
4491 }
4492
4493 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
4494 wpa_s->ifname, rn ? rn : "N/A");
4495 radio = os_zalloc(sizeof(*radio));
4496 if (radio == NULL)
4497 return NULL;
4498
4499 if (rn)
4500 os_strlcpy(radio->name, rn, sizeof(radio->name));
4501 dl_list_init(&radio->ifaces);
4502 dl_list_init(&radio->work);
4503 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4504
4505 return radio;
4506 }
4507
4508
4509 static void radio_work_free(struct wpa_radio_work *work)
4510 {
4511 if (work->wpa_s->scan_work == work) {
4512 /* This should not really happen. */
4513 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4514 work->type, work, work->started);
4515 work->wpa_s->scan_work = NULL;
4516 }
4517
4518 #ifdef CONFIG_P2P
4519 if (work->wpa_s->p2p_scan_work == work) {
4520 /* This should not really happen. */
4521 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4522 work->type, work, work->started);
4523 work->wpa_s->p2p_scan_work = NULL;
4524 }
4525 #endif /* CONFIG_P2P */
4526
4527 if (work->started) {
4528 work->wpa_s->radio->num_active_works--;
4529 wpa_dbg(work->wpa_s, MSG_DEBUG,
4530 "radio_work_free('%s'@%p: num_active_works --> %u",
4531 work->type, work,
4532 work->wpa_s->radio->num_active_works);
4533 }
4534
4535 dl_list_del(&work->list);
4536 os_free(work);
4537 }
4538
4539
4540 static int radio_work_is_connect(struct wpa_radio_work *work)
4541 {
4542 return os_strcmp(work->type, "sme-connect") == 0 ||
4543 os_strcmp(work->type, "connect") == 0;
4544 }
4545
4546
4547 static int radio_work_is_scan(struct wpa_radio_work *work)
4548 {
4549 return os_strcmp(work->type, "scan") == 0 ||
4550 os_strcmp(work->type, "p2p-scan") == 0;
4551 }
4552
4553
4554 static struct wpa_radio_work * radio_work_get_next_work(struct wpa_radio *radio)
4555 {
4556 struct wpa_radio_work *active_work = NULL;
4557 struct wpa_radio_work *tmp;
4558
4559 /* Get the active work to know the type and band. */
4560 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4561 if (tmp->started) {
4562 active_work = tmp;
4563 break;
4564 }
4565 }
4566
4567 if (!active_work) {
4568 /* No active work, start one */
4569 radio->num_active_works = 0;
4570 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work,
4571 list) {
4572 if (os_strcmp(tmp->type, "scan") == 0 &&
4573 radio->external_scan_running &&
4574 (((struct wpa_driver_scan_params *)
4575 tmp->ctx)->only_new_results ||
4576 tmp->wpa_s->clear_driver_scan_cache))
4577 continue;
4578 return tmp;
4579 }
4580 return NULL;
4581 }
4582
4583 if (radio_work_is_connect(active_work)) {
4584 /*
4585 * If the active work is either connect or sme-connect,
4586 * do not parallelize them with other radio works.
4587 */
4588 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4589 "Do not parallelize radio work with %s",
4590 active_work->type);
4591 return NULL;
4592 }
4593
4594 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4595 if (tmp->started)
4596 continue;
4597
4598 /*
4599 * If connect or sme-connect are enqueued, parallelize only
4600 * those operations ahead of them in the queue.
4601 */
4602 if (radio_work_is_connect(tmp))
4603 break;
4604
4605 /* Serialize parallel scan and p2p_scan operations on the same
4606 * interface since the driver_nl80211 mechanism for tracking
4607 * scan cookies does not yet have support for this. */
4608 if (active_work->wpa_s == tmp->wpa_s &&
4609 radio_work_is_scan(active_work) &&
4610 radio_work_is_scan(tmp)) {
4611 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4612 "Do not start work '%s' when another work '%s' is already scheduled",
4613 tmp->type, active_work->type);
4614 continue;
4615 }
4616 /*
4617 * Check that the radio works are distinct and
4618 * on different bands.
4619 */
4620 if (os_strcmp(active_work->type, tmp->type) != 0 &&
4621 (active_work->bands != tmp->bands)) {
4622 /*
4623 * If a scan has to be scheduled through nl80211 scan
4624 * interface and if an external scan is already running,
4625 * do not schedule the scan since it is likely to get
4626 * rejected by kernel.
4627 */
4628 if (os_strcmp(tmp->type, "scan") == 0 &&
4629 radio->external_scan_running &&
4630 (((struct wpa_driver_scan_params *)
4631 tmp->ctx)->only_new_results ||
4632 tmp->wpa_s->clear_driver_scan_cache))
4633 continue;
4634
4635 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4636 "active_work:%s new_work:%s",
4637 active_work->type, tmp->type);
4638 return tmp;
4639 }
4640 }
4641
4642 /* Did not find a radio work to schedule in parallel. */
4643 return NULL;
4644 }
4645
4646
4647 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
4648 {
4649 struct wpa_radio *radio = eloop_ctx;
4650 struct wpa_radio_work *work;
4651 struct os_reltime now, diff;
4652 struct wpa_supplicant *wpa_s;
4653
4654 work = dl_list_first(&radio->work, struct wpa_radio_work, list);
4655 if (work == NULL) {
4656 radio->num_active_works = 0;
4657 return;
4658 }
4659
4660 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
4661 radio_list);
4662
4663 if (!(wpa_s &&
4664 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
4665 if (work->started)
4666 return; /* already started and still in progress */
4667
4668 if (wpa_s && wpa_s->radio->external_scan_running) {
4669 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
4670 return;
4671 }
4672 } else {
4673 work = NULL;
4674 if (radio->num_active_works < MAX_ACTIVE_WORKS) {
4675 /* get the work to schedule next */
4676 work = radio_work_get_next_work(radio);
4677 }
4678 if (!work)
4679 return;
4680 }
4681
4682 wpa_s = work->wpa_s;
4683 os_get_reltime(&now);
4684 os_reltime_sub(&now, &work->time, &diff);
4685 wpa_dbg(wpa_s, MSG_DEBUG,
4686 "Starting radio work '%s'@%p after %ld.%06ld second wait",
4687 work->type, work, diff.sec, diff.usec);
4688 work->started = 1;
4689 work->time = now;
4690 radio->num_active_works++;
4691
4692 work->cb(work, 0);
4693
4694 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
4695 radio->num_active_works < MAX_ACTIVE_WORKS)
4696 radio_work_check_next(wpa_s);
4697 }
4698
4699
4700 /*
4701 * This function removes both started and pending radio works running on
4702 * the provided interface's radio.
4703 * Prior to the removal of the radio work, its callback (cb) is called with
4704 * deinit set to be 1. Each work's callback is responsible for clearing its
4705 * internal data and restoring to a correct state.
4706 * @wpa_s: wpa_supplicant data
4707 * @type: type of works to be removed
4708 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
4709 * this interface's works.
4710 */
4711 void radio_remove_works(struct wpa_supplicant *wpa_s,
4712 const char *type, int remove_all)
4713 {
4714 struct wpa_radio_work *work, *tmp;
4715 struct wpa_radio *radio = wpa_s->radio;
4716
4717 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
4718 list) {
4719 if (type && os_strcmp(type, work->type) != 0)
4720 continue;
4721
4722 /* skip other ifaces' works */
4723 if (!remove_all && work->wpa_s != wpa_s)
4724 continue;
4725
4726 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
4727 work->type, work, work->started ? " (started)" : "");
4728 work->cb(work, 1);
4729 radio_work_free(work);
4730 }
4731
4732 /* in case we removed the started work */
4733 radio_work_check_next(wpa_s);
4734 }
4735
4736
4737 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
4738 {
4739 struct wpa_radio *radio = wpa_s->radio;
4740
4741 if (!radio)
4742 return;
4743
4744 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
4745 wpa_s->ifname, radio->name);
4746 dl_list_del(&wpa_s->radio_list);
4747 radio_remove_works(wpa_s, NULL, 0);
4748 wpa_s->radio = NULL;
4749 if (!dl_list_empty(&radio->ifaces))
4750 return; /* Interfaces remain for this radio */
4751
4752 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
4753 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4754 os_free(radio);
4755 }
4756
4757
4758 void radio_work_check_next(struct wpa_supplicant *wpa_s)
4759 {
4760 struct wpa_radio *radio = wpa_s->radio;
4761
4762 if (dl_list_empty(&radio->work))
4763 return;
4764 if (wpa_s->ext_work_in_progress) {
4765 wpa_printf(MSG_DEBUG,
4766 "External radio work in progress - delay start of pending item");
4767 return;
4768 }
4769 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4770 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
4771 }
4772
4773
4774 /**
4775 * radio_add_work - Add a radio work item
4776 * @wpa_s: Pointer to wpa_supplicant data
4777 * @freq: Frequency of the offchannel operation in MHz or 0
4778 * @type: Unique identifier for each type of work
4779 * @next: Force as the next work to be executed
4780 * @cb: Callback function for indicating when radio is available
4781 * @ctx: Context pointer for the work (work->ctx in cb())
4782 * Returns: 0 on success, -1 on failure
4783 *
4784 * This function is used to request time for an operation that requires
4785 * exclusive radio control. Once the radio is available, the registered callback
4786 * function will be called. radio_work_done() must be called once the exclusive
4787 * radio operation has been completed, so that the radio is freed for other
4788 * operations. The special case of deinit=1 is used to free the context data
4789 * during interface removal. That does not allow the callback function to start
4790 * the radio operation, i.e., it must free any resources allocated for the radio
4791 * work and return.
4792 *
4793 * The @freq parameter can be used to indicate a single channel on which the
4794 * offchannel operation will occur. This may allow multiple radio work
4795 * operations to be performed in parallel if they apply for the same channel.
4796 * Setting this to 0 indicates that the work item may use multiple channels or
4797 * requires exclusive control of the radio.
4798 */
4799 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
4800 const char *type, int next,
4801 void (*cb)(struct wpa_radio_work *work, int deinit),
4802 void *ctx)
4803 {
4804 struct wpa_radio *radio = wpa_s->radio;
4805 struct wpa_radio_work *work;
4806 int was_empty;
4807
4808 work = os_zalloc(sizeof(*work));
4809 if (work == NULL)
4810 return -1;
4811 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
4812 os_get_reltime(&work->time);
4813 work->freq = freq;
4814 work->type = type;
4815 work->wpa_s = wpa_s;
4816 work->cb = cb;
4817 work->ctx = ctx;
4818
4819 if (freq)
4820 work->bands = wpas_freq_to_band(freq);
4821 else if (os_strcmp(type, "scan") == 0 ||
4822 os_strcmp(type, "p2p-scan") == 0)
4823 work->bands = wpas_get_bands(wpa_s,
4824 ((struct wpa_driver_scan_params *)
4825 ctx)->freqs);
4826 else
4827 work->bands = wpas_get_bands(wpa_s, NULL);
4828
4829 was_empty = dl_list_empty(&wpa_s->radio->work);
4830 if (next)
4831 dl_list_add(&wpa_s->radio->work, &work->list);
4832 else
4833 dl_list_add_tail(&wpa_s->radio->work, &work->list);
4834 if (was_empty) {
4835 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
4836 radio_work_check_next(wpa_s);
4837 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
4838 && radio->num_active_works < MAX_ACTIVE_WORKS) {
4839 wpa_dbg(wpa_s, MSG_DEBUG,
4840 "Try to schedule a radio work (num_active_works=%u)",
4841 radio->num_active_works);
4842 radio_work_check_next(wpa_s);
4843 }
4844
4845 return 0;
4846 }
4847
4848
4849 /**
4850 * radio_work_done - Indicate that a radio work item has been completed
4851 * @work: Completed work
4852 *
4853 * This function is called once the callback function registered with
4854 * radio_add_work() has completed its work.
4855 */
4856 void radio_work_done(struct wpa_radio_work *work)
4857 {
4858 struct wpa_supplicant *wpa_s = work->wpa_s;
4859 struct os_reltime now, diff;
4860 unsigned int started = work->started;
4861
4862 os_get_reltime(&now);
4863 os_reltime_sub(&now, &work->time, &diff);
4864 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
4865 work->type, work, started ? "done" : "canceled",
4866 diff.sec, diff.usec);
4867 radio_work_free(work);
4868 if (started)
4869 radio_work_check_next(wpa_s);
4870 }
4871
4872
4873 struct wpa_radio_work *
4874 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
4875 {
4876 struct wpa_radio_work *work;
4877 struct wpa_radio *radio = wpa_s->radio;
4878
4879 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
4880 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
4881 return work;
4882 }
4883
4884 return NULL;
4885 }
4886
4887
4888 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
4889 struct wpa_interface *iface)
4890 {
4891 const char *ifname, *driver, *rn;
4892
4893 driver = iface->driver;
4894 next_driver:
4895 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
4896 return -1;
4897
4898 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
4899 if (wpa_s->drv_priv == NULL) {
4900 const char *pos;
4901 pos = driver ? os_strchr(driver, ',') : NULL;
4902 if (pos) {
4903 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
4904 "driver interface - try next driver wrapper");
4905 driver = pos + 1;
4906 goto next_driver;
4907 }
4908 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
4909 "interface");
4910 return -1;
4911 }
4912 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
4913 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
4914 "driver_param '%s'", wpa_s->conf->driver_param);
4915 return -1;
4916 }
4917
4918 ifname = wpa_drv_get_ifname(wpa_s);
4919 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
4920 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
4921 "interface name with '%s'", ifname);
4922 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
4923 }
4924
4925 rn = wpa_driver_get_radio_name(wpa_s);
4926 if (rn && rn[0] == '\0')
4927 rn = NULL;
4928
4929 wpa_s->radio = radio_add_interface(wpa_s, rn);
4930 if (wpa_s->radio == NULL)
4931 return -1;
4932
4933 return 0;
4934 }
4935
4936
4937 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
4938 struct wpa_interface *iface)
4939 {
4940 struct wpa_driver_capa capa;
4941 int capa_res;
4942
4943 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
4944 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
4945 iface->confname ? iface->confname : "N/A",
4946 iface->driver ? iface->driver : "default",
4947 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
4948 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
4949
4950 if (iface->confname) {
4951 #ifdef CONFIG_BACKEND_FILE
4952 wpa_s->confname = os_rel2abs_path(iface->confname);
4953 if (wpa_s->confname == NULL) {
4954 wpa_printf(MSG_ERROR, "Failed to get absolute path "
4955 "for configuration file '%s'.",
4956 iface->confname);
4957 return -1;
4958 }
4959 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
4960 iface->confname, wpa_s->confname);
4961 #else /* CONFIG_BACKEND_FILE */
4962 wpa_s->confname = os_strdup(iface->confname);
4963 #endif /* CONFIG_BACKEND_FILE */
4964 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
4965 if (wpa_s->conf == NULL) {
4966 wpa_printf(MSG_ERROR, "Failed to read or parse "
4967 "configuration '%s'.", wpa_s->confname);
4968 return -1;
4969 }
4970 wpa_s->confanother = os_rel2abs_path(iface->confanother);
4971 wpa_config_read(wpa_s->confanother, wpa_s->conf);
4972
4973 /*
4974 * Override ctrl_interface and driver_param if set on command
4975 * line.
4976 */
4977 if (iface->ctrl_interface) {
4978 os_free(wpa_s->conf->ctrl_interface);
4979 wpa_s->conf->ctrl_interface =
4980 os_strdup(iface->ctrl_interface);
4981 }
4982
4983 if (iface->driver_param) {
4984 os_free(wpa_s->conf->driver_param);
4985 wpa_s->conf->driver_param =
4986 os_strdup(iface->driver_param);
4987 }
4988
4989 if (iface->p2p_mgmt && !iface->ctrl_interface) {
4990 os_free(wpa_s->conf->ctrl_interface);
4991 wpa_s->conf->ctrl_interface = NULL;
4992 }
4993 } else
4994 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
4995 iface->driver_param);
4996
4997 if (wpa_s->conf == NULL) {
4998 wpa_printf(MSG_ERROR, "\nNo configuration found.");
4999 return -1;
5000 }
5001
5002 if (iface->ifname == NULL) {
5003 wpa_printf(MSG_ERROR, "\nInterface name is required.");
5004 return -1;
5005 }
5006 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
5007 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
5008 iface->ifname);
5009 return -1;
5010 }
5011 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
5012
5013 if (iface->bridge_ifname) {
5014 if (os_strlen(iface->bridge_ifname) >=
5015 sizeof(wpa_s->bridge_ifname)) {
5016 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
5017 "name '%s'.", iface->bridge_ifname);
5018 return -1;
5019 }
5020 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
5021 sizeof(wpa_s->bridge_ifname));
5022 }
5023
5024 /* RSNA Supplicant Key Management - INITIALIZE */
5025 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
5026 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
5027
5028 /* Initialize driver interface and register driver event handler before
5029 * L2 receive handler so that association events are processed before
5030 * EAPOL-Key packets if both become available for the same select()
5031 * call. */
5032 if (wpas_init_driver(wpa_s, iface) < 0)
5033 return -1;
5034
5035 if (wpa_supplicant_init_wpa(wpa_s) < 0)
5036 return -1;
5037
5038 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
5039 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
5040 NULL);
5041 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
5042
5043 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
5044 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
5045 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
5046 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5047 "dot11RSNAConfigPMKLifetime");
5048 return -1;
5049 }
5050
5051 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
5052 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
5053 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
5054 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5055 "dot11RSNAConfigPMKReauthThreshold");
5056 return -1;
5057 }
5058
5059 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
5060 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
5061 wpa_s->conf->dot11RSNAConfigSATimeout)) {
5062 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5063 "dot11RSNAConfigSATimeout");
5064 return -1;
5065 }
5066
5067 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
5068 &wpa_s->hw.num_modes,
5069 &wpa_s->hw.flags);
5070 if (wpa_s->hw.modes) {
5071 u16 i;
5072
5073 for (i = 0; i < wpa_s->hw.num_modes; i++) {
5074 if (wpa_s->hw.modes[i].vht_capab) {
5075 wpa_s->hw_capab = CAPAB_VHT;
5076 break;
5077 }
5078
5079 if (wpa_s->hw.modes[i].ht_capab &
5080 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)
5081 wpa_s->hw_capab = CAPAB_HT40;
5082 else if (wpa_s->hw.modes[i].ht_capab &&
5083 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
5084 wpa_s->hw_capab = CAPAB_HT;
5085 }
5086 }
5087
5088 capa_res = wpa_drv_get_capa(wpa_s, &capa);
5089 if (capa_res == 0) {
5090 wpa_s->drv_capa_known = 1;
5091 wpa_s->drv_flags = capa.flags;
5092 wpa_s->drv_enc = capa.enc;
5093 wpa_s->drv_smps_modes = capa.smps_modes;
5094 wpa_s->drv_rrm_flags = capa.rrm_flags;
5095 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
5096 wpa_s->max_scan_ssids = capa.max_scan_ssids;
5097 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
5098 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
5099 wpa_s->max_sched_scan_plan_interval =
5100 capa.max_sched_scan_plan_interval;
5101 wpa_s->max_sched_scan_plan_iterations =
5102 capa.max_sched_scan_plan_iterations;
5103 wpa_s->sched_scan_supported = capa.sched_scan_supported;
5104 wpa_s->max_match_sets = capa.max_match_sets;
5105 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
5106 wpa_s->max_stations = capa.max_stations;
5107 wpa_s->extended_capa = capa.extended_capa;
5108 wpa_s->extended_capa_mask = capa.extended_capa_mask;
5109 wpa_s->extended_capa_len = capa.extended_capa_len;
5110 wpa_s->num_multichan_concurrent =
5111 capa.num_multichan_concurrent;
5112 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
5113
5114 if (capa.mac_addr_rand_scan_supported)
5115 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
5116 if (wpa_s->sched_scan_supported &&
5117 capa.mac_addr_rand_sched_scan_supported)
5118 wpa_s->mac_addr_rand_supported |=
5119 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO);
5120 }
5121 if (wpa_s->max_remain_on_chan == 0)
5122 wpa_s->max_remain_on_chan = 1000;
5123
5124 /*
5125 * Only take p2p_mgmt parameters when P2P Device is supported.
5126 * Doing it here as it determines whether l2_packet_init() will be done
5127 * during wpa_supplicant_driver_init().
5128 */
5129 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
5130 wpa_s->p2p_mgmt = iface->p2p_mgmt;
5131 else
5132 iface->p2p_mgmt = 1;
5133
5134 if (wpa_s->num_multichan_concurrent == 0)
5135 wpa_s->num_multichan_concurrent = 1;
5136
5137 if (wpa_supplicant_driver_init(wpa_s) < 0)
5138 return -1;
5139
5140 #ifdef CONFIG_TDLS
5141 if ((!iface->p2p_mgmt ||
5142 !(wpa_s->drv_flags &
5143 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
5144 wpa_tdls_init(wpa_s->wpa))
5145 return -1;
5146 #endif /* CONFIG_TDLS */
5147
5148 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
5149 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
5150 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
5151 return -1;
5152 }
5153
5154 #ifdef CONFIG_FST
5155 if (wpa_s->conf->fst_group_id) {
5156 struct fst_iface_cfg cfg;
5157 struct fst_wpa_obj iface_obj;
5158
5159 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
5160 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
5161 sizeof(cfg.group_id));
5162 cfg.priority = wpa_s->conf->fst_priority;
5163 cfg.llt = wpa_s->conf->fst_llt;
5164
5165 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
5166 &iface_obj, &cfg);
5167 if (!wpa_s->fst) {
5168 wpa_msg(wpa_s, MSG_ERROR,
5169 "FST: Cannot attach iface %s to group %s",
5170 wpa_s->ifname, cfg.group_id);
5171 return -1;
5172 }
5173 }
5174 #endif /* CONFIG_FST */
5175
5176 if (wpas_wps_init(wpa_s))
5177 return -1;
5178
5179 if (wpa_supplicant_init_eapol(wpa_s) < 0)
5180 return -1;
5181 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
5182
5183 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
5184 if (wpa_s->ctrl_iface == NULL) {
5185 wpa_printf(MSG_ERROR,
5186 "Failed to initialize control interface '%s'.\n"
5187 "You may have another wpa_supplicant process "
5188 "already running or the file was\n"
5189 "left by an unclean termination of wpa_supplicant "
5190 "in which case you will need\n"
5191 "to manually remove this file before starting "
5192 "wpa_supplicant again.\n",
5193 wpa_s->conf->ctrl_interface);
5194 return -1;
5195 }
5196
5197 wpa_s->gas = gas_query_init(wpa_s);
5198 if (wpa_s->gas == NULL) {
5199 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
5200 return -1;
5201 }
5202
5203 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
5204 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
5205 return -1;
5206 }
5207
5208 if (wpa_bss_init(wpa_s) < 0)
5209 return -1;
5210
5211 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
5212 #ifdef CONFIG_MESH
5213 dl_list_init(&wpa_s->mesh_external_pmksa_cache);
5214 #endif /* CONFIG_MESH */
5215 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
5216
5217 /*
5218 * Set Wake-on-WLAN triggers, if configured.
5219 * Note: We don't restore/remove the triggers on shutdown (it doesn't
5220 * have effect anyway when the interface is down).
5221 */
5222 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
5223 return -1;
5224
5225 #ifdef CONFIG_EAP_PROXY
5226 {
5227 size_t len;
5228 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
5229 &len);
5230 if (wpa_s->mnc_len > 0) {
5231 wpa_s->imsi[len] = '\0';
5232 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
5233 wpa_s->imsi, wpa_s->mnc_len);
5234 } else {
5235 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
5236 }
5237 }
5238 #endif /* CONFIG_EAP_PROXY */
5239
5240 if (pcsc_reader_init(wpa_s) < 0)
5241 return -1;
5242
5243 if (wpas_init_ext_pw(wpa_s) < 0)
5244 return -1;
5245
5246 wpas_rrm_reset(wpa_s);
5247
5248 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5249
5250 #ifdef CONFIG_HS20
5251 hs20_init(wpa_s);
5252 #endif /* CONFIG_HS20 */
5253 #ifdef CONFIG_MBO
5254 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
5255 #endif /* CONFIG_MBO */
5256
5257 wpa_supplicant_set_default_scan_ies(wpa_s);
5258
5259 return 0;
5260 }
5261
5262
5263 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
5264 int notify, int terminate)
5265 {
5266 struct wpa_global *global = wpa_s->global;
5267 struct wpa_supplicant *iface, *prev;
5268
5269 if (wpa_s == wpa_s->parent)
5270 wpas_p2p_group_remove(wpa_s, "*");
5271
5272 iface = global->ifaces;
5273 while (iface) {
5274 if (iface->p2pdev == wpa_s)
5275 iface->p2pdev = iface->parent;
5276 if (iface == wpa_s || iface->parent != wpa_s) {
5277 iface = iface->next;
5278 continue;
5279 }
5280 wpa_printf(MSG_DEBUG,
5281 "Remove remaining child interface %s from parent %s",
5282 iface->ifname, wpa_s->ifname);
5283 prev = iface;
5284 iface = iface->next;
5285 wpa_supplicant_remove_iface(global, prev, terminate);
5286 }
5287
5288 wpa_s->disconnected = 1;
5289 if (wpa_s->drv_priv) {
5290 wpa_supplicant_deauthenticate(wpa_s,
5291 WLAN_REASON_DEAUTH_LEAVING);
5292
5293 wpa_drv_set_countermeasures(wpa_s, 0);
5294 wpa_clear_keys(wpa_s, NULL);
5295 }
5296
5297 wpa_supplicant_cleanup(wpa_s);
5298 wpas_p2p_deinit_iface(wpa_s);
5299
5300 wpas_ctrl_radio_work_flush(wpa_s);
5301 radio_remove_interface(wpa_s);
5302
5303 #ifdef CONFIG_FST
5304 if (wpa_s->fst) {
5305 fst_detach(wpa_s->fst);
5306 wpa_s->fst = NULL;
5307 }
5308 if (wpa_s->received_mb_ies) {
5309 wpabuf_free(wpa_s->received_mb_ies);
5310 wpa_s->received_mb_ies = NULL;
5311 }
5312 #endif /* CONFIG_FST */
5313
5314 if (wpa_s->drv_priv)
5315 wpa_drv_deinit(wpa_s);
5316
5317 if (notify)
5318 wpas_notify_iface_removed(wpa_s);
5319
5320 if (terminate)
5321 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
5322
5323 if (wpa_s->ctrl_iface) {
5324 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
5325 wpa_s->ctrl_iface = NULL;
5326 }
5327
5328 #ifdef CONFIG_MESH
5329 if (wpa_s->ifmsh) {
5330 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
5331 wpa_s->ifmsh = NULL;
5332 }
5333 #endif /* CONFIG_MESH */
5334
5335 if (wpa_s->conf != NULL) {
5336 wpa_config_free(wpa_s->conf);
5337 wpa_s->conf = NULL;
5338 }
5339
5340 os_free(wpa_s->ssids_from_scan_req);
5341
5342 os_free(wpa_s);
5343 }
5344
5345
5346 #ifdef CONFIG_MATCH_IFACE
5347
5348 /**
5349 * wpa_supplicant_match_iface - Match an interface description to a name
5350 * @global: Pointer to global data from wpa_supplicant_init()
5351 * @ifname: Name of the interface to match
5352 * Returns: Pointer to the created interface description or %NULL on failure
5353 */
5354 struct wpa_interface * wpa_supplicant_match_iface(struct wpa_global *global,
5355 const char *ifname)
5356 {
5357 int i;
5358 struct wpa_interface *iface, *miface;
5359
5360 for (i = 0; i < global->params.match_iface_count; i++) {
5361 miface = &global->params.match_ifaces[i];
5362 if (!miface->ifname ||
5363 fnmatch(miface->ifname, ifname, 0) == 0) {
5364 iface = os_zalloc(sizeof(*iface));
5365 if (!iface)
5366 return NULL;
5367 *iface = *miface;
5368 iface->ifname = ifname;
5369 return iface;
5370 }
5371 }
5372
5373 return NULL;
5374 }
5375
5376
5377 /**
5378 * wpa_supplicant_match_existing - Match existing interfaces
5379 * @global: Pointer to global data from wpa_supplicant_init()
5380 * Returns: 0 on success, -1 on failure
5381 */
5382 static int wpa_supplicant_match_existing(struct wpa_global *global)
5383 {
5384 struct if_nameindex *ifi, *ifp;
5385 struct wpa_supplicant *wpa_s;
5386 struct wpa_interface *iface;
5387
5388 ifp = if_nameindex();
5389 if (!ifp) {
5390 wpa_printf(MSG_ERROR, "if_nameindex: %s", strerror(errno));
5391 return -1;
5392 }
5393
5394 for (ifi = ifp; ifi->if_name; ifi++) {
5395 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
5396 if (wpa_s)
5397 continue;
5398 iface = wpa_supplicant_match_iface(global, ifi->if_name);
5399 if (iface) {
5400 wpa_s = wpa_supplicant_add_iface(global, iface, NULL);
5401 os_free(iface);
5402 if (wpa_s)
5403 wpa_s->matched = 1;
5404 }
5405 }
5406
5407 if_freenameindex(ifp);
5408 return 0;
5409 }
5410
5411 #endif /* CONFIG_MATCH_IFACE */
5412
5413
5414 /**
5415 * wpa_supplicant_add_iface - Add a new network interface
5416 * @global: Pointer to global data from wpa_supplicant_init()
5417 * @iface: Interface configuration options
5418 * @parent: Parent interface or %NULL to assign new interface as parent
5419 * Returns: Pointer to the created interface or %NULL on failure
5420 *
5421 * This function is used to add new network interfaces for %wpa_supplicant.
5422 * This can be called before wpa_supplicant_run() to add interfaces before the
5423 * main event loop has been started. In addition, new interfaces can be added
5424 * dynamically while %wpa_supplicant is already running. This could happen,
5425 * e.g., when a hotplug network adapter is inserted.
5426 */
5427 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
5428 struct wpa_interface *iface,
5429 struct wpa_supplicant *parent)
5430 {
5431 struct wpa_supplicant *wpa_s;
5432 struct wpa_interface t_iface;
5433 struct wpa_ssid *ssid;
5434
5435 if (global == NULL || iface == NULL)
5436 return NULL;
5437
5438 wpa_s = wpa_supplicant_alloc(parent);
5439 if (wpa_s == NULL)
5440 return NULL;
5441
5442 wpa_s->global = global;
5443
5444 t_iface = *iface;
5445 if (global->params.override_driver) {
5446 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
5447 "('%s' -> '%s')",
5448 iface->driver, global->params.override_driver);
5449 t_iface.driver = global->params.override_driver;
5450 }
5451 if (global->params.override_ctrl_interface) {
5452 wpa_printf(MSG_DEBUG, "Override interface parameter: "
5453 "ctrl_interface ('%s' -> '%s')",
5454 iface->ctrl_interface,
5455 global->params.override_ctrl_interface);
5456 t_iface.ctrl_interface =
5457 global->params.override_ctrl_interface;
5458 }
5459 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
5460 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
5461 iface->ifname);
5462 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
5463 return NULL;
5464 }
5465
5466 if (iface->p2p_mgmt == 0) {
5467 /* Notify the control interfaces about new iface */
5468 if (wpas_notify_iface_added(wpa_s)) {
5469 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
5470 return NULL;
5471 }
5472
5473 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
5474 wpas_notify_network_added(wpa_s, ssid);
5475 }
5476
5477 wpa_s->next = global->ifaces;
5478 global->ifaces = wpa_s;
5479
5480 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
5481 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
5482
5483 #ifdef CONFIG_P2P
5484 if (wpa_s->global->p2p == NULL &&
5485 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
5486 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
5487 wpas_p2p_add_p2pdev_interface(
5488 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
5489 wpa_printf(MSG_INFO,
5490 "P2P: Failed to enable P2P Device interface");
5491 /* Try to continue without. P2P will be disabled. */
5492 }
5493 #endif /* CONFIG_P2P */
5494
5495 return wpa_s;
5496 }
5497
5498
5499 /**
5500 * wpa_supplicant_remove_iface - Remove a network interface
5501 * @global: Pointer to global data from wpa_supplicant_init()
5502 * @wpa_s: Pointer to the network interface to be removed
5503 * Returns: 0 if interface was removed, -1 if interface was not found
5504 *
5505 * This function can be used to dynamically remove network interfaces from
5506 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
5507 * addition, this function is used to remove all remaining interfaces when
5508 * %wpa_supplicant is terminated.
5509 */
5510 int wpa_supplicant_remove_iface(struct wpa_global *global,
5511 struct wpa_supplicant *wpa_s,
5512 int terminate)
5513 {
5514 struct wpa_supplicant *prev;
5515 #ifdef CONFIG_MESH
5516 unsigned int mesh_if_created = wpa_s->mesh_if_created;
5517 char *ifname = NULL;
5518 struct wpa_supplicant *parent = wpa_s->parent;
5519 #endif /* CONFIG_MESH */
5520
5521 /* Remove interface from the global list of interfaces */
5522 prev = global->ifaces;
5523 if (prev == wpa_s) {
5524 global->ifaces = wpa_s->next;
5525 } else {
5526 while (prev && prev->next != wpa_s)
5527 prev = prev->next;
5528 if (prev == NULL)
5529 return -1;
5530 prev->next = wpa_s->next;
5531 }
5532
5533 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
5534
5535 #ifdef CONFIG_MESH
5536 if (mesh_if_created) {
5537 ifname = os_strdup(wpa_s->ifname);
5538 if (ifname == NULL) {
5539 wpa_dbg(wpa_s, MSG_ERROR,
5540 "mesh: Failed to malloc ifname");
5541 return -1;
5542 }
5543 }
5544 #endif /* CONFIG_MESH */
5545
5546 if (global->p2p_group_formation == wpa_s)
5547 global->p2p_group_formation = NULL;
5548 if (global->p2p_invite_group == wpa_s)
5549 global->p2p_invite_group = NULL;
5550 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
5551
5552 #ifdef CONFIG_MESH
5553 if (mesh_if_created) {
5554 wpa_drv_if_remove(parent, WPA_IF_MESH, ifname);
5555 os_free(ifname);
5556 }
5557 #endif /* CONFIG_MESH */
5558
5559 return 0;
5560 }
5561
5562
5563 /**
5564 * wpa_supplicant_get_eap_mode - Get the current EAP mode
5565 * @wpa_s: Pointer to the network interface
5566 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
5567 */
5568 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
5569 {
5570 const char *eapol_method;
5571
5572 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
5573 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
5574 return "NO-EAP";
5575 }
5576
5577 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
5578 if (eapol_method == NULL)
5579 return "UNKNOWN-EAP";
5580
5581 return eapol_method;
5582 }
5583
5584
5585 /**
5586 * wpa_supplicant_get_iface - Get a new network interface
5587 * @global: Pointer to global data from wpa_supplicant_init()
5588 * @ifname: Interface name
5589 * Returns: Pointer to the interface or %NULL if not found
5590 */
5591 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
5592 const char *ifname)
5593 {
5594 struct wpa_supplicant *wpa_s;
5595
5596 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5597 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5598 return wpa_s;
5599 }
5600 return NULL;
5601 }
5602
5603
5604 #ifndef CONFIG_NO_WPA_MSG
5605 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
5606 {
5607 struct wpa_supplicant *wpa_s = ctx;
5608 if (wpa_s == NULL)
5609 return NULL;
5610 return wpa_s->ifname;
5611 }
5612 #endif /* CONFIG_NO_WPA_MSG */
5613
5614
5615 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL
5616 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10
5617 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */
5618
5619 /* Periodic cleanup tasks */
5620 static void wpas_periodic(void *eloop_ctx, void *timeout_ctx)
5621 {
5622 struct wpa_global *global = eloop_ctx;
5623 struct wpa_supplicant *wpa_s;
5624
5625 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5626 wpas_periodic, global, NULL);
5627
5628 #ifdef CONFIG_P2P
5629 if (global->p2p)
5630 p2p_expire_peers(global->p2p);
5631 #endif /* CONFIG_P2P */
5632
5633 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5634 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
5635 #ifdef CONFIG_AP
5636 ap_periodic(wpa_s);
5637 #endif /* CONFIG_AP */
5638 }
5639 }
5640
5641
5642 /**
5643 * wpa_supplicant_init - Initialize %wpa_supplicant
5644 * @params: Parameters for %wpa_supplicant
5645 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
5646 *
5647 * This function is used to initialize %wpa_supplicant. After successful
5648 * initialization, the returned data pointer can be used to add and remove
5649 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
5650 */
5651 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
5652 {
5653 struct wpa_global *global;
5654 int ret, i;
5655
5656 if (params == NULL)
5657 return NULL;
5658
5659 #ifdef CONFIG_DRIVER_NDIS
5660 {
5661 void driver_ndis_init_ops(void);
5662 driver_ndis_init_ops();
5663 }
5664 #endif /* CONFIG_DRIVER_NDIS */
5665
5666 #ifndef CONFIG_NO_WPA_MSG
5667 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
5668 #endif /* CONFIG_NO_WPA_MSG */
5669
5670 if (params->wpa_debug_file_path)
5671 wpa_debug_open_file(params->wpa_debug_file_path);
5672 else
5673 wpa_debug_setup_stdout();
5674 if (params->wpa_debug_syslog)
5675 wpa_debug_open_syslog();
5676 if (params->wpa_debug_tracing) {
5677 ret = wpa_debug_open_linux_tracing();
5678 if (ret) {
5679 wpa_printf(MSG_ERROR,
5680 "Failed to enable trace logging");
5681 return NULL;
5682 }
5683 }
5684
5685 ret = eap_register_methods();
5686 if (ret) {
5687 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
5688 if (ret == -2)
5689 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
5690 "the same EAP type.");
5691 return NULL;
5692 }
5693
5694 global = os_zalloc(sizeof(*global));
5695 if (global == NULL)
5696 return NULL;
5697 dl_list_init(&global->p2p_srv_bonjour);
5698 dl_list_init(&global->p2p_srv_upnp);
5699 global->params.daemonize = params->daemonize;
5700 global->params.wait_for_monitor = params->wait_for_monitor;
5701 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
5702 if (params->pid_file)
5703 global->params.pid_file = os_strdup(params->pid_file);
5704 if (params->ctrl_interface)
5705 global->params.ctrl_interface =
5706 os_strdup(params->ctrl_interface);
5707 if (params->ctrl_interface_group)
5708 global->params.ctrl_interface_group =
5709 os_strdup(params->ctrl_interface_group);
5710 if (params->override_driver)
5711 global->params.override_driver =
5712 os_strdup(params->override_driver);
5713 if (params->override_ctrl_interface)
5714 global->params.override_ctrl_interface =
5715 os_strdup(params->override_ctrl_interface);
5716 #ifdef CONFIG_MATCH_IFACE
5717 global->params.match_iface_count = params->match_iface_count;
5718 if (params->match_iface_count) {
5719 global->params.match_ifaces =
5720 os_calloc(params->match_iface_count,
5721 sizeof(struct wpa_interface));
5722 os_memcpy(global->params.match_ifaces,
5723 params->match_ifaces,
5724 params->match_iface_count *
5725 sizeof(struct wpa_interface));
5726 }
5727 #endif /* CONFIG_MATCH_IFACE */
5728 #ifdef CONFIG_P2P
5729 if (params->conf_p2p_dev)
5730 global->params.conf_p2p_dev =
5731 os_strdup(params->conf_p2p_dev);
5732 #endif /* CONFIG_P2P */
5733 wpa_debug_level = global->params.wpa_debug_level =
5734 params->wpa_debug_level;
5735 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
5736 params->wpa_debug_show_keys;
5737 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
5738 params->wpa_debug_timestamp;
5739
5740 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
5741
5742 if (eloop_init()) {
5743 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
5744 wpa_supplicant_deinit(global);
5745 return NULL;
5746 }
5747
5748 random_init(params->entropy_file);
5749
5750 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
5751 if (global->ctrl_iface == NULL) {
5752 wpa_supplicant_deinit(global);
5753 return NULL;
5754 }
5755
5756 if (wpas_notify_supplicant_initialized(global)) {
5757 wpa_supplicant_deinit(global);
5758 return NULL;
5759 }
5760
5761 for (i = 0; wpa_drivers[i]; i++)
5762 global->drv_count++;
5763 if (global->drv_count == 0) {
5764 wpa_printf(MSG_ERROR, "No drivers enabled");
5765 wpa_supplicant_deinit(global);
5766 return NULL;
5767 }
5768 global->drv_priv = os_calloc(global->drv_count, sizeof(void *));
5769 if (global->drv_priv == NULL) {
5770 wpa_supplicant_deinit(global);
5771 return NULL;
5772 }
5773
5774 #ifdef CONFIG_WIFI_DISPLAY
5775 if (wifi_display_init(global) < 0) {
5776 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
5777 wpa_supplicant_deinit(global);
5778 return NULL;
5779 }
5780 #endif /* CONFIG_WIFI_DISPLAY */
5781
5782 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5783 wpas_periodic, global, NULL);
5784
5785 return global;
5786 }
5787
5788
5789 /**
5790 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
5791 * @global: Pointer to global data from wpa_supplicant_init()
5792 * Returns: 0 after successful event loop run, -1 on failure
5793 *
5794 * This function starts the main event loop and continues running as long as
5795 * there are any remaining events. In most cases, this function is running as
5796 * long as the %wpa_supplicant process in still in use.
5797 */
5798 int wpa_supplicant_run(struct wpa_global *global)
5799 {
5800 struct wpa_supplicant *wpa_s;
5801
5802 if (global->params.daemonize &&
5803 (wpa_supplicant_daemon(global->params.pid_file) ||
5804 eloop_sock_requeue()))
5805 return -1;
5806
5807 #ifdef CONFIG_MATCH_IFACE
5808 if (wpa_supplicant_match_existing(global))
5809 return -1;
5810 #endif
5811
5812 if (global->params.wait_for_monitor) {
5813 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
5814 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
5815 wpa_supplicant_ctrl_iface_wait(
5816 wpa_s->ctrl_iface);
5817 }
5818
5819 eloop_register_signal_terminate(wpa_supplicant_terminate, global);
5820 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
5821
5822 eloop_run();
5823
5824 return 0;
5825 }
5826
5827
5828 /**
5829 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
5830 * @global: Pointer to global data from wpa_supplicant_init()
5831 *
5832 * This function is called to deinitialize %wpa_supplicant and to free all
5833 * allocated resources. Remaining network interfaces will also be removed.
5834 */
5835 void wpa_supplicant_deinit(struct wpa_global *global)
5836 {
5837 int i;
5838
5839 if (global == NULL)
5840 return;
5841
5842 eloop_cancel_timeout(wpas_periodic, global, NULL);
5843
5844 #ifdef CONFIG_WIFI_DISPLAY
5845 wifi_display_deinit(global);
5846 #endif /* CONFIG_WIFI_DISPLAY */
5847
5848 while (global->ifaces)
5849 wpa_supplicant_remove_iface(global, global->ifaces, 1);
5850
5851 if (global->ctrl_iface)
5852 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
5853
5854 wpas_notify_supplicant_deinitialized(global);
5855
5856 eap_peer_unregister_methods();
5857 #ifdef CONFIG_AP
5858 eap_server_unregister_methods();
5859 #endif /* CONFIG_AP */
5860
5861 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
5862 if (!global->drv_priv[i])
5863 continue;
5864 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
5865 }
5866 os_free(global->drv_priv);
5867
5868 random_deinit();
5869
5870 eloop_destroy();
5871
5872 if (global->params.pid_file) {
5873 os_daemonize_terminate(global->params.pid_file);
5874 os_free(global->params.pid_file);
5875 }
5876 os_free(global->params.ctrl_interface);
5877 os_free(global->params.ctrl_interface_group);
5878 os_free(global->params.override_driver);
5879 os_free(global->params.override_ctrl_interface);
5880 #ifdef CONFIG_MATCH_IFACE
5881 os_free(global->params.match_ifaces);
5882 #endif /* CONFIG_MATCH_IFACE */
5883 #ifdef CONFIG_P2P
5884 os_free(global->params.conf_p2p_dev);
5885 #endif /* CONFIG_P2P */
5886
5887 os_free(global->p2p_disallow_freq.range);
5888 os_free(global->p2p_go_avoid_freq.range);
5889 os_free(global->add_psk);
5890
5891 os_free(global);
5892 wpa_debug_close_syslog();
5893 wpa_debug_close_file();
5894 wpa_debug_close_linux_tracing();
5895 }
5896
5897
5898 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
5899 {
5900 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
5901 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5902 char country[3];
5903 country[0] = wpa_s->conf->country[0];
5904 country[1] = wpa_s->conf->country[1];
5905 country[2] = '\0';
5906 if (wpa_drv_set_country(wpa_s, country) < 0) {
5907 wpa_printf(MSG_ERROR, "Failed to set country code "
5908 "'%s'", country);
5909 }
5910 }
5911
5912 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
5913 wpas_init_ext_pw(wpa_s);
5914
5915 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
5916 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5917
5918 #ifdef CONFIG_WPS
5919 wpas_wps_update_config(wpa_s);
5920 #endif /* CONFIG_WPS */
5921 wpas_p2p_update_config(wpa_s);
5922 wpa_s->conf->changed_parameters = 0;
5923 }
5924
5925
5926 void add_freq(int *freqs, int *num_freqs, int freq)
5927 {
5928 int i;
5929
5930 for (i = 0; i < *num_freqs; i++) {
5931 if (freqs[i] == freq)
5932 return;
5933 }
5934
5935 freqs[*num_freqs] = freq;
5936 (*num_freqs)++;
5937 }
5938
5939
5940 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
5941 {
5942 struct wpa_bss *bss, *cbss;
5943 const int max_freqs = 10;
5944 int *freqs;
5945 int num_freqs = 0;
5946
5947 freqs = os_calloc(max_freqs + 1, sizeof(int));
5948 if (freqs == NULL)
5949 return NULL;
5950
5951 cbss = wpa_s->current_bss;
5952
5953 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
5954 if (bss == cbss)
5955 continue;
5956 if (bss->ssid_len == cbss->ssid_len &&
5957 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
5958 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
5959 add_freq(freqs, &num_freqs, bss->freq);
5960 if (num_freqs == max_freqs)
5961 break;
5962 }
5963 }
5964
5965 if (num_freqs == 0) {
5966 os_free(freqs);
5967 freqs = NULL;
5968 }
5969
5970 return freqs;
5971 }
5972
5973
5974 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
5975 {
5976 int timeout;
5977 int count;
5978 int *freqs = NULL;
5979
5980 wpas_connect_work_done(wpa_s);
5981
5982 /*
5983 * Remove possible authentication timeout since the connection failed.
5984 */
5985 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
5986
5987 /*
5988 * There is no point in blacklisting the AP if this event is
5989 * generated based on local request to disconnect.
5990 */
5991 if (wpa_s->own_disconnect_req) {
5992 wpa_s->own_disconnect_req = 0;
5993 wpa_dbg(wpa_s, MSG_DEBUG,
5994 "Ignore connection failure due to local request to disconnect");
5995 return;
5996 }
5997 if (wpa_s->disconnected) {
5998 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
5999 "indication since interface has been put into "
6000 "disconnected state");
6001 return;
6002 }
6003
6004 /*
6005 * Add the failed BSSID into the blacklist and speed up next scan
6006 * attempt if there could be other APs that could accept association.
6007 * The current blacklist count indicates how many times we have tried
6008 * connecting to this AP and multiple attempts mean that other APs are
6009 * either not available or has already been tried, so that we can start
6010 * increasing the delay here to avoid constant scanning.
6011 */
6012 count = wpa_blacklist_add(wpa_s, bssid);
6013 if (count == 1 && wpa_s->current_bss) {
6014 /*
6015 * This BSS was not in the blacklist before. If there is
6016 * another BSS available for the same ESS, we should try that
6017 * next. Otherwise, we may as well try this one once more
6018 * before allowing other, likely worse, ESSes to be considered.
6019 */
6020 freqs = get_bss_freqs_in_ess(wpa_s);
6021 if (freqs) {
6022 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
6023 "has been seen; try it next");
6024 wpa_blacklist_add(wpa_s, bssid);
6025 /*
6026 * On the next scan, go through only the known channels
6027 * used in this ESS based on previous scans to speed up
6028 * common load balancing use case.
6029 */
6030 os_free(wpa_s->next_scan_freqs);
6031 wpa_s->next_scan_freqs = freqs;
6032 }
6033 }
6034
6035 /*
6036 * Add previous failure count in case the temporary blacklist was
6037 * cleared due to no other BSSes being available.
6038 */
6039 count += wpa_s->extra_blacklist_count;
6040
6041 if (count > 3 && wpa_s->current_ssid) {
6042 wpa_printf(MSG_DEBUG, "Continuous association failures - "
6043 "consider temporary network disabling");
6044 wpas_auth_failed(wpa_s, "CONN_FAILED");
6045 }
6046
6047 switch (count) {
6048 case 1:
6049 timeout = 100;
6050 break;
6051 case 2:
6052 timeout = 500;
6053 break;
6054 case 3:
6055 timeout = 1000;
6056 break;
6057 case 4:
6058 timeout = 5000;
6059 break;
6060 default:
6061 timeout = 10000;
6062 break;
6063 }
6064
6065 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
6066 "ms", count, timeout);
6067
6068 /*
6069 * TODO: if more than one possible AP is available in scan results,
6070 * could try the other ones before requesting a new scan.
6071 */
6072 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
6073 1000 * (timeout % 1000));
6074 }
6075
6076
6077 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
6078 {
6079 return wpa_s->conf->ap_scan == 2 ||
6080 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
6081 }
6082
6083
6084 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
6085 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
6086 struct wpa_ssid *ssid,
6087 const char *field,
6088 const char *value)
6089 {
6090 #ifdef IEEE8021X_EAPOL
6091 struct eap_peer_config *eap = &ssid->eap;
6092
6093 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
6094 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
6095 (const u8 *) value, os_strlen(value));
6096
6097 switch (wpa_supplicant_ctrl_req_from_string(field)) {
6098 case WPA_CTRL_REQ_EAP_IDENTITY:
6099 os_free(eap->identity);
6100 eap->identity = (u8 *) os_strdup(value);
6101 eap->identity_len = os_strlen(value);
6102 eap->pending_req_identity = 0;
6103 if (ssid == wpa_s->current_ssid)
6104 wpa_s->reassociate = 1;
6105 break;
6106 case WPA_CTRL_REQ_EAP_PASSWORD:
6107 bin_clear_free(eap->password, eap->password_len);
6108 eap->password = (u8 *) os_strdup(value);
6109 eap->password_len = os_strlen(value);
6110 eap->pending_req_password = 0;
6111 if (ssid == wpa_s->current_ssid)
6112 wpa_s->reassociate = 1;
6113 break;
6114 case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
6115 bin_clear_free(eap->new_password, eap->new_password_len);
6116 eap->new_password = (u8 *) os_strdup(value);
6117 eap->new_password_len = os_strlen(value);
6118 eap->pending_req_new_password = 0;
6119 if (ssid == wpa_s->current_ssid)
6120 wpa_s->reassociate = 1;
6121 break;
6122 case WPA_CTRL_REQ_EAP_PIN:
6123 str_clear_free(eap->pin);
6124 eap->pin = os_strdup(value);
6125 eap->pending_req_pin = 0;
6126 if (ssid == wpa_s->current_ssid)
6127 wpa_s->reassociate = 1;
6128 break;
6129 case WPA_CTRL_REQ_EAP_OTP:
6130 bin_clear_free(eap->otp, eap->otp_len);
6131 eap->otp = (u8 *) os_strdup(value);
6132 eap->otp_len = os_strlen(value);
6133 os_free(eap->pending_req_otp);
6134 eap->pending_req_otp = NULL;
6135 eap->pending_req_otp_len = 0;
6136 break;
6137 case WPA_CTRL_REQ_EAP_PASSPHRASE:
6138 str_clear_free(eap->private_key_passwd);
6139 eap->private_key_passwd = os_strdup(value);
6140 eap->pending_req_passphrase = 0;
6141 if (ssid == wpa_s->current_ssid)
6142 wpa_s->reassociate = 1;
6143 break;
6144 case WPA_CTRL_REQ_SIM:
6145 str_clear_free(eap->external_sim_resp);
6146 eap->external_sim_resp = os_strdup(value);
6147 eap->pending_req_sim = 0;
6148 break;
6149 case WPA_CTRL_REQ_PSK_PASSPHRASE:
6150 if (wpa_config_set(ssid, "psk", value, 0) < 0)
6151 return -1;
6152 ssid->mem_only_psk = 1;
6153 if (ssid->passphrase)
6154 wpa_config_update_psk(ssid);
6155 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
6156 wpa_supplicant_req_scan(wpa_s, 0, 0);
6157 break;
6158 case WPA_CTRL_REQ_EXT_CERT_CHECK:
6159 if (eap->pending_ext_cert_check != PENDING_CHECK)
6160 return -1;
6161 if (os_strcmp(value, "good") == 0)
6162 eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD;
6163 else if (os_strcmp(value, "bad") == 0)
6164 eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD;
6165 else
6166 return -1;
6167 break;
6168 default:
6169 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
6170 return -1;
6171 }
6172
6173 return 0;
6174 #else /* IEEE8021X_EAPOL */
6175 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
6176 return -1;
6177 #endif /* IEEE8021X_EAPOL */
6178 }
6179 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
6180
6181
6182 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6183 {
6184 int i;
6185 unsigned int drv_enc;
6186
6187 if (wpa_s->p2p_mgmt)
6188 return 1; /* no normal network profiles on p2p_mgmt interface */
6189
6190 if (ssid == NULL)
6191 return 1;
6192
6193 if (ssid->disabled)
6194 return 1;
6195
6196 if (wpa_s->drv_capa_known)
6197 drv_enc = wpa_s->drv_enc;
6198 else
6199 drv_enc = (unsigned int) -1;
6200
6201 for (i = 0; i < NUM_WEP_KEYS; i++) {
6202 size_t len = ssid->wep_key_len[i];
6203 if (len == 0)
6204 continue;
6205 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
6206 continue;
6207 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
6208 continue;
6209 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
6210 continue;
6211 return 1; /* invalid WEP key */
6212 }
6213
6214 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
6215 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk &&
6216 !ssid->mem_only_psk)
6217 return 1;
6218
6219 return 0;
6220 }
6221
6222
6223 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6224 {
6225 #ifdef CONFIG_IEEE80211W
6226 if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) {
6227 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
6228 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
6229 /*
6230 * Driver does not support BIP -- ignore pmf=1 default
6231 * since the connection with PMF would fail and the
6232 * configuration does not require PMF to be enabled.
6233 */
6234 return NO_MGMT_FRAME_PROTECTION;
6235 }
6236
6237 if (ssid &&
6238 (ssid->key_mgmt &
6239 ~(WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPS |
6240 WPA_KEY_MGMT_IEEE8021X_NO_WPA)) == 0) {
6241 /*
6242 * Do not use the default PMF value for non-RSN networks
6243 * since PMF is available only with RSN and pmf=2
6244 * configuration would otherwise prevent connections to
6245 * all open networks.
6246 */
6247 return NO_MGMT_FRAME_PROTECTION;
6248 }
6249
6250 return wpa_s->conf->pmf;
6251 }
6252
6253 return ssid->ieee80211w;
6254 #else /* CONFIG_IEEE80211W */
6255 return NO_MGMT_FRAME_PROTECTION;
6256 #endif /* CONFIG_IEEE80211W */
6257 }
6258
6259
6260 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
6261 {
6262 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
6263 return 1;
6264 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
6265 return 0;
6266 return -1;
6267 }
6268
6269
6270 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
6271 {
6272 struct wpa_ssid *ssid = wpa_s->current_ssid;
6273 int dur;
6274 struct os_reltime now;
6275
6276 if (ssid == NULL) {
6277 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
6278 "SSID block");
6279 return;
6280 }
6281
6282 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
6283 return;
6284
6285 ssid->auth_failures++;
6286
6287 #ifdef CONFIG_P2P
6288 if (ssid->p2p_group &&
6289 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
6290 /*
6291 * Skip the wait time since there is a short timeout on the
6292 * connection to a P2P group.
6293 */
6294 return;
6295 }
6296 #endif /* CONFIG_P2P */
6297
6298 if (ssid->auth_failures > 50)
6299 dur = 300;
6300 else if (ssid->auth_failures > 10)
6301 dur = 120;
6302 else if (ssid->auth_failures > 5)
6303 dur = 90;
6304 else if (ssid->auth_failures > 3)
6305 dur = 60;
6306 else if (ssid->auth_failures > 2)
6307 dur = 30;
6308 else if (ssid->auth_failures > 1)
6309 dur = 20;
6310 else
6311 dur = 10;
6312
6313 if (ssid->auth_failures > 1 &&
6314 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
6315 dur += os_random() % (ssid->auth_failures * 10);
6316
6317 os_get_reltime(&now);
6318 if (now.sec + dur <= ssid->disabled_until.sec)
6319 return;
6320
6321 ssid->disabled_until.sec = now.sec + dur;
6322
6323 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
6324 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
6325 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
6326 ssid->auth_failures, dur, reason);
6327 }
6328
6329
6330 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
6331 struct wpa_ssid *ssid, int clear_failures)
6332 {
6333 if (ssid == NULL)
6334 return;
6335
6336 if (ssid->disabled_until.sec) {
6337 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
6338 "id=%d ssid=\"%s\"",
6339 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
6340 }
6341 ssid->disabled_until.sec = 0;
6342 ssid->disabled_until.usec = 0;
6343 if (clear_failures)
6344 ssid->auth_failures = 0;
6345 }
6346
6347
6348 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
6349 {
6350 size_t i;
6351
6352 if (wpa_s->disallow_aps_bssid == NULL)
6353 return 0;
6354
6355 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
6356 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
6357 bssid, ETH_ALEN) == 0)
6358 return 1;
6359 }
6360
6361 return 0;
6362 }
6363
6364
6365 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
6366 size_t ssid_len)
6367 {
6368 size_t i;
6369
6370 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
6371 return 0;
6372
6373 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
6374 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
6375 if (ssid_len == s->ssid_len &&
6376 os_memcmp(ssid, s->ssid, ssid_len) == 0)
6377 return 1;
6378 }
6379
6380 return 0;
6381 }
6382
6383
6384 /**
6385 * wpas_request_connection - Request a new connection
6386 * @wpa_s: Pointer to the network interface
6387 *
6388 * This function is used to request a new connection to be found. It will mark
6389 * the interface to allow reassociation and request a new scan to find a
6390 * suitable network to connect to.
6391 */
6392 void wpas_request_connection(struct wpa_supplicant *wpa_s)
6393 {
6394 wpa_s->normal_scans = 0;
6395 wpa_s->scan_req = NORMAL_SCAN_REQ;
6396 wpa_supplicant_reinit_autoscan(wpa_s);
6397 wpa_s->extra_blacklist_count = 0;
6398 wpa_s->disconnected = 0;
6399 wpa_s->reassociate = 1;
6400
6401 if (wpa_supplicant_fast_associate(wpa_s) != 1)
6402 wpa_supplicant_req_scan(wpa_s, 0, 0);
6403 else
6404 wpa_s->reattach = 0;
6405 }
6406
6407
6408 /**
6409 * wpas_request_disconnection - Request disconnection
6410 * @wpa_s: Pointer to the network interface
6411 *
6412 * This function is used to request disconnection from the currently connected
6413 * network. This will stop any ongoing scans and initiate deauthentication.
6414 */
6415 void wpas_request_disconnection(struct wpa_supplicant *wpa_s)
6416 {
6417 #ifdef CONFIG_SME
6418 wpa_s->sme.prev_bssid_set = 0;
6419 #endif /* CONFIG_SME */
6420 wpa_s->reassociate = 0;
6421 wpa_s->disconnected = 1;
6422 wpa_supplicant_cancel_sched_scan(wpa_s);
6423 wpa_supplicant_cancel_scan(wpa_s);
6424 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
6425 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
6426 }
6427
6428
6429 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
6430 struct wpa_used_freq_data *freqs_data,
6431 unsigned int len)
6432 {
6433 unsigned int i;
6434
6435 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
6436 len, title);
6437 for (i = 0; i < len; i++) {
6438 struct wpa_used_freq_data *cur = &freqs_data[i];
6439 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
6440 i, cur->freq, cur->flags);
6441 }
6442 }
6443
6444
6445 /*
6446 * Find the operating frequencies of any of the virtual interfaces that
6447 * are using the same radio as the current interface, and in addition, get
6448 * information about the interface types that are using the frequency.
6449 */
6450 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
6451 struct wpa_used_freq_data *freqs_data,
6452 unsigned int len)
6453 {
6454 struct wpa_supplicant *ifs;
6455 u8 bssid[ETH_ALEN];
6456 int freq;
6457 unsigned int idx = 0, i;
6458
6459 wpa_dbg(wpa_s, MSG_DEBUG,
6460 "Determining shared radio frequencies (max len %u)", len);
6461 os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
6462
6463 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
6464 radio_list) {
6465 if (idx == len)
6466 break;
6467
6468 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
6469 continue;
6470
6471 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
6472 ifs->current_ssid->mode == WPAS_MODE_P2P_GO ||
6473 ifs->current_ssid->mode == WPAS_MODE_MESH)
6474 freq = ifs->current_ssid->frequency;
6475 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
6476 freq = ifs->assoc_freq;
6477 else
6478 continue;
6479
6480 /* Hold only distinct freqs */
6481 for (i = 0; i < idx; i++)
6482 if (freqs_data[i].freq == freq)
6483 break;
6484
6485 if (i == idx)
6486 freqs_data[idx++].freq = freq;
6487
6488 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
6489 freqs_data[i].flags |= ifs->current_ssid->p2p_group ?
6490 WPA_FREQ_USED_BY_P2P_CLIENT :
6491 WPA_FREQ_USED_BY_INFRA_STATION;
6492 }
6493 }
6494
6495 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
6496 return idx;
6497 }
6498
6499
6500 /*
6501 * Find the operating frequencies of any of the virtual interfaces that
6502 * are using the same radio as the current interface.
6503 */
6504 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
6505 int *freq_array, unsigned int len)
6506 {
6507 struct wpa_used_freq_data *freqs_data;
6508 int num, i;
6509
6510 os_memset(freq_array, 0, sizeof(int) * len);
6511
6512 freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
6513 if (!freqs_data)
6514 return -1;
6515
6516 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
6517 for (i = 0; i < num; i++)
6518 freq_array[i] = freqs_data[i].freq;
6519
6520 os_free(freqs_data);
6521
6522 return num;
6523 }
6524
6525
6526 struct wpa_supplicant *
6527 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
6528 {
6529 switch (frame) {
6530 #ifdef CONFIG_P2P
6531 case VENDOR_ELEM_PROBE_REQ_P2P:
6532 case VENDOR_ELEM_PROBE_RESP_P2P:
6533 case VENDOR_ELEM_PROBE_RESP_P2P_GO:
6534 case VENDOR_ELEM_BEACON_P2P_GO:
6535 case VENDOR_ELEM_P2P_PD_REQ:
6536 case VENDOR_ELEM_P2P_PD_RESP:
6537 case VENDOR_ELEM_P2P_GO_NEG_REQ:
6538 case VENDOR_ELEM_P2P_GO_NEG_RESP:
6539 case VENDOR_ELEM_P2P_GO_NEG_CONF:
6540 case VENDOR_ELEM_P2P_INV_REQ:
6541 case VENDOR_ELEM_P2P_INV_RESP:
6542 case VENDOR_ELEM_P2P_ASSOC_REQ:
6543 case VENDOR_ELEM_P2P_ASSOC_RESP:
6544 return wpa_s->p2pdev;
6545 #endif /* CONFIG_P2P */
6546 default:
6547 return wpa_s;
6548 }
6549 }
6550
6551
6552 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
6553 {
6554 unsigned int i;
6555 char buf[30];
6556
6557 wpa_printf(MSG_DEBUG, "Update vendor elements");
6558
6559 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
6560 if (wpa_s->vendor_elem[i]) {
6561 int res;
6562
6563 res = os_snprintf(buf, sizeof(buf), "frame[%u]", i);
6564 if (!os_snprintf_error(sizeof(buf), res)) {
6565 wpa_hexdump_buf(MSG_DEBUG, buf,
6566 wpa_s->vendor_elem[i]);
6567 }
6568 }
6569 }
6570
6571 #ifdef CONFIG_P2P
6572 if (wpa_s->parent == wpa_s &&
6573 wpa_s->global->p2p &&
6574 !wpa_s->global->p2p_disabled)
6575 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
6576 #endif /* CONFIG_P2P */
6577 }
6578
6579
6580 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
6581 const u8 *elem, size_t len)
6582 {
6583 u8 *ie, *end;
6584
6585 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
6586 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
6587
6588 for (; ie + 1 < end; ie += 2 + ie[1]) {
6589 if (ie + len > end)
6590 break;
6591 if (os_memcmp(ie, elem, len) != 0)
6592 continue;
6593
6594 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
6595 wpabuf_free(wpa_s->vendor_elem[frame]);
6596 wpa_s->vendor_elem[frame] = NULL;
6597 } else {
6598 os_memmove(ie, ie + len, end - (ie + len));
6599 wpa_s->vendor_elem[frame]->used -= len;
6600 }
6601 wpas_vendor_elem_update(wpa_s);
6602 return 0;
6603 }
6604
6605 return -1;
6606 }
6607
6608
6609 struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
6610 u16 num_modes, enum hostapd_hw_mode mode)
6611 {
6612 u16 i;
6613
6614 for (i = 0; i < num_modes; i++) {
6615 if (modes[i].mode == mode)
6616 return &modes[i];
6617 }
6618
6619 return NULL;
6620 }
6621
6622
6623 static struct
6624 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
6625 const u8 *bssid)
6626 {
6627 struct wpa_bss_tmp_disallowed *bss;
6628
6629 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
6630 struct wpa_bss_tmp_disallowed, list) {
6631 if (os_memcmp(bssid, bss->bssid, ETH_ALEN) == 0)
6632 return bss;
6633 }
6634
6635 return NULL;
6636 }
6637
6638
6639 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
6640 unsigned int sec)
6641 {
6642 struct wpa_bss_tmp_disallowed *bss;
6643 struct os_reltime until;
6644
6645 os_get_reltime(&until);
6646 until.sec += sec;
6647
6648 bss = wpas_get_disallowed_bss(wpa_s, bssid);
6649 if (bss) {
6650 bss->disallowed_until = until;
6651 return;
6652 }
6653
6654 bss = os_malloc(sizeof(*bss));
6655 if (!bss) {
6656 wpa_printf(MSG_DEBUG,
6657 "Failed to allocate memory for temp disallow BSS");
6658 return;
6659 }
6660
6661 bss->disallowed_until = until;
6662 os_memcpy(bss->bssid, bssid, ETH_ALEN);
6663 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
6664 }
6665
6666
6667 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s, const u8 *bssid)
6668 {
6669 struct wpa_bss_tmp_disallowed *bss = NULL, *tmp, *prev;
6670 struct os_reltime now, age;
6671
6672 os_get_reltime(&now);
6673
6674 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
6675 struct wpa_bss_tmp_disallowed, list) {
6676 if (!os_reltime_before(&now, &tmp->disallowed_until)) {
6677 /* This BSS is not disallowed anymore */
6678 dl_list_del(&tmp->list);
6679 os_free(tmp);
6680 continue;
6681 }
6682 if (os_memcmp(bssid, tmp->bssid, ETH_ALEN) == 0) {
6683 bss = tmp;
6684 break;
6685 }
6686 }
6687 if (!bss)
6688 return 0;
6689
6690 os_reltime_sub(&bss->disallowed_until, &now, &age);
6691 wpa_printf(MSG_DEBUG,
6692 "BSS " MACSTR " disabled for %ld.%0ld seconds",
6693 MAC2STR(bss->bssid), age.sec, age.usec);
6694 return 1;
6695 }
Unnamed repository; edit this file 'description' to name the repository.