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