1 /*
2 * Wi-Fi Direct - P2P module
3 * Copyright (c) 2009-2010, Atheros Communications
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #include "common.h"
12 #include "eloop.h"
13 #include "common/defs.h"
14 #include "common/ieee802_11_defs.h"
15 #include "common/ieee802_11_common.h"
16 #include "common/wpa_ctrl.h"
17 #include "crypto/sha256.h"
18 #include "crypto/crypto.h"
19 #include "wps/wps_i.h"
20 #include "p2p_i.h"
21 #include "p2p.h"
22
23 #ifdef OPEN_HARMONY_MIRACAST_SINK_OPT
24 #include "hm_miracast_sink.h"
25 #endif
26
27 #ifdef CONFIG_OPEN_HARMONY_P2P_DEV_NOTIFY
28 #include "parse_miracast_ie.h"
29 #endif
30
31 #ifdef CONFIG_P2P_CHR
32 #include "wpa_hw_p2p_chr.h"
33 #endif
34
35 #ifdef CONFIG_LIBWPA_VENDOR
36 #include "wpa_client.h"
37 #endif
38
39 #ifdef CONFIG_WIFI_RPT
40 #define DEFAULT_RPT_ID -3
41 #endif
42
43 static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx);
44 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
45 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
46 const u8 *sa, const u8 *data, size_t len,
47 int rx_freq);
48 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
49 const u8 *sa, const u8 *data,
50 size_t len);
51
52 #if !defined(CONFIG_OPEN_HARMONY_PATCH) || !defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
53 static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx);
54 #endif
55 static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx);
56
57
58 /*
59 * p2p_scan recovery timeout
60 *
61 * Many drivers are using 30 second timeout on scan results. Allow a bit larger
62 * timeout for this to avoid hitting P2P timeout unnecessarily.
63 */
64 #define P2P_SCAN_TIMEOUT 35
65
66 /**
67 * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer
68 * entries will be removed
69 */
70 #ifndef P2P_PEER_EXPIRATION_AGE
71 #define P2P_PEER_EXPIRATION_AGE 60
72 #endif /* P2P_PEER_EXPIRATION_AGE */
73
74 #ifdef OPEN_HARMONY_P2P_ONEHOP_FIND
75 #define ONEHOP_LISTEHTIME_USEC (20 * 1000)
76 #endif
77
78 #ifdef CONFIG_OHOS_P2P
79 #define P2P_CONNECT_TIMEOUT_USEC (200 *10000)
80 #endif
81
82 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
83 #define P2P_CONNECT_TIMEOUT_MAX_USEC (200 * 10000)
84 #else
85 #define P2P_CONNECT_TIMEOUT_DEFAULT_USEC (500 * 1000)
86 #endif
87
88 #define P2P_CONNECT_TIMEOUT_MIN_USEC (100 * 1000)
89
90 #ifdef CONFIG_OPEN_HARMONY_P2P_DEV_NOTIFY
91 struct wpabuf *g_pvt_wfd_elems = NULL;
92
is_pvt_wfd_elems_valid()93 int is_pvt_wfd_elems_valid()
94 {
95 return g_pvt_wfd_elems != NULL;
96 }
97
wfd_add_pvt_elem_hex(char ** wfd_dev_info_hex)98 void wfd_add_pvt_elem_hex(char **wfd_dev_info_hex)
99 {
100 wifi_display_add_pvt_elem_hex(g_pvt_wfd_elems, wfd_dev_info_hex);
101 }
102
get_pvt_wfd_elems(const u8 * ies,size_t ies_len)103 static void get_pvt_wfd_elems(const u8 *ies, size_t ies_len)
104 {
105 p2p_get_pvt_wfd_elems(&g_pvt_wfd_elems, ies, ies_len);
106 }
107
free_pvt_wfd_elems()108 static void free_pvt_wfd_elems()
109 {
110 wpabuf_free(g_pvt_wfd_elems);
111 g_pvt_wfd_elems = NULL;
112 }
113 #endif
114
p2p_expire_peers(struct p2p_data * p2p)115 void p2p_expire_peers(struct p2p_data *p2p)
116 {
117 struct p2p_device *dev, *n;
118 struct os_reltime now;
119 size_t i;
120
121 os_get_reltime(&now);
122 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
123 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec)
124 continue;
125
126 if (dev == p2p->go_neg_peer) {
127 /*
128 * GO Negotiation is in progress with the peer, so
129 * don't expire the peer entry until GO Negotiation
130 * fails or times out.
131 */
132 continue;
133 }
134
135 if (p2p->cfg->go_connected &&
136 p2p->cfg->go_connected(p2p->cfg->cb_ctx,
137 dev->info.p2p_device_addr)) {
138 /*
139 * We are connected as a client to a group in which the
140 * peer is the GO, so do not expire the peer entry.
141 */
142 os_get_reltime(&dev->last_seen);
143 continue;
144 }
145
146 for (i = 0; i < p2p->num_groups; i++) {
147 if (p2p_group_is_client_connected(
148 p2p->groups[i], dev->info.p2p_device_addr))
149 break;
150 }
151 if (i < p2p->num_groups) {
152 /*
153 * The peer is connected as a client in a group where
154 * we are the GO, so do not expire the peer entry.
155 */
156 os_get_reltime(&dev->last_seen);
157 continue;
158 }
159
160 p2p_dbg(p2p, "Expiring old peer entry " MACSTR_SEC,
161 MAC2STR_SEC(dev->info.p2p_device_addr));
162 dl_list_del(&dev->list);
163 p2p_device_free(p2p, dev);
164 }
165 }
166
167
p2p_state_txt(int state)168 static const char * p2p_state_txt(int state)
169 {
170 switch (state) {
171 case P2P_IDLE:
172 return "IDLE";
173 case P2P_SEARCH:
174 return "SEARCH";
175 case P2P_CONNECT:
176 return "CONNECT";
177 case P2P_CONNECT_LISTEN:
178 return "CONNECT_LISTEN";
179 case P2P_GO_NEG:
180 return "GO_NEG";
181 case P2P_LISTEN_ONLY:
182 return "LISTEN_ONLY";
183 case P2P_WAIT_PEER_CONNECT:
184 return "WAIT_PEER_CONNECT";
185 case P2P_WAIT_PEER_IDLE:
186 return "WAIT_PEER_IDLE";
187 case P2P_SD_DURING_FIND:
188 return "SD_DURING_FIND";
189 case P2P_PROVISIONING:
190 return "PROVISIONING";
191 case P2P_PD_DURING_FIND:
192 return "PD_DURING_FIND";
193 case P2P_INVITE:
194 return "INVITE";
195 case P2P_INVITE_LISTEN:
196 return "INVITE_LISTEN";
197 default:
198 return "?";
199 }
200 }
201
202
p2p_get_state_txt(struct p2p_data * p2p)203 const char * p2p_get_state_txt(struct p2p_data *p2p)
204 {
205 return p2p_state_txt(p2p->state);
206 }
207
208
p2p_get_p2ps_adv_list(struct p2p_data * p2p)209 struct p2ps_advertisement * p2p_get_p2ps_adv_list(struct p2p_data *p2p)
210 {
211 return p2p ? p2p->p2ps_adv_list : NULL;
212 }
213
214
p2p_set_intended_addr(struct p2p_data * p2p,const u8 * intended_addr)215 void p2p_set_intended_addr(struct p2p_data *p2p, const u8 *intended_addr)
216 {
217 if (p2p && intended_addr)
218 os_memcpy(p2p->intended_addr, intended_addr, ETH_ALEN);
219 }
220
221
p2p_get_provisioning_info(struct p2p_data * p2p,const u8 * addr)222 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr)
223 {
224 struct p2p_device *dev = NULL;
225
226 if (!addr || !p2p)
227 return 0;
228
229 dev = p2p_get_device(p2p, addr);
230 if (dev)
231 return dev->wps_prov_info;
232 else
233 return 0;
234 }
235
236
p2p_clear_provisioning_info(struct p2p_data * p2p,const u8 * addr)237 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr)
238 {
239 struct p2p_device *dev = NULL;
240
241 if (!addr || !p2p)
242 return;
243
244 dev = p2p_get_device(p2p, addr);
245 if (dev)
246 dev->wps_prov_info = 0;
247 }
248
249
p2p_set_state(struct p2p_data * p2p,int new_state)250 void p2p_set_state(struct p2p_data *p2p, int new_state)
251 {
252 p2p_warning(p2p, "State %s -> %s",
253 p2p_state_txt(p2p->state), p2p_state_txt(new_state));
254 p2p->state = new_state;
255
256 if (new_state == P2P_IDLE && p2p->pending_channel) {
257 p2p_dbg(p2p, "Apply change in listen channel");
258 p2p->cfg->reg_class = p2p->pending_reg_class;
259 p2p->cfg->channel = p2p->pending_channel;
260 p2p->pending_reg_class = 0;
261 p2p->pending_channel = 0;
262 }
263 }
264
265
p2p_set_timeout(struct p2p_data * p2p,unsigned int sec,unsigned int usec)266 void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec)
267 {
268 p2p_warning(p2p, "Set timeout (state=%s): %u.%06u sec",
269 p2p_state_txt(p2p->state), sec, usec);
270 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
271 eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL);
272 }
273
274
p2p_clear_timeout(struct p2p_data * p2p)275 void p2p_clear_timeout(struct p2p_data *p2p)
276 {
277 p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state));
278 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
279 }
280
281
p2p_go_neg_failed(struct p2p_data * p2p,int status)282 void p2p_go_neg_failed(struct p2p_data *p2p, int status)
283 {
284 struct p2p_go_neg_results res;
285 struct p2p_device *peer = p2p->go_neg_peer;
286
287 if (!peer)
288 return;
289
290 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
291 if (p2p->state != P2P_SEARCH) {
292 /*
293 * Clear timeouts related to GO Negotiation if no new p2p_find
294 * has been started.
295 */
296 p2p_clear_timeout(p2p);
297 p2p_set_state(p2p, P2P_IDLE);
298 }
299
300 peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
301 peer->wps_method = WPS_NOT_READY;
302 peer->oob_pw_id = 0;
303 wpabuf_free(peer->go_neg_conf);
304 peer->go_neg_conf = NULL;
305 p2p->go_neg_peer = NULL;
306
307 os_memset(&res, 0, sizeof(res));
308 res.status = status;
309 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
310 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
311 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
312 }
313
314
p2p_listen_in_find(struct p2p_data * p2p,int dev_disc)315 static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc)
316 {
317 unsigned int r, tu;
318 int freq;
319 struct wpabuf *ies;
320
321 p2p_dbg(p2p, "Starting short listen state (state=%s)",
322 p2p_state_txt(p2p->state));
323
324 if (p2p->pending_listen_freq) {
325 /* We have a pending p2p_listen request */
326 p2p_dbg(p2p, "p2p_listen command pending already");
327 return;
328 }
329
330 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
331 if (freq < 0) {
332 p2p_dbg(p2p, "Unknown regulatory class/channel");
333 return;
334 }
335
336 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
337 r = 0;
338 tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) +
339 p2p->min_disc_int) * 100;
340 if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu)
341 tu = p2p->max_disc_tu;
342 if (!dev_disc && tu < 100)
343 tu = 100; /* Need to wait in non-device discovery use cases */
344 if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen)
345 tu = p2p->cfg->max_listen * 1000 / 1024;
346
347 if (tu == 0) {
348 p2p_dbg(p2p, "Skip listen state since duration was 0 TU");
349 p2p_set_timeout(p2p, 0, 0);
350 return;
351 }
352
353 ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
354 if (ies == NULL)
355 return;
356
357 p2p->pending_listen_freq = freq;
358 p2p->pending_listen_sec = 0;
359 #ifdef OPEN_HARMONY_P2P_ONEHOP_FIND
360 p2p->pending_listen_usec = p2p->pvt_p2p_service ==
361 P2P_ONEHOP_FIND ? ONEHOP_LISTEHTIME_USEC : 1024 * tu;
362 #else
363 p2p->pending_listen_usec = 1024 * tu;
364 #endif
365
366 #ifdef OPEN_HARMONY_P2P_ONEHOP_FIND
367 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq,
368 p2p->pending_listen_usec / 1000, ies) < 0) {
369 #else
370 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000,
371 ies) < 0) {
372 #endif
373 p2p_dbg(p2p, "Failed to start listen mode");
374 p2p->pending_listen_freq = 0;
375 } else {
376 p2p->pending_listen_wait_drv = true;
377 }
378 wpabuf_free(ies);
379 }
380
381
382 int p2p_listen(struct p2p_data *p2p, unsigned int timeout)
383 {
384 int freq;
385 struct wpabuf *ies;
386
387 p2p_dbg(p2p, "Going to listen(only) state");
388
389 if (p2p->pending_listen_freq) {
390 /* We have a pending p2p_listen request */
391 p2p_dbg(p2p, "p2p_listen command pending already");
392 return -1;
393 }
394
395 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel);
396 if (freq < 0) {
397 p2p_dbg(p2p, "Unknown regulatory class/channel");
398 return -1;
399 }
400
401 p2p->pending_listen_sec = timeout / 1000;
402 p2p->pending_listen_usec = (timeout % 1000) * 1000;
403
404 if (p2p->p2p_scan_running) {
405 if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) {
406 p2p_dbg(p2p, "p2p_scan running - connect is already pending - skip listen");
407 return 0;
408 }
409 p2p_dbg(p2p, "p2p_scan running - delay start of listen state");
410 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN;
411 return 0;
412 }
413
414 ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
415 if (ies == NULL)
416 return -1;
417
418 p2p->pending_listen_freq = freq;
419
420 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {
421 p2p_dbg(p2p, "Failed to start listen mode");
422 p2p->pending_listen_freq = 0;
423 wpabuf_free(ies);
424 return -1;
425 }
426 p2p->pending_listen_wait_drv = true;
427 wpabuf_free(ies);
428
429 p2p_set_state(p2p, P2P_LISTEN_ONLY);
430
431 return 0;
432 }
433
434
435 static void p2p_device_clear_reported(struct p2p_data *p2p)
436 {
437 struct p2p_device *dev;
438 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
439 dev->flags &= ~P2P_DEV_REPORTED;
440 dev->sd_reqs = 0;
441 }
442 }
443
444
445 /**
446 * p2p_get_device - Fetch a peer entry
447 * @p2p: P2P module context from p2p_init()
448 * @addr: P2P Device Address of the peer
449 * Returns: Pointer to the device entry or %NULL if not found
450 */
451 struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr)
452 {
453 struct p2p_device *dev;
454 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
455 if (ether_addr_equal(dev->info.p2p_device_addr, addr))
456 return dev;
457 }
458 return NULL;
459 }
460
461
462 /**
463 * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address
464 * @p2p: P2P module context from p2p_init()
465 * @addr: P2P Interface Address of the peer
466 * Returns: Pointer to the device entry or %NULL if not found
467 */
468 struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p,
469 const u8 *addr)
470 {
471 struct p2p_device *dev;
472 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
473 if (ether_addr_equal(dev->interface_addr, addr))
474 return dev;
475 }
476 return NULL;
477 }
478
479
480 /**
481 * p2p_create_device - Create a peer entry
482 * @p2p: P2P module context from p2p_init()
483 * @addr: P2P Device Address of the peer
484 * Returns: Pointer to the device entry or %NULL on failure
485 *
486 * If there is already an entry for the peer, it will be returned instead of
487 * creating a new one.
488 */
489 static struct p2p_device * p2p_create_device(struct p2p_data *p2p,
490 const u8 *addr)
491 {
492 struct p2p_device *dev, *oldest = NULL;
493 size_t count = 0;
494
495 dev = p2p_get_device(p2p, addr);
496 if (dev)
497 return dev;
498
499 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
500 count++;
501 if (oldest == NULL ||
502 os_reltime_before(&dev->last_seen, &oldest->last_seen))
503 oldest = dev;
504 }
505 if (count + 1 > p2p->cfg->max_peers && oldest) {
506 p2p_dbg(p2p,
507 "Remove oldest peer entry to make room for a new peer "
508 MACSTR_SEC, MAC2STR_SEC(oldest->info.p2p_device_addr));
509 dl_list_del(&oldest->list);
510 p2p_device_free(p2p, oldest);
511 }
512
513 dev = os_zalloc(sizeof(*dev));
514 if (dev == NULL)
515 return NULL;
516 dl_list_add(&p2p->devices, &dev->list);
517 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
518 dev->support_6ghz = false;
519
520 return dev;
521 }
522
523
524 static void p2p_copy_client_info(struct p2p_device *dev,
525 struct p2p_client_info *cli)
526 {
527 p2p_copy_filter_devname(dev->info.device_name,
528 sizeof(dev->info.device_name),
529 cli->dev_name, cli->dev_name_len);
530 dev->info.dev_capab = cli->dev_capab;
531 dev->info.config_methods = cli->config_methods;
532 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
533 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types;
534 if (dev->info.wps_sec_dev_type_list_len > WPS_SEC_DEV_TYPE_MAX_LEN)
535 dev->info.wps_sec_dev_type_list_len = WPS_SEC_DEV_TYPE_MAX_LEN;
536 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types,
537 dev->info.wps_sec_dev_type_list_len);
538 }
539
540
541 static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr,
542 const u8 *go_interface_addr, int freq,
543 const u8 *gi, size_t gi_len,
544 struct os_reltime *rx_time)
545 {
546 struct p2p_group_info info;
547 size_t c;
548 struct p2p_device *dev;
549
550 if (gi == NULL)
551 return 0;
552
553 if (p2p_group_info_parse(gi, gi_len, &info) < 0)
554 return -1;
555
556 /*
557 * Clear old data for this group; if the devices are still in the
558 * group, the information will be restored in the loop following this.
559 */
560 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
561 if (ether_addr_equal(dev->member_in_go_iface,
562 go_interface_addr)) {
563 os_memset(dev->member_in_go_iface, 0, ETH_ALEN);
564 os_memset(dev->member_in_go_dev, 0, ETH_ALEN);
565 }
566 }
567
568 for (c = 0; c < info.num_clients; c++) {
569 struct p2p_client_info *cli = &info.client[c];
570 if (ether_addr_equal(cli->p2p_device_addr, p2p->cfg->dev_addr))
571 continue; /* ignore our own entry */
572 dev = p2p_get_device(p2p, cli->p2p_device_addr);
573 if (dev) {
574 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY |
575 P2P_DEV_PROBE_REQ_ONLY)) {
576 /*
577 * Update information since we have not
578 * received this directly from the client.
579 */
580 p2p_copy_client_info(dev, cli);
581 } else {
582 /*
583 * Need to update P2P Client Discoverability
584 * flag since it is valid only in P2P Group
585 * Info attribute.
586 */
587 dev->info.dev_capab &=
588 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
589 dev->info.dev_capab |=
590 cli->dev_capab &
591 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
592 }
593 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
594 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
595 }
596 } else {
597 dev = p2p_create_device(p2p, cli->p2p_device_addr);
598 if (dev == NULL)
599 continue;
600 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
601 p2p_copy_client_info(dev, cli);
602 dev->oper_freq = freq;
603 p2p->cfg->dev_found(p2p->cfg->cb_ctx,
604 dev->info.p2p_device_addr,
605 &dev->info, 1);
606 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
607 }
608
609 os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
610 ETH_ALEN);
611 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime));
612 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN);
613 os_memcpy(dev->member_in_go_iface, go_interface_addr,
614 ETH_ALEN);
615 dev->flags |= P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT;
616 }
617
618 return 0;
619 }
620
621
622 static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev,
623 int probe_req, const struct p2p_message *msg)
624 {
625 os_memcpy(dev->info.device_name, msg->device_name,
626 sizeof(dev->info.device_name));
627
628 if (msg->manufacturer &&
629 msg->manufacturer_len < sizeof(dev->info.manufacturer)) {
630 os_memset(dev->info.manufacturer, 0,
631 sizeof(dev->info.manufacturer));
632 os_memcpy(dev->info.manufacturer, msg->manufacturer,
633 msg->manufacturer_len);
634 }
635
636 if (msg->model_name &&
637 msg->model_name_len < sizeof(dev->info.model_name)) {
638 os_memset(dev->info.model_name, 0,
639 sizeof(dev->info.model_name));
640 os_memcpy(dev->info.model_name, msg->model_name,
641 msg->model_name_len);
642 }
643
644 if (msg->model_number &&
645 msg->model_number_len < sizeof(dev->info.model_number)) {
646 os_memset(dev->info.model_number, 0,
647 sizeof(dev->info.model_number));
648 os_memcpy(dev->info.model_number, msg->model_number,
649 msg->model_number_len);
650 }
651
652 if (msg->serial_number &&
653 msg->serial_number_len < sizeof(dev->info.serial_number)) {
654 os_memset(dev->info.serial_number, 0,
655 sizeof(dev->info.serial_number));
656 os_memcpy(dev->info.serial_number, msg->serial_number,
657 msg->serial_number_len);
658 }
659
660 if (msg->pri_dev_type)
661 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
662 sizeof(dev->info.pri_dev_type));
663 else if (msg->wps_pri_dev_type)
664 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type,
665 sizeof(dev->info.pri_dev_type));
666
667 if (msg->wps_sec_dev_type_list) {
668 os_memcpy(dev->info.wps_sec_dev_type_list,
669 msg->wps_sec_dev_type_list,
670 msg->wps_sec_dev_type_list_len);
671 dev->info.wps_sec_dev_type_list_len =
672 msg->wps_sec_dev_type_list_len;
673 }
674
675 if (msg->capability) {
676 /*
677 * P2P Client Discoverability bit is reserved in all frames
678 * that use this function, so do not change its value here.
679 */
680 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
681 dev->info.dev_capab |= msg->capability[0] &
682 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
683 dev->info.group_capab = msg->capability[1];
684 }
685
686 p2p_update_peer_6ghz_capab(dev, msg);
687
688 if (msg->ext_listen_timing) {
689 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing);
690 dev->ext_listen_interval =
691 WPA_GET_LE16(msg->ext_listen_timing + 2);
692 }
693
694 if (!probe_req) {
695 u16 new_config_methods;
696 new_config_methods = msg->config_methods ?
697 msg->config_methods : msg->wps_config_methods;
698 if (new_config_methods &&
699 dev->info.config_methods != new_config_methods) {
700 p2p_dbg(p2p, "Update peer " MACSTR_SEC
701 " config_methods 0x%x -> 0x%x",
702 MAC2STR_SEC(dev->info.p2p_device_addr),
703 dev->info.config_methods,
704 new_config_methods);
705 dev->info.config_methods = new_config_methods;
706 }
707 }
708 }
709
710
711 void p2p_update_peer_6ghz_capab(struct p2p_device *dev,
712 const struct p2p_message *msg)
713 {
714 if (msg->capability &&
715 (msg->capability[0] & P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE))
716 dev->support_6ghz = true;
717 }
718
719
720 static void p2p_update_peer_vendor_elems(struct p2p_device *dev, const u8 *ies,
721 size_t ies_len)
722 {
723 const u8 *pos, *end;
724 u8 id, len;
725
726 wpabuf_free(dev->info.vendor_elems);
727 dev->info.vendor_elems = NULL;
728
729 end = ies + ies_len;
730
731 for (pos = ies; end - pos > 1; pos += len) {
732 id = *pos++;
733 len = *pos++;
734
735 if (len > end - pos)
736 break;
737
738 if (id != WLAN_EID_VENDOR_SPECIFIC || len < 3)
739 continue;
740
741 if (len >= 4) {
742 u32 type = WPA_GET_BE32(pos);
743
744 if (type == WPA_IE_VENDOR_TYPE ||
745 type == WMM_IE_VENDOR_TYPE ||
746 type == WPS_IE_VENDOR_TYPE ||
747 type == P2P_IE_VENDOR_TYPE ||
748 type == WFD_IE_VENDOR_TYPE)
749 continue;
750 }
751
752 /* Unknown vendor element - make raw IE data available */
753 if (wpabuf_resize(&dev->info.vendor_elems, 2 + len) < 0)
754 break;
755 wpabuf_put_data(dev->info.vendor_elems, pos - 2, 2 + len);
756 if (wpabuf_size(dev->info.vendor_elems) > 2000)
757 break;
758 }
759 }
760
761
762 static int p2p_compare_wfd_info(struct p2p_device *dev,
763 const struct p2p_message *msg)
764 {
765 if (dev->info.wfd_subelems && msg->wfd_subelems) {
766 if (dev->info.wfd_subelems->used != msg->wfd_subelems->used)
767 return 1;
768
769 return os_memcmp(dev->info.wfd_subelems->buf,
770 msg->wfd_subelems->buf,
771 dev->info.wfd_subelems->used);
772 }
773 if (dev->info.wfd_subelems || msg->wfd_subelems)
774 return 1;
775
776 return 0;
777 }
778
779
780 /**
781 * p2p_add_device - Add peer entries based on scan results or P2P frames
782 * @p2p: P2P module context from p2p_init()
783 * @addr: Source address of Beacon or Probe Response frame (may be either
784 * P2P Device Address or P2P Interface Address)
785 * @level: Signal level (signal strength of the received frame from the peer)
786 * @freq: Frequency on which the Beacon or Probe Response frame was received
787 * @rx_time: Time when the result was received
788 * @ies: IEs from the Beacon or Probe Response frame
789 * @ies_len: Length of ies buffer in octets
790 * @scan_res: Whether this was based on scan results
791 * Returns: 0 on success, -1 on failure
792 *
793 * If the scan result is for a GO, the clients in the group will also be added
794 * to the peer table. This function can also be used with some other frames
795 * like Provision Discovery Request that contains P2P Capability and P2P Device
796 * Info attributes.
797 */
798 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq,
799 struct os_reltime *rx_time, int level, const u8 *ies,
800 size_t ies_len, int scan_res)
801 {
802 struct p2p_device *dev;
803 struct p2p_message msg;
804 const u8 *p2p_dev_addr;
805 int wfd_changed;
806 int dev_name_changed;
807 int i;
808 struct os_reltime time_now;
809
810 os_memset(&msg, 0, sizeof(msg));
811 if (p2p_parse_ies(ies, ies_len, &msg)) {
812 p2p_dbg(p2p, "Failed to parse P2P IE for a device entry");
813 p2p_parse_free(&msg);
814 return -1;
815 }
816
817 if (msg.p2p_device_addr)
818 p2p_dev_addr = msg.p2p_device_addr;
819 else if (msg.device_id)
820 p2p_dev_addr = msg.device_id;
821 else {
822 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");
823 p2p_parse_free(&msg);
824 return -1;
825 }
826
827 if (!is_zero_ether_addr(p2p->peer_filter) &&
828 !ether_addr_equal(p2p_dev_addr, p2p->peer_filter)) {
829 p2p_dbg(p2p, "Do not add peer filter for " MACSTR_SEC
830 " due to peer filter", MAC2STR_SEC(p2p_dev_addr));
831 p2p_parse_free(&msg);
832 return 0;
833 }
834
835 dev = p2p_create_device(p2p, p2p_dev_addr);
836 if (dev == NULL) {
837 p2p_parse_free(&msg);
838 return -1;
839 }
840
841 if (rx_time == NULL) {
842 os_get_reltime(&time_now);
843 rx_time = &time_now;
844 }
845
846 /*
847 * Update the device entry only if the new peer
848 * entry is newer than the one previously stored, or if
849 * the device was previously seen as a P2P Client in a group
850 * and the new entry isn't older than a threshold.
851 */
852 if (dev->last_seen.sec > 0 &&
853 os_reltime_before(rx_time, &dev->last_seen) &&
854 (!(dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT) ||
855 os_reltime_expired(&dev->last_seen, rx_time,
856 P2P_DEV_GROUP_CLIENT_RESP_THRESHOLD))) {
857 p2p_dbg(p2p,
858 "Do not update peer entry based on old frame (rx_time=%u.%06u last_seen=%u.%06u flags=0x%x)",
859 (unsigned int) rx_time->sec,
860 (unsigned int) rx_time->usec,
861 (unsigned int) dev->last_seen.sec,
862 (unsigned int) dev->last_seen.usec,
863 dev->flags);
864 p2p_parse_free(&msg);
865 return -1;
866 }
867
868 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime));
869
870 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY |
871 P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT);
872
873 if (!ether_addr_equal(addr, p2p_dev_addr))
874 os_memcpy(dev->interface_addr, addr, ETH_ALEN);
875 if (msg.ssid &&
876 msg.ssid[1] <= sizeof(dev->oper_ssid) &&
877 (msg.ssid[1] != P2P_WILDCARD_SSID_LEN ||
878 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN)
879 != 0)) {
880 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]);
881 dev->oper_ssid_len = msg.ssid[1];
882 }
883
884 wpabuf_free(dev->info.p2ps_instance);
885 dev->info.p2ps_instance = NULL;
886 if (msg.adv_service_instance && msg.adv_service_instance_len)
887 dev->info.p2ps_instance = wpabuf_alloc_copy(
888 msg.adv_service_instance, msg.adv_service_instance_len);
889
890 if (freq >= 2412 && freq <= 2484 && msg.ds_params &&
891 *msg.ds_params >= 1 && *msg.ds_params <= 14) {
892 int ds_freq;
893 if (*msg.ds_params == 14)
894 ds_freq = 2484;
895 else
896 ds_freq = 2407 + *msg.ds_params * 5;
897 if (freq != ds_freq) {
898 p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz",
899 freq, ds_freq);
900 freq = ds_freq;
901 }
902 }
903
904 if (dev->listen_freq && dev->listen_freq != freq && scan_res) {
905 p2p_dbg(p2p, "Update Listen frequency based on scan results ("
906 MACSTR_SEC " %d -> %d MHz (DS param %d)",
907 MAC2STR_SEC(dev->info.p2p_device_addr), dev->listen_freq,
908 freq, msg.ds_params ? *msg.ds_params : -1);
909 }
910 if (scan_res) {
911 dev->listen_freq = freq;
912 if (msg.group_info)
913 dev->oper_freq = freq;
914 }
915 dev->info.level = level;
916
917 dev_name_changed = os_strncmp(dev->info.device_name, msg.device_name,
918 WPS_DEV_NAME_MAX_LEN) != 0;
919
920 p2p_copy_wps_info(p2p, dev, 0, &msg);
921
922 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
923 wpabuf_free(dev->info.wps_vendor_ext[i]);
924 dev->info.wps_vendor_ext[i] = NULL;
925 }
926
927 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
928 if (msg.wps_vendor_ext[i] == NULL)
929 break;
930 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy(
931 msg.wps_vendor_ext[i], msg.wps_vendor_ext_len[i]);
932 if (dev->info.wps_vendor_ext[i] == NULL)
933 break;
934 }
935
936 wfd_changed = p2p_compare_wfd_info(dev, &msg);
937
938 if (wfd_changed) {
939 wpabuf_free(dev->info.wfd_subelems);
940 if (msg.wfd_subelems)
941 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
942 else
943 dev->info.wfd_subelems = NULL;
944 }
945
946 if (scan_res) {
947 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq,
948 msg.group_info, msg.group_info_len,
949 rx_time);
950 }
951
952 p2p_parse_free(&msg);
953
954 p2p_update_peer_vendor_elems(dev, ies, ies_len);
955
956 if (dev->flags & P2P_DEV_REPORTED && !wfd_changed &&
957 !dev_name_changed &&
958 (!msg.adv_service_instance ||
959 (dev->flags & P2P_DEV_P2PS_REPORTED)))
960 return 0;
961
962 p2p_dbg(p2p, "Peer found with Listen frequency %d MHz (rx_time=%u.%06u)",
963 freq, (unsigned int) rx_time->sec,
964 (unsigned int) rx_time->usec);
965 if (dev->flags & P2P_DEV_USER_REJECTED) {
966 p2p_dbg(p2p, "Do not report rejected device");
967 return 0;
968 }
969
970 if (dev->info.config_methods == 0 &&
971 (freq == 2412 || freq == 2437 || freq == 2462)) {
972 /*
973 * If we have only seen a Beacon frame from a GO, we do not yet
974 * know what WPS config methods it supports. Since some
975 * applications use config_methods value from P2P-DEVICE-FOUND
976 * events, postpone reporting this peer until we've fully
977 * discovered its capabilities.
978 *
979 * At least for now, do this only if the peer was detected on
980 * one of the social channels since that peer can be easily be
981 * found again and there are no limitations of having to use
982 * passive scan on this channels, so this can be done through
983 * Probe Response frame that includes the config_methods
984 * information.
985 */
986 p2p_dbg(p2p, "Do not report peer " MACSTR_SEC
987 " with unknown config methods", MAC2STR_SEC(addr));
988 return 0;
989 }
990
991 #ifdef CONFIG_OPEN_HARMONY_P2P_DEV_NOTIFY
992 get_pvt_wfd_elems(ies, ies_len);
993 #endif
994
995 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
996 !(dev->flags & P2P_DEV_REPORTED_ONCE));
997
998 #ifdef CONFIG_OPEN_HARMONY_P2P_DEV_NOTIFY
999 free_pvt_wfd_elems();
1000 #endif
1001
1002 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
1003
1004 if (msg.adv_service_instance)
1005 dev->flags |= P2P_DEV_P2PS_REPORTED;
1006
1007 return 0;
1008 }
1009
1010
1011 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
1012 {
1013 int i;
1014
1015 if (p2p->go_neg_peer == dev) {
1016 /*
1017 * If GO Negotiation is in progress, report that it has failed.
1018 */
1019 p2p_go_neg_failed(p2p, -1);
1020 }
1021 if (p2p->invite_peer == dev)
1022 p2p->invite_peer = NULL;
1023 if (p2p->sd_peer == dev)
1024 p2p->sd_peer = NULL;
1025 if (p2p->pending_client_disc_go == dev)
1026 p2p->pending_client_disc_go = NULL;
1027
1028 /* dev_lost() device, but only if it was previously dev_found() */
1029 if (dev->flags & P2P_DEV_REPORTED_ONCE)
1030 p2p->cfg->dev_lost(p2p->cfg->cb_ctx,
1031 dev->info.p2p_device_addr);
1032
1033 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
1034 wpabuf_free(dev->info.wps_vendor_ext[i]);
1035 dev->info.wps_vendor_ext[i] = NULL;
1036 }
1037
1038 wpabuf_free(dev->info.wfd_subelems);
1039 #ifdef CONFIG_OPEN_HARMONY_P2P_DEV_NOTIFY
1040 wpabuf_free(g_pvt_wfd_elems);
1041 #endif
1042 wpabuf_free(dev->info.vendor_elems);
1043 wpabuf_free(dev->go_neg_conf);
1044 wpabuf_free(dev->info.p2ps_instance);
1045
1046 os_free(dev);
1047 }
1048
1049
1050 static int p2p_get_next_prog_freq(struct p2p_data *p2p)
1051 {
1052 struct p2p_channels *c;
1053 struct p2p_reg_class *cla;
1054 size_t cl, ch;
1055 int found = 0;
1056 u8 reg_class;
1057 u8 channel;
1058 int freq;
1059
1060 c = &p2p->cfg->channels;
1061 for (cl = 0; cl < c->reg_classes; cl++) {
1062 cla = &c->reg_class[cl];
1063 if (cla->reg_class != p2p->last_prog_scan_class)
1064 continue;
1065 for (ch = 0; ch < cla->channels; ch++) {
1066 if (cla->channel[ch] == p2p->last_prog_scan_chan) {
1067 found = 1;
1068 break;
1069 }
1070 }
1071 if (found)
1072 break;
1073 }
1074
1075 if (!found) {
1076 /* Start from beginning */
1077 reg_class = c->reg_class[0].reg_class;
1078 channel = c->reg_class[0].channel[0];
1079 } else {
1080 /* Pick the next channel */
1081 ch++;
1082 if (ch == cla->channels) {
1083 cl++;
1084 if (cl == c->reg_classes)
1085 cl = 0;
1086 ch = 0;
1087 }
1088 reg_class = c->reg_class[cl].reg_class;
1089 channel = c->reg_class[cl].channel[ch];
1090 }
1091
1092 freq = p2p_channel_to_freq(reg_class, channel);
1093 p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz",
1094 reg_class, channel, freq);
1095 p2p->last_prog_scan_class = reg_class;
1096 p2p->last_prog_scan_chan = channel;
1097
1098 if (freq == 2412 || freq == 2437 || freq == 2462)
1099 return 0; /* No need to add social channels */
1100 return freq;
1101 }
1102
1103
1104 static void p2p_search(struct p2p_data *p2p)
1105 {
1106 int freq = 0;
1107 enum p2p_scan_type type;
1108 u16 pw_id = DEV_PW_DEFAULT;
1109 int res;
1110
1111 if (p2p->drv_in_listen) {
1112 p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing");
1113 return;
1114 }
1115 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1116 p2p->pending_listen_wait_drv = false;
1117
1118 if (p2p->find_pending_full &&
1119 (p2p->find_type == P2P_FIND_PROGRESSIVE ||
1120 p2p->find_type == P2P_FIND_START_WITH_FULL)) {
1121 type = P2P_SCAN_FULL;
1122 p2p_dbg(p2p, "Starting search (pending full scan)");
1123 p2p->find_pending_full = 0;
1124 } else if ((p2p->find_type == P2P_FIND_PROGRESSIVE &&
1125 (freq = p2p_get_next_prog_freq(p2p)) > 0) ||
1126 (p2p->find_type == P2P_FIND_START_WITH_FULL &&
1127 (freq = p2p->find_specified_freq) > 0)) {
1128 type = P2P_SCAN_SOCIAL_PLUS_ONE;
1129 p2p_dbg(p2p, "Starting search (+ freq %u)", freq);
1130 #ifdef OPEN_HARMONY_P2P_ONEHOP_FIND
1131 } else if (p2p->pvt_p2p_service == P2P_ONEHOP_FIND) {
1132 type = P2P_SCAN_POSSIBLE_CHANNEL;
1133 p2p_dbg(p2p, "Starting onehop search");
1134
1135 #endif
1136 } else {
1137 type = P2P_SCAN_SOCIAL;
1138 p2p_dbg(p2p, "Starting search");
1139 }
1140
1141 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,
1142 p2p->num_req_dev_types, p2p->req_dev_types,
1143 p2p->find_dev_id, pw_id, p2p->include_6ghz);
1144 if (res < 0) {
1145 p2p_dbg(p2p, "Scan request schedule failed");
1146 p2p_continue_find(p2p);
1147 }
1148 }
1149
1150
1151 static void p2p_find_timeout(void *eloop_ctx, void *timeout_ctx)
1152 {
1153 struct p2p_data *p2p = eloop_ctx;
1154 p2p_dbg(p2p, "Find timeout -> stop");
1155 p2p_stop_find(p2p);
1156 }
1157
1158
1159 void p2p_notify_scan_trigger_status(struct p2p_data *p2p, int status)
1160 {
1161 if (status != 0) {
1162 p2p_dbg(p2p, "Scan request failed");
1163 /* Do continue find even for the first p2p_find_scan */
1164 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
1165 if (p2p->state == P2P_SEARCH)
1166 p2p_continue_find(p2p);
1167 #else
1168 p2p_continue_find(p2p);
1169 #endif
1170 } else {
1171 p2p_dbg(p2p, "Running p2p_scan");
1172 p2p->p2p_scan_running = 1;
1173 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
1174 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout,
1175 p2p, NULL);
1176 }
1177 }
1178
1179
1180 static int p2p_run_after_scan(struct p2p_data *p2p)
1181 {
1182 struct p2p_device *dev;
1183 enum p2p_after_scan op;
1184
1185 op = p2p->start_after_scan;
1186 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1187 switch (op) {
1188 case P2P_AFTER_SCAN_NOTHING:
1189 break;
1190 case P2P_AFTER_SCAN_LISTEN:
1191 p2p_dbg(p2p, "Start previously requested Listen state");
1192 p2p_listen(p2p, p2p->pending_listen_sec * 1000 +
1193 p2p->pending_listen_usec / 1000);
1194 return 1;
1195 case P2P_AFTER_SCAN_CONNECT:
1196 p2p_dbg(p2p, "Start previously requested connect with " MACSTR_SEC,
1197 MAC2STR_SEC(p2p->after_scan_peer));
1198 dev = p2p_get_device(p2p, p2p->after_scan_peer);
1199 if (dev == NULL) {
1200 p2p_dbg(p2p, "Peer not known anymore");
1201 break;
1202 }
1203 p2p_connect_send(p2p, dev);
1204 return 1;
1205 #ifdef CONFIG_OPEN_HARMONY_SPECIFIC_P2P_FIND
1206 case P2P_AFTER_SCAN_FULL_SCAN:
1207 p2p_search(p2p);
1208 return 1;
1209 #endif
1210 }
1211
1212 return 0;
1213 }
1214
1215
1216 static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx)
1217 {
1218 struct p2p_data *p2p = eloop_ctx;
1219 int running;
1220 p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running);
1221 running = p2p->p2p_scan_running;
1222 /* Make sure we recover from missed scan results callback */
1223 p2p->p2p_scan_running = 0;
1224
1225 if (running)
1226 p2p_run_after_scan(p2p);
1227 }
1228
1229
1230 static void p2p_free_req_dev_types(struct p2p_data *p2p)
1231 {
1232 p2p->num_req_dev_types = 0;
1233 os_free(p2p->req_dev_types);
1234 p2p->req_dev_types = NULL;
1235 }
1236
1237
1238 static int p2ps_gen_hash(struct p2p_data *p2p, const char *str, u8 *hash)
1239 {
1240 u8 buf[SHA256_MAC_LEN];
1241 char str_buf[256];
1242 const u8 *adv_array;
1243 size_t i, adv_len;
1244
1245 if (!str || !hash)
1246 return 0;
1247
1248 if (!str[0]) {
1249 os_memcpy(hash, p2p->wild_card_hash, P2PS_HASH_LEN);
1250 return 1;
1251 }
1252
1253 adv_array = (u8 *) str_buf;
1254 adv_len = os_strlen(str);
1255 if (adv_len >= sizeof(str_buf))
1256 return 0;
1257
1258 for (i = 0; i < adv_len; i++) {
1259 if (str[i] >= 'A' && str[i] <= 'Z')
1260 str_buf[i] = str[i] - 'A' + 'a';
1261 else
1262 str_buf[i] = str[i];
1263 }
1264
1265 if (sha256_vector(1, &adv_array, &adv_len, buf))
1266 return 0;
1267
1268 os_memcpy(hash, buf, P2PS_HASH_LEN);
1269 return 1;
1270 }
1271
1272
1273 int p2p_find(struct p2p_data *p2p, unsigned int timeout,
1274 enum p2p_discovery_type type,
1275 unsigned int num_req_dev_types, const u8 *req_dev_types,
1276 const u8 *dev_id, unsigned int search_delay,
1277 u8 seek_count, const char **seek, int freq, bool include_6ghz)
1278 {
1279 int res;
1280 struct os_reltime start;
1281
1282 #ifdef CONFIG_OPEN_HARMONY_SPECIFIC_P2P_FIND
1283 struct wpa_supplicant *wpa_s = NULL;
1284 #endif
1285
1286 p2p_dbg(p2p, "Starting find (type=%d)", type);
1287 if (p2p->p2p_scan_running) {
1288 p2p_dbg(p2p, "p2p_scan is already running");
1289 }
1290
1291 p2p_free_req_dev_types(p2p);
1292 if (req_dev_types && num_req_dev_types) {
1293 p2p->req_dev_types = os_memdup(req_dev_types,
1294 num_req_dev_types *
1295 WPS_DEV_TYPE_LEN);
1296 if (p2p->req_dev_types == NULL)
1297 return -1;
1298 p2p->num_req_dev_types = num_req_dev_types;
1299 }
1300
1301 if (dev_id) {
1302 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN);
1303 p2p->find_dev_id = p2p->find_dev_id_buf;
1304 } else
1305 p2p->find_dev_id = NULL;
1306 p2p->include_6ghz = p2p_wfd_enabled(p2p) && include_6ghz;
1307 if (seek_count == 0 || !seek) {
1308 /* Not an ASP search */
1309 p2p->p2ps_seek = 0;
1310 } else if (seek_count == 1 && seek && (!seek[0] || !seek[0][0])) {
1311 /*
1312 * An empty seek string means no hash values, but still an ASP
1313 * search.
1314 */
1315 p2p_dbg(p2p, "ASP search");
1316 p2p->p2ps_seek_count = 0;
1317 p2p->p2ps_seek = 1;
1318 } else if (seek && seek_count <= P2P_MAX_QUERY_HASH) {
1319 u8 buf[P2PS_HASH_LEN];
1320 int i, count = 0;
1321
1322 for (i = 0; i < seek_count; i++) {
1323 if (!p2ps_gen_hash(p2p, seek[i], buf))
1324 continue;
1325
1326 p2p_dbg(p2p, "Seek service %s hash " MACSTR_SEC,
1327 seek[i], MAC2STR_SEC(buf));
1328 os_memcpy(&p2p->p2ps_seek_hash[count * P2PS_HASH_LEN],
1329 buf, P2PS_HASH_LEN);
1330 count++;
1331 }
1332
1333 p2p->p2ps_seek_count = count;
1334 p2p->p2ps_seek = 1;
1335 } else {
1336 p2p->p2ps_seek_count = 0;
1337 p2p->p2ps_seek = 1;
1338 }
1339
1340 /* Special case to perform wildcard search */
1341 if (p2p->p2ps_seek_count == 0 && p2p->p2ps_seek) {
1342 p2p->p2ps_seek_count = 1;
1343 os_memcpy(&p2p->p2ps_seek_hash, p2p->wild_card_hash,
1344 P2PS_HASH_LEN);
1345 }
1346
1347 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1348 p2p_clear_timeout(p2p);
1349 if (p2p->pending_listen_freq) {
1350 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_find");
1351 p2p->pending_listen_freq = 0;
1352 }
1353 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1354 p2p->pending_listen_wait_drv = false;
1355 p2p->find_pending_full = 0;
1356 p2p->find_type = type;
1357 if (freq != 2412 && freq != 2437 && freq != 2462 && freq != 60480)
1358 p2p->find_specified_freq = freq;
1359 else
1360 p2p->find_specified_freq = 0;
1361 p2p_device_clear_reported(p2p);
1362 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);
1363 p2p_set_state(p2p, P2P_SEARCH);
1364 p2p->search_delay = search_delay;
1365 p2p->in_search_delay = 0;
1366 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1367 p2p->last_p2p_find_timeout = timeout;
1368 if (timeout)
1369 eloop_register_timeout(timeout, 0, p2p_find_timeout,
1370 p2p, NULL);
1371 os_get_reltime(&start);
1372 switch (type) {
1373 #ifdef CONFIG_OPEN_HARMONY_SPECIFIC_P2P_FIND
1374 case P2P_FIND_SPECIFIC_FREQ:
1375 wpa_s = p2p->cfg->cb_ctx;
1376 freq = wpa_get_assoc_sta_freq(wpa_s->global);
1377 if (freq != 0) {
1378 p2p->start_after_scan = P2P_AFTER_SCAN_FULL_SCAN;
1379 p2p->find_pending_full = 1;
1380 p2p->find_type = P2P_FIND_START_WITH_FULL;
1381 }
1382 __attribute__((fallthrough));
1383 #endif
1384 case P2P_FIND_START_WITH_FULL:
1385 if (freq > 0) {
1386 /*
1387 * Start with the specified channel and then move to
1388 * scans for social channels and this specific channel.
1389 */
1390 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx,
1391 P2P_SCAN_SPECIFIC, freq,
1392 p2p->num_req_dev_types,
1393 p2p->req_dev_types, dev_id,
1394 DEV_PW_DEFAULT,
1395 p2p->include_6ghz);
1396 break;
1397 }
1398 __attribute__((fallthrough));
1399 case P2P_FIND_PROGRESSIVE:
1400 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
1401 p2p->num_req_dev_types,
1402 p2p->req_dev_types, dev_id,
1403 DEV_PW_DEFAULT, p2p->include_6ghz);
1404 break;
1405 case P2P_FIND_ONLY_SOCIAL:
1406 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
1407 p2p->num_req_dev_types,
1408 p2p->req_dev_types, dev_id,
1409 DEV_PW_DEFAULT, p2p->include_6ghz);
1410 break;
1411 default:
1412 return -1;
1413 }
1414
1415 if (!res)
1416 p2p->find_start = start;
1417
1418 if (res != 0 && p2p->p2p_scan_running) {
1419 p2p_dbg(p2p, "Failed to start p2p_scan - another p2p_scan was already running");
1420 /* wait for the previous p2p_scan to complete */
1421 if (type == P2P_FIND_PROGRESSIVE ||
1422 (type == P2P_FIND_START_WITH_FULL && freq == 0))
1423 p2p->find_pending_full = 1;
1424 res = 0; /* do not report failure */
1425 } else if (res != 0) {
1426 p2p_dbg(p2p, "Failed to start p2p_scan");
1427 p2p_set_state(p2p, P2P_IDLE);
1428 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1429 }
1430
1431 return res;
1432 }
1433
1434
1435 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq)
1436 {
1437 p2p_dbg(p2p, "Stopping find");
1438 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
1439 p2p_clear_timeout(p2p);
1440 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)
1441 p2p->cfg->find_stopped(p2p->cfg->cb_ctx);
1442
1443 p2p->p2ps_seek_count = 0;
1444
1445 p2p_set_state(p2p, P2P_IDLE);
1446 p2p_free_req_dev_types(p2p);
1447 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1448 if (p2p->go_neg_peer)
1449 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
1450 p2p->go_neg_peer = NULL;
1451 p2p->sd_peer = NULL;
1452 p2p->invite_peer = NULL;
1453 p2p_stop_listen_for_freq(p2p, freq);
1454 p2p->send_action_in_progress = 0;
1455 }
1456
1457
1458 void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq)
1459 {
1460 p2p_dbg(p2p,
1461 "%s(freq=%d) pending_listen_freq=%d in_listen=%d drv_in_listen=%d",
1462 __func__, freq, p2p->pending_listen_freq, p2p->in_listen,
1463 p2p->drv_in_listen);
1464 if (freq > 0 &&
1465 ((p2p->drv_in_listen == freq && p2p->in_listen) ||
1466 p2p->pending_listen_freq == (unsigned int) freq)) {
1467 p2p_dbg(p2p, "Skip stop_listen since we are on correct channel for response");
1468 return;
1469 }
1470 if (p2p->in_listen) {
1471 p2p->in_listen = 0;
1472 p2p_clear_timeout(p2p);
1473 }
1474 if (p2p->drv_in_listen) {
1475 /*
1476 * The driver may not deliver callback to p2p_listen_end()
1477 * when the operation gets canceled, so clear the internal
1478 * variable that is tracking driver state.
1479 */
1480 p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen);
1481 p2p->drv_in_listen = 0;
1482 }
1483 if (p2p->pending_listen_freq &&
1484 p2p->pending_listen_freq != (unsigned int) freq &&
1485 !p2p->drv_in_listen && p2p->pending_listen_wait_drv) {
1486 p2p_dbg(p2p,
1487 "Clear pending_listen_freq since the started listen did not complete before being stopped");
1488 p2p->pending_listen_freq = 0;
1489 }
1490 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1491 p2p->pending_listen_wait_drv = false;
1492 }
1493
1494
1495 void p2p_stop_listen(struct p2p_data *p2p)
1496 {
1497 if (p2p->state != P2P_LISTEN_ONLY) {
1498 p2p_dbg(p2p, "Skip stop_listen since not in listen_only state.");
1499 return;
1500 }
1501
1502 p2p_stop_listen_for_freq(p2p, 0);
1503 p2p_set_state(p2p, P2P_IDLE);
1504 }
1505
1506
1507 void p2p_stop_find(struct p2p_data *p2p)
1508 {
1509 p2p->pending_listen_freq = 0;
1510 p2p_stop_find_for_freq(p2p, 0);
1511 }
1512
1513
1514 static int p2p_prepare_channel_pref(struct p2p_data *p2p,
1515 unsigned int force_freq,
1516 unsigned int pref_freq, int go)
1517 {
1518 u8 op_class, op_channel;
1519 unsigned int freq = force_freq ? force_freq : pref_freq;
1520
1521 p2p_dbg(p2p, "Prepare channel pref - force_freq=%u pref_freq=%u go=%d",
1522 force_freq, pref_freq, go);
1523 if (p2p_freq_to_channel(freq, &op_class, &op_channel) < 0) {
1524 p2p_dbg(p2p, "Unsupported frequency %u MHz", freq);
1525 return -1;
1526 }
1527
1528 if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel) &&
1529 (go || !p2p_channels_includes(&p2p->cfg->cli_channels, op_class,
1530 op_channel))) {
1531 p2p_dbg(p2p, "Frequency %u MHz (oper_class %u channel %u) not allowed for P2P",
1532 freq, op_class, op_channel);
1533 return -1;
1534 }
1535
1536 p2p->op_reg_class = op_class;
1537 p2p->op_channel = op_channel;
1538
1539 if (force_freq) {
1540 p2p->channels.reg_classes = 1;
1541 p2p->channels.reg_class[0].channels = 1;
1542 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;
1543 p2p->channels.reg_class[0].channel[0] = p2p->op_channel;
1544 } else {
1545 p2p_copy_channels(&p2p->channels, &p2p->cfg->channels,
1546 p2p->allow_6ghz);
1547 }
1548
1549 return 0;
1550 }
1551
1552
1553 static void p2p_prepare_channel_best(struct p2p_data *p2p)
1554 {
1555 u8 op_class, op_channel;
1556 const int op_classes_5ghz[] = { 124, 125, 115, 0 };
1557 const int op_classes_ht40[] = { 126, 127, 116, 117, 0 };
1558 const int op_classes_vht[] = { 128, 0 };
1559 const int op_classes_edmg[] = { 181, 182, 183, 0 };
1560 const int op_classes_6ghz[] = { 131, 0 };
1561
1562 p2p_dbg(p2p, "Prepare channel best");
1563
1564 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&
1565 p2p_supported_freq(p2p, p2p->best_freq_overall) &&
1566 p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel)
1567 == 0) {
1568 p2p_dbg(p2p, "Select best overall channel as operating channel preference");
1569 p2p->op_reg_class = op_class;
1570 p2p->op_channel = op_channel;
1571 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&
1572 p2p_supported_freq(p2p, p2p->best_freq_5) &&
1573 p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel)
1574 == 0) {
1575 p2p_dbg(p2p, "Select best 5 GHz channel as operating channel preference");
1576 p2p->op_reg_class = op_class;
1577 p2p->op_channel = op_channel;
1578 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 &&
1579 p2p_supported_freq(p2p, p2p->best_freq_24) &&
1580 p2p_freq_to_channel(p2p->best_freq_24, &op_class,
1581 &op_channel) == 0) {
1582 p2p_dbg(p2p, "Select best 2.4 GHz channel as operating channel preference");
1583 p2p->op_reg_class = op_class;
1584 p2p->op_channel = op_channel;
1585 } else if (p2p->cfg->num_pref_chan > 0 &&
1586 p2p_channels_includes(&p2p->cfg->channels,
1587 p2p->cfg->pref_chan[0].op_class,
1588 p2p->cfg->pref_chan[0].chan)) {
1589 p2p_dbg(p2p, "Select first pref_chan entry as operating channel preference");
1590 p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class;
1591 p2p->op_channel = p2p->cfg->pref_chan[0].chan;
1592 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_edmg,
1593 &p2p->op_reg_class, &p2p->op_channel) ==
1594 0) {
1595 p2p_dbg(p2p, "Select possible EDMG channel (op_class %u channel %u) as operating channel preference",
1596 p2p->op_reg_class, p2p->op_channel);
1597 } else if (p2p->allow_6ghz &&
1598 (p2p_channel_select(&p2p->cfg->channels, op_classes_6ghz,
1599 &p2p->op_reg_class, &p2p->op_channel) ==
1600 0)) {
1601 p2p_dbg(p2p, "Select possible 6 GHz channel (op_class %u channel %u) as operating channel preference",
1602 p2p->op_reg_class, p2p->op_channel);
1603 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_vht,
1604 &p2p->op_reg_class, &p2p->op_channel) ==
1605 0) {
1606 p2p_dbg(p2p, "Select possible VHT channel (op_class %u channel %u) as operating channel preference",
1607 p2p->op_reg_class, p2p->op_channel);
1608 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_ht40,
1609 &p2p->op_reg_class, &p2p->op_channel) ==
1610 0) {
1611 p2p_dbg(p2p, "Select possible HT40 channel (op_class %u channel %u) as operating channel preference",
1612 p2p->op_reg_class, p2p->op_channel);
1613 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_5ghz,
1614 &p2p->op_reg_class, &p2p->op_channel) ==
1615 0) {
1616 p2p_dbg(p2p, "Select possible 5 GHz channel (op_class %u channel %u) as operating channel preference",
1617 p2p->op_reg_class, p2p->op_channel);
1618 } else if (p2p_channels_includes(&p2p->cfg->channels,
1619 p2p->cfg->op_reg_class,
1620 p2p->cfg->op_channel)) {
1621 p2p_dbg(p2p, "Select pre-configured channel as operating channel preference");
1622 p2p->op_reg_class = p2p->cfg->op_reg_class;
1623 p2p->op_channel = p2p->cfg->op_channel;
1624 } else if (p2p_channel_random_social(&p2p->cfg->channels,
1625 &p2p->op_reg_class,
1626 &p2p->op_channel,
1627 NULL, NULL) == 0) {
1628 p2p_dbg(p2p, "Select random available social channel (op_class %u channel %u) as operating channel preference",
1629 p2p->op_reg_class, p2p->op_channel);
1630 } else {
1631 /* Select any random available channel from the first available
1632 * operating class */
1633 if (p2p_channel_select(&p2p->cfg->channels, NULL,
1634 &p2p->op_reg_class,
1635 &p2p->op_channel) == 0)
1636 p2p_dbg(p2p,
1637 "Select random available channel %d from operating class %d as operating channel preference",
1638 p2p->op_channel, p2p->op_reg_class);
1639 }
1640
1641 p2p_copy_channels(&p2p->channels, &p2p->cfg->channels, p2p->allow_6ghz);
1642 }
1643
1644
1645 /**
1646 * p2p_prepare_channel - Select operating channel for GO Negotiation or P2PS PD
1647 * @p2p: P2P module context from p2p_init()
1648 * @dev: Selected peer device
1649 * @force_freq: Forced frequency in MHz or 0 if not forced
1650 * @pref_freq: Preferred frequency in MHz or 0 if no preference
1651 * @go: Whether the local end will be forced to be GO
1652 * Returns: 0 on success, -1 on failure (channel not supported for P2P)
1653 *
1654 * This function is used to do initial operating channel selection for GO
1655 * Negotiation prior to having received peer information or for P2PS PD
1656 * signalling. The selected channel may be further optimized in
1657 * p2p_reselect_channel() once the peer information is available.
1658 */
1659 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev,
1660 unsigned int force_freq, unsigned int pref_freq, int go)
1661 {
1662 p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u go=%d",
1663 force_freq, pref_freq, go);
1664 if (force_freq || pref_freq) {
1665 if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq, go) <
1666 0)
1667 return -1;
1668 } else {
1669 p2p_prepare_channel_best(p2p);
1670 }
1671 p2p_channels_dump(p2p, "prepared channels", &p2p->channels);
1672 if (go)
1673 p2p_channels_remove_freqs(&p2p->channels, &p2p->no_go_freq);
1674 else if (!force_freq)
1675 p2p_channels_union_inplace(&p2p->channels,
1676 &p2p->cfg->cli_channels);
1677 p2p_channels_dump(p2p, "after go/cli filter/add", &p2p->channels);
1678
1679 p2p_dbg(p2p, "Own preference for operation channel: Operating Class %u Channel %u%s",
1680 p2p->op_reg_class, p2p->op_channel,
1681 force_freq ? " (forced)" : "");
1682
1683 if (force_freq)
1684 dev->flags |= P2P_DEV_FORCE_FREQ;
1685 else
1686 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1687
1688 return 0;
1689 }
1690
1691
1692 static void p2p_set_dev_persistent(struct p2p_device *dev,
1693 int persistent_group)
1694 {
1695 switch (persistent_group) {
1696 case 0:
1697 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP |
1698 P2P_DEV_PREFER_PERSISTENT_RECONN);
1699 break;
1700 case 1:
1701 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1702 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN;
1703 break;
1704 case 2:
1705 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP |
1706 P2P_DEV_PREFER_PERSISTENT_RECONN;
1707 break;
1708 }
1709 }
1710
1711
1712 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
1713 enum p2p_wps_method wps_method,
1714 int go_intent, const u8 *own_interface_addr,
1715 unsigned int force_freq, int persistent_group,
1716 const u8 *force_ssid, size_t force_ssid_len,
1717 int pd_before_go_neg, unsigned int pref_freq, u16 oob_pw_id)
1718 {
1719 struct p2p_device *dev;
1720
1721 p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR_SEC
1722 " GO Intent=%d Intended Interface Address=" MACSTR_SEC
1723 " wps_method=%d persistent_group=%d pd_before_go_neg=%d "
1724 "oob_pw_id=%u allow_6ghz=%d",
1725 MAC2STR_SEC(peer_addr), go_intent, MAC2STR_SEC(own_interface_addr),
1726 wps_method, persistent_group, pd_before_go_neg, oob_pw_id,
1727 p2p->allow_6ghz);
1728
1729 dev = p2p_get_device(p2p, peer_addr);
1730 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1731 p2p_dbg(p2p, "Cannot connect to unknown P2P Device " MACSTR_SEC,
1732 MAC2STR_SEC(peer_addr));
1733 return -1;
1734 }
1735
1736 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq,
1737 go_intent == 15) < 0)
1738 return -1;
1739
1740 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1741 if (!(dev->info.dev_capab &
1742 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
1743 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR_SEC
1744 " that is in a group and is not discoverable",
1745 MAC2STR_SEC(peer_addr));
1746 return -1;
1747 }
1748 if (dev->oper_freq <= 0) {
1749 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR_SEC
1750 " with incomplete information",
1751 MAC2STR_SEC(peer_addr));
1752 return -1;
1753 }
1754
1755 /*
1756 * First, try to connect directly. If the peer does not
1757 * acknowledge frames, assume it is sleeping and use device
1758 * discoverability via the GO at that point.
1759 */
1760 }
1761
1762 p2p->ssid_set = 0;
1763 if (force_ssid) {
1764 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID",
1765 force_ssid, force_ssid_len);
1766 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1767 p2p->ssid_len = force_ssid_len;
1768 p2p->ssid_set = 1;
1769 }
1770
1771 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1772 dev->flags &= ~P2P_DEV_USER_REJECTED;
1773 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1774 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1775 if (pd_before_go_neg)
1776 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG;
1777 else {
1778 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1779 /*
1780 * Assign dialog token and tie breaker here to use the same
1781 * values in each retry within the same GO Negotiation exchange.
1782 */
1783 dev->dialog_token++;
1784 if (dev->dialog_token == 0)
1785 dev->dialog_token = 1;
1786 dev->tie_breaker = p2p->next_tie_breaker;
1787 p2p->next_tie_breaker = !p2p->next_tie_breaker;
1788 }
1789 dev->connect_reqs = 0;
1790 dev->go_neg_req_sent = 0;
1791 dev->go_state = UNKNOWN_GO;
1792 p2p_set_dev_persistent(dev, persistent_group);
1793 p2p->go_intent = go_intent;
1794 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1795
1796 if (p2p->state != P2P_IDLE)
1797 p2p_stop_find(p2p);
1798
1799 dev->wps_method = wps_method;
1800 dev->oob_pw_id = oob_pw_id;
1801 dev->status = P2P_SC_SUCCESS;
1802
1803 if (p2p->p2p_scan_running) {
1804 p2p_dbg(p2p, "p2p_scan running - delay connect send");
1805 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;
1806 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);
1807 return 0;
1808 }
1809
1810 return p2p_connect_send(p2p, dev);
1811 }
1812
1813
1814 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,
1815 enum p2p_wps_method wps_method,
1816 int go_intent, const u8 *own_interface_addr,
1817 unsigned int force_freq, int persistent_group,
1818 const u8 *force_ssid, size_t force_ssid_len,
1819 unsigned int pref_freq, u16 oob_pw_id)
1820 {
1821 struct p2p_device *dev;
1822
1823 p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR_SEC
1824 " GO Intent=%d Intended Interface Address=" MACSTR_SEC
1825 " wps_method=%d persistent_group=%d oob_pw_id=%u allow_6ghz=%d",
1826 MAC2STR_SEC(peer_addr), go_intent, MAC2STR_SEC(own_interface_addr),
1827 wps_method, persistent_group, oob_pw_id, p2p->allow_6ghz);
1828
1829 dev = p2p_get_device(p2p, peer_addr);
1830 if (dev == NULL) {
1831 p2p_dbg(p2p, "Cannot authorize unknown P2P Device " MACSTR_SEC,
1832 MAC2STR_SEC(peer_addr));
1833 return -1;
1834 }
1835
1836 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, go_intent ==
1837 15) < 0)
1838 return -1;
1839
1840 p2p->ssid_set = 0;
1841 if (force_ssid) {
1842 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID",
1843 force_ssid, force_ssid_len);
1844 os_memcpy(p2p->ssid, force_ssid, force_ssid_len);
1845 p2p->ssid_len = force_ssid_len;
1846 p2p->ssid_set = 1;
1847 }
1848
1849 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1850 dev->flags &= ~P2P_DEV_USER_REJECTED;
1851 dev->go_neg_req_sent = 0;
1852 dev->go_state = UNKNOWN_GO;
1853 p2p_set_dev_persistent(dev, persistent_group);
1854 p2p->go_intent = go_intent;
1855 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1856
1857 dev->wps_method = wps_method;
1858 dev->oob_pw_id = oob_pw_id;
1859 dev->status = P2P_SC_SUCCESS;
1860
1861 return 0;
1862 }
1863
1864
1865 void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr,
1866 struct p2p_device *dev, struct p2p_message *msg)
1867 {
1868 os_get_reltime(&dev->last_seen);
1869
1870 p2p_copy_wps_info(p2p, dev, 0, msg);
1871
1872 if (msg->listen_channel) {
1873 int freq;
1874 freq = p2p_channel_to_freq(msg->listen_channel[3],
1875 msg->listen_channel[4]);
1876 if (freq < 0) {
1877 p2p_dbg(p2p, "Unknown peer Listen channel: "
1878 "country=%c%c(0x%02x) reg_class=%u channel=%u",
1879 msg->listen_channel[0],
1880 msg->listen_channel[1],
1881 msg->listen_channel[2],
1882 msg->listen_channel[3],
1883 msg->listen_channel[4]);
1884 } else {
1885 p2p_dbg(p2p, "Update peer " MACSTR_SEC
1886 " Listen channel: %u -> %u MHz",
1887 MAC2STR_SEC(dev->info.p2p_device_addr),
1888 dev->listen_freq, freq);
1889 dev->listen_freq = freq;
1890 }
1891 }
1892
1893 if (msg->wfd_subelems) {
1894 wpabuf_free(dev->info.wfd_subelems);
1895 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
1896 }
1897
1898 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
1899 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
1900 p2p_dbg(p2p, "Completed device entry based on data from GO Negotiation Request");
1901 } else {
1902 p2p_dbg(p2p, "Created device entry based on GO Neg Req: "
1903 MACSTR_SEC " dev_capab=0x%x group_capab=0x%x name='%s' "
1904 "listen_freq=%d",
1905 MAC2STR_SEC(dev->info.p2p_device_addr),
1906 dev->info.dev_capab, dev->info.group_capab,
1907 dev->info.device_name, dev->listen_freq);
1908 }
1909
1910 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
1911
1912 if (dev->flags & P2P_DEV_USER_REJECTED) {
1913 p2p_dbg(p2p, "Do not report rejected device");
1914 return;
1915 }
1916
1917 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1918 !(dev->flags & P2P_DEV_REPORTED_ONCE));
1919 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
1920 }
1921
1922
1923 void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)
1924 {
1925 os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
1926 p2p_random((char *) &ssid[P2P_WILDCARD_SSID_LEN], 2);
1927 os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN + 2],
1928 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
1929 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;
1930 }
1931
1932
1933 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params)
1934 {
1935 if (p2p->ssid_set) {
1936 os_memcpy(params->ssid, p2p->ssid, p2p->ssid_len);
1937 params->ssid_len = p2p->ssid_len;
1938 } else {
1939 p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len);
1940 }
1941 p2p->ssid_set = 0;
1942
1943 p2p_random(params->passphrase, p2p->cfg->passphrase_len);
1944 params->passphrase[p2p->cfg->passphrase_len] = '\0';
1945 return 0;
1946 }
1947
1948
1949 void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer)
1950 {
1951 struct p2p_go_neg_results res;
1952 int go = peer->go_state == LOCAL_GO;
1953 struct p2p_channels intersection;
1954
1955 p2p_dbg(p2p, "GO Negotiation with " MACSTR_SEC " completed (%s will be GO)",
1956 MAC2STR_SEC(peer->info.p2p_device_addr), go ? "local end" : "peer");
1957
1958 os_memset(&res, 0, sizeof(res));
1959 res.role_go = go;
1960 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
1961 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
1962 res.wps_method = peer->wps_method;
1963 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
1964 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
1965 res.persistent_group = 2;
1966 else
1967 res.persistent_group = 1;
1968 }
1969
1970 if (go) {
1971 /* Setup AP mode for WPS provisioning */
1972 res.freq = p2p_channel_to_freq(p2p->op_reg_class,
1973 p2p->op_channel);
1974 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1975 res.ssid_len = p2p->ssid_len;
1976 p2p_random(res.passphrase, p2p->cfg->passphrase_len);
1977 res.passphrase[p2p->cfg->passphrase_len] = '\0';
1978 } else {
1979 res.freq = peer->oper_freq;
1980 if (p2p->ssid_len) {
1981 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1982 res.ssid_len = p2p->ssid_len;
1983 }
1984 }
1985
1986 p2p_channels_dump(p2p, "own channels", &p2p->channels);
1987 p2p_channels_dump(p2p, "peer channels", &peer->channels);
1988 p2p_channels_intersect(&p2p->channels, &peer->channels,
1989 &intersection);
1990 if (go) {
1991 p2p_channels_remove_freqs(&intersection, &p2p->no_go_freq);
1992 p2p_channels_dump(p2p, "intersection after no-GO removal",
1993 &intersection);
1994 }
1995
1996 p2p_channels_to_freqs(&intersection, res.freq_list,
1997 P2P_MAX_CHANNELS);
1998
1999 res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout;
2000
2001 p2p_clear_timeout(p2p);
2002 p2p->ssid_set = 0;
2003 peer->go_neg_req_sent = 0;
2004 peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE;
2005 peer->wps_method = WPS_NOT_READY;
2006 peer->oob_pw_id = 0;
2007 wpabuf_free(peer->go_neg_conf);
2008 peer->go_neg_conf = NULL;
2009
2010 p2p_set_state(p2p, P2P_PROVISIONING);
2011 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
2012 }
2013
2014
2015 static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa,
2016 const u8 *data, size_t len, int rx_freq)
2017 {
2018 p2p_dbg(p2p, "RX P2P Public Action from " MACSTR_SEC, MAC2STR_SEC(sa));
2019 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len);
2020
2021 if (len < 1)
2022 return;
2023
2024 switch (data[0]) {
2025 case P2P_GO_NEG_REQ:
2026 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);
2027 break;
2028 case P2P_GO_NEG_RESP:
2029 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);
2030 break;
2031 case P2P_GO_NEG_CONF:
2032 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);
2033 break;
2034 case P2P_INVITATION_REQ:
2035 p2p_process_invitation_req(p2p, sa, data + 1, len - 1,
2036 rx_freq);
2037 break;
2038 case P2P_INVITATION_RESP:
2039 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);
2040 break;
2041 case P2P_PROV_DISC_REQ:
2042 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
2043 break;
2044 case P2P_PROV_DISC_RESP:
2045 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);
2046 break;
2047 case P2P_DEV_DISC_REQ:
2048 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
2049 break;
2050 case P2P_DEV_DISC_RESP:
2051 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);
2052 break;
2053 default:
2054 p2p_dbg(p2p, "Unsupported P2P Public Action frame type %d",
2055 data[0]);
2056 break;
2057 }
2058 }
2059
2060
2061 static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da,
2062 const u8 *sa, const u8 *bssid, const u8 *data,
2063 size_t len, int freq)
2064 {
2065 if (len < 1)
2066 return;
2067
2068 switch (data[0]) {
2069 case WLAN_PA_VENDOR_SPECIFIC:
2070 data++;
2071 len--;
2072 if (len < 4)
2073 return;
2074 if (WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE)
2075 return;
2076
2077 data += 4;
2078 len -= 4;
2079
2080 p2p_rx_p2p_action(p2p, sa, data, len, freq);
2081 break;
2082 case WLAN_PA_GAS_INITIAL_REQ:
2083 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);
2084 break;
2085 case WLAN_PA_GAS_INITIAL_RESP:
2086 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);
2087 break;
2088 case WLAN_PA_GAS_COMEBACK_REQ:
2089 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);
2090 break;
2091 case WLAN_PA_GAS_COMEBACK_RESP:
2092 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);
2093 break;
2094 }
2095 }
2096
2097
2098 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,
2099 const u8 *bssid, u8 category,
2100 const u8 *data, size_t len, int freq)
2101 {
2102 if (category == WLAN_ACTION_PUBLIC) {
2103 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq);
2104 return;
2105 }
2106
2107 if (category != WLAN_ACTION_VENDOR_SPECIFIC)
2108 return;
2109
2110 if (len < 4)
2111 return;
2112
2113 if (WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE)
2114 return;
2115 data += 4;
2116 len -= 4;
2117
2118 /* P2P action frame */
2119 p2p_dbg(p2p, "RX P2P Action from " MACSTR_SEC, MAC2STR_SEC(sa));
2120 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len);
2121
2122 if (len < 1)
2123 return;
2124 switch (data[0]) {
2125 case P2P_NOA:
2126 p2p_dbg(p2p, "Received P2P Action - Notice of Absence");
2127 /* TODO */
2128 break;
2129 case P2P_PRESENCE_REQ:
2130 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);
2131 break;
2132 case P2P_PRESENCE_RESP:
2133 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);
2134 break;
2135 case P2P_GO_DISC_REQ:
2136 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);
2137 break;
2138 default:
2139 p2p_dbg(p2p, "Received P2P Action - unknown type %u", data[0]);
2140 break;
2141 }
2142 }
2143
2144
2145 static void p2p_go_neg_start(void *eloop_ctx, void *timeout_ctx)
2146 {
2147 struct p2p_data *p2p = eloop_ctx;
2148 if (p2p->go_neg_peer == NULL)
2149 return;
2150 if (p2p->pending_listen_freq) {
2151 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_go_neg_start");
2152 p2p->pending_listen_freq = 0;
2153 }
2154 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
2155 p2p->pending_listen_wait_drv = false;
2156 p2p->go_neg_peer->status = P2P_SC_SUCCESS;
2157 /*
2158 * Set new timeout to make sure a previously set one does not expire
2159 * too quickly while waiting for the GO Negotiation to complete.
2160 */
2161 p2p_set_timeout(p2p, 0, 500000);
2162 p2p_connect_send(p2p, p2p->go_neg_peer);
2163 }
2164
2165
2166 static void p2p_invite_start(void *eloop_ctx, void *timeout_ctx)
2167 {
2168 struct p2p_data *p2p = eloop_ctx;
2169 if (p2p->invite_peer == NULL)
2170 return;
2171 if (p2p->pending_listen_freq) {
2172 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_invite_start");
2173 p2p->pending_listen_freq = 0;
2174 }
2175 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
2176 p2p->pending_listen_wait_drv = false;
2177 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr,
2178 p2p->invite_dev_pw_id);
2179 }
2180
2181
2182 static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr,
2183 const u8 *ie, size_t ie_len)
2184 {
2185 struct p2p_message msg;
2186 struct p2p_device *dev;
2187
2188 os_memset(&msg, 0, sizeof(msg));
2189 if (p2p_parse_ies(ie, ie_len, &msg) < 0 || msg.p2p_attributes == NULL)
2190 {
2191 p2p_parse_free(&msg);
2192 return; /* not a P2P probe */
2193 }
2194
2195 if (msg.ssid == NULL || msg.ssid[1] != P2P_WILDCARD_SSID_LEN ||
2196 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN)
2197 != 0) {
2198 /* The Probe Request is not part of P2P Device Discovery. It is
2199 * not known whether the source address of the frame is the P2P
2200 * Device Address or P2P Interface Address. Do not add a new
2201 * peer entry based on this frames.
2202 */
2203 p2p_parse_free(&msg);
2204 return;
2205 }
2206
2207 dev = p2p_get_device(p2p, addr);
2208 if (dev) {
2209 if (msg.listen_channel) {
2210 int freq;
2211
2212 if (dev->country[0] == 0)
2213 os_memcpy(dev->country, msg.listen_channel, 3);
2214
2215 freq = p2p_channel_to_freq(msg.listen_channel[3],
2216 msg.listen_channel[4]);
2217
2218 if (freq > 0 && dev->listen_freq != freq) {
2219 p2p_dbg(p2p,
2220 "Updated peer " MACSTR_SEC " Listen channel (Probe Request): %d -> %d MHz",
2221 MAC2STR_SEC(addr), dev->listen_freq, freq);
2222 dev->listen_freq = freq;
2223 }
2224 }
2225
2226 p2p_update_peer_6ghz_capab(dev, &msg);
2227 os_get_reltime(&dev->last_seen);
2228 p2p_parse_free(&msg);
2229 return; /* already known */
2230 }
2231
2232 dev = p2p_create_device(p2p, addr);
2233 if (dev == NULL) {
2234 p2p_parse_free(&msg);
2235 return;
2236 }
2237
2238 os_get_reltime(&dev->last_seen);
2239 dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
2240
2241 if (msg.listen_channel) {
2242 os_memcpy(dev->country, msg.listen_channel, 3);
2243 dev->listen_freq = p2p_channel_to_freq(msg.listen_channel[3],
2244 msg.listen_channel[4]);
2245 }
2246
2247 p2p_copy_wps_info(p2p, dev, 1, &msg);
2248
2249 if (msg.wfd_subelems) {
2250 wpabuf_free(dev->info.wfd_subelems);
2251 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
2252 }
2253
2254 p2p_parse_free(&msg);
2255
2256 p2p_dbg(p2p, "Created device entry based on Probe Req: " MACSTR_SEC
2257 " dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d",
2258 MAC2STR_SEC(dev->info.p2p_device_addr), dev->info.dev_capab,
2259 dev->info.group_capab, dev->info.device_name,
2260 dev->listen_freq);
2261 }
2262
2263
2264 struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p,
2265 const u8 *addr,
2266 struct p2p_message *msg)
2267 {
2268 struct p2p_device *dev;
2269
2270 dev = p2p_get_device(p2p, addr);
2271 if (dev) {
2272 os_get_reltime(&dev->last_seen);
2273 return dev; /* already known */
2274 }
2275
2276 dev = p2p_create_device(p2p, addr);
2277 if (dev == NULL)
2278 return NULL;
2279
2280 p2p_add_dev_info(p2p, addr, dev, msg);
2281
2282 return dev;
2283 }
2284
2285
2286 static int dev_type_match(const u8 *dev_type, const u8 *req_dev_type)
2287 {
2288 if (os_memcmp(dev_type, req_dev_type, WPS_DEV_TYPE_LEN) == 0)
2289 return 1;
2290 if (os_memcmp(dev_type, req_dev_type, 2) == 0 &&
2291 WPA_GET_BE32(&req_dev_type[2]) == 0 &&
2292 WPA_GET_BE16(&req_dev_type[6]) == 0)
2293 return 1; /* Category match with wildcard OUI/sub-category */
2294 return 0;
2295 }
2296
2297
2298 int dev_type_list_match(const u8 *dev_type, const u8 *req_dev_type[],
2299 size_t num_req_dev_type)
2300 {
2301 size_t i;
2302 for (i = 0; i < num_req_dev_type; i++) {
2303 if (dev_type_match(dev_type, req_dev_type[i]))
2304 return 1;
2305 }
2306 return 0;
2307 }
2308
2309
2310 /**
2311 * p2p_match_dev_type - Match local device type with requested type
2312 * @p2p: P2P module context from p2p_init()
2313 * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs)
2314 * Returns: 1 on match, 0 on mismatch
2315 *
2316 * This function can be used to match the Requested Device Type attribute in
2317 * WPS IE with the local device types for deciding whether to reply to a Probe
2318 * Request frame.
2319 */
2320 int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps)
2321 {
2322 struct wps_parse_attr attr;
2323 size_t i;
2324
2325 if (wps_parse_msg(wps, &attr))
2326 return 1; /* assume no Requested Device Type attributes */
2327
2328 if (attr.num_req_dev_type == 0)
2329 return 1; /* no Requested Device Type attributes -> match */
2330
2331 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,
2332 attr.num_req_dev_type))
2333 return 1; /* Own Primary Device Type matches */
2334
2335 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) {
2336 if (dev_type_list_match(p2p->cfg->sec_dev_type[i],
2337 attr.req_dev_type,
2338 attr.num_req_dev_type))
2339 return 1; /* Own Secondary Device Type matches */
2340 }
2341
2342 /* No matching device type found */
2343 return 0;
2344 }
2345
2346
2347 struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p,
2348 const u8 *query_hash,
2349 u8 query_count)
2350 {
2351 struct wpabuf *buf;
2352 u8 *len;
2353 int pw_id = -1;
2354 size_t extra = 0;
2355
2356 #ifdef CONFIG_WIFI_DISPLAY
2357 if (p2p->wfd_ie_probe_resp)
2358 extra = wpabuf_len(p2p->wfd_ie_probe_resp);
2359 #endif /* CONFIG_WIFI_DISPLAY */
2360
2361 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])
2362 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);
2363
2364 if (query_count)
2365 extra += MAX_SVC_ADV_IE_LEN;
2366
2367 buf = wpabuf_alloc(1000 + extra);
2368 if (buf == NULL)
2369 return NULL;
2370
2371 if (p2p->go_neg_peer) {
2372 /* Advertise immediate availability of WPS credential */
2373 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method);
2374 }
2375
2376 if (p2p_build_wps_ie(p2p, buf, pw_id, 1) < 0) {
2377 p2p_dbg(p2p, "Failed to build WPS IE for Probe Response");
2378 wpabuf_free(buf);
2379 return NULL;
2380 }
2381
2382 #ifdef CONFIG_WIFI_DISPLAY
2383 if (p2p->wfd_ie_probe_resp)
2384 wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp);
2385 #endif /* CONFIG_WIFI_DISPLAY */
2386
2387 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P])
2388 wpabuf_put_buf(buf,
2389 p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]);
2390 //resp增加字段
2391 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
2392 if (hm_p2p_add_pvt_vendor_ie(buf))
2393 wpa_printf(MSG_ERROR, "add pvt vendor IE fail");
2394 #endif
2395
2396 /* P2P IE */
2397 len = p2p_buf_add_ie_hdr(buf);
2398 p2p_buf_add_capability(buf, p2p->dev_capab &
2399 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0);
2400 if (p2p->ext_listen_interval)
2401 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
2402 p2p->ext_listen_interval);
2403 p2p_buf_add_device_info(buf, p2p, NULL);
2404 p2p_buf_update_ie_hdr(buf, len);
2405
2406 if (query_count) {
2407 p2p_buf_add_service_instance(buf, p2p, query_count, query_hash,
2408 p2p->p2ps_adv_list);
2409 }
2410
2411 return buf;
2412 }
2413
2414 static int p2p_build_probe_resp_buf(struct p2p_data *p2p, struct wpabuf *buf,
2415 struct wpabuf *ies,
2416 const u8 *addr, int rx_freq)
2417 {
2418 struct ieee80211_mgmt *resp;
2419 u8 channel, op_class;
2420
2421 resp = wpabuf_put(buf, offsetof(struct ieee80211_mgmt,
2422 u.probe_resp.variable));
2423
2424 resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) |
2425 (WLAN_FC_STYPE_PROBE_RESP << 4));
2426 os_memcpy(resp->da, addr, ETH_ALEN);
2427 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);
2428 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);
2429 resp->u.probe_resp.beacon_int = host_to_le16(100);
2430 /* hardware or low-level driver will setup seq_ctrl and timestamp */
2431 resp->u.probe_resp.capab_info =
2432 host_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE |
2433 WLAN_CAPABILITY_PRIVACY |
2434 WLAN_CAPABILITY_SHORT_SLOT_TIME);
2435
2436 wpabuf_put_u8(buf, WLAN_EID_SSID);
2437 wpabuf_put_u8(buf, P2P_WILDCARD_SSID_LEN);
2438 wpabuf_put_data(buf, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
2439
2440 wpabuf_put_u8(buf, WLAN_EID_SUPP_RATES);
2441 wpabuf_put_u8(buf, 8);
2442 wpabuf_put_u8(buf, (60 / 5) | 0x80);
2443 wpabuf_put_u8(buf, 90 / 5);
2444 wpabuf_put_u8(buf, (120 / 5) | 0x80);
2445 wpabuf_put_u8(buf, 180 / 5);
2446 wpabuf_put_u8(buf, (240 / 5) | 0x80);
2447 wpabuf_put_u8(buf, 360 / 5);
2448 wpabuf_put_u8(buf, 480 / 5);
2449 wpabuf_put_u8(buf, 540 / 5);
2450
2451 if (!rx_freq) {
2452 channel = p2p->cfg->channel;
2453 } else if (p2p_freq_to_channel(rx_freq, &op_class, &channel)) {
2454 p2p_err(p2p, "Failed to convert freq to channel");
2455 return -1;
2456 }
2457
2458 wpabuf_put_u8(buf, WLAN_EID_DS_PARAMS);
2459 wpabuf_put_u8(buf, 1);
2460 wpabuf_put_u8(buf, channel);
2461
2462 wpabuf_put_buf(buf, ies);
2463
2464 return 0;
2465 }
2466
2467 static int p2p_service_find_asp(struct p2p_data *p2p, const u8 *hash)
2468 {
2469 struct p2ps_advertisement *adv_data;
2470 int any_wfa;
2471
2472 p2p_dbg(p2p, "ASP find - ASP list: %p", p2p->p2ps_adv_list);
2473
2474 /* Wildcard org.wi-fi.wfds matches any WFA spec defined service */
2475 any_wfa = os_memcmp(hash, p2p->wild_card_hash, P2PS_HASH_LEN) == 0;
2476
2477 adv_data = p2p->p2ps_adv_list;
2478 while (adv_data) {
2479 if (os_memcmp(hash, adv_data->hash, P2PS_HASH_LEN) == 0)
2480 return 1; /* exact hash match */
2481 if (any_wfa &&
2482 os_strncmp(adv_data->svc_name, P2PS_WILD_HASH_STR,
2483 os_strlen(P2PS_WILD_HASH_STR)) == 0)
2484 return 1; /* WFA service match */
2485 adv_data = adv_data->next;
2486 }
2487
2488 return 0;
2489 }
2490
2491
2492 static enum p2p_probe_req_status
2493 p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2494 const u8 *bssid, const u8 *ie, size_t ie_len,
2495 unsigned int rx_freq)
2496 {
2497 struct ieee802_11_elems elems;
2498 struct wpabuf *buf;
2499 struct p2p_message msg;
2500 struct wpabuf *ies;
2501
2502 if (ieee802_11_parse_elems((u8 *) ie, ie_len, &elems, 0) ==
2503 ParseFailed) {
2504 /* Ignore invalid Probe Request frames */
2505 p2p_dbg(p2p, "Could not parse Probe Request frame - ignore it");
2506 return P2P_PREQ_MALFORMED;
2507 }
2508
2509 if (elems.p2p == NULL) {
2510 /* not a P2P probe - ignore it */
2511 p2p_dbg(p2p, "Not a P2P probe - ignore it");
2512 return P2P_PREQ_NOT_P2P;
2513 }
2514
2515 if (dst && !is_broadcast_ether_addr(dst) &&
2516 !ether_addr_equal(dst, p2p->cfg->dev_addr)) {
2517 /* Not sent to the broadcast address or our P2P Device Address
2518 */
2519 p2p_dbg(p2p, "Probe Req DA " MACSTR_SEC " not ours - ignore it",
2520 MAC2STR_SEC(dst));
2521 return P2P_PREQ_NOT_PROCESSED;
2522 }
2523
2524 if (bssid && !is_broadcast_ether_addr(bssid)) {
2525 /* Not sent to the Wildcard BSSID */
2526 p2p_dbg(p2p, "Probe Req BSSID " MACSTR_SEC " not wildcard - ignore it",
2527 MAC2STR_SEC(bssid));
2528 return P2P_PREQ_NOT_PROCESSED;
2529 }
2530
2531 if (elems.ssid == NULL || elems.ssid_len != P2P_WILDCARD_SSID_LEN ||
2532 os_memcmp(elems.ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) !=
2533 0) {
2534 /* not using P2P Wildcard SSID - ignore */
2535 p2p_dbg(p2p, "Probe Req not using P2P Wildcard SSID - ignore it");
2536 return P2P_PREQ_NOT_PROCESSED;
2537 }
2538
2539 if (supp_rates_11b_only(&elems)) {
2540 /* Indicates support for 11b rates only */
2541 p2p_dbg(p2p, "Probe Req with 11b rates only supported - ignore it");
2542 return P2P_PREQ_NOT_P2P;
2543 }
2544
2545 os_memset(&msg, 0, sizeof(msg));
2546 if (p2p_parse_ies(ie, ie_len, &msg) < 0) {
2547 /* Could not parse P2P attributes */
2548 p2p_dbg(p2p, "Could not parse P2P attributes in Probe Req - ignore it");
2549 return P2P_PREQ_NOT_P2P;
2550 }
2551
2552 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
2553 hm_p2p_save_peer_info(&elems, addr);
2554 #endif
2555
2556 if (msg.service_hash && msg.service_hash_count) {
2557 const u8 *hash = msg.service_hash;
2558 u8 i;
2559 int p2ps_svc_found = 0;
2560
2561 p2p_dbg(p2p, "in_listen=%d drv_in_listen=%d when received P2PS Probe Request at %u MHz; own Listen channel %u, pending listen freq %u MHz",
2562 p2p->in_listen, p2p->drv_in_listen, rx_freq,
2563 p2p->cfg->channel, p2p->pending_listen_freq);
2564
2565 if (!p2p->in_listen && !p2p->drv_in_listen &&
2566 p2p->pending_listen_freq && rx_freq &&
2567 rx_freq != p2p->pending_listen_freq) {
2568 p2p_dbg(p2p, "Do not reply to Probe Request frame that was received on %u MHz while waiting to start Listen state on %u MHz",
2569 rx_freq, p2p->pending_listen_freq);
2570 p2p_parse_free(&msg);
2571 return P2P_PREQ_NOT_LISTEN;
2572 }
2573
2574 for (i = 0; i < msg.service_hash_count; i++) {
2575 if (p2p_service_find_asp(p2p, hash)) {
2576 p2p_dbg(p2p, "Service Hash match found: "
2577 MACSTR_SEC, MAC2STR_SEC(hash));
2578 p2ps_svc_found = 1;
2579 break;
2580 }
2581 hash += P2PS_HASH_LEN;
2582 }
2583
2584 /* Probed hash unknown */
2585 if (!p2ps_svc_found) {
2586 p2p_dbg(p2p, "No Service Hash match found");
2587 p2p_parse_free(&msg);
2588 return P2P_PREQ_NOT_PROCESSED;
2589 }
2590 } else {
2591 /* This is not a P2PS Probe Request */
2592 p2p_dbg(p2p, "No P2PS Hash in Probe Request");
2593
2594 if (!p2p->in_listen || !p2p->drv_in_listen) {
2595 /* not in Listen state - ignore Probe Request */
2596 p2p_dbg(p2p, "Not in Listen state (in_listen=%d drv_in_listen=%d) - ignore Probe Request",
2597 p2p->in_listen, p2p->drv_in_listen);
2598 p2p_parse_free(&msg);
2599 return P2P_PREQ_NOT_LISTEN;
2600 }
2601 }
2602
2603 if (msg.device_id &&
2604 !ether_addr_equal(msg.device_id, p2p->cfg->dev_addr)) {
2605 /* Device ID did not match */
2606 p2p_dbg(p2p, "Probe Req requested Device ID " MACSTR_SEC " did not match - ignore it",
2607 MAC2STR_SEC(msg.device_id));
2608 p2p_parse_free(&msg);
2609 return P2P_PREQ_NOT_PROCESSED;
2610 }
2611
2612 /* Check Requested Device Type match */
2613 if (msg.wps_attributes &&
2614 !p2p_match_dev_type(p2p, msg.wps_attributes)) {
2615 /* No match with Requested Device Type */
2616 p2p_dbg(p2p, "Probe Req requested Device Type did not match - ignore it");
2617 p2p_parse_free(&msg);
2618 return P2P_PREQ_NOT_PROCESSED;
2619 }
2620
2621 if (!p2p->cfg->send_probe_resp) {
2622 /* Response generated elsewhere */
2623 p2p_dbg(p2p, "Probe Resp generated elsewhere - do not generate additional response");
2624 p2p_parse_free(&msg);
2625 return P2P_PREQ_NOT_PROCESSED;
2626 }
2627
2628 p2p_dbg(p2p, "Reply to P2P Probe Request in Listen state");
2629
2630 /*
2631 * We do not really have a specific BSS that this frame is advertising,
2632 * so build a frame that has some information in valid format. This is
2633 * really only used for discovery purposes, not to learn exact BSS
2634 * parameters.
2635 */
2636 ies = p2p_build_probe_resp_ies(p2p, msg.service_hash,
2637 msg.service_hash_count);
2638 p2p_parse_free(&msg);
2639 if (ies == NULL)
2640 return P2P_PREQ_NOT_PROCESSED;
2641
2642 buf = wpabuf_alloc(200 + wpabuf_len(ies));
2643 if (buf == NULL) {
2644 wpabuf_free(ies);
2645 return P2P_PREQ_NOT_PROCESSED;
2646 }
2647
2648 if (p2p_build_probe_resp_buf(p2p, buf, ies, addr, rx_freq)) {
2649 wpabuf_free(ies);
2650 wpabuf_free(buf);
2651 return P2P_PREQ_NOT_PROCESSED;
2652 }
2653
2654 wpabuf_free(ies);
2655
2656 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf, rx_freq);
2657
2658 wpabuf_free(buf);
2659
2660 return P2P_PREQ_PROCESSED;
2661 }
2662
2663
2664 enum p2p_probe_req_status
2665 p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst,
2666 const u8 *bssid, const u8 *ie, size_t ie_len,
2667 unsigned int rx_freq, int p2p_lo_started)
2668 {
2669 enum p2p_probe_req_status res;
2670
2671 p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len);
2672
2673 if (p2p_lo_started) {
2674 p2p_dbg(p2p,
2675 "Probe Response is offloaded, do not reply Probe Request");
2676 return P2P_PREQ_PROCESSED;
2677 }
2678
2679 res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len, rx_freq);
2680 if (res != P2P_PREQ_PROCESSED && res != P2P_PREQ_NOT_PROCESSED)
2681 return res;
2682
2683 /*
2684 * Activate a pending GO Negotiation/Invite flow if a received Probe
2685 * Request frame is from an expected peer. Some devices may share the
2686 * same address for P2P and non-P2P STA running simultaneously. The
2687 * P2P_PREQ_PROCESSED and P2P_PREQ_NOT_PROCESSED p2p_reply_probe()
2688 * return values verified above ensure we are handling a Probe Request
2689 * frame from a P2P peer.
2690 */
2691 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
2692 p2p->go_neg_peer &&
2693 ether_addr_equal(addr, p2p->go_neg_peer->info.p2p_device_addr) &&
2694 !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
2695 /* Received a Probe Request from GO Negotiation peer */
2696 p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout");
2697 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);
2698 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL);
2699 return res;
2700 }
2701
2702 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
2703 p2p->invite_peer &&
2704 (p2p->invite_peer->flags & P2P_DEV_WAIT_INV_REQ_ACK) &&
2705 ether_addr_equal(addr, p2p->invite_peer->info.p2p_device_addr)) {
2706 /* Received a Probe Request from Invite peer */
2707 p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout");
2708 eloop_cancel_timeout(p2p_invite_start, p2p, NULL);
2709 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL);
2710 return res;
2711 }
2712
2713 return res;
2714 }
2715
2716
2717 static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid,
2718 u8 *buf, size_t len, struct wpabuf *p2p_ie)
2719 {
2720 struct wpabuf *tmp;
2721 u8 *lpos;
2722 size_t tmplen;
2723 int res;
2724 u8 group_capab;
2725 struct p2p_message msg;
2726
2727 if (p2p_ie == NULL)
2728 return 0; /* WLAN AP is not a P2P manager */
2729
2730 os_memset(&msg, 0, sizeof(msg));
2731 if (p2p_parse_p2p_ie(p2p_ie, &msg) < 0)
2732 return 0;
2733
2734 p2p_dbg(p2p, "BSS P2P manageability %s",
2735 msg.manageability ? "enabled" : "disabled");
2736
2737 if (!msg.manageability)
2738 return 0;
2739
2740 /*
2741 * (Re)Association Request - P2P IE
2742 * P2P Capability attribute (shall be present)
2743 * P2P Interface attribute (present if concurrent device and
2744 * P2P Management is enabled)
2745 */
2746 tmp = wpabuf_alloc(200);
2747 if (tmp == NULL)
2748 return -1;
2749
2750 lpos = p2p_buf_add_ie_hdr(tmp);
2751 group_capab = 0;
2752 if (p2p->num_groups > 0) {
2753 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER;
2754 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2755 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
2756 p2p->cross_connect)
2757 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
2758 }
2759 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);
2760 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
2761 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))
2762 p2p_buf_add_p2p_interface(tmp, p2p);
2763 p2p_buf_update_ie_hdr(tmp, lpos);
2764
2765 tmplen = wpabuf_len(tmp);
2766 if (tmplen > len)
2767 res = -1;
2768 else {
2769 os_memcpy(buf, wpabuf_head(tmp), tmplen);
2770 res = tmplen;
2771 }
2772 wpabuf_free(tmp);
2773
2774 return res;
2775 }
2776
2777
2778 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,
2779 size_t len, int p2p_group, struct wpabuf *p2p_ie)
2780 {
2781 struct wpabuf *tmp;
2782 u8 *lpos;
2783 struct p2p_device *peer;
2784 size_t tmplen;
2785 int res;
2786 size_t extra = 0;
2787
2788 if (!p2p_group)
2789 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie);
2790
2791 #ifdef CONFIG_WIFI_DISPLAY
2792 if (p2p->wfd_ie_assoc_req)
2793 extra = wpabuf_len(p2p->wfd_ie_assoc_req);
2794 #endif /* CONFIG_WIFI_DISPLAY */
2795
2796 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])
2797 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);
2798
2799 /*
2800 * (Re)Association Request - P2P IE
2801 * P2P Capability attribute (shall be present)
2802 * Extended Listen Timing (may be present)
2803 * P2P Device Info attribute (shall be present)
2804 */
2805 tmp = wpabuf_alloc(200 + extra);
2806 if (tmp == NULL)
2807 return -1;
2808
2809 #ifdef CONFIG_WIFI_DISPLAY
2810 if (p2p->wfd_ie_assoc_req)
2811 wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req);
2812 #endif /* CONFIG_WIFI_DISPLAY */
2813
2814 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ])
2815 wpabuf_put_buf(tmp,
2816 p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]);
2817
2818 peer = bssid ? p2p_get_device(p2p, bssid) : NULL;
2819
2820 lpos = p2p_buf_add_ie_hdr(tmp);
2821 p2p_buf_add_capability(tmp, p2p->dev_capab, 0);
2822 if (p2p->ext_listen_interval)
2823 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,
2824 p2p->ext_listen_interval);
2825 p2p_buf_add_device_info(tmp, p2p, peer);
2826 p2p_buf_update_ie_hdr(tmp, lpos);
2827
2828 tmplen = wpabuf_len(tmp);
2829 if (tmplen > len)
2830 res = -1;
2831 else {
2832 os_memcpy(buf, wpabuf_head(tmp), tmplen);
2833 res = tmplen;
2834 }
2835 wpabuf_free(tmp);
2836
2837 return res;
2838 }
2839
2840
2841 int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end)
2842 {
2843 struct wpabuf *p2p_ie;
2844 int ret;
2845
2846 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, P2P_IE_VENDOR_TYPE);
2847 if (p2p_ie == NULL)
2848 return 0;
2849
2850 ret = p2p_attr_text(p2p_ie, buf, end);
2851 wpabuf_free(p2p_ie);
2852 return ret;
2853 }
2854
2855
2856 struct p2ps_advertisement *
2857 p2p_service_p2ps_id(struct p2p_data *p2p, u32 adv_id)
2858 {
2859 struct p2ps_advertisement *adv_data;
2860
2861 if (!p2p)
2862 return NULL;
2863
2864 adv_data = p2p->p2ps_adv_list;
2865 while (adv_data) {
2866 if (adv_data->id == adv_id)
2867 return adv_data;
2868 adv_data = adv_data->next;
2869 }
2870
2871 return NULL;
2872 }
2873
2874
2875 int p2p_service_del_asp(struct p2p_data *p2p, u32 adv_id)
2876 {
2877 struct p2ps_advertisement *adv_data;
2878 struct p2ps_advertisement **prior;
2879
2880 if (!p2p)
2881 return -1;
2882
2883 adv_data = p2p->p2ps_adv_list;
2884 prior = &p2p->p2ps_adv_list;
2885 while (adv_data) {
2886 if (adv_data->id == adv_id) {
2887 p2p_dbg(p2p, "Delete ASP adv_id=0x%x", adv_id);
2888 *prior = adv_data->next;
2889 os_free(adv_data);
2890 return 0;
2891 }
2892 prior = &adv_data->next;
2893 adv_data = adv_data->next;
2894 }
2895
2896 return -1;
2897 }
2898
2899
2900 int p2p_service_add_asp(struct p2p_data *p2p, int auto_accept, u32 adv_id,
2901 const char *adv_str, u8 svc_state, u16 config_methods,
2902 const char *svc_info, const u8 *cpt_priority)
2903 {
2904 struct p2ps_advertisement *adv_data, *tmp, **prev;
2905 u8 buf[P2PS_HASH_LEN];
2906 size_t adv_data_len, adv_len, info_len = 0;
2907 int i;
2908
2909 if (!p2p || !adv_str || !adv_str[0] || !cpt_priority)
2910 return -1;
2911
2912 if (!(config_methods & p2p->cfg->config_methods)) {
2913 p2p_dbg(p2p, "Config methods not supported svc: 0x%x dev: 0x%x",
2914 config_methods, p2p->cfg->config_methods);
2915 return -1;
2916 }
2917
2918 if (!p2ps_gen_hash(p2p, adv_str, buf))
2919 return -1;
2920
2921 if (svc_info)
2922 info_len = os_strlen(svc_info);
2923 adv_len = os_strlen(adv_str);
2924 adv_data_len = sizeof(struct p2ps_advertisement) + adv_len + 1 +
2925 info_len + 1;
2926
2927 adv_data = os_zalloc(adv_data_len);
2928 if (!adv_data)
2929 return -1;
2930
2931 os_memcpy(adv_data->hash, buf, P2PS_HASH_LEN);
2932 adv_data->id = adv_id;
2933 adv_data->state = svc_state;
2934 adv_data->config_methods = config_methods & p2p->cfg->config_methods;
2935 adv_data->auto_accept = (u8) auto_accept;
2936 os_memcpy(adv_data->svc_name, adv_str, adv_len);
2937
2938 for (i = 0; cpt_priority[i] && i < P2PS_FEATURE_CAPAB_CPT_MAX; i++) {
2939 adv_data->cpt_priority[i] = cpt_priority[i];
2940 adv_data->cpt_mask |= cpt_priority[i];
2941 }
2942
2943 if (svc_info && info_len) {
2944 adv_data->svc_info = &adv_data->svc_name[adv_len + 1];
2945 os_memcpy(adv_data->svc_info, svc_info, info_len);
2946 }
2947
2948 /*
2949 * Group Advertisements by service string. They do not need to be
2950 * sorted, but groups allow easier Probe Response instance grouping
2951 */
2952 tmp = p2p->p2ps_adv_list;
2953 prev = &p2p->p2ps_adv_list;
2954 while (tmp) {
2955 if (tmp->id == adv_data->id) {
2956 if (os_strcmp(tmp->svc_name, adv_data->svc_name) != 0) {
2957 os_free(adv_data);
2958 return -1;
2959 }
2960 adv_data->next = tmp->next;
2961 *prev = adv_data;
2962 os_free(tmp);
2963 goto inserted;
2964 } else {
2965 if (os_strcmp(tmp->svc_name, adv_data->svc_name) == 0) {
2966 adv_data->next = tmp->next;
2967 tmp->next = adv_data;
2968 goto inserted;
2969 }
2970 }
2971 prev = &tmp->next;
2972 tmp = tmp->next;
2973 }
2974
2975 /* No svc_name match found */
2976 adv_data->next = p2p->p2ps_adv_list;
2977 p2p->p2ps_adv_list = adv_data;
2978
2979 inserted:
2980 p2p_dbg(p2p,
2981 "Added ASP advertisement adv_id=0x%x config_methods=0x%x svc_state=0x%x adv_str='%s' cpt_mask=0x%x",
2982 adv_id, adv_data->config_methods, svc_state, adv_str,
2983 adv_data->cpt_mask);
2984
2985 return 0;
2986 }
2987
2988
2989 void p2p_service_flush_asp(struct p2p_data *p2p)
2990 {
2991 struct p2ps_advertisement *adv, *prev;
2992
2993 if (!p2p)
2994 return;
2995
2996 adv = p2p->p2ps_adv_list;
2997 while (adv) {
2998 prev = adv;
2999 adv = adv->next;
3000 os_free(prev);
3001 }
3002
3003 p2p->p2ps_adv_list = NULL;
3004 p2ps_prov_free(p2p);
3005 p2p_dbg(p2p, "All ASP advertisements flushed");
3006 }
3007
3008
3009 int p2p_parse_dev_addr_in_p2p_ie(struct wpabuf *p2p_ie, u8 *dev_addr)
3010 {
3011 struct p2p_message msg;
3012
3013 os_memset(&msg, 0, sizeof(msg));
3014 if (p2p_parse_p2p_ie(p2p_ie, &msg))
3015 return -1;
3016
3017 if (msg.p2p_device_addr) {
3018 os_memcpy(dev_addr, msg.p2p_device_addr, ETH_ALEN);
3019 return 0;
3020 } else if (msg.device_id) {
3021 os_memcpy(dev_addr, msg.device_id, ETH_ALEN);
3022 return 0;
3023 }
3024 return -1;
3025 }
3026
3027
3028 int p2p_parse_dev_addr(const u8 *ies, size_t ies_len, u8 *dev_addr)
3029 {
3030 struct wpabuf *p2p_ie;
3031 int ret;
3032
3033 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len,
3034 P2P_IE_VENDOR_TYPE);
3035 if (p2p_ie == NULL)
3036 return -1;
3037 ret = p2p_parse_dev_addr_in_p2p_ie(p2p_ie, dev_addr);
3038 wpabuf_free(p2p_ie);
3039 return ret;
3040 }
3041
3042
3043 static void p2p_clear_go_neg(struct p2p_data *p2p)
3044 {
3045 p2p->go_neg_peer = NULL;
3046 p2p_clear_timeout(p2p);
3047 p2p_set_state(p2p, P2P_IDLE);
3048 }
3049
3050
3051 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr)
3052 {
3053 if (p2p->go_neg_peer == NULL) {
3054 p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification");
3055 return; /* No pending Group Formation */
3056 }
3057
3058 if (!ether_addr_equal(mac_addr, p2p->go_neg_peer->intended_addr)) {
3059 p2p_dbg(p2p, "Ignore WPS registration success notification for "
3060 MACSTR_SEC " (GO Negotiation peer " MACSTR_SEC ")",
3061 MAC2STR_SEC(mac_addr),
3062 MAC2STR_SEC(p2p->go_neg_peer->intended_addr));
3063 return; /* Ignore unexpected peer address */
3064 }
3065
3066 p2p_dbg(p2p, "Group Formation completed successfully with " MACSTR_SEC,
3067 MAC2STR_SEC(mac_addr));
3068
3069 p2p_clear_go_neg(p2p);
3070 }
3071
3072
3073 void p2p_group_formation_failed(struct p2p_data *p2p)
3074 {
3075 if (p2p->go_neg_peer == NULL) {
3076 p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification");
3077 return; /* No pending Group Formation */
3078 }
3079
3080 p2p_dbg(p2p, "Group Formation failed with " MACSTR_SEC,
3081 MAC2STR_SEC(p2p->go_neg_peer->intended_addr));
3082
3083 p2p_clear_go_neg(p2p);
3084 }
3085
3086
3087 bool is_p2p_6ghz_disabled(struct p2p_data *p2p)
3088 {
3089 if (p2p)
3090 return p2p->cfg->p2p_6ghz_disable;
3091 return false;
3092 }
3093
3094
3095 struct p2p_data * p2p_init(const struct p2p_config *cfg)
3096 {
3097 struct p2p_data *p2p;
3098
3099 if (cfg->max_peers < 1 ||
3100 cfg->passphrase_len < 8 || cfg->passphrase_len > 63)
3101 return NULL;
3102
3103 p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg));
3104 if (p2p == NULL)
3105 return NULL;
3106 p2p->cfg = (struct p2p_config *) (p2p + 1);
3107 os_memcpy(p2p->cfg, cfg, sizeof(*cfg));
3108 if (cfg->dev_name)
3109 p2p->cfg->dev_name = os_strdup(cfg->dev_name);
3110 if (cfg->manufacturer)
3111 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);
3112 if (cfg->model_name)
3113 p2p->cfg->model_name = os_strdup(cfg->model_name);
3114 if (cfg->model_number)
3115 p2p->cfg->model_number = os_strdup(cfg->model_number);
3116 if (cfg->serial_number)
3117 p2p->cfg->serial_number = os_strdup(cfg->serial_number);
3118 if (cfg->pref_chan) {
3119 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan *
3120 sizeof(struct p2p_channel));
3121 if (p2p->cfg->pref_chan) {
3122 os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan,
3123 cfg->num_pref_chan *
3124 sizeof(struct p2p_channel));
3125 } else
3126 p2p->cfg->num_pref_chan = 0;
3127 }
3128
3129 p2ps_gen_hash(p2p, P2PS_WILD_HASH_STR, p2p->wild_card_hash);
3130
3131 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
3132 p2p->min_disc_int = 2;
3133 #else
3134 p2p->min_disc_int = 1;
3135 #endif /* HARMONY_P2P_CONNECTIVITY_PATCH */
3136 p2p->max_disc_int = 3;
3137 p2p->max_disc_tu = -1;
3138
3139 if (os_get_random(&p2p->next_tie_breaker, 1) < 0)
3140 p2p->next_tie_breaker = 0;
3141 p2p->next_tie_breaker &= 0x01;
3142 if (cfg->sd_request)
3143 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
3144 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
3145 if (cfg->concurrent_operations)
3146 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
3147 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3148
3149 dl_list_init(&p2p->devices);
3150
3151 p2p->go_timeout = 100;
3152 p2p->client_timeout = 20;
3153 p2p->num_p2p_sd_queries = 0;
3154
3155 p2p_dbg(p2p, "initialized");
3156 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);
3157 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);
3158
3159 #ifdef CONFIG_OPEN_HARMONY_PATCH
3160 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
3161 /* GO negotiation optimization initial, set enable to 1 and process to 1*/
3162 p2p_set_enable_go_neg_opt(p2p, 1);
3163 p2p_set_process_go_neg_opt(p2p, 1);
3164 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
3165 p2p->calculated_go_intent = P2P_GO_NEG_OPT_INTENT;
3166 #endif
3167 #endif
3168 #endif
3169 #ifdef HARMONY_CONNECTIVITY_PATCH
3170 #ifndef OPEN_HARMONY_MIRACAST_SINK_OPT
3171 p2p_set_persistent_group_need_remove_flag(p2p, 0);
3172 #endif
3173 #endif
3174
3175 #ifdef OPEN_HARMONY_P2P_ONEHOP_FIND
3176 p2p->pvt_p2p_service = P2P_NORMAL_FIND;
3177 #endif
3178 #ifdef CONFIG_WIFI_RPT
3179 p2p->p2p_rpt_net_id = DEFAULT_RPT_ID;
3180 #endif
3181 return p2p;
3182 }
3183
3184
3185 void p2p_deinit(struct p2p_data *p2p)
3186 {
3187 #ifdef CONFIG_WIFI_DISPLAY
3188 wpabuf_free(p2p->wfd_ie_beacon);
3189 wpabuf_free(p2p->wfd_ie_probe_req);
3190 wpabuf_free(p2p->wfd_ie_probe_resp);
3191 wpabuf_free(p2p->wfd_ie_assoc_req);
3192 wpabuf_free(p2p->wfd_ie_invitation);
3193 wpabuf_free(p2p->wfd_ie_prov_disc_req);
3194 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
3195 wpabuf_free(p2p->wfd_ie_go_neg);
3196 wpabuf_free(p2p->wfd_dev_info);
3197 wpabuf_free(p2p->wfd_assoc_bssid);
3198 wpabuf_free(p2p->wfd_coupled_sink_info);
3199 wpabuf_free(p2p->wfd_r2_dev_info);
3200 #endif /* CONFIG_WIFI_DISPLAY */
3201
3202 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
3203 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL);
3204 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
3205 p2p_flush(p2p);
3206 p2p_free_req_dev_types(p2p);
3207 os_free(p2p->cfg->dev_name);
3208 os_free(p2p->cfg->manufacturer);
3209 os_free(p2p->cfg->model_name);
3210 os_free(p2p->cfg->model_number);
3211 os_free(p2p->cfg->serial_number);
3212 os_free(p2p->cfg->pref_chan);
3213 os_free(p2p->groups);
3214 p2ps_prov_free(p2p);
3215 wpabuf_free(p2p->sd_resp);
3216 p2p_remove_wps_vendor_extensions(p2p);
3217 os_free(p2p->no_go_freq.range);
3218 p2p_service_flush_asp(p2p);
3219
3220 os_free(p2p);
3221 }
3222
3223
3224 void p2p_flush(struct p2p_data *p2p)
3225 {
3226 struct p2p_device *dev, *prev;
3227
3228 p2p_ext_listen(p2p, 0, 0);
3229 p2p_stop_find(p2p);
3230 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
3231 list) {
3232 dl_list_del(&dev->list);
3233 p2p_device_free(p2p, dev);
3234 }
3235 p2p_free_sd_queries(p2p);
3236 p2p->ssid_set = 0;
3237 p2ps_prov_free(p2p);
3238 p2p_reset_pending_pd(p2p);
3239 p2p->override_pref_op_class = 0;
3240 p2p->override_pref_channel = 0;
3241 }
3242
3243
3244 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr)
3245 {
3246 struct p2p_device *dev;
3247
3248 dev = p2p_get_device(p2p, addr);
3249 if (dev == NULL)
3250 return -1;
3251
3252 p2p_dbg(p2p, "Unauthorizing " MACSTR_SEC, MAC2STR_SEC(addr));
3253
3254 if (p2p->go_neg_peer == dev) {
3255 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
3256 p2p->go_neg_peer = NULL;
3257 }
3258
3259 dev->wps_method = WPS_NOT_READY;
3260 dev->oob_pw_id = 0;
3261 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
3262 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
3263
3264 return 0;
3265 }
3266
3267
3268 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name)
3269 {
3270 os_free(p2p->cfg->dev_name);
3271 if (dev_name) {
3272 p2p->cfg->dev_name = os_strdup(dev_name);
3273 if (p2p->cfg->dev_name == NULL)
3274 return -1;
3275 } else
3276 p2p->cfg->dev_name = NULL;
3277 return 0;
3278 }
3279
3280
3281 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer)
3282 {
3283 os_free(p2p->cfg->manufacturer);
3284 p2p->cfg->manufacturer = NULL;
3285 if (manufacturer) {
3286 p2p->cfg->manufacturer = os_strdup(manufacturer);
3287 if (p2p->cfg->manufacturer == NULL)
3288 return -1;
3289 }
3290
3291 return 0;
3292 }
3293
3294
3295 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name)
3296 {
3297 os_free(p2p->cfg->model_name);
3298 p2p->cfg->model_name = NULL;
3299 if (model_name) {
3300 p2p->cfg->model_name = os_strdup(model_name);
3301 if (p2p->cfg->model_name == NULL)
3302 return -1;
3303 }
3304
3305 return 0;
3306 }
3307
3308
3309 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number)
3310 {
3311 os_free(p2p->cfg->model_number);
3312 p2p->cfg->model_number = NULL;
3313 if (model_number) {
3314 p2p->cfg->model_number = os_strdup(model_number);
3315 if (p2p->cfg->model_number == NULL)
3316 return -1;
3317 }
3318
3319 return 0;
3320 }
3321
3322
3323 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number)
3324 {
3325 os_free(p2p->cfg->serial_number);
3326 p2p->cfg->serial_number = NULL;
3327 if (serial_number) {
3328 p2p->cfg->serial_number = os_strdup(serial_number);
3329 if (p2p->cfg->serial_number == NULL)
3330 return -1;
3331 }
3332
3333 return 0;
3334 }
3335
3336
3337 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods)
3338 {
3339 p2p->cfg->config_methods = config_methods;
3340 }
3341
3342
3343 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid)
3344 {
3345 os_memcpy(p2p->cfg->uuid, uuid, 16);
3346 }
3347
3348
3349 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type)
3350 {
3351 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);
3352 return 0;
3353 }
3354
3355
3356 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],
3357 size_t num_dev_types)
3358 {
3359 if (num_dev_types > P2P_SEC_DEVICE_TYPES)
3360 num_dev_types = P2P_SEC_DEVICE_TYPES;
3361 p2p->cfg->num_sec_dev_types = num_dev_types;
3362 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);
3363 return 0;
3364 }
3365
3366
3367 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p)
3368 {
3369 int i;
3370
3371 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
3372 wpabuf_free(p2p->wps_vendor_ext[i]);
3373 p2p->wps_vendor_ext[i] = NULL;
3374 }
3375 }
3376
3377
3378 int p2p_add_wps_vendor_extension(struct p2p_data *p2p,
3379 const struct wpabuf *vendor_ext)
3380 {
3381 int i;
3382
3383 if (vendor_ext == NULL)
3384 return -1;
3385
3386 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
3387 if (p2p->wps_vendor_ext[i] == NULL)
3388 break;
3389 }
3390 if (i >= P2P_MAX_WPS_VENDOR_EXT)
3391 return -1;
3392
3393 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);
3394 if (p2p->wps_vendor_ext[i] == NULL)
3395 return -1;
3396
3397 return 0;
3398 }
3399
3400
3401 int p2p_set_country(struct p2p_data *p2p, const char *country)
3402 {
3403 os_memcpy(p2p->cfg->country, country, 3);
3404 return 0;
3405 }
3406
3407
3408 static int p2p_pre_find_operation(struct p2p_data *p2p, struct p2p_device *dev)
3409 {
3410 int res;
3411
3412 if (dev->sd_pending_bcast_queries == 0) {
3413 /* Initialize with total number of registered broadcast
3414 * SD queries. */
3415 dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries;
3416 }
3417
3418 res = p2p_start_sd(p2p, dev);
3419 if (res == -2)
3420 return -2;
3421 if (res == 0)
3422 return 1;
3423
3424 if (dev->req_config_methods &&
3425 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) {
3426 p2p_dbg(p2p, "Send pending Provision Discovery Request to "
3427 MACSTR_SEC " (config methods 0x%x)",
3428 MAC2STR_SEC(dev->info.p2p_device_addr),
3429 dev->req_config_methods);
3430 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)
3431 return 1;
3432 }
3433
3434 return 0;
3435 }
3436
3437
3438 void p2p_continue_find(struct p2p_data *p2p)
3439 {
3440 struct p2p_device *dev;
3441 int found, res;
3442
3443 p2p_set_state(p2p, P2P_SEARCH);
3444
3445 /* Continue from the device following the last iteration */
3446 found = 0;
3447 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3448 if (dev == p2p->last_p2p_find_oper) {
3449 found = 1;
3450 continue;
3451 }
3452 if (!found)
3453 continue;
3454 res = p2p_pre_find_operation(p2p, dev);
3455 if (res > 0) {
3456 p2p->last_p2p_find_oper = dev;
3457 return;
3458 }
3459 if (res == -2)
3460 goto skip_sd;
3461 }
3462
3463 /*
3464 * Wrap around to the beginning of the list and continue until the last
3465 * iteration device.
3466 */
3467 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3468 res = p2p_pre_find_operation(p2p, dev);
3469 if (res > 0) {
3470 p2p->last_p2p_find_oper = dev;
3471 return;
3472 }
3473 if (res == -2)
3474 goto skip_sd;
3475 if (dev == p2p->last_p2p_find_oper)
3476 break;
3477 }
3478
3479 skip_sd:
3480 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN);
3481 p2p_listen_in_find(p2p, 1);
3482 }
3483
3484
3485 void p2p_sd_query_cb(struct p2p_data *p2p, int success)
3486 {
3487 p2p_dbg(p2p, "Service Discovery Query TX callback: success=%d",
3488 success);
3489 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3490
3491 if (!success) {
3492 if (p2p->sd_peer) {
3493 if (is_zero_ether_addr(p2p->sd_query_no_ack)) {
3494 os_memcpy(p2p->sd_query_no_ack,
3495 p2p->sd_peer->info.p2p_device_addr,
3496 ETH_ALEN);
3497 p2p_dbg(p2p,
3498 "First SD Query no-ACK in this search iteration: "
3499 MACSTR_SEC, MAC2STR_SEC(p2p->sd_query_no_ack));
3500 }
3501 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3502 }
3503 p2p->sd_peer = NULL;
3504 if (p2p->state != P2P_IDLE)
3505 p2p_continue_find(p2p);
3506 return;
3507 }
3508
3509 if (p2p->sd_peer == NULL) {
3510 p2p_dbg(p2p, "No SD peer entry known");
3511 if (p2p->state != P2P_IDLE)
3512 p2p_continue_find(p2p);
3513 return;
3514 }
3515
3516 if (p2p->sd_query && p2p->sd_query->for_all_peers) {
3517 /* Update the pending broadcast SD query count for this device
3518 */
3519 p2p->sd_peer->sd_pending_bcast_queries--;
3520
3521 /*
3522 * If there are no pending broadcast queries for this device,
3523 * mark it as done (-1).
3524 */
3525 if (p2p->sd_peer->sd_pending_bcast_queries == 0)
3526 p2p->sd_peer->sd_pending_bcast_queries = -1;
3527 }
3528
3529 /* Wait for response from the peer */
3530 p2p_set_state(p2p, P2P_SD_DURING_FIND);
3531 p2p_set_timeout(p2p, 0, 200000);
3532 }
3533
3534
3535 /**
3536 * p2p_retry_pd - Retry any pending provision disc requests in IDLE state
3537 * @p2p: P2P module context from p2p_init()
3538 */
3539 static void p2p_retry_pd(struct p2p_data *p2p)
3540 {
3541 struct p2p_device *dev;
3542
3543 /*
3544 * Retry the prov disc req attempt only for the peer that the user had
3545 * requested.
3546 */
3547
3548 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3549 if (!ether_addr_equal(p2p->pending_pd_devaddr,
3550 dev->info.p2p_device_addr))
3551 continue;
3552 if (!dev->req_config_methods)
3553 continue;
3554
3555 p2p_dbg(p2p, "Send pending Provision Discovery Request to "
3556 MACSTR_SEC " (config methods 0x%x)",
3557 MAC2STR_SEC(dev->info.p2p_device_addr),
3558 dev->req_config_methods);
3559 p2p_send_prov_disc_req(p2p, dev,
3560 dev->flags & P2P_DEV_PD_FOR_JOIN,
3561 p2p->pd_force_freq);
3562 return;
3563 }
3564 }
3565
3566
3567 static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)
3568 {
3569 p2p_warning(p2p, "Provision Discovery Request TX callback: success=%d",
3570 success);
3571
3572 /*
3573 * Postpone resetting the pending action state till after we actually
3574 * time out. This allows us to take some action like notifying any
3575 * interested parties about no response to the request.
3576 *
3577 * When the timer (below) goes off we check in IDLE, SEARCH, or
3578 * LISTEN_ONLY state, which are the only allowed states to issue a PD
3579 * requests in, if this was still pending and then raise notification.
3580 */
3581
3582 if (!success) {
3583 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3584
3585 if (p2p->user_initiated_pd &&
3586 (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY))
3587 {
3588 /* Retry request from timeout to avoid busy loops */
3589 p2p->pending_action_state = P2P_PENDING_PD;
3590 p2p_set_timeout(p2p, 0, 50000);
3591 } else if (p2p->state != P2P_IDLE)
3592 p2p_continue_find(p2p);
3593 else if (p2p->user_initiated_pd) {
3594 p2p->pending_action_state = P2P_PENDING_PD;
3595 p2p_set_timeout(p2p, 0, 300000);
3596 }
3597 return;
3598 }
3599
3600 /*
3601 * If after PD Request the peer doesn't expect to receive PD Response
3602 * the PD Request ACK indicates a completion of the current PD. This
3603 * happens only on the advertiser side sending the follow-on PD Request
3604 * with the status different than 12 (Success: accepted by user).
3605 */
3606 if (p2p->p2ps_prov && !p2p->p2ps_prov->pd_seeker &&
3607 p2p->p2ps_prov->status != P2P_SC_SUCCESS_DEFERRED) {
3608 p2p_dbg(p2p, "P2PS PD completion on Follow-on PD Request ACK");
3609
3610 if (p2p->send_action_in_progress) {
3611 p2p->send_action_in_progress = 0;
3612 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3613 }
3614
3615 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3616
3617 if (p2p->cfg->p2ps_prov_complete) {
3618 p2p->cfg->p2ps_prov_complete(
3619 p2p->cfg->cb_ctx,
3620 p2p->p2ps_prov->status,
3621 p2p->p2ps_prov->adv_mac,
3622 p2p->p2ps_prov->adv_mac,
3623 p2p->p2ps_prov->session_mac,
3624 NULL, p2p->p2ps_prov->adv_id,
3625 p2p->p2ps_prov->session_id,
3626 0, 0, NULL, 0, 0, 0,
3627 NULL, NULL, 0, 0, NULL, 0);
3628 }
3629
3630 if (p2p->user_initiated_pd)
3631 p2p_reset_pending_pd(p2p);
3632
3633 p2ps_prov_free(p2p);
3634 return;
3635 }
3636
3637 /*
3638 * This postponing, of resetting pending_action_state, needs to be
3639 * done only for user initiated PD requests and not internal ones.
3640 */
3641 if (p2p->user_initiated_pd)
3642 p2p->pending_action_state = P2P_PENDING_PD;
3643 else
3644 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3645
3646 /* Wait for response from the peer */
3647 if (p2p->state == P2P_SEARCH)
3648 p2p_set_state(p2p, P2P_PD_DURING_FIND);
3649 p2p_set_timeout(p2p, 0, 200000);
3650 }
3651
3652
3653 static void p2p_prov_disc_resp_cb(struct p2p_data *p2p, int success)
3654 {
3655 p2p_dbg(p2p, "Provision Discovery Response TX callback: success=%d",
3656 success);
3657
3658 if (p2p->send_action_in_progress) {
3659 p2p->send_action_in_progress = 0;
3660 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3661 }
3662
3663 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3664
3665 if (!success) {
3666 if (p2p->state == P2P_SEARCH)
3667 p2p_continue_find(p2p);
3668 return;
3669 }
3670
3671 if (!p2p->cfg->prov_disc_resp_cb ||
3672 p2p->cfg->prov_disc_resp_cb(p2p->cfg->cb_ctx) < 1) {
3673 if (p2p->state == P2P_SEARCH)
3674 p2p_continue_find(p2p);
3675 return;
3676 }
3677
3678 p2p_dbg(p2p,
3679 "Post-Provision Discovery operations started - do not try to continue other P2P operations");
3680 }
3681
3682
3683 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,
3684 struct os_reltime *rx_time, int level, const u8 *ies,
3685 size_t ies_len)
3686 {
3687 if (os_reltime_before(rx_time, &p2p->find_start)) {
3688 /*
3689 * The driver may have cached (e.g., in cfg80211 BSS table) the
3690 * scan results for relatively long time. To avoid reporting
3691 * stale information, update P2P peers only based on results
3692 * that have based on frames received after the last p2p_find
3693 * operation was started.
3694 */
3695 p2p_dbg(p2p, "Ignore old scan result for " MACSTR_SEC
3696 " (rx_time=%u.%06u find_start=%u.%06u)",
3697 MAC2STR_SEC(bssid), (unsigned int) rx_time->sec,
3698 (unsigned int) rx_time->usec,
3699 (unsigned int) p2p->find_start.sec,
3700 (unsigned int) p2p->find_start.usec);
3701 return 0;
3702 }
3703
3704 p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1);
3705
3706 return 0;
3707 }
3708
3709
3710 void p2p_scan_res_handled(struct p2p_data *p2p, unsigned int delay)
3711 {
3712 if (!p2p->p2p_scan_running) {
3713 p2p_dbg(p2p, "p2p_scan was not running, but scan results received");
3714 }
3715 p2p->p2p_scan_running = 0;
3716
3717 /* Use this delay only when p2p_find doesn't set it */
3718 if (!p2p->search_delay)
3719 p2p->search_delay = delay;
3720
3721 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
3722
3723 if (p2p_run_after_scan(p2p))
3724 return;
3725 if (p2p->state == P2P_SEARCH)
3726 p2p_continue_find(p2p);
3727 }
3728
3729
3730 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id,
3731 unsigned int bands)
3732 {
3733 u8 dev_capab;
3734 u8 *len;
3735
3736 #ifdef CONFIG_WIFI_DISPLAY
3737 if (p2p->wfd_ie_probe_req)
3738 wpabuf_put_buf(ies, p2p->wfd_ie_probe_req);
3739 #endif /* CONFIG_WIFI_DISPLAY */
3740
3741 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])
3742 wpabuf_put_buf(ies,
3743 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);
3744
3745 len = p2p_buf_add_ie_hdr(ies);
3746
3747 dev_capab = p2p->dev_capab & ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3748
3749 /* P2PS requires Probe Request frames to include SD bit */
3750 if (p2p->p2ps_seek && p2p->p2ps_seek_count)
3751 dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
3752
3753 p2p_buf_add_capability(ies, dev_capab, 0);
3754
3755 if (dev_id)
3756 p2p_buf_add_device_id(ies, dev_id);
3757 if (p2p->cfg->reg_class && p2p->cfg->channel)
3758 p2p_buf_add_listen_channel(ies, p2p->cfg->country,
3759 p2p->cfg->reg_class,
3760 p2p->cfg->channel);
3761 if (p2p->ext_listen_interval)
3762 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,
3763 p2p->ext_listen_interval);
3764
3765 if (bands & BAND_60_GHZ)
3766 p2p_buf_add_device_info(ies, p2p, NULL);
3767
3768 if (p2p->p2ps_seek && p2p->p2ps_seek_count)
3769 p2p_buf_add_service_hash(ies, p2p);
3770
3771 /* TODO: p2p_buf_add_operating_channel() if GO */
3772 p2p_buf_update_ie_hdr(ies, len);
3773 }
3774
3775
3776 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p)
3777 {
3778 size_t len = 100;
3779
3780 #ifdef CONFIG_WIFI_DISPLAY
3781 if (p2p && p2p->wfd_ie_probe_req)
3782 len += wpabuf_len(p2p->wfd_ie_probe_req);
3783 #endif /* CONFIG_WIFI_DISPLAY */
3784
3785 if (p2p && p2p->vendor_elem &&
3786 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P])
3787 len += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]);
3788
3789 return len;
3790 }
3791
3792
3793 int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end)
3794 {
3795 return p2p_attr_text(p2p_ie, buf, end);
3796 }
3797
3798
3799 static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success)
3800 {
3801 struct p2p_device *dev = p2p->go_neg_peer;
3802 int timeout;
3803
3804 p2p_dbg(p2p, "GO Negotiation Request TX callback: success=%d", success);
3805
3806 if (dev == NULL) {
3807 p2p_dbg(p2p, "No pending GO Negotiation");
3808 return;
3809 }
3810
3811 if (success) {
3812 if (dev->flags & P2P_DEV_USER_REJECTED) {
3813 p2p_set_state(p2p, P2P_IDLE);
3814 return;
3815 }
3816 } else if (dev->go_neg_req_sent) {
3817 /* Cancel the increment from p2p_connect_send() on failure */
3818 dev->go_neg_req_sent--;
3819 }
3820
3821 if (!success &&
3822 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
3823 !is_zero_ether_addr(dev->member_in_go_dev)) {
3824 p2p_dbg(p2p, "Peer " MACSTR_SEC " did not acknowledge request - try to use device discoverability through its GO",
3825 MAC2STR_SEC(dev->info.p2p_device_addr));
3826 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3827 p2p_send_dev_disc_req(p2p, dev);
3828 return;
3829 }
3830
3831 /*
3832 * Use P2P find, if needed, to find the other device from its listen
3833 * channel.
3834 */
3835 p2p_set_state(p2p, P2P_CONNECT);
3836 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
3837 timeout = success ? P2P_CONNECT_TIMEOUT_MAX_USEC : P2P_CONNECT_TIMEOUT_MIN_USEC;
3838 #else
3839 timeout = success ? P2P_CONNECT_TIMEOUT_DEFAULT_USEC : P2P_CONNECT_TIMEOUT_MIN_USEC;
3840 #endif
3841 if (!success && p2p->go_neg_peer &&
3842 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) {
3843 unsigned int r;
3844 /*
3845 * Peer is expected to wait our response and we will skip the
3846 * listen phase. Add some randomness to the wait time here to
3847 * make it less likely to hit cases where we could end up in
3848 * sync with peer not listening.
3849 */
3850 if (os_get_random((u8 *) &r, sizeof(r)) < 0)
3851 r = 0;
3852 timeout += r % 100000;
3853 }
3854 p2p_set_timeout(p2p, 0, timeout);
3855 }
3856
3857
3858 static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)
3859 {
3860 p2p_dbg(p2p, "GO Negotiation Response TX callback: success=%d",
3861 success);
3862 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {
3863 p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore");
3864 return;
3865 }
3866 p2p_set_state(p2p, P2P_CONNECT);
3867 #if defined(CONFIG_OHOS_P2P)
3868 p2p_set_timeout(p2p, 0, 800000);
3869 #elif defined(CONFIG_P2P_OPT)
3870 p2p_set_timeout(p2p, 0, P2P_CONNECT_TIMEOUT_USEC);
3871 #else
3872 p2p_set_timeout(p2p, 0, 500000);
3873 #endif // CONFIG_OHOS_P2P
3874 }
3875
3876
3877 static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success,
3878 const u8 *addr)
3879 {
3880 p2p_dbg(p2p, "GO Negotiation Response (failure) TX callback: success=%d", success);
3881 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {
3882 p2p_go_neg_failed(p2p, p2p->go_neg_peer->status);
3883 return;
3884 }
3885
3886 if (success) {
3887 struct p2p_device *dev;
3888 dev = p2p_get_device(p2p, addr);
3889 if (dev &&
3890 dev->status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
3891 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE;
3892 }
3893
3894 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND)
3895 p2p_continue_find(p2p);
3896 }
3897
3898
3899 static void p2p_go_neg_conf_cb(struct p2p_data *p2p,
3900 enum p2p_send_action_result result)
3901 {
3902 struct p2p_device *dev;
3903
3904 p2p_dbg(p2p, "GO Negotiation Confirm TX callback: result=%d", result);
3905 if (result == P2P_SEND_ACTION_FAILED) {
3906 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3907 p2p_go_neg_failed(p2p, -1);
3908 return;
3909 }
3910
3911 dev = p2p->go_neg_peer;
3912
3913 if (result == P2P_SEND_ACTION_NO_ACK) {
3914 /*
3915 * Retry GO Negotiation Confirmation
3916 * P2P_GO_NEG_CNF_MAX_RETRY_COUNT times if we did not receive
3917 * ACK for confirmation.
3918 */
3919 if (dev && dev->go_neg_conf &&
3920 dev->go_neg_conf_sent <= P2P_GO_NEG_CNF_MAX_RETRY_COUNT) {
3921 p2p_dbg(p2p, "GO Negotiation Confirm retry %d",
3922 dev->go_neg_conf_sent);
3923 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;
3924 if (p2p_send_action(p2p, dev->go_neg_conf_freq,
3925 dev->info.p2p_device_addr,
3926 p2p->cfg->dev_addr,
3927 dev->info.p2p_device_addr,
3928 wpabuf_head(dev->go_neg_conf),
3929 wpabuf_len(dev->go_neg_conf), 0) >=
3930 0) {
3931 dev->go_neg_conf_sent++;
3932 return;
3933 }
3934 p2p_dbg(p2p, "Failed to re-send Action frame");
3935
3936 /*
3937 * Continue with the assumption that the first attempt
3938 * went through and just the ACK frame was lost.
3939 */
3940 }
3941
3942 /*
3943 * It looks like the TX status for GO Negotiation Confirm is
3944 * often showing failure even when the peer has actually
3945 * received the frame. Since the peer may change channels
3946 * immediately after having received the frame, we may not see
3947 * an Ack for retries, so just dropping a single frame may
3948 * trigger this. To allow the group formation to succeed if the
3949 * peer did indeed receive the frame, continue regardless of
3950 * the TX status.
3951 */
3952 p2p_dbg(p2p, "Assume GO Negotiation Confirm TX was actually received by the peer even though Ack was not reported");
3953 }
3954
3955 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3956
3957 if (dev == NULL)
3958 return;
3959
3960 p2p_go_complete(p2p, dev);
3961 }
3962
3963
3964 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
3965 const u8 *src, const u8 *bssid,
3966 enum p2p_send_action_result result)
3967 {
3968 enum p2p_pending_action_state state;
3969 int success;
3970
3971 p2p_dbg(p2p, "Action frame TX callback (state=%d freq=%u dst=" MACSTR_SEC
3972 " src=" MACSTR_SEC " bssid=" MACSTR_SEC " result=%d p2p_state=%s)",
3973 p2p->pending_action_state, freq, MAC2STR_SEC(dst), MAC2STR_SEC(src),
3974 MAC2STR_SEC(bssid), result, p2p_state_txt(p2p->state));
3975 success = result == P2P_SEND_ACTION_SUCCESS;
3976 state = p2p->pending_action_state;
3977 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3978 switch (state) {
3979 case P2P_NO_PENDING_ACTION:
3980 if (p2p->send_action_in_progress) {
3981 p2p->send_action_in_progress = 0;
3982 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
3983 }
3984 break;
3985 case P2P_PENDING_GO_NEG_REQUEST:
3986 p2p_go_neg_req_cb(p2p, success);
3987 break;
3988 case P2P_PENDING_GO_NEG_RESPONSE:
3989 p2p_go_neg_resp_cb(p2p, success);
3990 break;
3991 case P2P_PENDING_GO_NEG_RESPONSE_FAILURE:
3992 p2p_go_neg_resp_failure_cb(p2p, success, dst);
3993 break;
3994 case P2P_PENDING_GO_NEG_CONFIRM:
3995 p2p_go_neg_conf_cb(p2p, result);
3996 break;
3997 case P2P_PENDING_SD:
3998 p2p_sd_query_cb(p2p, success);
3999 break;
4000 case P2P_PENDING_PD:
4001 p2p_prov_disc_cb(p2p, success);
4002 break;
4003 case P2P_PENDING_PD_RESPONSE:
4004 p2p_prov_disc_resp_cb(p2p, success);
4005 break;
4006 case P2P_PENDING_INVITATION_REQUEST:
4007 p2p_invitation_req_cb(p2p, success);
4008 break;
4009 case P2P_PENDING_INVITATION_RESPONSE:
4010 p2p_invitation_resp_cb(p2p, success);
4011 break;
4012 case P2P_PENDING_DEV_DISC_REQUEST:
4013 p2p_dev_disc_req_cb(p2p, success);
4014 break;
4015 case P2P_PENDING_DEV_DISC_RESPONSE:
4016 p2p_dev_disc_resp_cb(p2p, success);
4017 break;
4018 case P2P_PENDING_GO_DISC_REQ:
4019 p2p_go_disc_req_cb(p2p, success);
4020 break;
4021 }
4022 }
4023
4024
4025 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,
4026 unsigned int duration)
4027 {
4028 if (freq == p2p->pending_client_disc_freq) {
4029 p2p_dbg(p2p, "Client discoverability remain-awake completed");
4030 p2p->pending_client_disc_freq = 0;
4031 return;
4032 }
4033
4034 #ifndef OPEN_HARMONY_MIRACAST_SINK_OPT
4035 if (freq != p2p->pending_listen_freq) {
4036 p2p_dbg(p2p, "Unexpected listen callback for freq=%u duration=%u (pending_listen_freq=%u)",
4037 freq, duration, p2p->pending_listen_freq);
4038 return;
4039 }
4040 #endif
4041
4042 p2p_dbg(p2p, "Starting Listen timeout(%u,%u) on freq=%u based on callback",
4043 p2p->pending_listen_sec, p2p->pending_listen_usec,
4044 p2p->pending_listen_freq);
4045 p2p->pending_listen_wait_drv = false;
4046 p2p->in_listen = 1;
4047 p2p->drv_in_listen = freq;
4048 if (p2p->pending_listen_sec || p2p->pending_listen_usec) {
4049 /*
4050 * Add 20 msec extra wait to avoid race condition with driver
4051 * remain-on-channel end event, i.e., give driver more time to
4052 * complete the operation before our timeout expires.
4053 */
4054
4055 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
4056 p2p_set_timeout(p2p, p2p->pending_listen_sec,
4057 p2p->pending_listen_usec + HM_P2P_LISTEN_EXTRA_WAIT_TIME);
4058 #else
4059 p2p_set_timeout(p2p, p2p->pending_listen_sec,
4060 p2p->pending_listen_usec + 20000);
4061 #endif
4062 }
4063
4064 p2p->pending_listen_freq = 0;
4065 }
4066
4067
4068 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq)
4069 {
4070 p2p_dbg(p2p, "Driver ended Listen state (freq=%u)", freq);
4071 p2p->drv_in_listen = 0;
4072 if (p2p->in_listen)
4073 return 0; /* Internal timeout will trigger the next step */
4074
4075 if (p2p->state == P2P_WAIT_PEER_CONNECT && p2p->go_neg_peer &&
4076 p2p->pending_listen_freq) {
4077 /*
4078 * Better wait a bit if the driver is unable to start
4079 * offchannel operation for some reason to continue with
4080 * P2P_WAIT_PEER_(IDLE/CONNECT) state transitions.
4081 */
4082 p2p_dbg(p2p,
4083 "Listen operation did not seem to start - delay idle phase to avoid busy loop");
4084 p2p_set_timeout(p2p, 0, 100000);
4085 return 1;
4086 }
4087
4088 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {
4089 if (p2p->go_neg_peer->connect_reqs >= 120) {
4090 p2p_warning(p2p, "Timeout on sending GO Negotiation Request without getting response");
4091 p2p_go_neg_failed(p2p, -1);
4092 return 0;
4093 }
4094
4095 p2p_set_state(p2p, P2P_CONNECT);
4096 p2p_connect_send(p2p, p2p->go_neg_peer);
4097 return 1;
4098 } else if (p2p->state == P2P_SEARCH) {
4099 if (p2p->p2p_scan_running) {
4100 /*
4101 * Search is already in progress. This can happen if
4102 * an Action frame RX is reported immediately after
4103 * the end of a remain-on-channel operation and the
4104 * response frame to that is sent using an offchannel
4105 * operation while in p2p_find. Avoid an attempt to
4106 * restart a scan here.
4107 */
4108 p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one");
4109 return 1;
4110 }
4111 if (p2p->pending_listen_freq) {
4112 /*
4113 * Better wait a bit if the driver is unable to start
4114 * offchannel operation for some reason. p2p_search()
4115 * will be started from internal timeout.
4116 */
4117 p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop");
4118 p2p_set_timeout(p2p, 0, 100000);
4119 return 1;
4120 }
4121 if (p2p->search_delay) {
4122 p2p_dbg(p2p, "Delay search operation by %u ms",
4123 p2p->search_delay);
4124 p2p_set_timeout(p2p, p2p->search_delay / 1000,
4125 (p2p->search_delay % 1000) * 1000);
4126 return 1;
4127 }
4128 p2p_search(p2p);
4129 return 1;
4130 }
4131
4132 return 0;
4133 }
4134
4135
4136 static void p2p_timeout_connect(struct p2p_data *p2p)
4137 {
4138 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4139 if (p2p->go_neg_peer &&
4140 (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
4141 p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed");
4142 #ifdef CONFIG_P2P_CHR
4143 wpa_supplicant_upload_state_before_group_formation_success(GROUP_OWNER_NEGOTIATION,
4144 P2P_EVENT_REASON_GO_NEGOTIATION_WAIT_CONFRIM_FAILURE);
4145 #endif
4146 p2p_go_neg_failed(p2p, -1);
4147 return;
4148 }
4149 if (p2p->go_neg_peer &&
4150 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) &&
4151 p2p->go_neg_peer->connect_reqs < 120) {
4152 p2p_dbg(p2p, "Peer expected to wait our response - skip listen");
4153 p2p_connect_send(p2p, p2p->go_neg_peer);
4154 return;
4155 }
4156 if (p2p->go_neg_peer && p2p->go_neg_peer->oob_go_neg_freq > 0) {
4157 p2p_dbg(p2p, "Skip connect-listen since GO Neg channel known (OOB)");
4158 p2p_set_state(p2p, P2P_CONNECT_LISTEN);
4159 p2p_set_timeout(p2p, 0, 30000);
4160 return;
4161 }
4162 p2p_set_state(p2p, P2P_CONNECT_LISTEN);
4163 p2p_listen_in_find(p2p, 0);
4164 }
4165
4166
4167 static void p2p_timeout_connect_listen(struct p2p_data *p2p)
4168 {
4169 if (p2p->go_neg_peer) {
4170 if (p2p->drv_in_listen) {
4171 p2p_dbg(p2p, "Driver is still in Listen state; wait for it to complete");
4172 return;
4173 }
4174
4175 if (p2p->go_neg_peer->connect_reqs >= 120) {
4176 p2p_warning(p2p, "Timeout on sending GO Negotiation Request without getting response");
4177 p2p_go_neg_failed(p2p, -1);
4178 return;
4179 }
4180
4181 p2p_set_state(p2p, P2P_CONNECT);
4182 p2p_connect_send(p2p, p2p->go_neg_peer);
4183 } else
4184 p2p_set_state(p2p, P2P_IDLE);
4185 }
4186
4187
4188 static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p)
4189 {
4190 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
4191
4192 if (p2p->cfg->is_concurrent_session_active &&
4193 p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx))
4194 p2p_set_timeout(p2p, 0, 500000);
4195 else
4196 p2p_set_timeout(p2p, 0, 200000);
4197 }
4198
4199
4200 static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p)
4201 {
4202 struct p2p_device *dev = p2p->go_neg_peer;
4203
4204 if (dev == NULL) {
4205 p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait");
4206 return;
4207 }
4208
4209 p2p_dbg(p2p, "Go to Listen state while waiting for the peer to become ready for GO Negotiation");
4210 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
4211 p2p->pending_listen_wait_drv = false;
4212 if (p2p->pending_listen_freq) {
4213 p2p_dbg(p2p, "Clear pending_listen_freq for %s", __func__);
4214 p2p->pending_listen_freq = 0;
4215 }
4216 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);
4217 p2p_listen_in_find(p2p, 0);
4218 }
4219
4220
4221 static void p2p_timeout_sd_during_find(struct p2p_data *p2p)
4222 {
4223 p2p_dbg(p2p, "Service Discovery Query timeout");
4224 if (p2p->sd_peer) {
4225 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4226 p2p->sd_peer = NULL;
4227 }
4228 p2p_continue_find(p2p);
4229 }
4230
4231
4232 static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p)
4233 {
4234 p2p_dbg(p2p, "Provision Discovery Request timeout");
4235 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4236 p2p_continue_find(p2p);
4237 }
4238
4239
4240 static void p2p_timeout_prov_disc_req(struct p2p_data *p2p)
4241 {
4242 u32 adv_id = 0;
4243 u8 *adv_mac = NULL;
4244
4245 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4246
4247 /*
4248 * For user initiated PD requests that we have not gotten any responses
4249 * for while in IDLE state, we retry them a couple of times before
4250 * giving up.
4251 */
4252 if (!p2p->user_initiated_pd)
4253 return;
4254
4255 p2p_dbg(p2p, "User initiated Provision Discovery Request timeout");
4256
4257 if (p2p->pd_retries) {
4258 p2p->pd_retries--;
4259 p2p_retry_pd(p2p);
4260 } else {
4261 struct p2p_device *dev;
4262 int for_join = 0;
4263
4264 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
4265 if (!ether_addr_equal(p2p->pending_pd_devaddr,
4266 dev->info.p2p_device_addr))
4267 continue;
4268 if (dev->req_config_methods &&
4269 (dev->flags & P2P_DEV_PD_FOR_JOIN))
4270 for_join = 1;
4271 }
4272
4273 if (p2p->p2ps_prov) {
4274 adv_id = p2p->p2ps_prov->adv_id;
4275 adv_mac = p2p->p2ps_prov->adv_mac;
4276 }
4277
4278 if (p2p->cfg->prov_disc_fail)
4279 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,
4280 p2p->pending_pd_devaddr,
4281 for_join ?
4282 P2P_PROV_DISC_TIMEOUT_JOIN :
4283 P2P_PROV_DISC_TIMEOUT,
4284 adv_id, adv_mac, NULL);
4285 p2p_reset_pending_pd(p2p);
4286 }
4287 }
4288
4289
4290 static void p2p_timeout_invite(struct p2p_data *p2p)
4291 {
4292 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
4293 p2p_set_state(p2p, P2P_INVITE_LISTEN);
4294 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {
4295 /*
4296 * Better remain on operating channel instead of listen channel
4297 * when running a group.
4298 * Wait 120 ms to let the P2P GO to send its beacon on the
4299 * intended TBTT.
4300 */
4301 p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel");
4302 p2p_set_timeout(p2p, 0, 120000);
4303 return;
4304 }
4305 p2p_listen_in_find(p2p, 0);
4306 }
4307
4308
4309 static void p2p_timeout_invite_listen(struct p2p_data *p2p)
4310 {
4311 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {
4312 p2p_set_state(p2p, P2P_INVITE);
4313 p2p_invite_send(p2p, p2p->invite_peer,
4314 p2p->invite_go_dev_addr, p2p->invite_dev_pw_id);
4315 } else {
4316 if (p2p->invite_peer) {
4317 p2p_dbg(p2p, "Invitation Request retry limit reached");
4318 if (p2p->cfg->invitation_result)
4319 p2p->cfg->invitation_result(
4320 p2p->cfg->cb_ctx, -1, NULL, NULL,
4321 p2p->invite_peer->info.p2p_device_addr,
4322 0, 0);
4323 }
4324 #ifdef CONFIG_P2P_CHR
4325 wpa_supplicant_upload_state_before_group_formation_success(P2P_INVITATION, P2P_EVENT_REASON_INVIT_TIMEOUT);
4326 #endif
4327 p2p_set_state(p2p, P2P_IDLE);
4328 }
4329 }
4330
4331
4332 static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx)
4333 {
4334 struct p2p_data *p2p = eloop_ctx;
4335
4336 p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state));
4337
4338 p2p->in_listen = 0;
4339 if (p2p->drv_in_listen) {
4340 p2p_dbg(p2p, "Driver is still in listen state - stop it");
4341 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
4342 p2p->pending_listen_wait_drv = false;
4343 }
4344
4345 switch (p2p->state) {
4346 case P2P_IDLE:
4347 /* Check if we timed out waiting for PD req */
4348 if (p2p->pending_action_state == P2P_PENDING_PD)
4349 p2p_timeout_prov_disc_req(p2p);
4350 break;
4351 case P2P_SEARCH:
4352 /* Check if we timed out waiting for PD req */
4353 if (p2p->pending_action_state == P2P_PENDING_PD)
4354 p2p_timeout_prov_disc_req(p2p);
4355 if (p2p->search_delay && !p2p->in_search_delay) {
4356 p2p_dbg(p2p, "Delay search operation by %u ms",
4357 p2p->search_delay);
4358 p2p->in_search_delay = 1;
4359 p2p_set_timeout(p2p, p2p->search_delay / 1000,
4360 (p2p->search_delay % 1000) * 1000);
4361 break;
4362 }
4363 p2p->in_search_delay = 0;
4364 p2p_search(p2p);
4365 break;
4366 case P2P_CONNECT:
4367 p2p_timeout_connect(p2p);
4368 break;
4369 case P2P_CONNECT_LISTEN:
4370 p2p_timeout_connect_listen(p2p);
4371 break;
4372 case P2P_GO_NEG:
4373 break;
4374 case P2P_LISTEN_ONLY:
4375 /* Check if we timed out waiting for PD req */
4376 if (p2p->pending_action_state == P2P_PENDING_PD)
4377 p2p_timeout_prov_disc_req(p2p);
4378
4379 if (p2p->ext_listen_only) {
4380 p2p_dbg(p2p, "Extended Listen Timing - Listen State completed");
4381 p2p->ext_listen_only = 0;
4382 p2p_set_state(p2p, P2P_IDLE);
4383 }
4384 break;
4385 case P2P_WAIT_PEER_CONNECT:
4386 p2p_timeout_wait_peer_connect(p2p);
4387 break;
4388 case P2P_WAIT_PEER_IDLE:
4389 p2p_timeout_wait_peer_idle(p2p);
4390 break;
4391 case P2P_SD_DURING_FIND:
4392 p2p_timeout_sd_during_find(p2p);
4393 break;
4394 case P2P_PROVISIONING:
4395 break;
4396 case P2P_PD_DURING_FIND:
4397 p2p_timeout_prov_disc_during_find(p2p);
4398 break;
4399 case P2P_INVITE:
4400 p2p_timeout_invite(p2p);
4401 break;
4402 case P2P_INVITE_LISTEN:
4403 p2p_timeout_invite_listen(p2p);
4404 break;
4405 }
4406 }
4407
4408
4409 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr)
4410 {
4411 struct p2p_device *dev;
4412
4413 dev = p2p_get_device(p2p, peer_addr);
4414 p2p_dbg(p2p, "Local request to reject connection attempts by peer "
4415 MACSTR_SEC, MAC2STR_SEC(peer_addr));
4416 if (dev == NULL) {
4417 p2p_dbg(p2p, "Peer " MACSTR_SEC " unknown", MAC2STR_SEC(peer_addr));
4418 return -1;
4419 }
4420 dev->status = P2P_SC_FAIL_REJECTED_BY_USER;
4421 dev->flags |= P2P_DEV_USER_REJECTED;
4422 return 0;
4423 }
4424
4425
4426 const char * p2p_wps_method_text(enum p2p_wps_method method)
4427 {
4428 switch (method) {
4429 case WPS_NOT_READY:
4430 return "not-ready";
4431 case WPS_PIN_DISPLAY:
4432 return "Display";
4433 case WPS_PIN_KEYPAD:
4434 return "Keypad";
4435 case WPS_PBC:
4436 return "PBC";
4437 case WPS_NFC:
4438 return "NFC";
4439 case WPS_P2PS:
4440 return "P2PS";
4441 }
4442
4443 return "??";
4444 }
4445
4446
4447 static const char * p2p_go_state_text(enum p2p_go_state go_state)
4448 {
4449 switch (go_state) {
4450 case UNKNOWN_GO:
4451 return "unknown";
4452 case LOCAL_GO:
4453 return "local";
4454 case REMOTE_GO:
4455 return "remote";
4456 }
4457
4458 return "??";
4459 }
4460
4461
4462 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p,
4463 const u8 *addr, int next)
4464 {
4465 struct p2p_device *dev;
4466
4467 if (addr)
4468 dev = p2p_get_device(p2p, addr);
4469 else
4470 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4471
4472 if (dev && next) {
4473 dev = dl_list_first(&dev->list, struct p2p_device, list);
4474 if (&dev->list == &p2p->devices)
4475 dev = NULL;
4476 }
4477
4478 if (dev == NULL)
4479 return NULL;
4480
4481 return &dev->info;
4482 }
4483
4484
4485 int p2p_get_peer_info_txt(const struct p2p_peer_info *info,
4486 char *buf, size_t buflen)
4487 {
4488 struct p2p_device *dev;
4489 int res;
4490 char *pos, *end;
4491 struct os_reltime now;
4492
4493 if (info == NULL)
4494 return -1;
4495
4496 dev = (struct p2p_device *) (((u8 *) info) -
4497 offsetof(struct p2p_device, info));
4498
4499 pos = buf;
4500 end = buf + buflen;
4501
4502 os_get_reltime(&now);
4503 res = os_snprintf(pos, end - pos,
4504 "age=%d\n"
4505 "listen_freq=%d\n"
4506 "wps_method=%s\n"
4507 "interface_addr=" MACSTR "\n"
4508 "member_in_go_dev=" MACSTR "\n"
4509 "member_in_go_iface=" MACSTR "\n"
4510 "go_neg_req_sent=%d\n"
4511 "go_state=%s\n"
4512 "dialog_token=%u\n"
4513 "intended_addr=" MACSTR "\n"
4514 "country=%c%c\n"
4515 "oper_freq=%d\n"
4516 "req_config_methods=0x%x\n"
4517 "flags=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n"
4518 "status=%d\n"
4519 "invitation_reqs=%u\n",
4520 (int) (now.sec - dev->last_seen.sec),
4521 dev->listen_freq,
4522 p2p_wps_method_text(dev->wps_method),
4523 MAC2STR(dev->interface_addr),
4524 MAC2STR(dev->member_in_go_dev),
4525 MAC2STR(dev->member_in_go_iface),
4526 dev->go_neg_req_sent,
4527 p2p_go_state_text(dev->go_state),
4528 dev->dialog_token,
4529 MAC2STR(dev->intended_addr),
4530 dev->country[0] ? dev->country[0] : '_',
4531 dev->country[1] ? dev->country[1] : '_',
4532 dev->oper_freq,
4533 dev->req_config_methods,
4534 dev->flags & P2P_DEV_PROBE_REQ_ONLY ?
4535 "[PROBE_REQ_ONLY]" : "",
4536 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "",
4537 dev->flags & P2P_DEV_NOT_YET_READY ?
4538 "[NOT_YET_READY]" : "",
4539 dev->flags & P2P_DEV_PD_PEER_DISPLAY ?
4540 "[PD_PEER_DISPLAY]" : "",
4541 dev->flags & P2P_DEV_PD_PEER_KEYPAD ?
4542 "[PD_PEER_KEYPAD]" : "",
4543 dev->flags & P2P_DEV_PD_PEER_P2PS ?
4544 "[PD_PEER_P2PS]" : "",
4545 dev->flags & P2P_DEV_USER_REJECTED ?
4546 "[USER_REJECTED]" : "",
4547 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ?
4548 "[PEER_WAITING_RESPONSE]" : "",
4549 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ?
4550 "[PREFER_PERSISTENT_GROUP]" : "",
4551 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ?
4552 "[WAIT_GO_NEG_RESPONSE]" : "",
4553 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ?
4554 "[WAIT_GO_NEG_CONFIRM]" : "",
4555 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ?
4556 "[GROUP_CLIENT_ONLY]" : "",
4557 dev->flags & P2P_DEV_FORCE_FREQ ?
4558 "[FORCE_FREQ]" : "",
4559 dev->flags & P2P_DEV_PD_FOR_JOIN ?
4560 "[PD_FOR_JOIN]" : "",
4561 dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT ?
4562 "[LAST_SEEN_AS_GROUP_CLIENT]" : "",
4563 dev->status,
4564 dev->invitation_reqs);
4565 if (os_snprintf_error(end - pos, res))
4566 return pos - buf;
4567 pos += res;
4568
4569 if (dev->ext_listen_period) {
4570 res = os_snprintf(pos, end - pos,
4571 "ext_listen_period=%u\n"
4572 "ext_listen_interval=%u\n",
4573 dev->ext_listen_period,
4574 dev->ext_listen_interval);
4575 if (os_snprintf_error(end - pos, res))
4576 return pos - buf;
4577 pos += res;
4578 }
4579
4580 if (dev->oper_ssid_len) {
4581 res = os_snprintf(pos, end - pos,
4582 "oper_ssid=%s\n",
4583 wpa_ssid_txt(dev->oper_ssid,
4584 dev->oper_ssid_len));
4585 if (os_snprintf_error(end - pos, res))
4586 return pos - buf;
4587 pos += res;
4588 }
4589
4590 #ifdef CONFIG_WIFI_DISPLAY
4591 if (dev->info.wfd_subelems) {
4592 res = os_snprintf(pos, end - pos, "wfd_subelems=");
4593 if (os_snprintf_error(end - pos, res))
4594 return pos - buf;
4595 pos += res;
4596
4597 pos += wpa_snprintf_hex(pos, end - pos,
4598 wpabuf_head(dev->info.wfd_subelems),
4599 wpabuf_len(dev->info.wfd_subelems));
4600
4601 res = os_snprintf(pos, end - pos, "\n");
4602 if (os_snprintf_error(end - pos, res))
4603 return pos - buf;
4604 pos += res;
4605 }
4606 #endif /* CONFIG_WIFI_DISPLAY */
4607
4608 return pos - buf;
4609 }
4610
4611
4612 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr)
4613 {
4614 return p2p_get_device(p2p, addr) != NULL;
4615 }
4616
4617
4618 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled)
4619 {
4620 if (enabled) {
4621 p2p_dbg(p2p, "Client discoverability enabled");
4622 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
4623 } else {
4624 p2p_dbg(p2p, "Client discoverability disabled");
4625 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
4626 }
4627 }
4628
4629
4630 static struct wpabuf * p2p_build_presence_req(u32 duration1, u32 interval1,
4631 u32 duration2, u32 interval2)
4632 {
4633 struct wpabuf *req;
4634 struct p2p_noa_desc desc1, desc2, *ptr1 = NULL, *ptr2 = NULL;
4635 u8 *len;
4636
4637 req = wpabuf_alloc(100);
4638 if (req == NULL)
4639 return NULL;
4640
4641 if (duration1 || interval1) {
4642 os_memset(&desc1, 0, sizeof(desc1));
4643 desc1.count_type = 1;
4644 desc1.duration = duration1;
4645 desc1.interval = interval1;
4646 ptr1 = &desc1;
4647
4648 if (duration2 || interval2) {
4649 os_memset(&desc2, 0, sizeof(desc2));
4650 desc2.count_type = 2;
4651 desc2.duration = duration2;
4652 desc2.interval = interval2;
4653 ptr2 = &desc2;
4654 }
4655 }
4656
4657 p2p_buf_add_action_hdr(req, P2P_PRESENCE_REQ, 1);
4658 len = p2p_buf_add_ie_hdr(req);
4659 p2p_buf_add_noa(req, 0, 0, 0, ptr1, ptr2);
4660 p2p_buf_update_ie_hdr(req, len);
4661
4662 return req;
4663 }
4664
4665
4666 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,
4667 const u8 *own_interface_addr, unsigned int freq,
4668 u32 duration1, u32 interval1, u32 duration2,
4669 u32 interval2)
4670 {
4671 struct wpabuf *req;
4672
4673 p2p_dbg(p2p, "Send Presence Request to GO " MACSTR_SEC
4674 " (own interface " MACSTR_SEC ") freq=%u dur1=%u int1=%u "
4675 "dur2=%u int2=%u",
4676 MAC2STR_SEC(go_interface_addr), MAC2STR_SEC(own_interface_addr),
4677 freq, duration1, interval1, duration2, interval2);
4678
4679 req = p2p_build_presence_req(duration1, interval1, duration2,
4680 interval2);
4681 if (req == NULL)
4682 return -1;
4683
4684 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4685 if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr,
4686 go_interface_addr,
4687 wpabuf_head(req), wpabuf_len(req), 200) < 0) {
4688 p2p_dbg(p2p, "Failed to send Action frame");
4689 }
4690 wpabuf_free(req);
4691
4692 return 0;
4693 }
4694
4695
4696 static struct wpabuf * p2p_build_presence_resp(u8 status, const u8 *noa,
4697 size_t noa_len, u8 dialog_token)
4698 {
4699 struct wpabuf *resp;
4700 u8 *len;
4701
4702 resp = wpabuf_alloc(100 + noa_len);
4703 if (resp == NULL)
4704 return NULL;
4705
4706 p2p_buf_add_action_hdr(resp, P2P_PRESENCE_RESP, dialog_token);
4707 len = p2p_buf_add_ie_hdr(resp);
4708 p2p_buf_add_status(resp, status);
4709 if (noa) {
4710 wpabuf_put_u8(resp, P2P_ATTR_NOTICE_OF_ABSENCE);
4711 wpabuf_put_le16(resp, noa_len);
4712 wpabuf_put_data(resp, noa, noa_len);
4713 } else
4714 p2p_buf_add_noa(resp, 0, 0, 0, NULL, NULL);
4715 p2p_buf_update_ie_hdr(resp, len);
4716
4717 return resp;
4718 }
4719
4720
4721 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
4722 const u8 *sa, const u8 *data, size_t len,
4723 int rx_freq)
4724 {
4725 struct p2p_message msg;
4726 u8 status;
4727 struct wpabuf *resp;
4728 size_t g;
4729 struct p2p_group *group = NULL;
4730 int parsed = 0;
4731 u8 noa[50];
4732 int noa_len;
4733
4734 p2p_dbg(p2p, "Received P2P Action - P2P Presence Request");
4735
4736 for (g = 0; g < p2p->num_groups; g++) {
4737 if (ether_addr_equal(
4738 da, p2p_group_get_interface_addr(p2p->groups[g]))) {
4739 group = p2p->groups[g];
4740 break;
4741 }
4742 }
4743 if (group == NULL) {
4744 p2p_dbg(p2p, "Ignore P2P Presence Request for unknown group "
4745 MACSTR_SEC, MAC2STR_SEC(da));
4746 return;
4747 }
4748
4749 if (p2p_parse(data, len, &msg) < 0) {
4750 p2p_dbg(p2p, "Failed to parse P2P Presence Request");
4751 status = P2P_SC_FAIL_INVALID_PARAMS;
4752 goto fail;
4753 }
4754 parsed = 1;
4755
4756 if (msg.noa == NULL) {
4757 p2p_dbg(p2p, "No NoA attribute in P2P Presence Request");
4758 status = P2P_SC_FAIL_INVALID_PARAMS;
4759 goto fail;
4760 }
4761
4762 status = p2p_group_presence_req(group, sa, msg.noa, msg.noa_len);
4763
4764 fail:
4765 if (p2p->cfg->get_noa)
4766 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,
4767 sizeof(noa));
4768 else
4769 noa_len = -1;
4770 resp = p2p_build_presence_resp(status, noa_len > 0 ? noa : NULL,
4771 noa_len > 0 ? noa_len : 0,
4772 msg.dialog_token);
4773 if (parsed)
4774 p2p_parse_free(&msg);
4775 if (resp == NULL)
4776 return;
4777
4778 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
4779 if (p2p_send_action(p2p, rx_freq, sa, da, da,
4780 wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
4781 p2p_dbg(p2p, "Failed to send Action frame");
4782 }
4783 wpabuf_free(resp);
4784 }
4785
4786
4787 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
4788 const u8 *sa, const u8 *data, size_t len)
4789 {
4790 struct p2p_message msg;
4791
4792 p2p_dbg(p2p, "Received P2P Action - P2P Presence Response");
4793
4794 if (p2p_parse(data, len, &msg) < 0) {
4795 p2p_dbg(p2p, "Failed to parse P2P Presence Response");
4796 return;
4797 }
4798
4799 if (msg.status == NULL || msg.noa == NULL) {
4800 p2p_dbg(p2p, "No Status or NoA attribute in P2P Presence Response");
4801 p2p_parse_free(&msg);
4802 return;
4803 }
4804
4805 if (p2p->cfg->presence_resp) {
4806 p2p->cfg->presence_resp(p2p->cfg->cb_ctx, sa, *msg.status,
4807 msg.noa, msg.noa_len);
4808 }
4809
4810 if (*msg.status) {
4811 p2p_dbg(p2p, "P2P Presence Request was rejected: status %u",
4812 *msg.status);
4813 p2p_parse_free(&msg);
4814 return;
4815 }
4816
4817 p2p_dbg(p2p, "P2P Presence Request was accepted");
4818 wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA",
4819 msg.noa, msg.noa_len);
4820 /* TODO: process NoA */
4821 p2p_parse_free(&msg);
4822 }
4823
4824 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
4825 void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx)
4826 #else
4827 static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx)
4828 #endif
4829 {
4830 struct p2p_data *p2p = eloop_ctx;
4831
4832 if (p2p->ext_listen_interval) {
4833 /* Schedule next extended listen timeout */
4834
4835 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
4836 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
4837 #endif
4838 eloop_register_timeout(p2p->ext_listen_interval_sec,
4839 p2p->ext_listen_interval_usec,
4840 p2p_ext_listen_timeout, p2p, NULL);
4841 }
4842
4843 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
4844 /*
4845 * This should not really happen, but it looks like the Listen
4846 * command may fail is something else (e.g., a scan) was
4847 * running at an inconvenient time. As a workaround, allow new
4848 * Extended Listen operation to be started.
4849 */
4850 p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again");
4851 p2p->ext_listen_only = 0;
4852 p2p_set_state(p2p, P2P_IDLE);
4853 }
4854
4855 if ((p2p->cfg->is_p2p_in_progress &&
4856 p2p->cfg->is_p2p_in_progress(p2p->cfg->cb_ctx)) ||
4857 (p2p->pending_action_state == P2P_PENDING_PD &&
4858 p2p->pd_retries > 0)) {
4859 p2p_dbg(p2p, "Operation in progress - skip Extended Listen timeout (%s)",
4860 p2p_state_txt(p2p->state));
4861 return;
4862 }
4863
4864 if (p2p->state != P2P_IDLE) {
4865 p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state));
4866 return;
4867 }
4868
4869 p2p_dbg(p2p, "Extended Listen timeout");
4870 p2p->ext_listen_only = 1;
4871 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {
4872 p2p_dbg(p2p, "Failed to start Listen state for Extended Listen Timing");
4873 p2p->ext_listen_only = 0;
4874 }
4875 }
4876
4877
4878 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,
4879 unsigned int interval)
4880 {
4881 if (period > 65535 || interval > 65535 || period > interval ||
4882 (period == 0 && interval > 0) || (period > 0 && interval == 0)) {
4883 p2p_dbg(p2p, "Invalid Extended Listen Timing request: period=%u interval=%u",
4884 period, interval);
4885 return -1;
4886 }
4887
4888 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
4889
4890 if (interval == 0) {
4891 p2p_dbg(p2p, "Disabling Extended Listen Timing");
4892
4893 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
4894 p2p->enable_ext_listen = FALSE;
4895 #endif
4896 p2p->ext_listen_period = 0;
4897 p2p->ext_listen_interval = 0;
4898 return 0;
4899 }
4900
4901 p2p_dbg(p2p, "Enabling Extended Listen Timing: period %u msec, interval %u msec",
4902 period, interval);
4903
4904 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
4905 p2p->enable_ext_listen = TRUE;
4906 p2p->on_op_channel_listen = FALSE;
4907 p2p->cfg->channel = p2p->original_listen_channel;
4908 p2p->cfg->reg_class = p2p->original_reg_class;
4909 #endif
4910 p2p->ext_listen_period = period;
4911 p2p->ext_listen_interval = interval;
4912 p2p->ext_listen_interval_sec = interval / 1000;
4913 p2p->ext_listen_interval_usec = (interval % 1000) * 1000;
4914
4915 eloop_register_timeout(p2p->ext_listen_interval_sec,
4916 p2p->ext_listen_interval_usec,
4917 p2p_ext_listen_timeout, p2p, NULL);
4918
4919 return 0;
4920 }
4921
4922
4923 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
4924 const u8 *ie, size_t ie_len)
4925 {
4926 struct p2p_message msg;
4927
4928 if (bssid == NULL || ie == NULL)
4929 return;
4930
4931 os_memset(&msg, 0, sizeof(msg));
4932 if (p2p_parse_ies(ie, ie_len, &msg))
4933 return;
4934 if (msg.minor_reason_code == NULL) {
4935 p2p_parse_free(&msg);
4936 return;
4937 }
4938
4939 p2p_dbg(p2p, "Deauthentication notification BSSID " MACSTR_SEC
4940 " reason_code=%u minor_reason_code=%u",
4941 MAC2STR_SEC(bssid), reason_code, *msg.minor_reason_code);
4942
4943 p2p_parse_free(&msg);
4944 }
4945
4946
4947 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
4948 const u8 *ie, size_t ie_len)
4949 {
4950 struct p2p_message msg;
4951
4952 if (bssid == NULL || ie == NULL)
4953 return;
4954
4955 os_memset(&msg, 0, sizeof(msg));
4956 if (p2p_parse_ies(ie, ie_len, &msg))
4957 return;
4958 if (msg.minor_reason_code == NULL) {
4959 p2p_parse_free(&msg);
4960 return;
4961 }
4962
4963 p2p_dbg(p2p, "Disassociation notification BSSID " MACSTR_SEC
4964 " reason_code=%u minor_reason_code=%u",
4965 MAC2STR_SEC(bssid), reason_code, *msg.minor_reason_code);
4966
4967 p2p_parse_free(&msg);
4968 }
4969
4970
4971 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled)
4972 {
4973 if (enabled) {
4974 p2p_dbg(p2p, "Managed P2P Device operations enabled");
4975 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;
4976 } else {
4977 p2p_dbg(p2p, "Managed P2P Device operations disabled");
4978 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;
4979 }
4980 }
4981
4982
4983 int p2p_config_get_random_social(struct p2p_config *p2p, u8 *op_class,
4984 u8 *op_channel,
4985 struct wpa_freq_range_list *avoid_list,
4986 struct wpa_freq_range_list *disallow_list)
4987 {
4988 return p2p_channel_random_social(&p2p->channels, op_class, op_channel,
4989 avoid_list, disallow_list);
4990 }
4991
4992
4993 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel,
4994 u8 forced)
4995 {
4996 if (p2p_channel_to_freq(reg_class, channel) < 0)
4997 return -1;
4998
4999 /*
5000 * Listen channel was set in configuration or set by control interface;
5001 * cannot override it.
5002 */
5003 if (p2p->cfg->channel_forced && forced == 0) {
5004 p2p_dbg(p2p,
5005 "Listen channel was previously configured - do not override based on optimization");
5006 return -1;
5007 }
5008
5009 p2p_dbg(p2p, "Set Listen channel: reg_class %u channel %u",
5010 reg_class, channel);
5011
5012 if (p2p->state == P2P_IDLE) {
5013 p2p->cfg->reg_class = reg_class;
5014 p2p->cfg->channel = channel;
5015 p2p->cfg->channel_forced = forced;
5016 } else {
5017 p2p_dbg(p2p, "Defer setting listen channel");
5018 p2p->pending_reg_class = reg_class;
5019 p2p->pending_channel = channel;
5020 p2p->pending_channel_forced = forced;
5021 }
5022
5023 #if defined(CONFIG_OPEN_HARMONY_PATCH) && defined(OPEN_HARMONY_MIRACAST_SINK_OPT)
5024 p2p->original_listen_channel = channel;
5025 p2p->original_reg_class = reg_class;
5026 #endif
5027 return 0;
5028 }
5029
5030
5031 u8 p2p_get_listen_channel(struct p2p_data *p2p)
5032 {
5033 return p2p->cfg->channel;
5034 }
5035
5036
5037 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len)
5038 {
5039 p2p_dbg(p2p, "New SSID postfix: %s", anonymize_ssid(wpa_ssid_txt(postfix, len)));
5040 if (postfix == NULL) {
5041 p2p->cfg->ssid_postfix_len = 0;
5042 return 0;
5043 }
5044 if (len > sizeof(p2p->cfg->ssid_postfix))
5045 return -1;
5046 os_memcpy(p2p->cfg->ssid_postfix, postfix, len);
5047 p2p->cfg->ssid_postfix_len = len;
5048 return 0;
5049 }
5050
5051
5052 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel,
5053 int cfg_op_channel)
5054 {
5055 if (p2p_channel_to_freq(op_reg_class, op_channel) < 0)
5056 return -1;
5057
5058 p2p_dbg(p2p, "Set Operating channel: reg_class %u channel %u",
5059 op_reg_class, op_channel);
5060 p2p->cfg->op_reg_class = op_reg_class;
5061 p2p->cfg->op_channel = op_channel;
5062 p2p->cfg->cfg_op_channel = cfg_op_channel;
5063 return 0;
5064 }
5065
5066
5067 int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan,
5068 const struct p2p_channel *pref_chan)
5069 {
5070 struct p2p_channel *n;
5071
5072 if (pref_chan) {
5073 n = os_memdup(pref_chan,
5074 num_pref_chan * sizeof(struct p2p_channel));
5075 if (n == NULL)
5076 return -1;
5077 } else
5078 n = NULL;
5079
5080 os_free(p2p->cfg->pref_chan);
5081 p2p->cfg->pref_chan = n;
5082 p2p->cfg->num_pref_chan = num_pref_chan;
5083
5084 return 0;
5085 }
5086
5087
5088 int p2p_set_no_go_freq(struct p2p_data *p2p,
5089 const struct wpa_freq_range_list *list)
5090 {
5091 struct wpa_freq_range *tmp;
5092
5093 if (list == NULL || list->num == 0) {
5094 os_free(p2p->no_go_freq.range);
5095 p2p->no_go_freq.range = NULL;
5096 p2p->no_go_freq.num = 0;
5097 return 0;
5098 }
5099
5100 tmp = os_calloc(list->num, sizeof(struct wpa_freq_range));
5101 if (tmp == NULL)
5102 return -1;
5103 os_memcpy(tmp, list->range, list->num * sizeof(struct wpa_freq_range));
5104 os_free(p2p->no_go_freq.range);
5105 p2p->no_go_freq.range = tmp;
5106 p2p->no_go_freq.num = list->num;
5107 p2p_dbg(p2p, "Updated no GO chan list");
5108
5109 return 0;
5110 }
5111
5112
5113 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,
5114 u8 *iface_addr)
5115 {
5116 struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
5117 if (dev == NULL || is_zero_ether_addr(dev->interface_addr))
5118 return -1;
5119 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN);
5120 return 0;
5121 }
5122
5123
5124 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,
5125 u8 *dev_addr)
5126 {
5127 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
5128 if (dev == NULL)
5129 return -1;
5130 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
5131 return 0;
5132 }
5133
5134
5135 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr)
5136 {
5137 os_memcpy(p2p->peer_filter, addr, ETH_ALEN);
5138 if (is_zero_ether_addr(p2p->peer_filter))
5139 p2p_dbg(p2p, "Disable peer filter");
5140 else
5141 p2p_dbg(p2p, "Enable peer filter for " MACSTR_SEC,
5142 MAC2STR_SEC(p2p->peer_filter));
5143 }
5144
5145
5146 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled)
5147 {
5148 p2p_dbg(p2p, "Cross connection %s", enabled ? "enabled" : "disabled");
5149 if (p2p->cross_connect == enabled)
5150 return;
5151 p2p->cross_connect = enabled;
5152 /* TODO: may need to tear down any action group where we are GO(?) */
5153 }
5154
5155
5156 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr)
5157 {
5158 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
5159 if (dev == NULL)
5160 return -1;
5161 if (dev->oper_freq <= 0)
5162 return -1;
5163 return dev->oper_freq;
5164 }
5165
5166
5167 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled)
5168 {
5169 p2p_dbg(p2p, "Intra BSS distribution %s",
5170 enabled ? "enabled" : "disabled");
5171 p2p->cfg->p2p_intra_bss = enabled;
5172 }
5173
5174
5175 void p2p_update_channel_list(struct p2p_data *p2p,
5176 const struct p2p_channels *chan,
5177 const struct p2p_channels *cli_chan)
5178 {
5179 p2p_dbg(p2p, "Update channel list");
5180 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));
5181 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels);
5182 os_memcpy(&p2p->cfg->cli_channels, cli_chan,
5183 sizeof(struct p2p_channels));
5184 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels);
5185 }
5186
5187
5188 int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
5189 const u8 *src, const u8 *bssid, const u8 *buf,
5190 size_t len, unsigned int wait_time)
5191 {
5192 int res, scheduled;
5193
5194 res = p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,
5195 buf, len, wait_time, &scheduled);
5196 #ifndef OPEN_HARMONY_MIRACAST_SINK_OPT
5197 if (res == 0 && scheduled && p2p->in_listen && freq > 0 &&
5198 p2p->drv_in_listen > 0 &&
5199 (unsigned int) p2p->drv_in_listen != freq) {
5200 p2p_dbg(p2p,
5201 "Stop listen on %d MHz to allow a frame to be sent immediately on %d MHz",
5202 p2p->drv_in_listen, freq);
5203 p2p_stop_listen_for_freq(p2p, freq);
5204 }
5205 #endif
5206 return res;
5207 }
5208
5209
5210 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5,
5211 int freq_overall)
5212 {
5213 p2p_dbg(p2p, "Best channel: 2.4 GHz: %d, 5 GHz: %d, overall: %d",
5214 freq_24, freq_5, freq_overall);
5215 p2p->best_freq_24 = freq_24;
5216 p2p->best_freq_5 = freq_5;
5217 p2p->best_freq_overall = freq_overall;
5218 }
5219
5220
5221 void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq)
5222 {
5223 p2p_dbg(p2p, "Own frequency preference: %d MHz", freq);
5224 p2p->own_freq_preference = freq;
5225 }
5226
5227
5228 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p)
5229 {
5230 if (p2p == NULL || p2p->go_neg_peer == NULL)
5231 return NULL;
5232 return p2p->go_neg_peer->info.p2p_device_addr;
5233 }
5234
5235
5236 const struct p2p_peer_info *
5237 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next)
5238 {
5239 struct p2p_device *dev;
5240
5241 if (addr) {
5242 dev = p2p_get_device(p2p, addr);
5243 if (!dev)
5244 return NULL;
5245
5246 if (!next) {
5247 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
5248 return NULL;
5249
5250 return &dev->info;
5251 } else {
5252 do {
5253 dev = dl_list_first(&dev->list,
5254 struct p2p_device,
5255 list);
5256 if (!dev || &dev->list == &p2p->devices)
5257 return NULL;
5258 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY);
5259 }
5260 } else {
5261 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
5262 if (!dev)
5263 return NULL;
5264 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
5265 dev = dl_list_first(&dev->list,
5266 struct p2p_device,
5267 list);
5268 if (!dev || &dev->list == &p2p->devices)
5269 return NULL;
5270 }
5271 }
5272
5273 return &dev->info;
5274 }
5275
5276
5277 int p2p_in_progress(struct p2p_data *p2p)
5278 {
5279 if (p2p == NULL)
5280 return 0;
5281 if (p2p->state == P2P_SEARCH)
5282 return 2;
5283 return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING;
5284 }
5285
5286
5287 void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout,
5288 u8 client_timeout)
5289 {
5290 if (p2p) {
5291 p2p->go_timeout = go_timeout;
5292 p2p->client_timeout = client_timeout;
5293 }
5294 }
5295
5296
5297 #ifdef CONFIG_WIFI_DISPLAY
5298
5299 static void p2p_update_wfd_ie_groups(struct p2p_data *p2p)
5300 {
5301 size_t g;
5302 struct p2p_group *group;
5303
5304 for (g = 0; g < p2p->num_groups; g++) {
5305 group = p2p->groups[g];
5306 p2p_group_force_beacon_update_ies(group);
5307 }
5308 }
5309
5310
5311 int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie)
5312 {
5313 wpabuf_free(p2p->wfd_ie_beacon);
5314 p2p->wfd_ie_beacon = ie;
5315 p2p_update_wfd_ie_groups(p2p);
5316 return 0;
5317 }
5318
5319
5320 int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie)
5321 {
5322 wpabuf_free(p2p->wfd_ie_probe_req);
5323 p2p->wfd_ie_probe_req = ie;
5324 return 0;
5325 }
5326
5327
5328 int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie)
5329 {
5330 wpabuf_free(p2p->wfd_ie_probe_resp);
5331 p2p->wfd_ie_probe_resp = ie;
5332 p2p_update_wfd_ie_groups(p2p);
5333 return 0;
5334 }
5335
5336
5337 int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie)
5338 {
5339 wpabuf_free(p2p->wfd_ie_assoc_req);
5340 p2p->wfd_ie_assoc_req = ie;
5341 return 0;
5342 }
5343
5344
5345 int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie)
5346 {
5347 wpabuf_free(p2p->wfd_ie_invitation);
5348 p2p->wfd_ie_invitation = ie;
5349 return 0;
5350 }
5351
5352
5353 int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie)
5354 {
5355 wpabuf_free(p2p->wfd_ie_prov_disc_req);
5356 p2p->wfd_ie_prov_disc_req = ie;
5357 return 0;
5358 }
5359
5360
5361 int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie)
5362 {
5363 wpabuf_free(p2p->wfd_ie_prov_disc_resp);
5364 p2p->wfd_ie_prov_disc_resp = ie;
5365 return 0;
5366 }
5367
5368
5369 int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie)
5370 {
5371 wpabuf_free(p2p->wfd_ie_go_neg);
5372 p2p->wfd_ie_go_neg = ie;
5373 return 0;
5374 }
5375
5376
5377 int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)
5378 {
5379 wpabuf_free(p2p->wfd_dev_info);
5380 if (elem) {
5381 p2p->wfd_dev_info = wpabuf_dup(elem);
5382 if (p2p->wfd_dev_info == NULL)
5383 return -1;
5384 } else
5385 p2p->wfd_dev_info = NULL;
5386
5387 return 0;
5388 }
5389
5390
5391 int p2p_set_wfd_r2_dev_info(struct p2p_data *p2p, const struct wpabuf *elem)
5392 {
5393 wpabuf_free(p2p->wfd_r2_dev_info);
5394 if (elem) {
5395 p2p->wfd_r2_dev_info = wpabuf_dup(elem);
5396 if (p2p->wfd_r2_dev_info == NULL)
5397 return -1;
5398 } else
5399 p2p->wfd_r2_dev_info = NULL;
5400
5401 return 0;
5402 }
5403
5404
5405 int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem)
5406 {
5407 wpabuf_free(p2p->wfd_assoc_bssid);
5408 if (elem) {
5409 p2p->wfd_assoc_bssid = wpabuf_dup(elem);
5410 if (p2p->wfd_assoc_bssid == NULL)
5411 return -1;
5412 } else
5413 p2p->wfd_assoc_bssid = NULL;
5414
5415 return 0;
5416 }
5417
5418
5419 int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p,
5420 const struct wpabuf *elem)
5421 {
5422 wpabuf_free(p2p->wfd_coupled_sink_info);
5423 if (elem) {
5424 p2p->wfd_coupled_sink_info = wpabuf_dup(elem);
5425 if (p2p->wfd_coupled_sink_info == NULL)
5426 return -1;
5427 } else
5428 p2p->wfd_coupled_sink_info = NULL;
5429
5430 return 0;
5431 }
5432
5433 #endif /* CONFIG_WIFI_DISPLAY */
5434
5435
5436 int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int,
5437 int max_disc_tu)
5438 {
5439 if (min_disc_int > max_disc_int || min_disc_int < 0 || max_disc_int < 0)
5440 return -1;
5441
5442 p2p->min_disc_int = min_disc_int;
5443 p2p->max_disc_int = max_disc_int;
5444 p2p->max_disc_tu = max_disc_tu;
5445 p2p_dbg(p2p, "Set discoverable interval: min=%d max=%d max_tu=%d",
5446 min_disc_int, max_disc_int, max_disc_tu);
5447
5448 return 0;
5449 }
5450
5451
5452 void p2p_dbg(struct p2p_data *p2p, const char *fmt, ...)
5453 {
5454 va_list ap;
5455 char buf[500];
5456
5457 if (!p2p->cfg->debug_print)
5458 return;
5459
5460 va_start(ap, fmt);
5461 vsnprintf(buf, sizeof(buf), fmt, ap);
5462 buf[sizeof(buf) - 1] = '\0';
5463 va_end(ap);
5464 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf);
5465 }
5466
5467
5468 void p2p_info(struct p2p_data *p2p, const char *fmt, ...)
5469 {
5470 va_list ap;
5471 char buf[500];
5472
5473 if (!p2p->cfg->debug_print)
5474 return;
5475
5476 va_start(ap, fmt);
5477 vsnprintf(buf, sizeof(buf), fmt, ap);
5478 buf[sizeof(buf) - 1] = '\0';
5479 va_end(ap);
5480 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf);
5481 }
5482
5483
5484 void p2p_err(struct p2p_data *p2p, const char *fmt, ...)
5485 {
5486 va_list ap;
5487 char buf[500];
5488
5489 if (!p2p->cfg->debug_print)
5490 return;
5491
5492 va_start(ap, fmt);
5493 vsnprintf(buf, sizeof(buf), fmt, ap);
5494 buf[sizeof(buf) - 1] = '\0';
5495 va_end(ap);
5496 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf);
5497 }
5498
5499 void p2p_warning(struct p2p_data *p2p, const char *fmt, ...)
5500 {
5501 va_list ap;
5502 char buf[500];
5503
5504 if (!p2p->cfg->debug_print)
5505 return;
5506
5507 va_start(ap, fmt);
5508 vsnprintf(buf, sizeof(buf), fmt, ap);
5509 buf[sizeof(buf) - 1] = '\0';
5510 va_end(ap);
5511 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_WARNING, buf);
5512 }
5513
5514 void p2p_loop_on_known_peers(struct p2p_data *p2p,
5515 void (*peer_callback)(struct p2p_peer_info *peer,
5516 void *user_data),
5517 void *user_data)
5518 {
5519 struct p2p_device *dev, *n;
5520
5521 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
5522 peer_callback(&dev->info, user_data);
5523 }
5524 }
5525
5526
5527 #ifdef CONFIG_WPS_NFC
5528
5529 static struct wpabuf * p2p_build_nfc_handover(struct p2p_data *p2p,
5530 int client_freq,
5531 const u8 *go_dev_addr,
5532 const u8 *ssid, size_t ssid_len)
5533 {
5534 struct wpabuf *buf;
5535 u8 op_class, channel;
5536 enum p2p_role_indication role = P2P_DEVICE_NOT_IN_GROUP;
5537
5538 buf = wpabuf_alloc(1000);
5539 if (buf == NULL)
5540 return NULL;
5541
5542 op_class = p2p->cfg->reg_class;
5543 channel = p2p->cfg->channel;
5544
5545 p2p_buf_add_capability(buf, p2p->dev_capab &
5546 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0);
5547 p2p_buf_add_device_info(buf, p2p, NULL);
5548
5549 if (p2p->num_groups > 0) {
5550 int freq = p2p_group_get_freq(p2p->groups[0]);
5551 role = P2P_GO_IN_A_GROUP;
5552 if (p2p_freq_to_channel(freq, &op_class, &channel) < 0) {
5553 p2p_dbg(p2p,
5554 "Unknown GO operating frequency %d MHz for NFC handover",
5555 freq);
5556 wpabuf_free(buf);
5557 return NULL;
5558 }
5559 } else if (client_freq > 0) {
5560 role = P2P_CLIENT_IN_A_GROUP;
5561 if (p2p_freq_to_channel(client_freq, &op_class, &channel) < 0) {
5562 p2p_dbg(p2p,
5563 "Unknown client operating frequency %d MHz for NFC handover",
5564 client_freq);
5565 wpabuf_free(buf);
5566 return NULL;
5567 }
5568 }
5569
5570 p2p_buf_add_oob_go_neg_channel(buf, p2p->cfg->country, op_class,
5571 channel, role);
5572
5573 if (p2p->num_groups > 0) {
5574 /* Limit number of clients to avoid very long message */
5575 p2p_buf_add_group_info(p2p->groups[0], buf, 5);
5576 p2p_group_buf_add_id(p2p->groups[0], buf);
5577 } else if (client_freq > 0 &&
5578 go_dev_addr && !is_zero_ether_addr(go_dev_addr) &&
5579 ssid && ssid_len > 0) {
5580 /*
5581 * Add the optional P2P Group ID to indicate in which group this
5582 * device is a P2P Client.
5583 */
5584 p2p_buf_add_group_id(buf, go_dev_addr, ssid, ssid_len);
5585 }
5586
5587 return buf;
5588 }
5589
5590
5591 struct wpabuf * p2p_build_nfc_handover_req(struct p2p_data *p2p,
5592 int client_freq,
5593 const u8 *go_dev_addr,
5594 const u8 *ssid, size_t ssid_len)
5595 {
5596 return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid,
5597 ssid_len);
5598 }
5599
5600
5601 struct wpabuf * p2p_build_nfc_handover_sel(struct p2p_data *p2p,
5602 int client_freq,
5603 const u8 *go_dev_addr,
5604 const u8 *ssid, size_t ssid_len)
5605 {
5606 return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid,
5607 ssid_len);
5608 }
5609
5610
5611 int p2p_process_nfc_connection_handover(struct p2p_data *p2p,
5612 struct p2p_nfc_params *params)
5613 {
5614 struct p2p_message msg;
5615 struct p2p_device *dev;
5616 const u8 *p2p_dev_addr;
5617 int freq;
5618 enum p2p_role_indication role;
5619
5620 params->next_step = NO_ACTION;
5621
5622 if (p2p_parse_ies_separate(params->wsc_attr, params->wsc_len,
5623 params->p2p_attr, params->p2p_len, &msg)) {
5624 p2p_dbg(p2p, "Failed to parse WSC/P2P attributes from NFC");
5625 p2p_parse_free(&msg);
5626 return -1;
5627 }
5628
5629 if (msg.p2p_device_addr)
5630 p2p_dev_addr = msg.p2p_device_addr;
5631 else if (msg.device_id)
5632 p2p_dev_addr = msg.device_id;
5633 else {
5634 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id");
5635 p2p_parse_free(&msg);
5636 return -1;
5637 }
5638
5639 if (msg.oob_dev_password) {
5640 os_memcpy(params->oob_dev_pw, msg.oob_dev_password,
5641 msg.oob_dev_password_len);
5642 params->oob_dev_pw_len = msg.oob_dev_password_len;
5643 }
5644
5645 dev = p2p_create_device(p2p, p2p_dev_addr);
5646 if (dev == NULL) {
5647 p2p_parse_free(&msg);
5648 return -1;
5649 }
5650
5651 params->peer = &dev->info;
5652
5653 os_get_reltime(&dev->last_seen);
5654 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY);
5655 p2p_copy_wps_info(p2p, dev, 0, &msg);
5656
5657 if (!msg.oob_go_neg_channel) {
5658 p2p_dbg(p2p, "OOB GO Negotiation Channel attribute not included");
5659 p2p_parse_free(&msg);
5660 return -1;
5661 }
5662
5663 if (msg.oob_go_neg_channel[3] == 0 &&
5664 msg.oob_go_neg_channel[4] == 0)
5665 freq = 0;
5666 else
5667 freq = p2p_channel_to_freq(msg.oob_go_neg_channel[3],
5668 msg.oob_go_neg_channel[4]);
5669 if (freq < 0) {
5670 p2p_dbg(p2p, "Unknown peer OOB GO Neg channel");
5671 p2p_parse_free(&msg);
5672 return -1;
5673 }
5674 role = msg.oob_go_neg_channel[5];
5675
5676 if (role == P2P_GO_IN_A_GROUP) {
5677 p2p_dbg(p2p, "Peer OOB GO operating channel: %u MHz", freq);
5678 params->go_freq = freq;
5679 } else if (role == P2P_CLIENT_IN_A_GROUP) {
5680 p2p_dbg(p2p, "Peer (client) OOB GO operating channel: %u MHz",
5681 freq);
5682 params->go_freq = freq;
5683 } else
5684 p2p_dbg(p2p, "Peer OOB GO Neg channel: %u MHz", freq);
5685 dev->oob_go_neg_freq = freq;
5686
5687 if (!params->sel && role != P2P_GO_IN_A_GROUP) {
5688 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
5689 p2p->cfg->channel);
5690 if (freq < 0) {
5691 p2p_dbg(p2p, "Own listen channel not known");
5692 p2p_parse_free(&msg);
5693 return -1;
5694 }
5695 p2p_dbg(p2p, "Use own Listen channel as OOB GO Neg channel: %u MHz", freq);
5696 dev->oob_go_neg_freq = freq;
5697 }
5698
5699 if (msg.group_id) {
5700 os_memcpy(params->go_dev_addr, msg.group_id, ETH_ALEN);
5701 params->go_ssid_len = msg.group_id_len - ETH_ALEN;
5702 os_memcpy(params->go_ssid, msg.group_id + ETH_ALEN,
5703 params->go_ssid_len);
5704 }
5705
5706 if (dev->flags & P2P_DEV_USER_REJECTED) {
5707 p2p_dbg(p2p, "Do not report rejected device");
5708 p2p_parse_free(&msg);
5709 return 0;
5710 }
5711
5712 if (!(dev->flags & P2P_DEV_REPORTED)) {
5713 p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info,
5714 !(dev->flags & P2P_DEV_REPORTED_ONCE));
5715 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
5716 }
5717 p2p_parse_free(&msg);
5718
5719 if (role == P2P_GO_IN_A_GROUP && p2p->num_groups > 0)
5720 params->next_step = BOTH_GO;
5721 else if (role == P2P_GO_IN_A_GROUP)
5722 params->next_step = JOIN_GROUP;
5723 else if (role == P2P_CLIENT_IN_A_GROUP) {
5724 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
5725 params->next_step = PEER_CLIENT;
5726 } else if (p2p->num_groups > 0)
5727 params->next_step = AUTH_JOIN;
5728 else if (params->sel)
5729 params->next_step = INIT_GO_NEG;
5730 else
5731 params->next_step = RESP_GO_NEG;
5732
5733 return 0;
5734 }
5735
5736
5737 void p2p_set_authorized_oob_dev_pw_id(struct p2p_data *p2p, u16 dev_pw_id,
5738 int go_intent,
5739 const u8 *own_interface_addr)
5740 {
5741
5742 p2p->authorized_oob_dev_pw_id = dev_pw_id;
5743 if (dev_pw_id == 0) {
5744 p2p_dbg(p2p, "NFC OOB Password unauthorized for static handover");
5745 return;
5746 }
5747
5748 p2p_dbg(p2p, "NFC OOB Password (id=%u) authorized for static handover",
5749 dev_pw_id);
5750
5751 p2p->go_intent = go_intent;
5752 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
5753 }
5754
5755 #endif /* CONFIG_WPS_NFC */
5756
5757
5758 int p2p_set_passphrase_len(struct p2p_data *p2p, unsigned int len)
5759 {
5760 if (len < 8 || len > 63)
5761 return -1;
5762 p2p->cfg->passphrase_len = len;
5763 return 0;
5764 }
5765
5766
5767 void p2p_set_vendor_elems(struct p2p_data *p2p, struct wpabuf **vendor_elem)
5768 {
5769 p2p->vendor_elem = vendor_elem;
5770 }
5771
5772
5773 void p2p_go_neg_wait_timeout(void *eloop_ctx, void *timeout_ctx)
5774 {
5775 struct p2p_data *p2p = eloop_ctx;
5776
5777 p2p_dbg(p2p,
5778 "Timeout on waiting peer to become ready for GO Negotiation");
5779
5780 #ifdef CONFIG_P2P_CHR
5781 if (p2p->state == P2P_WAIT_PEER_CONNECT || p2p->state == P2P_WAIT_PEER_IDLE) {
5782 wpa_supplicant_upload_chr_statistics_event(GO_NEG_WAIT_PEER_READY_TIMEOUT_CNT);
5783 wpa_supplicant_upload_state_before_group_formation_success(GROUP_OWNER_NEGOTIATION,
5784 P2P_EVENT_REASON_GO_NEGOTIATION_WAIT_PEER_READY_TIMEOUT);
5785 #ifdef CONFIG_LIBWPA_VENDOR
5786 char buf[CHR_BUFFER_SIZE] = {0};
5787 os_snprintf(buf, CHR_BUFFER_SIZE, "04:%serrCode=%d", WPA_EVENT_CHR_REPORT,
5788 GO_NEGOTIATION_WAIT_PEER_READY_TIMEOUT);
5789 WpaEventReport("p2p0", WPA_EVENT_STA_NOTIFY, (void *)buf);
5790 #endif
5791 }
5792 #endif
5793
5794 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
5795 if (p2p->go_neg_peer)
5796 p2p_go_neg_failed(p2p, -1);
5797 #else
5798 p2p_go_neg_failed(p2p, -1);
5799 #endif
5800 }
5801
5802
5803 void p2p_set_own_pref_freq_list(struct p2p_data *p2p,
5804 const struct weighted_pcl *pref_freq_list,
5805 unsigned int size)
5806 {
5807 unsigned int i;
5808
5809 if (size > P2P_MAX_PREF_CHANNELS)
5810 size = P2P_MAX_PREF_CHANNELS;
5811 p2p->num_pref_freq = size;
5812 os_memcpy(p2p->pref_freq_list, pref_freq_list,
5813 size * sizeof(struct weighted_pcl));
5814 for (i = 0; i < size; i++) {
5815 p2p_dbg(p2p, "Own preferred frequency list[%u]=%u MHz",
5816 i, p2p->pref_freq_list[i].freq);
5817 }
5818 }
5819
5820
5821 void p2p_set_override_pref_op_chan(struct p2p_data *p2p, u8 op_class,
5822 u8 chan)
5823 {
5824 p2p->override_pref_op_class = op_class;
5825 p2p->override_pref_channel = chan;
5826 }
5827
5828
5829 struct wpabuf * p2p_build_probe_resp_template(struct p2p_data *p2p,
5830 unsigned int freq)
5831 {
5832 struct wpabuf *ies, *buf;
5833 u8 addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
5834 int ret;
5835
5836 ies = p2p_build_probe_resp_ies(p2p, NULL, 0);
5837 if (!ies) {
5838 wpa_printf(MSG_ERROR,
5839 "CTRL: Failed to build Probe Response IEs");
5840 return NULL;
5841 }
5842
5843 buf = wpabuf_alloc(200 + wpabuf_len(ies));
5844 if (!buf) {
5845 wpabuf_free(ies);
5846 return NULL;
5847 }
5848
5849 ret = p2p_build_probe_resp_buf(p2p, buf, ies, addr, freq);
5850 wpabuf_free(ies);
5851 if (ret) {
5852 wpabuf_free(buf);
5853 return NULL;
5854 }
5855
5856 return buf;
5857 }
5858
5859
5860 bool p2p_is_peer_6ghz_capab(struct p2p_data *p2p, const u8 *addr)
5861 {
5862 struct p2p_device *dev;
5863
5864 dev = p2p_get_device(p2p, addr);
5865 if (!dev)
5866 return false;
5867
5868 return dev->support_6ghz;
5869 }
5870
5871
5872 void p2p_set_6ghz_dev_capab(struct p2p_data *p2p, bool allow_6ghz)
5873 {
5874 p2p->p2p_6ghz_capable = allow_6ghz;
5875 p2p->allow_6ghz = allow_6ghz;
5876 p2p_dbg(p2p, "Set 6 GHz capability to %d", allow_6ghz);
5877
5878 if (allow_6ghz)
5879 p2p->dev_capab |= P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE;
5880 else
5881 p2p->dev_capab &= ~P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE;
5882 }
5883
5884
5885 bool is_p2p_6ghz_capable(struct p2p_data *p2p)
5886 {
5887 return p2p->p2p_6ghz_capable;
5888 }
5889
5890
5891 bool p2p_wfd_enabled(struct p2p_data *p2p)
5892 {
5893 #ifdef CONFIG_WIFI_DISPLAY
5894 return p2p->wfd_ie_probe_req != NULL;
5895 #else /* CONFIG_WIFI_DISPLAY */
5896 return false;
5897 #endif /* CONFIG_WIFI_DISPLAY */
5898 }
5899
5900
5901 bool p2p_peer_wfd_enabled(struct p2p_data *p2p, const u8 *peer_addr)
5902 {
5903 #ifdef CONFIG_WIFI_DISPLAY
5904 struct p2p_device *dev;
5905
5906 dev = p2p_get_device(p2p, peer_addr);
5907 return dev && dev->info.wfd_subelems != NULL;
5908 #else /* CONFIG_WIFI_DISPLAY */
5909 return false;
5910 #endif /* CONFIG_WIFI_DISPLAY */
5911 }
5912
5913
5914 bool is_p2p_allow_6ghz(struct p2p_data *p2p)
5915 {
5916 return p2p->allow_6ghz;
5917 }
5918
5919
5920 void set_p2p_allow_6ghz(struct p2p_data *p2p, bool value)
5921 {
5922 p2p->allow_6ghz = value;
5923 }
5924
5925 #ifdef HARMONY_P2P_CONNECTIVITY_PATCH
5926 int p2p_is_concurrents(struct p2p_data *p2p)
5927 {
5928 if (p2p->cfg->is_concurrent_session_active &&
5929 p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx))
5930 return 1;
5931 else
5932 return 0;
5933 }
5934
5935 int p2p_get_enable_go_neg_opt(struct p2p_data *p2p)
5936 {
5937 return p2p->enable_go_neg_opt;
5938 }
5939
5940 int p2p_get_process_go_neg_opt(struct p2p_data *p2p)
5941 {
5942 return p2p->process_go_neg_opt;
5943 }
5944
5945 void p2p_set_enable_go_neg_opt(struct p2p_data *p2p, int status)
5946 {
5947 p2p_dbg(p2p, "set enable_go_neg_opt=%d", status);
5948 p2p->enable_go_neg_opt = status;
5949 }
5950
5951 void p2p_set_process_go_neg_opt(struct p2p_data *p2p, int status)
5952 {
5953 p2p_dbg(p2p, "set process_go_neg_opt=%d", status);
5954 p2p->process_go_neg_opt = status;
5955 }
5956 #endif
5957
5958 #ifdef HARMONY_CONNECTIVITY_PATCH
5959 #ifndef OPEN_HARMONY_MIRACAST_SINK_OPT
5960 int p2p_get_persistent_group_need_remove_flag(struct p2p_data *p2p)
5961 {
5962 #ifndef HW_WPA_REDUCE_LOG
5963 p2p_dbg(p2p, "get persistent_group_need_remove = %d",
5964 p2p->persistent_group_need_remove);
5965 #endif
5966 return p2p->persistent_group_need_remove;
5967 }
5968
5969 void p2p_set_persistent_group_need_remove_flag(struct p2p_data *p2p, int value)
5970 {
5971 #ifndef HW_WPA_REDUCE_LOG
5972 p2p_dbg(p2p, "set persistent_group_need_remove = %d",
5973 p2p->persistent_group_need_remove);
5974 #endif
5975 p2p->persistent_group_need_remove = value;
5976 }
5977 #endif
5978 #endif
5979