xref: /freebsd/contrib/wpa/src/p2p/p2p_pd.c (revision cfd6422a5217410fbd66f7a7a8a64d9d85e61229)
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 
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 
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 
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 			p2p_buf_add_channel_list(buf, p2p->cfg->country,
129 						 &p2p->channels);
130 
131 		if ((shared_group && !is_zero_ether_addr(intended_addr)) ||
132 		    (prov->conncap & (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW)))
133 			p2p_buf_add_operating_channel(buf, p2p->cfg->country,
134 						      p2p->op_reg_class,
135 						      p2p->op_channel);
136 	}
137 
138 	if (prov->status < 0 && prov->info[0])
139 		p2p_buf_add_session_info(buf, prov->info);
140 
141 	if (!follow_on_req_fail)
142 		p2p_buf_add_connection_capability(buf, prov->conncap);
143 
144 	p2p_buf_add_advertisement_id(buf, prov->adv_id, prov->adv_mac);
145 
146 	if (!follow_on_req_fail) {
147 		if (shared_group || prov->conncap == P2PS_SETUP_NEW ||
148 		    prov->conncap ==
149 		    (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_NEW) ||
150 		    prov->conncap ==
151 		    (P2PS_SETUP_GROUP_OWNER | P2PS_SETUP_CLIENT)) {
152 			/* Add Config Timeout */
153 			p2p_buf_add_config_timeout(buf, p2p->go_timeout,
154 						   p2p->client_timeout);
155 		}
156 
157 		p2p_buf_add_listen_channel(buf, p2p->cfg->country,
158 					   p2p->cfg->reg_class,
159 					   p2p->cfg->channel);
160 	}
161 
162 	p2p_buf_add_session_id(buf, prov->session_id, prov->session_mac);
163 
164 	p2p_buf_add_feature_capability(buf, sizeof(fcap), (const u8 *) &fcap);
165 
166 	if (shared_group) {
167 		p2p_buf_add_persistent_group_info(buf, go_dev_addr,
168 						  ssid, ssid_len);
169 		/* Add intended interface address if it is not added yet */
170 		if ((prov->conncap == P2PS_SETUP_NONE ||
171 		     prov->conncap == P2PS_SETUP_CLIENT) &&
172 		    !is_zero_ether_addr(intended_addr))
173 			p2p_buf_add_intended_addr(buf, intended_addr);
174 	}
175 }
176 
177 
178 static struct wpabuf * p2p_build_prov_disc_req(struct p2p_data *p2p,
179 					       struct p2p_device *dev,
180 					       int join)
181 {
182 	struct wpabuf *buf;
183 	u8 *len;
184 	size_t extra = 0;
185 	u8 dialog_token = dev->dialog_token;
186 	u16 config_methods = dev->req_config_methods;
187 	struct p2p_device *go = join ? dev : NULL;
188 	u8 group_capab;
189 
190 #ifdef CONFIG_WIFI_DISPLAY
191 	if (p2p->wfd_ie_prov_disc_req)
192 		extra = wpabuf_len(p2p->wfd_ie_prov_disc_req);
193 #endif /* CONFIG_WIFI_DISPLAY */
194 
195 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
196 		extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
197 
198 	if (p2p->p2ps_prov)
199 		extra += os_strlen(p2p->p2ps_prov->info) + 1 +
200 			sizeof(struct p2ps_provision);
201 
202 	buf = wpabuf_alloc(1000 + extra);
203 	if (buf == NULL)
204 		return NULL;
205 
206 	p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
207 
208 	len = p2p_buf_add_ie_hdr(buf);
209 
210 	group_capab = 0;
211 	if (p2p->p2ps_prov) {
212 		group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
213 		group_capab |= P2P_GROUP_CAPAB_PERSISTENT_RECONN;
214 		if (p2p->cross_connect)
215 			group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
216 		if (p2p->cfg->p2p_intra_bss)
217 			group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
218 	}
219 	p2p_buf_add_capability(buf, p2p->dev_capab &
220 			       ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
221 			       group_capab);
222 	p2p_buf_add_device_info(buf, p2p, NULL);
223 	if (p2p->p2ps_prov) {
224 		p2ps_add_pd_req_attrs(p2p, dev, buf, config_methods);
225 	} else if (go) {
226 		p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
227 				     go->oper_ssid, go->oper_ssid_len);
228 	}
229 	p2p_buf_update_ie_hdr(buf, len);
230 
231 	/* WPS IE with Config Methods attribute */
232 	p2p_build_wps_ie_config_methods(buf, config_methods);
233 
234 #ifdef CONFIG_WIFI_DISPLAY
235 	if (p2p->wfd_ie_prov_disc_req)
236 		wpabuf_put_buf(buf, p2p->wfd_ie_prov_disc_req);
237 #endif /* CONFIG_WIFI_DISPLAY */
238 
239 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ])
240 		wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_REQ]);
241 
242 	return buf;
243 }
244 
245 
246 static struct wpabuf * p2p_build_prov_disc_resp(struct p2p_data *p2p,
247 						struct p2p_device *dev,
248 						u8 dialog_token,
249 						enum p2p_status_code status,
250 						u16 config_methods,
251 						u32 adv_id,
252 						const u8 *group_id,
253 						size_t group_id_len,
254 						const u8 *persist_ssid,
255 						size_t persist_ssid_len,
256 						const u8 *fcap,
257 						u16 fcap_len)
258 {
259 	struct wpabuf *buf;
260 	size_t extra = 0;
261 	int persist = 0;
262 
263 #ifdef CONFIG_WIFI_DISPLAY
264 	struct wpabuf *wfd_ie = p2p->wfd_ie_prov_disc_resp;
265 	if (wfd_ie && group_id) {
266 		size_t i;
267 		for (i = 0; i < p2p->num_groups; i++) {
268 			struct p2p_group *g = p2p->groups[i];
269 			struct wpabuf *ie;
270 			if (!p2p_group_is_group_id_match(g, group_id,
271 							 group_id_len))
272 				continue;
273 			ie = p2p_group_get_wfd_ie(g);
274 			if (ie) {
275 				wfd_ie = ie;
276 				break;
277 			}
278 		}
279 	}
280 	if (wfd_ie)
281 		extra = wpabuf_len(wfd_ie);
282 #endif /* CONFIG_WIFI_DISPLAY */
283 
284 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
285 		extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
286 
287 	buf = wpabuf_alloc(1000 + extra);
288 	if (buf == NULL)
289 		return NULL;
290 
291 	p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
292 
293 	/* Add P2P IE for P2PS */
294 	if (p2p->p2ps_prov && p2p->p2ps_prov->adv_id == adv_id) {
295 		u8 *len = p2p_buf_add_ie_hdr(buf);
296 		struct p2ps_provision *prov = p2p->p2ps_prov;
297 		u8 group_capab;
298 		u8 conncap = 0;
299 
300 		if (status == P2P_SC_SUCCESS ||
301 		    status == P2P_SC_SUCCESS_DEFERRED)
302 			conncap = prov->conncap;
303 
304 		if (!status && prov->status != -1)
305 			status = prov->status;
306 
307 		p2p_buf_add_status(buf, status);
308 		group_capab = P2P_GROUP_CAPAB_PERSISTENT_GROUP |
309 			P2P_GROUP_CAPAB_PERSISTENT_RECONN;
310 		if (p2p->cross_connect)
311 			group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
312 		if (p2p->cfg->p2p_intra_bss)
313 			group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
314 		p2p_buf_add_capability(buf, p2p->dev_capab &
315 				       ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
316 				       group_capab);
317 		p2p_buf_add_device_info(buf, p2p, NULL);
318 
319 		if (persist_ssid && p2p->cfg->get_persistent_group && dev &&
320 		    (status == P2P_SC_SUCCESS ||
321 		     status == P2P_SC_SUCCESS_DEFERRED)) {
322 			u8 ssid[SSID_MAX_LEN];
323 			size_t ssid_len;
324 			u8 go_dev_addr[ETH_ALEN];
325 			u8 intended_addr[ETH_ALEN];
326 
327 			persist = p2p->cfg->get_persistent_group(
328 				p2p->cfg->cb_ctx,
329 				dev->info.p2p_device_addr,
330 				persist_ssid, persist_ssid_len, go_dev_addr,
331 				ssid, &ssid_len, intended_addr);
332 			if (persist) {
333 				p2p_buf_add_persistent_group_info(
334 					buf, go_dev_addr, ssid, ssid_len);
335 				if (!is_zero_ether_addr(intended_addr))
336 					p2p_buf_add_intended_addr(
337 						buf, intended_addr);
338 			}
339 		}
340 
341 		if (!persist && (conncap & P2PS_SETUP_GROUP_OWNER))
342 			p2ps_add_new_group_info(p2p, dev, buf);
343 
344 		/* Add Operating Channel if conncap indicates GO */
345 		if (persist || (conncap & P2PS_SETUP_GROUP_OWNER)) {
346 			if (p2p->op_reg_class && p2p->op_channel)
347 				p2p_buf_add_operating_channel(
348 					buf, p2p->cfg->country,
349 					p2p->op_reg_class,
350 					p2p->op_channel);
351 			else
352 				p2p_buf_add_operating_channel(
353 					buf, p2p->cfg->country,
354 					p2p->cfg->op_reg_class,
355 					p2p->cfg->op_channel);
356 		}
357 
358 		if (persist ||
359 		    (conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER)))
360 			p2p_buf_add_channel_list(buf, p2p->cfg->country,
361 						 &p2p->channels);
362 
363 		if (!persist && conncap)
364 			p2p_buf_add_connection_capability(buf, conncap);
365 
366 		p2p_buf_add_advertisement_id(buf, adv_id, prov->adv_mac);
367 
368 		if (persist ||
369 		    (conncap & (P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER)))
370 			p2p_buf_add_config_timeout(buf, p2p->go_timeout,
371 						   p2p->client_timeout);
372 
373 		p2p_buf_add_session_id(buf, prov->session_id,
374 				       prov->session_mac);
375 
376 		p2p_buf_add_feature_capability(buf, fcap_len, fcap);
377 		p2p_buf_update_ie_hdr(buf, len);
378 	} else if (status != P2P_SC_SUCCESS || adv_id) {
379 		u8 *len = p2p_buf_add_ie_hdr(buf);
380 
381 		p2p_buf_add_status(buf, status);
382 
383 		if (p2p->p2ps_prov)
384 			p2p_buf_add_advertisement_id(buf, adv_id,
385 						     p2p->p2ps_prov->adv_mac);
386 
387 		p2p_buf_update_ie_hdr(buf, len);
388 	}
389 
390 	/* WPS IE with Config Methods attribute */
391 	p2p_build_wps_ie_config_methods(buf, config_methods);
392 
393 #ifdef CONFIG_WIFI_DISPLAY
394 	if (wfd_ie)
395 		wpabuf_put_buf(buf, wfd_ie);
396 #endif /* CONFIG_WIFI_DISPLAY */
397 
398 	if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP])
399 		wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_PD_RESP]);
400 
401 	return buf;
402 }
403 
404 
405 static int p2ps_setup_p2ps_prov(struct p2p_data *p2p, u32 adv_id,
406 				u32 session_id, u16 method,
407 				const u8 *session_mac, const u8 *adv_mac)
408 {
409 	struct p2ps_provision *tmp;
410 
411 	if (!p2p->p2ps_prov) {
412 		p2p->p2ps_prov = os_zalloc(sizeof(struct p2ps_provision) + 1);
413 		if (!p2p->p2ps_prov)
414 			return -1;
415 	} else {
416 		os_memset(p2p->p2ps_prov, 0, sizeof(struct p2ps_provision) + 1);
417 	}
418 
419 	tmp = p2p->p2ps_prov;
420 	tmp->adv_id = adv_id;
421 	tmp->session_id = session_id;
422 	tmp->method = method;
423 	os_memcpy(tmp->session_mac, session_mac, ETH_ALEN);
424 	os_memcpy(tmp->adv_mac, adv_mac, ETH_ALEN);
425 	tmp->info[0] = '\0';
426 
427 	return 0;
428 }
429 
430 
431 static u8 p2ps_own_preferred_cpt(const u8 *cpt_priority, u8 req_cpt_mask)
432 {
433 	int i;
434 
435 	for (i = 0; cpt_priority[i]; i++)
436 		if (req_cpt_mask & cpt_priority[i])
437 			return cpt_priority[i];
438 
439 	return 0;
440 }
441 
442 
443 /* Check if the message contains a valid P2PS PD Request */
444 static int p2ps_validate_pd_req(struct p2p_data *p2p, struct p2p_message *msg,
445 				const u8 *addr)
446 {
447 	u8 group_id = 0;
448 	u8 intended_addr = 0;
449 	u8 operating_channel = 0;
450 	u8 channel_list = 0;
451 	u8 config_timeout = 0;
452 	u8 listen_channel = 0;
453 
454 #define P2PS_PD_REQ_CHECK(_val, _attr) \
455 do { \
456 	if ((_val) && !msg->_attr) { \
457 		p2p_dbg(p2p, "Not P2PS PD Request. Missing %s", #_attr); \
458 		return -1; \
459 	} \
460 } while (0)
461 
462 	P2PS_PD_REQ_CHECK(1, adv_id);
463 	P2PS_PD_REQ_CHECK(1, session_id);
464 	P2PS_PD_REQ_CHECK(1, session_mac);
465 	P2PS_PD_REQ_CHECK(1, adv_mac);
466 	P2PS_PD_REQ_CHECK(1, capability);
467 	P2PS_PD_REQ_CHECK(1, p2p_device_info);
468 	P2PS_PD_REQ_CHECK(1, feature_cap);
469 
470 	/*
471 	 * We don't need to check Connection Capability, Persistent Group,
472 	 * and related attributes for follow-on PD Request with a status
473 	 * other than SUCCESS_DEFERRED.
474 	 */
475 	if (msg->status && *msg->status != P2P_SC_SUCCESS_DEFERRED)
476 		return 0;
477 
478 	P2PS_PD_REQ_CHECK(1, conn_cap);
479 
480 	/*
481 	 * Note 1: A feature capability attribute structure can be changed
482 	 * in the future. The assumption is that such modifications are
483 	 * backward compatible, therefore we allow processing of msg.feature_cap
484 	 * exceeding the size of the p2ps_feature_capab structure.
485 	 * Note 2: Verification of msg.feature_cap_len below has to be changed
486 	 * to allow 2 byte feature capability processing if
487 	 * struct p2ps_feature_capab is extended to include additional fields
488 	 * and it affects the structure size.
489 	 */
490 	if (msg->feature_cap_len < sizeof(struct p2ps_feature_capab)) {
491 		p2p_dbg(p2p, "P2PS: Invalid feature capability len");
492 		return -1;
493 	}
494 
495 	switch (*msg->conn_cap) {
496 	case P2PS_SETUP_NEW:
497 		group_id = 1;
498 		intended_addr = 1;
499 		operating_channel = 1;
500 		channel_list = 1;
501 		config_timeout = 1;
502 		listen_channel = 1;
503 		break;
504 	case P2PS_SETUP_CLIENT:
505 		channel_list = 1;
506 		listen_channel = 1;
507 		break;
508 	case P2PS_SETUP_GROUP_OWNER:
509 		group_id = 1;
510 		intended_addr = 1;
511 		operating_channel = 1;
512 		break;
513 	case P2PS_SETUP_NEW | P2PS_SETUP_GROUP_OWNER:
514 		group_id = 1;
515 		operating_channel = 1;
516 		intended_addr = 1;
517 		channel_list = 1;
518 		config_timeout = 1;
519 		break;
520 	case P2PS_SETUP_CLIENT | P2PS_SETUP_GROUP_OWNER:
521 		group_id = 1;
522 		intended_addr = 1;
523 		operating_channel = 1;
524 		channel_list = 1;
525 		config_timeout = 1;
526 		break;
527 	default:
528 		p2p_dbg(p2p, "Invalid P2PS PD connection capability");
529 		return -1;
530 	}
531 
532 	if (msg->persistent_dev) {
533 		channel_list = 1;
534 		config_timeout = 1;
535 		if (os_memcmp(msg->persistent_dev, addr, ETH_ALEN) == 0) {
536 			intended_addr = 1;
537 			operating_channel = 1;
538 		}
539 	}
540 
541 	P2PS_PD_REQ_CHECK(group_id, group_id);
542 	P2PS_PD_REQ_CHECK(intended_addr, intended_addr);
543 	P2PS_PD_REQ_CHECK(operating_channel, operating_channel);
544 	P2PS_PD_REQ_CHECK(channel_list, channel_list);
545 	P2PS_PD_REQ_CHECK(config_timeout, config_timeout);
546 	P2PS_PD_REQ_CHECK(listen_channel, listen_channel);
547 
548 #undef P2PS_PD_REQ_CHECK
549 
550 	return 0;
551 }
552 
553 
554 void p2p_process_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
555 			       const u8 *data, size_t len, int rx_freq)
556 {
557 	struct p2p_message msg;
558 	struct p2p_device *dev;
559 	int freq;
560 	enum p2p_status_code reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
561 	struct wpabuf *resp;
562 	u32 adv_id = 0;
563 	struct p2ps_advertisement *p2ps_adv = NULL;
564 	u8 conncap = P2PS_SETUP_NEW;
565 	u8 auto_accept = 0;
566 	u32 session_id = 0;
567 	u8 session_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
568 	u8 adv_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
569 	const u8 *group_mac;
570 	int passwd_id = DEV_PW_DEFAULT;
571 	u16 config_methods;
572 	u16 allowed_config_methods = WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD;
573 	struct p2ps_feature_capab resp_fcap = { 0, 0 };
574 	struct p2ps_feature_capab *req_fcap = NULL;
575 	u8 remote_conncap;
576 	u16 method;
577 
578 	if (p2p_parse(data, len, &msg))
579 		return;
580 
581 	p2p_dbg(p2p, "Received Provision Discovery Request from " MACSTR
582 		" with config methods 0x%x (freq=%d)",
583 		MAC2STR(sa), msg.wps_config_methods, rx_freq);
584 	group_mac = msg.intended_addr;
585 
586 	dev = p2p_get_device(p2p, sa);
587 	if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
588 		p2p_dbg(p2p, "Provision Discovery Request from unknown peer "
589 			MACSTR, MAC2STR(sa));
590 
591 		if (p2p_add_device(p2p, sa, rx_freq, NULL, 0, data + 1, len - 1,
592 				   0)) {
593 			p2p_dbg(p2p, "Provision Discovery Request add device failed "
594 				MACSTR, MAC2STR(sa));
595 			goto out;
596 		}
597 
598 		if (!dev) {
599 			dev = p2p_get_device(p2p, sa);
600 			if (!dev) {
601 				p2p_dbg(p2p,
602 					"Provision Discovery device not found "
603 					MACSTR, MAC2STR(sa));
604 				goto out;
605 			}
606 		}
607 	} else if (msg.wfd_subelems) {
608 		wpabuf_free(dev->info.wfd_subelems);
609 		dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
610 	}
611 
612 	if (!msg.adv_id) {
613 		allowed_config_methods |= WPS_CONFIG_PUSHBUTTON;
614 		if (!(msg.wps_config_methods & allowed_config_methods)) {
615 			p2p_dbg(p2p,
616 				"Unsupported Config Methods in Provision Discovery Request");
617 			goto out;
618 		}
619 
620 		/* Legacy (non-P2PS) - Unknown groups allowed for P2PS */
621 		if (msg.group_id) {
622 			size_t i;
623 
624 			for (i = 0; i < p2p->num_groups; i++) {
625 				if (p2p_group_is_group_id_match(
626 					    p2p->groups[i],
627 					    msg.group_id, msg.group_id_len))
628 					break;
629 			}
630 			if (i == p2p->num_groups) {
631 				p2p_dbg(p2p,
632 					"PD request for unknown P2P Group ID - reject");
633 				goto out;
634 			}
635 		}
636 	} else {
637 		allowed_config_methods |= WPS_CONFIG_P2PS;
638 
639 		/*
640 		 * Set adv_id here, so in case of an error, a P2PS PD Response
641 		 * will be sent.
642 		 */
643 		adv_id = WPA_GET_LE32(msg.adv_id);
644 		if (p2ps_validate_pd_req(p2p, &msg, sa) < 0) {
645 			reject = P2P_SC_FAIL_INVALID_PARAMS;
646 			goto out;
647 		}
648 
649 		req_fcap = (struct p2ps_feature_capab *) msg.feature_cap;
650 
651 		os_memcpy(session_mac, msg.session_mac, ETH_ALEN);
652 		os_memcpy(adv_mac, msg.adv_mac, ETH_ALEN);
653 
654 		session_id = WPA_GET_LE32(msg.session_id);
655 
656 		if (msg.conn_cap)
657 			conncap = *msg.conn_cap;
658 
659 		/*
660 		 * We need to verify a P2PS config methog in an initial PD
661 		 * request or in a follow-on PD request with the status
662 		 * SUCCESS_DEFERRED.
663 		 */
664 		if ((!msg.status || *msg.status == P2P_SC_SUCCESS_DEFERRED) &&
665 		    !(msg.wps_config_methods & allowed_config_methods)) {
666 			p2p_dbg(p2p,
667 				"Unsupported Config Methods in Provision Discovery Request");
668 			goto out;
669 		}
670 
671 		/*
672 		 * TODO: since we don't support multiple PD, reject PD request
673 		 * if we are in the middle of P2PS PD with some other peer
674 		 */
675 	}
676 
677 	dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
678 			P2P_DEV_PD_PEER_KEYPAD |
679 			P2P_DEV_PD_PEER_P2PS);
680 
681 	if (msg.wps_config_methods & WPS_CONFIG_DISPLAY) {
682 		p2p_dbg(p2p, "Peer " MACSTR
683 			" requested us to show a PIN on display", MAC2STR(sa));
684 		dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
685 		passwd_id = DEV_PW_USER_SPECIFIED;
686 	} else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
687 		p2p_dbg(p2p, "Peer " MACSTR
688 			" requested us to write its PIN using keypad",
689 			MAC2STR(sa));
690 		dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
691 		passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
692 	} else if (msg.wps_config_methods & WPS_CONFIG_P2PS) {
693 		p2p_dbg(p2p, "Peer " MACSTR " requesting P2PS PIN",
694 			MAC2STR(sa));
695 		dev->flags |= P2P_DEV_PD_PEER_P2PS;
696 		passwd_id = DEV_PW_P2PS_DEFAULT;
697 	}
698 
699 	/* Remove stale persistent groups */
700 	if (p2p->cfg->remove_stale_groups) {
701 		p2p->cfg->remove_stale_groups(
702 			p2p->cfg->cb_ctx, dev->info.p2p_device_addr,
703 			msg.persistent_dev,
704 			msg.persistent_ssid, msg.persistent_ssid_len);
705 	}
706 
707 	reject = P2P_SC_SUCCESS;
708 
709 	/*
710 	 * End of a legacy P2P PD Request processing, from this point continue
711 	 * with P2PS one.
712 	 */
713 	if (!msg.adv_id)
714 		goto out;
715 
716 	remote_conncap = conncap;
717 
718 	if (!msg.status) {
719 		unsigned int forced_freq, pref_freq;
720 
721 		if (os_memcmp(p2p->cfg->dev_addr, msg.adv_mac, ETH_ALEN)) {
722 			p2p_dbg(p2p,
723 				"P2PS PD adv mac does not match the local one");
724 			reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
725 			goto out;
726 		}
727 
728 		p2ps_adv = p2p_service_p2ps_id(p2p, adv_id);
729 		if (!p2ps_adv) {
730 			p2p_dbg(p2p, "P2PS PD invalid adv_id=0x%X", adv_id);
731 			reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
732 			goto out;
733 		}
734 		p2p_dbg(p2p, "adv_id: 0x%X, p2ps_adv: %p", adv_id, p2ps_adv);
735 
736 		auto_accept = p2ps_adv->auto_accept;
737 		conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
738 							  conncap, auto_accept,
739 							  &forced_freq,
740 							  &pref_freq);
741 
742 		p2p_dbg(p2p, "Conncap: local:%d remote:%d result:%d",
743 			auto_accept, remote_conncap, conncap);
744 
745 		p2p_prepare_channel(p2p, dev, forced_freq, pref_freq, 0);
746 
747 		resp_fcap.cpt = p2ps_own_preferred_cpt(p2ps_adv->cpt_priority,
748 						       req_fcap->cpt);
749 
750 		p2p_dbg(p2p, "cpt: service:0x%x remote:0x%x result:0x%x",
751 			p2ps_adv->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
752 
753 		if (!resp_fcap.cpt) {
754 			p2p_dbg(p2p,
755 				"Incompatible P2PS feature capability CPT bitmask");
756 			reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
757 		} else if (p2ps_adv->config_methods &&
758 			   !(msg.wps_config_methods &
759 			     p2ps_adv->config_methods)) {
760 			p2p_dbg(p2p,
761 				"Unsupported config methods in Provision Discovery Request (own=0x%x peer=0x%x)",
762 				p2ps_adv->config_methods,
763 				msg.wps_config_methods);
764 			reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
765 		} else if (!p2ps_adv->state) {
766 			p2p_dbg(p2p, "P2PS state unavailable");
767 			reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
768 		} else if (!conncap) {
769 			p2p_dbg(p2p, "Conncap resolution failed");
770 			reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
771 		}
772 
773 		if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
774 			p2p_dbg(p2p, "Keypad - always defer");
775 			auto_accept = 0;
776 		}
777 
778 		if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
779 		     msg.persistent_dev) && conncap != P2PS_SETUP_NEW &&
780 		    msg.channel_list && msg.channel_list_len &&
781 		    p2p_peer_channels_check(p2p, &p2p->channels, dev,
782 					    msg.channel_list,
783 					    msg.channel_list_len) < 0) {
784 			p2p_dbg(p2p,
785 				"No common channels - force deferred flow");
786 			auto_accept = 0;
787 		}
788 
789 		if (((remote_conncap & P2PS_SETUP_GROUP_OWNER) ||
790 		     msg.persistent_dev) && msg.operating_channel) {
791 			struct p2p_channels intersect;
792 
793 			/*
794 			 * There are cases where only the operating channel is
795 			 * provided. This requires saving the channel as the
796 			 * supported channel list, and verifying that it is
797 			 * supported.
798 			 */
799 			if (dev->channels.reg_classes == 0 ||
800 			    !p2p_channels_includes(&dev->channels,
801 						   msg.operating_channel[3],
802 						   msg.operating_channel[4])) {
803 				struct p2p_channels *ch = &dev->channels;
804 
805 				os_memset(ch, 0, sizeof(*ch));
806 				ch->reg_class[0].reg_class =
807 					msg.operating_channel[3];
808 				ch->reg_class[0].channel[0] =
809 					msg.operating_channel[4];
810 				ch->reg_class[0].channels = 1;
811 				ch->reg_classes = 1;
812 			}
813 
814 			p2p_channels_intersect(&p2p->channels, &dev->channels,
815 					       &intersect);
816 
817 			if (intersect.reg_classes == 0) {
818 				p2p_dbg(p2p,
819 					"No common channels - force deferred flow");
820 				auto_accept = 0;
821 			}
822 		}
823 
824 		if (auto_accept || reject != P2P_SC_SUCCESS) {
825 			struct p2ps_provision *tmp;
826 
827 			if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
828 						 msg.wps_config_methods,
829 						 session_mac, adv_mac) < 0) {
830 				reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
831 				goto out;
832 			}
833 
834 			tmp = p2p->p2ps_prov;
835 			tmp->force_freq = forced_freq;
836 			tmp->pref_freq = pref_freq;
837 			if (conncap) {
838 				tmp->conncap = conncap;
839 				tmp->status = P2P_SC_SUCCESS;
840 			} else {
841 				tmp->conncap = auto_accept;
842 				tmp->status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
843 			}
844 
845 			if (reject != P2P_SC_SUCCESS)
846 				goto out;
847 		}
848 	}
849 
850 	if (!msg.status && !auto_accept &&
851 	    (!p2p->p2ps_prov || p2p->p2ps_prov->adv_id != adv_id)) {
852 		struct p2ps_provision *tmp;
853 
854 		if (!conncap) {
855 			reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
856 			goto out;
857 		}
858 
859 		if (p2ps_setup_p2ps_prov(p2p, adv_id, session_id,
860 					 msg.wps_config_methods,
861 					 session_mac, adv_mac) < 0) {
862 			reject = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
863 			goto out;
864 		}
865 		tmp = p2p->p2ps_prov;
866 		reject = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
867 		tmp->status = reject;
868 	}
869 
870 	/* Not a P2PS Follow-on PD */
871 	if (!msg.status)
872 		goto out;
873 
874 	if (*msg.status && *msg.status != P2P_SC_SUCCESS_DEFERRED) {
875 		reject = *msg.status;
876 		goto out;
877 	}
878 
879 	if (*msg.status != P2P_SC_SUCCESS_DEFERRED || !p2p->p2ps_prov)
880 		goto out;
881 
882 	if (p2p->p2ps_prov->adv_id != adv_id ||
883 	    os_memcmp(p2p->p2ps_prov->adv_mac, msg.adv_mac, ETH_ALEN)) {
884 		p2p_dbg(p2p,
885 			"P2PS Follow-on PD with mismatch Advertisement ID/MAC");
886 		goto out;
887 	}
888 
889 	if (p2p->p2ps_prov->session_id != session_id ||
890 	    os_memcmp(p2p->p2ps_prov->session_mac, msg.session_mac, ETH_ALEN)) {
891 		p2p_dbg(p2p, "P2PS Follow-on PD with mismatch Session ID/MAC");
892 		goto out;
893 	}
894 
895 	method = p2p->p2ps_prov->method;
896 
897 	conncap = p2p->cfg->p2ps_group_capability(p2p->cfg->cb_ctx,
898 						  remote_conncap,
899 						  p2p->p2ps_prov->conncap,
900 						  &p2p->p2ps_prov->force_freq,
901 						  &p2p->p2ps_prov->pref_freq);
902 
903 	resp_fcap.cpt = p2ps_own_preferred_cpt(p2p->p2ps_prov->cpt_priority,
904 					       req_fcap->cpt);
905 
906 	p2p_dbg(p2p, "cpt: local:0x%x remote:0x%x result:0x%x",
907 		p2p->p2ps_prov->cpt_mask, req_fcap->cpt, resp_fcap.cpt);
908 
909 	p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
910 			    p2p->p2ps_prov->pref_freq, 0);
911 
912 	/*
913 	 * Ensure that if we asked for PIN originally, our method is consistent
914 	 * with original request.
915 	 */
916 	if (method & WPS_CONFIG_DISPLAY)
917 		method = WPS_CONFIG_KEYPAD;
918 	else if (method & WPS_CONFIG_KEYPAD)
919 		method = WPS_CONFIG_DISPLAY;
920 
921 	if (!conncap || !(msg.wps_config_methods & method)) {
922 		/*
923 		 * Reject this "Deferred Accept*
924 		 * if incompatible conncap or method
925 		 */
926 		reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
927 	} else if (!resp_fcap.cpt) {
928 		p2p_dbg(p2p,
929 			"Incompatible P2PS feature capability CPT bitmask");
930 		reject = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
931 	} else if ((remote_conncap & (P2PS_SETUP_NEW | P2PS_SETUP_CLIENT) ||
932 		    msg.persistent_dev) && conncap != P2PS_SETUP_NEW &&
933 		   msg.channel_list && msg.channel_list_len &&
934 		   p2p_peer_channels_check(p2p, &p2p->channels, dev,
935 					   msg.channel_list,
936 					   msg.channel_list_len) < 0) {
937 		p2p_dbg(p2p,
938 			"No common channels in Follow-On Provision Discovery Request");
939 		reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
940 	} else {
941 		reject = P2P_SC_SUCCESS;
942 	}
943 
944 	dev->oper_freq = 0;
945 	if (reject == P2P_SC_SUCCESS || reject == P2P_SC_SUCCESS_DEFERRED) {
946 		u8 tmp;
947 
948 		if (msg.operating_channel)
949 			dev->oper_freq =
950 				p2p_channel_to_freq(msg.operating_channel[3],
951 						    msg.operating_channel[4]);
952 
953 		if ((conncap & P2PS_SETUP_GROUP_OWNER) &&
954 		    p2p_go_select_channel(p2p, dev, &tmp) < 0)
955 			reject = P2P_SC_FAIL_NO_COMMON_CHANNELS;
956 	}
957 
958 	p2p->p2ps_prov->status = reject;
959 	p2p->p2ps_prov->conncap = conncap;
960 
961 out:
962 	if (reject == P2P_SC_SUCCESS ||
963 	    reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
964 		config_methods = msg.wps_config_methods;
965 	else
966 		config_methods = 0;
967 
968 	/*
969 	 * Send PD Response for an initial PD Request or for follow-on
970 	 * PD Request with P2P_SC_SUCCESS_DEFERRED status.
971 	 */
972 	if (!msg.status || *msg.status == P2P_SC_SUCCESS_DEFERRED) {
973 		resp = p2p_build_prov_disc_resp(p2p, dev, msg.dialog_token,
974 						reject, config_methods, adv_id,
975 						msg.group_id, msg.group_id_len,
976 						msg.persistent_ssid,
977 						msg.persistent_ssid_len,
978 						(const u8 *) &resp_fcap,
979 						sizeof(resp_fcap));
980 		if (!resp) {
981 			p2p_parse_free(&msg);
982 			return;
983 		}
984 		p2p_dbg(p2p, "Sending Provision Discovery Response");
985 		if (rx_freq > 0)
986 			freq = rx_freq;
987 		else
988 			freq = p2p_channel_to_freq(p2p->cfg->reg_class,
989 						   p2p->cfg->channel);
990 		if (freq < 0) {
991 			p2p_dbg(p2p, "Unknown regulatory class/channel");
992 			wpabuf_free(resp);
993 			p2p_parse_free(&msg);
994 			return;
995 		}
996 		p2p->pending_action_state = P2P_PENDING_PD_RESPONSE;
997 		if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
998 				    p2p->cfg->dev_addr,
999 				    wpabuf_head(resp), wpabuf_len(resp),
1000 				    50) < 0)
1001 			p2p_dbg(p2p, "Failed to send Action frame");
1002 		else
1003 			p2p->send_action_in_progress = 1;
1004 
1005 		wpabuf_free(resp);
1006 	}
1007 
1008 	if (!dev) {
1009 		p2p_parse_free(&msg);
1010 		return;
1011 	}
1012 
1013 	freq = 0;
1014 	if (reject == P2P_SC_SUCCESS && conncap == P2PS_SETUP_GROUP_OWNER) {
1015 		freq = p2p_channel_to_freq(p2p->op_reg_class,
1016 					   p2p->op_channel);
1017 		if (freq < 0)
1018 			freq = 0;
1019 	}
1020 
1021 	if (!p2p->cfg->p2ps_prov_complete) {
1022 		/* Don't emit anything */
1023 	} else if (msg.status && *msg.status != P2P_SC_SUCCESS &&
1024 		   *msg.status != P2P_SC_SUCCESS_DEFERRED) {
1025 		reject = *msg.status;
1026 		p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1027 					     sa, adv_mac, session_mac,
1028 					     NULL, adv_id, session_id,
1029 					     0, 0, msg.persistent_ssid,
1030 					     msg.persistent_ssid_len,
1031 					     0, 0, NULL, NULL, 0, freq,
1032 					     NULL, 0);
1033 	} else if (msg.status && *msg.status == P2P_SC_SUCCESS_DEFERRED &&
1034 		   p2p->p2ps_prov) {
1035 		p2p->p2ps_prov->status = reject;
1036 		p2p->p2ps_prov->conncap = conncap;
1037 
1038 		if (reject != P2P_SC_SUCCESS)
1039 			p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, reject,
1040 						     sa, adv_mac, session_mac,
1041 						     NULL, adv_id,
1042 						     session_id, conncap, 0,
1043 						     msg.persistent_ssid,
1044 						     msg.persistent_ssid_len, 0,
1045 						     0, NULL, NULL, 0, freq,
1046 						     NULL, 0);
1047 		else
1048 			p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx,
1049 						     *msg.status,
1050 						     sa, adv_mac, session_mac,
1051 						     group_mac, adv_id,
1052 						     session_id, conncap,
1053 						     passwd_id,
1054 						     msg.persistent_ssid,
1055 						     msg.persistent_ssid_len, 0,
1056 						     0, NULL,
1057 						     (const u8 *) &resp_fcap,
1058 						     sizeof(resp_fcap), freq,
1059 						     NULL, 0);
1060 	} else if (msg.status && p2p->p2ps_prov) {
1061 		p2p->p2ps_prov->status = P2P_SC_SUCCESS;
1062 		p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, *msg.status, sa,
1063 					     adv_mac, session_mac, group_mac,
1064 					     adv_id, session_id, conncap,
1065 					     passwd_id,
1066 					     msg.persistent_ssid,
1067 					     msg.persistent_ssid_len,
1068 					     0, 0, NULL,
1069 					     (const u8 *) &resp_fcap,
1070 					     sizeof(resp_fcap), freq, NULL, 0);
1071 	} else if (msg.status) {
1072 	} else if (auto_accept && reject == P2P_SC_SUCCESS) {
1073 		p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1074 					     sa, adv_mac, session_mac,
1075 					     group_mac, adv_id, session_id,
1076 					     conncap, passwd_id,
1077 					     msg.persistent_ssid,
1078 					     msg.persistent_ssid_len,
1079 					     0, 0, NULL,
1080 					     (const u8 *) &resp_fcap,
1081 					     sizeof(resp_fcap), freq,
1082 					     msg.group_id ?
1083 					     msg.group_id + ETH_ALEN : NULL,
1084 					     msg.group_id ?
1085 					     msg.group_id_len - ETH_ALEN : 0);
1086 	} else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1087 		   (!msg.session_info || !msg.session_info_len)) {
1088 		p2p->p2ps_prov->method = msg.wps_config_methods;
1089 
1090 		p2p->cfg->p2ps_prov_complete(p2p->cfg->cb_ctx, P2P_SC_SUCCESS,
1091 					     sa, adv_mac, session_mac,
1092 					     group_mac, adv_id, session_id,
1093 					     conncap, passwd_id,
1094 					     msg.persistent_ssid,
1095 					     msg.persistent_ssid_len,
1096 					     0, 1, NULL,
1097 					     (const u8 *) &resp_fcap,
1098 					     sizeof(resp_fcap), freq, NULL, 0);
1099 	} else if (reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1100 		size_t buf_len = msg.session_info_len;
1101 		char *buf = os_malloc(2 * buf_len + 1);
1102 
1103 		if (buf) {
1104 			p2p->p2ps_prov->method = msg.wps_config_methods;
1105 
1106 			utf8_escape((char *) msg.session_info, buf_len,
1107 				    buf, 2 * buf_len + 1);
1108 
1109 			p2p->cfg->p2ps_prov_complete(
1110 				p2p->cfg->cb_ctx, P2P_SC_SUCCESS, sa,
1111 				adv_mac, session_mac, group_mac, adv_id,
1112 				session_id, conncap, passwd_id,
1113 				msg.persistent_ssid, msg.persistent_ssid_len,
1114 				0, 1, buf,
1115 				(const u8 *) &resp_fcap, sizeof(resp_fcap),
1116 				freq, NULL, 0);
1117 
1118 			os_free(buf);
1119 		}
1120 	}
1121 
1122 	/*
1123 	 * prov_disc_req callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1124 	 * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1125 	 * Call it either on legacy P2P PD or on P2PS PD only if we need to
1126 	 * enter/show PIN.
1127 	 *
1128 	 * The callback is called in the following cases:
1129 	 * 1. Legacy P2P PD request, response status SUCCESS
1130 	 * 2. P2PS advertiser, method: DISPLAY, autoaccept: TRUE,
1131 	 *    response status: SUCCESS
1132 	 * 3. P2PS advertiser, method  DISPLAY, autoaccept: FALSE,
1133 	 *    response status: INFO_CURRENTLY_UNAVAILABLE
1134 	 * 4. P2PS advertiser, method: KEYPAD, autoaccept==any,
1135 	 *    response status: INFO_CURRENTLY_UNAVAILABLE
1136 	 * 5. P2PS follow-on with SUCCESS_DEFERRED,
1137 	 *    advertiser role: DISPLAY, autoaccept: FALSE,
1138 	 *    seeker: KEYPAD, response status: SUCCESS
1139 	 */
1140 	if (p2p->cfg->prov_disc_req &&
1141 	    ((reject == P2P_SC_SUCCESS && !msg.adv_id) ||
1142 	     (!msg.status &&
1143 	     (reject == P2P_SC_SUCCESS ||
1144 	      reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) &&
1145 	      passwd_id == DEV_PW_USER_SPECIFIED) ||
1146 	     (!msg.status &&
1147 	      reject == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1148 	      passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1149 	     (reject == P2P_SC_SUCCESS &&
1150 	      msg.status && *msg.status == P2P_SC_SUCCESS_DEFERRED &&
1151 	       passwd_id == DEV_PW_REGISTRAR_SPECIFIED))) {
1152 		const u8 *dev_addr = sa;
1153 
1154 		if (msg.p2p_device_addr)
1155 			dev_addr = msg.p2p_device_addr;
1156 		p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
1157 					msg.wps_config_methods,
1158 					dev_addr, msg.pri_dev_type,
1159 					msg.device_name, msg.config_methods,
1160 					msg.capability ? msg.capability[0] : 0,
1161 					msg.capability ? msg.capability[1] :
1162 					0,
1163 					msg.group_id, msg.group_id_len);
1164 	}
1165 
1166 	if (reject != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE)
1167 		p2ps_prov_free(p2p);
1168 
1169 	if (reject == P2P_SC_SUCCESS) {
1170 		switch (config_methods) {
1171 		case WPS_CONFIG_DISPLAY:
1172 			dev->wps_prov_info = WPS_CONFIG_KEYPAD;
1173 			break;
1174 		case WPS_CONFIG_KEYPAD:
1175 			dev->wps_prov_info = WPS_CONFIG_DISPLAY;
1176 			break;
1177 		case WPS_CONFIG_PUSHBUTTON:
1178 			dev->wps_prov_info = WPS_CONFIG_PUSHBUTTON;
1179 			break;
1180 		case WPS_CONFIG_P2PS:
1181 			dev->wps_prov_info = WPS_CONFIG_P2PS;
1182 			break;
1183 		default:
1184 			dev->wps_prov_info = 0;
1185 			break;
1186 		}
1187 
1188 		if (msg.intended_addr)
1189 			os_memcpy(dev->interface_addr, msg.intended_addr,
1190 				  ETH_ALEN);
1191 	}
1192 	p2p_parse_free(&msg);
1193 }
1194 
1195 
1196 static int p2p_validate_p2ps_pd_resp(struct p2p_data *p2p,
1197 				     struct p2p_message *msg)
1198 {
1199 	u8 conn_cap_go = 0;
1200 	u8 conn_cap_cli = 0;
1201 	u32 session_id;
1202 	u32 adv_id;
1203 
1204 #define P2PS_PD_RESP_CHECK(_val, _attr) \
1205 	do { \
1206 		if ((_val) && !msg->_attr) { \
1207 			p2p_dbg(p2p, "P2PS PD Response missing " #_attr); \
1208 			return -1; \
1209 		} \
1210 	} while (0)
1211 
1212 	P2PS_PD_RESP_CHECK(1, status);
1213 	P2PS_PD_RESP_CHECK(1, adv_id);
1214 	P2PS_PD_RESP_CHECK(1, adv_mac);
1215 	P2PS_PD_RESP_CHECK(1, capability);
1216 	P2PS_PD_RESP_CHECK(1, p2p_device_info);
1217 	P2PS_PD_RESP_CHECK(1, session_id);
1218 	P2PS_PD_RESP_CHECK(1, session_mac);
1219 	P2PS_PD_RESP_CHECK(1, feature_cap);
1220 
1221 	session_id = WPA_GET_LE32(msg->session_id);
1222 	adv_id = WPA_GET_LE32(msg->adv_id);
1223 
1224 	if (p2p->p2ps_prov->session_id != session_id) {
1225 		p2p_dbg(p2p,
1226 			"Ignore PD Response with unexpected Session ID");
1227 		return -1;
1228 	}
1229 
1230 	if (os_memcmp(p2p->p2ps_prov->session_mac, msg->session_mac,
1231 		      ETH_ALEN)) {
1232 		p2p_dbg(p2p,
1233 			"Ignore PD Response with unexpected Session MAC");
1234 		return -1;
1235 	}
1236 
1237 	if (p2p->p2ps_prov->adv_id != adv_id) {
1238 		p2p_dbg(p2p,
1239 			"Ignore PD Response with unexpected Advertisement ID");
1240 		return -1;
1241 	}
1242 
1243 	if (os_memcmp(p2p->p2ps_prov->adv_mac, msg->adv_mac, ETH_ALEN) != 0) {
1244 		p2p_dbg(p2p,
1245 			"Ignore PD Response with unexpected Advertisement MAC");
1246 		return -1;
1247 	}
1248 
1249 	if (msg->listen_channel) {
1250 		p2p_dbg(p2p,
1251 			"Ignore malformed PD Response - unexpected Listen Channel");
1252 		return -1;
1253 	}
1254 
1255 	if (*msg->status == P2P_SC_SUCCESS &&
1256 	    !(!!msg->conn_cap ^ !!msg->persistent_dev)) {
1257 		p2p_dbg(p2p,
1258 			"Ignore malformed PD Response - either conn_cap or persistent group should be present");
1259 		return -1;
1260 	}
1261 
1262 	if (msg->persistent_dev && *msg->status != P2P_SC_SUCCESS) {
1263 		p2p_dbg(p2p,
1264 			"Ignore malformed PD Response - persistent group is present, but the status isn't success");
1265 		return -1;
1266 	}
1267 
1268 	if (msg->conn_cap) {
1269 		conn_cap_go = *msg->conn_cap == P2PS_SETUP_GROUP_OWNER;
1270 		conn_cap_cli = *msg->conn_cap == P2PS_SETUP_CLIENT;
1271 	}
1272 
1273 	P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1274 			   channel_list);
1275 	P2PS_PD_RESP_CHECK(msg->persistent_dev || conn_cap_go || conn_cap_cli,
1276 			   config_timeout);
1277 
1278 	P2PS_PD_RESP_CHECK(conn_cap_go, group_id);
1279 	P2PS_PD_RESP_CHECK(conn_cap_go, intended_addr);
1280 	P2PS_PD_RESP_CHECK(conn_cap_go, operating_channel);
1281 	/*
1282 	 * TODO: Also validate that operating channel is present if the device
1283 	 * is a GO in a persistent group. We can't do it here since we don't
1284 	 * know what is the role of the peer. It should be probably done in
1285 	 * p2ps_prov_complete callback, but currently operating channel isn't
1286 	 * passed to it.
1287 	 */
1288 
1289 #undef P2PS_PD_RESP_CHECK
1290 
1291 	return 0;
1292 }
1293 
1294 
1295 void p2p_process_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
1296 				const u8 *data, size_t len)
1297 {
1298 	struct p2p_message msg;
1299 	struct p2p_device *dev;
1300 	u16 report_config_methods = 0, req_config_methods;
1301 	u8 status = P2P_SC_SUCCESS;
1302 	u32 adv_id = 0;
1303 	u8 conncap = P2PS_SETUP_NEW;
1304 	u8 adv_mac[ETH_ALEN];
1305 	const u8 *group_mac;
1306 	int passwd_id = DEV_PW_DEFAULT;
1307 	int p2ps_seeker;
1308 
1309 	if (p2p_parse(data, len, &msg))
1310 		return;
1311 
1312 	if (p2p->p2ps_prov && p2p_validate_p2ps_pd_resp(p2p, &msg)) {
1313 		p2p_parse_free(&msg);
1314 		return;
1315 	}
1316 
1317 	/* Parse the P2PS members present */
1318 	if (msg.status)
1319 		status = *msg.status;
1320 
1321 	group_mac = msg.intended_addr;
1322 
1323 	if (msg.adv_mac)
1324 		os_memcpy(adv_mac, msg.adv_mac, ETH_ALEN);
1325 	else
1326 		os_memset(adv_mac, 0, ETH_ALEN);
1327 
1328 	if (msg.adv_id)
1329 		adv_id = WPA_GET_LE32(msg.adv_id);
1330 
1331 	if (msg.conn_cap) {
1332 		conncap = *msg.conn_cap;
1333 
1334 		/* Switch bits to local relative */
1335 		switch (conncap) {
1336 		case P2PS_SETUP_GROUP_OWNER:
1337 			conncap = P2PS_SETUP_CLIENT;
1338 			break;
1339 		case P2PS_SETUP_CLIENT:
1340 			conncap = P2PS_SETUP_GROUP_OWNER;
1341 			break;
1342 		}
1343 	}
1344 
1345 	p2p_dbg(p2p, "Received Provision Discovery Response from " MACSTR
1346 		" with config methods 0x%x",
1347 		MAC2STR(sa), msg.wps_config_methods);
1348 
1349 	dev = p2p_get_device(p2p, sa);
1350 	if (dev == NULL || !dev->req_config_methods) {
1351 		p2p_dbg(p2p, "Ignore Provision Discovery Response from " MACSTR
1352 			" with no pending request", MAC2STR(sa));
1353 		p2p_parse_free(&msg);
1354 		return;
1355 	} else if (msg.wfd_subelems) {
1356 		wpabuf_free(dev->info.wfd_subelems);
1357 		dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
1358 	}
1359 
1360 	if (dev->dialog_token != msg.dialog_token) {
1361 		p2p_dbg(p2p, "Ignore Provision Discovery Response with unexpected Dialog Token %u (expected %u)",
1362 			msg.dialog_token, dev->dialog_token);
1363 		p2p_parse_free(&msg);
1364 		return;
1365 	}
1366 
1367 	if (p2p->pending_action_state == P2P_PENDING_PD) {
1368 		os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1369 		p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1370 	}
1371 
1372 	p2ps_seeker = p2p->p2ps_prov && p2p->p2ps_prov->pd_seeker;
1373 
1374 	/*
1375 	 * Use a local copy of the requested config methods since
1376 	 * p2p_reset_pending_pd() can clear this in the peer entry.
1377 	 */
1378 	req_config_methods = dev->req_config_methods;
1379 
1380 	/*
1381 	 * If the response is from the peer to whom a user initiated request
1382 	 * was sent earlier, we reset that state info here.
1383 	 */
1384 	if (p2p->user_initiated_pd &&
1385 	    os_memcmp(p2p->pending_pd_devaddr, sa, ETH_ALEN) == 0)
1386 		p2p_reset_pending_pd(p2p);
1387 
1388 	if (msg.wps_config_methods != req_config_methods) {
1389 		p2p_dbg(p2p, "Peer rejected our Provision Discovery Request (received config_methods 0x%x expected 0x%x",
1390 			msg.wps_config_methods, req_config_methods);
1391 		if (p2p->cfg->prov_disc_fail)
1392 			p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1393 						 P2P_PROV_DISC_REJECTED,
1394 						 adv_id, adv_mac, NULL);
1395 		p2p_parse_free(&msg);
1396 		p2ps_prov_free(p2p);
1397 		goto out;
1398 	}
1399 
1400 	report_config_methods = req_config_methods;
1401 	dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
1402 			P2P_DEV_PD_PEER_KEYPAD |
1403 			P2P_DEV_PD_PEER_P2PS);
1404 	if (req_config_methods & WPS_CONFIG_DISPLAY) {
1405 		p2p_dbg(p2p, "Peer " MACSTR
1406 			" accepted to show a PIN on display", MAC2STR(sa));
1407 		dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
1408 		passwd_id = DEV_PW_REGISTRAR_SPECIFIED;
1409 	} else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
1410 		p2p_dbg(p2p, "Peer " MACSTR
1411 			" accepted to write our PIN using keypad",
1412 			MAC2STR(sa));
1413 		dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
1414 		passwd_id = DEV_PW_USER_SPECIFIED;
1415 	} else if (msg.wps_config_methods & WPS_CONFIG_P2PS) {
1416 		p2p_dbg(p2p, "Peer " MACSTR " accepted P2PS PIN",
1417 			MAC2STR(sa));
1418 		dev->flags |= P2P_DEV_PD_PEER_P2PS;
1419 		passwd_id = DEV_PW_P2PS_DEFAULT;
1420 	}
1421 
1422 	if ((status == P2P_SC_SUCCESS || status == P2P_SC_SUCCESS_DEFERRED) &&
1423 	    p2p->p2ps_prov) {
1424 		dev->oper_freq = 0;
1425 
1426 		/*
1427 		 * Save the reported channel list and operating frequency.
1428 		 * Note that the specification mandates that the responder
1429 		 * should include in the channel list only channels reported by
1430 		 * the initiator, so this is only a sanity check, and if this
1431 		 * fails the flow would continue, although it would probably
1432 		 * fail. Same is true for the operating channel.
1433 		 */
1434 		if (msg.channel_list && msg.channel_list_len &&
1435 		    p2p_peer_channels_check(p2p, &p2p->channels, dev,
1436 					    msg.channel_list,
1437 					    msg.channel_list_len) < 0)
1438 			p2p_dbg(p2p, "P2PS PD Response - no common channels");
1439 
1440 		if (msg.operating_channel) {
1441 			if (p2p_channels_includes(&p2p->channels,
1442 						  msg.operating_channel[3],
1443 						  msg.operating_channel[4]) &&
1444 			    p2p_channels_includes(&dev->channels,
1445 						  msg.operating_channel[3],
1446 						  msg.operating_channel[4])) {
1447 				dev->oper_freq =
1448 					p2p_channel_to_freq(
1449 						msg.operating_channel[3],
1450 						msg.operating_channel[4]);
1451 			} else {
1452 				p2p_dbg(p2p,
1453 					"P2PS PD Response - invalid operating channel");
1454 			}
1455 		}
1456 
1457 		if (p2p->cfg->p2ps_prov_complete) {
1458 			int freq = 0;
1459 
1460 			if (conncap == P2PS_SETUP_GROUP_OWNER) {
1461 				u8 tmp;
1462 
1463 				/*
1464 				 * Re-select the operating channel as it is
1465 				 * possible that original channel is no longer
1466 				 * valid. This should not really fail.
1467 				 */
1468 				if (p2p_go_select_channel(p2p, dev, &tmp) < 0)
1469 					p2p_dbg(p2p,
1470 						"P2PS PD channel selection failed");
1471 
1472 				freq = p2p_channel_to_freq(p2p->op_reg_class,
1473 							   p2p->op_channel);
1474 				if (freq < 0)
1475 					freq = 0;
1476 			}
1477 
1478 			p2p->cfg->p2ps_prov_complete(
1479 				p2p->cfg->cb_ctx, status, sa, adv_mac,
1480 				p2p->p2ps_prov->session_mac,
1481 				group_mac, adv_id, p2p->p2ps_prov->session_id,
1482 				conncap, passwd_id, msg.persistent_ssid,
1483 				msg.persistent_ssid_len, 1, 0, NULL,
1484 				msg.feature_cap, msg.feature_cap_len, freq,
1485 				msg.group_id ? msg.group_id + ETH_ALEN : NULL,
1486 				msg.group_id ? msg.group_id_len - ETH_ALEN : 0);
1487 		}
1488 		p2ps_prov_free(p2p);
1489 	} else if (status != P2P_SC_SUCCESS &&
1490 		   status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1491 		   status != P2P_SC_SUCCESS_DEFERRED && p2p->p2ps_prov) {
1492 		if (p2p->cfg->p2ps_prov_complete)
1493 			p2p->cfg->p2ps_prov_complete(
1494 				p2p->cfg->cb_ctx, status, sa, adv_mac,
1495 				p2p->p2ps_prov->session_mac,
1496 				group_mac, adv_id, p2p->p2ps_prov->session_id,
1497 				0, 0, NULL, 0, 1, 0, NULL, NULL, 0, 0, NULL, 0);
1498 		p2ps_prov_free(p2p);
1499 	}
1500 
1501 	if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1502 		if (p2p->cfg->remove_stale_groups) {
1503 			p2p->cfg->remove_stale_groups(p2p->cfg->cb_ctx,
1504 						      dev->info.p2p_device_addr,
1505 						      NULL, NULL, 0);
1506 		}
1507 
1508 		if (msg.session_info && msg.session_info_len) {
1509 			size_t info_len = msg.session_info_len;
1510 			char *deferred_sess_resp = os_malloc(2 * info_len + 1);
1511 
1512 			if (!deferred_sess_resp) {
1513 				p2p_parse_free(&msg);
1514 				p2ps_prov_free(p2p);
1515 				goto out;
1516 			}
1517 			utf8_escape((char *) msg.session_info, info_len,
1518 				    deferred_sess_resp, 2 * info_len + 1);
1519 
1520 			if (p2p->cfg->prov_disc_fail)
1521 				p2p->cfg->prov_disc_fail(
1522 					p2p->cfg->cb_ctx, sa,
1523 					P2P_PROV_DISC_INFO_UNAVAILABLE,
1524 					adv_id, adv_mac,
1525 					deferred_sess_resp);
1526 			os_free(deferred_sess_resp);
1527 		} else
1528 			if (p2p->cfg->prov_disc_fail)
1529 				p2p->cfg->prov_disc_fail(
1530 					p2p->cfg->cb_ctx, sa,
1531 					P2P_PROV_DISC_INFO_UNAVAILABLE,
1532 					adv_id, adv_mac, NULL);
1533 	} else if (status != P2P_SC_SUCCESS) {
1534 		p2p_dbg(p2p, "Peer rejected our Provision Discovery Request");
1535 		if (p2p->cfg->prov_disc_fail)
1536 			p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
1537 						 P2P_PROV_DISC_REJECTED,
1538 						 adv_id, adv_mac, NULL);
1539 		p2p_parse_free(&msg);
1540 		p2ps_prov_free(p2p);
1541 		goto out;
1542 	}
1543 
1544 	/* Store the provisioning info */
1545 	dev->wps_prov_info = msg.wps_config_methods;
1546 	if (msg.intended_addr)
1547 		os_memcpy(dev->interface_addr, msg.intended_addr, ETH_ALEN);
1548 
1549 	p2p_parse_free(&msg);
1550 
1551 out:
1552 	dev->req_config_methods = 0;
1553 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1554 	if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
1555 		p2p_dbg(p2p, "Start GO Neg after the PD-before-GO-Neg workaround with "
1556 			MACSTR, MAC2STR(dev->info.p2p_device_addr));
1557 		dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1558 		p2p_connect_send(p2p, dev);
1559 		return;
1560 	}
1561 
1562 	/*
1563 	 * prov_disc_resp callback is used to generate P2P-PROV-DISC-ENTER-PIN,
1564 	 * P2P-PROV-DISC-SHOW-PIN, and P2P-PROV-DISC-PBC-REQ events.
1565 	 * Call it only for a legacy P2P PD or for P2PS PD scenarios where
1566 	 * show/enter PIN events are needed.
1567 	 *
1568 	 * The callback is called in the following cases:
1569 	 * 1. Legacy P2P PD response with a status SUCCESS
1570 	 * 2. P2PS, advertiser method: DISPLAY, autoaccept: true,
1571 	 *    response status: SUCCESS, local method KEYPAD
1572 	 * 3. P2PS, advertiser method: KEYPAD,Seeker side,
1573 	 *    response status: INFO_CURRENTLY_UNAVAILABLE,
1574 	 *    local method: DISPLAY
1575 	 */
1576 	if (p2p->cfg->prov_disc_resp &&
1577 	    ((status == P2P_SC_SUCCESS && !adv_id) ||
1578 	     (p2ps_seeker && status == P2P_SC_SUCCESS &&
1579 	      passwd_id == DEV_PW_REGISTRAR_SPECIFIED) ||
1580 	     (p2ps_seeker &&
1581 	      status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE &&
1582 	      passwd_id == DEV_PW_USER_SPECIFIED)))
1583 		p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
1584 					 report_config_methods);
1585 
1586 	if (p2p->state == P2P_PD_DURING_FIND) {
1587 		p2p_stop_listen_for_freq(p2p, 0);
1588 		p2p_continue_find(p2p);
1589 	}
1590 }
1591 
1592 
1593 int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
1594 			   int join, int force_freq)
1595 {
1596 	struct wpabuf *req;
1597 	int freq;
1598 
1599 	if (force_freq > 0)
1600 		freq = force_freq;
1601 	else
1602 		freq = dev->listen_freq > 0 ? dev->listen_freq :
1603 			dev->oper_freq;
1604 	if (freq <= 0) {
1605 		p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
1606 			MACSTR " to send Provision Discovery Request",
1607 			MAC2STR(dev->info.p2p_device_addr));
1608 		return -1;
1609 	}
1610 
1611 	if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1612 		if (!(dev->info.dev_capab &
1613 		      P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
1614 			p2p_dbg(p2p, "Cannot use PD with P2P Device " MACSTR
1615 				" that is in a group and is not discoverable",
1616 				MAC2STR(dev->info.p2p_device_addr));
1617 			return -1;
1618 		}
1619 		/* TODO: use device discoverability request through GO */
1620 	}
1621 
1622 	if (p2p->p2ps_prov) {
1623 		if (p2p->p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED) {
1624 			if (p2p->p2ps_prov->method == WPS_CONFIG_DISPLAY)
1625 				dev->req_config_methods = WPS_CONFIG_KEYPAD;
1626 			else if (p2p->p2ps_prov->method == WPS_CONFIG_KEYPAD)
1627 				dev->req_config_methods = WPS_CONFIG_DISPLAY;
1628 			else
1629 				dev->req_config_methods = WPS_CONFIG_P2PS;
1630 		} else {
1631 			/* Order of preference, based on peer's capabilities */
1632 			if (p2p->p2ps_prov->method)
1633 				dev->req_config_methods =
1634 					p2p->p2ps_prov->method;
1635 			else if (dev->info.config_methods & WPS_CONFIG_P2PS)
1636 				dev->req_config_methods = WPS_CONFIG_P2PS;
1637 			else if (dev->info.config_methods & WPS_CONFIG_DISPLAY)
1638 				dev->req_config_methods = WPS_CONFIG_DISPLAY;
1639 			else
1640 				dev->req_config_methods = WPS_CONFIG_KEYPAD;
1641 		}
1642 		p2p_dbg(p2p,
1643 			"Building PD Request based on P2PS config method 0x%x status %d --> req_config_methods 0x%x",
1644 			p2p->p2ps_prov->method, p2p->p2ps_prov->status,
1645 			dev->req_config_methods);
1646 
1647 		if (p2p_prepare_channel(p2p, dev, p2p->p2ps_prov->force_freq,
1648 					p2p->p2ps_prov->pref_freq, 1) < 0)
1649 			return -1;
1650 	}
1651 
1652 	req = p2p_build_prov_disc_req(p2p, dev, join);
1653 	if (req == NULL)
1654 		return -1;
1655 
1656 	if (p2p->state != P2P_IDLE)
1657 		p2p_stop_listen_for_freq(p2p, freq);
1658 	p2p->pending_action_state = P2P_PENDING_PD;
1659 	if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
1660 			    p2p->cfg->dev_addr, dev->info.p2p_device_addr,
1661 			    wpabuf_head(req), wpabuf_len(req), 200) < 0) {
1662 		p2p_dbg(p2p, "Failed to send Action frame");
1663 		wpabuf_free(req);
1664 		return -1;
1665 	}
1666 
1667 	os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
1668 
1669 	wpabuf_free(req);
1670 	return 0;
1671 }
1672 
1673 
1674 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
1675 		      struct p2ps_provision *p2ps_prov,
1676 		      u16 config_methods, int join, int force_freq,
1677 		      int user_initiated_pd)
1678 {
1679 	struct p2p_device *dev;
1680 
1681 	dev = p2p_get_device(p2p, peer_addr);
1682 	if (dev == NULL)
1683 		dev = p2p_get_device_interface(p2p, peer_addr);
1684 	if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1685 		p2p_dbg(p2p, "Provision Discovery Request destination " MACSTR
1686 			" not yet known", MAC2STR(peer_addr));
1687 		os_free(p2ps_prov);
1688 		return -1;
1689 	}
1690 
1691 	p2p_dbg(p2p, "Provision Discovery Request with " MACSTR
1692 		" (config methods 0x%x)",
1693 		MAC2STR(peer_addr), config_methods);
1694 	if (config_methods == 0 && !p2ps_prov) {
1695 		os_free(p2ps_prov);
1696 		return -1;
1697 	}
1698 
1699 	if (p2ps_prov && p2ps_prov->status == P2P_SC_SUCCESS_DEFERRED &&
1700 	    p2p->p2ps_prov) {
1701 		/* Use cached method from deferred provisioning */
1702 		p2ps_prov->method = p2p->p2ps_prov->method;
1703 	}
1704 
1705 	/* Reset provisioning info */
1706 	dev->wps_prov_info = 0;
1707 	p2ps_prov_free(p2p);
1708 	p2p->p2ps_prov = p2ps_prov;
1709 
1710 	dev->req_config_methods = config_methods;
1711 	if (join)
1712 		dev->flags |= P2P_DEV_PD_FOR_JOIN;
1713 	else
1714 		dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
1715 
1716 	if (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
1717 	    p2p->state != P2P_LISTEN_ONLY) {
1718 		p2p_dbg(p2p, "Busy with other operations; postpone Provision Discovery Request with "
1719 			MACSTR " (config methods 0x%x)",
1720 			MAC2STR(peer_addr), config_methods);
1721 		return 0;
1722 	}
1723 
1724 	p2p->user_initiated_pd = user_initiated_pd;
1725 	p2p->pd_force_freq = force_freq;
1726 
1727 	if (p2p->user_initiated_pd)
1728 		p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
1729 
1730 	/*
1731 	 * Assign dialog token here to use the same value in each retry within
1732 	 * the same PD exchange.
1733 	 */
1734 	dev->dialog_token++;
1735 	if (dev->dialog_token == 0)
1736 		dev->dialog_token = 1;
1737 
1738 	return p2p_send_prov_disc_req(p2p, dev, join, force_freq);
1739 }
1740 
1741 
1742 void p2p_reset_pending_pd(struct p2p_data *p2p)
1743 {
1744 	struct p2p_device *dev;
1745 
1746 	dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
1747 		if (os_memcmp(p2p->pending_pd_devaddr,
1748 			      dev->info.p2p_device_addr, ETH_ALEN))
1749 			continue;
1750 		if (!dev->req_config_methods)
1751 			continue;
1752 		if (dev->flags & P2P_DEV_PD_FOR_JOIN)
1753 			continue;
1754 		/* Reset the config methods of the device */
1755 		dev->req_config_methods = 0;
1756 	}
1757 
1758 	p2p->user_initiated_pd = 0;
1759 	os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
1760 	p2p->pd_retries = 0;
1761 	p2p->pd_force_freq = 0;
1762 }
1763 
1764 
1765 void p2ps_prov_free(struct p2p_data *p2p)
1766 {
1767 	os_free(p2p->p2ps_prov);
1768 	p2p->p2ps_prov = NULL;
1769 }
1770