Lines Matching refs:wpa_s
130 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s);
133 static void wpas_update_owe_connect_params(struct wpa_supplicant *wpa_s);
139 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
148 wpa_drv_set_key(wpa_s, -1, WPA_ALG_WEP, NULL,
161 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
174 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
180 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
185 switch (wpa_s->group_cipher) {
204 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
205 "WPA-None", wpa_s->group_cipher);
212 ret = wpa_drv_set_key(wpa_s, -1, alg, NULL, 0, 1, seq, 6, key, keylen,
221 struct wpa_supplicant *wpa_s = eloop_ctx;
222 const u8 *bssid = wpa_s->bssid;
223 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
224 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
225 wpa_s->wpa_state == WPA_ASSOCIATING))
226 bssid = wpa_s->pending_bssid;
227 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
229 wpa_bssid_ignore_add(wpa_s, bssid);
230 wpa_sm_notify_disassoc(wpa_s->wpa);
231 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
232 wpa_s->reassociate = 1;
238 wpa_supplicant_req_scan(wpa_s, 1, 0);
244 * @wpa_s: Pointer to wpa_supplicant data
251 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
254 if (wpa_s->conf->ap_scan == 0 &&
255 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
258 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
260 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
261 wpa_s->last_auth_timeout_sec = sec;
262 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
268 * @wpa_s: Pointer to wpa_supplicant data
271 void wpas_auth_timeout_restart(struct wpa_supplicant *wpa_s, int sec_diff)
273 int new_sec = wpa_s->last_auth_timeout_sec + sec_diff;
275 if (eloop_is_timeout_registered(wpa_supplicant_timeout, wpa_s, NULL)) {
276 wpa_dbg(wpa_s, MSG_DEBUG,
278 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
280 wpa_s, NULL);
287 * @wpa_s: Pointer to wpa_supplicant data
293 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
295 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
296 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
297 wpa_bssid_ignore_del(wpa_s, wpa_s->bssid);
298 os_free(wpa_s->last_con_fail_realm);
299 wpa_s->last_con_fail_realm = NULL;
300 wpa_s->last_con_fail_realm_len = 0;
306 * @wpa_s: Pointer to wpa_supplicant data
311 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
315 struct wpa_ssid *ssid = wpa_s->current_ssid;
319 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
320 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
325 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
326 eapol_sm_notify_eap_success(wpa_s->eapol, true);
327 eapol_sm_notify_eap_fail(wpa_s->eapol, false);
332 eapol_sm_notify_eap_success(wpa_s->eapol, false);
333 eapol_sm_notify_eap_fail(wpa_s->eapol, false);
335 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
336 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
337 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
339 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
342 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
353 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
356 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
359 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
360 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
361 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
362 eapol_conf.external_sim = wpa_s->conf->external_sim;
365 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
367 if (wpa_s->current_bss) {
369 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
381 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
384 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE && ssid->mka_psk_set)
385 ieee802_1x_create_preshared_mka(wpa_s, ssid);
387 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
395 * @wpa_s: Pointer to wpa_supplicant data
402 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
411 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
413 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
415 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
416 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
417 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
418 wpa_sm_set_ap_rsnxe(wpa_s->wpa, NULL, 0);
419 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
420 wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0);
421 wpa_s->rsnxe_len = 0;
422 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
423 wpa_s->group_cipher = WPA_CIPHER_NONE;
424 wpa_s->mgmt_group_cipher = 0;
429 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
430 wpa_s->group_cipher = WPA_CIPHER_WEP104;
433 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
434 wpa_s->group_cipher = WPA_CIPHER_WEP40;
440 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
441 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
442 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
443 wpa_s->pairwise_cipher);
444 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
445 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
446 wpa_s->mgmt_group_cipher);
447 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SSID_PROTECTION, 0);
449 pmksa_cache_clear_current(wpa_s->wpa);
451 wpa_sm_set_mlo_params(wpa_s->wpa, &mlo);
455 void free_hw_features(struct wpa_supplicant *wpa_s)
458 if (wpa_s->hw.modes == NULL)
461 for (i = 0; i < wpa_s->hw.num_modes; i++) {
462 os_free(wpa_s->hw.modes[i].channels);
463 os_free(wpa_s->hw.modes[i].rates);
466 os_free(wpa_s->hw.modes);
467 wpa_s->hw.modes = NULL;
471 static void remove_bss_tmp_disallowed_entry(struct wpa_supplicant *wpa_s,
474 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss);
480 void free_bss_tmp_disallowed(struct wpa_supplicant *wpa_s)
484 dl_list_for_each_safe(bss, prev, &wpa_s->bss_tmp_disallowed,
486 remove_bss_tmp_disallowed_entry(wpa_s, bss);
490 void wpas_flush_fils_hlp_req(struct wpa_supplicant *wpa_s)
494 while ((req = dl_list_first(&wpa_s->fils_hlp_req, struct fils_hlp_req,
505 struct wpa_supplicant *wpa_s = eloop_ctx;
507 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
509 wpa_dbg(wpa_s, MSG_DEBUG, "Clear cached state on disabled interface");
510 wpa_bss_flush(wpa_s);
515 void wpas_clear_driver_signal_override(struct wpa_supplicant *wpa_s)
519 while ((dso = dl_list_first(&wpa_s->drv_signal_override,
528 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
532 bgscan_deinit(wpa_s);
533 autoscan_deinit(wpa_s);
534 scard_deinit(wpa_s->scard);
535 wpa_s->scard = NULL;
536 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
537 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
538 l2_packet_deinit(wpa_s->l2);
539 wpa_s->l2 = NULL;
540 wpa_s->l2_br) {
541 l2_packet_deinit(wpa_s->l2_br);
542 wpa_s->l2_br = NULL;
545 l2_packet_deinit(wpa_s->l2_test);
546 wpa_s->l2_test = NULL;
547 os_free(wpa_s->get_pref_freq_list_override);
548 wpa_s->get_pref_freq_list_override = NULL;
549 wpabuf_free(wpa_s->last_assoc_req_wpa_ie);
550 wpa_s->last_assoc_req_wpa_ie = NULL;
551 os_free(wpa_s->extra_sae_rejected_groups);
552 wpa_s->extra_sae_rejected_groups = NULL;
553 wpabuf_free(wpa_s->rsne_override_eapol);
554 wpa_s->rsne_override_eapol = NULL;
555 wpabuf_free(wpa_s->rsnxe_override_assoc);
556 wpa_s->rsnxe_override_assoc = NULL;
557 wpabuf_free(wpa_s->rsnxe_override_eapol);
558 wpa_s->rsnxe_override_eapol = NULL;
559 wpas_clear_driver_signal_override(wpa_s);
562 if (wpa_s->conf != NULL) {
564 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
565 wpas_notify_network_removed(wpa_s, ssid);
568 os_free(wpa_s->confname);
569 wpa_s->confname = NULL;
571 os_free(wpa_s->confanother);
572 wpa_s->confanother = NULL;
574 os_free(wpa_s->last_con_fail_realm);
575 wpa_s->last_con_fail_realm = NULL;
576 wpa_s->last_con_fail_realm_len = 0;
578 wpa_sm_set_eapol(wpa_s->wpa, NULL);
579 eapol_sm_deinit(wpa_s->eapol);
580 wpa_s->eapol = NULL;
582 rsn_preauth_deinit(wpa_s->wpa);
585 wpa_tdls_deinit(wpa_s->wpa);
589 wmm_ac_clear_saved_tspecs(wpa_s);
591 pmksa_candidate_free(wpa_s->wpa);
592 ptksa_cache_deinit(wpa_s->ptksa);
593 wpa_s->ptksa = NULL;
594 wpa_sm_deinit(wpa_s->wpa);
595 wpa_s->wpa = NULL;
596 wpa_bssid_ignore_clear(wpa_s);
599 wpas_pasn_auth_stop(wpa_s);
602 wpa_bss_deinit(wpa_s);
604 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
605 wpa_supplicant_cancel_scan(wpa_s);
606 wpa_supplicant_cancel_auth_timeout(wpa_s);
607 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
610 wpa_s, NULL);
613 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
614 eloop_cancel_timeout(wpas_clear_disabled_interface, wpa_s, NULL);
615 eloop_cancel_timeout(wpas_verify_ssid_beacon, wpa_s, NULL);
617 wpas_wps_deinit(wpa_s);
619 wpabuf_free(wpa_s->pending_eapol_rx);
620 wpa_s->pending_eapol_rx = NULL;
623 ibss_rsn_deinit(wpa_s->ibss_rsn);
624 wpa_s->ibss_rsn = NULL;
627 sme_deinit(wpa_s);
630 wpa_supplicant_ap_deinit(wpa_s);
633 wpas_p2p_deinit(wpa_s);
636 offchannel_deinit(wpa_s);
639 wpa_supplicant_cancel_sched_scan(wpa_s);
641 os_free(wpa_s->next_scan_freqs);
642 wpa_s->next_scan_freqs = NULL;
644 os_free(wpa_s->manual_scan_freqs);
645 wpa_s->manual_scan_freqs = NULL;
646 os_free(wpa_s->select_network_scan_freqs);
647 wpa_s->select_network_scan_freqs = NULL;
649 os_free(wpa_s->manual_sched_scan_freqs);
650 wpa_s->manual_sched_scan_freqs = NULL;
652 wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
662 if (wpa_s->radio)
663 radio_remove_works(wpa_s, "gas-query", 0);
664 gas_query_deinit(wpa_s->gas);
665 wpa_s->gas = NULL;
666 gas_server_deinit(wpa_s->gas_server);
667 wpa_s->gas_server = NULL;
669 free_hw_features(wpa_s);
671 ieee802_1x_dealloc_kay_sm(wpa_s);
673 os_free(wpa_s->bssid_filter);
674 wpa_s->bssid_filter = NULL;
676 os_free(wpa_s->disallow_aps_bssid);
677 wpa_s->disallow_aps_bssid = NULL;
678 os_free(wpa_s->disallow_aps_ssid);
679 wpa_s->disallow_aps_ssid = NULL;
681 wnm_bss_keep_alive_deinit(wpa_s);
682 wnm_btm_reset(wpa_s);
684 ext_password_deinit(wpa_s->ext_pw);
685 wpa_s->ext_pw = NULL;
687 wpabuf_free(wpa_s->last_gas_resp);
688 wpa_s->last_gas_resp = NULL;
689 wpabuf_free(wpa_s->prev_gas_resp);
690 wpa_s->prev_gas_resp = NULL;
692 os_free(wpa_s->last_scan_res);
693 wpa_s->last_scan_res = NULL;
696 if (wpa_s->drv_priv)
697 wpa_drv_configure_frame_filters(wpa_s, 0);
698 hs20_deinit(wpa_s);
702 wpabuf_free(wpa_s->vendor_elem[i]);
703 wpa_s->vendor_elem[i] = NULL;
707 wmm_ac_notify_disassoc(wpa_s);
710 wpa_s->sched_scan_plans_num = 0;
711 os_free(wpa_s->sched_scan_plans);
712 wpa_s->sched_scan_plans = NULL;
715 wpa_s->non_pref_chan_num = 0;
716 os_free(wpa_s->non_pref_chan);
717 wpa_s->non_pref_chan = NULL;
720 free_bss_tmp_disallowed(wpa_s);
722 wpabuf_free(wpa_s->lci);
723 wpa_s->lci = NULL;
725 wpas_clear_beacon_rep_data(wpa_s);
733 while ((entry = dl_list_last(&wpa_s->mesh_external_pmksa_cache,
744 wpas_flush_fils_hlp_req(wpa_s);
746 wpabuf_free(wpa_s->ric_ies);
747 wpa_s->ric_ies = NULL;
750 wpas_dpp_deinit(wpa_s);
751 dpp_global_deinit(wpa_s->dpp);
752 wpa_s->dpp = NULL;
756 wpas_nan_usd_deinit(wpa_s);
760 wpas_pasn_auth_stop(wpa_s);
763 wpas_scs_deinit(wpa_s);
764 wpas_dscp_deinit(wpa_s);
768 os_free(wpa_s->owe_trans_scan_freq);
769 wpa_s->owe_trans_scan_freq = NULL;
776 * @wpa_s: Pointer to wpa_supplicant data
782 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
788 if (wpa_s->keys_cleared & BIT(i))
790 wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
794 if (~wpa_s->keys_cleared & (BIT(0) | BIT(15)) && addr &&
796 if (!(wpa_s->keys_cleared & BIT(0)))
797 wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, addr, 0, 0,
799 if (!(wpa_s->keys_cleared & BIT(15)))
800 wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, addr, 1, 0,
804 wpa_s, addr,
808 wpa_s->keys_cleared = (u32) -1;
848 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
850 if (wpa_s->bgscan_ssid) {
851 bgscan_deinit(wpa_s);
852 wpa_s->bgscan_ssid = NULL;
859 * @wpa_s: Pointer to the wpa_supplicant data
863 void wpa_supplicant_reset_bgscan(struct wpa_supplicant *wpa_s)
867 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
868 name = wpa_s->current_ssid->bgscan;
870 name = wpa_s->conf->bgscan;
872 wpa_supplicant_stop_bgscan(wpa_s);
875 if (wpas_driver_bss_selection(wpa_s))
878 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
882 bgscan_deinit(wpa_s);
883 if (wpa_s->current_ssid) {
884 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
885 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
894 wpa_s->bgscan_ssid = wpa_s->current_ssid;
895 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
898 bgscan_notify_scan(wpa_s, scan_res);
903 wpa_s->bgscan_ssid = NULL;
909 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
911 if (autoscan_init(wpa_s, 0))
912 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
916 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
918 autoscan_deinit(wpa_s);
922 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
924 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
925 wpa_s->wpa_state == WPA_SCANNING) {
926 autoscan_deinit(wpa_s);
927 wpa_supplicant_start_autoscan(wpa_s);
934 struct wpa_supplicant *wpa_s = eloop_ctx;
939 if (!wpa_s->current_ssid || !wpa_s->current_bss)
942 ssid = wpa_s->current_bss->ssid;
943 ssid_len = wpa_s->current_bss->ssid_len;
945 if (wpa_s->current_ssid->ssid_len &&
946 (wpa_s->current_ssid->ssid_len != ssid_len ||
947 os_memcmp(wpa_s->current_ssid->ssid, ssid, ssid_len) != 0))
950 if (wpa_s->wpa_state < WPA_4WAY_HANDSHAKE ||
951 !wpa_s->bigtk_set || wpa_s->ssid_verified)
956 if (wpa_supplicant_update_scan_results(wpa_s, wpa_s->bssid) < 0)
959 bss = wpa_bss_get_bssid_latest(wpa_s, wpa_s->bssid);
964 if (bss->tsf > wpa_s->first_beacon_tsf) {
969 wpa_s->beacons_checked++;
976 wpa_s->ssid_verified = true;
983 if (wpa_s->beacons_checked < 16) {
984 eloop_register_timeout(wpa_s->next_beacon_check, 0,
985 wpas_verify_ssid_beacon, wpa_s, NULL);
986 wpa_s->next_beacon_check++;
991 static void wpas_verify_ssid_beacon_prot(struct wpa_supplicant *wpa_s)
1001 if (wpa_supplicant_update_scan_results(wpa_s, wpa_s->bssid) < 0)
1004 bss = wpa_bss_get_bssid_latest(wpa_s, wpa_s->bssid);
1009 wpa_s->first_beacon_tsf = bss->tsf;
1010 wpa_s->beacons_checked = 0;
1011 wpa_s->next_beacon_check = 1;
1012 eloop_cancel_timeout(wpas_verify_ssid_beacon, wpa_s, NULL);
1013 eloop_register_timeout(1, 0, wpas_verify_ssid_beacon, wpa_s, NULL);
1019 * @wpa_s: Pointer to wpa_supplicant data
1025 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
1028 enum wpa_states old_state = wpa_s->wpa_state;
1033 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
1034 wpa_supplicant_state_txt(wpa_s->wpa_state),
1038 os_reltime_initialized(&wpa_s->roam_start)) {
1039 os_reltime_age(&wpa_s->roam_start, &wpa_s->roam_time);
1040 wpa_s->roam_start.sec = 0;
1041 wpa_s->roam_start.usec = 0;
1042 wpas_notify_auth_changed(wpa_s);
1043 wpas_notify_roam_time(wpa_s);
1044 wpas_notify_roam_complete(wpa_s);
1046 os_reltime_initialized(&wpa_s->roam_start)) {
1047 wpa_s->roam_start.sec = 0;
1048 wpa_s->roam_start.usec = 0;
1049 wpa_s->roam_time.sec = 0;
1050 wpa_s->roam_time.usec = 0;
1051 wpas_notify_roam_complete(wpa_s);
1056 wpa_s->normal_scans = 0;
1060 wpas_connect_work_done(wpa_s);
1062 wpa_s->normal_scans = 0;
1072 if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid &&
1073 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
1074 wpa_s->current_ssid->p2p_group) {
1075 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) {
1076 wpa_dbg(wpa_s, MSG_DEBUG,
1078 wpa_s->p2p_cli_probe =
1079 wpa_drv_probe_req_report(wpa_s, 1) >= 0;
1080 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) {
1081 wpa_dbg(wpa_s, MSG_DEBUG,
1083 wpa_s->p2p_cli_probe = 0;
1084 wpa_drv_probe_req_report(wpa_s, 0);
1090 wpa_supplicant_notify_scanning(wpa_s, 0);
1092 if (state == WPA_COMPLETED && wpa_s->new_connection) {
1093 struct wpa_ssid *ssid = wpa_s->current_ssid;
1098 if (wpa_s->valid_links)
1101 MAC2STR(wpa_s->ap_mld_addr));
1104 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1105 wpa_auth_alg_fils(wpa_s->sme.auth_alg))
1108 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1109 wpa_auth_alg_fils(wpa_s->auth_alg))
1113 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
1115 MAC2STR(wpa_s->bssid),
1120 wpas_clear_temp_disabled(wpa_s, ssid, 1);
1121 wpa_s->consecutive_conn_failures = 0;
1122 wpa_s->new_connection = 0;
1123 wpa_drv_set_operstate(wpa_s, 1);
1125 wpa_drv_set_supp_port(wpa_s, 1);
1127 wpa_s->after_wps = 0;
1128 wpa_s->known_wps_freq = 0;
1129 wpas_p2p_completed(wpa_s);
1131 sme_sched_obss_scan(wpa_s, 1);
1139 wpas_update_owe_connect_params(wpa_s);
1143 wpa_s->new_connection = 1;
1144 wpa_drv_set_operstate(wpa_s, 0);
1146 wpa_drv_set_supp_port(wpa_s, 0);
1148 sme_sched_obss_scan(wpa_s, 0);
1150 wpa_s->wpa_state = state;
1153 if (state == WPA_COMPLETED && wpa_s->current_ssid != wpa_s->bgscan_ssid)
1154 wpa_supplicant_reset_bgscan(wpa_s);
1156 wpa_supplicant_stop_bgscan(wpa_s);
1160 wpa_supplicant_stop_autoscan(wpa_s);
1163 wpa_supplicant_start_autoscan(wpa_s);
1167 wnm_btm_reset(wpa_s);
1170 if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
1171 wmm_ac_notify_disassoc(wpa_s);
1174 if (wpa_s->wpa_state != old_state) {
1175 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
1181 wpas_p2p_indicate_state_change(wpa_s);
1183 if (wpa_s->wpa_state == WPA_COMPLETED ||
1185 wpas_notify_auth_changed(wpa_s);
1187 if (wpa_s->wpa_state == WPA_COMPLETED)
1188 wpas_dpp_connected(wpa_s);
1191 if (wpa_s->wpa_state == WPA_COMPLETED &&
1192 wpa_s->bigtk_set && !wpa_s->ssid_verified)
1193 wpas_verify_ssid_beacon_prot(wpa_s);
1197 wpas_update_fils_connect_params(wpa_s);
1206 struct wpa_supplicant *wpa_s = global->ifaces;
1207 while (wpa_s) {
1208 struct wpa_supplicant *next = wpa_s->next;
1209 if (wpas_wps_terminate_pending(wpa_s) == 1)
1212 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
1213 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
1214 wpas_p2p_disconnect(wpa_s);
1216 wpa_s = next;
1232 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
1234 enum wpa_states old_state = wpa_s->wpa_state;
1242 wpa_s->pairwise_cipher = 0;
1243 wpa_s->group_cipher = 0;
1244 wpa_s->mgmt_group_cipher = 0;
1245 wpa_s->key_mgmt = 0;
1246 wpa_s->allowed_key_mgmts = 0;
1247 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
1248 wpa_supplicant_set_state(wpa_s, new_state);
1250 if (wpa_s->wpa_state != old_state)
1251 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
1257 * @wpa_s: Pointer to wpa_supplicant data
1266 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
1272 if (wpa_s->confname == NULL)
1274 conf = wpa_config_read(wpa_s->confname, NULL, false);
1276 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
1277 "file '%s' - exiting", wpa_s->confname);
1280 if (wpa_s->confanother &&
1281 !wpa_config_read(wpa_s->confanother, conf, true)) {
1282 wpa_msg(wpa_s, MSG_ERROR,
1284 wpa_s->confanother);
1290 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
1291 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
1293 wpa_s->conf->ctrl_interface) != 0);
1296 wpa_supplicant_ctrl_iface_deinit(wpa_s, wpa_s->ctrl_iface);
1297 wpa_s->ctrl_iface = NULL;
1300 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1301 if (wpa_s->current_ssid) {
1302 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
1303 wpa_s->own_disconnect_req = 1;
1304 wpa_supplicant_deauthenticate(wpa_s,
1312 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1313 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
1314 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) {
1319 eapol_sm_notify_eap_success(wpa_s->eapol, false);
1321 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1322 wpa_sm_set_config(wpa_s->wpa, NULL);
1323 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
1324 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1325 rsn_preauth_deinit(wpa_s->wpa);
1327 old_ap_scan = wpa_s->conf->ap_scan;
1328 wpa_config_free(wpa_s->conf);
1329 wpa_s->conf = conf;
1330 if (old_ap_scan != wpa_s->conf->ap_scan)
1331 wpas_notify_ap_scan_changed(wpa_s);
1334 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1336 wpa_supplicant_update_config(wpa_s);
1338 wpa_supplicant_clear_status(wpa_s);
1339 if (wpa_supplicant_enabled_networks(wpa_s)) {
1340 wpa_s->reassociate = 1;
1341 wpa_supplicant_req_scan(wpa_s, 0, 0);
1343 wpa_bssid_ignore_clear(wpa_s);
1344 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
1352 struct wpa_supplicant *wpa_s;
1353 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1354 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
1356 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
1368 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
1372 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
1375 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
1381 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
1384 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
1390 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
1396 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
1403 wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
1404 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
1426 void wpas_set_mgmt_group_cipher(struct wpa_supplicant *wpa_s,
1434 if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1437 wpa_dbg(wpa_s, MSG_DEBUG,
1441 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1442 wpa_dbg(wpa_s, MSG_DEBUG,
1445 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1446 wpa_dbg(wpa_s, MSG_DEBUG,
1449 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1450 wpa_dbg(wpa_s, MSG_DEBUG,
1453 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1454 wpa_dbg(wpa_s, MSG_DEBUG,
1457 wpa_s->mgmt_group_cipher = 0;
1458 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1460 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1461 wpa_s->mgmt_group_cipher);
1462 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1463 wpas_get_ssid_pmf(wpa_s, ssid));
1468 * @wpa_s: Pointer to wpa_supplicant data
1477 static int wpa_supplicant_get_psk(struct wpa_supplicant *wpa_s,
1492 wpa_msg(wpa_s, MSG_WARNING, "Error in pbkdf2_sha1()");
1503 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1508 wpa_msg(wpa_s, MSG_INFO,
1514 wpa_msg(wpa_s, MSG_INFO,
1529 wpa_msg(wpa_s, MSG_WARNING,
1542 wpa_msg(wpa_s, MSG_INFO,
1551 wpa_msg(wpa_s, MSG_INFO,
1569 static void wpas_update_allowed_key_mgmt(struct wpa_supplicant *wpa_s,
1572 int akm_count = wpa_s->max_num_akms;
1579 wpa_s->allowed_key_mgmts = 0;
1580 switch (wpa_s->key_mgmt) {
1584 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE;
1590 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE_EXT_KEY;
1595 wpa_s->allowed_key_mgmts |=
1601 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE;
1607 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE_EXT_KEY;
1612 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_PSK;
1617 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_PSK;
1623 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE_EXT_KEY;
1628 wpa_s->allowed_key_mgmts |=
1634 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE;
1640 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_PSK;
1645 wpa_s->allowed_key_mgmts |=
1652 if (wpa_s->conf->sae_pwe != SAE_PWE_HUNT_AND_PECK &&
1653 wpa_s->conf->sae_pwe != SAE_PWE_FORCE_HUNT_AND_PECK)
1660 if (!((wpa_s->allowed_key_mgmts &
1664 if (!wpa_s->rsnxe_len) {
1665 wpa_s->rsnxe_len = 3;
1666 wpa_s->rsnxe[0] = WLAN_EID_RSNX;
1667 wpa_s->rsnxe[1] = 1;
1668 wpa_s->rsnxe[2] = 0;
1671 wpa_s->rsnxe[2] |= capab;
1677 * @wpa_s: Pointer to wpa_supplicant data
1690 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
1714 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1721 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1729 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1736 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using OSEN (within RSN)");
1740 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1741 wpa_dbg(wpa_s, MSG_DEBUG,
1745 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1754 wpa_dbg(wpa_s, MSG_DEBUG,
1757 wpa_dbg(wpa_s, MSG_DEBUG,
1766 wpa_dbg(wpa_s, MSG_DEBUG,
1769 wpa_dbg(wpa_s, MSG_DEBUG,
1783 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1810 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1811 wpa_s->wpa_proto = 0;
1816 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1822 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1826 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1830 wpa_s->wpa_proto = proto;
1831 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1832 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1835 if (bss || !wpa_s->ap_ies_from_associnfo) {
1836 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1838 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1840 wpa_sm_set_ap_rsnxe(wpa_s->wpa, bss_rsnx,
1846 wpa_s->group_cipher = WPA_CIPHER_NONE;
1847 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1850 wpa_dbg(wpa_s, MSG_DEBUG,
1853 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1854 if (wpa_s->group_cipher < 0) {
1855 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1859 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1860 wpa_cipher_txt(wpa_s->group_cipher));
1863 wpa_dbg(wpa_s, MSG_DEBUG,
1866 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1867 if (wpa_s->pairwise_cipher < 0) {
1868 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1872 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1873 wpa_cipher_txt(wpa_s->pairwise_cipher));
1878 if ((!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE) &&
1879 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA)) ||
1880 wpas_is_sae_avoided(wpa_s, ssid, &ie))
1885 if (!(wpa_s->drv_flags & (WPA_DRIVER_FLAGS_SME |
1889 wpa_dbg(wpa_s, MSG_DEBUG,
1896 os_strcmp(wpa_supplicant_get_eap_mode(wpa_s), "LEAP") != 0) {
1897 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X_SHA384;
1898 wpa_dbg(wpa_s, MSG_DEBUG,
1901 pmksa_cache_get_current(wpa_s->wpa)) {
1904 wpa_dbg(wpa_s, MSG_DEBUG,
1906 pmksa_cache_clear_current(wpa_s->wpa);
1912 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1913 wpa_dbg(wpa_s, MSG_DEBUG,
1918 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1919 wpa_dbg(wpa_s, MSG_DEBUG,
1924 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA384;
1925 wpa_dbg(wpa_s, MSG_DEBUG,
1931 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384;
1932 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA384");
1935 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA384;
1936 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA384");
1939 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256;
1940 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA256");
1943 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA256;
1944 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA256");
1948 os_strcmp(wpa_supplicant_get_eap_mode(wpa_s), "LEAP") != 0) {
1949 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1950 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1952 pmksa_cache_get_current(wpa_s->wpa)) {
1955 wpa_dbg(wpa_s, MSG_DEBUG,
1957 pmksa_cache_clear_current(wpa_s->wpa);
1962 wpa_s->key_mgmt = WPA_KEY_MGMT_DPP;
1963 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT DPP");
1967 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE_EXT_KEY;
1968 wpa_dbg(wpa_s, MSG_DEBUG,
1971 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE_EXT_KEY;
1972 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE (ext key)");
1974 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1975 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1977 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1978 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1982 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1983 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1986 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1987 wpa_dbg(wpa_s, MSG_DEBUG,
1990 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1991 wpa_dbg(wpa_s, MSG_DEBUG,
1994 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1995 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1997 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1998 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
2000 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
2001 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
2004 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
2005 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
2009 wpa_s->key_mgmt = WPA_KEY_MGMT_OWE;
2010 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT OWE");
2013 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
2018 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
2019 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
2020 wpa_s->pairwise_cipher);
2021 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
2024 (wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED ||
2026 wpa_msg(wpa_s, MSG_INFO,
2031 wpas_set_mgmt_group_cipher(wpa_s, ssid, &ie);
2033 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) ||
2034 (wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OCV))
2035 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCV, ssid->ocv);
2037 sae_pwe = wpa_s->conf->sae_pwe;
2039 wpa_key_mgmt_sae_ext_key(wpa_s->key_mgmt)) &&
2044 wpa_dbg(wpa_s, MSG_DEBUG,
2048 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SAE_PWE, sae_pwe);
2050 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SAE_PK,
2059 wpas_get_ssid_pmf(wpa_s, ssid) != MGMT_FRAME_PROTECTION_REQUIRED) {
2060 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Force MFPR=1 on 6 GHz");
2061 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
2065 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_FT_RSNXE_USED,
2066 wpa_s->ft_rsnxe_used);
2067 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_EAPOL,
2068 wpa_s->oci_freq_override_eapol);
2069 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_EAPOL_G2,
2070 wpa_s->oci_freq_override_eapol_g2);
2071 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_FT_ASSOC,
2072 wpa_s->oci_freq_override_ft_assoc);
2073 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_FILS_ASSOC,
2074 wpa_s->oci_freq_override_fils_assoc);
2075 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DISABLE_EAPOL_G2_TX,
2076 wpa_s->disable_eapol_g2_tx);
2080 if (ssid->mode == WPAS_MODE_INFRA && wpa_s->conf->extended_key_id &&
2084 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_EXTENDED_KEY_ID)) {
2087 wpa_msg(wpa_s, MSG_DEBUG,
2089 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_EXT_KEY_ID,
2090 wpa_s->conf->extended_key_id);
2092 wpa_s->conf->extended_key_id &&
2093 wpa_s->pairwise_cipher != WPA_CIPHER_TKIP &&
2096 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_USE_EXT_KEY_ID,
2099 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_EXT_KEY_ID, 0);
2100 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_USE_EXT_KEY_ID, 0);
2112 wmm = wpa_s->connection_set &&
2113 (wpa_s->connection_ht || wpa_s->connection_vht ||
2114 wpa_s->connection_he || wpa_s->connection_eht);
2117 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_WMM_ENABLED, wmm);
2129 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SSID_PROTECTION,
2132 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SSID_PROTECTION, false);
2136 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie,
2138 wpa_msg(wpa_s, MSG_WARNING,
2143 wpa_s->rsnxe_len = sizeof(wpa_s->rsnxe);
2144 if (wpa_sm_set_assoc_rsnxe_default(wpa_s->wpa, wpa_s->rsnxe,
2145 &wpa_s->rsnxe_len)) {
2146 wpa_msg(wpa_s, MSG_WARNING,
2154 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) {
2156 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
2158 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DPP_PFS, ssid->dpp_pfs);
2167 if (wpa_supplicant_get_psk(wpa_s, bss, ssid,
2169 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
2181 wpa_msg(wpa_s, MSG_INFO,
2183 wpas_auth_failed(wpa_s, "NO_PSK_AVAILABLE", NULL);
2187 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE) {
2193 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
2196 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED) &&
2199 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAFE_PTK0_REKEYS)))) {
2200 wpa_msg(wpa_s, MSG_INFO,
2202 wpa_s->deny_ptk0_rekey = 1;
2203 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DENY_PTK0_REKEY, 1);
2205 wpa_s->deny_ptk0_rekey = 0;
2206 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DENY_PTK0_REKEY, 0);
2209 if (wpa_key_mgmt_cross_akm(wpa_s->key_mgmt) &&
2210 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
2211 wpas_update_allowed_key_mgmt(wpa_s, ssid);
2217 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx,
2230 if (wpa_s->conf->coloc_intf_reporting) {
2238 if ((wpas_driver_bss_selection(wpa_s) ||
2239 !wpa_s->disable_mbo_oce) &&
2240 !wpa_s->conf->disable_btm)
2249 if (wpa_s->conf->interworking)
2255 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_QOS_MAPPING)
2261 if (wpa_s->conf->hs20)
2271 if (wpa_s->disable_scs_support)
2288 if (wpa_s->conf->ftm_responder)
2290 if (wpa_s->conf->ftm_initiator)
2295 if (!wpa_s->disable_fils)
2302 if (wpa_s->disable_mscs_support)
2320 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf,
2326 if (len < wpa_s->extended_capa_len)
2327 len = wpa_s->extended_capa_len;
2337 wpas_ext_capab_byte(wpa_s, pos, i, bss);
2339 if (i < wpa_s->extended_capa_len) {
2340 *pos &= ~wpa_s->extended_capa_mask[i];
2341 *pos |= wpa_s->extended_capa[i];
2356 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
2361 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
2370 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
2375 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2384 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
2387 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
2390 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
2402 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
2405 struct wpa_radio_work *work = wpa_s->connect_work;
2410 wpa_s->connect_work = NULL;
2418 int wpas_update_random_addr(struct wpa_supplicant *wpa_s,
2428 if (wpa_s->last_mac_addr_style == style && wpa_s->reassoc_same_ess) {
2432 if (ether_addr_equal(wpa_s->own_addr, ssid->mac_value))
2434 } else if ((wpa_s->last_mac_addr_change.sec != 0 ||
2435 wpa_s->last_mac_addr_change.usec != 0) &&
2438 &wpa_s->last_mac_addr_change,
2439 wpa_s->conf->rand_addr_lifetime)) {
2440 wpa_msg(wpa_s, MSG_DEBUG,
2452 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
2458 wpa_msg(wpa_s, MSG_INFO,
2468 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
2469 wpa_msg(wpa_s, MSG_INFO,
2474 os_get_reltime(&wpa_s->last_mac_addr_change);
2475 wpa_s->mac_addr_changed = 1;
2476 wpa_s->last_mac_addr_style = style;
2478 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
2479 wpa_msg(wpa_s, MSG_INFO,
2484 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
2491 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
2493 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
2494 !wpa_s->conf->preassoc_mac_addr)
2497 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr,
2539 void wpa_s_clear_sae_rejected(struct wpa_supplicant *wpa_s)
2542 os_free(wpa_s->sme.sae_rejected_groups);
2543 wpa_s->sme.sae_rejected_groups = NULL;
2545 if (wpa_s->extra_sae_rejected_groups) {
2546 int i, *groups = wpa_s->extra_sae_rejected_groups;
2552 int_array_add_unique(&wpa_s->sme.sae_rejected_groups,
2561 int wpas_restore_permanent_mac_addr(struct wpa_supplicant *wpa_s)
2563 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
2564 wpa_msg(wpa_s, MSG_INFO,
2568 wpa_s->mac_addr_changed = 0;
2569 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
2570 wpa_msg(wpa_s, MSG_INFO,
2574 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
2583 * @wpa_s: Pointer to wpa_supplicant data
2589 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
2596 wpa_s->own_disconnect_req = 0;
2597 wpa_s->own_reconnect_req = 0;
2603 wpabuf_free(wpa_s->pending_eapol_rx);
2604 wpa_s->pending_eapol_rx = NULL;
2607 rand_style = wpa_s->conf->mac_addr;
2611 wpa_s->eapol_failed = 0;
2612 wpa_s->multi_ap_ie = 0;
2614 wmm_ac_clear_saved_tspecs(wpa_s);
2617 wpa_s->wnm_mode = 0;
2618 wpa_s->wnm_target_bss = NULL;
2620 wpa_s->reassoc_same_bss = 0;
2621 wpa_s->reassoc_same_ess = 0;
2623 wpa_s->testing_resend_assoc = 0;
2626 if (wpa_s->last_ssid == ssid) {
2627 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
2628 wpa_s->reassoc_same_ess = 1;
2629 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
2631 wmm_ac_save_tspecs(wpa_s);
2633 wpa_s->reassoc_same_bss = 1;
2635 } else if (wpa_s->current_bss && wpa_s->current_bss != bss) {
2636 os_get_reltime(&wpa_s->roam_start);
2641 wpa_s_clear_sae_rejected(wpa_s);
2644 wpa_s_setup_sae_pt(wpa_s->conf, ssid, false);
2648 int status = wpas_update_random_addr(wpa_s, rand_style, ssid);
2654 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
2656 wpa_s->mac_addr_changed) {
2657 if (wpas_restore_permanent_mac_addr(wpa_s) < 0)
2660 wpa_s->last_ssid = ssid;
2663 ibss_rsn_deinit(wpa_s->ibss_rsn);
2664 wpa_s->ibss_rsn = NULL;
2668 wpa_msg(wpa_s, MSG_INFO,
2677 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
2678 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
2682 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
2683 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2685 wpas_p2p_ap_setup_failed(wpa_s);
2688 wpa_s->current_bss = bss;
2690 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
2698 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
2699 wpa_msg(wpa_s, MSG_INFO,
2705 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
2706 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
2707 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
2710 wpa_s->current_bss = bss;
2712 wpa_msg(wpa_s, MSG_ERROR,
2725 wpa_supplicant_rsn_supp_set_config(wpa_s, ssid);
2728 if (wpas_dpp_check_connect(wpa_s, ssid, bss) != 0)
2734 wpa_tdls_ap_ies(wpa_s->wpa, wpa_bss_ie_ptr(bss), bss->ie_len);
2738 wpas_mbo_check_pmf(wpa_s, bss, ssid);
2741 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
2743 wpa_s, bss, ssid);
2747 if (wpa_s->connect_work) {
2748 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
2752 if (radio_work_pending(wpa_s, "connect")) {
2753 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
2760 wpa_s->sme.auth_alg = WPA_AUTH_ALG_OPEN;
2764 wpas_abort_ongoing_scan(wpa_s);
2773 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
2787 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
2798 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
2799 if (wpa_s->hw.modes[i].mode == hw_mode) {
2800 mode = &wpa_s->hw.modes[i];
2829 static struct wpa_bss * ibss_find_existing_bss(struct wpa_supplicant *wpa_s,
2834 for (j = 0; j < wpa_s->last_scan_res_used; j++) {
2835 struct wpa_bss *bss = wpa_s->last_scan_res[j];
2848 static bool ibss_mesh_can_use_ht(struct wpa_supplicant *wpa_s,
2854 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
2857 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
2858 wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
2859 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
2877 static bool ibss_mesh_can_use_vht(struct wpa_supplicant *wpa_s,
2884 if (!drv_supports_vht(wpa_s, ssid))
2889 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
2904 static bool ibss_mesh_can_use_he(struct wpa_supplicant *wpa_s,
2925 static bool ibss_mesh_can_use_eht(struct wpa_supplicant *wpa_s,
2944 static void ibss_mesh_select_40mhz(struct wpa_supplicant *wpa_s,
3014 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0,
3051 static bool ibss_mesh_select_80_160mhz(struct wpa_supplicant *wpa_s,
3190 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
3204 struct wpa_bss *bss = ibss_find_existing_bss(wpa_s, ssid);
3216 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
3233 freq->ht_enabled = ibss_mesh_can_use_ht(wpa_s, ssid, mode);
3235 freq->vht_enabled = ibss_mesh_can_use_vht(wpa_s, ssid, mode);
3237 freq->he_enabled = ibss_mesh_can_use_he(wpa_s, ssid, mode,
3242 ibss_mesh_select_40mhz(wpa_s, ssid, mode, freq, obss_scan);
3243 if (!ibss_mesh_select_80_160mhz(wpa_s, ssid, mode, freq,
3249 freq->eht_enabled = ibss_mesh_can_use_eht(wpa_s, ssid, mode,
3255 static size_t wpas_add_fils_hlp_req(struct wpa_supplicant *wpa_s, u8 *ie_buf,
3263 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
3289 os_memcpy(buf, wpa_s->own_addr, ETH_ALEN);
3323 int wpa_is_fils_supported(struct wpa_supplicant *wpa_s)
3325 return (((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
3326 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_FILS)) ||
3327 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
3328 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD)));
3332 int wpa_is_fils_sk_pfs_supported(struct wpa_supplicant *wpa_s)
3335 return (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
3336 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_FILS);
3368 static int wpas_populate_wfa_capa(struct wpa_supplicant *wpa_s,
3379 if (wpa_s->enable_dscp_policy_capa)
3422 struct wpa_supplicant *wpa_s,
3443 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
3465 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
3466 (wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_MLO) &&
3470 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
3471 wpa_s->valid_links)
3472 addr = wpa_s->ap_mld_addr;
3475 wpa_s->conf->okc :
3482 if (pmksa_cache_set_current(wpa_s->wpa, NULL, addr,
3485 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
3491 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
3493 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
3503 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
3505 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
3518 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
3520 wpa_s->wpa_proto = 0;
3523 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
3525 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
3541 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
3546 wpa_s->wpa_proto = 0;
3549 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
3551 wpa_s->wpa_proto = 0;
3566 wpa_sm_set_reset_fils_completed(wpa_s->wpa, 0);
3568 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) &&
3569 ssid->eap.erp && wpa_key_mgmt_fils(wpa_s->key_mgmt) &&
3570 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, &username,
3573 (!wpa_s->last_con_fail_realm ||
3574 wpa_s->last_con_fail_realm_len != realm_len ||
3575 os_memcmp(wpa_s->last_con_fail_realm, realm, realm_len) != 0)) {
3587 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) &&
3588 ssid->eap.erp && wpa_key_mgmt_fils(wpa_s->key_mgmt) &&
3595 if (wpa_key_mgmt_sae(wpa_s->key_mgmt))
3599 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
3602 wpa_dbg(wpa_s, MSG_DEBUG,
3608 wpa_dbg(wpa_s, MSG_DEBUG,
3615 if (wpa_s->global->p2p) {
3621 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
3627 wpa_s->cross_connect_disallowed = 0;
3632 wpa_s->cross_connect_disallowed =
3635 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
3637 wpa_s->cross_connect_disallowed ?
3642 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
3647 wpa_ie_len += wpas_supp_op_class_ie(wpa_s, ssid, bss,
3663 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
3665 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
3670 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
3696 if (is_hs20_network(wpa_s, ssid, bss)) {
3701 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
3715 hs20_configure_frame_filters(wpa_s);
3720 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
3721 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
3733 if (wpa_s->fst_ies) {
3734 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
3738 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
3746 if (!wpa_s->disable_mbo_oce && mbo_ie) {
3749 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
3762 len = wpas_add_fils_hlp_req(wpa_s, wpa_ie + wpa_ie_len,
3776 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OWE_OFFLOAD_STA)) {
3782 } else if (wpa_s->assoc_status_code ==
3784 if (wpa_s->last_owe_group == 19)
3786 else if (wpa_s->last_owe_group == 20)
3794 wpa_s->last_owe_group = group;
3796 owe_ie = owe_build_assoc_req(wpa_s->wpa, group);
3809 wpa_sm_get_key_mgmt(wpa_s->wpa) == WPA_KEY_MGMT_DPP &&
3814 pmksa = pmksa_cache_get_current(wpa_s->wpa);
3818 dpp_pfs_free(wpa_s->dpp_pfs);
3819 wpa_s->dpp_pfs = dpp_pfs_init(ssid->dpp_netaccesskey,
3821 if (!wpa_s->dpp_pfs) {
3826 if (wpabuf_len(wpa_s->dpp_pfs->ie) <=
3829 wpabuf_head(wpa_s->dpp_pfs->ie),
3830 wpabuf_len(wpa_s->dpp_pfs->ie));
3831 wpa_ie_len += wpabuf_len(wpa_s->dpp_pfs->ie);
3842 if (bss && wpa_key_mgmt_ft(wpa_sm_get_key_mgmt(wpa_s->wpa))) {
3848 const u8 *wpa_md = wpa_sm_get_ft_md(wpa_s->wpa);
3854 wpa_s->wpa, wpa_ie + wpa_ie_len,
3859 if (len > 0 && wpa_s->sme.ft_used &&
3860 wpa_sm_has_ft_keys(wpa_s->wpa, md)) {
3861 wpa_dbg(wpa_s, MSG_DEBUG,
3871 if (wpa_s->rsnxe_override_assoc &&
3872 wpabuf_len(wpa_s->rsnxe_override_assoc) <=
3876 wpabuf_head(wpa_s->rsnxe_override_assoc),
3877 wpabuf_len(wpa_s->rsnxe_override_assoc));
3878 wpa_ie_len += wpabuf_len(wpa_s->rsnxe_override_assoc);
3881 if (wpa_s->rsnxe_len > 0 &&
3882 wpa_s->rsnxe_len <= max_wpa_ie_len - wpa_ie_len) {
3883 os_memcpy(wpa_ie + wpa_ie_len, wpa_s->rsnxe, wpa_s->rsnxe_len);
3884 wpa_ie_len += wpa_s->rsnxe_len;
3889 if (wpa_s->disable_mscs_support)
3893 wpa_s->robust_av.valid_config) {
3902 wpa_s->robust_av.frame_classifier_len;
3910 wpas_populate_mscs_descriptor_ie(&wpa_s->robust_av, mscs_ie);
3924 wpa_ie_len = wpas_populate_wfa_capa(wpa_s, bss, wpa_ie, wpa_ie_len,
3957 static void wpas_update_owe_connect_params(struct wpa_supplicant *wpa_s)
3963 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss,
3964 wpa_s->current_ssid, ¶ms, NULL);
3968 wpa_drv_update_connect_params(wpa_s, ¶ms, WPA_DRV_UPDATE_ASSOC_IES);
3975 wpa_s)
3981 if (wpa_s->auth_alg != WPA_AUTH_ALG_OPEN)
3985 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss,
3986 wpa_s->current_ssid, ¶ms, &mask);
3991 wpa_s->auth_alg = params.auth_alg;
3992 wpa_drv_update_connect_params(wpa_s, ¶ms, mask);
4083 get_supported_edmg(struct wpa_supplicant *wpa_s,
4091 if (!wpa_s->hw.modes)
4098 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, hw_mode, false);
4112 void wpas_update_mbo_connect_params(struct wpa_supplicant *wpa_s)
4122 if (wpa_s->wpa_state != WPA_COMPLETED || !wpa_s->current_ssid ||
4123 !wpa_s->current_bss ||
4124 !wpa_bss_get_vendor_ie(wpa_s->current_bss, MBO_IE_VENDOR_TYPE))
4128 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss,
4129 wpa_s->current_ssid, ¶ms, NULL);
4133 wpa_drv_update_connect_params(wpa_s, ¶ms, WPA_DRV_UPDATE_ASSOC_IES);
4144 struct wpa_supplicant *wpa_s = work->wpa_s;
4166 wpa_s->roam_in_progress = false;
4168 wpa_s->bss_trans_mgmt_in_progress = false;
4173 wpa_s->connect_work = NULL;
4176 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
4183 wpa_s->connect_work = work;
4185 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
4186 wpas_network_disabled(wpa_s, ssid)) {
4187 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
4188 wpas_connect_work_done(wpa_s);
4196 * prev_bssid will be zero as both wpa_s->valid_links and wpa_s->bssid
4200 wpa_s->valid_links ? wpa_s->ap_mld_addr : wpa_s->bssid,
4203 wpa_s->reassociate = 0;
4204 wpa_s->eap_expected_failure = 0;
4208 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
4209 wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0);
4210 wpa_s->rsnxe_len = 0;
4212 wpa_s->mscs_setup_done = false;
4215 wpa_ie = wpas_populate_assoc_ies(wpa_s, bss, ssid, ¶ms, NULL);
4217 wpas_connect_work_done(wpa_s);
4222 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
4226 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
4229 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
4230 os_memset(wpa_s->bssid, 0, ETH_ALEN);
4231 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
4233 wpas_notify_bssid_changed(wpa_s);
4238 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
4241 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
4246 wpa_s->conf->ap_scan == 2 &&
4250 wpas_connect_work_done(wpa_s);
4251 wpa_s->scan_req = MANUAL_SCAN_REQ;
4252 wpa_s->reassociate = 1;
4253 wpa_supplicant_req_scan(wpa_s, 0, 0);
4258 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
4261 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
4263 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
4265 if (!wpa_s->pno)
4266 wpa_supplicant_cancel_sched_scan(wpa_s);
4268 wpa_supplicant_cancel_scan(wpa_s);
4270 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
4272 cipher_pairwise = wpa_s->pairwise_cipher;
4273 cipher_group = wpa_s->group_cipher;
4274 cipher_group_mgmt = wpa_s->mgmt_group_cipher;
4275 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
4276 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
4277 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
4280 if (wpa_set_wep_keys(wpa_s, ssid)) {
4286 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
4290 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
4305 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
4307 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
4312 old_ssid = wpa_s->current_ssid;
4313 wpa_s->current_ssid = ssid;
4315 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
4319 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set ||
4320 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
4326 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS);
4343 wpa_s->conf->ap_scan == 2) {
4351 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
4358 params.beacon_int = wpa_s->conf->beacon_int;
4416 params.freq.edmg = get_supported_edmg(wpa_s,
4429 params.key_mgmt_suite = wpa_s->key_mgmt;
4430 params.allowed_key_mgmts = wpa_s->allowed_key_mgmts;
4431 params.wpa_proto = wpa_s->wpa_proto;
4432 wpa_s->auth_alg = params.auth_alg;
4448 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) &&
4454 if (wpa_supplicant_get_psk(wpa_s, bss, ssid, psk) == 0)
4458 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X) &&
4466 if (wpa_s->conf->key_mgmt_offload) {
4475 wpa_s->conf->okc : ssid->proactive_key_caching;
4481 wpa_supplicant_get_psk(wpa_s, bss, ssid, psk) == 0)
4485 if ((wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA) &&
4498 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
4502 if (!wpas_driver_bss_selection(wpa_s) && rsn &&
4506 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
4520 if (wpa_s
4521 params.uapsd = wpa_s->p2pdev->sta_uapsd;
4530 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
4537 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms);
4540 wpa_supplicant_apply_he_overrides(wpa_s, ssid, ¶ms);
4542 wpa_supplicant_apply_eht_overrides(wpa_s, ssid, ¶ms);
4550 if (wpa_s->num_multichan_concurrent < 2) {
4552 num = get_shared_radio_freqs(wpa_s, &freq, 1, false);
4558 wpa_s, params.freq.freq, ssid) < 0) {
4559 wpas_connect_work_done(wpa_s);
4567 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
4572 params.sae_pwe = wpa_s->conf->sae_pwe;
4575 ret = wpa_drv_associate(wpa_s, ¶ms);
4579 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
4581 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_VALID_ERROR_CODES) {
4587 wpas_connection_failed(wpa_s, wpa_s->pending_bssid,
4589 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
4590 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
4598 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
4601 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
4604 wpa_supplicant_cancel_auth_timeout(wpa_s);
4605 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
4608 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
4609 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
4614 wpa_supplicant_cancel_auth_timeout(wpa_s);
4623 } else if (wpa_s->conf->ap_scan == 1) {
4627 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
4632 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
4634 wpa_set_wep_keys(wpa_s, ssid);
4643 eapol_sm_invalidate_cached_session(wpa_s->eapol);
4646 if (!wpas_driver_bss_selection(wpa_s) ||
4648 wpa_s->p2p_in_invitation ||
4651 wpa_s->current_bss = bss;
4653 hs20_configure_frame_filters(wpa_s);
4657 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
4659 wpa_sm_set_ssid(wpa_s->wpa, bss->ssid, bss->ssid_len);
4660 wpa_supplicant_initiate_eapol(wpa_s);
4661 if (old_ssid != wpa_s->current_ssid)
4662 wpas_notify_network_changed(wpa_s);
4663 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
4664 wpas_notify_auth_changed(wpa_s);
4668 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
4673 wpa_s->ml_connect_probe_ssid = NULL;
4674 wpa_s->ml_connect_probe_bss = NULL;
4675 wpas_connect_work_done(wpa_s);
4676 wpa_clear_keys(wpa_s, addr);
4677 old_ssid = wpa_s->current_ssid;
4678 wpa_supplicant_mark_disassoc(wpa_s);
4679 wpa_sm_set_config(wpa_s->wpa, NULL);
4680 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
4681 if (old_ssid != wpa_s->current_ssid)
4682 wpas_notify_network_changed(wpa_s);
4685 wpas_scs_deinit(wpa_s);
4686 wpas_dscp_deinit(wpa_s);
4688 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
4694 * @wpa_s: Pointer to wpa_supplicant data
4700 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
4707 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
4710 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
4712 wpa_supplicant_state_txt(wpa_s->wpa_state), wpa_s->valid_links,
4713 MAC2STR(wpa_s->ap_mld_addr));
4715 if (wpa_s->valid_links && !is_zero_ether_addr(wpa_s->ap_mld_addr))
4716 addr = wpa_s->ap_mld_addr;
4717 else if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
4718 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
4719 wpa_s->wpa_state == WPA_ASSOCIATING))
4720 addr = wpa_s->pending_bssid;
4721 else if (!is_zero_ether_addr(wpa_s->bssid))
4722 addr = wpa_s->bssid;
4723 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
4730 addr = wpa_s->bssid;
4734 if (wpa_s->enabled_4addr_mode && wpa_drv_set_4addr_mode(wpa_s, 0) == 0)
4735 wpa_s->enabled_4addr_mode = 0;
4738 wpa_tdls_teardown_peers(wpa_s->wpa);
4742 if (wpa_s->ifmsh) {
4745 mconf = wpa_s->ifmsh->mconf;
4746 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
4747 wpa_s->ifname);
4748 wpas_notify_mesh_group_removed(wpa_s, mconf->meshid,
4750 wpa_supplicant_leave_mesh(wpa_s, true);
4755 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
4759 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
4764 wpa_supplicant_clear_connection(wpa_s, addr);
4768 void wpa_supplicant_reconnect(struct wpa_supplicant *wpa_s)
4770 wpa_s->own_reconnect_req = 1;
4771 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_UNSPECIFIED);
4776 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
4784 wpas_clear_temp_disabled(wpa_s, ssid, 1);
4785 wpas_notify_network_enabled_changed(wpa_s, ssid);
4791 if (!wpa_s->current_ssid && !wpa_s->disconnected)
4792 wpa_s->reassociate = 1;
4798 * @wpa_s: wpa_supplicant structure for a network interface
4807 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s)
4811 ssid = wpa_config_add_network(wpa_s->conf);
4814 wpas_notify_network_added(wpa_s, ssid);
4824 * @wpa_s: wpa_supplicant structure for a network interface
4835 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id)
4837 struct wpa_ssid *ssid, *prev = wpa_s->current_ssid;
4840 ssid = wpa_config_get_network(wpa_s->conf, id);
4843 wpas_notify_network_removed(wpa_s, ssid);
4847 wpa_s->sme.prev_bssid_set = 0;
4853 eapol_sm_invalidate_cached_session(wpa_s->eapol);
4857 wpa_sm_set_config(wpa_s->wpa, NULL);
4858 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
4860 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
4861 wpa_s->own_disconnect_req = 1;
4862 wpa_supplicant_deauthenticate(wpa_s,
4868 if (wpa_config_remove_network(wpa_s->conf, id) < 0)
4871 if (!was_disabled && wpa_s->sched_scanning) {
4874 wpa_supplicant_cancel_sched_scan(wpa_s);
4875 wpa_supplicant_req_scan(wpa_s, 0, 0);
4884 * @wpa_s: wpa_supplicant structure for a network interface
4893 int wpa_supplicant_remove_all_networks(struct wpa_supplicant *wpa_s)
4897 if (wpa_s->drv_flags2 &
4900 wpa_drv_flush_pmkid(wpa_s);
4902 if (wpa_s->sched_scanning)
4903 wpa_supplicant_cancel_sched_scan(wpa_s);
4905 eapol_sm_invalidate_cached_session(wpa_s->eapol);
4906 if (wpa_s->current_ssid) {
4908 wpa_s->sme.prev_bssid_set = 0;
4910 wpa_sm_set_config(wpa_s->wpa, NULL);
4911 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
4912 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
4913 wpa_s->own_disconnect_req = 1;
4915 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
4917 ssid = wpa_s->conf->ssid;
4924 wpas_notify_network_removed(wpa_s, remove_ssid);
4925 wpa_config_remove_network(wpa_s->conf, id);
4933 * @wpa_s: wpa_supplicant structure for a network interface
4938 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
4942 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
4943 wpa_supplicant_enable_one_network(wpa_s, ssid);
4945 wpa_supplicant_enable_one_network(wpa_s, ssid);
4947 if (wpa_s->reassociate && !wpa_s->disconnected &&
4948 (!wpa_s->current_ssid ||
4949 wpa_s->wpa_state == WPA_DISCONNECTED ||
4950 wpa_s->wpa_state == WPA_SCANNING)) {
4951 if (wpa_s->sched_scanning) {
4954 wpa_supplicant_cancel_sched_scan(wpa_s);
4957 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
4958 wpa_s->scan_req = NORMAL_SCAN_REQ;
4959 wpa_supplicant_req_scan(wpa_s, 0, 0);
4967 * @wpa_s: wpa_supplicant structure for a network interface
4972 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
4979 if (wpa_s->sched_scanning)
4980 wpa_supplicant_cancel_sched_scan(wpa_s);
4982 for (other_ssid = wpa_s->conf->ssid; other_ssid;
4993 wpa_s, other_ssid);
4995 if (wpa_s->current_ssid) {
4996 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
4997 wpa_s->own_disconnect_req = 1;
4999 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
5002 if (ssid == wpa_s->current_ssid) {
5003 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
5004 wpa_s->own_disconnect_req = 1;
5006 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
5014 wpas_notify_network_enabled_changed(wpa_s, ssid);
5015 if (wpa_s->sched_scanning) {
5018 wpa_supplicant_cancel_sched_scan(wpa_s);
5019 wpa_supplicant_req_scan(wpa_s, 0, 0);
5028 * @wpa_s: wpa_supplicant structure for a network interface
5031 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
5038 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
5039 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
5040 wpa_s->own_disconnect_req = 1;
5042 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
5047 wpas_clear_temp_disabled(wpa_s, ssid, 1);
5053 for (other_ssid = wpa_s->conf->ssid; other_ssid;
5061 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
5064 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
5067 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
5068 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
5076 wpa_s->current_ssid = ssid;
5077 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
5078 wpa_s->connect_without_scan =
5086 os_free(wpa_s->next_scan_freqs);
5087 wpa_s->next_scan_freqs = NULL;
5089 wpa_s->connect_without_scan = NULL;
5092 wpa_s->disconnected = 0;
5093 wpa_s->reassociate = 1;
5094 wpa_s_clear_sae_rejected(wpa_s);
5095 wpa_s->last_owe_group = 0;
5098 wpa_s_setup_sae_pt(wpa_s->conf, ssid, false);
5101 if (wpa_s->connect_without_scan ||
5102 wpa_supplicant_fast_associate(wpa_s) != 1) {
5103 wpa_s->scan_req = NORMAL_SCAN_REQ;
5104 wpas_scan_reset_sched_scan(wpa_s);
5105 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
5109 wpas_notify_network_selected(wpa_s, ssid);
5116 * @wpa_s: wpa_supplicant structure for a network interface
5120 int wpas_remove_cred(struct wpa_supplicant *wpa_s, struct wpa_cred *cred)
5131 if (wpa_config_remove_cred(wpa_s->conf, id) < 0) {
5136 wpa_msg(wpa_s, MSG_INFO, CRED_REMOVED "%d", id);
5139 ssid = wpa_s->conf->ssid;
5147 if (wpa_supplicant_remove_network(wpa_s, ssid->id) ==
5164 * @wpa_s: wpa_supplicant structure for a network interface
5167 int wpas_remove_all_creds(struct wpa_supplicant *wpa_s)
5172 cred = wpa_s->conf->cred;
5176 res = wpas_remove_cred(wpa_s, prev);
5191 * @wpa_s: wpa_supplicant structure for a network interface
5200 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
5221 os_free(wpa_s->conf->pkcs11_engine_path);
5222 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
5225 os_free(wpa_s->conf->pkcs11_module_path);
5226 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
5229 wpa_sm_set_eapol(wpa_s->wpa, NULL);
5230 eapol_sm_deinit(wpa_s->eapol);
5231 wpa_s->eapol = NULL;
5232 if (wpa_supplicant_init_eapol(wpa_s)) {
5235 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
5240 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
5248 * @wpa_s: wpa_supplicant structure for a network interface
5253 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
5261 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
5267 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
5268 wpa_s->wpa_state >= WPA_ASSOCIATING &&
5269 wpa_s->wpa_state < WPA_COMPLETED) {
5271 "associating", wpa_s->conf->ap_scan, ap_scan);
5276 old_ap_scan = wpa_s->conf->ap_scan;
5277 wpa_s->conf->ap_scan = ap_scan;
5279 if (old_ap_scan != wpa_s->conf->ap_scan)
5280 wpas_notify_ap_scan_changed(wpa_s);
5288 * @wpa_s: wpa_supplicant structure for a network interface
5293 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
5297 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
5301 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
5303 wpa_s->conf->bss_expiration_age = bss_expire_age;
5311 * @wpa_s: wpa_supplicant structure for a network interface
5316 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
5320 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
5324 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
5326 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
5334 * @wpa_s: wpa_supplicant structure for a network interface
5339 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
5343 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
5347 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
5349 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
5398 static int owe_trans_ssid_match(struct wpa_supplicant *wpa_s, const u8 *bssid,
5408 bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
5434 * @wpa_s: Pointer to wpa_supplicant data
5437 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
5446 res = wpa_drv_get_ssid(wpa_s, ssid);
5448 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
5454 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
5455 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
5460 wired = wpa_s->conf->ap_scan == 0 &&
5461 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
5463 entry = wpa_s->conf->ssid;
5465 if (!wpas_network_disabled(wpa_s, entry) &&
5474 if (!wpas_network_disabled(wpa_s, entry) &&
5483 if (!wpas_network_disabled(wpa_s, entry) &&
5485 owe_trans_ssid_match(wpa_s, bssid, entry->ssid,
5492 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
5504 static int select_driver(struct wpa_supplicant *wpa_s, int i)
5506 struct wpa_global *global = wpa_s->global;
5517 wpa_s->driver = wpa_drivers[i];
5518 wpa_s->global_drv_priv = global->drv_priv[i];
5524 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
5531 if (wpa_s == NULL)
5535 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
5543 if (select_driver(wpa_s, i) == 0)
5562 if (select_driver(wpa_s, i) == 0)
5570 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
5577 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
5594 struct wpa_supplicant *wpa_s = ctx;
5595 const u8 *connected_addr = wpa_s->valid_links ?
5596 wpa_s->ap_mld_addr : wpa_s->bssid;
5598 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " (encrypted=%d)",
5602 if (wpa_s->own_disconnect_req) {
5609 wpa_msg_ctrl(wpa_s, MSG_INFO, "EAPOL-RX " MACSTR " %zu",
5611 if (wpa_s->ignore_auth_resp) {
5617 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
5618 (wpa_s->last_eapol_matches_bssid &&
5620 !wpa_s->ap_iface &&
5635 wpa_dbg(wpa_s, MSG_DEBUG,
5638 wpa_supplicant_state_txt(wpa_s->wpa_state),
5640 wpabuf_free(wpa_s->pending_eapol_rx);
5641 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
5642 if (wpa_s->pending_eapol_rx) {
5643 os_get_reltime(&wpa_s->pending_eapol_rx_time);
5644 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
5646 wpa_s->pending_eapol_encrypted = encrypted;
5651 wpa_s->last_eapol_matches_bssid =
5655 if (wpa_s->ap_iface) {
5656 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len,
5662 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
5663 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
5668 if (wpa_s->eapol_received == 0 &&
5669 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) ||
5670 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
5671 wpa_s->wpa_state != WPA_COMPLETED) &&
5672 (wpa_s->current_ssid == NULL ||
5673 wpa_s->current_ssid->mode != WPAS_MODE_IBSS)) {
5677 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
5678 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
5679 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
5685 if (wpa_s->current_ssid && wpa_s->current_bss &&
5686 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
5687 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
5696 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
5698 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
5704 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
5706 wpa_s->eapol_received++;
5708 if (wpa_s->countermeasures) {
5709 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
5715 if (wpa_s->current_ssid &&
5716 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
5717 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len,
5729 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
5730 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
5731 wpa_s->key_mgmt != WPA_KEY_MGMT_OWE &&
5732 wpa_s->key_mgmt != WPA_KEY_MGMT_DPP &&
5733 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len,
5736 wpa_drv_poll(wpa_s);
5737 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK))
5738 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len, encrypted);
5739 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
5746 eapol_sm_notify_portValid(wpa_s->eapol, true);
5759 static int wpas_eapol_needs_l2_packet(struct wpa_supplicant *wpa_s)
5761 return !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_CONTROL_PORT) ||
5762 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_CONTROL_PORT_RX);
5766 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
5770 os_memcpy(prev_mac_addr, wpa_s->own_addr, ETH_ALEN);
5772 if ((!wpa_s->p2p_mgmt ||
5773 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
5774 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
5775 l2_packet_deinit(wpa_s->l2);
5776 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
5777 wpa_drv_get_mac_addr(wpa_s),
5779 wpas_eapol_needs_l2_packet(wpa_s) ?
5781 wpa_s, 0);
5782 if (wpa_s->l2 == NULL)
5785 if (l2_packet_set_packet_filter(wpa_s->l2,
5787 wpa_dbg(wpa_s, MSG_DEBUG,
5790 if (l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
5791 wpa_msg(wpa_s, MSG_ERROR,
5796 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
5798 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
5801 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
5802 wpas_wps_update_mac_addr(wpa_s);
5805 if (wpa_s->fst)
5806 fst_update_mac_addr(wpa_s->fst, wpa_s->own_addr);
5809 if (!ether_addr_equal(prev_mac_addr, wpa_s->own_addr))
5810 wpas_notify_mac_address_changed(wpa_s);
5819 struct wpa_supplicant *wpa_s = ctx;
5826 if (!ether_addr_equal(eth->h_dest, wpa_s->own_addr) &&
5828 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
5834 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
5836 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
5841 int wpa_supplicant_update_bridge_ifname(struct wpa_supplicant *wpa_s,
5844 if (wpa_s->wpa_state > WPA_SCANNING)
5848 os_strlen(bridge_ifname) >= sizeof(wpa_s->bridge_ifname))
5854 if (os_strcmp(wpa_s->bridge_ifname, bridge_ifname) == 0)
5857 if (wpa_s->l2_br) {
5858 l2_packet_deinit(wpa_s->l2_br);
5859 wpa_s->l2_br = NULL;
5862 os_strlcpy(wpa_s->bridge_ifname, bridge_ifname,
5863 sizeof(wpa_s->bridge_ifname));
5865 if (wpa_s->bridge_ifname[0]) {
5866 wpa_dbg(wpa_s, MSG_DEBUG,
5868 wpa_s->bridge_ifname);
5869 wpa_s->l2_br = l2_packet_init_bridge(
5870 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
5871 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
5872 if (!wpa_s->l2_br) {
5873 wpa_msg(wpa_s, MSG_ERROR,
5875 wpa_s->bridge_ifname);
5881 if (!wpa_s->p2p_mgmt && wpa_tdls_init(wpa_s->wpa))
5887 wpa_s->bridge_ifname[0] = 0;
5888 if (wpa_s->l2_br) {
5889 l2_packet_deinit(wpa_s->l2_br);
5890 wpa_s->l2_br = NULL;
5893 if (!wpa_s->p2p_mgmt)
5894 wpa_tdls_init(wpa_s->wpa);
5902 * @wpa_s: Pointer to wpa_supplicant data
5909 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
5913 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
5916 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
5917 MAC2STR(wpa_s->own_addr));
5918 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
5919 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
5921 if (wpa_s->bridge_ifname[0] && wpas_eapol_needs_l2_packet(wpa_s)) {
5922 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
5923 "interface '%s'", wpa_s->bridge_ifname);
5924 wpa_s->l2_br = l2_packet_init_bridge(
5925 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
5926 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
5927 if (wpa_s->l2_br == NULL) {
5928 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
5930 wpa_s->bridge_ifname);
5935 if (wpa_s->conf->ap_scan == 2 &&
5936 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
5941 wpa_clear_keys(wpa_s, NULL);
5945 wpa_drv_set_countermeasures(wpa_s, 0);
5947 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
5948 wpa_drv_flush_pmkid(wpa_s);
5950 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
5951 wpa_s->prev_scan_wildcard = 0;
5953 if (wpa_supplicant_enabled_networks(wpa_s)) {
5954 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
5955 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
5959 if (!wpa_s->p2p_mgmt &&
5960 wpa_supplicant_delayed_sched_scan(wpa_s,
5963 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
5968 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
5984 struct wpa_supplicant *wpa_s;
5986 wpa_s = os_zalloc(sizeof(*wpa_s));
5987 if (wpa_s == NULL)
5989 wpa_s->scan_req = INITIAL_SCAN_REQ;
5990 wpa_s->scan_interval = 5;
5991 wpa_s->new_connection = 1;
5992 wpa_s->parent = parent ? parent : wpa_s;
5993 wpa_s->p2pdev = wpa_s->parent;
5994 wpa_s->sched_scanning = 0;
5995 wpa_s->setband_mask = WPA_SETBAND_AUTO;
5997 dl_list_init(&wpa_s->bss_tmp_disallowed);
5998 dl_list_init(&wpa_s->fils_hlp_req);
6000 dl_list_init(&wpa_s->drv_signal_override);
6001 wpa_s->test_assoc_comeback_type = -1;
6004 dl_list_init(&wpa_s->active_scs_ids);
6006 wpa_s->ml_probe_mld_id = -1;
6008 return wpa_s;
6014 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
6031 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
6040 wpa_msg(wpa_s, MSG_DEBUG,
6049 wpa_msg(wpa_s, MSG_ERROR,
6071 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
6081 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
6094 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
6102 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
6105 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
6118 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
6126 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
6129 wpa_msg(wpa_s, MSG_ERROR,
6143 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
6149 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
6158 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
6168 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
6181 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
6190 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
6203 static int wpa_set_tx_stbc(struct wpa_supplicant *wpa_s,
6213 wpa_msg(wpa_s, MSG_DEBUG, "set_tx_stbc: %d", tx_stbc);
6216 wpa_msg(wpa_s, MSG_ERROR,
6229 static int wpa_set_rx_stbc(struct wpa_supplicant *wpa_s,
6239 wpa_msg(wpa_s, MSG_DEBUG, "set_rx_stbc: %d", rx_stbc);
6242 wpa_msg(wpa_s, MSG_ERROR,
6256 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
6271 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
6272 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
6274 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
6275 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
6276 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
6277 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
6278 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
6279 wpa_set_rx_stbc(wpa_s, htcaps, htcaps_mask, ssid->rx_stbc);
6280 wpa_set_tx_stbc(wpa_s, htcaps, htcaps_mask, ssid->tx_stbc);
6294 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
6320 wpa_msg(wpa_s, MSG_DEBUG,
6334 wpa_set_ampdu_factor(wpa_s,
6371 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
6383 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
6393 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
6398 if (!wpa_s->conf->pcsc_reader)
6401 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
6402 if (!wpa_s->scard)
6405 if (wpa_s->conf->pcsc_pin &&
6406 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
6407 scard_deinit(wpa_s->scard);
6408 wpa_s->scard = NULL;
6409 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
6413 len = sizeof(wpa_s->imsi) - 1;
6414 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
6415 scard_deinit(wpa_s->scard);
6416 wpa_s->scard = NULL;
6417 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
6420 wpa_s->imsi[len] = '\0';
6422 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
6425 wpa_s->imsi, wpa_s->mnc_len);
6427 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
6428 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
6435 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
6439 ext_password_deinit(wpa_s->ext_pw);
6440 wpa_s->ext_pw = NULL;
6441 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
6443 if (!wpa_s->conf->ext_password_backend)
6446 val = os_strdup(wpa_s->conf->ext_password_backend);
6455 wpa_s->ext_pw = ext_password_init(val, pos);
6457 if (wpa_s->ext_pw == NULL) {
6461 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
6471 struct wpa_supplicant *wpa_s = ctx;
6473 return (is_zero_ether_addr(wpa_s->bssid) ||
6474 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
6482 struct wpa_supplicant *wpa_s = ctx;
6484 if (wpa_s->current_bss) {
6485 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
6487 } else if (wpa_s->hw.num_modes) {
6488 *hw_mode = wpa_s->hw.modes[0].mode;
6498 struct wpa_supplicant *wpa_s = ctx;
6500 *modes = wpa_s->hw.modes;
6501 return wpa_s->hw.num_modes;
6507 struct wpa_supplicant *wpa_s = ctx;
6510 wpa_s->fst_ies = fst_ies;
6516 struct wpa_supplicant *wpa_s = ctx;
6518 if (!ether_addr_equal(wpa_s->bssid, da)) {
6520 __func__, MAC2STR(wpa_s->bssid), MAC2STR(da));
6523 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
6524 wpa_s->own_addr, wpa_s->bssid,
6532 struct wpa_supplicant *wpa_s = ctx;
6534 WPA_ASSERT(ether_addr_equal(wpa_s->bssid, addr));
6535 return wpa_s->received_mb_ies;
6542 struct wpa_supplicant *wpa_s = ctx;
6545 WPA_ASSERT(ether_addr_equal(wpa_s->bssid, addr));
6548 wpabuf_free(wpa_s->received_mb_ies);
6549 wpa_s->received_mb_ies = mb_ies_by_info(&info);
6558 struct wpa_supplicant *wpa_s = ctx;
6561 if (!is_zero_ether_addr(wpa_s->bssid))
6562 return (wpa_s->received_mb_ies || !mb_only) ?
6563 wpa_s->bssid : NULL;
6575 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
6579 iface_obj->ctx = wpa_s;
6592 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
6598 if (!wpa_s->conf->wowlan_triggers)
6601 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
6603 ret = wpa_drv_wowlan(wpa_s, triggers);
6620 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
6634 for (i = 0; i < wpa_s->hw.num_modes; i++) {
6635 if (wpa_s->hw.modes[i].num_channels != 0) {
6636 if (wpa_s->hw.modes[i].mode ==
6638 wpa_s->hw.modes[i].mode ==
6641 else if (wpa_s->hw.modes[i].mode ==
6644 else if (wpa_s->hw.modes[i].mode ==
6647 else if (wpa_s->hw.modes[i].mode ==
6659 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
6662 struct wpa_supplicant *iface = wpa_s->global->ifaces;
6669 wpa_s->ifname, rn);
6670 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
6678 wpa_s->ifname, rn ? rn : "N/A");
6687 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
6695 if (work->wpa_s->scan_work == work) {
6697 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
6699 work->wpa_s->scan_work = NULL;
6703 if (work->wpa_s->p2p_scan_work == work) {
6705 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
6707 work->wpa_s->p2p_scan_work = NULL;
6712 work->wpa_s->radio->num_active_works--;
6713 wpa_dbg(work->wpa_s, MSG_DEBUG,
6716 work->wpa_s->radio->num_active_works);
6760 tmp->wpa_s->clear_driver_scan_cache))
6772 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
6792 if (active_work->wpa_s == tmp->wpa_s &&
6795 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
6816 tmp->wpa_s->clear_driver_scan_cache))
6819 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
6836 struct wpa_supplicant *wpa_s;
6844 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
6847 if (!(wpa_s &&
6848 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
6852 if (wpa_s && external_scan_running(wpa_s->radio)) {
6866 wpa_s = work->wpa_s;
6869 wpa_dbg(wpa_s, MSG_DEBUG,
6878 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
6880 radio_work_check_next(wpa_s);
6890 * @wpa_s: wpa_supplicant data
6895 void radio_remove_works(struct wpa_supplicant *wpa_s,
6899 struct wpa_radio *radio = wpa_s->radio;
6907 if (!remove_all && work->wpa_s != wpa_s)
6910 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
6917 radio_work_check_next(wpa_s);
6921 wpa_s, void *ctx)
6924 struct wpa_radio *radio = wpa_s->radio;
6929 wpa_dbg(wpa_s, MSG_DEBUG, "Free pending radio work '%s'@%p%s",
6937 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
6939 struct wpa_radio *radio = wpa_s->radio;
6945 wpa_s->ifname, radio->name);
6946 dl_list_del(&wpa_s->radio_list);
6947 radio_remove_works(wpa_s, NULL, 0);
6950 if (wpa_s == radio->external_scan_req_interface)
6952 wpa_s->radio = NULL;
6962 void radio_work_check_next(struct wpa_supplicant *wpa_s)
6964 struct wpa_radio *radio = wpa_s->radio;
6968 if (wpa_s->ext_work_in_progress) {
6980 * @wpa_s: Pointer to wpa_supplicant data
7003 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
7008 struct wpa_radio *radio = wpa_s->radio;
7015 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
7019 work->wpa_s = wpa_s;
7027 work->bands = wpas_get_bands(wpa_s,
7031 work->bands = wpas_get_bands(wpa_s, NULL);
7033 was_empty = dl_list_empty(&wpa_s->radio->work);
7035 dl_list_add(&wpa_s->radio->work, &work->list);
7037 dl_list_add_tail(&wpa_s->radio->work, &work->list);
7039 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
7040 radio_work_check_next(wpa_s);
7041 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
7043 wpa_dbg(wpa_s, MSG_DEBUG,
7046 radio_work_check_next(wpa_s);
7062 struct wpa_supplicant *wpa_s = work->wpa_s;
7068 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %jd.%06ld seconds",
7073 radio_work_check_next(wpa_s);
7078 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
7081 struct wpa_radio *radio = wpa_s->radio;
7084 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
7092 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
7099 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
7102 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
7103 if (wpa_s->drv_priv == NULL) {
7109 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
7116 if (wpa_s->matched == WPA_IFACE_MATCHED_NULL)
7119 wpa_msg(wpa_s, level, "Failed to initialize driver interface");
7122 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
7123 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
7124 "driver_param '%s'", wpa_s->conf->driver_param);
7128 ifname = wpa_drv_get_ifname(wpa_s);
7129 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
7130 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
7132 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
7135 rn = wpa_driver_get_radio_name(wpa_s);
7139 wpa_s->radio = radio_add_interface(wpa_s, rn);
7140 if (wpa_s->radio == NULL)
7149 static void wpas_gas_server_tx_status(struct wpa_supplicant *wpa_s,
7161 gas_server_tx_status(wpa_s->gas_server, dst, data, data_len,
7169 struct wpa_supplicant *wpa_s = ctx;
7172 if (wait_time > wpa_s->max_remain_on_chan)
7173 wait_time = wpa_s->max_remain_on_chan;
7175 offchannel_send_action(wpa_s, freq, da, wpa_s->own_addr, broadcast,
7182 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
7198 wpa_s->confname = os_rel2abs_path(iface->confname);
7199 if (wpa_s->confname == NULL) {
7206 iface->confname, wpa_s->confname);
7208 wpa_s->confname = os_strdup(iface->confname);
7210 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL, false);
7211 if (wpa_s->conf == NULL) {
7213 "configuration '%s'.", wpa_s->confname);
7216 wpa_s->confanother = os_rel2abs_path(iface->confanother);
7217 if (wpa_s->confanother &&
7218 !wpa_config_read(wpa_s->confanother, wpa_s->conf, true)) {
7221 wpa_s->confanother);
7230 os_free(wpa_s->conf->ctrl_interface);
7231 wpa_s->conf->ctrl_interface =
7233 if (!wpa_s->conf->ctrl_interface) {
7242 os_free(wpa_s->conf->driver_param);
7243 wpa_s->conf->driver_param =
7245 if (!wpa_s->conf->driver_param) {
7254 os_free(wpa_s->conf->ctrl_interface);
7255 wpa_s->conf->ctrl_interface = NULL;
7258 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
7261 if (wpa_s->conf == NULL) {
7270 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
7275 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
7277 wpa_s->matched = iface->matched;
7282 sizeof(wpa_s->bridge_ifname)) {
7287 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
7288 sizeof(wpa_s->bridge_ifname));
7292 eapol_sm_notify_portEnabled(wpa_s->eapol, false);
7293 eapol_sm_notify_portValid(wpa_s->eapol, false);
7299 if (wpas_init_driver(wpa_s, iface) < 0)
7302 if (wpa_supplicant_init_wpa(wpa_s) < 0)
7305 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
7306 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
7308 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
7310 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
7311 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
7312 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
7313 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
7318 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
7319 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
7320 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
7321 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
7326 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
7327 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
7328 wpa_s->conf->dot11RSNAConfigSATimeout)) {
7329 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
7334 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_FT_PREPEND_PMKID,
7335 wpa_s->conf->ft_prepend_pmkid);
7337 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
7338 &wpa_s->hw.num_modes,
7339 &wpa_s->hw.flags,
7341 if (wpa_s->hw.modes) {
7344 for (i = 0; i < wpa_s->hw.num_modes; i++) {
7345 if (wpa_s->hw.modes[i].vht_capab) {
7346 wpa_s->hw_capab = CAPAB_VHT;
7350 if (wpa_s->hw.modes[i].ht_capab &
7352 wpa_s->hw_capab = CAPAB_HT40;
7353 else if (wpa_s->hw.modes[i].ht_capab &&
7354 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
7355 wpa_s->hw_capab = CAPAB_HT;
7357 wpa_s->support_6ghz = wpas_is_6ghz_supported(wpa_s, false);
7360 capa_res = wpa_drv_get_capa(wpa_s, &capa);
7362 wpa_s->drv_capa_known = 1;
7363 wpa_s->drv_flags = capa.flags;
7364 wpa_s->drv_flags2 = capa.flags2;
7365 wpa_s->drv_enc = capa.enc;
7366 wpa_s->drv_rrm_flags = capa.rrm_flags;
7367 wpa_s->drv_max_acl_mac_addrs = capa.max_acl_mac_addrs;
7368 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
7369 wpa_s->max_scan_ssids = capa.max_scan_ssids;
7370 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
7371 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
7372 wpa_s->max_sched_scan_plan_interval =
7374 wpa_s->max_sched_scan_plan_iterations =
7376 wpa_s->sched_scan_supported = capa.sched_scan_supported;
7377 wpa_s->max_match_sets = capa.max_match_sets;
7378 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
7379 wpa_s->max_stations = capa.max_stations;
7380 wpa_s->extended_capa = capa.extended_capa;
7381 wpa_s->extended_capa_mask = capa.extended_capa_mask;
7382 wpa_s->extended_capa_len = capa.extended_capa_len;
7383 wpa_s->num_multichan_concurrent =
7386 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
7388 wpa_s->max_num_akms = capa.max_num_akms;
7391 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
7392 if (wpa_s->sched_scan_supported &&
7394 wpa_s->mac_addr_rand_supported |=
7397 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
7398 if (wpa_s->extended_capa &&
7399 wpa_s->extended_capa_len >= 3 &&
7400 wpa_s->extended_capa[2] & 0x40)
7401 wpa_s->multi_bss_support = 1;
7404 wpa_pasn_sm_set_caps(wpa_s->wpa, wpa_s->drv_flags2);
7406 wpa_sm_set_driver_bss_selection(wpa_s->wpa,
7407 !!(wpa_s->drv_flags &
7409 if (wpa_s->max_remain_on_chan == 0)
7410 wpa_s->max_remain_on_chan = 1000;
7417 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
7418 wpa_s->p2p_mgmt = iface->p2p_mgmt;
7420 if (wpa_s->num_multichan_concurrent == 0)
7421 wpa_s->num_multichan_concurrent = 1;
7423 if (wpa_supplicant_driver_init(wpa_s) < 0)
7427 if (!iface->p2p_mgmt && wpa_tdls_init(wpa_s->wpa))
7431 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
7432 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
7433 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
7438 if (wpa_s->conf->fst_group_id) {
7442 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
7443 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
7445 wpa_s->conf->fst_priority;
7446 cfg.llt = wpa_s->conf->fst_llt;
7448 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
7450 if (!wpa_s->fst) {
7451 wpa_msg(wpa_s, MSG_ERROR,
7453 wpa_s->ifname, cfg.group_id);
7459 if (wpas_wps_init(wpa_s))
7463 wpa_s->gas_server = gas_server_init(wpa_s, wpas_gas_server_tx);
7464 if (!wpa_s->gas_server) {
7471 if (wpas_dpp_init(wpa_s) < 0)
7476 if (wpas_nan_usd_init(wpa_s) < 0)
7480 if (wpa_supplicant_init_eapol(wpa_s) < 0)
7482 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
7484 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
7485 if (wpa_s->ctrl_iface == NULL) {
7494 wpa_s->conf->ctrl_interface);
7498 wpa_s->gas = gas_query_init(wpa_s);
7499 if (wpa_s->gas == NULL) {
7504 if ((!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) ||
7505 wpa_s->p2p_mgmt) &&
7506 wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
7507 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
7511 if (wpa_bss_init(wpa_s) < 0)
7516 dl_list_init(&wpa_s->mesh_external_pmksa_cache);
7525 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
7531 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, -1,
7532 wpa_s->imsi, &len);
7533 if (wpa_s->mnc_len > 0) {
7534 wpa_s->imsi[len] = '\0';
7536 wpa_s->imsi, wpa_s->mnc_len);
7543 if (pcsc_reader_init(wpa_s) < 0)
7546 if (wpas_init_ext_pw(wpa_s) < 0)
7550 wpas_rrm_reset(wpa_s);
7553 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
7556 hs20_init(wpa_s);
7559 if (!wpa_s->disable_mbo_oce && wpa_s->conf->oce) {
7560 if ((wpa_s->conf->oce & OCE_STA) &&
7561 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA))
7562 wpa_s->enable_oce = OCE_STA;
7563 if ((wpa_s->conf->oce & OCE_STA_CFON) &&
7564 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA_CFON)) {
7570 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
7573 wpa_supplicant_set_default_scan_ies(wpa_s);
7579 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
7582 struct wpa_global *global = wpa_s->global;
7585 if (wpa_s == wpa_s->parent)
7586 wpas_p2p_group_remove(wpa_s, "*");
7590 if (iface->p2pdev == wpa_s)
7592 if (iface == wpa_s || iface->parent != wpa_s) {
7598 iface->ifname, wpa_s->ifname);
7604 wpa_s->disconnected = 1;
7605 if (wpa_s->drv_priv) {
7610 if (!wpa_drv_get_wowlan(wpa_s) ||
7611 wpa_s->conf->wowlan_disconnect_on_deinit) {
7613 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
7615 wpa_drv_set_countermeasures(wpa_s, 0);
7616 wpa_clear_keys(wpa_s, NULL);
7618 wpa_msg(wpa_s, MSG_INFO,
7623 wpa_supplicant_cleanup(wpa_s);
7624 wpas_p2p_deinit_iface(wpa_s);
7626 wpas_ctrl_radio_work_flush(wpa_s);
7627 radio_remove_interface(wpa_s);
7630 if (wpa_s->fst) {
7631 fst_detach(wpa_s->fst);
7632 wpa_s->fst = NULL;
7634 if (wpa_s->received_mb_ies) {
7635 wpabuf_free(wpa_s->received_mb_ies);
7636 wpa_s->received_mb_ies = NULL;
7640 if (wpa_s->drv_priv)
7641 wpa_drv_deinit(wpa_s);
7644 wpas_notify_iface_removed(wpa_s);
7647 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
7649 wpa_supplicant_ctrl_iface_deinit(wpa_s, wpa_s->ctrl_iface);
7650 wpa_s->ctrl_iface = NULL;
7653 if (wpa_s->ifmsh) {
7654 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh, true);
7655 wpa_s->ifmsh = NULL;
7659 if (wpa_s->conf != NULL) {
7660 wpa_config_free(wpa_s->conf);
7661 wpa_s->conf = NULL;
7664 os_free(wpa_s->ssids_from_scan_req);
7665 os_free(wpa_s->last_scan_freqs);
7667 os_free(wpa_s);
7714 struct wpa_supplicant *wpa_s;
7724 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
7725 if (wpa_s)
7758 struct wpa_supplicant *wpa_s;
7765 wpa_s = wpa_supplicant_alloc(parent);
7766 if (wpa_s == NULL)
7769 wpa_s->global = global;
7786 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
7789 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
7795 if (wpas_notify_iface_added(wpa_s)) {
7796 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
7800 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
7801 wpas_notify_network_added(wpa_s, ssid);
7804 wpa_s->next = global->ifaces;
7805 global->ifaces = wpa_s;
7807 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
7808 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
7811 if (wpa_s->global->p2p == NULL &&
7812 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
7813 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
7815 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
7822 return wpa_s;
7829 * @wpa_s: Pointer to the network interface to be removed
7838 struct wpa_supplicant *wpa_s,
7843 unsigned int mesh_if_created = wpa_s->mesh_if_created;
7845 struct wpa_supplicant *parent = wpa_s->parent;
7850 if (prev == wpa_s) {
7851 global->ifaces = wpa_s->next;
7853 while (prev && prev->next != wpa_s)
7857 prev->next = wpa_s->next;
7860 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
7864 ifname = os_strdup(wpa_s->ifname);
7866 wpa_dbg(wpa_s, MSG_ERROR,
7873 if (global->p2p_group_formation == wpa_s)
7875 if (global->p2p_invite_group == wpa_s)
7877 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
7892 * @wpa_s: Pointer to the network interface
7895 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
7899 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
7900 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
7904 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
7921 struct wpa_supplicant *wpa_s;
7923 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7924 if (os_strcmp(wpa_s->ifname, ifname) == 0)
7925 return wpa_s;
7934 struct wpa_supplicant *wpa_s = ctx;
7935 if (wpa_s == NULL)
7937 return wpa_s->ifname;
7950 struct wpa_supplicant *wpa_s;
7960 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7961 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
7963 ap_periodic(wpa_s);
8170 struct wpa_supplicant *wpa_s;
8183 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
8184 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
8186 wpa_s->ctrl_iface);
8268 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
8270 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
8271 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
8273 country[0] = wpa_s->conf->country[0];
8274 country[1] = wpa_s->conf->country[1];
8276 if (wpa_drv_set_country(wpa_s, country) < 0) {
8282 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
8283 wpas_init_ext_pw(wpa_s);
8285 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
8286 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
8288 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WOWLAN_TRIGGERS) {
8290 int res = wpa_drv_get_capa(wpa_s, &capa);
8292 if (res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
8295 wpa_s->conf->wowlan_triggers);
8298 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DISABLE_BTM)
8299 wpa_supplicant_set_default_scan_ies(wpa_s);
8301 if (wpa_s->conf->changed_parameters & CFG_CHANGED_FT_PREPEND_PMKID)
8302 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_FT_PREPEND_PMKID,
8303 wpa_s->conf->ft_prepend_pmkid);
8311 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_BGSCAN) &&
8312 wpa_s->current_ssid && !wpa_s->current_ssid->bgscan &&
8313 wpa_s->wpa_state == WPA_COMPLETED)
8314 wpa_supplicant_reset_bgscan(wpa_s);
8318 wpas_wps_update_config(wpa_s);
8320 wpas_p2p_update_config(wpa_s);
8321 wpa_s->conf->changed_parameters = 0;
8339 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
8350 cbss = wpa_s->current_bss;
8352 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
8357 !wpa_bssid_ignore_is_listed(wpa_s, bss->bssid)) {
8373 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid,
8380 wpas_connect_work_done(wpa_s);
8385 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
8391 if (wpa_s->own_disconnect_req || wpa_s->own_reconnect_req) {
8392 wpa_s->own_disconnect_req = 0;
8393 wpa_dbg(wpa_s, MSG_DEBUG,
8397 if (wpa_s->disconnected) {
8398 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
8406 wpa_bssid_ignore_add(wpa_s, *link_bssids);
8414 count = wpa_bssid_ignore_add(wpa_s, bssid);
8415 if (count == 1 && wpa_s->current_bss) {
8422 freqs = get_bss_freqs_in_ess(wpa_s);
8424 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
8426 wpa_bssid_ignore_add(wpa_s, bssid);
8432 os_free(wpa_s->next_scan_freqs);
8433 wpa_s->next_scan_freqs = freqs;
8437 wpa_s->consecutive_conn_failures++;
8439 if (wpa_s->consecutive_conn_failures > 3 && wpa_s->current_ssid) {
8442 wpas_auth_failed(wpa_s, "CONN_FAILED", bssid);
8449 switch (wpa_s->consecutive_conn_failures) {
8467 wpa_dbg(wpa_s, MSG_DEBUG,
8469 wpa_s->consecutive_conn_failures, timeout);
8477 wpa_s->normal_scans = 0;
8478 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
8485 void fils_pmksa_cache_flush(struct wpa_supplicant *wpa_s)
8487 struct wpa_ssid *ssid = wpa_s->current_ssid;
8506 if (eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap,
8511 wpa_dbg(wpa_s, MSG_DEBUG,
8513 wpa_sm_aborted_external_cached(wpa_s->wpa);
8514 wpa_sm_external_pmksa_cache_flush(wpa_s->wpa, ssid);
8518 wpa_dbg(wpa_s, MSG_DEBUG, "FILS: Drop PMKSA cache entry");
8519 wpa_sm_aborted_cached(wpa_s->wpa);
8520 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
8524 void fils_connection_failure(struct wpa_supplicant *wpa_s)
8526 struct wpa_ssid *ssid = wpa_s->current_ssid;
8532 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap,
8542 os_free(wpa_s->last_con_fail_realm);
8543 wpa_s->last_con_fail_realm = os_malloc(realm_len);
8544 if (wpa_s->last_con_fail_realm) {
8545 wpa_s->last_con_fail_realm_len = realm_len;
8546 os_memcpy(wpa_s->last_con_fail_realm, realm, realm_len);
8552 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
8554 return wpa_s->conf->ap_scan == 2 ||
8555 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
8560 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
8580 if (ssid == wpa_s->current_ssid)
8581 wpa_s->reassociate = 1;
8590 if (ssid == wpa_s->current_ssid)
8591 wpa_s->reassociate = 1;
8600 if (ssid == wpa_s->current_ssid)
8601 wpa_s->reassociate = 1;
8609 if (ssid == wpa_s->current_ssid)
8610 wpa_s->reassociate = 1;
8628 if (ssid == wpa_s->current_ssid)
8629 wpa_s->reassociate = 1;
8644 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
8645 wpa_supplicant_req_scan(wpa_s, 0, 0);
8671 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
8678 if (wpa_s->p2p_mgmt)
8688 if (wpa_s->drv_capa_known)
8689 drv_enc = wpa_s->drv_enc;
8737 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
8740 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
8741 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
8765 if (wpa_s->conf->pmf == NO_MGMT_FRAME_PROTECTION &&
8770 return wpa_s->conf->pmf;
8778 bool wpas_is_sae_avoided(struct wpa_supplicant *wpa_s,
8782 return wpa_s->conf->sae_check_mfp &&
8785 wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION);
8790 int pmf_in_use(struct wpa_supplicant *wpa_s, const u8 *addr)
8792 if (wpa_s->current_ssid == NULL ||
8793 wpa_s->wpa_state < WPA_4WAY_HANDSHAKE)
8795 if (wpa_s->valid_links) {
8796 if (!ether_addr_equal(addr, wpa_s->ap_mld_addr) &&
8797 !wpas_ap_link_address(wpa_s, addr))
8800 if (!ether_addr_equal(addr, wpa_s->bssid))
8803 return wpa_sm_pmf_enabled(wpa_s->wpa);
8807 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
8809 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
8811 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
8817 void wpas_auth_failed(struct wpa_supplicant *wpa_s, const char *reason,
8820 struct wpa_ssid *ssid = wpa_s->current_ssid;
8837 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
8871 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
8881 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
8888 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
8900 wpa_bssid_ignore_add(wpa_s, ssid->disabled_due_to);
8906 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
8910 if (wpa_s->disallow_aps_bssid == NULL)
8913 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
8914 if (ether_addr_equal(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
8923 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
8928 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
8931 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
8932 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
8944 * @wpa_s: Pointer to the network interface
8950 void wpas_request_connection(struct wpa_supplicant *wpa_s)
8952 wpa_s->normal_scans = 0;
8953 wpa_s->scan_req = NORMAL_SCAN_REQ;
8954 wpa_supplicant_reinit_autoscan(wpa_s);
8955 wpa_s->disconnected = 0;
8956 wpa_s->reassociate = 1;
8957 wpa_s->last_owe_group = 0;
8959 if (wpa_supplicant_fast_associate(wpa_s) != 1)
8960 wpa_supplicant_req_scan(wpa_s, 0, 0);
8962 wpa_s->reattach = 0;
8968 * @wpa_s: Pointer to the network interface
8973 void wpas_request_disconnection(struct wpa_supplicant *wpa_s)
8976 wpa_s->sme.prev_bssid_set = 0;
8978 wpa_s->reassociate = 0;
8979 wpa_s->disconnected = 1;
8980 wpa_supplicant_cancel_sched_scan(wpa_s);
8981 wpa_supplicant_cancel_scan(wpa_s);
8982 wpas_abort_ongoing_scan(wpa_s);
8983 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
8984 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
8985 radio_remove_works(wpa_s, "connect", 0);
8986 radio_remove_works(wpa_s, "sme-connect", 0);
8987 wpa_s->roam_in_progress = false;
8989 wpa_s->bss_trans_mgmt_in_progress = false;
8994 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
9000 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
9004 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
9015 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
9024 wpa_dbg(wpa_s, MSG_DEBUG,
9028 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
9033 if (exclude_current && ifs == wpa_s)
9063 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
9072 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
9085 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len,
9097 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
9114 return wpa_s->p2pdev;
9117 return wpa_s;
9122 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
9130 if (wpa_s->vendor_elem[i]) {
9136 wpa_s->vendor_elem[i]);
9142 if (wpa_s->parent == wpa_s &&
9143 wpa_s->global->p2p &&
9144 !wpa_s->global->p2p_disabled)
9145 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
9150 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
9155 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
9156 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
9164 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
9165 wpabuf_free(wpa_s->vendor_elem[frame]);
9166 wpa_s->vendor_elem[frame] = NULL;
9169 wpa_s->vendor_elem[frame]->used -= len;
9171 wpas_vendor_elem_update(wpa_s);
9217 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
9222 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
9232 static int wpa_set_driver_tmp_disallow_list(struct wpa_supplicant *wpa_s)
9239 bssids = os_malloc(dl_list_len(&wpa_s->bss_tmp_disallowed) * ETH_ALEN);
9242 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed,
9248 ret = wpa_drv_set_bssid_tmp_disallow(wpa_s, num_bssid, bssids);
9256 struct wpa_supplicant *wpa_s = eloop_ctx;
9260 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed,
9263 remove_bss_tmp_disallowed_entry(wpa_s, tmp);
9264 wpa_set_driver_tmp_disallow_list(wpa_s);
9271 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
9276 bss = wpas_get_disallowed_bss(wpa_s, bssid);
9278 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss);
9290 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
9291 wpa_set_driver_tmp_disallow_list(wpa_s);
9296 wpa_s, bss);
9300 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s,
9305 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
9317 remove_bss_tmp_disallowed_entry(wpa_s, disallowed);
9318 wpa_set_driver_tmp_disallow_list(wpa_s);
9326 int wpas_enable_mac_addr_randomization(struct wpa_supplicant *wpa_s,
9343 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCAN,
9349 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCHED_SCAN,
9353 if (wpa_s->sched_scanning && !wpa_s->pno)
9354 wpas_scan_restart_sched_scan(wpa_s);
9358 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_PNO,
9362 if (wpa_s->pno) {
9363 wpas_stop_pno(wpa_s);
9364 wpas_start_pno(wpa_s);
9372 int wpas_disable_mac_addr_randomization(struct wpa_supplicant *wpa_s,
9375 wpas_mac_addr_rand_scan_clear(wpa_s, type);
9376 if (wpa_s->pno) {
9378 wpas_stop_pno(wpa_s);
9379 wpas_start_pno(wpa_s);
9381 } else if (wpa_s->sched_scanning && (type & MAC_ADDR_RAND_SCHED_SCAN)) {
9382 wpas_scan_restart_sched_scan(wpa_s);
9389 int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
9394 if (!wpa_s->driver->signal_poll)
9397 res = wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
9403 dl_list_for_each(dso, &wpa_s->drv_signal_override,
9405 if (!ether_addr_equal(wpa_s->bssid, dso->bssid))
9431 wpa_drv_get_scan_results(struct wpa_supplicant *wpa_s, const u8 *bssid)
9438 if (wpa_s->driver->get_scan_results)
9439 scan_res = wpa_s->driver->get_scan_results(wpa_s->drv_priv,
9441 else if (wpa_s->driver->get_scan_results2)
9442 scan_res = wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
9452 dl_list_for_each(dso, &wpa_s->drv_signal_override,
9476 bool wpas_ap_link_address(struct wpa_supplicant *wpa_s, const u8 *addr)
9480 if (!wpa_s->valid_links)
9483 for_each_link(wpa_s->valid_links, i) {
9484 if (ether_addr_equal(wpa_s->links[i].bssid, addr))
9492 int wpa_drv_send_action(struct wpa_supplicant *wpa_s, unsigned int freq,
9497 if (!wpa_s->driver->send_action)
9501 if (wpas_ap_link_address(wpa_s, dst))
9502 dst = wpa_s->ap_mld_addr;
9504 if (wpas_ap_link_address(wpa_s, bssid))
9505 bssid = wpa_s->ap_mld_addr;
9508 return wpa_s->driver->send_action(wpa_s->drv_priv, freq, wait, dst, src,
9513 bool wpas_is_6ghz_supported(struct wpa_supplicant *wpa_s, bool only_enabled)
9518 for (i = 0; i < wpa_s->hw.num_modes; i++) {
9519 if (wpa_s->hw.modes[i].mode == HOSTAPD_MODE_IEEE80211A) {
9520 chnl = wpa_s->hw.modes[i].channels;
9521 for (j = 0; j < wpa_s->hw.modes[i].num_channels; j++) {
Indexes created Sun Apr 12 00:22:20 UTC 2026