Lines Matching refs:wpa_s
61 static int wpas_select_network_from_last_scan(struct wpa_supplicant *wpa_s,
68 int wpas_temp_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
79 wpas_clear_temp_disabled(wpa_s, ssid, 0);
88 * @wpa_s: Pointer to wpa_supplicant data
96 static int wpas_reenabled_network_time(struct wpa_supplicant *wpa_s)
102 if (wpa_s->conf->auto_interworking && wpa_s->conf->interworking &&
103 wpa_s->conf->cred)
107 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
111 disabled_for = wpas_temp_disabled(wpa_s, ssid);
126 struct wpa_supplicant *wpa_s = eloop_ctx;
128 if (wpa_s->disconnected || wpa_s->wpa_state != WPA_SCANNING)
131 wpa_dbg(wpa_s, MSG_DEBUG,
133 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
134 wpa_supplicant_cancel_sched_scan(wpa_s);
135 wpa_supplicant_req_scan(wpa_s, 0, 0);
141 struct wpa_supplicant *wpa_s, const u8 *bssid, const u8 *ssid,
145 return wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
147 return wpa_bss_get_bssid(wpa_s, bssid);
152 struct wpa_supplicant *wpa_s, const u8 *bssid, const u8 *ssid,
155 struct wpa_bss *bss = __wpa_supplicant_get_new_bss(wpa_s, bssid, ssid,
161 wpa_supplicant_update_scan_results(wpa_s, bssid);
163 return __wpa_supplicant_get_new_bss(wpa_s, bssid, ssid, ssid_len);
168 struct wpa_supplicant *wpa_s, const u8 *bssid)
171 struct wpa_ssid *ssid = wpa_s->current_ssid;
176 res = wpa_drv_get_ssid(wpa_s, drv_ssid);
178 bss = _wpa_supplicant_get_new_bss(wpa_s, bssid, drv_ssid, res,
183 bss = _wpa_supplicant_get_new_bss(wpa_s, bssid, ssid->ssid,
189 bss = _wpa_supplicant_get_new_bss(wpa_s, bssid, NULL, 0,
197 wpa_supplicant_update_current_bss(struct wpa_supplicant *wpa_s, const u8 *bssid)
199 struct wpa_bss *bss = wpa_supplicant_get_new_bss(wpa_s, bssid);
202 wpa_s->current_bss = bss;
208 static void wpa_supplicant_update_link_bss(struct wpa_supplicant *wpa_s,
211 struct wpa_bss *bss = wpa_supplicant_get_new_bss(wpa_s, bssid);
214 wpa_s->links[link_id].bss = bss;
218 static int wpa_supplicant_select_config(struct wpa_supplicant *wpa_s,
227 if (wpa_s->conf->ap_scan == 1 && wpa_s->current_ssid) {
228 wpa_supplicant_update_current_bss(wpa_s, wpa_s->bssid);
230 if (wpa_s->current_ssid->ssid_len == 0)
232 res = wpa_drv_get_ssid(wpa_s, drv_ssid);
234 wpa_msg(wpa_s, MSG_INFO,
240 if (drv_ssid_len == wpa_s->current_ssid->ssid_len &&
241 os_memcmp(drv_ssid, wpa_s->current_ssid->ssid,
246 if ((wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_OWE) &&
247 wpa_s->current_bss &&
248 (wpa_s->current_bss->flags & WPA_BSS_OWE_TRANSITION) &&
249 drv_ssid_len == wpa_s->current_bss->ssid_len &&
250 os_memcmp(drv_ssid, wpa_s->current_bss->ssid,
255 wpa_msg(wpa_s, MSG_DEBUG,
261 wpa_dbg(wpa_s, MSG_DEBUG, "Select network based on association "
263 ssid = wpa_supplicant_get_ssid(wpa_s);
265 wpa_msg(wpa_s, MSG_INFO,
270 if (wpas_network_disabled(wpa_s, ssid)) {
271 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is disabled");
275 if (disallowed_bssid(wpa_s, wpa_s->bssid) ||
276 disallowed_ssid(wpa_s, ssid->ssid, ssid->ssid_len)) {
277 wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS is disallowed");
281 res = wpas_temp_disabled(wpa_s, ssid);
283 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is temporarily "
288 wpa_dbg(wpa_s, MSG_DEBUG, "Network configuration found for the "
290 bss = wpa_supplicant_update_current_bss(wpa_s, wpa_s->bssid);
300 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
303 wpa_dbg(wpa_s, MSG_DEBUG, "Could not set WPA suites");
305 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
308 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid)
309 eapol_sm_invalidate_cached_session(wpa_s->eapol);
310 old_ssid = wpa_s->current_ssid;
311 wpa_s->current_ssid = ssid;
313 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
314 wpa_supplicant_initiate_eapol(wpa_s);
315 if (old_ssid != wpa_s->current_ssid)
316 wpas_notify_network_changed(wpa_s);
324 struct wpa_supplicant *wpa_s = eloop_ctx;
326 if (wpa_s->countermeasures) {
327 wpa_s->countermeasures = 0;
328 wpa_drv_set_countermeasures(wpa_s, 0);
329 wpa_msg(wpa_s, MSG_INFO, "WPA: TKIP countermeasures stopped");
338 wpa_supplicant_cancel_sched_scan(wpa_s);
339 wpa_supplicant_req_scan(wpa_s, 0, 0);
344 void wpas_reset_mlo_info(struct wpa_supplicant *wpa_s)
346 if (!wpa_s->valid_links)
349 wpa_s->valid_links = 0;
350 wpa_s->mlo_assoc_link_id = 0;
351 os_memset(wpa_s->ap_mld_addr, 0, ETH_ALEN);
352 os_memset(wpa_s->links, 0, sizeof(wpa_s->links));
356 void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s)
360 wnm_bss_keep_alive_deinit(wpa_s);
363 ibss_rsn_deinit(wpa_s->ibss_rsn);
364 wpa_s->ibss_rsn = NULL;
368 wpa_supplicant_ap_deinit(wpa_s);
373 wpa_drv_configure_frame_filters(wpa_s, 0);
376 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
379 if (os_reltime_initialized(&wpa_s->session_start)) {
380 os_reltime_age(&wpa_s->session_start, &wpa_s->session_length);
381 wpa_s->session_start.sec = 0;
382 wpa_s->session_start.usec = 0;
383 wpas_notify_session_length(wpa_s);
386 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
387 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
388 os_memset(wpa_s->bssid, 0, ETH_ALEN);
389 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
390 sme_clear_on_disassoc(wpa_s);
391 wpa_s->current_bss = NULL;
392 wpa_s->assoc_freq = 0;
395 wpas_notify_bssid_changed(wpa_s);
397 eapol_sm_notify_portEnabled(wpa_s->eapol, false);
398 eapol_sm_notify_portValid(wpa_s->eapol, false);
399 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
400 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
401 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP || wpa_s->drv_authorized_port)
402 eapol_sm_notify_eap_success(wpa_s->eapol, false);
403 wpa_s->drv_authorized_port = 0;
404 wpa_s->ap_ies_from_associnfo = 0;
405 wpa_s->current_ssid = NULL;
406 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
407 wpa_s->key_mgmt = 0;
408 wpa_s->allowed_key_mgmts = 0;
411 wpas_rrm_reset(wpa_s);
413 wpa_s->wnmsleep_used = 0;
415 wpa_s->wnm_mode = 0;
417 wnm_clear_coloc_intf_reporting(wpa_s);
418 wpa_s->disable_mbo_oce = 0;
421 wpa_s->last_tk_alg = WPA_ALG_NONE;
422 os_memset(wpa_s->last_tk, 0, sizeof(wpa_s->last_tk));
424 wpa_s->ieee80211ac = 0;
426 if (wpa_s->enabled_4addr_mode && wpa_drv_set_4addr_mode(wpa_s, 0) == 0)
427 wpa_s->enabled_4addr_mode = 0;
429 wpa_s->wps_scan_done = false;
430 wpas_reset_mlo_info(wpa_s);
433 wpa_s->sme.bss_max_idle_period = 0;
436 wpa_s->ssid_verified = false;
437 wpa_s->bigtk_set = false;
441 static void wpa_find_assoc_pmkid(struct wpa_supplicant *wpa_s, bool authorized)
451 cur_pmksa = pmksa_cache_get_current(wpa_s->wpa);
453 pmksa_cache_clear_current(wpa_s->wpa);
455 if (wpa_sm_parse_own_wpa_ie(wpa_s->wpa, &ie) < 0 ||
460 pmksa_set = pmksa_cache_set_current(wpa_s->wpa,
465 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
467 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
472 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID from assoc IE %sfound from "
477 static void wpa_supplicant_event_pmkid_candidate(struct wpa_supplicant *wpa_s,
481 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: No data in PMKID candidate "
485 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID candidate event - bssid=" MACSTR
491 pmksa_candidate_add(wpa_s->wpa, data->pmkid_candidate.bssid,
497 static int wpa_supplicant_dynamic_keys(struct wpa_supplicant *wpa_s)
499 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
500 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
504 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
505 wpa_s->current_ssid &&
506 !(wpa_s->current_ssid->eapol_flags &
521 * @wpa_s: pointer to wpa_supplicant data
528 int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s,
536 wpa_s->scard != NULL || wpa_s->conf->external_sim)
565 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to "
571 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to use SIM "
574 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
575 if (wpa_s->scard == NULL) {
576 wpa_msg(wpa_s, MSG_WARNING, "Failed to initialize SIM "
580 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
581 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
648 static int wpa_supplicant_ssid_bss_match(struct wpa_supplicant *wpa_s,
661 ret = wpas_wps_ssid_bss_match(wpa_s, ssid, bss);
676 wpa_dbg(wpa_s, MSG_DEBUG,
686 wpa_dbg(wpa_s, MSG_DEBUG,
710 wpa_dbg(wpa_s, MSG_DEBUG,
719 wpa_dbg(wpa_s, MSG_DEBUG,
726 wpa_dbg(wpa_s, MSG_DEBUG,
733 wpa_dbg(wpa_s, MSG_DEBUG,
741 wpa_dbg(wpa_s, MSG_DEBUG,
750 wpa_dbg(wpa_s, MSG_DEBUG,
763 wpa_dbg(wpa_s, MSG_DEBUG,
769 wpas_get_ssid_pmf(wpa_s, ssid) ==
772 wpa_dbg(wpa_s, MSG_DEBUG,
777 wpas_get_ssid_pmf(wpa_s, ssid) ==
780 wpa_dbg(wpa_s, MSG_DEBUG,
786 wpa_dbg(wpa_s, MSG_DEBUG,
793 wpa_dbg(wpa_s, MSG_DEBUG,
800 if (wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED &&
805 wpa_s->owe_transition_select &&
811 wpa_dbg(wpa_s, MSG_DEBUG,
815 wpa_s->owe_transition_search = 1;
820 wpa_dbg(wpa_s, MSG_DEBUG,
830 wpa_dbg(wpa_s, MSG_DEBUG,
840 wpa_dbg(wpa_s, MSG_DEBUG,
848 wpa_dbg(wpa_s, MSG_DEBUG,
855 wpa_dbg(wpa_s, MSG_DEBUG,
862 wpa_dbg(wpa_s, MSG_DEBUG,
869 wpa_dbg(wpa_s, MSG_DEBUG,
875 wpa_dbg(wpa_s, MSG_DEBUG,
883 wpa_dbg(wpa_s, MSG_DEBUG,
891 if (wpa_s->owe_transition_select &&
897 wpa_dbg(wpa_s, MSG_DEBUG,
901 wpa_s->owe_transition_search = 1;
905 wpa_dbg(wpa_s, MSG_DEBUG,
914 wpa_dbg(wpa_s, MSG_DEBUG,
922 wpa_dbg(wpa_s, MSG_DEBUG, " allow in OSEN");
928 wpa_dbg(wpa_s, MSG_DEBUG, " allow in non-WPA/WPA2");
933 wpa_dbg(wpa_s, MSG_DEBUG,
954 static int rate_match(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
965 modes = wpa_s->hw.modes;
975 for (i = 0; i < wpa_s->hw.num_modes; i++) {
1013 wpa_dbg(wpa_s, MSG_DEBUG,
1025 wpa_dbg(wpa_s, MSG_DEBUG,
1036 wpa_dbg(wpa_s, MSG_DEBUG,
1046 if (wpa_s->conf->sae_pwe ==
1052 wpa_dbg(wpa_s, MSG_DEBUG,
1055 if (wpa_s->ignore_sae_h2e_only) {
1056 wpa_dbg(wpa_s, MSG_DEBUG,
1082 wpa_dbg(wpa_s, MSG_DEBUG,
1138 static void owe_trans_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
1162 wpa_dbg(wpa_s, MSG_DEBUG, "OWE: transition mode BSSID: " MACSTR
1170 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1171 if (wpas_network_disabled(wpa_s, ssid))
1177 wpa_dbg(wpa_s, MSG_DEBUG,
1188 static bool wpas_valid_ml_bss(struct wpa_supplicant *wpa_s, struct wpa_bss *bss)
1192 if (wpa_bss_parse_basic_ml_element(wpa_s, bss, NULL, NULL, NULL, NULL))
1199 removed_links = wpa_bss_parse_reconf_ml_element(wpa_s, bss);
1207 int disabled_freq(struct wpa_supplicant *wpa_s, int freq)
1211 if (!wpa_s->hw.modes || !wpa_s->hw.num_modes)
1214 for (j = 0; j < wpa_s->hw.num_modes; j++) {
1215 struct hostapd_hw_modes *mode = &wpa_s->hw.modes[j];
1229 static bool wpa_scan_res_ok(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
1236 static bool sae_pk_acceptable_bss_with_pk(struct wpa_supplicant *wpa_s,
1244 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1260 count = wpa_bssid_ignore_is_listed(wpa_s, bss->bssid);
1261 if (wpa_scan_res_ok(wpa_s, ssid, match_ssid, match_ssid_len,
1271 static bool wpa_scan_res_ok(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
1305 if (wpas_network_disabled(wpa_s, ssid)) {
1307 wpa_dbg(wpa_s, MSG_DEBUG, " skip - disabled");
1311 res = wpas_temp_disabled(wpa_s, ssid);
1314 wpa_dbg(wpa_s, MSG_DEBUG,
1323 wpa_dbg(wpa_s, MSG_DEBUG,
1329 wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))
1336 !wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss);
1348 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID mismatch");
1355 wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID mismatch");
1364 wpa_dbg(wpa_s, MSG_DEBUG,
1374 wpa_dbg(wpa_s, MSG_DEBUG,
1379 if (!wpa_supplicant_ssid_bss_match(wpa_s, ssid, bss, debug_print))
1388 wpa_dbg(wpa_s, MSG_DEBUG,
1396 wpa_dbg(wpa_s, MSG_DEBUG,
1404 wpa_dbg(wpa_s, MSG_DEBUG,
1411 wpa_dbg(wpa_s, MSG_DEBUG, " skip - privacy mismatch");
1418 wpa_dbg(wpa_s, MSG_DEBUG,
1425 wpa_dbg(wpa_s, MSG_DEBUG,
1433 wpa_dbg(wpa_s, MSG_DEBUG,
1442 wpa_dbg(wpa_s, MSG_DEBUG,
1448 if (!rate_match(wpa_s, ssid, bss, debug_print)) {
1450 wpa_dbg(wpa_s, MSG_DEBUG,
1458 if ((wpa_s->conf->sae_pwe == SAE_PWE_HASH_TO_ELEMENT ||
1460 wpa_s->conf->sae_pwe != SAE_PWE_FORCE_HUNT_AND_PECK &&
1464 wpa_dbg(wpa_s, MSG_DEBUG,
1474 wpa_dbg(wpa_s, MSG_DEBUG,
1484 wpa_dbg(wpa_s, MSG_DEBUG,
1495 wpa_dbg(wpa_s, MSG_DEBUG, " skip - no P2P IE seen");
1506 wpa_dbg(wpa_s, MSG_DEBUG,
1513 wpa_dbg(wpa_s, MSG_DEBUG,
1521 wpa_dbg(wpa_s, MSG_DEBUG,
1536 if (os_reltime_before(&bss->last_update, &wpa_s->scan_min_time)) {
1539 os_reltime_sub(&wpa_s->scan_min_time, &bss->last_update, &diff);
1541 wpa_dbg(wpa_s, MSG_DEBUG,
1549 if (wpa_s->ignore_assoc_disallow)
1555 wpa_dbg(wpa_s, MSG_DEBUG,
1561 if (wpa_is_bss_tmp_disallowed(wpa_s, bss)) {
1563 wpa_dbg(wpa_s, MSG_DEBUG,
1574 !wpa_sm_pmksa_exists(wpa_s->wpa, bss->bssid, wpa_s->own_addr,
1579 wpa_dbg(wpa_s, MSG_DEBUG,
1593 sae_pk_acceptable_bss_with_pk(wpa_s, bss, ssid, match_ssid,
1596 wpa_dbg(wpa_s, MSG_DEBUG,
1607 owe_trans_ssid(wpa_s, bss, &owe_ssid, &owe_ssid_len);
1612 wpa_dbg(wpa_s, MSG_DEBUG,
1614 int_array_add_unique(&wpa_s->owe_trans_scan_freq,
1620 wpa_dbg(wpa_s, MSG_DEBUG,
1625 if (!wpas_valid_ml_bss(wpa_s, bss)) {
1627 wpa_dbg(wpa_s, MSG_DEBUG,
1637 struct wpa_ssid * wpa_scan_res_match(struct wpa_supplicant *wpa_s,
1660 wpa_dbg(wpa_s, MSG_DEBUG, "%d: " MACSTR
1674 bssid_ignore_count = wpa_bssid_ignore_is_listed(wpa_s, bss->bssid);
1677 if (wpa_supplicant_enabled_networks(wpa_s) == 1) {
1690 wpa_dbg(wpa_s, MSG_DEBUG,
1700 owe_trans_ssid(wpa_s, bss, &match_ssid, &match_ssid_len);
1704 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID not known");
1708 if (disallowed_bssid(wpa_s, bss->bssid)) {
1710 wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID disallowed");
1714 if (disallowed_ssid(wpa_s, match_ssid, match_ssid_len)) {
1716 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID disallowed");
1720 if (disabled_freq(wpa_s, bss->freq)) {
1722 wpa_dbg(wpa_s, MSG_DEBUG, " skip - channel disabled");
1726 if (wnm_is_bss_excluded(wpa_s, bss)) {
1728 wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID excluded");
1733 if (wpa_scan_res_ok(wpa_s, ssid, match_ssid, match_ssid_len,
1744 wpa_supplicant_select_bss(struct wpa_supplicant *wpa_s,
1751 if (wpa_s->current_ssid) {
1754 wpa_dbg(wpa_s, MSG_DEBUG,
1756 for (i = 0; i < wpa_s->last_scan_res_used; i++) {
1757 struct wpa_bss *bss = wpa_s->last_scan_res[i];
1759 ssid = wpa_scan_res_match(wpa_s, i, bss, group,
1761 if (ssid != wpa_s->current_ssid)
1763 wpa_dbg(wpa_s, MSG_DEBUG, "%u: " MACSTR
1771 wpa_dbg(wpa_s, MSG_DEBUG, "Try to find BSS matching pre-selected network id=%d",
1774 wpa_dbg(wpa_s, MSG_DEBUG, "Selecting BSS from priority group %d",
1777 for (i = 0; i < wpa_s->last_scan_res_used; i++) {
1778 struct wpa_bss *bss = wpa_s->last_scan_res[i];
1780 wpa_s->owe_transition_select = 1;
1781 *selected_ssid = wpa_scan_res_match(wpa_s, i, bss, group,
1783 wpa_s->owe_transition_select = 0;
1786 wpa_dbg(wpa_s, MSG_DEBUG, " selected %sBSS " MACSTR
1788 bss == wpa_s->current_bss ? "current ": "",
1798 struct wpa_bss * wpa_supplicant_pick_network(struct wpa_supplicant *wpa_s,
1806 if (wpa_s->last_scan_res == NULL ||
1807 wpa_s->last_scan_res_used == 0)
1810 if (wpa_s->next_ssid) {
1812 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1813 if (ssid == wpa_s->next_ssid)
1817 wpa_s->next_ssid = NULL;
1821 for (prio = 0; prio < wpa_s->conf->num_prio; prio++) {
1823 wpa_s->conf->pssid[prio]->priority) {
1825 wpa_s, next_ssid, selected_ssid, 1);
1830 wpa_s, wpa_s->conf->pssid[prio],
1837 (wpa_s->bssid_ignore || wnm_active_bss_trans_mgmt(wpa_s)) &&
1838 !wpa_s->countermeasures) {
1839 wpa_dbg(wpa_s, MSG_DEBUG,
1841 wnm_btm_reset(wpa_s);
1842 wpa_bssid_ignore_clear(wpa_s);
1843 wpa_s->bssid_ignore_cleared = true;
1853 wpa_dbg(wpa_s, MSG_DEBUG,
1856 wpas_notify_network_request(wpa_s, ssid,
1864 wpas_send_ctrl_req(wpa_s, ssid, field_name, txt);
1873 static void wpa_supplicant_req_new_scan(struct wpa_supplicant *wpa_s,
1876 if (!wpa_supplicant_enabled_networks(wpa_s)) {
1882 wpa_dbg(wpa_s, MSG_DEBUG, "Short-circuit new scan request "
1884 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
1888 wpa_s->scan_for_connection = 1;
1889 wpa_supplicant_req_scan(wpa_s, timeout_sec, timeout_usec);
1893 static bool ml_link_probe_scan(struct wpa_supplicant *wpa_s)
1895 if (!wpa_s->ml_connect_probe_ssid || !wpa_s->ml_connect_probe_bss)
1898 wpa_msg(wpa_s, MSG_DEBUG,
1900 MAC2STR(wpa_s->ml_connect_probe_bss->bssid));
1902 wpa_supplicant_associate(wpa_s, wpa_s->ml_connect_probe_bss,
1903 wpa_s->ml_connect_probe_ssid);
1905 wpa_s->ml_connect_probe_ssid = NULL;
1906 wpa_s->ml_connect_probe_bss = NULL;
1912 static int wpa_supplicant_connect_ml_missing(struct wpa_supplicant *wpa_s,
1920 if (!((wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_MLO) &&
1921 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)))
1924 if (wpa_bss_parse_basic_ml_element(wpa_s, selected, NULL,
1930 removed_links = wpa_bss_parse_reconf_ml_element(wpa_s, selected);
1936 wpa_dbg(wpa_s, MSG_DEBUG,
1944 wpa_s->ml_connect_probe_ssid = ssid;
1945 wpa_s->ml_connect_probe_bss = selected;
1950 wpa_s->manual_scan_passive = 0;
1951 wpa_s->manual_scan_use_id = 0;
1952 wpa_s->manual_scan_only_new = 0;
1953 wpa_s->scan_id_count = 0;
1954 os_free(wpa_s->manual_scan_freqs);
1955 wpa_s->manual_scan_freqs = freqs;
1957 os_memcpy(wpa_s->ml_probe_bssid, selected->bssid, ETH_ALEN);
1967 wpa_s->ml_probe_mld_id = -1;
1969 wpa_s->ml_probe_mld_id = 0;
1972 os_free(wpa_s->ssids_from_scan_req);
1973 wpa_s->num_ssids_from_scan_req = 0;
1975 wpa_s->ssids_from_scan_req =
1977 if (wpa_s->ssids_from_scan_req) {
1981 wpa_s->num_ssids_from_scan_req = 1;
1982 wpa_s->ssids_from_scan_req[0].ssid_len = ssid->ssid_len;
1983 os_memcpy(wpa_s->ssids_from_scan_req[0].ssid,
1988 wpa_s->ml_probe_links = missing_links;
1990 wpa_s->normal_scans = 0;
1991 wpa_s->scan_req = MANUAL_SCAN_REQ;
1992 wpa_s->after_wps = 0;
1993 wpa_s->known_wps_freq = 0;
1994 wpa_supplicant_req_scan(wpa_s, 0, 0);
2000 int wpa_supplicant_connect(struct wpa_supplicant *wpa_s,
2006 wpas_wps_partner_link_overlap_detect(wpa_s)) ||
2007 wpas_wps_scan_pbc_overlap(wpa_s, selected, ssid)) {
2008 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_OVERLAP
2010 wpas_notify_wps_event_pbc_overlap(wpa_s);
2011 wpa_s->wps_overlap = true;
2013 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
2014 wpa_s->p2p_in_provisioning) {
2016 wpa_s, NULL);
2022 wpas_wps_pbc_overlap(wpa_s);
2023 wpas_wps_cancel(wpa_s);
2029 wpa_msg(wpa_s, MSG_DEBUG,
2033 wpa_s->reassociate, MAC2STR(selected->bssid),
2034 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
2035 wpa_supplicant_state_txt(wpa_s->wpa_state),
2036 ssid, wpa_s->current_ssid);
2043 if (wpa_s->reassociate ||
2044 (!ether_addr_equal(selected->bssid, wpa_s->bssid) &&
2045 ((wpa_s->wpa_state != WPA_ASSOCIATING &&
2046 wpa_s->wpa_state != WPA_AUTHENTICATING) ||
2047 (!is_zero_ether_addr(wpa_s->pending_bssid) &&
2048 !ether_addr_equal(selected->bssid, wpa_s->pending_bssid)) ||
2049 (is_zero_ether_addr(wpa_s->pending_bssid) &&
2050 ssid != wpa_s->current_ssid)))) {
2051 if (wpa_supplicant_scard_init(wpa_s, ssid)) {
2052 wpa_supplicant_req_new_scan(wpa_s, 10, 0);
2056 if (wpa_supplicant_connect_ml_missing(wpa_s, selected, ssid))
2059 wpa_msg(wpa_s, MSG_DEBUG, "Request association with " MACSTR,
2061 wpa_supplicant_associate(wpa_s, selected, ssid);
2063 wpa_dbg(wpa_s, MSG_DEBUG, "Already associated or trying to "
2072 wpa_supplicant_pick_new_network(struct wpa_supplicant *wpa_s)
2077 for (prio = 0; prio < wpa_s->conf->num_prio; prio++) {
2078 for (ssid = wpa_s->conf->pssid[prio]; ssid; ssid = ssid->pnext)
2080 if (wpas_network_disabled(wpa_s, ssid))
2086 wpa_msg(wpa_s, MSG_INFO,
2106 struct wpa_supplicant *wpa_s)
2110 if (rsn_preauth_scan_results(wpa_s->wpa) < 0)
2113 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
2124 rsn_preauth_scan_result(wpa_s->wpa, bss->bssid, ssid, rsn);
2148 wpas_get_est_throughput_from_bss_snr(const struct wpa_supplicant *wpa_s,
2156 return wpas_get_est_tpt(wpa_s, ies, ie_len, rate, snr, bss->freq,
2171 int wpa_supplicant_need_to_roam_within_ess(struct wpa_supplicant *wpa_s,
2190 wpa_dbg(wpa_s, MSG_DEBUG, "Considering within-ESS reassociation");
2191 wpa_dbg(wpa_s, MSG_DEBUG, "Current BSS: " MACSTR
2196 wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS: " MACSTR
2201 if (wpas_ap_link_address(wpa_s, selected->bssid)) {
2202 wpa_dbg(wpa_s, MSG_DEBUG, "MLD: associated to selected BSS");
2206 if (wpa_s->current_ssid->bssid_set &&
2207 ether_addr_equal(selected->bssid, wpa_s->current_ssid->bssid)) {
2208 wpa_dbg(wpa_s, MSG_DEBUG, "Allow reassociation - selected BSS "
2228 if (wpa_drv_signal_poll(wpa_s, &si) == 0 &&
2242 cur_est = wpas_get_est_throughput_from_bss_snr(wpa_s,
2245 wpa_dbg(wpa_s, MSG_DEBUG,
2267 wpa_dbg(wpa_s, MSG_DEBUG,
2279 wpa_dbg(wpa_s, MSG_DEBUG, "Skip roam - Current BSS has better "
2285 wpa_dbg(wpa_s, MSG_DEBUG,
2291 wpa_dbg(wpa_s, MSG_DEBUG,
2330 if (wpa_s->signal_threshold && cur_level <= wpa_s->signal_threshold &&
2331 sel_level > wpa_s->signal_threshold)
2335 wpa_dbg(wpa_s, MSG_DEBUG,
2340 wpa_dbg(wpa_s, MSG_DEBUG,
2345 wpa_msg_ctrl(wpa_s, MSG_INFO, "%scur_bssid=" MACSTR
2359 static int wpa_supplicant_need_to_roam(struct wpa_supplicant *wpa_s,
2366 if (wpa_s->reassociate)
2368 if (wpa_s->wpa_state < WPA_ASSOCIATED)
2370 if (wpa_s->current_ssid == NULL)
2372 if (wpa_s->current_ssid != ssid)
2375 if (wpas_driver_bss_selection(wpa_s))
2378 if (wpa_s->valid_links)
2379 bssid = wpa_s->links[wpa_s->mlo_assoc_link_id].bssid;
2381 bssid = wpa_s->bssid;
2383 if (wpa_s->current_ssid->ssid)
2384 current_bss = wpa_bss_get(wpa_s, bssid,
2385 wpa_s->current_ssid->ssid,
2386 wpa_s->current_ssid->ssid_len);
2388 current_bss = wpa_bss_get_bssid(wpa_s, bssid);
2400 return wpa_supplicant_need_to_roam_within_ess(wpa_s, current_bss,
2417 static int _wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
2430 if (wpa_s->ap_iface)
2434 trigger_6ghz_scan = wpa_s->crossed_6ghz_dom &&
2435 wpa_s->last_scan_all_chan;
2436 wpa_s->crossed_6ghz_dom = false;
2437 wpa_s->last_scan_all_chan = false;
2439 wpa_s, 0);
2441 scan_res = wpa_supplicant_get_scan_results(wpa_s,
2445 if (wpa_s->conf->ap_scan == 2 || ap ||
2446 wpa_s->scan_res_handler == scan_only_handler)
2452 if (wpa_s->scan_res_fail_handler) {
2453 void (*handler)(struct wpa_supplicant *wpa_s);
2455 handler = wpa_s->scan_res_fail_handler;
2456 wpa_s->scan_res_fail_handler = NULL;
2457 handler(wpa_s);
2459 wpa_dbg(wpa_s, MSG_DEBUG,
2461 wpa_supplicant_req_new_scan(wpa_s, 1, 0);
2489 if (own_request && wpa_s->scan_res_handler &&
2491 void (*scan_res_handler)(struct wpa_supplicant *wpa_s,
2494 scan_res_handler = wpa_s->scan_res_handler;
2495 wpa_s->scan_res_handler = NULL;
2496 scan_res_handler(wpa_s, scan_res);
2501 wpa_dbg(wpa_s, MSG_DEBUG, "New scan results available (own=%u ext=%u)",
2502 wpa_s->own_scan_running,
2504 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
2505 wpa_s->manual_scan_use_id && wpa_s->own_scan_running &&
2507 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS "id=%u",
2508 wpa_s->manual_scan_id);
2509 wpa_s->manual_scan_use_id = 0;
2511 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS);
2513 wpas_notify_scan_results(wpa_s);
2515 wpas_notify_scan_done(wpa_s, 1);
2518 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore scan results in AP mode");
2520 if (wpa_s->ap_iface->scan_cb)
2521 wpa_s->ap_iface->scan_cb(wpa_s->ap_iface);
2527 wpa_dbg(wpa_s, MSG_DEBUG, "Do not use results from externally requested scan operation for network selection");
2532 if (wnm_scan_process(wpa_s, false) > 0)
2535 if (sme_proc_obss_scan(wpa_s) > 0)
2540 wpas_beacon_rep_scan_process(wpa_s, scan_res, &data->scan_info) > 0)
2544 if (ml_link_probe_scan(wpa_s))
2547 if ((wpa_s->conf->ap_scan == 2 && !wpas_wps_searching(wpa_s)))
2550 if (autoscan_notify_scan(wpa_s, scan_res))
2553 if (wpa_s->disconnected) {
2554 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2558 if (!wpas_driver_bss_selection(wpa_s) &&
2559 bgscan_notify_scan(wpa_s, scan_res) == 1)
2562 wpas_wps_update_ap_info(wpa_s, scan_res);
2564 if (wpa_s->wpa_state >= WPA_AUTHENTICATING &&
2565 wpa_s->wpa_state < WPA_COMPLETED)
2570 if (own_request && wpa_s->scan_work) {
2571 struct wpa_radio_work *work = wpa_s->scan_work;
2572 wpa_s->scan_work = NULL;
2576 os_free(wpa_s->last_scan_freqs);
2577 wpa_s->last_scan_freqs = NULL;
2578 wpa_s->num_last_scan_freqs = 0;
2581 wpa_s->last_scan_freqs = os_malloc(sizeof(int) *
2583 if (wpa_s->last_scan_freqs) {
2584 os_memcpy(wpa_s->last_scan_freqs,
2587 wpa_s->num_last_scan_freqs = data->scan_info.num_freqs;
2591 if (wpa_s->supp_pbc_active && !wpas_wps_partner_link_scan_done(wpa_s))
2594 return wpas_select_network_from_last_scan(wpa_s, 1, own_request,
2599 if (own_request && wpa_s->scan_work) {
2600 struct wpa_radio_work *work = wpa_s->scan_work;
2601 wpa_s->scan_work = NULL;
2608 static int wpas_trigger_6ghz_scan(struct wpa_supplicant *wpa_s,
2614 wpa_dbg(wpa_s, MSG_INFO, "Triggering 6GHz-only scan");
2616 params.non_coloc_6ghz = wpa_s->last_scan_non_coloc_6ghz;
2620 wpa_add_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211A, ¶ms,
2621 true, !wpa_s->last_scan_non_coloc_6ghz, false);
2622 if (!wpa_supplicant_trigger_scan(wpa_s, ¶ms, true, true)) {
2626 wpa_dbg(wpa_s, MSG_INFO, "Failed to trigger 6GHz-only scan");
2634 * @wpa_s: Pointer to wpa_supplicant data
2642 static int wpas_select_network_from_last_scan(struct wpa_supplicant *wpa_s,
2649 int time_to_reenable = wpas_reenabled_network_time(wpa_s);
2652 wpa_dbg(wpa_s, MSG_DEBUG,
2655 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
2657 wpas_network_reenabled, wpa_s, NULL);
2661 if (wpa_s->p2p_mgmt)
2664 wpa_s->owe_transition_search = 0;
2666 os_free(wpa_s->owe_trans_scan_freq);
2667 wpa_s->owe_trans_scan_freq = NULL;
2669 selected = wpa_supplicant_pick_network(wpa_s, &ssid);
2672 if (wpa_s->ifmsh) {
2673 wpa_msg(wpa_s, MSG_INFO,
2681 skip = !wpa_supplicant_need_to_roam(wpa_s, selected, ssid);
2684 wpa_supplicant_rsn_preauth_scan_results(wpa_s);
2688 wpa_s->suitable_network++;
2690 if (ssid != wpa_s->current_ssid &&
2691 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
2692 wpa_s->own_disconnect_req = 1;
2694 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
2697 if (wpa_supplicant_connect(wpa_s, selected, ssid) < 0) {
2698 wpa_dbg(wpa_s, MSG_DEBUG, "Connect failed");
2701 wpa_s->supp_pbc_active = false;
2704 wpa_supplicant_rsn_preauth_scan_results(wpa_s);
2712 wpa_s->no_suitable_network++;
2713 wpa_dbg(wpa_s, MSG_DEBUG, "No suitable network found");
2714 ssid = wpa_supplicant_pick_new_network(wpa_s);
2716 wpa_dbg(wpa_s, MSG_DEBUG, "Setup a new network");
2717 wpa_supplicant_associate(wpa_s, NULL, ssid);
2719 wpa_supplicant_rsn_preauth_scan_results(wpa_s);
2721 if (wpa_s->support_6ghz && trigger_6ghz_scan && data &&
2722 wpas_trigger_6ghz_scan(wpa_s, data) < 0)
2730 int timeout_sec = wpa_s->scan_interval;
2735 res = wpas_p2p_scan_no_go_seen(wpa_s);
2741 if (wpas_p2p_retry_limit_exceeded(wpa_s))
2744 if (wpa_s->p2p_in_provisioning ||
2745 wpa_s->show_group_started ||
2746 wpa_s->p2p_in_invitation) {
2754 wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
2760 if (wpa_s->conf->auto_interworking &&
2761 wpa_s->conf->interworking &&
2762 wpa_s->conf->cred) {
2763 wpa_dbg(wpa_s, MSG_DEBUG, "Interworking: "
2766 wpa_s->network_select = 1;
2767 wpa_s->auto_network_select = 1;
2768 interworking_start_fetch_anqp(wpa_s);
2773 if (wpa_s->after_wps > 0 || wpas_wps_searching(wpa_s)) {
2774 wpa_dbg(wpa_s, MSG_DEBUG, "Use shorter wait during WPS processing");
2777 wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
2783 if (wpa_s->owe_transition_search) {
2784 wpa_dbg(wpa_s, MSG_DEBUG,
2788 if (wpa_s->owe_trans_scan_freq) {
2789 os_free(wpa_s->next_scan_freqs);
2790 wpa_s->next_scan_freqs =
2791 wpa_s->owe_trans_scan_freq;
2792 wpa_s->owe_trans_scan_freq = NULL;
2795 wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
2800 if (wpa_supplicant_req_sched_scan(wpa_s))
2801 wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
2804 wpa_msg_ctrl(wpa_s, MSG_INFO,
2812 static int wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
2818 res = _wpa_supplicant_event_scan_results(wpa_s, data, 1, 0);
2822 * wpa_s after this.
2842 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
2844 if (ifs != wpa_s) {
2860 int wpa_supplicant_fast_associate(struct wpa_supplicant *wpa_s)
2867 wpa_s->ignore_post_flush_scan_res = 0;
2869 if (wpa_s->last_scan_res_used == 0)
2873 if (os_reltime_expired(&now, &wpa_s->last_scan,
2874 wpa_s->conf->scan_res_valid_for_connect)) {
2877 } else if (wpa_s->crossed_6ghz_dom) {
2882 return wpas_select_network_from_last_scan(wpa_s, 0, 1, false, NULL);
2887 int wpa_wps_supplicant_fast_associate(struct wpa_supplicant *wpa_s)
2892 return wpas_select_network_from_last_scan(wpa_s, 1, 1, false, NULL);
2901 struct wpa_supplicant *wpa_s = eloop_ctx;
2903 if (wpa_s->wpa_state < WPA_ASSOCIATED)
2906 if (!wpa_s->no_keep_alive) {
2908 MAC2STR(wpa_s->bssid));
2912 if (wpa_s->l2)
2913 l2_packet_send(wpa_s->l2, wpa_s->bssid, 0x0800,
2918 if (wpa_s->sme.bss_max_idle_period) {
2920 msec = wpa_s->sme.bss_max_idle_period * 1024; /* times 1000 */
2924 wnm_bss_keep_alive, wpa_s, NULL);
2930 static void wnm_process_assoc_resp(struct wpa_supplicant *wpa_s,
2944 wpa_s->sme.bss_max_idle_period =
2947 "TU)%s", wpa_s->sme.bss_max_idle_period,
2950 if (wpa_s->sme.bss_max_idle_period == 0)
2951 wpa_s->sme.bss_max_idle_period = 1;
2952 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) {
2953 eloop_cancel_timeout(wnm_bss_keep_alive, wpa_s, NULL);
2955 msec = wpa_s->sme.bss_max_idle_period * 1024;
2959 wnm_bss_keep_alive, wpa_s,
2963 wpa_s->sme.bss_max_idle_period = 0;
2971 void wnm_bss_keep_alive_deinit(struct wpa_supplicant *wpa_s)
2974 eloop_cancel_timeout(wnm_bss_keep_alive, wpa_s, NULL);
2979 static int wpas_qos_map_set(struct wpa_supplicant *wpa_s, const u8 *qos_map,
2985 res = wpa_drv_set_qos_map(wpa_s, qos_map, len);
2994 static void interworking_process_assoc_resp(struct wpa_supplicant *wpa_s,
3006 wpas_qos_map_set(wpa_s, elems.qos_map_set,
3012 static void wpa_supplicant_set_4addr_mode(struct wpa_supplicant *wpa_s)
3014 if (wpa_s->enabled_4addr_mode) {
3019 if (wpa_drv_set_4addr_mode(wpa_s, 1) < 0) {
3020 wpa_msg(wpa_s, MSG_ERROR, "Failed to set 4addr mode");
3023 wpa_s->enabled_4addr_mode = 1;
3024 wpa_msg(wpa_s, MSG_INFO, "Successfully set 4addr mode");
3028 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3032 static void multi_ap_process_assoc_resp(struct wpa_supplicant *wpa_s,
3039 wpa_s->multi_ap_ie = 0;
3051 wpa_s->multi_ap_backhaul = !!(multi_ap.capability &
3053 wpa_s->multi_ap_fronthaul = !!(multi_ap.capability &
3055 wpa_s->multi_ap_ie = 1;
3059 static void multi_ap_set_4addr_mode(struct wpa_supplicant *wpa_s)
3061 if (!wpa_s->current_ssid ||
3062 !wpa_s->current_ssid->multi_ap_backhaul_sta)
3065 if (!wpa_s->multi_ap_ie) {
3071 if (!wpa_s->multi_ap_backhaul) {
3072 if (wpa_s->multi_ap_fronthaul &&
3073 wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
3083 wpa_supplicant_set_4addr_mode(wpa_s);
3087 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3092 static int wpas_fst_update_mbie(struct wpa_supplicant *wpa_s,
3097 if (!ie || !ie_len || !wpa_s->fst)
3125 wpabuf_free(wpa_s->received_mb_ies);
3126 wpa_s->received_mb_ies = mb_ies_by_info(&mb_ies);
3135 static int wpa_supplicant_use_own_rsne_params(struct wpa_supplicant *wpa_s,
3143 struct wpa_ssid *ssid = wpa_s->current_ssid;
3144 struct wpa_bss *bss = wpa_s->current_bss;
3173 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCV, 0);
3182 wpa_s->wpa_proto = ie.proto;
3183 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, wpa_s->wpa_proto);
3184 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
3185 !!(wpa_s->wpa_proto &
3193 wpa_dbg(wpa_s, MSG_DEBUG,
3198 wpa_s, WLAN_REASON_AKMP_NOT_VALID);
3203 if (((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) ||
3204 (wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OCV)) && ssid->ocv)
3205 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCV,
3213 if (wpa_s->key_mgmt != ie.key_mgmt &&
3216 wpa_dbg(wpa_s, MSG_INFO,
3218 wpas_auth_failed(wpa_s, "NO_PSK_AVAILABLE", NULL);
3222 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL, NULL);
3223 if (wpa_s->conf->key_mgmt_offload &&
3224 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD) &&
3225 wpa_drv_set_key(wpa_s, -1, 0, NULL, 0, 0, NULL, 0,
3227 wpa_dbg(wpa_s, MSG_ERROR,
3231 wpa_s->key_mgmt = ie.key_mgmt;
3232 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
3233 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT %s and proto %d",
3234 wpa_key_mgmt_txt(wpa_s->key_mgmt, wpa_s->wpa_proto),
3235 wpa_s->wpa_proto);
3242 wpa_dbg(wpa_s, MSG_DEBUG,
3247 wpa_s, WLAN_REASON_PAIRWISE_CIPHER_NOT_VALID);
3251 wpa_s->pairwise_cipher = ie.pairwise_cipher;
3252 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
3253 wpa_s->pairwise_cipher);
3254 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
3255 wpa_cipher_txt(wpa_s->pairwise_cipher));
3259 wpa_dbg(wpa_s, MSG_DEBUG,
3267 if (wpa_s->wpa_proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)) {
3276 } else if (wpa_s->wpa_proto & WPA_PROTO_WPA) {
3290 pmf = wpas_get_ssid_pmf(wpa_s, ssid);
3295 wpa_s, WLAN_REASON_INVALID_RSN_IE_CAPAB);
3302 wpa_s, WLAN_REASON_INVALID_RSN_IE_CAPAB);
3308 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, pmf);
3315 wpa_dbg(wpa_s, MSG_DEBUG,
3320 wpa_s, WLAN_REASON_GROUP_CIPHER_NOT_VALID);
3324 wpa_s->group_cipher = ie.group_cipher;
3325 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
3326 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
3327 wpa_cipher_txt(wpa_s->group_cipher));
3334 wpa_dbg(wpa_s, MSG_DEBUG,
3340 wpa_dbg(wpa_s, MSG_DEBUG,
3348 wpa_s, WLAN_REASON_CIPHER_SUITE_REJECTED);
3352 wpa_s->mgmt_group_cipher = ie.mgmt_group_cipher;
3353 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
3354 wpa_s->mgmt_group_cipher);
3355 if (wpa_s->mgmt_group_cipher)
3356 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher %s",
3357 wpa_cipher_txt(wpa_s->mgmt_group_cipher));
3359 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
3365 static int wpa_supplicant_event_associnfo(struct wpa_supplicant *wpa_s,
3373 wpa_dbg(wpa_s, MSG_DEBUG, "Association info event");
3374 wpa_s->ssid_verified = false;
3375 wpa_s->bigtk_set = false;
3380 if (wpa_s->sme.sae.state == SAE_ACCEPTED && wpa_s->sme.sae.h2e)
3381 wpa_s->ssid_verified = true;
3384 bssid_known = wpa_drv_get_bssid(wpa_s, bssid) == 0;
3392 wpa_tdls_assoc_resp_ies(wpa_s->wpa, data->assoc_info.resp_ies,
3396 wnm_process_assoc_resp(wpa_s, data->assoc_info.resp_ies,
3399 interworking_process_assoc_resp(wpa_s, data->assoc_info.resp_ies,
3401 if (wpa_s->hw_capab == CAPAB_VHT &&
3404 wpa_s->ieee80211ac = 1;
3406 multi_ap_process_assoc_resp(wpa_s, data->assoc_info.resp_ies,
3414 wpa_dbg(wpa_s, MSG_DEBUG, "freq=%u MHz",
3417 wpa_s->connection_set = 0;
3427 wpa_s->connection_set = 1;
3428 wpa_s->connection_ht = req_elems.ht_capabilities &&
3433 wpa_s->connection_vht = req_elems.vht_capabilities &&
3438 wpa_s->connection_he = req_elems.he_capabilities &&
3440 wpa_s->connection_eht = req_elems.eht_capabilities &&
3443 wpa_s->rrm.rrm_used = 1;
3464 if (wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, p, len))
3467 wpa_find_assoc_pmkid(wpa_s,
3471 if (wpa_sm_set_assoc_rsnxe(wpa_s->wpa, p, len))
3479 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
3481 wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0);
3485 if (wpa_s->sme.auth_alg == WPA_AUTH_ALG_FILS ||
3486 wpa_s->sme.auth_alg == WPA_AUTH_ALG_FILS_SK_PFS) {
3488 fils_process_assoc_resp(wpa_s->wpa,
3492 wpa_supplicant_deauthenticate(wpa_s,
3500 wpa_s->ssid_verified = true;
3505 if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS &&
3506 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
3507 wpa_sm_set_reset_fils_completed(wpa_s->wpa, 1);
3511 if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE &&
3512 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OWE_OFFLOAD_STA) &&
3514 owe_process_assoc_resp(wpa_s->wpa,
3515 wpa_s->valid_links ?
3516 wpa_s->ap_mld_addr : bssid,
3519 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_UNSPECIFIED);
3525 wpa_sm_set_dpp_z(wpa_s->wpa, NULL);
3526 if (DPP_VERSION > 1 && wpa_s->key_mgmt == WPA_KEY_MGMT_DPP &&
3527 wpa_s->dpp_pfs) {
3535 if (dpp_pfs_process(wpa_s->dpp_pfs, elems.owe_dh,
3537 wpa_supplicant_deauthenticate(wpa_s,
3542 wpa_sm_set_dpp_z(wpa_s->wpa, wpa_s->dpp_pfs->secret);
3549 if (wpa_s->sme.auth_alg == WPA_AUTH_ALG_FT) {
3551 wpa_ft_validate_reassoc_resp(wpa_s->wpa,
3555 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of "
3558 wpa_s, WLAN_REASON_INVALID_IE);
3563 wpa_s->ssid_verified = true;
3570 if (p && wpa_s->current_ssid &&
3571 wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_WPS) {
3575 wpa_msg(wpa_s, MSG_INFO, "WPS-STRICT: AP did not "
3583 wpa_s, WLAN_REASON_INVALID_IE);
3600 wpa_s->sme.ft_used = 1;
3601 os_memcpy(wpa_s->sme.mobility_domain, p + 2,
3611 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
3612 wpa_ft_is_completed(wpa_s->wpa)) {
3614 wpa_s->wpa,
3618 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of "
3621 wpa_s, WLAN_REASON_INVALID_IE);
3624 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Reassociation Response done");
3627 wpa_s->ssid_verified = true;
3630 wpa_sm_set_ft_params(wpa_s->wpa, data->assoc_info.resp_ies,
3636 wpas_handle_assoc_resp_mscs(wpa_s, bssid,
3659 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, p, len);
3665 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, p, len);
3669 wpa_sm_set_ap_rsnxe(wpa_s->wpa, p, len);
3676 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
3678 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
3679 wpa_sm_set_ap_rsnxe(wpa_s->wpa, NULL, 0);
3682 wpa_s->ap_ies_from_associnfo = 1;
3684 if (wpa_s->assoc_freq && data->assoc_info.freq) {
3689 bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
3696 wpa_s->assoc_freq, data->assoc_info.freq);
3697 wpa_supplicant_update_scan_results(wpa_s, bssid);
3701 wpa_s->assoc_freq = data->assoc_info.freq;
3704 wpas_handle_assoc_resp_qos_mgmt(wpa_s, data->assoc_info.resp_ies,
3712 static int wpa_supplicant_assoc_update_ie(struct wpa_supplicant *wpa_s)
3716 if (!wpa_s->current_bss || !wpa_s->current_ssid)
3719 if (!wpa_key_mgmt_wpa_any(wpa_s->current_ssid->key_mgmt))
3722 bss_wpa = wpa_bss_get_vendor_ie(wpa_s->current_bss,
3724 bss_rsn = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_RSN);
3725 bss_rsnx = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_RSNX);
3727 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
3729 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
3731 wpa_sm_set_ap_rsnxe(wpa_s->wpa, bss_rsnx,
3739 static void wpas_fst_update_mb_assoc(struct wpa_supplicant *wpa_s,
3744 struct wpa_bss *bss = wpa_s->current_bss;
3747 wpabuf_free(wpa_s->received_mb_ies);
3748 wpa_s->received_mb_ies = NULL;
3751 !wpas_fst_update_mbie(wpa_s, ai->resp_ies, ai->resp_ies_len)) {
3758 !wpas_fst_update_mbie(wpa_s, ai->beacon_ies, ai->beacon_ies_len)) {
3770 if (!wpas_fst_update_mbie(wpa_s, ieprb, bss->ie_len))
3772 else if (!wpas_fst_update_mbie(wpa_s, iebcn, bss->beacon_ie_len))
3778 static unsigned int wpas_ml_parse_assoc(struct wpa_supplicant *wpa_s,
3796 if (!wpa_s->valid_links || !elems->basic_mle || !elems->basic_mle_len)
3858 if (!ether_addr_equal(wpa_s->ap_mld_addr, common_info->mld_addr)) {
3860 MACSTR ")", MAC2STR(wpa_s->ap_mld_addr));
4033 static int wpa_drv_get_mlo_info(struct wpa_supplicant *wpa_s)
4039 if (wpas_drv_get_sta_mlo_info(wpa_s, &mlo)) {
4040 wpa_dbg(wpa_s, MSG_ERROR, "Failed to get MLO link info");
4041 wpa_supplicant_deauthenticate(wpa_s,
4046 if (wpa_s->valid_links == mlo.valid_links) {
4053 if (!ether_addr_equal(wpa_s->links[i].addr,
4055 !ether_addr_equal(wpa_s->links[i].bssid,
4062 if (match && wpa_s->mlo_assoc_link_id == mlo.assoc_link_id &&
4063 ether_addr_equal(wpa_s->ap_mld_addr, mlo.ap_mld_addr))
4067 wpa_s->valid_links = mlo.valid_links;
4068 wpa_s->mlo_assoc_link_id = mlo.assoc_link_id;
4069 os_memcpy(wpa_s->ap_mld_addr, mlo.ap_mld_addr, ETH_ALEN);
4070 for_each_link(wpa_s->valid_links, i) {
4071 os_memcpy(wpa_s->links[i].addr, mlo.links[i].addr, ETH_ALEN);
4072 os_memcpy(wpa_s->links[i].bssid, mlo.links[i].bssid, ETH_ALEN);
4073 wpa_s->links[i].freq = mlo.links[i].freq;
4074 wpa_supplicant_update_link_bss(wpa_s, i, mlo.links[i].bssid);
4081 static int wpa_sm_set_ml_info(struct wpa_supplicant *wpa_s)
4089 if (wpas_drv_get_sta_mlo_info(wpa_s, &drv_mlo)) {
4090 wpa_dbg(wpa_s, MSG_INFO, "Failed to get MLO link info");
4106 bss = wpa_supplicant_get_new_bss(wpa_s, drv_mlo.links[i].bssid);
4108 wpa_dbg(wpa_s, MSG_INFO,
4128 return wpa_sm_set_mlo_params(wpa_s->wpa, &wpa_mlo);
4132 static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
4143 if (wpa_s->ap_iface) {
4146 hostapd_notif_assoc(wpa_s->ap_iface->bss[0],
4155 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
4156 wpa_s->own_reconnect_req = 0;
4158 ft_completed = wpa_ft_is_completed(wpa_s->wpa);
4160 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
4161 wpa_dbg(wpa_s, MSG_ERROR, "Failed to get BSSID");
4163 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
4167 if (wpa_drv_get_mlo_info(wpa_s) < 0) {
4168 wpa_dbg(wpa_s, MSG_ERROR, "Failed to get MLO connection info");
4169 wpa_supplicant_deauthenticate(wpa_s,
4175 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION)) {
4176 wpa_msg(wpa_s, MSG_INFO, "Attempt to roam to " MACSTR,
4178 if (!wpa_supplicant_update_current_bss(wpa_s, bssid)) {
4183 wpa_supplicant_assoc_update_ie(wpa_s);
4186 if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0)
4194 ft_completed = wpa_fils_is_completed(wpa_s->wpa);
4196 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
4197 if (!ether_addr_equal(bssid, wpa_s->bssid)) {
4198 if (os_reltime_initialized(&wpa_s->session_start)) {
4199 os_reltime_age(&wpa_s->session_start,
4200 &wpa_s->session_length);
4201 wpa_s->session_start.sec = 0;
4202 wpa_s->session_start.usec = 0;
4203 wpas_notify_session_length(wpa_s);
4205 wpas_notify_auth_changed(wpa_s);
4206 os_get_reltime(&wpa_s->session_start);
4208 wpa_dbg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
4212 os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
4213 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
4214 wpas_notify_bssid_changed(wpa_s);
4216 if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
4217 wpa_clear_keys(wpa_s, bssid);
4219 if (wpa_supplicant_select_config(wpa_s, data) < 0) {
4221 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
4226 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
4227 data && wpa_supplicant_use_own_rsne_params(wpa_s, data) < 0)
4230 wpa_s);
4232 if (wpa_s->conf->ap_scan == 1 &&
4233 wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION) {
4234 if (wpa_supplicant_assoc_update_ie(wpa_s) < 0 && new_bss)
4235 wpa_msg(wpa_s, MSG_WARNING,
4239 wpas_fst_update_mb_assoc(wpa_s, data);
4247 os_memcpy(wpa_s->sme.prev_bssid,
4248 wpa_s->valid_links ? wpa_s->ap_mld_addr : bssid, ETH_ALEN);
4249 wpa_s->sme.prev_bssid_set = 1;
4250 wpa_s->sme.last_unprot_disconnect.sec = 0;
4253 wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
4254 if (wpa_s->current_ssid) {
4259 wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
4261 wpa_sm_notify_assoc(wpa_s->wpa, bssid);
4263 if (wpa_sm_set_ml_info(wpa_s)) {
4264 wpa_dbg(wpa_s, MSG_INFO,
4266 wpa_supplicant_deauthenticate(wpa_s,
4271 if (wpa_s->l2)
4272 l2_packet_notify_auth_start(wpa_s->l2);
4285 eapol_sm_notify_portEnabled(wpa_s->eapol, false);
4286 eapol_sm_notify_portValid(wpa_s->eapol, false);
4288 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
4289 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP ||
4290 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE || ft_completed ||
4291 already_authorized || wpa_s->drv_authorized_port)
4292 eapol_sm_notify_eap_success(wpa_s->eapol, false);
4294 eapol_sm_notify_portEnabled(wpa_s->eapol, true);
4295 wpa_s->eapol_received = 0;
4296 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
4297 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE ||
4298 (wpa_s->current_ssid &&
4299 wpa_s->current_ssid->mode == WPAS_MODE_IBSS)) {
4300 if (wpa_s->current_ssid &&
4301 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE &&
4302 (wpa_s->drv_flags &
4308 wpa_supplicant_set_wpa_none_key(wpa_s,
4309 wpa_s->current_ssid);
4311 wpa_supplicant_cancel_auth_timeout(wpa_s);
4312 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
4315 wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
4317 wpa_supplicant_cancel_scan(wpa_s);
4324 wpa_supplicant_cancel_auth_timeout(wpa_s);
4325 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
4326 eapol_sm_notify_portValid(wpa_s->eapol, true);
4327 eapol_sm_notify_eap_success(wpa_s->eapol, true);
4328 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) &&
4329 wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
4335 wpa_supplicant_cancel_auth_timeout(wpa_s);
4336 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
4337 eapol_sm_notify_portValid(wpa_s->eapol, true);
4338 eapol_sm_notify_eap_success(wpa_s->eapol, true);
4344 wpa_msg(wpa_s, MSG_DEBUG,
4347 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X) &&
4348 wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
4354 eapol_sm_notify_portValid(wpa_s->eapol, true);
4357 wpa_s->last_eapol_matches_bssid = 0;
4360 if (wpa_s->rsne_override_eapol) {
4363 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa,
4364 wpabuf_head(wpa_s->rsne_override_eapol),
4365 wpabuf_len(wpa_s->rsne_override_eapol));
4367 if (wpa_s->rsnxe_override_eapol) {
4370 wpa_sm_set_assoc_rsnxe(wpa_s->wpa,
4371 wpabuf_head(wpa_s->rsnxe_override_eapol),
4372 wpabuf_len(wpa_s->rsnxe_override_eapol));
4376 if (wpa_s->pending_eapol_rx) {
4379 os_reltime_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
4381 ether_addr_equal(wpa_s->pending_eapol_rx_src,
4382 wpa_s->valid_links ? wpa_s->ap_mld_addr :
4384 wpa_dbg(wpa_s, MSG_DEBUG, "Process pending EAPOL "
4388 wpa_s, wpa_s->pending_eapol_rx_src,
4389 wpabuf_head(wpa_s->pending_eapol_rx),
4390 wpabuf_len(wpa_s->pending_eapol_rx),
4391 wpa_s->pending_eapol_encrypted);
4393 wpabuf_free(wpa_s->pending_eapol_rx);
4394 wpa_s->pending_eapol_rx = NULL;
4398 if ((wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
4399 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
4400 wpa_s->current_ssid &&
4401 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE)) {
4403 wpa_set_wep_keys(wpa_s, wpa_s->current_ssid);
4408 if (wpa_s->current_ssid &&
4409 wpa_s->current_ssid->mode == WPAS_MODE_IBSS &&
4410 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
4411 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE &&
4412 wpa_s->ibss_rsn == NULL) {
4413 wpa_s->ibss_rsn = ibss_rsn_init(wpa_s, wpa_s->current_ssid);
4414 if (!wpa_s->ibss_rsn) {
4415 wpa_msg(wpa_s, MSG_INFO, "Failed to init IBSS RSN");
4417 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
4421 ibss_rsn_set_psk(wpa_s->ibss_rsn, wpa_s->current_ssid->psk);
4425 wpas_wps_notify_assoc(wpa_s, bssid);
4429 wmm_ac_notify_assoc(wpa_s, data->assoc_info.resp_ies,
4433 if (wpa_s->reassoc_same_bss)
4434 wmm_ac_restore_tspecs(wpa_s);
4439 bss = wpa_bss_get_bssid(wpa_s, bssid);
4442 if (wpa_key_mgmt_fils(wpa_s->key_mgmt)) {
4446 wpa_sm_set_fils_cache_id(wpa_s->wpa, fils_cache_id);
4451 wpas_mbo_check_pmf(wpa_s, bss, wpa_s->current_ssid);
4455 wpa_s->dpp_pfs_fallback = 0;
4458 if (wpa_s->current_ssid && wpa_s->current_ssid->enable_4addr_mode)
4459 wpa_supplicant_set_4addr_mode(wpa_s);
4471 static void wpa_supplicant_event_disassoc(struct wpa_supplicant *wpa_s,
4477 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
4486 bssid = wpa_s->bssid;
4488 bssid = wpa_s->pending_bssid;
4491 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
4492 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_DISCONNECTED "bssid=" MACSTR
4500 static int could_be_psk_mismatch(struct wpa_supplicant *wpa_s, u16 reason_code,
4503 if (wpa_s->wpa_state != WPA_4WAY_HANDSHAKE ||
4504 !wpa_s->new_connection ||
4505 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
4506 wpa_key_mgmt_sae(wpa_s->key_mgmt))
4524 static void wpa_supplicant_event_disassoc_finish(struct wpa_supplicant *wpa_s,
4533 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
4539 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - ignore in "
4544 if (!wpa_s->disconnected && wpa_s->wpa_state >= WPA_AUTHENTICATING &&
4555 curr = wpa_s->current_bss;
4557 if (could_be_psk_mismatch(wpa_s, reason_code, locally_generated)) {
4558 wpa_msg(wpa_s, MSG_INFO, "WPA: 4-Way Handshake failed - "
4560 if (wpas_p2p_4way_hs_failed(wpa_s) > 0)
4562 wpas_auth_failed(wpa_s, "WRONG_KEY", wpa_s->pending_bssid);
4563 wpas_notify_psk_mismatch(wpa_s);
4565 wpas_dpp_send_conn_status_result(wpa_s,
4569 if (!wpa_s->disconnected &&
4570 (!wpa_s->auto_reconnect_disabled ||
4571 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS ||
4572 wpas_wps_searching(wpa_s) ||
4573 wpas_wps_reenable_networks_pending(wpa_s))) {
4574 wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect enabled: try to "
4576 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS,
4577 wpas_wps_searching(wpa_s),
4578 wpa_s->wpa_state);
4579 if (wpa_s->wpa_state == WPA_COMPLETED &&
4580 wpa_s->current_ssid &&
4581 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
4582 (wpa_s->own_reconnect_req ||
4593 fast_reconnect = wpa_s->current_bss;
4594 fast_reconnect_ssid = wpa_s->current_ssid;
4595 } else if (wpa_s->wpa_state >= WPA_ASSOCIATING) {
4596 wpa_supplicant_req_scan(wpa_s, 0, 100000);
4598 wpa_dbg(wpa_s, MSG_DEBUG, "Do not request new "
4602 wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect disabled: do not "
4604 wpa_s->reassociate = 0;
4605 wpa_s->disconnected = 1;
4606 if (!wpa_s->pno)
4607 wpa_supplicant_cancel_sched_scan(wpa_s);
4609 bssid = wpa_s->bssid;
4611 bssid = wpa_s->pending_bssid;
4612 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
4613 wpas_connection_failed(wpa_s, bssid, NULL);
4614 wpa_sm_notify_disassoc(wpa_s->wpa);
4615 ptksa_cache_flush(wpa_s->ptksa, wpa_s->bssid, WPA_CIPHER_NONE);
4618 wpa_s->disconnect_reason = -reason_code;
4620 wpa_s->disconnect_reason = reason_code;
4621 wpas_notify_disconnect_reason(wpa_s);
4622 if (wpa_supplicant_dynamic_keys(wpa_s)) {
4623 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - remove keys");
4624 wpa_clear_keys(wpa_s, wpa_s->bssid);
4626 wpa_supplicant_mark_disassoc(wpa_s);
4629 wpa_bss_remove(wpa_s, curr, "Connection to AP lost");
4632 !wpas_network_disabled(wpa_s, fast_reconnect_ssid) &&
4633 !disallowed_bssid(wpa_s, fast_reconnect->bssid) &&
4634 !disallowed_ssid(wpa_s, fast_reconnect->ssid,
4636 !wpas_temp_disabled(wpa_s, fast_reconnect_ssid) &&
4637 !wpa_is_bss_tmp_disallowed(wpa_s, fast_reconnect)) {
4639 wpa_dbg(wpa_s, MSG_DEBUG, "Try to reconnect to the same BSS");
4640 if (wpa_supplicant_connect(wpa_s, fast_reconnect,
4643 wpa_supplicant_req_scan(wpa_s, 0, 100000);
4653 wpa_supplicant_req_scan(wpa_s, 0, 100000);
4661 struct wpa_supplicant *wpa_s = eloop_ctx;
4663 if (!wpa_s->pending_mic_error_report)
4666 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Sending pending MIC error report");
4667 wpa_sm_key_request(wpa_s->wpa, 1, wpa_s->pending_mic_error_pairwise);
4668 wpa_s->pending_mic_error_report = 0;
4674 wpa_supplicant_event_michael_mic_failure(struct wpa_supplicant *wpa_s,
4680 wpa_msg(wpa_s, MSG_WARNING, "Michael MIC failure detected");
4683 if ((os_reltime_initialized(&wpa_s->last_michael_mic_error) &&
4684 !os_reltime_expired(&t, &wpa_s->last_michael_mic_error, 60)) ||
4685 wpa_s->pending_mic_error_report) {
4686 if (wpa_s->pending_mic_error_report) {
4692 wpa_sm_key_request(wpa_s->wpa, 1,
4693 wpa_s->pending_mic_error_pairwise);
4699 wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
4702 wpa_s->countermeasures = 1;
4704 wpa_bssid_ignore_add(wpa_s, wpa_s->bssid);
4706 wpa_msg(wpa_s, MSG_WARNING, "TKIP countermeasures started");
4714 wpa_drv_set_countermeasures(wpa_s, 1);
4715 wpa_supplicant_deauthenticate(wpa_s,
4718 wpa_s, NULL);
4721 wpa_s, NULL);
4726 if (wpa_s->mic_errors_seen) {
4744 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Delay MIC error "
4746 wpa_s->pending_mic_error_report = 1;
4747 wpa_s->pending_mic_error_pairwise = pairwise;
4750 wpa_s, NULL);
4754 wpa_s, NULL);
4756 wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
4759 wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
4762 wpa_s->last_michael_mic_error = t;
4763 wpa_s->mic_errors_seen++;
4770 struct wpa_supplicant *wpa_s;
4772 for (wpa_s = head; wpa_s != NULL; wpa_s = wpa_s->next)
4773 if (!wpa_s->interface_removed)
4781 wpa_supplicant_event_interface_status(struct wpa_supplicant *wpa_s,
4784 if (os_strcmp(wpa_s->ifname, data->interface_status.ifname) != 0)
4789 if (!wpa_s->interface_removed)
4791 wpa_s->interface_removed = 0;
4792 wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was added");
4793 if (wpa_supplicant_driver_init(wpa_s) < 0) {
4794 wpa_msg(wpa_s, MSG_INFO, "Failed to initialize the "
4799 if (!wpa_s->global->p2p &&
4800 !wpa_s->global->p2p_disabled &&
4801 !wpa_s->conf->p2p_disabled &&
4802 (wpa_s->drv_flags &
4805 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
4814 wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was removed");
4815 wpa_s->interface_removed = 1;
4816 wpa_supplicant_mark_disassoc(wpa_s);
4817 wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
4818 l2_packet_deinit(wpa_s->l2);
4819 wpa_s->l2 = NULL;
4822 if (wpa_s->global->p2p &&
4823 wpa_s->global->p2p_init_wpa_s->parent == wpa_s &&
4824 (wpa_s->drv_flags &
4826 wpa_dbg(wpa_s, MSG_DEBUG,
4829 wpa_s->global, wpa_s->global->p2p_init_wpa_s,
4831 wpa_s->global->p2p_init_wpa_s = NULL;
4836 if (wpa_s->matched) {
4837 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
4844 if (!any_interfaces(wpa_s->global->ifaces))
4853 static void wpa_supplicant_event_tdls(struct wpa_supplicant *wpa_s,
4860 wpa_tdls_remove(wpa_s->wpa, data->tdls.peer);
4861 if (wpa_tdls_is_external_setup(wpa_s->wpa))
4862 wpa_tdls_start(wpa_s->wpa, data->tdls.peer);
4864 wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, data->tdls.peer);
4867 if (wpa_tdls_is_external_setup(wpa_s->wpa))
4868 wpa_tdls_teardown_link(wpa_s->wpa, data->tdls.peer,
4871 wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN,
4875 wpa_tdls_send_discovery_request(wpa_s->wpa,
4884 static void wpa_supplicant_event_wnm(struct wpa_supplicant *wpa_s,
4894 ieee802_11_send_wnmsleep_req(wpa_s, data->wnm.sleep_action,
4904 wpa_supplicant_event_ft_response(struct wpa_supplicant *wpa_s,
4910 if (wpa_ft_process_response(wpa_s->wpa, data->ft_ies.ies,
4923 static void wpa_supplicant_event_ibss_rsn_start(struct wpa_supplicant *wpa_s,
4927 if (wpa_s->wpa_state < WPA_ASSOCIATED)
4931 ssid = wpa_s->current_ssid;
4937 ibss_rsn_start(wpa_s->ibss_rsn, data->ibss_rsn_start.peer);
4941 static void wpa_supplicant_event_ibss_auth(struct wpa_supplicant *wpa_s,
4944 struct wpa_ssid *ssid = wpa_s->current_ssid;
4953 ibss_rsn_handle_auth(wpa_s->ibss_rsn, data->rx_mgmt.frame,
4960 static void ft_rx_action(struct wpa_supplicant *wpa_s, const u8 *data,
4967 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
4976 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Received FT Action Response: STA "
4980 if (!ether_addr_equal(sta_addr, wpa_s->own_addr)) {
4981 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Foreign STA Address " MACSTR
4987 wpa_dbg(wpa_s, MSG_DEBUG, "FT: FT Action Response indicates "
4993 if (wpa_ft_process_response(wpa_s->wpa, data + 1 + 2 * ETH_ALEN + 2,
5001 bss = wpa_bss_get_bssid(wpa_s, target_ap_addr);
5003 wpa_s->sme.freq = bss->freq;
5004 wpa_s->sme.auth_alg = WPA_AUTH_ALG_FT;
5005 sme_associate(wpa_s, WPAS_MODE_INFRA, target_ap_addr,
5013 static void wpa_supplicant_event_unprot_deauth(struct wpa_supplicant *wpa_s,
5020 sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code);
5024 static void wpa_supplicant_event_unprot_disassoc(struct wpa_supplicant *wpa_s,
5031 sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code);
5035 static void wpas_event_disconnect(struct wpa_supplicant *wpa_s, const u8 *addr,
5040 if (wpa_s->ap_iface && addr) {
5041 hostapd_notif_disassoc(wpa_s->ap_iface->bss[0], addr);
5045 if (wpa_s->ap_iface) {
5046 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore deauth event in AP mode");
5052 wpa_s->own_disconnect_req = 0;
5054 wpa_supplicant_event_disassoc(wpa_s, reason_code, locally_generated);
5057 ((wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
5058 (wpa_s->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) &&
5059 eapol_sm_failed(wpa_s->eapol))) &&
5060 !wpa_s->eap_expected_failure))
5061 wpas_auth_failed(wpa_s, "AUTH_FAILED", addr);
5065 if (wpas_p2p_deauth_notif(wpa_s, addr, reason_code, ie, ie_len,
5076 wpa_supplicant_event_disassoc_finish(wpa_s, reason_code,
5081 static void wpas_event_disassoc(struct wpa_supplicant *wpa_s,
5090 wpa_dbg(wpa_s, MSG_DEBUG, "Disassociation notification");
5098 wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u (%s)%s", reason_code,
5102 wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR,
5109 if (wpa_s->ap_iface && info && info->addr) {
5110 hostapd_notif_disassoc(wpa_s->ap_iface->bss[0], info->addr);
5114 if (wpa_s->ap_iface) {
5115 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore disassoc event in AP mode");
5123 wpa_s, info->addr, reason_code, info->ie, info->ie_len,
5128 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
5129 sme_event_disassoc(wpa_s, info);
5131 wpas_event_disconnect(wpa_s, addr, reason_code, locally_generated,
5136 static void wpas_event_deauth(struct wpa_supplicant *wpa_s,
5145 wpa_dbg(wpa_s, MSG_DEBUG, "Deauthentication notification");
5153 wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u (%s)%s",
5157 wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR,
5164 wpa_reset_ft_completed(wpa_s->wpa);
5166 wpas_event_disconnect(wpa_s, addr, reason_code,
5207 static void wpas_beacon_hint(struct wpa_supplicant *wpa_s, const char *title,
5212 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REGDOM_BEACON_HINT
5221 void wpa_supplicant_update_channel_list(struct wpa_supplicant *wpa_s,
5233 for (ifs = wpa_s; ifs->parent && ifs != ifs->parent; ifs = ifs->parent)
5251 if (wpa_s->drv_priv == NULL)
5254 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
5283 wpas_p2p_update_channel_list(wpa_s, WPAS_P2P_CHANNEL_UPDATE_DRIVER);
5287 static void wpas_event_rx_mgmt_action(struct wpa_supplicant *wpa_s,
5304 wpa_dbg(wpa_s, MSG_DEBUG, "Received Action frame: SA=" MACSTR
5310 wmm_ac_rx_action(wpa_s, mgmt->da, mgmt->sa, payload, plen);
5317 ft_rx_action(wpa_s, payload, plen);
5324 sme_sa_query_rx(wpa_s, mgmt->da, mgmt->sa, payload, plen);
5331 ieee802_11_rx_wnm_action(wpa_s, mgmt, len);
5339 gas_query_rx(wpa_s->gas, mgmt->da, mgmt->sa, mgmt->bssid,
5348 gas_server_rx(wpa_s->gas_server, mgmt->da, mgmt->sa, mgmt->bssid,
5357 wpa_dbg(wpa_s, MSG_DEBUG,
5360 if (wpa_s->valid_links &&
5361 wpa_tdls_process_discovery_response(wpa_s->wpa, mgmt->sa,
5363 wpa_dbg(wpa_s, MSG_ERROR,
5375 wpa_dbg(wpa_s, MSG_DEBUG, "Interworking: Received QoS Map Configure frame from "
5377 if (ether_addr_equal(mgmt->sa, wpa_s->bssid) &&
5380 wpas_qos_map_set(wpa_s, pos + 2, pos[1]);
5388 wpas_rrm_handle_radio_measurement_request(wpa_s, mgmt->sa,
5397 wpas_rrm_process_neighbor_rep(wpa_s, payload + 1, plen - 1);
5403 wpas_rrm_handle_link_measurement_request(wpa_s, mgmt->sa,
5411 if (mgmt->u.action.category == WLAN_ACTION_FST && wpa_s->fst) {
5412 fst_rx_action(wpa_s->fst, mgmt, len);
5423 wpas_nan_usd_rx_sdf(wpa_s, mgmt->sa, freq, payload, plen);
5435 wpas_dpp_rx_action(wpa_s, mgmt->sa, payload, plen, freq);
5443 wpas_handle_robust_av_scs_recv_action(wpa_s, mgmt->sa,
5450 wpas_handle_robust_av_recv_action(wpa_s, mgmt->sa,
5457 wpas_handle_qos_mgmt_recv_action(wpa_s, mgmt->sa,
5463 wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid,
5465 if (wpa_s->ifmsh)
5466 mesh_mpm_action_rx(wpa_s, mgmt, len);
5470 static void wpa_supplicant_notify_avoid_freq(struct wpa_supplicant *wpa_s,
5480 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_AVOID_FREQ "ranges=%s",
5484 if (freq_range_list_parse(&wpa_s->global->p2p_go_avoid_freq, str)) {
5485 wpa_dbg(wpa_s, MSG_ERROR, "%s: Failed to parse freq range",
5488 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Update channel list based on frequency avoid event");
5494 wpas_p2p_update_channel_list(wpa_s,
5503 static void wpa_supplicant_event_port_authorized(struct wpa_supplicant *wpa_s)
5505 if (wpa_s->wpa_state == WPA_ASSOCIATED) {
5506 wpa_supplicant_cancel_auth_timeout(wpa_s);
5507 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
5508 eapol_sm_notify_portValid(wpa_s->eapol, true);
5509 eapol_sm_notify_eap_success(wpa_s->eapol, true);
5510 wpa_s->drv_authorized_port = 1;
5515 static unsigned int wpas_event_cac_ms(const struct wpa_supplicant *wpa_s,
5521 for (i = 0; i < wpa_s->hw.num_modes; i++) {
5522 const struct hostapd_hw_modes *mode = &wpa_s->hw.modes[i];
5537 static void wpas_event_dfs_cac_started(struct wpa_supplicant *wpa_s,
5541 if (wpa_s->ap_iface || wpa_s->ifmsh) {
5542 wpas_ap_event_dfs_cac_started(wpa_s, radar);
5546 unsigned int cac_time = wpas_event_cac_ms(wpa_s, radar->freq);
5553 wpas_auth_timeout_restart(wpa_s, cac_time);
5558 static void wpas_event_dfs_cac_finished(struct wpa_supplicant *wpa_s,
5562 if (wpa_s->ap_iface || wpa_s->ifmsh) {
5563 wpas_ap_event_dfs_cac_finished(wpa_s, radar);
5569 wpas_auth_timeout_restart(wpa_s, 0);
5574 static void wpas_event_dfs_cac_aborted(struct wpa_supplicant *wpa_s,
5578 if (wpa_s->ap_iface || wpa_s->ifmsh) {
5579 wpas_ap_event_dfs_cac_aborted(wpa_s, radar);
5585 wpas_auth_timeout_restart(wpa_s, 0);
5590 static void wpa_supplicant_event_assoc_auth(struct wpa_supplicant *wpa_s,
5593 wpa_dbg(wpa_s, MSG_DEBUG,
5595 wpa_s->wpa_state);
5597 wpa_supplicant_event_port_authorized(wpa_s);
5599 wpa_s->last_eapol_matches_bssid = 1;
5601 wpa_sm_set_rx_replay_ctr(wpa_s->wpa, data->assoc_info.key_replay_ctr);
5602 wpa_sm_set_ptk_kck_kek(wpa_s->wpa, data->assoc_info.ptk_kck,
5607 if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS) {
5608 struct wpa_bss *bss = wpa_bss_get_bssid(wpa_s, wpa_s->bssid);
5613 wpa_s->eapol, data->assoc_info.fils_erp_next_seq_num);
5617 wpa_sm_pmksa_cache_add(wpa_s->wpa,
5621 wpa_s->valid_links ?
5622 wpa_s->ap_mld_addr :
5623 wpa_s->bssid,
5627 pmksa_cache_set_current(wpa_s->wpa,
5661 static void wpas_event_assoc_reject(struct wpa_supplicant *wpa_s,
5673 bssid = wpa_s->pending_bssid;
5675 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
5676 reject_bss = wpa_s->current_bss;
5678 reject_bss = wpa_bss_get_bssid(wpa_s, bssid);
5682 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
5695 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
5706 wpa_s->assoc_status_code = data->assoc_reject.status_code;
5707 wpas_notify_assoc_status_code(wpa_s);
5712 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE &&
5713 wpa_s->current_ssid &&
5714 wpa_s->current_ssid->owe_group == 0 &&
5715 wpa_s->last_owe_group != 21) {
5716 struct wpa_ssid *ssid = wpa_s->current_ssid;
5717 struct wpa_bss *bss = wpa_s->current_bss;
5720 bss = wpa_supplicant_get_new_bss(wpa_s, bssid);
5722 wpas_connection_failed(wpa_s, bssid, NULL);
5723 wpa_supplicant_mark_disassoc(wpa_s);
5728 wpas_connect_work_done(wpa_s);
5729 wpa_supplicant_mark_disassoc(wpa_s);
5730 wpa_supplicant_connect(wpa_s, bss, ssid);
5740 if (DPP_VERSION > 1 && wpa_s->current_ssid &&
5741 (wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_DPP ||
5742 ((wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_DPP) &&
5743 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP)) &&
5744 wpa_s->current_ssid->dpp_pfs == 0 &&
5748 struct wpa_ssid *ssid = wpa_s->current_ssid;
5749 struct wpa_bss *bss = wpa_s->current_bss;
5751 wpa_s->current_ssid->dpp_pfs_fallback ^= 1;
5753 bss = wpa_supplicant_get_new_bss(wpa_s, bssid);
5754 if (!bss || wpa_s->dpp_pfs_fallback) {
5757 wpas_connection_failed(wpa_s, bssid, NULL);
5758 wpa_supplicant_mark_disassoc(wpa_s);
5762 wpa_s->dpp_pfs_fallback = 1;
5763 wpas_connect_work_done(wpa_s);
5764 wpa_supplicant_mark_disassoc(wpa_s);
5765 wpa_supplicant_connect(wpa_s, bss, ssid);
5786 wpa_bss_tmp_disallow(wpa_s,
5802 n_links = wpas_ml_parse_assoc(wpa_s, &elems, ml_info);
5819 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) {
5820 sme_event_assoc_reject(wpa_s, data, link_bssids);
5827 if (wpa_s->current_ssid &&
5828 wpa_key_mgmt_sae(wpa_s->current_ssid->key_mgmt) &&
5830 wpa_dbg(wpa_s, MSG_DEBUG, "SAE: Drop PMKSA cache entry");
5831 wpa_sm_aborted_cached(wpa_s->wpa);
5832 wpa_sm_pmksa_cache_flush(wpa_s->wpa, wpa_s->current_ssid);
5837 if (wpa_s->current_ssid &&
5838 wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_DPP &&
5840 wpa_dbg(wpa_s, MSG_DEBUG, "DPP: Drop PMKSA cache entry");
5841 wpa_sm_aborted_cached(wpa_s->wpa);
5842 wpa_sm_pmksa_cache_flush(wpa_s->wpa, wpa_s->current_ssid);
5848 if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS) {
5849 fils_pmksa_cache_flush(wpa_s);
5851 wpa_s->eapol,
5853 fils_connection_failure(wpa_s);
5857 wpas_connection_failed(wpa_s, bssid, link_bssids);
5858 wpa_supplicant_mark_disassoc(wpa_s);
5862 static void wpas_event_unprot_beacon(struct wpa_supplicant *wpa_s,
5868 if (!data || wpa_s->wpa_state != WPA_COMPLETED ||
5869 !ether_addr_equal(data->sa, wpa_s->bssid))
5871 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_UNPROT_BEACON MACSTR,
5883 res = wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
5884 wpa_s->own_addr, wpa_s->bssid,
5907 static void wpas_tid_link_map(struct wpa_supplicant *wpa_s,
5940 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_T2LM_UPDATE "%s", map_info);
5944 static void wpas_link_reconfig(struct wpa_supplicant *wpa_s)
5948 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
5950 wpa_supplicant_deauthenticate(wpa_s,
5955 if (!ether_addr_equal(bssid, wpa_s->bssid)) {
5956 os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
5957 wpa_supplicant_update_current_bss(wpa_s, wpa_s->bssid);
5958 wpas_notify_bssid_changed(wpa_s);
5961 if (wpa_drv_get_mlo_info(wpa_s) < 0) {
5964 wpa_supplicant_deauthenticate(wpa_s,
5969 if (wpa_sm_set_ml_info(wpa_s)) {
5972 wpa_supplicant_deauthenticate(wpa_s,
5977 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_LINK_RECONFIG "valid_links=0x%x",
5978 wpa_s->valid_links);
5985 struct wpa_supplicant *wpa_s = ctx;
5992 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED &&
5997 wpa_dbg(wpa_s, MSG_DEBUG,
6014 wpa_dbg(wpa_s, level, "Event %s (%d) received",
6021 if (!wpas_fst_update_mbie(wpa_s, data->auth.ies,
6026 sme_event_auth(wpa_s, data);
6027 wpa_s->auth_status_code = data->auth.status_code;
6028 wpas_notify_auth_status_code(wpa_s);
6032 if (wpa_s->ignore_auth_resp) {
6037 if (wpa_s->testing_resend_assoc) {
6043 if (wpa_s->disconnected) {
6048 wpa_supplicant_event_assoc(wpa_s, data);
6049 wpa_s->assoc_status_code = WLAN_STATUS_SUCCESS;
6052 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
6053 wpa_fils_is_completed(wpa_s->wpa))))
6054 wpa_supplicant_event_assoc_auth(wpa_s, data);
6056 wpa_msg(wpa_s, MSG_INFO,
6062 wpas_event_disassoc(wpa_s,
6067 if (wpa_s->ignore_auth_resp) {
6072 if (wpa_s->testing_resend_assoc) {
6078 wpas_event_deauth(wpa_s,
6082 wpas_link_reconfig(wpa_s);
6085 wpa_supplicant_event_michael_mic_failure(wpa_s, data);
6089 if (wpa_s->own_scan_requested ||
6093 os_get_reltime(&wpa_s->scan_start_time);
6094 os_reltime_sub(&wpa_s->scan_start_time,
6095 &wpa_s->scan_trigger_time, &diff);
6096 wpa_dbg(wpa_s, MSG_DEBUG, "Own scan request started a scan in %jd.%06ld seconds",
6098 wpa_s->own_scan_requested = 0;
6099 wpa_s->own_scan_running = 1;
6100 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
6101 wpa_s->manual_scan_use_id) {
6102 wpa_msg_ctrl(wpa_s, MSG_INFO,
6104 wpa_s->manual_scan_id);
6106 wpa_msg_ctrl(wpa_s, MSG_INFO,
6110 wpa_dbg(wpa_s, MSG_DEBUG, "External program started a scan");
6111 wpa_s->radio->external_scan_req_interface = wpa_s;
6112 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_STARTED);
6116 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
6117 wpa_s->scan_res_handler = NULL;
6118 wpa_s->own_scan_running = 0;
6119 wpa_s->radio->external_scan_req_interface = NULL;
6120 wpa_s->last_scan_req = NORMAL_SCAN_REQ;
6125 os_reltime_initialized(&wpa_s->scan_start_time)) {
6128 os_reltime_sub(&now, &wpa_s->scan_start_time, &diff);
6129 wpa_s->scan_start_time.sec = 0;
6130 wpa_s->scan_start_time.usec = 0;
6131 wpa_s->wps_scan_done = true;
6132 wpa_dbg(wpa_s, MSG_DEBUG, "Scan completed in %jd.%06ld seconds",
6135 if (wpa_supplicant_event_scan_results(wpa_s, data))
6138 wpa_s->own_scan_running = 0;
6140 wpa_s->radio->external_scan_req_interface = NULL;
6141 radio_work_check_next(wpa_s);
6145 wpa_supplicant_event_associnfo(wpa_s, data);
6148 wpa_supplicant_event_interface_status(wpa_s, data);
6151 wpa_supplicant_event_pmkid_candidate(wpa_s, data);
6155 wpa_supplicant_event_tdls(wpa_s, data);
6160 wpa_supplicant_event_wnm(wpa_s, data);
6165 wpa_supplicant_event_ft_response(wpa_s, data);
6170 wpa_supplicant_event_ibss_rsn_start(wpa_s, data);
6174 wpas_event_assoc_reject(wpa_s, data);
6178 if (wpa_s->current_ssid &&
6179 wpa_s->current_ssid->mode == WPAS_MODE_MESH) {
6180 wpa_dbg(wpa_s, MSG_DEBUG,
6184 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
6185 sme_event_auth_timed_out(wpa_s, data);
6189 if (wpa_s->current_ssid &&
6190 wpa_s->current_ssid->mode == WPAS_MODE_MESH) {
6191 wpa_dbg(wpa_s, MSG_DEBUG,
6195 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
6196 sme_event_assoc_timed_out(wpa_s, data);
6199 wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS dst=" MACSTR
6206 wnm_btm_resp_tx_status(wpa_s, data->tx_status.data,
6213 wpas_pasn_auth_tx_status(wpa_s, data->tx_status.data,
6219 if (wpa_s->ap_iface == NULL) {
6224 wpa_s, data->tx_status.dst,
6235 wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS pending_dst="
6236 MACSTR, MAC2STR(wpa_s->p2pdev->pending_action_dst));
6240 * Note, wpa_s->p2pdev will be the same as wpa_s->parent,
6246 ether_addr_equal(wpa_s->p2pdev->pending_action_dst,
6249 wpa_s->p2pdev, data->tx_status.dst,
6261 ap_mgmt_tx_cb(wpa_s, data->tx_status.data,
6267 ap_tx_status(wpa_s, data->tx_status.dst,
6277 ap_eapol_tx_status(wpa_s, data->eapol_tx_status.dst,
6283 ap_client_poll_ok(wpa_s, data->client_poll.addr);
6286 if (wpa_s->ap_iface == NULL)
6288 ap_rx_from_unknown_sta(wpa_s, data->rx_from_unknown.addr,
6295 if (!data || !wpa_s->current_ssid ||
6296 !(wpa_s->valid_links & BIT(data->ch_switch.link_id)))
6299 wpa_msg(wpa_s, MSG_INFO,
6314 wpa_s->links[data->ch_switch.link_id].freq =
6316 if (wpa_s->links[data->ch_switch.link_id].bss &&
6317 wpa_s->links[data->ch_switch.link_id].bss->freq !=
6319 wpa_s->links[data->ch_switch.link_id].bss->freq =
6322 wpa_s, WPA_BSS_FREQ_CHANGED_FLAG,
6323 wpa_s->links[data->ch_switch.link_id].bss);
6328 if (!data || !wpa_s->current_ssid)
6331 wpa_msg(wpa_s, MSG_INFO,
6344 wpa_s->assoc_freq = data->ch_switch.freq;
6345 wpa_s->current_ssid->frequency = data->ch_switch.freq;
6346 if (wpa_s->current_bss &&
6347 wpa_s->current_bss->freq != data->ch_switch.freq) {
6348 wpa_s->current_bss->freq = data->ch_switch.freq;
6349 notify_bss_changes(wpa_s, WPA_BSS_FREQ_CHANGED_FLAG,
6350 wpa_s->current_bss);
6356 wpa_s->sme.ht_sec_chan = HT_SEC_CHAN_ABOVE;
6359 wpa_s->sme.ht_sec_chan = HT_SEC_CHAN_BELOW;
6362 wpa_s->sme.ht_sec_chan = HT_SEC_CHAN_UNKNOWN;
6368 if (wpa_s->current_ssid->mode == WPAS_MODE_AP ||
6369 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO ||
6370 wpa_s->current_ssid->mode == WPAS_MODE_MESH ||
6371 wpa_s->current_ssid->mode ==
6373 wpas_ap_ch_switch(wpa_s, data->ch_switch.freq,
6384 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
6385 sme_event_ch_switch(wpa_s);
6387 wpas_p2p_update_channel_list(wpa_s, WPAS_P2P_CHANNEL_UPDATE_CS);
6388 wnm_clear_coloc_intf_reporting(wpa_s);
6394 wpas_ap_event_dfs_radar_detected(wpa_s,
6399 wpas_ap_event_dfs_cac_nop_finished(wpa_s,
6406 wpas_event_dfs_cac_started(wpa_s, &data->dfs_event);
6410 wpas_event_dfs_cac_finished(wpa_s, &data->dfs_event);
6414 wpas_event_dfs_cac_aborted(wpa_s, &data->dfs_event);
6421 if (wpa_s->ext_mgmt_frame_handling) {
6428 wpa_msg(wpa_s, MSG_INFO, "MGMT-RX freq=%d datarate=%u ssi_signal=%d %s",
6443 if (wpa_s->ap_iface == NULL) {
6456 wpa_s, src, mgmt->da,
6464 if (wpa_s->current_ssid &&
6465 wpa_s->current_ssid->mode == WPAS_MODE_IBSS &&
6468 wpa_supplicant_event_ibss_auth(wpa_s, data);
6475 wpa_s, data->rx_mgmt.frame,
6482 if (wpa_s->ifmsh) {
6483 mesh_mpm_mgmt_rx(wpa_s, &data->rx_mgmt);
6488 wpas_pasn_auth_rx(wpa_s, mgmt,
6495 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
6496 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) {
6498 wpa_s, data->rx_mgmt.frame,
6503 wpa_dbg(wpa_s, MSG_DEBUG, "AP: ignore received "
6517 wpas_notify_preq(wpa_s, mgmt->sa, mgmt->da,
6522 ap_mgmt_rx(wpa_s, &data->rx_mgmt);
6531 if (wpa_s->ap_iface) {
6532 hostapd_probe_req_rx(wpa_s->ap_iface->bss[0],
6542 wpas_p2p_probe_req_rx(wpa_s, data->rx_probe_req.sa,
6553 wpa_s, data->remain_on_channel.freq,
6557 wpa_s, data->remain_on_channel.freq,
6561 wpa_s, data->remain_on_channel.freq,
6566 wpa_s, data->remain_on_channel.freq,
6573 wpa_s, data->remain_on_channel.freq);
6576 wpa_s, data->remain_on_channel.freq);
6579 wpa_s, data->remain_on_channel.freq);
6583 wpa_s, data->remain_on_channel.freq);
6587 wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src,
6593 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SIGNAL_CHANGE
6599 wpa_bss_update_level(wpa_s->current_bss,
6602 wpa_s, data->signal_change.above_threshold,
6606 os_memcpy(&wpa_s->last_signal_info, data,
6608 wpas_notify_signal_change(wpa_s);
6611 wpa_supplicant_update_mac_addr(wpa_s);
6612 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
6615 wpa_dbg(wpa_s, MSG_DEBUG, "Interface was enabled");
6616 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
6620 wpa_s, NULL);
6621 os_memcpy(addr, wpa_s->own_addr, ETH_ALEN);
6622 wpa_supplicant_update_mac_addr(wpa_s);
6623 if (!ether_addr_equal(addr, wpa_s->own_addr))
6624 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
6626 wpa_sm_pmksa_cache_reconfig(wpa_s->wpa);
6627 wpa_supplicant_set_default_scan_ies(wpa_s);
6628 if (wpa_s->p2p_mgmt) {
6629 wpa_supplicant_set_state(wpa_s,
6635 if (!wpa_s->ap_iface) {
6636 wpa_supplicant_set_state(wpa_s,
6638 wpa_s->scan_req = NORMAL_SCAN_REQ;
6639 wpa_supplicant_req_scan(wpa_s, 0, 0);
6641 wpa_supplicant_set_state(wpa_s,
6644 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
6645 wpa_supplicant_req_scan(wpa_s, 0, 0);
6650 wpa_dbg(wpa_s, MSG_DEBUG, "Interface was disabled");
6652 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO ||
6653 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group &&
6654 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)) {
6659 wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
6665 if (wpa_s->current_ssid &&
6666 wpa_s->current_ssid->p2p_group)
6667 wpas_p2p_interface_unavailable(wpa_s);
6669 wpas_p2p_disconnect(wpa_s);
6671 * wpa_s instance may have been freed, so must not use
6676 if (wpa_s->p2p_scan_work && wpa_s->global->p2p &&
6677 p2p_in_progress(wpa_s->global->p2p) > 1) {
6681 p2p_stop_find(wpa_s->global->p2p);
6685 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
6691 wpa_s, WLAN_REASON_DEAUTH_LEAVING, 1);
6693 wpa_supplicant_mark_disassoc(wpa_s);
6694 os_reltime_age(&wpa_s->last_scan, &age);
6695 if (age.sec >= wpa_s->conf->scan_res_valid_for_connect) {
6696 clear_at.sec = wpa_s->conf->scan_res_valid_for_connect;
6701 tmp.sec = wpa_s->conf->scan_res_valid_for_connect;
6707 wpa_s, NULL);
6708 radio_remove_works(wpa_s, NULL, 0);
6710 wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
6714 wpa_s, &data->channel_list_changed);
6717 wpas_p2p_interface_unavailable(wpa_s);
6720 wpa_dbg(wpa_s, MSG_DEBUG, "Best channel event received "
6724 wpa_s->best_24_freq = data->best_chan.freq_24;
6725 wpa_s->best_5_freq = data->best_chan.freq_5;
6726 wpa_s->best_overall_freq = data->best_chan.freq_overall;
6727 wpas_p2p_update_best_channels(wpa_s, data->best_chan.freq_24,
6732 wpa_supplicant_event_unprot_deauth(wpa_s,
6736 wpa_supplicant_event_unprot_disassoc(wpa_s,
6741 if (wpa_s->ap_iface && data)
6742 hostapd_event_sta_low_ack(wpa_s->ap_iface->bss[0],
6747 wpa_tdls_disable_unreachable_link(wpa_s->wpa,
6753 ibss_rsn_stop(wpa_s->ibss_rsn, data->ibss_peer_lost.peer);
6758 wpa_s->bssid))
6760 if (!wpa_s->wpa)
6762 wpa_sm_update_replay_ctr(wpa_s->wpa,
6766 wpa_s->sched_scanning = 0;
6767 resched = wpa_s->scanning && wpas_scan_scheduled(wpa_s);
6768 wpa_supplicant_notify_scanning(wpa_s, 0);
6770 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
6777 if (!wpa_s->sched_scan_stop_req &&
6778 wpa_s->wpa_state == WPA_SCANNING) {
6779 wpa_dbg(wpa_s, MSG_DEBUG,
6781 wpa_supplicant_req_scan(wpa_s, 1, 0);
6785 wpa_s->sched_scan_stop_req = 0;
6791 if (wpa_s->sched_scan_timed_out) {
6792 wpa_supplicant_req_sched_scan(wpa_s);
6793 } else if (wpa_s->pno_sched_pending) {
6794 wpa_s->pno_sched_pending = 0;
6795 wpas_start_pno(wpa_s);
6797 wpa_supplicant_req_scan(wpa_s, 0, 0);
6803 wpas_wps_start_pbc(wpa_s, NULL, 0, 0);
6807 wpa_supplicant_notify_avoid_freq(wpa_s, data);
6811 if (!wpa_s->ap_iface || !data)
6814 wpa_s->ap_iface->bss[0],
6821 if (!wpa_s->ifmsh || !data)
6823 wpa_mesh_notify_peer(wpa_s, data->mesh_peer.peer,
6830 if (!wpa_s->ap_iface)
6832 hostapd_event_get_survey(wpa_s->ap_iface,
6839 if (!wpa_s->ap_iface)
6841 hostapd_acs_channel_selected(wpa_s->ap_iface->bss[0],
6848 wpa_s->p2p_lo_started = 0;
6849 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_LISTEN_OFFLOAD_STOP
6855 if (!wpa_s->current_bss || !wpa_s->current_ssid)
6857 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_BEACON_LOSS);
6858 bgscan_notify_beacon_loss(wpa_s);
6862 if (!wpa_s->current_ssid) {
6866 sme_external_auth_trigger(wpa_s, data);
6871 wpas_pasn_auth_trigger(wpa_s, &data->pasn_auth);
6876 if (wpa_s->ap_iface && wpa_s->ap_iface->bss[0]) {
6879 sta = ap_get_sta(wpa_s->ap_iface->bss[0],
6882 ap_sta_set_authorized(wpa_s->ap_iface->bss[0],
6896 wpa_s, data->port_authorized.td_bitmap[0]);
6899 wpa_supplicant_event_port_authorized(wpa_s);
6903 if (!wpa_s->ap_iface || !data)
6906 hostapd_event_sta_opmode_changed(wpa_s->ap_iface->bss[0],
6914 wpas_event_unprot_beacon(wpa_s, &data->unprot_beacon);
6918 wpas_dpp_tx_wait_expire(wpa_s);
6921 wpas_nan_usd_tx_wait_expire(wpa_s);
6926 wpas_tid_link_map(wpa_s, &data->t2l_map_info);
6929 wpa_msg(wpa_s, MSG_INFO, "Unknown event %d", event);
6938 struct wpa_supplicant *wpa_s;
6943 wpa_s = wpa_supplicant_get_iface(ctx, data->interface_status.ifname);
6944 if (wpa_s && wpa_s->driver->get_ifindex) {
6947 ifindex = wpa_s->driver->get_ifindex(wpa_s->drv_priv);
6949 wpa_dbg(wpa_s, MSG_DEBUG,
6963 wpa_s = wpa_supplicant_add_iface(ctx, wpa_i, NULL);
6968 if (wpa_s)
6969 wpa_supplicant_event(wpa_s, event, data);
Indexes created Sun Apr 12 00:22:20 UTC 2026