]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/p2p_supplicant.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Extend STATUS command with frequency information
[thirdparty/hostap.git] / wpa_supplicant / p2p_supplicant.c
CommitLineData
b22128ef
JM		 1/*
2 * wpa_supplicant - P2P
3 * Copyright (c) 2009-2010, Atheros Communications
1b5d4714 4 * Copyright (c) 2010-2014, Jouni Malinen <j@w1.fi>
b22128ef 5 *
e22d4d95
JM		 6 * This software may be distributed under the terms of the BSD license.
7 * See README for more details.
b22128ef
JM		 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"
adc33680 20#include "ap/ap_config.h"
f2c56602
JM		 21#include "ap/sta_info.h"
22#include "ap/ap_drv_ops.h"
dd876771 23#include "ap/wps_hostapd.h"
aefb53bd 24#include "ap/p2p_hostapd.h"
20a0b03d
JM		 25#include "eapol_supp/eapol_supp_sm.h"
26#include "rsn_supp/wpa.h"
b22128ef
JM		 27#include "wpa_supplicant_i.h"
28#include "driver_i.h"
29#include "ap.h"
30#include "config_ssid.h"
31#include "config.h"
b22128ef
JM		 32#include "notify.h"
33#include "scan.h"
34#include "bss.h"
24f6497c 35#include "offchannel.h"
b22128ef
JM		 36#include "wps_supplicant.h"
37#include "p2p_supplicant.h"
b125c48f 38#include "wifi_display.h"
b22128ef
JM		 39
40
9b1ab931
JM		 41/*
42 * How many times to try to scan to find the GO before giving up on join
43 * request.
44 */
45#define P2P_MAX_JOIN_SCAN_ATTEMPTS 10
46
84286a22
SDU		 47#define P2P_AUTO_PD_SCAN_ATTEMPTS 5
48
c8106615
JM		 49#ifndef P2P_MAX_CLIENT_IDLE
50/*
51 * How many seconds to try to reconnect to the GO when connection in P2P client
52 * role has been lost.
53 */
54#define P2P_MAX_CLIENT_IDLE 10
55#endif /* P2P_MAX_CLIENT_IDLE */
56
361cdf34
JM		 57#ifndef P2P_MAX_INITIAL_CONN_WAIT
58/*
59 * How many seconds to wait for initial 4-way handshake to get completed after
91364b7f
SDU		 60 * WPS provisioning step or after the re-invocation of a persistent group on a
61 * P2P Client.
361cdf34
JM		 62 */
63#define P2P_MAX_INITIAL_CONN_WAIT 10
64#endif /* P2P_MAX_INITIAL_CONN_WAIT */
65
c1c0b35f
JM		 66#ifndef P2P_MAX_INITIAL_CONN_WAIT_GO
67/*
68 * How many seconds to wait for initial 4-way handshake to get completed after
69 * WPS provisioning step on the GO. This controls the extra time the P2P
70 * operation is considered to be in progress (e.g., to delay other scans) after
71 * WPS provisioning has been completed on the GO during group formation.
72 */
73#define P2P_MAX_INITIAL_CONN_WAIT_GO 10
74#endif /* P2P_MAX_INITIAL_CONN_WAIT_GO */
75
bbc6c729
JM		 76#ifndef P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE
77/*
78 * How many seconds to wait for initial 4-way handshake to get completed after
79 * re-invocation of a persistent group on the GO when the client is expected
80 * to connect automatically (no user interaction).
81 */
82#define P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE 15
83#endif /* P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE */
84
2e5ba4b6
AS		 85#define P2P_MGMT_DEVICE_PREFIX "p2p-dev-"
86
8dba4aef
JM		 87enum p2p_group_removal_reason {
88 P2P_GROUP_REMOVAL_UNKNOWN,
89 P2P_GROUP_REMOVAL_SILENT,
90 P2P_GROUP_REMOVAL_FORMATION_FAILED,
91 P2P_GROUP_REMOVAL_REQUESTED,
92 P2P_GROUP_REMOVAL_IDLE_TIMEOUT,
93 P2P_GROUP_REMOVAL_UNAVAILABLE,
5bf9a6c8 94 P2P_GROUP_REMOVAL_GO_ENDING_SESSION,
8567866d
JJ		 95 P2P_GROUP_REMOVAL_PSK_FAILURE,
96 P2P_GROUP_REMOVAL_FREQ_CONFLICT
8dba4aef
JM		 97};
98
9b1ab931 99
b22128ef
JM		 100static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx);
101static struct wpa_supplicant *
102wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
103 int go);
23318bea
JM		 104static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq,
105 const u8 *ssid, size_t ssid_len);
c48414af
JM		 106static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq,
107 const u8 *ssid, size_t ssid_len);
ef922c4a 108static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx);
108def93 109static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
b31be3a0 110 const u8 *dev_addr, enum p2p_wps_method wps_method,
23318bea
JM		 111 int auto_join, int freq,
112 const u8 *ssid, size_t ssid_len);
b22128ef 113static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s);
72044390 114static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s);
3071e181
JM		 115static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx);
116static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s);
77dfafd0
JM		 117static void wpas_p2p_group_formation_timeout(void *eloop_ctx,
118 void *timeout_ctx);
8567866d 119static void wpas_p2p_group_freq_conflict(void *eloop_ctx, void *timeout_ctx);
aa9bb764
JM		 120static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
121 int group_added);
8713a2e6 122static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s);
b3253ebb 123static void wpas_stop_listen(void *ctx);
fb2ac53d 124static void wpas_p2p_psk_failure_removal(void *eloop_ctx, void *timeout_ctx);
bd10d938 125static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s);
b22128ef
JM		 126
127
0d08efa4
IP		 128/*
129 * Get the number of concurrent channels that the HW can operate, but that are
130 * currently not in use by any of the wpa_supplicant interfaces.
131 */
132static int wpas_p2p_num_unused_channels(struct wpa_supplicant *wpa_s)
133{
134 int *freqs;
217cf499 135 int num, unused;
0d08efa4
IP		 136
137 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int));
138 if (!freqs)
139 return -1;
140
141 num = get_shared_radio_freqs(wpa_s, freqs,
142 wpa_s->num_multichan_concurrent);
143 os_free(freqs);
144
217cf499
JM		 145 unused = wpa_s->num_multichan_concurrent - num;
146 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: num_unused_channels: %d", unused);
147 return unused;
0d08efa4
IP		 148}
149
150
151/*
152 * Get the frequencies that are currently in use by one or more of the virtual
153 * interfaces, and that are also valid for P2P operation.
154 */
a0c90bb0
IP		 155static unsigned int
156wpas_p2p_valid_oper_freqs(struct wpa_supplicant *wpa_s,
157 struct wpa_used_freq_data *p2p_freqs,
158 unsigned int len)
0d08efa4 159{
a0c90bb0 160 struct wpa_used_freq_data *freqs;
0d08efa4
IP		 161 unsigned int num, i, j;
162
a0c90bb0
IP		 163 freqs = os_calloc(wpa_s->num_multichan_concurrent,
164 sizeof(struct wpa_used_freq_data));
0d08efa4 165 if (!freqs)
a0c90bb0 166 return 0;
0d08efa4 167
a0c90bb0
IP		 168 num = get_shared_radio_freqs_data(wpa_s, freqs,
169 wpa_s->num_multichan_concurrent);
0d08efa4 170
a0c90bb0 171 os_memset(p2p_freqs, 0, sizeof(struct wpa_used_freq_data) * len);
0d08efa4
IP		 172
173 for (i = 0, j = 0; i < num && j < len; i++) {
a0c90bb0 174 if (p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
0d08efa4
IP		 175 p2p_freqs[j++] = freqs[i];
176 }
177
178 os_free(freqs);
179
a0c90bb0 180 dump_freq_data(wpa_s, "valid for P2P", p2p_freqs, j);
217cf499 181
0d08efa4
IP		 182 return j;
183}
184
185
6cb27aa8
JM		 186static void wpas_p2p_set_own_freq_preference(struct wpa_supplicant *wpa_s,
187 int freq)
188{
189 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
190 return;
5624ccfe
JM		 191 if (wpa_s->parent->conf->p2p_ignore_shared_freq &&
192 freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
193 wpas_p2p_num_unused_channels(wpa_s) > 0) {
21e491f2
JM		 194 wpa_printf(MSG_DEBUG, "P2P: Ignore own channel preference %d MHz due to p2p_ignore_shared_freq=1 configuration",
195 freq);
b277a2be 196 freq = 0;
21e491f2 197 }
6cb27aa8
JM		 198 p2p_set_own_freq_preference(wpa_s->global->p2p, freq);
199}
200
201
b22128ef
JM		 202static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s,
203 struct wpa_scan_results *scan_res)
204{
205 size_t i;
206
1b5d4714
JM		 207 if (wpa_s->p2p_scan_work) {
208 struct wpa_radio_work *work = wpa_s->p2p_scan_work;
209 wpa_s->p2p_scan_work = NULL;
210 radio_work_done(work);
211 }
212
9526fd29 213 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
b22128ef
JM		 214 return;
215
216 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS)",
217 (int) scan_res->num);
218
219 for (i = 0; i < scan_res->num; i++) {
220 struct wpa_scan_res *bss = scan_res->res[i];
acb69cec 221 struct os_reltime time_tmp_age, entry_ts;
aaeb9c98
JM		 222 const u8 *ies;
223 size_t ies_len;
224
c5f10e80
JM		 225 time_tmp_age.sec = bss->age / 1000;
226 time_tmp_age.usec = (bss->age % 1000) * 1000;
acb69cec 227 os_reltime_sub(&scan_res->fetch_time, &time_tmp_age, &entry_ts);
aaeb9c98
JM		 228
229 ies = (const u8 *) (bss + 1);
230 ies_len = bss->ie_len;
231 if (bss->beacon_ie_len > 0 &&
232 !wpa_scan_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) &&
233 wpa_scan_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) {
234 wpa_printf(MSG_DEBUG, "P2P: Use P2P IE(s) from Beacon frame since no P2P IE(s) in Probe Response frames received for "
235 MACSTR, MAC2STR(bss->bssid));
236 ies = ies + ies_len;
237 ies_len = bss->beacon_ie_len;
238 }
239
240
b22128ef 241 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
c5f10e80 242 bss->freq, &entry_ts, bss->level,
aaeb9c98 243 ies, ies_len) > 0)
9bcf9541 244 break;
b22128ef
JM		 245 }
246
247 p2p_scan_res_handled(wpa_s->global->p2p);
248}
249
250
1b5d4714
JM		 251static void wpas_p2p_trigger_scan_cb(struct wpa_radio_work *work, int deinit)
252{
253 struct wpa_supplicant *wpa_s = work->wpa_s;
254 struct wpa_driver_scan_params *params = work->ctx;
255 int ret;
256
257 if (deinit) {
b3253ebb
AO		 258 if (!work->started) {
259 wpa_scan_free_params(params);
260 return;
261 }
262
263 wpa_s->p2p_scan_work = NULL;
1b5d4714
JM		 264 return;
265 }
266
267 ret = wpa_drv_scan(wpa_s, params);
268 wpa_scan_free_params(params);
269 work->ctx = NULL;
270 if (ret) {
271 radio_work_done(work);
272 return;
273 }
274
275 os_get_reltime(&wpa_s->scan_trigger_time);
276 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
277 wpa_s->own_scan_requested = 1;
278 wpa_s->p2p_scan_work = work;
279}
280
281
046ef4aa
JMB		 282static int wpas_p2p_scan(void *ctx, enum p2p_scan_type type, int freq,
283 unsigned int num_req_dev_types,
360182ed 284 const u8 *req_dev_types, const u8 *dev_id, u16 pw_id)
b22128ef
JM		 285{
286 struct wpa_supplicant *wpa_s = ctx;
1b5d4714 287 struct wpa_driver_scan_params *params = NULL;
b22128ef 288 struct wpabuf *wps_ie, *ies;
206e1f42 289 size_t ielen;
1b5d4714 290 u8 *n;
b22128ef 291
9526fd29
JM		 292 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
293 return -1;
294
1b5d4714
JM		 295 if (wpa_s->p2p_scan_work) {
296 wpa_dbg(wpa_s, MSG_INFO, "P2P: Reject scan trigger since one is already pending");
297 return -1;
99fcd404
JM		 298 }
299
1b5d4714
JM		 300 params = os_zalloc(sizeof(*params));
301 if (params == NULL)
302 return -1;
b22128ef
JM		 303
304 /* P2P Wildcard SSID */
1b5d4714
JM		 305 params->num_ssids = 1;
306 n = os_malloc(P2P_WILDCARD_SSID_LEN);
307 if (n == NULL)
308 goto fail;
309 os_memcpy(n, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
310 params->ssids[0].ssid = n;
311 params->ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
b22128ef
JM		 312
313 wpa_s->wps->dev.p2p = 1;
360182ed
JM		 314 wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev,
315 wpa_s->wps->uuid, WPS_REQ_ENROLLEE,
046ef4aa 316 num_req_dev_types, req_dev_types);
b22128ef 317 if (wps_ie == NULL)
1b5d4714 318 goto fail;
b22128ef 319
206e1f42
JM		 320 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
321 ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen);
b22128ef
JM		 322 if (ies == NULL) {
323 wpabuf_free(wps_ie);
1b5d4714 324 goto fail;
b22128ef
JM		 325 }
326 wpabuf_put_buf(ies, wps_ie);
327 wpabuf_free(wps_ie);
328
6d92fa6e 329 p2p_scan_ie(wpa_s->global->p2p, ies, dev_id);
b22128ef 330
1b5d4714
JM		 331 params->p2p_probe = 1;
332 n = os_malloc(wpabuf_len(ies));
333 if (n == NULL) {
334 wpabuf_free(ies);
335 goto fail;
336 }
337 os_memcpy(n, wpabuf_head(ies), wpabuf_len(ies));
338 params->extra_ies = n;
339 params->extra_ies_len = wpabuf_len(ies);
340 wpabuf_free(ies);
b22128ef
JM		 341
342 switch (type) {
343 case P2P_SCAN_SOCIAL:
1b5d4714
JM		 344 params->freqs = os_malloc(4 * sizeof(int));
345 if (params->freqs == NULL)
346 goto fail;
347 params->freqs[0] = 2412;
348 params->freqs[1] = 2437;
349 params->freqs[2] = 2462;
350 params->freqs[3] = 0;
b22128ef
JM		 351 break;
352 case P2P_SCAN_FULL:
353 break;
b22128ef 354 case P2P_SCAN_SOCIAL_PLUS_ONE:
1b5d4714
JM		 355 params->freqs = os_malloc(5 * sizeof(int));
356 if (params->freqs == NULL)
357 goto fail;
358 params->freqs[0] = 2412;
359 params->freqs[1] = 2437;
360 params->freqs[2] = 2462;
361 params->freqs[3] = freq;
362 params->freqs[4] = 0;
b22128ef
JM		 363 break;
364 }
365
b3253ebb 366 radio_remove_works(wpa_s, "p2p-scan", 0);
1b5d4714
JM		 367 if (radio_add_work(wpa_s, 0, "p2p-scan", 0, wpas_p2p_trigger_scan_cb,
368 params) < 0)
369 goto fail;
370 return 0;
0c96fd6d 371
1b5d4714
JM		 372fail:
373 wpa_scan_free_params(params);
374 return -1;
b22128ef
JM		 375}
376
377
b22128ef
JM		 378static enum wpa_driver_if_type wpas_p2p_if_type(int p2p_group_interface)
379{
380 switch (p2p_group_interface) {
381 case P2P_GROUP_INTERFACE_PENDING:
382 return WPA_IF_P2P_GROUP;
383 case P2P_GROUP_INTERFACE_GO:
384 return WPA_IF_P2P_GO;
385 case P2P_GROUP_INTERFACE_CLIENT:
386 return WPA_IF_P2P_CLIENT;
387 }
388
389 return WPA_IF_P2P_GROUP;
390}
391
392
6c0da49f
JM		 393static struct wpa_supplicant * wpas_get_p2p_group(struct wpa_supplicant *wpa_s,
394 const u8 *ssid,
395 size_t ssid_len, int *go)
396{
397 struct wpa_ssid *s;
398
399 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
400 for (s = wpa_s->conf->ssid; s; s = s->next) {
401 if (s->disabled != 0 || !s->p2p_group ||
402 s->ssid_len != ssid_len ||
403 os_memcmp(ssid, s->ssid, ssid_len) != 0)
404 continue;
405 if (s->mode == WPAS_MODE_P2P_GO &&
406 s != wpa_s->current_ssid)
407 continue;
408 if (go)
409 *go = s->mode == WPAS_MODE_P2P_GO;
410 return wpa_s;
411 }
412 }
413
414 return NULL;
415}
416
417
8dba4aef
JM		 418static int wpas_p2p_group_delete(struct wpa_supplicant *wpa_s,
419 enum p2p_group_removal_reason removal_reason)
b22128ef
JM		 420{
421 struct wpa_ssid *ssid;
422 char *gtype;
3071e181
JM		 423 const char *reason;
424
b22128ef
JM		 425 ssid = wpa_s->current_ssid;
426 if (ssid == NULL) {
427 /*
428 * The current SSID was not known, but there may still be a
0c802384
JM		 429 * pending P2P group interface waiting for provisioning or a
430 * P2P group that is trying to reconnect.
b22128ef
JM		 431 */
432 ssid = wpa_s->conf->ssid;
433 while (ssid) {
6d22a377 434 if (ssid->p2p_group && ssid->disabled != 2)
b22128ef
JM		 435 break;
436 ssid = ssid->next;
437 }
6f1ca696
JM		 438 if (ssid == NULL &&
439 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)
440 {
30ee7692
MN		 441 wpa_printf(MSG_ERROR, "P2P: P2P group interface "
442 "not found");
443 return -1;
444 }
b22128ef
JM		 445 }
446 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
447 gtype = "GO";
448 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
449 (ssid && ssid->mode == WPAS_MODE_INFRA)) {
450 wpa_s->reassociate = 0;
451 wpa_s->disconnected = 1;
b22128ef
JM		 452 gtype = "client";
453 } else
454 gtype = "GO";
c45dabb8
EA		 455
456 if (removal_reason != P2P_GROUP_REMOVAL_SILENT && ssid)
457 wpas_notify_p2p_group_removed(wpa_s, ssid, gtype);
458
459 if (os_strcmp(gtype, "client") == 0)
460 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
461
72044390
JM		 462 if (wpa_s->cross_connect_in_use) {
463 wpa_s->cross_connect_in_use = 0;
92c4465b
JM		 464 wpa_msg_global(wpa_s->parent, MSG_INFO,
465 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
466 wpa_s->ifname, wpa_s->cross_connect_uplink);
72044390 467 }
8dba4aef 468 switch (removal_reason) {
3071e181
JM		 469 case P2P_GROUP_REMOVAL_REQUESTED:
470 reason = " reason=REQUESTED";
471 break;
8dba4aef
JM		 472 case P2P_GROUP_REMOVAL_FORMATION_FAILED:
473 reason = " reason=FORMATION_FAILED";
474 break;
3071e181
JM		 475 case P2P_GROUP_REMOVAL_IDLE_TIMEOUT:
476 reason = " reason=IDLE";
477 break;
c973f386
JM		 478 case P2P_GROUP_REMOVAL_UNAVAILABLE:
479 reason = " reason=UNAVAILABLE";
480 break;
3fc14102
JM		 481 case P2P_GROUP_REMOVAL_GO_ENDING_SESSION:
482 reason = " reason=GO_ENDING_SESSION";
483 break;
5bf9a6c8
JM		 484 case P2P_GROUP_REMOVAL_PSK_FAILURE:
485 reason = " reason=PSK_FAILURE";
486 break;
8567866d
JJ		 487 case P2P_GROUP_REMOVAL_FREQ_CONFLICT:
488 reason = " reason=FREQ_CONFLICT";
489 break;
3071e181
JM		 490 default:
491 reason = "";
492 break;
493 }
8dba4aef 494 if (removal_reason != P2P_GROUP_REMOVAL_SILENT) {
92c4465b
JM		 495 wpa_msg_global(wpa_s->parent, MSG_INFO,
496 P2P_EVENT_GROUP_REMOVED "%s %s%s",
497 wpa_s->ifname, gtype, reason);
aa9bb764 498 }
408af93e 499
8567866d
JJ		 500 if (eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL) > 0)
501 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group freq_conflict timeout");
dddc7045
JM		 502 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
503 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
77dfafd0 504 if (eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
c9c77083 505 wpa_s->parent, NULL) > 0) {
77dfafd0
JM		 506 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group formation "
507 "timeout");
c9c77083
VN		 508 wpa_s->p2p_in_provisioning = 0;
509 }
a7a30b90 510
41d5ce9e
RR		 511 wpa_s->p2p_in_invitation = 0;
512
adeb4f59
JM		 513 /*
514 * Make sure wait for the first client does not remain active after the
515 * group has been removed.
516 */
517 wpa_s->global->p2p_go_wait_client.sec = 0;
518
b22128ef
JM		 519 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
520 struct wpa_global *global;
521 char *ifname;
522 enum wpa_driver_if_type type;
523 wpa_printf(MSG_DEBUG, "P2P: Remove group interface %s",
524 wpa_s->ifname);
525 global = wpa_s->global;
526 ifname = os_strdup(wpa_s->ifname);
527 type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
df509539 528 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
b22128ef
JM		 529 wpa_s = global->ifaces;
530 if (wpa_s && ifname)
531 wpa_drv_if_remove(wpa_s, type, ifname);
532 os_free(ifname);
0aadd568 533 return 1;
b22128ef
JM		 534 }
535
acdd0fc8
DG		 536 if (!wpa_s->p2p_go_group_formation_completed) {
537 wpa_s->global->p2p_group_formation = NULL;
538 wpa_s->p2p_in_provisioning = 0;
539 }
540
c092d83e
JM		 541 wpa_s->show_group_started = 0;
542 os_free(wpa_s->go_params);
543 wpa_s->go_params = NULL;
544
c64e3a08
JM		 545 wpa_s->waiting_presence_resp = 0;
546
b22128ef
JM		 547 wpa_printf(MSG_DEBUG, "P2P: Remove temporary group network");
548 if (ssid && (ssid->p2p_group ||
549 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION ||
550 (ssid->key_mgmt & WPA_KEY_MGMT_WPS))) {
551 int id = ssid->id;
20a0b03d
JM		 552 if (ssid == wpa_s->current_ssid) {
553 wpa_sm_set_config(wpa_s->wpa, NULL);
554 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
b22128ef 555 wpa_s->current_ssid = NULL;
20a0b03d 556 }
c2762e41
JS		 557 /*
558 * Networks objects created during any P2P activities are not
559 * exposed out as they might/will confuse certain non-P2P aware
560 * applications since these network objects won't behave like
561 * regular ones.
562 *
563 * Likewise, we don't send out network removed signals for such
564 * network objects.
565 */
b22128ef
JM		 566 wpa_config_remove_network(wpa_s->conf, id);
567 wpa_supplicant_clear_status(wpa_s);
433cd2ce 568 wpa_supplicant_cancel_sched_scan(wpa_s);
b22128ef
JM		 569 } else {
570 wpa_printf(MSG_DEBUG, "P2P: Temporary group network not "
571 "found");
572 }
3c29244e
EP		 573 if (wpa_s->ap_iface)
574 wpa_supplicant_ap_deinit(wpa_s);
575 else
576 wpa_drv_deinit_p2p_cli(wpa_s);
30ee7692
MN		 577
578 return 0;
b22128ef
JM		 579}
580
581
582static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s,
583 u8 *go_dev_addr,
584 const u8 *ssid, size_t ssid_len)
585{
586 struct wpa_bss *bss;
587 const u8 *bssid;
588 struct wpabuf *p2p;
589 u8 group_capab;
590 const u8 *addr;
591
592 if (wpa_s->go_params)
593 bssid = wpa_s->go_params->peer_interface_addr;
594 else
595 bssid = wpa_s->bssid;
596
597 bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
23318bea
JM		 598 if (bss == NULL && wpa_s->go_params &&
599 !is_zero_ether_addr(wpa_s->go_params->peer_device_addr))
600 bss = wpa_bss_get_p2p_dev_addr(
601 wpa_s, wpa_s->go_params->peer_device_addr);
b22128ef
JM		 602 if (bss == NULL) {
603 u8 iface_addr[ETH_ALEN];
604 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
605 iface_addr) == 0)
606 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
607 }
608 if (bss == NULL) {
609 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
610 "group is persistent - BSS " MACSTR " not found",
611 MAC2STR(bssid));
612 return 0;
613 }
614
615 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
5df7414b
JM		 616 if (p2p == NULL)
617 p2p = wpa_bss_get_vendor_ie_multi_beacon(bss,
618 P2P_IE_VENDOR_TYPE);
b22128ef
JM		 619 if (p2p == NULL) {
620 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
621 "group is persistent - BSS " MACSTR
622 " did not include P2P IE", MAC2STR(bssid));
623 wpa_hexdump(MSG_DEBUG, "P2P: Probe Response IEs",
624 (u8 *) (bss + 1), bss->ie_len);
625 wpa_hexdump(MSG_DEBUG, "P2P: Beacon IEs",
626 ((u8 *) bss + 1) + bss->ie_len,
627 bss->beacon_ie_len);
628 return 0;
629 }
630
631 group_capab = p2p_get_group_capab(p2p);
632 addr = p2p_get_go_dev_addr(p2p);
633 wpa_printf(MSG_DEBUG, "P2P: Checking whether group is persistent: "
634 "group_capab=0x%x", group_capab);
635 if (addr) {
636 os_memcpy(go_dev_addr, addr, ETH_ALEN);
637 wpa_printf(MSG_DEBUG, "P2P: GO Device Address " MACSTR,
638 MAC2STR(addr));
639 } else
640 os_memset(go_dev_addr, 0, ETH_ALEN);
641 wpabuf_free(p2p);
642
643 wpa_printf(MSG_DEBUG, "P2P: BSS " MACSTR " group_capab=0x%x "
644 "go_dev_addr=" MACSTR,
645 MAC2STR(bssid), group_capab, MAC2STR(go_dev_addr));
646
647 return group_capab & P2P_GROUP_CAPAB_PERSISTENT_GROUP;
648}
649
650
4b6baa2f
JMB		 651static int wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s,
652 struct wpa_ssid *ssid,
653 const u8 *go_dev_addr)
b22128ef
JM		 654{
655 struct wpa_ssid *s;
656 int changed = 0;
657
658 wpa_printf(MSG_DEBUG, "P2P: Storing credentials for a persistent "
659 "group (GO Dev Addr " MACSTR ")", MAC2STR(go_dev_addr));
660 for (s = wpa_s->conf->ssid; s; s = s->next) {
661 if (s->disabled == 2 &&
662 os_memcmp(go_dev_addr, s->bssid, ETH_ALEN) == 0 &&
663 s->ssid_len == ssid->ssid_len &&
664 os_memcmp(ssid->ssid, s->ssid, ssid->ssid_len) == 0)
665 break;
666 }
667
668 if (s) {
669 wpa_printf(MSG_DEBUG, "P2P: Update existing persistent group "
670 "entry");
671 if (ssid->passphrase && !s->passphrase)
672 changed = 1;
673 else if (ssid->passphrase && s->passphrase &&
674 os_strcmp(ssid->passphrase, s->passphrase) != 0)
675 changed = 1;
676 } else {
677 wpa_printf(MSG_DEBUG, "P2P: Create a new persistent group "
678 "entry");
679 changed = 1;
680 s = wpa_config_add_network(wpa_s->conf);
681 if (s == NULL)
4b6baa2f 682 return -1;
c2762e41
JS		 683
684 /*
685 * Instead of network_added we emit persistent_group_added
686 * notification. Also to keep the defense checks in
687 * persistent_group obj registration method, we set the
688 * relevant flags in s to designate it as a persistent group.
689 */
690 s->p2p_group = 1;
691 s->p2p_persistent_group = 1;
692 wpas_notify_persistent_group_added(wpa_s, s);
b22128ef
JM		 693 wpa_config_set_network_defaults(s);
694 }
695
696 s->p2p_group = 1;
697 s->p2p_persistent_group = 1;
698 s->disabled = 2;
699 s->bssid_set = 1;
700 os_memcpy(s->bssid, go_dev_addr, ETH_ALEN);
701 s->mode = ssid->mode;
702 s->auth_alg = WPA_AUTH_ALG_OPEN;
703 s->key_mgmt = WPA_KEY_MGMT_PSK;
704 s->proto = WPA_PROTO_RSN;
705 s->pairwise_cipher = WPA_CIPHER_CCMP;
d1c8ac88 706 s->export_keys = 1;
b22128ef
JM		 707 if (ssid->passphrase) {
708 os_free(s->passphrase);
709 s->passphrase = os_strdup(ssid->passphrase);
710 }
711 if (ssid->psk_set) {
712 s->psk_set = 1;
713 os_memcpy(s->psk, ssid->psk, 32);
714 }
715 if (s->passphrase && !s->psk_set)
716 wpa_config_update_psk(s);
717 if (s->ssid == NULL || s->ssid_len < ssid->ssid_len) {
718 os_free(s->ssid);
719 s->ssid = os_malloc(ssid->ssid_len);
720 }
721 if (s->ssid) {
722 s->ssid_len = ssid->ssid_len;
723 os_memcpy(s->ssid, ssid->ssid, s->ssid_len);
724 }
01a57fe4
JM		 725 if (ssid->mode == WPAS_MODE_P2P_GO && wpa_s->global->add_psk) {
726 dl_list_add(&s->psk_list, &wpa_s->global->add_psk->list);
727 wpa_s->global->add_psk = NULL;
728 changed = 1;
729 }
b22128ef 730
b22128ef
JM		 731 if (changed && wpa_s->conf->update_config &&
732 wpa_config_write(wpa_s->confname, wpa_s->conf)) {
733 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
734 }
4b6baa2f
JMB		 735
736 return s->id;
b22128ef
JM		 737}
738
739
fbdcfd57
JM		 740static void wpas_p2p_add_persistent_group_client(struct wpa_supplicant *wpa_s,
741 const u8 *addr)
742{
743 struct wpa_ssid *ssid, *s;
744 u8 *n;
745 size_t i;
22316795 746 int found = 0;
fbdcfd57
JM		 747
748 ssid = wpa_s->current_ssid;
749 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
750 !ssid->p2p_persistent_group)
751 return;
752
753 for (s = wpa_s->parent->conf->ssid; s; s = s->next) {
754 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
755 continue;
756
757 if (s->ssid_len == ssid->ssid_len &&
758 os_memcmp(s->ssid, ssid->ssid, s->ssid_len) == 0)
759 break;
760 }
761
762 if (s == NULL)
763 return;
764
765 for (i = 0; s->p2p_client_list && i < s->num_p2p_clients; i++) {
766 if (os_memcmp(s->p2p_client_list + i * ETH_ALEN, addr,
22316795
JM		 767 ETH_ALEN) != 0)
768 continue;
769
770 if (i == s->num_p2p_clients - 1)
771 return; /* already the most recent entry */
772
773 /* move the entry to mark it most recent */
774 os_memmove(s->p2p_client_list + i * ETH_ALEN,
775 s->p2p_client_list + (i + 1) * ETH_ALEN,
776 (s->num_p2p_clients - i - 1) * ETH_ALEN);
777 os_memcpy(s->p2p_client_list +
778 (s->num_p2p_clients - 1) * ETH_ALEN, addr, ETH_ALEN);
779 found = 1;
780 break;
fbdcfd57
JM		 781 }
782
b4a5dfa9 783 if (!found && s->num_p2p_clients < P2P_MAX_STORED_CLIENTS) {
22316795
JM		 784 n = os_realloc_array(s->p2p_client_list,
785 s->num_p2p_clients + 1, ETH_ALEN);
786 if (n == NULL)
787 return;
788 os_memcpy(n + s->num_p2p_clients * ETH_ALEN, addr, ETH_ALEN);
789 s->p2p_client_list = n;
790 s->num_p2p_clients++;
8931a36c 791 } else if (!found && s->p2p_client_list) {
b4a5dfa9
JM		 792 /* Not enough room for an additional entry - drop the oldest
793 * entry */
794 os_memmove(s->p2p_client_list,
795 s->p2p_client_list + ETH_ALEN,
796 (s->num_p2p_clients - 1) * ETH_ALEN);
797 os_memcpy(s->p2p_client_list +
798 (s->num_p2p_clients - 1) * ETH_ALEN,
799 addr, ETH_ALEN);
22316795 800 }
fbdcfd57 801
fbdcfd57
JM		 802 if (wpa_s->parent->conf->update_config &&
803 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
804 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
fbdcfd57
JM		 805}
806
807
f8723e1e
JM		 808static void wpas_p2p_group_started(struct wpa_supplicant *wpa_s,
809 int go, struct wpa_ssid *ssid, int freq,
810 const u8 *psk, const char *passphrase,
811 const u8 *go_dev_addr, int persistent,
812 const char *extra)
813{
814 const char *ssid_txt;
815 char psk_txt[65];
816
817 if (psk)
818 wpa_snprintf_hex(psk_txt, sizeof(psk_txt), psk, 32);
819 else
820 psk_txt[0] = '\0';
821
822 if (ssid)
823 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
824 else
825 ssid_txt = "";
826
827 if (passphrase && passphrase[0] == '\0')
828 passphrase = NULL;
829
52f4abfd
JM		 830 /*
831 * Include PSK/passphrase only in the control interface message and
832 * leave it out from the debug log entry.
833 */
834 wpa_msg_global_ctrl(wpa_s->parent, MSG_INFO,
835 P2P_EVENT_GROUP_STARTED
836 "%s %s ssid=\"%s\" freq=%d%s%s%s%s%s go_dev_addr="
837 MACSTR "%s%s",
838 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
839 psk ? " psk=" : "", psk_txt,
840 passphrase ? " passphrase=\"" : "",
841 passphrase ? passphrase : "",
842 passphrase ? "\"" : "",
843 MAC2STR(go_dev_addr),
844 persistent ? " [PERSISTENT]" : "", extra);
845 wpa_printf(MSG_INFO, P2P_EVENT_GROUP_STARTED
846 "%s %s ssid=\"%s\" freq=%d go_dev_addr=" MACSTR "%s%s",
847 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq,
848 MAC2STR(go_dev_addr), persistent ? " [PERSISTENT]" : "",
849 extra);
f8723e1e
JM		 850}
851
852
b22128ef
JM		 853static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s,
854 int success)
855{
856 struct wpa_ssid *ssid;
b22128ef
JM		 857 int client;
858 int persistent;
859 u8 go_dev_addr[ETH_ALEN];
4b6baa2f 860 int network_id = -1;
b22128ef
JM		 861
862 /*
863 * This callback is likely called for the main interface. Update wpa_s
864 * to use the group interface if a new interface was created for the
865 * group.
866 */
867 if (wpa_s->global->p2p_group_formation)
868 wpa_s = wpa_s->global->p2p_group_formation;
41f85323
JM		 869 if (wpa_s->p2p_go_group_formation_completed) {
870 wpa_s->global->p2p_group_formation = NULL;
871 wpa_s->p2p_in_provisioning = 0;
872 }
f05cee97 873 wpa_s->p2p_in_invitation = 0;
b22128ef
JM		 874
875 if (!success) {
92c4465b
JM		 876 wpa_msg_global(wpa_s->parent, MSG_INFO,
877 P2P_EVENT_GROUP_FORMATION_FAILURE);
8dba4aef
JM		 878 wpas_p2p_group_delete(wpa_s,
879 P2P_GROUP_REMOVAL_FORMATION_FAILED);
b22128ef
JM		 880 return;
881 }
882
92c4465b
JM		 883 wpa_msg_global(wpa_s->parent, MSG_INFO,
884 P2P_EVENT_GROUP_FORMATION_SUCCESS);
b22128ef
JM		 885
886 ssid = wpa_s->current_ssid;
887 if (ssid && ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
888 ssid->mode = WPAS_MODE_P2P_GO;
889 p2p_group_notif_formation_done(wpa_s->p2p_group);
890 wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL);
891 }
892
893 persistent = 0;
894 if (ssid) {
b22128ef
JM		 895 client = ssid->mode == WPAS_MODE_INFRA;
896 if (ssid->mode == WPAS_MODE_P2P_GO) {
897 persistent = ssid->p2p_persistent_group;
d7e70476 898 os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr,
b22128ef
JM		 899 ETH_ALEN);
900 } else
901 persistent = wpas_p2p_persistent_group(wpa_s,
902 go_dev_addr,
903 ssid->ssid,
904 ssid->ssid_len);
905 } else {
b22128ef
JM		 906 client = wpa_s->p2p_group_interface ==
907 P2P_GROUP_INTERFACE_CLIENT;
62c0d27e 908 os_memset(go_dev_addr, 0, ETH_ALEN);
b22128ef
JM		 909 }
910
911 wpa_s->show_group_started = 0;
912 if (client) {
913 /*
914 * Indicate event only after successfully completed 4-way
915 * handshake, i.e., when the interface is ready for data
916 * packets.
917 */
918 wpa_s->show_group_started = 1;
b22128ef 919 } else {
f8723e1e
JM		 920 wpas_p2p_group_started(wpa_s, 1, ssid,
921 ssid ? ssid->frequency : 0,
922 ssid && ssid->passphrase == NULL &&
923 ssid->psk_set ? ssid->psk : NULL,
924 ssid ? ssid->passphrase : NULL,
925 go_dev_addr, persistent, "");
72044390 926 wpas_p2p_cross_connect_setup(wpa_s);
3071e181 927 wpas_p2p_set_group_idle_timeout(wpa_s);
b22128ef
JM		 928 }
929
930 if (persistent)
4b6baa2f
JMB		 931 network_id = wpas_p2p_store_persistent_group(wpa_s->parent,
932 ssid, go_dev_addr);
01a57fe4
JM		 933 else {
934 os_free(wpa_s->global->add_psk);
935 wpa_s->global->add_psk = NULL;
936 }
21fe9e75 937 if (network_id < 0 && ssid)
4b6baa2f 938 network_id = ssid->id;
c1c0b35f 939 if (!client) {
4b6baa2f 940 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0);
151ab808 941 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
c1c0b35f 942 }
b22128ef
JM		 943}
944
945
e05e1308
JM		 946struct send_action_work {
947 unsigned int freq;
948 u8 dst[ETH_ALEN];
949 u8 src[ETH_ALEN];
950 u8 bssid[ETH_ALEN];
951 size_t len;
952 unsigned int wait_time;
953 u8 buf[0];
954};
955
956
957static void wpas_p2p_send_action_work_timeout(void *eloop_ctx,
958 void *timeout_ctx)
959{
960 struct wpa_supplicant *wpa_s = eloop_ctx;
961
962 if (!wpa_s->p2p_send_action_work)
963 return;
964
965 wpa_printf(MSG_DEBUG, "P2P: Send Action frame radio work timed out");
966 os_free(wpa_s->p2p_send_action_work->ctx);
967 radio_work_done(wpa_s->p2p_send_action_work);
968 wpa_s->p2p_send_action_work = NULL;
969}
970
971
2fa980f0 972static void wpas_p2p_action_tx_clear(struct wpa_supplicant *wpa_s)
534525ff 973{
e05e1308
JM		 974 if (wpa_s->p2p_send_action_work) {
975 struct send_action_work *awork;
976 awork = wpa_s->p2p_send_action_work->ctx;
977 if (awork->wait_time == 0) {
978 os_free(awork);
979 radio_work_done(wpa_s->p2p_send_action_work);
980 wpa_s->p2p_send_action_work = NULL;
981 } else {
982 /*
983 * In theory, this should not be needed, but number of
984 * places in the P2P code is still using non-zero wait
985 * time for the last Action frame in the sequence and
986 * some of these do not call send_action_done().
987 */
988 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
989 wpa_s, NULL);
990 eloop_register_timeout(
991 0, awork->wait_time * 1000,
992 wpas_p2p_send_action_work_timeout,
993 wpa_s, NULL);
994 }
995 }
2fa980f0
JJ		 996}
997
998
999static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s,
1000 unsigned int freq,
1001 const u8 *dst, const u8 *src,
1002 const u8 *bssid,
1003 const u8 *data, size_t data_len,
1004 enum offchannel_send_action_result
1005 result)
1006{
1007 enum p2p_send_action_result res = P2P_SEND_ACTION_SUCCESS;
1008
1009 wpas_p2p_action_tx_clear(wpa_s);
e05e1308 1010
9526fd29 1011 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
b22128ef
JM		 1012 return;
1013
24f6497c
JM		 1014 switch (result) {
1015 case OFFCHANNEL_SEND_ACTION_SUCCESS:
1016 res = P2P_SEND_ACTION_SUCCESS;
1017 break;
1018 case OFFCHANNEL_SEND_ACTION_NO_ACK:
1019 res = P2P_SEND_ACTION_NO_ACK;
1020 break;
1021 case OFFCHANNEL_SEND_ACTION_FAILED:
1022 res = P2P_SEND_ACTION_FAILED;
1023 break;
b22128ef
JM		 1024 }
1025
24f6497c 1026 p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res);
b22128ef 1027
f63b8542
JM		 1028 if (result != OFFCHANNEL_SEND_ACTION_SUCCESS &&
1029 wpa_s->pending_pd_before_join &&
24f6497c 1030 (os_memcmp(dst, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
175171ac
JM		 1031 os_memcmp(dst, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0) &&
1032 wpa_s->p2p_fallback_to_go_neg) {
b22128ef 1033 wpa_s->pending_pd_before_join = 0;
175171ac
JM		 1034 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No ACK for PD Req "
1035 "during p2p_connect-auto");
1036 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
1037 return;
b22128ef
JM		 1038 }
1039}
1040
1041
e05e1308
JM		 1042static void wpas_send_action_cb(struct wpa_radio_work *work, int deinit)
1043{
1044 struct wpa_supplicant *wpa_s = work->wpa_s;
1045 struct send_action_work *awork = work->ctx;
1046
1047 if (deinit) {
b3253ebb
AO		 1048 if (work->started) {
1049 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
1050 wpa_s, NULL);
1051 wpa_s->p2p_send_action_work = NULL;
1052 offchannel_send_action_done(wpa_s);
1053 }
e05e1308
JM		 1054 os_free(awork);
1055 return;
1056 }
1057
1058 if (offchannel_send_action(wpa_s, awork->freq, awork->dst, awork->src,
1059 awork->bssid, awork->buf, awork->len,
1060 awork->wait_time,
1061 wpas_p2p_send_action_tx_status, 1) < 0) {
1062 os_free(awork);
1063 radio_work_done(work);
1064 return;
1065 }
1066 wpa_s->p2p_send_action_work = work;
1067}
1068
1069
1070static int wpas_send_action_work(struct wpa_supplicant *wpa_s,
1071 unsigned int freq, const u8 *dst,
1072 const u8 *src, const u8 *bssid, const u8 *buf,
1073 size_t len, unsigned int wait_time)
1074{
1075 struct send_action_work *awork;
1076
1077 if (wpa_s->p2p_send_action_work) {
1078 wpa_printf(MSG_DEBUG, "P2P: Cannot schedule new p2p-send-action work since one is already pending");
1079 return -1;
1080 }
1081
1082 awork = os_zalloc(sizeof(*awork) + len);
1083 if (awork == NULL)
1084 return -1;
1085
1086 awork->freq = freq;
1087 os_memcpy(awork->dst, dst, ETH_ALEN);
1088 os_memcpy(awork->src, src, ETH_ALEN);
1089 os_memcpy(awork->bssid, bssid, ETH_ALEN);
1090 awork->len = len;
1091 awork->wait_time = wait_time;
1092 os_memcpy(awork->buf, buf, len);
1093
1094 if (radio_add_work(wpa_s, freq, "p2p-send-action", 0,
1095 wpas_send_action_cb, awork) < 0) {
1096 os_free(awork);
1097 return -1;
1098 }
1099
1100 return 0;
1101}
1102
1103
b22128ef
JM		 1104static int wpas_send_action(void *ctx, unsigned int freq, const u8 *dst,
1105 const u8 *src, const u8 *bssid, const u8 *buf,
1106 size_t len, unsigned int wait_time)
1107{
1108 struct wpa_supplicant *wpa_s = ctx;
e05e1308
JM		 1109 int listen_freq = -1, send_freq = -1;
1110
1111 if (wpa_s->p2p_listen_work)
1112 listen_freq = wpa_s->p2p_listen_work->freq;
1113 if (wpa_s->p2p_send_action_work)
1114 send_freq = wpa_s->p2p_send_action_work->freq;
1115 if (listen_freq != (int) freq && send_freq != (int) freq) {
1116 wpa_printf(MSG_DEBUG, "P2P: Schedule new radio work for Action frame TX (listen_freq=%d send_freq=%d)",
1117 listen_freq, send_freq);
1118 return wpas_send_action_work(wpa_s, freq, dst, src, bssid, buf,
1119 len, wait_time);
1120 }
1121
1122 wpa_printf(MSG_DEBUG, "P2P: Use ongoing radio work for Action frame TX");
24f6497c
JM		 1123 return offchannel_send_action(wpa_s, freq, dst, src, bssid, buf, len,
1124 wait_time,
b106173a 1125 wpas_p2p_send_action_tx_status, 1);
b22128ef
JM		 1126}
1127
1128
1129static void wpas_send_action_done(void *ctx)
1130{
1131 struct wpa_supplicant *wpa_s = ctx;
e05e1308
JM		 1132
1133 if (wpa_s->p2p_send_action_work) {
1134 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout,
1135 wpa_s, NULL);
1136 os_free(wpa_s->p2p_send_action_work->ctx);
1137 radio_work_done(wpa_s->p2p_send_action_work);
1138 wpa_s->p2p_send_action_work = NULL;
1139 }
1140
24f6497c 1141 offchannel_send_action_done(wpa_s);
b22128ef
JM		 1142}
1143
1144
1145static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s,
1146 struct p2p_go_neg_results *params)
1147{
1148 if (wpa_s->go_params == NULL) {
1149 wpa_s->go_params = os_malloc(sizeof(*params));
1150 if (wpa_s->go_params == NULL)
1151 return -1;
1152 }
1153 os_memcpy(wpa_s->go_params, params, sizeof(*params));
1154 return 0;
1155}
1156
1157
1158static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s,
1159 struct p2p_go_neg_results *res)
1160{
23318bea 1161 wpa_printf(MSG_DEBUG, "P2P: Start WPS Enrollee for peer " MACSTR
8e9f53c3 1162 " dev_addr " MACSTR " wps_method %d",
23318bea 1163 MAC2STR(res->peer_interface_addr),
8e9f53c3 1164 MAC2STR(res->peer_device_addr), res->wps_method);
e9a7ae41
JM		 1165 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Start WPS Enrollee for SSID",
1166 res->ssid, res->ssid_len);
b22128ef
JM		 1167 wpa_supplicant_ap_deinit(wpa_s);
1168 wpas_copy_go_neg_results(wpa_s, res);
db6ae69e 1169 if (res->wps_method == WPS_PBC) {
3b29972c 1170 wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1);
db6ae69e
JM		 1171#ifdef CONFIG_WPS_NFC
1172 } else if (res->wps_method == WPS_NFC) {
23318bea
JM		 1173 wpas_wps_start_nfc(wpa_s, res->peer_device_addr,
1174 res->peer_interface_addr,
db6ae69e
JM		 1175 wpa_s->parent->p2p_oob_dev_pw,
1176 wpa_s->parent->p2p_oob_dev_pw_id, 1,
1177 wpa_s->parent->p2p_oob_dev_pw_id ==
1178 DEV_PW_NFC_CONNECTION_HANDOVER ?
1179 wpa_s->parent->p2p_peer_oob_pubkey_hash :
1180 NULL,
91a65018 1181 NULL, 0, 0);
db6ae69e
JM		 1182#endif /* CONFIG_WPS_NFC */
1183 } else {
3c5126a4
JM		 1184 u16 dev_pw_id = DEV_PW_DEFAULT;
1185 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
1186 dev_pw_id = DEV_PW_REGISTRAR_SPECIFIED;
b22128ef 1187 wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
3c5126a4
JM		 1188 wpa_s->p2p_pin, 1, dev_pw_id);
1189 }
b22128ef
JM		 1190}
1191
1192
01a57fe4
JM		 1193static void wpas_p2p_add_psk_list(struct wpa_supplicant *wpa_s,
1194 struct wpa_ssid *ssid)
1195{
1196 struct wpa_ssid *persistent;
1197 struct psk_list_entry *psk;
1198 struct hostapd_data *hapd;
1199
1200 if (!wpa_s->ap_iface)
1201 return;
1202
1203 persistent = wpas_p2p_get_persistent(wpa_s->parent, NULL, ssid->ssid,
1204 ssid->ssid_len);
1205 if (persistent == NULL)
1206 return;
1207
1208 hapd = wpa_s->ap_iface->bss[0];
1209
1210 dl_list_for_each(psk, &persistent->psk_list, struct psk_list_entry,
1211 list) {
1212 struct hostapd_wpa_psk *hpsk;
1213
1214 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add persistent group PSK entry for "
1215 MACSTR " psk=%d",
1216 MAC2STR(psk->addr), psk->p2p);
1217 hpsk = os_zalloc(sizeof(*hpsk));
1218 if (hpsk == NULL)
1219 break;
1220 os_memcpy(hpsk->psk, psk->psk, PMK_LEN);
1221 if (psk->p2p)
1222 os_memcpy(hpsk->p2p_dev_addr, psk->addr, ETH_ALEN);
1223 else
1224 os_memcpy(hpsk->addr, psk->addr, ETH_ALEN);
1225 hpsk->next = hapd->conf->ssid.wpa_psk;
1226 hapd->conf->ssid.wpa_psk = hpsk;
1227 }
1228}
1229
1230
b22128ef
JM		 1231static void p2p_go_configured(void *ctx, void *data)
1232{
1233 struct wpa_supplicant *wpa_s = ctx;
1234 struct p2p_go_neg_results *params = data;
1235 struct wpa_ssid *ssid;
4b6baa2f 1236 int network_id = -1;
b22128ef
JM		 1237
1238 ssid = wpa_s->current_ssid;
1239 if (ssid && ssid->mode == WPAS_MODE_P2P_GO) {
1240 wpa_printf(MSG_DEBUG, "P2P: Group setup without provisioning");
d1b024c9
JM		 1241 if (wpa_s->global->p2p_group_formation == wpa_s)
1242 wpa_s->global->p2p_group_formation = NULL;
f8723e1e
JM		 1243 wpas_p2p_group_started(wpa_s, 1, ssid, ssid->frequency,
1244 params->passphrase[0] == '\0' ?
1245 params->psk : NULL,
1246 params->passphrase,
1247 wpa_s->global->p2p_dev_addr,
1248 params->persistent_group, "");
4b6baa2f 1249
151ab808 1250 os_get_reltime(&wpa_s->global->p2p_go_wait_client);
01a57fe4 1251 if (params->persistent_group) {
4b6baa2f 1252 network_id = wpas_p2p_store_persistent_group(
b22128ef 1253 wpa_s->parent, ssid,
d7e70476 1254 wpa_s->global->p2p_dev_addr);
01a57fe4
JM		 1255 wpas_p2p_add_psk_list(wpa_s, ssid);
1256 }
4b6baa2f
JMB		 1257 if (network_id < 0)
1258 network_id = ssid->id;
1259 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0);
72044390 1260 wpas_p2p_cross_connect_setup(wpa_s);
3071e181 1261 wpas_p2p_set_group_idle_timeout(wpa_s);
bbc6c729
JM		 1262
1263 if (wpa_s->p2p_first_connection_timeout) {
1264 wpa_dbg(wpa_s, MSG_DEBUG,
1265 "P2P: Start group formation timeout of %d seconds until first data connection on GO",
1266 wpa_s->p2p_first_connection_timeout);
1267 wpa_s->p2p_go_group_formation_completed = 0;
1268 wpa_s->global->p2p_group_formation = wpa_s;
1269 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1270 wpa_s->parent, NULL);
1271 eloop_register_timeout(
1272 wpa_s->p2p_first_connection_timeout, 0,
1273 wpas_p2p_group_formation_timeout,
1274 wpa_s->parent, NULL);
1275 }
1276
b22128ef
JM		 1277 return;
1278 }
1279
1280 wpa_printf(MSG_DEBUG, "P2P: Setting up WPS for GO provisioning");
1281 if (wpa_supplicant_ap_mac_addr_filter(wpa_s,
1282 params->peer_interface_addr)) {
1283 wpa_printf(MSG_DEBUG, "P2P: Failed to setup MAC address "
1284 "filtering");
1285 return;
1286 }
db6ae69e 1287 if (params->wps_method == WPS_PBC) {
d601247c 1288 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr,
c3daaf33 1289 params->peer_device_addr);
db6ae69e
JM		 1290#ifdef CONFIG_WPS_NFC
1291 } else if (params->wps_method == WPS_NFC) {
1292 if (wpa_s->parent->p2p_oob_dev_pw_id !=
1293 DEV_PW_NFC_CONNECTION_HANDOVER &&
1294 !wpa_s->parent->p2p_oob_dev_pw) {
1295 wpa_printf(MSG_DEBUG, "P2P: No NFC Dev Pw known");
1296 return;
1297 }
1298 wpas_ap_wps_add_nfc_pw(
1299 wpa_s, wpa_s->parent->p2p_oob_dev_pw_id,
1300 wpa_s->parent->p2p_oob_dev_pw,
1301 wpa_s->parent->p2p_peer_oob_pk_hash_known ?
1302 wpa_s->parent->p2p_peer_oob_pubkey_hash : NULL);
1303#endif /* CONFIG_WPS_NFC */
1304 } else if (wpa_s->p2p_pin[0])
b22128ef 1305 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
c423708f 1306 wpa_s->p2p_pin, NULL, 0, 0);
b22128ef
JM		 1307 os_free(wpa_s->go_params);
1308 wpa_s->go_params = NULL;
1309}
1310
1311
1312static void wpas_start_wps_go(struct wpa_supplicant *wpa_s,
1313 struct p2p_go_neg_results *params,
1314 int group_formation)
1315{
1316 struct wpa_ssid *ssid;
1317
ac06fb12
JM		 1318 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Starting GO");
1319 if (wpas_copy_go_neg_results(wpa_s, params) < 0) {
1320 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not copy GO Negotiation "
1321 "results");
b22128ef 1322 return;
ac06fb12 1323 }
b22128ef
JM		 1324
1325 ssid = wpa_config_add_network(wpa_s->conf);
ac06fb12
JM		 1326 if (ssid == NULL) {
1327 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not add network for GO");
b22128ef 1328 return;
ac06fb12 1329 }
b22128ef 1330
a9e02d59
JM		 1331 wpa_s->show_group_started = 0;
1332
b22128ef
JM		 1333 wpa_config_set_network_defaults(ssid);
1334 ssid->temporary = 1;
1335 ssid->p2p_group = 1;
1336 ssid->p2p_persistent_group = params->persistent_group;
1337 ssid->mode = group_formation ? WPAS_MODE_P2P_GROUP_FORMATION :
1338 WPAS_MODE_P2P_GO;
1339 ssid->frequency = params->freq;
7aeac985 1340 ssid->ht40 = params->ht40;
20ea1ca4 1341 ssid->vht = params->vht;
b22128ef
JM		 1342 ssid->ssid = os_zalloc(params->ssid_len + 1);
1343 if (ssid->ssid) {
1344 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
1345 ssid->ssid_len = params->ssid_len;
1346 }
1347 ssid->auth_alg = WPA_AUTH_ALG_OPEN;
1348 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
1349 ssid->proto = WPA_PROTO_RSN;
1350 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
bb4d4deb
MH		 1351 if (os_strlen(params->passphrase) > 0) {
1352 ssid->passphrase = os_strdup(params->passphrase);
1353 if (ssid->passphrase == NULL) {
92c4465b
JM		 1354 wpa_msg_global(wpa_s, MSG_ERROR,
1355 "P2P: Failed to copy passphrase for GO");
bb4d4deb
MH		 1356 wpa_config_remove_network(wpa_s->conf, ssid->id);
1357 return;
1358 }
1359 } else
1360 ssid->passphrase = NULL;
30c371e8
MH		 1361 ssid->psk_set = params->psk_set;
1362 if (ssid->psk_set)
1363 os_memcpy(ssid->psk, params->psk, sizeof(ssid->psk));
6350a148 1364 else if (ssid->passphrase)
30c371e8 1365 wpa_config_update_psk(ssid);
462a7439 1366 ssid->ap_max_inactivity = wpa_s->parent->conf->p2p_go_max_inactivity;
b22128ef
JM		 1367
1368 wpa_s->ap_configured_cb = p2p_go_configured;
1369 wpa_s->ap_configured_cb_ctx = wpa_s;
1370 wpa_s->ap_configured_cb_data = wpa_s->go_params;
3e66f789 1371 wpa_s->scan_req = NORMAL_SCAN_REQ;
7dcdcfd6 1372 wpa_s->connect_without_scan = ssid;
b22128ef
JM		 1373 wpa_s->reassociate = 1;
1374 wpa_s->disconnected = 0;
ac06fb12
JM		 1375 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Request scan (that will be skipped) to "
1376 "start GO)");
b22128ef
JM		 1377 wpa_supplicant_req_scan(wpa_s, 0, 0);
1378}
1379
1380
1381static void wpas_p2p_clone_config(struct wpa_supplicant *dst,
1382 const struct wpa_supplicant *src)
1383{
1384 struct wpa_config *d;
1385 const struct wpa_config *s;
1386
1387 d = dst->conf;
1388 s = src->conf;
1389
1390#define C(n) if (s->n) d->n = os_strdup(s->n)
1391 C(device_name);
1392 C(manufacturer);
1393 C(model_name);
1394 C(model_number);
1395 C(serial_number);
b22128ef
JM		 1396 C(config_methods);
1397#undef C
3071e181 1398
2f646b6e
JB		 1399 os_memcpy(d->device_type, s->device_type, WPS_DEV_TYPE_LEN);
1400 os_memcpy(d->sec_device_type, s->sec_device_type,
1401 sizeof(d->sec_device_type));
1402 d->num_sec_device_types = s->num_sec_device_types;
1403
3071e181 1404 d->p2p_group_idle = s->p2p_group_idle;
b029bd33 1405 d->p2p_intra_bss = s->p2p_intra_bss;
acc247b2 1406 d->persistent_reconnect = s->persistent_reconnect;
f571b593 1407 d->max_num_sta = s->max_num_sta;
1298c145 1408 d->pbc_in_m1 = s->pbc_in_m1;
4342326f 1409 d->ignore_old_scan_res = s->ignore_old_scan_res;
41b1a76a 1410 d->beacon_int = s->beacon_int;
f62a3c2f 1411 d->dtim_period = s->dtim_period;
5046eb4e 1412 d->disassoc_low_ack = s->disassoc_low_ack;
f22f274b 1413 d->disable_scan_offload = s->disable_scan_offload;
86e32081
JM		 1414
1415 if (s->wps_nfc_dh_privkey && s->wps_nfc_dh_pubkey) {
1416 d->wps_nfc_dh_privkey = wpabuf_dup(s->wps_nfc_dh_privkey);
1417 d->wps_nfc_dh_pubkey = wpabuf_dup(s->wps_nfc_dh_pubkey);
1418 }
b22128ef
JM		 1419}
1420
1421
2e5ba4b6
AS		 1422static void wpas_p2p_get_group_ifname(struct wpa_supplicant *wpa_s,
1423 char *ifname, size_t len)
1424{
1425 char *ifname_ptr = wpa_s->ifname;
1426
1427 if (os_strncmp(wpa_s->ifname, P2P_MGMT_DEVICE_PREFIX,
1428 os_strlen(P2P_MGMT_DEVICE_PREFIX)) == 0) {
1429 ifname_ptr = os_strrchr(wpa_s->ifname, '-') + 1;
1430 }
1431
1432 os_snprintf(ifname, len, "p2p-%s-%d", ifname_ptr, wpa_s->p2p_group_idx);
1433 if (os_strlen(ifname) >= IFNAMSIZ &&
1434 os_strlen(wpa_s->ifname) < IFNAMSIZ) {
1435 /* Try to avoid going over the IFNAMSIZ length limit */
41c526f3 1436 os_snprintf(ifname, len, "p2p-%d", wpa_s->p2p_group_idx);
2e5ba4b6
AS		 1437 }
1438}
1439
1440
b22128ef
JM		 1441static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
1442 enum wpa_driver_if_type type)
1443{
1444 char ifname[120], force_ifname[120];
1445
1446 if (wpa_s->pending_interface_name[0]) {
1447 wpa_printf(MSG_DEBUG, "P2P: Pending virtual interface exists "
1448 "- skip creation of a new one");
1449 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
1450 wpa_printf(MSG_DEBUG, "P2P: Pending virtual address "
1451 "unknown?! ifname='%s'",
1452 wpa_s->pending_interface_name);
1453 return -1;
1454 }
1455 return 0;
1456 }
1457
2e5ba4b6 1458 wpas_p2p_get_group_ifname(wpa_s, ifname, sizeof(ifname));
b22128ef
JM		 1459 force_ifname[0] = '\0';
1460
1461 wpa_printf(MSG_DEBUG, "P2P: Create a new interface %s for the group",
1462 ifname);
1463 wpa_s->p2p_group_idx++;
1464
1465 wpa_s->pending_interface_type = type;
1466 if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname,
e17a2477 1467 wpa_s->pending_interface_addr, NULL) < 0) {
b22128ef
JM		 1468 wpa_printf(MSG_ERROR, "P2P: Failed to create new group "
1469 "interface");
1470 return -1;
1471 }
1472
1473 if (force_ifname[0]) {
1474 wpa_printf(MSG_DEBUG, "P2P: Driver forced interface name %s",
1475 force_ifname);
1476 os_strlcpy(wpa_s->pending_interface_name, force_ifname,
1477 sizeof(wpa_s->pending_interface_name));
1478 } else
1479 os_strlcpy(wpa_s->pending_interface_name, ifname,
1480 sizeof(wpa_s->pending_interface_name));
1481 wpa_printf(MSG_DEBUG, "P2P: Created pending virtual interface %s addr "
1482 MACSTR, wpa_s->pending_interface_name,
1483 MAC2STR(wpa_s->pending_interface_addr));
1484
1485 return 0;
1486}
1487
1488
1489static void wpas_p2p_remove_pending_group_interface(
1490 struct wpa_supplicant *wpa_s)
1491{
1492 if (!wpa_s->pending_interface_name[0] ||
1493 is_zero_ether_addr(wpa_s->pending_interface_addr))
1494 return; /* No pending virtual interface */
1495
1496 wpa_printf(MSG_DEBUG, "P2P: Removing pending group interface %s",
1497 wpa_s->pending_interface_name);
1498 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
1499 wpa_s->pending_interface_name);
1500 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
1501 wpa_s->pending_interface_name[0] = '\0';
1502}
1503
1504
1505static struct wpa_supplicant *
1506wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go)
1507{
1508 struct wpa_interface iface;
1509 struct wpa_supplicant *group_wpa_s;
1510
1511 if (!wpa_s->pending_interface_name[0]) {
1512 wpa_printf(MSG_ERROR, "P2P: No pending group interface");
d75e8806
JM		 1513 if (!wpas_p2p_create_iface(wpa_s))
1514 return NULL;
1515 /*
1516 * Something has forced us to remove the pending interface; try
1517 * to create a new one and hope for the best that we will get
1518 * the same local address.
1519 */
1520 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
1521 WPA_IF_P2P_CLIENT) < 0)
1522 return NULL;
b22128ef
JM		 1523 }
1524
1525 os_memset(&iface, 0, sizeof(iface));
1526 iface.ifname = wpa_s->pending_interface_name;
1527 iface.driver = wpa_s->driver->name;
78f79fe5
JM		 1528 if (wpa_s->conf->ctrl_interface == NULL &&
1529 wpa_s->parent != wpa_s &&
1530 wpa_s->p2p_mgmt &&
1531 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE))
1532 iface.ctrl_interface = wpa_s->parent->conf->ctrl_interface;
1533 else
1534 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
b22128ef
JM		 1535 iface.driver_param = wpa_s->conf->driver_param;
1536 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
1537 if (group_wpa_s == NULL) {
1538 wpa_printf(MSG_ERROR, "P2P: Failed to create new "
1539 "wpa_supplicant interface");
1540 return NULL;
1541 }
1542 wpa_s->pending_interface_name[0] = '\0';
1543 group_wpa_s->parent = wpa_s;
1544 group_wpa_s->p2p_group_interface = go ? P2P_GROUP_INTERFACE_GO :
1545 P2P_GROUP_INTERFACE_CLIENT;
1546 wpa_s->global->p2p_group_formation = group_wpa_s;
1547
1548 wpas_p2p_clone_config(group_wpa_s, wpa_s);
1549
1550 return group_wpa_s;
1551}
1552
1553
1554static void wpas_p2p_group_formation_timeout(void *eloop_ctx,
1555 void *timeout_ctx)
1556{
1557 struct wpa_supplicant *wpa_s = eloop_ctx;
1558 wpa_printf(MSG_DEBUG, "P2P: Group Formation timed out");
1075b295
JM		 1559 wpas_p2p_group_formation_failed(wpa_s);
1560}
1561
1562
1563void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s)
1564{
1565 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1566 wpa_s->parent, NULL);
b22128ef
JM		 1567 if (wpa_s->global->p2p)
1568 p2p_group_formation_failed(wpa_s->global->p2p);
1569 wpas_group_formation_completed(wpa_s, 0);
1570}
1571
1572
95fb2db2
JM		 1573static void wpas_p2p_grpform_fail_after_wps(struct wpa_supplicant *wpa_s)
1574{
1575 wpa_printf(MSG_DEBUG, "P2P: Reject group formation due to WPS provisioning failure");
1576 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1577 wpa_s->parent, NULL);
1578 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
1579 wpa_s->parent, NULL);
1580 wpa_s->global->p2p_fail_on_wps_complete = 0;
1581}
1582
1583
b2b688d1
VKE		 1584void wpas_p2p_ap_setup_failed(struct wpa_supplicant *wpa_s)
1585{
1586 if (wpa_s->global->p2p_group_formation != wpa_s)
1587 return;
1588 /* Speed up group formation timeout since this cannot succeed */
1589 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
1590 wpa_s->parent, NULL);
1591 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
1592 wpa_s->parent, NULL);
1593}
1594
1595
152cff6b 1596static void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
b22128ef
JM		 1597{
1598 struct wpa_supplicant *wpa_s = ctx;
1599
8eada5ca 1600 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
b22128ef
JM		 1601 wpa_drv_cancel_remain_on_channel(wpa_s);
1602 wpa_s->off_channel_freq = 0;
07a30a66 1603 wpa_s->roc_waiting_drv_freq = 0;
b22128ef
JM		 1604 }
1605
1606 if (res->status) {
92c4465b
JM		 1607 wpa_msg_global(wpa_s, MSG_INFO,
1608 P2P_EVENT_GO_NEG_FAILURE "status=%d",
1609 res->status);
e5a359cf 1610 wpas_notify_p2p_go_neg_completed(wpa_s, res);
b22128ef
JM		 1611 wpas_p2p_remove_pending_group_interface(wpa_s);
1612 return;
1613 }
1614
e2308e4b
RM		 1615 if (wpa_s->p2p_go_ht40)
1616 res->ht40 = 1;
20ea1ca4
EP		 1617 if (wpa_s->p2p_go_vht)
1618 res->vht = 1;
e2308e4b 1619
8d660e04
JM		 1620 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS "role=%s "
1621 "freq=%d ht40=%d peer_dev=" MACSTR " peer_iface=" MACSTR
1622 " wps_method=%s",
1623 res->role_go ? "GO" : "client", res->freq, res->ht40,
1624 MAC2STR(res->peer_device_addr),
1625 MAC2STR(res->peer_interface_addr),
1626 p2p_wps_method_text(res->wps_method));
e5a359cf 1627 wpas_notify_p2p_go_neg_completed(wpa_s, res);
b22128ef 1628
23c84252
JM		 1629 if (res->role_go && wpa_s->p2p_persistent_id >= 0) {
1630 struct wpa_ssid *ssid;
1631 ssid = wpa_config_get_network(wpa_s->conf,
1632 wpa_s->p2p_persistent_id);
1633 if (ssid && ssid->disabled == 2 &&
1634 ssid->mode == WPAS_MODE_P2P_GO && ssid->passphrase) {
1635 size_t len = os_strlen(ssid->passphrase);
1636 wpa_printf(MSG_DEBUG, "P2P: Override passphrase based "
1637 "on requested persistent group");
1638 os_memcpy(res->passphrase, ssid->passphrase, len);
1639 res->passphrase[len] = '\0';
1640 }
1641 }
1642
b22128ef
JM		 1643 if (wpa_s->create_p2p_iface) {
1644 struct wpa_supplicant *group_wpa_s =
1645 wpas_p2p_init_group_interface(wpa_s, res->role_go);
1646 if (group_wpa_s == NULL) {
1647 wpas_p2p_remove_pending_group_interface(wpa_s);
5eae87a7
EA		 1648 eloop_cancel_timeout(wpas_p2p_long_listen_timeout,
1649 wpa_s, NULL);
1650 wpas_p2p_group_formation_failed(wpa_s);
b22128ef
JM		 1651 return;
1652 }
3c5126a4 1653 if (group_wpa_s != wpa_s) {
b22128ef
JM		 1654 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
1655 sizeof(group_wpa_s->p2p_pin));
3c5126a4
JM		 1656 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
1657 }
b22128ef
JM		 1658 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
1659 wpa_s->pending_interface_name[0] = '\0';
1660 group_wpa_s->p2p_in_provisioning = 1;
1661
1662 if (res->role_go)
1663 wpas_start_wps_go(group_wpa_s, res, 1);
1664 else
1665 wpas_start_wps_enrollee(group_wpa_s, res);
1666 } else {
1667 wpa_s->p2p_in_provisioning = 1;
1668 wpa_s->global->p2p_group_formation = wpa_s;
1669
1670 if (res->role_go)
1671 wpas_start_wps_go(wpa_s, res, 1);
1672 else
1673 wpas_start_wps_enrollee(ctx, res);
1674 }
1675
1676 wpa_s->p2p_long_listen = 0;
1677 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
1678
1679 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
ae3e3421
JM		 1680 eloop_register_timeout(15 + res->peer_config_timeout / 100,
1681 (res->peer_config_timeout % 100) * 10000,
1682 wpas_p2p_group_formation_timeout, wpa_s, NULL);
b22128ef
JM		 1683}
1684
1685
152cff6b 1686static void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id)
b22128ef
JM		 1687{
1688 struct wpa_supplicant *wpa_s = ctx;
92c4465b
JM		 1689 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR
1690 " dev_passwd_id=%u", MAC2STR(src), dev_passwd_id);
32d1bce0
KRK		 1691
1692 wpas_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id);
b22128ef
JM		 1693}
1694
1695
152cff6b
JM		 1696static void wpas_dev_found(void *ctx, const u8 *addr,
1697 const struct p2p_peer_info *info,
1698 int new_device)
b22128ef 1699{
5506d184 1700#ifndef CONFIG_NO_STDOUT_DEBUG
b22128ef
JM		 1701 struct wpa_supplicant *wpa_s = ctx;
1702 char devtype[WPS_DEV_TYPE_BUFSIZE];
b125c48f
DS		 1703 char *wfd_dev_info_hex = NULL;
1704
1705#ifdef CONFIG_WIFI_DISPLAY
1706 wfd_dev_info_hex = wifi_display_subelem_hex(info->wfd_subelems,
1707 WFD_SUBELEM_DEVICE_INFO);
1708#endif /* CONFIG_WIFI_DISPLAY */
c5db8e51 1709
92c4465b
JM		 1710 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
1711 " p2p_dev_addr=" MACSTR
1712 " pri_dev_type=%s name='%s' config_methods=0x%x "
71a0e395 1713 "dev_capab=0x%x group_capab=0x%x%s%s%s",
92c4465b
JM		 1714 MAC2STR(addr), MAC2STR(info->p2p_device_addr),
1715 wps_dev_type_bin2str(info->pri_dev_type, devtype,
1716 sizeof(devtype)),
b125c48f
DS		 1717 info->device_name, info->config_methods,
1718 info->dev_capab, info->group_capab,
1719 wfd_dev_info_hex ? " wfd_dev_info=0x" : "",
71a0e395
JM		 1720 wfd_dev_info_hex ? wfd_dev_info_hex : "",
1721 info->vendor_elems ? " vendor_elems=1" : "");
d642d2d2 1722
b125c48f 1723 os_free(wfd_dev_info_hex);
1b56d398 1724#endif /* CONFIG_NO_STDOUT_DEBUG */
b125c48f 1725
d642d2d2 1726 wpas_notify_p2p_device_found(ctx, info->p2p_device_addr, new_device);
b22128ef
JM		 1727}
1728
1729
56eeb8f2
JB		 1730static void wpas_dev_lost(void *ctx, const u8 *dev_addr)
1731{
1732 struct wpa_supplicant *wpa_s = ctx;
1733
92c4465b
JM		 1734 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_LOST
1735 "p2p_dev_addr=" MACSTR, MAC2STR(dev_addr));
3074d8f1 1736
56eeb8f2
JB		 1737 wpas_notify_p2p_device_lost(wpa_s, dev_addr);
1738}
1739
1740
710ae9ac
JM		 1741static void wpas_find_stopped(void *ctx)
1742{
1743 struct wpa_supplicant *wpa_s = ctx;
92c4465b 1744 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_FIND_STOPPED);
710ae9ac
JM		 1745}
1746
1747
e1d1c8e2
JM		 1748struct wpas_p2p_listen_work {
1749 unsigned int freq;
1750 unsigned int duration;
1751 struct wpabuf *probe_resp_ie;
1752};
1753
1754
1755static void wpas_p2p_listen_work_free(struct wpas_p2p_listen_work *lwork)
b22128ef 1756{
e1d1c8e2
JM		 1757 if (lwork == NULL)
1758 return;
1759 wpabuf_free(lwork->probe_resp_ie);
1760 os_free(lwork);
1761}
1762
1763
1764static void wpas_p2p_listen_work_done(struct wpa_supplicant *wpa_s)
1765{
1766 struct wpas_p2p_listen_work *lwork;
1767
1768 if (!wpa_s->p2p_listen_work)
1769 return;
1770
1771 lwork = wpa_s->p2p_listen_work->ctx;
1772 wpas_p2p_listen_work_free(lwork);
1773 radio_work_done(wpa_s->p2p_listen_work);
1774 wpa_s->p2p_listen_work = NULL;
1775}
1776
1777
1778static void wpas_start_listen_cb(struct wpa_radio_work *work, int deinit)
1779{
1780 struct wpa_supplicant *wpa_s = work->wpa_s;
1781 struct wpas_p2p_listen_work *lwork = work->ctx;
1782
1783 if (deinit) {
b3253ebb
AO		 1784 if (work->started) {
1785 wpa_s->p2p_listen_work = NULL;
1786 wpas_stop_listen(wpa_s);
1787 }
e1d1c8e2
JM		 1788 wpas_p2p_listen_work_free(lwork);
1789 return;
1790 }
b22128ef 1791
e1d1c8e2
JM		 1792 wpa_s->p2p_listen_work = work;
1793
1794 wpa_drv_set_ap_wps_ie(wpa_s, NULL, lwork->probe_resp_ie, NULL);
b22128ef
JM		 1795
1796 if (wpa_drv_probe_req_report(wpa_s, 1) < 0) {
1797 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver to "
1798 "report received Probe Request frames");
e1d1c8e2
JM		 1799 wpas_p2p_listen_work_done(wpa_s);
1800 return;
b22128ef
JM		 1801 }
1802
e1d1c8e2
JM		 1803 wpa_s->pending_listen_freq = lwork->freq;
1804 wpa_s->pending_listen_duration = lwork->duration;
b22128ef 1805
e1d1c8e2
JM		 1806 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq, lwork->duration) < 0)
1807 {
b22128ef
JM		 1808 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver "
1809 "to remain on channel (%u MHz) for Listen "
e1d1c8e2
JM		 1810 "state", lwork->freq);
1811 wpas_p2p_listen_work_done(wpa_s);
b22128ef 1812 wpa_s->pending_listen_freq = 0;
e1d1c8e2 1813 return;
b22128ef 1814 }
09d660b9 1815 wpa_s->off_channel_freq = 0;
e1d1c8e2
JM		 1816 wpa_s->roc_waiting_drv_freq = lwork->freq;
1817}
1818
1819
1820static int wpas_start_listen(void *ctx, unsigned int freq,
1821 unsigned int duration,
1822 const struct wpabuf *probe_resp_ie)
1823{
1824 struct wpa_supplicant *wpa_s = ctx;
1825 struct wpas_p2p_listen_work *lwork;
1826
1827 if (wpa_s->p2p_listen_work) {
1828 wpa_printf(MSG_DEBUG, "P2P: Reject start_listen since p2p_listen_work already exists");
1829 return -1;
1830 }
1831
1832 lwork = os_zalloc(sizeof(*lwork));
1833 if (lwork == NULL)
1834 return -1;
1835 lwork->freq = freq;
1836 lwork->duration = duration;
1837 if (probe_resp_ie) {
1838 lwork->probe_resp_ie = wpabuf_dup(probe_resp_ie);
1839 if (lwork->probe_resp_ie == NULL) {
1840 wpas_p2p_listen_work_free(lwork);
1841 return -1;
1842 }
1843 }
1844
1845 if (radio_add_work(wpa_s, freq, "p2p-listen", 0, wpas_start_listen_cb,
1846 lwork) < 0) {
1847 wpas_p2p_listen_work_free(lwork);
1848 return -1;
1849 }
b22128ef
JM		 1850
1851 return 0;
1852}
1853
1854
1855static void wpas_stop_listen(void *ctx)
1856{
1857 struct wpa_supplicant *wpa_s = ctx;
6cb22d2f 1858 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
b22128ef
JM		 1859 wpa_drv_cancel_remain_on_channel(wpa_s);
1860 wpa_s->off_channel_freq = 0;
07a30a66 1861 wpa_s->roc_waiting_drv_freq = 0;
b22128ef 1862 }
839b33ad 1863 wpa_drv_set_ap_wps_ie(wpa_s, NULL, NULL, NULL);
b22128ef 1864 wpa_drv_probe_req_report(wpa_s, 0);
e1d1c8e2 1865 wpas_p2p_listen_work_done(wpa_s);
b22128ef
JM		 1866}
1867
1868
1869static int wpas_send_probe_resp(void *ctx, const struct wpabuf *buf)
1870{
1871 struct wpa_supplicant *wpa_s = ctx;
9dbf53fe 1872 return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf), 1);
b22128ef
JM		 1873}
1874
1875
8c9ad085
JM		 1876/*
1877 * DNS Header section is used only to calculate compression pointers, so the
1878 * contents of this data does not matter, but the length needs to be reserved
1879 * in the virtual packet.
1880 */
1881#define DNS_HEADER_LEN 12
1882
1883/*
1884 * 27-octet in-memory packet from P2P specification containing two implied
1885 * queries for _tcp.lcoal. PTR IN and _udp.local. PTR IN
1886 */
1887#define P2P_SD_IN_MEMORY_LEN 27
1888
1889static int p2p_sd_dns_uncompress_label(char **upos, char *uend, u8 *start,
1890 u8 **spos, const u8 *end)
1891{
1892 while (*spos < end) {
1893 u8 val = ((*spos)[0] & 0xc0) >> 6;
1894 int len;
1895
1896 if (val == 1 || val == 2) {
1897 /* These are reserved values in RFC 1035 */
1898 wpa_printf(MSG_DEBUG, "P2P: Invalid domain name "
1899 "sequence starting with 0x%x", val);
1900 return -1;
1901 }
1902
1903 if (val == 3) {
1904 u16 offset;
1905 u8 *spos_tmp;
1906
1907 /* Offset */
1908 if (*spos + 2 > end) {
1909 wpa_printf(MSG_DEBUG, "P2P: No room for full "
1910 "DNS offset field");
1911 return -1;
1912 }
1913
1914 offset = (((*spos)[0] & 0x3f) << 8) | (*spos)[1];
1915 if (offset >= *spos - start) {
1916 wpa_printf(MSG_DEBUG, "P2P: Invalid DNS "
1917 "pointer offset %u", offset);
1918 return -1;
1919 }
1920
1921 (*spos) += 2;
1922 spos_tmp = start + offset;
1923 return p2p_sd_dns_uncompress_label(upos, uend, start,
1924 &spos_tmp,
1925 *spos - 2);
1926 }
1927
1928 /* Label */
1929 len = (*spos)[0] & 0x3f;
1930 if (len == 0)
1931 return 0;
1932
1933 (*spos)++;
1934 if (*spos + len > end) {
1935 wpa_printf(MSG_DEBUG, "P2P: Invalid domain name "
1936 "sequence - no room for label with length "
1937 "%u", len);
1938 return -1;
1939 }
1940
1941 if (*upos + len + 2 > uend)
1942 return -2;
1943
1944 os_memcpy(*upos, *spos, len);
1945 *spos += len;
1946 *upos += len;
1947 (*upos)[0] = '.';
1948 (*upos)++;
1949 (*upos)[0] = '\0';
1950 }
1951
1952 return 0;
1953}
1954
1955
1956/* Uncompress domain names per RFC 1035 using the P2P SD in-memory packet.
1957 * Returns -1 on parsing error (invalid input sequence), -2 if output buffer is
1958 * not large enough */
1959static int p2p_sd_dns_uncompress(char *buf, size_t buf_len, const u8 *msg,
1960 size_t msg_len, size_t offset)
1961{
1962 /* 27-octet in-memory packet from P2P specification */
1963 const char *prefix = "\x04_tcp\x05local\x00\x00\x0C\x00\x01"
1964 "\x04_udp\xC0\x11\x00\x0C\x00\x01";
1965 u8 *tmp, *end, *spos;
1966 char *upos, *uend;
1967 int ret = 0;
1968
1969 if (buf_len < 2)
1970 return -1;
1971 if (offset > msg_len)
1972 return -1;
1973
1974 tmp = os_malloc(DNS_HEADER_LEN + P2P_SD_IN_MEMORY_LEN + msg_len);
1975 if (tmp == NULL)
1976 return -1;
1977 spos = tmp + DNS_HEADER_LEN + P2P_SD_IN_MEMORY_LEN;
1978 end = spos + msg_len;
1979 spos += offset;
1980
1981 os_memset(tmp, 0, DNS_HEADER_LEN);
1982 os_memcpy(tmp + DNS_HEADER_LEN, prefix, P2P_SD_IN_MEMORY_LEN);
1983 os_memcpy(tmp + DNS_HEADER_LEN + P2P_SD_IN_MEMORY_LEN, msg, msg_len);
1984
1985 upos = buf;
1986 uend = buf + buf_len;
1987
1988 ret = p2p_sd_dns_uncompress_label(&upos, uend, tmp, &spos, end);
1989 if (ret) {
1990 os_free(tmp);
1991 return ret;
1992 }
1993
1994 if (upos == buf) {
1995 upos[0] = '.';
1996 upos[1] = '\0';
1997 } else if (upos[-1] == '.')
1998 upos[-1] = '\0';
1999
2000 os_free(tmp);
2001 return 0;
2002}
2003
2004
b22128ef
JM		 2005static struct p2p_srv_bonjour *
2006wpas_p2p_service_get_bonjour(struct wpa_supplicant *wpa_s,
2007 const struct wpabuf *query)
2008{
2009 struct p2p_srv_bonjour *bsrv;
2010 size_t len;
2011
2012 len = wpabuf_len(query);
2013 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
2014 struct p2p_srv_bonjour, list) {
2015 if (len == wpabuf_len(bsrv->query) &&
2016 os_memcmp(wpabuf_head(query), wpabuf_head(bsrv->query),
2017 len) == 0)
2018 return bsrv;
2019 }
2020 return NULL;
2021}
2022
2023
2024static struct p2p_srv_upnp *
2025wpas_p2p_service_get_upnp(struct wpa_supplicant *wpa_s, u8 version,
2026 const char *service)
2027{
2028 struct p2p_srv_upnp *usrv;
2029
2030 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
2031 struct p2p_srv_upnp, list) {
2032 if (version == usrv->version &&
2033 os_strcmp(service, usrv->service) == 0)
2034 return usrv;
2035 }
2036 return NULL;
2037}
2038
2039
2040static void wpas_sd_add_proto_not_avail(struct wpabuf *resp, u8 srv_proto,
2041 u8 srv_trans_id)
2042{
2043 u8 *len_pos;
2044
2045 if (wpabuf_tailroom(resp) < 5)
2046 return;
2047
2048 /* Length (to be filled) */
2049 len_pos = wpabuf_put(resp, 2);
2050 wpabuf_put_u8(resp, srv_proto);
2051 wpabuf_put_u8(resp, srv_trans_id);
2052 /* Status Code */
2053 wpabuf_put_u8(resp, P2P_SD_PROTO_NOT_AVAILABLE);
2054 /* Response Data: empty */
2055 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
2056}
2057
2058
2059static void wpas_sd_all_bonjour(struct wpa_supplicant *wpa_s,
2060 struct wpabuf *resp, u8 srv_trans_id)
2061{
2062 struct p2p_srv_bonjour *bsrv;
2063 u8 *len_pos;
2064
2065 wpa_printf(MSG_DEBUG, "P2P: SD Request for all Bonjour services");
2066
2067 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
2068 wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available");
2069 return;
2070 }
2071
2072 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
2073 struct p2p_srv_bonjour, list) {
2074 if (wpabuf_tailroom(resp) <
2075 5 + wpabuf_len(bsrv->query) + wpabuf_len(bsrv->resp))
2076 return;
2077 /* Length (to be filled) */
2078 len_pos = wpabuf_put(resp, 2);
2079 wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
2080 wpabuf_put_u8(resp, srv_trans_id);
2081 /* Status Code */
2082 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
2083 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service",
2084 wpabuf_head(bsrv->resp),
2085 wpabuf_len(bsrv->resp));
2086 /* Response Data */
2087 wpabuf_put_buf(resp, bsrv->query); /* Key */
2088 wpabuf_put_buf(resp, bsrv->resp); /* Value */
2089 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
2090 2);
2091 }
2092}
2093
2094
8c9ad085
JM		 2095static int match_bonjour_query(struct p2p_srv_bonjour *bsrv, const u8 *query,
2096 size_t query_len)
2097{
2098 char str_rx[256], str_srv[256];
2099
2100 if (query_len < 3 || wpabuf_len(bsrv->query) < 3)
2101 return 0; /* Too short to include DNS Type and Version */
2102 if (os_memcmp(query + query_len - 3,
2103 wpabuf_head_u8(bsrv->query) + wpabuf_len(bsrv->query) - 3,
2104 3) != 0)
2105 return 0; /* Mismatch in DNS Type or Version */
2106 if (query_len == wpabuf_len(bsrv->query) &&
2107 os_memcmp(query, wpabuf_head(bsrv->query), query_len - 3) == 0)
2108 return 1; /* Binary match */
2109
2110 if (p2p_sd_dns_uncompress(str_rx, sizeof(str_rx), query, query_len - 3,
2111 0))
2112 return 0; /* Failed to uncompress query */
2113 if (p2p_sd_dns_uncompress(str_srv, sizeof(str_srv),
2114 wpabuf_head(bsrv->query),
2115 wpabuf_len(bsrv->query) - 3, 0))
2116 return 0; /* Failed to uncompress service */
2117
2118 return os_strcmp(str_rx, str_srv) == 0;
2119}
2120
2121
b22128ef
JM		 2122static void wpas_sd_req_bonjour(struct wpa_supplicant *wpa_s,
2123 struct wpabuf *resp, u8 srv_trans_id,
2124 const u8 *query, size_t query_len)
2125{
2126 struct p2p_srv_bonjour *bsrv;
b22128ef 2127 u8 *len_pos;
560f8bda 2128 int matches = 0;
b22128ef
JM		 2129
2130 wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for Bonjour",
2131 query, query_len);
2132 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
2133 wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available");
2134 wpas_sd_add_proto_not_avail(resp, P2P_SERV_BONJOUR,
2135 srv_trans_id);
2136 return;
2137 }
2138
2139 if (query_len == 0) {
2140 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
2141 return;
2142 }
2143
560f8bda
JM		 2144 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
2145 struct p2p_srv_bonjour, list) {
8c9ad085 2146 if (!match_bonjour_query(bsrv, query, query_len))
560f8bda
JM		 2147 continue;
2148
2149 if (wpabuf_tailroom(resp) <
2150 5 + query_len + wpabuf_len(bsrv->resp))
2151 return;
2152
2153 matches++;
b22128ef 2154
560f8bda
JM		 2155 /* Length (to be filled) */
2156 len_pos = wpabuf_put(resp, 2);
2157 wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
2158 wpabuf_put_u8(resp, srv_trans_id);
2159
2160 /* Status Code */
2161 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
2162 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service",
2163 wpabuf_head(bsrv->resp),
2164 wpabuf_len(bsrv->resp));
2165
2166 /* Response Data */
2167 wpabuf_put_data(resp, query, query_len); /* Key */
2168 wpabuf_put_buf(resp, bsrv->resp); /* Value */
2169
2170 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
2171 }
2172
2173 if (matches == 0) {
b22128ef
JM		 2174 wpa_printf(MSG_DEBUG, "P2P: Requested Bonjour service not "
2175 "available");
560f8bda
JM		 2176 if (wpabuf_tailroom(resp) < 5)
2177 return;
2178
2179 /* Length (to be filled) */
2180 len_pos = wpabuf_put(resp, 2);
2181 wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
2182 wpabuf_put_u8(resp, srv_trans_id);
b22128ef
JM		 2183
2184 /* Status Code */
bf608cad 2185 wpabuf_put_u8(resp, P2P_SD_REQUESTED_INFO_NOT_AVAILABLE);
b22128ef
JM		 2186 /* Response Data: empty */
2187 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
2188 2);
b22128ef 2189 }
b22128ef
JM		 2190}
2191
2192
2193static void wpas_sd_all_upnp(struct wpa_supplicant *wpa_s,
2194 struct wpabuf *resp, u8 srv_trans_id)
2195{
2196 struct p2p_srv_upnp *usrv;
2197 u8 *len_pos;
2198
2199 wpa_printf(MSG_DEBUG, "P2P: SD Request for all UPnP services");
2200
2201 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
2202 wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available");
2203 return;
2204 }
2205
2206 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
2207 struct p2p_srv_upnp, list) {
2208 if (wpabuf_tailroom(resp) < 5 + 1 + os_strlen(usrv->service))
2209 return;
2210
2211 /* Length (to be filled) */
2212 len_pos = wpabuf_put(resp, 2);
2213 wpabuf_put_u8(resp, P2P_SERV_UPNP);
2214 wpabuf_put_u8(resp, srv_trans_id);
2215
2216 /* Status Code */
2217 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
2218 /* Response Data */
2219 wpabuf_put_u8(resp, usrv->version);
2220 wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s",
2221 usrv->service);
2222 wpabuf_put_str(resp, usrv->service);
2223 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
2224 2);
2225 }
2226}
2227
2228
2229static void wpas_sd_req_upnp(struct wpa_supplicant *wpa_s,
2230 struct wpabuf *resp, u8 srv_trans_id,
2231 const u8 *query, size_t query_len)
2232{
2233 struct p2p_srv_upnp *usrv;
2234 u8 *len_pos;
2235 u8 version;
2236 char *str;
2237 int count = 0;
2238
2239 wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for UPnP",
2240 query, query_len);
2241
2242 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
2243 wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available");
2244 wpas_sd_add_proto_not_avail(resp, P2P_SERV_UPNP,
2245 srv_trans_id);
2246 return;
2247 }
2248
2249 if (query_len == 0) {
2250 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
2251 return;
2252 }
2253
b22128ef
JM		 2254 if (wpabuf_tailroom(resp) < 5)
2255 return;
2256
2257 /* Length (to be filled) */
2258 len_pos = wpabuf_put(resp, 2);
2259 wpabuf_put_u8(resp, P2P_SERV_UPNP);
2260 wpabuf_put_u8(resp, srv_trans_id);
2261
79222cfa
JM		 2262 version = query[0];
2263 str = os_malloc(query_len);
2264 if (str == NULL)
2265 return;
2266 os_memcpy(str, query + 1, query_len - 1);
2267 str[query_len - 1] = '\0';
2268
b22128ef
JM		 2269 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
2270 struct p2p_srv_upnp, list) {
2271 if (version != usrv->version)
2272 continue;
2273
2274 if (os_strcmp(str, "ssdp:all") != 0 &&
2275 os_strstr(usrv->service, str) == NULL)
2276 continue;
2277
2278 if (wpabuf_tailroom(resp) < 2)
2279 break;
2280 if (count == 0) {
2281 /* Status Code */
2282 wpabuf_put_u8(resp, P2P_SD_SUCCESS);
2283 /* Response Data */
2284 wpabuf_put_u8(resp, version);
2285 } else
2286 wpabuf_put_u8(resp, ',');
2287
2288 count++;
2289
2290 wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s",
2291 usrv->service);
2292 if (wpabuf_tailroom(resp) < os_strlen(usrv->service))
2293 break;
2294 wpabuf_put_str(resp, usrv->service);
2295 }
714b8b53 2296 os_free(str);
b22128ef
JM		 2297
2298 if (count == 0) {
2299 wpa_printf(MSG_DEBUG, "P2P: Requested UPnP service not "
2300 "available");
2301 /* Status Code */
bf608cad 2302 wpabuf_put_u8(resp, P2P_SD_REQUESTED_INFO_NOT_AVAILABLE);
b22128ef
JM		 2303 /* Response Data: empty */
2304 }
2305
2306 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
2307}
2308
2309
6ffdc2f7
JM		 2310#ifdef CONFIG_WIFI_DISPLAY
2311static void wpas_sd_req_wfd(struct wpa_supplicant *wpa_s,
2312 struct wpabuf *resp, u8 srv_trans_id,
2313 const u8 *query, size_t query_len)
2314{
2315 const u8 *pos;
2316 u8 role;
2317 u8 *len_pos;
2318
2319 wpa_hexdump(MSG_DEBUG, "P2P: SD Request for WFD", query, query_len);
2320
2321 if (!wpa_s->global->wifi_display) {
2322 wpa_printf(MSG_DEBUG, "P2P: WFD protocol not available");
2323 wpas_sd_add_proto_not_avail(resp, P2P_SERV_WIFI_DISPLAY,
2324 srv_trans_id);
2325 return;
2326 }
2327
2328 if (query_len < 1) {
2329 wpa_printf(MSG_DEBUG, "P2P: Missing WFD Requested Device "
2330 "Role");
2331 return;
2332 }
2333
2334 if (wpabuf_tailroom(resp) < 5)
2335 return;
2336
2337 pos = query;
2338 role = *pos++;
2339 wpa_printf(MSG_DEBUG, "P2P: WSD for device role 0x%x", role);
2340
2341 /* TODO: role specific handling */
2342
2343 /* Length (to be filled) */
2344 len_pos = wpabuf_put(resp, 2);
2345 wpabuf_put_u8(resp, P2P_SERV_WIFI_DISPLAY);
2346 wpabuf_put_u8(resp, srv_trans_id);
2347 wpabuf_put_u8(resp, P2P_SD_SUCCESS); /* Status Code */
2348
2349 while (pos < query + query_len) {
2350 if (*pos < MAX_WFD_SUBELEMS &&
2351 wpa_s->global->wfd_subelem[*pos] &&
2352 wpabuf_tailroom(resp) >=
2353 wpabuf_len(wpa_s->global->wfd_subelem[*pos])) {
2354 wpa_printf(MSG_DEBUG, "P2P: Add WSD response "
2355 "subelement %u", *pos);
2356 wpabuf_put_buf(resp, wpa_s->global->wfd_subelem[*pos]);
2357 }
2358 pos++;
2359 }
2360
2361 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
2362}
2363#endif /* CONFIG_WIFI_DISPLAY */
2364
2365
152cff6b
JM		 2366static void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token,
2367 u16 update_indic, const u8 *tlvs, size_t tlvs_len)
b22128ef
JM		 2368{
2369 struct wpa_supplicant *wpa_s = ctx;
2370 const u8 *pos = tlvs;
2371 const u8 *end = tlvs + tlvs_len;
2372 const u8 *tlv_end;
2373 u16 slen;
2374 struct wpabuf *resp;
2375 u8 srv_proto, srv_trans_id;
2376 size_t buf_len;
2377 char *buf;
2378
2379 wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Request TLVs",
2380 tlvs, tlvs_len);
2381 buf_len = 2 * tlvs_len + 1;
2382 buf = os_malloc(buf_len);
2383 if (buf) {
2384 wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len);
2385 wpa_msg_ctrl(wpa_s, MSG_INFO, P2P_EVENT_SERV_DISC_REQ "%d "
2386 MACSTR " %u %u %s",
2387 freq, MAC2STR(sa), dialog_token, update_indic,
2388 buf);
2389 os_free(buf);
2390 }
2391
3b655312 2392 if (wpa_s->p2p_sd_over_ctrl_iface) {
2393 wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token,
2394 update_indic, tlvs, tlvs_len);
b22128ef 2395 return; /* to be processed by an external program */
3b655312 2396 }
b22128ef
JM		 2397
2398 resp = wpabuf_alloc(10000);
2399 if (resp == NULL)
2400 return;
2401
2402 while (pos + 1 < end) {
2403 wpa_printf(MSG_DEBUG, "P2P: Service Request TLV");
2404 slen = WPA_GET_LE16(pos);
2405 pos += 2;
2406 if (pos + slen > end || slen < 2) {
2407 wpa_printf(MSG_DEBUG, "P2P: Unexpected Query Data "
2408 "length");
2409 wpabuf_free(resp);
2410 return;
2411 }
2412 tlv_end = pos + slen;
2413
2414 srv_proto = *pos++;
2415 wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u",
2416 srv_proto);
2417 srv_trans_id = *pos++;
2418 wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u",
2419 srv_trans_id);
2420
2421 wpa_hexdump(MSG_MSGDUMP, "P2P: Query Data",
2422 pos, tlv_end - pos);
2423
6e6963ea
JM		 2424
2425 if (wpa_s->force_long_sd) {
2426 wpa_printf(MSG_DEBUG, "P2P: SD test - force long "
2427 "response");
2428 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
2429 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
2430 goto done;
2431 }
2432
b22128ef
JM		 2433 switch (srv_proto) {
2434 case P2P_SERV_ALL_SERVICES:
2435 wpa_printf(MSG_DEBUG, "P2P: Service Discovery Request "
2436 "for all services");
2437 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp) &&
2438 dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
2439 wpa_printf(MSG_DEBUG, "P2P: No service "
2440 "discovery protocols available");
2441 wpas_sd_add_proto_not_avail(
2442 resp, P2P_SERV_ALL_SERVICES,
2443 srv_trans_id);
2444 break;
2445 }
2446 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
2447 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
2448 break;
2449 case P2P_SERV_BONJOUR:
2450 wpas_sd_req_bonjour(wpa_s, resp, srv_trans_id,
2451 pos, tlv_end - pos);
2452 break;
2453 case P2P_SERV_UPNP:
2454 wpas_sd_req_upnp(wpa_s, resp, srv_trans_id,
2455 pos, tlv_end - pos);
2456 break;
6ffdc2f7
JM		 2457#ifdef CONFIG_WIFI_DISPLAY
2458 case P2P_SERV_WIFI_DISPLAY:
2459 wpas_sd_req_wfd(wpa_s, resp, srv_trans_id,
2460 pos, tlv_end - pos);
2461 break;
2462#endif /* CONFIG_WIFI_DISPLAY */
b22128ef
JM		 2463 default:
2464 wpa_printf(MSG_DEBUG, "P2P: Unavailable service "
2465 "protocol %u", srv_proto);
2466 wpas_sd_add_proto_not_avail(resp, srv_proto,
2467 srv_trans_id);
2468 break;
2469 }
2470
2471 pos = tlv_end;
2472 }
2473
6e6963ea 2474done:
e1653cac
KRK		 2475 wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token,
2476 update_indic, tlvs, tlvs_len);
2477
b22128ef
JM		 2478 wpas_p2p_sd_response(wpa_s, freq, sa, dialog_token, resp);
2479
2480 wpabuf_free(resp);
2481}
2482
2483
152cff6b
JM		 2484static void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic,
2485 const u8 *tlvs, size_t tlvs_len)
b22128ef
JM		 2486{
2487 struct wpa_supplicant *wpa_s = ctx;
2488 const u8 *pos = tlvs;
2489 const u8 *end = tlvs + tlvs_len;
2490 const u8 *tlv_end;
2491 u16 slen;
2492 size_t buf_len;
2493 char *buf;
2494
2495 wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Response TLVs",
2496 tlvs, tlvs_len);
18708aad
JM		 2497 if (tlvs_len > 1500) {
2498 /* TODO: better way for handling this */
2499 wpa_msg_ctrl(wpa_s, MSG_INFO,
2500 P2P_EVENT_SERV_DISC_RESP MACSTR
2501 " %u <long response: %u bytes>",
2502 MAC2STR(sa), update_indic,
2503 (unsigned int) tlvs_len);
2504 } else {
2505 buf_len = 2 * tlvs_len + 1;
2506 buf = os_malloc(buf_len);
2507 if (buf) {
2508 wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len);
2509 wpa_msg_ctrl(wpa_s, MSG_INFO,
2510 P2P_EVENT_SERV_DISC_RESP MACSTR " %u %s",
2511 MAC2STR(sa), update_indic, buf);
2512 os_free(buf);
2513 }
b22128ef
JM		 2514 }
2515
2516 while (pos < end) {
2517 u8 srv_proto, srv_trans_id, status;
2518
2519 wpa_printf(MSG_DEBUG, "P2P: Service Response TLV");
2520 slen = WPA_GET_LE16(pos);
2521 pos += 2;
2522 if (pos + slen > end || slen < 3) {
2523 wpa_printf(MSG_DEBUG, "P2P: Unexpected Response Data "
2524 "length");
2525 return;
2526 }
2527 tlv_end = pos + slen;
2528
2529 srv_proto = *pos++;
2530 wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u",
2531 srv_proto);
2532 srv_trans_id = *pos++;
2533 wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u",
2534 srv_trans_id);
2535 status = *pos++;
2536 wpa_printf(MSG_DEBUG, "P2P: Status Code ID %u",
2537 status);
2538
2539 wpa_hexdump(MSG_MSGDUMP, "P2P: Response Data",
2540 pos, tlv_end - pos);
2541
2542 pos = tlv_end;
2543 }
43a26f60
KRK		 2544
2545 wpas_notify_p2p_sd_response(wpa_s, sa, update_indic, tlvs, tlvs_len);
b22128ef
JM		 2546}
2547
2548
7165c5dc
JM		 2549u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
2550 const struct wpabuf *tlvs)
b22128ef 2551{
9526fd29 2552 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7165c5dc
JM		 2553 return 0;
2554 return (uintptr_t) p2p_sd_request(wpa_s->global->p2p, dst, tlvs);
b22128ef
JM		 2555}
2556
2557
7165c5dc
JM		 2558u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst,
2559 u8 version, const char *query)
b22128ef
JM		 2560{
2561 struct wpabuf *tlvs;
7165c5dc 2562 u64 ret;
b22128ef
JM		 2563
2564 tlvs = wpabuf_alloc(2 + 1 + 1 + 1 + os_strlen(query));
2565 if (tlvs == NULL)
7165c5dc 2566 return 0;
b22128ef
JM		 2567 wpabuf_put_le16(tlvs, 1 + 1 + 1 + os_strlen(query));
2568 wpabuf_put_u8(tlvs, P2P_SERV_UPNP); /* Service Protocol Type */
2569 wpabuf_put_u8(tlvs, 1); /* Service Transaction ID */
2570 wpabuf_put_u8(tlvs, version);
2571 wpabuf_put_str(tlvs, query);
2572 ret = wpas_p2p_sd_request(wpa_s, dst, tlvs);
2573 wpabuf_free(tlvs);
2574 return ret;
2575}
2576
2577
347d6a5b
JM		 2578#ifdef CONFIG_WIFI_DISPLAY
2579
2580static u64 wpas_p2p_sd_request_wfd(struct wpa_supplicant *wpa_s, const u8 *dst,
2581 const struct wpabuf *tlvs)
2582{
347d6a5b
JM		 2583 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2584 return 0;
2585 return (uintptr_t) p2p_sd_request_wfd(wpa_s->global->p2p, dst, tlvs);
2586}
2587
2588
2589#define MAX_WFD_SD_SUBELEMS 20
2590
2591static void wfd_add_sd_req_role(struct wpabuf *tlvs, u8 id, u8 role,
2592 const char *subelems)
2593{
2594 u8 *len;
2595 const char *pos;
2596 int val;
2597 int count = 0;
2598
2599 len = wpabuf_put(tlvs, 2);
2600 wpabuf_put_u8(tlvs, P2P_SERV_WIFI_DISPLAY); /* Service Protocol Type */
2601 wpabuf_put_u8(tlvs, id); /* Service Transaction ID */
2602
2603 wpabuf_put_u8(tlvs, role);
2604
2605 pos = subelems;
2606 while (*pos) {
2607 val = atoi(pos);
2608 if (val >= 0 && val < 256) {
2609 wpabuf_put_u8(tlvs, val);
2610 count++;
2611 if (count == MAX_WFD_SD_SUBELEMS)
2612 break;
2613 }
2614 pos = os_strchr(pos + 1, ',');
2615 if (pos == NULL)
2616 break;
2617 pos++;
2618 }
2619
2620 WPA_PUT_LE16(len, (u8 *) wpabuf_put(tlvs, 0) - len - 2);
2621}
2622
2623
2624u64 wpas_p2p_sd_request_wifi_display(struct wpa_supplicant *wpa_s,
2625 const u8 *dst, const char *role)
2626{
2627 struct wpabuf *tlvs;
2628 u64 ret;
2629 const char *subelems;
2630 u8 id = 1;
2631
2632 subelems = os_strchr(role, ' ');
2633 if (subelems == NULL)
2634 return 0;
2635 subelems++;
2636
2637 tlvs = wpabuf_alloc(4 * (2 + 1 + 1 + 1 + MAX_WFD_SD_SUBELEMS));
2638 if (tlvs == NULL)
2639 return 0;
2640
2641 if (os_strstr(role, "[source]"))
2642 wfd_add_sd_req_role(tlvs, id++, 0x00, subelems);
2643 if (os_strstr(role, "[pri-sink]"))
2644 wfd_add_sd_req_role(tlvs, id++, 0x01, subelems);
2645 if (os_strstr(role, "[sec-sink]"))
2646 wfd_add_sd_req_role(tlvs, id++, 0x02, subelems);
2647 if (os_strstr(role, "[source+sink]"))
2648 wfd_add_sd_req_role(tlvs, id++, 0x03, subelems);
2649
2650 ret = wpas_p2p_sd_request_wfd(wpa_s, dst, tlvs);
2651 wpabuf_free(tlvs);
2652 return ret;
2653}
2654
2655#endif /* CONFIG_WIFI_DISPLAY */
2656
2657
7165c5dc 2658int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, u64 req)
b22128ef 2659{
9526fd29
JM		 2660 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2661 return -1;
7165c5dc
JM		 2662 return p2p_sd_cancel_request(wpa_s->global->p2p,
2663 (void *) (uintptr_t) req);
b22128ef
JM		 2664}
2665
2666
2667void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq,
2668 const u8 *dst, u8 dialog_token,
2669 const struct wpabuf *resp_tlvs)
2670{
9526fd29
JM		 2671 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
2672 return;
b22128ef
JM		 2673 p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token,
2674 resp_tlvs);
2675}
2676
2677
2678void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s)
2679{
9526fd29
JM		 2680 if (wpa_s->global->p2p)
2681 p2p_sd_service_update(wpa_s->global->p2p);
b22128ef
JM		 2682}
2683
2684
2685static void wpas_p2p_srv_bonjour_free(struct p2p_srv_bonjour *bsrv)
2686{
2687 dl_list_del(&bsrv->list);
2688 wpabuf_free(bsrv->query);
2689 wpabuf_free(bsrv->resp);
2690 os_free(bsrv);
2691}
2692
2693
2694static void wpas_p2p_srv_upnp_free(struct p2p_srv_upnp *usrv)
2695{
2696 dl_list_del(&usrv->list);
2697 os_free(usrv->service);
2698 os_free(usrv);
2699}
2700
2701
2702void wpas_p2p_service_flush(struct wpa_supplicant *wpa_s)
2703{
2704 struct p2p_srv_bonjour *bsrv, *bn;
2705 struct p2p_srv_upnp *usrv, *un;
2706
2707 dl_list_for_each_safe(bsrv, bn, &wpa_s->global->p2p_srv_bonjour,
2708 struct p2p_srv_bonjour, list)
2709 wpas_p2p_srv_bonjour_free(bsrv);
2710
2711 dl_list_for_each_safe(usrv, un, &wpa_s->global->p2p_srv_upnp,
2712 struct p2p_srv_upnp, list)
2713 wpas_p2p_srv_upnp_free(usrv);
2714
2715 wpas_p2p_sd_service_update(wpa_s);
2716}
2717
2718
2719int wpas_p2p_service_add_bonjour(struct wpa_supplicant *wpa_s,
2720 struct wpabuf *query, struct wpabuf *resp)
2721{
2722 struct p2p_srv_bonjour *bsrv;
2723
b22128ef
JM		 2724 bsrv = os_zalloc(sizeof(*bsrv));
2725 if (bsrv == NULL)
2726 return -1;
2727 bsrv->query = query;
2728 bsrv->resp = resp;
2729 dl_list_add(&wpa_s->global->p2p_srv_bonjour, &bsrv->list);
2730
2731 wpas_p2p_sd_service_update(wpa_s);
2732 return 0;
2733}
2734
2735
2736int wpas_p2p_service_del_bonjour(struct wpa_supplicant *wpa_s,
2737 const struct wpabuf *query)
2738{
2739 struct p2p_srv_bonjour *bsrv;
2740
2741 bsrv = wpas_p2p_service_get_bonjour(wpa_s, query);
2742 if (bsrv == NULL)
2743 return -1;
2744 wpas_p2p_srv_bonjour_free(bsrv);
2745 wpas_p2p_sd_service_update(wpa_s);
2746 return 0;
2747}
2748
2749
2750int wpas_p2p_service_add_upnp(struct wpa_supplicant *wpa_s, u8 version,
2751 const char *service)
2752{
2753 struct p2p_srv_upnp *usrv;
2754
2755 if (wpas_p2p_service_get_upnp(wpa_s, version, service))
2756 return 0; /* Already listed */
2757 usrv = os_zalloc(sizeof(*usrv));
2758 if (usrv == NULL)
2759 return -1;
2760 usrv->version = version;
2761 usrv->service = os_strdup(service);
2762 if (usrv->service == NULL) {
2763 os_free(usrv);
2764 return -1;
2765 }
2766 dl_list_add(&wpa_s->global->p2p_srv_upnp, &usrv->list);
2767
2768 wpas_p2p_sd_service_update(wpa_s);
2769 return 0;
2770}
2771
2772
2773int wpas_p2p_service_del_upnp(struct wpa_supplicant *wpa_s, u8 version,
2774 const char *service)
2775{
2776 struct p2p_srv_upnp *usrv;
2777
2778 usrv = wpas_p2p_service_get_upnp(wpa_s, version, service);
2779 if (usrv == NULL)
2780 return -1;
2781 wpas_p2p_srv_upnp_free(usrv);
2782 wpas_p2p_sd_service_update(wpa_s);
2783 return 0;
2784}
2785
2786
2787static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s,
bbeee9b0
JB		 2788 const u8 *peer, const char *params,
2789 unsigned int generated_pin)
b22128ef 2790{
92c4465b
JM		 2791 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR
2792 " %08d%s", MAC2STR(peer), generated_pin, params);
b22128ef
JM		 2793}
2794
2795
2796static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
2797 const u8 *peer, const char *params)
2798{
92c4465b
JM		 2799 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR
2800 "%s", MAC2STR(peer), params);
b22128ef
JM		 2801}
2802
2803
152cff6b
JM		 2804static void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
2805 const u8 *dev_addr, const u8 *pri_dev_type,
2806 const char *dev_name, u16 supp_config_methods,
2807 u8 dev_capab, u8 group_capab, const u8 *group_id,
2808 size_t group_id_len)
b22128ef
JM		 2809{
2810 struct wpa_supplicant *wpa_s = ctx;
2811 char devtype[WPS_DEV_TYPE_BUFSIZE];
c3f42784 2812 char params[300];
b22128ef 2813 u8 empty_dev_type[8];
bbeee9b0 2814 unsigned int generated_pin = 0;
c3f42784
JM		 2815 struct wpa_supplicant *group = NULL;
2816
2817 if (group_id) {
2818 for (group = wpa_s->global->ifaces; group; group = group->next)
2819 {
2820 struct wpa_ssid *s = group->current_ssid;
2821 if (s != NULL &&
2822 s->mode == WPAS_MODE_P2P_GO &&
2823 group_id_len - ETH_ALEN == s->ssid_len &&
2824 os_memcmp(group_id + ETH_ALEN, s->ssid,
2825 s->ssid_len) == 0)
2826 break;
2827 }
2828 }
b22128ef
JM		 2829
2830 if (pri_dev_type == NULL) {
2831 os_memset(empty_dev_type, 0, sizeof(empty_dev_type));
2832 pri_dev_type = empty_dev_type;
2833 }
2834 os_snprintf(params, sizeof(params), " p2p_dev_addr=" MACSTR
2835 " pri_dev_type=%s name='%s' config_methods=0x%x "
c3f42784 2836 "dev_capab=0x%x group_capab=0x%x%s%s",
b22128ef
JM		 2837 MAC2STR(dev_addr),
2838 wps_dev_type_bin2str(pri_dev_type, devtype,
2839 sizeof(devtype)),
c3f42784
JM		 2840 dev_name, supp_config_methods, dev_capab, group_capab,
2841 group ? " group=" : "",
2842 group ? group->ifname : "");
b22128ef
JM		 2843 params[sizeof(params) - 1] = '\0';
2844
bbeee9b0
JB		 2845 if (config_methods & WPS_CONFIG_DISPLAY) {
2846 generated_pin = wps_generate_pin();
2847 wpas_prov_disc_local_display(wpa_s, peer, params,
2848 generated_pin);
2849 } else if (config_methods & WPS_CONFIG_KEYPAD)
b22128ef
JM		 2850 wpas_prov_disc_local_keypad(wpa_s, peer, params);
2851 else if (config_methods & WPS_CONFIG_PUSHBUTTON)
92c4465b
JM		 2852 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ
2853 MACSTR "%s", MAC2STR(peer), params);
dd8a7e05
JB		 2854
2855 wpas_notify_p2p_provision_discovery(wpa_s, peer, 1 /* request */,
2856 P2P_PROV_DISC_SUCCESS,
2857 config_methods, generated_pin);
b22128ef
JM		 2858}
2859
2860
152cff6b 2861static void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods)
b22128ef
JM		 2862{
2863 struct wpa_supplicant *wpa_s = ctx;
bbeee9b0 2864 unsigned int generated_pin = 0;
0918c4bf 2865 char params[20];
bbeee9b0 2866
c1931635
JM		 2867 if (wpa_s->pending_pd_before_join &&
2868 (os_memcmp(peer, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
2869 os_memcmp(peer, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) {
2870 wpa_s->pending_pd_before_join = 0;
2871 wpa_printf(MSG_DEBUG, "P2P: Starting pending "
2872 "join-existing-group operation");
23318bea 2873 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
c1931635
JM		 2874 return;
2875 }
2876
0918c4bf
JM		 2877 if (wpa_s->pending_pd_use == AUTO_PD_JOIN ||
2878 wpa_s->pending_pd_use == AUTO_PD_GO_NEG)
2879 os_snprintf(params, sizeof(params), " peer_go=%d",
2880 wpa_s->pending_pd_use == AUTO_PD_JOIN);
2881 else
2882 params[0] = '\0';
2883
b22128ef 2884 if (config_methods & WPS_CONFIG_DISPLAY)
0918c4bf 2885 wpas_prov_disc_local_keypad(wpa_s, peer, params);
bbeee9b0
JB		 2886 else if (config_methods & WPS_CONFIG_KEYPAD) {
2887 generated_pin = wps_generate_pin();
0918c4bf
JM		 2888 wpas_prov_disc_local_display(wpa_s, peer, params,
2889 generated_pin);
bbeee9b0 2890 } else if (config_methods & WPS_CONFIG_PUSHBUTTON)
92c4465b
JM		 2891 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP
2892 MACSTR "%s", MAC2STR(peer), params);
a482883f 2893
dd8a7e05
JB		 2894 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
2895 P2P_PROV_DISC_SUCCESS,
2896 config_methods, generated_pin);
b22128ef
JM		 2897}
2898
2899
19df9b07
JM		 2900static void wpas_prov_disc_fail(void *ctx, const u8 *peer,
2901 enum p2p_prov_disc_status status)
dd8a7e05
JB		 2902{
2903 struct wpa_supplicant *wpa_s = ctx;
2904
aa9bb764
JM		 2905 if (wpa_s->p2p_fallback_to_go_neg) {
2906 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto "
2907 "failed - fall back to GO Negotiation");
2908 wpas_p2p_fallback_to_go_neg(wpa_s, 0);
2909 return;
2910 }
2911
175171ac
JM		 2912 if (status == P2P_PROV_DISC_TIMEOUT_JOIN) {
2913 wpa_s->pending_pd_before_join = 0;
2914 wpa_printf(MSG_DEBUG, "P2P: Starting pending "
2915 "join-existing-group operation (no ACK for PD "
2916 "Req attempts)");
23318bea 2917 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
175171ac
JM		 2918 return;
2919 }
2920
92c4465b
JM		 2921 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
2922 " p2p_dev_addr=" MACSTR " status=%d",
2923 MAC2STR(peer), status);
f65a239b 2924
dd8a7e05
JB		 2925 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
2926 status, 0, 0);
2927}
2928
2929
72728c6f
SL		 2930static int freq_included(const struct p2p_channels *channels, unsigned int freq)
2931{
2932 if (channels == NULL)
2933 return 1; /* Assume no restrictions */
2934 return p2p_channels_includes_freq(channels, freq);
2935
2936}
2937
2938
a0c90bb0
IP		 2939/**
2940 * Pick the best frequency to use from all the currently used frequencies.
2941 */
2942static int wpas_p2p_pick_best_used_freq(struct wpa_supplicant *wpa_s,
2943 struct wpa_used_freq_data *freqs,
2944 unsigned int num)
2945{
2946 unsigned int i, c;
2947
2948 /* find a candidate freq that is supported by P2P */
2949 for (c = 0; c < num; c++)
2950 if (p2p_supported_freq(wpa_s->global->p2p, freqs[c].freq))
2951 break;
2952
2953 if (c == num)
2954 return 0;
2955
2956 /* once we have a candidate, try to find a 'better' one */
2957 for (i = c + 1; i < num; i++) {
2958 if (!p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq))
2959 continue;
2960
2961 /*
2962 * 1. Infrastructure station interfaces have higher preference.
2963 * 2. P2P Clients have higher preference.
2964 * 3. All others.
2965 */
2966 if (freqs[i].flags & WPA_FREQ_USED_BY_INFRA_STATION) {
2967 c = i;
2968 break;
2969 }
2970
2971 if ((freqs[i].flags & WPA_FREQ_USED_BY_P2P_CLIENT))
2972 c = i;
2973 }
2974 return freqs[c].freq;
2975}
2976
2977
b22128ef
JM		 2978static u8 wpas_invitation_process(void *ctx, const u8 *sa, const u8 *bssid,
2979 const u8 *go_dev_addr, const u8 *ssid,
2980 size_t ssid_len, int *go, u8 *group_bssid,
72728c6f 2981 int *force_freq, int persistent_group,
8e9f53c3
JM		 2982 const struct p2p_channels *channels,
2983 int dev_pw_id)
b22128ef
JM		 2984{
2985 struct wpa_supplicant *wpa_s = ctx;
2986 struct wpa_ssid *s;
a0c90bb0 2987 struct wpa_used_freq_data *freqs;
ab72eb52 2988 struct wpa_supplicant *grp;
a0c90bb0 2989 int best_freq;
b22128ef
JM		 2990
2991 if (!persistent_group) {
2992 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
c48414af
JM		 2993 " to join an active group (SSID: %s)",
2994 MAC2STR(sa), wpa_ssid_txt(ssid, ssid_len));
108def93 2995 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
131cb37c
JM		 2996 (os_memcmp(go_dev_addr, wpa_s->p2p_auth_invite, ETH_ALEN)
2997 == 0 ||
2998 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0)) {
108def93
JM		 2999 wpa_printf(MSG_DEBUG, "P2P: Accept previously "
3000 "authorized invitation");
3001 goto accept_inv;
3002 }
8e9f53c3
JM		 3003
3004#ifdef CONFIG_WPS_NFC
3005 if (dev_pw_id >= 0 && wpa_s->parent->p2p_nfc_tag_enabled &&
3006 dev_pw_id == wpa_s->parent->p2p_oob_dev_pw_id) {
3007 wpa_printf(MSG_DEBUG, "P2P: Accept invitation based on local enabled NFC Tag");
3008 wpa_s->parent->p2p_wps_method = WPS_NFC;
3009 wpa_s->parent->pending_join_wps_method = WPS_NFC;
3010 os_memcpy(wpa_s->parent->pending_join_dev_addr,
3011 go_dev_addr, ETH_ALEN);
3012 os_memcpy(wpa_s->parent->pending_join_iface_addr,
3013 bssid, ETH_ALEN);
3014 goto accept_inv;
3015 }
3016#endif /* CONFIG_WPS_NFC */
3017
b22128ef
JM		 3018 /*
3019 * Do not accept the invitation automatically; notify user and
3020 * request approval.
3021 */
3022 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
3023 }
3024
ab72eb52
JM		 3025 grp = wpas_get_p2p_group(wpa_s, ssid, ssid_len, go);
3026 if (grp) {
3027 wpa_printf(MSG_DEBUG, "P2P: Accept invitation to already "
3028 "running persistent group");
3029 if (*go)
3030 os_memcpy(group_bssid, grp->own_addr, ETH_ALEN);
3031 goto accept_inv;
3032 }
3033
77e4e853
JM		 3034 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
3035 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0) {
3036 wpa_printf(MSG_DEBUG, "P2P: Accept previously initiated "
3037 "invitation to re-invoke a persistent group");
829a1b32 3038 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
77e4e853 3039 } else if (!wpa_s->conf->persistent_reconnect)
b22128ef
JM		 3040 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
3041
3042 for (s = wpa_s->conf->ssid; s; s = s->next) {
3043 if (s->disabled == 2 &&
3044 os_memcmp(s->bssid, go_dev_addr, ETH_ALEN) == 0 &&
3045 s->ssid_len == ssid_len &&
3046 os_memcmp(ssid, s->ssid, ssid_len) == 0)
3047 break;
3048 }
3049
3050 if (!s) {
3051 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
3052 " requested reinvocation of an unknown group",
3053 MAC2STR(sa));
3054 return P2P_SC_FAIL_UNKNOWN_GROUP;
3055 }
3056
3057 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
3058 *go = 1;
3059 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
3060 wpa_printf(MSG_DEBUG, "P2P: The only available "
3061 "interface is already in use - reject "
3062 "invitation");
3063 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
3064 }
3065 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
3066 } else if (s->mode == WPAS_MODE_P2P_GO) {
3067 *go = 1;
3068 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0)
3069 {
3070 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
3071 "interface address for the group");
3072 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
3073 }
3074 os_memcpy(group_bssid, wpa_s->pending_interface_addr,
3075 ETH_ALEN);
3076 }
3077
108def93 3078accept_inv:
6cb27aa8
JM		 3079 wpas_p2p_set_own_freq_preference(wpa_s, 0);
3080
a0c90bb0
IP		 3081 best_freq = 0;
3082 freqs = os_calloc(wpa_s->num_multichan_concurrent,
3083 sizeof(struct wpa_used_freq_data));
3084 if (freqs) {
3085 int num_channels = wpa_s->num_multichan_concurrent;
3086 int num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, num_channels);
3087 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
3088 os_free(freqs);
3089 }
3090
0d08efa4 3091 /* Get one of the frequencies currently in use */
a0c90bb0 3092 if (best_freq > 0) {
21e491f2 3093 wpa_printf(MSG_DEBUG, "P2P: Trying to prefer a channel already used by one of the interfaces");
a0c90bb0 3094 wpas_p2p_set_own_freq_preference(wpa_s, best_freq);
21e491f2
JM		 3095
3096 if (wpa_s->num_multichan_concurrent < 2 ||
3097 wpas_p2p_num_unused_channels(wpa_s) < 1) {
3098 wpa_printf(MSG_DEBUG, "P2P: No extra channels available - trying to force channel to match a channel already used by one of the interfaces");
a0c90bb0 3099 *force_freq = best_freq;
21e491f2 3100 }
b22128ef
JM		 3101 }
3102
0d08efa4
IP		 3103 if (*force_freq > 0 && wpa_s->num_multichan_concurrent > 1 &&
3104 wpas_p2p_num_unused_channels(wpa_s) > 0) {
72728c6f
SL		 3105 if (*go == 0) {
3106 /* We are the client */
3107 wpa_printf(MSG_DEBUG, "P2P: Peer was found to be "
3108 "running a GO but we are capable of MCC, "
3109 "figure out the best channel to use");
3110 *force_freq = 0;
3111 } else if (!freq_included(channels, *force_freq)) {
3112 /* We are the GO, and *force_freq is not in the
3113 * intersection */
3114 wpa_printf(MSG_DEBUG, "P2P: Forced GO freq %d MHz not "
3115 "in intersection but we are capable of MCC, "
3116 "figure out the best channel to use",
3117 *force_freq);
3118 *force_freq = 0;
3119 }
3120 }
3121
b22128ef
JM		 3122 return P2P_SC_SUCCESS;
3123}
3124
3125
3126static void wpas_invitation_received(void *ctx, const u8 *sa, const u8 *bssid,
3127 const u8 *ssid, size_t ssid_len,
3128 const u8 *go_dev_addr, u8 status,
3129 int op_freq)
3130{
3131 struct wpa_supplicant *wpa_s = ctx;
3132 struct wpa_ssid *s;
3133
3134 for (s = wpa_s->conf->ssid; s; s = s->next) {
3135 if (s->disabled == 2 &&
3136 s->ssid_len == ssid_len &&
3137 os_memcmp(ssid, s->ssid, ssid_len) == 0)
3138 break;
3139 }
3140
3141 if (status == P2P_SC_SUCCESS) {
3142 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
c48414af
JM		 3143 " was accepted; op_freq=%d MHz, SSID=%s",
3144 MAC2STR(sa), op_freq, wpa_ssid_txt(ssid, ssid_len));
b22128ef 3145 if (s) {
2cd07584 3146 int go = s->mode == WPAS_MODE_P2P_GO;
b22128ef 3147 wpas_p2p_group_add_persistent(
41d5ce9e 3148 wpa_s, s, go, 0, op_freq, 0, 0, NULL,
bbc6c729 3149 go ? P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE : 0);
2049af2b 3150 } else if (bssid) {
67527166 3151 wpa_s->user_initiated_pd = 0;
108def93 3152 wpas_p2p_join(wpa_s, bssid, go_dev_addr,
23318bea 3153 wpa_s->p2p_wps_method, 0, op_freq,
c48414af 3154 ssid, ssid_len);
b22128ef
JM		 3155 }
3156 return;
3157 }
3158
3159 if (status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
3160 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
3161 " was rejected (status %u)", MAC2STR(sa), status);
3162 return;
3163 }
3164
3165 if (!s) {
3166 if (bssid) {
92c4465b
JM		 3167 wpa_msg_global(wpa_s, MSG_INFO,
3168 P2P_EVENT_INVITATION_RECEIVED
3169 "sa=" MACSTR " go_dev_addr=" MACSTR
3170 " bssid=" MACSTR " unknown-network",
3171 MAC2STR(sa), MAC2STR(go_dev_addr),
3172 MAC2STR(bssid));
b22128ef 3173 } else {
92c4465b
JM		 3174 wpa_msg_global(wpa_s, MSG_INFO,
3175 P2P_EVENT_INVITATION_RECEIVED
3176 "sa=" MACSTR " go_dev_addr=" MACSTR
3177 " unknown-network",
3178 MAC2STR(sa), MAC2STR(go_dev_addr));
b22128ef
JM		 3179 }
3180 return;
3181 }
3182
cd1e2309 3183 if (s->mode == WPAS_MODE_P2P_GO && op_freq) {
92c4465b
JM		 3184 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
3185 "sa=" MACSTR " persistent=%d freq=%d",
3186 MAC2STR(sa), s->id, op_freq);
cd1e2309 3187 } else {
92c4465b
JM		 3188 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
3189 "sa=" MACSTR " persistent=%d",
3190 MAC2STR(sa), s->id);
cd1e2309 3191 }
b22128ef
JM		 3192}
3193
3194
dbca75f8
JM		 3195static void wpas_remove_persistent_peer(struct wpa_supplicant *wpa_s,
3196 struct wpa_ssid *ssid,
f2c56602 3197 const u8 *peer, int inv)
dbca75f8
JM		 3198{
3199 size_t i;
3200
3201 if (ssid == NULL)
3202 return;
3203
3204 for (i = 0; ssid->p2p_client_list && i < ssid->num_p2p_clients; i++) {
3205 if (os_memcmp(ssid->p2p_client_list + i * ETH_ALEN, peer,
3206 ETH_ALEN) == 0)
3207 break;
3208 }
8931a36c 3209 if (i >= ssid->num_p2p_clients || !ssid->p2p_client_list) {
dbca75f8
JM		 3210 if (ssid->mode != WPAS_MODE_P2P_GO &&
3211 os_memcmp(ssid->bssid, peer, ETH_ALEN) == 0) {
3212 wpa_printf(MSG_DEBUG, "P2P: Remove persistent group %d "
3213 "due to invitation result", ssid->id);
3214 wpas_notify_network_removed(wpa_s, ssid);
3215 wpa_config_remove_network(wpa_s->conf, ssid->id);
3216 return;
3217 }
3218 return; /* Peer not found in client list */
3219 }
3220
3221 wpa_printf(MSG_DEBUG, "P2P: Remove peer " MACSTR " from persistent "
f2c56602
JM		 3222 "group %d client list%s",
3223 MAC2STR(peer), ssid->id,
3224 inv ? " due to invitation result" : "");
dbca75f8
JM		 3225 os_memmove(ssid->p2p_client_list + i * ETH_ALEN,
3226 ssid->p2p_client_list + (i + 1) * ETH_ALEN,
3227 (ssid->num_p2p_clients - i - 1) * ETH_ALEN);
3228 ssid->num_p2p_clients--;
dbca75f8
JM		 3229 if (wpa_s->parent->conf->update_config &&
3230 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
3231 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
dbca75f8
JM		 3232}
3233
3234
3235static void wpas_remove_persistent_client(struct wpa_supplicant *wpa_s,
3236 const u8 *peer)
3237{
3238 struct wpa_ssid *ssid;
3239
3240 wpa_s = wpa_s->global->p2p_invite_group;
3241 if (wpa_s == NULL)
3242 return; /* No known invitation group */
3243 ssid = wpa_s->current_ssid;
3244 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
3245 !ssid->p2p_persistent_group)
3246 return; /* Not operating as a GO in persistent group */
3247 ssid = wpas_p2p_get_persistent(wpa_s->parent, peer,
3248 ssid->ssid, ssid->ssid_len);
f2c56602 3249 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
dbca75f8
JM		 3250}
3251
3252
54733624 3253static void wpas_invitation_result(void *ctx, int status, const u8 *bssid,
dbca75f8 3254 const struct p2p_channels *channels,
41d5ce9e
RR		 3255 const u8 *peer, int neg_freq,
3256 int peer_oper_freq)
b22128ef
JM		 3257{
3258 struct wpa_supplicant *wpa_s = ctx;
3259 struct wpa_ssid *ssid;
41d5ce9e 3260 int freq;
b22128ef
JM		 3261
3262 if (bssid) {
92c4465b
JM		 3263 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
3264 "status=%d " MACSTR,
3265 status, MAC2STR(bssid));
b22128ef 3266 } else {
92c4465b
JM		 3267 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
3268 "status=%d ", status);
b22128ef 3269 }
5ccdf84f 3270 wpas_notify_p2p_invitation_result(wpa_s, status, bssid);
b22128ef 3271
dbca75f8
JM		 3272 wpa_printf(MSG_DEBUG, "P2P: Invitation result - status=%d peer=" MACSTR,
3273 status, MAC2STR(peer));
3274 if (wpa_s->pending_invite_ssid_id == -1) {
3275 if (status == P2P_SC_FAIL_UNKNOWN_GROUP)
3276 wpas_remove_persistent_client(wpa_s, peer);
706887fc 3277 return; /* Invitation to active group */
dbca75f8 3278 }
706887fc 3279
77e4e853
JM		 3280 if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
3281 wpa_printf(MSG_DEBUG, "P2P: Waiting for peer to start another "
3282 "invitation exchange to indicate readiness for "
3283 "re-invocation");
3284 }
3285
b22128ef 3286 if (status != P2P_SC_SUCCESS) {
dbca75f8
JM		 3287 if (status == P2P_SC_FAIL_UNKNOWN_GROUP) {
3288 ssid = wpa_config_get_network(
3289 wpa_s->conf, wpa_s->pending_invite_ssid_id);
f2c56602 3290 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1);
dbca75f8 3291 }
b22128ef
JM		 3292 wpas_p2p_remove_pending_group_interface(wpa_s);
3293 return;
3294 }
3295
3296 ssid = wpa_config_get_network(wpa_s->conf,
3297 wpa_s->pending_invite_ssid_id);
3298 if (ssid == NULL) {
3299 wpa_printf(MSG_ERROR, "P2P: Could not find persistent group "
3300 "data matching with invitation");
3301 return;
3302 }
3303
13ece96f
JM		 3304 /*
3305 * The peer could have missed our ctrl::ack frame for Invitation
3306 * Response and continue retransmitting the frame. To reduce the
3307 * likelihood of the peer not getting successful TX status for the
3308 * Invitation Response frame, wait a short time here before starting
3309 * the persistent group so that we will remain on the current channel to
3310 * acknowledge any possible retransmission from the peer.
3311 */
3312 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 50 ms wait on current channel before "
3313 "starting persistent group");
3314 os_sleep(0, 50000);
3315
41d5ce9e
RR		 3316 if (neg_freq > 0 && ssid->mode == WPAS_MODE_P2P_GO &&
3317 freq_included(channels, neg_freq))
3318 freq = neg_freq;
3319 else if (peer_oper_freq > 0 && ssid->mode != WPAS_MODE_P2P_GO &&
3320 freq_included(channels, peer_oper_freq))
3321 freq = peer_oper_freq;
3322 else
3323 freq = 0;
3324
3325 wpa_printf(MSG_DEBUG, "P2P: Persistent group invitation success - op_freq=%d MHz SSID=%s",
3326 freq, wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
b22128ef 3327 wpas_p2p_group_add_persistent(wpa_s, ssid,
4d32c0c4 3328 ssid->mode == WPAS_MODE_P2P_GO,
062a7c0d 3329 wpa_s->p2p_persistent_go_freq,
41d5ce9e 3330 freq,
20ea1ca4
EP		 3331 wpa_s->p2p_go_ht40, wpa_s->p2p_go_vht,
3332 channels,
bbc6c729
JM		 3333 ssid->mode == WPAS_MODE_P2P_GO ?
3334 P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE :
3335 0);
b22128ef
JM		 3336}
3337
3338
6f3bc72b
JM		 3339static int wpas_p2p_disallowed_freq(struct wpa_global *global,
3340 unsigned int freq)
3341{
253f2e37
AH		 3342 if (freq_range_list_includes(&global->p2p_go_avoid_freq, freq))
3343 return 1;
af8a827b 3344 return freq_range_list_includes(&global->p2p_disallow_freq, freq);
6f3bc72b
JM		 3345}
3346
3347
3348static void wpas_p2p_add_chan(struct p2p_reg_class *reg, u8 chan)
3349{
3350 reg->channel[reg->channels] = chan;
3351 reg->channels++;
3352}
3353
3354
ac8d1011 3355static int wpas_p2p_default_channels(struct wpa_supplicant *wpa_s,
51e9f228
JM		 3356 struct p2p_channels *chan,
3357 struct p2p_channels *cli_chan)
ac8d1011
JM		 3358{
3359 int i, cla = 0;
3360
51e9f228
JM		 3361 os_memset(cli_chan, 0, sizeof(*cli_chan));
3362
ac8d1011
JM		 3363 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for 2.4 GHz "
3364 "band");
3365
3366 /* Operating class 81 - 2.4 GHz band channels 1..13 */
3367 chan->reg_class[cla].reg_class = 81;
6f3bc72b
JM		 3368 chan->reg_class[cla].channels = 0;
3369 for (i = 0; i < 11; i++) {
3370 if (!wpas_p2p_disallowed_freq(wpa_s->global, 2412 + i * 5))
3371 wpas_p2p_add_chan(&chan->reg_class[cla], i + 1);
3372 }
3373 if (chan->reg_class[cla].channels)
3374 cla++;
ac8d1011
JM		 3375
3376 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for lower 5 GHz "
3377 "band");
3378
3379 /* Operating class 115 - 5 GHz, channels 36-48 */
3380 chan->reg_class[cla].reg_class = 115;
6f3bc72b
JM		 3381 chan->reg_class[cla].channels = 0;
3382 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5))
3383 wpas_p2p_add_chan(&chan->reg_class[cla], 36);
3384 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5))
3385 wpas_p2p_add_chan(&chan->reg_class[cla], 40);
3386 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5))
3387 wpas_p2p_add_chan(&chan->reg_class[cla], 44);
3388 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5))
3389 wpas_p2p_add_chan(&chan->reg_class[cla], 48);
3390 if (chan->reg_class[cla].channels)
3391 cla++;
ac8d1011
JM		 3392
3393 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for higher 5 GHz "
3394 "band");
3395
3396 /* Operating class 124 - 5 GHz, channels 149,153,157,161 */
3397 chan->reg_class[cla].reg_class = 124;
6f3bc72b
JM		 3398 chan->reg_class[cla].channels = 0;
3399 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5))
3400 wpas_p2p_add_chan(&chan->reg_class[cla], 149);
3401 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5))
3402 wpas_p2p_add_chan(&chan->reg_class[cla], 153);
3403 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5))
3404 wpas_p2p_add_chan(&chan->reg_class[cla], 157);
3405 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5))
3406 wpas_p2p_add_chan(&chan->reg_class[cla], 161);
3407 if (chan->reg_class[cla].channels)
3408 cla++;
ac8d1011
JM		 3409
3410 chan->reg_classes = cla;
3411 return 0;
3412}
3413
3414
3415static struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
3416 u16 num_modes,
3417 enum hostapd_hw_mode mode)
3418{
3419 u16 i;
3420
3421 for (i = 0; i < num_modes; i++) {
3422 if (modes[i].mode == mode)
3423 return &modes[i];
3424 }
3425
3426 return NULL;
3427}
3428
3429
51e9f228
JM		 3430enum chan_allowed {
3431 NOT_ALLOWED, PASSIVE_ONLY, ALLOWED
3432};
3433
6f3bc72b
JM		 3434static int has_channel(struct wpa_global *global,
3435 struct hostapd_hw_modes *mode, u8 chan, int *flags)
ac8d1011
JM		 3436{
3437 int i;
6f3bc72b
JM		 3438 unsigned int freq;
3439
3440 freq = (mode->mode == HOSTAPD_MODE_IEEE80211A ? 5000 : 2407) +
3441 chan * 5;
3442 if (wpas_p2p_disallowed_freq(global, freq))
51e9f228 3443 return NOT_ALLOWED;
ac8d1011
JM		 3444
3445 for (i = 0; i < mode->num_channels; i++) {
3446 if (mode->channels[i].chan == chan) {
51222429
JM		 3447 if (flags)
3448 *flags = mode->channels[i].flag;
51e9f228
JM		 3449 if (mode->channels[i].flag &
3450 (HOSTAPD_CHAN_DISABLED |
3451 HOSTAPD_CHAN_RADAR))
3452 return NOT_ALLOWED;
3453 if (mode->channels[i].flag &
3454 (HOSTAPD_CHAN_PASSIVE_SCAN |
3455 HOSTAPD_CHAN_NO_IBSS))
3456 return PASSIVE_ONLY;
3457 return ALLOWED;
ac8d1011
JM		 3458 }
3459 }
3460
51e9f228 3461 return NOT_ALLOWED;
ac8d1011
JM		 3462}
3463
3464
3465struct p2p_oper_class_map {
3466 enum hostapd_hw_mode mode;
3467 u8 op_class;
3468 u8 min_chan;
3469 u8 max_chan;
3470 u8 inc;
ca9bc5b5 3471 enum { BW20, BW40PLUS, BW40MINUS, BW80 } bw;
ac8d1011
JM		 3472};
3473
931228aa
RM		 3474static struct p2p_oper_class_map op_class[] = {
3475 { HOSTAPD_MODE_IEEE80211G, 81, 1, 13, 1, BW20 },
931228aa
RM		 3476#if 0 /* Do not enable HT40 on 2 GHz for now */
3477 { HOSTAPD_MODE_IEEE80211G, 83, 1, 9, 1, BW40PLUS },
3478 { HOSTAPD_MODE_IEEE80211G, 84, 5, 13, 1, BW40MINUS },
3479#endif
3480 { HOSTAPD_MODE_IEEE80211A, 115, 36, 48, 4, BW20 },
3481 { HOSTAPD_MODE_IEEE80211A, 124, 149, 161, 4, BW20 },
3482 { HOSTAPD_MODE_IEEE80211A, 116, 36, 44, 8, BW40PLUS },
3483 { HOSTAPD_MODE_IEEE80211A, 117, 40, 48, 8, BW40MINUS },
3484 { HOSTAPD_MODE_IEEE80211A, 126, 149, 157, 8, BW40PLUS },
3485 { HOSTAPD_MODE_IEEE80211A, 127, 153, 161, 8, BW40MINUS },
ca9bc5b5
EP		 3486
3487 /*
3488 * IEEE P802.11ac/D7.0 Table E-4 actually talks about channel center
3489 * frequency index 42, 58, 106, 122, 138, 155 with channel spacing of
3490 * 80 MHz, but currently use the following definition for simplicity
3491 * (these center frequencies are not actual channels, which makes
3492 * has_channel() fail). wpas_p2p_verify_80mhz() should take care of
3493 * removing invalid channels.
3494 */
3495 { HOSTAPD_MODE_IEEE80211A, 128, 36, 161, 4, BW80 },
931228aa
RM		 3496 { -1, 0, 0, 0, 0, BW20 }
3497};
3498
3499
ca9bc5b5
EP		 3500static int wpas_p2p_get_center_80mhz(struct wpa_supplicant *wpa_s,
3501 struct hostapd_hw_modes *mode,
3502 u8 channel)
3503{
3504 u8 center_channels[] = { 42, 58, 106, 122, 138, 155 };
3505 unsigned int i;
3506
3507 if (mode->mode != HOSTAPD_MODE_IEEE80211A)
3508 return 0;
3509
3510 for (i = 0; i < ARRAY_SIZE(center_channels); i++)
3511 /*
3512 * In 80 MHz, the bandwidth "spans" 12 channels (e.g., 36-48),
3513 * so the center channel is 6 channels away from the start/end.
3514 */
3515 if (channel >= center_channels[i] - 6 &&
3516 channel <= center_channels[i] + 6)
3517 return center_channels[i];
3518
3519 return 0;
3520}
3521
3522
3523static enum chan_allowed wpas_p2p_verify_80mhz(struct wpa_supplicant *wpa_s,
3524 struct hostapd_hw_modes *mode,
3525 u8 channel, u8 bw)
3526{
3527 u8 center_chan;
3528 int i, flags;
3529 enum chan_allowed res, ret = ALLOWED;
3530
3531 center_chan = wpas_p2p_get_center_80mhz(wpa_s, mode, channel);
3532 if (!center_chan)
3533 return NOT_ALLOWED;
3534 if (center_chan >= 58 && center_chan <= 138)
3535 return NOT_ALLOWED; /* Do not allow DFS channels for P2P */
3536
3537 /* check all the channels are available */
3538 for (i = 0; i < 4; i++) {
3539 int adj_chan = center_chan - 6 + i * 4;
3540
3541 res = has_channel(wpa_s->global, mode, adj_chan, &flags);
3542 if (res == NOT_ALLOWED)
3543 return NOT_ALLOWED;
3544 if (res == PASSIVE_ONLY)
3545 ret = PASSIVE_ONLY;
3546
3547 if (i == 0 && !(flags & HOSTAPD_CHAN_VHT_10_70))
3548 return NOT_ALLOWED;
3549 if (i == 1 && !(flags & HOSTAPD_CHAN_VHT_30_50))
3550 return NOT_ALLOWED;
3551 if (i == 2 && !(flags & HOSTAPD_CHAN_VHT_50_30))
3552 return NOT_ALLOWED;
3553 if (i == 3 && !(flags & HOSTAPD_CHAN_VHT_70_10))
3554 return NOT_ALLOWED;
3555 }
3556
3557 return ret;
3558}
3559
3560
51e9f228
JM		 3561static enum chan_allowed wpas_p2p_verify_channel(struct wpa_supplicant *wpa_s,
3562 struct hostapd_hw_modes *mode,
3563 u8 channel, u8 bw)
931228aa 3564{
cbf21c7c 3565 int flag = 0;
51e9f228
JM		 3566 enum chan_allowed res, res2;
3567
3568 res2 = res = has_channel(wpa_s->global, mode, channel, &flag);
3569 if (bw == BW40MINUS) {
3570 if (!(flag & HOSTAPD_CHAN_HT40MINUS))
3571 return NOT_ALLOWED;
3572 res2 = has_channel(wpa_s->global, mode, channel - 4, NULL);
3573 } else if (bw == BW40PLUS) {
3574 if (!(flag & HOSTAPD_CHAN_HT40PLUS))
3575 return NOT_ALLOWED;
3576 res2 = has_channel(wpa_s->global, mode, channel + 4, NULL);
ca9bc5b5
EP		 3577 } else if (bw == BW80) {
3578 res2 = wpas_p2p_verify_80mhz(wpa_s, mode, channel, bw);
51e9f228
JM		 3579 }
3580
3581 if (res == NOT_ALLOWED || res2 == NOT_ALLOWED)
3582 return NOT_ALLOWED;
3583 if (res == PASSIVE_ONLY || res2 == PASSIVE_ONLY)
3584 return PASSIVE_ONLY;
3585 return res;
931228aa
RM		 3586}
3587
3588
b22128ef 3589static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s,
51e9f228
JM		 3590 struct p2p_channels *chan,
3591 struct p2p_channels *cli_chan)
b22128ef 3592{
6bf731e8 3593 struct hostapd_hw_modes *mode;
51e9f228 3594 int cla, op, cli_cla;
b22128ef 3595
6bf731e8 3596 if (wpa_s->hw.modes == NULL) {
b22128ef
JM		 3597 wpa_printf(MSG_DEBUG, "P2P: Driver did not support fetching "
3598 "of all supported channels; assume dualband "
3599 "support");
51e9f228 3600 return wpas_p2p_default_channels(wpa_s, chan, cli_chan);
b22128ef
JM		 3601 }
3602
51e9f228 3603 cla = cli_cla = 0;
b22128ef 3604
ac8d1011
JM		 3605 for (op = 0; op_class[op].op_class; op++) {
3606 struct p2p_oper_class_map *o = &op_class[op];
3607 u8 ch;
51e9f228 3608 struct p2p_reg_class *reg = NULL, *cli_reg = NULL;
b22128ef 3609
6bf731e8 3610 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode);
ac8d1011
JM		 3611 if (mode == NULL)
3612 continue;
3613 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
51e9f228
JM		 3614 enum chan_allowed res;
3615 res = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw);
3616 if (res == ALLOWED) {
3617 if (reg == NULL) {
3618 wpa_printf(MSG_DEBUG, "P2P: Add operating class %u",
3619 o->op_class);
3620 reg = &chan->reg_class[cla];
3621 cla++;
3622 reg->reg_class = o->op_class;
3623 }
3624 reg->channel[reg->channels] = ch;
3625 reg->channels++;
3626 } else if (res == PASSIVE_ONLY &&
3627 wpa_s->conf->p2p_add_cli_chan) {
3628 if (cli_reg == NULL) {
3629 wpa_printf(MSG_DEBUG, "P2P: Add operating class %u (client only)",
3630 o->op_class);
3631 cli_reg = &cli_chan->reg_class[cli_cla];
3632 cli_cla++;
3633 cli_reg->reg_class = o->op_class;
3634 }
3635 cli_reg->channel[cli_reg->channels] = ch;
3636 cli_reg->channels++;
ac8d1011 3637 }
ac8d1011
JM		 3638 }
3639 if (reg) {
3640 wpa_hexdump(MSG_DEBUG, "P2P: Channels",
3641 reg->channel, reg->channels);
3642 }
51e9f228
JM		 3643 if (cli_reg) {
3644 wpa_hexdump(MSG_DEBUG, "P2P: Channels (client only)",
3645 cli_reg->channel, cli_reg->channels);
3646 }
b22128ef
JM		 3647 }
3648
ac8d1011 3649 chan->reg_classes = cla;
51e9f228 3650 cli_chan->reg_classes = cli_cla;
b22128ef 3651
b22128ef
JM		 3652 return 0;
3653}
3654
3655
7aeac985
RM		 3656int wpas_p2p_get_ht40_mode(struct wpa_supplicant *wpa_s,
3657 struct hostapd_hw_modes *mode, u8 channel)
3658{
51e9f228
JM		 3659 int op;
3660 enum chan_allowed ret;
7aeac985
RM		 3661
3662 for (op = 0; op_class[op].op_class; op++) {
3663 struct p2p_oper_class_map *o = &op_class[op];
3664 u8 ch;
3665
3666 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
3667 if (o->mode != HOSTAPD_MODE_IEEE80211A ||
3668 o->bw == BW20 || ch != channel)
3669 continue;
3670 ret = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw);
51e9f228 3671 if (ret == ALLOWED)
7aeac985 3672 return (o->bw == BW40MINUS) ? -1 : 1;
7aeac985
RM		 3673 }
3674 }
3675 return 0;
3676}
3677
3678
ca9bc5b5
EP		 3679int wpas_p2p_get_vht80_center(struct wpa_supplicant *wpa_s,
3680 struct hostapd_hw_modes *mode, u8 channel)
3681{
3682 if (!wpas_p2p_verify_channel(wpa_s, mode, channel, BW80))
3683 return 0;
3684
3685 return wpas_p2p_get_center_80mhz(wpa_s, mode, channel);
3686}
3687
3688
b22128ef
JM		 3689static int wpas_get_noa(void *ctx, const u8 *interface_addr, u8 *buf,
3690 size_t buf_len)
3691{
3692 struct wpa_supplicant *wpa_s = ctx;
3693
3694 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3695 if (os_memcmp(wpa_s->own_addr, interface_addr, ETH_ALEN) == 0)
3696 break;
3697 }
3698 if (wpa_s == NULL)
3699 return -1;
3700
3701 return wpa_drv_get_noa(wpa_s, buf, buf_len);
3702}
3703
3704
6f04642f
TB		 3705struct wpa_supplicant * wpas_get_p2p_go_iface(struct wpa_supplicant *wpa_s,
3706 const u8 *ssid, size_t ssid_len)
b1aebbc4 3707{
6f04642f
TB		 3708 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3709 struct wpa_ssid *s = wpa_s->current_ssid;
3710 if (s == NULL)
3711 continue;
3712 if (s->mode != WPAS_MODE_P2P_GO &&
3713 s->mode != WPAS_MODE_AP &&
3714 s->mode != WPAS_MODE_P2P_GROUP_FORMATION)
3715 continue;
3716 if (s->ssid_len != ssid_len ||
af65bc36 3717 os_memcmp(ssid, s->ssid, ssid_len) != 0)
6f04642f
TB		 3718 continue;
3719 return wpa_s;
3720 }
3721
3722 return NULL;
3723
3724}
3725
b1aebbc4 3726
6f04642f
TB		 3727struct wpa_supplicant * wpas_get_p2p_client_iface(struct wpa_supplicant *wpa_s,
3728 const u8 *peer_dev_addr)
3729{
b1aebbc4
JM		 3730 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3731 struct wpa_ssid *ssid = wpa_s->current_ssid;
3732 if (ssid == NULL)
3733 continue;
3734 if (ssid->mode != WPAS_MODE_INFRA)
3735 continue;
d9a0f666
PN		 3736 if (wpa_s->wpa_state != WPA_COMPLETED &&
3737 wpa_s->wpa_state != WPA_GROUP_HANDSHAKE)
b1aebbc4 3738 continue;
6f04642f
TB		 3739 if (os_memcmp(wpa_s->go_dev_addr, peer_dev_addr, ETH_ALEN) == 0)
3740 return wpa_s;
b1aebbc4
JM		 3741 }
3742
6f04642f
TB		 3743 return NULL;
3744}
3745
3746
3747static int wpas_go_connected(void *ctx, const u8 *dev_addr)
3748{
3749 struct wpa_supplicant *wpa_s = ctx;
3750
3751 return wpas_get_p2p_client_iface(wpa_s, dev_addr) != NULL;
b1aebbc4
JM		 3752}
3753
3754
a2d63657
RR		 3755static int wpas_is_concurrent_session_active(void *ctx)
3756{
3757 struct wpa_supplicant *wpa_s = ctx;
3758 struct wpa_supplicant *ifs;
3759
3760 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
3761 if (ifs == wpa_s)
3762 continue;
3763 if (ifs->wpa_state > WPA_ASSOCIATED)
3764 return 1;
3765 }
3766 return 0;
3767}
3768
3769
ed496f13
JM		 3770static void wpas_p2p_debug_print(void *ctx, int level, const char *msg)
3771{
3772 struct wpa_supplicant *wpa_s = ctx;
92c4465b 3773 wpa_msg_global(wpa_s, level, "P2P: %s", msg);
ed496f13
JM		 3774}
3775
3776
c68f6200
AS		 3777int wpas_p2p_add_p2pdev_interface(struct wpa_supplicant *wpa_s)
3778{
3779 struct wpa_interface iface;
3780 struct wpa_supplicant *p2pdev_wpa_s;
3781 char ifname[100];
3782 char force_name[100];
3783 int ret;
3784
2e5ba4b6
AS		 3785 os_snprintf(ifname, sizeof(ifname), P2P_MGMT_DEVICE_PREFIX "%s",
3786 wpa_s->ifname);
c68f6200
AS		 3787 force_name[0] = '\0';
3788 wpa_s->pending_interface_type = WPA_IF_P2P_DEVICE;
3789 ret = wpa_drv_if_add(wpa_s, WPA_IF_P2P_DEVICE, ifname, NULL, NULL,
3790 force_name, wpa_s->pending_interface_addr, NULL);
3791 if (ret < 0) {
3792 wpa_printf(MSG_DEBUG, "P2P: Failed to create P2P Device interface");
3793 return ret;
3794 }
3795 os_strlcpy(wpa_s->pending_interface_name, ifname,
3796 sizeof(wpa_s->pending_interface_name));
3797
3798 os_memset(&iface, 0, sizeof(iface));
3799 iface.p2p_mgmt = 1;
3800 iface.ifname = wpa_s->pending_interface_name;
3801 iface.driver = wpa_s->driver->name;
c68f6200 3802 iface.driver_param = wpa_s->conf->driver_param;
c16a7590
IP		 3803
3804 /*
3805 * If a P2P Device configuration file was given, use it as the interface
3806 * configuration file (instead of using parent's configuration file.
3807 */
3808 if (wpa_s->conf_p2p_dev) {
3809 iface.confname = wpa_s->conf_p2p_dev;
3810 iface.ctrl_interface = NULL;
3811 } else {
3812 iface.confname = wpa_s->confname;
3813 iface.ctrl_interface = wpa_s->conf->ctrl_interface;
3814 }
3815 iface.conf_p2p_dev = NULL;
3816
c68f6200
AS		 3817 p2pdev_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
3818 if (!p2pdev_wpa_s) {
3819 wpa_printf(MSG_DEBUG, "P2P: Failed to add P2P Device interface");
3820 return -1;
3821 }
78f79fe5 3822 p2pdev_wpa_s->parent = wpa_s;
c68f6200
AS		 3823
3824 wpa_s->pending_interface_name[0] = '\0';
3825 return 0;
3826}
3827
3828
c64e3a08
JM		 3829static void wpas_presence_resp(void *ctx, const u8 *src, u8 status,
3830 const u8 *noa, size_t noa_len)
3831{
3832 struct wpa_supplicant *wpa_s, *intf = ctx;
3833 char hex[100];
3834
3835 for (wpa_s = intf->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
3836 if (wpa_s->waiting_presence_resp)
3837 break;
3838 }
3839 if (!wpa_s) {
3840 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No group interface was waiting for presence response");
3841 return;
3842 }
3843 wpa_s->waiting_presence_resp = 0;
3844
3845 wpa_snprintf_hex(hex, sizeof(hex), noa, noa_len);
3846 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PRESENCE_RESPONSE "src=" MACSTR
3847 " status=%u noa=%s", MAC2STR(src), status, hex);
3848}
3849
3850
0f1034e3
SD		 3851static int _wpas_p2p_in_progress(void *ctx)
3852{
3853 struct wpa_supplicant *wpa_s = ctx;
3854 return wpas_p2p_in_progress(wpa_s);
3855}
3856
3857
b22128ef
JM		 3858/**
3859 * wpas_p2p_init - Initialize P2P module for %wpa_supplicant
3860 * @global: Pointer to global data from wpa_supplicant_init()
3861 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
3862 * Returns: 0 on success, -1 on failure
3863 */
3864int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
3865{
3866 struct p2p_config p2p;
3867 unsigned int r;
f95cac27 3868 int i;
b22128ef 3869
f2b3f4de
SS		 3870 if (wpa_s->conf->p2p_disabled)
3871 return 0;
3872
b22128ef
JM		 3873 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
3874 return 0;
3875
b22128ef
JM		 3876 if (global->p2p)
3877 return 0;
3878
3879 os_memset(&p2p, 0, sizeof(p2p));
b22128ef 3880 p2p.cb_ctx = wpa_s;
ed496f13 3881 p2p.debug_print = wpas_p2p_debug_print;
b22128ef
JM		 3882 p2p.p2p_scan = wpas_p2p_scan;
3883 p2p.send_action = wpas_send_action;
3884 p2p.send_action_done = wpas_send_action_done;
3885 p2p.go_neg_completed = wpas_go_neg_completed;
3886 p2p.go_neg_req_rx = wpas_go_neg_req_rx;
3887 p2p.dev_found = wpas_dev_found;
56eeb8f2 3888 p2p.dev_lost = wpas_dev_lost;
710ae9ac 3889 p2p.find_stopped = wpas_find_stopped;
b22128ef
JM		 3890 p2p.start_listen = wpas_start_listen;
3891 p2p.stop_listen = wpas_stop_listen;
3892 p2p.send_probe_resp = wpas_send_probe_resp;
3893 p2p.sd_request = wpas_sd_request;
3894 p2p.sd_response = wpas_sd_response;
3895 p2p.prov_disc_req = wpas_prov_disc_req;
3896 p2p.prov_disc_resp = wpas_prov_disc_resp;
dd8a7e05 3897 p2p.prov_disc_fail = wpas_prov_disc_fail;
b22128ef
JM		 3898 p2p.invitation_process = wpas_invitation_process;
3899 p2p.invitation_received = wpas_invitation_received;
3900 p2p.invitation_result = wpas_invitation_result;
3901 p2p.get_noa = wpas_get_noa;
b1aebbc4 3902 p2p.go_connected = wpas_go_connected;
c64e3a08 3903 p2p.presence_resp = wpas_presence_resp;
a2d63657 3904 p2p.is_concurrent_session_active = wpas_is_concurrent_session_active;
0f1034e3 3905 p2p.is_p2p_in_progress = _wpas_p2p_in_progress;
b22128ef
JM		 3906
3907 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
d7e70476 3908 os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN);
b22128ef 3909 p2p.dev_name = wpa_s->conf->device_name;
b6e01800
JM		 3910 p2p.manufacturer = wpa_s->conf->manufacturer;
3911 p2p.model_name = wpa_s->conf->model_name;
3912 p2p.model_number = wpa_s->conf->model_number;
3913 p2p.serial_number = wpa_s->conf->serial_number;
3914 if (wpa_s->wps) {
3915 os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16);
3916 p2p.config_methods = wpa_s->wps->config_methods;
3917 }
b22128ef
JM		 3918
3919 if (wpa_s->conf->p2p_listen_reg_class &&
3920 wpa_s->conf->p2p_listen_channel) {
3921 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
3922 p2p.channel = wpa_s->conf->p2p_listen_channel;
e3bd6e9d 3923 p2p.channel_forced = 1;
b22128ef
JM		 3924 } else {
3925 p2p.reg_class = 81;
3926 /*
3927 * Pick one of the social channels randomly as the listen
3928 * channel.
3929 */
df2508d7
JM		 3930 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
3931 return -1;
b22128ef 3932 p2p.channel = 1 + (r % 3) * 5;
e3bd6e9d 3933 p2p.channel_forced = 0;
b22128ef 3934 }
7cfc4ac3 3935 wpa_printf(MSG_DEBUG, "P2P: Own listen channel: %d", p2p.channel);
b22128ef
JM		 3936
3937 if (wpa_s->conf->p2p_oper_reg_class &&
3938 wpa_s->conf->p2p_oper_channel) {
3939 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
3940 p2p.op_channel = wpa_s->conf->p2p_oper_channel;
7cfc4ac3
AGS		 3941 p2p.cfg_op_channel = 1;
3942 wpa_printf(MSG_DEBUG, "P2P: Configured operating channel: "
3943 "%d:%d", p2p.op_reg_class, p2p.op_channel);
3944
b22128ef
JM		 3945 } else {
3946 p2p.op_reg_class = 81;
3947 /*
7cfc4ac3
AGS		 3948 * Use random operation channel from (1, 6, 11) if no other
3949 * preference is indicated.
b22128ef 3950 */
df2508d7
JM		 3951 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
3952 return -1;
7cfc4ac3
AGS		 3953 p2p.op_channel = 1 + (r % 3) * 5;
3954 p2p.cfg_op_channel = 0;
3955 wpa_printf(MSG_DEBUG, "P2P: Random operating channel: "
3956 "%d:%d", p2p.op_reg_class, p2p.op_channel);
b22128ef 3957 }
010b5f9b
YW		 3958
3959 if (wpa_s->conf->p2p_pref_chan && wpa_s->conf->num_p2p_pref_chan) {
3960 p2p.pref_chan = wpa_s->conf->p2p_pref_chan;
3961 p2p.num_pref_chan = wpa_s->conf->num_p2p_pref_chan;
3962 }
3963
b22128ef
JM		 3964 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
3965 os_memcpy(p2p.country, wpa_s->conf->country, 2);
3966 p2p.country[2] = 0x04;
3967 } else
aaca6505 3968 os_memcpy(p2p.country, "XX\x04", 3);
b22128ef 3969
51e9f228 3970 if (wpas_p2p_setup_channels(wpa_s, &p2p.channels, &p2p.cli_channels)) {
b22128ef
JM		 3971 wpa_printf(MSG_ERROR, "P2P: Failed to configure supported "
3972 "channel list");
3973 return -1;
3974 }
3975
2f646b6e
JB		 3976 os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type,
3977 WPS_DEV_TYPE_LEN);
b22128ef 3978
2f646b6e
JB		 3979 p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
3980 os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type,
3981 p2p.num_sec_dev_types * WPS_DEV_TYPE_LEN);
b22128ef
JM		 3982
3983 p2p.concurrent_operations = !!(wpa_s->drv_flags &
3984 WPA_DRIVER_FLAGS_P2P_CONCURRENT);
3985
de979d8f 3986 p2p.max_peers = 100;
b22128ef
JM		 3987
3988 if (wpa_s->conf->p2p_ssid_postfix) {
3989 p2p.ssid_postfix_len =
3990 os_strlen(wpa_s->conf->p2p_ssid_postfix);
3991 if (p2p.ssid_postfix_len > sizeof(p2p.ssid_postfix))
3992 p2p.ssid_postfix_len = sizeof(p2p.ssid_postfix);
3993 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
3994 p2p.ssid_postfix_len);
3995 }
3996
0f66abd2
SS		 3997 p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss;
3998
96beff11
JM		 3999 p2p.max_listen = wpa_s->max_remain_on_chan;
4000
1b928f96
JM		 4001 if (wpa_s->conf->p2p_passphrase_len >= 8 &&
4002 wpa_s->conf->p2p_passphrase_len <= 63)
4003 p2p.passphrase_len = wpa_s->conf->p2p_passphrase_len;
4004 else
4005 p2p.passphrase_len = 8;
4006
b22128ef
JM		 4007 global->p2p = p2p_init(&p2p);
4008 if (global->p2p == NULL)
4009 return -1;
ab28911d 4010 global->p2p_init_wpa_s = wpa_s;
b22128ef 4011
f95cac27
JMB		 4012 for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) {
4013 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
4014 continue;
4015 p2p_add_wps_vendor_extension(
4016 global->p2p, wpa_s->conf->wps_vendor_ext[i]);
4017 }
4018
556b30da
JM		 4019 p2p_set_no_go_freq(global->p2p, &wpa_s->conf->p2p_no_go_freq);
4020
b22128ef
JM		 4021 return 0;
4022}
4023
4024
4025/**
4026 * wpas_p2p_deinit - Deinitialize per-interface P2P data
4027 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4028 *
4029 * This function deinitialize per-interface P2P data.
4030 */
4031void wpas_p2p_deinit(struct wpa_supplicant *wpa_s)
4032{
4033 if (wpa_s->driver && wpa_s->drv_priv)
4034 wpa_drv_probe_req_report(wpa_s, 0);
ec437d9e
JJ		 4035
4036 if (wpa_s->go_params) {
4037 /* Clear any stored provisioning info */
4038 p2p_clear_provisioning_info(
4039 wpa_s->global->p2p,
10531d21 4040 wpa_s->go_params->peer_device_addr);
ec437d9e
JJ		 4041 }
4042
b22128ef
JM		 4043 os_free(wpa_s->go_params);
4044 wpa_s->go_params = NULL;
fb2ac53d 4045 eloop_cancel_timeout(wpas_p2p_psk_failure_removal, wpa_s, NULL);
b22128ef 4046 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
ef922c4a 4047 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
b22128ef
JM		 4048 wpa_s->p2p_long_listen = 0;
4049 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
3071e181 4050 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
b22128ef 4051 wpas_p2p_remove_pending_group_interface(wpa_s);
8567866d 4052 eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL);
e1d1c8e2 4053 wpas_p2p_listen_work_done(wpa_s);
e05e1308
JM		 4054 if (wpa_s->p2p_send_action_work) {
4055 os_free(wpa_s->p2p_send_action_work->ctx);
4056 radio_work_done(wpa_s->p2p_send_action_work);
4057 wpa_s->p2p_send_action_work = NULL;
4058 }
4059 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, wpa_s, NULL);
b22128ef 4060
db6ae69e
JM		 4061 wpabuf_free(wpa_s->p2p_oob_dev_pw);
4062 wpa_s->p2p_oob_dev_pw = NULL;
4063
b22128ef
JM		 4064 /* TODO: remove group interface from the driver if this wpa_s instance
4065 * is on top of a P2P group interface */
4066}
4067
4068
4069/**
4070 * wpas_p2p_deinit_global - Deinitialize global P2P module
4071 * @global: Pointer to global data from wpa_supplicant_init()
4072 *
4073 * This function deinitializes the global (per device) P2P module.
4074 */
bd10d938 4075static void wpas_p2p_deinit_global(struct wpa_global *global)
b22128ef
JM		 4076{
4077 struct wpa_supplicant *wpa_s, *tmp;
b22128ef 4078
bf428a73 4079 wpa_s = global->ifaces;
ee285df4
EA		 4080
4081 wpas_p2p_service_flush(global->p2p_init_wpa_s);
bf428a73 4082
b22128ef 4083 /* Remove remaining P2P group interfaces */
b22128ef
JM		 4084 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
4085 wpa_s = wpa_s->next;
4086 while (wpa_s) {
b22128ef
JM		 4087 tmp = global->ifaces;
4088 while (tmp &&
4089 (tmp == wpa_s ||
4090 tmp->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)) {
4091 tmp = tmp->next;
4092 }
4093 if (tmp == NULL)
4094 break;
103b8f4d
NS		 4095 /* Disconnect from the P2P group and deinit the interface */
4096 wpas_p2p_disconnect(tmp);
b22128ef
JM		 4097 }
4098
743ef799
JM		 4099 /*
4100 * Deinit GO data on any possibly remaining interface (if main
4101 * interface is used as GO).
4102 */
4103 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
4104 if (wpa_s->ap_iface)
4105 wpas_p2p_group_deinit(wpa_s);
4106 }
4107
b22128ef
JM		 4108 p2p_deinit(global->p2p);
4109 global->p2p = NULL;
ab28911d 4110 global->p2p_init_wpa_s = NULL;
b22128ef
JM		 4111}
4112
4113
4114static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s)
4115{
bb4028f1
AS		 4116 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
4117 wpa_s->conf->p2p_no_group_iface)
d76cd41a 4118 return 0; /* separate interface disabled per configuration */
971e357f
JM		 4119 if (wpa_s->drv_flags &
4120 (WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE |
4121 WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P))
b22128ef
JM		 4122 return 1; /* P2P group requires a new interface in every case
4123 */
4124 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
4125 return 0; /* driver does not support concurrent operations */
4126 if (wpa_s->global->ifaces->next)
4127 return 1; /* more that one interface already in use */
4128 if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
4129 return 1; /* this interface is already in use */
4130 return 0;
4131}
4132
4133
4134static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
4135 const u8 *peer_addr,
4136 enum p2p_wps_method wps_method,
4137 int go_intent, const u8 *own_interface_addr,
23c84252 4138 unsigned int force_freq, int persistent_group,
04a3e69d 4139 struct wpa_ssid *ssid, unsigned int pref_freq)
b22128ef 4140{
acc247b2
JM		 4141 if (persistent_group && wpa_s->conf->persistent_reconnect)
4142 persistent_group = 2;
4143
4f219667
JM		 4144 /*
4145 * Increase GO config timeout if HT40 is used since it takes some time
4146 * to scan channels for coex purposes before the BSS can be started.
4147 */
4148 p2p_set_config_timeout(wpa_s->global->p2p,
4149 wpa_s->p2p_go_ht40 ? 255 : 100, 20);
4150
b22128ef
JM		 4151 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
4152 go_intent, own_interface_addr, force_freq,
23c84252 4153 persistent_group, ssid ? ssid->ssid : NULL,
3bc462cb 4154 ssid ? ssid->ssid_len : 0,
db6ae69e
JM		 4155 wpa_s->p2p_pd_before_go_neg, pref_freq,
4156 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
4157 0);
b22128ef
JM		 4158}
4159
4160
4161static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
4162 const u8 *peer_addr,
4163 enum p2p_wps_method wps_method,
4164 int go_intent, const u8 *own_interface_addr,
23c84252 4165 unsigned int force_freq, int persistent_group,
04a3e69d 4166 struct wpa_ssid *ssid, unsigned int pref_freq)
b22128ef 4167{
acc247b2
JM		 4168 if (persistent_group && wpa_s->conf->persistent_reconnect)
4169 persistent_group = 2;
4170
b22128ef
JM		 4171 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
4172 go_intent, own_interface_addr, force_freq,
23c84252 4173 persistent_group, ssid ? ssid->ssid : NULL,
db6ae69e
JM		 4174 ssid ? ssid->ssid_len : 0, pref_freq,
4175 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id :
4176 0);
b22128ef
JM		 4177}
4178
4179
9b1ab931
JM		 4180static void wpas_p2p_check_join_scan_limit(struct wpa_supplicant *wpa_s)
4181{
4182 wpa_s->p2p_join_scan_count++;
4183 wpa_printf(MSG_DEBUG, "P2P: Join scan attempt %d",
4184 wpa_s->p2p_join_scan_count);
4185 if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) {
4186 wpa_printf(MSG_DEBUG, "P2P: Failed to find GO " MACSTR
4187 " for join operationg - stop join attempt",
4188 MAC2STR(wpa_s->pending_join_iface_addr));
4189 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
0918c4bf
JM		 4190 if (wpa_s->p2p_auto_pd) {
4191 wpa_s->p2p_auto_pd = 0;
92c4465b
JM		 4192 wpa_msg_global(wpa_s, MSG_INFO,
4193 P2P_EVENT_PROV_DISC_FAILURE
4194 " p2p_dev_addr=" MACSTR " status=N/A",
4195 MAC2STR(wpa_s->pending_join_dev_addr));
0918c4bf
JM		 4196 return;
4197 }
92c4465b
JM		 4198 wpa_msg_global(wpa_s->parent, MSG_INFO,
4199 P2P_EVENT_GROUP_FORMATION_FAILURE);
9b1ab931
JM		 4200 }
4201}
4202
4203
4b156206
JM		 4204static int wpas_check_freq_conflict(struct wpa_supplicant *wpa_s, int freq)
4205{
a0c90bb0
IP		 4206 int res;
4207 unsigned int num, i;
4208 struct wpa_used_freq_data *freqs;
4b156206 4209
0d08efa4
IP		 4210 if (wpas_p2p_num_unused_channels(wpa_s) > 0) {
4211 /* Multiple channels are supported and not all are in use */
4b156206 4212 return 0;
0d08efa4 4213 }
4b156206 4214
a0c90bb0
IP		 4215 freqs = os_calloc(wpa_s->num_multichan_concurrent,
4216 sizeof(struct wpa_used_freq_data));
0d08efa4
IP		 4217 if (!freqs)
4218 return 1;
86ae2e8a 4219
0d08efa4
IP		 4220 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
4221 wpa_s->num_multichan_concurrent);
4b156206 4222
0d08efa4 4223 for (i = 0; i < num; i++) {
a0c90bb0 4224 if (freqs[i].freq == freq) {
0d08efa4
IP		 4225 wpa_printf(MSG_DEBUG, "P2P: Frequency %d MHz in use by another virtual interface and can be used",
4226 freq);
4227 res = 0;
4228 goto exit_free;
4229 }
4b156206
JM		 4230 }
4231
a0c90bb0 4232 wpa_printf(MSG_DEBUG, "P2P: No valid operating frequencies");
0d08efa4
IP		 4233 res = 1;
4234
4235exit_free:
4236 os_free(freqs);
4237 return res;
4b156206
JM		 4238}
4239
4240
b31be3a0
JM		 4241static int wpas_p2p_peer_go(struct wpa_supplicant *wpa_s,
4242 const u8 *peer_dev_addr)
4243{
4244 struct wpa_bss *bss;
4245 int updated;
4246
4247 bss = wpa_bss_get_p2p_dev_addr(wpa_s, peer_dev_addr);
4248 if (bss == NULL)
aa9bb764 4249 return -1;
b31be3a0
JM		 4250 if (bss->last_update_idx < wpa_s->bss_update_idx) {
4251 wpa_printf(MSG_DEBUG, "P2P: Peer BSS entry not updated in the "
4252 "last scan");
4253 return 0;
4254 }
4255
acb69cec
JB		 4256 updated = os_reltime_before(&wpa_s->p2p_auto_started,
4257 &bss->last_update);
b31be3a0
JM		 4258 wpa_printf(MSG_DEBUG, "P2P: Current BSS entry for peer updated at "
4259 "%ld.%06ld (%supdated in last scan)",
4260 bss->last_update.sec, bss->last_update.usec,
4261 updated ? "": "not ");
4262
4263 return updated;
4264}
4265
4266
ef922c4a
JM		 4267static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s,
4268 struct wpa_scan_results *scan_res)
b22128ef 4269{
c48414af 4270 struct wpa_bss *bss = NULL;
f8d0131a 4271 int freq;
54960629 4272 u8 iface_addr[ETH_ALEN];
b22128ef 4273
ef922c4a 4274 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
b22128ef 4275
ef922c4a
JM		 4276 if (wpa_s->global->p2p_disabled)
4277 return;
b22128ef 4278
b31be3a0
JM		 4279 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS) for %sjoin",
4280 scan_res ? (int) scan_res->num : -1,
4281 wpa_s->p2p_auto_join ? "auto_" : "");
ef922c4a
JM		 4282
4283 if (scan_res)
4284 wpas_p2p_scan_res_handler(wpa_s, scan_res);
b22128ef 4285
0918c4bf
JM		 4286 if (wpa_s->p2p_auto_pd) {
4287 int join = wpas_p2p_peer_go(wpa_s,
4288 wpa_s->pending_join_dev_addr);
84286a22
SDU		 4289 if (join == 0 &&
4290 wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) {
4291 wpa_s->auto_pd_scan_retry++;
702621e6
JM		 4292 bss = wpa_bss_get_bssid_latest(
4293 wpa_s, wpa_s->pending_join_dev_addr);
84286a22
SDU		 4294 if (bss) {
4295 freq = bss->freq;
4296 wpa_printf(MSG_DEBUG, "P2P: Scan retry %d for "
4297 "the peer " MACSTR " at %d MHz",
4298 wpa_s->auto_pd_scan_retry,
4299 MAC2STR(wpa_s->
4300 pending_join_dev_addr),
4301 freq);
c48414af 4302 wpas_p2p_join_scan_req(wpa_s, freq, NULL, 0);
84286a22
SDU		 4303 return;
4304 }
4305 }
4306
aa9bb764
JM		 4307 if (join < 0)
4308 join = 0;
84286a22 4309
0918c4bf
JM		 4310 wpa_s->p2p_auto_pd = 0;
4311 wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG;
4312 wpa_printf(MSG_DEBUG, "P2P: Auto PD with " MACSTR " join=%d",
4313 MAC2STR(wpa_s->pending_join_dev_addr), join);
4314 if (p2p_prov_disc_req(wpa_s->global->p2p,
4315 wpa_s->pending_join_dev_addr,
4316 wpa_s->pending_pd_config_methods, join,
67527166 4317 0, wpa_s->user_initiated_pd) < 0) {
0918c4bf 4318 wpa_s->p2p_auto_pd = 0;
92c4465b
JM		 4319 wpa_msg_global(wpa_s, MSG_INFO,
4320 P2P_EVENT_PROV_DISC_FAILURE
4321 " p2p_dev_addr=" MACSTR " status=N/A",
4322 MAC2STR(wpa_s->pending_join_dev_addr));
0918c4bf
JM		 4323 }
4324 return;
4325 }
4326
b31be3a0 4327 if (wpa_s->p2p_auto_join) {
aa9bb764
JM		 4328 int join = wpas_p2p_peer_go(wpa_s,
4329 wpa_s->pending_join_dev_addr);
4330 if (join < 0) {
b31be3a0
JM		 4331 wpa_printf(MSG_DEBUG, "P2P: Peer was not found to be "
4332 "running a GO -> use GO Negotiation");
4333 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr,
4334 wpa_s->p2p_pin, wpa_s->p2p_wps_method,
4335 wpa_s->p2p_persistent_group, 0, 0, 0,
4336 wpa_s->p2p_go_intent,
23c84252 4337 wpa_s->p2p_connect_freq,
3bc462cb 4338 wpa_s->p2p_persistent_id,
e2308e4b 4339 wpa_s->p2p_pd_before_go_neg,
20ea1ca4
EP		 4340 wpa_s->p2p_go_ht40,
4341 wpa_s->p2p_go_vht);
b31be3a0
JM		 4342 return;
4343 }
4344
aa9bb764
JM		 4345 wpa_printf(MSG_DEBUG, "P2P: Peer was found running GO%s -> "
4346 "try to join the group", join ? "" :
4347 " in older scan");
4348 if (!join)
4349 wpa_s->p2p_fallback_to_go_neg = 1;
b31be3a0
JM		 4350 }
4351
f8d0131a
JM		 4352 freq = p2p_get_oper_freq(wpa_s->global->p2p,
4353 wpa_s->pending_join_iface_addr);
54960629
AL		 4354 if (freq < 0 &&
4355 p2p_get_interface_addr(wpa_s->global->p2p,
4356 wpa_s->pending_join_dev_addr,
4357 iface_addr) == 0 &&
4e536751
CM		 4358 os_memcmp(iface_addr, wpa_s->pending_join_dev_addr, ETH_ALEN) != 0
4359 && !wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr)) {
54960629
AL		 4360 wpa_printf(MSG_DEBUG, "P2P: Overwrite pending interface "
4361 "address for join from " MACSTR " to " MACSTR
4362 " based on newly discovered P2P peer entry",
4363 MAC2STR(wpa_s->pending_join_iface_addr),
4364 MAC2STR(iface_addr));
4365 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr,
4366 ETH_ALEN);
4367
4368 freq = p2p_get_oper_freq(wpa_s->global->p2p,
4369 wpa_s->pending_join_iface_addr);
4370 }
f8d0131a
JM		 4371 if (freq >= 0) {
4372 wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency "
4373 "from P2P peer table: %d MHz", freq);
4374 }
c48414af
JM		 4375 if (wpa_s->p2p_join_ssid_len) {
4376 wpa_printf(MSG_DEBUG, "P2P: Trying to find target GO BSS entry based on BSSID "
4377 MACSTR " and SSID %s",
4378 MAC2STR(wpa_s->pending_join_iface_addr),
4379 wpa_ssid_txt(wpa_s->p2p_join_ssid,
4380 wpa_s->p2p_join_ssid_len));
4381 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr,
4382 wpa_s->p2p_join_ssid,
4383 wpa_s->p2p_join_ssid_len);
4384 }
4385 if (!bss) {
4386 wpa_printf(MSG_DEBUG, "P2P: Trying to find target GO BSS entry based on BSSID "
4387 MACSTR, MAC2STR(wpa_s->pending_join_iface_addr));
4388 bss = wpa_bss_get_bssid_latest(wpa_s,
4389 wpa_s->pending_join_iface_addr);
4390 }
b22128ef 4391 if (bss) {
f8d0131a
JM		 4392 freq = bss->freq;
4393 wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency "
d2858883
JM		 4394 "from BSS table: %d MHz (SSID %s)", freq,
4395 wpa_ssid_txt(bss->ssid, bss->ssid_len));
f8d0131a
JM		 4396 }
4397 if (freq > 0) {
b22128ef
JM		 4398 u16 method;
4399
4b156206 4400 if (wpas_check_freq_conflict(wpa_s, freq) > 0) {
92c4465b
JM		 4401 wpa_msg_global(wpa_s->parent, MSG_INFO,
4402 P2P_EVENT_GROUP_FORMATION_FAILURE
4403 "reason=FREQ_CONFLICT");
4b156206
JM		 4404 return;
4405 }
4406
b22128ef
JM		 4407 wpa_printf(MSG_DEBUG, "P2P: Send Provision Discovery Request "
4408 "prior to joining an existing group (GO " MACSTR
4409 " freq=%u MHz)",
f8d0131a 4410 MAC2STR(wpa_s->pending_join_dev_addr), freq);
b22128ef
JM		 4411 wpa_s->pending_pd_before_join = 1;
4412
ef922c4a 4413 switch (wpa_s->pending_join_wps_method) {
b22128ef
JM		 4414 case WPS_PIN_DISPLAY:
4415 method = WPS_CONFIG_KEYPAD;
4416 break;
4417 case WPS_PIN_KEYPAD:
4418 method = WPS_CONFIG_DISPLAY;
4419 break;
4420 case WPS_PBC:
4421 method = WPS_CONFIG_PUSHBUTTON;
4422 break;
4423 default:
4424 method = 0;
4425 break;
4426 }
4427
ec437d9e
JJ		 4428 if ((p2p_get_provisioning_info(wpa_s->global->p2p,
4429 wpa_s->pending_join_dev_addr) ==
4430 method)) {
4431 /*
4432 * We have already performed provision discovery for
4433 * joining the group. Proceed directly to join
4434 * operation without duplicated provision discovery. */
e3a0706b 4435 wpa_printf(MSG_DEBUG, "P2P: Provision discovery "
ec437d9e
JJ		 4436 "with " MACSTR " already done - proceed to "
4437 "join",
4438 MAC2STR(wpa_s->pending_join_dev_addr));
4439 wpa_s->pending_pd_before_join = 0;
4440 goto start;
4441 }
4442
ef922c4a 4443 if (p2p_prov_disc_req(wpa_s->global->p2p,
1ef2f7ff 4444 wpa_s->pending_join_dev_addr, method, 1,
67527166 4445 freq, wpa_s->user_initiated_pd) < 0) {
b22128ef
JM		 4446 wpa_printf(MSG_DEBUG, "P2P: Failed to send Provision "
4447 "Discovery Request before joining an "
4448 "existing group");
4449 wpa_s->pending_pd_before_join = 0;
4450 goto start;
4451 }
ef922c4a 4452 return;
b22128ef
JM		 4453 }
4454
9b1ab931
JM		 4455 wpa_printf(MSG_DEBUG, "P2P: Failed to find BSS/GO - try again later");
4456 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
4457 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
4458 wpas_p2p_check_join_scan_limit(wpa_s);
4459 return;
b22128ef
JM		 4460
4461start:
4462 /* Start join operation immediately */
23318bea 4463 wpas_p2p_join_start(wpa_s, 0, NULL, 0);
ef922c4a
JM		 4464}
4465
4466
c48414af
JM		 4467static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq,
4468 const u8 *ssid, size_t ssid_len)
ef922c4a 4469{
ef922c4a
JM		 4470 int ret;
4471 struct wpa_driver_scan_params params;
4472 struct wpabuf *wps_ie, *ies;
206e1f42 4473 size_t ielen;
84286a22 4474 int freqs[2] = { 0, 0 };
ef922c4a
JM		 4475
4476 os_memset(&params, 0, sizeof(params));
4477
4478 /* P2P Wildcard SSID */
4479 params.num_ssids = 1;
c48414af
JM		 4480 if (ssid && ssid_len) {
4481 params.ssids[0].ssid = ssid;
4482 params.ssids[0].ssid_len = ssid_len;
4483 os_memcpy(wpa_s->p2p_join_ssid, ssid, ssid_len);
4484 wpa_s->p2p_join_ssid_len = ssid_len;
4485 } else {
4486 params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
4487 params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
4488 wpa_s->p2p_join_ssid_len = 0;
4489 }
ef922c4a
JM		 4490
4491 wpa_s->wps->dev.p2p = 1;
360182ed
JM		 4492 wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT, &wpa_s->wps->dev,
4493 wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 0,
4494 NULL);
ef922c4a
JM		 4495 if (wps_ie == NULL) {
4496 wpas_p2p_scan_res_join(wpa_s, NULL);
4497 return;
4498 }
4499
206e1f42
JM		 4500 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
4501 ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen);
ef922c4a
JM		 4502 if (ies == NULL) {
4503 wpabuf_free(wps_ie);
4504 wpas_p2p_scan_res_join(wpa_s, NULL);
4505 return;
4506 }
4507 wpabuf_put_buf(ies, wps_ie);
4508 wpabuf_free(wps_ie);
4509
6d92fa6e 4510 p2p_scan_ie(wpa_s->global->p2p, ies, NULL);
ef922c4a 4511
47185fc7 4512 params.p2p_probe = 1;
ef922c4a
JM		 4513 params.extra_ies = wpabuf_head(ies);
4514 params.extra_ies_len = wpabuf_len(ies);
37b4198a
JJ		 4515
4516 if (!freq) {
4517 int oper_freq;
4518 /*
4519 * If freq is not provided, check the operating freq of the GO
4520 * and use a single channel scan on if possible.
4521 */
4522 oper_freq = p2p_get_oper_freq(wpa_s->global->p2p,
4523 wpa_s->pending_join_iface_addr);
4524 if (oper_freq > 0)
4525 freq = oper_freq;
4526 }
84286a22
SDU		 4527 if (freq > 0) {
4528 freqs[0] = freq;
4529 params.freqs = freqs;
4530 }
ef922c4a
JM		 4531
4532 /*
4533 * Run a scan to update BSS table and start Provision Discovery once
4534 * the new scan results become available.
4535 */
17fbb751 4536 ret = wpa_drv_scan(wpa_s, &params);
4342326f 4537 if (!ret) {
acb69cec 4538 os_get_reltime(&wpa_s->scan_trigger_time);
205e6474 4539 wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
a5f40eff 4540 wpa_s->own_scan_requested = 1;
4342326f 4541 }
ef922c4a
JM		 4542
4543 wpabuf_free(ies);
4544
4545 if (ret) {
4546 wpa_printf(MSG_DEBUG, "P2P: Failed to start scan for join - "
4547 "try again later");
4548 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
4549 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
9b1ab931 4550 wpas_p2p_check_join_scan_limit(wpa_s);
ef922c4a
JM		 4551 }
4552}
4553
4554
84286a22
SDU		 4555static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx)
4556{
4557 struct wpa_supplicant *wpa_s = eloop_ctx;
c48414af 4558 wpas_p2p_join_scan_req(wpa_s, 0, NULL, 0);
84286a22
SDU		 4559}
4560
4561
ef922c4a 4562static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
b31be3a0 4563 const u8 *dev_addr, enum p2p_wps_method wps_method,
23318bea
JM		 4564 int auto_join, int op_freq,
4565 const u8 *ssid, size_t ssid_len)
ef922c4a
JM		 4566{
4567 wpa_printf(MSG_DEBUG, "P2P: Request to join existing group (iface "
23318bea
JM		 4568 MACSTR " dev " MACSTR " op_freq=%d)%s",
4569 MAC2STR(iface_addr), MAC2STR(dev_addr), op_freq,
b31be3a0 4570 auto_join ? " (auto_join)" : "");
c48414af
JM		 4571 if (ssid && ssid_len) {
4572 wpa_printf(MSG_DEBUG, "P2P: Group SSID specified: %s",
4573 wpa_ssid_txt(ssid, ssid_len));
4574 }
ef922c4a 4575
0918c4bf 4576 wpa_s->p2p_auto_pd = 0;
b31be3a0 4577 wpa_s->p2p_auto_join = !!auto_join;
ef922c4a
JM		 4578 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
4579 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
4580 wpa_s->pending_join_wps_method = wps_method;
4581
4582 /* Make sure we are not running find during connection establishment */
4583 wpas_p2p_stop_find(wpa_s);
4584
9b1ab931 4585 wpa_s->p2p_join_scan_count = 0;
23318bea 4586 wpas_p2p_join_scan_req(wpa_s, op_freq, ssid, ssid_len);
ef922c4a 4587 return 0;
b22128ef
JM		 4588}
4589
4590
23318bea
JM		 4591static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq,
4592 const u8 *ssid, size_t ssid_len)
b22128ef
JM		 4593{
4594 struct wpa_supplicant *group;
4595 struct p2p_go_neg_results res;
8e64f258 4596 struct wpa_bss *bss;
b22128ef
JM		 4597
4598 group = wpas_p2p_get_group_iface(wpa_s, 0, 0);
4599 if (group == NULL)
4600 return -1;
3c5126a4 4601 if (group != wpa_s) {
b22128ef
JM		 4602 os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
4603 sizeof(group->p2p_pin));
3c5126a4 4604 group->p2p_wps_method = wpa_s->p2p_wps_method;
2b79164f
JM		 4605 } else {
4606 /*
4607 * Need to mark the current interface for p2p_group_formation
4608 * when a separate group interface is not used. This is needed
4609 * to allow p2p_cancel stop a pending p2p_connect-join.
4610 * wpas_p2p_init_group_interface() addresses this for the case
4611 * where a separate group interface is used.
4612 */
4613 wpa_s->global->p2p_group_formation = wpa_s;
3c5126a4 4614 }
b22128ef
JM		 4615
4616 group->p2p_in_provisioning = 1;
aa9bb764 4617 group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg;
b22128ef
JM		 4618
4619 os_memset(&res, 0, sizeof(res));
23318bea 4620 os_memcpy(res.peer_device_addr, wpa_s->pending_join_dev_addr, ETH_ALEN);
b22128ef
JM		 4621 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
4622 ETH_ALEN);
4623 res.wps_method = wpa_s->pending_join_wps_method;
23318bea
JM		 4624 if (freq && ssid && ssid_len) {
4625 res.freq = freq;
4626 res.ssid_len = ssid_len;
4627 os_memcpy(res.ssid, ssid, ssid_len);
4628 } else {
4629 bss = wpa_bss_get_bssid_latest(wpa_s,
4630 wpa_s->pending_join_iface_addr);
4631 if (bss) {
4632 res.freq = bss->freq;
4633 res.ssid_len = bss->ssid_len;
4634 os_memcpy(res.ssid, bss->ssid, bss->ssid_len);
4635 wpa_printf(MSG_DEBUG, "P2P: Join target GO operating frequency from BSS table: %d MHz (SSID %s)",
4636 bss->freq,
4637 wpa_ssid_txt(bss->ssid, bss->ssid_len));
4638 }
8e64f258
JM		 4639 }
4640
e91829f9
JM		 4641 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
4642 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel prior to "
4643 "starting client");
4644 wpa_drv_cancel_remain_on_channel(wpa_s);
4645 wpa_s->off_channel_freq = 0;
4646 wpa_s->roc_waiting_drv_freq = 0;
4647 }
b22128ef
JM		 4648 wpas_start_wps_enrollee(group, &res);
4649
3094d483
JM		 4650 /*
4651 * Allow a longer timeout for join-a-running-group than normal 15
4652 * second group formation timeout since the GO may not have authorized
4653 * our connection yet.
4654 */
4655 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
4656 eloop_register_timeout(60, 0, wpas_p2p_group_formation_timeout,
4657 wpa_s, NULL);
4658
b22128ef
JM		 4659 return 0;
4660}
4661
4662
5de4b721 4663static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq,
51e9f228 4664 int *force_freq, int *pref_freq, int go)
5de4b721 4665{
a0c90bb0
IP		 4666 struct wpa_used_freq_data *freqs;
4667 int res, best_freq, num_unused;
0d08efa4
IP		 4668 unsigned int freq_in_use = 0, num, i;
4669
a0c90bb0
IP		 4670 freqs = os_calloc(wpa_s->num_multichan_concurrent,
4671 sizeof(struct wpa_used_freq_data));
0d08efa4
IP		 4672 if (!freqs)
4673 return -1;
4674
a0c90bb0
IP		 4675 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
4676 wpa_s->num_multichan_concurrent);
4677
4678 /*
4679 * It is possible that the total number of used frequencies is bigger
4680 * than the number of frequencies used for P2P, so get the system wide
4681 * number of unused frequencies.
4682 */
4683 num_unused = wpas_p2p_num_unused_channels(wpa_s);
4684
99d7c762 4685 wpa_printf(MSG_DEBUG,
a0c90bb0
IP		 4686 "P2P: Setup freqs: freq=%d num_MCC=%d shared_freqs=%u num_unused=%d",
4687 freq, wpa_s->num_multichan_concurrent, num, num_unused);
0d08efa4 4688
5de4b721 4689 if (freq > 0) {
51e9f228
JM		 4690 int ret;
4691 if (go)
4692 ret = p2p_supported_freq(wpa_s->global->p2p, freq);
4693 else
4694 ret = p2p_supported_freq_cli(wpa_s->global->p2p, freq);
4695 if (!ret) {
5de4b721
JM		 4696 wpa_printf(MSG_DEBUG, "P2P: The forced channel "
4697 "(%u MHz) is not supported for P2P uses",
4698 freq);
0d08efa4
IP		 4699 res = -3;
4700 goto exit_free;
5de4b721
JM		 4701 }
4702
0d08efa4 4703 for (i = 0; i < num; i++) {
a0c90bb0 4704 if (freqs[i].freq == freq)
0d08efa4
IP		 4705 freq_in_use = 1;
4706 }
4707
a0c90bb0 4708 if (num_unused <= 0 && !freq_in_use) {
0d08efa4
IP		 4709 wpa_printf(MSG_DEBUG, "P2P: Cannot start P2P group on %u MHz as there are no available channels",
4710 freq);
4711 res = -2;
4712 goto exit_free;
5de4b721
JM		 4713 }
4714 wpa_printf(MSG_DEBUG, "P2P: Trying to force us to use the "
4715 "requested channel (%u MHz)", freq);
4716 *force_freq = freq;
0d08efa4
IP		 4717 goto exit_ok;
4718 }
4719
a0c90bb0 4720 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
0d08efa4 4721
a0c90bb0
IP		 4722 /* We have a candidate frequency to use */
4723 if (best_freq > 0) {
4724 if (*pref_freq == 0 && num_unused > 0) {
b17d89bd 4725 wpa_printf(MSG_DEBUG, "P2P: Try to prefer a frequency (%u MHz) we are already using",
a0c90bb0
IP		 4726 best_freq);
4727 *pref_freq = best_freq;
b17d89bd
JM		 4728 } else {
4729 wpa_printf(MSG_DEBUG, "P2P: Try to force us to use frequency (%u MHz) which is already in use",
a0c90bb0
IP		 4730 best_freq);
4731 *force_freq = best_freq;
0d08efa4 4732 }
a0c90bb0
IP		 4733 } else if (num_unused > 0) {
4734 wpa_printf(MSG_DEBUG,
4735 "P2P: Current operating channels are not available for P2P. Try to use another channel");
4736 *force_freq = 0;
4737 } else {
4738 wpa_printf(MSG_DEBUG,
4739 "P2P: All channels are in use and none of them are P2P enabled. Cannot start P2P group");
4740 res = -2;
4741 goto exit_free;
0d08efa4
IP		 4742 }
4743
4744exit_ok:
4745 res = 0;
4746exit_free:
4747 os_free(freqs);
4748 return res;
5de4b721
JM		 4749}
4750
4751
b22128ef
JM		 4752/**
4753 * wpas_p2p_connect - Request P2P Group Formation to be started
4754 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4755 * @peer_addr: Address of the peer P2P Device
4756 * @pin: PIN to use during provisioning or %NULL to indicate PBC mode
4757 * @persistent_group: Whether to create a persistent group
b31be3a0 4758 * @auto_join: Whether to select join vs. GO Negotiation automatically
b22128ef
JM		 4759 * @join: Whether to join an existing group (as a client) instead of starting
4760 * Group Owner negotiation; @peer_addr is BSSID in that case
4761 * @auth: Whether to only authorize the connection instead of doing that and
4762 * initiating Group Owner negotiation
4763 * @go_intent: GO Intent or -1 to use default
4764 * @freq: Frequency for the group or 0 for auto-selection
23c84252
JM		 4765 * @persistent_id: Persistent group credentials to use for forcing GO
4766 * parameters or -1 to generate new values (SSID/passphrase)
3bc462cb
JM		 4767 * @pd: Whether to send Provision Discovery prior to GO Negotiation as an
4768 * interoperability workaround when initiating group formation
e2308e4b 4769 * @ht40: Start GO with 40 MHz channel width
20ea1ca4 4770 * @vht: Start GO with VHT support
d054a462
JM		 4771 * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on unspecified
4772 * failure, -2 on failure due to channel not currently available,
4773 * -3 if forced channel is not supported
b22128ef
JM		 4774 */
4775int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
4776 const char *pin, enum p2p_wps_method wps_method,
b31be3a0 4777 int persistent_group, int auto_join, int join, int auth,
e2308e4b 4778 int go_intent, int freq, int persistent_id, int pd,
20ea1ca4 4779 int ht40, int vht)
b22128ef 4780{
0d08efa4 4781 int force_freq = 0, pref_freq = 0;
5de4b721 4782 int ret = 0, res;
b22128ef 4783 enum wpa_driver_if_type iftype;
6cad95db 4784 const u8 *if_addr;
23c84252 4785 struct wpa_ssid *ssid = NULL;
b22128ef 4786
9526fd29
JM		 4787 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4788 return -1;
4789
23c84252
JM		 4790 if (persistent_id >= 0) {
4791 ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
4792 if (ssid == NULL || ssid->disabled != 2 ||
4793 ssid->mode != WPAS_MODE_P2P_GO)
4794 return -1;
4795 }
4796
01a57fe4
JM		 4797 os_free(wpa_s->global->add_psk);
4798 wpa_s->global->add_psk = NULL;
4799
95fb2db2
JM		 4800 wpa_s->global->p2p_fail_on_wps_complete = 0;
4801
b22128ef
JM		 4802 if (go_intent < 0)
4803 go_intent = wpa_s->conf->p2p_go_intent;
4804
4805 if (!auth)
4806 wpa_s->p2p_long_listen = 0;
4807
3c5126a4 4808 wpa_s->p2p_wps_method = wps_method;
b31be3a0 4809 wpa_s->p2p_persistent_group = !!persistent_group;
23c84252 4810 wpa_s->p2p_persistent_id = persistent_id;
b31be3a0
JM		 4811 wpa_s->p2p_go_intent = go_intent;
4812 wpa_s->p2p_connect_freq = freq;
aa9bb764 4813 wpa_s->p2p_fallback_to_go_neg = 0;
3bc462cb 4814 wpa_s->p2p_pd_before_go_neg = !!pd;
e2308e4b 4815 wpa_s->p2p_go_ht40 = !!ht40;
20ea1ca4 4816 wpa_s->p2p_go_vht = !!vht;
3c5126a4 4817
b22128ef
JM		 4818 if (pin)
4819 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
4820 else if (wps_method == WPS_PIN_DISPLAY) {
4821 ret = wps_generate_pin();
4822 os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin), "%08d",
4823 ret);
4824 wpa_printf(MSG_DEBUG, "P2P: Randomly generated PIN: %s",
4825 wpa_s->p2p_pin);
4826 } else
4827 wpa_s->p2p_pin[0] = '\0';
4828
b31be3a0 4829 if (join || auto_join) {
4147a2cc 4830 u8 iface_addr[ETH_ALEN], dev_addr[ETH_ALEN];
108def93
JM		 4831 if (auth) {
4832 wpa_printf(MSG_DEBUG, "P2P: Authorize invitation to "
4833 "connect a running group from " MACSTR,
4834 MAC2STR(peer_addr));
4835 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
4836 return ret;
4837 }
4147a2cc 4838 os_memcpy(dev_addr, peer_addr, ETH_ALEN);
b22128ef 4839 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
4147a2cc 4840 iface_addr) < 0) {
b22128ef 4841 os_memcpy(iface_addr, peer_addr, ETH_ALEN);
4147a2cc
JM		 4842 p2p_get_dev_addr(wpa_s->global->p2p, peer_addr,
4843 dev_addr);
4844 }
b31be3a0 4845 if (auto_join) {
acb69cec 4846 os_get_reltime(&wpa_s->p2p_auto_started);
b31be3a0
JM		 4847 wpa_printf(MSG_DEBUG, "P2P: Auto join started at "
4848 "%ld.%06ld",
4849 wpa_s->p2p_auto_started.sec,
4850 wpa_s->p2p_auto_started.usec);
4851 }
67527166 4852 wpa_s->user_initiated_pd = 1;
b31be3a0 4853 if (wpas_p2p_join(wpa_s, iface_addr, dev_addr, wps_method,
23318bea 4854 auto_join, freq, NULL, 0) < 0)
b22128ef
JM		 4855 return -1;
4856 return ret;
4857 }
4858
51e9f228
JM		 4859 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
4860 go_intent == 15);
5de4b721
JM		 4861 if (res)
4862 return res;
1b665cbf
JM		 4863 wpas_p2p_set_own_freq_preference(wpa_s,
4864 force_freq ? force_freq : pref_freq);
b22128ef
JM		 4865
4866 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
4867
6cad95db
JB		 4868 if (wpa_s->create_p2p_iface) {
4869 /* Prepare to add a new interface for the group */
4870 iftype = WPA_IF_P2P_GROUP;
4871 if (go_intent == 15)
4872 iftype = WPA_IF_P2P_GO;
4873 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
4874 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
4875 "interface for the group");
b22128ef 4876 return -1;
6cad95db 4877 }
b22128ef 4878
6cad95db
JB		 4879 if_addr = wpa_s->pending_interface_addr;
4880 } else
4881 if_addr = wpa_s->own_addr;
b22128ef
JM		 4882
4883 if (auth) {
4884 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
6cad95db 4885 go_intent, if_addr,
04a3e69d
JM		 4886 force_freq, persistent_group, ssid,
4887 pref_freq) < 0)
b22128ef
JM		 4888 return -1;
4889 return ret;
4890 }
6cad95db
JB		 4891
4892 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method,
4893 go_intent, if_addr, force_freq,
04a3e69d 4894 persistent_group, ssid, pref_freq) < 0) {
6cad95db
JB		 4895 if (wpa_s->create_p2p_iface)
4896 wpas_p2p_remove_pending_group_interface(wpa_s);
b22128ef
JM		 4897 return -1;
4898 }
4899 return ret;
4900}
4901
4902
4903/**
4904 * wpas_p2p_remain_on_channel_cb - Indication of remain-on-channel start
4905 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4906 * @freq: Frequency of the channel in MHz
4907 * @duration: Duration of the stay on the channel in milliseconds
4908 *
4909 * This callback is called when the driver indicates that it has started the
4910 * requested remain-on-channel duration.
4911 */
4912void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
4913 unsigned int freq, unsigned int duration)
4914{
9526fd29
JM		 4915 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4916 return;
b22128ef
JM		 4917 if (wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
4918 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
4919 wpa_s->pending_listen_duration);
4920 wpa_s->pending_listen_freq = 0;
211d7ab3
JM		 4921 } else {
4922 wpa_printf(MSG_DEBUG, "P2P: Ignore remain-on-channel callback (off_channel_freq=%u pending_listen_freq=%d freq=%u duration=%u)",
4923 wpa_s->off_channel_freq, wpa_s->pending_listen_freq,
4924 freq, duration);
b22128ef
JM		 4925 }
4926}
4927
4928
4929static int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s,
4930 unsigned int timeout)
4931{
4932 /* Limit maximum Listen state time based on driver limitation. */
4933 if (timeout > wpa_s->max_remain_on_chan)
4934 timeout = wpa_s->max_remain_on_chan;
4935
4936 return p2p_listen(wpa_s->global->p2p, timeout);
4937}
4938
4939
4940/**
4941 * wpas_p2p_cancel_remain_on_channel_cb - Remain-on-channel timeout
4942 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4943 * @freq: Frequency of the channel in MHz
4944 *
4945 * This callback is called when the driver indicates that a remain-on-channel
4946 * operation has been completed, i.e., the duration on the requested channel
4947 * has timed out.
4948 */
4949void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
4950 unsigned int freq)
4951{
1cc3a29d 4952 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel callback "
11fb02be 4953 "(p2p_long_listen=%d ms pending_action_tx=%p)",
2f3101d8 4954 wpa_s->p2p_long_listen, offchannel_pending_action_tx(wpa_s));
e1d1c8e2 4955 wpas_p2p_listen_work_done(wpa_s);
9526fd29
JM		 4956 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
4957 return;
b22128ef
JM		 4958 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
4959 return; /* P2P module started a new operation */
2f3101d8 4960 if (offchannel_pending_action_tx(wpa_s))
b22128ef
JM		 4961 return;
4962 if (wpa_s->p2p_long_listen > 0)
11fb02be 4963 wpa_s->p2p_long_listen -= wpa_s->max_remain_on_chan;
b22128ef
JM		 4964 if (wpa_s->p2p_long_listen > 0) {
4965 wpa_printf(MSG_DEBUG, "P2P: Continuing long Listen state");
11fb02be 4966 wpas_p2p_listen_start(wpa_s, wpa_s->p2p_long_listen);
0b5fb86a
SADR		 4967 } else {
4968 /*
4969 * When listen duration is over, stop listen & update p2p_state
4970 * to IDLE.
4971 */
4972 p2p_stop_listen(wpa_s->global->p2p);
b22128ef
JM		 4973 }
4974}
4975
4976
4977/**
4978 * wpas_p2p_group_remove - Remove a P2P group
4979 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
4980 * @ifname: Network interface name of the group interface or "*" to remove all
4981 * groups
4982 * Returns: 0 on success, -1 on failure
4983 *
4984 * This function is used to remove a P2P group. This can be used to disconnect
4985 * from a group in which the local end is a P2P Client or to end a P2P Group in
4986 * case the local end is the Group Owner. If a virtual network interface was
4987 * created for this group, that interface will be removed. Otherwise, only the
4988 * configured P2P group network will be removed from the interface.
4989 */
4990int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname)
4991{
4992 struct wpa_global *global = wpa_s->global;
4993
4994 if (os_strcmp(ifname, "*") == 0) {
4995 struct wpa_supplicant *prev;
4996 wpa_s = global->ifaces;
4997 while (wpa_s) {
4998 prev = wpa_s;
4999 wpa_s = wpa_s->next;
d99ca89d
IP		 5000 if (prev->p2p_group_interface !=
5001 NOT_P2P_GROUP_INTERFACE ||
5002 (prev->current_ssid &&
5003 prev->current_ssid->p2p_group))
5004 wpas_p2p_disconnect(prev);
b22128ef
JM		 5005 }
5006 return 0;
5007 }
5008
5009 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5010 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5011 break;
5012 }
5013
3103f345 5014 return wpas_p2p_disconnect(wpa_s);
b22128ef
JM		 5015}
5016
5017
4abc0424
WJL		 5018static int wpas_p2p_select_go_freq(struct wpa_supplicant *wpa_s, int freq)
5019{
5020 unsigned int r;
5021
5022 if (freq == 2) {
5023 wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 2.4 GHz "
5024 "band");
5025 if (wpa_s->best_24_freq > 0 &&
556b30da
JM		 5026 p2p_supported_freq_go(wpa_s->global->p2p,
5027 wpa_s->best_24_freq)) {
4abc0424
WJL		 5028 freq = wpa_s->best_24_freq;
5029 wpa_printf(MSG_DEBUG, "P2P: Use best 2.4 GHz band "
5030 "channel: %d MHz", freq);
5031 } else {
df2508d7
JM		 5032 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
5033 return -1;
4abc0424
WJL		 5034 freq = 2412 + (r % 3) * 25;
5035 wpa_printf(MSG_DEBUG, "P2P: Use random 2.4 GHz band "
5036 "channel: %d MHz", freq);
5037 }
5038 }
5039
5040 if (freq == 5) {
5041 wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 5 GHz "
5042 "band");
5043 if (wpa_s->best_5_freq > 0 &&
556b30da 5044 p2p_supported_freq_go(wpa_s->global->p2p,
4abc0424
WJL		 5045 wpa_s->best_5_freq)) {
5046 freq = wpa_s->best_5_freq;
5047 wpa_printf(MSG_DEBUG, "P2P: Use best 5 GHz band "
5048 "channel: %d MHz", freq);
5049 } else {
df2508d7
JM		 5050 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
5051 return -1;
4abc0424 5052 freq = 5180 + (r % 4) * 20;
556b30da 5053 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
4abc0424
WJL		 5054 wpa_printf(MSG_DEBUG, "P2P: Could not select "
5055 "5 GHz channel for P2P group");
5056 return -1;
5057 }
5058 wpa_printf(MSG_DEBUG, "P2P: Use random 5 GHz band "
5059 "channel: %d MHz", freq);
5060 }
5061 }
5062
556b30da 5063 if (freq > 0 && !p2p_supported_freq_go(wpa_s->global->p2p, freq)) {
4abc0424
WJL		 5064 wpa_printf(MSG_DEBUG, "P2P: The forced channel for GO "
5065 "(%u MHz) is not supported for P2P uses",
5066 freq);
5067 return -1;
5068 }
5069
5070 return freq;
5071}
5072
5073
28812a89
IP		 5074static int wpas_p2p_select_freq_no_pref(struct wpa_supplicant *wpa_s,
5075 struct p2p_go_neg_results *params,
5076 const struct p2p_channels *channels)
5077{
5078 unsigned int i, r;
5079
5080 /* first try some random selection of the social channels */
5e62cfdf
JM		 5081 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
5082 return -1;
28812a89
IP		 5083
5084 for (i = 0; i < 3; i++) {
5085 params->freq = 2412 + ((r + i) % 3) * 25;
5086 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) &&
5087 freq_included(channels, params->freq))
5088 goto out;
5089 }
5090
5091 /* try all channels in reg. class 81 */
5092 for (i = 0; i < 11; i++) {
5093 params->freq = 2412 + i * 5;
5094 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) &&
5095 freq_included(channels, params->freq))
5096 goto out;
5097 }
5098
5099 wpa_printf(MSG_DEBUG, "P2P: No 2.4 GHz channel allowed");
5100 return -1;
5101out:
5102 wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz (no preference known)",
5103 params->freq);
5104 return 0;
5105}
5106
5107
b8349523
NKG		 5108static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
5109 struct p2p_go_neg_results *params,
20ea1ca4 5110 int freq, int ht40, int vht,
54733624 5111 const struct p2p_channels *channels)
b22128ef 5112{
a0c90bb0
IP		 5113 struct wpa_used_freq_data *freqs;
5114 unsigned int pref_freq, cand_freq;
0d08efa4 5115 unsigned int num, i;
b22128ef
JM		 5116
5117 os_memset(params, 0, sizeof(*params));
5118 params->role_go = 1;
7aeac985 5119 params->ht40 = ht40;
20ea1ca4 5120 params->vht = vht;
7cfc4ac3 5121 if (freq) {
54733624
JM		 5122 if (!freq_included(channels, freq)) {
5123 wpa_printf(MSG_DEBUG, "P2P: Forced GO freq %d MHz not "
5124 "accepted", freq);
5125 return -1;
5126 }
7cfc4ac3
AGS		 5127 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on forced "
5128 "frequency %d MHz", freq);
b22128ef 5129 params->freq = freq;
7cfc4ac3
AGS		 5130 } else if (wpa_s->conf->p2p_oper_reg_class == 81 &&
5131 wpa_s->conf->p2p_oper_channel >= 1 &&
54733624
JM		 5132 wpa_s->conf->p2p_oper_channel <= 11 &&
5133 freq_included(channels,
5134 2407 + 5 * wpa_s->conf->p2p_oper_channel)) {
b22128ef 5135 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
7cfc4ac3
AGS		 5136 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured "
5137 "frequency %d MHz", params->freq);
54733624
JM		 5138 } else if ((wpa_s->conf->p2p_oper_reg_class == 115 ||
5139 wpa_s->conf->p2p_oper_reg_class == 116 ||
5140 wpa_s->conf->p2p_oper_reg_class == 117 ||
5141 wpa_s->conf->p2p_oper_reg_class == 124 ||
5142 wpa_s->conf->p2p_oper_reg_class == 126 ||
5143 wpa_s->conf->p2p_oper_reg_class == 127) &&
5144 freq_included(channels,
5145 5000 + 5 * wpa_s->conf->p2p_oper_channel)) {
b22128ef 5146 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
7cfc4ac3
AGS		 5147 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured "
5148 "frequency %d MHz", params->freq);
5149 } else if (wpa_s->conf->p2p_oper_channel == 0 &&
5150 wpa_s->best_overall_freq > 0 &&
556b30da
JM		 5151 p2p_supported_freq_go(wpa_s->global->p2p,
5152 wpa_s->best_overall_freq) &&
54733624 5153 freq_included(channels, wpa_s->best_overall_freq)) {
7cfc4ac3
AGS		 5154 params->freq = wpa_s->best_overall_freq;
5155 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best overall "
5156 "channel %d MHz", params->freq);
5157 } else if (wpa_s->conf->p2p_oper_channel == 0 &&
5158 wpa_s->best_24_freq > 0 &&
556b30da
JM		 5159 p2p_supported_freq_go(wpa_s->global->p2p,
5160 wpa_s->best_24_freq) &&
54733624 5161 freq_included(channels, wpa_s->best_24_freq)) {
7cfc4ac3
AGS		 5162 params->freq = wpa_s->best_24_freq;
5163 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 2.4 GHz "
5164 "channel %d MHz", params->freq);
5165 } else if (wpa_s->conf->p2p_oper_channel == 0 &&
5166 wpa_s->best_5_freq > 0 &&
556b30da
JM		 5167 p2p_supported_freq_go(wpa_s->global->p2p,
5168 wpa_s->best_5_freq) &&
54733624 5169 freq_included(channels, wpa_s->best_5_freq)) {
7cfc4ac3
AGS		 5170 params->freq = wpa_s->best_5_freq;
5171 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 5 GHz "
5172 "channel %d MHz", params->freq);
c6ccf12d
SS		 5173 } else if ((pref_freq = p2p_get_pref_freq(wpa_s->global->p2p,
5174 channels))) {
5175 params->freq = pref_freq;
5176 wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz from preferred "
5177 "channels", params->freq);
7cfc4ac3 5178 } else {
28812a89
IP		 5179 /* no preference, select some channel */
5180 if (wpas_p2p_select_freq_no_pref(wpa_s, params, channels) < 0)
6f3bc72b 5181 return -1;
7cfc4ac3
AGS		 5182 }
5183
a0c90bb0
IP		 5184 freqs = os_calloc(wpa_s->num_multichan_concurrent,
5185 sizeof(struct wpa_used_freq_data));
0d08efa4
IP		 5186 if (!freqs)
5187 return -1;
5188
a0c90bb0 5189 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs,
0d08efa4 5190 wpa_s->num_multichan_concurrent);
0d08efa4 5191
a0c90bb0
IP		 5192 cand_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num);
5193
5194 /* First try the best used frequency if possible */
5195 if (!freq && cand_freq > 0 && freq_included(channels, cand_freq)) {
5196 params->freq = cand_freq;
5197 } else if (!freq) {
5198 /* Try any of the used frequencies */
5199 for (i = 0; i < num; i++) {
5200 if (freq_included(channels, freqs[i].freq)) {
5201 wpa_printf(MSG_DEBUG, "P2P: Force GO on a channel we are already using (%u MHz)",
5202 freqs[i].freq);
5203 params->freq = freqs[i].freq;
5204 break;
5205 }
54733624 5206 }
b8349523 5207
a0c90bb0
IP		 5208 if (i == num) {
5209 if (wpas_p2p_num_unused_channels(wpa_s) <= 0) {
7d669cf7 5210 wpa_printf(MSG_DEBUG, "P2P: Cannot force GO on any of the channels we are already using");
a0c90bb0
IP		 5211 os_free(freqs);
5212 return -1;
5213 } else {
5214 wpa_printf(MSG_DEBUG, "P2P: Cannot force GO on any of the channels we are already using. Use one of the free channels");
5215 }
5216 }
5217 } else {
5218 for (i = 0; i < num; i++) {
5219 if (freqs[i].freq == freq)
5220 break;
5221 }
5222
5223 if (i == num) {
5224 if (wpas_p2p_num_unused_channels(wpa_s) <= 0) {
5225 if (freq)
5226 wpa_printf(MSG_DEBUG, "P2P: Cannot force GO on freq (%u MHz) as all the channels are in use", freq);
5227 os_free(freqs);
5228 return -1;
5229 } else {
5230 wpa_printf(MSG_DEBUG, "P2P: Use one of the free channels");
5231 }
0d08efa4
IP		 5232 }
5233 }
7d669cf7 5234
0d08efa4 5235 os_free(freqs);
b8349523 5236 return 0;
b22128ef
JM		 5237}
5238
5239
5240static struct wpa_supplicant *
5241wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
5242 int go)
5243{
5244 struct wpa_supplicant *group_wpa_s;
5245
ac06fb12
JM		 5246 if (!wpas_p2p_create_iface(wpa_s)) {
5247 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use same interface for group "
5248 "operations");
bbc6c729 5249 wpa_s->p2p_first_connection_timeout = 0;
b22128ef 5250 return wpa_s;
ac06fb12 5251 }
b22128ef
JM		 5252
5253 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
ac06fb12 5254 WPA_IF_P2P_CLIENT) < 0) {
92c4465b
JM		 5255 wpa_msg_global(wpa_s, MSG_ERROR,
5256 "P2P: Failed to add group interface");
b22128ef 5257 return NULL;
ac06fb12 5258 }
b22128ef
JM		 5259 group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go);
5260 if (group_wpa_s == NULL) {
92c4465b
JM		 5261 wpa_msg_global(wpa_s, MSG_ERROR,
5262 "P2P: Failed to initialize group interface");
b22128ef
JM		 5263 wpas_p2p_remove_pending_group_interface(wpa_s);
5264 return NULL;
5265 }
5266
ac06fb12
JM		 5267 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use separate group interface %s",
5268 group_wpa_s->ifname);
bbc6c729 5269 group_wpa_s->p2p_first_connection_timeout = 0;
b22128ef
JM		 5270 return group_wpa_s;
5271}
5272
5273
5274/**
5275 * wpas_p2p_group_add - Add a new P2P group with local end as Group Owner
5276 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
5277 * @persistent_group: Whether to create a persistent group
5278 * @freq: Frequency for the group or 0 to indicate no hardcoding
20ea1ca4
EP		 5279 * @ht40: Start GO with 40 MHz channel width
5280 * @vht: Start GO with VHT support
b22128ef
JM		 5281 * Returns: 0 on success, -1 on failure
5282 *
5283 * This function creates a new P2P group with the local end as the Group Owner,
5284 * i.e., without using Group Owner Negotiation.
5285 */
5286int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
20ea1ca4 5287 int freq, int ht40, int vht)
b22128ef
JM		 5288{
5289 struct p2p_go_neg_results params;
7cfc4ac3 5290
9526fd29
JM		 5291 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5292 return -1;
5293
01a57fe4
JM		 5294 os_free(wpa_s->global->add_psk);
5295 wpa_s->global->add_psk = NULL;
5296
2d4f15d6
JJ		 5297 /* Make sure we are not running find during connection establishment */
5298 wpa_printf(MSG_DEBUG, "P2P: Stop any on-going P2P FIND");
8713a2e6 5299 wpas_p2p_stop_find_oper(wpa_s);
2d4f15d6 5300
4abc0424
WJL		 5301 freq = wpas_p2p_select_go_freq(wpa_s, freq);
5302 if (freq < 0)
4ae4650b 5303 return -1;
4ae4650b 5304
20ea1ca4 5305 if (wpas_p2p_init_go_params(wpa_s, &params, freq, ht40, vht, NULL))
b8349523 5306 return -1;
f4329aa2 5307 if (params.freq &&
556b30da 5308 !p2p_supported_freq_go(wpa_s->global->p2p, params.freq)) {
f4329aa2
JM		 5309 wpa_printf(MSG_DEBUG, "P2P: The selected channel for GO "
5310 "(%u MHz) is not supported for P2P uses",
5311 params.freq);
5312 return -1;
5313 }
b22128ef
JM		 5314 p2p_go_params(wpa_s->global->p2p, &params);
5315 params.persistent_group = persistent_group;
5316
5317 wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
5318 if (wpa_s == NULL)
5319 return -1;
5320 wpas_start_wps_go(wpa_s, &params, 0);
5321
5322 return 0;
5323}
5324
5325
5326static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s,
41d5ce9e
RR		 5327 struct wpa_ssid *params, int addr_allocated,
5328 int freq)
b22128ef
JM		 5329{
5330 struct wpa_ssid *ssid;
5331
5332 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0);
5333 if (wpa_s == NULL)
5334 return -1;
5bf9a6c8 5335 wpa_s->p2p_last_4way_hs_fail = NULL;
b22128ef
JM		 5336
5337 wpa_supplicant_ap_deinit(wpa_s);
5338
5339 ssid = wpa_config_add_network(wpa_s->conf);
5340 if (ssid == NULL)
5341 return -1;
b22128ef
JM		 5342 wpa_config_set_network_defaults(ssid);
5343 ssid->temporary = 1;
5344 ssid->proto = WPA_PROTO_RSN;
5345 ssid->pairwise_cipher = WPA_CIPHER_CCMP;
5346 ssid->group_cipher = WPA_CIPHER_CCMP;
5347 ssid->key_mgmt = WPA_KEY_MGMT_PSK;
5348 ssid->ssid = os_malloc(params->ssid_len);
5349 if (ssid->ssid == NULL) {
b22128ef
JM		 5350 wpa_config_remove_network(wpa_s->conf, ssid->id);
5351 return -1;
5352 }
5353 os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
5354 ssid->ssid_len = params->ssid_len;
5355 ssid->p2p_group = 1;
d1c8ac88 5356 ssid->export_keys = 1;
b22128ef
JM		 5357 if (params->psk_set) {
5358 os_memcpy(ssid->psk, params->psk, 32);
5359 ssid->psk_set = 1;
5360 }
5361 if (params->passphrase)
5362 ssid->passphrase = os_strdup(params->passphrase);
5363
b22128ef 5364 wpa_s->show_group_started = 1;
41d5ce9e
RR		 5365 wpa_s->p2p_in_invitation = 1;
5366 wpa_s->p2p_invite_go_freq = freq;
b22128ef 5367
91364b7f
SDU		 5368 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent,
5369 NULL);
5370 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
5371 wpas_p2p_group_formation_timeout,
5372 wpa_s->parent, NULL);
6fc48481
RR		 5373 wpa_supplicant_select_network(wpa_s, ssid);
5374
b22128ef
JM		 5375 return 0;
5376}
5377
5378
5379int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s,
5380 struct wpa_ssid *ssid, int addr_allocated,
062a7c0d
MS		 5381 int force_freq, int neg_freq, int ht40,
5382 int vht, const struct p2p_channels *channels,
bbc6c729 5383 int connection_timeout)
b22128ef
JM		 5384{
5385 struct p2p_go_neg_results params;
062a7c0d 5386 int go = 0, freq;
b22128ef
JM		 5387
5388 if (ssid->disabled != 2 || ssid->ssid == NULL)
5389 return -1;
5390
6c0da49f
JM		 5391 if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) &&
5392 go == (ssid->mode == WPAS_MODE_P2P_GO)) {
5393 wpa_printf(MSG_DEBUG, "P2P: Requested persistent group is "
5394 "already running");
5395 return 0;
5396 }
5397
01a57fe4
JM		 5398 os_free(wpa_s->global->add_psk);
5399 wpa_s->global->add_psk = NULL;
5400
9d39057c 5401 /* Make sure we are not running find during connection establishment */
8713a2e6 5402 wpas_p2p_stop_find_oper(wpa_s);
b22128ef 5403
aa9bb764
JM		 5404 wpa_s->p2p_fallback_to_go_neg = 0;
5405
062a7c0d
MS		 5406 if (force_freq > 0) {
5407 freq = wpas_p2p_select_go_freq(wpa_s, force_freq);
5408 if (freq < 0)
5409 return -1;
5410 } else {
5411 freq = wpas_p2p_select_go_freq(wpa_s, neg_freq);
5412 if (freq < 0 || (freq > 0 && !freq_included(channels, freq)))
5413 freq = 0;
5414 }
4abc0424 5415
41d5ce9e
RR		 5416 if (ssid->mode == WPAS_MODE_INFRA)
5417 return wpas_start_p2p_client(wpa_s, ssid, addr_allocated, freq);
5418
5419 if (ssid->mode != WPAS_MODE_P2P_GO)
5420 return -1;
5421
20ea1ca4 5422 if (wpas_p2p_init_go_params(wpa_s, &params, freq, ht40, vht, channels))
b8349523 5423 return -1;
b22128ef
JM		 5424
5425 params.role_go = 1;
30c371e8
MH		 5426 params.psk_set = ssid->psk_set;
5427 if (params.psk_set)
5428 os_memcpy(params.psk, ssid->psk, sizeof(params.psk));
bb4d4deb
MH		 5429 if (ssid->passphrase) {
5430 if (os_strlen(ssid->passphrase) >= sizeof(params.passphrase)) {
5431 wpa_printf(MSG_ERROR, "P2P: Invalid passphrase in "
5432 "persistent group");
5433 return -1;
5434 }
5435 os_strlcpy(params.passphrase, ssid->passphrase,
5436 sizeof(params.passphrase));
b22128ef 5437 }
b22128ef
JM		 5438 os_memcpy(params.ssid, ssid->ssid, ssid->ssid_len);
5439 params.ssid_len = ssid->ssid_len;
5440 params.persistent_group = 1;
5441
5442 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1);
5443 if (wpa_s == NULL)
5444 return -1;
5445
bbc6c729 5446 wpa_s->p2p_first_connection_timeout = connection_timeout;
b22128ef
JM		 5447 wpas_start_wps_go(wpa_s, &params, 0);
5448
5449 return 0;
5450}
5451
5452
5453static void wpas_p2p_ie_update(void *ctx, struct wpabuf *beacon_ies,
5454 struct wpabuf *proberesp_ies)
5455{
5456 struct wpa_supplicant *wpa_s = ctx;
5457 if (wpa_s->ap_iface) {
5458 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
adc33680
JM		 5459 if (!(hapd->conf->p2p & P2P_GROUP_OWNER)) {
5460 wpabuf_free(beacon_ies);
5461 wpabuf_free(proberesp_ies);
5462 return;
5463 }
b22128ef
JM		 5464 if (beacon_ies) {
5465 wpabuf_free(hapd->p2p_beacon_ie);
5466 hapd->p2p_beacon_ie = beacon_ies;
5467 }
5468 wpabuf_free(hapd->p2p_probe_resp_ie);
5469 hapd->p2p_probe_resp_ie = proberesp_ies;
5470 } else {
5471 wpabuf_free(beacon_ies);
5472 wpabuf_free(proberesp_ies);
5473 }
5474 wpa_supplicant_ap_update_beacon(wpa_s);
5475}
5476
5477
3071e181
JM		 5478static void wpas_p2p_idle_update(void *ctx, int idle)
5479{
5480 struct wpa_supplicant *wpa_s = ctx;
5481 if (!wpa_s->ap_iface)
5482 return;
5483 wpa_printf(MSG_DEBUG, "P2P: GO - group %sidle", idle ? "" : "not ");
95fb2db2
JM		 5484 if (idle) {
5485 if (wpa_s->global->p2p_fail_on_wps_complete &&
5486 wpa_s->p2p_in_provisioning) {
5487 wpas_p2p_grpform_fail_after_wps(wpa_s);
5488 return;
5489 }
3071e181 5490 wpas_p2p_set_group_idle_timeout(wpa_s);
95fb2db2 5491 } else
3071e181
JM		 5492 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
5493}
5494
5495
b22128ef 5496struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
6f251b6b 5497 struct wpa_ssid *ssid)
b22128ef
JM		 5498{
5499 struct p2p_group *group;
5500 struct p2p_group_config *cfg;
5501
9526fd29
JM		 5502 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5503 return NULL;
3ac17eba 5504
b22128ef
JM		 5505 cfg = os_zalloc(sizeof(*cfg));
5506 if (cfg == NULL)
5507 return NULL;
5508
6f251b6b 5509 if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect)
acc247b2 5510 cfg->persistent_group = 2;
6f251b6b 5511 else if (ssid->p2p_persistent_group)
acc247b2 5512 cfg->persistent_group = 1;
b22128ef 5513 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
3f4ce13f
JM		 5514 if (wpa_s->max_stations &&
5515 wpa_s->max_stations < wpa_s->conf->max_num_sta)
5516 cfg->max_clients = wpa_s->max_stations;
5517 else
5518 cfg->max_clients = wpa_s->conf->max_num_sta;
6f251b6b
JM		 5519 os_memcpy(cfg->ssid, ssid->ssid, ssid->ssid_len);
5520 cfg->ssid_len = ssid->ssid_len;
ea43ad96 5521 cfg->freq = ssid->frequency;
b22128ef
JM		 5522 cfg->cb_ctx = wpa_s;
5523 cfg->ie_update = wpas_p2p_ie_update;
3071e181 5524 cfg->idle_update = wpas_p2p_idle_update;
b22128ef
JM		 5525
5526 group = p2p_group_init(wpa_s->global->p2p, cfg);
5527 if (group == NULL)
5528 os_free(cfg);
6f251b6b 5529 if (ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
b22128ef
JM		 5530 p2p_group_notif_formation_done(group);
5531 wpa_s->p2p_group = group;
5532 return group;
5533}
5534
5535
5536void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
5537 int registrar)
5538{
10531d21
JM		 5539 struct wpa_ssid *ssid = wpa_s->current_ssid;
5540
b22128ef
JM		 5541 if (!wpa_s->p2p_in_provisioning) {
5542 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS success event - P2P "
5543 "provisioning not in progress");
5544 return;
5545 }
5546
10531d21
JM		 5547 if (ssid && ssid->mode == WPAS_MODE_INFRA) {
5548 u8 go_dev_addr[ETH_ALEN];
5549 os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN);
5550 wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
5551 ssid->ssid_len);
5552 /* Clear any stored provisioning info */
5553 p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr);
5554 }
ec437d9e 5555
b22128ef
JM		 5556 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent,
5557 NULL);
41f85323 5558 wpa_s->p2p_go_group_formation_completed = 1;
361cdf34
JM		 5559 if (ssid && ssid->mode == WPAS_MODE_INFRA) {
5560 /*
5561 * Use a separate timeout for initial data connection to
5562 * complete to allow the group to be removed automatically if
5563 * something goes wrong in this step before the P2P group idle
5564 * timeout mechanism is taken into use.
5565 */
41f85323
JM		 5566 wpa_dbg(wpa_s, MSG_DEBUG,
5567 "P2P: Re-start group formation timeout (%d seconds) as client for initial connection",
5568 P2P_MAX_INITIAL_CONN_WAIT);
361cdf34
JM		 5569 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
5570 wpas_p2p_group_formation_timeout,
ad853202 5571 wpa_s->parent, NULL);
41f85323
JM		 5572 } else if (ssid) {
5573 /*
5574 * Use a separate timeout for initial data connection to
5575 * complete to allow the group to be removed automatically if
5576 * the client does not complete data connection successfully.
5577 */
5578 wpa_dbg(wpa_s, MSG_DEBUG,
5579 "P2P: Re-start group formation timeout (%d seconds) as GO for initial connection",
5580 P2P_MAX_INITIAL_CONN_WAIT_GO);
5581 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT_GO, 0,
5582 wpas_p2p_group_formation_timeout,
5583 wpa_s->parent, NULL);
5584 /*
5585 * Complete group formation on first successful data connection
5586 */
5587 wpa_s->p2p_go_group_formation_completed = 0;
361cdf34 5588 }
b22128ef
JM		 5589 if (wpa_s->global->p2p)
5590 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
5591 wpas_group_formation_completed(wpa_s, 1);
5592}
5593
5594
3734552f
JS		 5595void wpas_p2p_wps_failed(struct wpa_supplicant *wpa_s,
5596 struct wps_event_fail *fail)
5597{
5598 if (!wpa_s->p2p_in_provisioning) {
5599 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS fail event - P2P "
5600 "provisioning not in progress");
5601 return;
5602 }
ec437d9e
JJ		 5603
5604 if (wpa_s->go_params) {
5605 p2p_clear_provisioning_info(
5606 wpa_s->global->p2p,
10531d21 5607 wpa_s->go_params->peer_device_addr);
ec437d9e
JJ		 5608 }
5609
3734552f 5610 wpas_notify_p2p_wps_failed(wpa_s, fail);
95fb2db2
JM		 5611
5612 if (wpa_s == wpa_s->global->p2p_group_formation) {
5613 /*
5614 * Allow some time for the failed WPS negotiation exchange to
5615 * complete, but remove the group since group formation cannot
5616 * succeed after provisioning failure.
5617 */
5618 wpa_printf(MSG_DEBUG, "P2P: WPS step failed during group formation - reject connection from timeout");
5619 wpa_s->global->p2p_fail_on_wps_complete = 1;
5620 eloop_deplete_timeout(0, 50000,
5621 wpas_p2p_group_formation_timeout,
5622 wpa_s->parent, NULL);
5623 }
5624}
5625
5626
5627int wpas_p2p_wps_eapol_cb(struct wpa_supplicant *wpa_s)
5628{
5629 if (!wpa_s->global->p2p_fail_on_wps_complete ||
5630 !wpa_s->p2p_in_provisioning)
5631 return 0;
5632
5633 wpas_p2p_grpform_fail_after_wps(wpa_s);
5634
5635 return 1;
3734552f
JS		 5636}
5637
5638
b22128ef 5639int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
0918c4bf
JM		 5640 const char *config_method,
5641 enum wpas_p2p_prov_disc_use use)
b22128ef
JM		 5642{
5643 u16 config_methods;
5644
aa9bb764 5645 wpa_s->p2p_fallback_to_go_neg = 0;
0918c4bf 5646 wpa_s->pending_pd_use = NORMAL_PD;
8c5f7309 5647 if (os_strncmp(config_method, "display", 7) == 0)
b22128ef 5648 config_methods = WPS_CONFIG_DISPLAY;
8c5f7309 5649 else if (os_strncmp(config_method, "keypad", 6) == 0)
b22128ef 5650 config_methods = WPS_CONFIG_KEYPAD;
8c5f7309
JJ		 5651 else if (os_strncmp(config_method, "pbc", 3) == 0 ||
5652 os_strncmp(config_method, "pushbutton", 10) == 0)
b22128ef 5653 config_methods = WPS_CONFIG_PUSHBUTTON;
8c5f7309
JJ		 5654 else {
5655 wpa_printf(MSG_DEBUG, "P2P: Unknown config method");
b22128ef 5656 return -1;
8c5f7309 5657 }
b22128ef 5658
0918c4bf
JM		 5659 if (use == WPAS_P2P_PD_AUTO) {
5660 os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN);
5661 wpa_s->pending_pd_config_methods = config_methods;
5662 wpa_s->p2p_auto_pd = 1;
5663 wpa_s->p2p_auto_join = 0;
5664 wpa_s->pending_pd_before_join = 0;
84286a22 5665 wpa_s->auto_pd_scan_retry = 0;
0918c4bf
JM		 5666 wpas_p2p_stop_find(wpa_s);
5667 wpa_s->p2p_join_scan_count = 0;
acb69cec 5668 os_get_reltime(&wpa_s->p2p_auto_started);
84286a22
SDU		 5669 wpa_printf(MSG_DEBUG, "P2P: Auto PD started at %ld.%06ld",
5670 wpa_s->p2p_auto_started.sec,
5671 wpa_s->p2p_auto_started.usec);
0918c4bf
JM		 5672 wpas_p2p_join_scan(wpa_s, NULL);
5673 return 0;
5674 }
5675
9526fd29 5676 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
b22128ef
JM		 5677 return -1;
5678
5679 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr,
0918c4bf 5680 config_methods, use == WPAS_P2P_PD_FOR_JOIN,
67527166 5681 0, 1);
b22128ef
JM		 5682}
5683
5684
5685int wpas_p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf,
5686 char *end)
5687{
5688 return p2p_scan_result_text(ies, ies_len, buf, end);
5689}
5690
5691
1cc3a29d
JM		 5692static void wpas_p2p_clear_pending_action_tx(struct wpa_supplicant *wpa_s)
5693{
2f3101d8 5694 if (!offchannel_pending_action_tx(wpa_s))
1cc3a29d
JM		 5695 return;
5696
2fa980f0
JJ		 5697 wpas_p2p_action_tx_clear(wpa_s);
5698
1cc3a29d
JM		 5699 wpa_printf(MSG_DEBUG, "P2P: Drop pending Action TX due to new "
5700 "operation request");
2f3101d8 5701 offchannel_clear_pending_action_tx(wpa_s);
1cc3a29d
JM		 5702}
5703
5704
b22128ef 5705int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
046ef4aa 5706 enum p2p_discovery_type type,
6d92fa6e 5707 unsigned int num_req_dev_types, const u8 *req_dev_types,
37448ede 5708 const u8 *dev_id, unsigned int search_delay)
b22128ef 5709{
1cc3a29d 5710 wpas_p2p_clear_pending_action_tx(wpa_s);
b22128ef
JM		 5711 wpa_s->p2p_long_listen = 0;
5712
5bda43cd 5713 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
85a6cdb5 5714 wpa_s->p2p_in_provisioning)
9526fd29
JM		 5715 return -1;
5716
433cd2ce
JM		 5717 wpa_supplicant_cancel_sched_scan(wpa_s);
5718
046ef4aa 5719 return p2p_find(wpa_s->global->p2p, timeout, type,
37448ede
JM		 5720 num_req_dev_types, req_dev_types, dev_id,
5721 search_delay);
b22128ef
JM		 5722}
5723
5724
8713a2e6 5725static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s)
b22128ef 5726{
1cc3a29d 5727 wpas_p2p_clear_pending_action_tx(wpa_s);
b22128ef 5728 wpa_s->p2p_long_listen = 0;
9d39057c 5729 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
ef922c4a 5730 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
b22128ef 5731
9526fd29
JM		 5732 if (wpa_s->global->p2p)
5733 p2p_stop_find(wpa_s->global->p2p);
b22128ef 5734
8713a2e6
JM		 5735 return 0;
5736}
5737
5738
5739void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s)
5740{
5741 if (wpas_p2p_stop_find_oper(wpa_s) > 0)
5742 return;
b22128ef
JM		 5743 wpas_p2p_remove_pending_group_interface(wpa_s);
5744}
5745
5746
5747static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx)
5748{
5749 struct wpa_supplicant *wpa_s = eloop_ctx;
5750 wpa_s->p2p_long_listen = 0;
5751}
5752
5753
5754int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout)
5755{
5756 int res;
5757
9526fd29
JM		 5758 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5759 return -1;
5760
433cd2ce 5761 wpa_supplicant_cancel_sched_scan(wpa_s);
1cc3a29d
JM		 5762 wpas_p2p_clear_pending_action_tx(wpa_s);
5763
b22128ef
JM		 5764 if (timeout == 0) {
5765 /*
5766 * This is a request for unlimited Listen state. However, at
5767 * least for now, this is mapped to a Listen state for one
5768 * hour.
5769 */
5770 timeout = 3600;
5771 }
5772 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
5773 wpa_s->p2p_long_listen = 0;
5774
2bb747e2
JM		 5775 /*
5776 * Stop previous find/listen operation to avoid trying to request a new
5777 * remain-on-channel operation while the driver is still running the
5778 * previous one.
5779 */
5780 if (wpa_s->global->p2p)
5781 p2p_stop_find(wpa_s->global->p2p);
5782
b22128ef
JM		 5783 res = wpas_p2p_listen_start(wpa_s, timeout * 1000);
5784 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
11fb02be 5785 wpa_s->p2p_long_listen = timeout * 1000;
b22128ef
JM		 5786 eloop_register_timeout(timeout, 0,
5787 wpas_p2p_long_listen_timeout,
5788 wpa_s, NULL);
5789 }
5790
5791 return res;
5792}
5793
5794
4c08c0bd 5795int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
b22128ef
JM		 5796 u8 *buf, size_t len, int p2p_group)
5797{
4c08c0bd
JM		 5798 struct wpabuf *p2p_ie;
5799 int ret;
5800
b22128ef
JM		 5801 if (wpa_s->global->p2p_disabled)
5802 return -1;
1c2aa04c
EMK		 5803 if (wpa_s->conf->p2p_disabled)
5804 return -1;
b22128ef
JM		 5805 if (wpa_s->global->p2p == NULL)
5806 return -1;
e1f1509b
JM		 5807 if (bss == NULL)
5808 return -1;
b22128ef 5809
4c08c0bd
JM		 5810 p2p_ie = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
5811 ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len,
5812 p2p_group, p2p_ie);
5813 wpabuf_free(p2p_ie);
5814
5815 return ret;
b22128ef
JM		 5816}
5817
5818
5819int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr,
04a85e44 5820 const u8 *dst, const u8 *bssid,
baf513d6 5821 const u8 *ie, size_t ie_len, int ssi_signal)
b22128ef
JM		 5822{
5823 if (wpa_s->global->p2p_disabled)
5824 return 0;
5825 if (wpa_s->global->p2p == NULL)
5826 return 0;
5827
2d43d37f
JB		 5828 switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid,
5829 ie, ie_len)) {
5830 case P2P_PREQ_NOT_P2P:
5831 wpas_notify_preq(wpa_s, addr, dst, bssid, ie, ie_len,
5832 ssi_signal);
5833 /* fall through */
5834 case P2P_PREQ_MALFORMED:
5835 case P2P_PREQ_NOT_LISTEN:
5836 case P2P_PREQ_NOT_PROCESSED:
5837 default: /* make gcc happy */
5838 return 0;
5839 case P2P_PREQ_PROCESSED:
5840 return 1;
5841 }
b22128ef
JM		 5842}
5843
5844
5845void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
5846 const u8 *sa, const u8 *bssid,
5847 u8 category, const u8 *data, size_t len, int freq)
5848{
5849 if (wpa_s->global->p2p_disabled)
5850 return;
5851 if (wpa_s->global->p2p == NULL)
5852 return;
5853
5854 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
5855 freq);
5856}
5857
5858
5859void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies)
5860{
5861 if (wpa_s->global->p2p_disabled)
5862 return;
5863 if (wpa_s->global->p2p == NULL)
5864 return;
5865
6d92fa6e 5866 p2p_scan_ie(wpa_s->global->p2p, ies, NULL);
b22128ef
JM		 5867}
5868
5869
bd10d938 5870static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s)
b22128ef
JM		 5871{
5872 p2p_group_deinit(wpa_s->p2p_group);
5873 wpa_s->p2p_group = NULL;
a7fd39bb
JD		 5874
5875 wpa_s->ap_configured_cb = NULL;
5876 wpa_s->ap_configured_cb_ctx = NULL;
5877 wpa_s->ap_configured_cb_data = NULL;
5878 wpa_s->connect_without_scan = NULL;
b22128ef
JM		 5879}
5880
5881
5882int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
5883{
5884 wpa_s->p2p_long_listen = 0;
5885
9526fd29
JM		 5886 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5887 return -1;
5888
b22128ef
JM		 5889 return p2p_reject(wpa_s->global->p2p, addr);
5890}
5891
5892
5893/* Invite to reinvoke a persistent group */
5894int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
4d32c0c4 5895 struct wpa_ssid *ssid, const u8 *go_dev_addr, int freq,
20ea1ca4 5896 int ht40, int vht, int pref_freq)
b22128ef
JM		 5897{
5898 enum p2p_invite_role role;
0d08efa4
IP		 5899 u8 *bssid = NULL;
5900 int force_freq = 0;
5de4b721 5901 int res;
d0f61a4b 5902 int no_pref_freq_given = pref_freq == 0;
b22128ef 5903
dbca75f8 5904 wpa_s->global->p2p_invite_group = NULL;
77e4e853
JM		 5905 if (peer_addr)
5906 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
5907 else
5908 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
5909
4d32c0c4
JM		 5910 wpa_s->p2p_persistent_go_freq = freq;
5911 wpa_s->p2p_go_ht40 = !!ht40;
b22128ef
JM		 5912 if (ssid->mode == WPAS_MODE_P2P_GO) {
5913 role = P2P_INVITE_ROLE_GO;
5914 if (peer_addr == NULL) {
5915 wpa_printf(MSG_DEBUG, "P2P: Missing peer "
5916 "address in invitation command");
5917 return -1;
5918 }
5919 if (wpas_p2p_create_iface(wpa_s)) {
5920 if (wpas_p2p_add_group_interface(wpa_s,
5921 WPA_IF_P2P_GO) < 0) {
5922 wpa_printf(MSG_ERROR, "P2P: Failed to "
5923 "allocate a new interface for the "
5924 "group");
5925 return -1;
5926 }
5927 bssid = wpa_s->pending_interface_addr;
5928 } else
5929 bssid = wpa_s->own_addr;
5930 } else {
5931 role = P2P_INVITE_ROLE_CLIENT;
5932 peer_addr = ssid->bssid;
5933 }
5934 wpa_s->pending_invite_ssid_id = ssid->id;
5935
51e9f228
JM		 5936 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
5937 role == P2P_INVITE_ROLE_GO);
5de4b721
JM		 5938 if (res)
5939 return res;
79879f4a 5940
9526fd29
JM		 5941 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
5942 return -1;
5943
d0f61a4b
JM		 5944 if (wpa_s->parent->conf->p2p_ignore_shared_freq &&
5945 no_pref_freq_given && pref_freq > 0 &&
5946 wpa_s->num_multichan_concurrent > 1 &&
5947 wpas_p2p_num_unused_channels(wpa_s) > 0) {
5948 wpa_printf(MSG_DEBUG, "P2P: Ignore own channel preference %d MHz for invitation due to p2p_ignore_shared_freq=1 configuration",
5949 pref_freq);
5950 pref_freq = 0;
5951 }
5952
b22128ef 5953 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
79879f4a 5954 ssid->ssid, ssid->ssid_len, force_freq, go_dev_addr,
8e9f53c3 5955 1, pref_freq, -1);
b22128ef
JM		 5956}
5957
5958
5959/* Invite to join an active group */
5960int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
5961 const u8 *peer_addr, const u8 *go_dev_addr)
5962{
5963 struct wpa_global *global = wpa_s->global;
5964 enum p2p_invite_role role;
0d08efa4 5965 u8 *bssid = NULL;
b22128ef 5966 struct wpa_ssid *ssid;
c427ac92 5967 int persistent;
73b54d63 5968 int freq = 0, force_freq = 0, pref_freq = 0;
5de4b721 5969 int res;
b22128ef 5970
4d32c0c4
JM		 5971 wpa_s->p2p_persistent_go_freq = 0;
5972 wpa_s->p2p_go_ht40 = 0;
20ea1ca4 5973 wpa_s->p2p_go_vht = 0;
4d32c0c4 5974
b22128ef
JM		 5975 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
5976 if (os_strcmp(wpa_s->ifname, ifname) == 0)
5977 break;
5978 }
5979 if (wpa_s == NULL) {
5980 wpa_printf(MSG_DEBUG, "P2P: Interface '%s' not found", ifname);
5981 return -1;
5982 }
5983
5984 ssid = wpa_s->current_ssid;
5985 if (ssid == NULL) {
5986 wpa_printf(MSG_DEBUG, "P2P: No current SSID to use for "
5987 "invitation");
5988 return -1;
5989 }
5990
dbca75f8 5991 wpa_s->global->p2p_invite_group = wpa_s;
c427ac92
JM		 5992 persistent = ssid->p2p_persistent_group &&
5993 wpas_p2p_get_persistent(wpa_s->parent, peer_addr,
5994 ssid->ssid, ssid->ssid_len);
5995
b22128ef
JM		 5996 if (ssid->mode == WPAS_MODE_P2P_GO) {
5997 role = P2P_INVITE_ROLE_ACTIVE_GO;
5998 bssid = wpa_s->own_addr;
5999 if (go_dev_addr == NULL)
d7e70476 6000 go_dev_addr = wpa_s->global->p2p_dev_addr;
73b54d63 6001 freq = ssid->frequency;
b22128ef
JM		 6002 } else {
6003 role = P2P_INVITE_ROLE_CLIENT;
6004 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
6005 wpa_printf(MSG_DEBUG, "P2P: Not associated - cannot "
6006 "invite to current group");
6007 return -1;
6008 }
6009 bssid = wpa_s->bssid;
6010 if (go_dev_addr == NULL &&
6011 !is_zero_ether_addr(wpa_s->go_dev_addr))
6012 go_dev_addr = wpa_s->go_dev_addr;
73b54d63
JM		 6013 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
6014 (int) wpa_s->assoc_freq;
b22128ef 6015 }
bb79dc72 6016 wpa_s->parent->pending_invite_ssid_id = -1;
b22128ef 6017
9526fd29
JM		 6018 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6019 return -1;
6020
51e9f228
JM		 6021 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq,
6022 role == P2P_INVITE_ROLE_ACTIVE_GO);
5de4b721
JM		 6023 if (res)
6024 return res;
0d08efa4 6025 wpas_p2p_set_own_freq_preference(wpa_s, force_freq);
79879f4a 6026
b22128ef 6027 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
79879f4a 6028 ssid->ssid, ssid->ssid_len, force_freq,
8e9f53c3 6029 go_dev_addr, persistent, pref_freq, -1);
b22128ef
JM		 6030}
6031
6032
6033void wpas_p2p_completed(struct wpa_supplicant *wpa_s)
6034{
6035 struct wpa_ssid *ssid = wpa_s->current_ssid;
b22128ef 6036 u8 go_dev_addr[ETH_ALEN];
4b6baa2f 6037 int network_id = -1;
b22128ef 6038 int persistent;
b49d6ccb 6039 int freq;
25ef8529
JM		 6040 u8 ip[3 * 4];
6041 char ip_addr[100];
b22128ef 6042
73ccd083
JM		 6043 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION) {
6044 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
6045 wpa_s->parent, NULL);
6046 }
361cdf34 6047
b22128ef 6048 if (!wpa_s->show_group_started || !ssid)
1b5d4714 6049 return;
b22128ef
JM		 6050
6051 wpa_s->show_group_started = 0;
6052
b22128ef
JM		 6053 os_memset(go_dev_addr, 0, ETH_ALEN);
6054 if (ssid->bssid_set)
6055 os_memcpy(go_dev_addr, ssid->bssid, ETH_ALEN);
6056 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
6057 ssid->ssid_len);
6058 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
6059
a0a9f3b0
JM		 6060 if (wpa_s->global->p2p_group_formation == wpa_s)
6061 wpa_s->global->p2p_group_formation = NULL;
6062
b49d6ccb
JJ		 6063 freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
6064 (int) wpa_s->assoc_freq;
25ef8529
JM		 6065
6066 ip_addr[0] = '\0';
6067 if (wpa_sm_get_p2p_ip_addr(wpa_s->wpa, ip) == 0) {
6068 os_snprintf(ip_addr, sizeof(ip_addr), " ip_addr=%u.%u.%u.%u "
6069 "ip_mask=%u.%u.%u.%u go_ip_addr=%u.%u.%u.%u",
6070 ip[0], ip[1], ip[2], ip[3],
6071 ip[4], ip[5], ip[6], ip[7],
6072 ip[8], ip[9], ip[10], ip[11]);
6073 }
6074
f8723e1e
JM		 6075 wpas_p2p_group_started(wpa_s, 0, ssid, freq,
6076 ssid->passphrase == NULL && ssid->psk_set ?
6077 ssid->psk : NULL,
6078 ssid->passphrase, go_dev_addr, persistent,
6079 ip_addr);
b22128ef
JM		 6080
6081 if (persistent)
4b6baa2f
JMB		 6082 network_id = wpas_p2p_store_persistent_group(wpa_s->parent,
6083 ssid, go_dev_addr);
6084 if (network_id < 0)
6085 network_id = ssid->id;
6086 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 1);
b22128ef
JM		 6087}
6088
6089
6090int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
6091 u32 interval1, u32 duration2, u32 interval2)
6092{
c64e3a08
JM		 6093 int ret;
6094
9526fd29
JM		 6095 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6096 return -1;
3ac17eba 6097
b22128ef
JM		 6098 if (wpa_s->wpa_state < WPA_ASSOCIATED ||
6099 wpa_s->current_ssid == NULL ||
6100 wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
6101 return -1;
6102
c64e3a08
JM		 6103 ret = p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
6104 wpa_s->own_addr, wpa_s->assoc_freq,
6105 duration1, interval1, duration2, interval2);
6106 if (ret == 0)
6107 wpa_s->waiting_presence_resp = 1;
6108
6109 return ret;
b22128ef
JM		 6110}
6111
6112
6113int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
6114 unsigned int interval)
6115{
9526fd29
JM		 6116 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6117 return -1;
6118
b22128ef
JM		 6119 return p2p_ext_listen(wpa_s->global->p2p, period, interval);
6120}
6121
6122
c8106615
JM		 6123static int wpas_p2p_is_client(struct wpa_supplicant *wpa_s)
6124{
5fbddfdc
JM		 6125 if (wpa_s->current_ssid == NULL) {
6126 /*
c7deed74 6127 * current_ssid can be cleared when P2P client interface gets
5fbddfdc
JM		 6128 * disconnected, so assume this interface was used as P2P
6129 * client.
6130 */
6131 return 1;
6132 }
6133 return wpa_s->current_ssid->p2p_group &&
c8106615
JM		 6134 wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
6135}
6136
6137
3071e181
JM		 6138static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx)
6139{
6140 struct wpa_supplicant *wpa_s = eloop_ctx;
6141
c8106615 6142 if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) {
3071e181
JM		 6143 wpa_printf(MSG_DEBUG, "P2P: Ignore group idle timeout - "
6144 "disabled");
6145 return;
6146 }
6147
6148 wpa_printf(MSG_DEBUG, "P2P: Group idle timeout reached - terminate "
6149 "group");
8dba4aef 6150 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_IDLE_TIMEOUT);
3071e181
JM		 6151}
6152
6153
6154static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s)
6155{
5f482d55 6156 int timeout;
c8106615 6157
dddc7045
JM		 6158 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
6159 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
6160
c8106615 6161 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
3071e181
JM		 6162 return;
6163
c8106615
JM		 6164 timeout = wpa_s->conf->p2p_group_idle;
6165 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
6166 (timeout == 0 || timeout > P2P_MAX_CLIENT_IDLE))
6167 timeout = P2P_MAX_CLIENT_IDLE;
6168
6169 if (timeout == 0)
3071e181
JM		 6170 return;
6171
5f482d55
JM		 6172 if (timeout < 0) {
6173 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA)
6174 timeout = 0; /* special client mode no-timeout */
6175 else
6176 return;
6177 }
6178
8c472816
JM		 6179 if (wpa_s->p2p_in_provisioning) {
6180 /*
6181 * Use the normal group formation timeout during the
6182 * provisioning phase to avoid terminating this process too
6183 * early due to group idle timeout.
6184 */
6185 wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout "
6186 "during provisioning");
6187 return;
6188 }
6189
361cdf34
JM		 6190 if (wpa_s->show_group_started) {
6191 /*
6192 * Use the normal group formation timeout between the end of
6193 * the provisioning phase and completion of 4-way handshake to
6194 * avoid terminating this process too early due to group idle
6195 * timeout.
6196 */
6197 wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout "
6198 "while waiting for initial 4-way handshake to "
6199 "complete");
6200 return;
6201 }
6202
3071e181 6203 wpa_printf(MSG_DEBUG, "P2P: Set P2P group idle timeout to %u seconds",
c8106615
JM		 6204 timeout);
6205 eloop_register_timeout(timeout, 0, wpas_p2p_group_idle_timeout,
6206 wpa_s, NULL);
3071e181
JM		 6207}
6208
6209
0aadd568
JM		 6210/* Returns 1 if the interface was removed */
6211int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
6212 u16 reason_code, const u8 *ie, size_t ie_len,
6213 int locally_generated)
b22128ef 6214{
9526fd29 6215 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
0aadd568 6216 return 0;
b22128ef 6217
3fc14102
JM		 6218 if (!locally_generated)
6219 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
6220 ie_len);
6221
6222 if (reason_code == WLAN_REASON_DEAUTH_LEAVING && !locally_generated &&
6223 wpa_s->current_ssid &&
6224 wpa_s->current_ssid->p2p_group &&
6225 wpa_s->current_ssid->mode == WPAS_MODE_INFRA) {
6226 wpa_printf(MSG_DEBUG, "P2P: GO indicated that the P2P Group "
6227 "session is ending");
0aadd568
JM		 6228 if (wpas_p2p_group_delete(wpa_s,
6229 P2P_GROUP_REMOVAL_GO_ENDING_SESSION)
6230 > 0)
6231 return 1;
3fc14102 6232 }
0aadd568
JM		 6233
6234 return 0;
b22128ef
JM		 6235}
6236
6237
6238void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
3fc14102
JM		 6239 u16 reason_code, const u8 *ie, size_t ie_len,
6240 int locally_generated)
b22128ef 6241{
9526fd29 6242 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
b22128ef
JM		 6243 return;
6244
3fc14102
JM		 6245 if (!locally_generated)
6246 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
6247 ie_len);
b22128ef
JM		 6248}
6249
6250
6251void wpas_p2p_update_config(struct wpa_supplicant *wpa_s)
6252{
6253 struct p2p_data *p2p = wpa_s->global->p2p;
6254
6255 if (p2p == NULL)
6256 return;
6257
4c010834
KL		 6258 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
6259 return;
6260
b22128ef
JM		 6261 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
6262 p2p_set_dev_name(p2p, wpa_s->conf->device_name);
6263
2f646b6e
JB		 6264 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
6265 p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type);
b22128ef 6266
b6e01800
JM		 6267 if (wpa_s->wps &&
6268 (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS))
6269 p2p_set_config_methods(p2p, wpa_s->wps->config_methods);
6270
6271 if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID))
6272 p2p_set_uuid(p2p, wpa_s->wps->uuid);
6273
6274 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) {
6275 p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer);
6276 p2p_set_model_name(p2p, wpa_s->conf->model_name);
6277 p2p_set_model_number(p2p, wpa_s->conf->model_number);
6278 p2p_set_serial_number(p2p, wpa_s->conf->serial_number);
6279 }
6280
2f646b6e
JB		 6281 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE)
6282 p2p_set_sec_dev_types(p2p,
6283 (void *) wpa_s->conf->sec_device_type,
6284 wpa_s->conf->num_sec_device_types);
b22128ef 6285
f95cac27
JMB		 6286 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) {
6287 int i;
6288 p2p_remove_wps_vendor_extensions(p2p);
6289 for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) {
6290 if (wpa_s->conf->wps_vendor_ext[i] == NULL)
6291 continue;
6292 p2p_add_wps_vendor_extension(
6293 p2p, wpa_s->conf->wps_vendor_ext[i]);
6294 }
6295 }
6296
b22128ef
JM		 6297 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
6298 wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
6299 char country[3];
6300 country[0] = wpa_s->conf->country[0];
6301 country[1] = wpa_s->conf->country[1];
6302 country[2] = 0x04;
6303 p2p_set_country(p2p, country);
6304 }
6305
6306 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
6307 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
6308 wpa_s->conf->p2p_ssid_postfix ?
6309 os_strlen(wpa_s->conf->p2p_ssid_postfix) :
6310 0);
6311 }
0f66abd2
SS		 6312
6313 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS)
6314 p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss);
2463ba70
JS		 6315
6316 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) {
6317 u8 reg_class, channel;
6318 int ret;
6319 unsigned int r;
e3bd6e9d
IP		 6320 u8 channel_forced;
6321
2463ba70
JS		 6322 if (wpa_s->conf->p2p_listen_reg_class &&
6323 wpa_s->conf->p2p_listen_channel) {
6324 reg_class = wpa_s->conf->p2p_listen_reg_class;
6325 channel = wpa_s->conf->p2p_listen_channel;
e3bd6e9d 6326 channel_forced = 1;
2463ba70
JS		 6327 } else {
6328 reg_class = 81;
6329 /*
6330 * Pick one of the social channels randomly as the
6331 * listen channel.
6332 */
df2508d7
JM		 6333 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
6334 channel = 1;
6335 else
6336 channel = 1 + (r % 3) * 5;
e3bd6e9d 6337 channel_forced = 0;
2463ba70 6338 }
e3bd6e9d
IP		 6339 ret = p2p_set_listen_channel(p2p, reg_class, channel,
6340 channel_forced);
2463ba70
JS		 6341 if (ret)
6342 wpa_printf(MSG_ERROR, "P2P: Own listen channel update "
6343 "failed: %d", ret);
6344 }
6345 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) {
6346 u8 op_reg_class, op_channel, cfg_op_channel;
6347 int ret = 0;
6348 unsigned int r;
6349 if (wpa_s->conf->p2p_oper_reg_class &&
6350 wpa_s->conf->p2p_oper_channel) {
6351 op_reg_class = wpa_s->conf->p2p_oper_reg_class;
6352 op_channel = wpa_s->conf->p2p_oper_channel;
6353 cfg_op_channel = 1;
6354 } else {
6355 op_reg_class = 81;
6356 /*
6357 * Use random operation channel from (1, 6, 11)
6358 *if no other preference is indicated.
6359 */
df2508d7
JM		 6360 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
6361 op_channel = 1;
6362 else
6363 op_channel = 1 + (r % 3) * 5;
2463ba70
JS		 6364 cfg_op_channel = 0;
6365 }
6366 ret = p2p_set_oper_channel(p2p, op_reg_class, op_channel,
6367 cfg_op_channel);
6368 if (ret)
6369 wpa_printf(MSG_ERROR, "P2P: Own oper channel update "
6370 "failed: %d", ret);
6371 }
21d996f7
JM		 6372
6373 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
6374 if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
6375 wpa_s->conf->p2p_pref_chan) < 0) {
6376 wpa_printf(MSG_ERROR, "P2P: Preferred channel list "
6377 "update failed");
6378 }
556b30da
JM		 6379
6380 if (p2p_set_no_go_freq(p2p, &wpa_s->conf->p2p_no_go_freq) < 0) {
6381 wpa_printf(MSG_ERROR, "P2P: No GO channel list "
6382 "update failed");
6383 }
21d996f7 6384 }
1b928f96
JM		 6385
6386 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PASSPHRASE_LEN)
6387 p2p_set_passphrase_len(p2p, wpa_s->conf->p2p_passphrase_len);
b22128ef 6388}
aefb53bd
JM		 6389
6390
6391int wpas_p2p_set_noa(struct wpa_supplicant *wpa_s, u8 count, int start,
6392 int duration)
6393{
6394 if (!wpa_s->ap_iface)
6395 return -1;
6396 return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start,
6397 duration);
6398}
72044390
JM		 6399
6400
6401int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled)
6402{
9526fd29 6403 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
72044390 6404 return -1;
72044390
JM		 6405
6406 wpa_s->global->cross_connection = enabled;
6407 p2p_set_cross_connect(wpa_s->global->p2p, enabled);
6408
6409 if (!enabled) {
6410 struct wpa_supplicant *iface;
6411
6412 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
6413 {
6414 if (iface->cross_connect_enabled == 0)
6415 continue;
6416
6417 iface->cross_connect_enabled = 0;
6418 iface->cross_connect_in_use = 0;
92c4465b
JM		 6419 wpa_msg_global(iface->parent, MSG_INFO,
6420 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
6421 iface->ifname,
6422 iface->cross_connect_uplink);
72044390
JM		 6423 }
6424 }
6425
6426 return 0;
6427}
6428
6429
6430static void wpas_p2p_enable_cross_connect(struct wpa_supplicant *uplink)
6431{
6432 struct wpa_supplicant *iface;
6433
6434 if (!uplink->global->cross_connection)
6435 return;
6436
6437 for (iface = uplink->global->ifaces; iface; iface = iface->next) {
6438 if (!iface->cross_connect_enabled)
6439 continue;
6440 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
6441 0)
6442 continue;
6443 if (iface->ap_iface == NULL)
6444 continue;
6445 if (iface->cross_connect_in_use)
6446 continue;
6447
6448 iface->cross_connect_in_use = 1;
92c4465b
JM		 6449 wpa_msg_global(iface->parent, MSG_INFO,
6450 P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s",
6451 iface->ifname, iface->cross_connect_uplink);
72044390
JM		 6452 }
6453}
6454
6455
6456static void wpas_p2p_disable_cross_connect(struct wpa_supplicant *uplink)
6457{
6458 struct wpa_supplicant *iface;
6459
6460 for (iface = uplink->global->ifaces; iface; iface = iface->next) {
6461 if (!iface->cross_connect_enabled)
6462 continue;
6463 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
6464 0)
6465 continue;
6466 if (!iface->cross_connect_in_use)
6467 continue;
6468
92c4465b
JM		 6469 wpa_msg_global(iface->parent, MSG_INFO,
6470 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
6471 iface->ifname, iface->cross_connect_uplink);
72044390
JM		 6472 iface->cross_connect_in_use = 0;
6473 }
6474}
6475
6476
6477void wpas_p2p_notif_connected(struct wpa_supplicant *wpa_s)
6478{
6479 if (wpa_s->ap_iface || wpa_s->current_ssid == NULL ||
6480 wpa_s->current_ssid->mode != WPAS_MODE_INFRA ||
6481 wpa_s->cross_connect_disallowed)
6482 wpas_p2p_disable_cross_connect(wpa_s);
6483 else
6484 wpas_p2p_enable_cross_connect(wpa_s);
dddc7045
JM		 6485 if (!wpa_s->ap_iface &&
6486 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
6487 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
72044390
JM		 6488}
6489
6490
6491void wpas_p2p_notif_disconnected(struct wpa_supplicant *wpa_s)
6492{
6493 wpas_p2p_disable_cross_connect(wpa_s);
4c2c6751
JM		 6494 if (!wpa_s->ap_iface &&
6495 !eloop_is_timeout_registered(wpas_p2p_group_idle_timeout,
6496 wpa_s, NULL))
3071e181 6497 wpas_p2p_set_group_idle_timeout(wpa_s);
72044390
JM		 6498}
6499
6500
6501static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s)
6502{
6503 struct wpa_supplicant *iface;
6504
6505 if (!wpa_s->global->cross_connection)
6506 return;
6507
6508 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
6509 if (iface == wpa_s)
6510 continue;
6511 if (iface->drv_flags &
6512 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)
6513 continue;
6514 if (iface->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE)
6515 continue;
6516
6517 wpa_s->cross_connect_enabled = 1;
6518 os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname,
6519 sizeof(wpa_s->cross_connect_uplink));
6520 wpa_printf(MSG_DEBUG, "P2P: Enable cross connection from "
6521 "%s to %s whenever uplink is available",
6522 wpa_s->ifname, wpa_s->cross_connect_uplink);
6523
6524 if (iface->ap_iface || iface->current_ssid == NULL ||
6525 iface->current_ssid->mode != WPAS_MODE_INFRA ||
6526 iface->cross_connect_disallowed ||
6527 iface->wpa_state != WPA_COMPLETED)
6528 break;
6529
6530 wpa_s->cross_connect_in_use = 1;
92c4465b
JM		 6531 wpa_msg_global(wpa_s->parent, MSG_INFO,
6532 P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s",
6533 wpa_s->ifname, wpa_s->cross_connect_uplink);
72044390
JM		 6534 break;
6535 }
6536}
b73bf0a7
JM		 6537
6538
6539int wpas_p2p_notif_pbc_overlap(struct wpa_supplicant *wpa_s)
6540{
6541 if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT &&
6542 !wpa_s->p2p_in_provisioning)
6543 return 0; /* not P2P client operation */
6544
6545 wpa_printf(MSG_DEBUG, "P2P: Terminate connection due to WPS PBC "
6546 "session overlap");
148bb37f
JM		 6547 if (wpa_s != wpa_s->parent)
6548 wpa_msg_ctrl(wpa_s->parent, MSG_INFO, WPS_EVENT_OVERLAP);
1075b295 6549 wpas_p2p_group_formation_failed(wpa_s);
b73bf0a7
JM		 6550 return 1;
6551}
b5c9da8d
JM		 6552
6553
ace0fbdb
AS		 6554void wpas_p2p_pbc_overlap_cb(void *eloop_ctx, void *timeout_ctx)
6555{
6556 struct wpa_supplicant *wpa_s = eloop_ctx;
6557 wpas_p2p_notif_pbc_overlap(wpa_s);
6558}
6559
6560
b5c9da8d
JM		 6561void wpas_p2p_update_channel_list(struct wpa_supplicant *wpa_s)
6562{
51e9f228 6563 struct p2p_channels chan, cli_chan;
7b42862a 6564 struct wpa_supplicant *ifs;
b5c9da8d
JM		 6565
6566 if (wpa_s->global == NULL || wpa_s->global->p2p == NULL)
6567 return;
6568
6569 os_memset(&chan, 0, sizeof(chan));
51e9f228
JM		 6570 os_memset(&cli_chan, 0, sizeof(cli_chan));
6571 if (wpas_p2p_setup_channels(wpa_s, &chan, &cli_chan)) {
b5c9da8d
JM		 6572 wpa_printf(MSG_ERROR, "P2P: Failed to update supported "
6573 "channel list");
6574 return;
6575 }
6576
51e9f228 6577 p2p_update_channel_list(wpa_s->global->p2p, &chan, &cli_chan);
7b42862a
EMK		 6578
6579 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
6580 int freq;
6581 if (!ifs->current_ssid ||
6582 !ifs->current_ssid->p2p_group ||
6583 (ifs->current_ssid->mode != WPAS_MODE_P2P_GO &&
6584 ifs->current_ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION))
6585 continue;
6586 freq = ifs->current_ssid->frequency;
6587 if (freq_included(&chan, freq)) {
6588 wpa_dbg(ifs, MSG_DEBUG,
6589 "P2P GO operating frequency %d MHz in valid range",
6590 freq);
6591 continue;
6592 }
6593
6594 wpa_dbg(ifs, MSG_DEBUG,
6595 "P2P GO operating in invalid frequency %d MHz", freq);
6596 /* TODO: Consider using CSA or removing the group within
6597 * wpa_supplicant */
6598 wpa_msg(ifs, MSG_INFO, P2P_EVENT_REMOVE_AND_REFORM_GROUP);
6599 }
b5c9da8d 6600}
59eba7a2
JM		 6601
6602
50178335
JM		 6603static void wpas_p2p_scan_res_ignore(struct wpa_supplicant *wpa_s,
6604 struct wpa_scan_results *scan_res)
6605{
6606 wpa_printf(MSG_DEBUG, "P2P: Ignore scan results");
6607}
6608
6609
59eba7a2
JM		 6610int wpas_p2p_cancel(struct wpa_supplicant *wpa_s)
6611{
6612 struct wpa_global *global = wpa_s->global;
6613 int found = 0;
231bbd03 6614 const u8 *peer;
59eba7a2 6615
9526fd29
JM		 6616 if (global->p2p == NULL)
6617 return -1;
6618
59eba7a2
JM		 6619 wpa_printf(MSG_DEBUG, "P2P: Request to cancel group formation");
6620
6621 if (wpa_s->pending_interface_name[0] &&
6622 !is_zero_ether_addr(wpa_s->pending_interface_addr))
6623 found = 1;
6624
231bbd03
SS		 6625 peer = p2p_get_go_neg_peer(global->p2p);
6626 if (peer) {
6627 wpa_printf(MSG_DEBUG, "P2P: Unauthorize pending GO Neg peer "
6628 MACSTR, MAC2STR(peer));
6629 p2p_unauthorize(global->p2p, peer);
75c208b9 6630 found = 1;
231bbd03
SS		 6631 }
6632
50178335
JM		 6633 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_join) {
6634 wpa_printf(MSG_DEBUG, "P2P: Stop pending scan for join");
6635 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore;
6636 found = 1;
6637 }
6638
6639 if (wpa_s->pending_pd_before_join) {
6640 wpa_printf(MSG_DEBUG, "P2P: Stop pending PD before join");
6641 wpa_s->pending_pd_before_join = 0;
6642 found = 1;
6643 }
6644
59eba7a2
JM		 6645 wpas_p2p_stop_find(wpa_s);
6646
6647 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
6648 if (wpa_s == global->p2p_group_formation &&
a0a9f3b0
JM		 6649 (wpa_s->p2p_in_provisioning ||
6650 wpa_s->parent->pending_interface_type ==
6651 WPA_IF_P2P_CLIENT)) {
59eba7a2
JM		 6652 wpa_printf(MSG_DEBUG, "P2P: Interface %s in group "
6653 "formation found - cancelling",
6654 wpa_s->ifname);
6655 found = 1;
45fee6f0
SS		 6656 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
6657 wpa_s->parent, NULL);
30b80389
JM		 6658 if (wpa_s->p2p_in_provisioning) {
6659 wpas_group_formation_completed(wpa_s, 0);
6660 break;
6661 }
8dba4aef
JM		 6662 wpas_p2p_group_delete(wpa_s,
6663 P2P_GROUP_REMOVAL_REQUESTED);
59eba7a2 6664 break;
f05cee97
JM		 6665 } else if (wpa_s->p2p_in_invitation) {
6666 wpa_printf(MSG_DEBUG, "P2P: Interface %s in invitation found - cancelling",
6667 wpa_s->ifname);
6668 found = 1;
6669 wpas_p2p_group_formation_failed(wpa_s);
59eba7a2
JM		 6670 }
6671 }
6672
6673 if (!found) {
6674 wpa_printf(MSG_DEBUG, "P2P: No ongoing group formation found");
6675 return -1;
6676 }
6677
6678 return 0;
6679}
c973f386
JM		 6680
6681
6682void wpas_p2p_interface_unavailable(struct wpa_supplicant *wpa_s)
6683{
6684 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
6685 return;
6686
6687 wpa_printf(MSG_DEBUG, "P2P: Remove group due to driver resource not "
6688 "being available anymore");
8dba4aef 6689 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_UNAVAILABLE);
c973f386 6690}
7cfc4ac3
AGS		 6691
6692
6693void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s,
6694 int freq_24, int freq_5, int freq_overall)
6695{
6696 struct p2p_data *p2p = wpa_s->global->p2p;
152cff6b 6697 if (p2p == NULL)
7cfc4ac3
AGS		 6698 return;
6699 p2p_set_best_channels(p2p, freq_24, freq_5, freq_overall);
6700}
9d562b79
SS		 6701
6702
6703int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr)
6704{
6705 u8 peer[ETH_ALEN];
6706 struct p2p_data *p2p = wpa_s->global->p2p;
6707
152cff6b 6708 if (p2p == NULL)
9d562b79
SS		 6709 return -1;
6710
6711 if (hwaddr_aton(addr, peer))
6712 return -1;
6713
6714 return p2p_unauthorize(p2p, peer);
6715}
3103f345
JB		 6716
6717
6718/**
6719 * wpas_p2p_disconnect - Disconnect from a P2P Group
6720 * @wpa_s: Pointer to wpa_supplicant data
6721 * Returns: 0 on success, -1 on failure
6722 *
6723 * This can be used to disconnect from a group in which the local end is a P2P
6724 * Client or to end a P2P Group in case the local end is the Group Owner. If a
6725 * virtual network interface was created for this group, that interface will be
6726 * removed. Otherwise, only the configured P2P group network will be removed
6727 * from the interface.
6728 */
6729int wpas_p2p_disconnect(struct wpa_supplicant *wpa_s)
6730{
6731
6732 if (wpa_s == NULL)
6733 return -1;
6734
0aadd568
JM		 6735 return wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_REQUESTED) < 0 ?
6736 -1 : 0;
3103f345 6737}
303f60d3
JM		 6738
6739
6740int wpas_p2p_in_progress(struct wpa_supplicant *wpa_s)
6741{
ec01d5f6
JM		 6742 int ret;
6743
303f60d3
JM		 6744 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
6745 return 0;
6746
ec01d5f6
JM		 6747 ret = p2p_in_progress(wpa_s->global->p2p);
6748 if (ret == 0) {
6749 /*
6750 * Check whether there is an ongoing WPS provisioning step (or
6751 * other parts of group formation) on another interface since
6752 * p2p_in_progress() does not report this to avoid issues for
6753 * scans during such provisioning step.
6754 */
6755 if (wpa_s->global->p2p_group_formation &&
6756 wpa_s->global->p2p_group_formation != wpa_s) {
6757 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Another interface (%s) "
6758 "in group formation",
6759 wpa_s->global->p2p_group_formation->ifname);
6760 ret = 1;
6761 }
6762 }
6763
c1c0b35f 6764 if (!ret && wpa_s->global->p2p_go_wait_client.sec) {
151ab808
JB		 6765 struct os_reltime now;
6766 os_get_reltime(&now);
6767 if (os_reltime_expired(&now, &wpa_s->global->p2p_go_wait_client,
6768 P2P_MAX_INITIAL_CONN_WAIT_GO)) {
c1c0b35f
JM		 6769 /* Wait for the first client has expired */
6770 wpa_s->global->p2p_go_wait_client.sec = 0;
6771 } else {
6772 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Waiting for initial client connection during group formation");
6773 ret = 1;
6774 }
6775 }
6776
ec01d5f6 6777 return ret;
303f60d3 6778}
502618f7
JM		 6779
6780
6781void wpas_p2p_network_removed(struct wpa_supplicant *wpa_s,
6782 struct wpa_ssid *ssid)
502618f7
JM		 6783{
6784 if (wpa_s->p2p_in_provisioning && ssid->p2p_group &&
6785 eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
6786 wpa_s->parent, NULL) > 0) {
eb6f8c2b
AC		 6787 /**
6788 * Remove the network by scheduling the group formation
6789 * timeout to happen immediately. The teardown code
6790 * needs to be scheduled to run asynch later so that we
6791 * don't delete data from under ourselves unexpectedly.
6792 * Calling wpas_p2p_group_formation_timeout directly
6793 * causes a series of crashes in WPS failure scenarios.
6794 */
502618f7
JM		 6795 wpa_printf(MSG_DEBUG, "P2P: Canceled group formation due to "
6796 "P2P group network getting removed");
eb6f8c2b
AC		 6797 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
6798 wpa_s->parent, NULL);
502618f7
JM		 6799 }
6800}
87f841a1
JM		 6801
6802
6803struct wpa_ssid * wpas_p2p_get_persistent(struct wpa_supplicant *wpa_s,
c427ac92
JM		 6804 const u8 *addr, const u8 *ssid,
6805 size_t ssid_len)
87f841a1
JM		 6806{
6807 struct wpa_ssid *s;
fbdcfd57 6808 size_t i;
87f841a1
JM		 6809
6810 for (s = wpa_s->conf->ssid; s; s = s->next) {
fbdcfd57
JM		 6811 if (s->disabled != 2)
6812 continue;
c427ac92
JM		 6813 if (ssid &&
6814 (ssid_len != s->ssid_len ||
6815 os_memcmp(ssid, s->ssid, ssid_len) != 0))
6816 continue;
01a57fe4
JM		 6817 if (addr == NULL) {
6818 if (s->mode == WPAS_MODE_P2P_GO)
6819 return s;
6820 continue;
6821 }
fbdcfd57
JM		 6822 if (os_memcmp(s->bssid, addr, ETH_ALEN) == 0)
6823 return s; /* peer is GO in the persistent group */
6824 if (s->mode != WPAS_MODE_P2P_GO || s->p2p_client_list == NULL)
6825 continue;
6826 for (i = 0; i < s->num_p2p_clients; i++) {
6827 if (os_memcmp(s->p2p_client_list + i * ETH_ALEN,
6828 addr, ETH_ALEN) == 0)
6829 return s; /* peer is P2P client in persistent
6830 * group */
6831 }
87f841a1
JM		 6832 }
6833
6834 return NULL;
6835}
fbdcfd57
JM		 6836
6837
6838void wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
6839 const u8 *addr)
6840{
eab2b50d
JM		 6841 if (eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
6842 wpa_s->parent, NULL) > 0) {
6843 /*
6844 * This can happen if WPS provisioning step is not terminated
6845 * cleanly (e.g., P2P Client does not send WSC_Done). Since the
6846 * peer was able to connect, there is no need to time out group
41f85323
JM		 6847 * formation after this, though. In addition, this is used with
6848 * the initial connection wait on the GO as a separate formation
6849 * timeout and as such, expected to be hit after the initial WPS
6850 * provisioning step.
eab2b50d 6851 */
41f85323
JM		 6852 wpa_printf(MSG_DEBUG, "P2P: Canceled P2P group formation timeout on data connection");
6853 }
6854 if (!wpa_s->p2p_go_group_formation_completed) {
6855 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Marking group formation completed on GO on first data connection");
6856 wpa_s->p2p_go_group_formation_completed = 1;
6857 wpa_s->global->p2p_group_formation = NULL;
6858 wpa_s->p2p_in_provisioning = 0;
f05cee97 6859 wpa_s->p2p_in_invitation = 0;
eab2b50d 6860 }
c1c0b35f 6861 wpa_s->global->p2p_go_wait_client.sec = 0;
fbdcfd57
JM		 6862 if (addr == NULL)
6863 return;
6864 wpas_p2p_add_persistent_group_client(wpa_s, addr);
6865}
aa9bb764
JM		 6866
6867
6868static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
6869 int group_added)
6870{
6871 struct wpa_supplicant *group = wpa_s;
6872 if (wpa_s->global->p2p_group_formation)
6873 group = wpa_s->global->p2p_group_formation;
6874 wpa_s = wpa_s->parent;
b80eb89d 6875 offchannel_send_action_done(wpa_s);
aa9bb764 6876 if (group_added)
8dba4aef 6877 wpas_p2p_group_delete(group, P2P_GROUP_REMOVAL_SILENT);
aa9bb764
JM		 6878 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Fall back to GO Negotiation");
6879 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin,
6880 wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0,
6881 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
3bc462cb 6882 wpa_s->p2p_persistent_id,
e2308e4b 6883 wpa_s->p2p_pd_before_go_neg,
20ea1ca4
EP		 6884 wpa_s->p2p_go_ht40,
6885 wpa_s->p2p_go_vht);
aa9bb764
JM		 6886}
6887
6888
6889int wpas_p2p_scan_no_go_seen(struct wpa_supplicant *wpa_s)
6890{
6891 if (!wpa_s->p2p_fallback_to_go_neg ||
6892 wpa_s->p2p_in_provisioning <= 5)
6893 return 0;
6894
b80eb89d
JM		 6895 if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0)
6896 return 0; /* peer operating as a GO */
6897
aa9bb764
JM		 6898 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - "
6899 "fallback to GO Negotiation");
6900 wpas_p2p_fallback_to_go_neg(wpa_s, 1);
6901
6902 return 1;
6903}
05a77b3b
JM		 6904
6905
6906unsigned int wpas_p2p_search_delay(struct wpa_supplicant *wpa_s)
6907{
05a77b3b
JM		 6908 struct wpa_supplicant *ifs;
6909
6910 if (wpa_s->wpa_state > WPA_SCANNING) {
6911 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search delay due to "
6912 "concurrent operation",
d3b20469
NS		 6913 wpa_s->conf->p2p_search_delay);
6914 return wpa_s->conf->p2p_search_delay;
05a77b3b
JM		 6915 }
6916
5b81927d
JM		 6917 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
6918 radio_list) {
6919 if (ifs != wpa_s && ifs->wpa_state > WPA_SCANNING) {
05a77b3b
JM		 6920 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search "
6921 "delay due to concurrent operation on "
6922 "interface %s",
d3b20469
NS		 6923 wpa_s->conf->p2p_search_delay,
6924 ifs->ifname);
6925 return wpa_s->conf->p2p_search_delay;
05a77b3b
JM		 6926 }
6927 }
6928
6929 return 0;
6930}
f85f545e
JM		 6931
6932
43c693c2
JM		 6933static int wpas_p2p_remove_psk_entry(struct wpa_supplicant *wpa_s,
6934 struct wpa_ssid *s, const u8 *addr,
6935 int iface_addr)
6936{
6937 struct psk_list_entry *psk, *tmp;
6938 int changed = 0;
6939
6940 dl_list_for_each_safe(psk, tmp, &s->psk_list, struct psk_list_entry,
6941 list) {
6942 if ((iface_addr && !psk->p2p &&
6943 os_memcmp(addr, psk->addr, ETH_ALEN) == 0) ||
6944 (!iface_addr && psk->p2p &&
6945 os_memcmp(addr, psk->addr, ETH_ALEN) == 0)) {
6946 wpa_dbg(wpa_s, MSG_DEBUG,
6947 "P2P: Remove persistent group PSK list entry for "
6948 MACSTR " p2p=%u",
6949 MAC2STR(psk->addr), psk->p2p);
6950 dl_list_del(&psk->list);
6951 os_free(psk);
6952 changed++;
6953 }
6954 }
6955
6956 return changed;
6957}
6958
6959
01a57fe4
JM		 6960void wpas_p2p_new_psk_cb(struct wpa_supplicant *wpa_s, const u8 *mac_addr,
6961 const u8 *p2p_dev_addr,
6962 const u8 *psk, size_t psk_len)
6963{
6964 struct wpa_ssid *ssid = wpa_s->current_ssid;
6965 struct wpa_ssid *persistent;
0bceb8d6 6966 struct psk_list_entry *p, *last;
01a57fe4
JM		 6967
6968 if (psk_len != sizeof(p->psk))
6969 return;
6970
6971 if (p2p_dev_addr) {
6972 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR
6973 " p2p_dev_addr=" MACSTR,
6974 MAC2STR(mac_addr), MAC2STR(p2p_dev_addr));
6975 if (is_zero_ether_addr(p2p_dev_addr))
6976 p2p_dev_addr = NULL;
6977 } else {
6978 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR,
6979 MAC2STR(mac_addr));
6980 }
6981
6982 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
6983 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: new_psk_cb during group formation");
6984 /* To be added to persistent group once created */
6985 if (wpa_s->global->add_psk == NULL) {
6986 wpa_s->global->add_psk = os_zalloc(sizeof(*p));
6987 if (wpa_s->global->add_psk == NULL)
6988 return;
6989 }
6990 p = wpa_s->global->add_psk;
6991 if (p2p_dev_addr) {
6992 p->p2p = 1;
6993 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN);
6994 } else {
6995 p->p2p = 0;
6996 os_memcpy(p->addr, mac_addr, ETH_ALEN);
6997 }
6998 os_memcpy(p->psk, psk, psk_len);
6999 return;
7000 }
7001
7002 if (ssid->mode != WPAS_MODE_P2P_GO || !ssid->p2p_persistent_group) {
7003 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Ignore new_psk_cb on not-persistent GO");
7004 return;
7005 }
7006
7007 persistent = wpas_p2p_get_persistent(wpa_s->parent, NULL, ssid->ssid,
7008 ssid->ssid_len);
7009 if (!persistent) {
7010 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not find persistent group information to store the new PSK");
7011 return;
7012 }
7013
7014 p = os_zalloc(sizeof(*p));
7015 if (p == NULL)
7016 return;
7017 if (p2p_dev_addr) {
7018 p->p2p = 1;
7019 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN);
7020 } else {
7021 p->p2p = 0;
7022 os_memcpy(p->addr, mac_addr, ETH_ALEN);
7023 }
7024 os_memcpy(p->psk, psk, psk_len);
7025
0bceb8d6
JM		 7026 if (dl_list_len(&persistent->psk_list) > P2P_MAX_STORED_CLIENTS &&
7027 (last = dl_list_last(&persistent->psk_list,
7028 struct psk_list_entry, list))) {
01a57fe4
JM		 7029 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove oldest PSK entry for "
7030 MACSTR " (p2p=%u) to make room for a new one",
7031 MAC2STR(last->addr), last->p2p);
7032 dl_list_del(&last->list);
7033 os_free(last);
7034 }
7035
43c693c2
JM		 7036 wpas_p2p_remove_psk_entry(wpa_s->parent, persistent,
7037 p2p_dev_addr ? p2p_dev_addr : mac_addr,
7038 p2p_dev_addr == NULL);
7039 if (p2p_dev_addr) {
7040 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for p2p_dev_addr="
7041 MACSTR, MAC2STR(p2p_dev_addr));
7042 } else {
7043 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for addr=" MACSTR,
7044 MAC2STR(mac_addr));
7045 }
01a57fe4
JM		 7046 dl_list_add(&persistent->psk_list, &p->list);
7047
01a57fe4
JM		 7048 if (wpa_s->parent->conf->update_config &&
7049 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
7050 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
01a57fe4 7051}
f2c56602
JM		 7052
7053
7054static void wpas_p2p_remove_psk(struct wpa_supplicant *wpa_s,
7055 struct wpa_ssid *s, const u8 *addr,
7056 int iface_addr)
7057{
43c693c2 7058 int res;
f2c56602 7059
43c693c2 7060 res = wpas_p2p_remove_psk_entry(wpa_s, s, addr, iface_addr);
2a33687e
JM		 7061 if (res > 0 && wpa_s->conf->update_config &&
7062 wpa_config_write(wpa_s->confname, wpa_s->conf))
7063 wpa_dbg(wpa_s, MSG_DEBUG,
7064 "P2P: Failed to update configuration");
f2c56602
JM		 7065}
7066
7067
7068static void wpas_p2p_remove_client_go(struct wpa_supplicant *wpa_s,
7069 const u8 *peer, int iface_addr)
7070{
7071 struct hostapd_data *hapd;
7072 struct hostapd_wpa_psk *psk, *prev, *rem;
7073 struct sta_info *sta;
7074
7075 if (wpa_s->ap_iface == NULL || wpa_s->current_ssid == NULL ||
7076 wpa_s->current_ssid->mode != WPAS_MODE_P2P_GO)
7077 return;
7078
7079 /* Remove per-station PSK entry */
7080 hapd = wpa_s->ap_iface->bss[0];
7081 prev = NULL;
7082 psk = hapd->conf->ssid.wpa_psk;
7083 while (psk) {
7084 if ((iface_addr && os_memcmp(peer, psk->addr, ETH_ALEN) == 0) ||
7085 (!iface_addr &&
7086 os_memcmp(peer, psk->p2p_dev_addr, ETH_ALEN) == 0)) {
7087 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove operating group PSK entry for "
7088 MACSTR " iface_addr=%d",
7089 MAC2STR(peer), iface_addr);
7090 if (prev)
7091 prev->next = psk->next;
7092 else
7093 hapd->conf->ssid.wpa_psk = psk->next;
7094 rem = psk;
7095 psk = psk->next;
7096 os_free(rem);
7097 } else {
7098 prev = psk;
7099 psk = psk->next;
7100 }
7101 }
7102
7103 /* Disconnect from group */
7104 if (iface_addr)
7105 sta = ap_get_sta(hapd, peer);
7106 else
7107 sta = ap_get_sta_p2p(hapd, peer);
7108 if (sta) {
7109 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disconnect peer " MACSTR
7110 " (iface_addr=%d) from group",
7111 MAC2STR(peer), iface_addr);
7112 hostapd_drv_sta_deauth(hapd, sta->addr,
7113 WLAN_REASON_DEAUTH_LEAVING);
7114 ap_sta_deauthenticate(hapd, sta, WLAN_REASON_DEAUTH_LEAVING);
7115 }
7116}
7117
7118
7119void wpas_p2p_remove_client(struct wpa_supplicant *wpa_s, const u8 *peer,
7120 int iface_addr)
7121{
7122 struct wpa_ssid *s;
7123 struct wpa_supplicant *w;
7124
7125 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove client " MACSTR, MAC2STR(peer));
7126
7127 /* Remove from any persistent group */
7128 for (s = wpa_s->parent->conf->ssid; s; s = s->next) {
7129 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
7130 continue;
7131 if (!iface_addr)
7132 wpas_remove_persistent_peer(wpa_s, s, peer, 0);
7133 wpas_p2p_remove_psk(wpa_s->parent, s, peer, iface_addr);
7134 }
7135
7136 /* Remove from any operating group */
7137 for (w = wpa_s->global->ifaces; w; w = w->next)
7138 wpas_p2p_remove_client_go(w, peer, iface_addr);
7139}
5bf9a6c8
JM		 7140
7141
813e7b36
JM		 7142static void wpas_p2p_psk_failure_removal(void *eloop_ctx, void *timeout_ctx)
7143{
7144 struct wpa_supplicant *wpa_s = eloop_ctx;
7145 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_PSK_FAILURE);
7146}
7147
7148
8567866d
JJ		 7149static void wpas_p2p_group_freq_conflict(void *eloop_ctx, void *timeout_ctx)
7150{
7151 struct wpa_supplicant *wpa_s = eloop_ctx;
7152
7153 wpa_printf(MSG_DEBUG, "P2P: Frequency conflict - terminate group");
7154 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_FREQ_CONFLICT);
7155}
7156
7157
7158int wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant *wpa_s, int freq,
7159 struct wpa_ssid *ssid)
7160{
7161 struct wpa_supplicant *iface;
7162
7163 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
7164 if (!iface->current_ssid ||
7165 iface->current_ssid->frequency == freq ||
7166 (iface->p2p_group_interface == NOT_P2P_GROUP_INTERFACE &&
7167 !iface->current_ssid->p2p_group))
7168 continue;
7169
7170 /* Remove the connection with least priority */
7171 if (!wpas_is_p2p_prioritized(iface)) {
7172 /* STA connection has priority over existing
7173 * P2P connection, so remove the interface. */
7174 wpa_printf(MSG_DEBUG, "P2P: Removing P2P connection due to single channel concurrent mode frequency conflict");
7175 eloop_register_timeout(0, 0,
7176 wpas_p2p_group_freq_conflict,
7177 iface, NULL);
7178 /* If connection in progress is P2P connection, do not
7179 * proceed for the connection. */
7180 if (wpa_s == iface)
7181 return -1;
7182 else
7183 return 0;
7184 } else {
7185 /* P2P connection has priority, disable the STA network
7186 */
7187 wpa_supplicant_disable_network(wpa_s->global->ifaces,
7188 ssid);
7189 wpa_msg(wpa_s->global->ifaces, MSG_INFO,
7190 WPA_EVENT_FREQ_CONFLICT " id=%d", ssid->id);
7191 os_memset(wpa_s->global->ifaces->pending_bssid, 0,
7192 ETH_ALEN);
7193 /* If P2P connection is in progress, continue
7194 * connecting...*/
7195 if (wpa_s == iface)
7196 return 0;
7197 else
7198 return -1;
7199 }
7200 }
7201
7202 return 0;
7203}
7204
7205
5bf9a6c8
JM		 7206int wpas_p2p_4way_hs_failed(struct wpa_supplicant *wpa_s)
7207{
7208 struct wpa_ssid *ssid = wpa_s->current_ssid;
7209
7210 if (ssid == NULL || !ssid->p2p_group)
7211 return 0;
7212
7213 if (wpa_s->p2p_last_4way_hs_fail &&
7214 wpa_s->p2p_last_4way_hs_fail == ssid) {
7215 u8 go_dev_addr[ETH_ALEN];
7216 struct wpa_ssid *persistent;
7217
7218 if (wpas_p2p_persistent_group(wpa_s, go_dev_addr,
7219 ssid->ssid,
7220 ssid->ssid_len) <= 0) {
7221 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not determine whether 4-way handshake failures were for a persistent group");
7222 goto disconnect;
7223 }
7224
7225 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Two 4-way handshake failures for a P2P group - go_dev_addr="
7226 MACSTR, MAC2STR(go_dev_addr));
7227 persistent = wpas_p2p_get_persistent(wpa_s->parent, go_dev_addr,
7228 ssid->ssid,
7229 ssid->ssid_len);
7230 if (persistent == NULL || persistent->mode != WPAS_MODE_INFRA) {
7231 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No matching persistent group stored");
7232 goto disconnect;
7233 }
7234 wpa_msg_global(wpa_s->parent, MSG_INFO,
7235 P2P_EVENT_PERSISTENT_PSK_FAIL "%d",
7236 persistent->id);
7237 disconnect:
7238 wpa_s->p2p_last_4way_hs_fail = NULL;
813e7b36
JM		 7239 /*
7240 * Remove the group from a timeout to avoid issues with caller
7241 * continuing to use the interface if this is on a P2P group
7242 * interface.
7243 */
7244 eloop_register_timeout(0, 0, wpas_p2p_psk_failure_removal,
7245 wpa_s, NULL);
5bf9a6c8
JM		 7246 return 1;
7247 }
7248
7249 wpa_s->p2p_last_4way_hs_fail = ssid;
7250 return 0;
7251}
93588780
JM		 7252
7253
7254#ifdef CONFIG_WPS_NFC
7255
7256static struct wpabuf * wpas_p2p_nfc_handover(int ndef, struct wpabuf *wsc,
7257 struct wpabuf *p2p)
7258{
7259 struct wpabuf *ret;
59b45d1a 7260 size_t wsc_len;
93588780
JM		 7261
7262 if (p2p == NULL) {
7263 wpabuf_free(wsc);
7264 wpa_printf(MSG_DEBUG, "P2P: No p2p buffer for handover");
7265 return NULL;
7266 }
7267
59b45d1a
JM		 7268 wsc_len = wsc ? wpabuf_len(wsc) : 0;
7269 ret = wpabuf_alloc(2 + wsc_len + 2 + wpabuf_len(p2p));
93588780
JM		 7270 if (ret == NULL) {
7271 wpabuf_free(wsc);
7272 wpabuf_free(p2p);
7273 return NULL;
7274 }
7275
59b45d1a
JM		 7276 wpabuf_put_be16(ret, wsc_len);
7277 if (wsc)
7278 wpabuf_put_buf(ret, wsc);
93588780
JM		 7279 wpabuf_put_be16(ret, wpabuf_len(p2p));
7280 wpabuf_put_buf(ret, p2p);
7281
7282 wpabuf_free(wsc);
7283 wpabuf_free(p2p);
7284 wpa_hexdump_buf(MSG_DEBUG,
7285 "P2P: Generated NFC connection handover message", ret);
7286
7287 if (ndef && ret) {
7288 struct wpabuf *tmp;
7289 tmp = ndef_build_p2p(ret);
7290 wpabuf_free(ret);
7291 if (tmp == NULL) {
7292 wpa_printf(MSG_DEBUG, "P2P: Failed to NDEF encapsulate handover request");
7293 return NULL;
7294 }
7295 ret = tmp;
7296 }
7297
7298 return ret;
7299}
7300
7301
abe44e3c
JM		 7302static int wpas_p2p_cli_freq(struct wpa_supplicant *wpa_s,
7303 struct wpa_ssid **ssid, u8 *go_dev_addr)
59b45d1a
JM		 7304{
7305 struct wpa_supplicant *iface;
7306
abe44e3c
JM		 7307 if (go_dev_addr)
7308 os_memset(go_dev_addr, 0, ETH_ALEN);
7309 if (ssid)
7310 *ssid = NULL;
59b45d1a
JM		 7311 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
7312 if (iface->wpa_state < WPA_ASSOCIATING ||
7313 iface->current_ssid == NULL || iface->assoc_freq == 0 ||
7314 !iface->current_ssid->p2p_group ||
7315 iface->current_ssid->mode != WPAS_MODE_INFRA)
7316 continue;
abe44e3c
JM		 7317 if (ssid)
7318 *ssid = iface->current_ssid;
7319 if (go_dev_addr)
7320 os_memcpy(go_dev_addr, iface->go_dev_addr, ETH_ALEN);
59b45d1a
JM		 7321 return iface->assoc_freq;
7322 }
7323 return 0;
7324}
7325
7326
93588780
JM		 7327struct wpabuf * wpas_p2p_nfc_handover_req(struct wpa_supplicant *wpa_s,
7328 int ndef)
7329{
7330 struct wpabuf *wsc, *p2p;
abe44e3c
JM		 7331 struct wpa_ssid *ssid;
7332 u8 go_dev_addr[ETH_ALEN];
7333 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr);
93588780
JM		 7334
7335 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) {
7336 wpa_printf(MSG_DEBUG, "P2P: P2P disabled - cannot build handover request");
7337 return NULL;
7338 }
7339
7340 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
7341 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
7342 &wpa_s->conf->wps_nfc_dh_privkey) < 0) {
7343 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No DH key available for handover request");
7344 return NULL;
7345 }
7346
59b45d1a
JM		 7347 if (cli_freq == 0) {
7348 wsc = wps_build_nfc_handover_req_p2p(
7349 wpa_s->parent->wps, wpa_s->conf->wps_nfc_dh_pubkey);
7350 } else
7351 wsc = NULL;
abe44e3c
JM		 7352 p2p = p2p_build_nfc_handover_req(wpa_s->global->p2p, cli_freq,
7353 go_dev_addr, ssid ? ssid->ssid : NULL,
7354 ssid ? ssid->ssid_len : 0);
93588780
JM		 7355
7356 return wpas_p2p_nfc_handover(ndef, wsc, p2p);
7357}
7358
7359
7360struct wpabuf * wpas_p2p_nfc_handover_sel(struct wpa_supplicant *wpa_s,
7361 int ndef, int tag)
7362{
7363 struct wpabuf *wsc, *p2p;
abe44e3c
JM		 7364 struct wpa_ssid *ssid;
7365 u8 go_dev_addr[ETH_ALEN];
7366 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr);
93588780
JM		 7367
7368 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7369 return NULL;
7370
7371 if (!tag && wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
7372 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
7373 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
7374 return NULL;
7375
59b45d1a
JM		 7376 if (cli_freq == 0) {
7377 wsc = wps_build_nfc_handover_sel_p2p(
7378 wpa_s->parent->wps,
7379 tag ? wpa_s->conf->wps_nfc_dev_pw_id :
7380 DEV_PW_NFC_CONNECTION_HANDOVER,
7381 wpa_s->conf->wps_nfc_dh_pubkey,
7382 tag ? wpa_s->conf->wps_nfc_dev_pw : NULL);
7383 } else
7384 wsc = NULL;
abe44e3c
JM		 7385 p2p = p2p_build_nfc_handover_sel(wpa_s->global->p2p, cli_freq,
7386 go_dev_addr, ssid ? ssid->ssid : NULL,
7387 ssid ? ssid->ssid_len : 0);
93588780
JM		 7388
7389 return wpas_p2p_nfc_handover(ndef, wsc, p2p);
7390}
7391
db6ae69e
JM		 7392
7393static int wpas_p2p_nfc_join_group(struct wpa_supplicant *wpa_s,
7394 struct p2p_nfc_params *params)
7395{
7396 wpa_printf(MSG_DEBUG, "P2P: Initiate join-group based on NFC "
23318bea
JM		 7397 "connection handover (freq=%d)",
7398 params->go_freq);
7399
7400 if (params->go_freq && params->go_ssid_len) {
7401 wpa_s->p2p_wps_method = WPS_NFC;
7402 wpa_s->pending_join_wps_method = WPS_NFC;
7403 os_memset(wpa_s->pending_join_iface_addr, 0, ETH_ALEN);
7404 os_memcpy(wpa_s->pending_join_dev_addr, params->go_dev_addr,
7405 ETH_ALEN);
7406 return wpas_p2p_join_start(wpa_s, params->go_freq,
7407 params->go_ssid,
7408 params->go_ssid_len);
7409 }
7410
db6ae69e
JM		 7411 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
7412 WPS_NFC, 0, 0, 1, 0, wpa_s->conf->p2p_go_intent,
23318bea 7413 params->go_freq, -1, 0, 1, 1);
db6ae69e
JM		 7414}
7415
7416
7417static int wpas_p2p_nfc_auth_join(struct wpa_supplicant *wpa_s,
8e9f53c3 7418 struct p2p_nfc_params *params, int tag)
db6ae69e 7419{
8e9f53c3
JM		 7420 int res, persistent;
7421 struct wpa_ssid *ssid;
7422
db6ae69e
JM		 7423 wpa_printf(MSG_DEBUG, "P2P: Authorize join-group based on NFC "
7424 "connection handover");
7425 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
8e9f53c3 7426 ssid = wpa_s->current_ssid;
db6ae69e
JM		 7427 if (ssid == NULL)
7428 continue;
7429 if (ssid->mode != WPAS_MODE_P2P_GO)
7430 continue;
7431 if (wpa_s->ap_iface == NULL)
7432 continue;
7433 break;
7434 }
7435 if (wpa_s == NULL) {
7436 wpa_printf(MSG_DEBUG, "P2P: Could not find GO interface");
7437 return -1;
7438 }
7439
7440 if (wpa_s->parent->p2p_oob_dev_pw_id !=
7441 DEV_PW_NFC_CONNECTION_HANDOVER &&
7442 !wpa_s->parent->p2p_oob_dev_pw) {
7443 wpa_printf(MSG_DEBUG, "P2P: No NFC Dev Pw known");
7444 return -1;
7445 }
8e9f53c3 7446 res = wpas_ap_wps_add_nfc_pw(
db6ae69e
JM		 7447 wpa_s, wpa_s->parent->p2p_oob_dev_pw_id,
7448 wpa_s->parent->p2p_oob_dev_pw,
7449 wpa_s->parent->p2p_peer_oob_pk_hash_known ?
7450 wpa_s->parent->p2p_peer_oob_pubkey_hash : NULL);
8e9f53c3
JM		 7451 if (res)
7452 return res;
7453
7454 if (!tag) {
7455 wpa_printf(MSG_DEBUG, "P2P: Negotiated handover - wait for peer to join without invitation");
7456 return 0;
7457 }
7458
7459 if (!params->peer ||
7460 !(params->peer->dev_capab & P2P_DEV_CAPAB_INVITATION_PROCEDURE))
7461 return 0;
7462
7463 wpa_printf(MSG_DEBUG, "P2P: Static handover - invite peer " MACSTR
7464 " to join", MAC2STR(params->peer->p2p_device_addr));
7465
7466 wpa_s->global->p2p_invite_group = wpa_s;
7467 persistent = ssid->p2p_persistent_group &&
7468 wpas_p2p_get_persistent(wpa_s->parent,
7469 params->peer->p2p_device_addr,
7470 ssid->ssid, ssid->ssid_len);
7471 wpa_s->parent->pending_invite_ssid_id = -1;
7472
7473 return p2p_invite(wpa_s->global->p2p, params->peer->p2p_device_addr,
7474 P2P_INVITE_ROLE_ACTIVE_GO, wpa_s->own_addr,
7475 ssid->ssid, ssid->ssid_len, ssid->frequency,
7476 wpa_s->global->p2p_dev_addr, persistent, 0,
7477 wpa_s->parent->p2p_oob_dev_pw_id);
db6ae69e
JM		 7478}
7479
7480
7481static int wpas_p2p_nfc_init_go_neg(struct wpa_supplicant *wpa_s,
b56f6c88
JM		 7482 struct p2p_nfc_params *params,
7483 int forced_freq)
db6ae69e
JM		 7484{
7485 wpa_printf(MSG_DEBUG, "P2P: Initiate GO Negotiation based on NFC "
7486 "connection handover");
7487 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
7488 WPS_NFC, 0, 0, 0, 0, wpa_s->conf->p2p_go_intent,
b56f6c88 7489 forced_freq, -1, 0, 1, 1);
db6ae69e
JM		 7490}
7491
7492
7493static int wpas_p2p_nfc_resp_go_neg(struct wpa_supplicant *wpa_s,
b56f6c88
JM		 7494 struct p2p_nfc_params *params,
7495 int forced_freq)
db6ae69e
JM		 7496{
7497 int res;
7498
7499 wpa_printf(MSG_DEBUG, "P2P: Authorize GO Negotiation based on NFC "
7500 "connection handover");
7501 res = wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL,
7502 WPS_NFC, 0, 0, 0, 1, wpa_s->conf->p2p_go_intent,
b56f6c88 7503 forced_freq, -1, 0, 1, 1);
db6ae69e
JM		 7504 if (res)
7505 return res;
7506
7507 res = wpas_p2p_listen(wpa_s, 60);
7508 if (res) {
7509 p2p_unauthorize(wpa_s->global->p2p,
7510 params->peer->p2p_device_addr);
7511 }
7512
7513 return res;
7514}
7515
7516
7517static int wpas_p2p_nfc_connection_handover(struct wpa_supplicant *wpa_s,
7518 const struct wpabuf *data,
b56f6c88 7519 int sel, int tag, int forced_freq)
db6ae69e
JM		 7520{
7521 const u8 *pos, *end;
7522 u16 len, id;
7523 struct p2p_nfc_params params;
7524 int res;
7525
7526 os_memset(&params, 0, sizeof(params));
7527 params.sel = sel;
7528
7529 wpa_hexdump_buf(MSG_DEBUG, "P2P: Received NFC tag payload", data);
7530
7531 pos = wpabuf_head(data);
7532 end = pos + wpabuf_len(data);
7533
7534 if (end - pos < 2) {
7535 wpa_printf(MSG_DEBUG, "P2P: Not enough data for Length of WSC "
7536 "attributes");
7537 return -1;
7538 }
7539 len = WPA_GET_BE16(pos);
7540 pos += 2;
7541 if (pos + len > end) {
7542 wpa_printf(MSG_DEBUG, "P2P: Not enough data for WSC "
7543 "attributes");
7544 return -1;
7545 }
7546 params.wsc_attr = pos;
7547 params.wsc_len = len;
7548 pos += len;
7549
7550 if (end - pos < 2) {
7551 wpa_printf(MSG_DEBUG, "P2P: Not enough data for Length of P2P "
7552 "attributes");
7553 return -1;
7554 }
7555 len = WPA_GET_BE16(pos);
7556 pos += 2;
7557 if (pos + len > end) {
7558 wpa_printf(MSG_DEBUG, "P2P: Not enough data for P2P "
7559 "attributes");
7560 return -1;
7561 }
7562 params.p2p_attr = pos;
7563 params.p2p_len = len;
7564 pos += len;
7565
7566 wpa_hexdump(MSG_DEBUG, "P2P: WSC attributes",
7567 params.wsc_attr, params.wsc_len);
7568 wpa_hexdump(MSG_DEBUG, "P2P: P2P attributes",
7569 params.p2p_attr, params.p2p_len);
7570 if (pos < end) {
7571 wpa_hexdump(MSG_DEBUG,
7572 "P2P: Ignored extra data after P2P attributes",
7573 pos, end - pos);
7574 }
7575
7576 res = p2p_process_nfc_connection_handover(wpa_s->global->p2p, &params);
7577 if (res)
7578 return res;
7579
74df9ecd
JM		 7580 if (params.next_step == NO_ACTION)
7581 return 0;
7582
7583 if (params.next_step == BOTH_GO) {
7584 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_BOTH_GO "peer=" MACSTR,
7585 MAC2STR(params.peer->p2p_device_addr));
7586 return 0;
7587 }
7588
59b45d1a 7589 if (params.next_step == PEER_CLIENT) {
abe44e3c
JM		 7590 if (!is_zero_ether_addr(params.go_dev_addr)) {
7591 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT
7592 "peer=" MACSTR " freq=%d go_dev_addr=" MACSTR
7593 " ssid=\"%s\"",
7594 MAC2STR(params.peer->p2p_device_addr),
7595 params.go_freq,
7596 MAC2STR(params.go_dev_addr),
7597 wpa_ssid_txt(params.go_ssid,
7598 params.go_ssid_len));
7599 } else {
7600 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT
7601 "peer=" MACSTR " freq=%d",
7602 MAC2STR(params.peer->p2p_device_addr),
7603 params.go_freq);
7604 }
59b45d1a
JM		 7605 return 0;
7606 }
7607
abe44e3c 7608 if (wpas_p2p_cli_freq(wpa_s, NULL, NULL)) {
59b45d1a
JM		 7609 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_WHILE_CLIENT "peer="
7610 MACSTR, MAC2STR(params.peer->p2p_device_addr));
7611 return 0;
7612 }
7613
db6ae69e
JM		 7614 wpabuf_free(wpa_s->p2p_oob_dev_pw);
7615 wpa_s->p2p_oob_dev_pw = NULL;
7616
7617 if (params.oob_dev_pw_len < WPS_OOB_PUBKEY_HASH_LEN + 2) {
7618 wpa_printf(MSG_DEBUG, "P2P: No peer OOB Dev Pw "
7619 "received");
7620 return -1;
7621 }
7622
7623 id = WPA_GET_BE16(params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN);
7624 wpa_printf(MSG_DEBUG, "P2P: Peer OOB Dev Pw %u", id);
7625 wpa_hexdump(MSG_DEBUG, "P2P: Peer OOB Public Key hash",
7626 params.oob_dev_pw, WPS_OOB_PUBKEY_HASH_LEN);
7627 os_memcpy(wpa_s->p2p_peer_oob_pubkey_hash,
7628 params.oob_dev_pw, WPS_OOB_PUBKEY_HASH_LEN);
7629 wpa_s->p2p_peer_oob_pk_hash_known = 1;
7630
7631 if (tag) {
7632 if (id < 0x10) {
7633 wpa_printf(MSG_DEBUG, "P2P: Static handover - invalid "
7634 "peer OOB Device Password Id %u", id);
7635 return -1;
7636 }
7637 wpa_printf(MSG_DEBUG, "P2P: Static handover - use peer OOB "
7638 "Device Password Id %u", id);
7639 wpa_hexdump_key(MSG_DEBUG, "P2P: Peer OOB Device Password",
7640 params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN + 2,
7641 params.oob_dev_pw_len -
7642 WPS_OOB_PUBKEY_HASH_LEN - 2);
7643 wpa_s->p2p_oob_dev_pw_id = id;
7644 wpa_s->p2p_oob_dev_pw = wpabuf_alloc_copy(
7645 params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN + 2,
7646 params.oob_dev_pw_len -
7647 WPS_OOB_PUBKEY_HASH_LEN - 2);
7648 if (wpa_s->p2p_oob_dev_pw == NULL)
7649 return -1;
7650
7651 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL &&
7652 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey,
7653 &wpa_s->conf->wps_nfc_dh_privkey) < 0)
7654 return -1;
7655 } else {
7656 wpa_printf(MSG_DEBUG, "P2P: Using abbreviated WPS handshake "
7657 "without Device Password");
7658 wpa_s->p2p_oob_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER;
7659 }
7660
7661 switch (params.next_step) {
7662 case NO_ACTION:
74df9ecd 7663 case BOTH_GO:
59b45d1a 7664 case PEER_CLIENT:
74df9ecd 7665 /* already covered above */
db6ae69e
JM		 7666 return 0;
7667 case JOIN_GROUP:
7668 return wpas_p2p_nfc_join_group(wpa_s, &params);
7669 case AUTH_JOIN:
8e9f53c3 7670 return wpas_p2p_nfc_auth_join(wpa_s, &params, tag);
db6ae69e 7671 case INIT_GO_NEG:
b56f6c88 7672 return wpas_p2p_nfc_init_go_neg(wpa_s, &params, forced_freq);
db6ae69e
JM		 7673 case RESP_GO_NEG:
7674 /* TODO: use own OOB Dev Pw */
b56f6c88 7675 return wpas_p2p_nfc_resp_go_neg(wpa_s, &params, forced_freq);
db6ae69e
JM		 7676 }
7677
7678 return -1;
7679}
7680
7681
dd37a938 7682int wpas_p2p_nfc_tag_process(struct wpa_supplicant *wpa_s,
b56f6c88 7683 const struct wpabuf *data, int forced_freq)
dd37a938
JM		 7684{
7685 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7686 return -1;
7687
b56f6c88 7688 return wpas_p2p_nfc_connection_handover(wpa_s, data, 1, 1, forced_freq);
dd37a938
JM		 7689}
7690
7691
db6ae69e
JM		 7692int wpas_p2p_nfc_report_handover(struct wpa_supplicant *wpa_s, int init,
7693 const struct wpabuf *req,
b56f6c88 7694 const struct wpabuf *sel, int forced_freq)
db6ae69e
JM		 7695{
7696 struct wpabuf *tmp;
7697 int ret;
7698
7699 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7700 return -1;
7701
7702 wpa_printf(MSG_DEBUG, "NFC: P2P connection handover reported");
7703
7704 wpa_hexdump_ascii(MSG_DEBUG, "NFC: Req",
7705 wpabuf_head(req), wpabuf_len(req));
7706 wpa_hexdump_ascii(MSG_DEBUG, "NFC: Sel",
7707 wpabuf_head(sel), wpabuf_len(sel));
b56f6c88
JM		 7708 if (forced_freq)
7709 wpa_printf(MSG_DEBUG, "NFC: Forced freq %d", forced_freq);
db6ae69e
JM		 7710 tmp = ndef_parse_p2p(init ? sel : req);
7711 if (tmp == NULL) {
7712 wpa_printf(MSG_DEBUG, "P2P: Could not parse NDEF");
7713 return -1;
7714 }
7715
b56f6c88
JM		 7716 ret = wpas_p2p_nfc_connection_handover(wpa_s, tmp, init, 0,
7717 forced_freq);
db6ae69e
JM		 7718 wpabuf_free(tmp);
7719
7720 return ret;
7721}
7722
c4f87a70
JM		 7723
7724int wpas_p2p_nfc_tag_enabled(struct wpa_supplicant *wpa_s, int enabled)
7725{
7726 const u8 *if_addr;
7727 int go_intent = wpa_s->conf->p2p_go_intent;
dd876771 7728 struct wpa_supplicant *iface;
c4f87a70
JM		 7729
7730 if (wpa_s->global->p2p == NULL)
7731 return -1;
7732
7733 if (!enabled) {
dd876771
JM		 7734 wpa_printf(MSG_DEBUG, "P2P: Disable use of own NFC Tag");
7735 for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
7736 {
7737 if (!iface->ap_iface)
7738 continue;
7739 hostapd_wps_nfc_token_disable(iface->ap_iface->bss[0]);
7740 }
c4f87a70
JM		 7741 p2p_set_authorized_oob_dev_pw_id(wpa_s->global->p2p, 0,
7742 0, NULL);
7743 if (wpa_s->p2p_nfc_tag_enabled)
7744 wpas_p2p_remove_pending_group_interface(wpa_s);
7745 wpa_s->p2p_nfc_tag_enabled = 0;
7746 return 0;
7747 }
7748
7749 if (wpa_s->global->p2p_disabled)
7750 return -1;
7751
7752 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL ||
7753 wpa_s->conf->wps_nfc_dh_privkey == NULL ||
7754 wpa_s->conf->wps_nfc_dev_pw == NULL ||
7755 wpa_s->conf->wps_nfc_dev_pw_id < 0x10) {
7756 wpa_printf(MSG_DEBUG, "P2P: NFC password token not configured "
7757 "to allow static handover cases");
7758 return -1;
7759 }
7760
dd876771
JM		 7761 wpa_printf(MSG_DEBUG, "P2P: Enable use of own NFC Tag");
7762
c4f87a70
JM		 7763 wpa_s->p2p_oob_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
7764 wpabuf_free(wpa_s->p2p_oob_dev_pw);
7765 wpa_s->p2p_oob_dev_pw = wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
7766 if (wpa_s->p2p_oob_dev_pw == NULL)
7767 return -1;
7768 wpa_s->p2p_peer_oob_pk_hash_known = 0;
7769
67d39cfb
MB		 7770 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO ||
7771 wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT) {
7772 /*
7773 * P2P Group Interface present and the command came on group
7774 * interface, so enable the token for the current interface.
7775 */
7776 wpa_s->create_p2p_iface = 0;
7777 } else {
7778 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
7779 }
c4f87a70
JM		 7780
7781 if (wpa_s->create_p2p_iface) {
7782 enum wpa_driver_if_type iftype;
7783 /* Prepare to add a new interface for the group */
7784 iftype = WPA_IF_P2P_GROUP;
7785 if (go_intent == 15)
7786 iftype = WPA_IF_P2P_GO;
7787 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
7788 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
7789 "interface for the group");
7790 return -1;
7791 }
7792
7793 if_addr = wpa_s->pending_interface_addr;
7794 } else
7795 if_addr = wpa_s->own_addr;
7796
7797 wpa_s->p2p_nfc_tag_enabled = enabled;
7798
dd876771
JM		 7799 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
7800 struct hostapd_data *hapd;
7801 if (iface->ap_iface == NULL)
7802 continue;
7803 hapd = iface->ap_iface->bss[0];
7804 wpabuf_free(hapd->conf->wps_nfc_dh_pubkey);
7805 hapd->conf->wps_nfc_dh_pubkey =
7806 wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey);
7807 wpabuf_free(hapd->conf->wps_nfc_dh_privkey);
7808 hapd->conf->wps_nfc_dh_privkey =
7809 wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey);
7810 wpabuf_free(hapd->conf->wps_nfc_dev_pw);
7811 hapd->conf->wps_nfc_dev_pw =
7812 wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw);
7813 hapd->conf->wps_nfc_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id;
7814
7815 if (hostapd_wps_nfc_token_enable(iface->ap_iface->bss[0]) < 0) {
7816 wpa_dbg(iface, MSG_DEBUG,
7817 "P2P: Failed to enable NFC Tag for GO");
7818 }
7819 }
c4f87a70
JM		 7820 p2p_set_authorized_oob_dev_pw_id(
7821 wpa_s->global->p2p, wpa_s->conf->wps_nfc_dev_pw_id, go_intent,
7822 if_addr);
7823
7824 return 0;
7825}
7826
93588780 7827#endif /* CONFIG_WPS_NFC */
e3bd6e9d
IP		 7828
7829
7830static void wpas_p2p_optimize_listen_channel(struct wpa_supplicant *wpa_s,
7831 struct wpa_used_freq_data *freqs,
7832 unsigned int num)
7833{
7834 u8 curr_chan, cand, chan;
7835 unsigned int i;
7836
7837 curr_chan = p2p_get_listen_channel(wpa_s->global->p2p);
7838 for (i = 0, cand = 0; i < num; i++) {
7839 ieee80211_freq_to_chan(freqs[i].freq, &chan);
7840 if (curr_chan == chan) {
7841 cand = 0;
7842 break;
7843 }
7844
7845 if (chan == 1 || chan == 6 || chan == 11)
7846 cand = chan;
7847 }
7848
7849 if (cand) {
7850 wpa_dbg(wpa_s, MSG_DEBUG,
7851 "P2P: Update Listen channel to %u baased on operating channel",
7852 cand);
7853 p2p_set_listen_channel(wpa_s->global->p2p, 81, cand, 0);
7854 }
7855}
7856
7857
7858void wpas_p2p_indicate_state_change(struct wpa_supplicant *wpa_s)
7859{
7860 struct wpa_used_freq_data *freqs;
7861 unsigned int num = wpa_s->num_multichan_concurrent;
7862
7863 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
7864 return;
7865
7866 /*
7867 * If possible, optimize the Listen channel to be a channel that is
7868 * already used by one of the other interfaces.
7869 */
7870 if (!wpa_s->conf->p2p_optimize_listen_chan)
7871 return;
7872
7873 if (!wpa_s->current_ssid || wpa_s->wpa_state != WPA_COMPLETED)
7874 return;
7875
7876 freqs = os_calloc(num, sizeof(struct wpa_used_freq_data));
7877 if (!freqs)
7878 return;
7879
7880 num = get_shared_radio_freqs_data(wpa_s, freqs, num);
7881
7882 wpas_p2p_optimize_listen_channel(wpa_s, freqs, num);
7883 os_free(freqs);
7884}
bd10d938
JM		 7885
7886
7887void wpas_p2p_deinit_iface(struct wpa_supplicant *wpa_s)
7888{
7889 if (wpa_s == wpa_s->parent)
7890 wpas_p2p_group_remove(wpa_s, "*");
7891 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) {
7892 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing "
7893 "the management interface is being removed");
7894 wpas_p2p_deinit_global(wpa_s->global);
7895 }
7896}
7897
7898
7899void wpas_p2p_ap_deinit(struct wpa_supplicant *wpa_s)
7900{
7901 if (wpa_s->ap_iface->bss)
7902 wpa_s->ap_iface->bss[0]->p2p_group = NULL;
7903 wpas_p2p_group_deinit(wpa_s);
7904}
Unnamed repository; edit this file 'description' to name the repository.