3 * Copyright (c) 2003-2017, 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-2017, 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(wpa_s
->pending_bssid
) &&
196 (wpa_s
->wpa_state
== WPA_AUTHENTICATING
||
197 wpa_s
->wpa_state
== WPA_ASSOCIATING
))
198 bssid
= wpa_s
->pending_bssid
;
199 wpa_msg(wpa_s
, MSG_INFO
, "Authentication with " MACSTR
" timed out.",
201 wpa_blacklist_add(wpa_s
, bssid
);
202 wpa_sm_notify_disassoc(wpa_s
->wpa
);
203 wpa_supplicant_deauthenticate(wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
204 wpa_s
->reassociate
= 1;
207 * If we timed out, the AP or the local radio may be busy.
208 * So, wait a second until scanning again.
210 wpa_supplicant_req_scan(wpa_s
, 1, 0);
215 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
216 * @wpa_s: Pointer to wpa_supplicant data
217 * @sec: Number of seconds after which to time out authentication
218 * @usec: Number of microseconds after which to time out authentication
220 * This function is used to schedule a timeout for the current authentication
223 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant
*wpa_s
,
226 if (wpa_s
->conf
->ap_scan
== 0 &&
227 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
))
230 wpa_dbg(wpa_s
, MSG_DEBUG
, "Setting authentication timeout: %d sec "
231 "%d usec", sec
, usec
);
232 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
233 eloop_register_timeout(sec
, usec
, wpa_supplicant_timeout
, wpa_s
, NULL
);
238 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
239 * @wpa_s: Pointer to wpa_supplicant data
241 * This function is used to cancel authentication timeout scheduled with
242 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
245 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant
*wpa_s
)
247 wpa_dbg(wpa_s
, MSG_DEBUG
, "Cancelling authentication timeout");
248 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
249 wpa_blacklist_del(wpa_s
, wpa_s
->bssid
);
254 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
255 * @wpa_s: Pointer to wpa_supplicant data
257 * This function is used to configure EAPOL state machine based on the selected
258 * authentication mode.
260 void wpa_supplicant_initiate_eapol(struct wpa_supplicant
*wpa_s
)
262 #ifdef IEEE8021X_EAPOL
263 struct eapol_config eapol_conf
;
264 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
266 #ifdef CONFIG_IBSS_RSN
267 if (ssid
->mode
== WPAS_MODE_IBSS
&&
268 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_NONE
&&
269 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPA_NONE
) {
271 * RSN IBSS authentication is per-STA and we can disable the
272 * per-BSSID EAPOL authentication.
274 eapol_sm_notify_portControl(wpa_s
->eapol
, ForceAuthorized
);
275 eapol_sm_notify_eap_success(wpa_s
->eapol
, TRUE
);
276 eapol_sm_notify_eap_fail(wpa_s
->eapol
, FALSE
);
279 #endif /* CONFIG_IBSS_RSN */
281 eapol_sm_notify_eap_success(wpa_s
->eapol
, FALSE
);
282 eapol_sm_notify_eap_fail(wpa_s
->eapol
, FALSE
);
284 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
||
285 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
)
286 eapol_sm_notify_portControl(wpa_s
->eapol
, ForceAuthorized
);
288 eapol_sm_notify_portControl(wpa_s
->eapol
, Auto
);
290 os_memset(&eapol_conf
, 0, sizeof(eapol_conf
));
291 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
292 eapol_conf
.accept_802_1x_keys
= 1;
293 eapol_conf
.required_keys
= 0;
294 if (ssid
->eapol_flags
& EAPOL_FLAG_REQUIRE_KEY_UNICAST
) {
295 eapol_conf
.required_keys
|= EAPOL_REQUIRE_KEY_UNICAST
;
297 if (ssid
->eapol_flags
& EAPOL_FLAG_REQUIRE_KEY_BROADCAST
) {
298 eapol_conf
.required_keys
|=
299 EAPOL_REQUIRE_KEY_BROADCAST
;
302 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
)
303 eapol_conf
.required_keys
= 0;
305 eapol_conf
.fast_reauth
= wpa_s
->conf
->fast_reauth
;
306 eapol_conf
.workaround
= ssid
->eap_workaround
;
307 eapol_conf
.eap_disabled
=
308 !wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) &&
309 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_IEEE8021X_NO_WPA
&&
310 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPS
;
311 eapol_conf
.external_sim
= wpa_s
->conf
->external_sim
;
314 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
) {
315 eapol_conf
.wps
|= EAPOL_LOCAL_WPS_IN_USE
;
316 if (wpa_s
->current_bss
) {
318 ie
= wpa_bss_get_vendor_ie_multi(wpa_s
->current_bss
,
323 EAPOL_PEER_IS_WPS20_AP
;
328 #endif /* CONFIG_WPS */
330 eapol_sm_notify_config(wpa_s
->eapol
, &ssid
->eap
, &eapol_conf
);
333 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
&& ssid
->mka_psk_set
)
334 ieee802_1x_create_preshared_mka(wpa_s
, ssid
);
336 ieee802_1x_alloc_kay_sm(wpa_s
, ssid
);
337 #endif /* CONFIG_MACSEC */
338 #endif /* IEEE8021X_EAPOL */
343 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
344 * @wpa_s: Pointer to wpa_supplicant data
345 * @ssid: Configuration data for the network
347 * This function is used to configure WPA state machine and related parameters
348 * to a mode where WPA is not enabled. This is called as part of the
349 * authentication configuration when the selected network does not use WPA.
351 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant
*wpa_s
,
352 struct wpa_ssid
*ssid
)
356 if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)
357 wpa_s
->key_mgmt
= WPA_KEY_MGMT_WPS
;
358 else if (ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
)
359 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_NO_WPA
;
361 wpa_s
->key_mgmt
= WPA_KEY_MGMT_NONE
;
362 wpa_sm_set_ap_wpa_ie(wpa_s
->wpa
, NULL
, 0);
363 wpa_sm_set_ap_rsn_ie(wpa_s
->wpa
, NULL
, 0);
364 wpa_sm_set_assoc_wpa_ie(wpa_s
->wpa
, NULL
, 0);
365 wpa_s
->pairwise_cipher
= WPA_CIPHER_NONE
;
366 wpa_s
->group_cipher
= WPA_CIPHER_NONE
;
367 wpa_s
->mgmt_group_cipher
= 0;
369 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
370 if (ssid
->wep_key_len
[i
] > 5) {
371 wpa_s
->pairwise_cipher
= WPA_CIPHER_WEP104
;
372 wpa_s
->group_cipher
= WPA_CIPHER_WEP104
;
374 } else if (ssid
->wep_key_len
[i
] > 0) {
375 wpa_s
->pairwise_cipher
= WPA_CIPHER_WEP40
;
376 wpa_s
->group_cipher
= WPA_CIPHER_WEP40
;
381 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_RSN_ENABLED
, 0);
382 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_KEY_MGMT
, wpa_s
->key_mgmt
);
383 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PAIRWISE
,
384 wpa_s
->pairwise_cipher
);
385 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_GROUP
, wpa_s
->group_cipher
);
386 #ifdef CONFIG_IEEE80211W
387 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MGMT_GROUP
,
388 wpa_s
->mgmt_group_cipher
);
389 #endif /* CONFIG_IEEE80211W */
391 pmksa_cache_clear_current(wpa_s
->wpa
);
395 void free_hw_features(struct wpa_supplicant
*wpa_s
)
398 if (wpa_s
->hw
.modes
== NULL
)
401 for (i
= 0; i
< wpa_s
->hw
.num_modes
; i
++) {
402 os_free(wpa_s
->hw
.modes
[i
].channels
);
403 os_free(wpa_s
->hw
.modes
[i
].rates
);
406 os_free(wpa_s
->hw
.modes
);
407 wpa_s
->hw
.modes
= NULL
;
411 static void free_bss_tmp_disallowed(struct wpa_supplicant
*wpa_s
)
413 struct wpa_bss_tmp_disallowed
*bss
, *prev
;
415 dl_list_for_each_safe(bss
, prev
, &wpa_s
->bss_tmp_disallowed
,
416 struct wpa_bss_tmp_disallowed
, list
) {
417 dl_list_del(&bss
->list
);
423 void wpas_flush_fils_hlp_req(struct wpa_supplicant
*wpa_s
)
425 struct fils_hlp_req
*req
;
427 while ((req
= dl_list_first(&wpa_s
->fils_hlp_req
, struct fils_hlp_req
,
429 dl_list_del(&req
->list
);
430 wpabuf_free(req
->pkt
);
436 static void wpa_supplicant_cleanup(struct wpa_supplicant
*wpa_s
)
440 bgscan_deinit(wpa_s
);
441 autoscan_deinit(wpa_s
);
442 scard_deinit(wpa_s
->scard
);
444 wpa_sm_set_scard_ctx(wpa_s
->wpa
, NULL
);
445 eapol_sm_register_scard_ctx(wpa_s
->eapol
, NULL
);
446 l2_packet_deinit(wpa_s
->l2
);
449 l2_packet_deinit(wpa_s
->l2_br
);
452 #ifdef CONFIG_TESTING_OPTIONS
453 l2_packet_deinit(wpa_s
->l2_test
);
454 wpa_s
->l2_test
= NULL
;
455 os_free(wpa_s
->get_pref_freq_list_override
);
456 wpa_s
->get_pref_freq_list_override
= NULL
;
457 #endif /* CONFIG_TESTING_OPTIONS */
459 if (wpa_s
->conf
!= NULL
) {
460 struct wpa_ssid
*ssid
;
461 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
462 wpas_notify_network_removed(wpa_s
, ssid
);
465 os_free(wpa_s
->confname
);
466 wpa_s
->confname
= NULL
;
468 os_free(wpa_s
->confanother
);
469 wpa_s
->confanother
= NULL
;
471 wpa_sm_set_eapol(wpa_s
->wpa
, NULL
);
472 eapol_sm_deinit(wpa_s
->eapol
);
475 rsn_preauth_deinit(wpa_s
->wpa
);
478 wpa_tdls_deinit(wpa_s
->wpa
);
479 #endif /* CONFIG_TDLS */
481 wmm_ac_clear_saved_tspecs(wpa_s
);
482 pmksa_candidate_free(wpa_s
->wpa
);
483 wpa_sm_deinit(wpa_s
->wpa
);
485 wpa_blacklist_clear(wpa_s
);
487 wpa_bss_deinit(wpa_s
);
489 wpa_supplicant_cancel_delayed_sched_scan(wpa_s
);
490 wpa_supplicant_cancel_scan(wpa_s
);
491 wpa_supplicant_cancel_auth_timeout(wpa_s
);
492 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures
, wpa_s
, NULL
);
493 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
494 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report
,
496 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
498 eloop_cancel_timeout(wpas_network_reenabled
, wpa_s
, NULL
);
500 wpas_wps_deinit(wpa_s
);
502 wpabuf_free(wpa_s
->pending_eapol_rx
);
503 wpa_s
->pending_eapol_rx
= NULL
;
505 #ifdef CONFIG_IBSS_RSN
506 ibss_rsn_deinit(wpa_s
->ibss_rsn
);
507 wpa_s
->ibss_rsn
= NULL
;
508 #endif /* CONFIG_IBSS_RSN */
513 wpa_supplicant_ap_deinit(wpa_s
);
514 #endif /* CONFIG_AP */
516 wpas_p2p_deinit(wpa_s
);
518 #ifdef CONFIG_OFFCHANNEL
519 offchannel_deinit(wpa_s
);
520 #endif /* CONFIG_OFFCHANNEL */
522 wpa_supplicant_cancel_sched_scan(wpa_s
);
524 os_free(wpa_s
->next_scan_freqs
);
525 wpa_s
->next_scan_freqs
= NULL
;
527 os_free(wpa_s
->manual_scan_freqs
);
528 wpa_s
->manual_scan_freqs
= NULL
;
530 os_free(wpa_s
->manual_sched_scan_freqs
);
531 wpa_s
->manual_sched_scan_freqs
= NULL
;
533 wpas_mac_addr_rand_scan_clear(wpa_s
, MAC_ADDR_RAND_ALL
);
536 * Need to remove any pending gas-query radio work before the
537 * gas_query_deinit() call because gas_query::work has not yet been set
538 * for works that have not been started. gas_query_free() will be unable
539 * to cancel such pending radio works and once the pending gas-query
540 * radio work eventually gets removed, the deinit notification call to
541 * gas_query_start_cb() would result in dereferencing freed memory.
544 radio_remove_works(wpa_s
, "gas-query", 0);
545 gas_query_deinit(wpa_s
->gas
);
548 free_hw_features(wpa_s
);
550 ieee802_1x_dealloc_kay_sm(wpa_s
);
552 os_free(wpa_s
->bssid_filter
);
553 wpa_s
->bssid_filter
= NULL
;
555 os_free(wpa_s
->disallow_aps_bssid
);
556 wpa_s
->disallow_aps_bssid
= NULL
;
557 os_free(wpa_s
->disallow_aps_ssid
);
558 wpa_s
->disallow_aps_ssid
= NULL
;
560 wnm_bss_keep_alive_deinit(wpa_s
);
562 wnm_deallocate_memory(wpa_s
);
563 #endif /* CONFIG_WNM */
565 ext_password_deinit(wpa_s
->ext_pw
);
566 wpa_s
->ext_pw
= NULL
;
568 wpabuf_free(wpa_s
->last_gas_resp
);
569 wpa_s
->last_gas_resp
= NULL
;
570 wpabuf_free(wpa_s
->prev_gas_resp
);
571 wpa_s
->prev_gas_resp
= NULL
;
573 os_free(wpa_s
->last_scan_res
);
574 wpa_s
->last_scan_res
= NULL
;
578 wpa_drv_configure_frame_filters(wpa_s
, 0);
580 #endif /* CONFIG_HS20 */
582 for (i
= 0; i
< NUM_VENDOR_ELEM_FRAMES
; i
++) {
583 wpabuf_free(wpa_s
->vendor_elem
[i
]);
584 wpa_s
->vendor_elem
[i
] = NULL
;
587 wmm_ac_notify_disassoc(wpa_s
);
589 wpa_s
->sched_scan_plans_num
= 0;
590 os_free(wpa_s
->sched_scan_plans
);
591 wpa_s
->sched_scan_plans
= NULL
;
594 wpa_s
->non_pref_chan_num
= 0;
595 os_free(wpa_s
->non_pref_chan
);
596 wpa_s
->non_pref_chan
= NULL
;
597 #endif /* CONFIG_MBO */
599 free_bss_tmp_disallowed(wpa_s
);
601 wpabuf_free(wpa_s
->lci
);
603 wpas_clear_beacon_rep_data(wpa_s
);
605 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
608 struct external_pmksa_cache
*entry
;
610 while ((entry
= dl_list_last(&wpa_s
->mesh_external_pmksa_cache
,
611 struct external_pmksa_cache
,
613 dl_list_del(&entry
->list
);
614 os_free(entry
->pmksa_cache
);
618 #endif /* CONFIG_MESH */
619 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
621 wpas_flush_fils_hlp_req(wpa_s
);
623 wpabuf_free(wpa_s
->ric_ies
);
624 wpa_s
->ric_ies
= NULL
;
629 * wpa_clear_keys - Clear keys configured for the driver
630 * @wpa_s: Pointer to wpa_supplicant data
631 * @addr: Previously used BSSID or %NULL if not available
633 * This function clears the encryption keys that has been previously configured
636 void wpa_clear_keys(struct wpa_supplicant
*wpa_s
, const u8
*addr
)
640 #ifdef CONFIG_IEEE80211W
642 #else /* CONFIG_IEEE80211W */
644 #endif /* CONFIG_IEEE80211W */
646 /* MLME-DELETEKEYS.request */
647 for (i
= 0; i
< max
; i
++) {
648 if (wpa_s
->keys_cleared
& BIT(i
))
650 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, i
, 0, NULL
, 0,
653 if (!(wpa_s
->keys_cleared
& BIT(0)) && addr
&&
654 !is_zero_ether_addr(addr
)) {
655 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, addr
, 0, 0, NULL
, 0, NULL
,
657 /* MLME-SETPROTECTION.request(None) */
658 wpa_drv_mlme_setprotection(
660 MLME_SETPROTECTION_PROTECT_TYPE_NONE
,
661 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE
);
663 wpa_s
->keys_cleared
= (u32
) -1;
668 * wpa_supplicant_state_txt - Get the connection state name as a text string
669 * @state: State (wpa_state; WPA_*)
670 * Returns: The state name as a printable text string
672 const char * wpa_supplicant_state_txt(enum wpa_states state
)
675 case WPA_DISCONNECTED
:
676 return "DISCONNECTED";
679 case WPA_INTERFACE_DISABLED
:
680 return "INTERFACE_DISABLED";
683 case WPA_AUTHENTICATING
:
684 return "AUTHENTICATING";
685 case WPA_ASSOCIATING
:
686 return "ASSOCIATING";
689 case WPA_4WAY_HANDSHAKE
:
690 return "4WAY_HANDSHAKE";
691 case WPA_GROUP_HANDSHAKE
:
692 return "GROUP_HANDSHAKE";
703 static void wpa_supplicant_start_bgscan(struct wpa_supplicant
*wpa_s
)
707 if (wpa_s
->current_ssid
&& wpa_s
->current_ssid
->bgscan
)
708 name
= wpa_s
->current_ssid
->bgscan
;
710 name
= wpa_s
->conf
->bgscan
;
711 if (name
== NULL
|| name
[0] == '\0')
713 if (wpas_driver_bss_selection(wpa_s
))
715 if (wpa_s
->current_ssid
== wpa_s
->bgscan_ssid
)
718 if (wpa_s
->p2p_group_interface
!= NOT_P2P_GROUP_INTERFACE
)
720 #endif /* CONFIG_P2P */
722 bgscan_deinit(wpa_s
);
723 if (wpa_s
->current_ssid
) {
724 if (bgscan_init(wpa_s
, wpa_s
->current_ssid
, name
)) {
725 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize "
728 * Live without bgscan; it is only used as a roaming
729 * optimization, so the initial connection is not
733 struct wpa_scan_results
*scan_res
;
734 wpa_s
->bgscan_ssid
= wpa_s
->current_ssid
;
735 scan_res
= wpa_supplicant_get_scan_results(wpa_s
, NULL
,
738 bgscan_notify_scan(wpa_s
, scan_res
);
739 wpa_scan_results_free(scan_res
);
743 wpa_s
->bgscan_ssid
= NULL
;
747 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant
*wpa_s
)
749 if (wpa_s
->bgscan_ssid
!= NULL
) {
750 bgscan_deinit(wpa_s
);
751 wpa_s
->bgscan_ssid
= NULL
;
755 #endif /* CONFIG_BGSCAN */
758 static void wpa_supplicant_start_autoscan(struct wpa_supplicant
*wpa_s
)
760 if (autoscan_init(wpa_s
, 0))
761 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize autoscan");
765 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant
*wpa_s
)
767 autoscan_deinit(wpa_s
);
771 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant
*wpa_s
)
773 if (wpa_s
->wpa_state
== WPA_DISCONNECTED
||
774 wpa_s
->wpa_state
== WPA_SCANNING
) {
775 autoscan_deinit(wpa_s
);
776 wpa_supplicant_start_autoscan(wpa_s
);
782 * wpa_supplicant_set_state - Set current connection state
783 * @wpa_s: Pointer to wpa_supplicant data
784 * @state: The new connection state
786 * This function is called whenever the connection state changes, e.g.,
787 * association is completed for WPA/WPA2 4-Way Handshake is started.
789 void wpa_supplicant_set_state(struct wpa_supplicant
*wpa_s
,
790 enum wpa_states state
)
792 enum wpa_states old_state
= wpa_s
->wpa_state
;
794 wpa_dbg(wpa_s
, MSG_DEBUG
, "State: %s -> %s",
795 wpa_supplicant_state_txt(wpa_s
->wpa_state
),
796 wpa_supplicant_state_txt(state
));
798 if (state
== WPA_INTERFACE_DISABLED
) {
799 /* Assure normal scan when interface is restored */
800 wpa_s
->normal_scans
= 0;
803 if (state
== WPA_COMPLETED
) {
804 wpas_connect_work_done(wpa_s
);
805 /* Reinitialize normal_scan counter */
806 wpa_s
->normal_scans
= 0;
811 * P2PS client has to reply to Probe Request frames received on the
812 * group operating channel. Enable Probe Request frame reporting for
813 * P2P connected client in case p2p_cli_probe configuration property is
816 if (wpa_s
->conf
->p2p_cli_probe
&& wpa_s
->current_ssid
&&
817 wpa_s
->current_ssid
->mode
== WPAS_MODE_INFRA
&&
818 wpa_s
->current_ssid
->p2p_group
) {
819 if (state
== WPA_COMPLETED
&& !wpa_s
->p2p_cli_probe
) {
820 wpa_dbg(wpa_s
, MSG_DEBUG
,
821 "P2P: Enable CLI Probe Request RX reporting");
822 wpa_s
->p2p_cli_probe
=
823 wpa_drv_probe_req_report(wpa_s
, 1) >= 0;
824 } else if (state
!= WPA_COMPLETED
&& wpa_s
->p2p_cli_probe
) {
825 wpa_dbg(wpa_s
, MSG_DEBUG
,
826 "P2P: Disable CLI Probe Request RX reporting");
827 wpa_s
->p2p_cli_probe
= 0;
828 wpa_drv_probe_req_report(wpa_s
, 0);
831 #endif /* CONFIG_P2P */
833 if (state
!= WPA_SCANNING
)
834 wpa_supplicant_notify_scanning(wpa_s
, 0);
836 if (state
== WPA_COMPLETED
&& wpa_s
->new_connection
) {
837 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
838 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
839 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_CONNECTED
"- Connection to "
840 MACSTR
" completed [id=%d id_str=%s]",
841 MAC2STR(wpa_s
->bssid
),
842 ssid
? ssid
->id
: -1,
843 ssid
&& ssid
->id_str
? ssid
->id_str
: "");
844 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
845 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
846 wpa_blacklist_clear(wpa_s
);
847 wpa_s
->extra_blacklist_count
= 0;
848 wpa_s
->new_connection
= 0;
849 wpa_drv_set_operstate(wpa_s
, 1);
850 #ifndef IEEE8021X_EAPOL
851 wpa_drv_set_supp_port(wpa_s
, 1);
852 #endif /* IEEE8021X_EAPOL */
853 wpa_s
->after_wps
= 0;
854 wpa_s
->known_wps_freq
= 0;
855 wpas_p2p_completed(wpa_s
);
857 sme_sched_obss_scan(wpa_s
, 1);
858 } else if (state
== WPA_DISCONNECTED
|| state
== WPA_ASSOCIATING
||
859 state
== WPA_ASSOCIATED
) {
860 wpa_s
->new_connection
= 1;
861 wpa_drv_set_operstate(wpa_s
, 0);
862 #ifndef IEEE8021X_EAPOL
863 wpa_drv_set_supp_port(wpa_s
, 0);
864 #endif /* IEEE8021X_EAPOL */
865 sme_sched_obss_scan(wpa_s
, 0);
867 wpa_s
->wpa_state
= state
;
870 if (state
== WPA_COMPLETED
)
871 wpa_supplicant_start_bgscan(wpa_s
);
872 else if (state
< WPA_ASSOCIATED
)
873 wpa_supplicant_stop_bgscan(wpa_s
);
874 #endif /* CONFIG_BGSCAN */
876 if (state
== WPA_AUTHENTICATING
)
877 wpa_supplicant_stop_autoscan(wpa_s
);
879 if (state
== WPA_DISCONNECTED
|| state
== WPA_INACTIVE
)
880 wpa_supplicant_start_autoscan(wpa_s
);
882 if (old_state
>= WPA_ASSOCIATED
&& wpa_s
->wpa_state
< WPA_ASSOCIATED
)
883 wmm_ac_notify_disassoc(wpa_s
);
885 if (wpa_s
->wpa_state
!= old_state
) {
886 wpas_notify_state_changed(wpa_s
, wpa_s
->wpa_state
, old_state
);
889 * Notify the P2P Device interface about a state change in one
892 wpas_p2p_indicate_state_change(wpa_s
);
894 if (wpa_s
->wpa_state
== WPA_COMPLETED
||
895 old_state
== WPA_COMPLETED
)
896 wpas_notify_auth_changed(wpa_s
);
901 void wpa_supplicant_terminate_proc(struct wpa_global
*global
)
905 struct wpa_supplicant
*wpa_s
= global
->ifaces
;
907 struct wpa_supplicant
*next
= wpa_s
->next
;
908 if (wpas_wps_terminate_pending(wpa_s
) == 1)
911 if (wpa_s
->p2p_group_interface
!= NOT_P2P_GROUP_INTERFACE
||
912 (wpa_s
->current_ssid
&& wpa_s
->current_ssid
->p2p_group
))
913 wpas_p2p_disconnect(wpa_s
);
914 #endif /* CONFIG_P2P */
917 #endif /* CONFIG_WPS */
924 static void wpa_supplicant_terminate(int sig
, void *signal_ctx
)
926 struct wpa_global
*global
= signal_ctx
;
927 wpa_supplicant_terminate_proc(global
);
931 void wpa_supplicant_clear_status(struct wpa_supplicant
*wpa_s
)
933 enum wpa_states old_state
= wpa_s
->wpa_state
;
935 wpa_s
->pairwise_cipher
= 0;
936 wpa_s
->group_cipher
= 0;
937 wpa_s
->mgmt_group_cipher
= 0;
939 if (wpa_s
->wpa_state
!= WPA_INTERFACE_DISABLED
)
940 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
942 if (wpa_s
->wpa_state
!= old_state
)
943 wpas_notify_state_changed(wpa_s
, wpa_s
->wpa_state
, old_state
);
948 * wpa_supplicant_reload_configuration - Reload configuration data
949 * @wpa_s: Pointer to wpa_supplicant data
950 * Returns: 0 on success or -1 if configuration parsing failed
952 * This function can be used to request that the configuration data is reloaded
953 * (e.g., after configuration file change). This function is reloading
954 * configuration only for one interface, so this may need to be called multiple
955 * times if %wpa_supplicant is controlling multiple interfaces and all
956 * interfaces need reconfiguration.
958 int wpa_supplicant_reload_configuration(struct wpa_supplicant
*wpa_s
)
960 struct wpa_config
*conf
;
964 if (wpa_s
->confname
== NULL
)
966 conf
= wpa_config_read(wpa_s
->confname
, NULL
);
968 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to parse the configuration "
969 "file '%s' - exiting", wpa_s
->confname
);
972 wpa_config_read(wpa_s
->confanother
, conf
);
974 conf
->changed_parameters
= (unsigned int) -1;
976 reconf_ctrl
= !!conf
->ctrl_interface
!= !!wpa_s
->conf
->ctrl_interface
977 || (conf
->ctrl_interface
&& wpa_s
->conf
->ctrl_interface
&&
978 os_strcmp(conf
->ctrl_interface
,
979 wpa_s
->conf
->ctrl_interface
) != 0);
981 if (reconf_ctrl
&& wpa_s
->ctrl_iface
) {
982 wpa_supplicant_ctrl_iface_deinit(wpa_s
->ctrl_iface
);
983 wpa_s
->ctrl_iface
= NULL
;
986 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
987 if (wpa_s
->current_ssid
) {
988 if (wpa_s
->wpa_state
>= WPA_AUTHENTICATING
)
989 wpa_s
->own_disconnect_req
= 1;
990 wpa_supplicant_deauthenticate(wpa_s
,
991 WLAN_REASON_DEAUTH_LEAVING
);
995 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
996 * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
998 if (wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
)) {
1000 * Clear forced success to clear EAP state for next
1003 eapol_sm_notify_eap_success(wpa_s
->eapol
, FALSE
);
1005 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
1006 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
1007 wpa_sm_pmksa_cache_flush(wpa_s
->wpa
, NULL
);
1008 wpa_sm_set_fast_reauth(wpa_s
->wpa
, wpa_s
->conf
->fast_reauth
);
1009 rsn_preauth_deinit(wpa_s
->wpa
);
1011 old_ap_scan
= wpa_s
->conf
->ap_scan
;
1012 wpa_config_free(wpa_s
->conf
);
1014 if (old_ap_scan
!= wpa_s
->conf
->ap_scan
)
1015 wpas_notify_ap_scan_changed(wpa_s
);
1018 wpa_s
->ctrl_iface
= wpa_supplicant_ctrl_iface_init(wpa_s
);
1020 wpa_supplicant_update_config(wpa_s
);
1022 wpa_supplicant_clear_status(wpa_s
);
1023 if (wpa_supplicant_enabled_networks(wpa_s
)) {
1024 wpa_s
->reassociate
= 1;
1025 wpa_supplicant_req_scan(wpa_s
, 0, 0);
1027 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reconfiguration completed");
1032 static void wpa_supplicant_reconfig(int sig
, void *signal_ctx
)
1034 struct wpa_global
*global
= signal_ctx
;
1035 struct wpa_supplicant
*wpa_s
;
1036 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
1037 wpa_dbg(wpa_s
, MSG_DEBUG
, "Signal %d received - reconfiguring",
1039 if (wpa_supplicant_reload_configuration(wpa_s
) < 0) {
1040 wpa_supplicant_terminate_proc(global
);
1044 if (wpa_debug_reopen_file() < 0) {
1045 /* Ignore errors since we cannot really do much to fix this */
1046 wpa_printf(MSG_DEBUG
, "Could not reopen debug log file");
1051 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant
*wpa_s
,
1052 struct wpa_ssid
*ssid
,
1053 struct wpa_ie_data
*ie
)
1055 int ret
= wpa_sm_parse_own_wpa_ie(wpa_s
->wpa
, ie
);
1058 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Failed to parse WPA IE "
1059 "from association info");
1064 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Using WPA IE from AssocReq to set "
1066 if (!(ie
->group_cipher
& ssid
->group_cipher
)) {
1067 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled group "
1068 "cipher 0x%x (mask 0x%x) - reject",
1069 ie
->group_cipher
, ssid
->group_cipher
);
1072 if (!(ie
->pairwise_cipher
& ssid
->pairwise_cipher
)) {
1073 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled pairwise "
1074 "cipher 0x%x (mask 0x%x) - reject",
1075 ie
->pairwise_cipher
, ssid
->pairwise_cipher
);
1078 if (!(ie
->key_mgmt
& ssid
->key_mgmt
)) {
1079 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled key "
1080 "management 0x%x (mask 0x%x) - reject",
1081 ie
->key_mgmt
, ssid
->key_mgmt
);
1085 #ifdef CONFIG_IEEE80211W
1086 if (!(ie
->capabilities
& WPA_CAPABILITY_MFPC
) &&
1087 wpas_get_ssid_pmf(wpa_s
, ssid
) == MGMT_FRAME_PROTECTION_REQUIRED
) {
1088 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver associated with an AP "
1089 "that does not support management frame protection - "
1093 #endif /* CONFIG_IEEE80211W */
1100 * wpa_supplicant_set_suites - Set authentication and encryption parameters
1101 * @wpa_s: Pointer to wpa_supplicant data
1102 * @bss: Scan results for the selected BSS, or %NULL if not available
1103 * @ssid: Configuration data for the selected network
1104 * @wpa_ie: Buffer for the WPA/RSN IE
1105 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
1106 * used buffer length in case the functions returns success.
1107 * Returns: 0 on success or -1 on failure
1109 * This function is used to configure authentication and encryption parameters
1110 * based on the network configuration and scan result for the selected BSS (if
1113 int wpa_supplicant_set_suites(struct wpa_supplicant
*wpa_s
,
1114 struct wpa_bss
*bss
, struct wpa_ssid
*ssid
,
1115 u8
*wpa_ie
, size_t *wpa_ie_len
)
1117 struct wpa_ie_data ie
;
1119 const u8
*bss_wpa
, *bss_rsn
, *bss_osen
;
1122 bss_wpa
= wpa_bss_get_vendor_ie(bss
, WPA_IE_VENDOR_TYPE
);
1123 bss_rsn
= wpa_bss_get_ie(bss
, WLAN_EID_RSN
);
1124 bss_osen
= wpa_bss_get_vendor_ie(bss
, OSEN_IE_VENDOR_TYPE
);
1126 bss_wpa
= bss_rsn
= bss_osen
= NULL
;
1128 if (bss_rsn
&& (ssid
->proto
& WPA_PROTO_RSN
) &&
1129 wpa_parse_wpa_ie(bss_rsn
, 2 + bss_rsn
[1], &ie
) == 0 &&
1130 (ie
.group_cipher
& ssid
->group_cipher
) &&
1131 (ie
.pairwise_cipher
& ssid
->pairwise_cipher
) &&
1132 (ie
.key_mgmt
& ssid
->key_mgmt
)) {
1133 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using IEEE 802.11i/D9.0");
1134 proto
= WPA_PROTO_RSN
;
1135 } else if (bss_wpa
&& (ssid
->proto
& WPA_PROTO_WPA
) &&
1136 wpa_parse_wpa_ie(bss_wpa
, 2 + bss_wpa
[1], &ie
) == 0 &&
1137 (ie
.group_cipher
& ssid
->group_cipher
) &&
1138 (ie
.pairwise_cipher
& ssid
->pairwise_cipher
) &&
1139 (ie
.key_mgmt
& ssid
->key_mgmt
)) {
1140 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using IEEE 802.11i/D3.0");
1141 proto
= WPA_PROTO_WPA
;
1143 } else if (bss_osen
&& (ssid
->proto
& WPA_PROTO_OSEN
)) {
1144 wpa_dbg(wpa_s
, MSG_DEBUG
, "HS 2.0: using OSEN");
1145 /* TODO: parse OSEN element */
1146 os_memset(&ie
, 0, sizeof(ie
));
1147 ie
.group_cipher
= WPA_CIPHER_CCMP
;
1148 ie
.pairwise_cipher
= WPA_CIPHER_CCMP
;
1149 ie
.key_mgmt
= WPA_KEY_MGMT_OSEN
;
1150 proto
= WPA_PROTO_OSEN
;
1151 #endif /* CONFIG_HS20 */
1153 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select WPA/RSN");
1154 wpa_dbg(wpa_s
, MSG_DEBUG
,
1155 "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1156 ssid
->proto
, ssid
->pairwise_cipher
, ssid
->group_cipher
,
1158 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: BSS " MACSTR
" ssid='%s'%s%s%s",
1159 MAC2STR(bss
->bssid
),
1160 wpa_ssid_txt(bss
->ssid
, bss
->ssid_len
),
1161 bss_wpa
? " WPA" : "",
1162 bss_rsn
? " RSN" : "",
1163 bss_osen
? " OSEN" : "");
1165 wpa_hexdump(MSG_DEBUG
, "RSN", bss_rsn
, 2 + bss_rsn
[1]);
1166 if (wpa_parse_wpa_ie(bss_rsn
, 2 + bss_rsn
[1], &ie
)) {
1167 wpa_dbg(wpa_s
, MSG_DEBUG
,
1168 "Could not parse RSN element");
1170 wpa_dbg(wpa_s
, MSG_DEBUG
,
1171 "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1172 ie
.pairwise_cipher
, ie
.group_cipher
,
1177 wpa_hexdump(MSG_DEBUG
, "WPA", bss_wpa
, 2 + bss_wpa
[1]);
1178 if (wpa_parse_wpa_ie(bss_wpa
, 2 + bss_wpa
[1], &ie
)) {
1179 wpa_dbg(wpa_s
, MSG_DEBUG
,
1180 "Could not parse WPA element");
1182 wpa_dbg(wpa_s
, MSG_DEBUG
,
1183 "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1184 ie
.pairwise_cipher
, ie
.group_cipher
,
1190 if (ssid
->proto
& WPA_PROTO_OSEN
)
1191 proto
= WPA_PROTO_OSEN
;
1192 else if (ssid
->proto
& WPA_PROTO_RSN
)
1193 proto
= WPA_PROTO_RSN
;
1195 proto
= WPA_PROTO_WPA
;
1196 if (wpa_supplicant_suites_from_ai(wpa_s
, ssid
, &ie
) < 0) {
1197 os_memset(&ie
, 0, sizeof(ie
));
1198 ie
.group_cipher
= ssid
->group_cipher
;
1199 ie
.pairwise_cipher
= ssid
->pairwise_cipher
;
1200 ie
.key_mgmt
= ssid
->key_mgmt
;
1201 #ifdef CONFIG_IEEE80211W
1202 ie
.mgmt_group_cipher
=
1203 ssid
->ieee80211w
!= NO_MGMT_FRAME_PROTECTION
?
1204 WPA_CIPHER_AES_128_CMAC
: 0;
1205 #endif /* CONFIG_IEEE80211W */
1206 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Set cipher suites "
1207 "based on configuration");
1212 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected cipher suites: group %d "
1213 "pairwise %d key_mgmt %d proto %d",
1214 ie
.group_cipher
, ie
.pairwise_cipher
, ie
.key_mgmt
, proto
);
1215 #ifdef CONFIG_IEEE80211W
1216 if (ssid
->ieee80211w
) {
1217 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected mgmt group cipher %d",
1218 ie
.mgmt_group_cipher
);
1220 #endif /* CONFIG_IEEE80211W */
1222 wpa_s
->wpa_proto
= proto
;
1223 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PROTO
, proto
);
1224 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_RSN_ENABLED
,
1225 !!(ssid
->proto
& (WPA_PROTO_RSN
| WPA_PROTO_OSEN
)));
1227 if (bss
|| !wpa_s
->ap_ies_from_associnfo
) {
1228 if (wpa_sm_set_ap_wpa_ie(wpa_s
->wpa
, bss_wpa
,
1229 bss_wpa
? 2 + bss_wpa
[1] : 0) ||
1230 wpa_sm_set_ap_rsn_ie(wpa_s
->wpa
, bss_rsn
,
1231 bss_rsn
? 2 + bss_rsn
[1] : 0))
1235 #ifdef CONFIG_NO_WPA
1236 wpa_s
->group_cipher
= WPA_CIPHER_NONE
;
1237 wpa_s
->pairwise_cipher
= WPA_CIPHER_NONE
;
1238 #else /* CONFIG_NO_WPA */
1239 sel
= ie
.group_cipher
& ssid
->group_cipher
;
1240 wpa_s
->group_cipher
= wpa_pick_group_cipher(sel
);
1241 if (wpa_s
->group_cipher
< 0) {
1242 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select group "
1246 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK %s",
1247 wpa_cipher_txt(wpa_s
->group_cipher
));
1249 sel
= ie
.pairwise_cipher
& ssid
->pairwise_cipher
;
1250 wpa_s
->pairwise_cipher
= wpa_pick_pairwise_cipher(sel
, 1);
1251 if (wpa_s
->pairwise_cipher
< 0) {
1252 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select pairwise "
1256 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using PTK %s",
1257 wpa_cipher_txt(wpa_s
->pairwise_cipher
));
1258 #endif /* CONFIG_NO_WPA */
1260 sel
= ie
.key_mgmt
& ssid
->key_mgmt
;
1262 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SAE
))
1263 sel
&= ~(WPA_KEY_MGMT_SAE
| WPA_KEY_MGMT_FT_SAE
);
1264 #endif /* CONFIG_SAE */
1266 #ifdef CONFIG_SUITEB192
1267 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SUITE_B_192
) {
1268 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SUITE_B_192
;
1269 wpa_dbg(wpa_s
, MSG_DEBUG
,
1270 "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)");
1271 #endif /* CONFIG_SUITEB192 */
1272 #ifdef CONFIG_SUITEB
1273 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SUITE_B
) {
1274 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SUITE_B
;
1275 wpa_dbg(wpa_s
, MSG_DEBUG
,
1276 "WPA: using KEY_MGMT 802.1X with Suite B");
1277 #endif /* CONFIG_SUITEB */
1279 #ifdef CONFIG_IEEE80211R
1280 } else if (sel
& WPA_KEY_MGMT_FT_FILS_SHA384
) {
1281 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_FILS_SHA384
;
1282 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT-FILS-SHA384");
1283 } else if (sel
& WPA_KEY_MGMT_FT_FILS_SHA256
) {
1284 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_FILS_SHA256
;
1285 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT-FILS-SHA256");
1286 #endif /* CONFIG_IEEE80211R */
1287 } else if (sel
& WPA_KEY_MGMT_FILS_SHA384
) {
1288 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FILS_SHA384
;
1289 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FILS-SHA384");
1290 } else if (sel
& WPA_KEY_MGMT_FILS_SHA256
) {
1291 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FILS_SHA256
;
1292 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FILS-SHA256");
1293 #endif /* CONFIG_FILS */
1294 #ifdef CONFIG_IEEE80211R
1295 } else if (sel
& WPA_KEY_MGMT_FT_IEEE8021X
) {
1296 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_IEEE8021X
;
1297 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT/802.1X");
1298 } else if (sel
& WPA_KEY_MGMT_FT_PSK
) {
1299 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_PSK
;
1300 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT/PSK");
1301 #endif /* CONFIG_IEEE80211R */
1303 } else if (sel
& WPA_KEY_MGMT_SAE
) {
1304 wpa_s
->key_mgmt
= WPA_KEY_MGMT_SAE
;
1305 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using KEY_MGMT SAE");
1306 } else if (sel
& WPA_KEY_MGMT_FT_SAE
) {
1307 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_SAE
;
1308 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using KEY_MGMT FT/SAE");
1309 #endif /* CONFIG_SAE */
1310 #ifdef CONFIG_IEEE80211W
1311 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SHA256
) {
1312 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SHA256
;
1313 wpa_dbg(wpa_s
, MSG_DEBUG
,
1314 "WPA: using KEY_MGMT 802.1X with SHA256");
1315 } else if (sel
& WPA_KEY_MGMT_PSK_SHA256
) {
1316 wpa_s
->key_mgmt
= WPA_KEY_MGMT_PSK_SHA256
;
1317 wpa_dbg(wpa_s
, MSG_DEBUG
,
1318 "WPA: using KEY_MGMT PSK with SHA256");
1319 #endif /* CONFIG_IEEE80211W */
1320 } else if (sel
& WPA_KEY_MGMT_IEEE8021X
) {
1321 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X
;
1322 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT 802.1X");
1323 } else if (sel
& WPA_KEY_MGMT_PSK
) {
1324 wpa_s
->key_mgmt
= WPA_KEY_MGMT_PSK
;
1325 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT WPA-PSK");
1326 } else if (sel
& WPA_KEY_MGMT_WPA_NONE
) {
1327 wpa_s
->key_mgmt
= WPA_KEY_MGMT_WPA_NONE
;
1328 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT WPA-NONE");
1330 } else if (sel
& WPA_KEY_MGMT_OSEN
) {
1331 wpa_s
->key_mgmt
= WPA_KEY_MGMT_OSEN
;
1332 wpa_dbg(wpa_s
, MSG_DEBUG
, "HS 2.0: using KEY_MGMT OSEN");
1333 #endif /* CONFIG_HS20 */
1335 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select "
1336 "authenticated key management type");
1340 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_KEY_MGMT
, wpa_s
->key_mgmt
);
1341 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PAIRWISE
,
1342 wpa_s
->pairwise_cipher
);
1343 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_GROUP
, wpa_s
->group_cipher
);
1345 #ifdef CONFIG_IEEE80211W
1346 sel
= ie
.mgmt_group_cipher
;
1347 if (wpas_get_ssid_pmf(wpa_s
, ssid
) == NO_MGMT_FRAME_PROTECTION
||
1348 !(ie
.capabilities
& WPA_CAPABILITY_MFPC
))
1350 if (sel
& WPA_CIPHER_AES_128_CMAC
) {
1351 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_AES_128_CMAC
;
1352 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1354 } else if (sel
& WPA_CIPHER_BIP_GMAC_128
) {
1355 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_BIP_GMAC_128
;
1356 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1358 } else if (sel
& WPA_CIPHER_BIP_GMAC_256
) {
1359 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_BIP_GMAC_256
;
1360 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1362 } else if (sel
& WPA_CIPHER_BIP_CMAC_256
) {
1363 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_BIP_CMAC_256
;
1364 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1367 wpa_s
->mgmt_group_cipher
= 0;
1368 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: not using MGMT group cipher");
1370 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MGMT_GROUP
,
1371 wpa_s
->mgmt_group_cipher
);
1372 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MFP
,
1373 wpas_get_ssid_pmf(wpa_s
, ssid
));
1374 #endif /* CONFIG_IEEE80211W */
1376 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s
->wpa
, wpa_ie
, wpa_ie_len
)) {
1377 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to generate WPA IE");
1381 if (wpa_key_mgmt_wpa_psk(ssid
->key_mgmt
)) {
1384 if (ssid
->psk_set
) {
1385 wpa_sm_set_pmk(wpa_s
->wpa
, ssid
->psk
, PMK_LEN
, NULL
,
1389 #ifndef CONFIG_NO_PBKDF2
1390 if (bss
&& ssid
->bssid_set
&& ssid
->ssid_len
== 0 &&
1393 pbkdf2_sha1(ssid
->passphrase
, bss
->ssid
, bss
->ssid_len
,
1394 4096, psk
, PMK_LEN
);
1395 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from passphrase)",
1397 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
, NULL
, NULL
);
1399 os_memset(psk
, 0, sizeof(psk
));
1401 #endif /* CONFIG_NO_PBKDF2 */
1402 #ifdef CONFIG_EXT_PASSWORD
1403 if (ssid
->ext_psk
) {
1404 struct wpabuf
*pw
= ext_password_get(wpa_s
->ext_pw
,
1406 char pw_str
[64 + 1];
1410 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: No PSK "
1411 "found from external storage");
1415 if (wpabuf_len(pw
) < 8 || wpabuf_len(pw
) > 64) {
1416 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: Unexpected "
1417 "PSK length %d in external storage",
1418 (int) wpabuf_len(pw
));
1419 ext_password_free(pw
);
1423 os_memcpy(pw_str
, wpabuf_head(pw
), wpabuf_len(pw
));
1424 pw_str
[wpabuf_len(pw
)] = '\0';
1426 #ifndef CONFIG_NO_PBKDF2
1427 if (wpabuf_len(pw
) >= 8 && wpabuf_len(pw
) < 64 && bss
)
1429 pbkdf2_sha1(pw_str
, bss
->ssid
, bss
->ssid_len
,
1430 4096, psk
, PMK_LEN
);
1431 os_memset(pw_str
, 0, sizeof(pw_str
));
1432 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from "
1433 "external passphrase)",
1435 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
, NULL
,
1438 os_memset(psk
, 0, sizeof(psk
));
1440 #endif /* CONFIG_NO_PBKDF2 */
1441 if (wpabuf_len(pw
) == 2 * PMK_LEN
) {
1442 if (hexstr2bin(pw_str
, psk
, PMK_LEN
) < 0) {
1443 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: "
1444 "Invalid PSK hex string");
1445 os_memset(pw_str
, 0, sizeof(pw_str
));
1446 ext_password_free(pw
);
1449 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
, NULL
,
1452 os_memset(psk
, 0, sizeof(psk
));
1454 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: No suitable "
1456 os_memset(pw_str
, 0, sizeof(pw_str
));
1457 ext_password_free(pw
);
1461 os_memset(pw_str
, 0, sizeof(pw_str
));
1462 ext_password_free(pw
);
1464 #endif /* CONFIG_EXT_PASSWORD */
1467 wpa_msg(wpa_s
, MSG_INFO
,
1468 "No PSK available for association");
1472 wpa_sm_set_pmk_from_pmksa(wpa_s
->wpa
);
1478 static void wpas_ext_capab_byte(struct wpa_supplicant
*wpa_s
, u8
*pos
, int idx
)
1483 case 0: /* Bits 0-7 */
1485 case 1: /* Bits 8-15 */
1487 case 2: /* Bits 16-23 */
1489 *pos
|= 0x02; /* Bit 17 - WNM-Sleep Mode */
1490 *pos
|= 0x08; /* Bit 19 - BSS Transition */
1491 #endif /* CONFIG_WNM */
1493 case 3: /* Bits 24-31 */
1495 *pos
|= 0x02; /* Bit 25 - SSID List */
1496 #endif /* CONFIG_WNM */
1497 #ifdef CONFIG_INTERWORKING
1498 if (wpa_s
->conf
->interworking
)
1499 *pos
|= 0x80; /* Bit 31 - Interworking */
1500 #endif /* CONFIG_INTERWORKING */
1502 case 4: /* Bits 32-39 */
1503 #ifdef CONFIG_INTERWORKING
1504 if (wpa_s
->drv_flags
/ WPA_DRIVER_FLAGS_QOS_MAPPING
)
1505 *pos
|= 0x01; /* Bit 32 - QoS Map */
1506 #endif /* CONFIG_INTERWORKING */
1508 case 5: /* Bits 40-47 */
1510 if (wpa_s
->conf
->hs20
)
1511 *pos
|= 0x40; /* Bit 46 - WNM-Notification */
1512 #endif /* CONFIG_HS20 */
1514 *pos
|= 0x40; /* Bit 46 - WNM-Notification */
1515 #endif /* CONFIG_MBO */
1517 case 6: /* Bits 48-55 */
1519 case 7: /* Bits 56-63 */
1521 case 8: /* Bits 64-71 */
1522 if (wpa_s
->conf
->ftm_responder
)
1523 *pos
|= 0x40; /* Bit 70 - FTM responder */
1524 if (wpa_s
->conf
->ftm_initiator
)
1525 *pos
|= 0x80; /* Bit 71 - FTM initiator */
1527 case 9: /* Bits 72-79 */
1530 #endif /* CONFIG_FILS */
1536 int wpas_build_ext_capab(struct wpa_supplicant
*wpa_s
, u8
*buf
, size_t buflen
)
1541 if (len
< wpa_s
->extended_capa_len
)
1542 len
= wpa_s
->extended_capa_len
;
1543 if (buflen
< (size_t) len
+ 2) {
1544 wpa_printf(MSG_INFO
,
1545 "Not enough room for building extended capabilities element");
1549 *pos
++ = WLAN_EID_EXT_CAPAB
;
1551 for (i
= 0; i
< len
; i
++, pos
++) {
1552 wpas_ext_capab_byte(wpa_s
, pos
, i
);
1554 if (i
< wpa_s
->extended_capa_len
) {
1555 *pos
&= ~wpa_s
->extended_capa_mask
[i
];
1556 *pos
|= wpa_s
->extended_capa
[i
];
1560 while (len
> 0 && buf
[1 + len
] == 0) {
1571 static int wpas_valid_bss(struct wpa_supplicant
*wpa_s
,
1572 struct wpa_bss
*test_bss
)
1574 struct wpa_bss
*bss
;
1576 dl_list_for_each(bss
, &wpa_s
->bss
, struct wpa_bss
, list
) {
1577 if (bss
== test_bss
)
1585 static int wpas_valid_ssid(struct wpa_supplicant
*wpa_s
,
1586 struct wpa_ssid
*test_ssid
)
1588 struct wpa_ssid
*ssid
;
1590 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
) {
1591 if (ssid
== test_ssid
)
1599 int wpas_valid_bss_ssid(struct wpa_supplicant
*wpa_s
, struct wpa_bss
*test_bss
,
1600 struct wpa_ssid
*test_ssid
)
1602 if (test_bss
&& !wpas_valid_bss(wpa_s
, test_bss
))
1605 return test_ssid
== NULL
|| wpas_valid_ssid(wpa_s
, test_ssid
);
1609 void wpas_connect_work_free(struct wpa_connect_work
*cwork
)
1617 void wpas_connect_work_done(struct wpa_supplicant
*wpa_s
)
1619 struct wpa_connect_work
*cwork
;
1620 struct wpa_radio_work
*work
= wpa_s
->connect_work
;
1625 wpa_s
->connect_work
= NULL
;
1628 wpas_connect_work_free(cwork
);
1629 radio_work_done(work
);
1633 int wpas_update_random_addr(struct wpa_supplicant
*wpa_s
, int style
)
1635 struct os_reltime now
;
1638 os_get_reltime(&now
);
1639 if (wpa_s
->last_mac_addr_style
== style
&&
1640 wpa_s
->last_mac_addr_change
.sec
!= 0 &&
1641 !os_reltime_expired(&now
, &wpa_s
->last_mac_addr_change
,
1642 wpa_s
->conf
->rand_addr_lifetime
)) {
1643 wpa_msg(wpa_s
, MSG_DEBUG
,
1644 "Previously selected random MAC address has not yet expired");
1650 if (random_mac_addr(addr
) < 0)
1654 os_memcpy(addr
, wpa_s
->perm_addr
, ETH_ALEN
);
1655 if (random_mac_addr_keep_oui(addr
) < 0)
1662 if (wpa_drv_set_mac_addr(wpa_s
, addr
) < 0) {
1663 wpa_msg(wpa_s
, MSG_INFO
,
1664 "Failed to set random MAC address");
1668 os_get_reltime(&wpa_s
->last_mac_addr_change
);
1669 wpa_s
->mac_addr_changed
= 1;
1670 wpa_s
->last_mac_addr_style
= style
;
1672 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0) {
1673 wpa_msg(wpa_s
, MSG_INFO
,
1674 "Could not update MAC address information");
1678 wpa_msg(wpa_s
, MSG_DEBUG
, "Using random MAC address " MACSTR
,
1685 int wpas_update_random_addr_disassoc(struct wpa_supplicant
*wpa_s
)
1687 if (wpa_s
->wpa_state
>= WPA_AUTHENTICATING
||
1688 !wpa_s
->conf
->preassoc_mac_addr
)
1691 return wpas_update_random_addr(wpa_s
, wpa_s
->conf
->preassoc_mac_addr
);
1695 static void wpas_start_assoc_cb(struct wpa_radio_work
*work
, int deinit
);
1698 * wpa_supplicant_associate - Request association
1699 * @wpa_s: Pointer to wpa_supplicant data
1700 * @bss: Scan results for the selected BSS, or %NULL if not available
1701 * @ssid: Configuration data for the selected network
1703 * This function is used to request %wpa_supplicant to associate with a BSS.
1705 void wpa_supplicant_associate(struct wpa_supplicant
*wpa_s
,
1706 struct wpa_bss
*bss
, struct wpa_ssid
*ssid
)
1708 struct wpa_connect_work
*cwork
;
1711 wpa_s
->own_disconnect_req
= 0;
1714 * If we are starting a new connection, any previously pending EAPOL
1715 * RX cannot be valid anymore.
1717 wpabuf_free(wpa_s
->pending_eapol_rx
);
1718 wpa_s
->pending_eapol_rx
= NULL
;
1720 if (ssid
->mac_addr
== -1)
1721 rand_style
= wpa_s
->conf
->mac_addr
;
1723 rand_style
= ssid
->mac_addr
;
1725 wmm_ac_clear_saved_tspecs(wpa_s
);
1726 wpa_s
->reassoc_same_bss
= 0;
1727 wpa_s
->reassoc_same_ess
= 0;
1729 if (wpa_s
->last_ssid
== ssid
) {
1730 wpa_dbg(wpa_s
, MSG_DEBUG
, "Re-association to the same ESS");
1731 wpa_s
->reassoc_same_ess
= 1;
1732 if (wpa_s
->current_bss
&& wpa_s
->current_bss
== bss
) {
1733 wmm_ac_save_tspecs(wpa_s
);
1734 wpa_s
->reassoc_same_bss
= 1;
1738 if (rand_style
> 0 && !wpa_s
->reassoc_same_ess
) {
1739 if (wpas_update_random_addr(wpa_s
, rand_style
) < 0)
1741 wpa_sm_pmksa_cache_flush(wpa_s
->wpa
, ssid
);
1742 } else if (rand_style
== 0 && wpa_s
->mac_addr_changed
) {
1743 if (wpa_drv_set_mac_addr(wpa_s
, NULL
) < 0) {
1744 wpa_msg(wpa_s
, MSG_INFO
,
1745 "Could not restore permanent MAC address");
1748 wpa_s
->mac_addr_changed
= 0;
1749 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0) {
1750 wpa_msg(wpa_s
, MSG_INFO
,
1751 "Could not update MAC address information");
1754 wpa_msg(wpa_s
, MSG_DEBUG
, "Using permanent MAC address");
1756 wpa_s
->last_ssid
= ssid
;
1758 #ifdef CONFIG_IBSS_RSN
1759 ibss_rsn_deinit(wpa_s
->ibss_rsn
);
1760 wpa_s
->ibss_rsn
= NULL
;
1761 #else /* CONFIG_IBSS_RSN */
1762 if (ssid
->mode
== WPAS_MODE_IBSS
&&
1763 !(ssid
->key_mgmt
& (WPA_KEY_MGMT_NONE
| WPA_KEY_MGMT_WPA_NONE
))) {
1764 wpa_msg(wpa_s
, MSG_INFO
,
1765 "IBSS RSN not supported in the build");
1768 #endif /* CONFIG_IBSS_RSN */
1770 if (ssid
->mode
== WPAS_MODE_AP
|| ssid
->mode
== WPAS_MODE_P2P_GO
||
1771 ssid
->mode
== WPAS_MODE_P2P_GROUP_FORMATION
) {
1773 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_AP
)) {
1774 wpa_msg(wpa_s
, MSG_INFO
, "Driver does not support AP "
1778 if (wpa_supplicant_create_ap(wpa_s
, ssid
) < 0) {
1779 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
1780 if (ssid
->mode
== WPAS_MODE_P2P_GROUP_FORMATION
)
1781 wpas_p2p_ap_setup_failed(wpa_s
);
1784 wpa_s
->current_bss
= bss
;
1785 #else /* CONFIG_AP */
1786 wpa_msg(wpa_s
, MSG_ERROR
, "AP mode support not included in "
1788 #endif /* CONFIG_AP */
1792 if (ssid
->mode
== WPAS_MODE_MESH
) {
1794 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_MESH
)) {
1795 wpa_msg(wpa_s
, MSG_INFO
,
1796 "Driver does not support mesh mode");
1800 ssid
->frequency
= bss
->freq
;
1801 if (wpa_supplicant_join_mesh(wpa_s
, ssid
) < 0) {
1802 wpa_msg(wpa_s
, MSG_ERROR
, "Could not join mesh");
1805 wpa_s
->current_bss
= bss
;
1806 wpa_msg(wpa_s
, MSG_INFO
, MESH_GROUP_STARTED
"ssid=\"%s\" id=%d",
1807 wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
),
1809 #else /* CONFIG_MESH */
1810 wpa_msg(wpa_s
, MSG_ERROR
,
1811 "mesh mode support not included in the build");
1812 #endif /* CONFIG_MESH */
1818 wpa_tdls_ap_ies(wpa_s
->wpa
, (const u8
*) (bss
+ 1),
1820 #endif /* CONFIG_TDLS */
1822 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SME
) &&
1823 ssid
->mode
== IEEE80211_MODE_INFRA
) {
1824 sme_authenticate(wpa_s
, bss
, ssid
);
1828 if (wpa_s
->connect_work
) {
1829 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reject wpa_supplicant_associate() call since connect_work exist");
1833 if (radio_work_pending(wpa_s
, "connect")) {
1834 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reject wpa_supplicant_associate() call since pending work exist");
1839 if (ssid
->mode
== WPAS_MODE_IBSS
|| ssid
->mode
== WPAS_MODE_MESH
) {
1840 /* Clear possibly set auth_alg, if any, from last attempt. */
1841 wpa_s
->sme
.auth_alg
= WPA_AUTH_ALG_OPEN
;
1843 #endif /* CONFIG_SME */
1845 wpas_abort_ongoing_scan(wpa_s
);
1847 cwork
= os_zalloc(sizeof(*cwork
));
1854 if (radio_add_work(wpa_s
, bss
? bss
->freq
: 0, "connect", 1,
1855 wpas_start_assoc_cb
, cwork
) < 0) {
1861 static int bss_is_ibss(struct wpa_bss
*bss
)
1863 return (bss
->caps
& (IEEE80211_CAP_ESS
| IEEE80211_CAP_IBSS
)) ==
1868 static int drv_supports_vht(struct wpa_supplicant
*wpa_s
,
1869 const struct wpa_ssid
*ssid
)
1871 enum hostapd_hw_mode hw_mode
;
1872 struct hostapd_hw_modes
*mode
= NULL
;
1876 #ifdef CONFIG_HT_OVERRIDES
1877 if (ssid
->disable_ht
)
1879 #endif /* CONFIG_HT_OVERRIDES */
1881 hw_mode
= ieee80211_freq_to_chan(ssid
->frequency
, &channel
);
1882 if (hw_mode
== NUM_HOSTAPD_MODES
)
1884 for (i
= 0; wpa_s
->hw
.modes
&& i
< wpa_s
->hw
.num_modes
; i
++) {
1885 if (wpa_s
->hw
.modes
[i
].mode
== hw_mode
) {
1886 mode
= &wpa_s
->hw
.modes
[i
];
1894 return mode
->vht_capab
!= 0;
1898 void ibss_mesh_setup_freq(struct wpa_supplicant
*wpa_s
,
1899 const struct wpa_ssid
*ssid
,
1900 struct hostapd_freq_params
*freq
)
1902 enum hostapd_hw_mode hw_mode
;
1903 struct hostapd_hw_modes
*mode
= NULL
;
1904 int ht40plus
[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1906 int vht80
[] = { 36, 52, 100, 116, 132, 149 };
1907 struct hostapd_channel_data
*pri_chan
= NULL
, *sec_chan
= NULL
;
1909 int i
, chan_idx
, ht40
= -1, res
, obss_scan
= 1;
1911 struct hostapd_freq_params vht_freq
;
1912 int chwidth
, seg0
, seg1
;
1915 freq
->freq
= ssid
->frequency
;
1917 for (j
= 0; j
< wpa_s
->last_scan_res_used
; j
++) {
1918 struct wpa_bss
*bss
= wpa_s
->last_scan_res
[j
];
1920 if (ssid
->mode
!= WPAS_MODE_IBSS
)
1923 /* Don't adjust control freq in case of fixed_freq */
1924 if (ssid
->fixed_freq
)
1927 if (!bss_is_ibss(bss
))
1930 if (ssid
->ssid_len
== bss
->ssid_len
&&
1931 os_memcmp(ssid
->ssid
, bss
->ssid
, bss
->ssid_len
) == 0) {
1932 wpa_printf(MSG_DEBUG
,
1933 "IBSS already found in scan results, adjust control freq: %d",
1935 freq
->freq
= bss
->freq
;
1941 /* For IBSS check HT_IBSS flag */
1942 if (ssid
->mode
== WPAS_MODE_IBSS
&&
1943 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_HT_IBSS
))
1946 if (wpa_s
->group_cipher
== WPA_CIPHER_WEP40
||
1947 wpa_s
->group_cipher
== WPA_CIPHER_WEP104
||
1948 wpa_s
->pairwise_cipher
== WPA_CIPHER_TKIP
) {
1949 wpa_printf(MSG_DEBUG
,
1950 "IBSS: WEP/TKIP detected, do not try to enable HT");
1954 hw_mode
= ieee80211_freq_to_chan(freq
->freq
, &channel
);
1955 for (i
= 0; wpa_s
->hw
.modes
&& i
< wpa_s
->hw
.num_modes
; i
++) {
1956 if (wpa_s
->hw
.modes
[i
].mode
== hw_mode
) {
1957 mode
= &wpa_s
->hw
.modes
[i
];
1965 #ifdef CONFIG_HT_OVERRIDES
1966 if (ssid
->disable_ht
) {
1967 freq
->ht_enabled
= 0;
1970 #endif /* CONFIG_HT_OVERRIDES */
1972 freq
->ht_enabled
= ht_supported(mode
);
1973 if (!freq
->ht_enabled
)
1976 /* Setup higher BW only for 5 GHz */
1977 if (mode
->mode
!= HOSTAPD_MODE_IEEE80211A
)
1980 for (chan_idx
= 0; chan_idx
< mode
->num_channels
; chan_idx
++) {
1981 pri_chan
= &mode
->channels
[chan_idx
];
1982 if (pri_chan
->chan
== channel
)
1989 /* Check primary channel flags */
1990 if (pri_chan
->flag
& (HOSTAPD_CHAN_DISABLED
| HOSTAPD_CHAN_NO_IR
))
1993 #ifdef CONFIG_HT_OVERRIDES
1994 if (ssid
->disable_ht40
)
1996 #endif /* CONFIG_HT_OVERRIDES */
1998 /* Check/setup HT40+/HT40- */
1999 for (j
= 0; j
< ARRAY_SIZE(ht40plus
); j
++) {
2000 if (ht40plus
[j
] == channel
) {
2006 /* Find secondary channel */
2007 for (i
= 0; i
< mode
->num_channels
; i
++) {
2008 sec_chan
= &mode
->channels
[i
];
2009 if (sec_chan
->chan
== channel
+ ht40
* 4)
2016 /* Check secondary channel flags */
2017 if (sec_chan
->flag
& (HOSTAPD_CHAN_DISABLED
| HOSTAPD_CHAN_NO_IR
))
2020 freq
->channel
= pri_chan
->chan
;
2023 if (!(pri_chan
->flag
& HOSTAPD_CHAN_HT40MINUS
))
2026 if (!(pri_chan
->flag
& HOSTAPD_CHAN_HT40PLUS
))
2029 freq
->sec_channel_offset
= ht40
;
2032 struct wpa_scan_results
*scan_res
;
2034 scan_res
= wpa_supplicant_get_scan_results(wpa_s
, NULL
, 0);
2035 if (scan_res
== NULL
) {
2037 freq
->sec_channel_offset
= 0;
2041 res
= check_40mhz_5g(mode
, scan_res
, pri_chan
->chan
,
2046 freq
->sec_channel_offset
= 0;
2049 /* Configuration allowed */
2052 /* Switch pri/sec channels */
2053 freq
->freq
= hw_get_freq(mode
, sec_chan
->chan
);
2054 freq
->sec_channel_offset
= -freq
->sec_channel_offset
;
2055 freq
->channel
= sec_chan
->chan
;
2058 freq
->sec_channel_offset
= 0;
2062 wpa_scan_results_free(scan_res
);
2065 wpa_printf(MSG_DEBUG
,
2066 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
2067 freq
->channel
, freq
->sec_channel_offset
);
2069 if (!drv_supports_vht(wpa_s
, ssid
))
2072 /* For IBSS check VHT_IBSS flag */
2073 if (ssid
->mode
== WPAS_MODE_IBSS
&&
2074 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_VHT_IBSS
))
2079 #ifdef CONFIG_VHT_OVERRIDES
2080 if (ssid
->disable_vht
) {
2081 freq
->vht_enabled
= 0;
2084 #endif /* CONFIG_VHT_OVERRIDES */
2086 vht_freq
.vht_enabled
= vht_supported(mode
);
2087 if (!vht_freq
.vht_enabled
)
2090 /* setup center_freq1, bandwidth */
2091 for (j
= 0; j
< ARRAY_SIZE(vht80
); j
++) {
2092 if (freq
->channel
>= vht80
[j
] &&
2093 freq
->channel
< vht80
[j
] + 16)
2097 if (j
== ARRAY_SIZE(vht80
))
2100 for (i
= vht80
[j
]; i
< vht80
[j
] + 16; i
+= 4) {
2101 struct hostapd_channel_data
*chan
;
2103 chan
= hw_get_channel_chan(mode
, i
, NULL
);
2107 /* Back to HT configuration if channel not usable */
2108 if (chan
->flag
& (HOSTAPD_CHAN_DISABLED
| HOSTAPD_CHAN_NO_IR
))
2112 chwidth
= VHT_CHANWIDTH_80MHZ
;
2113 seg0
= vht80
[j
] + 6;
2116 if (ssid
->max_oper_chwidth
== VHT_CHANWIDTH_80P80MHZ
) {
2117 /* setup center_freq2, bandwidth */
2118 for (k
= 0; k
< ARRAY_SIZE(vht80
); k
++) {
2119 /* Only accept 80 MHz segments separated by a gap */
2120 if (j
== k
|| abs(vht80
[j
] - vht80
[k
]) == 16)
2122 for (i
= vht80
[k
]; i
< vht80
[k
] + 16; i
+= 4) {
2123 struct hostapd_channel_data
*chan
;
2125 chan
= hw_get_channel_chan(mode
, i
, NULL
);
2129 if (chan
->flag
& (HOSTAPD_CHAN_DISABLED
|
2130 HOSTAPD_CHAN_NO_IR
|
2131 HOSTAPD_CHAN_RADAR
))
2134 /* Found a suitable second segment for 80+80 */
2135 chwidth
= VHT_CHANWIDTH_80P80MHZ
;
2137 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ
;
2138 seg1
= vht80
[k
] + 6;
2141 if (chwidth
== VHT_CHANWIDTH_80P80MHZ
)
2144 } else if (ssid
->max_oper_chwidth
== VHT_CHANWIDTH_160MHZ
) {
2145 if (freq
->freq
== 5180) {
2146 chwidth
= VHT_CHANWIDTH_160MHZ
;
2147 vht_caps
|= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ
;
2149 } else if (freq
->freq
== 5520) {
2150 chwidth
= VHT_CHANWIDTH_160MHZ
;
2151 vht_caps
|= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ
;
2156 if (hostapd_set_freq_params(&vht_freq
, mode
->mode
, freq
->freq
,
2157 freq
->channel
, freq
->ht_enabled
,
2158 vht_freq
.vht_enabled
,
2159 freq
->sec_channel_offset
,
2160 chwidth
, seg0
, seg1
, vht_caps
) != 0)
2165 wpa_printf(MSG_DEBUG
, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d",
2166 freq
->center_freq1
, freq
->center_freq2
, freq
->bandwidth
);
2170 static void wpas_start_assoc_cb(struct wpa_radio_work
*work
, int deinit
)
2172 struct wpa_connect_work
*cwork
= work
->ctx
;
2173 struct wpa_bss
*bss
= cwork
->bss
;
2174 struct wpa_ssid
*ssid
= cwork
->ssid
;
2175 struct wpa_supplicant
*wpa_s
= work
->wpa_s
;
2178 int use_crypt
, ret
, i
, bssid_changed
;
2179 int algs
= WPA_AUTH_ALG_OPEN
;
2180 unsigned int cipher_pairwise
, cipher_group
;
2181 struct wpa_driver_associate_params params
;
2182 int wep_keys_set
= 0;
2183 int assoc_failed
= 0;
2184 struct wpa_ssid
*old_ssid
;
2185 u8 prev_bssid
[ETH_ALEN
];
2186 #ifdef CONFIG_HT_OVERRIDES
2187 struct ieee80211_ht_capabilities htcaps
;
2188 struct ieee80211_ht_capabilities htcaps_mask
;
2189 #endif /* CONFIG_HT_OVERRIDES */
2190 #ifdef CONFIG_VHT_OVERRIDES
2191 struct ieee80211_vht_capabilities vhtcaps
;
2192 struct ieee80211_vht_capabilities vhtcaps_mask
;
2193 #endif /* CONFIG_VHT_OVERRIDES */
2196 if (work
->started
) {
2197 wpa_s
->connect_work
= NULL
;
2199 /* cancel possible auth. timeout */
2200 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
,
2203 wpas_connect_work_free(cwork
);
2207 wpa_s
->connect_work
= work
;
2209 if (cwork
->bss_removed
|| !wpas_valid_bss_ssid(wpa_s
, bss
, ssid
) ||
2210 wpas_network_disabled(wpa_s
, ssid
)) {
2211 wpa_dbg(wpa_s
, MSG_DEBUG
, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2212 wpas_connect_work_done(wpa_s
);
2216 os_memcpy(prev_bssid
, wpa_s
->bssid
, ETH_ALEN
);
2217 os_memset(¶ms
, 0, sizeof(params
));
2218 wpa_s
->reassociate
= 0;
2219 wpa_s
->eap_expected_failure
= 0;
2221 (!wpas_driver_bss_selection(wpa_s
) || wpas_wps_searching(wpa_s
))) {
2222 #ifdef CONFIG_IEEE80211R
2223 const u8
*ie
, *md
= NULL
;
2224 #endif /* CONFIG_IEEE80211R */
2225 wpa_msg(wpa_s
, MSG_INFO
, "Trying to associate with " MACSTR
2226 " (SSID='%s' freq=%d MHz)", MAC2STR(bss
->bssid
),
2227 wpa_ssid_txt(bss
->ssid
, bss
->ssid_len
), bss
->freq
);
2228 bssid_changed
= !is_zero_ether_addr(wpa_s
->bssid
);
2229 os_memset(wpa_s
->bssid
, 0, ETH_ALEN
);
2230 os_memcpy(wpa_s
->pending_bssid
, bss
->bssid
, ETH_ALEN
);
2232 wpas_notify_bssid_changed(wpa_s
);
2233 #ifdef CONFIG_IEEE80211R
2234 ie
= wpa_bss_get_ie(bss
, WLAN_EID_MOBILITY_DOMAIN
);
2235 if (ie
&& ie
[1] >= MOBILITY_DOMAIN_ID_LEN
)
2237 wpa_sm_set_ft_params(wpa_s
->wpa
, ie
, ie
? 2 + ie
[1] : 0);
2239 /* Prepare for the next transition */
2240 wpa_ft_prepare_auth_request(wpa_s
->wpa
, ie
);
2242 #endif /* CONFIG_IEEE80211R */
2244 } else if ((ssid
->ssid
== NULL
|| ssid
->ssid_len
== 0) &&
2245 wpa_s
->conf
->ap_scan
== 2 &&
2246 (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)) {
2247 /* Use ap_scan==1 style network selection to find the network
2249 wpas_connect_work_done(wpa_s
);
2250 wpa_s
->scan_req
= MANUAL_SCAN_REQ
;
2251 wpa_s
->reassociate
= 1;
2252 wpa_supplicant_req_scan(wpa_s
, 0, 0);
2254 #endif /* CONFIG_WPS */
2256 wpa_msg(wpa_s
, MSG_INFO
, "Trying to associate with SSID '%s'",
2257 wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
2259 os_memcpy(wpa_s
->pending_bssid
, bss
->bssid
, ETH_ALEN
);
2261 os_memset(wpa_s
->pending_bssid
, 0, ETH_ALEN
);
2264 wpa_supplicant_cancel_sched_scan(wpa_s
);
2266 wpa_supplicant_cancel_scan(wpa_s
);
2268 /* Starting new association, so clear the possibly used WPA IE from the
2269 * previous association. */
2270 wpa_sm_set_assoc_wpa_ie(wpa_s
->wpa
, NULL
, 0);
2272 #ifdef IEEE8021X_EAPOL
2273 if (ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
2275 if (ssid
->non_leap
== 0)
2276 algs
= WPA_AUTH_ALG_LEAP
;
2278 algs
|= WPA_AUTH_ALG_LEAP
;
2281 #endif /* IEEE8021X_EAPOL */
2282 wpa_dbg(wpa_s
, MSG_DEBUG
, "Automatic auth_alg selection: 0x%x", algs
);
2283 if (ssid
->auth_alg
) {
2284 algs
= ssid
->auth_alg
;
2285 wpa_dbg(wpa_s
, MSG_DEBUG
, "Overriding auth_alg selection: "
2289 if (bss
&& (wpa_bss_get_vendor_ie(bss
, WPA_IE_VENDOR_TYPE
) ||
2290 wpa_bss_get_ie(bss
, WLAN_EID_RSN
)) &&
2291 wpa_key_mgmt_wpa(ssid
->key_mgmt
)) {
2292 int try_opportunistic
;
2293 try_opportunistic
= (ssid
->proactive_key_caching
< 0 ?
2295 ssid
->proactive_key_caching
) &&
2296 (ssid
->proto
& WPA_PROTO_RSN
);
2297 if (pmksa_cache_set_current(wpa_s
->wpa
, NULL
, bss
->bssid
,
2298 ssid
, try_opportunistic
) == 0)
2299 eapol_sm_notify_pmkid_attempt(wpa_s
->eapol
);
2300 wpa_ie_len
= sizeof(wpa_ie
);
2301 if (wpa_supplicant_set_suites(wpa_s
, bss
, ssid
,
2302 wpa_ie
, &wpa_ie_len
)) {
2303 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to set WPA "
2304 "key management and encryption suites");
2305 wpas_connect_work_done(wpa_s
);
2308 } else if ((ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
) && bss
&&
2309 wpa_key_mgmt_wpa_ieee8021x(ssid
->key_mgmt
)) {
2311 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
2312 * use non-WPA since the scan results did not indicate that the
2313 * AP is using WPA or WPA2.
2315 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
2317 wpa_s
->wpa_proto
= 0;
2318 } else if (wpa_key_mgmt_wpa_any(ssid
->key_mgmt
)) {
2319 wpa_ie_len
= sizeof(wpa_ie
);
2320 if (wpa_supplicant_set_suites(wpa_s
, NULL
, ssid
,
2321 wpa_ie
, &wpa_ie_len
)) {
2322 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to set WPA "
2323 "key management and encryption suites (no "
2325 wpas_connect_work_done(wpa_s
);
2329 } else if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
) {
2330 struct wpabuf
*wps_ie
;
2331 wps_ie
= wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid
));
2332 if (wps_ie
&& wpabuf_len(wps_ie
) <= sizeof(wpa_ie
)) {
2333 wpa_ie_len
= wpabuf_len(wps_ie
);
2334 os_memcpy(wpa_ie
, wpabuf_head(wps_ie
), wpa_ie_len
);
2337 wpabuf_free(wps_ie
);
2338 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
2339 if (!bss
|| (bss
->caps
& IEEE80211_CAP_PRIVACY
))
2340 params
.wps
= WPS_MODE_PRIVACY
;
2342 params
.wps
= WPS_MODE_OPEN
;
2343 wpa_s
->wpa_proto
= 0;
2344 #endif /* CONFIG_WPS */
2346 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
2348 wpa_s
->wpa_proto
= 0;
2352 if (wpa_s
->global
->p2p
) {
2356 pos
= wpa_ie
+ wpa_ie_len
;
2357 len
= sizeof(wpa_ie
) - wpa_ie_len
;
2358 res
= wpas_p2p_assoc_req_ie(wpa_s
, bss
, pos
, len
,
2364 wpa_s
->cross_connect_disallowed
= 0;
2367 p2p
= wpa_bss_get_vendor_ie_multi(bss
, P2P_IE_VENDOR_TYPE
);
2369 wpa_s
->cross_connect_disallowed
=
2370 p2p_get_cross_connect_disallowed(p2p
);
2372 wpa_dbg(wpa_s
, MSG_DEBUG
, "P2P: WLAN AP %s cross "
2374 wpa_s
->cross_connect_disallowed
?
2375 "disallows" : "allows");
2379 os_memset(wpa_s
->p2p_ip_addr_info
, 0, sizeof(wpa_s
->p2p_ip_addr_info
));
2380 #endif /* CONFIG_P2P */
2383 wpa_ie_len
+= wpas_supp_op_class_ie(wpa_s
, bss
->freq
,
2384 wpa_ie
+ wpa_ie_len
,
2390 * Workaround: Add Extended Capabilities element only if the AP
2391 * included this element in Beacon/Probe Response frames. Some older
2392 * APs seem to have interoperability issues if this element is
2393 * included, so while the standard may require us to include the
2394 * element in all cases, it is justifiable to skip it to avoid
2395 * interoperability issues.
2397 if (ssid
->p2p_group
)
2398 wpa_drv_get_ext_capa(wpa_s
, WPA_IF_P2P_CLIENT
);
2400 wpa_drv_get_ext_capa(wpa_s
, WPA_IF_STATION
);
2402 if (!bss
|| wpa_bss_get_ie(bss
, WLAN_EID_EXT_CAPAB
)) {
2405 ext_capab_len
= wpas_build_ext_capab(wpa_s
, ext_capab
,
2407 if (ext_capab_len
> 0) {
2409 if (wpa_ie_len
> 0 && pos
[0] == WLAN_EID_RSN
)
2411 os_memmove(pos
+ ext_capab_len
, pos
,
2412 wpa_ie_len
- (pos
- wpa_ie
));
2413 wpa_ie_len
+= ext_capab_len
;
2414 os_memcpy(pos
, ext_capab
, ext_capab_len
);
2419 if (is_hs20_network(wpa_s
, ssid
, bss
)) {
2420 struct wpabuf
*hs20
;
2422 hs20
= wpabuf_alloc(20);
2424 int pps_mo_id
= hs20_get_pps_mo_id(wpa_s
, ssid
);
2427 wpas_hs20_add_indication(hs20
, pps_mo_id
);
2428 len
= sizeof(wpa_ie
) - wpa_ie_len
;
2429 if (wpabuf_len(hs20
) <= len
) {
2430 os_memcpy(wpa_ie
+ wpa_ie_len
,
2431 wpabuf_head(hs20
), wpabuf_len(hs20
));
2432 wpa_ie_len
+= wpabuf_len(hs20
);
2436 hs20_configure_frame_filters(wpa_s
);
2439 #endif /* CONFIG_HS20 */
2441 if (wpa_s
->vendor_elem
[VENDOR_ELEM_ASSOC_REQ
]) {
2442 struct wpabuf
*buf
= wpa_s
->vendor_elem
[VENDOR_ELEM_ASSOC_REQ
];
2445 len
= sizeof(wpa_ie
) - wpa_ie_len
;
2446 if (wpabuf_len(buf
) <= len
) {
2447 os_memcpy(wpa_ie
+ wpa_ie_len
,
2448 wpabuf_head(buf
), wpabuf_len(buf
));
2449 wpa_ie_len
+= wpabuf_len(buf
);
2454 if (wpa_s
->fst_ies
) {
2455 int fst_ies_len
= wpabuf_len(wpa_s
->fst_ies
);
2457 if (wpa_ie_len
+ fst_ies_len
<= sizeof(wpa_ie
)) {
2458 os_memcpy(wpa_ie
+ wpa_ie_len
,
2459 wpabuf_head(wpa_s
->fst_ies
), fst_ies_len
);
2460 wpa_ie_len
+= fst_ies_len
;
2463 #endif /* CONFIG_FST */
2466 if (bss
&& wpa_bss_get_vendor_ie(bss
, MBO_IE_VENDOR_TYPE
)) {
2469 len
= wpas_mbo_ie(wpa_s
, wpa_ie
+ wpa_ie_len
,
2470 sizeof(wpa_ie
) - wpa_ie_len
);
2474 #endif /* CONFIG_MBO */
2476 wpa_clear_keys(wpa_s
, bss
? bss
->bssid
: NULL
);
2478 cipher_pairwise
= wpa_s
->pairwise_cipher
;
2479 cipher_group
= wpa_s
->group_cipher
;
2480 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
||
2481 wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
2482 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
)
2484 if (wpa_set_wep_keys(wpa_s
, ssid
)) {
2489 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
)
2492 #ifdef IEEE8021X_EAPOL
2493 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
2494 if ((ssid
->eapol_flags
&
2495 (EAPOL_FLAG_REQUIRE_KEY_UNICAST
|
2496 EAPOL_FLAG_REQUIRE_KEY_BROADCAST
)) == 0 &&
2500 /* Assume that dynamic WEP-104 keys will be used and
2501 * set cipher suites in order for drivers to expect
2503 cipher_pairwise
= cipher_group
= WPA_CIPHER_WEP104
;
2506 #endif /* IEEE8021X_EAPOL */
2508 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
) {
2509 /* Set the key before (and later after) association */
2510 wpa_supplicant_set_wpa_none_key(wpa_s
, ssid
);
2513 wpa_supplicant_set_state(wpa_s
, WPA_ASSOCIATING
);
2515 params
.ssid
= bss
->ssid
;
2516 params
.ssid_len
= bss
->ssid_len
;
2517 if (!wpas_driver_bss_selection(wpa_s
) || ssid
->bssid_set
||
2518 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
) {
2519 wpa_printf(MSG_DEBUG
, "Limit connection to BSSID "
2520 MACSTR
" freq=%u MHz based on scan results "
2521 "(bssid_set=%d wps=%d)",
2522 MAC2STR(bss
->bssid
), bss
->freq
,
2524 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
);
2525 params
.bssid
= bss
->bssid
;
2526 params
.freq
.freq
= bss
->freq
;
2528 params
.bssid_hint
= bss
->bssid
;
2529 params
.freq_hint
= bss
->freq
;
2530 params
.pbss
= bss_is_pbss(bss
);
2532 params
.ssid
= ssid
->ssid
;
2533 params
.ssid_len
= ssid
->ssid_len
;
2534 params
.pbss
= (ssid
->pbss
!= 2) ? ssid
->pbss
: 0;
2537 if (ssid
->mode
== WPAS_MODE_IBSS
&& ssid
->bssid_set
&&
2538 wpa_s
->conf
->ap_scan
== 2) {
2539 params
.bssid
= ssid
->bssid
;
2540 params
.fixed_bssid
= 1;
2543 /* Initial frequency for IBSS/mesh */
2544 if ((ssid
->mode
== WPAS_MODE_IBSS
|| ssid
->mode
== WPAS_MODE_MESH
) &&
2545 ssid
->frequency
> 0 && params
.freq
.freq
== 0)
2546 ibss_mesh_setup_freq(wpa_s
, ssid
, ¶ms
.freq
);
2548 if (ssid
->mode
== WPAS_MODE_IBSS
) {
2549 params
.fixed_freq
= ssid
->fixed_freq
;
2550 if (ssid
->beacon_int
)
2551 params
.beacon_int
= ssid
->beacon_int
;
2553 params
.beacon_int
= wpa_s
->conf
->beacon_int
;
2556 params
.wpa_ie
= wpa_ie
;
2557 params
.wpa_ie_len
= wpa_ie_len
;
2558 params
.pairwise_suite
= cipher_pairwise
;
2559 params
.group_suite
= cipher_group
;
2560 params
.key_mgmt_suite
= wpa_s
->key_mgmt
;
2561 params
.wpa_proto
= wpa_s
->wpa_proto
;
2562 params
.auth_alg
= algs
;
2563 params
.mode
= ssid
->mode
;
2564 params
.bg_scan_period
= ssid
->bg_scan_period
;
2565 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
2566 if (ssid
->wep_key_len
[i
])
2567 params
.wep_key
[i
] = ssid
->wep_key
[i
];
2568 params
.wep_key_len
[i
] = ssid
->wep_key_len
[i
];
2570 params
.wep_tx_keyidx
= ssid
->wep_tx_keyidx
;
2572 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) &&
2573 (params
.key_mgmt_suite
== WPA_KEY_MGMT_PSK
||
2574 params
.key_mgmt_suite
== WPA_KEY_MGMT_FT_PSK
)) {
2575 params
.passphrase
= ssid
->passphrase
;
2577 params
.psk
= ssid
->psk
;
2580 if (wpa_s
->conf
->key_mgmt_offload
) {
2581 if (params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X
||
2582 params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SHA256
||
2583 params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SUITE_B
||
2584 params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SUITE_B_192
)
2585 params
.req_key_mgmt_offload
=
2586 ssid
->proactive_key_caching
< 0 ?
2587 wpa_s
->conf
->okc
: ssid
->proactive_key_caching
;
2589 params
.req_key_mgmt_offload
= 1;
2591 if ((params
.key_mgmt_suite
== WPA_KEY_MGMT_PSK
||
2592 params
.key_mgmt_suite
== WPA_KEY_MGMT_PSK_SHA256
||
2593 params
.key_mgmt_suite
== WPA_KEY_MGMT_FT_PSK
) &&
2595 params
.psk
= ssid
->psk
;
2598 params
.drop_unencrypted
= use_crypt
;
2600 #ifdef CONFIG_IEEE80211W
2601 params
.mgmt_frame_protection
= wpas_get_ssid_pmf(wpa_s
, ssid
);
2602 if (params
.mgmt_frame_protection
!= NO_MGMT_FRAME_PROTECTION
&& bss
) {
2603 const u8
*rsn
= wpa_bss_get_ie(bss
, WLAN_EID_RSN
);
2604 struct wpa_ie_data ie
;
2605 if (rsn
&& wpa_parse_wpa_ie(rsn
, 2 + rsn
[1], &ie
) == 0 &&
2607 (WPA_CAPABILITY_MFPC
| WPA_CAPABILITY_MFPR
)) {
2608 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected AP supports "
2609 "MFP: require MFP");
2610 params
.mgmt_frame_protection
=
2611 MGMT_FRAME_PROTECTION_REQUIRED
;
2614 #endif /* CONFIG_IEEE80211W */
2616 params
.p2p
= ssid
->p2p_group
;
2618 if (wpa_s
->p2pdev
->set_sta_uapsd
)
2619 params
.uapsd
= wpa_s
->p2pdev
->sta_uapsd
;
2623 #ifdef CONFIG_HT_OVERRIDES
2624 os_memset(&htcaps
, 0, sizeof(htcaps
));
2625 os_memset(&htcaps_mask
, 0, sizeof(htcaps_mask
));
2626 params
.htcaps
= (u8
*) &htcaps
;
2627 params
.htcaps_mask
= (u8
*) &htcaps_mask
;
2628 wpa_supplicant_apply_ht_overrides(wpa_s
, ssid
, ¶ms
);
2629 #endif /* CONFIG_HT_OVERRIDES */
2630 #ifdef CONFIG_VHT_OVERRIDES
2631 os_memset(&vhtcaps
, 0, sizeof(vhtcaps
));
2632 os_memset(&vhtcaps_mask
, 0, sizeof(vhtcaps_mask
));
2633 params
.vhtcaps
= &vhtcaps
;
2634 params
.vhtcaps_mask
= &vhtcaps_mask
;
2635 wpa_supplicant_apply_vht_overrides(wpa_s
, ssid
, ¶ms
);
2636 #endif /* CONFIG_VHT_OVERRIDES */
2640 * If multi-channel concurrency is not supported, check for any
2641 * frequency conflict. In case of any frequency conflict, remove the
2642 * least prioritized connection.
2644 if (wpa_s
->num_multichan_concurrent
< 2) {
2646 num
= get_shared_radio_freqs(wpa_s
, &freq
, 1);
2647 if (num
> 0 && freq
> 0 && freq
!= params
.freq
.freq
) {
2648 wpa_printf(MSG_DEBUG
,
2649 "Assoc conflicting freq found (%d != %d)",
2650 freq
, params
.freq
.freq
);
2651 if (wpas_p2p_handle_frequency_conflicts(
2652 wpa_s
, params
.freq
.freq
, ssid
) < 0) {
2653 wpas_connect_work_done(wpa_s
);
2658 #endif /* CONFIG_P2P */
2660 if (wpa_s
->reassoc_same_ess
&& !is_zero_ether_addr(prev_bssid
) &&
2661 wpa_s
->current_ssid
)
2662 params
.prev_bssid
= prev_bssid
;
2664 ret
= wpa_drv_associate(wpa_s
, ¶ms
);
2666 wpa_msg(wpa_s
, MSG_INFO
, "Association request to the driver "
2668 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SANE_ERROR_CODES
) {
2670 * The driver is known to mean what is saying, so we
2671 * can stop right here; the association will not
2674 wpas_connection_failed(wpa_s
, wpa_s
->pending_bssid
);
2675 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
2676 os_memset(wpa_s
->pending_bssid
, 0, ETH_ALEN
);
2679 /* try to continue anyway; new association will be tried again
2684 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
) {
2685 /* Set the key after the association just in case association
2686 * cleared the previously configured key. */
2687 wpa_supplicant_set_wpa_none_key(wpa_s
, ssid
);
2688 /* No need to timeout authentication since there is no key
2690 wpa_supplicant_cancel_auth_timeout(wpa_s
);
2691 wpa_supplicant_set_state(wpa_s
, WPA_COMPLETED
);
2692 #ifdef CONFIG_IBSS_RSN
2693 } else if (ssid
->mode
== WPAS_MODE_IBSS
&&
2694 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_NONE
&&
2695 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPA_NONE
) {
2697 * RSN IBSS authentication is per-STA and we can disable the
2698 * per-BSSID authentication.
2700 wpa_supplicant_cancel_auth_timeout(wpa_s
);
2701 #endif /* CONFIG_IBSS_RSN */
2703 /* Timeout for IEEE 802.11 authentication and association */
2707 /* give IBSS a bit more time */
2708 timeout
= ssid
->mode
== WPAS_MODE_IBSS
? 10 : 5;
2709 } else if (wpa_s
->conf
->ap_scan
== 1) {
2710 /* give IBSS a bit more time */
2711 timeout
= ssid
->mode
== WPAS_MODE_IBSS
? 20 : 10;
2713 wpa_supplicant_req_auth_timeout(wpa_s
, timeout
, 0);
2717 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC
)) {
2718 /* Set static WEP keys again */
2719 wpa_set_wep_keys(wpa_s
, ssid
);
2722 if (wpa_s
->current_ssid
&& wpa_s
->current_ssid
!= ssid
) {
2724 * Do not allow EAP session resumption between different
2725 * network configurations.
2727 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
2729 old_ssid
= wpa_s
->current_ssid
;
2730 wpa_s
->current_ssid
= ssid
;
2732 if (!wpas_driver_bss_selection(wpa_s
) || ssid
->bssid_set
) {
2733 wpa_s
->current_bss
= bss
;
2735 hs20_configure_frame_filters(wpa_s
);
2736 #endif /* CONFIG_HS20 */
2739 wpa_supplicant_rsn_supp_set_config(wpa_s
, wpa_s
->current_ssid
);
2740 wpa_supplicant_initiate_eapol(wpa_s
);
2741 if (old_ssid
!= wpa_s
->current_ssid
)
2742 wpas_notify_network_changed(wpa_s
);
2746 static void wpa_supplicant_clear_connection(struct wpa_supplicant
*wpa_s
,
2749 struct wpa_ssid
*old_ssid
;
2751 wpas_connect_work_done(wpa_s
);
2752 wpa_clear_keys(wpa_s
, addr
);
2753 old_ssid
= wpa_s
->current_ssid
;
2754 wpa_supplicant_mark_disassoc(wpa_s
);
2755 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
2756 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
2757 if (old_ssid
!= wpa_s
->current_ssid
)
2758 wpas_notify_network_changed(wpa_s
);
2759 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
2764 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2765 * @wpa_s: Pointer to wpa_supplicant data
2766 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2768 * This function is used to request %wpa_supplicant to deauthenticate from the
2771 void wpa_supplicant_deauthenticate(struct wpa_supplicant
*wpa_s
,
2775 union wpa_event_data event
;
2778 wpa_dbg(wpa_s
, MSG_DEBUG
, "Request to deauthenticate - bssid=" MACSTR
2779 " pending_bssid=" MACSTR
" reason=%d state=%s",
2780 MAC2STR(wpa_s
->bssid
), MAC2STR(wpa_s
->pending_bssid
),
2781 reason_code
, wpa_supplicant_state_txt(wpa_s
->wpa_state
));
2783 if (!is_zero_ether_addr(wpa_s
->pending_bssid
) &&
2784 (wpa_s
->wpa_state
== WPA_AUTHENTICATING
||
2785 wpa_s
->wpa_state
== WPA_ASSOCIATING
))
2786 addr
= wpa_s
->pending_bssid
;
2787 else if (!is_zero_ether_addr(wpa_s
->bssid
))
2788 addr
= wpa_s
->bssid
;
2789 else if (wpa_s
->wpa_state
== WPA_ASSOCIATING
) {
2791 * When using driver-based BSS selection, we may not know the
2792 * BSSID with which we are currently trying to associate. We
2793 * need to notify the driver of this disconnection even in such
2794 * a case, so use the all zeros address here.
2796 addr
= wpa_s
->bssid
;
2801 wpa_tdls_teardown_peers(wpa_s
->wpa
);
2802 #endif /* CONFIG_TDLS */
2806 wpa_msg(wpa_s
, MSG_INFO
, MESH_GROUP_REMOVED
"%s",
2808 wpa_supplicant_leave_mesh(wpa_s
);
2810 #endif /* CONFIG_MESH */
2813 wpa_drv_deauthenticate(wpa_s
, addr
, reason_code
);
2814 os_memset(&event
, 0, sizeof(event
));
2815 event
.deauth_info
.reason_code
= (u16
) reason_code
;
2816 event
.deauth_info
.locally_generated
= 1;
2817 wpa_supplicant_event(wpa_s
, EVENT_DEAUTH
, &event
);
2822 wpa_supplicant_clear_connection(wpa_s
, addr
);
2825 static void wpa_supplicant_enable_one_network(struct wpa_supplicant
*wpa_s
,
2826 struct wpa_ssid
*ssid
)
2828 if (!ssid
|| !ssid
->disabled
|| ssid
->disabled
== 2)
2832 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
2833 wpas_notify_network_enabled_changed(wpa_s
, ssid
);
2836 * Try to reassociate since there is no current configuration and a new
2837 * network was made available.
2839 if (!wpa_s
->current_ssid
&& !wpa_s
->disconnected
)
2840 wpa_s
->reassociate
= 1;
2845 * wpa_supplicant_add_network - Add a new network
2846 * @wpa_s: wpa_supplicant structure for a network interface
2847 * Returns: The new network configuration or %NULL if operation failed
2849 * This function performs the following operations:
2850 * 1. Adds a new network.
2851 * 2. Send network addition notification.
2852 * 3. Marks the network disabled.
2853 * 4. Set network default parameters.
2855 struct wpa_ssid
* wpa_supplicant_add_network(struct wpa_supplicant
*wpa_s
)
2857 struct wpa_ssid
*ssid
;
2859 ssid
= wpa_config_add_network(wpa_s
->conf
);
2862 wpas_notify_network_added(wpa_s
, ssid
);
2864 wpa_config_set_network_defaults(ssid
);
2871 * wpa_supplicant_remove_network - Remove a configured network based on id
2872 * @wpa_s: wpa_supplicant structure for a network interface
2873 * @id: Unique network id to search for
2874 * Returns: 0 on success, or -1 if the network was not found, -2 if the network
2875 * could not be removed
2877 * This function performs the following operations:
2878 * 1. Removes the network.
2879 * 2. Send network removal notification.
2880 * 3. Update internal state machines.
2881 * 4. Stop any running sched scans.
2883 int wpa_supplicant_remove_network(struct wpa_supplicant
*wpa_s
, int id
)
2885 struct wpa_ssid
*ssid
;
2888 ssid
= wpa_config_get_network(wpa_s
->conf
, id
);
2891 wpas_notify_network_removed(wpa_s
, ssid
);
2893 if (wpa_s
->last_ssid
== ssid
)
2894 wpa_s
->last_ssid
= NULL
;
2896 if (ssid
== wpa_s
->current_ssid
|| !wpa_s
->current_ssid
) {
2898 wpa_s
->sme
.prev_bssid_set
= 0;
2899 #endif /* CONFIG_SME */
2901 * Invalidate the EAP session cache if the current or
2902 * previously used network is removed.
2904 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
2907 if (ssid
== wpa_s
->current_ssid
) {
2908 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
2909 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
2911 if (wpa_s
->wpa_state
>= WPA_AUTHENTICATING
)
2912 wpa_s
->own_disconnect_req
= 1;
2913 wpa_supplicant_deauthenticate(wpa_s
,
2914 WLAN_REASON_DEAUTH_LEAVING
);
2917 was_disabled
= ssid
->disabled
;
2919 if (wpa_config_remove_network(wpa_s
->conf
, id
) < 0)
2922 if (!was_disabled
&& wpa_s
->sched_scanning
) {
2923 wpa_printf(MSG_DEBUG
,
2924 "Stop ongoing sched_scan 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_enable_network - Mark a configured network as enabled
2935 * @wpa_s: wpa_supplicant structure for a network interface
2936 * @ssid: wpa_ssid structure for a configured network or %NULL
2938 * Enables the specified network or all networks if no network specified.
2940 void wpa_supplicant_enable_network(struct wpa_supplicant
*wpa_s
,
2941 struct wpa_ssid
*ssid
)
2944 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
2945 wpa_supplicant_enable_one_network(wpa_s
, ssid
);
2947 wpa_supplicant_enable_one_network(wpa_s
, ssid
);
2949 if (wpa_s
->reassociate
&& !wpa_s
->disconnected
&&
2950 (!wpa_s
->current_ssid
||
2951 wpa_s
->wpa_state
== WPA_DISCONNECTED
||
2952 wpa_s
->wpa_state
== WPA_SCANNING
)) {
2953 if (wpa_s
->sched_scanning
) {
2954 wpa_printf(MSG_DEBUG
, "Stop ongoing sched_scan to add "
2955 "new network to scan filters");
2956 wpa_supplicant_cancel_sched_scan(wpa_s
);
2959 if (wpa_supplicant_fast_associate(wpa_s
) != 1) {
2960 wpa_s
->scan_req
= NORMAL_SCAN_REQ
;
2961 wpa_supplicant_req_scan(wpa_s
, 0, 0);
2968 * wpa_supplicant_disable_network - Mark a configured network as disabled
2969 * @wpa_s: wpa_supplicant structure for a network interface
2970 * @ssid: wpa_ssid structure for a configured network or %NULL
2972 * Disables the specified network or all networks if no network specified.
2974 void wpa_supplicant_disable_network(struct wpa_supplicant
*wpa_s
,
2975 struct wpa_ssid
*ssid
)
2977 struct wpa_ssid
*other_ssid
;
2981 if (wpa_s
->sched_scanning
)
2982 wpa_supplicant_cancel_sched_scan(wpa_s
);
2984 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
2985 other_ssid
= other_ssid
->next
) {
2986 was_disabled
= other_ssid
->disabled
;
2987 if (was_disabled
== 2)
2988 continue; /* do not change persistent P2P group
2991 other_ssid
->disabled
= 1;
2993 if (was_disabled
!= other_ssid
->disabled
)
2994 wpas_notify_network_enabled_changed(
2997 if (wpa_s
->current_ssid
)
2998 wpa_supplicant_deauthenticate(
2999 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
3000 } else if (ssid
->disabled
!= 2) {
3001 if (ssid
== wpa_s
->current_ssid
)
3002 wpa_supplicant_deauthenticate(
3003 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
3005 was_disabled
= ssid
->disabled
;
3009 if (was_disabled
!= ssid
->disabled
) {
3010 wpas_notify_network_enabled_changed(wpa_s
, ssid
);
3011 if (wpa_s
->sched_scanning
) {
3012 wpa_printf(MSG_DEBUG
, "Stop ongoing sched_scan "
3013 "to remove network from filters");
3014 wpa_supplicant_cancel_sched_scan(wpa_s
);
3015 wpa_supplicant_req_scan(wpa_s
, 0, 0);
3023 * wpa_supplicant_select_network - Attempt association with a network
3024 * @wpa_s: wpa_supplicant structure for a network interface
3025 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
3027 void wpa_supplicant_select_network(struct wpa_supplicant
*wpa_s
,
3028 struct wpa_ssid
*ssid
)
3031 struct wpa_ssid
*other_ssid
;
3032 int disconnected
= 0;
3034 if (ssid
&& ssid
!= wpa_s
->current_ssid
&& wpa_s
->current_ssid
) {
3035 if (wpa_s
->wpa_state
>= WPA_AUTHENTICATING
)
3036 wpa_s
->own_disconnect_req
= 1;
3037 wpa_supplicant_deauthenticate(
3038 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
3043 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
3046 * Mark all other networks disabled or mark all networks enabled if no
3047 * network specified.
3049 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
3050 other_ssid
= other_ssid
->next
) {
3051 int was_disabled
= other_ssid
->disabled
;
3052 if (was_disabled
== 2)
3053 continue; /* do not change persistent P2P group data */
3055 other_ssid
->disabled
= ssid
? (ssid
->id
!= other_ssid
->id
) : 0;
3056 if (was_disabled
&& !other_ssid
->disabled
)
3057 wpas_clear_temp_disabled(wpa_s
, other_ssid
, 0);
3059 if (was_disabled
!= other_ssid
->disabled
)
3060 wpas_notify_network_enabled_changed(wpa_s
, other_ssid
);
3063 if (ssid
&& ssid
== wpa_s
->current_ssid
&& wpa_s
->current_ssid
&&
3064 wpa_s
->wpa_state
>= WPA_AUTHENTICATING
) {
3065 /* We are already associated with the selected network */
3066 wpa_printf(MSG_DEBUG
, "Already associated with the "
3067 "selected network - do nothing");
3072 wpa_s
->current_ssid
= ssid
;
3073 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
3074 wpa_s
->connect_without_scan
=
3075 (ssid
->mode
== WPAS_MODE_MESH
) ? ssid
: NULL
;
3078 * Don't optimize next scan freqs since a new ESS has been
3081 os_free(wpa_s
->next_scan_freqs
);
3082 wpa_s
->next_scan_freqs
= NULL
;
3084 wpa_s
->connect_without_scan
= NULL
;
3087 wpa_s
->disconnected
= 0;
3088 wpa_s
->reassociate
= 1;
3090 if (wpa_s
->connect_without_scan
||
3091 wpa_supplicant_fast_associate(wpa_s
) != 1) {
3092 wpa_s
->scan_req
= NORMAL_SCAN_REQ
;
3093 wpas_scan_reset_sched_scan(wpa_s
);
3094 wpa_supplicant_req_scan(wpa_s
, 0, disconnected
? 100000 : 0);
3098 wpas_notify_network_selected(wpa_s
, ssid
);
3103 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
3104 * @wpa_s: wpa_supplicant structure for a network interface
3105 * @pkcs11_engine_path: PKCS #11 engine path or NULL
3106 * @pkcs11_module_path: PKCS #11 module path or NULL
3107 * Returns: 0 on success; -1 on failure
3109 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
3110 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
3111 * module path fails the paths will be reset to the default value (NULL).
3113 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant
*wpa_s
,
3114 const char *pkcs11_engine_path
,
3115 const char *pkcs11_module_path
)
3117 char *pkcs11_engine_path_copy
= NULL
;
3118 char *pkcs11_module_path_copy
= NULL
;
3120 if (pkcs11_engine_path
!= NULL
) {
3121 pkcs11_engine_path_copy
= os_strdup(pkcs11_engine_path
);
3122 if (pkcs11_engine_path_copy
== NULL
)
3125 if (pkcs11_module_path
!= NULL
) {
3126 pkcs11_module_path_copy
= os_strdup(pkcs11_module_path
);
3127 if (pkcs11_module_path_copy
== NULL
) {
3128 os_free(pkcs11_engine_path_copy
);
3133 os_free(wpa_s
->conf
->pkcs11_engine_path
);
3134 os_free(wpa_s
->conf
->pkcs11_module_path
);
3135 wpa_s
->conf
->pkcs11_engine_path
= pkcs11_engine_path_copy
;
3136 wpa_s
->conf
->pkcs11_module_path
= pkcs11_module_path_copy
;
3138 wpa_sm_set_eapol(wpa_s
->wpa
, NULL
);
3139 eapol_sm_deinit(wpa_s
->eapol
);
3140 wpa_s
->eapol
= NULL
;
3141 if (wpa_supplicant_init_eapol(wpa_s
)) {
3142 /* Error -> Reset paths to the default value (NULL) once. */
3143 if (pkcs11_engine_path
!= NULL
&& pkcs11_module_path
!= NULL
)
3144 wpas_set_pkcs11_engine_and_module_path(wpa_s
, NULL
,
3149 wpa_sm_set_eapol(wpa_s
->wpa
, wpa_s
->eapol
);
3156 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
3157 * @wpa_s: wpa_supplicant structure for a network interface
3158 * @ap_scan: AP scan mode
3159 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
3162 int wpa_supplicant_set_ap_scan(struct wpa_supplicant
*wpa_s
, int ap_scan
)
3167 if (ap_scan
< 0 || ap_scan
> 2)
3170 if (ap_scan
== 2 && os_strcmp(wpa_s
->driver
->name
, "nl80211") == 0) {
3171 wpa_printf(MSG_INFO
,
3172 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3176 if (ap_scan
== 2 && ap_scan
!= wpa_s
->conf
->ap_scan
&&
3177 wpa_s
->wpa_state
>= WPA_ASSOCIATING
&&
3178 wpa_s
->wpa_state
< WPA_COMPLETED
) {
3179 wpa_printf(MSG_ERROR
, "ap_scan = %d (%d) rejected while "
3180 "associating", wpa_s
->conf
->ap_scan
, ap_scan
);
3183 #endif /* ANDROID */
3185 old_ap_scan
= wpa_s
->conf
->ap_scan
;
3186 wpa_s
->conf
->ap_scan
= ap_scan
;
3188 if (old_ap_scan
!= wpa_s
->conf
->ap_scan
)
3189 wpas_notify_ap_scan_changed(wpa_s
);
3196 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
3197 * @wpa_s: wpa_supplicant structure for a network interface
3198 * @expire_age: Expiration age in seconds
3199 * Returns: 0 if succeed or -1 if expire_age has an invalid value
3202 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant
*wpa_s
,
3203 unsigned int bss_expire_age
)
3205 if (bss_expire_age
< 10) {
3206 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid bss expiration age %u",
3210 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting bss expiration age: %d sec",
3212 wpa_s
->conf
->bss_expiration_age
= bss_expire_age
;
3219 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
3220 * @wpa_s: wpa_supplicant structure for a network interface
3221 * @expire_count: number of scans after which an unseen BSS is reclaimed
3222 * Returns: 0 if succeed or -1 if expire_count has an invalid value
3225 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant
*wpa_s
,
3226 unsigned int bss_expire_count
)
3228 if (bss_expire_count
< 1) {
3229 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid bss expiration count %u",
3233 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting bss expiration scan count: %u",
3235 wpa_s
->conf
->bss_expiration_scan_count
= bss_expire_count
;
3242 * wpa_supplicant_set_scan_interval - Set scan interval
3243 * @wpa_s: wpa_supplicant structure for a network interface
3244 * @scan_interval: scan interval in seconds
3245 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
3248 int wpa_supplicant_set_scan_interval(struct wpa_supplicant
*wpa_s
,
3251 if (scan_interval
< 0) {
3252 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid scan interval %d",
3256 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting scan interval: %d sec",
3258 wpa_supplicant_update_scan_int(wpa_s
, scan_interval
);
3265 * wpa_supplicant_set_debug_params - Set global debug params
3266 * @global: wpa_global structure
3267 * @debug_level: debug level
3268 * @debug_timestamp: determines if show timestamp in debug data
3269 * @debug_show_keys: determines if show keys in debug data
3270 * Returns: 0 if succeed or -1 if debug_level has wrong value
3272 int wpa_supplicant_set_debug_params(struct wpa_global
*global
, int debug_level
,
3273 int debug_timestamp
, int debug_show_keys
)
3276 int old_level
, old_timestamp
, old_show_keys
;
3278 /* check for allowed debuglevels */
3279 if (debug_level
!= MSG_EXCESSIVE
&&
3280 debug_level
!= MSG_MSGDUMP
&&
3281 debug_level
!= MSG_DEBUG
&&
3282 debug_level
!= MSG_INFO
&&
3283 debug_level
!= MSG_WARNING
&&
3284 debug_level
!= MSG_ERROR
)
3287 old_level
= wpa_debug_level
;
3288 old_timestamp
= wpa_debug_timestamp
;
3289 old_show_keys
= wpa_debug_show_keys
;
3291 wpa_debug_level
= debug_level
;
3292 wpa_debug_timestamp
= debug_timestamp
? 1 : 0;
3293 wpa_debug_show_keys
= debug_show_keys
? 1 : 0;
3295 if (wpa_debug_level
!= old_level
)
3296 wpas_notify_debug_level_changed(global
);
3297 if (wpa_debug_timestamp
!= old_timestamp
)
3298 wpas_notify_debug_timestamp_changed(global
);
3299 if (wpa_debug_show_keys
!= old_show_keys
)
3300 wpas_notify_debug_show_keys_changed(global
);
3307 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
3308 * @wpa_s: Pointer to wpa_supplicant data
3309 * Returns: A pointer to the current network structure or %NULL on failure
3311 struct wpa_ssid
* wpa_supplicant_get_ssid(struct wpa_supplicant
*wpa_s
)
3313 struct wpa_ssid
*entry
;
3314 u8 ssid
[SSID_MAX_LEN
];
3320 res
= wpa_drv_get_ssid(wpa_s
, ssid
);
3322 wpa_msg(wpa_s
, MSG_WARNING
, "Could not read SSID from "
3328 if (wpa_drv_get_bssid(wpa_s
, bssid
) < 0) {
3329 wpa_msg(wpa_s
, MSG_WARNING
, "Could not read BSSID from "
3334 wired
= wpa_s
->conf
->ap_scan
== 0 &&
3335 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
);
3337 entry
= wpa_s
->conf
->ssid
;
3339 if (!wpas_network_disabled(wpa_s
, entry
) &&
3340 ((ssid_len
== entry
->ssid_len
&&
3341 os_memcmp(ssid
, entry
->ssid
, ssid_len
) == 0) || wired
) &&
3342 (!entry
->bssid_set
||
3343 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0))
3346 if (!wpas_network_disabled(wpa_s
, entry
) &&
3347 (entry
->key_mgmt
& WPA_KEY_MGMT_WPS
) &&
3348 (entry
->ssid
== NULL
|| entry
->ssid_len
== 0) &&
3349 (!entry
->bssid_set
||
3350 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0))
3352 #endif /* CONFIG_WPS */
3354 if (!wpas_network_disabled(wpa_s
, entry
) && entry
->bssid_set
&&
3355 entry
->ssid_len
== 0 &&
3356 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0)
3359 entry
= entry
->next
;
3366 static int select_driver(struct wpa_supplicant
*wpa_s
, int i
)
3368 struct wpa_global
*global
= wpa_s
->global
;
3370 if (wpa_drivers
[i
]->global_init
&& global
->drv_priv
[i
] == NULL
) {
3371 global
->drv_priv
[i
] = wpa_drivers
[i
]->global_init(global
);
3372 if (global
->drv_priv
[i
] == NULL
) {
3373 wpa_printf(MSG_ERROR
, "Failed to initialize driver "
3374 "'%s'", wpa_drivers
[i
]->name
);
3379 wpa_s
->driver
= wpa_drivers
[i
];
3380 wpa_s
->global_drv_priv
= global
->drv_priv
[i
];
3386 static int wpa_supplicant_set_driver(struct wpa_supplicant
*wpa_s
,
3391 const char *pos
, *driver
= name
;
3396 if (wpa_drivers
[0] == NULL
) {
3397 wpa_msg(wpa_s
, MSG_ERROR
, "No driver interfaces build into "
3403 /* default to first driver in the list */
3404 return select_driver(wpa_s
, 0);
3408 pos
= os_strchr(driver
, ',');
3412 len
= os_strlen(driver
);
3414 for (i
= 0; wpa_drivers
[i
]; i
++) {
3415 if (os_strlen(wpa_drivers
[i
]->name
) == len
&&
3416 os_strncmp(driver
, wpa_drivers
[i
]->name
, len
) ==
3418 /* First driver that succeeds wins */
3419 if (select_driver(wpa_s
, i
) == 0)
3427 wpa_msg(wpa_s
, MSG_ERROR
, "Unsupported driver '%s'", name
);
3433 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
3434 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3435 * with struct wpa_driver_ops::init()
3436 * @src_addr: Source address of the EAPOL frame
3437 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
3438 * @len: Length of the EAPOL data
3440 * This function is called for each received EAPOL frame. Most driver
3441 * interfaces rely on more generic OS mechanism for receiving frames through
3442 * l2_packet, but if such a mechanism is not available, the driver wrapper may
3443 * take care of received EAPOL frames and deliver them to the core supplicant
3444 * code by calling this function.
3446 void wpa_supplicant_rx_eapol(void *ctx
, const u8
*src_addr
,
3447 const u8
*buf
, size_t len
)
3449 struct wpa_supplicant
*wpa_s
= ctx
;
3451 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
, MAC2STR(src_addr
));
3452 wpa_hexdump(MSG_MSGDUMP
, "RX EAPOL", buf
, len
);
3454 #ifdef CONFIG_TESTING_OPTIONS
3455 if (wpa_s
->ignore_auth_resp
) {
3456 wpa_printf(MSG_INFO
, "RX EAPOL - ignore_auth_resp active!");
3459 #endif /* CONFIG_TESTING_OPTIONS */
3461 #ifdef CONFIG_PEERKEY
3462 if (wpa_s
->wpa_state
> WPA_ASSOCIATED
&& wpa_s
->current_ssid
&&
3463 wpa_s
->current_ssid
->peerkey
&&
3464 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) &&
3465 wpa_sm_rx_eapol_peerkey(wpa_s
->wpa
, src_addr
, buf
, len
) == 1) {
3466 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: Processed PeerKey EAPOL-Key");
3469 #endif /* CONFIG_PEERKEY */
3471 if (wpa_s
->wpa_state
< WPA_ASSOCIATED
||
3472 (wpa_s
->last_eapol_matches_bssid
&&
3475 #endif /* CONFIG_AP */
3476 os_memcmp(src_addr
, wpa_s
->bssid
, ETH_ALEN
) != 0)) {
3478 * There is possible race condition between receiving the
3479 * association event and the EAPOL frame since they are coming
3480 * through different paths from the driver. In order to avoid
3481 * issues in trying to process the EAPOL frame before receiving
3482 * association information, lets queue it for processing until
3483 * the association event is received. This may also be needed in
3484 * driver-based roaming case, so also use src_addr != BSSID as a
3485 * trigger if we have previously confirmed that the
3486 * Authenticator uses BSSID as the src_addr (which is not the
3487 * case with wired IEEE 802.1X).
3489 wpa_dbg(wpa_s
, MSG_DEBUG
, "Not associated - Delay processing "
3490 "of received EAPOL frame (state=%s bssid=" MACSTR
")",
3491 wpa_supplicant_state_txt(wpa_s
->wpa_state
),
3492 MAC2STR(wpa_s
->bssid
));
3493 wpabuf_free(wpa_s
->pending_eapol_rx
);
3494 wpa_s
->pending_eapol_rx
= wpabuf_alloc_copy(buf
, len
);
3495 if (wpa_s
->pending_eapol_rx
) {
3496 os_get_reltime(&wpa_s
->pending_eapol_rx_time
);
3497 os_memcpy(wpa_s
->pending_eapol_rx_src
, src_addr
,
3503 wpa_s
->last_eapol_matches_bssid
=
3504 os_memcmp(src_addr
, wpa_s
->bssid
, ETH_ALEN
) == 0;
3507 if (wpa_s
->ap_iface
) {
3508 wpa_supplicant_ap_rx_eapol(wpa_s
, src_addr
, buf
, len
);
3511 #endif /* CONFIG_AP */
3513 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
) {
3514 wpa_dbg(wpa_s
, MSG_DEBUG
, "Ignored received EAPOL frame since "
3515 "no key management is configured");
3519 if (wpa_s
->eapol_received
== 0 &&
3520 (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) ||
3521 !wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
) ||
3522 wpa_s
->wpa_state
!= WPA_COMPLETED
) &&
3523 (wpa_s
->current_ssid
== NULL
||
3524 wpa_s
->current_ssid
->mode
!= IEEE80211_MODE_IBSS
)) {
3525 /* Timeout for completing IEEE 802.1X and WPA authentication */
3528 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) ||
3529 wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
||
3530 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
) {
3531 /* Use longer timeout for IEEE 802.1X/EAP */
3536 if (wpa_s
->current_ssid
&& wpa_s
->current_bss
&&
3537 (wpa_s
->current_ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
) &&
3538 eap_is_wps_pin_enrollee(&wpa_s
->current_ssid
->eap
)) {
3540 * Use shorter timeout if going through WPS AP iteration
3541 * for PIN config method with an AP that does not
3542 * advertise Selected Registrar.
3544 struct wpabuf
*wps_ie
;
3546 wps_ie
= wpa_bss_get_vendor_ie_multi(
3547 wpa_s
->current_bss
, WPS_IE_VENDOR_TYPE
);
3549 !wps_is_addr_authorized(wps_ie
, wpa_s
->own_addr
, 1))
3551 wpabuf_free(wps_ie
);
3553 #endif /* CONFIG_WPS */
3555 wpa_supplicant_req_auth_timeout(wpa_s
, timeout
, 0);
3557 wpa_s
->eapol_received
++;
3559 if (wpa_s
->countermeasures
) {
3560 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Countermeasures - dropped "
3565 #ifdef CONFIG_IBSS_RSN
3566 if (wpa_s
->current_ssid
&&
3567 wpa_s
->current_ssid
->mode
== WPAS_MODE_IBSS
) {
3568 ibss_rsn_rx_eapol(wpa_s
->ibss_rsn
, src_addr
, buf
, len
);
3571 #endif /* CONFIG_IBSS_RSN */
3573 /* Source address of the incoming EAPOL frame could be compared to the
3574 * current BSSID. However, it is possible that a centralized
3575 * Authenticator could be using another MAC address than the BSSID of
3576 * an AP, so just allow any address to be used for now. The replies are
3577 * still sent to the current BSSID (if available), though. */
3579 os_memcpy(wpa_s
->last_eapol_src
, src_addr
, ETH_ALEN
);
3580 if (!wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
) &&
3581 eapol_sm_rx_eapol(wpa_s
->eapol
, src_addr
, buf
, len
) > 0)
3583 wpa_drv_poll(wpa_s
);
3584 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
))
3585 wpa_sm_rx_eapol(wpa_s
->wpa
, src_addr
, buf
, len
);
3586 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
)) {
3588 * Set portValid = TRUE here since we are going to skip 4-way
3589 * handshake processing which would normally set portValid. We
3590 * need this to allow the EAPOL state machines to be completed
3591 * without going through EAPOL-Key handshake.
3593 eapol_sm_notify_portValid(wpa_s
->eapol
, TRUE
);
3598 int wpa_supplicant_update_mac_addr(struct wpa_supplicant
*wpa_s
)
3600 if ((!wpa_s
->p2p_mgmt
||
3601 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
)) &&
3602 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE
)) {
3603 l2_packet_deinit(wpa_s
->l2
);
3604 wpa_s
->l2
= l2_packet_init(wpa_s
->ifname
,
3605 wpa_drv_get_mac_addr(wpa_s
),
3607 wpa_supplicant_rx_eapol
, wpa_s
, 0);
3608 if (wpa_s
->l2
== NULL
)
3611 const u8
*addr
= wpa_drv_get_mac_addr(wpa_s
);
3613 os_memcpy(wpa_s
->own_addr
, addr
, ETH_ALEN
);
3616 if (wpa_s
->l2
&& l2_packet_get_own_addr(wpa_s
->l2
, wpa_s
->own_addr
)) {
3617 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to get own L2 address");
3621 wpa_sm_set_own_addr(wpa_s
->wpa
, wpa_s
->own_addr
);
3627 static void wpa_supplicant_rx_eapol_bridge(void *ctx
, const u8
*src_addr
,
3628 const u8
*buf
, size_t len
)
3630 struct wpa_supplicant
*wpa_s
= ctx
;
3631 const struct l2_ethhdr
*eth
;
3633 if (len
< sizeof(*eth
))
3635 eth
= (const struct l2_ethhdr
*) buf
;
3637 if (os_memcmp(eth
->h_dest
, wpa_s
->own_addr
, ETH_ALEN
) != 0 &&
3638 !(eth
->h_dest
[0] & 0x01)) {
3639 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
" to " MACSTR
3640 " (bridge - not for this interface - ignore)",
3641 MAC2STR(src_addr
), MAC2STR(eth
->h_dest
));
3645 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
" to " MACSTR
3646 " (bridge)", MAC2STR(src_addr
), MAC2STR(eth
->h_dest
));
3647 wpa_supplicant_rx_eapol(wpa_s
, src_addr
, buf
+ sizeof(*eth
),
3648 len
- sizeof(*eth
));
3653 * wpa_supplicant_driver_init - Initialize driver interface parameters
3654 * @wpa_s: Pointer to wpa_supplicant data
3655 * Returns: 0 on success, -1 on failure
3657 * This function is called to initialize driver interface parameters.
3658 * wpa_drv_init() must have been called before this function to initialize the
3661 int wpa_supplicant_driver_init(struct wpa_supplicant
*wpa_s
)
3663 static int interface_count
= 0;
3665 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0)
3668 wpa_dbg(wpa_s
, MSG_DEBUG
, "Own MAC address: " MACSTR
,
3669 MAC2STR(wpa_s
->own_addr
));
3670 os_memcpy(wpa_s
->perm_addr
, wpa_s
->own_addr
, ETH_ALEN
);
3671 wpa_sm_set_own_addr(wpa_s
->wpa
, wpa_s
->own_addr
);
3673 if (wpa_s
->bridge_ifname
[0]) {
3674 wpa_dbg(wpa_s
, MSG_DEBUG
, "Receiving packets from bridge "
3675 "interface '%s'", wpa_s
->bridge_ifname
);
3676 wpa_s
->l2_br
= l2_packet_init_bridge(
3677 wpa_s
->bridge_ifname
, wpa_s
->ifname
, wpa_s
->own_addr
,
3678 ETH_P_EAPOL
, wpa_supplicant_rx_eapol_bridge
, wpa_s
, 1);
3679 if (wpa_s
->l2_br
== NULL
) {
3680 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to open l2_packet "
3681 "connection for the bridge interface '%s'",
3682 wpa_s
->bridge_ifname
);
3687 if (wpa_s
->conf
->ap_scan
== 2 &&
3688 os_strcmp(wpa_s
->driver
->name
, "nl80211") == 0) {
3689 wpa_printf(MSG_INFO
,
3690 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures");
3693 wpa_clear_keys(wpa_s
, NULL
);
3695 /* Make sure that TKIP countermeasures are not left enabled (could
3696 * happen if wpa_supplicant is killed during countermeasures. */
3697 wpa_drv_set_countermeasures(wpa_s
, 0);
3699 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: flushing PMKID list in the driver");
3700 wpa_drv_flush_pmkid(wpa_s
);
3702 wpa_s
->prev_scan_ssid
= WILDCARD_SSID_SCAN
;
3703 wpa_s
->prev_scan_wildcard
= 0;
3705 if (wpa_supplicant_enabled_networks(wpa_s
)) {
3706 if (wpa_s
->wpa_state
== WPA_INTERFACE_DISABLED
) {
3707 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
3708 interface_count
= 0;
3711 if (!wpa_s
->p2p_mgmt
&&
3712 wpa_supplicant_delayed_sched_scan(wpa_s
,
3713 interface_count
% 3,
3715 wpa_supplicant_req_scan(wpa_s
, interface_count
% 3,
3717 #endif /* ANDROID */
3720 wpa_supplicant_set_state(wpa_s
, WPA_INACTIVE
);
3726 static int wpa_supplicant_daemon(const char *pid_file
)
3728 wpa_printf(MSG_DEBUG
, "Daemonize..");
3729 return os_daemonize(pid_file
);
3733 static struct wpa_supplicant
*
3734 wpa_supplicant_alloc(struct wpa_supplicant
*parent
)
3736 struct wpa_supplicant
*wpa_s
;
3738 wpa_s
= os_zalloc(sizeof(*wpa_s
));
3741 wpa_s
->scan_req
= INITIAL_SCAN_REQ
;
3742 wpa_s
->scan_interval
= 5;
3743 wpa_s
->new_connection
= 1;
3744 wpa_s
->parent
= parent
? parent
: wpa_s
;
3745 wpa_s
->p2pdev
= wpa_s
->parent
;
3746 wpa_s
->sched_scanning
= 0;
3748 dl_list_init(&wpa_s
->bss_tmp_disallowed
);
3749 dl_list_init(&wpa_s
->fils_hlp_req
);
3755 #ifdef CONFIG_HT_OVERRIDES
3757 static int wpa_set_htcap_mcs(struct wpa_supplicant
*wpa_s
,
3758 struct ieee80211_ht_capabilities
*htcaps
,
3759 struct ieee80211_ht_capabilities
*htcaps_mask
,
3762 /* parse ht_mcs into hex array */
3764 const char *tmp
= ht_mcs
;
3767 /* If ht_mcs is null, do not set anything */
3771 /* This is what we are setting in the kernel */
3772 os_memset(&htcaps
->supported_mcs_set
, 0, IEEE80211_HT_MCS_MASK_LEN
);
3774 wpa_msg(wpa_s
, MSG_DEBUG
, "set_htcap, ht_mcs -:%s:-", ht_mcs
);
3776 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++) {
3780 v
= strtol(tmp
, &end
, 16);
3783 wpa_msg(wpa_s
, MSG_DEBUG
,
3784 "htcap value[%i]: %ld end: %p tmp: %p",
3789 htcaps
->supported_mcs_set
[i
] = v
;
3792 wpa_msg(wpa_s
, MSG_ERROR
,
3793 "Failed to parse ht-mcs: %s, error: %s\n",
3794 ht_mcs
, strerror(errno
));
3800 * If we were able to parse any values, then set mask for the MCS set.
3803 os_memset(&htcaps_mask
->supported_mcs_set
, 0xff,
3804 IEEE80211_HT_MCS_MASK_LEN
- 1);
3805 /* skip the 3 reserved bits */
3806 htcaps_mask
->supported_mcs_set
[IEEE80211_HT_MCS_MASK_LEN
- 1] =
3814 static int wpa_disable_max_amsdu(struct wpa_supplicant
*wpa_s
,
3815 struct ieee80211_ht_capabilities
*htcaps
,
3816 struct ieee80211_ht_capabilities
*htcaps_mask
,
3821 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_max_amsdu: %d", disabled
);
3826 msk
= host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE
);
3827 htcaps_mask
->ht_capabilities_info
|= msk
;
3829 htcaps
->ht_capabilities_info
&= msk
;
3831 htcaps
->ht_capabilities_info
|= msk
;
3837 static int wpa_set_ampdu_factor(struct wpa_supplicant
*wpa_s
,
3838 struct ieee80211_ht_capabilities
*htcaps
,
3839 struct ieee80211_ht_capabilities
*htcaps_mask
,
3842 wpa_msg(wpa_s
, MSG_DEBUG
, "set_ampdu_factor: %d", factor
);
3847 if (factor
< 0 || factor
> 3) {
3848 wpa_msg(wpa_s
, MSG_ERROR
, "ampdu_factor: %d out of range. "
3849 "Must be 0-3 or -1", factor
);
3853 htcaps_mask
->a_mpdu_params
|= 0x3; /* 2 bits for factor */
3854 htcaps
->a_mpdu_params
&= ~0x3;
3855 htcaps
->a_mpdu_params
|= factor
& 0x3;
3861 static int wpa_set_ampdu_density(struct wpa_supplicant
*wpa_s
,
3862 struct ieee80211_ht_capabilities
*htcaps
,
3863 struct ieee80211_ht_capabilities
*htcaps_mask
,
3866 wpa_msg(wpa_s
, MSG_DEBUG
, "set_ampdu_density: %d", density
);
3871 if (density
< 0 || density
> 7) {
3872 wpa_msg(wpa_s
, MSG_ERROR
,
3873 "ampdu_density: %d out of range. Must be 0-7 or -1.",
3878 htcaps_mask
->a_mpdu_params
|= 0x1C;
3879 htcaps
->a_mpdu_params
&= ~(0x1C);
3880 htcaps
->a_mpdu_params
|= (density
<< 2) & 0x1C;
3886 static int wpa_set_disable_ht40(struct wpa_supplicant
*wpa_s
,
3887 struct ieee80211_ht_capabilities
*htcaps
,
3888 struct ieee80211_ht_capabilities
*htcaps_mask
,
3891 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_ht40: %d", disabled
);
3893 set_disable_ht40(htcaps
, disabled
);
3894 set_disable_ht40(htcaps_mask
, 0);
3900 static int wpa_set_disable_sgi(struct wpa_supplicant
*wpa_s
,
3901 struct ieee80211_ht_capabilities
*htcaps
,
3902 struct ieee80211_ht_capabilities
*htcaps_mask
,
3905 /* Masking these out disables SGI */
3906 le16 msk
= host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ
|
3907 HT_CAP_INFO_SHORT_GI40MHZ
);
3909 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_sgi: %d", disabled
);
3912 htcaps
->ht_capabilities_info
&= ~msk
;
3914 htcaps
->ht_capabilities_info
|= msk
;
3916 htcaps_mask
->ht_capabilities_info
|= msk
;
3922 static int wpa_set_disable_ldpc(struct wpa_supplicant
*wpa_s
,
3923 struct ieee80211_ht_capabilities
*htcaps
,
3924 struct ieee80211_ht_capabilities
*htcaps_mask
,
3927 /* Masking these out disables LDPC */
3928 le16 msk
= host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP
);
3930 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_ldpc: %d", disabled
);
3933 htcaps
->ht_capabilities_info
&= ~msk
;
3935 htcaps
->ht_capabilities_info
|= msk
;
3937 htcaps_mask
->ht_capabilities_info
|= msk
;
3943 void wpa_supplicant_apply_ht_overrides(
3944 struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
,
3945 struct wpa_driver_associate_params
*params
)
3947 struct ieee80211_ht_capabilities
*htcaps
;
3948 struct ieee80211_ht_capabilities
*htcaps_mask
;
3953 params
->disable_ht
= ssid
->disable_ht
;
3954 if (!params
->htcaps
|| !params
->htcaps_mask
)
3957 htcaps
= (struct ieee80211_ht_capabilities
*) params
->htcaps
;
3958 htcaps_mask
= (struct ieee80211_ht_capabilities
*) params
->htcaps_mask
;
3959 wpa_set_htcap_mcs(wpa_s
, htcaps
, htcaps_mask
, ssid
->ht_mcs
);
3960 wpa_disable_max_amsdu(wpa_s
, htcaps
, htcaps_mask
,
3961 ssid
->disable_max_amsdu
);
3962 wpa_set_ampdu_factor(wpa_s
, htcaps
, htcaps_mask
, ssid
->ampdu_factor
);
3963 wpa_set_ampdu_density(wpa_s
, htcaps
, htcaps_mask
, ssid
->ampdu_density
);
3964 wpa_set_disable_ht40(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_ht40
);
3965 wpa_set_disable_sgi(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_sgi
);
3966 wpa_set_disable_ldpc(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_ldpc
);
3968 if (ssid
->ht40_intolerant
) {
3969 le16 bit
= host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT
);
3970 htcaps
->ht_capabilities_info
|= bit
;
3971 htcaps_mask
->ht_capabilities_info
|= bit
;
3975 #endif /* CONFIG_HT_OVERRIDES */
3978 #ifdef CONFIG_VHT_OVERRIDES
3979 void wpa_supplicant_apply_vht_overrides(
3980 struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
,
3981 struct wpa_driver_associate_params
*params
)
3983 struct ieee80211_vht_capabilities
*vhtcaps
;
3984 struct ieee80211_vht_capabilities
*vhtcaps_mask
;
3989 params
->disable_vht
= ssid
->disable_vht
;
3991 vhtcaps
= (void *) params
->vhtcaps
;
3992 vhtcaps_mask
= (void *) params
->vhtcaps_mask
;
3994 if (!vhtcaps
|| !vhtcaps_mask
)
3997 vhtcaps
->vht_capabilities_info
= host_to_le32(ssid
->vht_capa
);
3998 vhtcaps_mask
->vht_capabilities_info
= host_to_le32(ssid
->vht_capa_mask
);
4000 #ifdef CONFIG_HT_OVERRIDES
4001 /* if max ampdu is <= 3, we have to make the HT cap the same */
4002 if (ssid
->vht_capa_mask
& VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX
) {
4005 max_ampdu
= (ssid
->vht_capa
&
4006 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX
) >>
4007 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT
;
4009 max_ampdu
= max_ampdu
< 3 ? max_ampdu
: 3;
4010 wpa_set_ampdu_factor(wpa_s
,
4011 (void *) params
->htcaps
,
4012 (void *) params
->htcaps_mask
,
4015 #endif /* CONFIG_HT_OVERRIDES */
4017 #define OVERRIDE_MCS(i) \
4018 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
4019 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
4020 host_to_le16(3 << 2 * (i - 1)); \
4021 vhtcaps->vht_supported_mcs_set.tx_map |= \
4022 host_to_le16(ssid->vht_tx_mcs_nss_ ##i << \
4025 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
4026 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
4027 host_to_le16(3 << 2 * (i - 1)); \
4028 vhtcaps->vht_supported_mcs_set.rx_map |= \
4029 host_to_le16(ssid->vht_rx_mcs_nss_ ##i << \
4042 #endif /* CONFIG_VHT_OVERRIDES */
4045 static int pcsc_reader_init(struct wpa_supplicant
*wpa_s
)
4050 if (!wpa_s
->conf
->pcsc_reader
)
4053 wpa_s
->scard
= scard_init(wpa_s
->conf
->pcsc_reader
);
4057 if (wpa_s
->conf
->pcsc_pin
&&
4058 scard_set_pin(wpa_s
->scard
, wpa_s
->conf
->pcsc_pin
) < 0) {
4059 scard_deinit(wpa_s
->scard
);
4060 wpa_s
->scard
= NULL
;
4061 wpa_msg(wpa_s
, MSG_ERROR
, "PC/SC PIN validation failed");
4065 len
= sizeof(wpa_s
->imsi
) - 1;
4066 if (scard_get_imsi(wpa_s
->scard
, wpa_s
->imsi
, &len
)) {
4067 scard_deinit(wpa_s
->scard
);
4068 wpa_s
->scard
= NULL
;
4069 wpa_msg(wpa_s
, MSG_ERROR
, "Could not read IMSI");
4072 wpa_s
->imsi
[len
] = '\0';
4074 wpa_s
->mnc_len
= scard_get_mnc_len(wpa_s
->scard
);
4076 wpa_printf(MSG_DEBUG
, "SCARD: IMSI %s (MNC length %d)",
4077 wpa_s
->imsi
, wpa_s
->mnc_len
);
4079 wpa_sm_set_scard_ctx(wpa_s
->wpa
, wpa_s
->scard
);
4080 eapol_sm_register_scard_ctx(wpa_s
->eapol
, wpa_s
->scard
);
4081 #endif /* PCSC_FUNCS */
4087 int wpas_init_ext_pw(struct wpa_supplicant
*wpa_s
)
4091 ext_password_deinit(wpa_s
->ext_pw
);
4092 wpa_s
->ext_pw
= NULL
;
4093 eapol_sm_set_ext_pw_ctx(wpa_s
->eapol
, NULL
);
4095 if (!wpa_s
->conf
->ext_password_backend
)
4098 val
= os_strdup(wpa_s
->conf
->ext_password_backend
);
4101 pos
= os_strchr(val
, ':');
4105 wpa_printf(MSG_DEBUG
, "EXT PW: Initialize backend '%s'", val
);
4107 wpa_s
->ext_pw
= ext_password_init(val
, pos
);
4109 if (wpa_s
->ext_pw
== NULL
) {
4110 wpa_printf(MSG_DEBUG
, "EXT PW: Failed to initialize backend");
4113 eapol_sm_set_ext_pw_ctx(wpa_s
->eapol
, wpa_s
->ext_pw
);
4121 static const u8
* wpas_fst_get_bssid_cb(void *ctx
)
4123 struct wpa_supplicant
*wpa_s
= ctx
;
4125 return (is_zero_ether_addr(wpa_s
->bssid
) ||
4126 wpa_s
->wpa_state
!= WPA_COMPLETED
) ? NULL
: wpa_s
->bssid
;
4130 static void wpas_fst_get_channel_info_cb(void *ctx
,
4131 enum hostapd_hw_mode
*hw_mode
,
4134 struct wpa_supplicant
*wpa_s
= ctx
;
4136 if (wpa_s
->current_bss
) {
4137 *hw_mode
= ieee80211_freq_to_chan(wpa_s
->current_bss
->freq
,
4139 } else if (wpa_s
->hw
.num_modes
) {
4140 *hw_mode
= wpa_s
->hw
.modes
[0].mode
;
4148 static int wpas_fst_get_hw_modes(void *ctx
, struct hostapd_hw_modes
**modes
)
4150 struct wpa_supplicant
*wpa_s
= ctx
;
4152 *modes
= wpa_s
->hw
.modes
;
4153 return wpa_s
->hw
.num_modes
;
4157 static void wpas_fst_set_ies_cb(void *ctx
, const struct wpabuf
*fst_ies
)
4159 struct wpa_supplicant
*wpa_s
= ctx
;
4161 wpa_hexdump_buf(MSG_DEBUG
, "FST: Set IEs", fst_ies
);
4162 wpa_s
->fst_ies
= fst_ies
;
4166 static int wpas_fst_send_action_cb(void *ctx
, const u8
*da
, struct wpabuf
*data
)
4168 struct wpa_supplicant
*wpa_s
= ctx
;
4170 if (os_memcmp(wpa_s
->bssid
, da
, ETH_ALEN
) != 0) {
4171 wpa_printf(MSG_INFO
, "FST:%s:bssid=" MACSTR
" != da=" MACSTR
,
4172 __func__
, MAC2STR(wpa_s
->bssid
), MAC2STR(da
));
4175 return wpa_drv_send_action(wpa_s
, wpa_s
->assoc_freq
, 0, wpa_s
->bssid
,
4176 wpa_s
->own_addr
, wpa_s
->bssid
,
4177 wpabuf_head(data
), wpabuf_len(data
),
4182 static const struct wpabuf
* wpas_fst_get_mb_ie_cb(void *ctx
, const u8
*addr
)
4184 struct wpa_supplicant
*wpa_s
= ctx
;
4186 WPA_ASSERT(os_memcmp(wpa_s
->bssid
, addr
, ETH_ALEN
) == 0);
4187 return wpa_s
->received_mb_ies
;
4191 static void wpas_fst_update_mb_ie_cb(void *ctx
, const u8
*addr
,
4192 const u8
*buf
, size_t size
)
4194 struct wpa_supplicant
*wpa_s
= ctx
;
4195 struct mb_ies_info info
;
4197 WPA_ASSERT(os_memcmp(wpa_s
->bssid
, addr
, ETH_ALEN
) == 0);
4199 if (!mb_ies_info_by_ies(&info
, buf
, size
)) {
4200 wpabuf_free(wpa_s
->received_mb_ies
);
4201 wpa_s
->received_mb_ies
= mb_ies_by_info(&info
);
4206 static const u8
* wpas_fst_get_peer_first(void *ctx
,
4207 struct fst_get_peer_ctx
**get_ctx
,
4210 struct wpa_supplicant
*wpa_s
= ctx
;
4213 if (!is_zero_ether_addr(wpa_s
->bssid
))
4214 return (wpa_s
->received_mb_ies
|| !mb_only
) ?
4215 wpa_s
->bssid
: NULL
;
4220 static const u8
* wpas_fst_get_peer_next(void *ctx
,
4221 struct fst_get_peer_ctx
**get_ctx
,
4227 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant
*wpa_s
,
4228 struct fst_wpa_obj
*iface_obj
)
4230 iface_obj
->ctx
= wpa_s
;
4231 iface_obj
->get_bssid
= wpas_fst_get_bssid_cb
;
4232 iface_obj
->get_channel_info
= wpas_fst_get_channel_info_cb
;
4233 iface_obj
->get_hw_modes
= wpas_fst_get_hw_modes
;
4234 iface_obj
->set_ies
= wpas_fst_set_ies_cb
;
4235 iface_obj
->send_action
= wpas_fst_send_action_cb
;
4236 iface_obj
->get_mb_ie
= wpas_fst_get_mb_ie_cb
;
4237 iface_obj
->update_mb_ie
= wpas_fst_update_mb_ie_cb
;
4238 iface_obj
->get_peer_first
= wpas_fst_get_peer_first
;
4239 iface_obj
->get_peer_next
= wpas_fst_get_peer_next
;
4241 #endif /* CONFIG_FST */
4243 static int wpas_set_wowlan_triggers(struct wpa_supplicant
*wpa_s
,
4244 const struct wpa_driver_capa
*capa
)
4246 struct wowlan_triggers
*triggers
;
4249 if (!wpa_s
->conf
->wowlan_triggers
)
4252 triggers
= wpa_get_wowlan_triggers(wpa_s
->conf
->wowlan_triggers
, capa
);
4254 ret
= wpa_drv_wowlan(wpa_s
, triggers
);
4261 enum wpa_radio_work_band
wpas_freq_to_band(int freq
)
4264 return BAND_2_4_GHZ
;
4271 unsigned int wpas_get_bands(struct wpa_supplicant
*wpa_s
, const int *freqs
)
4274 unsigned int band
= 0;
4277 /* freqs are specified for the radio work */
4278 for (i
= 0; freqs
[i
]; i
++)
4279 band
|= wpas_freq_to_band(freqs
[i
]);
4282 * freqs are not specified, implies all
4283 * the supported freqs by HW
4285 for (i
= 0; i
< wpa_s
->hw
.num_modes
; i
++) {
4286 if (wpa_s
->hw
.modes
[i
].num_channels
!= 0) {
4287 if (wpa_s
->hw
.modes
[i
].mode
==
4288 HOSTAPD_MODE_IEEE80211B
||
4289 wpa_s
->hw
.modes
[i
].mode
==
4290 HOSTAPD_MODE_IEEE80211G
)
4291 band
|= BAND_2_4_GHZ
;
4292 else if (wpa_s
->hw
.modes
[i
].mode
==
4293 HOSTAPD_MODE_IEEE80211A
)
4295 else if (wpa_s
->hw
.modes
[i
].mode
==
4296 HOSTAPD_MODE_IEEE80211AD
)
4297 band
|= BAND_60_GHZ
;
4298 else if (wpa_s
->hw
.modes
[i
].mode
==
4299 HOSTAPD_MODE_IEEE80211ANY
)
4300 band
= BAND_2_4_GHZ
| BAND_5_GHZ
|
4310 static struct wpa_radio
* radio_add_interface(struct wpa_supplicant
*wpa_s
,
4313 struct wpa_supplicant
*iface
= wpa_s
->global
->ifaces
;
4314 struct wpa_radio
*radio
;
4316 while (rn
&& iface
) {
4317 radio
= iface
->radio
;
4318 if (radio
&& os_strcmp(rn
, radio
->name
) == 0) {
4319 wpa_printf(MSG_DEBUG
, "Add interface %s to existing radio %s",
4321 dl_list_add(&radio
->ifaces
, &wpa_s
->radio_list
);
4325 iface
= iface
->next
;
4328 wpa_printf(MSG_DEBUG
, "Add interface %s to a new radio %s",
4329 wpa_s
->ifname
, rn
? rn
: "N/A");
4330 radio
= os_zalloc(sizeof(*radio
));
4335 os_strlcpy(radio
->name
, rn
, sizeof(radio
->name
));
4336 dl_list_init(&radio
->ifaces
);
4337 dl_list_init(&radio
->work
);
4338 dl_list_add(&radio
->ifaces
, &wpa_s
->radio_list
);
4344 static void radio_work_free(struct wpa_radio_work
*work
)
4346 if (work
->wpa_s
->scan_work
== work
) {
4347 /* This should not really happen. */
4348 wpa_dbg(work
->wpa_s
, MSG_INFO
, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4349 work
->type
, work
, work
->started
);
4350 work
->wpa_s
->scan_work
= NULL
;
4354 if (work
->wpa_s
->p2p_scan_work
== work
) {
4355 /* This should not really happen. */
4356 wpa_dbg(work
->wpa_s
, MSG_INFO
, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4357 work
->type
, work
, work
->started
);
4358 work
->wpa_s
->p2p_scan_work
= NULL
;
4360 #endif /* CONFIG_P2P */
4362 if (work
->started
) {
4363 work
->wpa_s
->radio
->num_active_works
--;
4364 wpa_dbg(work
->wpa_s
, MSG_DEBUG
,
4365 "radio_work_free('%s'@%p: num_active_works --> %u",
4367 work
->wpa_s
->radio
->num_active_works
);
4370 dl_list_del(&work
->list
);
4375 static int radio_work_is_connect(struct wpa_radio_work
*work
)
4377 return os_strcmp(work
->type
, "sme-connect") == 0 ||
4378 os_strcmp(work
->type
, "connect") == 0;
4382 static int radio_work_is_scan(struct wpa_radio_work
*work
)
4384 return os_strcmp(work
->type
, "scan") == 0 ||
4385 os_strcmp(work
->type
, "p2p-scan") == 0;
4389 static struct wpa_radio_work
* radio_work_get_next_work(struct wpa_radio
*radio
)
4391 struct wpa_radio_work
*active_work
= NULL
;
4392 struct wpa_radio_work
*tmp
;
4394 /* Get the active work to know the type and band. */
4395 dl_list_for_each(tmp
, &radio
->work
, struct wpa_radio_work
, list
) {
4403 /* No active work, start one */
4404 radio
->num_active_works
= 0;
4405 dl_list_for_each(tmp
, &radio
->work
, struct wpa_radio_work
,
4407 if (os_strcmp(tmp
->type
, "scan") == 0 &&
4408 radio
->external_scan_running
&&
4409 (((struct wpa_driver_scan_params
*)
4410 tmp
->ctx
)->only_new_results
||
4411 tmp
->wpa_s
->clear_driver_scan_cache
))
4418 if (radio_work_is_connect(active_work
)) {
4420 * If the active work is either connect or sme-connect,
4421 * do not parallelize them with other radio works.
4423 wpa_dbg(active_work
->wpa_s
, MSG_DEBUG
,
4424 "Do not parallelize radio work with %s",
4429 dl_list_for_each(tmp
, &radio
->work
, struct wpa_radio_work
, list
) {
4434 * If connect or sme-connect are enqueued, parallelize only
4435 * those operations ahead of them in the queue.
4437 if (radio_work_is_connect(tmp
))
4440 /* Serialize parallel scan and p2p_scan operations on the same
4441 * interface since the driver_nl80211 mechanism for tracking
4442 * scan cookies does not yet have support for this. */
4443 if (active_work
->wpa_s
== tmp
->wpa_s
&&
4444 radio_work_is_scan(active_work
) &&
4445 radio_work_is_scan(tmp
)) {
4446 wpa_dbg(active_work
->wpa_s
, MSG_DEBUG
,
4447 "Do not start work '%s' when another work '%s' is already scheduled",
4448 tmp
->type
, active_work
->type
);
4452 * Check that the radio works are distinct and
4453 * on different bands.
4455 if (os_strcmp(active_work
->type
, tmp
->type
) != 0 &&
4456 (active_work
->bands
!= tmp
->bands
)) {
4458 * If a scan has to be scheduled through nl80211 scan
4459 * interface and if an external scan is already running,
4460 * do not schedule the scan since it is likely to get
4461 * rejected by kernel.
4463 if (os_strcmp(tmp
->type
, "scan") == 0 &&
4464 radio
->external_scan_running
&&
4465 (((struct wpa_driver_scan_params
*)
4466 tmp
->ctx
)->only_new_results
||
4467 tmp
->wpa_s
->clear_driver_scan_cache
))
4470 wpa_dbg(active_work
->wpa_s
, MSG_DEBUG
,
4471 "active_work:%s new_work:%s",
4472 active_work
->type
, tmp
->type
);
4477 /* Did not find a radio work to schedule in parallel. */
4482 static void radio_start_next_work(void *eloop_ctx
, void *timeout_ctx
)
4484 struct wpa_radio
*radio
= eloop_ctx
;
4485 struct wpa_radio_work
*work
;
4486 struct os_reltime now
, diff
;
4487 struct wpa_supplicant
*wpa_s
;
4489 work
= dl_list_first(&radio
->work
, struct wpa_radio_work
, list
);
4491 radio
->num_active_works
= 0;
4495 wpa_s
= dl_list_first(&radio
->ifaces
, struct wpa_supplicant
,
4499 wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS
)) {
4501 return; /* already started and still in progress */
4503 if (wpa_s
&& wpa_s
->radio
->external_scan_running
) {
4504 wpa_printf(MSG_DEBUG
, "Delay radio work start until externally triggered scan completes");
4509 if (radio
->num_active_works
< MAX_ACTIVE_WORKS
) {
4510 /* get the work to schedule next */
4511 work
= radio_work_get_next_work(radio
);
4517 wpa_s
= work
->wpa_s
;
4518 os_get_reltime(&now
);
4519 os_reltime_sub(&now
, &work
->time
, &diff
);
4520 wpa_dbg(wpa_s
, MSG_DEBUG
,
4521 "Starting radio work '%s'@%p after %ld.%06ld second wait",
4522 work
->type
, work
, diff
.sec
, diff
.usec
);
4525 radio
->num_active_works
++;
4529 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS
) &&
4530 radio
->num_active_works
< MAX_ACTIVE_WORKS
)
4531 radio_work_check_next(wpa_s
);
4536 * This function removes both started and pending radio works running on
4537 * the provided interface's radio.
4538 * Prior to the removal of the radio work, its callback (cb) is called with
4539 * deinit set to be 1. Each work's callback is responsible for clearing its
4540 * internal data and restoring to a correct state.
4541 * @wpa_s: wpa_supplicant data
4542 * @type: type of works to be removed
4543 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
4544 * this interface's works.
4546 void radio_remove_works(struct wpa_supplicant
*wpa_s
,
4547 const char *type
, int remove_all
)
4549 struct wpa_radio_work
*work
, *tmp
;
4550 struct wpa_radio
*radio
= wpa_s
->radio
;
4552 dl_list_for_each_safe(work
, tmp
, &radio
->work
, struct wpa_radio_work
,
4554 if (type
&& os_strcmp(type
, work
->type
) != 0)
4557 /* skip other ifaces' works */
4558 if (!remove_all
&& work
->wpa_s
!= wpa_s
)
4561 wpa_dbg(wpa_s
, MSG_DEBUG
, "Remove radio work '%s'@%p%s",
4562 work
->type
, work
, work
->started
? " (started)" : "");
4564 radio_work_free(work
);
4567 /* in case we removed the started work */
4568 radio_work_check_next(wpa_s
);
4572 static void radio_remove_interface(struct wpa_supplicant
*wpa_s
)
4574 struct wpa_radio
*radio
= wpa_s
->radio
;
4579 wpa_printf(MSG_DEBUG
, "Remove interface %s from radio %s",
4580 wpa_s
->ifname
, radio
->name
);
4581 dl_list_del(&wpa_s
->radio_list
);
4582 radio_remove_works(wpa_s
, NULL
, 0);
4583 wpa_s
->radio
= NULL
;
4584 if (!dl_list_empty(&radio
->ifaces
))
4585 return; /* Interfaces remain for this radio */
4587 wpa_printf(MSG_DEBUG
, "Remove radio %s", radio
->name
);
4588 eloop_cancel_timeout(radio_start_next_work
, radio
, NULL
);
4593 void radio_work_check_next(struct wpa_supplicant
*wpa_s
)
4595 struct wpa_radio
*radio
= wpa_s
->radio
;
4597 if (dl_list_empty(&radio
->work
))
4599 if (wpa_s
->ext_work_in_progress
) {
4600 wpa_printf(MSG_DEBUG
,
4601 "External radio work in progress - delay start of pending item");
4604 eloop_cancel_timeout(radio_start_next_work
, radio
, NULL
);
4605 eloop_register_timeout(0, 0, radio_start_next_work
, radio
, NULL
);
4610 * radio_add_work - Add a radio work item
4611 * @wpa_s: Pointer to wpa_supplicant data
4612 * @freq: Frequency of the offchannel operation in MHz or 0
4613 * @type: Unique identifier for each type of work
4614 * @next: Force as the next work to be executed
4615 * @cb: Callback function for indicating when radio is available
4616 * @ctx: Context pointer for the work (work->ctx in cb())
4617 * Returns: 0 on success, -1 on failure
4619 * This function is used to request time for an operation that requires
4620 * exclusive radio control. Once the radio is available, the registered callback
4621 * function will be called. radio_work_done() must be called once the exclusive
4622 * radio operation has been completed, so that the radio is freed for other
4623 * operations. The special case of deinit=1 is used to free the context data
4624 * during interface removal. That does not allow the callback function to start
4625 * the radio operation, i.e., it must free any resources allocated for the radio
4628 * The @freq parameter can be used to indicate a single channel on which the
4629 * offchannel operation will occur. This may allow multiple radio work
4630 * operations to be performed in parallel if they apply for the same channel.
4631 * Setting this to 0 indicates that the work item may use multiple channels or
4632 * requires exclusive control of the radio.
4634 int radio_add_work(struct wpa_supplicant
*wpa_s
, unsigned int freq
,
4635 const char *type
, int next
,
4636 void (*cb
)(struct wpa_radio_work
*work
, int deinit
),
4639 struct wpa_radio
*radio
= wpa_s
->radio
;
4640 struct wpa_radio_work
*work
;
4643 work
= os_zalloc(sizeof(*work
));
4646 wpa_dbg(wpa_s
, MSG_DEBUG
, "Add radio work '%s'@%p", type
, work
);
4647 os_get_reltime(&work
->time
);
4650 work
->wpa_s
= wpa_s
;
4655 work
->bands
= wpas_freq_to_band(freq
);
4656 else if (os_strcmp(type
, "scan") == 0 ||
4657 os_strcmp(type
, "p2p-scan") == 0)
4658 work
->bands
= wpas_get_bands(wpa_s
,
4659 ((struct wpa_driver_scan_params
*)
4662 work
->bands
= wpas_get_bands(wpa_s
, NULL
);
4664 was_empty
= dl_list_empty(&wpa_s
->radio
->work
);
4666 dl_list_add(&wpa_s
->radio
->work
, &work
->list
);
4668 dl_list_add_tail(&wpa_s
->radio
->work
, &work
->list
);
4670 wpa_dbg(wpa_s
, MSG_DEBUG
, "First radio work item in the queue - schedule start immediately");
4671 radio_work_check_next(wpa_s
);
4672 } else if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS
)
4673 && radio
->num_active_works
< MAX_ACTIVE_WORKS
) {
4674 wpa_dbg(wpa_s
, MSG_DEBUG
,
4675 "Try to schedule a radio work (num_active_works=%u)",
4676 radio
->num_active_works
);
4677 radio_work_check_next(wpa_s
);
4685 * radio_work_done - Indicate that a radio work item has been completed
4686 * @work: Completed work
4688 * This function is called once the callback function registered with
4689 * radio_add_work() has completed its work.
4691 void radio_work_done(struct wpa_radio_work
*work
)
4693 struct wpa_supplicant
*wpa_s
= work
->wpa_s
;
4694 struct os_reltime now
, diff
;
4695 unsigned int started
= work
->started
;
4697 os_get_reltime(&now
);
4698 os_reltime_sub(&now
, &work
->time
, &diff
);
4699 wpa_dbg(wpa_s
, MSG_DEBUG
, "Radio work '%s'@%p %s in %ld.%06ld seconds",
4700 work
->type
, work
, started
? "done" : "canceled",
4701 diff
.sec
, diff
.usec
);
4702 radio_work_free(work
);
4704 radio_work_check_next(wpa_s
);
4708 struct wpa_radio_work
*
4709 radio_work_pending(struct wpa_supplicant
*wpa_s
, const char *type
)
4711 struct wpa_radio_work
*work
;
4712 struct wpa_radio
*radio
= wpa_s
->radio
;
4714 dl_list_for_each(work
, &radio
->work
, struct wpa_radio_work
, list
) {
4715 if (work
->wpa_s
== wpa_s
&& os_strcmp(work
->type
, type
) == 0)
4723 static int wpas_init_driver(struct wpa_supplicant
*wpa_s
,
4724 struct wpa_interface
*iface
)
4726 const char *ifname
, *driver
, *rn
;
4728 driver
= iface
->driver
;
4730 if (wpa_supplicant_set_driver(wpa_s
, driver
) < 0)
4733 wpa_s
->drv_priv
= wpa_drv_init(wpa_s
, wpa_s
->ifname
);
4734 if (wpa_s
->drv_priv
== NULL
) {
4736 pos
= driver
? os_strchr(driver
, ',') : NULL
;
4738 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize "
4739 "driver interface - try next driver wrapper");
4743 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to initialize driver "
4747 if (wpa_drv_set_param(wpa_s
, wpa_s
->conf
->driver_param
) < 0) {
4748 wpa_msg(wpa_s
, MSG_ERROR
, "Driver interface rejected "
4749 "driver_param '%s'", wpa_s
->conf
->driver_param
);
4753 ifname
= wpa_drv_get_ifname(wpa_s
);
4754 if (ifname
&& os_strcmp(ifname
, wpa_s
->ifname
) != 0) {
4755 wpa_dbg(wpa_s
, MSG_DEBUG
, "Driver interface replaced "
4756 "interface name with '%s'", ifname
);
4757 os_strlcpy(wpa_s
->ifname
, ifname
, sizeof(wpa_s
->ifname
));
4760 rn
= wpa_driver_get_radio_name(wpa_s
);
4761 if (rn
&& rn
[0] == '\0')
4764 wpa_s
->radio
= radio_add_interface(wpa_s
, rn
);
4765 if (wpa_s
->radio
== NULL
)
4772 static int wpa_supplicant_init_iface(struct wpa_supplicant
*wpa_s
,
4773 struct wpa_interface
*iface
)
4775 struct wpa_driver_capa capa
;
4778 wpa_printf(MSG_DEBUG
, "Initializing interface '%s' conf '%s' driver "
4779 "'%s' ctrl_interface '%s' bridge '%s'", iface
->ifname
,
4780 iface
->confname
? iface
->confname
: "N/A",
4781 iface
->driver
? iface
->driver
: "default",
4782 iface
->ctrl_interface
? iface
->ctrl_interface
: "N/A",
4783 iface
->bridge_ifname
? iface
->bridge_ifname
: "N/A");
4785 if (iface
->confname
) {
4786 #ifdef CONFIG_BACKEND_FILE
4787 wpa_s
->confname
= os_rel2abs_path(iface
->confname
);
4788 if (wpa_s
->confname
== NULL
) {
4789 wpa_printf(MSG_ERROR
, "Failed to get absolute path "
4790 "for configuration file '%s'.",
4794 wpa_printf(MSG_DEBUG
, "Configuration file '%s' -> '%s'",
4795 iface
->confname
, wpa_s
->confname
);
4796 #else /* CONFIG_BACKEND_FILE */
4797 wpa_s
->confname
= os_strdup(iface
->confname
);
4798 #endif /* CONFIG_BACKEND_FILE */
4799 wpa_s
->conf
= wpa_config_read(wpa_s
->confname
, NULL
);
4800 if (wpa_s
->conf
== NULL
) {
4801 wpa_printf(MSG_ERROR
, "Failed to read or parse "
4802 "configuration '%s'.", wpa_s
->confname
);
4805 wpa_s
->confanother
= os_rel2abs_path(iface
->confanother
);
4806 wpa_config_read(wpa_s
->confanother
, wpa_s
->conf
);
4809 * Override ctrl_interface and driver_param if set on command
4812 if (iface
->ctrl_interface
) {
4813 os_free(wpa_s
->conf
->ctrl_interface
);
4814 wpa_s
->conf
->ctrl_interface
=
4815 os_strdup(iface
->ctrl_interface
);
4818 if (iface
->driver_param
) {
4819 os_free(wpa_s
->conf
->driver_param
);
4820 wpa_s
->conf
->driver_param
=
4821 os_strdup(iface
->driver_param
);
4824 if (iface
->p2p_mgmt
&& !iface
->ctrl_interface
) {
4825 os_free(wpa_s
->conf
->ctrl_interface
);
4826 wpa_s
->conf
->ctrl_interface
= NULL
;
4829 wpa_s
->conf
= wpa_config_alloc_empty(iface
->ctrl_interface
,
4830 iface
->driver_param
);
4832 if (wpa_s
->conf
== NULL
) {
4833 wpa_printf(MSG_ERROR
, "\nNo configuration found.");
4837 if (iface
->ifname
== NULL
) {
4838 wpa_printf(MSG_ERROR
, "\nInterface name is required.");
4841 if (os_strlen(iface
->ifname
) >= sizeof(wpa_s
->ifname
)) {
4842 wpa_printf(MSG_ERROR
, "\nToo long interface name '%s'.",
4846 os_strlcpy(wpa_s
->ifname
, iface
->ifname
, sizeof(wpa_s
->ifname
));
4848 if (iface
->bridge_ifname
) {
4849 if (os_strlen(iface
->bridge_ifname
) >=
4850 sizeof(wpa_s
->bridge_ifname
)) {
4851 wpa_printf(MSG_ERROR
, "\nToo long bridge interface "
4852 "name '%s'.", iface
->bridge_ifname
);
4855 os_strlcpy(wpa_s
->bridge_ifname
, iface
->bridge_ifname
,
4856 sizeof(wpa_s
->bridge_ifname
));
4859 /* RSNA Supplicant Key Management - INITIALIZE */
4860 eapol_sm_notify_portEnabled(wpa_s
->eapol
, FALSE
);
4861 eapol_sm_notify_portValid(wpa_s
->eapol
, FALSE
);
4863 /* Initialize driver interface and register driver event handler before
4864 * L2 receive handler so that association events are processed before
4865 * EAPOL-Key packets if both become available for the same select()
4867 if (wpas_init_driver(wpa_s
, iface
) < 0)
4870 if (wpa_supplicant_init_wpa(wpa_s
) < 0)
4873 wpa_sm_set_ifname(wpa_s
->wpa
, wpa_s
->ifname
,
4874 wpa_s
->bridge_ifname
[0] ? wpa_s
->bridge_ifname
:
4876 wpa_sm_set_fast_reauth(wpa_s
->wpa
, wpa_s
->conf
->fast_reauth
);
4878 if (wpa_s
->conf
->dot11RSNAConfigPMKLifetime
&&
4879 wpa_sm_set_param(wpa_s
->wpa
, RSNA_PMK_LIFETIME
,
4880 wpa_s
->conf
->dot11RSNAConfigPMKLifetime
)) {
4881 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
4882 "dot11RSNAConfigPMKLifetime");
4886 if (wpa_s
->conf
->dot11RSNAConfigPMKReauthThreshold
&&
4887 wpa_sm_set_param(wpa_s
->wpa
, RSNA_PMK_REAUTH_THRESHOLD
,
4888 wpa_s
->conf
->dot11RSNAConfigPMKReauthThreshold
)) {
4889 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
4890 "dot11RSNAConfigPMKReauthThreshold");
4894 if (wpa_s
->conf
->dot11RSNAConfigSATimeout
&&
4895 wpa_sm_set_param(wpa_s
->wpa
, RSNA_SA_TIMEOUT
,
4896 wpa_s
->conf
->dot11RSNAConfigSATimeout
)) {
4897 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
4898 "dot11RSNAConfigSATimeout");
4902 wpa_s
->hw
.modes
= wpa_drv_get_hw_feature_data(wpa_s
,
4903 &wpa_s
->hw
.num_modes
,
4905 if (wpa_s
->hw
.modes
) {
4908 for (i
= 0; i
< wpa_s
->hw
.num_modes
; i
++) {
4909 if (wpa_s
->hw
.modes
[i
].vht_capab
) {
4910 wpa_s
->hw_capab
= CAPAB_VHT
;
4914 if (wpa_s
->hw
.modes
[i
].ht_capab
&
4915 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET
)
4916 wpa_s
->hw_capab
= CAPAB_HT40
;
4917 else if (wpa_s
->hw
.modes
[i
].ht_capab
&&
4918 wpa_s
->hw_capab
== CAPAB_NO_HT_VHT
)
4919 wpa_s
->hw_capab
= CAPAB_HT
;
4923 capa_res
= wpa_drv_get_capa(wpa_s
, &capa
);
4924 if (capa_res
== 0) {
4925 wpa_s
->drv_capa_known
= 1;
4926 wpa_s
->drv_flags
= capa
.flags
;
4927 wpa_s
->drv_enc
= capa
.enc
;
4928 wpa_s
->drv_smps_modes
= capa
.smps_modes
;
4929 wpa_s
->drv_rrm_flags
= capa
.rrm_flags
;
4930 wpa_s
->probe_resp_offloads
= capa
.probe_resp_offloads
;
4931 wpa_s
->max_scan_ssids
= capa
.max_scan_ssids
;
4932 wpa_s
->max_sched_scan_ssids
= capa
.max_sched_scan_ssids
;
4933 wpa_s
->max_sched_scan_plans
= capa
.max_sched_scan_plans
;
4934 wpa_s
->max_sched_scan_plan_interval
=
4935 capa
.max_sched_scan_plan_interval
;
4936 wpa_s
->max_sched_scan_plan_iterations
=
4937 capa
.max_sched_scan_plan_iterations
;
4938 wpa_s
->sched_scan_supported
= capa
.sched_scan_supported
;
4939 wpa_s
->max_match_sets
= capa
.max_match_sets
;
4940 wpa_s
->max_remain_on_chan
= capa
.max_remain_on_chan
;
4941 wpa_s
->max_stations
= capa
.max_stations
;
4942 wpa_s
->extended_capa
= capa
.extended_capa
;
4943 wpa_s
->extended_capa_mask
= capa
.extended_capa_mask
;
4944 wpa_s
->extended_capa_len
= capa
.extended_capa_len
;
4945 wpa_s
->num_multichan_concurrent
=
4946 capa
.num_multichan_concurrent
;
4947 wpa_s
->wmm_ac_supported
= capa
.wmm_ac_supported
;
4949 if (capa
.mac_addr_rand_scan_supported
)
4950 wpa_s
->mac_addr_rand_supported
|= MAC_ADDR_RAND_SCAN
;
4951 if (wpa_s
->sched_scan_supported
&&
4952 capa
.mac_addr_rand_sched_scan_supported
)
4953 wpa_s
->mac_addr_rand_supported
|=
4954 (MAC_ADDR_RAND_SCHED_SCAN
| MAC_ADDR_RAND_PNO
);
4956 if (wpa_s
->max_remain_on_chan
== 0)
4957 wpa_s
->max_remain_on_chan
= 1000;
4960 * Only take p2p_mgmt parameters when P2P Device is supported.
4961 * Doing it here as it determines whether l2_packet_init() will be done
4962 * during wpa_supplicant_driver_init().
4964 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
)
4965 wpa_s
->p2p_mgmt
= iface
->p2p_mgmt
;
4967 iface
->p2p_mgmt
= 1;
4969 if (wpa_s
->num_multichan_concurrent
== 0)
4970 wpa_s
->num_multichan_concurrent
= 1;
4972 if (wpa_supplicant_driver_init(wpa_s
) < 0)
4976 if ((!iface
->p2p_mgmt
||
4977 !(wpa_s
->drv_flags
&
4978 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
)) &&
4979 wpa_tdls_init(wpa_s
->wpa
))
4981 #endif /* CONFIG_TDLS */
4983 if (wpa_s
->conf
->country
[0] && wpa_s
->conf
->country
[1] &&
4984 wpa_drv_set_country(wpa_s
, wpa_s
->conf
->country
)) {
4985 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to set country");
4990 if (wpa_s
->conf
->fst_group_id
) {
4991 struct fst_iface_cfg cfg
;
4992 struct fst_wpa_obj iface_obj
;
4994 fst_wpa_supplicant_fill_iface_obj(wpa_s
, &iface_obj
);
4995 os_strlcpy(cfg
.group_id
, wpa_s
->conf
->fst_group_id
,
4996 sizeof(cfg
.group_id
));
4997 cfg
.priority
= wpa_s
->conf
->fst_priority
;
4998 cfg
.llt
= wpa_s
->conf
->fst_llt
;
5000 wpa_s
->fst
= fst_attach(wpa_s
->ifname
, wpa_s
->own_addr
,
5003 wpa_msg(wpa_s
, MSG_ERROR
,
5004 "FST: Cannot attach iface %s to group %s",
5005 wpa_s
->ifname
, cfg
.group_id
);
5009 #endif /* CONFIG_FST */
5011 if (wpas_wps_init(wpa_s
))
5014 if (wpa_supplicant_init_eapol(wpa_s
) < 0)
5016 wpa_sm_set_eapol(wpa_s
->wpa
, wpa_s
->eapol
);
5018 wpa_s
->ctrl_iface
= wpa_supplicant_ctrl_iface_init(wpa_s
);
5019 if (wpa_s
->ctrl_iface
== NULL
) {
5020 wpa_printf(MSG_ERROR
,
5021 "Failed to initialize control interface '%s'.\n"
5022 "You may have another wpa_supplicant process "
5023 "already running or the file was\n"
5024 "left by an unclean termination of wpa_supplicant "
5025 "in which case you will need\n"
5026 "to manually remove this file before starting "
5027 "wpa_supplicant again.\n",
5028 wpa_s
->conf
->ctrl_interface
);
5032 wpa_s
->gas
= gas_query_init(wpa_s
);
5033 if (wpa_s
->gas
== NULL
) {
5034 wpa_printf(MSG_ERROR
, "Failed to initialize GAS query");
5038 if (iface
->p2p_mgmt
&& wpas_p2p_init(wpa_s
->global
, wpa_s
) < 0) {
5039 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to init P2P");
5043 if (wpa_bss_init(wpa_s
) < 0)
5046 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL
5048 dl_list_init(&wpa_s
->mesh_external_pmksa_cache
);
5049 #endif /* CONFIG_MESH */
5050 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */
5053 * Set Wake-on-WLAN triggers, if configured.
5054 * Note: We don't restore/remove the triggers on shutdown (it doesn't
5055 * have effect anyway when the interface is down).
5057 if (capa_res
== 0 && wpas_set_wowlan_triggers(wpa_s
, &capa
) < 0)
5060 #ifdef CONFIG_EAP_PROXY
5063 wpa_s
->mnc_len
= eapol_sm_get_eap_proxy_imsi(wpa_s
->eapol
, wpa_s
->imsi
,
5065 if (wpa_s
->mnc_len
> 0) {
5066 wpa_s
->imsi
[len
] = '\0';
5067 wpa_printf(MSG_DEBUG
, "eap_proxy: IMSI %s (MNC length %d)",
5068 wpa_s
->imsi
, wpa_s
->mnc_len
);
5070 wpa_printf(MSG_DEBUG
, "eap_proxy: IMSI not available");
5073 #endif /* CONFIG_EAP_PROXY */
5075 if (pcsc_reader_init(wpa_s
) < 0)
5078 if (wpas_init_ext_pw(wpa_s
) < 0)
5081 wpas_rrm_reset(wpa_s
);
5083 wpas_sched_scan_plans_set(wpa_s
, wpa_s
->conf
->sched_scan_plans
);
5087 #endif /* CONFIG_HS20 */
5089 wpas_mbo_update_non_pref_chan(wpa_s
, wpa_s
->conf
->non_pref_chan
);
5090 #endif /* CONFIG_MBO */
5092 wpa_supplicant_set_default_scan_ies(wpa_s
);
5098 static void wpa_supplicant_deinit_iface(struct wpa_supplicant
*wpa_s
,
5099 int notify
, int terminate
)
5101 struct wpa_global
*global
= wpa_s
->global
;
5102 struct wpa_supplicant
*iface
, *prev
;
5104 if (wpa_s
== wpa_s
->parent
)
5105 wpas_p2p_group_remove(wpa_s
, "*");
5107 iface
= global
->ifaces
;
5109 if (iface
->p2pdev
== wpa_s
)
5110 iface
->p2pdev
= iface
->parent
;
5111 if (iface
== wpa_s
|| iface
->parent
!= wpa_s
) {
5112 iface
= iface
->next
;
5115 wpa_printf(MSG_DEBUG
,
5116 "Remove remaining child interface %s from parent %s",
5117 iface
->ifname
, wpa_s
->ifname
);
5119 iface
= iface
->next
;
5120 wpa_supplicant_remove_iface(global
, prev
, terminate
);
5123 wpa_s
->disconnected
= 1;
5124 if (wpa_s
->drv_priv
) {
5125 wpa_supplicant_deauthenticate(wpa_s
,
5126 WLAN_REASON_DEAUTH_LEAVING
);
5128 wpa_drv_set_countermeasures(wpa_s
, 0);
5129 wpa_clear_keys(wpa_s
, NULL
);
5132 wpa_supplicant_cleanup(wpa_s
);
5133 wpas_p2p_deinit_iface(wpa_s
);
5135 wpas_ctrl_radio_work_flush(wpa_s
);
5136 radio_remove_interface(wpa_s
);
5140 fst_detach(wpa_s
->fst
);
5143 if (wpa_s
->received_mb_ies
) {
5144 wpabuf_free(wpa_s
->received_mb_ies
);
5145 wpa_s
->received_mb_ies
= NULL
;
5147 #endif /* CONFIG_FST */
5149 if (wpa_s
->drv_priv
)
5150 wpa_drv_deinit(wpa_s
);
5153 wpas_notify_iface_removed(wpa_s
);
5156 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_TERMINATING
);
5158 if (wpa_s
->ctrl_iface
) {
5159 wpa_supplicant_ctrl_iface_deinit(wpa_s
->ctrl_iface
);
5160 wpa_s
->ctrl_iface
= NULL
;
5165 wpa_supplicant_mesh_iface_deinit(wpa_s
, wpa_s
->ifmsh
);
5166 wpa_s
->ifmsh
= NULL
;
5168 #endif /* CONFIG_MESH */
5170 if (wpa_s
->conf
!= NULL
) {
5171 wpa_config_free(wpa_s
->conf
);
5175 os_free(wpa_s
->ssids_from_scan_req
);
5181 #ifdef CONFIG_MATCH_IFACE
5184 * wpa_supplicant_match_iface - Match an interface description to a name
5185 * @global: Pointer to global data from wpa_supplicant_init()
5186 * @ifname: Name of the interface to match
5187 * Returns: Pointer to the created interface description or %NULL on failure
5189 struct wpa_interface
* wpa_supplicant_match_iface(struct wpa_global
*global
,
5193 struct wpa_interface
*iface
, *miface
;
5195 for (i
= 0; i
< global
->params
.match_iface_count
; i
++) {
5196 miface
= &global
->params
.match_ifaces
[i
];
5197 if (!miface
->ifname
||
5198 fnmatch(miface
->ifname
, ifname
, 0) == 0) {
5199 iface
= os_zalloc(sizeof(*iface
));
5203 iface
->ifname
= ifname
;
5213 * wpa_supplicant_match_existing - Match existing interfaces
5214 * @global: Pointer to global data from wpa_supplicant_init()
5215 * Returns: 0 on success, -1 on failure
5217 static int wpa_supplicant_match_existing(struct wpa_global
*global
)
5219 struct if_nameindex
*ifi
, *ifp
;
5220 struct wpa_supplicant
*wpa_s
;
5221 struct wpa_interface
*iface
;
5223 ifp
= if_nameindex();
5225 wpa_printf(MSG_ERROR
, "if_nameindex: %s", strerror(errno
));
5229 for (ifi
= ifp
; ifi
->if_name
; ifi
++) {
5230 wpa_s
= wpa_supplicant_get_iface(global
, ifi
->if_name
);
5233 iface
= wpa_supplicant_match_iface(global
, ifi
->if_name
);
5235 wpa_s
= wpa_supplicant_add_iface(global
, iface
, NULL
);
5242 if_freenameindex(ifp
);
5246 #endif /* CONFIG_MATCH_IFACE */
5250 * wpa_supplicant_add_iface - Add a new network interface
5251 * @global: Pointer to global data from wpa_supplicant_init()
5252 * @iface: Interface configuration options
5253 * @parent: Parent interface or %NULL to assign new interface as parent
5254 * Returns: Pointer to the created interface or %NULL on failure
5256 * This function is used to add new network interfaces for %wpa_supplicant.
5257 * This can be called before wpa_supplicant_run() to add interfaces before the
5258 * main event loop has been started. In addition, new interfaces can be added
5259 * dynamically while %wpa_supplicant is already running. This could happen,
5260 * e.g., when a hotplug network adapter is inserted.
5262 struct wpa_supplicant
* wpa_supplicant_add_iface(struct wpa_global
*global
,
5263 struct wpa_interface
*iface
,
5264 struct wpa_supplicant
*parent
)
5266 struct wpa_supplicant
*wpa_s
;
5267 struct wpa_interface t_iface
;
5268 struct wpa_ssid
*ssid
;
5270 if (global
== NULL
|| iface
== NULL
)
5273 wpa_s
= wpa_supplicant_alloc(parent
);
5277 wpa_s
->global
= global
;
5280 if (global
->params
.override_driver
) {
5281 wpa_printf(MSG_DEBUG
, "Override interface parameter: driver "
5283 iface
->driver
, global
->params
.override_driver
);
5284 t_iface
.driver
= global
->params
.override_driver
;
5286 if (global
->params
.override_ctrl_interface
) {
5287 wpa_printf(MSG_DEBUG
, "Override interface parameter: "
5288 "ctrl_interface ('%s' -> '%s')",
5289 iface
->ctrl_interface
,
5290 global
->params
.override_ctrl_interface
);
5291 t_iface
.ctrl_interface
=
5292 global
->params
.override_ctrl_interface
;
5294 if (wpa_supplicant_init_iface(wpa_s
, &t_iface
)) {
5295 wpa_printf(MSG_DEBUG
, "Failed to add interface %s",
5297 wpa_supplicant_deinit_iface(wpa_s
, 0, 0);
5301 if (iface
->p2p_mgmt
== 0) {
5302 /* Notify the control interfaces about new iface */
5303 if (wpas_notify_iface_added(wpa_s
)) {
5304 wpa_supplicant_deinit_iface(wpa_s
, 1, 0);
5308 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
5309 wpas_notify_network_added(wpa_s
, ssid
);
5312 wpa_s
->next
= global
->ifaces
;
5313 global
->ifaces
= wpa_s
;
5315 wpa_dbg(wpa_s
, MSG_DEBUG
, "Added interface %s", wpa_s
->ifname
);
5316 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
5319 if (wpa_s
->global
->p2p
== NULL
&&
5320 !wpa_s
->global
->p2p_disabled
&& !wpa_s
->conf
->p2p_disabled
&&
5321 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
) &&
5322 wpas_p2p_add_p2pdev_interface(
5323 wpa_s
, wpa_s
->global
->params
.conf_p2p_dev
) < 0) {
5324 wpa_printf(MSG_INFO
,
5325 "P2P: Failed to enable P2P Device interface");
5326 /* Try to continue without. P2P will be disabled. */
5328 #endif /* CONFIG_P2P */
5335 * wpa_supplicant_remove_iface - Remove a network interface
5336 * @global: Pointer to global data from wpa_supplicant_init()
5337 * @wpa_s: Pointer to the network interface to be removed
5338 * Returns: 0 if interface was removed, -1 if interface was not found
5340 * This function can be used to dynamically remove network interfaces from
5341 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
5342 * addition, this function is used to remove all remaining interfaces when
5343 * %wpa_supplicant is terminated.
5345 int wpa_supplicant_remove_iface(struct wpa_global
*global
,
5346 struct wpa_supplicant
*wpa_s
,
5349 struct wpa_supplicant
*prev
;
5351 unsigned int mesh_if_created
= wpa_s
->mesh_if_created
;
5352 char *ifname
= NULL
;
5353 struct wpa_supplicant
*parent
= wpa_s
->parent
;
5354 #endif /* CONFIG_MESH */
5356 /* Remove interface from the global list of interfaces */
5357 prev
= global
->ifaces
;
5358 if (prev
== wpa_s
) {
5359 global
->ifaces
= wpa_s
->next
;
5361 while (prev
&& prev
->next
!= wpa_s
)
5365 prev
->next
= wpa_s
->next
;
5368 wpa_dbg(wpa_s
, MSG_DEBUG
, "Removing interface %s", wpa_s
->ifname
);
5371 if (mesh_if_created
) {
5372 ifname
= os_strdup(wpa_s
->ifname
);
5373 if (ifname
== NULL
) {
5374 wpa_dbg(wpa_s
, MSG_ERROR
,
5375 "mesh: Failed to malloc ifname");
5379 #endif /* CONFIG_MESH */
5381 if (global
->p2p_group_formation
== wpa_s
)
5382 global
->p2p_group_formation
= NULL
;
5383 if (global
->p2p_invite_group
== wpa_s
)
5384 global
->p2p_invite_group
= NULL
;
5385 wpa_supplicant_deinit_iface(wpa_s
, 1, terminate
);
5388 if (mesh_if_created
) {
5389 wpa_drv_if_remove(parent
, WPA_IF_MESH
, ifname
);
5392 #endif /* CONFIG_MESH */
5399 * wpa_supplicant_get_eap_mode - Get the current EAP mode
5400 * @wpa_s: Pointer to the network interface
5401 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
5403 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant
*wpa_s
)
5405 const char *eapol_method
;
5407 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) == 0 &&
5408 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
5412 eapol_method
= eapol_sm_get_method_name(wpa_s
->eapol
);
5413 if (eapol_method
== NULL
)
5414 return "UNKNOWN-EAP";
5416 return eapol_method
;
5421 * wpa_supplicant_get_iface - Get a new network interface
5422 * @global: Pointer to global data from wpa_supplicant_init()
5423 * @ifname: Interface name
5424 * Returns: Pointer to the interface or %NULL if not found
5426 struct wpa_supplicant
* wpa_supplicant_get_iface(struct wpa_global
*global
,
5429 struct wpa_supplicant
*wpa_s
;
5431 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
5432 if (os_strcmp(wpa_s
->ifname
, ifname
) == 0)
5439 #ifndef CONFIG_NO_WPA_MSG
5440 static const char * wpa_supplicant_msg_ifname_cb(void *ctx
)
5442 struct wpa_supplicant
*wpa_s
= ctx
;
5445 return wpa_s
->ifname
;
5447 #endif /* CONFIG_NO_WPA_MSG */
5450 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL
5451 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10
5452 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */
5454 /* Periodic cleanup tasks */
5455 static void wpas_periodic(void *eloop_ctx
, void *timeout_ctx
)
5457 struct wpa_global
*global
= eloop_ctx
;
5458 struct wpa_supplicant
*wpa_s
;
5460 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL
, 0,
5461 wpas_periodic
, global
, NULL
);
5465 p2p_expire_peers(global
->p2p
);
5466 #endif /* CONFIG_P2P */
5468 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
5469 wpa_bss_flush_by_age(wpa_s
, wpa_s
->conf
->bss_expiration_age
);
5472 #endif /* CONFIG_AP */
5478 * wpa_supplicant_init - Initialize %wpa_supplicant
5479 * @params: Parameters for %wpa_supplicant
5480 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
5482 * This function is used to initialize %wpa_supplicant. After successful
5483 * initialization, the returned data pointer can be used to add and remove
5484 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
5486 struct wpa_global
* wpa_supplicant_init(struct wpa_params
*params
)
5488 struct wpa_global
*global
;
5494 #ifdef CONFIG_DRIVER_NDIS
5496 void driver_ndis_init_ops(void);
5497 driver_ndis_init_ops();
5499 #endif /* CONFIG_DRIVER_NDIS */
5501 #ifndef CONFIG_NO_WPA_MSG
5502 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb
);
5503 #endif /* CONFIG_NO_WPA_MSG */
5505 if (params
->wpa_debug_file_path
)
5506 wpa_debug_open_file(params
->wpa_debug_file_path
);
5508 wpa_debug_setup_stdout();
5509 if (params
->wpa_debug_syslog
)
5510 wpa_debug_open_syslog();
5511 if (params
->wpa_debug_tracing
) {
5512 ret
= wpa_debug_open_linux_tracing();
5514 wpa_printf(MSG_ERROR
,
5515 "Failed to enable trace logging");
5520 ret
= eap_register_methods();
5522 wpa_printf(MSG_ERROR
, "Failed to register EAP methods");
5524 wpa_printf(MSG_ERROR
, "Two or more EAP methods used "
5525 "the same EAP type.");
5529 global
= os_zalloc(sizeof(*global
));
5532 dl_list_init(&global
->p2p_srv_bonjour
);
5533 dl_list_init(&global
->p2p_srv_upnp
);
5534 global
->params
.daemonize
= params
->daemonize
;
5535 global
->params
.wait_for_monitor
= params
->wait_for_monitor
;
5536 global
->params
.dbus_ctrl_interface
= params
->dbus_ctrl_interface
;
5537 if (params
->pid_file
)
5538 global
->params
.pid_file
= os_strdup(params
->pid_file
);
5539 if (params
->ctrl_interface
)
5540 global
->params
.ctrl_interface
=
5541 os_strdup(params
->ctrl_interface
);
5542 if (params
->ctrl_interface_group
)
5543 global
->params
.ctrl_interface_group
=
5544 os_strdup(params
->ctrl_interface_group
);
5545 if (params
->override_driver
)
5546 global
->params
.override_driver
=
5547 os_strdup(params
->override_driver
);
5548 if (params
->override_ctrl_interface
)
5549 global
->params
.override_ctrl_interface
=
5550 os_strdup(params
->override_ctrl_interface
);
5551 #ifdef CONFIG_MATCH_IFACE
5552 global
->params
.match_iface_count
= params
->match_iface_count
;
5553 if (params
->match_iface_count
) {
5554 global
->params
.match_ifaces
=
5555 os_calloc(params
->match_iface_count
,
5556 sizeof(struct wpa_interface
));
5557 os_memcpy(global
->params
.match_ifaces
,
5558 params
->match_ifaces
,
5559 params
->match_iface_count
*
5560 sizeof(struct wpa_interface
));
5562 #endif /* CONFIG_MATCH_IFACE */
5564 if (params
->conf_p2p_dev
)
5565 global
->params
.conf_p2p_dev
=
5566 os_strdup(params
->conf_p2p_dev
);
5567 #endif /* CONFIG_P2P */
5568 wpa_debug_level
= global
->params
.wpa_debug_level
=
5569 params
->wpa_debug_level
;
5570 wpa_debug_show_keys
= global
->params
.wpa_debug_show_keys
=
5571 params
->wpa_debug_show_keys
;
5572 wpa_debug_timestamp
= global
->params
.wpa_debug_timestamp
=
5573 params
->wpa_debug_timestamp
;
5575 wpa_printf(MSG_DEBUG
, "wpa_supplicant v" VERSION_STR
);
5578 wpa_printf(MSG_ERROR
, "Failed to initialize event loop");
5579 wpa_supplicant_deinit(global
);
5583 random_init(params
->entropy_file
);
5585 global
->ctrl_iface
= wpa_supplicant_global_ctrl_iface_init(global
);
5586 if (global
->ctrl_iface
== NULL
) {
5587 wpa_supplicant_deinit(global
);
5591 if (wpas_notify_supplicant_initialized(global
)) {
5592 wpa_supplicant_deinit(global
);
5596 for (i
= 0; wpa_drivers
[i
]; i
++)
5597 global
->drv_count
++;
5598 if (global
->drv_count
== 0) {
5599 wpa_printf(MSG_ERROR
, "No drivers enabled");
5600 wpa_supplicant_deinit(global
);
5603 global
->drv_priv
= os_calloc(global
->drv_count
, sizeof(void *));
5604 if (global
->drv_priv
== NULL
) {
5605 wpa_supplicant_deinit(global
);
5609 #ifdef CONFIG_WIFI_DISPLAY
5610 if (wifi_display_init(global
) < 0) {
5611 wpa_printf(MSG_ERROR
, "Failed to initialize Wi-Fi Display");
5612 wpa_supplicant_deinit(global
);
5615 #endif /* CONFIG_WIFI_DISPLAY */
5617 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL
, 0,
5618 wpas_periodic
, global
, NULL
);
5625 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
5626 * @global: Pointer to global data from wpa_supplicant_init()
5627 * Returns: 0 after successful event loop run, -1 on failure
5629 * This function starts the main event loop and continues running as long as
5630 * there are any remaining events. In most cases, this function is running as
5631 * long as the %wpa_supplicant process in still in use.
5633 int wpa_supplicant_run(struct wpa_global
*global
)
5635 struct wpa_supplicant
*wpa_s
;
5637 if (global
->params
.daemonize
&&
5638 (wpa_supplicant_daemon(global
->params
.pid_file
) ||
5639 eloop_sock_requeue()))
5642 #ifdef CONFIG_MATCH_IFACE
5643 if (wpa_supplicant_match_existing(global
))
5647 if (global
->params
.wait_for_monitor
) {
5648 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
)
5649 if (wpa_s
->ctrl_iface
&& !wpa_s
->p2p_mgmt
)
5650 wpa_supplicant_ctrl_iface_wait(
5654 eloop_register_signal_terminate(wpa_supplicant_terminate
, global
);
5655 eloop_register_signal_reconfig(wpa_supplicant_reconfig
, global
);
5664 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
5665 * @global: Pointer to global data from wpa_supplicant_init()
5667 * This function is called to deinitialize %wpa_supplicant and to free all
5668 * allocated resources. Remaining network interfaces will also be removed.
5670 void wpa_supplicant_deinit(struct wpa_global
*global
)
5677 eloop_cancel_timeout(wpas_periodic
, global
, NULL
);
5679 #ifdef CONFIG_WIFI_DISPLAY
5680 wifi_display_deinit(global
);
5681 #endif /* CONFIG_WIFI_DISPLAY */
5683 while (global
->ifaces
)
5684 wpa_supplicant_remove_iface(global
, global
->ifaces
, 1);
5686 if (global
->ctrl_iface
)
5687 wpa_supplicant_global_ctrl_iface_deinit(global
->ctrl_iface
);
5689 wpas_notify_supplicant_deinitialized(global
);
5691 eap_peer_unregister_methods();
5693 eap_server_unregister_methods();
5694 #endif /* CONFIG_AP */
5696 for (i
= 0; wpa_drivers
[i
] && global
->drv_priv
; i
++) {
5697 if (!global
->drv_priv
[i
])
5699 wpa_drivers
[i
]->global_deinit(global
->drv_priv
[i
]);
5701 os_free(global
->drv_priv
);
5707 if (global
->params
.pid_file
) {
5708 os_daemonize_terminate(global
->params
.pid_file
);
5709 os_free(global
->params
.pid_file
);
5711 os_free(global
->params
.ctrl_interface
);
5712 os_free(global
->params
.ctrl_interface_group
);
5713 os_free(global
->params
.override_driver
);
5714 os_free(global
->params
.override_ctrl_interface
);
5715 #ifdef CONFIG_MATCH_IFACE
5716 os_free(global
->params
.match_ifaces
);
5717 #endif /* CONFIG_MATCH_IFACE */
5719 os_free(global
->params
.conf_p2p_dev
);
5720 #endif /* CONFIG_P2P */
5722 os_free(global
->p2p_disallow_freq
.range
);
5723 os_free(global
->p2p_go_avoid_freq
.range
);
5724 os_free(global
->add_psk
);
5727 wpa_debug_close_syslog();
5728 wpa_debug_close_file();
5729 wpa_debug_close_linux_tracing();
5733 void wpa_supplicant_update_config(struct wpa_supplicant
*wpa_s
)
5735 if ((wpa_s
->conf
->changed_parameters
& CFG_CHANGED_COUNTRY
) &&
5736 wpa_s
->conf
->country
[0] && wpa_s
->conf
->country
[1]) {
5738 country
[0] = wpa_s
->conf
->country
[0];
5739 country
[1] = wpa_s
->conf
->country
[1];
5741 if (wpa_drv_set_country(wpa_s
, country
) < 0) {
5742 wpa_printf(MSG_ERROR
, "Failed to set country code "
5747 if (wpa_s
->conf
->changed_parameters
& CFG_CHANGED_EXT_PW_BACKEND
)
5748 wpas_init_ext_pw(wpa_s
);
5750 if (wpa_s
->conf
->changed_parameters
& CFG_CHANGED_SCHED_SCAN_PLANS
)
5751 wpas_sched_scan_plans_set(wpa_s
, wpa_s
->conf
->sched_scan_plans
);
5754 wpas_wps_update_config(wpa_s
);
5755 #endif /* CONFIG_WPS */
5756 wpas_p2p_update_config(wpa_s
);
5757 wpa_s
->conf
->changed_parameters
= 0;
5761 void add_freq(int *freqs
, int *num_freqs
, int freq
)
5765 for (i
= 0; i
< *num_freqs
; i
++) {
5766 if (freqs
[i
] == freq
)
5770 freqs
[*num_freqs
] = freq
;
5775 static int * get_bss_freqs_in_ess(struct wpa_supplicant
*wpa_s
)
5777 struct wpa_bss
*bss
, *cbss
;
5778 const int max_freqs
= 10;
5782 freqs
= os_calloc(max_freqs
+ 1, sizeof(int));
5786 cbss
= wpa_s
->current_bss
;
5788 dl_list_for_each(bss
, &wpa_s
->bss
, struct wpa_bss
, list
) {
5791 if (bss
->ssid_len
== cbss
->ssid_len
&&
5792 os_memcmp(bss
->ssid
, cbss
->ssid
, bss
->ssid_len
) == 0 &&
5793 wpa_blacklist_get(wpa_s
, bss
->bssid
) == NULL
) {
5794 add_freq(freqs
, &num_freqs
, bss
->freq
);
5795 if (num_freqs
== max_freqs
)
5800 if (num_freqs
== 0) {
5809 void wpas_connection_failed(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
5815 wpas_connect_work_done(wpa_s
);
5818 * Remove possible authentication timeout since the connection failed.
5820 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
5823 * There is no point in blacklisting the AP if this event is
5824 * generated based on local request to disconnect.
5826 if (wpa_s
->own_disconnect_req
) {
5827 wpa_s
->own_disconnect_req
= 0;
5828 wpa_dbg(wpa_s
, MSG_DEBUG
,
5829 "Ignore connection failure due to local request to disconnect");
5832 if (wpa_s
->disconnected
) {
5833 wpa_dbg(wpa_s
, MSG_DEBUG
, "Ignore connection failure "
5834 "indication since interface has been put into "
5835 "disconnected state");
5840 * Add the failed BSSID into the blacklist and speed up next scan
5841 * attempt if there could be other APs that could accept association.
5842 * The current blacklist count indicates how many times we have tried
5843 * connecting to this AP and multiple attempts mean that other APs are
5844 * either not available or has already been tried, so that we can start
5845 * increasing the delay here to avoid constant scanning.
5847 count
= wpa_blacklist_add(wpa_s
, bssid
);
5848 if (count
== 1 && wpa_s
->current_bss
) {
5850 * This BSS was not in the blacklist before. If there is
5851 * another BSS available for the same ESS, we should try that
5852 * next. Otherwise, we may as well try this one once more
5853 * before allowing other, likely worse, ESSes to be considered.
5855 freqs
= get_bss_freqs_in_ess(wpa_s
);
5857 wpa_dbg(wpa_s
, MSG_DEBUG
, "Another BSS in this ESS "
5858 "has been seen; try it next");
5859 wpa_blacklist_add(wpa_s
, bssid
);
5861 * On the next scan, go through only the known channels
5862 * used in this ESS based on previous scans to speed up
5863 * common load balancing use case.
5865 os_free(wpa_s
->next_scan_freqs
);
5866 wpa_s
->next_scan_freqs
= freqs
;
5871 * Add previous failure count in case the temporary blacklist was
5872 * cleared due to no other BSSes being available.
5874 count
+= wpa_s
->extra_blacklist_count
;
5876 if (count
> 3 && wpa_s
->current_ssid
) {
5877 wpa_printf(MSG_DEBUG
, "Continuous association failures - "
5878 "consider temporary network disabling");
5879 wpas_auth_failed(wpa_s
, "CONN_FAILED");
5900 wpa_dbg(wpa_s
, MSG_DEBUG
, "Blacklist count %d --> request scan in %d "
5901 "ms", count
, timeout
);
5904 * TODO: if more than one possible AP is available in scan results,
5905 * could try the other ones before requesting a new scan.
5907 wpa_supplicant_req_scan(wpa_s
, timeout
/ 1000,
5908 1000 * (timeout
% 1000));
5912 int wpas_driver_bss_selection(struct wpa_supplicant
*wpa_s
)
5914 return wpa_s
->conf
->ap_scan
== 2 ||
5915 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_BSS_SELECTION
);
5919 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
5920 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant
*wpa_s
,
5921 struct wpa_ssid
*ssid
,
5925 #ifdef IEEE8021X_EAPOL
5926 struct eap_peer_config
*eap
= &ssid
->eap
;
5928 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: response handle field=%s", field
);
5929 wpa_hexdump_ascii_key(MSG_DEBUG
, "CTRL_IFACE: response value",
5930 (const u8
*) value
, os_strlen(value
));
5932 switch (wpa_supplicant_ctrl_req_from_string(field
)) {
5933 case WPA_CTRL_REQ_EAP_IDENTITY
:
5934 os_free(eap
->identity
);
5935 eap
->identity
= (u8
*) os_strdup(value
);
5936 eap
->identity_len
= os_strlen(value
);
5937 eap
->pending_req_identity
= 0;
5938 if (ssid
== wpa_s
->current_ssid
)
5939 wpa_s
->reassociate
= 1;
5941 case WPA_CTRL_REQ_EAP_PASSWORD
:
5942 bin_clear_free(eap
->password
, eap
->password_len
);
5943 eap
->password
= (u8
*) os_strdup(value
);
5944 eap
->password_len
= os_strlen(value
);
5945 eap
->pending_req_password
= 0;
5946 if (ssid
== wpa_s
->current_ssid
)
5947 wpa_s
->reassociate
= 1;
5949 case WPA_CTRL_REQ_EAP_NEW_PASSWORD
:
5950 bin_clear_free(eap
->new_password
, eap
->new_password_len
);
5951 eap
->new_password
= (u8
*) os_strdup(value
);
5952 eap
->new_password_len
= os_strlen(value
);
5953 eap
->pending_req_new_password
= 0;
5954 if (ssid
== wpa_s
->current_ssid
)
5955 wpa_s
->reassociate
= 1;
5957 case WPA_CTRL_REQ_EAP_PIN
:
5958 str_clear_free(eap
->pin
);
5959 eap
->pin
= os_strdup(value
);
5960 eap
->pending_req_pin
= 0;
5961 if (ssid
== wpa_s
->current_ssid
)
5962 wpa_s
->reassociate
= 1;
5964 case WPA_CTRL_REQ_EAP_OTP
:
5965 bin_clear_free(eap
->otp
, eap
->otp_len
);
5966 eap
->otp
= (u8
*) os_strdup(value
);
5967 eap
->otp_len
= os_strlen(value
);
5968 os_free(eap
->pending_req_otp
);
5969 eap
->pending_req_otp
= NULL
;
5970 eap
->pending_req_otp_len
= 0;
5972 case WPA_CTRL_REQ_EAP_PASSPHRASE
:
5973 str_clear_free(eap
->private_key_passwd
);
5974 eap
->private_key_passwd
= os_strdup(value
);
5975 eap
->pending_req_passphrase
= 0;
5976 if (ssid
== wpa_s
->current_ssid
)
5977 wpa_s
->reassociate
= 1;
5979 case WPA_CTRL_REQ_SIM
:
5980 str_clear_free(eap
->external_sim_resp
);
5981 eap
->external_sim_resp
= os_strdup(value
);
5982 eap
->pending_req_sim
= 0;
5984 case WPA_CTRL_REQ_PSK_PASSPHRASE
:
5985 if (wpa_config_set(ssid
, "psk", value
, 0) < 0)
5987 ssid
->mem_only_psk
= 1;
5988 if (ssid
->passphrase
)
5989 wpa_config_update_psk(ssid
);
5990 if (wpa_s
->wpa_state
== WPA_SCANNING
&& !wpa_s
->scanning
)
5991 wpa_supplicant_req_scan(wpa_s
, 0, 0);
5993 case WPA_CTRL_REQ_EXT_CERT_CHECK
:
5994 if (eap
->pending_ext_cert_check
!= PENDING_CHECK
)
5996 if (os_strcmp(value
, "good") == 0)
5997 eap
->pending_ext_cert_check
= EXT_CERT_CHECK_GOOD
;
5998 else if (os_strcmp(value
, "bad") == 0)
5999 eap
->pending_ext_cert_check
= EXT_CERT_CHECK_BAD
;
6004 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: Unknown field '%s'", field
);
6009 #else /* IEEE8021X_EAPOL */
6010 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: IEEE 802.1X not included");
6012 #endif /* IEEE8021X_EAPOL */
6014 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
6017 int wpas_network_disabled(struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
)
6020 unsigned int drv_enc
;
6022 if (wpa_s
->p2p_mgmt
)
6023 return 1; /* no normal network profiles on p2p_mgmt interface */
6031 if (wpa_s
->drv_capa_known
)
6032 drv_enc
= wpa_s
->drv_enc
;
6034 drv_enc
= (unsigned int) -1;
6036 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
6037 size_t len
= ssid
->wep_key_len
[i
];
6040 if (len
== 5 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP40
))
6042 if (len
== 13 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP104
))
6044 if (len
== 16 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP128
))
6046 return 1; /* invalid WEP key */
6049 if (wpa_key_mgmt_wpa_psk(ssid
->key_mgmt
) && !ssid
->psk_set
&&
6050 (!ssid
->passphrase
|| ssid
->ssid_len
!= 0) && !ssid
->ext_psk
&&
6051 !ssid
->mem_only_psk
)
6058 int wpas_get_ssid_pmf(struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
)
6060 #ifdef CONFIG_IEEE80211W
6061 if (ssid
== NULL
|| ssid
->ieee80211w
== MGMT_FRAME_PROTECTION_DEFAULT
) {
6062 if (wpa_s
->conf
->pmf
== MGMT_FRAME_PROTECTION_OPTIONAL
&&
6063 !(wpa_s
->drv_enc
& WPA_DRIVER_CAPA_ENC_BIP
)) {
6065 * Driver does not support BIP -- ignore pmf=1 default
6066 * since the connection with PMF would fail and the
6067 * configuration does not require PMF to be enabled.
6069 return NO_MGMT_FRAME_PROTECTION
;
6074 ~(WPA_KEY_MGMT_NONE
| WPA_KEY_MGMT_WPS
|
6075 WPA_KEY_MGMT_IEEE8021X_NO_WPA
)) == 0) {
6077 * Do not use the default PMF value for non-RSN networks
6078 * since PMF is available only with RSN and pmf=2
6079 * configuration would otherwise prevent connections to
6080 * all open networks.
6082 return NO_MGMT_FRAME_PROTECTION
;
6085 return wpa_s
->conf
->pmf
;
6088 return ssid
->ieee80211w
;
6089 #else /* CONFIG_IEEE80211W */
6090 return NO_MGMT_FRAME_PROTECTION
;
6091 #endif /* CONFIG_IEEE80211W */
6095 int wpas_is_p2p_prioritized(struct wpa_supplicant
*wpa_s
)
6097 if (wpa_s
->global
->conc_pref
== WPA_CONC_PREF_P2P
)
6099 if (wpa_s
->global
->conc_pref
== WPA_CONC_PREF_STA
)
6105 void wpas_auth_failed(struct wpa_supplicant
*wpa_s
, char *reason
)
6107 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
6109 struct os_reltime now
;
6112 wpa_printf(MSG_DEBUG
, "Authentication failure but no known "
6117 if (ssid
->key_mgmt
== WPA_KEY_MGMT_WPS
)
6120 ssid
->auth_failures
++;
6123 if (ssid
->p2p_group
&&
6124 (wpa_s
->p2p_in_provisioning
|| wpa_s
->show_group_started
)) {
6126 * Skip the wait time since there is a short timeout on the
6127 * connection to a P2P group.
6131 #endif /* CONFIG_P2P */
6133 if (ssid
->auth_failures
> 50)
6135 else if (ssid
->auth_failures
> 10)
6137 else if (ssid
->auth_failures
> 5)
6139 else if (ssid
->auth_failures
> 3)
6141 else if (ssid
->auth_failures
> 2)
6143 else if (ssid
->auth_failures
> 1)
6148 if (ssid
->auth_failures
> 1 &&
6149 wpa_key_mgmt_wpa_ieee8021x(ssid
->key_mgmt
))
6150 dur
+= os_random() % (ssid
->auth_failures
* 10);
6152 os_get_reltime(&now
);
6153 if (now
.sec
+ dur
<= ssid
->disabled_until
.sec
)
6156 ssid
->disabled_until
.sec
= now
.sec
+ dur
;
6158 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_TEMP_DISABLED
6159 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
6160 ssid
->id
, wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
),
6161 ssid
->auth_failures
, dur
, reason
);
6165 void wpas_clear_temp_disabled(struct wpa_supplicant
*wpa_s
,
6166 struct wpa_ssid
*ssid
, int clear_failures
)
6171 if (ssid
->disabled_until
.sec
) {
6172 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_REENABLED
6173 "id=%d ssid=\"%s\"",
6174 ssid
->id
, wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
6176 ssid
->disabled_until
.sec
= 0;
6177 ssid
->disabled_until
.usec
= 0;
6179 ssid
->auth_failures
= 0;
6183 int disallowed_bssid(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
6187 if (wpa_s
->disallow_aps_bssid
== NULL
)
6190 for (i
= 0; i
< wpa_s
->disallow_aps_bssid_count
; i
++) {
6191 if (os_memcmp(wpa_s
->disallow_aps_bssid
+ i
* ETH_ALEN
,
6192 bssid
, ETH_ALEN
) == 0)
6200 int disallowed_ssid(struct wpa_supplicant
*wpa_s
, const u8
*ssid
,
6205 if (wpa_s
->disallow_aps_ssid
== NULL
|| ssid
== NULL
)
6208 for (i
= 0; i
< wpa_s
->disallow_aps_ssid_count
; i
++) {
6209 struct wpa_ssid_value
*s
= &wpa_s
->disallow_aps_ssid
[i
];
6210 if (ssid_len
== s
->ssid_len
&&
6211 os_memcmp(ssid
, s
->ssid
, ssid_len
) == 0)
6220 * wpas_request_connection - Request a new connection
6221 * @wpa_s: Pointer to the network interface
6223 * This function is used to request a new connection to be found. It will mark
6224 * the interface to allow reassociation and request a new scan to find a
6225 * suitable network to connect to.
6227 void wpas_request_connection(struct wpa_supplicant
*wpa_s
)
6229 wpa_s
->normal_scans
= 0;
6230 wpa_s
->scan_req
= NORMAL_SCAN_REQ
;
6231 wpa_supplicant_reinit_autoscan(wpa_s
);
6232 wpa_s
->extra_blacklist_count
= 0;
6233 wpa_s
->disconnected
= 0;
6234 wpa_s
->reassociate
= 1;
6236 if (wpa_supplicant_fast_associate(wpa_s
) != 1)
6237 wpa_supplicant_req_scan(wpa_s
, 0, 0);
6239 wpa_s
->reattach
= 0;
6244 * wpas_request_disconnection - Request disconnection
6245 * @wpa_s: Pointer to the network interface
6247 * This function is used to request disconnection from the currently connected
6248 * network. This will stop any ongoing scans and initiate deauthentication.
6250 void wpas_request_disconnection(struct wpa_supplicant
*wpa_s
)
6253 wpa_s
->sme
.prev_bssid_set
= 0;
6254 #endif /* CONFIG_SME */
6255 wpa_s
->reassociate
= 0;
6256 wpa_s
->disconnected
= 1;
6257 wpa_supplicant_cancel_sched_scan(wpa_s
);
6258 wpa_supplicant_cancel_scan(wpa_s
);
6259 wpa_supplicant_deauthenticate(wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
6260 eloop_cancel_timeout(wpas_network_reenabled
, wpa_s
, NULL
);
6264 void dump_freq_data(struct wpa_supplicant
*wpa_s
, const char *title
,
6265 struct wpa_used_freq_data
*freqs_data
,
6270 wpa_dbg(wpa_s
, MSG_DEBUG
, "Shared frequencies (len=%u): %s",
6272 for (i
= 0; i
< len
; i
++) {
6273 struct wpa_used_freq_data
*cur
= &freqs_data
[i
];
6274 wpa_dbg(wpa_s
, MSG_DEBUG
, "freq[%u]: %d, flags=0x%X",
6275 i
, cur
->freq
, cur
->flags
);
6281 * Find the operating frequencies of any of the virtual interfaces that
6282 * are using the same radio as the current interface, and in addition, get
6283 * information about the interface types that are using the frequency.
6285 int get_shared_radio_freqs_data(struct wpa_supplicant
*wpa_s
,
6286 struct wpa_used_freq_data
*freqs_data
,
6289 struct wpa_supplicant
*ifs
;
6292 unsigned int idx
= 0, i
;
6294 wpa_dbg(wpa_s
, MSG_DEBUG
,
6295 "Determining shared radio frequencies (max len %u)", len
);
6296 os_memset(freqs_data
, 0, sizeof(struct wpa_used_freq_data
) * len
);
6298 dl_list_for_each(ifs
, &wpa_s
->radio
->ifaces
, struct wpa_supplicant
,
6303 if (ifs
->current_ssid
== NULL
|| ifs
->assoc_freq
== 0)
6306 if (ifs
->current_ssid
->mode
== WPAS_MODE_AP
||
6307 ifs
->current_ssid
->mode
== WPAS_MODE_P2P_GO
||
6308 ifs
->current_ssid
->mode
== WPAS_MODE_MESH
)
6309 freq
= ifs
->current_ssid
->frequency
;
6310 else if (wpa_drv_get_bssid(ifs
, bssid
) == 0)
6311 freq
= ifs
->assoc_freq
;
6315 /* Hold only distinct freqs */
6316 for (i
= 0; i
< idx
; i
++)
6317 if (freqs_data
[i
].freq
== freq
)
6321 freqs_data
[idx
++].freq
= freq
;
6323 if (ifs
->current_ssid
->mode
== WPAS_MODE_INFRA
) {
6324 freqs_data
[i
].flags
|= ifs
->current_ssid
->p2p_group
?
6325 WPA_FREQ_USED_BY_P2P_CLIENT
:
6326 WPA_FREQ_USED_BY_INFRA_STATION
;
6330 dump_freq_data(wpa_s
, "completed iteration", freqs_data
, idx
);
6336 * Find the operating frequencies of any of the virtual interfaces that
6337 * are using the same radio as the current interface.
6339 int get_shared_radio_freqs(struct wpa_supplicant
*wpa_s
,
6340 int *freq_array
, unsigned int len
)
6342 struct wpa_used_freq_data
*freqs_data
;
6345 os_memset(freq_array
, 0, sizeof(int) * len
);
6347 freqs_data
= os_calloc(len
, sizeof(struct wpa_used_freq_data
));
6351 num
= get_shared_radio_freqs_data(wpa_s
, freqs_data
, len
);
6352 for (i
= 0; i
< num
; i
++)
6353 freq_array
[i
] = freqs_data
[i
].freq
;
6355 os_free(freqs_data
);
6361 struct wpa_supplicant
*
6362 wpas_vendor_elem(struct wpa_supplicant
*wpa_s
, enum wpa_vendor_elem_frame frame
)
6366 case VENDOR_ELEM_PROBE_REQ_P2P
:
6367 case VENDOR_ELEM_PROBE_RESP_P2P
:
6368 case VENDOR_ELEM_PROBE_RESP_P2P_GO
:
6369 case VENDOR_ELEM_BEACON_P2P_GO
:
6370 case VENDOR_ELEM_P2P_PD_REQ
:
6371 case VENDOR_ELEM_P2P_PD_RESP
:
6372 case VENDOR_ELEM_P2P_GO_NEG_REQ
:
6373 case VENDOR_ELEM_P2P_GO_NEG_RESP
:
6374 case VENDOR_ELEM_P2P_GO_NEG_CONF
:
6375 case VENDOR_ELEM_P2P_INV_REQ
:
6376 case VENDOR_ELEM_P2P_INV_RESP
:
6377 case VENDOR_ELEM_P2P_ASSOC_REQ
:
6378 case VENDOR_ELEM_P2P_ASSOC_RESP
:
6379 return wpa_s
->p2pdev
;
6380 #endif /* CONFIG_P2P */
6387 void wpas_vendor_elem_update(struct wpa_supplicant
*wpa_s
)
6392 wpa_printf(MSG_DEBUG
, "Update vendor elements");
6394 for (i
= 0; i
< NUM_VENDOR_ELEM_FRAMES
; i
++) {
6395 if (wpa_s
->vendor_elem
[i
]) {
6398 res
= os_snprintf(buf
, sizeof(buf
), "frame[%u]", i
);
6399 if (!os_snprintf_error(sizeof(buf
), res
)) {
6400 wpa_hexdump_buf(MSG_DEBUG
, buf
,
6401 wpa_s
->vendor_elem
[i
]);
6407 if (wpa_s
->parent
== wpa_s
&&
6408 wpa_s
->global
->p2p
&&
6409 !wpa_s
->global
->p2p_disabled
)
6410 p2p_set_vendor_elems(wpa_s
->global
->p2p
, wpa_s
->vendor_elem
);
6411 #endif /* CONFIG_P2P */
6415 int wpas_vendor_elem_remove(struct wpa_supplicant
*wpa_s
, int frame
,
6416 const u8
*elem
, size_t len
)
6420 ie
= wpabuf_mhead_u8(wpa_s
->vendor_elem
[frame
]);
6421 end
= ie
+ wpabuf_len(wpa_s
->vendor_elem
[frame
]);
6423 for (; ie
+ 1 < end
; ie
+= 2 + ie
[1]) {
6426 if (os_memcmp(ie
, elem
, len
) != 0)
6429 if (wpabuf_len(wpa_s
->vendor_elem
[frame
]) == len
) {
6430 wpabuf_free(wpa_s
->vendor_elem
[frame
]);
6431 wpa_s
->vendor_elem
[frame
] = NULL
;
6433 os_memmove(ie
, ie
+ len
, end
- (ie
+ len
));
6434 wpa_s
->vendor_elem
[frame
]->used
-= len
;
6436 wpas_vendor_elem_update(wpa_s
);
6444 struct hostapd_hw_modes
* get_mode(struct hostapd_hw_modes
*modes
,
6445 u16 num_modes
, enum hostapd_hw_mode mode
)
6449 for (i
= 0; i
< num_modes
; i
++) {
6450 if (modes
[i
].mode
== mode
)
6459 wpa_bss_tmp_disallowed
* wpas_get_disallowed_bss(struct wpa_supplicant
*wpa_s
,
6462 struct wpa_bss_tmp_disallowed
*bss
;
6464 dl_list_for_each(bss
, &wpa_s
->bss_tmp_disallowed
,
6465 struct wpa_bss_tmp_disallowed
, list
) {
6466 if (os_memcmp(bssid
, bss
->bssid
, ETH_ALEN
) == 0)
6474 void wpa_bss_tmp_disallow(struct wpa_supplicant
*wpa_s
, const u8
*bssid
,
6477 struct wpa_bss_tmp_disallowed
*bss
;
6478 struct os_reltime until
;
6480 os_get_reltime(&until
);
6483 bss
= wpas_get_disallowed_bss(wpa_s
, bssid
);
6485 bss
->disallowed_until
= until
;
6489 bss
= os_malloc(sizeof(*bss
));
6491 wpa_printf(MSG_DEBUG
,
6492 "Failed to allocate memory for temp disallow BSS");
6496 bss
->disallowed_until
= until
;
6497 os_memcpy(bss
->bssid
, bssid
, ETH_ALEN
);
6498 dl_list_add(&wpa_s
->bss_tmp_disallowed
, &bss
->list
);
6502 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
6504 struct wpa_bss_tmp_disallowed
*bss
= NULL
, *tmp
, *prev
;
6505 struct os_reltime now
, age
;
6507 os_get_reltime(&now
);
6509 dl_list_for_each_safe(tmp
, prev
, &wpa_s
->bss_tmp_disallowed
,
6510 struct wpa_bss_tmp_disallowed
, list
) {
6511 if (!os_reltime_before(&now
, &tmp
->disallowed_until
)) {
6512 /* This BSS is not disallowed anymore */
6513 dl_list_del(&tmp
->list
);
6517 if (os_memcmp(bssid
, tmp
->bssid
, ETH_ALEN
) == 0) {
6525 os_reltime_sub(&bss
->disallowed_until
, &now
, &age
);
6526 wpa_printf(MSG_DEBUG
,
6527 "BSS " MACSTR
" disabled for %ld.%0ld seconds",
6528 MAC2STR(bss
->bssid
), age
.sec
, age
.usec
);