1 /*
2  * Wi-Fi Direct - P2P Device Discoverability procedure
3  * Copyright (c) 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 "p2p_i.h"
14 #include "p2p.h"
15 
16 
17 static struct wpabuf * p2p_build_dev_disc_req(struct p2p_data *p2p,
18 					      struct p2p_device *go,
19 					      const u8 *dev_id)
20 {
21 	struct wpabuf *buf;
22 	u8 *len;
23 
24 	buf = wpabuf_alloc(100);
25 	if (buf == NULL)
26 		return NULL;
27 
28 	go->dialog_token++;
29 	if (go->dialog_token == 0)
30 		go->dialog_token = 1;
31 	p2p_buf_add_public_action_hdr(buf, P2P_DEV_DISC_REQ, go->dialog_token);
32 
33 	len = p2p_buf_add_ie_hdr(buf);
34 	p2p_buf_add_device_id(buf, dev_id);
35 	p2p_buf_add_group_id(buf, go->info.p2p_device_addr, go->oper_ssid,
36 			     go->oper_ssid_len);
37 	p2p_buf_update_ie_hdr(buf, len);
38 
39 	return buf;
40 }
41 
42 
43 void p2p_dev_disc_req_cb(struct p2p_data *p2p, int success)
44 {
45 	p2p_dbg(p2p, "Device Discoverability Request TX callback: success=%d",
46 		success);
47 
48 	if (!success) {
49 		/*
50 		 * Use P2P find, if needed, to find the other device or to
51 		 * retry device discoverability.
52 		 */
53 		p2p_set_state(p2p, P2P_CONNECT);
54 		p2p_set_timeout(p2p, 0, 100000);
55 		return;
56 	}
57 
58 	p2p_dbg(p2p, "GO acknowledged Device Discoverability Request - wait for response");
59 	/*
60 	 * TODO: is the remain-on-channel from Action frame TX long enough for
61 	 * most cases or should we try to increase its duration and/or start
62 	 * another remain-on-channel if needed once the previous one expires?
63 	 */
64 }
65 
66 
67 int p2p_send_dev_disc_req(struct p2p_data *p2p, struct p2p_device *dev)
68 {
69 	struct p2p_device *go;
70 	struct wpabuf *req;
71 
72 	go = p2p_get_device(p2p, dev->member_in_go_dev);
73 	if (go == NULL || dev->oper_freq <= 0) {
74 		p2p_dbg(p2p, "Could not find peer entry for GO and frequency to send Device Discoverability Request");
75 		return -1;
76 	}
77 
78 	req = p2p_build_dev_disc_req(p2p, go, dev->info.p2p_device_addr);
79 	if (req == NULL)
80 		return -1;
81 
82 	p2p_dbg(p2p, "Sending Device Discoverability Request to GO " MACSTR
83 		" for client " MACSTR,
84 		MAC2STR(go->info.p2p_device_addr),
85 		MAC2STR(dev->info.p2p_device_addr));
86 
87 	p2p->pending_client_disc_go = go;
88 	os_memcpy(p2p->pending_client_disc_addr, dev->info.p2p_device_addr,
89 		  ETH_ALEN);
90 	p2p->pending_action_state = P2P_PENDING_DEV_DISC_REQUEST;
91 	if (p2p_send_action(p2p, dev->oper_freq, go->info.p2p_device_addr,
92 			    p2p->cfg->dev_addr, go->info.p2p_device_addr,
93 			    wpabuf_head(req), wpabuf_len(req), 1000) < 0) {
94 		p2p_dbg(p2p, "Failed to send Action frame");
95 		wpabuf_free(req);
96 		/* TODO: how to recover from failure? */
97 		return -1;
98 	}
99 
100 	wpabuf_free(req);
101 
102 	return 0;
103 }
104 
105 
106 static struct wpabuf * p2p_build_dev_disc_resp(u8 dialog_token, u8 status)
107 {
108 	struct wpabuf *buf;
109 	u8 *len;
110 
111 	buf = wpabuf_alloc(100);
112 	if (buf == NULL)
113 		return NULL;
114 
115 	p2p_buf_add_public_action_hdr(buf, P2P_DEV_DISC_RESP, dialog_token);
116 
117 	len = p2p_buf_add_ie_hdr(buf);
118 	p2p_buf_add_status(buf, status);
119 	p2p_buf_update_ie_hdr(buf, len);
120 
121 	return buf;
122 }
123 
124 
125 void p2p_dev_disc_resp_cb(struct p2p_data *p2p, int success)
126 {
127 	p2p_dbg(p2p, "Device Discoverability Response TX callback: success=%d",
128 		success);
129 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
130 }
131 
132 
133 static void p2p_send_dev_disc_resp(struct p2p_data *p2p, u8 dialog_token,
134 				   const u8 *addr, int freq, u8 status)
135 {
136 	struct wpabuf *resp;
137 
138 	resp = p2p_build_dev_disc_resp(dialog_token, status);
139 	if (resp == NULL)
140 		return;
141 
142 	p2p_dbg(p2p, "Sending Device Discoverability Response to " MACSTR
143 		" (status %u freq %d)",
144 		MAC2STR(addr), status, freq);
145 
146 	p2p->pending_action_state = P2P_PENDING_DEV_DISC_RESPONSE;
147 	if (p2p_send_action(p2p, freq, addr, p2p->cfg->dev_addr,
148 			    p2p->cfg->dev_addr,
149 			    wpabuf_head(resp), wpabuf_len(resp), 200) < 0) {
150 		p2p_dbg(p2p, "Failed to send Action frame");
151 	}
152 
153 	wpabuf_free(resp);
154 }
155 
156 
157 void p2p_process_dev_disc_req(struct p2p_data *p2p, const u8 *sa,
158 			      const u8 *data, size_t len, int rx_freq)
159 {
160 	struct p2p_message msg;
161 	size_t g;
162 
163 	p2p_dbg(p2p, "Received Device Discoverability Request from " MACSTR
164 		" (freq=%d)", MAC2STR(sa), rx_freq);
165 
166 	if (p2p_parse(data, len, &msg))
167 		return;
168 
169 	if (msg.dialog_token == 0) {
170 		p2p_dbg(p2p, "Invalid Dialog Token 0 (must be nonzero) in Device Discoverability Request");
171 		p2p_send_dev_disc_resp(p2p, msg.dialog_token, sa, rx_freq,
172 				       P2P_SC_FAIL_INVALID_PARAMS);
173 		p2p_parse_free(&msg);
174 		return;
175 	}
176 
177 	if (msg.device_id == NULL) {
178 		p2p_dbg(p2p, "P2P Device ID attribute missing from Device Discoverability Request");
179 		p2p_send_dev_disc_resp(p2p, msg.dialog_token, sa, rx_freq,
180 				       P2P_SC_FAIL_INVALID_PARAMS);
181 		p2p_parse_free(&msg);
182 		return;
183 	}
184 
185 	for (g = 0; g < p2p->num_groups; g++) {
186 		if (p2p_group_go_discover(p2p->groups[g], msg.device_id, sa,
187 					  rx_freq) == 0) {
188 			p2p_dbg(p2p, "Scheduled GO Discoverability Request for the target device");
189 			/*
190 			 * P2P group code will use a callback to indicate TX
191 			 * status, so that we can reply to the request once the
192 			 * target client has acknowledged the request or it has
193 			 * timed out.
194 			 */
195 			p2p->pending_dev_disc_dialog_token = msg.dialog_token;
196 			os_memcpy(p2p->pending_dev_disc_addr, sa, ETH_ALEN);
197 			p2p->pending_dev_disc_freq = rx_freq;
198 			p2p_parse_free(&msg);
199 			return;
200 		}
201 	}
202 
203 	p2p_dbg(p2p, "Requested client was not found in any group or did not support client discoverability");
204 	p2p_send_dev_disc_resp(p2p, msg.dialog_token, sa, rx_freq,
205 			       P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE);
206 	p2p_parse_free(&msg);
207 }
208 
209 
210 void p2p_process_dev_disc_resp(struct p2p_data *p2p, const u8 *sa,
211 			       const u8 *data, size_t len)
212 {
213 	struct p2p_message msg;
214 	struct p2p_device *go;
215 	u8 status;
216 
217 	p2p_dbg(p2p, "Received Device Discoverability Response from " MACSTR,
218 		MAC2STR(sa));
219 
220 	go = p2p->pending_client_disc_go;
221 	if (go == NULL ||
222 	    os_memcmp(sa, go->info.p2p_device_addr, ETH_ALEN) != 0) {
223 		p2p_dbg(p2p, "Ignore unexpected Device Discoverability Response");
224 		return;
225 	}
226 
227 	if (p2p_parse(data, len, &msg))
228 		return;
229 
230 	if (msg.status == NULL) {
231 		p2p_parse_free(&msg);
232 		return;
233 	}
234 
235 	if (msg.dialog_token != go->dialog_token) {
236 		p2p_dbg(p2p, "Ignore Device Discoverability Response with unexpected dialog token %u (expected %u)",
237 			msg.dialog_token, go->dialog_token);
238 		p2p_parse_free(&msg);
239 		return;
240 	}
241 
242 	status = *msg.status;
243 	p2p_parse_free(&msg);
244 
245 	p2p_dbg(p2p, "Device Discoverability Response status %u", status);
246 
247 	if (p2p->go_neg_peer == NULL ||
248 	    os_memcmp(p2p->pending_client_disc_addr,
249 		      p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN) != 0 ||
250 	    os_memcmp(p2p->go_neg_peer->member_in_go_dev,
251 		      go->info.p2p_device_addr, ETH_ALEN) != 0) {
252 		p2p_dbg(p2p, "No pending operation with the client discoverability peer anymore");
253 		return;
254 	}
255 
256 	if (status == 0) {
257 		/*
258 		 * Peer is expected to be awake for at least 100 TU; try to
259 		 * connect immediately.
260 		 */
261 		p2p_dbg(p2p, "Client discoverability request succeeded");
262 		if (p2p->state == P2P_CONNECT) {
263 			/*
264 			 * Change state to force the timeout to start in
265 			 * P2P_CONNECT again without going through the short
266 			 * Listen state.
267 			 */
268 			p2p_set_state(p2p, P2P_CONNECT_LISTEN);
269 			p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
270 		}
271 		p2p_set_timeout(p2p, 0, 0);
272 	} else {
273 		/*
274 		 * Client discoverability request failed; try to connect from
275 		 * timeout.
276 		 */
277 		p2p_dbg(p2p, "Client discoverability request failed");
278 		p2p_set_timeout(p2p, 0, 500000);
279 	}
280 
281 }
282 
283 
284 void p2p_go_disc_req_cb(struct p2p_data *p2p, int success)
285 {
286 	p2p_dbg(p2p, "GO Discoverability Request TX callback: success=%d",
287 		success);
288 	p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
289 
290 	if (p2p->pending_dev_disc_dialog_token == 0) {
291 		p2p_dbg(p2p, "No pending Device Discoverability Request");
292 		return;
293 	}
294 
295 	p2p_send_dev_disc_resp(p2p, p2p->pending_dev_disc_dialog_token,
296 			       p2p->pending_dev_disc_addr,
297 			       p2p->pending_dev_disc_freq,
298 			       success ? P2P_SC_SUCCESS :
299 			       P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE);
300 
301 	p2p->pending_dev_disc_dialog_token = 0;
302 }
303 
304 
305 void p2p_process_go_disc_req(struct p2p_data *p2p, const u8 *da, const u8 *sa,
306 			     const u8 *data, size_t len, int rx_freq)
307 {
308 	unsigned int tu;
309 	struct wpabuf *ies;
310 
311 	p2p_dbg(p2p, "Received GO Discoverability Request - remain awake for 100 TU");
312 
313 	ies = p2p_build_probe_resp_ies(p2p);
314 	if (ies == NULL)
315 		return;
316 
317 	/* Remain awake 100 TU on operating channel */
318 	p2p->pending_client_disc_freq = rx_freq;
319 	tu = 100;
320 	if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, rx_freq, 1024 * tu / 1000,
321 		    ies) < 0) {
322 		p2p_dbg(p2p, "Failed to start listen mode for client discoverability");
323 	}
324 	wpabuf_free(ies);
325 }
326