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 dev->info.pairing_config.enable_pairing_verification = true;
707 }
708 }
709
710
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)711 static void p2p_process_prov_disc_bootstrap_req(struct p2p_data *p2p,
712 struct p2p_message *msg,
713 const u8 *sa, const u8 *data,
714 size_t len, int rx_freq)
715 {
716 struct p2p_device *dev;
717 int freq;
718 struct wpabuf *resp;
719 u16 bootstrap;
720 size_t cookie_len = 0;
721 const u8 *pos, *cookie;
722 enum p2p_status_code status = P2P_SC_FAIL_INVALID_PARAMS;
723
724 p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
725 " with bootstrapping Attribute (freq=%d)",
726 MAC2STR(sa), rx_freq);
727
728 dev = p2p_get_device(p2p, sa);
729 if (!dev) {
730 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
731 MACSTR, MAC2STR(sa));
732
733 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data, len, 0)) {
734 p2p_dbg(p2p,
735 "Provision Discovery Request add device failed "
736 MACSTR, MAC2STR(sa));
737 return;
738 }
739
740 dev = p2p_get_device(p2p, sa);
741 if (!dev) {
742 p2p_dbg(p2p,
743 "Provision Discovery device not found "
744 MACSTR, MAC2STR(sa));
745 return;
746 }
747 }
748 dev->p2p2 = true;
749
750 if (p2p->send_action_in_progress) {
751 p2p_dbg(p2p, "Dropping retry frame as response TX pending");
752 return;
753 }
754
755 p2p_update_peer_6ghz_capab(dev, msg);
756
757 if (msg->pcea_info && msg->pcea_info_len >= 2)
758 p2p_process_pcea(p2p, msg, dev);
759
760 pos = msg->pbma_info;
761
762 if (msg->pbma_info_len > 2 && msg->status &&
763 *msg->status == P2P_SC_COMEBACK) {
764 /* PBMA comeback request */
765 cookie_len = *pos++;
766 if (msg->pbma_info_len < 1 + cookie_len) {
767 p2p_dbg(p2p, "Truncated PBMA");
768 return;
769 }
770 cookie = pos;
771
772 if (!dev->bootstrap_params ||
773 dev->bootstrap_params->cookie_len != cookie_len ||
774 os_memcmp(cookie, dev->bootstrap_params->cookie,
775 cookie_len) != 0) {
776 status = P2P_SC_FAIL_REJECTED_BY_USER;
777 goto out;
778 }
779
780 bootstrap = dev->bootstrap_params->bootstrap_method;
781
782 if (!dev->req_bootstrap_method) {
783 status = P2P_SC_COMEBACK;
784 if (p2p->cfg->bootstrap_req_rx)
785 p2p->cfg->bootstrap_req_rx(p2p->cfg->cb_ctx,
786 sa, bootstrap);
787 goto out;
788 }
789 } else {
790 /* PBMA request */
791 bootstrap = WPA_GET_LE16(pos);
792
793 os_free(dev->bootstrap_params);
794 dev->bootstrap_params = NULL;
795
796 if (!dev->req_bootstrap_method) {
797 dev->bootstrap_params =
798 os_zalloc(sizeof(struct p2p_bootstrap_params));
799 if (!dev->bootstrap_params)
800 return;
801 dev->bootstrap_params->bootstrap_method = bootstrap;
802 dev->bootstrap_params->cookie_len = 4;
803 if (os_get_random(dev->bootstrap_params->cookie,
804 dev->bootstrap_params->cookie_len) <
805 0) {
806 os_free(dev->bootstrap_params);
807 dev->bootstrap_params = NULL;
808 return;
809 }
810 dev->bootstrap_params->comeback_after =
811 p2p->cfg->comeback_after;
812 status = P2P_SC_COMEBACK;
813 if (p2p->cfg->bootstrap_req_rx)
814 p2p->cfg->bootstrap_req_rx(p2p->cfg->cb_ctx,
815 sa, bootstrap);
816 goto out;
817 }
818 }
819
820 if (bootstrap == P2P_PBMA_PIN_CODE_DISPLAY &&
821 dev->req_bootstrap_method == P2P_PBMA_PIN_CODE_KEYPAD)
822 status = P2P_SC_SUCCESS;
823 else if (bootstrap == P2P_PBMA_PIN_CODE_KEYPAD &&
824 dev->req_bootstrap_method == P2P_PBMA_PIN_CODE_DISPLAY)
825 status = P2P_SC_SUCCESS;
826 else if (bootstrap == P2P_PBMA_PASSPHRASE_DISPLAY &&
827 dev->req_bootstrap_method == P2P_PBMA_PASSPHRASE_KEYPAD)
828 status = P2P_SC_SUCCESS;
829 else if (bootstrap == P2P_PBMA_PASSPHRASE_KEYPAD &&
830 dev->req_bootstrap_method == P2P_PBMA_PASSPHRASE_DISPLAY)
831 status = P2P_SC_SUCCESS;
832 else if (bootstrap == P2P_PBMA_NFC_TAG &&
833 dev->req_bootstrap_method == P2P_PBMA_NFC_READER)
834 status = P2P_SC_SUCCESS;
835 else if (bootstrap == P2P_PBMA_NFC_READER &&
836 dev->req_bootstrap_method == P2P_PBMA_NFC_TAG)
837 status = P2P_SC_SUCCESS;
838 else if (bootstrap == P2P_PBMA_QR_DISPLAY &&
839 dev->req_bootstrap_method == P2P_PBMA_QR_SCAN)
840 status = P2P_SC_SUCCESS;
841 else if (bootstrap == P2P_PBMA_QR_SCAN &&
842 dev->req_bootstrap_method == P2P_PBMA_QR_DISPLAY)
843 status = P2P_SC_SUCCESS;
844 else if (bootstrap == P2P_PBMA_OPPORTUNISTIC &&
845 dev->req_bootstrap_method == P2P_PBMA_OPPORTUNISTIC)
846 status = P2P_SC_SUCCESS;
847 else
848 status = P2P_SC_FAIL_INVALID_PARAMS;
849
850 wpa_printf(MSG_ERROR, "Bootstrap received %d", bootstrap);
851
852 out:
853 /* Send PD Bootstrapping Response for the PD Request */
854 resp = p2p_build_prov_disc_bootstrap_resp(p2p, dev, msg->dialog_token,
855 status);
856 if (!resp)
857 return;
858
859 p2p_dbg(p2p, "Sending Provision Discovery Bootstrap Response");
860 if (rx_freq > 0)
861 freq = rx_freq;
862 else
863 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
864 p2p->cfg->channel);
865 if (freq < 0) {
866 p2p_dbg(p2p, "Unknown operating class/channel");
867 wpabuf_free(resp);
868 return;
869 }
870 p2p->pending_action_state = P2P_PENDING_PD_RESPONSE;
871 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
872 p2p->cfg->dev_addr, wpabuf_head(resp),
873 wpabuf_len(resp), 50) < 0)
874 p2p_dbg(p2p, "Failed to send Action frame");
875 else
876 p2p->send_action_in_progress = 1;
877
878 wpabuf_free(resp);
879 }
880
881
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)882 static void p2p_process_prov_disc_req(struct p2p_data *p2p,
883 struct p2p_message *msg, const u8 *sa,
884 const u8 *data, size_t len, int rx_freq)
885 {
886 struct p2p_device *dev;
887 int freq;
888 enum p2p_status_code reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
889 struct wpabuf *resp;
890 u32 adv_id = 0;
891 struct p2ps_advertisement *p2ps_adv = NULL;
892 u8 conncap = P2PS_SETUP_NEW;
893 u8 auto_accept = 0;
894 u32 session_id = 0;
895 u8 session_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
896 u8 adv_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
897 const u8 *group_mac;
898 int passwd_id = DEV_PW_DEFAULT;
899 u16 config_methods;
900 u16 allowed_config_methods = WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD;
901 struct p2ps_feature_capab resp_fcap = { 0, 0 };
902 struct p2ps_feature_capab *req_fcap = NULL;
903 u8 remote_conncap;
904 u16 method;
905
906 p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
907 " with config methods 0x%x (freq=%d)",
908 MAC2STR(sa), msg->wps_config_methods, rx_freq);
909 group_mac = msg->intended_addr;
910
911 dev = p2p_get_device(p2p, sa);
912 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
913 p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
914 MACSTR, MAC2STR(sa));
915
916 if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data, len, 0)) {
917 p2p_dbg(p2p, "Provision Discovery Request add device failed "
918 MACSTR, MAC2STR(sa));
919 goto out;
920 }
921
922 dev = p2p_get_device(p2p, sa);
923 if (!dev) {
924 p2p_dbg(p2p,
925 "Provision Discovery device not found "
926 MACSTR, MAC2STR(sa));
927 goto out;
928 }
929 } else if (msg->wfd_subelems) {
930 wpabuf_free(dev->info.wfd_subelems);
931 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
932 }
933
934 p2p_update_peer_6ghz_capab(dev, msg);
935
936 if (!msg->adv_id) {
937 allowed_config_methods |= WPS_CONFIG_PUSHBUTTON;
938 if (!(msg->wps_config_methods & allowed_config_methods)) {
939 p2p_dbg(p2p,
940 "Unsupported Config Methods in Provision Discovery Request");
941 goto out;
942 }
943
944 /* Legacy (non-P2PS) - Unknown groups allowed for P2PS */
945 if (msg->group_id) {
946 size_t i;
947
948 for (i = 0; i < p2p->num_groups; i++) {
949 if (p2p_group_is_group_id_match(
950 p2p->groups[i],
951 msg->group_id, msg->group_id_len))
952 break;
953 }
954 if (i == p2p->num_groups) {
955 p2p_dbg(p2p,
956 "PD request for unknown P2P Group ID - reject");
957 goto out;
958 }
959 }
960 } else {
961 allowed_config_methods |= WPS_CONFIG_P2PS;
962
963 /*
964 * Set adv_id here, so in case of an error, a P2PS PD Response
965 * will be sent.
966 */
967 adv_id = WPA_GET_LE32(msg->adv_id);
968 if (p2ps_validate_pd_req(p2p, msg, sa) < 0) {
969 reject = P2P_SC_FAIL_INVALID_PARAMS;
970 goto out;
971 }
972
973 req_fcap = (struct p2ps_feature_capab *) msg->feature_cap;
974
975 os_memcpy(session_mac, msg->session_mac, ETH_ALEN);
976 os_memcpy(adv_mac, msg->adv_mac, ETH_ALEN);
977
978 session_id = WPA_GET_LE32(msg->session_id);
979
980 if (msg->conn_cap)
981 conncap = *msg->conn_cap;
982
983 /*
984 * We need to verify a P2PS config methog in an initial PD
985 * request or in a follow-on PD request with the status
986 * SUCCESS_DEFERRED.
987 */
988 if ((!msg->status || *msg->status == P2P_SC_SUCCESS_DEFERRED) &&
989 !(msg->wps_config_methods & allowed_config_methods)) {
990 p2p_dbg(p2p,
991 "Unsupported Config Methods in Provision Discovery Request");
992 goto out;
993 }
994
995 /*
996 * TODO: since we don't support multiple PD, reject PD request
997 * if we are in the middle of P2PS PD with some other peer
998 */
999 }
1000
1001 dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
1002 P2P_DEV_PD_PEER_KEYPAD |
1003 P2P_DEV_PD_PEER_P2PS);
1004
1005 if (msg->wps_config_methods & WPS_CONFIG_DISPLAY) {
1006 p2p_dbg(p2p, "Peer " MACSTR
1007 " requested us to show a PIN on display", MAC2STR(sa));
1008 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
1009 passwd_id = DEV_PW_USER_SPECIFIED;
1010 } else if (msg->wps_config_methods & WPS_CONFIG_KEYPAD) {
1011 p2p_dbg(p2p, "Peer " MACSTR
1012 " requested us to write its PIN using keypad",
1013 MAC2STR(sa));
1014 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
1015 passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
1016 } else if (msg->wps_config_methods & WPS_CONFIG_P2PS) {
1017 p2p_dbg(p2p, "Peer " MACSTR " requesting P2PS PIN",
1018 MAC2STR(sa));
1019 dev->flags |= P2P_DEV_PD_PEER_P2PS;
1020 passwd_id = DEV_PW_P2PS_DEFAULT;
1021 }
1022
1023 /* Remove stale persistent groups */
1024 if (p2p->cfg->remove_stale_groups) {
1025 p2p->cfg->remove_stale_groups(
1026 p2p->cfg->cb_ctx, dev->info.p2p_device_addr,
1027 msg->persistent_dev,
1028 msg->persistent_ssid, msg->persistent_ssid_len);
1029 }
1030
1031 reject = P2P_SC_SUCCESS;
1032
1033 /*
1034 * End of a legacy P2P PD Request processing, from this point continue
1035 * with P2PS one.
1036 */
1037 if (!msg->adv_id)
1038 goto out;
1039
1040 remote_conncap = conncap;
1041
1042 if (!msg->status) {
1043 unsigned int forced_freq, pref_freq;
1044
1045 if (!ether_addr_equal(p2p->cfg->dev_addr, msg->adv_mac)) {
1046 p2p_dbg(p2p,
1047 "P2PS PD adv mac does not match the local one");
1048 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1049 goto out;
1050 }
1051
1052 p2ps_adv = p2p_service_p2ps_id(p2p, adv_id);
1053 if (!p2ps_adv) {
1054 p2p_dbg(p2p, "P2PS PD invalid adv_id=0x%X", adv_id);
1055 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1056 goto out;
1057 }
1058 p2p_dbg(p2p, "adv_id: 0x%X, p2ps_adv: %p", adv_id, p2ps_adv);
1059
1060 auto_accept = p2ps_adv->auto_accept;
1061 conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
1062 conncap, auto_accept,
1063 &forced_freq,
1064 &pref_freq);
1065
1066 p2p_dbg(p2p, "Conncap: local:%d remote:%d result:%d",
1067 auto_accept, remote_conncap, conncap);
1068
1069 p2p_prepare_channel(p2p, dev, forced_freq, pref_freq, 0);
1070
1071 resp_fcap.cpt = p2ps_own_preferred_cpt(p2ps_adv->cpt_priority,
1072 req_fcap->cpt);
1073
1074 p2p_dbg(p2p, "cpt: service:0x%x remote:0x%x result:0x%x",
1075 p2ps_adv->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
1076
1077 if (!resp_fcap.cpt) {
1078 p2p_dbg(p2p,
1079 "Incompatible P2PS feature capability CPT bitmask");
1080 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1081 } else if (p2ps_adv->config_methods &&
1082 !(msg->wps_config_methods &
1083 p2ps_adv->config_methods)) {
1084 p2p_dbg(p2p,
1085 "Unsupported config methods in Provision Discovery Request (own=0x%x peer=0x%x)",
1086 p2ps_adv->config_methods,
1087 msg->wps_config_methods);
1088 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1089 } else if (!p2ps_adv->state) {
1090 p2p_dbg(p2p, "P2PS state unavailable");
1091 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1092 } else if (!conncap) {
1093 p2p_dbg(p2p, "Conncap resolution failed");
1094 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1095 }
1096
1097 if (msg->wps_config_methods & WPS_CONFIG_KEYPAD) {
1098 p2p_dbg(p2p, "Keypad - always defer");
1099 auto_accept = 0;
1100 }
1101
1102 if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
1103 msg->persistent_dev) && conncap != P2PS_SETUP_NEW &&
1104 msg->channel_list && msg->channel_list_len &&
1105 p2p_peer_channels_check(p2p, &p2p->channels, dev,
1106 msg->channel_list,
1107 msg->channel_list_len) < 0) {
1108 p2p_dbg(p2p,
1109 "No common channels - force deferred flow");
1110 auto_accept = 0;
1111 }
1112
1113 if (((remote_conncap & P2PS_SETUP_GROUP_OWNER) ||
1114 msg->persistent_dev) && msg->operating_channel) {
1115 struct p2p_channels intersect;
1116
1117 /*
1118 * There are cases where only the operating channel is
1119 * provided. This requires saving the channel as the
1120 * supported channel list, and verifying that it is
1121 * supported.
1122 */
1123 if (dev->channels.reg_classes == 0 ||
1124 !p2p_channels_includes(&dev->channels,
1125 msg->operating_channel[3],
1126 msg->operating_channel[4])) {
1127 struct p2p_channels *ch = &dev->channels;
1128
1129 os_memset(ch, 0, sizeof(*ch));
1130 ch->reg_class[0].reg_class =
1131 msg->operating_channel[3];
1132 ch->reg_class[0].channel[0] =
1133 msg->operating_channel[4];
1134 ch->reg_class[0].channels = 1;
1135 ch->reg_classes = 1;
1136 }
1137
1138 p2p_channels_intersect(&p2p->channels, &dev->channels,
1139 &intersect);
1140
1141 if (intersect.reg_classes == 0) {
1142 p2p_dbg(p2p,
1143 "No common channels - force deferred flow");
1144 auto_accept = 0;
1145 }
1146 }
1147
1148 if (auto_accept || reject != P2P_SC_SUCCESS) {
1149 struct p2ps_provision *tmp;
1150
1151 if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
1152 msg->wps_config_methods,
1153 session_mac, adv_mac) < 0) {
1154 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1155 goto out;
1156 }
1157
1158 tmp = p2p->p2ps_prov;
1159 tmp->force_freq = forced_freq;
1160 tmp->pref_freq = pref_freq;
1161 if (conncap) {
1162 tmp->conncap = conncap;
1163 tmp->status = P2P_SC_SUCCESS;
1164 } else {
1165 tmp->conncap = auto_accept;
1166 tmp->status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1167 }
1168
1169 if (reject != P2P_SC_SUCCESS)
1170 goto out;
1171 }
1172 }
1173
1174 if (!msg->status && !auto_accept &&
1175 (!p2p->p2ps_prov || p2p->p2ps_prov->adv_id != adv_id)) {
1176 struct p2ps_provision *tmp;
1177
1178 if (!conncap) {
1179 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1180 goto out;
1181 }
1182
1183 if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
1184 msg->wps_config_methods,
1185 session_mac, adv_mac) < 0) {
1186 reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
1187 goto out;
1188 }
1189 tmp = p2p->p2ps_prov;
1190 reject = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
1191 tmp->status = reject;
1192 }
1193
1194 /* Not a P2PS Follow-on PD */
1195 if (!msg->status)
1196 goto out;
1197
1198 if (*msg->status && *msg->status != P2P_SC_SUCCESS_DEFERRED) {
1199 reject = *msg->status;
1200 goto out;
1201 }
1202
1203 if (*msg->status != P2P_SC_SUCCESS_DEFERRED || !p2p->p2ps_prov)
1204 goto out;
1205
1206 if (p2p->p2ps_prov->adv_id != adv_id ||
1207 !ether_addr_equal(p2p->p2ps_prov->adv_mac, msg->adv_mac)) {
1208 p2p_dbg(p2p,
1209 "P2PS Follow-on PD with mismatch Advertisement ID/MAC");
1210 goto out;
1211 }
1212
1213 if (p2p->p2ps_prov->session_id != session_id ||
1214 !ether_addr_equal(p2p->p2ps_prov->session_mac, msg->session_mac)) {
1215 p2p_dbg(p2p, "P2PS Follow-on PD with mismatch Session ID/MAC");
1216 goto out;
1217 }
1218
1219 method = p2p->p2ps_prov->method;
1220
1221 conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
1222 remote_conncap,
1223 p2p->p2ps_prov->conncap,
1224 &p2p->p2ps_prov->force_freq,
1225 &p2p->p2ps_prov->pref_freq);
1226
1227 resp_fcap.cpt = p2ps_own_preferred_cpt(p2p->p2ps_prov->cpt_priority,
1228 req_fcap->cpt);
1229
1230 p2p_dbg(p2p, "cpt: local:0x%x remote:0x%x result:0x%x",
1231 p2p->p2ps_prov->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
1232
1233 p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
1234 p2p->p2ps_prov->pref_freq, 0);
1235
1236 /*
1237 * Ensure that if we asked for PIN originally, our method is consistent
1238 * with original request.
1239 */
1240 if (method & WPS_CONFIG_DISPLAY)
1241 method = WPS_CONFIG_KEYPAD;
1242 else if (method & WPS_CONFIG_KEYPAD)
1243 method = WPS_CONFIG_DISPLAY;
1244
1245 if (!conncap || !(msg->wps_config_methods & method)) {
1246 /*
1247 * Reject this "Deferred Accept*
1248 * if incompatible conncap or method
1249 */
1250 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1251 } else if (!resp_fcap.cpt) {
1252 p2p_dbg(p2p,
1253 "Incompatible P2PS feature capability CPT bitmask");
1254 reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1255 } else if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
1256 msg->persistent_dev) && conncap != P2PS_SETUP_NEW &&
1257 msg->channel_list && msg->channel_list_len &&
1258 p2p_peer_channels_check(p2p, &p2p->channels, dev,
1259 msg->channel_list,
1260 msg->channel_list_len) < 0) {
1261 p2p_dbg(p2p,
1262 "No common channels in Follow-On Provision Discovery Request");
1263 reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
1264 } else {
1265 reject = P2P_SC_SUCCESS;
1266 }
1267
1268 dev->oper_freq = 0;
1269 if (reject == P2P_SC_SUCCESS || reject == P2P_SC_SUCCESS_DEFERRED) {
1270 u8 tmp;
1271
1272 if (msg->operating_channel)
1273 dev->oper_freq =
1274 p2p_channel_to_freq(msg->operating_channel[3],
1275 msg->operating_channel[4]);
1276
1277 if ((conncap & P2PS_SETUP_GROUP_OWNER) &&
1278 p2p_go_select_channel(p2p, dev, &tmp) < 0)
1279 reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
1280 }
1281
1282 p2p->p2ps_prov->status = reject;
1283 p2p->p2ps_prov->conncap = conncap;
1284
1285 out:
1286 if (reject == P2P_SC_SUCCESS ||
1287 reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1288 config_methods = msg->wps_config_methods;
1289 else
1290 config_methods = 0;
1291
1292 /*
1293 * Send PD Response for an initial PD Request or for follow-on
1294 * PD Request with P2P_SC_SUCCESS_DEFERRED status.
1295 */
1296 if (!msg->status || *msg->status == P2P_SC_SUCCESS_DEFERRED) {
1297 resp = p2p_build_prov_disc_resp(p2p, dev, msg->dialog_token,
1298 reject, config_methods, adv_id,
1299 msg->group_id,
1300 msg->group_id_len,
1301 msg->persistent_ssid,
1302 msg->persistent_ssid_len,
1303 (const u8 *) &resp_fcap,
1304 sizeof(resp_fcap));
1305 if (!resp)
1306 return;
1307
1308 p2p_dbg(p2p, "Sending Provision Discovery Response");
1309 if (rx_freq > 0)
1310 freq = rx_freq;
1311 else
1312 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
1313 p2p->cfg->channel);
1314 if (freq < 0) {
1315 p2p_dbg(p2p, "Unknown regulatory class/channel");
1316 wpabuf_free(resp);
1317 return;
1318 }
1319 p2p->pending_action_state = P2P_PENDING_PD_RESPONSE;
1320 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
1321 p2p->cfg->dev_addr,
1322 wpabuf_head(resp), wpabuf_len(resp),
1323 50) < 0)
1324 p2p_dbg(p2p, "Failed to send Action frame");
1325 else
1326 p2p->send_action_in_progress = 1;
1327
1328 wpabuf_free(resp);
1329 }
1330
1331 if (!dev)
1332 return;
1333
1334 freq = 0;
1335 if (reject == P2P_SC_SUCCESS && conncap == P2PS_SETUP_GROUP_OWNER) {
1336 freq = p2p_channel_to_freq(p2p->op_reg_class,
1337 p2p->op_channel);
1338 if (freq < 0)
1339 freq = 0;
1340 }
1341
1342 if (!p2p->cfg->p2ps_prov_complete) {
1343 /* Don't emit anything */
1344 } else if (msg->status && *msg->status != P2P_SC_SUCCESS &&
1345 *msg->status != P2P_SC_SUCCESS_DEFERRED) {
1346 reject = *msg->status;
1347 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1348 sa, adv_mac, session_mac,
1349 NULL, adv_id, session_id,
1350 0, 0, msg->persistent_ssid,
1351 msg->persistent_ssid_len,
1352 0, 0, NULL, NULL, 0, freq,
1353 NULL, 0);
1354 } else if (msg->status && *msg->status == P2P_SC_SUCCESS_DEFERRED &&
1355 p2p->p2ps_prov) {
1356 p2p->p2ps_prov->status = reject;
1357 p2p->p2ps_prov->conncap = conncap;
1358
1359 if (reject != P2P_SC_SUCCESS)
1360 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1361 sa, adv_mac, session_mac,
1362 NULL, adv_id,
1363 session_id, conncap, 0,
1364 msg->persistent_ssid,
1365 msg->persistent_ssid_len,
1366 0, 0, NULL, NULL, 0, freq,
1367 NULL, 0);
1368 else
1369 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx,
1370 *msg->status,
1371 sa, adv_mac, session_mac,
1372 group_mac, adv_id,
1373 session_id, conncap,
1374 passwd_id,
1375 msg->persistent_ssid,
1376 msg->persistent_ssid_len,
1377 0, 0, NULL,
1378 (const u8 *) &resp_fcap,
1379 sizeof(resp_fcap), freq,
1380 NULL, 0);
1381 } else if (msg->status && p2p->p2ps_prov) {
1382 p2p->p2ps_prov->status = P2P_SC_SUCCESS;
1383 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, *msg->status, sa,
1384 adv_mac, session_mac, group_mac,
1385 adv_id, session_id, conncap,
1386 passwd_id,
1387 msg->persistent_ssid,
1388 msg->persistent_ssid_len,
1389 0, 0, NULL,
1390 (const u8 *) &resp_fcap,
1391 sizeof(resp_fcap), freq, NULL, 0);
1392 } else if (msg->status) {
1393 } else if (auto_accept && reject == P2P_SC_SUCCESS) {
1394 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1395 sa, adv_mac, session_mac,
1396 group_mac, adv_id, session_id,
1397 conncap, passwd_id,
1398 msg->persistent_ssid,
1399 msg->persistent_ssid_len,
1400 0, 0, NULL,
1401 (const u8 *) &resp_fcap,
1402 sizeof(resp_fcap), freq,
1403 msg->group_id ?
1404 msg->group_id + ETH_ALEN : NULL,
1405 msg->group_id ?
1406 msg->group_id_len - ETH_ALEN : 0);
1407 } else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1408 (!msg->session_info || !msg->session_info_len)) {
1409 p2p->p2ps_prov->method = msg->wps_config_methods;
1410
1411 p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1412 sa, adv_mac, session_mac,
1413 group_mac, adv_id, session_id,
1414 conncap, passwd_id,
1415 msg->persistent_ssid,
1416 msg->persistent_ssid_len,
1417 0, 1, NULL,
1418 (const u8 *) &resp_fcap,
1419 sizeof(resp_fcap), freq, NULL, 0);
1420 } else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1421 size_t buf_len = msg->session_info_len;
1422 char *buf = os_malloc(2 * buf_len + 1);
1423
1424 if (buf) {
1425 p2p->p2ps_prov->method = msg->wps_config_methods;
1426
1427 utf8_escape((char *) msg->session_info, buf_len,
1428 buf, 2 * buf_len + 1);
1429
1430 p2p->cfg->p2ps_prov_complete(
1431 p2p->cfg->cb_ctx, P2P_SC_SUCCESS, sa,
1432 adv_mac, session_mac, group_mac, adv_id,
1433 session_id, conncap, passwd_id,
1434 msg->persistent_ssid, msg->persistent_ssid_len,
1435 0, 1, buf,
1436 (const u8 *) &resp_fcap, sizeof(resp_fcap),
1437 freq, NULL, 0);
1438
1439 os_free(buf);
1440 }
1441 }
1442
1443 /*
1444 * prov_disc_req callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1445 * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1446 * Call it either on legacy P2P PD or on P2PS PD only if we need to
1447 * enter/show PIN.
1448 *
1449 * The callback is called in the following cases:
1450 * 1. Legacy P2P PD request, response status SUCCESS
1451 * 2. P2PS advertiser, method: DISPLAY, autoaccept: TRUE,
1452 * response status: SUCCESS
1453 * 3. P2PS advertiser, method DISPLAY, autoaccept: FALSE,
1454 * response status: INFO_CURRENTLY_UNAVAILABLE
1455 * 4. P2PS advertiser, method: KEYPAD, autoaccept==any,
1456 * response status: INFO_CURRENTLY_UNAVAILABLE
1457 * 5. P2PS follow-on with SUCCESS_DEFERRED,
1458 * advertiser role: DISPLAY, autoaccept: FALSE,
1459 * seeker: KEYPAD, response status: SUCCESS
1460 */
1461 if (p2p->cfg->prov_disc_req &&
1462 ((reject == P2P_SC_SUCCESS && !msg->adv_id) ||
1463 (!msg->status &&
1464 (reject == P2P_SC_SUCCESS ||
1465 reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) &&
1466 passwd_id == DEV_PW_USER_SPECIFIED) ||
1467 (!msg->status &&
1468 reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1469 passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1470 (reject == P2P_SC_SUCCESS &&
1471 msg->status && *msg->status == P2P_SC_SUCCESS_DEFERRED &&
1472 passwd_id == DEV_PW_REGISTRAR_SPECIFIED))) {
1473 const u8 *dev_addr = sa;
1474
1475 if (msg->p2p_device_addr)
1476 dev_addr = msg->p2p_device_addr;
1477 p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
1478 msg->wps_config_methods,
1479 dev_addr, msg->pri_dev_type,
1480 msg->device_name, msg->config_methods,
1481 msg->capability ? msg->capability[0] :
1482 0,
1483 msg->capability ? msg->capability[1] :
1484 0,
1485 msg->group_id, msg->group_id_len);
1486 }
1487
1488 if (reject != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1489 p2ps_prov_free(p2p);
1490
1491 if (reject == P2P_SC_SUCCESS) {
1492 switch (config_methods) {
1493 case WPS_CONFIG_DISPLAY:
1494 dev->wps_prov_info = WPS_CONFIG_KEYPAD;
1495 break;
1496 case WPS_CONFIG_KEYPAD:
1497 dev->wps_prov_info = WPS_CONFIG_DISPLAY;
1498 break;
1499 case WPS_CONFIG_PUSHBUTTON:
1500 dev->wps_prov_info = WPS_CONFIG_PUSHBUTTON;
1501 break;
1502 case WPS_CONFIG_P2PS:
1503 dev->wps_prov_info = WPS_CONFIG_P2PS;
1504 break;
1505 default:
1506 dev->wps_prov_info = 0;
1507 break;
1508 }
1509
1510 if (msg->intended_addr)
1511 os_memcpy(dev->interface_addr, msg->intended_addr,
1512 ETH_ALEN);
1513 }
1514 }
1515
1516
p2p_handle_prov_disc_req(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)1517 void p2p_handle_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
1518 const u8 *data, size_t len, int rx_freq)
1519 {
1520 struct p2p_message msg;
1521
1522 if (p2p_parse(data, len, &msg))
1523 return;
1524
1525 if (msg.pcea_info && msg.pbma_info)
1526 p2p_process_prov_disc_bootstrap_req(p2p, &msg, sa, data + 1,
1527 len - 1, rx_freq);
1528 else
1529 p2p_process_prov_disc_req(p2p, &msg, sa, data + 1, len - 1,
1530 rx_freq);
1531
1532 p2p_parse_free(&msg);
1533 }
1534
1535
p2p_validate_p2ps_pd_resp(struct p2p_data * p2p,struct p2p_message * msg)1536 static int p2p_validate_p2ps_pd_resp(struct p2p_data *p2p,
1537 struct p2p_message *msg)
1538 {
1539 u8 conn_cap_go = 0;
1540 u8 conn_cap_cli = 0;
1541 u32 session_id;
1542 u32 adv_id;
1543
1544 #define P2PS_PD_RESP_CHECK(_val, _attr) \
1545 do { \
1546 if ((_val) && !msg->_attr) { \
1547 p2p_dbg(p2p, "P2PS PD Response missing " #_attr); \
1548 return -1; \
1549 } \
1550 } while (0)
1551
1552 P2PS_PD_RESP_CHECK(1, status);
1553 P2PS_PD_RESP_CHECK(1, adv_id);
1554 P2PS_PD_RESP_CHECK(1, adv_mac);
1555 P2PS_PD_RESP_CHECK(1, capability);
1556 P2PS_PD_RESP_CHECK(1, p2p_device_info);
1557 P2PS_PD_RESP_CHECK(1, session_id);
1558 P2PS_PD_RESP_CHECK(1, session_mac);
1559 P2PS_PD_RESP_CHECK(1, feature_cap);
1560
1561 session_id = WPA_GET_LE32(msg->session_id);
1562 adv_id = WPA_GET_LE32(msg->adv_id);
1563
1564 if (p2p->p2ps_prov->session_id != session_id) {
1565 p2p_dbg(p2p,
1566 "Ignore PD Response with unexpected Session ID");
1567 return -1;
1568 }
1569
1570 if (!ether_addr_equal(p2p->p2ps_prov->session_mac, msg->session_mac)) {
1571 p2p_dbg(p2p,
1572 "Ignore PD Response with unexpected Session MAC");
1573 return -1;
1574 }
1575
1576 if (p2p->p2ps_prov->adv_id != adv_id) {
1577 p2p_dbg(p2p,
1578 "Ignore PD Response with unexpected Advertisement ID");
1579 return -1;
1580 }
1581
1582 if (!ether_addr_equal(p2p->p2ps_prov->adv_mac, msg->adv_mac)) {
1583 p2p_dbg(p2p,
1584 "Ignore PD Response with unexpected Advertisement MAC");
1585 return -1;
1586 }
1587
1588 if (msg->listen_channel) {
1589 p2p_dbg(p2p,
1590 "Ignore malformed PD Response - unexpected Listen Channel");
1591 return -1;
1592 }
1593
1594 if (*msg->status == P2P_SC_SUCCESS &&
1595 !(!!msg->conn_cap ^ !!msg->persistent_dev)) {
1596 p2p_dbg(p2p,
1597 "Ignore malformed PD Response - either conn_cap or persistent group should be present");
1598 return -1;
1599 }
1600
1601 if (msg->persistent_dev && *msg->status != P2P_SC_SUCCESS) {
1602 p2p_dbg(p2p,
1603 "Ignore malformed PD Response - persistent group is present, but the status isn't success");
1604 return -1;
1605 }
1606
1607 if (msg->conn_cap) {
1608 conn_cap_go = *msg->conn_cap == P2PS_SETUP_GROUP_OWNER;
1609 conn_cap_cli = *msg->conn_cap == P2PS_SETUP_CLIENT;
1610 }
1611
1612 P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1613 channel_list);
1614 P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1615 config_timeout);
1616
1617 P2PS_PD_RESP_CHECK(conn_cap_go, group_id);
1618 P2PS_PD_RESP_CHECK(conn_cap_go, intended_addr);
1619 P2PS_PD_RESP_CHECK(conn_cap_go, operating_channel);
1620 /*
1621 * TODO: Also validate that operating channel is present if the device
1622 * is a GO in a persistent group. We can't do it here since we don't
1623 * know what is the role of the peer. It should be probably done in
1624 * p2ps_prov_complete callback, but currently operating channel isn't
1625 * passed to it.
1626 */
1627
1628 #undef P2PS_PD_RESP_CHECK
1629
1630 return 0;
1631 }
1632
1633
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)1634 static void p2p_process_prov_disc_bootstrap_resp(struct p2p_data *p2p,
1635 struct p2p_message *msg,
1636 const u8 *sa, const u8 *data,
1637 size_t len, int rx_freq)
1638 {
1639 struct p2p_device *dev;
1640 enum p2p_status_code status = P2P_SC_SUCCESS;
1641 size_t cookie_len = 0;
1642 const u8 *pos, *cookie;
1643 u16 comeback_after;
1644
1645 /* Parse the P2P status present */
1646 if (msg->status)
1647 status = *msg->status;
1648
1649 p2p_dbg(p2p, "Received Provision Discovery Bootstrap Response from "
1650 MACSTR, MAC2STR(sa));
1651
1652 dev = p2p_get_device(p2p, sa);
1653 if (!dev || !dev->req_bootstrap_method) {
1654 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
1655 " with no pending request", MAC2STR(sa));
1656 return;
1657 }
1658
1659 p2p_update_peer_6ghz_capab(dev, msg);
1660
1661 if (dev->dialog_token != msg->dialog_token) {
1662 p2p_dbg(p2p,
1663 "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
1664 msg->dialog_token, dev->dialog_token);
1665 return;
1666 }
1667
1668 if (p2p->pending_action_state == P2P_PENDING_PD) {
1669 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1670 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1671 }
1672
1673 os_free(dev->bootstrap_params);
1674 dev->bootstrap_params = NULL;
1675
1676 /* If the response is from the peer to whom a user initiated request
1677 * was sent earlier, we reset that state information here. */
1678 if (p2p->user_initiated_pd &&
1679 ether_addr_equal(p2p->pending_pd_devaddr, sa))
1680 p2p_reset_pending_pd(p2p);
1681
1682 if (status == P2P_SC_COMEBACK) {
1683 /* PBMA comeback response */
1684 pos = msg->pbma_info;
1685 if (msg->pbma_info_len < 2 + 1)
1686 return;
1687 comeback_after = WPA_GET_LE16(pos);
1688 pos += 2;
1689 cookie_len = *pos++;
1690 if (msg->pbma_info_len < 2 + 1 + cookie_len) {
1691 p2p_dbg(p2p, "Truncated PBMA");
1692 return;
1693 }
1694 cookie = pos;
1695
1696 dev->bootstrap_params =
1697 os_zalloc(sizeof(struct p2p_bootstrap_params));
1698 if (!dev->bootstrap_params)
1699 return;
1700 dev->bootstrap_params->cookie_len = cookie_len;
1701 os_memcpy(dev->bootstrap_params->cookie, cookie, cookie_len);
1702 dev->bootstrap_params->comeback_after = comeback_after;
1703 dev->bootstrap_params->bootstrap_method =
1704 dev->req_bootstrap_method;
1705 dev->bootstrap_params->status = status;
1706
1707 p2p->cfg->register_bootstrap_comeback(p2p->cfg->cb_ctx, sa,
1708 comeback_after);
1709 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1710 return;
1711 }
1712
1713 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1714 if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG)
1715 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1716
1717 if (p2p->cfg->bootstrap_completed)
1718 p2p->cfg->bootstrap_completed(p2p->cfg->cb_ctx, sa, status,
1719 rx_freq);
1720 }
1721
1722
p2p_process_prov_disc_resp(struct p2p_data * p2p,struct p2p_message * msg,const u8 * sa,const u8 * data,size_t len)1723 static void p2p_process_prov_disc_resp(struct p2p_data *p2p,
1724 struct p2p_message *msg, const u8 *sa,
1725 const u8 *data, size_t len)
1726 {
1727 struct p2p_device *dev;
1728 u16 report_config_methods = 0, req_config_methods;
1729 enum p2p_status_code status = P2P_SC_SUCCESS;
1730 u32 adv_id = 0;
1731 u8 conncap = P2PS_SETUP_NEW;
1732 u8 adv_mac[ETH_ALEN];
1733 const u8 *group_mac;
1734 int passwd_id = DEV_PW_DEFAULT;
1735 int p2ps_seeker;
1736
1737 if (p2p->p2ps_prov && p2p_validate_p2ps_pd_resp(p2p, msg))
1738 return;
1739
1740 /* Parse the P2PS members present */
1741 if (msg->status)
1742 status = *msg->status;
1743
1744 group_mac = msg->intended_addr;
1745
1746 if (msg->adv_mac)
1747 os_memcpy(adv_mac, msg->adv_mac, ETH_ALEN);
1748 else
1749 os_memset(adv_mac, 0, ETH_ALEN);
1750
1751 if (msg->adv_id)
1752 adv_id = WPA_GET_LE32(msg->adv_id);
1753
1754 if (msg->conn_cap) {
1755 conncap = *msg->conn_cap;
1756
1757 /* Switch bits to local relative */
1758 switch (conncap) {
1759 case P2PS_SETUP_GROUP_OWNER:
1760 conncap = P2PS_SETUP_CLIENT;
1761 break;
1762 case P2PS_SETUP_CLIENT:
1763 conncap = P2PS_SETUP_GROUP_OWNER;
1764 break;
1765 }
1766 }
1767
1768 p2p_dbg(p2p, "Received Provision Discovery Response from " MACSTR
1769 " with config methods 0x%x",
1770 MAC2STR(sa), msg->wps_config_methods);
1771
1772 dev = p2p_get_device(p2p, sa);
1773 if (dev == NULL || !dev->req_config_methods) {
1774 p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
1775 " with no pending request", MAC2STR(sa));
1776 return;
1777 } else if (msg->wfd_subelems) {
1778 wpabuf_free(dev->info.wfd_subelems);
1779 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
1780 }
1781
1782 p2p_update_peer_6ghz_capab(dev, msg);
1783
1784 if (dev->dialog_token != msg->dialog_token) {
1785 p2p_dbg(p2p, "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
1786 msg->dialog_token, dev->dialog_token);
1787 return;
1788 }
1789
1790 if (p2p->pending_action_state == P2P_PENDING_PD) {
1791 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1792 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1793 }
1794
1795 p2ps_seeker = p2p->p2ps_prov && p2p->p2ps_prov->pd_seeker;
1796
1797 /*
1798 * Use a local copy of the requested config methods since
1799 * p2p_reset_pending_pd() can clear this in the peer entry.
1800 */
1801 req_config_methods = dev->req_config_methods;
1802
1803 /*
1804 * If the response is from the peer to whom a user initiated request
1805 * was sent earlier, we reset that state info here.
1806 */
1807 if (p2p->user_initiated_pd &&
1808 ether_addr_equal(p2p->pending_pd_devaddr, sa))
1809 p2p_reset_pending_pd(p2p);
1810
1811 if (msg->wps_config_methods != req_config_methods) {
1812 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request (received config_methods 0x%x expected 0x%x",
1813 msg->wps_config_methods, req_config_methods);
1814 if (p2p->cfg->prov_disc_fail)
1815 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1816 P2P_PROV_DISC_REJECTED,
1817 adv_id, adv_mac, NULL);
1818 p2ps_prov_free(p2p);
1819 goto out;
1820 }
1821
1822 report_config_methods = req_config_methods;
1823 dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
1824 P2P_DEV_PD_PEER_KEYPAD |
1825 P2P_DEV_PD_PEER_P2PS);
1826 if (req_config_methods & WPS_CONFIG_DISPLAY) {
1827 p2p_dbg(p2p, "Peer " MACSTR
1828 " accepted to show a PIN on display", MAC2STR(sa));
1829 dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
1830 passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
1831 } else if (msg->wps_config_methods & WPS_CONFIG_KEYPAD) {
1832 p2p_dbg(p2p, "Peer " MACSTR
1833 " accepted to write our PIN using keypad",
1834 MAC2STR(sa));
1835 dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
1836 passwd_id = DEV_PW_USER_SPECIFIED;
1837 } else if (msg->wps_config_methods & WPS_CONFIG_P2PS) {
1838 p2p_dbg(p2p, "Peer " MACSTR " accepted P2PS PIN",
1839 MAC2STR(sa));
1840 dev->flags |= P2P_DEV_PD_PEER_P2PS;
1841 passwd_id = DEV_PW_P2PS_DEFAULT;
1842 }
1843
1844 if ((status == P2P_SC_SUCCESS || status == P2P_SC_SUCCESS_DEFERRED) &&
1845 p2p->p2ps_prov) {
1846 dev->oper_freq = 0;
1847
1848 /*
1849 * Save the reported channel list and operating frequency.
1850 * Note that the specification mandates that the responder
1851 * should include in the channel list only channels reported by
1852 * the initiator, so this is only a validity check, and if this
1853 * fails the flow would continue, although it would probably
1854 * fail. Same is true for the operating channel.
1855 */
1856 if (msg->channel_list && msg->channel_list_len &&
1857 p2p_peer_channels_check(p2p, &p2p->channels, dev,
1858 msg->channel_list,
1859 msg->channel_list_len) < 0)
1860 p2p_dbg(p2p, "P2PS PD Response - no common channels");
1861
1862 if (msg->operating_channel) {
1863 if (p2p_channels_includes(&p2p->channels,
1864 msg->operating_channel[3],
1865 msg->operating_channel[4]) &&
1866 p2p_channels_includes(&dev->channels,
1867 msg->operating_channel[3],
1868 msg->operating_channel[4])) {
1869 dev->oper_freq =
1870 p2p_channel_to_freq(
1871 msg->operating_channel[3],
1872 msg->operating_channel[4]);
1873 } else {
1874 p2p_dbg(p2p,
1875 "P2PS PD Response - invalid operating channel");
1876 }
1877 }
1878
1879 if (p2p->cfg->p2ps_prov_complete) {
1880 int freq = 0;
1881
1882 if (conncap == P2PS_SETUP_GROUP_OWNER) {
1883 u8 tmp;
1884
1885 /*
1886 * Re-select the operating channel as it is
1887 * possible that original channel is no longer
1888 * valid. This should not really fail.
1889 */
1890 if (p2p_go_select_channel(p2p, dev, &tmp) < 0)
1891 p2p_dbg(p2p,
1892 "P2PS PD channel selection failed");
1893
1894 freq = p2p_channel_to_freq(p2p->op_reg_class,
1895 p2p->op_channel);
1896 if (freq < 0)
1897 freq = 0;
1898 }
1899
1900 p2p->cfg->p2ps_prov_complete(
1901 p2p->cfg->cb_ctx, status, sa, adv_mac,
1902 p2p->p2ps_prov->session_mac,
1903 group_mac, adv_id, p2p->p2ps_prov->session_id,
1904 conncap, passwd_id, msg->persistent_ssid,
1905 msg->persistent_ssid_len, 1, 0, NULL,
1906 msg->feature_cap, msg->feature_cap_len, freq,
1907 msg->group_id ? msg->group_id + ETH_ALEN : NULL,
1908 msg->group_id ? msg->group_id_len - ETH_ALEN :
1909 0);
1910 }
1911 p2ps_prov_free(p2p);
1912 } else if (status != P2P_SC_SUCCESS &&
1913 status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1914 status != P2P_SC_SUCCESS_DEFERRED && p2p->p2ps_prov) {
1915 if (p2p->cfg->p2ps_prov_complete)
1916 p2p->cfg->p2ps_prov_complete(
1917 p2p->cfg->cb_ctx, status, sa, adv_mac,
1918 p2p->p2ps_prov->session_mac,
1919 group_mac, adv_id, p2p->p2ps_prov->session_id,
1920 0, 0, NULL, 0, 1, 0, NULL, NULL, 0, 0, NULL, 0);
1921 p2ps_prov_free(p2p);
1922 }
1923
1924 if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1925 if (p2p->cfg->remove_stale_groups) {
1926 p2p->cfg->remove_stale_groups(p2p->cfg->cb_ctx,
1927 dev->info.p2p_device_addr,
1928 NULL, NULL, 0);
1929 }
1930
1931 if (msg->session_info && msg->session_info_len) {
1932 size_t info_len = msg->session_info_len;
1933 char *deferred_sess_resp = os_malloc(2 * info_len + 1);
1934
1935 if (!deferred_sess_resp) {
1936 p2ps_prov_free(p2p);
1937 goto out;
1938 }
1939 utf8_escape((char *) msg->session_info, info_len,
1940 deferred_sess_resp, 2 * info_len + 1);
1941
1942 if (p2p->cfg->prov_disc_fail)
1943 p2p->cfg->prov_disc_fail(
1944 p2p->cfg->cb_ctx, sa,
1945 P2P_PROV_DISC_INFO_UNAVAILABLE,
1946 adv_id, adv_mac,
1947 deferred_sess_resp);
1948 os_free(deferred_sess_resp);
1949 } else
1950 if (p2p->cfg->prov_disc_fail)
1951 p2p->cfg->prov_disc_fail(
1952 p2p->cfg->cb_ctx, sa,
1953 P2P_PROV_DISC_INFO_UNAVAILABLE,
1954 adv_id, adv_mac, NULL);
1955 } else if (status != P2P_SC_SUCCESS) {
1956 p2p_dbg(p2p, "Peer rejected our Provision Discovery Request");
1957 if (p2p->cfg->prov_disc_fail)
1958 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1959 P2P_PROV_DISC_REJECTED,
1960 adv_id, adv_mac, NULL);
1961 p2ps_prov_free(p2p);
1962 goto out;
1963 }
1964
1965 /* Store the provisioning info */
1966 dev->wps_prov_info = msg->wps_config_methods;
1967 if (msg->intended_addr)
1968 os_memcpy(dev->interface_addr, msg->intended_addr, ETH_ALEN);
1969
1970 out:
1971 dev->req_config_methods = 0;
1972 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1973 if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
1974 p2p_dbg(p2p, "Start GO Neg after the PD-before-GO-Neg workaround with "
1975 MACSTR, MAC2STR(dev->info.p2p_device_addr));
1976 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1977 p2p_connect_send(p2p, dev);
1978 return;
1979 }
1980
1981 /*
1982 * prov_disc_resp callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1983 * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1984 * Call it only for a legacy P2P PD or for P2PS PD scenarios where
1985 * show/enter PIN events are needed.
1986 *
1987 * The callback is called in the following cases:
1988 * 1. Legacy P2P PD response with a status SUCCESS
1989 * 2. P2PS, advertiser method: DISPLAY, autoaccept: true,
1990 * response status: SUCCESS, local method KEYPAD
1991 * 3. P2PS, advertiser method: KEYPAD,Seeker side,
1992 * response status: INFO_CURRENTLY_UNAVAILABLE,
1993 * local method: DISPLAY
1994 */
1995 if (p2p->cfg->prov_disc_resp &&
1996 ((status == P2P_SC_SUCCESS && !adv_id) ||
1997 (p2ps_seeker && status == P2P_SC_SUCCESS &&
1998 passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1999 (p2ps_seeker &&
2000 status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
2001 passwd_id == DEV_PW_USER_SPECIFIED)))
2002 p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
2003 report_config_methods);
2004
2005 if (p2p->state == P2P_PD_DURING_FIND) {
2006 p2p_stop_listen_for_freq(p2p, 0);
2007 p2p_continue_find(p2p);
2008 }
2009 }
2010
2011
p2p_handle_prov_disc_resp(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)2012 void p2p_handle_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
2013 const u8 *data, size_t len, int rx_freq)
2014 {
2015 struct p2p_message msg;
2016
2017 if (p2p_parse(data, len, &msg))
2018 return;
2019
2020 if (msg.pcea_info && msg.pbma_info)
2021 p2p_process_prov_disc_bootstrap_resp(p2p, &msg, sa, data + 1,
2022 len - 1, rx_freq);
2023 else
2024 p2p_process_prov_disc_resp(p2p, &msg, sa, data + 1, len - 1);
2025
2026 p2p_parse_free(&msg);
2027 }
2028
2029
p2p_send_prov_disc_req(struct p2p_data * p2p,struct p2p_device * dev,int join,int force_freq)2030 int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
2031 int join, int force_freq)
2032 {
2033 struct wpabuf *req;
2034 int freq;
2035
2036 if (force_freq > 0)
2037 freq = force_freq;
2038 else
2039 freq = dev->listen_freq > 0 ? dev->listen_freq :
2040 dev->oper_freq;
2041 if (freq <= 0) {
2042 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
2043 MACSTR " to send Provision Discovery Request",
2044 MAC2STR(dev->info.p2p_device_addr));
2045 return -1;
2046 }
2047
2048 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
2049 if (!(dev->info.dev_capab &
2050 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
2051 p2p_dbg(p2p, "Cannot use PD with P2P Device " MACSTR
2052 " that is in a group and is not discoverable",
2053 MAC2STR(dev->info.p2p_device_addr));
2054 return -1;
2055 }
2056 /* TODO: use device discoverability request through GO */
2057 }
2058
2059 if (!dev->p2p2 && p2p->p2ps_prov) {
2060 if (p2p->p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED) {
2061 if (p2p->p2ps_prov->method == WPS_CONFIG_DISPLAY)
2062 dev->req_config_methods = WPS_CONFIG_KEYPAD;
2063 else if (p2p->p2ps_prov->method == WPS_CONFIG_KEYPAD)
2064 dev->req_config_methods = WPS_CONFIG_DISPLAY;
2065 else
2066 dev->req_config_methods = WPS_CONFIG_P2PS;
2067 } else {
2068 /* Order of preference, based on peer's capabilities */
2069 if (p2p->p2ps_prov->method)
2070 dev->req_config_methods =
2071 p2p->p2ps_prov->method;
2072 else if (dev->info.config_methods & WPS_CONFIG_P2PS)
2073 dev->req_config_methods = WPS_CONFIG_P2PS;
2074 else if (dev->info.config_methods & WPS_CONFIG_DISPLAY)
2075 dev->req_config_methods = WPS_CONFIG_DISPLAY;
2076 else
2077 dev->req_config_methods = WPS_CONFIG_KEYPAD;
2078 }
2079 p2p_dbg(p2p,
2080 "Building PD Request based on P2PS config method 0x%x status %d --> req_config_methods 0x%x",
2081 p2p->p2ps_prov->method, p2p->p2ps_prov->status,
2082 dev->req_config_methods);
2083
2084 if (p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
2085 p2p->p2ps_prov->pref_freq, 1) < 0)
2086 return -1;
2087 }
2088
2089 if (dev->p2p2)
2090 req = p2p_build_prov_disc_bootstrap_req(p2p, dev);
2091 else
2092 req = p2p_build_prov_disc_req(p2p, dev, join);
2093
2094 if (req == NULL)
2095 return -1;
2096
2097 if (p2p->state != P2P_IDLE)
2098 p2p_stop_listen_for_freq(p2p, freq);
2099 p2p->pending_action_state = P2P_PENDING_PD;
2100 if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
2101 p2p->cfg->dev_addr, dev->info.p2p_device_addr,
2102 wpabuf_head(req), wpabuf_len(req), 200) < 0) {
2103 p2p_dbg(p2p, "Failed to send Action frame");
2104 wpabuf_free(req);
2105 return -1;
2106 }
2107
2108 os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
2109
2110 wpabuf_free(req);
2111 return 0;
2112 }
2113
2114
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)2115 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
2116 struct p2ps_provision *p2ps_prov,
2117 u16 config_methods, int join, int force_freq,
2118 int user_initiated_pd)
2119 {
2120 struct p2p_device *dev;
2121
2122 dev = p2p_get_device(p2p, peer_addr);
2123 if (dev == NULL)
2124 dev = p2p_get_device_interface(p2p, peer_addr);
2125 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
2126 p2p_dbg(p2p, "Provision Discovery Request destination " MACSTR
2127 " not yet known", MAC2STR(peer_addr));
2128 os_free(p2ps_prov);
2129 return -1;
2130 }
2131
2132 if (dev->p2p2 && dev->req_bootstrap_method) {
2133 p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
2134 " (bootstrap methods 0x%x)",
2135 MAC2STR(peer_addr), dev->req_bootstrap_method);
2136 goto out;
2137 }
2138
2139 p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
2140 " (config methods 0x%x)",
2141 MAC2STR(peer_addr), config_methods);
2142
2143 if (config_methods == 0 && !p2ps_prov) {
2144 os_free(p2ps_prov);
2145 return -1;
2146 }
2147 dev->req_config_methods = config_methods;
2148
2149 if (p2ps_prov && p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED &&
2150 p2p->p2ps_prov) {
2151 /* Use cached method from deferred provisioning */
2152 p2ps_prov->method = p2p->p2ps_prov->method;
2153 }
2154
2155 out:
2156 /* Reset provisioning info */
2157 dev->wps_prov_info = 0;
2158 p2ps_prov_free(p2p);
2159 p2p->p2ps_prov = p2ps_prov;
2160
2161 if (join)
2162 dev->flags |= P2P_DEV_PD_FOR_JOIN;
2163 else
2164 dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
2165
2166 if (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
2167 p2p->state != P2P_LISTEN_ONLY) {
2168 p2p_dbg(p2p, "Busy with other operations; postpone Provision Discovery Request with "
2169 MACSTR, MAC2STR(peer_addr));
2170 return 0;
2171 }
2172
2173 p2p->user_initiated_pd = user_initiated_pd;
2174 p2p->pd_force_freq = force_freq;
2175
2176 if (p2p->user_initiated_pd)
2177 p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
2178
2179 /*
2180 * Assign dialog token here to use the same value in each retry within
2181 * the same PD exchange.
2182 */
2183 dev->dialog_token++;
2184 if (dev->dialog_token == 0)
2185 dev->dialog_token = 1;
2186
2187 return p2p_send_prov_disc_req(p2p, dev, join, force_freq);
2188 }
2189
2190
p2p_reset_pending_pd(struct p2p_data * p2p)2191 void p2p_reset_pending_pd(struct p2p_data *p2p)
2192 {
2193 struct p2p_device *dev;
2194
2195 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2196 if (!ether_addr_equal(p2p->pending_pd_devaddr,
2197 dev->info.p2p_device_addr))
2198 continue;
2199 if (!dev->req_config_methods)
2200 continue;
2201 if (dev->flags & P2P_DEV_PD_FOR_JOIN)
2202 continue;
2203 /* Reset the config methods of the device */
2204 dev->req_config_methods = 0;
2205 }
2206
2207 p2p->user_initiated_pd = 0;
2208 os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
2209 p2p->pd_retries = 0;
2210 p2p->pd_force_freq = 0;
2211 }
2212
2213
p2ps_prov_free(struct p2p_data * p2p)2214 void p2ps_prov_free(struct p2p_data *p2p)
2215 {
2216 os_free(p2p->p2ps_prov);
2217 p2p->p2ps_prov = NULL;
2218 }
2219