Lines Matching refs:wpa_s
34 static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s,
38 static void wpas_dpp_auth_success(struct wpa_supplicant *wpa_s, int initiator);
39 static void wpas_dpp_tx_status(struct wpa_supplicant *wpa_s,
45 static int wpas_dpp_auth_init_next(struct wpa_supplicant *wpa_s);
47 wpas_dpp_tx_pkex_status(struct wpa_supplicant *wpa_s,
56 static void wpas_dpp_start_gas_client(struct wpa_supplicant *wpa_s);
71 * @wpa_s: Pointer to wpa_supplicant data
75 int wpas_dpp_qr_code(struct wpa_supplicant *wpa_s, const char *cmd)
78 struct dpp_authentication *auth = wpa_s->dpp_auth;
80 bi = dpp_add_qr_code(wpa_s->dpp, cmd);
88 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR
92 offchannel_send_action(wpa_s, auth->curr_freq,
93 auth->peer_mac_addr, wpa_s->own_addr,
101 dpp_controller_new_qr_code(wpa_s->dpp, bi);
110 * @wpa_s: Pointer to wpa_supplicant data
114 int wpas_dpp_nfc_uri(struct wpa_supplicant *wpa_s, const char *cmd)
118 bi = dpp_add_nfc_uri(wpa_s->dpp, cmd);
126 int wpas_dpp_nfc_handover_req(struct wpa_supplicant *wpa_s, const char *cmd)
135 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
144 peer_bi = dpp_add_nfc_uri(wpa_s->dpp, pos);
158 int wpas_dpp_nfc_handover_sel(struct wpa_supplicant *wpa_s, const char *cmd)
167 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
176 peer_bi = dpp_add_nfc_uri(wpa_s->dpp, pos);
195 struct wpa_supplicant *wpa_s = eloop_ctx;
196 struct dpp_authentication *auth = wpa_s->dpp_auth;
203 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR
207 offchannel_send_action(wpa_s, auth->curr_freq, auth->peer_mac_addr,
208 wpa_s->own_addr, broadcast,
215 static void wpas_dpp_auth_resp_retry(struct wpa_supplicant *wpa_s)
217 struct dpp_authentication *auth = wpa_s->dpp_auth;
223 if (wpa_s->dpp_resp_max_tries)
224 max_tries = wpa_s->dpp_resp_max_tries;
230 offchannel_send_action_done(wpa_s);
231 dpp_auth_deinit(wpa_s->dpp_auth);
232 wpa_s->dpp_auth = NULL;
236 if (wpa_s->dpp_resp_retry_time)
237 wait_time = wpa_s->dpp_resp_retry_time;
240 if (wpa_s->dpp_tx_chan_change) {
241 wpa_s->dpp_tx_chan_change = false;
249 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL);
252 wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL);
256 static void wpas_dpp_try_to_connect(struct wpa_supplicant *wpa_s)
259 wpa_s->suitable_network = 0;
260 wpa_s->no_suitable_network = 0;
261 wpa_s->disconnected = 0;
262 wpa_s->reassociate = 1;
263 wpa_s->scan_runs = 0;
264 wpa_s->normal_scans = 0;
265 wpa_supplicant_cancel_sched_scan(wpa_s);
266 wpa_supplicant_req_scan(wpa_s, 0, 0);
272 static void wpas_dpp_stop_listen_for_tx(struct wpa_supplicant *wpa_s,
279 if (!wpa_s->dpp_listen_freq)
283 if (os_reltime_before(&now, &wpa_s->dpp_listen_end)) {
284 os_reltime_sub(&wpa_s->dpp_listen_end, &now, &res);
289 if (wpa_s->dpp_listen_freq == freq && remaining > wait_time)
294 wpa_s->dpp_listen_freq, remaining, freq, wait_time);
295 wpas_dpp_listen_stop(wpa_s);
304 struct wpa_supplicant *wpa_s = eloop_ctx;
305 struct dpp_authentication *auth = wpa_s->dpp_auth;
309 !dpp_tcp_conn_status_requested(wpa_s->dpp))
314 if (wpa_s->suitable_network)
316 else if (wpa_s->no_suitable_network)
320 if (wpa_s->wpa_state == WPA_SCANNING)
321 wpas_abort_ongoing_scan(wpa_s);
322 wpas_dpp_send_conn_status_result(wpa_s, result);
326 static char * wpas_dpp_scan_channel_list(struct wpa_supplicant *wpa_s)
334 if (!wpa_s->last_scan_freqs || !wpa_s->num_last_scan_freqs)
337 len = wpa_s->num_last_scan_freqs * 8;
344 for (i = 0; i < wpa_s->num_last_scan_freqs; i++) {
348 mode = ieee80211_freq_to_channel_ext(wpa_s->last_scan_freqs[i],
374 void wpas_dpp_send_conn_status_result(struct wpa_supplicant *wpa_s,
380 struct wpa_ssid *ssid = wpa_s->current_ssid;
381 struct dpp_authentication *auth = wpa_s->dpp_auth;
383 eloop_cancel_timeout(wpas_dpp_conn_status_result_timeout, wpa_s, NULL);
386 !dpp_tcp_conn_status_requested(wpa_s->dpp))
393 channel_list_buf = wpas_dpp_scan_channel_list(wpa_s);
398 dpp_tcp_send_conn_status(wpa_s->dpp, result,
400 wpa_s->dpp_last_ssid,
402 wpa_s->dpp_last_ssid_len,
412 wpa_s->dpp_last_ssid,
414 wpa_s->dpp_last_ssid_len,
418 dpp_auth_deinit(wpa_s->dpp_auth);
419 wpa_s->dpp_auth = NULL;
423 wpa_msg(wpa_s, MSG_INFO,
427 offchannel_send_action(wpa_s, auth->curr_freq,
428 auth->peer_mac_addr, wpa_s->own_addr, broadcast,
442 struct wpa_supplicant *wpa_s = eloop_ctx;
443 struct dpp_authentication *auth = wpa_s->dpp_auth;
446 dpp_tcp_conn_status_requested(wpa_s->dpp))
447 wpas_dpp_send_conn_status_result(wpa_s, DPP_STATUS_OK);
451 void wpas_dpp_connected(struct wpa_supplicant *wpa_s)
453 struct dpp_authentication *auth = wpa_s->dpp_auth;
456 dpp_tcp_conn_status_requested(wpa_s->dpp)) {
462 wpa_s, NULL);
471 struct wpa_supplicant *wpa_s = eloop_ctx;
472 struct dpp_authentication *auth = wpa_s->dpp_auth;
478 wpas_dpp_auth_init_next(wpa_s);
488 struct wpa_supplicant *wpa_s = eloop_ctx;
489 struct dpp_authentication *auth = wpa_s->dpp_auth;
491 if (!wpa_s->dpp_listen_on_tx_expire || !auth || !auth->neg_freq)
497 wpas_dpp_listen_start(wpa_s, auth->neg_freq);
501 static void wpas_dpp_tx_status(struct wpa_supplicant *wpa_s,
508 struct dpp_authentication *auth = wpa_s->dpp_auth;
515 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
518 if (!wpa_s->dpp_auth) {
529 wpas_dpp_try_to_connect(wpa_s);
535 wpa_s, NULL);
538 wpa_s, NULL);
540 dpp_auth_deinit(wpa_s->dpp_auth);
541 wpa_s->dpp_auth = NULL;
547 if (wpa_s->dpp_auth->remove_on_tx_status) {
550 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL);
551 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
552 eloop_cancel_timeout(wpas_dpp_auth_conf_wait_timeout, wpa_s,
554 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s,
558 wpa_s, NULL);
560 offchannel_send_action_done(wpa_s);
561 dpp_auth_deinit(wpa_s->dpp_auth);
562 wpa_s->dpp_auth = NULL;
566 if (wpa_s->dpp_auth_ok_on_ack)
567 wpas_dpp_auth_success(wpa_s, 1);
576 offchannel_send_action_done(wpa_s);
577 /* Call wpas_dpp_auth_init_next(wpa_s) from driver event
582 wpa_s, NULL);
586 wpas_dpp_auth_resp_retry(wpa_s);
596 eloop_cancel_timeout(wpas_dpp_auth_conf_wait_timeout, wpa_s,
599 wpa_s, NULL);
609 if (!wpa_s->dpp_auth_ok_on_ack && wpa_s->dpp_auth->neg_freq > 0 &&
610 wpa_s->dpp_auth->curr_freq != wpa_s->dpp_auth->neg_freq) {
613 wpa_s->dpp_auth->curr_freq,
614 wpa_s->dpp_auth->neg_freq);
615 offchannel_send_action_done(wpa_s);
616 wpa_s->dpp_listen_on_tx_expire = true;
618 wpa_s, NULL);
621 if (wpa_s->dpp_auth_ok_on_ack)
622 wpa_s->dpp_auth_ok_on_ack = 0;
628 struct wpa_supplicant *wpa_s = eloop_ctx;
629 struct dpp_authentication *auth = wpa_s->dpp_auth;
637 wait_time = wpa_s->dpp_resp_wait_time ?
638 wpa_s->dpp_resp_wait_time : 2000;
640 os_reltime_sub(&now, &wpa_s->dpp_last_init, &diff);
651 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED);
652 offchannel_send_action_done(wpa_s);
653 wpas_dpp_listen_stop(wpa_s);
655 wpa_s->dpp_auth = NULL;
664 offchannel_send_action_done(wpa_s);
665 wpas_dpp_listen_stop(wpa_s);
666 wpas_dpp_auth_init_next(wpa_s);
684 wpa_s->dpp_in_response_listen = 1;
685 wpas_dpp_listen_start(wpa_s, freq);
688 wpas_dpp_reply_wait_timeout, wpa_s, NULL);
694 struct wpa_supplicant *wpa_s = eloop_ctx;
695 struct dpp_authentication *auth = wpa_s->dpp_auth;
702 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL "No Auth Confirm received");
703 offchannel_send_action_done(wpa_s);
705 wpa_s->dpp_auth = NULL;
709 static void wpas_dpp_set_testing_options(struct wpa_supplicant *wpa_s,
713 if (wpa_s->dpp_config_obj_override)
715 os_strdup(wpa_s->dpp_config_obj_override);
716 if (wpa_s->dpp_discovery_override)
718 os_strdup(wpa_s->dpp_discovery_override);
719 if (wpa_s->dpp_groups_override)
721 os_strdup(wpa_s->dpp_groups_override);
723 wpa_s->dpp_ignore_netaccesskey_mismatch;
730 struct wpa_supplicant *wpa_s = eloop_ctx;
732 if (!wpa_s->dpp_auth)
735 wpas_dpp_auth_init_next(wpa_s);
739 static int wpas_dpp_auth_init_next(struct wpa_supplicant *wpa_s)
741 struct dpp_authentication *auth = wpa_s->dpp_auth;
746 eloop_cancel_timeout(wpas_dpp_drv_wait_timeout, wpa_s, NULL);
748 wpa_s->dpp_in_response_listen = 0;
753 os_get_reltime(&wpa_s->dpp_init_iter_start);
757 if (wpa_s->dpp_init_max_tries)
758 max_tries = wpa_s->dpp_init_max_tries;
764 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED);
766 wpa_s, NULL);
767 offchannel_send_action_done(wpa_s);
768 dpp_auth_deinit(wpa_s->dpp_auth);
769 wpa_s->dpp_auth = NULL;
773 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL);
774 if (wpa_s->dpp_init_retry_time)
775 wait_time = wpa_s->dpp_init_retry_time;
779 os_reltime_sub(&now, &wpa_s->dpp_init_iter_start, &diff);
789 wpas_dpp_init_timeout, wpa_s,
802 wpa_s->dpp_auth_ok_on_ack = 0;
803 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
804 wait_time = wpa_s->max_remain_on_chan;
805 max_wait_time = wpa_s->dpp_resp_wait_time ?
806 wpa_s->dpp_resp_wait_time : 2000;
812 wpa_s, NULL);
819 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
822 os_get_reltime(&wpa_s->dpp_last_init);
823 return offchannel_send_action(wpa_s, freq, dst,
824 wpa_s->own_addr, broadcast,
831 int wpas_dpp_auth_init(struct wpa_supplicant *wpa_s, const char *cmd)
845 wpa_s->dpp_gas_client = 0;
846 wpa_s->dpp_gas_server = 0;
852 peer_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
891 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
924 wpa_s->dpp_netrole = DPP_NETROLE_AP;
926 wpa_s->dpp_netrole = DPP_NETROLE_CONFIGURATOR;
928 wpa_s->dpp_netrole = DPP_NETROLE_STA;
930 wpa_s->dpp_netrole = DPP_NETROLE_STA;
937 if (!tcp && wpa_s->dpp_auth) {
938 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL);
939 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
940 eloop_cancel_timeout(wpas_dpp_auth_conf_wait_timeout, wpa_s,
942 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s,
946 wpa_s, NULL);
948 offchannel_send_action_done(wpa_s);
949 dpp_auth_deinit(wpa_s->dpp_auth);
950 wpa_s->dpp_auth = NULL;
953 auth = dpp_auth_init(wpa_s->dpp, wpa_s, peer_bi, own_bi, allowed_roles,
954 neg_freq, wpa_s->hw.modes, wpa_s->hw.num_modes);
957 wpas_dpp_set_testing_options(wpa_s, auth);
970 return dpp_tcp_init(wpa_s->dpp, auth, &ipaddr, tcp_port,
971 wpa_s->conf->dpp_name, DPP_NETROLE_STA,
972 wpa_s->conf->dpp_mud_url,
973 wpa_s->conf->dpp_extra_conf_req_name,
974 wpa_s->conf->dpp_extra_conf_req_value,
975 wpa_s, wpa_s, wpas_dpp_process_conf_obj,
979 wpa_s->dpp_auth = auth;
980 return wpas_dpp_auth_init_next(wpa_s);
1001 static void wpas_dpp_listen_work_done(struct wpa_supplicant *wpa_s)
1005 if (!wpa_s->dpp_listen_work)
1008 lwork = wpa_s->dpp_listen_work->ctx;
1010 radio_work_done(wpa_s->dpp_listen_work);
1011 wpa_s->dpp_listen_work = NULL;
1017 struct wpa_supplicant *wpa_s = work->wpa_s;
1022 wpa_s->dpp_listen_work = NULL;
1023 wpas_dpp_listen_stop(wpa_s);
1029 wpa_s->dpp_listen_work = work;
1031 wpa_s->dpp_pending_listen_freq = lwork->freq;
1033 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq,
1034 wpa_s->max_remain_on_chan) < 0) {
1038 wpa_s->dpp_listen_freq = 0;
1039 wpas_dpp_listen_work_done(wpa_s);
1040 wpa_s->dpp_pending_listen_freq = 0;
1043 wpa_s->off_channel_freq = 0;
1044 wpa_s->roc_waiting_drv_freq = lwork->freq;
1045 wpa_drv_dpp_listen(wpa_s, true);
1046 wpa_s->dpp_tx_auth_resp_on_roc_stop = false;
1047 wpa_s->dpp_tx_chan_change = false;
1051 static int wpas_dpp_listen_start(struct wpa_supplicant *wpa_s,
1056 if (wpa_s->dpp_listen_work) {
1062 if (wpa_s->dpp_listen_freq)
1063 wpas_dpp_listen_stop(wpa_s);
1064 wpa_s->dpp_listen_freq = freq;
1071 if (radio_add_work(wpa_s, freq, "dpp-listen", 0, dpp_start_listen_cb,
1081 int wpas_dpp_listen(struct wpa_supplicant *wpa_s, const char *cmd)
1090 wpa_s->dpp_allowed_roles = DPP_CAPAB_CONFIGURATOR;
1092 wpa_s->dpp_allowed_roles = DPP_CAPAB_ENROLLEE;
1094 wpa_s->dpp_allowed_roles = DPP_CAPAB_CONFIGURATOR |
1096 wpa_s->dpp_qr_mutual = os_strstr(cmd, " qr=mutual") != NULL;
1098 wpa_s->dpp_netrole = DPP_NETROLE_AP;
1100 wpa_s->dpp_netrole = DPP_NETROLE_CONFIGURATOR;
1102 wpa_s->dpp_netrole = DPP_NETROLE_STA;
1103 if (wpa_s->dpp_listen_freq == (unsigned int) freq) {
1109 return wpas_dpp_listen_start(wpa_s, freq);
1113 void wpas_dpp_listen_stop(struct wpa_supplicant *wpa_s)
1115 wpa_s->dpp_in_response_listen = 0;
1116 if (!wpa_s->dpp_listen_freq)
1120 wpa_s->dpp_listen_freq);
1121 wpa_drv_cancel_remain_on_channel(wpa_s);
1122 wpa_drv_dpp_listen(wpa_s, false);
1123 wpa_s->dpp_listen_freq = 0;
1124 wpas_dpp_listen_work_done(wpa_s);
1125 radio_remove_works(wpa_s, "dpp-listen", 0);
1129 void wpas_dpp_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
1132 if (wpa_s->dpp_listen_freq != freq)
1138 os_get_reltime(&wpa_s->dpp_listen_end);
1139 wpa_s->dpp_listen_end.usec += duration * 1000;
1140 while (wpa_s->dpp_listen_end.usec >= 1000000) {
1141 wpa_s->dpp_listen_end.sec++;
1142 wpa_s->dpp_listen_end.usec -= 1000000;
1147 static void wpas_dpp_tx_auth_resp(struct wpa_supplicant *wpa_s)
1149 struct dpp_authentication *auth = wpa_s->dpp_auth;
1154 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
1157 offchannel_send_action(wpa_s, auth->curr_freq,
1158 auth->peer_mac_addr, wpa_s->own_addr, broadcast,
1168 struct wpa_supplicant *wpa_s = eloop_ctx;
1169 struct dpp_authentication *auth = wpa_s->dpp_auth;
1171 if (!auth || !wpa_s->dpp_tx_auth_resp_on_roc_stop)
1174 wpa_s
1175 wpa_s->dpp_tx_chan_change = true;
1178 wpas_dpp_tx_auth_resp(wpa_s);
1182 void wpas_dpp_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
1186 wpas_dpp_listen_work_done(wpa_s);
1188 if (wpa_s->dpp_auth && wpa_s->dpp_tx_auth_resp_on_roc_stop) {
1190 wpa_s, NULL);
1191 wpa_s->dpp_tx_auth_resp_on_roc_stop = false;
1192 wpa_s->dpp_tx_chan_change = true;
1195 wpas_dpp_tx_auth_resp(wpa_s);
1199 if (wpa_s->dpp_auth && wpa_s->dpp_in_response_listen) {
1203 if (wpa_s->dpp_auth->neg_freq > 0)
1204 new_freq = wpa_s->dpp_auth->neg_freq;
1206 new_freq = wpa_s->dpp_auth->curr_freq;
1210 wpas_dpp_listen_start(wpa_s, new_freq);
1214 if (wpa_s->dpp_listen_freq) {
1216 wpas_dpp_listen_start(wpa_s, wpa_s->dpp_listen_freq);
1221 static void wpas_dpp_rx_auth_req(struct wpa_supplicant *wpa_s, const u8 *src,
1229 if (!wpa_s->dpp)
1236 wpas_dpp_chirp_stop(wpa_s);
1242 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
1252 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
1261 dpp_bootstrap_find_pair(wpa_s->dpp, i_bootstrap, r_bootstrap,
1264 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
1271 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
1278 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
1284 if (wpa_s->dpp_auth) {
1285 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
1290 wpa_s->dpp_pkex_wait_auth_req = false;
1291 wpa_s->dpp_gas_client = 0;
1292 wpa_s->dpp_gas_server = 0;
1293 wpa_s->dpp_auth_ok_on_ack = 0;
1294 wpa_s->dpp_auth = dpp_auth_req_rx(wpa_s->dpp, wpa_s,
1295 wpa_s->dpp_allowed_roles,
1296 wpa_s->dpp_qr_mutual,
1298 if (!wpa_s->dpp_auth) {
1302 wpas_dpp_set_testing_options(wpa_s, wpa_s->dpp_auth);
1303 if (dpp_set_configurator(wpa_s->dpp_auth,
1304 wpa_s->dpp_configurator_params) < 0) {
1305 dpp_auth_deinit(wpa_s->dpp_auth);
1306 wpa_s->dpp_auth = NULL;
1309 os_memcpy(wpa_s->dpp_auth->peer_mac_addr, src, ETH_ALEN);
1311 if (wpa_s->dpp_listen_freq &&
1312 wpa_s->dpp_listen_freq != wpa_s->dpp_auth->curr_freq) {
1315 wpa_s->dpp_listen_freq, wpa_s->dpp_auth->curr_freq);
1316 wpa_s->dpp_tx_auth_resp_on_roc_stop = true;
1319 wpa_s, NULL);
1320 wpas_dpp_listen_stop(wpa_s);
1323 wpa_s->dpp_tx_auth_resp_on_roc_stop = false;
1324 wpa_s->dpp_tx_chan_change = false;
1326 wpas_dpp_tx_auth_resp(wpa_s);
1330 void wpas_dpp_tx_wait_expire(struct wpa_supplicant *wpa_s)
1332 struct dpp_authentication *auth = wpa_s->dpp_auth;
1335 if (wpa_s->dpp_listen_on_tx_expire && auth && auth->neg_freq) {
1339 eloop_cancel_timeout(wpas_dpp_neg_freq_timeout, wpa_s, NULL);
1340 wpas_dpp_listen_start(wpa_s, auth->neg_freq);
1344 if (!wpa_s->dpp_gas_server || !auth) {
1347 wpa_s, NULL)) {
1349 wpa_s, NULL);
1353 wpas_dpp_auth_init_next(wpa_s);
1359 if (wpa_s->dpp_listen_work || (int) wpa_s->dpp_listen_freq == freq)
1363 wpa_s->dpp_in_response_listen = 1;
1364 wpas_dpp_listen_start(wpa_s, freq);
1368 static void wpas_dpp_start_gas_server(struct wpa_supplicant *wpa_s)
1370 struct dpp_authentication *auth = wpa_s->dpp_auth;
1374 auth->curr_freq, auth->neg_freq, wpa_s->dpp_listen_freq,
1375 !!wpa_s->dpp_listen_work);
1376 wpa_s->dpp_gas_server = 1;
1380 static struct wpa_ssid * wpas_dpp_add_network(struct wpa_supplicant *wpa_s,
1392 res = wpa_drv_get_capa(wpa_s, &capa);
1396 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) {
1408 ssid = wpa_config_add_network(wpa_s->conf);
1411 wpas_notify_network_added(wpa_s, ssid);
1431 wpa_s->conf->dpp_connector_privacy_default;
1512 if (!wpa_config_get_blob(wpa_s->conf, name))
1530 wpa_config_set_blob(wpa_s->conf, blob);
1547 if (!wpa_config_get_blob(wpa_s->conf, name))
1565 wpa_config_set_blob(wpa_s->conf, blob);
1586 os_memcpy(wpa_s->dpp_last_ssid, conf->ssid, conf->ssid_len);
1587 wpa_s->dpp_last_ssid_len = conf->ssid_len;
1591 wpas_notify_network_removed(wpa_s, ssid);
1592 wpa_config_remove_network(wpa_s->conf, ssid->id);
1597 static int wpas_dpp_process_config(struct wpa_supplicant *wpa_s,
1603 if (wpa_s->conf->dpp_config_processing < 1)
1606 ssid = wpas_dpp_add_network(wpa_s, auth, conf);
1610 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_NETWORK_ID "%d", ssid->id);
1611 if (wpa_s->conf->dpp_config_processing == 2)
1615 if (wpa_s->conf->update_config &&
1616 wpa_config_write(wpa_s->confname, wpa_s->conf))
1624 static void wpas_dpp_post_process_config(struct wpa_supplicant *wpa_s,
1628 if (auth->reconfig && wpa_s->dpp_reconfig_ssid &&
1629 wpa_config_get_network(wpa_s->conf, wpa_s->dpp_reconfig_ssid_id) ==
1630 wpa_s->dpp_reconfig_ssid) {
1633 wpas_notify_network_removed(wpa_s, wpa_s->dpp_reconfig_ssid);
1634 wpa_config_remove_network(wpa_s->conf,
1635 wpa_s->dpp_reconfig_ssid_id);
1636 wpa_s->dpp_reconfig_ssid = NULL;
1637 wpa_s->dpp_reconfig_ssid_id = -1;
1641 if (wpa_s->conf->dpp_config_processing < 2)
1653 wpas_dpp_try_to_connect(wpa_s);
1657 static int wpas_dpp_handle_config_obj(struct wpa_supplicant *wpa_s,
1661 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_RECEIVED);
1662 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_AKM "%s",
1665 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_SSID "%s",
1668 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_SSID_CHARSET "%d",
1676 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONNECTOR "%s",
1685 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_PASS "%s",
1691 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFOBJ_PSK "%s",
1704 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_C_SIGN_KEY "%s",
1719 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PP_KEY "%s", hex);
1734 wpa_msg(wpa_s, MSG_INFO,
1739 wpa_msg(wpa_s, MSG_INFO,
1752 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CERTBAG "%s", b64);
1762 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CACERT "%s", b64);
1767 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_SERVER_NAME "%s",
1772 if (!wpa_s->dpp_pb_result_indicated) {
1773 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT "success");
1774 wpa_s->dpp_pb_result_indicated = true;
1779 return wpas_dpp_process_config(wpa_s, auth, conf);
1783 static int wpas_dpp_handle_key_pkg(struct wpa_supplicant *wpa_s,
1793 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_RECEIVED);
1794 wpa_s->dpp_conf_backup_received = true;
1797 res = dpp_configurator_from_backup(wpa_s->dpp, key);
1800 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONFIGURATOR_ID "%d",
1813 struct wpa_supplicant *wpa_s = eloop_ctx;
1814 struct dpp_authentication *auth = wpa_s->dpp_auth;
1822 auth->csr = dpp_build_csr(auth, wpa_s->conf->dpp_name ?
1823 wpa_s->conf->dpp_name : "Test");
1825 dpp_auth_deinit(wpa_s->dpp_auth);
1826 wpa_s->dpp_auth = NULL;
1830 wpas_dpp_start_gas_client(wpa_s);
1838 struct wpa_supplicant *wpa_s = eloop_ctx;
1839 struct dpp_authentication *auth = wpa_s->dpp_auth;
1845 wpas_dpp_start_gas_client(wpa_s);
1855 struct wpa_supplicant *wpa_s = ctx;
1857 struct dpp_authentication *auth = wpa_s->dpp_auth;
1862 eloop_cancel_timeout(wpas_dpp_gas_client_timeout, wpa_s, NULL);
1863 wpa_s->dpp_gas_dialog_token = -1;
1899 eloop_register_timeout(0, 0, wpas_dpp_build_csr, wpa_s, NULL);
1906 eloop_register_timeout(0, 0, wpas_dpp_build_new_key, wpa_s,
1916 wpa_s->dpp_conf_backup_received = false;
1918 res = wpas_dpp_handle_config_obj(wpa_s, auth,
1924 wpas_dpp_post_process_config(wpa_s, auth);
1925 if (wpas_dpp_handle_key_pkg(wpa_s, auth->conf_key_pkg) < 0)
1937 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
1948 wpa_msg(wpa_s, MSG_INFO,
1952 offchannel_send_action(wpa_s, auth->curr_freq,
1953 addr, wpa_s->own_addr, broadcast,
1960 if (wpa_s->conf->dpp_config_processing < 2 ||
1961 wpa_s->dpp_conf_backup_received)
1967 dpp_auth_deinit(wpa_s->dpp_auth);
1968 wpa_s->dpp_auth = NULL;
1974 struct wpa_supplicant *wpa_s = eloop_ctx;
1975 struct dpp_authentication *auth = wpa_s->dpp_auth;
1977 if (!wpa_s->dpp_gas_client || !auth ||
1982 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
1983 dpp_auth_deinit(wpa_s->dpp_auth);
1984 wpa_s->dpp_auth = NULL;
1988 static void wpas_dpp_start_gas_client(struct wpa_supplicant *wpa_s)
1990 struct dpp_authentication *auth = wpa_s->dpp_auth;
1995 wpa_s->dpp_gas_client = 1;
1996 offchannel_send_action_done(wpa_s);
1997 wpas_dpp_listen_stop(wpa_s);
2002 supp_op_classes = wpas_supp_op_classes(wpa_s);
2004 buf = dpp_build_conf_req_helper(auth, wpa_s->conf->dpp_name,
2005 wpa_s->dpp_netrole,
2006 wpa_s->conf->dpp_mud_url,
2008 wpa_s->conf->dpp_extra_conf_req_name,
2009 wpa_s->conf->dpp_extra_conf_req_value);
2028 wpa_s, NULL);
2030 res = gas_query_req(wpa_s->gas, auth->peer_mac_addr, auth->curr_freq,
2031 1, 1, buf, wpas_dpp_gas_resp_cb, wpa_s);
2033 wpa_msg(wpa_s, MSG_DEBUG, "GAS: Failed to send Query Request");
2038 wpa_s->dpp_gas_dialog_token = res;
2043 static void wpas_dpp_auth_success(struct wpa_supplicant *wpa_s, int initiator)
2046 dpp_notify_auth_success(wpa_s->dpp_auth, initiator);
2051 if (wpa_s->dpp_auth->configurator) {
2053 wpa_s->dpp_auth->auth_success = 0;
2059 if (wpa_s->dpp_auth->configurator)
2060 wpas_dpp_start_gas_server(wpa_s);
2062 wpas_dpp_start_gas_client(wpa_s);
2066 static void wpas_dpp_rx_auth_resp(struct wpa_supplicant *wpa_s, const u8 *src,
2070 struct dpp_authentication *auth = wpa_s->dpp_auth;
2089 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
2097 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL);
2103 offchannel_send_action_done(wpa_s);
2104 wpas_dpp_listen_start(wpa_s, auth->curr_freq);
2112 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
2114 offchannel_send_action(wpa_s, auth->curr_freq,
2115 src, wpa_s->own_addr, broadcast,
2119 wpa_s->dpp_auth_ok_on_ack = 1;
2123 static void wpas_dpp_rx_auth_conf(struct wpa_supplicant *wpa_s, const u8 *src,
2126 struct dpp_authentication *auth = wpa_s->dpp_auth;
2143 eloop_cancel_timeout(wpas_dpp_auth_conf_wait_timeout, wpa_s, NULL);
2150 wpas_dpp_auth_success(wpa_s, 0);
2159 struct wpa_supplicant *wpa_s = eloop_ctx;
2160 struct dpp_authentication *auth = wpa_s->dpp_auth;
2167 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
2169 wpa_s->dpp_auth = NULL;
2176 struct wpa_supplicant *wpa_s = eloop_ctx;
2177 struct dpp_authentication *auth = wpa_s->dpp_auth;
2184 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONN_STATUS_RESULT "timeout");
2185 wpas_dpp_listen_stop(wpa_s);
2187 wpa_s->dpp_auth = NULL;
2193 static bool wpas_dpp_pb_active(struct wpa_supplicant *wpa_s)
2195 return (wpa_s->dpp_pb_time.sec || wpa_s->dpp_pb_time.usec) &&
2196 wpa_s->dpp_pb_configurator;
2200 static void wpas_dpp_remove_pb_hash(struct wpa_supplicant *wpa_s)
2204 if (!wpa_s->dpp_pb_bi)
2207 struct dpp_pb_info *info = &wpa_s->dpp_pb[i];
2211 if (os_memcmp(info->hash, wpa_s->dpp_pb_resp_hash,
2227 static void wpas_dpp_rx_conf_result(struct wpa_supplicant *wpa_s, const u8 *src,
2230 struct dpp_authentication *auth = wpa_s->dpp_auth;
2239 gas_server_response_sent(wpa_s->gas_server,
2266 wpa_msg(wpa_s, MSG_INFO,
2271 wpa_s, NULL);
2274 wpa_s, NULL);
2277 wpa_s, NULL);
2278 offchannel_send_action_done(wpa_s);
2280 if (!wpa_s->dpp_in_response_listen ||
2281 (int) wpa_s->dpp_listen_freq != freq)
2282 wpas_dpp_listen_start(wpa_s, freq);
2285 offchannel_send_action_done(wpa_s);
2286 wpas_dpp_listen_stop(wpa_s);
2288 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT "conf_status=%d",
2291 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
2293 wpa_s->dpp_auth = NULL;
2294 eloop_cancel_timeout(wpas_dpp_config_result_wait_timeout, wpa_s, NULL);
2296 if (!wpa_s->dpp_pb_result_indicated && wpas_dpp_pb_active(wpa_s)) {
2298 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT
2301 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT
2303 wpa_s->dpp_pb_result_indicated = true;
2305 wpas_dpp_remove_pb_hash(wpa_s);
2306 wpas_dpp_push_button_stop(wpa_s);
2312 static void wpas_dpp_rx_conn_status_result(struct wpa_supplicant *wpa_s,
2316 struct dpp_authentication *auth = wpa_s->dpp_auth;
2332 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONN_STATUS_RESULT
2337 offchannel_send_action_done(wpa_s);
2338 wpas_dpp_listen_stop(wpa_s);
2340 wpa_s->dpp_auth = NULL;
2342 wpa_s, NULL);
2349 struct wpa_supplicant *wpa_s = ctx;
2354 res = wpas_dpp_handle_config_obj(wpa_s, auth,
2360 wpas_dpp_post_process_config(wpa_s, auth);
2368 struct wpa_supplicant *wpa_s = ctx;
2376 wpas_dpp_try_to_connect(wpa_s);
2382 wpa_s, NULL);
2385 wpa_s, NULL);
2396 struct wpa_supplicant *wpa_s = ctx;
2398 if (bi == wpa_s->dpp_chirp_bi)
2399 wpas_dpp_chirp_stop(wpa_s);
2404 wpas_dpp_rx_presence_announcement(struct wpa_supplicant *wpa_s, const u8 *src,
2414 if (!wpa_s->dpp)
2417 if (wpa_s->dpp_auth) {
2429 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
2435 peer_bi = dpp_bootstrap_find_chirp(wpa_s->dpp, r_bootstrap);
2436 dpp_notify_chirp_received(wpa_s, peer_bi ? (int) peer_bi->id : -1, src,
2447 auth = dpp_auth_init(wpa_s->dpp, wpa_s, peer_bi, NULL,
2451 wpas_dpp_set_testing_options(wpa_s, auth);
2452 if (dpp_set_configurator(auth, wpa_s->dpp_configurator_params) < 0) {
2463 wait_time = wpa_s->max_remain_on_chan;
2464 max_wait_time = wpa_s->dpp_resp_wait_time ?
2465 wpa_s->dpp_resp_wait_time : 2000;
2468 wpas_dpp_stop_listen_for_tx(wpa_s, freq, wait_time);
2470 wpa_s->dpp_auth = auth;
2471 if (wpas_dpp_auth_init_next(wpa_s) < 0) {
2472 dpp_auth_deinit(wpa_s->dpp_auth);
2473 wpa_s->dpp_auth = NULL;
2481 struct wpa_supplicant *wpa_s = eloop_ctx;
2482 struct dpp_authentication *auth = wpa_s->dpp_auth;
2488 offchannel_send_action_done(wpa_s);
2489 wpas_dpp_listen_stop(wpa_s);
2491 wpa_s->dpp_auth = NULL;
2496 wpas_dpp_rx_reconfig_announcement(struct wpa_supplicant *wpa_s, const u8 *src,
2507 if (!wpa_s->dpp)
2510 if (wpa_s->dpp_auth) {
2522 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
2528 conf = dpp_configurator_find_kid(wpa_s->dpp, csign_hash);
2538 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
2548 auth = dpp_reconfig_init(wpa_s->dpp, wpa_s, conf, freq, group,
2552 wpas_dpp_set_testing_options(wpa_s, auth);
2553 if (dpp_set_configurator(auth, wpa_s->dpp_configurator_params) < 0) {
2559 wpa_s->dpp_auth = auth;
2561 wpa_s->dpp_in_response_listen = 0;
2562 wpa_s->dpp_auth_ok_on_ack = 0;
2563 wait_time = wpa_s->max_remain_on_chan;
2564 max_wait_time = wpa_s->dpp_resp_wait_time ?
2565 wpa_s->dpp_resp_wait_time : 2000;
2571 wpa_s, NULL);
2574 wpas_dpp_stop_listen_for_tx(wpa_s, freq, wait_time);
2576 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
2578 if (offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, broadcast,
2582 dpp_auth_deinit(wpa_s->dpp_auth);
2583 wpa_s->dpp_auth = NULL;
2589 wpas_dpp_rx_reconfig_auth_req(struct wpa_supplicant *wpa_s, const u8 *src,
2599 if (!wpa_s->dpp)
2601 if (wpa_s->dpp_auth) {
2606 if (!wpa_s->dpp_reconfig_ssid) {
2611 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2612 if (ssid == wpa_s->dpp_reconfig_ssid &&
2613 ssid->id == wpa_s->dpp_reconfig_ssid_id)
2623 auth = dpp_reconfig_auth_req_rx(wpa_s->dpp, wpa_s, ssid->dpp_connector,
2631 wpa_s->dpp_auth = auth;
2633 wpas_dpp_chirp_stop(wpa_s);
2635 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
2637 if (offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, broadcast,
2641 dpp_auth_deinit(wpa_s->dpp_auth);
2642 wpa_s->dpp_auth = NULL;
2648 wpas_dpp_rx_reconfig_auth_resp(struct wpa_supplicant *wpa_s, const u8 *src,
2652 struct dpp_authentication *auth = wpa_s->dpp_auth;
2674 eloop_cancel_timeout(wpas_dpp_reconfig_reply_wait_timeout, wpa_s, NULL);
2676 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
2678 if (offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, broadcast,
2682 dpp_auth_deinit(wpa_s->dpp_auth);
2683 wpa_s->dpp_auth = NULL;
2688 wpas_dpp_start_gas_server(wpa_s);
2693 wpas_dpp_rx_reconfig_auth_conf(struct wpa_supplicant *wpa_s, const u8 *src,
2697 struct dpp_authentication *auth = wpa_s->dpp_auth;
2717 wpas_dpp_start_gas_client(wpa_s);
2723 static void wpas_dpp_rx_peer_disc_resp(struct wpa_supplicant *wpa_s,
2745 if (is_zero_ether_addr(wpa_s->dpp_intro_bssid) ||
2746 !ether_addr_equal(src, wpa_s->dpp_intro_bssid)) {
2751 offchannel_send_action_done(wpa_s);
2753 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
2754 if (ssid == wpa_s->dpp_intro_network)
2771 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2779 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2787 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2795 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2798 wpas_dpp_send_conn_status_result(wpa_s, status[0]);
2807 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2821 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2824 wpas_dpp_send_conn_status_result(wpa_s, res);
2833 os_memcpy(entry->spa, wpa_s->own_addr, ETH_ALEN);
2849 wpas_dpp_send_conn_status_result(wpa_s, DPP_STATUS_NO_MATCH);
2865 wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry);
2867 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
2872 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
2873 wpa_supplicant_cancel_sched_scan(wpa_s);
2874 wpa_supplicant_req_scan(wpa_s, 0, 0);
2881 static int wpas_dpp_allow_ir(struct wpa_supplicant *wpa_s, unsigned int freq)
2885 if (!wpa_s->hw.modes)
2888 for (i = 0; i < wpa_s->hw.num_modes; i++) {
2889 struct hostapd_hw_modes *mode = &wpa_s->hw.modes[i];
2914 static int wpas_dpp_pkex_next_channel(struct wpa_supplicant *wpa_s,
2926 if (wpas_dpp_allow_ir(wpa_s, pkex->freq) == 1) {
2933 return wpas_dpp_pkex_next_channel(wpa_s, pkex);
2937 static void wpas_dpp_pkex_clear_code(struct wpa_supplicant *wpa_s)
2939 if (!wpa_s->dpp_pkex_code && !wpa_s->dpp_pkex_identifier)
2946 os_free(wpa_s->dpp_pkex_code);
2947 wpa_s->dpp_pkex_code = NULL;
2948 os_free(wpa_s->dpp_pkex_identifier);
2949 wpa_s->dpp_pkex_identifier = NULL;
2958 struct wpa_supplicant *wpa_s = ctx;
2965 wpas_dpp_pkex_clear_code(wpa_s);
2968 wpa_s->dpp_pkex_auth_cmd ? wpa_s->dpp_pkex_auth_cmd : "");
2975 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
3004 auth = dpp_auth_init(wpa_s->dpp, wpa_s, peer_bi, own_bi, allowed_roles,
3005 0, wpa_s->hw.modes, wpa_s->hw.num_modes);
3009 wpas_dpp_set_testing_options(wpa_s, auth);
3015 return dpp_tcp_auth(wpa_s->dpp, conn, auth, wpa_s->conf->dpp_name,
3017 wpa_s->conf->dpp_mud_url,
3018 wpa_s->conf->dpp_extra_conf_req_name,
3019 wpa_s->conf->dpp_extra_conf_req_value,
3026 static int wpas_dpp_pkex_init(struct wpa_supplicant *wpa_s,
3037 dpp_pkex_free(wpa_s->dpp_pkex);
3038 wpa_s->dpp_pkex = NULL;
3039 pkex = dpp_pkex_init(wpa_s, wpa_s->dpp_pkex_bi, wpa_s->own_addr,
3040 wpa_s->dpp_pkex_identifier,
3041 wpa_s->dpp_pkex_code, wpa_s->dpp_pkex_code_len,
3049 return dpp_tcp_pkex_init(wpa_s->dpp, pkex, ipaddr, tcp_port,
3050 wpa_s, wpa_s, wpas_dpp_pkex_done);
3056 wpa_s->dpp_pkex = pkex;
3058 wait_time = wpa_s->max_remain_on_chan;
3062 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR
3067 offchannel_send_action(wpa_s, pkex->freq, broadcast,
3068 wpa_s->own_addr, broadcast,
3082 struct wpa_supplicant *wpa_s = eloop_ctx;
3083 struct dpp_pkex *pkex = wpa_s->dpp_pkex;
3088 if (wpas_dpp_pkex_next_channel(wpa_s, pkex) < 0) {
3093 wpas_dpp_pkex_init(wpa_s, PKEX_VER_ONLY_1,
3098 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_FAIL
3101 wpa_s->dpp_pkex = NULL;
3110 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
3114 offchannel_send_action(wpa_s, pkex->freq, broadcast,
3115 wpa_s->own_addr, broadcast,
3124 wpas_dpp_tx_pkex_status(struct wpa_supplicant *wpa_s,
3131 struct dpp_pkex *pkex = wpa_s->dpp_pkex;
3139 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
3154 wpa_s->dpp_pkex = NULL;
3161 eloop_cancel_timeout(wpas_dpp_pkex_retry_timeout, wpa_s, NULL);
3164 wpas_dpp_pkex_retry_timeout, wpa_s,
3171 wpas_dpp_rx_pkex_exchange_req(struct wpa_supplicant *wpa_s, const u8 *src,
3181 if (wpa_s->dpp_pkex_ver == PKEX_VER_ONLY_1 && v2) {
3186 if (wpa_s->dpp_pkex_ver == PKEX_VER_ONLY_2 && !v2) {
3195 if (!wpa_s->dpp_pkex_code || !wpa_s->dpp_pkex_bi) {
3202 if (dpp_controller_is_own_pkex_req(wpa_s->dpp, buf, len)) {
3209 if (wpa_s->dpp_pkex) {
3216 wpa_s->dpp_pkex = dpp_pkex_rx_exchange_req(wpa_s, wpa_s->dpp_pkex_bi,
3217 wpa_s->own_addr, src,
3218 wpa_s->dpp_pkex_identifier,
3219 wpa_s->dpp_pkex_code,
3220 wpa_s->dpp_pkex_code_len,
3222 if (!wpa_s->dpp_pkex) {
3229 if (wpa_s->dpp_pb_bi && wpa_s->dpp_pb_announcement) {
3232 wpabuf_free(wpa_s->dpp_pb_announcement);
3233 wpa_s->dpp_pb_announcement = NULL;
3236 wpa_s->dpp_pkex_wait_auth_req = false;
3237 msg = wpa_s->dpp_pkex->exchange_resp;
3238 wait_time = wpa_s->max_remain_on_chan;
3241 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
3243 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr,
3251 wpas_dpp_rx_pkex_exchange_resp(struct wpa_supplicant *wpa_s, const u8 *src,
3263 if (!wpa_s->dpp_pkex || !wpa_s->dpp_pkex->initiator ||
3264 wpa_s->dpp_pkex->exchange_done) {
3269 eloop_cancel_timeout(wpas_dpp_pkex_retry_timeout, wpa_s, NULL);
3270 wpa_s->dpp_pkex->exch_req_wait_time = 0;
3272 msg = dpp_pkex_rx_exchange_resp(wpa_s->dpp_pkex, src, buf, len);
3281 wait_time = wpa_s->max_remain_on_chan;
3284 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
3286 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr,
3295 wpas_dpp_pkex_finish(struct wpa_supplicant *wpa_s, const u8 *peer,
3300 wpas_dpp_pkex_clear_code(wpa_s);
3301 bi = dpp_pkex_finish(wpa_s->dpp, wpa_s->dpp_pkex, peer, freq);
3305 wpa_s->dpp_pkex = NULL;
3308 if (wpa_s->dpp_pb_bi && !wpa_s->dpp_pb_configurator &&
3309 os_memcmp(bi->pubkey_hash_chirp, wpa_s->dpp_pb_init_hash,
3320 wpa_s->dpp_pb_init_hash, SHA256_MAC_LEN);
3323 dpp_bootstrap_remove(wpa_s->dpp, id);
3324 wpas_dpp_push_button_stop(wpa_s);
3334 wpas_dpp_rx_pkex_commit_reveal_req(struct wpa_supplicant *wpa_s, const u8 *src,
3340 struct dpp_pkex *pkex = wpa_s->dpp_pkex;
3357 dpp_pkex_free(wpa_s->dpp_pkex);
3358 wpa_s->dpp_pkex = NULL;
3366 wait_time = wpa_s->max_remain_on_chan;
3369 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
3371 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr,
3377 wpas_dpp_pkex_finish(wpa_s, src, freq);
3378 wpa_s->dpp_pkex_wait_auth_req = true;
3383 wpas_dpp_rx_pkex_commit_reveal_resp(struct wpa_supplicant *wpa_s, const u8 *src,
3389 struct dpp_pkex *pkex = wpa_s->dpp_pkex;
3406 bi = wpas_dpp_pkex_finish(wpa_s, src, freq);
3411 if (wpa_s->dpp_pb_bi && wpa_s->dpp_pb_configurator &&
3412 os_memcmp(bi->pubkey_hash_chirp, wpa_s->dpp_pb_resp_hash,
3423 wpa_s->dpp_pb_resp_hash, SHA256_MAC_LEN);
3426 dpp_bootstrap_remove(wpa_s->dpp, id);
3427 wpas_dpp_push_button_stop(wpa_s);
3434 wpa_s->dpp_pkex_auth_cmd ? wpa_s->dpp_pkex_auth_cmd : "");
3438 if (wpas_dpp_auth_init(wpa_s, cmd) < 0) {
3441 offchannel_send_action_done(wpa_s);
3449 static void wpas_dpp_pb_pkex_init(struct wpa_supplicant *wpa_s,
3458 if (wpa_s->dpp_pkex) {
3462 msg = wpa_s->dpp_pkex->exchange_req;
3463 wpa_s->max_remain_on_chan;
3466 offchannel_send_action(wpa_s, freq, src,
3467 wpa_s->own_addr, broadcast,
3476 if (!wpa_s->dpp_pb_cmd) {
3479 wpas_dpp_push_button_stop(wpa_s);
3483 wpa_s->dpp_pkex_bi = wpa_s->dpp_pb_bi;
3484 os_memcpy(wpa_s->dpp_pb_resp_hash, r_hash, SHA256_MAC_LEN);
3486 pkex = dpp_pkex_init(wpa_s, wpa_s->dpp_pkex_bi, wpa_s->own_addr,
3487 "PBPKEX", (const char *) wpa_s->dpp_pb_c_nonce,
3488 wpa_s->dpp_pb_bi->curve->nonce_len,
3491 wpas_dpp_push_button_stop(wpa_s);
3496 wpa_s->dpp_pkex = pkex;
3497 msg = wpa_s->dpp_pkex->exchange_req;
3498 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR
3501 wait_time = wpa_s->max_remain_on_chan;
3504 offchannel_send_action(wpa_s, pkex->freq, src,
3505 wpa_s->own_addr, broadcast,
3512 os_free(wpa_s->dpp_pkex_auth_cmd);
3513 len = 30 + os_strlen(wpa_s->dpp_pb_cmd);
3514 wpa_s->dpp_pkex_auth_cmd = os_malloc(len);
3515 if (wpa_s->dpp_pkex_auth_cmd)
3516 os_snprintf(wpa_s->dpp_pkex_auth_cmd, len, " own=%d %s",
3517 wpa_s->dpp_pkex_bi->id, wpa_s->dpp_pb_cmd);
3519 wpas_dpp_push_button_stop(wpa_s);
3524 wpas_dpp_rx_pb_presence_announcement(struct wpa_supplicant *wpa_s,
3552 info = &wpa_s->dpp_pb[i];
3564 tmp = &wpa_s->dpp_pb[i];
3580 if (!wpa_s->dpp_pb_result_indicated &&
3581 wpas_dpp_pb_active(wpa_s)) {
3582 wpa_msg(wpa_s, MSG_INFO,
3584 wpa_s->dpp_pb_result_indicated = true;
3586 wpas_dpp_push_button_stop(wpa_s);
3591 info = &wpa_s->dpp_pb[0];
3593 tmp = &wpa_s->dpp_pb[i];
3602 if (!wpas_dpp_pb_active(wpa_s)) {
3608 if (wpa_s->dpp_pb_announce_time.sec == 0 &&
3609 wpa_s->dpp_pb_announce_time.usec == 0) {
3611 wpa_s->dpp_pb_announce_time = now;
3614 if (!wpa_s->dpp_pb_bi) {
3617 res = dpp_bootstrap_gen(wpa_s->dpp, "type=pkex");
3620 wpa_s->dpp_pb_bi = dpp_bootstrap_get_id(wpa_s->dpp, res);
3621 if (!wpa_s->dpp_pb_bi)
3624 if (random_get_bytes(wpa_s->dpp_pb_c_nonce,
3625 wpa_s->dpp_pb_bi->curve->nonce_len)) {
3628 wpas_dpp_push_button_stop(wpa_s);
3636 os_reltime_sub(&now, &wpa_s->dpp_pb_last_resp, &age);
3644 wpa_s->dpp_pb_bi, r_hash, wpa_s->dpp_pb_c_nonce,
3645 wpa_s->dpp_pb_bi->curve->nonce_len);
3647 wpas_dpp_push_button_stop(wpa_s);
3654 wpa_s->dpp_pb_last_resp = now;
3656 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
3658 offchannel_send_action(wpa_s, freq, src, wpa_s->own_addr, broadcast,
3663 if (os_reltime_expired(&now, &wpa_s->dpp_pb_announce_time, 15))
3664 wpas_dpp_pb_pkex_init(wpa_s, freq, src, r_hash);
3669 wpas_dpp_rx_pb_presence_announcement_resp(struct wpa_supplicant *wpa_s,
3678 if (!wpa_s->dpp_pb_announcement || !wpa_s->dpp_pb_bi ||
3679 wpa_s->dpp_pb_configurator) {
3712 os_memcmp(r_hash, wpa_s->dpp_pb_bi->pubkey_hash_chirp,
3716 if (os_memcmp(r_hash, wpa_s->dpp_pb_bi->pubkey_hash_chirp,
3726 if (wpa_s->dpp_pb_resp_freq &&
3727 os_memcmp(i_hash, wpa_s->dpp_pb_init_hash, SHA256_MAC_LEN) != 0) {
3734 if (!wpa_s->dpp_pb_result_indicated) {
3735 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT
3737 wpa_s->dpp_pb_result_indicated = true;
3739 wpas_dpp_push_button_stop(wpa_s);
3743 if (!wpa_s->dpp_pb_resp_freq) {
3744 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_STATUS
3747 wpa_s->dpp_pb_resp_freq = freq;
3748 os_memcpy(wpa_s->dpp_pb_init_hash, i_hash, SHA256_MAC_LEN);
3749 os_memcpy(wpa_s->dpp_pb_c_nonce, c_nonce, c_nonce_len);
3750 wpa_s->dpp_pb_c_nonce_len = c_nonce_len;
3754 wpa_s->dpp_pb_stop_iter = 3;
3760 wpas_dpp_tx_priv_intro_status(struct wpa_supplicant *wpa_s,
3774 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
3777 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR " version=%u",
3778 MAC2STR(src), wpa_s->dpp_intro_peer_version);
3782 if (wpa_supplicant_fast_associate(wpa_s) != 1) {
3783 wpa_supplicant_cancel_sched_scan(wpa_s);
3784 wpa_supplicant_req_scan(wpa_s, 0, 0);
3790 wpas_dpp_send_private_peer_intro_update(struct wpa_supplicant *wpa_s,
3873 wait_time = wpa_s->max_remain_on_chan;
3876 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
3878 offchannel_send_action(wpa_s, freq, dst, wpa_s->own_addr, broadcast,
3888 wpas_dpp_rx_priv_peer_intro_notify(struct wpa_supplicant *wpa_s,
3909 if (is_zero_ether_addr(wpa_s->dpp_intro_bssid) ||
3910 !ether_addr_equal(src, wpa_s->dpp_intro_bssid)) {
3915 offchannel_send_action_done(wpa_s);
3917 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
3918 if (ssid == wpa_s->dpp_intro_network)
3933 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
3941 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
3950 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
3960 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
3974 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_INTRO "peer=" MACSTR
3976 wpas_dpp_send_conn_status_result(wpa_s, res);
3986 wpas_dpp_send_conn_status_result(wpa_s, DPP_STATUS_NO_MATCH);
3989 wpa_s->dpp_intro_peer_version = peer_version;
3996 os_memcpy(entry->spa, wpa_s->own_addr, ETH_ALEN);
4008 if (wpas_dpp_send_private_peer_intro_update(wpa_s, &intro, ssid, src,
4018 wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry);
4030 void wpas_dpp_rx_action(struct wpa_supplicant *wpa_s, const u8 *src,
4054 if (wpa_s->dpp_discard_public_action &&
4065 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR
4072 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR
4077 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_RX "src=" MACSTR " freq=%u type=%d",
4082 wpas_dpp_rx_auth_req(wpa_s, src, hdr, buf, len, freq);
4085 wpas_dpp_rx_auth_resp(wpa_s, src, hdr, buf, len, freq);
4088 wpas_dpp_rx_auth_conf(wpa_s, src, hdr, buf, len);
4091 wpas_dpp_rx_peer_disc_resp(wpa_s, src, buf, len);
4098 wpas_dpp_rx_pkex_exchange_req(wpa_s, src, buf, len, freq, true);
4102 wpas_dpp_rx_pkex_exchange_req(wpa_s, src, buf, len, freq,
4106 wpas_dpp_rx_pkex_exchange_resp(wpa_s, src, buf, len, freq);
4109 wpas_dpp_rx_pkex_commit_reveal_req(wpa_s, src, hdr, buf, len,
4113 wpas_dpp_rx_pkex_commit_reveal_resp(wpa_s, src, hdr, buf, len,
4118 wpas_dpp_rx_conf_result(wpa_s, src, hdr, buf, len);
4121 wpas_dpp_rx_conn_status_result(wpa_s, src, hdr, buf, len);
4124 wpas_dpp_rx_presence_announcement(wpa_s, src, hdr, buf, len,
4128 wpas_dpp_rx_reconfig_announcement(wpa_s, src, hdr, buf, len,
4132 wpas_dpp_rx_reconfig_auth_req(wpa_s, src, hdr, buf, len, freq);
4135 wpas_dpp_rx_reconfig_auth_resp(wpa_s, src, hdr, buf, len, freq);
4138 wpas_dpp_rx_reconfig_auth_conf(wpa_s, src, hdr, buf, len, freq);
4143 wpas_dpp_rx_pb_presence_announcement(wpa_s, src, hdr,
4147 wpas_dpp_rx_pb_presence_announcement_resp(wpa_s, src, hdr,
4151 wpas_dpp_rx_priv_peer_intro_notify(wpa_s, src, hdr,
4161 if (wpa_s->dpp_pkex)
4162 pkex_t = wpa_s->dpp_pkex->t;
4163 else if (wpa_s->dpp_pkex_bi)
4164 pkex_t = wpa_s->dpp_pkex_bi->pkex_t;
4168 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PKEX_T_LIMIT "id=0");
4169 wpas_dpp_pkex_remove(wpa_s, "*");
4177 struct wpa_supplicant *wpa_s = eloop_ctx;
4178 struct dpp_authentication *auth = wpa_s->dpp_auth;
4185 gas_server_set_comeback_delay(wpa_s->gas_server, auth->config_resp_ctx,
4194 struct wpa_supplicant *wpa_s = ctx;
4195 struct dpp_authentication *auth = wpa_s->dpp_auth;
4206 if (wpa_s->dpp_auth_ok_on_ack && auth->configurator) {
4214 wpa_s->dpp_auth_ok_on_ack = 0;
4227 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_REQ_RX "src=" MACSTR,
4280 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_NEEDED "peer=%d src="
4287 eloop_cancel_timeout(wpas_dpp_gas_initial_resp_timeout, wpa_s,
4290 wpas_dpp_gas_initial_resp_timeout, wpa_s,
4297 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
4298 dpp_auth_deinit(wpa_s->dpp_auth);
4299 wpa_s->dpp_auth = NULL;
4308 struct wpa_supplicant *wpa_s = ctx;
4309 struct dpp_authentication *auth = wpa_s->dpp_auth;
4341 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
4342 eloop_cancel_timeout(wpas_dpp_auth_conf_wait_timeout, wpa_s, NULL);
4343 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL);
4353 wpa_s, NULL);
4356 wpa_s, NULL);
4360 offchannel_send_action_done(wpa_s);
4361 wpas_dpp_listen_stop(wpa_s);
4363 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT "conf_status=%d",
4366 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
4367 dpp_auth_deinit(wpa_s->dpp_auth);
4368 wpa_s->dpp_auth = NULL;
4371 if (!wpa_s->dpp_pb_result_indicated && wpas_dpp_pb_active(wpa_s)) {
4373 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT
4376 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT
4378 wpa_s->dpp_pb_result_indicated = true;
4380 wpas_dpp_remove_pb_hash(wpa_s);
4381 wpas_dpp_push_button_stop(wpa_s);
4387 int wpas_dpp_configurator_sign(struct wpa_supplicant *wpa_s, const char *cmd)
4393 auth = dpp_alloc_auth(wpa_s->dpp, wpa_s);
4398 wpas_dpp_set_testing_options(wpa_s, auth);
4401 ret = wpas_dpp_handle_config_obj(wpa_s, auth,
4404 wpas_dpp_post_process_config(wpa_s, auth);
4414 wpas_dpp_tx_introduction_status(struct wpa_supplicant *wpa_s,
4428 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX_STATUS "dst=" MACSTR
4435 static int wpas_dpp_start_private_peer_intro(struct wpa_supplicant *wpa_s,
4471 wait_time = wpa_s->max_remain_on_chan;
4474 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
4476 offchannel_send_action(wpa_s, bss->freq, bss->bssid, wpa_s->own_addr,
4484 os_memcpy(wpa_s->dpp_intro_bssid, bss->bssid, ETH_ALEN);
4485 wpa_s->dpp_intro_network = ssid;
4491 int wpas_dpp_check_connect(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
4507 if (wpa_sm_pmksa_exists(wpa_s->wpa, bss->bssid, wpa_s->own_addr, ssid))
4512 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_MISSING_CONNECTOR
4524 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_MISSING_CONNECTOR
4534 if (wpa_s->wpa_state == WPA_SCANNING)
4535 wpa_supplicant_set_state(wpa_s, wpa_s->scan_prev_wpa_state);
4539 return wpas_dpp_start_private_peer_intro(wpa_s, ssid, bss);
4639 wait_time = wpa_s->max_remain_on_chan;
4642 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
4644 offchannel_send_action(wpa_s, bss->freq, bss->bssid, wpa_s->own_addr,
4652 os_memcpy(wpa_s->dpp_intro_bssid, bss->bssid, ETH_ALEN);
4653 wpa_s->dpp_intro_network = ssid;
4658 int wpas_dpp_pkex_add(struct wpa_supplicant *wpa_s, const char *cmd)
4695 own_bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
4706 wpa_s->dpp_pkex_bi = own_bi;
4709 os_free(wpa_s->dpp_pkex_identifier);
4710 wpa_s->dpp_pkex_identifier = NULL;
4717 wpa_s->dpp_pkex_identifier = os_malloc(end - pos + 1);
4718 if (!wpa_s->dpp_pkex_identifier)
4720 os_memcpy(wpa_s->dpp_pkex_identifier, pos, end - pos);
4721 wpa_s->dpp_pkex_identifier[end - pos] = '\0';
4727 os_free(wpa_s->dpp_pkex_code);
4728 wpa_s->dpp_pkex_code = os_strdup(pos + 6);
4729 if (!wpa_s->dpp_pkex_code)
4731 wpa_s->dpp_pkex_code_len = os_strlen(wpa_s->dpp_pkex_code);
4746 wpa_s->dpp_pkex_ver = ver;
4749 if (wpas_dpp_pkex_init(wpa_s, ver, ipaddr, tcp_port) < 0)
4753 dpp_controller_pkex_add(wpa_s->dpp, own_bi,
4754 wpa_s->dpp_pkex_code,
4755 wpa_s->dpp_pkex_identifier);
4761 os_free(wpa_s->dpp_pkex_auth_cmd);
4762 wpa_s->dpp_pkex_auth_cmd = os_strdup(cmd);
4768 int wpas_dpp_pkex_remove(struct wpa_supplicant *wpa_s, const char *id)
4784 os_free(wpa_s->dpp_pkex_code);
4785 wpa_s->dpp_pkex_code = NULL;
4786 os_free(wpa_s->dpp_pkex_identifier);
4787 wpa_s->dpp_pkex_identifier = NULL;
4788 os_free(wpa_s->dpp_pkex_auth_cmd);
4789 wpa_s->dpp_pkex_auth_cmd = NULL;
4790 wpa_s->dpp_pkex_bi = NULL;
4792 dpp_pkex_free(wpa_s->dpp_pkex);
4793 wpa_s->dpp_pkex = NULL;
4798 void wpas_dpp_stop(struct wpa_supplicant *wpa_s)
4800 if (wpa_s->dpp_auth || wpa_s->dpp_pkex || wpa_s->dpp_pkex_wait_auth_req)
4801 offchannel_send_action_done(wpa_s);
4802 dpp_auth_deinit(wpa_s->dpp_auth);
4803 wpa_s->dpp_auth = NULL;
4804 dpp_pkex_free(wpa_s->dpp_pkex);
4805 wpa_s->dpp_pkex = NULL;
4806 wpa_s->dpp_pkex_wait_auth_req = false;
4807 if (wpa_s->dpp_gas_client && wpa_s->dpp_gas_dialog_token >= 0)
4808 gas_query_stop(wpa_s->gas, wpa_s->dpp_gas_dialog_token);
4810 wpas_dpp_push_button_stop(wpa_s);
4815 int wpas_dpp_init(struct wpa_supplicant *wpa_s)
4826 if (gas_server_register(wpa_s->gas_server, adv_proto_id,
4828 wpas_dpp_gas_status_handler, wpa_s) < 0)
4832 config.cb_ctx = wpa_s;
4836 wpa_s->dpp = dpp_global_init(&config);
4837 return wpa_s->dpp ? 0 : -1;
4841 void wpas_dpp_deinit(struct wpa_supplicant *wpa_s)
4844 os_free(wpa_s->dpp_config_obj_override);
4845 wpa_s->dpp_config_obj_override = NULL;
4846 os_free(wpa_s->dpp_discovery_override);
4847 wpa_s->dpp_discovery_override = NULL;
4848 os_free(wpa_s->dpp_groups_override);
4849 wpa_s->dpp_groups_override = NULL;
4850 wpa_s->dpp_ignore_netaccesskey_mismatch = 0;
4852 if (!wpa_s->dpp)
4854 eloop_cancel_timeout(wpas_dpp_pkex_retry_timeout, wpa_s, NULL);
4855 eloop_cancel_timeout(wpas_dpp_reply_wait_timeout, wpa_s, NULL);
4856 eloop_cancel_timeout(wpas_dpp_auth_conf_wait_timeout, wpa_s, NULL);
4857 eloop_cancel_timeout(wpas_dpp_init_timeout, wpa_s, NULL);
4858 eloop_cancel_timeout(wpas_dpp_auth_resp_retry_timeout, wpa_s, NULL);
4859 eloop_cancel_timeout(wpas_dpp_gas_initial_resp_timeout, wpa_s, NULL);
4860 eloop_cancel_timeout(wpas_dpp_gas_client_timeout, wpa_s, NULL);
4861 eloop_cancel_timeout(wpas_dpp_drv_wait_timeout, wpa_s, NULL);
4862 eloop_cancel_timeout(wpas_dpp_tx_auth_resp_roc_timeout, wpa_s, NULL);
4863 eloop_cancel_timeout(wpas_dpp_neg_freq_timeout, wpa_s, NULL);
4865 eloop_cancel_timeout(wpas_dpp_config_result_wait_timeout, wpa_s, NULL);
4867 wpa_s, NULL);
4868 eloop_cancel_timeout(wpas_dpp_conn_status_result_timeout, wpa_s, NULL);
4870 wpa_s, NULL);
4871 eloop_cancel_timeout(wpas_dpp_build_csr, wpa_s, NULL);
4872 eloop_cancel_timeout(wpas_dpp_connected_timeout, wpa_s, NULL);
4873 dpp_pfs_free(wpa_s->dpp_pfs);
4874 wpa_s->dpp_pfs = NULL;
4875 wpas_dpp_chirp_stop(wpa_s);
4876 dpp_free_reconfig_id(wpa_s->dpp_reconfig_id);
4877 wpa_s->dpp_reconfig_id = NULL;
4880 eloop_cancel_timeout(wpas_dpp_build_new_key, wpa_s, NULL);
4882 offchannel_send_action_done(wpa_s);
4883 wpas_dpp_listen_stop(wpa_s);
4884 wpas_dpp_stop(wpa_s);
4885 wpas_dpp_pkex_remove(wpa_s, "*");
4886 os_memset(wpa_s->dpp_intro_bssid, 0, ETH_ALEN);
4887 os_free(wpa_s->dpp_configurator_params);
4888 wpa_s->dpp_configurator_params = NULL;
4889 dpp_global_clear(wpa_s->dpp);
4893 static int wpas_dpp_build_conf_resp(struct wpa_supplicant *wpa_s,
4908 eloop_cancel_timeout(wpas_dpp_gas_initial_resp_timeout, wpa_s, NULL);
4909 if (gas_server_set_resp(wpa_s->gas_server, auth->config_resp_ctx,
4921 int wpas_dpp_conf_set(struct wpa_supplicant *wpa_s, const char *cmd)
4925 struct dpp_authentication *auth = wpa_s->dpp_auth;
4936 auth = dpp_controller_get_auth(wpa_s->dpp, peer);
4957 eloop_cancel_timeout(wpas_dpp_gas_initial_resp_timeout, wpa_s,
4959 gas_server_set_comeback_delay(wpa_s->gas_server,
4970 return wpas_dpp_build_conf_resp(wpa_s, auth, tcp);
4976 int wpas_dpp_controller_start(struct wpa_supplicant *wpa_s, const char *cmd)
4984 config.msg_ctx = wpa_s;
4985 config.cb_ctx = wpa_s;
5011 config.configurator_params = wpa_s->dpp_configurator_params;
5012 return dpp_controller_start(wpa_s->dpp, &config);
5020 struct wpa_supplicant *wpa_s = eloop_ctx;
5023 offchannel_send_action_done(wpa_s);
5024 wpas_dpp_chirp_next(wpa_s, NULL);
5028 static void wpas_dpp_chirp_tx_status(struct wpa_supplicant *wpa_s,
5036 wpa_s->dpp_chirp_freq);
5038 wpa_s, NULL) < 0)
5039 wpas_dpp_chirp_stop(wpa_s);
5045 wpa_s, NULL) < 0)
5046 wpas_dpp_chirp_stop(wpa_s);
5050 static void wpas_dpp_chirp_start(struct wpa_supplicant *wpa_s)
5055 msg = wpa_s->dpp_presence_announcement;
5058 struct wpa_ssid *ssid = wpa_s->dpp_reconfig_ssid;
5060 if (ssid && wpa_s->dpp_reconfig_id &&
5061 wpa_config_get_network(wpa_s->conf,
5062 wpa_s->dpp_reconfig_ssid_id) ==
5069 wpa_s->dpp_reconfig_id);
5076 wpa_printf(MSG_DEBUG, "DPP: Chirp on %d MHz", wpa_s->dpp_chirp_freq);
5077 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_TX "dst=" MACSTR " freq=%u type=%d",
5078 MAC2STR(broadcast), wpa_s->dpp_chirp_freq, type);
5080 wpa_s, wpa_s->dpp_chirp_freq, broadcast,
5081 wpa_s->own_addr, broadcast,
5084 wpas_dpp_chirp_stop(wpa_s);
5090 static int * wpas_dpp_presence_ann_channels(struct wpa_supplicant *wpa_s,
5097 bool chan6 = wpa_s->hw.modes == NULL;
5107 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
5123 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
5145 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
5162 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
5171 wpa_s,
5174 struct dpp_bootstrap_info *bi = wpa_s->dpp_chirp_bi;
5176 if (!bi && !wpa_s->dpp_reconfig_ssid)
5179 wpa_s->dpp_chirp_scan_done = 1;
5181 os_free(wpa_s->dpp_chirp_freqs);
5182 wpa_s->dpp_chirp_freqs = wpas_dpp_presence_ann_channels(wpa_s, bi);
5184 if (!wpa_s->dpp_chirp_freqs ||
5185 eloop_register_timeout(0, 0, wpas_dpp_chirp_next, wpa_s, NULL) < 0)
5186 wpas_dpp_chirp_stop(wpa_s);
5192 struct wpa_supplicant *wpa_s = eloop_ctx;
5195 if (wpa_s->dpp_chirp_listen)
5196 wpas_dpp_listen_stop(wpa_s);
5198 if (wpa_s->dpp_chirp_freq == 0) {
5199 if (wpa_s->dpp_chirp_round % 4 == 0 &&
5200 !wpa_s->dpp_chirp_scan_done) {
5201 if (wpas_scan_scheduled(wpa_s)) {
5206 wpa_s, NULL) < 0) {
5207 wpas_dpp_chirp_stop(wpa_s);
5214 wpa_s->scan_req = MANUAL_SCAN_REQ;
5215 wpa_s->scan_res_handler =
5217 wpa_supplicant_req_scan(wpa_s, 0, 0);
5220 wpa_s->dpp_chirp_freq = wpa_s->dpp_chirp_freqs[0];
5221 wpa_s->dpp_chirp_round++;
5223 wpa_s->dpp_chirp_round);
5225 for (i = 0; wpa_s->dpp_chirp_freqs[i]; i++)
5226 if (wpa_s->dpp_chirp_freqs[i] == wpa_s->dpp_chirp_freq)
5228 if (!wpa_s->dpp_chirp_freqs[i]) {
5231 wpa_s->dpp_chirp_freq);
5235 if (wpa_s->dpp_chirp_freqs[i]) {
5236 wpa_s->dpp_chirp_freq = wpa_s->dpp_chirp_freqs[i];
5238 wpa_s->dpp_chirp_iter--;
5239 if (wpa_s->dpp_chirp_iter <= 0) {
5242 wpas_dpp_chirp_stop(wpa_s);
5245 wpa_s->dpp_chirp_freq = 0;
5246 wpa_s->dpp_chirp_scan_done = 0;
5248 wpa_s, NULL) < 0) {
5249 wpas_dpp_chirp_stop(wpa_s);
5252 if (wpa_s->dpp_chirp_listen) {
5255 wpa_s->dpp_chirp_listen);
5256 wpas_dpp_listen_start(wpa_s,
5257 wpa_s->dpp_chirp_listen);
5266 wpas_dpp_chirp_start(wpa_s);
5270 int wpas_dpp_chirp(struct wpa_supplicant *wpa_s, const char *cmd)
5280 bi = dpp_bootstrap_get_id(wpa_s->dpp, atoi(pos));
5301 wpas_dpp_chirp_stop(wpa_s);
5302 wpa_s->dpp_allowed_roles = DPP_CAPAB_ENROLLEE;
5303 wpa_s->dpp_netrole = DPP_NETROLE_STA;
5304 wpa_s->dpp_qr_mutual = 0;
5305 wpa_s->dpp_chirp_bi = bi;
5306 wpa_s->dpp_presence_announcement = dpp_build_presence_announcement(bi);
5307 if (!wpa_s->dpp_presence_announcement)
5309 wpa_s->dpp_chirp_iter = iter;
5310 wpa_s->dpp_chirp_round = 0;
5311 wpa_s->dpp_chirp_scan_done = 0;
5312 wpa_s->dpp_chirp_listen = listen_freq;
5314 return eloop_register_timeout(0, 0, wpas_dpp_chirp_next, wpa_s, NULL);
5318 void wpas_dpp_chirp_stop(struct wpa_supplicant *wpa_s)
5320 if (wpa_s->dpp_presence_announcement ||
5321 wpa_s->dpp_reconfig_ssid) {
5322 offchannel_send_action_done(wpa_s);
5323 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CHIRP_STOPPED);
5325 wpa_s->dpp_chirp_bi = NULL;
5326 wpabuf_free(wpa_s->dpp_presence_announcement);
5327 wpa_s->dpp_presence_announcement = NULL;
5328 if (wpa_s->dpp_chirp_listen)
5329 wpas_dpp_listen_stop(wpa_s);
5330 wpa_s->dpp_chirp_listen = 0;
5331 wpa_s->dpp_chirp_freq = 0;
5332 os_free(wpa_s->dpp_chirp_freqs);
5333 wpa_s->dpp_chirp_freqs = NULL;
5334 eloop_cancel_timeout(wpas_dpp_chirp_next, wpa_s, NULL);
5335 eloop_cancel_timeout(wpas_dpp_chirp_timeout, wpa_s, NULL);
5336 if (wpa_s->scan_res_handler == wpas_dpp_chirp_scan_res_handler) {
5337 wpas_abort_ongoing_scan(wpa_s);
5338 wpa_s->scan_res_handler = NULL;
5343 int wpas_dpp_reconfig(struct wpa_supplicant *wpa_s, const char *cmd)
5349 ssid = wpa_config_get_network(wpa_s->conf, atoi(cmd));
5364 if (wpa_s->dpp_auth) {
5370 dpp_free_reconfig_id(wpa_s->dpp_reconfig_id);
5371 wpa_s->dpp_reconfig_id = dpp_gen_reconfig_id(ssid->dpp_csign,
5375 if (!wpa_s->dpp_reconfig_id) {
5380 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
5382 wpa_s->own_disconnect_req = 1;
5384 wpa_s, WLAN_REASON_DEAUTH_LEAVING);
5386 wpas_dpp_chirp_stop(wpa_s);
5387 wpa_s->dpp_allowed_roles = DPP_CAPAB_ENROLLEE;
5388 wpa_s->dpp_netrole = DPP_NETROLE_STA;
5389 wpa_s->dpp_qr_mutual = 0;
5390 wpa_s->dpp_reconfig_ssid = ssid;
5391 wpa_s->dpp_reconfig_ssid_id = ssid->id;
5392 wpa_s->dpp_chirp_iter = iter;
5393 wpa_s->dpp_chirp_round = 0;
5394 wpa_s->dpp_chirp_scan_done = 0;
5395 wpa_s->dpp_chirp_listen = 0;
5397 return eloop_register_timeout(0, 0, wpas_dpp_chirp_next, wpa_s, NULL);
5401 int wpas_dpp_ca_set(struct wpa_supplicant *wpa_s, const char *cmd)
5405 struct dpp_authentication *auth = wpa_s->dpp_auth;
5417 auth = dpp_controller_get_auth(wpa_s->dpp, peer);
5449 return wpas_dpp_build_conf_resp(wpa_s, auth, tcp);
5473 return wpas_dpp_build_conf_resp(wpa_s, auth, tcp);
5487 static int wpas_dpp_pb_announce(struct wpa_supplicant *wpa_s, int freq);
5491 static void wpas_dpp_pb_tx_status(struct wpa_supplicant *wpa_s,
5502 wpa_s, NULL) < 0)
5503 wpas_dpp_push_button_stop(wpa_s);
5509 if (wpa_s->dpp_pb_discovery_done) {
5510 wpa_s->dpp_pb_announce_count = 0;
5515 wpa_s, NULL) < 0)
5516 wpas_dpp_push_button_stop(wpa_s);
5518 } else if (wpa_s->dpp_pb_announce_count >= DPP_PB_ANNOUNCE_PER_CHAN) {
5523 wpa_s, NULL) < 0)
5524 wpas_dpp_push_button_stop(wpa_s);
5528 if (wpas_dpp_pb_announce(wpa_s, freq) < 0)
5529 wpas_dpp_push_button_stop(wpa_s);
5533 static int wpas_dpp_pb_announce(struct wpa_supplicant *wpa_s, int freq)
5538 msg = wpa_s->dpp_pb_announcement;
5542 wpa_s->dpp_pb_announce_count++;
5545 wpa_s->dpp_pb_announce_count, DPP_PB_ANNOUNCE_PER_CHAN,
5549 if (wpa_s->dpp_pb_announce_count == 1)
5550 wpa_msg(wpa_s, MSG_INFO,
5554 wpa_s, freq, broadcast, wpa_s->own_addr, broadcast,
5565 struct wpa_supplicant *wpa_s = eloop_ctx;
5569 if (!wpa_s->dpp_pb_freqs)
5573 offchannel_send_action_done(wpa_s);
5575 if (os_reltime_expired(&now, &wpa_s->dpp_pb_time, 100)) {
5577 wpas_dpp_push_button_stop(wpa_s);
5581 if (wpa_s->dpp_pb_freq_idx >= int_array_len(wpa_s->dpp_pb_freqs)) {
5584 wpa_s->dpp_pb_freq_idx = 0;
5585 if (wpa_s->dpp_pb_stop_iter > 0) {
5586 wpa_s->dpp_pb_stop_iter--;
5588 if (wpa_s->dpp_pb_stop_iter == 1) {
5589 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_STATUS
5593 wpa_s, NULL) < 0) {
5594 wpas_dpp_push_button_stop(wpa_s);
5600 if (wpa_s->dpp_pb_stop_iter == 0) {
5601 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_STATUS
5603 wpa_s->dpp_pb_resp_freq);
5604 wpa_s->dpp_pb_discovery_done = true;
5606 wpa_s->dpp_pkex_bi = wpa_s->dpp_pb_bi;
5608 os_free(wpa_s->dpp_pkex_code);
5609 wpa_s->dpp_pkex_code = os_memdup(
5610 wpa_s->dpp_pb_c_nonce,
5611 wpa_s->dpp_pb_c_nonce_len);
5612 wpa_s->dpp_pkex_code_len =
5613 wpa_s->dpp_pb_c_nonce_len;
5615 os_free(wpa_s->dpp_pkex_identifier);
5616 wpa_s->dpp_pkex_identifier =
5619 if (!wpa_s->dpp_pkex_code ||
5620 !wpa_s->dpp_pkex_identifier) {
5621 wpas_dpp_push_button_stop(wpa_s);
5625 wpa_s->dpp_pkex_ver = PKEX_VER_ONLY_2;
5627 os_free(wpa_s->dpp_pkex_auth_cmd);
5628 wpa_s->dpp_pkex_auth_cmd = NULL;
5633 if (wpa_s->dpp_pb_discovery_done)
5634 freq = wpa_s->dpp_pb_resp_freq;
5636 freq = wpa_s->dpp_pb_freqs[wpa_s->dpp_pb_freq_idx++];
5637 wpa_s->dpp_pb_announce_count = 0;
5638 if (!wpa_s->dpp_pb_announcement) {
5642 if (wpas_dpp_pb_announce(wpa_s, freq) < 0) {
5643 wpas_dpp_push_button_stop(wpa_s);
5651 struct wpa_supplicant *wpa_s = eloop_ctx;
5655 wpas_dpp_push_button_stop(wpa_s);
5659 static int wpas_dpp_push_button_configurator(struct wpa_supplicant *wpa_s,
5662 wpa_s->dpp_pb_configurator = true;
5663 wpa_s->dpp_pb_announce_time.sec = 0;
5664 wpa_s->dpp_pb_announce_time.usec = 0;
5665 str_clear_free(wpa_s->dpp_pb_cmd);
5666 wpa_s->dpp_pb_cmd = NULL;
5668 wpa_s->dpp_pb_cmd = os_strdup(cmd);
5669 if (!wpa_s->dpp_pb_cmd)
5673 wpa_s, NULL);
5675 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_STATUS "started");
5680 static void wpas_dpp_pb_scan_res_handler(struct wpa_supplicant *wpa_s,
5683 if (!wpa_s->dpp_pb_time.sec && !wpa_s->dpp_pb_time.usec)
5686 os_free(wpa_s->dpp_pb_freqs);
5687 wpa_s->dpp_pb_freqs = wpas_dpp_presence_ann_channels(wpa_s, NULL);
5690 if (!wpa_s->dpp_pb_freqs ||
5691 eloop_register_timeout(0, 0, wpas_dpp_pb_next, wpa_s, NULL) < 0)
5692 wpas_dpp_push_button_stop(wpa_s);
5696 int wpas_dpp_push_button(struct wpa_supplicant *wpa_s, const char *cmd)
5700 if (!wpa_s->dpp)
5702 wpas_dpp_push_button_stop(wpa_s);
5703 wpas_dpp_stop(wpa_s);
5704 wpas_dpp_chirp_stop(wpa_s);
5706 os_get_reltime(&wpa_s->dpp_pb_time);
5711 return wpas_dpp_push_button_configurator(wpa_s, cmd);
5713 wpa_s->dpp_pb_configurator = false;
5715 wpa_s->dpp_pb_freq_idx = 0;
5717 res = dpp_bootstrap_gen(wpa_s->dpp, "type=pkex");
5720 wpa_s->dpp_pb_bi = dpp_bootstrap_get_id(wpa_s->dpp, res);
5721 if (!wpa_s->dpp_pb_bi)
5724 wpa_s->dpp_allowed_roles = DPP_CAPAB_ENROLLEE;
5725 wpa_s->dpp_netrole = DPP_NETROLE_STA;
5726 wpa_s->dpp_qr_mutual = 0;
5727 wpa_s->dpp_pb_announcement =
5728 dpp_build_pb_announcement(wpa_s->dpp_pb_bi);
5729 if (!wpa_s->dpp_pb_announcement)
5734 wpa_s->scan_req = MANUAL_SCAN_REQ;
5735 wpa_s->scan_res_handler = wpas_dpp_pb_scan_res_handler;
5736 wpa_supplicant_req_scan(wpa_s, 0, 0);
5737 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_STATUS "started");
5742 void wpas_dpp_push_button_stop(struct wpa_supplicant *wpa_s)
5744 if (!wpa_s->dpp)
5746 os_free(wpa_s->dpp_pb_freqs);
5747 wpa_s->dpp_pb_freqs = NULL;
5748 wpabuf_free(wpa_s->dpp_pb_announcement);
5749 wpa_s->dpp_pb_announcement = NULL;
5750 if (wpa_s->dpp_pb_bi) {
5753 if (wpa_s->dpp_pb_bi == wpa_s->dpp_pkex_bi)
5754 wpa_s->dpp_pkex_bi = NULL;
5755 os_snprintf(id, sizeof(id), "%u", wpa_s->dpp_pb_bi->id);
5756 dpp_bootstrap_remove(wpa_s->dpp, id);
5757 wpa_s->dpp_pb_bi = NULL;
5758 if (!wpa_s->dpp_pb_result_indicated) {
5759 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT "failed");
5760 wpa_s->dpp_pb_result_indicated = true;
5764 wpa_s->dpp_pb_resp_freq = 0;
5765 wpa_s->dpp_pb_stop_iter = 0;
5766 wpa_s->dpp_pb_discovery_done = false;
5767 os_free(wpa_s->dpp_pb_cmd);
5768 wpa_s->dpp_pb_cmd = NULL;
5770 eloop_cancel_timeout(wpas_dpp_pb_next, wpa_s, NULL);
5771 eloop_cancel_timeout(wpas_dpp_push_button_expire, wpa_s, NULL);
5772 if (wpas_dpp_pb_active(wpa_s)) {
5774 if (!wpa_s->dpp_pb_result_indicated)
5775 wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_PB_RESULT "failed");
5777 wpa_s->dpp_pb_time.sec = 0;
5778 wpa_s->dpp_pb_time.usec = 0;
5779 dpp_pkex_free(wpa_s->dpp_pkex);
5780 wpa_s->dpp_pkex = NULL;
5781 os_free(wpa_s->dpp_pkex_auth_cmd);
5782 wpa_s->dpp_pkex_auth_cmd = NULL;
5784 wpa_s->dpp_pb_result_indicated = false;
5786 str_clear_free(wpa_s->dpp_pb_cmd);
5787 wpa_s->dpp_pb_cmd = NULL;
5789 if (wpa_s->scan_res_handler == wpas_dpp_pb_scan_res_handler) {
5790 wpa_s);
5791 wpa_s->scan_res_handler = NULL;
Indexes created Sun Apr 12 00:22:20 UTC 2026