3 * Copyright (c) 2003-2016, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
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.
14 #ifdef CONFIG_MATCH_IFACE
17 #endif /* CONFIG_MATCH_IFACE */
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"
29 #include "utils/ext_password.h"
30 #include "l2_packet/l2_packet.h"
31 #include "wpa_supplicant_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"
43 #include "blacklist.h"
44 #include "wpas_glue.h"
45 #include "wps_supplicant.h"
48 #include "gas_query.h"
50 #include "p2p_supplicant.h"
51 #include "wifi_display.h"
57 #include "offchannel.h"
58 #include "hs20_supplicant.h"
63 const char *const wpa_supplicant_version =
64 "wpa_supplicant v" VERSION_STR "\n"
65 "Copyright (c) 2003-2016, Jouni Malinen <j@w1.fi> and contributors";
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 */
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 =
80 const char *const wpa_supplicant_full_license2 =
81 "This software may be distributed under the terms of the BSD license.\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"
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"
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"
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"
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"
113 #endif /* CONFIG_NO_STDOUT_DEBUG */
115 /* Configure default/group WEP keys for static WEP */
116 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
120 for (i = 0; i < NUM_WEP_KEYS; i++) {
121 if (ssid->wep_key_len[i] == 0)
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]);
134 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
135 struct wpa_ssid *ssid)
143 /* IBSS/WPA-None uses only one key (Group) for both receiving and
144 * sending unicast and multicast packets. */
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);
152 if (!ssid->psk_set) {
153 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
158 switch (wpa_s->group_cipher) {
159 case WPA_CIPHER_CCMP:
160 os_memcpy(key, ssid->psk, 16);
164 case WPA_CIPHER_GCMP:
165 os_memcpy(key, ssid->psk, 16);
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);
177 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
178 "WPA-None", wpa_s->group_cipher);
182 /* TODO: should actually remember the previously used seq#, both for TX
183 * and RX from each STA.. */
185 ret = wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
186 os_memset(key, 0, sizeof(key));
191 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
193 struct wpa_supplicant *wpa_s = eloop_ctx;
194 const u8 *bssid = wpa_s->bssid;
195 if (is_zero_ether_addr(bssid))
196 bssid = wpa_s->pending_bssid;
197 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
199 wpa_blacklist_add(wpa_s, bssid);
200 wpa_sm_notify_disassoc(wpa_s->wpa);
201 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
202 wpa_s->reassociate = 1;
205 * If we timed out, the AP or the local radio may be busy.
206 * So, wait a second until scanning again.
208 wpa_supplicant_req_scan(wpa_s, 1, 0);
213 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
214 * @wpa_s: Pointer to wpa_supplicant data
215 * @sec: Number of seconds after which to time out authentication
216 * @usec: Number of microseconds after which to time out authentication
218 * This function is used to schedule a timeout for the current authentication
221 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
224 if (wpa_s->conf->ap_scan == 0 &&
225 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
228 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
229 "%d usec", sec, usec);
230 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
231 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
236 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
237 * @wpa_s: Pointer to wpa_supplicant data
239 * This function is used to cancel authentication timeout scheduled with
240 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
243 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
245 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
246 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
247 wpa_blacklist_del(wpa_s, wpa_s->bssid);
252 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
253 * @wpa_s: Pointer to wpa_supplicant data
255 * This function is used to configure EAPOL state machine based on the selected
256 * authentication mode.
258 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
260 #ifdef IEEE8021X_EAPOL
261 struct eapol_config eapol_conf;
262 struct wpa_ssid *ssid = wpa_s->current_ssid;
264 #ifdef CONFIG_IBSS_RSN
265 if (ssid->mode == WPAS_MODE_IBSS &&
266 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
267 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
269 * RSN IBSS authentication is per-STA and we can disable the
270 * per-BSSID EAPOL authentication.
272 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
273 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
274 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
277 #endif /* CONFIG_IBSS_RSN */
279 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
280 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
282 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
283 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
284 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
286 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
288 os_memset(&eapol_conf, 0, sizeof(eapol_conf));
289 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
290 eapol_conf.accept_802_1x_keys = 1;
291 eapol_conf.required_keys = 0;
292 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) {
293 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST;
295 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) {
296 eapol_conf.required_keys |=
297 EAPOL_REQUIRE_KEY_BROADCAST;
300 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
301 eapol_conf.required_keys = 0;
303 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
304 eapol_conf.workaround = ssid->eap_workaround;
305 eapol_conf.eap_disabled =
306 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
307 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
308 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
309 eapol_conf.external_sim = wpa_s->conf->external_sim;
312 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
313 eapol_conf.wps |= EAPOL_LOCAL_WPS_IN_USE;
314 if (wpa_s->current_bss) {
316 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
321 EAPOL_PEER_IS_WPS20_AP;
326 #endif /* CONFIG_WPS */
328 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
330 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
331 #endif /* IEEE8021X_EAPOL */
336 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
337 * @wpa_s: Pointer to wpa_supplicant data
338 * @ssid: Configuration data for the network
340 * This function is used to configure WPA state machine and related parameters
341 * to a mode where WPA is not enabled. This is called as part of the
342 * authentication configuration when the selected network does not use WPA.
344 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
345 struct wpa_ssid *ssid)
349 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
350 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
351 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)
352 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
354 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
355 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
356 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
357 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
358 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
359 wpa_s->group_cipher = WPA_CIPHER_NONE;
360 wpa_s->mgmt_group_cipher = 0;
362 for (i = 0; i < NUM_WEP_KEYS; i++) {
363 if (ssid->wep_key_len[i] > 5) {
364 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
365 wpa_s->group_cipher = WPA_CIPHER_WEP104;
367 } else if (ssid->wep_key_len[i] > 0) {
368 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
369 wpa_s->group_cipher = WPA_CIPHER_WEP40;
374 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
375 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
376 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
377 wpa_s->pairwise_cipher);
378 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
379 #ifdef CONFIG_IEEE80211W
380 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
381 wpa_s->mgmt_group_cipher);
382 #endif /* CONFIG_IEEE80211W */
384 pmksa_cache_clear_current(wpa_s->wpa);
388 void free_hw_features(struct wpa_supplicant *wpa_s)
391 if (wpa_s->hw.modes == NULL)
394 for (i = 0; i < wpa_s->hw.num_modes; i++) {
395 os_free(wpa_s->hw.modes[i].channels);
396 os_free(wpa_s->hw.modes[i].rates);
399 os_free(wpa_s->hw.modes);
400 wpa_s->hw.modes = NULL;
404 static void free_bss_tmp_disallowed(struct wpa_supplicant *wpa_s)
406 struct wpa_bss_tmp_disallowed *bss, *prev;
408 dl_list_for_each_safe(bss, prev, &wpa_s->bss_tmp_disallowed,
409 struct wpa_bss_tmp_disallowed, list) {
410 dl_list_del(&bss->list);
416 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
420 bgscan_deinit(wpa_s);
421 autoscan_deinit(wpa_s);
422 scard_deinit(wpa_s->scard);
424 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
425 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
426 l2_packet_deinit(wpa_s->l2);
429 l2_packet_deinit(wpa_s->l2_br);
432 #ifdef CONFIG_TESTING_OPTIONS
433 l2_packet_deinit(wpa_s->l2_test);
434 wpa_s->l2_test = NULL;
435 #endif /* CONFIG_TESTING_OPTIONS */
437 if (wpa_s->conf != NULL) {
438 struct wpa_ssid *ssid;
439 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
440 wpas_notify_network_removed(wpa_s, ssid);
443 os_free(wpa_s->confname);
444 wpa_s->confname = NULL;
446 os_free(wpa_s->confanother);
447 wpa_s->confanother = NULL;
449 wpa_sm_set_eapol(wpa_s->wpa, NULL);
450 eapol_sm_deinit(wpa_s->eapol);
453 rsn_preauth_deinit(wpa_s->wpa);
456 wpa_tdls_deinit(wpa_s->wpa);
457 #endif /* CONFIG_TDLS */
459 wmm_ac_clear_saved_tspecs(wpa_s);
460 pmksa_candidate_free(wpa_s->wpa);
461 wpa_sm_deinit(wpa_s->wpa);
463 wpa_blacklist_clear(wpa_s);
465 wpa_bss_deinit(wpa_s);
467 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
468 wpa_supplicant_cancel_scan(wpa_s);
469 wpa_supplicant_cancel_auth_timeout(wpa_s);
470 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
471 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
472 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report,
474 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
476 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
478 wpas_wps_deinit(wpa_s);
480 wpabuf_free(wpa_s->pending_eapol_rx);
481 wpa_s->pending_eapol_rx = NULL;
483 #ifdef CONFIG_IBSS_RSN
484 ibss_rsn_deinit(wpa_s->ibss_rsn);
485 wpa_s->ibss_rsn = NULL;
486 #endif /* CONFIG_IBSS_RSN */
491 wpa_supplicant_ap_deinit(wpa_s);
492 #endif /* CONFIG_AP */
494 wpas_p2p_deinit(wpa_s);
496 #ifdef CONFIG_OFFCHANNEL
497 offchannel_deinit(wpa_s);
498 #endif /* CONFIG_OFFCHANNEL */
500 wpa_supplicant_cancel_sched_scan(wpa_s);
502 os_free(wpa_s->next_scan_freqs);
503 wpa_s->next_scan_freqs = NULL;
505 os_free(wpa_s->manual_scan_freqs);
506 wpa_s->manual_scan_freqs = NULL;
508 os_free(wpa_s->manual_sched_scan_freqs);
509 wpa_s->manual_sched_scan_freqs = NULL;
511 wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
514 * Need to remove any pending gas-query radio work before the
515 * gas_query_deinit() call because gas_query::work has not yet been set
516 * for works that have not been started. gas_query_free() will be unable
517 * to cancel such pending radio works and once the pending gas-query
518 * radio work eventually gets removed, the deinit notification call to
519 * gas_query_start_cb() would result in dereferencing freed memory.
522 radio_remove_works(wpa_s, "gas-query", 0);
523 gas_query_deinit(wpa_s->gas);
526 free_hw_features(wpa_s);
528 ieee802_1x_dealloc_kay_sm(wpa_s);
530 os_free(wpa_s->bssid_filter);
531 wpa_s->bssid_filter = NULL;
533 os_free(wpa_s->disallow_aps_bssid);
534 wpa_s->disallow_aps_bssid = NULL;
535 os_free(wpa_s->disallow_aps_ssid);
536 wpa_s->disallow_aps_ssid = NULL;
538 wnm_bss_keep_alive_deinit(wpa_s);
540 wnm_deallocate_memory(wpa_s);
541 #endif /* CONFIG_WNM */
543 ext_password_deinit(wpa_s->ext_pw);
544 wpa_s->ext_pw = NULL;
546 wpabuf_free(wpa_s->last_gas_resp);
547 wpa_s->last_gas_resp = NULL;
548 wpabuf_free(wpa_s->prev_gas_resp);
549 wpa_s->prev_gas_resp = NULL;
551 os_free(wpa_s->last_scan_res);
552 wpa_s->last_scan_res = NULL;
556 wpa_drv_configure_frame_filters(wpa_s, 0);
558 #endif /* CONFIG_HS20 */
560 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
561 wpabuf_free(wpa_s->vendor_elem[i]);
562 wpa_s->vendor_elem[i] = NULL;
565 wmm_ac_notify_disassoc(wpa_s);
567 wpa_s->sched_scan_plans_num = 0;
568 os_free(wpa_s->sched_scan_plans);
569 wpa_s->sched_scan_plans = NULL;
572 wpa_s->non_pref_chan_num = 0;
573 os_free(wpa_s->non_pref_chan);
574 wpa_s->non_pref_chan = NULL;
575 #endif /* CONFIG_MBO */
577 free_bss_tmp_disallowed(wpa_s);
579 wpabuf_free(wpa_s->lci);
585 * wpa_clear_keys - Clear keys configured for the driver
586 * @wpa_s: Pointer to wpa_supplicant data
587 * @addr: Previously used BSSID or %NULL if not available
589 * This function clears the encryption keys that has been previously configured
592 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
596 #ifdef CONFIG_IEEE80211W
598 #else /* CONFIG_IEEE80211W */
600 #endif /* CONFIG_IEEE80211W */
602 /* MLME-DELETEKEYS.request */
603 for (i = 0; i < max; i++) {
604 if (wpa_s->keys_cleared & BIT(i))
606 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
609 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
610 !is_zero_ether_addr(addr)) {
611 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
613 /* MLME-SETPROTECTION.request(None) */
614 wpa_drv_mlme_setprotection(
616 MLME_SETPROTECTION_PROTECT_TYPE_NONE,
617 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE);
619 wpa_s->keys_cleared = (u32) -1;
624 * wpa_supplicant_state_txt - Get the connection state name as a text string
625 * @state: State (wpa_state; WPA_*)
626 * Returns: The state name as a printable text string
628 const char * wpa_supplicant_state_txt(enum wpa_states state)
631 case WPA_DISCONNECTED:
632 return "DISCONNECTED";
635 case WPA_INTERFACE_DISABLED:
636 return "INTERFACE_DISABLED";
639 case WPA_AUTHENTICATING:
640 return "AUTHENTICATING";
641 case WPA_ASSOCIATING:
642 return "ASSOCIATING";
645 case WPA_4WAY_HANDSHAKE:
646 return "4WAY_HANDSHAKE";
647 case WPA_GROUP_HANDSHAKE:
648 return "GROUP_HANDSHAKE";
659 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
663 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
664 name = wpa_s->current_ssid->bgscan;
666 name = wpa_s->conf->bgscan;
667 if (name == NULL || name[0] == '\0')
669 if (wpas_driver_bss_selection(wpa_s))
671 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
674 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
676 #endif /* CONFIG_P2P */
678 bgscan_deinit(wpa_s);
679 if (wpa_s->current_ssid) {
680 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
681 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
684 * Live without bgscan; it is only used as a roaming
685 * optimization, so the initial connection is not
689 struct wpa_scan_results *scan_res;
690 wpa_s->bgscan_ssid = wpa_s->current_ssid;
691 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
694 bgscan_notify_scan(wpa_s, scan_res);
695 wpa_scan_results_free(scan_res);
699 wpa_s->bgscan_ssid = NULL;
703 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
705 if (wpa_s->bgscan_ssid != NULL) {
706 bgscan_deinit(wpa_s);
707 wpa_s->bgscan_ssid = NULL;
711 #endif /* CONFIG_BGSCAN */
714 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
716 if (autoscan_init(wpa_s, 0))
717 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
721 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
723 autoscan_deinit(wpa_s);
727 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
729 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
730 wpa_s->wpa_state == WPA_SCANNING) {
731 autoscan_deinit(wpa_s);
732 wpa_supplicant_start_autoscan(wpa_s);
738 * wpa_supplicant_set_state - Set current connection state
739 * @wpa_s: Pointer to wpa_supplicant data
740 * @state: The new connection state
742 * This function is called whenever the connection state changes, e.g.,
743 * association is completed for WPA/WPA2 4-Way Handshake is started.
745 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
746 enum wpa_states state)
748 enum wpa_states old_state = wpa_s->wpa_state;
750 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
751 wpa_supplicant_state_txt(wpa_s->wpa_state),
752 wpa_supplicant_state_txt(state));
754 if (state == WPA_INTERFACE_DISABLED) {
755 /* Assure normal scan when interface is restored */
756 wpa_s->normal_scans = 0;
759 if (state == WPA_COMPLETED) {
760 wpas_connect_work_done(wpa_s);
761 /* Reinitialize normal_scan counter */
762 wpa_s->normal_scans = 0;
767 * P2PS client has to reply to Probe Request frames received on the
768 * group operating channel. Enable Probe Request frame reporting for
769 * P2P connected client in case p2p_cli_probe configuration property is
772 if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid &&
773 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
774 wpa_s->current_ssid->p2p_group) {
775 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) {
776 wpa_dbg(wpa_s, MSG_DEBUG,
777 "P2P: Enable CLI Probe Request RX reporting");
778 wpa_s->p2p_cli_probe =
779 wpa_drv_probe_req_report(wpa_s, 1) >= 0;
780 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) {
781 wpa_dbg(wpa_s, MSG_DEBUG,
782 "P2P: Disable CLI Probe Request RX reporting");
783 wpa_s->p2p_cli_probe = 0;
784 wpa_drv_probe_req_report(wpa_s, 0);
787 #endif /* CONFIG_P2P */
789 if (state != WPA_SCANNING)
790 wpa_supplicant_notify_scanning(wpa_s, 0);
792 if (state == WPA_COMPLETED && wpa_s->new_connection) {
793 struct wpa_ssid *ssid = wpa_s->current_ssid;
794 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
795 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
796 MACSTR " completed [id=%d id_str=%s]",
797 MAC2STR(wpa_s->bssid),
798 ssid ? ssid->id : -1,
799 ssid && ssid->id_str ? ssid->id_str : "");
800 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
801 wpas_clear_temp_disabled(wpa_s, ssid, 1);
802 wpa_blacklist_clear(wpa_s);
803 wpa_s->extra_blacklist_count = 0;
804 wpa_s->new_connection = 0;
805 wpa_drv_set_operstate(wpa_s, 1);
806 #ifndef IEEE8021X_EAPOL
807 wpa_drv_set_supp_port(wpa_s, 1);
808 #endif /* IEEE8021X_EAPOL */
809 wpa_s->after_wps = 0;
810 wpa_s->known_wps_freq = 0;
811 wpas_p2p_completed(wpa_s);
813 sme_sched_obss_scan(wpa_s, 1);
814 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING ||
815 state == WPA_ASSOCIATED) {
816 wpa_s->new_connection = 1;
817 wpa_drv_set_operstate(wpa_s, 0);
818 #ifndef IEEE8021X_EAPOL
819 wpa_drv_set_supp_port(wpa_s, 0);
820 #endif /* IEEE8021X_EAPOL */
821 sme_sched_obss_scan(wpa_s, 0);
823 wpa_s->wpa_state = state;
826 if (state == WPA_COMPLETED)
827 wpa_supplicant_start_bgscan(wpa_s);
828 else if (state < WPA_ASSOCIATED)
829 wpa_supplicant_stop_bgscan(wpa_s);
830 #endif /* CONFIG_BGSCAN */
832 if (state == WPA_AUTHENTICATING)
833 wpa_supplicant_stop_autoscan(wpa_s);
835 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE)
836 wpa_supplicant_start_autoscan(wpa_s);
838 if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
839 wmm_ac_notify_disassoc(wpa_s);
841 if (wpa_s->wpa_state != old_state) {
842 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
845 * Notify the P2P Device interface about a state change in one
848 wpas_p2p_indicate_state_change(wpa_s);
850 if (wpa_s->wpa_state == WPA_COMPLETED ||
851 old_state == WPA_COMPLETED)
852 wpas_notify_auth_changed(wpa_s);
857 void wpa_supplicant_terminate_proc(struct wpa_global *global)
861 struct wpa_supplicant *wpa_s = global->ifaces;
863 struct wpa_supplicant *next = wpa_s->next;
864 if (wpas_wps_terminate_pending(wpa_s) == 1)
867 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
868 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
869 wpas_p2p_disconnect(wpa_s);
870 #endif /* CONFIG_P2P */
873 #endif /* CONFIG_WPS */
880 static void wpa_supplicant_terminate(int sig, void *signal_ctx)
882 struct wpa_global *global = signal_ctx;
883 wpa_supplicant_terminate_proc(global);
887 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
889 enum wpa_states old_state = wpa_s->wpa_state;
891 wpa_s->pairwise_cipher = 0;
892 wpa_s->group_cipher = 0;
893 wpa_s->mgmt_group_cipher = 0;
895 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
896 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
898 if (wpa_s->wpa_state != old_state)
899 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
904 * wpa_supplicant_reload_configuration - Reload configuration data
905 * @wpa_s: Pointer to wpa_supplicant data
906 * Returns: 0 on success or -1 if configuration parsing failed
908 * This function can be used to request that the configuration data is reloaded
909 * (e.g., after configuration file change). This function is reloading
910 * configuration only for one interface, so this may need to be called multiple
911 * times if %wpa_supplicant is controlling multiple interfaces and all
912 * interfaces need reconfiguration.
914 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
916 struct wpa_config *conf;
920 if (wpa_s->confname == NULL)
922 conf = wpa_config_read(wpa_s->confname, NULL);
924 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
925 "file '%s' - exiting", wpa_s->confname);
928 wpa_config_read(wpa_s->confanother, conf);
930 conf->changed_parameters = (unsigned int) -1;
932 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
933 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
934 os_strcmp(conf->ctrl_interface,
935 wpa_s->conf->ctrl_interface) != 0);
937 if (reconf_ctrl && wpa_s->ctrl_iface) {
938 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
939 wpa_s->ctrl_iface = NULL;
942 eapol_sm_invalidate_cached_session(wpa_s->eapol);
943 if (wpa_s->current_ssid) {
944 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
945 wpa_s->own_disconnect_req = 1;
946 wpa_supplicant_deauthenticate(wpa_s,
947 WLAN_REASON_DEAUTH_LEAVING);
951 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
952 * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
954 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
956 * Clear forced success to clear EAP state for next
959 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
961 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
962 wpa_sm_set_config(wpa_s->wpa, NULL);
963 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
964 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
965 rsn_preauth_deinit(wpa_s->wpa);
967 old_ap_scan = wpa_s->conf->ap_scan;
968 wpa_config_free(wpa_s->conf);
970 if (old_ap_scan != wpa_s->conf->ap_scan)
971 wpas_notify_ap_scan_changed(wpa_s);
974 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
976 wpa_supplicant_update_config(wpa_s);
978 wpa_supplicant_clear_status(wpa_s);
979 if (wpa_supplicant_enabled_networks(wpa_s)) {
980 wpa_s->reassociate = 1;
981 wpa_supplicant_req_scan(wpa_s, 0, 0);
983 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
988 static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
990 struct wpa_global *global = signal_ctx;
991 struct wpa_supplicant *wpa_s;
992 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
993 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
995 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
996 wpa_supplicant_terminate_proc(global);
1000 if (wpa_debug_reopen_file() < 0) {
1001 /* Ignore errors since we cannot really do much to fix this */
1002 wpa_printf(MSG_DEBUG, "Could not reopen debug log file");
1007 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
1008 struct wpa_ssid *ssid,
1009 struct wpa_ie_data *ie)
1011 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
1014 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
1015 "from association info");
1020 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
1022 if (!(ie->group_cipher & ssid->group_cipher)) {
1023 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
1024 "cipher 0x%x (mask 0x%x) - reject",
1025 ie->group_cipher, ssid->group_cipher);
1028 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) {
1029 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
1030 "cipher 0x%x (mask 0x%x) - reject",
1031 ie->pairwise_cipher, ssid->pairwise_cipher);
1034 if (!(ie->key_mgmt & ssid->key_mgmt)) {
1035 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
1036 "management 0x%x (mask 0x%x) - reject",
1037 ie->key_mgmt, ssid->key_mgmt);
1041 #ifdef CONFIG_IEEE80211W
1042 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) &&
1043 wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
1044 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
1045 "that does not support management frame protection - "
1049 #endif /* CONFIG_IEEE80211W */
1056 * wpa_supplicant_set_suites - Set authentication and encryption parameters
1057 * @wpa_s: Pointer to wpa_supplicant data
1058 * @bss: Scan results for the selected BSS, or %NULL if not available
1059 * @ssid: Configuration data for the selected network
1060 * @wpa_ie: Buffer for the WPA/RSN IE
1061 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
1062 * used buffer length in case the functions returns success.
1063 * Returns: 0 on success or -1 on failure
1065 * This function is used to configure authentication and encryption parameters
1066 * based on the network configuration and scan result for the selected BSS (if
1069 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
1070 struct wpa_bss *bss, struct wpa_ssid *ssid,
1071 u8 *wpa_ie, size_t *wpa_ie_len)
1073 struct wpa_ie_data ie;
1075 const u8 *bss_wpa, *bss_rsn, *bss_osen;
1078 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
1079 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
1080 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
1082 bss_wpa = bss_rsn = bss_osen = NULL;
1084 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) &&
1085 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 &&
1086 (ie.group_cipher & ssid->group_cipher) &&
1087 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1088 (ie.key_mgmt & ssid->key_mgmt)) {
1089 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1090 proto = WPA_PROTO_RSN;
1091 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) &&
1092 wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie) == 0 &&
1093 (ie.group_cipher & ssid->group_cipher) &&
1094 (ie.pairwise_cipher & ssid->pairwise_cipher) &&
1095 (ie.key_mgmt & ssid->key_mgmt)) {
1096 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1097 proto = WPA_PROTO_WPA;
1099 } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN)) {
1100 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1101 /* TODO: parse OSEN element */
1102 os_memset(&ie, 0, sizeof(ie));
1103 ie.group_cipher = WPA_CIPHER_CCMP;
1104 ie.pairwise_cipher = WPA_CIPHER_CCMP;
1105 ie.key_mgmt = WPA_KEY_MGMT_OSEN;
1106 proto = WPA_PROTO_OSEN;
1107 #endif /* CONFIG_HS20 */
1109 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1110 wpa_dbg(wpa_s, MSG_DEBUG,
1111 "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1112 ssid->proto, ssid->pairwise_cipher, ssid->group_cipher,
1114 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1115 MAC2STR(bss->bssid),
1116 wpa_ssid_txt(bss->ssid, bss->ssid_len),
1117 bss_wpa ? " WPA" : "",
1118 bss_rsn ? " RSN" : "",
1119 bss_osen ? " OSEN" : "");
1121 wpa_hexdump(MSG_DEBUG, "RSN", bss_rsn, 2 + bss_rsn[1]);
1122 if (wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie)) {
1123 wpa_dbg(wpa_s, MSG_DEBUG,
1124 "Could not parse RSN element");
1126 wpa_dbg(wpa_s, MSG_DEBUG,
1127 "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1128 ie.pairwise_cipher, ie.group_cipher,
1133 wpa_hexdump(MSG_DEBUG, "WPA", bss_wpa, 2 + bss_wpa[1]);
1134 if (wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie)) {
1135 wpa_dbg(wpa_s, MSG_DEBUG,
1136 "Could not parse WPA element");
1138 wpa_dbg(wpa_s, MSG_DEBUG,
1139 "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1140 ie.pairwise_cipher, ie.group_cipher,
1146 if (ssid->proto & WPA_PROTO_OSEN)
1147 proto = WPA_PROTO_OSEN;
1148 else if (ssid->proto & WPA_PROTO_RSN)
1149 proto = WPA_PROTO_RSN;
1151 proto = WPA_PROTO_WPA;
1152 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1153 os_memset(&ie, 0, sizeof(ie));
1154 ie.group_cipher = ssid->group_cipher;
1155 ie.pairwise_cipher = ssid->pairwise_cipher;
1156 ie.key_mgmt = ssid->key_mgmt;
1157 #ifdef CONFIG_IEEE80211W
1158 ie.mgmt_group_cipher =
1159 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ?
1160 WPA_CIPHER_AES_128_CMAC : 0;
1161 #endif /* CONFIG_IEEE80211W */
1162 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1163 "based on configuration");
1168 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1169 "pairwise %d key_mgmt %d proto %d",
1170 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto);
1171 #ifdef CONFIG_IEEE80211W
1172 if (ssid->ieee80211w) {
1173 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1174 ie.mgmt_group_cipher);
1176 #endif /* CONFIG_IEEE80211W */
1178 wpa_s->wpa_proto = proto;
1179 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1180 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1181 !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)));
1183 if (bss || !wpa_s->ap_ies_from_associnfo) {
1184 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1185 bss_wpa ? 2 + bss_wpa[1] : 0) ||
1186 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1187 bss_rsn ? 2 + bss_rsn[1] : 0))
1191 #ifdef CONFIG_NO_WPA
1192 wpa_s->group_cipher = WPA_CIPHER_NONE;
1193 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1194 #else /* CONFIG_NO_WPA */
1195 sel = ie.group_cipher & ssid->group_cipher;
1196 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1197 if (wpa_s->group_cipher < 0) {
1198 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1202 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1203 wpa_cipher_txt(wpa_s->group_cipher));
1205 sel = ie.pairwise_cipher & ssid->pairwise_cipher;
1206 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1207 if (wpa_s->pairwise_cipher < 0) {
1208 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1212 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1213 wpa_cipher_txt(wpa_s->pairwise_cipher));
1214 #endif /* CONFIG_NO_WPA */
1216 sel = ie.key_mgmt & ssid->key_mgmt;
1218 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1219 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE);
1220 #endif /* CONFIG_SAE */
1222 #ifdef CONFIG_SUITEB192
1223 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
1224 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1225 wpa_dbg(wpa_s, MSG_DEBUG,
1226 "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)");
1227 #endif /* CONFIG_SUITEB192 */
1228 #ifdef CONFIG_SUITEB
1229 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B) {
1230 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1231 wpa_dbg(wpa_s, MSG_DEBUG,
1232 "WPA: using KEY_MGMT 802.1X with Suite B");
1233 #endif /* CONFIG_SUITEB */
1234 #ifdef CONFIG_IEEE80211R
1235 } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) {
1236 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1237 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1238 } else if (sel & WPA_KEY_MGMT_FT_PSK) {
1239 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1240 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1241 #endif /* CONFIG_IEEE80211R */
1243 } else if (sel & WPA_KEY_MGMT_SAE) {
1244 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1245 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1246 } else if (sel & WPA_KEY_MGMT_FT_SAE) {
1247 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1248 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1249 #endif /* CONFIG_SAE */
1250 #ifdef CONFIG_IEEE80211W
1251 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) {
1252 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1253 wpa_dbg(wpa_s, MSG_DEBUG,
1254 "WPA: using KEY_MGMT 802.1X with SHA256");
1255 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) {
1256 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1257 wpa_dbg(wpa_s, MSG_DEBUG,
1258 "WPA: using KEY_MGMT PSK with SHA256");
1259 #endif /* CONFIG_IEEE80211W */
1260 } else if (sel & WPA_KEY_MGMT_IEEE8021X) {
1261 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1262 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1263 } else if (sel & WPA_KEY_MGMT_PSK) {
1264 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1265 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1266 } else if (sel & WPA_KEY_MGMT_WPA_NONE) {
1267 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1268 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1270 } else if (sel & WPA_KEY_MGMT_OSEN) {
1271 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1272 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1273 #endif /* CONFIG_HS20 */
1275 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1276 "authenticated key management type");
1280 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1281 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1282 wpa_s->pairwise_cipher);
1283 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1285 #ifdef CONFIG_IEEE80211W
1286 sel = ie.mgmt_group_cipher;
1287 if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1288 !(ie.capabilities & WPA_CAPABILITY_MFPC))
1290 if (sel & WPA_CIPHER_AES_128_CMAC) {
1291 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1292 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1294 } else if (sel & WPA_CIPHER_BIP_GMAC_128) {
1295 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1296 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1298 } else if (sel & WPA_CIPHER_BIP_GMAC_256) {
1299 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1300 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1302 } else if (sel & WPA_CIPHER_BIP_CMAC_256) {
1303 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1304 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1307 wpa_s->mgmt_group_cipher = 0;
1308 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1310 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1311 wpa_s->mgmt_group_cipher);
1312 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1313 wpas_get_ssid_pmf(wpa_s, ssid));
1314 #endif /* CONFIG_IEEE80211W */
1316 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1317 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1321 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) {
1324 if (ssid->psk_set) {
1325 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL,
1329 #ifndef CONFIG_NO_PBKDF2
1330 if (bss && ssid->bssid_set && ssid->ssid_len == 0 &&
1333 pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len,
1334 4096, psk, PMK_LEN);
1335 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)",
1337 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL, NULL);
1339 os_memset(psk, 0, sizeof(psk));
1341 #endif /* CONFIG_NO_PBKDF2 */
1342 #ifdef CONFIG_EXT_PASSWORD
1343 if (ssid->ext_psk) {
1344 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1346 char pw_str[64 + 1];
1350 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1351 "found from external storage");
1355 if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) {
1356 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1357 "PSK length %d in external storage",
1358 (int) wpabuf_len(pw));
1359 ext_password_free(pw);
1363 os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw));
1364 pw_str[wpabuf_len(pw)] = '\0';
1366 #ifndef CONFIG_NO_PBKDF2
1367 if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss)
1369 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len,
1370 4096, psk, PMK_LEN);
1371 os_memset(pw_str, 0, sizeof(pw_str));
1372 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from "
1373 "external passphrase)",
1375 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1378 os_memset(psk, 0, sizeof(psk));
1380 #endif /* CONFIG_NO_PBKDF2 */
1381 if (wpabuf_len(pw) == 2 * PMK_LEN) {
1382 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) {
1383 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1384 "Invalid PSK hex string");
1385 os_memset(pw_str, 0, sizeof(pw_str));
1386 ext_password_free(pw);
1389 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1392 os_memset(psk, 0, sizeof(psk));
1394 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1396 os_memset(pw_str, 0, sizeof(pw_str));
1397 ext_password_free(pw);
1401 os_memset(pw_str, 0, sizeof(pw_str));
1402 ext_password_free(pw);
1404 #endif /* CONFIG_EXT_PASSWORD */
1407 wpa_msg(wpa_s, MSG_INFO,
1408 "No PSK available for association");
1412 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1418 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1423 case 0: /* Bits 0-7 */
1425 case 1: /* Bits 8-15 */
1427 case 2: /* Bits 16-23 */
1429 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */
1430 *pos |= 0x08; /* Bit 19 - BSS Transition */
1431 #endif /* CONFIG_WNM */
1433 case 3: /* Bits 24-31 */
1435 *pos |= 0x02; /* Bit 25 - SSID List */
1436 #endif /* CONFIG_WNM */
1437 #ifdef CONFIG_INTERWORKING
1438 if (wpa_s->conf->interworking)
1439 *pos |= 0x80; /* Bit 31 - Interworking */
1440 #endif /* CONFIG_INTERWORKING */
1442 case 4: /* Bits 32-39 */
1443 #ifdef CONFIG_INTERWORKING
1444 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1445 *pos |= 0x01; /* Bit 32 - QoS Map */
1446 #endif /* CONFIG_INTERWORKING */
1448 case 5: /* Bits 40-47 */
1450 if (wpa_s->conf->hs20)
1451 *pos |= 0x40; /* Bit 46 - WNM-Notification */
1452 #endif /* CONFIG_HS20 */
1454 *pos |= 0x40; /* Bit 46 - WNM-Notification */
1455 #endif /* CONFIG_MBO */
1457 case 6: /* Bits 48-55 */
1459 case 7: /* Bits 56-63 */
1461 case 8: /* Bits 64-71 */
1462 if (wpa_s->conf->ftm_responder)
1463 *pos |= 0x40; /* Bit 70 - FTM responder */
1464 if (wpa_s->conf->ftm_initiator)
1465 *pos |= 0x80; /* Bit 71 - FTM initiator */
1471 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1477 (wpa_s->conf->ftm_initiator || wpa_s->conf->ftm_responder))
1479 if (len < wpa_s->extended_capa_len)
1480 len = wpa_s->extended_capa_len;
1481 if (buflen < (size_t) len + 2) {
1482 wpa_printf(MSG_INFO,
1483 "Not enough room for building extended capabilities element");
1487 *pos++ = WLAN_EID_EXT_CAPAB;
1489 for (i = 0; i < len; i++, pos++) {
1490 wpas_ext_capab_byte(wpa_s, pos, i);
1492 if (i < wpa_s->extended_capa_len) {
1493 *pos &= ~wpa_s->extended_capa_mask[i];
1494 *pos |= wpa_s->extended_capa[i];
1498 while (len > 0 && buf[1 + len] == 0) {
1509 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1510 struct wpa_bss *test_bss)
1512 struct wpa_bss *bss;
1514 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1515 if (bss == test_bss)
1523 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1524 struct wpa_ssid *test_ssid)
1526 struct wpa_ssid *ssid;
1528 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1529 if (ssid == test_ssid)
1537 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1538 struct wpa_ssid *test_ssid)
1540 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1543 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1547 void wpas_connect_work_free(struct wpa_connect_work *cwork)
1555 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1557 struct wpa_connect_work *cwork;
1558 struct wpa_radio_work *work = wpa_s->connect_work;
1563 wpa_s->connect_work = NULL;
1566 wpas_connect_work_free(cwork);
1567 radio_work_done(work);
1571 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1573 struct os_reltime now;
1576 os_get_reltime(&now);
1577 if (wpa_s->last_mac_addr_style == style &&
1578 wpa_s->last_mac_addr_change.sec != 0 &&
1579 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1580 wpa_s->conf->rand_addr_lifetime)) {
1581 wpa_msg(wpa_s, MSG_DEBUG,
1582 "Previously selected random MAC address has not yet expired");
1588 if (random_mac_addr(addr) < 0)
1592 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1593 if (random_mac_addr_keep_oui(addr) < 0)
1600 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1601 wpa_msg(wpa_s, MSG_INFO,
1602 "Failed to set random MAC address");
1606 os_get_reltime(&wpa_s->last_mac_addr_change);
1607 wpa_s->mac_addr_changed = 1;
1608 wpa_s->last_mac_addr_style = style;
1610 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1611 wpa_msg(wpa_s, MSG_INFO,
1612 "Could not update MAC address information");
1616 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1623 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1625 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1626 !wpa_s->conf->preassoc_mac_addr)
1629 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1633 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit);
1636 * wpa_supplicant_associate - Request association
1637 * @wpa_s: Pointer to wpa_supplicant data
1638 * @bss: Scan results for the selected BSS, or %NULL if not available
1639 * @ssid: Configuration data for the selected network
1641 * This function is used to request %wpa_supplicant to associate with a BSS.
1643 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1644 struct wpa_bss *bss, struct wpa_ssid *ssid)
1646 struct wpa_connect_work *cwork;
1649 wpa_s->own_disconnect_req = 0;
1652 * If we are starting a new connection, any previously pending EAPOL
1653 * RX cannot be valid anymore.
1655 wpabuf_free(wpa_s->pending_eapol_rx);
1656 wpa_s->pending_eapol_rx = NULL;
1658 if (ssid->mac_addr == -1)
1659 rand_style = wpa_s->conf->mac_addr;
1661 rand_style = ssid->mac_addr;
1663 wmm_ac_clear_saved_tspecs(wpa_s);
1664 wpa_s->reassoc_same_bss = 0;
1665 wpa_s->reassoc_same_ess = 0;
1667 if (wpa_s->last_ssid == ssid) {
1668 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1669 wpa_s->reassoc_same_ess = 1;
1670 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1671 wmm_ac_save_tspecs(wpa_s);
1672 wpa_s->reassoc_same_bss = 1;
1674 } else if (rand_style > 0) {
1675 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1677 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1678 } else if (wpa_s->mac_addr_changed) {
1679 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1680 wpa_msg(wpa_s, MSG_INFO,
1681 "Could not restore permanent MAC address");
1684 wpa_s->mac_addr_changed = 0;
1685 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1686 wpa_msg(wpa_s, MSG_INFO,
1687 "Could not update MAC address information");
1690 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1692 wpa_s->last_ssid = ssid;
1694 #ifdef CONFIG_IBSS_RSN
1695 ibss_rsn_deinit(wpa_s->ibss_rsn);
1696 wpa_s->ibss_rsn = NULL;
1697 #endif /* CONFIG_IBSS_RSN */
1699 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1700 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1702 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1703 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1707 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1708 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1709 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1710 wpas_p2p_ap_setup_failed(wpa_s);
1713 wpa_s->current_bss = bss;
1714 #else /* CONFIG_AP */
1715 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1717 #endif /* CONFIG_AP */
1721 if (ssid->mode == WPAS_MODE_MESH) {
1723 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
1724 wpa_msg(wpa_s, MSG_INFO,
1725 "Driver does not support mesh mode");
1729 ssid->frequency = bss->freq;
1730 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
1731 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
1734 wpa_s->current_bss = bss;
1735 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_STARTED "ssid=\"%s\" id=%d",
1736 wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
1738 #else /* CONFIG_MESH */
1739 wpa_msg(wpa_s, MSG_ERROR,
1740 "mesh mode support not included in the build");
1741 #endif /* CONFIG_MESH */
1747 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1749 #endif /* CONFIG_TDLS */
1751 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1752 ssid->mode == IEEE80211_MODE_INFRA) {
1753 sme_authenticate(wpa_s, bss, ssid);
1757 if (wpa_s->connect_work) {
1758 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1762 if (radio_work_pending(wpa_s, "connect")) {
1763 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1767 wpas_abort_ongoing_scan(wpa_s);
1769 cwork = os_zalloc(sizeof(*cwork));
1776 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1777 wpas_start_assoc_cb, cwork) < 0) {
1783 static int bss_is_ibss(struct wpa_bss *bss)
1785 return (bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) ==
1790 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
1791 const struct wpa_ssid *ssid)
1793 enum hostapd_hw_mode hw_mode;
1794 struct hostapd_hw_modes *mode = NULL;
1798 #ifdef CONFIG_HT_OVERRIDES
1799 if (ssid->disable_ht)
1801 #endif /* CONFIG_HT_OVERRIDES */
1803 hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel);
1804 if (hw_mode == NUM_HOSTAPD_MODES)
1806 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1807 if (wpa_s->hw.modes[i].mode == hw_mode) {
1808 mode = &wpa_s->hw.modes[i];
1816 return mode->vht_capab != 0;
1820 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
1821 const struct wpa_ssid *ssid,
1822 struct hostapd_freq_params *freq)
1824 enum hostapd_hw_mode hw_mode;
1825 struct hostapd_hw_modes *mode = NULL;
1826 int ht40plus[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1828 int vht80[] = { 36, 52, 100, 116, 132, 149 };
1829 struct hostapd_channel_data *pri_chan = NULL, *sec_chan = NULL;
1831 int i, chan_idx, ht40 = -1, res, obss_scan = 1;
1833 struct hostapd_freq_params vht_freq;
1834 int chwidth, seg0, seg1;
1837 freq->freq = ssid->frequency;
1839 for (j = 0; j < wpa_s->last_scan_res_used; j++) {
1840 struct wpa_bss *bss = wpa_s->last_scan_res[j];
1842 if (ssid->mode != WPAS_MODE_IBSS)
1845 /* Don't adjust control freq in case of fixed_freq */
1846 if (ssid->fixed_freq)
1849 if (!bss_is_ibss(bss))
1852 if (ssid->ssid_len == bss->ssid_len &&
1853 os_memcmp(ssid->ssid, bss->ssid, bss->ssid_len) == 0) {
1854 wpa_printf(MSG_DEBUG,
1855 "IBSS already found in scan results, adjust control freq: %d",
1857 freq->freq = bss->freq;
1863 /* For IBSS check HT_IBSS flag */
1864 if (ssid->mode == WPAS_MODE_IBSS &&
1865 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
1868 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
1869 wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
1870 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
1871 wpa_printf(MSG_DEBUG,
1872 "IBSS: WEP/TKIP detected, do not try to enable HT");
1876 hw_mode = ieee80211_freq_to_chan(freq->freq, &channel);
1877 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1878 if (wpa_s->hw.modes[i].mode == hw_mode) {
1879 mode = &wpa_s->hw.modes[i];
1887 #ifdef CONFIG_HT_OVERRIDES
1888 if (ssid->disable_ht) {
1889 freq->ht_enabled = 0;
1892 #endif /* CONFIG_HT_OVERRIDES */
1894 freq->ht_enabled = ht_supported(mode);
1895 if (!freq->ht_enabled)
1898 /* Setup higher BW only for 5 GHz */
1899 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
1902 for (chan_idx = 0; chan_idx < mode->num_channels; chan_idx++) {
1903 pri_chan = &mode->channels[chan_idx];
1904 if (pri_chan->chan == channel)
1911 /* Check primary channel flags */
1912 if (pri_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1915 #ifdef CONFIG_HT_OVERRIDES
1916 if (ssid->disable_ht40)
1918 #endif /* CONFIG_HT_OVERRIDES */
1920 /* Check/setup HT40+/HT40- */
1921 for (j = 0; j < ARRAY_SIZE(ht40plus); j++) {
1922 if (ht40plus[j] == channel) {
1928 /* Find secondary channel */
1929 for (i = 0; i < mode->num_channels; i++) {
1930 sec_chan = &mode->channels[i];
1931 if (sec_chan->chan == channel + ht40 * 4)
1938 /* Check secondary channel flags */
1939 if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1942 freq->channel = pri_chan->chan;
1945 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS))
1948 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS))
1951 freq->sec_channel_offset = ht40;
1954 struct wpa_scan_results *scan_res;
1956 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
1957 if (scan_res == NULL) {
1959 freq->sec_channel_offset = 0;
1963 res = check_40mhz_5g(mode, scan_res, pri_chan->chan,
1968 freq->sec_channel_offset = 0;
1971 /* Configuration allowed */
1974 /* Switch pri/sec channels */
1975 freq->freq = hw_get_freq(mode, sec_chan->chan);
1976 freq->sec_channel_offset = -freq->sec_channel_offset;
1977 freq->channel = sec_chan->chan;
1980 freq->sec_channel_offset = 0;
1984 wpa_scan_results_free(scan_res);
1987 wpa_printf(MSG_DEBUG,
1988 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
1989 freq->channel, freq->sec_channel_offset);
1991 if (!drv_supports_vht(wpa_s, ssid))
1994 /* For IBSS check VHT_IBSS flag */
1995 if (ssid->mode == WPAS_MODE_IBSS &&
1996 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
2001 vht_freq.vht_enabled = vht_supported(mode);
2002 if (!vht_freq.vht_enabled)
2005 /* setup center_freq1, bandwidth */
2006 for (j = 0; j < ARRAY_SIZE(vht80); j++) {
2007 if (freq->channel >= vht80[j] &&
2008 freq->channel < vht80[j] + 16)
2012 if (j == ARRAY_SIZE(vht80))
2015 for (i = vht80[j]; i < vht80[j] + 16; i += 4) {
2016 struct hostapd_channel_data *chan;
2018 chan = hw_get_channel_chan(mode, i, NULL);
2022 /* Back to HT configuration if channel not usable */
2023 if (chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
2027 chwidth = VHT_CHANWIDTH_80MHZ;
2028 seg0 = vht80[j] + 6;
2031 if (ssid->max_oper_chwidth == VHT_CHANWIDTH_80P80MHZ) {
2032 /* setup center_freq2, bandwidth */
2033 for (k = 0; k < ARRAY_SIZE(vht80); k++) {
2034 /* Only accept 80 MHz segments separated by a gap */
2035 if (j == k || abs(vht80[j] - vht80[k]) == 16)
2037 for (i = vht80[k]; i < vht80[k] + 16; i += 4) {
2038 struct hostapd_channel_data *chan;
2040 chan = hw_get_channel_chan(mode, i, NULL);
2044 if (chan->flag & (HOSTAPD_CHAN_DISABLED |
2045 HOSTAPD_CHAN_NO_IR |
2046 HOSTAPD_CHAN_RADAR))
2049 /* Found a suitable second segment for 80+80 */
2050 chwidth = VHT_CHANWIDTH_80P80MHZ;
2052 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
2053 seg1 = vht80[k] + 6;
2056 if (chwidth == VHT_CHANWIDTH_80P80MHZ)
2059 } else if (ssid->max_oper_chwidth == VHT_CHANWIDTH_160MHZ) {
2060 if (freq->freq == 5180) {
2061 chwidth = VHT_CHANWIDTH_160MHZ;
2062 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2064 } else if (freq->freq == 5520) {
2065 chwidth = VHT_CHANWIDTH_160MHZ;
2066 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2071 if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq,
2072 freq->channel, freq->ht_enabled,
2073 vht_freq.vht_enabled,
2074 freq->sec_channel_offset,
2075 chwidth, seg0, seg1, vht_caps) != 0)
2080 wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
2081 freq->center_freq1, freq->center_freq2, freq->bandwidth);
2085 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
2087 struct wpa_connect_work *cwork = work->ctx;
2088 struct wpa_bss *bss = cwork->bss;
2089 struct wpa_ssid *ssid = cwork->ssid;
2090 struct wpa_supplicant *wpa_s = work->wpa_s;
2093 int use_crypt, ret, i, bssid_changed;
2094 int algs = WPA_AUTH_ALG_OPEN;
2095 unsigned int cipher_pairwise, cipher_group;
2096 struct wpa_driver_associate_params params;
2097 int wep_keys_set = 0;
2098 int assoc_failed = 0;
2099 struct wpa_ssid *old_ssid;
2100 u8 prev_bssid[ETH_ALEN];
2101 #ifdef CONFIG_HT_OVERRIDES
2102 struct ieee80211_ht_capabilities htcaps;
2103 struct ieee80211_ht_capabilities htcaps_mask;
2104 #endif /* CONFIG_HT_OVERRIDES */
2105 #ifdef CONFIG_VHT_OVERRIDES
2106 struct ieee80211_vht_capabilities vhtcaps;
2107 struct ieee80211_vht_capabilities vhtcaps_mask;
2108 #endif /* CONFIG_VHT_OVERRIDES */
2110 const u8 *mbo = NULL;
2111 #endif /* CONFIG_MBO */
2114 if (work->started) {
2115 wpa_s->connect_work = NULL;
2117 /* cancel possible auth. timeout */
2118 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
2121 wpas_connect_work_free(cwork);
2125 wpa_s->connect_work = work;
2127 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
2128 wpas_network_disabled(wpa_s, ssid)) {
2129 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2130 wpas_connect_work_done(wpa_s);
2134 os_memcpy(prev_bssid, wpa_s->bssid, ETH_ALEN);
2135 os_memset(¶ms, 0, sizeof(params));
2136 wpa_s->reassociate = 0;
2137 wpa_s->eap_expected_failure = 0;
2139 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
2140 #ifdef CONFIG_IEEE80211R
2141 const u8 *ie, *md = NULL;
2142 #endif /* CONFIG_IEEE80211R */
2143 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
2144 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
2145 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
2146 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
2147 os_memset(wpa_s->bssid, 0, ETH_ALEN);
2148 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2150 wpas_notify_bssid_changed(wpa_s);
2151 #ifdef CONFIG_IEEE80211R
2152 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
2153 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
2155 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
2157 /* Prepare for the next transition */
2158 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
2160 #endif /* CONFIG_IEEE80211R */
2162 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
2163 wpa_s->conf->ap_scan == 2 &&
2164 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
2165 /* Use ap_scan==1 style network selection to find the network
2167 wpas_connect_work_done(wpa_s);
2168 wpa_s->scan_req = MANUAL_SCAN_REQ;
2169 wpa_s->reassociate = 1;
2170 wpa_supplicant_req_scan(wpa_s, 0, 0);
2172 #endif /* CONFIG_WPS */
2174 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
2175 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2176 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2179 wpa_supplicant_cancel_sched_scan(wpa_s);
2181 wpa_supplicant_cancel_scan(wpa_s);
2183 /* Starting new association, so clear the possibly used WPA IE from the
2184 * previous association. */
2185 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
2187 #ifdef IEEE8021X_EAPOL
2188 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2190 if (ssid->non_leap == 0)
2191 algs = WPA_AUTH_ALG_LEAP;
2193 algs |= WPA_AUTH_ALG_LEAP;
2196 #endif /* IEEE8021X_EAPOL */
2197 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2198 if (ssid->auth_alg) {
2199 algs = ssid->auth_alg;
2200 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
2204 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
2205 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
2206 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
2207 int try_opportunistic;
2208 try_opportunistic = (ssid->proactive_key_caching < 0 ?
2210 ssid->proactive_key_caching) &&
2211 (ssid->proto & WPA_PROTO_RSN);
2212 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2213 ssid, try_opportunistic) == 0)
2214 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2215 wpa_ie_len = sizeof(wpa_ie);
2216 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2217 wpa_ie, &wpa_ie_len)) {
2218 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2219 "key management and encryption suites");
2220 wpas_connect_work_done(wpa_s);
2223 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
2224 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
2226 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2227 * use non-WPA since the scan results did not indicate that the
2228 * AP is using WPA or WPA2.
2230 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2232 wpa_s->wpa_proto = 0;
2233 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
2234 wpa_ie_len = sizeof(wpa_ie);
2235 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2236 wpa_ie, &wpa_ie_len)) {
2237 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2238 "key management and encryption suites (no "
2240 wpas_connect_work_done(wpa_s);
2244 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
2245 struct wpabuf *wps_ie;
2246 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
2247 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
2248 wpa_ie_len = wpabuf_len(wps_ie);
2249 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
2252 wpabuf_free(wps_ie);
2253 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2254 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
2255 params.wps = WPS_MODE_PRIVACY;
2257 params.wps = WPS_MODE_OPEN;
2258 wpa_s->wpa_proto = 0;
2259 #endif /* CONFIG_WPS */
2261 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2263 wpa_s->wpa_proto = 0;
2267 if (wpa_s->global->p2p) {
2271 pos = wpa_ie + wpa_ie_len;
2272 len = sizeof(wpa_ie) - wpa_ie_len;
2273 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2279 wpa_s->cross_connect_disallowed = 0;
2282 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
2284 wpa_s->cross_connect_disallowed =
2285 p2p_get_cross_connect_disallowed(p2p);
2287 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2289 wpa_s->cross_connect_disallowed ?
2290 "disallows" : "allows");
2294 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2295 #endif /* CONFIG_P2P */
2299 mbo = wpa_bss_get_vendor_ie(bss, MBO_IE_VENDOR_TYPE);
2303 len = wpas_mbo_supp_op_class_ie(wpa_s, bss->freq,
2304 wpa_ie + wpa_ie_len,
2311 #endif /* CONFIG_MBO */
2314 * Workaround: Add Extended Capabilities element only if the AP
2315 * included this element in Beacon/Probe Response frames. Some older
2316 * APs seem to have interoperability issues if this element is
2317 * included, so while the standard may require us to include the
2318 * element in all cases, it is justifiable to skip it to avoid
2319 * interoperability issues.
2321 if (ssid->p2p_group)
2322 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
2324 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
2326 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
2329 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2331 if (ext_capab_len > 0) {
2333 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
2335 os_memmove(pos + ext_capab_len, pos,
2336 wpa_ie_len - (pos - wpa_ie));
2337 wpa_ie_len += ext_capab_len;
2338 os_memcpy(pos, ext_capab, ext_capab_len);
2343 if (is_hs20_network(wpa_s, ssid, bss)) {
2344 struct wpabuf *hs20;
2346 hs20 = wpabuf_alloc(20);
2348 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2351 wpas_hs20_add_indication(hs20, pps_mo_id);
2352 len = sizeof(wpa_ie) - wpa_ie_len;
2353 if (wpabuf_len(hs20) <= len) {
2354 os_memcpy(wpa_ie + wpa_ie_len,
2355 wpabuf_head(hs20), wpabuf_len(hs20));
2356 wpa_ie_len += wpabuf_len(hs20);
2360 hs20_configure_frame_filters(wpa_s);
2363 #endif /* CONFIG_HS20 */
2365 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2366 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2369 len = sizeof(wpa_ie) - wpa_ie_len;
2370 if (wpabuf_len(buf) <= len) {
2371 os_memcpy(wpa_ie + wpa_ie_len,
2372 wpabuf_head(buf), wpabuf_len(buf));
2373 wpa_ie_len += wpabuf_len(buf);
2378 if (wpa_s->fst_ies) {
2379 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2381 if (wpa_ie_len + fst_ies_len <= sizeof(wpa_ie)) {
2382 os_memcpy(wpa_ie + wpa_ie_len,
2383 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2384 wpa_ie_len += fst_ies_len;
2387 #endif /* CONFIG_FST */
2393 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
2394 sizeof(wpa_ie) - wpa_ie_len);
2398 #endif /* CONFIG_MBO */
2400 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2402 cipher_pairwise = wpa_s->pairwise_cipher;
2403 cipher_group = wpa_s->group_cipher;
2404 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2405 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2406 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2408 if (wpa_set_wep_keys(wpa_s, ssid)) {
2413 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2416 #ifdef IEEE8021X_EAPOL
2417 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2418 if ((ssid->eapol_flags &
2419 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
2420 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
2424 /* Assume that dynamic WEP-104 keys will be used and
2425 * set cipher suites in order for drivers to expect
2427 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
2430 #endif /* IEEE8021X_EAPOL */
2432 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2433 /* Set the key before (and later after) association */
2434 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2437 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2439 params.ssid = bss->ssid;
2440 params.ssid_len = bss->ssid_len;
2441 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2442 wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
2443 MACSTR " freq=%u MHz based on scan results "
2445 MAC2STR(bss->bssid), bss->freq,
2447 params.bssid = bss->bssid;
2448 params.freq.freq = bss->freq;
2450 params.bssid_hint = bss->bssid;
2451 params.freq_hint = bss->freq;
2452 params.pbss = bss_is_pbss(bss);
2454 params.ssid = ssid->ssid;
2455 params.ssid_len = ssid->ssid_len;
2456 params.pbss = (ssid->pbss != 2) ? ssid->pbss : 0;
2459 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
2460 wpa_s->conf->ap_scan == 2) {
2461 params.bssid = ssid->bssid;
2462 params.fixed_bssid = 1;
2465 /* Initial frequency for IBSS/mesh */
2466 if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) &&
2467 ssid->frequency > 0 && params.freq.freq == 0)
2468 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
2470 if (ssid->mode == WPAS_MODE_IBSS) {
2471 params.fixed_freq = ssid->fixed_freq;
2472 if (ssid->beacon_int)
2473 params.beacon_int = ssid->beacon_int;
2475 params.beacon_int = wpa_s->conf->beacon_int;
2478 params.wpa_ie = wpa_ie;
2479 params.wpa_ie_len = wpa_ie_len;
2480 params.pairwise_suite = cipher_pairwise;
2481 params.group_suite = cipher_group;
2482 params.key_mgmt_suite = wpa_s->key_mgmt;
2483 params.wpa_proto = wpa_s->wpa_proto;
2484 params.auth_alg = algs;
2485 params.mode = ssid->mode;
2486 params.bg_scan_period = ssid->bg_scan_period;
2487 for (i = 0; i < NUM_WEP_KEYS; i++) {
2488 if (ssid->wep_key_len[i])
2489 params.wep_key[i] = ssid->wep_key[i];
2490 params.wep_key_len[i] = ssid->wep_key_len[i];
2492 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
2494 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2495 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2496 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
2497 params.passphrase = ssid->passphrase;
2499 params.psk = ssid->psk;
2502 if (wpa_s->conf->key_mgmt_offload) {
2503 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
2504 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
2505 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
2506 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
2507 params.req_key_mgmt_offload =
2508 ssid->proactive_key_caching < 0 ?
2509 wpa_s->conf->okc : ssid->proactive_key_caching;
2511 params.req_key_mgmt_offload = 1;
2513 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2514 params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
2515 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
2517 params.psk = ssid->psk;
2520 params.drop_unencrypted = use_crypt;
2522 #ifdef CONFIG_IEEE80211W
2523 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
2524 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
2525 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2526 struct wpa_ie_data ie;
2527 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
2529 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
2530 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2531 "MFP: require MFP");
2532 params.mgmt_frame_protection =
2533 MGMT_FRAME_PROTECTION_REQUIRED;
2536 #endif /* CONFIG_IEEE80211W */
2538 params.p2p = ssid->p2p_group;
2540 if (wpa_s->p2pdev->set_sta_uapsd)
2541 params.uapsd = wpa_s->p2pdev->sta_uapsd;
2545 #ifdef CONFIG_HT_OVERRIDES
2546 os_memset(&htcaps, 0, sizeof(htcaps));
2547 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
2548 params.htcaps = (u8 *) &htcaps;
2549 params.htcaps_mask = (u8 *) &htcaps_mask;
2550 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
2551 #endif /* CONFIG_HT_OVERRIDES */
2552 #ifdef CONFIG_VHT_OVERRIDES
2553 os_memset(&vhtcaps, 0, sizeof(vhtcaps));
2554 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
2555 params.vhtcaps = &vhtcaps;
2556 params.vhtcaps_mask = &vhtcaps_mask;
2557 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms);
2558 #endif /* CONFIG_VHT_OVERRIDES */
2562 * If multi-channel concurrency is not supported, check for any
2563 * frequency conflict. In case of any frequency conflict, remove the
2564 * least prioritized connection.
2566 if (wpa_s->num_multichan_concurrent < 2) {
2568 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2569 if (num > 0 && freq > 0 && freq != params.freq.freq) {
2570 wpa_printf(MSG_DEBUG,
2571 "Assoc conflicting freq found (%d != %d)",
2572 freq, params.freq.freq);
2573 if (wpas_p2p_handle_frequency_conflicts(
2574 wpa_s, params.freq.freq, ssid) < 0) {
2575 wpas_connect_work_done(wpa_s);
2580 #endif /* CONFIG_P2P */
2582 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
2583 wpa_s->current_ssid)
2584 params.prev_bssid = prev_bssid;
2586 ret = wpa_drv_associate(wpa_s, ¶ms);
2588 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2590 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2592 * The driver is known to mean what is saying, so we
2593 * can stop right here; the association will not
2596 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2597 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2598 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2601 /* try to continue anyway; new association will be tried again
2606 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2607 /* Set the key after the association just in case association
2608 * cleared the previously configured key. */
2609 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2610 /* No need to timeout authentication since there is no key
2612 wpa_supplicant_cancel_auth_timeout(wpa_s);
2613 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2614 #ifdef CONFIG_IBSS_RSN
2615 } else if (ssid->mode == WPAS_MODE_IBSS &&
2616 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2617 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2619 * RSN IBSS authentication is per-STA and we can disable the
2620 * per-BSSID authentication.
2622 wpa_supplicant_cancel_auth_timeout(wpa_s);
2623 #endif /* CONFIG_IBSS_RSN */
2625 /* Timeout for IEEE 802.11 authentication and association */
2629 /* give IBSS a bit more time */
2630 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2631 } else if (wpa_s->conf->ap_scan == 1) {
2632 /* give IBSS a bit more time */
2633 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2635 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2639 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2640 /* Set static WEP keys again */
2641 wpa_set_wep_keys(wpa_s, ssid);
2644 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2646 * Do not allow EAP session resumption between different
2647 * network configurations.
2649 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2651 old_ssid = wpa_s->current_ssid;
2652 wpa_s->current_ssid = ssid;
2654 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2655 wpa_s->current_bss = bss;
2657 hs20_configure_frame_filters(wpa_s);
2658 #endif /* CONFIG_HS20 */
2661 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2662 wpa_supplicant_initiate_eapol(wpa_s);
2663 if (old_ssid != wpa_s->current_ssid)
2664 wpas_notify_network_changed(wpa_s);
2668 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2671 struct wpa_ssid *old_ssid;
2673 wpas_connect_work_done(wpa_s);
2674 wpa_clear_keys(wpa_s, addr);
2675 old_ssid = wpa_s->current_ssid;
2676 wpa_supplicant_mark_disassoc(wpa_s);
2677 wpa_sm_set_config(wpa_s->wpa, NULL);
2678 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2679 if (old_ssid != wpa_s->current_ssid)
2680 wpas_notify_network_changed(wpa_s);
2681 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2686 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2687 * @wpa_s: Pointer to wpa_supplicant data
2688 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2690 * This function is used to request %wpa_supplicant to deauthenticate from the
2693 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2697 union wpa_event_data event;
2700 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2701 " pending_bssid=" MACSTR " reason=%d state=%s",
2702 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2703 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2705 if (!is_zero_ether_addr(wpa_s->bssid))
2706 addr = wpa_s->bssid;
2707 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2708 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2709 wpa_s->wpa_state == WPA_ASSOCIATING))
2710 addr = wpa_s->pending_bssid;
2711 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2713 * When using driver-based BSS selection, we may not know the
2714 * BSSID with which we are currently trying to associate. We
2715 * need to notify the driver of this disconnection even in such
2716 * a case, so use the all zeros address here.
2718 addr = wpa_s->bssid;
2723 wpa_tdls_teardown_peers(wpa_s->wpa);
2724 #endif /* CONFIG_TDLS */
2728 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
2730 wpa_supplicant_leave_mesh(wpa_s);
2732 #endif /* CONFIG_MESH */
2735 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2736 os_memset(&event, 0, sizeof(event));
2737 event.deauth_info.reason_code = (u16) reason_code;
2738 event.deauth_info.locally_generated = 1;
2739 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2744 wpa_supplicant_clear_connection(wpa_s, addr);
2747 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2748 struct wpa_ssid *ssid)
2750 if (!ssid || !ssid->disabled || ssid->disabled == 2)
2754 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2755 wpas_notify_network_enabled_changed(wpa_s, ssid);
2758 * Try to reassociate since there is no current configuration and a new
2759 * network was made available.
2761 if (!wpa_s->current_ssid && !wpa_s->disconnected)
2762 wpa_s->reassociate = 1;
2767 * wpa_supplicant_add_network - Add a new network
2768 * @wpa_s: wpa_supplicant structure for a network interface
2769 * Returns: The new network configuration or %NULL if operation failed
2771 * This function performs the following operations:
2772 * 1. Adds a new network.
2773 * 2. Send network addition notification.
2774 * 3. Marks the network disabled.
2775 * 4. Set network default parameters.
2777 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s)
2779 struct wpa_ssid *ssid;
2781 ssid = wpa_config_add_network(wpa_s->conf);
2784 wpas_notify_network_added(wpa_s, ssid);
2786 wpa_config_set_network_defaults(ssid);
2793 * wpa_supplicant_remove_network - Remove a configured network based on id
2794 * @wpa_s: wpa_supplicant structure for a network interface
2795 * @id: Unique network id to search for
2796 * Returns: 0 on success, or -1 if the network was not found, -2 if the network
2797 * could not be removed
2799 * This function performs the following operations:
2800 * 1. Removes the network.
2801 * 2. Send network removal notification.
2802 * 3. Update internal state machines.
2803 * 4. Stop any running sched scans.
2805 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id)
2807 struct wpa_ssid *ssid;
2810 ssid = wpa_config_get_network(wpa_s->conf, id);
2813 wpas_notify_network_removed(wpa_s, ssid);
2815 if (wpa_s->last_ssid == ssid)
2816 wpa_s->last_ssid = NULL;
2818 if (ssid == wpa_s->current_ssid || !wpa_s->current_ssid) {
2820 wpa_s->sme.prev_bssid_set = 0;
2821 #endif /* CONFIG_SME */
2823 * Invalidate the EAP session cache if the current or
2824 * previously used network is removed.
2826 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2829 if (ssid == wpa_s->current_ssid) {
2830 wpa_sm_set_config(wpa_s->wpa, NULL);
2831 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2833 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2834 wpa_s->own_disconnect_req = 1;
2835 wpa_supplicant_deauthenticate(wpa_s,
2836 WLAN_REASON_DEAUTH_LEAVING);
2839 was_disabled = ssid->disabled;
2841 if (wpa_config_remove_network(wpa_s->conf, id) < 0)
2844 if (!was_disabled && wpa_s->sched_scanning) {
2845 wpa_printf(MSG_DEBUG,
2846 "Stop ongoing sched_scan to remove network from filters");
2847 wpa_supplicant_cancel_sched_scan(wpa_s);
2848 wpa_supplicant_req_scan(wpa_s, 0, 0);
2856 * wpa_supplicant_enable_network - Mark a configured network as enabled
2857 * @wpa_s: wpa_supplicant structure for a network interface
2858 * @ssid: wpa_ssid structure for a configured network or %NULL
2860 * Enables the specified network or all networks if no network specified.
2862 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2863 struct wpa_ssid *ssid)
2866 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2867 wpa_supplicant_enable_one_network(wpa_s, ssid);
2869 wpa_supplicant_enable_one_network(wpa_s, ssid);
2871 if (wpa_s->reassociate && !wpa_s->disconnected &&
2872 (!wpa_s->current_ssid ||
2873 wpa_s->wpa_state == WPA_DISCONNECTED ||
2874 wpa_s->wpa_state == WPA_SCANNING)) {
2875 if (wpa_s->sched_scanning) {
2876 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2877 "new network to scan filters");
2878 wpa_supplicant_cancel_sched_scan(wpa_s);
2881 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
2882 wpa_s->scan_req = NORMAL_SCAN_REQ;
2883 wpa_supplicant_req_scan(wpa_s, 0, 0);
2890 * wpa_supplicant_disable_network - Mark a configured network as disabled
2891 * @wpa_s: wpa_supplicant structure for a network interface
2892 * @ssid: wpa_ssid structure for a configured network or %NULL
2894 * Disables the specified network or all networks if no network specified.
2896 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2897 struct wpa_ssid *ssid)
2899 struct wpa_ssid *other_ssid;
2903 if (wpa_s->sched_scanning)
2904 wpa_supplicant_cancel_sched_scan(wpa_s);
2906 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2907 other_ssid = other_ssid->next) {
2908 was_disabled = other_ssid->disabled;
2909 if (was_disabled == 2)
2910 continue; /* do not change persistent P2P group
2913 other_ssid->disabled = 1;
2915 if (was_disabled != other_ssid->disabled)
2916 wpas_notify_network_enabled_changed(
2919 if (wpa_s->current_ssid)
2920 wpa_supplicant_deauthenticate(
2921 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2922 } else if (ssid->disabled != 2) {
2923 if (ssid == wpa_s->current_ssid)
2924 wpa_supplicant_deauthenticate(
2925 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2927 was_disabled = ssid->disabled;
2931 if (was_disabled != ssid->disabled) {
2932 wpas_notify_network_enabled_changed(wpa_s, ssid);
2933 if (wpa_s->sched_scanning) {
2934 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2935 "to remove network from filters");
2936 wpa_supplicant_cancel_sched_scan(wpa_s);
2937 wpa_supplicant_req_scan(wpa_s, 0, 0);
2945 * wpa_supplicant_select_network - Attempt association with a network
2946 * @wpa_s: wpa_supplicant structure for a network interface
2947 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2949 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2950 struct wpa_ssid *ssid)
2953 struct wpa_ssid *other_ssid;
2954 int disconnected = 0;
2956 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2957 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2958 wpa_s->own_disconnect_req = 1;
2959 wpa_supplicant_deauthenticate(
2960 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2965 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2968 * Mark all other networks disabled or mark all networks enabled if no
2969 * network specified.
2971 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2972 other_ssid = other_ssid->next) {
2973 int was_disabled = other_ssid->disabled;
2974 if (was_disabled == 2)
2975 continue; /* do not change persistent P2P group data */
2977 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
2978 if (was_disabled && !other_ssid->disabled)
2979 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2981 if (was_disabled != other_ssid->disabled)
2982 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2985 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
2986 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2987 /* We are already associated with the selected network */
2988 wpa_printf(MSG_DEBUG, "Already associated with the "
2989 "selected network - do nothing");
2994 wpa_s->current_ssid = ssid;
2995 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2996 wpa_s->connect_without_scan =
2997 (ssid->mode == WPAS_MODE_MESH) ? ssid : NULL;
3000 * Don't optimize next scan freqs since a new ESS has been
3003 os_free(wpa_s->next_scan_freqs);
3004 wpa_s->next_scan_freqs = NULL;
3006 wpa_s->connect_without_scan = NULL;
3009 wpa_s->disconnected = 0;
3010 wpa_s->reassociate = 1;
3012 if (wpa_s->connect_without_scan ||
3013 wpa_supplicant_fast_associate(wpa_s) != 1) {
3014 wpa_s->scan_req = NORMAL_SCAN_REQ;
3015 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
3019 wpas_notify_network_selected(wpa_s, ssid);
3024 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
3025 * @wpa_s: wpa_supplicant structure for a network interface
3026 * @pkcs11_engine_path: PKCS #11 engine path or NULL
3027 * @pkcs11_module_path: PKCS #11 module path or NULL
3028 * Returns: 0 on success; -1 on failure
3030 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
3031 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
3032 * module path fails the paths will be reset to the default value (NULL).
3034 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
3035 const char *pkcs11_engine_path,
3036 const char *pkcs11_module_path)
3038 char *pkcs11_engine_path_copy = NULL;
3039 char *pkcs11_module_path_copy = NULL;
3041 if (pkcs11_engine_path != NULL) {
3042 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
3043 if (pkcs11_engine_path_copy == NULL)
3046 if (pkcs11_module_path != NULL) {
3047 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
3048 if (pkcs11_module_path_copy == NULL) {
3049 os_free(pkcs11_engine_path_copy);
3054 os_free(wpa_s->conf->pkcs11_engine_path);
3055 os_free(wpa_s->conf->pkcs11_module_path);
3056 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
3057 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
3059 wpa_sm_set_eapol(wpa_s->wpa, NULL);
3060 eapol_sm_deinit(wpa_s->eapol);
3061 wpa_s->eapol = NULL;
3062 if (wpa_supplicant_init_eapol(wpa_s)) {
3063 /* Error -> Reset paths to the default value (NULL) once. */
3064 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
3065 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
3070 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3077 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
3078 * @wpa_s: wpa_supplicant structure for a network interface
3079 * @ap_scan: AP scan mode
3080 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
3083 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
3088 if (ap_scan < 0 || ap_scan > 2)
3091 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3092 wpa_printf(MSG_INFO,
3093 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3097 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
3098 wpa_s->wpa_state >= WPA_ASSOCIATING &&
3099 wpa_s->wpa_state < WPA_COMPLETED) {
3100 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
3101 "associating", wpa_s->conf->ap_scan, ap_scan);
3104 #endif /* ANDROID */
3106 old_ap_scan = wpa_s->conf->ap_scan;
3107 wpa_s->conf->ap_scan = ap_scan;
3109 if (old_ap_scan != wpa_s->conf->ap_scan)
3110 wpas_notify_ap_scan_changed(wpa_s);
3117 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
3118 * @wpa_s: wpa_supplicant structure for a network interface
3119 * @expire_age: Expiration age in seconds
3120 * Returns: 0 if succeed or -1 if expire_age has an invalid value
3123 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
3124 unsigned int bss_expire_age)
3126 if (bss_expire_age < 10) {
3127 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
3131 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
3133 wpa_s->conf->bss_expiration_age = bss_expire_age;
3140 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
3141 * @wpa_s: wpa_supplicant structure for a network interface
3142 * @expire_count: number of scans after which an unseen BSS is reclaimed
3143 * Returns: 0 if succeed or -1 if expire_count has an invalid value
3146 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
3147 unsigned int bss_expire_count)
3149 if (bss_expire_count < 1) {
3150 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
3154 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
3156 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
3163 * wpa_supplicant_set_scan_interval - Set scan interval
3164 * @wpa_s: wpa_supplicant structure for a network interface
3165 * @scan_interval: scan interval in seconds
3166 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
3169 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
3172 if (scan_interval < 0) {
3173 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
3177 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3179 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3186 * wpa_supplicant_set_debug_params - Set global debug params
3187 * @global: wpa_global structure
3188 * @debug_level: debug level
3189 * @debug_timestamp: determines if show timestamp in debug data
3190 * @debug_show_keys: determines if show keys in debug data
3191 * Returns: 0 if succeed or -1 if debug_level has wrong value
3193 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
3194 int debug_timestamp, int debug_show_keys)
3197 int old_level, old_timestamp, old_show_keys;
3199 /* check for allowed debuglevels */
3200 if (debug_level != MSG_EXCESSIVE &&
3201 debug_level != MSG_MSGDUMP &&
3202 debug_level != MSG_DEBUG &&
3203 debug_level != MSG_INFO &&
3204 debug_level != MSG_WARNING &&
3205 debug_level != MSG_ERROR)
3208 old_level = wpa_debug_level;
3209 old_timestamp = wpa_debug_timestamp;
3210 old_show_keys = wpa_debug_show_keys;
3212 wpa_debug_level = debug_level;
3213 wpa_debug_timestamp = debug_timestamp ? 1 : 0;
3214 wpa_debug_show_keys = debug_show_keys ? 1 : 0;
3216 if (wpa_debug_level != old_level)
3217 wpas_notify_debug_level_changed(global);
3218 if (wpa_debug_timestamp != old_timestamp)
3219 wpas_notify_debug_timestamp_changed(global);
3220 if (wpa_debug_show_keys != old_show_keys)
3221 wpas_notify_debug_show_keys_changed(global);
3228 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
3229 * @wpa_s: Pointer to wpa_supplicant data
3230 * Returns: A pointer to the current network structure or %NULL on failure
3232 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
3234 struct wpa_ssid *entry;
3235 u8 ssid[SSID_MAX_LEN];
3241 res = wpa_drv_get_ssid(wpa_s, ssid);
3243 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
3249 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
3250 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
3255 wired = wpa_s->conf->ap_scan == 0 &&
3256 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
3258 entry = wpa_s->conf->ssid;
3260 if (!wpas_network_disabled(wpa_s, entry) &&
3261 ((ssid_len == entry->ssid_len &&
3262 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
3263 (!entry->bssid_set ||
3264 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3267 if (!wpas_network_disabled(wpa_s, entry) &&
3268 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
3269 (entry->ssid == NULL || entry->ssid_len == 0) &&
3270 (!entry->bssid_set ||
3271 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3273 #endif /* CONFIG_WPS */
3275 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
3276 entry->ssid_len == 0 &&
3277 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
3280 entry = entry->next;
3287 static int select_driver(struct wpa_supplicant *wpa_s, int i)
3289 struct wpa_global *global = wpa_s->global;
3291 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
3292 global->drv_priv[i] = wpa_drivers[i]->global_init(global);
3293 if (global->drv_priv[i] == NULL) {
3294 wpa_printf(MSG_ERROR, "Failed to initialize driver "
3295 "'%s'", wpa_drivers[i]->name);
3300 wpa_s->driver = wpa_drivers[i];
3301 wpa_s->global_drv_priv = global->drv_priv[i];
3307 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
3312 const char *pos, *driver = name;
3317 if (wpa_drivers[0] == NULL) {
3318 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
3324 /* default to first driver in the list */
3325 return select_driver(wpa_s, 0);
3329 pos = os_strchr(driver, ',');
3333 len = os_strlen(driver);
3335 for (i = 0; wpa_drivers[i]; i++) {
3336 if (os_strlen(wpa_drivers[i]->name) == len &&
3337 os_strncmp(driver, wpa_drivers[i]->name, len) ==
3339 /* First driver that succeeds wins */
3340 if (select_driver(wpa_s, i) == 0)
3348 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
3354 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
3355 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3356 * with struct wpa_driver_ops::init()
3357 * @src_addr: Source address of the EAPOL frame
3358 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3359 * @len: Length of the EAPOL data
3361 * This function is called for each received EAPOL frame. Most driver
3362 * interfaces rely on more generic OS mechanism for receiving frames through
3363 * l2_packet, but if such a mechanism is not available, the driver wrapper may
3364 * take care of received EAPOL frames and deliver them to the core supplicant
3365 * code by calling this function.
3367 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
3368 const u8 *buf, size_t len)
3370 struct wpa_supplicant *wpa_s = ctx;
3372 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3373 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
3375 #ifdef CONFIG_PEERKEY
3376 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
3377 wpa_s->current_ssid->peerkey &&
3378 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
3379 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
3380 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
3383 #endif /* CONFIG_PEERKEY */
3385 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3386 (wpa_s->last_eapol_matches_bssid &&
3389 #endif /* CONFIG_AP */
3390 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3392 * There is possible race condition between receiving the
3393 * association event and the EAPOL frame since they are coming
3394 * through different paths from the driver. In order to avoid
3395 * issues in trying to process the EAPOL frame before receiving
3396 * association information, lets queue it for processing until
3397 * the association event is received. This may also be needed in
3398 * driver-based roaming case, so also use src_addr != BSSID as a
3399 * trigger if we have previously confirmed that the
3400 * Authenticator uses BSSID as the src_addr (which is not the
3401 * case with wired IEEE 802.1X).
3403 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3404 "of received EAPOL frame (state=%s bssid=" MACSTR ")",
3405 wpa_supplicant_state_txt(wpa_s->wpa_state),
3406 MAC2STR(wpa_s->bssid));
3407 wpabuf_free(wpa_s->pending_eapol_rx);
3408 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3409 if (wpa_s->pending_eapol_rx) {
3410 os_get_reltime(&wpa_s->pending_eapol_rx_time);
3411 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3417 wpa_s->last_eapol_matches_bssid =
3418 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3421 if (wpa_s->ap_iface) {
3422 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3425 #endif /* CONFIG_AP */
3427 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3428 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3429 "no key management is configured");
3433 if (wpa_s->eapol_received == 0 &&
3434 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3435 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3436 wpa_s->wpa_state != WPA_COMPLETED) &&
3437 (wpa_s->current_ssid == NULL ||
3438 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3439 /* Timeout for completing IEEE 802.1X and WPA authentication */
3442 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3443 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3444 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3445 /* Use longer timeout for IEEE 802.1X/EAP */
3450 if (wpa_s->current_ssid && wpa_s->current_bss &&
3451 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3452 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3454 * Use shorter timeout if going through WPS AP iteration
3455 * for PIN config method with an AP that does not
3456 * advertise Selected Registrar.
3458 struct wpabuf *wps_ie;
3460 wps_ie = wpa_bss_get_vendor_ie_multi(
3461 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3463 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3465 wpabuf_free(wps_ie);
3467 #endif /* CONFIG_WPS */
3469 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3471 wpa_s->eapol_received++;
3473 if (wpa_s->countermeasures) {
3474 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3479 #ifdef CONFIG_IBSS_RSN
3480 if (wpa_s->current_ssid &&
3481 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3482 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3485 #endif /* CONFIG_IBSS_RSN */
3487 /* Source address of the incoming EAPOL frame could be compared to the
3488 * current BSSID. However, it is possible that a centralized
3489 * Authenticator could be using another MAC address than the BSSID of
3490 * an AP, so just allow any address to be used for now. The replies are
3491 * still sent to the current BSSID (if available), though. */
3493 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3494 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3495 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3497 wpa_drv_poll(wpa_s);
3498 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3499 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3500 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3502 * Set portValid = TRUE here since we are going to skip 4-way
3503 * handshake processing which would normally set portValid. We
3504 * need this to allow the EAPOL state machines to be completed
3505 * without going through EAPOL-Key handshake.
3507 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3512 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3514 if ((!wpa_s->p2p_mgmt ||
3515 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3516 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3517 l2_packet_deinit(wpa_s->l2);
3518 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3519 wpa_drv_get_mac_addr(wpa_s),
3521 wpa_supplicant_rx_eapol, wpa_s, 0);
3522 if (wpa_s->l2 == NULL)
3525 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3527 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3530 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3531 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3535 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3541 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
3542 const u8 *buf, size_t len)
3544 struct wpa_supplicant *wpa_s = ctx;
3545 const struct l2_ethhdr *eth;
3547 if (len < sizeof(*eth))
3549 eth = (const struct l2_ethhdr *) buf;
3551 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3552 !(eth->h_dest[0] & 0x01)) {
3553 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3554 " (bridge - not for this interface - ignore)",
3555 MAC2STR(src_addr), MAC2STR(eth->h_dest));
3559 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3560 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
3561 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
3562 len - sizeof(*eth));
3567 * wpa_supplicant_driver_init - Initialize driver interface parameters
3568 * @wpa_s: Pointer to wpa_supplicant data
3569 * Returns: 0 on success, -1 on failure
3571 * This function is called to initialize driver interface parameters.
3572 * wpa_drv_init() must have been called before this function to initialize the
3575 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
3577 static int interface_count = 0;
3579 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
3582 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
3583 MAC2STR(wpa_s->own_addr));
3584 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
3585 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3587 if (wpa_s->bridge_ifname[0]) {
3588 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
3589 "interface '%s'", wpa_s->bridge_ifname);
3590 wpa_s->l2_br = l2_packet_init_bridge(
3591 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
3592 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
3593 if (wpa_s->l2_br == NULL) {
3594 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
3595 "connection for the bridge interface '%s'",
3596 wpa_s->bridge_ifname);
3601 if (wpa_s->conf->ap_scan == 2 &&
3602 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3603 wpa_printf(MSG_INFO,
3604 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3607 wpa_clear_keys(wpa_s, NULL);
3609 /* Make sure that TKIP countermeasures are not left enabled (could
3610 * happen if wpa_supplicant is killed during countermeasures. */
3611 wpa_drv_set_countermeasures(wpa_s, 0);
3613 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
3614 wpa_drv_flush_pmkid(wpa_s);
3616 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
3617 wpa_s->prev_scan_wildcard = 0;
3619 if (wpa_supplicant_enabled_networks(wpa_s)) {
3620 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
3621 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3622 interface_count = 0;
3625 if (!wpa_s->p2p_mgmt &&
3626 wpa_supplicant_delayed_sched_scan(wpa_s,
3627 interface_count % 3,
3629 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
3631 #endif /* ANDROID */
3634 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
3640 static int wpa_supplicant_daemon(const char *pid_file)
3642 wpa_printf(MSG_DEBUG, "Daemonize..");
3643 return os_daemonize(pid_file);
3647 static struct wpa_supplicant *
3648 wpa_supplicant_alloc(struct wpa_supplicant *parent)
3650 struct wpa_supplicant *wpa_s;
3652 wpa_s = os_zalloc(sizeof(*wpa_s));
3655 wpa_s->scan_req = INITIAL_SCAN_REQ;
3656 wpa_s->scan_interval = 5;
3657 wpa_s->new_connection = 1;
3658 wpa_s->parent = parent ? parent : wpa_s;
3659 wpa_s->p2pdev = wpa_s->parent;
3660 wpa_s->sched_scanning = 0;
3662 dl_list_init(&wpa_s->bss_tmp_disallowed);
3668 #ifdef CONFIG_HT_OVERRIDES
3670 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
3671 struct ieee80211_ht_capabilities *htcaps,
3672 struct ieee80211_ht_capabilities *htcaps_mask,
3675 /* parse ht_mcs into hex array */
3677 const char *tmp = ht_mcs;
3680 /* If ht_mcs is null, do not set anything */
3684 /* This is what we are setting in the kernel */
3685 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
3687 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
3689 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3691 long v = strtol(tmp, &end, 16);
3693 wpa_msg(wpa_s, MSG_DEBUG,
3694 "htcap value[%i]: %ld end: %p tmp: %p",
3699 htcaps->supported_mcs_set[i] = v;
3702 wpa_msg(wpa_s, MSG_ERROR,
3703 "Failed to parse ht-mcs: %s, error: %s\n",
3704 ht_mcs, strerror(errno));
3710 * If we were able to parse any values, then set mask for the MCS set.
3713 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
3714 IEEE80211_HT_MCS_MASK_LEN - 1);
3715 /* skip the 3 reserved bits */
3716 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
3724 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
3725 struct ieee80211_ht_capabilities *htcaps,
3726 struct ieee80211_ht_capabilities *htcaps_mask,
3731 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3736 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3737 htcaps_mask->ht_capabilities_info |= msk;
3739 htcaps->ht_capabilities_info &= msk;
3741 htcaps->ht_capabilities_info |= msk;
3747 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3748 struct ieee80211_ht_capabilities *htcaps,
3749 struct ieee80211_ht_capabilities *htcaps_mask,
3752 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3757 if (factor < 0 || factor > 3) {
3758 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3759 "Must be 0-3 or -1", factor);
3763 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3764 htcaps->a_mpdu_params &= ~0x3;
3765 htcaps->a_mpdu_params |= factor & 0x3;
3771 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3772 struct ieee80211_ht_capabilities *htcaps,
3773 struct ieee80211_ht_capabilities *htcaps_mask,
3776 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3781 if (density < 0 || density > 7) {
3782 wpa_msg(wpa_s, MSG_ERROR,
3783 "ampdu_density: %d out of range. Must be 0-7 or -1.",
3788 htcaps_mask->a_mpdu_params |= 0x1C;
3789 htcaps->a_mpdu_params &= ~(0x1C);
3790 htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3796 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3797 struct ieee80211_ht_capabilities *htcaps,
3798 struct ieee80211_ht_capabilities *htcaps_mask,
3801 /* Masking these out disables HT40 */
3802 le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3803 HT_CAP_INFO_SHORT_GI40MHZ);
3805 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3808 htcaps->ht_capabilities_info &= ~msk;
3810 htcaps->ht_capabilities_info |= msk;
3812 htcaps_mask->ht_capabilities_info |= msk;
3818 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3819 struct ieee80211_ht_capabilities *htcaps,
3820 struct ieee80211_ht_capabilities *htcaps_mask,
3823 /* Masking these out disables SGI */
3824 le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3825 HT_CAP_INFO_SHORT_GI40MHZ);
3827 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3830 htcaps->ht_capabilities_info &= ~msk;
3832 htcaps->ht_capabilities_info |= msk;
3834 htcaps_mask->ht_capabilities_info |= msk;
3840 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3841 struct ieee80211_ht_capabilities *htcaps,
3842 struct ieee80211_ht_capabilities *htcaps_mask,
3845 /* Masking these out disables LDPC */
3846 le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
3848 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3851 htcaps->ht_capabilities_info &= ~msk;
3853 htcaps->ht_capabilities_info |= msk;
3855 htcaps_mask->ht_capabilities_info |= msk;
3861 void wpa_supplicant_apply_ht_overrides(
3862 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3863 struct wpa_driver_associate_params *params)
3865 struct ieee80211_ht_capabilities *htcaps;
3866 struct ieee80211_ht_capabilities *htcaps_mask;
3871 params->disable_ht = ssid->disable_ht;
3872 if (!params->htcaps || !params->htcaps_mask)
3875 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3876 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3877 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3878 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3879 ssid->disable_max_amsdu);
3880 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3881 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3882 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3883 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3884 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3886 if (ssid->ht40_intolerant) {
3887 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
3888 htcaps->ht_capabilities_info |= bit;
3889 htcaps_mask->ht_capabilities_info |= bit;
3893 #endif /* CONFIG_HT_OVERRIDES */
3896 #ifdef CONFIG_VHT_OVERRIDES
3897 void wpa_supplicant_apply_vht_overrides(
3898 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3899 struct wpa_driver_associate_params *params)
3901 struct ieee80211_vht_capabilities *vhtcaps;
3902 struct ieee80211_vht_capabilities *vhtcaps_mask;
3907 params->disable_vht = ssid->disable_vht;
3909 vhtcaps = (void *) params->vhtcaps;
3910 vhtcaps_mask = (void *) params->vhtcaps_mask;
3912 if (!vhtcaps || !vhtcaps_mask)
3915 vhtcaps->vht_capabilities_info = host_to_le32(ssid->vht_capa);
3916 vhtcaps_mask->vht_capabilities_info = host_to_le32(ssid->vht_capa_mask);
3918 #ifdef CONFIG_HT_OVERRIDES
3919 /* if max ampdu is <= 3, we have to make the HT cap the same */
3920 if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) {
3923 max_ampdu = (ssid->vht_capa &
3924 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >>
3925 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT;
3927 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3928 wpa_set_ampdu_factor(wpa_s,
3929 (void *) params->htcaps,
3930 (void *) params->htcaps_mask,
3933 #endif /* CONFIG_HT_OVERRIDES */
3935 #define OVERRIDE_MCS(i) \
3936 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
3937 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
3938 host_to_le16(3 << 2 * (i - 1)); \
3939 vhtcaps->vht_supported_mcs_set.tx_map |= \
3940 host_to_le16(ssid->vht_tx_mcs_nss_ ##i << \
3943 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
3944 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
3945 host_to_le16(3 << 2 * (i - 1)); \
3946 vhtcaps->vht_supported_mcs_set.rx_map |= \
3947 host_to_le16(ssid->vht_rx_mcs_nss_ ##i << \
3960 #endif /* CONFIG_VHT_OVERRIDES */
3963 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3968 if (!wpa_s->conf->pcsc_reader)
3971 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3975 if (wpa_s->conf->pcsc_pin &&
3976 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3977 scard_deinit(wpa_s->scard);
3978 wpa_s->scard = NULL;
3979 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3983 len = sizeof(wpa_s->imsi) - 1;
3984 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3985 scard_deinit(wpa_s->scard);
3986 wpa_s->scard = NULL;
3987 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3990 wpa_s->imsi[len] = '\0';
3992 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3994 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3995 wpa_s->imsi, wpa_s->mnc_len);
3997 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3998 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3999 #endif /* PCSC_FUNCS */
4005 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
4009 ext_password_deinit(wpa_s->ext_pw);
4010 wpa_s->ext_pw = NULL;
4011 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
4013 if (!wpa_s->conf->ext_password_backend)
4016 val = os_strdup(wpa_s->conf->ext_password_backend);
4019 pos = os_strchr(val, ':');
4023 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
4025 wpa_s->ext_pw = ext_password_init(val, pos);
4027 if (wpa_s->ext_pw == NULL) {
4028 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
4031 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
4039 static const u8 * wpas_fst_get_bssid_cb(void *ctx)
4041 struct wpa_supplicant *wpa_s = ctx;
4043 return (is_zero_ether_addr(wpa_s->bssid) ||
4044 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
4048 static void wpas_fst_get_channel_info_cb(void *ctx,
4049 enum hostapd_hw_mode *hw_mode,
4052 struct wpa_supplicant *wpa_s = ctx;
4054 if (wpa_s->current_bss) {
4055 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
4057 } else if (wpa_s->hw.num_modes) {
4058 *hw_mode = wpa_s->hw.modes[0].mode;
4066 static int wpas_fst_get_hw_modes(void *ctx, struct hostapd_hw_modes **modes)
4068 struct wpa_supplicant *wpa_s = ctx;
4070 *modes = wpa_s->hw.modes;
4071 return wpa_s->hw.num_modes;
4075 static void wpas_fst_set_ies_cb(void *ctx, const struct wpabuf *fst_ies)
4077 struct wpa_supplicant *wpa_s = ctx;
4079 wpa_hexdump_buf(MSG_DEBUG, "FST: Set IEs", fst_ies);
4080 wpa_s->fst_ies = fst_ies;
4084 static int wpas_fst_send_action_cb(void *ctx, const u8 *da, struct wpabuf *data)
4086 struct wpa_supplicant *wpa_s = ctx;
4088 WPA_ASSERT(os_memcmp(wpa_s->bssid, da, ETH_ALEN) == 0);
4089 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
4090 wpa_s->own_addr, wpa_s->bssid,
4091 wpabuf_head(data), wpabuf_len(data),
4096 static const struct wpabuf * wpas_fst_get_mb_ie_cb(void *ctx, const u8 *addr)
4098 struct wpa_supplicant *wpa_s = ctx;
4100 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4101 return wpa_s->received_mb_ies;
4105 static void wpas_fst_update_mb_ie_cb(void *ctx, const u8 *addr,
4106 const u8 *buf, size_t size)
4108 struct wpa_supplicant *wpa_s = ctx;
4109 struct mb_ies_info info;
4111 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4113 if (!mb_ies_info_by_ies(&info, buf, size)) {
4114 wpabuf_free(wpa_s->received_mb_ies);
4115 wpa_s->received_mb_ies = mb_ies_by_info(&info);
4120 static const u8 * wpas_fst_get_peer_first(void *ctx,
4121 struct fst_get_peer_ctx **get_ctx,
4124 struct wpa_supplicant *wpa_s = ctx;
4127 if (!is_zero_ether_addr(wpa_s->bssid))
4128 return (wpa_s->received_mb_ies || !mb_only) ?
4129 wpa_s->bssid : NULL;
4134 static const u8 * wpas_fst_get_peer_next(void *ctx,
4135 struct fst_get_peer_ctx **get_ctx,
4141 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
4142 struct fst_wpa_obj *iface_obj)
4144 iface_obj->ctx = wpa_s;
4145 iface_obj->get_bssid = wpas_fst_get_bssid_cb;
4146 iface_obj->get_channel_info = wpas_fst_get_channel_info_cb;
4147 iface_obj->get_hw_modes = wpas_fst_get_hw_modes;
4148 iface_obj->set_ies = wpas_fst_set_ies_cb;
4149 iface_obj->send_action = wpas_fst_send_action_cb;
4150 iface_obj->get_mb_ie = wpas_fst_get_mb_ie_cb;
4151 iface_obj->update_mb_ie = wpas_fst_update_mb_ie_cb;
4152 iface_obj->get_peer_first = wpas_fst_get_peer_first;
4153 iface_obj->get_peer_next = wpas_fst_get_peer_next;
4155 #endif /* CONFIG_FST */
4157 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
4158 const struct wpa_driver_capa *capa)
4160 struct wowlan_triggers *triggers;
4163 if (!wpa_s->conf->wowlan_triggers)
4166 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
4168 ret = wpa_drv_wowlan(wpa_s, triggers);
4175 enum wpa_radio_work_band wpas_freq_to_band(int freq)
4178 return BAND_2_4_GHZ;
4185 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
4188 unsigned int band = 0;
4191 /* freqs are specified for the radio work */
4192 for (i = 0; freqs[i]; i++)
4193 band |= wpas_freq_to_band(freqs[i]);
4196 * freqs are not specified, implies all
4197 * the supported freqs by HW
4199 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4200 if (wpa_s->hw.modes[i].num_channels != 0) {
4201 if (wpa_s->hw.modes[i].mode ==
4202 HOSTAPD_MODE_IEEE80211B ||
4203 wpa_s->hw.modes[i].mode ==
4204 HOSTAPD_MODE_IEEE80211G)
4205 band |= BAND_2_4_GHZ;
4206 else if (wpa_s->hw.modes[i].mode ==
4207 HOSTAPD_MODE_IEEE80211A)
4209 else if (wpa_s->hw.modes[i].mode ==
4210 HOSTAPD_MODE_IEEE80211AD)
4211 band |= BAND_60_GHZ;
4212 else if (wpa_s->hw.modes[i].mode ==
4213 HOSTAPD_MODE_IEEE80211ANY)
4214 band = BAND_2_4_GHZ | BAND_5_GHZ |
4224 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
4227 struct wpa_supplicant *iface = wpa_s->global->ifaces;
4228 struct wpa_radio *radio;
4230 while (rn && iface) {
4231 radio = iface->radio;
4232 if (radio && os_strcmp(rn, radio->name) == 0) {
4233 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
4235 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4239 iface = iface->next;
4242 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
4243 wpa_s->ifname, rn ? rn : "N/A");
4244 radio = os_zalloc(sizeof(*radio));
4249 os_strlcpy(radio->name, rn, sizeof(radio->name));
4250 dl_list_init(&radio->ifaces);
4251 dl_list_init(&radio->work);
4252 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4258 static void radio_work_free(struct wpa_radio_work *work)
4260 if (work->wpa_s->scan_work == work) {
4261 /* This should not really happen. */
4262 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4263 work->type, work, work->started);
4264 work->wpa_s->scan_work = NULL;
4268 if (work->wpa_s->p2p_scan_work == work) {
4269 /* This should not really happen. */
4270 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4271 work->type, work, work->started);
4272 work->wpa_s->p2p_scan_work = NULL;
4274 #endif /* CONFIG_P2P */
4276 if (work->started) {
4277 work->wpa_s->radio->num_active_works--;
4278 wpa_dbg(work->wpa_s, MSG_DEBUG,
4279 "radio_work_free('%s'@%p: num_active_works --> %u",
4281 work->wpa_s->radio->num_active_works);
4284 dl_list_del(&work->list);
4289 static struct wpa_radio_work * radio_work_get_next_work(struct wpa_radio *radio)
4291 struct wpa_radio_work *active_work = NULL;
4292 struct wpa_radio_work *tmp;
4294 /* Get the active work to know the type and band. */
4295 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4303 /* No active work, start one */
4304 radio->num_active_works = 0;
4305 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work,
4307 if (os_strcmp(tmp->type, "scan") == 0 &&
4308 radio->external_scan_running &&
4309 (((struct wpa_driver_scan_params *)
4310 tmp->ctx)->only_new_results ||
4311 tmp->wpa_s->clear_driver_scan_cache))
4318 if (os_strcmp(active_work->type, "sme-connect") == 0 ||
4319 os_strcmp(active_work->type, "connect") == 0) {
4321 * If the active work is either connect or sme-connect,
4322 * do not parallelize them with other radio works.
4324 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4325 "Do not parallelize radio work with %s",
4330 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4335 * If connect or sme-connect are enqueued, parallelize only
4336 * those operations ahead of them in the queue.
4338 if (os_strcmp(tmp->type, "connect") == 0 ||
4339 os_strcmp(tmp->type, "sme-connect") == 0)
4343 * Check that the radio works are distinct and
4344 * on different bands.
4346 if (os_strcmp(active_work->type, tmp->type) != 0 &&
4347 (active_work->bands != tmp->bands)) {
4349 * If a scan has to be scheduled through nl80211 scan
4350 * interface and if an external scan is already running,
4351 * do not schedule the scan since it is likely to get
4352 * rejected by kernel.
4354 if (os_strcmp(tmp->type, "scan") == 0 &&
4355 radio->external_scan_running &&
4356 (((struct wpa_driver_scan_params *)
4357 tmp->ctx)->only_new_results ||
4358 tmp->wpa_s->clear_driver_scan_cache))
4361 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4362 "active_work:%s new_work:%s",
4363 active_work->type, tmp->type);
4368 /* Did not find a radio work to schedule in parallel. */
4373 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
4375 struct wpa_radio *radio = eloop_ctx;
4376 struct wpa_radio_work *work;
4377 struct os_reltime now, diff;
4378 struct wpa_supplicant *wpa_s;
4380 work = dl_list_first(&radio->work, struct wpa_radio_work, list);
4382 radio->num_active_works = 0;
4386 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
4390 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
4392 return; /* already started and still in progress */
4394 if (wpa_s && wpa_s->radio->external_scan_running) {
4395 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
4400 if (radio->num_active_works < MAX_ACTIVE_WORKS) {
4401 /* get the work to schedule next */
4402 work = radio_work_get_next_work(radio);
4408 wpa_s = work->wpa_s;
4409 os_get_reltime(&now);
4410 os_reltime_sub(&now, &work->time, &diff);
4411 wpa_dbg(wpa_s, MSG_DEBUG,
4412 "Starting radio work '%s'@%p after %ld.%06ld second wait",
4413 work->type, work, diff.sec, diff.usec);
4416 radio->num_active_works++;
4420 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
4421 radio->num_active_works < MAX_ACTIVE_WORKS)
4422 radio_work_check_next(wpa_s);
4427 * This function removes both started and pending radio works running on
4428 * the provided interface's radio.
4429 * Prior to the removal of the radio work, its callback (cb) is called with
4430 * deinit set to be 1. Each work's callback is responsible for clearing its
4431 * internal data and restoring to a correct state.
4432 * @wpa_s: wpa_supplicant data
4433 * @type: type of works to be removed
4434 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
4435 * this interface's works.
4437 void radio_remove_works(struct wpa_supplicant *wpa_s,
4438 const char *type, int remove_all)
4440 struct wpa_radio_work *work, *tmp;
4441 struct wpa_radio *radio = wpa_s->radio;
4443 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
4445 if (type && os_strcmp(type, work->type) != 0)
4448 /* skip other ifaces' works */
4449 if (!remove_all && work->wpa_s != wpa_s)
4452 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
4453 work->type, work, work->started ? " (started)" : "");
4455 radio_work_free(work);
4458 /* in case we removed the started work */
4459 radio_work_check_next(wpa_s);
4463 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
4465 struct wpa_radio *radio = wpa_s->radio;
4470 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
4471 wpa_s->ifname, radio->name);
4472 dl_list_del(&wpa_s->radio_list);
4473 radio_remove_works(wpa_s, NULL, 0);
4474 wpa_s->radio = NULL;
4475 if (!dl_list_empty(&radio->ifaces))
4476 return; /* Interfaces remain for this radio */
4478 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
4479 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4484 void radio_work_check_next(struct wpa_supplicant *wpa_s)
4486 struct wpa_radio *radio = wpa_s->radio;
4488 if (dl_list_empty(&radio->work))
4490 if (wpa_s->ext_work_in_progress) {
4491 wpa_printf(MSG_DEBUG,
4492 "External radio work in progress - delay start of pending item");
4495 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4496 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
4501 * radio_add_work - Add a radio work item
4502 * @wpa_s: Pointer to wpa_supplicant data
4503 * @freq: Frequency of the offchannel operation in MHz or 0
4504 * @type: Unique identifier for each type of work
4505 * @next: Force as the next work to be executed
4506 * @cb: Callback function for indicating when radio is available
4507 * @ctx: Context pointer for the work (work->ctx in cb())
4508 * Returns: 0 on success, -1 on failure
4510 * This function is used to request time for an operation that requires
4511 * exclusive radio control. Once the radio is available, the registered callback
4512 * function will be called. radio_work_done() must be called once the exclusive
4513 * radio operation has been completed, so that the radio is freed for other
4514 * operations. The special case of deinit=1 is used to free the context data
4515 * during interface removal. That does not allow the callback function to start
4516 * the radio operation, i.e., it must free any resources allocated for the radio
4519 * The @freq parameter can be used to indicate a single channel on which the
4520 * offchannel operation will occur. This may allow multiple radio work
4521 * operations to be performed in parallel if they apply for the same channel.
4522 * Setting this to 0 indicates that the work item may use multiple channels or
4523 * requires exclusive control of the radio.
4525 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
4526 const char *type, int next,
4527 void (*cb)(struct wpa_radio_work *work, int deinit),
4530 struct wpa_radio *radio = wpa_s->radio;
4531 struct wpa_radio_work *work;
4534 work = os_zalloc(sizeof(*work));
4537 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
4538 os_get_reltime(&work->time);
4541 work->wpa_s = wpa_s;
4546 work->bands = wpas_freq_to_band(freq);
4547 else if (os_strcmp(type, "scan") == 0 ||
4548 os_strcmp(type, "p2p-scan") == 0)
4549 work->bands = wpas_get_bands(wpa_s,
4550 ((struct wpa_driver_scan_params *)
4553 work->bands = wpas_get_bands(wpa_s, NULL);
4555 was_empty = dl_list_empty(&wpa_s->radio->work);
4557 dl_list_add(&wpa_s->radio->work, &work->list);
4559 dl_list_add_tail(&wpa_s->radio->work, &work->list);
4561 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
4562 radio_work_check_next(wpa_s);
4563 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
4564 && radio->num_active_works < MAX_ACTIVE_WORKS) {
4565 wpa_dbg(wpa_s, MSG_DEBUG,
4566 "Try to schedule a radio work (num_active_works=%u)",
4567 radio->num_active_works);
4568 radio_work_check_next(wpa_s);
4576 * radio_work_done - Indicate that a radio work item has been completed
4577 * @work: Completed work
4579 * This function is called once the callback function registered with
4580 * radio_add_work() has completed its work.
4582 void radio_work_done(struct wpa_radio_work *work)
4584 struct wpa_supplicant *wpa_s = work->wpa_s;
4585 struct os_reltime now, diff;
4586 unsigned int started = work->started;
4588 os_get_reltime(&now);
4589 os_reltime_sub(&now, &work->time, &diff);
4590 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
4591 work->type, work, started ? "done" : "canceled",
4592 diff.sec, diff.usec);
4593 radio_work_free(work);
4595 radio_work_check_next(wpa_s);
4599 struct wpa_radio_work *
4600 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
4602 struct wpa_radio_work *work;
4603 struct wpa_radio *radio = wpa_s->radio;
4605 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
4606 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
4614 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
4615 struct wpa_interface *iface)
4617 const char *ifname, *driver, *rn;
4619 driver = iface->driver;
4621 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
4624 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
4625 if (wpa_s->drv_priv == NULL) {
4627 pos = driver ? os_strchr(driver, ',') : NULL;
4629 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
4630 "driver interface - try next driver wrapper");
4634 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
4638 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
4639 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
4640 "driver_param '%s'", wpa_s->conf->driver_param);
4644 ifname = wpa_drv_get_ifname(wpa_s);
4645 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
4646 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
4647 "interface name with '%s'", ifname);
4648 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
4651 rn = wpa_driver_get_radio_name(wpa_s);
4652 if (rn && rn[0] == '\0')
4655 wpa_s->radio = radio_add_interface(wpa_s, rn);
4656 if (wpa_s->radio == NULL)
4663 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
4664 struct wpa_interface *iface)
4666 struct wpa_driver_capa capa;
4669 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
4670 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
4671 iface->confname ? iface->confname : "N/A",
4672 iface->driver ? iface->driver : "default",
4673 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
4674 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
4676 if (iface->confname) {
4677 #ifdef CONFIG_BACKEND_FILE
4678 wpa_s->confname = os_rel2abs_path(iface->confname);
4679 if (wpa_s->confname == NULL) {
4680 wpa_printf(MSG_ERROR, "Failed to get absolute path "
4681 "for configuration file '%s'.",
4685 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
4686 iface->confname, wpa_s->confname);
4687 #else /* CONFIG_BACKEND_FILE */
4688 wpa_s->confname = os_strdup(iface->confname);
4689 #endif /* CONFIG_BACKEND_FILE */
4690 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
4691 if (wpa_s->conf == NULL) {
4692 wpa_printf(MSG_ERROR, "Failed to read or parse "
4693 "configuration '%s'.", wpa_s->confname);
4696 wpa_s->confanother = os_rel2abs_path(iface->confanother);
4697 wpa_config_read(wpa_s->confanother, wpa_s->conf);
4700 * Override ctrl_interface and driver_param if set on command
4703 if (iface->ctrl_interface) {
4704 os_free(wpa_s->conf->ctrl_interface);
4705 wpa_s->conf->ctrl_interface =
4706 os_strdup(iface->ctrl_interface);
4709 if (iface->driver_param) {
4710 os_free(wpa_s->conf->driver_param);
4711 wpa_s->conf->driver_param =
4712 os_strdup(iface->driver_param);
4715 if (iface->p2p_mgmt && !iface->ctrl_interface) {
4716 os_free(wpa_s->conf->ctrl_interface);
4717 wpa_s->conf->ctrl_interface = NULL;
4720 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
4721 iface->driver_param);
4723 if (wpa_s->conf == NULL) {
4724 wpa_printf(MSG_ERROR, "\nNo configuration found.");
4728 if (iface->ifname == NULL) {
4729 wpa_printf(MSG_ERROR, "\nInterface name is required.");
4732 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
4733 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
4737 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
4739 if (iface->bridge_ifname) {
4740 if (os_strlen(iface->bridge_ifname) >=
4741 sizeof(wpa_s->bridge_ifname)) {
4742 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
4743 "name '%s'.", iface->bridge_ifname);
4746 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
4747 sizeof(wpa_s->bridge_ifname));
4750 /* RSNA Supplicant Key Management - INITIALIZE */
4751 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
4752 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
4754 /* Initialize driver interface and register driver event handler before
4755 * L2 receive handler so that association events are processed before
4756 * EAPOL-Key packets if both become available for the same select()
4758 if (wpas_init_driver(wpa_s, iface) < 0)
4761 if (wpa_supplicant_init_wpa(wpa_s) < 0)
4764 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
4765 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
4767 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
4769 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
4770 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
4771 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
4772 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4773 "dot11RSNAConfigPMKLifetime");
4777 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
4778 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
4779 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
4780 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4781 "dot11RSNAConfigPMKReauthThreshold");
4785 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
4786 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
4787 wpa_s->conf->dot11RSNAConfigSATimeout)) {
4788 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4789 "dot11RSNAConfigSATimeout");
4793 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
4794 &wpa_s->hw.num_modes,
4796 if (wpa_s->hw.modes) {
4799 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4800 if (wpa_s->hw.modes[i].vht_capab) {
4801 wpa_s->hw_capab = CAPAB_VHT;
4805 if (wpa_s->hw.modes[i].ht_capab &
4806 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)
4807 wpa_s->hw_capab = CAPAB_HT40;
4808 else if (wpa_s->hw.modes[i].ht_capab &&
4809 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
4810 wpa_s->hw_capab = CAPAB_HT;
4814 capa_res = wpa_drv_get_capa(wpa_s, &capa);
4815 if (capa_res == 0) {
4816 wpa_s->drv_capa_known = 1;
4817 wpa_s->drv_flags = capa.flags;
4818 wpa_s->drv_enc = capa.enc;
4819 wpa_s->drv_smps_modes = capa.smps_modes;
4820 wpa_s->drv_rrm_flags = capa.rrm_flags;
4821 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
4822 wpa_s->max_scan_ssids = capa.max_scan_ssids;
4823 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
4824 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
4825 wpa_s->max_sched_scan_plan_interval =
4826 capa.max_sched_scan_plan_interval;
4827 wpa_s->max_sched_scan_plan_iterations =
4828 capa.max_sched_scan_plan_iterations;
4829 wpa_s->sched_scan_supported = capa.sched_scan_supported;
4830 wpa_s->max_match_sets = capa.max_match_sets;
4831 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
4832 wpa_s->max_stations = capa.max_stations;
4833 wpa_s->extended_capa = capa.extended_capa;
4834 wpa_s->extended_capa_mask = capa.extended_capa_mask;
4835 wpa_s->extended_capa_len = capa.extended_capa_len;
4836 wpa_s->num_multichan_concurrent =
4837 capa.num_multichan_concurrent;
4838 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
4840 if (capa.mac_addr_rand_scan_supported)
4841 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
4842 if (wpa_s->sched_scan_supported &&
4843 capa.mac_addr_rand_sched_scan_supported)
4844 wpa_s->mac_addr_rand_supported |=
4845 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO);
4847 if (wpa_s->max_remain_on_chan == 0)
4848 wpa_s->max_remain_on_chan = 1000;
4851 * Only take p2p_mgmt parameters when P2P Device is supported.
4852 * Doing it here as it determines whether l2_packet_init() will be done
4853 * during wpa_supplicant_driver_init().
4855 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
4856 wpa_s->p2p_mgmt = iface->p2p_mgmt;
4858 iface->p2p_mgmt = 1;
4860 if (wpa_s->num_multichan_concurrent == 0)
4861 wpa_s->num_multichan_concurrent = 1;
4863 if (wpa_supplicant_driver_init(wpa_s) < 0)
4867 if ((!iface->p2p_mgmt ||
4868 !(wpa_s->drv_flags &
4869 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
4870 wpa_tdls_init(wpa_s->wpa))
4872 #endif /* CONFIG_TDLS */
4874 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
4875 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
4876 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
4881 if (wpa_s->conf->fst_group_id) {
4882 struct fst_iface_cfg cfg;
4883 struct fst_wpa_obj iface_obj;
4885 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
4886 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
4887 sizeof(cfg.group_id));
4888 cfg.priority = wpa_s->conf->fst_priority;
4889 cfg.llt = wpa_s->conf->fst_llt;
4891 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
4894 wpa_msg(wpa_s, MSG_ERROR,
4895 "FST: Cannot attach iface %s to group %s",
4896 wpa_s->ifname, cfg.group_id);
4900 #endif /* CONFIG_FST */
4902 if (wpas_wps_init(wpa_s))
4905 if (wpa_supplicant_init_eapol(wpa_s) < 0)
4907 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
4909 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
4910 if (wpa_s->ctrl_iface == NULL) {
4911 wpa_printf(MSG_ERROR,
4912 "Failed to initialize control interface '%s'.\n"
4913 "You may have another wpa_supplicant process "
4914 "already running or the file was\n"
4915 "left by an unclean termination of wpa_supplicant "
4916 "in which case you will need\n"
4917 "to manually remove this file before starting "
4918 "wpa_supplicant again.\n",
4919 wpa_s->conf->ctrl_interface);
4923 wpa_s->gas = gas_query_init(wpa_s);
4924 if (wpa_s->gas == NULL) {
4925 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
4929 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
4930 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
4934 if (wpa_bss_init(wpa_s) < 0)
4938 * Set Wake-on-WLAN triggers, if configured.
4939 * Note: We don't restore/remove the triggers on shutdown (it doesn't
4940 * have effect anyway when the interface is down).
4942 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
4945 #ifdef CONFIG_EAP_PROXY
4948 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
4950 if (wpa_s->mnc_len > 0) {
4951 wpa_s->imsi[len] = '\0';
4952 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
4953 wpa_s->imsi, wpa_s->mnc_len);
4955 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
4958 #endif /* CONFIG_EAP_PROXY */
4960 if (pcsc_reader_init(wpa_s) < 0)
4963 if (wpas_init_ext_pw(wpa_s) < 0)
4966 wpas_rrm_reset(wpa_s);
4968 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
4972 #endif /* CONFIG_HS20 */
4974 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
4975 #endif /* CONFIG_MBO */
4977 wpa_supplicant_set_default_scan_ies(wpa_s);
4983 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
4984 int notify, int terminate)
4986 struct wpa_global *global = wpa_s->global;
4987 struct wpa_supplicant *iface, *prev;
4989 if (wpa_s == wpa_s->parent)
4990 wpas_p2p_group_remove(wpa_s, "*");
4992 iface = global->ifaces;
4994 if (iface->p2pdev == wpa_s)
4995 iface->p2pdev = iface->parent;
4996 if (iface == wpa_s || iface->parent != wpa_s) {
4997 iface = iface->next;
5000 wpa_printf(MSG_DEBUG,
5001 "Remove remaining child interface %s from parent %s",
5002 iface->ifname, wpa_s->ifname);
5004 iface = iface->next;
5005 wpa_supplicant_remove_iface(global, prev, terminate);
5008 wpa_s->disconnected = 1;
5009 if (wpa_s->drv_priv) {
5010 wpa_supplicant_deauthenticate(wpa_s,
5011 WLAN_REASON_DEAUTH_LEAVING);
5013 wpa_drv_set_countermeasures(wpa_s, 0);
5014 wpa_clear_keys(wpa_s, NULL);
5017 wpa_supplicant_cleanup(wpa_s);
5018 wpas_p2p_deinit_iface(wpa_s);
5020 wpas_ctrl_radio_work_flush(wpa_s);
5021 radio_remove_interface(wpa_s);
5025 fst_detach(wpa_s->fst);
5028 if (wpa_s->received_mb_ies) {
5029 wpabuf_free(wpa_s->received_mb_ies);
5030 wpa_s->received_mb_ies = NULL;
5032 #endif /* CONFIG_FST */
5034 if (wpa_s->drv_priv)
5035 wpa_drv_deinit(wpa_s);
5038 wpas_notify_iface_removed(wpa_s);
5041 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
5043 if (wpa_s->ctrl_iface) {
5044 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
5045 wpa_s->ctrl_iface = NULL;
5050 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
5051 wpa_s->ifmsh = NULL;
5053 #endif /* CONFIG_MESH */
5055 if (wpa_s->conf != NULL) {
5056 wpa_config_free(wpa_s->conf);
5060 os_free(wpa_s->ssids_from_scan_req);
5066 #ifdef CONFIG_MATCH_IFACE
5069 * wpa_supplicant_match_iface - Match an interface description to a name
5070 * @global: Pointer to global data from wpa_supplicant_init()
5071 * @ifname: Name of the interface to match
5072 * Returns: Pointer to the created interface description or %NULL on failure
5074 struct wpa_interface * wpa_supplicant_match_iface(struct wpa_global *global,
5078 struct wpa_interface *iface, *miface;
5080 for (i = 0; i < global->params.match_iface_count; i++) {
5081 miface = &global->params.match_ifaces[i];
5082 if (!miface->ifname ||
5083 fnmatch(miface->ifname, ifname, 0) == 0) {
5084 iface = os_zalloc(sizeof(*iface));
5088 iface->ifname = ifname;
5098 * wpa_supplicant_match_existing - Match existing interfaces
5099 * @global: Pointer to global data from wpa_supplicant_init()
5100 * Returns: 0 on success, -1 on failure
5102 static int wpa_supplicant_match_existing(struct wpa_global *global)
5104 struct if_nameindex *ifi, *ifp;
5105 struct wpa_supplicant *wpa_s;
5106 struct wpa_interface *iface;
5108 ifp = if_nameindex();
5110 wpa_printf(MSG_ERROR, "if_nameindex: %s", strerror(errno));
5114 for (ifi = ifp; ifi->if_name; ifi++) {
5115 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
5118 iface = wpa_supplicant_match_iface(global, ifi->if_name);
5120 wpa_s = wpa_supplicant_add_iface(global, iface, NULL);
5127 if_freenameindex(ifp);
5131 #endif /* CONFIG_MATCH_IFACE */
5135 * wpa_supplicant_add_iface - Add a new network interface
5136 * @global: Pointer to global data from wpa_supplicant_init()
5137 * @iface: Interface configuration options
5138 * @parent: Parent interface or %NULL to assign new interface as parent
5139 * Returns: Pointer to the created interface or %NULL on failure
5141 * This function is used to add new network interfaces for %wpa_supplicant.
5142 * This can be called before wpa_supplicant_run() to add interfaces before the
5143 * main event loop has been started. In addition, new interfaces can be added
5144 * dynamically while %wpa_supplicant is already running. This could happen,
5145 * e.g., when a hotplug network adapter is inserted.
5147 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
5148 struct wpa_interface *iface,
5149 struct wpa_supplicant *parent)
5151 struct wpa_supplicant *wpa_s;
5152 struct wpa_interface t_iface;
5153 struct wpa_ssid *ssid;
5155 if (global == NULL || iface == NULL)
5158 wpa_s = wpa_supplicant_alloc(parent);
5162 wpa_s->global = global;
5165 if (global->params.override_driver) {
5166 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
5168 iface->driver, global->params.override_driver);
5169 t_iface.driver = global->params.override_driver;
5171 if (global->params.override_ctrl_interface) {
5172 wpa_printf(MSG_DEBUG, "Override interface parameter: "
5173 "ctrl_interface ('%s' -> '%s')",
5174 iface->ctrl_interface,
5175 global->params.override_ctrl_interface);
5176 t_iface.ctrl_interface =
5177 global->params.override_ctrl_interface;
5179 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
5180 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
5182 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
5186 if (iface->p2p_mgmt == 0) {
5187 /* Notify the control interfaces about new iface */
5188 if (wpas_notify_iface_added(wpa_s)) {
5189 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
5193 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
5194 wpas_notify_network_added(wpa_s, ssid);
5197 wpa_s->next = global->ifaces;
5198 global->ifaces = wpa_s;
5200 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
5201 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
5204 if (wpa_s->global->p2p == NULL &&
5205 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
5206 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
5207 wpas_p2p_add_p2pdev_interface(
5208 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
5209 wpa_printf(MSG_INFO,
5210 "P2P: Failed to enable P2P Device interface");
5211 /* Try to continue without. P2P will be disabled. */
5213 #endif /* CONFIG_P2P */
5220 * wpa_supplicant_remove_iface - Remove a network interface
5221 * @global: Pointer to global data from wpa_supplicant_init()
5222 * @wpa_s: Pointer to the network interface to be removed
5223 * Returns: 0 if interface was removed, -1 if interface was not found
5225 * This function can be used to dynamically remove network interfaces from
5226 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
5227 * addition, this function is used to remove all remaining interfaces when
5228 * %wpa_supplicant is terminated.
5230 int wpa_supplicant_remove_iface(struct wpa_global *global,
5231 struct wpa_supplicant *wpa_s,
5234 struct wpa_supplicant *prev;
5236 unsigned int mesh_if_created = wpa_s->mesh_if_created;
5237 char *ifname = NULL;
5238 #endif /* CONFIG_MESH */
5240 /* Remove interface from the global list of interfaces */
5241 prev = global->ifaces;
5242 if (prev == wpa_s) {
5243 global->ifaces = wpa_s->next;
5245 while (prev && prev->next != wpa_s)
5249 prev->next = wpa_s->next;
5252 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
5255 if (mesh_if_created) {
5256 ifname = os_strdup(wpa_s->ifname);
5257 if (ifname == NULL) {
5258 wpa_dbg(wpa_s, MSG_ERROR,
5259 "mesh: Failed to malloc ifname");
5263 #endif /* CONFIG_MESH */
5265 if (global->p2p_group_formation == wpa_s)
5266 global->p2p_group_formation = NULL;
5267 if (global->p2p_invite_group == wpa_s)
5268 global->p2p_invite_group = NULL;
5269 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
5272 if (mesh_if_created) {
5273 wpa_drv_if_remove(global->ifaces, WPA_IF_MESH, ifname);
5276 #endif /* CONFIG_MESH */
5283 * wpa_supplicant_get_eap_mode - Get the current EAP mode
5284 * @wpa_s: Pointer to the network interface
5285 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
5287 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
5289 const char *eapol_method;
5291 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
5292 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
5296 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
5297 if (eapol_method == NULL)
5298 return "UNKNOWN-EAP";
5300 return eapol_method;
5305 * wpa_supplicant_get_iface - Get a new network interface
5306 * @global: Pointer to global data from wpa_supplicant_init()
5307 * @ifname: Interface name
5308 * Returns: Pointer to the interface or %NULL if not found
5310 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
5313 struct wpa_supplicant *wpa_s;
5315 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5316 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5323 #ifndef CONFIG_NO_WPA_MSG
5324 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
5326 struct wpa_supplicant *wpa_s = ctx;
5329 return wpa_s->ifname;
5331 #endif /* CONFIG_NO_WPA_MSG */
5334 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL
5335 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10
5336 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */
5338 /* Periodic cleanup tasks */
5339 static void wpas_periodic(void *eloop_ctx, void *timeout_ctx)
5341 struct wpa_global *global = eloop_ctx;
5342 struct wpa_supplicant *wpa_s;
5344 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5345 wpas_periodic, global, NULL);
5349 p2p_expire_peers(global->p2p);
5350 #endif /* CONFIG_P2P */
5352 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5353 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
5356 #endif /* CONFIG_AP */
5362 * wpa_supplicant_init - Initialize %wpa_supplicant
5363 * @params: Parameters for %wpa_supplicant
5364 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
5366 * This function is used to initialize %wpa_supplicant. After successful
5367 * initialization, the returned data pointer can be used to add and remove
5368 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
5370 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
5372 struct wpa_global *global;
5378 #ifdef CONFIG_DRIVER_NDIS
5380 void driver_ndis_init_ops(void);
5381 driver_ndis_init_ops();
5383 #endif /* CONFIG_DRIVER_NDIS */
5385 #ifndef CONFIG_NO_WPA_MSG
5386 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
5387 #endif /* CONFIG_NO_WPA_MSG */
5389 if (params->wpa_debug_file_path)
5390 wpa_debug_open_file(params->wpa_debug_file_path);
5392 wpa_debug_setup_stdout();
5393 if (params->wpa_debug_syslog)
5394 wpa_debug_open_syslog();
5395 if (params->wpa_debug_tracing) {
5396 ret = wpa_debug_open_linux_tracing();
5398 wpa_printf(MSG_ERROR,
5399 "Failed to enable trace logging");
5404 ret = eap_register_methods();
5406 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
5408 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
5409 "the same EAP type.");
5413 global = os_zalloc(sizeof(*global));
5416 dl_list_init(&global->p2p_srv_bonjour);
5417 dl_list_init(&global->p2p_srv_upnp);
5418 global->params.daemonize = params->daemonize;
5419 global->params.wait_for_monitor = params->wait_for_monitor;
5420 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
5421 if (params->pid_file)
5422 global->params.pid_file = os_strdup(params->pid_file);
5423 if (params->ctrl_interface)
5424 global->params.ctrl_interface =
5425 os_strdup(params->ctrl_interface);
5426 if (params->ctrl_interface_group)
5427 global->params.ctrl_interface_group =
5428 os_strdup(params->ctrl_interface_group);
5429 if (params->override_driver)
5430 global->params.override_driver =
5431 os_strdup(params->override_driver);
5432 if (params->override_ctrl_interface)
5433 global->params.override_ctrl_interface =
5434 os_strdup(params->override_ctrl_interface);
5435 #ifdef CONFIG_MATCH_IFACE
5436 global->params.match_iface_count = params->match_iface_count;
5437 if (params->match_iface_count) {
5438 global->params.match_ifaces =
5439 os_calloc(params->match_iface_count,
5440 sizeof(struct wpa_interface));
5441 os_memcpy(global->params.match_ifaces,
5442 params->match_ifaces,
5443 params->match_iface_count *
5444 sizeof(struct wpa_interface));
5446 #endif /* CONFIG_MATCH_IFACE */
5448 if (params->conf_p2p_dev)
5449 global->params.conf_p2p_dev =
5450 os_strdup(params->conf_p2p_dev);
5451 #endif /* CONFIG_P2P */
5452 wpa_debug_level = global->params.wpa_debug_level =
5453 params->wpa_debug_level;
5454 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
5455 params->wpa_debug_show_keys;
5456 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
5457 params->wpa_debug_timestamp;
5459 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
5462 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
5463 wpa_supplicant_deinit(global);
5467 random_init(params->entropy_file);
5469 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
5470 if (global->ctrl_iface == NULL) {
5471 wpa_supplicant_deinit(global);
5475 if (wpas_notify_supplicant_initialized(global)) {
5476 wpa_supplicant_deinit(global);
5480 for (i = 0; wpa_drivers[i]; i++)
5481 global->drv_count++;
5482 if (global->drv_count == 0) {
5483 wpa_printf(MSG_ERROR, "No drivers enabled");
5484 wpa_supplicant_deinit(global);
5487 global->drv_priv = os_calloc(global->drv_count, sizeof(void *));
5488 if (global->drv_priv == NULL) {
5489 wpa_supplicant_deinit(global);
5493 #ifdef CONFIG_WIFI_DISPLAY
5494 if (wifi_display_init(global) < 0) {
5495 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
5496 wpa_supplicant_deinit(global);
5499 #endif /* CONFIG_WIFI_DISPLAY */
5501 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5502 wpas_periodic, global, NULL);
5509 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
5510 * @global: Pointer to global data from wpa_supplicant_init()
5511 * Returns: 0 after successful event loop run, -1 on failure
5513 * This function starts the main event loop and continues running as long as
5514 * there are any remaining events. In most cases, this function is running as
5515 * long as the %wpa_supplicant process in still in use.
5517 int wpa_supplicant_run(struct wpa_global *global)
5519 struct wpa_supplicant *wpa_s;
5521 if (global->params.daemonize &&
5522 (wpa_supplicant_daemon(global->params.pid_file) ||
5523 eloop_sock_requeue()))
5526 #ifdef CONFIG_MATCH_IFACE
5527 if (wpa_supplicant_match_existing(global))
5531 if (global->params.wait_for_monitor) {
5532 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
5533 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
5534 wpa_supplicant_ctrl_iface_wait(
5538 eloop_register_signal_terminate(wpa_supplicant_terminate, global);
5539 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
5548 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
5549 * @global: Pointer to global data from wpa_supplicant_init()
5551 * This function is called to deinitialize %wpa_supplicant and to free all
5552 * allocated resources. Remaining network interfaces will also be removed.
5554 void wpa_supplicant_deinit(struct wpa_global *global)
5561 eloop_cancel_timeout(wpas_periodic, global, NULL);
5563 #ifdef CONFIG_WIFI_DISPLAY
5564 wifi_display_deinit(global);
5565 #endif /* CONFIG_WIFI_DISPLAY */
5567 while (global->ifaces)
5568 wpa_supplicant_remove_iface(global, global->ifaces, 1);
5570 if (global->ctrl_iface)
5571 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
5573 wpas_notify_supplicant_deinitialized(global);
5575 eap_peer_unregister_methods();
5577 eap_server_unregister_methods();
5578 #endif /* CONFIG_AP */
5580 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
5581 if (!global->drv_priv[i])
5583 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
5585 os_free(global->drv_priv);
5591 if (global->params.pid_file) {
5592 os_daemonize_terminate(global->params.pid_file);
5593 os_free(global->params.pid_file);
5595 os_free(global->params.ctrl_interface);
5596 os_free(global->params.ctrl_interface_group);
5597 os_free(global->params.override_driver);
5598 os_free(global->params.override_ctrl_interface);
5599 #ifdef CONFIG_MATCH_IFACE
5600 os_free(global->params.match_ifaces);
5601 #endif /* CONFIG_MATCH_IFACE */
5603 os_free(global->params.conf_p2p_dev);
5604 #endif /* CONFIG_P2P */
5606 os_free(global->p2p_disallow_freq.range);
5607 os_free(global->p2p_go_avoid_freq.range);
5608 os_free(global->add_psk);
5611 wpa_debug_close_syslog();
5612 wpa_debug_close_file();
5613 wpa_debug_close_linux_tracing();
5617 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
5619 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
5620 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5622 country[0] = wpa_s->conf->country[0];
5623 country[1] = wpa_s->conf->country[1];
5625 if (wpa_drv_set_country(wpa_s, country) < 0) {
5626 wpa_printf(MSG_ERROR, "Failed to set country code "
5631 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
5632 wpas_init_ext_pw(wpa_s);
5634 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
5635 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5638 wpas_wps_update_config(wpa_s);
5639 #endif /* CONFIG_WPS */
5640 wpas_p2p_update_config(wpa_s);
5641 wpa_s->conf->changed_parameters = 0;
5645 void add_freq(int *freqs, int *num_freqs, int freq)
5649 for (i = 0; i < *num_freqs; i++) {
5650 if (freqs[i] == freq)
5654 freqs[*num_freqs] = freq;
5659 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
5661 struct wpa_bss *bss, *cbss;
5662 const int max_freqs = 10;
5666 freqs = os_calloc(max_freqs + 1, sizeof(int));
5670 cbss = wpa_s->current_bss;
5672 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
5675 if (bss->ssid_len == cbss->ssid_len &&
5676 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
5677 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
5678 add_freq(freqs, &num_freqs, bss->freq);
5679 if (num_freqs == max_freqs)
5684 if (num_freqs == 0) {
5693 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
5699 wpas_connect_work_done(wpa_s);
5702 * Remove possible authentication timeout since the connection failed.
5704 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
5707 * There is no point in blacklisting the AP if this event is
5708 * generated based on local request to disconnect.
5710 if (wpa_s->own_disconnect_req) {
5711 wpa_s->own_disconnect_req = 0;
5712 wpa_dbg(wpa_s, MSG_DEBUG,
5713 "Ignore connection failure due to local request to disconnect");
5716 if (wpa_s->disconnected) {
5717 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
5718 "indication since interface has been put into "
5719 "disconnected state");
5724 * Add the failed BSSID into the blacklist and speed up next scan
5725 * attempt if there could be other APs that could accept association.
5726 * The current blacklist count indicates how many times we have tried
5727 * connecting to this AP and multiple attempts mean that other APs are
5728 * either not available or has already been tried, so that we can start
5729 * increasing the delay here to avoid constant scanning.
5731 count = wpa_blacklist_add(wpa_s, bssid);
5732 if (count == 1 && wpa_s->current_bss) {
5734 * This BSS was not in the blacklist before. If there is
5735 * another BSS available for the same ESS, we should try that
5736 * next. Otherwise, we may as well try this one once more
5737 * before allowing other, likely worse, ESSes to be considered.
5739 freqs = get_bss_freqs_in_ess(wpa_s);
5741 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
5742 "has been seen; try it next");
5743 wpa_blacklist_add(wpa_s, bssid);
5745 * On the next scan, go through only the known channels
5746 * used in this ESS based on previous scans to speed up
5747 * common load balancing use case.
5749 os_free(wpa_s->next_scan_freqs);
5750 wpa_s->next_scan_freqs = freqs;
5755 * Add previous failure count in case the temporary blacklist was
5756 * cleared due to no other BSSes being available.
5758 count += wpa_s->extra_blacklist_count;
5760 if (count > 3 && wpa_s->current_ssid) {
5761 wpa_printf(MSG_DEBUG, "Continuous association failures - "
5762 "consider temporary network disabling");
5763 wpas_auth_failed(wpa_s, "CONN_FAILED");
5784 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
5785 "ms", count, timeout);
5788 * TODO: if more than one possible AP is available in scan results,
5789 * could try the other ones before requesting a new scan.
5791 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
5792 1000 * (timeout % 1000));
5796 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
5798 return wpa_s->conf->ap_scan == 2 ||
5799 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
5803 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
5804 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
5805 struct wpa_ssid *ssid,
5809 #ifdef IEEE8021X_EAPOL
5810 struct eap_peer_config *eap = &ssid->eap;
5812 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
5813 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
5814 (const u8 *) value, os_strlen(value));
5816 switch (wpa_supplicant_ctrl_req_from_string(field)) {
5817 case WPA_CTRL_REQ_EAP_IDENTITY:
5818 os_free(eap->identity);
5819 eap->identity = (u8 *) os_strdup(value);
5820 eap->identity_len = os_strlen(value);
5821 eap->pending_req_identity = 0;
5822 if (ssid == wpa_s->current_ssid)
5823 wpa_s->reassociate = 1;
5825 case WPA_CTRL_REQ_EAP_PASSWORD:
5826 bin_clear_free(eap->password, eap->password_len);
5827 eap->password = (u8 *) os_strdup(value);
5828 eap->password_len = os_strlen(value);
5829 eap->pending_req_password = 0;
5830 if (ssid == wpa_s->current_ssid)
5831 wpa_s->reassociate = 1;
5833 case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
5834 bin_clear_free(eap->new_password, eap->new_password_len);
5835 eap->new_password = (u8 *) os_strdup(value);
5836 eap->new_password_len = os_strlen(value);
5837 eap->pending_req_new_password = 0;
5838 if (ssid == wpa_s->current_ssid)
5839 wpa_s->reassociate = 1;
5841 case WPA_CTRL_REQ_EAP_PIN:
5842 str_clear_free(eap->pin);
5843 eap->pin = os_strdup(value);
5844 eap->pending_req_pin = 0;
5845 if (ssid == wpa_s->current_ssid)
5846 wpa_s->reassociate = 1;
5848 case WPA_CTRL_REQ_EAP_OTP:
5849 bin_clear_free(eap->otp, eap->otp_len);
5850 eap->otp = (u8 *) os_strdup(value);
5851 eap->otp_len = os_strlen(value);
5852 os_free(eap->pending_req_otp);
5853 eap->pending_req_otp = NULL;
5854 eap->pending_req_otp_len = 0;
5856 case WPA_CTRL_REQ_EAP_PASSPHRASE:
5857 str_clear_free(eap->private_key_passwd);
5858 eap->private_key_passwd = os_strdup(value);
5859 eap->pending_req_passphrase = 0;
5860 if (ssid == wpa_s->current_ssid)
5861 wpa_s->reassociate = 1;
5863 case WPA_CTRL_REQ_SIM:
5864 str_clear_free(eap->external_sim_resp);
5865 eap->external_sim_resp = os_strdup(value);
5867 case WPA_CTRL_REQ_PSK_PASSPHRASE:
5868 if (wpa_config_set(ssid, "psk", value, 0) < 0)
5870 ssid->mem_only_psk = 1;
5871 if (ssid->passphrase)
5872 wpa_config_update_psk(ssid);
5873 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
5874 wpa_supplicant_req_scan(wpa_s, 0, 0);
5876 case WPA_CTRL_REQ_EXT_CERT_CHECK:
5877 if (eap->pending_ext_cert_check != PENDING_CHECK)
5879 if (os_strcmp(value, "good") == 0)
5880 eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD;
5881 else if (os_strcmp(value, "bad") == 0)
5882 eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD;
5887 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
5892 #else /* IEEE8021X_EAPOL */
5893 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
5895 #endif /* IEEE8021X_EAPOL */
5897 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
5900 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5903 unsigned int drv_enc;
5905 if (wpa_s->p2p_mgmt)
5906 return 1; /* no normal network profiles on p2p_mgmt interface */
5914 if (wpa_s->drv_capa_known)
5915 drv_enc = wpa_s->drv_enc;
5917 drv_enc = (unsigned int) -1;
5919 for (i = 0; i < NUM_WEP_KEYS; i++) {
5920 size_t len = ssid->wep_key_len[i];
5923 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
5925 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
5927 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
5929 return 1; /* invalid WEP key */
5932 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
5933 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk &&
5934 !ssid->mem_only_psk)
5941 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5943 #ifdef CONFIG_IEEE80211W
5944 if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) {
5945 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
5946 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
5948 * Driver does not support BIP -- ignore pmf=1 default
5949 * since the connection with PMF would fail and the
5950 * configuration does not require PMF to be enabled.
5952 return NO_MGMT_FRAME_PROTECTION;
5957 ~(WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPS |
5958 WPA_KEY_MGMT_IEEE8021X_NO_WPA)) == 0) {
5960 * Do not use the default PMF value for non-RSN networks
5961 * since PMF is available only with RSN and pmf=2
5962 * configuration would otherwise prevent connections to
5963 * all open networks.
5965 return NO_MGMT_FRAME_PROTECTION;
5968 return wpa_s->conf->pmf;
5971 return ssid->ieee80211w;
5972 #else /* CONFIG_IEEE80211W */
5973 return NO_MGMT_FRAME_PROTECTION;
5974 #endif /* CONFIG_IEEE80211W */
5978 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
5980 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
5982 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
5988 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
5990 struct wpa_ssid *ssid = wpa_s->current_ssid;
5992 struct os_reltime now;
5995 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
6000 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
6003 ssid->auth_failures++;
6006 if (ssid->p2p_group &&
6007 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
6009 * Skip the wait time since there is a short timeout on the
6010 * connection to a P2P group.
6014 #endif /* CONFIG_P2P */
6016 if (ssid->auth_failures > 50)
6018 else if (ssid->auth_failures > 10)
6020 else if (ssid->auth_failures > 5)
6022 else if (ssid->auth_failures > 3)
6024 else if (ssid->auth_failures > 2)
6026 else if (ssid->auth_failures > 1)
6031 if (ssid->auth_failures > 1 &&
6032 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
6033 dur += os_random() % (ssid->auth_failures * 10);
6035 os_get_reltime(&now);
6036 if (now.sec + dur <= ssid->disabled_until.sec)
6039 ssid->disabled_until.sec = now.sec + dur;
6041 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
6042 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
6043 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
6044 ssid->auth_failures, dur, reason);
6048 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
6049 struct wpa_ssid *ssid, int clear_failures)
6054 if (ssid->disabled_until.sec) {
6055 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
6056 "id=%d ssid=\"%s\"",
6057 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
6059 ssid->disabled_until.sec = 0;
6060 ssid->disabled_until.usec = 0;
6062 ssid->auth_failures = 0;
6066 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
6070 if (wpa_s->disallow_aps_bssid == NULL)
6073 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
6074 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
6075 bssid, ETH_ALEN) == 0)
6083 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
6088 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
6091 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
6092 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
6093 if (ssid_len == s->ssid_len &&
6094 os_memcmp(ssid, s->ssid, ssid_len) == 0)
6103 * wpas_request_connection - Request a new connection
6104 * @wpa_s: Pointer to the network interface
6106 * This function is used to request a new connection to be found. It will mark
6107 * the interface to allow reassociation and request a new scan to find a
6108 * suitable network to connect to.
6110 void wpas_request_connection(struct wpa_supplicant *wpa_s)
6112 wpa_s->normal_scans = 0;
6113 wpa_s->scan_req = NORMAL_SCAN_REQ;
6114 wpa_supplicant_reinit_autoscan(wpa_s);
6115 wpa_s->extra_blacklist_count = 0;
6116 wpa_s->disconnected = 0;
6117 wpa_s->reassociate = 1;
6119 if (wpa_supplicant_fast_associate(wpa_s) != 1)
6120 wpa_supplicant_req_scan(wpa_s, 0, 0);
6122 wpa_s->reattach = 0;
6127 * wpas_request_disconnection - Request disconnection
6128 * @wpa_s: Pointer to the network interface
6130 * This function is used to request disconnection from the currently connected
6131 * network. This will stop any ongoing scans and initiate deauthentication.
6133 void wpas_request_disconnection(struct wpa_supplicant *wpa_s)
6136 wpa_s->sme.prev_bssid_set = 0;
6137 #endif /* CONFIG_SME */
6138 wpa_s->reassociate = 0;
6139 wpa_s->disconnected = 1;
6140 wpa_supplicant_cancel_sched_scan(wpa_s);
6141 wpa_supplicant_cancel_scan(wpa_s);
6142 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
6143 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
6147 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
6148 struct wpa_used_freq_data *freqs_data,
6153 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
6155 for (i = 0; i < len; i++) {
6156 struct wpa_used_freq_data *cur = &freqs_data[i];
6157 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
6158 i, cur->freq, cur->flags);
6164 * Find the operating frequencies of any of the virtual interfaces that
6165 * are using the same radio as the current interface, and in addition, get
6166 * information about the interface types that are using the frequency.
6168 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
6169 struct wpa_used_freq_data *freqs_data,
6172 struct wpa_supplicant *ifs;
6175 unsigned int idx = 0, i;
6177 wpa_dbg(wpa_s, MSG_DEBUG,
6178 "Determining shared radio frequencies (max len %u)", len);
6179 os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
6181 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
6186 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
6189 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
6190 ifs->current_ssid->mode == WPAS_MODE_P2P_GO ||
6191 ifs->current_ssid->mode == WPAS_MODE_MESH)
6192 freq = ifs->current_ssid->frequency;
6193 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
6194 freq = ifs->assoc_freq;
6198 /* Hold only distinct freqs */
6199 for (i = 0; i < idx; i++)
6200 if (freqs_data[i].freq == freq)
6204 freqs_data[idx++].freq = freq;
6206 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
6207 freqs_data[i].flags |= ifs->current_ssid->p2p_group ?
6208 WPA_FREQ_USED_BY_P2P_CLIENT :
6209 WPA_FREQ_USED_BY_INFRA_STATION;
6213 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
6219 * Find the operating frequencies of any of the virtual interfaces that
6220 * are using the same radio as the current interface.
6222 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
6223 int *freq_array, unsigned int len)
6225 struct wpa_used_freq_data *freqs_data;
6228 os_memset(freq_array, 0, sizeof(int) * len);
6230 freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
6234 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
6235 for (i = 0; i < num; i++)
6236 freq_array[i] = freqs_data[i].freq;
6238 os_free(freqs_data);
6244 static void wpas_rrm_neighbor_rep_timeout_handler(void *data, void *user_ctx)
6246 struct rrm_data *rrm = data;
6248 if (!rrm->notify_neighbor_rep) {
6249 wpa_printf(MSG_ERROR,
6250 "RRM: Unexpected neighbor report timeout");
6254 wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report - NONE");
6255 rrm->notify_neighbor_rep(rrm->neighbor_rep_cb_ctx, NULL);
6257 rrm->notify_neighbor_rep = NULL;
6258 rrm->neighbor_rep_cb_ctx = NULL;
6263 * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant
6264 * @wpa_s: Pointer to wpa_supplicant
6266 void wpas_rrm_reset(struct wpa_supplicant *wpa_s)
6268 wpa_s->rrm.rrm_used = 0;
6270 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
6272 if (wpa_s->rrm.notify_neighbor_rep)
6273 wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL);
6274 wpa_s->rrm.next_neighbor_rep_token = 1;
6279 * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
6280 * @wpa_s: Pointer to wpa_supplicant
6281 * @report: Neighbor report buffer, prefixed by a 1-byte dialog token
6282 * @report_len: Length of neighbor report buffer
6284 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s,
6285 const u8 *report, size_t report_len)
6287 struct wpabuf *neighbor_rep;
6289 wpa_hexdump(MSG_DEBUG, "RRM: New Neighbor Report", report, report_len);
6293 if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
6294 wpa_printf(MSG_DEBUG,
6295 "RRM: Discarding neighbor report with token %d (expected %d)",
6296 report[0], wpa_s->rrm.next_neighbor_rep_token - 1);
6300 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
6303 if (!wpa_s->rrm.notify_neighbor_rep) {
6304 wpa_printf(MSG_ERROR, "RRM: Unexpected neighbor report");
6308 /* skipping the first byte, which is only an id (dialog token) */
6309 neighbor_rep = wpabuf_alloc(report_len - 1);
6310 if (neighbor_rep == NULL)
6312 wpabuf_put_data(neighbor_rep, report + 1, report_len - 1);
6313 wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)",
6315 wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
6317 wpa_s->rrm.notify_neighbor_rep = NULL;
6318 wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
6322 #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
6323 /* Workaround different, undefined for Windows, error codes used here */
6325 #define EOPNOTSUPP -1
6326 #define ECANCELED -1
6329 /* Measurement Request element + Location Subject + Maximum Age subelement */
6330 #define MEASURE_REQUEST_LCI_LEN (3 + 1 + 4)
6331 /* Measurement Request element + Location Civic Request */
6332 #define MEASURE_REQUEST_CIVIC_LEN (3 + 5)
6336 * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP
6337 * @wpa_s: Pointer to wpa_supplicant
6338 * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE
6339 * is sent in the request.
6340 * @lci: if set, neighbor request will include LCI request
6341 * @civic: if set, neighbor request will include civic location request
6342 * @cb: Callback function to be called once the requested report arrives, or
6343 * timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds.
6344 * In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's
6345 * the requester's responsibility to free it.
6346 * In the latter case NULL will be sent in 'neighbor_rep'.
6347 * @cb_ctx: Context value to send the callback function
6348 * Returns: 0 in case of success, negative error code otherwise
6350 * In case there is a previous request which has not been answered yet, the
6351 * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT.
6352 * Request must contain a callback function.
6354 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s,
6355 const struct wpa_ssid_value *ssid,
6357 void (*cb)(void *ctx,
6358 struct wpabuf *neighbor_rep),
6364 if (wpa_s->wpa_state != WPA_COMPLETED || wpa_s->current_ssid == NULL) {
6365 wpa_printf(MSG_DEBUG, "RRM: No connection, no RRM.");
6369 if (!wpa_s->rrm.rrm_used) {
6370 wpa_printf(MSG_DEBUG, "RRM: No RRM in current connection.");
6374 rrm_ie = wpa_bss_get_ie(wpa_s->current_bss,
6375 WLAN_EID_RRM_ENABLED_CAPABILITIES);
6376 if (!rrm_ie || !(wpa_s->current_bss->caps & IEEE80211_CAP_RRM) ||
6377 !(rrm_ie[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
6378 wpa_printf(MSG_DEBUG,
6379 "RRM: No network support for Neighbor Report.");
6384 wpa_printf(MSG_DEBUG,
6385 "RRM: Neighbor Report request must provide a callback.");
6389 /* Refuse if there's a live request */
6390 if (wpa_s->rrm.notify_neighbor_rep) {
6391 wpa_printf(MSG_DEBUG,
6392 "RRM: Currently handling previous Neighbor Report.");
6396 /* 3 = action category + action code + dialog token */
6397 buf = wpabuf_alloc(3 + (ssid ? 2 + ssid->ssid_len : 0) +
6398 (lci ? 2 + MEASURE_REQUEST_LCI_LEN : 0) +
6399 (civic ? 2 + MEASURE_REQUEST_CIVIC_LEN : 0));
6401 wpa_printf(MSG_DEBUG,
6402 "RRM: Failed to allocate Neighbor Report Request");
6406 wpa_printf(MSG_DEBUG, "RRM: Neighbor report request (for %s), token=%d",
6407 (ssid ? wpa_ssid_txt(ssid->ssid, ssid->ssid_len) : ""),
6408 wpa_s->rrm.next_neighbor_rep_token);
6410 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6411 wpabuf_put_u8(buf, WLAN_RRM_NEIGHBOR_REPORT_REQUEST);
6412 wpabuf_put_u8(buf, wpa_s->rrm.next_neighbor_rep_token);
6414 wpabuf_put_u8(buf, WLAN_EID_SSID);
6415 wpabuf_put_u8(buf, ssid->ssid_len);
6416 wpabuf_put_data(buf, ssid->ssid, ssid->ssid_len);
6420 /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */
6421 wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST);
6422 wpabuf_put_u8(buf, MEASURE_REQUEST_LCI_LEN);
6425 * Measurement token; nonzero number that is unique among the
6426 * Measurement Request elements in a particular frame.
6428 wpabuf_put_u8(buf, 1); /* Measurement Token */
6431 * Parallel, Enable, Request, and Report bits are 0, Duration is
6434 wpabuf_put_u8(buf, 0); /* Measurement Request Mode */
6435 wpabuf_put_u8(buf, MEASURE_TYPE_LCI); /* Measurement Type */
6437 /* IEEE P802.11-REVmc/D5.0 9.4.2.21.10 - LCI request */
6438 /* Location Subject */
6439 wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE);
6441 /* Optional Subelements */
6443 * IEEE P802.11-REVmc/D5.0 Figure 9-170
6444 * The Maximum Age subelement is required, otherwise the AP can
6445 * send only data that was determined after receiving the
6446 * request. Setting it here to unlimited age.
6448 wpabuf_put_u8(buf, LCI_REQ_SUBELEM_MAX_AGE);
6449 wpabuf_put_u8(buf, 2);
6450 wpabuf_put_le16(buf, 0xffff);
6454 /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */
6455 wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST);
6456 wpabuf_put_u8(buf, MEASURE_REQUEST_CIVIC_LEN);
6459 * Measurement token; nonzero number that is unique among the
6460 * Measurement Request elements in a particular frame.
6462 wpabuf_put_u8(buf, 2); /* Measurement Token */
6465 * Parallel, Enable, Request, and Report bits are 0, Duration is
6468 wpabuf_put_u8(buf, 0); /* Measurement Request Mode */
6469 /* Measurement Type */
6470 wpabuf_put_u8(buf, MEASURE_TYPE_LOCATION_CIVIC);
6472 /* IEEE P802.11-REVmc/D5.0 9.4.2.21.14:
6473 * Location Civic request */
6474 /* Location Subject */
6475 wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE);
6476 wpabuf_put_u8(buf, 0); /* Civic Location Type: IETF RFC 4776 */
6477 /* Location Service Interval Units: Seconds */
6478 wpabuf_put_u8(buf, 0);
6479 /* Location Service Interval: 0 - Only one report is requested
6481 wpabuf_put_le16(buf, 0);
6482 /* No optional subelements */
6485 wpa_s->rrm.next_neighbor_rep_token++;
6487 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
6488 wpa_s->own_addr, wpa_s->bssid,
6489 wpabuf_head(buf), wpabuf_len(buf), 0) < 0) {
6490 wpa_printf(MSG_DEBUG,
6491 "RRM: Failed to send Neighbor Report Request");
6496 wpa_s->rrm.neighbor_rep_cb_ctx = cb_ctx;
6497 wpa_s->rrm.notify_neighbor_rep = cb;
6498 eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT, 0,
6499 wpas_rrm_neighbor_rep_timeout_handler,
6507 static struct wpabuf * wpas_rrm_build_lci_report(struct wpa_supplicant *wpa_s,
6508 const u8 *request, size_t len,
6509 struct wpabuf *report)
6511 u8 token, type, subject;
6513 struct os_reltime t, diff;
6514 unsigned long diff_l;
6518 if (!wpa_s->lci || len < 3 + 4)
6522 /* Measurement request mode isn't used */
6525 subject = *request++;
6527 wpa_printf(MSG_DEBUG,
6528 "Measurement request token %u type %u location subject %u",
6529 token, type, subject);
6531 if (type != MEASURE_TYPE_LCI || subject != LOCATION_SUBJECT_REMOTE) {
6532 wpa_printf(MSG_INFO,
6533 "Not building LCI report - bad type or location subject");
6537 /* Subelements are formatted exactly like elements */
6538 subelem = get_ie(request, len, LCI_REQ_SUBELEM_MAX_AGE);
6539 if (subelem && subelem[1] == 2)
6540 max_age = WPA_GET_LE16(subelem + 2);
6542 if (os_get_reltime(&t))
6545 os_reltime_sub(&t, &wpa_s->lci_time, &diff);
6546 /* LCI age is calculated in 10th of a second units. */
6547 diff_l = diff.sec * 10 + diff.usec / 100000;
6549 if (max_age != 0xffff && max_age < diff_l)
6552 if (wpabuf_resize(&report, 2 + wpabuf_len(wpa_s->lci)))
6555 wpabuf_put_u8(report, WLAN_EID_MEASURE_REPORT);
6556 wpabuf_put_u8(report, wpabuf_len(wpa_s->lci));
6557 /* We'll override user's measurement token */
6558 ptoken = wpabuf_put(report, 0);
6559 wpabuf_put_buf(report, wpa_s->lci);
6566 void wpas_rrm_handle_radio_measurement_request(struct wpa_supplicant *wpa_s,
6568 const u8 *frame, size_t len)
6570 struct wpabuf *buf, *report;
6574 if (wpa_s->wpa_state != WPA_COMPLETED) {
6575 wpa_printf(MSG_INFO,
6576 "RRM: Ignoring radio measurement request: Not associated");
6580 if (!wpa_s->rrm.rrm_used) {
6581 wpa_printf(MSG_INFO,
6582 "RRM: Ignoring radio measurement request: Not RRM network");
6587 wpa_printf(MSG_INFO,
6588 "RRM: Ignoring too short radio measurement request");
6596 /* Ignore number of repetitions because it's not used in LCI request */
6600 while ((ie = get_ie(frame, end - frame, WLAN_EID_MEASURE_REQUEST)) &&
6605 wpa_printf(MSG_DEBUG, "RRM request %d", msmt_type);
6607 switch (msmt_type) {
6608 case MEASURE_TYPE_LCI:
6609 report = wpas_rrm_build_lci_report(wpa_s, ie + 2, ie[1],
6613 wpa_printf(MSG_INFO,
6614 "RRM: Unsupported radio measurement request %d",
6619 frame = ie + ie[1] + 2;
6625 buf = wpabuf_alloc(3 + wpabuf_len(report));
6627 wpabuf_free(report);
6631 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6632 wpabuf_put_u8(buf, WLAN_RRM_RADIO_MEASUREMENT_REPORT);
6633 wpabuf_put_u8(buf, token);
6635 wpabuf_put_buf(buf, report);
6636 wpabuf_free(report);
6638 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6639 wpa_s->own_addr, wpa_s->bssid,
6640 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6641 wpa_printf(MSG_ERROR,
6642 "RRM: Radio measurement report failed: Sending Action frame failed");
6648 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s,
6650 const u8 *frame, size_t len,
6654 const struct rrm_link_measurement_request *req;
6655 struct rrm_link_measurement_report report;
6657 if (wpa_s->wpa_state != WPA_COMPLETED) {
6658 wpa_printf(MSG_INFO,
6659 "RRM: Ignoring link measurement request. Not associated");
6663 if (!wpa_s->rrm.rrm_used) {
6664 wpa_printf(MSG_INFO,
6665 "RRM: Ignoring link measurement request. Not RRM network");
6669 if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION)) {
6670 wpa_printf(MSG_INFO,
6671 "RRM: Measurement report failed. TX power insertion not supported");
6675 req = (const struct rrm_link_measurement_request *) frame;
6676 if (len < sizeof(*req)) {
6677 wpa_printf(MSG_INFO,
6678 "RRM: Link measurement report failed. Request too short");
6682 os_memset(&report, 0, sizeof(report));
6683 report.tpc.eid = WLAN_EID_TPC_REPORT;
6685 report.rsni = 255; /* 255 indicates that RSNI is not available */
6686 report.dialog_token = req->dialog_token;
6689 * It's possible to estimate RCPI based on RSSI in dBm. This
6690 * calculation will not reflect the correct value for high rates,
6691 * but it's good enough for Action frames which are transmitted
6692 * with up to 24 Mbps rates.
6695 report.rcpi = 255; /* not available */
6696 else if (rssi < -110)
6701 report.rcpi = (rssi + 110) * 2;
6703 /* action_category + action_code */
6704 buf = wpabuf_alloc(2 + sizeof(report));
6706 wpa_printf(MSG_ERROR,
6707 "RRM: Link measurement report failed. Buffer allocation failed");
6711 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6712 wpabuf_put_u8(buf, WLAN_RRM_LINK_MEASUREMENT_REPORT);
6713 wpabuf_put_data(buf, &report, sizeof(report));
6714 wpa_hexdump(MSG_DEBUG, "RRM: Link measurement report:",
6715 wpabuf_head(buf), wpabuf_len(buf));
6717 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6718 wpa_s->own_addr, wpa_s->bssid,
6719 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6720 wpa_printf(MSG_ERROR,
6721 "RRM: Link measurement report failed. Send action failed");
6727 struct wpa_supplicant *
6728 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
6732 case VENDOR_ELEM_PROBE_REQ_P2P:
6733 case VENDOR_ELEM_PROBE_RESP_P2P:
6734 case VENDOR_ELEM_PROBE_RESP_P2P_GO:
6735 case VENDOR_ELEM_BEACON_P2P_GO:
6736 case VENDOR_ELEM_P2P_PD_REQ:
6737 case VENDOR_ELEM_P2P_PD_RESP:
6738 case VENDOR_ELEM_P2P_GO_NEG_REQ:
6739 case VENDOR_ELEM_P2P_GO_NEG_RESP:
6740 case VENDOR_ELEM_P2P_GO_NEG_CONF:
6741 case VENDOR_ELEM_P2P_INV_REQ:
6742 case VENDOR_ELEM_P2P_INV_RESP:
6743 case VENDOR_ELEM_P2P_ASSOC_REQ:
6744 case VENDOR_ELEM_P2P_ASSOC_RESP:
6745 return wpa_s->p2pdev;
6746 #endif /* CONFIG_P2P */
6753 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
6758 wpa_printf(MSG_DEBUG, "Update vendor elements");
6760 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
6761 if (wpa_s->vendor_elem[i]) {
6764 res = os_snprintf(buf, sizeof(buf), "frame[%u]", i);
6765 if (!os_snprintf_error(sizeof(buf), res)) {
6766 wpa_hexdump_buf(MSG_DEBUG, buf,
6767 wpa_s->vendor_elem[i]);
6773 if (wpa_s->parent == wpa_s &&
6774 wpa_s->global->p2p &&
6775 !wpa_s->global->p2p_disabled)
6776 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
6777 #endif /* CONFIG_P2P */
6781 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
6782 const u8 *elem, size_t len)
6786 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
6787 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
6789 for (; ie + 1 < end; ie += 2 + ie[1]) {
6792 if (os_memcmp(ie, elem, len) != 0)
6795 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
6796 wpabuf_free(wpa_s->vendor_elem[frame]);
6797 wpa_s->vendor_elem[frame] = NULL;
6799 os_memmove(ie, ie + len, end - (ie + len));
6800 wpa_s->vendor_elem[frame]->used -= len;
6802 wpas_vendor_elem_update(wpa_s);
6810 struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
6811 u16 num_modes, enum hostapd_hw_mode mode)
6815 for (i = 0; i < num_modes; i++) {
6816 if (modes[i].mode == mode)
6825 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
6828 struct wpa_bss_tmp_disallowed *bss;
6830 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
6831 struct wpa_bss_tmp_disallowed, list) {
6832 if (os_memcmp(bssid, bss->bssid, ETH_ALEN) == 0)
6840 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
6843 struct wpa_bss_tmp_disallowed *bss;
6844 struct os_reltime until;
6846 os_get_reltime(&until);
6849 bss = wpas_get_disallowed_bss(wpa_s, bssid);
6851 bss->disallowed_until = until;
6855 bss = os_malloc(sizeof(*bss));
6857 wpa_printf(MSG_DEBUG,
6858 "Failed to allocate memory for temp disallow BSS");
6862 bss->disallowed_until = until;
6863 os_memcpy(bss->bssid, bssid, ETH_ALEN);
6864 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
6868 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s, const u8 *bssid)
6870 struct wpa_bss_tmp_disallowed *bss = NULL, *tmp, *prev;
6871 struct os_reltime now, age;
6873 os_get_reltime(&now);
6875 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
6876 struct wpa_bss_tmp_disallowed, list) {
6877 if (!os_reltime_before(&now, &tmp->disallowed_until)) {
6878 /* This BSS is not disallowed anymore */
6879 dl_list_del(&tmp->list);
6883 if (os_memcmp(bssid, tmp->bssid, ETH_ALEN) == 0) {
6891 os_reltime_sub(&bss->disallowed_until, &now, &age);
6892 wpa_printf(MSG_DEBUG,
6893 "BSS " MACSTR " disabled for %ld.%0ld seconds",
6894 MAC2STR(bss->bssid), age.sec, age.usec);