p2p_pd.c revision 75ecf5267604f166b85a7ee2cf0d9cb682966680 
1/*
2 * Wi-Fi Direct - P2P provision discovery
3 * Copyright (c) 2009-2010, Atheros Communications
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15#include "includes.h"
16
17#include "common.h"
18#include "common/ieee802_11_defs.h"
19#include "wps/wps_defs.h"
20#include "p2p_i.h"
21#include "p2p.h"
22
23
24/*
25 * Number of retries to attempt for provision discovery requests during IDLE
26 * state in case the peer is not listening.
27 */
28#define MAX_PROV_DISC_REQ_RETRIES 10
29
30
31static void p2p_build_wps_ie_config_methods(struct wpabuf *buf,
32					    u16 config_methods)
33{
34	u8 *len;
35	wpabuf_put_u8(buf, WLAN_EID_VENDOR_SPECIFIC);
36	len = wpabuf_put(buf, 1);
37	wpabuf_put_be32(buf, WPS_DEV_OUI_WFA);
38
39	/* Config Methods */
40	wpabuf_put_be16(buf, ATTR_CONFIG_METHODS);
41	wpabuf_put_be16(buf, 2);
42	wpabuf_put_be16(buf, config_methods);
43
44	p2p_buf_update_ie_hdr(buf, len);
45}
46
47
48static struct wpabuf * p2p_build_prov_disc_req(struct p2p_data *p2p,
49					       u8 dialog_token,
50					       u16 config_methods,
51					       struct p2p_device *go)
52{
53	struct wpabuf *buf;
54	u8 *len;
55
56	buf = wpabuf_alloc(1000);
57	if (buf == NULL)
58		return NULL;
59
60	p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_REQ, dialog_token);
61
62	len = p2p_buf_add_ie_hdr(buf);
63	p2p_buf_add_capability(buf, p2p->dev_capab, 0);
64	p2p_buf_add_device_info(buf, p2p, NULL);
65	if (go) {
66		p2p_buf_add_group_id(buf, go->info.p2p_device_addr,
67				     go->oper_ssid, go->oper_ssid_len);
68	}
69	p2p_buf_update_ie_hdr(buf, len);
70
71	/* WPS IE with Config Methods attribute */
72	p2p_build_wps_ie_config_methods(buf, config_methods);
73
74	return buf;
75}
76
77
78static struct wpabuf * p2p_build_prov_disc_resp(struct p2p_data *p2p,
79						u8 dialog_token,
80						u16 config_methods)
81{
82	struct wpabuf *buf;
83
84	buf = wpabuf_alloc(100);
85	if (buf == NULL)
86		return NULL;
87
88	p2p_buf_add_public_action_hdr(buf, P2P_PROV_DISC_RESP, dialog_token);
89
90	/* WPS IE with Config Methods attribute */
91	p2p_build_wps_ie_config_methods(buf, config_methods);
92
93	return buf;
94}
95
96
97void p2p_process_prov_disc_req(struct p2p_data *p2p, const u8 *sa,
98			       const u8 *data, size_t len, int rx_freq)
99{
100	struct p2p_message msg;
101	struct p2p_device *dev;
102	int freq;
103	int reject = 1;
104	struct wpabuf *resp;
105
106	if (p2p_parse(data, len, &msg))
107		return;
108
109	wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
110		"P2P: Received Provision Discovery Request from " MACSTR
111		" with config methods 0x%x (freq=%d)",
112		MAC2STR(sa), msg.wps_config_methods, rx_freq);
113
114	dev = p2p_get_device(p2p, sa);
115	if (dev == NULL || !(dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
116		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
117			"P2P: Provision Discovery Request from "
118			"unknown peer " MACSTR, MAC2STR(sa));
119		if (p2p_add_device(p2p, sa, rx_freq, 0, data + 1, len - 1)) {
120			wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
121			        "P2P: Provision Discovery Request add device "
122				"failed " MACSTR, MAC2STR(sa));
123		}
124	}
125
126	if (!(msg.wps_config_methods &
127	      (WPS_CONFIG_DISPLAY | WPS_CONFIG_KEYPAD |
128	       WPS_CONFIG_PUSHBUTTON))) {
129		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Unsupported "
130			"Config Methods in Provision Discovery Request");
131		goto out;
132	}
133
134	if (dev)
135		dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
136				P2P_DEV_PD_PEER_KEYPAD);
137	if (msg.wps_config_methods & WPS_CONFIG_DISPLAY) {
138		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR
139			" requested us to show a PIN on display", MAC2STR(sa));
140		if (dev)
141			dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
142	} else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
143		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR
144			" requested us to write its PIN using keypad",
145			MAC2STR(sa));
146		if (dev)
147			dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
148	}
149
150	reject = 0;
151
152out:
153	resp = p2p_build_prov_disc_resp(p2p, msg.dialog_token,
154					reject ? 0 : msg.wps_config_methods);
155	if (resp == NULL) {
156		p2p_parse_free(&msg);
157		return;
158	}
159	wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
160		"P2P: Sending Provision Discovery Response");
161	if (rx_freq > 0)
162		freq = rx_freq;
163	else
164		freq = p2p_channel_to_freq(p2p->cfg->country,
165					   p2p->cfg->reg_class,
166					   p2p->cfg->channel);
167	if (freq < 0) {
168		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
169			"P2P: Unknown regulatory class/channel");
170		wpabuf_free(resp);
171		p2p_parse_free(&msg);
172		return;
173	}
174	p2p->pending_action_state = P2P_NO_PENDING_ACTION;
175	if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
176			    p2p->cfg->dev_addr,
177			    wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
178		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
179			"P2P: Failed to send Action frame");
180	}
181
182	wpabuf_free(resp);
183
184	if (!reject && p2p->cfg->prov_disc_req) {
185		const u8 *dev_addr = sa;
186		if (msg.p2p_device_addr)
187			dev_addr = msg.p2p_device_addr;
188		p2p->cfg->prov_disc_req(p2p->cfg->cb_ctx, sa,
189					msg.wps_config_methods,
190					dev_addr, msg.pri_dev_type,
191					msg.device_name, msg.config_methods,
192					msg.capability ? msg.capability[0] : 0,
193					msg.capability ? msg.capability[1] :
194					0);
195
196	}
197	p2p_parse_free(&msg);
198}
199
200
201void p2p_process_prov_disc_resp(struct p2p_data *p2p, const u8 *sa,
202				const u8 *data, size_t len)
203{
204	struct p2p_message msg;
205	struct p2p_device *dev;
206	u16 report_config_methods = 0;
207
208	if (p2p_parse(data, len, &msg))
209		return;
210
211	wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
212		"P2P: Received Provisioning Discovery Response from " MACSTR
213		" with config methods 0x%x",
214		MAC2STR(sa), msg.wps_config_methods);
215
216	dev = p2p_get_device(p2p, sa);
217	if (dev == NULL || !dev->req_config_methods) {
218		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
219			"P2P: Ignore Provisioning Discovery Response from "
220			MACSTR " with no pending request", MAC2STR(sa));
221		p2p_parse_free(&msg);
222		return;
223	}
224
225	if (p2p->pending_action_state == P2P_PENDING_PD) {
226		os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
227		p2p->pending_action_state = P2P_NO_PENDING_ACTION;
228	}
229
230	if (dev->dialog_token != msg.dialog_token) {
231		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
232			"P2P: Ignore Provisioning Discovery Response with "
233			"unexpected Dialog Token %u (expected %u)",
234			msg.dialog_token, dev->dialog_token);
235		p2p_parse_free(&msg);
236		return;
237	}
238
239	/*
240	 * If the response is from the peer to whom a user initiated request
241	 * was sent earlier, we reset that state info here.
242	 */
243	if (p2p->user_initiated_pd &&
244	    os_memcmp(p2p->pending_pd_devaddr, sa, ETH_ALEN) == 0)
245		p2p_reset_pending_pd(p2p);
246
247	if (msg.wps_config_methods != dev->req_config_methods) {
248		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer rejected "
249			"our Provisioning Discovery Request");
250		if (p2p->cfg->prov_disc_fail)
251			p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, sa,
252						 P2P_PROV_DISC_REJECTED);
253		p2p_parse_free(&msg);
254		goto out;
255	}
256
257	report_config_methods = dev->req_config_methods;
258	dev->flags &= ~(P2P_DEV_PD_PEER_DISPLAY |
259			P2P_DEV_PD_PEER_KEYPAD);
260	if (dev->req_config_methods & WPS_CONFIG_DISPLAY) {
261		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR
262			" accepted to show a PIN on display", MAC2STR(sa));
263		dev->flags |= P2P_DEV_PD_PEER_DISPLAY;
264	} else if (msg.wps_config_methods & WPS_CONFIG_KEYPAD) {
265		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR
266			" accepted to write our PIN using keypad",
267			MAC2STR(sa));
268		dev->flags |= P2P_DEV_PD_PEER_KEYPAD;
269	}
270	p2p_parse_free(&msg);
271
272out:
273	dev->req_config_methods = 0;
274	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
275	if (p2p->cfg->prov_disc_resp)
276		p2p->cfg->prov_disc_resp(p2p->cfg->cb_ctx, sa,
277					 report_config_methods);
278}
279
280
281int p2p_send_prov_disc_req(struct p2p_data *p2p, struct p2p_device *dev,
282			   int join)
283{
284	struct wpabuf *req;
285	int freq;
286
287	freq = dev->listen_freq > 0 ? dev->listen_freq : dev->oper_freq;
288	if (freq <= 0) {
289		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
290			"P2P: No Listen/Operating frequency known for the "
291			"peer " MACSTR " to send Provision Discovery Request",
292			MAC2STR(dev->info.p2p_device_addr));
293		return -1;
294	}
295
296	if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
297		if (!(dev->info.dev_capab &
298		      P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) {
299			wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
300				"P2P: Cannot use PD with P2P Device " MACSTR
301				" that is in a group and is not discoverable",
302				MAC2STR(dev->info.p2p_device_addr));
303			return -1;
304		}
305		/* TODO: use device discoverability request through GO */
306	}
307
308	dev->dialog_token++;
309	if (dev->dialog_token == 0)
310		dev->dialog_token = 1;
311	req = p2p_build_prov_disc_req(p2p, dev->dialog_token,
312				      dev->req_config_methods,
313				      join ? dev : NULL);
314	if (req == NULL)
315		return -1;
316
317	p2p->pending_action_state = P2P_PENDING_PD;
318	if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
319			    p2p->cfg->dev_addr, dev->info.p2p_device_addr,
320			    wpabuf_head(req), wpabuf_len(req), 200) < 0) {
321		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
322			"P2P: Failed to send Action frame");
323		wpabuf_free(req);
324		return -1;
325	}
326
327	os_memcpy(p2p->pending_pd_devaddr, dev->info.p2p_device_addr, ETH_ALEN);
328
329	wpabuf_free(req);
330	return 0;
331}
332
333
334int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
335		      u16 config_methods, int join)
336{
337	struct p2p_device *dev;
338
339	dev = p2p_get_device(p2p, peer_addr);
340	if (dev == NULL)
341		dev = p2p_get_device_interface(p2p, peer_addr);
342	if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
343		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Provision "
344			"Discovery Request destination " MACSTR
345			" not yet known", MAC2STR(peer_addr));
346		return -1;
347	}
348
349	wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Provision Discovery "
350		"Request with " MACSTR " (config methods 0x%x)",
351		MAC2STR(peer_addr), config_methods);
352	if (config_methods == 0)
353		return -1;
354
355	dev->req_config_methods = config_methods;
356	if (join)
357		dev->flags |= P2P_DEV_PD_FOR_JOIN;
358	else
359		dev->flags &= ~P2P_DEV_PD_FOR_JOIN;
360
361	if (p2p->go_neg_peer ||
362	    (p2p->state != P2P_IDLE && p2p->state != P2P_SEARCH &&
363	     p2p->state != P2P_LISTEN_ONLY)) {
364		wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Busy with other "
365			"operations; postpone Provision Discovery Request "
366			"with " MACSTR " (config methods 0x%x)",
367			MAC2STR(peer_addr), config_methods);
368		return 0;
369	}
370
371	/*
372	 * We use the join param as a cue to differentiate between user
373	 * initiated PD request and one issued during finds (internal).
374	 */
375	p2p->user_initiated_pd = !join;
376
377	/* Also set some retries to attempt in case of IDLE state */
378	if (p2p->user_initiated_pd && p2p->state == P2P_IDLE)
379		p2p->pd_retries = MAX_PROV_DISC_REQ_RETRIES;
380
381	return p2p_send_prov_disc_req(p2p, dev, join);
382}
383
384
385void p2p_reset_pending_pd(struct p2p_data *p2p)
386{
387	p2p->user_initiated_pd = 0;
388	os_memset(p2p->pending_pd_devaddr, 0, ETH_ALEN);
389	p2p->pd_retries = 0;
390}
391