1 /*
2 * Wi-Fi Direct - P2P provision discovery
3 * Copyright (c) 2009-2010, Atheros Communications
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10
11 #include "common.h"
12 #include "common/ieee802_11_defs.h"
13 #include "common/wpa_ctrl.h"
14 #include "wps/wps_defs.h"
15 #include "p2p_i.h"
16 #include "p2p.h"
17
18
19 /*
20 * Number of retries to attempt for provision discovery requests
21 * in case the peer is not listening.
22 */
23 #define MAX_PROV_DISC_REQ_RETRIES 120
24
25
p2p_build_wps_ie_config_methods(struct wpabuf * buf,u16 config_methods)26 static void p2p_build_wps_ie_config_methods(struct wpabuf *buf,
27 u16 config_methods)
28 {
29 u8 *len;
30 wpabuf_put_u8(buf, WLAN_EID_VENDOR_SPECIFIC);
31 len = wpabuf_put(buf, 1);
32 wpabuf_put_be32(buf, WPS_DEV_OUI_WFA);
33
34 /* Config Methods */
35 wpabuf_put_be16(buf, ATTR_CONFIG_METHODS);
36 wpabuf_put_be16(buf, 2);
37 wpabuf_put_be16(buf, config_methods);
38
39 p2p_buf_update_ie_hdr(buf, len);
40 }
41
42
p2ps_add_new_group_info(struct p2p_data * p2p,struct p2p_device * dev,struct wpabuf * buf)43 static void p2ps_add_new_group_info(struct p2p_data *p2p,
44 struct p2p_device *dev,
45 struct wpabuf *buf)
46 {
47 int found;
48 u8 intended_addr[ETH_ALEN];
49 u8 ssid[SSID_MAX_LEN];
50 size_t ssid_len;
51 int group_iface;
52 unsigned int force_freq;
53
54 if (!p2p->cfg->get_go_info)
55 return;
56
57 found = p2p->cfg->get_go_info(
58 p2p->cfg->cb_ctx, intended_addr, ssid,
59 &ssid_len, &group_iface, &force_freq);
60 if (found) {
61 if (force_freq > 0) {
62 p2p->p2ps_prov->force_freq = force_freq;
63 p2p->p2ps_prov->pref_freq = 0;
64
65 if (dev)
66 p2p_prepare_channel(p2p, dev, force_freq, 0, 0);
67 }
68 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr,
69 ssid, ssid_len);
70
71 if (group_iface)
72 p2p_buf_add_intended_addr(buf, p2p->intended_addr);
73 else
74 p2p_buf_add_intended_addr(buf, intended_addr);
75 } else {
76 if (!p2p->ssid_set) {
77 p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
78 p2p->ssid_set = 1;
79 }
80
81 /* Add pre-composed P2P Group ID */
82 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr,
83 p2p->ssid, p2p->ssid_len);
84
85 if (group_iface)
86 p2p_buf_add_intended_addr(
87 buf, p2p->intended_addr);
88 else
89 p2p_buf_add_intended_addr(
90 buf, p2p->cfg->dev_addr);
91 }
92 }
93
94
p2ps_add_pd_req_attrs(struct p2p_data * p2p,struct p2p_device * dev,struct wpabuf * buf,u16 config_methods)95 static void p2ps_add_pd_req_attrs(struct p2p_data *p2p, struct p2p_device *dev,
96 struct wpabuf *buf, u16 config_methods)
97 {
98 struct p2ps_provision *prov = p2p->p2ps_prov;
99 struct p2ps_feature_capab fcap = { prov->cpt_mask, 0 };
100 int shared_group = 0;
101 u8 ssid[SSID_MAX_LEN];
102 size_t ssid_len;
103 u8 go_dev_addr[ETH_ALEN];
104 u8 intended_addr[ETH_ALEN];
105 int follow_on_req_fail = prov->status >= 0 &&
106 prov->status != P2P_SC_SUCCESS_DEFERRED;
107
108 /* If we might be explicite group owner, add GO details */
109 if (!follow_on_req_fail &&
110 (prov->conncap & (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW)))
111 p2ps_add_new_group_info(p2p, dev, buf);
112
113 if (prov->status >= 0)
114 p2p_buf_add_status(buf, (u8) prov->status);
115 else
116 prov->method = config_methods;
117
118 if (!follow_on_req_fail) {
119 if (p2p->cfg->get_persistent_group) {
120 shared_group = p2p->cfg->get_persistent_group(
121 p2p->cfg->cb_ctx, dev->info.p2p_device_addr,
122 NULL, 0, go_dev_addr, ssid, &ssid_len,
123 intended_addr);
124 }
125
126 if (shared_group ||
127 (prov->conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_NEW))) {
128 bool is_6ghz_capab;
129
130 is_6ghz_capab = is_p2p_6ghz_capable(p2p) &&
131 p2p_is_peer_6ghz_capab(
132 p2p, dev->info.p2p_device_addr);
133 p2p_buf_add_channel_list(buf, p2p->cfg->country,
134 &p2p->channels, is_6ghz_capab);
135 }
136
137 if ((shared_group && !is_zero_ether_addr(intended_addr)) ||
138 (prov->conncap & (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW)))
139 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
140 p2p->op_reg_class,
141 p2p->op_channel);
142 }
143
144 if (prov->status < 0 && prov->info[0])
145 p2p_buf_add_session_info(buf, prov->info);
146
147 if (!follow_on_req_fail)
148 p2p_buf_add_connection_capability(buf, prov->conncap);
149
150 p2p_buf_add_advertisement_id(buf, prov->adv_id, prov->adv_mac);
151
152 if (!follow_on_req_fail) {
153 if (shared_group || prov->conncap == P2PS_SETUP_NEW ||
154 prov->conncap ==
155 (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW) ||
156 prov->conncap ==
157 (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT)) {
158 /* Add Config Timeout */
159 p2p_buf_add_config_timeout(buf, p2p->go_timeout,
160 p2p->client_timeout);
161 }
162
163 p2p_buf_add_listen_channel(buf, p2p->cfg->country,
164 p2p->cfg->reg_class,
165 p2p->cfg->channel);
166 }
167
168 p2p_buf_add_session_id(buf, prov->session_id, prov->session_mac);
169
170 p2p_buf_add_feature_capability(buf, sizeof(fcap), (const u8 *) &fcap);
171
172 if (shared_group) {
173 p2p_buf_add_persistent_group_info(buf, go_dev_addr,
174 ssid, ssid_len);
175 /* Add intended interface address if it is not added yet */
176 if ((prov->conncap == P2PS_SETUP_NONE ||
177 prov->conncap == P2PS_SETUP_CLIENT) &&
178 !is_zero_ether_addr(intended_addr))
179 p2p_buf_add_intended_addr(buf, intended_addr);
180 }
181 }
182
183
p2p_build_prov_disc_bootstrap_req(struct p2p_data * p2p,struct p2p_device * dev)184 static struct wpabuf * p2p_build_prov_disc_bootstrap_req(struct p2p_data *p2p,
185 struct p2p_device *dev)
186 {
187 struct wpabuf *buf;
188 u8 *len;
189 size_t cookie_len = 0;
190 const u8 *cookie = NULL;
191 u8 dialog_token = dev->dialog_token;
192 u8 group_capab;
193
194 buf = wpabuf_alloc(1000);
195 if (!buf)
196 return NULL;
197
198 p2p_dbg(p2p, "P2P2: Building bootstrapping PD Request");
199 p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
200
201 len = p2p_buf_add_ie_hdr(buf);
202
203 group_capab = 0;
204
205 if (p2p->num_groups) {
206 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER;
207 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) &&
208 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) &&
209 p2p->cross_connect)
210 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
211 }
212 if (p2p->cfg->p2p_intra_bss)
213 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
214
215 p2p_buf_add_capability(buf, p2p->dev_capab &
216 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
217 group_capab);
218 p2p_buf_add_device_info(buf, p2p, NULL);
219
220 if (dev->bootstrap_params) {
221 cookie = dev->bootstrap_params->cookie;
222 cookie_len = dev->bootstrap_params->cookie_len;
223
224 if (dev->bootstrap_params->status == P2P_SC_COMEBACK)
225 p2p_buf_add_status(buf, dev->bootstrap_params->status);
226 }
227
228 p2p_buf_update_ie_hdr(buf, len);
229
230 len = p2p_buf_add_p2p2_ie_hdr(buf);
231
232 p2p_buf_add_pcea(buf, p2p);
233 p2p_buf_add_pbma(buf, dev->req_bootstrap_method, cookie, cookie_len, 0);
234
235 p2p_buf_update_ie_hdr(buf, len);
236
237 wpa_printf(MSG_DEBUG, "P2P2: Added PCEA and PBMA in PD Request");
238 return buf;
239 }
240
241
p2p_build_prov_disc_req(struct p2p_data * p2p,struct p2p_device * dev,int join)242 static struct wpabuf * p2p_build_prov_disc_req(struct p2p_data *p2p,
243 struct p2p_device *dev,
244 int join)
245 {
246 struct wpabuf *buf;
247 u8 *len;
248 size_t extra = 0;
249 u8 dialog_token = dev->dialog_token;
250 u16 config_methods = dev->req_config_methods;
251 struct p2p_device *go = join ? dev : NULL;
252 u8 group_capab;
253
254 #ifdef CONFIG_WIFI_DISPLAY
255 if (p2p->wfd_ie_prov_disc_req)
256 extra = wpabuf_len(p2p->wfd_ie_prov_disc_req);
257 #endif /* CONFIG_WIFI_DISPLAY */
258
259 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
260 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
261
262 if (p2p->p2ps_prov)
263 extra += os_strlen(p2p->p2ps_prov->info) + 1 +
264 sizeof(struct p2ps_provision);
265
266 buf = wpabuf_alloc(1000 + extra);
267 if (buf == NULL)
268 return NULL;
269
270 p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
271
272 len = p2p_buf_add_ie_hdr(buf);
273
274 group_capab = 0;
275 if (p2p->p2ps_prov) {
276 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
277 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_RECONN;
278 if (p2p->cross_connect)
279 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
280 if (p2p->cfg->p2p_intra_bss)
281 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
282 }
283 p2p_buf_add_capability(buf, p2p->dev_capab &
284 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
285 group_capab);
286 p2p_buf_add_device_info(buf, p2p, NULL);
287 if (p2p->p2ps_prov) {
288 p2ps_add_pd_req_attrs(p2p, dev, buf, config_methods);
289 } else if (go) {
290 p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
291 go->oper_ssid, go->oper_ssid_len);
292 }
293 p2p_buf_update_ie_hdr(buf, len);
294
295 /* WPS IE with Config Methods attribute */
296 p2p_build_wps_ie_config_methods(buf, config_methods);
297
298 #ifdef CONFIG_WIFI_DISPLAY
299 if (p2p->wfd_ie_prov_disc_req)
300 wpabuf_put_buf(buf, p2p->wfd_ie_prov_disc_req);
301 #endif /* CONFIG_WIFI_DISPLAY */
302
303 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
304 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
305
306 return buf;
307 }
308
309
310 static struct wpabuf *
p2p_build_prov_disc_bootstrap_resp(struct p2p_data * p2p,struct p2p_device * dev,u8 dialog_token,enum p2p_status_code status)311 p2p_build_prov_disc_bootstrap_resp(struct p2p_data *p2p, struct p2p_device *dev,
312 u8 dialog_token, enum p2p_status_code status)
313 {
314 struct wpabuf *buf;
315 u8 *cookie = NULL;
316 size_t cookie_len = 0;
317 int comeback_after = 0;
318 u8 *len;
319
320 buf = wpabuf_alloc(1000);
321 if (!buf)
322 return NULL;
323
324 p2p_dbg(p2p, "P2P2: Building boostrapping PD Response");
325 if (status == P2P_SC_COMEBACK && dev->bootstrap_params) {
326 cookie = dev->bootstrap_params->cookie;
327 cookie_len = dev->bootstrap_params->cookie_len;
328 comeback_after = dev->bootstrap_params->comeback_after;
329 }
330
331 p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
332
333 len = p2p_buf_add_p2p2_ie_hdr(buf);
334
335 p2p_buf_add_status(buf, status);
336 p2p_buf_add_pcea(buf, p2p);
337 p2p_buf_add_pbma(buf, dev->req_bootstrap_method, cookie, cookie_len,
338 comeback_after);
339
340 p2p_buf_update_ie_hdr(buf, len);
341
342 return buf;
343 }
344
345
p2p_build_prov_disc_resp(struct p2p_data * p2p,struct p2p_device * dev,u8 dialog_token,enum p2p_status_code status,u16 config_methods,u32 adv_id,const u8 * group_id,size_t group_id_len,const u8 * persist_ssid,size_t persist_ssid_len,const u8 * fcap,u16 fcap_len)346 static struct wpabuf * p2p_build_prov_disc_resp(struct p2p_data *p2p,
347 struct p2p_device *dev,
348 u8 dialog_token,
349 enum p2p_status_code status,
350 u16 config_methods,
351 u32 adv_id,
352 const u8 *group_id,
353 size_t group_id_len,
354 const u8 *persist_ssid,
355 size_t persist_ssid_len,
356 const u8 *fcap,
357 u16 fcap_len)
358 {
359 struct wpabuf *buf;
360 size_t extra = 0;
361 int persist = 0;
362
363 #ifdef CONFIG_WIFI_DISPLAY
364 struct wpabuf *wfd_ie = p2p->wfd_ie_prov_disc_resp;
365 if (wfd_ie && group_id) {
366 size_t i;
367 for (i = 0; i < p2p->num_groups; i++) {
368 struct p2p_group *g = p2p->groups[i];
369 struct wpabuf *ie;
370 if (!p2p_group_is_group_id_match(g, group_id,
371 group_id_len))
372 continue;
373 ie = p2p_group_get_wfd_ie(g);
374 if (ie) {
375 wfd_ie = ie;
376 break;
377 }
378 }
379 }
380 if (wfd_ie)
381 extra = wpabuf_len(wfd_ie);
382 #endif /* CONFIG_WIFI_DISPLAY */
383
384 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
385 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
386
387 buf = wpabuf_alloc(1000 + extra);
388 if (buf == NULL)
389 return NULL;
390
391 p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
392
393 /* Add P2P IE for P2PS */
394 if (p2p->p2ps_prov && p2p->p2ps_prov->adv_id == adv_id) {
395 u8 *len = p2p_buf_add_ie_hdr(buf);
396 struct p2ps_provision *prov = p2p->p2ps_prov;
397 u8 group_capab;
398 u8 conncap = 0;
399
400 if (status == P2P_SC_SUCCESS ||
401 status == P2P_SC_SUCCESS_DEFERRED)
402 conncap = prov->conncap;
403
404 if (!status && prov->status != -1)
405 status = prov->status;
406
407 p2p_buf_add_status(buf, status);
408 group_capab = P2P_GROUP_CAPAB_PERSISTENT_GROUP |
409 P2P_GROUP_CAPAB_PERSISTENT_RECONN;
410 if (p2p->cross_connect)
411 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
412 if (p2p->cfg->p2p_intra_bss)
413 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
414 p2p_buf_add_capability(buf, p2p->dev_capab &
415 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
416 group_capab);
417 p2p_buf_add_device_info(buf, p2p, NULL);
418
419 if (persist_ssid && p2p->cfg->get_persistent_group && dev &&
420 (status == P2P_SC_SUCCESS ||
421 status == P2P_SC_SUCCESS_DEFERRED)) {
422 u8 ssid[SSID_MAX_LEN];
423 size_t ssid_len;
424 u8 go_dev_addr[ETH_ALEN];
425 u8 intended_addr[ETH_ALEN];
426
427 persist = p2p->cfg->get_persistent_group(
428 p2p->cfg->cb_ctx,
429 dev->info.p2p_device_addr,
430 persist_ssid, persist_ssid_len, go_dev_addr,
431 ssid, &ssid_len, intended_addr);
432 if (persist) {
433 p2p_buf_add_persistent_group_info(
434 buf, go_dev_addr, ssid, ssid_len);
435 if (!is_zero_ether_addr(intended_addr))
436 p2p_buf_add_intended_addr(
437 buf, intended_addr);
438 }
439 }
440
441 if (!persist && (conncap & P2PS_SETUP_GROUP_OWNER))
442 p2ps_add_new_group_info(p2p, dev, buf);
443
444 /* Add Operating Channel if conncap indicates GO */
445 if (persist || (conncap & P2PS_SETUP_GROUP_OWNER)) {
446 if (p2p->op_reg_class && p2p->op_channel)
447 p2p_buf_add_operating_channel(
448 buf, p2p->cfg->country,
449 p2p->op_reg_class,
450 p2p->op_channel);
451 else
452 p2p_buf_add_operating_channel(
453 buf, p2p->cfg->country,
454 p2p->cfg->op_reg_class,
455 p2p->cfg->op_channel);
456 }
457
458 if (persist ||
459 (conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER))) {
460 bool is_6ghz_capab;
461
462 is_6ghz_capab = is_p2p_6ghz_capable(p2p) && dev &&
463 p2p_is_peer_6ghz_capab(
464 p2p, dev->info.p2p_device_addr);
465 p2p_buf_add_channel_list(buf, p2p->cfg->country,
466 &p2p->channels, is_6ghz_capab);
467 }
468
469 if (!persist && conncap)
470 p2p_buf_add_connection_capability(buf, conncap);
471
472 p2p_buf_add_advertisement_id(buf, adv_id, prov->adv_mac);
473
474 if (persist ||
475 (conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER)))
476 p2p_buf_add_config_timeout(buf, p2p->go_timeout,
477 p2p->client_timeout);
478
479 p2p_buf_add_session_id(buf, prov->session_id,
480 prov->session_mac);
481
482 p2p_buf_add_feature_capability(buf, fcap_len, fcap);
483 p2p_buf_update_ie_hdr(buf, len);
484 } else if (status != P2P_SC_SUCCESS || adv_id) {
485 u8 *len = p2p_buf_add_ie_hdr(buf);
486
487 p2p_buf_add_status(buf, status);
488
489 if (p2p->p2ps_prov)
490 p2p_buf_add_advertisement_id(buf, adv_id,
491 p2p->p2ps_prov->adv_mac);
492
493 p2p_buf_update_ie_hdr(buf, len);
494 }
495
496 /* WPS IE with Config Methods attribute */
497 p2p_build_wps_ie_config_methods(buf, config_methods);
498
499 #ifdef CONFIG_WIFI_DISPLAY
500 if (wfd_ie)
501 wpabuf_put_buf(buf, wfd_ie);
502 #endif /* CONFIG_WIFI_DISPLAY */
503
504 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
505 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
506
507 return buf;
508 }
509
510
p2ps_setup_p2ps_prov(struct p2p_data * p2p,u32 adv_id,u32 session_id,u16 method,const u8 * session_mac,const u8 * adv_mac)511 static int p2ps_setup_p2ps_prov(struct p2p_data *p2p, u32 adv_id,
512 u32 session_id, u16 method,
513 const u8 *session_mac, const u8 *adv_mac)
514 {
515 struct p2ps_provision *tmp;
516
517 if (!p2p->p2ps_prov) {
518 p2p->p2ps_prov = os_zalloc(sizeof(struct p2ps_provision) + 1);
519 if (!p2p->p2ps_prov)
520 return -1;
521 } else {
522 os_memset(p2p->p2ps_prov, 0, sizeof(struct p2ps_provision) + 1);
523 }
524
525 tmp = p2p->p2ps_prov;
526 tmp->adv_id = adv_id;
527 tmp->session_id = session_id;
528 tmp->method = method;
529 os_memcpy(tmp->session_mac, session_mac, ETH_ALEN);
530 os_memcpy(tmp->adv_mac, adv_mac, ETH_ALEN);
531 tmp->info[0] = '\0';
532
533 return 0;
534 }
535
536
p2ps_own_preferred_cpt(const u8 * cpt_priority,u8 req_cpt_mask)537 static u8 p2ps_own_preferred_cpt(const u8 *cpt_priority, u8 req_cpt_mask)
538 {
539 int i;
540
541 for (i = 0; cpt_priority[i]; i++)
542 if (req_cpt_mask & cpt_priority[i])
543 return cpt_priority[i];
544
545 return 0;
546 }
547
548
549 /* Check if the message contains a valid P2PS PD Request */
p2ps_validate_pd_req(struct p2p_data * p2p,struct p2p_message * msg,const u8 * addr)550 static int p2ps_validate_pd_req(struct p2p_data *p2p, struct p2p_message *msg,
551 const u8 *addr)
552 {
553 u8 group_id = 0;
554 u8 intended_addr = 0;
555 u8 operating_channel = 0;
556 u8 channel_list = 0;
557 u8 config_timeout = 0;
558 u8 listen_channel = 0;
559
560 #define P2PS_PD_REQ_CHECK(_val, _attr) \
561 do { \
562 if ((_val) && !msg->_attr) { \
563 p2p_dbg(p2p, "Not P2PS PD Request. Missing %s", #_attr); \
564 return -1; \
565 } \
566 } while (0)
567
568 P2PS_PD_REQ_CHECK(1, adv_id);
569 P2PS_PD_REQ_CHECK(1, session_id);
570 P2PS_PD_REQ_CHECK(1, session_mac);
571 P2PS_PD_REQ_CHECK(1, adv_mac);
572 P2PS_PD_REQ_CHECK(1, capability);
573 P2PS_PD_REQ_CHECK(1, p2p_device_info);
574 P2PS_PD_REQ_CHECK(1, feature_cap);
575
576 /*
577 * We don't need to check Connection Capability, Persistent Group,
578 * and related attributes for follow-on PD Request with a status
579 * other than SUCCESS_DEFERRED.
580 */
581 if (msg->status && *msg->status != P2P_SC_SUCCESS_DEFERRED)
582 return 0;
583
584 P2PS_PD_REQ_CHECK(1, conn_cap);
585
586 /*
587 * Note 1: A feature capability attribute structure can be changed
588 * in the future. The assumption is that such modifications are
589 * backward compatible, therefore we allow processing of msg.feature_cap
590 * exceeding the size of the p2ps_feature_capab structure.
591 * Note 2: Verification of msg.feature_cap_len below has to be changed
592 * to allow 2 byte feature capability processing if
593 * struct p2ps_feature_capab is extended to include additional fields
594 * and it affects the structure size.
595 */
596 if (msg->feature_cap_len < sizeof(struct p2ps_feature_capab)) {
597 p2p_dbg(p2p, "P2PS: Invalid feature capability len");
598 return -1;
599 }
600
601 switch (*msg->conn_cap) {
602 case P2PS_SETUP_NEW:
603 group_id = 1;
604 intended_addr = 1;
605 operating_channel = 1;
606 channel_list = 1;
607 config_timeout = 1;
608 listen_channel = 1;
609 break;
610 case P2PS_SETUP_CLIENT:
611 channel_list = 1;
612 listen_channel = 1;
613 break;
614 case P2PS_SETUP_GROUP_OWNER:
615 group_id = 1;
616 intended_addr = 1;
617 operating_channel = 1;
618 break;
619 case P2PS_SETUP_NEW | P2PS_SETUP_GROUP_OWNER:
620 group_id = 1;
621 operating_channel = 1;
622 intended_addr = 1;
623 channel_list = 1;
624 config_timeout = 1;
625 break;
626 case P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER:
627 group_id = 1;
628 intended_addr = 1;
629 operating_channel = 1;
630 channel_list = 1;
631 config_timeout = 1;
632 break;
633 default:
634 p2p_dbg(p2p, "Invalid P2PS PD connection capability");
635 return -1;
636 }
637
638 if (msg->persistent_dev) {
639 channel_list = 1;
640 config_timeout = 1;
641 if (ether_addr_equal(msg->persistent_dev, addr)) {
642 intended_addr = 1;
643 operating_channel = 1;
644 }
645 }
646
647 P2PS_PD_REQ_CHECK(group_id, group_id);
648 P2PS_PD_REQ_CHECK(intended_addr, intended_addr);
649 P2PS_PD_REQ_CHECK(operating_channel, operating_channel);
650 P2PS_PD_REQ_CHECK(channel_list, channel_list);
651 P2PS_PD_REQ_CHECK(config_timeout, config_timeout);
652 P2PS_PD_REQ_CHECK(listen_channel, listen_channel);
653
654 #undef P2PS_PD_REQ_CHECK
655
656 return 0;
657 }
658
659
p2p_process_pcea(struct p2p_data * p2p,struct p2p_message * msg,struct p2p_device * dev)660 void p2p_process_pcea(struct p2p_data *p2p, struct p2p_message *msg,
661 struct p2p_device *dev)
662 {
663 const u8 *pos, *end;
664 u8 cap_info_len;
665
666 if (!p2p || !dev || !msg || !msg->pcea_info)
667 return;
668
669 pos = msg->pcea_info;
670 end = pos + msg->pcea_info_len;
671 dev->info.pcea_cap_info = WPA_GET_LE16(pos);
672 cap_info_len = dev->info.pcea_cap_info & P2P_PCEA_LEN_MASK;
673
674 /* Field length is (n-1), n in octets */
675 if (end - pos < cap_info_len + 1)
676 return;
677 pos += cap_info_len + 1;
678
679 if (dev->info.pcea_cap_info & P2P_PCEA_6GHZ)
680 dev->support_6ghz = true;
681
682 if (dev->info.pcea_cap_info & P2P_PCEA_REG_INFO) {
683 if (end - pos < 1) {
684 p2p_dbg(p2p, "Truncated PCEA");
685 return;
686 }
687 dev->info.reg_info = *pos++;
688 }
689
690 if (dev->info.pcea_cap_info & P2P_PCEA_PASN_TYPE) {
691 if (end - pos < 1) {
692 p2p_dbg(p2p, "Truncated PCEA");
693 return;
694 }
695 dev->info.pairing_config.pasn_type = *pos++;
696 }
697
698 if (dev->info.pcea_cap_info & P2P_PCEA_PAIRING_CAPABLE)
699 dev->info.pairing_config.pairing_capable = true;
700
701 if (dev->info.pcea_cap_info & P2P_PCEA_PAIRING_SETUP_ENABLED)
702 dev->info.pairing_config.enable_pairing_setup = true;
703
704 if (dev->info.pcea_cap_info & P2P_PCEA_PMK_CACHING) {
705 dev->info.pairing_config.enable_pairing_cache = true;
706 }
707 }
708
709
p2p_process_prov_disc_bootstrap_req(struct p2p_data * p2p,struct p2p_message * msg,const u8 * sa,const u8 * data,size_t len,int rx_freq)710 static void p2p_process_prov_disc_bootstrap_req(struct p2p_data *p2p,
711 struct p2p_message *msg,
712 const u8 *sa, const u8 *data,
713 size_t len, int rx_freq)
714 {
715 struct p2p_device *dev;
716 int freq;
717 struct wpabuf *resp;
718 u16 bootstrap;
719 size_t cookie_len = 0;
720 const u8 *pos, *cookie;
721 enum p2p_status_code status = P2P_SC_FAIL_INVALID_PARAMS;
722
723 p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
724 " with bootstrapping Attribute (freq=%d)",
725 MAC2STR(sa), rx_freq);
726
727 dev = p2p_get_device(p2p, sa);
728 if (!dev) {
729 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
730 MACSTR, MAC2STR(sa));
731
732 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data, len, 0)) {
733 p2p_dbg(p2p,
734 "Provision Discovery Request add device failed "
735 MACSTR, MAC2STR(sa));
736 return;
737 }
738
739 dev = p2p_get_device(p2p, sa);
740 if (!dev) {
741 p2p_dbg(p2p,
742 "Provision Discovery device not found "
743 MACSTR, MAC2STR(sa));
744 return;
745 }
746 }
747 dev->p2p2 = true;
748
749 if (p2p->send_action_in_progress) {
750 p2p_dbg(p2p, "Dropping retry frame as response TX pending");
751 return;
752 }
753
754 p2p_update_peer_6ghz_capab(dev, msg);
755
756 if (msg->pcea_info && msg->pcea_info_len >= 2)
757 p2p_process_pcea(p2p, msg, dev);
758
759 pos = msg->pbma_info;
760
761 if (msg->pbma_info_len > 2 && msg->status &&
762 *msg->status == P2P_SC_COMEBACK) {
763 /* PBMA comeback request */
764 cookie_len = *pos++;
765 if (msg->pbma_info_len < 1 + cookie_len) {
766 p2p_dbg(p2p, "Truncated PBMA");
767 return;
768 }
769 cookie = pos;
770
771 if (!dev->bootstrap_params ||
772 dev->bootstrap_params->cookie_len != cookie_len ||
773 os_memcmp(cookie, dev->bootstrap_params->cookie,
774 cookie_len) != 0) {
775 status = P2P_SC_FAIL_REJECTED_BY_USER;
776 goto out;
777 }
778
779 bootstrap = dev->bootstrap_params->bootstrap_method;
780
781 if (!dev->req_bootstrap_method) {
782 status = P2P_SC_COMEBACK;
783 goto out;
784 }
785 } else {
786 /* PBMA request */
787 bootstrap = WPA_GET_LE16(pos);
788
789 os_free(dev->bootstrap_params);
790 dev->bootstrap_params = NULL;
791
792 if (!dev->req_bootstrap_method) {
793 dev->bootstrap_params =
794 os_zalloc(sizeof(struct p2p_bootstrap_params));
795 if (!dev->bootstrap_params)
796 return;
797 dev->bootstrap_params->bootstrap_method = bootstrap;
798 dev->bootstrap_params->cookie_len = 4;
799 if (os_get_random(dev->bootstrap_params->cookie,
800 dev->bootstrap_params->cookie_len) <
801 0) {
802 os_free(dev->bootstrap_params);
803 dev->bootstrap_params = NULL;
804 return;
805 }
806 dev->bootstrap_params->comeback_after =
807 p2p->cfg->comeback_after;
808 status = P2P_SC_COMEBACK;
809 if (p2p->cfg->bootstrap_req_rx)
810 p2p->cfg->bootstrap_req_rx(p2p->cfg->cb_ctx,
811 sa, bootstrap);
812 goto out;
813 }
814 }
815
816 if (bootstrap == P2P_PBMA_PIN_CODE_DISPLAY &&
817 dev->req_bootstrap_method == P2P_PBMA_PIN_CODE_KEYPAD)
818 status = P2P_SC_SUCCESS;
819 else if (bootstrap == P2P_PBMA_PIN_CODE_KEYPAD &&
820 dev->req_bootstrap_method == P2P_PBMA_PIN_CODE_DISPLAY)
821 status = P2P_SC_SUCCESS;
822 else if (bootstrap == P2P_PBMA_PASSPHRASE_DISPLAY &&
823 dev->req_bootstrap_method == P2P_PBMA_PASSPHRASE_KEYPAD)
824 status = P2P_SC_SUCCESS;
825 else if (bootstrap == P2P_PBMA_PASSPHRASE_KEYPAD &&
826 dev->req_bootstrap_method == P2P_PBMA_PASSPHRASE_DISPLAY)
827 status = P2P_SC_SUCCESS;
828 else if (bootstrap == P2P_PBMA_NFC_TAG &&
829 dev->req_bootstrap_method == P2P_PBMA_NFC_READER)
830 status = P2P_SC_SUCCESS;
831 else if (bootstrap == P2P_PBMA_NFC_READER &&
832 dev->req_bootstrap_method == P2P_PBMA_NFC_TAG)
833 status = P2P_SC_SUCCESS;
834 else if (bootstrap == P2P_PBMA_QR_DISPLAY &&
835 dev->req_bootstrap_method == P2P_PBMA_QR_SCAN)
836 status = P2P_SC_SUCCESS;
837 else if (bootstrap == P2P_PBMA_QR_SCAN &&
838 dev->req_bootstrap_method == P2P_PBMA_QR_DISPLAY)
839 status = P2P_SC_SUCCESS;
840 else if (bootstrap == P2P_PBMA_OPPORTUNISTIC &&
841 dev->req_bootstrap_method == P2P_PBMA_OPPORTUNISTIC)
842 status = P2P_SC_SUCCESS;
843 else
844 status = P2P_SC_FAIL_INVALID_PARAMS;
845
846 wpa_printf(MSG_ERROR, "Bootstrap received %d", bootstrap);
847
848 if (status == P2P_SC_SUCCESS) {
849 dev->role = P2P_ROLE_PAIRING_RESPONDER;
850 #ifdef CONFIG_PASN
851 p2p_pasn_initialize(p2p, dev, sa, rx_freq, false, true);
852 #endif /* CONFIG_PASN */
853 }
854 out:
855 /* Send PD Bootstrapping Response for the PD Request */
856 resp = p2p_build_prov_disc_bootstrap_resp(p2p, dev, msg->dialog_token,
857 status);
858 if (!resp)
859 return;
860
861 p2p_dbg(p2p, "Sending Provision Discovery Bootstrap Response");
862 if (rx_freq > 0)
863 freq = rx_freq;
864 else
865 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
866 p2p->cfg->channel);
867 if (freq < 0) {
868 p2p_dbg(p2p, "Unknown operating class/channel");
869 wpabuf_free(resp);
870 return;
871 }
872 p2p->pending_action_state = P2P_PENDING_PD_RESPONSE;
873 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
874 p2p->cfg->dev_addr, wpabuf_head(resp),
875 wpabuf_len(resp), 50) < 0)
876 p2p_dbg(p2p, "Failed to send Action frame");
877 else
878 p2p->send_action_in_progress = 1;
879
880 wpabuf_free(resp);
881 }
882
883
p2p_process_prov_disc_req(struct p2p_data * p2p,struct p2p_message * msg,const u8 * sa,const u8 * data,size_t len,int rx_freq)884 static void p2p_process_prov_disc_req(struct p2p_data *p2p,
885 struct p2p_message *msg, const u8 *sa,
886 const u8 *data, size_t len, int rx_freq)
887 {
888 struct p2p_device *dev;
889 int freq;
890 enum p2p_status_code reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
891 struct wpabuf *resp;
892 u32 adv_id = 0;
893 struct p2ps_advertisement *p2ps_adv = NULL;
894 u8 conncap = P2PS_SETUP_NEW;
895 u8 auto_accept = 0;
896 u32 session_id = 0;
897 u8 session_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
898 u8 adv_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
899 const u8 *group_mac;
900 int passwd_id = DEV_PW_DEFAULT;
901 u16 config_methods;
902 u16 allowed_config_methods = WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD;
903 struct p2ps_feature_capab resp_fcap = { 0, 0 };
904 struct p2ps_feature_capab *req_fcap = NULL;
905 u8 remote_conncap;
906 u16 method;
907
908 p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
909 " with config methods 0x%x (freq=%d)",
910 MAC2STR(sa), msg->wps_config_methods, rx_freq);
911 group_mac = msg->intended_addr;
912
913 dev = p2p_get_device(p2p, sa);
914 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
915 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
916 MACSTR, MAC2STR(sa));
917
918 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data, len, 0)) {
919 p2p_dbg(p2p, "Provision Discovery Request add device failed "
920 MACSTR, MAC2STR(sa));
921 goto out;
922 }
923
924 dev = p2p_get_device(p2p, sa);
925 if (!dev) {
926 p2p_dbg(p2p,
927 "Provision Discovery device not found "
928 MACSTR, MAC2STR(sa));
929 goto out;
930 }
931 } else if (msg->wfd_subelems) {
932 wpabuf_free(dev->info.wfd_subelems);
933 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
934 }
935
936 p2p_update_peer_6ghz_capab(dev, msg);
937
938 if (!msg->adv_id) {
939 allowed_config_methods |= WPS_CONFIG_PUSHBUTTON;
940 if (!(msg->wps_config_methods & allowed_config_methods)) {
941 p2p_dbg(p2p,
942 "Unsupported Config Methods in Provision Discovery Request");
943 goto out;
944 }
945
946 /* Legacy (non-P2PS) - Unknown groups allowed for P2PS */
947 if (msg->group_id) {
948 size_t i;
949
950 for (i = 0; i < p2p->num_groups; i++) {
951 if (p2p_group_is_group_id_match(
952 p2p->groups[i],
953 msg->group_id, msg->group_id_len))
954 break;
955 }
956 if (i == p2p->num_groups) {
957 p2p_dbg(p2p,
958 "PD request for unknown P2P Group ID - reject");
959 goto out;
960 }
961 }
962 } else {
963 allowed_config_methods |= WPS_CONFIG_P2PS;
964
965 /*
966 * Set adv_id here, so in case of an error, a P2PS PD Response
967 * will be sent.
968 */
969 adv_id = WPA_GET_LE32(msg->adv_id);
970 if (p2ps_validate_pd_req(p2p, msg, sa) < 0) {
971 reject = P2P_SC_FAIL_INVALID_PARAMS;
972 goto out;
973 }
974
975 req_fcap = (struct p2ps_feature_capab *) msg->feature_cap;
976
977 os_memcpy(session_mac, msg->session_mac, ETH_ALEN);
978 os_memcpy(adv_mac, msg->adv_mac, ETH_ALEN);
979
980 session_id = WPA_GET_LE32(msg->session_id);
981
982 if (msg->conn_cap)
983 conncap = *msg->conn_cap;
984
985 /*
986 * We need to verify a P2PS config methog in an initial PD
987 * request or in a follow-on PD request with the status
988 * SUCCESS_DEFERRED.
989 */
990 if ((!msg->status || *msg->status == P2P_SC_SUCCESS_DEFERRED) &&
991 !(msg->wps_config_methods & allowed_config_methods)) {
992 p2p_dbg(p2p,
993 "Unsupported Config Methods in Provision Discovery Request");
994 goto out;
995 }
996
997 /*
998 * TODO: since we don't support multiple PD, reject PD request
999 * if we are in the middle of P2PS PD with some other peer
1000 */
1001 }
1002
1003 dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
1004 P2P_DEV_PD_PEER_KEYPAD |
1005 P2P_DEV_PD_PEER_P2PS);
1006
1007 if (msg->wps_config_methods & WPS_CONFIG_DISPLAY) {
1008 p2p_dbg(p2p, "Peer " MACSTR
1009 " requested us to show a PIN on display", MAC2STR(sa));
1010 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
1011 passwd_id = DEV_PW_USER_SPECIFIED;
1012 } else if (msg->wps_config_methods & WPS_CONFIG_KEYPAD) {
1013 p2p_dbg(p2p, "Peer " MACSTR
1014 " requested us to write its PIN using keypad",
1015 MAC2STR(sa));
1016 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
1017 passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
1018 } else if (msg->wps_config_methods & WPS_CONFIG_P2PS) {
1019 p2p_dbg(p2p, "Peer " MACSTR " requesting P2PS PIN",
1020 MAC2STR(sa));
1021 dev->flags |= P2P_DEV_PD_PEER_P2PS;
1022 passwd_id = DEV_PW_P2PS_DEFAULT;
1023 }
1024
1025 /* Remove stale persistent groups */
1026 if (p2p->cfg->remove_stale_groups) {
1027 p2p->cfg->remove_stale_groups(
1028 p2p->cfg->cb_ctx, dev->info.p2p_device_addr,
1029 msg->persistent_dev,
1030 msg->persistent_ssid, msg->persistent_ssid_len);
1031 }
1032
1033 reject = P2P_SC_SUCCESS;
1034
1035 /*
1036 * End of a legacy P2P PD Request processing, from this point continue
1037 * with P2PS one.
1038 */
1039 if (!msg->adv_id)
1040 goto out;
1041
1042 remote_conncap = conncap;
1043
1044 if (!msg->status) {
1045 unsigned int forced_freq, pref_freq;
1046
1047 if (!ether_addr_equal(p2p->cfg->dev_addr, msg->adv_mac)) {
1048 p2p_dbg(p2p,
1049 "P2PS PD adv mac does not match the local one");
1050 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1051 goto out;
1052 }
1053
1054 p2ps_adv = p2p_service_p2ps_id(p2p, adv_id);
1055 if (!p2ps_adv) {
1056 p2p_dbg(p2p, "P2PS PD invalid adv_id=0x%X", adv_id);
1057 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1058 goto out;
1059 }
1060 p2p_dbg(p2p, "adv_id: 0x%X, p2ps_adv: %p", adv_id, p2ps_adv);
1061
1062 auto_accept = p2ps_adv->auto_accept;
1063 conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
1064 conncap, auto_accept,
1065 &forced_freq,
1066 &pref_freq);
1067
1068 p2p_dbg(p2p, "Conncap: local:%d remote:%d result:%d",
1069 auto_accept, remote_conncap, conncap);
1070
1071 p2p_prepare_channel(p2p, dev, forced_freq, pref_freq, 0);
1072
1073 resp_fcap.cpt = p2ps_own_preferred_cpt(p2ps_adv->cpt_priority,
1074 req_fcap->cpt);
1075
1076 p2p_dbg(p2p, "cpt: service:0x%x remote:0x%x result:0x%x",
1077 p2ps_adv->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
1078
1079 if (!resp_fcap.cpt) {
1080 p2p_dbg(p2p,
1081 "Incompatible P2PS feature capability CPT bitmask");
1082 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1083 } else if (p2ps_adv->config_methods &&
1084 !(msg->wps_config_methods &
1085 p2ps_adv->config_methods)) {
1086 p2p_dbg(p2p,
1087 "Unsupported config methods in Provision Discovery Request (own=0x%x peer=0x%x)",
1088 p2ps_adv->config_methods,
1089 msg->wps_config_methods);
1090 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1091 } else if (!p2ps_adv->state) {
1092 p2p_dbg(p2p, "P2PS state unavailable");
1093 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1094 } else if (!conncap) {
1095 p2p_dbg(p2p, "Conncap resolution failed");
1096 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1097 }
1098
1099 if (msg->wps_config_methods & WPS_CONFIG_KEYPAD) {
1100 p2p_dbg(p2p, "Keypad - always defer");
1101 auto_accept = 0;
1102 }
1103
1104 if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
1105 msg->persistent_dev) && conncap != P2PS_SETUP_NEW &&
1106 msg->channel_list && msg->channel_list_len &&
1107 p2p_peer_channels_check(p2p, &p2p->channels, dev,
1108 msg->channel_list,
1109 msg->channel_list_len) < 0) {
1110 p2p_dbg(p2p,
1111 "No common channels - force deferred flow");
1112 auto_accept = 0;
1113 }
1114
1115 if (((remote_conncap & P2PS_SETUP_GROUP_OWNER) ||
1116 msg->persistent_dev) && msg->operating_channel) {
1117 struct p2p_channels intersect;
1118
1119 /*
1120 * There are cases where only the operating channel is
1121 * provided. This requires saving the channel as the
1122 * supported channel list, and verifying that it is
1123 * supported.
1124 */
1125 if (dev->channels.reg_classes == 0 ||
1126 !p2p_channels_includes(&dev->channels,
1127 msg->operating_channel[3],
1128 msg->operating_channel[4])) {
1129 struct p2p_channels *ch = &dev->channels;
1130
1131 os_memset(ch, 0, sizeof(*ch));
1132 ch->reg_class[0].reg_class =
1133 msg->operating_channel[3];
1134 ch->reg_class[0].channel[0] =
1135 msg->operating_channel[4];
1136 ch->reg_class[0].channels = 1;
1137 ch->reg_classes = 1;
1138 }
1139
1140 p2p_channels_intersect(&p2p->channels, &dev->channels,
1141 &intersect);
1142
1143 if (intersect.reg_classes == 0) {
1144 p2p_dbg(p2p,
1145 "No common channels - force deferred flow");
1146 auto_accept = 0;
1147 }
1148 }
1149
1150 if (auto_accept || reject != P2P_SC_SUCCESS) {
1151 struct p2ps_provision *tmp;
1152
1153 if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
1154 msg->wps_config_methods,
1155 session_mac, adv_mac) < 0) {
1156 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1157 goto out;
1158 }
1159
1160 tmp = p2p->p2ps_prov;
1161 tmp->force_freq = forced_freq;
1162 tmp->pref_freq = pref_freq;
1163 if (conncap) {
1164 tmp->conncap = conncap;
1165 tmp->status = P2P_SC_SUCCESS;
1166 } else {
1167 tmp->conncap = auto_accept;
1168 tmp->status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1169 }
1170
1171 if (reject != P2P_SC_SUCCESS)
1172 goto out;
1173 }
1174 }
1175
1176 if (!msg->status && !auto_accept &&
1177 (!p2p->p2ps_prov || p2p->p2ps_prov->adv_id != adv_id)) {
1178 struct p2ps_provision *tmp;
1179
1180 if (!conncap) {
1181 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1182 goto out;
1183 }
1184
1185 if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
1186 msg->wps_config_methods,
1187 session_mac, adv_mac) < 0) {
1188 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1189 goto out;
1190 }
1191 tmp = p2p->p2ps_prov;
1192 reject = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
1193 tmp->status = reject;
1194 }
1195
1196 /* Not a P2PS Follow-on PD */
1197 if (!msg->status)
1198 goto out;
1199
1200 if (*msg->status && *msg->status != P2P_SC_SUCCESS_DEFERRED) {
1201 reject = *msg->status;
1202 goto out;
1203 }
1204
1205 if (*msg->status != P2P_SC_SUCCESS_DEFERRED || !p2p->p2ps_prov)
1206 goto out;
1207
1208 if (p2p->p2ps_prov->adv_id != adv_id ||
1209 !ether_addr_equal(p2p->p2ps_prov->adv_mac, msg->adv_mac)) {
1210 p2p_dbg(p2p,
1211 "P2PS Follow-on PD with mismatch Advertisement ID/MAC");
1212 goto out;
1213 }
1214
1215 if (p2p->p2ps_prov->session_id != session_id ||
1216 !ether_addr_equal(p2p->p2ps_prov->session_mac, msg->session_mac)) {
1217 p2p_dbg(p2p, "P2PS Follow-on PD with mismatch Session ID/MAC");
1218 goto out;
1219 }
1220
1221 method = p2p->p2ps_prov->method;
1222
1223 conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
1224 remote_conncap,
1225 p2p->p2ps_prov->conncap,
1226 &p2p->p2ps_prov->force_freq,
1227 &p2p->p2ps_prov->pref_freq);
1228
1229 resp_fcap.cpt = p2ps_own_preferred_cpt(p2p->p2ps_prov->cpt_priority,
1230 req_fcap->cpt);
1231
1232 p2p_dbg(p2p, "cpt: local:0x%x remote:0x%x result:0x%x",
1233 p2p->p2ps_prov->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
1234
1235 p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
1236 p2p->p2ps_prov->pref_freq, 0);
1237
1238 /*
1239 * Ensure that if we asked for PIN originally, our method is consistent
1240 * with original request.
1241 */
1242 if (method & WPS_CONFIG_DISPLAY)
1243 method = WPS_CONFIG_KEYPAD;
1244 else if (method & WPS_CONFIG_KEYPAD)
1245 method = WPS_CONFIG_DISPLAY;
1246
1247 if (!conncap || !(msg->wps_config_methods & method)) {
1248 /*
1249 * Reject this "Deferred Accept*
1250 * if incompatible conncap or method
1251 */
1252 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1253 } else if (!resp_fcap.cpt) {
1254 p2p_dbg(p2p,
1255 "Incompatible P2PS feature capability CPT bitmask");
1256 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1257 } else if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
1258 msg->persistent_dev) && conncap != P2PS_SETUP_NEW &&
1259 msg->channel_list && msg->channel_list_len &&
1260 p2p_peer_channels_check(p2p, &p2p->channels, dev,
1261 msg->channel_list,
1262 msg->channel_list_len) < 0) {
1263 p2p_dbg(p2p,
1264 "No common channels in Follow-On Provision Discovery Request");
1265 reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
1266 } else {
1267 reject = P2P_SC_SUCCESS;
1268 }
1269
1270 dev->oper_freq = 0;
1271 if (reject == P2P_SC_SUCCESS || reject == P2P_SC_SUCCESS_DEFERRED) {
1272 u8 tmp;
1273
1274 if (msg->operating_channel)
1275 dev->oper_freq =
1276 p2p_channel_to_freq(msg->operating_channel[3],
1277 msg->operating_channel[4]);
1278
1279 if ((conncap & P2PS_SETUP_GROUP_OWNER) &&
1280 p2p_go_select_channel(p2p, dev, &tmp) < 0)
1281 reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
1282 }
1283
1284 p2p->p2ps_prov->status = reject;
1285 p2p->p2ps_prov->conncap = conncap;
1286
1287 out:
1288 if (reject == P2P_SC_SUCCESS ||
1289 reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1290 config_methods = msg->wps_config_methods;
1291 else
1292 config_methods = 0;
1293
1294 /*
1295 * Send PD Response for an initial PD Request or for follow-on
1296 * PD Request with P2P_SC_SUCCESS_DEFERRED status.
1297 */
1298 if (!msg->status || *msg->status == P2P_SC_SUCCESS_DEFERRED) {
1299 resp = p2p_build_prov_disc_resp(p2p, dev, msg->dialog_token,
1300 reject, config_methods, adv_id,
1301 msg->group_id,
1302 msg->group_id_len,
1303 msg->persistent_ssid,
1304 msg->persistent_ssid_len,
1305 (const u8 *) &resp_fcap,
1306 sizeof(resp_fcap));
1307 if (!resp)
1308 return;
1309
1310 p2p_dbg(p2p, "Sending Provision Discovery Response");
1311 if (rx_freq > 0)
1312 freq = rx_freq;
1313 else
1314 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
1315 p2p->cfg->channel);
1316 if (freq < 0) {
1317 p2p_dbg(p2p, "Unknown regulatory class/channel");
1318 wpabuf_free(resp);
1319 return;
1320 }
1321 p2p->pending_action_state = P2P_PENDING_PD_RESPONSE;
1322 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
1323 p2p->cfg->dev_addr,
1324 wpabuf_head(resp), wpabuf_len(resp),
1325 50) < 0)
1326 p2p_dbg(p2p, "Failed to send Action frame");
1327 else
1328 p2p->send_action_in_progress = 1;
1329
1330 wpabuf_free(resp);
1331 }
1332
1333 if (!dev)
1334 return;
1335
1336 freq = 0;
1337 if (reject == P2P_SC_SUCCESS && conncap == P2PS_SETUP_GROUP_OWNER) {
1338 freq = p2p_channel_to_freq(p2p->op_reg_class,
1339 p2p->op_channel);
1340 if (freq < 0)
1341 freq = 0;
1342 }
1343
1344 if (!p2p->cfg->p2ps_prov_complete) {
1345 /* Don't emit anything */
1346 } else if (msg->status && *msg->status != P2P_SC_SUCCESS &&
1347 *msg->status != P2P_SC_SUCCESS_DEFERRED) {
1348 reject = *msg->status;
1349 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1350 sa, adv_mac, session_mac,
1351 NULL, adv_id, session_id,
1352 0, 0, msg->persistent_ssid,
1353 msg->persistent_ssid_len,
1354 0, 0, NULL, NULL, 0, freq,
1355 NULL, 0);
1356 } else if (msg->status && *msg->status == P2P_SC_SUCCESS_DEFERRED &&
1357 p2p->p2ps_prov) {
1358 p2p->p2ps_prov->status = reject;
1359 p2p->p2ps_prov->conncap = conncap;
1360
1361 if (reject != P2P_SC_SUCCESS)
1362 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1363 sa, adv_mac, session_mac,
1364 NULL, adv_id,
1365 session_id, conncap, 0,
1366 msg->persistent_ssid,
1367 msg->persistent_ssid_len,
1368 0, 0, NULL, NULL, 0, freq,
1369 NULL, 0);
1370 else
1371 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx,
1372 *msg->status,
1373 sa, adv_mac, session_mac,
1374 group_mac, adv_id,
1375 session_id, conncap,
1376 passwd_id,
1377 msg->persistent_ssid,
1378 msg->persistent_ssid_len,
1379 0, 0, NULL,
1380 (const u8 *) &resp_fcap,
1381 sizeof(resp_fcap), freq,
1382 NULL, 0);
1383 } else if (msg->status && p2p->p2ps_prov) {
1384 p2p->p2ps_prov->status = P2P_SC_SUCCESS;
1385 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, *msg->status, sa,
1386 adv_mac, session_mac, group_mac,
1387 adv_id, session_id, conncap,
1388 passwd_id,
1389 msg->persistent_ssid,
1390 msg->persistent_ssid_len,
1391 0, 0, NULL,
1392 (const u8 *) &resp_fcap,
1393 sizeof(resp_fcap), freq, NULL, 0);
1394 } else if (msg->status) {
1395 } else if (auto_accept && reject == P2P_SC_SUCCESS) {
1396 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1397 sa, adv_mac, session_mac,
1398 group_mac, adv_id, session_id,
1399 conncap, passwd_id,
1400 msg->persistent_ssid,
1401 msg->persistent_ssid_len,
1402 0, 0, NULL,
1403 (const u8 *) &resp_fcap,
1404 sizeof(resp_fcap), freq,
1405 msg->group_id ?
1406 msg->group_id + ETH_ALEN : NULL,
1407 msg->group_id ?
1408 msg->group_id_len - ETH_ALEN : 0);
1409 } else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1410 (!msg->session_info || !msg->session_info_len)) {
1411 p2p->p2ps_prov->method = msg->wps_config_methods;
1412
1413 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1414 sa, adv_mac, session_mac,
1415 group_mac, adv_id, session_id,
1416 conncap, passwd_id,
1417 msg->persistent_ssid,
1418 msg->persistent_ssid_len,
1419 0, 1, NULL,
1420 (const u8 *) &resp_fcap,
1421 sizeof(resp_fcap), freq, NULL, 0);
1422 } else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1423 size_t buf_len = msg->session_info_len;
1424 char *buf = os_malloc(2 * buf_len + 1);
1425
1426 if (buf) {
1427 p2p->p2ps_prov->method = msg->wps_config_methods;
1428
1429 utf8_escape((char *) msg->session_info, buf_len,
1430 buf, 2 * buf_len + 1);
1431
1432 p2p->cfg->p2ps_prov_complete(
1433 p2p->cfg->cb_ctx, P2P_SC_SUCCESS, sa,
1434 adv_mac, session_mac, group_mac, adv_id,
1435 session_id, conncap, passwd_id,
1436 msg->persistent_ssid, msg->persistent_ssid_len,
1437 0, 1, buf,
1438 (const u8 *) &resp_fcap, sizeof(resp_fcap),
1439 freq, NULL, 0);
1440
1441 os_free(buf);
1442 }
1443 }
1444
1445 /*
1446 * prov_disc_req callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1447 * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1448 * Call it either on legacy P2P PD or on P2PS PD only if we need to
1449 * enter/show PIN.
1450 *
1451 * The callback is called in the following cases:
1452 * 1. Legacy P2P PD request, response status SUCCESS
1453 * 2. P2PS advertiser, method: DISPLAY, autoaccept: TRUE,
1454 * response status: SUCCESS
1455 * 3. P2PS advertiser, method DISPLAY, autoaccept: FALSE,
1456 * response status: INFO_CURRENTLY_UNAVAILABLE
1457 * 4. P2PS advertiser, method: KEYPAD, autoaccept==any,
1458 * response status: INFO_CURRENTLY_UNAVAILABLE
1459 * 5. P2PS follow-on with SUCCESS_DEFERRED,
1460 * advertiser role: DISPLAY, autoaccept: FALSE,
1461 * seeker: KEYPAD, response status: SUCCESS
1462 */
1463 if (p2p->cfg->prov_disc_req &&
1464 ((reject == P2P_SC_SUCCESS && !msg->adv_id) ||
1465 (!msg->status &&
1466 (reject == P2P_SC_SUCCESS ||
1467 reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) &&
1468 passwd_id == DEV_PW_USER_SPECIFIED) ||
1469 (!msg->status &&
1470 reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1471 passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1472 (reject == P2P_SC_SUCCESS &&
1473 msg->status && *msg->status == P2P_SC_SUCCESS_DEFERRED &&
1474 passwd_id == DEV_PW_REGISTRAR_SPECIFIED))) {
1475 const u8 *dev_addr = sa;
1476
1477 if (msg->p2p_device_addr)
1478 dev_addr = msg->p2p_device_addr;
1479 p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
1480 msg->wps_config_methods,
1481 dev_addr, msg->pri_dev_type,
1482 msg->device_name, msg->config_methods,
1483 msg->capability ? msg->capability[0] :
1484 0,
1485 msg->capability ? msg->capability[1] :
1486 0,
1487 msg->group_id, msg->group_id_len);
1488 }
1489
1490 if (reject != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1491 p2ps_prov_free(p2p);
1492
1493 if (reject == P2P_SC_SUCCESS) {
1494 switch (config_methods) {
1495 case WPS_CONFIG_DISPLAY:
1496 dev->wps_prov_info = WPS_CONFIG_KEYPAD;
1497 break;
1498 case WPS_CONFIG_KEYPAD:
1499 dev->wps_prov_info = WPS_CONFIG_DISPLAY;
1500 break;
1501 case WPS_CONFIG_PUSHBUTTON:
1502 dev->wps_prov_info = WPS_CONFIG_PUSHBUTTON;
1503 break;
1504 case WPS_CONFIG_P2PS:
1505 dev->wps_prov_info = WPS_CONFIG_P2PS;
1506 break;
1507 default:
1508 dev->wps_prov_info = 0;
1509 break;
1510 }
1511
1512 if (msg->intended_addr)
1513 os_memcpy(dev->interface_addr, msg->intended_addr,
1514 ETH_ALEN);
1515 }
1516 }
1517
1518
p2p_handle_prov_disc_req(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)1519 void p2p_handle_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
1520 const u8 *data, size_t len, int rx_freq)
1521 {
1522 struct p2p_message msg;
1523
1524 if (p2p_parse(data, len, &msg))
1525 return;
1526
1527 if (msg.pcea_info && msg.pbma_info)
1528 p2p_process_prov_disc_bootstrap_req(p2p, &msg, sa, data + 1,
1529 len - 1, rx_freq);
1530 else
1531 p2p_process_prov_disc_req(p2p, &msg, sa, data + 1, len - 1,
1532 rx_freq);
1533
1534 p2p_parse_free(&msg);
1535 }
1536
1537
p2p_validate_p2ps_pd_resp(struct p2p_data * p2p,struct p2p_message * msg)1538 static int p2p_validate_p2ps_pd_resp(struct p2p_data *p2p,
1539 struct p2p_message *msg)
1540 {
1541 u8 conn_cap_go = 0;
1542 u8 conn_cap_cli = 0;
1543 u32 session_id;
1544 u32 adv_id;
1545
1546 #define P2PS_PD_RESP_CHECK(_val, _attr) \
1547 do { \
1548 if ((_val) && !msg->_attr) { \
1549 p2p_dbg(p2p, "P2PS PD Response missing " #_attr); \
1550 return -1; \
1551 } \
1552 } while (0)
1553
1554 P2PS_PD_RESP_CHECK(1, status);
1555 P2PS_PD_RESP_CHECK(1, adv_id);
1556 P2PS_PD_RESP_CHECK(1, adv_mac);
1557 P2PS_PD_RESP_CHECK(1, capability);
1558 P2PS_PD_RESP_CHECK(1, p2p_device_info);
1559 P2PS_PD_RESP_CHECK(1, session_id);
1560 P2PS_PD_RESP_CHECK(1, session_mac);
1561 P2PS_PD_RESP_CHECK(1, feature_cap);
1562
1563 session_id = WPA_GET_LE32(msg->session_id);
1564 adv_id = WPA_GET_LE32(msg->adv_id);
1565
1566 if (p2p->p2ps_prov->session_id != session_id) {
1567 p2p_dbg(p2p,
1568 "Ignore PD Response with unexpected Session ID");
1569 return -1;
1570 }
1571
1572 if (!ether_addr_equal(p2p->p2ps_prov->session_mac, msg->session_mac)) {
1573 p2p_dbg(p2p,
1574 "Ignore PD Response with unexpected Session MAC");
1575 return -1;
1576 }
1577
1578 if (p2p->p2ps_prov->adv_id != adv_id) {
1579 p2p_dbg(p2p,
1580 "Ignore PD Response with unexpected Advertisement ID");
1581 return -1;
1582 }
1583
1584 if (!ether_addr_equal(p2p->p2ps_prov->adv_mac, msg->adv_mac)) {
1585 p2p_dbg(p2p,
1586 "Ignore PD Response with unexpected Advertisement MAC");
1587 return -1;
1588 }
1589
1590 if (msg->listen_channel) {
1591 p2p_dbg(p2p,
1592 "Ignore malformed PD Response - unexpected Listen Channel");
1593 return -1;
1594 }
1595
1596 if (*msg->status == P2P_SC_SUCCESS &&
1597 !(!!msg->conn_cap ^ !!msg->persistent_dev)) {
1598 p2p_dbg(p2p,
1599 "Ignore malformed PD Response - either conn_cap or persistent group should be present");
1600 return -1;
1601 }
1602
1603 if (msg->persistent_dev && *msg->status != P2P_SC_SUCCESS) {
1604 p2p_dbg(p2p,
1605 "Ignore malformed PD Response - persistent group is present, but the status isn't success");
1606 return -1;
1607 }
1608
1609 if (msg->conn_cap) {
1610 conn_cap_go = *msg->conn_cap == P2PS_SETUP_GROUP_OWNER;
1611 conn_cap_cli = *msg->conn_cap == P2PS_SETUP_CLIENT;
1612 }
1613
1614 P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1615 channel_list);
1616 P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1617 config_timeout);
1618
1619 P2PS_PD_RESP_CHECK(conn_cap_go, group_id);
1620 P2PS_PD_RESP_CHECK(conn_cap_go, intended_addr);
1621 P2PS_PD_RESP_CHECK(conn_cap_go, operating_channel);
1622 /*
1623 * TODO: Also validate that operating channel is present if the device
1624 * is a GO in a persistent group. We can't do it here since we don't
1625 * know what is the role of the peer. It should be probably done in
1626 * p2ps_prov_complete callback, but currently operating channel isn't
1627 * passed to it.
1628 */
1629
1630 #undef P2PS_PD_RESP_CHECK
1631
1632 return 0;
1633 }
1634
1635
p2p_process_prov_disc_bootstrap_resp(struct p2p_data * p2p,struct p2p_message * msg,const u8 * sa,const u8 * data,size_t len,int rx_freq)1636 static void p2p_process_prov_disc_bootstrap_resp(struct p2p_data *p2p,
1637 struct p2p_message *msg,
1638 const u8 *sa, const u8 *data,
1639 size_t len, int rx_freq)
1640 {
1641 struct p2p_device *dev;
1642 enum p2p_status_code status = P2P_SC_SUCCESS;
1643 size_t cookie_len = 0;
1644 const u8 *pos, *cookie;
1645 u16 comeback_after;
1646 u16 bootstrap = 0;
1647
1648 /* Parse the P2P status present */
1649 if (msg->status)
1650 status = *msg->status;
1651
1652 p2p_dbg(p2p, "Received Provision Discovery Bootstrap Response from "
1653 MACSTR, MAC2STR(sa));
1654
1655 dev = p2p_get_device(p2p, sa);
1656 if (!dev || !dev->req_bootstrap_method) {
1657 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
1658 " with no pending request", MAC2STR(sa));
1659 return;
1660 }
1661
1662 p2p_update_peer_6ghz_capab(dev, msg);
1663
1664 if (dev->dialog_token != msg->dialog_token) {
1665 p2p_dbg(p2p,
1666 "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
1667 msg->dialog_token, dev->dialog_token);
1668 return;
1669 }
1670
1671 if (p2p->pending_action_state == P2P_PENDING_PD) {
1672 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1673 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1674 }
1675
1676 os_free(dev->bootstrap_params);
1677 dev->bootstrap_params = NULL;
1678
1679 /* If the response is from the peer to whom a user initiated request
1680 * was sent earlier, we reset that state information here. */
1681 if (p2p->user_initiated_pd &&
1682 ether_addr_equal(p2p->pending_pd_devaddr, sa))
1683 p2p_reset_pending_pd(p2p);
1684
1685 if (status == P2P_SC_COMEBACK) {
1686 /* PBMA comeback response */
1687 pos = msg->pbma_info;
1688 if (msg->pbma_info_len < 2 + 1)
1689 return;
1690 comeback_after = WPA_GET_LE16(pos);
1691 pos += 2;
1692 cookie_len = *pos++;
1693 if (msg->pbma_info_len < 2 + 1 + cookie_len) {
1694 p2p_dbg(p2p, "Truncated PBMA");
1695 return;
1696 }
1697 cookie = pos;
1698
1699 dev->bootstrap_params =
1700 os_zalloc(sizeof(struct p2p_bootstrap_params));
1701 if (!dev->bootstrap_params)
1702 return;
1703 dev->bootstrap_params->cookie_len = cookie_len;
1704 os_memcpy(dev->bootstrap_params->cookie, cookie, cookie_len);
1705 dev->bootstrap_params->comeback_after = comeback_after;
1706 dev->bootstrap_params->bootstrap_method =
1707 dev->req_bootstrap_method;
1708 dev->bootstrap_params->status = status;
1709
1710 p2p->cfg->register_bootstrap_comeback(p2p->cfg->cb_ctx, sa,
1711 comeback_after);
1712 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1713
1714 if (p2p->cfg->bootstrap_rsp_rx)
1715 p2p->cfg->bootstrap_rsp_rx(p2p->cfg->cb_ctx, sa, status,
1716 rx_freq, bootstrap);
1717 return;
1718 }
1719
1720 /* PBMA response */
1721 if (msg->pbma_info_len >= 2)
1722 bootstrap = WPA_GET_LE16(msg->pbma_info);
1723
1724 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1725 if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG)
1726 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1727
1728 if (p2p->cfg->bootstrap_rsp_rx)
1729 p2p->cfg->bootstrap_rsp_rx(p2p->cfg->cb_ctx, sa, status,
1730 rx_freq, bootstrap);
1731 }
1732
1733
p2p_process_prov_disc_resp(struct p2p_data * p2p,struct p2p_message * msg,const u8 * sa,const u8 * data,size_t len)1734 static void p2p_process_prov_disc_resp(struct p2p_data *p2p,
1735 struct p2p_message *msg, const u8 *sa,
1736 const u8 *data, size_t len)
1737 {
1738 struct p2p_device *dev;
1739 u16 report_config_methods = 0, req_config_methods;
1740 enum p2p_status_code status = P2P_SC_SUCCESS;
1741 u32 adv_id = 0;
1742 u8 conncap = P2PS_SETUP_NEW;
1743 u8 adv_mac[ETH_ALEN];
1744 const u8 *group_mac;
1745 int passwd_id = DEV_PW_DEFAULT;
1746 int p2ps_seeker;
1747
1748 if (p2p->p2ps_prov && p2p_validate_p2ps_pd_resp(p2p, msg))
1749 return;
1750
1751 /* Parse the P2PS members present */
1752 if (msg->status)
1753 status = *msg->status;
1754
1755 group_mac = msg->intended_addr;
1756
1757 if (msg->adv_mac)
1758 os_memcpy(adv_mac, msg->adv_mac, ETH_ALEN);
1759 else
1760 os_memset(adv_mac, 0, ETH_ALEN);
1761
1762 if (msg->adv_id)
1763 adv_id = WPA_GET_LE32(msg->adv_id);
1764
1765 if (msg->conn_cap) {
1766 conncap = *msg->conn_cap;
1767
1768 /* Switch bits to local relative */
1769 switch (conncap) {
1770 case P2PS_SETUP_GROUP_OWNER:
1771 conncap = P2PS_SETUP_CLIENT;
1772 break;
1773 case P2PS_SETUP_CLIENT:
1774 conncap = P2PS_SETUP_GROUP_OWNER;
1775 break;
1776 }
1777 }
1778
1779 p2p_dbg(p2p, "Received Provision Discovery Response from " MACSTR
1780 " with config methods 0x%x",
1781 MAC2STR(sa), msg->wps_config_methods);
1782
1783 dev = p2p_get_device(p2p, sa);
1784 if (dev == NULL || !dev->req_config_methods) {
1785 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
1786 " with no pending request", MAC2STR(sa));
1787 return;
1788 } else if (msg->wfd_subelems) {
1789 wpabuf_free(dev->info.wfd_subelems);
1790 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
1791 }
1792
1793 p2p_update_peer_6ghz_capab(dev, msg);
1794
1795 if (dev->dialog_token != msg->dialog_token) {
1796 p2p_dbg(p2p, "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
1797 msg->dialog_token, dev->dialog_token);
1798 return;
1799 }
1800
1801 if (p2p->pending_action_state == P2P_PENDING_PD) {
1802 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1803 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1804 }
1805
1806 p2ps_seeker = p2p->p2ps_prov && p2p->p2ps_prov->pd_seeker;
1807
1808 /*
1809 * Use a local copy of the requested config methods since
1810 * p2p_reset_pending_pd() can clear this in the peer entry.
1811 */
1812 req_config_methods = dev->req_config_methods;
1813
1814 /*
1815 * If the response is from the peer to whom a user initiated request
1816 * was sent earlier, we reset that state info here.
1817 */
1818 if (p2p->user_initiated_pd &&
1819 ether_addr_equal(p2p->pending_pd_devaddr, sa))
1820 p2p_reset_pending_pd(p2p);
1821
1822 if (msg->wps_config_methods != req_config_methods) {
1823 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request (received config_methods 0x%x expected 0x%x",
1824 msg->wps_config_methods, req_config_methods);
1825 if (p2p->cfg->prov_disc_fail)
1826 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1827 P2P_PROV_DISC_REJECTED,
1828 adv_id, adv_mac, NULL);
1829 p2ps_prov_free(p2p);
1830 goto out;
1831 }
1832
1833 report_config_methods = req_config_methods;
1834 dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
1835 P2P_DEV_PD_PEER_KEYPAD |
1836 P2P_DEV_PD_PEER_P2PS);
1837 if (req_config_methods & WPS_CONFIG_DISPLAY) {
1838 p2p_dbg(p2p, "Peer " MACSTR
1839 " accepted to show a PIN on display", MAC2STR(sa));
1840 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
1841 passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
1842 } else if (msg->wps_config_methods & WPS_CONFIG_KEYPAD) {
1843 p2p_dbg(p2p, "Peer " MACSTR
1844 " accepted to write our PIN using keypad",
1845 MAC2STR(sa));
1846 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
1847 passwd_id = DEV_PW_USER_SPECIFIED;
1848 } else if (msg->wps_config_methods & WPS_CONFIG_P2PS) {
1849 p2p_dbg(p2p, "Peer " MACSTR " accepted P2PS PIN",
1850 MAC2STR(sa));
1851 dev->flags |= P2P_DEV_PD_PEER_P2PS;
1852 passwd_id = DEV_PW_P2PS_DEFAULT;
1853 }
1854
1855 if ((status == P2P_SC_SUCCESS || status == P2P_SC_SUCCESS_DEFERRED) &&
1856 p2p->p2ps_prov) {
1857 dev->oper_freq = 0;
1858
1859 /*
1860 * Save the reported channel list and operating frequency.
1861 * Note that the specification mandates that the responder
1862 * should include in the channel list only channels reported by
1863 * the initiator, so this is only a validity check, and if this
1864 * fails the flow would continue, although it would probably
1865 * fail. Same is true for the operating channel.
1866 */
1867 if (msg->channel_list && msg->channel_list_len &&
1868 p2p_peer_channels_check(p2p, &p2p->channels, dev,
1869 msg->channel_list,
1870 msg->channel_list_len) < 0)
1871 p2p_dbg(p2p, "P2PS PD Response - no common channels");
1872
1873 if (msg->operating_channel) {
1874 if (p2p_channels_includes(&p2p->channels,
1875 msg->operating_channel[3],
1876 msg->operating_channel[4]) &&
1877 p2p_channels_includes(&dev->channels,
1878 msg->operating_channel[3],
1879 msg->operating_channel[4])) {
1880 dev->oper_freq =
1881 p2p_channel_to_freq(
1882 msg->operating_channel[3],
1883 msg->operating_channel[4]);
1884 } else {
1885 p2p_dbg(p2p,
1886 "P2PS PD Response - invalid operating channel");
1887 }
1888 }
1889
1890 if (p2p->cfg->p2ps_prov_complete) {
1891 int freq = 0;
1892
1893 if (conncap == P2PS_SETUP_GROUP_OWNER) {
1894 u8 tmp;
1895
1896 /*
1897 * Re-select the operating channel as it is
1898 * possible that original channel is no longer
1899 * valid. This should not really fail.
1900 */
1901 if (p2p_go_select_channel(p2p, dev, &tmp) < 0)
1902 p2p_dbg(p2p,
1903 "P2PS PD channel selection failed");
1904
1905 freq = p2p_channel_to_freq(p2p->op_reg_class,
1906 p2p->op_channel);
1907 if (freq < 0)
1908 freq = 0;
1909 }
1910
1911 p2p->cfg->p2ps_prov_complete(
1912 p2p->cfg->cb_ctx, status, sa, adv_mac,
1913 p2p->p2ps_prov->session_mac,
1914 group_mac, adv_id, p2p->p2ps_prov->session_id,
1915 conncap, passwd_id, msg->persistent_ssid,
1916 msg->persistent_ssid_len, 1, 0, NULL,
1917 msg->feature_cap, msg->feature_cap_len, freq,
1918 msg->group_id ? msg->group_id + ETH_ALEN : NULL,
1919 msg->group_id ? msg->group_id_len - ETH_ALEN :
1920 0);
1921 }
1922 p2ps_prov_free(p2p);
1923 } else if (status != P2P_SC_SUCCESS &&
1924 status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1925 status != P2P_SC_SUCCESS_DEFERRED && p2p->p2ps_prov) {
1926 if (p2p->cfg->p2ps_prov_complete)
1927 p2p->cfg->p2ps_prov_complete(
1928 p2p->cfg->cb_ctx, status, sa, adv_mac,
1929 p2p->p2ps_prov->session_mac,
1930 group_mac, adv_id, p2p->p2ps_prov->session_id,
1931 0, 0, NULL, 0, 1, 0, NULL, NULL, 0, 0, NULL, 0);
1932 p2ps_prov_free(p2p);
1933 }
1934
1935 if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1936 if (p2p->cfg->remove_stale_groups) {
1937 p2p->cfg->remove_stale_groups(p2p->cfg->cb_ctx,
1938 dev->info.p2p_device_addr,
1939 NULL, NULL, 0);
1940 }
1941
1942 if (msg->session_info && msg->session_info_len) {
1943 size_t info_len = msg->session_info_len;
1944 char *deferred_sess_resp = os_malloc(2 * info_len + 1);
1945
1946 if (!deferred_sess_resp) {
1947 p2ps_prov_free(p2p);
1948 goto out;
1949 }
1950 utf8_escape((char *) msg->session_info, info_len,
1951 deferred_sess_resp, 2 * info_len + 1);
1952
1953 if (p2p->cfg->prov_disc_fail)
1954 p2p->cfg->prov_disc_fail(
1955 p2p->cfg->cb_ctx, sa,
1956 P2P_PROV_DISC_INFO_UNAVAILABLE,
1957 adv_id, adv_mac,
1958 deferred_sess_resp);
1959 os_free(deferred_sess_resp);
1960 } else
1961 if (p2p->cfg->prov_disc_fail)
1962 p2p->cfg->prov_disc_fail(
1963 p2p->cfg->cb_ctx, sa,
1964 P2P_PROV_DISC_INFO_UNAVAILABLE,
1965 adv_id, adv_mac, NULL);
1966 } else if (status != P2P_SC_SUCCESS) {
1967 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request");
1968 if (p2p->cfg->prov_disc_fail)
1969 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1970 P2P_PROV_DISC_REJECTED,
1971 adv_id, adv_mac, NULL);
1972 p2ps_prov_free(p2p);
1973 goto out;
1974 }
1975
1976 /* Store the provisioning info */
1977 dev->wps_prov_info = msg->wps_config_methods;
1978 if (msg->intended_addr)
1979 os_memcpy(dev->interface_addr, msg->intended_addr, ETH_ALEN);
1980
1981 out:
1982 dev->req_config_methods = 0;
1983 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1984 if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
1985 p2p_dbg(p2p, "Start GO Neg after the PD-before-GO-Neg workaround with "
1986 MACSTR, MAC2STR(dev->info.p2p_device_addr));
1987 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1988 p2p_connect_send(p2p, dev);
1989 return;
1990 }
1991
1992 /*
1993 * prov_disc_resp callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1994 * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1995 * Call it only for a legacy P2P PD or for P2PS PD scenarios where
1996 * show/enter PIN events are needed.
1997 *
1998 * The callback is called in the following cases:
1999 * 1. Legacy P2P PD response with a status SUCCESS
2000 * 2. P2PS, advertiser method: DISPLAY, autoaccept: true,
2001 * response status: SUCCESS, local method KEYPAD
2002 * 3. P2PS, advertiser method: KEYPAD,Seeker side,
2003 * response status: INFO_CURRENTLY_UNAVAILABLE,
2004 * local method: DISPLAY
2005 */
2006 if (p2p->cfg->prov_disc_resp &&
2007 ((status == P2P_SC_SUCCESS && !adv_id) ||
2008 (p2ps_seeker && status == P2P_SC_SUCCESS &&
2009 passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
2010 (p2ps_seeker &&
2011 status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
2012 passwd_id == DEV_PW_USER_SPECIFIED)))
2013 p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
2014 report_config_methods);
2015
2016 if (p2p->state == P2P_PD_DURING_FIND) {
2017 p2p_stop_listen_for_freq(p2p, 0);
2018 p2p_continue_find(p2p);
2019 }
2020 }
2021
2022
p2p_handle_prov_disc_resp(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)2023 void p2p_handle_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
2024 const u8 *data, size_t len, int rx_freq)
2025 {
2026 struct p2p_message msg;
2027
2028 if (p2p_parse(data, len, &msg))
2029 return;
2030
2031 if (msg.pcea_info && msg.pbma_info)
2032 p2p_process_prov_disc_bootstrap_resp(p2p, &msg, sa, data + 1,
2033 len - 1, rx_freq);
2034 else
2035 p2p_process_prov_disc_resp(p2p, &msg, sa, data + 1, len - 1);
2036
2037 p2p_parse_free(&msg);
2038 }
2039
2040
p2p_send_prov_disc_req(struct p2p_data * p2p,struct p2p_device * dev,int join,int force_freq)2041 int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
2042 int join, int force_freq)
2043 {
2044 struct wpabuf *req;
2045 int freq;
2046
2047 if (force_freq > 0)
2048 freq = force_freq;
2049 else
2050 freq = dev->listen_freq > 0 ? dev->listen_freq :
2051 dev->oper_freq;
2052 if (freq <= 0) {
2053 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
2054 MACSTR " to send Provision Discovery Request",
2055 MAC2STR(dev->info.p2p_device_addr));
2056 return -1;
2057 }
2058
2059 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
2060 if (!(dev->info.dev_capab &
2061 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
2062 p2p_dbg(p2p, "Cannot use PD with P2P Device " MACSTR
2063 " that is in a group and is not discoverable",
2064 MAC2STR(dev->info.p2p_device_addr));
2065 return -1;
2066 }
2067 /* TODO: use device discoverability request through GO */
2068 }
2069
2070 if (!dev->p2p2 && p2p->p2ps_prov) {
2071 if (p2p->p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED) {
2072 if (p2p->p2ps_prov->method == WPS_CONFIG_DISPLAY)
2073 dev->req_config_methods = WPS_CONFIG_KEYPAD;
2074 else if (p2p->p2ps_prov->method == WPS_CONFIG_KEYPAD)
2075 dev->req_config_methods = WPS_CONFIG_DISPLAY;
2076 else
2077 dev->req_config_methods = WPS_CONFIG_P2PS;
2078 } else {
2079 /* Order of preference, based on peer's capabilities */
2080 if (p2p->p2ps_prov->method)
2081 dev->req_config_methods =
2082 p2p->p2ps_prov->method;
2083 else if (dev->info.config_methods & WPS_CONFIG_P2PS)
2084 dev->req_config_methods = WPS_CONFIG_P2PS;
2085 else if (dev->info.config_methods & WPS_CONFIG_DISPLAY)
2086 dev->req_config_methods = WPS_CONFIG_DISPLAY;
2087 else
2088 dev->req_config_methods = WPS_CONFIG_KEYPAD;
2089 }
2090 p2p_dbg(p2p,
2091 "Building PD Request based on P2PS config method 0x%x status %d --> req_config_methods 0x%x",
2092 p2p->p2ps_prov->method, p2p->p2ps_prov->status,
2093 dev->req_config_methods);
2094
2095 if (p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
2096 p2p->p2ps_prov->pref_freq, 1) < 0)
2097 return -1;
2098 }
2099
2100 if (dev->p2p2)
2101 req = p2p_build_prov_disc_bootstrap_req(p2p, dev);
2102 else
2103 req = p2p_build_prov_disc_req(p2p, dev, join);
2104
2105 if (req == NULL)
2106 return -1;
2107
2108 if (p2p->state != P2P_IDLE)
2109 p2p_stop_listen_for_freq(p2p, freq);
2110 p2p->pending_action_state = P2P_PENDING_PD;
2111 if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
2112 p2p->cfg->dev_addr, dev->info.p2p_device_addr,
2113 wpabuf_head(req), wpabuf_len(req), 200) < 0) {
2114 p2p_dbg(p2p, "Failed to send Action frame");
2115 wpabuf_free(req);
2116 return -1;
2117 }
2118
2119 os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
2120
2121 wpabuf_free(req);
2122 return 0;
2123 }
2124
2125
p2p_set_req_bootstrap_method(struct p2p_data * p2p,const u8 * peer_addr,u16 bootstrap)2126 int p2p_set_req_bootstrap_method(struct p2p_data *p2p, const u8 *peer_addr,
2127 u16 bootstrap)
2128 {
2129 struct p2p_device *dev;
2130
2131 dev = p2p_get_device(p2p, peer_addr);
2132 if (!dev) {
2133 p2p_dbg(p2p, "Bootstrap request for peer " MACSTR
2134 " not yet known", MAC2STR(peer_addr));
2135 return -1;
2136 }
2137
2138 dev->p2p2 = 1;
2139 dev->req_bootstrap_method = bootstrap;
2140 return 0;
2141 }
2142
2143
p2p_prov_disc_req(struct p2p_data * p2p,const u8 * peer_addr,struct p2ps_provision * p2ps_prov,u16 config_methods,int join,int force_freq,int user_initiated_pd)2144 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
2145 struct p2ps_provision *p2ps_prov,
2146 u16 config_methods, int join, int force_freq,
2147 int user_initiated_pd)
2148 {
2149 struct p2p_device *dev;
2150
2151 dev = p2p_get_device(p2p, peer_addr);
2152 if (dev == NULL)
2153 dev = p2p_get_device_interface(p2p, peer_addr);
2154 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
2155 p2p_dbg(p2p, "Provision Discovery Request destination " MACSTR
2156 " not yet known", MAC2STR(peer_addr));
2157 os_free(p2ps_prov);
2158 return -1;
2159 }
2160
2161 if (dev->p2p2 && dev->req_bootstrap_method) {
2162 p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
2163 " (bootstrap methods 0x%x)",
2164 MAC2STR(peer_addr), dev->req_bootstrap_method);
2165 goto out;
2166 }
2167
2168 p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
2169 " (config methods 0x%x)",
2170 MAC2STR(peer_addr), config_methods);
2171
2172 if (config_methods == 0 && !p2ps_prov) {
2173 os_free(p2ps_prov);
2174 return -1;
2175 }
2176 dev->req_config_methods = config_methods;
2177
2178 if (p2ps_prov && p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED &&
2179 p2p->p2ps_prov) {
2180 /* Use cached method from deferred provisioning */
2181 p2ps_prov->method = p2p->p2ps_prov->method;
2182 }
2183
2184 out:
2185 /* Reset provisioning info */
2186 dev->wps_prov_info = 0;
2187 p2ps_prov_free(p2p);
2188 p2p->p2ps_prov = p2ps_prov;
2189
2190 if (join)
2191 dev->flags |= P2P_DEV_PD_FOR_JOIN;
2192 else
2193 dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
2194
2195 if (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
2196 p2p->state != P2P_LISTEN_ONLY) {
2197 p2p_dbg(p2p, "Busy with other operations; postpone Provision Discovery Request with "
2198 MACSTR, MAC2STR(peer_addr));
2199 return 0;
2200 }
2201
2202 p2p->user_initiated_pd = user_initiated_pd;
2203 p2p->pd_force_freq = force_freq;
2204
2205 if (p2p->user_initiated_pd)
2206 p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
2207
2208 /*
2209 * Assign dialog token here to use the same value in each retry within
2210 * the same PD exchange.
2211 */
2212 dev->dialog_token++;
2213 if (dev->dialog_token == 0)
2214 dev->dialog_token = 1;
2215
2216 return p2p_send_prov_disc_req(p2p, dev, join, force_freq);
2217 }
2218
2219
p2p_reset_pending_pd(struct p2p_data * p2p)2220 void p2p_reset_pending_pd(struct p2p_data *p2p)
2221 {
2222 struct p2p_device *dev;
2223
2224 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2225 if (!ether_addr_equal(p2p->pending_pd_devaddr,
2226 dev->info.p2p_device_addr))
2227 continue;
2228 if (!dev->req_config_methods)
2229 continue;
2230 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
2231 continue;
2232 /* Reset the config methods of the device */
2233 dev->req_config_methods = 0;
2234 }
2235
2236 p2p->user_initiated_pd = 0;
2237 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
2238 p2p->pd_retries = 0;
2239 p2p->pd_force_freq = 0;
2240 }
2241
2242
p2ps_prov_free(struct p2p_data * p2p)2243 void p2ps_prov_free(struct p2p_data *p2p)
2244 {
2245 os_free(p2p->p2ps_prov);
2246 p2p->p2ps_prov = NULL;
2247 }
2248