Lines Matching defs:wpa_s

75 static int * freq_range_to_channel_list(struct wpa_supplicant *wpa_s,
79 static int set_bssid_filter(struct wpa_supplicant *wpa_s, char *val)
108 	os_free(wpa_s->bssid_filter);
109 	wpa_s->bssid_filter = filter;
110 	wpa_s->bssid_filter_count = count;
116 static int set_disallow_aps(struct wpa_supplicant *wpa_s, char *val)
205 	os_free(wpa_s->disallow_aps_bssid);
206 	wpa_s->disallow_aps_bssid = bssid;
207 	wpa_s->disallow_aps_bssid_count = count;
210 	os_free(wpa_s->disallow_aps_ssid);
211 	wpa_s->disallow_aps_ssid = ssid;
212 	wpa_s->disallow_aps_ssid_count = ssid_count;
214 	if (!wpa_s->current_ssid || wpa_s->wpa_state < WPA_AUTHENTICATING)
217 	c = wpa_s->current_ssid;
221 	if (!disallowed_bssid(wpa_s, wpa_s->bssid) &&
222 	    !disallowed_ssid(wpa_s, c->ssid, c->ssid_len))
229 	wpa_s->sme.prev_bssid_set = 0;
231 	wpa_s->reassociate = 1;
232 	wpa_s->own_disconnect_req = 1;
233 	wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
234 	wpa_supplicant_req_scan(wpa_s, 0, 0);
241 static int wpas_ctrl_set_blob(struct wpa_supplicant *wpa_s, char *pos)
273 	wpa_config_set_blob(wpa_s->conf, blob);
280 static int wpas_ctrl_pno(struct wpa_supplicant *wpa_s, char *cmd)
289 		os_free(wpa_s->manual_sched_scan_freqs);
294 				freqs = freq_range_to_channel_list(wpa_s,
297 		wpa_s->manual_sched_scan_freqs = freqs;
298 		ret = wpas_start_pno(wpa_s);
300 		ret = wpas_stop_pno(wpa_s);
306 static int wpas_ctrl_set_band(struct wpa_supplicant *wpa_s, char *bands)
328 	wpa_s->setband_mask = setband_mask;
329 	if (wpa_drv_setband(wpa_s, wpa_s->setband_mask) == 0) {
333 		wpa_supplicant_event(wpa_s, EVENT_CHANNEL_LIST_CHANGED, &event);
340 static int wpas_ctrl_iface_set_lci(struct wpa_supplicant *wpa_s,
346 		wpabuf_free(wpa_s->lci);
347 		wpa_s->lci = NULL;
355 	if (os_get_reltime(&wpa_s->lci_time)) {
360 	wpabuf_free(wpa_s->lci);
361 	wpa_s->lci = lci;
368 wpas_ctrl_set_relative_rssi(struct wpa_supplicant *wpa_s, const char *cmd)
373 		wpa_s->srp.relative_rssi_set = 0;
380 	wpa_s->srp.relative_rssi = relative_rssi;
381 	wpa_s->srp.relative_rssi_set = 1;
386 static int wpas_ctrl_set_relative_band_adjust(struct wpa_supplicant *wpa_s,
402 		wpa_s->srp.relative_adjust_band = WPA_SETBAND_2G;
404 		wpa_s->srp.relative_adjust_band = WPA_SETBAND_5G;
408 	wpa_s->srp.relative_adjust_rssi = adjust_rssi;
414 static int wpas_ctrl_iface_set_ric_ies(struct wpa_supplicant *wpa_s,
420 		wpabuf_free(wpa_s->ric_ies);
421 		wpa_s->ric_ies = NULL;
429 	wpabuf_free(wpa_s->ric_ies);
430 	wpa_s->ric_ies = ric_ies;
437 static int wpas_ctrl_iface_set_dso(struct wpa_supplicant *wpa_s,
448 	dl_list_for_each(tmp, &wpa_s->drv_signal_override,
481 		dl_list_add(&wpa_s->drv_signal_override, &dso->list);
494 static int wpa_supplicant_ctrl_iface_set(struct wpa_supplicant *wpa_s,
507 		eapol_sm_configure(wpa_s->eapol,
510 		eapol_sm_configure(wpa_s->eapol,
513 		eapol_sm_configure(wpa_s->eapol,
516 		eapol_sm_configure(wpa_s->eapol,
521 			eapol_sm_notify_portControl(wpa_s->eapol, Auto);
523 			eapol_sm_notify_portControl(wpa_s->eapol,
526 			eapol_sm_notify_portControl(wpa_s->eapol,
532 		if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
537 			wpa_config_process_global(wpa_s->conf, cmd, -1);
541 		if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
546 			wpa_config_process_global(wpa_s->conf, cmd, -1);
549 		if (wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT,
554 			wpa_config_process_global(wpa_s->conf, cmd, -1);
557 		wpa_s->wps_fragment_size = atoi(value);
597 		if (wpa_drv_ampdu(wpa_s, atoi(value)) < 0)
609 			if (wpa_drv_tdls_oper(wpa_s, TDLS_DISABLE, NULL) < 0)
611 		} else if (wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL) < 0)
613 		wpa_tdls_enable(wpa_s->wpa, !disabled);
616 		ret = wpas_ctrl_pno(wpa_s, value);
619 		if (wpa_drv_radio_disable(wpa_s, disabled) < 0)
622 			wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
625 			wpa_s->set_sta_uapsd = 0;
648 			wpa_s->set_sta_uapsd = 1;
649 			wpa_s->sta_uapsd = 0;
651 				wpa_s->sta_uapsd |= BIT(0);
653 				wpa_s->sta_uapsd |= BIT(1);
655 				wpa_s->sta_uapsd |= BIT(2);
657 				wpa_s->sta_uapsd |= BIT(3);
660 		ret = wpa_drv_set_p2p_powersave(wpa_s, atoi(value), -1, -1);
664 		if (enabled && !wpa_s->global->p2p)
667 			wifi_display_enable(wpa_s->global, enabled);
670 		ret = set_bssid_filter(wpa_s, value);
672 		ret = set_disallow_aps(wpa_s, value);
674 		wpa_s->no_keep_alive = !!atoi(value);
677 		os_free(wpa_s->dpp_configurator_params);
678 		wpa_s->dpp_configurator_params = os_strdup(value);
680 		dpp_controller_set_params(wpa_s->dpp, value);
683 		wpa_s->dpp_init_max_tries = atoi(value);
685 		wpa_s->dpp_init_retry_time = atoi(value);
687 		wpa_s->dpp_resp_wait_time = atoi(value);
689 		wpa_s->dpp_resp_max_tries = atoi(value);
691 		wpa_s->dpp_resp_retry_time = atoi(value);
735 		wpa_s->ext_mgmt_frame_handling = !!atoi(value);
737 		wpa_s->ext_eapol_frame_io = !!atoi(value);
739 		if (wpa_s->ap_iface) {
740 			wpa_s->ap_iface->bss[0]->ext_eapol_frame_io =
741 				wpa_s->ext_eapol_frame_io;
745 		wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_ENCRYPT_EAPOL_M2,
748 		wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_ENCRYPT_EAPOL_M4,
751 		wpa_s->extra_roc_dur = atoi(value);
753 		wpa_s->test_failure = atoi(value);
755 		wpa_s->p2p_go_csa_on_inv = !!atoi(value);
757 		wpa_s->ignore_auth_resp = !!atoi(value);
759 		wpa_s->ignore_assoc_disallow = !!atoi(value);
760 		wpa_drv_ignore_assoc_disallow(wpa_s,
761 					      wpa_s->ignore_assoc_disallow);
763 		wpa_s->disable_sa_query = !!atoi(value);
765 		wpa_s->ignore_sae_h2e_only = !!atoi(value);
769 		os_free(wpa_s->extra_sae_rejected_groups);
770 		wpa_s->extra_sae_rejected_groups = NULL;
781 					&wpa_s->extra_sae_rejected_groups,
789 		wpa_s->ft_rsnxe_used = atoi(value);
791 		wpa_s->oci_freq_override_eapol = atoi(value);
793 		wpa_s->oci_freq_override_saquery_req = atoi(value);
795 		wpa_s->oci_freq_override_saquery_resp = atoi(value);
797 		wpa_s->oci_freq_override_eapol_g2 = atoi(value);
799 		wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_EAPOL_G2,
800 				 wpa_s->oci_freq_override_eapol_g2);
802 		wpa_s->oci_freq_override_ft_assoc = atoi(value);
804 		wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_FT_ASSOC,
805 				 wpa_s->oci_freq_override_ft_assoc);
807 		wpa_s->oci_freq_override_fils_assoc = atoi(value);
809 		wpa_s->oci_freq_override_wnm_sleep = atoi(value);
811 		wpabuf_free(wpa_s->rsne_override_eapol);
813 			wpa_s->rsne_override_eapol = NULL;
815 			wpa_s->rsne_override_eapol = wpabuf_parse_bin(value);
817 		wpabuf_free(wpa_s->rsnxe_override_assoc);
819 			wpa_s->rsnxe_override_assoc = NULL;
821 			wpa_s->rsnxe_override_assoc = wpabuf_parse_bin(value);
823 		wpabuf_free(wpa_s->rsnxe_override_eapol);
825 			wpa_s->rsnxe_override_eapol = NULL;
827 			wpa_s->rsnxe_override_eapol = wpabuf_parse_bin(value);
829 		wpa_s->reject_btm_req_reason = atoi(value);
831 		os_free(wpa_s->get_pref_freq_list_override);
833 			wpa_s->get_pref_freq_list_override = NULL;
835 			wpa_s->get_pref_freq_list_override = os_strdup(value);
837 		wpabuf_free(wpa_s->sae_commit_override);
839 			wpa_s->sae_commit_override = NULL;
841 			wpa_s->sae_commit_override = wpabuf_parse_bin(value);
843 		ret = wpas_ctrl_iface_set_dso(wpa_s, value);
846 		wpa_s->disable_scs_support = !!atoi(value);
848 		wpa_s->disable_mscs_support = !!atoi(value);
851 		wpa_s->disable_eapol_g2_tx = !!atoi(value);
853 		wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DISABLE_EAPOL_G2_TX,
854 				 wpa_s->disable_eapol_g2_tx);
856 		wpa_s->test_assoc_comeback_type = atoi(value);
859 		os_free(wpa_s->dpp_config_obj_override);
861 			wpa_s->dpp_config_obj_override = NULL;
863 			wpa_s->dpp_config_obj_override = os_strdup(value);
865 		os_free(wpa_s->dpp_discovery_override);
867 			wpa_s->dpp_discovery_override = NULL;
869 			wpa_s->dpp_discovery_override = os_strdup(value);
871 		os_free(wpa_s->dpp_groups_override);
873 			wpa_s->dpp_groups_override = NULL;
875 			wpa_s->dpp_groups_override = os_strdup(value);
878 		wpa_s->dpp_ignore_netaccesskey_mismatch = atoi(value);
880 		wpa_s->dpp_discard_public_action = atoi(value);
887 		wpa_s->disable_fils = !!atoi(value);
888 		wpa_drv_disable_fils(wpa_s, wpa_s->disable_fils);
889 		wpa_supplicant_set_default_scan_ies(wpa_s);
893 		ret = wpas_ctrl_set_blob(wpa_s, value);
896 		ret = wpas_ctrl_set_band(wpa_s, value);
899 		ret = wpas_mbo_update_non_pref_chan(wpa_s, value);
902 			wpa_config_process_global(wpa_s->conf, cmd, -1);
911 		wpas_mbo_update_cell_capa(wpa_s, val);
918 		wpa_s->conf->oce = val;
919 		if (wpa_s->conf->oce) {
920 			if ((wpa_s->conf->oce & OCE_STA) &&
921 			    (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA))
922 				wpa_s->enable_oce = OCE_STA;
924 			if ((wpa_s->conf->oce & OCE_STA_CFON) &&
925 			    (wpa_s->drv_flags &
933 			wpa_s->enable_oce = 0;
935 		wpa_supplicant_set_default_scan_ies(wpa_s);
938 		ret = wpas_ctrl_iface_set_lci(wpa_s, value);
940 		ret = wpa_drv_set_tdls_mode(wpa_s, atoi(value));
942 		ret = wpas_ctrl_set_relative_rssi(wpa_s, value);
944 		ret = wpas_ctrl_set_relative_band_adjust(wpa_s, value);
946 		ret = wpas_ctrl_iface_set_ric_ies(wpa_s, value);
948 		ret = wpa_drv_roaming(wpa_s, atoi(value), NULL);
956 		wnm_set_coloc_intf_elems(wpa_s, elems);
960 		wpa_s->enable_dscp_policy_capa = !!atoi(value);
964 		ret = wpa_config_process_global(wpa_s->conf, cmd, -1);
966 			wpa_supplicant_update_config(wpa_s);
975 static int wpa_supplicant_ctrl_iface_get(struct wpa_supplicant *wpa_s,
987 		if (wpa_s->conf->country[0] && wpa_s->conf->country[1])
989 					  wpa_s->conf->country[0],
990 					  wpa_s->conf->country[1]);
994 		if (wpa_s->global->p2p == NULL ||
995 		    wpa_s->global->p2p_disabled)
998 			enabled = wpa_s->global->wifi_display;
1003 		if (wpa_s->last_gtk_len == 0)
1005 		res = wpa_snprintf_hex(buf, buflen, wpa_s->last_gtk,
1006 				       wpa_s->last_gtk_len);
1014 					wpa_sm_get_anonce(wpa_s->wpa),
1017 		res = os_snprintf(buf, buflen, "%d", wpa_s->last_tk_key_idx);
1020 		res = wpa_config_get_value(cmd, wpa_s->conf, buf, buflen);
1030 static int wpa_supplicant_ctrl_iface_preauth(struct wpa_supplicant *wpa_s,
1034 	struct wpa_ssid *ssid = wpa_s->current_ssid;
1043 	rsn_preauth_deinit(wpa_s->wpa);
1044 	if (rsn_preauth_init(wpa_s->wpa, bssid, ssid ? &ssid->eap : NULL))
1055 	struct wpa_supplicant *wpa_s, char *addr)
1069 	if (wpa_tdls_is_external_setup(wpa_s->wpa))
1070 		ret = wpa_tdls_send_discovery_request(wpa_s->wpa, peer);
1072 		ret = wpa_drv_tdls_oper(wpa_s, TDLS_DISCOVERY_REQ, peer);
1079 	struct wpa_supplicant *wpa_s, char *addr)
1093 	if ((wpa_s->conf->tdls_external_control) &&
1094 	    wpa_tdls_is_external_setup(wpa_s->wpa))
1095 		return wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
1097 	wpa_tdls_remove(wpa_s->wpa, peer);
1099 	if (wpa_tdls_is_external_setup(wpa_s->wpa))
1100 		ret = wpa_tdls_start(wpa_s->wpa, peer);
1102 		ret = wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, peer);
1109 	struct wpa_supplicant *wpa_s, char *addr)
1117 		wpa_tdls_teardown_peers(wpa_s->wpa);
1130 	if ((wpa_s->conf->tdls_external_control) &&
1131 	    wpa_tdls_is_external_setup(wpa_s->wpa))
1132 		return wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
1134 	if (wpa_tdls_is_external_setup(wpa_s->wpa))
1136 			wpa_s->wpa, peer,
1139 		ret = wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, peer);
1146 	struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
1151 			  wpa_s->drv_flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT ?
1152 			  (wpa_s->drv_flags &
1162 	struct wpa_supplicant *wpa_s, char *cmd)
1169 	if (!wpa_tdls_is_external_setup(wpa_s->wpa)) {
1229 	return wpa_tdls_enable_chan_switch(wpa_s->wpa, peer, oper_class,
1235 	struct wpa_supplicant *wpa_s, char *cmd)
1239 	if (!wpa_tdls_is_external_setup(wpa_s->wpa)) {
1255 	return wpa_tdls_disable_chan_switch(wpa_s->wpa, peer);
1260 	struct wpa_supplicant *wpa_s, const char *addr,
1276 	tdls_status = wpa_tdls_get_link_status(wpa_s->wpa, peer);
1290 static int wmm_ac_ctrl_addts(struct wpa_supplicant *wpa_s, char *cmd)
1328 	return wpas_wmm_ac_addts(wpa_s, &params);
1332 static int wmm_ac_ctrl_delts(struct wpa_supplicant *wpa_s, char *cmd)
1336 	return wpas_wmm_ac_delts(wpa_s, tsid);
1344 	struct wpa_supplicant *wpa_s, char *addr)
1359 	bss = wpa_bss_get_bssid(wpa_s, target_ap);
1365 	return wpa_ft_start_over_ds(wpa_s->wpa, target_ap, mdie, force);
1371 static int wpa_supplicant_ctrl_iface_wps_pbc(struct wpa_supplicant *wpa_s,
1415 	if (wpa_s->ap_iface)
1416 		return wpa_supplicant_ap_wps_pbc(wpa_s, _bssid, _p2p_dev_addr);
1419 	return wpas_wps_start_pbc(wpa_s, _bssid, 0, multi_ap);
1423 static int wpa_supplicant_ctrl_iface_wps_pin(struct wpa_supplicant *wpa_s,
1448 	if (wpa_s->ap_iface) {
1460 		return wpa_supplicant_ap_wps_pin(wpa_s, _bssid, pin,
1466 		ret = wpas_wps_start_pin(wpa_s, _bssid, pin, 0,
1476 	ret = wpas_wps_start_pin(wpa_s, _bssid, NULL, 0, DEV_PW_DEFAULT);
1490 	struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
1536 static int wpa_supplicant_ctrl_iface_wps_nfc(struct wpa_supplicant *wpa_s,
1546 	return wpas_wps_start_nfc(wpa_s, NULL, _bssid, NULL, 0, 0, NULL, NULL,
1552 	struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1569 	buf = wpas_wps_nfc_config_token(wpa_s, ndef, pos);
1585 	struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
1598 	buf = wpas_wps_nfc_token(wpa_s, ndef);
1614 	struct wpa_supplicant *wpa_s, char *pos)
1642 	ret = wpas_wps_nfc_tag_read(wpa_s, buf, forced_freq);
1649 static int wpas_ctrl_nfc_get_handover_req_wps(struct wpa_supplicant *wpa_s,
1656 	buf = wpas_wps_nfc_handover_req(wpa_s, ndef);
1672 static int wpas_ctrl_nfc_get_handover_req_p2p(struct wpa_supplicant *wpa_s,
1679 	buf = wpas_p2p_nfc_handover_req(wpa_s, ndef);
1697 static int wpas_ctrl_nfc_get_handover_req(struct wpa_supplicant *wpa_s,
1720 			wpa_s, reply, max_len, ndef);
1726 			wpa_s, reply, max_len, ndef);
1734 static int wpas_ctrl_nfc_get_handover_sel_wps(struct wpa_supplicant *wpa_s,
1741 	buf = wpas_wps_nfc_handover_sel(wpa_s, ndef, cr, uuid);
1757 static int wpas_ctrl_nfc_get_handover_sel_p2p(struct wpa_supplicant *wpa_s,
1764 	buf = wpas_p2p_nfc_handover_sel(wpa_s, ndef, tag);
1780 static int wpas_ctrl_nfc_get_handover_sel(struct wpa_supplicant *wpa_s,
1806 			wpa_s, reply, max_len, ndef,
1813 			wpa_s, reply, max_len, ndef, 0);
1818 			wpa_s, reply, max_len, ndef, 1);
1826 static int wpas_ctrl_nfc_report_handover(struct wpa_supplicant *wpa_s,
1911 		ret = wpas_wps_nfc_report_handover(wpa_s, req, sel);
1915 		ret = wpas_ap_wps_nfc_report_handover(wpa_s, req, sel);
1917 			ret = wpas_er_wps_nfc_report_handover(wpa_s, req, sel);
1922 		ret = wpas_p2p_nfc_report_handover(wpa_s, 1, req, sel, 0);
1925 		ret = wpas_p2p_nfc_report_handover(wpa_s, 0, req, sel,
1945 static int wpa_supplicant_ctrl_iface_wps_reg(struct wpa_supplicant *wpa_s,
1969 		return wpas_wps_start_reg(wpa_s, bssid, pin, NULL);
1992 	return wpas_wps_start_reg(wpa_s, bssid, pin, &ap);
1997 static int wpa_supplicant_ctrl_iface_wps_ap_pin(struct wpa_supplicant *wpa_s,
2005 	if (!wpa_s->ap_iface)
2013 		wpas_wps_ap_pin_disable(wpa_s);
2020 		pin_txt = wpas_wps_ap_pin_random(wpa_s, timeout);
2027 		pin_txt = wpas_wps_ap_pin_get(wpa_s);
2045 		if (wpas_wps_ap_pin_set(wpa_s, pin, timeout) < 0)
2056 static int wpa_supplicant_ctrl_iface_wps_er_pin(struct wpa_supplicant *wpa_s,
2071 	return wpas_wps_er_add_pin(wpa_s, addr, uuid, pin);
2075 static int wpa_supplicant_ctrl_iface_wps_er_learn(struct wpa_supplicant *wpa_s,
2083 	return wpas_wps_er_learn(wpa_s, uuid, pin);
2088 	struct wpa_supplicant *wpa_s, char *cmd)
2095 	return wpas_wps_er_set_config(wpa_s, uuid, atoi(id));
2100 	struct wpa_supplicant *wpa_s, char *cmd)
2139 	return wpas_wps_er_config(wpa_s, cmd, pin, &ap);
2145 	struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
2164 	buf = wpas_wps_er_nfc_config_token(wpa_s, ndef, uuid);
2185 	struct wpa_supplicant *wpa_s, char *addr)
2198 	return ibss_rsn_start(wpa_s->ibss_rsn, peer);
2203 static int wpa_supplicant_ctrl_iface_ctrl_rsp(struct wpa_supplicant *wpa_s,
2225 	ssid = wpa_config_get_network(wpa_s->conf, id);
2232 	return wpa_supplicant_ctrl_iface_ctrl_rsp_handle(wpa_s, ssid, rsp,
2241 static int wpa_supplicant_ctrl_iface_status(struct wpa_supplicant *wpa_s,
2254 		return wpa_drv_status(wpa_s, buf, buflen);
2259 	if (wpa_s->wpa_state >= WPA_ASSOCIATED) {
2260 		struct wpa_ssid *ssid = wpa_s->current_ssid;
2262 				  MAC2STR(wpa_s->bssid));
2267 				  wpa_s->assoc_freq);
2276 				int _res = wpa_drv_get_ssid(wpa_s, ssid_buf);
2345 		if (wpa_s->connection_set &&
2346 		    (wpa_s->connection_ht || wpa_s->connection_vht ||
2347 		     wpa_s->connection_he || wpa_s->connection_eht)) {
2350 					  wpa_s->connection_eht ? 7 :
2351 					  (wpa_s->connection_he ? 6 :
2352 					   (wpa_s->connection_vht ? 5 : 4)));
2359 		if (wpa_s->ap_iface) {
2360 			pos += ap_ctrl_iface_wpa_get_status(wpa_s, pos,
2365 		pos += wpa_sm_get_status(wpa_s->wpa, pos, end - pos, verbose);
2369 	if (wpa_s->wpa_state >= WPA_ASSOCIATED &&
2371 	    !wpa_s->ap_iface &&
2373 	    wpa_s->sme.sae.state == SAE_ACCEPTED) {
2377 				  wpa_s->sme.sae.group,
2378 				  wpa_s->sme.sae.h2e,
2379 				  wpa_s->sme.sae.pk);
2387 			  wpa_supplicant_state_txt(wpa_s->wpa_state));
2392 	if (wpa_s->l2 &&
2393 	    l2_packet_get_ip_addr(wpa_s->l2, tmp, sizeof(tmp)) >= 0) {
2401 	if (wpa_s->global->p2p) {
2403 				  "\n", MAC2STR(wpa_s->global->p2p_dev_addr));
2411 			  MAC2STR(wpa_s->own_addr));
2416 	if (wpa_s->valid_links) {
2418 				  MAC2STR(wpa_s->ap_mld_addr));
2425 	if (wpa_s->current_bss &&
2426 	    (hs20 = wpa_bss_get_vendor_ie(wpa_s->current_bss,
2428 	    wpa_s->wpa_proto == WPA_PROTO_RSN &&
2429 	    wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
2441 	if (wpa_s->current_ssid) {
2445 		for (cred = wpa_s->conf->cred; cred; cred = cred->next) {
2448 			if (wpa_s->current_ssid->parent_cred != cred)
2464 			if (wpa_s->current_bss && wpa_s->current_bss->anqp) {
2466 					wpa_s->current_bss->anqp->domain_name;
2483 			if (wpa_s->current_bss == NULL ||
2484 			    wpa_s->current_bss->anqp == NULL)
2488 					wpa_s, cred,
2489 					wpa_s->current_bss->anqp->domain_name);
2507 	if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
2508 	    wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
2509 		res = eapol_sm_get_status(wpa_s->eapol, pos, end - pos,
2516 	res = ieee802_1x_kay_get_status(wpa_s->kay, pos, end - pos);
2521 	sess_id = eapol_sm_get_session_id(wpa_s->eapol, &sess_id_len);
2539 	res = rsn_preauth_get_status(wpa_s->wpa, pos, end - pos, verbose);
2546 		uuid_bin2str(wpa_s->wps->uuid, uuid_str, sizeof(uuid_str));
2554 	if (wpa_s->ieee80211ac) {
2562 	if (wpa_s->sme.bss_max_idle_period) {
2564 				  wpa_s->sme.bss_max_idle_period);
2571 	if (wpa_s->ssid_verified) {
2578 	if (wpa_s->bigtk_set) {
2592 		wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE
2594 			     wpa_s->current_ssid ? wpa_s->current_ssid->id : -1,
2595 			     wpa_s->wpa_state,
2596 			     MAC2STR(wpa_s->bssid),
2597 			     wpa_s->current_ssid && wpa_s->current_ssid->ssid ?
2598 			     wpa_ssid_txt(wpa_s->current_ssid->ssid,
2599 					  wpa_s->current_ssid->ssid_len) : "");
2600 		if (wpa_s->wpa_state == WPA_COMPLETED) {
2601 			struct wpa_ssid *ssid = wpa_s->current_ssid;
2605 			if (wpa_s->valid_links)
2608 					    MAC2STR(wpa_s->ap_mld_addr));
2610 			wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED
2613 				     MAC2STR(wpa_s->bssid), "(auth)",
2625 static int wpa_supplicant_ctrl_iface_bssid(struct wpa_supplicant *wpa_s,
2645 	ssid = wpa_config_get_network(wpa_s->conf, id);
2659 static int wpa_supplicant_ctrl_iface_bssid_ignore(struct wpa_supplicant *wpa_s,
2672 		e = wpa_s->bssid_ignore;
2686 		wpa_bssid_ignore_clear(wpa_s);
2701 	ret = wpa_bssid_ignore_add(wpa_s, bssid);
2704 	ret = wpa_bssid_ignore_add(wpa_s, bssid);
2712 static int wpa_supplicant_ctrl_iface_log_level(struct wpa_supplicant *wpa_s,
2760 	struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
2774 	ssid = wpa_s->conf->ssid;
2804 				  ssid == wpa_s->current_ssid ?
3052 static char * wpa_supplicant_wps_ie_txt_buf(struct wpa_supplicant *wpa_s,
3063 	else if (wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 0))
3079 static char * wpa_supplicant_wps_ie_txt(struct wpa_supplicant *wpa_s,
3086 	return wpa_supplicant_wps_ie_txt_buf(wpa_s, pos, end, wps_ie);
3095 	struct wpa_supplicant *wpa_s,
3152 	pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
3264 	struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
3278 	dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
3279 		ret = wpa_supplicant_ctrl_iface_scan_result(wpa_s, bss, pos,
3293 	struct wpa_supplicant *wpa_s, char *cmd, char *reply, size_t max_len)
3305 	if (wpas_mesh_add_interface(wpa_s, ifname, sizeof(ifname)) < 0)
3314 	struct wpa_supplicant *wpa_s, char *cmd)
3322 	ssid = wpa_config_get_network(wpa_s->conf, id);
3345 	wpa_supplicant_select_network(wpa_s, ssid);
3352 	struct wpa_supplicant *wpa_s, char *cmd)
3360 	global = wpa_s->global;
3361 	orig = wpa_s;
3363 	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3364 		if (os_strcmp(wpa_s->ifname, cmd) == 0) {
3375 	if (wpa_s->mesh_if_created && wpa_s == orig) {
3381 	wpa_s->reassociate = 0;
3382 	wpa_s->disconnected = 1;
3383 	wpa_supplicant_cancel_sched_scan(wpa_s);
3384 	wpa_supplicant_cancel_scan(wpa_s);
3390 	wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
3392 	if (wpa_s->mesh_if_created)
3393 		wpa_supplicant_remove_iface(global, wpa_s, 0);
3400 	struct wpa_supplicant *wpa_s, char *cmd)
3407 	return wpas_mesh_peer_remove(wpa_s, addr);
3412 	struct wpa_supplicant *wpa_s, char *cmd)
3429 	return wpas_mesh_peer_add(wpa_s, addr, duration);
3434 	struct wpa_supplicant *wpa_s, char *cmd)
3463 	os_memcpy(eth->ether_shost, wpa_s->own_addr, ETH_ALEN);
3469 	ret = wpa_drv_mesh_link_probe(wpa_s, addr, buf, len);
3479 	struct wpa_supplicant *wpa_s, char *cmd)
3493 		ssid = wpa_config_get_network(wpa_s->conf, id);
3508 		int *freqs = freq_range_to_channel_list(wpa_s, pos + 6);
3510 			os_free(wpa_s->select_network_scan_freqs);
3511 			wpa_s->select_network_scan_freqs = freqs;
3515 	wpa_s->scan_min_time.sec = 0;
3516 	wpa_s->scan_min_time.usec = 0;
3517 	wpa_supplicant_select_network(wpa_s, ssid);
3524 	struct wpa_supplicant *wpa_s, char *cmd)
3537 		ssid = wpa_config_get_network(wpa_s->conf, id);
3554 	wpa_s->scan_min_time.sec = 0;
3555 	wpa_s->scan_min_time.usec = 0;
3556 	wpa_supplicant_enable_network(wpa_s, ssid);
3563 	struct wpa_supplicant *wpa_s, char *cmd)
3576 		ssid = wpa_config_get_network(wpa_s->conf, id);
3589 	wpa_supplicant_disable_network(wpa_s, ssid);
3596 	struct wpa_supplicant *wpa_s, char *buf, size_t buflen)
3603 	ssid = wpa_supplicant_add_network(wpa_s);
3615 	struct wpa_supplicant *wpa_s, char *cmd)
3623 		return wpa_supplicant_remove_all_networks(wpa_s);
3629 	result = wpa_supplicant_remove_network(wpa_s, id);
3645 	struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
3666 		if (wpa_s->current_ssid == ssid &&
3667 		    wpa_s->wpa_state == WPA_COMPLETED)
3668 			wpa_supplicant_reset_bgscan(wpa_s);
3677 		wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
3679 		if (wpa_s->current_ssid == ssid ||
3680 		    wpa_s->current_ssid == NULL) {
3685 			eapol_sm_invalidate_cached_session(wpa_s->eapol);
3694 		wpa_config_update_prio_list(wpa_s->conf);
3701 	struct wpa_supplicant *wpa_s, char *cmd)
3725 	ssid = wpa_config_get_network(wpa_s->conf, id);
3735 	ret = wpa_supplicant_ctrl_iface_update_network(wpa_s, ssid, name,
3740 		wpas_notify_network_bssid_set_changed(wpa_s, ssid);
3744 		wpas_notify_network_type_changed(wpa_s, ssid);
3751 	struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
3768 	ssid = wpa_config_get_network(wpa_s->conf, id);
3795 	struct wpa_supplicant *wpa_s, char *cmd,
3818 		   wpa_s->ifname, dst_wpa_s->ifname, id_s, id_d, name);
3820 	ssid_s = wpa_config_get_network(wpa_s->conf, id_s);
3850 static int wpa_supplicant_ctrl_iface_list_creds(struct wpa_supplicant *wpa_s,
3865 	cred = wpa_s->conf->cred;
3883 static int wpa_supplicant_ctrl_iface_add_cred(struct wpa_supplicant *wpa_s,
3891 	cred = wpa_config_add_cred(wpa_s->conf);
3895 	wpa_msg(wpa_s, MSG_INFO, CRED_ADDED "%d", cred->id);
3904 static int wpa_supplicant_ctrl_iface_remove_cred(struct wpa_supplicant *wpa_s,
3914 		return wpas_remove_all_creds(wpa_s);
3920 		cred = wpa_s->conf->cred;
3930 					wpas_remove_cred(wpa_s, prev);
3941 		cred = wpa_s->conf->cred;
3947 				wpas_remove_cred(wpa_s, prev);
3955 	cred = wpa_config_get_cred(wpa_s->conf, id);
3956 	return wpas_remove_cred(wpa_s, cred);
3960 static int wpa_supplicant_ctrl_iface_set_cred(struct wpa_supplicant *wpa_s,
3984 	cred = wpa_config_get_cred(wpa_s->conf, id);
3997 	wpa_msg(wpa_s, MSG_INFO, CRED_MODIFIED "%d %s", cred->id, name);
4003 static int wpa_supplicant_ctrl_iface_get_cred(struct wpa_supplicant *wpa_s,
4022 	cred = wpa_config_get_cred(wpa_s->conf, id);
4049 static int wpa_supplicant_ctrl_iface_save_config(struct wpa_supplicant *wpa_s)
4053 	if (!wpa_s->conf->update_config) {
4059 	ret = wpa_config_write(wpa_s->confname, wpa_s->conf);
4518 static int ctrl_iface_get_capability_auth_alg(struct wpa_supplicant *wpa_s,
4564 	if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE) {
4574 	if (wpa_is_fils_supported(wpa_s)) {
4583 	if (wpa_is_fils_sk_pfs_supported(wpa_s)) {
4656 static int ctrl_iface_get_capability_channels(struct wpa_supplicant *wpa_s,
4666 	for (j = 0; j < wpa_s->hw.num_modes; j++) {
4667 		switch (wpa_s->hw.modes[j].mode) {
4687 		chnl = wpa_s->hw.modes[j].channels;
4688 		for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
4706 static int ctrl_iface_get_capability_freq(struct wpa_supplicant *wpa_s,
4716 	for (j = 0; j < wpa_s->hw.num_modes; j++) {
4717 		switch (wpa_s->hw.modes[j].mode) {
4738 		chnl = wpa_s->hw.modes[j].channels;
4739 		for (i = 0; i < wpa_s->hw.modes[j].num_channels; i++) {
4764 	struct wpa_supplicant *wpa_s, const char *_field, char *buf,
4804 	res = wpa_drv_get_capa(wpa_s, &capa);
4827 		return ctrl_iface_get_capability_auth_alg(wpa_s, res, strict,
4835 		return ctrl_iface_get_capability_channels(wpa_s, buf, buflen);
4838 		return ctrl_iface_get_capability_freq(wpa_s, buf, buflen);
4842 		return ctrl_iface_get_capability_tdls(wpa_s, buf, buflen);
4875 		if (wpa_is_fils_supported(wpa_s) &&
4876 		    wpa_is_fils_sk_pfs_supported(wpa_s)) {
4884 		if (wpa_is_fils_supported(wpa_s)) {
4893 	if (os_strcmp(field, "multibss") == 0 && wpa_s->multi_bss_support) {
4926 	    (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) {
4940 		if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) ||
4941 		    (wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OCV))
4952 		if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_BEACON_PROTECTION) ||
4953 		    (wpa_s->drv_flags2 &
5326 static int print_bss_info(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
5478 		pos = wpa_supplicant_wps_ie_txt(wpa_s, pos, end, bss);
5792 static int wpa_supplicant_ctrl_iface_bss(struct wpa_supplicant *wpa_s,
5808 			bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss,
5810 			bsslast = dl_list_last(&wpa_s->bss_id, struct wpa_bss,
5830 			bss = wpa_bss_get_id_range(wpa_s, id1, id2);
5832 				bsslast = dl_list_last(&wpa_s->bss_id,
5836 				bsslast = wpa_bss_get_id(wpa_s, id2);
5841 						if (next == &wpa_s->bss_id)
5854 		bss = dl_list_first(&wpa_s->bss_id, struct wpa_bss, list_id);
5856 		bss = dl_list_last(&wpa_s->bss_id, struct wpa_bss, list_id);
5859 		bss = wpa_bss_get_id(wpa_s, i);
5862 		bss = wpa_bss_get_id(wpa_s, i);
5865 			if (next == &wpa_s->bss_id)
5872 		bss = wpa_s->current_bss;
5876 			bss = wpa_bss_get_p2p_dev_addr(wpa_s, bssid);
5881 		bss = wpa_bss_get_bssid(wpa_s, bssid);
5886 		dl_list_for_each(tmp, &wpa_s->bss_id, struct wpa_bss, list_id)
5908 		len = print_bss_info(wpa_s, bss, mask, buf, buflen);
5914 			    (bss == dl_list_last(&wpa_s->bss_id,
5928 		if (next == &wpa_s->bss_id)
5938 	struct wpa_supplicant *wpa_s, char *cmd)
5941 	return wpa_supplicant_set_ap_scan(wpa_s, ap_scan);
5946 	struct wpa_supplicant *wpa_s, char *cmd)
5949 	return wpa_supplicant_set_scan_interval(wpa_s, scan_int);
5954 	struct wpa_supplicant *wpa_s, char *cmd)
5957 	return wpa_supplicant_set_bss_expiration_age(wpa_s, expire_age);
5962 	struct wpa_supplicant *wpa_s, char *cmd)
5965 	return wpa_supplicant_set_bss_expiration_count(wpa_s, expire_count);
5970 	struct wpa_supplicant *wpa_s, char *cmd)
5975 		wpa_bss_flush(wpa_s);
5977 		wpa_bss_flush_by_age(wpa_s, flush_age);
5982 static void wpa_supplicant_ctrl_iface_drop_sa(struct wpa_supplicant *wpa_s)
5986 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, 0, 0, NULL, 0, NULL,
5988 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, 1, 0, NULL, 0, NULL,
5990 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, 2, 0, NULL, 0, NULL,
5992 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, 3, 0, NULL, 0, NULL,
5994 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, 4, 0, NULL, 0, NULL,
5996 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, 5, 0, NULL, 0, NULL,
5999 	wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, wpa_s->bssid, 0, 0, NULL, 0,
6001 	if (wpa_sm_ext_key_id(wpa_s->wpa))
6002 		wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, wpa_s->bssid, 1, 0,
6005 	wpa_drv_mlme_setprotection(wpa_s, wpa_s->bssid,
6008 	wpa_sm_drop_sa(wpa_s->wpa);
6013 static int wpa_supplicant_ctrl_iface_roam(struct wpa_supplicant *wpa_s,
6021 	struct wpa_ssid *ssid = wpa_s->current_ssid;
6038 	bss = wpa_bss_get(wpa_s, bssid, ssid->ssid, ssid->ssid_len);
6050 	already_connecting = radio_work_pending(wpa_s, "sme-connect");
6051 	wpa_s->reassociate = 1;
6052 	wpa_supplicant_connect(wpa_s, bss, ssid);
6059 	if (!already_connecting && radio_work_pending(wpa_s, "sme-connect"))
6060 		wpa_s->roam_in_progress = true;
6068 static int p2p_ctrl_find(struct wpa_supplicant *wpa_s, char *cmd)
6081 	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
6082 		wpa_dbg(wpa_s, MSG_INFO,
6115 		search_delay = wpas_p2p_search_delay(wpa_s);
6147 	return wpas_p2p_find(wpa_s, timeout, type, _dev_type != NULL, _dev_type,
6297 static int p2p_ctrl_asp_provision_resp(struct wpa_supplicant *wpa_s, char *cmd)
6323 	return wpas_p2p_prov_disc(wpa_s, addr, NULL, WPAS_P2P_PD_FOR_ASP,
6328 static int p2p_ctrl_asp_provision(struct wpa_supplicant *wpa_s, char *cmd)
6352 	return wpas_p2p_prov_disc(wpa_s, addr, NULL, WPAS_P2P_PD_FOR_ASP,
6357 static int p2p_ctrl_connect(struct wpa_supplicant *wpa_s, char *cmd,
6380 	if (!wpa_s->global->p2p_init_wpa_s)
6382 	if (wpa_s->global->p2p_init_wpa_s != wpa_s) {
6383 		wpa_dbg(wpa_s, MSG_DEBUG, "Direct P2P_CONNECT command to %s",
6384 			wpa_s->global->p2p_init_wpa_s->ifname);
6385 		wpa_s = wpa_s->global->p2p_init_wpa_s;
6406 		ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
6420 	vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
6421 	ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
6423 	he = (os_strstr(cmd, " he") != NULL) || wpa_s->conf->p2p_go_he;
6424 	edmg = (os_strstr(cmd, " edmg") != NULL) || wpa_s->conf->p2p_go_edmg;
6495 	new_pin = wpas_p2p_connect(wpa_s, addr, pin, wps_method,
6522 static int p2p_ctrl_listen(struct wpa_supplicant *wpa_s, char *cmd)
6525 	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
6526 		wpa_dbg(wpa_s, MSG_INFO,
6530 	return wpas_p2p_listen(wpa_s, timeout);
6534 static int p2p_ctrl_prov_disc(struct wpa_supplicant *wpa_s, char *cmd)
6555 	return wpas_p2p_prov_disc(wpa_s, addr, pos, use, NULL);
6559 static int p2p_get_passphrase(struct wpa_supplicant *wpa_s, char *buf,
6562 	struct wpa_ssid *ssid = wpa_s->current_ssid;
6573 static int p2p_ctrl_serv_disc_req(struct wpa_supplicant *wpa_s, char *cmd,
6603 		ref = wpas_p2p_sd_request_upnp(wpa_s, dst, version, pos);
6606 		ref = wpas_p2p_sd_request_wifi_display(wpa_s, dst, pos + 13);
6640 		ref = wpas_p2p_sd_request_asp(wpa_s, dst, (u8) id,
6655 		ref = wpas_p2p_sd_request(wpa_s, dst, tlvs);
6667 static int p2p_ctrl_serv_disc_cancel_req(struct wpa_supplicant *wpa_s,
6675 	return wpas_p2p_sd_cancel_request(wpa_s, req);
6679 static int p2p_ctrl_serv_disc_resp(struct wpa_supplicant *wpa_s, char *cmd)
6721 	wpas_p2p_sd_response(wpa_s, freq, dst, dialog_token, resp_tlvs);
6727 static int p2p_ctrl_serv_disc_external(struct wpa_supplicant *wpa_s,
6732 	wpa_s->p2p_sd_over_ctrl_iface = atoi(cmd);
6737 static int p2p_ctrl_service_add_bonjour(struct wpa_supplicant *wpa_s,
6772 	ret = wpas_p2p_service_add_bonjour(wpa_s, query, resp);
6782 static int p2p_ctrl_service_add_upnp(struct wpa_supplicant *wpa_s, char *cmd)
6795 	return wpas_p2p_service_add_upnp(wpa_s, version, pos);
6799 static int p2p_ctrl_service_add_asp(struct wpa_supplicant *wpa_s,
6839 	if (wpas_p2p_service_p2ps_id_exists(wpa_s, adv_id)) {
6908 	return wpas_p2p_service_add_asp(wpa_s, auto_accept, adv_id, adv_str,
6914 static int p2p_ctrl_service_add(struct wpa_supplicant *wpa_s, char *cmd)
6924 		return p2p_ctrl_service_add_bonjour(wpa_s, pos);
6926 		return p2p_ctrl_service_add_upnp(wpa_s, pos);
6928 		return p2p_ctrl_service_add_asp(wpa_s, 0, pos);
6934 static int p2p_ctrl_service_del_bonjour(struct wpa_supplicant *wpa_s,
6953 	ret = wpas_p2p_service_del_bonjour(wpa_s, query);
6959 static int p2p_ctrl_service_del_upnp(struct wpa_supplicant *wpa_s, char *cmd)
6972 	return wpas_p2p_service_del_upnp(wpa_s, version, pos);
6976 static int p2p_ctrl_service_del_asp(struct wpa_supplicant *wpa_s, char *cmd)
6981 		wpas_p2p_service_flush_asp(wpa_s);
6988 	return wpas_p2p_service_del_asp(wpa_s, adv_id);
6992 static int p2p_ctrl_service_del(struct wpa_supplicant *wpa_s, char *cmd)
7002 		return p2p_ctrl_service_del_bonjour(wpa_s, pos);
7004 		return p2p_ctrl_service_del_upnp(wpa_s, pos);
7006 		return p2p_ctrl_service_del_asp(wpa_s, pos);
7012 static int p2p_ctrl_service_replace(struct wpa_supplicant *wpa_s, char *cmd)
7022 		return p2p_ctrl_service_add_asp(wpa_s, 1, pos);
7029 static int p2p_ctrl_reject(struct wpa_supplicant *wpa_s, char *cmd)
7038 	return wpas_p2p_reject(wpa_s, addr);
7042 static int p2p_ctrl_invite_persistent(struct wpa_supplicant *wpa_s, char *cmd)
7061 	ssid = wpa_config_get_network(wpa_s->conf, id);
7085 	vht = (os_strstr(cmd, " vht") != NULL) || wpa_s->conf->p2p_go_vht;
7086 	ht40 = (os_strstr(cmd, " ht40") != NULL) || wpa_s->conf->p2p_go_ht40 ||
7088 	he = (os_strstr(cmd, " he") != NULL) || wpa_s->conf->p2p_go_he;
7089 	edmg = (os_strstr(cmd, " edmg") != NULL) || wpa_s->conf->p2p_go_edmg;
7108 	return wpas_p2p_invite(wpa_s, _peer, ssid, NULL, freq, freq2, ht40, vht,
7114 static int p2p_ctrl_invite_group(struct wpa_supplicant *wpa_s, char *cmd)
7144 	return wpas_p2p_invite_group(wpa_s, cmd, peer, go_dev, allow_6ghz);
7148 static int p2p_ctrl_invite(struct wpa_supplicant *wpa_s, char *cmd)
7151 		return p2p_ctrl_invite_persistent(wpa_s, cmd + 11);
7153 		return p2p_ctrl_invite_group(wpa_s, cmd + 6);
7159 static int p2p_ctrl_group_add_persistent(struct wpa_supplicant *wpa_s,
7167 	ssid = wpa_config_get_network(wpa_s->conf, id);
7175 	return wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq, 0,
7183 static int p2p_ctrl_group_add(struct wpa_supplicant *wpa_s, char *cmd)
7187 	int vht = wpa_s->conf->p2p_go_vht;
7188 	int ht40 = wpa_s->conf->p2p_go_ht40 || vht;
7189 	int he = wpa_s->conf->p2p_go_he;
7190 	int edmg = wpa_s->conf->p2p_go_edmg;
7235 	if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_ACS_OFFLOAD) &&
7237 		if (freq == 2 && wpa_s->best_24_freq <= 0) {
7238 			wpa_s->p2p_go_acs_band = HOSTAPD_MODE_IEEE80211G;
7239 			wpa_s->p2p_go_do_acs = 1;
7241 		} else if (freq == 5 && wpa_s->best_5_freq <= 0) {
7242 			wpa_s->p2p_go_acs_band = HOSTAPD_MODE_IEEE80211A;
7243 			wpa_s->p2p_go_do_acs = 1;
7246 			wpa_s->p2p_go_acs_band = HOSTAPD_MODE_IEEE80211ANY;
7247 			wpa_s->p2p_go_do_acs = 1;
7250 		wpa_s->p2p_go_do_acs = 0;
7262 	wpa_s->p2p_go_allow_dfs = !!(wpa_s->drv_flags &
7266 		return p2p_ctrl_group_add_persistent(wpa_s, group_id,
7272 	return wpas_p2p_group_add(wpa_s, persistent, freq, freq2, ht40, vht,
7277 static int p2p_ctrl_group_member(struct wpa_supplicant *wpa_s, const char *cmd,
7285 	ssid = wpa_s->current_ssid;
7286 	if (!wpa_s->global->p2p || !ssid || ssid->mode != WPAS_MODE_P2P_GO ||
7290 	iaddr = p2p_group_get_client_interface_addr(wpa_s->p2p_group, dev_addr);
7303 	struct wpa_supplicant *wpa_s;
7305 	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7306 		if (wpa_bss_get_p2p_dev_addr(wpa_s, p2p_dev_addr))
7314 static int p2p_ctrl_peer(struct wpa_supplicant *wpa_s, char *cmd,
7325 	if (!wpa_s->global->p2p)
7343 	info = p2p_get_peer_info(wpa_s->global->p2p, addr_ptr, next);
7349 	    !wpas_find_p2p_dev_addr_bss(wpa_s->global, info->p2p_device_addr)) {
7399 	ssid = wpas_p2p_get_persistent(wpa_s, info->p2p_device_addr, NULL, 0);
7432 static int p2p_ctrl_disallow_freq(struct wpa_supplicant *wpa_s,
7437 	if (wpa_s->global->p2p == NULL)
7440 	if (freq_range_list_parse(&wpa_s->global->p2p_disallow_freq, param) < 0)
7443 	for (i = 0; i < wpa_s->global->p2p_disallow_freq.num; i++) {
7445 		freq = &wpa_s->global->p2p_disallow_freq.range[i];
7450 	wpas_p2p_update_channel_list(wpa_s, WPAS_P2P_CHANNEL_UPDATE_DISALLOW);
7455 static int p2p_ctrl_set(struct wpa_supplicant *wpa_s, char *cmd)
7459 	if (wpa_s->global->p2p == NULL)
7468 		p2p_set_client_discoverability(wpa_s->global->p2p,
7474 		p2p_set_managed_oper(wpa_s->global->p2p, atoi(param));
7486 		return p2p_set_listen_channel(wpa_s->global->p2p, op_class,
7491 		return p2p_set_ssid_postfix(wpa_s->global->p2p, (u8 *) param,
7516 		return wpas_p2p_set_noa(wpa_s, count, start, duration);
7520 		return wpa_drv_set_p2p_powersave(wpa_s, atoi(param), -1, -1);
7523 		return wpa_drv_set_p2p_powersave(wpa_s, -1, atoi(param), -1);
7526 		return wpa_drv_set_p2p_powersave(wpa_s, -1, -1, atoi(param));
7529 		wpa_s->global->p2p_disabled = atoi(param);
7531 			   wpa_s->global->p2p_disabled ?
7533 		if (wpa_s->global->p2p_disabled) {
7534 			wpas_p2p_stop_find(wpa_s);
7535 			os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
7536 			p2p_flush(wpa_s->global->p2p);
7543 			wpa_s->global->conc_pref = WPA_CONC_PREF_STA;
7545 			wpa_s->global->conc_pref = WPA_CONC_PREF_P2P;
7556 		wpa_s->force_long_sd = atoi(param);
7564 		p2p_set_peer_filter(wpa_s->global->p2p, addr);
7569 		return wpas_p2p_set_cross_connect(wpa_s, atoi(param));
7573 			wpa_s->set_ap_uapsd = 0;
7575 			wpa_s->set_ap_uapsd = 1;
7576 			wpa_s->ap_uapsd = atoi(param);
7583 			wpa_s->set_sta_uapsd = 0;
7606 			wpa_s->set_sta_uapsd = 1;
7607 			wpa_s->sta_uapsd = 0;
7609 				wpa_s->sta_uapsd |= BIT(0);
7611 				wpa_s->sta_uapsd |= BIT(1);
7613 				wpa_s->sta_uapsd |= BIT(2);
7615 				wpa_s->sta_uapsd |= BIT(3);
7621 		return p2p_ctrl_disallow_freq(wpa_s, param);
7643 		return p2p_set_disc_int(wpa_s->global->p2p, min_disc_int,
7648 		wpa_s->global->p2p_per_sta_psk = !!atoi(param);
7654 		return wpas_p2p_nfc_tag_enabled(wpa_s, !!atoi(param));
7658 		wpa_s->p2p_disable_ip_addr_req = !!atoi(param);
7671 		p2p_set_override_pref_op_chan(wpa_s->global->p2p, op_class,
7683 static void p2p_ctrl_flush(struct wpa_supplicant *wpa_s)
7685 	os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
7686 	wpa_s->force_long_sd = 0;
7689 	os_free(wpa_s->get_pref_freq_list_override);
7690 	wpa_s->get_pref_freq_list_override = NULL;
7693 	wpas_p2p_stop_find(wpa_s);
7694 	wpa_s->parent->p2ps_method_config_any = 0;
7695 	if (wpa_s->global->p2p)
7696 		p2p_flush(wpa_s->global->p2p);
7700 static int p2p_ctrl_presence_req(struct wpa_supplicant *wpa_s, char *cmd)
7728 	return wpas_p2p_presence_req(wpa_s, dur1, int1, dur2, int2);
7732 static int p2p_ctrl_ext_listen(struct wpa_supplicant *wpa_s, char *cmd)
7746 	return wpas_p2p_ext_listen(wpa_s, period, interval);
7750 static int p2p_ctrl_remove_client(struct wpa_supplicant *wpa_s, const char *cmd)
7764 	wpas_p2p_remove_client(wpa_s, peer, iface_addr);
7769 static int p2p_ctrl_iface_p2p_lo_start(struct wpa_supplicant *wpa_s, char *cmd)
7780 	return wpas_p2p_lo_start(wpa_s, freq, period, interval, count);
7786 static int * freq_range_to_channel_list(struct wpa_supplicant *wpa_s, char *val)
7793 	if (wpa_s->hw.modes == NULL)
7800 	for (i = 0; i < wpa_s->hw.num_modes; i++) {
7803 		mode = &wpa_s->hw.modes[i];
7825 static int ctrl_interworking_select(struct wpa_supplicant *wpa_s, char *param)
7837 			freqs = freq_range_to_channel_list(wpa_s, pos + 5);
7844 	return interworking_select(wpa_s, auto_sel, freqs);
7848 static int ctrl_interworking_connect(struct wpa_supplicant *wpa_s, char *dst,
7859 	bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
7872 		dl_list_for_each_reverse(bss, &wpa_s->bss, struct wpa_bss,
7887 	return interworking_connect(wpa_s, bss, only_add);
7891 static int get_anqp(struct wpa_supplicant *wpa_s, char *dst)
7951 	return anqp_send_req(wpa_s, dst_addr, freq, id, num_id, subtypes,
7956 static int gas_request(struct wpa_supplicant *wpa_s, char *cmd)
8010 	ret = gas_send_request(wpa_s, dst_addr, advproto, query);
8020 static int gas_response_get(struct wpa_supplicant *wpa_s, char *cmd, char *buf,
8040 	if (wpa_s->last_gas_resp &&
8041 	    ether_addr_equal(addr, wpa_s->last_gas_addr) &&
8042 	    dialog_token == wpa_s->last_gas_dialog_token)
8043 		resp = wpa_s->last_gas_resp;
8044 	else if (wpa_s->prev_gas_resp &&
8045 		 ether_addr_equal(addr, wpa_s->prev_gas_addr) &&
8046 		 dialog_token == wpa_s->prev_gas_dialog_token)
8047 		resp = wpa_s->prev_gas_resp;
8080 		if (resp == wpa_s->prev_gas_resp) {
8081 			wpabuf_free(wpa_s->prev_gas_resp);
8082 			wpa_s->prev_gas_resp = NULL;
8084 			wpabuf_free(wpa_s->last_gas_resp);
8085 			wpa_s->last_gas_resp = NULL;
8096 static int get_hs20_anqp(struct wpa_supplicant *wpa_s, char *dst)
8123 	return hs20_anqp_send_req(wpa_s, dst_addr, subtypes, NULL, 0, 0);
8127 static int hs20_nai_home_realm_list(struct wpa_supplicant *wpa_s,
8144 	ret = hs20_anqp_send_req(wpa_s, addr,
8154 static int hs20_get_nai_home_realm_list(struct wpa_supplicant *wpa_s,
8157 	struct wpa_cred *cred = wpa_s->conf->cred;
8171 		return hs20_nai_home_realm_list(wpa_s, dst_addr,
8177 		return hs20_nai_home_realm_list(wpa_s, dst_addr, cred->realm);
8190 	ret = hs20_anqp_send_req(wpa_s, dst_addr,
8199 static int get_hs20_icon(struct wpa_supplicant *wpa_s, char *cmd, char *reply,
8217 	wpa_s->fetch_osu_icon_in_progress = 0;
8218 	return hs20_get_icon(wpa_s, dst_addr, icon, atoi(poffset), atoi(psize),
8223 static int del_hs20_icon(struct wpa_supplicant *wpa_s, char *cmd)
8230 		return hs20_del_icon(wpa_s, NULL, NULL);
8240 	return hs20_del_icon(wpa_s, dst_addr, icon);
8244 static int hs20_icon_request(struct wpa_supplicant *wpa_s, char *cmd, int inmem)
8258 	wpa_s->fetch_osu_icon_in_progress = 0;
8259 	return hs20_anqp_send_req(wpa_s, dst_addr, BIT(HS20_STYPE_ICON_REQUEST),
8268 static int wpa_supplicant_ctrl_iface_autoscan(struct wpa_supplicant *wpa_s,
8271 	enum wpa_states state = wpa_s->wpa_state;
8280 	os_free(wpa_s->conf->autoscan);
8281 	wpa_s->conf->autoscan = new_params;
8283 	if (wpa_s->conf->autoscan == NULL)
8284 		autoscan_deinit(wpa_s);
8286 		autoscan_init(wpa_s, 1);
8288 		wpa_supplicant_reinit_autoscan(wpa_s);
8301 static int wpas_ctrl_iface_wnm_sleep(struct wpa_supplicant *wpa_s, char *cmd)
8342 	ret = ieee802_11_send_wnmsleep_req(wpa_s, enter ? WNM_SLEEP_MODE_ENTER :
8351 static int wpas_ctrl_iface_wnm_bss_query(struct wpa_supplicant *wpa_s, char *cmd)
8370 	return wnm_send_bss_transition_mgmt_query(wpa_s, query_reason,
8376 static int wpas_ctrl_iface_coloc_intf_report(struct wpa_supplicant *wpa_s,
8386 	ret = wnm_send_coloc_intf_report(wpa_s, 0, elems);
8394 static int wpa_supplicant_signal_poll(struct wpa_supplicant *wpa_s, char *buf,
8401 	ret = wpa_drv_signal_poll(wpa_s, &si);
8461 static int wpas_ctrl_iface_signal_monitor(struct wpa_supplicant *wpa_s,
8468 	if (wpa_s->bgscan && wpa_s->bgscan_priv) {
8479 	return wpa_drv_signal_monitor(wpa_s, threshold, hysteresis);
8484 int wpas_ctrl_iface_get_pref_freq_list_override(struct wpa_supplicant *wpa_s,
8489 	char *pos = wpa_s->get_pref_freq_list_override;
8525 	struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen)
8556 	ret = wpa_drv_get_pref_freq_list(wpa_s, iface_type, &num, freq_list);
8572 static int wpas_ctrl_iface_driver_flags(struct wpa_supplicant *wpa_s,
8579 			  (long long unsigned) wpa_s->drv_flags);
8587 		if (wpa_s->drv_flags & (1LLU << i)) {
8600 static int wpas_ctrl_iface_driver_flags2(struct wpa_supplicant *wpa_s,
8607 			  (long long unsigned) wpa_s->drv_flags2);
8615 		if (wpa_s->drv_flags2 & (1LLU << i)) {
8628 static int wpa_supplicant_pktcnt_poll(struct wpa_supplicant *wpa_s, char *buf,
8634 	ret = wpa_drv_pktcnt_poll(wpa_s, &sta);
8647 static int wpa_supplicant_driver_cmd(struct wpa_supplicant *wpa_s, char *cmd,
8652 	ret = wpa_drv_driver_cmd(wpa_s, cmd, buf, buflen);
8655 			struct p2p_data *p2p = wpa_s->global->p2p;
8673 static int wpa_supplicant_vendor_cmd(struct wpa_supplicant *wpa_s, char *cmd,
8727 	ret = wpa_drv_vendor_cmd(wpa_s, vendor_id, subcmd, data, data_len,
8741 static void wpa_supplicant_ctrl_iface_flush(struct wpa_supplicant *wpa_s)
8744 	struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s ?
8745 		wpa_s->global->p2p_init_wpa_s : wpa_s;
8748 	wpa_dbg(wpa_s, MSG_DEBUG, "Flush all wpa_supplicant state");
8750 	if (wpas_abort_ongoing_scan(wpa_s) == 0)
8751 		wpa_s->ignore_post_flush_scan_res = 1;
8753 	if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
8758 		wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
8785 	wpa_s->wps_fragment_size = 0;
8786 	wpas_wps_cancel(wpa_s);
8787 	wps_registrar_flush(wpa_s->wps->registrar);
8789 	wpa_s->after_wps = 0;
8790 	wpa_s->known_wps_freq = 0;
8793 	wpas_dpp_deinit(wpa_s);
8794 	wpa_s->dpp_init_max_tries = 0;
8795 	wpa_s->dpp_init_retry_time = 0;
8796 	wpa_s->dpp_resp_wait_time = 0;
8797 	wpa_s->dpp_resp_max_tries = 0;
8798 	wpa_s->dpp_resp_retry_time = 0;
8800 	wpas_dpp_chirp_stop(wpa_s);
8801 	wpa_s->dpp_pfs_fallback = 0;
8810 			info = &wpa_s->dpp_pb[i];
8836 	wpa_drv_tdls_oper(wpa_s, TDLS_ENABLE, NULL);
8837 	wpa_tdls_enable(wpa_s->wpa, 1);
8840 	eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL);
8841 	wpa_supplicant_stop_countermeasures(wpa_s, NULL);
8842 	wpa_s->last_michael_mic_error.sec = 0;
8844 	wpa_s->no_keep_alive = 0;
8845 	wpa_s->own_disconnect_req = 0;
8846 	wpa_s->own_reconnect_req = 0;
8847 	wpa_s->deny_ptk0_rekey = 0;
8849 	os_free(wpa_s->disallow_aps_bssid);
8850 	wpa_s->disallow_aps_bssid = NULL;
8851 	wpa_s->disallow_aps_bssid_count = 0;
8852 	os_free(wpa_s->disallow_aps_ssid);
8853 	wpa_s->disallow_aps_ssid = NULL;
8854 	wpa_s->disallow_aps_ssid_count = 0;
8856 	wpa_s->set_sta_uapsd = 0;
8857 	wpa_s->sta_uapsd = 0;
8859 	wpa_s->consecutive_conn_failures = 0;
8861 	wpa_drv_radio_disable(wpa_s, 0);
8862 	wpa_bssid_ignore_clear(wpa_s);
8863 	wpa_supplicant_ctrl_iface_remove_network(wpa_s, "all");
8864 	wpa_supplicant_ctrl_iface_remove_cred(wpa_s, "all");
8865 	wpa_config_flush_blobs(wpa_s->conf);
8866 	wpa_s->conf->auto_interworking = 0;
8867 	wpa_s->conf->okc = 0;
8869 	ptksa_cache_flush(wpa_s->ptksa, NULL, WPA_CIPHER_NONE);
8870 	wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
8871 	rsn_preauth_deinit(wpa_s->wpa);
8873 	wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME, 43200);
8874 	wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD, 70);
8875 	wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, 60);
8876 	eapol_sm_notify_logoff(wpa_s->eapol, false);
8878 	radio_remove_works(wpa_s, NULL, 1);
8879 	wpa_s->ext_work_in_progress = 0;
8881 	wpa_s->next_ssid = NULL;
8883 	wnm_btm_reset(wpa_s);
8887 	hs20_cancel_fetch_osu(wpa_s);
8888 	hs20_del_icon(wpa_s, NULL, NULL);
8892 	wpa_s->ext_mgmt_frame_handling = 0;
8893 	wpa_s->ext_eapol_frame_io = 0;
8895 	wpa_s->extra_roc_dur = 0;
8896 	wpa_s->test_failure = WPAS_TEST_FAILURE_NONE;
8897 	wpa_s->p2p_go_csa_on_inv = 0;
8898 	wpa_s->ignore_auth_resp = 0;
8899 	wpa_s->ignore_assoc_disallow = 0;
8900 	wpa_s->disable_sa_query = 0;
8901 	wpa_s->testing_resend_assoc = 0;
8902 	wpa_s->ignore_sae_h2e_only = 0;
8903 	wpa_s->ft_rsnxe_used = 0;
8904 	wpa_s->reject_btm_req_reason = 0;
8905 	wpa_sm_set_test_assoc_ie(wpa_s->wpa, NULL);
8906 	wpa_sm_set_test_eapol_m2_elems(wpa_s->wpa, NULL);
8907 	wpa_sm_set_test_eapol_m4_elems(wpa_s->wpa, NULL);
8908 	wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_ENCRYPT_EAPOL_M2, 0);
8909 	wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_ENCRYPT_EAPOL_M4, 0);
8910 	os_free(wpa_s->get_pref_freq_list_override);
8911 	wpa_s->get_pref_freq_list_override = NULL;
8912 	wpabuf_free(wpa_s->sae_commit_override);
8913 	wpa_s->sae_commit_override = NULL;
8914 	os_free(wpa_s->extra_sae_rejected_groups);
8915 	wpa_s->extra_sae_rejected_groups = NULL;
8916 	wpabuf_free(wpa_s->rsne_override_eapol);
8917 	wpa_s->rsne_override_eapol = NULL;
8918 	wpabuf_free(wpa_s->rsnxe_override_assoc);
8919 	wpa_s->rsnxe_override_assoc = NULL;
8920 	wpabuf_free(wpa_s->rsnxe_override_eapol);
8921 	wpa_s->rsnxe_override_eapol = NULL;
8922 	wpas_clear_driver_signal_override(wpa_s);
8924 	wpa_s->disable_scs_support = 0;
8925 	wpa_s->disable_mscs_support = 0;
8926 	wpa_s->enable_dscp_policy_capa = 0;
8928 	wpa_s->oci_freq_override_eapol = 0;
8929 	wpa_s->oci_freq_override_saquery_req = 0;
8930 	wpa_s->oci_freq_override_saquery_resp = 0;
8931 	wpa_s->oci_freq_override_eapol_g2 = 0;
8932 	wpa_s->oci_freq_override_ft_assoc = 0;
8933 	wpa_s->oci_freq_override_fils_assoc = 0;
8934 	wpa_s->oci_freq_override_wnm_sleep = 0;
8935 	wpa_s->disable_eapol_g2_tx = 0;
8936 	wpa_s->test_assoc_comeback_type = -1;
8938 	os_free(wpa_s->dpp_config_obj_override);
8939 	wpa_s->dpp_config_obj_override = NULL;
8940 	os_free(wpa_s->dpp_discovery_override);
8941 	wpa_s->dpp_discovery_override = NULL;
8942 	os_free(wpa_s->dpp_groups_override);
8943 	wpa_s->dpp_groups_override = NULL;
8944 	wpa_s->dpp_ignore_netaccesskey_mismatch = 0;
8945 	wpa_s->dpp_discard_public_action = 0;
8950 	wpa_s->disconnected = 0;
8951 	os_free(wpa_s->next_scan_freqs);
8952 	wpa_s->next_scan_freqs = NULL;
8953 	os_memset(wpa_s->next_scan_bssid, 0, ETH_ALEN);
8954 	wpa_s->next_scan_bssid_wildcard_ssid = 0;
8955 	os_free(wpa_s->select_network_scan_freqs);
8956 	wpa_s->select_network_scan_freqs = NULL;
8958 	os_memset(&wpa_s->robust_av, 0, sizeof(struct robust_av_data));
8961 	wpa_bss_flush(wpa_s);
8962 	if (!dl_list_empty(&wpa_s->bss)) {
8966 			   dl_list_len(&wpa_s->bss), wpa_s->current_bss,
8967 			   MAC2STR(wpa_s->bssid),
8968 			   MAC2STR(wpa_s->pending_bssid));
8971 	eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
8972 	wpa_s->wnmsleep_used = 0;
8975 	wpa_s->sme.last_unprot_disconnect.sec = 0;
8976 	wpa_s->sme.auth_alg = 0;
8979 	wpabuf_free(wpa_s->ric_ies);
8980 	wpa_s->ric_ies = NULL;
8982 	wpa_supplicant_update_channel_list(wpa_s, NULL);
8984 	free_bss_tmp_disallowed(wpa_s);
8987 	os_memset(&wpa_s->robust_av, 0, sizeof(struct robust_av_data));
8991 	wpas_pasn_auth_stop(wpa_s);
8994 	if (wpa_s->mac_addr_changed && wpa_s->conf->mac_addr == 0)
8995 		wpas_restore_permanent_mac_addr(wpa_s);
8997 	wpa_s->conf->ignore_old_scan_res = 0;
9000 	wpas_nan_usd_flush(wpa_s);
9005 static int wpas_ctrl_radio_work_show(struct wpa_supplicant *wpa_s,
9017 	dl_list_for_each(work, &wpa_s->radio->work, struct wpa_radio_work, list)
9023 				  work->type, work->wpa_s->ifname, work->freq,
9039 	wpa_dbg(work->wpa_s, MSG_DEBUG,
9042 	wpa_msg(work->wpa_s, MSG_INFO, EXT_RADIO_WORK_TIMEOUT "%u", ework->id);
9043 	work->wpa_s->ext_work_in_progress = 0;
9069 	wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting external radio work %u (%s)",
9071 	wpa_msg(work->wpa_s, MSG_INFO, EXT_RADIO_WORK_START "%u", ework->id);
9072 	work->wpa_s->ext_work_in_progress = 1;
9080 static int wpas_ctrl_radio_work_add(struct wpa_supplicant *wpa_s, char *cmd,
9116 	wpa_s->ext_work_id++;
9117 	if (wpa_s->ext_work_id == 0)
9118 		wpa_s->ext_work_id++;
9119 	ework->id = wpa_s->ext_work_id;
9121 	if (radio_add_work(wpa_s, freq, ework->type, 0, wpas_ctrl_radio_work_cb,
9134 static int wpas_ctrl_radio_work_done(struct wpa_supplicant *wpa_s, char *cmd)
9139 	dl_list_for_each(work, &wpa_s->radio->work, struct wpa_radio_work, list)
9148 		wpa_dbg(wpa_s, MSG_DEBUG,
9152 		wpa_s->ext_work_in_progress = 0;
9162 static int wpas_ctrl_radio_work(struct wpa_supplicant *wpa_s, char *cmd,
9166 		return wpas_ctrl_radio_work_show(wpa_s, buf, buflen);
9168 		return wpas_ctrl_radio_work_add(wpa_s, cmd + 4, buf, buflen);
9170 		return wpas_ctrl_radio_work_done(wpa_s, cmd + 4);
9175 void wpas_ctrl_radio_work_flush(struct wpa_supplicant *wpa_s)
9179 	if (!wpa_s || !wpa_s->radio)
9182 	dl_list_for_each_safe(work, tmp, &wpa_s->radio->work,
9189 		wpa_dbg(wpa_s, MSG_DEBUG,
9204 	struct wpa_supplicant *wpa_s = eloop_ctx;
9205 	eapol_sm_notify_ctrl_response(wpa_s->eapol);
9209 static int scan_id_list_parse(struct wpa_supplicant *wpa_s, const char *value,
9229 static void wpas_ctrl_scan(struct wpa_supplicant *wpa_s, char *params,
9240 	void (*scan_res_handler)(struct wpa_supplicant *wpa_s,
9246 	if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
9251 	if (radio_work_pending(wpa_s, "scan")) {
9259 	if (wpa_s->fetch_anqp_in_progress || wpa_s->network_select) {
9273 			manual_scan_freqs = freq_range_to_channel_list(wpa_s,
9294 		if (pos && scan_id_list_parse(wpa_s, pos + 8, &scan_id_count,
9310 			os_memcpy(wpa_s->next_scan_bssid, bssid, ETH_ALEN);
9312 			wpa_s->next_scan_bssid_wildcard_ssid =
9366 	wpa_s->num_ssids_from_scan_req = ssid_count;
9367 	os_free(wpa_s->ssids_from_scan_req);
9369 		wpa_s->ssids_from_scan_req = ssid;
9372 		wpa_s->ssids_from_scan_req = NULL;
9377 	else if (wpa_s->scan_res_handler == scan_only_handler)
9380 		scan_res_handler = wpa_s->scan_res_handler;
9382 	if (!wpa_s->sched_scanning && !wpa_s->scanning &&
9383 	    ((wpa_s->wpa_state <= WPA_SCANNING) ||
9384 	     (wpa_s->wpa_state == WPA_COMPLETED))) {
9385 		wpa_s->manual_scan_passive = manual_scan_passive;
9386 		wpa_s->manual_scan_use_id = manual_scan_use_id;
9387 		wpa_s->manual_scan_only_new = manual_scan_only_new;
9388 		wpa_s->scan_id_count = scan_id_count;
9389 		wpa_s->manual_non_coloc_6ghz = manual_non_coloc_6ghz;
9390 		os_memcpy(wpa_s->scan_id, scan_id, scan_id_count * sizeof(int));
9391 		wpa_s->scan_res_handler = scan_res_handler;
9392 		os_free(wpa_s->manual_scan_freqs);
9393 		wpa_s->manual_scan_freqs = manual_scan_freqs;
9396 		wpa_s->normal_scans = 0;
9397 		wpa_s->scan_req = MANUAL_SCAN_REQ;
9398 		wpa_s->after_wps = 0;
9399 		wpa_s->known_wps_freq = 0;
9400 		wpa_supplicant_req_scan(wpa_s, 0, 0);
9401 		if (wpa_s->manual_scan_use_id) {
9402 			wpa_s->manual_scan_id++;
9403 			wpa_dbg(wpa_s, MSG_DEBUG, "Assigned scan id %u",
9404 				wpa_s->manual_scan_id);
9406 						 wpa_s->manual_scan_id);
9408 	} else if (wpa_s->sched_scanning) {
9409 		wpa_s->manual_scan_passive = manual_scan_passive;
9410 		wpa_s->manual_scan_use_id = manual_scan_use_id;
9411 		wpa_s->manual_scan_only_new = manual_scan_only_new;
9412 		wpa_s->scan_id_count = scan_id_count;
9413 		wpa_s->manual_non_coloc_6ghz = manual_non_coloc_6ghz;
9414 		os_memcpy(wpa_s->scan_id, scan_id, scan_id_count * sizeof(int));
9415 		wpa_s->scan_res_handler = scan_res_handler;
9416 		os_free(wpa_s->manual_scan_freqs);
9417 		wpa_s->manual_scan_freqs = manual_scan_freqs;
9421 		wpa_supplicant_cancel_sched_scan(wpa_s);
9422 		wpa_s->scan_req = MANUAL_SCAN_REQ;
9423 		wpa_supplicant_req_scan(wpa_s, 0, 0);
9424 		if (wpa_s->manual_scan_use_id) {
9425 			wpa_s->manual_scan_id++;
9427 						 wpa_s->manual_scan_id);
9428 			wpa_dbg(wpa_s, MSG_DEBUG, "Assigned scan id %u",
9429 				wpa_s->manual_scan_id);
9444 static void wpas_ctrl_iface_mgmt_tx_cb(struct wpa_supplicant *wpa_s,
9451 	wpa_msg(wpa_s, MSG_INFO, "MGMT-TX-STATUS freq=%u dst=" MACSTR
9460 static int wpas_ctrl_iface_mgmt_tx(struct wpa_supplicant *wpa_s, char *cmd)
9522 	res = offchannel_send_action(wpa_s, freq, da, wpa_s->own_addr, bssid,
9530 static void wpas_ctrl_iface_mgmt_tx_done(struct wpa_supplicant *wpa_s)
9533 	offchannel_send_action_done(wpa_s);
9537 static int wpas_ctrl_iface_mgmt_rx_process(struct wpa_supplicant *wpa_s,
9546 	if (!wpa_s->ext_mgmt_frame_handling)
9597 	wpa_s->ext_mgmt_frame_handling = 0;
9598 	wpa_supplicant_event(wpa_s, EVENT_RX_MGMT, &event);
9599 	wpa_s->ext_mgmt_frame_handling = 1;
9607 static int wpas_ctrl_iface_driver_scan_res(struct wpa_supplicant *wpa_s,
9619 		wpa_bss_update_start(wpa_s);
9624 		wpa_bss_update_end(wpa_s, NULL, 1);
9716 	wpa_bss_update_scan_res(wpa_s, res, &now);
9725 static int wpas_ctrl_iface_driver_event_assoc(struct wpa_supplicant *wpa_s,
9836 	wpa_supplicant_event(wpa_s, EVENT_ASSOC, &event);
9851 static int wpas_ctrl_iface_driver_event(struct wpa_supplicant *wpa_s, char *cmd)
9859 	wpa_dbg(wpa_s, MSG_DEBUG, "Testing - external driver event: %s", cmd);
9878 		wpa_supplicant_event(wpa_s, ev, &event);
9882 		return wpas_ctrl_iface_driver_scan_res(wpa_s, param);
9884 		return wpas_ctrl_iface_driver_event_assoc(wpa_s, param);
9886 		wpa_dbg(wpa_s, MSG_DEBUG, "Testing - unknown driver event: %s",
9891 	wpa_supplicant_event(wpa_s, ev, &event);
9897 static int wpas_ctrl_iface_eapol_rx(struct wpa_supplicant *wpa_s, char *cmd)
9928 	wpa_supplicant_rx_eapol(wpa_s, src, buf, len, FRAME_ENCRYPTION_UNKNOWN);
9935 static int wpas_ctrl_iface_eapol_tx(struct wpa_supplicant *wpa_s, char *cmd)
9964 	prev = wpa_s->ext_eapol_frame_io;
9965 	wpa_s->ext_eapol_frame_io = 0;
9966 	ret = wpa_ether_send(wpa_s, dst, ETH_P_EAPOL, buf, len);
9967 	wpa_s->ext_eapol_frame_io = prev;
9996 	struct wpa_supplicant *wpa_s = ctx;
10031 	wpa_msg(wpa_s, MSG_INFO, "DATA-TEST-RX " MACSTR " " MACSTR "%s",
10036 static int wpas_ctrl_iface_data_test_config(struct wpa_supplicant *wpa_s,
10044 		if (wpa_s->l2_test) {
10045 			l2_packet_deinit(wpa_s->l2_test);
10046 			wpa_s->l2_test = NULL;
10047 			wpa_dbg(wpa_s, MSG_DEBUG, "test data: Disabled");
10052 	if (wpa_s->l2_test)
10059 		ifname = wpa_s->ifname;
10061 	wpa_s->l2_test = l2_packet_init(ifname, wpa_s->own_addr,
10063 					wpa_s, 1);
10064 	if (wpa_s->l2_test == NULL)
10067 	wpa_dbg(wpa_s, MSG_DEBUG, "test data: Enabled");
10073 static int wpas_ctrl_iface_data_test_tx(struct wpa_supplicant *wpa_s, char *cmd)
10087 	if (wpa_s->l2_test == NULL)
10136 	if (l2_packet_send(wpa_s->l2_test, dst, ETHERTYPE_IP, &buf[2],
10140 	wpa_dbg(wpa_s, MSG_DEBUG, "test data: TX dst=" MACSTR " src=" MACSTR
10147 static int wpas_ctrl_iface_data_test_frame(struct wpa_supplicant *wpa_s,
10172 	l2 = l2_packet_init(wpa_s->ifname, wpa_s->own_addr, ethertype,
10173 			    wpas_data_test_rx, wpa_s, 1);
10178 	wpa_dbg(wpa_s, MSG_DEBUG, "test data: TX frame res=%d", res);
10190 	struct wpa_supplicant *wpa_s = eloop_ctx;
10196 		wpa_msg_ctrl(wpa_s, MSG_INFO, "TEST-EVENT-MESSAGE %d/%d",
10202 static int wpas_ctrl_event_test(struct wpa_supplicant *wpa_s, const char *cmd)
10210 	return eloop_register_timeout(0, 0, wpas_ctrl_event_test_cb, wpa_s,
10243 static int wpas_ctrl_test_assoc_ie(struct wpa_supplicant *wpa_s,
10250 	wpa_sm_set_test_assoc_ie(wpa_s->wpa, buf);
10255 static int wpas_ctrl_test_eapol_m2_elems(struct wpa_supplicant *wpa_s,
10262 	wpa_sm_set_test_eapol_m2_elems(wpa_s->wpa, buf);
10267 static int wpas_ctrl_test_eapol_m4_elems(struct wpa_supplicant *wpa_s,
10274 	wpa_sm_set_test_eapol_m4_elems(wpa_s->wpa, buf);
10279 static int wpas_ctrl_reset_pn(struct wpa_supplicant *wpa_s)
10283 	if (wpa_s->last_tk_alg == WPA_ALG_NONE)
10291 	if (wpa_drv_set_key(wpa_s, -1, wpa_s->last_tk_alg, wpa_s->last_tk_addr,
10292 			    wpa_s->last_tk_key_idx, 1, zero, 6,
10293 			    zero, wpa_s->last_tk_len,
10298 	return wpa_drv_set_key(wpa_s, -1, wpa_s->last_tk_alg,
10299 			       wpa_s->last_tk_addr,
10300 			       wpa_s->last_tk_key_idx, 1, zero, 6,
10301 			       wpa_s->last_tk, wpa_s->last_tk_len,
10306 static int wpas_ctrl_key_request(struct wpa_supplicant *wpa_s, const char *cmd)
10316 	wpa_sm_key_request(wpa_s->wpa, error, pairwise);
10321 static int wpas_ctrl_resend_assoc(struct wpa_supplicant *wpa_s)
10328 	params.bssid = wpa_s->bssid;
10329 	params.ssid = wpa_s->sme.ssid;
10330 	params.ssid_len = wpa_s->sme.ssid_len;
10331 	params.freq.freq = wpa_s->sme.freq;
10332 	if (wpa_s->last_assoc_req_wpa_ie) {
10333 		params.wpa_ie = wpabuf_head(wpa_s->last_assoc_req_wpa_ie);
10334 		params.wpa_ie_len = wpabuf_len(wpa_s->last_assoc_req_wpa_ie);
10336 	params.pairwise_suite = wpa_s->pairwise_cipher;
10337 	params.group_suite = wpa_s->group_cipher;
10338 	params.mgmt_group_suite = wpa_s->mgmt_group_cipher;
10339 	params.key_mgmt_suite = wpa_s->key_mgmt;
10340 	params.wpa_proto = wpa_s->wpa_proto;
10341 	params.mgmt_frame_protection = wpa_s->sme.mfp;
10342 	params.rrm_used = wpa_s->rrm.rrm_used;
10343 	if (wpa_s->sme.prev_bssid_set)
10344 		params.prev_bssid = wpa_s->sme.prev_bssid;
10346 	ret = wpa_drv_associate(wpa_s, &params);
10347 	wpa_s->testing_resend_assoc = 1;
10355 static int wpas_ctrl_iface_send_twt_setup(struct wpa_supplicant *wpa_s,
10433 	return wpas_twt_send_setup(wpa_s, dtok, exponent, mantissa, min_twt,
10440 static int wpas_ctrl_iface_send_twt_teardown(struct wpa_supplicant *wpa_s,
10450 	return wpas_twt_send_teardown(wpa_s, flags);
10456 static int wpas_ctrl_vendor_elem_add(struct wpa_supplicant *wpa_s, char *cmd)
10467 	wpa_s = wpas_vendor_elem(wpa_s, frame);
10496 	if (wpa_s->vendor_elem[frame] == NULL) {
10497 		wpa_s->vendor_elem[frame] = buf;
10501 	if (wpabuf_resize(&wpa_s->vendor_elem[frame], len) < 0) {
10506 	wpabuf_put_buf(wpa_s->vendor_elem[frame], buf);
10510 	wpas_vendor_elem_update(wpa_s);
10514 		wpa_supplicant_set_default_scan_ies(wpa_s);
10520 static int wpas_ctrl_vendor_elem_get(struct wpa_supplicant *wpa_s, char *cmd,
10527 	wpa_s = wpas_vendor_elem(wpa_s, frame);
10529 	if (wpa_s->vendor_elem[frame] == NULL)
10533 				wpabuf_head_u8(wpa_s->vendor_elem[frame]),
10534 				wpabuf_len(wpa_s->vendor_elem[frame]));
10538 static int wpas_ctrl_vendor_elem_remove(struct wpa_supplicant *wpa_s, char *cmd)
10550 	wpa_s = wpas_vendor_elem(wpa_s, frame);
10558 		wpabuf_free(wpa_s->vendor_elem[frame]);
10559 		wpa_s->vendor_elem[frame] = NULL;
10560 		wpas_vendor_elem_update(wpa_s);
10564 	if (wpa_s->vendor_elem[frame] == NULL)
10588 	res = wpas_vendor_elem_remove(wpa_s, frame, buf, len);
10598 	struct wpa_supplicant *wpa_s = ctx;
10614 		wpa_msg_ctrl(wpa_s, MSG_INFO, RRM_EVENT_NEIGHBOR_REP_FAILED);
10630 			wpa_dbg(wpa_s, MSG_DEBUG,
10637 			wpa_dbg(wpa_s, MSG_DEBUG,
10681 		wpa_msg(wpa_s, MSG_INFO, RRM_EVENT_NEIGHBOR_REP_RXED
10699 static int wpas_ctrl_iface_send_neighbor_rep(struct wpa_supplicant *wpa_s,
10709 			wpa_msg(wpa_s, MSG_INFO,
10732 	ret = wpas_rrm_send_neighbor_rep_request(wpa_s, ssid_p, lci, civic,
10734 						 wpa_s);
10742 static int wpas_ctrl_iface_erp_flush(struct wpa_supplicant *wpa_s)
10744 	eapol_sm_erp_flush(wpa_s->eapol);
10749 static int wpas_ctrl_iface_mac_rand_scan(struct wpa_supplicant *wpa_s,
10765 			type = wpa_s->mac_addr_rand_supported;
10804 		return wpas_disable_mac_addr_randomization(wpa_s, type);
10806 	return wpas_enable_mac_addr_randomization(wpa_s, type, addr, mask);
10810 static int wpas_ctrl_iface_pmksa(struct wpa_supplicant *wpa_s,
10815 	reply_len = wpa_sm_pmksa_cache_list(wpa_s->wpa, buf, buflen);
10817 	reply_len += wpas_ap_pmksa_cache_list(wpa_s, &buf[reply_len],
10824 static void wpas_ctrl_iface_pmksa_flush(struct wpa_supplicant *wpa_s)
10826 	ptksa_cache_flush(wpa_s->ptksa, NULL, WPA_CIPHER_NONE);
10827 	wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL);
10829 	wpas_ap_pmksa_cache_flush(wpa_s);
10836 static int wpas_ctrl_iface_pmksa_get(struct wpa_supplicant *wpa_s,
10845 	ssid = wpa_config_get_network(wpa_s->conf, atoi(cmd));
10861 	for (entry = wpa_sm_pmksa_cache_head(wpa_s->wpa); entry;
10914 static int wpas_ctrl_iface_pmksa_add(struct wpa_supplicant *wpa_s,
10931 	ssid = wpa_config_get_network(wpa_s->conf, atoi(cmd));
10998 	os_memcpy(entry->spa, wpa_s->own_addr, ETH_ALEN);
11002 	wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry);
11013 static int wpas_ctrl_iface_mesh_pmksa_get(struct wpa_supplicant *wpa_s,
11019 	if (!wpa_s->ifmsh)
11023 		return wpas_ap_pmksa_cache_list_mesh(wpa_s, NULL, buf, buflen);
11028 	return wpas_ap_pmksa_cache_list_mesh(wpa_s, spa, buf, buflen);
11032 static int wpas_ctrl_iface_mesh_pmksa_add(struct wpa_supplicant *wpa_s,
11037 	 * stored before wpa_s->ifmsh creation to suppress commit message
11040 	return wpas_ap_pmksa_cache_add_external(wpa_s, cmd);
11048 static int wpas_ctrl_iface_fils_hlp_req_add(struct wpa_supplicant *wpa_s,
11071 	dl_list_add_tail(&wpa_s->fils_hlp_req, &req->list);
11095 static int wpas_ctrl_iface_configure_mscs(struct wpa_supplicant *wpa_s,
11100 	struct robust_av_data *robust_av = &wpa_s->robust_av;
11114 		return wpas_send_mscs_req(wpa_s);
11161 	return wpas_send_mscs_req(wpa_s);
11167 static int wpas_ctrl_iface_pasn_start(struct wpa_supplicant *wpa_s, char *cmd)
11243 	ret = wpas_pasn_auth_start(wpa_s, wpa_s->own_addr, bssid, akmp, cipher,
11251 static int wpas_ctrl_iface_pasn_deauthenticate(struct wpa_supplicant *wpa_s,
11262 	return wpas_pasn_deauthenticate(wpa_s, wpa_s->own_addr, bssid);
11267 static int wpas_ctrl_iface_pasn_driver(struct wpa_supplicant *wpa_s,
11294 		os_memcpy(peer->own_addr, wpa_s->own_addr, ETH_ALEN);
11304 	wpa_supplicant_event(wpa_s, EVENT_PASN_AUTH, &event);
11595 static int wpas_ctrl_iface_configure_scs(struct wpa_supplicant *wpa_s,
11599 	struct scs_robust_av_data *scs_data = &wpa_s->scs_robust_av_req;
11604 	if (wpa_s->ongoing_scs_req) {
11660 		dl_list_for_each(active_scs_desc, &wpa_s->active_scs_ids,
11908 	return wpas_send_scs_req(wpa_s);
11917 static int wpas_ctrl_iface_send_dscp_resp(struct wpa_supplicant *wpa_s,
11973 	ret = wpas_send_dscp_response(wpa_s, &resp_data);
11982 static int wpas_ctrl_iface_send_dscp_query(struct wpa_supplicant *wpa_s,
11998 		return wpas_send_dscp_query(wpa_s, NULL, 0);
12007 	return wpas_send_dscp_query(wpa_s, pos + 12, os_strlen(pos + 12));
12013 static int wpas_ctrl_iface_mlo_signal_poll(struct wpa_supplicant *wpa_s,
12020 	if (!wpa_s->valid_links)
12023 	ret = wpa_drv_mlo_signal_poll(wpa_s, &mlo_si);
12090 static int wpas_ctrl_iface_mlo_status(struct wpa_supplicant *wpa_s,
12096 	if (!wpa_s->valid_links)
12102 	for_each_link(wpa_s->valid_links, i) {
12106 				  i, wpa_s->links[i].freq,
12107 				  MAC2STR(wpa_s->links[i].bssid),
12108 				  MAC2STR(wpa_s->links[i].addr));
12119 static int wpas_ctrl_ml_probe(struct wpa_supplicant *wpa_s, char *cmd)
12146 	bss = wpa_bss_get_bssid(wpa_s, bssid);
12153 	if (wpa_s->sched_scanning || wpa_s->scanning ||
12154 	    (wpa_s->wpa_state > WPA_SCANNING &&
12155 	     wpa_s->wpa_state != WPA_COMPLETED)) {
12168 	wpa_s->manual_scan_passive = 0;
12169 	wpa_s->manual_scan_use_id = 0;
12170 	wpa_s->manual_scan_only_new = 0;
12171 	wpa_s->scan_id_count = 0;
12172 	wpa_s->scan_res_handler = scan_only_handler;
12173 	os_free(wpa_s->manual_scan_freqs);
12174 	wpa_s->manual_scan_freqs = freqs;
12176 	os_memcpy(wpa_s->ml_probe_bssid, bssid, ETH_ALEN);
12177 	wpa_s->ml_probe_mld_id = mld_id;
12179 		wpa_s->ml_probe_links = BIT(link_id);
12181 	wpa_s->normal_scans = 0;
12182 	wpa_s->scan_req = MANUAL_SCAN_REQ;
12183 	wpa_s->after_wps = 0;
12184 	wpa_s->known_wps_freq = 0;
12185 	wpa_supplicant_req_scan(wpa_s, 0, 0);
12194 static int wpas_ctrl_nan_publish(struct wpa_supplicant *wpa_s, char *cmd,
12235 				freq_list = wpas_nan_usd_all_freqs(wpa_s);
12285 	publish_id = wpas_nan_usd_publish(wpa_s, service_name, srv_proto_type,
12296 static int wpas_ctrl_nan_cancel_publish(struct wpa_supplicant *wpa_s,
12317 	wpas_nan_usd_cancel_publish(wpa_s, publish_id);
12322 static int wpas_ctrl_nan_update_publish(struct wpa_supplicant *wpa_s,
12353 	ret = wpas_nan_usd_update_publish(wpa_s, publish_id, ssi);
12360 static int wpas_ctrl_nan_subscribe(struct wpa_supplicant *wpa_s, char *cmd,
12415 	subscribe_id = wpas_nan_usd_subscribe(wpa_s, service_name,
12426 static int wpas_ctrl_nan_cancel_subscribe(struct wpa_supplicant *wpa_s,
12447 	wpas_nan_usd_cancel_subscribe(wpa_s, subscribe_id);
12452 static int wpas_ctrl_nan_transmit(struct wpa_supplicant *wpa_s, char *cmd)
12503 	ret = wpas_nan_usd_transmit(wpa_s, handle, ssi, NULL, peer_addr,
12513 char * wpa_supplicant_ctrl_iface_process(struct wpa_supplicant *wpa_s,
12525 			wpa_dbg(wpa_s, MSG_DEBUG,
12528 			wpa_dbg(wpa_s, MSG_DEBUG,
12541 		wpa_dbg(wpa_s, level, "Control interface command '%s'", buf);
12557 		reply_len = os_strlen(wpa_s->ifname);
12558 		os_memcpy(reply, wpa_s->ifname, reply_len);
12565 		reply_len = wpa_sm_get_mib(wpa_s->wpa, reply, reply_size);
12567 			reply_len += eapol_sm_get_mib(wpa_s->eapol,
12572 				wpa_s->kay, reply + reply_len,
12578 			wpa_s, buf + 6, reply, reply_size);
12580 		reply_len = wpas_ctrl_iface_pmksa(wpa_s, reply, reply_size);
12582 		wpas_ctrl_iface_pmksa_flush(wpa_s);
12585 		reply_len = wpas_ctrl_iface_pmksa_get(wpa_s, buf + 10,
12588 		if (wpas_ctrl_iface_pmksa_add(wpa_s, buf + 10) < 0)
12592 		reply_len = wpas_ctrl_iface_mesh_pmksa_get(wpa_s, buf + 15,
12595 		if (wpas_ctrl_iface_mesh_pmksa_add(wpa_s, buf + 15) < 0)
12600 		if (wpa_supplicant_ctrl_iface_set(wpa_s, buf + 4))
12603 		reply_len = wpa_config_dump_values(wpa_s->conf,
12606 		reply_len = wpa_supplicant_ctrl_iface_get(wpa_s, buf + 4,
12609 		eapol_sm_notify_logoff(wpa_s->eapol, false);
12611 		eapol_sm_notify_logoff(wpa_s->eapol, true);
12613 		if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
12616 			wpas_request_connection(wpa_s);
12618 		if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED ||
12619 		    !wpa_s->current_ssid)
12622 			wpa_s->reattach = 1;
12623 			wpas_request_connection(wpa_s);
12626 		if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
12628 		else if (wpa_s->disconnected)
12629 			wpas_request_connection(wpa_s);
12632 		if (wpa_supplicant_ctrl_iface_preauth(wpa_s, buf + 8))
12637 		if (wpa_supplicant_ctrl_iface_ft_ds(wpa_s, buf + 6))
12642 		int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, NULL);
12649 		int res = wpa_supplicant_ctrl_iface_wps_pbc(wpa_s, buf + 8);
12656 		reply_len = wpa_supplicant_ctrl_iface_wps_pin(wpa_s, buf + 8,
12661 			wpa_s, buf + 14, reply, reply_size);
12663 		if (wpas_wps_cancel(wpa_s))
12667 		if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, NULL))
12670 		if (wpa_supplicant_ctrl_iface_wps_nfc(wpa_s, buf + 8))
12674 			wpa_s, buf + 21, reply, reply_size);
12677 			wpa_s, buf + 14, reply, reply_size);
12679 		if (wpa_supplicant_ctrl_iface_wps_nfc_tag_read(wpa_s,
12684 			wpa_s, buf + 21, reply, reply_size);
12687 			wpa_s, buf + 21, reply, reply_size);
12689 		if (wpas_ctrl_nfc_report_handover(wpa_s, buf + 20))
12693 		if (wpa_supplicant_ctrl_iface_wps_reg(wpa_s, buf + 8))
12698 			wpa_s, buf + 11, reply, reply_size);
12702 		if (wpas_wps_er_start(wpa_s, NULL))
12705 		if (wpas_wps_er_start(wpa_s, buf + 13))
12708 		wpas_wps_er_stop(wpa_s);
12710 		if (wpa_supplicant_ctrl_iface_wps_er_pin(wpa_s, buf + 11))
12713 		int ret = wpas_wps_er_pbc(wpa_s, buf + 11);
12726 		if (wpa_supplicant_ctrl_iface_wps_er_learn(wpa_s, buf + 13))
12729 		if (wpa_supplicant_ctrl_iface_wps_er_set_config(wpa_s,
12733 		if (wpa_supplicant_ctrl_iface_wps_er_config(wpa_s, buf + 14))
12738 			wpa_s, buf + 24, reply, reply_size);
12744 		if (wpa_supplicant_ctrl_iface_ibss_rsn(wpa_s, buf + 9))
12750 			wpa_s, buf + 19, reply, reply_size);
12753 			wpa_s, "", reply, reply_size);
12755 		if (wpa_supplicant_ctrl_iface_mesh_group_add(wpa_s, buf + 15))
12758 		if (wpa_supplicant_ctrl_iface_mesh_group_remove(wpa_s,
12762 		if (wpa_supplicant_ctrl_iface_mesh_peer_remove(wpa_s, buf + 17))
12765 		if (wpa_supplicant_ctrl_iface_mesh_peer_add(wpa_s, buf + 14))
12768 		if (wpa_supplicant_ctrl_iface_mesh_link_probe(wpa_s, buf + 16))
12773 		if (p2p_ctrl_find(wpa_s, buf + 8))
12776 		if (p2p_ctrl_find(wpa_s, ""))
12779 		wpas_p2p_stop_find(wpa_s);
12781 		if (p2p_ctrl_asp_provision(wpa_s, buf + 18))
12784 		if (p2p_ctrl_asp_provision_resp(wpa_s, buf + 23))
12787 		reply_len = p2p_ctrl_connect(wpa_s, buf + 12, reply,
12790 		if (p2p_ctrl_listen(wpa_s, buf + 11))
12793 		if (p2p_ctrl_listen(wpa_s, ""))
12796 		if (wpas_p2p_group_remove(wpa_s, buf + 17))
12799 		if (p2p_ctrl_group_add(wpa_s, ""))
12802 		if (p2p_ctrl_group_add(wpa_s, buf + 14))
12805 		reply_len = p2p_ctrl_group_member(wpa_s, buf + 17, reply,
12808 		if (p2p_ctrl_prov_disc(wpa_s, buf + 14))
12811 		reply_len = p2p_get_passphrase(wpa_s, reply, reply_size);
12813 		reply_len = p2p_ctrl_serv_disc_req(wpa_s, buf + 18, reply,
12816 		if (p2p_ctrl_serv_disc_cancel_req(wpa_s, buf + 25) < 0)
12819 		if (p2p_ctrl_serv_disc_resp(wpa_s, buf + 19) < 0)
12822 		wpas_p2p_sd_service_update(wpa_s);
12824 		if (p2p_ctrl_serv_disc_external(wpa_s, buf + 23) < 0)
12827 		wpas_p2p_service_flush(wpa_s);
12829 		if (p2p_ctrl_service_add(wpa_s, buf + 16) < 0)
12832 		if (p2p_ctrl_service_del(wpa_s, buf + 16) < 0)
12835 		if (p2p_ctrl_service_replace(wpa_s, buf + 16) < 0)
12838 		if (p2p_ctrl_reject(wpa_s, buf + 11) < 0)
12841 		if (p2p_ctrl_invite(wpa_s, buf + 11) < 0)
12844 		reply_len = p2p_ctrl_peer(wpa_s, buf + 9, reply,
12847 		if (p2p_ctrl_set(wpa_s, buf + 8) < 0)
12850 		p2p_ctrl_flush(wpa_s);
12852 		if (wpas_p2p_unauthorize(wpa_s, buf + 16) < 0)
12855 		if (wpas_p2p_cancel(wpa_s))
12858 		if (p2p_ctrl_presence_req(wpa_s, buf + 17) < 0)
12861 		if (p2p_ctrl_presence_req(wpa_s, "") < 0)
12864 		if (p2p_ctrl_ext_listen(wpa_s, buf + 15) < 0)
12867 		if (p2p_ctrl_ext_listen(wpa_s, "") < 0)
12870 		if (p2p_ctrl_remove_client(wpa_s, buf + 18) < 0)
12873 		if (p2p_ctrl_iface_p2p_lo_start(wpa_s, buf + 13))
12876 		if (wpas_p2p_lo_stop(wpa_s))
12881 		if (wifi_display_subelem_set(wpa_s->global, buf + 16) < 0)
12884 		reply_len = wifi_display_subelem_get(wpa_s->global, buf + 16,
12889 		if (interworking_fetch_anqp(wpa_s) < 0)
12892 		interworking_stop_fetch_anqp(wpa_s);
12894 		if (ctrl_interworking_select(wpa_s, NULL) < 0)
12897 		if (ctrl_interworking_select(wpa_s, buf + 20) < 0)
12900 		if (ctrl_interworking_connect(wpa_s, buf + 21, 0) < 0)
12905 		id = ctrl_interworking_connect(wpa_s, buf + 25, 1);
12914 		if (get_anqp(wpa_s, buf + 9) < 0)
12917 		if (gas_request(wpa_s, buf + 12) < 0)
12920 		reply_len = gas_response_get(wpa_s, buf + 17, reply,
12925 		if (get_hs20_anqp(wpa_s, buf + 14) < 0)
12928 		if (hs20_get_nai_home_realm_list(wpa_s, buf + 29) < 0)
12931 		if (hs20_icon_request(wpa_s, buf + 18, 0) < 0)
12934 		if (hs20_icon_request(wpa_s, buf + 14, 1) < 0)
12937 		reply_len = get_hs20_icon(wpa_s, buf + 14, reply, reply_size);
12939 		if (del_hs20_icon(wpa_s, buf + 14) < 0)
12942 		if (hs20_fetch_osu(wpa_s, 0) < 0)
12945 		if (hs20_fetch_osu(wpa_s, 1) < 0)
12948 		hs20_cancel_fetch_osu(wpa_s);
12953 			    wpa_s, buf + os_strlen(WPA_CTRL_RSP)))
12961 					       wpa_s, NULL);
12964 		if (wpa_supplicant_reload_configuration(wpa_s))
12967 		wpa_supplicant_terminate_proc(wpa_s->global);
12969 		if (wpa_supplicant_ctrl_iface_bssid(wpa_s, buf + 6))
12973 			wpa_s, buf + 12, reply, reply_size);
12977 			wpa_s, buf + 9, reply, reply_size);
12980 			wpa_s, buf + 9, reply, reply_size);
12983 			wpa_s, buf + 14, reply, reply_size);
12986 			wpa_s, NULL, reply, reply_size);
12988 		wpas_request_disconnection(wpa_s);
12990 		wpas_ctrl_scan(wpa_s, NULL, reply, reply_size, &reply_len);
12992 		wpas_ctrl_scan(wpa_s, buf + 5, reply, reply_size, &reply_len);
12995 			wpa_s, reply, reply_size);
12997 		if (wpas_abort_ongoing_scan(wpa_s) < 0)
13000 		if (wpa_supplicant_ctrl_iface_select_network(wpa_s, buf + 15))
13003 		if (wpa_supplicant_ctrl_iface_enable_network(wpa_s, buf + 15))
13006 		if (wpa_supplicant_ctrl_iface_disable_network(wpa_s, buf + 16))
13010 			wpa_s, reply, reply_size);
13012 		if (wpa_supplicant_ctrl_iface_remove_network(wpa_s, buf + 15))
13015 		if (wpa_supplicant_ctrl_iface_set_network(wpa_s, buf + 12))
13019 			wpa_s, buf + 12, reply, reply_size);
13021 		if (wpa_supplicant_ctrl_iface_dup_network(wpa_s, buf + 12,
13022 							  wpa_s))
13026 			wpa_s, reply, reply_size);
13029 			wpa_s, reply, reply_size);
13031 		if (wpa_supplicant_ctrl_iface_remove_cred(wpa_s, buf + 12))
13034 		if (wpa_supplicant_ctrl_iface_set_cred(wpa_s, buf + 9))
13037 		reply_len = wpa_supplicant_ctrl_iface_get_cred(wpa_s, buf + 9,
13042 		if (wpa_supplicant_ctrl_iface_save_config(wpa_s))
13047 			wpa_s, buf + 15, reply, reply_size);
13049 		if (wpa_supplicant_ctrl_iface_ap_scan(wpa_s, buf + 8))
13052 		if (wpa_supplicant_ctrl_iface_scan_interval(wpa_s, buf + 14))
13056 			wpa_s->global, reply, reply_size);
13059 			wpa_s->global, buf + 10, reply, reply_size);
13062 			wpa_s, buf + 4, reply, reply_size);
13065 		reply_len = ap_ctrl_iface_sta_first(wpa_s, reply, reply_size);
13067 		reply_len = ap_ctrl_iface_sta(wpa_s, buf + 4, reply,
13070 		reply_len = ap_ctrl_iface_sta_next(wpa_s, buf + 9, reply,
13073 		if (ap_ctrl_iface_sta_deauthenticate(wpa_s, buf + 15))
13076 		if (ap_ctrl_iface_sta_disassociate(wpa_s, buf + 13))
13079 		if (ap_ctrl_iface_chanswitch(wpa_s, buf + 12))
13082 		if (wpas_ap_stop_ap(wpa_s))
13085 		if (wpas_ap_update_beacon(wpa_s))
13089 			if (ap_ctrl_iface_acl_add_mac(wpa_s,
13092 			    ap_ctrl_iface_set_acl(wpa_s))
13095 			if (ap_ctrl_iface_acl_del_mac(wpa_s,
13098 			    ap_ctrl_iface_set_acl(wpa_s) ||
13099 			    ap_ctrl_iface_disassoc_accept_mac(wpa_s))
13103 				wpa_s, DENY_UNLESS_ACCEPTED,
13106 			ap_ctrl_iface_acl_clear_list(wpa_s,
13108 			if (ap_ctrl_iface_set_acl(wpa_s) ||
13109 			    ap_ctrl_iface_disassoc_accept_mac(wpa_s))
13116 			if (ap_ctrl_iface_acl_add_mac(wpa_s,
13119 			    ap_ctrl_iface_set_acl(wpa_s) ||
13120 			    ap_ctrl_iface_disassoc_deny_mac(wpa_s))
13123 			if (ap_ctrl_iface_acl_del_mac(wpa_s,
13126 			    ap_ctrl_iface_set_acl(wpa_s))
13130 				wpa_s, ACCEPT_UNLESS_DENIED, reply, reply_size);
13132 			ap_ctrl_iface_acl_clear_list(wpa_s,
13134 			if (ap_ctrl_iface_set_acl(wpa_s))
13141 		wpas_notify_suspend(wpa_s->global);
13143 		wpas_notify_resume(wpa_s->global);
13146 		wpa_supplicant_ctrl_iface_drop_sa(wpa_s);
13149 		if (wpa_supplicant_ctrl_iface_roam(wpa_s, buf + 5))
13152 		wpa_s->auto_reconnect_disabled = atoi(buf + 16) == 0;
13154 		if (wpa_supplicant_ctrl_iface_bss_expire_age(wpa_s, buf + 15))
13157 		if (wpa_supplicant_ctrl_iface_bss_expire_count(wpa_s,
13161 		wpa_supplicant_ctrl_iface_bss_flush(wpa_s, buf + 10);
13164 		if (wpa_supplicant_ctrl_iface_tdls_discover(wpa_s, buf + 14))
13167 		if (wpa_supplicant_ctrl_iface_tdls_setup(wpa_s, buf + 11))
13170 		if (wpa_supplicant_ctrl_iface_tdls_teardown(wpa_s, buf + 14))
13173 		if (wpa_supplicant_ctrl_iface_tdls_chan_switch(wpa_s,
13177 		if (wpa_supplicant_ctrl_iface_tdls_cancel_chan_switch(wpa_s,
13182 			wpa_s, buf + 17, reply, reply_size);
13186 		reply_len = wpas_wmm_ac_status(wpa_s, reply, reply_size);
13188 		if (wmm_ac_ctrl_addts(wpa_s, buf + 13))
13191 		if (wmm_ac_ctrl_delts(wpa_s, buf + 13))
13195 		reply_len = wpa_supplicant_signal_poll(wpa_s, reply,
13198 		if (wpas_ctrl_iface_signal_monitor(wpa_s, buf + 14))
13201 		reply_len = wpa_supplicant_pktcnt_poll(wpa_s, reply,
13205 		if (wpa_supplicant_ctrl_iface_autoscan(wpa_s, buf + 9))
13209 		reply_len = wpas_ctrl_iface_driver_flags(wpa_s, reply,
13212 		reply_len = wpas_ctrl_iface_driver_flags2(wpa_s, reply,
13216 		reply_len = wpa_supplicant_driver_cmd(wpa_s, buf + 7, reply,
13220 		reply_len = wpa_supplicant_vendor_cmd(wpa_s, buf + 7, reply,
13223 		pmksa_cache_clear_current(wpa_s->wpa);
13224 		eapol_sm_request_reauth(wpa_s->eapol);
13227 		if (wpas_ctrl_iface_wnm_sleep(wpa_s, buf + 10))
13230 		if (wpas_ctrl_iface_wnm_bss_query(wpa_s, buf + 14))
13233 		if (wpas_ctrl_iface_coloc_intf_report(wpa_s, buf + 18))
13238 		if (ap_ctrl_iface_disassoc_imminent(wpa_s, buf + 18))
13241 		if (ap_ctrl_iface_ess_disassoc(wpa_s, buf + 13))
13244 		if (ap_ctrl_iface_bss_tm_req(wpa_s, buf + 11))
13248 		wpa_supplicant_ctrl_iface_flush(wpa_s);
13250 		reply_len = wpas_ctrl_radio_work(wpa_s, buf + 11, reply,
13254 		if (wpas_ctrl_iface_mgmt_tx(wpa_s, buf + 8) < 0)
13257 		wpas_ctrl_iface_mgmt_tx_done(wpa_s);
13259 		if (wpas_ctrl_iface_mgmt_rx_process(wpa_s, buf + 16) < 0)
13262 		if (wpas_ctrl_iface_driver_event(wpa_s, buf + 13) < 0)
13265 		if (wpas_ctrl_iface_eapol_rx(wpa_s, buf + 9) < 0)
13268 		if (wpas_ctrl_iface_eapol_tx(wpa_s, buf + 9) < 0)
13271 		if (wpas_ctrl_iface_data_test_config(wpa_s, buf + 17) < 0)
13274 		if (wpas_ctrl_iface_data_test_tx(wpa_s, buf + 13) < 0)
13277 		if (wpas_ctrl_iface_data_test_frame(wpa_s, buf + 16) < 0)
13290 		if (wpas_ctrl_event_test(wpa_s, buf + 11) < 0)
13293 		if (wpas_ctrl_test_assoc_ie(wpa_s, buf + 14) < 0)
13296 		if (wpas_ctrl_test_eapol_m2_elems(wpa_s, buf + 20) < 0)
13299 		if (wpas_ctrl_test_eapol_m4_elems(wpa_s, buf + 20) < 0)
13302 		if (wpas_ctrl_reset_pn(wpa_s) < 0)
13305 		if (wpas_ctrl_key_request(wpa_s, buf + 12) < 0)
13308 		if (wpas_ctrl_resend_assoc(wpa_s) < 0)
13312 			wpa_s, wpa_s->bssid, NULL,
13315 		if (wpas_ctrl_iface_send_twt_setup(wpa_s, buf + 9))
13318 		if (wpas_ctrl_iface_send_twt_setup(wpa_s, ""))
13321 		if (wpas_ctrl_iface_send_twt_teardown(wpa_s, buf + 12))
13324 		if (wpas_ctrl_iface_send_twt_teardown(wpa_s, ""))
13327 		if (wpas_ctrl_ml_probe(wpa_s, buf + 13))
13331 		if (wpas_ctrl_vendor_elem_add(wpa_s, buf + 16) < 0)
13334 		reply_len = wpas_ctrl_vendor_elem_get(wpa_s, buf + 16, reply,
13337 		if (wpas_ctrl_vendor_elem_remove(wpa_s, buf + 19) < 0)
13341 		if (wpas_ctrl_iface_send_neighbor_rep(wpa_s, buf + 20))
13345 		wpas_ctrl_iface_erp_flush(wpa_s);
13347 		if (wpas_ctrl_iface_mac_rand_scan(wpa_s, buf + 14))
13351 			wpa_s, buf + 19, reply, reply_size);
13354 		if (wpas_ctrl_iface_fils_hlp_req_add(wpa_s, buf + 17))
13357 		wpas_flush_fils_hlp_req(wpa_s);
13363 		res = wpas_dpp_qr_code(wpa_s, buf + 12);
13374 		res = wpas_dpp_nfc_uri(wpa_s, buf + 12);
13385 		res = wpas_dpp_nfc_handover_req(wpa_s, buf + 20);
13396 		res = wpas_dpp_nfc_handover_sel(wpa_s, buf + 20);
13407 		res = dpp_bootstrap_gen(wpa_s->dpp, buf + 18);
13416 		if (dpp_bootstrap_remove(wpa_s->dpp, buf + 21) < 0)
13421 		uri = dpp_bootstrap_get_uri(wpa_s->dpp, atoi(buf + 22));
13430 		reply_len = dpp_bootstrap_info(wpa_s->dpp, atoi(buf + 19),
13433 		if (dpp_bootstrap_set(wpa_s->dpp, atoi(buf + 18),
13437 		if (wpas_dpp_auth_init(wpa_s, buf + 13) < 0)
13440 		if (wpas_dpp_listen(wpa_s, buf + 11) < 0)
13443 		wpas_dpp_stop(wpa_s);
13444 		wpas_dpp_listen_stop(wpa_s);
13448 		res = dpp_configurator_add(wpa_s->dpp, buf + 20);
13457 		if (dpp_configurator_set(wpa_s->dpp, buf + 20) < 0)
13460 		if (dpp_configurator_remove(wpa_s->dpp, buf + 24) < 0)
13463 		if (wpas_dpp_configurator_sign(wpa_s, buf + 21) < 0)
13466 		reply_len = dpp_configurator_get_key_id(wpa_s->dpp,
13472 		res = wpas_dpp_pkex_add(wpa_s, buf + 12);
13481 		if (wpas_dpp_pkex_remove(wpa_s, buf + 16) < 0)
13484 		if (wpas_dpp_conf_set(wpa_s, buf + 12) < 0)
13488 		if (wpas_dpp_controller_start(wpa_s, buf + 20) < 0)
13491 		if (wpas_dpp_controller_start(wpa_s, NULL) < 0)
13494 		dpp_controller_stop(wpa_s->dpp);
13496 		if (wpas_dpp_chirp(wpa_s, buf + 9) < 0)
13499 		wpas_dpp_chirp_stop(wpa_s);
13501 		if (wpas_dpp_reconfig(wpa_s, buf + 13) < 0)
13504 		if (wpas_dpp_ca_set(wpa_s, buf + 10) < 0)
13509 		if (wpas_dpp_push_button(wpa_s, NULL) < 0)
13512 		if (wpas_dpp_push_button(wpa_s, buf + 15) < 0)
13518 		reply_len = wpas_ctrl_nan_publish(wpa_s, buf + 12, reply,
13521 		if (wpas_ctrl_nan_cancel_publish(wpa_s, buf + 19) < 0)
13524 		if (wpas_ctrl_nan_update_publish(wpa_s, buf + 19) < 0)
13527 		reply_len = wpas_ctrl_nan_subscribe(wpa_s, buf + 14, reply,
13530 		if (wpas_ctrl_nan_cancel_subscribe(wpa_s, buf + 21) < 0)
13533 		if (wpas_ctrl_nan_transmit(wpa_s, buf + 13) < 0)
13538 		if (wpas_ctrl_iface_pasn_start(wpa_s, buf + 11) < 0)
13541 		wpas_pasn_auth_stop(wpa_s);
13543 		reply_len = ptksa_cache_list(wpa_s->ptksa, reply, reply_size);
13545 		if (wpas_ctrl_iface_pasn_deauthenticate(wpa_s, buf + 12) < 0)
13549 		if (wpas_ctrl_iface_pasn_driver(wpa_s, buf + 12) < 0)
13555 		if (wpas_ctrl_iface_configure_mscs(wpa_s, buf + 5))
13558 		if (wpas_ctrl_iface_configure_scs(wpa_s, buf + 4))
13561 		if (wpas_ctrl_iface_send_dscp_resp(wpa_s, buf + 10))
13564 		if (wpas_ctrl_iface_send_dscp_query(wpa_s, buf + 11))
13568 		reply_len = wpas_ctrl_iface_mlo_status(wpa_s, reply,
13571 		reply_len = wpas_ctrl_iface_mlo_signal_poll(wpa_s, reply,
13593 	struct wpa_supplicant *wpa_s;
13711 	wpa_s = wpa_supplicant_add_iface(global, &iface, NULL);
13712 	if (!wpa_s)
13714 	wpa_s->added_vif = create_iface;
13730 	struct wpa_supplicant *wpa_s;
13736 	wpa_s = wpa_supplicant_get_iface(global, cmd);
13737 	if (wpa_s == NULL)
13739 	delete_iface = wpa_s->added_vif;
13740 	ret = wpa_supplicant_remove_iface(global, wpa_s, 0);
13815 	struct wpa_supplicant *wpa_s;
13821 	wpa_s = global->ifaces;
13825 	while (wpa_s) {
13828 					  wpa_s->ifname,
13829 					  wpa_s->conf->ctrl_interface ?
13830 					  wpa_s->conf->ctrl_interface : "N/A");
13833 					  wpa_s->ifname);
13840 		wpa_s = wpa_s->next;
13850 	struct wpa_supplicant *wpa_s;
13852 	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
13853 		if (os_strcmp(ifname, wpa_s->ifname) == 0)
13857 	if (wpa_s == NULL) {
13866 	return wpa_supplicant_ctrl_iface_process(wpa_s, cmd, resp_len);
14018 	struct wpa_supplicant *wpa_s[2]; /* src, dst */
14025 	for (i = 0; i < ARRAY_SIZE(wpa_s) ; i++) {
14031 		wpa_s[i] = global->ifaces;
14032 		for (; wpa_s[i]; wpa_s[i] = wpa_s[i]->next) {
14033 			if (os_strcmp(cmd, wpa_s[i]->ifname) == 0)
14037 		if (!wpa_s[i]) {
14046 	return wpa_supplicant_ctrl_iface_dup_network(wpa_s[0], cmd, wpa_s[1]);
14054 	struct wpa_supplicant *wpa_s;
14056 	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
14057 		if (!wpa_s->conf->update_config) {
14058 			wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Not allowed to update configuration (update_config=0)");
14062 		if (wpa_config_write(wpa_s->confname, wpa_s->conf)) {
14063 			wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Failed to update configuration");
14066 			wpa_dbg(wpa_s, MSG_DEBUG, "CTRL_IFACE: SAVE_CONFIG - Configuration updated");
14072 		wpa_dbg(wpa_s, MSG_DEBUG,
14087 	struct wpa_supplicant *wpa_s;
14118 	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
14121 				  wpa_s->ifname, MAC2STR(wpa_s->own_addr));
14139 	struct wpa_supplicant *wpa_s;
14143 		wpa_s = wpa_supplicant_get_iface(global, ifname);
14144 		if (wpa_s) {
14145 			if (wpa_s->fst) {
14149 			fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj);
14150 			wpa_s->fst = fst_attach(ifname, wpa_s->own_addr,
14152 			if (wpa_s->fst)
14166 	struct wpa_supplicant *wpa_s;
14169 		wpa_s = wpa_supplicant_get_iface(global, ifname);
14170 		if (wpa_s) {
14172 				wpa_s->fst = NULL;