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