3 * Copyright (c) 2003-2012, 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_server/eap_methods.h"
21 #include "rsn_supp/wpa.h"
24 #include "utils/ext_password.h"
25 #include "l2_packet/l2_packet.h"
26 #include "wpa_supplicant_i.h"
28 #include "ctrl_iface.h"
29 #include "pcsc_funcs.h"
30 #include "common/version.h"
31 #include "rsn_supp/preauth.h"
32 #include "rsn_supp/pmksa_cache.h"
33 #include "common/wpa_ctrl.h"
34 #include "common/ieee802_11_defs.h"
36 #include "blacklist.h"
37 #include "wpas_glue.h"
38 #include "wps_supplicant.h"
41 #include "gas_query.h"
43 #include "p2p_supplicant.h"
44 #include "wifi_display.h"
50 #include "offchannel.h"
51 #include "hs20_supplicant.h"
53 const char *wpa_supplicant_version
=
54 "wpa_supplicant v" VERSION_STR
"\n"
55 "Copyright (c) 2003-2012, Jouni Malinen <j@w1.fi> and contributors";
57 const char *wpa_supplicant_license
=
58 "This software may be distributed under the terms of the BSD license.\n"
59 "See README for more details.\n"
60 #ifdef EAP_TLS_OPENSSL
61 "\nThis product includes software developed by the OpenSSL Project\n"
62 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n"
63 #endif /* EAP_TLS_OPENSSL */
66 #ifndef CONFIG_NO_STDOUT_DEBUG
67 /* Long text divided into parts in order to fit in C89 strings size limits. */
68 const char *wpa_supplicant_full_license1
=
70 const char *wpa_supplicant_full_license2
=
71 "This software may be distributed under the terms of the BSD license.\n"
73 "Redistribution and use in source and binary forms, with or without\n"
74 "modification, are permitted provided that the following conditions are\n"
77 const char *wpa_supplicant_full_license3
=
78 "1. Redistributions of source code must retain the above copyright\n"
79 " notice, this list of conditions and the following disclaimer.\n"
81 "2. Redistributions in binary form must reproduce the above copyright\n"
82 " notice, this list of conditions and the following disclaimer in the\n"
83 " documentation and/or other materials provided with the distribution.\n"
85 const char *wpa_supplicant_full_license4
=
86 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n"
87 " names of its contributors may be used to endorse or promote products\n"
88 " derived from this software without specific prior written permission.\n"
90 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
91 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
92 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
93 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n";
94 const char *wpa_supplicant_full_license5
=
95 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
96 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
97 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
98 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
99 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
100 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
101 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
103 #endif /* CONFIG_NO_STDOUT_DEBUG */
105 extern int wpa_debug_level
;
106 extern int wpa_debug_show_keys
;
107 extern int wpa_debug_timestamp
;
108 extern struct wpa_driver_ops
*wpa_drivers
[];
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 static int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant
*wpa_s
,
130 struct wpa_ssid
*ssid
)
137 /* IBSS/WPA-None uses only one key (Group) for both receiving and
138 * sending unicast and multicast packets. */
140 if (ssid
->mode
!= WPAS_MODE_IBSS
) {
141 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Invalid mode %d (not "
142 "IBSS/ad-hoc) for WPA-None", ssid
->mode
);
146 if (!ssid
->psk_set
) {
147 wpa_msg(wpa_s
, MSG_INFO
, "WPA: No PSK configured for "
152 switch (wpa_s
->group_cipher
) {
153 case WPA_CIPHER_CCMP
:
154 os_memcpy(key
, ssid
->psk
, 16);
158 case WPA_CIPHER_GCMP
:
159 os_memcpy(key
, ssid
->psk
, 16);
163 case WPA_CIPHER_TKIP
:
164 /* WPA-None uses the same Michael MIC key for both TX and RX */
165 os_memcpy(key
, ssid
->psk
, 16 + 8);
166 os_memcpy(key
+ 16 + 8, ssid
->psk
+ 16, 8);
171 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Invalid group cipher %d for "
172 "WPA-None", wpa_s
->group_cipher
);
176 /* TODO: should actually remember the previously used seq#, both for TX
177 * and RX from each STA.. */
179 return wpa_drv_set_key(wpa_s
, alg
, NULL
, 0, 1, seq
, 6, key
, keylen
);
183 static void wpa_supplicant_timeout(void *eloop_ctx
, void *timeout_ctx
)
185 struct wpa_supplicant
*wpa_s
= eloop_ctx
;
186 const u8
*bssid
= wpa_s
->bssid
;
187 if (is_zero_ether_addr(bssid
))
188 bssid
= wpa_s
->pending_bssid
;
189 wpa_msg(wpa_s
, MSG_INFO
, "Authentication with " MACSTR
" timed out.",
191 wpa_blacklist_add(wpa_s
, bssid
);
192 wpa_sm_notify_disassoc(wpa_s
->wpa
);
193 wpa_supplicant_deauthenticate(wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
194 wpa_s
->reassociate
= 1;
197 * If we timed out, the AP or the local radio may be busy.
198 * So, wait a second until scanning again.
200 wpa_supplicant_req_scan(wpa_s
, 1, 0);
203 if (wpa_s
->global
->p2p_cb_on_scan_complete
&& !wpa_s
->global
->p2p_disabled
&&
204 wpa_s
->global
->p2p
!= NULL
) {
205 wpa_s
->global
->p2p_cb_on_scan_complete
= 0;
206 if (p2p_other_scan_completed(wpa_s
->global
->p2p
) == 1) {
207 wpa_dbg(wpa_s
, MSG_DEBUG
, "P2P: Pending P2P operation "
208 "continued after timed out authentication");
211 #endif /* CONFIG_P2P */
216 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication
217 * @wpa_s: Pointer to wpa_supplicant data
218 * @sec: Number of seconds after which to time out authentication
219 * @usec: Number of microseconds after which to time out authentication
221 * This function is used to schedule a timeout for the current authentication
224 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant
*wpa_s
,
227 if (wpa_s
->conf
&& wpa_s
->conf
->ap_scan
== 0 &&
228 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
))
231 wpa_dbg(wpa_s
, MSG_DEBUG
, "Setting authentication timeout: %d sec "
232 "%d usec", sec
, usec
);
233 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
234 eloop_register_timeout(sec
, usec
, wpa_supplicant_timeout
, wpa_s
, NULL
);
239 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout
240 * @wpa_s: Pointer to wpa_supplicant data
242 * This function is used to cancel authentication timeout scheduled with
243 * wpa_supplicant_req_auth_timeout() and it is called when authentication has
246 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant
*wpa_s
)
248 wpa_dbg(wpa_s
, MSG_DEBUG
, "Cancelling authentication timeout");
249 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
250 wpa_blacklist_del(wpa_s
, wpa_s
->bssid
);
255 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine
256 * @wpa_s: Pointer to wpa_supplicant data
258 * This function is used to configure EAPOL state machine based on the selected
259 * authentication mode.
261 void wpa_supplicant_initiate_eapol(struct wpa_supplicant
*wpa_s
)
263 #ifdef IEEE8021X_EAPOL
264 struct eapol_config eapol_conf
;
265 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
267 #ifdef CONFIG_IBSS_RSN
268 if (ssid
->mode
== WPAS_MODE_IBSS
&&
269 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_NONE
&&
270 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPA_NONE
) {
272 * RSN IBSS authentication is per-STA and we can disable the
273 * per-BSSID EAPOL authentication.
275 eapol_sm_notify_portControl(wpa_s
->eapol
, ForceAuthorized
);
276 eapol_sm_notify_eap_success(wpa_s
->eapol
, TRUE
);
277 eapol_sm_notify_eap_fail(wpa_s
->eapol
, FALSE
);
280 #endif /* CONFIG_IBSS_RSN */
282 eapol_sm_notify_eap_success(wpa_s
->eapol
, FALSE
);
283 eapol_sm_notify_eap_fail(wpa_s
->eapol
, FALSE
);
285 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
||
286 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
)
287 eapol_sm_notify_portControl(wpa_s
->eapol
, ForceAuthorized
);
289 eapol_sm_notify_portControl(wpa_s
->eapol
, Auto
);
291 os_memset(&eapol_conf
, 0, sizeof(eapol_conf
));
292 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
293 eapol_conf
.accept_802_1x_keys
= 1;
294 eapol_conf
.required_keys
= 0;
295 if (ssid
->eapol_flags
& EAPOL_FLAG_REQUIRE_KEY_UNICAST
) {
296 eapol_conf
.required_keys
|= EAPOL_REQUIRE_KEY_UNICAST
;
298 if (ssid
->eapol_flags
& EAPOL_FLAG_REQUIRE_KEY_BROADCAST
) {
299 eapol_conf
.required_keys
|=
300 EAPOL_REQUIRE_KEY_BROADCAST
;
303 if (wpa_s
->conf
&& (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
))
304 eapol_conf
.required_keys
= 0;
307 eapol_conf
.fast_reauth
= wpa_s
->conf
->fast_reauth
;
308 eapol_conf
.workaround
= ssid
->eap_workaround
;
309 eapol_conf
.eap_disabled
=
310 !wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) &&
311 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_IEEE8021X_NO_WPA
&&
312 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPS
;
313 eapol_sm_notify_config(wpa_s
->eapol
, &ssid
->eap
, &eapol_conf
);
314 #endif /* IEEE8021X_EAPOL */
319 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode
320 * @wpa_s: Pointer to wpa_supplicant data
321 * @ssid: Configuration data for the network
323 * This function is used to configure WPA state machine and related parameters
324 * to a mode where WPA is not enabled. This is called as part of the
325 * authentication configuration when the selected network does not use WPA.
327 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant
*wpa_s
,
328 struct wpa_ssid
*ssid
)
332 if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)
333 wpa_s
->key_mgmt
= WPA_KEY_MGMT_WPS
;
334 else if (ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
)
335 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_NO_WPA
;
337 wpa_s
->key_mgmt
= WPA_KEY_MGMT_NONE
;
338 wpa_sm_set_ap_wpa_ie(wpa_s
->wpa
, NULL
, 0);
339 wpa_sm_set_ap_rsn_ie(wpa_s
->wpa
, NULL
, 0);
340 wpa_sm_set_assoc_wpa_ie(wpa_s
->wpa
, NULL
, 0);
341 wpa_s
->pairwise_cipher
= WPA_CIPHER_NONE
;
342 wpa_s
->group_cipher
= WPA_CIPHER_NONE
;
343 wpa_s
->mgmt_group_cipher
= 0;
345 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
346 if (ssid
->wep_key_len
[i
] > 5) {
347 wpa_s
->pairwise_cipher
= WPA_CIPHER_WEP104
;
348 wpa_s
->group_cipher
= WPA_CIPHER_WEP104
;
350 } else if (ssid
->wep_key_len
[i
] > 0) {
351 wpa_s
->pairwise_cipher
= WPA_CIPHER_WEP40
;
352 wpa_s
->group_cipher
= WPA_CIPHER_WEP40
;
357 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_RSN_ENABLED
, 0);
358 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_KEY_MGMT
, wpa_s
->key_mgmt
);
359 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PAIRWISE
,
360 wpa_s
->pairwise_cipher
);
361 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_GROUP
, wpa_s
->group_cipher
);
362 #ifdef CONFIG_IEEE80211W
363 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MGMT_GROUP
,
364 wpa_s
->mgmt_group_cipher
);
365 #endif /* CONFIG_IEEE80211W */
367 pmksa_cache_clear_current(wpa_s
->wpa
);
371 void free_hw_features(struct wpa_supplicant
*wpa_s
)
374 if (wpa_s
->hw
.modes
== NULL
)
377 for (i
= 0; i
< wpa_s
->hw
.num_modes
; i
++) {
378 os_free(wpa_s
->hw
.modes
[i
].channels
);
379 os_free(wpa_s
->hw
.modes
[i
].rates
);
382 os_free(wpa_s
->hw
.modes
);
383 wpa_s
->hw
.modes
= NULL
;
387 static void wpa_supplicant_cleanup(struct wpa_supplicant
*wpa_s
)
389 bgscan_deinit(wpa_s
);
390 autoscan_deinit(wpa_s
);
391 scard_deinit(wpa_s
->scard
);
393 wpa_sm_set_scard_ctx(wpa_s
->wpa
, NULL
);
394 eapol_sm_register_scard_ctx(wpa_s
->eapol
, NULL
);
395 l2_packet_deinit(wpa_s
->l2
);
398 l2_packet_deinit(wpa_s
->l2_br
);
402 if (wpa_s
->conf
!= NULL
) {
403 struct wpa_ssid
*ssid
;
404 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
405 wpas_notify_network_removed(wpa_s
, ssid
);
408 os_free(wpa_s
->confname
);
409 wpa_s
->confname
= NULL
;
411 wpa_sm_set_eapol(wpa_s
->wpa
, NULL
);
412 eapol_sm_deinit(wpa_s
->eapol
);
415 rsn_preauth_deinit(wpa_s
->wpa
);
418 wpa_tdls_deinit(wpa_s
->wpa
);
419 #endif /* CONFIG_TDLS */
421 pmksa_candidate_free(wpa_s
->wpa
);
422 wpa_sm_deinit(wpa_s
->wpa
);
424 wpa_blacklist_clear(wpa_s
);
426 wpa_bss_deinit(wpa_s
);
428 wpa_supplicant_cancel_scan(wpa_s
);
429 wpa_supplicant_cancel_auth_timeout(wpa_s
);
430 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures
, wpa_s
, NULL
);
431 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
432 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report
,
434 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
436 wpas_wps_deinit(wpa_s
);
438 wpabuf_free(wpa_s
->pending_eapol_rx
);
439 wpa_s
->pending_eapol_rx
= NULL
;
441 #ifdef CONFIG_IBSS_RSN
442 ibss_rsn_deinit(wpa_s
->ibss_rsn
);
443 wpa_s
->ibss_rsn
= NULL
;
444 #endif /* CONFIG_IBSS_RSN */
449 wpa_supplicant_ap_deinit(wpa_s
);
450 #endif /* CONFIG_AP */
453 wpas_p2p_deinit(wpa_s
);
454 #endif /* CONFIG_P2P */
456 #ifdef CONFIG_OFFCHANNEL
457 offchannel_deinit(wpa_s
);
458 #endif /* CONFIG_OFFCHANNEL */
460 wpa_supplicant_cancel_sched_scan(wpa_s
);
462 os_free(wpa_s
->next_scan_freqs
);
463 wpa_s
->next_scan_freqs
= NULL
;
465 gas_query_deinit(wpa_s
->gas
);
468 free_hw_features(wpa_s
);
470 os_free(wpa_s
->bssid_filter
);
471 wpa_s
->bssid_filter
= NULL
;
473 os_free(wpa_s
->disallow_aps_bssid
);
474 wpa_s
->disallow_aps_bssid
= NULL
;
475 os_free(wpa_s
->disallow_aps_ssid
);
476 wpa_s
->disallow_aps_ssid
= NULL
;
478 wnm_bss_keep_alive_deinit(wpa_s
);
480 ext_password_deinit(wpa_s
->ext_pw
);
481 wpa_s
->ext_pw
= NULL
;
483 wpabuf_free(wpa_s
->last_gas_resp
);
485 os_free(wpa_s
->last_scan_res
);
486 wpa_s
->last_scan_res
= NULL
;
491 * wpa_clear_keys - Clear keys configured for the driver
492 * @wpa_s: Pointer to wpa_supplicant data
493 * @addr: Previously used BSSID or %NULL if not available
495 * This function clears the encryption keys that has been previously configured
498 void wpa_clear_keys(struct wpa_supplicant
*wpa_s
, const u8
*addr
)
500 if (wpa_s
->keys_cleared
) {
501 /* Some drivers (e.g., ndiswrapper & NDIS drivers) seem to have
502 * timing issues with keys being cleared just before new keys
503 * are set or just after association or something similar. This
504 * shows up in group key handshake failing often because of the
505 * client not receiving the first encrypted packets correctly.
506 * Skipping some of the extra key clearing steps seems to help
507 * in completing group key handshake more reliably. */
508 wpa_dbg(wpa_s
, MSG_DEBUG
, "No keys have been configured - "
509 "skip key clearing");
513 /* MLME-DELETEKEYS.request */
514 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, 0, 0, NULL
, 0, NULL
, 0);
515 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, 1, 0, NULL
, 0, NULL
, 0);
516 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, 2, 0, NULL
, 0, NULL
, 0);
517 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, 3, 0, NULL
, 0, NULL
, 0);
518 #ifdef CONFIG_IEEE80211W
519 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, 4, 0, NULL
, 0, NULL
, 0);
520 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, NULL
, 5, 0, NULL
, 0, NULL
, 0);
521 #endif /* CONFIG_IEEE80211W */
523 wpa_drv_set_key(wpa_s
, WPA_ALG_NONE
, addr
, 0, 0, NULL
, 0, NULL
,
525 /* MLME-SETPROTECTION.request(None) */
526 wpa_drv_mlme_setprotection(
528 MLME_SETPROTECTION_PROTECT_TYPE_NONE
,
529 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE
);
531 wpa_s
->keys_cleared
= 1;
536 * wpa_supplicant_state_txt - Get the connection state name as a text string
537 * @state: State (wpa_state; WPA_*)
538 * Returns: The state name as a printable text string
540 const char * wpa_supplicant_state_txt(enum wpa_states state
)
543 case WPA_DISCONNECTED
:
544 return "DISCONNECTED";
547 case WPA_INTERFACE_DISABLED
:
548 return "INTERFACE_DISABLED";
551 case WPA_AUTHENTICATING
:
552 return "AUTHENTICATING";
553 case WPA_ASSOCIATING
:
554 return "ASSOCIATING";
557 case WPA_4WAY_HANDSHAKE
:
558 return "4WAY_HANDSHAKE";
559 case WPA_GROUP_HANDSHAKE
:
560 return "GROUP_HANDSHAKE";
571 static void wpa_supplicant_start_bgscan(struct wpa_supplicant
*wpa_s
)
573 if (wpas_driver_bss_selection(wpa_s
))
575 if (wpa_s
->current_ssid
== wpa_s
->bgscan_ssid
)
578 bgscan_deinit(wpa_s
);
579 if (wpa_s
->current_ssid
&& wpa_s
->current_ssid
->bgscan
) {
580 if (bgscan_init(wpa_s
, wpa_s
->current_ssid
)) {
581 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize "
584 * Live without bgscan; it is only used as a roaming
585 * optimization, so the initial connection is not
589 struct wpa_scan_results
*scan_res
;
590 wpa_s
->bgscan_ssid
= wpa_s
->current_ssid
;
591 scan_res
= wpa_supplicant_get_scan_results(wpa_s
, NULL
,
594 bgscan_notify_scan(wpa_s
, scan_res
);
595 wpa_scan_results_free(scan_res
);
599 wpa_s
->bgscan_ssid
= NULL
;
603 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant
*wpa_s
)
605 if (wpa_s
->bgscan_ssid
!= NULL
) {
606 bgscan_deinit(wpa_s
);
607 wpa_s
->bgscan_ssid
= NULL
;
611 #endif /* CONFIG_BGSCAN */
614 static void wpa_supplicant_start_autoscan(struct wpa_supplicant
*wpa_s
)
616 if (autoscan_init(wpa_s
, 0))
617 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize autoscan");
621 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant
*wpa_s
)
623 autoscan_deinit(wpa_s
);
627 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant
*wpa_s
)
629 if (wpa_s
->wpa_state
== WPA_DISCONNECTED
||
630 wpa_s
->wpa_state
== WPA_SCANNING
) {
631 autoscan_deinit(wpa_s
);
632 wpa_supplicant_start_autoscan(wpa_s
);
638 * wpa_supplicant_set_state - Set current connection state
639 * @wpa_s: Pointer to wpa_supplicant data
640 * @state: The new connection state
642 * This function is called whenever the connection state changes, e.g.,
643 * association is completed for WPA/WPA2 4-Way Handshake is started.
645 void wpa_supplicant_set_state(struct wpa_supplicant
*wpa_s
,
646 enum wpa_states state
)
648 enum wpa_states old_state
= wpa_s
->wpa_state
;
650 wpa_dbg(wpa_s
, MSG_DEBUG
, "State: %s -> %s",
651 wpa_supplicant_state_txt(wpa_s
->wpa_state
),
652 wpa_supplicant_state_txt(state
));
654 if (state
!= WPA_SCANNING
)
655 wpa_supplicant_notify_scanning(wpa_s
, 0);
657 if (state
== WPA_COMPLETED
&& wpa_s
->new_connection
) {
658 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG)
659 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
660 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_CONNECTED
"- Connection to "
661 MACSTR
" completed %s [id=%d id_str=%s]",
662 MAC2STR(wpa_s
->bssid
), wpa_s
->reassociated_connection
?
663 "(reauth)" : "(auth)",
664 ssid
? ssid
->id
: -1,
665 ssid
&& ssid
->id_str
? ssid
->id_str
: "");
666 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */
667 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
668 wpa_s
->extra_blacklist_count
= 0;
669 wpa_s
->new_connection
= 0;
670 wpa_s
->reassociated_connection
= 1;
671 wpa_drv_set_operstate(wpa_s
, 1);
672 #ifndef IEEE8021X_EAPOL
673 wpa_drv_set_supp_port(wpa_s
, 1);
674 #endif /* IEEE8021X_EAPOL */
675 wpa_s
->after_wps
= 0;
677 wpas_p2p_completed(wpa_s
);
678 #endif /* CONFIG_P2P */
680 sme_sched_obss_scan(wpa_s
, 1);
681 } else if (state
== WPA_DISCONNECTED
|| state
== WPA_ASSOCIATING
||
682 state
== WPA_ASSOCIATED
) {
683 wpa_s
->new_connection
= 1;
684 wpa_drv_set_operstate(wpa_s
, 0);
685 #ifndef IEEE8021X_EAPOL
686 wpa_drv_set_supp_port(wpa_s
, 0);
687 #endif /* IEEE8021X_EAPOL */
688 sme_sched_obss_scan(wpa_s
, 0);
690 wpa_s
->wpa_state
= state
;
693 if (state
== WPA_COMPLETED
)
694 wpa_supplicant_start_bgscan(wpa_s
);
696 wpa_supplicant_stop_bgscan(wpa_s
);
697 #endif /* CONFIG_BGSCAN */
699 if (state
== WPA_AUTHENTICATING
)
700 wpa_supplicant_stop_autoscan(wpa_s
);
702 if (state
== WPA_DISCONNECTED
|| state
== WPA_INACTIVE
)
703 wpa_supplicant_start_autoscan(wpa_s
);
705 if (wpa_s
->wpa_state
!= old_state
) {
706 wpas_notify_state_changed(wpa_s
, wpa_s
->wpa_state
, old_state
);
708 if (wpa_s
->wpa_state
== WPA_COMPLETED
||
709 old_state
== WPA_COMPLETED
)
710 wpas_notify_auth_changed(wpa_s
);
715 void wpa_supplicant_terminate_proc(struct wpa_global
*global
)
719 struct wpa_supplicant
*wpa_s
= global
->ifaces
;
721 if (wpas_wps_terminate_pending(wpa_s
) == 1)
725 #endif /* CONFIG_WPS */
732 static void wpa_supplicant_terminate(int sig
, void *signal_ctx
)
734 struct wpa_global
*global
= signal_ctx
;
735 wpa_supplicant_terminate_proc(global
);
739 void wpa_supplicant_clear_status(struct wpa_supplicant
*wpa_s
)
741 enum wpa_states old_state
= wpa_s
->wpa_state
;
743 wpa_s
->pairwise_cipher
= 0;
744 wpa_s
->group_cipher
= 0;
745 wpa_s
->mgmt_group_cipher
= 0;
747 if (wpa_s
->wpa_state
!= WPA_INTERFACE_DISABLED
)
748 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
750 if (wpa_s
->wpa_state
!= old_state
)
751 wpas_notify_state_changed(wpa_s
, wpa_s
->wpa_state
, old_state
);
756 * wpa_supplicant_reload_configuration - Reload configuration data
757 * @wpa_s: Pointer to wpa_supplicant data
758 * Returns: 0 on success or -1 if configuration parsing failed
760 * This function can be used to request that the configuration data is reloaded
761 * (e.g., after configuration file change). This function is reloading
762 * configuration only for one interface, so this may need to be called multiple
763 * times if %wpa_supplicant is controlling multiple interfaces and all
764 * interfaces need reconfiguration.
766 int wpa_supplicant_reload_configuration(struct wpa_supplicant
*wpa_s
)
768 struct wpa_config
*conf
;
772 if (wpa_s
->confname
== NULL
)
774 conf
= wpa_config_read(wpa_s
->confname
);
776 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to parse the configuration "
777 "file '%s' - exiting", wpa_s
->confname
);
780 conf
->changed_parameters
= (unsigned int) -1;
782 reconf_ctrl
= !!conf
->ctrl_interface
!= !!wpa_s
->conf
->ctrl_interface
783 || (conf
->ctrl_interface
&& wpa_s
->conf
->ctrl_interface
&&
784 os_strcmp(conf
->ctrl_interface
,
785 wpa_s
->conf
->ctrl_interface
) != 0);
787 if (reconf_ctrl
&& wpa_s
->ctrl_iface
) {
788 wpa_supplicant_ctrl_iface_deinit(wpa_s
->ctrl_iface
);
789 wpa_s
->ctrl_iface
= NULL
;
792 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
793 if (wpa_s
->current_ssid
) {
794 wpa_supplicant_deauthenticate(wpa_s
,
795 WLAN_REASON_DEAUTH_LEAVING
);
799 * TODO: should notify EAPOL SM about changes in opensc_engine_path,
800 * pkcs11_engine_path, pkcs11_module_path.
802 if (wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
)) {
804 * Clear forced success to clear EAP state for next
807 eapol_sm_notify_eap_success(wpa_s
->eapol
, FALSE
);
809 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
810 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
811 wpa_sm_pmksa_cache_flush(wpa_s
->wpa
, NULL
);
812 wpa_sm_set_fast_reauth(wpa_s
->wpa
, wpa_s
->conf
->fast_reauth
);
813 rsn_preauth_deinit(wpa_s
->wpa
);
815 old_ap_scan
= wpa_s
->conf
->ap_scan
;
816 wpa_config_free(wpa_s
->conf
);
818 if (old_ap_scan
!= wpa_s
->conf
->ap_scan
)
819 wpas_notify_ap_scan_changed(wpa_s
);
822 wpa_s
->ctrl_iface
= wpa_supplicant_ctrl_iface_init(wpa_s
);
824 wpa_supplicant_update_config(wpa_s
);
826 wpa_supplicant_clear_status(wpa_s
);
827 if (wpa_supplicant_enabled_networks(wpa_s
)) {
828 wpa_s
->reassociate
= 1;
829 wpa_supplicant_req_scan(wpa_s
, 0, 0);
831 wpa_dbg(wpa_s
, MSG_DEBUG
, "Reconfiguration completed");
836 static void wpa_supplicant_reconfig(int sig
, void *signal_ctx
)
838 struct wpa_global
*global
= signal_ctx
;
839 struct wpa_supplicant
*wpa_s
;
840 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
841 wpa_dbg(wpa_s
, MSG_DEBUG
, "Signal %d received - reconfiguring",
843 if (wpa_supplicant_reload_configuration(wpa_s
) < 0) {
844 wpa_supplicant_terminate_proc(global
);
850 enum wpa_cipher
cipher_suite2driver(int cipher
)
853 case WPA_CIPHER_NONE
:
855 case WPA_CIPHER_WEP40
:
857 case WPA_CIPHER_WEP104
:
858 return CIPHER_WEP104
;
859 case WPA_CIPHER_CCMP
:
861 case WPA_CIPHER_GCMP
:
863 case WPA_CIPHER_TKIP
:
870 enum wpa_key_mgmt
key_mgmt2driver(int key_mgmt
)
873 case WPA_KEY_MGMT_NONE
:
874 return KEY_MGMT_NONE
;
875 case WPA_KEY_MGMT_IEEE8021X_NO_WPA
:
876 return KEY_MGMT_802_1X_NO_WPA
;
877 case WPA_KEY_MGMT_IEEE8021X
:
878 return KEY_MGMT_802_1X
;
879 case WPA_KEY_MGMT_WPA_NONE
:
880 return KEY_MGMT_WPA_NONE
;
881 case WPA_KEY_MGMT_FT_IEEE8021X
:
882 return KEY_MGMT_FT_802_1X
;
883 case WPA_KEY_MGMT_FT_PSK
:
884 return KEY_MGMT_FT_PSK
;
885 case WPA_KEY_MGMT_IEEE8021X_SHA256
:
886 return KEY_MGMT_802_1X_SHA256
;
887 case WPA_KEY_MGMT_PSK_SHA256
:
888 return KEY_MGMT_PSK_SHA256
;
889 case WPA_KEY_MGMT_WPS
:
891 case WPA_KEY_MGMT_PSK
:
898 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant
*wpa_s
,
899 struct wpa_ssid
*ssid
,
900 struct wpa_ie_data
*ie
)
902 int ret
= wpa_sm_parse_own_wpa_ie(wpa_s
->wpa
, ie
);
905 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Failed to parse WPA IE "
906 "from association info");
911 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Using WPA IE from AssocReq to set "
913 if (!(ie
->group_cipher
& ssid
->group_cipher
)) {
914 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled group "
915 "cipher 0x%x (mask 0x%x) - reject",
916 ie
->group_cipher
, ssid
->group_cipher
);
919 if (!(ie
->pairwise_cipher
& ssid
->pairwise_cipher
)) {
920 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled pairwise "
921 "cipher 0x%x (mask 0x%x) - reject",
922 ie
->pairwise_cipher
, ssid
->pairwise_cipher
);
925 if (!(ie
->key_mgmt
& ssid
->key_mgmt
)) {
926 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver used disabled key "
927 "management 0x%x (mask 0x%x) - reject",
928 ie
->key_mgmt
, ssid
->key_mgmt
);
932 #ifdef CONFIG_IEEE80211W
933 if (!(ie
->capabilities
& WPA_CAPABILITY_MFPC
) &&
934 (ssid
->ieee80211w
== MGMT_FRAME_PROTECTION_DEFAULT
?
935 wpa_s
->conf
->pmf
: ssid
->ieee80211w
) ==
936 MGMT_FRAME_PROTECTION_REQUIRED
) {
937 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Driver associated with an AP "
938 "that does not support management frame protection - "
942 #endif /* CONFIG_IEEE80211W */
949 * wpa_supplicant_set_suites - Set authentication and encryption parameters
950 * @wpa_s: Pointer to wpa_supplicant data
951 * @bss: Scan results for the selected BSS, or %NULL if not available
952 * @ssid: Configuration data for the selected network
953 * @wpa_ie: Buffer for the WPA/RSN IE
954 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the
955 * used buffer length in case the functions returns success.
956 * Returns: 0 on success or -1 on failure
958 * This function is used to configure authentication and encryption parameters
959 * based on the network configuration and scan result for the selected BSS (if
962 int wpa_supplicant_set_suites(struct wpa_supplicant
*wpa_s
,
963 struct wpa_bss
*bss
, struct wpa_ssid
*ssid
,
964 u8
*wpa_ie
, size_t *wpa_ie_len
)
966 struct wpa_ie_data ie
;
968 const u8
*bss_wpa
, *bss_rsn
;
971 bss_wpa
= wpa_bss_get_vendor_ie(bss
, WPA_IE_VENDOR_TYPE
);
972 bss_rsn
= wpa_bss_get_ie(bss
, WLAN_EID_RSN
);
974 bss_wpa
= bss_rsn
= NULL
;
976 if (bss_rsn
&& (ssid
->proto
& WPA_PROTO_RSN
) &&
977 wpa_parse_wpa_ie(bss_rsn
, 2 + bss_rsn
[1], &ie
) == 0 &&
978 (ie
.group_cipher
& ssid
->group_cipher
) &&
979 (ie
.pairwise_cipher
& ssid
->pairwise_cipher
) &&
980 (ie
.key_mgmt
& ssid
->key_mgmt
)) {
981 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using IEEE 802.11i/D9.0");
982 proto
= WPA_PROTO_RSN
;
983 } else if (bss_wpa
&& (ssid
->proto
& WPA_PROTO_WPA
) &&
984 wpa_parse_wpa_ie(bss_wpa
, 2 +bss_wpa
[1], &ie
) == 0 &&
985 (ie
.group_cipher
& ssid
->group_cipher
) &&
986 (ie
.pairwise_cipher
& ssid
->pairwise_cipher
) &&
987 (ie
.key_mgmt
& ssid
->key_mgmt
)) {
988 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using IEEE 802.11i/D3.0");
989 proto
= WPA_PROTO_WPA
;
991 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select WPA/RSN");
994 if (ssid
->proto
& WPA_PROTO_RSN
)
995 proto
= WPA_PROTO_RSN
;
997 proto
= WPA_PROTO_WPA
;
998 if (wpa_supplicant_suites_from_ai(wpa_s
, ssid
, &ie
) < 0) {
999 os_memset(&ie
, 0, sizeof(ie
));
1000 ie
.group_cipher
= ssid
->group_cipher
;
1001 ie
.pairwise_cipher
= ssid
->pairwise_cipher
;
1002 ie
.key_mgmt
= ssid
->key_mgmt
;
1003 #ifdef CONFIG_IEEE80211W
1004 ie
.mgmt_group_cipher
=
1005 ssid
->ieee80211w
!= NO_MGMT_FRAME_PROTECTION
?
1006 WPA_CIPHER_AES_128_CMAC
: 0;
1007 #endif /* CONFIG_IEEE80211W */
1008 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Set cipher suites "
1009 "based on configuration");
1014 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected cipher suites: group %d "
1015 "pairwise %d key_mgmt %d proto %d",
1016 ie
.group_cipher
, ie
.pairwise_cipher
, ie
.key_mgmt
, proto
);
1017 #ifdef CONFIG_IEEE80211W
1018 if (ssid
->ieee80211w
) {
1019 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected mgmt group cipher %d",
1020 ie
.mgmt_group_cipher
);
1022 #endif /* CONFIG_IEEE80211W */
1024 wpa_s
->wpa_proto
= proto
;
1025 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PROTO
, proto
);
1026 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_RSN_ENABLED
,
1027 !!(ssid
->proto
& WPA_PROTO_RSN
));
1029 if (bss
|| !wpa_s
->ap_ies_from_associnfo
) {
1030 if (wpa_sm_set_ap_wpa_ie(wpa_s
->wpa
, bss_wpa
,
1031 bss_wpa
? 2 + bss_wpa
[1] : 0) ||
1032 wpa_sm_set_ap_rsn_ie(wpa_s
->wpa
, bss_rsn
,
1033 bss_rsn
? 2 + bss_rsn
[1] : 0))
1037 sel
= ie
.group_cipher
& ssid
->group_cipher
;
1038 if (sel
& WPA_CIPHER_CCMP
) {
1039 wpa_s
->group_cipher
= WPA_CIPHER_CCMP
;
1040 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK CCMP");
1041 } else if (sel
& WPA_CIPHER_GCMP
) {
1042 wpa_s
->group_cipher
= WPA_CIPHER_GCMP
;
1043 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK GCMP");
1044 } else if (sel
& WPA_CIPHER_TKIP
) {
1045 wpa_s
->group_cipher
= WPA_CIPHER_TKIP
;
1046 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK TKIP");
1047 } else if (sel
& WPA_CIPHER_WEP104
) {
1048 wpa_s
->group_cipher
= WPA_CIPHER_WEP104
;
1049 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK WEP104");
1050 } else if (sel
& WPA_CIPHER_WEP40
) {
1051 wpa_s
->group_cipher
= WPA_CIPHER_WEP40
;
1052 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using GTK WEP40");
1054 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select group "
1059 sel
= ie
.pairwise_cipher
& ssid
->pairwise_cipher
;
1060 if (sel
& WPA_CIPHER_CCMP
) {
1061 wpa_s
->pairwise_cipher
= WPA_CIPHER_CCMP
;
1062 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using PTK CCMP");
1063 } else if (sel
& WPA_CIPHER_GCMP
) {
1064 wpa_s
->pairwise_cipher
= WPA_CIPHER_GCMP
;
1065 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using PTK GCMP");
1066 } else if (sel
& WPA_CIPHER_TKIP
) {
1067 wpa_s
->pairwise_cipher
= WPA_CIPHER_TKIP
;
1068 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using PTK TKIP");
1069 } else if (sel
& WPA_CIPHER_NONE
) {
1070 wpa_s
->pairwise_cipher
= WPA_CIPHER_NONE
;
1071 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using PTK NONE");
1073 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select pairwise "
1078 sel
= ie
.key_mgmt
& ssid
->key_mgmt
;
1080 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SAE
))
1081 sel
&= ~(WPA_KEY_MGMT_SAE
| WPA_KEY_MGMT_FT_SAE
);
1082 #endif /* CONFIG_SAE */
1084 #ifdef CONFIG_IEEE80211R
1085 } else if (sel
& WPA_KEY_MGMT_FT_IEEE8021X
) {
1086 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_IEEE8021X
;
1087 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT/802.1X");
1088 } else if (sel
& WPA_KEY_MGMT_FT_PSK
) {
1089 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_PSK
;
1090 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT FT/PSK");
1091 #endif /* CONFIG_IEEE80211R */
1093 } else if (sel
& WPA_KEY_MGMT_SAE
) {
1094 wpa_s
->key_mgmt
= WPA_KEY_MGMT_SAE
;
1095 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using KEY_MGMT SAE");
1096 } else if (sel
& WPA_KEY_MGMT_FT_SAE
) {
1097 wpa_s
->key_mgmt
= WPA_KEY_MGMT_FT_SAE
;
1098 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: using KEY_MGMT FT/SAE");
1099 #endif /* CONFIG_SAE */
1100 #ifdef CONFIG_IEEE80211W
1101 } else if (sel
& WPA_KEY_MGMT_IEEE8021X_SHA256
) {
1102 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X_SHA256
;
1103 wpa_dbg(wpa_s
, MSG_DEBUG
,
1104 "WPA: using KEY_MGMT 802.1X with SHA256");
1105 } else if (sel
& WPA_KEY_MGMT_PSK_SHA256
) {
1106 wpa_s
->key_mgmt
= WPA_KEY_MGMT_PSK_SHA256
;
1107 wpa_dbg(wpa_s
, MSG_DEBUG
,
1108 "WPA: using KEY_MGMT PSK with SHA256");
1109 #endif /* CONFIG_IEEE80211W */
1110 } else if (sel
& WPA_KEY_MGMT_IEEE8021X
) {
1111 wpa_s
->key_mgmt
= WPA_KEY_MGMT_IEEE8021X
;
1112 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT 802.1X");
1113 } else if (sel
& WPA_KEY_MGMT_PSK
) {
1114 wpa_s
->key_mgmt
= WPA_KEY_MGMT_PSK
;
1115 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT WPA-PSK");
1116 } else if (sel
& WPA_KEY_MGMT_WPA_NONE
) {
1117 wpa_s
->key_mgmt
= WPA_KEY_MGMT_WPA_NONE
;
1118 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using KEY_MGMT WPA-NONE");
1120 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to select "
1121 "authenticated key management type");
1125 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_KEY_MGMT
, wpa_s
->key_mgmt
);
1126 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_PAIRWISE
,
1127 wpa_s
->pairwise_cipher
);
1128 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_GROUP
, wpa_s
->group_cipher
);
1130 #ifdef CONFIG_IEEE80211W
1131 sel
= ie
.mgmt_group_cipher
;
1132 if ((ssid
->ieee80211w
== MGMT_FRAME_PROTECTION_DEFAULT
?
1133 wpa_s
->conf
->pmf
: ssid
->ieee80211w
) == NO_MGMT_FRAME_PROTECTION
||
1134 !(ie
.capabilities
& WPA_CAPABILITY_MFPC
))
1136 if (sel
& WPA_CIPHER_AES_128_CMAC
) {
1137 wpa_s
->mgmt_group_cipher
= WPA_CIPHER_AES_128_CMAC
;
1138 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: using MGMT group cipher "
1141 wpa_s
->mgmt_group_cipher
= 0;
1142 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: not using MGMT group cipher");
1144 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MGMT_GROUP
,
1145 wpa_s
->mgmt_group_cipher
);
1146 wpa_sm_set_param(wpa_s
->wpa
, WPA_PARAM_MFP
,
1147 (ssid
->ieee80211w
== MGMT_FRAME_PROTECTION_DEFAULT
?
1148 wpa_s
->conf
->pmf
: ssid
->ieee80211w
));
1149 #endif /* CONFIG_IEEE80211W */
1151 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s
->wpa
, wpa_ie
, wpa_ie_len
)) {
1152 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to generate WPA IE");
1156 if (wpa_key_mgmt_wpa_psk(ssid
->key_mgmt
)) {
1157 wpa_sm_set_pmk(wpa_s
->wpa
, ssid
->psk
, PMK_LEN
);
1158 #ifndef CONFIG_NO_PBKDF2
1159 if (bss
&& ssid
->bssid_set
&& ssid
->ssid_len
== 0 &&
1162 pbkdf2_sha1(ssid
->passphrase
, bss
->ssid
, bss
->ssid_len
,
1163 4096, psk
, PMK_LEN
);
1164 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from passphrase)",
1166 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
);
1168 #endif /* CONFIG_NO_PBKDF2 */
1169 #ifdef CONFIG_EXT_PASSWORD
1170 if (ssid
->ext_psk
) {
1171 struct wpabuf
*pw
= ext_password_get(wpa_s
->ext_pw
,
1173 char pw_str
[64 + 1];
1177 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: No PSK "
1178 "found from external storage");
1182 if (wpabuf_len(pw
) < 8 || wpabuf_len(pw
) > 64) {
1183 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: Unexpected "
1184 "PSK length %d in external storage",
1185 (int) wpabuf_len(pw
));
1186 ext_password_free(pw
);
1190 os_memcpy(pw_str
, wpabuf_head(pw
), wpabuf_len(pw
));
1191 pw_str
[wpabuf_len(pw
)] = '\0';
1193 #ifndef CONFIG_NO_PBKDF2
1194 if (wpabuf_len(pw
) >= 8 && wpabuf_len(pw
) < 64 && bss
)
1196 pbkdf2_sha1(pw_str
, bss
->ssid
, bss
->ssid_len
,
1197 4096, psk
, PMK_LEN
);
1198 os_memset(pw_str
, 0, sizeof(pw_str
));
1199 wpa_hexdump_key(MSG_MSGDUMP
, "PSK (from "
1200 "external passphrase)",
1202 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
);
1204 #endif /* CONFIG_NO_PBKDF2 */
1205 if (wpabuf_len(pw
) == 2 * PMK_LEN
) {
1206 if (hexstr2bin(pw_str
, psk
, PMK_LEN
) < 0) {
1207 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: "
1208 "Invalid PSK hex string");
1209 os_memset(pw_str
, 0, sizeof(pw_str
));
1210 ext_password_free(pw
);
1213 wpa_sm_set_pmk(wpa_s
->wpa
, psk
, PMK_LEN
);
1215 wpa_msg(wpa_s
, MSG_INFO
, "EXT PW: No suitable "
1217 os_memset(pw_str
, 0, sizeof(pw_str
));
1218 ext_password_free(pw
);
1222 os_memset(pw_str
, 0, sizeof(pw_str
));
1223 ext_password_free(pw
);
1225 #endif /* CONFIG_EXT_PASSWORD */
1227 wpa_sm_set_pmk_from_pmksa(wpa_s
->wpa
);
1233 int wpas_build_ext_capab(struct wpa_supplicant
*wpa_s
, u8
*buf
)
1238 #ifdef CONFIG_INTERWORKING
1239 if (wpa_s
->conf
->interworking
)
1240 ext_capab
|= BIT(31); /* Interworking */
1241 #endif /* CONFIG_INTERWORKING */
1244 ext_capab
|= BIT(17); /* WNM-Sleep Mode */
1245 ext_capab
|= BIT(19); /* BSS Transition */
1246 #endif /* CONFIG_WNM */
1251 *pos
++ = WLAN_EID_EXT_CAPAB
;
1253 WPA_PUT_LE32(pos
, ext_capab
);
1261 * wpa_supplicant_associate - Request association
1262 * @wpa_s: Pointer to wpa_supplicant data
1263 * @bss: Scan results for the selected BSS, or %NULL if not available
1264 * @ssid: Configuration data for the selected network
1266 * This function is used to request %wpa_supplicant to associate with a BSS.
1268 void wpa_supplicant_associate(struct wpa_supplicant
*wpa_s
,
1269 struct wpa_bss
*bss
, struct wpa_ssid
*ssid
)
1273 int use_crypt
, ret
, i
, bssid_changed
;
1274 int algs
= WPA_AUTH_ALG_OPEN
;
1275 enum wpa_cipher cipher_pairwise
, cipher_group
;
1276 struct wpa_driver_associate_params params
;
1277 int wep_keys_set
= 0;
1278 struct wpa_driver_capa capa
;
1279 int assoc_failed
= 0;
1280 struct wpa_ssid
*old_ssid
;
1283 #ifdef CONFIG_HT_OVERRIDES
1284 struct ieee80211_ht_capabilities htcaps
;
1285 struct ieee80211_ht_capabilities htcaps_mask
;
1286 #endif /* CONFIG_HT_OVERRIDES */
1288 #ifdef CONFIG_IBSS_RSN
1289 ibss_rsn_deinit(wpa_s
->ibss_rsn
);
1290 wpa_s
->ibss_rsn
= NULL
;
1291 #endif /* CONFIG_IBSS_RSN */
1293 if (ssid
->mode
== WPAS_MODE_AP
|| ssid
->mode
== WPAS_MODE_P2P_GO
||
1294 ssid
->mode
== WPAS_MODE_P2P_GROUP_FORMATION
) {
1296 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_AP
)) {
1297 wpa_msg(wpa_s
, MSG_INFO
, "Driver does not support AP "
1301 if (wpa_supplicant_create_ap(wpa_s
, ssid
) < 0) {
1302 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
1305 wpa_s
->current_bss
= bss
;
1306 #else /* CONFIG_AP */
1307 wpa_msg(wpa_s
, MSG_ERROR
, "AP mode support not included in "
1309 #endif /* CONFIG_AP */
1315 wpa_tdls_ap_ies(wpa_s
->wpa
, (const u8
*) (bss
+ 1),
1317 #endif /* CONFIG_TDLS */
1319 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SME
) &&
1320 ssid
->mode
== IEEE80211_MODE_INFRA
) {
1321 sme_authenticate(wpa_s
, bss
, ssid
);
1325 os_memset(¶ms
, 0, sizeof(params
));
1326 wpa_s
->reassociate
= 0;
1327 if (bss
&& !wpas_driver_bss_selection(wpa_s
)) {
1328 #ifdef CONFIG_IEEE80211R
1329 const u8
*ie
, *md
= NULL
;
1330 #endif /* CONFIG_IEEE80211R */
1331 wpa_msg(wpa_s
, MSG_INFO
, "Trying to associate with " MACSTR
1332 " (SSID='%s' freq=%d MHz)", MAC2STR(bss
->bssid
),
1333 wpa_ssid_txt(bss
->ssid
, bss
->ssid_len
), bss
->freq
);
1334 bssid_changed
= !is_zero_ether_addr(wpa_s
->bssid
);
1335 os_memset(wpa_s
->bssid
, 0, ETH_ALEN
);
1336 os_memcpy(wpa_s
->pending_bssid
, bss
->bssid
, ETH_ALEN
);
1338 wpas_notify_bssid_changed(wpa_s
);
1339 #ifdef CONFIG_IEEE80211R
1340 ie
= wpa_bss_get_ie(bss
, WLAN_EID_MOBILITY_DOMAIN
);
1341 if (ie
&& ie
[1] >= MOBILITY_DOMAIN_ID_LEN
)
1343 wpa_sm_set_ft_params(wpa_s
->wpa
, ie
, ie
? 2 + ie
[1] : 0);
1345 /* Prepare for the next transition */
1346 wpa_ft_prepare_auth_request(wpa_s
->wpa
, ie
);
1348 #endif /* CONFIG_IEEE80211R */
1350 } else if ((ssid
->ssid
== NULL
|| ssid
->ssid_len
== 0) &&
1351 wpa_s
->conf
->ap_scan
== 2 &&
1352 (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
)) {
1353 /* Use ap_scan==1 style network selection to find the network
1355 wpa_s
->scan_req
= MANUAL_SCAN_REQ
;
1356 wpa_s
->reassociate
= 1;
1357 wpa_supplicant_req_scan(wpa_s
, 0, 0);
1359 #endif /* CONFIG_WPS */
1361 wpa_msg(wpa_s
, MSG_INFO
, "Trying to associate with SSID '%s'",
1362 wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
1363 os_memset(wpa_s
->pending_bssid
, 0, ETH_ALEN
);
1365 wpa_supplicant_cancel_sched_scan(wpa_s
);
1366 wpa_supplicant_cancel_scan(wpa_s
);
1368 /* Starting new association, so clear the possibly used WPA IE from the
1369 * previous association. */
1370 wpa_sm_set_assoc_wpa_ie(wpa_s
->wpa
, NULL
, 0);
1372 #ifdef IEEE8021X_EAPOL
1373 if (ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
1375 if (ssid
->non_leap
== 0)
1376 algs
= WPA_AUTH_ALG_LEAP
;
1378 algs
|= WPA_AUTH_ALG_LEAP
;
1381 #endif /* IEEE8021X_EAPOL */
1382 wpa_dbg(wpa_s
, MSG_DEBUG
, "Automatic auth_alg selection: 0x%x", algs
);
1383 if (ssid
->auth_alg
) {
1384 algs
= ssid
->auth_alg
;
1385 wpa_dbg(wpa_s
, MSG_DEBUG
, "Overriding auth_alg selection: "
1389 if (bss
&& (wpa_bss_get_vendor_ie(bss
, WPA_IE_VENDOR_TYPE
) ||
1390 wpa_bss_get_ie(bss
, WLAN_EID_RSN
)) &&
1391 wpa_key_mgmt_wpa(ssid
->key_mgmt
)) {
1392 int try_opportunistic
;
1393 try_opportunistic
= (ssid
->proactive_key_caching
< 0 ?
1395 ssid
->proactive_key_caching
) &&
1396 (ssid
->proto
& WPA_PROTO_RSN
);
1397 if (pmksa_cache_set_current(wpa_s
->wpa
, NULL
, bss
->bssid
,
1398 wpa_s
->current_ssid
,
1399 try_opportunistic
) == 0)
1400 eapol_sm_notify_pmkid_attempt(wpa_s
->eapol
, 1);
1401 wpa_ie_len
= sizeof(wpa_ie
);
1402 if (wpa_supplicant_set_suites(wpa_s
, bss
, ssid
,
1403 wpa_ie
, &wpa_ie_len
)) {
1404 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to set WPA "
1405 "key management and encryption suites");
1408 } else if ((ssid
->key_mgmt
& WPA_KEY_MGMT_IEEE8021X_NO_WPA
) && bss
&&
1409 wpa_key_mgmt_wpa_ieee8021x(ssid
->key_mgmt
)) {
1411 * Both WPA and non-WPA IEEE 802.1X enabled in configuration -
1412 * use non-WPA since the scan results did not indicate that the
1413 * AP is using WPA or WPA2.
1415 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
1417 wpa_s
->wpa_proto
= 0;
1418 } else if (wpa_key_mgmt_wpa_any(ssid
->key_mgmt
)) {
1419 wpa_ie_len
= sizeof(wpa_ie
);
1420 if (wpa_supplicant_set_suites(wpa_s
, NULL
, ssid
,
1421 wpa_ie
, &wpa_ie_len
)) {
1422 wpa_msg(wpa_s
, MSG_WARNING
, "WPA: Failed to set WPA "
1423 "key management and encryption suites (no "
1428 } else if (ssid
->key_mgmt
& WPA_KEY_MGMT_WPS
) {
1429 struct wpabuf
*wps_ie
;
1430 wps_ie
= wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid
));
1431 if (wps_ie
&& wpabuf_len(wps_ie
) <= sizeof(wpa_ie
)) {
1432 wpa_ie_len
= wpabuf_len(wps_ie
);
1433 os_memcpy(wpa_ie
, wpabuf_head(wps_ie
), wpa_ie_len
);
1436 wpabuf_free(wps_ie
);
1437 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
1438 if (!bss
|| (bss
->caps
& IEEE80211_CAP_PRIVACY
))
1439 params
.wps
= WPS_MODE_PRIVACY
;
1441 params
.wps
= WPS_MODE_OPEN
;
1442 wpa_s
->wpa_proto
= 0;
1443 #endif /* CONFIG_WPS */
1445 wpa_supplicant_set_non_wpa_policy(wpa_s
, ssid
);
1447 wpa_s
->wpa_proto
= 0;
1451 if (wpa_s
->global
->p2p
) {
1455 pos
= wpa_ie
+ wpa_ie_len
;
1456 len
= sizeof(wpa_ie
) - wpa_ie_len
;
1457 res
= wpas_p2p_assoc_req_ie(wpa_s
, bss
, pos
, len
,
1463 wpa_s
->cross_connect_disallowed
= 0;
1466 p2p
= wpa_bss_get_vendor_ie_multi(bss
, P2P_IE_VENDOR_TYPE
);
1468 wpa_s
->cross_connect_disallowed
=
1469 p2p_get_cross_connect_disallowed(p2p
);
1471 wpa_dbg(wpa_s
, MSG_DEBUG
, "P2P: WLAN AP %s cross "
1473 wpa_s
->cross_connect_disallowed
?
1474 "disallows" : "allows");
1477 #endif /* CONFIG_P2P */
1480 if (wpa_s
->conf
->hs20
) {
1481 struct wpabuf
*hs20
;
1482 hs20
= wpabuf_alloc(20);
1484 wpas_hs20_add_indication(hs20
);
1485 os_memcpy(wpa_ie
+ wpa_ie_len
, wpabuf_head(hs20
),
1487 wpa_ie_len
+= wpabuf_len(hs20
);
1491 #endif /* CONFIG_HS20 */
1493 ext_capab_len
= wpas_build_ext_capab(wpa_s
, ext_capab
);
1494 if (ext_capab_len
> 0) {
1496 if (wpa_ie_len
> 0 && pos
[0] == WLAN_EID_RSN
)
1498 os_memmove(pos
+ ext_capab_len
, pos
,
1499 wpa_ie_len
- (pos
- wpa_ie
));
1500 wpa_ie_len
+= ext_capab_len
;
1501 os_memcpy(pos
, ext_capab
, ext_capab_len
);
1504 wpa_clear_keys(wpa_s
, bss
? bss
->bssid
: NULL
);
1506 cipher_pairwise
= cipher_suite2driver(wpa_s
->pairwise_cipher
);
1507 cipher_group
= cipher_suite2driver(wpa_s
->group_cipher
);
1508 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
||
1509 wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
1510 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
)
1512 if (wpa_set_wep_keys(wpa_s
, ssid
)) {
1517 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
)
1520 #ifdef IEEE8021X_EAPOL
1521 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
1522 if ((ssid
->eapol_flags
&
1523 (EAPOL_FLAG_REQUIRE_KEY_UNICAST
|
1524 EAPOL_FLAG_REQUIRE_KEY_BROADCAST
)) == 0 &&
1528 /* Assume that dynamic WEP-104 keys will be used and
1529 * set cipher suites in order for drivers to expect
1531 cipher_pairwise
= cipher_group
= CIPHER_WEP104
;
1534 #endif /* IEEE8021X_EAPOL */
1536 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
) {
1537 /* Set the key before (and later after) association */
1538 wpa_supplicant_set_wpa_none_key(wpa_s
, ssid
);
1541 wpa_supplicant_set_state(wpa_s
, WPA_ASSOCIATING
);
1543 params
.ssid
= bss
->ssid
;
1544 params
.ssid_len
= bss
->ssid_len
;
1545 if (!wpas_driver_bss_selection(wpa_s
) || ssid
->bssid_set
) {
1546 wpa_printf(MSG_DEBUG
, "Limit connection to BSSID "
1547 MACSTR
" freq=%u MHz based on scan results "
1549 MAC2STR(bss
->bssid
), bss
->freq
,
1551 params
.bssid
= bss
->bssid
;
1552 params
.freq
= bss
->freq
;
1555 params
.ssid
= ssid
->ssid
;
1556 params
.ssid_len
= ssid
->ssid_len
;
1559 if (ssid
->mode
== WPAS_MODE_IBSS
&& ssid
->bssid_set
&&
1560 wpa_s
->conf
->ap_scan
== 2) {
1561 params
.bssid
= ssid
->bssid
;
1562 params
.fixed_bssid
= 1;
1565 if (ssid
->mode
== WPAS_MODE_IBSS
&& ssid
->frequency
> 0 &&
1567 params
.freq
= ssid
->frequency
; /* Initial channel for IBSS */
1568 params
.wpa_ie
= wpa_ie
;
1569 params
.wpa_ie_len
= wpa_ie_len
;
1570 params
.pairwise_suite
= cipher_pairwise
;
1571 params
.group_suite
= cipher_group
;
1572 params
.key_mgmt_suite
= key_mgmt2driver(wpa_s
->key_mgmt
);
1573 params
.wpa_proto
= wpa_s
->wpa_proto
;
1574 params
.auth_alg
= algs
;
1575 params
.mode
= ssid
->mode
;
1576 params
.bg_scan_period
= ssid
->bg_scan_period
;
1577 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
1578 if (ssid
->wep_key_len
[i
])
1579 params
.wep_key
[i
] = ssid
->wep_key
[i
];
1580 params
.wep_key_len
[i
] = ssid
->wep_key_len
[i
];
1582 params
.wep_tx_keyidx
= ssid
->wep_tx_keyidx
;
1584 if ((wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) &&
1585 (params
.key_mgmt_suite
== KEY_MGMT_PSK
||
1586 params
.key_mgmt_suite
== KEY_MGMT_FT_PSK
)) {
1587 params
.passphrase
= ssid
->passphrase
;
1589 params
.psk
= ssid
->psk
;
1592 params
.drop_unencrypted
= use_crypt
;
1594 #ifdef CONFIG_IEEE80211W
1595 params
.mgmt_frame_protection
=
1596 ssid
->ieee80211w
== MGMT_FRAME_PROTECTION_DEFAULT
?
1597 wpa_s
->conf
->pmf
: ssid
->ieee80211w
;
1598 if (params
.mgmt_frame_protection
!= NO_MGMT_FRAME_PROTECTION
&& bss
) {
1599 const u8
*rsn
= wpa_bss_get_ie(bss
, WLAN_EID_RSN
);
1600 struct wpa_ie_data ie
;
1601 if (rsn
&& wpa_parse_wpa_ie(rsn
, 2 + rsn
[1], &ie
) == 0 &&
1603 (WPA_CAPABILITY_MFPC
| WPA_CAPABILITY_MFPR
)) {
1604 wpa_dbg(wpa_s
, MSG_DEBUG
, "WPA: Selected AP supports "
1605 "MFP: require MFP");
1606 params
.mgmt_frame_protection
=
1607 MGMT_FRAME_PROTECTION_REQUIRED
;
1610 #endif /* CONFIG_IEEE80211W */
1612 params
.p2p
= ssid
->p2p_group
;
1614 if (wpa_s
->parent
->set_sta_uapsd
)
1615 params
.uapsd
= wpa_s
->parent
->sta_uapsd
;
1619 #ifdef CONFIG_HT_OVERRIDES
1620 os_memset(&htcaps
, 0, sizeof(htcaps
));
1621 os_memset(&htcaps_mask
, 0, sizeof(htcaps_mask
));
1622 params
.htcaps
= (u8
*) &htcaps
;
1623 params
.htcaps_mask
= (u8
*) &htcaps_mask
;
1624 wpa_supplicant_apply_ht_overrides(wpa_s
, ssid
, ¶ms
);
1625 #endif /* CONFIG_HT_OVERRIDES */
1627 ret
= wpa_drv_associate(wpa_s
, ¶ms
);
1629 wpa_msg(wpa_s
, MSG_INFO
, "Association request to the driver "
1631 if (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_SANE_ERROR_CODES
) {
1633 * The driver is known to mean what is saying, so we
1634 * can stop right here; the association will not
1637 wpas_connection_failed(wpa_s
, wpa_s
->pending_bssid
);
1638 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
1639 os_memset(wpa_s
->pending_bssid
, 0, ETH_ALEN
);
1642 /* try to continue anyway; new association will be tried again
1647 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPA_NONE
) {
1648 /* Set the key after the association just in case association
1649 * cleared the previously configured key. */
1650 wpa_supplicant_set_wpa_none_key(wpa_s
, ssid
);
1651 /* No need to timeout authentication since there is no key
1653 wpa_supplicant_cancel_auth_timeout(wpa_s
);
1654 wpa_supplicant_set_state(wpa_s
, WPA_COMPLETED
);
1655 #ifdef CONFIG_IBSS_RSN
1656 } else if (ssid
->mode
== WPAS_MODE_IBSS
&&
1657 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_NONE
&&
1658 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_WPA_NONE
) {
1660 * RSN IBSS authentication is per-STA and we can disable the
1661 * per-BSSID authentication.
1663 wpa_supplicant_cancel_auth_timeout(wpa_s
);
1664 #endif /* CONFIG_IBSS_RSN */
1666 /* Timeout for IEEE 802.11 authentication and association */
1670 /* give IBSS a bit more time */
1671 timeout
= ssid
->mode
== WPAS_MODE_IBSS
? 10 : 5;
1672 } else if (wpa_s
->conf
->ap_scan
== 1) {
1673 /* give IBSS a bit more time */
1674 timeout
= ssid
->mode
== WPAS_MODE_IBSS
? 20 : 10;
1676 wpa_supplicant_req_auth_timeout(wpa_s
, timeout
, 0);
1679 if (wep_keys_set
&& wpa_drv_get_capa(wpa_s
, &capa
) == 0 &&
1680 capa
.flags
& WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC
) {
1681 /* Set static WEP keys again */
1682 wpa_set_wep_keys(wpa_s
, ssid
);
1685 if (wpa_s
->current_ssid
&& wpa_s
->current_ssid
!= ssid
) {
1687 * Do not allow EAP session resumption between different
1688 * network configurations.
1690 eapol_sm_invalidate_cached_session(wpa_s
->eapol
);
1692 old_ssid
= wpa_s
->current_ssid
;
1693 wpa_s
->current_ssid
= ssid
;
1694 wpa_s
->current_bss
= bss
;
1695 wpa_supplicant_rsn_supp_set_config(wpa_s
, wpa_s
->current_ssid
);
1696 wpa_supplicant_initiate_eapol(wpa_s
);
1697 if (old_ssid
!= wpa_s
->current_ssid
)
1698 wpas_notify_network_changed(wpa_s
);
1702 static void wpa_supplicant_clear_connection(struct wpa_supplicant
*wpa_s
,
1705 struct wpa_ssid
*old_ssid
;
1707 wpa_clear_keys(wpa_s
, addr
);
1708 old_ssid
= wpa_s
->current_ssid
;
1709 wpa_supplicant_mark_disassoc(wpa_s
);
1710 wpa_sm_set_config(wpa_s
->wpa
, NULL
);
1711 eapol_sm_notify_config(wpa_s
->eapol
, NULL
, NULL
);
1712 if (old_ssid
!= wpa_s
->current_ssid
)
1713 wpas_notify_network_changed(wpa_s
);
1714 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
1719 * wpa_supplicant_deauthenticate - Deauthenticate the current connection
1720 * @wpa_s: Pointer to wpa_supplicant data
1721 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame
1723 * This function is used to request %wpa_supplicant to deauthenticate from the
1726 void wpa_supplicant_deauthenticate(struct wpa_supplicant
*wpa_s
,
1730 union wpa_event_data event
;
1733 wpa_dbg(wpa_s
, MSG_DEBUG
, "Request to deauthenticate - bssid=" MACSTR
1734 " pending_bssid=" MACSTR
" reason=%d state=%s",
1735 MAC2STR(wpa_s
->bssid
), MAC2STR(wpa_s
->pending_bssid
),
1736 reason_code
, wpa_supplicant_state_txt(wpa_s
->wpa_state
));
1738 if (!is_zero_ether_addr(wpa_s
->bssid
))
1739 addr
= wpa_s
->bssid
;
1740 else if (!is_zero_ether_addr(wpa_s
->pending_bssid
) &&
1741 (wpa_s
->wpa_state
== WPA_AUTHENTICATING
||
1742 wpa_s
->wpa_state
== WPA_ASSOCIATING
))
1743 addr
= wpa_s
->pending_bssid
;
1744 else if (wpa_s
->wpa_state
== WPA_ASSOCIATING
) {
1746 * When using driver-based BSS selection, we may not know the
1747 * BSSID with which we are currently trying to associate. We
1748 * need to notify the driver of this disconnection even in such
1749 * a case, so use the all zeros address here.
1751 addr
= wpa_s
->bssid
;
1756 wpa_drv_deauthenticate(wpa_s
, addr
, reason_code
);
1757 os_memset(&event
, 0, sizeof(event
));
1758 event
.deauth_info
.reason_code
= (u16
) reason_code
;
1759 event
.deauth_info
.locally_generated
= 1;
1760 wpa_supplicant_event(wpa_s
, EVENT_DEAUTH
, &event
);
1765 wpa_supplicant_clear_connection(wpa_s
, addr
);
1770 * wpa_supplicant_enable_network - Mark a configured network as enabled
1771 * @wpa_s: wpa_supplicant structure for a network interface
1772 * @ssid: wpa_ssid structure for a configured network or %NULL
1774 * Enables the specified network or all networks if no network specified.
1776 void wpa_supplicant_enable_network(struct wpa_supplicant
*wpa_s
,
1777 struct wpa_ssid
*ssid
)
1779 struct wpa_ssid
*other_ssid
;
1783 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
1784 other_ssid
= other_ssid
->next
) {
1785 if (other_ssid
->disabled
== 2)
1786 continue; /* do not change persistent P2P group
1788 if (other_ssid
== wpa_s
->current_ssid
&&
1789 other_ssid
->disabled
)
1790 wpa_s
->reassociate
= 1;
1792 was_disabled
= other_ssid
->disabled
;
1794 other_ssid
->disabled
= 0;
1796 wpas_clear_temp_disabled(wpa_s
, other_ssid
, 0);
1798 if (was_disabled
!= other_ssid
->disabled
)
1799 wpas_notify_network_enabled_changed(
1802 if (wpa_s
->reassociate
)
1803 wpa_supplicant_req_scan(wpa_s
, 0, 0);
1804 } else if (ssid
->disabled
&& ssid
->disabled
!= 2) {
1805 if (wpa_s
->current_ssid
== NULL
) {
1807 * Try to reassociate since there is no current
1808 * configuration and a new network was made available.
1810 wpa_s
->reassociate
= 1;
1811 wpa_supplicant_req_scan(wpa_s
, 0, 0);
1814 was_disabled
= ssid
->disabled
;
1817 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
1819 if (was_disabled
!= ssid
->disabled
)
1820 wpas_notify_network_enabled_changed(wpa_s
, ssid
);
1826 * wpa_supplicant_disable_network - Mark a configured network as disabled
1827 * @wpa_s: wpa_supplicant structure for a network interface
1828 * @ssid: wpa_ssid structure for a configured network or %NULL
1830 * Disables the specified network or all networks if no network specified.
1832 void wpa_supplicant_disable_network(struct wpa_supplicant
*wpa_s
,
1833 struct wpa_ssid
*ssid
)
1835 struct wpa_ssid
*other_ssid
;
1839 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
1840 other_ssid
= other_ssid
->next
) {
1841 was_disabled
= other_ssid
->disabled
;
1842 if (was_disabled
== 2)
1843 continue; /* do not change persistent P2P group
1846 other_ssid
->disabled
= 1;
1848 if (was_disabled
!= other_ssid
->disabled
)
1849 wpas_notify_network_enabled_changed(
1852 if (wpa_s
->current_ssid
)
1853 wpa_supplicant_deauthenticate(
1854 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
1855 } else if (ssid
->disabled
!= 2) {
1856 if (ssid
== wpa_s
->current_ssid
)
1857 wpa_supplicant_deauthenticate(
1858 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
1860 was_disabled
= ssid
->disabled
;
1864 if (was_disabled
!= ssid
->disabled
)
1865 wpas_notify_network_enabled_changed(wpa_s
, ssid
);
1871 * wpa_supplicant_select_network - Attempt association with a network
1872 * @wpa_s: wpa_supplicant structure for a network interface
1873 * @ssid: wpa_ssid structure for a configured network or %NULL for any network
1875 void wpa_supplicant_select_network(struct wpa_supplicant
*wpa_s
,
1876 struct wpa_ssid
*ssid
)
1879 struct wpa_ssid
*other_ssid
;
1880 int disconnected
= 0;
1882 if (ssid
&& ssid
!= wpa_s
->current_ssid
&& wpa_s
->current_ssid
) {
1883 wpa_supplicant_deauthenticate(
1884 wpa_s
, WLAN_REASON_DEAUTH_LEAVING
);
1889 wpas_clear_temp_disabled(wpa_s
, ssid
, 1);
1892 * Mark all other networks disabled or mark all networks enabled if no
1893 * network specified.
1895 for (other_ssid
= wpa_s
->conf
->ssid
; other_ssid
;
1896 other_ssid
= other_ssid
->next
) {
1897 int was_disabled
= other_ssid
->disabled
;
1898 if (was_disabled
== 2)
1899 continue; /* do not change persistent P2P group data */
1901 other_ssid
->disabled
= ssid
? (ssid
->id
!= other_ssid
->id
) : 0;
1902 if (was_disabled
&& !other_ssid
->disabled
)
1903 wpas_clear_temp_disabled(wpa_s
, other_ssid
, 0);
1905 if (was_disabled
!= other_ssid
->disabled
)
1906 wpas_notify_network_enabled_changed(wpa_s
, other_ssid
);
1909 if (ssid
&& ssid
== wpa_s
->current_ssid
&& wpa_s
->current_ssid
) {
1910 /* We are already associated with the selected network */
1911 wpa_printf(MSG_DEBUG
, "Already associated with the "
1912 "selected network - do nothing");
1917 wpa_s
->current_ssid
= ssid
;
1918 wpa_s
->connect_without_scan
= NULL
;
1919 wpa_s
->disconnected
= 0;
1920 wpa_s
->reassociate
= 1;
1921 wpa_supplicant_req_scan(wpa_s
, 0, disconnected
? 100000 : 0);
1924 wpas_notify_network_selected(wpa_s
, ssid
);
1929 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface
1930 * @wpa_s: wpa_supplicant structure for a network interface
1931 * @ap_scan: AP scan mode
1932 * Returns: 0 if succeed or -1 if ap_scan has an invalid value
1935 int wpa_supplicant_set_ap_scan(struct wpa_supplicant
*wpa_s
, int ap_scan
)
1940 if (ap_scan
< 0 || ap_scan
> 2)
1944 if (ap_scan
== 2 && ap_scan
!= wpa_s
->conf
->ap_scan
&&
1945 wpa_s
->wpa_state
>= WPA_ASSOCIATING
&&
1946 wpa_s
->wpa_state
< WPA_COMPLETED
) {
1947 wpa_printf(MSG_ERROR
, "ap_scan = %d (%d) rejected while "
1948 "associating", wpa_s
->conf
->ap_scan
, ap_scan
);
1951 #endif /* ANDROID */
1953 old_ap_scan
= wpa_s
->conf
->ap_scan
;
1954 wpa_s
->conf
->ap_scan
= ap_scan
;
1956 if (old_ap_scan
!= wpa_s
->conf
->ap_scan
)
1957 wpas_notify_ap_scan_changed(wpa_s
);
1964 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age
1965 * @wpa_s: wpa_supplicant structure for a network interface
1966 * @expire_age: Expiration age in seconds
1967 * Returns: 0 if succeed or -1 if expire_age has an invalid value
1970 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant
*wpa_s
,
1971 unsigned int bss_expire_age
)
1973 if (bss_expire_age
< 10) {
1974 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid bss expiration age %u",
1978 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting bss expiration age: %d sec",
1980 wpa_s
->conf
->bss_expiration_age
= bss_expire_age
;
1987 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count
1988 * @wpa_s: wpa_supplicant structure for a network interface
1989 * @expire_count: number of scans after which an unseen BSS is reclaimed
1990 * Returns: 0 if succeed or -1 if expire_count has an invalid value
1993 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant
*wpa_s
,
1994 unsigned int bss_expire_count
)
1996 if (bss_expire_count
< 1) {
1997 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid bss expiration count %u",
2001 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting bss expiration scan count: %u",
2003 wpa_s
->conf
->bss_expiration_scan_count
= bss_expire_count
;
2010 * wpa_supplicant_set_scan_interval - Set scan interval
2011 * @wpa_s: wpa_supplicant structure for a network interface
2012 * @scan_interval: scan interval in seconds
2013 * Returns: 0 if succeed or -1 if scan_interval has an invalid value
2016 int wpa_supplicant_set_scan_interval(struct wpa_supplicant
*wpa_s
,
2019 if (scan_interval
< 0) {
2020 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid scan interval %d",
2024 wpa_msg(wpa_s
, MSG_DEBUG
, "Setting scan interval: %d sec",
2026 wpa_s
->scan_interval
= scan_interval
;
2033 * wpa_supplicant_set_debug_params - Set global debug params
2034 * @global: wpa_global structure
2035 * @debug_level: debug level
2036 * @debug_timestamp: determines if show timestamp in debug data
2037 * @debug_show_keys: determines if show keys in debug data
2038 * Returns: 0 if succeed or -1 if debug_level has wrong value
2040 int wpa_supplicant_set_debug_params(struct wpa_global
*global
, int debug_level
,
2041 int debug_timestamp
, int debug_show_keys
)
2044 int old_level
, old_timestamp
, old_show_keys
;
2046 /* check for allowed debuglevels */
2047 if (debug_level
!= MSG_EXCESSIVE
&&
2048 debug_level
!= MSG_MSGDUMP
&&
2049 debug_level
!= MSG_DEBUG
&&
2050 debug_level
!= MSG_INFO
&&
2051 debug_level
!= MSG_WARNING
&&
2052 debug_level
!= MSG_ERROR
)
2055 old_level
= wpa_debug_level
;
2056 old_timestamp
= wpa_debug_timestamp
;
2057 old_show_keys
= wpa_debug_show_keys
;
2059 wpa_debug_level
= debug_level
;
2060 wpa_debug_timestamp
= debug_timestamp
? 1 : 0;
2061 wpa_debug_show_keys
= debug_show_keys
? 1 : 0;
2063 if (wpa_debug_level
!= old_level
)
2064 wpas_notify_debug_level_changed(global
);
2065 if (wpa_debug_timestamp
!= old_timestamp
)
2066 wpas_notify_debug_timestamp_changed(global
);
2067 if (wpa_debug_show_keys
!= old_show_keys
)
2068 wpas_notify_debug_show_keys_changed(global
);
2075 * wpa_supplicant_get_ssid - Get a pointer to the current network structure
2076 * @wpa_s: Pointer to wpa_supplicant data
2077 * Returns: A pointer to the current network structure or %NULL on failure
2079 struct wpa_ssid
* wpa_supplicant_get_ssid(struct wpa_supplicant
*wpa_s
)
2081 struct wpa_ssid
*entry
;
2082 u8 ssid
[MAX_SSID_LEN
];
2088 res
= wpa_drv_get_ssid(wpa_s
, ssid
);
2090 wpa_msg(wpa_s
, MSG_WARNING
, "Could not read SSID from "
2096 if (wpa_drv_get_bssid(wpa_s
, bssid
) < 0) {
2097 wpa_msg(wpa_s
, MSG_WARNING
, "Could not read BSSID from "
2102 wired
= wpa_s
->conf
->ap_scan
== 0 &&
2103 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_WIRED
);
2105 entry
= wpa_s
->conf
->ssid
;
2107 if (!wpas_network_disabled(wpa_s
, entry
) &&
2108 ((ssid_len
== entry
->ssid_len
&&
2109 os_memcmp(ssid
, entry
->ssid
, ssid_len
) == 0) || wired
) &&
2110 (!entry
->bssid_set
||
2111 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0))
2114 if (!wpas_network_disabled(wpa_s
, entry
) &&
2115 (entry
->key_mgmt
& WPA_KEY_MGMT_WPS
) &&
2116 (entry
->ssid
== NULL
|| entry
->ssid_len
== 0) &&
2117 (!entry
->bssid_set
||
2118 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0))
2120 #endif /* CONFIG_WPS */
2122 if (!wpas_network_disabled(wpa_s
, entry
) && entry
->bssid_set
&&
2123 entry
->ssid_len
== 0 &&
2124 os_memcmp(bssid
, entry
->bssid
, ETH_ALEN
) == 0)
2127 entry
= entry
->next
;
2134 static int select_driver(struct wpa_supplicant
*wpa_s
, int i
)
2136 struct wpa_global
*global
= wpa_s
->global
;
2138 if (wpa_drivers
[i
]->global_init
&& global
->drv_priv
[i
] == NULL
) {
2139 global
->drv_priv
[i
] = wpa_drivers
[i
]->global_init();
2140 if (global
->drv_priv
[i
] == NULL
) {
2141 wpa_printf(MSG_ERROR
, "Failed to initialize driver "
2142 "'%s'", wpa_drivers
[i
]->name
);
2147 wpa_s
->driver
= wpa_drivers
[i
];
2148 wpa_s
->global_drv_priv
= global
->drv_priv
[i
];
2154 static int wpa_supplicant_set_driver(struct wpa_supplicant
*wpa_s
,
2159 const char *pos
, *driver
= name
;
2164 if (wpa_drivers
[0] == NULL
) {
2165 wpa_msg(wpa_s
, MSG_ERROR
, "No driver interfaces build into "
2171 /* default to first driver in the list */
2172 return select_driver(wpa_s
, 0);
2176 pos
= os_strchr(driver
, ',');
2180 len
= os_strlen(driver
);
2182 for (i
= 0; wpa_drivers
[i
]; i
++) {
2183 if (os_strlen(wpa_drivers
[i
]->name
) == len
&&
2184 os_strncmp(driver
, wpa_drivers
[i
]->name
, len
) ==
2186 /* First driver that succeeds wins */
2187 if (select_driver(wpa_s
, i
) == 0)
2195 wpa_msg(wpa_s
, MSG_ERROR
, "Unsupported driver '%s'", name
);
2201 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant
2202 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
2203 * with struct wpa_driver_ops::init()
2204 * @src_addr: Source address of the EAPOL frame
2205 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header)
2206 * @len: Length of the EAPOL data
2208 * This function is called for each received EAPOL frame. Most driver
2209 * interfaces rely on more generic OS mechanism for receiving frames through
2210 * l2_packet, but if such a mechanism is not available, the driver wrapper may
2211 * take care of received EAPOL frames and deliver them to the core supplicant
2212 * code by calling this function.
2214 void wpa_supplicant_rx_eapol(void *ctx
, const u8
*src_addr
,
2215 const u8
*buf
, size_t len
)
2217 struct wpa_supplicant
*wpa_s
= ctx
;
2219 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
, MAC2STR(src_addr
));
2220 wpa_hexdump(MSG_MSGDUMP
, "RX EAPOL", buf
, len
);
2222 if (wpa_s
->wpa_state
< WPA_ASSOCIATED
||
2223 (wpa_s
->last_eapol_matches_bssid
&&
2226 #endif /* CONFIG_AP */
2227 os_memcmp(src_addr
, wpa_s
->bssid
, ETH_ALEN
) != 0)) {
2229 * There is possible race condition between receiving the
2230 * association event and the EAPOL frame since they are coming
2231 * through different paths from the driver. In order to avoid
2232 * issues in trying to process the EAPOL frame before receiving
2233 * association information, lets queue it for processing until
2234 * the association event is received. This may also be needed in
2235 * driver-based roaming case, so also use src_addr != BSSID as a
2236 * trigger if we have previously confirmed that the
2237 * Authenticator uses BSSID as the src_addr (which is not the
2238 * case with wired IEEE 802.1X).
2240 wpa_dbg(wpa_s
, MSG_DEBUG
, "Not associated - Delay processing "
2241 "of received EAPOL frame (state=%s bssid=" MACSTR
")",
2242 wpa_supplicant_state_txt(wpa_s
->wpa_state
),
2243 MAC2STR(wpa_s
->bssid
));
2244 wpabuf_free(wpa_s
->pending_eapol_rx
);
2245 wpa_s
->pending_eapol_rx
= wpabuf_alloc_copy(buf
, len
);
2246 if (wpa_s
->pending_eapol_rx
) {
2247 os_get_time(&wpa_s
->pending_eapol_rx_time
);
2248 os_memcpy(wpa_s
->pending_eapol_rx_src
, src_addr
,
2254 wpa_s
->last_eapol_matches_bssid
=
2255 os_memcmp(src_addr
, wpa_s
->bssid
, ETH_ALEN
) == 0;
2258 if (wpa_s
->ap_iface
) {
2259 wpa_supplicant_ap_rx_eapol(wpa_s
, src_addr
, buf
, len
);
2262 #endif /* CONFIG_AP */
2264 if (wpa_s
->key_mgmt
== WPA_KEY_MGMT_NONE
) {
2265 wpa_dbg(wpa_s
, MSG_DEBUG
, "Ignored received EAPOL frame since "
2266 "no key management is configured");
2270 if (wpa_s
->eapol_received
== 0 &&
2271 (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
) ||
2272 !wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
) ||
2273 wpa_s
->wpa_state
!= WPA_COMPLETED
) &&
2274 (wpa_s
->current_ssid
== NULL
||
2275 wpa_s
->current_ssid
->mode
!= IEEE80211_MODE_IBSS
)) {
2276 /* Timeout for completing IEEE 802.1X and WPA authentication */
2277 wpa_supplicant_req_auth_timeout(
2279 (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) ||
2280 wpa_s
->key_mgmt
== WPA_KEY_MGMT_IEEE8021X_NO_WPA
||
2281 wpa_s
->key_mgmt
== WPA_KEY_MGMT_WPS
) ?
2284 wpa_s
->eapol_received
++;
2286 if (wpa_s
->countermeasures
) {
2287 wpa_msg(wpa_s
, MSG_INFO
, "WPA: Countermeasures - dropped "
2292 #ifdef CONFIG_IBSS_RSN
2293 if (wpa_s
->current_ssid
&&
2294 wpa_s
->current_ssid
->mode
== WPAS_MODE_IBSS
) {
2295 ibss_rsn_rx_eapol(wpa_s
->ibss_rsn
, src_addr
, buf
, len
);
2298 #endif /* CONFIG_IBSS_RSN */
2300 /* Source address of the incoming EAPOL frame could be compared to the
2301 * current BSSID. However, it is possible that a centralized
2302 * Authenticator could be using another MAC address than the BSSID of
2303 * an AP, so just allow any address to be used for now. The replies are
2304 * still sent to the current BSSID (if available), though. */
2306 os_memcpy(wpa_s
->last_eapol_src
, src_addr
, ETH_ALEN
);
2307 if (!wpa_key_mgmt_wpa_psk(wpa_s
->key_mgmt
) &&
2308 eapol_sm_rx_eapol(wpa_s
->eapol
, src_addr
, buf
, len
) > 0)
2310 wpa_drv_poll(wpa_s
);
2311 if (!(wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_4WAY_HANDSHAKE
))
2312 wpa_sm_rx_eapol(wpa_s
->wpa
, src_addr
, buf
, len
);
2313 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
)) {
2315 * Set portValid = TRUE here since we are going to skip 4-way
2316 * handshake processing which would normally set portValid. We
2317 * need this to allow the EAPOL state machines to be completed
2318 * without going through EAPOL-Key handshake.
2320 eapol_sm_notify_portValid(wpa_s
->eapol
, TRUE
);
2325 int wpa_supplicant_update_mac_addr(struct wpa_supplicant
*wpa_s
)
2327 if (wpa_s
->driver
->send_eapol
) {
2328 const u8
*addr
= wpa_drv_get_mac_addr(wpa_s
);
2330 os_memcpy(wpa_s
->own_addr
, addr
, ETH_ALEN
);
2331 } else if (!(wpa_s
->drv_flags
&
2332 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE
)) {
2333 l2_packet_deinit(wpa_s
->l2
);
2334 wpa_s
->l2
= l2_packet_init(wpa_s
->ifname
,
2335 wpa_drv_get_mac_addr(wpa_s
),
2337 wpa_supplicant_rx_eapol
, wpa_s
, 0);
2338 if (wpa_s
->l2
== NULL
)
2341 const u8
*addr
= wpa_drv_get_mac_addr(wpa_s
);
2343 os_memcpy(wpa_s
->own_addr
, addr
, ETH_ALEN
);
2346 if (wpa_s
->l2
&& l2_packet_get_own_addr(wpa_s
->l2
, wpa_s
->own_addr
)) {
2347 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to get own L2 address");
2351 wpa_dbg(wpa_s
, MSG_DEBUG
, "Own MAC address: " MACSTR
,
2352 MAC2STR(wpa_s
->own_addr
));
2353 wpa_sm_set_own_addr(wpa_s
->wpa
, wpa_s
->own_addr
);
2359 static void wpa_supplicant_rx_eapol_bridge(void *ctx
, const u8
*src_addr
,
2360 const u8
*buf
, size_t len
)
2362 struct wpa_supplicant
*wpa_s
= ctx
;
2363 const struct l2_ethhdr
*eth
;
2365 if (len
< sizeof(*eth
))
2367 eth
= (const struct l2_ethhdr
*) buf
;
2369 if (os_memcmp(eth
->h_dest
, wpa_s
->own_addr
, ETH_ALEN
) != 0 &&
2370 !(eth
->h_dest
[0] & 0x01)) {
2371 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
" to " MACSTR
2372 " (bridge - not for this interface - ignore)",
2373 MAC2STR(src_addr
), MAC2STR(eth
->h_dest
));
2377 wpa_dbg(wpa_s
, MSG_DEBUG
, "RX EAPOL from " MACSTR
" to " MACSTR
2378 " (bridge)", MAC2STR(src_addr
), MAC2STR(eth
->h_dest
));
2379 wpa_supplicant_rx_eapol(wpa_s
, src_addr
, buf
+ sizeof(*eth
),
2380 len
- sizeof(*eth
));
2385 * wpa_supplicant_driver_init - Initialize driver interface parameters
2386 * @wpa_s: Pointer to wpa_supplicant data
2387 * Returns: 0 on success, -1 on failure
2389 * This function is called to initialize driver interface parameters.
2390 * wpa_drv_init() must have been called before this function to initialize the
2393 int wpa_supplicant_driver_init(struct wpa_supplicant
*wpa_s
)
2395 static int interface_count
= 0;
2397 if (wpa_supplicant_update_mac_addr(wpa_s
) < 0)
2400 if (wpa_s
->bridge_ifname
[0]) {
2401 wpa_dbg(wpa_s
, MSG_DEBUG
, "Receiving packets from bridge "
2402 "interface '%s'", wpa_s
->bridge_ifname
);
2403 wpa_s
->l2_br
= l2_packet_init(wpa_s
->bridge_ifname
,
2406 wpa_supplicant_rx_eapol_bridge
,
2408 if (wpa_s
->l2_br
== NULL
) {
2409 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to open l2_packet "
2410 "connection for the bridge interface '%s'",
2411 wpa_s
->bridge_ifname
);
2416 wpa_clear_keys(wpa_s
, NULL
);
2418 /* Make sure that TKIP countermeasures are not left enabled (could
2419 * happen if wpa_supplicant is killed during countermeasures. */
2420 wpa_drv_set_countermeasures(wpa_s
, 0);
2422 wpa_dbg(wpa_s
, MSG_DEBUG
, "RSN: flushing PMKID list in the driver");
2423 wpa_drv_flush_pmkid(wpa_s
);
2425 wpa_s
->prev_scan_ssid
= WILDCARD_SSID_SCAN
;
2426 wpa_s
->prev_scan_wildcard
= 0;
2428 if (wpa_supplicant_enabled_networks(wpa_s
)) {
2429 if (wpa_supplicant_delayed_sched_scan(wpa_s
, interface_count
,
2431 wpa_supplicant_req_scan(wpa_s
, interface_count
,
2435 wpa_supplicant_set_state(wpa_s
, WPA_INACTIVE
);
2441 static int wpa_supplicant_daemon(const char *pid_file
)
2443 wpa_printf(MSG_DEBUG
, "Daemonize..");
2444 return os_daemonize(pid_file
);
2448 static struct wpa_supplicant
* wpa_supplicant_alloc(void)
2450 struct wpa_supplicant
*wpa_s
;
2452 wpa_s
= os_zalloc(sizeof(*wpa_s
));
2455 wpa_s
->scan_req
= INITIAL_SCAN_REQ
;
2456 wpa_s
->scan_interval
= 5;
2457 wpa_s
->new_connection
= 1;
2458 wpa_s
->parent
= wpa_s
;
2459 wpa_s
->sched_scanning
= 0;
2465 #ifdef CONFIG_HT_OVERRIDES
2467 static int wpa_set_htcap_mcs(struct wpa_supplicant
*wpa_s
,
2468 struct ieee80211_ht_capabilities
*htcaps
,
2469 struct ieee80211_ht_capabilities
*htcaps_mask
,
2472 /* parse ht_mcs into hex array */
2474 const char *tmp
= ht_mcs
;
2477 /* If ht_mcs is null, do not set anything */
2481 /* This is what we are setting in the kernel */
2482 os_memset(&htcaps
->supported_mcs_set
, 0, IEEE80211_HT_MCS_MASK_LEN
);
2484 wpa_msg(wpa_s
, MSG_DEBUG
, "set_htcap, ht_mcs -:%s:-", ht_mcs
);
2486 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++) {
2488 long v
= strtol(tmp
, &end
, 16);
2490 wpa_msg(wpa_s
, MSG_DEBUG
,
2491 "htcap value[%i]: %ld end: %p tmp: %p",
2496 htcaps
->supported_mcs_set
[i
] = v
;
2499 wpa_msg(wpa_s
, MSG_ERROR
,
2500 "Failed to parse ht-mcs: %s, error: %s\n",
2501 ht_mcs
, strerror(errno
));
2507 * If we were able to parse any values, then set mask for the MCS set.
2510 os_memset(&htcaps_mask
->supported_mcs_set
, 0xff,
2511 IEEE80211_HT_MCS_MASK_LEN
- 1);
2512 /* skip the 3 reserved bits */
2513 htcaps_mask
->supported_mcs_set
[IEEE80211_HT_MCS_MASK_LEN
- 1] =
2521 static int wpa_disable_max_amsdu(struct wpa_supplicant
*wpa_s
,
2522 struct ieee80211_ht_capabilities
*htcaps
,
2523 struct ieee80211_ht_capabilities
*htcaps_mask
,
2528 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_max_amsdu: %d", disabled
);
2533 msk
= host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE
);
2534 htcaps_mask
->ht_capabilities_info
|= msk
;
2536 htcaps
->ht_capabilities_info
&= msk
;
2538 htcaps
->ht_capabilities_info
|= msk
;
2544 static int wpa_set_ampdu_factor(struct wpa_supplicant
*wpa_s
,
2545 struct ieee80211_ht_capabilities
*htcaps
,
2546 struct ieee80211_ht_capabilities
*htcaps_mask
,
2549 wpa_msg(wpa_s
, MSG_DEBUG
, "set_ampdu_factor: %d", factor
);
2554 if (factor
< 0 || factor
> 3) {
2555 wpa_msg(wpa_s
, MSG_ERROR
, "ampdu_factor: %d out of range. "
2556 "Must be 0-3 or -1", factor
);
2560 htcaps_mask
->a_mpdu_params
|= 0x3; /* 2 bits for factor */
2561 htcaps
->a_mpdu_params
&= ~0x3;
2562 htcaps
->a_mpdu_params
|= factor
& 0x3;
2568 static int wpa_set_ampdu_density(struct wpa_supplicant
*wpa_s
,
2569 struct ieee80211_ht_capabilities
*htcaps
,
2570 struct ieee80211_ht_capabilities
*htcaps_mask
,
2573 wpa_msg(wpa_s
, MSG_DEBUG
, "set_ampdu_density: %d", density
);
2578 if (density
< 0 || density
> 7) {
2579 wpa_msg(wpa_s
, MSG_ERROR
,
2580 "ampdu_density: %d out of range. Must be 0-7 or -1.",
2585 htcaps_mask
->a_mpdu_params
|= 0x1C;
2586 htcaps
->a_mpdu_params
&= ~(0x1C);
2587 htcaps
->a_mpdu_params
|= (density
<< 2) & 0x1C;
2593 static int wpa_set_disable_ht40(struct wpa_supplicant
*wpa_s
,
2594 struct ieee80211_ht_capabilities
*htcaps
,
2595 struct ieee80211_ht_capabilities
*htcaps_mask
,
2598 /* Masking these out disables HT40 */
2599 u16 msk
= host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET
|
2600 HT_CAP_INFO_SHORT_GI40MHZ
);
2602 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_ht40: %d", disabled
);
2605 htcaps
->ht_capabilities_info
&= ~msk
;
2607 htcaps
->ht_capabilities_info
|= msk
;
2609 htcaps_mask
->ht_capabilities_info
|= msk
;
2615 static int wpa_set_disable_sgi(struct wpa_supplicant
*wpa_s
,
2616 struct ieee80211_ht_capabilities
*htcaps
,
2617 struct ieee80211_ht_capabilities
*htcaps_mask
,
2620 /* Masking these out disables SGI */
2621 u16 msk
= host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ
|
2622 HT_CAP_INFO_SHORT_GI40MHZ
);
2624 wpa_msg(wpa_s
, MSG_DEBUG
, "set_disable_sgi: %d", disabled
);
2627 htcaps
->ht_capabilities_info
&= ~msk
;
2629 htcaps
->ht_capabilities_info
|= msk
;
2631 htcaps_mask
->ht_capabilities_info
|= msk
;
2637 void wpa_supplicant_apply_ht_overrides(
2638 struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
,
2639 struct wpa_driver_associate_params
*params
)
2641 struct ieee80211_ht_capabilities
*htcaps
;
2642 struct ieee80211_ht_capabilities
*htcaps_mask
;
2647 params
->disable_ht
= ssid
->disable_ht
;
2648 if (!params
->htcaps
|| !params
->htcaps_mask
)
2651 htcaps
= (struct ieee80211_ht_capabilities
*) params
->htcaps
;
2652 htcaps_mask
= (struct ieee80211_ht_capabilities
*) params
->htcaps_mask
;
2653 wpa_set_htcap_mcs(wpa_s
, htcaps
, htcaps_mask
, ssid
->ht_mcs
);
2654 wpa_disable_max_amsdu(wpa_s
, htcaps
, htcaps_mask
,
2655 ssid
->disable_max_amsdu
);
2656 wpa_set_ampdu_factor(wpa_s
, htcaps
, htcaps_mask
, ssid
->ampdu_factor
);
2657 wpa_set_ampdu_density(wpa_s
, htcaps
, htcaps_mask
, ssid
->ampdu_density
);
2658 wpa_set_disable_ht40(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_ht40
);
2659 wpa_set_disable_sgi(wpa_s
, htcaps
, htcaps_mask
, ssid
->disable_sgi
);
2662 #endif /* CONFIG_HT_OVERRIDES */
2665 static int pcsc_reader_init(struct wpa_supplicant
*wpa_s
)
2670 if (!wpa_s
->conf
->pcsc_reader
)
2673 wpa_s
->scard
= scard_init(SCARD_TRY_BOTH
, wpa_s
->conf
->pcsc_reader
);
2677 if (wpa_s
->conf
->pcsc_pin
&&
2678 scard_set_pin(wpa_s
->scard
, wpa_s
->conf
->pcsc_pin
) < 0) {
2679 scard_deinit(wpa_s
->scard
);
2680 wpa_s
->scard
= NULL
;
2681 wpa_msg(wpa_s
, MSG_ERROR
, "PC/SC PIN validation failed");
2685 len
= sizeof(wpa_s
->imsi
) - 1;
2686 if (scard_get_imsi(wpa_s
->scard
, wpa_s
->imsi
, &len
)) {
2687 scard_deinit(wpa_s
->scard
);
2688 wpa_s
->scard
= NULL
;
2689 wpa_msg(wpa_s
, MSG_ERROR
, "Could not read IMSI");
2692 wpa_s
->imsi
[len
] = '\0';
2694 wpa_s
->mnc_len
= scard_get_mnc_len(wpa_s
->scard
);
2696 wpa_printf(MSG_DEBUG
, "SCARD: IMSI %s (MNC length %d)",
2697 wpa_s
->imsi
, wpa_s
->mnc_len
);
2699 wpa_sm_set_scard_ctx(wpa_s
->wpa
, wpa_s
->scard
);
2700 eapol_sm_register_scard_ctx(wpa_s
->eapol
, wpa_s
->scard
);
2701 #endif /* PCSC_FUNCS */
2707 int wpas_init_ext_pw(struct wpa_supplicant
*wpa_s
)
2711 ext_password_deinit(wpa_s
->ext_pw
);
2712 wpa_s
->ext_pw
= NULL
;
2713 eapol_sm_set_ext_pw_ctx(wpa_s
->eapol
, NULL
);
2715 if (!wpa_s
->conf
->ext_password_backend
)
2718 val
= os_strdup(wpa_s
->conf
->ext_password_backend
);
2721 pos
= os_strchr(val
, ':');
2725 wpa_printf(MSG_DEBUG
, "EXT PW: Initialize backend '%s'", val
);
2727 wpa_s
->ext_pw
= ext_password_init(val
, pos
);
2729 if (wpa_s
->ext_pw
== NULL
) {
2730 wpa_printf(MSG_DEBUG
, "EXT PW: Failed to initialize backend");
2733 eapol_sm_set_ext_pw_ctx(wpa_s
->eapol
, wpa_s
->ext_pw
);
2739 static int wpa_supplicant_init_iface(struct wpa_supplicant
*wpa_s
,
2740 struct wpa_interface
*iface
)
2742 const char *ifname
, *driver
;
2743 struct wpa_driver_capa capa
;
2745 wpa_printf(MSG_DEBUG
, "Initializing interface '%s' conf '%s' driver "
2746 "'%s' ctrl_interface '%s' bridge '%s'", iface
->ifname
,
2747 iface
->confname
? iface
->confname
: "N/A",
2748 iface
->driver
? iface
->driver
: "default",
2749 iface
->ctrl_interface
? iface
->ctrl_interface
: "N/A",
2750 iface
->bridge_ifname
? iface
->bridge_ifname
: "N/A");
2752 if (iface
->confname
) {
2753 #ifdef CONFIG_BACKEND_FILE
2754 wpa_s
->confname
= os_rel2abs_path(iface
->confname
);
2755 if (wpa_s
->confname
== NULL
) {
2756 wpa_printf(MSG_ERROR
, "Failed to get absolute path "
2757 "for configuration file '%s'.",
2761 wpa_printf(MSG_DEBUG
, "Configuration file '%s' -> '%s'",
2762 iface
->confname
, wpa_s
->confname
);
2763 #else /* CONFIG_BACKEND_FILE */
2764 wpa_s
->confname
= os_strdup(iface
->confname
);
2765 #endif /* CONFIG_BACKEND_FILE */
2766 wpa_s
->conf
= wpa_config_read(wpa_s
->confname
);
2767 if (wpa_s
->conf
== NULL
) {
2768 wpa_printf(MSG_ERROR
, "Failed to read or parse "
2769 "configuration '%s'.", wpa_s
->confname
);
2774 * Override ctrl_interface and driver_param if set on command
2777 if (iface
->ctrl_interface
) {
2778 os_free(wpa_s
->conf
->ctrl_interface
);
2779 wpa_s
->conf
->ctrl_interface
=
2780 os_strdup(iface
->ctrl_interface
);
2783 if (iface
->driver_param
) {
2784 os_free(wpa_s
->conf
->driver_param
);
2785 wpa_s
->conf
->driver_param
=
2786 os_strdup(iface
->driver_param
);
2789 wpa_s
->conf
= wpa_config_alloc_empty(iface
->ctrl_interface
,
2790 iface
->driver_param
);
2792 if (wpa_s
->conf
== NULL
) {
2793 wpa_printf(MSG_ERROR
, "\nNo configuration found.");
2797 if (iface
->ifname
== NULL
) {
2798 wpa_printf(MSG_ERROR
, "\nInterface name is required.");
2801 if (os_strlen(iface
->ifname
) >= sizeof(wpa_s
->ifname
)) {
2802 wpa_printf(MSG_ERROR
, "\nToo long interface name '%s'.",
2806 os_strlcpy(wpa_s
->ifname
, iface
->ifname
, sizeof(wpa_s
->ifname
));
2808 if (iface
->bridge_ifname
) {
2809 if (os_strlen(iface
->bridge_ifname
) >=
2810 sizeof(wpa_s
->bridge_ifname
)) {
2811 wpa_printf(MSG_ERROR
, "\nToo long bridge interface "
2812 "name '%s'.", iface
->bridge_ifname
);
2815 os_strlcpy(wpa_s
->bridge_ifname
, iface
->bridge_ifname
,
2816 sizeof(wpa_s
->bridge_ifname
));
2819 /* RSNA Supplicant Key Management - INITIALIZE */
2820 eapol_sm_notify_portEnabled(wpa_s
->eapol
, FALSE
);
2821 eapol_sm_notify_portValid(wpa_s
->eapol
, FALSE
);
2823 /* Initialize driver interface and register driver event handler before
2824 * L2 receive handler so that association events are processed before
2825 * EAPOL-Key packets if both become available for the same select()
2827 driver
= iface
->driver
;
2829 if (wpa_supplicant_set_driver(wpa_s
, driver
) < 0)
2832 wpa_s
->drv_priv
= wpa_drv_init(wpa_s
, wpa_s
->ifname
);
2833 if (wpa_s
->drv_priv
== NULL
) {
2835 pos
= driver
? os_strchr(driver
, ',') : NULL
;
2837 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to initialize "
2838 "driver interface - try next driver wrapper");
2842 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to initialize driver "
2846 if (wpa_drv_set_param(wpa_s
, wpa_s
->conf
->driver_param
) < 0) {
2847 wpa_msg(wpa_s
, MSG_ERROR
, "Driver interface rejected "
2848 "driver_param '%s'", wpa_s
->conf
->driver_param
);
2852 ifname
= wpa_drv_get_ifname(wpa_s
);
2853 if (ifname
&& os_strcmp(ifname
, wpa_s
->ifname
) != 0) {
2854 wpa_dbg(wpa_s
, MSG_DEBUG
, "Driver interface replaced "
2855 "interface name with '%s'", ifname
);
2856 os_strlcpy(wpa_s
->ifname
, ifname
, sizeof(wpa_s
->ifname
));
2859 if (wpa_supplicant_init_wpa(wpa_s
) < 0)
2862 wpa_sm_set_ifname(wpa_s
->wpa
, wpa_s
->ifname
,
2863 wpa_s
->bridge_ifname
[0] ? wpa_s
->bridge_ifname
:
2865 wpa_sm_set_fast_reauth(wpa_s
->wpa
, wpa_s
->conf
->fast_reauth
);
2867 if (wpa_s
->conf
->dot11RSNAConfigPMKLifetime
&&
2868 wpa_sm_set_param(wpa_s
->wpa
, RSNA_PMK_LIFETIME
,
2869 wpa_s
->conf
->dot11RSNAConfigPMKLifetime
)) {
2870 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
2871 "dot11RSNAConfigPMKLifetime");
2875 if (wpa_s
->conf
->dot11RSNAConfigPMKReauthThreshold
&&
2876 wpa_sm_set_param(wpa_s
->wpa
, RSNA_PMK_REAUTH_THRESHOLD
,
2877 wpa_s
->conf
->dot11RSNAConfigPMKReauthThreshold
)) {
2878 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
2879 "dot11RSNAConfigPMKReauthThreshold");
2883 if (wpa_s
->conf
->dot11RSNAConfigSATimeout
&&
2884 wpa_sm_set_param(wpa_s
->wpa
, RSNA_SA_TIMEOUT
,
2885 wpa_s
->conf
->dot11RSNAConfigSATimeout
)) {
2886 wpa_msg(wpa_s
, MSG_ERROR
, "Invalid WPA parameter value for "
2887 "dot11RSNAConfigSATimeout");
2891 wpa_s
->hw
.modes
= wpa_drv_get_hw_feature_data(wpa_s
,
2892 &wpa_s
->hw
.num_modes
,
2895 if (wpa_drv_get_capa(wpa_s
, &capa
) == 0) {
2896 wpa_s
->drv_capa_known
= 1;
2897 wpa_s
->drv_flags
= capa
.flags
;
2898 wpa_s
->drv_enc
= capa
.enc
;
2899 wpa_s
->probe_resp_offloads
= capa
.probe_resp_offloads
;
2900 wpa_s
->max_scan_ssids
= capa
.max_scan_ssids
;
2901 wpa_s
->max_sched_scan_ssids
= capa
.max_sched_scan_ssids
;
2902 wpa_s
->sched_scan_supported
= capa
.sched_scan_supported
;
2903 wpa_s
->max_match_sets
= capa
.max_match_sets
;
2904 wpa_s
->max_remain_on_chan
= capa
.max_remain_on_chan
;
2905 wpa_s
->max_stations
= capa
.max_stations
;
2907 if (wpa_s
->max_remain_on_chan
== 0)
2908 wpa_s
->max_remain_on_chan
= 1000;
2910 if (wpa_supplicant_driver_init(wpa_s
) < 0)
2914 if (wpa_tdls_init(wpa_s
->wpa
))
2916 #endif /* CONFIG_TDLS */
2918 if (wpa_s
->conf
->country
[0] && wpa_s
->conf
->country
[1] &&
2919 wpa_drv_set_country(wpa_s
, wpa_s
->conf
->country
)) {
2920 wpa_dbg(wpa_s
, MSG_DEBUG
, "Failed to set country");
2924 if (wpas_wps_init(wpa_s
))
2927 if (wpa_supplicant_init_eapol(wpa_s
) < 0)
2929 wpa_sm_set_eapol(wpa_s
->wpa
, wpa_s
->eapol
);
2931 wpa_s
->ctrl_iface
= wpa_supplicant_ctrl_iface_init(wpa_s
);
2932 if (wpa_s
->ctrl_iface
== NULL
) {
2933 wpa_printf(MSG_ERROR
,
2934 "Failed to initialize control interface '%s'.\n"
2935 "You may have another wpa_supplicant process "
2936 "already running or the file was\n"
2937 "left by an unclean termination of wpa_supplicant "
2938 "in which case you will need\n"
2939 "to manually remove this file before starting "
2940 "wpa_supplicant again.\n",
2941 wpa_s
->conf
->ctrl_interface
);
2945 wpa_s
->gas
= gas_query_init(wpa_s
);
2946 if (wpa_s
->gas
== NULL
) {
2947 wpa_printf(MSG_ERROR
, "Failed to initialize GAS query");
2952 if (wpas_p2p_init(wpa_s
->global
, wpa_s
) < 0) {
2953 wpa_msg(wpa_s
, MSG_ERROR
, "Failed to init P2P");
2956 #endif /* CONFIG_P2P */
2958 if (wpa_bss_init(wpa_s
) < 0)
2961 if (pcsc_reader_init(wpa_s
) < 0)
2964 if (wpas_init_ext_pw(wpa_s
) < 0)
2971 static void wpa_supplicant_deinit_iface(struct wpa_supplicant
*wpa_s
,
2972 int notify
, int terminate
)
2974 if (wpa_s
->drv_priv
) {
2975 wpa_supplicant_deauthenticate(wpa_s
,
2976 WLAN_REASON_DEAUTH_LEAVING
);
2978 wpa_drv_set_countermeasures(wpa_s
, 0);
2979 wpa_clear_keys(wpa_s
, NULL
);
2982 wpa_supplicant_cleanup(wpa_s
);
2985 if (wpa_s
== wpa_s
->global
->p2p_init_wpa_s
&& wpa_s
->global
->p2p
) {
2986 wpa_dbg(wpa_s
, MSG_DEBUG
, "P2P: Disable P2P since removing "
2987 "the management interface is being removed");
2988 wpas_p2p_deinit_global(wpa_s
->global
);
2990 #endif /* CONFIG_P2P */
2992 if (wpa_s
->drv_priv
)
2993 wpa_drv_deinit(wpa_s
);
2996 wpas_notify_iface_removed(wpa_s
);
2999 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_TERMINATING
);
3001 if (wpa_s
->ctrl_iface
) {
3002 wpa_supplicant_ctrl_iface_deinit(wpa_s
->ctrl_iface
);
3003 wpa_s
->ctrl_iface
= NULL
;
3006 if (wpa_s
->conf
!= NULL
) {
3007 wpa_config_free(wpa_s
->conf
);
3014 * wpa_supplicant_add_iface - Add a new network interface
3015 * @global: Pointer to global data from wpa_supplicant_init()
3016 * @iface: Interface configuration options
3017 * Returns: Pointer to the created interface or %NULL on failure
3019 * This function is used to add new network interfaces for %wpa_supplicant.
3020 * This can be called before wpa_supplicant_run() to add interfaces before the
3021 * main event loop has been started. In addition, new interfaces can be added
3022 * dynamically while %wpa_supplicant is already running. This could happen,
3023 * e.g., when a hotplug network adapter is inserted.
3025 struct wpa_supplicant
* wpa_supplicant_add_iface(struct wpa_global
*global
,
3026 struct wpa_interface
*iface
)
3028 struct wpa_supplicant
*wpa_s
;
3029 struct wpa_interface t_iface
;
3030 struct wpa_ssid
*ssid
;
3032 if (global
== NULL
|| iface
== NULL
)
3035 wpa_s
= wpa_supplicant_alloc();
3039 wpa_s
->global
= global
;
3042 if (global
->params
.override_driver
) {
3043 wpa_printf(MSG_DEBUG
, "Override interface parameter: driver "
3045 iface
->driver
, global
->params
.override_driver
);
3046 t_iface
.driver
= global
->params
.override_driver
;
3048 if (global
->params
.override_ctrl_interface
) {
3049 wpa_printf(MSG_DEBUG
, "Override interface parameter: "
3050 "ctrl_interface ('%s' -> '%s')",
3051 iface
->ctrl_interface
,
3052 global
->params
.override_ctrl_interface
);
3053 t_iface
.ctrl_interface
=
3054 global
->params
.override_ctrl_interface
;
3056 if (wpa_supplicant_init_iface(wpa_s
, &t_iface
)) {
3057 wpa_printf(MSG_DEBUG
, "Failed to add interface %s",
3059 wpa_supplicant_deinit_iface(wpa_s
, 0, 0);
3064 /* Notify the control interfaces about new iface */
3065 if (wpas_notify_iface_added(wpa_s
)) {
3066 wpa_supplicant_deinit_iface(wpa_s
, 1, 0);
3071 for (ssid
= wpa_s
->conf
->ssid
; ssid
; ssid
= ssid
->next
)
3072 wpas_notify_network_added(wpa_s
, ssid
);
3074 wpa_s
->next
= global
->ifaces
;
3075 global
->ifaces
= wpa_s
;
3077 wpa_dbg(wpa_s
, MSG_DEBUG
, "Added interface %s", wpa_s
->ifname
);
3078 wpa_supplicant_set_state(wpa_s
, WPA_DISCONNECTED
);
3085 * wpa_supplicant_remove_iface - Remove a network interface
3086 * @global: Pointer to global data from wpa_supplicant_init()
3087 * @wpa_s: Pointer to the network interface to be removed
3088 * Returns: 0 if interface was removed, -1 if interface was not found
3090 * This function can be used to dynamically remove network interfaces from
3091 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In
3092 * addition, this function is used to remove all remaining interfaces when
3093 * %wpa_supplicant is terminated.
3095 int wpa_supplicant_remove_iface(struct wpa_global
*global
,
3096 struct wpa_supplicant
*wpa_s
,
3099 struct wpa_supplicant
*prev
;
3101 /* Remove interface from the global list of interfaces */
3102 prev
= global
->ifaces
;
3103 if (prev
== wpa_s
) {
3104 global
->ifaces
= wpa_s
->next
;
3106 while (prev
&& prev
->next
!= wpa_s
)
3110 prev
->next
= wpa_s
->next
;
3113 wpa_dbg(wpa_s
, MSG_DEBUG
, "Removing interface %s", wpa_s
->ifname
);
3115 if (global
->p2p_group_formation
== wpa_s
)
3116 global
->p2p_group_formation
= NULL
;
3117 wpa_supplicant_deinit_iface(wpa_s
, 1, terminate
);
3125 * wpa_supplicant_get_eap_mode - Get the current EAP mode
3126 * @wpa_s: Pointer to the network interface
3127 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found
3129 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant
*wpa_s
)
3131 const char *eapol_method
;
3133 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s
->key_mgmt
) == 0 &&
3134 wpa_s
->key_mgmt
!= WPA_KEY_MGMT_IEEE8021X_NO_WPA
) {
3138 eapol_method
= eapol_sm_get_method_name(wpa_s
->eapol
);
3139 if (eapol_method
== NULL
)
3140 return "UNKNOWN-EAP";
3142 return eapol_method
;
3147 * wpa_supplicant_get_iface - Get a new network interface
3148 * @global: Pointer to global data from wpa_supplicant_init()
3149 * @ifname: Interface name
3150 * Returns: Pointer to the interface or %NULL if not found
3152 struct wpa_supplicant
* wpa_supplicant_get_iface(struct wpa_global
*global
,
3155 struct wpa_supplicant
*wpa_s
;
3157 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
) {
3158 if (os_strcmp(wpa_s
->ifname
, ifname
) == 0)
3165 #ifndef CONFIG_NO_WPA_MSG
3166 static const char * wpa_supplicant_msg_ifname_cb(void *ctx
)
3168 struct wpa_supplicant
*wpa_s
= ctx
;
3171 return wpa_s
->ifname
;
3173 #endif /* CONFIG_NO_WPA_MSG */
3177 * wpa_supplicant_init - Initialize %wpa_supplicant
3178 * @params: Parameters for %wpa_supplicant
3179 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure
3181 * This function is used to initialize %wpa_supplicant. After successful
3182 * initialization, the returned data pointer can be used to add and remove
3183 * network interfaces, and eventually, to deinitialize %wpa_supplicant.
3185 struct wpa_global
* wpa_supplicant_init(struct wpa_params
*params
)
3187 struct wpa_global
*global
;
3193 #ifdef CONFIG_DRIVER_NDIS
3195 void driver_ndis_init_ops(void);
3196 driver_ndis_init_ops();
3198 #endif /* CONFIG_DRIVER_NDIS */
3200 #ifndef CONFIG_NO_WPA_MSG
3201 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb
);
3202 #endif /* CONFIG_NO_WPA_MSG */
3204 wpa_debug_open_file(params
->wpa_debug_file_path
);
3205 if (params
->wpa_debug_syslog
)
3206 wpa_debug_open_syslog();
3207 if (params
->wpa_debug_tracing
) {
3208 ret
= wpa_debug_open_linux_tracing();
3210 wpa_printf(MSG_ERROR
,
3211 "Failed to enable trace logging");
3216 ret
= eap_register_methods();
3218 wpa_printf(MSG_ERROR
, "Failed to register EAP methods");
3220 wpa_printf(MSG_ERROR
, "Two or more EAP methods used "
3221 "the same EAP type.");
3225 global
= os_zalloc(sizeof(*global
));
3228 dl_list_init(&global
->p2p_srv_bonjour
);
3229 dl_list_init(&global
->p2p_srv_upnp
);
3230 global
->params
.daemonize
= params
->daemonize
;
3231 global
->params
.wait_for_monitor
= params
->wait_for_monitor
;
3232 global
->params
.dbus_ctrl_interface
= params
->dbus_ctrl_interface
;
3233 if (params
->pid_file
)
3234 global
->params
.pid_file
= os_strdup(params
->pid_file
);
3235 if (params
->ctrl_interface
)
3236 global
->params
.ctrl_interface
=
3237 os_strdup(params
->ctrl_interface
);
3238 if (params
->override_driver
)
3239 global
->params
.override_driver
=
3240 os_strdup(params
->override_driver
);
3241 if (params
->override_ctrl_interface
)
3242 global
->params
.override_ctrl_interface
=
3243 os_strdup(params
->override_ctrl_interface
);
3244 wpa_debug_level
= global
->params
.wpa_debug_level
=
3245 params
->wpa_debug_level
;
3246 wpa_debug_show_keys
= global
->params
.wpa_debug_show_keys
=
3247 params
->wpa_debug_show_keys
;
3248 wpa_debug_timestamp
= global
->params
.wpa_debug_timestamp
=
3249 params
->wpa_debug_timestamp
;
3251 wpa_printf(MSG_DEBUG
, "wpa_supplicant v" VERSION_STR
);
3254 wpa_printf(MSG_ERROR
, "Failed to initialize event loop");
3255 wpa_supplicant_deinit(global
);
3259 random_init(params
->entropy_file
);
3261 global
->ctrl_iface
= wpa_supplicant_global_ctrl_iface_init(global
);
3262 if (global
->ctrl_iface
== NULL
) {
3263 wpa_supplicant_deinit(global
);
3267 if (wpas_notify_supplicant_initialized(global
)) {
3268 wpa_supplicant_deinit(global
);
3272 for (i
= 0; wpa_drivers
[i
]; i
++)
3273 global
->drv_count
++;
3274 if (global
->drv_count
== 0) {
3275 wpa_printf(MSG_ERROR
, "No drivers enabled");
3276 wpa_supplicant_deinit(global
);
3279 global
->drv_priv
= os_zalloc(global
->drv_count
* sizeof(void *));
3280 if (global
->drv_priv
== NULL
) {
3281 wpa_supplicant_deinit(global
);
3285 #ifdef CONFIG_WIFI_DISPLAY
3286 if (wifi_display_init(global
) < 0) {
3287 wpa_printf(MSG_ERROR
, "Failed to initialize Wi-Fi Display");
3288 wpa_supplicant_deinit(global
);
3291 #endif /* CONFIG_WIFI_DISPLAY */
3298 * wpa_supplicant_run - Run the %wpa_supplicant main event loop
3299 * @global: Pointer to global data from wpa_supplicant_init()
3300 * Returns: 0 after successful event loop run, -1 on failure
3302 * This function starts the main event loop and continues running as long as
3303 * there are any remaining events. In most cases, this function is running as
3304 * long as the %wpa_supplicant process in still in use.
3306 int wpa_supplicant_run(struct wpa_global
*global
)
3308 struct wpa_supplicant
*wpa_s
;
3310 if (global
->params
.daemonize
&&
3311 wpa_supplicant_daemon(global
->params
.pid_file
))
3314 if (global
->params
.wait_for_monitor
) {
3315 for (wpa_s
= global
->ifaces
; wpa_s
; wpa_s
= wpa_s
->next
)
3316 if (wpa_s
->ctrl_iface
)
3317 wpa_supplicant_ctrl_iface_wait(
3321 eloop_register_signal_terminate(wpa_supplicant_terminate
, global
);
3322 eloop_register_signal_reconfig(wpa_supplicant_reconfig
, global
);
3331 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant
3332 * @global: Pointer to global data from wpa_supplicant_init()
3334 * This function is called to deinitialize %wpa_supplicant and to free all
3335 * allocated resources. Remaining network interfaces will also be removed.
3337 void wpa_supplicant_deinit(struct wpa_global
*global
)
3344 #ifdef CONFIG_WIFI_DISPLAY
3345 wifi_display_deinit(global
);
3346 #endif /* CONFIG_WIFI_DISPLAY */
3348 wpas_p2p_deinit_global(global
);
3349 #endif /* CONFIG_P2P */
3351 while (global
->ifaces
)
3352 wpa_supplicant_remove_iface(global
, global
->ifaces
, 1);
3354 if (global
->ctrl_iface
)
3355 wpa_supplicant_global_ctrl_iface_deinit(global
->ctrl_iface
);
3357 wpas_notify_supplicant_deinitialized(global
);
3359 eap_peer_unregister_methods();
3361 eap_server_unregister_methods();
3362 #endif /* CONFIG_AP */
3364 for (i
= 0; wpa_drivers
[i
] && global
->drv_priv
; i
++) {
3365 if (!global
->drv_priv
[i
])
3367 wpa_drivers
[i
]->global_deinit(global
->drv_priv
[i
]);
3369 os_free(global
->drv_priv
);
3375 if (global
->params
.pid_file
) {
3376 os_daemonize_terminate(global
->params
.pid_file
);
3377 os_free(global
->params
.pid_file
);
3379 os_free(global
->params
.ctrl_interface
);
3380 os_free(global
->params
.override_driver
);
3381 os_free(global
->params
.override_ctrl_interface
);
3383 os_free(global
->p2p_disallow_freq
);
3386 wpa_debug_close_syslog();
3387 wpa_debug_close_file();
3388 wpa_debug_close_linux_tracing();
3392 void wpa_supplicant_update_config(struct wpa_supplicant
*wpa_s
)
3394 if ((wpa_s
->conf
->changed_parameters
& CFG_CHANGED_COUNTRY
) &&
3395 wpa_s
->conf
->country
[0] && wpa_s
->conf
->country
[1]) {
3397 country
[0] = wpa_s
->conf
->country
[0];
3398 country
[1] = wpa_s
->conf
->country
[1];
3400 if (wpa_drv_set_country(wpa_s
, country
) < 0) {
3401 wpa_printf(MSG_ERROR
, "Failed to set country code "
3406 if (wpa_s
->conf
->changed_parameters
& CFG_CHANGED_EXT_PW_BACKEND
)
3407 wpas_init_ext_pw(wpa_s
);
3410 wpas_wps_update_config(wpa_s
);
3411 #endif /* CONFIG_WPS */
3414 wpas_p2p_update_config(wpa_s
);
3415 #endif /* CONFIG_P2P */
3417 wpa_s
->conf
->changed_parameters
= 0;
3421 static void add_freq(int *freqs
, int *num_freqs
, int freq
)
3425 for (i
= 0; i
< *num_freqs
; i
++) {
3426 if (freqs
[i
] == freq
)
3430 freqs
[*num_freqs
] = freq
;
3435 static int * get_bss_freqs_in_ess(struct wpa_supplicant
*wpa_s
)
3437 struct wpa_bss
*bss
, *cbss
;
3438 const int max_freqs
= 10;
3442 freqs
= os_zalloc(sizeof(int) * (max_freqs
+ 1));
3446 cbss
= wpa_s
->current_bss
;
3448 dl_list_for_each(bss
, &wpa_s
->bss
, struct wpa_bss
, list
) {
3451 if (bss
->ssid_len
== cbss
->ssid_len
&&
3452 os_memcmp(bss
->ssid
, cbss
->ssid
, bss
->ssid_len
) == 0 &&
3453 wpa_blacklist_get(wpa_s
, bss
->bssid
) == NULL
) {
3454 add_freq(freqs
, &num_freqs
, bss
->freq
);
3455 if (num_freqs
== max_freqs
)
3460 if (num_freqs
== 0) {
3469 void wpas_connection_failed(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
3476 * Remove possible authentication timeout since the connection failed.
3478 eloop_cancel_timeout(wpa_supplicant_timeout
, wpa_s
, NULL
);
3481 * Add the failed BSSID into the blacklist and speed up next scan
3482 * attempt if there could be other APs that could accept association.
3483 * The current blacklist count indicates how many times we have tried
3484 * connecting to this AP and multiple attempts mean that other APs are
3485 * either not available or has already been tried, so that we can start
3486 * increasing the delay here to avoid constant scanning.
3488 count
= wpa_blacklist_add(wpa_s
, bssid
);
3489 if (count
== 1 && wpa_s
->current_bss
) {
3491 * This BSS was not in the blacklist before. If there is
3492 * another BSS available for the same ESS, we should try that
3493 * next. Otherwise, we may as well try this one once more
3494 * before allowing other, likely worse, ESSes to be considered.
3496 freqs
= get_bss_freqs_in_ess(wpa_s
);
3498 wpa_dbg(wpa_s
, MSG_DEBUG
, "Another BSS in this ESS "
3499 "has been seen; try it next");
3500 wpa_blacklist_add(wpa_s
, bssid
);
3502 * On the next scan, go through only the known channels
3503 * used in this ESS based on previous scans to speed up
3504 * common load balancing use case.
3506 os_free(wpa_s
->next_scan_freqs
);
3507 wpa_s
->next_scan_freqs
= freqs
;
3512 * Add previous failure count in case the temporary blacklist was
3513 * cleared due to no other BSSes being available.
3515 count
+= wpa_s
->extra_blacklist_count
;
3535 wpa_dbg(wpa_s
, MSG_DEBUG
, "Blacklist count %d --> request scan in %d "
3536 "ms", count
, timeout
);
3539 * TODO: if more than one possible AP is available in scan results,
3540 * could try the other ones before requesting a new scan.
3542 wpa_supplicant_req_scan(wpa_s
, timeout
/ 1000,
3543 1000 * (timeout
% 1000));
3546 if (wpa_s
->global
->p2p_cb_on_scan_complete
&& !wpa_s
->global
->p2p_disabled
&&
3547 wpa_s
->global
->p2p
!= NULL
) {
3548 wpa_s
->global
->p2p_cb_on_scan_complete
= 0;
3549 if (p2p_other_scan_completed(wpa_s
->global
->p2p
) == 1) {
3550 wpa_dbg(wpa_s
, MSG_DEBUG
, "P2P: Pending P2P operation "
3551 "continued after failed association");
3554 #endif /* CONFIG_P2P */
3558 int wpas_driver_bss_selection(struct wpa_supplicant
*wpa_s
)
3560 return wpa_s
->conf
->ap_scan
== 2 ||
3561 (wpa_s
->drv_flags
& WPA_DRIVER_FLAGS_BSS_SELECTION
);
3565 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW)
3566 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant
*wpa_s
,
3567 struct wpa_ssid
*ssid
,
3571 #ifdef IEEE8021X_EAPOL
3572 struct eap_peer_config
*eap
= &ssid
->eap
;
3574 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: response handle field=%s", field
);
3575 wpa_hexdump_ascii_key(MSG_DEBUG
, "CTRL_IFACE: response value",
3576 (const u8
*) value
, os_strlen(value
));
3578 switch (wpa_supplicant_ctrl_req_from_string(field
)) {
3579 case WPA_CTRL_REQ_EAP_IDENTITY
:
3580 os_free(eap
->identity
);
3581 eap
->identity
= (u8
*) os_strdup(value
);
3582 eap
->identity_len
= os_strlen(value
);
3583 eap
->pending_req_identity
= 0;
3584 if (ssid
== wpa_s
->current_ssid
)
3585 wpa_s
->reassociate
= 1;
3587 case WPA_CTRL_REQ_EAP_PASSWORD
:
3588 os_free(eap
->password
);
3589 eap
->password
= (u8
*) os_strdup(value
);
3590 eap
->password_len
= os_strlen(value
);
3591 eap
->pending_req_password
= 0;
3592 if (ssid
== wpa_s
->current_ssid
)
3593 wpa_s
->reassociate
= 1;
3595 case WPA_CTRL_REQ_EAP_NEW_PASSWORD
:
3596 os_free(eap
->new_password
);
3597 eap
->new_password
= (u8
*) os_strdup(value
);
3598 eap
->new_password_len
= os_strlen(value
);
3599 eap
->pending_req_new_password
= 0;
3600 if (ssid
== wpa_s
->current_ssid
)
3601 wpa_s
->reassociate
= 1;
3603 case WPA_CTRL_REQ_EAP_PIN
:
3605 eap
->pin
= os_strdup(value
);
3606 eap
->pending_req_pin
= 0;
3607 if (ssid
== wpa_s
->current_ssid
)
3608 wpa_s
->reassociate
= 1;
3610 case WPA_CTRL_REQ_EAP_OTP
:
3612 eap
->otp
= (u8
*) os_strdup(value
);
3613 eap
->otp_len
= os_strlen(value
);
3614 os_free(eap
->pending_req_otp
);
3615 eap
->pending_req_otp
= NULL
;
3616 eap
->pending_req_otp_len
= 0;
3618 case WPA_CTRL_REQ_EAP_PASSPHRASE
:
3619 os_free(eap
->private_key_passwd
);
3620 eap
->private_key_passwd
= (u8
*) os_strdup(value
);
3621 eap
->pending_req_passphrase
= 0;
3622 if (ssid
== wpa_s
->current_ssid
)
3623 wpa_s
->reassociate
= 1;
3626 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: Unknown field '%s'", field
);
3631 #else /* IEEE8021X_EAPOL */
3632 wpa_printf(MSG_DEBUG
, "CTRL_IFACE: IEEE 802.1X not included");
3634 #endif /* IEEE8021X_EAPOL */
3636 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */
3639 int wpas_network_disabled(struct wpa_supplicant
*wpa_s
, struct wpa_ssid
*ssid
)
3642 unsigned int drv_enc
;
3650 if (wpa_s
&& wpa_s
->drv_capa_known
)
3651 drv_enc
= wpa_s
->drv_enc
;
3653 drv_enc
= (unsigned int) -1;
3655 for (i
= 0; i
< NUM_WEP_KEYS
; i
++) {
3656 size_t len
= ssid
->wep_key_len
[i
];
3659 if (len
== 5 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP40
))
3661 if (len
== 13 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP104
))
3663 if (len
== 16 && (drv_enc
& WPA_DRIVER_CAPA_ENC_WEP128
))
3665 return 1; /* invalid WEP key */
3668 if (wpa_key_mgmt_wpa_psk(ssid
->key_mgmt
) && !ssid
->psk_set
&&
3676 int wpas_is_p2p_prioritized(struct wpa_supplicant
*wpa_s
)
3678 if (wpa_s
->global
->conc_pref
== WPA_CONC_PREF_P2P
)
3680 if (wpa_s
->global
->conc_pref
== WPA_CONC_PREF_STA
)
3686 void wpas_auth_failed(struct wpa_supplicant
*wpa_s
)
3688 struct wpa_ssid
*ssid
= wpa_s
->current_ssid
;
3693 wpa_printf(MSG_DEBUG
, "Authentication failure but no known "
3698 if (ssid
->key_mgmt
== WPA_KEY_MGMT_WPS
)
3701 ssid
->auth_failures
++;
3702 if (ssid
->auth_failures
> 50)
3704 else if (ssid
->auth_failures
> 20)
3706 else if (ssid
->auth_failures
> 10)
3708 else if (ssid
->auth_failures
> 5)
3710 else if (ssid
->auth_failures
> 1)
3716 if (now
.sec
+ dur
<= ssid
->disabled_until
.sec
)
3719 ssid
->disabled_until
.sec
= now
.sec
+ dur
;
3721 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_TEMP_DISABLED
3722 "id=%d ssid=\"%s\" auth_failures=%u duration=%d",
3723 ssid
->id
, wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
),
3724 ssid
->auth_failures
, dur
);
3728 void wpas_clear_temp_disabled(struct wpa_supplicant
*wpa_s
,
3729 struct wpa_ssid
*ssid
, int clear_failures
)
3734 if (ssid
->disabled_until
.sec
) {
3735 wpa_msg(wpa_s
, MSG_INFO
, WPA_EVENT_REENABLED
3736 "id=%d ssid=\"%s\"",
3737 ssid
->id
, wpa_ssid_txt(ssid
->ssid
, ssid
->ssid_len
));
3739 ssid
->disabled_until
.sec
= 0;
3740 ssid
->disabled_until
.usec
= 0;
3742 ssid
->auth_failures
= 0;
3746 int disallowed_bssid(struct wpa_supplicant
*wpa_s
, const u8
*bssid
)
3750 if (wpa_s
->disallow_aps_bssid
== NULL
)
3753 for (i
= 0; i
< wpa_s
->disallow_aps_bssid_count
; i
++) {
3754 if (os_memcmp(wpa_s
->disallow_aps_bssid
+ i
* ETH_ALEN
,
3755 bssid
, ETH_ALEN
) == 0)
3763 int disallowed_ssid(struct wpa_supplicant
*wpa_s
, const u8
*ssid
,
3768 if (wpa_s
->disallow_aps_ssid
== NULL
|| ssid
== NULL
)
3771 for (i
= 0; i
< wpa_s
->disallow_aps_ssid_count
; i
++) {
3772 struct wpa_ssid_value
*s
= &wpa_s
->disallow_aps_ssid
[i
];
3773 if (ssid_len
== s
->ssid_len
&&
3774 os_memcmp(ssid
, s
->ssid
, ssid_len
) == 0)
3783 * wpas_request_connection - Request a new connection
3784 * @wpa_s: Pointer to the network interface
3786 * This function is used to request a new connection to be found. It will mark
3787 * the interface to allow reassociation and request a new scan to find a
3788 * suitable network to connect to.
3790 void wpas_request_connection(struct wpa_supplicant
*wpa_s
)
3792 wpa_s
->normal_scans
= 0;
3793 wpa_supplicant_reinit_autoscan(wpa_s
);
3794 wpa_s
->extra_blacklist_count
= 0;
3795 wpa_s
->disconnected
= 0;
3796 wpa_s
->reassociate
= 1;
3797 wpa_supplicant_req_scan(wpa_s
, 0, 0);