Lines Matching +full:rx +full:- +full:level +full:- +full:trig
2 * wpa_supplicant - P2P
3 * Copyright (c) 2009-2010, Atheros Communications
4 * Copyright (c) 2010-2014, Jouni Malinen <j@w1.fi>
73 * How many seconds to wait for initial 4-way handshake to get completed after
74 * WPS provisioning step or after the re-invocation of a persistent group on a
82 * How many seconds to wait for initial 4-way handshake to get completed after
92 * How many seconds to wait for initial 4-way handshake to get completed after
93 * re-invocation of a persistent group on the GO when the client is expected
99 #define P2P_MGMT_DEVICE_PREFIX "p2p-dev-"
102 * How many seconds to wait to re-attempt to move GOs, in case previous attempt
163 enum wpas_p2p_channel_update_trig trig);
174 he_capab = mode->he_capab[WPAS_MODE_INFRA].phy_cap[
189 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
191 return -1;
194 wpa_s->num_multichan_concurrent, false);
197 unused = wpa_s->num_multichan_concurrent - num;
215 freqs = os_calloc(wpa_s->num_multichan_concurrent,
221 wpa_s->num_multichan_concurrent,
227 if (p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
242 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
246 wpa_s = wpa_s->global->p2p_init_wpa_s;
248 if (wpa_s->conf->p2p_ignore_shared_freq &&
249 freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
255 p2p_set_own_freq_preference(wpa_s->global->p2p, freq);
264 if (external_scan_running(wpa_s->radio)) {
265 delay = wpa_s->conf->p2p_search_delay;
271 p2p_scan_res_handled(wpa_s->global->p2p, delay);
280 if (wpa_s->p2p_scan_work) {
281 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
282 wpa_s->p2p_scan_work = NULL;
286 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
290 (int) scan_res->num);
292 for (i = 0; i < scan_res->num; i++) {
293 struct wpa_scan_res *bss = scan_res->res[i];
298 time_tmp_age.sec = bss->age / 1000;
299 time_tmp_age.usec = (bss->age % 1000) * 1000;
300 os_reltime_sub(&scan_res->fetch_time, &time_tmp_age, &entry_ts);
303 ies_len = bss->ie_len;
304 if (bss->beacon_ie_len > 0 &&
308 MACSTR, MAC2STR(bss->bssid));
310 ies_len = bss->beacon_ie_len;
314 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
315 bss->freq, &entry_ts, bss->level,
326 if (wpa_s->p2p_scan_work) {
327 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
329 wpa_s->p2p_scan_work = NULL;
333 if (wpa_s->global->p2p_disabled || !wpa_s->global->p2p)
337 "P2P: Failed to get scan results - try to continue");
352 if (!wpa_s->conf->p2p_6ghz_disable &&
353 is_p2p_allow_6ghz(wpa_s->global->p2p) && include_6ghz)
361 struct wpa_supplicant *wpa_s = work->wpa_s;
362 struct wpa_driver_scan_params *params = work->ctx;
366 if (!work->started) {
371 wpa_s->p2p_scan_work = NULL;
375 if (wpa_s->clear_driver_scan_cache) {
378 params->only_new_results = 1;
381 if (!params->freqs)
382 wpas_p2p_scan_freqs(wpa_s, params, params->p2p_include_6ghz);
386 wpa_s->curr_scan_cookie = params->scan_cookie;
388 work->ctx = NULL;
391 p2p_notify_scan_trigger_status(wpa_s->global->p2p, ret);
395 p2p_notify_scan_trigger_status(wpa_s->global->p2p, ret);
396 os_get_reltime(&wpa_s->scan_trigger_time);
397 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
398 wpa_s->scan_res_fail_handler = wpas_p2p_scan_res_fail_handler;
399 wpa_s->own_scan_requested = 1;
400 wpa_s->clear_driver_scan_cache = 0;
401 wpa_s->p2p_scan_work = work;
408 if (wpa_s->global->p2p_24ghz_social_channels &&
417 return p2p_supported_freq(wpa_s->global->p2p, freq);
435 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
436 return -1;
438 if (wpa_s->p2p_scan_work) {
440 return -1;
445 return -1;
448 params->num_ssids = 1;
453 params->ssids[0].ssid = n;
454 params->ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
456 wpa_s->wps->dev.p2p = 1;
457 wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev,
458 wpa_s->wps->uuid, WPS_REQ_ENROLLEE,
469 if (!wpa_s->conf->p2p_6ghz_disable)
470 params->p2p_include_6ghz = include_6ghz;
473 params->freqs = os_calloc(ARRAY_SIZE(social_channels_freq) + 1,
475 if (params->freqs == NULL)
480 params->freqs[num_channels++] =
483 params->freqs[num_channels++] = 0;
488 params->freqs = os_calloc(2, sizeof(int));
489 if (params->freqs == NULL)
491 params->freqs[0] = freq;
492 params->freqs[1] = 0;
495 params->freqs = os_calloc(ARRAY_SIZE(social_channels_freq) + 2,
497 if (params->freqs == NULL)
502 params->freqs[num_channels++] =
505 if (p2p_supported_freq(wpa_s->global->p2p, freq))
506 params->freqs[num_channels++] = freq;
507 params->freqs[num_channels++] = 0;
511 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
520 bands = wpas_get_bands(wpa_s, params->freqs);
521 p2p_scan_ie(wpa_s->global->p2p, ies, dev_id, bands);
523 params->p2p_probe = 1;
530 params->extra_ies = n;
531 params->extra_ies_len = wpabuf_len(ies);
534 radio_remove_works(wpa_s, "p2p-scan", 0);
535 if (radio_add_work(wpa_s, 0, "p2p-scan", 0, wpas_p2p_trigger_scan_cb,
542 return -1;
567 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
568 for (s = wpa_s->conf->ssid; s; s = s->next) {
569 if (s->disabled != 0 || !s->p2p_group ||
570 s->ssid_len != ssid_len ||
571 os_memcmp(ssid, s->ssid, ssid_len) != 0)
573 if (s->mode == WPAS_MODE_P2P_GO &&
574 s != wpa_s->current_ssid)
577 *go = s->mode == WPAS_MODE_P2P_GO;
591 wpa_s->ifname);
600 wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
605 * control interface responses on the per-interface socket.
609 return -1;
623 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
624 for (s = wpa_s->conf->ssid; s; s = s->next) {
627 wpa_s, s, s->disabled, s->p2p_group,
628 s->mode);
629 if (!s->disabled && s->p2p_group &&
630 s->mode == WPAS_MODE_P2P_GO) {
632 wpa_s->p2p_group);
643 return !wpa_s->p2p_mgmt && wpa_s->current_ssid &&
644 !wpa_s->current_ssid->disabled &&
645 wpa_s->current_ssid->p2p_group &&
646 wpa_s->current_ssid->p2p_persistent_group;
653 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO;
666 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
671 if (p2p_get_group_num_members(wpa_s->p2p_group))
684 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
692 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
707 for (s = wpa_s->conf->ssid; s; s = s->next) {
708 if (s->disabled == 2 && s->mode == WPAS_MODE_P2P_GO)
730 wpa_printf(MSG_DEBUG, "P2P: Conncap - in:%d role:%d", incoming, role);
746 * For non-concurrent capable devices:
753 owned_members = p2p_get_group_num_members(go_wpa_s->p2p_group);
772 p2p_client_limit_reached(go_wpa_s->p2p_group))
817 * Must be a complimentary role - cannot be a client to
842 * negotiation, but rather try to re-use the existing groups.
888 if (go_wpa_s && p2p_client_limit_reached(go_wpa_s->p2p_group))
893 p2p_set_intended_addr(wpa_s->global->p2p,
894 wpa_s->p2p_mgmt ?
895 wpa_s->parent->own_addr :
896 wpa_s->own_addr);
904 wpa_s->global->pending_group_iface_for_p2ps = 1;
905 p2p_set_intended_addr(wpa_s->global->p2p,
906 wpa_s->pending_interface_addr);
921 ssid = wpa_s->current_ssid;
928 ssid = wpa_s->conf->ssid;
930 if (ssid->p2p_group && ssid->disabled != 2)
932 ssid = ssid->next;
935 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)
939 return -1;
942 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
944 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
945 (ssid && ssid->mode == WPAS_MODE_INFRA)) {
946 wpa_s->reassociate = 0;
947 wpa_s->disconnected = 1;
967 if (wpa_s->cross_connect_in_use) {
968 wpa_s->cross_connect_in_use = 0;
969 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
971 wpa_s->ifname, wpa_s->cross_connect_uplink);
1000 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1002 wpa_s->ifname, gtype, reason);
1010 wpa_s->p2pdev, NULL) > 0) {
1013 wpa_s->p2p_in_provisioning = 0;
1017 wpa_s->p2p_in_invitation = 0;
1018 wpa_s->p2p_retry_limit = 0;
1026 wpa_s->global->p2p_go_wait_client.sec = 0;
1028 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
1033 wpa_s->ifname);
1034 global = wpa_s->global;
1035 ifname = os_strdup(wpa_s->ifname);
1036 type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
1038 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
1039 wpa_s = global->ifaces;
1050 wpa_s->p2pdev = wpa_s->parent;
1052 if (!wpa_s->p2p_go_group_formation_completed) {
1053 wpa_s->global->p2p_group_formation = NULL;
1054 wpa_s->p2p_in_provisioning = 0;
1057 wpa_s->show_group_started = 0;
1058 os_free(wpa_s->go_params);
1059 wpa_s->go_params = NULL;
1061 os_free(wpa_s->p2p_group_common_freqs);
1062 wpa_s->p2p_group_common_freqs = NULL;
1063 wpa_s->p2p_group_common_freqs_num = 0;
1064 wpa_s->p2p_go_do_acs = 0;
1065 wpa_s->p2p_go_allow_dfs = 0;
1067 wpa_s->waiting_presence_resp = 0;
1070 if (ssid && (ssid->p2p_group ||
1071 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION ||
1072 (ssid->key_mgmt & WPA_KEY_MGMT_WPS))) {
1073 int id = ssid->id;
1074 if (ssid == wpa_s->current_ssid) {
1075 wpa_sm_set_config(wpa_s->wpa, NULL);
1076 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1077 wpa_s->current_ssid = NULL;
1081 * exposed out as they might/will confuse certain non-P2P aware
1089 wpa_config_remove_network(wpa_s->conf, id);
1096 if (wpa_s->ap_iface)
1101 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
1103 wpa_s->p2p_go_no_pri_sec_switch = 0;
1119 if (wpa_s->go_params)
1120 bssid = wpa_s->go_params->peer_interface_addr;
1122 bssid = wpa_s->bssid;
1125 if (bss == NULL && wpa_s->go_params &&
1126 !is_zero_ether_addr(wpa_s->go_params->peer_device_addr))
1128 wpa_s, wpa_s->go_params->peer_device_addr);
1131 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
1137 "group is persistent - BSS " MACSTR " not found",
1148 "group is persistent - BSS " MACSTR
1151 wpa_bss_ie_ptr(bss), bss->ie_len);
1153 wpa_bss_ie_ptr(bss) + bss->ie_len,
1154 bss->beacon_ie_len);
1187 for (s = wpa_s->conf->ssid; s; s = s->next) {
1188 if (s->disabled == 2 &&
1189 ether_addr_equal(go_dev_addr, s->bssid) &&
1190 s->ssid_len == ssid->ssid_len &&
1191 os_memcmp(ssid->ssid, s->ssid, ssid->ssid_len) == 0)
1198 if (ssid->passphrase && !s->passphrase)
1200 else if (ssid->passphrase && s->passphrase &&
1201 os_strcmp(ssid->passphrase, s->passphrase) != 0)
1207 s = wpa_config_add_network(wpa_s->conf);
1209 return -1;
1217 s->p2p_group = 1;
1218 s->p2p_persistent_group = 1;
1223 s->p2p_group = 1;
1224 s->p2p_persistent_group = 1;
1225 s->disabled = 2;
1226 s->bssid_set = 1;
1227 os_memcpy(s->bssid, go_dev_addr, ETH_ALEN);
1228 s->mode = ssid->mode;
1229 s->auth_alg = WPA_AUTH_ALG_OPEN;
1230 s->key_mgmt = WPA_KEY_MGMT_PSK;
1231 s->proto = WPA_PROTO_RSN;
1232 s->pbss = ssid->pbss;
1233 s->pairwise_cipher = ssid->pbss ? WPA_CIPHER_GCMP : WPA_CIPHER_CCMP;
1234 s->export_keys = 1;
1235 if (ssid->passphrase) {
1236 os_free(s->passphrase);
1237 s->passphrase = os_strdup(ssid->passphrase);
1239 if (ssid->psk_set) {
1240 s->psk_set = 1;
1241 os_memcpy(s->psk, ssid->psk, 32);
1243 if (s->passphrase && !s->psk_set)
1245 if (s->ssid == NULL || s->ssid_len < ssid->ssid_len) {
1246 os_free(s->ssid);
1247 s->ssid = os_malloc(ssid->ssid_len);
1249 if (s->ssid) {
1250 s->ssid_len = ssid->ssid_len;
1251 os_memcpy(s->ssid, ssid->ssid, s->ssid_len);
1253 if (ssid->mode == WPAS_MODE_P2P_GO && wpa_s->global->add_psk) {
1254 dl_list_add(&s->psk_list, &wpa_s->global->add_psk->list);
1255 wpa_s->global->add_psk = NULL;
1259 if (changed && wpa_s->conf->update_config &&
1260 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
1264 return s->id;
1275 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
1277 ssid = wpa_s->current_ssid;
1278 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
1279 !ssid->p2p_persistent_group)
1282 for (s = p2p_wpa_s->conf->ssid; s; s = s->next) {
1283 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
1286 if (s->ssid_len == ssid->ssid_len &&
1287 os_memcmp(s->ssid, ssid->ssid, s->ssid_len) == 0)
1294 for (i = 0; s->p2p_client_list && i < s->num_p2p_clients; i++) {
1295 if (!ether_addr_equal(s->p2p_client_list + i * 2 * ETH_ALEN,
1299 if (i == s->num_p2p_clients - 1)
1303 os_memmove(s->p2p_client_list + i * 2 * ETH_ALEN,
1304 s->p2p_client_list + (i + 1) * 2 * ETH_ALEN,
1305 (s->num_p2p_clients - i - 1) * 2 * ETH_ALEN);
1306 os_memcpy(s->p2p_client_list +
1307 (s->num_p2p_clients - 1) * 2 * ETH_ALEN, addr,
1309 os_memset(s->p2p_client_list +
1310 (s->num_p2p_clients - 1) * 2 * ETH_ALEN + ETH_ALEN,
1316 if (!found && s->num_p2p_clients < P2P_MAX_STORED_CLIENTS) {
1317 n = os_realloc_array(s->p2p_client_list,
1318 s->num_p2p_clients + 1, 2 * ETH_ALEN);
1321 os_memcpy(n + s->num_p2p_clients * 2 * ETH_ALEN, addr,
1323 os_memset(n + s->num_p2p_clients * 2 * ETH_ALEN + ETH_ALEN,
1325 s->p2p_client_list = n;
1326 s->num_p2p_clients++;
1327 } else if (!found && s->p2p_client_list) {
1328 /* Not enough room for an additional entry - drop the oldest
1330 os_memmove(s->p2p_client_list,
1331 s->p2p_client_list + 2 * ETH_ALEN,
1332 (s->num_p2p_clients - 1) * 2 * ETH_ALEN);
1333 os_memcpy(s->p2p_client_list +
1334 (s->num_p2p_clients - 1) * 2 * ETH_ALEN,
1336 os_memset(s->p2p_client_list +
1337 (s->num_p2p_clients - 1) * 2 * ETH_ALEN + ETH_ALEN,
1341 if (p2p_wpa_s->conf->update_config &&
1342 wpa_config_write(p2p_wpa_s->confname, p2p_wpa_s->conf))
1362 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
1373 wpa_msg_global_ctrl(wpa_s->p2pdev, MSG_INFO,
1377 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
1386 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
1405 if (wpa_s->global->p2p_group_formation)
1406 wpa_s = wpa_s->global->p2p_group_formation;
1407 if (wpa_s->p2p_go_group_formation_completed) {
1408 wpa_s->global->p2p_group_formation = NULL;
1409 wpa_s->p2p_in_provisioning = 0;
1410 } else if (wpa_s->p2p_in_provisioning && !success) {
1413 wpa_s->p2p_in_provisioning = 0;
1415 wpa_s->p2p_in_invitation = 0;
1416 wpa_s->p2p_retry_limit = 0;
1417 wpa_s->group_formation_reported = 1;
1420 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1430 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1433 ssid = wpa_s->current_ssid;
1434 if (ssid && ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1435 ssid->mode = WPAS_MODE_P2P_GO;
1436 p2p_group_notif_formation_done(wpa_s->p2p_group);
1442 client = ssid->mode == WPAS_MODE_INFRA;
1443 if (ssid->mode == WPAS_MODE_P2P_GO) {
1444 persistent = ssid->p2p_persistent_group;
1445 os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr,
1450 ssid->ssid,
1451 ssid->ssid_len);
1453 client = wpa_s->p2p_group_interface ==
1458 wpa_s->show_group_started = 0;
1461 * Indicate event only after successfully completed 4-way
1465 wpa_s->show_group_started = 1;
1468 ssid ? ssid->frequency : 0,
1469 ssid && ssid->passphrase == NULL &&
1470 ssid->psk_set ? ssid->psk : NULL,
1471 ssid ? ssid->passphrase : NULL,
1478 wpas_p2p_store_persistent_group(wpa_s->p2pdev,
1481 os_free(wpa_s->global->add_psk);
1482 wpa_s->global->add_psk = NULL;
1487 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
1505 struct send_action_work *awork = wpa_s->p2p_send_action_work->ctx;
1510 wpa_s->p2p_send_action_work, awork->freq,
1511 MAC2STR(awork->dst), MAC2STR(awork->src),
1512 MAC2STR(awork->bssid), awork->wait_time);
1514 awork->buf, awork->len);
1516 wpa_s->p2p_send_action_work->ctx = NULL;
1517 radio_work_done(wpa_s->p2p_send_action_work);
1518 wpa_s->p2p_send_action_work = NULL;
1527 if (!wpa_s->p2p_send_action_work)
1537 if (wpa_s->p2p_send_action_work) {
1540 awork = wpa_s->p2p_send_action_work->ctx;
1543 wpa_s->p2p_send_action_work, awork->wait_time);
1544 if (awork->wait_time == 0) {
1549 * places in the P2P code is still using non-zero wait
1556 0, awork->wait_time * 1000,
1576 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
1591 p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res);
1594 wpa_s->pending_pd_before_join &&
1595 (ether_addr_equal(dst, wpa_s->pending_join_dev_addr) ||
1596 ether_addr_equal(dst, wpa_s->pending_join_iface_addr)) &&
1597 wpa_s->p2p_fallback_to_go_neg) {
1598 wpa_s->pending_pd_before_join = 0;
1600 "during p2p_connect-auto");
1601 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1603 "reason=no-ACK-to-PD-Req");
1612 struct wpa_supplicant *wpa_s = work->wpa_s;
1613 struct send_action_work *awork = work->ctx;
1616 if (work->started) {
1619 wpa_s->p2p_send_action_work = NULL;
1626 if (offchannel_send_action(wpa_s, awork->freq, awork->dst, awork->src,
1627 awork->bssid, awork->buf, awork->len,
1628 awork->wait_time,
1634 wpa_s->p2p_send_action_work = work;
1645 if (radio_work_pending(wpa_s, "p2p-send-action")) {
1646 wpa_printf(MSG_DEBUG, "P2P: Cannot schedule new p2p-send-action work since one is already pending");
1647 return -1;
1652 return -1;
1654 awork->freq = freq;
1655 os_memcpy(awork->dst, dst, ETH_ALEN);
1656 os_memcpy(awork->src, src, ETH_ALEN);
1657 os_memcpy(awork->bssid, bssid, ETH_ALEN);
1658 awork->len = len;
1659 awork->wait_time = wait_time;
1660 os_memcpy(awork->buf, buf, len);
1662 if (radio_add_work(wpa_s, freq, "p2p-send-action", 1,
1665 return -1;
1677 int listen_freq = -1, send_freq = -1;
1681 if (wpa_s->p2p_listen_work)
1682 listen_freq = wpa_s->p2p_listen_work->freq;
1683 if (wpa_s->p2p_send_action_work)
1684 send_freq = wpa_s->p2p_send_action_work->freq;
1708 if (wpa_s->p2p_send_action_work) {
1711 os_free(wpa_s->p2p_send_action_work->ctx);
1712 radio_work_done(wpa_s->p2p_send_action_work);
1713 wpa_s->p2p_send_action_work = NULL;
1723 if (wpa_s->go_params == NULL) {
1724 wpa_s->go_params = os_malloc(sizeof(*params));
1725 if (wpa_s->go_params == NULL)
1726 return -1;
1728 os_memcpy(wpa_s->go_params, params, sizeof(*params));
1736 wpa_s->group_formation_reported = 0;
1739 MAC2STR(res->peer_interface_addr),
1740 MAC2STR(res->peer_device_addr), res->wps_method);
1742 res->ssid, res->ssid_len);
1745 if (res->wps_method == WPS_PBC) {
1746 wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1, 0);
1748 } else if (res->wps_method == WPS_NFC) {
1749 wpas_wps_start_nfc(wpa_s, res->peer_device_addr,
1750 res->peer_interface_addr,
1751 wpa_s->p2pdev->p2p_oob_dev_pw,
1752 wpa_s->p2pdev->p2p_oob_dev_pw_id, 1,
1753 wpa_s->p2pdev->p2p_oob_dev_pw_id ==
1755 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash :
1761 if (wpa_s->p2p_wps_method == WPS_P2PS)
1763 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
1765 wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
1766 wpa_s->p2p_pin, 1, dev_pw_id);
1778 if (!wpa_s->ap_iface)
1781 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, NULL, ssid->ssid,
1782 ssid->ssid_len);
1786 hapd = wpa_s->ap_iface->bss[0];
1788 dl_list_for_each(psk, &persistent->psk_list, struct psk_list_entry,
1794 MAC2STR(psk->addr), psk->p2p);
1798 os_memcpy(hpsk->psk, psk->psk, PMK_LEN);
1799 if (psk->p2p)
1800 os_memcpy(hpsk->p2p_dev_addr, psk->addr, ETH_ALEN);
1802 os_memcpy(hpsk->addr, psk->addr, ETH_ALEN);
1803 hpsk->next = hapd->conf->ssid.wpa_psk;
1804 hapd->conf->ssid.wpa_psk = hpsk;
1818 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
1819 res = os_snprintf(pos, end - pos, " %d",
1820 wpa_s->p2p_group_common_freqs[i]);
1821 if (os_snprintf_error(end - pos, res))
1834 unsigned int i, len = int_array_len(wpa_s->go_params->freq_list);
1836 wpa_s->p2p_group_common_freqs_num = 0;
1837 os_free(wpa_s->p2p_group_common_freqs);
1838 wpa_s->p2p_group_common_freqs = os_calloc(len, sizeof(int));
1839 if (!wpa_s->p2p_group_common_freqs)
1843 if (!wpa_s->go_params->freq_list[i])
1845 wpa_s->p2p_group_common_freqs[i] =
1846 wpa_s->go_params->freq_list[i];
1848 wpa_s->p2p_group_common_freqs_num = i;
1855 if (wpa_s->p2pdev->conf->update_config &&
1856 wpa_config_write(wpa_s->p2pdev->confname, wpa_s->p2pdev->conf))
1868 wpa_s->ap_configured_cb = NULL;
1869 wpa_s->ap_configured_cb_ctx = NULL;
1870 wpa_s->ap_configured_cb_data = NULL;
1871 if (!wpa_s->go_params) {
1873 "P2P: p2p_go_configured() called with wpa_s->go_params == NULL");
1880 ssid = wpa_s->current_ssid;
1881 if (ssid && ssid->mode == WPAS_MODE_P2P_GO) {
1883 if (wpa_s->global->p2p_group_formation == wpa_s)
1884 wpa_s->global->p2p_group_formation = NULL;
1885 wpas_p2p_group_started(wpa_s, 1, ssid, ssid->frequency,
1886 params->passphrase[0] == '\0' ?
1887 params->psk : NULL,
1888 params->passphrase,
1889 wpa_s->global->p2p_dev_addr,
1890 params->persistent_group, "");
1891 wpa_s->group_formation_reported = 1;
1893 if (wpa_s->p2pdev->p2ps_method_config_any) {
1894 if (is_zero_ether_addr(wpa_s->p2pdev->p2ps_join_addr)) {
1903 MAC2STR(wpa_s->p2pdev->p2ps_join_addr));
1905 wpa_s, wpa_s->p2pdev->p2ps_join_addr,
1908 wpa_s->p2pdev->p2ps_method_config_any = 0;
1911 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
1912 if (params->persistent_group) {
1914 wpa_s->p2pdev, ssid,
1915 wpa_s->global->p2p_dev_addr);
1920 params->persistent_group, 0,
1925 if (wpa_s->p2p_first_connection_timeout) {
1928 wpa_s->p2p_first_connection_timeout);
1929 wpa_s->p2p_go_group_formation_completed = 0;
1930 wpa_s->global->p2p_group_formation = wpa_s;
1932 wpa_s->p2pdev, NULL);
1934 wpa_s->p2p_first_connection_timeout, 0,
1936 wpa_s->p2pdev, NULL);
1944 params->peer_interface_addr)) {
1949 if (params->wps_method == WPS_PBC) {
1950 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr,
1951 params->peer_device_addr);
1953 } else if (params->wps_method == WPS_NFC) {
1954 if (wpa_s->p2pdev->p2p_oob_dev_pw_id !=
1956 !wpa_s->p2pdev->p2p_oob_dev_pw) {
1961 wpa_s, wpa_s->p2pdev->p2p_oob_dev_pw_id,
1962 wpa_s->p2pdev->p2p_oob_dev_pw,
1963 wpa_s->p2pdev->p2p_peer_oob_pk_hash_known ?
1964 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash : NULL);
1966 } else if (wpa_s->p2p_pin[0])
1967 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
1968 wpa_s->p2p_pin, NULL, 0, 0);
1969 os_free(wpa_s->go_params);
1970 wpa_s->go_params = NULL;
1975 * wpas_p2p_freq_to_edmg_channel - Convert frequency into EDMG channel
1979 * Returns: 0 on success, -1 on failure
1997 if (!wpa_s->hw.modes)
1998 return -1;
2000 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
2005 return -1;
2017 ieee802_edmg_is_allowed(hwmode->edmg, edmg)) {
2025 return -1;
2036 freq = (!params->freq) ? 58320 + 1 * 2160 : params->freq;
2043 params->freq = freq;
2047 return -1;
2064 ssid = wpa_config_add_network(wpa_s->conf);
2070 wpa_s->show_group_started = 0;
2071 wpa_s->p2p_go_group_formation_completed = 0;
2072 wpa_s->group_formation_reported = 0;
2073 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
2076 ssid->temporary = 1;
2077 ssid->p2p_group = 1;
2078 ssid->p2p_persistent_group = !!params->persistent_group;
2079 ssid->mode = group_formation ? WPAS_MODE_P2P_GROUP_FORMATION :
2081 ssid->frequency = params->freq;
2082 ssid->ht40 = params->ht40;
2083 ssid->vht = params->vht;
2084 ssid->max_oper_chwidth = params->max_oper_chwidth;
2085 ssid->vht_center_freq2 = params->vht_center_freq2;
2086 ssid->he = params->he;
2087 if (params->edmg) {
2090 if (!wpas_p2p_freq_to_edmg_channel(wpa_s, params->freq,
2092 ssid->edmg_channel = op_channel;
2093 ssid->enable_edmg = params->edmg;
2097 params->freq);
2101 ssid->ssid = os_zalloc(params->ssid_len + 1);
2102 if (ssid->ssid) {
2103 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
2104 ssid->ssid_len = params->ssid_len;
2106 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
2107 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
2108 if (is_6ghz_freq(ssid->frequency) &&
2109 is_p2p_6ghz_capable(wpa_s->global->p2p)) {
2110 ssid->auth_alg |= WPA_AUTH_ALG_SAE;
2111 ssid->key_mgmt = WPA_KEY_MGMT_SAE;
2112 ssid->ieee80211w = MGMT_FRAME_PROTECTION_REQUIRED;
2113 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
2116 p2p_set_6ghz_dev_capab(wpa_s->global->p2p, false);
2118 ssid->proto = WPA_PROTO_RSN;
2119 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
2120 ssid->group_cipher = WPA_CIPHER_CCMP;
2121 if (params->freq > 56160) {
2126 ssid->pairwise_cipher = WPA_CIPHER_GCMP;
2127 ssid->group_cipher = WPA_CIPHER_GCMP;
2129 ssid->pbss = 1;
2131 if (os_strlen(params->passphrase) > 0) {
2132 ssid->passphrase = os_strdup(params->passphrase);
2133 if (ssid->passphrase == NULL) {
2136 wpa_config_remove_network(wpa_s->conf, ssid->id);
2140 ssid->passphrase = NULL;
2141 ssid->psk_set = params->psk_set;
2142 if (ssid->psk_set)
2143 os_memcpy(ssid->psk, params->psk, sizeof(ssid->psk));
2144 else if (ssid->passphrase)
2146 ssid->ap_max_inactivity = wpa_s->p2pdev->conf->p2p_go_max_inactivity;
2148 wpa_s->ap_configured_cb = p2p_go_configured;
2149 wpa_s->ap_configured_cb_ctx = wpa_s;
2150 wpa_s->ap_configured_cb_data = wpa_s->go_params;
2151 wpa_s->scan_req = NORMAL_SCAN_REQ;
2152 wpa_s->connect_without_scan = ssid;
2153 wpa_s->reassociate = 1;
2154 wpa_s->disconnected = 0;
2167 d = dst->conf;
2168 s = src->conf;
2172 if (s->n && !d->n) \
2173 d->n = os_strdup(s->n); \
2184 os_memcpy(d->device_type, s->device_type, WPS_DEV_TYPE_LEN);
2185 os_memcpy(d->sec_device_type, s->sec_device_type,
2186 sizeof(d->sec_device_type));
2187 d->num_sec_device_types = s->num_sec_device_types;
2189 d->p2p_group_idle = s->p2p_group_idle;
2190 d->p2p_go_freq_change_policy = s->p2p_go_freq_change_policy;
2191 d->p2p_intra_bss = s->p2p_intra_bss;
2192 d->persistent_reconnect = s->persistent_reconnect;
2193 d->max_num_sta = s->max_num_sta;
2194 d->pbc_in_m1 = s->pbc_in_m1;
2195 d->ignore_old_scan_res = s->ignore_old_scan_res;
2196 d->beacon_int = s->beacon_int;
2197 d->dtim_period = s->dtim_period;
2198 d->p2p_go_ctwindow = s->p2p_go_ctwindow;
2199 d->disassoc_low_ack = s->disassoc_low_ack;
2200 d->disable_scan_offload = s->disable_scan_offload;
2201 d->passive_scan = s->passive_scan;
2202 d->pmf = s->pmf;
2203 d->p2p_6ghz_disable = s->p2p_6ghz_disable;
2204 d->sae_pwe = s->sae_pwe;
2206 if (s->wps_nfc_dh_privkey && s->wps_nfc_dh_pubkey &&
2207 !d->wps_nfc_pw_from_config) {
2208 wpabuf_free(d->wps_nfc_dh_privkey);
2209 wpabuf_free(d->wps_nfc_dh_pubkey);
2210 d->wps_nfc_dh_privkey = wpabuf_dup(s->wps_nfc_dh_privkey);
2211 d->wps_nfc_dh_pubkey = wpabuf_dup(s->wps_nfc_dh_pubkey);
2213 d->p2p_cli_probe = s->p2p_cli_probe;
2214 d->go_interworking = s->go_interworking;
2215 d->go_access_network_type = s->go_access_network_type;
2216 d->go_internet = s->go_internet;
2217 d->go_venue_group = s->go_venue_group;
2218 d->go_venue_type = s->go_venue_type;
2219 d->p2p_add_cli_chan = s->p2p_add_cli_chan;
2226 char *ifname_ptr = wpa_s->ifname;
2228 if (os_strncmp(wpa_s->ifname, P2P_MGMT_DEVICE_PREFIX,
2230 ifname_ptr = os_strrchr(wpa_s->ifname, '-') + 1;
2233 os_snprintf(ifname, len, "p2p-%s-%d", ifname_ptr, wpa_s->p2p_group_idx);
2235 os_strlen(wpa_s->ifname) < IFNAMSIZ) {
2239 res = os_snprintf(ifname, len, "p2p-%d", wpa_s->p2p_group_idx);
2241 ifname[len - 1] = '\0';
2251 if (wpa_s->pending_interface_name[0]) {
2253 "- skip creation of a new one");
2254 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
2257 wpa_s->pending_interface_name);
2258 return -1;
2268 wpa_s->p2p_group_idx++;
2270 wpa_s->pending_interface_type = type;
2272 wpa_s->pending_interface_addr, NULL) < 0) {
2275 return -1;
2278 if (wpa_s->conf->p2p_interface_random_mac_addr) {
2279 random_mac_addr(wpa_s->pending_interface_addr);
2282 MAC2STR(wpa_s->pending_interface_addr));
2288 os_strlcpy(wpa_s->pending_interface_name, force_ifname,
2289 sizeof(wpa_s->pending_interface_name));
2291 os_strlcpy(wpa_s->pending_interface_name, ifname,
2292 sizeof(wpa_s->pending_interface_name));
2294 MACSTR, wpa_s->pending_interface_name,
2295 MAC2STR(wpa_s->pending_interface_addr));
2304 if (!wpa_s->pending_interface_name[0] ||
2305 is_zero_ether_addr(wpa_s->pending_interface_addr))
2309 wpa_s->pending_interface_name);
2310 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
2311 wpa_s->pending_interface_name);
2312 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
2313 wpa_s->pending_interface_name[0] = '\0';
2314 wpa_s->global->pending_group_iface_for_p2ps = 0;
2324 if (!wpa_s->pending_interface_name[0]) {
2339 iface.ifname = wpa_s->pending_interface_name;
2340 iface.driver = wpa_s->driver->name;
2341 if (wpa_s->conf->ctrl_interface == NULL &&
2342 wpa_s->parent != wpa_s &&
2343 wpa_s->p2p_mgmt &&
2344 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE))
2345 iface.ctrl_interface = wpa_s->parent->conf->ctrl_interface;
2347 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
2348 iface.driver_param = wpa_s->conf->driver_param;
2349 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface, wpa_s);
2355 wpa_s->pending_interface_name[0] = '\0';
2356 group_wpa_s->p2p_group_interface = go ? P2P_GROUP_INTERFACE_GO :
2358 wpa_s->global->p2p_group_formation = group_wpa_s;
2359 wpa_s->global->pending_group_iface_for_p2ps = 0;
2363 if (wpa_s->conf->p2p_interface_random_mac_addr) {
2365 wpa_s->pending_interface_addr) < 0) {
2368 wpa_supplicant_remove_iface(wpa_s->global, group_wpa_s,
2376 wpa_supplicant_remove_iface(wpa_s->global, group_wpa_s,
2383 MAC2STR(wpa_s->pending_interface_addr));
2403 wpa_s->p2pdev, NULL);
2404 if (wpa_s->global->p2p)
2405 p2p_group_formation_failed(wpa_s->global->p2p);
2414 wpa_s->p2pdev, NULL);
2416 wpa_s->p2pdev, NULL);
2417 wpa_s->global->p2p_fail_on_wps_complete = 0;
2423 if (wpa_s->global->p2p_group_formation != wpa_s)
2427 wpa_s->p2pdev, NULL);
2429 wpa_s->p2pdev, NULL);
2435 if (!wpa_s->p2p_in_invitation || !wpa_s->p2p_retry_limit ||
2436 wpa_s->p2p_in_invitation <= wpa_s->p2p_retry_limit)
2441 wpa_s->p2pdev, NULL);
2443 wpa_s->p2pdev, NULL);
2453 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
2455 wpa_s->off_channel_freq = 0;
2456 wpa_s->roc_waiting_drv_freq = 0;
2459 if (res->status) {
2462 res->status);
2468 if (!res->role_go) {
2470 wpa_drv_set_prob_oper_freq(wpa_s, res->freq);
2473 if (wpa_s->p2p_go_ht40)
2474 res->ht40 = 1;
2475 if (wpa_s->p2p_go_vht)
2476 res->vht = 1;
2477 if (wpa_s->p2p_go_he)
2478 res->he = 1;
2479 if (wpa_s->p2p_go_edmg)
2480 res->edmg = 1;
2481 res->max_oper_chwidth = wpa_s->p2p_go_max_oper_chwidth;
2482 res->vht_center_freq2 = wpa_s->p2p_go_vht_center_freq2;
2487 res->role_go ? "GO" : "client", res->freq, res->ht40,
2488 MAC2STR(res->peer_device_addr),
2489 MAC2STR(res->peer_interface_addr),
2490 p2p_wps_method_text(res->wps_method));
2493 if (res->role_go && wpa_s->p2p_persistent_id >= 0) {
2495 ssid = wpa_config_get_network(wpa_s->conf,
2496 wpa_s->p2p_persistent_id);
2497 if (ssid && ssid->disabled == 2 &&
2498 ssid->mode == WPAS_MODE_P2P_GO && ssid->passphrase) {
2499 size_t len = os_strlen(ssid->passphrase);
2502 os_memcpy(res->passphrase, ssid->passphrase, len);
2503 res->passphrase[len] = '\0';
2507 if (wpa_s->create_p2p_iface) {
2509 wpas_p2p_init_group_interface(wpa_s, res->role_go);
2517 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
2518 wpa_s->pending_interface_name[0] = '\0';
2520 group_wpa_s = wpa_s->parent;
2521 wpa_s->global->p2p_group_formation = group_wpa_s;
2526 group_wpa_s->p2p_in_provisioning = 1;
2527 group_wpa_s->p2pdev = wpa_s;
2529 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
2530 sizeof(group_wpa_s->p2p_pin));
2531 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
2533 if (res->role_go) {
2536 os_get_reltime(&group_wpa_s->scan_min_time);
2540 wpa_s->global->p2p_long_listen = 0;
2544 eloop_register_timeout(15 + res->peer_config_timeout / 100,
2545 (res->peer_config_timeout % 100) * 10000,
2572 wfd_dev_info_hex = wifi_display_subelem_hex(info->wfd_subelems,
2576 if (info->p2ps_instance) {
2578 const u8 *buf = wpabuf_head(info->p2ps_instance);
2579 size_t len = wpabuf_len(info->p2ps_instance);
2593 if (str_len > len - 4 - 2 - 1)
2598 len -= str_len + sizeof(u32) + sizeof(u16) + sizeof(u8);
2609 MAC2STR(info->p2p_device_addr),
2611 info->pri_dev_type,
2613 info->device_name, methods,
2614 info->dev_capab, info->group_capab,
2616 info->vendor_elems ?
2626 MAC2STR(addr), MAC2STR(info->p2p_device_addr),
2627 wps_dev_type_bin2str(info->pri_dev_type, devtype,
2629 info->device_name, info->config_methods,
2630 info->dev_capab, info->group_capab,
2633 info->vendor_elems ? " vendor_elems=1" : "",
2640 wpas_notify_p2p_device_found(ctx, info->p2p_device_addr, new_device);
2659 if (wpa_s->p2p_scan_work && wpas_abort_ongoing_scan(wpa_s) < 0)
2678 wpabuf_free(lwork->probe_resp_ie);
2687 if (!wpa_s->p2p_listen_work)
2690 lwork = wpa_s->p2p_listen_work->ctx;
2692 radio_work_done(wpa_s->p2p_listen_work);
2693 wpa_s->p2p_listen_work = NULL;
2699 struct wpa_supplicant *wpa_s = work->wpa_s;
2700 struct wpas_p2p_listen_work *lwork = work->ctx;
2704 if (work->started) {
2705 wpa_s->p2p_listen_work = NULL;
2712 wpa_s->p2p_listen_work = work;
2714 wpa_drv_set_ap_wps_ie(wpa_s, NULL, lwork->probe_resp_ie, NULL);
2723 wpa_s->pending_listen_freq = lwork->freq;
2724 wpa_s->pending_listen_duration = lwork->duration;
2726 duration = lwork->duration;
2728 if (wpa_s->extra_roc_dur) {
2729 wpa_printf(MSG_DEBUG, "TESTING: Increase ROC duration %u -> %u",
2730 duration, duration + wpa_s->extra_roc_dur);
2731 duration += wpa_s->extra_roc_dur;
2735 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq, duration) < 0) {
2738 "state", lwork->freq);
2740 wpa_s->pending_listen_freq = 0;
2743 wpa_s->off_channel_freq = 0;
2744 wpa_s->roc_waiting_drv_freq = lwork->freq;
2755 if (wpa_s->p2p_listen_work) {
2757 return -1;
2762 return -1;
2763 lwork->freq = freq;
2764 lwork->duration = duration;
2766 lwork->probe_resp_ie = wpabuf_dup(probe_resp_ie);
2767 if (lwork->probe_resp_ie == NULL) {
2769 return -1;
2773 if (radio_add_work(wpa_s, freq, "p2p-listen", 0, wpas_start_listen_cb,
2776 return -1;
2786 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
2788 wpa_s->off_channel_freq = 0;
2789 wpa_s->roc_waiting_drv_freq = 0;
2794 * Don't cancel Probe Request RX reporting for a connected P2P Client
2797 if (!wpa_s->p2p_cli_probe)
2802 if (radio_work_pending(wpa_s, "p2p-listen")) {
2804 "P2P: p2p-listen is still pending - remove it");
2805 radio_remove_works(wpa_s, "p2p-listen", 0);
2851 for (group = wpa_s->global->ifaces; group; group = group->next)
2853 struct wpa_ssid *s = group->current_ssid;
2855 s->mode == WPAS_MODE_P2P_GO &&
2856 group_id_len - ETH_ALEN == s->ssid_len &&
2857 os_memcmp(group_id + ETH_ALEN, s->ssid,
2858 s->ssid_len) == 0)
2875 group ? group->ifname : "");
2878 params[sizeof(params) - 1] = '\0';
2908 if (wpa_s->pending_pd_before_join &&
2909 (ether_addr_equal(peer, wpa_s->pending_join_dev_addr) ||
2910 ether_addr_equal(peer, wpa_s->pending_join_iface_addr))) {
2911 wpa_s->pending_pd_before_join = 0;
2913 "join-existing-group operation");
2918 if (wpa_s->pending_pd_use == AUTO_PD_JOIN ||
2919 wpa_s->pending_pd_use == AUTO_PD_GO_NEG) {
2923 wpa_s->pending_pd_use == AUTO_PD_JOIN);
2925 params[sizeof(params) - 1] = '\0';
2958 if (wpa_s->p2p_fallback_to_go_neg) {
2959 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto "
2960 "failed - fall back to GO Negotiation");
2961 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
2963 "reason=PD-failed");
2969 wpa_s->pending_pd_before_join = 0;
2971 "join-existing-group operation (no ACK for PD "
3020 ret = p2p_group_get_common_freqs(wpa_s->p2p_group, common_freqs, &num);
3028 os_free(wpa_s->p2p_group_common_freqs);
3029 wpa_s->p2p_group_common_freqs = common_freqs;
3030 wpa_s->p2p_group_common_freqs_num = num;
3046 if (!wpa_s->p2p_group_common_freqs_num)
3049 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
3050 if (wpa_s->p2p_group_common_freqs[i] == freq)
3062 *ecsa_support &= sta->ecsa_supported;
3073 ap_for_each_sta(wpa_s->ap_iface->bss[0], wpas_sta_check_ecsa,
3091 if (p2p_supported_freq(wpa_s->global->p2p, freqs[c].freq))
3099 if (!p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
3123 * - input: the max size of pref_freq_list,
3124 * - output: the valid size of pref_freq_list filled with data.
3145 if (!res && !is_p2p_allow_6ghz(wpa_s->global->p2p))
3157 (!p2p_supported_freq(wpa_s->global->p2p,
3159 wpas_p2p_disallowed_freq(wpa_s->global,
3202 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
3203 (ether_addr_equal(go_dev_addr, wpa_s->p2p_auth_invite) ||
3204 ether_addr_equal(sa, wpa_s->p2p_auth_invite))) {
3211 if (dev_pw_id >= 0 && wpa_s->p2p_nfc_tag_enabled &&
3212 dev_pw_id == wpa_s->p2p_oob_dev_pw_id) {
3214 wpa_s->p2p_wps_method = WPS_NFC;
3215 wpa_s->pending_join_wps_method = WPS_NFC;
3216 os_memcpy(wpa_s->pending_join_dev_addr,
3218 os_memcpy(wpa_s->pending_join_iface_addr,
3236 os_memcpy(group_bssid, grp->own_addr, ETH_ALEN);
3240 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
3241 ether_addr_equal(sa, wpa_s->p2p_auth_invite)) {
3243 "invitation to re-invoke a persistent group");
3244 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
3245 } else if (!wpa_s->conf->persistent_reconnect)
3248 for (s = wpa_s->conf->ssid; s; s = s->next) {
3249 if (s->disabled == 2 &&
3250 ether_addr_equal(s->bssid, go_dev_addr) &&
3251 s->ssid_len == ssid_len &&
3252 os_memcmp(ssid, s->ssid, ssid_len) == 0)
3263 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
3265 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
3267 "interface is already in use - reject "
3271 if (wpa_s->p2p_mgmt)
3272 os_memcpy(group_bssid, wpa_s->parent->own_addr,
3275 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
3276 } else if (s->mode == WPAS_MODE_P2P_GO) {
3284 os_memcpy(group_bssid, wpa_s->pending_interface_addr,
3292 freqs = os_calloc(wpa_s->num_multichan_concurrent,
3295 int num_channels = wpa_s->num_multichan_concurrent;
3312 if (wpa_s->num_multichan_concurrent < 2 ||
3314 wpa_printf(MSG_DEBUG, "P2P: No extra channels available - trying to force channel to match a channel already used by one of the interfaces");
3319 if (*force_freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
3350 for (s = wpa_s->conf->ssid; s; s = s->next) {
3351 if (s->disabled == 2 &&
3352 s->ssid_len == ssid_len &&
3353 os_memcmp(ssid, s->ssid, ssid_len) == 0)
3362 int go = s->mode == WPAS_MODE_P2P_GO;
3368 MAC2STR(sa), s->id, op_freq);
3374 MAC2STR(sa), s->id);
3378 wpa_s->conf->p2p_go_ht40,
3379 wpa_s->conf->p2p_go_vht,
3381 wpa_s->conf->p2p_go_he,
3382 wpa_s->conf->p2p_go_edmg, NULL,
3384 1, is_p2p_allow_6ghz(wpa_s->global->p2p), 0,
3387 wpa_s->user_initiated_pd = 0;
3391 " bssid=" MACSTR " unknown-network",
3395 wpa_s->p2p_wps_method, 0, op_freq,
3412 " bssid=" MACSTR " unknown-network",
3419 " unknown-network",
3427 if (s->mode == WPAS_MODE_P2P_GO && op_freq) {
3430 MAC2STR(sa), s->id, op_freq);
3434 MAC2STR(sa), s->id);
3437 s->id, op_freq);
3446 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
3451 for (i = 0; ssid->p2p_client_list && i < ssid->num_p2p_clients; i++) {
3452 if (ether_addr_equal(ssid->p2p_client_list + i * 2 * ETH_ALEN,
3456 if (i >= ssid->num_p2p_clients || !ssid->p2p_client_list) {
3457 if (ssid->mode != WPAS_MODE_P2P_GO &&
3458 ether_addr_equal(ssid->bssid, peer)) {
3460 "due to invitation result", ssid->id);
3462 wpa_config_remove_network(wpa_s->conf, ssid->id);
3470 MAC2STR(peer), ssid->id,
3472 os_memmove(ssid->p2p_client_list + i * 2 * ETH_ALEN,
3473 ssid->p2p_client_list + (i + 1) * 2 * ETH_ALEN,
3474 (ssid->num_p2p_clients - i - 1) * 2 * ETH_ALEN);
3475 ssid->num_p2p_clients--;
3476 if (p2p_wpa_s->conf->update_config &&
3477 wpa_config_write(p2p_wpa_s->confname, p2p_wpa_s->conf))
3487 wpa_s = wpa_s->global->p2p_invite_group;
3490 ssid = wpa_s->current_ssid;
3491 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
3492 !ssid->p2p_persistent_group)
3494 ssid = wpas_p2p_get_persistent(wpa_s->p2pdev, peer,
3495 ssid->ssid, ssid->ssid_len);
3519 wpa_printf(MSG_DEBUG, "P2P: Invitation result - status=%d peer=" MACSTR,
3521 if (wpa_s->pending_invite_ssid_id == -1) {
3523 wpa_s->global->p2p_invite_group;
3535 group_if && group_if->current_ssid &&
3536 group_if->current_ssid->mode == WPAS_MODE_P2P_GO) {
3537 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
3539 if (group_if->p2p_go_csa_on_inv) {
3558 "re-invocation");
3564 wpa_s->conf, wpa_s->pending_invite_ssid_id);
3571 ssid = wpa_config_get_network(wpa_s->conf,
3572 wpa_s->pending_invite_ssid_id);
3591 if (neg_freq > 0 && ssid->mode == WPAS_MODE_P2P_GO &&
3594 else if (peer_oper_freq > 0 && ssid->mode != WPAS_MODE_P2P_GO &&
3600 wpa_printf(MSG_DEBUG, "P2P: Persistent group invitation success - op_freq=%d MHz SSID=%s",
3601 freq, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
3603 ssid->mode == WPAS_MODE_P2P_GO,
3604 wpa_s->p2p_persistent_go_freq,
3606 wpa_s->p2p_go_vht_center_freq2,
3607 wpa_s->p2p_go_ht40, wpa_s->p2p_go_vht,
3608 wpa_s->p2p_go_max_oper_chwidth,
3609 wpa_s->p2p_go_he,
3610 wpa_s->p2p_go_edmg,
3612 ssid->mode == WPAS_MODE_P2P_GO ?
3615 is_p2p_allow_6ghz(wpa_s->global->p2p), 0,
3623 if (freq_range_list_includes(&global->p2p_go_avoid_freq, freq))
3625 return freq_range_list_includes(&global->p2p_disallow_freq, freq);
3631 reg->channel[reg->channels] = chan;
3632 reg->channels++;
3642 wpa_s->global->p2p_24ghz_social_channels = 1;
3649 /* Operating class 81 - 2.4 GHz band channels 1..13 */
3650 chan->reg_class[cla].reg_class = 81;
3651 chan->reg_class[cla].channels = 0;
3653 if (!wpas_p2p_disallowed_freq(wpa_s->global, 2412 + i * 5))
3654 wpas_p2p_add_chan(&chan->reg_class[cla], i + 1);
3656 if (chan->reg_class[cla].channels)
3662 /* Operating class 115 - 5 GHz, channels 36-48 */
3663 chan->reg_class[cla].reg_class = 115;
3664 chan->reg_class[cla].channels = 0;
3665 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5))
3666 wpas_p2p_add_chan(&chan->reg_class[cla], 36);
3667 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5))
3668 wpas_p2p_add_chan(&chan->reg_class[cla], 40);
3669 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5))
3670 wpas_p2p_add_chan(&chan->reg_class[cla], 44);
3671 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5))
3672 wpas_p2p_add_chan(&chan->reg_class[cla], 48);
3673 if (chan->reg_class[cla].channels)
3679 /* Operating class 124 - 5 GHz, channels 149,153,157,161 */
3680 chan->reg_class[cla].reg_class = 124;
3681 chan->reg_class[cla].channels = 0;
3682 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5))
3683 wpas_p2p_add_chan(&chan->reg_class[cla], 149);
3684 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5))
3685 wpas_p2p_add_chan(&chan->reg_class[cla], 153);
3686 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5))
3687 wpas_p2p_add_chan(&chan->reg_class[cla], 157);
3688 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5))
3689 wpas_p2p_add_chan(&chan->reg_class[cla], 161);
3690 if (chan->reg_class[cla].channels)
3693 chan->reg_classes = cla;
3709 for (i = 0; i < mode->num_channels; i++) {
3710 if ((unsigned int) mode->channels[i].freq == freq) {
3712 *flags = mode->channels[i].flag;
3713 if (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED)
3715 if (mode->channels[i].flag & HOSTAPD_CHAN_NO_IR)
3717 if (mode->channels[i].flag & HOSTAPD_CHAN_RADAR)
3734 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
3739 * In 80 MHz, the bandwidth "spans" 12 channels (e.g., 36-48),
3742 if (channel >= center_channels[i] - 6 &&
3778 if (!wpa_s->p2p_go_allow_dfs &&
3784 int adj_chan = center_chan - 6 + i * 4;
3786 res = has_channel(wpa_s->global, mode, op_class, adj_chan,
3815 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
3820 * In 160 MHz, the bandwidth "spans" 28 channels (e.g., 36-64),
3823 if (channel >= center_channels[i] - 14 &&
3860 int adj_chan = center_chan - 14 + i * 4;
3862 res = has_channel(wpa_s->global, mode, op_class, adj_chan,
3894 if (edmg.channels && ieee802_edmg_is_allowed(mode->edmg, edmg))
3912 res2 = res = has_channel(wpa_s->global, mode, op_class, channel, &flag);
3916 res2 = has_channel(wpa_s->global, mode, op_class, channel - 4,
3921 res2 = has_channel(wpa_s->global, mode, op_class, channel + 4,
3924 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
3927 res2 = has_channel(wpa_s->global, mode, op_class,
3928 channel - 4, NULL);
3930 res2 = has_channel(wpa_s->global, mode, op_class,
3960 if (wpa_s->hw.modes == NULL) {
3974 if (o->p2p == NO_P2P_SUPP ||
3975 (is_6ghz_op_class(o->op_class) && p2p_disable_6ghz))
3978 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode,
3979 is_6ghz_op_class(o->op_class));
3982 if (mode->mode == HOSTAPD_MODE_IEEE80211G)
3983 wpa_s->global->p2p_24ghz_social_channels = 1;
3984 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
3987 /* Check for non-continuous jump in channel index
3989 if ((o->op_class >= 128 && o->op_class <= 130) &&
3990 ch < 149 && ch + o->inc > 149)
3993 res = wpas_p2p_verify_channel(wpa_s, mode, o->op_class,
3994 ch, o->bw);
4000 o->op_class);
4001 reg = &chan->reg_class[cla];
4003 reg->reg_class = o->op_class;
4005 if (reg->channels == P2P_MAX_REG_CLASS_CHANNELS)
4007 reg->channel[reg->channels] = ch;
4008 reg->channels++;
4010 wpa_s->conf->p2p_add_cli_chan) {
4015 o->op_class);
4016 cli_reg = &cli_chan->reg_class[cli_cla];
4018 cli_reg->reg_class = o->op_class;
4020 if (cli_reg->channels ==
4023 cli_reg->channel[cli_reg->channels] = ch;
4024 cli_reg->channels++;
4029 reg->channel, reg->channels);
4033 cli_reg->channel, cli_reg->channels);
4037 chan->reg_classes = cla;
4038 cli_chan->reg_classes = cli_cla;
4057 if ((o->p2p == NO_P2P_SUPP &&
4058 (!is_dfs_global_op_class(o->op_class) ||
4059 !wpa_s->p2p_go_allow_dfs)) ||
4060 (is_6ghz_op_class(o->op_class) &&
4061 wpa_s->conf->p2p_6ghz_disable))
4064 /* IEEE Std 802.11ax-2021 26.17.2.3.2: "A 6 GHz-only AP should
4071 if (is_6ghz_op_class(o->op_class) && o->bw == BW40 &&
4075 for (ch += o->min_chan; ch <= o->max_chan; ch += o->inc) {
4076 if (o->mode != HOSTAPD_MODE_IEEE80211A ||
4077 (o->bw != BW40PLUS && o->bw != BW40MINUS &&
4078 o->bw != BW40) ||
4081 ret = wpas_p2p_verify_channel(wpa_s, mode, o->op_class,
4082 ch, o->bw);
4084 if (is_6ghz_op_class(o->op_class) &&
4085 o->bw == BW40)
4087 return (o->bw == BW40MINUS) ? -1 : 1;
4089 if (ret == RADAR && wpa_s->p2p_go_allow_dfs) {
4092 return (o->bw == BW40MINUS) ? -1 : 1;
4109 if (!(ret == ALLOWED || (ret == RADAR && wpa_s->p2p_go_allow_dfs)))
4133 if (!(ret == ALLOWED || (ret == RADAR && wpa_s->p2p_go_allow_dfs)))
4152 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4153 if (ether_addr_equal(wpa_s->own_addr, interface_addr))
4157 return -1;
4166 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4167 struct wpa_ssid *s = wpa_s->current_ssid;
4170 if (s->mode != WPAS_MODE_P2P_GO &&
4171 s->mode != WPAS_MODE_AP &&
4172 s->mode != WPAS_MODE_P2P_GROUP_FORMATION)
4174 if (s->ssid_len != ssid_len ||
4175 os_memcmp(ssid, s->ssid, ssid_len) != 0)
4188 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4189 struct wpa_ssid *ssid = wpa_s->current_ssid;
4190 if (ssid && (ssid->mode != WPAS_MODE_INFRA || !ssid->p2p_group))
4192 if (ether_addr_equal(wpa_s->go_dev_addr, peer_dev_addr))
4213 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
4216 if (ifs->wpa_state > WPA_ASSOCIATED)
4223 static void wpas_p2p_debug_print(void *ctx, int level, const char *msg)
4226 wpa_msg_global(wpa_s, level, "P2P: %s", msg);
4241 wpa_s->ifname);
4243 return -1;
4247 ifname[IFNAMSIZ - 1] = '\0';
4249 wpa_s->pending_interface_type = WPA_IF_P2P_DEVICE;
4251 if (wpa_s->conf->p2p_device_random_mac_addr == 2 &&
4252 !is_zero_ether_addr(wpa_s->conf->p2p_device_persistent_mac_addr))
4253 if_addr = wpa_s->conf->p2p_device_persistent_mac_addr;
4256 force_name, wpa_s->pending_interface_addr, NULL);
4261 os_strlcpy(wpa_s->pending_interface_name, ifname,
4262 sizeof(wpa_s->pending_interface_name));
4266 iface.ifname = wpa_s->pending_interface_name;
4267 iface.driver = wpa_s->driver->name;
4268 iface.driver_param = wpa_s->conf->driver_param;
4278 iface.confname = wpa_s->confname;
4279 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
4282 p2pdev_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface, wpa_s);
4285 return -1;
4288 p2pdev_wpa_s->p2pdev = p2pdev_wpa_s;
4289 wpa_s->pending_interface_name[0] = '\0';
4300 for (wpa_s = intf->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4301 if (wpa_s->waiting_presence_resp)
4308 wpa_s->waiting_presence_resp = 0;
4326 os_memcpy(ret_ssid, s->ssid, s->ssid_len);
4327 *ret_ssid_len = s->ssid_len;
4328 os_memcpy(go_dev_addr, s->bssid, ETH_ALEN);
4330 if (s->mode != WPAS_MODE_P2P_GO) {
4337 wpa_s->pending_interface_addr, ETH_ALEN);
4339 os_memcpy(intended_iface_addr, wpa_s->own_addr,
4374 os_memcpy(intended_addr, s->bssid, ETH_ALEN);
4378 s = go->current_ssid;
4379 os_memcpy(intended_addr, go->own_addr, ETH_ALEN);
4381 *freq = go->assoc_freq;
4384 os_memcpy(ssid, s->ssid, s->ssid_len);
4385 *ssid_len = s->ssid_len;
4402 s->ssid_len == ssid_len &&
4403 ether_addr_equal(go, s->bssid) &&
4404 os_memcmp(ssid, s->ssid, ssid_len) == 0)
4408 if (s->mode != WPAS_MODE_P2P_GO || s->num_p2p_clients <= 1) {
4411 s->id);
4413 wpa_config_remove_network(wpa_s->conf, s->id);
4418 for (i = 0; i < s->num_p2p_clients; i++) {
4419 if (!ether_addr_equal(s->p2p_client_list +
4423 os_memmove(s->p2p_client_list + i * 2 * ETH_ALEN,
4424 s->p2p_client_list + (i + 1) * 2 * ETH_ALEN,
4425 (s->num_p2p_clients - i - 1) * 2 * ETH_ALEN);
4428 s->num_p2p_clients--;
4459 ret = wpa_snprintf_hex(&buf[sizeof(pref) - 1],
4460 buf_len - sizeof(pref) + 1,
4532 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
4534 if (persistent_go && !persistent_go->num_p2p_clients) {
4538 persistent_go->id);
4541 wpa_config_remove_network(wpa_s->conf,
4542 persistent_go->id);
4561 if (persist_ssid && s && s->mode != WPAS_MODE_P2P_GO &&
4573 if (s && s->ssid_len == stale->ssid_len &&
4574 ether_addr_equal(stale->bssid, s->bssid) &&
4575 os_memcmp(stale->ssid, s->ssid, s->ssid_len) == 0)
4579 if (stale->mode != WPAS_MODE_P2P_GO ||
4580 stale->num_p2p_clients <= 1) {
4583 stale->id);
4585 wpa_config_remove_network(wpa_s->conf, stale->id);
4589 for (i = 0; i < stale->num_p2p_clients; i++) {
4590 if (ether_addr_equal(stale->p2p_client_list +
4592 os_memmove(stale->p2p_client_list +
4594 stale->p2p_client_list +
4596 (stale->num_p2p_clients -
4597 i - 1) * ETH_ALEN);
4601 stale->num_p2p_clients--;
4611 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
4614 !persistent_go->num_p2p_clients) {
4618 persistent_go->id);
4621 wpa_config_remove_network(wpa_s->conf,
4622 persistent_go->id);
4634 ses_id, MAC2STR(ses_mac), s->id, feat_cap_str);
4638 wpa_s->global->pending_p2ps_group = 0;
4639 wpa_s->global->pending_p2ps_group_freq = 0;
4652 wpa_s->global->pending_p2ps_group = 1;
4653 wpa_s->global->pending_p2ps_group_freq = freq;
4657 os_memcpy(go_ifname, wpa_s->ifname,
4659 else if (wpa_s->pending_interface_name[0])
4661 wpa_s->pending_interface_name,
4679 persistent_go->mode ==
4689 os_memcpy(wpa_s->p2ps_join_addr, grp_mac,
4691 wpa_s->p2ps_method_config_any = 1;
4694 os_memcpy(go_ifname, go_wpa_s->ifname,
4699 "P2P: Setting PIN-1 for ANY");
4705 "P2P: Setting PIN-1 for " MACSTR,
4712 os_memcpy(wpa_s->p2ps_join_addr, grp_mac, ETH_ALEN);
4713 wpa_s->p2ps_method_config_any = 1;
4730 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
4732 if (persistent_go && !persistent_go->num_p2p_clients) {
4736 persistent_go->id);
4738 wpa_config_remove_network(wpa_s->conf, persistent_go->id);
4788 if (!wpa_s->global->pending_p2ps_group)
4791 freq = wpa_s->global->pending_p2ps_group_freq;
4792 wpa_s->global->pending_p2ps_group_freq = 0;
4793 wpa_s->global->pending_p2ps_group = 0;
4803 persistent_go->mode == WPAS_MODE_P2P_GO ?
4805 is_p2p_allow_6ghz(wpa_s->global->p2p), 0, NULL);
4808 is_p2p_allow_6ghz(wpa_s->global->p2p));
4830 if (wpa_s->conf->p2p_device_random_mac_addr == 0)
4833 if (wpa_s->conf->p2p_device_random_mac_addr == 2) {
4835 wpa_s->conf->p2p_device_persistent_mac_addr) &&
4836 !is_zero_ether_addr(wpa_s->own_addr)) {
4837 os_memcpy(wpa_s->conf->p2p_device_persistent_mac_addr,
4838 wpa_s->own_addr, ETH_ALEN);
4843 if (!wpa_s->conf->ssid) {
4847 return -EINVAL;
4851 os_memcpy(wpa_s->conf->p2p_device_persistent_mac_addr, addr,
4858 wpa_s->conf->p2p_device_persistent_mac_addr))
4860 os_memcpy(addr, wpa_s->conf->p2p_device_persistent_mac_addr,
4868 return -EINVAL;
4874 return -EINVAL;
4885 * wpas_p2p_init - Initialize P2P module for %wpa_supplicant
4888 * Returns: 0 on success, -1 on failure
4895 if (wpa_s->conf->p2p_disabled)
4898 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
4901 if (global->p2p)
4907 return -1;
4944 p2p.p2p_6ghz_disable = wpa_s->conf->p2p_6ghz_disable;
4946 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
4947 os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN);
4948 p2p.dev_name = wpa_s->conf->device_name;
4949 p2p.manufacturer = wpa_s->conf->manufacturer;
4950 p2p.model_name = wpa_s->conf->model_name;
4951 p2p.model_number = wpa_s->conf->model_number;
4952 p2p.serial_number = wpa_s->conf->serial_number;
4953 if (wpa_s->wps) {
4954 os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16);
4955 p2p.config_methods = wpa_s->wps->config_methods;
4962 return -1;
4965 if (wpa_s->conf->p2p_listen_reg_class &&
4966 wpa_s->conf->p2p_listen_channel) {
4967 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
4968 p2p.channel = wpa_s->conf->p2p_listen_channel;
4977 &global->p2p_go_avoid_freq,
4978 &global->p2p_disallow_freq) !=
4981 "P2P: No social channels supported by the driver - do not enable P2P");
4989 if (wpa_s->conf->p2p_oper_reg_class &&
4990 wpa_s->conf->p2p_oper_channel) {
4991 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
4992 p2p.op_channel = wpa_s->conf->p2p_oper_channel;
5018 if (wpa_s->conf->p2p_pref_chan && wpa_s->conf->num_p2p_pref_chan) {
5019 p2p.pref_chan = wpa_s->conf->p2p_pref_chan;
5020 p2p.num_pref_chan = wpa_s->conf->num_p2p_pref_chan;
5023 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5024 os_memcpy(p2p.country, wpa_s->conf->country, 2);
5029 os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type,
5032 p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
5033 os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type,
5036 p2p.concurrent_operations = !!(wpa_s->drv_flags &
5041 if (wpa_s->conf->p2p_ssid_postfix) {
5043 os_strlen(wpa_s->conf->p2p_ssid_postfix);
5046 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
5050 p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss;
5052 p2p.max_listen = wpa_s->max_remain_on_chan;
5054 if (wpa_s->conf->p2p_passphrase_len >= 8 &&
5055 wpa_s->conf->p2p_passphrase_len <= 63)
5056 p2p.passphrase_len = wpa_s->conf->p2p_passphrase_len;
5060 global->p2p = p2p_init(&p2p);
5061 if (global->p2p == NULL)
5062 return -1;
5063 global->p2p_init_wpa_s = wpa_s;
5066 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
5069 global->p2p, wpa_s->conf->wps_vendor_ext[i]);
5072 p2p_set_no_go_freq(global->p2p, &wpa_s->conf->p2p_no_go_freq);
5079 * wpas_p2p_deinit - Deinitialize per-interface P2P data
5082 * This function deinitialize per-interface P2P data.
5086 if (wpa_s->driver && wpa_s->drv_priv)
5089 if (wpa_s->go_params) {
5092 wpa_s->global->p2p,
5093 wpa_s->go_params->peer_device_addr);
5096 os_free(wpa_s->go_params);
5097 wpa_s->go_params = NULL;
5101 wpa_s->global->p2p_long_listen = 0;
5108 if (wpa_s->p2p_send_action_work) {
5109 os_free(wpa_s->p2p_send_action_work->ctx);
5110 radio_work_done(wpa_s->p2p_send_action_work);
5111 wpa_s->p2p_send_action_work = NULL;
5115 wpabuf_free(wpa_s->p2p_oob_dev_pw);
5116 wpa_s->p2p_oob_dev_pw = NULL;
5118 os_free(wpa_s->p2p_group_common_freqs);
5119 wpa_s->p2p_group_common_freqs = NULL;
5120 wpa_s->p2p_group_common_freqs_num = 0;
5128 * wpas_p2p_deinit_global - Deinitialize global P2P module
5137 wpa_s = global->ifaces;
5139 wpas_p2p_service_flush(global->p2p_init_wpa_s);
5142 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
5143 wpa_s = wpa_s->next;
5145 tmp = global->ifaces;
5148 tmp->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)) {
5149 tmp = tmp->next;
5161 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5162 if (wpa_s->ap_iface)
5166 p2p_deinit(global->p2p);
5167 global->p2p = NULL;
5168 global->p2p_init_wpa_s = NULL;
5174 if (wpa_s->conf->p2p_no_group_iface)
5176 if (wpa_s->drv_flags &
5181 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
5183 if (wpa_s->global->ifaces->next)
5185 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
5198 if (persistent_group && wpa_s->conf->persistent_reconnect)
5205 p2p_set_config_timeout(wpa_s->global->p2p,
5206 wpa_s->p2p_go_ht40 ? 255 : 100, 20);
5208 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
5210 persistent_group, ssid ? ssid->ssid : NULL,
5211 ssid ? ssid->ssid_len : 0,
5212 wpa_s->p2p_pd_before_go_neg, pref_freq,
5213 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
5225 if (persistent_group && wpa_s->conf->persistent_reconnect)
5228 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
5230 persistent_group, ssid ? ssid->ssid : NULL,
5231 ssid ? ssid->ssid_len : 0, pref_freq,
5232 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
5239 wpa_s->p2p_join_scan_count++;
5241 wpa_s->p2p_join_scan_count);
5242 if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) {
5244 " for join operationg - stop join attempt",
5245 MAC2STR(wpa_s->pending_join_iface_addr));
5247 if (wpa_s->p2p_auto_pd) {
5248 wpa_s->p2p_auto_pd = 0;
5252 MAC2STR(wpa_s->pending_join_dev_addr));
5255 if (wpa_s->p2p_fallback_to_go_neg) {
5257 "P2P: Join operation failed - fall back to GO Negotiation");
5258 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
5260 "reason=join-failed");
5264 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
5282 freqs = os_calloc(wpa_s->num_multichan_concurrent,
5288 wpa_s->num_multichan_concurrent);
5316 return -1;
5317 if (bss->last_update_idx < wpa_s->bss_update_idx) {
5323 updated = os_reltime_before(&wpa_s->p2p_auto_started,
5324 &bss->last_update);
5327 bss->last_update.sec, bss->last_update.usec,
5343 if (wpa_s->global->p2p_disabled)
5347 scan_res ? (int) scan_res->num : -1,
5348 wpa_s->p2p_auto_join ? "auto_" : "");
5353 if (wpa_s->p2p_auto_pd) {
5355 wpa_s->pending_join_dev_addr);
5357 wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) {
5358 wpa_s->auto_pd_scan_retry++;
5360 wpa_s, wpa_s->pending_join_dev_addr);
5362 freq = bss->freq;
5365 wpa_s->auto_pd_scan_retry,
5366 MAC2STR(wpa_s->
5377 wpa_s->p2p_auto_pd = 0;
5378 wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG;
5380 MAC2STR(wpa_s->pending_join_dev_addr), join);
5381 if (p2p_prov_disc_req(wpa_s->global->p2p,
5382 wpa_s->pending_join_dev_addr, NULL,
5383 wpa_s->pending_pd_config_methods, join,
5384 0, wpa_s->user_initiated_pd) < 0) {
5385 wpa_s->p2p_auto_pd = 0;
5389 MAC2STR(wpa_s->pending_join_dev_addr));
5394 if (wpa_s->p2p_auto_join) {
5396 wpa_s->pending_join_dev_addr);
5399 "running a GO -> use GO Negotiation");
5400 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
5402 "reason=peer-not-running-GO");
5403 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr,
5404 wpa_s->p2p_pin, wpa_s->p2p_wps_method,
5405 wpa_s->p2p_persistent_group, 0, 0, 0,
5406 wpa_s->p2p_go_intent,
5407 wpa_s->p2p_connect_freq,
5408 wpa_s->p2p_go_vht_center_freq2,
5409 wpa_s->p2p_persistent_id,
5410 wpa_s->p2p_pd_before_go_neg,
5411 wpa_s->p2p_go_ht40,
5412 wpa_s->p2p_go_vht,
5413 wpa_s->p2p_go_max_oper_chwidth,
5414 wpa_s->p2p_go_he,
5415 wpa_s->p2p_go_edmg,
5417 is_p2p_allow_6ghz(wpa_s->global->p2p));
5421 wpa_printf(MSG_DEBUG, "P2P: Peer was found running GO%s -> "
5425 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
5427 wpa_s->p2p_fallback_to_go_neg = 1;
5431 freq = p2p_get_oper_freq(wpa_s->global->p2p,
5432 wpa_s->pending_join_iface_addr);
5434 p2p_get_interface_addr(wpa_s->global->p2p,
5435 wpa_s->pending_join_dev_addr,
5437 !ether_addr_equal(iface_addr, wpa_s->pending_join_dev_addr) &&
5438 !wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr)) {
5442 MAC2STR(wpa_s->pending_join_iface_addr),
5444 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr,
5447 freq = p2p_get_oper_freq(wpa_s->global->p2p,
5448 wpa_s->pending_join_iface_addr);
5454 if (wpa_s->p2p_join_ssid_len) {
5457 MAC2STR(wpa_s->pending_join_iface_addr),
5458 wpa_ssid_txt(wpa_s->p2p_join_ssid,
5459 wpa_s->p2p_join_ssid_len));
5460 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr,
5461 wpa_s->p2p_join_ssid,
5462 wpa_s->p2p_join_ssid_len);
5465 MACSTR, MAC2STR(wpa_s->pending_join_iface_addr));
5467 wpa_s->pending_join_iface_addr);
5472 freq = bss->freq;
5475 wpa_ssid_txt(bss->ssid, bss->ssid_len));
5476 if (p2p_parse_dev_addr(wpa_bss_ie_ptr(bss), bss->ie_len,
5478 ether_addr_equal(wpa_s->pending_join_dev_addr,
5479 wpa_s->pending_join_iface_addr) &&
5480 !ether_addr_equal(dev_addr, wpa_s->pending_join_dev_addr)) {
5484 MAC2STR(wpa_s->pending_join_dev_addr));
5485 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr,
5493 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
5504 MAC2STR(wpa_s->pending_join_dev_addr), freq);
5505 wpa_s->pending_pd_before_join = 1;
5507 switch (wpa_s->pending_join_wps_method) {
5525 if ((p2p_get_provisioning_info(wpa_s->global->p2p,
5526 wpa_s->pending_join_dev_addr) ==
5533 "with " MACSTR " already done - proceed to "
5535 MAC2STR(wpa_s->pending_join_dev_addr));
5536 wpa_s->pending_pd_before_join = 0;
5540 if (p2p_prov_disc_req(wpa_s->global->p2p,
5541 wpa_s->pending_join_dev_addr,
5543 freq, wpa_s->user_initiated_pd) < 0) {
5547 wpa_s->pending_pd_before_join = 0;
5553 wpa_printf(MSG_DEBUG, "P2P: Failed to find BSS/GO - try again later");
5561 wpas_p2p_join_start(wpa_s, 0, wpa_s->p2p_join_ssid,
5562 wpa_s->p2p_join_ssid_len);
5583 os_memcpy(wpa_s->p2p_join_ssid, ssid, ssid_len);
5584 wpa_s->p2p_join_ssid_len = ssid_len;
5588 wpa_s->p2p_join_ssid_len = 0;
5591 wpa_s->wps->dev.p2p = 1;
5592 wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT, &wpa_s->wps->dev,
5593 wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 0,
5606 oper_freq = p2p_get_oper_freq(wpa_s->global->p2p,
5607 wpa_s->pending_join_iface_addr);
5618 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
5629 p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands);
5635 if (wpa_s->clear_driver_scan_cache) {
5649 os_get_reltime(&wpa_s->scan_trigger_time);
5650 wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
5651 wpa_s->own_scan_requested = 1;
5652 wpa_s->clear_driver_scan_cache = 0;
5658 wpa_printf(MSG_DEBUG, "P2P: Failed to start scan for join - "
5688 wpa_s->p2p_auto_pd = 0;
5689 wpa_s->p2p_auto_join = !!auto_join;
5690 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
5691 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
5692 wpa_s->pending_join_wps_method = wps_method;
5697 wpa_s->p2p_join_scan_count = 0;
5712 return -1;
5714 os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
5715 sizeof(group->p2p_pin));
5716 group->p2p_wps_method = wpa_s->p2p_wps_method;
5722 * to allow p2p_cancel stop a pending p2p_connect-join.
5726 if (group == wpa_s->parent)
5727 wpa_s->global->p2p_group_formation = group;
5729 group->p2p_in_provisioning = 1;
5730 group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg;
5733 os_memcpy(res.peer_device_addr, wpa_s->pending_join_dev_addr, ETH_ALEN);
5734 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
5736 res.wps_method = wpa_s->pending_join_wps_method;
5743 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr,
5747 wpa_s, wpa_s->pending_join_iface_addr);
5750 res.freq = bss->freq;
5751 res.ssid_len = bss->ssid_len;
5752 os_memcpy(res.ssid, bss->ssid, bss->ssid_len);
5754 bss->freq,
5755 wpa_ssid_txt(bss->ssid, bss->ssid_len));
5764 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
5765 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel prior to "
5768 wpa_s->off_channel_freq = 0;
5769 wpa_s->roc_waiting_drv_freq = 0;
5774 * Allow a longer timeout for join-a-running-group than normal 15
5798 freqs = os_calloc(wpa_s->num_multichan_concurrent,
5801 return -1;
5804 wpa_s->num_multichan_concurrent);
5815 freq, wpa_s->num_multichan_concurrent, num, num_unused);
5820 ret = p2p_supported_freq(wpa_s->global->p2p, freq);
5822 ret = p2p_supported_freq_cli(wpa_s->global->p2p, freq);
5824 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
5825 ieee80211_is_dfs(freq, wpa_s->hw.modes,
5826 wpa_s->hw.num_modes)) {
5838 res = -3;
5851 res = -2;
5862 if (!wpa_s->conf->num_p2p_pref_chan && *pref_freq == 0) {
5891 res = -2;
5906 if (wpa_s->conf->p2p_6ghz_disable ||
5907 !get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
5911 if (!p2p_wfd_enabled(wpa_s->global->p2p))
5913 if (peer_addr && !p2p_peer_wfd_enabled(wpa_s->global->p2p, peer_addr))
5926 p2p_set_6ghz_dev_capab(wpa_s->global->p2p, true);
5929 return -2;
5930 p2p_set_6ghz_dev_capab(wpa_s->global->p2p, false);
5938 * wpas_p2p_connect - Request P2P Group Formation to be started
5948 * @go_intent: GO Intent or -1 to use default
5949 * @freq: Frequency for the group or 0 for auto-selection
5952 * parameters or -1 to generate new values (SSID/passphrase)
5962 * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on unspecified
5963 * failure, -2 on failure due to channel not currently available,
5964 * -3 if forced channel is not supported
5983 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5984 return -1;
5987 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
5988 if (ssid == NULL || ssid->disabled != 2 ||
5989 ssid->mode != WPAS_MODE_P2P_GO)
5990 return -1;
5994 return -2;
5996 os_free(wpa_s->global->add_psk);
5997 wpa_s->global->add_psk = NULL;
5999 wpa_s->global->p2p_fail_on_wps_complete = 0;
6000 wpa_s->global->pending_p2ps_group = 0;
6001 wpa_s->global->pending_p2ps_group_freq = 0;
6002 wpa_s->p2ps_method_config_any = 0;
6005 go_intent = wpa_s->conf->p2p_go_intent;
6008 wpa_s->global->p2p_long_listen = 0;
6010 wpa_s->p2p_wps_method = wps_method;
6011 wpa_s->p2p_persistent_group = !!persistent_group;
6012 wpa_s->p2p_persistent_id = persistent_id;
6013 wpa_s->p2p_go_intent = go_intent;
6014 wpa_s->p2p_connect_freq = freq;
6015 wpa_s->p2p_fallback_to_go_neg = 0;
6016 wpa_s->p2p_pd_before_go_neg = !!pd;
6017 wpa_s->p2p_go_ht40 = !!ht40;
6018 wpa_s->p2p_go_vht = !!vht;
6019 wpa_s->p2p_go_vht_center_freq2 = vht_center_freq2;
6020 wpa_s->p2p_go_max_oper_chwidth = vht_chwidth;
6021 wpa_s->p2p_go_he = !!he;
6022 wpa_s->p2p_go_edmg = !!edmg;
6025 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
6028 return -1;
6029 res = os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin),
6031 if (os_snprintf_error(sizeof(wpa_s->p2p_pin), res))
6032 wpa_s->p2p_pin[sizeof(wpa_s->p2p_pin) - 1] = '\0';
6034 wpa_s->p2p_pin);
6037 os_strlcpy(wpa_s->p2p_pin, "12345670", sizeof(wpa_s->p2p_pin));
6039 wpa_s->p2p_pin[0] = '\0';
6047 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
6051 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
6054 p2p_get_dev_addr(wpa_s->global->p2p, peer_addr,
6058 os_get_reltime(&wpa_s->p2p_auto_started);
6061 wpa_s->p2p_auto_started.sec,
6062 wpa_s->p2p_auto_started.usec);
6064 wpa_s->user_initiated_pd = 1;
6068 return -1;
6080 p2p_set_own_pref_freq_list(wpa_s->global->p2p, pref_freq_list, size);
6082 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
6084 if (wpa_s->create_p2p_iface) {
6092 return -1;
6095 if_addr = wpa_s->pending_interface_addr;
6097 if (wpa_s->p2p_mgmt)
6098 if_addr = wpa_s->parent->own_addr;
6100 if_addr = wpa_s->own_addr;
6101 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
6109 return -1;
6116 if (wpa_s->create_p2p_iface)
6118 return -1;
6125 * wpas_p2p_remain_on_channel_cb - Indication of remain-on-channel start
6131 * requested remain-on-channel duration.
6136 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6138 wpa_printf(MSG_DEBUG, "P2P: remain-on-channel callback (off_channel_freq=%u pending_listen_freq=%d roc_waiting_drv_freq=%d freq=%u duration=%u)",
6139 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
6140 wpa_s->roc_waiting_drv_freq, freq, duration);
6141 if (wpa_s->off_channel_freq &&
6142 wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
6143 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
6144 wpa_s->pending_listen_duration);
6145 wpa_s->pending_listen_freq = 0;
6147 wpa_printf(MSG_DEBUG, "P2P: Ignore remain-on-channel callback (off_channel_freq=%u pending_listen_freq=%d freq=%u duration=%u)",
6148 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
6157 if (timeout > wpa_s->max_remain_on_chan)
6158 timeout = wpa_s->max_remain_on_chan;
6160 return p2p_listen(wpa_s->global->p2p, timeout);
6165 * wpas_p2p_cancel_remain_on_channel_cb - Remain-on-channel timeout
6169 * This callback is called when the driver indicates that a remain-on-channel
6176 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel callback "
6178 wpa_s->global->p2p_long_listen,
6181 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6183 if (wpa_s->global->p2p_long_listen > 0)
6184 wpa_s->global->p2p_long_listen -= wpa_s->max_remain_on_chan;
6185 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
6189 if (wpa_s->global->p2p_long_listen > 0) {
6191 wpas_p2p_listen_start(wpa_s, wpa_s->global->p2p_long_listen);
6197 p2p_stop_listen(wpa_s->global->p2p);
6203 * wpas_p2p_group_remove - Remove a P2P group
6207 * Returns: 0 on success, -1 on failure
6217 struct wpa_global *global = wpa_s->global;
6224 wpa_s = global->ifaces;
6227 wpa_s = wpa_s->next;
6228 if (prev->p2p_group_interface !=
6230 (prev->current_ssid &&
6231 prev->current_ssid->p2p_group)) {
6239 (calling_wpa_s->p2p_group_interface !=
6241 (calling_wpa_s->current_ssid &&
6242 calling_wpa_s->current_ssid->p2p_group))) {
6251 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6252 if (os_strcmp(wpa_s->ifname, ifname) == 0)
6264 if (!wpa_s->conf->num_p2p_pref_chan && !freq) {
6271 if (!res && size > 0 && !is_p2p_allow_6ghz(wpa_s->global->p2p))
6277 (!p2p_supported_freq(wpa_s->global->p2p,
6280 wpa_s->global,
6307 if (wpa_s->best_24_freq > 0 &&
6308 p2p_supported_freq_go(wpa_s->global->p2p,
6309 wpa_s->best_24_freq)) {
6310 freq = wpa_s->best_24_freq;
6315 return -1;
6325 if (wpa_s->best_5_freq > 0 &&
6326 p2p_supported_freq_go(wpa_s->global->p2p,
6327 wpa_s->best_5_freq)) {
6328 freq = wpa_s->best_5_freq;
6341 return -1;
6352 if (p2p_supported_freq_go(wpa_s->global->p2p,
6360 return -1;
6367 if (freq > 0 && !p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
6368 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
6369 ieee80211_is_dfs(freq, wpa_s->hw.modes,
6370 wpa_s->hw.num_modes)) {
6383 return -1;
6394 if (!wpas_p2p_disallowed_freq(wpa_s->global, freq) &&
6395 p2p_supported_freq_go(wpa_s->global->p2p, freq) &&
6410 params->freq = 5180 + i * 20;
6411 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
6417 params->freq = 5745 + i * 20;
6418 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
6423 params->freq = 58320 + 1 * 2160;
6424 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
6429 params->freq = 58320 + i * 2160;
6430 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
6439 params->freq = 2412 + ((r + i) % 3) * 25;
6440 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
6446 params->freq = 2412 + i * 5;
6449 if (params->freq == 2412 ||
6450 params->freq == 2437 ||
6451 params->freq == 2462)
6454 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
6458 params->freq = 0;
6463 params->freq);
6494 params->role_go = 1;
6495 params->ht40 = ht40;
6496 params->vht = vht;
6497 params->he = he;
6498 params->max_oper_chwidth = max_oper_chwidth;
6499 params->vht_center_freq2 = vht_center_freq2;
6500 params->edmg = edmg;
6502 freqs = os_calloc(wpa_s->num_multichan_concurrent,
6505 return -1;
6508 wpa_s->num_multichan_concurrent,
6511 if (wpa_s->current_ssid &&
6512 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO &&
6513 wpa_s->wpa_state == WPA_COMPLETED) {
6521 * move the P2P GO so its frequency can be re-used.
6524 if (freqs[i].freq == wpa_s->current_ssid->frequency &&
6533 if (params->edmg) {
6536 params->edmg = 0;
6541 if (wpas_p2p_disallowed_freq(wpa_s->global, freq) ||
6548 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
6549 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
6550 ieee80211_is_dfs(freq, wpa_s->hw.modes,
6551 wpa_s->hw.num_modes)) {
6572 params->freq = freq;
6587 params->freq = freq;
6593 (!wpa_s->conf->p2p_ignore_shared_freq || !unused_channels)) {
6599 params->freq = cand;
6610 params->freq = freqs[i].freq;
6623 if (wpa_s->conf->p2p_oper_reg_class == 81 &&
6624 wpa_s->conf->p2p_oper_channel >= 1 &&
6625 wpa_s->conf->p2p_oper_channel <= 11 &&
6628 2407 + 5 * wpa_s->conf->p2p_oper_channel)) {
6629 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
6631 "frequency %d MHz", params->freq);
6635 if ((wpa_s->conf->p2p_oper_reg_class == 115 ||
6636 wpa_s->conf->p2p_oper_reg_class == 116 ||
6637 wpa_s->conf->p2p_oper_reg_class == 117 ||
6638 wpa_s->conf->p2p_oper_reg_class == 124 ||
6639 wpa_s->conf->p2p_oper_reg_class == 125 ||
6640 wpa_s->conf->p2p_oper_reg_class == 126 ||
6641 wpa_s->conf->p2p_oper_reg_class == 127) &&
6644 5 * wpa_s->conf->p2p_oper_channel)) {
6645 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
6647 "frequency %d MHz", params->freq);
6652 if (wpa_s->conf->p2p_oper_channel == 0 &&
6653 wpa_s->best_overall_freq > 0 &&
6655 wpa_s->best_overall_freq)) {
6656 params->freq = wpa_s->best_overall_freq;
6658 "channel %d MHz", params->freq);
6662 if (wpa_s->conf->p2p_oper_channel == 0 &&
6663 wpa_s->best_24_freq > 0 &&
6665 wpa_s->best_24_freq)) {
6666 params->freq = wpa_s->best_24_freq;
6668 "channel %d MHz", params->freq);
6672 if (wpa_s->conf->p2p_oper_channel == 0 &&
6673 wpa_s->best_5_freq > 0 &&
6675 wpa_s->best_5_freq)) {
6676 params->freq = wpa_s->best_5_freq;
6678 "channel %d MHz", params->freq);
6683 cand = p2p_get_pref_freq(wpa_s->global->p2p, channels);
6685 params->freq = cand;
6687 "channels", params->freq);
6692 if (wpa_s->hw.modes && wpa_s->p2p_group_common_freqs) {
6693 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6699 cand = wpa_s->p2p_group_common_freqs[i];
6702 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
6709 params->freq = cand;
6712 params->freq);
6720 if (wpa_s->current_ssid && wpa_s->hw.modes &&
6721 wpa_s->p2p_group_common_freqs) {
6722 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6729 cand = wpa_s->p2p_group_common_freqs[i];
6731 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
6733 if (!wpas_same_band(wpa_s->current_ssid->frequency,
6744 cand, -1, CONF_OPER_CHWIDTH_USE_HT,
6764 params->freq = cand;
6767 params->freq);
6775 if (wpa_s->current_ssid && wpa_s->p2p_group_common_freqs) {
6776 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6777 cand = wpa_s->p2p_group_common_freqs[i];
6778 if (!wpas_same_band(wpa_s->current_ssid->frequency,
6782 params->freq = cand;
6785 params->freq);
6792 if (wpa_s->p2p_group_common_freqs) {
6793 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
6794 cand = wpa_s->p2p_group_common_freqs[i];
6796 params->freq = cand;
6799 params->freq);
6808 if (params->freq == 0) {
6818 return -1;
6829 if (wpa_s->p2p_mgmt) {
6835 wpa_s->parent->p2pdev = wpa_s;
6836 wpa_s = wpa_s->parent;
6840 wpa_s->p2p_first_connection_timeout = 0;
6841 if (wpa_s != wpa_s->p2pdev)
6842 wpas_p2p_clone_config(wpa_s, wpa_s->p2pdev);
6860 if (go && wpa_s->p2p_go_do_acs) {
6861 group_wpa_s->p2p_go_do_acs = wpa_s->p2p_go_do_acs;
6862 group_wpa_s->p2p_go_acs_band = wpa_s->p2p_go_acs_band;
6863 wpa_s->p2p_go_do_acs = 0;
6866 if (go && wpa_s->p2p_go_allow_dfs) {
6867 group_wpa_s->p2p_go_allow_dfs = wpa_s->p2p_go_allow_dfs;
6868 wpa_s->p2p_go_allow_dfs = 0;
6872 group_wpa_s->ifname);
6873 group_wpa_s->p2p_first_connection_timeout = 0;
6879 * wpas_p2p_group_add - Add a new P2P group with local end as Group Owner
6889 * Returns: 0 on success, -1 on failure
6902 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6903 return -1;
6905 return -1;
6907 os_free(wpa_s->global->add_psk);
6908 wpa_s->global->add_psk = NULL;
6911 wpa_printf(MSG_DEBUG, "P2P: Stop any on-going P2P FIND");
6914 if (!wpa_s->p2p_go_do_acs) {
6917 return -1;
6924 return -1;
6926 p2p_go_params(wpa_s->global->p2p, ¶ms);
6931 return -1;
6933 wpa_s->p2p_go_no_pri_sec_switch = 1;
6951 return -1;
6953 os_get_reltime(&wpa_s->scan_min_time);
6954 wpa_s->p2p_last_4way_hs_fail = NULL;
6958 ssid = wpa_config_add_network(wpa_s->conf);
6960 return -1;
6961 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
6963 ssid->temporary = 1;
6964 ssid->proto = WPA_PROTO_RSN;
6965 ssid->pbss = params->pbss;
6966 ssid->pairwise_cipher = params->pbss ? WPA_CIPHER_GCMP :
6968 ssid->group_cipher = params->pbss ? WPA_CIPHER_GCMP : WPA_CIPHER_CCMP;
6969 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
6971 is_p2p_6ghz_capable(wpa_s->global->p2p)) {
6972 ssid->auth_alg |= WPA_AUTH_ALG_SAE;
6973 ssid->key_mgmt |= WPA_KEY_MGMT_SAE;
6974 ssid->ieee80211w = MGMT_FRAME_PROTECTION_OPTIONAL;
6975 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
6980 ssid->ssid = os_malloc(params->ssid_len);
6981 if (ssid->ssid == NULL) {
6982 wpa_config_remove_network(wpa_s->conf, ssid->id);
6983 return -1;
6985 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
6986 ssid->ssid_len = params->ssid_len;
6987 ssid->p2p_group = 1;
6988 ssid->export_keys = 1;
6989 if (params->psk_set) {
6990 os_memcpy(ssid->psk, params->psk, 32);
6991 ssid->psk_set = 1;
6993 if (params->passphrase)
6994 ssid->passphrase = os_strdup(params->passphrase);
6997 ssid->bssid_set = 1;
6998 os_memcpy(ssid->bssid, go_bssid, ETH_ALEN);
7001 wpa_s->show_group_started = 1;
7002 wpa_s->p2p_in_invitation = 1;
7003 wpa_s->p2p_retry_limit = retry_limit;
7004 wpa_s->p2p_invite_go_freq = freq;
7005 wpa_s->p2p_go_group_formation_completed = 0;
7006 wpa_s->global->p2p_group_formation = wpa_s;
7016 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
7020 if (!other_iface_found || os_reltime_before(&wpa_s->last_scan,
7021 &ifs->last_scan)) {
7023 wpa_s->last_scan.sec = ifs->last_scan.sec;
7024 wpa_s->last_scan.usec = ifs->last_scan.usec;
7028 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->p2pdev,
7032 wpa_s->p2pdev, NULL);
7053 if (ssid->disabled != 2 || ssid->ssid == NULL)
7054 return -1;
7056 if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) &&
7057 go == (ssid->mode == WPAS_MODE_P2P_GO)) {
7062 wpa_s->p2pdev, NULL)) {
7075 wpa_s->p2pdev, NULL);
7080 os_free(wpa_s->global->add_psk);
7081 wpa_s->global->add_psk = NULL;
7086 wpa_s->p2p_fallback_to_go_neg = 0;
7088 if (ssid->mode == WPAS_MODE_P2P_GO) {
7092 return -1;
7093 wpa_s->p2p_go_no_pri_sec_switch = 1;
7100 } else if (ssid->mode == WPAS_MODE_INFRA) {
7105 wpa_bss_get_p2p_dev_addr(wpa_s, ssid->bssid);
7109 !os_reltime_expired(&now, &bss->last_update, 5) &&
7110 freq_included(wpa_s, channels, bss->freq))
7111 freq = bss->freq;
7119 return -1;
7125 return -1;
7128 params.psk_set = ssid->psk_set;
7130 os_memcpy(params.psk, ssid->psk, sizeof(params.psk));
7131 if (ssid->passphrase) {
7132 if (os_strlen(ssid->passphrase) >= sizeof(params.passphrase)) {
7135 return -1;
7137 os_strlcpy(params.passphrase, ssid->passphrase,
7140 os_memcpy(params.ssid, ssid->ssid, ssid->ssid_len);
7141 params.ssid_len = ssid->ssid_len;
7146 return -1;
7150 wpa_s->p2p_first_connection_timeout = connection_timeout;
7161 if (wpa_s->ap_iface) {
7162 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
7163 if (!(hapd->conf->p2p & P2P_GROUP_OWNER)) {
7169 wpabuf_free(hapd->p2p_beacon_ie);
7170 hapd->p2p_beacon_ie = beacon_ies;
7172 wpabuf_free(hapd->p2p_probe_resp_ie);
7173 hapd->p2p_probe_resp_ie = proberesp_ies;
7185 if (!wpa_s->ap_iface)
7187 wpa_printf(MSG_DEBUG, "P2P: GO - group %sidle", idle ? "" : "not ");
7189 if (wpa_s->global->p2p_fail_on_wps_complete &&
7190 wpa_s->p2p_in_provisioning) {
7206 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
7207 !ssid->p2p_group)
7214 if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect)
7215 cfg->persistent_group = 2;
7216 else if (ssid->p2p_persistent_group)
7217 cfg->persistent_group = 1;
7218 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
7219 if (wpa_s->max_stations &&
7220 wpa_s->max_stations < wpa_s->conf->max_num_sta)
7221 cfg->max_clients = wpa_s->max_stations;
7223 cfg->max_clients = wpa_s->conf->max_num_sta;
7224 os_memcpy(cfg->ssid, ssid->ssid, ssid->ssid_len);
7225 cfg->ssid_len = ssid->ssid_len;
7226 cfg->freq = ssid->frequency;
7227 cfg->cb_ctx = wpa_s;
7228 cfg->ie_update = wpas_p2p_ie_update;
7229 cfg->idle_update = wpas_p2p_idle_update;
7230 cfg->ip_addr_alloc = WPA_GET_BE32(wpa_s->p2pdev->conf->ip_addr_start)
7233 group = p2p_group_init(wpa_s->global->p2p, cfg);
7236 if (ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
7238 wpa_s->p2p_group = group;
7246 struct wpa_ssid *ssid = wpa_s->current_ssid;
7248 if (!wpa_s->p2p_in_provisioning) {
7249 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS success event - P2P "
7254 if (ssid && ssid->mode == WPAS_MODE_INFRA) {
7256 os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN);
7257 wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
7258 ssid->ssid_len);
7260 p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr);
7263 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->p2pdev,
7265 wpa_s->p2p_go_group_formation_completed = 1;
7266 if (ssid && ssid->mode == WPAS_MODE_INFRA) {
7274 "P2P: Re-start group formation timeout (%d seconds) as client for initial connection",
7278 wpa_s->p2pdev, NULL);
7280 wpa_s->p2p_go_group_formation_completed = 0;
7288 "P2P: Re-start group formation timeout (%d seconds) as GO for initial connection",
7292 wpa_s->p2pdev, NULL);
7296 wpa_s->p2p_go_group_formation_completed = 0;
7298 if (wpa_s->global->p2p)
7299 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
7307 if (!wpa_s->p2p_in_provisioning) {
7308 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS fail event - P2P "
7313 if (wpa_s->go_params) {
7315 wpa_s->global->p2p,
7316 wpa_s->go_params->peer_device_addr);
7321 if (wpa_s == wpa_s->global->p2p_group_formation) {
7327 wpa_printf(MSG_DEBUG, "P2P: WPS step failed during group formation - reject connection from timeout");
7328 wpa_s->global->p2p_fail_on_wps_complete = 1;
7331 wpa_s->p2pdev, NULL);
7338 if (!wpa_s->global->p2p_fail_on_wps_complete ||
7339 !wpa_s->p2p_in_provisioning)
7355 wpa_s->global->pending_p2ps_group = 0;
7356 wpa_s->global->pending_p2ps_group_freq = 0;
7357 wpa_s->p2p_fallback_to_go_neg = 0;
7358 wpa_s->pending_pd_use = NORMAL_PD;
7360 p2ps_prov->conncap = p2ps_group_capability(
7361 wpa_s, P2PS_SETUP_NONE, p2ps_prov->role,
7362 &p2ps_prov->force_freq, &p2ps_prov->pref_freq);
7365 "P2P: %s conncap: %d - ASP parsed: %x %x %d %s",
7366 __func__, p2ps_prov->conncap,
7367 p2ps_prov->adv_id, p2ps_prov->conncap,
7368 p2ps_prov->status, p2ps_prov->info);
7381 return -1;
7385 os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN);
7386 wpa_s->pending_pd_config_methods = config_methods;
7387 wpa_s->p2p_auto_pd = 1;
7388 wpa_s->p2p_auto_join = 0;
7389 wpa_s->pending_pd_before_join = 0;
7390 wpa_s->auto_pd_scan_retry = 0;
7392 wpa_s->p2p_join_scan_count = 0;
7393 os_get_reltime(&wpa_s->p2p_auto_started);
7395 wpa_s->p2p_auto_started.sec,
7396 wpa_s->p2p_auto_started.usec);
7401 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) {
7403 return -1;
7406 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr, p2ps_prov,
7425 if (wpa_s->p2p_send_action_work) {
7448 wpa_s->global->p2p_long_listen = 0;
7450 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
7451 wpa_s->p2p_in_provisioning) {
7453 (wpa_s->global->p2p_disabled || !wpa_s->global->p2p) ?
7455 wpa_s->p2p_in_provisioning ?
7457 return -1;
7462 return p2p_find(wpa_s->global->p2p, timeout, type,
7474 if (wpa_s->p2p_scan_work) {
7475 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
7476 wpa_s->p2p_scan_work = NULL;
7480 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7494 wpa_s->global->p2p_long_listen = 0;
7498 if (wpa_s->global->p2p)
7499 p2p_stop_find(wpa_s->global->p2p);
7501 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_handler) {
7504 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore_search;
7512 if (!wpa_s->global->pending_group_iface_for_p2ps)
7520 wpa_s->global->p2p_long_listen = 0;
7528 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7529 return -1;
7531 if (wpa_s->p2p_lo_started) {
7534 return -1;
7549 wpa_s->global->p2p_long_listen = 0;
7553 * remain-on-channel operation while the driver is still running the
7556 if (wpa_s->global->p2p)
7557 p2p_stop_find(wpa_s->global->p2p);
7560 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
7561 wpa_s->global->p2p_long_listen = timeout * 1000;
7577 if (wpa_s->global->p2p_disabled)
7578 return -1;
7583 if (wpa_s->conf->p2p_disabled && p2p_group)
7584 return -1;
7585 if (wpa_s->global->p2p == NULL)
7586 return -1;
7588 return -1;
7591 ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len,
7604 if (wpa_s->global->p2p_disabled)
7606 if (wpa_s->global->p2p == NULL)
7609 switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid,
7610 ie, ie_len, rx_freq, wpa_s->p2p_lo_started)) {
7630 if (wpa_s->global->p2p_disabled)
7632 if (wpa_s->global->p2p == NULL)
7635 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
7644 if (wpa_s->global->p2p_disabled)
7646 if (wpa_s->global->p2p == NULL)
7650 p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands);
7656 p2p_group_deinit(wpa_s->p2p_group);
7657 wpa_s->p2p_group = NULL;
7659 wpa_s->ap_configured_cb = NULL;
7660 wpa_s->ap_configured_cb_ctx = NULL;
7661 wpa_s->ap_configured_cb_data = NULL;
7662 wpa_s->connect_without_scan = NULL;
7668 wpa_s->global->p2p_long_listen = 0;
7670 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7671 return -1;
7673 return p2p_reject(wpa_s->global->p2p, addr);
7692 return -1;
7694 wpa_s->global->p2p_invite_group = NULL;
7696 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
7698 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
7700 wpa_s->p2p_persistent_go_freq = freq;
7701 wpa_s->p2p_go_ht40 = !!ht40;
7702 wpa_s->p2p_go_vht = !!vht;
7703 wpa_s->p2p_go_he = !!he;
7704 wpa_s->p2p_go_max_oper_chwidth = max_chwidth;
7705 wpa_s->p2p_go_vht_center_freq2 = vht_center_freq2;
7706 wpa_s->p2p_go_edmg = !!edmg;
7707 if (ssid->mode == WPAS_MODE_P2P_GO) {
7712 return -1;
7720 return -1;
7722 bssid = wpa_s->pending_interface_addr;
7723 } else if (wpa_s->p2p_mgmt)
7724 bssid = wpa_s->parent->own_addr;
7726 bssid = wpa_s->own_addr;
7729 peer_addr = ssid->bssid;
7731 wpa_s->pending_invite_ssid_id = ssid->id;
7740 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7741 return -1;
7743 p2p_set_own_pref_freq_list(wpa_s->global->p2p, pref_freq_list, size);
7745 if (wpa_s->parent->conf->p2p_ignore_shared_freq &&
7747 wpa_s->num_multichan_concurrent > 1 &&
7760 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
7761 ssid->ssid, ssid->ssid_len, force_freq, go_dev_addr,
7762 1, pref_freq, -1);
7771 struct wpa_global *global = wpa_s->global;
7781 wpa_s->p2p_persistent_go_freq = 0;
7782 wpa_s->p2p_go_ht40 = 0;
7783 wpa_s->p2p_go_vht = 0;
7784 wpa_s->p2p_go_vht_center_freq2 = 0;
7785 wpa_s->p2p_go_max_oper_chwidth = 0;
7786 wpa_s->p2p_go_edmg = 0;
7788 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7789 if (os_strcmp(wpa_s->ifname, ifname) == 0)
7794 return -1;
7797 ssid = wpa_s->current_ssid;
7801 return -1;
7804 wpa_s->global->p2p_invite_group = wpa_s;
7805 persistent = ssid->p2p_persistent_group &&
7806 wpas_p2p_get_persistent(wpa_s->p2pdev, peer_addr,
7807 ssid->ssid, ssid->ssid_len);
7809 if (ssid->mode == WPAS_MODE_P2P_GO) {
7811 bssid = wpa_s->own_addr;
7813 go_dev_addr = wpa_s->global->p2p_dev_addr;
7814 freq = ssid->frequency;
7817 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
7818 wpa_printf(MSG_DEBUG, "P2P: Not associated - cannot "
7820 return -1;
7822 bssid = wpa_s->bssid;
7824 !is_zero_ether_addr(wpa_s->go_dev_addr))
7825 go_dev_addr = wpa_s->go_dev_addr;
7826 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
7827 (int) wpa_s->assoc_freq;
7829 wpa_s->p2pdev->pending_invite_ssid_id = -1;
7831 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7832 return -1;
7834 return -1;
7844 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
7845 ssid->ssid, ssid->ssid_len, force_freq,
7846 go_dev_addr, persistent, pref_freq, -1);
7852 struct wpa_ssid *ssid = wpa_s->current_ssid;
7859 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION) {
7861 wpa_s->p2pdev, NULL);
7864 if (!wpa_s->show_group_started || !ssid)
7867 wpa_s->show_group_started = 0;
7868 if (!wpa_s->p2p_go_group_formation_completed &&
7869 wpa_s->global->p2p_group_formation == wpa_s) {
7872 wpa_s->p2p_go_group_formation_completed = 1;
7873 wpa_s->global->p2p_group_formation = NULL;
7874 wpa_s->p2p_in_provisioning = 0;
7875 wpa_s->p2p_in_invitation = 0;
7876 wpa_s->p2p_retry_limit = 0;
7880 if (ssid->bssid_set)
7881 os_memcpy(go_dev_addr, ssid->bssid, ETH_ALEN);
7882 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
7883 ssid->ssid_len);
7884 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
7886 if (wpa_s->global->p2p_group_formation == wpa_s)
7887 wpa_s->global->p2p_group_formation = NULL;
7889 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
7890 (int) wpa_s->assoc_freq;
7893 if (wpa_sm_get_p2p_ip_addr(wpa_s->wpa, ip) == 0) {
7908 ssid->passphrase == NULL && ssid->psk_set ?
7909 ssid->psk : NULL,
7910 ssid->passphrase, go_dev_addr, persistent,
7914 wpas_p2p_store_persistent_group(wpa_s->p2pdev,
7926 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7927 return -1;
7929 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
7930 wpa_s->current_ssid == NULL ||
7931 wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
7932 return -1;
7934 ret = p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
7935 wpa_s->own_addr, wpa_s->assoc_freq,
7938 wpa_s->waiting_presence_resp = 1;
7947 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7948 return -1;
7950 return p2p_ext_listen(wpa_s->global->p2p, period, interval);
7956 if (wpa_s->current_ssid == NULL) {
7964 return wpa_s->current_ssid->p2p_group &&
7965 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
7973 if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) {
7974 wpa_printf(MSG_DEBUG, "P2P: Ignore group idle timeout - "
7979 wpa_printf(MSG_DEBUG, "P2P: Group idle timeout reached - terminate "
7992 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
7995 timeout = wpa_s->conf->p2p_group_idle;
7996 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
8004 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA)
8005 timeout = 0; /* special client mode no-timeout */
8010 if (wpa_s->p2p_in_provisioning) {
8021 if (wpa_s->show_group_started) {
8024 * the provisioning phase and completion of 4-way handshake to
8029 "while waiting for initial 4-way handshake to "
8046 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8050 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
8054 wpa_s->current_ssid &&
8055 wpa_s->current_ssid->p2p_group &&
8056 wpa_s->current_ssid->mode == WPAS_MODE_INFRA) {
8073 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8077 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
8084 struct p2p_data *p2p = wpa_s->global->p2p;
8089 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
8092 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
8093 p2p_set_dev_name(p2p, wpa_s->conf->device_name);
8095 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
8096 p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type);
8098 if (wpa_s->wps &&
8099 (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS))
8100 p2p_set_config_methods(p2p, wpa_s->wps->config_methods);
8102 if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID))
8103 p2p_set_uuid(p2p, wpa_s->wps->uuid);
8105 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) {
8106 p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer);
8107 p2p_set_model_name(p2p, wpa_s->conf->model_name);
8108 p2p_set_model_number(p2p, wpa_s->conf->model_number);
8109 p2p_set_serial_number(p2p, wpa_s->conf->serial_number);
8112 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE)
8114 (void *) wpa_s->conf->sec_device_type,
8115 wpa_s->conf->num_sec_device_types);
8117 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) {
8121 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
8124 p2p, wpa_s->conf->wps_vendor_ext[i]);
8128 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
8129 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
8131 country[0] = wpa_s->conf->country[0];
8132 country[1] = wpa_s->conf->country[1];
8137 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
8138 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
8139 wpa_s->conf->p2p_ssid_postfix ?
8140 os_strlen(wpa_s->conf->p2p_ssid_postfix) :
8144 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS)
8145 p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss);
8147 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) {
8153 if (wpa_s->conf->p2p_listen_reg_class &&
8154 wpa_s->conf->p2p_listen_channel) {
8155 reg_class = wpa_s->conf->p2p_listen_reg_class;
8156 channel = wpa_s->conf->p2p_listen_channel;
8176 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) {
8180 if (wpa_s->conf->p2p_oper_reg_class &&
8181 wpa_s->conf->p2p_oper_channel) {
8182 op_reg_class = wpa_s->conf->p2p_oper_reg_class;
8183 op_channel = wpa_s->conf->p2p_oper_channel;
8204 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
8205 if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
8206 wpa_s->conf->p2p_pref_chan) < 0) {
8211 if (p2p_set_no_go_freq(p2p, &wpa_s->conf->p2p_no_go_freq) < 0) {
8217 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PASSPHRASE_LEN)
8218 p2p_set_passphrase_len(p2p, wpa_s->conf->p2p_passphrase_len);
8225 if (!wpa_s->ap_iface)
8226 return -1;
8227 return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start,
8234 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8235 return -1;
8237 wpa_s->global->cross_connection = enabled;
8238 p2p_set_cross_connect(wpa_s->global->p2p, enabled);
8243 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
8245 if (iface->cross_connect_enabled == 0)
8248 iface->cross_connect_enabled = 0;
8249 iface->cross_connect_in_use = 0;
8250 wpa_msg_global(iface->p2pdev, MSG_INFO,
8252 iface->ifname,
8253 iface->cross_connect_uplink);
8265 if (!uplink->global->cross_connection)
8268 for (iface = uplink->global->ifaces; iface; iface = iface->next) {
8269 if (!iface->cross_connect_enabled)
8271 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
8274 if (iface->ap_iface == NULL)
8276 if (iface->cross_connect_in_use)
8279 iface->cross_connect_in_use = 1;
8280 wpa_msg_global(iface->p2pdev, MSG_INFO,
8282 iface->ifname, iface->cross_connect_uplink);
8291 for (iface = uplink->global->ifaces; iface; iface = iface->next) {
8292 if (!iface->cross_connect_enabled)
8294 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
8297 if (!iface->cross_connect_in_use)
8300 wpa_msg_global(iface->p2pdev, MSG_INFO,
8302 iface->ifname, iface->cross_connect_uplink);
8303 iface->cross_connect_in_use = 0;
8310 if (wpa_s->ap_iface || wpa_s->current_ssid == NULL ||
8311 wpa_s->current_ssid->mode != WPAS_MODE_INFRA ||
8312 wpa_s->cross_connect_disallowed)
8316 if (!wpa_s->ap_iface &&
8325 if (!wpa_s->ap_iface &&
8336 if (!wpa_s->global->cross_connection)
8339 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
8342 if (iface->drv_flags &
8345 if ((iface->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE) &&
8346 iface != wpa_s->parent)
8349 wpa_s->cross_connect_enabled = 1;
8350 os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname,
8351 sizeof(wpa_s->cross_connect_uplink));
8354 wpa_s->ifname, wpa_s->cross_connect_uplink);
8356 if (iface->ap_iface || iface->current_ssid == NULL ||
8357 iface->current_ssid->mode != WPAS_MODE_INFRA ||
8358 iface->cross_connect_disallowed ||
8359 iface->wpa_state != WPA_COMPLETED)
8362 wpa_s->cross_connect_in_use = 1;
8363 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
8365 wpa_s->ifname, wpa_s->cross_connect_uplink);
8373 if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT &&
8374 !wpa_s->p2p_in_provisioning)
8379 if (wpa_s != wpa_s->p2pdev)
8380 wpa_msg_ctrl(wpa_s->p2pdev, MSG_INFO, WPS_EVENT_OVERLAP);
8394 enum wpas_p2p_channel_update_trig trig)
8398 unsigned int num = wpa_s->num_multichan_concurrent;
8400 if (wpa_s->global == NULL || wpa_s->global->p2p == NULL)
8412 is_p2p_6ghz_disabled(wpa_s->global->p2p))) {
8418 p2p_update_channel_list(wpa_s->global->p2p, &chan, &cli_chan);
8428 wpas_p2p_consider_moving_gos(wpa_s, freqs, num, trig);
8443 struct wpa_global *global = wpa_s->global;
8447 if (global->p2p == NULL)
8448 return -1;
8452 if (wpa_s->pending_interface_name[0] &&
8453 !is_zero_ether_addr(wpa_s->pending_interface_addr))
8456 peer = p2p_get_go_neg_peer(global->p2p);
8460 p2p_unauthorize(global->p2p, peer);
8464 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_join) {
8466 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore;
8470 if (wpa_s->pending_pd_before_join) {
8472 wpa_s->pending_pd_before_join = 0;
8478 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
8479 if (wpa_s == global->p2p_group_formation &&
8480 (wpa_s->p2p_in_provisioning ||
8481 wpa_s->parent->pending_interface_type ==
8484 "formation found - cancelling",
8485 wpa_s->ifname);
8488 wpa_s->p2pdev, NULL);
8489 if (wpa_s->p2p_in_provisioning) {
8496 } else if (wpa_s->p2p_in_invitation) {
8497 wpa_printf(MSG_DEBUG, "P2P: Interface %s in invitation found - cancelling",
8498 wpa_s->ifname);
8507 return -1;
8516 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
8528 struct p2p_data *p2p = wpa_s->global->p2p;
8538 struct p2p_data *p2p = wpa_s->global->p2p;
8541 return -1;
8544 return -1;
8551 * wpas_p2p_disconnect - Disconnect from a P2P Group
8553 * Returns: 0 on success, -1 on failure
8565 return -1;
8568 -1 : 0;
8576 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8579 ret = p2p_in_progress(wpa_s->global->p2p);
8587 if (wpa_s->global->p2p_group_formation &&
8588 wpa_s->global->p2p_group_formation != wpa_s) {
8591 wpa_s->global->p2p_group_formation->ifname);
8593 } else if (wpa_s->global->p2p_group_formation == wpa_s) {
8600 if (!ret && wpa_s->global->p2p_go_wait_client.sec) {
8603 if (os_reltime_expired(&now, &wpa_s->global->p2p_go_wait_client,
8606 wpa_s->global->p2p_go_wait_client.sec = 0;
8620 if (wpa_s->p2p_in_provisioning && ssid->p2p_group &&
8622 wpa_s->p2pdev, NULL) > 0) {
8634 wpa_s->p2pdev, NULL);
8646 for (s = wpa_s->conf->ssid; s; s = s->next) {
8647 if (s->disabled != 2)
8650 (ssid_len != s->ssid_len ||
8651 os_memcmp(ssid, s->ssid, ssid_len) != 0))
8654 if (s->mode == WPAS_MODE_P2P_GO)
8658 if (ether_addr_equal(s->bssid, addr))
8660 if (s->mode != WPAS_MODE_P2P_GO || s->p2p_client_list == NULL)
8662 for (i = 0; i < s->num_p2p_clients; i++) {
8663 if (ether_addr_equal(s->p2p_client_list +
8678 wpa_s->p2pdev, NULL) > 0) {
8690 if (!wpa_s->p2p_go_group_formation_completed &&
8691 !wpa_s->group_formation_reported) {
8699 if (wpa_s->global->p2p)
8700 p2p_wps_success_cb(wpa_s->global->p2p, addr);
8704 if (!wpa_s->p2p_go_group_formation_completed) {
8706 wpa_s->p2p_go_group_formation_completed = 1;
8707 wpa_s->global->p2p_group_formation = NULL;
8708 wpa_s->p2p_in_provisioning = 0;
8709 wpa_s->p2p_in_invitation = 0;
8710 wpa_s->p2p_retry_limit = 0;
8712 wpa_s->global->p2p_go_wait_client.sec = 0;
8725 if (wpa_s->global->p2p_group_formation)
8726 group = wpa_s->global->p2p_group_formation;
8727 wpa_s = wpa_s->global->p2p_init_wpa_s;
8732 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin,
8733 wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0,
8734 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
8735 wpa_s->p2p_go_vht_center_freq2,
8736 wpa_s->p2p_persistent_id,
8737 wpa_s->p2p_pd_before_go_neg,
8738 wpa_s->p2p_go_ht40,
8739 wpa_s->p2p_go_vht,
8740 wpa_s->p2p_go_max_oper_chwidth,
8741 wpa_s->p2p_go_he,
8742 wpa_s->p2p_go_edmg,
8743 NULL, 0, is_p2p_allow_6ghz(wpa_s->global->p2p));
8752 if (!wpa_s->p2p_fallback_to_go_neg ||
8753 wpa_s->p2p_in_provisioning <= 5)
8756 if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0)
8759 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - "
8761 wpa_msg_global(wpa_s->p2pdev, MSG_INFO, P2P_EVENT_FALLBACK_TO_GO_NEG
8762 "reason=GO-not-found");
8773 if (wpa_s->wpa_state > WPA_SCANNING) {
8776 wpa_s->conf->p2p_search_delay);
8777 return wpa_s->conf->p2p_search_delay;
8780 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
8782 if (ifs != wpa_s && ifs->wpa_state > WPA_SCANNING) {
8786 wpa_s->conf->p2p_search_delay,
8787 ifs->ifname);
8788 return wpa_s->conf->p2p_search_delay;
8803 dl_list_for_each_safe(psk, tmp, &s->psk_list, struct psk_list_entry,
8805 if ((iface_addr && !psk->p2p &&
8806 ether_addr_equal(addr, psk->addr)) ||
8807 (!iface_addr && psk->p2p &&
8808 ether_addr_equal(addr, psk->addr))) {
8812 MAC2STR(psk->addr), psk->p2p);
8813 dl_list_del(&psk->list);
8827 struct wpa_ssid *ssid = wpa_s->current_ssid;
8831 if (psk_len != sizeof(p->psk))
8845 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
8848 if (wpa_s->global->add_psk == NULL) {
8849 wpa_s->global->add_psk = os_zalloc(sizeof(*p));
8850 if (wpa_s->global->add_psk == NULL)
8853 p = wpa_s->global->add_psk;
8855 p->p2p = 1;
8856 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN);
8858 p->p2p = 0;
8859 os_memcpy(p->addr, mac_addr, ETH_ALEN);
8861 os_memcpy(p->psk, psk, psk_len);
8865 if (ssid->mode != WPAS_MODE_P2P_GO || !ssid->p2p_persistent_group) {
8866 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Ignore new_psk_cb on not-persistent GO");
8870 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, NULL, ssid->ssid,
8871 ssid->ssid_len);
8881 p->p2p = 1;
8882 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN);
8884 p->p2p = 0;
8885 os_memcpy(p->addr, mac_addr, ETH_ALEN);
8887 os_memcpy(p->psk, psk, psk_len);
8889 if (dl_list_len(&persistent->psk_list) > P2P_MAX_STORED_CLIENTS &&
8890 (last = dl_list_last(&persistent->psk_list,
8894 MAC2STR(last->addr), last->p2p);
8895 dl_list_del(&last->list);
8899 wpas_p2p_remove_psk_entry(wpa_s->p2pdev, persistent,
8909 dl_list_add(&persistent->psk_list, &p->list);
8911 if (wpa_s->p2pdev->conf->update_config &&
8912 wpa_config_write(wpa_s->p2pdev->confname, wpa_s->p2pdev->conf))
8924 if (res > 0 && wpa_s->conf->update_config &&
8925 wpa_config_write(wpa_s->confname, wpa_s->conf))
8938 if (wpa_s->ap_iface == NULL || wpa_s->current_ssid == NULL ||
8939 wpa_s->current_ssid->mode != WPAS_MODE_P2P_GO)
8942 /* Remove per-station PSK entry */
8943 hapd = wpa_s->ap_iface->bss[0];
8945 psk = hapd->conf->ssid.wpa_psk;
8947 if ((iface_addr && ether_addr_equal(peer, psk->addr)) ||
8949 ether_addr_equal(peer, psk->p2p_dev_addr))) {
8954 prev->next = psk->next;
8956 hapd->conf->ssid.wpa_psk = psk->next;
8958 psk = psk->next;
8962 psk = psk->next;
8975 hostapd_drv_sta_deauth(hapd, sta->addr,
8987 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
8992 for (s = p2p_wpa_s->conf->ssid; s; s = s->next) {
8993 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
9001 for (w = wpa_s->global->ifaces; w; w = w->next)
9017 wpa_printf(MSG_DEBUG, "P2P: Frequency conflict - terminate group");
9027 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
9028 if (!iface->current_ssid ||
9029 iface->current_ssid->frequency == freq ||
9030 (iface->p2p_group_interface == NOT_P2P_GROUP_INTERFACE &&
9031 !iface->current_ssid->p2p_group))
9045 return -1;
9051 wpa_supplicant_disable_network(wpa_s->global->ifaces,
9053 wpa_msg(wpa_s->global->ifaces, MSG_INFO,
9054 WPA_EVENT_FREQ_CONFLICT " id=%d", ssid->id);
9055 os_memset(wpa_s->global->ifaces->pending_bssid, 0,
9062 return -1;
9072 struct wpa_ssid *ssid = wpa_s->current_ssid;
9074 if (ssid == NULL || !ssid->p2p_group)
9077 if (wpa_s->p2p_last_4way_hs_fail &&
9078 wpa_s->p2p_last_4way_hs_fail == ssid) {
9083 ssid->ssid,
9084 ssid->ssid_len) <= 0) {
9085 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not determine whether 4-way handshake failures were for a persistent group");
9089 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Two 4-way handshake failures for a P2P group - go_dev_addr="
9091 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, go_dev_addr,
9092 ssid->ssid,
9093 ssid->ssid_len);
9094 if (persistent == NULL || persistent->mode != WPAS_MODE_INFRA) {
9098 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
9100 persistent->id);
9102 wpa_s->p2p_last_4way_hs_fail = NULL;
9113 wpa_s->p2p_last_4way_hs_fail = ssid;
9175 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
9176 if (iface->wpa_state < WPA_ASSOCIATING ||
9177 iface->current_ssid == NULL || iface->assoc_freq == 0 ||
9178 !iface->current_ssid->p2p_group ||
9179 iface->current_ssid->mode != WPAS_MODE_INFRA)
9182 *ssid = iface->current_ssid;
9184 os_memcpy(go_dev_addr, iface->go_dev_addr, ETH_ALEN);
9185 return iface->assoc_freq;
9199 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
9200 wpa_printf(MSG_DEBUG, "P2P: P2P disabled - cannot build handover request");
9204 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
9205 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
9206 &wpa_s->conf->wps_nfc_dh_privkey) < 0) {
9213 wpa_s->parent->wps, wpa_s->conf->wps_nfc_dh_pubkey);
9216 p2p = p2p_build_nfc_handover_req(wpa_s->global->p2p, cli_freq,
9217 go_dev_addr, ssid ? ssid->ssid : NULL,
9218 ssid ? ssid->ssid_len : 0);
9232 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9235 if (!tag && wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
9236 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
9237 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
9242 wpa_s->parent->wps,
9243 tag ? wpa_s->conf->wps_nfc_dev_pw_id :
9245 wpa_s->conf->wps_nfc_dh_pubkey,
9246 tag ? wpa_s->conf->wps_nfc_dev_pw : NULL);
9249 p2p = p2p_build_nfc_handover_sel(wpa_s->global->p2p, cli_freq,
9250 go_dev_addr, ssid ? ssid->ssid : NULL,
9251 ssid ? ssid->ssid_len : 0);
9260 wpa_printf(MSG_DEBUG, "P2P: Initiate join-group based on NFC "
9262 params->go_freq);
9264 if (params->go_freq && params->go_ssid_len) {
9265 wpa_s->p2p_wps_method = WPS_NFC;
9266 wpa_s->pending_join_wps_method = WPS_NFC;
9267 os_memset(wpa_s->pending_join_iface_addr, 0, ETH_ALEN);
9268 os_memcpy(wpa_s->pending_join_dev_addr, params->go_dev_addr,
9270 return wpas_p2p_join_start(wpa_s, params->go_freq,
9271 params->go_ssid,
9272 params->go_ssid_len);
9275 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
9276 WPS_NFC, 0, 0, 1, 0, wpa_s->conf->p2p_go_intent,
9277 params->go_freq, wpa_s->p2p_go_vht_center_freq2,
9278 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
9279 wpa_s->p2p_go_he, wpa_s->p2p_go_edmg,
9280 params->go_ssid_len ? params->go_ssid : NULL,
9281 params->go_ssid_len, false);
9291 wpa_printf(MSG_DEBUG, "P2P: Authorize join-group based on NFC "
9293 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
9294 ssid = wpa_s->current_ssid;
9297 if (ssid->mode != WPAS_MODE_P2P_GO)
9299 if (wpa_s->ap_iface == NULL)
9305 return -1;
9308 if (wpa_s->p2pdev->p2p_oob_dev_pw_id !=
9310 !wpa_s->p2pdev->p2p_oob_dev_pw) {
9312 return -1;
9315 wpa_s, wpa_s->p2pdev->p2p_oob_dev_pw_id,
9316 wpa_s->p2pdev->p2p_oob_dev_pw,
9317 wpa_s->p2pdev->p2p_peer_oob_pk_hash_known ?
9318 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash : NULL);
9323 wpa_printf(MSG_DEBUG, "P2P: Negotiated handover - wait for peer to join without invitation");
9327 if (!params->peer ||
9328 !(params->peer->dev_capab & P2P_DEV_CAPAB_INVITATION_PROCEDURE))
9331 wpa_printf(MSG_DEBUG, "P2P: Static handover - invite peer " MACSTR
9332 " to join", MAC2STR(params->peer->p2p_device_addr));
9334 wpa_s->global->p2p_invite_group = wpa_s;
9335 persistent = ssid->p2p_persistent_group &&
9336 wpas_p2p_get_persistent(wpa_s->p2pdev,
9337 params->peer->p2p_device_addr,
9338 ssid->ssid, ssid->ssid_len);
9339 wpa_s->p2pdev->pending_invite_ssid_id = -1;
9341 return p2p_invite(wpa_s->global->p2p, params->peer->p2p_device_addr,
9342 P2P_INVITE_ROLE_ACTIVE_GO, wpa_s->own_addr,
9343 ssid->ssid, ssid->ssid_len, ssid->frequency,
9344 wpa_s->global->p2p_dev_addr, persistent, 0,
9345 wpa_s->p2pdev->p2p_oob_dev_pw_id);
9355 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
9356 WPS_NFC, 0, 0, 0, 0, wpa_s->conf->p2p_go_intent,
9357 forced_freq, wpa_s->p2p_go_vht_center_freq2,
9358 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
9359 wpa_s->p2p_go_he, wpa_s->p2p_go_edmg,
9372 res = wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
9373 WPS_NFC, 0, 0, 0, 1, wpa_s->conf->p2p_go_intent,
9374 forced_freq, wpa_s->p2p_go_vht_center_freq2,
9375 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
9376 wpa_s->p2p_go_he, wpa_s->p2p_go_edmg,
9383 p2p_unauthorize(wpa_s->global->p2p,
9384 params->peer->p2p_device_addr);
9408 if (end - pos < 2) {
9411 return -1;
9415 if (len > end - pos) {
9418 return -1;
9424 if (end - pos < 2) {
9427 return -1;
9431 if (len > end - pos) {
9434 return -1;
9447 pos, end - pos);
9450 res = p2p_process_nfc_connection_handover(wpa_s->global->p2p, ¶ms);
9459 MAC2STR(params.peer->p2p_device_addr));
9468 MAC2STR(params.peer->p2p_device_addr),
9476 MAC2STR(params.peer->p2p_device_addr),
9484 MACSTR, MAC2STR(params.peer->p2p_device_addr));
9488 wpabuf_free(wpa_s->p2p_oob_dev_pw);
9489 wpa_s->p2p_oob_dev_pw = NULL;
9494 return -1;
9501 os_memcpy(wpa_s->p2p_peer_oob_pubkey_hash,
9503 wpa_s->p2p_peer_oob_pk_hash_known = 1;
9507 wpa_printf(MSG_DEBUG, "P2P: Static handover - invalid "
9509 return -1;
9511 wpa_printf(MSG_DEBUG, "P2P: Static handover - use peer OOB "
9515 params.oob_dev_pw_len -
9516 WPS_OOB_PUBKEY_HASH_LEN - 2);
9517 wpa_s->p2p_oob_dev_pw_id = id;
9518 wpa_s->p2p_oob_dev_pw = wpabuf_alloc_copy(
9520 params.oob_dev_pw_len -
9521 WPS_OOB_PUBKEY_HASH_LEN - 2);
9522 if (wpa_s->p2p_oob_dev_pw == NULL)
9523 return -1;
9525 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
9526 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
9527 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
9528 return -1;
9532 wpa_s->p2p_oob_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER;
9552 return -1;
9559 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9560 return -1;
9573 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9574 return -1;
9587 return -1;
9601 int go_intent = wpa_s->conf->p2p_go_intent;
9604 if (wpa_s->global->p2p == NULL)
9605 return -1;
9609 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
9611 if (!iface->ap_iface)
9613 hostapd_wps_nfc_token_disable(iface->ap_iface->bss[0]);
9615 p2p_set_authorized_oob_dev_pw_id(wpa_s->global->p2p, 0,
9617 if (wpa_s->p2p_nfc_tag_enabled)
9619 wpa_s->p2p_nfc_tag_enabled = 0;
9623 if (wpa_s->global->p2p_disabled)
9624 return -1;
9626 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL ||
9627 wpa_s->conf->wps_nfc_dh_privkey == NULL ||
9628 wpa_s->conf->wps_nfc_dev_pw == NULL ||
9629 wpa_s->conf->wps_nfc_dev_pw_id < 0x10) {
9632 return -1;
9637 wpa_s->p2p_oob_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
9638 wpabuf_free(wpa_s->p2p_oob_dev_pw);
9639 wpa_s->p2p_oob_dev_pw = wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
9640 if (wpa_s->p2p_oob_dev_pw == NULL)
9641 return -1;
9642 wpa_s->p2p_peer_oob_pk_hash_known = 0;
9644 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO ||
9645 wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT) {
9650 wpa_s->create_p2p_iface = 0;
9652 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
9655 if (wpa_s->create_p2p_iface) {
9664 return -1;
9667 if_addr = wpa_s->pending_interface_addr;
9668 } else if (wpa_s->p2p_mgmt)
9669 if_addr = wpa_s->parent->own_addr;
9671 if_addr = wpa_s->own_addr;
9673 wpa_s->p2p_nfc_tag_enabled = enabled;
9675 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
9677 if (iface->ap_iface == NULL)
9679 hapd = iface->ap_iface->bss[0];
9680 wpabuf_free(hapd->conf->wps_nfc_dh_pubkey);
9681 hapd->conf->wps_nfc_dh_pubkey =
9682 wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
9683 wpabuf_free(hapd->conf->wps_nfc_dh_privkey);
9684 hapd->conf->wps_nfc_dh_privkey =
9685 wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
9686 wpabuf_free(hapd->conf->wps_nfc_dev_pw);
9687 hapd->conf->wps_nfc_dev_pw =
9688 wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
9689 hapd->conf->wps_nfc_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
9691 if (hostapd_wps_nfc_token_enable(iface->ap_iface->bss[0]) < 0) {
9697 wpa_s->global->p2p, wpa_s->conf->wps_nfc_dev_pw_id, go_intent,
9717 if (!wpa_s->conf->p2p_optimize_listen_chan)
9720 curr_chan = p2p_get_listen_channel(wpa_s->global->p2p);
9736 p2p_set_listen_channel(wpa_s->global->p2p, 81, cand, 0);
9746 struct wpa_ssid *current_ssid = wpa_s->current_ssid;
9747 int old_freq = current_ssid->frequency;
9750 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP_CSA)) {
9752 return -1;
9763 return -1;
9766 if (current_ssid->frequency == params.freq) {
9768 "P2P CSA: Selected same frequency - not moving GO");
9776 return -1;
9779 current_ssid->frequency = params.freq;
9783 ret = -1;
9787 if (conf->hw_mode != wpa_s->ap_iface->current_mode->mode &&
9788 (wpa_s->ap_iface->current_mode->mode != HOSTAPD_MODE_IEEE80211A ||
9789 is_6ghz_freq(wpa_s->ap_iface->freq) ||
9790 conf->hw_mode != HOSTAPD_MODE_IEEE80211G)) {
9793 wpa_s->ap_iface->current_mode->mode,
9794 is_6ghz_freq(wpa_s->ap_iface->freq) ? " (6 GHz)" : "",
9795 conf->hw_mode);
9796 ret = -1;
9803 csa_settings.link_id = -1;
9805 csa_settings.freq_params.sec_channel_offset = conf->secondary_channel;
9806 csa_settings.freq_params.ht_enabled = conf->ieee80211n;
9807 csa_settings.freq_params.bandwidth = conf->secondary_channel ? 40 : 20;
9809 if (conf->ieee80211ac) {
9814 conf->secondary_channel,
9815 conf->vht_oper_chwidth,
9819 ret = -1;
9823 if (conf->vht_oper_centr_freq_seg0_idx)
9826 conf->vht_oper_centr_freq_seg0_idx);
9828 if (conf->vht_oper_centr_freq_seg1_idx)
9831 conf->vht_oper_centr_freq_seg1_idx);
9836 ret = -1;
9840 csa_settings.freq_params.vht_enabled = conf->ieee80211ac;
9844 switch (conf->vht_oper_chwidth) {
9859 current_ssid->frequency = old_freq;
9868 struct wpa_ssid *current_ssid = wpa_s->current_ssid;
9875 current_ssid->frequency);
9881 * be preserved, or GROUP-STARTED event would be lost. If this action
9884 ap_configured_cb = wpa_s->ap_configured_cb;
9885 ap_configured_cb_ctx = wpa_s->ap_configured_cb_ctx;
9886 ap_configured_cb_data = wpa_s->ap_configured_cb_data;
9901 !p2p_supported_freq_go(wpa_s->global->p2p, params.freq)) {
9911 wpa_s->ap_configured_cb = ap_configured_cb;
9912 wpa_s->ap_configured_cb_ctx = ap_configured_cb_ctx;
9913 wpa_s->ap_configured_cb_data = ap_configured_cb_data;
9916 current_ssid->frequency = params.freq;
9917 wpa_s->connect_without_scan = current_ssid;
9918 wpa_s->reassociate = 1;
9919 wpa_s->disconnected = 0;
9928 if (!wpa_s->ap_iface || !wpa_s->current_ssid)
9934 if (hostapd_csa_in_progress(wpa_s->ap_iface)) {
9936 "P2P: CSA is in progress - not moving GO");
9953 unsigned int num = wpa_s->num_multichan_concurrent;
9961 /* Previous attempt to move a GO was not possible -- try again. */
9991 freq = wpa_s->current_ssid->frequency;
9992 dfs_offload = (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
9993 ieee80211_is_dfs(freq, wpa_s->hw.modes, wpa_s->hw.num_modes);
9999 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq) &&
10009 } else if (!p2p_supported_freq(wpa_s->global->p2p,
10013 } else if (wpa_s->conf->p2p_go_freq_change_policy ==
10016 } else if (wpa_s->conf->p2p_go_freq_change_policy ==
10020 } else if ((wpa_s->conf->p2p_go_freq_change_policy ==
10023 if (!p2p_get_group_num_members(wpa_s->p2p_group)) {
10025 } else if ((wpa_s->drv_flags &
10034 if (wpa_s->ap_iface->current_mode->mode ==
10057 "P2P: GO move: policy CS is not allowed - setting timeout to re-consider GO move");
10077 if (hostapd_csa_in_progress(wpa_s->ap_iface)) {
10079 "P2P: Not initiating a GO frequency change - CSA is in progress");
10083 if (invalid_freq && !wpas_p2p_disallowed_freq(wpa_s->global, freq))
10098 enum wpas_p2p_channel_update_trig trig)
10110 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
10112 if (ifs->current_ssid == NULL ||
10113 ifs->current_ssid->mode != WPAS_MODE_P2P_GO)
10121 (trig == WPAS_P2P_CHANNEL_UPDATE_STATE_CHANGE ||
10122 trig == WPAS_P2P_CHANNEL_UPDATE_CS)) {
10124 "P2P: GO move - schedule re-consideration");
10138 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
10148 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
10151 wpas_p2p_deinit_global(wpa_s->global);
10158 if (wpa_s->ap_iface->bss)
10159 wpa_s->ap_iface->bss[0]->p2p_group = NULL;
10168 struct p2p_data *p2p = wpa_s->global->p2p;
10174 if (wpa_s->p2p_lo_started) {
10180 if (wpa_s->global->p2p == NULL ||
10181 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD)) {
10183 return -1;
10186 if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
10189 return -1;
10193 dev_types_len = (wpa_s->conf->num_sec_device_types + 1) *
10197 return -1;
10198 os_memcpy(device_types, wpa_s->conf->device_type, WPS_DEV_TYPE_LEN);
10199 os_memcpy(&device_types[WPS_DEV_TYPE_LEN], wpa_s->conf->sec_device_type,
10200 wpa_s->conf->num_sec_device_types * WPS_DEV_TYPE_LEN);
10206 return -1;
10220 wpa_s->p2p_lo_started = 1;
10234 if (!wpa_s->p2p_lo_started)
10242 wpa_s->p2p_lo_started = 0;