3 * Copyright (c) 2003-2015, 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.
16 #include "crypto/random.h"
17 #include "crypto/sha1.h"
18 #include "eapol_supp/eapol_supp_sm.h"
19 #include "eap_peer/eap.h"
20 #include "eap_peer/eap_proxy.h"
21 #include "eap_server/eap_methods.h"
22 #include "rsn_supp/wpa.h"
25 #include "utils/ext_password.h"
26 #include "l2_packet/l2_packet.h"
27 #include "wpa_supplicant_i.h"
29 #include "ctrl_iface.h"
30 #include "pcsc_funcs.h"
31 #include "common/version.h"
32 #include "rsn_supp/preauth.h"
33 #include "rsn_supp/pmksa_cache.h"
34 #include "common/wpa_ctrl.h"
35 #include "common/ieee802_11_defs.h"
36 #include "common/hw_features_common.h"
38 #include "blacklist.h"
39 #include "wpas_glue.h"
40 #include "wps_supplicant.h"
43 #include "gas_query.h"
45 #include "p2p_supplicant.h"
46 #include "wifi_display.h"
52 #include "offchannel.h"
53 #include "hs20_supplicant.h"
58 const char *wpa_supplicant_version
=
59 "wpa_supplicant v" VERSION_STR
"\n"
60 "Copyright (c) 2003-2015, Jouni Malinen <j@w1.fi> and contributors";
62 const char *wpa_supplicant_license
=
63 "This software may be distributed under the terms of the BSD license.\n"
64 "See README for more details.\n"
65 #ifdef EAP_TLS_OPENSSL
66 "\nThis product includes software developed by the OpenSSL Project\n"
67 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
68 #endif /* EAP_TLS_OPENSSL */
71 #ifndef CONFIG_NO_STDOUT_DEBUG
72 /* Long text divided into parts in order to fit in C89 strings size limits. */
73 const char *wpa_supplicant_full_license1
=
75 const char *wpa_supplicant_full_license2
=
76 "This software may be distributed under the terms of the BSD license.\n"
78 "Redistribution and use in source and binary forms, with or without\n"
79 "modification, are permitted provided that the following conditions are\n"
82 const char *wpa_supplicant_full_license3
=
83 "1. Redistributions of source code must retain the above copyright\n"
84 " notice, this list of conditions and the following disclaimer.\n"
86 "2. Redistributions in binary form must reproduce the above copyright\n"
87 " notice, this list of conditions and the following disclaimer in the\n"
88 " documentation and/or other materials provided with the distribution.\n"
90 const char *wpa_supplicant_full_license4
=
91 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
92 " names of its contributors may be used to endorse or promote products\n"
93 " derived from this software without specific prior written permission.\n"
95 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
96 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
97 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
98 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
99 const char *wpa_supplicant_full_license5
=
100 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
101 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
102 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
103 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
104 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
105 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
106 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
108 #endif /* CONFIG_NO_STDOUT_DEBUG */
110 /* Configure default/group WEP keys for static WEP */
111 int wpa_set_wep_keys(struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
)
115 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
116 if (ssid
->wep_key_len
[i
] == 0)
120 wpa_drv_set_key(wpa_s
, WPA_ALG_WEP
, NULL
,
121 i
, i
== ssid
->wep_tx_keyidx
, NULL
, 0,
122 ssid
->wep_key
[i
], ssid
->wep_key_len
[i
]);
129 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant
*wpa_s
,
130 struct wpa_ssid
*ssid
)
138 /* IBSS/WPA-None uses only one key (Group) for both receiving and
139 * sending unicast and multicast packets. */
141 if (ssid
->mode
!= WPAS_MODE_IBSS
) {
142 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Invalid mode %d (not "
143 "IBSS/ad-hoc) for WPA-None", ssid
->mode
);
147 if (!ssid
->psk_set
) {
148 wpa_msg(wpa_s
, MSG_INFO
, "WPA: No PSK configured for "
153 switch (wpa_s
->group_cipher
) {
154 case WPA_CIPHER_CCMP
:
155 os_memcpy(key
, ssid
->psk
, 16);
159 case WPA_CIPHER_GCMP
:
160 os_memcpy(key
, ssid
->psk
, 16);
164 case WPA_CIPHER_TKIP
:
165 /* WPA-None uses the same Michael MIC key for both TX and RX */
166 os_memcpy(key
, ssid
->psk
, 16 + 8);
167 os_memcpy(key
+ 16 + 8, ssid
->psk
+ 16, 8);
172 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Invalid group cipher %d for "
173 "WPA-None", wpa_s
->group_cipher
);
177 /* TODO: should actually remember the previously used seq#, both for TX
178 * and RX from each STA.. */
180 ret
= wpa_drv_set_key(wpa_s
, alg
, NULL
, 0, 1, seq
, 6, key
, keylen
);
181 os_memset(key
, 0, sizeof(key
));
186 static void wpa_supplicant_timeout(void *eloop_ctx
, void *timeout_ctx
)
188 struct wpa_supplicant
*wpa_s
= eloop_ctx
;
189 const u8
*bssid
= wpa_s
->bssid
;
190 if (is_zero_ether_addr(bssid
))
191 bssid
= wpa_s
->pending_bssid
;
192 wpa_msg(wpa_s
, MSG_INFO
, "Authentication with " MACSTR
" timed out.",
194 wpa_blacklist_add(wpa_s
, bssid
);
195 wpa_sm_notify_disassoc(wpa_s
->wpa
);
196 wpa_supplicant_deauthenticate(wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
197 wpa_s
->reassociate
= 1;
200 * If we timed out, the AP or the local radio may be busy.
201 * So, wait a second until scanning again.
203 wpa_supplicant_req_scan(wpa_s
, 1, 0);
208 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
209 * @wpa_s: Pointer to wpa_supplicant data
210 * @sec: Number of seconds after which to time out authentication
211 * @usec: Number of microseconds after which to time out authentication
213 * This function is used to schedule a timeout for the current authentication
216 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant
*wpa_s
,
219 if (wpa_s
->conf
->ap_scan
== 0 &&
220 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
))
223 wpa_dbg(wpa_s
, MSG_DEBUG
, "Setting authentication timeout: %d sec "
224 "%d usec", sec
, usec
);
225 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
226 eloop_register_timeout(sec
, usec
, wpa_supplicant_timeout
, wpa_s
, NULL
);
231 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
232 * @wpa_s: Pointer to wpa_supplicant data
234 * This function is used to cancel authentication timeout scheduled with
235 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
238 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant
*wpa_s
)
240 wpa_dbg(wpa_s
, MSG_DEBUG
, "Cancelling authentication timeout");
241 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
242 wpa_blacklist_del(wpa_s
, wpa_s
->bssid
);
247 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
248 * @wpa_s: Pointer to wpa_supplicant data
250 * This function is used to configure EAPOL state machine based on the selected
251 * authentication mode.
253 void wpa_supplicant_initiate_eapol(struct wpa_supplicant
*wpa_s
)
255 #ifdef IEEE8021X_EAPOL
256 struct eapol_config eapol_conf
;
257 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
259 #ifdef CONFIG_IBSS_RSN
260 if (ssid
->mode
== WPAS_MODE_IBSS
&&
261 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_NONE
&&
262 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPA_NONE
) {
264 * RSN IBSS authentication is per-STA and we can disable the
265 * per-BSSID EAPOL authentication.
267 eapol_sm_notify_portControl(wpa_s
->eapol
, ForceAuthorized
);
268 eapol_sm_notify_eap_success(wpa_s
->eapol
, TRUE
);
269 eapol_sm_notify_eap_fail(wpa_s
->eapol
, FALSE
);
272 #endif /* CONFIG_IBSS_RSN */
274 eapol_sm_notify_eap_success(wpa_s
->eapol
, FALSE
);
275 eapol_sm_notify_eap_fail(wpa_s
->eapol
, FALSE
);
277 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
||
278 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
)
279 eapol_sm_notify_portControl(wpa_s
->eapol
, ForceAuthorized
);
281 eapol_sm_notify_portControl(wpa_s
->eapol
, Auto
);
283 os_memset(&eapol_conf
, 0, sizeof(eapol_conf
));
284 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
285 eapol_conf
.accept_802_1x_keys
= 1;
286 eapol_conf
.required_keys
= 0;
287 if (ssid
->eapol_flags
& EAPOL_FLAG_REQUIRE_KEY_UNICAST
) {
288 eapol_conf
.required_keys
|= EAPOL_REQUIRE_KEY_UNICAST
;
290 if (ssid
->eapol_flags
& EAPOL_FLAG_REQUIRE_KEY_BROADCAST
) {
291 eapol_conf
.required_keys
|=
292 EAPOL_REQUIRE_KEY_BROADCAST
;
295 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
)
296 eapol_conf
.required_keys
= 0;
298 eapol_conf
.fast_reauth
= wpa_s
->conf
->fast_reauth
;
299 eapol_conf
.workaround
= ssid
->eap_workaround
;
300 eapol_conf
.eap_disabled
=
301 !wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) &&
302 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_IEEE8021X_NO_WPA
&&
303 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPS
;
304 eapol_conf
.external_sim
= wpa_s
->conf
->external_sim
;
307 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
) {
308 eapol_conf
.wps
|= EAPOL_LOCAL_WPS_IN_USE
;
309 if (wpa_s
->current_bss
) {
311 ie
= wpa_bss_get_vendor_ie_multi(wpa_s
->current_bss
,
316 EAPOL_PEER_IS_WPS20_AP
;
321 #endif /* CONFIG_WPS */
323 eapol_sm_notify_config(wpa_s
->eapol
, &ssid
->eap
, &eapol_conf
);
325 ieee802_1x_alloc_kay_sm(wpa_s
, ssid
);
326 #endif /* IEEE8021X_EAPOL */
331 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
332 * @wpa_s: Pointer to wpa_supplicant data
333 * @ssid: Configuration data for the network
335 * This function is used to configure WPA state machine and related parameters
336 * to a mode where WPA is not enabled. This is called as part of the
337 * authentication configuration when the selected network does not use WPA.
339 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant
*wpa_s
,
340 struct wpa_ssid
*ssid
)
344 if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)
345 wpa_s
->key_mgmt
= WPA_KEY_MGMT_WPS
;
346 else if (ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
)
347 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_NO_WPA
;
349 wpa_s
->key_mgmt
= WPA_KEY_MGMT_NONE
;
350 wpa_sm_set_ap_wpa_ie(wpa_s
->wpa
, NULL
, 0);
351 wpa_sm_set_ap_rsn_ie(wpa_s
->wpa
, NULL
, 0);
352 wpa_sm_set_assoc_wpa_ie(wpa_s
->wpa
, NULL
, 0);
353 wpa_s
->pairwise_cipher
= WPA_CIPHER_NONE
;
354 wpa_s
->group_cipher
= WPA_CIPHER_NONE
;
355 wpa_s
->mgmt_group_cipher
= 0;
357 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
358 if (ssid
->wep_key_len
[i
] > 5) {
359 wpa_s
->pairwise_cipher
= WPA_CIPHER_WEP104
;
360 wpa_s
->group_cipher
= WPA_CIPHER_WEP104
;
362 } else if (ssid
->wep_key_len
[i
] > 0) {
363 wpa_s
->pairwise_cipher
= WPA_CIPHER_WEP40
;
364 wpa_s
->group_cipher
= WPA_CIPHER_WEP40
;
369 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_RSN_ENABLED
, 0);
370 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_KEY_MGMT
, wpa_s
->key_mgmt
);
371 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PAIRWISE
,
372 wpa_s
->pairwise_cipher
);
373 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_GROUP
, wpa_s
->group_cipher
);
374 #ifdef CONFIG_IEEE80211W
375 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MGMT_GROUP
,
376 wpa_s
->mgmt_group_cipher
);
377 #endif /* CONFIG_IEEE80211W */
379 pmksa_cache_clear_current(wpa_s
->wpa
);
383 void free_hw_features(struct wpa_supplicant
*wpa_s
)
386 if (wpa_s
->hw
.modes
== NULL
)
389 for (i
= 0; i
< wpa_s
->hw
.num_modes
; i
++) {
390 os_free(wpa_s
->hw
.modes
[i
].channels
);
391 os_free(wpa_s
->hw
.modes
[i
].rates
);
394 os_free(wpa_s
->hw
.modes
);
395 wpa_s
->hw
.modes
= NULL
;
399 static void wpa_supplicant_cleanup(struct wpa_supplicant
*wpa_s
)
403 bgscan_deinit(wpa_s
);
404 autoscan_deinit(wpa_s
);
405 scard_deinit(wpa_s
->scard
);
407 wpa_sm_set_scard_ctx(wpa_s
->wpa
, NULL
);
408 eapol_sm_register_scard_ctx(wpa_s
->eapol
, NULL
);
409 l2_packet_deinit(wpa_s
->l2
);
412 l2_packet_deinit(wpa_s
->l2_br
);
415 #ifdef CONFIG_TESTING_OPTIONS
416 l2_packet_deinit(wpa_s
->l2_test
);
417 wpa_s
->l2_test
= NULL
;
418 #endif /* CONFIG_TESTING_OPTIONS */
420 if (wpa_s
->conf
!= NULL
) {
421 struct wpa_ssid
*ssid
;
422 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
423 wpas_notify_network_removed(wpa_s
, ssid
);
426 os_free(wpa_s
->confname
);
427 wpa_s
->confname
= NULL
;
429 os_free(wpa_s
->confanother
);
430 wpa_s
->confanother
= NULL
;
432 wpa_sm_set_eapol(wpa_s
->wpa
, NULL
);
433 eapol_sm_deinit(wpa_s
->eapol
);
436 rsn_preauth_deinit(wpa_s
->wpa
);
439 wpa_tdls_deinit(wpa_s
->wpa
);
440 #endif /* CONFIG_TDLS */
442 wmm_ac_clear_saved_tspecs(wpa_s
);
443 pmksa_candidate_free(wpa_s
->wpa
);
444 wpa_sm_deinit(wpa_s
->wpa
);
446 wpa_blacklist_clear(wpa_s
);
448 wpa_bss_deinit(wpa_s
);
450 wpa_supplicant_cancel_delayed_sched_scan(wpa_s
);
451 wpa_supplicant_cancel_scan(wpa_s
);
452 wpa_supplicant_cancel_auth_timeout(wpa_s
);
453 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures
, wpa_s
, NULL
);
454 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
455 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report
,
457 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
459 wpas_wps_deinit(wpa_s
);
461 wpabuf_free(wpa_s
->pending_eapol_rx
);
462 wpa_s
->pending_eapol_rx
= NULL
;
464 #ifdef CONFIG_IBSS_RSN
465 ibss_rsn_deinit(wpa_s
->ibss_rsn
);
466 wpa_s
->ibss_rsn
= NULL
;
467 #endif /* CONFIG_IBSS_RSN */
472 wpa_supplicant_ap_deinit(wpa_s
);
473 #endif /* CONFIG_AP */
475 wpas_p2p_deinit(wpa_s
);
477 #ifdef CONFIG_OFFCHANNEL
478 offchannel_deinit(wpa_s
);
479 #endif /* CONFIG_OFFCHANNEL */
481 wpa_supplicant_cancel_sched_scan(wpa_s
);
483 os_free(wpa_s
->next_scan_freqs
);
484 wpa_s
->next_scan_freqs
= NULL
;
486 os_free(wpa_s
->manual_scan_freqs
);
487 wpa_s
->manual_scan_freqs
= NULL
;
489 os_free(wpa_s
->manual_sched_scan_freqs
);
490 wpa_s
->manual_sched_scan_freqs
= NULL
;
492 wpas_mac_addr_rand_scan_clear(wpa_s
, MAC_ADDR_RAND_ALL
);
494 gas_query_deinit(wpa_s
->gas
);
497 free_hw_features(wpa_s
);
499 ieee802_1x_dealloc_kay_sm(wpa_s
);
501 os_free(wpa_s
->bssid_filter
);
502 wpa_s
->bssid_filter
= NULL
;
504 os_free(wpa_s
->disallow_aps_bssid
);
505 wpa_s
->disallow_aps_bssid
= NULL
;
506 os_free(wpa_s
->disallow_aps_ssid
);
507 wpa_s
->disallow_aps_ssid
= NULL
;
509 wnm_bss_keep_alive_deinit(wpa_s
);
511 wnm_deallocate_memory(wpa_s
);
512 #endif /* CONFIG_WNM */
514 ext_password_deinit(wpa_s
->ext_pw
);
515 wpa_s
->ext_pw
= NULL
;
517 wpabuf_free(wpa_s
->last_gas_resp
);
518 wpa_s
->last_gas_resp
= NULL
;
519 wpabuf_free(wpa_s
->prev_gas_resp
);
520 wpa_s
->prev_gas_resp
= NULL
;
522 os_free(wpa_s
->last_scan_res
);
523 wpa_s
->last_scan_res
= NULL
;
527 #endif /* CONFIG_HS20 */
529 for (i
= 0; i
< NUM_VENDOR_ELEM_FRAMES
; i
++) {
530 wpabuf_free(wpa_s
->vendor_elem
[i
]);
531 wpa_s
->vendor_elem
[i
] = NULL
;
534 wmm_ac_notify_disassoc(wpa_s
);
539 * wpa_clear_keys - Clear keys configured for the driver
540 * @wpa_s: Pointer to wpa_supplicant data
541 * @addr: Previously used BSSID or %NULL if not available
543 * This function clears the encryption keys that has been previously configured
546 void wpa_clear_keys(struct wpa_supplicant
*wpa_s
, const u8
*addr
)
550 #ifdef CONFIG_IEEE80211W
552 #else /* CONFIG_IEEE80211W */
554 #endif /* CONFIG_IEEE80211W */
556 /* MLME-DELETEKEYS.request */
557 for (i
= 0; i
< max
; i
++) {
558 if (wpa_s
->keys_cleared
& BIT(i
))
560 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, i
, 0, NULL
, 0,
563 if (!(wpa_s
->keys_cleared
& BIT(0)) && addr
&&
564 !is_zero_ether_addr(addr
)) {
565 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, addr
, 0, 0, NULL
, 0, NULL
,
567 /* MLME-SETPROTECTION.request(None) */
568 wpa_drv_mlme_setprotection(
570 MLME_SETPROTECTION_PROTECT_TYPE_NONE
,
571 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE
);
573 wpa_s
->keys_cleared
= (u32
) -1;
578 * wpa_supplicant_state_txt - Get the connection state name as a text string
579 * @state: State (wpa_state; WPA_*)
580 * Returns: The state name as a printable text string
582 const char * wpa_supplicant_state_txt(enum wpa_states state
)
585 case WPA_DISCONNECTED
:
586 return "DISCONNECTED";
589 case WPA_INTERFACE_DISABLED
:
590 return "INTERFACE_DISABLED";
593 case WPA_AUTHENTICATING
:
594 return "AUTHENTICATING";
595 case WPA_ASSOCIATING
:
596 return "ASSOCIATING";
599 case WPA_4WAY_HANDSHAKE
:
600 return "4WAY_HANDSHAKE";
601 case WPA_GROUP_HANDSHAKE
:
602 return "GROUP_HANDSHAKE";
613 static void wpa_supplicant_start_bgscan(struct wpa_supplicant
*wpa_s
)
617 if (wpa_s
->current_ssid
&& wpa_s
->current_ssid
->bgscan
)
618 name
= wpa_s
->current_ssid
->bgscan
;
620 name
= wpa_s
->conf
->bgscan
;
621 if (name
== NULL
|| name
[0] == '\0')
623 if (wpas_driver_bss_selection(wpa_s
))
625 if (wpa_s
->current_ssid
== wpa_s
->bgscan_ssid
)
628 if (wpa_s
->p2p_group_interface
!= NOT_P2P_GROUP_INTERFACE
)
630 #endif /* CONFIG_P2P */
632 bgscan_deinit(wpa_s
);
633 if (wpa_s
->current_ssid
) {
634 if (bgscan_init(wpa_s
, wpa_s
->current_ssid
, name
)) {
635 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize "
638 * Live without bgscan; it is only used as a roaming
639 * optimization, so the initial connection is not
643 struct wpa_scan_results
*scan_res
;
644 wpa_s
->bgscan_ssid
= wpa_s
->current_ssid
;
645 scan_res
= wpa_supplicant_get_scan_results(wpa_s
, NULL
,
648 bgscan_notify_scan(wpa_s
, scan_res
);
649 wpa_scan_results_free(scan_res
);
653 wpa_s
->bgscan_ssid
= NULL
;
657 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant
*wpa_s
)
659 if (wpa_s
->bgscan_ssid
!= NULL
) {
660 bgscan_deinit(wpa_s
);
661 wpa_s
->bgscan_ssid
= NULL
;
665 #endif /* CONFIG_BGSCAN */
668 static void wpa_supplicant_start_autoscan(struct wpa_supplicant
*wpa_s
)
670 if (autoscan_init(wpa_s
, 0))
671 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize autoscan");
675 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant
*wpa_s
)
677 autoscan_deinit(wpa_s
);
681 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant
*wpa_s
)
683 if (wpa_s
->wpa_state
== WPA_DISCONNECTED
||
684 wpa_s
->wpa_state
== WPA_SCANNING
) {
685 autoscan_deinit(wpa_s
);
686 wpa_supplicant_start_autoscan(wpa_s
);
692 * wpa_supplicant_set_state - Set current connection state
693 * @wpa_s: Pointer to wpa_supplicant data
694 * @state: The new connection state
696 * This function is called whenever the connection state changes, e.g.,
697 * association is completed for WPA/WPA2 4-Way Handshake is started.
699 void wpa_supplicant_set_state(struct wpa_supplicant
*wpa_s
,
700 enum wpa_states state
)
702 enum wpa_states old_state
= wpa_s
->wpa_state
;
704 wpa_dbg(wpa_s
, MSG_DEBUG
, "State: %s -> %s",
705 wpa_supplicant_state_txt(wpa_s
->wpa_state
),
706 wpa_supplicant_state_txt(state
));
708 if (state
== WPA_INTERFACE_DISABLED
) {
709 /* Assure normal scan when interface is restored */
710 wpa_s
->normal_scans
= 0;
713 if (state
== WPA_COMPLETED
) {
714 wpas_connect_work_done(wpa_s
);
715 /* Reinitialize normal_scan counter */
716 wpa_s
->normal_scans
= 0;
719 if (state
!= WPA_SCANNING
)
720 wpa_supplicant_notify_scanning(wpa_s
, 0);
722 if (state
== WPA_COMPLETED
&& wpa_s
->new_connection
) {
723 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
724 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
725 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_CONNECTED
"- Connection to "
726 MACSTR
" completed [id=%d id_str=%s]",
727 MAC2STR(wpa_s
->bssid
),
728 ssid
? ssid
->id
: -1,
729 ssid
&& ssid
->id_str
? ssid
->id_str
: "");
730 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
731 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
732 wpa_s
->extra_blacklist_count
= 0;
733 wpa_s
->new_connection
= 0;
734 wpa_drv_set_operstate(wpa_s
, 1);
735 #ifndef IEEE8021X_EAPOL
736 wpa_drv_set_supp_port(wpa_s
, 1);
737 #endif /* IEEE8021X_EAPOL */
738 wpa_s
->after_wps
= 0;
739 wpa_s
->known_wps_freq
= 0;
740 wpas_p2p_completed(wpa_s
);
742 sme_sched_obss_scan(wpa_s
, 1);
743 } else if (state
== WPA_DISCONNECTED
|| state
== WPA_ASSOCIATING
||
744 state
== WPA_ASSOCIATED
) {
745 wpa_s
->new_connection
= 1;
746 wpa_drv_set_operstate(wpa_s
, 0);
747 #ifndef IEEE8021X_EAPOL
748 wpa_drv_set_supp_port(wpa_s
, 0);
749 #endif /* IEEE8021X_EAPOL */
750 sme_sched_obss_scan(wpa_s
, 0);
752 wpa_s
->wpa_state
= state
;
755 if (state
== WPA_COMPLETED
)
756 wpa_supplicant_start_bgscan(wpa_s
);
757 else if (state
< WPA_ASSOCIATED
)
758 wpa_supplicant_stop_bgscan(wpa_s
);
759 #endif /* CONFIG_BGSCAN */
761 if (state
== WPA_AUTHENTICATING
)
762 wpa_supplicant_stop_autoscan(wpa_s
);
764 if (state
== WPA_DISCONNECTED
|| state
== WPA_INACTIVE
)
765 wpa_supplicant_start_autoscan(wpa_s
);
767 if (old_state
>= WPA_ASSOCIATED
&& wpa_s
->wpa_state
< WPA_ASSOCIATED
)
768 wmm_ac_notify_disassoc(wpa_s
);
770 if (wpa_s
->wpa_state
!= old_state
) {
771 wpas_notify_state_changed(wpa_s
, wpa_s
->wpa_state
, old_state
);
774 * Notify the P2P Device interface about a state change in one
777 wpas_p2p_indicate_state_change(wpa_s
);
779 if (wpa_s
->wpa_state
== WPA_COMPLETED
||
780 old_state
== WPA_COMPLETED
)
781 wpas_notify_auth_changed(wpa_s
);
786 void wpa_supplicant_terminate_proc(struct wpa_global
*global
)
790 struct wpa_supplicant
*wpa_s
= global
->ifaces
;
792 struct wpa_supplicant
*next
= wpa_s
->next
;
793 if (wpas_wps_terminate_pending(wpa_s
) == 1)
796 if (wpa_s
->p2p_group_interface
!= NOT_P2P_GROUP_INTERFACE
||
797 (wpa_s
->current_ssid
&& wpa_s
->current_ssid
->p2p_group
))
798 wpas_p2p_disconnect(wpa_s
);
799 #endif /* CONFIG_P2P */
802 #endif /* CONFIG_WPS */
809 static void wpa_supplicant_terminate(int sig
, void *signal_ctx
)
811 struct wpa_global
*global
= signal_ctx
;
812 wpa_supplicant_terminate_proc(global
);
816 void wpa_supplicant_clear_status(struct wpa_supplicant
*wpa_s
)
818 enum wpa_states old_state
= wpa_s
->wpa_state
;
820 wpa_s
->pairwise_cipher
= 0;
821 wpa_s
->group_cipher
= 0;
822 wpa_s
->mgmt_group_cipher
= 0;
824 if (wpa_s
->wpa_state
!= WPA_INTERFACE_DISABLED
)
825 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
827 if (wpa_s
->wpa_state
!= old_state
)
828 wpas_notify_state_changed(wpa_s
, wpa_s
->wpa_state
, old_state
);
833 * wpa_supplicant_reload_configuration - Reload configuration data
834 * @wpa_s: Pointer to wpa_supplicant data
835 * Returns: 0 on success or -1 if configuration parsing failed
837 * This function can be used to request that the configuration data is reloaded
838 * (e.g., after configuration file change). This function is reloading
839 * configuration only for one interface, so this may need to be called multiple
840 * times if %wpa_supplicant is controlling multiple interfaces and all
841 * interfaces need reconfiguration.
843 int wpa_supplicant_reload_configuration(struct wpa_supplicant
*wpa_s
)
845 struct wpa_config
*conf
;
849 if (wpa_s
->confname
== NULL
)
851 conf
= wpa_config_read(wpa_s
->confname
, NULL
);
853 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to parse the configuration "
854 "file '%s' - exiting", wpa_s
->confname
);
857 wpa_config_read(wpa_s
->confanother
, conf
);
859 conf
->changed_parameters
= (unsigned int) -1;
861 reconf_ctrl
= !!conf
->ctrl_interface
!= !!wpa_s
->conf
->ctrl_interface
862 || (conf
->ctrl_interface
&& wpa_s
->conf
->ctrl_interface
&&
863 os_strcmp(conf
->ctrl_interface
,
864 wpa_s
->conf
->ctrl_interface
) != 0);
866 if (reconf_ctrl
&& wpa_s
->ctrl_iface
) {
867 wpa_supplicant_ctrl_iface_deinit(wpa_s
->ctrl_iface
);
868 wpa_s
->ctrl_iface
= NULL
;
871 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
872 if (wpa_s
->current_ssid
) {
873 wpa_supplicant_deauthenticate(wpa_s
,
874 WLAN_REASON_DEAUTH_LEAVING
);
878 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
879 * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers.
881 if (wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
)) {
883 * Clear forced success to clear EAP state for next
886 eapol_sm_notify_eap_success(wpa_s
->eapol
, FALSE
);
888 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
889 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
890 wpa_sm_pmksa_cache_flush(wpa_s
->wpa
, NULL
);
891 wpa_sm_set_fast_reauth(wpa_s
->wpa
, wpa_s
->conf
->fast_reauth
);
892 rsn_preauth_deinit(wpa_s
->wpa
);
894 old_ap_scan
= wpa_s
->conf
->ap_scan
;
895 wpa_config_free(wpa_s
->conf
);
897 if (old_ap_scan
!= wpa_s
->conf
->ap_scan
)
898 wpas_notify_ap_scan_changed(wpa_s
);
901 wpa_s
->ctrl_iface
= wpa_supplicant_ctrl_iface_init(wpa_s
);
903 wpa_supplicant_update_config(wpa_s
);
905 wpa_supplicant_clear_status(wpa_s
);
906 if (wpa_supplicant_enabled_networks(wpa_s
)) {
907 wpa_s
->reassociate
= 1;
908 wpa_supplicant_req_scan(wpa_s
, 0, 0);
910 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reconfiguration completed");
915 static void wpa_supplicant_reconfig(int sig
, void *signal_ctx
)
917 struct wpa_global
*global
= signal_ctx
;
918 struct wpa_supplicant
*wpa_s
;
919 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
920 wpa_dbg(wpa_s
, MSG_DEBUG
, "Signal %d received - reconfiguring",
922 if (wpa_supplicant_reload_configuration(wpa_s
) < 0) {
923 wpa_supplicant_terminate_proc(global
);
929 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant
*wpa_s
,
930 struct wpa_ssid
*ssid
,
931 struct wpa_ie_data
*ie
)
933 int ret
= wpa_sm_parse_own_wpa_ie(wpa_s
->wpa
, ie
);
936 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Failed to parse WPA IE "
937 "from association info");
942 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Using WPA IE from AssocReq to set "
944 if (!(ie
->group_cipher
& ssid
->group_cipher
)) {
945 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled group "
946 "cipher 0x%x (mask 0x%x) - reject",
947 ie
->group_cipher
, ssid
->group_cipher
);
950 if (!(ie
->pairwise_cipher
& ssid
->pairwise_cipher
)) {
951 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled pairwise "
952 "cipher 0x%x (mask 0x%x) - reject",
953 ie
->pairwise_cipher
, ssid
->pairwise_cipher
);
956 if (!(ie
->key_mgmt
& ssid
->key_mgmt
)) {
957 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled key "
958 "management 0x%x (mask 0x%x) - reject",
959 ie
->key_mgmt
, ssid
->key_mgmt
);
963 #ifdef CONFIG_IEEE80211W
964 if (!(ie
->capabilities
& WPA_CAPABILITY_MFPC
) &&
965 wpas_get_ssid_pmf(wpa_s
, ssid
) == MGMT_FRAME_PROTECTION_REQUIRED
) {
966 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver associated with an AP "
967 "that does not support management frame protection - "
971 #endif /* CONFIG_IEEE80211W */
978 * wpa_supplicant_set_suites - Set authentication and encryption parameters
979 * @wpa_s: Pointer to wpa_supplicant data
980 * @bss: Scan results for the selected BSS, or %NULL if not available
981 * @ssid: Configuration data for the selected network
982 * @wpa_ie: Buffer for the WPA/RSN IE
983 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
984 * used buffer length in case the functions returns success.
985 * Returns: 0 on success or -1 on failure
987 * This function is used to configure authentication and encryption parameters
988 * based on the network configuration and scan result for the selected BSS (if
991 int wpa_supplicant_set_suites(struct wpa_supplicant
*wpa_s
,
992 struct wpa_bss
*bss
, struct wpa_ssid
*ssid
,
993 u8
*wpa_ie
, size_t *wpa_ie_len
)
995 struct wpa_ie_data ie
;
997 const u8
*bss_wpa
, *bss_rsn
, *bss_osen
;
1000 bss_wpa
= wpa_bss_get_vendor_ie(bss
, WPA_IE_VENDOR_TYPE
);
1001 bss_rsn
= wpa_bss_get_ie(bss
, WLAN_EID_RSN
);
1002 bss_osen
= wpa_bss_get_vendor_ie(bss
, OSEN_IE_VENDOR_TYPE
);
1004 bss_wpa
= bss_rsn
= bss_osen
= NULL
;
1006 if (bss_rsn
&& (ssid
->proto
& WPA_PROTO_RSN
) &&
1007 wpa_parse_wpa_ie(bss_rsn
, 2 + bss_rsn
[1], &ie
) == 0 &&
1008 (ie
.group_cipher
& ssid
->group_cipher
) &&
1009 (ie
.pairwise_cipher
& ssid
->pairwise_cipher
) &&
1010 (ie
.key_mgmt
& ssid
->key_mgmt
)) {
1011 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using IEEE 802.11i/D9.0");
1012 proto
= WPA_PROTO_RSN
;
1013 } else if (bss_wpa
&& (ssid
->proto
& WPA_PROTO_WPA
) &&
1014 wpa_parse_wpa_ie(bss_wpa
, 2 + bss_wpa
[1], &ie
) == 0 &&
1015 (ie
.group_cipher
& ssid
->group_cipher
) &&
1016 (ie
.pairwise_cipher
& ssid
->pairwise_cipher
) &&
1017 (ie
.key_mgmt
& ssid
->key_mgmt
)) {
1018 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using IEEE 802.11i/D3.0");
1019 proto
= WPA_PROTO_WPA
;
1021 } else if (bss_osen
&& (ssid
->proto
& WPA_PROTO_OSEN
)) {
1022 wpa_dbg(wpa_s
, MSG_DEBUG
, "HS 2.0: using OSEN");
1023 /* TODO: parse OSEN element */
1024 os_memset(&ie
, 0, sizeof(ie
));
1025 ie
.group_cipher
= WPA_CIPHER_CCMP
;
1026 ie
.pairwise_cipher
= WPA_CIPHER_CCMP
;
1027 ie
.key_mgmt
= WPA_KEY_MGMT_OSEN
;
1028 proto
= WPA_PROTO_OSEN
;
1029 #endif /* CONFIG_HS20 */
1031 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select WPA/RSN");
1032 wpa_dbg(wpa_s
, MSG_DEBUG
,
1033 "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1034 ssid
->proto
, ssid
->pairwise_cipher
, ssid
->group_cipher
,
1036 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: BSS " MACSTR
" ssid='%s'%s%s%s",
1037 MAC2STR(bss
->bssid
),
1038 wpa_ssid_txt(bss
->ssid
, bss
->ssid_len
),
1039 bss_wpa
? " WPA" : "",
1040 bss_rsn
? " RSN" : "",
1041 bss_osen
? " OSEN" : "");
1043 wpa_hexdump(MSG_DEBUG
, "RSN", bss_rsn
, 2 + bss_rsn
[1]);
1044 if (wpa_parse_wpa_ie(bss_rsn
, 2 + bss_rsn
[1], &ie
)) {
1045 wpa_dbg(wpa_s
, MSG_DEBUG
,
1046 "Could not parse RSN element");
1048 wpa_dbg(wpa_s
, MSG_DEBUG
,
1049 "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1050 ie
.pairwise_cipher
, ie
.group_cipher
,
1055 wpa_hexdump(MSG_DEBUG
, "WPA", bss_wpa
, 2 + bss_wpa
[1]);
1056 if (wpa_parse_wpa_ie(bss_wpa
, 2 + bss_wpa
[1], &ie
)) {
1057 wpa_dbg(wpa_s
, MSG_DEBUG
,
1058 "Could not parse WPA element");
1060 wpa_dbg(wpa_s
, MSG_DEBUG
,
1061 "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x",
1062 ie
.pairwise_cipher
, ie
.group_cipher
,
1068 if (ssid
->proto
& WPA_PROTO_OSEN
)
1069 proto
= WPA_PROTO_OSEN
;
1070 else if (ssid
->proto
& WPA_PROTO_RSN
)
1071 proto
= WPA_PROTO_RSN
;
1073 proto
= WPA_PROTO_WPA
;
1074 if (wpa_supplicant_suites_from_ai(wpa_s
, ssid
, &ie
) < 0) {
1075 os_memset(&ie
, 0, sizeof(ie
));
1076 ie
.group_cipher
= ssid
->group_cipher
;
1077 ie
.pairwise_cipher
= ssid
->pairwise_cipher
;
1078 ie
.key_mgmt
= ssid
->key_mgmt
;
1079 #ifdef CONFIG_IEEE80211W
1080 ie
.mgmt_group_cipher
=
1081 ssid
->ieee80211w
!= NO_MGMT_FRAME_PROTECTION
?
1082 WPA_CIPHER_AES_128_CMAC
: 0;
1083 #endif /* CONFIG_IEEE80211W */
1084 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Set cipher suites "
1085 "based on configuration");
1090 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected cipher suites: group %d "
1091 "pairwise %d key_mgmt %d proto %d",
1092 ie
.group_cipher
, ie
.pairwise_cipher
, ie
.key_mgmt
, proto
);
1093 #ifdef CONFIG_IEEE80211W
1094 if (ssid
->ieee80211w
) {
1095 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected mgmt group cipher %d",
1096 ie
.mgmt_group_cipher
);
1098 #endif /* CONFIG_IEEE80211W */
1100 wpa_s
->wpa_proto
= proto
;
1101 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PROTO
, proto
);
1102 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_RSN_ENABLED
,
1103 !!(ssid
->proto
& (WPA_PROTO_RSN
| WPA_PROTO_OSEN
)));
1105 if (bss
|| !wpa_s
->ap_ies_from_associnfo
) {
1106 if (wpa_sm_set_ap_wpa_ie(wpa_s
->wpa
, bss_wpa
,
1107 bss_wpa
? 2 + bss_wpa
[1] : 0) ||
1108 wpa_sm_set_ap_rsn_ie(wpa_s
->wpa
, bss_rsn
,
1109 bss_rsn
? 2 + bss_rsn
[1] : 0))
1113 sel
= ie
.group_cipher
& ssid
->group_cipher
;
1114 wpa_s
->group_cipher
= wpa_pick_group_cipher(sel
);
1115 if (wpa_s
->group_cipher
< 0) {
1116 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select group "
1120 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK %s",
1121 wpa_cipher_txt(wpa_s
->group_cipher
));
1123 sel
= ie
.pairwise_cipher
& ssid
->pairwise_cipher
;
1124 wpa_s
->pairwise_cipher
= wpa_pick_pairwise_cipher(sel
, 1);
1125 if (wpa_s
->pairwise_cipher
< 0) {
1126 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select pairwise "
1130 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using PTK %s",
1131 wpa_cipher_txt(wpa_s
->pairwise_cipher
));
1133 sel
= ie
.key_mgmt
& ssid
->key_mgmt
;
1135 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SAE
))
1136 sel
&= ~(WPA_KEY_MGMT_SAE
| WPA_KEY_MGMT_FT_SAE
);
1137 #endif /* CONFIG_SAE */
1139 #ifdef CONFIG_SUITEB192
1140 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SUITE_B_192
) {
1141 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SUITE_B_192
;
1142 wpa_dbg(wpa_s
, MSG_DEBUG
,
1143 "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)");
1144 #endif /* CONFIG_SUITEB192 */
1145 #ifdef CONFIG_SUITEB
1146 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SUITE_B
) {
1147 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SUITE_B
;
1148 wpa_dbg(wpa_s
, MSG_DEBUG
,
1149 "WPA: using KEY_MGMT 802.1X with Suite B");
1150 #endif /* CONFIG_SUITEB */
1151 #ifdef CONFIG_IEEE80211R
1152 } else if (sel
& WPA_KEY_MGMT_FT_IEEE8021X
) {
1153 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_IEEE8021X
;
1154 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT/802.1X");
1155 } else if (sel
& WPA_KEY_MGMT_FT_PSK
) {
1156 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_PSK
;
1157 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT/PSK");
1158 #endif /* CONFIG_IEEE80211R */
1160 } else if (sel
& WPA_KEY_MGMT_SAE
) {
1161 wpa_s
->key_mgmt
= WPA_KEY_MGMT_SAE
;
1162 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using KEY_MGMT SAE");
1163 } else if (sel
& WPA_KEY_MGMT_FT_SAE
) {
1164 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_SAE
;
1165 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using KEY_MGMT FT/SAE");
1166 #endif /* CONFIG_SAE */
1167 #ifdef CONFIG_IEEE80211W
1168 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SHA256
) {
1169 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SHA256
;
1170 wpa_dbg(wpa_s
, MSG_DEBUG
,
1171 "WPA: using KEY_MGMT 802.1X with SHA256");
1172 } else if (sel
& WPA_KEY_MGMT_PSK_SHA256
) {
1173 wpa_s
->key_mgmt
= WPA_KEY_MGMT_PSK_SHA256
;
1174 wpa_dbg(wpa_s
, MSG_DEBUG
,
1175 "WPA: using KEY_MGMT PSK with SHA256");
1176 #endif /* CONFIG_IEEE80211W */
1177 } else if (sel
& WPA_KEY_MGMT_IEEE8021X
) {
1178 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X
;
1179 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT 802.1X");
1180 } else if (sel
& WPA_KEY_MGMT_PSK
) {
1181 wpa_s
->key_mgmt
= WPA_KEY_MGMT_PSK
;
1182 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT WPA-PSK");
1183 } else if (sel
& WPA_KEY_MGMT_WPA_NONE
) {
1184 wpa_s
->key_mgmt
= WPA_KEY_MGMT_WPA_NONE
;
1185 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT WPA-NONE");
1187 } else if (sel
& WPA_KEY_MGMT_OSEN
) {
1188 wpa_s
->key_mgmt
= WPA_KEY_MGMT_OSEN
;
1189 wpa_dbg(wpa_s
, MSG_DEBUG
, "HS 2.0: using KEY_MGMT OSEN");
1190 #endif /* CONFIG_HS20 */
1192 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select "
1193 "authenticated key management type");
1197 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_KEY_MGMT
, wpa_s
->key_mgmt
);
1198 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PAIRWISE
,
1199 wpa_s
->pairwise_cipher
);
1200 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_GROUP
, wpa_s
->group_cipher
);
1202 #ifdef CONFIG_IEEE80211W
1203 sel
= ie
.mgmt_group_cipher
;
1204 if (wpas_get_ssid_pmf(wpa_s
, ssid
) == NO_MGMT_FRAME_PROTECTION
||
1205 !(ie
.capabilities
& WPA_CAPABILITY_MFPC
))
1207 if (sel
& WPA_CIPHER_AES_128_CMAC
) {
1208 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_AES_128_CMAC
;
1209 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1211 } else if (sel
& WPA_CIPHER_BIP_GMAC_128
) {
1212 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_BIP_GMAC_128
;
1213 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1215 } else if (sel
& WPA_CIPHER_BIP_GMAC_256
) {
1216 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_BIP_GMAC_256
;
1217 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1219 } else if (sel
& WPA_CIPHER_BIP_CMAC_256
) {
1220 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_BIP_CMAC_256
;
1221 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1224 wpa_s
->mgmt_group_cipher
= 0;
1225 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: not using MGMT group cipher");
1227 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MGMT_GROUP
,
1228 wpa_s
->mgmt_group_cipher
);
1229 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MFP
,
1230 wpas_get_ssid_pmf(wpa_s
, ssid
));
1231 #endif /* CONFIG_IEEE80211W */
1233 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s
->wpa
, wpa_ie
, wpa_ie_len
)) {
1234 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to generate WPA IE");
1238 if (wpa_key_mgmt_wpa_psk(ssid
->key_mgmt
)) {
1239 wpa_sm_set_pmk(wpa_s
->wpa
, ssid
->psk
, PMK_LEN
, NULL
);
1240 #ifndef CONFIG_NO_PBKDF2
1241 if (bss
&& ssid
->bssid_set
&& ssid
->ssid_len
== 0 &&
1244 pbkdf2_sha1(ssid
->passphrase
, bss
->ssid
, bss
->ssid_len
,
1245 4096, psk
, PMK_LEN
);
1246 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from passphrase)",
1248 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
, NULL
);
1249 os_memset(psk
, 0, sizeof(psk
));
1251 #endif /* CONFIG_NO_PBKDF2 */
1252 #ifdef CONFIG_EXT_PASSWORD
1253 if (ssid
->ext_psk
) {
1254 struct wpabuf
*pw
= ext_password_get(wpa_s
->ext_pw
,
1256 char pw_str
[64 + 1];
1260 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: No PSK "
1261 "found from external storage");
1265 if (wpabuf_len(pw
) < 8 || wpabuf_len(pw
) > 64) {
1266 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: Unexpected "
1267 "PSK length %d in external storage",
1268 (int) wpabuf_len(pw
));
1269 ext_password_free(pw
);
1273 os_memcpy(pw_str
, wpabuf_head(pw
), wpabuf_len(pw
));
1274 pw_str
[wpabuf_len(pw
)] = '\0';
1276 #ifndef CONFIG_NO_PBKDF2
1277 if (wpabuf_len(pw
) >= 8 && wpabuf_len(pw
) < 64 && bss
)
1279 pbkdf2_sha1(pw_str
, bss
->ssid
, bss
->ssid_len
,
1280 4096, psk
, PMK_LEN
);
1281 os_memset(pw_str
, 0, sizeof(pw_str
));
1282 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from "
1283 "external passphrase)",
1285 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
, NULL
);
1286 os_memset(psk
, 0, sizeof(psk
));
1288 #endif /* CONFIG_NO_PBKDF2 */
1289 if (wpabuf_len(pw
) == 2 * PMK_LEN
) {
1290 if (hexstr2bin(pw_str
, psk
, PMK_LEN
) < 0) {
1291 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: "
1292 "Invalid PSK hex string");
1293 os_memset(pw_str
, 0, sizeof(pw_str
));
1294 ext_password_free(pw
);
1297 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
, NULL
);
1298 os_memset(psk
, 0, sizeof(psk
));
1300 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: No suitable "
1302 os_memset(pw_str
, 0, sizeof(pw_str
));
1303 ext_password_free(pw
);
1307 os_memset(pw_str
, 0, sizeof(pw_str
));
1308 ext_password_free(pw
);
1310 #endif /* CONFIG_EXT_PASSWORD */
1312 wpa_sm_set_pmk_from_pmksa(wpa_s
->wpa
);
1318 static void wpas_ext_capab_byte(struct wpa_supplicant
*wpa_s
, u8
*pos
, int idx
)
1323 case 0: /* Bits 0-7 */
1325 case 1: /* Bits 8-15 */
1327 case 2: /* Bits 16-23 */
1329 *pos
|= 0x02; /* Bit 17 - WNM-Sleep Mode */
1330 *pos
|= 0x08; /* Bit 19 - BSS Transition */
1331 #endif /* CONFIG_WNM */
1333 case 3: /* Bits 24-31 */
1335 *pos
|= 0x02; /* Bit 25 - SSID List */
1336 #endif /* CONFIG_WNM */
1337 #ifdef CONFIG_INTERWORKING
1338 if (wpa_s
->conf
->interworking
)
1339 *pos
|= 0x80; /* Bit 31 - Interworking */
1340 #endif /* CONFIG_INTERWORKING */
1342 case 4: /* Bits 32-39 */
1343 #ifdef CONFIG_INTERWORKING
1344 if (wpa_s
->drv_flags
/ WPA_DRIVER_FLAGS_QOS_MAPPING
)
1345 *pos
|= 0x01; /* Bit 32 - QoS Map */
1346 #endif /* CONFIG_INTERWORKING */
1348 case 5: /* Bits 40-47 */
1350 if (wpa_s
->conf
->hs20
)
1351 *pos
|= 0x40; /* Bit 46 - WNM-Notification */
1352 #endif /* CONFIG_HS20 */
1354 case 6: /* Bits 48-55 */
1360 int wpas_build_ext_capab(struct wpa_supplicant
*wpa_s
, u8
*buf
, size_t buflen
)
1365 if (len
< wpa_s
->extended_capa_len
)
1366 len
= wpa_s
->extended_capa_len
;
1367 if (buflen
< (size_t) len
+ 2) {
1368 wpa_printf(MSG_INFO
,
1369 "Not enough room for building extended capabilities element");
1373 *pos
++ = WLAN_EID_EXT_CAPAB
;
1375 for (i
= 0; i
< len
; i
++, pos
++) {
1376 wpas_ext_capab_byte(wpa_s
, pos
, i
);
1378 if (i
< wpa_s
->extended_capa_len
) {
1379 *pos
&= ~wpa_s
->extended_capa_mask
[i
];
1380 *pos
|= wpa_s
->extended_capa
[i
];
1384 while (len
> 0 && buf
[1 + len
] == 0) {
1395 static int wpas_valid_bss(struct wpa_supplicant
*wpa_s
,
1396 struct wpa_bss
*test_bss
)
1398 struct wpa_bss
*bss
;
1400 dl_list_for_each(bss
, &wpa_s
->bss
, struct wpa_bss
, list
) {
1401 if (bss
== test_bss
)
1409 static int wpas_valid_ssid(struct wpa_supplicant
*wpa_s
,
1410 struct wpa_ssid
*test_ssid
)
1412 struct wpa_ssid
*ssid
;
1414 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
) {
1415 if (ssid
== test_ssid
)
1423 int wpas_valid_bss_ssid(struct wpa_supplicant
*wpa_s
, struct wpa_bss
*test_bss
,
1424 struct wpa_ssid
*test_ssid
)
1426 if (test_bss
&& !wpas_valid_bss(wpa_s
, test_bss
))
1429 return test_ssid
== NULL
|| wpas_valid_ssid(wpa_s
, test_ssid
);
1433 void wpas_connect_work_free(struct wpa_connect_work
*cwork
)
1441 void wpas_connect_work_done(struct wpa_supplicant
*wpa_s
)
1443 struct wpa_connect_work
*cwork
;
1444 struct wpa_radio_work
*work
= wpa_s
->connect_work
;
1449 wpa_s
->connect_work
= NULL
;
1452 wpas_connect_work_free(cwork
);
1453 radio_work_done(work
);
1457 int wpas_update_random_addr(struct wpa_supplicant
*wpa_s
, int style
)
1459 struct os_reltime now
;
1462 os_get_reltime(&now
);
1463 if (wpa_s
->last_mac_addr_style
== style
&&
1464 wpa_s
->last_mac_addr_change
.sec
!= 0 &&
1465 !os_reltime_expired(&now
, &wpa_s
->last_mac_addr_change
,
1466 wpa_s
->conf
->rand_addr_lifetime
)) {
1467 wpa_msg(wpa_s
, MSG_DEBUG
,
1468 "Previously selected random MAC address has not yet expired");
1474 if (random_mac_addr(addr
) < 0)
1478 os_memcpy(addr
, wpa_s
->perm_addr
, ETH_ALEN
);
1479 if (random_mac_addr_keep_oui(addr
) < 0)
1486 if (wpa_drv_set_mac_addr(wpa_s
, addr
) < 0) {
1487 wpa_msg(wpa_s
, MSG_INFO
,
1488 "Failed to set random MAC address");
1492 os_get_reltime(&wpa_s
->last_mac_addr_change
);
1493 wpa_s
->mac_addr_changed
= 1;
1494 wpa_s
->last_mac_addr_style
= style
;
1496 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0) {
1497 wpa_msg(wpa_s
, MSG_INFO
,
1498 "Could not update MAC address information");
1502 wpa_msg(wpa_s
, MSG_DEBUG
, "Using random MAC address " MACSTR
,
1509 int wpas_update_random_addr_disassoc(struct wpa_supplicant
*wpa_s
)
1511 if (wpa_s
->wpa_state
>= WPA_AUTHENTICATING
||
1512 !wpa_s
->conf
->preassoc_mac_addr
)
1515 return wpas_update_random_addr(wpa_s
, wpa_s
->conf
->preassoc_mac_addr
);
1519 static void wpas_start_assoc_cb(struct wpa_radio_work
*work
, int deinit
);
1522 * wpa_supplicant_associate - Request association
1523 * @wpa_s: Pointer to wpa_supplicant data
1524 * @bss: Scan results for the selected BSS, or %NULL if not available
1525 * @ssid: Configuration data for the selected network
1527 * This function is used to request %wpa_supplicant to associate with a BSS.
1529 void wpa_supplicant_associate(struct wpa_supplicant
*wpa_s
,
1530 struct wpa_bss
*bss
, struct wpa_ssid
*ssid
)
1532 struct wpa_connect_work
*cwork
;
1535 if (ssid
->mac_addr
== -1)
1536 rand_style
= wpa_s
->conf
->mac_addr
;
1538 rand_style
= ssid
->mac_addr
;
1540 wmm_ac_clear_saved_tspecs(wpa_s
);
1541 wpa_s
->reassoc_same_bss
= 0;
1543 if (wpa_s
->last_ssid
== ssid
) {
1544 wpa_dbg(wpa_s
, MSG_DEBUG
, "Re-association to the same ESS");
1545 if (wpa_s
->current_bss
&& wpa_s
->current_bss
== bss
) {
1546 wmm_ac_save_tspecs(wpa_s
);
1547 wpa_s
->reassoc_same_bss
= 1;
1549 } else if (rand_style
> 0) {
1550 if (wpas_update_random_addr(wpa_s
, rand_style
) < 0)
1552 wpa_sm_pmksa_cache_flush(wpa_s
->wpa
, ssid
);
1553 } else if (wpa_s
->mac_addr_changed
) {
1554 if (wpa_drv_set_mac_addr(wpa_s
, NULL
) < 0) {
1555 wpa_msg(wpa_s
, MSG_INFO
,
1556 "Could not restore permanent MAC address");
1559 wpa_s
->mac_addr_changed
= 0;
1560 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0) {
1561 wpa_msg(wpa_s
, MSG_INFO
,
1562 "Could not update MAC address information");
1565 wpa_msg(wpa_s
, MSG_DEBUG
, "Using permanent MAC address");
1567 wpa_s
->last_ssid
= ssid
;
1569 #ifdef CONFIG_IBSS_RSN
1570 ibss_rsn_deinit(wpa_s
->ibss_rsn
);
1571 wpa_s
->ibss_rsn
= NULL
;
1572 #endif /* CONFIG_IBSS_RSN */
1574 if (ssid
->mode
== WPAS_MODE_AP
|| ssid
->mode
== WPAS_MODE_P2P_GO
||
1575 ssid
->mode
== WPAS_MODE_P2P_GROUP_FORMATION
) {
1577 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_AP
)) {
1578 wpa_msg(wpa_s
, MSG_INFO
, "Driver does not support AP "
1582 if (wpa_supplicant_create_ap(wpa_s
, ssid
) < 0) {
1583 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
1584 if (ssid
->mode
== WPAS_MODE_P2P_GROUP_FORMATION
)
1585 wpas_p2p_ap_setup_failed(wpa_s
);
1588 wpa_s
->current_bss
= bss
;
1589 #else /* CONFIG_AP */
1590 wpa_msg(wpa_s
, MSG_ERROR
, "AP mode support not included in "
1592 #endif /* CONFIG_AP */
1596 if (ssid
->mode
== WPAS_MODE_MESH
) {
1598 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_MESH
)) {
1599 wpa_msg(wpa_s
, MSG_INFO
,
1600 "Driver does not support mesh mode");
1604 ssid
->frequency
= bss
->freq
;
1605 if (wpa_supplicant_join_mesh(wpa_s
, ssid
) < 0) {
1606 wpa_msg(wpa_s
, MSG_ERROR
, "Could not join mesh");
1609 wpa_s
->current_bss
= bss
;
1610 wpa_msg_ctrl(wpa_s
, MSG_INFO
, MESH_GROUP_STARTED
1611 "ssid=\"%s\" id=%d",
1612 wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
),
1614 #else /* CONFIG_MESH */
1615 wpa_msg(wpa_s
, MSG_ERROR
,
1616 "mesh mode support not included in the build");
1617 #endif /* CONFIG_MESH */
1623 wpa_tdls_ap_ies(wpa_s
->wpa
, (const u8
*) (bss
+ 1),
1625 #endif /* CONFIG_TDLS */
1627 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SME
) &&
1628 ssid
->mode
== IEEE80211_MODE_INFRA
) {
1629 sme_authenticate(wpa_s
, bss
, ssid
);
1633 if (wpa_s
->connect_work
) {
1634 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reject wpa_supplicant_associate() call since connect_work exist");
1638 if (radio_work_pending(wpa_s
, "connect")) {
1639 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reject wpa_supplicant_associate() call since pending work exist");
1643 cwork
= os_zalloc(sizeof(*cwork
));
1650 if (radio_add_work(wpa_s
, bss
? bss
->freq
: 0, "connect", 1,
1651 wpas_start_assoc_cb
, cwork
) < 0) {
1657 void ibss_mesh_setup_freq(struct wpa_supplicant
*wpa_s
,
1658 const struct wpa_ssid
*ssid
,
1659 struct hostapd_freq_params
*freq
)
1661 enum hostapd_hw_mode hw_mode
;
1662 struct hostapd_hw_modes
*mode
= NULL
;
1663 int ht40plus
[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157,
1665 struct hostapd_channel_data
*pri_chan
= NULL
, *sec_chan
= NULL
;
1667 int i
, chan_idx
, ht40
= -1, res
;
1670 freq
->freq
= ssid
->frequency
;
1672 /* For IBSS check HT_IBSS flag */
1673 if (ssid
->mode
== WPAS_MODE_IBSS
&&
1674 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_HT_IBSS
))
1677 hw_mode
= ieee80211_freq_to_chan(ssid
->frequency
, &channel
);
1678 for (i
= 0; wpa_s
->hw
.modes
&& i
< wpa_s
->hw
.num_modes
; i
++) {
1679 if (wpa_s
->hw
.modes
[i
].mode
== hw_mode
) {
1680 mode
= &wpa_s
->hw
.modes
[i
];
1688 freq
->ht_enabled
= ht_supported(mode
);
1689 if (!freq
->ht_enabled
)
1692 /* Setup higher BW only for 5 GHz */
1693 if (mode
->mode
!= HOSTAPD_MODE_IEEE80211A
)
1696 for (chan_idx
= 0; chan_idx
< mode
->num_channels
; chan_idx
++) {
1697 pri_chan
= &mode
->channels
[chan_idx
];
1698 if (pri_chan
->chan
== channel
)
1705 /* Check primary channel flags */
1706 if (pri_chan
->flag
& (HOSTAPD_CHAN_DISABLED
| HOSTAPD_CHAN_NO_IR
))
1709 /* Check/setup HT40+/HT40- */
1710 for (j
= 0; j
< ARRAY_SIZE(ht40plus
); j
++) {
1711 if (ht40plus
[j
] == channel
) {
1717 /* Find secondary channel */
1718 for (i
= 0; i
< mode
->num_channels
; i
++) {
1719 sec_chan
= &mode
->channels
[i
];
1720 if (sec_chan
->chan
== channel
+ ht40
* 4)
1727 /* Check secondary channel flags */
1728 if (sec_chan
->flag
& (HOSTAPD_CHAN_DISABLED
| HOSTAPD_CHAN_NO_IR
))
1731 freq
->channel
= pri_chan
->chan
;
1735 if (!(pri_chan
->flag
& HOSTAPD_CHAN_HT40MINUS
))
1737 freq
->sec_channel_offset
= -1;
1740 if (!(pri_chan
->flag
& HOSTAPD_CHAN_HT40PLUS
))
1742 freq
->sec_channel_offset
= 1;
1748 if (freq
->sec_channel_offset
) {
1749 struct wpa_scan_results
*scan_res
;
1751 scan_res
= wpa_supplicant_get_scan_results(wpa_s
, NULL
, 0);
1752 if (scan_res
== NULL
) {
1754 freq
->sec_channel_offset
= 0;
1758 res
= check_40mhz_5g(mode
, scan_res
, pri_chan
->chan
,
1763 freq
->sec_channel_offset
= 0;
1766 /* Configuration allowed */
1769 /* Switch pri/sec channels */
1770 freq
->freq
= hw_get_freq(mode
, sec_chan
->chan
);
1771 freq
->sec_channel_offset
= -freq
->sec_channel_offset
;
1772 freq
->channel
= sec_chan
->chan
;
1775 freq
->sec_channel_offset
= 0;
1779 wpa_scan_results_free(scan_res
);
1782 wpa_printf(MSG_DEBUG
,
1783 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d",
1784 freq
->channel
, freq
->sec_channel_offset
);
1788 static void wpas_start_assoc_cb(struct wpa_radio_work
*work
, int deinit
)
1790 struct wpa_connect_work
*cwork
= work
->ctx
;
1791 struct wpa_bss
*bss
= cwork
->bss
;
1792 struct wpa_ssid
*ssid
= cwork
->ssid
;
1793 struct wpa_supplicant
*wpa_s
= work
->wpa_s
;
1796 int use_crypt
, ret
, i
, bssid_changed
;
1797 int algs
= WPA_AUTH_ALG_OPEN
;
1798 unsigned int cipher_pairwise
, cipher_group
;
1799 struct wpa_driver_associate_params params
;
1800 int wep_keys_set
= 0;
1801 int assoc_failed
= 0;
1802 struct wpa_ssid
*old_ssid
;
1803 #ifdef CONFIG_HT_OVERRIDES
1804 struct ieee80211_ht_capabilities htcaps
;
1805 struct ieee80211_ht_capabilities htcaps_mask
;
1806 #endif /* CONFIG_HT_OVERRIDES */
1807 #ifdef CONFIG_VHT_OVERRIDES
1808 struct ieee80211_vht_capabilities vhtcaps
;
1809 struct ieee80211_vht_capabilities vhtcaps_mask
;
1810 #endif /* CONFIG_VHT_OVERRIDES */
1813 if (work
->started
) {
1814 wpa_s
->connect_work
= NULL
;
1816 /* cancel possible auth. timeout */
1817 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
,
1820 wpas_connect_work_free(cwork
);
1824 wpa_s
->connect_work
= work
;
1826 if (cwork
->bss_removed
|| !wpas_valid_bss_ssid(wpa_s
, bss
, ssid
)) {
1827 wpa_dbg(wpa_s
, MSG_DEBUG
, "BSS/SSID entry for association not valid anymore - drop connection attempt");
1828 wpas_connect_work_done(wpa_s
);
1832 os_memset(¶ms
, 0, sizeof(params
));
1833 wpa_s
->reassociate
= 0;
1834 wpa_s
->eap_expected_failure
= 0;
1836 (!wpas_driver_bss_selection(wpa_s
) || wpas_wps_searching(wpa_s
))) {
1837 #ifdef CONFIG_IEEE80211R
1838 const u8
*ie
, *md
= NULL
;
1839 #endif /* CONFIG_IEEE80211R */
1840 wpa_msg(wpa_s
, MSG_INFO
, "Trying to associate with " MACSTR
1841 " (SSID='%s' freq=%d MHz)", MAC2STR(bss
->bssid
),
1842 wpa_ssid_txt(bss
->ssid
, bss
->ssid_len
), bss
->freq
);
1843 bssid_changed
= !is_zero_ether_addr(wpa_s
->bssid
);
1844 os_memset(wpa_s
->bssid
, 0, ETH_ALEN
);
1845 os_memcpy(wpa_s
->pending_bssid
, bss
->bssid
, ETH_ALEN
);
1847 wpas_notify_bssid_changed(wpa_s
);
1848 #ifdef CONFIG_IEEE80211R
1849 ie
= wpa_bss_get_ie(bss
, WLAN_EID_MOBILITY_DOMAIN
);
1850 if (ie
&& ie
[1] >= MOBILITY_DOMAIN_ID_LEN
)
1852 wpa_sm_set_ft_params(wpa_s
->wpa
, ie
, ie
? 2 + ie
[1] : 0);
1854 /* Prepare for the next transition */
1855 wpa_ft_prepare_auth_request(wpa_s
->wpa
, ie
);
1857 #endif /* CONFIG_IEEE80211R */
1859 } else if ((ssid
->ssid
== NULL
|| ssid
->ssid_len
== 0) &&
1860 wpa_s
->conf
->ap_scan
== 2 &&
1861 (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)) {
1862 /* Use ap_scan==1 style network selection to find the network
1864 wpas_connect_work_done(wpa_s
);
1865 wpa_s
->scan_req
= MANUAL_SCAN_REQ
;
1866 wpa_s
->reassociate
= 1;
1867 wpa_supplicant_req_scan(wpa_s
, 0, 0);
1869 #endif /* CONFIG_WPS */
1871 wpa_msg(wpa_s
, MSG_INFO
, "Trying to associate with SSID '%s'",
1872 wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
1873 os_memset(wpa_s
->pending_bssid
, 0, ETH_ALEN
);
1875 wpa_supplicant_cancel_sched_scan(wpa_s
);
1876 wpa_supplicant_cancel_scan(wpa_s
);
1878 /* Starting new association, so clear the possibly used WPA IE from the
1879 * previous association. */
1880 wpa_sm_set_assoc_wpa_ie(wpa_s
->wpa
, NULL
, 0);
1882 #ifdef IEEE8021X_EAPOL
1883 if (ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
1885 if (ssid
->non_leap
== 0)
1886 algs
= WPA_AUTH_ALG_LEAP
;
1888 algs
|= WPA_AUTH_ALG_LEAP
;
1891 #endif /* IEEE8021X_EAPOL */
1892 wpa_dbg(wpa_s
, MSG_DEBUG
, "Automatic auth_alg selection: 0x%x", algs
);
1893 if (ssid
->auth_alg
) {
1894 algs
= ssid
->auth_alg
;
1895 wpa_dbg(wpa_s
, MSG_DEBUG
, "Overriding auth_alg selection: "
1899 if (bss
&& (wpa_bss_get_vendor_ie(bss
, WPA_IE_VENDOR_TYPE
) ||
1900 wpa_bss_get_ie(bss
, WLAN_EID_RSN
)) &&
1901 wpa_key_mgmt_wpa(ssid
->key_mgmt
)) {
1902 int try_opportunistic
;
1903 try_opportunistic
= (ssid
->proactive_key_caching
< 0 ?
1905 ssid
->proactive_key_caching
) &&
1906 (ssid
->proto
& WPA_PROTO_RSN
);
1907 if (pmksa_cache_set_current(wpa_s
->wpa
, NULL
, bss
->bssid
,
1908 ssid
, try_opportunistic
) == 0)
1909 eapol_sm_notify_pmkid_attempt(wpa_s
->eapol
);
1910 wpa_ie_len
= sizeof(wpa_ie
);
1911 if (wpa_supplicant_set_suites(wpa_s
, bss
, ssid
,
1912 wpa_ie
, &wpa_ie_len
)) {
1913 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to set WPA "
1914 "key management and encryption suites");
1915 wpas_connect_work_done(wpa_s
);
1918 } else if ((ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
) && bss
&&
1919 wpa_key_mgmt_wpa_ieee8021x(ssid
->key_mgmt
)) {
1921 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1922 * use non-WPA since the scan results did not indicate that the
1923 * AP is using WPA or WPA2.
1925 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
1927 wpa_s
->wpa_proto
= 0;
1928 } else if (wpa_key_mgmt_wpa_any(ssid
->key_mgmt
)) {
1929 wpa_ie_len
= sizeof(wpa_ie
);
1930 if (wpa_supplicant_set_suites(wpa_s
, NULL
, ssid
,
1931 wpa_ie
, &wpa_ie_len
)) {
1932 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to set WPA "
1933 "key management and encryption suites (no "
1935 wpas_connect_work_done(wpa_s
);
1939 } else if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
) {
1940 struct wpabuf
*wps_ie
;
1941 wps_ie
= wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid
));
1942 if (wps_ie
&& wpabuf_len(wps_ie
) <= sizeof(wpa_ie
)) {
1943 wpa_ie_len
= wpabuf_len(wps_ie
);
1944 os_memcpy(wpa_ie
, wpabuf_head(wps_ie
), wpa_ie_len
);
1947 wpabuf_free(wps_ie
);
1948 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
1949 if (!bss
|| (bss
->caps
& IEEE80211_CAP_PRIVACY
))
1950 params
.wps
= WPS_MODE_PRIVACY
;
1952 params
.wps
= WPS_MODE_OPEN
;
1953 wpa_s
->wpa_proto
= 0;
1954 #endif /* CONFIG_WPS */
1956 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
1958 wpa_s
->wpa_proto
= 0;
1962 if (wpa_s
->global
->p2p
) {
1966 pos
= wpa_ie
+ wpa_ie_len
;
1967 len
= sizeof(wpa_ie
) - wpa_ie_len
;
1968 res
= wpas_p2p_assoc_req_ie(wpa_s
, bss
, pos
, len
,
1974 wpa_s
->cross_connect_disallowed
= 0;
1977 p2p
= wpa_bss_get_vendor_ie_multi(bss
, P2P_IE_VENDOR_TYPE
);
1979 wpa_s
->cross_connect_disallowed
=
1980 p2p_get_cross_connect_disallowed(p2p
);
1982 wpa_dbg(wpa_s
, MSG_DEBUG
, "P2P: WLAN AP %s cross "
1984 wpa_s
->cross_connect_disallowed
?
1985 "disallows" : "allows");
1989 os_memset(wpa_s
->p2p_ip_addr_info
, 0, sizeof(wpa_s
->p2p_ip_addr_info
));
1990 #endif /* CONFIG_P2P */
1993 if (is_hs20_network(wpa_s
, ssid
, bss
)) {
1994 struct wpabuf
*hs20
;
1995 hs20
= wpabuf_alloc(20);
1997 int pps_mo_id
= hs20_get_pps_mo_id(wpa_s
, ssid
);
2000 wpas_hs20_add_indication(hs20
, pps_mo_id
);
2001 len
= sizeof(wpa_ie
) - wpa_ie_len
;
2002 if (wpabuf_len(hs20
) <= len
) {
2003 os_memcpy(wpa_ie
+ wpa_ie_len
,
2004 wpabuf_head(hs20
), wpabuf_len(hs20
));
2005 wpa_ie_len
+= wpabuf_len(hs20
);
2010 #endif /* CONFIG_HS20 */
2013 * Workaround: Add Extended Capabilities element only if the AP
2014 * included this element in Beacon/Probe Response frames. Some older
2015 * APs seem to have interoperability issues if this element is
2016 * included, so while the standard may require us to include the
2017 * element in all cases, it is justifiable to skip it to avoid
2018 * interoperability issues.
2020 if (!bss
|| wpa_bss_get_ie(bss
, WLAN_EID_EXT_CAPAB
)) {
2023 ext_capab_len
= wpas_build_ext_capab(wpa_s
, ext_capab
,
2025 if (ext_capab_len
> 0) {
2027 if (wpa_ie_len
> 0 && pos
[0] == WLAN_EID_RSN
)
2029 os_memmove(pos
+ ext_capab_len
, pos
,
2030 wpa_ie_len
- (pos
- wpa_ie
));
2031 wpa_ie_len
+= ext_capab_len
;
2032 os_memcpy(pos
, ext_capab
, ext_capab_len
);
2036 if (wpa_s
->vendor_elem
[VENDOR_ELEM_ASSOC_REQ
]) {
2037 struct wpabuf
*buf
= wpa_s
->vendor_elem
[VENDOR_ELEM_ASSOC_REQ
];
2040 len
= sizeof(wpa_ie
) - wpa_ie_len
;
2041 if (wpabuf_len(buf
) <= len
) {
2042 os_memcpy(wpa_ie
+ wpa_ie_len
,
2043 wpabuf_head(buf
), wpabuf_len(buf
));
2044 wpa_ie_len
+= wpabuf_len(buf
);
2048 wpa_clear_keys(wpa_s
, bss
? bss
->bssid
: NULL
);
2050 cipher_pairwise
= wpa_s
->pairwise_cipher
;
2051 cipher_group
= wpa_s
->group_cipher
;
2052 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
||
2053 wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
2054 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
)
2056 if (wpa_set_wep_keys(wpa_s
, ssid
)) {
2061 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
)
2064 #ifdef IEEE8021X_EAPOL
2065 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
2066 if ((ssid
->eapol_flags
&
2067 (EAPOL_FLAG_REQUIRE_KEY_UNICAST
|
2068 EAPOL_FLAG_REQUIRE_KEY_BROADCAST
)) == 0 &&
2072 /* Assume that dynamic WEP-104 keys will be used and
2073 * set cipher suites in order for drivers to expect
2075 cipher_pairwise
= cipher_group
= WPA_CIPHER_WEP104
;
2078 #endif /* IEEE8021X_EAPOL */
2080 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
) {
2081 /* Set the key before (and later after) association */
2082 wpa_supplicant_set_wpa_none_key(wpa_s
, ssid
);
2085 wpa_supplicant_set_state(wpa_s
, WPA_ASSOCIATING
);
2087 params
.ssid
= bss
->ssid
;
2088 params
.ssid_len
= bss
->ssid_len
;
2089 if (!wpas_driver_bss_selection(wpa_s
) || ssid
->bssid_set
) {
2090 wpa_printf(MSG_DEBUG
, "Limit connection to BSSID "
2091 MACSTR
" freq=%u MHz based on scan results "
2093 MAC2STR(bss
->bssid
), bss
->freq
,
2095 params
.bssid
= bss
->bssid
;
2096 params
.freq
.freq
= bss
->freq
;
2098 params
.bssid_hint
= bss
->bssid
;
2099 params
.freq_hint
= bss
->freq
;
2101 params
.ssid
= ssid
->ssid
;
2102 params
.ssid_len
= ssid
->ssid_len
;
2105 if (ssid
->mode
== WPAS_MODE_IBSS
&& ssid
->bssid_set
&&
2106 wpa_s
->conf
->ap_scan
== 2) {
2107 params
.bssid
= ssid
->bssid
;
2108 params
.fixed_bssid
= 1;
2111 /* Initial frequency for IBSS/mesh */
2112 if ((ssid
->mode
== WPAS_MODE_IBSS
|| ssid
->mode
== WPAS_MODE_MESH
) &&
2113 ssid
->frequency
> 0 && params
.freq
.freq
== 0)
2114 ibss_mesh_setup_freq(wpa_s
, ssid
, ¶ms
.freq
);
2116 if (ssid
->mode
== WPAS_MODE_IBSS
) {
2117 if (ssid
->beacon_int
)
2118 params
.beacon_int
= ssid
->beacon_int
;
2120 params
.beacon_int
= wpa_s
->conf
->beacon_int
;
2123 params
.wpa_ie
= wpa_ie
;
2124 params
.wpa_ie_len
= wpa_ie_len
;
2125 params
.pairwise_suite
= cipher_pairwise
;
2126 params
.group_suite
= cipher_group
;
2127 params
.key_mgmt_suite
= wpa_s
->key_mgmt
;
2128 params
.wpa_proto
= wpa_s
->wpa_proto
;
2129 params
.auth_alg
= algs
;
2130 params
.mode
= ssid
->mode
;
2131 params
.bg_scan_period
= ssid
->bg_scan_period
;
2132 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
2133 if (ssid
->wep_key_len
[i
])
2134 params
.wep_key
[i
] = ssid
->wep_key
[i
];
2135 params
.wep_key_len
[i
] = ssid
->wep_key_len
[i
];
2137 params
.wep_tx_keyidx
= ssid
->wep_tx_keyidx
;
2139 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) &&
2140 (params
.key_mgmt_suite
== WPA_KEY_MGMT_PSK
||
2141 params
.key_mgmt_suite
== WPA_KEY_MGMT_FT_PSK
)) {
2142 params
.passphrase
= ssid
->passphrase
;
2144 params
.psk
= ssid
->psk
;
2147 if (wpa_s
->conf
->key_mgmt_offload
) {
2148 if (params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X
||
2149 params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SHA256
||
2150 params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SUITE_B
||
2151 params
.key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SUITE_B_192
)
2152 params
.req_key_mgmt_offload
=
2153 ssid
->proactive_key_caching
< 0 ?
2154 wpa_s
->conf
->okc
: ssid
->proactive_key_caching
;
2156 params
.req_key_mgmt_offload
= 1;
2158 if ((params
.key_mgmt_suite
== WPA_KEY_MGMT_PSK
||
2159 params
.key_mgmt_suite
== WPA_KEY_MGMT_PSK_SHA256
||
2160 params
.key_mgmt_suite
== WPA_KEY_MGMT_FT_PSK
) &&
2162 params
.psk
= ssid
->psk
;
2165 params
.drop_unencrypted
= use_crypt
;
2167 #ifdef CONFIG_IEEE80211W
2168 params
.mgmt_frame_protection
= wpas_get_ssid_pmf(wpa_s
, ssid
);
2169 if (params
.mgmt_frame_protection
!= NO_MGMT_FRAME_PROTECTION
&& bss
) {
2170 const u8
*rsn
= wpa_bss_get_ie(bss
, WLAN_EID_RSN
);
2171 struct wpa_ie_data ie
;
2172 if (rsn
&& wpa_parse_wpa_ie(rsn
, 2 + rsn
[1], &ie
) == 0 &&
2174 (WPA_CAPABILITY_MFPC
| WPA_CAPABILITY_MFPR
)) {
2175 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected AP supports "
2176 "MFP: require MFP");
2177 params
.mgmt_frame_protection
=
2178 MGMT_FRAME_PROTECTION_REQUIRED
;
2181 #endif /* CONFIG_IEEE80211W */
2183 params
.p2p
= ssid
->p2p_group
;
2185 if (wpa_s
->parent
->set_sta_uapsd
)
2186 params
.uapsd
= wpa_s
->parent
->sta_uapsd
;
2190 #ifdef CONFIG_HT_OVERRIDES
2191 os_memset(&htcaps
, 0, sizeof(htcaps
));
2192 os_memset(&htcaps_mask
, 0, sizeof(htcaps_mask
));
2193 params
.htcaps
= (u8
*) &htcaps
;
2194 params
.htcaps_mask
= (u8
*) &htcaps_mask
;
2195 wpa_supplicant_apply_ht_overrides(wpa_s
, ssid
, ¶ms
);
2196 #endif /* CONFIG_HT_OVERRIDES */
2197 #ifdef CONFIG_VHT_OVERRIDES
2198 os_memset(&vhtcaps
, 0, sizeof(vhtcaps
));
2199 os_memset(&vhtcaps_mask
, 0, sizeof(vhtcaps_mask
));
2200 params
.vhtcaps
= &vhtcaps
;
2201 params
.vhtcaps_mask
= &vhtcaps_mask
;
2202 wpa_supplicant_apply_vht_overrides(wpa_s
, ssid
, ¶ms
);
2203 #endif /* CONFIG_VHT_OVERRIDES */
2207 * If multi-channel concurrency is not supported, check for any
2208 * frequency conflict. In case of any frequency conflict, remove the
2209 * least prioritized connection.
2211 if (wpa_s
->num_multichan_concurrent
< 2) {
2213 num
= get_shared_radio_freqs(wpa_s
, &freq
, 1);
2214 if (num
> 0 && freq
> 0 && freq
!= params
.freq
.freq
) {
2215 wpa_printf(MSG_DEBUG
,
2216 "Assoc conflicting freq found (%d != %d)",
2217 freq
, params
.freq
.freq
);
2218 if (wpas_p2p_handle_frequency_conflicts(
2219 wpa_s
, params
.freq
.freq
, ssid
) < 0) {
2220 wpas_connect_work_done(wpa_s
);
2225 #endif /* CONFIG_P2P */
2227 ret
= wpa_drv_associate(wpa_s
, ¶ms
);
2229 wpa_msg(wpa_s
, MSG_INFO
, "Association request to the driver "
2231 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SANE_ERROR_CODES
) {
2233 * The driver is known to mean what is saying, so we
2234 * can stop right here; the association will not
2237 wpas_connection_failed(wpa_s
, wpa_s
->pending_bssid
);
2238 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
2239 os_memset(wpa_s
->pending_bssid
, 0, ETH_ALEN
);
2242 /* try to continue anyway; new association will be tried again
2247 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
) {
2248 /* Set the key after the association just in case association
2249 * cleared the previously configured key. */
2250 wpa_supplicant_set_wpa_none_key(wpa_s
, ssid
);
2251 /* No need to timeout authentication since there is no key
2253 wpa_supplicant_cancel_auth_timeout(wpa_s
);
2254 wpa_supplicant_set_state(wpa_s
, WPA_COMPLETED
);
2255 #ifdef CONFIG_IBSS_RSN
2256 } else if (ssid
->mode
== WPAS_MODE_IBSS
&&
2257 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_NONE
&&
2258 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPA_NONE
) {
2260 * RSN IBSS authentication is per-STA and we can disable the
2261 * per-BSSID authentication.
2263 wpa_supplicant_cancel_auth_timeout(wpa_s
);
2264 #endif /* CONFIG_IBSS_RSN */
2266 /* Timeout for IEEE 802.11 authentication and association */
2270 /* give IBSS a bit more time */
2271 timeout
= ssid
->mode
== WPAS_MODE_IBSS
? 10 : 5;
2272 } else if (wpa_s
->conf
->ap_scan
== 1) {
2273 /* give IBSS a bit more time */
2274 timeout
= ssid
->mode
== WPAS_MODE_IBSS
? 20 : 10;
2276 wpa_supplicant_req_auth_timeout(wpa_s
, timeout
, 0);
2280 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC
)) {
2281 /* Set static WEP keys again */
2282 wpa_set_wep_keys(wpa_s
, ssid
);
2285 if (wpa_s
->current_ssid
&& wpa_s
->current_ssid
!= ssid
) {
2287 * Do not allow EAP session resumption between different
2288 * network configurations.
2290 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
2292 old_ssid
= wpa_s
->current_ssid
;
2293 wpa_s
->current_ssid
= ssid
;
2294 wpa_s
->current_bss
= bss
;
2295 wpa_supplicant_rsn_supp_set_config(wpa_s
, wpa_s
->current_ssid
);
2296 wpa_supplicant_initiate_eapol(wpa_s
);
2297 if (old_ssid
!= wpa_s
->current_ssid
)
2298 wpas_notify_network_changed(wpa_s
);
2302 static void wpa_supplicant_clear_connection(struct wpa_supplicant
*wpa_s
,
2305 struct wpa_ssid
*old_ssid
;
2307 wpas_connect_work_done(wpa_s
);
2308 wpa_clear_keys(wpa_s
, addr
);
2309 old_ssid
= wpa_s
->current_ssid
;
2310 wpa_supplicant_mark_disassoc(wpa_s
);
2311 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
2312 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
2313 if (old_ssid
!= wpa_s
->current_ssid
)
2314 wpas_notify_network_changed(wpa_s
);
2315 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
2320 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
2321 * @wpa_s: Pointer to wpa_supplicant data
2322 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
2324 * This function is used to request %wpa_supplicant to deauthenticate from the
2327 void wpa_supplicant_deauthenticate(struct wpa_supplicant
*wpa_s
,
2331 union wpa_event_data event
;
2334 wpa_dbg(wpa_s
, MSG_DEBUG
, "Request to deauthenticate - bssid=" MACSTR
2335 " pending_bssid=" MACSTR
" reason=%d state=%s",
2336 MAC2STR(wpa_s
->bssid
), MAC2STR(wpa_s
->pending_bssid
),
2337 reason_code
, wpa_supplicant_state_txt(wpa_s
->wpa_state
));
2339 if (!is_zero_ether_addr(wpa_s
->bssid
))
2340 addr
= wpa_s
->bssid
;
2341 else if (!is_zero_ether_addr(wpa_s
->pending_bssid
) &&
2342 (wpa_s
->wpa_state
== WPA_AUTHENTICATING
||
2343 wpa_s
->wpa_state
== WPA_ASSOCIATING
))
2344 addr
= wpa_s
->pending_bssid
;
2345 else if (wpa_s
->wpa_state
== WPA_ASSOCIATING
) {
2347 * When using driver-based BSS selection, we may not know the
2348 * BSSID with which we are currently trying to associate. We
2349 * need to notify the driver of this disconnection even in such
2350 * a case, so use the all zeros address here.
2352 addr
= wpa_s
->bssid
;
2357 wpa_tdls_teardown_peers(wpa_s
->wpa
);
2358 #endif /* CONFIG_TDLS */
2362 wpa_msg_ctrl(wpa_s
, MSG_INFO
, MESH_GROUP_REMOVED
"%s",
2364 wpa_supplicant_leave_mesh(wpa_s
);
2366 #endif /* CONFIG_MESH */
2369 wpa_drv_deauthenticate(wpa_s
, addr
, reason_code
);
2370 os_memset(&event
, 0, sizeof(event
));
2371 event
.deauth_info
.reason_code
= (u16
) reason_code
;
2372 event
.deauth_info
.locally_generated
= 1;
2373 wpa_supplicant_event(wpa_s
, EVENT_DEAUTH
, &event
);
2378 wpa_supplicant_clear_connection(wpa_s
, addr
);
2381 static void wpa_supplicant_enable_one_network(struct wpa_supplicant
*wpa_s
,
2382 struct wpa_ssid
*ssid
)
2384 if (!ssid
|| !ssid
->disabled
|| ssid
->disabled
== 2)
2388 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
2389 wpas_notify_network_enabled_changed(wpa_s
, ssid
);
2392 * Try to reassociate since there is no current configuration and a new
2393 * network was made available.
2395 if (!wpa_s
->current_ssid
&& !wpa_s
->disconnected
)
2396 wpa_s
->reassociate
= 1;
2401 * wpa_supplicant_enable_network - Mark a configured network as enabled
2402 * @wpa_s: wpa_supplicant structure for a network interface
2403 * @ssid: wpa_ssid structure for a configured network or %NULL
2405 * Enables the specified network or all networks if no network specified.
2407 void wpa_supplicant_enable_network(struct wpa_supplicant
*wpa_s
,
2408 struct wpa_ssid
*ssid
)
2411 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
2412 wpa_supplicant_enable_one_network(wpa_s
, ssid
);
2414 wpa_supplicant_enable_one_network(wpa_s
, ssid
);
2416 if (wpa_s
->reassociate
&& !wpa_s
->disconnected
) {
2417 if (wpa_s
->sched_scanning
) {
2418 wpa_printf(MSG_DEBUG
, "Stop ongoing sched_scan to add "
2419 "new network to scan filters");
2420 wpa_supplicant_cancel_sched_scan(wpa_s
);
2423 if (wpa_supplicant_fast_associate(wpa_s
) != 1)
2424 wpa_supplicant_req_scan(wpa_s
, 0, 0);
2430 * wpa_supplicant_disable_network - Mark a configured network as disabled
2431 * @wpa_s: wpa_supplicant structure for a network interface
2432 * @ssid: wpa_ssid structure for a configured network or %NULL
2434 * Disables the specified network or all networks if no network specified.
2436 void wpa_supplicant_disable_network(struct wpa_supplicant
*wpa_s
,
2437 struct wpa_ssid
*ssid
)
2439 struct wpa_ssid
*other_ssid
;
2443 if (wpa_s
->sched_scanning
)
2444 wpa_supplicant_cancel_sched_scan(wpa_s
);
2446 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
2447 other_ssid
= other_ssid
->next
) {
2448 was_disabled
= other_ssid
->disabled
;
2449 if (was_disabled
== 2)
2450 continue; /* do not change persistent P2P group
2453 other_ssid
->disabled
= 1;
2455 if (was_disabled
!= other_ssid
->disabled
)
2456 wpas_notify_network_enabled_changed(
2459 if (wpa_s
->current_ssid
)
2460 wpa_supplicant_deauthenticate(
2461 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
2462 } else if (ssid
->disabled
!= 2) {
2463 if (ssid
== wpa_s
->current_ssid
)
2464 wpa_supplicant_deauthenticate(
2465 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
2467 was_disabled
= ssid
->disabled
;
2471 if (was_disabled
!= ssid
->disabled
) {
2472 wpas_notify_network_enabled_changed(wpa_s
, ssid
);
2473 if (wpa_s
->sched_scanning
) {
2474 wpa_printf(MSG_DEBUG
, "Stop ongoing sched_scan "
2475 "to remove network from filters");
2476 wpa_supplicant_cancel_sched_scan(wpa_s
);
2477 wpa_supplicant_req_scan(wpa_s
, 0, 0);
2485 * wpa_supplicant_select_network - Attempt association with a network
2486 * @wpa_s: wpa_supplicant structure for a network interface
2487 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
2489 void wpa_supplicant_select_network(struct wpa_supplicant
*wpa_s
,
2490 struct wpa_ssid
*ssid
)
2493 struct wpa_ssid
*other_ssid
;
2494 int disconnected
= 0;
2496 if (ssid
&& ssid
!= wpa_s
->current_ssid
&& wpa_s
->current_ssid
) {
2497 wpa_supplicant_deauthenticate(
2498 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
2503 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
2506 * Mark all other networks disabled or mark all networks enabled if no
2507 * network specified.
2509 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
2510 other_ssid
= other_ssid
->next
) {
2511 int was_disabled
= other_ssid
->disabled
;
2512 if (was_disabled
== 2)
2513 continue; /* do not change persistent P2P group data */
2515 other_ssid
->disabled
= ssid
? (ssid
->id
!= other_ssid
->id
) : 0;
2516 if (was_disabled
&& !other_ssid
->disabled
)
2517 wpas_clear_temp_disabled(wpa_s
, other_ssid
, 0);
2519 if (was_disabled
!= other_ssid
->disabled
)
2520 wpas_notify_network_enabled_changed(wpa_s
, other_ssid
);
2523 if (ssid
&& ssid
== wpa_s
->current_ssid
&& wpa_s
->current_ssid
) {
2524 /* We are already associated with the selected network */
2525 wpa_printf(MSG_DEBUG
, "Already associated with the "
2526 "selected network - do nothing");
2531 wpa_s
->current_ssid
= ssid
;
2532 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
2533 wpa_s
->connect_without_scan
=
2534 (ssid
->mode
== WPAS_MODE_MESH
) ? ssid
: NULL
;
2536 wpa_s
->connect_without_scan
= NULL
;
2539 wpa_s
->disconnected
= 0;
2540 wpa_s
->reassociate
= 1;
2542 if (wpa_s
->connect_without_scan
||
2543 wpa_supplicant_fast_associate(wpa_s
) != 1)
2544 wpa_supplicant_req_scan(wpa_s
, 0, disconnected
? 100000 : 0);
2547 wpas_notify_network_selected(wpa_s
, ssid
);
2552 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path
2553 * @wpa_s: wpa_supplicant structure for a network interface
2554 * @pkcs11_engine_path: PKCS #11 engine path or NULL
2555 * @pkcs11_module_path: PKCS #11 module path or NULL
2556 * Returns: 0 on success; -1 on failure
2558 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid
2559 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and
2560 * module path fails the paths will be reset to the default value (NULL).
2562 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant
*wpa_s
,
2563 const char *pkcs11_engine_path
,
2564 const char *pkcs11_module_path
)
2566 char *pkcs11_engine_path_copy
= NULL
;
2567 char *pkcs11_module_path_copy
= NULL
;
2569 if (pkcs11_engine_path
!= NULL
) {
2570 pkcs11_engine_path_copy
= os_strdup(pkcs11_engine_path
);
2571 if (pkcs11_engine_path_copy
== NULL
)
2574 if (pkcs11_module_path
!= NULL
) {
2575 pkcs11_module_path_copy
= os_strdup(pkcs11_module_path
);
2576 if (pkcs11_module_path_copy
== NULL
) {
2577 os_free(pkcs11_engine_path_copy
);
2582 os_free(wpa_s
->conf
->pkcs11_engine_path
);
2583 os_free(wpa_s
->conf
->pkcs11_module_path
);
2584 wpa_s
->conf
->pkcs11_engine_path
= pkcs11_engine_path_copy
;
2585 wpa_s
->conf
->pkcs11_module_path
= pkcs11_module_path_copy
;
2587 wpa_sm_set_eapol(wpa_s
->wpa
, NULL
);
2588 eapol_sm_deinit(wpa_s
->eapol
);
2589 wpa_s
->eapol
= NULL
;
2590 if (wpa_supplicant_init_eapol(wpa_s
)) {
2591 /* Error -> Reset paths to the default value (NULL) once. */
2592 if (pkcs11_engine_path
!= NULL
&& pkcs11_module_path
!= NULL
)
2593 wpas_set_pkcs11_engine_and_module_path(wpa_s
, NULL
,
2598 wpa_sm_set_eapol(wpa_s
->wpa
, wpa_s
->eapol
);
2605 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
2606 * @wpa_s: wpa_supplicant structure for a network interface
2607 * @ap_scan: AP scan mode
2608 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
2611 int wpa_supplicant_set_ap_scan(struct wpa_supplicant
*wpa_s
, int ap_scan
)
2616 if (ap_scan
< 0 || ap_scan
> 2)
2620 if (ap_scan
== 2 && ap_scan
!= wpa_s
->conf
->ap_scan
&&
2621 wpa_s
->wpa_state
>= WPA_ASSOCIATING
&&
2622 wpa_s
->wpa_state
< WPA_COMPLETED
) {
2623 wpa_printf(MSG_ERROR
, "ap_scan = %d (%d) rejected while "
2624 "associating", wpa_s
->conf
->ap_scan
, ap_scan
);
2627 #endif /* ANDROID */
2629 old_ap_scan
= wpa_s
->conf
->ap_scan
;
2630 wpa_s
->conf
->ap_scan
= ap_scan
;
2632 if (old_ap_scan
!= wpa_s
->conf
->ap_scan
)
2633 wpas_notify_ap_scan_changed(wpa_s
);
2640 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
2641 * @wpa_s: wpa_supplicant structure for a network interface
2642 * @expire_age: Expiration age in seconds
2643 * Returns: 0 if succeed or -1 if expire_age has an invalid value
2646 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant
*wpa_s
,
2647 unsigned int bss_expire_age
)
2649 if (bss_expire_age
< 10) {
2650 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid bss expiration age %u",
2654 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting bss expiration age: %d sec",
2656 wpa_s
->conf
->bss_expiration_age
= bss_expire_age
;
2663 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
2664 * @wpa_s: wpa_supplicant structure for a network interface
2665 * @expire_count: number of scans after which an unseen BSS is reclaimed
2666 * Returns: 0 if succeed or -1 if expire_count has an invalid value
2669 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant
*wpa_s
,
2670 unsigned int bss_expire_count
)
2672 if (bss_expire_count
< 1) {
2673 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid bss expiration count %u",
2677 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting bss expiration scan count: %u",
2679 wpa_s
->conf
->bss_expiration_scan_count
= bss_expire_count
;
2686 * wpa_supplicant_set_scan_interval - Set scan interval
2687 * @wpa_s: wpa_supplicant structure for a network interface
2688 * @scan_interval: scan interval in seconds
2689 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2692 int wpa_supplicant_set_scan_interval(struct wpa_supplicant
*wpa_s
,
2695 if (scan_interval
< 0) {
2696 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid scan interval %d",
2700 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting scan interval: %d sec",
2702 wpa_supplicant_update_scan_int(wpa_s
, scan_interval
);
2709 * wpa_supplicant_set_debug_params - Set global debug params
2710 * @global: wpa_global structure
2711 * @debug_level: debug level
2712 * @debug_timestamp: determines if show timestamp in debug data
2713 * @debug_show_keys: determines if show keys in debug data
2714 * Returns: 0 if succeed or -1 if debug_level has wrong value
2716 int wpa_supplicant_set_debug_params(struct wpa_global
*global
, int debug_level
,
2717 int debug_timestamp
, int debug_show_keys
)
2720 int old_level
, old_timestamp
, old_show_keys
;
2722 /* check for allowed debuglevels */
2723 if (debug_level
!= MSG_EXCESSIVE
&&
2724 debug_level
!= MSG_MSGDUMP
&&
2725 debug_level
!= MSG_DEBUG
&&
2726 debug_level
!= MSG_INFO
&&
2727 debug_level
!= MSG_WARNING
&&
2728 debug_level
!= MSG_ERROR
)
2731 old_level
= wpa_debug_level
;
2732 old_timestamp
= wpa_debug_timestamp
;
2733 old_show_keys
= wpa_debug_show_keys
;
2735 wpa_debug_level
= debug_level
;
2736 wpa_debug_timestamp
= debug_timestamp
? 1 : 0;
2737 wpa_debug_show_keys
= debug_show_keys
? 1 : 0;
2739 if (wpa_debug_level
!= old_level
)
2740 wpas_notify_debug_level_changed(global
);
2741 if (wpa_debug_timestamp
!= old_timestamp
)
2742 wpas_notify_debug_timestamp_changed(global
);
2743 if (wpa_debug_show_keys
!= old_show_keys
)
2744 wpas_notify_debug_show_keys_changed(global
);
2751 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2752 * @wpa_s: Pointer to wpa_supplicant data
2753 * Returns: A pointer to the current network structure or %NULL on failure
2755 struct wpa_ssid
* wpa_supplicant_get_ssid(struct wpa_supplicant
*wpa_s
)
2757 struct wpa_ssid
*entry
;
2758 u8 ssid
[MAX_SSID_LEN
];
2764 res
= wpa_drv_get_ssid(wpa_s
, ssid
);
2766 wpa_msg(wpa_s
, MSG_WARNING
, "Could not read SSID from "
2772 if (wpa_drv_get_bssid(wpa_s
, bssid
) < 0) {
2773 wpa_msg(wpa_s
, MSG_WARNING
, "Could not read BSSID from "
2778 wired
= wpa_s
->conf
->ap_scan
== 0 &&
2779 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
);
2781 entry
= wpa_s
->conf
->ssid
;
2783 if (!wpas_network_disabled(wpa_s
, entry
) &&
2784 ((ssid_len
== entry
->ssid_len
&&
2785 os_memcmp(ssid
, entry
->ssid
, ssid_len
) == 0) || wired
) &&
2786 (!entry
->bssid_set
||
2787 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0))
2790 if (!wpas_network_disabled(wpa_s
, entry
) &&
2791 (entry
->key_mgmt
& WPA_KEY_MGMT_WPS
) &&
2792 (entry
->ssid
== NULL
|| entry
->ssid_len
== 0) &&
2793 (!entry
->bssid_set
||
2794 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0))
2796 #endif /* CONFIG_WPS */
2798 if (!wpas_network_disabled(wpa_s
, entry
) && entry
->bssid_set
&&
2799 entry
->ssid_len
== 0 &&
2800 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0)
2803 entry
= entry
->next
;
2810 static int select_driver(struct wpa_supplicant
*wpa_s
, int i
)
2812 struct wpa_global
*global
= wpa_s
->global
;
2814 if (wpa_drivers
[i
]->global_init
&& global
->drv_priv
[i
] == NULL
) {
2815 global
->drv_priv
[i
] = wpa_drivers
[i
]->global_init();
2816 if (global
->drv_priv
[i
] == NULL
) {
2817 wpa_printf(MSG_ERROR
, "Failed to initialize driver "
2818 "'%s'", wpa_drivers
[i
]->name
);
2823 wpa_s
->driver
= wpa_drivers
[i
];
2824 wpa_s
->global_drv_priv
= global
->drv_priv
[i
];
2830 static int wpa_supplicant_set_driver(struct wpa_supplicant
*wpa_s
,
2835 const char *pos
, *driver
= name
;
2840 if (wpa_drivers
[0] == NULL
) {
2841 wpa_msg(wpa_s
, MSG_ERROR
, "No driver interfaces build into "
2847 /* default to first driver in the list */
2848 return select_driver(wpa_s
, 0);
2852 pos
= os_strchr(driver
, ',');
2856 len
= os_strlen(driver
);
2858 for (i
= 0; wpa_drivers
[i
]; i
++) {
2859 if (os_strlen(wpa_drivers
[i
]->name
) == len
&&
2860 os_strncmp(driver
, wpa_drivers
[i
]->name
, len
) ==
2862 /* First driver that succeeds wins */
2863 if (select_driver(wpa_s
, i
) == 0)
2871 wpa_msg(wpa_s
, MSG_ERROR
, "Unsupported driver '%s'", name
);
2877 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2878 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2879 * with struct wpa_driver_ops::init()
2880 * @src_addr: Source address of the EAPOL frame
2881 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2882 * @len: Length of the EAPOL data
2884 * This function is called for each received EAPOL frame. Most driver
2885 * interfaces rely on more generic OS mechanism for receiving frames through
2886 * l2_packet, but if such a mechanism is not available, the driver wrapper may
2887 * take care of received EAPOL frames and deliver them to the core supplicant
2888 * code by calling this function.
2890 void wpa_supplicant_rx_eapol(void *ctx
, const u8
*src_addr
,
2891 const u8
*buf
, size_t len
)
2893 struct wpa_supplicant
*wpa_s
= ctx
;
2895 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
, MAC2STR(src_addr
));
2896 wpa_hexdump(MSG_MSGDUMP
, "RX EAPOL", buf
, len
);
2898 #ifdef CONFIG_PEERKEY
2899 if (wpa_s
->wpa_state
> WPA_ASSOCIATED
&& wpa_s
->current_ssid
&&
2900 wpa_s
->current_ssid
->peerkey
&&
2901 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) &&
2902 wpa_sm_rx_eapol_peerkey(wpa_s
->wpa
, src_addr
, buf
, len
) == 1) {
2903 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: Processed PeerKey EAPOL-Key");
2906 #endif /* CONFIG_PEERKEY */
2908 if (wpa_s
->wpa_state
< WPA_ASSOCIATED
||
2909 (wpa_s
->last_eapol_matches_bssid
&&
2912 #endif /* CONFIG_AP */
2913 os_memcmp(src_addr
, wpa_s
->bssid
, ETH_ALEN
) != 0)) {
2915 * There is possible race condition between receiving the
2916 * association event and the EAPOL frame since they are coming
2917 * through different paths from the driver. In order to avoid
2918 * issues in trying to process the EAPOL frame before receiving
2919 * association information, lets queue it for processing until
2920 * the association event is received. This may also be needed in
2921 * driver-based roaming case, so also use src_addr != BSSID as a
2922 * trigger if we have previously confirmed that the
2923 * Authenticator uses BSSID as the src_addr (which is not the
2924 * case with wired IEEE 802.1X).
2926 wpa_dbg(wpa_s
, MSG_DEBUG
, "Not associated - Delay processing "
2927 "of received EAPOL frame (state=%s bssid=" MACSTR
")",
2928 wpa_supplicant_state_txt(wpa_s
->wpa_state
),
2929 MAC2STR(wpa_s
->bssid
));
2930 wpabuf_free(wpa_s
->pending_eapol_rx
);
2931 wpa_s
->pending_eapol_rx
= wpabuf_alloc_copy(buf
, len
);
2932 if (wpa_s
->pending_eapol_rx
) {
2933 os_get_reltime(&wpa_s
->pending_eapol_rx_time
);
2934 os_memcpy(wpa_s
->pending_eapol_rx_src
, src_addr
,
2940 wpa_s
->last_eapol_matches_bssid
=
2941 os_memcmp(src_addr
, wpa_s
->bssid
, ETH_ALEN
) == 0;
2944 if (wpa_s
->ap_iface
) {
2945 wpa_supplicant_ap_rx_eapol(wpa_s
, src_addr
, buf
, len
);
2948 #endif /* CONFIG_AP */
2950 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
) {
2951 wpa_dbg(wpa_s
, MSG_DEBUG
, "Ignored received EAPOL frame since "
2952 "no key management is configured");
2956 if (wpa_s
->eapol_received
== 0 &&
2957 (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) ||
2958 !wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
) ||
2959 wpa_s
->wpa_state
!= WPA_COMPLETED
) &&
2960 (wpa_s
->current_ssid
== NULL
||
2961 wpa_s
->current_ssid
->mode
!= IEEE80211_MODE_IBSS
)) {
2962 /* Timeout for completing IEEE 802.1X and WPA authentication */
2963 wpa_supplicant_req_auth_timeout(
2965 (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) ||
2966 wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
||
2967 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
) ?
2970 wpa_s
->eapol_received
++;
2972 if (wpa_s
->countermeasures
) {
2973 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Countermeasures - dropped "
2978 #ifdef CONFIG_IBSS_RSN
2979 if (wpa_s
->current_ssid
&&
2980 wpa_s
->current_ssid
->mode
== WPAS_MODE_IBSS
) {
2981 ibss_rsn_rx_eapol(wpa_s
->ibss_rsn
, src_addr
, buf
, len
);
2984 #endif /* CONFIG_IBSS_RSN */
2986 /* Source address of the incoming EAPOL frame could be compared to the
2987 * current BSSID. However, it is possible that a centralized
2988 * Authenticator could be using another MAC address than the BSSID of
2989 * an AP, so just allow any address to be used for now. The replies are
2990 * still sent to the current BSSID (if available), though. */
2992 os_memcpy(wpa_s
->last_eapol_src
, src_addr
, ETH_ALEN
);
2993 if (!wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
) &&
2994 eapol_sm_rx_eapol(wpa_s
->eapol
, src_addr
, buf
, len
) > 0)
2996 wpa_drv_poll(wpa_s
);
2997 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
))
2998 wpa_sm_rx_eapol(wpa_s
->wpa
, src_addr
, buf
, len
);
2999 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
)) {
3001 * Set portValid = TRUE here since we are going to skip 4-way
3002 * handshake processing which would normally set portValid. We
3003 * need this to allow the EAPOL state machines to be completed
3004 * without going through EAPOL-Key handshake.
3006 eapol_sm_notify_portValid(wpa_s
->eapol
, TRUE
);
3011 int wpa_supplicant_update_mac_addr(struct wpa_supplicant
*wpa_s
)
3013 if ((!wpa_s
->p2p_mgmt
||
3014 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
)) &&
3015 !(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE
)) {
3016 l2_packet_deinit(wpa_s
->l2
);
3017 wpa_s
->l2
= l2_packet_init(wpa_s
->ifname
,
3018 wpa_drv_get_mac_addr(wpa_s
),
3020 wpa_supplicant_rx_eapol
, wpa_s
, 0);
3021 if (wpa_s
->l2
== NULL
)
3024 const u8
*addr
= wpa_drv_get_mac_addr(wpa_s
);
3026 os_memcpy(wpa_s
->own_addr
, addr
, ETH_ALEN
);
3029 if (wpa_s
->l2
&& l2_packet_get_own_addr(wpa_s
->l2
, wpa_s
->own_addr
)) {
3030 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to get own L2 address");
3034 wpa_sm_set_own_addr(wpa_s
->wpa
, wpa_s
->own_addr
);
3040 static void wpa_supplicant_rx_eapol_bridge(void *ctx
, const u8
*src_addr
,
3041 const u8
*buf
, size_t len
)
3043 struct wpa_supplicant
*wpa_s
= ctx
;
3044 const struct l2_ethhdr
*eth
;
3046 if (len
< sizeof(*eth
))
3048 eth
= (const struct l2_ethhdr
*) buf
;
3050 if (os_memcmp(eth
->h_dest
, wpa_s
->own_addr
, ETH_ALEN
) != 0 &&
3051 !(eth
->h_dest
[0] & 0x01)) {
3052 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
" to " MACSTR
3053 " (bridge - not for this interface - ignore)",
3054 MAC2STR(src_addr
), MAC2STR(eth
->h_dest
));
3058 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
" to " MACSTR
3059 " (bridge)", MAC2STR(src_addr
), MAC2STR(eth
->h_dest
));
3060 wpa_supplicant_rx_eapol(wpa_s
, src_addr
, buf
+ sizeof(*eth
),
3061 len
- sizeof(*eth
));
3066 * wpa_supplicant_driver_init - Initialize driver interface parameters
3067 * @wpa_s: Pointer to wpa_supplicant data
3068 * Returns: 0 on success, -1 on failure
3070 * This function is called to initialize driver interface parameters.
3071 * wpa_drv_init() must have been called before this function to initialize the
3074 int wpa_supplicant_driver_init(struct wpa_supplicant
*wpa_s
)
3076 static int interface_count
= 0;
3078 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0)
3081 wpa_dbg(wpa_s
, MSG_DEBUG
, "Own MAC address: " MACSTR
,
3082 MAC2STR(wpa_s
->own_addr
));
3083 os_memcpy(wpa_s
->perm_addr
, wpa_s
->own_addr
, ETH_ALEN
);
3084 wpa_sm_set_own_addr(wpa_s
->wpa
, wpa_s
->own_addr
);
3086 if (wpa_s
->bridge_ifname
[0]) {
3087 wpa_dbg(wpa_s
, MSG_DEBUG
, "Receiving packets from bridge "
3088 "interface '%s'", wpa_s
->bridge_ifname
);
3089 wpa_s
->l2_br
= l2_packet_init(wpa_s
->bridge_ifname
,
3092 wpa_supplicant_rx_eapol_bridge
,
3094 if (wpa_s
->l2_br
== NULL
) {
3095 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to open l2_packet "
3096 "connection for the bridge interface '%s'",
3097 wpa_s
->bridge_ifname
);
3102 wpa_clear_keys(wpa_s
, NULL
);
3104 /* Make sure that TKIP countermeasures are not left enabled (could
3105 * happen if wpa_supplicant is killed during countermeasures. */
3106 wpa_drv_set_countermeasures(wpa_s
, 0);
3108 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: flushing PMKID list in the driver");
3109 wpa_drv_flush_pmkid(wpa_s
);
3111 wpa_s
->prev_scan_ssid
= WILDCARD_SSID_SCAN
;
3112 wpa_s
->prev_scan_wildcard
= 0;
3114 if (wpa_supplicant_enabled_networks(wpa_s
)) {
3115 if (wpa_s
->wpa_state
== WPA_INTERFACE_DISABLED
) {
3116 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
3117 interface_count
= 0;
3120 if (!wpa_s
->p2p_mgmt
&&
3121 wpa_supplicant_delayed_sched_scan(wpa_s
,
3122 interface_count
% 3,
3124 wpa_supplicant_req_scan(wpa_s
, interface_count
% 3,
3126 #endif /* ANDROID */
3129 wpa_supplicant_set_state(wpa_s
, WPA_INACTIVE
);
3135 static int wpa_supplicant_daemon(const char *pid_file
)
3137 wpa_printf(MSG_DEBUG
, "Daemonize..");
3138 return os_daemonize(pid_file
);
3142 static struct wpa_supplicant
* wpa_supplicant_alloc(void)
3144 struct wpa_supplicant
*wpa_s
;
3146 wpa_s
= os_zalloc(sizeof(*wpa_s
));
3149 wpa_s
->scan_req
= INITIAL_SCAN_REQ
;
3150 wpa_s
->scan_interval
= 5;
3151 wpa_s
->new_connection
= 1;
3152 wpa_s
->parent
= wpa_s
;
3153 wpa_s
->sched_scanning
= 0;
3159 #ifdef CONFIG_HT_OVERRIDES
3161 static int wpa_set_htcap_mcs(struct wpa_supplicant
*wpa_s
,
3162 struct ieee80211_ht_capabilities
*htcaps
,
3163 struct ieee80211_ht_capabilities
*htcaps_mask
,
3166 /* parse ht_mcs into hex array */
3168 const char *tmp
= ht_mcs
;
3171 /* If ht_mcs is null, do not set anything */
3175 /* This is what we are setting in the kernel */
3176 os_memset(&htcaps
->supported_mcs_set
, 0, IEEE80211_HT_MCS_MASK_LEN
);
3178 wpa_msg(wpa_s
, MSG_DEBUG
, "set_htcap, ht_mcs -:%s:-", ht_mcs
);
3180 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++) {
3182 long v
= strtol(tmp
, &end
, 16);
3184 wpa_msg(wpa_s
, MSG_DEBUG
,
3185 "htcap value[%i]: %ld end: %p tmp: %p",
3190 htcaps
->supported_mcs_set
[i
] = v
;
3193 wpa_msg(wpa_s
, MSG_ERROR
,
3194 "Failed to parse ht-mcs: %s, error: %s\n",
3195 ht_mcs
, strerror(errno
));
3201 * If we were able to parse any values, then set mask for the MCS set.
3204 os_memset(&htcaps_mask
->supported_mcs_set
, 0xff,
3205 IEEE80211_HT_MCS_MASK_LEN
- 1);
3206 /* skip the 3 reserved bits */
3207 htcaps_mask
->supported_mcs_set
[IEEE80211_HT_MCS_MASK_LEN
- 1] =
3215 static int wpa_disable_max_amsdu(struct wpa_supplicant
*wpa_s
,
3216 struct ieee80211_ht_capabilities
*htcaps
,
3217 struct ieee80211_ht_capabilities
*htcaps_mask
,
3222 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_max_amsdu: %d", disabled
);
3227 msk
= host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE
);
3228 htcaps_mask
->ht_capabilities_info
|= msk
;
3230 htcaps
->ht_capabilities_info
&= msk
;
3232 htcaps
->ht_capabilities_info
|= msk
;
3238 static int wpa_set_ampdu_factor(struct wpa_supplicant
*wpa_s
,
3239 struct ieee80211_ht_capabilities
*htcaps
,
3240 struct ieee80211_ht_capabilities
*htcaps_mask
,
3243 wpa_msg(wpa_s
, MSG_DEBUG
, "set_ampdu_factor: %d", factor
);
3248 if (factor
< 0 || factor
> 3) {
3249 wpa_msg(wpa_s
, MSG_ERROR
, "ampdu_factor: %d out of range. "
3250 "Must be 0-3 or -1", factor
);
3254 htcaps_mask
->a_mpdu_params
|= 0x3; /* 2 bits for factor */
3255 htcaps
->a_mpdu_params
&= ~0x3;
3256 htcaps
->a_mpdu_params
|= factor
& 0x3;
3262 static int wpa_set_ampdu_density(struct wpa_supplicant
*wpa_s
,
3263 struct ieee80211_ht_capabilities
*htcaps
,
3264 struct ieee80211_ht_capabilities
*htcaps_mask
,
3267 wpa_msg(wpa_s
, MSG_DEBUG
, "set_ampdu_density: %d", density
);
3272 if (density
< 0 || density
> 7) {
3273 wpa_msg(wpa_s
, MSG_ERROR
,
3274 "ampdu_density: %d out of range. Must be 0-7 or -1.",
3279 htcaps_mask
->a_mpdu_params
|= 0x1C;
3280 htcaps
->a_mpdu_params
&= ~(0x1C);
3281 htcaps
->a_mpdu_params
|= (density
<< 2) & 0x1C;
3287 static int wpa_set_disable_ht40(struct wpa_supplicant
*wpa_s
,
3288 struct ieee80211_ht_capabilities
*htcaps
,
3289 struct ieee80211_ht_capabilities
*htcaps_mask
,
3292 /* Masking these out disables HT40 */
3293 le16 msk
= host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET
|
3294 HT_CAP_INFO_SHORT_GI40MHZ
);
3296 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_ht40: %d", disabled
);
3299 htcaps
->ht_capabilities_info
&= ~msk
;
3301 htcaps
->ht_capabilities_info
|= msk
;
3303 htcaps_mask
->ht_capabilities_info
|= msk
;
3309 static int wpa_set_disable_sgi(struct wpa_supplicant
*wpa_s
,
3310 struct ieee80211_ht_capabilities
*htcaps
,
3311 struct ieee80211_ht_capabilities
*htcaps_mask
,
3314 /* Masking these out disables SGI */
3315 le16 msk
= host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ
|
3316 HT_CAP_INFO_SHORT_GI40MHZ
);
3318 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_sgi: %d", disabled
);
3321 htcaps
->ht_capabilities_info
&= ~msk
;
3323 htcaps
->ht_capabilities_info
|= msk
;
3325 htcaps_mask
->ht_capabilities_info
|= msk
;
3331 static int wpa_set_disable_ldpc(struct wpa_supplicant
*wpa_s
,
3332 struct ieee80211_ht_capabilities
*htcaps
,
3333 struct ieee80211_ht_capabilities
*htcaps_mask
,
3336 /* Masking these out disables LDPC */
3337 le16 msk
= host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP
);
3339 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_ldpc: %d", disabled
);
3342 htcaps
->ht_capabilities_info
&= ~msk
;
3344 htcaps
->ht_capabilities_info
|= msk
;
3346 htcaps_mask
->ht_capabilities_info
|= msk
;
3352 void wpa_supplicant_apply_ht_overrides(
3353 struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
,
3354 struct wpa_driver_associate_params
*params
)
3356 struct ieee80211_ht_capabilities
*htcaps
;
3357 struct ieee80211_ht_capabilities
*htcaps_mask
;
3362 params
->disable_ht
= ssid
->disable_ht
;
3363 if (!params
->htcaps
|| !params
->htcaps_mask
)
3366 htcaps
= (struct ieee80211_ht_capabilities
*) params
->htcaps
;
3367 htcaps_mask
= (struct ieee80211_ht_capabilities
*) params
->htcaps_mask
;
3368 wpa_set_htcap_mcs(wpa_s
, htcaps
, htcaps_mask
, ssid
->ht_mcs
);
3369 wpa_disable_max_amsdu(wpa_s
, htcaps
, htcaps_mask
,
3370 ssid
->disable_max_amsdu
);
3371 wpa_set_ampdu_factor(wpa_s
, htcaps
, htcaps_mask
, ssid
->ampdu_factor
);
3372 wpa_set_ampdu_density(wpa_s
, htcaps
, htcaps_mask
, ssid
->ampdu_density
);
3373 wpa_set_disable_ht40(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_ht40
);
3374 wpa_set_disable_sgi(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_sgi
);
3375 wpa_set_disable_ldpc(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_ldpc
);
3377 if (ssid
->ht40_intolerant
) {
3378 le16 bit
= host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT
);
3379 htcaps
->ht_capabilities_info
|= bit
;
3380 htcaps_mask
->ht_capabilities_info
|= bit
;
3384 #endif /* CONFIG_HT_OVERRIDES */
3387 #ifdef CONFIG_VHT_OVERRIDES
3388 void wpa_supplicant_apply_vht_overrides(
3389 struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
,
3390 struct wpa_driver_associate_params
*params
)
3392 struct ieee80211_vht_capabilities
*vhtcaps
;
3393 struct ieee80211_vht_capabilities
*vhtcaps_mask
;
3398 params
->disable_vht
= ssid
->disable_vht
;
3400 vhtcaps
= (void *) params
->vhtcaps
;
3401 vhtcaps_mask
= (void *) params
->vhtcaps_mask
;
3403 if (!vhtcaps
|| !vhtcaps_mask
)
3406 vhtcaps
->vht_capabilities_info
= ssid
->vht_capa
;
3407 vhtcaps_mask
->vht_capabilities_info
= ssid
->vht_capa_mask
;
3409 #ifdef CONFIG_HT_OVERRIDES
3410 /* if max ampdu is <= 3, we have to make the HT cap the same */
3411 if (ssid
->vht_capa_mask
& VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX
) {
3414 max_ampdu
= (ssid
->vht_capa
&
3415 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX
) >>
3416 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT
;
3418 max_ampdu
= max_ampdu
< 3 ? max_ampdu
: 3;
3419 wpa_set_ampdu_factor(wpa_s
,
3420 (void *) params
->htcaps
,
3421 (void *) params
->htcaps_mask
,
3424 #endif /* CONFIG_HT_OVERRIDES */
3426 #define OVERRIDE_MCS(i) \
3427 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \
3428 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \
3430 vhtcaps->vht_supported_mcs_set.tx_map |= \
3431 ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1); \
3433 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \
3434 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \
3436 vhtcaps->vht_supported_mcs_set.rx_map |= \
3437 ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1); \
3449 #endif /* CONFIG_VHT_OVERRIDES */
3452 static int pcsc_reader_init(struct wpa_supplicant
*wpa_s
)
3457 if (!wpa_s
->conf
->pcsc_reader
)
3460 wpa_s
->scard
= scard_init(wpa_s
->conf
->pcsc_reader
);
3464 if (wpa_s
->conf
->pcsc_pin
&&
3465 scard_set_pin(wpa_s
->scard
, wpa_s
->conf
->pcsc_pin
) < 0) {
3466 scard_deinit(wpa_s
->scard
);
3467 wpa_s
->scard
= NULL
;
3468 wpa_msg(wpa_s
, MSG_ERROR
, "PC/SC PIN validation failed");
3472 len
= sizeof(wpa_s
->imsi
) - 1;
3473 if (scard_get_imsi(wpa_s
->scard
, wpa_s
->imsi
, &len
)) {
3474 scard_deinit(wpa_s
->scard
);
3475 wpa_s
->scard
= NULL
;
3476 wpa_msg(wpa_s
, MSG_ERROR
, "Could not read IMSI");
3479 wpa_s
->imsi
[len
] = '\0';
3481 wpa_s
->mnc_len
= scard_get_mnc_len(wpa_s
->scard
);
3483 wpa_printf(MSG_DEBUG
, "SCARD: IMSI %s (MNC length %d)",
3484 wpa_s
->imsi
, wpa_s
->mnc_len
);
3486 wpa_sm_set_scard_ctx(wpa_s
->wpa
, wpa_s
->scard
);
3487 eapol_sm_register_scard_ctx(wpa_s
->eapol
, wpa_s
->scard
);
3488 #endif /* PCSC_FUNCS */
3494 int wpas_init_ext_pw(struct wpa_supplicant
*wpa_s
)
3498 ext_password_deinit(wpa_s
->ext_pw
);
3499 wpa_s
->ext_pw
= NULL
;
3500 eapol_sm_set_ext_pw_ctx(wpa_s
->eapol
, NULL
);
3502 if (!wpa_s
->conf
->ext_password_backend
)
3505 val
= os_strdup(wpa_s
->conf
->ext_password_backend
);
3508 pos
= os_strchr(val
, ':');
3512 wpa_printf(MSG_DEBUG
, "EXT PW: Initialize backend '%s'", val
);
3514 wpa_s
->ext_pw
= ext_password_init(val
, pos
);
3516 if (wpa_s
->ext_pw
== NULL
) {
3517 wpa_printf(MSG_DEBUG
, "EXT PW: Failed to initialize backend");
3520 eapol_sm_set_ext_pw_ctx(wpa_s
->eapol
, wpa_s
->ext_pw
);
3526 static int wpas_set_wowlan_triggers(struct wpa_supplicant
*wpa_s
,
3527 const struct wpa_driver_capa
*capa
)
3529 struct wowlan_triggers
*triggers
;
3532 if (!wpa_s
->conf
->wowlan_triggers
)
3535 triggers
= wpa_get_wowlan_triggers(wpa_s
->conf
->wowlan_triggers
, capa
);
3537 ret
= wpa_drv_wowlan(wpa_s
, triggers
);
3544 static struct wpa_radio
* radio_add_interface(struct wpa_supplicant
*wpa_s
,
3547 struct wpa_supplicant
*iface
= wpa_s
->global
->ifaces
;
3548 struct wpa_radio
*radio
;
3550 while (rn
&& iface
) {
3551 radio
= iface
->radio
;
3552 if (radio
&& os_strcmp(rn
, radio
->name
) == 0) {
3553 wpa_printf(MSG_DEBUG
, "Add interface %s to existing radio %s",
3555 dl_list_add(&radio
->ifaces
, &wpa_s
->radio_list
);
3559 iface
= iface
->next
;
3562 wpa_printf(MSG_DEBUG
, "Add interface %s to a new radio %s",
3563 wpa_s
->ifname
, rn
? rn
: "N/A");
3564 radio
= os_zalloc(sizeof(*radio
));
3569 os_strlcpy(radio
->name
, rn
, sizeof(radio
->name
));
3570 dl_list_init(&radio
->ifaces
);
3571 dl_list_init(&radio
->work
);
3572 dl_list_add(&radio
->ifaces
, &wpa_s
->radio_list
);
3578 static void radio_work_free(struct wpa_radio_work
*work
)
3580 if (work
->wpa_s
->scan_work
== work
) {
3581 /* This should not really happen. */
3582 wpa_dbg(work
->wpa_s
, MSG_INFO
, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
3583 work
->type
, work
, work
->started
);
3584 work
->wpa_s
->scan_work
= NULL
;
3588 if (work
->wpa_s
->p2p_scan_work
== work
) {
3589 /* This should not really happen. */
3590 wpa_dbg(work
->wpa_s
, MSG_INFO
, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
3591 work
->type
, work
, work
->started
);
3592 work
->wpa_s
->p2p_scan_work
= NULL
;
3594 #endif /* CONFIG_P2P */
3596 dl_list_del(&work
->list
);
3601 static void radio_start_next_work(void *eloop_ctx
, void *timeout_ctx
)
3603 struct wpa_radio
*radio
= eloop_ctx
;
3604 struct wpa_radio_work
*work
;
3605 struct os_reltime now
, diff
;
3606 struct wpa_supplicant
*wpa_s
;
3608 work
= dl_list_first(&radio
->work
, struct wpa_radio_work
, list
);
3613 return; /* already started and still in progress */
3615 wpa_s
= dl_list_first(&radio
->ifaces
, struct wpa_supplicant
,
3617 if (wpa_s
&& wpa_s
->radio
->external_scan_running
) {
3618 wpa_printf(MSG_DEBUG
, "Delay radio work start until externally triggered scan completes");
3622 os_get_reltime(&now
);
3623 os_reltime_sub(&now
, &work
->time
, &diff
);
3624 wpa_dbg(work
->wpa_s
, MSG_DEBUG
, "Starting radio work '%s'@%p after %ld.%06ld second wait",
3625 work
->type
, work
, diff
.sec
, diff
.usec
);
3633 * This function removes both started and pending radio works running on
3634 * the provided interface's radio.
3635 * Prior to the removal of the radio work, its callback (cb) is called with
3636 * deinit set to be 1. Each work's callback is responsible for clearing its
3637 * internal data and restoring to a correct state.
3638 * @wpa_s: wpa_supplicant data
3639 * @type: type of works to be removed
3640 * @remove_all: 1 to remove all the works on this radio, 0 to remove only
3641 * this interface's works.
3643 void radio_remove_works(struct wpa_supplicant
*wpa_s
,
3644 const char *type
, int remove_all
)
3646 struct wpa_radio_work
*work
, *tmp
;
3647 struct wpa_radio
*radio
= wpa_s
->radio
;
3649 dl_list_for_each_safe(work
, tmp
, &radio
->work
, struct wpa_radio_work
,
3651 if (type
&& os_strcmp(type
, work
->type
) != 0)
3654 /* skip other ifaces' works */
3655 if (!remove_all
&& work
->wpa_s
!= wpa_s
)
3658 wpa_dbg(wpa_s
, MSG_DEBUG
, "Remove radio work '%s'@%p%s",
3659 work
->type
, work
, work
->started
? " (started)" : "");
3661 radio_work_free(work
);
3664 /* in case we removed the started work */
3665 radio_work_check_next(wpa_s
);
3669 static void radio_remove_interface(struct wpa_supplicant
*wpa_s
)
3671 struct wpa_radio
*radio
= wpa_s
->radio
;
3676 wpa_printf(MSG_DEBUG
, "Remove interface %s from radio %s",
3677 wpa_s
->ifname
, radio
->name
);
3678 dl_list_del(&wpa_s
->radio_list
);
3679 radio_remove_works(wpa_s
, NULL
, 0);
3680 wpa_s
->radio
= NULL
;
3681 if (!dl_list_empty(&radio
->ifaces
))
3682 return; /* Interfaces remain for this radio */
3684 wpa_printf(MSG_DEBUG
, "Remove radio %s", radio
->name
);
3685 eloop_cancel_timeout(radio_start_next_work
, radio
, NULL
);
3690 void radio_work_check_next(struct wpa_supplicant
*wpa_s
)
3692 struct wpa_radio
*radio
= wpa_s
->radio
;
3694 if (dl_list_empty(&radio
->work
))
3696 if (wpa_s
->ext_work_in_progress
) {
3697 wpa_printf(MSG_DEBUG
,
3698 "External radio work in progress - delay start of pending item");
3701 eloop_cancel_timeout(radio_start_next_work
, radio
, NULL
);
3702 eloop_register_timeout(0, 0, radio_start_next_work
, radio
, NULL
);
3707 * radio_add_work - Add a radio work item
3708 * @wpa_s: Pointer to wpa_supplicant data
3709 * @freq: Frequency of the offchannel operation in MHz or 0
3710 * @type: Unique identifier for each type of work
3711 * @next: Force as the next work to be executed
3712 * @cb: Callback function for indicating when radio is available
3713 * @ctx: Context pointer for the work (work->ctx in cb())
3714 * Returns: 0 on success, -1 on failure
3716 * This function is used to request time for an operation that requires
3717 * exclusive radio control. Once the radio is available, the registered callback
3718 * function will be called. radio_work_done() must be called once the exclusive
3719 * radio operation has been completed, so that the radio is freed for other
3720 * operations. The special case of deinit=1 is used to free the context data
3721 * during interface removal. That does not allow the callback function to start
3722 * the radio operation, i.e., it must free any resources allocated for the radio
3725 * The @freq parameter can be used to indicate a single channel on which the
3726 * offchannel operation will occur. This may allow multiple radio work
3727 * operations to be performed in parallel if they apply for the same channel.
3728 * Setting this to 0 indicates that the work item may use multiple channels or
3729 * requires exclusive control of the radio.
3731 int radio_add_work(struct wpa_supplicant
*wpa_s
, unsigned int freq
,
3732 const char *type
, int next
,
3733 void (*cb
)(struct wpa_radio_work
*work
, int deinit
),
3736 struct wpa_radio_work
*work
;
3739 work
= os_zalloc(sizeof(*work
));
3742 wpa_dbg(wpa_s
, MSG_DEBUG
, "Add radio work '%s'@%p", type
, work
);
3743 os_get_reltime(&work
->time
);
3746 work
->wpa_s
= wpa_s
;
3750 was_empty
= dl_list_empty(&wpa_s
->radio
->work
);
3752 dl_list_add(&wpa_s
->radio
->work
, &work
->list
);
3754 dl_list_add_tail(&wpa_s
->radio
->work
, &work
->list
);
3756 wpa_dbg(wpa_s
, MSG_DEBUG
, "First radio work item in the queue - schedule start immediately");
3757 radio_work_check_next(wpa_s
);
3765 * radio_work_done - Indicate that a radio work item has been completed
3766 * @work: Completed work
3768 * This function is called once the callback function registered with
3769 * radio_add_work() has completed its work.
3771 void radio_work_done(struct wpa_radio_work
*work
)
3773 struct wpa_supplicant
*wpa_s
= work
->wpa_s
;
3774 struct os_reltime now
, diff
;
3775 unsigned int started
= work
->started
;
3777 os_get_reltime(&now
);
3778 os_reltime_sub(&now
, &work
->time
, &diff
);
3779 wpa_dbg(wpa_s
, MSG_DEBUG
, "Radio work '%s'@%p %s in %ld.%06ld seconds",
3780 work
->type
, work
, started
? "done" : "canceled",
3781 diff
.sec
, diff
.usec
);
3782 radio_work_free(work
);
3784 radio_work_check_next(wpa_s
);
3788 struct wpa_radio_work
*
3789 radio_work_pending(struct wpa_supplicant
*wpa_s
, const char *type
)
3791 struct wpa_radio_work
*work
;
3792 struct wpa_radio
*radio
= wpa_s
->radio
;
3794 dl_list_for_each(work
, &radio
->work
, struct wpa_radio_work
, list
) {
3795 if (work
->wpa_s
== wpa_s
&& os_strcmp(work
->type
, type
) == 0)
3803 static int wpas_init_driver(struct wpa_supplicant
*wpa_s
,
3804 struct wpa_interface
*iface
)
3806 const char *ifname
, *driver
, *rn
;
3808 driver
= iface
->driver
;
3810 if (wpa_supplicant_set_driver(wpa_s
, driver
) < 0)
3813 wpa_s
->drv_priv
= wpa_drv_init(wpa_s
, wpa_s
->ifname
);
3814 if (wpa_s
->drv_priv
== NULL
) {
3816 pos
= driver
? os_strchr(driver
, ',') : NULL
;
3818 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize "
3819 "driver interface - try next driver wrapper");
3823 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to initialize driver "
3827 if (wpa_drv_set_param(wpa_s
, wpa_s
->conf
->driver_param
) < 0) {
3828 wpa_msg(wpa_s
, MSG_ERROR
, "Driver interface rejected "
3829 "driver_param '%s'", wpa_s
->conf
->driver_param
);
3833 ifname
= wpa_drv_get_ifname(wpa_s
);
3834 if (ifname
&& os_strcmp(ifname
, wpa_s
->ifname
) != 0) {
3835 wpa_dbg(wpa_s
, MSG_DEBUG
, "Driver interface replaced "
3836 "interface name with '%s'", ifname
);
3837 os_strlcpy(wpa_s
->ifname
, ifname
, sizeof(wpa_s
->ifname
));
3840 rn
= wpa_driver_get_radio_name(wpa_s
);
3841 if (rn
&& rn
[0] == '\0')
3844 wpa_s
->radio
= radio_add_interface(wpa_s
, rn
);
3845 if (wpa_s
->radio
== NULL
)
3852 static int wpa_supplicant_init_iface(struct wpa_supplicant
*wpa_s
,
3853 struct wpa_interface
*iface
)
3855 struct wpa_driver_capa capa
;
3858 wpa_printf(MSG_DEBUG
, "Initializing interface '%s' conf '%s' driver "
3859 "'%s' ctrl_interface '%s' bridge '%s'", iface
->ifname
,
3860 iface
->confname
? iface
->confname
: "N/A",
3861 iface
->driver
? iface
->driver
: "default",
3862 iface
->ctrl_interface
? iface
->ctrl_interface
: "N/A",
3863 iface
->bridge_ifname
? iface
->bridge_ifname
: "N/A");
3865 if (iface
->confname
) {
3866 #ifdef CONFIG_BACKEND_FILE
3867 wpa_s
->confname
= os_rel2abs_path(iface
->confname
);
3868 if (wpa_s
->confname
== NULL
) {
3869 wpa_printf(MSG_ERROR
, "Failed to get absolute path "
3870 "for configuration file '%s'.",
3874 wpa_printf(MSG_DEBUG
, "Configuration file '%s' -> '%s'",
3875 iface
->confname
, wpa_s
->confname
);
3876 #else /* CONFIG_BACKEND_FILE */
3877 wpa_s
->confname
= os_strdup(iface
->confname
);
3878 #endif /* CONFIG_BACKEND_FILE */
3879 wpa_s
->conf
= wpa_config_read(wpa_s
->confname
, NULL
);
3880 if (wpa_s
->conf
== NULL
) {
3881 wpa_printf(MSG_ERROR
, "Failed to read or parse "
3882 "configuration '%s'.", wpa_s
->confname
);
3885 wpa_s
->confanother
= os_rel2abs_path(iface
->confanother
);
3886 wpa_config_read(wpa_s
->confanother
, wpa_s
->conf
);
3889 * Override ctrl_interface and driver_param if set on command
3892 if (iface
->ctrl_interface
) {
3893 os_free(wpa_s
->conf
->ctrl_interface
);
3894 wpa_s
->conf
->ctrl_interface
=
3895 os_strdup(iface
->ctrl_interface
);
3898 if (iface
->driver_param
) {
3899 os_free(wpa_s
->conf
->driver_param
);
3900 wpa_s
->conf
->driver_param
=
3901 os_strdup(iface
->driver_param
);
3904 if (iface
->p2p_mgmt
&& !iface
->ctrl_interface
) {
3905 os_free(wpa_s
->conf
->ctrl_interface
);
3906 wpa_s
->conf
->ctrl_interface
= NULL
;
3909 wpa_s
->conf
= wpa_config_alloc_empty(iface
->ctrl_interface
,
3910 iface
->driver_param
);
3912 if (wpa_s
->conf
== NULL
) {
3913 wpa_printf(MSG_ERROR
, "\nNo configuration found.");
3917 if (iface
->ifname
== NULL
) {
3918 wpa_printf(MSG_ERROR
, "\nInterface name is required.");
3921 if (os_strlen(iface
->ifname
) >= sizeof(wpa_s
->ifname
)) {
3922 wpa_printf(MSG_ERROR
, "\nToo long interface name '%s'.",
3926 os_strlcpy(wpa_s
->ifname
, iface
->ifname
, sizeof(wpa_s
->ifname
));
3928 if (iface
->bridge_ifname
) {
3929 if (os_strlen(iface
->bridge_ifname
) >=
3930 sizeof(wpa_s
->bridge_ifname
)) {
3931 wpa_printf(MSG_ERROR
, "\nToo long bridge interface "
3932 "name '%s'.", iface
->bridge_ifname
);
3935 os_strlcpy(wpa_s
->bridge_ifname
, iface
->bridge_ifname
,
3936 sizeof(wpa_s
->bridge_ifname
));
3939 /* RSNA Supplicant Key Management - INITIALIZE */
3940 eapol_sm_notify_portEnabled(wpa_s
->eapol
, FALSE
);
3941 eapol_sm_notify_portValid(wpa_s
->eapol
, FALSE
);
3943 /* Initialize driver interface and register driver event handler before
3944 * L2 receive handler so that association events are processed before
3945 * EAPOL-Key packets if both become available for the same select()
3947 if (wpas_init_driver(wpa_s
, iface
) < 0)
3950 if (wpa_supplicant_init_wpa(wpa_s
) < 0)
3953 wpa_sm_set_ifname(wpa_s
->wpa
, wpa_s
->ifname
,
3954 wpa_s
->bridge_ifname
[0] ? wpa_s
->bridge_ifname
:
3956 wpa_sm_set_fast_reauth(wpa_s
->wpa
, wpa_s
->conf
->fast_reauth
);
3958 if (wpa_s
->conf
->dot11RSNAConfigPMKLifetime
&&
3959 wpa_sm_set_param(wpa_s
->wpa
, RSNA_PMK_LIFETIME
,
3960 wpa_s
->conf
->dot11RSNAConfigPMKLifetime
)) {
3961 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
3962 "dot11RSNAConfigPMKLifetime");
3966 if (wpa_s
->conf
->dot11RSNAConfigPMKReauthThreshold
&&
3967 wpa_sm_set_param(wpa_s
->wpa
, RSNA_PMK_REAUTH_THRESHOLD
,
3968 wpa_s
->conf
->dot11RSNAConfigPMKReauthThreshold
)) {
3969 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
3970 "dot11RSNAConfigPMKReauthThreshold");
3974 if (wpa_s
->conf
->dot11RSNAConfigSATimeout
&&
3975 wpa_sm_set_param(wpa_s
->wpa
, RSNA_SA_TIMEOUT
,
3976 wpa_s
->conf
->dot11RSNAConfigSATimeout
)) {
3977 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
3978 "dot11RSNAConfigSATimeout");
3982 wpa_s
->hw
.modes
= wpa_drv_get_hw_feature_data(wpa_s
,
3983 &wpa_s
->hw
.num_modes
,
3986 capa_res
= wpa_drv_get_capa(wpa_s
, &capa
);
3987 if (capa_res
== 0) {
3988 wpa_s
->drv_capa_known
= 1;
3989 wpa_s
->drv_flags
= capa
.flags
;
3990 wpa_s
->drv_enc
= capa
.enc
;
3991 wpa_s
->drv_smps_modes
= capa
.smps_modes
;
3992 wpa_s
->drv_rrm_flags
= capa
.rrm_flags
;
3993 wpa_s
->probe_resp_offloads
= capa
.probe_resp_offloads
;
3994 wpa_s
->max_scan_ssids
= capa
.max_scan_ssids
;
3995 wpa_s
->max_sched_scan_ssids
= capa
.max_sched_scan_ssids
;
3996 wpa_s
->sched_scan_supported
= capa
.sched_scan_supported
;
3997 wpa_s
->max_match_sets
= capa
.max_match_sets
;
3998 wpa_s
->max_remain_on_chan
= capa
.max_remain_on_chan
;
3999 wpa_s
->max_stations
= capa
.max_stations
;
4000 wpa_s
->extended_capa
= capa
.extended_capa
;
4001 wpa_s
->extended_capa_mask
= capa
.extended_capa_mask
;
4002 wpa_s
->extended_capa_len
= capa
.extended_capa_len
;
4003 wpa_s
->num_multichan_concurrent
=
4004 capa
.num_multichan_concurrent
;
4005 wpa_s
->wmm_ac_supported
= capa
.wmm_ac_supported
;
4007 if (capa
.mac_addr_rand_scan_supported
)
4008 wpa_s
->mac_addr_rand_supported
|= MAC_ADDR_RAND_SCAN
;
4009 if (wpa_s
->sched_scan_supported
&&
4010 capa
.mac_addr_rand_sched_scan_supported
)
4011 wpa_s
->mac_addr_rand_supported
|=
4012 (MAC_ADDR_RAND_SCHED_SCAN
| MAC_ADDR_RAND_PNO
);
4014 if (wpa_s
->max_remain_on_chan
== 0)
4015 wpa_s
->max_remain_on_chan
= 1000;
4018 * Only take p2p_mgmt parameters when P2P Device is supported.
4019 * Doing it here as it determines whether l2_packet_init() will be done
4020 * during wpa_supplicant_driver_init().
4022 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
)
4023 wpa_s
->p2p_mgmt
= iface
->p2p_mgmt
;
4025 iface
->p2p_mgmt
= 1;
4027 if (wpa_s
->num_multichan_concurrent
== 0)
4028 wpa_s
->num_multichan_concurrent
= 1;
4030 if (wpa_supplicant_driver_init(wpa_s
) < 0)
4034 if ((!iface
->p2p_mgmt
||
4035 !(wpa_s
->drv_flags
&
4036 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
)) &&
4037 wpa_tdls_init(wpa_s
->wpa
))
4039 #endif /* CONFIG_TDLS */
4041 if (wpa_s
->conf
->country
[0] && wpa_s
->conf
->country
[1] &&
4042 wpa_drv_set_country(wpa_s
, wpa_s
->conf
->country
)) {
4043 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to set country");
4047 if (wpas_wps_init(wpa_s
))
4050 if (wpa_supplicant_init_eapol(wpa_s
) < 0)
4052 wpa_sm_set_eapol(wpa_s
->wpa
, wpa_s
->eapol
);
4054 wpa_s
->ctrl_iface
= wpa_supplicant_ctrl_iface_init(wpa_s
);
4055 if (wpa_s
->ctrl_iface
== NULL
) {
4056 wpa_printf(MSG_ERROR
,
4057 "Failed to initialize control interface '%s'.\n"
4058 "You may have another wpa_supplicant process "
4059 "already running or the file was\n"
4060 "left by an unclean termination of wpa_supplicant "
4061 "in which case you will need\n"
4062 "to manually remove this file before starting "
4063 "wpa_supplicant again.\n",
4064 wpa_s
->conf
->ctrl_interface
);
4068 wpa_s
->gas
= gas_query_init(wpa_s
);
4069 if (wpa_s
->gas
== NULL
) {
4070 wpa_printf(MSG_ERROR
, "Failed to initialize GAS query");
4074 if (iface
->p2p_mgmt
&& wpas_p2p_init(wpa_s
->global
, wpa_s
) < 0) {
4075 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to init P2P");
4079 if (wpa_bss_init(wpa_s
) < 0)
4083 * Set Wake-on-WLAN triggers, if configured.
4084 * Note: We don't restore/remove the triggers on shutdown (it doesn't
4085 * have effect anyway when the interface is down).
4087 if (capa_res
== 0 && wpas_set_wowlan_triggers(wpa_s
, &capa
) < 0)
4090 #ifdef CONFIG_EAP_PROXY
4093 wpa_s
->mnc_len
= eapol_sm_get_eap_proxy_imsi(wpa_s
->eapol
, wpa_s
->imsi
,
4095 if (wpa_s
->mnc_len
> 0) {
4096 wpa_s
->imsi
[len
] = '\0';
4097 wpa_printf(MSG_DEBUG
, "eap_proxy: IMSI %s (MNC length %d)",
4098 wpa_s
->imsi
, wpa_s
->mnc_len
);
4100 wpa_printf(MSG_DEBUG
, "eap_proxy: IMSI not available");
4103 #endif /* CONFIG_EAP_PROXY */
4105 if (pcsc_reader_init(wpa_s
) < 0)
4108 if (wpas_init_ext_pw(wpa_s
) < 0)
4111 wpas_rrm_reset(wpa_s
);
4117 static void wpa_supplicant_deinit_iface(struct wpa_supplicant
*wpa_s
,
4118 int notify
, int terminate
)
4120 struct wpa_global
*global
= wpa_s
->global
;
4121 struct wpa_supplicant
*iface
, *prev
;
4123 if (wpa_s
== wpa_s
->parent
)
4124 wpas_p2p_group_remove(wpa_s
, "*");
4126 iface
= global
->ifaces
;
4128 if (iface
== wpa_s
|| iface
->parent
!= wpa_s
) {
4129 iface
= iface
->next
;
4132 wpa_printf(MSG_DEBUG
,
4133 "Remove remaining child interface %s from parent %s",
4134 iface
->ifname
, wpa_s
->ifname
);
4136 iface
= iface
->next
;
4137 wpa_supplicant_remove_iface(global
, prev
, terminate
);
4140 wpa_s
->disconnected
= 1;
4141 if (wpa_s
->drv_priv
) {
4142 wpa_supplicant_deauthenticate(wpa_s
,
4143 WLAN_REASON_DEAUTH_LEAVING
);
4145 wpa_drv_set_countermeasures(wpa_s
, 0);
4146 wpa_clear_keys(wpa_s
, NULL
);
4149 wpa_supplicant_cleanup(wpa_s
);
4150 wpas_p2p_deinit_iface(wpa_s
);
4152 wpas_ctrl_radio_work_flush(wpa_s
);
4153 radio_remove_interface(wpa_s
);
4155 if (wpa_s
->drv_priv
)
4156 wpa_drv_deinit(wpa_s
);
4159 wpas_notify_iface_removed(wpa_s
);
4162 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_TERMINATING
);
4164 if (wpa_s
->ctrl_iface
) {
4165 wpa_supplicant_ctrl_iface_deinit(wpa_s
->ctrl_iface
);
4166 wpa_s
->ctrl_iface
= NULL
;
4171 wpa_supplicant_mesh_iface_deinit(wpa_s
, wpa_s
->ifmsh
);
4172 wpa_s
->ifmsh
= NULL
;
4174 #endif /* CONFIG_MESH */
4176 if (wpa_s
->conf
!= NULL
) {
4177 wpa_config_free(wpa_s
->conf
);
4186 * wpa_supplicant_add_iface - Add a new network interface
4187 * @global: Pointer to global data from wpa_supplicant_init()
4188 * @iface: Interface configuration options
4189 * Returns: Pointer to the created interface or %NULL on failure
4191 * This function is used to add new network interfaces for %wpa_supplicant.
4192 * This can be called before wpa_supplicant_run() to add interfaces before the
4193 * main event loop has been started. In addition, new interfaces can be added
4194 * dynamically while %wpa_supplicant is already running. This could happen,
4195 * e.g., when a hotplug network adapter is inserted.
4197 struct wpa_supplicant
* wpa_supplicant_add_iface(struct wpa_global
*global
,
4198 struct wpa_interface
*iface
)
4200 struct wpa_supplicant
*wpa_s
;
4201 struct wpa_interface t_iface
;
4202 struct wpa_ssid
*ssid
;
4204 if (global
== NULL
|| iface
== NULL
)
4207 wpa_s
= wpa_supplicant_alloc();
4211 wpa_s
->global
= global
;
4214 if (global
->params
.override_driver
) {
4215 wpa_printf(MSG_DEBUG
, "Override interface parameter: driver "
4217 iface
->driver
, global
->params
.override_driver
);
4218 t_iface
.driver
= global
->params
.override_driver
;
4220 if (global
->params
.override_ctrl_interface
) {
4221 wpa_printf(MSG_DEBUG
, "Override interface parameter: "
4222 "ctrl_interface ('%s' -> '%s')",
4223 iface
->ctrl_interface
,
4224 global
->params
.override_ctrl_interface
);
4225 t_iface
.ctrl_interface
=
4226 global
->params
.override_ctrl_interface
;
4228 if (wpa_supplicant_init_iface(wpa_s
, &t_iface
)) {
4229 wpa_printf(MSG_DEBUG
, "Failed to add interface %s",
4231 wpa_supplicant_deinit_iface(wpa_s
, 0, 0);
4235 if (iface
->p2p_mgmt
== 0) {
4236 /* Notify the control interfaces about new iface */
4237 if (wpas_notify_iface_added(wpa_s
)) {
4238 wpa_supplicant_deinit_iface(wpa_s
, 1, 0);
4242 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
4243 wpas_notify_network_added(wpa_s
, ssid
);
4246 wpa_s
->next
= global
->ifaces
;
4247 global
->ifaces
= wpa_s
;
4249 wpa_dbg(wpa_s
, MSG_DEBUG
, "Added interface %s", wpa_s
->ifname
);
4250 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
4253 if (wpa_s
->global
->p2p
== NULL
&&
4254 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
) &&
4255 wpas_p2p_add_p2pdev_interface(wpa_s
, iface
->conf_p2p_dev
) < 0) {
4256 wpa_printf(MSG_INFO
,
4257 "P2P: Failed to enable P2P Device interface");
4258 /* Try to continue without. P2P will be disabled. */
4260 #endif /* CONFIG_P2P */
4267 * wpa_supplicant_remove_iface - Remove a network interface
4268 * @global: Pointer to global data from wpa_supplicant_init()
4269 * @wpa_s: Pointer to the network interface to be removed
4270 * Returns: 0 if interface was removed, -1 if interface was not found
4272 * This function can be used to dynamically remove network interfaces from
4273 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
4274 * addition, this function is used to remove all remaining interfaces when
4275 * %wpa_supplicant is terminated.
4277 int wpa_supplicant_remove_iface(struct wpa_global
*global
,
4278 struct wpa_supplicant
*wpa_s
,
4281 struct wpa_supplicant
*prev
;
4283 unsigned int mesh_if_created
= wpa_s
->mesh_if_created
;
4284 char *ifname
= NULL
;
4285 #endif /* CONFIG_MESH */
4287 /* Remove interface from the global list of interfaces */
4288 prev
= global
->ifaces
;
4289 if (prev
== wpa_s
) {
4290 global
->ifaces
= wpa_s
->next
;
4292 while (prev
&& prev
->next
!= wpa_s
)
4296 prev
->next
= wpa_s
->next
;
4299 wpa_dbg(wpa_s
, MSG_DEBUG
, "Removing interface %s", wpa_s
->ifname
);
4302 if (mesh_if_created
) {
4303 ifname
= os_strdup(wpa_s
->ifname
);
4304 if (ifname
== NULL
) {
4305 wpa_dbg(wpa_s
, MSG_ERROR
,
4306 "mesh: Failed to malloc ifname");
4310 #endif /* CONFIG_MESH */
4312 if (global
->p2p_group_formation
== wpa_s
)
4313 global
->p2p_group_formation
= NULL
;
4314 if (global
->p2p_invite_group
== wpa_s
)
4315 global
->p2p_invite_group
= NULL
;
4316 wpa_supplicant_deinit_iface(wpa_s
, 1, terminate
);
4319 if (mesh_if_created
) {
4320 wpa_drv_if_remove(global
->ifaces
, WPA_IF_MESH
, ifname
);
4323 #endif /* CONFIG_MESH */
4330 * wpa_supplicant_get_eap_mode - Get the current EAP mode
4331 * @wpa_s: Pointer to the network interface
4332 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
4334 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant
*wpa_s
)
4336 const char *eapol_method
;
4338 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) == 0 &&
4339 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
4343 eapol_method
= eapol_sm_get_method_name(wpa_s
->eapol
);
4344 if (eapol_method
== NULL
)
4345 return "UNKNOWN-EAP";
4347 return eapol_method
;
4352 * wpa_supplicant_get_iface - Get a new network interface
4353 * @global: Pointer to global data from wpa_supplicant_init()
4354 * @ifname: Interface name
4355 * Returns: Pointer to the interface or %NULL if not found
4357 struct wpa_supplicant
* wpa_supplicant_get_iface(struct wpa_global
*global
,
4360 struct wpa_supplicant
*wpa_s
;
4362 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
4363 if (os_strcmp(wpa_s
->ifname
, ifname
) == 0)
4370 #ifndef CONFIG_NO_WPA_MSG
4371 static const char * wpa_supplicant_msg_ifname_cb(void *ctx
)
4373 struct wpa_supplicant
*wpa_s
= ctx
;
4376 return wpa_s
->ifname
;
4378 #endif /* CONFIG_NO_WPA_MSG */
4382 * wpa_supplicant_init - Initialize %wpa_supplicant
4383 * @params: Parameters for %wpa_supplicant
4384 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
4386 * This function is used to initialize %wpa_supplicant. After successful
4387 * initialization, the returned data pointer can be used to add and remove
4388 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
4390 struct wpa_global
* wpa_supplicant_init(struct wpa_params
*params
)
4392 struct wpa_global
*global
;
4398 #ifdef CONFIG_DRIVER_NDIS
4400 void driver_ndis_init_ops(void);
4401 driver_ndis_init_ops();
4403 #endif /* CONFIG_DRIVER_NDIS */
4405 #ifndef CONFIG_NO_WPA_MSG
4406 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb
);
4407 #endif /* CONFIG_NO_WPA_MSG */
4409 if (params
->wpa_debug_file_path
)
4410 wpa_debug_open_file(params
->wpa_debug_file_path
);
4412 wpa_debug_setup_stdout();
4413 if (params
->wpa_debug_syslog
)
4414 wpa_debug_open_syslog();
4415 if (params
->wpa_debug_tracing
) {
4416 ret
= wpa_debug_open_linux_tracing();
4418 wpa_printf(MSG_ERROR
,
4419 "Failed to enable trace logging");
4424 ret
= eap_register_methods();
4426 wpa_printf(MSG_ERROR
, "Failed to register EAP methods");
4428 wpa_printf(MSG_ERROR
, "Two or more EAP methods used "
4429 "the same EAP type.");
4433 global
= os_zalloc(sizeof(*global
));
4436 dl_list_init(&global
->p2p_srv_bonjour
);
4437 dl_list_init(&global
->p2p_srv_upnp
);
4438 global
->params
.daemonize
= params
->daemonize
;
4439 global
->params
.wait_for_monitor
= params
->wait_for_monitor
;
4440 global
->params
.dbus_ctrl_interface
= params
->dbus_ctrl_interface
;
4441 if (params
->pid_file
)
4442 global
->params
.pid_file
= os_strdup(params
->pid_file
);
4443 if (params
->ctrl_interface
)
4444 global
->params
.ctrl_interface
=
4445 os_strdup(params
->ctrl_interface
);
4446 if (params
->ctrl_interface_group
)
4447 global
->params
.ctrl_interface_group
=
4448 os_strdup(params
->ctrl_interface_group
);
4449 if (params
->override_driver
)
4450 global
->params
.override_driver
=
4451 os_strdup(params
->override_driver
);
4452 if (params
->override_ctrl_interface
)
4453 global
->params
.override_ctrl_interface
=
4454 os_strdup(params
->override_ctrl_interface
);
4455 wpa_debug_level
= global
->params
.wpa_debug_level
=
4456 params
->wpa_debug_level
;
4457 wpa_debug_show_keys
= global
->params
.wpa_debug_show_keys
=
4458 params
->wpa_debug_show_keys
;
4459 wpa_debug_timestamp
= global
->params
.wpa_debug_timestamp
=
4460 params
->wpa_debug_timestamp
;
4462 wpa_printf(MSG_DEBUG
, "wpa_supplicant v" VERSION_STR
);
4465 wpa_printf(MSG_ERROR
, "Failed to initialize event loop");
4466 wpa_supplicant_deinit(global
);
4470 random_init(params
->entropy_file
);
4472 global
->ctrl_iface
= wpa_supplicant_global_ctrl_iface_init(global
);
4473 if (global
->ctrl_iface
== NULL
) {
4474 wpa_supplicant_deinit(global
);
4478 if (wpas_notify_supplicant_initialized(global
)) {
4479 wpa_supplicant_deinit(global
);
4483 for (i
= 0; wpa_drivers
[i
]; i
++)
4484 global
->drv_count
++;
4485 if (global
->drv_count
== 0) {
4486 wpa_printf(MSG_ERROR
, "No drivers enabled");
4487 wpa_supplicant_deinit(global
);
4490 global
->drv_priv
= os_calloc(global
->drv_count
, sizeof(void *));
4491 if (global
->drv_priv
== NULL
) {
4492 wpa_supplicant_deinit(global
);
4496 #ifdef CONFIG_WIFI_DISPLAY
4497 if (wifi_display_init(global
) < 0) {
4498 wpa_printf(MSG_ERROR
, "Failed to initialize Wi-Fi Display");
4499 wpa_supplicant_deinit(global
);
4502 #endif /* CONFIG_WIFI_DISPLAY */
4509 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
4510 * @global: Pointer to global data from wpa_supplicant_init()
4511 * Returns: 0 after successful event loop run, -1 on failure
4513 * This function starts the main event loop and continues running as long as
4514 * there are any remaining events. In most cases, this function is running as
4515 * long as the %wpa_supplicant process in still in use.
4517 int wpa_supplicant_run(struct wpa_global
*global
)
4519 struct wpa_supplicant
*wpa_s
;
4521 if (global
->params
.daemonize
&&
4522 wpa_supplicant_daemon(global
->params
.pid_file
))
4525 if (global
->params
.wait_for_monitor
) {
4526 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
)
4527 if (wpa_s
->ctrl_iface
)
4528 wpa_supplicant_ctrl_iface_wait(
4532 eloop_register_signal_terminate(wpa_supplicant_terminate
, global
);
4533 eloop_register_signal_reconfig(wpa_supplicant_reconfig
, global
);
4542 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
4543 * @global: Pointer to global data from wpa_supplicant_init()
4545 * This function is called to deinitialize %wpa_supplicant and to free all
4546 * allocated resources. Remaining network interfaces will also be removed.
4548 void wpa_supplicant_deinit(struct wpa_global
*global
)
4555 #ifdef CONFIG_WIFI_DISPLAY
4556 wifi_display_deinit(global
);
4557 #endif /* CONFIG_WIFI_DISPLAY */
4559 while (global
->ifaces
)
4560 wpa_supplicant_remove_iface(global
, global
->ifaces
, 1);
4562 if (global
->ctrl_iface
)
4563 wpa_supplicant_global_ctrl_iface_deinit(global
->ctrl_iface
);
4565 wpas_notify_supplicant_deinitialized(global
);
4567 eap_peer_unregister_methods();
4569 eap_server_unregister_methods();
4570 #endif /* CONFIG_AP */
4572 for (i
= 0; wpa_drivers
[i
] && global
->drv_priv
; i
++) {
4573 if (!global
->drv_priv
[i
])
4575 wpa_drivers
[i
]->global_deinit(global
->drv_priv
[i
]);
4577 os_free(global
->drv_priv
);
4583 if (global
->params
.pid_file
) {
4584 os_daemonize_terminate(global
->params
.pid_file
);
4585 os_free(global
->params
.pid_file
);
4587 os_free(global
->params
.ctrl_interface
);
4588 os_free(global
->params
.ctrl_interface_group
);
4589 os_free(global
->params
.override_driver
);
4590 os_free(global
->params
.override_ctrl_interface
);
4592 os_free(global
->p2p_disallow_freq
.range
);
4593 os_free(global
->p2p_go_avoid_freq
.range
);
4594 os_free(global
->add_psk
);
4597 wpa_debug_close_syslog();
4598 wpa_debug_close_file();
4599 wpa_debug_close_linux_tracing();
4603 void wpa_supplicant_update_config(struct wpa_supplicant
*wpa_s
)
4605 if ((wpa_s
->conf
->changed_parameters
& CFG_CHANGED_COUNTRY
) &&
4606 wpa_s
->conf
->country
[0] && wpa_s
->conf
->country
[1]) {
4608 country
[0] = wpa_s
->conf
->country
[0];
4609 country
[1] = wpa_s
->conf
->country
[1];
4611 if (wpa_drv_set_country(wpa_s
, country
) < 0) {
4612 wpa_printf(MSG_ERROR
, "Failed to set country code "
4617 if (wpa_s
->conf
->changed_parameters
& CFG_CHANGED_EXT_PW_BACKEND
)
4618 wpas_init_ext_pw(wpa_s
);
4621 wpas_wps_update_config(wpa_s
);
4622 #endif /* CONFIG_WPS */
4623 wpas_p2p_update_config(wpa_s
);
4624 wpa_s
->conf
->changed_parameters
= 0;
4628 void add_freq(int *freqs
, int *num_freqs
, int freq
)
4632 for (i
= 0; i
< *num_freqs
; i
++) {
4633 if (freqs
[i
] == freq
)
4637 freqs
[*num_freqs
] = freq
;
4642 static int * get_bss_freqs_in_ess(struct wpa_supplicant
*wpa_s
)
4644 struct wpa_bss
*bss
, *cbss
;
4645 const int max_freqs
= 10;
4649 freqs
= os_calloc(max_freqs
+ 1, sizeof(int));
4653 cbss
= wpa_s
->current_bss
;
4655 dl_list_for_each(bss
, &wpa_s
->bss
, struct wpa_bss
, list
) {
4658 if (bss
->ssid_len
== cbss
->ssid_len
&&
4659 os_memcmp(bss
->ssid
, cbss
->ssid
, bss
->ssid_len
) == 0 &&
4660 wpa_blacklist_get(wpa_s
, bss
->bssid
) == NULL
) {
4661 add_freq(freqs
, &num_freqs
, bss
->freq
);
4662 if (num_freqs
== max_freqs
)
4667 if (num_freqs
== 0) {
4676 void wpas_connection_failed(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
4682 wpas_connect_work_done(wpa_s
);
4685 * Remove possible authentication timeout since the connection failed.
4687 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
4689 if (wpa_s
->disconnected
) {
4691 * There is no point in blacklisting the AP if this event is
4692 * generated based on local request to disconnect.
4694 wpa_dbg(wpa_s
, MSG_DEBUG
, "Ignore connection failure "
4695 "indication since interface has been put into "
4696 "disconnected state");
4701 * Add the failed BSSID into the blacklist and speed up next scan
4702 * attempt if there could be other APs that could accept association.
4703 * The current blacklist count indicates how many times we have tried
4704 * connecting to this AP and multiple attempts mean that other APs are
4705 * either not available or has already been tried, so that we can start
4706 * increasing the delay here to avoid constant scanning.
4708 count
= wpa_blacklist_add(wpa_s
, bssid
);
4709 if (count
== 1 && wpa_s
->current_bss
) {
4711 * This BSS was not in the blacklist before. If there is
4712 * another BSS available for the same ESS, we should try that
4713 * next. Otherwise, we may as well try this one once more
4714 * before allowing other, likely worse, ESSes to be considered.
4716 freqs
= get_bss_freqs_in_ess(wpa_s
);
4718 wpa_dbg(wpa_s
, MSG_DEBUG
, "Another BSS in this ESS "
4719 "has been seen; try it next");
4720 wpa_blacklist_add(wpa_s
, bssid
);
4722 * On the next scan, go through only the known channels
4723 * used in this ESS based on previous scans to speed up
4724 * common load balancing use case.
4726 os_free(wpa_s
->next_scan_freqs
);
4727 wpa_s
->next_scan_freqs
= freqs
;
4732 * Add previous failure count in case the temporary blacklist was
4733 * cleared due to no other BSSes being available.
4735 count
+= wpa_s
->extra_blacklist_count
;
4737 if (count
> 3 && wpa_s
->current_ssid
) {
4738 wpa_printf(MSG_DEBUG
, "Continuous association failures - "
4739 "consider temporary network disabling");
4740 wpas_auth_failed(wpa_s
, "CONN_FAILED");
4761 wpa_dbg(wpa_s
, MSG_DEBUG
, "Blacklist count %d --> request scan in %d "
4762 "ms", count
, timeout
);
4765 * TODO: if more than one possible AP is available in scan results,
4766 * could try the other ones before requesting a new scan.
4768 wpa_supplicant_req_scan(wpa_s
, timeout
/ 1000,
4769 1000 * (timeout
% 1000));
4773 int wpas_driver_bss_selection(struct wpa_supplicant
*wpa_s
)
4775 return wpa_s
->conf
->ap_scan
== 2 ||
4776 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_BSS_SELECTION
);
4780 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
4781 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant
*wpa_s
,
4782 struct wpa_ssid
*ssid
,
4786 #ifdef IEEE8021X_EAPOL
4787 struct eap_peer_config
*eap
= &ssid
->eap
;
4789 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: response handle field=%s", field
);
4790 wpa_hexdump_ascii_key(MSG_DEBUG
, "CTRL_IFACE: response value",
4791 (const u8
*) value
, os_strlen(value
));
4793 switch (wpa_supplicant_ctrl_req_from_string(field
)) {
4794 case WPA_CTRL_REQ_EAP_IDENTITY
:
4795 os_free(eap
->identity
);
4796 eap
->identity
= (u8
*) os_strdup(value
);
4797 eap
->identity_len
= os_strlen(value
);
4798 eap
->pending_req_identity
= 0;
4799 if (ssid
== wpa_s
->current_ssid
)
4800 wpa_s
->reassociate
= 1;
4802 case WPA_CTRL_REQ_EAP_PASSWORD
:
4803 bin_clear_free(eap
->password
, eap
->password_len
);
4804 eap
->password
= (u8
*) os_strdup(value
);
4805 eap
->password_len
= os_strlen(value
);
4806 eap
->pending_req_password
= 0;
4807 if (ssid
== wpa_s
->current_ssid
)
4808 wpa_s
->reassociate
= 1;
4810 case WPA_CTRL_REQ_EAP_NEW_PASSWORD
:
4811 bin_clear_free(eap
->new_password
, eap
->new_password_len
);
4812 eap
->new_password
= (u8
*) os_strdup(value
);
4813 eap
->new_password_len
= os_strlen(value
);
4814 eap
->pending_req_new_password
= 0;
4815 if (ssid
== wpa_s
->current_ssid
)
4816 wpa_s
->reassociate
= 1;
4818 case WPA_CTRL_REQ_EAP_PIN
:
4819 str_clear_free(eap
->pin
);
4820 eap
->pin
= os_strdup(value
);
4821 eap
->pending_req_pin
= 0;
4822 if (ssid
== wpa_s
->current_ssid
)
4823 wpa_s
->reassociate
= 1;
4825 case WPA_CTRL_REQ_EAP_OTP
:
4826 bin_clear_free(eap
->otp
, eap
->otp_len
);
4827 eap
->otp
= (u8
*) os_strdup(value
);
4828 eap
->otp_len
= os_strlen(value
);
4829 os_free(eap
->pending_req_otp
);
4830 eap
->pending_req_otp
= NULL
;
4831 eap
->pending_req_otp_len
= 0;
4833 case WPA_CTRL_REQ_EAP_PASSPHRASE
:
4834 str_clear_free(eap
->private_key_passwd
);
4835 eap
->private_key_passwd
= os_strdup(value
);
4836 eap
->pending_req_passphrase
= 0;
4837 if (ssid
== wpa_s
->current_ssid
)
4838 wpa_s
->reassociate
= 1;
4840 case WPA_CTRL_REQ_SIM
:
4841 str_clear_free(eap
->external_sim_resp
);
4842 eap
->external_sim_resp
= os_strdup(value
);
4845 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: Unknown field '%s'", field
);
4850 #else /* IEEE8021X_EAPOL */
4851 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: IEEE 802.1X not included");
4853 #endif /* IEEE8021X_EAPOL */
4855 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
4858 int wpas_network_disabled(struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
)
4861 unsigned int drv_enc
;
4869 if (wpa_s
&& wpa_s
->drv_capa_known
)
4870 drv_enc
= wpa_s
->drv_enc
;
4872 drv_enc
= (unsigned int) -1;
4874 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
4875 size_t len
= ssid
->wep_key_len
[i
];
4878 if (len
== 5 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP40
))
4880 if (len
== 13 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP104
))
4882 if (len
== 16 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP128
))
4884 return 1; /* invalid WEP key */
4887 if (wpa_key_mgmt_wpa_psk(ssid
->key_mgmt
) && !ssid
->psk_set
&&
4888 (!ssid
->passphrase
|| ssid
->ssid_len
!= 0) && !ssid
->ext_psk
)
4895 int wpas_get_ssid_pmf(struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
)
4897 #ifdef CONFIG_IEEE80211W
4898 if (ssid
== NULL
|| ssid
->ieee80211w
== MGMT_FRAME_PROTECTION_DEFAULT
) {
4899 if (wpa_s
->conf
->pmf
== MGMT_FRAME_PROTECTION_OPTIONAL
&&
4900 !(wpa_s
->drv_enc
& WPA_DRIVER_CAPA_ENC_BIP
)) {
4902 * Driver does not support BIP -- ignore pmf=1 default
4903 * since the connection with PMF would fail and the
4904 * configuration does not require PMF to be enabled.
4906 return NO_MGMT_FRAME_PROTECTION
;
4909 return wpa_s
->conf
->pmf
;
4912 return ssid
->ieee80211w
;
4913 #else /* CONFIG_IEEE80211W */
4914 return NO_MGMT_FRAME_PROTECTION
;
4915 #endif /* CONFIG_IEEE80211W */
4919 int wpas_is_p2p_prioritized(struct wpa_supplicant
*wpa_s
)
4921 if (wpa_s
->global
->conc_pref
== WPA_CONC_PREF_P2P
)
4923 if (wpa_s
->global
->conc_pref
== WPA_CONC_PREF_STA
)
4929 void wpas_auth_failed(struct wpa_supplicant
*wpa_s
, char *reason
)
4931 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
4933 struct os_reltime now
;
4936 wpa_printf(MSG_DEBUG
, "Authentication failure but no known "
4941 if (ssid
->key_mgmt
== WPA_KEY_MGMT_WPS
)
4944 ssid
->auth_failures
++;
4947 if (ssid
->p2p_group
&&
4948 (wpa_s
->p2p_in_provisioning
|| wpa_s
->show_group_started
)) {
4950 * Skip the wait time since there is a short timeout on the
4951 * connection to a P2P group.
4955 #endif /* CONFIG_P2P */
4957 if (ssid
->auth_failures
> 50)
4959 else if (ssid
->auth_failures
> 10)
4961 else if (ssid
->auth_failures
> 5)
4963 else if (ssid
->auth_failures
> 3)
4965 else if (ssid
->auth_failures
> 2)
4967 else if (ssid
->auth_failures
> 1)
4972 if (ssid
->auth_failures
> 1 &&
4973 wpa_key_mgmt_wpa_ieee8021x(ssid
->key_mgmt
))
4974 dur
+= os_random() % (ssid
->auth_failures
* 10);
4976 os_get_reltime(&now
);
4977 if (now
.sec
+ dur
<= ssid
->disabled_until
.sec
)
4980 ssid
->disabled_until
.sec
= now
.sec
+ dur
;
4982 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_TEMP_DISABLED
4983 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s",
4984 ssid
->id
, wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
),
4985 ssid
->auth_failures
, dur
, reason
);
4989 void wpas_clear_temp_disabled(struct wpa_supplicant
*wpa_s
,
4990 struct wpa_ssid
*ssid
, int clear_failures
)
4995 if (ssid
->disabled_until
.sec
) {
4996 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_REENABLED
4997 "id=%d ssid=\"%s\"",
4998 ssid
->id
, wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
5000 ssid
->disabled_until
.sec
= 0;
5001 ssid
->disabled_until
.usec
= 0;
5003 ssid
->auth_failures
= 0;
5007 int disallowed_bssid(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
5011 if (wpa_s
->disallow_aps_bssid
== NULL
)
5014 for (i
= 0; i
< wpa_s
->disallow_aps_bssid_count
; i
++) {
5015 if (os_memcmp(wpa_s
->disallow_aps_bssid
+ i
* ETH_ALEN
,
5016 bssid
, ETH_ALEN
) == 0)
5024 int disallowed_ssid(struct wpa_supplicant
*wpa_s
, const u8
*ssid
,
5029 if (wpa_s
->disallow_aps_ssid
== NULL
|| ssid
== NULL
)
5032 for (i
= 0; i
< wpa_s
->disallow_aps_ssid_count
; i
++) {
5033 struct wpa_ssid_value
*s
= &wpa_s
->disallow_aps_ssid
[i
];
5034 if (ssid_len
== s
->ssid_len
&&
5035 os_memcmp(ssid
, s
->ssid
, ssid_len
) == 0)
5044 * wpas_request_connection - Request a new connection
5045 * @wpa_s: Pointer to the network interface
5047 * This function is used to request a new connection to be found. It will mark
5048 * the interface to allow reassociation and request a new scan to find a
5049 * suitable network to connect to.
5051 void wpas_request_connection(struct wpa_supplicant
*wpa_s
)
5053 wpa_s
->normal_scans
= 0;
5054 wpa_s
->scan_req
= NORMAL_SCAN_REQ
;
5055 wpa_supplicant_reinit_autoscan(wpa_s
);
5056 wpa_s
->extra_blacklist_count
= 0;
5057 wpa_s
->disconnected
= 0;
5058 wpa_s
->reassociate
= 1;
5060 if (wpa_supplicant_fast_associate(wpa_s
) != 1)
5061 wpa_supplicant_req_scan(wpa_s
, 0, 0);
5063 wpa_s
->reattach
= 0;
5067 void dump_freq_data(struct wpa_supplicant
*wpa_s
, const char *title
,
5068 struct wpa_used_freq_data
*freqs_data
,
5073 wpa_dbg(wpa_s
, MSG_DEBUG
, "Shared frequencies (len=%u): %s",
5075 for (i
= 0; i
< len
; i
++) {
5076 struct wpa_used_freq_data
*cur
= &freqs_data
[i
];
5077 wpa_dbg(wpa_s
, MSG_DEBUG
, "freq[%u]: %d, flags=0x%X",
5078 i
, cur
->freq
, cur
->flags
);
5084 * Find the operating frequencies of any of the virtual interfaces that
5085 * are using the same radio as the current interface, and in addition, get
5086 * information about the interface types that are using the frequency.
5088 int get_shared_radio_freqs_data(struct wpa_supplicant
*wpa_s
,
5089 struct wpa_used_freq_data
*freqs_data
,
5092 struct wpa_supplicant
*ifs
;
5095 unsigned int idx
= 0, i
;
5097 wpa_dbg(wpa_s
, MSG_DEBUG
,
5098 "Determining shared radio frequencies (max len %u)", len
);
5099 os_memset(freqs_data
, 0, sizeof(struct wpa_used_freq_data
) * len
);
5101 dl_list_for_each(ifs
, &wpa_s
->radio
->ifaces
, struct wpa_supplicant
,
5106 if (ifs
->current_ssid
== NULL
|| ifs
->assoc_freq
== 0)
5109 if (ifs
->current_ssid
->mode
== WPAS_MODE_AP
||
5110 ifs
->current_ssid
->mode
== WPAS_MODE_P2P_GO
)
5111 freq
= ifs
->current_ssid
->frequency
;
5112 else if (wpa_drv_get_bssid(ifs
, bssid
) == 0)
5113 freq
= ifs
->assoc_freq
;
5117 /* Hold only distinct freqs */
5118 for (i
= 0; i
< idx
; i
++)
5119 if (freqs_data
[i
].freq
== freq
)
5123 freqs_data
[idx
++].freq
= freq
;
5125 if (ifs
->current_ssid
->mode
== WPAS_MODE_INFRA
) {
5126 freqs_data
[i
].flags
= ifs
->current_ssid
->p2p_group
?
5127 WPA_FREQ_USED_BY_P2P_CLIENT
:
5128 WPA_FREQ_USED_BY_INFRA_STATION
;
5132 dump_freq_data(wpa_s
, "completed iteration", freqs_data
, idx
);
5138 * Find the operating frequencies of any of the virtual interfaces that
5139 * are using the same radio as the current interface.
5141 int get_shared_radio_freqs(struct wpa_supplicant
*wpa_s
,
5142 int *freq_array
, unsigned int len
)
5144 struct wpa_used_freq_data
*freqs_data
;
5147 os_memset(freq_array
, 0, sizeof(int) * len
);
5149 freqs_data
= os_calloc(len
, sizeof(struct wpa_used_freq_data
));
5153 num
= get_shared_radio_freqs_data(wpa_s
, freqs_data
, len
);
5154 for (i
= 0; i
< num
; i
++)
5155 freq_array
[i
] = freqs_data
[i
].freq
;
5157 os_free(freqs_data
);
5163 static void wpas_rrm_neighbor_rep_timeout_handler(void *data
, void *user_ctx
)
5165 struct rrm_data
*rrm
= data
;
5167 if (!rrm
->notify_neighbor_rep
) {
5168 wpa_printf(MSG_ERROR
,
5169 "RRM: Unexpected neighbor report timeout");
5173 wpa_printf(MSG_DEBUG
, "RRM: Notifying neighbor report - NONE");
5174 rrm
->notify_neighbor_rep(rrm
->neighbor_rep_cb_ctx
, NULL
);
5176 rrm
->notify_neighbor_rep
= NULL
;
5177 rrm
->neighbor_rep_cb_ctx
= NULL
;
5182 * wpas_rrm_reset - Clear and reset all RRM data in wpa_supplicant
5183 * @wpa_s: Pointer to wpa_supplicant
5185 void wpas_rrm_reset(struct wpa_supplicant
*wpa_s
)
5187 wpa_s
->rrm
.rrm_used
= 0;
5189 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler
, &wpa_s
->rrm
,
5191 if (wpa_s
->rrm
.notify_neighbor_rep
)
5192 wpas_rrm_neighbor_rep_timeout_handler(&wpa_s
->rrm
, NULL
);
5193 wpa_s
->rrm
.next_neighbor_rep_token
= 1;
5198 * wpas_rrm_process_neighbor_rep - Handle incoming neighbor report
5199 * @wpa_s: Pointer to wpa_supplicant
5200 * @report: Neighbor report buffer, prefixed by a 1-byte dialog token
5201 * @report_len: Length of neighbor report buffer
5203 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant
*wpa_s
,
5204 const u8
*report
, size_t report_len
)
5206 struct wpabuf
*neighbor_rep
;
5208 wpa_hexdump(MSG_DEBUG
, "RRM: New Neighbor Report", report
, report_len
);
5212 if (report
[0] != wpa_s
->rrm
.next_neighbor_rep_token
- 1) {
5213 wpa_printf(MSG_DEBUG
,
5214 "RRM: Discarding neighbor report with token %d (expected %d)",
5215 report
[0], wpa_s
->rrm
.next_neighbor_rep_token
- 1);
5219 eloop_cancel_timeout(wpas_rrm_neighbor_rep_timeout_handler
, &wpa_s
->rrm
,
5222 if (!wpa_s
->rrm
.notify_neighbor_rep
) {
5223 wpa_printf(MSG_ERROR
, "RRM: Unexpected neighbor report");
5227 /* skipping the first byte, which is only an id (dialog token) */
5228 neighbor_rep
= wpabuf_alloc(report_len
- 1);
5229 if (neighbor_rep
== NULL
)
5231 wpabuf_put_data(neighbor_rep
, report
+ 1, report_len
- 1);
5232 wpa_printf(MSG_DEBUG
, "RRM: Notifying neighbor report (token = %d)",
5234 wpa_s
->rrm
.notify_neighbor_rep(wpa_s
->rrm
.neighbor_rep_cb_ctx
,
5236 wpa_s
->rrm
.notify_neighbor_rep
= NULL
;
5237 wpa_s
->rrm
.neighbor_rep_cb_ctx
= NULL
;
5241 #if defined(__CYGWIN__) || defined(CONFIG_NATIVE_WINDOWS)
5242 /* Workaround different, undefined for Windows, error codes used here */
5244 #define EOPNOTSUPP -1
5245 #define ECANCELED -1
5249 * wpas_rrm_send_neighbor_rep_request - Request a neighbor report from our AP
5250 * @wpa_s: Pointer to wpa_supplicant
5251 * @ssid: if not null, this is sent in the request. Otherwise, no SSID IE
5252 * is sent in the request.
5253 * @cb: Callback function to be called once the requested report arrives, or
5254 * timed out after RRM_NEIGHBOR_REPORT_TIMEOUT seconds.
5255 * In the former case, 'neighbor_rep' is a newly allocated wpabuf, and it's
5256 * the requester's responsibility to free it.
5257 * In the latter case NULL will be sent in 'neighbor_rep'.
5258 * @cb_ctx: Context value to send the callback function
5259 * Returns: 0 in case of success, negative error code otherwise
5261 * In case there is a previous request which has not been answered yet, the
5262 * new request fails. The caller may retry after RRM_NEIGHBOR_REPORT_TIMEOUT.
5263 * Request must contain a callback function.
5265 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant
*wpa_s
,
5266 const struct wpa_ssid
*ssid
,
5267 void (*cb
)(void *ctx
,
5268 struct wpabuf
*neighbor_rep
),
5274 if (wpa_s
->wpa_state
!= WPA_COMPLETED
|| wpa_s
->current_ssid
== NULL
) {
5275 wpa_printf(MSG_DEBUG
, "RRM: No connection, no RRM.");
5279 if (!wpa_s
->rrm
.rrm_used
) {
5280 wpa_printf(MSG_DEBUG
, "RRM: No RRM in current connection.");
5284 rrm_ie
= wpa_bss_get_ie(wpa_s
->current_bss
,
5285 WLAN_EID_RRM_ENABLED_CAPABILITIES
);
5286 if (!rrm_ie
|| !(wpa_s
->current_bss
->caps
& IEEE80211_CAP_RRM
) ||
5287 !(rrm_ie
[2] & WLAN_RRM_CAPS_NEIGHBOR_REPORT
)) {
5288 wpa_printf(MSG_DEBUG
,
5289 "RRM: No network support for Neighbor Report.");
5294 wpa_printf(MSG_DEBUG
,
5295 "RRM: Neighbor Report request must provide a callback.");
5299 /* Refuse if there's a live request */
5300 if (wpa_s
->rrm
.notify_neighbor_rep
) {
5301 wpa_printf(MSG_DEBUG
,
5302 "RRM: Currently handling previous Neighbor Report.");
5306 /* 3 = action category + action code + dialog token */
5307 buf
= wpabuf_alloc(3 + (ssid
? 2 + ssid
->ssid_len
: 0));
5309 wpa_printf(MSG_DEBUG
,
5310 "RRM: Failed to allocate Neighbor Report Request");
5314 wpa_printf(MSG_DEBUG
, "RRM: Neighbor report request (for %s), token=%d",
5315 (ssid
? wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
) : ""),
5316 wpa_s
->rrm
.next_neighbor_rep_token
);
5318 wpabuf_put_u8(buf
, WLAN_ACTION_RADIO_MEASUREMENT
);
5319 wpabuf_put_u8(buf
, WLAN_RRM_NEIGHBOR_REPORT_REQUEST
);
5320 wpabuf_put_u8(buf
, wpa_s
->rrm
.next_neighbor_rep_token
);
5322 wpabuf_put_u8(buf
, WLAN_EID_SSID
);
5323 wpabuf_put_u8(buf
, ssid
->ssid_len
);
5324 wpabuf_put_data(buf
, ssid
->ssid
, ssid
->ssid_len
);
5327 wpa_s
->rrm
.next_neighbor_rep_token
++;
5329 if (wpa_drv_send_action(wpa_s
, wpa_s
->assoc_freq
, 0, wpa_s
->bssid
,
5330 wpa_s
->own_addr
, wpa_s
->bssid
,
5331 wpabuf_head(buf
), wpabuf_len(buf
), 0) < 0) {
5332 wpa_printf(MSG_DEBUG
,
5333 "RRM: Failed to send Neighbor Report Request");
5338 wpa_s
->rrm
.neighbor_rep_cb_ctx
= cb_ctx
;
5339 wpa_s
->rrm
.notify_neighbor_rep
= cb
;
5340 eloop_register_timeout(RRM_NEIGHBOR_REPORT_TIMEOUT
, 0,
5341 wpas_rrm_neighbor_rep_timeout_handler
,
5349 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant
*wpa_s
,
5351 const u8
*frame
, size_t len
,
5355 const struct rrm_link_measurement_request
*req
;
5356 struct rrm_link_measurement_report report
;
5358 if (wpa_s
->wpa_state
!= WPA_COMPLETED
) {
5359 wpa_printf(MSG_INFO
,
5360 "RRM: Ignoring link measurement request. Not associated");
5364 if (!wpa_s
->rrm
.rrm_used
) {
5365 wpa_printf(MSG_INFO
,
5366 "RRM: Ignoring link measurement request. Not RRM network");
5370 if (!(wpa_s
->drv_rrm_flags
& WPA_DRIVER_FLAGS_TX_POWER_INSERTION
)) {
5371 wpa_printf(MSG_INFO
,
5372 "RRM: Measurement report failed. TX power insertion not supported");
5376 req
= (const struct rrm_link_measurement_request
*) frame
;
5377 if (len
< sizeof(*req
)) {
5378 wpa_printf(MSG_INFO
,
5379 "RRM: Link measurement report failed. Request too short");
5383 os_memset(&report
, 0, sizeof(report
));
5384 report
.tpc
.eid
= WLAN_EID_TPC_REPORT
;
5386 report
.rsni
= 255; /* 255 indicates that RSNI is not available */
5387 report
.dialog_token
= req
->dialog_token
;
5390 * It's possible to estimate RCPI based on RSSI in dBm. This
5391 * calculation will not reflect the correct value for high rates,
5392 * but it's good enough for Action frames which are transmitted
5393 * with up to 24 Mbps rates.
5396 report
.rcpi
= 255; /* not available */
5397 else if (rssi
< -110)
5402 report
.rcpi
= (rssi
+ 110) * 2;
5404 /* action_category + action_code */
5405 buf
= wpabuf_alloc(2 + sizeof(report
));
5407 wpa_printf(MSG_ERROR
,
5408 "RRM: Link measurement report failed. Buffer allocation failed");
5412 wpabuf_put_u8(buf
, WLAN_ACTION_RADIO_MEASUREMENT
);
5413 wpabuf_put_u8(buf
, WLAN_RRM_LINK_MEASUREMENT_REPORT
);
5414 wpabuf_put_data(buf
, &report
, sizeof(report
));
5415 wpa_hexdump(MSG_DEBUG
, "RRM: Link measurement report:",
5416 wpabuf_head(buf
), wpabuf_len(buf
));
5418 if (wpa_drv_send_action(wpa_s
, wpa_s
->assoc_freq
, 0, src
,
5419 wpa_s
->own_addr
, wpa_s
->bssid
,
5420 wpabuf_head(buf
), wpabuf_len(buf
), 0)) {
5421 wpa_printf(MSG_ERROR
,
5422 "RRM: Link measurement report failed. Send action failed");