1 /*
2 * wpa_supplicant - P2P
3 * Copyright (c) 2009-2010, Atheros Communications
4 * Copyright (c) 2010-2014, Jouni Malinen <j@w1.fi>
5 *
6 * This software may be distributed under the terms of the BSD license.
7 * See README for more details.
8 */
9
10 #include "includes.h"
11
12 #include "common.h"
13 #include "eloop.h"
14 #include "common/ieee802_11_common.h"
15 #include "common/ieee802_11_defs.h"
16 #include "common/wpa_ctrl.h"
17 #include "wps/wps_i.h"
18 #include "p2p/p2p.h"
19 #include "ap/hostapd.h"
20 #include "ap/ap_config.h"
21 #include "ap/sta_info.h"
22 #include "ap/ap_drv_ops.h"
23 #include "ap/wps_hostapd.h"
24 #include "ap/p2p_hostapd.h"
25 #include "ap/dfs.h"
26 #include "ap/wpa_auth.h"
27 #include "eapol_supp/eapol_supp_sm.h"
28 #include "rsn_supp/wpa.h"
29 #include "rsn_supp/pmksa_cache.h"
30 #include "wpa_supplicant_i.h"
31 #include "driver_i.h"
32 #include "ap.h"
33 #include "config_ssid.h"
34 #include "config.h"
35 #include "notify.h"
36 #include "scan.h"
37 #include "bss.h"
38 #include "offchannel.h"
39 #include "wps_supplicant.h"
40 #include "p2p_supplicant.h"
41 #include "wifi_display.h"
42
43
44 /*
45 * How many times to try to scan to find the GO before giving up on join
46 * request.
47 */
48 #define P2P_MAX_JOIN_SCAN_ATTEMPTS 10
49
50 #define P2P_AUTO_PD_SCAN_ATTEMPTS 5
51
52 /**
53 * Defines time interval in seconds when a GO needs to evacuate a frequency that
54 * it is currently using, but is no longer valid for P2P use cases.
55 */
56 #define P2P_GO_FREQ_CHANGE_TIME 5
57
58 /**
59 * Defines CSA parameters which are used when GO evacuates the no longer valid
60 * channel (and if the driver supports channel switch).
61 */
62 #define P2P_GO_CSA_COUNT 7
63 #define P2P_GO_CSA_BLOCK_TX 0
64
65 #ifndef P2P_MAX_CLIENT_IDLE
66 /*
67 * How many seconds to try to reconnect to the GO when connection in P2P client
68 * role has been lost.
69 */
70 #define P2P_MAX_CLIENT_IDLE 10
71 #endif /* P2P_MAX_CLIENT_IDLE */
72
73 #ifndef P2P_MAX_INITIAL_CONN_WAIT
74 /*
75 * How many seconds to wait for initial 4-way handshake to get completed after
76 * WPS provisioning step or after the re-invocation of a persistent group on a
77 * P2P Client.
78 */
79 #define P2P_MAX_INITIAL_CONN_WAIT 10
80 #endif /* P2P_MAX_INITIAL_CONN_WAIT */
81
82 #ifndef P2P_MAX_INITIAL_CONN_WAIT_GO
83 /*
84 * How many seconds to wait for initial 4-way handshake to get completed after
85 * WPS provisioning step on the GO. This controls the extra time the P2P
86 * operation is considered to be in progress (e.g., to delay other scans) after
87 * WPS provisioning has been completed on the GO during group formation.
88 */
89 #define P2P_MAX_INITIAL_CONN_WAIT_GO 10
90 #endif /* P2P_MAX_INITIAL_CONN_WAIT_GO */
91
92 #ifndef P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE
93 /*
94 * How many seconds to wait for initial 4-way handshake to get completed after
95 * re-invocation of a persistent group on the GO when the client is expected
96 * to connect automatically (no user interaction).
97 */
98 #define P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE 15
99 #endif /* P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE */
100
101 #define P2P_MGMT_DEVICE_PREFIX "p2p-dev-"
102
103 /*
104 * How many seconds to wait to re-attempt to move GOs, in case previous attempt
105 * was not possible.
106 */
107 #define P2P_RECONSIDER_GO_MOVE_DELAY 30
108
109 enum p2p_group_removal_reason {
110 P2P_GROUP_REMOVAL_UNKNOWN,
111 P2P_GROUP_REMOVAL_SILENT,
112 P2P_GROUP_REMOVAL_FORMATION_FAILED,
113 P2P_GROUP_REMOVAL_REQUESTED,
114 P2P_GROUP_REMOVAL_IDLE_TIMEOUT,
115 P2P_GROUP_REMOVAL_UNAVAILABLE,
116 P2P_GROUP_REMOVAL_GO_ENDING_SESSION,
117 P2P_GROUP_REMOVAL_PSK_FAILURE,
118 P2P_GROUP_REMOVAL_FREQ_CONFLICT,
119 P2P_GROUP_REMOVAL_GO_LEAVE_CHANNEL
120 };
121
122
123 static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx);
124 static struct wpa_supplicant *
125 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
126 int go);
127 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq,
128 const u8 *ssid, size_t ssid_len);
129 static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq,
130 int *force_freq, int *pref_freq, int go,
131 struct weighted_pcl *pref_freq_list,
132 unsigned int *num_pref_freq);
133 static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq,
134 const u8 *ssid, size_t ssid_len);
135 static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx);
136 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
137 const u8 *dev_addr, enum p2p_wps_method wps_method,
138 int auto_join, int freq,
139 const u8 *ssid, size_t ssid_len);
140 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s);
141 static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s);
142 static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx);
143 static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s);
144 static void wpas_p2p_group_formation_timeout(void *eloop_ctx,
145 void *timeout_ctx);
146 static void wpas_p2p_group_freq_conflict(void *eloop_ctx, void *timeout_ctx);
147 static int wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
148 int group_added);
149 static void wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s);
150 static void wpas_stop_listen(void *ctx);
151 static void wpas_p2p_psk_failure_removal(void *eloop_ctx, void *timeout_ctx);
152 static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s);
153 static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
154 enum wpa_driver_if_type type);
155 static void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s,
156 int already_deleted,
157 const char *reason);
158 static void wpas_p2p_optimize_listen_channel(struct wpa_supplicant *wpa_s,
159 struct wpa_used_freq_data *freqs,
160 unsigned int num);
161 static void wpas_p2p_move_go(void *eloop_ctx, void *timeout_ctx);
162 static int wpas_p2p_go_is_peer_freq(struct wpa_supplicant *wpa_s, int freq);
163 static void
164 wpas_p2p_consider_moving_gos(struct wpa_supplicant *wpa_s,
165 struct wpa_used_freq_data *freqs, unsigned int num,
166 enum wpas_p2p_channel_update_trig trig);
167 static void wpas_p2p_reconsider_moving_go(void *eloop_ctx, void *timeout_ctx);
168 static int wpas_p2p_disallowed_freq(struct wpa_global *global,
169 unsigned int freq);
170
171
wpas_get_6ghz_he_chwidth_capab(struct hostapd_hw_modes * mode)172 static int wpas_get_6ghz_he_chwidth_capab(struct hostapd_hw_modes *mode)
173 {
174 int he_capab = 0;
175
176 if (mode)
177 he_capab = mode->he_capab[WPAS_MODE_INFRA].phy_cap[
178 HE_PHYCAP_CHANNEL_WIDTH_SET_IDX];
179 return he_capab;
180 }
181
182
183 /*
184 * Get the number of concurrent channels that the HW can operate, but that are
185 * currently not in use by any of the wpa_supplicant interfaces.
186 */
wpas_p2p_num_unused_channels(struct wpa_supplicant * wpa_s)187 static int wpas_p2p_num_unused_channels(struct wpa_supplicant *wpa_s)
188 {
189 int *freqs;
190 int num, unused;
191
192 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
193 if (!freqs)
194 return -1;
195
196 num = get_shared_radio_freqs(wpa_s, freqs,
197 wpa_s->num_multichan_concurrent, false);
198 os_free(freqs);
199
200 unused = wpa_s->num_multichan_concurrent - num;
201 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: num_unused_channels: %d", unused);
202 return unused;
203 }
204
205
206 /*
207 * Get the frequencies that are currently in use by one or more of the virtual
208 * interfaces, and that are also valid for P2P operation.
209 */
210 static unsigned int
wpas_p2p_valid_oper_freqs(struct wpa_supplicant * wpa_s,struct wpa_used_freq_data * p2p_freqs,unsigned int len)211 wpas_p2p_valid_oper_freqs(struct wpa_supplicant *wpa_s,
212 struct wpa_used_freq_data *p2p_freqs,
213 unsigned int len)
214 {
215 struct wpa_used_freq_data *freqs;
216 unsigned int num, i, j;
217
218 freqs = os_calloc(wpa_s->num_multichan_concurrent,
219 sizeof(struct wpa_used_freq_data));
220 if (!freqs)
221 return 0;
222
223 num = get_shared_radio_freqs_data(wpa_s, freqs,
224 wpa_s->num_multichan_concurrent,
225 false);
226
227 os_memset(p2p_freqs, 0, sizeof(struct wpa_used_freq_data) * len);
228
229 for (i = 0, j = 0; i < num && j < len; i++) {
230 if (p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
231 p2p_freqs[j++] = freqs[i];
232 }
233
234 os_free(freqs);
235
236 dump_freq_data(wpa_s, "valid for P2P", p2p_freqs, j);
237
238 return j;
239 }
240
241
wpas_p2p_set_own_freq_preference(struct wpa_supplicant * wpa_s,int freq)242 static void wpas_p2p_set_own_freq_preference(struct wpa_supplicant *wpa_s,
243 int freq)
244 {
245 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
246 return;
247
248 /* Use the wpa_s used to control the P2P Device operation */
249 wpa_s = wpa_s->global->p2p_init_wpa_s;
250
251 if (wpa_s->conf->p2p_ignore_shared_freq &&
252 freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
253 wpas_p2p_num_unused_channels(wpa_s) > 0) {
254 wpa_printf(MSG_DEBUG, "P2P: Ignore own channel preference %d MHz due to p2p_ignore_shared_freq=1 configuration",
255 freq);
256 freq = 0;
257 }
258 p2p_set_own_freq_preference(wpa_s->global->p2p, freq);
259 }
260
261
wpas_p2p_scan_res_handled(struct wpa_supplicant * wpa_s)262 static void wpas_p2p_scan_res_handled(struct wpa_supplicant *wpa_s)
263 {
264 unsigned int delay = wpas_p2p_search_delay(wpa_s);
265
266 /* In case of concurrent P2P and external scans, delay P2P search. */
267 if (external_scan_running(wpa_s->radio)) {
268 delay = wpa_s->conf->p2p_search_delay;
269 wpa_printf(MSG_DEBUG,
270 "P2P: Delay next P2P search by %d ms to let externally triggered scan complete",
271 delay);
272 }
273
274 p2p_scan_res_handled(wpa_s->global->p2p, delay);
275 }
276
277
wpas_p2p_scan_res_handler(struct wpa_supplicant * wpa_s,struct wpa_scan_results * scan_res)278 static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s,
279 struct wpa_scan_results *scan_res)
280 {
281 size_t i;
282
283 if (wpa_s->p2p_scan_work) {
284 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
285 wpa_s->p2p_scan_work = NULL;
286 radio_work_done(work);
287 }
288
289 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
290 return;
291
292 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS)",
293 (int) scan_res->num);
294
295 for (i = 0; i < scan_res->num; i++) {
296 struct wpa_scan_res *bss = scan_res->res[i];
297 struct os_reltime time_tmp_age, entry_ts;
298 const u8 *ies;
299 size_t ies_len;
300
301 time_tmp_age.sec = bss->age / 1000;
302 time_tmp_age.usec = (bss->age % 1000) * 1000;
303 os_reltime_sub(&scan_res->fetch_time, &time_tmp_age, &entry_ts);
304
305 ies = (const u8 *) (bss + 1);
306 ies_len = bss->ie_len;
307 if (bss->beacon_ie_len > 0 &&
308 !wpa_scan_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) &&
309 wpa_scan_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) {
310 wpa_printf(MSG_DEBUG, "P2P: Use P2P IE(s) from Beacon frame since no P2P IE(s) in Probe Response frames received for "
311 MACSTR, MAC2STR(bss->bssid));
312 ies = ies + ies_len;
313 ies_len = bss->beacon_ie_len;
314 }
315
316
317 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
318 bss->freq, &entry_ts, bss->level,
319 ies, ies_len) > 0)
320 break;
321 }
322
323 wpas_p2p_scan_res_handled(wpa_s);
324 }
325
326
wpas_p2p_scan_res_fail_handler(struct wpa_supplicant * wpa_s)327 static void wpas_p2p_scan_res_fail_handler(struct wpa_supplicant *wpa_s)
328 {
329 if (wpa_s->p2p_scan_work) {
330 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
331
332 wpa_s->p2p_scan_work = NULL;
333 radio_work_done(work);
334 }
335
336 if (wpa_s->global->p2p_disabled || !wpa_s->global->p2p)
337 return;
338
339 wpa_dbg(wpa_s, MSG_DEBUG,
340 "P2P: Failed to get scan results - try to continue");
341 wpas_p2p_scan_res_handled(wpa_s);
342 }
343
344
wpas_p2p_scan_freqs(struct wpa_supplicant * wpa_s,struct wpa_driver_scan_params * params,bool include_6ghz)345 void wpas_p2p_scan_freqs(struct wpa_supplicant *wpa_s,
346 struct wpa_driver_scan_params *params,
347 bool include_6ghz)
348 {
349 wpa_add_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211A,
350 params, false, false, false);
351 wpa_add_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211G,
352 params, false, false, false);
353 wpa_add_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211AD,
354 params, false, false, false);
355 if (!wpa_s->conf->p2p_6ghz_disable &&
356 is_p2p_allow_6ghz(wpa_s->global->p2p) && include_6ghz)
357 wpa_add_scan_freqs_list(wpa_s, HOSTAPD_MODE_IEEE80211A,
358 params, true, true, false);
359 }
360
361
wpas_p2p_trigger_scan_cb(struct wpa_radio_work * work,int deinit)362 static void wpas_p2p_trigger_scan_cb(struct wpa_radio_work *work, int deinit)
363 {
364 struct wpa_supplicant *wpa_s = work->wpa_s;
365 struct wpa_driver_scan_params *params = work->ctx;
366 int ret;
367
368 if (deinit) {
369 if (!work->started) {
370 wpa_scan_free_params(params);
371 return;
372 }
373
374 wpa_s->p2p_scan_work = NULL;
375 return;
376 }
377
378 if (wpa_s->clear_driver_scan_cache) {
379 wpa_printf(MSG_DEBUG,
380 "Request driver to clear scan cache due to local BSS flush");
381 params->only_new_results = 1;
382 }
383
384 if (!params->freqs)
385 wpas_p2p_scan_freqs(wpa_s, params, params->p2p_include_6ghz);
386
387 ret = wpa_drv_scan(wpa_s, params);
388 if (ret == 0)
389 wpa_s->curr_scan_cookie = params->scan_cookie;
390 wpa_scan_free_params(params);
391 work->ctx = NULL;
392 if (ret) {
393 radio_work_done(work);
394 p2p_notify_scan_trigger_status(wpa_s->global->p2p, ret);
395 return;
396 }
397
398 p2p_notify_scan_trigger_status(wpa_s->global->p2p, ret);
399 os_get_reltime(&wpa_s->scan_trigger_time);
400 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
401 wpa_s->scan_res_fail_handler = wpas_p2p_scan_res_fail_handler;
402 wpa_s->own_scan_requested = 1;
403 wpa_s->clear_driver_scan_cache = 0;
404 wpa_s->p2p_scan_work = work;
405 }
406
407
wpas_p2p_search_social_channel(struct wpa_supplicant * wpa_s,int freq)408 static int wpas_p2p_search_social_channel(struct wpa_supplicant *wpa_s,
409 int freq)
410 {
411 if (wpa_s->global->p2p_24ghz_social_channels &&
412 (freq == 2412 || freq == 2437 || freq == 2462)) {
413 /*
414 * Search all social channels regardless of whether these have
415 * been disabled for P2P operating channel use to avoid missing
416 * peers.
417 */
418 return 1;
419 }
420 return p2p_supported_freq(wpa_s->global->p2p, freq);
421 }
422
423
wpas_p2p_scan(void * ctx,enum p2p_scan_type type,int freq,unsigned int num_req_dev_types,const u8 * req_dev_types,const u8 * dev_id,u16 pw_id,bool include_6ghz)424 static int wpas_p2p_scan(void *ctx, enum p2p_scan_type type, int freq,
425 unsigned int num_req_dev_types,
426 const u8 *req_dev_types, const u8 *dev_id, u16 pw_id,
427 bool include_6ghz)
428 {
429 struct wpa_supplicant *wpa_s = ctx;
430 struct wpa_driver_scan_params *params = NULL;
431 struct wpabuf *wps_ie, *ies;
432 unsigned int num_channels = 0;
433 int social_channels_freq[] = { 2412, 2437, 2462, 60480 };
434 size_t ielen;
435 u8 *n, i;
436 unsigned int bands;
437
438 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
439 return -1;
440
441 if (wpa_s->p2p_scan_work) {
442 wpa_dbg(wpa_s, MSG_INFO, "P2P: Reject scan trigger since one is already pending");
443 return -1;
444 }
445
446 params = os_zalloc(sizeof(*params));
447 if (params == NULL)
448 return -1;
449
450 /* P2P Wildcard SSID */
451 params->num_ssids = 1;
452 n = os_malloc(P2P_WILDCARD_SSID_LEN);
453 if (n == NULL)
454 goto fail;
455 os_memcpy(n, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
456 params->ssids[0].ssid = n;
457 params->ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
458
459 wpa_s->wps->dev.p2p = 1;
460 wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev,
461 wpa_s->wps->uuid, WPS_REQ_ENROLLEE,
462 num_req_dev_types, req_dev_types);
463 if (wps_ie == NULL)
464 goto fail;
465
466 /*
467 * In case 6 GHz channels are requested as part of the P2P scan, only
468 * the PSCs would be included as P2P GOs are not expected to be
469 * collocated, i.e., they would not be announced in the RNR element of
470 * other APs.
471 */
472 if (!wpa_s->conf->p2p_6ghz_disable)
473 params->p2p_include_6ghz = include_6ghz;
474 switch (type) {
475 case P2P_SCAN_SOCIAL:
476 params->freqs = os_calloc(ARRAY_SIZE(social_channels_freq) + 1,
477 sizeof(int));
478 if (params->freqs == NULL)
479 goto fail;
480 for (i = 0; i < ARRAY_SIZE(social_channels_freq); i++) {
481 if (wpas_p2p_search_social_channel(
482 wpa_s, social_channels_freq[i]))
483 params->freqs[num_channels++] =
484 social_channels_freq[i];
485 }
486 params->freqs[num_channels++] = 0;
487 break;
488 case P2P_SCAN_FULL:
489 break;
490 case P2P_SCAN_SPECIFIC:
491 params->freqs = os_calloc(2, sizeof(int));
492 if (params->freqs == NULL)
493 goto fail;
494 params->freqs[0] = freq;
495 params->freqs[1] = 0;
496 break;
497 case P2P_SCAN_SOCIAL_PLUS_ONE:
498 params->freqs = os_calloc(ARRAY_SIZE(social_channels_freq) + 2,
499 sizeof(int));
500 if (params->freqs == NULL)
501 goto fail;
502 for (i = 0; i < ARRAY_SIZE(social_channels_freq); i++) {
503 if (wpas_p2p_search_social_channel(
504 wpa_s, social_channels_freq[i]))
505 params->freqs[num_channels++] =
506 social_channels_freq[i];
507 }
508 if (p2p_supported_freq(wpa_s->global->p2p, freq))
509 params->freqs[num_channels++] = freq;
510 params->freqs[num_channels++] = 0;
511 break;
512 }
513
514 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
515 ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen);
516 if (ies == NULL) {
517 wpabuf_free(wps_ie);
518 goto fail;
519 }
520 wpabuf_put_buf(ies, wps_ie);
521 wpabuf_free(wps_ie);
522
523 bands = wpas_get_bands(wpa_s, params->freqs);
524 p2p_scan_ie(wpa_s->global->p2p, ies, dev_id, bands);
525
526 params->p2p_probe = 1;
527 n = os_malloc(wpabuf_len(ies));
528 if (n == NULL) {
529 wpabuf_free(ies);
530 goto fail;
531 }
532 os_memcpy(n, wpabuf_head(ies), wpabuf_len(ies));
533 params->extra_ies = n;
534 params->extra_ies_len = wpabuf_len(ies);
535 wpabuf_free(ies);
536
537 radio_remove_works(wpa_s, "p2p-scan", 0);
538 if (radio_add_work(wpa_s, 0, "p2p-scan", 0, wpas_p2p_trigger_scan_cb,
539 params) < 0)
540 goto fail;
541 return 0;
542
543 fail:
544 wpa_scan_free_params(params);
545 return -1;
546 }
547
548
wpas_p2p_if_type(int p2p_group_interface)549 static enum wpa_driver_if_type wpas_p2p_if_type(int p2p_group_interface)
550 {
551 switch (p2p_group_interface) {
552 case P2P_GROUP_INTERFACE_PENDING:
553 return WPA_IF_P2P_GROUP;
554 case P2P_GROUP_INTERFACE_GO:
555 return WPA_IF_P2P_GO;
556 case P2P_GROUP_INTERFACE_CLIENT:
557 return WPA_IF_P2P_CLIENT;
558 default:
559 return WPA_IF_P2P_GROUP;
560 }
561 }
562
563
wpas_get_p2p_group(struct wpa_supplicant * wpa_s,const u8 * ssid,size_t ssid_len,int * go)564 static struct wpa_supplicant * wpas_get_p2p_group(struct wpa_supplicant *wpa_s,
565 const u8 *ssid,
566 size_t ssid_len, int *go)
567 {
568 struct wpa_ssid *s;
569
570 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
571 for (s = wpa_s->conf->ssid; s; s = s->next) {
572 if (s->disabled != 0 || !s->p2p_group ||
573 s->ssid_len != ssid_len ||
574 os_memcmp(ssid, s->ssid, ssid_len) != 0)
575 continue;
576 if (s->mode == WPAS_MODE_P2P_GO &&
577 s != wpa_s->current_ssid)
578 continue;
579 if (go)
580 *go = s->mode == WPAS_MODE_P2P_GO;
581 return wpa_s;
582 }
583 }
584
585 return NULL;
586 }
587
588
run_wpas_p2p_disconnect(void * eloop_ctx,void * timeout_ctx)589 static void run_wpas_p2p_disconnect(void *eloop_ctx, void *timeout_ctx)
590 {
591 struct wpa_supplicant *wpa_s = eloop_ctx;
592 wpa_printf(MSG_DEBUG,
593 "P2P: Complete previously requested removal of %s",
594 wpa_s->ifname);
595 wpas_p2p_disconnect(wpa_s);
596 }
597
598
wpas_p2p_disconnect_safely(struct wpa_supplicant * wpa_s,struct wpa_supplicant * calling_wpa_s)599 static int wpas_p2p_disconnect_safely(struct wpa_supplicant *wpa_s,
600 struct wpa_supplicant *calling_wpa_s)
601 {
602 if (calling_wpa_s == wpa_s && wpa_s &&
603 wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
604 /*
605 * The calling wpa_s instance is going to be removed. Do that
606 * from an eloop callback to keep the instance available until
607 * the caller has returned. This may be needed, e.g., to provide
608 * control interface responses on the per-interface socket.
609 */
610 if (eloop_register_timeout(0, 0, run_wpas_p2p_disconnect,
611 wpa_s, NULL) < 0)
612 return -1;
613 return 0;
614 }
615
616 return wpas_p2p_disconnect(wpa_s);
617 }
618
619
620 /* Determine total number of clients in active groups where we are the GO */
p2p_group_go_member_count(struct wpa_supplicant * wpa_s)621 static unsigned int p2p_group_go_member_count(struct wpa_supplicant *wpa_s)
622 {
623 unsigned int count = 0;
624 struct wpa_ssid *s;
625
626 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
627 for (s = wpa_s->conf->ssid; s; s = s->next) {
628 wpa_printf(MSG_DEBUG,
629 "P2P: sup:%p ssid:%p disabled:%d p2p:%d mode:%d",
630 wpa_s, s, s->disabled, s->p2p_group,
631 s->mode);
632 if (!s->disabled && s->p2p_group &&
633 s->mode == WPAS_MODE_P2P_GO) {
634 count += p2p_get_group_num_members(
635 wpa_s->p2p_group);
636 }
637 }
638 }
639
640 return count;
641 }
642
643
p2p_is_active_persistent_group(struct wpa_supplicant * wpa_s)644 static unsigned int p2p_is_active_persistent_group(struct wpa_supplicant *wpa_s)
645 {
646 return !wpa_s->p2p_mgmt && wpa_s->current_ssid &&
647 !wpa_s->current_ssid->disabled &&
648 wpa_s->current_ssid->p2p_group &&
649 wpa_s->current_ssid->p2p_persistent_group;
650 }
651
652
p2p_is_active_persistent_go(struct wpa_supplicant * wpa_s)653 static unsigned int p2p_is_active_persistent_go(struct wpa_supplicant *wpa_s)
654 {
655 return p2p_is_active_persistent_group(wpa_s) &&
656 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO;
657 }
658
659
660 /* Find an interface for a P2P group where we are the GO */
661 static struct wpa_supplicant *
wpas_p2p_get_go_group(struct wpa_supplicant * wpa_s)662 wpas_p2p_get_go_group(struct wpa_supplicant *wpa_s)
663 {
664 struct wpa_supplicant *save = NULL;
665
666 if (!wpa_s)
667 return NULL;
668
669 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
670 if (!p2p_is_active_persistent_go(wpa_s))
671 continue;
672
673 /* Prefer a group with connected clients */
674 if (p2p_get_group_num_members(wpa_s->p2p_group))
675 return wpa_s;
676 save = wpa_s;
677 }
678
679 /* No group with connected clients, so pick the one without (if any) */
680 return save;
681 }
682
683
p2p_is_active_persistent_cli(struct wpa_supplicant * wpa_s)684 static unsigned int p2p_is_active_persistent_cli(struct wpa_supplicant *wpa_s)
685 {
686 return p2p_is_active_persistent_group(wpa_s) &&
687 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
688 }
689
690
691 /* Find an interface for a P2P group where we are the P2P Client */
692 static struct wpa_supplicant *
wpas_p2p_get_cli_group(struct wpa_supplicant * wpa_s)693 wpas_p2p_get_cli_group(struct wpa_supplicant *wpa_s)
694 {
695 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
696 if (p2p_is_active_persistent_cli(wpa_s))
697 return wpa_s;
698 }
699
700 return NULL;
701 }
702
703
704 /* Find a persistent group where we are the GO */
705 static struct wpa_ssid *
wpas_p2p_get_persistent_go(struct wpa_supplicant * wpa_s)706 wpas_p2p_get_persistent_go(struct wpa_supplicant *wpa_s)
707 {
708 struct wpa_ssid *s;
709
710 for (s = wpa_s->conf->ssid; s; s = s->next) {
711 if (s->disabled == 2 && s->mode == WPAS_MODE_P2P_GO)
712 return s;
713 }
714
715 return NULL;
716 }
717
718
p2ps_group_capability(void * ctx,u8 incoming,u8 role,unsigned int * force_freq,unsigned int * pref_freq)719 static u8 p2ps_group_capability(void *ctx, u8 incoming, u8 role,
720 unsigned int *force_freq,
721 unsigned int *pref_freq)
722 {
723 struct wpa_supplicant *wpa_s = ctx;
724 struct wpa_ssid *s;
725 u8 conncap = P2PS_SETUP_NONE;
726 unsigned int owned_members = 0;
727 struct wpa_supplicant *go_wpa_s, *cli_wpa_s;
728 struct wpa_ssid *persistent_go;
729 int p2p_no_group_iface;
730 struct weighted_pcl pref_freq_list[P2P_MAX_PREF_CHANNELS];
731 unsigned int size;
732
733 wpa_printf(MSG_DEBUG, "P2P: Conncap - in:%d role:%d", incoming, role);
734
735 if (force_freq)
736 *force_freq = 0;
737 if (pref_freq)
738 *pref_freq = 0;
739
740 size = P2P_MAX_PREF_CHANNELS;
741 if (force_freq && pref_freq &&
742 !wpas_p2p_setup_freqs(wpa_s, 0, (int *) force_freq,
743 (int *) pref_freq, 0, pref_freq_list, &size))
744 wpas_p2p_set_own_freq_preference(wpa_s,
745 *force_freq ? *force_freq :
746 *pref_freq);
747
748 /*
749 * For non-concurrent capable devices:
750 * If persistent_go, then no new.
751 * If GO, then no client.
752 * If client, then no GO.
753 */
754 go_wpa_s = wpas_p2p_get_go_group(wpa_s);
755 if (go_wpa_s)
756 owned_members = p2p_get_group_num_members(go_wpa_s->p2p_group);
757 persistent_go = wpas_p2p_get_persistent_go(wpa_s);
758 p2p_no_group_iface = !wpas_p2p_create_iface(wpa_s);
759 cli_wpa_s = wpas_p2p_get_cli_group(wpa_s);
760
761 wpa_printf(MSG_DEBUG,
762 "P2P: GO(iface)=%p members=%u CLI(iface)=%p persistent(ssid)=%p",
763 go_wpa_s, owned_members, cli_wpa_s, persistent_go);
764
765 /* If not concurrent, restrict our choices */
766 if (p2p_no_group_iface) {
767 wpa_printf(MSG_DEBUG, "P2P: p2p_no_group_iface");
768
769 if (cli_wpa_s)
770 return P2PS_SETUP_NONE;
771
772 if (go_wpa_s) {
773 if (role == P2PS_SETUP_CLIENT ||
774 incoming == P2PS_SETUP_GROUP_OWNER ||
775 p2p_client_limit_reached(go_wpa_s->p2p_group))
776 return P2PS_SETUP_NONE;
777
778 return P2PS_SETUP_GROUP_OWNER;
779 }
780
781 if (persistent_go) {
782 if (role == P2PS_SETUP_NONE || role == P2PS_SETUP_NEW) {
783 if (!incoming)
784 return P2PS_SETUP_GROUP_OWNER |
785 P2PS_SETUP_CLIENT;
786 if (incoming == P2PS_SETUP_NEW) {
787 u8 r;
788
789 if (os_get_random(&r, sizeof(r)) < 0 ||
790 (r & 1))
791 return P2PS_SETUP_CLIENT;
792 return P2PS_SETUP_GROUP_OWNER;
793 }
794 }
795 }
796 }
797
798 /* If a required role has been specified, handle it here */
799 if (role && role != P2PS_SETUP_NEW) {
800 switch (incoming) {
801 case P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW:
802 case P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT:
803 /*
804 * Peer has an active GO, so if the role allows it and
805 * we do not have any active roles, become client.
806 */
807 if ((role & P2PS_SETUP_CLIENT) && !go_wpa_s &&
808 !cli_wpa_s)
809 return P2PS_SETUP_CLIENT;
810
811 /* fall through */
812
813 case P2PS_SETUP_NONE:
814 case P2PS_SETUP_NEW:
815 conncap = role;
816 goto grp_owner;
817
818 case P2PS_SETUP_GROUP_OWNER:
819 /*
820 * Must be a complimentary role - cannot be a client to
821 * more than one peer.
822 */
823 if (incoming == role || cli_wpa_s)
824 return P2PS_SETUP_NONE;
825
826 return P2PS_SETUP_CLIENT;
827
828 case P2PS_SETUP_CLIENT:
829 /* Must be a complimentary role */
830 if (incoming != role) {
831 conncap = P2PS_SETUP_GROUP_OWNER;
832 goto grp_owner;
833 }
834 /* fall through */
835
836 default:
837 return P2PS_SETUP_NONE;
838 }
839 }
840
841 /*
842 * For now, we only will support ownership of one group, and being a
843 * client of one group. Therefore, if we have either an existing GO
844 * group, or an existing client group, we will not do a new GO
845 * negotiation, but rather try to re-use the existing groups.
846 */
847 switch (incoming) {
848 case P2PS_SETUP_NONE:
849 case P2PS_SETUP_NEW:
850 if (cli_wpa_s)
851 conncap = P2PS_SETUP_GROUP_OWNER;
852 else if (!owned_members)
853 conncap = P2PS_SETUP_NEW;
854 else if (incoming == P2PS_SETUP_NONE)
855 conncap = P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT;
856 else
857 conncap = P2PS_SETUP_CLIENT;
858 break;
859
860 case P2PS_SETUP_CLIENT:
861 conncap = P2PS_SETUP_GROUP_OWNER;
862 break;
863
864 case P2PS_SETUP_GROUP_OWNER:
865 if (!cli_wpa_s)
866 conncap = P2PS_SETUP_CLIENT;
867 break;
868
869 case P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW:
870 case P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT:
871 if (cli_wpa_s)
872 conncap = P2PS_SETUP_GROUP_OWNER;
873 else {
874 u8 r;
875
876 if (os_get_random(&r, sizeof(r)) < 0 ||
877 (r & 1))
878 conncap = P2PS_SETUP_CLIENT;
879 else
880 conncap = P2PS_SETUP_GROUP_OWNER;
881 }
882 break;
883
884 default:
885 return P2PS_SETUP_NONE;
886 }
887
888 grp_owner:
889 if ((conncap & P2PS_SETUP_GROUP_OWNER) ||
890 (!incoming && (conncap & P2PS_SETUP_NEW))) {
891 if (go_wpa_s && p2p_client_limit_reached(go_wpa_s->p2p_group))
892 conncap &= ~P2PS_SETUP_GROUP_OWNER;
893
894 s = wpas_p2p_get_persistent_go(wpa_s);
895 if (!s && !go_wpa_s && p2p_no_group_iface) {
896 p2p_set_intended_addr(wpa_s->global->p2p,
897 wpa_s->p2p_mgmt ?
898 wpa_s->parent->own_addr :
899 wpa_s->own_addr);
900 } else if (!s && !go_wpa_s) {
901 if (wpas_p2p_add_group_interface(wpa_s,
902 WPA_IF_P2P_GROUP) < 0) {
903 wpa_printf(MSG_ERROR,
904 "P2P: Failed to allocate a new interface for the group");
905 return P2PS_SETUP_NONE;
906 }
907 wpa_s->global->pending_group_iface_for_p2ps = 1;
908 p2p_set_intended_addr(wpa_s->global->p2p,
909 wpa_s->pending_interface_addr);
910 }
911 }
912
913 return conncap;
914 }
915
916
wpas_p2p_group_delete(struct wpa_supplicant * wpa_s,enum p2p_group_removal_reason removal_reason)917 static int wpas_p2p_group_delete(struct wpa_supplicant *wpa_s,
918 enum p2p_group_removal_reason removal_reason)
919 {
920 struct wpa_ssid *ssid;
921 char *gtype;
922 const char *reason;
923
924 ssid = wpa_s->current_ssid;
925 if (ssid == NULL) {
926 /*
927 * The current SSID was not known, but there may still be a
928 * pending P2P group interface waiting for provisioning or a
929 * P2P group that is trying to reconnect.
930 */
931 ssid = wpa_s->conf->ssid;
932 while (ssid) {
933 if (ssid->p2p_group && ssid->disabled != 2)
934 break;
935 ssid = ssid->next;
936 }
937 if (ssid == NULL &&
938 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)
939 {
940 wpa_printf(MSG_ERROR, "P2P: P2P group interface "
941 "not found");
942 return -1;
943 }
944 }
945 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
946 gtype = "GO";
947 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
948 (ssid && ssid->mode == WPAS_MODE_INFRA)) {
949 wpa_s->reassociate = 0;
950 wpa_s->disconnected = 1;
951 gtype = "client";
952 } else
953 gtype = "GO";
954
955 if (removal_reason != P2P_GROUP_REMOVAL_SILENT && ssid)
956 wpas_notify_p2p_group_removed(wpa_s, ssid, gtype);
957
958 if (os_strcmp(gtype, "client") == 0) {
959 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
960 if (eloop_is_timeout_registered(wpas_p2p_psk_failure_removal,
961 wpa_s, NULL)) {
962 wpa_printf(MSG_DEBUG,
963 "P2P: PSK failure removal was scheduled, so use PSK failure as reason for group removal");
964 removal_reason = P2P_GROUP_REMOVAL_PSK_FAILURE;
965 eloop_cancel_timeout(wpas_p2p_psk_failure_removal,
966 wpa_s, NULL);
967 }
968 }
969
970 if (wpa_s->cross_connect_in_use) {
971 wpa_s->cross_connect_in_use = 0;
972 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
973 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
974 wpa_s->ifname, wpa_s->cross_connect_uplink);
975 }
976 switch (removal_reason) {
977 case P2P_GROUP_REMOVAL_REQUESTED:
978 reason = " reason=REQUESTED";
979 break;
980 case P2P_GROUP_REMOVAL_FORMATION_FAILED:
981 reason = " reason=FORMATION_FAILED";
982 break;
983 case P2P_GROUP_REMOVAL_IDLE_TIMEOUT:
984 reason = " reason=IDLE";
985 break;
986 case P2P_GROUP_REMOVAL_UNAVAILABLE:
987 reason = " reason=UNAVAILABLE";
988 break;
989 case P2P_GROUP_REMOVAL_GO_ENDING_SESSION:
990 reason = " reason=GO_ENDING_SESSION";
991 break;
992 case P2P_GROUP_REMOVAL_PSK_FAILURE:
993 reason = " reason=PSK_FAILURE";
994 break;
995 case P2P_GROUP_REMOVAL_FREQ_CONFLICT:
996 reason = " reason=FREQ_CONFLICT";
997 break;
998 default:
999 reason = "";
1000 break;
1001 }
1002 if (removal_reason != P2P_GROUP_REMOVAL_SILENT) {
1003 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1004 P2P_EVENT_GROUP_REMOVED "%s %s%s",
1005 wpa_s->ifname, gtype, reason);
1006 }
1007
1008 if (eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL) > 0)
1009 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group freq_conflict timeout");
1010 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
1011 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
1012 if (eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1013 wpa_s->p2pdev, NULL) > 0) {
1014 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group formation "
1015 "timeout");
1016 wpa_s->p2p_in_provisioning = 0;
1017 wpas_p2p_group_formation_failed(wpa_s, 1, reason);
1018 }
1019
1020 wpa_s->p2p_in_invitation = 0;
1021 wpa_s->p2p_retry_limit = 0;
1022 eloop_cancel_timeout(wpas_p2p_move_go, wpa_s, NULL);
1023 eloop_cancel_timeout(wpas_p2p_reconsider_moving_go, wpa_s, NULL);
1024
1025 /*
1026 * Make sure wait for the first client does not remain active after the
1027 * group has been removed.
1028 */
1029 wpa_s->global->p2p_go_wait_client.sec = 0;
1030
1031 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
1032 struct wpa_global *global;
1033 char *ifname;
1034 enum wpa_driver_if_type type;
1035 wpa_printf(MSG_DEBUG, "P2P: Remove group interface %s",
1036 wpa_s->ifname);
1037 global = wpa_s->global;
1038 ifname = os_strdup(wpa_s->ifname);
1039 type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
1040 eloop_cancel_timeout(run_wpas_p2p_disconnect, wpa_s, NULL);
1041 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
1042 wpa_s = global->ifaces;
1043 if (wpa_s && ifname)
1044 wpa_drv_if_remove(wpa_s, type, ifname);
1045 os_free(ifname);
1046 return 1;
1047 }
1048
1049 /*
1050 * The primary interface was used for P2P group operations, so
1051 * need to reset its p2pdev.
1052 */
1053 wpa_s->p2pdev = wpa_s->parent;
1054
1055 if (!wpa_s->p2p_go_group_formation_completed) {
1056 wpa_s->global->p2p_group_formation = NULL;
1057 wpa_s->p2p_in_provisioning = 0;
1058 }
1059
1060 wpa_s->show_group_started = 0;
1061 os_free(wpa_s->go_params);
1062 wpa_s->go_params = NULL;
1063
1064 os_free(wpa_s->p2p_group_common_freqs);
1065 wpa_s->p2p_group_common_freqs = NULL;
1066 wpa_s->p2p_group_common_freqs_num = 0;
1067 wpa_s->p2p_go_do_acs = 0;
1068 wpa_s->p2p_go_allow_dfs = 0;
1069
1070 wpa_s->waiting_presence_resp = 0;
1071
1072 wpa_printf(MSG_DEBUG, "P2P: Remove temporary group network");
1073 if (ssid && (ssid->p2p_group ||
1074 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION ||
1075 (ssid->key_mgmt & WPA_KEY_MGMT_WPS))) {
1076 int id = ssid->id;
1077 if (ssid == wpa_s->current_ssid) {
1078 wpa_sm_set_config(wpa_s->wpa, NULL);
1079 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
1080 wpa_s->current_ssid = NULL;
1081 }
1082 /*
1083 * Networks objects created during any P2P activities are not
1084 * exposed out as they might/will confuse certain non-P2P aware
1085 * applications since these network objects won't behave like
1086 * regular ones.
1087 *
1088 * Likewise, we don't send out network removed signals for such
1089 * network objects.
1090 */
1091 wpas_notify_network_removed(wpa_s, ssid);
1092 wpa_config_remove_network(wpa_s->conf, id);
1093 wpa_supplicant_clear_status(wpa_s);
1094 wpa_supplicant_cancel_sched_scan(wpa_s);
1095 } else {
1096 wpa_printf(MSG_DEBUG, "P2P: Temporary group network not "
1097 "found");
1098 }
1099 if (wpa_s->ap_iface)
1100 wpa_supplicant_ap_deinit(wpa_s);
1101 else
1102 wpa_drv_deinit_p2p_cli(wpa_s);
1103
1104 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
1105
1106 wpa_s->p2p_go_no_pri_sec_switch = 0;
1107
1108 return 0;
1109 }
1110
1111
wpas_p2p_persistent_group(struct wpa_supplicant * wpa_s,u8 * go_dev_addr,const u8 * ssid,size_t ssid_len)1112 static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s,
1113 u8 *go_dev_addr,
1114 const u8 *ssid, size_t ssid_len)
1115 {
1116 struct wpa_bss *bss;
1117 const u8 *bssid;
1118 struct wpabuf *p2p;
1119 u8 group_capab;
1120 const u8 *addr;
1121
1122 if (wpa_s->go_params)
1123 bssid = wpa_s->go_params->peer_interface_addr;
1124 else
1125 bssid = wpa_s->bssid;
1126
1127 bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
1128 if (bss == NULL && wpa_s->go_params &&
1129 !is_zero_ether_addr(wpa_s->go_params->peer_device_addr))
1130 bss = wpa_bss_get_p2p_dev_addr(
1131 wpa_s, wpa_s->go_params->peer_device_addr);
1132 if (bss == NULL) {
1133 u8 iface_addr[ETH_ALEN];
1134 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
1135 iface_addr) == 0)
1136 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
1137 }
1138 if (bss == NULL) {
1139 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
1140 "group is persistent - BSS " MACSTR " not found",
1141 MAC2STR(bssid));
1142 return 0;
1143 }
1144
1145 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
1146 if (p2p == NULL)
1147 p2p = wpa_bss_get_vendor_ie_multi_beacon(bss,
1148 P2P_IE_VENDOR_TYPE);
1149 if (p2p == NULL) {
1150 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
1151 "group is persistent - BSS " MACSTR
1152 " did not include P2P IE", MAC2STR(bssid));
1153 wpa_hexdump(MSG_DEBUG, "P2P: Probe Response IEs",
1154 wpa_bss_ie_ptr(bss), bss->ie_len);
1155 wpa_hexdump(MSG_DEBUG, "P2P: Beacon IEs",
1156 wpa_bss_ie_ptr(bss) + bss->ie_len,
1157 bss->beacon_ie_len);
1158 return 0;
1159 }
1160
1161 group_capab = p2p_get_group_capab(p2p);
1162 addr = p2p_get_go_dev_addr(p2p);
1163 wpa_printf(MSG_DEBUG, "P2P: Checking whether group is persistent: "
1164 "group_capab=0x%x", group_capab);
1165 if (addr) {
1166 os_memcpy(go_dev_addr, addr, ETH_ALEN);
1167 wpa_printf(MSG_DEBUG, "P2P: GO Device Address " MACSTR,
1168 MAC2STR(addr));
1169 } else
1170 os_memset(go_dev_addr, 0, ETH_ALEN);
1171 wpabuf_free(p2p);
1172
1173 wpa_printf(MSG_DEBUG, "P2P: BSS " MACSTR " group_capab=0x%x "
1174 "go_dev_addr=" MACSTR,
1175 MAC2STR(bssid), group_capab, MAC2STR(go_dev_addr));
1176
1177 return !!(group_capab & P2P_GROUP_CAPAB_PERSISTENT_GROUP);
1178 }
1179
1180
wpas_p2p_store_persistent_group(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid,const u8 * go_dev_addr,int dik_id)1181 static int wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s,
1182 struct wpa_ssid *ssid,
1183 const u8 *go_dev_addr, int dik_id)
1184 {
1185 struct wpa_ssid *s;
1186 int changed = 0;
1187
1188 wpa_printf(MSG_DEBUG, "P2P: Storing credentials for a persistent "
1189 "group (GO Dev Addr " MACSTR ")", MAC2STR(go_dev_addr));
1190 for (s = wpa_s->conf->ssid; s; s = s->next) {
1191 if (s->disabled == 2 &&
1192 ether_addr_equal(go_dev_addr, s->bssid) &&
1193 s->ssid_len == ssid->ssid_len &&
1194 os_memcmp(ssid->ssid, s->ssid, ssid->ssid_len) == 0)
1195 break;
1196
1197 if (dik_id && s->go_dik_id == dik_id)
1198 break;
1199 }
1200
1201 if (s) {
1202 wpa_printf(MSG_DEBUG, "P2P: Update existing persistent group "
1203 "entry");
1204 if (ssid->passphrase && !s->passphrase)
1205 changed = 1;
1206 else if (ssid->passphrase && s->passphrase &&
1207 os_strcmp(ssid->passphrase, s->passphrase) != 0)
1208 changed = 1;
1209 } else {
1210 wpa_printf(MSG_DEBUG, "P2P: Create a new persistent group "
1211 "entry");
1212 changed = 1;
1213 s = wpa_config_add_network(wpa_s->conf);
1214 if (s == NULL)
1215 return -1;
1216
1217 /*
1218 * Instead of network_added we emit persistent_group_added
1219 * notification. Also to keep the defense checks in
1220 * persistent_group obj registration method, we set the
1221 * relevant flags in s to designate it as a persistent group.
1222 */
1223 s->p2p_group = 1;
1224 s->p2p_persistent_group = 1;
1225 wpas_notify_persistent_group_added(wpa_s, s);
1226 wpa_config_set_network_defaults(s);
1227 }
1228
1229 s->p2p_group = 1;
1230 s->p2p_persistent_group = 1;
1231 s->disabled = 2;
1232 s->bssid_set = 1;
1233 os_memcpy(s->bssid, go_dev_addr, ETH_ALEN);
1234 s->mode = ssid->mode;
1235 s->auth_alg = ssid->auth_alg;
1236 s->key_mgmt = ssid->key_mgmt;
1237 s->proto = ssid->proto;
1238 s->pbss = ssid->pbss;
1239 s->pmk_valid = ssid->pmk_valid;
1240 s->pairwise_cipher = ssid->pbss ? WPA_CIPHER_GCMP : WPA_CIPHER_CCMP;
1241 s->export_keys = 1;
1242 s->go_dik_id = dik_id;
1243
1244 if (ssid->sae_password) {
1245 os_free(s->sae_password);
1246 s->sae_password = os_strdup(ssid->sae_password);
1247 }
1248 if (ssid->passphrase) {
1249 os_free(s->passphrase);
1250 s->passphrase = os_strdup(ssid->passphrase);
1251 }
1252 if (ssid->psk_set) {
1253 s->psk_set = 1;
1254 os_memcpy(s->psk, ssid->psk, 32);
1255 }
1256 if (s->passphrase && !s->psk_set)
1257 wpa_config_update_psk(s);
1258 if (s->ssid == NULL || s->ssid_len < ssid->ssid_len) {
1259 os_free(s->ssid);
1260 s->ssid = os_malloc(ssid->ssid_len);
1261 }
1262 if (s->ssid) {
1263 s->ssid_len = ssid->ssid_len;
1264 os_memcpy(s->ssid, ssid->ssid, s->ssid_len);
1265 }
1266 if (ssid->mode == WPAS_MODE_P2P_GO && wpa_s->global->add_psk) {
1267 dl_list_add(&s->psk_list, &wpa_s->global->add_psk->list);
1268 wpa_s->global->add_psk = NULL;
1269 changed = 1;
1270 }
1271
1272 if (changed && wpa_s->conf->update_config &&
1273 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
1274 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
1275 }
1276
1277 return s->id;
1278 }
1279
1280
wpas_p2p2_add_group_client_dik_id(struct wpa_ssid * s,int dik_id)1281 static void wpas_p2p2_add_group_client_dik_id(struct wpa_ssid *s, int dik_id)
1282 {
1283 size_t i;
1284 bool found = false;
1285 size_t num = int_array_len(s->p2p2_client_list);
1286
1287 for (i = 0; i < num; i++) {
1288 if (s->p2p2_client_list[i] != dik_id)
1289 continue;
1290
1291 if (i == num - 1)
1292 return; /* already the most recent entry */
1293
1294 /* Move the entry to mark it most recent */
1295 os_memmove(s->p2p2_client_list + i,
1296 s->p2p2_client_list + i + 1,
1297 (num - i - 1) * sizeof(int));
1298 s->p2p2_client_list[num - 1] = dik_id;
1299 found = true;
1300 break;
1301 }
1302
1303 if (!found && num < P2P_MAX_STORED_CLIENTS) {
1304 int_array_add_unique(&s->p2p2_client_list, dik_id);
1305 } else if (!found && s->p2p2_client_list) {
1306 /* Not enough room for an additional entry - drop the oldest
1307 * entry
1308 */
1309 os_memmove(s->p2p2_client_list, s->p2p2_client_list + 1,
1310 (num - 1) * sizeof(int));
1311 s->p2p2_client_list[num - 1] = dik_id;
1312 }
1313 }
1314
1315
wpas_p2p_add_persistent_group_client(struct wpa_supplicant * wpa_s,const u8 * addr,int dik_id)1316 static void wpas_p2p_add_persistent_group_client(struct wpa_supplicant *wpa_s,
1317 const u8 *addr, int dik_id)
1318 {
1319 struct wpa_ssid *ssid, *s;
1320 u8 *n;
1321 size_t i;
1322 int found = 0;
1323 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
1324
1325 ssid = wpa_s->current_ssid;
1326 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
1327 !ssid->p2p_persistent_group)
1328 return;
1329
1330 for (s = p2p_wpa_s->conf->ssid; s; s = s->next) {
1331 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
1332 continue;
1333
1334 if (s->ssid_len == ssid->ssid_len &&
1335 os_memcmp(s->ssid, ssid->ssid, s->ssid_len) == 0)
1336 break;
1337 }
1338
1339 if (s == NULL)
1340 return;
1341
1342 if (dik_id) {
1343 wpas_p2p2_add_group_client_dik_id(s, dik_id);
1344 goto done;
1345 }
1346
1347 for (i = 0; s->p2p_client_list && i < s->num_p2p_clients; i++) {
1348 if (!ether_addr_equal(s->p2p_client_list + i * 2 * ETH_ALEN,
1349 addr))
1350 continue;
1351
1352 if (i == s->num_p2p_clients - 1)
1353 return; /* already the most recent entry */
1354
1355 /* move the entry to mark it most recent */
1356 os_memmove(s->p2p_client_list + i * 2 * ETH_ALEN,
1357 s->p2p_client_list + (i + 1) * 2 * ETH_ALEN,
1358 (s->num_p2p_clients - i - 1) * 2 * ETH_ALEN);
1359 os_memcpy(s->p2p_client_list +
1360 (s->num_p2p_clients - 1) * 2 * ETH_ALEN, addr,
1361 ETH_ALEN);
1362 os_memset(s->p2p_client_list +
1363 (s->num_p2p_clients - 1) * 2 * ETH_ALEN + ETH_ALEN,
1364 0xff, ETH_ALEN);
1365 found = 1;
1366 break;
1367 }
1368
1369 if (!found && s->num_p2p_clients < P2P_MAX_STORED_CLIENTS) {
1370 n = os_realloc_array(s->p2p_client_list,
1371 s->num_p2p_clients + 1, 2 * ETH_ALEN);
1372 if (n == NULL)
1373 return;
1374 os_memcpy(n + s->num_p2p_clients * 2 * ETH_ALEN, addr,
1375 ETH_ALEN);
1376 os_memset(n + s->num_p2p_clients * 2 * ETH_ALEN + ETH_ALEN,
1377 0xff, ETH_ALEN);
1378 s->p2p_client_list = n;
1379 s->num_p2p_clients++;
1380 } else if (!found && s->p2p_client_list) {
1381 /* Not enough room for an additional entry - drop the oldest
1382 * entry */
1383 os_memmove(s->p2p_client_list,
1384 s->p2p_client_list + 2 * ETH_ALEN,
1385 (s->num_p2p_clients - 1) * 2 * ETH_ALEN);
1386 os_memcpy(s->p2p_client_list +
1387 (s->num_p2p_clients - 1) * 2 * ETH_ALEN,
1388 addr, ETH_ALEN);
1389 os_memset(s->p2p_client_list +
1390 (s->num_p2p_clients - 1) * 2 * ETH_ALEN + ETH_ALEN,
1391 0xff, ETH_ALEN);
1392 }
1393
1394 done:
1395 if (p2p_wpa_s->conf->update_config &&
1396 wpa_config_write(p2p_wpa_s->confname, p2p_wpa_s->conf))
1397 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
1398 }
1399
1400
wpas_p2p_group_started(struct wpa_supplicant * wpa_s,int go,struct wpa_ssid * ssid,int freq,const u8 * psk,const char * passphrase,const u8 * go_dev_addr,int persistent,const char * extra)1401 static void wpas_p2p_group_started(struct wpa_supplicant *wpa_s,
1402 int go, struct wpa_ssid *ssid, int freq,
1403 const u8 *psk, const char *passphrase,
1404 const u8 *go_dev_addr, int persistent,
1405 const char *extra)
1406 {
1407 const char *ssid_txt;
1408 char psk_txt[65];
1409
1410 if (psk)
1411 wpa_snprintf_hex(psk_txt, sizeof(psk_txt), psk, 32);
1412 else
1413 psk_txt[0] = '\0';
1414
1415 if (ssid)
1416 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
1417 else
1418 ssid_txt = "";
1419
1420 if (passphrase && passphrase[0] == '\0')
1421 passphrase = NULL;
1422
1423 /*
1424 * Include PSK/passphrase only in the control interface message and
1425 * leave it out from the debug log entry.
1426 */
1427 wpa_msg_global_ctrl(wpa_s->p2pdev, MSG_INFO,
1428 P2P_EVENT_GROUP_STARTED
1429 "%s %s ssid=\"%s\" freq=%d%s%s%s%s%s go_dev_addr="
1430 MACSTR "%s%s",
1431 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
1432 psk ? " psk=" : "", psk_txt,
1433 passphrase ? " passphrase=\"" : "",
1434 passphrase ? passphrase : "",
1435 passphrase ? "\"" : "",
1436 MAC2STR(go_dev_addr),
1437 persistent ? " [PERSISTENT]" : "", extra);
1438 wpa_printf(MSG_INFO, P2P_EVENT_GROUP_STARTED
1439 "%s %s ssid=\"%s\" freq=%d go_dev_addr=" MACSTR "%s%s",
1440 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
1441 MAC2STR(go_dev_addr), persistent ? " [PERSISTENT]" : "",
1442 extra);
1443 }
1444
1445
wpas_p2p_remove_all_identity(struct wpa_supplicant * wpa_s)1446 int wpas_p2p_remove_all_identity(struct wpa_supplicant *wpa_s)
1447 {
1448 struct wpa_dev_ik *ik;
1449
1450 for (ik = wpa_s->conf->identity; ik; ik = ik->next)
1451 wpa_config_remove_identity(wpa_s->conf, ik->id);
1452
1453 if (wpa_s->conf->update_config &&
1454 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
1455 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
1456 return -1;
1457 }
1458 return 0;
1459 }
1460
1461
wpas_p2p_store_identity(struct wpa_supplicant * wpa_s,u8 cipher,const u8 * dik_data,size_t dik_len,const u8 * pmk,size_t pmk_len,const u8 * pmkid)1462 static int wpas_p2p_store_identity(struct wpa_supplicant *wpa_s, u8 cipher,
1463 const u8 *dik_data, size_t dik_len,
1464 const u8 *pmk, size_t pmk_len,
1465 const u8 *pmkid)
1466 {
1467 struct wpa_dev_ik *ik;
1468
1469 for (ik = wpa_s->conf->identity; ik; ik = ik->next) {
1470 if (dik_len == wpabuf_len(ik->dik) &&
1471 os_memcmp(dik_data, wpabuf_head(ik->dik), dik_len) == 0) {
1472 wpa_printf(MSG_DEBUG,
1473 "P2P: Remove previous device identity entry for matching DIK");
1474 wpa_config_remove_identity(wpa_s->conf, ik->id);
1475 break;
1476 }
1477 }
1478
1479 wpa_printf(MSG_DEBUG, "P2P: Create a new device identity entry");
1480 ik = wpa_config_add_identity(wpa_s->conf);
1481 if (!ik)
1482 return 0;
1483
1484 ik->dik = wpabuf_alloc_copy(dik_data, dik_len);
1485 if (!ik->dik)
1486 goto fail;
1487 ik->pmk = wpabuf_alloc_copy(pmk, pmk_len);
1488 if (!ik->pmk)
1489 goto fail;
1490 ik->pmkid = wpabuf_alloc_copy(pmkid, PMKID_LEN);
1491 if (!ik->pmkid)
1492 goto fail;
1493
1494 ik->dik_cipher = cipher;
1495
1496 if (wpa_s->conf->update_config &&
1497 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
1498 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
1499 return 0;
1500 }
1501 return ik->id;
1502
1503 fail:
1504 wpa_config_remove_identity(wpa_s->conf, ik->id);
1505 return 0;
1506 }
1507
1508
wpas_p2p_store_go_identity(struct wpa_supplicant * wpa_s,const u8 * go_dev_addr,const u8 * bssid)1509 static int wpas_p2p_store_go_identity(struct wpa_supplicant *wpa_s,
1510 const u8 *go_dev_addr, const u8 *bssid)
1511 {
1512 int ret;
1513 u8 cipher;
1514 const u8 *dik_data, *pmk, *pmkid;
1515 size_t dik_len, pmk_len;
1516 u8 iface_addr[ETH_ALEN];
1517 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
1518
1519 if (!wpa_s->p2p2)
1520 return 0;
1521
1522 ret = p2p_get_dev_identity_key(p2p_wpa_s->global->p2p, go_dev_addr,
1523 &dik_data, &dik_len, &cipher);
1524 if (ret)
1525 return 0;
1526
1527 ret = p2p_get_interface_addr(p2p_wpa_s->global->p2p, go_dev_addr,
1528 iface_addr);
1529 if (ret) {
1530 wpa_printf(MSG_DEBUG,
1531 "P2P: Fetch PMK for GO BSSID " MACSTR,
1532 MAC2STR(bssid));
1533 os_memcpy(iface_addr, bssid, ETH_ALEN);
1534 }
1535 ret = wpa_sm_pmksa_get_pmk(wpa_s->wpa, iface_addr, &pmk, &pmk_len,
1536 &pmkid);
1537 if (ret)
1538 return 0;
1539
1540 wpa_printf(MSG_DEBUG,
1541 "P2P: Storing Device identity of GO (Interface Addr " MACSTR
1542 ")",
1543 MAC2STR(iface_addr));
1544 return wpas_p2p_store_identity(p2p_wpa_s, cipher, dik_data, dik_len,
1545 pmk, pmk_len, pmkid);
1546 }
1547
1548
wpas_group_formation_completed(struct wpa_supplicant * wpa_s,int already_deleted,const char * failure_reason)1549 static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s,
1550 int already_deleted,
1551 const char *failure_reason)
1552 {
1553 struct wpa_ssid *ssid;
1554 int client;
1555 int persistent;
1556 u8 go_dev_addr[ETH_ALEN];
1557
1558 /*
1559 * This callback is likely called for the main interface. Update wpa_s
1560 * to use the group interface if a new interface was created for the
1561 * group.
1562 */
1563 if (wpa_s->global->p2p_group_formation)
1564 wpa_s = wpa_s->global->p2p_group_formation;
1565 if (wpa_s->p2p_go_group_formation_completed) {
1566 wpa_s->global->p2p_group_formation = NULL;
1567 wpa_s->p2p_in_provisioning = 0;
1568 } else if (wpa_s->p2p_in_provisioning && failure_reason) {
1569 wpa_msg(wpa_s, MSG_DEBUG,
1570 "P2P: Stop provisioning state due to failure");
1571 wpa_s->p2p_in_provisioning = 0;
1572 }
1573 wpa_s->p2p_in_invitation = 0;
1574 wpa_s->p2p_retry_limit = 0;
1575 wpa_s->group_formation_reported = 1;
1576
1577 if (failure_reason) {
1578 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1579 P2P_EVENT_GROUP_FORMATION_FAILURE);
1580 wpas_notify_p2p_group_formation_failure(wpa_s, failure_reason);
1581 if (already_deleted)
1582 return;
1583 wpas_p2p_group_delete(wpa_s,
1584 P2P_GROUP_REMOVAL_FORMATION_FAILED);
1585 return;
1586 }
1587
1588 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1589 P2P_EVENT_GROUP_FORMATION_SUCCESS);
1590
1591 ssid = wpa_s->current_ssid;
1592 if (ssid && ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
1593 ssid->mode = WPAS_MODE_P2P_GO;
1594 p2p_group_notif_formation_done(wpa_s->p2p_group);
1595 wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL);
1596 }
1597
1598 persistent = 0;
1599 if (ssid) {
1600 client = ssid->mode == WPAS_MODE_INFRA;
1601 if (ssid->mode == WPAS_MODE_P2P_GO) {
1602 persistent = ssid->p2p_persistent_group;
1603 os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr,
1604 ETH_ALEN);
1605 } else {
1606 os_memset(go_dev_addr, 0, ETH_ALEN);
1607 persistent = wpas_p2p_persistent_group(wpa_s,
1608 go_dev_addr,
1609 ssid->ssid,
1610 ssid->ssid_len);
1611 }
1612 } else {
1613 client = wpa_s->p2p_group_interface ==
1614 P2P_GROUP_INTERFACE_CLIENT;
1615 os_memset(go_dev_addr, 0, ETH_ALEN);
1616 }
1617
1618 wpa_s->show_group_started = 0;
1619 if (client) {
1620 /*
1621 * Indicate event only after successfully completed 4-way
1622 * handshake, i.e., when the interface is ready for data
1623 * packets.
1624 */
1625 wpa_s->show_group_started = 1;
1626 } else {
1627 wpas_p2p_group_started(wpa_s, 1, ssid,
1628 ssid ? ssid->frequency : 0,
1629 ssid && ssid->passphrase == NULL &&
1630 ssid->psk_set ? ssid->psk : NULL,
1631 ssid ? ssid->passphrase : NULL,
1632 go_dev_addr, persistent, "");
1633 wpas_p2p_cross_connect_setup(wpa_s);
1634 wpas_p2p_set_group_idle_timeout(wpa_s);
1635 }
1636
1637 if (persistent)
1638 wpas_p2p_store_persistent_group(wpa_s->p2pdev,
1639 ssid, go_dev_addr, 0);
1640 else {
1641 os_free(wpa_s->global->add_psk);
1642 wpa_s->global->add_psk = NULL;
1643 }
1644
1645 if (!client) {
1646 wpas_notify_p2p_group_started(wpa_s, ssid, persistent, 0, NULL);
1647 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
1648 }
1649 }
1650
1651
1652 struct send_action_work {
1653 unsigned int freq;
1654 u8 dst[ETH_ALEN];
1655 u8 src[ETH_ALEN];
1656 u8 bssid[ETH_ALEN];
1657 size_t len;
1658 unsigned int wait_time;
1659 u8 buf[0];
1660 };
1661
1662
wpas_p2p_free_send_action_work(struct wpa_supplicant * wpa_s)1663 static void wpas_p2p_free_send_action_work(struct wpa_supplicant *wpa_s)
1664 {
1665 struct send_action_work *awork = wpa_s->p2p_send_action_work->ctx;
1666
1667 wpa_printf(MSG_DEBUG,
1668 "P2P: Free Action frame radio work @%p (freq=%u dst="
1669 MACSTR " src=" MACSTR " bssid=" MACSTR " wait_time=%u)",
1670 wpa_s->p2p_send_action_work, awork->freq,
1671 MAC2STR(awork->dst), MAC2STR(awork->src),
1672 MAC2STR(awork->bssid), awork->wait_time);
1673 wpa_hexdump(MSG_DEBUG, "P2P: Freeing pending Action frame",
1674 awork->buf, awork->len);
1675 os_free(awork);
1676 wpa_s->p2p_send_action_work->ctx = NULL;
1677 radio_work_done(wpa_s->p2p_send_action_work);
1678 wpa_s->p2p_send_action_work = NULL;
1679 }
1680
1681
wpas_p2p_send_action_work_timeout(void * eloop_ctx,void * timeout_ctx)1682 static void wpas_p2p_send_action_work_timeout(void *eloop_ctx,
1683 void *timeout_ctx)
1684 {
1685 struct wpa_supplicant *wpa_s = eloop_ctx;
1686
1687 if (!wpa_s->p2p_send_action_work)
1688 return;
1689
1690 wpa_printf(MSG_DEBUG, "P2P: Send Action frame radio work timed out");
1691 wpas_p2p_free_send_action_work(wpa_s);
1692 }
1693
1694
wpas_p2p_action_tx_clear(struct wpa_supplicant * wpa_s)1695 static void wpas_p2p_action_tx_clear(struct wpa_supplicant *wpa_s)
1696 {
1697 if (wpa_s->p2p_send_action_work) {
1698 struct send_action_work *awork;
1699
1700 awork = wpa_s->p2p_send_action_work->ctx;
1701 wpa_printf(MSG_DEBUG,
1702 "P2P: Clear Action TX work @%p (wait_time=%u)",
1703 wpa_s->p2p_send_action_work, awork->wait_time);
1704 if (awork->wait_time == 0) {
1705 wpas_p2p_free_send_action_work(wpa_s);
1706 } else {
1707 /*
1708 * In theory, this should not be needed, but number of
1709 * places in the P2P code is still using non-zero wait
1710 * time for the last Action frame in the sequence and
1711 * some of these do not call send_action_done().
1712 */
1713 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
1714 wpa_s, NULL);
1715 eloop_register_timeout(
1716 0, awork->wait_time * 1000,
1717 wpas_p2p_send_action_work_timeout,
1718 wpa_s, NULL);
1719 }
1720 }
1721 }
1722
1723
wpas_p2p_send_action_tx_status(struct wpa_supplicant * wpa_s,unsigned int freq,const u8 * dst,const u8 * src,const u8 * bssid,const u8 * data,size_t data_len,enum offchannel_send_action_result result)1724 static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s,
1725 unsigned int freq,
1726 const u8 *dst, const u8 *src,
1727 const u8 *bssid,
1728 const u8 *data, size_t data_len,
1729 enum offchannel_send_action_result
1730 result)
1731 {
1732 enum p2p_send_action_result res = P2P_SEND_ACTION_SUCCESS;
1733
1734 wpas_p2p_action_tx_clear(wpa_s);
1735
1736 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
1737 return;
1738
1739 switch (result) {
1740 case OFFCHANNEL_SEND_ACTION_SUCCESS:
1741 res = P2P_SEND_ACTION_SUCCESS;
1742 break;
1743 case OFFCHANNEL_SEND_ACTION_NO_ACK:
1744 res = P2P_SEND_ACTION_NO_ACK;
1745 break;
1746 case OFFCHANNEL_SEND_ACTION_FAILED:
1747 res = P2P_SEND_ACTION_FAILED;
1748 break;
1749 }
1750
1751 p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res);
1752
1753 if (result != OFFCHANNEL_SEND_ACTION_SUCCESS &&
1754 wpa_s->pending_pd_before_join &&
1755 (ether_addr_equal(dst, wpa_s->pending_join_dev_addr) ||
1756 ether_addr_equal(dst, wpa_s->pending_join_iface_addr)) &&
1757 wpa_s->p2p_fallback_to_go_neg) {
1758 wpa_s->pending_pd_before_join = 0;
1759 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No ACK for PD Req "
1760 "during p2p_connect-auto");
1761 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
1762 P2P_EVENT_FALLBACK_TO_GO_NEG
1763 "reason=no-ACK-to-PD-Req");
1764 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
1765 return;
1766 }
1767 }
1768
1769
wpas_send_action_cb(struct wpa_radio_work * work,int deinit)1770 static void wpas_send_action_cb(struct wpa_radio_work *work, int deinit)
1771 {
1772 struct wpa_supplicant *wpa_s = work->wpa_s;
1773 struct send_action_work *awork = work->ctx;
1774
1775 if (deinit) {
1776 if (work->started) {
1777 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
1778 wpa_s, NULL);
1779 wpa_s->p2p_send_action_work = NULL;
1780 offchannel_send_action_done(wpa_s);
1781 }
1782 os_free(awork);
1783 return;
1784 }
1785
1786 if (offchannel_send_action(wpa_s, awork->freq, awork->dst, awork->src,
1787 awork->bssid, awork->buf, awork->len,
1788 awork->wait_time,
1789 wpas_p2p_send_action_tx_status, 1) < 0) {
1790 os_free(awork);
1791 radio_work_done(work);
1792 return;
1793 }
1794 wpa_s->p2p_send_action_work = work;
1795 }
1796
1797
wpas_send_action_work(struct wpa_supplicant * wpa_s,unsigned int freq,const u8 * dst,const u8 * src,const u8 * bssid,const u8 * buf,size_t len,unsigned int wait_time)1798 static int wpas_send_action_work(struct wpa_supplicant *wpa_s,
1799 unsigned int freq, const u8 *dst,
1800 const u8 *src, const u8 *bssid, const u8 *buf,
1801 size_t len, unsigned int wait_time)
1802 {
1803 struct send_action_work *awork;
1804
1805 if (radio_work_pending(wpa_s, "p2p-send-action")) {
1806 wpa_printf(MSG_DEBUG, "P2P: Cannot schedule new p2p-send-action work since one is already pending");
1807 return -1;
1808 }
1809
1810 awork = os_zalloc(sizeof(*awork) + len);
1811 if (awork == NULL)
1812 return -1;
1813
1814 awork->freq = freq;
1815 os_memcpy(awork->dst, dst, ETH_ALEN);
1816 os_memcpy(awork->src, src, ETH_ALEN);
1817 os_memcpy(awork->bssid, bssid, ETH_ALEN);
1818 awork->len = len;
1819 awork->wait_time = wait_time;
1820 os_memcpy(awork->buf, buf, len);
1821
1822 if (radio_add_work(wpa_s, freq, "p2p-send-action", 1,
1823 wpas_send_action_cb, awork) < 0) {
1824 os_free(awork);
1825 return -1;
1826 }
1827
1828 return 0;
1829 }
1830
1831
wpas_send_action(void * ctx,unsigned int freq,const u8 * dst,const u8 * src,const u8 * bssid,const u8 * buf,size_t len,unsigned int wait_time,int * scheduled)1832 static int wpas_send_action(void *ctx, unsigned int freq, const u8 *dst,
1833 const u8 *src, const u8 *bssid, const u8 *buf,
1834 size_t len, unsigned int wait_time, int *scheduled)
1835 {
1836 struct wpa_supplicant *wpa_s = ctx;
1837 int listen_freq = -1, send_freq = -1;
1838
1839 if (scheduled)
1840 *scheduled = 0;
1841 if (wpa_s->p2p_listen_work)
1842 listen_freq = wpa_s->p2p_listen_work->freq;
1843 if (wpa_s->p2p_send_action_work)
1844 send_freq = wpa_s->p2p_send_action_work->freq;
1845 if (listen_freq != (int) freq && send_freq != (int) freq) {
1846 int res;
1847
1848 wpa_printf(MSG_DEBUG,
1849 "P2P: Schedule new radio work for Action frame TX (listen_freq=%d send_freq=%d freq=%u dst="
1850 MACSTR " src=" MACSTR " bssid=" MACSTR,
1851 listen_freq, send_freq, freq, MAC2STR(dst),
1852 MAC2STR(src), MAC2STR(bssid));
1853 res = wpas_send_action_work(wpa_s, freq, dst, src, bssid, buf,
1854 len, wait_time);
1855 if (res == 0 && scheduled)
1856 *scheduled = 1;
1857 return res;
1858 }
1859
1860 wpa_printf(MSG_DEBUG, "P2P: Use ongoing radio work for Action frame TX");
1861 return offchannel_send_action(wpa_s, freq, dst, src, bssid, buf, len,
1862 wait_time,
1863 wpas_p2p_send_action_tx_status, 1);
1864 }
1865
1866
wpas_send_action_done(void * ctx)1867 static void wpas_send_action_done(void *ctx)
1868 {
1869 struct wpa_supplicant *wpa_s = ctx;
1870
1871 if (wpa_s->p2p_send_action_work) {
1872 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
1873 wpa_s, NULL);
1874 os_free(wpa_s->p2p_send_action_work->ctx);
1875 radio_work_done(wpa_s->p2p_send_action_work);
1876 wpa_s->p2p_send_action_work = NULL;
1877 }
1878
1879 offchannel_send_action_done(wpa_s);
1880 }
1881
1882
1883 #ifdef CONFIG_PASN
1884
1885 struct wpa_p2p_pasn_auth_work {
1886 u8 peer_addr[ETH_ALEN];
1887 int freq;
1888 bool verify;
1889 int force_freq;
1890 int pref_freq;
1891 enum p2p_invite_role role;
1892 u8 *ssid;
1893 size_t ssid_len;
1894 u8 bssid[ETH_ALEN];
1895 u8 go_dev_addr[ETH_ALEN];
1896 };
1897
1898
wpas_p2p_pasn_free_auth_work(struct wpa_p2p_pasn_auth_work * awork)1899 static void wpas_p2p_pasn_free_auth_work(struct wpa_p2p_pasn_auth_work *awork)
1900 {
1901 if (!awork)
1902 return;
1903 os_free(awork->ssid);
1904 os_free(awork);
1905 }
1906
1907
wpas_p2p_pasn_cancel_auth_work(struct wpa_supplicant * wpa_s)1908 static void wpas_p2p_pasn_cancel_auth_work(struct wpa_supplicant *wpa_s)
1909 {
1910 wpa_printf(MSG_DEBUG, "P2P PASN: Cancel p2p-pasn-start-auth work");
1911
1912 /* Remove pending/started work */
1913 radio_remove_works(wpa_s, "p2p-pasn-start-auth", 0);
1914 }
1915
1916
wpas_p2p_pasn_auth_start_cb(struct wpa_radio_work * work,int deinit)1917 static void wpas_p2p_pasn_auth_start_cb(struct wpa_radio_work *work, int deinit)
1918 {
1919 int ret;
1920 struct wpa_supplicant *wpa_s = work->wpa_s;
1921 struct wpa_p2p_pasn_auth_work *awork = work->ctx;
1922 struct p2p_data *p2p = wpa_s->global->p2p;
1923 const u8 *peer_addr = NULL;
1924 const u8 *bssid = NULL;
1925 const u8 *go_dev_addr = NULL;
1926
1927 if (deinit) {
1928 if (!work->started) {
1929 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1930 wpa_s->p2pdev, NULL);
1931 }
1932 wpas_p2p_pasn_free_auth_work(awork);
1933 return;
1934 }
1935
1936 if (!is_zero_ether_addr(awork->peer_addr))
1937 peer_addr = awork->peer_addr;
1938 if (!is_zero_ether_addr(awork->bssid))
1939 bssid = awork->bssid;
1940 if (!is_zero_ether_addr(awork->go_dev_addr))
1941 go_dev_addr = awork->go_dev_addr;
1942
1943
1944 if (awork->verify)
1945 ret = p2p_initiate_pasn_verify(p2p, peer_addr, awork->freq,
1946 awork->role, bssid, awork->ssid,
1947 awork->ssid_len,
1948 awork->force_freq, go_dev_addr,
1949 awork->pref_freq);
1950 else
1951 ret = p2p_initiate_pasn_auth(p2p, peer_addr, awork->freq);
1952
1953 if (ret) {
1954 wpa_printf(MSG_DEBUG,
1955 "P2P PASN: Failed to start PASN authentication");
1956 goto fail;
1957 }
1958 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1959 wpa_s->p2pdev, NULL);
1960 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
1961 wpas_p2p_group_formation_timeout,
1962 wpa_s->p2pdev, NULL);
1963 wpa_s->p2p_pasn_auth_work = work;
1964 return;
1965
1966 fail:
1967 wpas_p2p_pasn_free_auth_work(awork);
1968 work->ctx = NULL;
1969 radio_work_done(work);
1970 }
1971
1972
wpas_p2p_initiate_pasn_auth(struct wpa_supplicant * wpa_s,const u8 * peer_addr,int freq)1973 static int wpas_p2p_initiate_pasn_auth(struct wpa_supplicant *wpa_s,
1974 const u8 *peer_addr, int freq)
1975 {
1976 struct wpa_p2p_pasn_auth_work *awork;
1977
1978 wpas_p2p_pasn_cancel_auth_work(wpa_s);
1979 wpa_s->p2p_pasn_auth_work = NULL;
1980
1981 awork = os_zalloc(sizeof(*awork));
1982 if (!awork)
1983 return -1;
1984
1985 awork->freq = freq;
1986 os_memcpy(awork->peer_addr, peer_addr, ETH_ALEN);
1987
1988 if (radio_add_work(wpa_s, freq, "p2p-pasn-start-auth", 1,
1989 wpas_p2p_pasn_auth_start_cb, awork) < 0) {
1990 wpas_p2p_pasn_free_auth_work(awork);
1991 return -1;
1992 }
1993
1994 wpa_printf(MSG_DEBUG,
1995 "P2P PASN: Authentication work successfully added");
1996 return 0;
1997 }
1998
1999 #endif /* CONFIG_PASN */
2000
2001
wpas_copy_go_neg_results(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * params)2002 static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s,
2003 struct p2p_go_neg_results *params)
2004 {
2005 if (wpa_s->go_params == NULL) {
2006 wpa_s->go_params = os_malloc(sizeof(*params));
2007 if (wpa_s->go_params == NULL)
2008 return -1;
2009 }
2010 os_memcpy(wpa_s->go_params, params, sizeof(*params));
2011 return 0;
2012 }
2013
2014
wpas_start_gc(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * res)2015 static void wpas_start_gc(struct wpa_supplicant *wpa_s,
2016 struct p2p_go_neg_results *res)
2017 {
2018 struct os_reltime now;
2019 struct wpa_ssid *ssid;
2020 struct rsn_pmksa_cache_entry *entry;
2021
2022 if (!res->ssid_len) {
2023 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: SSID info not present");
2024 return;
2025 }
2026
2027 wpa_s->group_formation_reported = 0;
2028 wpa_printf(MSG_DEBUG, "P2P: Start connect for peer " MACSTR
2029 " dev_addr " MACSTR,
2030 MAC2STR(res->peer_interface_addr),
2031 MAC2STR(res->peer_device_addr));
2032 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Start connect for SSID",
2033 res->ssid, res->ssid_len);
2034 wpa_supplicant_ap_deinit(wpa_s);
2035 wpas_copy_go_neg_results(wpa_s, res);
2036
2037 ssid = wpa_config_add_network(wpa_s->conf);
2038 if (!ssid) {
2039 wpa_dbg(wpa_s, MSG_DEBUG,
2040 "P2P: Could not add network for client");
2041 return;
2042 }
2043 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
2044 wpa_config_set_network_defaults(ssid);
2045 ssid->temporary = 1;
2046 ssid->p2p_group = 1;
2047
2048 ssid->ssid = os_memdup(res->ssid, res->ssid_len);
2049 if (!ssid->ssid)
2050 return;
2051 ssid->ssid_len = res->ssid_len;
2052
2053 os_memcpy(ssid->bssid, res->peer_interface_addr, ETH_ALEN);
2054
2055 if (res->akmp == WPA_KEY_MGMT_PASN && res->sae_password[0]) {
2056 ssid->auth_alg = WPA_AUTH_ALG_SAE;
2057 ssid->sae_password = os_strdup(res->sae_password);
2058 if (!ssid->sae_password)
2059 return;
2060 } else if (res->akmp == WPA_KEY_MGMT_SAE && res->pmk_len) {
2061 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
2062 entry = os_zalloc(sizeof(*entry));
2063 if (!entry)
2064 return;
2065 os_memcpy(entry->aa, res->peer_interface_addr, ETH_ALEN);
2066 os_memcpy(entry->pmkid, res->pmkid, PMKID_LEN);
2067 entry->pmk_len = res->pmk_len;
2068 os_memcpy(entry->pmk, res->pmk, res->pmk_len);
2069 entry->akmp = res->akmp;
2070 os_get_reltime(&now);
2071 entry->expiration = now.sec + 43200;
2072 entry->reauth_time = now.sec + 43200 * 70 / 100;
2073 entry->network_ctx = ssid;
2074 os_memcpy(entry->spa, wpa_s->own_addr, ETH_ALEN);
2075
2076 wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry);
2077 ssid->pmk_valid = true;
2078 } else if (res->akmp == WPA_KEY_MGMT_SAE && res->sae_password[0]) {
2079 ssid->auth_alg = WPA_AUTH_ALG_SAE;
2080 ssid->sae_password = os_strdup(res->sae_password);
2081 if (!ssid->sae_password)
2082 return;
2083 }
2084
2085 if (res->psk_set) {
2086 os_memcpy(ssid->psk, res->psk, 32);
2087 ssid->psk_set = 1;
2088 }
2089 ssid->proto = WPA_PROTO_RSN;
2090 ssid->key_mgmt = WPA_KEY_MGMT_SAE;
2091 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
2092 ssid->group_cipher = WPA_CIPHER_CCMP;
2093 if (res->cipher)
2094 ssid->pairwise_cipher |= res->cipher;
2095 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
2096 ssid->ieee80211w = MGMT_FRAME_PROTECTION_REQUIRED;
2097 ssid->disabled = 0;
2098 wpa_s->show_group_started = 1;
2099 wpa_s->p2p_in_invitation = 1;
2100 wpa_s->p2p_go_group_formation_completed = 0;
2101 wpa_s->global->p2p_group_formation = wpa_s;
2102 ssid->rsn_overriding = RSN_OVERRIDING_ENABLED;
2103
2104 wpa_s->current_ssid = ssid;
2105 wpa_supplicant_update_scan_results(wpa_s, res->peer_interface_addr);
2106 wpa_supplicant_select_network(wpa_s, ssid);
2107 }
2108
2109
wpas_start_wps_enrollee(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * res)2110 static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s,
2111 struct p2p_go_neg_results *res)
2112 {
2113 wpa_s->group_formation_reported = 0;
2114 wpa_printf(MSG_DEBUG, "P2P: Start WPS Enrollee for peer " MACSTR
2115 " dev_addr " MACSTR " wps_method %d",
2116 MAC2STR(res->peer_interface_addr),
2117 MAC2STR(res->peer_device_addr), res->wps_method);
2118 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Start WPS Enrollee for SSID",
2119 res->ssid, res->ssid_len);
2120 wpa_supplicant_ap_deinit(wpa_s);
2121 wpas_copy_go_neg_results(wpa_s, res);
2122 if (res->wps_method == WPS_PBC) {
2123 wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1, 0);
2124 #ifdef CONFIG_WPS_NFC
2125 } else if (res->wps_method == WPS_NFC) {
2126 wpas_wps_start_nfc(wpa_s, res->peer_device_addr,
2127 res->peer_interface_addr,
2128 wpa_s->p2pdev->p2p_oob_dev_pw,
2129 wpa_s->p2pdev->p2p_oob_dev_pw_id, 1,
2130 wpa_s->p2pdev->p2p_oob_dev_pw_id ==
2131 DEV_PW_NFC_CONNECTION_HANDOVER ?
2132 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash :
2133 NULL,
2134 NULL, 0, 0);
2135 #endif /* CONFIG_WPS_NFC */
2136 } else {
2137 u16 dev_pw_id = DEV_PW_DEFAULT;
2138 if (wpa_s->p2p_wps_method == WPS_P2PS)
2139 dev_pw_id = DEV_PW_P2PS_DEFAULT;
2140 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
2141 dev_pw_id = DEV_PW_REGISTRAR_SPECIFIED;
2142 wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
2143 wpa_s->p2p_pin, 1, dev_pw_id);
2144 }
2145 }
2146
2147
wpas_p2p_add_psk_list(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)2148 static void wpas_p2p_add_psk_list(struct wpa_supplicant *wpa_s,
2149 struct wpa_ssid *ssid)
2150 {
2151 struct wpa_ssid *persistent;
2152 struct psk_list_entry *psk;
2153 struct hostapd_data *hapd;
2154
2155 if (!wpa_s->ap_iface)
2156 return;
2157
2158 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, NULL, ssid->ssid,
2159 ssid->ssid_len);
2160 if (persistent == NULL)
2161 return;
2162
2163 hapd = wpa_s->ap_iface->bss[0];
2164
2165 dl_list_for_each(psk, &persistent->psk_list, struct psk_list_entry,
2166 list) {
2167 struct hostapd_wpa_psk *hpsk;
2168
2169 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add persistent group PSK entry for "
2170 MACSTR " psk=%d",
2171 MAC2STR(psk->addr), psk->p2p);
2172 hpsk = os_zalloc(sizeof(*hpsk));
2173 if (hpsk == NULL)
2174 break;
2175 os_memcpy(hpsk->psk, psk->psk, PMK_LEN);
2176 if (psk->p2p)
2177 os_memcpy(hpsk->p2p_dev_addr, psk->addr, ETH_ALEN);
2178 else
2179 os_memcpy(hpsk->addr, psk->addr, ETH_ALEN);
2180 hpsk->next = hapd->conf->ssid.wpa_psk;
2181 hapd->conf->ssid.wpa_psk = hpsk;
2182 }
2183 }
2184
2185
p2p_go_dump_common_freqs(struct wpa_supplicant * wpa_s)2186 static void p2p_go_dump_common_freqs(struct wpa_supplicant *wpa_s)
2187 {
2188 char buf[20 + P2P_MAX_CHANNELS * 6];
2189 char *pos, *end;
2190 unsigned int i;
2191 int res;
2192
2193 pos = buf;
2194 end = pos + sizeof(buf);
2195 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
2196 res = os_snprintf(pos, end - pos, " %d",
2197 wpa_s->p2p_group_common_freqs[i]);
2198 if (os_snprintf_error(end - pos, res))
2199 break;
2200 pos += res;
2201 }
2202 *pos = '\0';
2203
2204 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Common group frequencies:%s", buf);
2205 }
2206
2207
p2p_go_save_group_common_freqs(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * params)2208 static void p2p_go_save_group_common_freqs(struct wpa_supplicant *wpa_s,
2209 struct p2p_go_neg_results *params)
2210 {
2211 unsigned int i, len = int_array_len(wpa_s->go_params->freq_list);
2212
2213 wpa_s->p2p_group_common_freqs_num = 0;
2214 os_free(wpa_s->p2p_group_common_freqs);
2215 wpa_s->p2p_group_common_freqs = os_calloc(len, sizeof(int));
2216 if (!wpa_s->p2p_group_common_freqs)
2217 return;
2218
2219 for (i = 0; i < len; i++) {
2220 if (!wpa_s->go_params->freq_list[i])
2221 break;
2222 wpa_s->p2p_group_common_freqs[i] =
2223 wpa_s->go_params->freq_list[i];
2224 }
2225 wpa_s->p2p_group_common_freqs_num = i;
2226 }
2227
2228
p2p_config_write(struct wpa_supplicant * wpa_s)2229 static void p2p_config_write(struct wpa_supplicant *wpa_s)
2230 {
2231 #ifndef CONFIG_NO_CONFIG_WRITE
2232 if (wpa_s->p2pdev->conf->update_config &&
2233 wpa_config_write(wpa_s->p2pdev->confname, wpa_s->p2pdev->conf))
2234 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
2235 #endif /* CONFIG_NO_CONFIG_WRITE */
2236 }
2237
2238
p2p_go_configured(void * ctx,void * data)2239 static void p2p_go_configured(void *ctx, void *data)
2240 {
2241 struct wpa_supplicant *wpa_s = ctx;
2242 struct p2p_go_neg_results *params = data;
2243 struct wpa_ssid *ssid;
2244
2245 wpa_s->ap_configured_cb = NULL;
2246 wpa_s->ap_configured_cb_ctx = NULL;
2247 wpa_s->ap_configured_cb_data = NULL;
2248 if (!wpa_s->go_params) {
2249 wpa_printf(MSG_ERROR,
2250 "P2P: p2p_go_configured() called with wpa_s->go_params == NULL");
2251 return;
2252 }
2253
2254 if (wpa_s->ap_iface && params->p2p2 &&
2255 params->akmp == WPA_KEY_MGMT_SAE) {
2256 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
2257
2258 wpa_auth_pmksa_add_sae(hapd->wpa_auth,
2259 params->peer_device_addr,
2260 params->pmk, params->pmk_len,
2261 params->pmkid, WPA_KEY_MGMT_SAE,
2262 false);
2263 hostapd_add_pmkid(hapd, params->peer_device_addr,
2264 params->pmk, params->pmk_len,
2265 params->pmkid, WPA_KEY_MGMT_SAE);
2266 }
2267
2268 p2p_go_save_group_common_freqs(wpa_s, params);
2269 p2p_go_dump_common_freqs(wpa_s);
2270
2271 ssid = wpa_s->current_ssid;
2272 if (ssid && ssid->mode == WPAS_MODE_P2P_GO) {
2273 wpa_printf(MSG_DEBUG, "P2P: Group setup without provisioning");
2274 if (wpa_s->global->p2p_group_formation == wpa_s)
2275 wpa_s->global->p2p_group_formation = NULL;
2276 wpas_p2p_group_started(wpa_s, 1, ssid, ssid->frequency,
2277 params->passphrase[0] == '\0' ?
2278 params->psk : NULL,
2279 params->passphrase,
2280 wpa_s->global->p2p_dev_addr,
2281 params->persistent_group, "");
2282 wpa_s->group_formation_reported = 1;
2283
2284 if (wpa_s->p2pdev->p2ps_method_config_any) {
2285 if (is_zero_ether_addr(wpa_s->p2pdev->p2ps_join_addr)) {
2286 wpa_dbg(wpa_s, MSG_DEBUG,
2287 "P2PS: Setting default PIN for ANY");
2288 wpa_supplicant_ap_wps_pin(wpa_s, NULL,
2289 "12345670", NULL, 0,
2290 0);
2291 } else {
2292 wpa_dbg(wpa_s, MSG_DEBUG,
2293 "P2PS: Setting default PIN for " MACSTR,
2294 MAC2STR(wpa_s->p2pdev->p2ps_join_addr));
2295 wpa_supplicant_ap_wps_pin(
2296 wpa_s, wpa_s->p2pdev->p2ps_join_addr,
2297 "12345670", NULL, 0, 0);
2298 }
2299 wpa_s->p2pdev->p2ps_method_config_any = 0;
2300 }
2301
2302 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
2303 if (params->persistent_group) {
2304 wpas_p2p_store_persistent_group(
2305 wpa_s->p2pdev, ssid,
2306 wpa_s->global->p2p_dev_addr, 0);
2307 wpas_p2p_add_psk_list(wpa_s, ssid);
2308 }
2309
2310 wpas_notify_p2p_group_started(wpa_s, ssid,
2311 params->persistent_group, 0,
2312 NULL);
2313 wpas_p2p_cross_connect_setup(wpa_s);
2314 wpas_p2p_set_group_idle_timeout(wpa_s);
2315
2316 if (wpa_s->p2p_first_connection_timeout) {
2317 wpa_dbg(wpa_s, MSG_DEBUG,
2318 "P2P: Start group formation timeout of %d seconds until first data connection on GO",
2319 wpa_s->p2p_first_connection_timeout);
2320 wpa_s->p2p_go_group_formation_completed = 0;
2321 wpa_s->global->p2p_group_formation = wpa_s;
2322 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
2323 wpa_s->p2pdev, NULL);
2324 eloop_register_timeout(
2325 wpa_s->p2p_first_connection_timeout, 0,
2326 wpas_p2p_group_formation_timeout,
2327 wpa_s->p2pdev, NULL);
2328 }
2329
2330 return;
2331 }
2332
2333 if (wpa_supplicant_ap_mac_addr_filter(wpa_s,
2334 params->peer_interface_addr)) {
2335 wpa_printf(MSG_DEBUG, "P2P: Failed to setup MAC address "
2336 "filtering");
2337 return;
2338 }
2339
2340 if (params->p2p2) {
2341 wpas_group_formation_completed(wpa_s, 0, NULL);
2342 wpa_printf(MSG_DEBUG,
2343 "P2P2: Group formation completed - first connection in progress");
2344 goto out;
2345 }
2346
2347 wpa_printf(MSG_DEBUG, "P2P: Setting up WPS for GO provisioning");
2348 if (params->wps_method == WPS_PBC) {
2349 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr,
2350 params->peer_device_addr);
2351 #ifdef CONFIG_WPS_NFC
2352 } else if (params->wps_method == WPS_NFC) {
2353 if (wpa_s->p2pdev->p2p_oob_dev_pw_id !=
2354 DEV_PW_NFC_CONNECTION_HANDOVER &&
2355 !wpa_s->p2pdev->p2p_oob_dev_pw) {
2356 wpa_printf(MSG_DEBUG, "P2P: No NFC Dev Pw known");
2357 return;
2358 }
2359 wpas_ap_wps_add_nfc_pw(
2360 wpa_s, wpa_s->p2pdev->p2p_oob_dev_pw_id,
2361 wpa_s->p2pdev->p2p_oob_dev_pw,
2362 wpa_s->p2pdev->p2p_peer_oob_pk_hash_known ?
2363 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash : NULL);
2364 #endif /* CONFIG_WPS_NFC */
2365 } else if (wpa_s->p2p_pin[0])
2366 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
2367 wpa_s->p2p_pin, NULL, 0, 0);
2368 out:
2369 os_free(wpa_s->go_params);
2370 wpa_s->go_params = NULL;
2371 }
2372
2373
2374 /**
2375 * wpas_p2p_freq_to_edmg_channel - Convert frequency into EDMG channel
2376 * @freq: Frequency (MHz) to convert
2377 * @op_class: Buffer for returning operating class
2378 * @op_edmg_channel: Buffer for returning channel number
2379 * Returns: 0 on success, -1 on failure
2380 *
2381 * This can be used to find the highest channel bonding which includes the
2382 * specified frequency.
2383 */
wpas_p2p_freq_to_edmg_channel(struct wpa_supplicant * wpa_s,unsigned int freq,u8 * op_class,u8 * op_edmg_channel)2384 static int wpas_p2p_freq_to_edmg_channel(struct wpa_supplicant *wpa_s,
2385 unsigned int freq,
2386 u8 *op_class, u8 *op_edmg_channel)
2387 {
2388 struct hostapd_hw_modes *hwmode;
2389 struct ieee80211_edmg_config edmg;
2390 unsigned int i;
2391 enum chan_width chanwidth[] = {
2392 CHAN_WIDTH_8640,
2393 CHAN_WIDTH_6480,
2394 CHAN_WIDTH_4320,
2395 };
2396
2397 if (!wpa_s->hw.modes)
2398 return -1;
2399
2400 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
2401 HOSTAPD_MODE_IEEE80211AD, false);
2402 if (!hwmode) {
2403 wpa_printf(MSG_ERROR,
2404 "Unsupported AP mode: HOSTAPD_MODE_IEEE80211AD");
2405 return -1;
2406 }
2407
2408 /* Find the highest EDMG channel bandwidth to start the P2P GO */
2409 for (i = 0; i < ARRAY_SIZE(chanwidth); i++) {
2410 if (ieee80211_chaninfo_to_channel(freq, chanwidth[i], 0,
2411 op_class,
2412 op_edmg_channel) < 0)
2413 continue;
2414
2415 hostapd_encode_edmg_chan(1, *op_edmg_channel, 0, &edmg);
2416 if (edmg.channels &&
2417 ieee802_edmg_is_allowed(hwmode->edmg, edmg)) {
2418 wpa_printf(MSG_DEBUG,
2419 "Freq %u to EDMG channel %u at opclass %u",
2420 freq, *op_edmg_channel, *op_class);
2421 return 0;
2422 }
2423 }
2424
2425 return -1;
2426 }
2427
2428
wpas_p2p_try_edmg_channel(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * params)2429 int wpas_p2p_try_edmg_channel(struct wpa_supplicant *wpa_s,
2430 struct p2p_go_neg_results *params)
2431 {
2432 u8 op_channel, op_class;
2433 int freq;
2434
2435 /* Try social channel as primary channel frequency */
2436 freq = (!params->freq) ? 58320 + 1 * 2160 : params->freq;
2437
2438 if (wpas_p2p_freq_to_edmg_channel(wpa_s, freq, &op_class,
2439 &op_channel) == 0) {
2440 wpa_printf(MSG_DEBUG,
2441 "Freq %d will be used to set an EDMG connection (channel=%u opclass=%u)",
2442 freq, op_channel, op_class);
2443 params->freq = freq;
2444 return 0;
2445 }
2446
2447 return -1;
2448 }
2449
2450
wpas_start_go(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * params,int group_formation,enum wpa_p2p_mode p2p_mode)2451 static void wpas_start_go(struct wpa_supplicant *wpa_s,
2452 struct p2p_go_neg_results *params,
2453 int group_formation, enum wpa_p2p_mode p2p_mode)
2454 {
2455 struct wpa_ssid *ssid;
2456
2457 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Starting GO");
2458 if (wpas_copy_go_neg_results(wpa_s, params) < 0) {
2459 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not copy GO Negotiation "
2460 "results");
2461 return;
2462 }
2463
2464 ssid = wpa_config_add_network(wpa_s->conf);
2465 if (ssid == NULL) {
2466 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not add network for GO");
2467 return;
2468 }
2469
2470 wpa_s->show_group_started = 0;
2471 wpa_s->p2p_go_group_formation_completed = 0;
2472 wpa_s->group_formation_reported = 0;
2473 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
2474
2475 wpa_config_set_network_defaults(ssid);
2476 ssid->temporary = 1;
2477 ssid->p2p_group = 1;
2478 ssid->p2p_persistent_group = !!params->persistent_group;
2479 ssid->mode = group_formation ? WPAS_MODE_P2P_GROUP_FORMATION :
2480 WPAS_MODE_P2P_GO;
2481 ssid->frequency = params->freq;
2482 ssid->ht40 = params->ht40;
2483 ssid->vht = params->vht;
2484 ssid->max_oper_chwidth = params->max_oper_chwidth;
2485 ssid->vht_center_freq2 = params->vht_center_freq2;
2486 ssid->he = params->he;
2487 if (params->edmg) {
2488 u8 op_channel, op_class;
2489
2490 if (!wpas_p2p_freq_to_edmg_channel(wpa_s, params->freq,
2491 &op_class, &op_channel)) {
2492 ssid->edmg_channel = op_channel;
2493 ssid->enable_edmg = params->edmg;
2494 } else {
2495 wpa_dbg(wpa_s, MSG_DEBUG,
2496 "P2P: Could not match EDMG channel, freq %d, for GO",
2497 params->freq);
2498 }
2499 }
2500
2501 ssid->ssid = os_zalloc(params->ssid_len + 1);
2502 if (ssid->ssid) {
2503 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
2504 ssid->ssid_len = params->ssid_len;
2505 }
2506 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
2507 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
2508 if (is_6ghz_freq(ssid->frequency) &&
2509 is_p2p_6ghz_capable(wpa_s->global->p2p)) {
2510 ssid->auth_alg |= WPA_AUTH_ALG_SAE;
2511 ssid->key_mgmt = WPA_KEY_MGMT_SAE;
2512 ssid->ieee80211w = MGMT_FRAME_PROTECTION_REQUIRED;
2513 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
2514 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use SAE auth_alg and key_mgmt");
2515 } else {
2516 p2p_set_6ghz_dev_capab(wpa_s->global->p2p, false);
2517 }
2518 ssid->proto = WPA_PROTO_RSN;
2519 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
2520 ssid->group_cipher = WPA_CIPHER_CCMP;
2521 if (params->freq > 56160) {
2522 /*
2523 * Enable GCMP instead of CCMP as pairwise_cipher and
2524 * group_cipher in 60 GHz.
2525 */
2526 ssid->pairwise_cipher = WPA_CIPHER_GCMP;
2527 ssid->group_cipher = WPA_CIPHER_GCMP;
2528 /* P2P GO in 60 GHz is always a PCP (PBSS) */
2529 ssid->pbss = 1;
2530 }
2531 if (os_strlen(params->passphrase) > 0) {
2532 ssid->passphrase = os_strdup(params->passphrase);
2533 if (ssid->passphrase == NULL) {
2534 wpa_msg_global(wpa_s, MSG_ERROR,
2535 "P2P: Failed to copy passphrase for GO");
2536 wpa_config_remove_network(wpa_s->conf, ssid->id);
2537 return;
2538 }
2539 } else
2540 ssid->passphrase = NULL;
2541 ssid->psk_set = params->psk_set;
2542 if (ssid->psk_set)
2543 os_memcpy(ssid->psk, params->psk, sizeof(ssid->psk));
2544 else if (ssid->passphrase)
2545 wpa_config_update_psk(ssid);
2546 ssid->ap_max_inactivity = wpa_s->p2pdev->conf->p2p_go_max_inactivity;
2547
2548 ssid->p2p_mode = p2p_mode;
2549 if (params->p2p2) {
2550 if (params->akmp == WPA_KEY_MGMT_SAE)
2551 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
2552 else
2553 ssid->auth_alg |= WPA_AUTH_ALG_SAE;
2554
2555 ssid->key_mgmt = WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_PASN;
2556 ssid->sae_password = os_strdup(params->sae_password);
2557 /* In PCC, RSNE indicates PMF to be disabled while RSNOE/RSNO2E
2558 * requires PMF for SAE. */
2559 if (ssid->p2p_mode != WPA_P2P_MODE_WFD_PCC)
2560 ssid->ieee80211w = MGMT_FRAME_PROTECTION_REQUIRED;
2561 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
2562 if (params->cipher)
2563 ssid->pairwise_cipher |= params->cipher;
2564 }
2565
2566 wpa_s->ap_configured_cb = p2p_go_configured;
2567 wpa_s->ap_configured_cb_ctx = wpa_s;
2568 wpa_s->ap_configured_cb_data = wpa_s->go_params;
2569 wpa_s->scan_req = NORMAL_SCAN_REQ;
2570 wpa_s->connect_without_scan = ssid;
2571 wpa_s->reassociate = 1;
2572 wpa_s->disconnected = 0;
2573 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Request scan (that will be skipped) to "
2574 "start GO)");
2575 wpa_supplicant_req_scan(wpa_s, 0, 0);
2576 }
2577
2578
wpas_p2p_clone_config(struct wpa_supplicant * dst,const struct wpa_supplicant * src)2579 static void wpas_p2p_clone_config(struct wpa_supplicant *dst,
2580 const struct wpa_supplicant *src)
2581 {
2582 struct wpa_config *d;
2583 const struct wpa_config *s;
2584
2585 d = dst->conf;
2586 s = src->conf;
2587
2588 #define C(n) \
2589 do { \
2590 if (s->n && !d->n) \
2591 d->n = os_strdup(s->n); \
2592 } while (0)
2593
2594 C(device_name);
2595 C(manufacturer);
2596 C(model_name);
2597 C(model_number);
2598 C(serial_number);
2599 C(config_methods);
2600 #undef C
2601
2602 os_memcpy(d->device_type, s->device_type, WPS_DEV_TYPE_LEN);
2603 os_memcpy(d->sec_device_type, s->sec_device_type,
2604 sizeof(d->sec_device_type));
2605 d->num_sec_device_types = s->num_sec_device_types;
2606
2607 d->p2p_group_idle = s->p2p_group_idle;
2608 d->p2p_go_freq_change_policy = s->p2p_go_freq_change_policy;
2609 d->p2p_intra_bss = s->p2p_intra_bss;
2610 d->persistent_reconnect = s->persistent_reconnect;
2611 d->max_num_sta = s->max_num_sta;
2612 d->pbc_in_m1 = s->pbc_in_m1;
2613 d->ignore_old_scan_res = s->ignore_old_scan_res;
2614 d->beacon_int = s->beacon_int;
2615 d->dtim_period = s->dtim_period;
2616 d->p2p_go_ctwindow = s->p2p_go_ctwindow;
2617 d->disassoc_low_ack = s->disassoc_low_ack;
2618 d->disable_scan_offload = s->disable_scan_offload;
2619 d->passive_scan = s->passive_scan;
2620 d->pmf = s->pmf;
2621 d->p2p_6ghz_disable = s->p2p_6ghz_disable;
2622 d->sae_pwe = s->sae_pwe;
2623
2624 if (s->wps_nfc_dh_privkey && s->wps_nfc_dh_pubkey &&
2625 !d->wps_nfc_pw_from_config) {
2626 wpabuf_free(d->wps_nfc_dh_privkey);
2627 wpabuf_free(d->wps_nfc_dh_pubkey);
2628 d->wps_nfc_dh_privkey = wpabuf_dup(s->wps_nfc_dh_privkey);
2629 d->wps_nfc_dh_pubkey = wpabuf_dup(s->wps_nfc_dh_pubkey);
2630 }
2631 d->p2p_cli_probe = s->p2p_cli_probe;
2632 d->go_interworking = s->go_interworking;
2633 d->go_access_network_type = s->go_access_network_type;
2634 d->go_internet = s->go_internet;
2635 d->go_venue_group = s->go_venue_group;
2636 d->go_venue_type = s->go_venue_type;
2637 d->p2p_add_cli_chan = s->p2p_add_cli_chan;
2638 }
2639
2640
wpas_p2p_get_group_ifname(struct wpa_supplicant * wpa_s,char * ifname,size_t len)2641 static void wpas_p2p_get_group_ifname(struct wpa_supplicant *wpa_s,
2642 char *ifname, size_t len)
2643 {
2644 char *ifname_ptr = wpa_s->ifname;
2645
2646 if (os_strncmp(wpa_s->ifname, P2P_MGMT_DEVICE_PREFIX,
2647 os_strlen(P2P_MGMT_DEVICE_PREFIX)) == 0) {
2648 ifname_ptr = os_strrchr(wpa_s->ifname, '-') + 1;
2649 }
2650
2651 os_snprintf(ifname, len, "p2p-%s-%d", ifname_ptr, wpa_s->p2p_group_idx);
2652 if (os_strlen(ifname) >= IFNAMSIZ &&
2653 os_strlen(wpa_s->ifname) < IFNAMSIZ) {
2654 int res;
2655
2656 /* Try to avoid going over the IFNAMSIZ length limit */
2657 res = os_snprintf(ifname, len, "p2p-%d", wpa_s->p2p_group_idx);
2658 if (os_snprintf_error(len, res) && len)
2659 ifname[len - 1] = '\0';
2660 }
2661 }
2662
2663
wpas_p2p_add_group_interface(struct wpa_supplicant * wpa_s,enum wpa_driver_if_type type)2664 static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
2665 enum wpa_driver_if_type type)
2666 {
2667 char ifname[120], force_ifname[120];
2668
2669 if (wpa_s->pending_interface_name[0]) {
2670 wpa_printf(MSG_DEBUG, "P2P: Pending virtual interface exists "
2671 "- skip creation of a new one");
2672 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
2673 wpa_printf(MSG_DEBUG, "P2P: Pending virtual address "
2674 "unknown?! ifname='%s'",
2675 wpa_s->pending_interface_name);
2676 return -1;
2677 }
2678 return 0;
2679 }
2680
2681 wpas_p2p_get_group_ifname(wpa_s, ifname, sizeof(ifname));
2682 force_ifname[0] = '\0';
2683
2684 wpa_printf(MSG_DEBUG, "P2P: Create a new interface %s for the group",
2685 ifname);
2686 wpa_s->p2p_group_idx++;
2687
2688 wpa_s->pending_interface_type = type;
2689 if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname,
2690 wpa_s->pending_interface_addr, NULL) < 0) {
2691 wpa_printf(MSG_ERROR, "P2P: Failed to create new group "
2692 "interface");
2693 return -1;
2694 }
2695
2696 if (wpa_s->conf->p2p_interface_random_mac_addr) {
2697 random_mac_addr(wpa_s->pending_interface_addr);
2698 wpa_printf(MSG_DEBUG, "P2P: Generate random MAC address " MACSTR
2699 " for the group",
2700 MAC2STR(wpa_s->pending_interface_addr));
2701 }
2702
2703 if (force_ifname[0]) {
2704 wpa_printf(MSG_DEBUG, "P2P: Driver forced interface name %s",
2705 force_ifname);
2706 os_strlcpy(wpa_s->pending_interface_name, force_ifname,
2707 sizeof(wpa_s->pending_interface_name));
2708 } else
2709 os_strlcpy(wpa_s->pending_interface_name, ifname,
2710 sizeof(wpa_s->pending_interface_name));
2711 wpa_printf(MSG_DEBUG, "P2P: Created pending virtual interface %s addr "
2712 MACSTR, wpa_s->pending_interface_name,
2713 MAC2STR(wpa_s->pending_interface_addr));
2714
2715 return 0;
2716 }
2717
2718
wpas_p2p_remove_pending_group_interface(struct wpa_supplicant * wpa_s)2719 static void wpas_p2p_remove_pending_group_interface(
2720 struct wpa_supplicant *wpa_s)
2721 {
2722 if (!wpa_s->pending_interface_name[0] ||
2723 is_zero_ether_addr(wpa_s->pending_interface_addr))
2724 return; /* No pending virtual interface */
2725
2726 wpa_printf(MSG_DEBUG, "P2P: Removing pending group interface %s",
2727 wpa_s->pending_interface_name);
2728 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
2729 wpa_s->pending_interface_name);
2730 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
2731 wpa_s->pending_interface_name[0] = '\0';
2732 wpa_s->global->pending_group_iface_for_p2ps = 0;
2733 }
2734
2735
2736 static struct wpa_supplicant *
wpas_p2p_init_group_interface(struct wpa_supplicant * wpa_s,int go)2737 wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go)
2738 {
2739 struct wpa_interface iface;
2740 struct wpa_supplicant *group_wpa_s;
2741
2742 if (!wpa_s->pending_interface_name[0]) {
2743 wpa_printf(MSG_ERROR, "P2P: No pending group interface");
2744 if (!wpas_p2p_create_iface(wpa_s))
2745 return NULL;
2746 /*
2747 * Something has forced us to remove the pending interface; try
2748 * to create a new one and hope for the best that we will get
2749 * the same local address.
2750 */
2751 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
2752 WPA_IF_P2P_CLIENT) < 0)
2753 return NULL;
2754 }
2755
2756 os_memset(&iface, 0, sizeof(iface));
2757 iface.ifname = wpa_s->pending_interface_name;
2758 iface.driver = wpa_s->driver->name;
2759 if (wpa_s->conf->ctrl_interface == NULL &&
2760 wpa_s->parent != wpa_s &&
2761 wpa_s->p2p_mgmt &&
2762 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE))
2763 iface.ctrl_interface = wpa_s->parent->conf->ctrl_interface;
2764 else
2765 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
2766 iface.driver_param = wpa_s->conf->driver_param;
2767 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface, wpa_s);
2768 if (group_wpa_s == NULL) {
2769 wpa_printf(MSG_ERROR, "P2P: Failed to create new "
2770 "wpa_supplicant interface");
2771 return NULL;
2772 }
2773 wpa_s->pending_interface_name[0] = '\0';
2774 group_wpa_s->p2p_group_interface = go ? P2P_GROUP_INTERFACE_GO :
2775 P2P_GROUP_INTERFACE_CLIENT;
2776 wpa_s->global->p2p_group_formation = group_wpa_s;
2777 wpa_s->global->pending_group_iface_for_p2ps = 0;
2778
2779 wpas_p2p_clone_config(group_wpa_s, wpa_s);
2780 group_wpa_s->p2p2 = wpa_s->p2p2;
2781
2782 if (wpa_s->conf->p2p_interface_random_mac_addr) {
2783 if (wpa_drv_set_mac_addr(group_wpa_s,
2784 wpa_s->pending_interface_addr) < 0) {
2785 wpa_msg(group_wpa_s, MSG_INFO,
2786 "Failed to set random MAC address");
2787 wpa_supplicant_remove_iface(wpa_s->global, group_wpa_s,
2788 0);
2789 return NULL;
2790 }
2791
2792 if (wpa_supplicant_update_mac_addr(group_wpa_s) < 0) {
2793 wpa_msg(group_wpa_s, MSG_INFO,
2794 "Could not update MAC address information");
2795 wpa_supplicant_remove_iface(wpa_s->global, group_wpa_s,
2796 0);
2797 return NULL;
2798 }
2799
2800 wpa_printf(MSG_DEBUG, "P2P: Using random MAC address " MACSTR
2801 " for the group",
2802 MAC2STR(wpa_s->pending_interface_addr));
2803 }
2804
2805 return group_wpa_s;
2806 }
2807
2808
wpas_p2p_group_formation_timeout(void * eloop_ctx,void * timeout_ctx)2809 static void wpas_p2p_group_formation_timeout(void *eloop_ctx,
2810 void *timeout_ctx)
2811 {
2812 struct wpa_supplicant *wpa_s = eloop_ctx;
2813
2814 #ifdef CONFIG_PASN
2815 if (wpa_s->p2p_pasn_auth_work) {
2816 wpas_p2p_pasn_cancel_auth_work(wpa_s);
2817 wpa_s->p2p_pasn_auth_work = NULL;
2818 }
2819 #endif /* CONFIG_PASN */
2820
2821 wpa_printf(MSG_DEBUG, "P2P: Group Formation timed out");
2822 wpas_p2p_group_formation_failed(wpa_s, 0, "Group formation timed out");
2823 }
2824
2825
wpas_p2p_group_formation_failed(struct wpa_supplicant * wpa_s,int already_deleted,const char * reason)2826 static void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s,
2827 int already_deleted,
2828 const char *reason)
2829 {
2830 /* reason == NULL would indicate success in
2831 * wpas_group_formation_completed(), so make sure that is not the case
2832 * here. */
2833 if (!reason)
2834 reason = "";
2835
2836 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
2837 wpa_s->p2pdev, NULL);
2838 if (wpa_s->global->p2p)
2839 p2p_group_formation_failed(wpa_s->global->p2p);
2840 wpas_group_formation_completed(wpa_s, already_deleted, reason);
2841 }
2842
2843
wpas_p2p_grpform_fail_after_wps(struct wpa_supplicant * wpa_s)2844 static void wpas_p2p_grpform_fail_after_wps(struct wpa_supplicant *wpa_s)
2845 {
2846 wpa_printf(MSG_DEBUG, "P2P: Reject group formation due to WPS provisioning failure");
2847 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
2848 wpa_s->p2pdev, NULL);
2849 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
2850 wpa_s->p2pdev, NULL);
2851 wpa_s->global->p2p_fail_on_wps_complete = 0;
2852 }
2853
2854
wpas_p2p_ap_setup_failed(struct wpa_supplicant * wpa_s)2855 void wpas_p2p_ap_setup_failed(struct wpa_supplicant *wpa_s)
2856 {
2857 if (wpa_s->global->p2p_group_formation != wpa_s)
2858 return;
2859 /* Speed up group formation timeout since this cannot succeed */
2860 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
2861 wpa_s->p2pdev, NULL);
2862 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
2863 wpa_s->p2pdev, NULL);
2864 }
2865
2866
wpas_p2p_retry_limit_exceeded(struct wpa_supplicant * wpa_s)2867 bool wpas_p2p_retry_limit_exceeded(struct wpa_supplicant *wpa_s)
2868 {
2869 if (!wpa_s->p2p_in_invitation || !wpa_s->p2p_retry_limit ||
2870 wpa_s->p2p_in_invitation <= wpa_s->p2p_retry_limit)
2871 return false;
2872
2873 wpa_printf(MSG_DEBUG, "P2P: Group join retry limit exceeded");
2874 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
2875 wpa_s->p2pdev, NULL);
2876 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
2877 wpa_s->p2pdev, NULL);
2878 return true;
2879 }
2880
2881
wpas_set_go_security_config(void * ctx,struct p2p_go_neg_results * params)2882 static void wpas_set_go_security_config(void *ctx,
2883 struct p2p_go_neg_results *params)
2884 {
2885 struct wpa_supplicant *wpa_s = ctx;
2886 struct wpa_supplicant *tmp, *ifs = NULL;
2887 struct hostapd_data *hapd;
2888
2889 if (!params->p2p2)
2890 return;
2891
2892 dl_list_for_each(tmp, &wpa_s->radio->ifaces, struct wpa_supplicant,
2893 radio_list) {
2894 struct wpa_ssid *ssid = tmp->current_ssid;
2895
2896 if (ssid && ssid->mode == WPAS_MODE_P2P_GO &&
2897 ssid->ssid && ssid->ssid_len == params->ssid_len &&
2898 os_memcmp(ssid->ssid, params->ssid, params->ssid_len) == 0)
2899 {
2900 ifs = tmp;
2901 break;
2902 }
2903 }
2904
2905 if (!ifs || !ifs->ap_iface)
2906 return;
2907
2908 hapd = ifs->ap_iface->bss[0];
2909 hapd->conf->wps_state = 0;
2910
2911 if (params->akmp == WPA_KEY_MGMT_SAE) {
2912 wpa_printf(MSG_DEBUG, "P2P: Adding PMK for peer: " MACSTR,
2913 MAC2STR(params->peer_device_addr));
2914 wpa_auth_pmksa_add_sae(hapd->wpa_auth,
2915 params->peer_device_addr,
2916 params->pmk, params->pmk_len,
2917 params->pmkid, WPA_KEY_MGMT_SAE,
2918 false);
2919 hostapd_add_pmkid(hapd, params->peer_device_addr,
2920 params->pmk, params->pmk_len,
2921 params->pmkid, WPA_KEY_MGMT_SAE);
2922 }
2923 }
2924
2925
wpas_go_neg_completed(void * ctx,struct p2p_go_neg_results * res)2926 static void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
2927 {
2928 struct wpa_supplicant *wpa_s = ctx;
2929 struct wpa_supplicant *group_wpa_s;
2930
2931 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
2932 wpa_drv_cancel_remain_on_channel(wpa_s);
2933 wpa_s->off_channel_freq = 0;
2934 wpa_s->roc_waiting_drv_freq = 0;
2935 }
2936
2937 #ifdef CONFIG_PASN
2938 if (wpa_s->p2p_pasn_auth_work) {
2939 wpas_p2p_pasn_cancel_auth_work(wpa_s);
2940 wpa_s->p2p_pasn_auth_work = NULL;
2941 }
2942 #endif /* CONFIG_PASN */
2943
2944 if (res->status) {
2945 wpa_msg_global(wpa_s, MSG_INFO,
2946 P2P_EVENT_GO_NEG_FAILURE "status=%d",
2947 res->status);
2948 wpas_notify_p2p_go_neg_completed(wpa_s, res);
2949 wpas_p2p_remove_pending_group_interface(wpa_s);
2950 return;
2951 }
2952
2953 if (!res->role_go) {
2954 /* Inform driver of the operating channel of GO. */
2955 wpa_drv_set_prob_oper_freq(wpa_s, res->freq);
2956 }
2957
2958 if (wpa_s->p2p_go_ht40)
2959 res->ht40 = 1;
2960 if (wpa_s->p2p_go_vht)
2961 res->vht = 1;
2962 if (wpa_s->p2p_go_he)
2963 res->he = 1;
2964 if (wpa_s->p2p_go_edmg)
2965 res->edmg = 1;
2966 res->max_oper_chwidth = wpa_s->p2p_go_max_oper_chwidth;
2967 res->vht_center_freq2 = wpa_s->p2p_go_vht_center_freq2;
2968
2969 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS "role=%s "
2970 "freq=%d ht40=%d peer_dev=" MACSTR " peer_iface=" MACSTR
2971 " wps_method=%s",
2972 res->role_go ? "GO" : "client", res->freq, res->ht40,
2973 MAC2STR(res->peer_device_addr),
2974 MAC2STR(res->peer_interface_addr),
2975 p2p_wps_method_text(res->wps_method));
2976 wpas_notify_p2p_go_neg_completed(wpa_s, res);
2977
2978 if (res->role_go && wpa_s->p2p_persistent_id >= 0) {
2979 struct wpa_ssid *ssid;
2980 ssid = wpa_config_get_network(wpa_s->conf,
2981 wpa_s->p2p_persistent_id);
2982 if (ssid && ssid->disabled == 2 &&
2983 ssid->mode == WPAS_MODE_P2P_GO && ssid->passphrase) {
2984 size_t len = os_strlen(ssid->passphrase);
2985 wpa_printf(MSG_DEBUG, "P2P: Override passphrase based "
2986 "on requested persistent group");
2987 os_memcpy(res->passphrase, ssid->passphrase, len);
2988 res->passphrase[len] = '\0';
2989 }
2990 }
2991
2992 if (wpa_s->create_p2p_iface) {
2993 group_wpa_s =
2994 wpas_p2p_init_group_interface(wpa_s, res->role_go);
2995 if (group_wpa_s == NULL) {
2996 wpas_p2p_remove_pending_group_interface(wpa_s);
2997 eloop_cancel_timeout(wpas_p2p_long_listen_timeout,
2998 wpa_s, NULL);
2999 wpas_p2p_group_formation_failed(wpa_s, 1,
3000 "Could not initialize group interface");
3001 return;
3002 }
3003 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
3004 wpa_s->pending_interface_name[0] = '\0';
3005 } else {
3006 group_wpa_s = wpa_s->parent;
3007 wpa_s->global->p2p_group_formation = group_wpa_s;
3008 if (group_wpa_s != wpa_s)
3009 wpas_p2p_clone_config(group_wpa_s, wpa_s);
3010 }
3011
3012 group_wpa_s->p2p_in_provisioning = 1;
3013 group_wpa_s->p2pdev = wpa_s;
3014 if (group_wpa_s != wpa_s) {
3015 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
3016 sizeof(group_wpa_s->p2p_pin));
3017 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
3018 group_wpa_s->p2p2 = res->p2p2;
3019 group_wpa_s->p2p_bootstrap = wpa_s->p2p_bootstrap;
3020 }
3021
3022 if (res->role_go) {
3023 wpas_start_go(group_wpa_s, res, 1, group_wpa_s->p2p_mode);
3024 } else {
3025 os_get_reltime(&group_wpa_s->scan_min_time);
3026 if (res->p2p2)
3027 wpas_start_gc(group_wpa_s, res);
3028 else
3029 wpas_start_wps_enrollee(group_wpa_s, res);
3030 }
3031
3032 wpa_s->global->p2p_long_listen = 0;
3033 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
3034
3035 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
3036 eloop_register_timeout(15 + res->peer_config_timeout / 100,
3037 (res->peer_config_timeout % 100) * 10000,
3038 wpas_p2p_group_formation_timeout, wpa_s, NULL);
3039 }
3040
3041
wpas_go_neg_req_rx(void * ctx,const u8 * src,u16 dev_passwd_id,u8 go_intent)3042 static void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id,
3043 u8 go_intent)
3044 {
3045 struct wpa_supplicant *wpa_s = ctx;
3046 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR
3047 " dev_passwd_id=%u go_intent=%u", MAC2STR(src),
3048 dev_passwd_id, go_intent);
3049
3050 wpas_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id, go_intent);
3051 }
3052
3053
wpas_dev_found(void * ctx,const u8 * addr,const struct p2p_peer_info * info,int new_device)3054 static void wpas_dev_found(void *ctx, const u8 *addr,
3055 const struct p2p_peer_info *info,
3056 int new_device)
3057 {
3058 #ifndef CONFIG_NO_STDOUT_DEBUG
3059 struct wpa_supplicant *wpa_s = ctx;
3060 char devtype[WPS_DEV_TYPE_BUFSIZE];
3061 char *wfd_dev_info_hex = NULL;
3062
3063 #ifdef CONFIG_WIFI_DISPLAY
3064 wfd_dev_info_hex = wifi_display_subelem_hex(info->wfd_subelems,
3065 WFD_SUBELEM_DEVICE_INFO);
3066 #endif /* CONFIG_WIFI_DISPLAY */
3067
3068 if (info->p2ps_instance) {
3069 char str[256];
3070 const u8 *buf = wpabuf_head(info->p2ps_instance);
3071 size_t len = wpabuf_len(info->p2ps_instance);
3072
3073 while (len) {
3074 u32 id;
3075 u16 methods;
3076 u8 str_len;
3077
3078 if (len < 4 + 2 + 1)
3079 break;
3080 id = WPA_GET_LE32(buf);
3081 buf += sizeof(u32);
3082 methods = WPA_GET_BE16(buf);
3083 buf += sizeof(u16);
3084 str_len = *buf++;
3085 if (str_len > len - 4 - 2 - 1)
3086 break;
3087 os_memcpy(str, buf, str_len);
3088 str[str_len] = '\0';
3089 buf += str_len;
3090 len -= str_len + sizeof(u32) + sizeof(u16) + sizeof(u8);
3091
3092 wpa_msg_global(wpa_s, MSG_INFO,
3093 P2P_EVENT_DEVICE_FOUND MACSTR
3094 " p2p_dev_addr=" MACSTR
3095 " pri_dev_type=%s name='%s'"
3096 " config_methods=0x%x"
3097 " dev_capab=0x%x"
3098 " group_capab=0x%x"
3099 " adv_id=%x asp_svc=%s%s",
3100 MAC2STR(addr),
3101 MAC2STR(info->p2p_device_addr),
3102 wps_dev_type_bin2str(
3103 info->pri_dev_type,
3104 devtype, sizeof(devtype)),
3105 info->device_name, methods,
3106 info->dev_capab, info->group_capab,
3107 id, str,
3108 info->vendor_elems ?
3109 " vendor_elems=1" : "");
3110 }
3111 goto done;
3112 }
3113
3114 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
3115 " p2p_dev_addr=" MACSTR
3116 " pri_dev_type=%s name='%s' config_methods=0x%x dev_capab=0x%x group_capab=0x%x%s%s%s new=%d pcea_cap_info=0x%x bootstrap_methods=0x%x pasn_type=0x%x",
3117 MAC2STR(addr), MAC2STR(info->p2p_device_addr),
3118 wps_dev_type_bin2str(info->pri_dev_type, devtype,
3119 sizeof(devtype)),
3120 info->device_name, info->config_methods,
3121 info->dev_capab, info->group_capab,
3122 wfd_dev_info_hex ? " wfd_dev_info=0x" : "",
3123 wfd_dev_info_hex ? wfd_dev_info_hex : "",
3124 info->vendor_elems ? " vendor_elems=1" : "",
3125 new_device, info->pcea_cap_info,
3126 info->pairing_config.bootstrap_methods,
3127 info->pairing_config.pasn_type);
3128
3129 done:
3130 os_free(wfd_dev_info_hex);
3131 #endif /* CONFIG_NO_STDOUT_DEBUG */
3132
3133 wpas_notify_p2p_device_found(ctx, info->p2p_device_addr, new_device);
3134 }
3135
3136
wpas_dev_lost(void * ctx,const u8 * dev_addr)3137 static void wpas_dev_lost(void *ctx, const u8 *dev_addr)
3138 {
3139 struct wpa_supplicant *wpa_s = ctx;
3140
3141 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_LOST
3142 "p2p_dev_addr=" MACSTR, MAC2STR(dev_addr));
3143
3144 wpas_notify_p2p_device_lost(wpa_s, dev_addr);
3145 }
3146
3147
wpas_find_stopped(void * ctx)3148 static void wpas_find_stopped(void *ctx)
3149 {
3150 struct wpa_supplicant *wpa_s = ctx;
3151
3152 if (wpa_s->p2p_scan_work && wpas_abort_ongoing_scan(wpa_s) < 0)
3153 wpa_printf(MSG_DEBUG, "P2P: Abort ongoing scan failed");
3154
3155 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_FIND_STOPPED);
3156 wpas_notify_p2p_find_stopped(wpa_s);
3157 }
3158
3159
3160 struct wpas_p2p_listen_work {
3161 unsigned int freq;
3162 unsigned int duration;
3163 struct wpabuf *probe_resp_ie;
3164 };
3165
3166
wpas_p2p_listen_work_free(struct wpas_p2p_listen_work * lwork)3167 static void wpas_p2p_listen_work_free(struct wpas_p2p_listen_work *lwork)
3168 {
3169 if (lwork == NULL)
3170 return;
3171 wpabuf_free(lwork->probe_resp_ie);
3172 os_free(lwork);
3173 }
3174
3175
wpas_p2p_listen_work_done(struct wpa_supplicant * wpa_s)3176 static void wpas_p2p_listen_work_done(struct wpa_supplicant *wpa_s)
3177 {
3178 struct wpas_p2p_listen_work *lwork;
3179
3180 if (!wpa_s->p2p_listen_work)
3181 return;
3182
3183 lwork = wpa_s->p2p_listen_work->ctx;
3184 wpas_p2p_listen_work_free(lwork);
3185 radio_work_done(wpa_s->p2p_listen_work);
3186 wpa_s->p2p_listen_work = NULL;
3187 }
3188
3189
wpas_start_listen_cb(struct wpa_radio_work * work,int deinit)3190 static void wpas_start_listen_cb(struct wpa_radio_work *work, int deinit)
3191 {
3192 struct wpa_supplicant *wpa_s = work->wpa_s;
3193 struct wpas_p2p_listen_work *lwork = work->ctx;
3194 unsigned int duration;
3195
3196 if (deinit) {
3197 if (work->started && !wpa_s->p2p_removing_listen_work) {
3198 wpa_s->p2p_listen_work = NULL;
3199 wpas_stop_listen(wpa_s);
3200 }
3201 wpas_p2p_listen_work_free(lwork);
3202 return;
3203 }
3204
3205 wpa_s->p2p_listen_work = work;
3206
3207 wpa_drv_set_ap_wps_ie(wpa_s, NULL, lwork->probe_resp_ie, NULL);
3208
3209 if (wpa_drv_probe_req_report(wpa_s, 1) < 0) {
3210 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver to "
3211 "report received Probe Request frames");
3212 p2p_listen_failed(wpa_s->global->p2p, lwork->freq);
3213 wpas_p2p_listen_work_done(wpa_s);
3214 return;
3215 }
3216
3217 wpa_s->pending_listen_freq = lwork->freq;
3218 wpa_s->pending_listen_duration = lwork->duration;
3219
3220 duration = lwork->duration;
3221 #ifdef CONFIG_TESTING_OPTIONS
3222 if (wpa_s->extra_roc_dur) {
3223 wpa_printf(MSG_DEBUG, "TESTING: Increase ROC duration %u -> %u",
3224 duration, duration + wpa_s->extra_roc_dur);
3225 duration += wpa_s->extra_roc_dur;
3226 }
3227 #endif /* CONFIG_TESTING_OPTIONS */
3228
3229 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq, duration) < 0) {
3230 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver "
3231 "to remain on channel (%u MHz) for Listen "
3232 "state", lwork->freq);
3233 p2p_listen_failed(wpa_s->global->p2p, lwork->freq);
3234 wpas_p2p_listen_work_done(wpa_s);
3235 wpa_s->pending_listen_freq = 0;
3236 return;
3237 }
3238 wpa_s->off_channel_freq = 0;
3239 wpa_s->roc_waiting_drv_freq = lwork->freq;
3240 }
3241
3242
wpas_start_listen(void * ctx,unsigned int freq,unsigned int duration,const struct wpabuf * probe_resp_ie)3243 static int wpas_start_listen(void *ctx, unsigned int freq,
3244 unsigned int duration,
3245 const struct wpabuf *probe_resp_ie)
3246 {
3247 struct wpa_supplicant *wpa_s = ctx;
3248 struct wpas_p2p_listen_work *lwork;
3249
3250 if (wpa_s->p2p_listen_work) {
3251 wpa_printf(MSG_DEBUG, "P2P: Reject start_listen since p2p_listen_work already exists");
3252 return -1;
3253 }
3254
3255 lwork = os_zalloc(sizeof(*lwork));
3256 if (lwork == NULL)
3257 return -1;
3258 lwork->freq = freq;
3259 lwork->duration = duration;
3260 if (probe_resp_ie) {
3261 lwork->probe_resp_ie = wpabuf_dup(probe_resp_ie);
3262 if (lwork->probe_resp_ie == NULL) {
3263 wpas_p2p_listen_work_free(lwork);
3264 return -1;
3265 }
3266 }
3267
3268 if (radio_add_work(wpa_s, freq, "p2p-listen", 0, wpas_start_listen_cb,
3269 lwork) < 0) {
3270 wpas_p2p_listen_work_free(lwork);
3271 return -1;
3272 }
3273
3274 return 0;
3275 }
3276
3277
wpas_stop_listen(void * ctx)3278 static void wpas_stop_listen(void *ctx)
3279 {
3280 struct wpa_supplicant *wpa_s = ctx;
3281 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
3282 wpa_drv_cancel_remain_on_channel(wpa_s);
3283 wpa_s->off_channel_freq = 0;
3284 wpa_s->roc_waiting_drv_freq = 0;
3285 }
3286 wpa_drv_set_ap_wps_ie(wpa_s, NULL, NULL, NULL);
3287
3288 /*
3289 * Don't cancel Probe Request RX reporting for a connected P2P Client
3290 * handling Probe Request frames.
3291 */
3292 if (!wpa_s->p2p_cli_probe)
3293 wpa_drv_probe_req_report(wpa_s, 0);
3294
3295 wpas_p2p_listen_work_done(wpa_s);
3296
3297 if (!wpa_s->p2p_removing_listen_work &&
3298 radio_work_pending(wpa_s, "p2p-listen")) {
3299 wpa_s->p2p_removing_listen_work = true;
3300 wpa_printf(MSG_DEBUG,
3301 "P2P: p2p-listen is still pending - remove it");
3302 radio_remove_works(wpa_s, "p2p-listen", 0);
3303 wpa_s->p2p_removing_listen_work = false;
3304 }
3305 }
3306
3307
wpas_send_probe_resp(void * ctx,const struct wpabuf * buf,unsigned int freq)3308 static int wpas_send_probe_resp(void *ctx, const struct wpabuf *buf,
3309 unsigned int freq)
3310 {
3311 struct wpa_supplicant *wpa_s = ctx;
3312 return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf), 1,
3313 freq, 0);
3314 }
3315
3316
wpas_prov_disc_local_display(struct wpa_supplicant * wpa_s,const u8 * peer,const char * params,unsigned int generated_pin)3317 static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s,
3318 const u8 *peer, const char *params,
3319 unsigned int generated_pin)
3320 {
3321 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR
3322 " %08d%s", MAC2STR(peer), generated_pin, params);
3323 }
3324
3325
wpas_prov_disc_local_keypad(struct wpa_supplicant * wpa_s,const u8 * peer,const char * params)3326 static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
3327 const u8 *peer, const char *params)
3328 {
3329 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR
3330 "%s", MAC2STR(peer), params);
3331 }
3332
3333
wpas_prov_disc_req(void * ctx,const u8 * peer,u16 config_methods,const u8 * dev_addr,const u8 * pri_dev_type,const char * dev_name,u16 supp_config_methods,u8 dev_capab,u8 group_capab,const u8 * group_id,size_t group_id_len)3334 static void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
3335 const u8 *dev_addr, const u8 *pri_dev_type,
3336 const char *dev_name, u16 supp_config_methods,
3337 u8 dev_capab, u8 group_capab, const u8 *group_id,
3338 size_t group_id_len)
3339 {
3340 struct wpa_supplicant *wpa_s = ctx;
3341 char devtype[WPS_DEV_TYPE_BUFSIZE];
3342 char params[300];
3343 u8 empty_dev_type[8];
3344 unsigned int generated_pin = 0;
3345 struct wpa_supplicant *group = NULL;
3346 int res;
3347
3348 if (group_id) {
3349 for (group = wpa_s->global->ifaces; group; group = group->next)
3350 {
3351 struct wpa_ssid *s = group->current_ssid;
3352 if (s != NULL &&
3353 s->mode == WPAS_MODE_P2P_GO &&
3354 group_id_len - ETH_ALEN == s->ssid_len &&
3355 os_memcmp(group_id + ETH_ALEN, s->ssid,
3356 s->ssid_len) == 0)
3357 break;
3358 }
3359 }
3360
3361 if (pri_dev_type == NULL) {
3362 os_memset(empty_dev_type, 0, sizeof(empty_dev_type));
3363 pri_dev_type = empty_dev_type;
3364 }
3365 res = os_snprintf(params, sizeof(params), " p2p_dev_addr=" MACSTR
3366 " pri_dev_type=%s name='%s' config_methods=0x%x "
3367 "dev_capab=0x%x group_capab=0x%x%s%s",
3368 MAC2STR(dev_addr),
3369 wps_dev_type_bin2str(pri_dev_type, devtype,
3370 sizeof(devtype)),
3371 dev_name, supp_config_methods, dev_capab, group_capab,
3372 group ? " group=" : "",
3373 group ? group->ifname : "");
3374 if (os_snprintf_error(sizeof(params), res))
3375 wpa_printf(MSG_DEBUG, "P2P: PD Request event truncated");
3376 params[sizeof(params) - 1] = '\0';
3377
3378 if (config_methods & WPS_CONFIG_DISPLAY) {
3379 if (wps_generate_pin(&generated_pin) < 0) {
3380 wpa_printf(MSG_DEBUG, "P2P: Could not generate PIN");
3381 wpas_notify_p2p_provision_discovery(
3382 wpa_s, peer, 0 /* response */,
3383 P2P_PROV_DISC_INFO_UNAVAILABLE, 0, 0);
3384 return;
3385 }
3386 wpas_prov_disc_local_display(wpa_s, peer, params,
3387 generated_pin);
3388 } else if (config_methods & WPS_CONFIG_KEYPAD)
3389 wpas_prov_disc_local_keypad(wpa_s, peer, params);
3390 else if (config_methods & WPS_CONFIG_PUSHBUTTON)
3391 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ
3392 MACSTR "%s", MAC2STR(peer), params);
3393
3394 wpas_notify_p2p_provision_discovery(wpa_s, peer, 1 /* request */,
3395 P2P_PROV_DISC_SUCCESS,
3396 config_methods, generated_pin);
3397 }
3398
3399
wpas_prov_disc_resp(void * ctx,const u8 * peer,u16 config_methods)3400 static void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods)
3401 {
3402 struct wpa_supplicant *wpa_s = ctx;
3403 unsigned int generated_pin = 0;
3404 char params[20];
3405
3406 if (wpa_s->pending_pd_before_join &&
3407 (ether_addr_equal(peer, wpa_s->pending_join_dev_addr) ||
3408 ether_addr_equal(peer, wpa_s->pending_join_iface_addr))) {
3409 wpa_s->pending_pd_before_join = 0;
3410 wpa_printf(MSG_DEBUG, "P2P: Starting pending "
3411 "join-existing-group operation");
3412 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
3413 return;
3414 }
3415
3416 if (wpa_s->pending_pd_use == AUTO_PD_JOIN ||
3417 wpa_s->pending_pd_use == AUTO_PD_GO_NEG) {
3418 int res;
3419
3420 res = os_snprintf(params, sizeof(params), " peer_go=%d",
3421 wpa_s->pending_pd_use == AUTO_PD_JOIN);
3422 if (os_snprintf_error(sizeof(params), res))
3423 params[sizeof(params) - 1] = '\0';
3424 } else
3425 params[0] = '\0';
3426
3427 if (config_methods & WPS_CONFIG_DISPLAY)
3428 wpas_prov_disc_local_keypad(wpa_s, peer, params);
3429 else if (config_methods & WPS_CONFIG_KEYPAD) {
3430 if (wps_generate_pin(&generated_pin) < 0) {
3431 wpa_printf(MSG_DEBUG, "P2P: Could not generate PIN");
3432 wpas_notify_p2p_provision_discovery(
3433 wpa_s, peer, 0 /* response */,
3434 P2P_PROV_DISC_INFO_UNAVAILABLE, 0, 0);
3435 return;
3436 }
3437 wpas_prov_disc_local_display(wpa_s, peer, params,
3438 generated_pin);
3439 } else if (config_methods & WPS_CONFIG_PUSHBUTTON)
3440 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP
3441 MACSTR "%s", MAC2STR(peer), params);
3442
3443 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
3444 P2P_PROV_DISC_SUCCESS,
3445 config_methods, generated_pin);
3446 }
3447
3448
wpas_prov_disc_fail(void * ctx,const u8 * peer,enum p2p_prov_disc_status status,u32 adv_id,const u8 * adv_mac,const char * deferred_session_resp)3449 static void wpas_prov_disc_fail(void *ctx, const u8 *peer,
3450 enum p2p_prov_disc_status status,
3451 u32 adv_id, const u8 *adv_mac,
3452 const char *deferred_session_resp)
3453 {
3454 struct wpa_supplicant *wpa_s = ctx;
3455
3456 if (wpa_s->p2p_fallback_to_go_neg) {
3457 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto "
3458 "failed - fall back to GO Negotiation");
3459 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
3460 P2P_EVENT_FALLBACK_TO_GO_NEG
3461 "reason=PD-failed");
3462 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
3463 return;
3464 }
3465
3466 if (status == P2P_PROV_DISC_TIMEOUT_JOIN) {
3467 wpa_s->pending_pd_before_join = 0;
3468 wpa_printf(MSG_DEBUG, "P2P: Starting pending "
3469 "join-existing-group operation (no ACK for PD "
3470 "Req attempts)");
3471 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
3472 return;
3473 }
3474
3475 if (adv_id && adv_mac && deferred_session_resp) {
3476 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
3477 " p2p_dev_addr=" MACSTR " status=%d adv_id=%x"
3478 " deferred_session_resp='%s'",
3479 MAC2STR(peer), status, adv_id,
3480 deferred_session_resp);
3481 } else if (adv_id && adv_mac) {
3482 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
3483 " p2p_dev_addr=" MACSTR " status=%d adv_id=%x",
3484 MAC2STR(peer), status, adv_id);
3485 } else {
3486 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
3487 " p2p_dev_addr=" MACSTR " status=%d",
3488 MAC2STR(peer), status);
3489 }
3490
3491 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
3492 status, 0, 0);
3493 }
3494
3495
freq_included(struct wpa_supplicant * wpa_s,const struct p2p_channels * channels,unsigned int freq)3496 static int freq_included(struct wpa_supplicant *wpa_s,
3497 const struct p2p_channels *channels,
3498 unsigned int freq)
3499 {
3500 if ((channels == NULL || p2p_channels_includes_freq(channels, freq)) &&
3501 wpas_p2p_go_is_peer_freq(wpa_s, freq))
3502 return 1;
3503 return 0;
3504 }
3505
3506
wpas_p2p_go_update_common_freqs(struct wpa_supplicant * wpa_s)3507 static void wpas_p2p_go_update_common_freqs(struct wpa_supplicant *wpa_s)
3508 {
3509 unsigned int num = P2P_MAX_CHANNELS;
3510 int *common_freqs;
3511 int ret;
3512
3513 p2p_go_dump_common_freqs(wpa_s);
3514 common_freqs = os_calloc(num, sizeof(int));
3515 if (!common_freqs)
3516 return;
3517
3518 ret = p2p_group_get_common_freqs(wpa_s->p2p_group, common_freqs, &num);
3519 if (ret < 0) {
3520 wpa_dbg(wpa_s, MSG_DEBUG,
3521 "P2P: Failed to get group common freqs");
3522 os_free(common_freqs);
3523 return;
3524 }
3525
3526 os_free(wpa_s->p2p_group_common_freqs);
3527 wpa_s->p2p_group_common_freqs = common_freqs;
3528 wpa_s->p2p_group_common_freqs_num = num;
3529 p2p_go_dump_common_freqs(wpa_s);
3530 }
3531
3532
3533 /*
3534 * Check if the given frequency is one of the possible operating frequencies
3535 * set after the completion of the GO Negotiation.
3536 */
wpas_p2p_go_is_peer_freq(struct wpa_supplicant * wpa_s,int freq)3537 static int wpas_p2p_go_is_peer_freq(struct wpa_supplicant *wpa_s, int freq)
3538 {
3539 unsigned int i;
3540
3541 p2p_go_dump_common_freqs(wpa_s);
3542
3543 /* assume no restrictions */
3544 if (!wpa_s->p2p_group_common_freqs_num)
3545 return 1;
3546
3547 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
3548 if (wpa_s->p2p_group_common_freqs[i] == freq)
3549 return 1;
3550 }
3551 return 0;
3552 }
3553
3554
wpas_sta_check_ecsa(struct hostapd_data * hapd,struct sta_info * sta,void * ctx)3555 static int wpas_sta_check_ecsa(struct hostapd_data *hapd,
3556 struct sta_info *sta, void *ctx)
3557 {
3558 int *ecsa_support = ctx;
3559
3560 *ecsa_support &= sta->ecsa_supported;
3561
3562 return 0;
3563 }
3564
3565
3566 /* Check if all the peers support eCSA */
wpas_p2p_go_clients_support_ecsa(struct wpa_supplicant * wpa_s)3567 static int wpas_p2p_go_clients_support_ecsa(struct wpa_supplicant *wpa_s)
3568 {
3569 int ecsa_support = 1;
3570
3571 ap_for_each_sta(wpa_s->ap_iface->bss[0], wpas_sta_check_ecsa,
3572 &ecsa_support);
3573
3574 return ecsa_support;
3575 }
3576
3577
3578 /**
3579 * Pick the best frequency to use from all the currently used frequencies.
3580 */
wpas_p2p_pick_best_used_freq(struct wpa_supplicant * wpa_s,struct wpa_used_freq_data * freqs,unsigned int num)3581 static int wpas_p2p_pick_best_used_freq(struct wpa_supplicant *wpa_s,
3582 struct wpa_used_freq_data *freqs,
3583 unsigned int num)
3584 {
3585 unsigned int i, c;
3586
3587 /* find a candidate freq that is supported by P2P */
3588 for (c = 0; c < num; c++)
3589 if (p2p_supported_freq(wpa_s->global->p2p, freqs[c].freq))
3590 break;
3591
3592 if (c == num)
3593 return 0;
3594
3595 /* once we have a candidate, try to find a 'better' one */
3596 for (i = c + 1; i < num; i++) {
3597 if (!p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
3598 continue;
3599
3600 /*
3601 * 1. Infrastructure station interfaces have higher preference.
3602 * 2. P2P Clients have higher preference.
3603 * 3. All others.
3604 */
3605 if (freqs[i].flags & WPA_FREQ_USED_BY_INFRA_STATION) {
3606 c = i;
3607 break;
3608 }
3609
3610 if ((freqs[i].flags & WPA_FREQ_USED_BY_P2P_CLIENT))
3611 c = i;
3612 }
3613 return freqs[c].freq;
3614 }
3615
3616
3617 /**
3618 * Pick the best frequency the driver suggests.
3619 *
3620 * num_pref_freq is used as both input and output
3621 * - input: the max size of pref_freq_list,
3622 * - output: the valid size of pref_freq_list filled with data.
3623 */
wpas_p2p_pick_best_pref_freq(struct wpa_supplicant * wpa_s,bool go,struct weighted_pcl * pref_freq_list,unsigned int * num_pref_freq)3624 static int wpas_p2p_pick_best_pref_freq(struct wpa_supplicant *wpa_s, bool go,
3625 struct weighted_pcl *pref_freq_list,
3626 unsigned int *num_pref_freq)
3627 {
3628 int best_freq = 0;
3629 unsigned int max_pref_freq, i;
3630 int res;
3631 enum wpa_driver_if_type iface_type;
3632
3633 max_pref_freq = *num_pref_freq;
3634 *num_pref_freq = 0;
3635
3636 if (go)
3637 iface_type = WPA_IF_P2P_GO;
3638 else
3639 iface_type = WPA_IF_P2P_CLIENT;
3640
3641 res = wpa_drv_get_pref_freq_list(wpa_s, iface_type, &max_pref_freq,
3642 pref_freq_list);
3643 if (!res && !is_p2p_allow_6ghz(wpa_s->global->p2p))
3644 max_pref_freq = p2p_remove_6ghz_channels(pref_freq_list,
3645 max_pref_freq);
3646 if (res || !max_pref_freq) {
3647 wpa_printf(MSG_DEBUG,
3648 "P2P: No preferred frequency list available");
3649 return 0;
3650 }
3651
3652 *num_pref_freq = max_pref_freq;
3653 i = 0;
3654 while (i < *num_pref_freq &&
3655 (!p2p_supported_freq(wpa_s->global->p2p,
3656 pref_freq_list[i].freq) ||
3657 wpas_p2p_disallowed_freq(wpa_s->global,
3658 pref_freq_list[i].freq) ||
3659 !p2p_pref_freq_allowed(&pref_freq_list[i], go))) {
3660 wpa_printf(MSG_DEBUG,
3661 "P2P: preferred_freq_list[%d]=%d is disallowed",
3662 i, pref_freq_list[i].freq);
3663 i++;
3664 }
3665 if (i != *num_pref_freq) {
3666 best_freq = pref_freq_list[i].freq;
3667 wpa_printf(MSG_DEBUG, "P2P: Using preferred_freq_list[%d]=%d",
3668 i, best_freq);
3669 } else {
3670 wpa_printf(MSG_DEBUG,
3671 "P2P: All driver preferred frequencies are disallowed for P2P use");
3672 *num_pref_freq = 0;
3673 }
3674
3675 return best_freq;
3676 }
3677
3678
wpas_invitation_process(void * ctx,const u8 * sa,const u8 * bssid,const u8 * go_dev_addr,const u8 * ssid,size_t ssid_len,int * go,u8 * group_bssid,int * force_freq,int persistent_group,const struct p2p_channels * channels,int dev_pw_id,bool p2p2,const u8 ** new_ssid,size_t * new_ssid_len)3679 static u8 wpas_invitation_process(void *ctx, const u8 *sa, const u8 *bssid,
3680 const u8 *go_dev_addr, const u8 *ssid,
3681 size_t ssid_len, int *go, u8 *group_bssid,
3682 int *force_freq, int persistent_group,
3683 const struct p2p_channels *channels,
3684 int dev_pw_id, bool p2p2, const u8 **new_ssid,
3685 size_t *new_ssid_len)
3686 {
3687 struct wpa_supplicant *wpa_s = ctx;
3688 struct wpa_ssid *s;
3689 struct wpa_used_freq_data *freqs;
3690 struct wpa_supplicant *grp;
3691 int best_freq;
3692 struct weighted_pcl pref_freq_list[P2P_MAX_PREF_CHANNELS];
3693 unsigned int num_pref_freq;
3694 int res;
3695
3696
3697 if (!persistent_group) {
3698 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
3699 " to join an active group (SSID: %s)",
3700 MAC2STR(sa), wpa_ssid_txt(ssid, ssid_len));
3701 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
3702 (ether_addr_equal(go_dev_addr, wpa_s->p2p_auth_invite) ||
3703 ether_addr_equal(sa, wpa_s->p2p_auth_invite))) {
3704 wpa_printf(MSG_DEBUG, "P2P: Accept previously "
3705 "authorized invitation");
3706 goto accept_inv;
3707 }
3708
3709 #ifdef CONFIG_WPS_NFC
3710 if (dev_pw_id >= 0 && wpa_s->p2p_nfc_tag_enabled &&
3711 dev_pw_id == wpa_s->p2p_oob_dev_pw_id) {
3712 wpa_printf(MSG_DEBUG, "P2P: Accept invitation based on local enabled NFC Tag");
3713 wpa_s->p2p_wps_method = WPS_NFC;
3714 wpa_s->pending_join_wps_method = WPS_NFC;
3715 os_memcpy(wpa_s->pending_join_dev_addr,
3716 go_dev_addr, ETH_ALEN);
3717 os_memcpy(wpa_s->pending_join_iface_addr,
3718 bssid, ETH_ALEN);
3719 goto accept_inv;
3720 }
3721 #endif /* CONFIG_WPS_NFC */
3722
3723 /*
3724 * Do not accept the invitation automatically; notify user and
3725 * request approval.
3726 */
3727 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
3728 }
3729
3730 grp = wpas_get_p2p_group(wpa_s, ssid, ssid_len, go);
3731 if (grp) {
3732 wpa_printf(MSG_DEBUG, "P2P: Accept invitation to already "
3733 "running persistent group");
3734 if (*go)
3735 os_memcpy(group_bssid, grp->own_addr, ETH_ALEN);
3736 goto accept_inv;
3737 }
3738
3739 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
3740 ether_addr_equal(sa, wpa_s->p2p_auth_invite)) {
3741 wpa_printf(MSG_DEBUG, "P2P: Accept previously initiated "
3742 "invitation to re-invoke a persistent group");
3743 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
3744 } else if (!wpa_s->conf->persistent_reconnect)
3745 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
3746
3747 for (s = wpa_s->conf->ssid; s; s = s->next) {
3748 if (s->disabled == 2 &&
3749 (p2p2 || ether_addr_equal(s->bssid, go_dev_addr)) &&
3750 s->ssid_len == ssid_len &&
3751 os_memcmp(ssid, s->ssid, ssid_len) == 0)
3752 break;
3753 }
3754
3755 if (p2p2) {
3756 int dik_id;
3757 u8 go_ssid[SSID_MAX_LEN];
3758
3759 dik_id = p2p_get_dik_id(wpa_s->global->p2p, sa);
3760 s = wpa_config_get_network_with_dik_id(wpa_s->conf, dik_id);
3761 if (!s) {
3762 wpa_printf(MSG_DEBUG, "P2P2: Invitation from " MACSTR
3763 " requested reinvocation of an unknown group",
3764 MAC2STR(sa));
3765 return P2P_SC_FAIL_UNKNOWN_GROUP;
3766 }
3767 os_free(s->ssid);
3768 if (s->mode == WPAS_MODE_P2P_GO) {
3769 p2p_build_ssid(wpa_s->global->p2p, go_ssid,
3770 &s->ssid_len);
3771 s->ssid = os_memdup(go_ssid, s->ssid_len);
3772 if (!s->ssid) {
3773 s->ssid_len = 0;
3774 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
3775 }
3776 wpa_printf(MSG_DEBUG,
3777 "P2P: New random SSID for the group: %s",
3778 wpa_ssid_txt(s->ssid, s->ssid_len));
3779 *new_ssid = s->ssid;
3780 *new_ssid_len = s->ssid_len;
3781 } else {
3782 s->ssid_len = ssid_len;
3783 s->ssid = os_memdup(ssid, ssid_len);
3784 if (!s->ssid) {
3785 s->ssid_len = 0;
3786 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
3787 }
3788 }
3789 } else if (!s) {
3790 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
3791 " requested reinvocation of an unknown group",
3792 MAC2STR(sa));
3793 return P2P_SC_FAIL_UNKNOWN_GROUP;
3794 }
3795
3796 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
3797 *go = 1;
3798 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
3799 wpa_printf(MSG_DEBUG, "P2P: The only available "
3800 "interface is already in use - reject "
3801 "invitation");
3802 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
3803 }
3804 if (wpa_s->p2p_mgmt)
3805 os_memcpy(group_bssid, wpa_s->parent->own_addr,
3806 ETH_ALEN);
3807 else
3808 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
3809 } else if (s->mode == WPAS_MODE_P2P_GO) {
3810 *go = 1;
3811 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0)
3812 {
3813 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
3814 "interface address for the group");
3815 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
3816 }
3817 os_memcpy(group_bssid, wpa_s->pending_interface_addr,
3818 ETH_ALEN);
3819 }
3820
3821 accept_inv:
3822 wpas_p2p_set_own_freq_preference(wpa_s, 0);
3823
3824 best_freq = 0;
3825 freqs = os_calloc(wpa_s->num_multichan_concurrent,
3826 sizeof(struct wpa_used_freq_data));
3827 if (freqs) {
3828 int num_channels = wpa_s->num_multichan_concurrent;
3829 int num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, num_channels);
3830 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
3831 os_free(freqs);
3832 }
3833
3834 num_pref_freq = P2P_MAX_PREF_CHANNELS;
3835 res = wpas_p2p_pick_best_pref_freq(wpa_s, *go, pref_freq_list,
3836 &num_pref_freq);
3837 if (res > 0)
3838 best_freq = res;
3839
3840 /* Get one of the frequencies currently in use */
3841 if (best_freq > 0) {
3842 wpa_printf(MSG_DEBUG, "P2P: Trying to prefer a channel already used by one of the interfaces");
3843 wpas_p2p_set_own_freq_preference(wpa_s, best_freq);
3844
3845 if (wpa_s->num_multichan_concurrent < 2 ||
3846 wpas_p2p_num_unused_channels(wpa_s) < 1) {
3847 wpa_printf(MSG_DEBUG, "P2P: No extra channels available - trying to force channel to match a channel already used by one of the interfaces");
3848 *force_freq = best_freq;
3849 }
3850 }
3851
3852 if (*force_freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
3853 wpas_p2p_num_unused_channels(wpa_s) > 0) {
3854 if (*go == 0) {
3855 /* We are the client */
3856 wpa_printf(MSG_DEBUG, "P2P: Peer was found to be "
3857 "running a GO but we are capable of MCC, "
3858 "figure out the best channel to use");
3859 *force_freq = 0;
3860 } else if (!freq_included(wpa_s, channels, *force_freq)) {
3861 /* We are the GO, and *force_freq is not in the
3862 * intersection */
3863 wpa_printf(MSG_DEBUG, "P2P: Forced GO freq %d MHz not "
3864 "in intersection but we are capable of MCC, "
3865 "figure out the best channel to use",
3866 *force_freq);
3867 *force_freq = 0;
3868 }
3869 }
3870
3871 return P2P_SC_SUCCESS;
3872 }
3873
3874
wpas_invitation_received(void * ctx,const u8 * sa,const u8 * bssid,const u8 * ssid,size_t ssid_len,const u8 * go_dev_addr,u8 status,int op_freq,const u8 * pmkid,const u8 * pmk,size_t pmk_len)3875 static void wpas_invitation_received(void *ctx, const u8 *sa, const u8 *bssid,
3876 const u8 *ssid, size_t ssid_len,
3877 const u8 *go_dev_addr, u8 status,
3878 int op_freq, const u8 *pmkid,
3879 const u8 *pmk, size_t pmk_len)
3880 {
3881 struct wpa_supplicant *wpa_s = ctx;
3882 struct wpa_ssid *s;
3883
3884 for (s = wpa_s->conf->ssid; s; s = s->next) {
3885 if (s->disabled == 2 &&
3886 s->ssid_len == ssid_len &&
3887 os_memcmp(ssid, s->ssid, ssid_len) == 0)
3888 break;
3889 }
3890
3891 if (status == P2P_SC_SUCCESS) {
3892 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
3893 " was accepted; op_freq=%d MHz, SSID=%s",
3894 MAC2STR(sa), op_freq, wpa_ssid_txt(ssid, ssid_len));
3895 if (s) {
3896 const char *ssid_txt;
3897
3898 ssid_txt = wpa_ssid_txt(s->ssid, s->ssid_len);
3899 int go = s->mode == WPAS_MODE_P2P_GO;
3900 if (go) {
3901 wpa_msg_global(wpa_s, MSG_INFO,
3902 P2P_EVENT_INVITATION_ACCEPTED
3903 "sa=" MACSTR
3904 " persistent=%d freq=%d ssid=\"%s\" go_dev_addr="
3905 MACSTR, MAC2STR(sa), s->id,
3906 op_freq, ssid_txt,
3907 MAC2STR(go_dev_addr));
3908 } else {
3909 wpa_msg_global(wpa_s, MSG_INFO,
3910 P2P_EVENT_INVITATION_ACCEPTED
3911 "sa=" MACSTR
3912 " persistent=%d ssid=\"%s\" go_dev_addr=" MACSTR,
3913 MAC2STR(sa), s->id, ssid_txt,
3914 MAC2STR(go_dev_addr));
3915 }
3916 wpas_p2p_group_add_persistent(
3917 wpa_s, s, go, 0, op_freq, 0,
3918 wpa_s->conf->p2p_go_ht40,
3919 wpa_s->conf->p2p_go_vht,
3920 0,
3921 wpa_s->conf->p2p_go_he,
3922 wpa_s->conf->p2p_go_edmg, NULL,
3923 go ? P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE : 0,
3924 1, is_p2p_allow_6ghz(wpa_s->global->p2p), 0,
3925 bssid, sa, pmkid, pmk, pmk_len);
3926 } else if (bssid) {
3927 wpa_s->user_initiated_pd = 0;
3928 wpa_msg_global(wpa_s, MSG_INFO,
3929 P2P_EVENT_INVITATION_ACCEPTED
3930 "sa=" MACSTR " go_dev_addr=" MACSTR
3931 " bssid=" MACSTR " unknown-network",
3932 MAC2STR(sa), MAC2STR(go_dev_addr),
3933 MAC2STR(bssid));
3934 wpas_p2p_join(wpa_s, bssid, go_dev_addr,
3935 wpa_s->p2p_wps_method, 0, op_freq,
3936 ssid, ssid_len);
3937 }
3938 return;
3939 }
3940
3941 if (status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
3942 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
3943 " was rejected (status %u)", MAC2STR(sa), status);
3944 return;
3945 }
3946
3947 if (!s) {
3948 if (bssid) {
3949 wpa_msg_global(wpa_s, MSG_INFO,
3950 P2P_EVENT_INVITATION_RECEIVED
3951 "sa=" MACSTR " go_dev_addr=" MACSTR
3952 " bssid=" MACSTR " unknown-network",
3953 MAC2STR(sa), MAC2STR(go_dev_addr),
3954 MAC2STR(bssid));
3955 } else {
3956 wpa_msg_global(wpa_s, MSG_INFO,
3957 P2P_EVENT_INVITATION_RECEIVED
3958 "sa=" MACSTR " go_dev_addr=" MACSTR
3959 " unknown-network",
3960 MAC2STR(sa), MAC2STR(go_dev_addr));
3961 }
3962 wpas_notify_p2p_invitation_received(wpa_s, sa, go_dev_addr,
3963 bssid, 0, op_freq);
3964 return;
3965 }
3966
3967 if (s->mode == WPAS_MODE_P2P_GO && op_freq) {
3968 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
3969 "sa=" MACSTR " persistent=%d freq=%d",
3970 MAC2STR(sa), s->id, op_freq);
3971 } else {
3972 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
3973 "sa=" MACSTR " persistent=%d",
3974 MAC2STR(sa), s->id);
3975 }
3976 wpas_notify_p2p_invitation_received(wpa_s, sa, go_dev_addr, bssid,
3977 s->id, op_freq);
3978 }
3979
3980
wpas_remove_persistent_peer(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid,const u8 * peer,int inv)3981 static void wpas_remove_persistent_peer(struct wpa_supplicant *wpa_s,
3982 struct wpa_ssid *ssid,
3983 const u8 *peer, int inv)
3984 {
3985 size_t i;
3986 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
3987
3988 if (ssid == NULL)
3989 return;
3990
3991 for (i = 0; ssid->p2p_client_list && i < ssid->num_p2p_clients; i++) {
3992 if (ether_addr_equal(ssid->p2p_client_list + i * 2 * ETH_ALEN,
3993 peer))
3994 break;
3995 }
3996 if (i >= ssid->num_p2p_clients || !ssid->p2p_client_list) {
3997 if (ssid->mode != WPAS_MODE_P2P_GO &&
3998 ether_addr_equal(ssid->bssid, peer)) {
3999 wpa_printf(MSG_DEBUG, "P2P: Remove persistent group %d "
4000 "due to invitation result", ssid->id);
4001 wpas_notify_network_removed(wpa_s, ssid);
4002 wpa_config_remove_network(wpa_s->conf, ssid->id);
4003 return;
4004 }
4005 return; /* Peer not found in client list */
4006 }
4007
4008 wpa_printf(MSG_DEBUG, "P2P: Remove peer " MACSTR " from persistent "
4009 "group %d client list%s",
4010 MAC2STR(peer), ssid->id,
4011 inv ? " due to invitation result" : "");
4012 os_memmove(ssid->p2p_client_list + i * 2 * ETH_ALEN,
4013 ssid->p2p_client_list + (i + 1) * 2 * ETH_ALEN,
4014 (ssid->num_p2p_clients - i - 1) * 2 * ETH_ALEN);
4015 ssid->num_p2p_clients--;
4016 if (p2p_wpa_s->conf->update_config &&
4017 wpa_config_write(p2p_wpa_s->confname, p2p_wpa_s->conf))
4018 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
4019 }
4020
4021
wpas_remove_persistent_client(struct wpa_supplicant * wpa_s,const u8 * peer)4022 static void wpas_remove_persistent_client(struct wpa_supplicant *wpa_s,
4023 const u8 *peer)
4024 {
4025 struct wpa_ssid *ssid;
4026
4027 wpa_s = wpa_s->global->p2p_invite_group;
4028 if (wpa_s == NULL)
4029 return; /* No known invitation group */
4030 ssid = wpa_s->current_ssid;
4031 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
4032 !ssid->p2p_persistent_group)
4033 return; /* Not operating as a GO in persistent group */
4034 ssid = wpas_p2p_get_persistent(wpa_s->p2pdev, peer,
4035 ssid->ssid, ssid->ssid_len);
4036 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
4037 }
4038
4039
wpas_msg_p2p_invitation_result(struct wpa_supplicant * wpa_s,int status,const u8 * new_ssid,size_t new_ssid_len,const u8 * bssid,const u8 * go_dev_addr)4040 static void wpas_msg_p2p_invitation_result(struct wpa_supplicant *wpa_s,
4041 int status, const u8 *new_ssid,
4042 size_t new_ssid_len, const u8 *bssid,
4043 const u8 *go_dev_addr)
4044 {
4045 int res;
4046 char buf[500];
4047 char *pos, *end;
4048 const char *ssid_txt = NULL;
4049
4050 pos = buf;
4051 end = buf + sizeof(buf);
4052
4053 if (go_dev_addr && new_ssid && new_ssid_len) {
4054 ssid_txt = wpa_ssid_txt(new_ssid, new_ssid_len);
4055 } else if (go_dev_addr) {
4056 struct wpa_ssid *ssid;
4057
4058 ssid = wpa_config_get_network(wpa_s->conf,
4059 wpa_s->pending_invite_ssid_id);
4060 if (ssid)
4061 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
4062 }
4063
4064 res = os_snprintf(pos, end - pos, "status=%d", status);
4065 if (os_snprintf_error(end - pos, res))
4066 goto fail;
4067 pos += res;
4068
4069 if (bssid) {
4070 res = os_snprintf(pos, end - pos, " " MACSTR, MAC2STR(bssid));
4071 if (os_snprintf_error(end - pos, res))
4072 goto fail;
4073 pos += res;
4074 }
4075
4076 if (ssid_txt) {
4077 res = os_snprintf(pos, end - pos, " ssid=\"%s\"", ssid_txt);
4078 if (os_snprintf_error(end - pos, res))
4079 goto fail;
4080 pos += res;
4081 }
4082
4083 if (go_dev_addr) {
4084 res = os_snprintf(pos, end - pos, " go_dev_addr=" MACSTR,
4085 MAC2STR(go_dev_addr));
4086 if (os_snprintf_error(end - pos, res))
4087 goto fail;
4088 pos += res;
4089 }
4090
4091 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT "%s", buf);
4092 return;
4093
4094 fail:
4095 wpa_printf(MSG_DEBUG,
4096 "P2P: Failed to send P2P-INVITATION-RESULT message");
4097 }
4098
4099
wpas_invitation_result(void * ctx,int status,const u8 * new_ssid,size_t new_ssid_len,const u8 * bssid,const struct p2p_channels * channels,const u8 * peer,int neg_freq,int peer_oper_freq,const u8 * pmkid,const u8 * pmk,size_t pmk_len,const u8 * go_dev_addr)4100 static void wpas_invitation_result(void *ctx, int status, const u8 *new_ssid,
4101 size_t new_ssid_len, const u8 *bssid,
4102 const struct p2p_channels *channels,
4103 const u8 *peer, int neg_freq,
4104 int peer_oper_freq, const u8 *pmkid,
4105 const u8 *pmk, size_t pmk_len,
4106 const u8 *go_dev_addr)
4107 {
4108 struct wpa_supplicant *wpa_s = ctx;
4109 struct wpa_ssid *ssid;
4110 int freq;
4111
4112 #ifdef CONFIG_PASN
4113 if (wpa_s->p2p_pasn_auth_work) {
4114 wpas_p2p_pasn_cancel_auth_work(wpa_s);
4115 wpa_s->p2p_pasn_auth_work = NULL;
4116 }
4117 #endif /* CONFIG_PASN */
4118
4119 wpas_msg_p2p_invitation_result(wpa_s, status, new_ssid, new_ssid_len,
4120 bssid, go_dev_addr);
4121 wpas_notify_p2p_invitation_result(wpa_s, status, bssid);
4122
4123 wpa_printf(MSG_DEBUG, "P2P: Invitation result - status=%d peer=" MACSTR,
4124 status, MAC2STR(peer));
4125 if (wpa_s->pending_invite_ssid_id == -1) {
4126 struct wpa_supplicant *group_if =
4127 wpa_s->global->p2p_invite_group;
4128
4129 if (status == P2P_SC_FAIL_UNKNOWN_GROUP)
4130 wpas_remove_persistent_client(wpa_s, peer);
4131
4132 /*
4133 * Invitation to an active group. If this is successful and we
4134 * are the GO, set the client wait to postpone some concurrent
4135 * operations and to allow provisioning and connection to happen
4136 * more quickly.
4137 */
4138 if (status == P2P_SC_SUCCESS &&
4139 group_if && group_if->current_ssid &&
4140 group_if->current_ssid->mode == WPAS_MODE_P2P_GO) {
4141 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
4142 #ifdef CONFIG_TESTING_OPTIONS
4143 if (group_if->p2p_go_csa_on_inv) {
4144 wpa_printf(MSG_DEBUG,
4145 "Testing: force P2P GO CSA after invitation");
4146 eloop_cancel_timeout(
4147 wpas_p2p_reconsider_moving_go,
4148 wpa_s, NULL);
4149 eloop_register_timeout(
4150 0, 50000,
4151 wpas_p2p_reconsider_moving_go,
4152 wpa_s, NULL);
4153 }
4154 #endif /* CONFIG_TESTING_OPTIONS */
4155 }
4156 return;
4157 }
4158
4159 if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
4160 wpa_printf(MSG_DEBUG, "P2P: Waiting for peer to start another "
4161 "invitation exchange to indicate readiness for "
4162 "re-invocation");
4163 }
4164
4165 if (status != P2P_SC_SUCCESS) {
4166 if (status == P2P_SC_FAIL_UNKNOWN_GROUP) {
4167 ssid = wpa_config_get_network(
4168 wpa_s->conf, wpa_s->pending_invite_ssid_id);
4169 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
4170 }
4171 wpas_p2p_remove_pending_group_interface(wpa_s);
4172 return;
4173 }
4174
4175 ssid = wpa_config_get_network(wpa_s->conf,
4176 wpa_s->pending_invite_ssid_id);
4177 if (ssid == NULL) {
4178 wpa_printf(MSG_ERROR, "P2P: Could not find persistent group "
4179 "data matching with invitation");
4180 return;
4181 }
4182
4183 if (new_ssid && new_ssid_len) {
4184 os_free(ssid->ssid);
4185 ssid->ssid = os_memdup(new_ssid, new_ssid_len);
4186 if (!ssid->ssid) {
4187 ssid->ssid_len = 0;
4188 return;
4189 }
4190 ssid->ssid_len = new_ssid_len;
4191 }
4192
4193 /*
4194 * The peer could have missed our ctrl::ack frame for Invitation
4195 * Response and continue retransmitting the frame. To reduce the
4196 * likelihood of the peer not getting successful TX status for the
4197 * Invitation Response frame, wait a short time here before starting
4198 * the persistent group so that we will remain on the current channel to
4199 * acknowledge any possible retransmission from the peer.
4200 */
4201 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 50 ms wait on current channel before "
4202 "starting persistent group");
4203 os_sleep(0, 50000);
4204
4205 if (neg_freq > 0 && ssid->mode == WPAS_MODE_P2P_GO &&
4206 freq_included(wpa_s, channels, neg_freq))
4207 freq = neg_freq;
4208 else if (peer_oper_freq > 0 && ssid->mode != WPAS_MODE_P2P_GO &&
4209 freq_included(wpa_s, channels, peer_oper_freq))
4210 freq = peer_oper_freq;
4211 else
4212 freq = 0;
4213
4214 wpa_printf(MSG_DEBUG, "P2P: Persistent group invitation success - op_freq=%d MHz SSID=%s",
4215 freq, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
4216 wpas_p2p_group_add_persistent(wpa_s, ssid,
4217 ssid->mode == WPAS_MODE_P2P_GO,
4218 wpa_s->p2p_persistent_go_freq,
4219 freq,
4220 wpa_s->p2p_go_vht_center_freq2,
4221 wpa_s->p2p_go_ht40, wpa_s->p2p_go_vht,
4222 wpa_s->p2p_go_max_oper_chwidth,
4223 wpa_s->p2p_go_he,
4224 wpa_s->p2p_go_edmg,
4225 channels,
4226 ssid->mode == WPAS_MODE_P2P_GO ?
4227 P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE :
4228 0, 1,
4229 is_p2p_allow_6ghz(wpa_s->global->p2p), 0,
4230 bssid, peer, pmkid, pmk, pmk_len);
4231 }
4232
4233
wpas_p2p_disallowed_freq(struct wpa_global * global,unsigned int freq)4234 static int wpas_p2p_disallowed_freq(struct wpa_global *global,
4235 unsigned int freq)
4236 {
4237 if (freq_range_list_includes(&global->p2p_go_avoid_freq, freq))
4238 return 1;
4239 return freq_range_list_includes(&global->p2p_disallow_freq, freq);
4240 }
4241
4242
wpas_p2p_add_chan(struct p2p_reg_class * reg,u8 chan)4243 static void wpas_p2p_add_chan(struct p2p_reg_class *reg, u8 chan)
4244 {
4245 reg->channel[reg->channels] = chan;
4246 reg->channels++;
4247 }
4248
4249
wpas_p2p_default_channels(struct wpa_supplicant * wpa_s,struct p2p_channels * chan,struct p2p_channels * cli_chan)4250 static int wpas_p2p_default_channels(struct wpa_supplicant *wpa_s,
4251 struct p2p_channels *chan,
4252 struct p2p_channels *cli_chan)
4253 {
4254 int i, cla = 0;
4255
4256 wpa_s->global->p2p_24ghz_social_channels = 1;
4257
4258 os_memset(cli_chan, 0, sizeof(*cli_chan));
4259
4260 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for 2.4 GHz "
4261 "band");
4262
4263 /* Operating class 81 - 2.4 GHz band channels 1..13 */
4264 chan->reg_class[cla].reg_class = 81;
4265 chan->reg_class[cla].channels = 0;
4266 for (i = 0; i < 11; i++) {
4267 if (!wpas_p2p_disallowed_freq(wpa_s->global, 2412 + i * 5))
4268 wpas_p2p_add_chan(&chan->reg_class[cla], i + 1);
4269 }
4270 if (chan->reg_class[cla].channels)
4271 cla++;
4272
4273 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for lower 5 GHz "
4274 "band");
4275
4276 /* Operating class 115 - 5 GHz, channels 36-48 */
4277 chan->reg_class[cla].reg_class = 115;
4278 chan->reg_class[cla].channels = 0;
4279 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5))
4280 wpas_p2p_add_chan(&chan->reg_class[cla], 36);
4281 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5))
4282 wpas_p2p_add_chan(&chan->reg_class[cla], 40);
4283 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5))
4284 wpas_p2p_add_chan(&chan->reg_class[cla], 44);
4285 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5))
4286 wpas_p2p_add_chan(&chan->reg_class[cla], 48);
4287 if (chan->reg_class[cla].channels)
4288 cla++;
4289
4290 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for higher 5 GHz "
4291 "band");
4292
4293 /* Operating class 124 - 5 GHz, channels 149,153,157,161 */
4294 chan->reg_class[cla].reg_class = 124;
4295 chan->reg_class[cla].channels = 0;
4296 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5))
4297 wpas_p2p_add_chan(&chan->reg_class[cla], 149);
4298 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5))
4299 wpas_p2p_add_chan(&chan->reg_class[cla], 153);
4300 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5))
4301 wpas_p2p_add_chan(&chan->reg_class[cla], 157);
4302 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5))
4303 wpas_p2p_add_chan(&chan->reg_class[cla], 161);
4304 if (chan->reg_class[cla].channels)
4305 cla++;
4306
4307 chan->reg_classes = cla;
4308 return 0;
4309 }
4310
4311
has_channel(struct wpa_global * global,struct hostapd_hw_modes * mode,u8 op_class,u8 chan,int * flags)4312 static enum chan_allowed has_channel(struct wpa_global *global,
4313 struct hostapd_hw_modes *mode, u8 op_class,
4314 u8 chan, int *flags)
4315 {
4316 int i;
4317 unsigned int freq;
4318
4319 freq = ieee80211_chan_to_freq(NULL, op_class, chan);
4320 if (wpas_p2p_disallowed_freq(global, freq))
4321 return NOT_ALLOWED;
4322
4323 for (i = 0; i < mode->num_channels; i++) {
4324 if ((unsigned int) mode->channels[i].freq == freq) {
4325 if (flags)
4326 *flags = mode->channels[i].flag;
4327 if (mode->channels[i].flag & HOSTAPD_CHAN_DISABLED)
4328 return NOT_ALLOWED;
4329 if (mode->channels[i].flag & HOSTAPD_CHAN_NO_IR)
4330 return NO_IR;
4331 if (mode->channels[i].flag & HOSTAPD_CHAN_RADAR)
4332 return RADAR;
4333 return ALLOWED;
4334 }
4335 }
4336
4337 return NOT_ALLOWED;
4338 }
4339
4340
wpas_p2p_get_center_80mhz(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 channel,const u8 * center_channels,size_t num_chan)4341 static int wpas_p2p_get_center_80mhz(struct wpa_supplicant *wpa_s,
4342 struct hostapd_hw_modes *mode,
4343 u8 channel, const u8 *center_channels,
4344 size_t num_chan)
4345 {
4346 size_t i;
4347
4348 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
4349 return 0;
4350
4351 for (i = 0; i < num_chan; i++)
4352 /*
4353 * In 80 MHz, the bandwidth "spans" 12 channels (e.g., 36-48),
4354 * so the center channel is 6 channels away from the start/end.
4355 */
4356 if (channel >= center_channels[i] - 6 &&
4357 channel <= center_channels[i] + 6)
4358 return center_channels[i];
4359
4360 return 0;
4361 }
4362
4363
4364 static const u8 center_channels_5ghz_80mhz[] = { 42, 58, 106, 122, 138,
4365 155, 171 };
4366 static const u8 center_channels_6ghz_80mhz[] = { 7, 23, 39, 55, 71, 87, 103,
4367 119, 135, 151, 167, 183, 199,
4368 215 };
4369
wpas_p2p_verify_80mhz(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 op_class,u8 channel,u8 bw)4370 static enum chan_allowed wpas_p2p_verify_80mhz(struct wpa_supplicant *wpa_s,
4371 struct hostapd_hw_modes *mode,
4372 u8 op_class, u8 channel, u8 bw)
4373 {
4374 u8 center_chan;
4375 int i, flags;
4376 enum chan_allowed res, ret = ALLOWED;
4377 const u8 *chans;
4378 size_t num_chans;
4379 bool is_6ghz = is_6ghz_op_class(op_class);
4380
4381 if (is_6ghz) {
4382 chans = center_channels_6ghz_80mhz;
4383 num_chans = ARRAY_SIZE(center_channels_6ghz_80mhz);
4384 } else {
4385 chans = center_channels_5ghz_80mhz;
4386 num_chans = ARRAY_SIZE(center_channels_5ghz_80mhz);
4387 }
4388 center_chan = wpas_p2p_get_center_80mhz(wpa_s, mode, channel,
4389 chans, num_chans);
4390 if (!center_chan)
4391 return NOT_ALLOWED;
4392 if (!wpa_s->p2p_go_allow_dfs &&
4393 !is_6ghz && center_chan >= 58 && center_chan <= 138)
4394 return NOT_ALLOWED; /* Do not allow DFS channels for P2P */
4395
4396 /* check all the channels are available */
4397 for (i = 0; i < 4; i++) {
4398 int adj_chan = center_chan - 6 + i * 4;
4399
4400 res = has_channel(wpa_s->global, mode, op_class, adj_chan,
4401 &flags);
4402 if (res == NOT_ALLOWED)
4403 return NOT_ALLOWED;
4404 if (res == RADAR)
4405 ret = RADAR;
4406 if (res == NO_IR)
4407 ret = NO_IR;
4408 if (!is_6ghz) {
4409 if (!(flags & HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL))
4410 return NOT_ALLOWED;
4411 } else if (is_6ghz &&
4412 (!(wpas_get_6ghz_he_chwidth_capab(mode) &
4413 HE_PHYCAP_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G))) {
4414 return NOT_ALLOWED;
4415 }
4416 }
4417
4418 return ret;
4419 }
4420
4421
wpas_p2p_get_center_160mhz(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 channel,const u8 * center_channels,size_t num_chan)4422 static int wpas_p2p_get_center_160mhz(struct wpa_supplicant *wpa_s,
4423 struct hostapd_hw_modes *mode,
4424 u8 channel, const u8 *center_channels,
4425 size_t num_chan)
4426 {
4427 unsigned int i;
4428
4429 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
4430 return 0;
4431
4432 for (i = 0; i < num_chan; i++)
4433 /*
4434 * In 160 MHz, the bandwidth "spans" 28 channels (e.g., 36-64),
4435 * so the center channel is 14 channels away from the start/end.
4436 */
4437 if (channel >= center_channels[i] - 14 &&
4438 channel <= center_channels[i] + 14)
4439 return center_channels[i];
4440
4441 return 0;
4442 }
4443
4444
4445 static const u8 center_channels_5ghz_160mhz[] = { 50, 114, 163 };
4446 static const u8 center_channels_6ghz_160mhz[] = { 15, 47, 79, 111, 143, 175,
4447 207 };
4448
wpas_p2p_verify_160mhz(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 op_class,u8 channel,u8 bw)4449 static enum chan_allowed wpas_p2p_verify_160mhz(struct wpa_supplicant *wpa_s,
4450 struct hostapd_hw_modes *mode,
4451 u8 op_class, u8 channel, u8 bw)
4452 {
4453 u8 center_chan;
4454 int i, flags;
4455 enum chan_allowed res, ret = ALLOWED;
4456 const u8 *chans;
4457 size_t num_chans;
4458
4459 if (is_6ghz_op_class(op_class)) {
4460 chans = center_channels_6ghz_160mhz;
4461 num_chans = ARRAY_SIZE(center_channels_6ghz_160mhz);
4462 } else {
4463 chans = center_channels_5ghz_160mhz;
4464 num_chans = ARRAY_SIZE(center_channels_5ghz_160mhz);
4465 }
4466 center_chan = wpas_p2p_get_center_160mhz(wpa_s, mode, channel,
4467 chans, num_chans);
4468 if (!center_chan)
4469 return NOT_ALLOWED;
4470 /* VHT 160 MHz uses DFS channels in most countries. */
4471
4472 /* Check all the channels are available */
4473 for (i = 0; i < 8; i++) {
4474 int adj_chan = center_chan - 14 + i * 4;
4475
4476 res = has_channel(wpa_s->global, mode, op_class, adj_chan,
4477 &flags);
4478 if (res == NOT_ALLOWED)
4479 return NOT_ALLOWED;
4480
4481 if (res == RADAR)
4482 ret = RADAR;
4483 if (res == NO_IR)
4484 ret = NO_IR;
4485
4486 if (!is_6ghz_op_class(op_class)) {
4487 if (!(flags & HOSTAPD_CHAN_VHT_80MHZ_SUBCHANNEL) ||
4488 !(flags & HOSTAPD_CHAN_VHT_160MHZ_SUBCHANNEL))
4489 return NOT_ALLOWED;
4490 } else if (is_6ghz_op_class(op_class) &&
4491 (!(wpas_get_6ghz_he_chwidth_capab(mode) &
4492 HE_PHYCAP_CHANNEL_WIDTH_SET_160MHZ_IN_5G))) {
4493 return NOT_ALLOWED;
4494 }
4495 }
4496
4497 return ret;
4498 }
4499
4500
wpas_p2p_verify_edmg(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 channel)4501 static enum chan_allowed wpas_p2p_verify_edmg(struct wpa_supplicant *wpa_s,
4502 struct hostapd_hw_modes *mode,
4503 u8 channel)
4504 {
4505 struct ieee80211_edmg_config edmg;
4506
4507 hostapd_encode_edmg_chan(1, channel, 0, &edmg);
4508 if (edmg.channels && ieee802_edmg_is_allowed(mode->edmg, edmg))
4509 return ALLOWED;
4510
4511 return NOT_ALLOWED;
4512 }
4513
4514
wpas_p2p_verify_channel(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 op_class,u8 channel,u8 bw)4515 static enum chan_allowed wpas_p2p_verify_channel(struct wpa_supplicant *wpa_s,
4516 struct hostapd_hw_modes *mode,
4517 u8 op_class, u8 channel, u8 bw)
4518 {
4519 int flag = 0;
4520 enum chan_allowed res, res2;
4521
4522 if (is_6ghz_op_class(op_class) && !is_6ghz_psc_frequency(
4523 p2p_channel_to_freq(op_class, channel)))
4524 return NOT_ALLOWED;
4525
4526 res2 = res = has_channel(wpa_s->global, mode, op_class, channel, &flag);
4527 if (bw == BW40MINUS) {
4528 if (!(flag & HOSTAPD_CHAN_HT40MINUS))
4529 return NOT_ALLOWED;
4530 res2 = has_channel(wpa_s->global, mode, op_class, channel - 4,
4531 NULL);
4532 } else if (bw == BW40PLUS) {
4533 if (!(flag & HOSTAPD_CHAN_HT40PLUS))
4534 return NOT_ALLOWED;
4535 res2 = has_channel(wpa_s->global, mode, op_class, channel + 4,
4536 NULL);
4537 } else if (is_6ghz_op_class(op_class) && bw == BW40) {
4538 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
4539 return NOT_ALLOWED;
4540 if (get_6ghz_sec_channel(channel) < 0)
4541 res2 = has_channel(wpa_s->global, mode, op_class,
4542 channel - 4, NULL);
4543 else
4544 res2 = has_channel(wpa_s->global, mode, op_class,
4545 channel + 4, NULL);
4546 } else if (bw == BW80) {
4547 res2 = wpas_p2p_verify_80mhz(wpa_s, mode, op_class, channel,
4548 bw);
4549 } else if (bw == BW160) {
4550 res2 = wpas_p2p_verify_160mhz(wpa_s, mode, op_class, channel,
4551 bw);
4552 } else if (bw == BW4320 || bw == BW6480 || bw == BW8640) {
4553 return wpas_p2p_verify_edmg(wpa_s, mode, channel);
4554 }
4555
4556 if (res == NOT_ALLOWED || res2 == NOT_ALLOWED)
4557 return NOT_ALLOWED;
4558 if (res == NO_IR || res2 == NO_IR)
4559 return NO_IR;
4560 if (res == RADAR || res2 == RADAR)
4561 return RADAR;
4562 return res;
4563 }
4564
4565
wpas_p2p_setup_channels(struct wpa_supplicant * wpa_s,struct p2p_channels * chan,struct p2p_channels * cli_chan,bool p2p_disable_6ghz)4566 static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s,
4567 struct p2p_channels *chan,
4568 struct p2p_channels *cli_chan,
4569 bool p2p_disable_6ghz)
4570 {
4571 struct hostapd_hw_modes *mode;
4572 int cla, op, cli_cla;
4573
4574 if (wpa_s->hw.modes == NULL) {
4575 wpa_printf(MSG_DEBUG, "P2P: Driver did not support fetching "
4576 "of all supported channels; assume dualband "
4577 "support");
4578 return wpas_p2p_default_channels(wpa_s, chan, cli_chan);
4579 }
4580
4581 cla = cli_cla = 0;
4582
4583 for (op = 0; global_op_class[op].op_class; op++) {
4584 const struct oper_class_map *o = &global_op_class[op];
4585 unsigned int ch;
4586 struct p2p_reg_class *reg = NULL, *cli_reg = NULL;
4587
4588 if (o->p2p == NO_P2P_SUPP ||
4589 (is_6ghz_op_class(o->op_class) && p2p_disable_6ghz))
4590 continue;
4591
4592 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode,
4593 is_6ghz_op_class(o->op_class));
4594 if (mode == NULL)
4595 continue;
4596 if (mode->mode == HOSTAPD_MODE_IEEE80211G)
4597 wpa_s->global->p2p_24ghz_social_channels = 1;
4598 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
4599 enum chan_allowed res;
4600
4601 /* Check for non-continuous jump in channel index
4602 * incrementation */
4603 if ((o->op_class >= 128 && o->op_class <= 130) &&
4604 ch < 149 && ch + o->inc > 149)
4605 ch = 149;
4606
4607 res = wpas_p2p_verify_channel(wpa_s, mode, o->op_class,
4608 ch, o->bw);
4609 if (res == ALLOWED) {
4610 if (reg == NULL) {
4611 if (cla == P2P_MAX_REG_CLASSES)
4612 continue;
4613 wpa_printf(MSG_DEBUG, "P2P: Add operating class %u",
4614 o->op_class);
4615 reg = &chan->reg_class[cla];
4616 cla++;
4617 reg->reg_class = o->op_class;
4618 }
4619 if (reg->channels == P2P_MAX_REG_CLASS_CHANNELS)
4620 continue;
4621 reg->channel[reg->channels] = ch;
4622 reg->channels++;
4623 } else if (res == NO_IR &&
4624 wpa_s->conf->p2p_add_cli_chan) {
4625 if (cli_reg == NULL) {
4626 if (cli_cla == P2P_MAX_REG_CLASSES)
4627 continue;
4628 wpa_printf(MSG_DEBUG, "P2P: Add operating class %u (client only)",
4629 o->op_class);
4630 cli_reg = &cli_chan->reg_class[cli_cla];
4631 cli_cla++;
4632 cli_reg->reg_class = o->op_class;
4633 }
4634 if (cli_reg->channels ==
4635 P2P_MAX_REG_CLASS_CHANNELS)
4636 continue;
4637 cli_reg->channel[cli_reg->channels] = ch;
4638 cli_reg->channels++;
4639 }
4640 }
4641 if (reg) {
4642 wpa_hexdump(MSG_DEBUG, "P2P: Channels",
4643 reg->channel, reg->channels);
4644 }
4645 if (cli_reg) {
4646 wpa_hexdump(MSG_DEBUG, "P2P: Channels (client only)",
4647 cli_reg->channel, cli_reg->channels);
4648 }
4649 }
4650
4651 chan->reg_classes = cla;
4652 cli_chan->reg_classes = cli_cla;
4653
4654 return 0;
4655 }
4656
4657
wpas_p2p_get_sec_channel_offset_40mhz(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 channel)4658 int wpas_p2p_get_sec_channel_offset_40mhz(struct wpa_supplicant *wpa_s,
4659 struct hostapd_hw_modes *mode,
4660 u8 channel)
4661 {
4662 int op;
4663 enum chan_allowed ret;
4664
4665 for (op = 0; global_op_class[op].op_class; op++) {
4666 const struct oper_class_map *o = &global_op_class[op];
4667 u16 ch = 0;
4668
4669 /* Allow DFS channels marked as NO_P2P_SUPP to be used with
4670 * driver offloaded DFS. */
4671 if ((o->p2p == NO_P2P_SUPP &&
4672 (!is_dfs_global_op_class(o->op_class) ||
4673 !wpa_s->p2p_go_allow_dfs)) ||
4674 (is_6ghz_op_class(o->op_class) &&
4675 wpa_s->conf->p2p_6ghz_disable))
4676 continue;
4677
4678 /* IEEE Std 802.11ax-2021 26.17.2.3.2: "A 6 GHz-only AP should
4679 * set up the BSS with a primary 20 MHz channel that coincides
4680 * with a preferred scanning channel (PSC)."
4681 * 6 GHz BW40 operation class 132 in wpa_supplicant uses the
4682 * lowest 20 MHz channel for simplicity, so increase ch by 4 to
4683 * match the PSC.
4684 */
4685 if (is_6ghz_op_class(o->op_class) && o->bw == BW40 &&
4686 get_6ghz_sec_channel(channel) < 0)
4687 ch = 4;
4688
4689 for (ch += o->min_chan; ch <= o->max_chan; ch += o->inc) {
4690 if (o->mode != HOSTAPD_MODE_IEEE80211A ||
4691 (o->bw != BW40PLUS && o->bw != BW40MINUS &&
4692 o->bw != BW40) ||
4693 ch != channel)
4694 continue;
4695 ret = wpas_p2p_verify_channel(wpa_s, mode, o->op_class,
4696 ch, o->bw);
4697 if (ret == ALLOWED) {
4698 if (is_6ghz_op_class(o->op_class) &&
4699 o->bw == BW40)
4700 return get_6ghz_sec_channel(channel);
4701 return (o->bw == BW40MINUS) ? -1 : 1;
4702 }
4703 if (ret == RADAR && wpa_s->p2p_go_allow_dfs) {
4704 /* Allow RADAR channels used for driver
4705 * offloaded DFS */
4706 return (o->bw == BW40MINUS) ? -1 : 1;
4707 }
4708 }
4709 }
4710 return 0;
4711 }
4712
4713
wpas_p2p_get_vht80_center(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 channel,u8 op_class)4714 int wpas_p2p_get_vht80_center(struct wpa_supplicant *wpa_s,
4715 struct hostapd_hw_modes *mode, u8 channel,
4716 u8 op_class)
4717 {
4718 const u8 *chans;
4719 size_t num_chans;
4720 enum chan_allowed ret;
4721
4722 ret = wpas_p2p_verify_channel(wpa_s, mode, op_class, channel, BW80);
4723 if (!(ret == ALLOWED || (ret == RADAR && wpa_s->p2p_go_allow_dfs)))
4724 return 0;
4725
4726 if (is_6ghz_op_class(op_class)) {
4727 chans = center_channels_6ghz_80mhz;
4728 num_chans = ARRAY_SIZE(center_channels_6ghz_80mhz);
4729 } else {
4730 chans = center_channels_5ghz_80mhz;
4731 num_chans = ARRAY_SIZE(center_channels_5ghz_80mhz);
4732 }
4733 return wpas_p2p_get_center_80mhz(wpa_s, mode, channel,
4734 chans, num_chans);
4735 }
4736
4737
wpas_p2p_get_vht160_center(struct wpa_supplicant * wpa_s,struct hostapd_hw_modes * mode,u8 channel,u8 op_class)4738 int wpas_p2p_get_vht160_center(struct wpa_supplicant *wpa_s,
4739 struct hostapd_hw_modes *mode, u8 channel,
4740 u8 op_class)
4741 {
4742 const u8 *chans;
4743 size_t num_chans;
4744 enum chan_allowed ret;
4745
4746 ret = wpas_p2p_verify_channel(wpa_s, mode, op_class, channel, BW160);
4747 if (!(ret == ALLOWED || (ret == RADAR && wpa_s->p2p_go_allow_dfs)))
4748 return 0;
4749 if (is_6ghz_op_class(op_class)) {
4750 chans = center_channels_6ghz_160mhz;
4751 num_chans = ARRAY_SIZE(center_channels_6ghz_160mhz);
4752 } else {
4753 chans = center_channels_5ghz_160mhz;
4754 num_chans = ARRAY_SIZE(center_channels_5ghz_160mhz);
4755 }
4756 return wpas_p2p_get_center_160mhz(wpa_s, mode, channel,
4757 chans, num_chans);
4758 }
4759
4760
wpas_get_noa(void * ctx,const u8 * interface_addr,u8 * buf,size_t buf_len)4761 static int wpas_get_noa(void *ctx, const u8 *interface_addr, u8 *buf,
4762 size_t buf_len)
4763 {
4764 struct wpa_supplicant *wpa_s = ctx;
4765
4766 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4767 if (ether_addr_equal(wpa_s->own_addr, interface_addr))
4768 break;
4769 }
4770 if (wpa_s == NULL)
4771 return -1;
4772
4773 return wpa_drv_get_noa(wpa_s, buf, buf_len);
4774 }
4775
4776
wpas_get_p2p_go_iface(struct wpa_supplicant * wpa_s,const u8 * ssid,size_t ssid_len)4777 struct wpa_supplicant * wpas_get_p2p_go_iface(struct wpa_supplicant *wpa_s,
4778 const u8 *ssid, size_t ssid_len)
4779 {
4780 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4781 struct wpa_ssid *s = wpa_s->current_ssid;
4782 if (s == NULL)
4783 continue;
4784 if (s->mode != WPAS_MODE_P2P_GO &&
4785 s->mode != WPAS_MODE_AP &&
4786 s->mode != WPAS_MODE_P2P_GROUP_FORMATION)
4787 continue;
4788 if (s->ssid_len != ssid_len ||
4789 os_memcmp(ssid, s->ssid, ssid_len) != 0)
4790 continue;
4791 return wpa_s;
4792 }
4793
4794 return NULL;
4795
4796 }
4797
4798
wpas_get_p2p_client_iface(struct wpa_supplicant * wpa_s,const u8 * peer_dev_addr)4799 struct wpa_supplicant * wpas_get_p2p_client_iface(struct wpa_supplicant *wpa_s,
4800 const u8 *peer_dev_addr)
4801 {
4802 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4803 struct wpa_ssid *ssid = wpa_s->current_ssid;
4804 if (ssid && (ssid->mode != WPAS_MODE_INFRA || !ssid->p2p_group))
4805 continue;
4806 if (ether_addr_equal(wpa_s->go_dev_addr, peer_dev_addr))
4807 return wpa_s;
4808 }
4809
4810 return NULL;
4811 }
4812
4813
wpas_go_connected(void * ctx,const u8 * dev_addr)4814 static int wpas_go_connected(void *ctx, const u8 *dev_addr)
4815 {
4816 struct wpa_supplicant *wpa_s = ctx;
4817
4818 return wpas_get_p2p_client_iface(wpa_s, dev_addr) != NULL;
4819 }
4820
4821
wpas_is_concurrent_session_active(void * ctx)4822 static int wpas_is_concurrent_session_active(void *ctx)
4823 {
4824 struct wpa_supplicant *wpa_s = ctx;
4825 struct wpa_supplicant *ifs;
4826
4827 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
4828 if (ifs == wpa_s)
4829 continue;
4830 if (ifs->wpa_state > WPA_ASSOCIATED)
4831 return 1;
4832 }
4833 return 0;
4834 }
4835
4836
wpas_p2p_debug_print(void * ctx,int level,const char * msg)4837 static void wpas_p2p_debug_print(void *ctx, int level, const char *msg)
4838 {
4839 struct wpa_supplicant *wpa_s = ctx;
4840 wpa_msg_global(wpa_s, level, "P2P: %s", msg);
4841 }
4842
4843
wpas_p2p_add_p2pdev_interface(struct wpa_supplicant * wpa_s,const char * conf_p2p_dev)4844 int wpas_p2p_add_p2pdev_interface(struct wpa_supplicant *wpa_s,
4845 const char *conf_p2p_dev)
4846 {
4847 struct wpa_interface iface;
4848 struct wpa_supplicant *p2pdev_wpa_s;
4849 char ifname[100];
4850 char force_name[100];
4851 int ret;
4852 const u8 *if_addr = NULL;
4853
4854 ret = os_snprintf(ifname, sizeof(ifname), P2P_MGMT_DEVICE_PREFIX "%s",
4855 wpa_s->ifname);
4856 if (os_snprintf_error(sizeof(ifname), ret))
4857 return -1;
4858 /* Cut length at the maximum size. Note that we don't need to ensure
4859 * collision free names here as the created interface is not a netdev.
4860 */
4861 ifname[IFNAMSIZ - 1] = '\0';
4862 force_name[0] = '\0';
4863 wpa_s->pending_interface_type = WPA_IF_P2P_DEVICE;
4864
4865 if (wpa_s->conf->p2p_device_random_mac_addr == 2 &&
4866 !is_zero_ether_addr(wpa_s->conf->p2p_device_persistent_mac_addr))
4867 if_addr = wpa_s->conf->p2p_device_persistent_mac_addr;
4868
4869 ret = wpa_drv_if_add(wpa_s, WPA_IF_P2P_DEVICE, ifname, if_addr, NULL,
4870 force_name, wpa_s->pending_interface_addr, NULL);
4871 if (ret < 0) {
4872 wpa_printf(MSG_DEBUG, "P2P: Failed to create P2P Device interface");
4873 return ret;
4874 }
4875 os_strlcpy(wpa_s->pending_interface_name, ifname,
4876 sizeof(wpa_s->pending_interface_name));
4877
4878 os_memset(&iface, 0, sizeof(iface));
4879 iface.p2p_mgmt = 1;
4880 iface.ifname = wpa_s->pending_interface_name;
4881 iface.driver = wpa_s->driver->name;
4882 iface.driver_param = wpa_s->conf->driver_param;
4883
4884 /*
4885 * If a P2P Device configuration file was given, use it as the interface
4886 * configuration file (instead of using parent's configuration file.
4887 */
4888 if (conf_p2p_dev) {
4889 iface.confname = conf_p2p_dev;
4890 iface.ctrl_interface = NULL;
4891 } else {
4892 iface.confname = wpa_s->confname;
4893 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
4894 }
4895
4896 p2pdev_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface, wpa_s);
4897 if (!p2pdev_wpa_s) {
4898 wpa_printf(MSG_DEBUG, "P2P: Failed to add P2P Device interface");
4899 return -1;
4900 }
4901
4902 p2pdev_wpa_s->p2pdev = p2pdev_wpa_s;
4903 wpa_s->pending_interface_name[0] = '\0';
4904 return 0;
4905 }
4906
4907
wpas_presence_resp(void * ctx,const u8 * src,u8 status,const u8 * noa,size_t noa_len)4908 static void wpas_presence_resp(void *ctx, const u8 *src, u8 status,
4909 const u8 *noa, size_t noa_len)
4910 {
4911 struct wpa_supplicant *wpa_s, *intf = ctx;
4912 char hex[100];
4913
4914 for (wpa_s = intf->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4915 if (wpa_s->waiting_presence_resp)
4916 break;
4917 }
4918 if (!wpa_s) {
4919 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No group interface was waiting for presence response");
4920 return;
4921 }
4922 wpa_s->waiting_presence_resp = 0;
4923
4924 wpa_snprintf_hex(hex, sizeof(hex), noa, noa_len);
4925 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PRESENCE_RESPONSE "src=" MACSTR
4926 " status=%u noa=%s", MAC2STR(src), status, hex);
4927 }
4928
4929
wpas_get_persistent_group(void * ctx,const u8 * addr,const u8 * ssid,size_t ssid_len,u8 * go_dev_addr,u8 * ret_ssid,size_t * ret_ssid_len,u8 * intended_iface_addr)4930 static int wpas_get_persistent_group(void *ctx, const u8 *addr, const u8 *ssid,
4931 size_t ssid_len, u8 *go_dev_addr,
4932 u8 *ret_ssid, size_t *ret_ssid_len,
4933 u8 *intended_iface_addr)
4934 {
4935 struct wpa_supplicant *wpa_s = ctx;
4936 struct wpa_ssid *s;
4937
4938 s = wpas_p2p_get_persistent(wpa_s, addr, ssid, ssid_len);
4939 if (s) {
4940 os_memcpy(ret_ssid, s->ssid, s->ssid_len);
4941 *ret_ssid_len = s->ssid_len;
4942 os_memcpy(go_dev_addr, s->bssid, ETH_ALEN);
4943
4944 if (s->mode != WPAS_MODE_P2P_GO) {
4945 os_memset(intended_iface_addr, 0, ETH_ALEN);
4946 } else if (wpas_p2p_create_iface(wpa_s)) {
4947 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO))
4948 return 0;
4949
4950 os_memcpy(intended_iface_addr,
4951 wpa_s->pending_interface_addr, ETH_ALEN);
4952 } else {
4953 os_memcpy(intended_iface_addr, wpa_s->own_addr,
4954 ETH_ALEN);
4955 }
4956 return 1;
4957 }
4958
4959 return 0;
4960 }
4961
4962
wpas_get_go_info(void * ctx,u8 * intended_addr,u8 * ssid,size_t * ssid_len,int * group_iface,unsigned int * freq)4963 static int wpas_get_go_info(void *ctx, u8 *intended_addr,
4964 u8 *ssid, size_t *ssid_len, int *group_iface,
4965 unsigned int *freq)
4966 {
4967 struct wpa_supplicant *wpa_s = ctx;
4968 struct wpa_supplicant *go;
4969 struct wpa_ssid *s;
4970
4971 /*
4972 * group_iface will be set to 1 only if a dedicated interface for P2P
4973 * role is required. First, we try to reuse an active GO. However,
4974 * if it is not present, we will try to reactivate an existing
4975 * persistent group and set group_iface to 1, so the caller will know
4976 * that the pending interface should be used.
4977 */
4978 *group_iface = 0;
4979
4980 if (freq)
4981 *freq = 0;
4982
4983 go = wpas_p2p_get_go_group(wpa_s);
4984 if (!go) {
4985 s = wpas_p2p_get_persistent_go(wpa_s);
4986 *group_iface = wpas_p2p_create_iface(wpa_s);
4987 if (s)
4988 os_memcpy(intended_addr, s->bssid, ETH_ALEN);
4989 else
4990 return 0;
4991 } else {
4992 s = go->current_ssid;
4993 os_memcpy(intended_addr, go->own_addr, ETH_ALEN);
4994 if (freq)
4995 *freq = go->assoc_freq;
4996 }
4997
4998 os_memcpy(ssid, s->ssid, s->ssid_len);
4999 *ssid_len = s->ssid_len;
5000
5001 return 1;
5002 }
5003
5004
wpas_remove_stale_groups(void * ctx,const u8 * peer,const u8 * go,const u8 * ssid,size_t ssid_len)5005 static int wpas_remove_stale_groups(void *ctx, const u8 *peer, const u8 *go,
5006 const u8 *ssid, size_t ssid_len)
5007 {
5008 struct wpa_supplicant *wpa_s = ctx;
5009 struct wpa_ssid *s;
5010 int save_config = 0;
5011 size_t i;
5012
5013 /* Start with our first choice of Persistent Groups */
5014 while ((s = wpas_p2p_get_persistent(wpa_s, peer, NULL, 0))) {
5015 if (go && ssid && ssid_len &&
5016 s->ssid_len == ssid_len &&
5017 ether_addr_equal(go, s->bssid) &&
5018 os_memcmp(ssid, s->ssid, ssid_len) == 0)
5019 break;
5020
5021 /* Remove stale persistent group */
5022 if (s->mode != WPAS_MODE_P2P_GO || s->num_p2p_clients <= 1) {
5023 wpa_dbg(wpa_s, MSG_DEBUG,
5024 "P2P: Remove stale persistent group id=%d",
5025 s->id);
5026 wpas_notify_persistent_group_removed(wpa_s, s);
5027 wpa_config_remove_network(wpa_s->conf, s->id);
5028 save_config = 1;
5029 continue;
5030 }
5031
5032 for (i = 0; i < s->num_p2p_clients; i++) {
5033 if (!ether_addr_equal(s->p2p_client_list +
5034 i * 2 * ETH_ALEN, peer))
5035 continue;
5036
5037 os_memmove(s->p2p_client_list + i * 2 * ETH_ALEN,
5038 s->p2p_client_list + (i + 1) * 2 * ETH_ALEN,
5039 (s->num_p2p_clients - i - 1) * 2 * ETH_ALEN);
5040 break;
5041 }
5042 s->num_p2p_clients--;
5043 save_config = 1;
5044 }
5045
5046 if (save_config)
5047 p2p_config_write(wpa_s);
5048
5049 /* Return TRUE if valid SSID remains */
5050 return s != NULL;
5051 }
5052
5053
wpas_p2ps_get_feat_cap_str(char * buf,size_t buf_len,const u8 * feat_cap,size_t feat_cap_len)5054 static void wpas_p2ps_get_feat_cap_str(char *buf, size_t buf_len,
5055 const u8 *feat_cap, size_t feat_cap_len)
5056 {
5057 static const char pref[] = " feature_cap=";
5058 int ret;
5059
5060 buf[0] = '\0';
5061
5062 /*
5063 * We expect a feature capability to contain at least one byte to be
5064 * reported. The string buffer provided by the caller function is
5065 * expected to be big enough to contain all bytes of the attribute for
5066 * known specifications. This function truncates the reported bytes if
5067 * the feature capability data exceeds the string buffer size.
5068 */
5069 if (!feat_cap || !feat_cap_len || buf_len < sizeof(pref) + 2)
5070 return;
5071
5072 os_memcpy(buf, pref, sizeof(pref));
5073 ret = wpa_snprintf_hex(&buf[sizeof(pref) - 1],
5074 buf_len - sizeof(pref) + 1,
5075 feat_cap, feat_cap_len);
5076
5077 if (ret != (2 * (int) feat_cap_len))
5078 wpa_printf(MSG_WARNING, "P2PS feature_cap bytes truncated");
5079 }
5080
5081
wpas_p2ps_prov_complete(void * ctx,enum p2p_status_code status,const u8 * dev,const u8 * adv_mac,const u8 * ses_mac,const u8 * grp_mac,u32 adv_id,u32 ses_id,u8 conncap,int passwd_id,const u8 * persist_ssid,size_t persist_ssid_size,int response_done,int prov_start,const char * session_info,const u8 * feat_cap,size_t feat_cap_len,unsigned int freq,const u8 * group_ssid,size_t group_ssid_len)5082 static void wpas_p2ps_prov_complete(void *ctx, enum p2p_status_code status,
5083 const u8 *dev,
5084 const u8 *adv_mac, const u8 *ses_mac,
5085 const u8 *grp_mac, u32 adv_id, u32 ses_id,
5086 u8 conncap, int passwd_id,
5087 const u8 *persist_ssid,
5088 size_t persist_ssid_size, int response_done,
5089 int prov_start, const char *session_info,
5090 const u8 *feat_cap, size_t feat_cap_len,
5091 unsigned int freq,
5092 const u8 *group_ssid, size_t group_ssid_len)
5093 {
5094 struct wpa_supplicant *wpa_s = ctx;
5095 u8 mac[ETH_ALEN];
5096 struct wpa_ssid *persistent_go, *stale, *s = NULL;
5097 int save_config = 0;
5098 struct wpa_supplicant *go_wpa_s;
5099 char feat_cap_str[256];
5100
5101 if (!dev)
5102 return;
5103
5104 os_memset(mac, 0, ETH_ALEN);
5105 if (!adv_mac)
5106 adv_mac = mac;
5107 if (!ses_mac)
5108 ses_mac = mac;
5109 if (!grp_mac)
5110 grp_mac = mac;
5111
5112 wpas_p2ps_get_feat_cap_str(feat_cap_str, sizeof(feat_cap_str),
5113 feat_cap, feat_cap_len);
5114
5115 if (prov_start) {
5116 if (session_info == NULL) {
5117 wpa_msg_global(wpa_s, MSG_INFO,
5118 P2P_EVENT_P2PS_PROVISION_START MACSTR
5119 " adv_id=%x conncap=%x"
5120 " adv_mac=" MACSTR
5121 " session=%x mac=" MACSTR
5122 " dev_passwd_id=%d%s",
5123 MAC2STR(dev), adv_id, conncap,
5124 MAC2STR(adv_mac),
5125 ses_id, MAC2STR(ses_mac),
5126 passwd_id, feat_cap_str);
5127 } else {
5128 wpa_msg_global(wpa_s, MSG_INFO,
5129 P2P_EVENT_P2PS_PROVISION_START MACSTR
5130 " adv_id=%x conncap=%x"
5131 " adv_mac=" MACSTR
5132 " session=%x mac=" MACSTR
5133 " dev_passwd_id=%d info='%s'%s",
5134 MAC2STR(dev), adv_id, conncap,
5135 MAC2STR(adv_mac),
5136 ses_id, MAC2STR(ses_mac),
5137 passwd_id, session_info, feat_cap_str);
5138 }
5139 return;
5140 }
5141
5142 go_wpa_s = wpas_p2p_get_go_group(wpa_s);
5143 persistent_go = wpas_p2p_get_persistent_go(wpa_s);
5144
5145 if (status && status != P2P_SC_SUCCESS_DEFERRED) {
5146 if (go_wpa_s && !p2p_group_go_member_count(wpa_s))
5147 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
5148
5149 if (persistent_go && !persistent_go->num_p2p_clients) {
5150 /* remove empty persistent GO */
5151 wpa_dbg(wpa_s, MSG_DEBUG,
5152 "P2P: Remove empty persistent group id=%d",
5153 persistent_go->id);
5154 wpas_notify_persistent_group_removed(wpa_s,
5155 persistent_go);
5156 wpa_config_remove_network(wpa_s->conf,
5157 persistent_go->id);
5158 }
5159
5160 wpa_msg_global(wpa_s, MSG_INFO,
5161 P2P_EVENT_P2PS_PROVISION_DONE MACSTR
5162 " status=%d"
5163 " adv_id=%x adv_mac=" MACSTR
5164 " session=%x mac=" MACSTR "%s",
5165 MAC2STR(dev), status,
5166 adv_id, MAC2STR(adv_mac),
5167 ses_id, MAC2STR(ses_mac), feat_cap_str);
5168 return;
5169 }
5170
5171 /* Clean up stale persistent groups with this device */
5172 if (persist_ssid && persist_ssid_size)
5173 s = wpas_p2p_get_persistent(wpa_s, dev, persist_ssid,
5174 persist_ssid_size);
5175
5176 if (persist_ssid && s && s->mode != WPAS_MODE_P2P_GO &&
5177 is_zero_ether_addr(grp_mac)) {
5178 wpa_dbg(wpa_s, MSG_ERROR,
5179 "P2P: Peer device is a GO in a persistent group, but it did not provide the intended MAC address");
5180 return;
5181 }
5182
5183 for (;;) {
5184 stale = wpas_p2p_get_persistent(wpa_s, dev, NULL, 0);
5185 if (!stale)
5186 break;
5187
5188 if (s && s->ssid_len == stale->ssid_len &&
5189 ether_addr_equal(stale->bssid, s->bssid) &&
5190 os_memcmp(stale->ssid, s->ssid, s->ssid_len) == 0)
5191 break;
5192
5193 /* Remove stale persistent group */
5194 if (stale->mode != WPAS_MODE_P2P_GO ||
5195 stale->num_p2p_clients <= 1) {
5196 wpa_dbg(wpa_s, MSG_DEBUG,
5197 "P2P: Remove stale persistent group id=%d",
5198 stale->id);
5199 wpas_notify_persistent_group_removed(wpa_s, stale);
5200 wpa_config_remove_network(wpa_s->conf, stale->id);
5201 } else {
5202 size_t i;
5203
5204 for (i = 0; i < stale->num_p2p_clients; i++) {
5205 if (ether_addr_equal(stale->p2p_client_list +
5206 i * ETH_ALEN, dev)) {
5207 os_memmove(stale->p2p_client_list +
5208 i * ETH_ALEN,
5209 stale->p2p_client_list +
5210 (i + 1) * ETH_ALEN,
5211 (stale->num_p2p_clients -
5212 i - 1) * ETH_ALEN);
5213 break;
5214 }
5215 }
5216 stale->num_p2p_clients--;
5217 }
5218 save_config = 1;
5219 }
5220
5221 if (save_config)
5222 p2p_config_write(wpa_s);
5223
5224 if (s) {
5225 if (go_wpa_s && !p2p_group_go_member_count(wpa_s))
5226 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
5227
5228 if (persistent_go && s != persistent_go &&
5229 !persistent_go->num_p2p_clients) {
5230 /* remove empty persistent GO */
5231 wpa_dbg(wpa_s, MSG_DEBUG,
5232 "P2P: Remove empty persistent group id=%d",
5233 persistent_go->id);
5234 wpas_notify_persistent_group_removed(wpa_s,
5235 persistent_go);
5236 wpa_config_remove_network(wpa_s->conf,
5237 persistent_go->id);
5238 /* Save config */
5239 }
5240
5241 wpa_msg_global(wpa_s, MSG_INFO,
5242 P2P_EVENT_P2PS_PROVISION_DONE MACSTR
5243 " status=%d"
5244 " adv_id=%x adv_mac=" MACSTR
5245 " session=%x mac=" MACSTR
5246 " persist=%d%s",
5247 MAC2STR(dev), status,
5248 adv_id, MAC2STR(adv_mac),
5249 ses_id, MAC2STR(ses_mac), s->id, feat_cap_str);
5250 return;
5251 }
5252
5253 wpa_s->global->pending_p2ps_group = 0;
5254 wpa_s->global->pending_p2ps_group_freq = 0;
5255
5256 if (conncap == P2PS_SETUP_GROUP_OWNER) {
5257 /*
5258 * We need to copy the interface name. Simply saving a
5259 * pointer isn't enough, since if we use pending_interface_name
5260 * it will be overwritten when the group is added.
5261 */
5262 char go_ifname[100];
5263
5264 go_ifname[0] = '\0';
5265 if (!go_wpa_s) {
5266 if (!response_done) {
5267 wpa_s->global->pending_p2ps_group = 1;
5268 wpa_s->global->pending_p2ps_group_freq = freq;
5269 }
5270
5271 if (!wpas_p2p_create_iface(wpa_s))
5272 os_memcpy(go_ifname, wpa_s->ifname,
5273 sizeof(go_ifname));
5274 else if (wpa_s->pending_interface_name[0])
5275 os_memcpy(go_ifname,
5276 wpa_s->pending_interface_name,
5277 sizeof(go_ifname));
5278
5279 if (!go_ifname[0]) {
5280 wpas_p2ps_prov_complete(
5281 wpa_s, P2P_SC_FAIL_UNKNOWN_GROUP,
5282 dev, adv_mac, ses_mac,
5283 grp_mac, adv_id, ses_id, 0, 0,
5284 NULL, 0, 0, 0, NULL, NULL, 0, 0,
5285 NULL, 0);
5286 return;
5287 }
5288
5289 /* If PD Resp complete, start up the GO */
5290 if (response_done && persistent_go) {
5291 wpas_p2p_group_add_persistent(
5292 wpa_s, persistent_go,
5293 0, 0, freq, 0, 0, 0, 0, 0, 0, NULL,
5294 persistent_go->mode ==
5295 WPAS_MODE_P2P_GO ?
5296 P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE :
5297 0, 0, false, 0, NULL, NULL, NULL, NULL,
5298 0);
5299 } else if (response_done) {
5300 wpas_p2p_group_add(wpa_s, 1, freq,
5301 0, 0, 0, 0, 0, 0, false,
5302 wpa_s->p2p2,
5303 WPA_P2P_MODE_WFD_R1);
5304 }
5305
5306 if (passwd_id == DEV_PW_P2PS_DEFAULT) {
5307 os_memcpy(wpa_s->p2ps_join_addr, grp_mac,
5308 ETH_ALEN);
5309 wpa_s->p2ps_method_config_any = 1;
5310 }
5311 } else if (passwd_id == DEV_PW_P2PS_DEFAULT) {
5312 os_memcpy(go_ifname, go_wpa_s->ifname,
5313 sizeof(go_ifname));
5314
5315 if (is_zero_ether_addr(grp_mac)) {
5316 wpa_dbg(go_wpa_s, MSG_DEBUG,
5317 "P2P: Setting PIN-1 for ANY");
5318 wpa_supplicant_ap_wps_pin(go_wpa_s, NULL,
5319 "12345670", NULL, 0,
5320 0);
5321 } else {
5322 wpa_dbg(go_wpa_s, MSG_DEBUG,
5323 "P2P: Setting PIN-1 for " MACSTR,
5324 MAC2STR(grp_mac));
5325 wpa_supplicant_ap_wps_pin(go_wpa_s, grp_mac,
5326 "12345670", NULL, 0,
5327 0);
5328 }
5329
5330 os_memcpy(wpa_s->p2ps_join_addr, grp_mac, ETH_ALEN);
5331 wpa_s->p2ps_method_config_any = 1;
5332 }
5333
5334 wpa_msg_global(wpa_s, MSG_INFO,
5335 P2P_EVENT_P2PS_PROVISION_DONE MACSTR
5336 " status=%d conncap=%x"
5337 " adv_id=%x adv_mac=" MACSTR
5338 " session=%x mac=" MACSTR
5339 " dev_passwd_id=%d go=%s%s",
5340 MAC2STR(dev), status, conncap,
5341 adv_id, MAC2STR(adv_mac),
5342 ses_id, MAC2STR(ses_mac),
5343 passwd_id, go_ifname, feat_cap_str);
5344 return;
5345 }
5346
5347 if (go_wpa_s && !p2p_group_go_member_count(wpa_s))
5348 wpas_p2p_group_remove(wpa_s, go_wpa_s->ifname);
5349
5350 if (persistent_go && !persistent_go->num_p2p_clients) {
5351 /* remove empty persistent GO */
5352 wpa_dbg(wpa_s, MSG_DEBUG,
5353 "P2P: Remove empty persistent group id=%d",
5354 persistent_go->id);
5355 wpas_notify_persistent_group_removed(wpa_s, persistent_go);
5356 wpa_config_remove_network(wpa_s->conf, persistent_go->id);
5357 }
5358
5359 if (conncap == P2PS_SETUP_CLIENT) {
5360 char ssid_hex[32 * 2 + 1];
5361
5362 if (group_ssid)
5363 wpa_snprintf_hex(ssid_hex, sizeof(ssid_hex),
5364 group_ssid, group_ssid_len);
5365 else
5366 ssid_hex[0] = '\0';
5367 wpa_msg_global(wpa_s, MSG_INFO,
5368 P2P_EVENT_P2PS_PROVISION_DONE MACSTR
5369 " status=%d conncap=%x"
5370 " adv_id=%x adv_mac=" MACSTR
5371 " session=%x mac=" MACSTR
5372 " dev_passwd_id=%d join=" MACSTR "%s%s%s",
5373 MAC2STR(dev), status, conncap,
5374 adv_id, MAC2STR(adv_mac),
5375 ses_id, MAC2STR(ses_mac),
5376 passwd_id, MAC2STR(grp_mac), feat_cap_str,
5377 group_ssid ? " group_ssid=" : "", ssid_hex);
5378 } else {
5379 wpa_msg_global(wpa_s, MSG_INFO,
5380 P2P_EVENT_P2PS_PROVISION_DONE MACSTR
5381 " status=%d conncap=%x"
5382 " adv_id=%x adv_mac=" MACSTR
5383 " session=%x mac=" MACSTR
5384 " dev_passwd_id=%d%s",
5385 MAC2STR(dev), status, conncap,
5386 adv_id, MAC2STR(adv_mac),
5387 ses_id, MAC2STR(ses_mac),
5388 passwd_id, feat_cap_str);
5389 }
5390 }
5391
5392
_wpas_p2p_in_progress(void * ctx)5393 static int _wpas_p2p_in_progress(void *ctx)
5394 {
5395 struct wpa_supplicant *wpa_s = ctx;
5396 return wpas_p2p_in_progress(wpa_s);
5397 }
5398
5399
wpas_prov_disc_resp_cb(void * ctx)5400 static int wpas_prov_disc_resp_cb(void *ctx)
5401 {
5402 struct wpa_supplicant *wpa_s = ctx;
5403 struct wpa_ssid *persistent_go;
5404 unsigned int freq;
5405
5406 if (!wpa_s->global->pending_p2ps_group)
5407 return 0;
5408
5409 freq = wpa_s->global->pending_p2ps_group_freq;
5410 wpa_s->global->pending_p2ps_group_freq = 0;
5411 wpa_s->global->pending_p2ps_group = 0;
5412
5413 if (wpas_p2p_get_go_group(wpa_s))
5414 return 0;
5415 persistent_go = wpas_p2p_get_persistent_go(wpa_s);
5416
5417 if (persistent_go) {
5418 wpas_p2p_group_add_persistent(
5419 wpa_s, persistent_go, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5420 NULL,
5421 persistent_go->mode == WPAS_MODE_P2P_GO ?
5422 P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE : 0, 0,
5423 is_p2p_allow_6ghz(wpa_s->global->p2p), 0, NULL, NULL,
5424 NULL, NULL, 0);
5425 } else {
5426 wpas_p2p_group_add(wpa_s, 1, freq, 0, 0, 0, 0, 0, 0,
5427 is_p2p_allow_6ghz(wpa_s->global->p2p),
5428 wpa_s->p2p2, WPA_P2P_MODE_WFD_R1);
5429 }
5430
5431 return 1;
5432 }
5433
5434
wpas_p2p_get_pref_freq_list(void * ctx,int go,unsigned int * len,struct weighted_pcl * freq_list)5435 static int wpas_p2p_get_pref_freq_list(void *ctx, int go,
5436 unsigned int *len,
5437 struct weighted_pcl *freq_list)
5438 {
5439 struct wpa_supplicant *wpa_s = ctx;
5440
5441 return wpa_drv_get_pref_freq_list(wpa_s, go ? WPA_IF_P2P_GO :
5442 WPA_IF_P2P_CLIENT, len, freq_list);
5443 }
5444
5445
wpas_p2p_send_bootstrap_comeback(void * eloop_ctx,void * timeout_ctx)5446 static void wpas_p2p_send_bootstrap_comeback(void *eloop_ctx, void *timeout_ctx)
5447 {
5448 struct wpa_supplicant *wpa_s = eloop_ctx;
5449
5450 wpa_printf(MSG_DEBUG, "P2P2: Send bootstrapping comeback PD Request");
5451
5452 if (wpa_s->p2p_pd_before_go_neg) {
5453 wpas_p2p_connect(wpa_s, wpa_s->p2p_bootstrap_dev_addr,
5454 wpa_s->p2p_pin, wpa_s->p2p_wps_method,
5455 wpa_s->p2p_persistent_group, 0, 0, 0,
5456 wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
5457 wpa_s->p2p_go_vht_center_freq2,
5458 wpa_s->p2p_persistent_id, 1,
5459 wpa_s->p2p_go_ht40,
5460 wpa_s->p2p_go_vht,
5461 wpa_s->p2p_go_max_oper_chwidth,
5462 wpa_s->p2p_go_he,
5463 wpa_s->p2p_go_edmg,
5464 NULL, 0, is_p2p_allow_6ghz(wpa_s->global->p2p),
5465 wpa_s->p2p2, wpa_s->p2p_bootstrap, NULL,
5466 false);
5467 } else {
5468 p2p_prov_disc_req(wpa_s->global->p2p,
5469 wpa_s->p2p_bootstrap_dev_addr, NULL,
5470 0, 0, 0, 1);
5471 }
5472 }
5473
5474
wpas_p2p_register_bootstrap_comeback(void * ctx,const u8 * addr,u16 comeback_after)5475 static void wpas_p2p_register_bootstrap_comeback(void *ctx, const u8 *addr,
5476 u16 comeback_after)
5477 {
5478 unsigned int timeout_us;
5479 struct wpa_supplicant *wpa_s = ctx;
5480
5481 timeout_us = comeback_after * 1024;
5482 os_memcpy(wpa_s->p2p_bootstrap_dev_addr, addr, ETH_ALEN);
5483
5484 eloop_cancel_timeout(wpas_p2p_send_bootstrap_comeback, wpa_s, NULL);
5485 eloop_register_timeout(0, timeout_us, wpas_p2p_send_bootstrap_comeback,
5486 wpa_s, NULL);
5487 }
5488
5489
wpas_bootstrap_req_rx(void * ctx,const u8 * addr,u16 bootstrap_method)5490 static void wpas_bootstrap_req_rx(void *ctx, const u8 *addr,
5491 u16 bootstrap_method)
5492 {
5493 struct wpa_supplicant *wpa_s = ctx;
5494
5495 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_BOOTSTRAP_REQUEST MACSTR
5496 " bootstrap_method=%u", MAC2STR(addr), bootstrap_method);
5497
5498 wpas_notify_p2p_bootstrap_req(wpa_s, addr, bootstrap_method);
5499 }
5500
5501
wpas_bootstrap_rsp_rx(void * ctx,const u8 * addr,enum p2p_status_code status,int freq,u16 bootstrap_method)5502 static void wpas_bootstrap_rsp_rx(void *ctx, const u8 *addr,
5503 enum p2p_status_code status, int freq,
5504 u16 bootstrap_method)
5505 {
5506 struct wpa_supplicant *wpa_s = ctx;
5507
5508 wpas_notify_p2p_bootstrap_rsp(wpa_s, addr, status, bootstrap_method);
5509
5510 if (status) {
5511 wpa_msg_global(wpa_s, MSG_INFO,
5512 P2P_EVENT_BOOTSTRAP_FAILURE MACSTR " status=%d",
5513 MAC2STR(addr), status);
5514 return;
5515 }
5516
5517 wpa_msg_global(wpa_s, MSG_INFO,
5518 P2P_EVENT_BOOTSTRAP_SUCCESS MACSTR " status=%d",
5519 MAC2STR(addr), status);
5520
5521 #ifdef CONFIG_PASN
5522 if (wpa_s->p2p_pd_before_go_neg)
5523 wpas_p2p_initiate_pasn_auth(wpa_s, addr, freq);
5524 #endif /* CONFIG_PASN */
5525 }
5526
5527
wpas_validate_dira(void * ctx,const u8 * peer_addr,const u8 * dira_nonce,const u8 * dira_tag)5528 static int wpas_validate_dira(void *ctx, const u8 *peer_addr,
5529 const u8 *dira_nonce, const u8 *dira_tag)
5530 {
5531 struct wpa_supplicant *wpa_s = ctx;
5532 int ret;
5533 u8 tag[DEVICE_MAX_HASH_LEN];
5534 struct wpa_dev_ik *ik;
5535 const u8 *addr[3];
5536 size_t len[3];
5537 const char *label = "DIR";
5538
5539 addr[0] = (const u8 *) label;
5540 len[0] = DIR_STR_LEN;
5541 addr[1] = peer_addr;
5542 len[1] = ETH_ALEN;
5543 addr[2] = dira_nonce;
5544 len[2] = DEVICE_IDENTITY_NONCE_LEN;
5545
5546 for (ik = wpa_s->conf->identity; ik; ik = ik->next) {
5547 if (wpabuf_len(ik->dik) != DEVICE_IDENTITY_KEY_LEN ||
5548 ik->dik_cipher != DIRA_CIPHER_VERSION_128)
5549 continue;
5550
5551 ret = hmac_sha256_vector(wpabuf_head(ik->dik),
5552 DEVICE_IDENTITY_KEY_LEN,
5553 3, addr, len, tag);
5554 if (ret < 0) {
5555 wpa_printf(MSG_ERROR,
5556 "P2P2: Failed to derive DIRA Tag");
5557 return 0;
5558 }
5559
5560 if (os_memcmp(tag, dira_tag, DEVICE_IDENTITY_TAG_LEN) == 0) {
5561 wpa_printf(MSG_DEBUG, "P2P2: DIRA Tag matched");
5562 break;
5563 }
5564 }
5565
5566 if (!ik)
5567 return 0;
5568
5569 #ifdef CONFIG_PASN
5570 p2p_pasn_pmksa_set_pmk(wpa_s->global->p2p, wpa_s->global->p2p_dev_addr,
5571 peer_addr,
5572 wpabuf_head(ik->pmk), wpabuf_len(ik->pmk),
5573 wpabuf_head(ik->pmkid));
5574 #endif /* CONFIG_PASN */
5575
5576 return ik->id;
5577 }
5578
5579
5580 #ifdef CONFIG_PASN
5581
wpas_p2p_initiate_pasn_verify(struct wpa_supplicant * wpa_s,const u8 * peer,enum p2p_invite_role role,const u8 * bssid,const u8 * ssid,size_t ssid_len,unsigned int force_freq,const u8 * go_dev_addr,unsigned int pref_freq)5582 static int wpas_p2p_initiate_pasn_verify(struct wpa_supplicant *wpa_s,
5583 const u8 *peer,
5584 enum p2p_invite_role role,
5585 const u8 *bssid, const u8 *ssid,
5586 size_t ssid_len,
5587 unsigned int force_freq,
5588 const u8 *go_dev_addr,
5589 unsigned int pref_freq)
5590 {
5591 int freq;
5592 struct wpa_p2p_pasn_auth_work *awork;
5593
5594 wpas_p2p_pasn_cancel_auth_work(wpa_s);
5595 wpa_s->p2p_pasn_auth_work = NULL;
5596
5597 freq = p2p_get_listen_freq(wpa_s->global->p2p, peer);
5598 if (freq == -1)
5599 return -1;
5600
5601 awork = os_zalloc(sizeof(*awork));
5602 if (!awork)
5603 return -1;
5604
5605 awork->verify = 1;
5606 awork->role = role;
5607 awork->freq = freq;
5608 awork->force_freq = force_freq;
5609 awork->pref_freq = pref_freq;
5610 os_memcpy(awork->peer_addr, peer, ETH_ALEN);
5611 if (go_dev_addr)
5612 os_memcpy(awork->go_dev_addr, go_dev_addr, ETH_ALEN);
5613 if (bssid)
5614 os_memcpy(awork->bssid, bssid, ETH_ALEN);
5615 if (ssid_len) {
5616 awork->ssid = os_zalloc(ssid_len);
5617 if (!awork->ssid) {
5618 os_free(awork);
5619 return -1;
5620 }
5621 os_memcpy(awork->ssid, ssid, ssid_len);
5622 awork->ssid_len = ssid_len;
5623 }
5624
5625 if (radio_add_work(wpa_s, freq, "p2p-pasn-start-auth", 1,
5626 wpas_p2p_pasn_auth_start_cb, awork) < 0) {
5627 wpas_p2p_pasn_free_auth_work(awork);
5628 return -1;
5629 }
5630
5631 wpa_printf(MSG_DEBUG, "P2P PASN: Auth work successfully added");
5632 return 0;
5633 }
5634
5635
wpas_p2p_pasn_send_mgmt(void * ctx,const u8 * data,size_t data_len,int noack,unsigned int freq,unsigned int wait)5636 static int wpas_p2p_pasn_send_mgmt(void *ctx, const u8 *data, size_t data_len,
5637 int noack, unsigned int freq,
5638 unsigned int wait)
5639 {
5640 struct wpa_supplicant *wpa_s = ctx;
5641
5642 return wpa_drv_send_mlme(wpa_s, data, data_len, noack, freq, wait);
5643 }
5644
5645
wpas_p2p_prepare_data_element(void * ctx,const u8 * peer_addr)5646 static int wpas_p2p_prepare_data_element(void *ctx, const u8 *peer_addr)
5647 {
5648 struct wpa_supplicant *wpa_s = ctx;
5649 struct p2p_data *p2p = wpa_s->global->p2p;
5650
5651 return p2p_prepare_data_element(p2p, peer_addr);
5652 }
5653
5654
wpas_p2p_parse_data_element(void * ctx,const u8 * data,size_t len)5655 static int wpas_p2p_parse_data_element(void *ctx, const u8 *data, size_t len)
5656 {
5657 struct wpa_supplicant *wpa_s = ctx;
5658 struct p2p_data *p2p = wpa_s->global->p2p;
5659
5660 return p2p_parse_data_element(p2p, data, len);
5661 }
5662
5663
wpas_p2p_pasn_validate_pmkid(void * ctx,const u8 * addr,const u8 * rsn_pmkid)5664 static int wpas_p2p_pasn_validate_pmkid(void *ctx, const u8 *addr,
5665 const u8 *rsn_pmkid)
5666 {
5667 struct wpa_supplicant *wpa_s = ctx;
5668
5669 return p2p_pasn_validate_and_update_pmkid(wpa_s->global->p2p, addr,
5670 rsn_pmkid);
5671 }
5672
5673 #endif /* CONFIG_PASN */
5674
5675
wpas_p2p_mac_setup(struct wpa_supplicant * wpa_s)5676 int wpas_p2p_mac_setup(struct wpa_supplicant *wpa_s)
5677 {
5678 u8 addr[ETH_ALEN] = {0};
5679
5680 if (wpa_s->conf->p2p_device_random_mac_addr == 0)
5681 return 0;
5682
5683 if (wpa_s->conf->p2p_device_random_mac_addr == 2) {
5684 if (is_zero_ether_addr(
5685 wpa_s->conf->p2p_device_persistent_mac_addr) &&
5686 !is_zero_ether_addr(wpa_s->own_addr)) {
5687 os_memcpy(wpa_s->conf->p2p_device_persistent_mac_addr,
5688 wpa_s->own_addr, ETH_ALEN);
5689 }
5690 return 0;
5691 }
5692
5693 if (!wpa_s->conf->ssid) {
5694 if (random_mac_addr(addr) < 0) {
5695 wpa_msg(wpa_s, MSG_INFO,
5696 "Failed to generate random MAC address");
5697 return -EINVAL;
5698 }
5699
5700 /* Store generated MAC address. */
5701 os_memcpy(wpa_s->conf->p2p_device_persistent_mac_addr, addr,
5702 ETH_ALEN);
5703 } else {
5704 /* If there are existing saved groups, restore last MAC address.
5705 * if there is no last used MAC address, the last one is
5706 * factory MAC. */
5707 if (is_zero_ether_addr(
5708 wpa_s->conf->p2p_device_persistent_mac_addr))
5709 return 0;
5710 os_memcpy(addr, wpa_s->conf->p2p_device_persistent_mac_addr,
5711 ETH_ALEN);
5712 wpa_msg(wpa_s, MSG_DEBUG, "Restore last used MAC address.");
5713 }
5714
5715 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) {
5716 wpa_msg(wpa_s, MSG_INFO,
5717 "Failed to set random MAC address");
5718 return -EINVAL;
5719 }
5720
5721 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) {
5722 wpa_msg(wpa_s, MSG_INFO,
5723 "Could not update MAC address information");
5724 return -EINVAL;
5725 }
5726
5727 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR,
5728 MAC2STR(addr));
5729
5730 return 0;
5731 }
5732
5733
5734 /**
5735 * wpas_p2p_init - Initialize P2P module for %wpa_supplicant
5736 * @global: Pointer to global data from wpa_supplicant_init()
5737 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5738 * Returns: 0 on success, -1 on failure
5739 */
wpas_p2p_init(struct wpa_global * global,struct wpa_supplicant * wpa_s)5740 int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
5741 {
5742 struct p2p_config p2p;
5743 int i;
5744
5745 if (wpa_s->conf->p2p_disabled)
5746 return 0;
5747
5748 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
5749 return 0;
5750
5751 if (global->p2p)
5752 return 0;
5753
5754 if (wpas_p2p_mac_setup(wpa_s) < 0) {
5755 wpa_msg(wpa_s, MSG_ERROR,
5756 "Failed to initialize P2P random MAC address.");
5757 return -1;
5758 }
5759
5760 os_memset(&p2p, 0, sizeof(p2p));
5761 p2p.cb_ctx = wpa_s;
5762 p2p.debug_print = wpas_p2p_debug_print;
5763 p2p.p2p_scan = wpas_p2p_scan;
5764 p2p.send_action = wpas_send_action;
5765 p2p.send_action_done = wpas_send_action_done;
5766 p2p.go_neg_completed = wpas_go_neg_completed;
5767 p2p.set_go_security_config = wpas_set_go_security_config;
5768 p2p.go_neg_req_rx = wpas_go_neg_req_rx;
5769 p2p.dev_found = wpas_dev_found;
5770 p2p.dev_lost = wpas_dev_lost;
5771 p2p.find_stopped = wpas_find_stopped;
5772 p2p.start_listen = wpas_start_listen;
5773 p2p.stop_listen = wpas_stop_listen;
5774 p2p.send_probe_resp = wpas_send_probe_resp;
5775 p2p.sd_request = wpas_sd_request;
5776 p2p.sd_response = wpas_sd_response;
5777 p2p.prov_disc_req = wpas_prov_disc_req;
5778 p2p.prov_disc_resp = wpas_prov_disc_resp;
5779 p2p.prov_disc_fail = wpas_prov_disc_fail;
5780 p2p.invitation_process = wpas_invitation_process;
5781 p2p.invitation_received = wpas_invitation_received;
5782 p2p.invitation_result = wpas_invitation_result;
5783 p2p.get_noa = wpas_get_noa;
5784 p2p.go_connected = wpas_go_connected;
5785 p2p.presence_resp = wpas_presence_resp;
5786 p2p.is_concurrent_session_active = wpas_is_concurrent_session_active;
5787 p2p.is_p2p_in_progress = _wpas_p2p_in_progress;
5788 p2p.get_persistent_group = wpas_get_persistent_group;
5789 p2p.get_go_info = wpas_get_go_info;
5790 p2p.remove_stale_groups = wpas_remove_stale_groups;
5791 p2p.p2ps_prov_complete = wpas_p2ps_prov_complete;
5792 p2p.prov_disc_resp_cb = wpas_prov_disc_resp_cb;
5793 p2p.p2ps_group_capability = p2ps_group_capability;
5794 p2p.get_pref_freq_list = wpas_p2p_get_pref_freq_list;
5795 p2p.p2p_6ghz_disable = wpa_s->conf->p2p_6ghz_disable;
5796 p2p.register_bootstrap_comeback = wpas_p2p_register_bootstrap_comeback;
5797 p2p.bootstrap_req_rx = wpas_bootstrap_req_rx;
5798 p2p.bootstrap_rsp_rx = wpas_bootstrap_rsp_rx;
5799 p2p.validate_dira = wpas_validate_dira;
5800 #ifdef CONFIG_PASN
5801 p2p.pasn_send_mgmt = wpas_p2p_pasn_send_mgmt;
5802 p2p.prepare_data_element = wpas_p2p_prepare_data_element;
5803 p2p.parse_data_element = wpas_p2p_parse_data_element;
5804 p2p.pasn_validate_pmkid = wpas_p2p_pasn_validate_pmkid;
5805 #endif /* CONFIG_PASN */
5806
5807 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
5808 os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN);
5809 p2p.dev_name = wpa_s->conf->device_name;
5810 p2p.manufacturer = wpa_s->conf->manufacturer;
5811 p2p.model_name = wpa_s->conf->model_name;
5812 p2p.model_number = wpa_s->conf->model_number;
5813 p2p.serial_number = wpa_s->conf->serial_number;
5814 if (wpa_s->wps) {
5815 os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16);
5816 p2p.config_methods = wpa_s->wps->config_methods;
5817 }
5818
5819 if (wpas_p2p_setup_channels(wpa_s, &p2p.channels, &p2p.cli_channels,
5820 p2p.p2p_6ghz_disable)) {
5821 wpa_printf(MSG_ERROR,
5822 "P2P: Failed to configure supported channel list");
5823 return -1;
5824 }
5825
5826 if (wpa_s->conf->p2p_listen_reg_class &&
5827 wpa_s->conf->p2p_listen_channel) {
5828 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
5829 p2p.channel = wpa_s->conf->p2p_listen_channel;
5830 p2p.channel_forced = 1;
5831 } else {
5832 /*
5833 * Pick one of the social channels randomly as the listen
5834 * channel.
5835 */
5836 if (p2p_config_get_random_social(&p2p, &p2p.reg_class,
5837 &p2p.channel,
5838 &global->p2p_go_avoid_freq,
5839 &global->p2p_disallow_freq) !=
5840 0) {
5841 wpa_printf(MSG_INFO,
5842 "P2P: No social channels supported by the driver - do not enable P2P");
5843 return 0;
5844 }
5845 p2p.channel_forced = 0;
5846 }
5847 wpa_printf(MSG_DEBUG, "P2P: Own listen channel: %d:%d",
5848 p2p.reg_class, p2p.channel);
5849
5850 if (wpa_s->conf->p2p_oper_reg_class &&
5851 wpa_s->conf->p2p_oper_channel) {
5852 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
5853 p2p.op_channel = wpa_s->conf->p2p_oper_channel;
5854 p2p.cfg_op_channel = 1;
5855 wpa_printf(MSG_DEBUG, "P2P: Configured operating channel: "
5856 "%d:%d", p2p.op_reg_class, p2p.op_channel);
5857
5858 } else {
5859 /*
5860 * Use random operation channel from 2.4 GHz band social
5861 * channels (1, 6, 11) or band 60 GHz social channel (2) if no
5862 * other preference is indicated.
5863 */
5864 if (p2p_config_get_random_social(&p2p, &p2p.op_reg_class,
5865 &p2p.op_channel, NULL,
5866 NULL) != 0) {
5867 wpa_printf(MSG_INFO,
5868 "P2P: Failed to select random social channel as operation channel");
5869 p2p.op_reg_class = 0;
5870 p2p.op_channel = 0;
5871 /* This will be overridden during group setup in
5872 * p2p_prepare_channel(), so allow setup to continue. */
5873 }
5874 p2p.cfg_op_channel = 0;
5875 wpa_printf(MSG_DEBUG, "P2P: Random operating channel: "
5876 "%d:%d", p2p.op_reg_class, p2p.op_channel);
5877 }
5878
5879 if (wpa_s->conf->p2p_pref_chan && wpa_s->conf->num_p2p_pref_chan) {
5880 p2p.pref_chan = wpa_s->conf->p2p_pref_chan;
5881 p2p.num_pref_chan = wpa_s->conf->num_p2p_pref_chan;
5882 }
5883
5884 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
5885 os_memcpy(p2p.country, wpa_s->conf->country, 2);
5886 p2p.country[2] = 0x04;
5887 } else
5888 os_memcpy(p2p.country, "XX\x04", 3);
5889
5890 os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type,
5891 WPS_DEV_TYPE_LEN);
5892
5893 p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
5894 os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type,
5895 p2p.num_sec_dev_types * WPS_DEV_TYPE_LEN);
5896
5897 p2p.concurrent_operations = !!(wpa_s->drv_flags &
5898 WPA_DRIVER_FLAGS_P2P_CONCURRENT);
5899
5900 p2p.max_peers = 100;
5901
5902 if (wpa_s->conf->p2p_ssid_postfix) {
5903 p2p.ssid_postfix_len =
5904 os_strlen(wpa_s->conf->p2p_ssid_postfix);
5905 if (p2p.ssid_postfix_len > sizeof(p2p.ssid_postfix))
5906 p2p.ssid_postfix_len = sizeof(p2p.ssid_postfix);
5907 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
5908 p2p.ssid_postfix_len);
5909 }
5910
5911 p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss;
5912
5913 p2p.max_listen = wpa_s->max_remain_on_chan;
5914
5915 if (wpa_s->conf->p2p_passphrase_len >= 8 &&
5916 wpa_s->conf->p2p_passphrase_len <= 63)
5917 p2p.passphrase_len = wpa_s->conf->p2p_passphrase_len;
5918 else
5919 p2p.passphrase_len = 8;
5920
5921 if (wpa_s->conf->dik &&
5922 wpabuf_len(wpa_s->conf->dik) <= DEVICE_IDENTITY_KEY_MAX_LEN) {
5923 p2p.pairing_config.dik_cipher = wpa_s->conf->dik_cipher;
5924 p2p.pairing_config.dik_len = wpabuf_len(wpa_s->conf->dik);
5925 os_memcpy(p2p.pairing_config.dik_data,
5926 wpabuf_head(wpa_s->conf->dik),
5927 p2p.pairing_config.dik_len);
5928 } else {
5929 p2p.pairing_config.dik_cipher = DIRA_CIPHER_VERSION_128;
5930 p2p.pairing_config.dik_len = DEVICE_IDENTITY_KEY_LEN;
5931 if (os_get_random(p2p.pairing_config.dik_data,
5932 p2p.pairing_config.dik_len) < 0)
5933 return -1;
5934
5935 wpa_s->conf->dik =
5936 wpabuf_alloc_copy(p2p.pairing_config.dik_data,
5937 p2p.pairing_config.dik_len);
5938 if (!wpa_s->conf->dik)
5939 return -1;
5940
5941 wpa_s->conf->dik_cipher = p2p.pairing_config.dik_cipher;
5942
5943 if (wpa_s->conf->update_config &&
5944 wpa_config_write(wpa_s->confname, wpa_s->conf))
5945 wpa_printf(MSG_DEBUG,
5946 "P2P: Failed to update configuration");
5947 }
5948
5949 p2p.pairing_config.enable_pairing_setup =
5950 wpa_s->conf->p2p_pairing_setup;
5951 p2p.pairing_config.enable_pairing_cache =
5952 wpa_s->conf->p2p_pairing_cache;
5953 p2p.pairing_config.bootstrap_methods =
5954 wpa_s->conf->p2p_bootstrap_methods;
5955 p2p.pairing_config.pasn_type = wpa_s->conf->p2p_pasn_type;
5956 p2p.comeback_after = wpa_s->conf->p2p_comeback_after;
5957 p2p.reg_info = wpa_s->conf->p2p_reg_info;
5958 p2p.twt_power_mgmt = wpa_s->conf->p2p_twt_power_mgmt;
5959 p2p.chan_switch_req_enable = wpa_s->conf->p2p_chan_switch_req_enable;
5960
5961 global->p2p = p2p_init(&p2p);
5962 if (global->p2p == NULL)
5963 return -1;
5964 global->p2p_init_wpa_s = wpa_s;
5965
5966 for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) {
5967 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
5968 continue;
5969 p2p_add_wps_vendor_extension(
5970 global->p2p, wpa_s->conf->wps_vendor_ext[i]);
5971 }
5972
5973 p2p_set_no_go_freq(global->p2p, &wpa_s->conf->p2p_no_go_freq);
5974
5975 return 0;
5976 }
5977
5978
5979 /**
5980 * wpas_p2p_deinit - Deinitialize per-interface P2P data
5981 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5982 *
5983 * This function deinitialize per-interface P2P data.
5984 */
wpas_p2p_deinit(struct wpa_supplicant * wpa_s)5985 void wpas_p2p_deinit(struct wpa_supplicant *wpa_s)
5986 {
5987 if (wpa_s->driver && wpa_s->drv_priv)
5988 wpa_drv_probe_req_report(wpa_s, 0);
5989
5990 if (wpa_s->go_params) {
5991 /* Clear any stored provisioning info */
5992 p2p_clear_provisioning_info(
5993 wpa_s->global->p2p,
5994 wpa_s->go_params->peer_device_addr);
5995 }
5996
5997 os_free(wpa_s->go_params);
5998 wpa_s->go_params = NULL;
5999 eloop_cancel_timeout(wpas_p2p_psk_failure_removal, wpa_s, NULL);
6000 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
6001 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
6002 wpa_s->global->p2p_long_listen = 0;
6003 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
6004 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
6005 wpas_p2p_remove_pending_group_interface(wpa_s);
6006 eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL);
6007 eloop_cancel_timeout(wpas_p2p_reconsider_moving_go, wpa_s, NULL);
6008 wpas_p2p_listen_work_done(wpa_s);
6009 if (wpa_s->p2p_send_action_work) {
6010 os_free(wpa_s->p2p_send_action_work->ctx);
6011 radio_work_done(wpa_s->p2p_send_action_work);
6012 wpa_s->p2p_send_action_work = NULL;
6013 }
6014 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, wpa_s, NULL);
6015 eloop_cancel_timeout(wpas_p2p_send_bootstrap_comeback, wpa_s, NULL);
6016
6017 wpabuf_free(wpa_s->p2p_oob_dev_pw);
6018 wpa_s->p2p_oob_dev_pw = NULL;
6019
6020 os_free(wpa_s->p2p_group_common_freqs);
6021 wpa_s->p2p_group_common_freqs = NULL;
6022 wpa_s->p2p_group_common_freqs_num = 0;
6023
6024 /* TODO: remove group interface from the driver if this wpa_s instance
6025 * is on top of a P2P group interface */
6026 }
6027
6028
6029 /**
6030 * wpas_p2p_deinit_global - Deinitialize global P2P module
6031 * @global: Pointer to global data from wpa_supplicant_init()
6032 *
6033 * This function deinitializes the global (per device) P2P module.
6034 */
wpas_p2p_deinit_global(struct wpa_global * global)6035 static void wpas_p2p_deinit_global(struct wpa_global *global)
6036 {
6037 struct wpa_supplicant *wpa_s, *tmp;
6038
6039 wpa_s = global->ifaces;
6040
6041 wpas_p2p_service_flush(global->p2p_init_wpa_s);
6042
6043 /* Remove remaining P2P group interfaces */
6044 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
6045 wpa_s = wpa_s->next;
6046 while (wpa_s) {
6047 tmp = global->ifaces;
6048 while (tmp &&
6049 (tmp == wpa_s ||
6050 tmp->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)) {
6051 tmp = tmp->next;
6052 }
6053 if (tmp == NULL)
6054 break;
6055 /* Disconnect from the P2P group and deinit the interface */
6056 wpas_p2p_disconnect(tmp);
6057 }
6058
6059 /*
6060 * Deinit GO data on any possibly remaining interface (if main
6061 * interface is used as GO).
6062 */
6063 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6064 if (wpa_s->ap_iface)
6065 wpas_p2p_group_deinit(wpa_s);
6066 }
6067
6068 p2p_deinit(global->p2p);
6069 global->p2p = NULL;
6070 global->p2p_init_wpa_s = NULL;
6071 }
6072
6073
wpas_p2p_create_iface(struct wpa_supplicant * wpa_s)6074 static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s)
6075 {
6076 if (wpa_s->conf->p2p_no_group_iface)
6077 return 0; /* separate interface disabled per configuration */
6078 if (wpa_s->drv_flags &
6079 (WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE |
6080 WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P))
6081 return 1; /* P2P group requires a new interface in every case
6082 */
6083 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
6084 return 0; /* driver does not support concurrent operations */
6085 if (wpa_s->global->ifaces->next)
6086 return 1; /* more that one interface already in use */
6087 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
6088 return 1; /* this interface is already in use */
6089 return 0;
6090 }
6091
6092
6093 #ifdef CONFIG_PASN
wpas_p2p_config_sae_password(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)6094 static int wpas_p2p_config_sae_password(struct wpa_supplicant *wpa_s,
6095 struct wpa_ssid *ssid)
6096 {
6097 struct p2p_data *p2p = wpa_s->global->p2p;
6098
6099 if (wpa_s->global->p2p_disabled || !p2p || !ssid->sae_password)
6100 return -2;
6101
6102 return p2p_config_sae_password(p2p, ssid->sae_password);
6103 }
6104 #endif /* CONFIG_PASN */
6105
6106
wpas_p2p_start_go_neg(struct wpa_supplicant * wpa_s,const u8 * peer_addr,enum p2p_wps_method wps_method,int go_intent,const u8 * own_interface_addr,unsigned int force_freq,int persistent_group,struct wpa_ssid * ssid,unsigned int pref_freq,bool p2p2,u16 bootstrap,const char * password)6107 static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
6108 const u8 *peer_addr,
6109 enum p2p_wps_method wps_method,
6110 int go_intent, const u8 *own_interface_addr,
6111 unsigned int force_freq, int persistent_group,
6112 struct wpa_ssid *ssid, unsigned int pref_freq,
6113 bool p2p2, u16 bootstrap, const char *password)
6114 {
6115 if (persistent_group && wpa_s->conf->persistent_reconnect)
6116 persistent_group = 2;
6117
6118 /*
6119 * Increase GO config timeout if HT40 is used since it takes some time
6120 * to scan channels for coex purposes before the BSS can be started.
6121 */
6122 p2p_set_config_timeout(wpa_s->global->p2p,
6123 wpa_s->p2p_go_ht40 ? 255 : 100, 20);
6124
6125 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
6126 go_intent, own_interface_addr, force_freq,
6127 persistent_group, ssid ? ssid->ssid : NULL,
6128 ssid ? ssid->ssid_len : 0,
6129 wpa_s->p2p_pd_before_go_neg, pref_freq,
6130 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
6131 0, p2p2, bootstrap, password);
6132 }
6133
6134
wpas_p2p_auth_go_neg(struct wpa_supplicant * wpa_s,const u8 * peer_addr,enum p2p_wps_method wps_method,int go_intent,const u8 * own_interface_addr,unsigned int force_freq,int persistent_group,struct wpa_ssid * ssid,unsigned int pref_freq,u16 bootstrap,const char * password)6135 static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
6136 const u8 *peer_addr,
6137 enum p2p_wps_method wps_method,
6138 int go_intent, const u8 *own_interface_addr,
6139 unsigned int force_freq, int persistent_group,
6140 struct wpa_ssid *ssid, unsigned int pref_freq,
6141 u16 bootstrap, const char *password)
6142 {
6143 if (persistent_group && wpa_s->conf->persistent_reconnect)
6144 persistent_group = 2;
6145
6146 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
6147 go_intent, own_interface_addr, force_freq,
6148 persistent_group, ssid ? ssid->ssid : NULL,
6149 ssid ? ssid->ssid_len : 0, pref_freq,
6150 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
6151 0, bootstrap, password);
6152 }
6153
6154
wpas_p2p_check_join_scan_limit(struct wpa_supplicant * wpa_s)6155 static void wpas_p2p_check_join_scan_limit(struct wpa_supplicant *wpa_s)
6156 {
6157 wpa_s->p2p_join_scan_count++;
6158 wpa_printf(MSG_DEBUG, "P2P: Join scan attempt %d",
6159 wpa_s->p2p_join_scan_count);
6160 if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) {
6161 wpa_printf(MSG_DEBUG, "P2P: Failed to find GO " MACSTR
6162 " for join operationg - stop join attempt",
6163 MAC2STR(wpa_s->pending_join_iface_addr));
6164 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
6165 if (wpa_s->p2p_auto_pd) {
6166 wpa_s->p2p_auto_pd = 0;
6167 wpa_msg_global(wpa_s, MSG_INFO,
6168 P2P_EVENT_PROV_DISC_FAILURE
6169 " p2p_dev_addr=" MACSTR " status=N/A",
6170 MAC2STR(wpa_s->pending_join_dev_addr));
6171 return;
6172 }
6173 if (wpa_s->p2p_fallback_to_go_neg) {
6174 wpa_dbg(wpa_s, MSG_DEBUG,
6175 "P2P: Join operation failed - fall back to GO Negotiation");
6176 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
6177 P2P_EVENT_FALLBACK_TO_GO_NEG
6178 "reason=join-failed");
6179 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
6180 return;
6181 }
6182 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
6183 P2P_EVENT_GROUP_FORMATION_FAILURE);
6184 wpas_notify_p2p_group_formation_failure(wpa_s, "");
6185 }
6186 }
6187
6188
wpas_check_freq_conflict(struct wpa_supplicant * wpa_s,int freq)6189 static int wpas_check_freq_conflict(struct wpa_supplicant *wpa_s, int freq)
6190 {
6191 int res;
6192 unsigned int num, i;
6193 struct wpa_used_freq_data *freqs;
6194
6195 if (wpas_p2p_num_unused_channels(wpa_s) > 0) {
6196 /* Multiple channels are supported and not all are in use */
6197 return 0;
6198 }
6199
6200 freqs = os_calloc(wpa_s->num_multichan_concurrent,
6201 sizeof(struct wpa_used_freq_data));
6202 if (!freqs)
6203 return 1;
6204
6205 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
6206 wpa_s->num_multichan_concurrent);
6207
6208 for (i = 0; i < num; i++) {
6209 if (freqs[i].freq == freq) {
6210 wpa_printf(MSG_DEBUG, "P2P: Frequency %d MHz in use by another virtual interface and can be used",
6211 freq);
6212 res = 0;
6213 goto exit_free;
6214 }
6215 }
6216
6217 wpa_printf(MSG_DEBUG, "P2P: No valid operating frequencies");
6218 res = 1;
6219
6220 exit_free:
6221 os_free(freqs);
6222 return res;
6223 }
6224
6225
wpas_p2p_peer_go(struct wpa_supplicant * wpa_s,const u8 * peer_dev_addr)6226 static int wpas_p2p_peer_go(struct wpa_supplicant *wpa_s,
6227 const u8 *peer_dev_addr)
6228 {
6229 struct wpa_bss *bss;
6230 int updated;
6231
6232 bss = wpa_bss_get_p2p_dev_addr(wpa_s, peer_dev_addr);
6233 if (bss == NULL)
6234 return -1;
6235 if (bss->last_update_idx < wpa_s->bss_update_idx) {
6236 wpa_printf(MSG_DEBUG, "P2P: Peer BSS entry not updated in the "
6237 "last scan");
6238 return 0;
6239 }
6240
6241 updated = os_reltime_before(&wpa_s->p2p_auto_started,
6242 &bss->last_update);
6243 wpa_printf(MSG_DEBUG, "P2P: Current BSS entry for peer updated at "
6244 "%ld.%06ld (%supdated in last scan)",
6245 bss->last_update.sec, bss->last_update.usec,
6246 updated ? "": "not ");
6247
6248 return updated;
6249 }
6250
6251
wpas_p2p_scan_res_join(struct wpa_supplicant * wpa_s,struct wpa_scan_results * scan_res)6252 static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s,
6253 struct wpa_scan_results *scan_res)
6254 {
6255 struct wpa_bss *bss = NULL;
6256 int freq;
6257 u8 iface_addr[ETH_ALEN];
6258
6259 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
6260
6261 if (wpa_s->global->p2p_disabled)
6262 return;
6263
6264 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS) for %sjoin",
6265 scan_res ? (int) scan_res->num : -1,
6266 wpa_s->p2p_auto_join ? "auto_" : "");
6267
6268 if (scan_res)
6269 wpas_p2p_scan_res_handler(wpa_s, scan_res);
6270
6271 if (!wpa_s->p2p2 && wpa_s->p2p_auto_pd) {
6272 int join = wpas_p2p_peer_go(wpa_s,
6273 wpa_s->pending_join_dev_addr);
6274 if (join == 0 &&
6275 wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) {
6276 wpa_s->auto_pd_scan_retry++;
6277 bss = wpa_bss_get_bssid_latest(
6278 wpa_s, wpa_s->pending_join_dev_addr);
6279 if (bss) {
6280 freq = bss->freq;
6281 wpa_printf(MSG_DEBUG, "P2P: Scan retry %d for "
6282 "the peer " MACSTR " at %d MHz",
6283 wpa_s->auto_pd_scan_retry,
6284 MAC2STR(wpa_s->
6285 pending_join_dev_addr),
6286 freq);
6287 wpas_p2p_join_scan_req(wpa_s, freq, NULL, 0);
6288 return;
6289 }
6290 }
6291
6292 if (join < 0)
6293 join = 0;
6294
6295 wpa_s->p2p_auto_pd = 0;
6296 wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG;
6297 wpa_printf(MSG_DEBUG, "P2P: Auto PD with " MACSTR " join=%d",
6298 MAC2STR(wpa_s->pending_join_dev_addr), join);
6299 if (p2p_prov_disc_req(wpa_s->global->p2p,
6300 wpa_s->pending_join_dev_addr, NULL,
6301 wpa_s->pending_pd_config_methods, join,
6302 0, wpa_s->user_initiated_pd) < 0) {
6303 wpa_s->p2p_auto_pd = 0;
6304 wpa_msg_global(wpa_s, MSG_INFO,
6305 P2P_EVENT_PROV_DISC_FAILURE
6306 " p2p_dev_addr=" MACSTR " status=N/A",
6307 MAC2STR(wpa_s->pending_join_dev_addr));
6308 }
6309 return;
6310 }
6311
6312 if (wpa_s->p2p2 || wpa_s->p2p_auto_join) {
6313 int join = wpas_p2p_peer_go(wpa_s,
6314 wpa_s->pending_join_dev_addr);
6315
6316 if (wpa_s->p2p2 || join < 0) {
6317 if (join < 0) {
6318 wpa_printf(MSG_DEBUG,
6319 "P2P: Peer was not found to be running a GO -> use GO Negotiation");
6320 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
6321 P2P_EVENT_FALLBACK_TO_GO_NEG
6322 "reason=peer-not-running-GO");
6323 }
6324
6325 if (wpa_s->p2p2)
6326 wpa_printf(MSG_DEBUG,
6327 "P2P2: Initiate GO negotiation and provisioning using PASN Authentication");
6328 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr,
6329 wpa_s->p2p_pin, wpa_s->p2p_wps_method,
6330 wpa_s->p2p_persistent_group, 0, 0, 0,
6331 wpa_s->p2p_go_intent,
6332 wpa_s->p2p_connect_freq,
6333 wpa_s->p2p_go_vht_center_freq2,
6334 wpa_s->p2p_persistent_id,
6335 wpa_s->p2p_pd_before_go_neg,
6336 wpa_s->p2p_go_ht40,
6337 wpa_s->p2p_go_vht,
6338 wpa_s->p2p_go_max_oper_chwidth,
6339 wpa_s->p2p_go_he,
6340 wpa_s->p2p_go_edmg,
6341 NULL, 0,
6342 is_p2p_allow_6ghz(wpa_s->global->p2p),
6343 wpa_s->p2p2, wpa_s->p2p_bootstrap,
6344 wpa_s->pending_join_password[0] ?
6345 wpa_s->pending_join_password : NULL,
6346 false);
6347 return;
6348 }
6349
6350 wpa_printf(MSG_DEBUG, "P2P: Peer was found running GO%s -> "
6351 "try to join the group", join ? "" :
6352 " in older scan");
6353 if (!join) {
6354 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
6355 P2P_EVENT_FALLBACK_TO_GO_NEG_ENABLED);
6356 wpa_s->p2p_fallback_to_go_neg = 1;
6357 }
6358 }
6359
6360 freq = p2p_get_oper_freq(wpa_s->global->p2p,
6361 wpa_s->pending_join_iface_addr);
6362 if (freq < 0 &&
6363 p2p_get_interface_addr(wpa_s->global->p2p,
6364 wpa_s->pending_join_dev_addr,
6365 iface_addr) == 0 &&
6366 !ether_addr_equal(iface_addr, wpa_s->pending_join_dev_addr) &&
6367 !wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr)) {
6368 wpa_printf(MSG_DEBUG, "P2P: Overwrite pending interface "
6369 "address for join from " MACSTR " to " MACSTR
6370 " based on newly discovered P2P peer entry",
6371 MAC2STR(wpa_s->pending_join_iface_addr),
6372 MAC2STR(iface_addr));
6373 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr,
6374 ETH_ALEN);
6375
6376 freq = p2p_get_oper_freq(wpa_s->global->p2p,
6377 wpa_s->pending_join_iface_addr);
6378 }
6379 if (freq >= 0) {
6380 wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency "
6381 "from P2P peer table: %d MHz", freq);
6382 }
6383 if (wpa_s->p2p_join_ssid_len) {
6384 wpa_printf(MSG_DEBUG, "P2P: Trying to find target GO BSS entry based on BSSID "
6385 MACSTR " and SSID %s",
6386 MAC2STR(wpa_s->pending_join_iface_addr),
6387 wpa_ssid_txt(wpa_s->p2p_join_ssid,
6388 wpa_s->p2p_join_ssid_len));
6389 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr,
6390 wpa_s->p2p_join_ssid,
6391 wpa_s->p2p_join_ssid_len);
6392 } else if (!bss) {
6393 wpa_printf(MSG_DEBUG, "P2P: Trying to find target GO BSS entry based on BSSID "
6394 MACSTR, MAC2STR(wpa_s->pending_join_iface_addr));
6395 bss = wpa_bss_get_bssid_latest(wpa_s,
6396 wpa_s->pending_join_iface_addr);
6397 }
6398 if (bss) {
6399 u8 dev_addr[ETH_ALEN];
6400
6401 freq = bss->freq;
6402 wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency "
6403 "from BSS table: %d MHz (SSID %s)", freq,
6404 wpa_ssid_txt(bss->ssid, bss->ssid_len));
6405 if (p2p_parse_dev_addr(wpa_bss_ie_ptr(bss), bss->ie_len,
6406 dev_addr) == 0 &&
6407 ether_addr_equal(wpa_s->pending_join_dev_addr,
6408 wpa_s->pending_join_iface_addr) &&
6409 !ether_addr_equal(dev_addr, wpa_s->pending_join_dev_addr)) {
6410 wpa_printf(MSG_DEBUG,
6411 "P2P: Update target GO device address based on BSS entry: " MACSTR " (was " MACSTR ")",
6412 MAC2STR(dev_addr),
6413 MAC2STR(wpa_s->pending_join_dev_addr));
6414 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr,
6415 ETH_ALEN);
6416 }
6417 }
6418 if (freq > 0) {
6419 u16 method;
6420
6421 if (wpas_check_freq_conflict(wpa_s, freq) > 0) {
6422 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
6423 P2P_EVENT_GROUP_FORMATION_FAILURE
6424 "reason=FREQ_CONFLICT");
6425 wpas_notify_p2p_group_formation_failure(
6426 wpa_s, "FREQ_CONFLICT");
6427 return;
6428 }
6429
6430 wpa_printf(MSG_DEBUG, "P2P: Send Provision Discovery Request "
6431 "prior to joining an existing group (GO " MACSTR
6432 " freq=%u MHz)",
6433 MAC2STR(wpa_s->pending_join_dev_addr), freq);
6434 wpa_s->pending_pd_before_join = 1;
6435
6436 switch (wpa_s->pending_join_wps_method) {
6437 case WPS_PIN_DISPLAY:
6438 method = WPS_CONFIG_KEYPAD;
6439 break;
6440 case WPS_PIN_KEYPAD:
6441 method = WPS_CONFIG_DISPLAY;
6442 break;
6443 case WPS_PBC:
6444 method = WPS_CONFIG_PUSHBUTTON;
6445 break;
6446 case WPS_P2PS:
6447 method = WPS_CONFIG_P2PS;
6448 break;
6449 default:
6450 method = 0;
6451 break;
6452 }
6453
6454 if ((p2p_get_provisioning_info(wpa_s->global->p2p,
6455 wpa_s->pending_join_dev_addr) ==
6456 method)) {
6457 /*
6458 * We have already performed provision discovery for
6459 * joining the group. Proceed directly to join
6460 * operation without duplicated provision discovery. */
6461 wpa_printf(MSG_DEBUG, "P2P: Provision discovery "
6462 "with " MACSTR " already done - proceed to "
6463 "join",
6464 MAC2STR(wpa_s->pending_join_dev_addr));
6465 wpa_s->pending_pd_before_join = 0;
6466 goto start;
6467 }
6468
6469 if (p2p_prov_disc_req(wpa_s->global->p2p,
6470 wpa_s->pending_join_dev_addr,
6471 NULL, method, 1,
6472 freq, wpa_s->user_initiated_pd) < 0) {
6473 wpa_printf(MSG_DEBUG, "P2P: Failed to send Provision "
6474 "Discovery Request before joining an "
6475 "existing group");
6476 wpa_s->pending_pd_before_join = 0;
6477 goto start;
6478 }
6479 return;
6480 }
6481
6482 wpa_printf(MSG_DEBUG, "P2P: Failed to find BSS/GO - try again later");
6483 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
6484 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
6485 wpas_p2p_check_join_scan_limit(wpa_s);
6486 return;
6487
6488 start:
6489 /* Start join operation immediately */
6490 wpas_p2p_join_start(wpa_s, 0, wpa_s->p2p_join_ssid,
6491 wpa_s->p2p_join_ssid_len);
6492 }
6493
6494
wpas_p2p_join_scan_req(struct wpa_supplicant * wpa_s,int freq,const u8 * ssid,size_t ssid_len)6495 static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq,
6496 const u8 *ssid, size_t ssid_len)
6497 {
6498 int ret;
6499 struct wpa_driver_scan_params params;
6500 struct wpabuf *wps_ie = NULL, *ies;
6501 size_t ielen;
6502 int freqs[2] = { 0, 0 };
6503 unsigned int bands;
6504
6505 os_memset(¶ms, 0, sizeof(params));
6506
6507 /* P2P Wildcard SSID */
6508 params.num_ssids = 1;
6509 if (ssid && ssid_len) {
6510 params.ssids[0].ssid = ssid;
6511 params.ssids[0].ssid_len = ssid_len;
6512 os_memcpy(wpa_s->p2p_join_ssid, ssid, ssid_len);
6513 wpa_s->p2p_join_ssid_len = ssid_len;
6514 } else {
6515 params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
6516 params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
6517 wpa_s->p2p_join_ssid_len = 0;
6518 }
6519
6520 if (!wpa_s->p2p2) {
6521 wpa_s->wps->dev.p2p = 1;
6522 wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT,
6523 &wpa_s->wps->dev,
6524 wpa_s->wps->uuid,
6525 WPS_REQ_ENROLLEE, 0, NULL);
6526 if (!wps_ie) {
6527 wpas_p2p_scan_res_join(wpa_s, NULL);
6528 return;
6529 }
6530 }
6531
6532 if (!freq) {
6533 int oper_freq;
6534 /*
6535 * If freq is not provided, check the operating freq of the GO
6536 * and use a single channel scan on if possible.
6537 */
6538 oper_freq = p2p_get_oper_freq(wpa_s->global->p2p,
6539 wpa_s->pending_join_iface_addr);
6540 if (oper_freq > 0)
6541 freq = oper_freq;
6542 }
6543 if (freq > 0) {
6544 freqs[0] = freq;
6545 params.freqs = freqs;
6546 } else {
6547 wpas_p2p_scan_freqs(wpa_s, ¶ms, true);
6548 }
6549
6550 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
6551
6552 if (wps_ie)
6553 ielen += wpabuf_len(wps_ie);
6554
6555 ies = wpabuf_alloc(ielen);
6556 if (!ies) {
6557 wpabuf_free(wps_ie);
6558 wpas_p2p_scan_res_join(wpa_s, NULL);
6559 return;
6560 }
6561
6562 if (wps_ie) {
6563 wpabuf_put_buf(ies, wps_ie);
6564 wpabuf_free(wps_ie);
6565 }
6566
6567 bands = wpas_get_bands(wpa_s, freqs);
6568 p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands);
6569
6570 params.p2p_probe = 1;
6571 params.extra_ies = wpabuf_head(ies);
6572 params.extra_ies_len = wpabuf_len(ies);
6573
6574 if (wpa_s->clear_driver_scan_cache) {
6575 wpa_printf(MSG_DEBUG,
6576 "Request driver to clear scan cache due to local BSS flush");
6577 params.only_new_results = 1;
6578 }
6579
6580 /*
6581 * Run a scan to update BSS table and start Provision Discovery once
6582 * the new scan results become available.
6583 */
6584 ret = wpa_drv_scan(wpa_s, ¶ms);
6585 if (params.freqs != freqs)
6586 os_free(params.freqs);
6587 if (!ret) {
6588 os_get_reltime(&wpa_s->scan_trigger_time);
6589 wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
6590 wpa_s->own_scan_requested = 1;
6591 wpa_s->clear_driver_scan_cache = 0;
6592 }
6593
6594 wpabuf_free(ies);
6595
6596 if (ret) {
6597 wpa_printf(MSG_DEBUG, "P2P: Failed to start scan for join - "
6598 "try again later");
6599 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
6600 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
6601 wpas_p2p_check_join_scan_limit(wpa_s);
6602 }
6603 }
6604
6605
wpas_p2p_join_scan(void * eloop_ctx,void * timeout_ctx)6606 static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx)
6607 {
6608 struct wpa_supplicant *wpa_s = eloop_ctx;
6609 wpas_p2p_join_scan_req(wpa_s, 0, NULL, 0);
6610 }
6611
6612
wpas_p2p_join(struct wpa_supplicant * wpa_s,const u8 * iface_addr,const u8 * dev_addr,enum p2p_wps_method wps_method,int auto_join,int op_freq,const u8 * ssid,size_t ssid_len)6613 static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
6614 const u8 *dev_addr, enum p2p_wps_method wps_method,
6615 int auto_join, int op_freq,
6616 const u8 *ssid, size_t ssid_len)
6617 {
6618 wpa_printf(MSG_DEBUG, "P2P: Request to join existing group (iface "
6619 MACSTR " dev " MACSTR " op_freq=%d)%s",
6620 MAC2STR(iface_addr), MAC2STR(dev_addr), op_freq,
6621 auto_join ? " (auto_join)" : "");
6622 if (ssid && ssid_len) {
6623 wpa_printf(MSG_DEBUG, "P2P: Group SSID specified: %s",
6624 wpa_ssid_txt(ssid, ssid_len));
6625 }
6626
6627 wpa_s->p2p_auto_pd = 0;
6628 wpa_s->p2p_auto_join = !!auto_join;
6629 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
6630 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
6631 wpa_s->pending_join_wps_method = wps_method;
6632
6633 /* Make sure we are not running find during connection establishment */
6634 wpas_p2p_stop_find(wpa_s);
6635
6636 wpa_s->p2p_join_scan_count = 0;
6637 wpas_p2p_join_scan_req(wpa_s, op_freq, ssid, ssid_len);
6638 return 0;
6639 }
6640
6641
wpas_p2p_join_start(struct wpa_supplicant * wpa_s,int freq,const u8 * ssid,size_t ssid_len)6642 static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq,
6643 const u8 *ssid, size_t ssid_len)
6644 {
6645 struct wpa_supplicant *group;
6646 struct p2p_go_neg_results res;
6647 struct wpa_bss *bss;
6648 const u8 *iface_addr = NULL;
6649
6650 group = wpas_p2p_get_group_iface(wpa_s, 0, 0);
6651 if (group == NULL)
6652 return -1;
6653 if (group != wpa_s) {
6654 os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
6655 sizeof(group->p2p_pin));
6656 group->p2p_wps_method = wpa_s->p2p_wps_method;
6657 }
6658
6659 /*
6660 * Need to mark the current interface for p2p_group_formation
6661 * when a separate group interface is not used. This is needed
6662 * to allow p2p_cancel stop a pending p2p_connect-join.
6663 * wpas_p2p_init_group_interface() addresses this for the case
6664 * where a separate group interface is used.
6665 */
6666 if (group == wpa_s->parent)
6667 wpa_s->global->p2p_group_formation = group;
6668
6669 group->p2p_in_provisioning = 1;
6670 group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg;
6671
6672 os_memset(&res, 0, sizeof(res));
6673 os_memcpy(res.peer_device_addr, wpa_s->pending_join_dev_addr, ETH_ALEN);
6674 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
6675 ETH_ALEN);
6676 if (!is_zero_ether_addr(wpa_s->pending_join_iface_addr))
6677 iface_addr = wpa_s->pending_join_iface_addr;
6678
6679 if (wpa_s->pending_join_password[0]) {
6680 res.akmp = WPA_KEY_MGMT_SAE;
6681 os_strlcpy(res.sae_password, wpa_s->pending_join_password,
6682 sizeof(res.sae_password));
6683 os_memset(wpa_s->pending_join_password, 0,
6684 sizeof(wpa_s->pending_join_password));
6685 }
6686 res.wps_method = wpa_s->pending_join_wps_method;
6687 res.p2p2 = wpa_s->p2p2;
6688 res.cipher = WPA_CIPHER_CCMP;
6689
6690 if (freq && ssid && ssid_len) {
6691 res.freq = freq;
6692 res.ssid_len = ssid_len;
6693 os_memcpy(res.ssid, ssid, ssid_len);
6694 } else {
6695 if (ssid && ssid_len) {
6696 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
6697 } else {
6698 bss = wpa_bss_get_bssid_latest(
6699 wpa_s, wpa_s->pending_join_iface_addr);
6700 }
6701 if (bss) {
6702 res.freq = bss->freq;
6703 res.ssid_len = bss->ssid_len;
6704 os_memcpy(res.ssid, bss->ssid, bss->ssid_len);
6705 os_memcpy(res.peer_interface_addr, bss->bssid,
6706 ETH_ALEN);
6707 wpa_printf(MSG_DEBUG, "P2P: Join target GO operating frequency from BSS table: %d MHz (SSID %s)",
6708 bss->freq,
6709 wpa_ssid_txt(bss->ssid, bss->ssid_len));
6710 } else if (ssid && ssid_len) {
6711 res.ssid_len = ssid_len;
6712 os_memcpy(res.ssid, ssid, ssid_len);
6713 wpa_printf(MSG_DEBUG, "P2P: Join target GO (SSID %s)",
6714 wpa_ssid_txt(ssid, ssid_len));
6715 }
6716 }
6717
6718 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
6719 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel prior to "
6720 "starting client");
6721 wpa_drv_cancel_remain_on_channel(wpa_s);
6722 wpa_s->off_channel_freq = 0;
6723 wpa_s->roc_waiting_drv_freq = 0;
6724 }
6725 if (res.p2p2)
6726 wpas_start_gc(group, &res);
6727 else
6728 wpas_start_wps_enrollee(group, &res);
6729
6730 /*
6731 * Allow a longer timeout for join-a-running-group than normal 15
6732 * second group formation timeout since the GO may not have authorized
6733 * our connection yet.
6734 */
6735 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
6736 eloop_register_timeout(60, 0, wpas_p2p_group_formation_timeout,
6737 wpa_s, NULL);
6738
6739 return 0;
6740 }
6741
6742
wpas_p2p_setup_freqs(struct wpa_supplicant * wpa_s,int freq,int * force_freq,int * pref_freq,int go,struct weighted_pcl * pref_freq_list,unsigned int * num_pref_freq)6743 static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq,
6744 int *force_freq, int *pref_freq, int go,
6745 struct weighted_pcl *pref_freq_list,
6746 unsigned int *num_pref_freq)
6747 {
6748 struct wpa_used_freq_data *freqs;
6749 int res, best_freq, num_unused;
6750 unsigned int freq_in_use = 0, num, i, max_pref_freq;
6751
6752 max_pref_freq = *num_pref_freq;
6753 *num_pref_freq = 0;
6754
6755 freqs = os_calloc(wpa_s->num_multichan_concurrent,
6756 sizeof(struct wpa_used_freq_data));
6757 if (!freqs)
6758 return -1;
6759
6760 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
6761 wpa_s->num_multichan_concurrent);
6762
6763 /*
6764 * It is possible that the total number of used frequencies is bigger
6765 * than the number of frequencies used for P2P, so get the system wide
6766 * number of unused frequencies.
6767 */
6768 num_unused = wpas_p2p_num_unused_channels(wpa_s);
6769
6770 wpa_printf(MSG_DEBUG,
6771 "P2P: Setup freqs: freq=%d num_MCC=%d shared_freqs=%u num_unused=%d",
6772 freq, wpa_s->num_multichan_concurrent, num, num_unused);
6773
6774 if (freq > 0) {
6775 int ret;
6776 if (go)
6777 ret = p2p_supported_freq(wpa_s->global->p2p, freq);
6778 else
6779 ret = p2p_supported_freq_cli(wpa_s->global->p2p, freq);
6780 if (!ret) {
6781 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
6782 ieee80211_is_dfs(freq, wpa_s->hw.modes,
6783 wpa_s->hw.num_modes)) {
6784 /*
6785 * If freq is a DFS channel and DFS is offloaded
6786 * to the driver, allow P2P GO to use it.
6787 */
6788 wpa_printf(MSG_DEBUG,
6789 "P2P: The forced channel for GO (%u MHz) is DFS, and DFS is offloaded to the driver",
6790 freq);
6791 } else {
6792 wpa_printf(MSG_DEBUG,
6793 "P2P: The forced channel (%u MHz) is not supported for P2P uses",
6794 freq);
6795 res = -3;
6796 goto exit_free;
6797 }
6798 }
6799
6800 for (i = 0; i < num; i++) {
6801 if (freqs[i].freq == freq)
6802 freq_in_use = 1;
6803 }
6804
6805 if (num_unused <= 0 && !freq_in_use) {
6806 wpa_printf(MSG_DEBUG, "P2P: Cannot start P2P group on %u MHz as there are no available channels",
6807 freq);
6808 res = -2;
6809 goto exit_free;
6810 }
6811 wpa_printf(MSG_DEBUG, "P2P: Trying to force us to use the "
6812 "requested channel (%u MHz)", freq);
6813 *force_freq = freq;
6814 goto exit_ok;
6815 }
6816
6817 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
6818
6819 if (!wpa_s->conf->num_p2p_pref_chan && *pref_freq == 0) {
6820 wpa_printf(MSG_DEBUG, "P2P: best_freq=%d, go=%d",
6821 best_freq, go);
6822
6823 *num_pref_freq = max_pref_freq;
6824 res = wpas_p2p_pick_best_pref_freq(wpa_s, go, pref_freq_list,
6825 num_pref_freq);
6826 if (res > 0)
6827 best_freq = res;
6828 }
6829
6830 /* We have a candidate frequency to use */
6831 if (best_freq > 0) {
6832 if (*pref_freq == 0 && num_unused > 0) {
6833 wpa_printf(MSG_DEBUG, "P2P: Try to prefer a frequency (%u MHz) we are already using",
6834 best_freq);
6835 *pref_freq = best_freq;
6836 } else {
6837 wpa_printf(MSG_DEBUG, "P2P: Try to force us to use frequency (%u MHz) which is already in use",
6838 best_freq);
6839 *force_freq = best_freq;
6840 }
6841 } else if (num_unused > 0) {
6842 wpa_printf(MSG_DEBUG,
6843 "P2P: Current operating channels are not available for P2P. Try to use another channel");
6844 *force_freq = 0;
6845 } else {
6846 wpa_printf(MSG_DEBUG,
6847 "P2P: All channels are in use and none of them are P2P enabled. Cannot start P2P group");
6848 res = -2;
6849 goto exit_free;
6850 }
6851
6852 exit_ok:
6853 res = 0;
6854 exit_free:
6855 os_free(freqs);
6856 return res;
6857 }
6858
6859
is_p2p_6ghz_supported(struct wpa_supplicant * wpa_s,const u8 * peer_addr)6860 static bool is_p2p_6ghz_supported(struct wpa_supplicant *wpa_s,
6861 const u8 *peer_addr)
6862 {
6863 if (wpa_s->conf->p2p_6ghz_disable ||
6864 !get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
6865 HOSTAPD_MODE_IEEE80211A, true))
6866 return false;
6867
6868 if (wpa_s->p2p2)
6869 return true;
6870
6871 if (!p2p_wfd_enabled(wpa_s->global->p2p))
6872 return false;
6873 if (peer_addr && !p2p_peer_wfd_enabled(wpa_s->global->p2p, peer_addr))
6874 return false;
6875
6876 return true;
6877 }
6878
6879
wpas_p2p_check_6ghz(struct wpa_supplicant * wpa_s,const u8 * peer_addr,bool allow_6ghz,int freq)6880 static int wpas_p2p_check_6ghz(struct wpa_supplicant *wpa_s,
6881 const u8 *peer_addr, bool allow_6ghz, int freq)
6882 {
6883 if (allow_6ghz && is_p2p_6ghz_supported(wpa_s, peer_addr)) {
6884 wpa_printf(MSG_DEBUG,
6885 "P2P: Allow connection on 6 GHz channels");
6886 p2p_set_6ghz_dev_capab(wpa_s->global->p2p, true);
6887 } else {
6888 if (is_6ghz_freq(freq))
6889 return -2;
6890 p2p_set_6ghz_dev_capab(wpa_s->global->p2p, false);
6891 }
6892
6893 return 0;
6894 }
6895
6896
6897 /**
6898 * wpas_p2p_connect - Request P2P Group Formation to be started
6899 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
6900 * @peer_addr: Address of the peer P2P Device
6901 * @pin: PIN to use during provisioning or %NULL to indicate PBC mode
6902 * @persistent_group: Whether to create a persistent group
6903 * @auto_join: Whether to select join vs. GO Negotiation automatically
6904 * @join: Whether to join an existing group (as a client) instead of starting
6905 * Group Owner negotiation; @peer_addr is BSSID in that case
6906 * @auth: Whether to only authorize the connection instead of doing that and
6907 * initiating Group Owner negotiation
6908 * @go_intent: GO Intent or -1 to use default
6909 * @freq: Frequency for the group or 0 for auto-selection
6910 * @freq2: Center frequency of segment 1 for the GO operating in VHT 80P80 mode
6911 * @persistent_id: Persistent group credentials to use for forcing GO
6912 * parameters or -1 to generate new values (SSID/passphrase)
6913 * @pd: Whether to send Provision Discovery prior to GO Negotiation as an
6914 * interoperability workaround when initiating group formation
6915 * @ht40: Start GO with 40 MHz channel width
6916 * @vht: Start GO with VHT support
6917 * @vht_chwidth: Channel width supported by GO operating with VHT support
6918 * (CHANWIDTH_*).
6919 * @group_ssid: Specific Group SSID for join or %NULL if not set
6920 * @group_ssid_len: Length of @group_ssid in octets
6921 * @allow_6ghz: Allow P2P connection on 6 GHz channels
6922 * @p2p2: Whether device is in P2P R2 mode
6923 * @bootstrap: Requested bootstrap method for pairing in P2P2
6924 * @password: Password for pairing setup or NULL for opportunistic method
6925 * in P2P2
6926 * @skip_prov: Connect without provisioning
6927 * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on unspecified
6928 * failure, -2 on failure due to channel not currently available,
6929 * -3 if forced channel is not supported
6930 */
wpas_p2p_connect(struct wpa_supplicant * wpa_s,const u8 * peer_addr,const char * pin,enum p2p_wps_method wps_method,int persistent_group,int auto_join,int join,int auth,int go_intent,int freq,unsigned int vht_center_freq2,int persistent_id,int pd,int ht40,int vht,unsigned int vht_chwidth,int he,int edmg,const u8 * group_ssid,size_t group_ssid_len,bool allow_6ghz,bool p2p2,u16 bootstrap,const char * password,bool skip_prov)6931 int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
6932 const char *pin, enum p2p_wps_method wps_method,
6933 int persistent_group, int auto_join, int join, int auth,
6934 int go_intent, int freq, unsigned int vht_center_freq2,
6935 int persistent_id, int pd, int ht40, int vht,
6936 unsigned int vht_chwidth, int he, int edmg,
6937 const u8 *group_ssid, size_t group_ssid_len,
6938 bool allow_6ghz, bool p2p2, u16 bootstrap,
6939 const char *password, bool skip_prov)
6940 {
6941 int force_freq = 0, pref_freq = 0;
6942 int ret = 0, res;
6943 enum wpa_driver_if_type iftype;
6944 const u8 *if_addr;
6945 struct wpa_ssid *ssid = NULL;
6946 struct weighted_pcl pref_freq_list[P2P_MAX_PREF_CHANNELS];
6947 unsigned int size;
6948
6949 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6950 return -1;
6951
6952 if (persistent_id >= 0) {
6953 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
6954 if (ssid == NULL || ssid->disabled != 2 ||
6955 ssid->mode != WPAS_MODE_P2P_GO)
6956 return -1;
6957 }
6958
6959 wpa_s->p2p2 = p2p2;
6960 wpa_s->p2p_mode = p2p2 ? WPA_P2P_MODE_WFD_R2 : WPA_P2P_MODE_WFD_R1;
6961
6962 if (wpas_p2p_check_6ghz(wpa_s, peer_addr, allow_6ghz, freq))
6963 return -2;
6964
6965 os_free(wpa_s->global->add_psk);
6966 wpa_s->global->add_psk = NULL;
6967
6968 p2p_set_go_role(wpa_s->global->p2p, false);
6969 wpa_s->global->p2p_fail_on_wps_complete = 0;
6970 wpa_s->global->pending_p2ps_group = 0;
6971 wpa_s->global->pending_p2ps_group_freq = 0;
6972 wpa_s->p2ps_method_config_any = 0;
6973
6974 if (go_intent < 0)
6975 go_intent = wpa_s->conf->p2p_go_intent;
6976
6977 if (!auth)
6978 wpa_s->global->p2p_long_listen = 0;
6979
6980 wpa_s->p2p_wps_method = wps_method;
6981 wpa_s->p2p_persistent_group = !!persistent_group;
6982 wpa_s->p2p_persistent_id = persistent_id;
6983 wpa_s->p2p_go_intent = go_intent;
6984 wpa_s->p2p_connect_freq = freq;
6985 wpa_s->p2p_fallback_to_go_neg = 0;
6986 wpa_s->p2p_pd_before_go_neg = !!pd;
6987 wpa_s->p2p_go_ht40 = !!ht40;
6988 wpa_s->p2p_go_vht = !!vht;
6989 wpa_s->p2p_go_vht_center_freq2 = vht_center_freq2;
6990 wpa_s->p2p_go_max_oper_chwidth = vht_chwidth;
6991 wpa_s->p2p_go_he = !!he;
6992 wpa_s->p2p_go_edmg = !!edmg;
6993 wpa_s->p2p_bootstrap = bootstrap;
6994
6995 if (pin)
6996 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
6997 else if (wps_method == WPS_PIN_DISPLAY) {
6998 if (wps_generate_pin((unsigned int *) &ret) < 0)
6999 return -1;
7000 res = os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin),
7001 "%08d", ret);
7002 if (os_snprintf_error(sizeof(wpa_s->p2p_pin), res))
7003 wpa_s->p2p_pin[sizeof(wpa_s->p2p_pin) - 1] = '\0';
7004 wpa_printf(MSG_DEBUG, "P2P: Randomly generated PIN: %s",
7005 wpa_s->p2p_pin);
7006 } else if (wps_method == WPS_P2PS) {
7007 /* Force the P2Ps default PIN to be used */
7008 os_strlcpy(wpa_s->p2p_pin, "12345670", sizeof(wpa_s->p2p_pin));
7009 } else
7010 wpa_s->p2p_pin[0] = '\0';
7011
7012 if (!password)
7013 os_memset(wpa_s->pending_join_password, 0,
7014 sizeof(wpa_s->pending_join_password));
7015
7016 if (join || auto_join) {
7017 u8 iface_addr[ETH_ALEN], dev_addr[ETH_ALEN];
7018 if (auth) {
7019 #ifdef CONFIG_PASN
7020 struct wpa_supplicant *ifs;
7021 #endif /* CONFIG_PASN */
7022
7023 wpa_printf(MSG_DEBUG, "P2P: Authorize invitation to "
7024 "connect a running group from " MACSTR,
7025 MAC2STR(peer_addr));
7026 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
7027
7028 #ifdef CONFIG_PASN
7029 if (!wpa_s->p2p2)
7030 return ret;
7031
7032 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
7033 if (wpa_s->create_p2p_iface) {
7034 if_addr = wpa_s->pending_interface_addr;
7035 } else {
7036 if (wpa_s->p2p_mgmt)
7037 if_addr = wpa_s->parent->own_addr;
7038 else
7039 if_addr = wpa_s->own_addr;
7040 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
7041 }
7042
7043 dl_list_for_each(ifs, &wpa_s->radio->ifaces,
7044 struct wpa_supplicant, radio_list) {
7045 if (!ifs->current_ssid ||
7046 ifs->current_ssid->mode != WPAS_MODE_P2P_GO)
7047 continue;
7048
7049 ssid = ifs->current_ssid;
7050
7051 if (bootstrap == P2P_PBMA_OPPORTUNISTIC &&
7052 wpas_p2p_config_sae_password(wpa_s, ssid)) {
7053 ssid = NULL;
7054 continue;
7055 }
7056
7057 force_freq = ifs->ap_iface->freq;
7058 break;
7059 }
7060 p2p_set_go_role(wpa_s->global->p2p, true);
7061 return wpas_p2p_auth_go_neg(wpa_s, peer_addr,
7062 wps_method, 15, if_addr,
7063 force_freq,
7064 persistent_group, ssid,
7065 pref_freq, bootstrap,
7066 password);
7067 #else /* CONFIG_PASN */
7068 return ret;
7069 #endif /* CONFIG_PASN */
7070 }
7071 os_memcpy(dev_addr, peer_addr, ETH_ALEN);
7072 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
7073 iface_addr) < 0) {
7074 os_memcpy(iface_addr, peer_addr, ETH_ALEN);
7075 p2p_get_dev_addr(wpa_s->global->p2p, peer_addr,
7076 dev_addr);
7077 }
7078 if (auto_join) {
7079 os_get_reltime(&wpa_s->p2p_auto_started);
7080 wpa_printf(MSG_DEBUG, "P2P: Auto join started at "
7081 "%ld.%06ld",
7082 wpa_s->p2p_auto_started.sec,
7083 wpa_s->p2p_auto_started.usec);
7084 }
7085 wpa_s->user_initiated_pd = 1;
7086 if (password)
7087 os_strlcpy(wpa_s->pending_join_password, password,
7088 sizeof(wpa_s->pending_join_password));
7089
7090 if (skip_prov) {
7091 if (!wpa_s->p2p2) {
7092 wpa_printf(MSG_DEBUG,
7093 "P2P: Join without provisioning not supported");
7094 return -1;
7095 }
7096 /* Start join operation immediately */
7097 return wpas_p2p_join_start(wpa_s, 0, group_ssid,
7098 group_ssid_len);
7099 }
7100 if (wpas_p2p_join(wpa_s, iface_addr, dev_addr, wps_method,
7101 auto_join, freq,
7102 group_ssid, group_ssid_len) < 0)
7103 return -1;
7104 return ret;
7105 }
7106
7107 size = P2P_MAX_PREF_CHANNELS;
7108 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
7109 go_intent == 15, pref_freq_list, &size);
7110 if (res)
7111 return res;
7112 wpas_p2p_set_own_freq_preference(wpa_s,
7113 force_freq ? force_freq : pref_freq);
7114
7115 p2p_set_own_pref_freq_list(wpa_s->global->p2p, pref_freq_list, size);
7116
7117 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
7118
7119 if (wpa_s->create_p2p_iface) {
7120 /* Prepare to add a new interface for the group */
7121 iftype = WPA_IF_P2P_GROUP;
7122 if (go_intent == 15)
7123 iftype = WPA_IF_P2P_GO;
7124 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
7125 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
7126 "interface for the group");
7127 return -1;
7128 }
7129
7130 if_addr = wpa_s->pending_interface_addr;
7131 } else {
7132 if (wpa_s->p2p_mgmt)
7133 if_addr = wpa_s->parent->own_addr;
7134 else
7135 if_addr = wpa_s->own_addr;
7136 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
7137 }
7138
7139 if (auth) {
7140 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
7141 go_intent, if_addr,
7142 force_freq, persistent_group, ssid,
7143 pref_freq, bootstrap, password) < 0)
7144 return -1;
7145 return ret;
7146 }
7147
7148 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method,
7149 go_intent, if_addr, force_freq,
7150 persistent_group, ssid, pref_freq, p2p2,
7151 bootstrap, password) < 0) {
7152 if (wpa_s->create_p2p_iface)
7153 wpas_p2p_remove_pending_group_interface(wpa_s);
7154 return -1;
7155 }
7156
7157 #ifdef CONFIG_PASN
7158 if (wpa_s->p2p2 && !wpa_s->p2p_pd_before_go_neg)
7159 wpas_p2p_initiate_pasn_auth(wpa_s, peer_addr, force_freq);
7160 #endif /* CONFIG_PASN */
7161
7162 return ret;
7163 }
7164
7165
7166 /**
7167 * wpas_p2p_remain_on_channel_cb - Indication of remain-on-channel start
7168 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
7169 * @freq: Frequency of the channel in MHz
7170 * @duration: Duration of the stay on the channel in milliseconds
7171 *
7172 * This callback is called when the driver indicates that it has started the
7173 * requested remain-on-channel duration.
7174 */
wpas_p2p_remain_on_channel_cb(struct wpa_supplicant * wpa_s,unsigned int freq,unsigned int duration)7175 void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
7176 unsigned int freq, unsigned int duration)
7177 {
7178 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7179 return;
7180 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)",
7181 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
7182 wpa_s->roc_waiting_drv_freq, freq, duration);
7183 if (wpa_s->off_channel_freq &&
7184 wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
7185 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
7186 wpa_s->pending_listen_duration);
7187 wpa_s->pending_listen_freq = 0;
7188 } else {
7189 wpa_printf(MSG_DEBUG, "P2P: Ignore remain-on-channel callback (off_channel_freq=%u pending_listen_freq=%d freq=%u duration=%u)",
7190 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
7191 freq, duration);
7192 }
7193 }
7194
7195
wpas_p2p_listen_start(struct wpa_supplicant * wpa_s,unsigned int timeout)7196 int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s, unsigned int timeout)
7197 {
7198 /* Limit maximum Listen state time based on driver limitation. */
7199 if (timeout > wpa_s->max_remain_on_chan)
7200 timeout = wpa_s->max_remain_on_chan;
7201
7202 return p2p_listen(wpa_s->global->p2p, timeout);
7203 }
7204
7205
7206 /**
7207 * wpas_p2p_cancel_remain_on_channel_cb - Remain-on-channel timeout
7208 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
7209 * @freq: Frequency of the channel in MHz
7210 *
7211 * This callback is called when the driver indicates that a remain-on-channel
7212 * operation has been completed, i.e., the duration on the requested channel
7213 * has timed out.
7214 */
wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant * wpa_s,unsigned int freq)7215 void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
7216 unsigned int freq)
7217 {
7218 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel callback "
7219 "(p2p_long_listen=%d ms pending_action_tx=%p)",
7220 wpa_s->global->p2p_long_listen,
7221 offchannel_pending_action_tx(wpa_s));
7222 wpas_p2p_listen_work_done(wpa_s);
7223 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7224 return;
7225 if (wpa_s->global->p2p_long_listen > 0)
7226 wpa_s->global->p2p_long_listen -= wpa_s->max_remain_on_chan;
7227 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
7228 return; /* P2P module started a new operation */
7229 if (offchannel_pending_action_tx(wpa_s))
7230 return;
7231 if (wpa_s->global->p2p_long_listen > 0) {
7232 wpa_printf(MSG_DEBUG, "P2P: Continuing long Listen state");
7233 wpas_p2p_listen_start(wpa_s, wpa_s->global->p2p_long_listen);
7234 } else {
7235 /*
7236 * When listen duration is over, stop listen & update p2p_state
7237 * to IDLE.
7238 */
7239 p2p_stop_listen(wpa_s->global->p2p);
7240 }
7241 }
7242
7243
7244 /**
7245 * wpas_p2p_group_remove - Remove a P2P group
7246 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
7247 * @ifname: Network interface name of the group interface or "*" to remove all
7248 * groups
7249 * Returns: 0 on success, -1 on failure
7250 *
7251 * This function is used to remove a P2P group. This can be used to disconnect
7252 * from a group in which the local end is a P2P Client or to end a P2P Group in
7253 * case the local end is the Group Owner. If a virtual network interface was
7254 * created for this group, that interface will be removed. Otherwise, only the
7255 * configured P2P group network will be removed from the interface.
7256 */
wpas_p2p_group_remove(struct wpa_supplicant * wpa_s,const char * ifname)7257 int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname)
7258 {
7259 struct wpa_global *global = wpa_s->global;
7260 struct wpa_supplicant *calling_wpa_s = wpa_s;
7261
7262 if (os_strcmp(ifname, "*") == 0) {
7263 struct wpa_supplicant *prev;
7264 bool calling_wpa_s_group_removed = false;
7265
7266 wpa_s = global->ifaces;
7267 while (wpa_s) {
7268 prev = wpa_s;
7269 wpa_s = wpa_s->next;
7270 if (prev->p2p_group_interface !=
7271 NOT_P2P_GROUP_INTERFACE ||
7272 (prev->current_ssid &&
7273 prev->current_ssid->p2p_group)) {
7274 wpas_p2p_disconnect_safely(prev, calling_wpa_s);
7275 if (prev == calling_wpa_s)
7276 calling_wpa_s_group_removed = true;
7277 }
7278 }
7279
7280 if (!calling_wpa_s_group_removed &&
7281 (calling_wpa_s->p2p_group_interface !=
7282 NOT_P2P_GROUP_INTERFACE ||
7283 (calling_wpa_s->current_ssid &&
7284 calling_wpa_s->current_ssid->p2p_group))) {
7285 wpa_printf(MSG_DEBUG, "Remove calling_wpa_s P2P group");
7286 wpas_p2p_disconnect_safely(calling_wpa_s,
7287 calling_wpa_s);
7288 }
7289
7290 return 0;
7291 }
7292
7293 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
7294 if (os_strcmp(wpa_s->ifname, ifname) == 0)
7295 break;
7296 }
7297
7298 return wpas_p2p_disconnect_safely(wpa_s, calling_wpa_s);
7299 }
7300
7301
wpas_p2p_select_go_freq(struct wpa_supplicant * wpa_s,int freq)7302 static int wpas_p2p_select_go_freq(struct wpa_supplicant *wpa_s, int freq)
7303 {
7304 unsigned int r;
7305
7306 if (!wpa_s->conf->num_p2p_pref_chan && !freq) {
7307 unsigned int i, size = P2P_MAX_PREF_CHANNELS;
7308 struct weighted_pcl pref_freq_list[P2P_MAX_PREF_CHANNELS];
7309 int res;
7310
7311 res = wpa_drv_get_pref_freq_list(wpa_s, WPA_IF_P2P_GO,
7312 &size, pref_freq_list);
7313 if (!res && size > 0 && !is_p2p_allow_6ghz(wpa_s->global->p2p))
7314 size = p2p_remove_6ghz_channels(pref_freq_list, size);
7315
7316 if (!res && size > 0) {
7317 i = 0;
7318 while (i < size &&
7319 (!p2p_supported_freq(wpa_s->global->p2p,
7320 pref_freq_list[i].freq) ||
7321 wpas_p2p_disallowed_freq(
7322 wpa_s->global,
7323 pref_freq_list[i].freq) ||
7324 !p2p_pref_freq_allowed(&pref_freq_list[i],
7325 true))) {
7326 wpa_printf(MSG_DEBUG,
7327 "P2P: preferred_freq_list[%d]=%d is disallowed",
7328 i, pref_freq_list[i].freq);
7329 i++;
7330 }
7331 if (i != size) {
7332 freq = pref_freq_list[i].freq;
7333 wpa_printf(MSG_DEBUG,
7334 "P2P: Using preferred_freq_list[%d]=%d",
7335 i, freq);
7336 } else {
7337 wpa_printf(MSG_DEBUG,
7338 "P2P: All driver preferred frequencies are disallowed for P2P use");
7339 }
7340 } else {
7341 wpa_printf(MSG_DEBUG,
7342 "P2P: No preferred frequency list available");
7343 }
7344 }
7345
7346 if (freq == 2) {
7347 wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 2.4 GHz "
7348 "band");
7349 if (wpa_s->best_24_freq > 0 &&
7350 p2p_supported_freq_go(wpa_s->global->p2p,
7351 wpa_s->best_24_freq)) {
7352 freq = wpa_s->best_24_freq;
7353 wpa_printf(MSG_DEBUG, "P2P: Use best 2.4 GHz band "
7354 "channel: %d MHz", freq);
7355 } else {
7356 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
7357 return -1;
7358 freq = 2412 + (r % 3) * 25;
7359 wpa_printf(MSG_DEBUG, "P2P: Use random 2.4 GHz band "
7360 "channel: %d MHz", freq);
7361 }
7362 }
7363
7364 if (freq == 5) {
7365 wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 5 GHz "
7366 "band");
7367 if (wpa_s->best_5_freq > 0 &&
7368 p2p_supported_freq_go(wpa_s->global->p2p,
7369 wpa_s->best_5_freq)) {
7370 freq = wpa_s->best_5_freq;
7371 wpa_printf(MSG_DEBUG, "P2P: Use best 5 GHz band "
7372 "channel: %d MHz", freq);
7373 } else {
7374 const int freqs[] = {
7375 /* operating class 115 */
7376 5180, 5200, 5220, 5240,
7377 /* operating class 124 */
7378 5745, 5765, 5785, 5805,
7379 };
7380 unsigned int i, num_freqs = ARRAY_SIZE(freqs);
7381
7382 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
7383 return -1;
7384
7385 /*
7386 * Most of the 5 GHz channels require DFS. Only
7387 * operating classes 115 and 124 are available possibly
7388 * without that requirement. Check these for
7389 * availability starting from a randomly picked
7390 * position.
7391 */
7392 for (i = 0; i < num_freqs; i++, r++) {
7393 freq = freqs[r % num_freqs];
7394 if (p2p_supported_freq_go(wpa_s->global->p2p,
7395 freq))
7396 break;
7397 }
7398
7399 if (i >= num_freqs) {
7400 wpa_printf(MSG_DEBUG, "P2P: Could not select "
7401 "5 GHz channel for P2P group");
7402 return -1;
7403 }
7404 wpa_printf(MSG_DEBUG, "P2P: Use random 5 GHz band "
7405 "channel: %d MHz", freq);
7406 }
7407 }
7408
7409 if (freq > 0 && !p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
7410 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
7411 ieee80211_is_dfs(freq, wpa_s->hw.modes,
7412 wpa_s->hw.num_modes)) {
7413 /*
7414 * If freq is a DFS channel and DFS is offloaded to the
7415 * driver, allow P2P GO to use it.
7416 */
7417 wpa_printf(MSG_DEBUG, "P2P: "
7418 "%s: The forced channel for GO (%u MHz) is DFS, and DFS is offloaded",
7419 __func__, freq);
7420 return freq;
7421 }
7422 wpa_printf(MSG_DEBUG, "P2P: The forced channel for GO "
7423 "(%u MHz) is not supported for P2P uses",
7424 freq);
7425 return -1;
7426 }
7427
7428 return freq;
7429 }
7430
7431
wpas_p2p_supported_freq_go(struct wpa_supplicant * wpa_s,const struct p2p_channels * channels,int freq)7432 static int wpas_p2p_supported_freq_go(struct wpa_supplicant *wpa_s,
7433 const struct p2p_channels *channels,
7434 int freq)
7435 {
7436 if (is_6ghz_freq(freq) &&
7437 !is_p2p_6ghz_capable(wpa_s->global->p2p))
7438 return 0;
7439
7440 if (!wpas_p2p_disallowed_freq(wpa_s->global, freq) &&
7441 p2p_supported_freq_go(wpa_s->global->p2p, freq) &&
7442 freq_included(wpa_s, channels, freq))
7443 return 1;
7444 return 0;
7445 }
7446
7447
wpas_p2p_select_go_freq_no_pref(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * params,const struct p2p_channels * channels)7448 static void wpas_p2p_select_go_freq_no_pref(struct wpa_supplicant *wpa_s,
7449 struct p2p_go_neg_results *params,
7450 const struct p2p_channels *channels)
7451 {
7452 unsigned int i, r;
7453
7454 /* try all channels in operating class 115 */
7455 for (i = 0; i < 4; i++) {
7456 params->freq = 5180 + i * 20;
7457 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
7458 goto out;
7459 }
7460
7461 /* try all channels in operating class 124 */
7462 for (i = 0; i < 4; i++) {
7463 params->freq = 5745 + i * 20;
7464 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
7465 goto out;
7466 }
7467
7468 /* try social channel class 180 channel 2 */
7469 params->freq = 58320 + 1 * 2160;
7470 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
7471 goto out;
7472
7473 /* try all channels in reg. class 180 */
7474 for (i = 0; i < 4; i++) {
7475 params->freq = 58320 + i * 2160;
7476 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
7477 goto out;
7478 }
7479
7480 /* try some random selection of the social channels */
7481 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
7482 return;
7483
7484 for (i = 0; i < 3; i++) {
7485 params->freq = 2412 + ((r + i) % 3) * 25;
7486 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
7487 goto out;
7488 }
7489
7490 /* try all other channels in operating class 81 */
7491 for (i = 0; i < 11; i++) {
7492 params->freq = 2412 + i * 5;
7493
7494 /* skip social channels; covered in the previous loop */
7495 if (params->freq == 2412 ||
7496 params->freq == 2437 ||
7497 params->freq == 2462)
7498 continue;
7499
7500 if (wpas_p2p_supported_freq_go(wpa_s, channels, params->freq))
7501 goto out;
7502 }
7503
7504 params->freq = 0;
7505 wpa_printf(MSG_DEBUG, "P2P: No 2.4, 5, or 60 GHz channel allowed");
7506 return;
7507 out:
7508 wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz (no preference known)",
7509 params->freq);
7510 }
7511
7512
wpas_same_band(int freq1,int freq2)7513 static int wpas_same_band(int freq1, int freq2)
7514 {
7515 enum hostapd_hw_mode mode1, mode2;
7516 u8 chan1, chan2;
7517
7518 mode1 = ieee80211_freq_to_chan(freq1, &chan1);
7519 mode2 = ieee80211_freq_to_chan(freq2, &chan2);
7520 if (mode1 == NUM_HOSTAPD_MODES)
7521 return 0;
7522 return mode1 == mode2;
7523 }
7524
7525
wpas_p2p_init_go_params(struct wpa_supplicant * wpa_s,struct p2p_go_neg_results * params,int freq,int vht_center_freq2,int ht40,int vht,int max_oper_chwidth,int he,int edmg,const struct p2p_channels * channels)7526 static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
7527 struct p2p_go_neg_results *params,
7528 int freq, int vht_center_freq2, int ht40,
7529 int vht, int max_oper_chwidth, int he,
7530 int edmg,
7531 const struct p2p_channels *channels)
7532 {
7533 struct wpa_used_freq_data *freqs;
7534 unsigned int cand;
7535 unsigned int num, i;
7536 int ignore_no_freqs = 0;
7537 int unused_channels = wpas_p2p_num_unused_channels(wpa_s) > 0;
7538
7539 os_memset(params, 0, sizeof(*params));
7540 params->role_go = 1;
7541 params->ht40 = ht40;
7542 params->vht = vht;
7543 params->he = he;
7544 params->max_oper_chwidth = max_oper_chwidth;
7545 params->vht_center_freq2 = vht_center_freq2;
7546 params->edmg = edmg;
7547 params->p2p2 = wpa_s->p2p2;
7548
7549 freqs = os_calloc(wpa_s->num_multichan_concurrent,
7550 sizeof(struct wpa_used_freq_data));
7551 if (!freqs)
7552 return -1;
7553
7554 num = get_shared_radio_freqs_data(wpa_s, freqs,
7555 wpa_s->num_multichan_concurrent,
7556 false);
7557
7558 if (wpa_s->current_ssid &&
7559 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO &&
7560 wpa_s->wpa_state == WPA_COMPLETED) {
7561 wpa_printf(MSG_DEBUG, "P2P: %s called for an active GO",
7562 __func__);
7563
7564 /*
7565 * If the frequency selection is done for an active P2P GO that
7566 * is not sharing a frequency, allow to select a new frequency
7567 * even if there are no unused frequencies as we are about to
7568 * move the P2P GO so its frequency can be re-used.
7569 */
7570 for (i = 0; i < num; i++) {
7571 if (freqs[i].freq == wpa_s->current_ssid->frequency &&
7572 freqs[i].flags == 0) {
7573 ignore_no_freqs = 1;
7574 break;
7575 }
7576 }
7577 }
7578
7579 /* Try to use EDMG channel */
7580 if (params->edmg) {
7581 if (wpas_p2p_try_edmg_channel(wpa_s, params) == 0)
7582 goto success;
7583 params->edmg = 0;
7584 }
7585
7586 /* try using the forced freq */
7587 if (freq) {
7588 if (wpas_p2p_disallowed_freq(wpa_s->global, freq) ||
7589 !freq_included(wpa_s, channels, freq)) {
7590 wpa_printf(MSG_DEBUG,
7591 "P2P: Forced GO freq %d MHz disallowed",
7592 freq);
7593 goto fail;
7594 }
7595 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
7596 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
7597 ieee80211_is_dfs(freq, wpa_s->hw.modes,
7598 wpa_s->hw.num_modes)) {
7599 /*
7600 * If freq is a DFS channel and DFS is offloaded
7601 * to the driver, allow P2P GO to use it.
7602 */
7603 wpa_printf(MSG_DEBUG,
7604 "P2P: %s: The forced channel for GO (%u MHz) requires DFS and DFS is offloaded",
7605 __func__, freq);
7606 } else {
7607 wpa_printf(MSG_DEBUG,
7608 "P2P: The forced channel for GO (%u MHz) is not supported for P2P uses",
7609 freq);
7610 goto fail;
7611 }
7612 }
7613
7614 for (i = 0; i < num; i++) {
7615 if (freqs[i].freq == freq) {
7616 wpa_printf(MSG_DEBUG,
7617 "P2P: forced freq (%d MHz) is also shared",
7618 freq);
7619 params->freq = freq;
7620 goto success;
7621 }
7622 }
7623
7624 if (!ignore_no_freqs && !unused_channels) {
7625 wpa_printf(MSG_DEBUG,
7626 "P2P: Cannot force GO on freq (%d MHz) as all the channels are in use",
7627 freq);
7628 goto fail;
7629 }
7630
7631 wpa_printf(MSG_DEBUG,
7632 "P2P: force GO freq (%d MHz) on a free channel",
7633 freq);
7634 params->freq = freq;
7635 goto success;
7636 }
7637
7638 /* consider using one of the shared frequencies */
7639 if (num &&
7640 (!wpa_s->conf->p2p_ignore_shared_freq || !unused_channels)) {
7641 cand = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
7642 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
7643 wpa_printf(MSG_DEBUG,
7644 "P2P: Use shared freq (%d MHz) for GO",
7645 cand);
7646 params->freq = cand;
7647 goto success;
7648 }
7649
7650 /* try using one of the shared freqs */
7651 for (i = 0; i < num; i++) {
7652 if (wpas_p2p_supported_freq_go(wpa_s, channels,
7653 freqs[i].freq)) {
7654 wpa_printf(MSG_DEBUG,
7655 "P2P: Use shared freq (%d MHz) for GO",
7656 freqs[i].freq);
7657 params->freq = freqs[i].freq;
7658 goto success;
7659 }
7660 }
7661 }
7662
7663 if (!ignore_no_freqs && !unused_channels) {
7664 wpa_printf(MSG_DEBUG,
7665 "P2P: Cannot force GO on any of the channels we are already using");
7666 goto fail;
7667 }
7668
7669 /* try using the setting from the configuration file */
7670 if (wpa_s->conf->p2p_oper_reg_class == 81 &&
7671 wpa_s->conf->p2p_oper_channel >= 1 &&
7672 wpa_s->conf->p2p_oper_channel <= 11 &&
7673 wpas_p2p_supported_freq_go(
7674 wpa_s, channels,
7675 2407 + 5 * wpa_s->conf->p2p_oper_channel)) {
7676 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
7677 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured "
7678 "frequency %d MHz", params->freq);
7679 goto success;
7680 }
7681
7682 if ((wpa_s->conf->p2p_oper_reg_class == 115 ||
7683 wpa_s->conf->p2p_oper_reg_class == 116 ||
7684 wpa_s->conf->p2p_oper_reg_class == 117 ||
7685 wpa_s->conf->p2p_oper_reg_class == 124 ||
7686 wpa_s->conf->p2p_oper_reg_class == 125 ||
7687 wpa_s->conf->p2p_oper_reg_class == 126 ||
7688 wpa_s->conf->p2p_oper_reg_class == 127) &&
7689 wpas_p2p_supported_freq_go(wpa_s, channels,
7690 5000 +
7691 5 * wpa_s->conf->p2p_oper_channel)) {
7692 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
7693 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured "
7694 "frequency %d MHz", params->freq);
7695 goto success;
7696 }
7697
7698 /* Try using best channels */
7699 if (wpa_s->conf->p2p_oper_channel == 0 &&
7700 wpa_s->best_overall_freq > 0 &&
7701 wpas_p2p_supported_freq_go(wpa_s, channels,
7702 wpa_s->best_overall_freq)) {
7703 params->freq = wpa_s->best_overall_freq;
7704 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best overall "
7705 "channel %d MHz", params->freq);
7706 goto success;
7707 }
7708
7709 if (wpa_s->conf->p2p_oper_channel == 0 &&
7710 wpa_s->best_24_freq > 0 &&
7711 wpas_p2p_supported_freq_go(wpa_s, channels,
7712 wpa_s->best_24_freq)) {
7713 params->freq = wpa_s->best_24_freq;
7714 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 2.4 GHz "
7715 "channel %d MHz", params->freq);
7716 goto success;
7717 }
7718
7719 if (wpa_s->conf->p2p_oper_channel == 0 &&
7720 wpa_s->best_5_freq > 0 &&
7721 wpas_p2p_supported_freq_go(wpa_s, channels,
7722 wpa_s->best_5_freq)) {
7723 params->freq = wpa_s->best_5_freq;
7724 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 5 GHz "
7725 "channel %d MHz", params->freq);
7726 goto success;
7727 }
7728
7729 /* try using preferred channels */
7730 cand = p2p_get_pref_freq(wpa_s->global->p2p, channels);
7731 if (cand && wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
7732 params->freq = cand;
7733 wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz from preferred "
7734 "channels", params->freq);
7735 goto success;
7736 }
7737
7738 /* Try using a channel that allows VHT to be used with 80 MHz */
7739 if (wpa_s->hw.modes && wpa_s->p2p_group_common_freqs) {
7740 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
7741 enum hostapd_hw_mode mode;
7742 struct hostapd_hw_modes *hwmode;
7743 u8 chan;
7744 u8 op_class;
7745
7746 cand = wpa_s->p2p_group_common_freqs[i];
7747 op_class = is_6ghz_freq(cand) ? 133 : 128;
7748 mode = ieee80211_freq_to_chan(cand, &chan);
7749 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
7750 mode, is_6ghz_freq(cand));
7751 if (!hwmode ||
7752 wpas_p2p_verify_channel(wpa_s, hwmode, op_class,
7753 chan, BW80) != ALLOWED)
7754 continue;
7755 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
7756 params->freq = cand;
7757 wpa_printf(MSG_DEBUG,
7758 "P2P: Use freq %d MHz common with the peer and allowing VHT80",
7759 params->freq);
7760 goto success;
7761 }
7762 }
7763 }
7764
7765 /* Try using a channel that allows HT to be used with 40 MHz on the same
7766 * band so that CSA can be used */
7767 if (wpa_s->current_ssid && wpa_s->hw.modes &&
7768 wpa_s->p2p_group_common_freqs) {
7769 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
7770 enum hostapd_hw_mode mode;
7771 struct hostapd_hw_modes *hwmode;
7772 u8 chan, op_class;
7773 bool is_6ghz, supported = false;
7774
7775 is_6ghz = is_6ghz_freq(cand);
7776 cand = wpa_s->p2p_group_common_freqs[i];
7777 mode = ieee80211_freq_to_chan(cand, &chan);
7778 hwmode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes,
7779 mode, is_6ghz);
7780 if (!wpas_same_band(wpa_s->current_ssid->frequency,
7781 cand) ||
7782 !hwmode)
7783 continue;
7784 if (is_6ghz &&
7785 wpas_p2p_verify_channel(wpa_s, hwmode, 132, chan,
7786 BW40) == ALLOWED)
7787 supported = true;
7788
7789 if (!is_6ghz &&
7790 ieee80211_freq_to_channel_ext(
7791 cand, -1, CONF_OPER_CHWIDTH_USE_HT,
7792 &op_class, &chan) != NUM_HOSTAPD_MODES &&
7793 wpas_p2p_verify_channel(
7794 wpa_s, hwmode, op_class, chan,
7795 BW40MINUS) == ALLOWED)
7796 supported = true;
7797
7798 if (!supported && !is_6ghz &&
7799 ieee80211_freq_to_channel_ext(
7800 cand, 1, CONF_OPER_CHWIDTH_USE_HT,
7801 &op_class, &chan) != NUM_HOSTAPD_MODES &&
7802 wpas_p2p_verify_channel(
7803 wpa_s, hwmode, op_class, chan,
7804 BW40PLUS) == ALLOWED)
7805 supported = true;
7806
7807 if (!supported)
7808 continue;
7809
7810 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
7811 params->freq = cand;
7812 wpa_printf(MSG_DEBUG,
7813 "P2P: Use freq %d MHz common with the peer, allowing HT40, and maintaining same band",
7814 params->freq);
7815 goto success;
7816 }
7817 }
7818 }
7819
7820 /* Try using one of the group common freqs on the same band so that CSA
7821 * can be used */
7822 if (wpa_s->current_ssid && wpa_s->p2p_group_common_freqs) {
7823 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
7824 cand = wpa_s->p2p_group_common_freqs[i];
7825 if (!wpas_same_band(wpa_s->current_ssid->frequency,
7826 cand))
7827 continue;
7828 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
7829 params->freq = cand;
7830 wpa_printf(MSG_DEBUG,
7831 "P2P: Use freq %d MHz common with the peer and maintaining same band",
7832 params->freq);
7833 goto success;
7834 }
7835 }
7836 }
7837
7838 /* Try using one of the group common freqs */
7839 if (wpa_s->p2p_group_common_freqs) {
7840 for (i = 0; i < wpa_s->p2p_group_common_freqs_num; i++) {
7841 cand = wpa_s->p2p_group_common_freqs[i];
7842 if (wpas_p2p_supported_freq_go(wpa_s, channels, cand)) {
7843 params->freq = cand;
7844 wpa_printf(MSG_DEBUG,
7845 "P2P: Use freq %d MHz common with the peer",
7846 params->freq);
7847 goto success;
7848 }
7849 }
7850 }
7851
7852 /* no preference, select some channel */
7853 wpas_p2p_select_go_freq_no_pref(wpa_s, params, channels);
7854
7855 if (params->freq == 0) {
7856 wpa_printf(MSG_DEBUG, "P2P: did not find a freq for GO use");
7857 goto fail;
7858 }
7859
7860 success:
7861 os_free(freqs);
7862 return 0;
7863 fail:
7864 os_free(freqs);
7865 return -1;
7866 }
7867
7868
7869 static struct wpa_supplicant *
wpas_p2p_get_group_iface(struct wpa_supplicant * wpa_s,int addr_allocated,int go)7870 wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
7871 int go)
7872 {
7873 struct wpa_supplicant *group_wpa_s;
7874
7875 if (!wpas_p2p_create_iface(wpa_s)) {
7876 if (wpa_s->p2p_mgmt) {
7877 /*
7878 * We may be called on the p2p_dev interface which
7879 * cannot be used for group operations, so always use
7880 * the primary interface.
7881 */
7882 wpa_s->parent->p2pdev = wpa_s;
7883 wpa_s = wpa_s->parent;
7884 }
7885 wpa_dbg(wpa_s, MSG_DEBUG,
7886 "P2P: Use primary interface for group operations");
7887 wpa_s->p2p_first_connection_timeout = 0;
7888 if (wpa_s != wpa_s->p2pdev)
7889 wpas_p2p_clone_config(wpa_s, wpa_s->p2pdev);
7890 return wpa_s;
7891 }
7892
7893 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
7894 WPA_IF_P2P_CLIENT) < 0) {
7895 wpa_msg_global(wpa_s, MSG_ERROR,
7896 "P2P: Failed to add group interface");
7897 return NULL;
7898 }
7899 group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go);
7900 if (group_wpa_s == NULL) {
7901 wpa_msg_global(wpa_s, MSG_ERROR,
7902 "P2P: Failed to initialize group interface");
7903 wpas_p2p_remove_pending_group_interface(wpa_s);
7904 return NULL;
7905 }
7906
7907 if (go && wpa_s->p2p_go_do_acs) {
7908 group_wpa_s->p2p_go_do_acs = wpa_s->p2p_go_do_acs;
7909 group_wpa_s->p2p_go_acs_band = wpa_s->p2p_go_acs_band;
7910 wpa_s->p2p_go_do_acs = 0;
7911 }
7912
7913 if (go && wpa_s->p2p_go_allow_dfs) {
7914 group_wpa_s->p2p_go_allow_dfs = wpa_s->p2p_go_allow_dfs;
7915 wpa_s->p2p_go_allow_dfs = 0;
7916 }
7917
7918 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use separate group interface %s",
7919 group_wpa_s->ifname);
7920 group_wpa_s->p2p_first_connection_timeout = 0;
7921 return group_wpa_s;
7922 }
7923
7924
7925 /**
7926 * wpas_p2p_group_add - Add a new P2P group with local end as Group Owner
7927 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
7928 * @persistent_group: Whether to create a persistent group
7929 * @freq: Frequency for the group or 0 to indicate no hardcoding
7930 * @vht_center_freq2: segment_1 center frequency for GO operating in VHT 80P80
7931 * @ht40: Start GO with 40 MHz channel width
7932 * @vht: Start GO with VHT support
7933 * @vht_chwidth: channel bandwidth for GO operating with VHT support
7934 * @edmg: Start GO with EDMG support
7935 * @allow_6ghz: Allow P2P group creation on a 6 GHz channel
7936 * @p2p_mode: Operation mode for GO (R1/R2/PCC)
7937 * Returns: 0 on success, -1 on failure
7938 *
7939 * This function creates a new P2P group with the local end as the Group Owner,
7940 * i.e., without using Group Owner Negotiation.
7941 */
wpas_p2p_group_add(struct wpa_supplicant * wpa_s,int persistent_group,int freq,int vht_center_freq2,int ht40,int vht,int max_oper_chwidth,int he,int edmg,bool allow_6ghz,bool p2p2,enum wpa_p2p_mode p2p_mode)7942 int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
7943 int freq, int vht_center_freq2, int ht40, int vht,
7944 int max_oper_chwidth, int he, int edmg,
7945 bool allow_6ghz, bool p2p2, enum wpa_p2p_mode p2p_mode)
7946 {
7947 struct p2p_go_neg_results params;
7948 int selected_freq = 0;
7949
7950 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7951 return -1;
7952 if (wpas_p2p_check_6ghz(wpa_s, NULL, allow_6ghz, freq))
7953 return -1;
7954
7955 os_free(wpa_s->global->add_psk);
7956 wpa_s->global->add_psk = NULL;
7957 wpa_s->p2p2 = p2p2;
7958 wpa_s->p2p_mode = p2p_mode;
7959
7960 /* Make sure we are not running find during connection establishment */
7961 wpa_printf(MSG_DEBUG, "P2P: Stop any on-going P2P FIND");
7962 wpas_p2p_stop_find_oper(wpa_s);
7963
7964 if (!wpa_s->p2p_go_do_acs) {
7965 selected_freq = wpas_p2p_select_go_freq(wpa_s, freq);
7966 if (selected_freq < 0)
7967 return -1;
7968 }
7969
7970 if (wpas_p2p_init_go_params(wpa_s, ¶ms, selected_freq,
7971 vht_center_freq2,
7972 ht40, vht, max_oper_chwidth, he, edmg,
7973 NULL))
7974 return -1;
7975
7976 p2p_go_params(wpa_s->global->p2p, ¶ms);
7977 params.persistent_group = persistent_group;
7978
7979 wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
7980 if (wpa_s == NULL)
7981 return -1;
7982 if (freq > 0)
7983 wpa_s->p2p_go_no_pri_sec_switch = 1;
7984 params.p2p2 = wpa_s->p2p2;
7985 wpas_start_go(wpa_s, ¶ms, 0, p2p_mode);
7986
7987 return 0;
7988 }
7989
7990
wpas_start_p2p_client(struct wpa_supplicant * wpa_s,struct wpa_ssid * params,int addr_allocated,int freq,int force_scan,int retry_limit,const u8 * go_bssid,bool p2p2,const u8 * pmkid,const u8 * pmk,size_t pmk_len)7991 static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s,
7992 struct wpa_ssid *params, int addr_allocated,
7993 int freq, int force_scan, int retry_limit,
7994 const u8 *go_bssid, bool p2p2, const u8 *pmkid,
7995 const u8 *pmk, size_t pmk_len)
7996 {
7997 struct os_reltime now;
7998 struct wpa_ssid *ssid;
7999 int other_iface_found = 0;
8000 struct wpa_supplicant *ifs;
8001 struct rsn_pmksa_cache_entry *entry;
8002
8003 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0);
8004 if (wpa_s == NULL)
8005 return -1;
8006 if (force_scan)
8007 os_get_reltime(&wpa_s->scan_min_time);
8008 wpa_s->p2p_last_4way_hs_fail = NULL;
8009
8010 wpa_supplicant_ap_deinit(wpa_s);
8011
8012 ssid = wpa_config_add_network(wpa_s->conf);
8013 if (ssid == NULL)
8014 return -1;
8015 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN);
8016 wpa_config_set_network_defaults(ssid);
8017 ssid->temporary = 1;
8018 ssid->proto = WPA_PROTO_RSN;
8019 ssid->pbss = params->pbss;
8020 ssid->pairwise_cipher = params->pbss ? WPA_CIPHER_GCMP :
8021 WPA_CIPHER_CCMP;
8022 ssid->group_cipher = params->pbss ? WPA_CIPHER_GCMP : WPA_CIPHER_CCMP;
8023 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
8024 if (is_6ghz_freq(freq) &&
8025 is_p2p_6ghz_capable(wpa_s->global->p2p)) {
8026 ssid->auth_alg |= WPA_AUTH_ALG_SAE;
8027 ssid->key_mgmt |= WPA_KEY_MGMT_SAE;
8028 ssid->ieee80211w = MGMT_FRAME_PROTECTION_OPTIONAL;
8029 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
8030 wpa_dbg(wpa_s, MSG_DEBUG,
8031 "P2P: Enable SAE auth_alg and key_mgmt");
8032 }
8033
8034 ssid->ssid = os_malloc(params->ssid_len);
8035 if (ssid->ssid == NULL) {
8036 wpa_config_remove_network(wpa_s->conf, ssid->id);
8037 return -1;
8038 }
8039 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
8040 ssid->ssid_len = params->ssid_len;
8041 ssid->p2p_group = 1;
8042 ssid->export_keys = 1;
8043 if (params->psk_set) {
8044 os_memcpy(ssid->psk, params->psk, 32);
8045 ssid->psk_set = 1;
8046 }
8047 if (params->passphrase)
8048 ssid->passphrase = os_strdup(params->passphrase);
8049
8050 if (go_bssid) {
8051 ssid->bssid_set = 1;
8052 os_memcpy(ssid->bssid, go_bssid, ETH_ALEN);
8053 }
8054
8055 if (p2p2) {
8056 ssid->key_mgmt = WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_PASN;
8057 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
8058 ssid->sae_pwe = SAE_PWE_HASH_TO_ELEMENT;
8059 ssid->ieee80211w = MGMT_FRAME_PROTECTION_REQUIRED;
8060 ssid->disabled = 0;
8061
8062 if (pmk && pmk_len && pmkid) {
8063 entry = os_zalloc(sizeof(*entry));
8064 if (!entry)
8065 return -1;
8066 os_memcpy(entry->aa, ssid->bssid, ETH_ALEN);
8067 os_memcpy(entry->pmkid, pmkid, PMKID_LEN);
8068 entry->pmk_len = pmk_len;
8069 os_memcpy(entry->pmk, pmk, pmk_len);
8070 entry->akmp = WPA_KEY_MGMT_SAE;
8071 os_get_reltime(&now);
8072 entry->expiration = now.sec + 43200;
8073 entry->reauth_time = now.sec + 43200 * 70 / 100;
8074 entry->network_ctx = ssid;
8075 os_memcpy(entry->spa, wpa_s->own_addr, ETH_ALEN);
8076
8077 wpa_sm_pmksa_cache_add_entry(wpa_s->wpa, entry);
8078 ssid->pmk_valid = true;
8079 }
8080 wpa_s->current_ssid = ssid;
8081 }
8082
8083 wpa_s->show_group_started = 1;
8084 wpa_s->p2p_in_invitation = 1;
8085 wpa_s->p2p_retry_limit = retry_limit;
8086 wpa_s->p2p_invite_go_freq = freq;
8087 wpa_s->p2p_go_group_formation_completed = 0;
8088 wpa_s->global->p2p_group_formation = wpa_s;
8089
8090 /*
8091 * Get latest scan results from driver in case cached scan results from
8092 * interfaces on the same wiphy allow us to skip the next scan by fast
8093 * associating. Also update the scan time to the most recent scan result
8094 * fetch time on the same radio so it reflects the actual time the last
8095 * scan result event occurred.
8096 */
8097 wpa_supplicant_update_scan_results(wpa_s, go_bssid);
8098 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
8099 radio_list) {
8100 if (ifs == wpa_s)
8101 continue;
8102 if (!other_iface_found || os_reltime_before(&wpa_s->last_scan,
8103 &ifs->last_scan)) {
8104 other_iface_found = 1;
8105 wpa_s->last_scan.sec = ifs->last_scan.sec;
8106 wpa_s->last_scan.usec = ifs->last_scan.usec;
8107 }
8108 }
8109
8110 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->p2pdev,
8111 NULL);
8112 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
8113 wpas_p2p_group_formation_timeout,
8114 wpa_s->p2pdev, NULL);
8115 wpa_supplicant_select_network(wpa_s, ssid);
8116
8117 return 0;
8118 }
8119
8120
wpas_p2p_group_add_persistent(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid,int addr_allocated,int force_freq,int neg_freq,int vht_center_freq2,int ht40,int vht,int max_oper_chwidth,int he,int edmg,const struct p2p_channels * channels,int connection_timeout,int force_scan,bool allow_6ghz,int retry_limit,const u8 * go_bssid,const u8 * dev_addr,const u8 * pmkid,const u8 * pmk,size_t pmk_len)8121 int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s,
8122 struct wpa_ssid *ssid, int addr_allocated,
8123 int force_freq, int neg_freq,
8124 int vht_center_freq2, int ht40,
8125 int vht, int max_oper_chwidth, int he,
8126 int edmg,
8127 const struct p2p_channels *channels,
8128 int connection_timeout, int force_scan,
8129 bool allow_6ghz, int retry_limit,
8130 const u8 *go_bssid, const u8 *dev_addr,
8131 const u8 *pmkid, const u8 *pmk,
8132 size_t pmk_len)
8133 {
8134 struct p2p_go_neg_results params;
8135 int go = 0, freq;
8136
8137 if (ssid->disabled != 2 || ssid->ssid == NULL)
8138 return -1;
8139
8140 if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) &&
8141 go == (ssid->mode == WPAS_MODE_P2P_GO)) {
8142 wpa_printf(MSG_DEBUG, "P2P: Requested persistent group is "
8143 "already running");
8144 if (go == 0 &&
8145 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
8146 wpa_s->p2pdev, NULL)) {
8147 /*
8148 * This can happen if Invitation Response frame was lost
8149 * and the peer (GO of a persistent group) tries to
8150 * invite us again. Reschedule the timeout to avoid
8151 * terminating the wait for the connection too early
8152 * since we now know that the peer is still trying to
8153 * invite us instead of having already started the GO.
8154 */
8155 wpa_printf(MSG_DEBUG,
8156 "P2P: Reschedule group formation timeout since peer is still trying to invite us");
8157 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
8158 wpas_p2p_group_formation_timeout,
8159 wpa_s->p2pdev, NULL);
8160 }
8161 return 0;
8162 }
8163
8164 os_free(wpa_s->global->add_psk);
8165 wpa_s->global->add_psk = NULL;
8166
8167 /* Make sure we are not running find during connection establishment */
8168 wpas_p2p_stop_find_oper(wpa_s);
8169
8170 wpa_s->p2p_fallback_to_go_neg = 0;
8171
8172 if (ssid->mode == WPAS_MODE_P2P_GO) {
8173 if (force_freq > 0) {
8174 freq = wpas_p2p_select_go_freq(wpa_s, force_freq);
8175 if (freq < 0)
8176 return -1;
8177 wpa_s->p2p_go_no_pri_sec_switch = 1;
8178 } else {
8179 freq = wpas_p2p_select_go_freq(wpa_s, neg_freq);
8180 if (freq < 0 ||
8181 (freq > 0 && !freq_included(wpa_s, channels, freq)))
8182 freq = 0;
8183 }
8184 } else if (ssid->mode == WPAS_MODE_INFRA) {
8185 freq = neg_freq;
8186 if (freq <= 0 || !freq_included(wpa_s, channels, freq)) {
8187 struct os_reltime now;
8188 struct wpa_bss *bss =
8189 wpa_bss_get_p2p_dev_addr(wpa_s, ssid->bssid);
8190
8191 os_get_reltime(&now);
8192 if (bss &&
8193 !os_reltime_expired(&now, &bss->last_update, 5) &&
8194 freq_included(wpa_s, channels, bss->freq))
8195 freq = bss->freq;
8196 else
8197 freq = 0;
8198 }
8199
8200 return wpas_start_p2p_client(wpa_s, ssid, addr_allocated, freq,
8201 force_scan, retry_limit, go_bssid,
8202 wpa_s->p2p2, pmkid, pmk, pmk_len);
8203 } else {
8204 return -1;
8205 }
8206
8207 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, vht_center_freq2,
8208 ht40, vht, max_oper_chwidth, he, edmg,
8209 channels))
8210 return -1;
8211
8212 params.role_go = 1;
8213 params.psk_set = ssid->psk_set;
8214 if (params.psk_set)
8215 os_memcpy(params.psk, ssid->psk, sizeof(params.psk));
8216 if (ssid->passphrase) {
8217 if (os_strlen(ssid->passphrase) >= sizeof(params.passphrase)) {
8218 wpa_printf(MSG_ERROR, "P2P: Invalid passphrase in "
8219 "persistent group");
8220 return -1;
8221 }
8222 os_strlcpy(params.passphrase, ssid->passphrase,
8223 sizeof(params.passphrase));
8224 }
8225 os_memcpy(params.ssid, ssid->ssid, ssid->ssid_len);
8226 params.ssid_len = ssid->ssid_len;
8227 params.persistent_group = 1;
8228
8229 if (wpa_s->p2p2 && pmk_len && pmk && pmkid) {
8230 os_memcpy(params.peer_device_addr, dev_addr, ETH_ALEN);
8231 os_memcpy(params.pmkid, pmkid, PMKID_LEN);
8232 os_memcpy(params.pmk, pmk, pmk_len);
8233 params.pmk_len = pmk_len;
8234 params.akmp = WPA_KEY_MGMT_SAE;
8235 params.p2p2 = true;
8236 }
8237
8238 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1);
8239 if (wpa_s == NULL)
8240 return -1;
8241
8242 p2p_channels_to_freqs(channels, params.freq_list, P2P_MAX_CHANNELS);
8243
8244 wpa_s->p2p_first_connection_timeout = connection_timeout;
8245 params.p2p2 = wpa_s->p2p2;
8246 wpas_start_go(wpa_s, ¶ms, 0, wpa_s->p2p_mode);
8247
8248 return 0;
8249 }
8250
8251
wpas_p2p_ie_update(void * ctx,struct wpabuf * beacon_ies,struct wpabuf * proberesp_ies)8252 static void wpas_p2p_ie_update(void *ctx, struct wpabuf *beacon_ies,
8253 struct wpabuf *proberesp_ies)
8254 {
8255 struct wpa_supplicant *wpa_s = ctx;
8256 if (wpa_s->ap_iface) {
8257 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
8258 if (!(hapd->conf->p2p & P2P_GROUP_OWNER)) {
8259 wpabuf_free(beacon_ies);
8260 wpabuf_free(proberesp_ies);
8261 return;
8262 }
8263 if (beacon_ies) {
8264 wpabuf_free(hapd->p2p_beacon_ie);
8265 hapd->p2p_beacon_ie = beacon_ies;
8266 }
8267 wpabuf_free(hapd->p2p_probe_resp_ie);
8268 hapd->p2p_probe_resp_ie = proberesp_ies;
8269
8270 if (wpa_s->p2p2) {
8271 hapd->iconf->peer_to_peer_twt = true;
8272 hapd->iconf->channel_usage = true;
8273 }
8274
8275 } else {
8276 wpabuf_free(beacon_ies);
8277 wpabuf_free(proberesp_ies);
8278 }
8279 wpa_supplicant_ap_update_beacon(wpa_s);
8280 }
8281
8282
wpas_p2p_idle_update(void * ctx,int idle)8283 static void wpas_p2p_idle_update(void *ctx, int idle)
8284 {
8285 struct wpa_supplicant *wpa_s = ctx;
8286 if (!wpa_s->ap_iface)
8287 return;
8288 wpa_printf(MSG_DEBUG, "P2P: GO - group %sidle", idle ? "" : "not ");
8289 if (idle) {
8290 if (wpa_s->global->p2p_fail_on_wps_complete &&
8291 wpa_s->p2p_in_provisioning) {
8292 wpas_p2p_grpform_fail_after_wps(wpa_s);
8293 return;
8294 }
8295 wpas_p2p_set_group_idle_timeout(wpa_s);
8296 } else
8297 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
8298 }
8299
8300
wpas_p2p_group_init(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)8301 struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
8302 struct wpa_ssid *ssid)
8303 {
8304 struct p2p_group *group;
8305 struct p2p_group_config *cfg;
8306
8307 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
8308 !ssid->p2p_group)
8309 return NULL;
8310
8311 cfg = os_zalloc(sizeof(*cfg));
8312 if (cfg == NULL)
8313 return NULL;
8314
8315 if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect)
8316 cfg->persistent_group = 2;
8317 else if (ssid->p2p_persistent_group)
8318 cfg->persistent_group = 1;
8319 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
8320 if (wpa_s->max_stations &&
8321 wpa_s->max_stations < wpa_s->conf->max_num_sta)
8322 cfg->max_clients = wpa_s->max_stations;
8323 else
8324 cfg->max_clients = wpa_s->conf->max_num_sta;
8325 os_memcpy(cfg->ssid, ssid->ssid, ssid->ssid_len);
8326 cfg->ssid_len = ssid->ssid_len;
8327 cfg->freq = ssid->frequency;
8328 cfg->cb_ctx = wpa_s;
8329 cfg->ie_update = wpas_p2p_ie_update;
8330 cfg->idle_update = wpas_p2p_idle_update;
8331 cfg->ip_addr_alloc = WPA_GET_BE32(wpa_s->p2pdev->conf->ip_addr_start)
8332 != 0;
8333 cfg->p2p2 = wpa_s->p2p2;
8334
8335 group = p2p_group_init(wpa_s->global->p2p, cfg);
8336 if (group == NULL)
8337 os_free(cfg);
8338 if (ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
8339 p2p_group_notif_formation_done(group);
8340 wpa_s->p2p_group = group;
8341 return group;
8342 }
8343
8344
wpas_p2p_wps_success(struct wpa_supplicant * wpa_s,const u8 * peer_addr,int registrar)8345 void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
8346 int registrar)
8347 {
8348 struct wpa_ssid *ssid = wpa_s->current_ssid;
8349
8350 if (!wpa_s->p2p_in_provisioning) {
8351 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS success event - P2P "
8352 "provisioning not in progress");
8353 return;
8354 }
8355
8356 if (ssid && ssid->mode == WPAS_MODE_INFRA) {
8357 u8 go_dev_addr[ETH_ALEN];
8358 os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN);
8359 wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
8360 ssid->ssid_len);
8361 /* Clear any stored provisioning info */
8362 p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr);
8363 }
8364
8365 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->p2pdev,
8366 NULL);
8367 wpa_s->p2p_go_group_formation_completed = 1;
8368 if (ssid && ssid->mode == WPAS_MODE_INFRA) {
8369 /*
8370 * Use a separate timeout for initial data connection to
8371 * complete to allow the group to be removed automatically if
8372 * something goes wrong in this step before the P2P group idle
8373 * timeout mechanism is taken into use.
8374 */
8375 wpa_dbg(wpa_s, MSG_DEBUG,
8376 "P2P: Re-start group formation timeout (%d seconds) as client for initial connection",
8377 P2P_MAX_INITIAL_CONN_WAIT);
8378 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
8379 wpas_p2p_group_formation_timeout,
8380 wpa_s->p2pdev, NULL);
8381 /* Complete group formation on successful data connection. */
8382 wpa_s->p2p_go_group_formation_completed = 0;
8383 } else if (ssid) {
8384 /*
8385 * Use a separate timeout for initial data connection to
8386 * complete to allow the group to be removed automatically if
8387 * the client does not complete data connection successfully.
8388 */
8389 wpa_dbg(wpa_s, MSG_DEBUG,
8390 "P2P: Re-start group formation timeout (%d seconds) as GO for initial connection",
8391 P2P_MAX_INITIAL_CONN_WAIT_GO);
8392 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT_GO, 0,
8393 wpas_p2p_group_formation_timeout,
8394 wpa_s->p2pdev, NULL);
8395 /*
8396 * Complete group formation on first successful data connection
8397 */
8398 wpa_s->p2p_go_group_formation_completed = 0;
8399 }
8400 if (wpa_s->global->p2p)
8401 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
8402 wpas_group_formation_completed(wpa_s, 0, NULL);
8403 }
8404
8405
wpas_p2p_wps_failed(struct wpa_supplicant * wpa_s,struct wps_event_fail * fail)8406 void wpas_p2p_wps_failed(struct wpa_supplicant *wpa_s,
8407 struct wps_event_fail *fail)
8408 {
8409 if (!wpa_s->p2p_in_provisioning) {
8410 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS fail event - P2P "
8411 "provisioning not in progress");
8412 return;
8413 }
8414
8415 if (wpa_s->go_params) {
8416 p2p_clear_provisioning_info(
8417 wpa_s->global->p2p,
8418 wpa_s->go_params->peer_device_addr);
8419 }
8420
8421 wpas_notify_p2p_wps_failed(wpa_s, fail);
8422
8423 if (wpa_s == wpa_s->global->p2p_group_formation) {
8424 /*
8425 * Allow some time for the failed WPS negotiation exchange to
8426 * complete, but remove the group since group formation cannot
8427 * succeed after provisioning failure.
8428 */
8429 wpa_printf(MSG_DEBUG, "P2P: WPS step failed during group formation - reject connection from timeout");
8430 wpa_s->global->p2p_fail_on_wps_complete = 1;
8431 eloop_deplete_timeout(0, 50000,
8432 wpas_p2p_group_formation_timeout,
8433 wpa_s->p2pdev, NULL);
8434 }
8435 }
8436
8437
wpas_p2p_wps_eapol_cb(struct wpa_supplicant * wpa_s)8438 int wpas_p2p_wps_eapol_cb(struct wpa_supplicant *wpa_s)
8439 {
8440 if (!wpa_s->global->p2p_fail_on_wps_complete ||
8441 !wpa_s->p2p_in_provisioning)
8442 return 0;
8443
8444 wpas_p2p_grpform_fail_after_wps(wpa_s);
8445
8446 return 1;
8447 }
8448
8449
wpas_p2p_prov_disc(struct wpa_supplicant * wpa_s,const u8 * peer_addr,const char * config_method,u16 bootstrap,enum wpas_p2p_prov_disc_use use,struct p2ps_provision * p2ps_prov)8450 int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
8451 const char *config_method, u16 bootstrap,
8452 enum wpas_p2p_prov_disc_use use,
8453 struct p2ps_provision *p2ps_prov)
8454 {
8455 u16 config_methods;
8456
8457 wpa_s->global->pending_p2ps_group = 0;
8458 wpa_s->global->pending_p2ps_group_freq = 0;
8459 wpa_s->p2p_fallback_to_go_neg = 0;
8460 wpa_s->pending_pd_use = NORMAL_PD;
8461 if (p2ps_prov && use == WPAS_P2P_PD_FOR_ASP) {
8462 p2ps_prov->conncap = p2ps_group_capability(
8463 wpa_s, P2PS_SETUP_NONE, p2ps_prov->role,
8464 &p2ps_prov->force_freq, &p2ps_prov->pref_freq);
8465
8466 wpa_printf(MSG_DEBUG,
8467 "P2P: %s conncap: %d - ASP parsed: %x %x %d %s",
8468 __func__, p2ps_prov->conncap,
8469 p2ps_prov->adv_id, p2ps_prov->conncap,
8470 p2ps_prov->status, p2ps_prov->info);
8471
8472 config_methods = 0;
8473 } else if (bootstrap) {
8474 wpa_s->p2p2 = true;
8475 config_methods = 0;
8476 wpa_s->p2p_bootstrap = bootstrap;
8477 p2p_set_req_bootstrap_method(wpa_s->global->p2p, peer_addr,
8478 bootstrap);
8479 } else if (os_strncmp(config_method, "display", 7) == 0)
8480 config_methods = WPS_CONFIG_DISPLAY;
8481 else if (os_strncmp(config_method, "keypad", 6) == 0)
8482 config_methods = WPS_CONFIG_KEYPAD;
8483 else if (os_strncmp(config_method, "pbc", 3) == 0 ||
8484 os_strncmp(config_method, "pushbutton", 10) == 0)
8485 config_methods = WPS_CONFIG_PUSHBUTTON;
8486 else {
8487 wpa_printf(MSG_DEBUG, "P2P: Unknown config method");
8488 os_free(p2ps_prov);
8489 return -1;
8490 }
8491
8492 if (use == WPAS_P2P_PD_AUTO) {
8493 os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN);
8494 wpa_s->pending_pd_config_methods = config_methods;
8495 wpa_s->p2p_auto_pd = 1;
8496 wpa_s->p2p_auto_join = 0;
8497 wpa_s->pending_pd_before_join = 0;
8498 wpa_s->auto_pd_scan_retry = 0;
8499 wpas_p2p_stop_find(wpa_s);
8500 wpa_s->p2p_join_scan_count = 0;
8501 os_get_reltime(&wpa_s->p2p_auto_started);
8502 wpa_printf(MSG_DEBUG, "P2P: Auto PD started at %ld.%06ld",
8503 wpa_s->p2p_auto_started.sec,
8504 wpa_s->p2p_auto_started.usec);
8505 wpas_p2p_join_scan(wpa_s, NULL);
8506 return 0;
8507 }
8508
8509 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) {
8510 os_free(p2ps_prov);
8511 return -1;
8512 }
8513
8514 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr, p2ps_prov,
8515 config_methods, use == WPAS_P2P_PD_FOR_JOIN,
8516 0, 1);
8517 }
8518
8519
wpas_p2p_scan_result_text(const u8 * ies,size_t ies_len,char * buf,char * end)8520 int wpas_p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf,
8521 char *end)
8522 {
8523 return p2p_scan_result_text(ies, ies_len, buf, end);
8524 }
8525
8526
wpas_p2p_clear_pending_action_tx(struct wpa_supplicant * wpa_s,bool force)8527 static void wpas_p2p_clear_pending_action_tx(struct wpa_supplicant *wpa_s,
8528 bool force)
8529 {
8530 if (!offchannel_pending_action_tx(wpa_s) && !force)
8531 return;
8532
8533 if (wpa_s->p2p_send_action_work) {
8534 wpas_p2p_free_send_action_work(wpa_s);
8535 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
8536 wpa_s, NULL);
8537 offchannel_send_action_done(wpa_s);
8538 }
8539
8540 if (!offchannel_pending_action_tx(wpa_s))
8541 return;
8542 wpa_printf(MSG_DEBUG, "P2P: Drop pending Action TX due to new "
8543 "operation request");
8544 offchannel_clear_pending_action_tx(wpa_s);
8545 }
8546
8547
wpas_p2p_find(struct wpa_supplicant * wpa_s,unsigned int timeout,enum p2p_discovery_type type,unsigned int num_req_dev_types,const u8 * req_dev_types,const u8 * dev_id,unsigned int search_delay,u8 seek_cnt,const char ** seek_string,int freq,bool include_6ghz)8548 int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
8549 enum p2p_discovery_type type,
8550 unsigned int num_req_dev_types, const u8 *req_dev_types,
8551 const u8 *dev_id, unsigned int search_delay,
8552 u8 seek_cnt, const char **seek_string, int freq,
8553 bool include_6ghz)
8554 {
8555 wpas_p2p_clear_pending_action_tx(wpa_s, false);
8556 wpa_s->global->p2p_long_listen = 0;
8557
8558 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
8559 wpa_s->p2p_in_provisioning) {
8560 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Reject p2p_find operation%s%s",
8561 (wpa_s->global->p2p_disabled || !wpa_s->global->p2p) ?
8562 " (P2P disabled)" : "",
8563 wpa_s->p2p_in_provisioning ?
8564 " (p2p_in_provisioning)" : "");
8565 return -1;
8566 }
8567
8568 wpa_supplicant_cancel_sched_scan(wpa_s);
8569
8570 return p2p_find(wpa_s->global->p2p, timeout, type,
8571 num_req_dev_types, req_dev_types, dev_id,
8572 search_delay, seek_cnt, seek_string, freq,
8573 include_6ghz);
8574 }
8575
8576
wpas_p2p_scan_res_ignore_search(struct wpa_supplicant * wpa_s,struct wpa_scan_results * scan_res)8577 static void wpas_p2p_scan_res_ignore_search(struct wpa_supplicant *wpa_s,
8578 struct wpa_scan_results *scan_res)
8579 {
8580 wpa_printf(MSG_DEBUG, "P2P: Ignore scan results");
8581
8582 if (wpa_s->p2p_scan_work) {
8583 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
8584 wpa_s->p2p_scan_work = NULL;
8585 radio_work_done(work);
8586 }
8587
8588 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8589 return;
8590
8591 /*
8592 * Indicate that results have been processed so that the P2P module can
8593 * continue pending tasks.
8594 */
8595 wpas_p2p_scan_res_handled(wpa_s);
8596 }
8597
8598
wpas_p2p_stop_find_oper(struct wpa_supplicant * wpa_s)8599 static void wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s)
8600 {
8601 wpas_p2p_clear_pending_action_tx(wpa_s, true);
8602 wpa_s->global->p2p_long_listen = 0;
8603 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
8604 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
8605
8606 if (wpa_s->global->p2p)
8607 p2p_stop_find(wpa_s->global->p2p);
8608
8609 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_handler) {
8610 wpa_printf(MSG_DEBUG,
8611 "P2P: Do not consider the scan results after stop_find");
8612 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore_search;
8613 }
8614 }
8615
8616
wpas_p2p_stop_find(struct wpa_supplicant * wpa_s)8617 void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s)
8618 {
8619 wpas_p2p_stop_find_oper(wpa_s);
8620 if (!wpa_s->global->pending_group_iface_for_p2ps)
8621 wpas_p2p_remove_pending_group_interface(wpa_s);
8622 }
8623
8624
wpas_p2p_long_listen_timeout(void * eloop_ctx,void * timeout_ctx)8625 static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx)
8626 {
8627 struct wpa_supplicant *wpa_s = eloop_ctx;
8628 wpa_s->global->p2p_long_listen = 0;
8629 }
8630
8631
wpas_p2p_listen(struct wpa_supplicant * wpa_s,unsigned int timeout)8632 int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout)
8633 {
8634 int res;
8635
8636 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8637 return -1;
8638
8639 if (wpa_s->p2p_lo_started) {
8640 wpa_printf(MSG_DEBUG,
8641 "P2P: Cannot start P2P listen, it is offloaded");
8642 return -1;
8643 }
8644
8645 wpa_supplicant_cancel_sched_scan(wpa_s);
8646 wpas_p2p_clear_pending_action_tx(wpa_s, false);
8647
8648 if (timeout == 0) {
8649 /*
8650 * This is a request for unlimited Listen state. However, at
8651 * least for now, this is mapped to a Listen state for one
8652 * hour.
8653 */
8654 timeout = 3600;
8655 }
8656 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
8657 wpa_s->global->p2p_long_listen = 0;
8658
8659 /*
8660 * Stop previous find/listen operation to avoid trying to request a new
8661 * remain-on-channel operation while the driver is still running the
8662 * previous one.
8663 */
8664 if (wpa_s->global->p2p)
8665 p2p_stop_find(wpa_s->global->p2p);
8666
8667 res = wpas_p2p_listen_start(wpa_s, timeout * 1000);
8668 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
8669 wpa_s->global->p2p_long_listen = timeout * 1000;
8670 eloop_register_timeout(timeout, 0,
8671 wpas_p2p_long_listen_timeout,
8672 wpa_s, NULL);
8673 }
8674
8675 return res;
8676 }
8677
8678
wpas_p2p_assoc_req_ie(struct wpa_supplicant * wpa_s,struct wpa_bss * bss,u8 * buf,size_t len,int p2p_group)8679 int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
8680 u8 *buf, size_t len, int p2p_group)
8681 {
8682 struct wpabuf *p2p_ie;
8683 int ret;
8684
8685 if (wpa_s->global->p2p_disabled)
8686 return -1;
8687 /*
8688 * Advertize mandatory cross connection capability even on
8689 * p2p_disabled=1 interface when associating with a P2P Manager WLAN AP.
8690 */
8691 if (wpa_s->conf->p2p_disabled && p2p_group)
8692 return -1;
8693 if (wpa_s->global->p2p == NULL)
8694 return -1;
8695 if (bss == NULL)
8696 return -1;
8697
8698 p2p_ie = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
8699 ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len,
8700 p2p_group, p2p_ie);
8701 wpabuf_free(p2p_ie);
8702
8703 return ret;
8704 }
8705
8706
wpas_p2p_probe_req_rx(struct wpa_supplicant * wpa_s,const u8 * addr,const u8 * dst,const u8 * bssid,const u8 * ie,size_t ie_len,unsigned int rx_freq,int ssi_signal)8707 int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr,
8708 const u8 *dst, const u8 *bssid,
8709 const u8 *ie, size_t ie_len,
8710 unsigned int rx_freq, int ssi_signal)
8711 {
8712 if (wpa_s->global->p2p_disabled)
8713 return 0;
8714 if (wpa_s->global->p2p == NULL)
8715 return 0;
8716
8717 switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid,
8718 ie, ie_len, rx_freq, wpa_s->p2p_lo_started)) {
8719 case P2P_PREQ_NOT_P2P:
8720 wpas_notify_preq(wpa_s, addr, dst, bssid, ie, ie_len,
8721 ssi_signal);
8722 /* fall through */
8723 case P2P_PREQ_MALFORMED:
8724 case P2P_PREQ_NOT_LISTEN:
8725 case P2P_PREQ_NOT_PROCESSED:
8726 default: /* make gcc happy */
8727 return 0;
8728 case P2P_PREQ_PROCESSED:
8729 return 1;
8730 }
8731 }
8732
8733
wpas_p2p_rx_action(struct wpa_supplicant * wpa_s,const u8 * da,const u8 * sa,const u8 * bssid,u8 category,const u8 * data,size_t len,int freq)8734 void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
8735 const u8 *sa, const u8 *bssid,
8736 u8 category, const u8 *data, size_t len, int freq)
8737 {
8738 if (wpa_s->global->p2p_disabled)
8739 return;
8740 if (wpa_s->global->p2p == NULL)
8741 return;
8742
8743 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
8744 freq);
8745 }
8746
8747
wpas_p2p_scan_ie(struct wpa_supplicant * wpa_s,struct wpabuf * ies)8748 void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies)
8749 {
8750 unsigned int bands;
8751
8752 if (wpa_s->global->p2p_disabled)
8753 return;
8754 if (wpa_s->global->p2p == NULL)
8755 return;
8756
8757 bands = wpas_get_bands(wpa_s, NULL);
8758 p2p_scan_ie(wpa_s->global->p2p, ies, NULL, bands);
8759 }
8760
8761
wpas_p2p_group_deinit(struct wpa_supplicant * wpa_s)8762 static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s)
8763 {
8764 p2p_group_deinit(wpa_s->p2p_group);
8765 wpa_s->p2p_group = NULL;
8766
8767 wpa_s->ap_configured_cb = NULL;
8768 wpa_s->ap_configured_cb_ctx = NULL;
8769 wpa_s->ap_configured_cb_data = NULL;
8770 wpa_s->connect_without_scan = NULL;
8771 }
8772
8773
wpas_p2p_reject(struct wpa_supplicant * wpa_s,const u8 * addr)8774 int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
8775 {
8776 wpa_s->global->p2p_long_listen = 0;
8777
8778 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8779 return -1;
8780
8781 return p2p_reject(wpa_s->global->p2p, addr);
8782 }
8783
8784
8785 /* Invite to reinvoke a persistent group */
wpas_p2p_invite(struct wpa_supplicant * wpa_s,const u8 * peer_addr,struct wpa_ssid * ssid,const u8 * go_dev_addr,int freq,int vht_center_freq2,int ht40,int vht,int max_chwidth,int pref_freq,int he,int edmg,bool allow_6ghz,bool p2p2)8786 int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
8787 struct wpa_ssid *ssid, const u8 *go_dev_addr, int freq,
8788 int vht_center_freq2, int ht40, int vht, int max_chwidth,
8789 int pref_freq, int he, int edmg, bool allow_6ghz, bool p2p2)
8790 {
8791 enum p2p_invite_role role;
8792 u8 *bssid = NULL;
8793 int force_freq = 0;
8794 int res;
8795 int no_pref_freq_given = pref_freq == 0;
8796 struct weighted_pcl pref_freq_list[P2P_MAX_PREF_CHANNELS];
8797 unsigned int size;
8798
8799 if (wpas_p2p_check_6ghz(wpa_s, NULL, allow_6ghz, freq))
8800 return -1;
8801
8802 wpa_s->global->p2p_invite_group = NULL;
8803 if (peer_addr)
8804 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
8805 else
8806 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
8807
8808 if (wpa_s->global->p2p && p2p2 && !ssid && peer_addr) {
8809 int dik_id;
8810
8811 dik_id = p2p_get_dik_id(wpa_s->global->p2p, peer_addr);
8812 ssid = wpa_config_get_network_with_dik_id(wpa_s->conf, dik_id);
8813 if (!ssid) {
8814 wpa_printf(MSG_DEBUG,
8815 "P2P: Could not find SSID for P2P2 peer "
8816 MACSTR, MAC2STR(peer_addr));
8817 return -1;
8818 }
8819 }
8820
8821 if (!ssid)
8822 return -1;
8823
8824 wpa_s->p2p_persistent_go_freq = freq;
8825 wpa_s->p2p_go_ht40 = !!ht40;
8826 wpa_s->p2p_go_vht = !!vht;
8827 wpa_s->p2p_go_he = !!he;
8828 wpa_s->p2p_go_max_oper_chwidth = max_chwidth;
8829 wpa_s->p2p_go_vht_center_freq2 = vht_center_freq2;
8830 wpa_s->p2p_go_edmg = !!edmg;
8831 wpa_s->p2p2 = p2p2;
8832 if (ssid->mode == WPAS_MODE_P2P_GO) {
8833 role = P2P_INVITE_ROLE_GO;
8834 if (peer_addr == NULL) {
8835 wpa_printf(MSG_DEBUG, "P2P: Missing peer "
8836 "address in invitation command");
8837 return -1;
8838 }
8839 if (wpas_p2p_create_iface(wpa_s)) {
8840 if (wpas_p2p_add_group_interface(wpa_s,
8841 WPA_IF_P2P_GO) < 0) {
8842 wpa_printf(MSG_ERROR, "P2P: Failed to "
8843 "allocate a new interface for the "
8844 "group");
8845 return -1;
8846 }
8847 bssid = wpa_s->pending_interface_addr;
8848 } else if (wpa_s->p2p_mgmt)
8849 bssid = wpa_s->parent->own_addr;
8850 else
8851 bssid = wpa_s->own_addr;
8852 } else {
8853 role = P2P_INVITE_ROLE_CLIENT;
8854 if (!wpa_s->p2p2)
8855 peer_addr = ssid->bssid;
8856 }
8857 wpa_s->pending_invite_ssid_id = ssid->id;
8858
8859 size = P2P_MAX_PREF_CHANNELS;
8860 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
8861 role == P2P_INVITE_ROLE_GO,
8862 pref_freq_list, &size);
8863 if (res)
8864 return res;
8865
8866 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8867 return -1;
8868
8869 p2p_set_own_pref_freq_list(wpa_s->global->p2p, pref_freq_list, size);
8870
8871 if (wpa_s->parent->conf->p2p_ignore_shared_freq &&
8872 no_pref_freq_given && pref_freq > 0 &&
8873 wpa_s->num_multichan_concurrent > 1 &&
8874 wpas_p2p_num_unused_channels(wpa_s) > 0) {
8875 wpa_printf(MSG_DEBUG, "P2P: Ignore own channel preference %d MHz for invitation due to p2p_ignore_shared_freq=1 configuration",
8876 pref_freq);
8877 pref_freq = 0;
8878 }
8879
8880 /*
8881 * Stop any find/listen operations before invitation and possibly
8882 * connection establishment.
8883 */
8884 wpas_p2p_stop_find_oper(wpa_s);
8885
8886 #ifdef CONFIG_PASN
8887 if (p2p2) {
8888 if (peer_addr &&
8889 wpas_p2p_initiate_pasn_verify(wpa_s, peer_addr, role, bssid,
8890 ssid->ssid, ssid->ssid_len,
8891 force_freq, go_dev_addr,
8892 pref_freq) < 0) {
8893 if (wpa_s->create_p2p_iface)
8894 wpas_p2p_remove_pending_group_interface(wpa_s);
8895 return -1;
8896 }
8897 return 0;
8898 }
8899 #endif /* CONFIG_PASN */
8900
8901 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
8902 ssid->ssid, ssid->ssid_len, force_freq, go_dev_addr,
8903 1, pref_freq, -1, false);
8904 }
8905
8906
8907 /* Invite to join an active group */
wpas_p2p_invite_group(struct wpa_supplicant * wpa_s,const char * ifname,const u8 * peer_addr,const u8 * go_dev_addr,bool allow_6ghz)8908 int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
8909 const u8 *peer_addr, const u8 *go_dev_addr,
8910 bool allow_6ghz)
8911 {
8912 struct wpa_global *global = wpa_s->global;
8913 enum p2p_invite_role role;
8914 u8 *bssid = NULL;
8915 struct wpa_ssid *ssid;
8916 int persistent;
8917 int freq = 0, force_freq = 0, pref_freq = 0;
8918 int res;
8919 struct weighted_pcl pref_freq_list[P2P_MAX_PREF_CHANNELS];
8920 unsigned int size;
8921
8922 wpa_s->p2p_persistent_go_freq = 0;
8923 wpa_s->p2p_go_ht40 = 0;
8924 wpa_s->p2p_go_vht = 0;
8925 wpa_s->p2p_go_vht_center_freq2 = 0;
8926 wpa_s->p2p_go_max_oper_chwidth = 0;
8927 wpa_s->p2p_go_edmg = 0;
8928
8929 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
8930 if (os_strcmp(wpa_s->ifname, ifname) == 0)
8931 break;
8932 }
8933 if (wpa_s == NULL) {
8934 wpa_printf(MSG_DEBUG, "P2P: Interface '%s' not found", ifname);
8935 return -1;
8936 }
8937
8938 ssid = wpa_s->current_ssid;
8939 if (ssid == NULL) {
8940 wpa_printf(MSG_DEBUG, "P2P: No current SSID to use for "
8941 "invitation");
8942 return -1;
8943 }
8944
8945 wpa_s->global->p2p_invite_group = wpa_s;
8946 persistent = ssid->p2p_persistent_group &&
8947 wpas_p2p_get_persistent(wpa_s->p2pdev, peer_addr,
8948 ssid->ssid, ssid->ssid_len);
8949
8950 if (ssid->mode == WPAS_MODE_P2P_GO) {
8951 role = P2P_INVITE_ROLE_ACTIVE_GO;
8952 bssid = wpa_s->own_addr;
8953 if (go_dev_addr == NULL)
8954 go_dev_addr = wpa_s->global->p2p_dev_addr;
8955 freq = ssid->frequency;
8956 } else {
8957 role = P2P_INVITE_ROLE_CLIENT;
8958 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
8959 wpa_printf(MSG_DEBUG, "P2P: Not associated - cannot "
8960 "invite to current group");
8961 return -1;
8962 }
8963 bssid = wpa_s->bssid;
8964 if (go_dev_addr == NULL &&
8965 !is_zero_ether_addr(wpa_s->go_dev_addr))
8966 go_dev_addr = wpa_s->go_dev_addr;
8967 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
8968 (int) wpa_s->assoc_freq;
8969 }
8970 wpa_s->p2pdev->pending_invite_ssid_id = -1;
8971
8972 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
8973 return -1;
8974 if (wpas_p2p_check_6ghz(wpa_s, peer_addr, allow_6ghz, freq))
8975 return -1;
8976
8977 size = P2P_MAX_PREF_CHANNELS;
8978 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
8979 role == P2P_INVITE_ROLE_ACTIVE_GO,
8980 pref_freq_list, &size);
8981 if (res)
8982 return res;
8983 wpas_p2p_set_own_freq_preference(wpa_s, force_freq);
8984
8985 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
8986 ssid->ssid, ssid->ssid_len, force_freq,
8987 go_dev_addr, persistent, pref_freq, -1, false);
8988 }
8989
8990
wpas_p2p_completed(struct wpa_supplicant * wpa_s)8991 void wpas_p2p_completed(struct wpa_supplicant *wpa_s)
8992 {
8993 struct wpa_ssid *ssid = wpa_s->current_ssid;
8994 const u8 *bssid;
8995 u8 go_dev_addr[ETH_ALEN];
8996 int persistent, dik_id;
8997 int freq;
8998 u8 ip[3 * 4], *ip_ptr = NULL;
8999 char ip_addr[100];
9000
9001 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION) {
9002 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
9003 wpa_s->p2pdev, NULL);
9004 }
9005
9006 if (!wpa_s->show_group_started || !ssid)
9007 return;
9008
9009 if (wpa_s->go_params)
9010 bssid = wpa_s->go_params->peer_interface_addr;
9011 else
9012 bssid = wpa_s->bssid;
9013
9014 wpa_s->show_group_started = 0;
9015 if (!wpa_s->p2p_go_group_formation_completed &&
9016 wpa_s->global->p2p_group_formation == wpa_s) {
9017 wpa_dbg(wpa_s, MSG_DEBUG,
9018 "P2P: Marking group formation completed on client on data connection");
9019 wpa_s->p2p_go_group_formation_completed = 1;
9020 wpa_s->global->p2p_group_formation = NULL;
9021 wpa_s->p2p_in_provisioning = 0;
9022 wpa_s->p2p_in_invitation = 0;
9023 wpa_s->p2p_retry_limit = 0;
9024 }
9025
9026 os_memset(go_dev_addr, 0, ETH_ALEN);
9027 if (ssid->bssid_set)
9028 os_memcpy(go_dev_addr, ssid->bssid, ETH_ALEN);
9029 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
9030 ssid->ssid_len);
9031 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
9032
9033 if (wpa_s->global->p2p_group_formation == wpa_s)
9034 wpa_s->global->p2p_group_formation = NULL;
9035
9036 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
9037 (int) wpa_s->assoc_freq;
9038
9039 ip_addr[0] = '\0';
9040 if (wpa_sm_get_p2p_ip_addr(wpa_s->wpa, ip) == 0) {
9041 int res;
9042
9043 res = os_snprintf(ip_addr, sizeof(ip_addr),
9044 " ip_addr=%u.%u.%u.%u "
9045 "ip_mask=%u.%u.%u.%u go_ip_addr=%u.%u.%u.%u",
9046 ip[0], ip[1], ip[2], ip[3],
9047 ip[4], ip[5], ip[6], ip[7],
9048 ip[8], ip[9], ip[10], ip[11]);
9049 if (os_snprintf_error(sizeof(ip_addr), res))
9050 ip_addr[0] = '\0';
9051 ip_ptr = ip;
9052 }
9053
9054 wpas_p2p_group_started(wpa_s, 0, ssid, freq,
9055 ssid->passphrase == NULL && ssid->psk_set ?
9056 ssid->psk : NULL,
9057 ssid->passphrase, go_dev_addr, persistent,
9058 ip_addr);
9059
9060 if (persistent) {
9061 dik_id = wpas_p2p_store_go_identity(wpa_s, go_dev_addr, bssid);
9062 wpas_p2p_store_persistent_group(wpa_s->p2pdev,
9063 ssid, go_dev_addr, dik_id);
9064 }
9065
9066 wpas_notify_p2p_group_started(wpa_s, ssid, persistent, 1, ip_ptr);
9067 }
9068
9069
wpas_p2p_presence_req(struct wpa_supplicant * wpa_s,u32 duration1,u32 interval1,u32 duration2,u32 interval2)9070 int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
9071 u32 interval1, u32 duration2, u32 interval2)
9072 {
9073 int ret;
9074
9075 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9076 return -1;
9077
9078 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
9079 wpa_s->current_ssid == NULL ||
9080 wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
9081 return -1;
9082
9083 ret = p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
9084 wpa_s->own_addr, wpa_s->assoc_freq,
9085 duration1, interval1, duration2, interval2);
9086 if (ret == 0)
9087 wpa_s->waiting_presence_resp = 1;
9088
9089 return ret;
9090 }
9091
9092
wpas_p2p_ext_listen(struct wpa_supplicant * wpa_s,unsigned int period,unsigned int interval)9093 int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
9094 unsigned int interval)
9095 {
9096 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9097 return -1;
9098
9099 return p2p_ext_listen(wpa_s->global->p2p, period, interval);
9100 }
9101
9102
wpas_p2p_is_client(struct wpa_supplicant * wpa_s)9103 static int wpas_p2p_is_client(struct wpa_supplicant *wpa_s)
9104 {
9105 if (wpa_s->current_ssid == NULL) {
9106 /*
9107 * current_ssid can be cleared when P2P client interface gets
9108 * disconnected, so assume this interface was used as P2P
9109 * client.
9110 */
9111 return 1;
9112 }
9113 return wpa_s->current_ssid->p2p_group &&
9114 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
9115 }
9116
9117
wpas_p2p_group_idle_timeout(void * eloop_ctx,void * timeout_ctx)9118 static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx)
9119 {
9120 struct wpa_supplicant *wpa_s = eloop_ctx;
9121
9122 if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) {
9123 wpa_printf(MSG_DEBUG, "P2P: Ignore group idle timeout - "
9124 "disabled");
9125 return;
9126 }
9127
9128 wpa_printf(MSG_DEBUG, "P2P: Group idle timeout reached - terminate "
9129 "group");
9130 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_IDLE_TIMEOUT);
9131 }
9132
9133
wpas_p2p_set_group_idle_timeout(struct wpa_supplicant * wpa_s)9134 static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s)
9135 {
9136 int timeout;
9137
9138 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
9139 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
9140
9141 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
9142 return;
9143
9144 timeout = wpa_s->conf->p2p_group_idle;
9145 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
9146 (timeout == 0 || timeout > P2P_MAX_CLIENT_IDLE))
9147 timeout = P2P_MAX_CLIENT_IDLE;
9148
9149 if (timeout == 0)
9150 return;
9151
9152 if (timeout < 0) {
9153 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA)
9154 timeout = 0; /* special client mode no-timeout */
9155 else
9156 return;
9157 }
9158
9159 if (wpa_s->p2p_in_provisioning) {
9160 /*
9161 * Use the normal group formation timeout during the
9162 * provisioning phase to avoid terminating this process too
9163 * early due to group idle timeout.
9164 */
9165 wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout "
9166 "during provisioning");
9167 return;
9168 }
9169
9170 if (wpa_s->show_group_started) {
9171 /*
9172 * Use the normal group formation timeout between the end of
9173 * the provisioning phase and completion of 4-way handshake to
9174 * avoid terminating this process too early due to group idle
9175 * timeout.
9176 */
9177 wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout "
9178 "while waiting for initial 4-way handshake to "
9179 "complete");
9180 return;
9181 }
9182
9183 wpa_printf(MSG_DEBUG, "P2P: Set P2P group idle timeout to %u seconds",
9184 timeout);
9185 eloop_register_timeout(timeout, 0, wpas_p2p_group_idle_timeout,
9186 wpa_s, NULL);
9187 }
9188
9189
9190 /* Returns 1 if the interface was removed */
wpas_p2p_deauth_notif(struct wpa_supplicant * wpa_s,const u8 * bssid,u16 reason_code,const u8 * ie,size_t ie_len,int locally_generated)9191 int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
9192 u16 reason_code, const u8 *ie, size_t ie_len,
9193 int locally_generated)
9194 {
9195 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9196 return 0;
9197
9198 if (!locally_generated)
9199 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
9200 ie_len);
9201
9202 if (reason_code == WLAN_REASON_DEAUTH_LEAVING && !locally_generated &&
9203 wpa_s->current_ssid &&
9204 wpa_s->current_ssid->p2p_group &&
9205 wpa_s->current_ssid->mode == WPAS_MODE_INFRA) {
9206 wpa_printf(MSG_DEBUG, "P2P: GO indicated that the P2P Group "
9207 "session is ending");
9208 if (wpas_p2p_group_delete(wpa_s,
9209 P2P_GROUP_REMOVAL_GO_ENDING_SESSION)
9210 > 0)
9211 return 1;
9212 }
9213
9214 return 0;
9215 }
9216
9217
wpas_p2p_disassoc_notif(struct wpa_supplicant * wpa_s,const u8 * bssid,u16 reason_code,const u8 * ie,size_t ie_len,int locally_generated)9218 void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
9219 u16 reason_code, const u8 *ie, size_t ie_len,
9220 int locally_generated)
9221 {
9222 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9223 return;
9224
9225 if (!locally_generated)
9226 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
9227 ie_len);
9228 }
9229
9230
wpas_p2p_update_config(struct wpa_supplicant * wpa_s)9231 void wpas_p2p_update_config(struct wpa_supplicant *wpa_s)
9232 {
9233 struct p2p_data *p2p = wpa_s->global->p2p;
9234
9235 if (p2p == NULL)
9236 return;
9237
9238 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
9239 return;
9240
9241 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
9242 p2p_set_dev_name(p2p, wpa_s->conf->device_name);
9243
9244 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
9245 p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type);
9246
9247 if (wpa_s->wps &&
9248 (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS))
9249 p2p_set_config_methods(p2p, wpa_s->wps->config_methods);
9250
9251 if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID))
9252 p2p_set_uuid(p2p, wpa_s->wps->uuid);
9253
9254 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) {
9255 p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer);
9256 p2p_set_model_name(p2p, wpa_s->conf->model_name);
9257 p2p_set_model_number(p2p, wpa_s->conf->model_number);
9258 p2p_set_serial_number(p2p, wpa_s->conf->serial_number);
9259 }
9260
9261 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE)
9262 p2p_set_sec_dev_types(p2p,
9263 (void *) wpa_s->conf->sec_device_type,
9264 wpa_s->conf->num_sec_device_types);
9265
9266 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) {
9267 int i;
9268 p2p_remove_wps_vendor_extensions(p2p);
9269 for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) {
9270 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
9271 continue;
9272 p2p_add_wps_vendor_extension(
9273 p2p, wpa_s->conf->wps_vendor_ext[i]);
9274 }
9275 }
9276
9277 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
9278 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
9279 char country[3];
9280 country[0] = wpa_s->conf->country[0];
9281 country[1] = wpa_s->conf->country[1];
9282 country[2] = 0x04;
9283 p2p_set_country(p2p, country);
9284 }
9285
9286 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
9287 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
9288 wpa_s->conf->p2p_ssid_postfix ?
9289 os_strlen(wpa_s->conf->p2p_ssid_postfix) :
9290 0);
9291 }
9292
9293 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS)
9294 p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss);
9295
9296 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) {
9297 u8 reg_class, channel;
9298 int ret;
9299 unsigned int r;
9300 u8 channel_forced;
9301
9302 if (wpa_s->conf->p2p_listen_reg_class &&
9303 wpa_s->conf->p2p_listen_channel) {
9304 reg_class = wpa_s->conf->p2p_listen_reg_class;
9305 channel = wpa_s->conf->p2p_listen_channel;
9306 channel_forced = 1;
9307 } else {
9308 reg_class = 81;
9309 /*
9310 * Pick one of the social channels randomly as the
9311 * listen channel.
9312 */
9313 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
9314 channel = 1;
9315 else
9316 channel = 1 + (r % 3) * 5;
9317 channel_forced = 0;
9318 }
9319 ret = p2p_set_listen_channel(p2p, reg_class, channel,
9320 channel_forced);
9321 if (ret)
9322 wpa_printf(MSG_ERROR, "P2P: Own listen channel update "
9323 "failed: %d", ret);
9324 }
9325 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) {
9326 u8 op_reg_class, op_channel, cfg_op_channel;
9327 int ret = 0;
9328 unsigned int r;
9329 if (wpa_s->conf->p2p_oper_reg_class &&
9330 wpa_s->conf->p2p_oper_channel) {
9331 op_reg_class = wpa_s->conf->p2p_oper_reg_class;
9332 op_channel = wpa_s->conf->p2p_oper_channel;
9333 cfg_op_channel = 1;
9334 } else {
9335 op_reg_class = 81;
9336 /*
9337 * Use random operation channel from (1, 6, 11)
9338 *if no other preference is indicated.
9339 */
9340 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
9341 op_channel = 1;
9342 else
9343 op_channel = 1 + (r % 3) * 5;
9344 cfg_op_channel = 0;
9345 }
9346 ret = p2p_set_oper_channel(p2p, op_reg_class, op_channel,
9347 cfg_op_channel);
9348 if (ret)
9349 wpa_printf(MSG_ERROR, "P2P: Own oper channel update "
9350 "failed: %d", ret);
9351 }
9352
9353 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
9354 if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
9355 wpa_s->conf->p2p_pref_chan) < 0) {
9356 wpa_printf(MSG_ERROR, "P2P: Preferred channel list "
9357 "update failed");
9358 }
9359
9360 if (p2p_set_no_go_freq(p2p, &wpa_s->conf->p2p_no_go_freq) < 0) {
9361 wpa_printf(MSG_ERROR, "P2P: No GO channel list "
9362 "update failed");
9363 }
9364 }
9365
9366 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PASSPHRASE_LEN)
9367 p2p_set_passphrase_len(p2p, wpa_s->conf->p2p_passphrase_len);
9368 }
9369
9370
wpas_p2p_set_noa(struct wpa_supplicant * wpa_s,u8 count,int start,int duration)9371 int wpas_p2p_set_noa(struct wpa_supplicant *wpa_s, u8 count, int start,
9372 int duration)
9373 {
9374 if (!wpa_s->ap_iface)
9375 return -1;
9376 return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start,
9377 duration);
9378 }
9379
9380
wpas_p2p_set_cross_connect(struct wpa_supplicant * wpa_s,int enabled)9381 int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled)
9382 {
9383 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9384 return -1;
9385
9386 wpa_s->global->cross_connection = enabled;
9387 p2p_set_cross_connect(wpa_s->global->p2p, enabled);
9388
9389 if (!enabled) {
9390 struct wpa_supplicant *iface;
9391
9392 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
9393 {
9394 if (iface->cross_connect_enabled == 0)
9395 continue;
9396
9397 iface->cross_connect_enabled = 0;
9398 iface->cross_connect_in_use = 0;
9399 wpa_msg_global(iface->p2pdev, MSG_INFO,
9400 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
9401 iface->ifname,
9402 iface->cross_connect_uplink);
9403 }
9404 }
9405
9406 return 0;
9407 }
9408
9409
wpas_p2p_enable_cross_connect(struct wpa_supplicant * uplink)9410 static void wpas_p2p_enable_cross_connect(struct wpa_supplicant *uplink)
9411 {
9412 struct wpa_supplicant *iface;
9413
9414 if (!uplink->global->cross_connection)
9415 return;
9416
9417 for (iface = uplink->global->ifaces; iface; iface = iface->next) {
9418 if (!iface->cross_connect_enabled)
9419 continue;
9420 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
9421 0)
9422 continue;
9423 if (iface->ap_iface == NULL)
9424 continue;
9425 if (iface->cross_connect_in_use)
9426 continue;
9427
9428 iface->cross_connect_in_use = 1;
9429 wpa_msg_global(iface->p2pdev, MSG_INFO,
9430 P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s",
9431 iface->ifname, iface->cross_connect_uplink);
9432 }
9433 }
9434
9435
wpas_p2p_disable_cross_connect(struct wpa_supplicant * uplink)9436 static void wpas_p2p_disable_cross_connect(struct wpa_supplicant *uplink)
9437 {
9438 struct wpa_supplicant *iface;
9439
9440 for (iface = uplink->global->ifaces; iface; iface = iface->next) {
9441 if (!iface->cross_connect_enabled)
9442 continue;
9443 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
9444 0)
9445 continue;
9446 if (!iface->cross_connect_in_use)
9447 continue;
9448
9449 wpa_msg_global(iface->p2pdev, MSG_INFO,
9450 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
9451 iface->ifname, iface->cross_connect_uplink);
9452 iface->cross_connect_in_use = 0;
9453 }
9454 }
9455
9456
wpas_p2p_notif_connected(struct wpa_supplicant * wpa_s)9457 void wpas_p2p_notif_connected(struct wpa_supplicant *wpa_s)
9458 {
9459 if (wpa_s->ap_iface || wpa_s->current_ssid == NULL ||
9460 wpa_s->current_ssid->mode != WPAS_MODE_INFRA ||
9461 wpa_s->cross_connect_disallowed)
9462 wpas_p2p_disable_cross_connect(wpa_s);
9463 else
9464 wpas_p2p_enable_cross_connect(wpa_s);
9465 if (!wpa_s->ap_iface &&
9466 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
9467 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
9468 }
9469
9470
wpas_p2p_notif_disconnected(struct wpa_supplicant * wpa_s)9471 void wpas_p2p_notif_disconnected(struct wpa_supplicant *wpa_s)
9472 {
9473 wpas_p2p_disable_cross_connect(wpa_s);
9474 if (!wpa_s->ap_iface &&
9475 !eloop_is_timeout_registered(wpas_p2p_group_idle_timeout,
9476 wpa_s, NULL))
9477 wpas_p2p_set_group_idle_timeout(wpa_s);
9478 }
9479
9480
wpas_p2p_cross_connect_setup(struct wpa_supplicant * wpa_s)9481 static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s)
9482 {
9483 struct wpa_supplicant *iface;
9484
9485 if (!wpa_s->global->cross_connection)
9486 return;
9487
9488 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
9489 if (iface == wpa_s)
9490 continue;
9491 if (iface->drv_flags &
9492 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)
9493 continue;
9494 if ((iface->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE) &&
9495 iface != wpa_s->parent)
9496 continue;
9497
9498 wpa_s->cross_connect_enabled = 1;
9499 os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname,
9500 sizeof(wpa_s->cross_connect_uplink));
9501 wpa_printf(MSG_DEBUG, "P2P: Enable cross connection from "
9502 "%s to %s whenever uplink is available",
9503 wpa_s->ifname, wpa_s->cross_connect_uplink);
9504
9505 if (iface->ap_iface || iface->current_ssid == NULL ||
9506 iface->current_ssid->mode != WPAS_MODE_INFRA ||
9507 iface->cross_connect_disallowed ||
9508 iface->wpa_state != WPA_COMPLETED)
9509 break;
9510
9511 wpa_s->cross_connect_in_use = 1;
9512 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
9513 P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s",
9514 wpa_s->ifname, wpa_s->cross_connect_uplink);
9515 break;
9516 }
9517 }
9518
9519
wpas_p2p_notif_pbc_overlap(struct wpa_supplicant * wpa_s)9520 static int wpas_p2p_notif_pbc_overlap(struct wpa_supplicant *wpa_s)
9521 {
9522 if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT &&
9523 !wpa_s->p2p_in_provisioning)
9524 return 0; /* not P2P client operation */
9525
9526 wpa_printf(MSG_DEBUG, "P2P: Terminate connection due to WPS PBC "
9527 "session overlap");
9528 if (wpa_s != wpa_s->p2pdev)
9529 wpa_msg_ctrl(wpa_s->p2pdev, MSG_INFO, WPS_EVENT_OVERLAP);
9530 wpas_p2p_group_formation_failed(wpa_s, 0, "WPS PBC session overlap");
9531 return 1;
9532 }
9533
9534
wpas_p2p_pbc_overlap_cb(void * eloop_ctx,void * timeout_ctx)9535 void wpas_p2p_pbc_overlap_cb(void *eloop_ctx, void *timeout_ctx)
9536 {
9537 struct wpa_supplicant *wpa_s = eloop_ctx;
9538 wpas_p2p_notif_pbc_overlap(wpa_s);
9539 }
9540
9541
wpas_p2p_update_channel_list(struct wpa_supplicant * wpa_s,enum wpas_p2p_channel_update_trig trig)9542 void wpas_p2p_update_channel_list(struct wpa_supplicant *wpa_s,
9543 enum wpas_p2p_channel_update_trig trig)
9544 {
9545 struct p2p_channels chan, cli_chan;
9546 struct wpa_used_freq_data *freqs = NULL;
9547 unsigned int num = wpa_s->num_multichan_concurrent;
9548
9549 if (wpa_s->global == NULL || wpa_s->global->p2p == NULL)
9550 return;
9551
9552 freqs = os_calloc(num, sizeof(struct wpa_used_freq_data));
9553 if (!freqs)
9554 return;
9555
9556 num = get_shared_radio_freqs_data(wpa_s, freqs, num, false);
9557
9558 os_memset(&chan, 0, sizeof(chan));
9559 os_memset(&cli_chan, 0, sizeof(cli_chan));
9560 if (wpas_p2p_setup_channels(wpa_s, &chan, &cli_chan,
9561 is_p2p_6ghz_disabled(wpa_s->global->p2p))) {
9562 wpa_printf(MSG_ERROR, "P2P: Failed to update supported "
9563 "channel list");
9564 return;
9565 }
9566
9567 p2p_update_channel_list(wpa_s->global->p2p, &chan, &cli_chan);
9568
9569 wpas_p2p_optimize_listen_channel(wpa_s, freqs, num);
9570
9571 /*
9572 * The used frequencies map changed, so it is possible that a GO is
9573 * using a channel that is no longer valid for P2P use. It is also
9574 * possible that due to policy consideration, it would be preferable to
9575 * move it to a frequency already used by other station interfaces.
9576 */
9577 wpas_p2p_consider_moving_gos(wpa_s, freqs, num, trig);
9578
9579 os_free(freqs);
9580 }
9581
9582
wpas_p2p_scan_res_ignore(struct wpa_supplicant * wpa_s,struct wpa_scan_results * scan_res)9583 static void wpas_p2p_scan_res_ignore(struct wpa_supplicant *wpa_s,
9584 struct wpa_scan_results *scan_res)
9585 {
9586 wpa_printf(MSG_DEBUG, "P2P: Ignore scan results");
9587 }
9588
9589
wpas_p2p_cancel(struct wpa_supplicant * wpa_s)9590 int wpas_p2p_cancel(struct wpa_supplicant *wpa_s)
9591 {
9592 struct wpa_global *global = wpa_s->global;
9593 int found = 0;
9594 const u8 *peer;
9595
9596 if (global->p2p == NULL)
9597 return -1;
9598
9599 wpa_printf(MSG_DEBUG, "P2P: Request to cancel group formation");
9600
9601 if (wpa_s->pending_interface_name[0] &&
9602 !is_zero_ether_addr(wpa_s->pending_interface_addr))
9603 found = 1;
9604
9605 peer = p2p_get_go_neg_peer(global->p2p);
9606 if (peer) {
9607 wpa_printf(MSG_DEBUG, "P2P: Unauthorize pending GO Neg peer "
9608 MACSTR, MAC2STR(peer));
9609 p2p_unauthorize(global->p2p, peer);
9610 found = 1;
9611 }
9612
9613 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_join) {
9614 wpa_printf(MSG_DEBUG, "P2P: Stop pending scan for join");
9615 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore;
9616 found = 1;
9617 }
9618
9619 if (wpa_s->pending_pd_before_join) {
9620 wpa_printf(MSG_DEBUG, "P2P: Stop pending PD before join");
9621 wpa_s->pending_pd_before_join = 0;
9622 found = 1;
9623 }
9624
9625 wpas_p2p_stop_find(wpa_s);
9626
9627 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
9628 if (wpa_s == global->p2p_group_formation &&
9629 (wpa_s->p2p_in_provisioning ||
9630 wpa_s->parent->pending_interface_type ==
9631 WPA_IF_P2P_CLIENT)) {
9632 wpa_printf(MSG_DEBUG, "P2P: Interface %s in group "
9633 "formation found - cancelling",
9634 wpa_s->ifname);
9635 found = 1;
9636 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
9637 wpa_s->p2pdev, NULL);
9638 if (wpa_s->p2p_in_provisioning) {
9639 wpas_group_formation_completed(wpa_s, 0,
9640 "Canceled");
9641 break;
9642 }
9643 wpas_p2p_group_delete(wpa_s,
9644 P2P_GROUP_REMOVAL_REQUESTED);
9645 break;
9646 } else if (wpa_s->p2p_in_invitation) {
9647 wpa_printf(MSG_DEBUG, "P2P: Interface %s in invitation found - cancelling",
9648 wpa_s->ifname);
9649 found = 1;
9650 wpas_p2p_group_formation_failed(wpa_s, 0, "Canceled");
9651 break;
9652 }
9653 }
9654
9655 if (!found) {
9656 wpa_printf(MSG_DEBUG, "P2P: No ongoing group formation found");
9657 return -1;
9658 }
9659
9660 return 0;
9661 }
9662
9663
wpas_p2p_interface_unavailable(struct wpa_supplicant * wpa_s)9664 void wpas_p2p_interface_unavailable(struct wpa_supplicant *wpa_s)
9665 {
9666 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
9667 return;
9668
9669 wpa_printf(MSG_DEBUG, "P2P: Remove group due to driver resource not "
9670 "being available anymore");
9671 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_UNAVAILABLE);
9672 }
9673
9674
wpas_p2p_update_best_channels(struct wpa_supplicant * wpa_s,int freq_24,int freq_5,int freq_overall)9675 void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s,
9676 int freq_24, int freq_5, int freq_overall)
9677 {
9678 struct p2p_data *p2p = wpa_s->global->p2p;
9679 if (p2p == NULL)
9680 return;
9681 p2p_set_best_channels(p2p, freq_24, freq_5, freq_overall);
9682 }
9683
9684
wpas_p2p_unauthorize(struct wpa_supplicant * wpa_s,const char * addr)9685 int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr)
9686 {
9687 u8 peer[ETH_ALEN];
9688 struct p2p_data *p2p = wpa_s->global->p2p;
9689
9690 if (p2p == NULL)
9691 return -1;
9692
9693 if (hwaddr_aton(addr, peer))
9694 return -1;
9695
9696 return p2p_unauthorize(p2p, peer);
9697 }
9698
9699
9700 /**
9701 * wpas_p2p_disconnect - Disconnect from a P2P Group
9702 * @wpa_s: Pointer to wpa_supplicant data
9703 * Returns: 0 on success, -1 on failure
9704 *
9705 * This can be used to disconnect from a group in which the local end is a P2P
9706 * Client or to end a P2P Group in case the local end is the Group Owner. If a
9707 * virtual network interface was created for this group, that interface will be
9708 * removed. Otherwise, only the configured P2P group network will be removed
9709 * from the interface.
9710 */
wpas_p2p_disconnect(struct wpa_supplicant * wpa_s)9711 int wpas_p2p_disconnect(struct wpa_supplicant *wpa_s)
9712 {
9713
9714 if (wpa_s == NULL)
9715 return -1;
9716
9717 return wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_REQUESTED) < 0 ?
9718 -1 : 0;
9719 }
9720
9721
wpas_p2p_in_progress(struct wpa_supplicant * wpa_s)9722 int wpas_p2p_in_progress(struct wpa_supplicant *wpa_s)
9723 {
9724 int ret;
9725
9726 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
9727 return 0;
9728
9729 ret = p2p_in_progress(wpa_s->global->p2p);
9730 if (ret == 0) {
9731 /*
9732 * Check whether there is an ongoing WPS provisioning step (or
9733 * other parts of group formation) on another interface since
9734 * p2p_in_progress() does not report this to avoid issues for
9735 * scans during such provisioning step.
9736 */
9737 if (wpa_s->global->p2p_group_formation &&
9738 wpa_s->global->p2p_group_formation != wpa_s) {
9739 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Another interface (%s) "
9740 "in group formation",
9741 wpa_s->global->p2p_group_formation->ifname);
9742 ret = 1;
9743 } else if (wpa_s->global->p2p_group_formation == wpa_s) {
9744 wpa_dbg(wpa_s, MSG_DEBUG,
9745 "P2P: Skip Extended Listen timeout and allow scans on current interface for group formation");
9746 ret = 2;
9747 }
9748 }
9749
9750 if (!ret && wpa_s->global->p2p_go_wait_client.sec) {
9751 struct os_reltime now;
9752 os_get_reltime(&now);
9753 if (os_reltime_expired(&now, &wpa_s->global->p2p_go_wait_client,
9754 P2P_MAX_INITIAL_CONN_WAIT_GO)) {
9755 /* Wait for the first client has expired */
9756 wpa_s->global->p2p_go_wait_client.sec = 0;
9757 } else {
9758 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Waiting for initial client connection during group formation");
9759 ret = 1;
9760 }
9761 }
9762
9763 return ret;
9764 }
9765
9766
wpas_p2p_network_removed(struct wpa_supplicant * wpa_s,struct wpa_ssid * ssid)9767 void wpas_p2p_network_removed(struct wpa_supplicant *wpa_s,
9768 struct wpa_ssid *ssid)
9769 {
9770 if (wpa_s->p2p_in_provisioning && ssid->p2p_group &&
9771 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
9772 wpa_s->p2pdev, NULL) > 0) {
9773 /**
9774 * Remove the network by scheduling the group formation
9775 * timeout to happen immediately. The teardown code
9776 * needs to be scheduled to run asynch later so that we
9777 * don't delete data from under ourselves unexpectedly.
9778 * Calling wpas_p2p_group_formation_timeout directly
9779 * causes a series of crashes in WPS failure scenarios.
9780 */
9781 wpa_printf(MSG_DEBUG, "P2P: Canceled group formation due to "
9782 "P2P group network getting removed");
9783 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
9784 wpa_s->p2pdev, NULL);
9785 }
9786 }
9787
9788
wpas_p2p_get_persistent(struct wpa_supplicant * wpa_s,const u8 * addr,const u8 * ssid,size_t ssid_len)9789 struct wpa_ssid * wpas_p2p_get_persistent(struct wpa_supplicant *wpa_s,
9790 const u8 *addr, const u8 *ssid,
9791 size_t ssid_len)
9792 {
9793 struct wpa_ssid *s;
9794 size_t i;
9795
9796 for (s = wpa_s->conf->ssid; s; s = s->next) {
9797 if (s->disabled != 2)
9798 continue;
9799 if (ssid &&
9800 (ssid_len != s->ssid_len ||
9801 os_memcmp(ssid, s->ssid, ssid_len) != 0))
9802 continue;
9803 if (addr == NULL) {
9804 if (s->mode == WPAS_MODE_P2P_GO)
9805 return s;
9806 continue;
9807 }
9808 if (ether_addr_equal(s->bssid, addr))
9809 return s; /* peer is GO in the persistent group */
9810 if (s->mode != WPAS_MODE_P2P_GO || s->p2p_client_list == NULL)
9811 continue;
9812 for (i = 0; i < s->num_p2p_clients; i++) {
9813 if (ether_addr_equal(s->p2p_client_list +
9814 i * 2 * ETH_ALEN, addr))
9815 return s; /* peer is P2P client in persistent
9816 * group */
9817 }
9818 }
9819
9820 return NULL;
9821 }
9822
9823
wpas_p2p_store_client_identity(struct wpa_supplicant * wpa_s,const u8 * addr)9824 static int wpas_p2p_store_client_identity(struct wpa_supplicant *wpa_s,
9825 const u8 *addr)
9826 {
9827 u8 cipher;
9828 size_t dik_len;
9829 const u8 *dik_data;
9830 const u8 *pmk, *pmkid;
9831 size_t pmk_len;
9832 u8 iface_addr[ETH_ALEN];
9833 struct hostapd_data *hapd;
9834 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
9835
9836 if (!wpa_s->p2p2 || !wpa_s->ap_iface)
9837 return 0;
9838
9839 hapd = wpa_s->ap_iface->bss[0];
9840 if (!hapd)
9841 return 0;
9842
9843 if (p2p_get_dev_identity_key(p2p_wpa_s->global->p2p, addr,
9844 &dik_data, &dik_len, &cipher))
9845 return 0;
9846
9847 wpa_printf(MSG_DEBUG, "P2P: Fetch PMK from client (Device Addr " MACSTR
9848 ")", MAC2STR(addr));
9849 if (wpa_auth_pmksa_get_pmk(hapd->wpa_auth, addr, &pmk, &pmk_len,
9850 &pmkid)) {
9851 if (p2p_get_interface_addr(p2p_wpa_s->global->p2p, addr,
9852 iface_addr))
9853 return 0;
9854 wpa_printf(MSG_DEBUG,
9855 "P2P: Fetch PMK from client (Interface Addr " MACSTR
9856 ")", MAC2STR(iface_addr));
9857 if (wpa_auth_pmksa_get_pmk(hapd->wpa_auth, iface_addr, &pmk,
9858 &pmk_len, &pmkid))
9859 return 0;
9860 }
9861
9862 wpa_printf(MSG_DEBUG,
9863 "P2P: Storing device identity of client (Device Addr "
9864 MACSTR ")", MAC2STR(addr));
9865 return wpas_p2p_store_identity(p2p_wpa_s, cipher, dik_data, dik_len,
9866 pmk, pmk_len, pmkid);
9867 }
9868
9869
wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant * wpa_s,const u8 * addr)9870 void wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
9871 const u8 *addr)
9872 {
9873 int dik_id;
9874
9875 if (eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
9876 wpa_s->p2pdev, NULL) > 0) {
9877 /*
9878 * This can happen if WPS provisioning step is not terminated
9879 * cleanly (e.g., P2P Client does not send WSC_Done). Since the
9880 * peer was able to connect, there is no need to time out group
9881 * formation after this, though. In addition, this is used with
9882 * the initial connection wait on the GO as a separate formation
9883 * timeout and as such, expected to be hit after the initial WPS
9884 * provisioning step.
9885 */
9886 wpa_printf(MSG_DEBUG, "P2P: Canceled P2P group formation timeout on data connection");
9887
9888 if (!wpa_s->p2p_go_group_formation_completed &&
9889 !wpa_s->group_formation_reported) {
9890 /*
9891 * GO has not yet notified group formation success since
9892 * the WPS step was not completed cleanly. Do that
9893 * notification now since the P2P Client was able to
9894 * connect and as such, must have received the
9895 * credential from the WPS step.
9896 */
9897 if (wpa_s->global->p2p)
9898 p2p_wps_success_cb(wpa_s->global->p2p, addr);
9899 wpas_group_formation_completed(wpa_s, 0, NULL);
9900 }
9901 }
9902 if (!wpa_s->p2p_go_group_formation_completed) {
9903 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Marking group formation completed on GO on first data connection");
9904 wpa_s->p2p_go_group_formation_completed = 1;
9905 wpa_s->global->p2p_group_formation = NULL;
9906 wpa_s->p2p_in_provisioning = 0;
9907 wpa_s->p2p_in_invitation = 0;
9908 wpa_s->p2p_retry_limit = 0;
9909 }
9910 wpa_s->global->p2p_go_wait_client.sec = 0;
9911 if (addr == NULL)
9912 return;
9913
9914 dik_id = wpas_p2p_store_client_identity(wpa_s, addr);
9915 wpas_p2p_add_persistent_group_client(wpa_s, addr, dik_id);
9916 }
9917
9918
wpas_p2p_fallback_to_go_neg(struct wpa_supplicant * wpa_s,int group_added)9919 static int wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
9920 int group_added)
9921 {
9922 struct wpa_supplicant *group = wpa_s;
9923 int ret = 0;
9924
9925 if (wpa_s->global->p2p_group_formation)
9926 group = wpa_s->global->p2p_group_formation;
9927 wpa_s = wpa_s->global->p2p_init_wpa_s;
9928 offchannel_send_action_done(wpa_s);
9929 if (group_added)
9930 ret = wpas_p2p_group_delete(group, P2P_GROUP_REMOVAL_SILENT);
9931 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Fall back to GO Negotiation");
9932 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin,
9933 wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0,
9934 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
9935 wpa_s->p2p_go_vht_center_freq2,
9936 wpa_s->p2p_persistent_id,
9937 wpa_s->p2p_pd_before_go_neg,
9938 wpa_s->p2p_go_ht40,
9939 wpa_s->p2p_go_vht,
9940 wpa_s->p2p_go_max_oper_chwidth,
9941 wpa_s->p2p_go_he,
9942 wpa_s->p2p_go_edmg,
9943 NULL, 0, is_p2p_allow_6ghz(wpa_s->global->p2p),
9944 wpa_s->p2p2, wpa_s->p2p_bootstrap, NULL, false);
9945 return ret;
9946 }
9947
9948
wpas_p2p_scan_no_go_seen(struct wpa_supplicant * wpa_s)9949 int wpas_p2p_scan_no_go_seen(struct wpa_supplicant *wpa_s)
9950 {
9951 int res;
9952
9953 if (!wpa_s->p2p_fallback_to_go_neg ||
9954 wpa_s->p2p_in_provisioning <= 5)
9955 return 0;
9956
9957 if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0)
9958 return 0; /* peer operating as a GO */
9959
9960 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - "
9961 "fallback to GO Negotiation");
9962 wpa_msg_global(wpa_s->p2pdev, MSG_INFO, P2P_EVENT_FALLBACK_TO_GO_NEG
9963 "reason=GO-not-found");
9964 res = wpas_p2p_fallback_to_go_neg(wpa_s, 1);
9965
9966 return res == 1 ? 2 : 1;
9967 }
9968
9969
wpas_p2p_search_delay(struct wpa_supplicant * wpa_s)9970 unsigned int wpas_p2p_search_delay(struct wpa_supplicant *wpa_s)
9971 {
9972 struct wpa_supplicant *ifs;
9973
9974 if (wpa_s->wpa_state > WPA_SCANNING) {
9975 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search delay due to "
9976 "concurrent operation",
9977 wpa_s->conf->p2p_search_delay);
9978 return wpa_s->conf->p2p_search_delay;
9979 }
9980
9981 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
9982 radio_list) {
9983 if (ifs != wpa_s && ifs->wpa_state > WPA_SCANNING) {
9984 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search "
9985 "delay due to concurrent operation on "
9986 "interface %s",
9987 wpa_s->conf->p2p_search_delay,
9988 ifs->ifname);
9989 return wpa_s->conf->p2p_search_delay;
9990 }
9991 }
9992
9993 return 0;
9994 }
9995
9996
wpas_p2p_remove_psk_entry(struct wpa_supplicant * wpa_s,struct wpa_ssid * s,const u8 * addr,int iface_addr)9997 static int wpas_p2p_remove_psk_entry(struct wpa_supplicant *wpa_s,
9998 struct wpa_ssid *s, const u8 *addr,
9999 int iface_addr)
10000 {
10001 struct psk_list_entry *psk, *tmp;
10002 int changed = 0;
10003
10004 dl_list_for_each_safe(psk, tmp, &s->psk_list, struct psk_list_entry,
10005 list) {
10006 if ((iface_addr && !psk->p2p &&
10007 ether_addr_equal(addr, psk->addr)) ||
10008 (!iface_addr && psk->p2p &&
10009 ether_addr_equal(addr, psk->addr))) {
10010 wpa_dbg(wpa_s, MSG_DEBUG,
10011 "P2P: Remove persistent group PSK list entry for "
10012 MACSTR " p2p=%u",
10013 MAC2STR(psk->addr), psk->p2p);
10014 dl_list_del(&psk->list);
10015 os_free(psk);
10016 changed++;
10017 }
10018 }
10019
10020 return changed;
10021 }
10022
10023
wpas_p2p_new_psk_cb(struct wpa_supplicant * wpa_s,const u8 * mac_addr,const u8 * p2p_dev_addr,const u8 * psk,size_t psk_len)10024 void wpas_p2p_new_psk_cb(struct wpa_supplicant *wpa_s, const u8 *mac_addr,
10025 const u8 *p2p_dev_addr,
10026 const u8 *psk, size_t psk_len)
10027 {
10028 struct wpa_ssid *ssid = wpa_s->current_ssid;
10029 struct wpa_ssid *persistent;
10030 struct psk_list_entry *p, *last;
10031
10032 if (psk_len != sizeof(p->psk))
10033 return;
10034
10035 if (p2p_dev_addr) {
10036 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR
10037 " p2p_dev_addr=" MACSTR,
10038 MAC2STR(mac_addr), MAC2STR(p2p_dev_addr));
10039 if (is_zero_ether_addr(p2p_dev_addr))
10040 p2p_dev_addr = NULL;
10041 } else {
10042 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR,
10043 MAC2STR(mac_addr));
10044 }
10045
10046 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
10047 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: new_psk_cb during group formation");
10048 /* To be added to persistent group once created */
10049 if (wpa_s->global->add_psk == NULL) {
10050 wpa_s->global->add_psk = os_zalloc(sizeof(*p));
10051 if (wpa_s->global->add_psk == NULL)
10052 return;
10053 }
10054 p = wpa_s->global->add_psk;
10055 if (p2p_dev_addr) {
10056 p->p2p = 1;
10057 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN);
10058 } else {
10059 p->p2p = 0;
10060 os_memcpy(p->addr, mac_addr, ETH_ALEN);
10061 }
10062 os_memcpy(p->psk, psk, psk_len);
10063 return;
10064 }
10065
10066 if (ssid->mode != WPAS_MODE_P2P_GO || !ssid->p2p_persistent_group) {
10067 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Ignore new_psk_cb on not-persistent GO");
10068 return;
10069 }
10070
10071 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, NULL, ssid->ssid,
10072 ssid->ssid_len);
10073 if (!persistent) {
10074 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not find persistent group information to store the new PSK");
10075 return;
10076 }
10077
10078 p = os_zalloc(sizeof(*p));
10079 if (p == NULL)
10080 return;
10081 if (p2p_dev_addr) {
10082 p->p2p = 1;
10083 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN);
10084 } else {
10085 p->p2p = 0;
10086 os_memcpy(p->addr, mac_addr, ETH_ALEN);
10087 }
10088 os_memcpy(p->psk, psk, psk_len);
10089
10090 if (dl_list_len(&persistent->psk_list) > P2P_MAX_STORED_CLIENTS &&
10091 (last = dl_list_last(&persistent->psk_list,
10092 struct psk_list_entry, list))) {
10093 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove oldest PSK entry for "
10094 MACSTR " (p2p=%u) to make room for a new one",
10095 MAC2STR(last->addr), last->p2p);
10096 dl_list_del(&last->list);
10097 os_free(last);
10098 }
10099
10100 wpas_p2p_remove_psk_entry(wpa_s->p2pdev, persistent,
10101 p2p_dev_addr ? p2p_dev_addr : mac_addr,
10102 p2p_dev_addr == NULL);
10103 if (p2p_dev_addr) {
10104 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for p2p_dev_addr="
10105 MACSTR, MAC2STR(p2p_dev_addr));
10106 } else {
10107 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for addr=" MACSTR,
10108 MAC2STR(mac_addr));
10109 }
10110 dl_list_add(&persistent->psk_list, &p->list);
10111
10112 if (wpa_s->p2pdev->conf->update_config &&
10113 wpa_config_write(wpa_s->p2pdev->confname, wpa_s->p2pdev->conf))
10114 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
10115 }
10116
10117
wpas_p2p_remove_psk(struct wpa_supplicant * wpa_s,struct wpa_ssid * s,const u8 * addr,int iface_addr)10118 static void wpas_p2p_remove_psk(struct wpa_supplicant *wpa_s,
10119 struct wpa_ssid *s, const u8 *addr,
10120 int iface_addr)
10121 {
10122 int res;
10123
10124 res = wpas_p2p_remove_psk_entry(wpa_s, s, addr, iface_addr);
10125 if (res > 0 && wpa_s->conf->update_config &&
10126 wpa_config_write(wpa_s->confname, wpa_s->conf))
10127 wpa_dbg(wpa_s, MSG_DEBUG,
10128 "P2P: Failed to update configuration");
10129 }
10130
10131
wpas_p2p_remove_client_go(struct wpa_supplicant * wpa_s,const u8 * peer,int iface_addr)10132 static void wpas_p2p_remove_client_go(struct wpa_supplicant *wpa_s,
10133 const u8 *peer, int iface_addr)
10134 {
10135 struct hostapd_data *hapd;
10136 struct hostapd_wpa_psk *psk, *prev, *rem;
10137 struct sta_info *sta;
10138
10139 if (wpa_s->ap_iface == NULL || wpa_s->current_ssid == NULL ||
10140 wpa_s->current_ssid->mode != WPAS_MODE_P2P_GO)
10141 return;
10142
10143 /* Remove per-station PSK entry */
10144 hapd = wpa_s->ap_iface->bss[0];
10145 prev = NULL;
10146 psk = hapd->conf->ssid.wpa_psk;
10147 while (psk) {
10148 if ((iface_addr && ether_addr_equal(peer, psk->addr)) ||
10149 (!iface_addr &&
10150 ether_addr_equal(peer, psk->p2p_dev_addr))) {
10151 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove operating group PSK entry for "
10152 MACSTR " iface_addr=%d",
10153 MAC2STR(peer), iface_addr);
10154 if (prev)
10155 prev->next = psk->next;
10156 else
10157 hapd->conf->ssid.wpa_psk = psk->next;
10158 rem = psk;
10159 psk = psk->next;
10160 bin_clear_free(rem, sizeof(*rem));
10161 } else {
10162 prev = psk;
10163 psk = psk->next;
10164 }
10165 }
10166
10167 /* Disconnect from group */
10168 if (iface_addr)
10169 sta = ap_get_sta(hapd, peer);
10170 else
10171 sta = ap_get_sta_p2p(hapd, peer);
10172 if (sta) {
10173 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disconnect peer " MACSTR
10174 " (iface_addr=%d) from group",
10175 MAC2STR(peer), iface_addr);
10176 hostapd_drv_sta_deauth(hapd, sta->addr,
10177 WLAN_REASON_DEAUTH_LEAVING);
10178 ap_sta_deauthenticate(hapd, sta, WLAN_REASON_DEAUTH_LEAVING);
10179 }
10180 }
10181
10182
wpas_p2p_remove_client(struct wpa_supplicant * wpa_s,const u8 * peer,int iface_addr)10183 void wpas_p2p_remove_client(struct wpa_supplicant *wpa_s, const u8 *peer,
10184 int iface_addr)
10185 {
10186 struct wpa_ssid *s;
10187 struct wpa_supplicant *w;
10188 struct wpa_supplicant *p2p_wpa_s = wpa_s->global->p2p_init_wpa_s;
10189
10190 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove client " MACSTR, MAC2STR(peer));
10191
10192 /* Remove from any persistent group */
10193 for (s = p2p_wpa_s->conf->ssid; s; s = s->next) {
10194 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
10195 continue;
10196 if (!iface_addr)
10197 wpas_remove_persistent_peer(p2p_wpa_s, s, peer, 0);
10198 wpas_p2p_remove_psk(p2p_wpa_s, s, peer, iface_addr);
10199 }
10200
10201 /* Remove from any operating group */
10202 for (w = wpa_s->global->ifaces; w; w = w->next)
10203 wpas_p2p_remove_client_go(w, peer, iface_addr);
10204 }
10205
10206
wpas_p2p_psk_failure_removal(void * eloop_ctx,void * timeout_ctx)10207 static void wpas_p2p_psk_failure_removal(void *eloop_ctx, void *timeout_ctx)
10208 {
10209 struct wpa_supplicant *wpa_s = eloop_ctx;
10210 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_PSK_FAILURE);
10211 }
10212
10213
wpas_p2p_group_freq_conflict(void * eloop_ctx,void * timeout_ctx)10214 static void wpas_p2p_group_freq_conflict(void *eloop_ctx, void *timeout_ctx)
10215 {
10216 struct wpa_supplicant *wpa_s = eloop_ctx;
10217
10218 wpa_printf(MSG_DEBUG, "P2P: Frequency conflict - terminate group");
10219 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_FREQ_CONFLICT);
10220 }
10221
10222
wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant * wpa_s,int freq,struct wpa_ssid * ssid)10223 int wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant *wpa_s, int freq,
10224 struct wpa_ssid *ssid)
10225 {
10226 struct wpa_supplicant *iface;
10227
10228 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
10229 if (!iface->current_ssid ||
10230 iface->current_ssid->frequency == freq ||
10231 (iface->p2p_group_interface == NOT_P2P_GROUP_INTERFACE &&
10232 !iface->current_ssid->p2p_group))
10233 continue;
10234
10235 /* Remove the connection with least priority */
10236 if (!wpas_is_p2p_prioritized(iface)) {
10237 /* STA connection has priority over existing
10238 * P2P connection, so remove the interface. */
10239 wpa_printf(MSG_DEBUG, "P2P: Removing P2P connection due to single channel concurrent mode frequency conflict");
10240 eloop_register_timeout(0, 0,
10241 wpas_p2p_group_freq_conflict,
10242 iface, NULL);
10243 /* If connection in progress is P2P connection, do not
10244 * proceed for the connection. */
10245 if (wpa_s == iface)
10246 return -1;
10247 else
10248 return 0;
10249 } else {
10250 /* P2P connection has priority, disable the STA network
10251 */
10252 wpa_supplicant_disable_network(wpa_s->global->ifaces,
10253 ssid);
10254 wpa_msg(wpa_s->global->ifaces, MSG_INFO,
10255 WPA_EVENT_FREQ_CONFLICT " id=%d", ssid->id);
10256 os_memset(wpa_s->global->ifaces->pending_bssid, 0,
10257 ETH_ALEN);
10258 /* If P2P connection is in progress, continue
10259 * connecting...*/
10260 if (wpa_s == iface)
10261 return 0;
10262 else
10263 return -1;
10264 }
10265 }
10266
10267 return 0;
10268 }
10269
10270
wpas_p2p_4way_hs_failed(struct wpa_supplicant * wpa_s)10271 int wpas_p2p_4way_hs_failed(struct wpa_supplicant *wpa_s)
10272 {
10273 struct wpa_ssid *ssid = wpa_s->current_ssid;
10274
10275 if (ssid == NULL || !ssid->p2p_group)
10276 return 0;
10277
10278 if (wpa_s->p2p_last_4way_hs_fail &&
10279 wpa_s->p2p_last_4way_hs_fail == ssid) {
10280 u8 go_dev_addr[ETH_ALEN];
10281 struct wpa_ssid *persistent;
10282
10283 if (wpas_p2p_persistent_group(wpa_s, go_dev_addr,
10284 ssid->ssid,
10285 ssid->ssid_len) <= 0) {
10286 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not determine whether 4-way handshake failures were for a persistent group");
10287 goto disconnect;
10288 }
10289
10290 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Two 4-way handshake failures for a P2P group - go_dev_addr="
10291 MACSTR, MAC2STR(go_dev_addr));
10292 persistent = wpas_p2p_get_persistent(wpa_s->p2pdev, go_dev_addr,
10293 ssid->ssid,
10294 ssid->ssid_len);
10295 if (persistent == NULL || persistent->mode != WPAS_MODE_INFRA) {
10296 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No matching persistent group stored");
10297 goto disconnect;
10298 }
10299 wpa_msg_global(wpa_s->p2pdev, MSG_INFO,
10300 P2P_EVENT_PERSISTENT_PSK_FAIL "%d",
10301 persistent->id);
10302 disconnect:
10303 wpa_s->p2p_last_4way_hs_fail = NULL;
10304 /*
10305 * Remove the group from a timeout to avoid issues with caller
10306 * continuing to use the interface if this is on a P2P group
10307 * interface.
10308 */
10309 eloop_register_timeout(0, 0, wpas_p2p_psk_failure_removal,
10310 wpa_s, NULL);
10311 return 1;
10312 }
10313
10314 wpa_s->p2p_last_4way_hs_fail = ssid;
10315 return 0;
10316 }
10317
10318
10319 #ifdef CONFIG_WPS_NFC
10320
wpas_p2p_nfc_handover(int ndef,struct wpabuf * wsc,struct wpabuf * p2p)10321 static struct wpabuf * wpas_p2p_nfc_handover(int ndef, struct wpabuf *wsc,
10322 struct wpabuf *p2p)
10323 {
10324 struct wpabuf *ret;
10325 size_t wsc_len;
10326
10327 if (p2p == NULL) {
10328 wpabuf_free(wsc);
10329 wpa_printf(MSG_DEBUG, "P2P: No p2p buffer for handover");
10330 return NULL;
10331 }
10332
10333 wsc_len = wsc ? wpabuf_len(wsc) : 0;
10334 ret = wpabuf_alloc(2 + wsc_len + 2 + wpabuf_len(p2p));
10335 if (ret == NULL) {
10336 wpabuf_free(wsc);
10337 wpabuf_free(p2p);
10338 return NULL;
10339 }
10340
10341 wpabuf_put_be16(ret, wsc_len);
10342 if (wsc)
10343 wpabuf_put_buf(ret, wsc);
10344 wpabuf_put_be16(ret, wpabuf_len(p2p));
10345 wpabuf_put_buf(ret, p2p);
10346
10347 wpabuf_free(wsc);
10348 wpabuf_free(p2p);
10349 wpa_hexdump_buf(MSG_DEBUG,
10350 "P2P: Generated NFC connection handover message", ret);
10351
10352 if (ndef && ret) {
10353 struct wpabuf *tmp;
10354 tmp = ndef_build_p2p(ret);
10355 wpabuf_free(ret);
10356 if (tmp == NULL) {
10357 wpa_printf(MSG_DEBUG, "P2P: Failed to NDEF encapsulate handover request");
10358 return NULL;
10359 }
10360 ret = tmp;
10361 }
10362
10363 return ret;
10364 }
10365
10366
wpas_p2p_cli_freq(struct wpa_supplicant * wpa_s,struct wpa_ssid ** ssid,u8 * go_dev_addr)10367 static int wpas_p2p_cli_freq(struct wpa_supplicant *wpa_s,
10368 struct wpa_ssid **ssid, u8 *go_dev_addr)
10369 {
10370 struct wpa_supplicant *iface;
10371
10372 if (go_dev_addr)
10373 os_memset(go_dev_addr, 0, ETH_ALEN);
10374 if (ssid)
10375 *ssid = NULL;
10376 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
10377 if (iface->wpa_state < WPA_ASSOCIATING ||
10378 iface->current_ssid == NULL || iface->assoc_freq == 0 ||
10379 !iface->current_ssid->p2p_group ||
10380 iface->current_ssid->mode != WPAS_MODE_INFRA)
10381 continue;
10382 if (ssid)
10383 *ssid = iface->current_ssid;
10384 if (go_dev_addr)
10385 os_memcpy(go_dev_addr, iface->go_dev_addr, ETH_ALEN);
10386 return iface->assoc_freq;
10387 }
10388 return 0;
10389 }
10390
10391
wpas_p2p_nfc_handover_req(struct wpa_supplicant * wpa_s,int ndef)10392 struct wpabuf * wpas_p2p_nfc_handover_req(struct wpa_supplicant *wpa_s,
10393 int ndef)
10394 {
10395 struct wpabuf *wsc, *p2p;
10396 struct wpa_ssid *ssid;
10397 u8 go_dev_addr[ETH_ALEN];
10398 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr);
10399
10400 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
10401 wpa_printf(MSG_DEBUG, "P2P: P2P disabled - cannot build handover request");
10402 return NULL;
10403 }
10404
10405 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
10406 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
10407 &wpa_s->conf->wps_nfc_dh_privkey) < 0) {
10408 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No DH key available for handover request");
10409 return NULL;
10410 }
10411
10412 wpa_s->p2p2 = false;
10413
10414 if (cli_freq == 0) {
10415 wsc = wps_build_nfc_handover_req_p2p(
10416 wpa_s->parent->wps, wpa_s->conf->wps_nfc_dh_pubkey);
10417 } else
10418 wsc = NULL;
10419 p2p = p2p_build_nfc_handover_req(wpa_s->global->p2p, cli_freq,
10420 go_dev_addr, ssid ? ssid->ssid : NULL,
10421 ssid ? ssid->ssid_len : 0);
10422
10423 return wpas_p2p_nfc_handover(ndef, wsc, p2p);
10424 }
10425
10426
wpas_p2p_nfc_handover_sel(struct wpa_supplicant * wpa_s,int ndef,int tag)10427 struct wpabuf * wpas_p2p_nfc_handover_sel(struct wpa_supplicant *wpa_s,
10428 int ndef, int tag)
10429 {
10430 struct wpabuf *wsc, *p2p;
10431 struct wpa_ssid *ssid;
10432 u8 go_dev_addr[ETH_ALEN];
10433 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr);
10434
10435 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
10436 return NULL;
10437
10438 if (!tag && wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
10439 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
10440 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
10441 return NULL;
10442
10443 wpa_s->p2p2 = false;
10444
10445 if (cli_freq == 0) {
10446 wsc = wps_build_nfc_handover_sel_p2p(
10447 wpa_s->parent->wps,
10448 tag ? wpa_s->conf->wps_nfc_dev_pw_id :
10449 DEV_PW_NFC_CONNECTION_HANDOVER,
10450 wpa_s->conf->wps_nfc_dh_pubkey,
10451 tag ? wpa_s->conf->wps_nfc_dev_pw : NULL);
10452 } else
10453 wsc = NULL;
10454 p2p = p2p_build_nfc_handover_sel(wpa_s->global->p2p, cli_freq,
10455 go_dev_addr, ssid ? ssid->ssid : NULL,
10456 ssid ? ssid->ssid_len : 0);
10457
10458 return wpas_p2p_nfc_handover(ndef, wsc, p2p);
10459 }
10460
10461
wpas_p2p_nfc_join_group(struct wpa_supplicant * wpa_s,struct p2p_nfc_params * params)10462 static int wpas_p2p_nfc_join_group(struct wpa_supplicant *wpa_s,
10463 struct p2p_nfc_params *params)
10464 {
10465 wpa_printf(MSG_DEBUG, "P2P: Initiate join-group based on NFC "
10466 "connection handover (freq=%d)",
10467 params->go_freq);
10468
10469 if (params->go_freq && params->go_ssid_len) {
10470 wpa_s->p2p_wps_method = WPS_NFC;
10471 wpa_s->pending_join_wps_method = WPS_NFC;
10472 os_memset(wpa_s->pending_join_iface_addr, 0, ETH_ALEN);
10473 os_memcpy(wpa_s->pending_join_dev_addr, params->go_dev_addr,
10474 ETH_ALEN);
10475 return wpas_p2p_join_start(wpa_s, params->go_freq,
10476 params->go_ssid,
10477 params->go_ssid_len);
10478 }
10479
10480 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
10481 WPS_NFC, 0, 0, 1, 0, wpa_s->conf->p2p_go_intent,
10482 params->go_freq, wpa_s->p2p_go_vht_center_freq2,
10483 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
10484 wpa_s->p2p_go_he, wpa_s->p2p_go_edmg,
10485 params->go_ssid_len ? params->go_ssid : NULL,
10486 params->go_ssid_len, false, wpa_s->p2p2,
10487 wpa_s->p2p_bootstrap, NULL, false);
10488 }
10489
10490
wpas_p2p_nfc_auth_join(struct wpa_supplicant * wpa_s,struct p2p_nfc_params * params,int tag)10491 static int wpas_p2p_nfc_auth_join(struct wpa_supplicant *wpa_s,
10492 struct p2p_nfc_params *params, int tag)
10493 {
10494 int res, persistent;
10495 struct wpa_ssid *ssid;
10496
10497 wpa_printf(MSG_DEBUG, "P2P: Authorize join-group based on NFC "
10498 "connection handover");
10499 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
10500 ssid = wpa_s->current_ssid;
10501 if (ssid == NULL)
10502 continue;
10503 if (ssid->mode != WPAS_MODE_P2P_GO)
10504 continue;
10505 if (wpa_s->ap_iface == NULL)
10506 continue;
10507 break;
10508 }
10509 if (wpa_s == NULL) {
10510 wpa_printf(MSG_DEBUG, "P2P: Could not find GO interface");
10511 return -1;
10512 }
10513
10514 if (wpa_s->p2pdev->p2p_oob_dev_pw_id !=
10515 DEV_PW_NFC_CONNECTION_HANDOVER &&
10516 !wpa_s->p2pdev->p2p_oob_dev_pw) {
10517 wpa_printf(MSG_DEBUG, "P2P: No NFC Dev Pw known");
10518 return -1;
10519 }
10520 res = wpas_ap_wps_add_nfc_pw(
10521 wpa_s, wpa_s->p2pdev->p2p_oob_dev_pw_id,
10522 wpa_s->p2pdev->p2p_oob_dev_pw,
10523 wpa_s->p2pdev->p2p_peer_oob_pk_hash_known ?
10524 wpa_s->p2pdev->p2p_peer_oob_pubkey_hash : NULL);
10525 if (res)
10526 return res;
10527
10528 if (!tag) {
10529 wpa_printf(MSG_DEBUG, "P2P: Negotiated handover - wait for peer to join without invitation");
10530 return 0;
10531 }
10532
10533 if (!params->peer ||
10534 !(params->peer->dev_capab & P2P_DEV_CAPAB_INVITATION_PROCEDURE))
10535 return 0;
10536
10537 wpa_printf(MSG_DEBUG, "P2P: Static handover - invite peer " MACSTR
10538 " to join", MAC2STR(params->peer->p2p_device_addr));
10539
10540 wpa_s->global->p2p_invite_group = wpa_s;
10541 persistent = ssid->p2p_persistent_group &&
10542 wpas_p2p_get_persistent(wpa_s->p2pdev,
10543 params->peer->p2p_device_addr,
10544 ssid->ssid, ssid->ssid_len);
10545 wpa_s->p2pdev->pending_invite_ssid_id = -1;
10546
10547 return p2p_invite(wpa_s->global->p2p, params->peer->p2p_device_addr,
10548 P2P_INVITE_ROLE_ACTIVE_GO, wpa_s->own_addr,
10549 ssid->ssid, ssid->ssid_len, ssid->frequency,
10550 wpa_s->global->p2p_dev_addr, persistent, 0,
10551 wpa_s->p2pdev->p2p_oob_dev_pw_id, false);
10552 }
10553
10554
wpas_p2p_nfc_init_go_neg(struct wpa_supplicant * wpa_s,struct p2p_nfc_params * params,int forced_freq)10555 static int wpas_p2p_nfc_init_go_neg(struct wpa_supplicant *wpa_s,
10556 struct p2p_nfc_params *params,
10557 int forced_freq)
10558 {
10559 wpa_printf(MSG_DEBUG, "P2P: Initiate GO Negotiation based on NFC "
10560 "connection handover");
10561 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
10562 WPS_NFC, 0, 0, 0, 0, wpa_s->conf->p2p_go_intent,
10563 forced_freq, wpa_s->p2p_go_vht_center_freq2,
10564 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
10565 wpa_s->p2p_go_he, wpa_s->p2p_go_edmg,
10566 NULL, 0, false, wpa_s->p2p2,
10567 wpa_s->p2p_bootstrap, NULL, false);
10568 }
10569
10570
wpas_p2p_nfc_resp_go_neg(struct wpa_supplicant * wpa_s,struct p2p_nfc_params * params,int forced_freq)10571 static int wpas_p2p_nfc_resp_go_neg(struct wpa_supplicant *wpa_s,
10572 struct p2p_nfc_params *params,
10573 int forced_freq)
10574 {
10575 int res;
10576
10577 wpa_printf(MSG_DEBUG, "P2P: Authorize GO Negotiation based on NFC "
10578 "connection handover");
10579 res = wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
10580 WPS_NFC, 0, 0, 0, 1, wpa_s->conf->p2p_go_intent,
10581 forced_freq, wpa_s->p2p_go_vht_center_freq2,
10582 -1, 0, 1, 1, wpa_s->p2p_go_max_oper_chwidth,
10583 wpa_s->p2p_go_he, wpa_s->p2p_go_edmg,
10584 NULL, 0, false, wpa_s->p2p2,
10585 wpa_s->p2p_bootstrap, NULL, false);
10586 if (res)
10587 return res;
10588
10589 res = wpas_p2p_listen(wpa_s, 60);
10590 if (res) {
10591 p2p_unauthorize(wpa_s->global->p2p,
10592 params->peer->p2p_device_addr);
10593 }
10594
10595 return res;
10596 }
10597
10598
wpas_p2p_nfc_connection_handover(struct wpa_supplicant * wpa_s,const struct wpabuf * data,int sel,int tag,int forced_freq)10599 static int wpas_p2p_nfc_connection_handover(struct wpa_supplicant *wpa_s,
10600 const struct wpabuf *data,
10601 int sel, int tag, int forced_freq)
10602 {
10603 const u8 *pos, *end;
10604 u16 len, id;
10605 struct p2p_nfc_params params;
10606 int res;
10607
10608 os_memset(¶ms, 0, sizeof(params));
10609 params.sel = sel;
10610
10611 wpa_hexdump_buf(MSG_DEBUG, "P2P: Received NFC tag payload", data);
10612
10613 pos = wpabuf_head(data);
10614 end = pos + wpabuf_len(data);
10615
10616 if (end - pos < 2) {
10617 wpa_printf(MSG_DEBUG, "P2P: Not enough data for Length of WSC "
10618 "attributes");
10619 return -1;
10620 }
10621 len = WPA_GET_BE16(pos);
10622 pos += 2;
10623 if (len > end - pos) {
10624 wpa_printf(MSG_DEBUG, "P2P: Not enough data for WSC "
10625 "attributes");
10626 return -1;
10627 }
10628 params.wsc_attr = pos;
10629 params.wsc_len = len;
10630 pos += len;
10631
10632 if (end - pos < 2) {
10633 wpa_printf(MSG_DEBUG, "P2P: Not enough data for Length of P2P "
10634 "attributes");
10635 return -1;
10636 }
10637 len = WPA_GET_BE16(pos);
10638 pos += 2;
10639 if (len > end - pos) {
10640 wpa_printf(MSG_DEBUG, "P2P: Not enough data for P2P "
10641 "attributes");
10642 return -1;
10643 }
10644 params.p2p_attr = pos;
10645 params.p2p_len = len;
10646 pos += len;
10647
10648 wpa_hexdump(MSG_DEBUG, "P2P: WSC attributes",
10649 params.wsc_attr, params.wsc_len);
10650 wpa_hexdump(MSG_DEBUG, "P2P: P2P attributes",
10651 params.p2p_attr, params.p2p_len);
10652 if (pos < end) {
10653 wpa_hexdump(MSG_DEBUG,
10654 "P2P: Ignored extra data after P2P attributes",
10655 pos, end - pos);
10656 }
10657
10658 res = p2p_process_nfc_connection_handover(wpa_s->global->p2p, ¶ms);
10659 if (res)
10660 return res;
10661
10662 if (params.next_step == NO_ACTION)
10663 return 0;
10664
10665 if (params.next_step == BOTH_GO) {
10666 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_BOTH_GO "peer=" MACSTR,
10667 MAC2STR(params.peer->p2p_device_addr));
10668 return 0;
10669 }
10670
10671 if (params.next_step == PEER_CLIENT) {
10672 if (!is_zero_ether_addr(params.go_dev_addr)) {
10673 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT
10674 "peer=" MACSTR " freq=%d go_dev_addr=" MACSTR
10675 " ssid=\"%s\"",
10676 MAC2STR(params.peer->p2p_device_addr),
10677 params.go_freq,
10678 MAC2STR(params.go_dev_addr),
10679 wpa_ssid_txt(params.go_ssid,
10680 params.go_ssid_len));
10681 } else {
10682 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT
10683 "peer=" MACSTR " freq=%d",
10684 MAC2STR(params.peer->p2p_device_addr),
10685 params.go_freq);
10686 }
10687 return 0;
10688 }
10689
10690 if (wpas_p2p_cli_freq(wpa_s, NULL, NULL)) {
10691 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_WHILE_CLIENT "peer="
10692 MACSTR, MAC2STR(params.peer->p2p_device_addr));
10693 return 0;
10694 }
10695
10696 wpabuf_free(wpa_s->p2p_oob_dev_pw);
10697 wpa_s->p2p_oob_dev_pw = NULL;
10698
10699 if (params.oob_dev_pw_len < WPS_OOB_PUBKEY_HASH_LEN + 2) {
10700 wpa_printf(MSG_DEBUG, "P2P: No peer OOB Dev Pw "
10701 "received");
10702 return -1;
10703 }
10704
10705 id = WPA_GET_BE16(params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN);
10706 wpa_printf(MSG_DEBUG, "P2P: Peer OOB Dev Pw %u", id);
10707 wpa_hexdump(MSG_DEBUG, "P2P: Peer OOB Public Key hash",
10708 params.oob_dev_pw, WPS_OOB_PUBKEY_HASH_LEN);
10709 os_memcpy(wpa_s->p2p_peer_oob_pubkey_hash,
10710 params.oob_dev_pw, WPS_OOB_PUBKEY_HASH_LEN);
10711 wpa_s->p2p_peer_oob_pk_hash_known = 1;
10712
10713 wpa_s->p2p2 = false;
10714
10715 if (tag) {
10716 if (id < 0x10) {
10717 wpa_printf(MSG_DEBUG, "P2P: Static handover - invalid "
10718 "peer OOB Device Password Id %u", id);
10719 return -1;
10720 }
10721 wpa_printf(MSG_DEBUG, "P2P: Static handover - use peer OOB "
10722 "Device Password Id %u", id);
10723 wpa_hexdump_key(MSG_DEBUG, "P2P: Peer OOB Device Password",
10724 params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN + 2,
10725 params.oob_dev_pw_len -
10726 WPS_OOB_PUBKEY_HASH_LEN - 2);
10727 wpa_s->p2p_oob_dev_pw_id = id;
10728 wpa_s->p2p_oob_dev_pw = wpabuf_alloc_copy(
10729 params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN + 2,
10730 params.oob_dev_pw_len -
10731 WPS_OOB_PUBKEY_HASH_LEN - 2);
10732 if (wpa_s->p2p_oob_dev_pw == NULL)
10733 return -1;
10734
10735 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
10736 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
10737 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
10738 return -1;
10739 } else {
10740 wpa_printf(MSG_DEBUG, "P2P: Using abbreviated WPS handshake "
10741 "without Device Password");
10742 wpa_s->p2p_oob_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER;
10743 }
10744
10745 switch (params.next_step) {
10746 case NO_ACTION:
10747 case BOTH_GO:
10748 case PEER_CLIENT:
10749 /* already covered above */
10750 return 0;
10751 case JOIN_GROUP:
10752 return wpas_p2p_nfc_join_group(wpa_s, ¶ms);
10753 case AUTH_JOIN:
10754 return wpas_p2p_nfc_auth_join(wpa_s, ¶ms, tag);
10755 case INIT_GO_NEG:
10756 return wpas_p2p_nfc_init_go_neg(wpa_s, ¶ms, forced_freq);
10757 case RESP_GO_NEG:
10758 /* TODO: use own OOB Dev Pw */
10759 return wpas_p2p_nfc_resp_go_neg(wpa_s, ¶ms, forced_freq);
10760 }
10761
10762 return -1;
10763 }
10764
10765
wpas_p2p_nfc_tag_process(struct wpa_supplicant * wpa_s,const struct wpabuf * data,int forced_freq)10766 int wpas_p2p_nfc_tag_process(struct wpa_supplicant *wpa_s,
10767 const struct wpabuf *data, int forced_freq)
10768 {
10769 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
10770 return -1;
10771
10772 return wpas_p2p_nfc_connection_handover(wpa_s, data, 1, 1, forced_freq);
10773 }
10774
10775
wpas_p2p_nfc_report_handover(struct wpa_supplicant * wpa_s,int init,const struct wpabuf * req,const struct wpabuf * sel,int forced_freq)10776 int wpas_p2p_nfc_report_handover(struct wpa_supplicant *wpa_s, int init,
10777 const struct wpabuf *req,
10778 const struct wpabuf *sel, int forced_freq)
10779 {
10780 struct wpabuf *tmp;
10781 int ret;
10782
10783 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
10784 return -1;
10785
10786 wpa_printf(MSG_DEBUG, "NFC: P2P connection handover reported");
10787
10788 wpa_hexdump_ascii(MSG_DEBUG, "NFC: Req",
10789 wpabuf_head(req), wpabuf_len(req));
10790 wpa_hexdump_ascii(MSG_DEBUG, "NFC: Sel",
10791 wpabuf_head(sel), wpabuf_len(sel));
10792 if (forced_freq)
10793 wpa_printf(MSG_DEBUG, "NFC: Forced freq %d", forced_freq);
10794 tmp = ndef_parse_p2p(init ? sel : req);
10795 if (tmp == NULL) {
10796 wpa_printf(MSG_DEBUG, "P2P: Could not parse NDEF");
10797 return -1;
10798 }
10799
10800 ret = wpas_p2p_nfc_connection_handover(wpa_s, tmp, init, 0,
10801 forced_freq);
10802 wpabuf_free(tmp);
10803
10804 return ret;
10805 }
10806
10807
wpas_p2p_nfc_tag_enabled(struct wpa_supplicant * wpa_s,int enabled)10808 int wpas_p2p_nfc_tag_enabled(struct wpa_supplicant *wpa_s, int enabled)
10809 {
10810 const u8 *if_addr;
10811 int go_intent = wpa_s->conf->p2p_go_intent;
10812 struct wpa_supplicant *iface;
10813
10814 if (wpa_s->global->p2p == NULL)
10815 return -1;
10816
10817 if (!enabled) {
10818 wpa_printf(MSG_DEBUG, "P2P: Disable use of own NFC Tag");
10819 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
10820 {
10821 if (!iface->ap_iface)
10822 continue;
10823 hostapd_wps_nfc_token_disable(iface->ap_iface->bss[0]);
10824 }
10825 p2p_set_authorized_oob_dev_pw_id(wpa_s->global->p2p, 0,
10826 0, NULL);
10827 if (wpa_s->p2p_nfc_tag_enabled)
10828 wpas_p2p_remove_pending_group_interface(wpa_s);
10829 wpa_s->p2p_nfc_tag_enabled = 0;
10830 return 0;
10831 }
10832
10833 if (wpa_s->global->p2p_disabled)
10834 return -1;
10835
10836 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL ||
10837 wpa_s->conf->wps_nfc_dh_privkey == NULL ||
10838 wpa_s->conf->wps_nfc_dev_pw == NULL ||
10839 wpa_s->conf->wps_nfc_dev_pw_id < 0x10) {
10840 wpa_printf(MSG_DEBUG, "P2P: NFC password token not configured "
10841 "to allow static handover cases");
10842 return -1;
10843 }
10844
10845 wpa_printf(MSG_DEBUG, "P2P: Enable use of own NFC Tag");
10846
10847 wpa_s->p2p_oob_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
10848 wpabuf_free(wpa_s->p2p_oob_dev_pw);
10849 wpa_s->p2p_oob_dev_pw = wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
10850 if (wpa_s->p2p_oob_dev_pw == NULL)
10851 return -1;
10852 wpa_s->p2p_peer_oob_pk_hash_known = 0;
10853
10854 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO ||
10855 wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT) {
10856 /*
10857 * P2P Group Interface present and the command came on group
10858 * interface, so enable the token for the current interface.
10859 */
10860 wpa_s->create_p2p_iface = 0;
10861 } else {
10862 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
10863 }
10864
10865 if (wpa_s->create_p2p_iface) {
10866 enum wpa_driver_if_type iftype;
10867 /* Prepare to add a new interface for the group */
10868 iftype = WPA_IF_P2P_GROUP;
10869 if (go_intent == 15)
10870 iftype = WPA_IF_P2P_GO;
10871 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
10872 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
10873 "interface for the group");
10874 return -1;
10875 }
10876
10877 if_addr = wpa_s->pending_interface_addr;
10878 } else if (wpa_s->p2p_mgmt)
10879 if_addr = wpa_s->parent->own_addr;
10880 else
10881 if_addr = wpa_s->own_addr;
10882
10883 wpa_s->p2p_nfc_tag_enabled = enabled;
10884
10885 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
10886 struct hostapd_data *hapd;
10887 if (iface->ap_iface == NULL)
10888 continue;
10889 hapd = iface->ap_iface->bss[0];
10890 wpabuf_free(hapd->conf->wps_nfc_dh_pubkey);
10891 hapd->conf->wps_nfc_dh_pubkey =
10892 wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
10893 wpabuf_free(hapd->conf->wps_nfc_dh_privkey);
10894 hapd->conf->wps_nfc_dh_privkey =
10895 wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
10896 wpabuf_free(hapd->conf->wps_nfc_dev_pw);
10897 hapd->conf->wps_nfc_dev_pw =
10898 wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
10899 hapd->conf->wps_nfc_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
10900
10901 if (hostapd_wps_nfc_token_enable(iface->ap_iface->bss[0]) < 0) {
10902 wpa_dbg(iface, MSG_DEBUG,
10903 "P2P: Failed to enable NFC Tag for GO");
10904 }
10905 }
10906 p2p_set_authorized_oob_dev_pw_id(
10907 wpa_s->global->p2p, wpa_s->conf->wps_nfc_dev_pw_id, go_intent,
10908 if_addr);
10909
10910 return 0;
10911 }
10912
10913 #endif /* CONFIG_WPS_NFC */
10914
10915
wpas_p2p_optimize_listen_channel(struct wpa_supplicant * wpa_s,struct wpa_used_freq_data * freqs,unsigned int num)10916 static void wpas_p2p_optimize_listen_channel(struct wpa_supplicant *wpa_s,
10917 struct wpa_used_freq_data *freqs,
10918 unsigned int num)
10919 {
10920 u8 curr_chan, cand, chan;
10921 unsigned int i;
10922
10923 /*
10924 * If possible, optimize the Listen channel to be a channel that is
10925 * already used by one of the other interfaces.
10926 */
10927 if (!wpa_s->conf->p2p_optimize_listen_chan)
10928 return;
10929
10930 curr_chan = p2p_get_listen_channel(wpa_s->global->p2p);
10931 for (i = 0, cand = 0; i < num; i++) {
10932 ieee80211_freq_to_chan(freqs[i].freq, &chan);
10933 if (curr_chan == chan) {
10934 cand = 0;
10935 break;
10936 }
10937
10938 if (chan == 1 || chan == 6 || chan == 11)
10939 cand = chan;
10940 }
10941
10942 if (cand) {
10943 wpa_dbg(wpa_s, MSG_DEBUG,
10944 "P2P: Update Listen channel to %u based on operating channel",
10945 cand);
10946 p2p_set_listen_channel(wpa_s->global->p2p, 81, cand, 0);
10947 }
10948 }
10949
10950
wpas_p2p_move_go_csa(struct wpa_supplicant * wpa_s)10951 static int wpas_p2p_move_go_csa(struct wpa_supplicant *wpa_s)
10952 {
10953 struct hostapd_config *conf;
10954 struct p2p_go_neg_results params;
10955 struct csa_settings csa_settings;
10956 struct wpa_ssid *current_ssid = wpa_s->current_ssid;
10957 int old_freq = current_ssid->frequency;
10958 int ret;
10959
10960 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP_CSA)) {
10961 wpa_dbg(wpa_s, MSG_DEBUG, "CSA is not enabled");
10962 return -1;
10963 }
10964
10965 /*
10966 * TODO: This function may not always work correctly. For example,
10967 * when we have a running GO and a BSS on a DFS channel.
10968 */
10969 if (wpas_p2p_init_go_params(wpa_s, ¶ms, 0, 0, 0, 0, 0, 0, 0,
10970 NULL)) {
10971 wpa_dbg(wpa_s, MSG_DEBUG,
10972 "P2P CSA: Failed to select new frequency for GO");
10973 return -1;
10974 }
10975
10976 if (current_ssid->frequency == params.freq) {
10977 wpa_dbg(wpa_s, MSG_DEBUG,
10978 "P2P CSA: Selected same frequency - not moving GO");
10979 return 0;
10980 }
10981
10982 conf = hostapd_config_defaults();
10983 if (!conf) {
10984 wpa_dbg(wpa_s, MSG_DEBUG,
10985 "P2P CSA: Failed to allocate default config");
10986 return -1;
10987 }
10988
10989 current_ssid->frequency = params.freq;
10990 if (wpa_supplicant_conf_ap_ht(wpa_s, current_ssid, conf)) {
10991 wpa_dbg(wpa_s, MSG_DEBUG,
10992 "P2P CSA: Failed to create new GO config");
10993 ret = -1;
10994 goto out;
10995 }
10996
10997 if (conf->hw_mode != wpa_s->ap_iface->current_mode->mode &&
10998 (wpa_s->ap_iface->current_mode->mode != HOSTAPD_MODE_IEEE80211A ||
10999 is_6ghz_freq(wpa_s->ap_iface->freq) ||
11000 conf->hw_mode != HOSTAPD_MODE_IEEE80211G)) {
11001 wpa_dbg(wpa_s, MSG_INFO,
11002 "P2P CSA: CSA from hardware mode %d%s to %d is not supported",
11003 wpa_s->ap_iface->current_mode->mode,
11004 is_6ghz_freq(wpa_s->ap_iface->freq) ? " (6 GHz)" : "",
11005 conf->hw_mode);
11006 ret = -1;
11007 goto out;
11008 }
11009
11010 os_memset(&csa_settings, 0, sizeof(csa_settings));
11011 csa_settings.cs_count = P2P_GO_CSA_COUNT;
11012 csa_settings.block_tx = P2P_GO_CSA_BLOCK_TX;
11013 csa_settings.link_id = -1;
11014 csa_settings.freq_params.freq = params.freq;
11015 csa_settings.freq_params.sec_channel_offset = conf->secondary_channel;
11016 csa_settings.freq_params.ht_enabled = conf->ieee80211n;
11017 csa_settings.freq_params.bandwidth = conf->secondary_channel ? 40 : 20;
11018
11019 if (conf->ieee80211ac) {
11020 int freq1 = 0, freq2 = 0;
11021 u8 chan, opclass;
11022
11023 if (ieee80211_freq_to_channel_ext(params.freq,
11024 conf->secondary_channel,
11025 conf->vht_oper_chwidth,
11026 &opclass, &chan) ==
11027 NUM_HOSTAPD_MODES) {
11028 wpa_printf(MSG_ERROR, "P2P CSA: Bad freq");
11029 ret = -1;
11030 goto out;
11031 }
11032
11033 if (conf->vht_oper_centr_freq_seg0_idx)
11034 freq1 = ieee80211_chan_to_freq(
11035 NULL, opclass,
11036 conf->vht_oper_centr_freq_seg0_idx);
11037
11038 if (conf->vht_oper_centr_freq_seg1_idx)
11039 freq2 = ieee80211_chan_to_freq(
11040 NULL, opclass,
11041 conf->vht_oper_centr_freq_seg1_idx);
11042
11043 if (freq1 < 0 || freq2 < 0) {
11044 wpa_dbg(wpa_s, MSG_DEBUG,
11045 "P2P CSA: Selected invalid VHT center freqs");
11046 ret = -1;
11047 goto out;
11048 }
11049
11050 csa_settings.freq_params.vht_enabled = conf->ieee80211ac;
11051 csa_settings.freq_params.center_freq1 = freq1;
11052 csa_settings.freq_params.center_freq2 = freq2;
11053
11054 switch (conf->vht_oper_chwidth) {
11055 case CONF_OPER_CHWIDTH_80MHZ:
11056 case CONF_OPER_CHWIDTH_80P80MHZ:
11057 csa_settings.freq_params.bandwidth = 80;
11058 break;
11059 case CONF_OPER_CHWIDTH_160MHZ:
11060 csa_settings.freq_params.bandwidth = 160;
11061 break;
11062 default:
11063 break;
11064 }
11065 }
11066
11067 ret = ap_switch_channel(wpa_s, &csa_settings);
11068 out:
11069 current_ssid->frequency = old_freq;
11070 hostapd_config_free(conf);
11071 return ret;
11072 }
11073
11074
wpas_p2p_move_go_no_csa(struct wpa_supplicant * wpa_s)11075 static void wpas_p2p_move_go_no_csa(struct wpa_supplicant *wpa_s)
11076 {
11077 struct p2p_go_neg_results params;
11078 struct wpa_ssid *current_ssid = wpa_s->current_ssid;
11079 void (*ap_configured_cb)(void *ctx, void *data);
11080 void *ap_configured_cb_ctx, *ap_configured_cb_data;
11081
11082 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_REMOVE_AND_REFORM_GROUP);
11083
11084 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Move GO from freq=%d MHz",
11085 current_ssid->frequency);
11086
11087 /* Stop the AP functionality */
11088 /* TODO: Should do this in a way that does not indicated to possible
11089 * P2P Clients in the group that the group is terminated. */
11090 /* If this action occurs before a group is started, the callback should
11091 * be preserved, or GROUP-STARTED event would be lost. If this action
11092 * occurs after a group is started, these pointers are all NULL and
11093 * harmless. */
11094 ap_configured_cb = wpa_s->ap_configured_cb;
11095 ap_configured_cb_ctx = wpa_s->ap_configured_cb_ctx;
11096 ap_configured_cb_data = wpa_s->ap_configured_cb_data;
11097 wpa_supplicant_ap_deinit(wpa_s);
11098
11099 /* Reselect the GO frequency */
11100 if (wpas_p2p_init_go_params(wpa_s, ¶ms, 0, 0, 0, 0, 0, 0, 0,
11101 NULL)) {
11102 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Failed to reselect freq");
11103 wpas_p2p_group_delete(wpa_s,
11104 P2P_GROUP_REMOVAL_GO_LEAVE_CHANNEL);
11105 return;
11106 }
11107 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New freq selected for the GO (%u MHz)",
11108 params.freq);
11109
11110 if (params.freq &&
11111 !p2p_supported_freq_go(wpa_s->global->p2p, params.freq)) {
11112 wpa_printf(MSG_DEBUG,
11113 "P2P: Selected freq (%u MHz) is not valid for P2P",
11114 params.freq);
11115 wpas_p2p_group_delete(wpa_s,
11116 P2P_GROUP_REMOVAL_GO_LEAVE_CHANNEL);
11117 return;
11118 }
11119
11120 /* Restore preserved callback parameters */
11121 wpa_s->ap_configured_cb = ap_configured_cb;
11122 wpa_s->ap_configured_cb_ctx = ap_configured_cb_ctx;
11123 wpa_s->ap_configured_cb_data = ap_configured_cb_data;
11124
11125 /* Update the frequency */
11126 current_ssid->frequency = params.freq;
11127 wpa_s->connect_without_scan = current_ssid;
11128 wpa_s->reassociate = 1;
11129 wpa_s->disconnected = 0;
11130 wpa_supplicant_req_scan(wpa_s, 0, 0);
11131 }
11132
11133
wpas_p2p_move_go(void * eloop_ctx,void * timeout_ctx)11134 static void wpas_p2p_move_go(void *eloop_ctx, void *timeout_ctx)
11135 {
11136 struct wpa_supplicant *wpa_s = eloop_ctx;
11137
11138 if (!wpa_s->ap_iface || !wpa_s->current_ssid)
11139 return;
11140
11141 wpas_p2p_go_update_common_freqs(wpa_s);
11142
11143 /* Do not move GO in the middle of a CSA */
11144 if (hostapd_csa_in_progress(wpa_s->ap_iface)) {
11145 wpa_printf(MSG_DEBUG,
11146 "P2P: CSA is in progress - not moving GO");
11147 return;
11148 }
11149
11150 /*
11151 * First, try a channel switch flow. If it is not supported or fails,
11152 * take down the GO and bring it up again.
11153 */
11154 if (wpas_p2p_move_go_csa(wpa_s) < 0)
11155 wpas_p2p_move_go_no_csa(wpa_s);
11156 }
11157
11158
wpas_p2p_reconsider_moving_go(void * eloop_ctx,void * timeout_ctx)11159 static void wpas_p2p_reconsider_moving_go(void *eloop_ctx, void *timeout_ctx)
11160 {
11161 struct wpa_supplicant *wpa_s = eloop_ctx;
11162 struct wpa_used_freq_data *freqs = NULL;
11163 unsigned int num = wpa_s->num_multichan_concurrent;
11164
11165 freqs = os_calloc(num, sizeof(struct wpa_used_freq_data));
11166 if (!freqs)
11167 return;
11168
11169 num = get_shared_radio_freqs_data(wpa_s, freqs, num, false);
11170
11171 /* Previous attempt to move a GO was not possible -- try again. */
11172 wpas_p2p_consider_moving_gos(wpa_s, freqs, num,
11173 WPAS_P2P_CHANNEL_UPDATE_ANY);
11174
11175 os_free(freqs);
11176 }
11177
11178
11179 /*
11180 * Consider moving a GO from its currently used frequency:
11181 * 1. It is possible that due to regulatory consideration the frequency
11182 * can no longer be used and there is a need to evacuate the GO.
11183 * 2. It is possible that due to MCC considerations, it would be preferable
11184 * to move the GO to a channel that is currently used by some other
11185 * station interface.
11186 *
11187 * In case a frequency that became invalid is once again valid, cancel a
11188 * previously initiated GO frequency change.
11189 */
wpas_p2p_consider_moving_one_go(struct wpa_supplicant * wpa_s,struct wpa_used_freq_data * freqs,unsigned int num)11190 static void wpas_p2p_consider_moving_one_go(struct wpa_supplicant *wpa_s,
11191 struct wpa_used_freq_data *freqs,
11192 unsigned int num)
11193 {
11194 unsigned int i, invalid_freq = 0, policy_move = 0, flags = 0;
11195 unsigned int timeout;
11196 int freq;
11197 int dfs_offload;
11198
11199 wpas_p2p_go_update_common_freqs(wpa_s);
11200
11201 freq = wpa_s->current_ssid->frequency;
11202 dfs_offload = (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) &&
11203 ieee80211_is_dfs(freq, wpa_s->hw.modes, wpa_s->hw.num_modes);
11204 for (i = 0, invalid_freq = 0; i < num; i++) {
11205 if (freqs[i].freq == freq) {
11206 flags = freqs[i].flags;
11207
11208 /* The channel is invalid, must change it */
11209 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq) &&
11210 !dfs_offload) {
11211 wpa_dbg(wpa_s, MSG_DEBUG,
11212 "P2P: Freq=%d MHz no longer valid for GO",
11213 freq);
11214 invalid_freq = 1;
11215 }
11216 } else if (freqs[i].flags == 0) {
11217 /* Freq is not used by any other station interface */
11218 continue;
11219 } else if (!p2p_supported_freq(wpa_s->global->p2p,
11220 freqs[i].freq) && !dfs_offload) {
11221 /* Freq is not valid for P2P use cases */
11222 continue;
11223 } else if (wpa_s->conf->p2p_go_freq_change_policy ==
11224 P2P_GO_FREQ_MOVE_SCM) {
11225 policy_move = 1;
11226 } else if (wpa_s->conf->p2p_go_freq_change_policy ==
11227 P2P_GO_FREQ_MOVE_SCM_PEER_SUPPORTS &&
11228 wpas_p2p_go_is_peer_freq(wpa_s, freqs[i].freq)) {
11229 policy_move = 1;
11230 } else if ((wpa_s->conf->p2p_go_freq_change_policy ==
11231 P2P_GO_FREQ_MOVE_SCM_ECSA) &&
11232 wpas_p2p_go_is_peer_freq(wpa_s, freqs[i].freq)) {
11233 if (!p2p_get_group_num_members(wpa_s->p2p_group)) {
11234 policy_move = 1;
11235 } else if ((wpa_s->drv_flags &
11236 WPA_DRIVER_FLAGS_AP_CSA) &&
11237 wpas_p2p_go_clients_support_ecsa(wpa_s)) {
11238 u8 chan;
11239
11240 /*
11241 * We do not support CSA between bands, so move
11242 * GO only within the same band.
11243 */
11244 if (wpa_s->ap_iface->current_mode->mode ==
11245 ieee80211_freq_to_chan(freqs[i].freq,
11246 &chan))
11247 policy_move = 1;
11248 }
11249 }
11250 }
11251
11252 wpa_dbg(wpa_s, MSG_DEBUG,
11253 "P2P: GO move: invalid_freq=%u, policy_move=%u, flags=0x%X",
11254 invalid_freq, policy_move, flags);
11255
11256 /*
11257 * The channel is valid, or we are going to have a policy move, so
11258 * cancel timeout.
11259 */
11260 if (!invalid_freq || policy_move) {
11261 wpa_dbg(wpa_s, MSG_DEBUG,
11262 "P2P: Cancel a GO move from freq=%d MHz", freq);
11263 eloop_cancel_timeout(wpas_p2p_move_go, wpa_s, NULL);
11264
11265 if (wpas_p2p_in_progress(wpa_s)) {
11266 wpa_dbg(wpa_s, MSG_DEBUG,
11267 "P2P: GO move: policy CS is not allowed - setting timeout to re-consider GO move");
11268 eloop_cancel_timeout(wpas_p2p_reconsider_moving_go,
11269 wpa_s, NULL);
11270 eloop_register_timeout(P2P_RECONSIDER_GO_MOVE_DELAY, 0,
11271 wpas_p2p_reconsider_moving_go,
11272 wpa_s, NULL);
11273 return;
11274 }
11275 }
11276
11277 if (!invalid_freq && (!policy_move || flags != 0)) {
11278 wpa_dbg(wpa_s, MSG_DEBUG,
11279 "P2P: Not initiating a GO frequency change");
11280 return;
11281 }
11282
11283 /*
11284 * Do not consider moving GO if it is in the middle of a CSA. When the
11285 * CSA is finished this flow should be retriggered.
11286 */
11287 if (hostapd_csa_in_progress(wpa_s->ap_iface)) {
11288 wpa_dbg(wpa_s, MSG_DEBUG,
11289 "P2P: Not initiating a GO frequency change - CSA is in progress");
11290 return;
11291 }
11292
11293 if (invalid_freq && !wpas_p2p_disallowed_freq(wpa_s->global, freq))
11294 timeout = P2P_GO_FREQ_CHANGE_TIME;
11295 else
11296 timeout = 0;
11297
11298 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Move GO from freq=%d MHz in %d secs",
11299 freq, timeout);
11300 eloop_cancel_timeout(wpas_p2p_move_go, wpa_s, NULL);
11301 eloop_register_timeout(timeout, 0, wpas_p2p_move_go, wpa_s, NULL);
11302 }
11303
11304
wpas_p2p_consider_moving_gos(struct wpa_supplicant * wpa_s,struct wpa_used_freq_data * freqs,unsigned int num,enum wpas_p2p_channel_update_trig trig)11305 static void wpas_p2p_consider_moving_gos(struct wpa_supplicant *wpa_s,
11306 struct wpa_used_freq_data *freqs,
11307 unsigned int num,
11308 enum wpas_p2p_channel_update_trig trig)
11309 {
11310 struct wpa_supplicant *ifs;
11311
11312 eloop_cancel_timeout(wpas_p2p_reconsider_moving_go, ELOOP_ALL_CTX,
11313 NULL);
11314
11315 /*
11316 * Travers all the radio interfaces, and for each GO interface, check
11317 * if there is a need to move the GO from the frequency it is using,
11318 * or in case the frequency is valid again, cancel the evacuation flow.
11319 */
11320 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
11321 radio_list) {
11322 if (ifs->current_ssid == NULL ||
11323 ifs->current_ssid->mode != WPAS_MODE_P2P_GO)
11324 continue;
11325
11326 /*
11327 * The GO was just started or completed channel switch, no need
11328 * to move it.
11329 */
11330 if (wpa_s == ifs &&
11331 (trig == WPAS_P2P_CHANNEL_UPDATE_STATE_CHANGE ||
11332 trig == WPAS_P2P_CHANNEL_UPDATE_CS)) {
11333 wpa_dbg(wpa_s, MSG_DEBUG,
11334 "P2P: GO move - schedule re-consideration");
11335 eloop_register_timeout(P2P_RECONSIDER_GO_MOVE_DELAY, 0,
11336 wpas_p2p_reconsider_moving_go,
11337 wpa_s, NULL);
11338 continue;
11339 }
11340
11341 wpas_p2p_consider_moving_one_go(ifs, freqs, num);
11342 }
11343 }
11344
11345
wpas_p2p_indicate_state_change(struct wpa_supplicant * wpa_s)11346 void wpas_p2p_indicate_state_change(struct wpa_supplicant *wpa_s)
11347 {
11348 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
11349 return;
11350
11351 wpas_p2p_update_channel_list(wpa_s,
11352 WPAS_P2P_CHANNEL_UPDATE_STATE_CHANGE);
11353 }
11354
11355
wpas_p2p_deinit_iface(struct wpa_supplicant * wpa_s)11356 void wpas_p2p_deinit_iface(struct wpa_supplicant *wpa_s)
11357 {
11358 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
11359 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
11360 "the management interface is being removed");
11361 wpas_p2p_deinit_global(wpa_s->global);
11362 }
11363 }
11364
11365
wpas_p2p_ap_deinit(struct wpa_supplicant * wpa_s)11366 void wpas_p2p_ap_deinit(struct wpa_supplicant *wpa_s)
11367 {
11368 if (wpa_s->ap_iface->bss)
11369 wpa_s->ap_iface->bss[0]->p2p_group = NULL;
11370 wpas_p2p_group_deinit(wpa_s);
11371 }
11372
11373
wpas_p2p_lo_start(struct wpa_supplicant * wpa_s,unsigned int freq,unsigned int period,unsigned int interval,unsigned int count)11374 int wpas_p2p_lo_start(struct wpa_supplicant *wpa_s, unsigned int freq,
11375 unsigned int period, unsigned int interval,
11376 unsigned int count)
11377 {
11378 struct p2p_data *p2p = wpa_s->global->p2p;
11379 u8 *device_types;
11380 size_t dev_types_len;
11381 struct wpabuf *buf;
11382 int ret;
11383
11384 if (wpa_s->p2p_lo_started) {
11385 wpa_dbg(wpa_s, MSG_DEBUG,
11386 "P2P Listen offload is already started");
11387 return 0;
11388 }
11389
11390 if (wpa_s->global->p2p == NULL ||
11391 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD)) {
11392 wpa_printf(MSG_DEBUG, "P2P: Listen offload not supported");
11393 return -1;
11394 }
11395
11396 if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
11397 wpa_printf(MSG_ERROR, "P2P: Input channel not supported: %u",
11398 freq);
11399 return -1;
11400 }
11401
11402 /* Get device type */
11403 dev_types_len = (wpa_s->conf->num_sec_device_types + 1) *
11404 WPS_DEV_TYPE_LEN;
11405 device_types = os_malloc(dev_types_len);
11406 if (!device_types)
11407 return -1;
11408 os_memcpy(device_types, wpa_s->conf->device_type, WPS_DEV_TYPE_LEN);
11409 os_memcpy(&device_types[WPS_DEV_TYPE_LEN], wpa_s->conf->sec_device_type,
11410 wpa_s->conf->num_sec_device_types * WPS_DEV_TYPE_LEN);
11411
11412 /* Get Probe Response IE(s) */
11413 buf = p2p_build_probe_resp_template(p2p, freq);
11414 if (!buf) {
11415 os_free(device_types);
11416 return -1;
11417 }
11418
11419 ret = wpa_drv_p2p_lo_start(wpa_s, freq, period, interval, count,
11420 device_types, dev_types_len,
11421 wpabuf_mhead_u8(buf), wpabuf_len(buf));
11422 if (ret < 0)
11423 wpa_dbg(wpa_s, MSG_DEBUG,
11424 "P2P: Failed to start P2P listen offload");
11425
11426 os_free(device_types);
11427 wpabuf_free(buf);
11428
11429 if (ret == 0) {
11430 wpa_s->p2p_lo_started = 1;
11431
11432 /* Stop current P2P listen if any */
11433 wpas_stop_listen(wpa_s);
11434 }
11435
11436 return ret;
11437 }
11438
11439
wpas_p2p_lo_stop(struct wpa_supplicant * wpa_s)11440 int wpas_p2p_lo_stop(struct wpa_supplicant *wpa_s)
11441 {
11442 int ret;
11443
11444 if (!wpa_s->p2p_lo_started)
11445 return 0;
11446
11447 ret = wpa_drv_p2p_lo_stop(wpa_s);
11448 if (ret < 0)
11449 wpa_dbg(wpa_s, MSG_DEBUG,
11450 "P2P: Failed to stop P2P listen offload");
11451
11452 wpa_s->p2p_lo_started = 0;
11453 return ret;
11454 }
11455
11456
wpas_p2p_usd_elems(struct wpa_supplicant * wpa_s,const char * service_name)11457 struct wpabuf * wpas_p2p_usd_elems(struct wpa_supplicant *wpa_s,
11458 const char *service_name)
11459 {
11460 struct p2p_data *p2p = wpa_s->global->p2p;
11461
11462 if (wpa_s->global->p2p_disabled || !p2p)
11463 return NULL;
11464 p2p_usd_service_hash(p2p, service_name);
11465 return p2p_usd_elems(p2p);
11466 }
11467
11468
wpas_p2p_process_usd_elems(struct wpa_supplicant * wpa_s,const u8 * buf,u16 buf_len,const u8 * peer_addr,unsigned int freq)11469 void wpas_p2p_process_usd_elems(struct wpa_supplicant *wpa_s, const u8 *buf,
11470 u16 buf_len, const u8 *peer_addr,
11471 unsigned int freq)
11472 {
11473 struct p2p_data *p2p = wpa_s->global->p2p;
11474
11475 if (wpa_s->global->p2p_disabled || !p2p)
11476 return;
11477 p2p_process_usd_elems(p2p, buf, buf_len, peer_addr, freq);
11478 }
11479
11480
11481 #ifdef CONFIG_PASN
11482
wpas_p2p_pasn_auth_rx(struct wpa_supplicant * wpa_s,const struct ieee80211_mgmt * mgmt,size_t len,int freq)11483 int wpas_p2p_pasn_auth_rx(struct wpa_supplicant *wpa_s,
11484 const struct ieee80211_mgmt *mgmt, size_t len,
11485 int freq)
11486 {
11487 struct p2p_data *p2p = wpa_s->global->p2p;
11488
11489 if (wpa_s->global->p2p_disabled || !p2p)
11490 return -2;
11491 return p2p_pasn_auth_rx(p2p, mgmt, len, freq);
11492 }
11493
11494
wpas_p2p_pasn_auth_tx_status(struct wpa_supplicant * wpa_s,const u8 * data,size_t data_len,bool acked)11495 int wpas_p2p_pasn_auth_tx_status(struct wpa_supplicant *wpa_s, const u8 *data,
11496 size_t data_len, bool acked)
11497 {
11498 struct p2p_data *p2p = wpa_s->global->p2p;
11499 struct wpa_p2p_pasn_auth_work *awork;
11500
11501 if (!wpa_s->p2p_pasn_auth_work)
11502 return -1;
11503 awork = wpa_s->p2p_pasn_auth_work->ctx;
11504
11505 return p2p_pasn_auth_tx_status(p2p, data, data_len, acked,
11506 awork->verify);
11507 }
11508
11509
11510 #ifdef CONFIG_TESTING_OPTIONS
wpas_p2p_get_pasn_ptk(struct wpa_supplicant * wpa_s,const u8 ** ptk,size_t * ptk_len)11511 int wpas_p2p_get_pasn_ptk(struct wpa_supplicant *wpa_s, const u8 **ptk,
11512 size_t *ptk_len)
11513 {
11514 struct p2p_data *p2p = wpa_s->global->p2p;
11515
11516 if (wpa_s->global->p2p_disabled || !p2p)
11517 return -2;
11518 return p2p_pasn_get_ptk(p2p, ptk, ptk_len);
11519 }
11520 #endif /* CONFIG_TESTING_OPTIONS */
11521
11522 #endif /* CONFIG_PASN */
11523
11524
wpas_p2p_get_dira(struct wpa_supplicant * wpa_s,char * buf,size_t buf_len)11525 int wpas_p2p_get_dira(struct wpa_supplicant *wpa_s, char *buf, size_t buf_len)
11526 {
11527 struct p2p_data *p2p = wpa_s->global->p2p;
11528
11529 if (wpa_s->global->p2p_disabled || !p2p)
11530 return 0;
11531 return p2p_get_dira_info(p2p, buf, buf_len);
11532 }
11533
11534
wpas_p2p_validate_dira(struct wpa_supplicant * wpa_s,const u8 * addr,u8 cipher,const u8 * nonce,const u8 * tag)11535 int wpas_p2p_validate_dira(struct wpa_supplicant *wpa_s, const u8 *addr,
11536 u8 cipher, const u8 *nonce, const u8 *tag)
11537 {
11538 if (cipher != DIRA_CIPHER_VERSION_128) {
11539 wpa_printf(MSG_INFO, "P2P2: Unsupported DIRA cipher version %d",
11540 cipher);
11541 return 0;
11542 }
11543
11544 return wpas_validate_dira(wpa_s, addr, nonce, tag);
11545 }
11546
11547
wpas_p2p_update_dev_addr(struct wpa_supplicant * wpa_s)11548 void wpas_p2p_update_dev_addr(struct wpa_supplicant *wpa_s)
11549 {
11550 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
11551 p2p_set_dev_addr(wpa_s->global->p2p, wpa_s->own_addr);
11552 }
11553