]> git.ipfire.org Git - thirdparty/hostap.git/blame - src/p2p/p2p.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Check random_get_bytes() result before writing entropy file
[thirdparty/hostap.git] / src / p2p / p2p.c
CommitLineData
b22128ef
JM		 1/*
2 * Wi-Fi Direct - P2P module
3 * Copyright (c) 2009-2010, Atheros Communications
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15#include "includes.h"
16
17#include "common.h"
18#include "eloop.h"
19#include "common/ieee802_11_defs.h"
20#include "common/ieee802_11_common.h"
21#include "wps/wps_i.h"
22#include "p2p_i.h"
23#include "p2p.h"
24
25
26static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx);
27static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
28static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
29 const u8 *sa, const u8 *data, size_t len,
30 int rx_freq);
31static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
32 const u8 *sa, const u8 *data,
33 size_t len);
34static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx);
40c03fd4 35static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx);
b22128ef
JM		 36
37
40c03fd4
JM		 38/*
39 * p2p_scan recovery timeout
40 *
41 * Many drivers are using 30 second timeout on scan results. Allow a bit larger
42 * timeout for this to avoid hitting P2P timeout unnecessarily.
43 */
44#define P2P_SCAN_TIMEOUT 35
45
b22128ef
JM		 46/**
47 * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer
48 * entries will be removed
49 */
50#define P2P_PEER_EXPIRATION_AGE 300
51
52#define P2P_PEER_EXPIRATION_INTERVAL (P2P_PEER_EXPIRATION_AGE / 2)
53
54static void p2p_expire_peers(struct p2p_data *p2p)
55{
56 struct p2p_device *dev, *n;
57 struct os_time now;
58
59 os_get_time(&now);
60 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
61 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec)
62 continue;
63 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Expiring old peer "
c5db8e51 64 "entry " MACSTR, MAC2STR(dev->info.p2p_device_addr));
b22128ef
JM		 65 dl_list_del(&dev->list);
66 p2p_device_free(p2p, dev);
67 }
68}
69
70
71static void p2p_expiration_timeout(void *eloop_ctx, void *timeout_ctx)
72{
73 struct p2p_data *p2p = eloop_ctx;
74 p2p_expire_peers(p2p);
75 eloop_register_timeout(P2P_PEER_EXPIRATION_INTERVAL, 0,
76 p2p_expiration_timeout, p2p, NULL);
77}
78
79
80static const char * p2p_state_txt(int state)
81{
82 switch (state) {
83 case P2P_IDLE:
84 return "IDLE";
85 case P2P_SEARCH:
86 return "SEARCH";
87 case P2P_CONNECT:
88 return "CONNECT";
89 case P2P_CONNECT_LISTEN:
90 return "CONNECT_LISTEN";
91 case P2P_GO_NEG:
92 return "GO_NEG";
93 case P2P_LISTEN_ONLY:
94 return "LISTEN_ONLY";
95 case P2P_WAIT_PEER_CONNECT:
96 return "WAIT_PEER_CONNECT";
97 case P2P_WAIT_PEER_IDLE:
98 return "WAIT_PEER_IDLE";
99 case P2P_SD_DURING_FIND:
100 return "SD_DURING_FIND";
101 case P2P_PROVISIONING:
102 return "PROVISIONING";
103 case P2P_PD_DURING_FIND:
104 return "PD_DURING_FIND";
105 case P2P_INVITE:
106 return "INVITE";
107 case P2P_INVITE_LISTEN:
108 return "INVITE_LISTEN";
109 default:
110 return "?";
111 }
112}
113
114
115void p2p_set_state(struct p2p_data *p2p, int new_state)
116{
117 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: State %s -> %s",
118 p2p_state_txt(p2p->state), p2p_state_txt(new_state));
119 p2p->state = new_state;
120}
121
122
123void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec)
124{
125 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
126 "P2P: Set timeout (state=%s): %u.%06u sec",
127 p2p_state_txt(p2p->state), sec, usec);
128 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
129 eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL);
130}
131
132
133void p2p_clear_timeout(struct p2p_data *p2p)
134{
135 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Clear timeout (state=%s)",
136 p2p_state_txt(p2p->state));
137 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL);
138}
139
140
141void p2p_go_neg_failed(struct p2p_data *p2p, struct p2p_device *peer,
142 int status)
143{
144 struct p2p_go_neg_results res;
145 p2p_clear_timeout(p2p);
146 p2p_set_state(p2p, P2P_IDLE);
147 p2p->go_neg_peer = NULL;
148
149 os_memset(&res, 0, sizeof(res));
150 res.status = status;
151 if (peer) {
c5db8e51 152 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr,
b22128ef
JM		 153 ETH_ALEN);
154 os_memcpy(res.peer_interface_addr, peer->intended_addr,
155 ETH_ALEN);
156 }
157 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
158}
159
160
161static void p2p_listen_in_find(struct p2p_data *p2p)
162{
163 unsigned int r, tu;
164 int freq;
165 struct wpabuf *ies;
166
167 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
168 "P2P: Starting short listen state (state=%s)",
169 p2p_state_txt(p2p->state));
170
171 freq = p2p_channel_to_freq(p2p->cfg->country, p2p->cfg->reg_class,
172 p2p->cfg->channel);
173 if (freq < 0) {
174 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
175 "P2P: Unknown regulatory class/channel");
176 return;
177 }
178
179 os_get_random((u8 *) &r, sizeof(r));
180 tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) +
181 p2p->min_disc_int) * 100;
182
183 p2p->pending_listen_freq = freq;
184 p2p->pending_listen_sec = 0;
185 p2p->pending_listen_usec = 1024 * tu;
186
187 ies = p2p_build_probe_resp_ies(p2p);
188 if (ies == NULL)
189 return;
190
191 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000,
192 ies) < 0) {
193 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
194 "P2P: Failed to start listen mode");
195 p2p->pending_listen_freq = 0;
196 }
197 wpabuf_free(ies);
198}
199
200
201int p2p_listen(struct p2p_data *p2p, unsigned int timeout)
202{
203 int freq;
204 struct wpabuf *ies;
205
206 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
207 "P2P: Going to listen(only) state");
208
209 freq = p2p_channel_to_freq(p2p->cfg->country, p2p->cfg->reg_class,
210 p2p->cfg->channel);
211 if (freq < 0) {
212 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
213 "P2P: Unknown regulatory class/channel");
214 return -1;
215 }
216
217 p2p->pending_listen_freq = freq;
218 p2p->pending_listen_sec = timeout / 1000;
219 p2p->pending_listen_usec = (timeout % 1000) * 1000;
220
221 if (p2p->p2p_scan_running) {
222 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
223 "P2P: p2p_scan running - delay start of listen state");
224 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN;
225 return 0;
226 }
227
228 ies = p2p_build_probe_resp_ies(p2p);
229 if (ies == NULL)
230 return -1;
231
232 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) {
233 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
234 "P2P: Failed to start listen mode");
235 p2p->pending_listen_freq = 0;
236 wpabuf_free(ies);
237 return -1;
238 }
239 wpabuf_free(ies);
240
241 p2p_set_state(p2p, P2P_LISTEN_ONLY);
242
243 return 0;
244}
245
246
247static void p2p_device_clear_reported(struct p2p_data *p2p)
248{
249 struct p2p_device *dev;
250 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list)
251 dev->flags &= ~P2P_DEV_REPORTED;
252}
253
254
255/**
256 * p2p_get_device - Fetch a peer entry
257 * @p2p: P2P module context from p2p_init()
258 * @addr: P2P Device Address of the peer
259 * Returns: Pointer to the device entry or %NULL if not found
260 */
261struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr)
262{
263 struct p2p_device *dev;
264 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
c5db8e51 265 if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0)
b22128ef
JM		 266 return dev;
267 }
268 return NULL;
269}
270
271
272/**
273 * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address
274 * @p2p: P2P module context from p2p_init()
275 * @addr: P2P Interface Address of the peer
276 * Returns: Pointer to the device entry or %NULL if not found
277 */
278struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p,
279 const u8 *addr)
280{
281 struct p2p_device *dev;
282 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
283 if (os_memcmp(dev->interface_addr, addr, ETH_ALEN) == 0)
284 return dev;
285 }
286 return NULL;
287}
288
289
290/**
291 * p2p_create_device - Create a peer entry
292 * @p2p: P2P module context from p2p_init()
293 * @addr: P2P Device Address of the peer
294 * Returns: Pointer to the device entry or %NULL on failure
295 *
296 * If there is already an entry for the peer, it will be returned instead of
297 * creating a new one.
298 */
299static struct p2p_device * p2p_create_device(struct p2p_data *p2p,
300 const u8 *addr)
301{
302 struct p2p_device *dev, *oldest = NULL;
303 size_t count = 0;
304
305 dev = p2p_get_device(p2p, addr);
306 if (dev)
307 return dev;
308
309 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
310 count++;
311 if (oldest == NULL ||
312 os_time_before(&dev->last_seen, &oldest->last_seen))
313 oldest = dev;
314 }
315 if (count + 1 > p2p->cfg->max_peers && oldest) {
316 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
317 "P2P: Remove oldest peer entry to make room for a new "
318 "peer");
319 dl_list_del(&oldest->list);
320 p2p_device_free(p2p, oldest);
321 }
322
323 dev = os_zalloc(sizeof(*dev));
324 if (dev == NULL)
325 return NULL;
326 dl_list_add(&p2p->devices, &dev->list);
c5db8e51 327 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
b22128ef
JM		 328
329 return dev;
330}
331
332
333static void p2p_copy_client_info(struct p2p_device *dev,
334 struct p2p_client_info *cli)
335{
c5db8e51
KRK		 336 os_memcpy(dev->info.device_name, cli->dev_name, cli->dev_name_len);
337 dev->info.device_name[cli->dev_name_len] = '\0';
338 dev->info.dev_capab = cli->dev_capab;
339 dev->info.config_methods = cli->config_methods;
340 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
e57ae6e1
JMB		 341 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types;
342 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types,
343 dev->info.wps_sec_dev_type_list_len);
b22128ef
JM		 344}
345
346
347static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr,
348 const u8 *go_interface_addr, int freq,
349 const u8 *gi, size_t gi_len)
350{
351 struct p2p_group_info info;
352 size_t c;
353 struct p2p_device *dev;
354
355 if (gi == NULL)
356 return 0;
357
358 if (p2p_group_info_parse(gi, gi_len, &info) < 0)
359 return -1;
360
361 /*
362 * Clear old data for this group; if the devices are still in the
363 * group, the information will be restored in the loop following this.
364 */
365 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
366 if (os_memcpy(dev->member_in_go_iface, go_interface_addr,
367 ETH_ALEN) == 0) {
368 os_memset(dev->member_in_go_iface, 0, ETH_ALEN);
369 os_memset(dev->member_in_go_dev, 0, ETH_ALEN);
370 }
371 }
372
373 for (c = 0; c < info.num_clients; c++) {
374 struct p2p_client_info *cli = &info.client[c];
375 dev = p2p_get_device(p2p, cli->p2p_device_addr);
376 if (dev) {
377 /*
378 * Update information only if we have not received this
379 * directly from the client.
380 */
381 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY |
382 P2P_DEV_PROBE_REQ_ONLY))
383 p2p_copy_client_info(dev, cli);
384 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
385 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
386 }
387 } else {
388 dev = p2p_create_device(p2p, cli->p2p_device_addr);
389 if (dev == NULL)
390 continue;
391 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
392 p2p_copy_client_info(dev, cli);
393 dev->oper_freq = freq;
c5db8e51
KRK		 394 p2p->cfg->dev_found(p2p->cfg->cb_ctx,
395 dev->info.p2p_device_addr,
8fd7dc1b
JB		 396 &dev->info, 1);
397 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
b22128ef
JM		 398 }
399
400 os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
401 ETH_ALEN);
402 os_get_time(&dev->last_seen);
403 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN);
404 os_memcpy(dev->member_in_go_iface, go_interface_addr,
405 ETH_ALEN);
406 }
407
408 return 0;
409}
410
411
b67d0d9e
JM		 412static void p2p_copy_wps_info(struct p2p_device *dev, int probe_req,
413 const struct p2p_message *msg)
414{
415 os_memcpy(dev->info.device_name, msg->device_name,
416 sizeof(dev->info.device_name));
417
418 if (msg->manufacturer &&
419 msg->manufacturer_len < sizeof(dev->info.manufacturer)) {
420 os_memset(dev->info.manufacturer, 0,
421 sizeof(dev->info.manufacturer));
422 os_memcpy(dev->info.manufacturer, msg->manufacturer,
423 msg->manufacturer_len);
424 }
425
426 if (msg->model_name &&
427 msg->model_name_len < sizeof(dev->info.model_name)) {
428 os_memset(dev->info.model_name, 0,
429 sizeof(dev->info.model_name));
430 os_memcpy(dev->info.model_name, msg->model_name,
431 msg->model_name_len);
432 }
433
434 if (msg->model_number &&
435 msg->model_number_len < sizeof(dev->info.model_number)) {
436 os_memset(dev->info.model_number, 0,
437 sizeof(dev->info.model_number));
438 os_memcpy(dev->info.model_number, msg->model_number,
439 msg->model_number_len);
440 }
441
442 if (msg->serial_number &&
443 msg->serial_number_len < sizeof(dev->info.serial_number)) {
444 os_memset(dev->info.serial_number, 0,
445 sizeof(dev->info.serial_number));
446 os_memcpy(dev->info.serial_number, msg->serial_number,
447 msg->serial_number_len);
448 }
449
450 if (msg->pri_dev_type)
451 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
452 sizeof(dev->info.pri_dev_type));
453 else if (msg->wps_pri_dev_type)
454 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type,
455 sizeof(dev->info.pri_dev_type));
456
457 if (msg->wps_sec_dev_type_list) {
458 os_memcpy(dev->info.wps_sec_dev_type_list,
459 msg->wps_sec_dev_type_list,
460 msg->wps_sec_dev_type_list_len);
461 dev->info.wps_sec_dev_type_list_len =
462 msg->wps_sec_dev_type_list_len;
463 }
464
465 if (msg->capability) {
466 dev->info.dev_capab = msg->capability[0];
467 dev->info.group_capab = msg->capability[1];
468 }
469
470 if (msg->ext_listen_timing) {
471 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing);
472 dev->ext_listen_interval =
473 WPA_GET_LE16(msg->ext_listen_timing + 2);
474 }
475
476 if (!probe_req) {
477 dev->info.config_methods = msg->config_methods ?
478 msg->config_methods : msg->wps_config_methods;
479 }
480}
481
482
b22128ef
JM		 483/**
484 * p2p_add_device - Add peer entries based on scan results
485 * @p2p: P2P module context from p2p_init()
486 * @addr: Source address of Beacon or Probe Response frame (may be either
487 * P2P Device Address or P2P Interface Address)
488 * @level: Signal level (signal strength of the received frame from the peer)
489 * @freq: Frequency on which the Beacon or Probe Response frame was received
490 * @ies: IEs from the Beacon or Probe Response frame
491 * @ies_len: Length of ies buffer in octets
492 * Returns: 0 on success, -1 on failure
493 *
494 * If the scan result is for a GO, the clients in the group will also be added
17bef1e9
AC		 495 * to the peer table. This function can also be used with some other frames
496 * like Provision Discovery Request that contains P2P Capability and P2P Device
497 * Info attributes.
b22128ef 498 */
17bef1e9
AC		 499int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq, int level,
500 const u8 *ies, size_t ies_len)
b22128ef
JM		 501{
502 struct p2p_device *dev;
503 struct p2p_message msg;
504 const u8 *p2p_dev_addr;
6f2c0607 505 int i;
b22128ef
JM		 506
507 os_memset(&msg, 0, sizeof(msg));
508 if (p2p_parse_ies(ies, ies_len, &msg)) {
509 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
510 "P2P: Failed to parse P2P IE for a device entry");
511 p2p_parse_free(&msg);
512 return -1;
513 }
514
515 if (msg.p2p_device_addr)
516 p2p_dev_addr = msg.p2p_device_addr;
517 else if (msg.device_id)
518 p2p_dev_addr = msg.device_id;
519 else {
520 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
521 "P2P: Ignore scan data without P2P Device Info or "
522 "P2P Device Id");
523 p2p_parse_free(&msg);
524 return -1;
525 }
526
80c9582a
JM		 527 if (!is_zero_ether_addr(p2p->peer_filter) &&
528 os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) {
529 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Do not add peer "
530 "filter for " MACSTR " due to peer filter",
531 MAC2STR(p2p_dev_addr));
532 return 0;
533 }
534
b22128ef
JM		 535 dev = p2p_create_device(p2p, p2p_dev_addr);
536 if (dev == NULL) {
537 p2p_parse_free(&msg);
538 return -1;
539 }
540 os_get_time(&dev->last_seen);
541 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY);
542
543 if (os_memcmp(addr, p2p_dev_addr, ETH_ALEN) != 0)
544 os_memcpy(dev->interface_addr, addr, ETH_ALEN);
545 if (msg.ssid &&
546 (msg.ssid[1] != P2P_WILDCARD_SSID_LEN ||
547 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN)
548 != 0)) {
549 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]);
550 dev->oper_ssid_len = msg.ssid[1];
551 }
552
553 if (freq >= 2412 && freq <= 2484 && msg.ds_params &&
554 *msg.ds_params >= 1 && *msg.ds_params <= 14) {
555 int ds_freq;
556 if (*msg.ds_params == 14)
557 ds_freq = 2484;
558 else
559 ds_freq = 2407 + *msg.ds_params * 5;
560 if (freq != ds_freq) {
561 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
562 "P2P: Update Listen frequency based on DS "
563 "Parameter Set IE: %d -> %d MHz",
564 freq, ds_freq);
565 freq = ds_freq;
566 }
567 }
568
569 if (dev->listen_freq && dev->listen_freq != freq) {
570 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
571 "P2P: Update Listen frequency based on scan "
572 "results (" MACSTR " %d -> %d MHz (DS param %d)",
c5db8e51
KRK		 573 MAC2STR(dev->info.p2p_device_addr), dev->listen_freq,
574 freq, msg.ds_params ? *msg.ds_params : -1);
b22128ef
JM		 575 }
576 dev->listen_freq = freq;
f8d0131a
JM		 577 if (msg.group_info)
578 dev->oper_freq = freq;
6402fc43 579 dev->info.level = level;
b22128ef 580
b67d0d9e 581 p2p_copy_wps_info(dev, 0, &msg);
e57ae6e1 582
10c5d2a5 583 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
6f2c0607
JMB		 584 wpabuf_free(dev->info.wps_vendor_ext[i]);
585 dev->info.wps_vendor_ext[i] = NULL;
586 }
587
10c5d2a5 588 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
6f2c0607
JMB		 589 if (msg.wps_vendor_ext[i] == NULL)
590 break;
591 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy(
592 msg.wps_vendor_ext[i], msg.wps_vendor_ext_len[i]);
593 if (dev->info.wps_vendor_ext[i] == NULL)
594 break;
595 }
596
b22128ef
JM		 597 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq, msg.group_info,
598 msg.group_info_len);
599
600 p2p_parse_free(&msg);
601
602 if (p2p_pending_sd_req(p2p, dev))
603 dev->flags |= P2P_DEV_SD_SCHEDULE;
604
605 if (dev->flags & P2P_DEV_REPORTED)
606 return 0;
607
608 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
609 "P2P: Peer found with Listen frequency %d MHz", freq);
610 if (dev->flags & P2P_DEV_USER_REJECTED) {
611 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
612 "P2P: Do not report rejected device");
613 return 0;
614 }
8fd7dc1b
JB		 615
616 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
617 !(dev->flags & P2P_DEV_REPORTED_ONCE));
618 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
b22128ef
JM		 619
620 return 0;
621}
622
623
624static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
625{
6f2c0607
JMB		 626 int i;
627
b22128ef
JM		 628 if (p2p->go_neg_peer == dev)
629 p2p->go_neg_peer = NULL;
630 if (p2p->invite_peer == dev)
631 p2p->invite_peer = NULL;
632 if (p2p->sd_peer == dev)
633 p2p->sd_peer = NULL;
634 if (p2p->pending_client_disc_go == dev)
635 p2p->pending_client_disc_go = NULL;
636
f5fc6032
AC		 637 /* dev_lost() device, but only if it was previously dev_found() */
638 if (dev->flags & P2P_DEV_REPORTED_ONCE)
639 p2p->cfg->dev_lost(p2p->cfg->cb_ctx,
640 dev->info.p2p_device_addr);
56eeb8f2 641
10c5d2a5 642 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
6f2c0607
JMB		 643 wpabuf_free(dev->info.wps_vendor_ext[i]);
644 dev->info.wps_vendor_ext[i] = NULL;
645 }
646
b22128ef
JM		 647 os_free(dev);
648}
649
650
651static int p2p_get_next_prog_freq(struct p2p_data *p2p)
652{
653 struct p2p_channels *c;
654 struct p2p_reg_class *cla;
655 size_t cl, ch;
656 int found = 0;
657 u8 reg_class;
658 u8 channel;
659 int freq;
660
661 c = &p2p->cfg->channels;
662 for (cl = 0; cl < c->reg_classes; cl++) {
663 cla = &c->reg_class[cl];
664 if (cla->reg_class != p2p->last_prog_scan_class)
665 continue;
666 for (ch = 0; ch < cla->channels; ch++) {
667 if (cla->channel[ch] == p2p->last_prog_scan_chan) {
668 found = 1;
669 break;
670 }
671 }
672 if (found)
673 break;
674 }
675
676 if (!found) {
677 /* Start from beginning */
678 reg_class = c->reg_class[0].reg_class;
679 channel = c->reg_class[0].channel[0];
680 } else {
681 /* Pick the next channel */
682 ch++;
683 if (ch == cla->channels) {
684 cl++;
685 if (cl == c->reg_classes)
686 cl = 0;
687 ch = 0;
688 }
689 reg_class = c->reg_class[cl].reg_class;
690 channel = c->reg_class[cl].channel[ch];
691 }
692
693 freq = p2p_channel_to_freq(p2p->cfg->country, reg_class, channel);
694 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Next progressive search "
695 "channel: reg_class %u channel %u -> %d MHz",
696 reg_class, channel, freq);
697 p2p->last_prog_scan_class = reg_class;
698 p2p->last_prog_scan_chan = channel;
699
700 if (freq == 2412 || freq == 2437 || freq == 2462)
701 return 0; /* No need to add social channels */
702 return freq;
703}
704
705
706static void p2p_search(struct p2p_data *p2p)
707{
708 int freq = 0;
709 enum p2p_scan_type type;
710
711 if (p2p->drv_in_listen) {
712 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver is still "
713 "in Listen state - wait for it to end before "
714 "continuing");
715 return;
716 }
717 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
718
719 if (p2p->go_neg_peer) {
720 /*
721 * Only scan the known listen frequency of the peer
722 * during GO Negotiation start.
723 */
724 freq = p2p->go_neg_peer->listen_freq;
725 if (freq <= 0)
726 freq = p2p->go_neg_peer->oper_freq;
727 type = P2P_SCAN_SPECIFIC;
728 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search "
729 "for freq %u (GO Neg)", freq);
730 } else if (p2p->invite_peer) {
731 /*
732 * Only scan the known listen frequency of the peer
733 * during Invite start.
734 */
735 freq = p2p->invite_peer->listen_freq;
736 if (freq <= 0)
737 freq = p2p->invite_peer->oper_freq;
738 type = P2P_SCAN_SPECIFIC;
739 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search "
740 "for freq %u (Invite)", freq);
741 } else if (p2p->find_type == P2P_FIND_PROGRESSIVE &&
742 (freq = p2p_get_next_prog_freq(p2p)) > 0) {
743 type = P2P_SCAN_SOCIAL_PLUS_ONE;
744 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search "
745 "(+ freq %u)", freq);
746 } else {
747 type = P2P_SCAN_SOCIAL;
748 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search");
749 }
750
046ef4aa
JMB		 751 if (p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq,
752 p2p->num_req_dev_types, p2p->req_dev_types) < 0)
753 {
b22128ef
JM		 754 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
755 "P2P: Scan request failed");
756 p2p_continue_find(p2p);
40c03fd4
JM		 757 } else {
758 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Running p2p_scan");
759 p2p->p2p_scan_running = 1;
760 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
761 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout,
762 p2p, NULL);
b22128ef
JM		 763 }
764}
765
766
767static void p2p_find_timeout(void *eloop_ctx, void *timeout_ctx)
768{
769 struct p2p_data *p2p = eloop_ctx;
770 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Find timeout -> stop");
771 p2p_stop_find(p2p);
772}
773
774
775static int p2p_run_after_scan(struct p2p_data *p2p)
776{
777 struct p2p_device *dev;
778 enum p2p_after_scan op;
779
3f9285ff
JM		 780 if (p2p->after_scan_tx) {
781 int ret;
782 /* TODO: schedule p2p_run_after_scan to be called from TX
783 * status callback(?) */
784 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send pending "
785 "Action frame at p2p_scan completion");
786 ret = p2p->cfg->send_action(p2p->cfg->cb_ctx,
787 p2p->after_scan_tx->freq,
788 p2p->after_scan_tx->dst,
789 p2p->after_scan_tx->src,
790 p2p->after_scan_tx->bssid,
791 (u8 *) (p2p->after_scan_tx + 1),
792 p2p->after_scan_tx->len,
793 p2p->after_scan_tx->wait_time);
794 os_free(p2p->after_scan_tx);
795 p2p->after_scan_tx = NULL;
796 return 1;
797 }
798
b22128ef
JM		 799 op = p2p->start_after_scan;
800 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
801 switch (op) {
802 case P2P_AFTER_SCAN_NOTHING:
803 break;
804 case P2P_AFTER_SCAN_LISTEN:
805 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Start previously "
806 "requested Listen state");
807 p2p_listen(p2p, p2p->pending_listen_sec * 1000 +
808 p2p->pending_listen_usec / 1000);
809 return 1;
810 case P2P_AFTER_SCAN_CONNECT:
811 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Start previously "
812 "requested connect with " MACSTR,
813 MAC2STR(p2p->after_scan_peer));
814 dev = p2p_get_device(p2p, p2p->after_scan_peer);
815 if (dev == NULL) {
816 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer not "
817 "known anymore");
818 break;
819 }
820 p2p_connect_send(p2p, dev);
821 return 1;
822 }
823
824 return 0;
825}
826
827
b22128ef
JM		 828static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx)
829{
830 struct p2p_data *p2p = eloop_ctx;
831 int running;
832 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan timeout "
833 "(running=%d)", p2p->p2p_scan_running);
834 running = p2p->p2p_scan_running;
835 /* Make sure we recover from missed scan results callback */
836 p2p->p2p_scan_running = 0;
837
838 if (running)
839 p2p_run_after_scan(p2p);
840}
841
842
046ef4aa
JMB		 843static void p2p_free_req_dev_types(struct p2p_data *p2p)
844{
845 p2p->num_req_dev_types = 0;
846 os_free(p2p->req_dev_types);
847 p2p->req_dev_types = NULL;
848}
849
850
b22128ef 851int p2p_find(struct p2p_data *p2p, unsigned int timeout,
046ef4aa
JMB		 852 enum p2p_discovery_type type,
853 unsigned int num_req_dev_types, const u8 *req_dev_types)
b22128ef
JM		 854{
855 int res;
856
857 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting find (type=%d)",
858 type);
859 if (p2p->p2p_scan_running) {
860 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan is "
861 "already running");
862 }
046ef4aa
JMB		 863
864 p2p_free_req_dev_types(p2p);
865 if (req_dev_types && num_req_dev_types) {
866 p2p->req_dev_types = os_malloc(num_req_dev_types *
867 WPS_DEV_TYPE_LEN);
868 if (p2p->req_dev_types == NULL)
869 return -1;
870 os_memcpy(p2p->req_dev_types, req_dev_types,
871 num_req_dev_types * WPS_DEV_TYPE_LEN);
872 p2p->num_req_dev_types = num_req_dev_types;
873 }
874
b22128ef
JM		 875 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
876 p2p_clear_timeout(p2p);
877 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
878 p2p->find_type = type;
879 p2p_device_clear_reported(p2p);
880 p2p_set_state(p2p, P2P_SEARCH);
881 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
882 if (timeout)
883 eloop_register_timeout(timeout, 0, p2p_find_timeout,
884 p2p, NULL);
885 switch (type) {
886 case P2P_FIND_START_WITH_FULL:
887 case P2P_FIND_PROGRESSIVE:
046ef4aa
JMB		 888 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0,
889 p2p->num_req_dev_types,
890 p2p->req_dev_types);
b22128ef
JM		 891 break;
892 case P2P_FIND_ONLY_SOCIAL:
046ef4aa
JMB		 893 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0,
894 p2p->num_req_dev_types,
895 p2p->req_dev_types);
b22128ef
JM		 896 break;
897 default:
898 return -1;
899 }
900
901 if (res == 0) {
902 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Running p2p_scan");
903 p2p->p2p_scan_running = 1;
904 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
905 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout,
906 p2p, NULL);
907 } else {
908 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Failed to start "
909 "p2p_scan");
910 }
911
912 return res;
913}
914
915
0b8889d8 916void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq)
b22128ef
JM		 917{
918 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Stopping find");
919 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
920 p2p_clear_timeout(p2p);
921 p2p_set_state(p2p, P2P_IDLE);
046ef4aa 922 p2p_free_req_dev_types(p2p);
b22128ef
JM		 923 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
924 p2p->go_neg_peer = NULL;
925 p2p->sd_peer = NULL;
926 p2p->invite_peer = NULL;
0b8889d8
JM		 927 if (freq > 0 && p2p->drv_in_listen == freq && p2p->in_listen) {
928 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip stop_listen "
929 "since we are on correct channel for response");
930 return;
931 }
b22128ef
JM		 932 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
933}
934
935
0b8889d8
JM		 936void p2p_stop_find(struct p2p_data *p2p)
937{
938 p2p_stop_find_for_freq(p2p, 0);
939}
940
941
7861cb08 942static int p2p_prepare_channel(struct p2p_data *p2p, unsigned int force_freq)
b22128ef 943{
b22128ef 944 if (force_freq) {
1e19f734 945 u8 op_reg_class, op_channel;
b22128ef 946 if (p2p_freq_to_channel(p2p->cfg->country, force_freq,
1e19f734 947 &op_reg_class, &op_channel) < 0) {
b22128ef
JM		 948 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
949 "P2P: Unsupported frequency %u MHz",
950 force_freq);
951 return -1;
952 }
1e19f734
JM		 953 if (!p2p_channels_includes(&p2p->cfg->channels, op_reg_class,
954 op_channel)) {
955 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
956 "P2P: Frequency %u MHz (oper_class %u "
957 "channel %u) not allowed for P2P",
958 force_freq, op_reg_class, op_channel);
959 return -1;
960 }
961 p2p->op_reg_class = op_reg_class;
962 p2p->op_channel = op_channel;
b22128ef
JM		 963 p2p->channels.reg_classes = 1;
964 p2p->channels.reg_class[0].channels = 1;
965 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class;
966 p2p->channels.reg_class[0].channel[0] = p2p->op_channel;
967 } else {
7cfc4ac3
AGS		 968 u8 op_reg_class, op_channel;
969
970 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 &&
971 p2p_supported_freq(p2p, p2p->best_freq_overall) &&
972 p2p_freq_to_channel(p2p->cfg->country,
973 p2p->best_freq_overall,
974 &op_reg_class, &op_channel) == 0) {
975 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
976 "P2P: Select best overall channel as "
977 "operating channel preference");
978 p2p->op_reg_class = op_reg_class;
979 p2p->op_channel = op_channel;
980 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 &&
981 p2p_supported_freq(p2p, p2p->best_freq_5) &&
982 p2p_freq_to_channel(p2p->cfg->country,
983 p2p->best_freq_5,
984 &op_reg_class, &op_channel) ==
985 0) {
986 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
987 "P2P: Select best 5 GHz channel as "
988 "operating channel preference");
989 p2p->op_reg_class = op_reg_class;
990 p2p->op_channel = op_channel;
991 } else if (!p2p->cfg->cfg_op_channel &&
992 p2p->best_freq_24 > 0 &&
993 p2p_supported_freq(p2p, p2p->best_freq_24) &&
994 p2p_freq_to_channel(p2p->cfg->country,
995 p2p->best_freq_24,
996 &op_reg_class, &op_channel) ==
997 0) {
998 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
999 "P2P: Select best 2.4 GHz channel as "
1000 "operating channel preference");
1001 p2p->op_reg_class = op_reg_class;
1002 p2p->op_channel = op_channel;
1003 } else {
1004 p2p->op_reg_class = p2p->cfg->op_reg_class;
1005 p2p->op_channel = p2p->cfg->op_channel;
1006 }
1007
b22128ef
JM		 1008 os_memcpy(&p2p->channels, &p2p->cfg->channels,
1009 sizeof(struct p2p_channels));
1010 }
1011 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1012 "P2P: Own preference for operation channel: "
7cfc4ac3 1013 "Operating Class %u Channel %u%s",
b22128ef
JM		 1014 p2p->op_reg_class, p2p->op_channel,
1015 force_freq ? " (forced)" : "");
1016
7861cb08
JM		 1017 return 0;
1018}
1019
1020
1021int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
1022 enum p2p_wps_method wps_method,
1023 int go_intent, const u8 *own_interface_addr,
1024 unsigned int force_freq, int persistent_group)
1025{
1026 struct p2p_device *dev;
1027
1028 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1029 "P2P: Request to start group negotiation - peer=" MACSTR
1030 " GO Intent=%d Intended Interface Address=" MACSTR
1031 " wps_method=%d persistent_group=%d",
1032 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr),
1033 wps_method, persistent_group);
1034
1035 if (p2p_prepare_channel(p2p, force_freq) < 0)
1036 return -1;
1037
b22128ef
JM		 1038 dev = p2p_get_device(p2p, peer_addr);
1039 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1040 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1041 "P2P: Cannot connect to unknown P2P Device " MACSTR,
1042 MAC2STR(peer_addr));
1043 return -1;
1044 }
1045
1046 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
c5db8e51
KRK		 1047 if (!(dev->info.dev_capab &
1048 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
b22128ef
JM		 1049 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1050 "P2P: Cannot connect to P2P Device " MACSTR
1051 " that is in a group and is not discoverable",
1052 MAC2STR(peer_addr));
1053 return -1;
1054 }
1055 if (dev->oper_freq <= 0) {
1056 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1057 "P2P: Cannot connect to P2P Device " MACSTR
1058 " with incomplete information",
1059 MAC2STR(peer_addr));
1060 return -1;
1061 }
1062
1063 /*
1064 * First, try to connect directly. If the peer does not
1065 * acknowledge frames, assume it is sleeping and use device
1066 * discoverability via the GO at that point.
1067 */
1068 }
1069
1070 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1071 dev->flags &= ~P2P_DEV_USER_REJECTED;
1072 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1073 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
9dac8c3e 1074 dev->connect_reqs = 0;
b22128ef
JM		 1075 dev->go_neg_req_sent = 0;
1076 dev->go_state = UNKNOWN_GO;
1077 if (persistent_group)
1078 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1079 else
1080 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_GROUP;
1081 p2p->go_intent = go_intent;
1082 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1083
1084 if (p2p->state != P2P_IDLE)
1085 p2p_stop_find(p2p);
1086
f44ae207
JM		 1087 if (p2p->after_scan_tx) {
1088 /*
1089 * We need to drop the pending frame to avoid issues with the
1090 * new GO Negotiation, e.g., when the pending frame was from a
1091 * previous attempt at starting a GO Negotiation.
1092 */
1093 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Dropped "
1094 "previous pending Action frame TX that was waiting "
1095 "for p2p_scan completion");
1096 os_free(p2p->after_scan_tx);
1097 p2p->after_scan_tx = NULL;
1098 }
1099
b22128ef
JM		 1100 dev->wps_method = wps_method;
1101 dev->status = P2P_SC_SUCCESS;
d5b20a73
JM		 1102
1103 if (force_freq)
1104 dev->flags |= P2P_DEV_FORCE_FREQ;
1105 else
1106 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1107
b22128ef
JM		 1108 if (p2p->p2p_scan_running) {
1109 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1110 "P2P: p2p_scan running - delay connect send");
1111 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT;
1112 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN);
1113 return 0;
1114 }
1115 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
1116
1117 return p2p_connect_send(p2p, dev);
1118}
1119
1120
1121int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,
1122 enum p2p_wps_method wps_method,
1123 int go_intent, const u8 *own_interface_addr,
1124 unsigned int force_freq, int persistent_group)
1125{
1126 struct p2p_device *dev;
1127
1128 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1129 "P2P: Request to authorize group negotiation - peer=" MACSTR
1130 " GO Intent=%d Intended Interface Address=" MACSTR
1131 " wps_method=%d persistent_group=%d",
1132 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr),
1133 wps_method, persistent_group);
1134
7861cb08
JM		 1135 if (p2p_prepare_channel(p2p, force_freq) < 0)
1136 return -1;
b22128ef
JM		 1137
1138 dev = p2p_get_device(p2p, peer_addr);
1139 if (dev == NULL) {
1140 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1141 "P2P: Cannot authorize unknown P2P Device " MACSTR,
1142 MAC2STR(peer_addr));
1143 return -1;
1144 }
1145
1146 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1147 dev->flags &= ~P2P_DEV_USER_REJECTED;
1148 dev->go_neg_req_sent = 0;
1149 dev->go_state = UNKNOWN_GO;
1150 if (persistent_group)
1151 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1152 else
1153 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_GROUP;
1154 p2p->go_intent = go_intent;
1155 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN);
1156
1157 dev->wps_method = wps_method;
1158 dev->status = P2P_SC_SUCCESS;
1159
d5b20a73
JM		 1160 if (force_freq)
1161 dev->flags |= P2P_DEV_FORCE_FREQ;
1162 else
1163 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1164
b22128ef
JM		 1165 return 0;
1166}
1167
1168
1169void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr,
1170 struct p2p_device *dev, struct p2p_message *msg)
1171{
1172 os_get_time(&dev->last_seen);
1173
b67d0d9e 1174 p2p_copy_wps_info(dev, 0, msg);
e57ae6e1 1175
b22128ef
JM		 1176 if (msg->listen_channel) {
1177 int freq;
1178 freq = p2p_channel_to_freq((char *) msg->listen_channel,
1179 msg->listen_channel[3],
1180 msg->listen_channel[4]);
1181 if (freq < 0) {
1182 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1183 "P2P: Unknown peer Listen channel: "
1184 "country=%c%c(0x%02x) reg_class=%u channel=%u",
1185 msg->listen_channel[0],
1186 msg->listen_channel[1],
1187 msg->listen_channel[2],
1188 msg->listen_channel[3],
1189 msg->listen_channel[4]);
1190 } else {
1191 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update "
1192 "peer " MACSTR " Listen channel: %u -> %u MHz",
c5db8e51 1193 MAC2STR(dev->info.p2p_device_addr),
b22128ef
JM		 1194 dev->listen_freq, freq);
1195 dev->listen_freq = freq;
1196 }
1197 }
b22128ef
JM		 1198
1199 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
1200 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
1201 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1202 "P2P: Completed device entry based on data from "
1203 "GO Negotiation Request");
1204 } else {
1205 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1206 "P2P: Created device entry based on GO Neg Req: "
1207 MACSTR " dev_capab=0x%x group_capab=0x%x name='%s' "
1208 "listen_freq=%d",
c5db8e51
KRK		 1209 MAC2STR(dev->info.p2p_device_addr),
1210 dev->info.dev_capab, dev->info.group_capab,
1211 dev->info.device_name, dev->listen_freq);
b22128ef
JM		 1212 }
1213
1214 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
1215
1216 if (dev->flags & P2P_DEV_USER_REJECTED) {
1217 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1218 "P2P: Do not report rejected device");
1219 return;
1220 }
1221
8fd7dc1b
JB		 1222 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1223 !(dev->flags & P2P_DEV_REPORTED_ONCE));
1224 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
b22128ef
JM		 1225}
1226
1227
1228void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len)
1229{
1230 os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
1231 p2p_random((char *) &ssid[P2P_WILDCARD_SSID_LEN], 2);
1232 os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN + 2],
1233 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len);
1234 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len;
1235}
1236
1237
1238int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params)
1239{
1240 p2p_build_ssid(p2p, params->ssid, &params->ssid_len);
1241 p2p_random(params->passphrase, 8);
1242 return 0;
1243}
1244
1245
1246void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer)
1247{
1248 struct p2p_go_neg_results res;
1249 int go = peer->go_state == LOCAL_GO;
1250 struct p2p_channels intersection;
1251 int freqs;
1252 size_t i, j;
1253
1254 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1255 "P2P: GO Negotiation with " MACSTR " completed (%s will be "
c5db8e51 1256 "GO)", MAC2STR(peer->info.p2p_device_addr),
b22128ef
JM		 1257 go ? "local end" : "peer");
1258
1259 os_memset(&res, 0, sizeof(res));
1260 res.role_go = go;
c5db8e51 1261 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN);
b22128ef
JM		 1262 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN);
1263 res.wps_method = peer->wps_method;
1264 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP)
1265 res.persistent_group = 1;
1266
1267 if (go) {
1268 /* Setup AP mode for WPS provisioning */
1269 res.freq = p2p_channel_to_freq(p2p->cfg->country,
1270 p2p->op_reg_class,
1271 p2p->op_channel);
1272 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1273 res.ssid_len = p2p->ssid_len;
1274 p2p_random(res.passphrase, 8);
e9a7ae41 1275 } else {
b22128ef 1276 res.freq = peer->oper_freq;
e9a7ae41
JM		 1277 if (p2p->ssid_len) {
1278 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len);
1279 res.ssid_len = p2p->ssid_len;
1280 }
1281 }
b22128ef
JM		 1282
1283 p2p_channels_intersect(&p2p->channels, &peer->channels,
1284 &intersection);
1285 freqs = 0;
1286 for (i = 0; i < intersection.reg_classes; i++) {
1287 struct p2p_reg_class *c = &intersection.reg_class[i];
1288 if (freqs + 1 == P2P_MAX_CHANNELS)
1289 break;
1290 for (j = 0; j < c->channels; j++) {
1291 int freq;
1292 if (freqs + 1 == P2P_MAX_CHANNELS)
1293 break;
1294 freq = p2p_channel_to_freq(peer->country, c->reg_class,
1295 c->channel[j]);
1296 if (freq < 0)
1297 continue;
1298 res.freq_list[freqs++] = freq;
1299 }
1300 }
1301
ae3e3421
JM		 1302 res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout;
1303
b22128ef
JM		 1304 p2p_clear_timeout(p2p);
1305 peer->go_neg_req_sent = 0;
1306 peer->wps_method = WPS_NOT_READY;
1307
1308 p2p_set_state(p2p, P2P_PROVISIONING);
1309 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res);
1310}
1311
1312
1313static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa,
1314 const u8 *data, size_t len, int rx_freq)
1315{
1316 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1317 "P2P: RX P2P Public Action from " MACSTR, MAC2STR(sa));
1318 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len);
1319
1320 if (len < 1)
1321 return;
1322
1323 switch (data[0]) {
1324 case P2P_GO_NEG_REQ:
1325 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq);
1326 break;
1327 case P2P_GO_NEG_RESP:
1328 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq);
1329 break;
1330 case P2P_GO_NEG_CONF:
1331 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1);
1332 break;
1333 case P2P_INVITATION_REQ:
1334 p2p_process_invitation_req(p2p, sa, data + 1, len - 1,
1335 rx_freq);
1336 break;
1337 case P2P_INVITATION_RESP:
1338 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1);
1339 break;
1340 case P2P_PROV_DISC_REQ:
1341 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1342 break;
1343 case P2P_PROV_DISC_RESP:
1344 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1);
1345 break;
1346 case P2P_DEV_DISC_REQ:
1347 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq);
1348 break;
1349 case P2P_DEV_DISC_RESP:
1350 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1);
1351 break;
1352 default:
1353 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1354 "P2P: Unsupported P2P Public Action frame type %d",
1355 data[0]);
1356 break;
1357 }
1358}
1359
1360
1361void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da, const u8 *sa,
1362 const u8 *bssid, const u8 *data, size_t len,
1363 int freq)
1364{
1365 if (len < 1)
1366 return;
1367
1368 switch (data[0]) {
1369 case WLAN_PA_VENDOR_SPECIFIC:
1370 data++;
1371 len--;
1372 if (len < 3)
1373 return;
1374 if (WPA_GET_BE24(data) != OUI_WFA)
1375 return;
1376
1377 data += 3;
1378 len -= 3;
1379 if (len < 1)
1380 return;
1381
1382 if (*data != P2P_OUI_TYPE)
1383 return;
1384
1385 p2p_rx_p2p_action(p2p, sa, data + 1, len - 1, freq);
1386 break;
1387 case WLAN_PA_GAS_INITIAL_REQ:
1388 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq);
1389 break;
1390 case WLAN_PA_GAS_INITIAL_RESP:
18708aad
JM		 1391 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq);
1392 break;
1393 case WLAN_PA_GAS_COMEBACK_REQ:
1394 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq);
1395 break;
1396 case WLAN_PA_GAS_COMEBACK_RESP:
1397 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq);
b22128ef
JM		 1398 break;
1399 }
1400}
1401
1402
1403void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,
1404 const u8 *bssid, u8 category,
1405 const u8 *data, size_t len, int freq)
1406{
1407 if (category == WLAN_ACTION_PUBLIC) {
1408 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq);
1409 return;
1410 }
1411
1412 if (category != WLAN_ACTION_VENDOR_SPECIFIC)
1413 return;
1414
1415 if (len < 4)
1416 return;
1417
1418 if (WPA_GET_BE24(data) != OUI_WFA)
1419 return;
1420 data += 3;
1421 len -= 3;
1422
1423 if (*data != P2P_OUI_TYPE)
1424 return;
1425 data++;
1426 len--;
1427
1428 /* P2P action frame */
1429 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1430 "P2P: RX P2P Action from " MACSTR, MAC2STR(sa));
1431 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len);
1432
1433 if (len < 1)
1434 return;
1435 switch (data[0]) {
1436 case P2P_NOA:
1437 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1438 "P2P: Received P2P Action - Notice of Absence");
1439 /* TODO */
1440 break;
1441 case P2P_PRESENCE_REQ:
1442 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq);
1443 break;
1444 case P2P_PRESENCE_RESP:
1445 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1);
1446 break;
1447 case P2P_GO_DISC_REQ:
1448 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq);
1449 break;
1450 default:
1451 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1452 "P2P: Received P2P Action - unknown type %u", data[0]);
1453 break;
1454 }
1455}
1456
1457
1458static void p2p_go_neg_start(void *eloop_ctx, void *timeout_ctx)
1459{
1460 struct p2p_data *p2p = eloop_ctx;
1461 if (p2p->go_neg_peer == NULL)
1462 return;
1463 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1464 p2p->go_neg_peer->status = P2P_SC_SUCCESS;
1465 p2p_connect_send(p2p, p2p->go_neg_peer);
1466}
1467
1468
1469static void p2p_invite_start(void *eloop_ctx, void *timeout_ctx)
1470{
1471 struct p2p_data *p2p = eloop_ctx;
1472 if (p2p->invite_peer == NULL)
1473 return;
1474 p2p->cfg->stop_listen(p2p->cfg->cb_ctx);
1475 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr);
1476}
1477
1478
1479static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr,
1480 const u8 *ie, size_t ie_len)
1481{
1482 struct p2p_message msg;
1483 struct p2p_device *dev;
1484
1485 os_memset(&msg, 0, sizeof(msg));
1486 if (p2p_parse_ies(ie, ie_len, &msg) < 0 || msg.p2p_attributes == NULL)
1487 {
1488 p2p_parse_free(&msg);
1489 return; /* not a P2P probe */
1490 }
1491
1492 if (msg.ssid == NULL || msg.ssid[1] != P2P_WILDCARD_SSID_LEN ||
1493 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN)
1494 != 0) {
1495 /* The Probe Request is not part of P2P Device Discovery. It is
1496 * not known whether the source address of the frame is the P2P
1497 * Device Address or P2P Interface Address. Do not add a new
1498 * peer entry based on this frames.
1499 */
1500 p2p_parse_free(&msg);
1501 return;
1502 }
1503
1504 dev = p2p_get_device(p2p, addr);
1505 if (dev) {
1506 if (dev->country[0] == 0 && msg.listen_channel)
1507 os_memcpy(dev->country, msg.listen_channel, 3);
1508 p2p_parse_free(&msg);
1509 return; /* already known */
1510 }
1511
1512 dev = p2p_create_device(p2p, addr);
1513 if (dev == NULL) {
1514 p2p_parse_free(&msg);
1515 return;
1516 }
1517
1518 os_get_time(&dev->last_seen);
1519 dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
1520
b22128ef
JM		 1521 if (msg.listen_channel) {
1522 os_memcpy(dev->country, msg.listen_channel, 3);
1523 dev->listen_freq = p2p_channel_to_freq(dev->country,
1524 msg.listen_channel[3],
1525 msg.listen_channel[4]);
1526 }
1527
b67d0d9e 1528 p2p_copy_wps_info(dev, 1, &msg);
e57ae6e1 1529
b22128ef
JM		 1530 p2p_parse_free(&msg);
1531
1532 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1533 "P2P: Created device entry based on Probe Req: " MACSTR
1534 " dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d",
c5db8e51
KRK		 1535 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab,
1536 dev->info.group_capab, dev->info.device_name,
1537 dev->listen_freq);
b22128ef
JM		 1538}
1539
1540
1541struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p,
1542 const u8 *addr,
1543 struct p2p_message *msg)
1544{
1545 struct p2p_device *dev;
1546
1547 dev = p2p_get_device(p2p, addr);
1548 if (dev) {
1549 os_get_time(&dev->last_seen);
1550 return dev; /* already known */
1551 }
1552
1553 dev = p2p_create_device(p2p, addr);
1554 if (dev == NULL)
1555 return NULL;
1556
1557 p2p_add_dev_info(p2p, addr, dev, msg);
1558
1559 return dev;
1560}
1561
1562
1563static int dev_type_match(const u8 *dev_type, const u8 *req_dev_type)
1564{
1565 if (os_memcmp(dev_type, req_dev_type, WPS_DEV_TYPE_LEN) == 0)
1566 return 1;
1567 if (os_memcmp(dev_type, req_dev_type, 2) == 0 &&
1568 WPA_GET_BE32(&req_dev_type[2]) == 0 &&
1569 WPA_GET_BE16(&req_dev_type[6]) == 0)
1570 return 1; /* Category match with wildcard OUI/sub-category */
1571 return 0;
1572}
1573
1574
1575int dev_type_list_match(const u8 *dev_type, const u8 *req_dev_type[],
1576 size_t num_req_dev_type)
1577{
1578 size_t i;
1579 for (i = 0; i < num_req_dev_type; i++) {
1580 if (dev_type_match(dev_type, req_dev_type[i]))
1581 return 1;
1582 }
1583 return 0;
1584}
1585
1586
1587/**
1588 * p2p_match_dev_type - Match local device type with requested type
1589 * @p2p: P2P module context from p2p_init()
1590 * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs)
1591 * Returns: 1 on match, 0 on mismatch
1592 *
1593 * This function can be used to match the Requested Device Type attribute in
1594 * WPS IE with the local device types for deciding whether to reply to a Probe
1595 * Request frame.
1596 */
1597int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps)
1598{
1599 struct wps_parse_attr attr;
1600 size_t i;
1601
1602 if (wps_parse_msg(wps, &attr))
1603 return 1; /* assume no Requested Device Type attributes */
1604
1605 if (attr.num_req_dev_type == 0)
1606 return 1; /* no Requested Device Type attributes -> match */
1607
1608 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type,
1609 attr.num_req_dev_type))
1610 return 1; /* Own Primary Device Type matches */
1611
1612 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++)
1613 if (dev_type_list_match(p2p->cfg->sec_dev_type[i],
1614 attr.req_dev_type,
1615 attr.num_req_dev_type))
1616 return 1; /* Own Secondary Device Type matches */
1617
1618 /* No matching device type found */
1619 return 0;
1620}
1621
1622
1623struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p)
1624{
1625 struct wpabuf *buf;
1626 u8 *len;
1627
1628 buf = wpabuf_alloc(1000);
1629 if (buf == NULL)
1630 return NULL;
1631
b22128ef
JM		 1632 p2p_build_wps_ie(p2p, buf, DEV_PW_DEFAULT, 1);
1633
1634 /* P2P IE */
1635 len = p2p_buf_add_ie_hdr(buf);
1636 p2p_buf_add_capability(buf, p2p->dev_capab, 0);
1637 if (p2p->ext_listen_interval)
1638 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
1639 p2p->ext_listen_interval);
1640 p2p_buf_add_device_info(buf, p2p, NULL);
1641 p2p_buf_update_ie_hdr(buf, len);
1642
1643 return buf;
1644}
1645
1646
1647static void p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *ie,
1648 size_t ie_len)
1649{
1650 struct ieee802_11_elems elems;
1651 struct wpabuf *buf;
1652 struct ieee80211_mgmt *resp;
1653 struct wpabuf *wps;
1654 struct wpabuf *ies;
1655
1656 if (!p2p->in_listen || !p2p->drv_in_listen) {
1657 /* not in Listen state - ignore Probe Request */
1658 return;
1659 }
1660
1661 if (ieee802_11_parse_elems((u8 *) ie, ie_len, &elems, 0) ==
1662 ParseFailed) {
1663 /* Ignore invalid Probe Request frames */
1664 return;
1665 }
1666
1667 if (elems.p2p == NULL) {
1668 /* not a P2P probe - ignore it */
1669 return;
1670 }
1671
1672 if (elems.ssid == NULL || elems.ssid_len != P2P_WILDCARD_SSID_LEN ||
1673 os_memcmp(elems.ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) !=
1674 0) {
1675 /* not using P2P Wildcard SSID - ignore */
1676 return;
1677 }
1678
1679 /* Check Requested Device Type match */
1680 wps = ieee802_11_vendor_ie_concat(ie, ie_len, WPS_DEV_OUI_WFA);
1681 if (wps && !p2p_match_dev_type(p2p, wps)) {
1682 wpabuf_free(wps);
1683 /* No match with Requested Device Type */
1684 return;
1685 }
1686 wpabuf_free(wps);
1687
1688 if (!p2p->cfg->send_probe_resp)
1689 return; /* Response generated elsewhere */
1690
1691 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1692 "P2P: Reply to P2P Probe Request in Listen state");
1693
1694 /*
1695 * We do not really have a specific BSS that this frame is advertising,
1696 * so build a frame that has some information in valid format. This is
1697 * really only used for discovery purposes, not to learn exact BSS
1698 * parameters.
1699 */
1700 ies = p2p_build_probe_resp_ies(p2p);
1701 if (ies == NULL)
1702 return;
1703
1704 buf = wpabuf_alloc(200 + wpabuf_len(ies));
1705 if (buf == NULL) {
1706 wpabuf_free(ies);
1707 return;
1708 }
1709
1710 resp = NULL;
1711 resp = wpabuf_put(buf, resp->u.probe_resp.variable - (u8 *) resp);
1712
1713 resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) |
1714 (WLAN_FC_STYPE_PROBE_RESP << 4));
1715 os_memcpy(resp->da, addr, ETH_ALEN);
1716 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN);
1717 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN);
1718 resp->u.probe_resp.beacon_int = host_to_le16(100);
1719 /* hardware or low-level driver will setup seq_ctrl and timestamp */
1720 resp->u.probe_resp.capab_info =
1721 host_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE |
1722 WLAN_CAPABILITY_PRIVACY |
1723 WLAN_CAPABILITY_SHORT_SLOT_TIME);
1724
1725 wpabuf_put_u8(buf, WLAN_EID_SSID);
1726 wpabuf_put_u8(buf, P2P_WILDCARD_SSID_LEN);
1727 wpabuf_put_data(buf, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN);
1728
1729 wpabuf_put_u8(buf, WLAN_EID_SUPP_RATES);
1730 wpabuf_put_u8(buf, 8);
1731 wpabuf_put_u8(buf, (60 / 5) | 0x80);
1732 wpabuf_put_u8(buf, 90 / 5);
1733 wpabuf_put_u8(buf, (120 / 5) | 0x80);
1734 wpabuf_put_u8(buf, 180 / 5);
1735 wpabuf_put_u8(buf, (240 / 5) | 0x80);
1736 wpabuf_put_u8(buf, 360 / 5);
1737 wpabuf_put_u8(buf, 480 / 5);
1738 wpabuf_put_u8(buf, 540 / 5);
1739
1740 wpabuf_put_u8(buf, WLAN_EID_DS_PARAMS);
1741 wpabuf_put_u8(buf, 1);
1742 wpabuf_put_u8(buf, p2p->cfg->channel);
1743
1744 wpabuf_put_buf(buf, ies);
1745 wpabuf_free(ies);
1746
1747 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf);
1748
1749 wpabuf_free(buf);
1750}
1751
1752
1753int p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *ie,
1754 size_t ie_len)
1755{
1756 p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len);
1757
1758 p2p_reply_probe(p2p, addr, ie, ie_len);
1759
1760 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) &&
1761 p2p->go_neg_peer &&
c5db8e51
KRK		 1762 os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN)
1763 == 0) {
b22128ef
JM		 1764 /* Received a Probe Request from GO Negotiation peer */
1765 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1766 "P2P: Found GO Negotiation peer - try to start GO "
1767 "negotiation from timeout");
1768 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL);
1769 return 1;
1770 }
1771
1772 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) &&
1773 p2p->invite_peer &&
c5db8e51
KRK		 1774 os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN)
1775 == 0) {
b22128ef
JM		 1776 /* Received a Probe Request from Invite peer */
1777 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1778 "P2P: Found Invite peer - try to start Invite from "
1779 "timeout");
1780 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL);
1781 return 1;
1782 }
1783
1784 return 0;
1785}
1786
1787
1788static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid,
4c08c0bd 1789 u8 *buf, size_t len, struct wpabuf *p2p_ie)
b22128ef
JM		 1790{
1791 struct wpabuf *tmp;
1792 u8 *lpos;
1793 size_t tmplen;
1794 int res;
72044390 1795 u8 group_capab;
b22128ef 1796
4c08c0bd
JM		 1797 if (p2p_ie == NULL)
1798 return 0; /* WLAN AP is not a P2P manager */
b22128ef
JM		 1799
1800 /*
1801 * (Re)Association Request - P2P IE
1802 * P2P Capability attribute (shall be present)
4c08c0bd
JM		 1803 * P2P Interface attribute (present if concurrent device and
1804 * P2P Management is enabled)
b22128ef
JM		 1805 */
1806 tmp = wpabuf_alloc(200);
1807 if (tmp == NULL)
1808 return -1;
1809
1810 lpos = p2p_buf_add_ie_hdr(tmp);
72044390
JM		 1811 group_capab = 0;
1812 if (p2p->num_groups > 0) {
1813 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER;
1814 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
1815 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
1816 p2p->cross_connect)
1817 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
1818 }
1819 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab);
4c08c0bd
JM		 1820 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
1821 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED))
b22128ef
JM		 1822 p2p_buf_add_p2p_interface(tmp, p2p);
1823 p2p_buf_update_ie_hdr(tmp, lpos);
1824
1825 tmplen = wpabuf_len(tmp);
1826 if (tmplen > len)
1827 res = -1;
1828 else {
1829 os_memcpy(buf, wpabuf_head(tmp), tmplen);
1830 res = tmplen;
1831 }
1832 wpabuf_free(tmp);
1833
1834 return res;
1835}
1836
1837
1838int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,
4c08c0bd 1839 size_t len, int p2p_group, struct wpabuf *p2p_ie)
b22128ef
JM		 1840{
1841 struct wpabuf *tmp;
1842 u8 *lpos;
1843 struct p2p_device *peer;
1844 size_t tmplen;
1845 int res;
1846
1847 if (!p2p_group)
4c08c0bd 1848 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie);
b22128ef
JM		 1849
1850 /*
1851 * (Re)Association Request - P2P IE
1852 * P2P Capability attribute (shall be present)
1853 * Extended Listen Timing (may be present)
1854 * P2P Device Info attribute (shall be present)
1855 */
1856 tmp = wpabuf_alloc(200);
1857 if (tmp == NULL)
1858 return -1;
1859
1860 peer = bssid ? p2p_get_device(p2p, bssid) : NULL;
1861
1862 lpos = p2p_buf_add_ie_hdr(tmp);
1863 p2p_buf_add_capability(tmp, p2p->dev_capab, 0);
5be5305b
JM		 1864 if (p2p->ext_listen_interval)
1865 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period,
1866 p2p->ext_listen_interval);
b22128ef
JM		 1867 p2p_buf_add_device_info(tmp, p2p, peer);
1868 p2p_buf_update_ie_hdr(tmp, lpos);
1869
1870 tmplen = wpabuf_len(tmp);
1871 if (tmplen > len)
1872 res = -1;
1873 else {
1874 os_memcpy(buf, wpabuf_head(tmp), tmplen);
1875 res = tmplen;
1876 }
1877 wpabuf_free(tmp);
1878
1879 return res;
1880}
1881
1882
1883int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end)
1884{
1885 struct wpabuf *p2p_ie;
1886 int ret;
1887
1888 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, P2P_IE_VENDOR_TYPE);
1889 if (p2p_ie == NULL)
1890 return 0;
1891
1892 ret = p2p_attr_text(p2p_ie, buf, end);
1893 wpabuf_free(p2p_ie);
1894 return ret;
1895}
1896
1897
1898static void p2p_clear_go_neg(struct p2p_data *p2p)
1899{
1900 p2p->go_neg_peer = NULL;
1901 p2p_clear_timeout(p2p);
1902 p2p_set_state(p2p, P2P_IDLE);
1903}
1904
1905
1906void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr)
1907{
1908 if (p2p->go_neg_peer == NULL) {
1909 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1910 "P2P: No pending Group Formation - "
1911 "ignore WPS registration success notification");
1912 return; /* No pending Group Formation */
1913 }
1914
1915 if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) !=
1916 0) {
1917 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1918 "P2P: Ignore WPS registration success notification "
1919 "for " MACSTR " (GO Negotiation peer " MACSTR ")",
1920 MAC2STR(mac_addr),
1921 MAC2STR(p2p->go_neg_peer->intended_addr));
1922 return; /* Ignore unexpected peer address */
1923 }
1924
1925 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1926 "P2P: Group Formation completed successfully with " MACSTR,
1927 MAC2STR(mac_addr));
1928
1929 p2p_clear_go_neg(p2p);
1930}
1931
1932
1933void p2p_group_formation_failed(struct p2p_data *p2p)
1934{
1935 if (p2p->go_neg_peer == NULL) {
1936 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1937 "P2P: No pending Group Formation - "
1938 "ignore group formation failure notification");
1939 return; /* No pending Group Formation */
1940 }
1941
1942 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1943 "P2P: Group Formation failed with " MACSTR,
1944 MAC2STR(p2p->go_neg_peer->intended_addr));
1945
1946 p2p_clear_go_neg(p2p);
1947}
1948
1949
1950struct p2p_data * p2p_init(const struct p2p_config *cfg)
1951{
1952 struct p2p_data *p2p;
1953
1954 if (cfg->max_peers < 1)
1955 return NULL;
1956
1957 p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg));
1958 if (p2p == NULL)
1959 return NULL;
1960 p2p->cfg = (struct p2p_config *) (p2p + 1);
1961 os_memcpy(p2p->cfg, cfg, sizeof(*cfg));
1962 if (cfg->dev_name)
1963 p2p->cfg->dev_name = os_strdup(cfg->dev_name);
b6e01800
JM		 1964 if (cfg->manufacturer)
1965 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer);
1966 if (cfg->model_name)
1967 p2p->cfg->model_name = os_strdup(cfg->model_name);
1968 if (cfg->model_number)
1969 p2p->cfg->model_number = os_strdup(cfg->model_number);
1970 if (cfg->serial_number)
1971 p2p->cfg->serial_number = os_strdup(cfg->serial_number);
b22128ef
JM		 1972
1973 p2p->min_disc_int = 1;
1974 p2p->max_disc_int = 3;
1975
1976 os_get_random(&p2p->next_tie_breaker, 1);
1977 p2p->next_tie_breaker &= 0x01;
1978 if (cfg->sd_request)
1979 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY;
1980 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE;
1981 if (cfg->concurrent_operations)
1982 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER;
1983 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
1984
1985 dl_list_init(&p2p->devices);
1986
1987 eloop_register_timeout(P2P_PEER_EXPIRATION_INTERVAL, 0,
1988 p2p_expiration_timeout, p2p, NULL);
1989
1990 return p2p;
1991}
1992
1993
1994void p2p_deinit(struct p2p_data *p2p)
1995{
1996 eloop_cancel_timeout(p2p_expiration_timeout, p2p, NULL);
1997 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
1998 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
1999 p2p_flush(p2p);
046ef4aa 2000 p2p_free_req_dev_types(p2p);
b22128ef 2001 os_free(p2p->cfg->dev_name);
b6e01800
JM		 2002 os_free(p2p->cfg->manufacturer);
2003 os_free(p2p->cfg->model_name);
2004 os_free(p2p->cfg->model_number);
2005 os_free(p2p->cfg->serial_number);
b22128ef 2006 os_free(p2p->groups);
18708aad 2007 wpabuf_free(p2p->sd_resp);
3f9285ff 2008 os_free(p2p->after_scan_tx);
f95cac27 2009 p2p_remove_wps_vendor_extensions(p2p);
b22128ef
JM		 2010 os_free(p2p);
2011}
2012
2013
2014void p2p_flush(struct p2p_data *p2p)
2015{
2016 struct p2p_device *dev, *prev;
2017 p2p_clear_timeout(p2p);
2018 p2p_set_state(p2p, P2P_IDLE);
2019 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING;
2020 p2p->go_neg_peer = NULL;
2021 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL);
2022 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
2023 list) {
2024 dl_list_del(&dev->list);
2025 p2p_device_free(p2p, dev);
2026 }
2027 p2p_free_sd_queries(p2p);
f44ae207
JM		 2028 os_free(p2p->after_scan_tx);
2029 p2p->after_scan_tx = NULL;
b22128ef
JM		 2030}
2031
2032
9d562b79
SS		 2033int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr)
2034{
2035 struct p2p_device *dev;
2036
2037 dev = p2p_get_device(p2p, addr);
2038 if (dev == NULL)
2039 return -1;
2040
2041 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Unauthorizing " MACSTR,
2042 MAC2STR(addr));
2043
2044 if (p2p->go_neg_peer == dev)
2045 p2p->go_neg_peer = NULL;
2046
2047 dev->wps_method = WPS_NOT_READY;
2048 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
2049 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
2050
2051 /* Check if after_scan_tx is for this peer. If so free it */
2052 if (p2p->after_scan_tx &&
2053 os_memcmp(addr, p2p->after_scan_tx->dst, ETH_ALEN) == 0) {
2054 os_free(p2p->after_scan_tx);
2055 p2p->after_scan_tx = NULL;
2056 }
2057
2058 return 0;
2059}
2060
2061
b22128ef
JM		 2062int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name)
2063{
2064 os_free(p2p->cfg->dev_name);
2065 if (dev_name) {
2066 p2p->cfg->dev_name = os_strdup(dev_name);
2067 if (p2p->cfg->dev_name == NULL)
2068 return -1;
2069 } else
2070 p2p->cfg->dev_name = NULL;
2071 return 0;
2072}
2073
2074
b6e01800
JM		 2075int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer)
2076{
2077 os_free(p2p->cfg->manufacturer);
2078 p2p->cfg->manufacturer = NULL;
2079 if (manufacturer) {
2080 p2p->cfg->manufacturer = os_strdup(manufacturer);
2081 if (p2p->cfg->manufacturer == NULL)
2082 return -1;
2083 }
2084
2085 return 0;
2086}
2087
2088
2089int p2p_set_model_name(struct p2p_data *p2p, const char *model_name)
2090{
2091 os_free(p2p->cfg->model_name);
2092 p2p->cfg->model_name = NULL;
2093 if (model_name) {
2094 p2p->cfg->model_name = os_strdup(model_name);
2095 if (p2p->cfg->model_name == NULL)
2096 return -1;
2097 }
2098
2099 return 0;
2100}
2101
2102
2103int p2p_set_model_number(struct p2p_data *p2p, const char *model_number)
2104{
2105 os_free(p2p->cfg->model_number);
2106 p2p->cfg->model_number = NULL;
2107 if (model_number) {
2108 p2p->cfg->model_number = os_strdup(model_number);
2109 if (p2p->cfg->model_number == NULL)
2110 return -1;
2111 }
2112
2113 return 0;
2114}
2115
2116
2117int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number)
2118{
2119 os_free(p2p->cfg->serial_number);
2120 p2p->cfg->serial_number = NULL;
2121 if (serial_number) {
2122 p2p->cfg->serial_number = os_strdup(serial_number);
2123 if (p2p->cfg->serial_number == NULL)
2124 return -1;
2125 }
2126
2127 return 0;
2128}
2129
2130
2131void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods)
2132{
2133 p2p->cfg->config_methods = config_methods;
2134}
2135
2136
2137void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid)
2138{
2139 os_memcpy(p2p->cfg->uuid, uuid, 16);
2140}
2141
2142
b22128ef
JM		 2143int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type)
2144{
2145 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8);
2146 return 0;
2147}
2148
2149
2150int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],
2151 size_t num_dev_types)
2152{
2153 if (num_dev_types > P2P_SEC_DEVICE_TYPES)
2154 num_dev_types = P2P_SEC_DEVICE_TYPES;
2155 p2p->cfg->num_sec_dev_types = num_dev_types;
2156 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8);
2157 return 0;
2158}
2159
2160
f95cac27
JMB		 2161void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p)
2162{
2163 int i;
2164
10c5d2a5 2165 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
f95cac27
JMB		 2166 wpabuf_free(p2p->wps_vendor_ext[i]);
2167 p2p->wps_vendor_ext[i] = NULL;
2168 }
2169}
2170
2171
2172int p2p_add_wps_vendor_extension(struct p2p_data *p2p,
2173 const struct wpabuf *vendor_ext)
2174{
2175 int i;
2176
2177 if (vendor_ext == NULL)
2178 return -1;
2179
10c5d2a5 2180 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
f95cac27
JMB		 2181 if (p2p->wps_vendor_ext[i] == NULL)
2182 break;
2183 }
10c5d2a5 2184 if (i >= P2P_MAX_WPS_VENDOR_EXT)
f95cac27
JMB		 2185 return -1;
2186
2187 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext);
2188 if (p2p->wps_vendor_ext[i] == NULL)
2189 return -1;
2190
2191 return 0;
2192}
2193
2194
b22128ef
JM		 2195int p2p_set_country(struct p2p_data *p2p, const char *country)
2196{
2197 os_memcpy(p2p->cfg->country, country, 3);
2198 return 0;
2199}
2200
2201
2202void p2p_continue_find(struct p2p_data *p2p)
2203{
2204 struct p2p_device *dev;
2205 p2p_set_state(p2p, P2P_SEARCH);
2206 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2207 if (dev->flags & P2P_DEV_SD_SCHEDULE) {
2208 if (p2p_start_sd(p2p, dev) == 0)
2209 return;
2210 else
2211 break;
10c4edde
JM		 2212 } else if (dev->req_config_methods &&
2213 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) {
2214 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send "
2215 "pending Provisioning Discovery Request to "
2216 MACSTR " (config methods 0x%x)",
c5db8e51 2217 MAC2STR(dev->info.p2p_device_addr),
10c4edde 2218 dev->req_config_methods);
b22128ef
JM		 2219 if (p2p_send_prov_disc_req(p2p, dev, 0) == 0)
2220 return;
2221 }
2222 }
2223
2224 p2p_listen_in_find(p2p);
2225}
2226
2227
2228static void p2p_sd_cb(struct p2p_data *p2p, int success)
2229{
2230 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2231 "P2P: Service Discovery Query TX callback: success=%d",
2232 success);
2233 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2234
2235 if (!success) {
2236 if (p2p->sd_peer) {
2237 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE;
2238 p2p->sd_peer = NULL;
2239 }
2240 p2p_continue_find(p2p);
2241 return;
2242 }
2243
2244 if (p2p->sd_peer == NULL) {
2245 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2246 "P2P: No SD peer entry known");
2247 p2p_continue_find(p2p);
2248 return;
2249 }
2250
2251 /* Wait for response from the peer */
2252 p2p_set_state(p2p, P2P_SD_DURING_FIND);
2253 p2p_set_timeout(p2p, 0, 200000);
2254}
2255
6b56cc2d
JS		 2256
2257/**
2258 * p2p_retry_pd - Retry any pending provision disc requests in IDLE state
2259 * @p2p: P2P module context from p2p_init()
2260 */
2261void p2p_retry_pd(struct p2p_data *p2p)
2262{
2263 struct p2p_device *dev;
2264
2265 if (p2p->state != P2P_IDLE)
2266 return;
2267
2268 /*
2269 * Retry the prov disc req attempt only for the peer that the user had
2270 * requested for and provided a join has not been initiated on it
2271 * in the meantime.
2272 */
2273
2274 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2275 if (os_memcmp(p2p->pending_pd_devaddr,
2276 dev->info.p2p_device_addr, ETH_ALEN) != 0)
2277 continue;
2278 if (!dev->req_config_methods)
2279 continue;
2280 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
2281 continue;
2282
2283 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send "
2284 "pending Provisioning Discovery Request to "
2285 MACSTR " (config methods 0x%x)",
2286 MAC2STR(dev->info.p2p_device_addr),
2287 dev->req_config_methods);
2288 p2p_send_prov_disc_req(p2p, dev, 0);
2289 return;
2290 }
2291}
2292
2293
b22128ef
JM		 2294static void p2p_prov_disc_cb(struct p2p_data *p2p, int success)
2295{
2296 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2297 "P2P: Provision Discovery Request TX callback: success=%d",
2298 success);
6b56cc2d
JS		 2299
2300 /*
2301 * Postpone resetting the pending action state till after we actually
2302 * time out. This allows us to take some action like notifying any
2303 * interested parties about no response to the request.
2304 *
2305 * When the timer (below) goes off we check in IDLE, SEARCH, or
2306 * LISTEN_ONLY state, which are the only allowed states to issue a PD
2307 * requests in, if this was still pending and then raise notification.
2308 */
b22128ef
JM		 2309
2310 if (!success) {
6b56cc2d
JS		 2311 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2312
b22128ef
JM		 2313 if (p2p->state != P2P_IDLE)
2314 p2p_continue_find(p2p);
6b56cc2d
JS		 2315 else if (p2p->user_initiated_pd) {
2316 p2p->pending_action_state = P2P_PENDING_PD;
2317 p2p_set_timeout(p2p, 0, 300000);
2318 }
b22128ef
JM		 2319 return;
2320 }
2321
6b56cc2d
JS		 2322 /*
2323 * This postponing, of resetting pending_action_state, needs to be
2324 * done only for user initiated PD requests and not internal ones.
2325 */
2326 if (p2p->user_initiated_pd)
2327 p2p->pending_action_state = P2P_PENDING_PD;
2328 else
2329 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2330
b22128ef
JM		 2331 /* Wait for response from the peer */
2332 if (p2p->state == P2P_SEARCH)
2333 p2p_set_state(p2p, P2P_PD_DURING_FIND);
2334 p2p_set_timeout(p2p, 0, 200000);
2335}
2336
2337
2338int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,
2339 int level, const u8 *ies, size_t ies_len)
2340{
2341 p2p_add_device(p2p, bssid, freq, level, ies, ies_len);
2342
2343 if (p2p->go_neg_peer && p2p->state == P2P_SEARCH &&
c5db8e51
KRK		 2344 os_memcmp(p2p->go_neg_peer->info.p2p_device_addr, bssid, ETH_ALEN)
2345 == 0) {
b22128ef
JM		 2346 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2347 "P2P: Found GO Negotiation peer - try to start GO "
2348 "negotiation");
2349 p2p_connect_send(p2p, p2p->go_neg_peer);
2350 return 1;
2351 }
2352
2353 return 0;
2354}
2355
2356
2357void p2p_scan_res_handled(struct p2p_data *p2p)
2358{
2359 if (!p2p->p2p_scan_running) {
2360 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan was not "
2361 "running, but scan results received");
2362 }
2363 p2p->p2p_scan_running = 0;
2364 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL);
2365
2366 if (p2p_run_after_scan(p2p))
2367 return;
2368 if (p2p->state == P2P_SEARCH)
2369 p2p_continue_find(p2p);
2370}
2371
2372
2373void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies)
2374{
2375 u8 *len = p2p_buf_add_ie_hdr(ies);
2376 p2p_buf_add_capability(ies, p2p->dev_capab, 0);
2377 if (p2p->cfg->reg_class && p2p->cfg->channel)
2378 p2p_buf_add_listen_channel(ies, p2p->cfg->country,
2379 p2p->cfg->reg_class,
2380 p2p->cfg->channel);
2381 if (p2p->ext_listen_interval)
2382 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period,
2383 p2p->ext_listen_interval);
2384 /* TODO: p2p_buf_add_operating_channel() if GO */
2385 p2p_buf_update_ie_hdr(ies, len);
2386}
2387
2388
2389int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end)
2390{
2391 return p2p_attr_text(p2p_ie, buf, end);
2392}
2393
2394
2395static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success)
2396{
2397 struct p2p_device *dev = p2p->go_neg_peer;
2398
2399 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2400 "P2P: GO Negotiation Request TX callback: success=%d",
2401 success);
2402
2403 if (dev == NULL) {
2404 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2405 "P2P: No pending GO Negotiation");
2406 return;
2407 }
2408
2409 if (success) {
2410 dev->go_neg_req_sent++;
2411 if (dev->flags & P2P_DEV_USER_REJECTED) {
2412 p2p_set_state(p2p, P2P_IDLE);
2413 return;
2414 }
2415 }
2416
2417 if (!success &&
c5db8e51 2418 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
b22128ef
JM		 2419 !is_zero_ether_addr(dev->member_in_go_dev)) {
2420 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2421 "P2P: Peer " MACSTR " did not acknowledge request - "
2422 "try to use device discoverability through its GO",
c5db8e51 2423 MAC2STR(dev->info.p2p_device_addr));
b22128ef
JM		 2424 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2425 p2p_send_dev_disc_req(p2p, dev);
2426 return;
2427 }
2428
2429 /*
2430 * Use P2P find, if needed, to find the other device from its listen
2431 * channel.
2432 */
2433 p2p_set_state(p2p, P2P_CONNECT);
2434 p2p_set_timeout(p2p, 0, 100000);
2435}
2436
2437
2438static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)
2439{
2440 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2441 "P2P: GO Negotiation Response TX callback: success=%d",
2442 success);
2443 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) {
2444 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2445 "P2P: Ignore TX callback event - GO Negotiation is "
2446 "not running anymore");
2447 return;
2448 }
2449 p2p_set_state(p2p, P2P_CONNECT);
2450 p2p_set_timeout(p2p, 0, 100000);
2451}
2452
2453
2454static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success)
2455{
2456 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2457 "P2P: GO Negotiation Response (failure) TX callback: "
2458 "success=%d", success);
fbe70272
JM		 2459 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) {
2460 p2p_go_neg_failed(p2p, p2p->go_neg_peer,
2461 p2p->go_neg_peer->status);
2462 }
b22128ef
JM		 2463}
2464
2465
93b7ddd0
JM		 2466static void p2p_go_neg_conf_cb(struct p2p_data *p2p,
2467 enum p2p_send_action_result result)
b22128ef
JM		 2468{
2469 struct p2p_device *dev;
2470
2471 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
93b7ddd0
JM		 2472 "P2P: GO Negotiation Confirm TX callback: result=%d",
2473 result);
b22128ef 2474 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
93b7ddd0
JM		 2475 if (result == P2P_SEND_ACTION_FAILED) {
2476 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2477 return;
2478 }
2479 if (result == P2P_SEND_ACTION_NO_ACK) {
b22128ef
JM		 2480 /*
2481 * It looks like the TX status for GO Negotiation Confirm is
2482 * often showing failure even when the peer has actually
2483 * received the frame. Since the peer may change channels
2484 * immediately after having received the frame, we may not see
2485 * an Ack for retries, so just dropping a single frame may
2486 * trigger this. To allow the group formation to succeed if the
2487 * peer did indeed receive the frame, continue regardless of
2488 * the TX status.
2489 */
2490 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2491 "P2P: Assume GO Negotiation Confirm TX was actually "
2492 "received by the peer even though Ack was not "
2493 "reported");
2494 }
2495
2496 dev = p2p->go_neg_peer;
2497 if (dev == NULL)
2498 return;
2499
2500 p2p_go_complete(p2p, dev);
2501}
2502
2503
2504void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
93b7ddd0
JM		 2505 const u8 *src, const u8 *bssid,
2506 enum p2p_send_action_result result)
b22128ef
JM		 2507{
2508 enum p2p_pending_action_state state;
93b7ddd0 2509 int success;
b22128ef
JM		 2510
2511 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2512 "P2P: Action frame TX callback (state=%d freq=%u dst=" MACSTR
93b7ddd0 2513 " src=" MACSTR " bssid=" MACSTR " result=%d",
b22128ef 2514 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src),
93b7ddd0
JM		 2515 MAC2STR(bssid), result);
2516 success = result == P2P_SEND_ACTION_SUCCESS;
b22128ef
JM		 2517 state = p2p->pending_action_state;
2518 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2519 switch (state) {
2520 case P2P_NO_PENDING_ACTION:
2521 break;
2522 case P2P_PENDING_GO_NEG_REQUEST:
2523 p2p_go_neg_req_cb(p2p, success);
2524 break;
2525 case P2P_PENDING_GO_NEG_RESPONSE:
2526 p2p_go_neg_resp_cb(p2p, success);
2527 break;
2528 case P2P_PENDING_GO_NEG_RESPONSE_FAILURE:
2529 p2p_go_neg_resp_failure_cb(p2p, success);
2530 break;
2531 case P2P_PENDING_GO_NEG_CONFIRM:
93b7ddd0 2532 p2p_go_neg_conf_cb(p2p, result);
b22128ef
JM		 2533 break;
2534 case P2P_PENDING_SD:
2535 p2p_sd_cb(p2p, success);
2536 break;
2537 case P2P_PENDING_PD:
2538 p2p_prov_disc_cb(p2p, success);
2539 break;
2540 case P2P_PENDING_INVITATION_REQUEST:
2541 p2p_invitation_req_cb(p2p, success);
2542 break;
2543 case P2P_PENDING_INVITATION_RESPONSE:
2544 p2p_invitation_resp_cb(p2p, success);
2545 break;
2546 case P2P_PENDING_DEV_DISC_REQUEST:
2547 p2p_dev_disc_req_cb(p2p, success);
2548 break;
2549 case P2P_PENDING_DEV_DISC_RESPONSE:
2550 p2p_dev_disc_resp_cb(p2p, success);
2551 break;
2552 case P2P_PENDING_GO_DISC_REQ:
2553 p2p_go_disc_req_cb(p2p, success);
2554 break;
2555 }
2556}
2557
2558
2559void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,
2560 unsigned int duration)
2561{
2562 if (freq == p2p->pending_client_disc_freq) {
2563 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2564 "P2P: Client discoverability remain-awake completed");
2565 p2p->pending_client_disc_freq = 0;
2566 return;
2567 }
2568
2569 if (freq != p2p->pending_listen_freq) {
2570 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2571 "P2P: Unexpected listen callback for freq=%u "
2572 "duration=%u (pending_listen_freq=%u)",
2573 freq, duration, p2p->pending_listen_freq);
2574 return;
2575 }
2576
2577 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2578 "P2P: Starting Listen timeout(%u,%u) on freq=%u based on "
2579 "callback",
2580 p2p->pending_listen_sec, p2p->pending_listen_usec,
2581 p2p->pending_listen_freq);
2582 p2p->in_listen = 1;
0b8889d8 2583 p2p->drv_in_listen = freq;
b22128ef
JM		 2584 if (p2p->pending_listen_sec || p2p->pending_listen_usec) {
2585 /*
2586 * Add 20 msec extra wait to avoid race condition with driver
2587 * remain-on-channel end event, i.e., give driver more time to
2588 * complete the operation before our timeout expires.
2589 */
2590 p2p_set_timeout(p2p, p2p->pending_listen_sec,
2591 p2p->pending_listen_usec + 20000);
2592 }
2593
2594 p2p->pending_listen_freq = 0;
2595}
2596
2597
2598int p2p_listen_end(struct p2p_data *p2p, unsigned int freq)
2599{
2600 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver ended Listen "
2601 "state (freq=%u)", freq);
2602 p2p->drv_in_listen = 0;
2603 if (p2p->in_listen)
2604 return 0; /* Internal timeout will trigger the next step */
2605
2606 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) {
e24cf97c
JM		 2607 if (p2p->go_neg_peer->connect_reqs >= 120) {
2608 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2609 "P2P: Timeout on sending GO Negotiation "
2610 "Request without getting response");
2611 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2612 return 0;
2613 }
2614
b22128ef
JM		 2615 p2p_set_state(p2p, P2P_CONNECT);
2616 p2p_connect_send(p2p, p2p->go_neg_peer);
2617 return 1;
2618 } else if (p2p->state == P2P_SEARCH) {
2619 p2p_search(p2p);
2620 return 1;
2621 }
2622
2623 return 0;
2624}
2625
2626
2627static void p2p_timeout_connect(struct p2p_data *p2p)
2628{
2629 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2630 p2p_set_state(p2p, P2P_CONNECT_LISTEN);
2631 p2p_listen_in_find(p2p);
2632}
2633
2634
2635static void p2p_timeout_connect_listen(struct p2p_data *p2p)
2636{
2637 if (p2p->go_neg_peer) {
2638 if (p2p->drv_in_listen) {
2639 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver is "
2640 "still in Listen state; wait for it to "
2641 "complete");
2642 return;
2643 }
9dac8c3e
FM		 2644
2645 if (p2p->go_neg_peer->connect_reqs >= 120) {
2646 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2647 "P2P: Timeout on sending GO Negotiation "
2648 "Request without getting response");
2649 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1);
2650 return;
2651 }
2652
b22128ef
JM		 2653 p2p_set_state(p2p, P2P_CONNECT);
2654 p2p_connect_send(p2p, p2p->go_neg_peer);
2655 } else
2656 p2p_set_state(p2p, P2P_IDLE);
2657}
2658
2659
2660static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p)
2661{
2662 /*
2663 * TODO: could remain constantly in Listen state for some time if there
2664 * are no other concurrent uses for the radio. For now, go to listen
2665 * state once per second to give other uses a chance to use the radio.
2666 */
2667 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
2668 p2p_set_timeout(p2p, 1, 0);
2669}
2670
2671
2672static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p)
2673{
2674 struct p2p_device *dev = p2p->go_neg_peer;
2675
2676 if (dev == NULL) {
2677 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2678 "P2P: Unknown GO Neg peer - stop GO Neg wait");
2679 return;
2680 }
2681
2682 dev->wait_count++;
2683 if (dev->wait_count >= 120) {
2684 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2685 "P2P: Timeout on waiting peer to become ready for GO "
2686 "Negotiation");
2687 p2p_go_neg_failed(p2p, dev, -1);
2688 return;
2689 }
2690
2691 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2692 "P2P: Go to Listen state while waiting for the peer to become "
2693 "ready for GO Negotiation");
2694 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);
2695 p2p_listen_in_find(p2p);
2696}
2697
2698
2699static void p2p_timeout_sd_during_find(struct p2p_data *p2p)
2700{
2701 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2702 "P2P: Service Discovery Query timeout");
2703 if (p2p->sd_peer) {
2704 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2705 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE;
2706 p2p->sd_peer = NULL;
2707 }
2708 p2p_continue_find(p2p);
2709}
2710
2711
2712static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p)
2713{
2714 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2715 "P2P: Provision Discovery Request timeout");
2716 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2717 p2p_continue_find(p2p);
2718}
2719
2720
6b56cc2d
JS		 2721static void p2p_timeout_prov_disc_req(struct p2p_data *p2p)
2722{
2723 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
2724
2725 /*
2726 * For user initiated PD requests that we have not gotten any responses
2727 * for while in IDLE state, we retry them a couple of times before
2728 * giving up.
2729 */
2730 if (!p2p->user_initiated_pd)
2731 return;
2732
2733 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2734 "P2P: User initiated Provision Discovery Request timeout");
2735
2736 if (p2p->pd_retries) {
2737 p2p->pd_retries--;
2738 p2p_retry_pd(p2p);
2739 } else {
349b213c
JS		 2740 if (p2p->cfg->prov_disc_fail)
2741 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx,
2742 p2p->pending_pd_devaddr,
2743 P2P_PROV_DISC_TIMEOUT);
6b56cc2d
JS		 2744 p2p_reset_pending_pd(p2p);
2745 }
2746}
2747
2748
b22128ef
JM		 2749static void p2p_timeout_invite(struct p2p_data *p2p)
2750{
2751 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
2752 p2p_set_state(p2p, P2P_INVITE_LISTEN);
04d8dad5
JM		 2753 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) {
2754 /*
2755 * Better remain on operating channel instead of listen channel
2756 * when running a group.
2757 */
2758 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Inviting in "
2759 "active GO role - wait on operating channel");
2760 p2p_set_timeout(p2p, 0, 100000);
2761 return;
2762 }
b22128ef
JM		 2763 p2p_listen_in_find(p2p);
2764}
2765
2766
2767static void p2p_timeout_invite_listen(struct p2p_data *p2p)
2768{
2769 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) {
2770 p2p_set_state(p2p, P2P_INVITE);
2771 p2p_invite_send(p2p, p2p->invite_peer,
2772 p2p->invite_go_dev_addr);
2773 } else {
2774 if (p2p->invite_peer) {
2775 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2776 "P2P: Invitation Request retry limit reached");
2777 if (p2p->cfg->invitation_result)
2778 p2p->cfg->invitation_result(
2779 p2p->cfg->cb_ctx, -1, NULL);
2780 }
2781 p2p_set_state(p2p, P2P_IDLE);
2782 }
2783}
2784
2785
2786static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx)
2787{
2788 struct p2p_data *p2p = eloop_ctx;
2789
2790 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Timeout (state=%s)",
2791 p2p_state_txt(p2p->state));
2792
2793 p2p->in_listen = 0;
2794
2795 switch (p2p->state) {
2796 case P2P_IDLE:
6b56cc2d
JS		 2797 /* Check if we timed out waiting for PD req */
2798 if (p2p->pending_action_state == P2P_PENDING_PD)
2799 p2p_timeout_prov_disc_req(p2p);
b22128ef
JM		 2800 break;
2801 case P2P_SEARCH:
6b56cc2d
JS		 2802 /* Check if we timed out waiting for PD req */
2803 if (p2p->pending_action_state == P2P_PENDING_PD)
2804 p2p_timeout_prov_disc_req(p2p);
b22128ef
JM		 2805 p2p_search(p2p);
2806 break;
2807 case P2P_CONNECT:
2808 p2p_timeout_connect(p2p);
2809 break;
2810 case P2P_CONNECT_LISTEN:
2811 p2p_timeout_connect_listen(p2p);
2812 break;
2813 case P2P_GO_NEG:
2814 break;
2815 case P2P_LISTEN_ONLY:
6b56cc2d
JS		 2816 /* Check if we timed out waiting for PD req */
2817 if (p2p->pending_action_state == P2P_PENDING_PD)
2818 p2p_timeout_prov_disc_req(p2p);
2819
b22128ef
JM		 2820 if (p2p->ext_listen_only) {
2821 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
2822 "P2P: Extended Listen Timing - Listen State "
2823 "completed");
2824 p2p->ext_listen_only = 0;
2825 p2p_set_state(p2p, P2P_IDLE);
2826 }
2827 break;
2828 case P2P_WAIT_PEER_CONNECT:
2829 p2p_timeout_wait_peer_connect(p2p);
2830 break;
2831 case P2P_WAIT_PEER_IDLE:
2832 p2p_timeout_wait_peer_idle(p2p);
2833 break;
2834 case P2P_SD_DURING_FIND:
2835 p2p_timeout_sd_during_find(p2p);
2836 break;
2837 case P2P_PROVISIONING:
2838 break;
2839 case P2P_PD_DURING_FIND:
2840 p2p_timeout_prov_disc_during_find(p2p);
2841 break;
2842 case P2P_INVITE:
2843 p2p_timeout_invite(p2p);
2844 break;
2845 case P2P_INVITE_LISTEN:
2846 p2p_timeout_invite_listen(p2p);
2847 break;
2848 }
2849}
2850
2851
2852int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr)
2853{
2854 struct p2p_device *dev;
2855
2856 dev = p2p_get_device(p2p, peer_addr);
2857 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Local request to reject "
2858 "connection attempts by peer " MACSTR, MAC2STR(peer_addr));
2859 if (dev == NULL) {
2860 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR
2861 " unknown", MAC2STR(peer_addr));
2862 return -1;
2863 }
2864 dev->status = P2P_SC_FAIL_REJECTED_BY_USER;
2865 dev->flags |= P2P_DEV_USER_REJECTED;
2866 return 0;
2867}
2868
2869
2870static const char * p2p_wps_method_text(enum p2p_wps_method method)
2871{
2872 switch (method) {
2873 case WPS_NOT_READY:
2874 return "not-ready";
2875 case WPS_PIN_LABEL:
2876 return "Label";
2877 case WPS_PIN_DISPLAY:
2878 return "Display";
2879 case WPS_PIN_KEYPAD:
2880 return "Keypad";
2881 case WPS_PBC:
2882 return "PBC";
2883 }
2884
2885 return "??";
2886}
2887
2888
2889static const char * p2p_go_state_text(enum p2p_go_state go_state)
2890{
2891 switch (go_state) {
2892 case UNKNOWN_GO:
2893 return "unknown";
2894 case LOCAL_GO:
2895 return "local";
2896 case REMOTE_GO:
2897 return "remote";
2898 }
2899
2900 return "??";
2901}
2902
2903
2904int p2p_get_peer_info(struct p2p_data *p2p, const u8 *addr, int next,
2905 char *buf, size_t buflen)
2906{
2907 struct p2p_device *dev;
2908 int res;
2909 char *pos, *end;
2910 struct os_time now;
2911 char devtype[WPS_DEV_TYPE_BUFSIZE];
2912
2913 if (addr)
2914 dev = p2p_get_device(p2p, addr);
2915 else
2916 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
2917
2918 if (dev && next) {
2919 dev = dl_list_first(&dev->list, struct p2p_device, list);
2920 if (&dev->list == &p2p->devices)
2921 dev = NULL;
2922 }
2923
2924 if (dev == NULL)
2925 return -1;
2926
2927 pos = buf;
2928 end = buf + buflen;
2929
2930 res = os_snprintf(pos, end - pos, MACSTR "\n",
c5db8e51 2931 MAC2STR(dev->info.p2p_device_addr));
b22128ef
JM		 2932 if (res < 0 || res >= end - pos)
2933 return pos - buf;
2934 pos += res;
2935
2936 os_get_time(&now);
2937 res = os_snprintf(pos, end - pos,
2938 "age=%d\n"
2939 "listen_freq=%d\n"
2940 "level=%d\n"
2941 "wps_method=%s\n"
2942 "interface_addr=" MACSTR "\n"
2943 "member_in_go_dev=" MACSTR "\n"
2944 "member_in_go_iface=" MACSTR "\n"
2945 "pri_dev_type=%s\n"
2946 "device_name=%s\n"
b67d0d9e
JM		 2947 "manufacturer=%s\n"
2948 "model_name=%s\n"
2949 "model_number=%s\n"
2950 "serial_number=%s\n"
b22128ef
JM		 2951 "config_methods=0x%x\n"
2952 "dev_capab=0x%x\n"
2953 "group_capab=0x%x\n"
2954 "go_neg_req_sent=%d\n"
2955 "go_state=%s\n"
2956 "dialog_token=%u\n"
2957 "intended_addr=" MACSTR "\n"
2958 "country=%c%c\n"
2959 "oper_freq=%d\n"
2960 "req_config_methods=0x%x\n"
10c4edde 2961 "flags=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n"
b22128ef
JM		 2962 "status=%d\n"
2963 "wait_count=%u\n"
2964 "invitation_reqs=%u\n",
2965 (int) (now.sec - dev->last_seen.sec),
2966 dev->listen_freq,
6402fc43 2967 dev->info.level,
b22128ef
JM		 2968 p2p_wps_method_text(dev->wps_method),
2969 MAC2STR(dev->interface_addr),
2970 MAC2STR(dev->member_in_go_dev),
2971 MAC2STR(dev->member_in_go_iface),
c5db8e51 2972 wps_dev_type_bin2str(dev->info.pri_dev_type,
b22128ef 2973 devtype, sizeof(devtype)),
c5db8e51 2974 dev->info.device_name,
b67d0d9e
JM		 2975 dev->info.manufacturer,
2976 dev->info.model_name,
2977 dev->info.model_number,
2978 dev->info.serial_number,
c5db8e51
KRK		 2979 dev->info.config_methods,
2980 dev->info.dev_capab,
2981 dev->info.group_capab,
b22128ef
JM		 2982 dev->go_neg_req_sent,
2983 p2p_go_state_text(dev->go_state),
2984 dev->dialog_token,
2985 MAC2STR(dev->intended_addr),
2986 dev->country[0] ? dev->country[0] : '_',
2987 dev->country[1] ? dev->country[1] : '_',
2988 dev->oper_freq,
2989 dev->req_config_methods,
2990 dev->flags & P2P_DEV_PROBE_REQ_ONLY ?
2991 "[PROBE_REQ_ONLY]" : "",
2992 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "",
2993 dev->flags & P2P_DEV_NOT_YET_READY ?
2994 "[NOT_YET_READY]" : "",
2995 dev->flags & P2P_DEV_SD_INFO ? "[SD_INFO]" : "",
2996 dev->flags & P2P_DEV_SD_SCHEDULE ? "[SD_SCHEDULE]" :
2997 "",
2998 dev->flags & P2P_DEV_PD_PEER_DISPLAY ?
2999 "[PD_PEER_DISPLAY]" : "",
3000 dev->flags & P2P_DEV_PD_PEER_KEYPAD ?
3001 "[PD_PEER_KEYPAD]" : "",
3002 dev->flags & P2P_DEV_USER_REJECTED ?
3003 "[USER_REJECTED]" : "",
3004 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ?
3005 "[PEER_WAITING_RESPONSE]" : "",
3006 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ?
3007 "[PREFER_PERSISTENT_GROUP]" : "",
3008 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ?
3009 "[WAIT_GO_NEG_RESPONSE]" : "",
3010 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ?
3011 "[WAIT_GO_NEG_CONFIRM]" : "",
3012 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ?
3013 "[GROUP_CLIENT_ONLY]" : "",
d5b20a73 3014 dev->flags & P2P_DEV_FORCE_FREQ ?
10c4edde
JM		 3015 "[FORCE_FREQ]" : "",
3016 dev->flags & P2P_DEV_PD_FOR_JOIN ?
3017 "[PD_FOR_JOIN]" : "",
b22128ef
JM		 3018 dev->status,
3019 dev->wait_count,
3020 dev->invitation_reqs);
3021 if (res < 0 || res >= end - pos)
3022 return pos - buf;
3023 pos += res;
3024
3025 if (dev->ext_listen_period) {
3026 res = os_snprintf(pos, end - pos,
3027 "ext_listen_period=%u\n"
3028 "ext_listen_interval=%u\n",
3029 dev->ext_listen_period,
3030 dev->ext_listen_interval);
3031 if (res < 0 || res >= end - pos)
3032 return pos - buf;
3033 pos += res;
3034 }
3035
3036 if (dev->oper_ssid_len) {
3037 res = os_snprintf(pos, end - pos,
3038 "oper_ssid=%s\n",
3039 wpa_ssid_txt(dev->oper_ssid,
3040 dev->oper_ssid_len));
3041 if (res < 0 || res >= end - pos)
3042 return pos - buf;
3043 pos += res;
3044 }
3045
3046 return pos - buf;
3047}
3048
3049
3050void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled)
3051{
3052 if (enabled) {
3053 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Client "
3054 "discoverability enabled");
3055 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3056 } else {
3057 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Client "
3058 "discoverability disabled");
3059 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
3060 }
3061}
3062
3063
3064static struct wpabuf * p2p_build_presence_req(u32 duration1, u32 interval1,
3065 u32 duration2, u32 interval2)
3066{
3067 struct wpabuf *req;
3068 struct p2p_noa_desc desc1, desc2, *ptr1 = NULL, *ptr2 = NULL;
3069 u8 *len;
3070
3071 req = wpabuf_alloc(100);
3072 if (req == NULL)
3073 return NULL;
3074
3075 if (duration1 || interval1) {
3076 os_memset(&desc1, 0, sizeof(desc1));
3077 desc1.count_type = 1;
3078 desc1.duration = duration1;
3079 desc1.interval = interval1;
3080 ptr1 = &desc1;
3081
3082 if (duration2 || interval2) {
3083 os_memset(&desc2, 0, sizeof(desc2));
3084 desc2.count_type = 2;
3085 desc2.duration = duration2;
3086 desc2.interval = interval2;
3087 ptr2 = &desc2;
3088 }
3089 }
3090
3091 p2p_buf_add_action_hdr(req, P2P_PRESENCE_REQ, 1);
3092 len = p2p_buf_add_ie_hdr(req);
3093 p2p_buf_add_noa(req, 0, 0, 0, ptr1, ptr2);
3094 p2p_buf_update_ie_hdr(req, len);
3095
3096 return req;
3097}
3098
3099
3100int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,
3101 const u8 *own_interface_addr, unsigned int freq,
3102 u32 duration1, u32 interval1, u32 duration2,
3103 u32 interval2)
3104{
3105 struct wpabuf *req;
3106
3107 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send Presence Request to "
3108 "GO " MACSTR " (own interface " MACSTR ") freq=%u dur1=%u "
3109 "int1=%u dur2=%u int2=%u",
3110 MAC2STR(go_interface_addr), MAC2STR(own_interface_addr),
3111 freq, duration1, interval1, duration2, interval2);
3112
3113 req = p2p_build_presence_req(duration1, interval1, duration2,
3114 interval2);
3115 if (req == NULL)
3116 return -1;
3117
3118 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3f9285ff
JM		 3119 if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr,
3120 go_interface_addr,
3121 wpabuf_head(req), wpabuf_len(req), 200) < 0) {
b22128ef
JM		 3122 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3123 "P2P: Failed to send Action frame");
3124 }
3125 wpabuf_free(req);
3126
3127 return 0;
3128}
3129
3130
3131static struct wpabuf * p2p_build_presence_resp(u8 status, const u8 *noa,
3132 size_t noa_len, u8 dialog_token)
3133{
3134 struct wpabuf *resp;
3135 u8 *len;
3136
3137 resp = wpabuf_alloc(100 + noa_len);
3138 if (resp == NULL)
3139 return NULL;
3140
3141 p2p_buf_add_action_hdr(resp, P2P_PRESENCE_RESP, dialog_token);
3142 len = p2p_buf_add_ie_hdr(resp);
3143 p2p_buf_add_status(resp, status);
3144 if (noa) {
3145 wpabuf_put_u8(resp, P2P_ATTR_NOTICE_OF_ABSENCE);
3146 wpabuf_put_le16(resp, noa_len);
3147 wpabuf_put_data(resp, noa, noa_len);
3148 } else
3149 p2p_buf_add_noa(resp, 0, 0, 0, NULL, NULL);
3150 p2p_buf_update_ie_hdr(resp, len);
3151
3152 return resp;
3153}
3154
3155
3156static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da,
3157 const u8 *sa, const u8 *data, size_t len,
3158 int rx_freq)
3159{
3160 struct p2p_message msg;
3161 u8 status;
3162 struct wpabuf *resp;
3163 size_t g;
3164 struct p2p_group *group = NULL;
3165 int parsed = 0;
3166 u8 noa[50];
3167 int noa_len;
3168
3169 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3170 "P2P: Received P2P Action - P2P Presence Request");
3171
3172 for (g = 0; g < p2p->num_groups; g++) {
3173 if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]),
3174 ETH_ALEN) == 0) {
3175 group = p2p->groups[g];
3176 break;
3177 }
3178 }
3179 if (group == NULL) {
3180 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3181 "P2P: Ignore P2P Presence Request for unknown group "
3182 MACSTR, MAC2STR(da));
3183 return;
3184 }
3185
3186 if (p2p_parse(data, len, &msg) < 0) {
3187 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3188 "P2P: Failed to parse P2P Presence Request");
3189 status = P2P_SC_FAIL_INVALID_PARAMS;
3190 goto fail;
3191 }
3192 parsed = 1;
3193
3194 if (msg.noa == NULL) {
3195 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3196 "P2P: No NoA attribute in P2P Presence Request");
3197 status = P2P_SC_FAIL_INVALID_PARAMS;
3198 goto fail;
3199 }
3200
3201 status = p2p_group_presence_req(group, sa, msg.noa, msg.noa_len);
3202
3203fail:
3204 if (p2p->cfg->get_noa)
3205 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa,
3206 sizeof(noa));
3207 else
3208 noa_len = -1;
3209 resp = p2p_build_presence_resp(status, noa_len > 0 ? noa : NULL,
3210 noa_len > 0 ? noa_len : 0,
3211 msg.dialog_token);
3212 if (parsed)
3213 p2p_parse_free(&msg);
3214 if (resp == NULL)
3215 return;
3216
3217 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
3f9285ff
JM		 3218 if (p2p_send_action(p2p, rx_freq, sa, da, da,
3219 wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
b22128ef
JM		 3220 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3221 "P2P: Failed to send Action frame");
3222 }
3223 wpabuf_free(resp);
3224}
3225
3226
3227static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da,
3228 const u8 *sa, const u8 *data, size_t len)
3229{
3230 struct p2p_message msg;
3231
3232 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3233 "P2P: Received P2P Action - P2P Presence Response");
3234
3235 if (p2p_parse(data, len, &msg) < 0) {
3236 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3237 "P2P: Failed to parse P2P Presence Response");
3238 return;
3239 }
3240
3241 if (msg.status == NULL || msg.noa == NULL) {
3242 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3243 "P2P: No Status or NoA attribute in P2P Presence "
3244 "Response");
3245 p2p_parse_free(&msg);
3246 return;
3247 }
3248
3249 if (*msg.status) {
3250 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3251 "P2P: P2P Presence Request was rejected: status %u",
3252 *msg.status);
3253 p2p_parse_free(&msg);
3254 return;
3255 }
3256
3257 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3258 "P2P: P2P Presence Request was accepted");
3259 wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA",
3260 msg.noa, msg.noa_len);
3261 /* TODO: process NoA */
3262 p2p_parse_free(&msg);
3263}
3264
3265
3266static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx)
3267{
3268 struct p2p_data *p2p = eloop_ctx;
3269
3270 if (p2p->ext_listen_interval) {
3271 /* Schedule next extended listen timeout */
3272 eloop_register_timeout(p2p->ext_listen_interval_sec,
3273 p2p->ext_listen_interval_usec,
3274 p2p_ext_listen_timeout, p2p, NULL);
3275 }
3276
f7a69057
JM		 3277 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) {
3278 /*
3279 * This should not really happen, but it looks like the Listen
3280 * command may fail is something else (e.g., a scan) was
3281 * running at an inconvenient time. As a workaround, allow new
3282 * Extended Listen operation to be started.
3283 */
3284 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Previous "
3285 "Extended Listen operation had not been completed - "
3286 "try again");
3287 p2p->ext_listen_only = 0;
3288 p2p_set_state(p2p, P2P_IDLE);
3289 }
3290
b22128ef
JM		 3291 if (p2p->state != P2P_IDLE) {
3292 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip Extended "
3293 "Listen timeout in active state (%s)",
3294 p2p_state_txt(p2p->state));
3295 return;
3296 }
3297
3298 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Extended Listen timeout");
3299 p2p->ext_listen_only = 1;
3300 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) {
3301 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Failed to start "
3302 "Listen state for Extended Listen Timing");
3303 p2p->ext_listen_only = 0;
3304 }
3305}
3306
3307
3308int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,
3309 unsigned int interval)
3310{
3311 if (period > 65535 || interval > 65535 || period > interval ||
3312 (period == 0 && interval > 0) || (period > 0 && interval == 0)) {
3313 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3314 "P2P: Invalid Extended Listen Timing request: "
3315 "period=%u interval=%u", period, interval);
3316 return -1;
3317 }
3318
3319 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL);
3320
3321 if (interval == 0) {
3322 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3323 "P2P: Disabling Extended Listen Timing");
3324 p2p->ext_listen_period = 0;
3325 p2p->ext_listen_interval = 0;
3326 return 0;
3327 }
3328
3329 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
3330 "P2P: Enabling Extended Listen Timing: period %u msec, "
3331 "interval %u msec", period, interval);
3332 p2p->ext_listen_period = period;
3333 p2p->ext_listen_interval = interval;
3334 p2p->ext_listen_interval_sec = interval / 1000;
3335 p2p->ext_listen_interval_usec = (interval % 1000) * 1000;
3336
3337 eloop_register_timeout(p2p->ext_listen_interval_sec,
3338 p2p->ext_listen_interval_usec,
3339 p2p_ext_listen_timeout, p2p, NULL);
3340
3341 return 0;
3342}
3343
3344
3345void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
3346 const u8 *ie, size_t ie_len)
3347{
3348 struct p2p_message msg;
3349
3350 if (bssid == NULL || ie == NULL)
3351 return;
3352
3353 os_memset(&msg, 0, sizeof(msg));
3354 if (p2p_parse_ies(ie, ie_len, &msg))
3355 return;
3356 if (msg.minor_reason_code == NULL)
3357 return;
3358
3359 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
3360 "P2P: Deauthentication notification BSSID " MACSTR
3361 " reason_code=%u minor_reason_code=%u",
3362 MAC2STR(bssid), reason_code, *msg.minor_reason_code);
3363
3364 p2p_parse_free(&msg);
3365}
3366
3367
3368void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
3369 const u8 *ie, size_t ie_len)
3370{
3371 struct p2p_message msg;
3372
3373 if (bssid == NULL || ie == NULL)
3374 return;
3375
3376 os_memset(&msg, 0, sizeof(msg));
3377 if (p2p_parse_ies(ie, ie_len, &msg))
3378 return;
3379 if (msg.minor_reason_code == NULL)
3380 return;
3381
3382 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
3383 "P2P: Disassociation notification BSSID " MACSTR
3384 " reason_code=%u minor_reason_code=%u",
3385 MAC2STR(bssid), reason_code, *msg.minor_reason_code);
3386
3387 p2p_parse_free(&msg);
3388}
3389
3390
3391void p2p_set_managed_oper(struct p2p_data *p2p, int enabled)
3392{
3393 if (enabled) {
3394 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Managed P2P "
3395 "Device operations enabled");
3396 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED;
3397 } else {
3398 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Managed P2P "
3399 "Device operations disabled");
3400 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED;
3401 }
3402}
3403
3404
3405int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel)
3406{
3407 if (p2p_channel_to_freq(p2p->cfg->country, reg_class, channel) < 0)
3408 return -1;
3409
3410 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Set Listen channel: "
3411 "reg_class %u channel %u", reg_class, channel);
3412 p2p->cfg->reg_class = reg_class;
3413 p2p->cfg->channel = channel;
3414
3415 return 0;
3416}
3417
3418
3419int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len)
3420{
3421 wpa_hexdump_ascii(MSG_DEBUG, "P2P: New SSID postfix", postfix, len);
3422 if (postfix == NULL) {
3423 p2p->cfg->ssid_postfix_len = 0;
3424 return 0;
3425 }
3426 if (len > sizeof(p2p->cfg->ssid_postfix))
3427 return -1;
3428 os_memcpy(p2p->cfg->ssid_postfix, postfix, len);
3429 p2p->cfg->ssid_postfix_len = len;
3430 return 0;
3431}
3432
3433
2463ba70
JS		 3434int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel,
3435 int cfg_op_channel)
3436{
3437 if (p2p_channel_to_freq(p2p->cfg->country, op_reg_class, op_channel)
3438 < 0)
3439 return -1;
3440
3441 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, "P2P: Set Operating channel: "
3442 "reg_class %u channel %u", op_reg_class, op_channel);
3443 p2p->cfg->op_reg_class = op_reg_class;
3444 p2p->cfg->op_channel = op_channel;
3445 p2p->cfg->cfg_op_channel = cfg_op_channel;
3446 return 0;
3447}
3448
3449
b22128ef
JM		 3450int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,
3451 u8 *iface_addr)
3452{
3453 struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
3454 if (dev == NULL || is_zero_ether_addr(dev->interface_addr))
3455 return -1;
3456 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN);
3457 return 0;
3458}
80c9582a
JM		 3459
3460
4147a2cc
JM		 3461int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,
3462 u8 *dev_addr)
3463{
3464 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
3465 if (dev == NULL)
3466 return -1;
c5db8e51 3467 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
4147a2cc
JM		 3468 return 0;
3469}
3470
3471
80c9582a
JM		 3472void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr)
3473{
3474 os_memcpy(p2p->peer_filter, addr, ETH_ALEN);
3475 if (is_zero_ether_addr(p2p->peer_filter))
3476 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Disable peer "
3477 "filter");
3478 else
3479 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Enable peer "
3480 "filter for " MACSTR, MAC2STR(p2p->peer_filter));
3481}
72044390
JM		 3482
3483
3484void p2p_set_cross_connect(struct p2p_data *p2p, int enabled)
3485{
3486 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Cross connection %s",
3487 enabled ? "enabled" : "disabled");
3488 if (p2p->cross_connect == enabled)
3489 return;
3490 p2p->cross_connect = enabled;
3491 /* TODO: may need to tear down any action group where we are GO(?) */
3492}
f8d0131a
JM		 3493
3494
3495int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr)
3496{
3497 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
3498 if (dev == NULL)
3499 return -1;
3500 if (dev->oper_freq <= 0)
3501 return -1;
3502 return dev->oper_freq;
3503}
0f66abd2
SS		 3504
3505
3506void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled)
3507{
3508 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Intra BSS distribution %s",
3509 enabled ? "enabled" : "disabled");
3510 p2p->cfg->p2p_intra_bss = enabled;
3511}
b5c9da8d
JM		 3512
3513
3514void p2p_update_channel_list(struct p2p_data *p2p, struct p2p_channels *chan)
3515{
3516 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update channel list");
3517 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels));
3518}
3f9285ff
JM		 3519
3520
3521int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
3522 const u8 *src, const u8 *bssid, const u8 *buf,
3523 size_t len, unsigned int wait_time)
3524{
3525 if (p2p->p2p_scan_running) {
3526 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Delay Action "
3527 "frame TX until p2p_scan completes");
3528 if (p2p->after_scan_tx) {
3529 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Dropped "
3530 "previous pending Action frame TX");
3531 os_free(p2p->after_scan_tx);
3532 }
3533 p2p->after_scan_tx = os_malloc(sizeof(*p2p->after_scan_tx) +
3534 len);
3535 if (p2p->after_scan_tx == NULL)
3536 return -1;
3537 p2p->after_scan_tx->freq = freq;
3538 os_memcpy(p2p->after_scan_tx->dst, dst, ETH_ALEN);
3539 os_memcpy(p2p->after_scan_tx->src, src, ETH_ALEN);
3540 os_memcpy(p2p->after_scan_tx->bssid, bssid, ETH_ALEN);
3541 p2p->after_scan_tx->len = len;
3542 p2p->after_scan_tx->wait_time = wait_time;
3543 os_memcpy(p2p->after_scan_tx + 1, buf, len);
3544 return 0;
3545 }
3546
3547 return p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid,
3548 buf, len, wait_time);
3549}
7cfc4ac3
AGS		 3550
3551
3552void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5,
3553 int freq_overall)
3554{
3555 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Best channel: 2.4 GHz: %d,"
3556 " 5 GHz: %d, overall: %d", freq_24, freq_5, freq_overall);
3557 p2p->best_freq_24 = freq_24;
3558 p2p->best_freq_5 = freq_5;
3559 p2p->best_freq_overall = freq_overall;
3560}
231bbd03
SS		 3561
3562
3563const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p)
3564{
3565 if (p2p == NULL || p2p->go_neg_peer == NULL)
3566 return NULL;
c5db8e51 3567 return p2p->go_neg_peer->info.p2p_device_addr;
231bbd03 3568}
c165d81e
JB		 3569
3570
3571const struct p2p_peer_info *
3572p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next)
3573{
3574 struct p2p_device *dev;
3575
3576 if (addr) {
3577 dev = p2p_get_device(p2p, addr);
3578 if (!dev)
3579 return NULL;
3580
3581 if (!next) {
3582 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
3583 return NULL;
3584
3585 return &dev->info;
3586 } else {
3587 do {
3588 dev = dl_list_first(&dev->list,
3589 struct p2p_device,
3590 list);
3591 if (&dev->list == &p2p->devices)
3592 return NULL;
3593 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY);
3594 }
3595 } else {
3596 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
3597 if (!dev)
3598 return NULL;
3599 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
3600 dev = dl_list_first(&dev->list,
3601 struct p2p_device,
3602 list);
3603 if (&dev->list == &p2p->devices)
3604 return NULL;
3605 }
3606 }
3607
3608 return &dev->info;
3609}
Unnamed repository; edit this file 'description' to name the repository.