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 */
1463 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1468 if (len < wpa_s->extended_capa_len)
1469 len = wpa_s->extended_capa_len;
1470 if (buflen < (size_t) len + 2) {
1471 wpa_printf(MSG_INFO,
1472 "Not enough room for building extended capabilities element");
1476 *pos++ = WLAN_EID_EXT_CAPAB;
1478 for (i = 0; i < len; i++, pos++) {
1479 wpas_ext_capab_byte(wpa_s, pos, i);
1481 if (i < wpa_s->extended_capa_len) {
1482 *pos &= ~wpa_s->extended_capa_mask[i];
1483 *pos |= wpa_s->extended_capa[i];
1487 while (len > 0 && buf[1 + len] == 0) {
1498 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1499 struct wpa_bss *test_bss)
1501 struct wpa_bss *bss;
1503 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1504 if (bss == test_bss)
1512 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1513 struct wpa_ssid *test_ssid)
1515 struct wpa_ssid *ssid;
1517 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1518 if (ssid == test_ssid)
1526 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1527 struct wpa_ssid *test_ssid)
1529 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1532 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1536 void wpas_connect_work_free(struct wpa_connect_work *cwork)
1544 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1546 struct wpa_connect_work *cwork;
1547 struct wpa_radio_work *work = wpa_s->connect_work;
1552 wpa_s->connect_work = NULL;
1555 wpas_connect_work_free(cwork);
1556 radio_work_done(work);
1560 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1562 struct os_reltime now;
1565 os_get_reltime(&now);
1566 if (wpa_s->last_mac_addr_style == style &&
1567 wpa_s->last_mac_addr_change.sec != 0 &&
1568 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1569 wpa_s->conf->rand_addr_lifetime)) {
1570 wpa_msg(wpa_s, MSG_DEBUG,
1571 "Previously selected random MAC address has not yet expired");
1577 if (random_mac_addr(addr) < 0)
1581 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1582 if (random_mac_addr_keep_oui(addr) < 0)
1589 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1590 wpa_msg(wpa_s, MSG_INFO,
1591 "Failed to set random MAC address");
1595 os_get_reltime(&wpa_s->last_mac_addr_change);
1596 wpa_s->mac_addr_changed = 1;
1597 wpa_s->last_mac_addr_style = style;
1599 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1600 wpa_msg(wpa_s, MSG_INFO,
1601 "Could not update MAC address information");
1605 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1612 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1614 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1615 !wpa_s->conf->preassoc_mac_addr)
1618 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1622 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit);
1625 * wpa_supplicant_associate - Request association
1626 * @wpa_s: Pointer to wpa_supplicant data
1627 * @bss: Scan results for the selected BSS, or %NULL if not available
1628 * @ssid: Configuration data for the selected network
1630 * This function is used to request %wpa_supplicant to associate with a BSS.
1632 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1633 struct wpa_bss *bss, struct wpa_ssid *ssid)
1635 struct wpa_connect_work *cwork;
1638 wpa_s->own_disconnect_req = 0;
1641 * If we are starting a new connection, any previously pending EAPOL
1642 * RX cannot be valid anymore.
1644 wpabuf_free(wpa_s->pending_eapol_rx);
1645 wpa_s->pending_eapol_rx = NULL;
1647 if (ssid->mac_addr == -1)
1648 rand_style = wpa_s->conf->mac_addr;
1650 rand_style = ssid->mac_addr;
1652 wmm_ac_clear_saved_tspecs(wpa_s);
1653 wpa_s->reassoc_same_bss = 0;
1654 wpa_s->reassoc_same_ess = 0;
1656 if (wpa_s->last_ssid == ssid) {
1657 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1658 wpa_s->reassoc_same_ess = 1;
1659 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1660 wmm_ac_save_tspecs(wpa_s);
1661 wpa_s->reassoc_same_bss = 1;
1663 } else if (rand_style > 0) {
1664 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1666 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1667 } else if (wpa_s->mac_addr_changed) {
1668 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1669 wpa_msg(wpa_s, MSG_INFO,
1670 "Could not restore permanent MAC address");
1673 wpa_s->mac_addr_changed = 0;
1674 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1675 wpa_msg(wpa_s, MSG_INFO,
1676 "Could not update MAC address information");
1679 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1681 wpa_s->last_ssid = ssid;
1683 #ifdef CONFIG_IBSS_RSN
1684 ibss_rsn_deinit(wpa_s->ibss_rsn);
1685 wpa_s->ibss_rsn = NULL;
1686 #endif /* CONFIG_IBSS_RSN */
1688 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO ||
1689 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1691 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1692 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1696 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1697 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1698 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
1699 wpas_p2p_ap_setup_failed(wpa_s);
1702 wpa_s->current_bss = bss;
1703 #else /* CONFIG_AP */
1704 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1706 #endif /* CONFIG_AP */
1710 if (ssid->mode == WPAS_MODE_MESH) {
1712 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
1713 wpa_msg(wpa_s, MSG_INFO,
1714 "Driver does not support mesh mode");
1718 ssid->frequency = bss->freq;
1719 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
1720 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
1723 wpa_s->current_bss = bss;
1724 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_STARTED "ssid=\"%s\" id=%d",
1725 wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
1727 #else /* CONFIG_MESH */
1728 wpa_msg(wpa_s, MSG_ERROR,
1729 "mesh mode support not included in the build");
1730 #endif /* CONFIG_MESH */
1736 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1738 #endif /* CONFIG_TDLS */
1740 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1741 ssid->mode == IEEE80211_MODE_INFRA) {
1742 sme_authenticate(wpa_s, bss, ssid);
1746 if (wpa_s->connect_work) {
1747 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1751 if (radio_work_pending(wpa_s, "connect")) {
1752 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1756 wpas_abort_ongoing_scan(wpa_s);
1758 cwork = os_zalloc(sizeof(*cwork));
1765 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1766 wpas_start_assoc_cb, cwork) < 0) {
1772 static int bss_is_ibss(struct wpa_bss *bss)
1774 return (bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) ==
1779 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
1780 const struct wpa_ssid *ssid)
1782 enum hostapd_hw_mode hw_mode;
1783 struct hostapd_hw_modes *mode = NULL;
1787 #ifdef CONFIG_HT_OVERRIDES
1788 if (ssid->disable_ht)
1790 #endif /* CONFIG_HT_OVERRIDES */
1792 hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel);
1793 if (hw_mode == NUM_HOSTAPD_MODES)
1795 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1796 if (wpa_s->hw.modes[i].mode == hw_mode) {
1797 mode = &wpa_s->hw.modes[i];
1805 return mode->vht_capab != 0;
1809 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
1810 const struct wpa_ssid *ssid,
1811 struct hostapd_freq_params *freq)
1813 enum hostapd_hw_mode hw_mode;
1814 struct hostapd_hw_modes *mode = NULL;
1815 int ht40plus[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1817 int vht80[] = { 36, 52, 100, 116, 132, 149 };
1818 struct hostapd_channel_data *pri_chan = NULL, *sec_chan = NULL;
1820 int i, chan_idx, ht40 = -1, res, obss_scan = 1;
1822 struct hostapd_freq_params vht_freq;
1823 int chwidth, seg0, seg1;
1826 freq->freq = ssid->frequency;
1828 for (j = 0; j < wpa_s->last_scan_res_used; j++) {
1829 struct wpa_bss *bss = wpa_s->last_scan_res[j];
1831 if (ssid->mode != WPAS_MODE_IBSS)
1834 /* Don't adjust control freq in case of fixed_freq */
1835 if (ssid->fixed_freq)
1838 if (!bss_is_ibss(bss))
1841 if (ssid->ssid_len == bss->ssid_len &&
1842 os_memcmp(ssid->ssid, bss->ssid, bss->ssid_len) == 0) {
1843 wpa_printf(MSG_DEBUG,
1844 "IBSS already found in scan results, adjust control freq: %d",
1846 freq->freq = bss->freq;
1852 /* For IBSS check HT_IBSS flag */
1853 if (ssid->mode == WPAS_MODE_IBSS &&
1854 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
1857 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
1858 wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
1859 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
1860 wpa_printf(MSG_DEBUG,
1861 "IBSS: WEP/TKIP detected, do not try to enable HT");
1865 hw_mode = ieee80211_freq_to_chan(freq->freq, &channel);
1866 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1867 if (wpa_s->hw.modes[i].mode == hw_mode) {
1868 mode = &wpa_s->hw.modes[i];
1876 #ifdef CONFIG_HT_OVERRIDES
1877 if (ssid->disable_ht) {
1878 freq->ht_enabled = 0;
1881 #endif /* CONFIG_HT_OVERRIDES */
1883 freq->ht_enabled = ht_supported(mode);
1884 if (!freq->ht_enabled)
1887 /* Setup higher BW only for 5 GHz */
1888 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
1891 for (chan_idx = 0; chan_idx < mode->num_channels; chan_idx++) {
1892 pri_chan = &mode->channels[chan_idx];
1893 if (pri_chan->chan == channel)
1900 /* Check primary channel flags */
1901 if (pri_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1904 /* Check/setup HT40+/HT40- */
1905 for (j = 0; j < ARRAY_SIZE(ht40plus); j++) {
1906 if (ht40plus[j] == channel) {
1912 /* Find secondary channel */
1913 for (i = 0; i < mode->num_channels; i++) {
1914 sec_chan = &mode->channels[i];
1915 if (sec_chan->chan == channel + ht40 * 4)
1922 /* Check secondary channel flags */
1923 if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1926 freq->channel = pri_chan->chan;
1930 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS))
1932 freq->sec_channel_offset = -1;
1935 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS))
1937 freq->sec_channel_offset = 1;
1943 if (freq->sec_channel_offset && obss_scan) {
1944 struct wpa_scan_results *scan_res;
1946 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
1947 if (scan_res == NULL) {
1949 freq->sec_channel_offset = 0;
1953 res = check_40mhz_5g(mode, scan_res, pri_chan->chan,
1958 freq->sec_channel_offset = 0;
1961 /* Configuration allowed */
1964 /* Switch pri/sec channels */
1965 freq->freq = hw_get_freq(mode, sec_chan->chan);
1966 freq->sec_channel_offset = -freq->sec_channel_offset;
1967 freq->channel = sec_chan->chan;
1970 freq->sec_channel_offset = 0;
1974 wpa_scan_results_free(scan_res);
1977 wpa_printf(MSG_DEBUG,
1978 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
1979 freq->channel, freq->sec_channel_offset);
1981 if (!drv_supports_vht(wpa_s, ssid))
1984 /* For IBSS check VHT_IBSS flag */
1985 if (ssid->mode == WPAS_MODE_IBSS &&
1986 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
1991 vht_freq.vht_enabled = vht_supported(mode);
1992 if (!vht_freq.vht_enabled)
1995 /* setup center_freq1, bandwidth */
1996 for (j = 0; j < ARRAY_SIZE(vht80); j++) {
1997 if (freq->channel >= vht80[j] &&
1998 freq->channel < vht80[j] + 16)
2002 if (j == ARRAY_SIZE(vht80))
2005 for (i = vht80[j]; i < vht80[j] + 16; i += 4) {
2006 struct hostapd_channel_data *chan;
2008 chan = hw_get_channel_chan(mode, i, NULL);
2012 /* Back to HT configuration if channel not usable */
2013 if (chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
2017 chwidth = VHT_CHANWIDTH_80MHZ;
2018 seg0 = vht80[j] + 6;
2021 if (ssid->max_oper_chwidth == VHT_CHANWIDTH_80P80MHZ) {
2022 /* setup center_freq2, bandwidth */
2023 for (k = 0; k < ARRAY_SIZE(vht80); k++) {
2024 /* Only accept 80 MHz segments separated by a gap */
2025 if (j == k || abs(vht80[j] - vht80[k]) == 16)
2027 for (i = vht80[k]; i < vht80[k] + 16; i += 4) {
2028 struct hostapd_channel_data *chan;
2030 chan = hw_get_channel_chan(mode, i, NULL);
2034 if (chan->flag & (HOSTAPD_CHAN_DISABLED |
2035 HOSTAPD_CHAN_NO_IR |
2036 HOSTAPD_CHAN_RADAR))
2039 /* Found a suitable second segment for 80+80 */
2040 chwidth = VHT_CHANWIDTH_80P80MHZ;
2042 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
2043 seg1 = vht80[k] + 6;
2046 if (chwidth == VHT_CHANWIDTH_80P80MHZ)
2049 } else if (ssid->max_oper_chwidth == VHT_CHANWIDTH_160MHZ) {
2050 if (freq->freq == 5180) {
2051 chwidth = VHT_CHANWIDTH_160MHZ;
2052 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2054 } else if (freq->freq == 5520) {
2055 chwidth = VHT_CHANWIDTH_160MHZ;
2056 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2061 if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq,
2062 freq->channel, freq->ht_enabled,
2063 vht_freq.vht_enabled,
2064 freq->sec_channel_offset,
2065 chwidth, seg0, seg1, vht_caps) != 0)
2070 wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
2071 freq->center_freq1, freq->center_freq2, freq->bandwidth);
2075 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
2077 struct wpa_connect_work *cwork = work->ctx;
2078 struct wpa_bss *bss = cwork->bss;
2079 struct wpa_ssid *ssid = cwork->ssid;
2080 struct wpa_supplicant *wpa_s = work->wpa_s;
2083 int use_crypt, ret, i, bssid_changed;
2084 int algs = WPA_AUTH_ALG_OPEN;
2085 unsigned int cipher_pairwise, cipher_group;
2086 struct wpa_driver_associate_params params;
2087 int wep_keys_set = 0;
2088 int assoc_failed = 0;
2089 struct wpa_ssid *old_ssid;
2090 u8 prev_bssid[ETH_ALEN];
2091 #ifdef CONFIG_HT_OVERRIDES
2092 struct ieee80211_ht_capabilities htcaps;
2093 struct ieee80211_ht_capabilities htcaps_mask;
2094 #endif /* CONFIG_HT_OVERRIDES */
2095 #ifdef CONFIG_VHT_OVERRIDES
2096 struct ieee80211_vht_capabilities vhtcaps;
2097 struct ieee80211_vht_capabilities vhtcaps_mask;
2098 #endif /* CONFIG_VHT_OVERRIDES */
2100 const u8 *mbo = NULL;
2101 #endif /* CONFIG_MBO */
2104 if (work->started) {
2105 wpa_s->connect_work = NULL;
2107 /* cancel possible auth. timeout */
2108 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
2111 wpas_connect_work_free(cwork);
2115 wpa_s->connect_work = work;
2117 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
2118 wpas_network_disabled(wpa_s, ssid)) {
2119 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2120 wpas_connect_work_done(wpa_s);
2124 os_memcpy(prev_bssid, wpa_s->bssid, ETH_ALEN);
2125 os_memset(¶ms, 0, sizeof(params));
2126 wpa_s->reassociate = 0;
2127 wpa_s->eap_expected_failure = 0;
2129 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
2130 #ifdef CONFIG_IEEE80211R
2131 const u8 *ie, *md = NULL;
2132 #endif /* CONFIG_IEEE80211R */
2133 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
2134 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
2135 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
2136 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
2137 os_memset(wpa_s->bssid, 0, ETH_ALEN);
2138 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2140 wpas_notify_bssid_changed(wpa_s);
2141 #ifdef CONFIG_IEEE80211R
2142 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
2143 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
2145 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
2147 /* Prepare for the next transition */
2148 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
2150 #endif /* CONFIG_IEEE80211R */
2152 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
2153 wpa_s->conf->ap_scan == 2 &&
2154 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
2155 /* Use ap_scan==1 style network selection to find the network
2157 wpas_connect_work_done(wpa_s);
2158 wpa_s->scan_req = MANUAL_SCAN_REQ;
2159 wpa_s->reassociate = 1;
2160 wpa_supplicant_req_scan(wpa_s, 0, 0);
2162 #endif /* CONFIG_WPS */
2164 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
2165 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2166 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2169 wpa_supplicant_cancel_sched_scan(wpa_s);
2171 wpa_supplicant_cancel_scan(wpa_s);
2173 /* Starting new association, so clear the possibly used WPA IE from the
2174 * previous association. */
2175 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
2177 #ifdef IEEE8021X_EAPOL
2178 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2180 if (ssid->non_leap == 0)
2181 algs = WPA_AUTH_ALG_LEAP;
2183 algs |= WPA_AUTH_ALG_LEAP;
2186 #endif /* IEEE8021X_EAPOL */
2187 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2188 if (ssid->auth_alg) {
2189 algs = ssid->auth_alg;
2190 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
2194 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
2195 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
2196 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
2197 int try_opportunistic;
2198 try_opportunistic = (ssid->proactive_key_caching < 0 ?
2200 ssid->proactive_key_caching) &&
2201 (ssid->proto & WPA_PROTO_RSN);
2202 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2203 ssid, try_opportunistic) == 0)
2204 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2205 wpa_ie_len = sizeof(wpa_ie);
2206 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2207 wpa_ie, &wpa_ie_len)) {
2208 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2209 "key management and encryption suites");
2210 wpas_connect_work_done(wpa_s);
2213 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
2214 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
2216 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2217 * use non-WPA since the scan results did not indicate that the
2218 * AP is using WPA or WPA2.
2220 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2222 wpa_s->wpa_proto = 0;
2223 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
2224 wpa_ie_len = sizeof(wpa_ie);
2225 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2226 wpa_ie, &wpa_ie_len)) {
2227 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2228 "key management and encryption suites (no "
2230 wpas_connect_work_done(wpa_s);
2234 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
2235 struct wpabuf *wps_ie;
2236 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
2237 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
2238 wpa_ie_len = wpabuf_len(wps_ie);
2239 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
2242 wpabuf_free(wps_ie);
2243 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2244 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
2245 params.wps = WPS_MODE_PRIVACY;
2247 params.wps = WPS_MODE_OPEN;
2248 wpa_s->wpa_proto = 0;
2249 #endif /* CONFIG_WPS */
2251 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2253 wpa_s->wpa_proto = 0;
2257 if (wpa_s->global->p2p) {
2261 pos = wpa_ie + wpa_ie_len;
2262 len = sizeof(wpa_ie) - wpa_ie_len;
2263 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2269 wpa_s->cross_connect_disallowed = 0;
2272 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
2274 wpa_s->cross_connect_disallowed =
2275 p2p_get_cross_connect_disallowed(p2p);
2277 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2279 wpa_s->cross_connect_disallowed ?
2280 "disallows" : "allows");
2284 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2285 #endif /* CONFIG_P2P */
2289 mbo = wpa_bss_get_vendor_ie(bss, MBO_IE_VENDOR_TYPE);
2293 len = wpas_mbo_supp_op_class_ie(wpa_s, bss->freq,
2294 wpa_ie + wpa_ie_len,
2301 #endif /* CONFIG_MBO */
2304 * Workaround: Add Extended Capabilities element only if the AP
2305 * included this element in Beacon/Probe Response frames. Some older
2306 * APs seem to have interoperability issues if this element is
2307 * included, so while the standard may require us to include the
2308 * element in all cases, it is justifiable to skip it to avoid
2309 * interoperability issues.
2311 if (ssid->p2p_group)
2312 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
2314 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
2316 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
2319 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2321 if (ext_capab_len > 0) {
2323 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
2325 os_memmove(pos + ext_capab_len, pos,
2326 wpa_ie_len - (pos - wpa_ie));
2327 wpa_ie_len += ext_capab_len;
2328 os_memcpy(pos, ext_capab, ext_capab_len);
2333 if (is_hs20_network(wpa_s, ssid, bss)) {
2334 struct wpabuf *hs20;
2336 hs20 = wpabuf_alloc(20);
2338 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2341 wpas_hs20_add_indication(hs20, pps_mo_id);
2342 len = sizeof(wpa_ie) - wpa_ie_len;
2343 if (wpabuf_len(hs20) <= len) {
2344 os_memcpy(wpa_ie + wpa_ie_len,
2345 wpabuf_head(hs20), wpabuf_len(hs20));
2346 wpa_ie_len += wpabuf_len(hs20);
2350 hs20_configure_frame_filters(wpa_s);
2353 #endif /* CONFIG_HS20 */
2355 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2356 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2359 len = sizeof(wpa_ie) - wpa_ie_len;
2360 if (wpabuf_len(buf) <= len) {
2361 os_memcpy(wpa_ie + wpa_ie_len,
2362 wpabuf_head(buf), wpabuf_len(buf));
2363 wpa_ie_len += wpabuf_len(buf);
2368 if (wpa_s->fst_ies) {
2369 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2371 if (wpa_ie_len + fst_ies_len <= sizeof(wpa_ie)) {
2372 os_memcpy(wpa_ie + wpa_ie_len,
2373 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2374 wpa_ie_len += fst_ies_len;
2377 #endif /* CONFIG_FST */
2383 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
2384 sizeof(wpa_ie) - wpa_ie_len);
2388 #endif /* CONFIG_MBO */
2390 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2392 cipher_pairwise = wpa_s->pairwise_cipher;
2393 cipher_group = wpa_s->group_cipher;
2394 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2395 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2396 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2398 if (wpa_set_wep_keys(wpa_s, ssid)) {
2403 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2406 #ifdef IEEE8021X_EAPOL
2407 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2408 if ((ssid->eapol_flags &
2409 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
2410 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
2414 /* Assume that dynamic WEP-104 keys will be used and
2415 * set cipher suites in order for drivers to expect
2417 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
2420 #endif /* IEEE8021X_EAPOL */
2422 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2423 /* Set the key before (and later after) association */
2424 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2427 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2429 params.ssid = bss->ssid;
2430 params.ssid_len = bss->ssid_len;
2431 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2432 wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
2433 MACSTR " freq=%u MHz based on scan results "
2435 MAC2STR(bss->bssid), bss->freq,
2437 params.bssid = bss->bssid;
2438 params.freq.freq = bss->freq;
2440 params.bssid_hint = bss->bssid;
2441 params.freq_hint = bss->freq;
2442 params.pbss = bss_is_pbss(bss);
2444 params.ssid = ssid->ssid;
2445 params.ssid_len = ssid->ssid_len;
2446 params.pbss = (ssid->pbss != 2) ? ssid->pbss : 0;
2449 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
2450 wpa_s->conf->ap_scan == 2) {
2451 params.bssid = ssid->bssid;
2452 params.fixed_bssid = 1;
2455 /* Initial frequency for IBSS/mesh */
2456 if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) &&
2457 ssid->frequency > 0 && params.freq.freq == 0)
2458 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
2460 if (ssid->mode == WPAS_MODE_IBSS) {
2461 params.fixed_freq = ssid->fixed_freq;
2462 if (ssid->beacon_int)
2463 params.beacon_int = ssid->beacon_int;
2465 params.beacon_int = wpa_s->conf->beacon_int;
2468 params.wpa_ie = wpa_ie;
2469 params.wpa_ie_len = wpa_ie_len;
2470 params.pairwise_suite = cipher_pairwise;
2471 params.group_suite = cipher_group;
2472 params.key_mgmt_suite = wpa_s->key_mgmt;
2473 params.wpa_proto = wpa_s->wpa_proto;
2474 params.auth_alg = algs;
2475 params.mode = ssid->mode;
2476 params.bg_scan_period = ssid->bg_scan_period;
2477 for (i = 0; i < NUM_WEP_KEYS; i++) {
2478 if (ssid->wep_key_len[i])
2479 params.wep_key[i] = ssid->wep_key[i];
2480 params.wep_key_len[i] = ssid->wep_key_len[i];
2482 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
2484 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2485 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2486 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
2487 params.passphrase = ssid->passphrase;
2489 params.psk = ssid->psk;
2492 if (wpa_s->conf->key_mgmt_offload) {
2493 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
2494 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
2495 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
2496 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
2497 params.req_key_mgmt_offload =
2498 ssid->proactive_key_caching < 0 ?
2499 wpa_s->conf->okc : ssid->proactive_key_caching;
2501 params.req_key_mgmt_offload = 1;
2503 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2504 params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
2505 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
2507 params.psk = ssid->psk;
2510 params.drop_unencrypted = use_crypt;
2512 #ifdef CONFIG_IEEE80211W
2513 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
2514 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
2515 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2516 struct wpa_ie_data ie;
2517 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
2519 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
2520 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2521 "MFP: require MFP");
2522 params.mgmt_frame_protection =
2523 MGMT_FRAME_PROTECTION_REQUIRED;
2526 #endif /* CONFIG_IEEE80211W */
2528 params.p2p = ssid->p2p_group;
2530 if (wpa_s->p2pdev->set_sta_uapsd)
2531 params.uapsd = wpa_s->p2pdev->sta_uapsd;
2535 #ifdef CONFIG_HT_OVERRIDES
2536 os_memset(&htcaps, 0, sizeof(htcaps));
2537 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
2538 params.htcaps = (u8 *) &htcaps;
2539 params.htcaps_mask = (u8 *) &htcaps_mask;
2540 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
2541 #endif /* CONFIG_HT_OVERRIDES */
2542 #ifdef CONFIG_VHT_OVERRIDES
2543 os_memset(&vhtcaps, 0, sizeof(vhtcaps));
2544 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
2545 params.vhtcaps = &vhtcaps;
2546 params.vhtcaps_mask = &vhtcaps_mask;
2547 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms);
2548 #endif /* CONFIG_VHT_OVERRIDES */
2552 * If multi-channel concurrency is not supported, check for any
2553 * frequency conflict. In case of any frequency conflict, remove the
2554 * least prioritized connection.
2556 if (wpa_s->num_multichan_concurrent < 2) {
2558 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2559 if (num > 0 && freq > 0 && freq != params.freq.freq) {
2560 wpa_printf(MSG_DEBUG,
2561 "Assoc conflicting freq found (%d != %d)",
2562 freq, params.freq.freq);
2563 if (wpas_p2p_handle_frequency_conflicts(
2564 wpa_s, params.freq.freq, ssid) < 0) {
2565 wpas_connect_work_done(wpa_s);
2570 #endif /* CONFIG_P2P */
2572 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
2573 wpa_s->current_ssid)
2574 params.prev_bssid = prev_bssid;
2576 ret = wpa_drv_associate(wpa_s, ¶ms);
2578 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2580 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2582 * The driver is known to mean what is saying, so we
2583 * can stop right here; the association will not
2586 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2587 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2588 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2591 /* try to continue anyway; new association will be tried again
2596 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2597 /* Set the key after the association just in case association
2598 * cleared the previously configured key. */
2599 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2600 /* No need to timeout authentication since there is no key
2602 wpa_supplicant_cancel_auth_timeout(wpa_s);
2603 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2604 #ifdef CONFIG_IBSS_RSN
2605 } else if (ssid->mode == WPAS_MODE_IBSS &&
2606 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2607 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2609 * RSN IBSS authentication is per-STA and we can disable the
2610 * per-BSSID authentication.
2612 wpa_supplicant_cancel_auth_timeout(wpa_s);
2613 #endif /* CONFIG_IBSS_RSN */
2615 /* Timeout for IEEE 802.11 authentication and association */
2619 /* give IBSS a bit more time */
2620 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2621 } else if (wpa_s->conf->ap_scan == 1) {
2622 /* give IBSS a bit more time */
2623 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2625 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2629 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2630 /* Set static WEP keys again */
2631 wpa_set_wep_keys(wpa_s, ssid);
2634 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2636 * Do not allow EAP session resumption between different
2637 * network configurations.
2639 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2641 old_ssid = wpa_s->current_ssid;
2642 wpa_s->current_ssid = ssid;
2644 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2645 wpa_s->current_bss = bss;
2647 hs20_configure_frame_filters(wpa_s);
2648 #endif /* CONFIG_HS20 */
2651 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2652 wpa_supplicant_initiate_eapol(wpa_s);
2653 if (old_ssid != wpa_s->current_ssid)
2654 wpas_notify_network_changed(wpa_s);
2658 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2661 struct wpa_ssid *old_ssid;
2663 wpas_connect_work_done(wpa_s);
2664 wpa_clear_keys(wpa_s, addr);
2665 old_ssid = wpa_s->current_ssid;
2666 wpa_supplicant_mark_disassoc(wpa_s);
2667 wpa_sm_set_config(wpa_s->wpa, NULL);
2668 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2669 if (old_ssid != wpa_s->current_ssid)
2670 wpas_notify_network_changed(wpa_s);
2671 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2676 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2677 * @wpa_s: Pointer to wpa_supplicant data
2678 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2680 * This function is used to request %wpa_supplicant to deauthenticate from the
2683 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2687 union wpa_event_data event;
2690 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2691 " pending_bssid=" MACSTR " reason=%d state=%s",
2692 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2693 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2695 if (!is_zero_ether_addr(wpa_s->bssid))
2696 addr = wpa_s->bssid;
2697 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2698 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2699 wpa_s->wpa_state == WPA_ASSOCIATING))
2700 addr = wpa_s->pending_bssid;
2701 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2703 * When using driver-based BSS selection, we may not know the
2704 * BSSID with which we are currently trying to associate. We
2705 * need to notify the driver of this disconnection even in such
2706 * a case, so use the all zeros address here.
2708 addr = wpa_s->bssid;
2713 wpa_tdls_teardown_peers(wpa_s->wpa);
2714 #endif /* CONFIG_TDLS */
2718 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
2720 wpa_supplicant_leave_mesh(wpa_s);
2722 #endif /* CONFIG_MESH */
2725 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2726 os_memset(&event, 0, sizeof(event));
2727 event.deauth_info.reason_code = (u16) reason_code;
2728 event.deauth_info.locally_generated = 1;
2729 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2734 wpa_supplicant_clear_connection(wpa_s, addr);
2737 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2738 struct wpa_ssid *ssid)
2740 if (!ssid || !ssid->disabled || ssid->disabled == 2)
2744 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2745 wpas_notify_network_enabled_changed(wpa_s, ssid);
2748 * Try to reassociate since there is no current configuration and a new
2749 * network was made available.
2751 if (!wpa_s->current_ssid && !wpa_s->disconnected)
2752 wpa_s->reassociate = 1;
2757 * wpa_supplicant_enable_network - Mark a configured network as enabled
2758 * @wpa_s: wpa_supplicant structure for a network interface
2759 * @ssid: wpa_ssid structure for a configured network or %NULL
2761 * Enables the specified network or all networks if no network specified.
2763 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2764 struct wpa_ssid *ssid)
2767 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2768 wpa_supplicant_enable_one_network(wpa_s, ssid);
2770 wpa_supplicant_enable_one_network(wpa_s, ssid);
2772 if (wpa_s->reassociate && !wpa_s->disconnected &&
2773 (!wpa_s->current_ssid ||
2774 wpa_s->wpa_state == WPA_DISCONNECTED ||
2775 wpa_s->wpa_state == WPA_SCANNING)) {
2776 if (wpa_s->sched_scanning) {
2777 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2778 "new network to scan filters");
2779 wpa_supplicant_cancel_sched_scan(wpa_s);
2782 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
2783 wpa_s->scan_req = NORMAL_SCAN_REQ;
2784 wpa_supplicant_req_scan(wpa_s, 0, 0);
2791 * wpa_supplicant_disable_network - Mark a configured network as disabled
2792 * @wpa_s: wpa_supplicant structure for a network interface
2793 * @ssid: wpa_ssid structure for a configured network or %NULL
2795 * Disables the specified network or all networks if no network specified.
2797 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2798 struct wpa_ssid *ssid)
2800 struct wpa_ssid *other_ssid;
2804 if (wpa_s->sched_scanning)
2805 wpa_supplicant_cancel_sched_scan(wpa_s);
2807 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2808 other_ssid = other_ssid->next) {
2809 was_disabled = other_ssid->disabled;
2810 if (was_disabled == 2)
2811 continue; /* do not change persistent P2P group
2814 other_ssid->disabled = 1;
2816 if (was_disabled != other_ssid->disabled)
2817 wpas_notify_network_enabled_changed(
2820 if (wpa_s->current_ssid)
2821 wpa_supplicant_deauthenticate(
2822 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2823 } else if (ssid->disabled != 2) {
2824 if (ssid == wpa_s->current_ssid)
2825 wpa_supplicant_deauthenticate(
2826 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2828 was_disabled = ssid->disabled;
2832 if (was_disabled != ssid->disabled) {
2833 wpas_notify_network_enabled_changed(wpa_s, ssid);
2834 if (wpa_s->sched_scanning) {
2835 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2836 "to remove network from filters");
2837 wpa_supplicant_cancel_sched_scan(wpa_s);
2838 wpa_supplicant_req_scan(wpa_s, 0, 0);
2846 * wpa_supplicant_select_network - Attempt association with a network
2847 * @wpa_s: wpa_supplicant structure for a network interface
2848 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2850 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2851 struct wpa_ssid *ssid)
2854 struct wpa_ssid *other_ssid;
2855 int disconnected = 0;
2857 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2858 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2859 wpa_s->own_disconnect_req = 1;
2860 wpa_supplicant_deauthenticate(
2861 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2866 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2869 * Mark all other networks disabled or mark all networks enabled if no
2870 * network specified.
2872 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2873 other_ssid = other_ssid->next) {
2874 int was_disabled = other_ssid->disabled;
2875 if (was_disabled == 2)
2876 continue; /* do not change persistent P2P group data */
2878 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
2879 if (was_disabled && !other_ssid->disabled)
2880 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2882 if (was_disabled != other_ssid->disabled)
2883 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2886 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
2887 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2888 /* We are already associated with the selected network */
2889 wpa_printf(MSG_DEBUG, "Already associated with the "
2890 "selected network - do nothing");
2895 wpa_s->current_ssid = ssid;
2896 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2897 wpa_s->connect_without_scan =
2898 (ssid->mode == WPAS_MODE_MESH) ? ssid : NULL;
2901 * Don't optimize next scan freqs since a new ESS has been
2904 os_free(wpa_s->next_scan_freqs);
2905 wpa_s->next_scan_freqs = NULL;
2907 wpa_s->connect_without_scan = NULL;
2910 wpa_s->disconnected = 0;
2911 wpa_s->reassociate = 1;
2913 if (wpa_s->connect_without_scan ||
2914 wpa_supplicant_fast_associate(wpa_s) != 1) {
2915 wpa_s->scan_req = NORMAL_SCAN_REQ;
2916 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
2920 wpas_notify_network_selected(wpa_s, ssid);
2925 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
2926 * @wpa_s: wpa_supplicant structure for a network interface
2927 * @pkcs11_engine_path: PKCS #11 engine path or NULL
2928 * @pkcs11_module_path: PKCS #11 module path or NULL
2929 * Returns: 0 on success; -1 on failure
2931 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
2932 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
2933 * module path fails the paths will be reset to the default value (NULL).
2935 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
2936 const char *pkcs11_engine_path,
2937 const char *pkcs11_module_path)
2939 char *pkcs11_engine_path_copy = NULL;
2940 char *pkcs11_module_path_copy = NULL;
2942 if (pkcs11_engine_path != NULL) {
2943 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
2944 if (pkcs11_engine_path_copy == NULL)
2947 if (pkcs11_module_path != NULL) {
2948 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
2949 if (pkcs11_module_path_copy == NULL) {
2950 os_free(pkcs11_engine_path_copy);
2955 os_free(wpa_s->conf->pkcs11_engine_path);
2956 os_free(wpa_s->conf->pkcs11_module_path);
2957 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
2958 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
2960 wpa_sm_set_eapol(wpa_s->wpa, NULL);
2961 eapol_sm_deinit(wpa_s->eapol);
2962 wpa_s->eapol = NULL;
2963 if (wpa_supplicant_init_eapol(wpa_s)) {
2964 /* Error -> Reset paths to the default value (NULL) once. */
2965 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
2966 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
2971 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
2978 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2979 * @wpa_s: wpa_supplicant structure for a network interface
2980 * @ap_scan: AP scan mode
2981 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2984 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
2989 if (ap_scan < 0 || ap_scan > 2)
2992 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
2993 wpa_printf(MSG_INFO,
2994 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
2998 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
2999 wpa_s->wpa_state >= WPA_ASSOCIATING &&
3000 wpa_s->wpa_state < WPA_COMPLETED) {
3001 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
3002 "associating", wpa_s->conf->ap_scan, ap_scan);
3005 #endif /* ANDROID */
3007 old_ap_scan = wpa_s->conf->ap_scan;
3008 wpa_s->conf->ap_scan = ap_scan;
3010 if (old_ap_scan != wpa_s->conf->ap_scan)
3011 wpas_notify_ap_scan_changed(wpa_s);
3018 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
3019 * @wpa_s: wpa_supplicant structure for a network interface
3020 * @expire_age: Expiration age in seconds
3021 * Returns: 0 if succeed or -1 if expire_age has an invalid value
3024 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
3025 unsigned int bss_expire_age)
3027 if (bss_expire_age < 10) {
3028 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
3032 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
3034 wpa_s->conf->bss_expiration_age = bss_expire_age;
3041 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
3042 * @wpa_s: wpa_supplicant structure for a network interface
3043 * @expire_count: number of scans after which an unseen BSS is reclaimed
3044 * Returns: 0 if succeed or -1 if expire_count has an invalid value
3047 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
3048 unsigned int bss_expire_count)
3050 if (bss_expire_count < 1) {
3051 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
3055 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
3057 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
3064 * wpa_supplicant_set_scan_interval - Set scan interval
3065 * @wpa_s: wpa_supplicant structure for a network interface
3066 * @scan_interval: scan interval in seconds
3067 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
3070 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
3073 if (scan_interval < 0) {
3074 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
3078 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3080 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3087 * wpa_supplicant_set_debug_params - Set global debug params
3088 * @global: wpa_global structure
3089 * @debug_level: debug level
3090 * @debug_timestamp: determines if show timestamp in debug data
3091 * @debug_show_keys: determines if show keys in debug data
3092 * Returns: 0 if succeed or -1 if debug_level has wrong value
3094 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
3095 int debug_timestamp, int debug_show_keys)
3098 int old_level, old_timestamp, old_show_keys;
3100 /* check for allowed debuglevels */
3101 if (debug_level != MSG_EXCESSIVE &&
3102 debug_level != MSG_MSGDUMP &&
3103 debug_level != MSG_DEBUG &&
3104 debug_level != MSG_INFO &&
3105 debug_level != MSG_WARNING &&
3106 debug_level != MSG_ERROR)
3109 old_level = wpa_debug_level;
3110 old_timestamp = wpa_debug_timestamp;
3111 old_show_keys = wpa_debug_show_keys;
3113 wpa_debug_level = debug_level;
3114 wpa_debug_timestamp = debug_timestamp ? 1 : 0;
3115 wpa_debug_show_keys = debug_show_keys ? 1 : 0;
3117 if (wpa_debug_level != old_level)
3118 wpas_notify_debug_level_changed(global);
3119 if (wpa_debug_timestamp != old_timestamp)
3120 wpas_notify_debug_timestamp_changed(global);
3121 if (wpa_debug_show_keys != old_show_keys)
3122 wpas_notify_debug_show_keys_changed(global);
3129 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
3130 * @wpa_s: Pointer to wpa_supplicant data
3131 * Returns: A pointer to the current network structure or %NULL on failure
3133 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
3135 struct wpa_ssid *entry;
3136 u8 ssid[SSID_MAX_LEN];
3142 res = wpa_drv_get_ssid(wpa_s, ssid);
3144 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
3150 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
3151 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
3156 wired = wpa_s->conf->ap_scan == 0 &&
3157 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
3159 entry = wpa_s->conf->ssid;
3161 if (!wpas_network_disabled(wpa_s, entry) &&
3162 ((ssid_len == entry->ssid_len &&
3163 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
3164 (!entry->bssid_set ||
3165 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3168 if (!wpas_network_disabled(wpa_s, entry) &&
3169 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
3170 (entry->ssid == NULL || entry->ssid_len == 0) &&
3171 (!entry->bssid_set ||
3172 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3174 #endif /* CONFIG_WPS */
3176 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
3177 entry->ssid_len == 0 &&
3178 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
3181 entry = entry->next;
3188 static int select_driver(struct wpa_supplicant *wpa_s, int i)
3190 struct wpa_global *global = wpa_s->global;
3192 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
3193 global->drv_priv[i] = wpa_drivers[i]->global_init(global);
3194 if (global->drv_priv[i] == NULL) {
3195 wpa_printf(MSG_ERROR, "Failed to initialize driver "
3196 "'%s'", wpa_drivers[i]->name);
3201 wpa_s->driver = wpa_drivers[i];
3202 wpa_s->global_drv_priv = global->drv_priv[i];
3208 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
3213 const char *pos, *driver = name;
3218 if (wpa_drivers[0] == NULL) {
3219 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
3225 /* default to first driver in the list */
3226 return select_driver(wpa_s, 0);
3230 pos = os_strchr(driver, ',');
3234 len = os_strlen(driver);
3236 for (i = 0; wpa_drivers[i]; i++) {
3237 if (os_strlen(wpa_drivers[i]->name) == len &&
3238 os_strncmp(driver, wpa_drivers[i]->name, len) ==
3240 /* First driver that succeeds wins */
3241 if (select_driver(wpa_s, i) == 0)
3249 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
3255 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
3256 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3257 * with struct wpa_driver_ops::init()
3258 * @src_addr: Source address of the EAPOL frame
3259 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3260 * @len: Length of the EAPOL data
3262 * This function is called for each received EAPOL frame. Most driver
3263 * interfaces rely on more generic OS mechanism for receiving frames through
3264 * l2_packet, but if such a mechanism is not available, the driver wrapper may
3265 * take care of received EAPOL frames and deliver them to the core supplicant
3266 * code by calling this function.
3268 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
3269 const u8 *buf, size_t len)
3271 struct wpa_supplicant *wpa_s = ctx;
3273 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3274 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
3276 #ifdef CONFIG_PEERKEY
3277 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
3278 wpa_s->current_ssid->peerkey &&
3279 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
3280 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
3281 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
3284 #endif /* CONFIG_PEERKEY */
3286 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3287 (wpa_s->last_eapol_matches_bssid &&
3290 #endif /* CONFIG_AP */
3291 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3293 * There is possible race condition between receiving the
3294 * association event and the EAPOL frame since they are coming
3295 * through different paths from the driver. In order to avoid
3296 * issues in trying to process the EAPOL frame before receiving
3297 * association information, lets queue it for processing until
3298 * the association event is received. This may also be needed in
3299 * driver-based roaming case, so also use src_addr != BSSID as a
3300 * trigger if we have previously confirmed that the
3301 * Authenticator uses BSSID as the src_addr (which is not the
3302 * case with wired IEEE 802.1X).
3304 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3305 "of received EAPOL frame (state=%s bssid=" MACSTR ")",
3306 wpa_supplicant_state_txt(wpa_s->wpa_state),
3307 MAC2STR(wpa_s->bssid));
3308 wpabuf_free(wpa_s->pending_eapol_rx);
3309 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3310 if (wpa_s->pending_eapol_rx) {
3311 os_get_reltime(&wpa_s->pending_eapol_rx_time);
3312 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3318 wpa_s->last_eapol_matches_bssid =
3319 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3322 if (wpa_s->ap_iface) {
3323 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3326 #endif /* CONFIG_AP */
3328 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3329 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3330 "no key management is configured");
3334 if (wpa_s->eapol_received == 0 &&
3335 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3336 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3337 wpa_s->wpa_state != WPA_COMPLETED) &&
3338 (wpa_s->current_ssid == NULL ||
3339 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3340 /* Timeout for completing IEEE 802.1X and WPA authentication */
3343 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3344 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3345 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3346 /* Use longer timeout for IEEE 802.1X/EAP */
3351 if (wpa_s->current_ssid && wpa_s->current_bss &&
3352 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3353 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3355 * Use shorter timeout if going through WPS AP iteration
3356 * for PIN config method with an AP that does not
3357 * advertise Selected Registrar.
3359 struct wpabuf *wps_ie;
3361 wps_ie = wpa_bss_get_vendor_ie_multi(
3362 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3364 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3366 wpabuf_free(wps_ie);
3368 #endif /* CONFIG_WPS */
3370 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3372 wpa_s->eapol_received++;
3374 if (wpa_s->countermeasures) {
3375 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3380 #ifdef CONFIG_IBSS_RSN
3381 if (wpa_s->current_ssid &&
3382 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3383 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3386 #endif /* CONFIG_IBSS_RSN */
3388 /* Source address of the incoming EAPOL frame could be compared to the
3389 * current BSSID. However, it is possible that a centralized
3390 * Authenticator could be using another MAC address than the BSSID of
3391 * an AP, so just allow any address to be used for now. The replies are
3392 * still sent to the current BSSID (if available), though. */
3394 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3395 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3396 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3398 wpa_drv_poll(wpa_s);
3399 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3400 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3401 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3403 * Set portValid = TRUE here since we are going to skip 4-way
3404 * handshake processing which would normally set portValid. We
3405 * need this to allow the EAPOL state machines to be completed
3406 * without going through EAPOL-Key handshake.
3408 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3413 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3415 if ((!wpa_s->p2p_mgmt ||
3416 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3417 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3418 l2_packet_deinit(wpa_s->l2);
3419 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3420 wpa_drv_get_mac_addr(wpa_s),
3422 wpa_supplicant_rx_eapol, wpa_s, 0);
3423 if (wpa_s->l2 == NULL)
3426 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3428 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3431 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3432 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3436 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3442 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
3443 const u8 *buf, size_t len)
3445 struct wpa_supplicant *wpa_s = ctx;
3446 const struct l2_ethhdr *eth;
3448 if (len < sizeof(*eth))
3450 eth = (const struct l2_ethhdr *) buf;
3452 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3453 !(eth->h_dest[0] & 0x01)) {
3454 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3455 " (bridge - not for this interface - ignore)",
3456 MAC2STR(src_addr), MAC2STR(eth->h_dest));
3460 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3461 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
3462 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
3463 len - sizeof(*eth));
3468 * wpa_supplicant_driver_init - Initialize driver interface parameters
3469 * @wpa_s: Pointer to wpa_supplicant data
3470 * Returns: 0 on success, -1 on failure
3472 * This function is called to initialize driver interface parameters.
3473 * wpa_drv_init() must have been called before this function to initialize the
3476 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
3478 static int interface_count = 0;
3480 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
3483 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
3484 MAC2STR(wpa_s->own_addr));
3485 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
3486 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3488 if (wpa_s->bridge_ifname[0]) {
3489 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
3490 "interface '%s'", wpa_s->bridge_ifname);
3491 wpa_s->l2_br = l2_packet_init_bridge(
3492 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
3493 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
3494 if (wpa_s->l2_br == NULL) {
3495 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
3496 "connection for the bridge interface '%s'",
3497 wpa_s->bridge_ifname);
3502 if (wpa_s->conf->ap_scan == 2 &&
3503 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3504 wpa_printf(MSG_INFO,
3505 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3508 wpa_clear_keys(wpa_s, NULL);
3510 /* Make sure that TKIP countermeasures are not left enabled (could
3511 * happen if wpa_supplicant is killed during countermeasures. */
3512 wpa_drv_set_countermeasures(wpa_s, 0);
3514 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
3515 wpa_drv_flush_pmkid(wpa_s);
3517 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
3518 wpa_s->prev_scan_wildcard = 0;
3520 if (wpa_supplicant_enabled_networks(wpa_s)) {
3521 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
3522 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3523 interface_count = 0;
3526 if (!wpa_s->p2p_mgmt &&
3527 wpa_supplicant_delayed_sched_scan(wpa_s,
3528 interface_count % 3,
3530 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
3532 #endif /* ANDROID */
3535 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
3541 static int wpa_supplicant_daemon(const char *pid_file)
3543 wpa_printf(MSG_DEBUG, "Daemonize..");
3544 return os_daemonize(pid_file);
3548 static struct wpa_supplicant *
3549 wpa_supplicant_alloc(struct wpa_supplicant *parent)
3551 struct wpa_supplicant *wpa_s;
3553 wpa_s = os_zalloc(sizeof(*wpa_s));
3556 wpa_s->scan_req = INITIAL_SCAN_REQ;
3557 wpa_s->scan_interval = 5;
3558 wpa_s->new_connection = 1;
3559 wpa_s->parent = parent ? parent : wpa_s;
3560 wpa_s->p2pdev = wpa_s->parent;
3561 wpa_s->sched_scanning = 0;
3563 dl_list_init(&wpa_s->bss_tmp_disallowed);
3569 #ifdef CONFIG_HT_OVERRIDES
3571 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
3572 struct ieee80211_ht_capabilities *htcaps,
3573 struct ieee80211_ht_capabilities *htcaps_mask,
3576 /* parse ht_mcs into hex array */
3578 const char *tmp = ht_mcs;
3581 /* If ht_mcs is null, do not set anything */
3585 /* This is what we are setting in the kernel */
3586 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
3588 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
3590 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3592 long v = strtol(tmp, &end, 16);
3594 wpa_msg(wpa_s, MSG_DEBUG,
3595 "htcap value[%i]: %ld end: %p tmp: %p",
3600 htcaps->supported_mcs_set[i] = v;
3603 wpa_msg(wpa_s, MSG_ERROR,
3604 "Failed to parse ht-mcs: %s, error: %s\n",
3605 ht_mcs, strerror(errno));
3611 * If we were able to parse any values, then set mask for the MCS set.
3614 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
3615 IEEE80211_HT_MCS_MASK_LEN - 1);
3616 /* skip the 3 reserved bits */
3617 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
3625 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
3626 struct ieee80211_ht_capabilities *htcaps,
3627 struct ieee80211_ht_capabilities *htcaps_mask,
3632 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3637 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3638 htcaps_mask->ht_capabilities_info |= msk;
3640 htcaps->ht_capabilities_info &= msk;
3642 htcaps->ht_capabilities_info |= msk;
3648 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3649 struct ieee80211_ht_capabilities *htcaps,
3650 struct ieee80211_ht_capabilities *htcaps_mask,
3653 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3658 if (factor < 0 || factor > 3) {
3659 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3660 "Must be 0-3 or -1", factor);
3664 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3665 htcaps->a_mpdu_params &= ~0x3;
3666 htcaps->a_mpdu_params |= factor & 0x3;
3672 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3673 struct ieee80211_ht_capabilities *htcaps,
3674 struct ieee80211_ht_capabilities *htcaps_mask,
3677 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3682 if (density < 0 || density > 7) {
3683 wpa_msg(wpa_s, MSG_ERROR,
3684 "ampdu_density: %d out of range. Must be 0-7 or -1.",
3689 htcaps_mask->a_mpdu_params |= 0x1C;
3690 htcaps->a_mpdu_params &= ~(0x1C);
3691 htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3697 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3698 struct ieee80211_ht_capabilities *htcaps,
3699 struct ieee80211_ht_capabilities *htcaps_mask,
3702 /* Masking these out disables HT40 */
3703 le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3704 HT_CAP_INFO_SHORT_GI40MHZ);
3706 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3709 htcaps->ht_capabilities_info &= ~msk;
3711 htcaps->ht_capabilities_info |= msk;
3713 htcaps_mask->ht_capabilities_info |= msk;
3719 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3720 struct ieee80211_ht_capabilities *htcaps,
3721 struct ieee80211_ht_capabilities *htcaps_mask,
3724 /* Masking these out disables SGI */
3725 le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3726 HT_CAP_INFO_SHORT_GI40MHZ);
3728 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3731 htcaps->ht_capabilities_info &= ~msk;
3733 htcaps->ht_capabilities_info |= msk;
3735 htcaps_mask->ht_capabilities_info |= msk;
3741 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3742 struct ieee80211_ht_capabilities *htcaps,
3743 struct ieee80211_ht_capabilities *htcaps_mask,
3746 /* Masking these out disables LDPC */
3747 le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
3749 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3752 htcaps->ht_capabilities_info &= ~msk;
3754 htcaps->ht_capabilities_info |= msk;
3756 htcaps_mask->ht_capabilities_info |= msk;
3762 void wpa_supplicant_apply_ht_overrides(
3763 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3764 struct wpa_driver_associate_params *params)
3766 struct ieee80211_ht_capabilities *htcaps;
3767 struct ieee80211_ht_capabilities *htcaps_mask;
3772 params->disable_ht = ssid->disable_ht;
3773 if (!params->htcaps || !params->htcaps_mask)
3776 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3777 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3778 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3779 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3780 ssid->disable_max_amsdu);
3781 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3782 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3783 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3784 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3785 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3787 if (ssid->ht40_intolerant) {
3788 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
3789 htcaps->ht_capabilities_info |= bit;
3790 htcaps_mask->ht_capabilities_info |= bit;
3794 #endif /* CONFIG_HT_OVERRIDES */
3797 #ifdef CONFIG_VHT_OVERRIDES
3798 void wpa_supplicant_apply_vht_overrides(
3799 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3800 struct wpa_driver_associate_params *params)
3802 struct ieee80211_vht_capabilities *vhtcaps;
3803 struct ieee80211_vht_capabilities *vhtcaps_mask;
3808 params->disable_vht = ssid->disable_vht;
3810 vhtcaps = (void *) params->vhtcaps;
3811 vhtcaps_mask = (void *) params->vhtcaps_mask;
3813 if (!vhtcaps || !vhtcaps_mask)
3816 vhtcaps->vht_capabilities_info = host_to_le32(ssid->vht_capa);
3817 vhtcaps_mask->vht_capabilities_info = host_to_le32(ssid->vht_capa_mask);
3819 #ifdef CONFIG_HT_OVERRIDES
3820 /* if max ampdu is <= 3, we have to make the HT cap the same */
3821 if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) {
3824 max_ampdu = (ssid->vht_capa &
3825 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >>
3826 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT;
3828 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3829 wpa_set_ampdu_factor(wpa_s,
3830 (void *) params->htcaps,
3831 (void *) params->htcaps_mask,
3834 #endif /* CONFIG_HT_OVERRIDES */
3836 #define OVERRIDE_MCS(i) \
3837 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
3838 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
3839 host_to_le16(3 << 2 * (i - 1)); \
3840 vhtcaps->vht_supported_mcs_set.tx_map |= \
3841 host_to_le16(ssid->vht_tx_mcs_nss_ ##i << \
3844 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
3845 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
3846 host_to_le16(3 << 2 * (i - 1)); \
3847 vhtcaps->vht_supported_mcs_set.rx_map |= \
3848 host_to_le16(ssid->vht_rx_mcs_nss_ ##i << \
3861 #endif /* CONFIG_VHT_OVERRIDES */
3864 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3869 if (!wpa_s->conf->pcsc_reader)
3872 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3876 if (wpa_s->conf->pcsc_pin &&
3877 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3878 scard_deinit(wpa_s->scard);
3879 wpa_s->scard = NULL;
3880 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3884 len = sizeof(wpa_s->imsi) - 1;
3885 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3886 scard_deinit(wpa_s->scard);
3887 wpa_s->scard = NULL;
3888 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3891 wpa_s->imsi[len] = '\0';
3893 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3895 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3896 wpa_s->imsi, wpa_s->mnc_len);
3898 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3899 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3900 #endif /* PCSC_FUNCS */
3906 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3910 ext_password_deinit(wpa_s->ext_pw);
3911 wpa_s->ext_pw = NULL;
3912 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
3914 if (!wpa_s->conf->ext_password_backend)
3917 val = os_strdup(wpa_s->conf->ext_password_backend);
3920 pos = os_strchr(val, ':');
3924 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
3926 wpa_s->ext_pw = ext_password_init(val, pos);
3928 if (wpa_s->ext_pw == NULL) {
3929 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
3932 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
3940 static const u8 * wpas_fst_get_bssid_cb(void *ctx)
3942 struct wpa_supplicant *wpa_s = ctx;
3944 return (is_zero_ether_addr(wpa_s->bssid) ||
3945 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
3949 static void wpas_fst_get_channel_info_cb(void *ctx,
3950 enum hostapd_hw_mode *hw_mode,
3953 struct wpa_supplicant *wpa_s = ctx;
3955 if (wpa_s->current_bss) {
3956 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
3958 } else if (wpa_s->hw.num_modes) {
3959 *hw_mode = wpa_s->hw.modes[0].mode;
3967 static int wpas_fst_get_hw_modes(void *ctx, struct hostapd_hw_modes **modes)
3969 struct wpa_supplicant *wpa_s = ctx;
3971 *modes = wpa_s->hw.modes;
3972 return wpa_s->hw.num_modes;
3976 static void wpas_fst_set_ies_cb(void *ctx, const struct wpabuf *fst_ies)
3978 struct wpa_supplicant *wpa_s = ctx;
3980 wpa_hexdump_buf(MSG_DEBUG, "FST: Set IEs", fst_ies);
3981 wpa_s->fst_ies = fst_ies;
3985 static int wpas_fst_send_action_cb(void *ctx, const u8 *da, struct wpabuf *data)
3987 struct wpa_supplicant *wpa_s = ctx;
3989 WPA_ASSERT(os_memcmp(wpa_s->bssid, da, ETH_ALEN) == 0);
3990 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
3991 wpa_s->own_addr, wpa_s->bssid,
3992 wpabuf_head(data), wpabuf_len(data),
3997 static const struct wpabuf * wpas_fst_get_mb_ie_cb(void *ctx, const u8 *addr)
3999 struct wpa_supplicant *wpa_s = ctx;
4001 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4002 return wpa_s->received_mb_ies;
4006 static void wpas_fst_update_mb_ie_cb(void *ctx, const u8 *addr,
4007 const u8 *buf, size_t size)
4009 struct wpa_supplicant *wpa_s = ctx;
4010 struct mb_ies_info info;
4012 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4014 if (!mb_ies_info_by_ies(&info, buf, size)) {
4015 wpabuf_free(wpa_s->received_mb_ies);
4016 wpa_s->received_mb_ies = mb_ies_by_info(&info);
4021 static const u8 * wpas_fst_get_peer_first(void *ctx,
4022 struct fst_get_peer_ctx **get_ctx,
4025 struct wpa_supplicant *wpa_s = ctx;
4028 if (!is_zero_ether_addr(wpa_s->bssid))
4029 return (wpa_s->received_mb_ies || !mb_only) ?
4030 wpa_s->bssid : NULL;
4035 static const u8 * wpas_fst_get_peer_next(void *ctx,
4036 struct fst_get_peer_ctx **get_ctx,
4042 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
4043 struct fst_wpa_obj *iface_obj)
4045 iface_obj->ctx = wpa_s;
4046 iface_obj->get_bssid = wpas_fst_get_bssid_cb;
4047 iface_obj->get_channel_info = wpas_fst_get_channel_info_cb;
4048 iface_obj->get_hw_modes = wpas_fst_get_hw_modes;
4049 iface_obj->set_ies = wpas_fst_set_ies_cb;
4050 iface_obj->send_action = wpas_fst_send_action_cb;
4051 iface_obj->get_mb_ie = wpas_fst_get_mb_ie_cb;
4052 iface_obj->update_mb_ie = wpas_fst_update_mb_ie_cb;
4053 iface_obj->get_peer_first = wpas_fst_get_peer_first;
4054 iface_obj->get_peer_next = wpas_fst_get_peer_next;
4056 #endif /* CONFIG_FST */
4058 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
4059 const struct wpa_driver_capa *capa)
4061 struct wowlan_triggers *triggers;
4064 if (!wpa_s->conf->wowlan_triggers)
4067 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
4069 ret = wpa_drv_wowlan(wpa_s, triggers);
4076 enum wpa_radio_work_band wpas_freq_to_band(int freq)
4079 return BAND_2_4_GHZ;
4086 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
4089 unsigned int band = 0;
4092 /* freqs are specified for the radio work */
4093 for (i = 0; freqs[i]; i++)
4094 band |= wpas_freq_to_band(freqs[i]);
4097 * freqs are not specified, implies all
4098 * the supported freqs by HW
4100 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4101 if (wpa_s->hw.modes[i].num_channels != 0) {
4102 if (wpa_s->hw.modes[i].mode ==
4103 HOSTAPD_MODE_IEEE80211B ||
4104 wpa_s->hw.modes[i].mode ==
4105 HOSTAPD_MODE_IEEE80211G)
4106 band |= BAND_2_4_GHZ;
4107 else if (wpa_s->hw.modes[i].mode ==
4108 HOSTAPD_MODE_IEEE80211A)
4110 else if (wpa_s->hw.modes[i].mode ==
4111 HOSTAPD_MODE_IEEE80211AD)
4112 band |= BAND_60_GHZ;
4113 else if (wpa_s->hw.modes[i].mode ==
4114 HOSTAPD_MODE_IEEE80211ANY)
4115 band = BAND_2_4_GHZ | BAND_5_GHZ |
4125 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
4128 struct wpa_supplicant *iface = wpa_s->global->ifaces;
4129 struct wpa_radio *radio;
4131 while (rn && iface) {
4132 radio = iface->radio;
4133 if (radio && os_strcmp(rn, radio->name) == 0) {
4134 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
4136 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4140 iface = iface->next;
4143 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
4144 wpa_s->ifname, rn ? rn : "N/A");
4145 radio = os_zalloc(sizeof(*radio));
4150 os_strlcpy(radio->name, rn, sizeof(radio->name));
4151 dl_list_init(&radio->ifaces);
4152 dl_list_init(&radio->work);
4153 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4159 static void radio_work_free(struct wpa_radio_work *work)
4161 if (work->wpa_s->scan_work == work) {
4162 /* This should not really happen. */
4163 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4164 work->type, work, work->started);
4165 work->wpa_s->scan_work = NULL;
4169 if (work->wpa_s->p2p_scan_work == work) {
4170 /* This should not really happen. */
4171 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4172 work->type, work, work->started);
4173 work->wpa_s->p2p_scan_work = NULL;
4175 #endif /* CONFIG_P2P */
4177 if (work->started) {
4178 work->wpa_s->radio->num_active_works--;
4179 wpa_dbg(work->wpa_s, MSG_DEBUG,
4180 "radio_work_free('%s'@%p: num_active_works --> %u",
4182 work->wpa_s->radio->num_active_works);
4185 dl_list_del(&work->list);
4190 static struct wpa_radio_work * radio_work_get_next_work(struct wpa_radio *radio)
4192 struct wpa_radio_work *active_work = NULL;
4193 struct wpa_radio_work *tmp;
4195 /* Get the active work to know the type and band. */
4196 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4204 /* No active work, start one */
4205 radio->num_active_works = 0;
4206 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work,
4208 if (os_strcmp(tmp->type, "scan") == 0 &&
4209 radio->external_scan_running &&
4210 (((struct wpa_driver_scan_params *)
4211 tmp->ctx)->only_new_results ||
4212 tmp->wpa_s->clear_driver_scan_cache))
4219 if (os_strcmp(active_work->type, "sme-connect") == 0 ||
4220 os_strcmp(active_work->type, "connect") == 0) {
4222 * If the active work is either connect or sme-connect,
4223 * do not parallelize them with other radio works.
4225 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4226 "Do not parallelize radio work with %s",
4231 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4236 * If connect or sme-connect are enqueued, parallelize only
4237 * those operations ahead of them in the queue.
4239 if (os_strcmp(tmp->type, "connect") == 0 ||
4240 os_strcmp(tmp->type, "sme-connect") == 0)
4244 * Check that the radio works are distinct and
4245 * on different bands.
4247 if (os_strcmp(active_work->type, tmp->type) != 0 &&
4248 (active_work->bands != tmp->bands)) {
4250 * If a scan has to be scheduled through nl80211 scan
4251 * interface and if an external scan is already running,
4252 * do not schedule the scan since it is likely to get
4253 * rejected by kernel.
4255 if (os_strcmp(tmp->type, "scan") == 0 &&
4256 radio->external_scan_running &&
4257 (((struct wpa_driver_scan_params *)
4258 tmp->ctx)->only_new_results ||
4259 tmp->wpa_s->clear_driver_scan_cache))
4262 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4263 "active_work:%s new_work:%s",
4264 active_work->type, tmp->type);
4269 /* Did not find a radio work to schedule in parallel. */
4274 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
4276 struct wpa_radio *radio = eloop_ctx;
4277 struct wpa_radio_work *work;
4278 struct os_reltime now, diff;
4279 struct wpa_supplicant *wpa_s;
4281 work = dl_list_first(&radio->work, struct wpa_radio_work, list);
4283 radio->num_active_works = 0;
4287 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
4291 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
4293 return; /* already started and still in progress */
4295 if (wpa_s && wpa_s->radio->external_scan_running) {
4296 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
4301 if (radio->num_active_works < MAX_ACTIVE_WORKS) {
4302 /* get the work to schedule next */
4303 work = radio_work_get_next_work(radio);
4309 wpa_s = work->wpa_s;
4310 os_get_reltime(&now);
4311 os_reltime_sub(&now, &work->time, &diff);
4312 wpa_dbg(wpa_s, MSG_DEBUG,
4313 "Starting radio work '%s'@%p after %ld.%06ld second wait",
4314 work->type, work, diff.sec, diff.usec);
4317 radio->num_active_works++;
4321 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
4322 radio->num_active_works < MAX_ACTIVE_WORKS)
4323 radio_work_check_next(wpa_s);
4328 * This function removes both started and pending radio works running on
4329 * the provided interface's radio.
4330 * Prior to the removal of the radio work, its callback (cb) is called with
4331 * deinit set to be 1. Each work's callback is responsible for clearing its
4332 * internal data and restoring to a correct state.
4333 * @wpa_s: wpa_supplicant data
4334 * @type: type of works to be removed
4335 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
4336 * this interface's works.
4338 void radio_remove_works(struct wpa_supplicant *wpa_s,
4339 const char *type, int remove_all)
4341 struct wpa_radio_work *work, *tmp;
4342 struct wpa_radio *radio = wpa_s->radio;
4344 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
4346 if (type && os_strcmp(type, work->type) != 0)
4349 /* skip other ifaces' works */
4350 if (!remove_all && work->wpa_s != wpa_s)
4353 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
4354 work->type, work, work->started ? " (started)" : "");
4356 radio_work_free(work);
4359 /* in case we removed the started work */
4360 radio_work_check_next(wpa_s);
4364 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
4366 struct wpa_radio *radio = wpa_s->radio;
4371 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
4372 wpa_s->ifname, radio->name);
4373 dl_list_del(&wpa_s->radio_list);
4374 radio_remove_works(wpa_s, NULL, 0);
4375 wpa_s->radio = NULL;
4376 if (!dl_list_empty(&radio->ifaces))
4377 return; /* Interfaces remain for this radio */
4379 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
4380 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4385 void radio_work_check_next(struct wpa_supplicant *wpa_s)
4387 struct wpa_radio *radio = wpa_s->radio;
4389 if (dl_list_empty(&radio->work))
4391 if (wpa_s->ext_work_in_progress) {
4392 wpa_printf(MSG_DEBUG,
4393 "External radio work in progress - delay start of pending item");
4396 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4397 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
4402 * radio_add_work - Add a radio work item
4403 * @wpa_s: Pointer to wpa_supplicant data
4404 * @freq: Frequency of the offchannel operation in MHz or 0
4405 * @type: Unique identifier for each type of work
4406 * @next: Force as the next work to be executed
4407 * @cb: Callback function for indicating when radio is available
4408 * @ctx: Context pointer for the work (work->ctx in cb())
4409 * Returns: 0 on success, -1 on failure
4411 * This function is used to request time for an operation that requires
4412 * exclusive radio control. Once the radio is available, the registered callback
4413 * function will be called. radio_work_done() must be called once the exclusive
4414 * radio operation has been completed, so that the radio is freed for other
4415 * operations. The special case of deinit=1 is used to free the context data
4416 * during interface removal. That does not allow the callback function to start
4417 * the radio operation, i.e., it must free any resources allocated for the radio
4420 * The @freq parameter can be used to indicate a single channel on which the
4421 * offchannel operation will occur. This may allow multiple radio work
4422 * operations to be performed in parallel if they apply for the same channel.
4423 * Setting this to 0 indicates that the work item may use multiple channels or
4424 * requires exclusive control of the radio.
4426 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
4427 const char *type, int next,
4428 void (*cb)(struct wpa_radio_work *work, int deinit),
4431 struct wpa_radio *radio = wpa_s->radio;
4432 struct wpa_radio_work *work;
4435 work = os_zalloc(sizeof(*work));
4438 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
4439 os_get_reltime(&work->time);
4442 work->wpa_s = wpa_s;
4447 work->bands = wpas_freq_to_band(freq);
4448 else if (os_strcmp(type, "scan") == 0 ||
4449 os_strcmp(type, "p2p-scan") == 0)
4450 work->bands = wpas_get_bands(wpa_s,
4451 ((struct wpa_driver_scan_params *)
4454 work->bands = wpas_get_bands(wpa_s, NULL);
4456 was_empty = dl_list_empty(&wpa_s->radio->work);
4458 dl_list_add(&wpa_s->radio->work, &work->list);
4460 dl_list_add_tail(&wpa_s->radio->work, &work->list);
4462 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
4463 radio_work_check_next(wpa_s);
4464 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
4465 && radio->num_active_works < MAX_ACTIVE_WORKS) {
4466 wpa_dbg(wpa_s, MSG_DEBUG,
4467 "Try to schedule a radio work (num_active_works=%u)",
4468 radio->num_active_works);
4469 radio_work_check_next(wpa_s);
4477 * radio_work_done - Indicate that a radio work item has been completed
4478 * @work: Completed work
4480 * This function is called once the callback function registered with
4481 * radio_add_work() has completed its work.
4483 void radio_work_done(struct wpa_radio_work *work)
4485 struct wpa_supplicant *wpa_s = work->wpa_s;
4486 struct os_reltime now, diff;
4487 unsigned int started = work->started;
4489 os_get_reltime(&now);
4490 os_reltime_sub(&now, &work->time, &diff);
4491 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
4492 work->type, work, started ? "done" : "canceled",
4493 diff.sec, diff.usec);
4494 radio_work_free(work);
4496 radio_work_check_next(wpa_s);
4500 struct wpa_radio_work *
4501 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
4503 struct wpa_radio_work *work;
4504 struct wpa_radio *radio = wpa_s->radio;
4506 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
4507 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
4515 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
4516 struct wpa_interface *iface)
4518 const char *ifname, *driver, *rn;
4520 driver = iface->driver;
4522 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
4525 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
4526 if (wpa_s->drv_priv == NULL) {
4528 pos = driver ? os_strchr(driver, ',') : NULL;
4530 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
4531 "driver interface - try next driver wrapper");
4535 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
4539 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
4540 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
4541 "driver_param '%s'", wpa_s->conf->driver_param);
4545 ifname = wpa_drv_get_ifname(wpa_s);
4546 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
4547 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
4548 "interface name with '%s'", ifname);
4549 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
4552 rn = wpa_driver_get_radio_name(wpa_s);
4553 if (rn && rn[0] == '\0')
4556 wpa_s->radio = radio_add_interface(wpa_s, rn);
4557 if (wpa_s->radio == NULL)
4564 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
4565 struct wpa_interface *iface)
4567 struct wpa_driver_capa capa;
4570 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
4571 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
4572 iface->confname ? iface->confname : "N/A",
4573 iface->driver ? iface->driver : "default",
4574 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
4575 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
4577 if (iface->confname) {
4578 #ifdef CONFIG_BACKEND_FILE
4579 wpa_s->confname = os_rel2abs_path(iface->confname);
4580 if (wpa_s->confname == NULL) {
4581 wpa_printf(MSG_ERROR, "Failed to get absolute path "
4582 "for configuration file '%s'.",
4586 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
4587 iface->confname, wpa_s->confname);
4588 #else /* CONFIG_BACKEND_FILE */
4589 wpa_s->confname = os_strdup(iface->confname);
4590 #endif /* CONFIG_BACKEND_FILE */
4591 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
4592 if (wpa_s->conf == NULL) {
4593 wpa_printf(MSG_ERROR, "Failed to read or parse "
4594 "configuration '%s'.", wpa_s->confname);
4597 wpa_s->confanother = os_rel2abs_path(iface->confanother);
4598 wpa_config_read(wpa_s->confanother, wpa_s->conf);
4601 * Override ctrl_interface and driver_param if set on command
4604 if (iface->ctrl_interface) {
4605 os_free(wpa_s->conf->ctrl_interface);
4606 wpa_s->conf->ctrl_interface =
4607 os_strdup(iface->ctrl_interface);
4610 if (iface->driver_param) {
4611 os_free(wpa_s->conf->driver_param);
4612 wpa_s->conf->driver_param =
4613 os_strdup(iface->driver_param);
4616 if (iface->p2p_mgmt && !iface->ctrl_interface) {
4617 os_free(wpa_s->conf->ctrl_interface);
4618 wpa_s->conf->ctrl_interface = NULL;
4621 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
4622 iface->driver_param);
4624 if (wpa_s->conf == NULL) {
4625 wpa_printf(MSG_ERROR, "\nNo configuration found.");
4629 if (iface->ifname == NULL) {
4630 wpa_printf(MSG_ERROR, "\nInterface name is required.");
4633 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
4634 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
4638 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
4640 if (iface->bridge_ifname) {
4641 if (os_strlen(iface->bridge_ifname) >=
4642 sizeof(wpa_s->bridge_ifname)) {
4643 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
4644 "name '%s'.", iface->bridge_ifname);
4647 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
4648 sizeof(wpa_s->bridge_ifname));
4651 /* RSNA Supplicant Key Management - INITIALIZE */
4652 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
4653 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
4655 /* Initialize driver interface and register driver event handler before
4656 * L2 receive handler so that association events are processed before
4657 * EAPOL-Key packets if both become available for the same select()
4659 if (wpas_init_driver(wpa_s, iface) < 0)
4662 if (wpa_supplicant_init_wpa(wpa_s) < 0)
4665 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
4666 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
4668 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
4670 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
4671 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
4672 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
4673 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4674 "dot11RSNAConfigPMKLifetime");
4678 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
4679 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
4680 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
4681 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4682 "dot11RSNAConfigPMKReauthThreshold");
4686 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
4687 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
4688 wpa_s->conf->dot11RSNAConfigSATimeout)) {
4689 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4690 "dot11RSNAConfigSATimeout");
4694 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
4695 &wpa_s->hw.num_modes,
4697 if (wpa_s->hw.modes) {
4700 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4701 if (wpa_s->hw.modes[i].vht_capab) {
4702 wpa_s->hw_capab = CAPAB_VHT;
4706 if (wpa_s->hw.modes[i].ht_capab &
4707 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)
4708 wpa_s->hw_capab = CAPAB_HT40;
4709 else if (wpa_s->hw.modes[i].ht_capab &&
4710 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
4711 wpa_s->hw_capab = CAPAB_HT;
4715 capa_res = wpa_drv_get_capa(wpa_s, &capa);
4716 if (capa_res == 0) {
4717 wpa_s->drv_capa_known = 1;
4718 wpa_s->drv_flags = capa.flags;
4719 wpa_s->drv_enc = capa.enc;
4720 wpa_s->drv_smps_modes = capa.smps_modes;
4721 wpa_s->drv_rrm_flags = capa.rrm_flags;
4722 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
4723 wpa_s->max_scan_ssids = capa.max_scan_ssids;
4724 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
4725 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
4726 wpa_s->max_sched_scan_plan_interval =
4727 capa.max_sched_scan_plan_interval;
4728 wpa_s->max_sched_scan_plan_iterations =
4729 capa.max_sched_scan_plan_iterations;
4730 wpa_s->sched_scan_supported = capa.sched_scan_supported;
4731 wpa_s->max_match_sets = capa.max_match_sets;
4732 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
4733 wpa_s->max_stations = capa.max_stations;
4734 wpa_s->extended_capa = capa.extended_capa;
4735 wpa_s->extended_capa_mask = capa.extended_capa_mask;
4736 wpa_s->extended_capa_len = capa.extended_capa_len;
4737 wpa_s->num_multichan_concurrent =
4738 capa.num_multichan_concurrent;
4739 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
4741 if (capa.mac_addr_rand_scan_supported)
4742 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
4743 if (wpa_s->sched_scan_supported &&
4744 capa.mac_addr_rand_sched_scan_supported)
4745 wpa_s->mac_addr_rand_supported |=
4746 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO);
4748 if (wpa_s->max_remain_on_chan == 0)
4749 wpa_s->max_remain_on_chan = 1000;
4752 * Only take p2p_mgmt parameters when P2P Device is supported.
4753 * Doing it here as it determines whether l2_packet_init() will be done
4754 * during wpa_supplicant_driver_init().
4756 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
4757 wpa_s->p2p_mgmt = iface->p2p_mgmt;
4759 iface->p2p_mgmt = 1;
4761 if (wpa_s->num_multichan_concurrent == 0)
4762 wpa_s->num_multichan_concurrent = 1;
4764 if (wpa_supplicant_driver_init(wpa_s) < 0)
4768 if ((!iface->p2p_mgmt ||
4769 !(wpa_s->drv_flags &
4770 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
4771 wpa_tdls_init(wpa_s->wpa))
4773 #endif /* CONFIG_TDLS */
4775 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
4776 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
4777 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
4782 if (wpa_s->conf->fst_group_id) {
4783 struct fst_iface_cfg cfg;
4784 struct fst_wpa_obj iface_obj;
4786 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
4787 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
4788 sizeof(cfg.group_id));
4789 cfg.priority = wpa_s->conf->fst_priority;
4790 cfg.llt = wpa_s->conf->fst_llt;
4792 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
4795 wpa_msg(wpa_s, MSG_ERROR,
4796 "FST: Cannot attach iface %s to group %s",
4797 wpa_s->ifname, cfg.group_id);
4801 #endif /* CONFIG_FST */
4803 if (wpas_wps_init(wpa_s))
4806 if (wpa_supplicant_init_eapol(wpa_s) < 0)
4808 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
4810 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
4811 if (wpa_s->ctrl_iface == NULL) {
4812 wpa_printf(MSG_ERROR,
4813 "Failed to initialize control interface '%s'.\n"
4814 "You may have another wpa_supplicant process "
4815 "already running or the file was\n"
4816 "left by an unclean termination of wpa_supplicant "
4817 "in which case you will need\n"
4818 "to manually remove this file before starting "
4819 "wpa_supplicant again.\n",
4820 wpa_s->conf->ctrl_interface);
4824 wpa_s->gas = gas_query_init(wpa_s);
4825 if (wpa_s->gas == NULL) {
4826 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
4830 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
4831 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
4835 if (wpa_bss_init(wpa_s) < 0)
4839 * Set Wake-on-WLAN triggers, if configured.
4840 * Note: We don't restore/remove the triggers on shutdown (it doesn't
4841 * have effect anyway when the interface is down).
4843 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
4846 #ifdef CONFIG_EAP_PROXY
4849 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
4851 if (wpa_s->mnc_len > 0) {
4852 wpa_s->imsi[len] = '\0';
4853 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
4854 wpa_s->imsi, wpa_s->mnc_len);
4856 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
4859 #endif /* CONFIG_EAP_PROXY */
4861 if (pcsc_reader_init(wpa_s) < 0)
4864 if (wpas_init_ext_pw(wpa_s) < 0)
4867 wpas_rrm_reset(wpa_s);
4869 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
4873 #endif /* CONFIG_HS20 */
4875 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
4876 #endif /* CONFIG_MBO */
4878 wpa_supplicant_set_default_scan_ies(wpa_s);
4884 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
4885 int notify, int terminate)
4887 struct wpa_global *global = wpa_s->global;
4888 struct wpa_supplicant *iface, *prev;
4890 if (wpa_s == wpa_s->parent)
4891 wpas_p2p_group_remove(wpa_s, "*");
4893 iface = global->ifaces;
4895 if (iface->p2pdev == wpa_s)
4896 iface->p2pdev = iface->parent;
4897 if (iface == wpa_s || iface->parent != wpa_s) {
4898 iface = iface->next;
4901 wpa_printf(MSG_DEBUG,
4902 "Remove remaining child interface %s from parent %s",
4903 iface->ifname, wpa_s->ifname);
4905 iface = iface->next;
4906 wpa_supplicant_remove_iface(global, prev, terminate);
4909 wpa_s->disconnected = 1;
4910 if (wpa_s->drv_priv) {
4911 wpa_supplicant_deauthenticate(wpa_s,
4912 WLAN_REASON_DEAUTH_LEAVING);
4914 wpa_drv_set_countermeasures(wpa_s, 0);
4915 wpa_clear_keys(wpa_s, NULL);
4918 wpa_supplicant_cleanup(wpa_s);
4919 wpas_p2p_deinit_iface(wpa_s);
4921 wpas_ctrl_radio_work_flush(wpa_s);
4922 radio_remove_interface(wpa_s);
4926 fst_detach(wpa_s->fst);
4929 if (wpa_s->received_mb_ies) {
4930 wpabuf_free(wpa_s->received_mb_ies);
4931 wpa_s->received_mb_ies = NULL;
4933 #endif /* CONFIG_FST */
4935 if (wpa_s->drv_priv)
4936 wpa_drv_deinit(wpa_s);
4939 wpas_notify_iface_removed(wpa_s);
4942 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
4944 if (wpa_s->ctrl_iface) {
4945 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
4946 wpa_s->ctrl_iface = NULL;
4951 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
4952 wpa_s->ifmsh = NULL;
4954 #endif /* CONFIG_MESH */
4956 if (wpa_s->conf != NULL) {
4957 wpa_config_free(wpa_s->conf);
4961 os_free(wpa_s->ssids_from_scan_req);
4967 #ifdef CONFIG_MATCH_IFACE
4970 * wpa_supplicant_match_iface - Match an interface description to a name
4971 * @global: Pointer to global data from wpa_supplicant_init()
4972 * @ifname: Name of the interface to match
4973 * Returns: Pointer to the created interface description or %NULL on failure
4975 struct wpa_interface * wpa_supplicant_match_iface(struct wpa_global *global,
4979 struct wpa_interface *iface, *miface;
4981 for (i = 0; i < global->params.match_iface_count; i++) {
4982 miface = &global->params.match_ifaces[i];
4983 if (!miface->ifname ||
4984 fnmatch(miface->ifname, ifname, 0) == 0) {
4985 iface = os_zalloc(sizeof(*iface));
4989 iface->ifname = ifname;
4999 * wpa_supplicant_match_existing - Match existing interfaces
5000 * @global: Pointer to global data from wpa_supplicant_init()
5001 * Returns: 0 on success, -1 on failure
5003 static int wpa_supplicant_match_existing(struct wpa_global *global)
5005 struct if_nameindex *ifi, *ifp;
5006 struct wpa_supplicant *wpa_s;
5007 struct wpa_interface *iface;
5009 ifp = if_nameindex();
5011 wpa_printf(MSG_ERROR, "if_nameindex: %s", strerror(errno));
5015 for (ifi = ifp; ifi->if_name; ifi++) {
5016 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
5019 iface = wpa_supplicant_match_iface(global, ifi->if_name);
5021 wpa_s = wpa_supplicant_add_iface(global, iface, NULL);
5028 if_freenameindex(ifp);
5032 #endif /* CONFIG_MATCH_IFACE */
5036 * wpa_supplicant_add_iface - Add a new network interface
5037 * @global: Pointer to global data from wpa_supplicant_init()
5038 * @iface: Interface configuration options
5039 * @parent: Parent interface or %NULL to assign new interface as parent
5040 * Returns: Pointer to the created interface or %NULL on failure
5042 * This function is used to add new network interfaces for %wpa_supplicant.
5043 * This can be called before wpa_supplicant_run() to add interfaces before the
5044 * main event loop has been started. In addition, new interfaces can be added
5045 * dynamically while %wpa_supplicant is already running. This could happen,
5046 * e.g., when a hotplug network adapter is inserted.
5048 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
5049 struct wpa_interface *iface,
5050 struct wpa_supplicant *parent)
5052 struct wpa_supplicant *wpa_s;
5053 struct wpa_interface t_iface;
5054 struct wpa_ssid *ssid;
5056 if (global == NULL || iface == NULL)
5059 wpa_s = wpa_supplicant_alloc(parent);
5063 wpa_s->global = global;
5066 if (global->params.override_driver) {
5067 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
5069 iface->driver, global->params.override_driver);
5070 t_iface.driver = global->params.override_driver;
5072 if (global->params.override_ctrl_interface) {
5073 wpa_printf(MSG_DEBUG, "Override interface parameter: "
5074 "ctrl_interface ('%s' -> '%s')",
5075 iface->ctrl_interface,
5076 global->params.override_ctrl_interface);
5077 t_iface.ctrl_interface =
5078 global->params.override_ctrl_interface;
5080 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
5081 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
5083 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
5087 if (iface->p2p_mgmt == 0) {
5088 /* Notify the control interfaces about new iface */
5089 if (wpas_notify_iface_added(wpa_s)) {
5090 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
5094 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
5095 wpas_notify_network_added(wpa_s, ssid);
5098 wpa_s->next = global->ifaces;
5099 global->ifaces = wpa_s;
5101 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
5102 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
5105 if (wpa_s->global->p2p == NULL &&
5106 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
5107 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
5108 wpas_p2p_add_p2pdev_interface(
5109 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
5110 wpa_printf(MSG_INFO,
5111 "P2P: Failed to enable P2P Device interface");
5112 /* Try to continue without. P2P will be disabled. */
5114 #endif /* CONFIG_P2P */
5121 * wpa_supplicant_remove_iface - Remove a network interface
5122 * @global: Pointer to global data from wpa_supplicant_init()
5123 * @wpa_s: Pointer to the network interface to be removed
5124 * Returns: 0 if interface was removed, -1 if interface was not found
5126 * This function can be used to dynamically remove network interfaces from
5127 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
5128 * addition, this function is used to remove all remaining interfaces when
5129 * %wpa_supplicant is terminated.
5131 int wpa_supplicant_remove_iface(struct wpa_global *global,
5132 struct wpa_supplicant *wpa_s,
5135 struct wpa_supplicant *prev;
5137 unsigned int mesh_if_created = wpa_s->mesh_if_created;
5138 char *ifname = NULL;
5139 #endif /* CONFIG_MESH */
5141 /* Remove interface from the global list of interfaces */
5142 prev = global->ifaces;
5143 if (prev == wpa_s) {
5144 global->ifaces = wpa_s->next;
5146 while (prev && prev->next != wpa_s)
5150 prev->next = wpa_s->next;
5153 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
5156 if (mesh_if_created) {
5157 ifname = os_strdup(wpa_s->ifname);
5158 if (ifname == NULL) {
5159 wpa_dbg(wpa_s, MSG_ERROR,
5160 "mesh: Failed to malloc ifname");
5164 #endif /* CONFIG_MESH */
5166 if (global->p2p_group_formation == wpa_s)
5167 global->p2p_group_formation = NULL;
5168 if (global->p2p_invite_group == wpa_s)
5169 global->p2p_invite_group = NULL;
5170 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
5173 if (mesh_if_created) {
5174 wpa_drv_if_remove(global->ifaces, WPA_IF_MESH, ifname);
5177 #endif /* CONFIG_MESH */
5184 * wpa_supplicant_get_eap_mode - Get the current EAP mode
5185 * @wpa_s: Pointer to the network interface
5186 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
5188 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
5190 const char *eapol_method;
5192 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
5193 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
5197 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
5198 if (eapol_method == NULL)
5199 return "UNKNOWN-EAP";
5201 return eapol_method;
5206 * wpa_supplicant_get_iface - Get a new network interface
5207 * @global: Pointer to global data from wpa_supplicant_init()
5208 * @ifname: Interface name
5209 * Returns: Pointer to the interface or %NULL if not found
5211 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
5214 struct wpa_supplicant *wpa_s;
5216 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5217 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5224 #ifndef CONFIG_NO_WPA_MSG
5225 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
5227 struct wpa_supplicant *wpa_s = ctx;
5230 return wpa_s->ifname;
5232 #endif /* CONFIG_NO_WPA_MSG */
5235 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL
5236 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10
5237 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */
5239 /* Periodic cleanup tasks */
5240 static void wpas_periodic(void *eloop_ctx, void *timeout_ctx)
5242 struct wpa_global *global = eloop_ctx;
5243 struct wpa_supplicant *wpa_s;
5245 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5246 wpas_periodic, global, NULL);
5250 p2p_expire_peers(global->p2p);
5251 #endif /* CONFIG_P2P */
5253 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5254 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
5257 #endif /* CONFIG_AP */
5263 * wpa_supplicant_init - Initialize %wpa_supplicant
5264 * @params: Parameters for %wpa_supplicant
5265 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
5267 * This function is used to initialize %wpa_supplicant. After successful
5268 * initialization, the returned data pointer can be used to add and remove
5269 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
5271 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
5273 struct wpa_global *global;
5279 #ifdef CONFIG_DRIVER_NDIS
5281 void driver_ndis_init_ops(void);
5282 driver_ndis_init_ops();
5284 #endif /* CONFIG_DRIVER_NDIS */
5286 #ifndef CONFIG_NO_WPA_MSG
5287 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
5288 #endif /* CONFIG_NO_WPA_MSG */
5290 if (params->wpa_debug_file_path)
5291 wpa_debug_open_file(params->wpa_debug_file_path);
5293 wpa_debug_setup_stdout();
5294 if (params->wpa_debug_syslog)
5295 wpa_debug_open_syslog();
5296 if (params->wpa_debug_tracing) {
5297 ret = wpa_debug_open_linux_tracing();
5299 wpa_printf(MSG_ERROR,
5300 "Failed to enable trace logging");
5305 ret = eap_register_methods();
5307 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
5309 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
5310 "the same EAP type.");
5314 global = os_zalloc(sizeof(*global));
5317 dl_list_init(&global->p2p_srv_bonjour);
5318 dl_list_init(&global->p2p_srv_upnp);
5319 global->params.daemonize = params->daemonize;
5320 global->params.wait_for_monitor = params->wait_for_monitor;
5321 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
5322 if (params->pid_file)
5323 global->params.pid_file = os_strdup(params->pid_file);
5324 if (params->ctrl_interface)
5325 global->params.ctrl_interface =
5326 os_strdup(params->ctrl_interface);
5327 if (params->ctrl_interface_group)
5328 global->params.ctrl_interface_group =
5329 os_strdup(params->ctrl_interface_group);
5330 if (params->override_driver)
5331 global->params.override_driver =
5332 os_strdup(params->override_driver);
5333 if (params->override_ctrl_interface)
5334 global->params.override_ctrl_interface =
5335 os_strdup(params->override_ctrl_interface);
5336 #ifdef CONFIG_MATCH_IFACE
5337 global->params.match_iface_count = params->match_iface_count;
5338 if (params->match_iface_count) {
5339 global->params.match_ifaces =
5340 os_calloc(params->match_iface_count,
5341 sizeof(struct wpa_interface));
5342 os_memcpy(global->params.match_ifaces,
5343 params->match_ifaces,
5344 params->match_iface_count *
5345 sizeof(struct wpa_interface));
5347 #endif /* CONFIG_MATCH_IFACE */
5349 if (params->conf_p2p_dev)
5350 global->params.conf_p2p_dev =
5351 os_strdup(params->conf_p2p_dev);
5352 #endif /* CONFIG_P2P */
5353 wpa_debug_level = global->params.wpa_debug_level =
5354 params->wpa_debug_level;
5355 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
5356 params->wpa_debug_show_keys;
5357 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
5358 params->wpa_debug_timestamp;
5360 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
5363 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
5364 wpa_supplicant_deinit(global);
5368 random_init(params->entropy_file);
5370 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
5371 if (global->ctrl_iface == NULL) {
5372 wpa_supplicant_deinit(global);
5376 if (wpas_notify_supplicant_initialized(global)) {
5377 wpa_supplicant_deinit(global);
5381 for (i = 0; wpa_drivers[i]; i++)
5382 global->drv_count++;
5383 if (global->drv_count == 0) {
5384 wpa_printf(MSG_ERROR, "No drivers enabled");
5385 wpa_supplicant_deinit(global);
5388 global->drv_priv = os_calloc(global->drv_count, sizeof(void *));
5389 if (global->drv_priv == NULL) {
5390 wpa_supplicant_deinit(global);
5394 #ifdef CONFIG_WIFI_DISPLAY
5395 if (wifi_display_init(global) < 0) {
5396 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
5397 wpa_supplicant_deinit(global);
5400 #endif /* CONFIG_WIFI_DISPLAY */
5402 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5403 wpas_periodic, global, NULL);
5410 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
5411 * @global: Pointer to global data from wpa_supplicant_init()
5412 * Returns: 0 after successful event loop run, -1 on failure
5414 * This function starts the main event loop and continues running as long as
5415 * there are any remaining events. In most cases, this function is running as
5416 * long as the %wpa_supplicant process in still in use.
5418 int wpa_supplicant_run(struct wpa_global *global)
5420 struct wpa_supplicant *wpa_s;
5422 if (global->params.daemonize &&
5423 (wpa_supplicant_daemon(global->params.pid_file) ||
5424 eloop_sock_requeue()))
5427 #ifdef CONFIG_MATCH_IFACE
5428 if (wpa_supplicant_match_existing(global))
5432 if (global->params.wait_for_monitor) {
5433 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
5434 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
5435 wpa_supplicant_ctrl_iface_wait(
5439 eloop_register_signal_terminate(wpa_supplicant_terminate, global);
5440 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
5449 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
5450 * @global: Pointer to global data from wpa_supplicant_init()
5452 * This function is called to deinitialize %wpa_supplicant and to free all
5453 * allocated resources. Remaining network interfaces will also be removed.
5455 void wpa_supplicant_deinit(struct wpa_global *global)
5462 eloop_cancel_timeout(wpas_periodic, global, NULL);
5464 #ifdef CONFIG_WIFI_DISPLAY
5465 wifi_display_deinit(global);
5466 #endif /* CONFIG_WIFI_DISPLAY */
5468 while (global->ifaces)
5469 wpa_supplicant_remove_iface(global, global->ifaces, 1);
5471 if (global->ctrl_iface)
5472 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
5474 wpas_notify_supplicant_deinitialized(global);
5476 eap_peer_unregister_methods();
5478 eap_server_unregister_methods();
5479 #endif /* CONFIG_AP */
5481 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
5482 if (!global->drv_priv[i])
5484 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
5486 os_free(global->drv_priv);
5492 if (global->params.pid_file) {
5493 os_daemonize_terminate(global->params.pid_file);
5494 os_free(global->params.pid_file);
5496 os_free(global->params.ctrl_interface);
5497 os_free(global->params.ctrl_interface_group);
5498 os_free(global->params.override_driver);
5499 os_free(global->params.override_ctrl_interface);
5500 #ifdef CONFIG_MATCH_IFACE
5501 os_free(global->params.match_ifaces);
5502 #endif /* CONFIG_MATCH_IFACE */
5504 os_free(global->params.conf_p2p_dev);
5505 #endif /* CONFIG_P2P */
5507 os_free(global->p2p_disallow_freq.range);
5508 os_free(global->p2p_go_avoid_freq.range);
5509 os_free(global->add_psk);
5512 wpa_debug_close_syslog();
5513 wpa_debug_close_file();
5514 wpa_debug_close_linux_tracing();
5518 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
5520 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
5521 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5523 country[0] = wpa_s->conf->country[0];
5524 country[1] = wpa_s->conf->country[1];
5526 if (wpa_drv_set_country(wpa_s, country) < 0) {
5527 wpa_printf(MSG_ERROR, "Failed to set country code "
5532 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
5533 wpas_init_ext_pw(wpa_s);
5535 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
5536 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5539 wpas_wps_update_config(wpa_s);
5540 #endif /* CONFIG_WPS */
5541 wpas_p2p_update_config(wpa_s);
5542 wpa_s->conf->changed_parameters = 0;
5546 void add_freq(int *freqs, int *num_freqs, int freq)
5550 for (i = 0; i < *num_freqs; i++) {
5551 if (freqs[i] == freq)
5555 freqs[*num_freqs] = freq;
5560 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
5562 struct wpa_bss *bss, *cbss;
5563 const int max_freqs = 10;
5567 freqs = os_calloc(max_freqs + 1, sizeof(int));
5571 cbss = wpa_s->current_bss;
5573 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
5576 if (bss->ssid_len == cbss->ssid_len &&
5577 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
5578 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
5579 add_freq(freqs, &num_freqs, bss->freq);
5580 if (num_freqs == max_freqs)
5585 if (num_freqs == 0) {
5594 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
5600 wpas_connect_work_done(wpa_s);
5603 * Remove possible authentication timeout since the connection failed.
5605 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
5608 * There is no point in blacklisting the AP if this event is
5609 * generated based on local request to disconnect.
5611 if (wpa_s->own_disconnect_req) {
5612 wpa_s->own_disconnect_req = 0;
5613 wpa_dbg(wpa_s, MSG_DEBUG,
5614 "Ignore connection failure due to local request to disconnect");
5617 if (wpa_s->disconnected) {
5618 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
5619 "indication since interface has been put into "
5620 "disconnected state");
5625 * Add the failed BSSID into the blacklist and speed up next scan
5626 * attempt if there could be other APs that could accept association.
5627 * The current blacklist count indicates how many times we have tried
5628 * connecting to this AP and multiple attempts mean that other APs are
5629 * either not available or has already been tried, so that we can start
5630 * increasing the delay here to avoid constant scanning.
5632 count = wpa_blacklist_add(wpa_s, bssid);
5633 if (count == 1 && wpa_s->current_bss) {
5635 * This BSS was not in the blacklist before. If there is
5636 * another BSS available for the same ESS, we should try that
5637 * next. Otherwise, we may as well try this one once more
5638 * before allowing other, likely worse, ESSes to be considered.
5640 freqs = get_bss_freqs_in_ess(wpa_s);
5642 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
5643 "has been seen; try it next");
5644 wpa_blacklist_add(wpa_s, bssid);
5646 * On the next scan, go through only the known channels
5647 * used in this ESS based on previous scans to speed up
5648 * common load balancing use case.
5650 os_free(wpa_s->next_scan_freqs);
5651 wpa_s->next_scan_freqs = freqs;
5656 * Add previous failure count in case the temporary blacklist was
5657 * cleared due to no other BSSes being available.
5659 count += wpa_s->extra_blacklist_count;
5661 if (count > 3 && wpa_s->current_ssid) {
5662 wpa_printf(MSG_DEBUG, "Continuous association failures - "
5663 "consider temporary network disabling");
5664 wpas_auth_failed(wpa_s, "CONN_FAILED");
5685 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
5686 "ms", count, timeout);
5689 * TODO: if more than one possible AP is available in scan results,
5690 * could try the other ones before requesting a new scan.
5692 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
5693 1000 * (timeout % 1000));
5697 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
5699 return wpa_s->conf->ap_scan == 2 ||
5700 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
5704 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
5705 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
5706 struct wpa_ssid *ssid,
5710 #ifdef IEEE8021X_EAPOL
5711 struct eap_peer_config *eap = &ssid->eap;
5713 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
5714 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
5715 (const u8 *) value, os_strlen(value));
5717 switch (wpa_supplicant_ctrl_req_from_string(field)) {
5718 case WPA_CTRL_REQ_EAP_IDENTITY:
5719 os_free(eap->identity);
5720 eap->identity = (u8 *) os_strdup(value);
5721 eap->identity_len = os_strlen(value);
5722 eap->pending_req_identity = 0;
5723 if (ssid == wpa_s->current_ssid)
5724 wpa_s->reassociate = 1;
5726 case WPA_CTRL_REQ_EAP_PASSWORD:
5727 bin_clear_free(eap->password, eap->password_len);
5728 eap->password = (u8 *) os_strdup(value);
5729 eap->password_len = os_strlen(value);
5730 eap->pending_req_password = 0;
5731 if (ssid == wpa_s->current_ssid)
5732 wpa_s->reassociate = 1;
5734 case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
5735 bin_clear_free(eap->new_password, eap->new_password_len);
5736 eap->new_password = (u8 *) os_strdup(value);
5737 eap->new_password_len = os_strlen(value);
5738 eap->pending_req_new_password = 0;
5739 if (ssid == wpa_s->current_ssid)
5740 wpa_s->reassociate = 1;
5742 case WPA_CTRL_REQ_EAP_PIN:
5743 str_clear_free(eap->pin);
5744 eap->pin = os_strdup(value);
5745 eap->pending_req_pin = 0;
5746 if (ssid == wpa_s->current_ssid)
5747 wpa_s->reassociate = 1;
5749 case WPA_CTRL_REQ_EAP_OTP:
5750 bin_clear_free(eap->otp, eap->otp_len);
5751 eap->otp = (u8 *) os_strdup(value);
5752 eap->otp_len = os_strlen(value);
5753 os_free(eap->pending_req_otp);
5754 eap->pending_req_otp = NULL;
5755 eap->pending_req_otp_len = 0;
5757 case WPA_CTRL_REQ_EAP_PASSPHRASE:
5758 str_clear_free(eap->private_key_passwd);
5759 eap->private_key_passwd = os_strdup(value);
5760 eap->pending_req_passphrase = 0;
5761 if (ssid == wpa_s->current_ssid)
5762 wpa_s->reassociate = 1;
5764 case WPA_CTRL_REQ_SIM:
5765 str_clear_free(eap->external_sim_resp);
5766 eap->external_sim_resp = os_strdup(value);
5768 case WPA_CTRL_REQ_PSK_PASSPHRASE:
5769 if (wpa_config_set(ssid, "psk", value, 0) < 0)
5771 ssid->mem_only_psk = 1;
5772 if (ssid->passphrase)
5773 wpa_config_update_psk(ssid);
5774 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
5775 wpa_supplicant_req_scan(wpa_s, 0, 0);
5777 case WPA_CTRL_REQ_EXT_CERT_CHECK:
5778 if (eap->pending_ext_cert_check != PENDING_CHECK)
5780 if (os_strcmp(value, "good") == 0)
5781 eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD;
5782 else if (os_strcmp(value, "bad") == 0)
5783 eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD;
5788 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
5793 #else /* IEEE8021X_EAPOL */
5794 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
5796 #endif /* IEEE8021X_EAPOL */
5798 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
5801 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5804 unsigned int drv_enc;
5806 if (wpa_s->p2p_mgmt)
5807 return 1; /* no normal network profiles on p2p_mgmt interface */
5815 if (wpa_s->drv_capa_known)
5816 drv_enc = wpa_s->drv_enc;
5818 drv_enc = (unsigned int) -1;
5820 for (i = 0; i < NUM_WEP_KEYS; i++) {
5821 size_t len = ssid->wep_key_len[i];
5824 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
5826 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
5828 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
5830 return 1; /* invalid WEP key */
5833 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
5834 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk &&
5835 !ssid->mem_only_psk)
5842 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5844 #ifdef CONFIG_IEEE80211W
5845 if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) {
5846 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
5847 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
5849 * Driver does not support BIP -- ignore pmf=1 default
5850 * since the connection with PMF would fail and the
5851 * configuration does not require PMF to be enabled.
5853 return NO_MGMT_FRAME_PROTECTION;
5858 ~(WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPS |
5859 WPA_KEY_MGMT_IEEE8021X_NO_WPA)) == 0) {
5861 * Do not use the default PMF value for non-RSN networks
5862 * since PMF is available only with RSN and pmf=2
5863 * configuration would otherwise prevent connections to
5864 * all open networks.
5866 return NO_MGMT_FRAME_PROTECTION;
5869 return wpa_s->conf->pmf;
5872 return ssid->ieee80211w;
5873 #else /* CONFIG_IEEE80211W */
5874 return NO_MGMT_FRAME_PROTECTION;
5875 #endif /* CONFIG_IEEE80211W */
5879 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
5881 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
5883 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
5889 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
5891 struct wpa_ssid *ssid = wpa_s->current_ssid;
5893 struct os_reltime now;
5896 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
5901 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
5904 ssid->auth_failures++;
5907 if (ssid->p2p_group &&
5908 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
5910 * Skip the wait time since there is a short timeout on the
5911 * connection to a P2P group.
5915 #endif /* CONFIG_P2P */
5917 if (ssid->auth_failures > 50)
5919 else if (ssid->auth_failures > 10)
5921 else if (ssid->auth_failures > 5)
5923 else if (ssid->auth_failures > 3)
5925 else if (ssid->auth_failures > 2)
5927 else if (ssid->auth_failures > 1)
5932 if (ssid->auth_failures > 1 &&
5933 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
5934 dur += os_random() % (ssid->auth_failures * 10);
5936 os_get_reltime(&now);
5937 if (now.sec + dur <= ssid->disabled_until.sec)
5940 ssid->disabled_until.sec = now.sec + dur;
5942 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
5943 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
5944 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
5945 ssid->auth_failures, dur, reason);
5949 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
5950 struct wpa_ssid *ssid, int clear_failures)
5955 if (ssid->disabled_until.sec) {
5956 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
5957 "id=%d ssid=\"%s\"",
5958 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
5960 ssid->disabled_until.sec = 0;
5961 ssid->disabled_until.usec = 0;
5963 ssid->auth_failures = 0;
5967 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
5971 if (wpa_s->disallow_aps_bssid == NULL)
5974 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
5975 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
5976 bssid, ETH_ALEN) == 0)
5984 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
5989 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
5992 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
5993 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
5994 if (ssid_len == s->ssid_len &&
5995 os_memcmp(ssid, s->ssid, ssid_len) == 0)
6004 * wpas_request_connection - Request a new connection
6005 * @wpa_s: Pointer to the network interface
6007 * This function is used to request a new connection to be found. It will mark
6008 * the interface to allow reassociation and request a new scan to find a
6009 * suitable network to connect to.
6011 void wpas_request_connection(struct wpa_supplicant *wpa_s)
6013 wpa_s->normal_scans = 0;
6014 wpa_s->scan_req = NORMAL_SCAN_REQ;
6015 wpa_supplicant_reinit_autoscan(wpa_s);
6016 wpa_s->extra_blacklist_count = 0;
6017 wpa_s->disconnected = 0;
6018 wpa_s->reassociate = 1;
6020 if (wpa_supplicant_fast_associate(wpa_s) != 1)
6021 wpa_supplicant_req_scan(wpa_s, 0, 0);
6023 wpa_s->reattach = 0;
6027 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
6028 struct wpa_used_freq_data *freqs_data,
6033 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
6035 for (i = 0; i < len; i++) {
6036 struct wpa_used_freq_data *cur = &freqs_data[i];
6037 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
6038 i, cur->freq, cur->flags);
6044 * Find the operating frequencies of any of the virtual interfaces that
6045 * are using the same radio as the current interface, and in addition, get
6046 * information about the interface types that are using the frequency.
6048 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
6049 struct wpa_used_freq_data *freqs_data,
6052 struct wpa_supplicant *ifs;
6055 unsigned int idx = 0, i;
6057 wpa_dbg(wpa_s, MSG_DEBUG,
6058 "Determining shared radio frequencies (max len %u)", len);
6059 os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
6061 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
6066 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
6069 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
6070 ifs->current_ssid->mode == WPAS_MODE_P2P_GO ||
6071 ifs->current_ssid->mode == WPAS_MODE_MESH)
6072 freq = ifs->current_ssid->frequency;
6073 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
6074 freq = ifs->assoc_freq;
6078 /* Hold only distinct freqs */
6079 for (i = 0; i < idx; i++)
6080 if (freqs_data[i].freq == freq)
6084 freqs_data[idx++].freq = freq;
6086 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
6087 freqs_data[i].flags |= ifs->current_ssid->p2p_group ?
6088 WPA_FREQ_USED_BY_P2P_CLIENT :
6089 WPA_FREQ_USED_BY_INFRA_STATION;
6093 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
6099 * Find the operating frequencies of any of the virtual interfaces that
6100 * are using the same radio as the current interface.
6102 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
6103 int *freq_array, unsigned int len)
6105 struct wpa_used_freq_data *freqs_data;
6108 os_memset(freq_array, 0, sizeof(int) * len);
6110 freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
6114 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
6115 for (i = 0; i < num; i++)
6116 freq_array[i] = freqs_data[i].freq;
6118 os_free(freqs_data);
6124 static void wpas_rrm_neighbor_rep_timeout_handler(void *data, void *user_ctx)
6126 struct rrm_data *rrm = data;
6128 if (!rrm->notify_neighbor_rep) {
6129 wpa_printf(MSG_ERROR,
6130 "RRM: Unexpected neighbor report timeout");
6134 wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report - NONE");
6135 rrm->notify_neighbor_rep(rrm->neighbor_rep_cb_ctx, NULL);
6137 rrm->notify_neighbor_rep = NULL;
6138 rrm->neighbor_rep_cb_ctx = NULL;
6143 * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant
6144 * @wpa_s: Pointer to wpa_supplicant
6146 void wpas_rrm_reset(struct wpa_supplicant *wpa_s)
6148 wpa_s->rrm.rrm_used = 0;
6150 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
6152 if (wpa_s->rrm.notify_neighbor_rep)
6153 wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL);
6154 wpa_s->rrm.next_neighbor_rep_token = 1;
6159 * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
6160 * @wpa_s: Pointer to wpa_supplicant
6161 * @report: Neighbor report buffer, prefixed by a 1-byte dialog token
6162 * @report_len: Length of neighbor report buffer
6164 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s,
6165 const u8 *report, size_t report_len)
6167 struct wpabuf *neighbor_rep;
6169 wpa_hexdump(MSG_DEBUG, "RRM: New Neighbor Report", report, report_len);
6173 if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
6174 wpa_printf(MSG_DEBUG,
6175 "RRM: Discarding neighbor report with token %d (expected %d)",
6176 report[0], wpa_s->rrm.next_neighbor_rep_token - 1);
6180 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
6183 if (!wpa_s->rrm.notify_neighbor_rep) {
6184 wpa_printf(MSG_ERROR, "RRM: Unexpected neighbor report");
6188 /* skipping the first byte, which is only an id (dialog token) */
6189 neighbor_rep = wpabuf_alloc(report_len - 1);
6190 if (neighbor_rep == NULL)
6192 wpabuf_put_data(neighbor_rep, report + 1, report_len - 1);
6193 wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)",
6195 wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
6197 wpa_s->rrm.notify_neighbor_rep = NULL;
6198 wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
6202 #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
6203 /* Workaround different, undefined for Windows, error codes used here */
6205 #define EOPNOTSUPP -1
6206 #define ECANCELED -1
6209 /* Measurement Request element + Location Subject + Maximum Age subelement */
6210 #define MEASURE_REQUEST_LCI_LEN (3 + 1 + 4)
6211 /* Measurement Request element + Location Civic Request */
6212 #define MEASURE_REQUEST_CIVIC_LEN (3 + 5)
6216 * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP
6217 * @wpa_s: Pointer to wpa_supplicant
6218 * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE
6219 * is sent in the request.
6220 * @lci: if set, neighbor request will include LCI request
6221 * @civic: if set, neighbor request will include civic location request
6222 * @cb: Callback function to be called once the requested report arrives, or
6223 * timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds.
6224 * In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's
6225 * the requester's responsibility to free it.
6226 * In the latter case NULL will be sent in 'neighbor_rep'.
6227 * @cb_ctx: Context value to send the callback function
6228 * Returns: 0 in case of success, negative error code otherwise
6230 * In case there is a previous request which has not been answered yet, the
6231 * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT.
6232 * Request must contain a callback function.
6234 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s,
6235 const struct wpa_ssid_value *ssid,
6237 void (*cb)(void *ctx,
6238 struct wpabuf *neighbor_rep),
6244 if (wpa_s->wpa_state != WPA_COMPLETED || wpa_s->current_ssid == NULL) {
6245 wpa_printf(MSG_DEBUG, "RRM: No connection, no RRM.");
6249 if (!wpa_s->rrm.rrm_used) {
6250 wpa_printf(MSG_DEBUG, "RRM: No RRM in current connection.");
6254 rrm_ie = wpa_bss_get_ie(wpa_s->current_bss,
6255 WLAN_EID_RRM_ENABLED_CAPABILITIES);
6256 if (!rrm_ie || !(wpa_s->current_bss->caps & IEEE80211_CAP_RRM) ||
6257 !(rrm_ie[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
6258 wpa_printf(MSG_DEBUG,
6259 "RRM: No network support for Neighbor Report.");
6264 wpa_printf(MSG_DEBUG,
6265 "RRM: Neighbor Report request must provide a callback.");
6269 /* Refuse if there's a live request */
6270 if (wpa_s->rrm.notify_neighbor_rep) {
6271 wpa_printf(MSG_DEBUG,
6272 "RRM: Currently handling previous Neighbor Report.");
6276 /* 3 = action category + action code + dialog token */
6277 buf = wpabuf_alloc(3 + (ssid ? 2 + ssid->ssid_len : 0) +
6278 (lci ? 2 + MEASURE_REQUEST_LCI_LEN : 0) +
6279 (civic ? 2 + MEASURE_REQUEST_CIVIC_LEN : 0));
6281 wpa_printf(MSG_DEBUG,
6282 "RRM: Failed to allocate Neighbor Report Request");
6286 wpa_printf(MSG_DEBUG, "RRM: Neighbor report request (for %s), token=%d",
6287 (ssid ? wpa_ssid_txt(ssid->ssid, ssid->ssid_len) : ""),
6288 wpa_s->rrm.next_neighbor_rep_token);
6290 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6291 wpabuf_put_u8(buf, WLAN_RRM_NEIGHBOR_REPORT_REQUEST);
6292 wpabuf_put_u8(buf, wpa_s->rrm.next_neighbor_rep_token);
6294 wpabuf_put_u8(buf, WLAN_EID_SSID);
6295 wpabuf_put_u8(buf, ssid->ssid_len);
6296 wpabuf_put_data(buf, ssid->ssid, ssid->ssid_len);
6300 /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */
6301 wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST);
6302 wpabuf_put_u8(buf, MEASURE_REQUEST_LCI_LEN);
6305 * Measurement token; nonzero number that is unique among the
6306 * Measurement Request elements in a particular frame.
6308 wpabuf_put_u8(buf, 1); /* Measurement Token */
6311 * Parallel, Enable, Request, and Report bits are 0, Duration is
6314 wpabuf_put_u8(buf, 0); /* Measurement Request Mode */
6315 wpabuf_put_u8(buf, MEASURE_TYPE_LCI); /* Measurement Type */
6317 /* IEEE P802.11-REVmc/D5.0 9.4.2.21.10 - LCI request */
6318 /* Location Subject */
6319 wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE);
6321 /* Optional Subelements */
6323 * IEEE P802.11-REVmc/D5.0 Figure 9-170
6324 * The Maximum Age subelement is required, otherwise the AP can
6325 * send only data that was determined after receiving the
6326 * request. Setting it here to unlimited age.
6328 wpabuf_put_u8(buf, LCI_REQ_SUBELEM_MAX_AGE);
6329 wpabuf_put_u8(buf, 2);
6330 wpabuf_put_le16(buf, 0xffff);
6334 /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */
6335 wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST);
6336 wpabuf_put_u8(buf, MEASURE_REQUEST_CIVIC_LEN);
6339 * Measurement token; nonzero number that is unique among the
6340 * Measurement Request elements in a particular frame.
6342 wpabuf_put_u8(buf, 2); /* Measurement Token */
6345 * Parallel, Enable, Request, and Report bits are 0, Duration is
6348 wpabuf_put_u8(buf, 0); /* Measurement Request Mode */
6349 /* Measurement Type */
6350 wpabuf_put_u8(buf, MEASURE_TYPE_LOCATION_CIVIC);
6352 /* IEEE P802.11-REVmc/D5.0 9.4.2.21.14:
6353 * Location Civic request */
6354 /* Location Subject */
6355 wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE);
6356 wpabuf_put_u8(buf, 0); /* Civic Location Type: IETF RFC 4776 */
6357 /* Location Service Interval Units: Seconds */
6358 wpabuf_put_u8(buf, 0);
6359 /* Location Service Interval: 0 - Only one report is requested
6361 wpabuf_put_le16(buf, 0);
6362 /* No optional subelements */
6365 wpa_s->rrm.next_neighbor_rep_token++;
6367 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
6368 wpa_s->own_addr, wpa_s->bssid,
6369 wpabuf_head(buf), wpabuf_len(buf), 0) < 0) {
6370 wpa_printf(MSG_DEBUG,
6371 "RRM: Failed to send Neighbor Report Request");
6376 wpa_s->rrm.neighbor_rep_cb_ctx = cb_ctx;
6377 wpa_s->rrm.notify_neighbor_rep = cb;
6378 eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT, 0,
6379 wpas_rrm_neighbor_rep_timeout_handler,
6387 static struct wpabuf * wpas_rrm_build_lci_report(struct wpa_supplicant *wpa_s,
6388 const u8 *request, size_t len,
6389 struct wpabuf *report)
6391 u8 token, type, subject;
6393 struct os_reltime t, diff;
6394 unsigned long diff_l;
6398 if (!wpa_s->lci || len < 3 + 4)
6402 /* Measurement request mode isn't used */
6405 subject = *request++;
6407 wpa_printf(MSG_DEBUG,
6408 "Measurement request token %u type %u location subject %u",
6409 token, type, subject);
6411 if (type != MEASURE_TYPE_LCI || subject != LOCATION_SUBJECT_REMOTE) {
6412 wpa_printf(MSG_INFO,
6413 "Not building LCI report - bad type or location subject");
6417 /* Subelements are formatted exactly like elements */
6418 subelem = get_ie(request, len, LCI_REQ_SUBELEM_MAX_AGE);
6419 if (subelem && subelem[1] == 2)
6420 max_age = WPA_GET_LE16(subelem + 2);
6422 if (os_get_reltime(&t))
6425 os_reltime_sub(&t, &wpa_s->lci_time, &diff);
6426 /* LCI age is calculated in 10th of a second units. */
6427 diff_l = diff.sec * 10 + diff.usec / 100000;
6429 if (max_age != 0xffff && max_age < diff_l)
6432 if (wpabuf_resize(&report, 2 + wpabuf_len(wpa_s->lci)))
6435 wpabuf_put_u8(report, WLAN_EID_MEASURE_REPORT);
6436 wpabuf_put_u8(report, wpabuf_len(wpa_s->lci));
6437 /* We'll override user's measurement token */
6438 ptoken = wpabuf_put(report, 0);
6439 wpabuf_put_buf(report, wpa_s->lci);
6446 void wpas_rrm_handle_radio_measurement_request(struct wpa_supplicant *wpa_s,
6448 const u8 *frame, size_t len)
6450 struct wpabuf *buf, *report;
6454 if (wpa_s->wpa_state != WPA_COMPLETED) {
6455 wpa_printf(MSG_INFO,
6456 "RRM: Ignoring radio measurement request: Not associated");
6460 if (!wpa_s->rrm.rrm_used) {
6461 wpa_printf(MSG_INFO,
6462 "RRM: Ignoring radio measurement request: Not RRM network");
6467 wpa_printf(MSG_INFO,
6468 "RRM: Ignoring too short radio measurement request");
6476 /* Ignore number of repetitions because it's not used in LCI request */
6480 while ((ie = get_ie(frame, end - frame, WLAN_EID_MEASURE_REQUEST)) &&
6485 wpa_printf(MSG_DEBUG, "RRM request %d", msmt_type);
6487 switch (msmt_type) {
6488 case MEASURE_TYPE_LCI:
6489 report = wpas_rrm_build_lci_report(wpa_s, ie + 2, ie[1],
6493 wpa_printf(MSG_INFO,
6494 "RRM: Unsupported radio measurement request %d",
6499 frame = ie + ie[1] + 2;
6505 buf = wpabuf_alloc(3 + wpabuf_len(report));
6507 wpabuf_free(report);
6511 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6512 wpabuf_put_u8(buf, WLAN_RRM_RADIO_MEASUREMENT_REPORT);
6513 wpabuf_put_u8(buf, token);
6515 wpabuf_put_buf(buf, report);
6516 wpabuf_free(report);
6518 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6519 wpa_s->own_addr, wpa_s->bssid,
6520 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6521 wpa_printf(MSG_ERROR,
6522 "RRM: Radio measurement report failed: Sending Action frame failed");
6528 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s,
6530 const u8 *frame, size_t len,
6534 const struct rrm_link_measurement_request *req;
6535 struct rrm_link_measurement_report report;
6537 if (wpa_s->wpa_state != WPA_COMPLETED) {
6538 wpa_printf(MSG_INFO,
6539 "RRM: Ignoring link measurement request. Not associated");
6543 if (!wpa_s->rrm.rrm_used) {
6544 wpa_printf(MSG_INFO,
6545 "RRM: Ignoring link measurement request. Not RRM network");
6549 if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION)) {
6550 wpa_printf(MSG_INFO,
6551 "RRM: Measurement report failed. TX power insertion not supported");
6555 req = (const struct rrm_link_measurement_request *) frame;
6556 if (len < sizeof(*req)) {
6557 wpa_printf(MSG_INFO,
6558 "RRM: Link measurement report failed. Request too short");
6562 os_memset(&report, 0, sizeof(report));
6563 report.tpc.eid = WLAN_EID_TPC_REPORT;
6565 report.rsni = 255; /* 255 indicates that RSNI is not available */
6566 report.dialog_token = req->dialog_token;
6569 * It's possible to estimate RCPI based on RSSI in dBm. This
6570 * calculation will not reflect the correct value for high rates,
6571 * but it's good enough for Action frames which are transmitted
6572 * with up to 24 Mbps rates.
6575 report.rcpi = 255; /* not available */
6576 else if (rssi < -110)
6581 report.rcpi = (rssi + 110) * 2;
6583 /* action_category + action_code */
6584 buf = wpabuf_alloc(2 + sizeof(report));
6586 wpa_printf(MSG_ERROR,
6587 "RRM: Link measurement report failed. Buffer allocation failed");
6591 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6592 wpabuf_put_u8(buf, WLAN_RRM_LINK_MEASUREMENT_REPORT);
6593 wpabuf_put_data(buf, &report, sizeof(report));
6594 wpa_hexdump(MSG_DEBUG, "RRM: Link measurement report:",
6595 wpabuf_head(buf), wpabuf_len(buf));
6597 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6598 wpa_s->own_addr, wpa_s->bssid,
6599 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6600 wpa_printf(MSG_ERROR,
6601 "RRM: Link measurement report failed. Send action failed");
6607 struct wpa_supplicant *
6608 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
6612 case VENDOR_ELEM_PROBE_REQ_P2P:
6613 case VENDOR_ELEM_PROBE_RESP_P2P:
6614 case VENDOR_ELEM_PROBE_RESP_P2P_GO:
6615 case VENDOR_ELEM_BEACON_P2P_GO:
6616 case VENDOR_ELEM_P2P_PD_REQ:
6617 case VENDOR_ELEM_P2P_PD_RESP:
6618 case VENDOR_ELEM_P2P_GO_NEG_REQ:
6619 case VENDOR_ELEM_P2P_GO_NEG_RESP:
6620 case VENDOR_ELEM_P2P_GO_NEG_CONF:
6621 case VENDOR_ELEM_P2P_INV_REQ:
6622 case VENDOR_ELEM_P2P_INV_RESP:
6623 case VENDOR_ELEM_P2P_ASSOC_REQ:
6624 case VENDOR_ELEM_P2P_ASSOC_RESP:
6625 return wpa_s->p2pdev;
6626 #endif /* CONFIG_P2P */
6633 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
6638 wpa_printf(MSG_DEBUG, "Update vendor elements");
6640 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
6641 if (wpa_s->vendor_elem[i]) {
6644 res = os_snprintf(buf, sizeof(buf), "frame[%u]", i);
6645 if (!os_snprintf_error(sizeof(buf), res)) {
6646 wpa_hexdump_buf(MSG_DEBUG, buf,
6647 wpa_s->vendor_elem[i]);
6653 if (wpa_s->parent == wpa_s &&
6654 wpa_s->global->p2p &&
6655 !wpa_s->global->p2p_disabled)
6656 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
6657 #endif /* CONFIG_P2P */
6661 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
6662 const u8 *elem, size_t len)
6666 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
6667 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
6669 for (; ie + 1 < end; ie += 2 + ie[1]) {
6672 if (os_memcmp(ie, elem, len) != 0)
6675 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
6676 wpabuf_free(wpa_s->vendor_elem[frame]);
6677 wpa_s->vendor_elem[frame] = NULL;
6679 os_memmove(ie, ie + len, end - (ie + len));
6680 wpa_s->vendor_elem[frame]->used -= len;
6682 wpas_vendor_elem_update(wpa_s);
6690 struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
6691 u16 num_modes, enum hostapd_hw_mode mode)
6695 for (i = 0; i < num_modes; i++) {
6696 if (modes[i].mode == mode)
6705 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
6708 struct wpa_bss_tmp_disallowed *bss;
6710 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
6711 struct wpa_bss_tmp_disallowed, list) {
6712 if (os_memcmp(bssid, bss->bssid, ETH_ALEN) == 0)
6720 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
6723 struct wpa_bss_tmp_disallowed *bss;
6724 struct os_reltime until;
6726 os_get_reltime(&until);
6729 bss = wpas_get_disallowed_bss(wpa_s, bssid);
6731 bss->disallowed_until = until;
6735 bss = os_malloc(sizeof(*bss));
6737 wpa_printf(MSG_DEBUG,
6738 "Failed to allocate memory for temp disallow BSS");
6742 bss->disallowed_until = until;
6743 os_memcpy(bss->bssid, bssid, ETH_ALEN);
6744 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
6748 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s, const u8 *bssid)
6750 struct wpa_bss_tmp_disallowed *bss = NULL, *tmp, *prev;
6751 struct os_reltime now, age;
6753 os_get_reltime(&now);
6755 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
6756 struct wpa_bss_tmp_disallowed, list) {
6757 if (!os_reltime_before(&now, &tmp->disallowed_until)) {
6758 /* This BSS is not disallowed anymore */
6759 dl_list_del(&tmp->list);
6763 if (os_memcmp(bssid, tmp->bssid, ETH_ALEN) == 0) {
6771 os_reltime_sub(&bss->disallowed_until, &now, &age);
6772 wpa_printf(MSG_DEBUG,
6773 "BSS " MACSTR " disabled for %ld.%0ld seconds",
6774 MAC2STR(bss->bssid), age.sec, age.usec);