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 #ifdef CONFIG_HT_OVERRIDES
1905 if (ssid->disable_ht40)
1907 #endif /* CONFIG_HT_OVERRIDES */
1909 /* Check/setup HT40+/HT40- */
1910 for (j = 0; j < ARRAY_SIZE(ht40plus); j++) {
1911 if (ht40plus[j] == channel) {
1917 /* Find secondary channel */
1918 for (i = 0; i < mode->num_channels; i++) {
1919 sec_chan = &mode->channels[i];
1920 if (sec_chan->chan == channel + ht40 * 4)
1927 /* Check secondary channel flags */
1928 if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
1931 freq->channel = pri_chan->chan;
1934 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS))
1937 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS))
1940 freq->sec_channel_offset = ht40;
1943 struct wpa_scan_results *scan_res;
1945 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
1946 if (scan_res == NULL) {
1948 freq->sec_channel_offset = 0;
1952 res = check_40mhz_5g(mode, scan_res, pri_chan->chan,
1957 freq->sec_channel_offset = 0;
1960 /* Configuration allowed */
1963 /* Switch pri/sec channels */
1964 freq->freq = hw_get_freq(mode, sec_chan->chan);
1965 freq->sec_channel_offset = -freq->sec_channel_offset;
1966 freq->channel = sec_chan->chan;
1969 freq->sec_channel_offset = 0;
1973 wpa_scan_results_free(scan_res);
1976 wpa_printf(MSG_DEBUG,
1977 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
1978 freq->channel, freq->sec_channel_offset);
1980 if (!drv_supports_vht(wpa_s, ssid))
1983 /* For IBSS check VHT_IBSS flag */
1984 if (ssid->mode == WPAS_MODE_IBSS &&
1985 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
1990 vht_freq.vht_enabled = vht_supported(mode);
1991 if (!vht_freq.vht_enabled)
1994 /* setup center_freq1, bandwidth */
1995 for (j = 0; j < ARRAY_SIZE(vht80); j++) {
1996 if (freq->channel >= vht80[j] &&
1997 freq->channel < vht80[j] + 16)
2001 if (j == ARRAY_SIZE(vht80))
2004 for (i = vht80[j]; i < vht80[j] + 16; i += 4) {
2005 struct hostapd_channel_data *chan;
2007 chan = hw_get_channel_chan(mode, i, NULL);
2011 /* Back to HT configuration if channel not usable */
2012 if (chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR))
2016 chwidth = VHT_CHANWIDTH_80MHZ;
2017 seg0 = vht80[j] + 6;
2020 if (ssid->max_oper_chwidth == VHT_CHANWIDTH_80P80MHZ) {
2021 /* setup center_freq2, bandwidth */
2022 for (k = 0; k < ARRAY_SIZE(vht80); k++) {
2023 /* Only accept 80 MHz segments separated by a gap */
2024 if (j == k || abs(vht80[j] - vht80[k]) == 16)
2026 for (i = vht80[k]; i < vht80[k] + 16; i += 4) {
2027 struct hostapd_channel_data *chan;
2029 chan = hw_get_channel_chan(mode, i, NULL);
2033 if (chan->flag & (HOSTAPD_CHAN_DISABLED |
2034 HOSTAPD_CHAN_NO_IR |
2035 HOSTAPD_CHAN_RADAR))
2038 /* Found a suitable second segment for 80+80 */
2039 chwidth = VHT_CHANWIDTH_80P80MHZ;
2041 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ;
2042 seg1 = vht80[k] + 6;
2045 if (chwidth == VHT_CHANWIDTH_80P80MHZ)
2048 } else if (ssid->max_oper_chwidth == VHT_CHANWIDTH_160MHZ) {
2049 if (freq->freq == 5180) {
2050 chwidth = VHT_CHANWIDTH_160MHZ;
2051 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2053 } else if (freq->freq == 5520) {
2054 chwidth = VHT_CHANWIDTH_160MHZ;
2055 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
2060 if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq,
2061 freq->channel, freq->ht_enabled,
2062 vht_freq.vht_enabled,
2063 freq->sec_channel_offset,
2064 chwidth, seg0, seg1, vht_caps) != 0)
2069 wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
2070 freq->center_freq1, freq->center_freq2, freq->bandwidth);
2074 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit)
2076 struct wpa_connect_work *cwork = work->ctx;
2077 struct wpa_bss *bss = cwork->bss;
2078 struct wpa_ssid *ssid = cwork->ssid;
2079 struct wpa_supplicant *wpa_s = work->wpa_s;
2082 int use_crypt, ret, i, bssid_changed;
2083 int algs = WPA_AUTH_ALG_OPEN;
2084 unsigned int cipher_pairwise, cipher_group;
2085 struct wpa_driver_associate_params params;
2086 int wep_keys_set = 0;
2087 int assoc_failed = 0;
2088 struct wpa_ssid *old_ssid;
2089 u8 prev_bssid[ETH_ALEN];
2090 #ifdef CONFIG_HT_OVERRIDES
2091 struct ieee80211_ht_capabilities htcaps;
2092 struct ieee80211_ht_capabilities htcaps_mask;
2093 #endif /* CONFIG_HT_OVERRIDES */
2094 #ifdef CONFIG_VHT_OVERRIDES
2095 struct ieee80211_vht_capabilities vhtcaps;
2096 struct ieee80211_vht_capabilities vhtcaps_mask;
2097 #endif /* CONFIG_VHT_OVERRIDES */
2099 const u8 *mbo = NULL;
2100 #endif /* CONFIG_MBO */
2103 if (work->started) {
2104 wpa_s->connect_work = NULL;
2106 /* cancel possible auth. timeout */
2107 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
2110 wpas_connect_work_free(cwork);
2114 wpa_s->connect_work = work;
2116 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
2117 wpas_network_disabled(wpa_s, ssid)) {
2118 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2119 wpas_connect_work_done(wpa_s);
2123 os_memcpy(prev_bssid, wpa_s->bssid, ETH_ALEN);
2124 os_memset(¶ms, 0, sizeof(params));
2125 wpa_s->reassociate = 0;
2126 wpa_s->eap_expected_failure = 0;
2128 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
2129 #ifdef CONFIG_IEEE80211R
2130 const u8 *ie, *md = NULL;
2131 #endif /* CONFIG_IEEE80211R */
2132 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
2133 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
2134 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
2135 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
2136 os_memset(wpa_s->bssid, 0, ETH_ALEN);
2137 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2139 wpas_notify_bssid_changed(wpa_s);
2140 #ifdef CONFIG_IEEE80211R
2141 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
2142 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
2144 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
2146 /* Prepare for the next transition */
2147 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
2149 #endif /* CONFIG_IEEE80211R */
2151 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) &&
2152 wpa_s->conf->ap_scan == 2 &&
2153 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
2154 /* Use ap_scan==1 style network selection to find the network
2156 wpas_connect_work_done(wpa_s);
2157 wpa_s->scan_req = MANUAL_SCAN_REQ;
2158 wpa_s->reassociate = 1;
2159 wpa_supplicant_req_scan(wpa_s, 0, 0);
2161 #endif /* CONFIG_WPS */
2163 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
2164 wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
2165 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2168 wpa_supplicant_cancel_sched_scan(wpa_s);
2170 wpa_supplicant_cancel_scan(wpa_s);
2172 /* Starting new association, so clear the possibly used WPA IE from the
2173 * previous association. */
2174 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
2176 #ifdef IEEE8021X_EAPOL
2177 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2179 if (ssid->non_leap == 0)
2180 algs = WPA_AUTH_ALG_LEAP;
2182 algs |= WPA_AUTH_ALG_LEAP;
2185 #endif /* IEEE8021X_EAPOL */
2186 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2187 if (ssid->auth_alg) {
2188 algs = ssid->auth_alg;
2189 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: "
2193 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
2194 wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
2195 wpa_key_mgmt_wpa(ssid->key_mgmt)) {
2196 int try_opportunistic;
2197 try_opportunistic = (ssid->proactive_key_caching < 0 ?
2199 ssid->proactive_key_caching) &&
2200 (ssid->proto & WPA_PROTO_RSN);
2201 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2202 ssid, try_opportunistic) == 0)
2203 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2204 wpa_ie_len = sizeof(wpa_ie);
2205 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2206 wpa_ie, &wpa_ie_len)) {
2207 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2208 "key management and encryption suites");
2209 wpas_connect_work_done(wpa_s);
2212 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss &&
2213 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) {
2215 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2216 * use non-WPA since the scan results did not indicate that the
2217 * AP is using WPA or WPA2.
2219 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2221 wpa_s->wpa_proto = 0;
2222 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
2223 wpa_ie_len = sizeof(wpa_ie);
2224 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2225 wpa_ie, &wpa_ie_len)) {
2226 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2227 "key management and encryption suites (no "
2229 wpas_connect_work_done(wpa_s);
2233 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
2234 struct wpabuf *wps_ie;
2235 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid));
2236 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) {
2237 wpa_ie_len = wpabuf_len(wps_ie);
2238 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len);
2241 wpabuf_free(wps_ie);
2242 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2243 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY))
2244 params.wps = WPS_MODE_PRIVACY;
2246 params.wps = WPS_MODE_OPEN;
2247 wpa_s->wpa_proto = 0;
2248 #endif /* CONFIG_WPS */
2250 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2252 wpa_s->wpa_proto = 0;
2256 if (wpa_s->global->p2p) {
2260 pos = wpa_ie + wpa_ie_len;
2261 len = sizeof(wpa_ie) - wpa_ie_len;
2262 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2268 wpa_s->cross_connect_disallowed = 0;
2271 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
2273 wpa_s->cross_connect_disallowed =
2274 p2p_get_cross_connect_disallowed(p2p);
2276 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2278 wpa_s->cross_connect_disallowed ?
2279 "disallows" : "allows");
2283 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2284 #endif /* CONFIG_P2P */
2288 mbo = wpa_bss_get_vendor_ie(bss, MBO_IE_VENDOR_TYPE);
2292 len = wpas_mbo_supp_op_class_ie(wpa_s, bss->freq,
2293 wpa_ie + wpa_ie_len,
2300 #endif /* CONFIG_MBO */
2303 * Workaround: Add Extended Capabilities element only if the AP
2304 * included this element in Beacon/Probe Response frames. Some older
2305 * APs seem to have interoperability issues if this element is
2306 * included, so while the standard may require us to include the
2307 * element in all cases, it is justifiable to skip it to avoid
2308 * interoperability issues.
2310 if (ssid->p2p_group)
2311 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
2313 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
2315 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) {
2318 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2320 if (ext_capab_len > 0) {
2322 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN)
2324 os_memmove(pos + ext_capab_len, pos,
2325 wpa_ie_len - (pos - wpa_ie));
2326 wpa_ie_len += ext_capab_len;
2327 os_memcpy(pos, ext_capab, ext_capab_len);
2332 if (is_hs20_network(wpa_s, ssid, bss)) {
2333 struct wpabuf *hs20;
2335 hs20 = wpabuf_alloc(20);
2337 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2340 wpas_hs20_add_indication(hs20, pps_mo_id);
2341 len = sizeof(wpa_ie) - wpa_ie_len;
2342 if (wpabuf_len(hs20) <= len) {
2343 os_memcpy(wpa_ie + wpa_ie_len,
2344 wpabuf_head(hs20), wpabuf_len(hs20));
2345 wpa_ie_len += wpabuf_len(hs20);
2349 hs20_configure_frame_filters(wpa_s);
2352 #endif /* CONFIG_HS20 */
2354 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2355 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2358 len = sizeof(wpa_ie) - wpa_ie_len;
2359 if (wpabuf_len(buf) <= len) {
2360 os_memcpy(wpa_ie + wpa_ie_len,
2361 wpabuf_head(buf), wpabuf_len(buf));
2362 wpa_ie_len += wpabuf_len(buf);
2367 if (wpa_s->fst_ies) {
2368 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2370 if (wpa_ie_len + fst_ies_len <= sizeof(wpa_ie)) {
2371 os_memcpy(wpa_ie + wpa_ie_len,
2372 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2373 wpa_ie_len += fst_ies_len;
2376 #endif /* CONFIG_FST */
2382 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
2383 sizeof(wpa_ie) - wpa_ie_len);
2387 #endif /* CONFIG_MBO */
2389 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2391 cipher_pairwise = wpa_s->pairwise_cipher;
2392 cipher_group = wpa_s->group_cipher;
2393 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2394 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2395 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2397 if (wpa_set_wep_keys(wpa_s, ssid)) {
2402 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2405 #ifdef IEEE8021X_EAPOL
2406 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2407 if ((ssid->eapol_flags &
2408 (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
2409 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 &&
2413 /* Assume that dynamic WEP-104 keys will be used and
2414 * set cipher suites in order for drivers to expect
2416 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104;
2419 #endif /* IEEE8021X_EAPOL */
2421 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2422 /* Set the key before (and later after) association */
2423 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2426 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2428 params.ssid = bss->ssid;
2429 params.ssid_len = bss->ssid_len;
2430 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2431 wpa_printf(MSG_DEBUG, "Limit connection to BSSID "
2432 MACSTR " freq=%u MHz based on scan results "
2434 MAC2STR(bss->bssid), bss->freq,
2436 params.bssid = bss->bssid;
2437 params.freq.freq = bss->freq;
2439 params.bssid_hint = bss->bssid;
2440 params.freq_hint = bss->freq;
2441 params.pbss = bss_is_pbss(bss);
2443 params.ssid = ssid->ssid;
2444 params.ssid_len = ssid->ssid_len;
2445 params.pbss = (ssid->pbss != 2) ? ssid->pbss : 0;
2448 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set &&
2449 wpa_s->conf->ap_scan == 2) {
2450 params.bssid = ssid->bssid;
2451 params.fixed_bssid = 1;
2454 /* Initial frequency for IBSS/mesh */
2455 if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) &&
2456 ssid->frequency > 0 && params.freq.freq == 0)
2457 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
2459 if (ssid->mode == WPAS_MODE_IBSS) {
2460 params.fixed_freq = ssid->fixed_freq;
2461 if (ssid->beacon_int)
2462 params.beacon_int = ssid->beacon_int;
2464 params.beacon_int = wpa_s->conf->beacon_int;
2467 params.wpa_ie = wpa_ie;
2468 params.wpa_ie_len = wpa_ie_len;
2469 params.pairwise_suite = cipher_pairwise;
2470 params.group_suite = cipher_group;
2471 params.key_mgmt_suite = wpa_s->key_mgmt;
2472 params.wpa_proto = wpa_s->wpa_proto;
2473 params.auth_alg = algs;
2474 params.mode = ssid->mode;
2475 params.bg_scan_period = ssid->bg_scan_period;
2476 for (i = 0; i < NUM_WEP_KEYS; i++) {
2477 if (ssid->wep_key_len[i])
2478 params.wep_key[i] = ssid->wep_key[i];
2479 params.wep_key_len[i] = ssid->wep_key_len[i];
2481 params.wep_tx_keyidx = ssid->wep_tx_keyidx;
2483 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2484 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2485 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
2486 params.passphrase = ssid->passphrase;
2488 params.psk = ssid->psk;
2491 if (wpa_s->conf->key_mgmt_offload) {
2492 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
2493 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
2494 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
2495 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192)
2496 params.req_key_mgmt_offload =
2497 ssid->proactive_key_caching < 0 ?
2498 wpa_s->conf->okc : ssid->proactive_key_caching;
2500 params.req_key_mgmt_offload = 1;
2502 if ((params.key_mgmt_suite == WPA_KEY_MGMT_PSK ||
2503 params.key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
2504 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK) &&
2506 params.psk = ssid->psk;
2509 params.drop_unencrypted = use_crypt;
2511 #ifdef CONFIG_IEEE80211W
2512 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
2513 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) {
2514 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
2515 struct wpa_ie_data ie;
2516 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
2518 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) {
2519 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2520 "MFP: require MFP");
2521 params.mgmt_frame_protection =
2522 MGMT_FRAME_PROTECTION_REQUIRED;
2525 #endif /* CONFIG_IEEE80211W */
2527 params.p2p = ssid->p2p_group;
2529 if (wpa_s->p2pdev->set_sta_uapsd)
2530 params.uapsd = wpa_s->p2pdev->sta_uapsd;
2534 #ifdef CONFIG_HT_OVERRIDES
2535 os_memset(&htcaps, 0, sizeof(htcaps));
2536 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask));
2537 params.htcaps = (u8 *) &htcaps;
2538 params.htcaps_mask = (u8 *) &htcaps_mask;
2539 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
2540 #endif /* CONFIG_HT_OVERRIDES */
2541 #ifdef CONFIG_VHT_OVERRIDES
2542 os_memset(&vhtcaps, 0, sizeof(vhtcaps));
2543 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask));
2544 params.vhtcaps = &vhtcaps;
2545 params.vhtcaps_mask = &vhtcaps_mask;
2546 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms);
2547 #endif /* CONFIG_VHT_OVERRIDES */
2551 * If multi-channel concurrency is not supported, check for any
2552 * frequency conflict. In case of any frequency conflict, remove the
2553 * least prioritized connection.
2555 if (wpa_s->num_multichan_concurrent < 2) {
2557 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2558 if (num > 0 && freq > 0 && freq != params.freq.freq) {
2559 wpa_printf(MSG_DEBUG,
2560 "Assoc conflicting freq found (%d != %d)",
2561 freq, params.freq.freq);
2562 if (wpas_p2p_handle_frequency_conflicts(
2563 wpa_s, params.freq.freq, ssid) < 0) {
2564 wpas_connect_work_done(wpa_s);
2569 #endif /* CONFIG_P2P */
2571 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
2572 wpa_s->current_ssid)
2573 params.prev_bssid = prev_bssid;
2575 ret = wpa_drv_associate(wpa_s, ¶ms);
2577 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2579 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2581 * The driver is known to mean what is saying, so we
2582 * can stop right here; the association will not
2585 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2586 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2587 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2590 /* try to continue anyway; new association will be tried again
2595 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2596 /* Set the key after the association just in case association
2597 * cleared the previously configured key. */
2598 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2599 /* No need to timeout authentication since there is no key
2601 wpa_supplicant_cancel_auth_timeout(wpa_s);
2602 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2603 #ifdef CONFIG_IBSS_RSN
2604 } else if (ssid->mode == WPAS_MODE_IBSS &&
2605 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2606 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
2608 * RSN IBSS authentication is per-STA and we can disable the
2609 * per-BSSID authentication.
2611 wpa_supplicant_cancel_auth_timeout(wpa_s);
2612 #endif /* CONFIG_IBSS_RSN */
2614 /* Timeout for IEEE 802.11 authentication and association */
2618 /* give IBSS a bit more time */
2619 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
2620 } else if (wpa_s->conf->ap_scan == 1) {
2621 /* give IBSS a bit more time */
2622 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
2624 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
2628 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
2629 /* Set static WEP keys again */
2630 wpa_set_wep_keys(wpa_s, ssid);
2633 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
2635 * Do not allow EAP session resumption between different
2636 * network configurations.
2638 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2640 old_ssid = wpa_s->current_ssid;
2641 wpa_s->current_ssid = ssid;
2643 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
2644 wpa_s->current_bss = bss;
2646 hs20_configure_frame_filters(wpa_s);
2647 #endif /* CONFIG_HS20 */
2650 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
2651 wpa_supplicant_initiate_eapol(wpa_s);
2652 if (old_ssid != wpa_s->current_ssid)
2653 wpas_notify_network_changed(wpa_s);
2657 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
2660 struct wpa_ssid *old_ssid;
2662 wpas_connect_work_done(wpa_s);
2663 wpa_clear_keys(wpa_s, addr);
2664 old_ssid = wpa_s->current_ssid;
2665 wpa_supplicant_mark_disassoc(wpa_s);
2666 wpa_sm_set_config(wpa_s->wpa, NULL);
2667 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2668 if (old_ssid != wpa_s->current_ssid)
2669 wpas_notify_network_changed(wpa_s);
2670 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
2675 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2676 * @wpa_s: Pointer to wpa_supplicant data
2677 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2679 * This function is used to request %wpa_supplicant to deauthenticate from the
2682 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
2686 union wpa_event_data event;
2689 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
2690 " pending_bssid=" MACSTR " reason=%d state=%s",
2691 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2692 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
2694 if (!is_zero_ether_addr(wpa_s->bssid))
2695 addr = wpa_s->bssid;
2696 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2697 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
2698 wpa_s->wpa_state == WPA_ASSOCIATING))
2699 addr = wpa_s->pending_bssid;
2700 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
2702 * When using driver-based BSS selection, we may not know the
2703 * BSSID with which we are currently trying to associate. We
2704 * need to notify the driver of this disconnection even in such
2705 * a case, so use the all zeros address here.
2707 addr = wpa_s->bssid;
2712 wpa_tdls_teardown_peers(wpa_s->wpa);
2713 #endif /* CONFIG_TDLS */
2717 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
2719 wpa_supplicant_leave_mesh(wpa_s);
2721 #endif /* CONFIG_MESH */
2724 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
2725 os_memset(&event, 0, sizeof(event));
2726 event.deauth_info.reason_code = (u16) reason_code;
2727 event.deauth_info.locally_generated = 1;
2728 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
2733 wpa_supplicant_clear_connection(wpa_s, addr);
2736 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
2737 struct wpa_ssid *ssid)
2739 if (!ssid || !ssid->disabled || ssid->disabled == 2)
2743 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2744 wpas_notify_network_enabled_changed(wpa_s, ssid);
2747 * Try to reassociate since there is no current configuration and a new
2748 * network was made available.
2750 if (!wpa_s->current_ssid && !wpa_s->disconnected)
2751 wpa_s->reassociate = 1;
2756 * wpa_supplicant_add_network - Add a new network
2757 * @wpa_s: wpa_supplicant structure for a network interface
2758 * Returns: The new network configuration or %NULL if operation failed
2760 * This function performs the following operations:
2761 * 1. Adds a new network.
2762 * 2. Send network addition notification.
2763 * 3. Marks the network disabled.
2764 * 4. Set network default parameters.
2766 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s)
2768 struct wpa_ssid *ssid;
2770 ssid = wpa_config_add_network(wpa_s->conf);
2773 wpas_notify_network_added(wpa_s, ssid);
2775 wpa_config_set_network_defaults(ssid);
2782 * wpa_supplicant_remove_network - Remove a configured network based on id
2783 * @wpa_s: wpa_supplicant structure for a network interface
2784 * @id: Unique network id to search for
2785 * Returns: 0 on success, or -1 if the network was not found, -2 if the network
2786 * could not be removed
2788 * This function performs the following operations:
2789 * 1. Removes the network.
2790 * 2. Send network removal notification.
2791 * 3. Update internal state machines.
2792 * 4. Stop any running sched scans.
2794 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id)
2796 struct wpa_ssid *ssid;
2799 ssid = wpa_config_get_network(wpa_s->conf, id);
2802 wpas_notify_network_removed(wpa_s, ssid);
2804 if (wpa_s->last_ssid == ssid)
2805 wpa_s->last_ssid = NULL;
2807 if (ssid == wpa_s->current_ssid || !wpa_s->current_ssid) {
2809 wpa_s->sme.prev_bssid_set = 0;
2810 #endif /* CONFIG_SME */
2812 * Invalidate the EAP session cache if the current or
2813 * previously used network is removed.
2815 eapol_sm_invalidate_cached_session(wpa_s->eapol);
2818 if (ssid == wpa_s->current_ssid) {
2819 wpa_sm_set_config(wpa_s->wpa, NULL);
2820 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2822 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2823 wpa_s->own_disconnect_req = 1;
2824 wpa_supplicant_deauthenticate(wpa_s,
2825 WLAN_REASON_DEAUTH_LEAVING);
2828 was_disabled = ssid->disabled;
2830 if (wpa_config_remove_network(wpa_s->conf, id) < 0)
2833 if (!was_disabled && wpa_s->sched_scanning) {
2834 wpa_printf(MSG_DEBUG,
2835 "Stop ongoing sched_scan to remove network from filters");
2836 wpa_supplicant_cancel_sched_scan(wpa_s);
2837 wpa_supplicant_req_scan(wpa_s, 0, 0);
2845 * wpa_supplicant_enable_network - Mark a configured network as enabled
2846 * @wpa_s: wpa_supplicant structure for a network interface
2847 * @ssid: wpa_ssid structure for a configured network or %NULL
2849 * Enables the specified network or all networks if no network specified.
2851 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
2852 struct wpa_ssid *ssid)
2855 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
2856 wpa_supplicant_enable_one_network(wpa_s, ssid);
2858 wpa_supplicant_enable_one_network(wpa_s, ssid);
2860 if (wpa_s->reassociate && !wpa_s->disconnected &&
2861 (!wpa_s->current_ssid ||
2862 wpa_s->wpa_state == WPA_DISCONNECTED ||
2863 wpa_s->wpa_state == WPA_SCANNING)) {
2864 if (wpa_s->sched_scanning) {
2865 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add "
2866 "new network to scan filters");
2867 wpa_supplicant_cancel_sched_scan(wpa_s);
2870 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
2871 wpa_s->scan_req = NORMAL_SCAN_REQ;
2872 wpa_supplicant_req_scan(wpa_s, 0, 0);
2879 * wpa_supplicant_disable_network - Mark a configured network as disabled
2880 * @wpa_s: wpa_supplicant structure for a network interface
2881 * @ssid: wpa_ssid structure for a configured network or %NULL
2883 * Disables the specified network or all networks if no network specified.
2885 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
2886 struct wpa_ssid *ssid)
2888 struct wpa_ssid *other_ssid;
2892 if (wpa_s->sched_scanning)
2893 wpa_supplicant_cancel_sched_scan(wpa_s);
2895 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2896 other_ssid = other_ssid->next) {
2897 was_disabled = other_ssid->disabled;
2898 if (was_disabled == 2)
2899 continue; /* do not change persistent P2P group
2902 other_ssid->disabled = 1;
2904 if (was_disabled != other_ssid->disabled)
2905 wpas_notify_network_enabled_changed(
2908 if (wpa_s->current_ssid)
2909 wpa_supplicant_deauthenticate(
2910 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2911 } else if (ssid->disabled != 2) {
2912 if (ssid == wpa_s->current_ssid)
2913 wpa_supplicant_deauthenticate(
2914 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2916 was_disabled = ssid->disabled;
2920 if (was_disabled != ssid->disabled) {
2921 wpas_notify_network_enabled_changed(wpa_s, ssid);
2922 if (wpa_s->sched_scanning) {
2923 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan "
2924 "to remove network from filters");
2925 wpa_supplicant_cancel_sched_scan(wpa_s);
2926 wpa_supplicant_req_scan(wpa_s, 0, 0);
2934 * wpa_supplicant_select_network - Attempt association with a network
2935 * @wpa_s: wpa_supplicant structure for a network interface
2936 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2938 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
2939 struct wpa_ssid *ssid)
2942 struct wpa_ssid *other_ssid;
2943 int disconnected = 0;
2945 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
2946 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
2947 wpa_s->own_disconnect_req = 1;
2948 wpa_supplicant_deauthenticate(
2949 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2954 wpas_clear_temp_disabled(wpa_s, ssid, 1);
2957 * Mark all other networks disabled or mark all networks enabled if no
2958 * network specified.
2960 for (other_ssid = wpa_s->conf->ssid; other_ssid;
2961 other_ssid = other_ssid->next) {
2962 int was_disabled = other_ssid->disabled;
2963 if (was_disabled == 2)
2964 continue; /* do not change persistent P2P group data */
2966 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0;
2967 if (was_disabled && !other_ssid->disabled)
2968 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
2970 if (was_disabled != other_ssid->disabled)
2971 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
2974 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
2975 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2976 /* We are already associated with the selected network */
2977 wpa_printf(MSG_DEBUG, "Already associated with the "
2978 "selected network - do nothing");
2983 wpa_s->current_ssid = ssid;
2984 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
2985 wpa_s->connect_without_scan =
2986 (ssid->mode == WPAS_MODE_MESH) ? ssid : NULL;
2989 * Don't optimize next scan freqs since a new ESS has been
2992 os_free(wpa_s->next_scan_freqs);
2993 wpa_s->next_scan_freqs = NULL;
2995 wpa_s->connect_without_scan = NULL;
2998 wpa_s->disconnected = 0;
2999 wpa_s->reassociate = 1;
3001 if (wpa_s->connect_without_scan ||
3002 wpa_supplicant_fast_associate(wpa_s) != 1) {
3003 wpa_s->scan_req = NORMAL_SCAN_REQ;
3004 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
3008 wpas_notify_network_selected(wpa_s, ssid);
3013 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
3014 * @wpa_s: wpa_supplicant structure for a network interface
3015 * @pkcs11_engine_path: PKCS #11 engine path or NULL
3016 * @pkcs11_module_path: PKCS #11 module path or NULL
3017 * Returns: 0 on success; -1 on failure
3019 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
3020 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
3021 * module path fails the paths will be reset to the default value (NULL).
3023 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
3024 const char *pkcs11_engine_path,
3025 const char *pkcs11_module_path)
3027 char *pkcs11_engine_path_copy = NULL;
3028 char *pkcs11_module_path_copy = NULL;
3030 if (pkcs11_engine_path != NULL) {
3031 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path);
3032 if (pkcs11_engine_path_copy == NULL)
3035 if (pkcs11_module_path != NULL) {
3036 pkcs11_module_path_copy = os_strdup(pkcs11_module_path);
3037 if (pkcs11_module_path_copy == NULL) {
3038 os_free(pkcs11_engine_path_copy);
3043 os_free(wpa_s->conf->pkcs11_engine_path);
3044 os_free(wpa_s->conf->pkcs11_module_path);
3045 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
3046 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
3048 wpa_sm_set_eapol(wpa_s->wpa, NULL);
3049 eapol_sm_deinit(wpa_s->eapol);
3050 wpa_s->eapol = NULL;
3051 if (wpa_supplicant_init_eapol(wpa_s)) {
3052 /* Error -> Reset paths to the default value (NULL) once. */
3053 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL)
3054 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
3059 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3066 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
3067 * @wpa_s: wpa_supplicant structure for a network interface
3068 * @ap_scan: AP scan mode
3069 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
3072 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
3077 if (ap_scan < 0 || ap_scan > 2)
3080 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3081 wpa_printf(MSG_INFO,
3082 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3086 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
3087 wpa_s->wpa_state >= WPA_ASSOCIATING &&
3088 wpa_s->wpa_state < WPA_COMPLETED) {
3089 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while "
3090 "associating", wpa_s->conf->ap_scan, ap_scan);
3093 #endif /* ANDROID */
3095 old_ap_scan = wpa_s->conf->ap_scan;
3096 wpa_s->conf->ap_scan = ap_scan;
3098 if (old_ap_scan != wpa_s->conf->ap_scan)
3099 wpas_notify_ap_scan_changed(wpa_s);
3106 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
3107 * @wpa_s: wpa_supplicant structure for a network interface
3108 * @expire_age: Expiration age in seconds
3109 * Returns: 0 if succeed or -1 if expire_age has an invalid value
3112 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
3113 unsigned int bss_expire_age)
3115 if (bss_expire_age < 10) {
3116 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
3120 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
3122 wpa_s->conf->bss_expiration_age = bss_expire_age;
3129 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
3130 * @wpa_s: wpa_supplicant structure for a network interface
3131 * @expire_count: number of scans after which an unseen BSS is reclaimed
3132 * Returns: 0 if succeed or -1 if expire_count has an invalid value
3135 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
3136 unsigned int bss_expire_count)
3138 if (bss_expire_count < 1) {
3139 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
3143 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
3145 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
3152 * wpa_supplicant_set_scan_interval - Set scan interval
3153 * @wpa_s: wpa_supplicant structure for a network interface
3154 * @scan_interval: scan interval in seconds
3155 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
3158 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
3161 if (scan_interval < 0) {
3162 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
3166 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3168 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3175 * wpa_supplicant_set_debug_params - Set global debug params
3176 * @global: wpa_global structure
3177 * @debug_level: debug level
3178 * @debug_timestamp: determines if show timestamp in debug data
3179 * @debug_show_keys: determines if show keys in debug data
3180 * Returns: 0 if succeed or -1 if debug_level has wrong value
3182 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level,
3183 int debug_timestamp, int debug_show_keys)
3186 int old_level, old_timestamp, old_show_keys;
3188 /* check for allowed debuglevels */
3189 if (debug_level != MSG_EXCESSIVE &&
3190 debug_level != MSG_MSGDUMP &&
3191 debug_level != MSG_DEBUG &&
3192 debug_level != MSG_INFO &&
3193 debug_level != MSG_WARNING &&
3194 debug_level != MSG_ERROR)
3197 old_level = wpa_debug_level;
3198 old_timestamp = wpa_debug_timestamp;
3199 old_show_keys = wpa_debug_show_keys;
3201 wpa_debug_level = debug_level;
3202 wpa_debug_timestamp = debug_timestamp ? 1 : 0;
3203 wpa_debug_show_keys = debug_show_keys ? 1 : 0;
3205 if (wpa_debug_level != old_level)
3206 wpas_notify_debug_level_changed(global);
3207 if (wpa_debug_timestamp != old_timestamp)
3208 wpas_notify_debug_timestamp_changed(global);
3209 if (wpa_debug_show_keys != old_show_keys)
3210 wpas_notify_debug_show_keys_changed(global);
3217 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
3218 * @wpa_s: Pointer to wpa_supplicant data
3219 * Returns: A pointer to the current network structure or %NULL on failure
3221 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
3223 struct wpa_ssid *entry;
3224 u8 ssid[SSID_MAX_LEN];
3230 res = wpa_drv_get_ssid(wpa_s, ssid);
3232 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
3238 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
3239 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
3244 wired = wpa_s->conf->ap_scan == 0 &&
3245 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
3247 entry = wpa_s->conf->ssid;
3249 if (!wpas_network_disabled(wpa_s, entry) &&
3250 ((ssid_len == entry->ssid_len &&
3251 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) &&
3252 (!entry->bssid_set ||
3253 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3256 if (!wpas_network_disabled(wpa_s, entry) &&
3257 (entry->key_mgmt & WPA_KEY_MGMT_WPS) &&
3258 (entry->ssid == NULL || entry->ssid_len == 0) &&
3259 (!entry->bssid_set ||
3260 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0))
3262 #endif /* CONFIG_WPS */
3264 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
3265 entry->ssid_len == 0 &&
3266 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)
3269 entry = entry->next;
3276 static int select_driver(struct wpa_supplicant *wpa_s, int i)
3278 struct wpa_global *global = wpa_s->global;
3280 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {
3281 global->drv_priv[i] = wpa_drivers[i]->global_init(global);
3282 if (global->drv_priv[i] == NULL) {
3283 wpa_printf(MSG_ERROR, "Failed to initialize driver "
3284 "'%s'", wpa_drivers[i]->name);
3289 wpa_s->driver = wpa_drivers[i];
3290 wpa_s->global_drv_priv = global->drv_priv[i];
3296 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
3301 const char *pos, *driver = name;
3306 if (wpa_drivers[0] == NULL) {
3307 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
3313 /* default to first driver in the list */
3314 return select_driver(wpa_s, 0);
3318 pos = os_strchr(driver, ',');
3322 len = os_strlen(driver);
3324 for (i = 0; wpa_drivers[i]; i++) {
3325 if (os_strlen(wpa_drivers[i]->name) == len &&
3326 os_strncmp(driver, wpa_drivers[i]->name, len) ==
3328 /* First driver that succeeds wins */
3329 if (select_driver(wpa_s, i) == 0)
3337 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
3343 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
3344 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3345 * with struct wpa_driver_ops::init()
3346 * @src_addr: Source address of the EAPOL frame
3347 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3348 * @len: Length of the EAPOL data
3350 * This function is called for each received EAPOL frame. Most driver
3351 * interfaces rely on more generic OS mechanism for receiving frames through
3352 * l2_packet, but if such a mechanism is not available, the driver wrapper may
3353 * take care of received EAPOL frames and deliver them to the core supplicant
3354 * code by calling this function.
3356 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
3357 const u8 *buf, size_t len)
3359 struct wpa_supplicant *wpa_s = ctx;
3361 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3362 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len);
3364 #ifdef CONFIG_PEERKEY
3365 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid &&
3366 wpa_s->current_ssid->peerkey &&
3367 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
3368 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) {
3369 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key");
3372 #endif /* CONFIG_PEERKEY */
3374 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3375 (wpa_s->last_eapol_matches_bssid &&
3378 #endif /* CONFIG_AP */
3379 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3381 * There is possible race condition between receiving the
3382 * association event and the EAPOL frame since they are coming
3383 * through different paths from the driver. In order to avoid
3384 * issues in trying to process the EAPOL frame before receiving
3385 * association information, lets queue it for processing until
3386 * the association event is received. This may also be needed in
3387 * driver-based roaming case, so also use src_addr != BSSID as a
3388 * trigger if we have previously confirmed that the
3389 * Authenticator uses BSSID as the src_addr (which is not the
3390 * case with wired IEEE 802.1X).
3392 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3393 "of received EAPOL frame (state=%s bssid=" MACSTR ")",
3394 wpa_supplicant_state_txt(wpa_s->wpa_state),
3395 MAC2STR(wpa_s->bssid));
3396 wpabuf_free(wpa_s->pending_eapol_rx);
3397 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3398 if (wpa_s->pending_eapol_rx) {
3399 os_get_reltime(&wpa_s->pending_eapol_rx_time);
3400 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3406 wpa_s->last_eapol_matches_bssid =
3407 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3410 if (wpa_s->ap_iface) {
3411 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3414 #endif /* CONFIG_AP */
3416 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3417 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3418 "no key management is configured");
3422 if (wpa_s->eapol_received == 0 &&
3423 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3424 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3425 wpa_s->wpa_state != WPA_COMPLETED) &&
3426 (wpa_s->current_ssid == NULL ||
3427 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3428 /* Timeout for completing IEEE 802.1X and WPA authentication */
3431 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3432 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3433 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3434 /* Use longer timeout for IEEE 802.1X/EAP */
3439 if (wpa_s->current_ssid && wpa_s->current_bss &&
3440 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3441 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3443 * Use shorter timeout if going through WPS AP iteration
3444 * for PIN config method with an AP that does not
3445 * advertise Selected Registrar.
3447 struct wpabuf *wps_ie;
3449 wps_ie = wpa_bss_get_vendor_ie_multi(
3450 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3452 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3454 wpabuf_free(wps_ie);
3456 #endif /* CONFIG_WPS */
3458 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3460 wpa_s->eapol_received++;
3462 if (wpa_s->countermeasures) {
3463 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3468 #ifdef CONFIG_IBSS_RSN
3469 if (wpa_s->current_ssid &&
3470 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3471 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3474 #endif /* CONFIG_IBSS_RSN */
3476 /* Source address of the incoming EAPOL frame could be compared to the
3477 * current BSSID. However, it is possible that a centralized
3478 * Authenticator could be using another MAC address than the BSSID of
3479 * an AP, so just allow any address to be used for now. The replies are
3480 * still sent to the current BSSID (if available), though. */
3482 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3483 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3484 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3486 wpa_drv_poll(wpa_s);
3487 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3488 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3489 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3491 * Set portValid = TRUE here since we are going to skip 4-way
3492 * handshake processing which would normally set portValid. We
3493 * need this to allow the EAPOL state machines to be completed
3494 * without going through EAPOL-Key handshake.
3496 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3501 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3503 if ((!wpa_s->p2p_mgmt ||
3504 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3505 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3506 l2_packet_deinit(wpa_s->l2);
3507 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3508 wpa_drv_get_mac_addr(wpa_s),
3510 wpa_supplicant_rx_eapol, wpa_s, 0);
3511 if (wpa_s->l2 == NULL)
3514 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3516 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3519 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3520 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3524 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3530 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr,
3531 const u8 *buf, size_t len)
3533 struct wpa_supplicant *wpa_s = ctx;
3534 const struct l2_ethhdr *eth;
3536 if (len < sizeof(*eth))
3538 eth = (const struct l2_ethhdr *) buf;
3540 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3541 !(eth->h_dest[0] & 0x01)) {
3542 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3543 " (bridge - not for this interface - ignore)",
3544 MAC2STR(src_addr), MAC2STR(eth->h_dest));
3548 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3549 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest));
3550 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
3551 len - sizeof(*eth));
3556 * wpa_supplicant_driver_init - Initialize driver interface parameters
3557 * @wpa_s: Pointer to wpa_supplicant data
3558 * Returns: 0 on success, -1 on failure
3560 * This function is called to initialize driver interface parameters.
3561 * wpa_drv_init() must have been called before this function to initialize the
3564 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
3566 static int interface_count = 0;
3568 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
3571 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
3572 MAC2STR(wpa_s->own_addr));
3573 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
3574 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3576 if (wpa_s->bridge_ifname[0]) {
3577 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
3578 "interface '%s'", wpa_s->bridge_ifname);
3579 wpa_s->l2_br = l2_packet_init_bridge(
3580 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
3581 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
3582 if (wpa_s->l2_br == NULL) {
3583 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
3584 "connection for the bridge interface '%s'",
3585 wpa_s->bridge_ifname);
3590 if (wpa_s->conf->ap_scan == 2 &&
3591 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3592 wpa_printf(MSG_INFO,
3593 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3596 wpa_clear_keys(wpa_s, NULL);
3598 /* Make sure that TKIP countermeasures are not left enabled (could
3599 * happen if wpa_supplicant is killed during countermeasures. */
3600 wpa_drv_set_countermeasures(wpa_s, 0);
3602 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
3603 wpa_drv_flush_pmkid(wpa_s);
3605 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
3606 wpa_s->prev_scan_wildcard = 0;
3608 if (wpa_supplicant_enabled_networks(wpa_s)) {
3609 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
3610 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3611 interface_count = 0;
3614 if (!wpa_s->p2p_mgmt &&
3615 wpa_supplicant_delayed_sched_scan(wpa_s,
3616 interface_count % 3,
3618 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
3620 #endif /* ANDROID */
3623 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
3629 static int wpa_supplicant_daemon(const char *pid_file)
3631 wpa_printf(MSG_DEBUG, "Daemonize..");
3632 return os_daemonize(pid_file);
3636 static struct wpa_supplicant *
3637 wpa_supplicant_alloc(struct wpa_supplicant *parent)
3639 struct wpa_supplicant *wpa_s;
3641 wpa_s = os_zalloc(sizeof(*wpa_s));
3644 wpa_s->scan_req = INITIAL_SCAN_REQ;
3645 wpa_s->scan_interval = 5;
3646 wpa_s->new_connection = 1;
3647 wpa_s->parent = parent ? parent : wpa_s;
3648 wpa_s->p2pdev = wpa_s->parent;
3649 wpa_s->sched_scanning = 0;
3651 dl_list_init(&wpa_s->bss_tmp_disallowed);
3657 #ifdef CONFIG_HT_OVERRIDES
3659 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
3660 struct ieee80211_ht_capabilities *htcaps,
3661 struct ieee80211_ht_capabilities *htcaps_mask,
3664 /* parse ht_mcs into hex array */
3666 const char *tmp = ht_mcs;
3669 /* If ht_mcs is null, do not set anything */
3673 /* This is what we are setting in the kernel */
3674 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN);
3676 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
3678 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
3680 long v = strtol(tmp, &end, 16);
3682 wpa_msg(wpa_s, MSG_DEBUG,
3683 "htcap value[%i]: %ld end: %p tmp: %p",
3688 htcaps->supported_mcs_set[i] = v;
3691 wpa_msg(wpa_s, MSG_ERROR,
3692 "Failed to parse ht-mcs: %s, error: %s\n",
3693 ht_mcs, strerror(errno));
3699 * If we were able to parse any values, then set mask for the MCS set.
3702 os_memset(&htcaps_mask->supported_mcs_set, 0xff,
3703 IEEE80211_HT_MCS_MASK_LEN - 1);
3704 /* skip the 3 reserved bits */
3705 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] =
3713 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
3714 struct ieee80211_ht_capabilities *htcaps,
3715 struct ieee80211_ht_capabilities *htcaps_mask,
3720 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
3725 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE);
3726 htcaps_mask->ht_capabilities_info |= msk;
3728 htcaps->ht_capabilities_info &= msk;
3730 htcaps->ht_capabilities_info |= msk;
3736 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
3737 struct ieee80211_ht_capabilities *htcaps,
3738 struct ieee80211_ht_capabilities *htcaps_mask,
3741 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
3746 if (factor < 0 || factor > 3) {
3747 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
3748 "Must be 0-3 or -1", factor);
3752 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */
3753 htcaps->a_mpdu_params &= ~0x3;
3754 htcaps->a_mpdu_params |= factor & 0x3;
3760 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
3761 struct ieee80211_ht_capabilities *htcaps,
3762 struct ieee80211_ht_capabilities *htcaps_mask,
3765 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
3770 if (density < 0 || density > 7) {
3771 wpa_msg(wpa_s, MSG_ERROR,
3772 "ampdu_density: %d out of range. Must be 0-7 or -1.",
3777 htcaps_mask->a_mpdu_params |= 0x1C;
3778 htcaps->a_mpdu_params &= ~(0x1C);
3779 htcaps->a_mpdu_params |= (density << 2) & 0x1C;
3785 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
3786 struct ieee80211_ht_capabilities *htcaps,
3787 struct ieee80211_ht_capabilities *htcaps_mask,
3790 /* Masking these out disables HT40 */
3791 le16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET |
3792 HT_CAP_INFO_SHORT_GI40MHZ);
3794 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
3797 htcaps->ht_capabilities_info &= ~msk;
3799 htcaps->ht_capabilities_info |= msk;
3801 htcaps_mask->ht_capabilities_info |= msk;
3807 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
3808 struct ieee80211_ht_capabilities *htcaps,
3809 struct ieee80211_ht_capabilities *htcaps_mask,
3812 /* Masking these out disables SGI */
3813 le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ |
3814 HT_CAP_INFO_SHORT_GI40MHZ);
3816 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
3819 htcaps->ht_capabilities_info &= ~msk;
3821 htcaps->ht_capabilities_info |= msk;
3823 htcaps_mask->ht_capabilities_info |= msk;
3829 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
3830 struct ieee80211_ht_capabilities *htcaps,
3831 struct ieee80211_ht_capabilities *htcaps_mask,
3834 /* Masking these out disables LDPC */
3835 le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP);
3837 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
3840 htcaps->ht_capabilities_info &= ~msk;
3842 htcaps->ht_capabilities_info |= msk;
3844 htcaps_mask->ht_capabilities_info |= msk;
3850 void wpa_supplicant_apply_ht_overrides(
3851 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3852 struct wpa_driver_associate_params *params)
3854 struct ieee80211_ht_capabilities *htcaps;
3855 struct ieee80211_ht_capabilities *htcaps_mask;
3860 params->disable_ht = ssid->disable_ht;
3861 if (!params->htcaps || !params->htcaps_mask)
3864 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps;
3865 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask;
3866 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
3867 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
3868 ssid->disable_max_amsdu);
3869 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
3870 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
3871 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
3872 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
3873 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
3875 if (ssid->ht40_intolerant) {
3876 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT);
3877 htcaps->ht_capabilities_info |= bit;
3878 htcaps_mask->ht_capabilities_info |= bit;
3882 #endif /* CONFIG_HT_OVERRIDES */
3885 #ifdef CONFIG_VHT_OVERRIDES
3886 void wpa_supplicant_apply_vht_overrides(
3887 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3888 struct wpa_driver_associate_params *params)
3890 struct ieee80211_vht_capabilities *vhtcaps;
3891 struct ieee80211_vht_capabilities *vhtcaps_mask;
3896 params->disable_vht = ssid->disable_vht;
3898 vhtcaps = (void *) params->vhtcaps;
3899 vhtcaps_mask = (void *) params->vhtcaps_mask;
3901 if (!vhtcaps || !vhtcaps_mask)
3904 vhtcaps->vht_capabilities_info = host_to_le32(ssid->vht_capa);
3905 vhtcaps_mask->vht_capabilities_info = host_to_le32(ssid->vht_capa_mask);
3907 #ifdef CONFIG_HT_OVERRIDES
3908 /* if max ampdu is <= 3, we have to make the HT cap the same */
3909 if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) {
3912 max_ampdu = (ssid->vht_capa &
3913 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >>
3914 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT;
3916 max_ampdu = max_ampdu < 3 ? max_ampdu : 3;
3917 wpa_set_ampdu_factor(wpa_s,
3918 (void *) params->htcaps,
3919 (void *) params->htcaps_mask,
3922 #endif /* CONFIG_HT_OVERRIDES */
3924 #define OVERRIDE_MCS(i) \
3925 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
3926 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
3927 host_to_le16(3 << 2 * (i - 1)); \
3928 vhtcaps->vht_supported_mcs_set.tx_map |= \
3929 host_to_le16(ssid->vht_tx_mcs_nss_ ##i << \
3932 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
3933 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
3934 host_to_le16(3 << 2 * (i - 1)); \
3935 vhtcaps->vht_supported_mcs_set.rx_map |= \
3936 host_to_le16(ssid->vht_rx_mcs_nss_ ##i << \
3949 #endif /* CONFIG_VHT_OVERRIDES */
3952 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
3957 if (!wpa_s->conf->pcsc_reader)
3960 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
3964 if (wpa_s->conf->pcsc_pin &&
3965 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
3966 scard_deinit(wpa_s->scard);
3967 wpa_s->scard = NULL;
3968 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
3972 len = sizeof(wpa_s->imsi) - 1;
3973 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
3974 scard_deinit(wpa_s->scard);
3975 wpa_s->scard = NULL;
3976 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
3979 wpa_s->imsi[len] = '\0';
3981 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
3983 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)",
3984 wpa_s->imsi, wpa_s->mnc_len);
3986 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
3987 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
3988 #endif /* PCSC_FUNCS */
3994 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
3998 ext_password_deinit(wpa_s->ext_pw);
3999 wpa_s->ext_pw = NULL;
4000 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
4002 if (!wpa_s->conf->ext_password_backend)
4005 val = os_strdup(wpa_s->conf->ext_password_backend);
4008 pos = os_strchr(val, ':');
4012 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val);
4014 wpa_s->ext_pw = ext_password_init(val, pos);
4016 if (wpa_s->ext_pw == NULL) {
4017 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend");
4020 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
4028 static const u8 * wpas_fst_get_bssid_cb(void *ctx)
4030 struct wpa_supplicant *wpa_s = ctx;
4032 return (is_zero_ether_addr(wpa_s->bssid) ||
4033 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
4037 static void wpas_fst_get_channel_info_cb(void *ctx,
4038 enum hostapd_hw_mode *hw_mode,
4041 struct wpa_supplicant *wpa_s = ctx;
4043 if (wpa_s->current_bss) {
4044 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
4046 } else if (wpa_s->hw.num_modes) {
4047 *hw_mode = wpa_s->hw.modes[0].mode;
4055 static int wpas_fst_get_hw_modes(void *ctx, struct hostapd_hw_modes **modes)
4057 struct wpa_supplicant *wpa_s = ctx;
4059 *modes = wpa_s->hw.modes;
4060 return wpa_s->hw.num_modes;
4064 static void wpas_fst_set_ies_cb(void *ctx, const struct wpabuf *fst_ies)
4066 struct wpa_supplicant *wpa_s = ctx;
4068 wpa_hexdump_buf(MSG_DEBUG, "FST: Set IEs", fst_ies);
4069 wpa_s->fst_ies = fst_ies;
4073 static int wpas_fst_send_action_cb(void *ctx, const u8 *da, struct wpabuf *data)
4075 struct wpa_supplicant *wpa_s = ctx;
4077 WPA_ASSERT(os_memcmp(wpa_s->bssid, da, ETH_ALEN) == 0);
4078 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
4079 wpa_s->own_addr, wpa_s->bssid,
4080 wpabuf_head(data), wpabuf_len(data),
4085 static const struct wpabuf * wpas_fst_get_mb_ie_cb(void *ctx, const u8 *addr)
4087 struct wpa_supplicant *wpa_s = ctx;
4089 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4090 return wpa_s->received_mb_ies;
4094 static void wpas_fst_update_mb_ie_cb(void *ctx, const u8 *addr,
4095 const u8 *buf, size_t size)
4097 struct wpa_supplicant *wpa_s = ctx;
4098 struct mb_ies_info info;
4100 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4102 if (!mb_ies_info_by_ies(&info, buf, size)) {
4103 wpabuf_free(wpa_s->received_mb_ies);
4104 wpa_s->received_mb_ies = mb_ies_by_info(&info);
4109 static const u8 * wpas_fst_get_peer_first(void *ctx,
4110 struct fst_get_peer_ctx **get_ctx,
4113 struct wpa_supplicant *wpa_s = ctx;
4116 if (!is_zero_ether_addr(wpa_s->bssid))
4117 return (wpa_s->received_mb_ies || !mb_only) ?
4118 wpa_s->bssid : NULL;
4123 static const u8 * wpas_fst_get_peer_next(void *ctx,
4124 struct fst_get_peer_ctx **get_ctx,
4130 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
4131 struct fst_wpa_obj *iface_obj)
4133 iface_obj->ctx = wpa_s;
4134 iface_obj->get_bssid = wpas_fst_get_bssid_cb;
4135 iface_obj->get_channel_info = wpas_fst_get_channel_info_cb;
4136 iface_obj->get_hw_modes = wpas_fst_get_hw_modes;
4137 iface_obj->set_ies = wpas_fst_set_ies_cb;
4138 iface_obj->send_action = wpas_fst_send_action_cb;
4139 iface_obj->get_mb_ie = wpas_fst_get_mb_ie_cb;
4140 iface_obj->update_mb_ie = wpas_fst_update_mb_ie_cb;
4141 iface_obj->get_peer_first = wpas_fst_get_peer_first;
4142 iface_obj->get_peer_next = wpas_fst_get_peer_next;
4144 #endif /* CONFIG_FST */
4146 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
4147 const struct wpa_driver_capa *capa)
4149 struct wowlan_triggers *triggers;
4152 if (!wpa_s->conf->wowlan_triggers)
4155 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
4157 ret = wpa_drv_wowlan(wpa_s, triggers);
4164 enum wpa_radio_work_band wpas_freq_to_band(int freq)
4167 return BAND_2_4_GHZ;
4174 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
4177 unsigned int band = 0;
4180 /* freqs are specified for the radio work */
4181 for (i = 0; freqs[i]; i++)
4182 band |= wpas_freq_to_band(freqs[i]);
4185 * freqs are not specified, implies all
4186 * the supported freqs by HW
4188 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4189 if (wpa_s->hw.modes[i].num_channels != 0) {
4190 if (wpa_s->hw.modes[i].mode ==
4191 HOSTAPD_MODE_IEEE80211B ||
4192 wpa_s->hw.modes[i].mode ==
4193 HOSTAPD_MODE_IEEE80211G)
4194 band |= BAND_2_4_GHZ;
4195 else if (wpa_s->hw.modes[i].mode ==
4196 HOSTAPD_MODE_IEEE80211A)
4198 else if (wpa_s->hw.modes[i].mode ==
4199 HOSTAPD_MODE_IEEE80211AD)
4200 band |= BAND_60_GHZ;
4201 else if (wpa_s->hw.modes[i].mode ==
4202 HOSTAPD_MODE_IEEE80211ANY)
4203 band = BAND_2_4_GHZ | BAND_5_GHZ |
4213 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
4216 struct wpa_supplicant *iface = wpa_s->global->ifaces;
4217 struct wpa_radio *radio;
4219 while (rn && iface) {
4220 radio = iface->radio;
4221 if (radio && os_strcmp(rn, radio->name) == 0) {
4222 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s",
4224 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4228 iface = iface->next;
4231 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s",
4232 wpa_s->ifname, rn ? rn : "N/A");
4233 radio = os_zalloc(sizeof(*radio));
4238 os_strlcpy(radio->name, rn, sizeof(radio->name));
4239 dl_list_init(&radio->ifaces);
4240 dl_list_init(&radio->work);
4241 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4247 static void radio_work_free(struct wpa_radio_work *work)
4249 if (work->wpa_s->scan_work == work) {
4250 /* This should not really happen. */
4251 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4252 work->type, work, work->started);
4253 work->wpa_s->scan_work = NULL;
4257 if (work->wpa_s->p2p_scan_work == work) {
4258 /* This should not really happen. */
4259 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4260 work->type, work, work->started);
4261 work->wpa_s->p2p_scan_work = NULL;
4263 #endif /* CONFIG_P2P */
4265 if (work->started) {
4266 work->wpa_s->radio->num_active_works--;
4267 wpa_dbg(work->wpa_s, MSG_DEBUG,
4268 "radio_work_free('%s'@%p: num_active_works --> %u",
4270 work->wpa_s->radio->num_active_works);
4273 dl_list_del(&work->list);
4278 static struct wpa_radio_work * radio_work_get_next_work(struct wpa_radio *radio)
4280 struct wpa_radio_work *active_work = NULL;
4281 struct wpa_radio_work *tmp;
4283 /* Get the active work to know the type and band. */
4284 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4292 /* No active work, start one */
4293 radio->num_active_works = 0;
4294 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work,
4296 if (os_strcmp(tmp->type, "scan") == 0 &&
4297 radio->external_scan_running &&
4298 (((struct wpa_driver_scan_params *)
4299 tmp->ctx)->only_new_results ||
4300 tmp->wpa_s->clear_driver_scan_cache))
4307 if (os_strcmp(active_work->type, "sme-connect") == 0 ||
4308 os_strcmp(active_work->type, "connect") == 0) {
4310 * If the active work is either connect or sme-connect,
4311 * do not parallelize them with other radio works.
4313 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4314 "Do not parallelize radio work with %s",
4319 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) {
4324 * If connect or sme-connect are enqueued, parallelize only
4325 * those operations ahead of them in the queue.
4327 if (os_strcmp(tmp->type, "connect") == 0 ||
4328 os_strcmp(tmp->type, "sme-connect") == 0)
4332 * Check that the radio works are distinct and
4333 * on different bands.
4335 if (os_strcmp(active_work->type, tmp->type) != 0 &&
4336 (active_work->bands != tmp->bands)) {
4338 * If a scan has to be scheduled through nl80211 scan
4339 * interface and if an external scan is already running,
4340 * do not schedule the scan since it is likely to get
4341 * rejected by kernel.
4343 if (os_strcmp(tmp->type, "scan") == 0 &&
4344 radio->external_scan_running &&
4345 (((struct wpa_driver_scan_params *)
4346 tmp->ctx)->only_new_results ||
4347 tmp->wpa_s->clear_driver_scan_cache))
4350 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4351 "active_work:%s new_work:%s",
4352 active_work->type, tmp->type);
4357 /* Did not find a radio work to schedule in parallel. */
4362 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx)
4364 struct wpa_radio *radio = eloop_ctx;
4365 struct wpa_radio_work *work;
4366 struct os_reltime now, diff;
4367 struct wpa_supplicant *wpa_s;
4369 work = dl_list_first(&radio->work, struct wpa_radio_work, list);
4371 radio->num_active_works = 0;
4375 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
4379 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
4381 return; /* already started and still in progress */
4383 if (wpa_s && wpa_s->radio->external_scan_running) {
4384 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes");
4389 if (radio->num_active_works < MAX_ACTIVE_WORKS) {
4390 /* get the work to schedule next */
4391 work = radio_work_get_next_work(radio);
4397 wpa_s = work->wpa_s;
4398 os_get_reltime(&now);
4399 os_reltime_sub(&now, &work->time, &diff);
4400 wpa_dbg(wpa_s, MSG_DEBUG,
4401 "Starting radio work '%s'@%p after %ld.%06ld second wait",
4402 work->type, work, diff.sec, diff.usec);
4405 radio->num_active_works++;
4409 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
4410 radio->num_active_works < MAX_ACTIVE_WORKS)
4411 radio_work_check_next(wpa_s);
4416 * This function removes both started and pending radio works running on
4417 * the provided interface's radio.
4418 * Prior to the removal of the radio work, its callback (cb) is called with
4419 * deinit set to be 1. Each work's callback is responsible for clearing its
4420 * internal data and restoring to a correct state.
4421 * @wpa_s: wpa_supplicant data
4422 * @type: type of works to be removed
4423 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
4424 * this interface's works.
4426 void radio_remove_works(struct wpa_supplicant *wpa_s,
4427 const char *type, int remove_all)
4429 struct wpa_radio_work *work, *tmp;
4430 struct wpa_radio *radio = wpa_s->radio;
4432 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work,
4434 if (type && os_strcmp(type, work->type) != 0)
4437 /* skip other ifaces' works */
4438 if (!remove_all && work->wpa_s != wpa_s)
4441 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
4442 work->type, work, work->started ? " (started)" : "");
4444 radio_work_free(work);
4447 /* in case we removed the started work */
4448 radio_work_check_next(wpa_s);
4452 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
4454 struct wpa_radio *radio = wpa_s->radio;
4459 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s",
4460 wpa_s->ifname, radio->name);
4461 dl_list_del(&wpa_s->radio_list);
4462 radio_remove_works(wpa_s, NULL, 0);
4463 wpa_s->radio = NULL;
4464 if (!dl_list_empty(&radio->ifaces))
4465 return; /* Interfaces remain for this radio */
4467 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name);
4468 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4473 void radio_work_check_next(struct wpa_supplicant *wpa_s)
4475 struct wpa_radio *radio = wpa_s->radio;
4477 if (dl_list_empty(&radio->work))
4479 if (wpa_s->ext_work_in_progress) {
4480 wpa_printf(MSG_DEBUG,
4481 "External radio work in progress - delay start of pending item");
4484 eloop_cancel_timeout(radio_start_next_work, radio, NULL);
4485 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL);
4490 * radio_add_work - Add a radio work item
4491 * @wpa_s: Pointer to wpa_supplicant data
4492 * @freq: Frequency of the offchannel operation in MHz or 0
4493 * @type: Unique identifier for each type of work
4494 * @next: Force as the next work to be executed
4495 * @cb: Callback function for indicating when radio is available
4496 * @ctx: Context pointer for the work (work->ctx in cb())
4497 * Returns: 0 on success, -1 on failure
4499 * This function is used to request time for an operation that requires
4500 * exclusive radio control. Once the radio is available, the registered callback
4501 * function will be called. radio_work_done() must be called once the exclusive
4502 * radio operation has been completed, so that the radio is freed for other
4503 * operations. The special case of deinit=1 is used to free the context data
4504 * during interface removal. That does not allow the callback function to start
4505 * the radio operation, i.e., it must free any resources allocated for the radio
4508 * The @freq parameter can be used to indicate a single channel on which the
4509 * offchannel operation will occur. This may allow multiple radio work
4510 * operations to be performed in parallel if they apply for the same channel.
4511 * Setting this to 0 indicates that the work item may use multiple channels or
4512 * requires exclusive control of the radio.
4514 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
4515 const char *type, int next,
4516 void (*cb)(struct wpa_radio_work *work, int deinit),
4519 struct wpa_radio *radio = wpa_s->radio;
4520 struct wpa_radio_work *work;
4523 work = os_zalloc(sizeof(*work));
4526 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
4527 os_get_reltime(&work->time);
4530 work->wpa_s = wpa_s;
4535 work->bands = wpas_freq_to_band(freq);
4536 else if (os_strcmp(type, "scan") == 0 ||
4537 os_strcmp(type, "p2p-scan") == 0)
4538 work->bands = wpas_get_bands(wpa_s,
4539 ((struct wpa_driver_scan_params *)
4542 work->bands = wpas_get_bands(wpa_s, NULL);
4544 was_empty = dl_list_empty(&wpa_s->radio->work);
4546 dl_list_add(&wpa_s->radio->work, &work->list);
4548 dl_list_add_tail(&wpa_s->radio->work, &work->list);
4550 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
4551 radio_work_check_next(wpa_s);
4552 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
4553 && radio->num_active_works < MAX_ACTIVE_WORKS) {
4554 wpa_dbg(wpa_s, MSG_DEBUG,
4555 "Try to schedule a radio work (num_active_works=%u)",
4556 radio->num_active_works);
4557 radio_work_check_next(wpa_s);
4565 * radio_work_done - Indicate that a radio work item has been completed
4566 * @work: Completed work
4568 * This function is called once the callback function registered with
4569 * radio_add_work() has completed its work.
4571 void radio_work_done(struct wpa_radio_work *work)
4573 struct wpa_supplicant *wpa_s = work->wpa_s;
4574 struct os_reltime now, diff;
4575 unsigned int started = work->started;
4577 os_get_reltime(&now);
4578 os_reltime_sub(&now, &work->time, &diff);
4579 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
4580 work->type, work, started ? "done" : "canceled",
4581 diff.sec, diff.usec);
4582 radio_work_free(work);
4584 radio_work_check_next(wpa_s);
4588 struct wpa_radio_work *
4589 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
4591 struct wpa_radio_work *work;
4592 struct wpa_radio *radio = wpa_s->radio;
4594 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) {
4595 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
4603 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
4604 struct wpa_interface *iface)
4606 const char *ifname, *driver, *rn;
4608 driver = iface->driver;
4610 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
4613 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
4614 if (wpa_s->drv_priv == NULL) {
4616 pos = driver ? os_strchr(driver, ',') : NULL;
4618 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
4619 "driver interface - try next driver wrapper");
4623 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
4627 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
4628 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
4629 "driver_param '%s'", wpa_s->conf->driver_param);
4633 ifname = wpa_drv_get_ifname(wpa_s);
4634 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
4635 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
4636 "interface name with '%s'", ifname);
4637 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
4640 rn = wpa_driver_get_radio_name(wpa_s);
4641 if (rn && rn[0] == '\0')
4644 wpa_s->radio = radio_add_interface(wpa_s, rn);
4645 if (wpa_s->radio == NULL)
4652 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
4653 struct wpa_interface *iface)
4655 struct wpa_driver_capa capa;
4658 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver "
4659 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname,
4660 iface->confname ? iface->confname : "N/A",
4661 iface->driver ? iface->driver : "default",
4662 iface->ctrl_interface ? iface->ctrl_interface : "N/A",
4663 iface->bridge_ifname ? iface->bridge_ifname : "N/A");
4665 if (iface->confname) {
4666 #ifdef CONFIG_BACKEND_FILE
4667 wpa_s->confname = os_rel2abs_path(iface->confname);
4668 if (wpa_s->confname == NULL) {
4669 wpa_printf(MSG_ERROR, "Failed to get absolute path "
4670 "for configuration file '%s'.",
4674 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'",
4675 iface->confname, wpa_s->confname);
4676 #else /* CONFIG_BACKEND_FILE */
4677 wpa_s->confname = os_strdup(iface->confname);
4678 #endif /* CONFIG_BACKEND_FILE */
4679 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
4680 if (wpa_s->conf == NULL) {
4681 wpa_printf(MSG_ERROR, "Failed to read or parse "
4682 "configuration '%s'.", wpa_s->confname);
4685 wpa_s->confanother = os_rel2abs_path(iface->confanother);
4686 wpa_config_read(wpa_s->confanother, wpa_s->conf);
4689 * Override ctrl_interface and driver_param if set on command
4692 if (iface->ctrl_interface) {
4693 os_free(wpa_s->conf->ctrl_interface);
4694 wpa_s->conf->ctrl_interface =
4695 os_strdup(iface->ctrl_interface);
4698 if (iface->driver_param) {
4699 os_free(wpa_s->conf->driver_param);
4700 wpa_s->conf->driver_param =
4701 os_strdup(iface->driver_param);
4704 if (iface->p2p_mgmt && !iface->ctrl_interface) {
4705 os_free(wpa_s->conf->ctrl_interface);
4706 wpa_s->conf->ctrl_interface = NULL;
4709 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
4710 iface->driver_param);
4712 if (wpa_s->conf == NULL) {
4713 wpa_printf(MSG_ERROR, "\nNo configuration found.");
4717 if (iface->ifname == NULL) {
4718 wpa_printf(MSG_ERROR, "\nInterface name is required.");
4721 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
4722 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.",
4726 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
4728 if (iface->bridge_ifname) {
4729 if (os_strlen(iface->bridge_ifname) >=
4730 sizeof(wpa_s->bridge_ifname)) {
4731 wpa_printf(MSG_ERROR, "\nToo long bridge interface "
4732 "name '%s'.", iface->bridge_ifname);
4735 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
4736 sizeof(wpa_s->bridge_ifname));
4739 /* RSNA Supplicant Key Management - INITIALIZE */
4740 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
4741 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
4743 /* Initialize driver interface and register driver event handler before
4744 * L2 receive handler so that association events are processed before
4745 * EAPOL-Key packets if both become available for the same select()
4747 if (wpas_init_driver(wpa_s, iface) < 0)
4750 if (wpa_supplicant_init_wpa(wpa_s) < 0)
4753 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
4754 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
4756 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
4758 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
4759 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
4760 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
4761 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4762 "dot11RSNAConfigPMKLifetime");
4766 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
4767 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
4768 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
4769 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4770 "dot11RSNAConfigPMKReauthThreshold");
4774 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
4775 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
4776 wpa_s->conf->dot11RSNAConfigSATimeout)) {
4777 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
4778 "dot11RSNAConfigSATimeout");
4782 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
4783 &wpa_s->hw.num_modes,
4785 if (wpa_s->hw.modes) {
4788 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4789 if (wpa_s->hw.modes[i].vht_capab) {
4790 wpa_s->hw_capab = CAPAB_VHT;
4794 if (wpa_s->hw.modes[i].ht_capab &
4795 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)
4796 wpa_s->hw_capab = CAPAB_HT40;
4797 else if (wpa_s->hw.modes[i].ht_capab &&
4798 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
4799 wpa_s->hw_capab = CAPAB_HT;
4803 capa_res = wpa_drv_get_capa(wpa_s, &capa);
4804 if (capa_res == 0) {
4805 wpa_s->drv_capa_known = 1;
4806 wpa_s->drv_flags = capa.flags;
4807 wpa_s->drv_enc = capa.enc;
4808 wpa_s->drv_smps_modes = capa.smps_modes;
4809 wpa_s->drv_rrm_flags = capa.rrm_flags;
4810 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
4811 wpa_s->max_scan_ssids = capa.max_scan_ssids;
4812 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
4813 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
4814 wpa_s->max_sched_scan_plan_interval =
4815 capa.max_sched_scan_plan_interval;
4816 wpa_s->max_sched_scan_plan_iterations =
4817 capa.max_sched_scan_plan_iterations;
4818 wpa_s->sched_scan_supported = capa.sched_scan_supported;
4819 wpa_s->max_match_sets = capa.max_match_sets;
4820 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
4821 wpa_s->max_stations = capa.max_stations;
4822 wpa_s->extended_capa = capa.extended_capa;
4823 wpa_s->extended_capa_mask = capa.extended_capa_mask;
4824 wpa_s->extended_capa_len = capa.extended_capa_len;
4825 wpa_s->num_multichan_concurrent =
4826 capa.num_multichan_concurrent;
4827 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
4829 if (capa.mac_addr_rand_scan_supported)
4830 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
4831 if (wpa_s->sched_scan_supported &&
4832 capa.mac_addr_rand_sched_scan_supported)
4833 wpa_s->mac_addr_rand_supported |=
4834 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO);
4836 if (wpa_s->max_remain_on_chan == 0)
4837 wpa_s->max_remain_on_chan = 1000;
4840 * Only take p2p_mgmt parameters when P2P Device is supported.
4841 * Doing it here as it determines whether l2_packet_init() will be done
4842 * during wpa_supplicant_driver_init().
4844 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
4845 wpa_s->p2p_mgmt = iface->p2p_mgmt;
4847 iface->p2p_mgmt = 1;
4849 if (wpa_s->num_multichan_concurrent == 0)
4850 wpa_s->num_multichan_concurrent = 1;
4852 if (wpa_supplicant_driver_init(wpa_s) < 0)
4856 if ((!iface->p2p_mgmt ||
4857 !(wpa_s->drv_flags &
4858 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
4859 wpa_tdls_init(wpa_s->wpa))
4861 #endif /* CONFIG_TDLS */
4863 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
4864 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
4865 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
4870 if (wpa_s->conf->fst_group_id) {
4871 struct fst_iface_cfg cfg;
4872 struct fst_wpa_obj iface_obj;
4874 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
4875 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
4876 sizeof(cfg.group_id));
4877 cfg.priority = wpa_s->conf->fst_priority;
4878 cfg.llt = wpa_s->conf->fst_llt;
4880 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
4883 wpa_msg(wpa_s, MSG_ERROR,
4884 "FST: Cannot attach iface %s to group %s",
4885 wpa_s->ifname, cfg.group_id);
4889 #endif /* CONFIG_FST */
4891 if (wpas_wps_init(wpa_s))
4894 if (wpa_supplicant_init_eapol(wpa_s) < 0)
4896 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
4898 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
4899 if (wpa_s->ctrl_iface == NULL) {
4900 wpa_printf(MSG_ERROR,
4901 "Failed to initialize control interface '%s'.\n"
4902 "You may have another wpa_supplicant process "
4903 "already running or the file was\n"
4904 "left by an unclean termination of wpa_supplicant "
4905 "in which case you will need\n"
4906 "to manually remove this file before starting "
4907 "wpa_supplicant again.\n",
4908 wpa_s->conf->ctrl_interface);
4912 wpa_s->gas = gas_query_init(wpa_s);
4913 if (wpa_s->gas == NULL) {
4914 wpa_printf(MSG_ERROR, "Failed to initialize GAS query");
4918 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
4919 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
4923 if (wpa_bss_init(wpa_s) < 0)
4927 * Set Wake-on-WLAN triggers, if configured.
4928 * Note: We don't restore/remove the triggers on shutdown (it doesn't
4929 * have effect anyway when the interface is down).
4931 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
4934 #ifdef CONFIG_EAP_PROXY
4937 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi,
4939 if (wpa_s->mnc_len > 0) {
4940 wpa_s->imsi[len] = '\0';
4941 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)",
4942 wpa_s->imsi, wpa_s->mnc_len);
4944 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available");
4947 #endif /* CONFIG_EAP_PROXY */
4949 if (pcsc_reader_init(wpa_s) < 0)
4952 if (wpas_init_ext_pw(wpa_s) < 0)
4955 wpas_rrm_reset(wpa_s);
4957 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
4961 #endif /* CONFIG_HS20 */
4963 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
4964 #endif /* CONFIG_MBO */
4966 wpa_supplicant_set_default_scan_ies(wpa_s);
4972 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
4973 int notify, int terminate)
4975 struct wpa_global *global = wpa_s->global;
4976 struct wpa_supplicant *iface, *prev;
4978 if (wpa_s == wpa_s->parent)
4979 wpas_p2p_group_remove(wpa_s, "*");
4981 iface = global->ifaces;
4983 if (iface->p2pdev == wpa_s)
4984 iface->p2pdev = iface->parent;
4985 if (iface == wpa_s || iface->parent != wpa_s) {
4986 iface = iface->next;
4989 wpa_printf(MSG_DEBUG,
4990 "Remove remaining child interface %s from parent %s",
4991 iface->ifname, wpa_s->ifname);
4993 iface = iface->next;
4994 wpa_supplicant_remove_iface(global, prev, terminate);
4997 wpa_s->disconnected = 1;
4998 if (wpa_s->drv_priv) {
4999 wpa_supplicant_deauthenticate(wpa_s,
5000 WLAN_REASON_DEAUTH_LEAVING);
5002 wpa_drv_set_countermeasures(wpa_s, 0);
5003 wpa_clear_keys(wpa_s, NULL);
5006 wpa_supplicant_cleanup(wpa_s);
5007 wpas_p2p_deinit_iface(wpa_s);
5009 wpas_ctrl_radio_work_flush(wpa_s);
5010 radio_remove_interface(wpa_s);
5014 fst_detach(wpa_s->fst);
5017 if (wpa_s->received_mb_ies) {
5018 wpabuf_free(wpa_s->received_mb_ies);
5019 wpa_s->received_mb_ies = NULL;
5021 #endif /* CONFIG_FST */
5023 if (wpa_s->drv_priv)
5024 wpa_drv_deinit(wpa_s);
5027 wpas_notify_iface_removed(wpa_s);
5030 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
5032 if (wpa_s->ctrl_iface) {
5033 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
5034 wpa_s->ctrl_iface = NULL;
5039 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
5040 wpa_s->ifmsh = NULL;
5042 #endif /* CONFIG_MESH */
5044 if (wpa_s->conf != NULL) {
5045 wpa_config_free(wpa_s->conf);
5049 os_free(wpa_s->ssids_from_scan_req);
5055 #ifdef CONFIG_MATCH_IFACE
5058 * wpa_supplicant_match_iface - Match an interface description to a name
5059 * @global: Pointer to global data from wpa_supplicant_init()
5060 * @ifname: Name of the interface to match
5061 * Returns: Pointer to the created interface description or %NULL on failure
5063 struct wpa_interface * wpa_supplicant_match_iface(struct wpa_global *global,
5067 struct wpa_interface *iface, *miface;
5069 for (i = 0; i < global->params.match_iface_count; i++) {
5070 miface = &global->params.match_ifaces[i];
5071 if (!miface->ifname ||
5072 fnmatch(miface->ifname, ifname, 0) == 0) {
5073 iface = os_zalloc(sizeof(*iface));
5077 iface->ifname = ifname;
5087 * wpa_supplicant_match_existing - Match existing interfaces
5088 * @global: Pointer to global data from wpa_supplicant_init()
5089 * Returns: 0 on success, -1 on failure
5091 static int wpa_supplicant_match_existing(struct wpa_global *global)
5093 struct if_nameindex *ifi, *ifp;
5094 struct wpa_supplicant *wpa_s;
5095 struct wpa_interface *iface;
5097 ifp = if_nameindex();
5099 wpa_printf(MSG_ERROR, "if_nameindex: %s", strerror(errno));
5103 for (ifi = ifp; ifi->if_name; ifi++) {
5104 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
5107 iface = wpa_supplicant_match_iface(global, ifi->if_name);
5109 wpa_s = wpa_supplicant_add_iface(global, iface, NULL);
5116 if_freenameindex(ifp);
5120 #endif /* CONFIG_MATCH_IFACE */
5124 * wpa_supplicant_add_iface - Add a new network interface
5125 * @global: Pointer to global data from wpa_supplicant_init()
5126 * @iface: Interface configuration options
5127 * @parent: Parent interface or %NULL to assign new interface as parent
5128 * Returns: Pointer to the created interface or %NULL on failure
5130 * This function is used to add new network interfaces for %wpa_supplicant.
5131 * This can be called before wpa_supplicant_run() to add interfaces before the
5132 * main event loop has been started. In addition, new interfaces can be added
5133 * dynamically while %wpa_supplicant is already running. This could happen,
5134 * e.g., when a hotplug network adapter is inserted.
5136 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
5137 struct wpa_interface *iface,
5138 struct wpa_supplicant *parent)
5140 struct wpa_supplicant *wpa_s;
5141 struct wpa_interface t_iface;
5142 struct wpa_ssid *ssid;
5144 if (global == NULL || iface == NULL)
5147 wpa_s = wpa_supplicant_alloc(parent);
5151 wpa_s->global = global;
5154 if (global->params.override_driver) {
5155 wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
5157 iface->driver, global->params.override_driver);
5158 t_iface.driver = global->params.override_driver;
5160 if (global->params.override_ctrl_interface) {
5161 wpa_printf(MSG_DEBUG, "Override interface parameter: "
5162 "ctrl_interface ('%s' -> '%s')",
5163 iface->ctrl_interface,
5164 global->params.override_ctrl_interface);
5165 t_iface.ctrl_interface =
5166 global->params.override_ctrl_interface;
5168 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
5169 wpa_printf(MSG_DEBUG, "Failed to add interface %s",
5171 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
5175 if (iface->p2p_mgmt == 0) {
5176 /* Notify the control interfaces about new iface */
5177 if (wpas_notify_iface_added(wpa_s)) {
5178 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
5182 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
5183 wpas_notify_network_added(wpa_s, ssid);
5186 wpa_s->next = global->ifaces;
5187 global->ifaces = wpa_s;
5189 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
5190 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
5193 if (wpa_s->global->p2p == NULL &&
5194 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
5195 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
5196 wpas_p2p_add_p2pdev_interface(
5197 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
5198 wpa_printf(MSG_INFO,
5199 "P2P: Failed to enable P2P Device interface");
5200 /* Try to continue without. P2P will be disabled. */
5202 #endif /* CONFIG_P2P */
5209 * wpa_supplicant_remove_iface - Remove a network interface
5210 * @global: Pointer to global data from wpa_supplicant_init()
5211 * @wpa_s: Pointer to the network interface to be removed
5212 * Returns: 0 if interface was removed, -1 if interface was not found
5214 * This function can be used to dynamically remove network interfaces from
5215 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
5216 * addition, this function is used to remove all remaining interfaces when
5217 * %wpa_supplicant is terminated.
5219 int wpa_supplicant_remove_iface(struct wpa_global *global,
5220 struct wpa_supplicant *wpa_s,
5223 struct wpa_supplicant *prev;
5225 unsigned int mesh_if_created = wpa_s->mesh_if_created;
5226 char *ifname = NULL;
5227 #endif /* CONFIG_MESH */
5229 /* Remove interface from the global list of interfaces */
5230 prev = global->ifaces;
5231 if (prev == wpa_s) {
5232 global->ifaces = wpa_s->next;
5234 while (prev && prev->next != wpa_s)
5238 prev->next = wpa_s->next;
5241 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
5244 if (mesh_if_created) {
5245 ifname = os_strdup(wpa_s->ifname);
5246 if (ifname == NULL) {
5247 wpa_dbg(wpa_s, MSG_ERROR,
5248 "mesh: Failed to malloc ifname");
5252 #endif /* CONFIG_MESH */
5254 if (global->p2p_group_formation == wpa_s)
5255 global->p2p_group_formation = NULL;
5256 if (global->p2p_invite_group == wpa_s)
5257 global->p2p_invite_group = NULL;
5258 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
5261 if (mesh_if_created) {
5262 wpa_drv_if_remove(global->ifaces, WPA_IF_MESH, ifname);
5265 #endif /* CONFIG_MESH */
5272 * wpa_supplicant_get_eap_mode - Get the current EAP mode
5273 * @wpa_s: Pointer to the network interface
5274 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
5276 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
5278 const char *eapol_method;
5280 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
5281 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
5285 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
5286 if (eapol_method == NULL)
5287 return "UNKNOWN-EAP";
5289 return eapol_method;
5294 * wpa_supplicant_get_iface - Get a new network interface
5295 * @global: Pointer to global data from wpa_supplicant_init()
5296 * @ifname: Interface name
5297 * Returns: Pointer to the interface or %NULL if not found
5299 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
5302 struct wpa_supplicant *wpa_s;
5304 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5305 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5312 #ifndef CONFIG_NO_WPA_MSG
5313 static const char * wpa_supplicant_msg_ifname_cb(void *ctx)
5315 struct wpa_supplicant *wpa_s = ctx;
5318 return wpa_s->ifname;
5320 #endif /* CONFIG_NO_WPA_MSG */
5323 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL
5324 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10
5325 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */
5327 /* Periodic cleanup tasks */
5328 static void wpas_periodic(void *eloop_ctx, void *timeout_ctx)
5330 struct wpa_global *global = eloop_ctx;
5331 struct wpa_supplicant *wpa_s;
5333 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5334 wpas_periodic, global, NULL);
5338 p2p_expire_peers(global->p2p);
5339 #endif /* CONFIG_P2P */
5341 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5342 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
5345 #endif /* CONFIG_AP */
5351 * wpa_supplicant_init - Initialize %wpa_supplicant
5352 * @params: Parameters for %wpa_supplicant
5353 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
5355 * This function is used to initialize %wpa_supplicant. After successful
5356 * initialization, the returned data pointer can be used to add and remove
5357 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
5359 struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
5361 struct wpa_global *global;
5367 #ifdef CONFIG_DRIVER_NDIS
5369 void driver_ndis_init_ops(void);
5370 driver_ndis_init_ops();
5372 #endif /* CONFIG_DRIVER_NDIS */
5374 #ifndef CONFIG_NO_WPA_MSG
5375 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb);
5376 #endif /* CONFIG_NO_WPA_MSG */
5378 if (params->wpa_debug_file_path)
5379 wpa_debug_open_file(params->wpa_debug_file_path);
5381 wpa_debug_setup_stdout();
5382 if (params->wpa_debug_syslog)
5383 wpa_debug_open_syslog();
5384 if (params->wpa_debug_tracing) {
5385 ret = wpa_debug_open_linux_tracing();
5387 wpa_printf(MSG_ERROR,
5388 "Failed to enable trace logging");
5393 ret = eap_register_methods();
5395 wpa_printf(MSG_ERROR, "Failed to register EAP methods");
5397 wpa_printf(MSG_ERROR, "Two or more EAP methods used "
5398 "the same EAP type.");
5402 global = os_zalloc(sizeof(*global));
5405 dl_list_init(&global->p2p_srv_bonjour);
5406 dl_list_init(&global->p2p_srv_upnp);
5407 global->params.daemonize = params->daemonize;
5408 global->params.wait_for_monitor = params->wait_for_monitor;
5409 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface;
5410 if (params->pid_file)
5411 global->params.pid_file = os_strdup(params->pid_file);
5412 if (params->ctrl_interface)
5413 global->params.ctrl_interface =
5414 os_strdup(params->ctrl_interface);
5415 if (params->ctrl_interface_group)
5416 global->params.ctrl_interface_group =
5417 os_strdup(params->ctrl_interface_group);
5418 if (params->override_driver)
5419 global->params.override_driver =
5420 os_strdup(params->override_driver);
5421 if (params->override_ctrl_interface)
5422 global->params.override_ctrl_interface =
5423 os_strdup(params->override_ctrl_interface);
5424 #ifdef CONFIG_MATCH_IFACE
5425 global->params.match_iface_count = params->match_iface_count;
5426 if (params->match_iface_count) {
5427 global->params.match_ifaces =
5428 os_calloc(params->match_iface_count,
5429 sizeof(struct wpa_interface));
5430 os_memcpy(global->params.match_ifaces,
5431 params->match_ifaces,
5432 params->match_iface_count *
5433 sizeof(struct wpa_interface));
5435 #endif /* CONFIG_MATCH_IFACE */
5437 if (params->conf_p2p_dev)
5438 global->params.conf_p2p_dev =
5439 os_strdup(params->conf_p2p_dev);
5440 #endif /* CONFIG_P2P */
5441 wpa_debug_level = global->params.wpa_debug_level =
5442 params->wpa_debug_level;
5443 wpa_debug_show_keys = global->params.wpa_debug_show_keys =
5444 params->wpa_debug_show_keys;
5445 wpa_debug_timestamp = global->params.wpa_debug_timestamp =
5446 params->wpa_debug_timestamp;
5448 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR);
5451 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
5452 wpa_supplicant_deinit(global);
5456 random_init(params->entropy_file);
5458 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global);
5459 if (global->ctrl_iface == NULL) {
5460 wpa_supplicant_deinit(global);
5464 if (wpas_notify_supplicant_initialized(global)) {
5465 wpa_supplicant_deinit(global);
5469 for (i = 0; wpa_drivers[i]; i++)
5470 global->drv_count++;
5471 if (global->drv_count == 0) {
5472 wpa_printf(MSG_ERROR, "No drivers enabled");
5473 wpa_supplicant_deinit(global);
5476 global->drv_priv = os_calloc(global->drv_count, sizeof(void *));
5477 if (global->drv_priv == NULL) {
5478 wpa_supplicant_deinit(global);
5482 #ifdef CONFIG_WIFI_DISPLAY
5483 if (wifi_display_init(global) < 0) {
5484 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display");
5485 wpa_supplicant_deinit(global);
5488 #endif /* CONFIG_WIFI_DISPLAY */
5490 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0,
5491 wpas_periodic, global, NULL);
5498 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
5499 * @global: Pointer to global data from wpa_supplicant_init()
5500 * Returns: 0 after successful event loop run, -1 on failure
5502 * This function starts the main event loop and continues running as long as
5503 * there are any remaining events. In most cases, this function is running as
5504 * long as the %wpa_supplicant process in still in use.
5506 int wpa_supplicant_run(struct wpa_global *global)
5508 struct wpa_supplicant *wpa_s;
5510 if (global->params.daemonize &&
5511 (wpa_supplicant_daemon(global->params.pid_file) ||
5512 eloop_sock_requeue()))
5515 #ifdef CONFIG_MATCH_IFACE
5516 if (wpa_supplicant_match_existing(global))
5520 if (global->params.wait_for_monitor) {
5521 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
5522 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
5523 wpa_supplicant_ctrl_iface_wait(
5527 eloop_register_signal_terminate(wpa_supplicant_terminate, global);
5528 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
5537 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
5538 * @global: Pointer to global data from wpa_supplicant_init()
5540 * This function is called to deinitialize %wpa_supplicant and to free all
5541 * allocated resources. Remaining network interfaces will also be removed.
5543 void wpa_supplicant_deinit(struct wpa_global *global)
5550 eloop_cancel_timeout(wpas_periodic, global, NULL);
5552 #ifdef CONFIG_WIFI_DISPLAY
5553 wifi_display_deinit(global);
5554 #endif /* CONFIG_WIFI_DISPLAY */
5556 while (global->ifaces)
5557 wpa_supplicant_remove_iface(global, global->ifaces, 1);
5559 if (global->ctrl_iface)
5560 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface);
5562 wpas_notify_supplicant_deinitialized(global);
5564 eap_peer_unregister_methods();
5566 eap_server_unregister_methods();
5567 #endif /* CONFIG_AP */
5569 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) {
5570 if (!global->drv_priv[i])
5572 wpa_drivers[i]->global_deinit(global->drv_priv[i]);
5574 os_free(global->drv_priv);
5580 if (global->params.pid_file) {
5581 os_daemonize_terminate(global->params.pid_file);
5582 os_free(global->params.pid_file);
5584 os_free(global->params.ctrl_interface);
5585 os_free(global->params.ctrl_interface_group);
5586 os_free(global->params.override_driver);
5587 os_free(global->params.override_ctrl_interface);
5588 #ifdef CONFIG_MATCH_IFACE
5589 os_free(global->params.match_ifaces);
5590 #endif /* CONFIG_MATCH_IFACE */
5592 os_free(global->params.conf_p2p_dev);
5593 #endif /* CONFIG_P2P */
5595 os_free(global->p2p_disallow_freq.range);
5596 os_free(global->p2p_go_avoid_freq.range);
5597 os_free(global->add_psk);
5600 wpa_debug_close_syslog();
5601 wpa_debug_close_file();
5602 wpa_debug_close_linux_tracing();
5606 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
5608 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
5609 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5611 country[0] = wpa_s->conf->country[0];
5612 country[1] = wpa_s->conf->country[1];
5614 if (wpa_drv_set_country(wpa_s, country) < 0) {
5615 wpa_printf(MSG_ERROR, "Failed to set country code "
5620 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
5621 wpas_init_ext_pw(wpa_s);
5623 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
5624 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5627 wpas_wps_update_config(wpa_s);
5628 #endif /* CONFIG_WPS */
5629 wpas_p2p_update_config(wpa_s);
5630 wpa_s->conf->changed_parameters = 0;
5634 void add_freq(int *freqs, int *num_freqs, int freq)
5638 for (i = 0; i < *num_freqs; i++) {
5639 if (freqs[i] == freq)
5643 freqs[*num_freqs] = freq;
5648 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
5650 struct wpa_bss *bss, *cbss;
5651 const int max_freqs = 10;
5655 freqs = os_calloc(max_freqs + 1, sizeof(int));
5659 cbss = wpa_s->current_bss;
5661 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
5664 if (bss->ssid_len == cbss->ssid_len &&
5665 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 &&
5666 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
5667 add_freq(freqs, &num_freqs, bss->freq);
5668 if (num_freqs == max_freqs)
5673 if (num_freqs == 0) {
5682 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
5688 wpas_connect_work_done(wpa_s);
5691 * Remove possible authentication timeout since the connection failed.
5693 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
5696 * There is no point in blacklisting the AP if this event is
5697 * generated based on local request to disconnect.
5699 if (wpa_s->own_disconnect_req) {
5700 wpa_s->own_disconnect_req = 0;
5701 wpa_dbg(wpa_s, MSG_DEBUG,
5702 "Ignore connection failure due to local request to disconnect");
5705 if (wpa_s->disconnected) {
5706 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
5707 "indication since interface has been put into "
5708 "disconnected state");
5713 * Add the failed BSSID into the blacklist and speed up next scan
5714 * attempt if there could be other APs that could accept association.
5715 * The current blacklist count indicates how many times we have tried
5716 * connecting to this AP and multiple attempts mean that other APs are
5717 * either not available or has already been tried, so that we can start
5718 * increasing the delay here to avoid constant scanning.
5720 count = wpa_blacklist_add(wpa_s, bssid);
5721 if (count == 1 && wpa_s->current_bss) {
5723 * This BSS was not in the blacklist before. If there is
5724 * another BSS available for the same ESS, we should try that
5725 * next. Otherwise, we may as well try this one once more
5726 * before allowing other, likely worse, ESSes to be considered.
5728 freqs = get_bss_freqs_in_ess(wpa_s);
5730 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
5731 "has been seen; try it next");
5732 wpa_blacklist_add(wpa_s, bssid);
5734 * On the next scan, go through only the known channels
5735 * used in this ESS based on previous scans to speed up
5736 * common load balancing use case.
5738 os_free(wpa_s->next_scan_freqs);
5739 wpa_s->next_scan_freqs = freqs;
5744 * Add previous failure count in case the temporary blacklist was
5745 * cleared due to no other BSSes being available.
5747 count += wpa_s->extra_blacklist_count;
5749 if (count > 3 && wpa_s->current_ssid) {
5750 wpa_printf(MSG_DEBUG, "Continuous association failures - "
5751 "consider temporary network disabling");
5752 wpas_auth_failed(wpa_s, "CONN_FAILED");
5773 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
5774 "ms", count, timeout);
5777 * TODO: if more than one possible AP is available in scan results,
5778 * could try the other ones before requesting a new scan.
5780 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
5781 1000 * (timeout % 1000));
5785 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
5787 return wpa_s->conf->ap_scan == 2 ||
5788 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
5792 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
5793 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
5794 struct wpa_ssid *ssid,
5798 #ifdef IEEE8021X_EAPOL
5799 struct eap_peer_config *eap = &ssid->eap;
5801 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field);
5802 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value",
5803 (const u8 *) value, os_strlen(value));
5805 switch (wpa_supplicant_ctrl_req_from_string(field)) {
5806 case WPA_CTRL_REQ_EAP_IDENTITY:
5807 os_free(eap->identity);
5808 eap->identity = (u8 *) os_strdup(value);
5809 eap->identity_len = os_strlen(value);
5810 eap->pending_req_identity = 0;
5811 if (ssid == wpa_s->current_ssid)
5812 wpa_s->reassociate = 1;
5814 case WPA_CTRL_REQ_EAP_PASSWORD:
5815 bin_clear_free(eap->password, eap->password_len);
5816 eap->password = (u8 *) os_strdup(value);
5817 eap->password_len = os_strlen(value);
5818 eap->pending_req_password = 0;
5819 if (ssid == wpa_s->current_ssid)
5820 wpa_s->reassociate = 1;
5822 case WPA_CTRL_REQ_EAP_NEW_PASSWORD:
5823 bin_clear_free(eap->new_password, eap->new_password_len);
5824 eap->new_password = (u8 *) os_strdup(value);
5825 eap->new_password_len = os_strlen(value);
5826 eap->pending_req_new_password = 0;
5827 if (ssid == wpa_s->current_ssid)
5828 wpa_s->reassociate = 1;
5830 case WPA_CTRL_REQ_EAP_PIN:
5831 str_clear_free(eap->pin);
5832 eap->pin = os_strdup(value);
5833 eap->pending_req_pin = 0;
5834 if (ssid == wpa_s->current_ssid)
5835 wpa_s->reassociate = 1;
5837 case WPA_CTRL_REQ_EAP_OTP:
5838 bin_clear_free(eap->otp, eap->otp_len);
5839 eap->otp = (u8 *) os_strdup(value);
5840 eap->otp_len = os_strlen(value);
5841 os_free(eap->pending_req_otp);
5842 eap->pending_req_otp = NULL;
5843 eap->pending_req_otp_len = 0;
5845 case WPA_CTRL_REQ_EAP_PASSPHRASE:
5846 str_clear_free(eap->private_key_passwd);
5847 eap->private_key_passwd = os_strdup(value);
5848 eap->pending_req_passphrase = 0;
5849 if (ssid == wpa_s->current_ssid)
5850 wpa_s->reassociate = 1;
5852 case WPA_CTRL_REQ_SIM:
5853 str_clear_free(eap->external_sim_resp);
5854 eap->external_sim_resp = os_strdup(value);
5856 case WPA_CTRL_REQ_PSK_PASSPHRASE:
5857 if (wpa_config_set(ssid, "psk", value, 0) < 0)
5859 ssid->mem_only_psk = 1;
5860 if (ssid->passphrase)
5861 wpa_config_update_psk(ssid);
5862 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
5863 wpa_supplicant_req_scan(wpa_s, 0, 0);
5865 case WPA_CTRL_REQ_EXT_CERT_CHECK:
5866 if (eap->pending_ext_cert_check != PENDING_CHECK)
5868 if (os_strcmp(value, "good") == 0)
5869 eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD;
5870 else if (os_strcmp(value, "bad") == 0)
5871 eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD;
5876 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field);
5881 #else /* IEEE8021X_EAPOL */
5882 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included");
5884 #endif /* IEEE8021X_EAPOL */
5886 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
5889 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5892 unsigned int drv_enc;
5894 if (wpa_s->p2p_mgmt)
5895 return 1; /* no normal network profiles on p2p_mgmt interface */
5903 if (wpa_s->drv_capa_known)
5904 drv_enc = wpa_s->drv_enc;
5906 drv_enc = (unsigned int) -1;
5908 for (i = 0; i < NUM_WEP_KEYS; i++) {
5909 size_t len = ssid->wep_key_len[i];
5912 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40))
5914 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104))
5916 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128))
5918 return 1; /* invalid WEP key */
5921 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set &&
5922 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk &&
5923 !ssid->mem_only_psk)
5930 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
5932 #ifdef CONFIG_IEEE80211W
5933 if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) {
5934 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
5935 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
5937 * Driver does not support BIP -- ignore pmf=1 default
5938 * since the connection with PMF would fail and the
5939 * configuration does not require PMF to be enabled.
5941 return NO_MGMT_FRAME_PROTECTION;
5946 ~(WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPS |
5947 WPA_KEY_MGMT_IEEE8021X_NO_WPA)) == 0) {
5949 * Do not use the default PMF value for non-RSN networks
5950 * since PMF is available only with RSN and pmf=2
5951 * configuration would otherwise prevent connections to
5952 * all open networks.
5954 return NO_MGMT_FRAME_PROTECTION;
5957 return wpa_s->conf->pmf;
5960 return ssid->ieee80211w;
5961 #else /* CONFIG_IEEE80211W */
5962 return NO_MGMT_FRAME_PROTECTION;
5963 #endif /* CONFIG_IEEE80211W */
5967 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
5969 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
5971 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
5977 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
5979 struct wpa_ssid *ssid = wpa_s->current_ssid;
5981 struct os_reltime now;
5984 wpa_printf(MSG_DEBUG, "Authentication failure but no known "
5989 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS)
5992 ssid->auth_failures++;
5995 if (ssid->p2p_group &&
5996 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
5998 * Skip the wait time since there is a short timeout on the
5999 * connection to a P2P group.
6003 #endif /* CONFIG_P2P */
6005 if (ssid->auth_failures > 50)
6007 else if (ssid->auth_failures > 10)
6009 else if (ssid->auth_failures > 5)
6011 else if (ssid->auth_failures > 3)
6013 else if (ssid->auth_failures > 2)
6015 else if (ssid->auth_failures > 1)
6020 if (ssid->auth_failures > 1 &&
6021 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt))
6022 dur += os_random() % (ssid->auth_failures * 10);
6024 os_get_reltime(&now);
6025 if (now.sec + dur <= ssid->disabled_until.sec)
6028 ssid->disabled_until.sec = now.sec + dur;
6030 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
6031 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
6032 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
6033 ssid->auth_failures, dur, reason);
6037 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
6038 struct wpa_ssid *ssid, int clear_failures)
6043 if (ssid->disabled_until.sec) {
6044 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
6045 "id=%d ssid=\"%s\"",
6046 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
6048 ssid->disabled_until.sec = 0;
6049 ssid->disabled_until.usec = 0;
6051 ssid->auth_failures = 0;
6055 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
6059 if (wpa_s->disallow_aps_bssid == NULL)
6062 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
6063 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
6064 bssid, ETH_ALEN) == 0)
6072 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
6077 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
6080 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
6081 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
6082 if (ssid_len == s->ssid_len &&
6083 os_memcmp(ssid, s->ssid, ssid_len) == 0)
6092 * wpas_request_connection - Request a new connection
6093 * @wpa_s: Pointer to the network interface
6095 * This function is used to request a new connection to be found. It will mark
6096 * the interface to allow reassociation and request a new scan to find a
6097 * suitable network to connect to.
6099 void wpas_request_connection(struct wpa_supplicant *wpa_s)
6101 wpa_s->normal_scans = 0;
6102 wpa_s->scan_req = NORMAL_SCAN_REQ;
6103 wpa_supplicant_reinit_autoscan(wpa_s);
6104 wpa_s->extra_blacklist_count = 0;
6105 wpa_s->disconnected = 0;
6106 wpa_s->reassociate = 1;
6108 if (wpa_supplicant_fast_associate(wpa_s) != 1)
6109 wpa_supplicant_req_scan(wpa_s, 0, 0);
6111 wpa_s->reattach = 0;
6116 * wpas_request_disconnection - Request disconnection
6117 * @wpa_s: Pointer to the network interface
6119 * This function is used to request disconnection from the currently connected
6120 * network. This will stop any ongoing scans and initiate deauthentication.
6122 void wpas_request_disconnection(struct wpa_supplicant *wpa_s)
6125 wpa_s->sme.prev_bssid_set = 0;
6126 #endif /* CONFIG_SME */
6127 wpa_s->reassociate = 0;
6128 wpa_s->disconnected = 1;
6129 wpa_supplicant_cancel_sched_scan(wpa_s);
6130 wpa_supplicant_cancel_scan(wpa_s);
6131 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
6132 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
6136 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
6137 struct wpa_used_freq_data *freqs_data,
6142 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
6144 for (i = 0; i < len; i++) {
6145 struct wpa_used_freq_data *cur = &freqs_data[i];
6146 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
6147 i, cur->freq, cur->flags);
6153 * Find the operating frequencies of any of the virtual interfaces that
6154 * are using the same radio as the current interface, and in addition, get
6155 * information about the interface types that are using the frequency.
6157 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
6158 struct wpa_used_freq_data *freqs_data,
6161 struct wpa_supplicant *ifs;
6164 unsigned int idx = 0, i;
6166 wpa_dbg(wpa_s, MSG_DEBUG,
6167 "Determining shared radio frequencies (max len %u)", len);
6168 os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len);
6170 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
6175 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0)
6178 if (ifs->current_ssid->mode == WPAS_MODE_AP ||
6179 ifs->current_ssid->mode == WPAS_MODE_P2P_GO ||
6180 ifs->current_ssid->mode == WPAS_MODE_MESH)
6181 freq = ifs->current_ssid->frequency;
6182 else if (wpa_drv_get_bssid(ifs, bssid) == 0)
6183 freq = ifs->assoc_freq;
6187 /* Hold only distinct freqs */
6188 for (i = 0; i < idx; i++)
6189 if (freqs_data[i].freq == freq)
6193 freqs_data[idx++].freq = freq;
6195 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) {
6196 freqs_data[i].flags |= ifs->current_ssid->p2p_group ?
6197 WPA_FREQ_USED_BY_P2P_CLIENT :
6198 WPA_FREQ_USED_BY_INFRA_STATION;
6202 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
6208 * Find the operating frequencies of any of the virtual interfaces that
6209 * are using the same radio as the current interface.
6211 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
6212 int *freq_array, unsigned int len)
6214 struct wpa_used_freq_data *freqs_data;
6217 os_memset(freq_array, 0, sizeof(int) * len);
6219 freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data));
6223 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
6224 for (i = 0; i < num; i++)
6225 freq_array[i] = freqs_data[i].freq;
6227 os_free(freqs_data);
6233 static void wpas_rrm_neighbor_rep_timeout_handler(void *data, void *user_ctx)
6235 struct rrm_data *rrm = data;
6237 if (!rrm->notify_neighbor_rep) {
6238 wpa_printf(MSG_ERROR,
6239 "RRM: Unexpected neighbor report timeout");
6243 wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report - NONE");
6244 rrm->notify_neighbor_rep(rrm->neighbor_rep_cb_ctx, NULL);
6246 rrm->notify_neighbor_rep = NULL;
6247 rrm->neighbor_rep_cb_ctx = NULL;
6252 * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant
6253 * @wpa_s: Pointer to wpa_supplicant
6255 void wpas_rrm_reset(struct wpa_supplicant *wpa_s)
6257 wpa_s->rrm.rrm_used = 0;
6259 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
6261 if (wpa_s->rrm.notify_neighbor_rep)
6262 wpas_rrm_neighbor_rep_timeout_handler(&wpa_s->rrm, NULL);
6263 wpa_s->rrm.next_neighbor_rep_token = 1;
6268 * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
6269 * @wpa_s: Pointer to wpa_supplicant
6270 * @report: Neighbor report buffer, prefixed by a 1-byte dialog token
6271 * @report_len: Length of neighbor report buffer
6273 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s,
6274 const u8 *report, size_t report_len)
6276 struct wpabuf *neighbor_rep;
6278 wpa_hexdump(MSG_DEBUG, "RRM: New Neighbor Report", report, report_len);
6282 if (report[0] != wpa_s->rrm.next_neighbor_rep_token - 1) {
6283 wpa_printf(MSG_DEBUG,
6284 "RRM: Discarding neighbor report with token %d (expected %d)",
6285 report[0], wpa_s->rrm.next_neighbor_rep_token - 1);
6289 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler, &wpa_s->rrm,
6292 if (!wpa_s->rrm.notify_neighbor_rep) {
6293 wpa_printf(MSG_ERROR, "RRM: Unexpected neighbor report");
6297 /* skipping the first byte, which is only an id (dialog token) */
6298 neighbor_rep = wpabuf_alloc(report_len - 1);
6299 if (neighbor_rep == NULL)
6301 wpabuf_put_data(neighbor_rep, report + 1, report_len - 1);
6302 wpa_printf(MSG_DEBUG, "RRM: Notifying neighbor report (token = %d)",
6304 wpa_s->rrm.notify_neighbor_rep(wpa_s->rrm.neighbor_rep_cb_ctx,
6306 wpa_s->rrm.notify_neighbor_rep = NULL;
6307 wpa_s->rrm.neighbor_rep_cb_ctx = NULL;
6311 #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
6312 /* Workaround different, undefined for Windows, error codes used here */
6314 #define EOPNOTSUPP -1
6315 #define ECANCELED -1
6318 /* Measurement Request element + Location Subject + Maximum Age subelement */
6319 #define MEASURE_REQUEST_LCI_LEN (3 + 1 + 4)
6320 /* Measurement Request element + Location Civic Request */
6321 #define MEASURE_REQUEST_CIVIC_LEN (3 + 5)
6325 * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP
6326 * @wpa_s: Pointer to wpa_supplicant
6327 * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE
6328 * is sent in the request.
6329 * @lci: if set, neighbor request will include LCI request
6330 * @civic: if set, neighbor request will include civic location request
6331 * @cb: Callback function to be called once the requested report arrives, or
6332 * timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds.
6333 * In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's
6334 * the requester's responsibility to free it.
6335 * In the latter case NULL will be sent in 'neighbor_rep'.
6336 * @cb_ctx: Context value to send the callback function
6337 * Returns: 0 in case of success, negative error code otherwise
6339 * In case there is a previous request which has not been answered yet, the
6340 * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT.
6341 * Request must contain a callback function.
6343 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s,
6344 const struct wpa_ssid_value *ssid,
6346 void (*cb)(void *ctx,
6347 struct wpabuf *neighbor_rep),
6353 if (wpa_s->wpa_state != WPA_COMPLETED || wpa_s->current_ssid == NULL) {
6354 wpa_printf(MSG_DEBUG, "RRM: No connection, no RRM.");
6358 if (!wpa_s->rrm.rrm_used) {
6359 wpa_printf(MSG_DEBUG, "RRM: No RRM in current connection.");
6363 rrm_ie = wpa_bss_get_ie(wpa_s->current_bss,
6364 WLAN_EID_RRM_ENABLED_CAPABILITIES);
6365 if (!rrm_ie || !(wpa_s->current_bss->caps & IEEE80211_CAP_RRM) ||
6366 !(rrm_ie[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT)) {
6367 wpa_printf(MSG_DEBUG,
6368 "RRM: No network support for Neighbor Report.");
6373 wpa_printf(MSG_DEBUG,
6374 "RRM: Neighbor Report request must provide a callback.");
6378 /* Refuse if there's a live request */
6379 if (wpa_s->rrm.notify_neighbor_rep) {
6380 wpa_printf(MSG_DEBUG,
6381 "RRM: Currently handling previous Neighbor Report.");
6385 /* 3 = action category + action code + dialog token */
6386 buf = wpabuf_alloc(3 + (ssid ? 2 + ssid->ssid_len : 0) +
6387 (lci ? 2 + MEASURE_REQUEST_LCI_LEN : 0) +
6388 (civic ? 2 + MEASURE_REQUEST_CIVIC_LEN : 0));
6390 wpa_printf(MSG_DEBUG,
6391 "RRM: Failed to allocate Neighbor Report Request");
6395 wpa_printf(MSG_DEBUG, "RRM: Neighbor report request (for %s), token=%d",
6396 (ssid ? wpa_ssid_txt(ssid->ssid, ssid->ssid_len) : ""),
6397 wpa_s->rrm.next_neighbor_rep_token);
6399 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6400 wpabuf_put_u8(buf, WLAN_RRM_NEIGHBOR_REPORT_REQUEST);
6401 wpabuf_put_u8(buf, wpa_s->rrm.next_neighbor_rep_token);
6403 wpabuf_put_u8(buf, WLAN_EID_SSID);
6404 wpabuf_put_u8(buf, ssid->ssid_len);
6405 wpabuf_put_data(buf, ssid->ssid, ssid->ssid_len);
6409 /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */
6410 wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST);
6411 wpabuf_put_u8(buf, MEASURE_REQUEST_LCI_LEN);
6414 * Measurement token; nonzero number that is unique among the
6415 * Measurement Request elements in a particular frame.
6417 wpabuf_put_u8(buf, 1); /* Measurement Token */
6420 * Parallel, Enable, Request, and Report bits are 0, Duration is
6423 wpabuf_put_u8(buf, 0); /* Measurement Request Mode */
6424 wpabuf_put_u8(buf, MEASURE_TYPE_LCI); /* Measurement Type */
6426 /* IEEE P802.11-REVmc/D5.0 9.4.2.21.10 - LCI request */
6427 /* Location Subject */
6428 wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE);
6430 /* Optional Subelements */
6432 * IEEE P802.11-REVmc/D5.0 Figure 9-170
6433 * The Maximum Age subelement is required, otherwise the AP can
6434 * send only data that was determined after receiving the
6435 * request. Setting it here to unlimited age.
6437 wpabuf_put_u8(buf, LCI_REQ_SUBELEM_MAX_AGE);
6438 wpabuf_put_u8(buf, 2);
6439 wpabuf_put_le16(buf, 0xffff);
6443 /* IEEE P802.11-REVmc/D5.0 9.4.2.21 */
6444 wpabuf_put_u8(buf, WLAN_EID_MEASURE_REQUEST);
6445 wpabuf_put_u8(buf, MEASURE_REQUEST_CIVIC_LEN);
6448 * Measurement token; nonzero number that is unique among the
6449 * Measurement Request elements in a particular frame.
6451 wpabuf_put_u8(buf, 2); /* Measurement Token */
6454 * Parallel, Enable, Request, and Report bits are 0, Duration is
6457 wpabuf_put_u8(buf, 0); /* Measurement Request Mode */
6458 /* Measurement Type */
6459 wpabuf_put_u8(buf, MEASURE_TYPE_LOCATION_CIVIC);
6461 /* IEEE P802.11-REVmc/D5.0 9.4.2.21.14:
6462 * Location Civic request */
6463 /* Location Subject */
6464 wpabuf_put_u8(buf, LOCATION_SUBJECT_REMOTE);
6465 wpabuf_put_u8(buf, 0); /* Civic Location Type: IETF RFC 4776 */
6466 /* Location Service Interval Units: Seconds */
6467 wpabuf_put_u8(buf, 0);
6468 /* Location Service Interval: 0 - Only one report is requested
6470 wpabuf_put_le16(buf, 0);
6471 /* No optional subelements */
6474 wpa_s->rrm.next_neighbor_rep_token++;
6476 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
6477 wpa_s->own_addr, wpa_s->bssid,
6478 wpabuf_head(buf), wpabuf_len(buf), 0) < 0) {
6479 wpa_printf(MSG_DEBUG,
6480 "RRM: Failed to send Neighbor Report Request");
6485 wpa_s->rrm.neighbor_rep_cb_ctx = cb_ctx;
6486 wpa_s->rrm.notify_neighbor_rep = cb;
6487 eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT, 0,
6488 wpas_rrm_neighbor_rep_timeout_handler,
6496 static struct wpabuf * wpas_rrm_build_lci_report(struct wpa_supplicant *wpa_s,
6497 const u8 *request, size_t len,
6498 struct wpabuf *report)
6500 u8 token, type, subject;
6502 struct os_reltime t, diff;
6503 unsigned long diff_l;
6507 if (!wpa_s->lci || len < 3 + 4)
6511 /* Measurement request mode isn't used */
6514 subject = *request++;
6516 wpa_printf(MSG_DEBUG,
6517 "Measurement request token %u type %u location subject %u",
6518 token, type, subject);
6520 if (type != MEASURE_TYPE_LCI || subject != LOCATION_SUBJECT_REMOTE) {
6521 wpa_printf(MSG_INFO,
6522 "Not building LCI report - bad type or location subject");
6526 /* Subelements are formatted exactly like elements */
6527 subelem = get_ie(request, len, LCI_REQ_SUBELEM_MAX_AGE);
6528 if (subelem && subelem[1] == 2)
6529 max_age = WPA_GET_LE16(subelem + 2);
6531 if (os_get_reltime(&t))
6534 os_reltime_sub(&t, &wpa_s->lci_time, &diff);
6535 /* LCI age is calculated in 10th of a second units. */
6536 diff_l = diff.sec * 10 + diff.usec / 100000;
6538 if (max_age != 0xffff && max_age < diff_l)
6541 if (wpabuf_resize(&report, 2 + wpabuf_len(wpa_s->lci)))
6544 wpabuf_put_u8(report, WLAN_EID_MEASURE_REPORT);
6545 wpabuf_put_u8(report, wpabuf_len(wpa_s->lci));
6546 /* We'll override user's measurement token */
6547 ptoken = wpabuf_put(report, 0);
6548 wpabuf_put_buf(report, wpa_s->lci);
6555 void wpas_rrm_handle_radio_measurement_request(struct wpa_supplicant *wpa_s,
6557 const u8 *frame, size_t len)
6559 struct wpabuf *buf, *report;
6563 if (wpa_s->wpa_state != WPA_COMPLETED) {
6564 wpa_printf(MSG_INFO,
6565 "RRM: Ignoring radio measurement request: Not associated");
6569 if (!wpa_s->rrm.rrm_used) {
6570 wpa_printf(MSG_INFO,
6571 "RRM: Ignoring radio measurement request: Not RRM network");
6576 wpa_printf(MSG_INFO,
6577 "RRM: Ignoring too short radio measurement request");
6585 /* Ignore number of repetitions because it's not used in LCI request */
6589 while ((ie = get_ie(frame, end - frame, WLAN_EID_MEASURE_REQUEST)) &&
6594 wpa_printf(MSG_DEBUG, "RRM request %d", msmt_type);
6596 switch (msmt_type) {
6597 case MEASURE_TYPE_LCI:
6598 report = wpas_rrm_build_lci_report(wpa_s, ie + 2, ie[1],
6602 wpa_printf(MSG_INFO,
6603 "RRM: Unsupported radio measurement request %d",
6608 frame = ie + ie[1] + 2;
6614 buf = wpabuf_alloc(3 + wpabuf_len(report));
6616 wpabuf_free(report);
6620 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6621 wpabuf_put_u8(buf, WLAN_RRM_RADIO_MEASUREMENT_REPORT);
6622 wpabuf_put_u8(buf, token);
6624 wpabuf_put_buf(buf, report);
6625 wpabuf_free(report);
6627 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6628 wpa_s->own_addr, wpa_s->bssid,
6629 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6630 wpa_printf(MSG_ERROR,
6631 "RRM: Radio measurement report failed: Sending Action frame failed");
6637 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s,
6639 const u8 *frame, size_t len,
6643 const struct rrm_link_measurement_request *req;
6644 struct rrm_link_measurement_report report;
6646 if (wpa_s->wpa_state != WPA_COMPLETED) {
6647 wpa_printf(MSG_INFO,
6648 "RRM: Ignoring link measurement request. Not associated");
6652 if (!wpa_s->rrm.rrm_used) {
6653 wpa_printf(MSG_INFO,
6654 "RRM: Ignoring link measurement request. Not RRM network");
6658 if (!(wpa_s->drv_rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION)) {
6659 wpa_printf(MSG_INFO,
6660 "RRM: Measurement report failed. TX power insertion not supported");
6664 req = (const struct rrm_link_measurement_request *) frame;
6665 if (len < sizeof(*req)) {
6666 wpa_printf(MSG_INFO,
6667 "RRM: Link measurement report failed. Request too short");
6671 os_memset(&report, 0, sizeof(report));
6672 report.tpc.eid = WLAN_EID_TPC_REPORT;
6674 report.rsni = 255; /* 255 indicates that RSNI is not available */
6675 report.dialog_token = req->dialog_token;
6678 * It's possible to estimate RCPI based on RSSI in dBm. This
6679 * calculation will not reflect the correct value for high rates,
6680 * but it's good enough for Action frames which are transmitted
6681 * with up to 24 Mbps rates.
6684 report.rcpi = 255; /* not available */
6685 else if (rssi < -110)
6690 report.rcpi = (rssi + 110) * 2;
6692 /* action_category + action_code */
6693 buf = wpabuf_alloc(2 + sizeof(report));
6695 wpa_printf(MSG_ERROR,
6696 "RRM: Link measurement report failed. Buffer allocation failed");
6700 wpabuf_put_u8(buf, WLAN_ACTION_RADIO_MEASUREMENT);
6701 wpabuf_put_u8(buf, WLAN_RRM_LINK_MEASUREMENT_REPORT);
6702 wpabuf_put_data(buf, &report, sizeof(report));
6703 wpa_hexdump(MSG_DEBUG, "RRM: Link measurement report:",
6704 wpabuf_head(buf), wpabuf_len(buf));
6706 if (wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, src,
6707 wpa_s->own_addr, wpa_s->bssid,
6708 wpabuf_head(buf), wpabuf_len(buf), 0)) {
6709 wpa_printf(MSG_ERROR,
6710 "RRM: Link measurement report failed. Send action failed");
6716 struct wpa_supplicant *
6717 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
6721 case VENDOR_ELEM_PROBE_REQ_P2P:
6722 case VENDOR_ELEM_PROBE_RESP_P2P:
6723 case VENDOR_ELEM_PROBE_RESP_P2P_GO:
6724 case VENDOR_ELEM_BEACON_P2P_GO:
6725 case VENDOR_ELEM_P2P_PD_REQ:
6726 case VENDOR_ELEM_P2P_PD_RESP:
6727 case VENDOR_ELEM_P2P_GO_NEG_REQ:
6728 case VENDOR_ELEM_P2P_GO_NEG_RESP:
6729 case VENDOR_ELEM_P2P_GO_NEG_CONF:
6730 case VENDOR_ELEM_P2P_INV_REQ:
6731 case VENDOR_ELEM_P2P_INV_RESP:
6732 case VENDOR_ELEM_P2P_ASSOC_REQ:
6733 case VENDOR_ELEM_P2P_ASSOC_RESP:
6734 return wpa_s->p2pdev;
6735 #endif /* CONFIG_P2P */
6742 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
6747 wpa_printf(MSG_DEBUG, "Update vendor elements");
6749 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) {
6750 if (wpa_s->vendor_elem[i]) {
6753 res = os_snprintf(buf, sizeof(buf), "frame[%u]", i);
6754 if (!os_snprintf_error(sizeof(buf), res)) {
6755 wpa_hexdump_buf(MSG_DEBUG, buf,
6756 wpa_s->vendor_elem[i]);
6762 if (wpa_s->parent == wpa_s &&
6763 wpa_s->global->p2p &&
6764 !wpa_s->global->p2p_disabled)
6765 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
6766 #endif /* CONFIG_P2P */
6770 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
6771 const u8 *elem, size_t len)
6775 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
6776 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
6778 for (; ie + 1 < end; ie += 2 + ie[1]) {
6781 if (os_memcmp(ie, elem, len) != 0)
6784 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
6785 wpabuf_free(wpa_s->vendor_elem[frame]);
6786 wpa_s->vendor_elem[frame] = NULL;
6788 os_memmove(ie, ie + len, end - (ie + len));
6789 wpa_s->vendor_elem[frame]->used -= len;
6791 wpas_vendor_elem_update(wpa_s);
6799 struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
6800 u16 num_modes, enum hostapd_hw_mode mode)
6804 for (i = 0; i < num_modes; i++) {
6805 if (modes[i].mode == mode)
6814 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
6817 struct wpa_bss_tmp_disallowed *bss;
6819 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
6820 struct wpa_bss_tmp_disallowed, list) {
6821 if (os_memcmp(bssid, bss->bssid, ETH_ALEN) == 0)
6829 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
6832 struct wpa_bss_tmp_disallowed *bss;
6833 struct os_reltime until;
6835 os_get_reltime(&until);
6838 bss = wpas_get_disallowed_bss(wpa_s, bssid);
6840 bss->disallowed_until = until;
6844 bss = os_malloc(sizeof(*bss));
6846 wpa_printf(MSG_DEBUG,
6847 "Failed to allocate memory for temp disallow BSS");
6851 bss->disallowed_until = until;
6852 os_memcpy(bss->bssid, bssid, ETH_ALEN);
6853 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
6857 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s, const u8 *bssid)
6859 struct wpa_bss_tmp_disallowed *bss = NULL, *tmp, *prev;
6860 struct os_reltime now, age;
6862 os_get_reltime(&now);
6864 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
6865 struct wpa_bss_tmp_disallowed, list) {
6866 if (!os_reltime_before(&now, &tmp->disallowed_until)) {
6867 /* This BSS is not disallowed anymore */
6868 dl_list_del(&tmp->list);
6872 if (os_memcmp(bssid, tmp->bssid, ETH_ALEN) == 0) {
6880 os_reltime_sub(&bss->disallowed_until, &now, &age);
6881 wpa_printf(MSG_DEBUG,
6882 "BSS " MACSTR " disabled for %ld.%0ld seconds",
6883 MAC2STR(bss->bssid), age.sec, age.usec);