Lines Matching refs:wpa_s
124 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s);
129 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
138 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL,
147 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,
160 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not "
166 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for "
171 switch (wpa_s->group_cipher) {
190 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for "
191 "WPA-None", wpa_s->group_cipher);
198 ret = wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen);
206 struct wpa_supplicant *wpa_s = eloop_ctx;
207 const u8 *bssid = wpa_s->bssid;
208 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
209 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
210 wpa_s->wpa_state == WPA_ASSOCIATING))
211 bssid = wpa_s->pending_bssid;
212 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.",
214 wpa_blacklist_add(wpa_s, bssid);
215 wpa_sm_notify_disassoc(wpa_s->wpa);
216 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
217 wpa_s->reassociate = 1;
218 wpas_notify_auth_timeout(wpa_s);
224 wpa_supplicant_req_scan(wpa_s, 1, 0);
230 * @wpa_s: Pointer to wpa_supplicant data
237 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
240 if (wpa_s->conf->ap_scan == 0 &&
241 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED))
244 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec "
246 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
247 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL);
253 * @wpa_s: Pointer to wpa_supplicant data
259 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
261 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout");
262 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
263 wpa_blacklist_del(wpa_s, wpa_s->bssid);
269 * @wpa_s: Pointer to wpa_supplicant data
274 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
278 struct wpa_ssid *ssid = wpa_s->current_ssid;
282 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
283 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
288 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
289 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE);
290 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
295 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
296 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE);
298 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
299 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
300 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized);
302 eapol_sm_notify_portControl(wpa_s->eapol, Auto);
305 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
316 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)
319 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth;
322 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) &&
323 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
324 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS;
325 eapol_conf.external_sim = wpa_s->conf->external_sim;
328 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
330 if (wpa_s->current_bss) {
332 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss,
344 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf);
347 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE && ssid->mka_psk_set)
348 ieee802_1x_create_preshared_mka(wpa_s, ssid);
350 ieee802_1x_alloc_kay_sm(wpa_s, ssid);
358 * @wpa_s: Pointer to wpa_supplicant data
365 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
371 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS;
373 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA;
375 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
376 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
377 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
378 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
379 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
380 wpa_s->group_cipher = WPA_CIPHER_NONE;
381 wpa_s->mgmt_group_cipher = 0;
385 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104;
386 wpa_s->group_cipher = WPA_CIPHER_WEP104;
389 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40;
390 wpa_s->group_cipher = WPA_CIPHER_WEP40;
395 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0);
396 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
397 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
398 wpa_s->pairwise_cipher);
399 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
401 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
402 wpa_s->mgmt_group_cipher);
405 pmksa_cache_clear_current(wpa_s->wpa);
409 void free_hw_features(struct wpa_supplicant *wpa_s)
412 if (wpa_s->hw.modes == NULL)
415 for (i = 0; i < wpa_s->hw.num_modes; i++) {
416 os_free(wpa_s->hw.modes[i].channels);
417 os_free(wpa_s->hw.modes[i].rates);
420 os_free(wpa_s->hw.modes);
421 wpa_s->hw.modes = NULL;
425 static void free_bss_tmp_disallowed(struct wpa_supplicant *wpa_s)
429 dl_list_for_each_safe(bss, prev, &wpa_s->bss_tmp_disallowed,
431 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss);
438 void wpas_flush_fils_hlp_req(struct wpa_supplicant *wpa_s)
442 while ((req = dl_list_first(&wpa_s->fils_hlp_req, struct fils_hlp_req,
451 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
455 bgscan_deinit(wpa_s);
456 autoscan_deinit(wpa_s);
457 scard_deinit(wpa_s->scard);
458 wpa_s->scard = NULL;
459 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL);
460 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL);
461 l2_packet_deinit(wpa_s->l2);
462 wpa_s->l2 = NULL;
463 if (wpa_s->l2_br) {
464 l2_packet_deinit(wpa_s->l2_br);
465 wpa_s->l2_br = NULL;
468 l2_packet_deinit(wpa_s->l2_test);
469 wpa_s->l2_test = NULL;
470 os_free(wpa_s->get_pref_freq_list_override);
471 wpa_s->get_pref_freq_list_override = NULL;
472 wpabuf_free(wpa_s->last_assoc_req_wpa_ie);
473 wpa_s->last_assoc_req_wpa_ie = NULL;
476 if (wpa_s->conf != NULL) {
478 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
479 wpas_notify_network_removed(wpa_s, ssid);
482 os_free(wpa_s->confname);
483 wpa_s->confname = NULL;
485 os_free(wpa_s->confanother);
486 wpa_s->confanother = NULL;
488 wpa_sm_set_eapol(wpa_s->wpa, NULL);
489 eapol_sm_deinit(wpa_s->eapol);
490 wpa_s->eapol = NULL;
492 rsn_preauth_deinit(wpa_s->wpa);
495 wpa_tdls_deinit(wpa_s->wpa);
498 wmm_ac_clear_saved_tspecs(wpa_s);
499 pmksa_candidate_free(wpa_s->wpa);
500 wpa_sm_deinit(wpa_s->wpa);
501 wpa_s->wpa = NULL;
502 wpa_blacklist_clear(wpa_s);
504 wpa_bss_deinit(wpa_s);
506 wpa_supplicant_cancel_delayed_sched_scan(wpa_s);
507 wpa_supplicant_cancel_scan(wpa_s);
508 wpa_supplicant_cancel_auth_timeout(wpa_s);
509 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
512 wpa_s, NULL);
515 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
517 wpas_wps_deinit(wpa_s);
519 wpabuf_free(wpa_s->pending_eapol_rx);
520 wpa_s->pending_eapol_rx = NULL;
523 ibss_rsn_deinit(wpa_s->ibss_rsn);
524 wpa_s->ibss_rsn = NULL;
527 sme_deinit(wpa_s);
530 wpa_supplicant_ap_deinit(wpa_s);
533 wpas_p2p_deinit(wpa_s);
536 offchannel_deinit(wpa_s);
539 wpa_supplicant_cancel_sched_scan(wpa_s);
541 os_free(wpa_s->next_scan_freqs);
542 wpa_s->next_scan_freqs = NULL;
544 os_free(wpa_s->manual_scan_freqs);
545 wpa_s->manual_scan_freqs = NULL;
546 os_free(wpa_s->select_network_scan_freqs);
547 wpa_s->select_network_scan_freqs = NULL;
549 os_free(wpa_s->manual_sched_scan_freqs);
550 wpa_s->manual_sched_scan_freqs = NULL;
552 wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL);
562 if (wpa_s->radio)
563 radio_remove_works(wpa_s, "gas-query", 0);
564 gas_query_deinit(wpa_s->gas);
565 wpa_s->gas = NULL;
566 gas_server_deinit(wpa_s->gas_server);
567 wpa_s->gas_server = NULL;
569 free_hw_features(wpa_s);
571 ieee802_1x_dealloc_kay_sm(wpa_s);
573 os_free(wpa_s->bssid_filter);
574 wpa_s->bssid_filter = NULL;
576 os_free(wpa_s->disallow_aps_bssid);
577 wpa_s->disallow_aps_bssid = NULL;
578 os_free(wpa_s->disallow_aps_ssid);
579 wpa_s->disallow_aps_ssid = NULL;
581 wnm_bss_keep_alive_deinit(wpa_s);
583 wnm_deallocate_memory(wpa_s);
586 ext_password_deinit(wpa_s->ext_pw);
587 wpa_s->ext_pw = NULL;
589 wpabuf_free(wpa_s->last_gas_resp);
590 wpa_s->last_gas_resp = NULL;
591 wpabuf_free(wpa_s->prev_gas_resp);
592 wpa_s->prev_gas_resp = NULL;
594 os_free(wpa_s->last_scan_res);
595 wpa_s->last_scan_res = NULL;
598 if (wpa_s->drv_priv)
599 wpa_drv_configure_frame_filters(wpa_s, 0);
600 hs20_deinit(wpa_s);
604 wpabuf_free(wpa_s->vendor_elem[i]);
605 wpa_s->vendor_elem[i] = NULL;
608 wmm_ac_notify_disassoc(wpa_s);
610 wpa_s->sched_scan_plans_num = 0;
611 os_free(wpa_s->sched_scan_plans);
612 wpa_s->sched_scan_plans = NULL;
615 wpa_s->non_pref_chan_num = 0;
616 os_free(wpa_s->non_pref_chan);
617 wpa_s->non_pref_chan = NULL;
620 free_bss_tmp_disallowed(wpa_s);
622 wpabuf_free(wpa_s->lci);
623 wpa_s->lci = NULL;
624 wpas_clear_beacon_rep_data(wpa_s);
631 while ((entry = dl_list_last(&wpa_s->mesh_external_pmksa_cache,
642 wpas_flush_fils_hlp_req(wpa_s);
644 wpabuf_free(wpa_s->ric_ies);
645 wpa_s->ric_ies = NULL;
648 wpas_dpp_deinit(wpa_s);
655 * @wpa_s: Pointer to wpa_supplicant data
661 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
673 if (wpa_s->keys_cleared & BIT(i))
675 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0,
678 if (!(wpa_s->keys_cleared & BIT(0)) && addr &&
680 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL,
684 wpa_s, addr,
688 wpa_s->keys_cleared = (u32) -1;
728 static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s)
732 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan)
733 name = wpa_s->current_ssid->bgscan;
735 name = wpa_s->conf->bgscan;
738 if (wpas_driver_bss_selection(wpa_s))
740 if (wpa_s->current_ssid == wpa_s->bgscan_ssid)
743 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
747 bgscan_deinit(wpa_s);
748 if (wpa_s->current_ssid) {
749 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) {
750 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
759 wpa_s->bgscan_ssid = wpa_s->current_ssid;
760 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL,
763 bgscan_notify_scan(wpa_s, scan_res);
768 wpa_s->bgscan_ssid = NULL;
772 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s)
774 if (wpa_s->bgscan_ssid != NULL) {
775 bgscan_deinit(wpa_s);
776 wpa_s->bgscan_ssid = NULL;
783 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s)
785 if (autoscan_init(wpa_s, 0))
786 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan");
790 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s)
792 autoscan_deinit(wpa_s);
796 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s)
798 if (wpa_s->wpa_state == WPA_DISCONNECTED ||
799 wpa_s->wpa_state == WPA_SCANNING) {
800 autoscan_deinit(wpa_s);
801 wpa_supplicant_start_autoscan(wpa_s);
808 * @wpa_s: Pointer to wpa_supplicant data
814 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
817 enum wpa_states old_state = wpa_s->wpa_state;
819 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s",
820 wpa_supplicant_state_txt(wpa_s->wpa_state),
825 wpa_s->normal_scans = 0;
829 wpas_connect_work_done(wpa_s);
831 wpa_s->normal_scans = 0;
841 if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid &&
842 wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
843 wpa_s->current_ssid->p2p_group) {
844 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) {
845 wpa_dbg(wpa_s, MSG_DEBUG,
847 wpa_s->p2p_cli_probe =
848 wpa_drv_probe_req_report(wpa_s, 1) >= 0;
849 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) {
850 wpa_dbg(wpa_s, MSG_DEBUG,
852 wpa_s->p2p_cli_probe = 0;
853 wpa_drv_probe_req_report(wpa_s, 0);
859 wpa_supplicant_notify_scanning(wpa_s, 0);
861 if (state == WPA_COMPLETED && wpa_s->new_connection) {
862 struct wpa_ssid *ssid = wpa_s->current_ssid;
866 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
867 wpa_auth_alg_fils(wpa_s->sme.auth_alg))
870 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
871 wpa_auth_alg_fils(wpa_s->auth_alg))
875 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to "
877 MAC2STR(wpa_s->bssid),
882 wpas_clear_temp_disabled(wpa_s, ssid, 1);
883 wpa_blacklist_clear(wpa_s);
884 wpa_s->extra_blacklist_count = 0;
885 wpa_s->new_connection = 0;
886 wpa_drv_set_operstate(wpa_s, 1);
888 wpa_drv_set_supp_port(wpa_s, 1);
890 wpa_s->after_wps = 0;
891 wpa_s->known_wps_freq = 0;
892 wpas_p2p_completed(wpa_s);
894 sme_sched_obss_scan(wpa_s, 1);
898 wpas_update_fils_connect_params(wpa_s);
902 wpa_s->new_connection = 1;
903 wpa_drv_set_operstate(wpa_s, 0);
905 wpa_drv_set_supp_port(wpa_s, 0);
907 sme_sched_obss_scan(wpa_s, 0);
909 wpa_s->wpa_state = state;
913 wpa_supplicant_start_bgscan(wpa_s);
915 wpa_supplicant_stop_bgscan(wpa_s);
919 wpa_supplicant_stop_autoscan(wpa_s);
922 wpa_supplicant_start_autoscan(wpa_s);
924 if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED)
925 wmm_ac_notify_disassoc(wpa_s);
927 if (wpa_s->wpa_state != old_state) {
928 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
934 wpas_p2p_indicate_state_change(wpa_s);
936 if (wpa_s->wpa_state == WPA_COMPLETED ||
938 wpas_notify_auth_changed(wpa_s);
947 struct wpa_supplicant *wpa_s = global->ifaces;
948 while (wpa_s) {
949 struct wpa_supplicant *next = wpa_s->next;
950 if (wpas_wps_terminate_pending(wpa_s) == 1)
953 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE ||
954 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group))
955 wpas_p2p_disconnect(wpa_s);
957 wpa_s = next;
973 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
975 enum wpa_states old_state = wpa_s->wpa_state;
977 wpa_s->pairwise_cipher = 0;
978 wpa_s->group_cipher = 0;
979 wpa_s->mgmt_group_cipher = 0;
980 wpa_s->key_mgmt = 0;
981 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED)
982 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
984 if (wpa_s->wpa_state != old_state)
985 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state);
991 * @wpa_s: Pointer to wpa_supplicant data
1000 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
1006 if (wpa_s->confname == NULL)
1008 conf = wpa_config_read(wpa_s->confname, NULL);
1010 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration "
1011 "file '%s' - exiting", wpa_s->confname);
1014 wpa_config_read(wpa_s->confanother, conf);
1018 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface
1019 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface &&
1021 wpa_s->conf->ctrl_interface) != 0);
1023 if (reconf_ctrl && wpa_s->ctrl_iface) {
1024 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
1025 wpa_s->ctrl_iface = NULL;
1028 eapol_sm_invalidate_cached_session(wpa_s->eapol);
1029 if (wpa_s->current_ssid) {
1030 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
1031 wpa_s->own_disconnect_req = 1;
1032 wpa_supplicant_deauthenticate(wpa_s,
1040 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
1041 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
1042 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) {
1047 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE);
1049 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1050 wpa_sm_set_config(wpa_s->wpa, NULL);
1051 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
1052 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
1053 rsn_preauth_deinit(wpa_s->wpa);
1055 old_ap_scan = wpa_s->conf->ap_scan;
1056 wpa_config_free(wpa_s->conf);
1057 wpa_s->conf = conf;
1058 if (old_ap_scan != wpa_s->conf->ap_scan)
1059 wpas_notify_ap_scan_changed(wpa_s);
1062 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
1064 wpa_supplicant_update_config(wpa_s);
1066 wpa_supplicant_clear_status(wpa_s);
1067 if (wpa_supplicant_enabled_networks(wpa_s)) {
1068 wpa_s->reassociate = 1;
1069 wpa_supplicant_req_scan(wpa_s, 0, 0);
1071 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed");
1079 struct wpa_supplicant *wpa_s;
1080 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
1081 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring",
1083 if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
1095 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s,
1099 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie);
1102 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE "
1108 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set "
1111 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group "
1117 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise "
1123 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key "
1131 wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) {
1132 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP "
1145 * @wpa_s: Pointer to wpa_supplicant data
1157 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
1177 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
1184 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
1188 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN");
1197 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN");
1198 wpa_dbg(wpa_s, MSG_DEBUG,
1202 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s",
1211 wpa_dbg(wpa_s, MSG_DEBUG,
1214 wpa_dbg(wpa_s, MSG_DEBUG,
1223 wpa_dbg(wpa_s, MSG_DEBUG,
1226 wpa_dbg(wpa_s, MSG_DEBUG,
1240 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) {
1265 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites "
1271 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d "
1276 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d",
1281 wpa_s->wpa_proto = proto;
1282 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto);
1283 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED,
1286 if (bss || !wpa_s->ap_ies_from_associnfo) {
1287 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
1289 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
1295 wpa_s->group_cipher = WPA_CIPHER_NONE;
1296 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
1299 wpa_s->group_cipher = wpa_pick_group_cipher(sel);
1300 if (wpa_s->group_cipher < 0) {
1301 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group "
1305 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s",
1306 wpa_cipher_txt(wpa_s->group_cipher));
1309 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1);
1310 if (wpa_s->pairwise_cipher < 0) {
1311 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise "
1315 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s",
1316 wpa_cipher_txt(wpa_s->pairwise_cipher));
1321 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE))
1327 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192;
1328 wpa_dbg(wpa_s, MSG_DEBUG,
1333 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B;
1334 wpa_dbg(wpa_s, MSG_DEBUG,
1340 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384;
1341 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA384");
1343 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256;
1344 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA256");
1347 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA384;
1348 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA384");
1350 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA256;
1351 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA256");
1355 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X;
1356 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X");
1358 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK;
1359 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK");
1363 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE;
1364 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE");
1366 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE;
1367 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE");
1371 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256;
1372 wpa_dbg(wpa_s, MSG_DEBUG,
1375 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256;
1376 wpa_dbg(wpa_s, MSG_DEBUG,
1380 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
1381 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X");
1383 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
1384 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK");
1386 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE;
1387 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE");
1390 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN;
1391 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN");
1395 wpa_s->key_mgmt = WPA_KEY_MGMT_OWE;
1396 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT OWE");
1400 wpa_s->key_mgmt = WPA_KEY_MGMT_DPP;
1401 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT DPP");
1404 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select "
1409 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt);
1410 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE,
1411 wpa_s->pairwise_cipher);
1412 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher);
1418 if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION ||
1422 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC;
1423 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1426 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128;
1427 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1430 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256;
1431 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1434 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256;
1435 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher "
1438 wpa_s->mgmt_group_cipher = 0;
1439 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher");
1441 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP,
1442 wpa_s->mgmt_group_cipher);
1443 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP,
1444 wpas_get_ssid_pmf(wpa_s, ssid));
1447 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) {
1448 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE");
1456 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN, NULL,
1472 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL, NULL);
1479 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw,
1485 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK "
1491 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected "
1510 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1518 wpa_msg(wpa_s, MSG_INFO, "EXT PW: "
1524 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL,
1529 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable "
1542 wpa_msg(wpa_s, MSG_INFO,
1547 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE) {
1553 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa);
1559 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx)
1579 if (wpa_s->conf->interworking)
1585 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING)
1591 if (wpa_s->conf->hs20)
1603 if (wpa_s->conf->ftm_responder)
1605 if (wpa_s->conf->ftm_initiator)
1617 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen)
1622 if (len < wpa_s->extended_capa_len)
1623 len = wpa_s->extended_capa_len;
1633 wpas_ext_capab_byte(wpa_s, pos, i);
1635 if (i < wpa_s->extended_capa_len) {
1636 *pos &= ~wpa_s->extended_capa_mask[i];
1637 *pos |= wpa_s->extended_capa[i];
1652 static int wpas_valid_bss(struct wpa_supplicant *wpa_s,
1657 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
1666 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s,
1671 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
1680 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s
1683 if (test_bss && !wpas_valid_bss(wpa_s, test_bss))
1686 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid);
1698 void wpas_connect_work_done(struct wpa_supplicant *wpa_s)
1701 struct wpa_radio_work *work = wpa_s->connect_work;
1706 wpa_s->connect_work = NULL;
1714 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style)
1720 if (wpa_s->last_mac_addr_style == style &&
1721 wpa_s->last_mac_addr_change.sec != 0 &&
1722 !os_reltime_expired(&now, &wpa_s->last_mac_addr_change,
1723 wpa_s->conf->rand_addr_lifetime)) {
1724 wpa_msg(wpa_s, MSG_DEBUG,
1735 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN);
1743 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
1744 wpa_msg(wpa_s, MSG_INFO,
1749 os_get_reltime(&wpa_s->last_mac_addr_change);
1750 wpa_s->mac_addr_changed = 1;
1751 wpa_s->last_mac_addr_style = style;
1753 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1754 wpa_msg(wpa_s, MSG_INFO,
1759 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
1766 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s)
1768 if (wpa_s->wpa_state >= WPA_AUTHENTICATING ||
1769 !wpa_s->conf->preassoc_mac_addr)
1772 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr);
1780 * @wpa_s: Pointer to wpa_supplicant data
1786 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
1792 wpa_s->own_disconnect_req = 0;
1798 wpabuf_free(wpa_s->pending_eapol_rx);
1799 wpa_s->pending_eapol_rx = NULL;
1802 rand_style = wpa_s->conf->mac_addr;
1806 wmm_ac_clear_saved_tspecs(wpa_s);
1807 wpa_s->reassoc_same_bss = 0;
1808 wpa_s->reassoc_same_ess = 0;
1810 wpa_s->testing_resend_assoc = 0;
1813 if (wpa_s->last_ssid == ssid) {
1814 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS");
1815 wpa_s->reassoc_same_ess = 1;
1816 if (wpa_s->current_bss && wpa_s->current_bss == bss) {
1817 wmm_ac_save_tspecs(wpa_s);
1818 wpa_s->reassoc_same_bss = 1;
1822 if (rand_style > 0 && !wpa_s->reassoc_same_ess) {
1823 if (wpas_update_random_addr(wpa_s, rand_style) < 0)
1825 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
1826 } else if (rand_style == 0 && wpa_s->mac_addr_changed) {
1827 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) {
1828 wpa_msg(wpa_s, MSG_INFO,
1832 wpa_s->mac_addr_changed = 0;
1833 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
1834 wpa_msg(wpa_s, MSG_INFO,
1838 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address");
1840 wpa_s->last_ssid = ssid;
1843 ibss_rsn_deinit(wpa_s->ibss_rsn);
1844 wpa_s->ibss_rsn = NULL;
1848 wpa_msg(wpa_s, MSG_INFO,
1857 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
1858 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP "
1862 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) {
1863 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
1865 wpas_p2p_ap_setup_failed(wpa_s);
1868 wpa_s->current_bss = bss;
1870 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in "
1878 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) {
1879 wpa_msg(wpa_s, MSG_INFO,
1885 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) {
1886 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh");
1889 wpa_s->current_bss = bss;
1890 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_STARTED "ssid=\"%s\" id=%d",
1893 wpas_notify_mesh_group_started(wpa_s, ssid);
1895 wpa_msg(wpa_s, MSG_ERROR,
1908 wpa_supplicant_rsn_supp_set_config(wpa_s, ssid);
1911 if (wpas_dpp_check_connect(wpa_s, ssid, bss) != 0)
1917 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1),
1921 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
1923 sme_authenticate(wpa_s, bss, ssid);
1927 if (wpa_s->connect_work) {
1928 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist");
1932 if (radio_work_pending(wpa_s, "connect")) {
1933 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist");
1940 wpa_s->sme.auth_alg = WPA_AUTH_ALG_OPEN;
1944 wpas_abort_ongoing_scan(wpa_s);
1953 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1,
1967 static int drv_supports_vht(struct wpa_supplicant *wpa_s,
1978 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
1979 if (wpa_s->hw.modes[i].mode == hw_mode) {
1980 mode = &wpa_s->hw.modes[i];
1992 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,
2011 for (j = 0; j < wpa_s->last_scan_res_used; j++) {
2012 struct wpa_bss *bss = wpa_s->last_scan_res[j];
2037 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS))
2040 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 ||
2041 wpa_s->group_cipher == WPA_CIPHER_WEP104 ||
2042 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) {
2049 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) {
2050 if (wpa_s->hw.modes[i].mode == hw_mode) {
2051 mode = &wpa_s->hw.modes[i];
2128 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0);
2163 if (!drv_supports_vht(wpa_s, ssid))
2168 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS))
2265 static size_t wpas_add_fils_hlp_req(struct wpa_supplicant *wpa_s, u8 *ie_buf,
2273 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
2299 os_memcpy(buf, wpa_s->own_addr, ETH_ALEN);
2335 struct wpa_supplicant *wpa_s,
2350 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req,
2372 wpa_s->conf->okc :
2379 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid,
2382 eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
2384 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
2386 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2398 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2400 wpa_s->wpa_proto = 0;
2403 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
2405 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA "
2421 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2426 wpa_s->wpa_proto = 0;
2429 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
2431 wpa_s->wpa_proto = 0;
2446 wpa_sm_set_reset_fils_completed(wpa_s->wpa, 0);
2448 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) &&
2449 ssid->eap.erp && wpa_key_mgmt_fils(wpa_s->key_mgmt) &&
2450 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, &username,
2468 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs);
2471 wpa_dbg(wpa_s, MSG_DEBUG,
2476 if (wpa_s->global->p2p) {
2482 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len,
2488 wpa_s->cross_connect_disallowed = 0;
2493 wpa_s->cross_connect_disallowed =
2496 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross "
2498 wpa_s->cross_connect_disallowed ?
2503 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info));
2507 wpa_ie_len += wpas_supp_op_class_ie(wpa_s, bss->freq,
2522 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT);
2524 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION);
2529 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab,
2544 if (is_hs20_network(wpa_s, ssid, bss)) {
2549 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid);
2561 hs20_configure_frame_filters(wpa_s);
2566 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) {
2567 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ];
2579 if (wpa_s->fst_ies) {
2580 int fst_ies_len = wpabuf_len(wpa_s->fst_ies);
2584 wpabuf_head(wpa_s->fst_ies), fst_ies_len);
2594 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len,
2605 len = wpas_add_fils_hlp_req(wpa_s, wpa_ie + wpa_ie_len,
2619 owe_ie = owe_build_assoc_req(wpa_s->wpa, group);
2641 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s)
2647 if (wpa_s->auth_alg != WPA_AUTH_ALG_OPEN)
2651 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss,
2652 wpa_s->current_ssid, ¶ms, &mask);
2661 wpa_s->auth_alg = params.auth_alg;
2662 wpa_drv_update_connect_params(wpa_s, ¶ms, mask);
2673 struct wpa_supplicant *wpa_s = work->wpa_s;
2693 wpa_s->connect_work = NULL;
2696 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s,
2703 wpa_s->connect_work = work;
2705 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) ||
2706 wpas_network_disabled(wpa_s, ssid)) {
2707 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt");
2708 wpas_connect_work_done(wpa_s);
2712 os_memcpy(prev_bssid, wpa_s->bssid, ETH_ALEN);
2714 wpa_s->reassociate = 0;
2715 wpa_s->eap_expected_failure = 0;
2717 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) {
2721 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
2724 bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
2725 os_memset(wpa_s->bssid, 0, ETH_ALEN);
2726 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2728 wpas_notify_bssid_changed(wpa_s);
2733 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0);
2736 wpa_ft_prepare_auth_request(wpa_s->wpa, ie);
2741 wpa_s->conf->ap_scan == 2 &&
2745 wpas_connect_work_done(wpa_s);
2746 wpa_s->scan_req = MANUAL_SCAN_REQ;
2747 wpa_s->reassociate = 1;
2748 wpa_supplicant_req_scan(wpa_s, 0, 0);
2752 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'",
2755 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
2757 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2759 if (!wpa_s->pno)
2760 wpa_supplicant_cancel_sched_scan(wpa_s);
2762 wpa_supplicant_cancel_scan(wpa_s);
2766 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
2768 wpa_ie = wpas_populate_assoc_ies(wpa_s, bss, ssid, ¶ms, NULL);
2770 wpas_connect_work_done(wpa_s);
2774 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL);
2776 cipher_pairwise = wpa_s->pairwise_cipher;
2777 cipher_group = wpa_s->group_cipher;
2778 cipher_group_mgmt = wpa_s->mgmt_group_cipher;
2779 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
2780 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2781 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE)
2783 if (wpa_set_wep_keys(wpa_s, ssid)) {
2788 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)
2792 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2807 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2809 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2812 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
2816 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set ||
2817 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
2823 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS);
2840 wpa_s->conf->ap_scan == 2) {
2848 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq);
2855 params.beacon_int = wpa_s->conf->beacon_int;
2861 params.key_mgmt_suite = wpa_s->key_mgmt;
2862 params.wpa_proto = wpa_s->wpa_proto;
2863 wpa_s->auth_alg = params.auth_alg;
2873 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) &&
2881 if (wpa_s->conf->key_mgmt_offload) {
2888 wpa_s->conf->okc : ssid->proactive_key_caching;
2902 wpa_s, ssid);
2909 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports "
2919 if (wpa_s->p2pdev->set_sta_uapsd)
2920 params.uapsd = wpa_s->p2pdev->sta_uapsd;
2929 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms);
2936 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms);
2945 if (wpa_s->num_multichan_concurrent < 2) {
2947 num = get_shared_radio_freqs(wpa_s, &freq, 1);
2953 wpa_s, params.freq.freq, ssid) < 0) {
2954 wpas_connect_work_done(wpa_s);
2962 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) &&
2963 wpa_s->current_ssid)
2966 ret = wpa_drv_associate(wpa_s, ¶ms);
2969 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver "
2971 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) {
2977 wpas_connection_failed(wpa_s, wpa_s->pending_bssid);
2978 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
2979 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
2987 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
2990 wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
2993 wpa_supplicant_cancel_auth_timeout(wpa_s);
2994 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
2997 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
2998 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
3003 wpa_supplicant_cancel_auth_timeout(wpa_s);
3012 } else if (wpa_s->conf->ap_scan == 1) {
3016 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3020 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) {
3022 wpa_set_wep_keys(wpa_s, ssid);
3025 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) {
3030 eapol_sm_invalidate_cached_session(wpa_s->eapol);
3032 old_ssid = wpa_s->current_ssid;
3033 wpa_s->current_ssid = ssid;
3035 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) {
3036 wpa_s->current_bss = bss;
3038 hs20_configure_frame_filters(wpa_s);
3042 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
3043 wpa_supplicant_initiate_eapol(wpa_s);
3044 if (old_ssid != wpa_s->current_ssid)
3045 wpas_notify_network_changed(wpa_s);
3049 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s,
3054 wpas_connect_work_done(wpa_s);
3055 wpa_clear_keys(wpa_s, addr);
3056 old_ssid = wpa_s->current_ssid;
3057 wpa_supplicant_mark_disassoc(wpa_s);
3058 wpa_sm_set_config(wpa_s->wpa, NULL);
3059 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3060 if (old_ssid != wpa_s->current_ssid)
3061 wpas_notify_network_changed(wpa_s);
3062 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
3068 * @wpa_s: Pointer to wpa_supplicant data
3074 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
3081 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR
3083 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
3084 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state));
3086 if (!is_zero_ether_addr(wpa_s->pending_bssid) &&
3087 (wpa_s->wpa_state == WPA_AUTHENTICATING ||
3088 wpa_s->wpa_state == WPA_ASSOCIATING))
3089 addr = wpa_s->pending_bssid;
3090 else if (!is_zero_ether_addr(wpa_s->bssid))
3091 addr = wpa_s->bssid;
3092 else if (wpa_s->wpa_state == WPA_ASSOCIATING) {
3099 addr = wpa_s->bssid;
3104 wpa_tdls_teardown_peers(wpa_s->wpa);
3108 if (wpa_s->ifmsh) {
3111 mconf = wpa_s->ifmsh->mconf;
3112 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s",
3113 wpa_s->ifname);
3114 wpas_notify_mesh_group_removed(wpa_s, mconf->meshid,
3116 wpa_supplicant_leave_mesh(wpa_s);
3121 wpa_drv_deauthenticate(wpa_s, addr, reason_code);
3125 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event);
3130 wpa_supplicant_clear_connection(wpa_s, addr);
3133 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s,
3140 wpas_clear_temp_disabled(wpa_s, ssid, 1);
3141 wpas_notify_network_enabled_changed(wpa_s, ssid);
3147 if (!wpa_s->current_ssid && !wpa_s->disconnected)
3148 wpa_s->reassociate = 1;
3154 * @wpa_s: wpa_supplicant structure for a network interface
3163 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s)
3167 ssid = wpa_config_add_network(wpa_s->conf);
3170 wpas_notify_network_added(wpa_s, ssid);
3180 * @wpa_s: wpa_supplicant structure for a network interface
3191 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id)
3196 ssid = wpa_config_get_network(wpa_s->conf, id);
3199 wpas_notify_network_removed(wpa_s, ssid);
3201 if (wpa_s->last_ssid == ssid)
3202 wpa_s->last_ssid = NULL;
3204 if (ssid == wpa_s->current_ssid || !wpa_s->current_ssid) {
3206 wpa_s->sme.prev_bssid_set = 0;
3212 eapol_sm_invalidate_cached_session(wpa_s->eapol);
3215 if (ssid == wpa_s->current_ssid) {
3216 wpa_sm_set_config(wpa_s->wpa, NULL);
3217 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3219 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3220 wpa_s->own_disconnect_req = 1;
3221 wpa_supplicant_deauthenticate(wpa_s,
3227 if (wpa_config_remove_network(wpa_s->conf, id) < 0)
3230 if (!was_disabled && wpa_s->sched_scanning) {
3233 wpa_supplicant_cancel_sched_scan(wpa_s);
3234 wpa_supplicant_req_scan(wpa_s, 0, 0);
3243 * @wpa_s: wpa_supplicant structure for a network interface
3248 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,
3252 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
3253 wpa_supplicant_enable_one_network(wpa_s, ssid);
3255 wpa_supplicant_enable_one_network(wpa_s, ssid);
3257 if (wpa_s->reassociate && !wpa_s->disconnected &&
3258 (!wpa_s->current_ssid ||
3259 wpa_s->wpa_state == WPA_DISCONNECTED ||
3260 wpa_s->wpa_state == WPA_SCANNING)) {
3261 if (wpa_s->sched_scanning) {
3264 wpa_supplicant_cancel_sched_scan(wpa_s);
3267 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
3268 wpa_s->scan_req = NORMAL_SCAN_REQ;
3269 wpa_supplicant_req_scan(wpa_s, 0, 0);
3277 * @wpa_s: wpa_supplicant structure for a network interface
3282 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,
3289 if (wpa_s->sched_scanning)
3290 wpa_supplicant_cancel_sched_scan(wpa_s);
3292 for (other_ssid = wpa_s->conf->ssid; other_ssid;
3303 wpa_s, other_ssid);
3305 if (wpa_s->current_ssid) {
3306 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3307 wpa_s->own_disconnect_req = 1;
3309 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3312 if (ssid == wpa_s->current_ssid) {
3313 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3314 wpa_s->own_disconnect_req = 1;
3316 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3324 wpas_notify_network_enabled_changed(wpa_s, ssid);
3325 if (wpa_s->sched_scanning) {
3328 wpa_supplicant_cancel_sched_scan(wpa_s);
3329 wpa_supplicant_req_scan(wpa_s, 0, 0);
3338 * @wpa_s: wpa_supplicant structure for a network interface
3341 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,
3348 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) {
3349 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
3350 wpa_s->own_disconnect_req = 1;
3352 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3357 wpas_clear_temp_disabled(wpa_s, ssid, 1);
3363 for (other_ssid = wpa_s->conf->ssid; other_ssid;
3371 wpas_clear_temp_disabled(wpa_s, other_ssid, 0);
3374 wpas_notify_network_enabled_changed(wpa_s, other_ssid);
3377 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid &&
3378 wpa_s->wpa_state >= WPA_AUTHENTICATING) {
3386 wpa_s->current_ssid = ssid;
3387 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
3388 wpa_s->connect_without_scan =
3395 os_free(wpa_s->next_scan_freqs);
3396 wpa_s->next_scan_freqs = NULL;
3398 wpa_s->connect_without_scan = NULL;
3401 wpa_s->disconnected = 0;
3402 wpa_s->reassociate = 1;
3404 if (wpa_s->connect_without_scan ||
3405 wpa_supplicant_fast_associate(wpa_s) != 1) {
3406 wpa_s->scan_req = NORMAL_SCAN_REQ;
3407 wpas_scan_reset_sched_scan(wpa_s);
3408 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0);
3412 wpas_notify_network_selected(wpa_s, ssid);
3418 * @wpa_s: wpa_supplicant structure for a network interface
3427 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,
3447 os_free(wpa_s->conf->pkcs11_engine_path);
3448 os_free(wpa_s->conf->pkcs11_module_path);
3449 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy;
3450 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy;
3452 wpa_sm_set_eapol(wpa_s->wpa, NULL);
3453 eapol_sm_deinit(wpa_s->eapol);
3454 wpa_s->eapol = NULL;
3455 wpa_s)) {
3458 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL,
3463 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
3471 * @wpa_s: wpa_supplicant structure for a network interface
3476 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
3484 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
3490 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan &&
3491 wpa_s->wpa_state >= WPA_ASSOCIATING &&
3492 wpa_s->wpa_state < WPA_COMPLETED) {
3494 "associating", wpa_s->conf->ap_scan, ap_scan);
3499 old_ap_scan = wpa_s->conf->ap_scan;
3500 wpa_s->conf->ap_scan = ap_scan;
3502 if (old_ap_scan != wpa_s->conf->ap_scan)
3503 wpas_notify_ap_scan_changed(wpa_s);
3511 * @wpa_s: wpa_supplicant structure for a network interface
3516 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,
3520 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u",
3524 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec",
3526 wpa_s->conf->bss_expiration_age = bss_expire_age;
3534 * @wpa_s: wpa_supplicant structure for a network interface
3539 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,
3543 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u",
3547 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u",
3549 wpa_s->conf->bss_expiration_scan_count = bss_expire_count;
3557 * @wpa_s: wpa_supplicant structure for a network interface
3562 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,
3566 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d",
3570 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec",
3572 wpa_supplicant_update_scan_int(wpa_s, scan_interval);
3621 static int owe_trans_ssid_match(struct wpa_supplicant *wpa_s, const u8 *bssid,
3631 bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
3657 * @wpa_s: Pointer to wpa_supplicant data
3660 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
3669 res = wpa_drv_get_ssid(wpa_s, ssid);
3671 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from "
3677 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
3678 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from "
3683 wired = wpa_s->conf->ap_scan == 0 &&
3684 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED);
3686 entry = wpa_s->conf->ssid;
3688 if (!wpas_network_disabled(wpa_s, entry) &&
3695 if (!wpas_network_disabled(wpa_s, entry) &&
3704 if (!wpas_network_disabled(wpa_s, entry) &&
3705 owe_trans_ssid_match(wpa_s, bssid, entry->ssid,
3712 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set &&
3724 static int select_driver(struct wpa_supplicant *wpa_s, int i)
3726 struct wpa_global *global = wpa_s->global;
3737 wpa_s->driver = wpa_drivers[i];
3738 wpa_s->global_drv_priv = global->drv_priv[i];
3744 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s,
3751 if (wpa_s == NULL)
3755 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into "
3762 return select_driver(wpa_s, 0);
3777 if (select_driver(wpa_s, i) == 0)
3785 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name);
3792 * @ctx: Context pointer (wpa_s); this is the ctx variable registered
3807 struct wpa_supplicant *wpa_s = ctx;
3809 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr));
3813 if (wpa_s->ignore_auth_resp) {
3819 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
3820 (wpa_s->last_eapol_matches_bssid &&
3822 !wpa_s->ap_iface &&
3824 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) {
3837 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing "
3839 wpa_supplicant_state_txt(wpa_s->wpa_state),
3840 MAC2STR(wpa_s->bssid));
3841 wpabuf_free(wpa_s->pending_eapol_rx);
3842 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len);
3843 if (wpa_s->pending_eapol_rx) {
3844 os_get_reltime(&wpa_s->pending_eapol_rx_time);
3845 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr,
3851 wpa_s->last_eapol_matches_bssid =
3852 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0;
3855 if (wpa_s->ap_iface) {
3856 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len);
3861 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
3862 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since "
3867 if (wpa_s->eapol_received == 0 &&
3868 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
3869 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
3870 wpa_s->wpa_state != WPA_COMPLETED) &&
3871 (wpa_s->current_ssid == NULL ||
3872 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
3876 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
3877 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA ||
3878 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) {
3884 if (wpa_s->current_ssid && wpa_s->current_bss &&
3885 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
3886 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) {
3895 wpa_s->current_bss, WPS_IE_VENDOR_TYPE);
3897 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1))
3903 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
3905 wpa_s->eapol_received++;
3907 if (wpa_s->countermeasures) {
3908 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped "
3914 if (wpa_s->current_ssid &&
3915 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
3916 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
3927 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN);
3928 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) &&
3929 wpa_s->key_mgmt != WPA_KEY_MGMT_OWE &&
3930 wpa_s->key_mgmt != WPA_KEY_MGMT_DPP &&
3931 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0)
3933 wpa_drv_poll(wpa_s);
3934 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE))
3935 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len);
3936 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
3943 eapol_sm_notify_portValid(wpa_s->eapol, TRUE);
3948 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s)
3950 if ((!wpa_s->p2p_mgmt ||
3951 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) &&
3952 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) {
3953 l2_packet_deinit(wpa_s->l2);
3954 wpa_s->l2 = l2_packet_init(wpa_s->ifname,
3955 wpa_drv_get_mac_addr(wpa_s),
3957 wpa_supplicant_rx_eapol, wpa_s, 0);
3958 if (wpa_s->l2 == NULL)
3961 const u8 *addr = wpa_drv_get_mac_addr(wpa_s);
3963 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN);
3966 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
3967 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address");
3971 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
3980 struct wpa_supplicant *wpa_s = ctx;
3987 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 &&
3989 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3995 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR
3997 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth),
4004 * @wpa_s: Pointer to wpa_supplicant data
4011 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
4015 if (wpa_supplicant_update_mac_addr(wpa_s) < 0)
4018 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR,
4019 MAC2STR(wpa_s->own_addr));
4020 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN);
4021 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr);
4023 if (wpa_s->bridge_ifname[0]) {
4024 wpa_dbg(wpa_s
4025 "interface '%s'", wpa_s->bridge_ifname);
4026 wpa_s->l2_br = l2_packet_init_bridge(
4027 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr,
4028 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1);
4029 if (wpa_s->l2_br == NULL) {
4030 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet "
4032 wpa_s->bridge_ifname);
4037 if (wpa_s->conf->ap_scan == 2 &&
4038 os_strcmp(wpa_s->driver->name, "nl80211") == 0) {
4043 wpa_clear_keys(wpa_s, NULL);
4047 wpa_drv_set_countermeasures(wpa_s, 0);
4049 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver");
4050 wpa_drv_flush_pmkid(wpa_s);
4052 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN;
4053 wpa_s->prev_scan_wildcard = 0;
4055 if (wpa_supplicant_enabled_networks(wpa_s)) {
4056 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
4057 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
4061 if (!wpa_s->p2p_mgmt &&
4062 wpa_supplicant_delayed_sched_scan(wpa_s,
4065 wpa_supplicant_req_scan(wpa_s, interface_count % 3,
4070 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
4086 struct wpa_supplicant *wpa_s;
4088 wpa_s = os_zalloc(sizeof(*wpa_s));
4089 if (wpa_s == NULL)
4091 wpa_s->scan_req = INITIAL_SCAN_REQ;
4092 wpa_s->scan_interval = 5;
4093 wpa_s->new_connection = 1;
4094 wpa_s->parent = parent ? parent : wpa_s;
4095 wpa_s->p2pdev = wpa_s->parent;
4096 wpa_s->sched_scanning = 0;
4098 dl_list_init(&wpa_s->bss_tmp_disallowed);
4099 dl_list_init(&wpa_s->fils_hlp_req);
4101 return wpa_s;
4107 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s,
4124 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs);
4133 wpa_msg(wpa_s, MSG_DEBUG,
4142 wpa_msg(wpa_s, MSG_ERROR,
4164 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s,
4171 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled);
4187 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s,
4192 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor);
4198 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. "
4211 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s,
4216 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density);
4222 wpa_msg(wpa_s, MSG_ERROR,
4236 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s,
4241 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled);
4250 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s,
4259 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled);
4272 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s,
4280 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled);
4294 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4309 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs);
4310 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask,
4312 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor);
4313 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density);
4314 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40);
4315 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi);
4316 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc);
4330 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4360 wpa_set_ampdu_factor(wpa_s,
4395 static int pcsc_reader_init(struct wpa_supplicant *wpa_s)
4400 if (!wpa_s->conf->pcsc_reader)
4403 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
4404 if (!wpa_s->scard)
4407 if (wpa_s->conf->pcsc_pin &&
4408 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) {
4409 scard_deinit(wpa_s->scard);
4410 wpa_s->scard = NULL;
4411 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed");
4415 len = sizeof(wpa_s->imsi) - 1;
4416 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) {
4417 scard_deinit(wpa_s->scard);
4418 wpa_s->scard = NULL;
4419 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI");
4422 wpa_s->imsi[len] = '\0';
4424 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard);
4427 wpa_s->imsi, wpa_s->mnc_len);
4429 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
4430 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
4437 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s)
4441 ext_password_deinit(wpa_s->ext_pw);
4442 wpa_s->ext_pw = NULL;
4443 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL);
4445 if (!wpa_s->conf->ext_password_backend)
4448 val = os_strdup(wpa_s->conf->ext_password_backend);
4457 wpa_s->ext_pw = ext_password_init(val, pos);
4459 if (wpa_s->ext_pw == NULL) {
4463 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw);
4473 struct wpa_supplicant *wpa_s = ctx;
4475 return (is_zero_ether_addr(wpa_s->bssid) ||
4476 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid;
4484 struct wpa_supplicant *wpa_s = ctx;
4486 if (wpa_s->current_bss) {
4487 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq,
4489 } else if (wpa_s->hw.num_modes) {
4490 *hw_mode = wpa_s->hw.modes[0].mode;
4500 struct wpa_supplicant *wpa_s = ctx;
4502 *modes = wpa_s->hw.modes;
4503 return wpa_s->hw.num_modes;
4509 struct wpa_supplicant *wpa_s = ctx;
4512 wpa_s->fst_ies = fst_ies;
4518 struct wpa_supplicant *wpa_s = ctx;
4520 if (os_memcmp(wpa_s->bssid, da, ETH_ALEN) != 0) {
4522 __func__, MAC2STR(wpa_s->bssid), MAC2STR(da));
4525 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
4526 wpa_s->own_addr, wpa_s->bssid,
4534 struct wpa_supplicant *wpa_s = ctx;
4536 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4537 return wpa_s->received_mb_ies;
4544 struct wpa_supplicant *wpa_s = ctx;
4547 WPA_ASSERT(os_memcmp(wpa_s->bssid, addr, ETH_ALEN) == 0);
4550 wpabuf_free(wpa_s->received_mb_ies);
4551 wpa_s->received_mb_ies = mb_ies_by_info(&info);
4560 struct wpa_supplicant *wpa_s = ctx;
4563 if (!is_zero_ether_addr(wpa_s->bssid))
4564 return (wpa_s->received_mb_ies || !mb_only) ?
4565 wpa_s->bssid : NULL;
4577 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,
4580 iface_obj->ctx = wpa_s;
4593 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s,
4599 if (!wpa_s->conf->wowlan_triggers)
4602 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa);
4604 ret = wpa_drv_wowlan(wpa_s, triggers);
4621 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs)
4635 for (i = 0; i < wpa_s->hw.num_modes; i++) {
4636 if (wpa_s->hw.modes[i].num_channels != 0) {
4637 if (wpa_s->hw.modes[i].mode ==
4639 wpa_s->hw.modes[i].mode ==
4642 else if (wpa_s->hw.modes[i].mode ==
4645 else if (wpa_s->hw.modes[i].mode ==
4648 else if (wpa_s->hw.modes[i].mode ==
4660 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s,
4663 struct wpa_supplicant *iface = wpa_s->global->ifaces;
4670 wpa_s->ifname, rn);
4671 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4679 wpa_s->ifname, rn ? rn : "N/A");
4688 dl_list_add(&radio->ifaces, &wpa_s->radio_list);
4696 if (work->wpa_s->scan_work == work) {
4698 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work",
4700 work->wpa_s->scan_work = NULL;
4704 if (work->wpa_s->p2p_scan_work == work) {
4706 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work",
4708 work->wpa_s->p2p_scan_work = NULL;
4713 work->wpa_s->radio->num_active_works--;
4714 wpa_dbg(work->wpa_s, MSG_DEBUG,
4717 work->wpa_s->radio->num_active_works);
4761 tmp->wpa_s->clear_driver_scan_cache))
4773 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4793 if (active_work->wpa_s == tmp->wpa_s &&
4796 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4817 tmp->wpa_s->clear_driver_scan_cache))
4820 wpa_dbg(active_work->wpa_s, MSG_DEBUG,
4837 struct wpa_supplicant *wpa_s;
4845 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant,
4848 if (!(wpa_s &&
4849 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) {
4853 if (wpa_s && wpa_s->radio->external_scan_running) {
4867 wpa_s = work->wpa_s;
4870 wpa_dbg(wpa_s, MSG_DEBUG,
4879 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) &&
4881 radio_work_check_next(wpa_s);
4891 * @wpa_s: wpa_supplicant data
4896 void radio_remove_works(struct wpa_supplicant *wpa_s,
4900 struct wpa_radio *radio = wpa_s->radio;
4908 if (!remove_all && work->wpa_s != wpa_s)
4911 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s",
4918 radio_work_check_next(wpa_s);
4922 static void radio_remove_interface(struct wpa_supplicant *wpa_s)
4924 struct wpa_radio *radio = wpa_s->radio;
4930 wpa_s->ifname, radio->name);
4931 dl_list_del(&wpa_s->radio_list);
4932 radio_remove_works(wpa_s, NULL, 0);
4933 wpa_s->radio = NULL;
4943 void radio_work_check_next(struct wpa_supplicant *wpa_s)
4945 struct wpa_radio *radio = wpa_s->radio;
4949 if (wpa_s->ext_work_in_progress) {
4961 * @wpa_s: Pointer to wpa_supplicant data
4984 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,
4989 struct wpa_radio *radio = wpa_s->radio;
4996 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work);
5000 work->wpa_s = wpa_s;
5008 work->bands = wpas_get_bands(wpa_s,
5012 work->bands = wpas_get_bands(wpa_s, NULL);
5014 was_empty = dl_list_empty(&wpa_s->radio->work);
5016 dl_list_add(&wpa_s->radio->work, &work->list);
5018 dl_list_add_tail(&wpa_s->radio->work, &work->list);
5020 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately");
5021 radio_work_check_next(wpa_s);
5022 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)
5024 wpa_dbg(wpa_s, MSG_DEBUG,
5027 radio_work_check_next(wpa_s);
5043 struct wpa_supplicant *wpa_s = work->wpa_s;
5049 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds",
5054 radio_work_check_next(wpa_s);
5059 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type)
5062 struct wpa_radio *radio = wpa_s->radio;
5065 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0)
5073 static int wpas_init_driver(struct wpa_supplicant *wpa_s,
5080 if (wpa_supplicant_set_driver(wpa_s, driver) < 0)
5083 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
5084 if (wpa_s->drv_priv == NULL) {
5088 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize "
5093 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver "
5097 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) {
5098 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected "
5099 "driver_param '%s'", wpa_s->conf->driver_param);
5103 ifname = wpa_drv_get_ifname(wpa_s);
5104 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) {
5105 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced "
5107 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname));
5110 rn = wpa_driver_get_radio_name(wpa_s);
5114 wpa_s->radio = radio_add_interface(wpa_s, rn);
5115 if (wpa_s->radio == NULL)
5124 static void wpas_gas_server_tx_status(struct wpa_supplicant *wpa_s,
5136 gas_server_tx_status(wpa_s->gas_server, dst, data, data_len,
5144 struct wpa_supplicant *wpa_s = ctx;
5147 if (wait_time > wpa_s->max_remain_on_chan)
5148 wait_time = wpa_s->max_remain_on_chan;
5150 offchannel_send_action(wpa_s, freq, da, wpa_s->own_addr, broadcast,
5157 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
5173 wpa_s->confname = os_rel2abs_path(iface->confname);
5174 if (wpa_s->confname == NULL) {
5181 iface->confname, wpa_s->confname);
5183 wpa_s->confname = os_strdup(iface->confname);
5185 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL);
5186 if (wpa_s->conf == NULL) {
5188 "configuration '%s'.", wpa_s->confname);
5191 wpa_s->confanother = os_rel2abs_path(iface->confanother);
5192 wpa_config_read(wpa_s->confanother, wpa_s->conf);
5199 os_free(wpa_s->conf->ctrl_interface);
5200 wpa_s->conf->ctrl_interface =
5205 os_free(wpa_s->conf->driver_param);
5206 wpa_s->conf->driver_param =
5211 os_free(wpa_s->conf->ctrl_interface);
5212 wpa_s->conf->ctrl_interface = NULL;
5215 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface,
5218 if (wpa_s->conf == NULL) {
5227 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) {
5232 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname));
5236 sizeof(wpa_s->bridge_ifname)) {
5241 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname,
5242 sizeof(wpa_s->bridge_ifname));
5246 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE);
5247 eapol_sm_notify_portValid(wpa_s->eapol, FALSE);
5253 if (wpas_init_driver(wpa_s, iface) < 0)
5256 if (wpa_supplicant_init_wpa(wpa_s) < 0)
5259 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname,
5260 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname :
5262 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth);
5264 if (wpa_s->conf->dot11RSNAConfigPMKLifetime &&
5265 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
5266 wpa_s->conf->dot11RSNAConfigPMKLifetime)) {
5267 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5272 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold &&
5273 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
5274 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) {
5275 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5280 if (wpa_s->conf->dot11RSNAConfigSATimeout &&
5281 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
5282 wpa_s->conf->dot11RSNAConfigSATimeout)) {
5283 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for "
5288 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s,
5289 &wpa_s->hw.num_modes,
5290 &wpa_s->hw.flags,
5292 if (wpa_s->hw.modes) {
5295 for (i = 0; i < wpa_s->hw.num_modes; i++) {
5296 if (wpa_s->hw.modes[i].vht_capab) {
5297 wpa_s->hw_capab = CAPAB_VHT;
5301 if (wpa_s->hw.modes[i].ht_capab &
5303 wpa_s->hw_capab = CAPAB_HT40;
5304 else if (wpa_s->hw.modes[i].ht_capab &&
5305 wpa_s->hw_capab == CAPAB_NO_HT_VHT)
5306 wpa_s->hw_capab = CAPAB_HT;
5310 capa_res = wpa_drv_get_capa(wpa_s, &capa);
5312 wpa_s->drv_capa_known = 1;
5313 wpa_s->drv_flags = capa.flags;
5314 wpa_s->drv_enc = capa.enc;
5315 wpa_s->drv_smps_modes = capa.smps_modes;
5316 wpa_s->drv_rrm_flags = capa.rrm_flags;
5317 wpa_s->probe_resp_offloads = capa.probe_resp_offloads;
5318 wpa_s->max_scan_ssids = capa.max_scan_ssids;
5319 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids;
5320 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans;
5321 wpa_s->max_sched_scan_plan_interval =
5323 wpa_s->max_sched_scan_plan_iterations =
5325 wpa_s->sched_scan_supported = capa.sched_scan_supported;
5326 wpa_s->max_match_sets = capa.max_match_sets;
5327 wpa_s->max_remain_on_chan = capa.max_remain_on_chan;
5328 wpa_s->max_stations = capa.max_stations;
5329 wpa_s->extended_capa = capa.extended_capa;
5330 wpa_s->extended_capa_mask = capa.extended_capa_mask;
5331 wpa_s->extended_capa_len = capa.extended_capa_len;
5332 wpa_s->num_multichan_concurrent =
5334 wpa_s->wmm_ac_supported = capa.wmm_ac_supported;
5337 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN;
5338 if (wpa_s->sched_scan_supported &&
5340 wpa_s->mac_addr_rand_supported |=
5343 if (wpa_s->max_remain_on_chan == 0)
5344 wpa_s->max_remain_on_chan = 1000;
5351 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)
5352 wpa_s->p2p_mgmt = iface->p2p_mgmt;
5356 if (wpa_s->num_multichan_concurrent == 0)
5357 wpa_s->num_multichan_concurrent = 1;
5359 if (wpa_supplicant_driver_init(wpa_s) < 0)
5364 !(wpa_s->drv_flags &
5366 wpa_tdls_init(wpa_s->wpa))
5370 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] &&
5371 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) {
5372 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country");
5377 if (wpa_s->conf->fst_group_id) {
5381 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
5382 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id,
5384 cfg.priority = wpa_s->conf->fst_priority;
5385 cfg.llt = wpa_s->conf->fst_llt;
5387 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr,
5389 if (!wpa_s->fst) {
5390 wpa_msg(wpa_s, MSG_ERROR,
5392 wpa_s->ifname, cfg.group_id);
5398 if (wpas_wps_init(wpa_s))
5402 wpa_s->gas_server = gas_server_init(wpa_s, wpas_gas_server_tx);
5403 if (!wpa_s->gas_server) {
5410 if (wpas_dpp_init(wpa_s) < 0)
5414 if (wpa_supplicant_init_eapol(wpa_s) < 0)
5416 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol);
5418 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s);
5419 if (wpa_s->ctrl_iface == NULL) {
5428 wpa_s->conf->ctrl_interface);
5432 wpa_s->gas = gas_query_init(wpa_s);
5433 if (wpa_s->gas == NULL) {
5438 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) {
5439 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P");
5443 if (wpa_bss_init(wpa_s) < 0)
5448 dl_list_init(&wpa_s->mesh_external_pmksa_cache);
5457 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
5463 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, -1,
5464 wpa_s->imsi, &len);
5465 if (wpa_s->mnc_len > 0) {
5466 wpa_s->imsi[len] = '\0';
5468 wpa_s->imsi, wpa_s->mnc_len);
5475 if (pcsc_reader_init(wpa_s) < 0)
5478 if (wpas_init_ext_pw(wpa_s) < 0)
5481 wpas_rrm_reset(wpa_s);
5483 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
5486 hs20_init(wpa_s);
5489 if (wpa_s->conf->oce) {
5490 if ((wpa_s->conf->oce & OCE_STA) &&
5491 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA))
5492 wpa_s->enable_oce = OCE_STA;
5493 if ((wpa_s->conf->oce & OCE_STA_CFON) &&
5494 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA_CFON)) {
5500 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan);
5503 wpa_supplicant_set_default_scan_ies(wpa_s);
5509 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
5512 struct wpa_global *global = wpa_s->global;
5515 if (wpa_s == wpa_s->parent)
5516 wpas_p2p_group_remove(wpa_s, "*");
5520 if (iface->p2pdev == wpa_s)
5522 if (iface == wpa_s || iface->parent != wpa_s) {
5528 iface->ifname, wpa_s->ifname);
5534 wpa_s->disconnected = 1;
5535 if (wpa_s->drv_priv) {
5536 wpa_supplicant_deauthenticate(wpa_s,
5539 wpa_drv_set_countermeasures(wpa_s, 0);
5540 wpa_clear_keys(wpa_s, NULL);
5543 wpa_supplicant_cleanup(wpa_s);
5544 wpas_p2p_deinit_iface(wpa_s);
5546 wpas_ctrl_radio_work_flush(wpa_s);
5547 radio_remove_interface(wpa_s);
5550 if (wpa_s->fst) {
5551 fst_detach(wpa_s->fst);
5552 wpa_s->fst = NULL;
5554 if (wpa_s->received_mb_ies) {
5555 wpabuf_free(wpa_s->received_mb_ies);
5556 wpa_s->received_mb_ies = NULL;
5560 if (wpa_s->drv_priv)
5561 wpa_drv_deinit(wpa_s);
5564 wpas_notify_iface_removed(wpa_s);
5567 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING);
5569 if (wpa_s->ctrl_iface) {
5570 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface);
5571 wpa_s->ctrl_iface = NULL;
5575 if (wpa_s->ifmsh) {
5576 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh);
5577 wpa_s->ifmsh = NULL;
5581 if (wpa_s->conf != NULL) {
5582 wpa_config_free(wpa_s->conf);
5583 wpa_s->conf = NULL;
5586 os_free(wpa_s->ssids_from_scan_req);
5588 os_free(wpa_s);
5631 struct wpa_supplicant *wpa_s;
5641 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name);
5642 if (wpa_s)
5646 wpa_s = wpa_supplicant_add_iface(global, iface, NULL);
5648 if (wpa_s)
5649 wpa_s->matched = 1;
5677 struct wpa_supplicant *wpa_s;
5684 wpa_s = wpa_supplicant_alloc(parent);
5685 if (wpa_s == NULL)
5688 wpa_s->global = global;
5705 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
5708 wpa_supplicant_deinit_iface(wpa_s, 0, 0);
5713 if (wpas_notify_iface_added(wpa_s)) {
5714 wpa_supplicant_deinit_iface(wpa_s, 1, 0);
5721 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
5722 wpas_notify_network_added(wpa_s, ssid);
5725 wpa_s->next = global->ifaces;
5726 global->ifaces = wpa_s;
5728 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname);
5729 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
5732 if (wpa_s->global->p2p == NULL &&
5733 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled &&
5734 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
5736 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
5743 return wpa_s;
5750 * @wpa_s: Pointer to the network interface to be removed
5759 struct wpa_supplicant *wpa_s,
5764 unsigned int mesh_if_created = wpa_s->mesh_if_created;
5766 struct wpa_supplicant *parent = wpa_s->parent;
5771 if (prev == wpa_s) {
5772 global->ifaces = wpa_s->next;
5774 while (prev && prev->next != wpa_s)
5778 prev->next = wpa_s->next;
5781 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
5785 ifname = os_strdup(wpa_s->ifname);
5787 wpa_dbg(wpa_s, MSG_ERROR,
5794 if (global->p2p_group_formation == wpa_s)
5796 if (global->p2p_invite_group == wpa_s)
5798 wpa_supplicant_deinit_iface(wpa_s, 1, terminate);
5813 * @wpa_s: Pointer to the network interface
5816 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
5820 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 &&
5821 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
5825 eapol_method = eapol_sm_get_method_name(wpa_s->eapol);
5842 struct wpa_supplicant *wpa_s;
5844 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5845 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5846 return wpa_s;
5855 struct wpa_supplicant *wpa_s = ctx;
5856 if (wpa_s == NULL)
5858 return wpa_s->ifname;
5871 struct wpa_supplicant *wpa_s;
5881 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5882 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age);
5884 ap_periodic(wpa_s);
6048 struct wpa_supplicant *wpa_s;
6061 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
6062 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt)
6064 wpa_s->ctrl_iface);
6146 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s)
6148 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
6149 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
6151 country[0] = wpa_s->conf->country[0];
6152 country[1] = wpa_s->conf->country[1];
6154 if (wpa_drv_set_country(wpa_s, country) < 0) {
6160 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND)
6161 wpas_init_ext_pw(wpa_s);
6163 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS)
6164 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans);
6166 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WOWLAN_TRIGGERS) {
6168 int res = wpa_drv_get_capa(wpa_s, &capa);
6170 if (res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0)
6173 wpa_s->conf->wowlan_triggers);
6177 wpas_wps_update_config(wpa_s);
6179 wpas_p2p_update_config(wpa_s);
6180 wpa_s->conf->changed_parameters = 0;
6198 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s)
6209 cbss = wpa_s->current_bss;
6211 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
6216 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) {
6232 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid)
6238 wpas_connect_work_done(wpa_s);
6243 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
6249 if (wpa_s->own_disconnect_req) {
6250 wpa_s->own_disconnect_req = 0;
6251 wpa_dbg(wpa_s, MSG_DEBUG,
6255 if (wpa_s->disconnected) {
6256 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure "
6270 count = wpa_blacklist_add(wpa_s, bssid);
6271 if (count == 1 && wpa_s->current_bss) {
6278 freqs = get_bss_freqs_in_ess(wpa_s);
6280 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS "
6282 wpa_blacklist_add(wpa_s, bssid);
6288 os_free(wpa_s->next_scan_freqs);
6289 wpa_s->next_scan_freqs = freqs;
6297 count += wpa_s->extra_blacklist_count;
6299 if (count > 3 && wpa_s->current_ssid) {
6302 wpas_auth_failed(wpa_s, "CONN_FAILED");
6323 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d "
6330 wpa_supplicant_req_scan(wpa_s, timeout / 1000,
6335 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s)
6337 return wpa_s->conf->ap_scan == 2 ||
6338 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION);
6343 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
6356 return wpa_supplicant_ctrl_rsp_handle(wpa_s, ssid, rtype, value, strlen(value));
6363 int wpa_supplicant_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,
6396 if (ssid == wpa_s->current_ssid)
6397 wpa_s->reassociate = 1;
6404 if (ssid == wpa_s->current_ssid)
6405 wpa_s->reassociate = 1;
6412 if (ssid == wpa_s->current_ssid)
6413 wpa_s->reassociate = 1;
6419 if (ssid == wpa_s->current_ssid)
6420 wpa_s->reassociate = 1;
6434 if (ssid == wpa_s->current_ssid)
6435 wpa_s->reassociate = 1;
6448 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning)
6449 wpa_supplicant_req_scan(wpa_s, 0, 0);
6475 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6480 if (wpa_s->p2p_mgmt)
6489 if (wpa_s->drv_capa_known)
6490 drv_enc = wpa_s->drv_enc;
6517 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
6521 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL &&
6522 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) {
6544 return wpa_s->conf->pmf;
6554 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s)
6556 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P)
6558 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA)
6564 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason)
6566 struct wpa_ssid *ssid = wpa_s->current_ssid;
6583 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) {
6617 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED
6624 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,
6631 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED
6642 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid)
6646 if (wpa_s->disallow_aps_bssid == NULL)
6649 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) {
6650 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN,
6659 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,
6664 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL)
6667 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) {
6668 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i];
6680 * @wpa_s: Pointer to the network interface
6686 void wpas_request_connection(struct wpa_supplicant *wpa_s)
6688 wpa_s->normal_scans = 0;
6689 wpa_s->scan_req = NORMAL_SCAN_REQ;
6690 wpa_supplicant_reinit_autoscan(wpa_s);
6691 wpa_s->extra_blacklist_count = 0;
6692 wpa_s->disconnected = 0;
6693 wpa_s->reassociate = 1;
6695 if (wpa_supplicant_fast_associate(wpa_s) != 1)
6696 wpa_supplicant_req_scan(wpa_s, 0, 0);
6698 wpa_s->reattach = 0;
6704 * @wpa_s: Pointer to the network interface
6709 void wpas_request_disconnection(struct wpa_supplicant *wpa_s)
6712 wpa_s->sme.prev_bssid_set = 0;
6714 wpa_s->reassociate = 0;
6715 wpa_s->disconnected = 1;
6716 wpa_supplicant_cancel_sched_scan(wpa_s);
6717 wpa_supplicant_cancel_scan(wpa_s);
6718 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
6719 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
6723 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,
6729 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s",
6733 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X",
6744 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,
6753 wpa_dbg(wpa_s, MSG_DEBUG,
6757 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
6789 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx);
6798 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,
6810 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len);
6821 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame)
6838 return wpa_s->p2pdev;
6841 return wpa_s;
6846 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s)
6854 if (wpa_s->vendor_elem[i]) {
6860 wpa_s->vendor_elem[i]);
6866 if (wpa_s->parent == wpa_s &&
6867 wpa_s->global->p2p &&
6868 !wpa_s->global->p2p_disabled)
6869 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem);
6874 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame,
6879 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]);
6880 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]);
6888 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) {
6889 wpabuf_free(wpa_s->vendor_elem[frame]);
6890 wpa_s->vendor_elem[frame] = NULL;
6893 wpa_s->vendor_elem[frame]->used -= len;
6895 wpas_vendor_elem_update(wpa_s);
6918 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s,
6923 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed,
6933 static int wpa_set_driver_tmp_disallow_list(struct wpa_supplicant *wpa_s)
6940 bssids = os_malloc(dl_list_len(&wpa_s->bss_tmp_disallowed) * ETH_ALEN);
6943 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed,
6949 ret = wpa_drv_set_bssid_blacklist(wpa_s, num_bssid, bssids);
6957 struct wpa_supplicant *wpa_s = eloop_ctx;
6961 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed,
6966 wpa_set_driver_tmp_disallow_list(wpa_s);
6973 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid,
6978 bss = wpas_get_disallowed_bss(wpa_s, bssid);
6980 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss);
6982 wpa_s, bss);
6994 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list);
6995 wpa_set_driver_tmp_disallow_list(wpa_s);
6997 wpa_s, bss);
7001 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s, const u8 *bssid)
7005 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed,
