Lines Matching refs:wpa_s
126 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s);
131 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
140 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
149 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
162 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
168 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
173 switch (wpa_s->group_cipher) {
192 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
193 "WPA-None", wpa_s->group_cipher);
200 ret = wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
208 struct wpa_supplicant *wpa_s = eloop_ctx;
209 const u8 *bssid = wpa_s->bssid;
210 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
211 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
212 wpa_s->wpa_state == WPA_ASSOCIATING))
213 bssid = wpa_s->pending_bssid;
214 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
216 wpa_blacklist_add(wpa_s, bssid);
217 wpa_sm_notify_disassoc(wpa_s->wpa);
218 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
219 wpa_s->reassociate = 1;
225 wpa_supplicant_req_scan(wpa_s, 1, 0);
231 * @wpa_s: Pointer to wpa_supplicant data
238 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
241 if (wpa_s->conf->ap_scan == 0 &&
242 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
245 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
247 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
248 wpa_s->last_auth_timeout_sec = sec;
249 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
255 * @wpa_s: Pointer to wpa_supplicant data
258 void wpas_auth_timeout_restart(struct wpa_supplicant *wpa_s, int sec_diff)
260 int new_sec = wpa_s->last_auth_timeout_sec + sec_diff;
262 if (eloop_is_timeout_registered(wpa_supplicant_timeout, wpa_s, NULL)) {
263 wpa_dbg(wpa_s, MSG_DEBUG,
265 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
267 wpa_s, NULL);
274 * @wpa_s: Pointer to wpa_supplicant data
280 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
282 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
283 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
284 wpa_blacklist_del(wpa_s, wpa_s->bssid);
285 os_free(wpa_s->last_con_fail_realm);
286 wpa_s->last_con_fail_realm = NULL;
287 wpa_s->last_con_fail_realm_len = 0;
293 * @wpa_s: Pointer to wpa_supplicant data
298 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
302 struct wpa_ssid *ssid = wpa_s->current_ssid;
306 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
307 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
312 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
313 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
314 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
319 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
320 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
322 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
323 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
324 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
326 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
329 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
340 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
343 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
346 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
347 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
348 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
349 eapol_conf.external_sim = wpa_s->conf->external_sim;
352 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
354 if (wpa_s->current_bss) {
356 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
368 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
371 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE && ssid->mka_psk_set)
372 ieee802_1x_create_preshared_mka(wpa_s, ssid);
374 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
382 * @wpa_s: Pointer to wpa_supplicant data
389 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
395 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
397 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
399 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
400 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
401 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
402 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
403 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
404 wpa_s->group_cipher = WPA_CIPHER_NONE;
405 wpa_s->mgmt_group_cipher = 0;
409 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
410 wpa_s->group_cipher = WPA_CIPHER_WEP104;
413 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
414 wpa_s->group_cipher = WPA_CIPHER_WEP40;
419 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
420 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
421 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
422 wpa_s->pairwise_cipher);
423 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
425 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
426 wpa_s->mgmt_group_cipher);
429 pmksa_cache_clear_current(wpa_s->wpa);
433 void free_hw_features(struct wpa_supplicant *wpa_s)
436 if (wpa_s->hw.modes == NULL)
439 for (i = 0; i < wpa_s->hw.num_modes; i++) {
440 os_free(wpa_s->hw.modes[i].channels);
441 os_free(wpa_s->hw.modes[i].rates);
444 os_free(wpa_s->hw.modes);
445 wpa_s->hw.modes = NULL;
449 void free_bss_tmp_disallowed(struct wpa_supplicant *wpa_s)
453 dl_list_for_each_safe(bss, prev, &wpa_s->bss_tmp_disallowed,
455 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss);
462 void wpas_flush_fils_hlp_req(struct wpa_supplicant *wpa_s)
466 while ((req = dl_list_first(&wpa_s->fils_hlp_req, struct fils_hlp_req,
475 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
479 bgscan_deinit(wpa_s);
480 autoscan_deinit(wpa_s);
481 scard_deinit(wpa_s->scard);
482 wpa_s->scard = NULL;
483 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
484 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
485 l2_packet_deinit(wpa_s->l2);
486 wpa_s->l2 = NULL;
487 if (wpa_s->l2_br) {
488 l2_packet_deinit(wpa_s->l2_br);
489 wpa_s->l2_br = NULL;
492 l2_packet_deinit(wpa_s->l2_test);
493 wpa_s->l2_test = NULL;
494 os_free(wpa_s->get_pref_freq_list_override);
495 wpa_s->get_pref_freq_list_override = NULL;
496 wpabuf_free(wpa_s->last_assoc_req_wpa_ie);
497 wpa_s->last_assoc_req_wpa_ie = NULL;
500 if (wpa_s->conf != NULL) {
502 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
503 wpas_notify_network_removed(wpa_s, ssid);
506 os_free(wpa_s->confname);
507 wpa_s->confname = NULL;
509 os_free(wpa_s->confanother);
510 wpa_s->confanother = NULL;
512 os_free(wpa_s->last_con_fail_realm);
513 wpa_s->last_con_fail_realm = NULL;
514 wpa_s->last_con_fail_realm_len = 0;
516 wpa_sm_set_eapol(wpa_s->wpa, NULL);
517 eapol_sm_deinit(wpa_s->eapol);
518 wpa_s->eapol = NULL;
520 rsn_preauth_deinit(wpa_s->wpa);
523 wpa_tdls_deinit(wpa_s->wpa);
526 wmm_ac_clear_saved_tspecs(wpa_s);
527 pmksa_candidate_free(wpa_s->wpa);
528 wpa_sm_deinit(wpa_s->wpa);
529 wpa_s->wpa = NULL;
530 wpa_blacklist_clear(wpa_s);
532 wpa_bss_deinit(wpa_s);
534 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
535 wpa_supplicant_cancel_scan(wpa_s);
536 wpa_supplicant_cancel_auth_timeout(wpa_s);
537 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
540 wpa_s, NULL);
543 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
545 wpas_wps_deinit(wpa_s);
547 wpabuf_free(wpa_s->pending_eapol_rx);
548 wpa_s->pending_eapol_rx = NULL;
551 ibss_rsn_deinit(wpa_s->ibss_rsn);
552 wpa_s->ibss_rsn = NULL;
555 sme_deinit(wpa_s);
558 wpa_supplicant_ap_deinit(wpa_s);
561 wpas_p2p_deinit(wpa_s);
564 offchannel_deinit(wpa_s);
567 wpa_supplicant_cancel_sched_scan(wpa_s);
569 os_free(wpa_s->next_scan_freqs);
570 wpa_s->next_scan_freqs = NULL;
572 os_free(wpa_s->manual_scan_freqs);
573 wpa_s->manual_scan_freqs = NULL;
574 os_free(wpa_s->select_network_scan_freqs);
575 wpa_s->select_network_scan_freqs = NULL;
577 os_free(wpa_s->manual_sched_scan_freqs);
578 wpa_s->manual_sched_scan_freqs = NULL;
580 wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
590 if (wpa_s->radio)
591 radio_remove_works(wpa_s, "gas-query", 0);
592 gas_query_deinit(wpa_s->gas);
593 wpa_s->gas = NULL;
594 gas_server_deinit(wpa_s->gas_server);
595 wpa_s->gas_server = NULL;
597 free_hw_features(wpa_s);
599 ieee802_1x_dealloc_kay_sm(wpa_s);
601 os_free(wpa_s->bssid_filter);
602 wpa_s->bssid_filter = NULL;
604 os_free(wpa_s->disallow_aps_bssid);
605 wpa_s->disallow_aps_bssid = NULL;
606 os_free(wpa_s->disallow_aps_ssid);
607 wpa_s->disallow_aps_ssid = NULL;
609 wnm_bss_keep_alive_deinit(wpa_s);
611 wnm_deallocate_memory(wpa_s);
614 ext_password_deinit(wpa_s->ext_pw);
615 wpa_s->ext_pw = NULL;
617 wpabuf_free(wpa_s->last_gas_resp);
618 wpa_s->last_gas_resp = NULL;
619 wpabuf_free(wpa_s->prev_gas_resp);
620 wpa_s->prev_gas_resp = NULL;
622 os_free(wpa_s->last_scan_res);
623 wpa_s->last_scan_res = NULL;
626 if (wpa_s->drv_priv)
627 wpa_drv_configure_frame_filters(wpa_s, 0);
628 hs20_deinit(wpa_s);
632 wpabuf_free(wpa_s->vendor_elem[i]);
633 wpa_s->vendor_elem[i] = NULL;
636 wmm_ac_notify_disassoc(wpa_s);
638 wpa_s->sched_scan_plans_num = 0;
639 os_free(wpa_s->sched_scan_plans);
640 wpa_s->sched_scan_plans = NULL;
643 wpa_s->non_pref_chan_num = 0;
644 os_free(wpa_s->non_pref_chan);
645 wpa_s->non_pref_chan = NULL;
648 free_bss_tmp_disallowed(wpa_s);
650 wpabuf_free(wpa_s->lci);
651 wpa_s->lci = NULL;
652 wpas_clear_beacon_rep_data(wpa_s);
659 while ((entry = dl_list_last(&wpa_s->mesh_external_pmksa_cache,
670 wpas_flush_fils_hlp_req(wpa_s);
672 wpabuf_free(wpa_s->ric_ies);
673 wpa_s->ric_ies = NULL;
676 wpas_dpp_deinit(wpa_s);
677 dpp_global_deinit(wpa_s->dpp);
678 wpa_s->dpp = NULL;
685 * @wpa_s: Pointer to wpa_supplicant data
691 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
703 if (wpa_s->keys_cleared & BIT(i))
705 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
708 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
710 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
714 wpa_s, addr,
718 wpa_s->keys_cleared = (u32) -1;
758 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
762 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
763 name = wpa_s->current_ssid->bgscan;
765 name = wpa_s->conf->bgscan;
768 if (wpas_driver_bss_selection(wpa_s))
770 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
773 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
777 bgscan_deinit(wpa_s);
778 if (wpa_s->current_ssid) {
779 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
780 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
789 wpa_s->bgscan_ssid = wpa_s->current_ssid;
790 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
793 bgscan_notify_scan(wpa_s, scan_res);
798 wpa_s->bgscan_ssid = NULL;
802 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
804 if (wpa_s->bgscan_ssid != NULL) {
805 bgscan_deinit(wpa_s);
806 wpa_s->bgscan_ssid = NULL;
813 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
815 if (autoscan_init(wpa_s, 0))
816 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
820 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
822 autoscan_deinit(wpa_s);
826 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
828 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
829 wpa_s->wpa_state == WPA_SCANNING) {
830 autoscan_deinit(wpa_s);
831 wpa_supplicant_start_autoscan(wpa_s);
838 * @wpa_s: Pointer to wpa_supplicant data
844 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
847 enum wpa_states old_state = wpa_s->wpa_state;
849 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
850 wpa_supplicant_state_txt(wpa_s->wpa_state),
854 os_reltime_initialized(&wpa_s->roam_start)) {
855 os_reltime_age(&wpa_s->roam_start, &wpa_s->roam_time);
856 wpa_s->roam_start.sec = 0;
857 wpa_s->roam_start.usec = 0;
858 wpas_notify_auth_changed(wpa_s);
859 wpas_notify_roam_time(wpa_s);
860 wpas_notify_roam_complete(wpa_s);
862 os_reltime_initialized(&wpa_s->roam_start)) {
863 wpa_s->roam_start.sec = 0;
864 wpa_s->roam_start.usec = 0;
865 wpa_s->roam_time.sec = 0;
866 wpa_s->roam_time.usec = 0;
867 wpas_notify_roam_complete(wpa_s);
872 wpa_s->normal_scans = 0;
876 wpas_connect_work_done(wpa_s);
878 wpa_s->normal_scans = 0;
888 if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid &&
889 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
890 wpa_s->current_ssid->p2p_group) {
891 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) {
892 wpa_dbg(wpa_s, MSG_DEBUG,
894 wpa_s->p2p_cli_probe =
895 wpa_drv_probe_req_report(wpa_s, 1) >= 0;
896 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) {
897 wpa_dbg(wpa_s, MSG_DEBUG,
899 wpa_s->p2p_cli_probe = 0;
900 wpa_drv_probe_req_report(wpa_s, 0);
906 wpa_supplicant_notify_scanning(wpa_s, 0);
908 if (state == WPA_COMPLETED && wpa_s->new_connection) {
909 struct wpa_ssid *ssid = wpa_s->current_ssid;
913 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
914 wpa_auth_alg_fils(wpa_s->sme.auth_alg))
917 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
918 wpa_auth_alg_fils(wpa_s->auth_alg))
922 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
924 MAC2STR(wpa_s->bssid),
929 wpas_clear_temp_disabled(wpa_s, ssid, 1);
930 wpa_blacklist_clear(wpa_s);
931 wpa_s->extra_blacklist_count = 0;
932 wpa_s->new_connection = 0;
933 wpa_drv_set_operstate(wpa_s, 1);
935 wpa_drv_set_supp_port(wpa_s, 1);
937 wpa_s->after_wps = 0;
938 wpa_s->known_wps_freq = 0;
939 wpas_p2p_completed(wpa_s);
941 sme_sched_obss_scan(wpa_s, 1);
945 wpas_update_fils_connect_params(wpa_s);
949 wpa_s->new_connection = 1;
950 wpa_drv_set_operstate(wpa_s, 0);
952 wpa_drv_set_supp_port(wpa_s, 0);
954 sme_sched_obss_scan(wpa_s, 0);
956 wpa_s->wpa_state = state;
960 wpa_supplicant_start_bgscan(wpa_s);
962 wpa_supplicant_stop_bgscan(wpa_s);
966 wpa_supplicant_stop_autoscan(wpa_s);
969 wpa_supplicant_start_autoscan(wpa_s);
971 if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
972 wmm_ac_notify_disassoc(wpa_s);
974 if (wpa_s->wpa_state != old_state) {
975 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
981 wpas_p2p_indicate_state_change(wpa_s);
983 if (wpa_s->wpa_state == WPA_COMPLETED ||
985 wpas_notify_auth_changed(wpa_s);
994 struct wpa_supplicant *wpa_s = global->ifaces;
995 while (wpa_s) {
996 struct wpa_supplicant *next = wpa_s->next;
997 if (wpas_wps_terminate_pending(wpa_s) == 1)
1000 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
1001 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
1002 wpas_p2p_disconnect(wpa_s);
1004 wpa_s = next;
1020 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
1022 enum wpa_states old_state = wpa_s->wpa_state;
1024 wpa_s->pairwise_cipher = 0;
1025 wpa_s->group_cipher = 0;
1026 wpa_s->mgmt_group_cipher = 0;
1027 wpa_s->key_mgmt = 0;
1028 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
1029 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1031 if (wpa_s->wpa_state != old_state)
1032 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
1038 * @wpa_s: Pointer to wpa_supplicant data
1047 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
1053 if (wpa_s->confname == NULL)
1055 conf = wpa_config_read(wpa_s->confname, NULL);
1057 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
1058 "file '%s' - exiting", wpa_s->confname);
1061 if (wpa_s->confanother &&
1062 !wpa_config_read(wpa_s->confanother, conf)) {
1063 wpa_msg(wpa_s, MSG_ERROR,
1065 wpa_s->confanother);
1071 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
1072 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
1074 wpa_s->conf->ctrl_interface) != 0);
1076 if (reconf_ctrl && wpa_s->ctrl_iface) {
1077 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
1078 wpa_s->ctrl_iface = NULL;
1081 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1082 if (wpa_s->current_ssid) {
1083 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
1084 wpa_s->own_disconnect_req = 1;
1085 wpa_supplicant_deauthenticate(wpa_s,
1093 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1094 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
1095 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) {
1100 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
1102 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1103 wpa_sm_set_config(wpa_s->wpa, NULL);
1104 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
1105 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1106 rsn_preauth_deinit(wpa_s->wpa);
1108 old_ap_scan = wpa_s->conf->ap_scan;
1109 wpa_config_free(wpa_s->conf);
1110 wpa_s->conf = conf;
1111 if (old_ap_scan != wpa_s->conf->ap_scan)
1112 wpas_notify_ap_scan_changed(wpa_s);
1115 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1117 wpa_supplicant_update_config(wpa_s);
1119 wpa_supplicant_clear_status(wpa_s);
1120 if (wpa_supplicant_enabled_networks(wpa_s)) {
1121 wpa_s->reassociate = 1;
1122 wpa_supplicant_req_scan(wpa_s, 0, 0);
1124 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
1132 struct wpa_supplicant *wpa_s;
1133 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1134 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
1136 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
1148 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
1152 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
1155 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
1161 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
1164 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
1170 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
1176 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
1184 wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
1185 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
1210 * @wpa_s: Pointer to wpa_supplicant data
1222 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
1241 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1248 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1256 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1263 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using OSEN (within RSN)");
1267 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1268 wpa_dbg(wpa_s, MSG_DEBUG,
1272 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1281 wpa_dbg(wpa_s, MSG_DEBUG,
1284 wpa_dbg(wpa_s, MSG_DEBUG,
1293 wpa_dbg(wpa_s, MSG_DEBUG,
1296 wpa_dbg(wpa_s, MSG_DEBUG,
1310 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1339 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
1340 wpa_s->wpa_proto = 0;
1345 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1351 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1356 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1361 wpa_s->wpa_proto = proto;
1362 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1363 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1366 if (bss || !wpa_s->ap_ies_from_associnfo) {
1367 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1369 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1375 wpa_s->group_cipher = WPA_CIPHER_NONE;
1376 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1379 wpa_dbg(wpa_s, MSG_DEBUG,
1382 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1383 if (wpa_s->group_cipher < 0) {
1384 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1388 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1389 wpa_cipher_txt(wpa_s->group_cipher));
1392 wpa_dbg(wpa_s, MSG_DEBUG,
1395 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1396 if (wpa_s->pairwise_cipher < 0) {
1397 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1401 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1402 wpa_cipher_txt(wpa_s->pairwise_cipher));
1406 wpa_dbg(wpa_s, MSG_DEBUG,
1410 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1417 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X_SHA384;
1418 wpa_dbg(wpa_s, MSG_DEBUG,
1421 pmksa_cache_get_current(wpa_s->wpa)) {
1424 wpa_dbg(wpa_s, MSG_DEBUG,
1426 pmksa_cache_clear_current(wpa_s->wpa);
1432 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1433 wpa_dbg(wpa_s, MSG_DEBUG,
1438 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1439 wpa_dbg(wpa_s, MSG_DEBUG,
1445 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384;
1446 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA384");
1448 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256;
1449 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA256");
1452 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA384;
1453 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA384");
1455 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA256;
1456 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA256");
1460 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1461 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1463 pmksa_cache_get_current(wpa_s->wpa)) {
1466 wpa_dbg(wpa_s, MSG_DEBUG,
1468 pmksa_cache_clear_current(wpa_s->wpa);
1473 wpa_s->key_mgmt = WPA_KEY_MGMT_DPP;
1474 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT DPP");
1478 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1479 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1481 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1482 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1486 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1487 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1491 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1492 wpa_dbg(wpa_s, MSG_DEBUG,
1495 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1496 wpa_dbg(wpa_s, MSG_DEBUG,
1500 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1501 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1503 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1504 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1506 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1507 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1510 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1511 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1515 wpa_s->key_mgmt = WPA_KEY_MGMT_OWE;
1516 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT OWE");
1519 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1524 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1525 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1526 wpa_s->pairwise_cipher);
1527 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1533 if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1536 wpa_dbg(wpa_s, MSG_DEBUG,
1540 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1541 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1544 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1545 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1548 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1549 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1552 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1553 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1556 wpa_s->mgmt_group_cipher = 0;
1557 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1559 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1560 wpa_s->mgmt_group_cipher);
1561 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1562 wpas_get_ssid_pmf(wpa_s, ssid));
1565 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCV, ssid->ocv);
1568 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1569 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1575 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) {
1577 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1590 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL,
1607 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL, NULL);
1614 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1620 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1626 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1645 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1653 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1662 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1667 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1680 wpa_msg(wpa_s, MSG_INFO,
1682 wpas_auth_failed(wpa_s, "NO_PSK_AVAILABLE");
1686 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE) {
1692 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1698 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1706 if (wpa_s->conf->coloc_intf_reporting) {
1714 if (!wpa_s->conf->disable_btm)
1723 if (wpa_s->conf->interworking)
1729 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_QOS_MAPPING)
1735 if (wpa_s->conf->hs20)
1747 if (wpa_s->conf->ftm_responder)
1749 if (wpa_s->conf->ftm_initiator)
1754 if (!wpa_s->disable_fils)
1762 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1767 if (len < wpa_s->extended_capa_len)
1768 len = wpa_s->extended_capa_len;
1778 wpas_ext_capab_byte(wpa_s, pos, i);
1780 if (i < wpa_s->extended_capa_len) {
1781 *pos &= ~wpa_s->extended_capa_mask[i];
1782 *pos |= wpa_s->extended_capa[i];
1797 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1802 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1811 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1816 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1825 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,
1828 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1831 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1843 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1846 struct wpa_radio_work *work = wpa_s->connect_work;
1851 wpa_s->connect_work = NULL;
1859 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1865 if (wpa_s->last_mac_addr_style == style &&
1866 wpa_s->last_mac_addr_change.sec != 0 &&
1867 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1868 wpa_s->conf->rand_addr_lifetime)) {
1869 wpa_msg(wpa_s, MSG_DEBUG,
1880 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1888 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1889 wpa_msg(wpa_s, MSG_INFO,
1894 os_get_reltime(&wpa_s->last_mac_addr_change);
1895 wpa_s->mac_addr_changed = 1;
1896 wpa_s->last_mac_addr_style = style;
1898 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1899 wpa_msg(wpa_s, MSG_INFO,
1904 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1911 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1913 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1914 !wpa_s->conf->preassoc_mac_addr)
1917 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1925 * @wpa_s: Pointer to wpa_supplicant data
1931 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1937 wpa_s->own_disconnect_req = 0;
1943 wpabuf_free(wpa_s->pending_eapol_rx);
1944 wpa_s->pending_eapol_rx = NULL;
1947 rand_style = wpa_s->conf->mac_addr;
1951 wmm_ac_clear_saved_tspecs(wpa_s);
1952 wpa_s->reassoc_same_bss = 0;
1953 wpa_s->reassoc_same_ess = 0;
1955 wpa_s->testing_resend_assoc = 0;
1958 if (wpa_s->last_ssid == ssid) {
1959 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1960 wpa_s->reassoc_same_ess = 1;
1961 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1962 wmm_ac_save_tspecs(wpa_s);
1963 wpa_s->reassoc_same_bss = 1;
1964 } else if (wpa_s->current_bss && wpa_s->current_bss != bss) {
1965 os_get_reltime(&wpa_s->roam_start);
1969 if (rand_style > 0 && !wpa_s->reassoc_same_ess) {
1970 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1972 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1973 } else if (rand_style == 0 && wpa_s->mac_addr_changed) {
1974 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1975 wpa_msg(wpa_s, MSG_INFO,
1979 wpa_s->mac_addr_changed = 0;
1980 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1981 wpa_msg(wpa_s, MSG_INFO,
1985 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1987 wpa_s->last_ssid = ssid;
1990 ibss_rsn_deinit(wpa_s->ibss_rsn);
1991 wpa_s->ibss_rsn = NULL;
1995 wpa_msg(wpa_s, MSG_INFO,
2004 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
2005 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
2009 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
2010 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2012 wpas_p2p_ap_setup_failed(wpa_s);
2015 wpa_s->current_bss = bss;
2017 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
2025 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
2026 wpa_msg(wpa_s, MSG_INFO,
2032 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
2033 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
2036 wpa_s->current_bss = bss;
2037 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_STARTED "ssid=\"%s\" id=%d",
2040 wpas_notify_mesh_group_started(wpa_s, ssid);
2042 wpa_msg(wpa_s, MSG_ERROR,
2055 wpa_supplicant_rsn_supp_set_config(wpa_s, ssid);
2058 if (wpas_dpp_check_connect(wpa_s, ssid, bss) != 0)
2064 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
2068 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
2070 sme_authenticate(wpa_s, bss, ssid);
2074 if (wpa_s->connect_work) {
2075 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
2079 if (radio_work_pending(wpa_s, "connect")) {
2080 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
2087 wpa_s->sme.auth_alg = WPA_AUTH_ALG_OPEN;
2091 wpas_abort_ongoing_scan(wpa_s);
2100 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
2114 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
2125 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
2126 if (wpa_s->hw.modes[i].mode == hw_mode) {
2127 mode = &wpa_s->hw.modes[i];
2139 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
2159 for (j = 0; j < wpa_s->last_scan_res_used; j++) {
2160 struct wpa_bss *bss = wpa_s->last_scan_res[j];
2185 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
2188 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
2189 wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
2190 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
2197 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
2198 if (wpa_s->hw.modes[i].mode == hw_mode) {
2199 mode = &wpa_s->hw.modes[i];
2282 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
2320 if (!drv_supports_vht(wpa_s, ssid))
2325 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
2430 static size_t wpas_add_fils_hlp_req(struct wpa_supplicant *wpa_s, u8 *ie_buf,
2438 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
2464 os_memcpy(buf, wpa_s->own_addr, ETH_ALEN);
2498 int wpa_is_fils_supported(struct wpa_supplicant *wpa_s)
2500 return (((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
2501 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_FILS)) ||
2502 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
2503 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD)));
2507 int wpa_is_fils_sk_pfs_supported(struct wpa_supplicant *wpa_s)
2510 return (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
2511 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_FILS);
2521 struct wpa_supplicant *wpa_s,
2542 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
2564 wpa_s->conf->okc :
2571 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2574 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2580 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2582 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2592 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2594 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2607 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2609 wpa_s->wpa_proto = 0;
2612 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2614 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2630 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2635 wpa_s->wpa_proto = 0;
2638 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2640 wpa_s->wpa_proto = 0;
2655 wpa_sm_set_reset_fils_completed(wpa_s->wpa, 0);
2657 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) &&
2658 ssid->eap.erp && wpa_key_mgmt_fils(wpa_s->key_mgmt) &&
2659 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, &username,
2662 (!wpa_s->last_con_fail_realm ||
2663 wpa_s->last_con_fail_realm_len != realm_len ||
2664 os_memcmp(wpa_s->last_con_fail_realm, realm, realm_len) != 0)) {
2680 if (wpa_s->key_mgmt & (WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE))
2684 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2687 wpa_dbg(wpa_s, MSG_DEBUG,
2693 wpa_dbg(wpa_s, MSG_DEBUG,
2700 if (wpa_s->global->p2p) {
2706 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2712 wpa_s->cross_connect_disallowed = 0;
2717 wpa_s->cross_connect_disallowed =
2720 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2722 wpa_s->cross_connect_disallowed ?
2727 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2731 wpa_ie_len += wpas_supp_op_class_ie(wpa_s, ssid, bss->freq,
2746 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
2748 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
2753 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2768 if (is_hs20_network(wpa_s, ssid, bss)) {
2773 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2787 hs20_configure_frame_filters(wpa_s);
2792 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2793 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2805 if (wpa_s->fst_ies) {
2806 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2810 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2821 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
2834 len = wpas_add_fils_hlp_req(wpa_s, wpa_ie + wpa_ie_len,
2853 } else if (wpa_s->assoc_status_code ==
2855 if (wpa_s->last_owe_group == 19)
2857 else if (wpa_s->last_owe_group == 20)
2865 wpa_s->last_owe_group = group;
2867 owe_ie = owe_build_assoc_req(wpa_s->wpa, group);
2879 if (wpa_sm_get_key_mgmt(wpa_s->wpa) == WPA_KEY_MGMT_DPP &&
2881 dpp_pfs_free(wpa_s->dpp_pfs);
2882 wpa_s->dpp_pfs = dpp_pfs_init(ssid->dpp_netaccesskey,
2884 if (!wpa_s->dpp_pfs) {
2889 if (wpabuf_len(wpa_s->dpp_pfs->ie) <=
2892 wpabuf_head(wpa_s->dpp_pfs->ie),
2893 wpabuf_len(wpa_s->dpp_pfs->ie));
2894 wpa_ie_len += wpabuf_len(wpa_s->dpp_pfs->ie);
2905 if (bss && wpa_key_mgmt_ft(wpa_sm_get_key_mgmt(wpa_s->wpa))) {
2911 const u8 *wpa_md = wpa_sm_get_ft_md(wpa_s->wpa);
2917 wpa_s->wpa, wpa_ie + wpa_ie_len,
2922 if (len > 0 && wpa_s->sme.ft_used &&
2923 wpa_sm_has_ptk(wpa_s->wpa)) {
2924 wpa_dbg(wpa_s, MSG_DEBUG,
2959 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s)
2965 if (wpa_s->auth_alg != WPA_AUTH_ALG_OPEN)
2969 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss,
2970 wpa_s->current_ssid, ¶ms, &mask);
2979 wpa_s->auth_alg = params.auth_alg;
2980 wpa_drv_update_connect_params(wpa_s, ¶ms, mask);
2987 void wpas_update_mbo_connect_params(struct wpa_supplicant *wpa_s)
2997 if (wpa_s->wpa_state != WPA_COMPLETED || !wpa_s->current_ssid ||
2998 !wpa_s->current_bss ||
2999 !wpa_bss_get_vendor_ie(wpa_s->current_bss, MBO_IE_VENDOR_TYPE))
3003 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss,
3004 wpa_s->current_ssid, ¶ms, NULL);
3008 wpa_drv_update_connect_params(wpa_s, ¶ms, WPA_DRV_UPDATE_ASSOC_IES);
3019 struct wpa_supplicant *wpa_s = work->wpa_s;
3039 wpa_s->connect_work = NULL;
3042 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
3049 wpa_s->connect_work = work;
3051 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
3052 wpas_network_disabled(wpa_s, ssid)) {
3053 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
3054 wpas_connect_work_done(wpa_s);
3058 os_memcpy(prev_bssid, wpa_s->bssid, ETH_ALEN);
3060 wpa_s->reassociate = 0;
3061 wpa_s->eap_expected_failure = 0;
3063 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
3067 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
3070 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
3071 os_memset(wpa_s->bssid, 0, ETH_ALEN);
3072 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
3074 wpas_notify_bssid_changed(wpa_s);
3079 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
3082 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
3087 wpa_s->conf->ap_scan == 2 &&
3091 wpas_connect_work_done(wpa_s);
3092 wpa_s->scan_req = MANUAL_SCAN_REQ;
3093 wpa_s->reassociate = 1;
3094 wpa_supplicant_req_scan(wpa_s, 0, 0);
3098 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
3101 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
3103 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
3105 if (!wpa_s->pno)
3106 wpa_supplicant_cancel_sched_scan(wpa_s);
3108 wpa_supplicant_cancel_scan(wpa_s);
3112 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
3114 wpa_ie = wpas_populate_assoc_ies(wpa_s, bss, ssid, ¶ms, NULL);
3116 wpas_connect_work_done(wpa_s);
3120 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
3122 cipher_pairwise = wpa_s->pairwise_cipher;
3123 cipher_group = wpa_s->group_cipher;
3124 cipher_group_mgmt = wpa_s->mgmt_group_cipher;
3125 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
3126 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3127 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
3129 if (wpa_set_wep_keys(wpa_s, ssid)) {
3134 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
3138 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
3153 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
3155 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
3158 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
3162 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set ||
3163 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3169 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS);
3186 wpa_s->conf->ap_scan == 2) {
3194 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
3201 params.beacon_int = wpa_s->conf->beacon_int;
3207 params.key_mgmt_suite = wpa_s->key_mgmt;
3208 params.wpa_proto = wpa_s->wpa_proto;
3209 wpa_s->auth_alg = params.auth_alg;
3219 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) &&
3227 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X) &&
3234 if (wpa_s->conf->key_mgmt_offload) {
3241 wpa_s->conf->okc : ssid->proactive_key_caching;
3255 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid);
3262 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
3277 if (wpa_s->p2pdev->set_sta_uapsd)
3278 params.uapsd = wpa_s->p2pdev->sta_uapsd;
3287 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
3294 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms);
3303 if (wpa_s->num_multichan_concurrent < 2) {
3305 num = get_shared_radio_freqs(wpa_s, &freq, 1);
3311 wpa_s, params.freq.freq, ssid) < 0) {
3312 wpas_connect_work_done(wpa_s);
3320 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
3321 wpa_s->current_ssid)
3324 ret = wpa_drv_associate(wpa_s, ¶ms);
3327 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
3329 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
3335 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
3336 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
3337 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
3345 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
3348 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
3351 wpa_supplicant_cancel_auth_timeout(wpa_s);
3352 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
3355 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
3356 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
3361 wpa_supplicant_cancel_auth_timeout(wpa_s);
3370 } else if (wpa_s->conf->ap_scan == 1) {
3374 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3378 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
3380 wpa_set_wep_keys(wpa_s, ssid);
3383 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
3388 eapol_sm_invalidate_cached_session(wpa_s->eapol);
3390 old_ssid = wpa_s->current_ssid;
3391 wpa_s->current_ssid = ssid;
3393 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
3394 wpa_s->current_bss = bss;
3396 hs20_configure_frame_filters(wpa_s);
3400 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
3401 wpa_supplicant_initiate_eapol(wpa_s);
3402 if (old_ssid != wpa_s->current_ssid)
3403 wpas_notify_network_changed(wpa_s);
3407 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
3412 wpas_connect_work_done(wpa_s);
3413 wpa_clear_keys(wpa_s, addr);
3414 old_ssid = wpa_s->current_ssid;
3415 wpa_supplicant_mark_disassoc(wpa_s);
3416 wpa_sm_set_config(wpa_s->wpa, NULL);
3417 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3418 if (old_ssid != wpa_s->current_ssid)
3419 wpas_notify_network_changed(wpa_s);
3420 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3426 * @wpa_s: Pointer to wpa_supplicant data
3432 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
3439 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
3441 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
3443 wpa_supplicant_state_txt(wpa_s->wpa_state));
3445 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
3446 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
3447 wpa_s->wpa_state == WPA_ASSOCIATING))
3448 addr = wpa_s->pending_bssid;
3449 else if (!is_zero_ether_addr(wpa_s->bssid))
3450 addr = wpa_s->bssid;
3451 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
3458 addr = wpa_s->bssid;
3462 if (wpa_s->enabled_4addr_mode && wpa_drv_set_4addr_mode(wpa_s, 0) == 0)
3463 wpa_s->enabled_4addr_mode = 0;
3466 wpa_tdls_teardown_peers(wpa_s->wpa);
3470 if (wpa_s->ifmsh) {
3473 mconf = wpa_s->ifmsh->mconf;
3474 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
3475 wpa_s->ifname);
3476 wpas_notify_mesh_group_removed(wpa_s, mconf->meshid,
3478 wpa_supplicant_leave_mesh(wpa_s);
3483 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
3487 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
3492 wpa_supplicant_clear_connection(wpa_s, addr);
3495 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
3503 wpas_clear_temp_disabled(wpa_s, ssid, 1);
3504 wpas_notify_network_enabled_changed(wpa_s, ssid);
3510 if (!wpa_s->current_ssid && !wpa_s->disconnected)
3511 wpa_s->reassociate = 1;
3517 * @wpa_s: wpa_supplicant structure for a network interface
3526 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s)
3530 ssid = wpa_config_add_network(wpa_s->conf);
3533 wpas_notify_network_added(wpa_s, ssid);
3543 * @wpa_s: wpa_supplicant structure for a network interface
3554 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id)
3559 ssid = wpa_config_get_network(wpa_s->conf, id);
3562 wpas_notify_network_removed(wpa_s, ssid);
3564 if (wpa_s->last_ssid == ssid)
3565 wpa_s->last_ssid = NULL;
3567 if (ssid == wpa_s->current_ssid || !wpa_s->current_ssid) {
3569 wpa_s->sme.prev_bssid_set = 0;
3575 eapol_sm_invalidate_cached_session(wpa_s->eapol);
3578 if (ssid == wpa_s->current_ssid) {
3579 wpa_sm_set_config(wpa_s->wpa, NULL);
3580 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3582 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3583 wpa_s->own_disconnect_req = 1;
3584 wpa_supplicant_deauthenticate(wpa_s,
3590 if (wpa_config_remove_network(wpa_s->conf, id) < 0)
3593 if (!was_disabled && wpa_s->sched_scanning) {
3596 wpa_supplicant_cancel_sched_scan(wpa_s);
3597 wpa_supplicant_req_scan(wpa_s, 0, 0);
3606 * @wpa_s: wpa_supplicant structure for a network interface
3611 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
3615 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3616 wpa_supplicant_enable_one_network(wpa_s, ssid);
3618 wpa_supplicant_enable_one_network(wpa_s, ssid);
3620 if (wpa_s->reassociate && !wpa_s->disconnected &&
3621 (!wpa_s->current_ssid ||
3622 wpa_s->wpa_state == WPA_DISCONNECTED ||
3623 wpa_s->wpa_state == WPA_SCANNING)) {
3624 if (wpa_s->sched_scanning) {
3627 wpa_supplicant_cancel_sched_scan(wpa_s);
3630 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
3631 wpa_s->scan_req = NORMAL_SCAN_REQ;
3632 wpa_supplicant_req_scan(wpa_s, 0, 0);
3640 * @wpa_s: wpa_supplicant structure for a network interface
3645 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
3652 if (wpa_s->sched_scanning)
3653 wpa_supplicant_cancel_sched_scan(wpa_s);
3655 for (other_ssid = wpa_s->conf->ssid; other_ssid;
3666 wpa_s, other_ssid);
3668 if (wpa_s->current_ssid) {
3669 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3670 wpa_s->own_disconnect_req = 1;
3672 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3675 if (ssid == wpa_s->current_ssid) {
3676 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3677 wpa_s->own_disconnect_req = 1;
3679 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3687 wpas_notify_network_enabled_changed(wpa_s, ssid);
3688 if (wpa_s->sched_scanning) {
3691 wpa_supplicant_cancel_sched_scan(wpa_s);
3692 wpa_supplicant_req_scan(wpa_s, 0, 0);
3701 * @wpa_s: wpa_supplicant structure for a network interface
3704 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
3711 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
3712 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3713 wpa_s->own_disconnect_req = 1;
3715 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3720 wpas_clear_temp_disabled(wpa_s, ssid, 1);
3726 for (other_ssid = wpa_s->conf->ssid; other_ssid;
3734 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
3737 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
3740 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
3741 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
3749 wpa_s->current_ssid = ssid;
3750 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3751 wpa_s->connect_without_scan =
3758 os_free(wpa_s->next_scan_freqs);
3759 wpa_s->next_scan_freqs = NULL;
3761 wpa_s->connect_without_scan = NULL;
3764 wpa_s->disconnected = 0;
3765 wpa_s->reassociate = 1;
3766 wpa_s->last_owe_group = 0;
3770 if (wpa_s->connect_without_scan ||
3771 wpa_supplicant_fast_associate(wpa_s) != 1) {
3772 wpa_s->scan_req = NORMAL_SCAN_REQ;
3773 wpas_scan_reset_sched_scan(wpa_s);
3774 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
3778 wpas_notify_network_selected(wpa_s, ssid);
3784 * @wpa_s: wpa_supplicant structure for a network interface
3793 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
3813 os_free(wpa_s->conf->pkcs11_engine_path);
3814 os_free(wpa_s->conf->pkcs11_module_path);
3815 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
3816 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
3818 wpa_sm_set_eapol(wpa_s->wpa, NULL);
3819 eapol_sm_deinit(wpa_s->eapol);
3820 wpa_s->eapol = NULL;
3821 if (wpa_supplicant_init_eapol(wpa_s)) {
3824 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
3829 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3837 * @wpa_s: wpa_supplicant structure for a network interface
3842 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
3850 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3856 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
3857 wpa_s->wpa_state >= WPA_ASSOCIATING &&
3858 wpa_s->wpa_state < WPA_COMPLETED) {
3860 "associating", wpa_s->conf->ap_scan, ap_scan);
3865 old_ap_scan = wpa_s->conf->ap_scan;
3866 wpa_s->conf->ap_scan = ap_scan;
3868 if (old_ap_scan != wpa_s->conf->ap_scan)
3869 wpas_notify_ap_scan_changed(wpa_s);
3877 * @wpa_s: wpa_supplicant structure for a network interface
3882 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
3886 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
3890 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
3892 wpa_s->conf->bss_expiration_age = bss_expire_age;
3900 * @wpa_s: wpa_supplicant structure for a network interface
3905 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
3909 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
3913 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
3915 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
3923 * @wpa_s: wpa_supplicant structure for a network interface
3928 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
3932 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
3936 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3938 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3987 static int owe_trans_ssid_match(struct wpa_supplicant *wpa_s, const u8 *bssid,
3997 bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
4023 * @wpa_s: Pointer to wpa_supplicant data
4026 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
4035 res = wpa_drv_get_ssid(wpa_s, ssid);
4037 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
4043 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
4044 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
4049 wired = wpa_s->conf->ap_scan == 0 &&
4050 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
4052 entry = wpa_s->conf->ssid;
4054 if (!wpas_network_disabled(wpa_s, entry) &&
4063 if (!wpas_network_disabled(wpa_s, entry) &&
4072 if (!wpas_network_disabled(wpa_s, entry) &&
4073 owe_trans_ssid_match(wpa_s, bssid, entry->ssid,
4080 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
4092 static int select_driver(struct wpa_supplicant *wpa_s, int i)
4094 struct wpa_global *global = wpa_s->global;
4105 wpa_s->driver = wpa_drivers[i];
4106 wpa_s->global_drv_priv = global->drv_priv[i];
4112 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
4119 if (wpa_s == NULL)
4123 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
4130 return select_driver(wpa_s, 0);
4145 if (select_driver(wpa_s, i) == 0)
4153 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
4160 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
4175 struct wpa_supplicant *wpa_s = ctx;
4177 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
4181 if (wpa_s->ignore_auth_resp) {
4187 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
4188 (wpa_s->last_eapol_matches_bssid &&
4190 !wpa_s->ap_iface &&
4192 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
4205 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
4207 wpa_supplicant_state_txt(wpa_s->wpa_state),
4208 MAC2STR(wpa_s->bssid));
4209 wpabuf_free(wpa_s->pending_eapol_rx);
4210 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
4211 if (wpa_s->pending_eapol_rx) {
4212 os_get_reltime(&wpa_s->pending_eapol_rx_time);
4213 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
4219 wpa_s->last_eapol_matches_bssid =
4220 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
4223 if (wpa_s->ap_iface) {
4224 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
4229 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
4230 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
4235 if (wpa_s->eapol_received == 0 &&
4236 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) ||
4237 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
4238 wpa_s->wpa_state != WPA_COMPLETED) &&
4239 (wpa_s->current_ssid == NULL ||
4240 wpa_s->current_ssid->mode != WPAS_MODE_IBSS)) {
4244 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
4245 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
4246 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
4252 if (wpa_s->current_ssid && wpa_s->current_bss &&
4253 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
4254 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
4263 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
4265 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
4271 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
4273 wpa_s->eapol_received++;
4275 if (wpa_s->countermeasures) {
4276 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
4282 if (wpa_s->current_ssid &&
4283 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
4284 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
4295 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
4296 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
4297 wpa_s->key_mgmt != WPA_KEY_MGMT_OWE &&
4298 wpa_s->key_mgmt != WPA_KEY_MGMT_DPP &&
4299 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
4301 wpa_drv_poll(wpa_s);
4302 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK))
4303 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
4304 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
4311 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
4316 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
4318 if ((!wpa_s->p2p_mgmt ||
4319 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
4320 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
4321 l2_packet_deinit(wpa_s->l2);
4322 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
4323 wpa_drv_get_mac_addr(wpa_s),
4325 wpa_supplicant_rx_eapol, wpa_s, 0);
4326 if (wpa_s->l2 == NULL)
4329 if (l2_packet_set_packet_filter(wpa_s->l2,
4331 wpa_dbg(wpa_s, MSG_DEBUG,
4334 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
4336 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
4339 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
4340 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
4344 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
4353 struct wpa_supplicant *wpa_s = ctx;
4360 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
4362 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
4368 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
4370 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
4377 * @wpa_s: Pointer to wpa_supplicant data
4384 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
4388 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
4391 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
4392 MAC2STR(wpa_s->own_addr));
4393 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
4394 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
4396 if (wpa_s->bridge_ifname[0]) {
4397 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge "
4398 "interface '%s'", wpa_s->bridge_ifname);
4399 wpa_s->l2_br = l2_packet_init_bridge(
4400 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
4401 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
4402 if (wpa_s->l2_br == NULL) {
4403 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
4405 wpa_s->bridge_ifname);
4410 if (wpa_s->conf->ap_scan == 2 &&
4411 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
4416 wpa_clear_keys(wpa_s, NULL);
4420 wpa_drv_set_countermeasures(wpa_s, 0);
4422 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
4423 wpa_drv_flush_pmkid(wpa_s);
4425 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
4426 wpa_s->prev_scan_wildcard = 0;
4428 if (wpa_supplicant_enabled_networks(wpa_s)) {
4429 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
4430 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
4434 if (!wpa_s->p2p_mgmt &&
4435 wpa_supplicant_delayed_sched_scan(wpa_s,
4438 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
4443 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
4459 struct wpa_supplicant *wpa_s;
4461 wpa_s = os_zalloc(sizeof(*wpa_s));
4462 if (wpa_s == NULL)
4464 wpa_s->scan_req = INITIAL_SCAN_REQ;
4465 wpa_s->scan_interval = 5;
4466 wpa_s->new_connection = 1;
4467 wpa_s->parent = parent ? parent : wpa_s;
4468 wpa_s->p2pdev = wpa_s->parent;
4469 wpa_s->sched_scanning = 0;
4471 dl_list_init(&wpa_s->bss_tmp_disallowed);
4472 dl_list_init(&wpa_s->fils_hlp_req);
4474 return wpa_s;
4480 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
4497 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
4506 wpa_msg(wpa_s, MSG_DEBUG,
4515 wpa_msg(wpa_s, MSG_ERROR,
4537 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
4547 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
4560 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
4568 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
4571 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
4584 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
4592 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
4595 wpa_msg(wpa_s, MSG_ERROR,
4609 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
4615 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
4624 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
4634 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
4647 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
4656 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
4669 static int wpa_set_tx_stbc(struct wpa_supplicant *wpa_s,
4679 wpa_msg(wpa_s, MSG_DEBUG, "set_tx_stbc: %d", tx_stbc);
4682 wpa_msg(wpa_s, MSG_ERROR,
4695 static int wpa_set_rx_stbc(struct wpa_supplicant *wpa_s,
4705 wpa_msg(wpa_s, MSG_DEBUG, "set_rx_stbc: %d", rx_stbc);
4708 wpa_msg(wpa_s, MSG_ERROR,
4722 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4737 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
4738 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
4740 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
4741 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
4742 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
4743 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
4744 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
4745 wpa_set_rx_stbc(wpa_s, htcaps, htcaps_mask, ssid->rx_stbc);
4746 wpa_set_tx_stbc(wpa_s, htcaps, htcaps_mask, ssid->tx_stbc);
4760 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4786 wpa_msg(wpa_s, MSG_DEBUG,
4800 wpa_set_ampdu_factor(wpa_s,
4835 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
4840 if (!wpa_s->conf->pcsc_reader)
4843 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
4844 if (!wpa_s->scard)
4847 if (wpa_s->conf->pcsc_pin &&
4848 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
4849 scard_deinit(wpa_s->scard);
4850 wpa_s->scard = NULL;
4851 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
4855 len = sizeof(wpa_s->imsi) - 1;
4856 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
4857 scard_deinit(wpa_s->scard);
4858 wpa_s->scard = NULL;
4859 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
4862 wpa_s->imsi[len] = '\0';
4864 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
4867 wpa_s->imsi, wpa_s->mnc_len);
4869 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
4870 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
4877 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
4881 ext_password_deinit(wpa_s->ext_pw);
4882 wpa_s->ext_pw = NULL;
4883 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
4885 if (!wpa_s->conf->ext_password_backend)
4888 val = os_strdup(wpa_s->conf->ext_password_backend);
4897 wpa_s->ext_pw = ext_password_init(val, pos);
4899 if (wpa_s->ext_pw == NULL) {
4903 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
4913 struct wpa_supplicant *wpa_s = ctx;
4915 return (is_zero_ether_addr(wpa_s->bssid) ||
4916 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
4924 struct wpa_supplicant *wpa_s = ctx;
4926 if (wpa_s->current_bss) {
4927 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
4929 } else if (wpa_s->hw.num_modes) {
4930 *hw_mode = wpa_s->hw.modes[0].mode;
4940 struct wpa_supplicant *wpa_s = ctx;
4942 *modes = wpa_s->hw.modes;
4943 return wpa_s->hw.num_modes;
4949 struct wpa_supplicant *wpa_s = ctx;
4952 wpa_s->fst_ies = fst_ies;
4958 struct wpa_supplicant *wpa_s = ctx;
4960 if (os_memcmp(wpa_s->bssid, da, ETH_ALEN) != 0) {
4962 __func__, MAC2STR(wpa_s->bssid), MAC2STR(da));
4965 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
4966 wpa_s->own_addr, wpa_s->bssid,
4974 struct wpa_supplicant *wpa_s = ctx;
4976 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4977 return wpa_s->received_mb_ies;
4984 struct wpa_supplicant *wpa_s = ctx;
4987 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4990 wpabuf_free(wpa_s->received_mb_ies);
4991 wpa_s->received_mb_ies = mb_ies_by_info(&info);
5000 struct wpa_supplicant *wpa_s = ctx;
5003 if (!is_zero_ether_addr(wpa_s->bssid))
5004 return (wpa_s->received_mb_ies || !mb_only) ?
5005 wpa_s->bssid : NULL;
5017 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
5020 iface_obj->ctx = wpa_s;
5033 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
5039 if (!wpa_s->conf->wowlan_triggers)
5042 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
5044 ret = wpa_drv_wowlan(wpa_s, triggers);
5061 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
5075 for (i = 0; i < wpa_s->hw.num_modes; i++) {
5076 if (wpa_s->hw.modes[i].num_channels != 0) {
5077 if (wpa_s->hw.modes[i].mode ==
5079 wpa_s->hw.modes[i].mode ==
5082 else if (wpa_s->hw.modes[i].mode ==
5085 else if (wpa_s->hw.modes[i].mode ==
5088 else if (wpa_s->hw.modes[i].mode ==
5100 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
5103 struct wpa_supplicant *iface = wpa_s->global->ifaces;
5110 wpa_s->ifname, rn);
5111 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
5119 wpa_s->ifname, rn ? rn : "N/A");
5128 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
5136 if (work->wpa_s->scan_work == work) {
5138 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
5140 work->wpa_s->scan_work = NULL;
5144 if (work->wpa_s->p2p_scan_work == work) {
5146 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
5148 work->wpa_s->p2p_scan_work = NULL;
5153 work->wpa_s->radio->num_active_works--;
5154 wpa_dbg(work->wpa_s, MSG_DEBUG,
5157 work->wpa_s->radio->num_active_works);
5201 tmp->wpa_s->clear_driver_scan_cache))
5213 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
5233 if (active_work->wpa_s == tmp->wpa_s &&
5236 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
5257 tmp->wpa_s->clear_driver_scan_cache))
5260 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
5277 struct wpa_supplicant *wpa_s;
5285 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
5288 if (!(wpa_s &&
5289 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
5293 if (wpa_s && wpa_s->radio->external_scan_running) {
5307 wpa_s = work->wpa_s;
5310 wpa_dbg(wpa_s, MSG_DEBUG,
5319 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
5321 radio_work_check_next(wpa_s);
5331 * @wpa_s: wpa_supplicant data
5336 void radio_remove_works(struct wpa_supplicant *wpa_s,
5340 struct wpa_radio *radio = wpa_s->radio;
5348 if (!remove_all && work->wpa_s != wpa_s)
5351 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
5358 radio_work_check_next(wpa_s);
5362 void radio_remove_pending_work(struct wpa_supplicant *wpa_s, void *ctx)
5365 struct wpa_radio *radio = wpa_s->radio;
5370 wpa_dbg(wpa_s, MSG_DEBUG, "Free pending radio work '%s'@%p%s",
5378 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
5380 struct wpa_radio *radio = wpa_s->radio;
5386 wpa_s->ifname, radio->name);
5387 dl_list_del(&wpa_s->radio_list);
5388 radio_remove_works(wpa_s, NULL, 0);
5389 wpa_s->radio = NULL;
5399 void radio_work_check_next(struct wpa_supplicant *wpa_s)
5401 struct wpa_radio *radio = wpa_s->radio;
5405 if (wpa_s->ext_work_in_progress) {
5417 * @wpa_s: Pointer to wpa_supplicant data
5440 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
5445 struct wpa_radio *radio = wpa_s->radio;
5452 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
5456 work->wpa_s = wpa_s;
5464 work->bands = wpas_get_bands(wpa_s,
5468 work->bands = wpas_get_bands(wpa_s, NULL);
5470 was_empty = dl_list_empty(&wpa_s->radio->work);
5472 dl_list_add(&wpa_s->radio->work, &work->list);
5474 dl_list_add_tail(&wpa_s->radio->work, &work->list);
5476 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
5477 radio_work_check_next(wpa_s);
5478 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
5480 wpa_dbg(wpa_s, MSG_DEBUG,
5483 radio_work_check_next(wpa_s);
5499 struct wpa_supplicant *wpa_s = work->wpa_s;
5505 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %jd.%06ld seconds",
5510 radio_work_check_next(wpa_s);
5515 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
5518 struct wpa_radio *radio = wpa_s->radio;
5521 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
5529 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
5536 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
5539 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
5540 if (wpa_s->drv_priv == NULL) {
5546 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
5553 if (wpa_s->matched == WPA_IFACE_MATCHEDNULL)
5558 wpa_msg(wpa_s, level, "Failed to initialize driver "
5562 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
5563 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
5564 "driver_param '%s'", wpa_s->conf->driver_param);
5568 ifname = wpa_drv_get_ifname(wpa_s);
5569 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
5570 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
5572 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
5575 rn = wpa_driver_get_radio_name(wpa_s);
5579 wpa_s->radio = radio_add_interface(wpa_s, rn);
5580 if (wpa_s->radio == NULL)
5589 static void wpas_gas_server_tx_status(struct wpa_supplicant *wpa_s,
5601 gas_server_tx_status(wpa_s->gas_server, dst, data, data_len,
5609 struct wpa_supplicant *wpa_s = ctx;
5612 if (wait_time > wpa_s->max_remain_on_chan)
5613 wait_time = wpa_s->max_remain_on_chan;
5615 offchannel_send_action(wpa_s, freq, da, wpa_s->own_addr, broadcast,
5622 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
5638 wpa_s->confname = os_rel2abs_path(iface->confname);
5639 if (wpa_s->confname == NULL) {
5646 iface->confname, wpa_s->confname);
5648 wpa_s->confname = os_strdup(iface->confname);
5650 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
5651 if (wpa_s->conf == NULL) {
5653 "configuration '%s'.", wpa_s->confname);
5656 wpa_s->confanother = os_rel2abs_path(iface->confanother);
5657 if (wpa_s->confanother &&
5658 !wpa_config_read(wpa_s->confanother, wpa_s->conf)) {
5661 wpa_s->confanother);
5670 os_free(wpa_s->conf->ctrl_interface);
5671 wpa_s->conf->ctrl_interface =
5676 os_free(wpa_s->conf->driver_param);
5677 wpa_s->conf->driver_param =
5682 os_free(wpa_s->conf->ctrl_interface);
5683 wpa_s->conf->ctrl_interface = NULL;
5686 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
5689 if (wpa_s->conf == NULL) {
5698 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
5703 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
5705 wpa_s->matched = iface->matched;
5710 sizeof(wpa_s->bridge_ifname)) {
5715 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
5716 sizeof(wpa_s->bridge_ifname));
5720 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
5721 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
5727 if (wpas_init_driver(wpa_s, iface) < 0)
5730 if (wpa_supplicant_init_wpa(wpa_s) < 0)
5733 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
5734 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
5736 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
5738 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
5739 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
5740 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
5741 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5746 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
5747 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
5748 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
5749 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5754 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
5755 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
5756 wpa_s->conf->dot11RSNAConfigSATimeout)) {
5757 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5762 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
5763 &wpa_s->hw.num_modes,
5764 &wpa_s->hw.flags,
5766 if (wpa_s->hw.modes) {
5769 for (i = 0; i < wpa_s->hw.num_modes; i++) {
5770 if (wpa_s->hw.modes[i].vht_capab) {
5771 wpa_s->hw_capab = CAPAB_VHT;
5775 if (wpa_s->hw.modes[i].ht_capab &
5777 wpa_s->hw_capab = CAPAB_HT40;
5778 else if (wpa_s->hw.modes[i].ht_capab &&
5779 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
5780 wpa_s->hw_capab = CAPAB_HT;
5784 capa_res = wpa_drv_get_capa(wpa_s, &capa);
5786 wpa_s->drv_capa_known = 1;
5787 wpa_s->drv_flags = capa.flags;
5788 wpa_s->drv_enc = capa.enc;
5789 wpa_s->drv_smps_modes = capa.smps_modes;
5790 wpa_s->drv_rrm_flags = capa.rrm_flags;
5791 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
5792 wpa_s->max_scan_ssids = capa.max_scan_ssids;
5793 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
5794 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
5795 wpa_s->max_sched_scan_plan_interval =
5797 wpa_s->max_sched_scan_plan_iterations =
5799 wpa_s->sched_scan_supported = capa.sched_scan_supported;
5800 wpa_s->max_match_sets = capa.max_match_sets;
5801 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
5802 wpa_s->max_stations = capa.max_stations;
5803 wpa_s->extended_capa = capa.extended_capa;
5804 wpa_s->extended_capa_mask = capa.extended_capa_mask;
5805 wpa_s->extended_capa_len = capa.extended_capa_len;
5806 wpa_s->num_multichan_concurrent =
5808 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
5811 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
5812 if (wpa_s->sched_scan_supported &&
5814 wpa_s->mac_addr_rand_supported |=
5817 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
5818 if (wpa_s->extended_capa &&
5819 wpa_s->extended_capa_len >= 3 &&
5820 wpa_s->extended_capa[2] & 0x40)
5821 wpa_s->multi_bss_support = 1;
5823 if (wpa_s->max_remain_on_chan == 0)
5824 wpa_s->max_remain_on_chan = 1000;
5831 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
5832 wpa_s->p2p_mgmt = iface->p2p_mgmt;
5834 if (wpa_s->num_multichan_concurrent == 0)
5835 wpa_s->num_multichan_concurrent = 1;
5837 if (wpa_supplicant_driver_init(wpa_s) < 0)
5841 if (!iface->p2p_mgmt && wpa_tdls_init(wpa_s->wpa))
5845 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
5846 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
5847 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
5852 if (wpa_s->conf->fst_group_id) {
5856 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
5857 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
5859 cfg.priority = wpa_s->conf->fst_priority;
5860 cfg.llt = wpa_s->conf->fst_llt;
5862 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
5864 if (!wpa_s->fst) {
5865 wpa_msg(wpa_s, MSG_ERROR,
5867 wpa_s->ifname, cfg.group_id);
5873 if (wpas_wps_init(wpa_s))
5877 wpa_s->gas_server = gas_server_init(wpa_s, wpas_gas_server_tx);
5878 if (!wpa_s->gas_server) {
5885 if (wpas_dpp_init(wpa_s) < 0)
5889 if (wpa_supplicant_init_eapol(wpa_s) < 0)
5891 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
5893 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
5894 if (wpa_s->ctrl_iface == NULL) {
5903 wpa_s->conf->ctrl_interface);
5907 wpa_s->gas = gas_query_init(wpa_s);
5908 if (wpa_s->gas == NULL) {
5913 if ((!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) ||
5914 wpa_s->p2p_mgmt) &&
5915 wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
5916 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
5920 if (wpa_bss_init(wpa_s) < 0)
5925 dl_list_init(&wpa_s->mesh_external_pmksa_cache);
5934 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
5940 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, -1,
5941 wpa_s->imsi, &len);
5942 if (wpa_s->mnc_len > 0) {
5943 wpa_s->imsi[len] = '\0';
5945 wpa_s->imsi, wpa_s->mnc_len);
5952 if (pcsc_reader_init(wpa_s) < 0)
5955 if (wpas_init_ext_pw(wpa_s) < 0)
5958 wpas_rrm_reset(wpa_s);
5960 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5963 hs20_init(wpa_s);
5966 if (wpa_s->conf->oce) {
5967 if ((wpa_s->conf->oce & OCE_STA) &&
5968 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA))
5969 wpa_s->enable_oce = OCE_STA;
5970 if ((wpa_s->conf->oce & OCE_STA_CFON) &&
5971 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA_CFON)) {
5977 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
5980 wpa_supplicant_set_default_scan_ies(wpa_s);
5986 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
5989 struct wpa_global *global = wpa_s->global;
5992 if (wpa_s == wpa_s->parent)
5993 wpas_p2p_group_remove(wpa_s, "*");
5997 if (iface->p2pdev == wpa_s)
5999 if (iface == wpa_s || iface->parent != wpa_s) {
6005 iface->ifname, wpa_s->ifname);
6011 wpa_s->disconnected = 1;
6012 if (wpa_s->drv_priv) {
6013 wpa_supplicant_deauthenticate(wpa_s,
6016 wpa_drv_set_countermeasures(wpa_s, 0);
6017 wpa_clear_keys(wpa_s, NULL);
6020 wpa_supplicant_cleanup(wpa_s);
6021 wpas_p2p_deinit_iface(wpa_s);
6023 wpas_ctrl_radio_work_flush(wpa_s);
6024 radio_remove_interface(wpa_s);
6027 if (wpa_s->fst) {
6028 fst_detach(wpa_s->fst);
6029 wpa_s->fst = NULL;
6031 if (wpa_s->received_mb_ies) {
6032 wpabuf_free(wpa_s->received_mb_ies);
6033 wpa_s->received_mb_ies = NULL;
6037 if (wpa_s->drv_priv)
6038 wpa_drv_deinit(wpa_s);
6041 wpas_notify_iface_removed(wpa_s);
6044 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
6046 if (wpa_s->ctrl_iface) {
6047 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
6048 wpa_s->ctrl_iface = NULL;
6052 if (wpa_s->ifmsh) {
6053 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
6054 wpa_s->ifmsh = NULL;
6058 if (wpa_s->conf != NULL) {
6059 wpa_config_free(wpa_s->conf);
6060 wpa_s->conf = NULL;
6063 os_free(wpa_s->ssids_from_scan_req);
6065 os_free(wpa_s);
6112 struct wpa_supplicant *wpa_s;
6122 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
6123 if (wpa_s)
6127 wpa_s = wpa_supplicant_add_iface(global, iface, NULL);
6156 struct wpa_supplicant *wpa_s;
6163 wpa_s = wpa_supplicant_alloc(parent);
6164 if (wpa_s == NULL)
6167 wpa_s->global = global;
6184 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
6187 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
6193 if (wpas_notify_iface_added(wpa_s)) {
6194 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
6198 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
6199 wpas_notify_network_added(wpa_s, ssid);
6202 wpa_s->next = global->ifaces;
6203 global->ifaces = wpa_s;
6205 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
6206 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
6209 if (wpa_s->global->p2p == NULL &&
6210 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
6211 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
6213 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
6220 return wpa_s;
6227 * @wpa_s: Pointer to the network interface to be removed
6236 struct wpa_supplicant *wpa_s,
6241 unsigned int mesh_if_created = wpa_s->mesh_if_created;
6243 struct wpa_supplicant *parent = wpa_s->parent;
6248 if (prev == wpa_s) {
6249 global->ifaces = wpa_s->next;
6251 while (prev && prev->next != wpa_s)
6255 prev->next = wpa_s->next;
6258 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
6262 ifname = os_strdup(wpa_s->ifname);
6264 wpa_dbg(wpa_s, MSG_ERROR,
6271 if (global->p2p_group_formation == wpa_s)
6273 if (global->p2p_invite_group == wpa_s)
6275 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
6290 * @wpa_s: Pointer to the network interface
6293 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
6297 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
6298 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
6302 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
6319 struct wpa_supplicant *wpa_s;
6321 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6322 if (os_strcmp(wpa_s->ifname, ifname) == 0)
6323 return wpa_s;
6332 struct wpa_supplicant *wpa_s = ctx;
6333 if (wpa_s == NULL)
6335 return wpa_s->ifname;
6348 struct wpa_supplicant *wpa_s;
6358 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6359 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
6361 ap_periodic(wpa_s);
6525 struct wpa_supplicant *wpa_s;
6538 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
6539 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
6541 wpa_s->ctrl_iface);
6623 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
6625 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
6626 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
6628 country[0] = wpa_s->conf->country[0];
6629 country[1] = wpa_s->conf->country[1];
6631 if (wpa_drv_set_country(wpa_s, country) < 0) {
6637 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
6638 wpas_init_ext_pw(wpa_s);
6640 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
6641 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
6643 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WOWLAN_TRIGGERS) {
6645 int res = wpa_drv_get_capa(wpa_s, &capa);
6647 if (res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
6650 wpa_s->conf->wowlan_triggers);
6653 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DISABLE_BTM)
6654 wpa_supplicant_set_default_scan_ies(wpa_s);
6657 wpas_wps_update_config(wpa_s);
6659 wpas_p2p_update_config(wpa_s);
6660 wpa_s->conf->changed_parameters = 0;
6678 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
6689 cbss = wpa_s->current_bss;
6691 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
6696 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
6712 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
6718 wpas_connect_work_done(wpa_s);
6723 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
6729 if (wpa_s->own_disconnect_req) {
6730 wpa_s->own_disconnect_req = 0;
6731 wpa_dbg(wpa_s, MSG_DEBUG,
6735 if (wpa_s->disconnected) {
6736 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
6750 count = wpa_blacklist_add(wpa_s, bssid);
6751 if (count == 1 && wpa_s->current_bss) {
6758 freqs = get_bss_freqs_in_ess(wpa_s);
6760 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
6762 wpa_blacklist_add(wpa_s, bssid);
6768 os_free(wpa_s->next_scan_freqs);
6769 wpa_s->next_scan_freqs = freqs;
6777 count += wpa_s->extra_blacklist_count;
6779 if (count > 3 && wpa_s->current_ssid) {
6782 wpas_auth_failed(wpa_s, "CONN_FAILED");
6803 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
6812 wpa_s->normal_scans = 0;
6813 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
6819 void fils_connection_failure(struct wpa_supplicant *wpa_s)
6821 struct wpa_ssid *ssid = wpa_s->current_ssid;
6827 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap,
6837 os_free(wpa_s->last_con_fail_realm);
6838 wpa_s->last_con_fail_realm = os_malloc(realm_len);
6839 if (wpa_s->last_con_fail_realm) {
6840 wpa_s->last_con_fail_realm_len = realm_len;
6841 os_memcpy(wpa_s->last_con_fail_realm, realm, realm_len);
6847 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
6849 return wpa_s->conf->ap_scan == 2 ||
6850 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
6855 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
6873 if (ssid == wpa_s->current_ssid)
6874 wpa_s->reassociate = 1;
6881 if (ssid == wpa_s->current_ssid)
6882 wpa_s->reassociate = 1;
6889 if (ssid == wpa_s->current_ssid)
6890 wpa_s->reassociate = 1;
6896 if (ssid == wpa_s->current_ssid)
6897 wpa_s->reassociate = 1;
6911 if (ssid == wpa_s->current_ssid)
6912 wpa_s->reassociate = 1;
6925 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
6926 wpa_supplicant_req_scan(wpa_s, 0, 0);
6952 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6957 if (wpa_s->p2p_mgmt)
6966 if (wpa_s->drv_capa_known)
6967 drv_enc = wpa_s->drv_enc;
6994 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6998 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
6999 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
7021 return wpa_s->conf->pmf;
7031 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
7033 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
7035 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
7041 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
7043 struct wpa_ssid *ssid = wpa_s->current_ssid;
7060 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
7094 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
7101 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
7108 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
7119 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
7123 if (wpa_s->disallow_aps_bssid == NULL)
7126 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
7127 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
7136 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
7141 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
7144 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
7145 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
7157 * @wpa_s: Pointer to the network interface
7163 void wpas_request_connection(struct wpa_supplicant *wpa_s)
7165 wpa_s->normal_scans = 0;
7166 wpa_s->scan_req = NORMAL_SCAN_REQ;
7167 wpa_supplicant_reinit_autoscan(wpa_s);
7168 wpa_s->extra_blacklist_count = 0;
7169 wpa_s->disconnected = 0;
7170 wpa_s->reassociate = 1;
7171 wpa_s->last_owe_group = 0;
7173 if (wpa_supplicant_fast_associate(wpa_s) != 1)
7174 wpa_supplicant_req_scan(wpa_s, 0, 0);
7176 wpa_s->reattach = 0;
7182 * @wpa_s: Pointer to the network interface
7187 void wpas_request_disconnection(struct wpa_supplicant *wpa_s)
7190 wpa_s->sme.prev_bssid_set = 0;
7192 wpa_s->reassociate = 0;
7193 wpa_s->disconnected = 1;
7194 wpa_supplicant_cancel_sched_scan(wpa_s);
7195 wpa_supplicant_cancel_scan(wpa_s);
7196 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
7197 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
7198 radio_remove_works(wpa_s, "connect", 0);
7199 radio_remove_works(wpa_s, "sme-connect", 0);
7203 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
7209 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
7213 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
7224 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
7233 wpa_dbg(wpa_s, MSG_DEBUG,
7237 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
7269 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
7278 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
7290 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
7301 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
7318 return wpa_s->p2pdev;
7321 return wpa_s;
7326 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
7334 if (wpa_s->vendor_elem[i]) {
7340 wpa_s->vendor_elem[i]);
7346 if (wpa_s->parent == wpa_s &&
7347 wpa_s->global->p2p &&
7348 !wpa_s->global->p2p_disabled)
7349 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
7354 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
7359 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
7360 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
7368 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
7369 wpabuf_free(wpa_s->vendor_elem[frame]);
7370 wpa_s->vendor_elem[frame] = NULL;
7373 wpa_s->vendor_elem[frame]->used -= len;
7375 wpas_vendor_elem_update(wpa_s);
7398 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
7403 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
7413 static int wpa_set_driver_tmp_disallow_list(struct wpa_supplicant *wpa_s)
7420 bssids = os_malloc(dl_list_len(&wpa_s->bss_tmp_disallowed) * ETH_ALEN);
7423 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed,
7429 ret = wpa_drv_set_bssid_blacklist(wpa_s, num_bssid, bssids);
7437 struct wpa_supplicant *wpa_s = eloop_ctx;
7441 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed,
7446 wpa_set_driver_tmp_disallow_list(wpa_s);
7453 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
7458 bss = wpas_get_disallowed_bss(wpa_s, bssid);
7460 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss);
7472 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
7473 wpa_set_driver_tmp_disallow_list(wpa_s);
7478 wpa_s, bss);
7482 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s,
7487 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
7505 int wpas_enable_mac_addr_randomization(struct wpa_supplicant *wpa_s,
7522 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCAN,
7528 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCHED_SCAN,
7532 if (wpa_s->sched_scanning && !wpa_s->pno)
7533 wpas_scan_restart_sched_scan(wpa_s);
7537 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_PNO,
7541 if (wpa_s->pno) {
7542 wpas_stop_pno(wpa_s);
7543 wpas_start_pno(wpa_s);
7551 int wpas_disable_mac_addr_randomization(struct wpa_supplicant *wpa_s,
7554 wpas_mac_addr_rand_scan_clear(wpa_s, type);
7555 if (wpa_s->pno) {
7557 wpas_stop_pno(wpa_s);
7558 wpas_start_pno(wpa_s);
7560 } else if (wpa_s->sched_scanning && (type & MAC_ADDR_RAND_SCHED_SCAN)) {
7561 wpas_scan_restart_sched_scan(wpa_s);