1 /*
2 * Wi-Fi Direct - P2P Group Owner Negotiation
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 "utils/eloop.h"
13 #include "common/ieee802_11_defs.h"
14 #include "common/wpa_ctrl.h"
15 #include "wps/wps_defs.h"
16 #include "p2p_i.h"
17 #include "p2p.h"
18
19
p2p_go_det(u8 own_intent,u8 peer_value)20 static int p2p_go_det(u8 own_intent, u8 peer_value)
21 {
22 u8 peer_intent = peer_value >> 1;
23 if (own_intent == peer_intent) {
24 if (own_intent == P2P_MAX_GO_INTENT)
25 return -1; /* both devices want to become GO */
26
27 /* Use tie breaker bit to determine GO */
28 return (peer_value & 0x01) ? 0 : 1;
29 }
30
31 return own_intent > peer_intent;
32 }
33
34
p2p_peer_channels_check(struct p2p_data * p2p,struct p2p_channels * own,struct p2p_device * dev,const u8 * channel_list,size_t channel_list_len)35 int p2p_peer_channels_check(struct p2p_data *p2p, struct p2p_channels *own,
36 struct p2p_device *dev,
37 const u8 *channel_list, size_t channel_list_len)
38 {
39 const u8 *pos, *end;
40 struct p2p_channels *ch;
41 u8 channels;
42 struct p2p_channels intersection;
43
44 ch = &dev->channels;
45 os_memset(ch, 0, sizeof(*ch));
46 pos = channel_list;
47 end = channel_list + channel_list_len;
48
49 if (end - pos < 3)
50 return -1;
51 os_memcpy(dev->country, pos, 3);
52 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Peer country", pos, 3);
53 if (pos[2] != 0x04 && os_memcmp(pos, p2p->cfg->country, 2) != 0) {
54 p2p_info(p2p, "Mismatching country (ours=%c%c peer's=%c%c)",
55 p2p->cfg->country[0], p2p->cfg->country[1],
56 pos[0], pos[1]);
57 return -1;
58 }
59 pos += 3;
60
61 while (end - pos > 2) {
62 struct p2p_reg_class *cl = &ch->reg_class[ch->reg_classes];
63 cl->reg_class = *pos++;
64 channels = *pos++;
65 if (channels > end - pos) {
66 p2p_info(p2p, "Invalid peer Channel List");
67 return -1;
68 }
69 cl->channels = channels > P2P_MAX_REG_CLASS_CHANNELS ?
70 P2P_MAX_REG_CLASS_CHANNELS : channels;
71 os_memcpy(cl->channel, pos, cl->channels);
72 pos += channels;
73 ch->reg_classes++;
74 if (ch->reg_classes == P2P_MAX_REG_CLASSES)
75 break;
76 }
77
78 p2p_channels_intersect(own, &dev->channels, &intersection);
79 p2p_dbg(p2p, "Own reg_classes %d peer reg_classes %d intersection reg_classes %d",
80 (int) own->reg_classes,
81 (int) dev->channels.reg_classes,
82 (int) intersection.reg_classes);
83 if (intersection.reg_classes == 0) {
84 p2p_info(p2p, "No common channels found");
85 return -1;
86 }
87 return 0;
88 }
89
90
p2p_peer_channels(struct p2p_data * p2p,struct p2p_device * dev,const u8 * channel_list,size_t channel_list_len)91 static int p2p_peer_channels(struct p2p_data *p2p, struct p2p_device *dev,
92 const u8 *channel_list, size_t channel_list_len)
93 {
94 return p2p_peer_channels_check(p2p, &p2p->channels, dev,
95 channel_list, channel_list_len);
96 }
97
98
p2p_wps_method_pw_id(enum p2p_wps_method wps_method)99 u16 p2p_wps_method_pw_id(enum p2p_wps_method wps_method)
100 {
101 switch (wps_method) {
102 case WPS_PIN_DISPLAY:
103 return DEV_PW_REGISTRAR_SPECIFIED;
104 case WPS_PIN_KEYPAD:
105 return DEV_PW_USER_SPECIFIED;
106 case WPS_PBC:
107 return DEV_PW_PUSHBUTTON;
108 case WPS_NFC:
109 return DEV_PW_NFC_CONNECTION_HANDOVER;
110 case WPS_P2PS:
111 return DEV_PW_P2PS_DEFAULT;
112 default:
113 return DEV_PW_DEFAULT;
114 }
115 }
116
117
p2p_wps_method_str(enum p2p_wps_method wps_method)118 static const char * p2p_wps_method_str(enum p2p_wps_method wps_method)
119 {
120 switch (wps_method) {
121 case WPS_PIN_DISPLAY:
122 return "Display";
123 case WPS_PIN_KEYPAD:
124 return "Keypad";
125 case WPS_PBC:
126 return "PBC";
127 case WPS_NFC:
128 return "NFC";
129 case WPS_P2PS:
130 return "P2PS";
131 default:
132 return "??";
133 }
134 }
135
136
p2p_build_go_neg_req(struct p2p_data * p2p,struct p2p_device * peer)137 static struct wpabuf * p2p_build_go_neg_req(struct p2p_data *p2p,
138 struct p2p_device *peer)
139 {
140 struct wpabuf *buf;
141 u8 *len;
142 u8 group_capab;
143 size_t extra = 0;
144 u16 pw_id;
145
146 #ifdef CONFIG_WIFI_DISPLAY
147 if (p2p->wfd_ie_go_neg)
148 extra = wpabuf_len(p2p->wfd_ie_go_neg);
149 #endif /* CONFIG_WIFI_DISPLAY */
150
151 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_REQ])
152 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_REQ]);
153
154 buf = wpabuf_alloc(1000 + extra);
155 if (buf == NULL)
156 return NULL;
157
158 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_REQ, peer->dialog_token);
159
160 len = p2p_buf_add_ie_hdr(buf);
161 group_capab = 0;
162 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
163 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
164 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
165 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_RECONN;
166 }
167 if (p2p->cross_connect)
168 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
169 if (p2p->cfg->p2p_intra_bss)
170 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
171 p2p_buf_add_capability(buf, p2p->dev_capab &
172 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
173 group_capab);
174 p2p_buf_add_go_intent(buf, (p2p->go_intent << 1) | peer->tie_breaker);
175 p2p_buf_add_config_timeout(buf, p2p->go_timeout, p2p->client_timeout);
176 p2p_buf_add_listen_channel(buf, p2p->cfg->country, p2p->cfg->reg_class,
177 p2p->cfg->channel);
178 if (p2p->ext_listen_interval)
179 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
180 p2p->ext_listen_interval);
181 p2p_buf_add_intended_addr(buf, p2p->intended_addr);
182 p2p_buf_add_channel_list(buf, p2p->cfg->country, &p2p->channels);
183 p2p_buf_add_device_info(buf, p2p, peer);
184 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
185 p2p->op_reg_class, p2p->op_channel);
186 p2p_buf_update_ie_hdr(buf, len);
187
188 p2p_buf_add_pref_channel_list(buf, p2p->pref_freq_list,
189 p2p->num_pref_freq);
190
191 /* WPS IE with Device Password ID attribute */
192 pw_id = p2p_wps_method_pw_id(peer->wps_method);
193 if (peer->oob_pw_id)
194 pw_id = peer->oob_pw_id;
195 if (p2p_build_wps_ie(p2p, buf, pw_id, 0) < 0) {
196 p2p_dbg(p2p, "Failed to build WPS IE for GO Negotiation Request");
197 wpabuf_free(buf);
198 return NULL;
199 }
200
201 #ifdef CONFIG_WIFI_DISPLAY
202 if (p2p->wfd_ie_go_neg)
203 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
204 #endif /* CONFIG_WIFI_DISPLAY */
205
206 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_REQ])
207 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_REQ]);
208
209 return buf;
210 }
211
212
p2p_connect_send(struct p2p_data * p2p,struct p2p_device * dev)213 int p2p_connect_send(struct p2p_data *p2p, struct p2p_device *dev)
214 {
215 struct wpabuf *req;
216 int freq;
217
218 if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
219 u16 config_method;
220 p2p_dbg(p2p, "Use PD-before-GO-Neg workaround for " MACSTR,
221 MAC2STR(dev->info.p2p_device_addr));
222 if (dev->wps_method == WPS_PIN_DISPLAY)
223 config_method = WPS_CONFIG_KEYPAD;
224 else if (dev->wps_method == WPS_PIN_KEYPAD)
225 config_method = WPS_CONFIG_DISPLAY;
226 else if (dev->wps_method == WPS_PBC)
227 config_method = WPS_CONFIG_PUSHBUTTON;
228 else if (dev->wps_method == WPS_P2PS)
229 config_method = WPS_CONFIG_P2PS;
230 else
231 return -1;
232 return p2p_prov_disc_req(p2p, dev->info.p2p_device_addr,
233 NULL, config_method, 0, 0, 1);
234 }
235
236 freq = dev->listen_freq > 0 ? dev->listen_freq : dev->oper_freq;
237 if (dev->oob_go_neg_freq > 0)
238 freq = dev->oob_go_neg_freq;
239 if (freq <= 0) {
240 p2p_dbg(p2p, "No Listen/Operating frequency known for the peer "
241 MACSTR " to send GO Negotiation Request",
242 MAC2STR(dev->info.p2p_device_addr));
243 return -1;
244 }
245
246 req = p2p_build_go_neg_req(p2p, dev);
247 if (req == NULL)
248 return -1;
249 p2p_dbg(p2p, "Sending GO Negotiation Request");
250 p2p_set_state(p2p, P2P_CONNECT);
251 p2p->pending_action_state = P2P_PENDING_GO_NEG_REQUEST;
252 p2p->go_neg_peer = dev;
253 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
254 dev->flags |= P2P_DEV_WAIT_GO_NEG_RESPONSE;
255 dev->connect_reqs++;
256 if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
257 p2p->cfg->dev_addr, dev->info.p2p_device_addr,
258 wpabuf_head(req), wpabuf_len(req), 500) < 0) {
259 p2p_dbg(p2p, "Failed to send Action frame");
260 /* Use P2P find to recover and retry */
261 p2p_set_timeout(p2p, 0, 0);
262 } else
263 dev->go_neg_req_sent++;
264
265 wpabuf_free(req);
266
267 return 0;
268 }
269
270
p2p_build_go_neg_resp(struct p2p_data * p2p,struct p2p_device * peer,u8 dialog_token,u8 status,u8 tie_breaker)271 static struct wpabuf * p2p_build_go_neg_resp(struct p2p_data *p2p,
272 struct p2p_device *peer,
273 u8 dialog_token, u8 status,
274 u8 tie_breaker)
275 {
276 struct wpabuf *buf;
277 u8 *len;
278 u8 group_capab;
279 size_t extra = 0;
280 u16 pw_id;
281
282 p2p_dbg(p2p, "Building GO Negotiation Response");
283
284 #ifdef CONFIG_WIFI_DISPLAY
285 if (p2p->wfd_ie_go_neg)
286 extra = wpabuf_len(p2p->wfd_ie_go_neg);
287 #endif /* CONFIG_WIFI_DISPLAY */
288
289 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_RESP])
290 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_RESP]);
291
292 buf = wpabuf_alloc(1000 + extra);
293 if (buf == NULL)
294 return NULL;
295
296 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_RESP, dialog_token);
297
298 len = p2p_buf_add_ie_hdr(buf);
299 p2p_buf_add_status(buf, status);
300 group_capab = 0;
301 if (peer && peer->go_state == LOCAL_GO) {
302 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
303 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
304 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
305 group_capab |=
306 P2P_GROUP_CAPAB_PERSISTENT_RECONN;
307 }
308 if (p2p->cross_connect)
309 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
310 if (p2p->cfg->p2p_intra_bss)
311 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
312 }
313 p2p_buf_add_capability(buf, p2p->dev_capab &
314 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
315 group_capab);
316 p2p_buf_add_go_intent(buf, (p2p->go_intent << 1) | tie_breaker);
317 p2p_buf_add_config_timeout(buf, p2p->go_timeout, p2p->client_timeout);
318 if (p2p->override_pref_op_class) {
319 p2p_dbg(p2p, "Override operating channel preference");
320 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
321 p2p->override_pref_op_class,
322 p2p->override_pref_channel);
323 } else if (peer && peer->go_state == REMOTE_GO && !p2p->num_pref_freq) {
324 p2p_dbg(p2p, "Omit Operating Channel attribute");
325 } else {
326 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
327 p2p->op_reg_class,
328 p2p->op_channel);
329 }
330 p2p_buf_add_intended_addr(buf, p2p->intended_addr);
331 if (status || peer == NULL) {
332 p2p_buf_add_channel_list(buf, p2p->cfg->country,
333 &p2p->channels);
334 } else if (peer->go_state == REMOTE_GO) {
335 p2p_buf_add_channel_list(buf, p2p->cfg->country,
336 &p2p->channels);
337 } else {
338 struct p2p_channels res;
339 p2p_channels_intersect(&p2p->channels, &peer->channels,
340 &res);
341 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res);
342 }
343 p2p_buf_add_device_info(buf, p2p, peer);
344 if (peer && peer->go_state == LOCAL_GO) {
345 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid,
346 p2p->ssid_len);
347 }
348 p2p_buf_update_ie_hdr(buf, len);
349
350 /* WPS IE with Device Password ID attribute */
351 pw_id = p2p_wps_method_pw_id(peer ? peer->wps_method : WPS_NOT_READY);
352 if (peer && peer->oob_pw_id)
353 pw_id = peer->oob_pw_id;
354 if (p2p_build_wps_ie(p2p, buf, pw_id, 0) < 0) {
355 p2p_dbg(p2p, "Failed to build WPS IE for GO Negotiation Response");
356 wpabuf_free(buf);
357 return NULL;
358 }
359
360 #ifdef CONFIG_WIFI_DISPLAY
361 if (p2p->wfd_ie_go_neg)
362 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
363 #endif /* CONFIG_WIFI_DISPLAY */
364
365 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_RESP])
366 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_RESP]);
367
368 return buf;
369 }
370
371
372 /**
373 * p2p_reselect_channel - Re-select operating channel based on peer information
374 * @p2p: P2P module context from p2p_init()
375 * @intersection: Support channel list intersection from local and peer
376 *
377 * This function is used to re-select the best channel after having received
378 * information from the peer to allow supported channel lists to be intersected.
379 * This can be used to improve initial channel selection done in
380 * p2p_prepare_channel() prior to the start of GO Negotiation. In addition, this
381 * can be used for Invitation case.
382 */
p2p_reselect_channel(struct p2p_data * p2p,struct p2p_channels * intersection)383 void p2p_reselect_channel(struct p2p_data *p2p,
384 struct p2p_channels *intersection)
385 {
386 struct p2p_reg_class *cl;
387 int freq;
388 u8 op_reg_class, op_channel;
389 unsigned int i;
390 const int op_classes_5ghz[] = { 124, 125, 115, 0 };
391 const int op_classes_ht40[] = { 126, 127, 116, 117, 0 };
392 const int op_classes_vht[] = { 128, 129, 130, 0 };
393
394 if (p2p->own_freq_preference > 0 &&
395 p2p_freq_to_channel(p2p->own_freq_preference,
396 &op_reg_class, &op_channel) == 0 &&
397 p2p_channels_includes(intersection, op_reg_class, op_channel)) {
398 p2p_dbg(p2p, "Pick own channel preference (reg_class %u channel %u) from intersection",
399 op_reg_class, op_channel);
400 p2p->op_reg_class = op_reg_class;
401 p2p->op_channel = op_channel;
402 return;
403 }
404
405 if (p2p->best_freq_overall > 0 &&
406 p2p_freq_to_channel(p2p->best_freq_overall,
407 &op_reg_class, &op_channel) == 0 &&
408 p2p_channels_includes(intersection, op_reg_class, op_channel)) {
409 p2p_dbg(p2p, "Pick best overall channel (reg_class %u channel %u) from intersection",
410 op_reg_class, op_channel);
411 p2p->op_reg_class = op_reg_class;
412 p2p->op_channel = op_channel;
413 return;
414 }
415
416 /* First, try to pick the best channel from another band */
417 freq = p2p_channel_to_freq(p2p->op_reg_class, p2p->op_channel);
418 if (freq >= 2400 && freq < 2500 && p2p->best_freq_5 > 0 &&
419 !p2p_channels_includes(intersection, p2p->op_reg_class,
420 p2p->op_channel) &&
421 p2p_freq_to_channel(p2p->best_freq_5,
422 &op_reg_class, &op_channel) == 0 &&
423 p2p_channels_includes(intersection, op_reg_class, op_channel)) {
424 p2p_dbg(p2p, "Pick best 5 GHz channel (reg_class %u channel %u) from intersection",
425 op_reg_class, op_channel);
426 p2p->op_reg_class = op_reg_class;
427 p2p->op_channel = op_channel;
428 return;
429 }
430
431 if (freq >= 4900 && freq < 6000 && p2p->best_freq_24 > 0 &&
432 !p2p_channels_includes(intersection, p2p->op_reg_class,
433 p2p->op_channel) &&
434 p2p_freq_to_channel(p2p->best_freq_24,
435 &op_reg_class, &op_channel) == 0 &&
436 p2p_channels_includes(intersection, op_reg_class, op_channel)) {
437 p2p_dbg(p2p, "Pick best 2.4 GHz channel (reg_class %u channel %u) from intersection",
438 op_reg_class, op_channel);
439 p2p->op_reg_class = op_reg_class;
440 p2p->op_channel = op_channel;
441 return;
442 }
443
444 /* Select channel with highest preference if the peer supports it */
445 for (i = 0; p2p->cfg->pref_chan && i < p2p->cfg->num_pref_chan; i++) {
446 if (p2p_channels_includes(intersection,
447 p2p->cfg->pref_chan[i].op_class,
448 p2p->cfg->pref_chan[i].chan)) {
449 p2p->op_reg_class = p2p->cfg->pref_chan[i].op_class;
450 p2p->op_channel = p2p->cfg->pref_chan[i].chan;
451 p2p_dbg(p2p, "Pick highest preferred channel (op_class %u channel %u) from intersection",
452 p2p->op_reg_class, p2p->op_channel);
453 return;
454 }
455 }
456
457 /* Try a channel where we might be able to use VHT */
458 if (p2p_channel_select(intersection, op_classes_vht,
459 &p2p->op_reg_class, &p2p->op_channel) == 0) {
460 p2p_dbg(p2p, "Pick possible VHT channel (op_class %u channel %u) from intersection",
461 p2p->op_reg_class, p2p->op_channel);
462 return;
463 }
464
465 /* Try a channel where we might be able to use HT40 */
466 if (p2p_channel_select(intersection, op_classes_ht40,
467 &p2p->op_reg_class, &p2p->op_channel) == 0) {
468 p2p_dbg(p2p, "Pick possible HT40 channel (op_class %u channel %u) from intersection",
469 p2p->op_reg_class, p2p->op_channel);
470 return;
471 }
472
473 /* Prefer a 5 GHz channel */
474 if (p2p_channel_select(intersection, op_classes_5ghz,
475 &p2p->op_reg_class, &p2p->op_channel) == 0) {
476 p2p_dbg(p2p, "Pick possible 5 GHz channel (op_class %u channel %u) from intersection",
477 p2p->op_reg_class, p2p->op_channel);
478 return;
479 }
480
481 /*
482 * Try to see if the original channel is in the intersection. If
483 * so, no need to change anything, as it already contains some
484 * randomness.
485 */
486 if (p2p_channels_includes(intersection, p2p->op_reg_class,
487 p2p->op_channel)) {
488 p2p_dbg(p2p, "Using original operating class and channel (op_class %u channel %u) from intersection",
489 p2p->op_reg_class, p2p->op_channel);
490 return;
491 }
492
493 /*
494 * Fall back to whatever is included in the channel intersection since
495 * no better options seems to be available.
496 */
497 cl = &intersection->reg_class[0];
498 p2p_dbg(p2p, "Pick another channel (reg_class %u channel %u) from intersection",
499 cl->reg_class, cl->channel[0]);
500 p2p->op_reg_class = cl->reg_class;
501 p2p->op_channel = cl->channel[0];
502 }
503
504
p2p_go_select_channel(struct p2p_data * p2p,struct p2p_device * dev,u8 * status)505 int p2p_go_select_channel(struct p2p_data *p2p, struct p2p_device *dev,
506 u8 *status)
507 {
508 struct p2p_channels tmp, intersection;
509
510 p2p_channels_dump(p2p, "own channels", &p2p->channels);
511 p2p_channels_dump(p2p, "peer channels", &dev->channels);
512 p2p_channels_intersect(&p2p->channels, &dev->channels, &tmp);
513 p2p_channels_dump(p2p, "intersection", &tmp);
514 p2p_channels_remove_freqs(&tmp, &p2p->no_go_freq);
515 p2p_channels_dump(p2p, "intersection after no-GO removal", &tmp);
516 p2p_channels_intersect(&tmp, &p2p->cfg->channels, &intersection);
517 p2p_channels_dump(p2p, "intersection with local channel list",
518 &intersection);
519 if (intersection.reg_classes == 0 ||
520 intersection.reg_class[0].channels == 0) {
521 *status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
522 p2p_dbg(p2p, "No common channels found");
523 return -1;
524 }
525
526 if (!p2p_channels_includes(&intersection, p2p->op_reg_class,
527 p2p->op_channel)) {
528 if (dev->flags & P2P_DEV_FORCE_FREQ) {
529 *status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
530 p2p_dbg(p2p, "Peer does not support the forced channel");
531 return -1;
532 }
533
534 p2p_dbg(p2p, "Selected operating channel (op_class %u channel %u) not acceptable to the peer",
535 p2p->op_reg_class, p2p->op_channel);
536 p2p_reselect_channel(p2p, &intersection);
537 } else if (!(dev->flags & P2P_DEV_FORCE_FREQ) &&
538 !p2p->cfg->cfg_op_channel) {
539 p2p_dbg(p2p, "Try to optimize channel selection with peer information received; previously selected op_class %u channel %u",
540 p2p->op_reg_class, p2p->op_channel);
541 p2p_reselect_channel(p2p, &intersection);
542 }
543
544 if (!p2p->ssid_set) {
545 p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
546 p2p->ssid_set = 1;
547 }
548
549 return 0;
550 }
551
552
p2p_check_pref_chan_no_recv(struct p2p_data * p2p,int go,struct p2p_device * dev,struct p2p_message * msg,unsigned freq_list[],unsigned int size)553 static void p2p_check_pref_chan_no_recv(struct p2p_data *p2p, int go,
554 struct p2p_device *dev,
555 struct p2p_message *msg,
556 unsigned freq_list[], unsigned int size)
557 {
558 u8 op_class, op_channel;
559 unsigned int oper_freq = 0, i, j;
560 int found = 0;
561
562 p2p_dbg(p2p,
563 "Peer didn't provide a preferred frequency list, see if any of our preferred channels are supported by peer device");
564
565 /*
566 * Search for a common channel in our preferred frequency list which is
567 * also supported by the peer device.
568 */
569 for (i = 0; i < size && !found; i++) {
570 /* Make sure that the common frequency is supported by peer. */
571 oper_freq = freq_list[i];
572 if (p2p_freq_to_channel(oper_freq, &op_class,
573 &op_channel) < 0)
574 continue; /* cannot happen due to earlier check */
575 for (j = 0; j < msg->channel_list_len; j++) {
576
577 if (op_channel != msg->channel_list[j])
578 continue;
579
580 p2p->op_reg_class = op_class;
581 p2p->op_channel = op_channel;
582 os_memcpy(&p2p->channels, &p2p->cfg->channels,
583 sizeof(struct p2p_channels));
584 found = 1;
585 break;
586 }
587 }
588
589 if (found) {
590 p2p_dbg(p2p,
591 "Freq %d MHz is a preferred channel and is also supported by peer, use it as the operating channel",
592 oper_freq);
593 } else {
594 p2p_dbg(p2p,
595 "None of our preferred channels are supported by peer!");
596 }
597 }
598
599
p2p_check_pref_chan_recv(struct p2p_data * p2p,int go,struct p2p_device * dev,struct p2p_message * msg,unsigned freq_list[],unsigned int size)600 static void p2p_check_pref_chan_recv(struct p2p_data *p2p, int go,
601 struct p2p_device *dev,
602 struct p2p_message *msg,
603 unsigned freq_list[], unsigned int size)
604 {
605 u8 op_class, op_channel;
606 unsigned int oper_freq = 0, i, j;
607 int found = 0;
608
609 /*
610 * Peer device supports a Preferred Frequency List.
611 * Search for a common channel in the preferred frequency lists
612 * of both peer and local devices.
613 */
614 for (i = 0; i < size && !found; i++) {
615 for (j = 2; j < (msg->pref_freq_list_len / 2); j++) {
616 oper_freq = p2p_channel_to_freq(
617 msg->pref_freq_list[2 * j],
618 msg->pref_freq_list[2 * j + 1]);
619 if (freq_list[i] != oper_freq)
620 continue;
621 if (p2p_freq_to_channel(oper_freq, &op_class,
622 &op_channel) < 0)
623 continue; /* cannot happen */
624 p2p->op_reg_class = op_class;
625 p2p->op_channel = op_channel;
626 os_memcpy(&p2p->channels, &p2p->cfg->channels,
627 sizeof(struct p2p_channels));
628 found = 1;
629 break;
630 }
631 }
632
633 if (found) {
634 p2p_dbg(p2p,
635 "Freq %d MHz is a common preferred channel for both peer and local, use it as operating channel",
636 oper_freq);
637 } else {
638 p2p_dbg(p2p, "No common preferred channels found!");
639 }
640 }
641
642
p2p_check_pref_chan(struct p2p_data * p2p,int go,struct p2p_device * dev,struct p2p_message * msg)643 void p2p_check_pref_chan(struct p2p_data *p2p, int go,
644 struct p2p_device *dev, struct p2p_message *msg)
645 {
646 unsigned int freq_list[P2P_MAX_PREF_CHANNELS], size;
647 unsigned int i;
648 u8 op_class, op_channel;
649 char txt[100], *pos, *end;
650 int res;
651
652 /*
653 * Use the preferred channel list from the driver only if there is no
654 * forced_freq, e.g., P2P_CONNECT freq=..., and no preferred operating
655 * channel hardcoded in the configuration file.
656 */
657 if (!p2p->cfg->get_pref_freq_list || p2p->cfg->num_pref_chan ||
658 (dev->flags & P2P_DEV_FORCE_FREQ) || p2p->cfg->cfg_op_channel)
659 return;
660
661 /* Obtain our preferred frequency list from driver based on P2P role. */
662 size = P2P_MAX_PREF_CHANNELS;
663 if (p2p->cfg->get_pref_freq_list(p2p->cfg->cb_ctx, go, &size,
664 freq_list))
665 return;
666 /* Filter out frequencies that are not acceptable for P2P use */
667 i = 0;
668 while (i < size) {
669 if (p2p_freq_to_channel(freq_list[i], &op_class,
670 &op_channel) < 0 ||
671 (!p2p_channels_includes(&p2p->cfg->channels,
672 op_class, op_channel) &&
673 (go || !p2p_channels_includes(&p2p->cfg->cli_channels,
674 op_class, op_channel)))) {
675 p2p_dbg(p2p,
676 "Ignore local driver frequency preference %u MHz since it is not acceptable for P2P use (go=%d)",
677 freq_list[i], go);
678 if (size - i - 1 > 0)
679 os_memmove(&freq_list[i], &freq_list[i + 1],
680 (size - i - 1) *
681 sizeof(unsigned int));
682 size--;
683 continue;
684 }
685
686 /* Preferred frequency is acceptable for P2P use */
687 i++;
688 }
689
690 pos = txt;
691 end = pos + sizeof(txt);
692 for (i = 0; i < size; i++) {
693 res = os_snprintf(pos, end - pos, " %u", freq_list[i]);
694 if (os_snprintf_error(end - pos, res))
695 break;
696 pos += res;
697 }
698 *pos = '\0';
699 p2p_dbg(p2p, "Local driver frequency preference (size=%u):%s",
700 size, txt);
701
702 /*
703 * Check if peer's preference of operating channel is in
704 * our preferred channel list.
705 */
706 for (i = 0; i < size; i++) {
707 if (freq_list[i] == (unsigned int) dev->oper_freq)
708 break;
709 }
710 if (i != size &&
711 p2p_freq_to_channel(freq_list[i], &op_class, &op_channel) == 0) {
712 /* Peer operating channel preference matches our preference */
713 p2p->op_reg_class = op_class;
714 p2p->op_channel = op_channel;
715 os_memcpy(&p2p->channels, &p2p->cfg->channels,
716 sizeof(struct p2p_channels));
717 return;
718 }
719
720 p2p_dbg(p2p,
721 "Peer operating channel preference: %d MHz is not in our preferred channel list",
722 dev->oper_freq);
723
724 /*
725 Check if peer's preferred channel list is
726 * _not_ included in the GO Negotiation Request or Invitation Request.
727 */
728 if (msg->pref_freq_list_len == 0)
729 p2p_check_pref_chan_no_recv(p2p, go, dev, msg, freq_list, size);
730 else
731 p2p_check_pref_chan_recv(p2p, go, dev, msg, freq_list, size);
732 }
733
734
p2p_process_go_neg_req(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)735 void p2p_process_go_neg_req(struct p2p_data *p2p, const u8 *sa,
736 const u8 *data, size_t len, int rx_freq)
737 {
738 struct p2p_device *dev = NULL;
739 struct wpabuf *resp;
740 struct p2p_message msg;
741 u8 status = P2P_SC_FAIL_INVALID_PARAMS;
742 int tie_breaker = 0;
743 int freq;
744
745 p2p_dbg(p2p, "Received GO Negotiation Request from " MACSTR "(freq=%d)",
746 MAC2STR(sa), rx_freq);
747
748 if (p2p_parse(data, len, &msg))
749 return;
750
751 if (!msg.capability) {
752 p2p_dbg(p2p, "Mandatory Capability attribute missing from GO Negotiation Request");
753 #ifdef CONFIG_P2P_STRICT
754 goto fail;
755 #endif /* CONFIG_P2P_STRICT */
756 }
757
758 if (msg.go_intent)
759 tie_breaker = *msg.go_intent & 0x01;
760 else {
761 p2p_dbg(p2p, "Mandatory GO Intent attribute missing from GO Negotiation Request");
762 #ifdef CONFIG_P2P_STRICT
763 goto fail;
764 #endif /* CONFIG_P2P_STRICT */
765 }
766
767 if (!msg.config_timeout) {
768 p2p_dbg(p2p, "Mandatory Configuration Timeout attribute missing from GO Negotiation Request");
769 #ifdef CONFIG_P2P_STRICT
770 goto fail;
771 #endif /* CONFIG_P2P_STRICT */
772 }
773
774 if (!msg.listen_channel) {
775 p2p_dbg(p2p, "No Listen Channel attribute received");
776 goto fail;
777 }
778 if (!msg.operating_channel) {
779 p2p_dbg(p2p, "No Operating Channel attribute received");
780 goto fail;
781 }
782 if (!msg.channel_list) {
783 p2p_dbg(p2p, "No Channel List attribute received");
784 goto fail;
785 }
786 if (!msg.intended_addr) {
787 p2p_dbg(p2p, "No Intended P2P Interface Address attribute received");
788 goto fail;
789 }
790 if (!msg.p2p_device_info) {
791 p2p_dbg(p2p, "No P2P Device Info attribute received");
792 goto fail;
793 }
794
795 if (os_memcmp(msg.p2p_device_addr, sa, ETH_ALEN) != 0) {
796 p2p_dbg(p2p, "Unexpected GO Negotiation Request SA=" MACSTR
797 " != dev_addr=" MACSTR,
798 MAC2STR(sa), MAC2STR(msg.p2p_device_addr));
799 goto fail;
800 }
801
802 dev = p2p_get_device(p2p, sa);
803
804 if (msg.status && *msg.status) {
805 p2p_dbg(p2p, "Unexpected Status attribute (%d) in GO Negotiation Request",
806 *msg.status);
807 if (dev && p2p->go_neg_peer == dev &&
808 *msg.status == P2P_SC_FAIL_REJECTED_BY_USER) {
809 /*
810 * This mechanism for using Status attribute in GO
811 * Negotiation Request is not compliant with the P2P
812 * specification, but some deployed devices use it to
813 * indicate rejection of GO Negotiation in a case where
814 * they have sent out GO Negotiation Response with
815 * status 1. The P2P specification explicitly disallows
816 * this. To avoid unnecessary interoperability issues
817 * and extra frames, mark the pending negotiation as
818 * failed and do not reply to this GO Negotiation
819 * Request frame.
820 */
821 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
822 p2p_go_neg_failed(p2p, *msg.status);
823 p2p_parse_free(&msg);
824 return;
825 }
826 goto fail;
827 }
828
829 if (dev == NULL)
830 dev = p2p_add_dev_from_go_neg_req(p2p, sa, &msg);
831 else if ((dev->flags & P2P_DEV_PROBE_REQ_ONLY) ||
832 !(dev->flags & P2P_DEV_REPORTED))
833 p2p_add_dev_info(p2p, sa, dev, &msg);
834 else if (!dev->listen_freq && !dev->oper_freq) {
835 /*
836 * This may happen if the peer entry was added based on PD
837 * Request and no Probe Request/Response frame has been received
838 * from this peer (or that information has timed out).
839 */
840 p2p_dbg(p2p, "Update peer " MACSTR
841 " based on GO Neg Req since listen/oper freq not known",
842 MAC2STR(dev->info.p2p_device_addr));
843 p2p_add_dev_info(p2p, sa, dev, &msg);
844 }
845
846 if (p2p->go_neg_peer && p2p->go_neg_peer == dev)
847 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
848
849 if (dev && dev->flags & P2P_DEV_USER_REJECTED) {
850 p2p_dbg(p2p, "User has rejected this peer");
851 status = P2P_SC_FAIL_REJECTED_BY_USER;
852 } else if (dev == NULL ||
853 (dev->wps_method == WPS_NOT_READY &&
854 (p2p->authorized_oob_dev_pw_id == 0 ||
855 p2p->authorized_oob_dev_pw_id !=
856 msg.dev_password_id))) {
857 p2p_dbg(p2p, "Not ready for GO negotiation with " MACSTR,
858 MAC2STR(sa));
859 status = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
860 p2p->cfg->go_neg_req_rx(p2p->cfg->cb_ctx, sa,
861 msg.dev_password_id,
862 msg.go_intent ? (*msg.go_intent >> 1) :
863 0);
864 } else if (p2p->go_neg_peer && p2p->go_neg_peer != dev) {
865 p2p_dbg(p2p, "Already in Group Formation with another peer");
866 status = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
867 } else {
868 int go;
869
870 if (!p2p->go_neg_peer) {
871 p2p_dbg(p2p, "Starting GO Negotiation with previously authorized peer");
872 if (!(dev->flags & P2P_DEV_FORCE_FREQ)) {
873 p2p_dbg(p2p, "Use default channel settings");
874 p2p->op_reg_class = p2p->cfg->op_reg_class;
875 p2p->op_channel = p2p->cfg->op_channel;
876 os_memcpy(&p2p->channels, &p2p->cfg->channels,
877 sizeof(struct p2p_channels));
878 } else {
879 p2p_dbg(p2p, "Use previously configured forced channel settings");
880 }
881 }
882
883 dev->flags &= ~P2P_DEV_NOT_YET_READY;
884
885 if (!msg.go_intent) {
886 p2p_dbg(p2p, "No GO Intent attribute received");
887 goto fail;
888 }
889 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) {
890 p2p_dbg(p2p, "Invalid GO Intent value (%u) received",
891 *msg.go_intent >> 1);
892 goto fail;
893 }
894
895 if (dev->go_neg_req_sent &&
896 os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) > 0) {
897 p2p_dbg(p2p, "Do not reply since peer has higher address and GO Neg Request already sent");
898 p2p_parse_free(&msg);
899 return;
900 }
901
902 if (dev->go_neg_req_sent &&
903 (dev->flags & P2P_DEV_PEER_WAITING_RESPONSE)) {
904 p2p_dbg(p2p,
905 "Do not reply since peer is waiting for us to start a new GO Negotiation and GO Neg Request already sent");
906 p2p_parse_free(&msg);
907 return;
908 }
909
910 go = p2p_go_det(p2p->go_intent, *msg.go_intent);
911 if (go < 0) {
912 p2p_dbg(p2p, "Incompatible GO Intent");
913 status = P2P_SC_FAIL_BOTH_GO_INTENT_15;
914 goto fail;
915 }
916
917 if (p2p_peer_channels(p2p, dev, msg.channel_list,
918 msg.channel_list_len) < 0) {
919 p2p_dbg(p2p, "No common channels found");
920 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
921 goto fail;
922 }
923
924 switch (msg.dev_password_id) {
925 case DEV_PW_REGISTRAR_SPECIFIED:
926 p2p_dbg(p2p, "PIN from peer Display");
927 if (dev->wps_method != WPS_PIN_KEYPAD) {
928 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
929 p2p_wps_method_str(dev->wps_method));
930 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
931 goto fail;
932 }
933 break;
934 case DEV_PW_USER_SPECIFIED:
935 p2p_dbg(p2p, "Peer entered PIN on Keypad");
936 if (dev->wps_method != WPS_PIN_DISPLAY) {
937 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
938 p2p_wps_method_str(dev->wps_method));
939 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
940 goto fail;
941 }
942 break;
943 case DEV_PW_PUSHBUTTON:
944 p2p_dbg(p2p, "Peer using pushbutton");
945 if (dev->wps_method != WPS_PBC) {
946 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
947 p2p_wps_method_str(dev->wps_method));
948 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
949 goto fail;
950 }
951 break;
952 case DEV_PW_P2PS_DEFAULT:
953 p2p_dbg(p2p, "Peer using P2PS pin");
954 if (dev->wps_method != WPS_P2PS) {
955 p2p_dbg(p2p,
956 "We have wps_method=%s -> incompatible",
957 p2p_wps_method_str(dev->wps_method));
958 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
959 goto fail;
960 }
961 break;
962 default:
963 if (msg.dev_password_id &&
964 msg.dev_password_id == dev->oob_pw_id) {
965 p2p_dbg(p2p, "Peer using NFC");
966 if (dev->wps_method != WPS_NFC) {
967 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
968 p2p_wps_method_str(
969 dev->wps_method));
970 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
971 goto fail;
972 }
973 break;
974 }
975 #ifdef CONFIG_WPS_NFC
976 if (p2p->authorized_oob_dev_pw_id &&
977 msg.dev_password_id ==
978 p2p->authorized_oob_dev_pw_id) {
979 p2p_dbg(p2p, "Using static handover with our device password from NFC Tag");
980 dev->wps_method = WPS_NFC;
981 dev->oob_pw_id = p2p->authorized_oob_dev_pw_id;
982 break;
983 }
984 #endif /* CONFIG_WPS_NFC */
985 p2p_dbg(p2p, "Unsupported Device Password ID %d",
986 msg.dev_password_id);
987 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
988 goto fail;
989 }
990
991 if (go && p2p_go_select_channel(p2p, dev, &status) < 0)
992 goto fail;
993
994 dev->go_state = go ? LOCAL_GO : REMOTE_GO;
995 dev->oper_freq = p2p_channel_to_freq(msg.operating_channel[3],
996 msg.operating_channel[4]);
997 p2p_dbg(p2p, "Peer operating channel preference: %d MHz",
998 dev->oper_freq);
999
1000 /*
1001 * Use the driver preferred frequency list extension if
1002 * supported.
1003 */
1004 p2p_check_pref_chan(p2p, go, dev, &msg);
1005
1006 if (msg.config_timeout) {
1007 dev->go_timeout = msg.config_timeout[0];
1008 dev->client_timeout = msg.config_timeout[1];
1009 }
1010
1011 p2p_dbg(p2p, "GO Negotiation with " MACSTR, MAC2STR(sa));
1012 if (p2p->state != P2P_IDLE)
1013 p2p_stop_find_for_freq(p2p, rx_freq);
1014 p2p_set_state(p2p, P2P_GO_NEG);
1015 p2p_clear_timeout(p2p);
1016 dev->dialog_token = msg.dialog_token;
1017 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN);
1018 p2p->go_neg_peer = dev;
1019 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL);
1020 status = P2P_SC_SUCCESS;
1021 }
1022
1023 fail:
1024 if (dev)
1025 dev->status = status;
1026 resp = p2p_build_go_neg_resp(p2p, dev, msg.dialog_token, status,
1027 !tie_breaker);
1028 p2p_parse_free(&msg);
1029 if (resp == NULL)
1030 return;
1031 p2p_dbg(p2p, "Sending GO Negotiation Response");
1032 if (rx_freq > 0)
1033 freq = rx_freq;
1034 else
1035 freq = p2p_channel_to_freq(p2p->cfg->reg_class,
1036 p2p->cfg->channel);
1037 if (freq < 0) {
1038 p2p_dbg(p2p, "Unknown regulatory class/channel");
1039 wpabuf_free(resp);
1040 return;
1041 }
1042 if (status == P2P_SC_SUCCESS) {
1043 p2p->pending_action_state = P2P_PENDING_GO_NEG_RESPONSE;
1044 dev->flags |= P2P_DEV_WAIT_GO_NEG_CONFIRM;
1045 if (os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) < 0) {
1046 /*
1047 * Peer has smaller address, so the GO Negotiation
1048 * Response from us is expected to complete
1049 * negotiation. Ignore a GO Negotiation Response from
1050 * the peer if it happens to be received after this
1051 * point due to a race condition in GO Negotiation
1052 * Request transmission and processing.
1053 */
1054 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1055 }
1056 } else
1057 p2p->pending_action_state =
1058 P2P_PENDING_GO_NEG_RESPONSE_FAILURE;
1059 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
1060 p2p->cfg->dev_addr,
1061 wpabuf_head(resp), wpabuf_len(resp), 100) < 0) {
1062 p2p_dbg(p2p, "Failed to send Action frame");
1063 }
1064
1065 wpabuf_free(resp);
1066 }
1067
1068
p2p_build_go_neg_conf(struct p2p_data * p2p,struct p2p_device * peer,u8 dialog_token,u8 status,const u8 * resp_chan,int go)1069 static struct wpabuf * p2p_build_go_neg_conf(struct p2p_data *p2p,
1070 struct p2p_device *peer,
1071 u8 dialog_token, u8 status,
1072 const u8 *resp_chan, int go)
1073 {
1074 struct wpabuf *buf;
1075 u8 *len;
1076 struct p2p_channels res;
1077 u8 group_capab;
1078 size_t extra = 0;
1079
1080 p2p_dbg(p2p, "Building GO Negotiation Confirm");
1081
1082 #ifdef CONFIG_WIFI_DISPLAY
1083 if (p2p->wfd_ie_go_neg)
1084 extra = wpabuf_len(p2p->wfd_ie_go_neg);
1085 #endif /* CONFIG_WIFI_DISPLAY */
1086
1087 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_CONF])
1088 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_CONF]);
1089
1090 buf = wpabuf_alloc(1000 + extra);
1091 if (buf == NULL)
1092 return NULL;
1093
1094 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_CONF, dialog_token);
1095
1096 len = p2p_buf_add_ie_hdr(buf);
1097 p2p_buf_add_status(buf, status);
1098 group_capab = 0;
1099 if (peer->go_state == LOCAL_GO) {
1100 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
1101 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
1102 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
1103 group_capab |=
1104 P2P_GROUP_CAPAB_PERSISTENT_RECONN;
1105 }
1106 if (p2p->cross_connect)
1107 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
1108 if (p2p->cfg->p2p_intra_bss)
1109 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
1110 }
1111 p2p_buf_add_capability(buf, p2p->dev_capab &
1112 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
1113 group_capab);
1114 if (go || resp_chan == NULL)
1115 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
1116 p2p->op_reg_class,
1117 p2p->op_channel);
1118 else
1119 p2p_buf_add_operating_channel(buf, (const char *) resp_chan,
1120 resp_chan[3], resp_chan[4]);
1121 p2p_channels_intersect(&p2p->channels, &peer->channels, &res);
1122 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res);
1123 if (go) {
1124 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid,
1125 p2p->ssid_len);
1126 }
1127 p2p_buf_update_ie_hdr(buf, len);
1128
1129 #ifdef CONFIG_WIFI_DISPLAY
1130 if (p2p->wfd_ie_go_neg)
1131 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
1132 #endif /* CONFIG_WIFI_DISPLAY */
1133
1134 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_CONF])
1135 wpabuf_put_buf(buf, p2p->vendor_elem[VENDOR_ELEM_P2P_GO_NEG_CONF]);
1136
1137 return buf;
1138 }
1139
1140
p2p_process_go_neg_resp(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)1141 void p2p_process_go_neg_resp(struct p2p_data *p2p, const u8 *sa,
1142 const u8 *data, size_t len, int rx_freq)
1143 {
1144 struct p2p_device *dev;
1145 int go = -1;
1146 struct p2p_message msg;
1147 u8 status = P2P_SC_SUCCESS;
1148 int freq;
1149
1150 p2p_dbg(p2p, "Received GO Negotiation Response from " MACSTR
1151 " (freq=%d)", MAC2STR(sa), rx_freq);
1152 dev = p2p_get_device(p2p, sa);
1153 if (dev == NULL || dev->wps_method == WPS_NOT_READY ||
1154 dev != p2p->go_neg_peer) {
1155 p2p_dbg(p2p, "Not ready for GO negotiation with " MACSTR,
1156 MAC2STR(sa));
1157 return;
1158 }
1159
1160 if (p2p_parse(data, len, &msg))
1161 return;
1162
1163 if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE)) {
1164 p2p_dbg(p2p, "Was not expecting GO Negotiation Response - ignore");
1165 p2p_parse_free(&msg);
1166 return;
1167 }
1168 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1169
1170 if (msg.dialog_token != dev->dialog_token) {
1171 p2p_dbg(p2p, "Unexpected Dialog Token %u (expected %u)",
1172 msg.dialog_token, dev->dialog_token);
1173 p2p_parse_free(&msg);
1174 return;
1175 }
1176
1177 if (!msg.status) {
1178 p2p_dbg(p2p, "No Status attribute received");
1179 status = P2P_SC_FAIL_INVALID_PARAMS;
1180 goto fail;
1181 }
1182 if (*msg.status) {
1183 p2p_dbg(p2p, "GO Negotiation rejected: status %d", *msg.status);
1184 dev->go_neg_req_sent = 0;
1185 if (*msg.status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
1186 p2p_dbg(p2p, "Wait for the peer to become ready for GO Negotiation");
1187 dev->flags |= P2P_DEV_NOT_YET_READY;
1188 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p,
1189 NULL);
1190 eloop_register_timeout(120, 0, p2p_go_neg_wait_timeout,
1191 p2p, NULL);
1192 if (p2p->state == P2P_CONNECT_LISTEN)
1193 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT);
1194 else
1195 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
1196 p2p_set_timeout(p2p, 0, 0);
1197 } else {
1198 p2p_dbg(p2p, "Stop GO Negotiation attempt");
1199 p2p_go_neg_failed(p2p, *msg.status);
1200 }
1201 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1202 p2p_parse_free(&msg);
1203 return;
1204 }
1205
1206 if (!msg.capability) {
1207 p2p_dbg(p2p, "Mandatory Capability attribute missing from GO Negotiation Response");
1208 #ifdef CONFIG_P2P_STRICT
1209 status = P2P_SC_FAIL_INVALID_PARAMS;
1210 goto fail;
1211 #endif /* CONFIG_P2P_STRICT */
1212 }
1213
1214 if (!msg.p2p_device_info) {
1215 p2p_dbg(p2p, "Mandatory P2P Device Info attribute missing from GO Negotiation Response");
1216 #ifdef CONFIG_P2P_STRICT
1217 status = P2P_SC_FAIL_INVALID_PARAMS;
1218 goto fail;
1219 #endif /* CONFIG_P2P_STRICT */
1220 }
1221
1222 if (!msg.intended_addr) {
1223 p2p_dbg(p2p, "No Intended P2P Interface Address attribute received");
1224 status = P2P_SC_FAIL_INVALID_PARAMS;
1225 goto fail;
1226 }
1227
1228 if (!msg.go_intent) {
1229 p2p_dbg(p2p, "No GO Intent attribute received");
1230 status = P2P_SC_FAIL_INVALID_PARAMS;
1231 goto fail;
1232 }
1233 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) {
1234 p2p_dbg(p2p, "Invalid GO Intent value (%u) received",
1235 *msg.go_intent >> 1);
1236 status = P2P_SC_FAIL_INVALID_PARAMS;
1237 goto fail;
1238 }
1239
1240 go = p2p_go_det(p2p->go_intent, *msg.go_intent);
1241 if (go < 0) {
1242 p2p_dbg(p2p, "Incompatible GO Intent");
1243 status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
1244 goto fail;
1245 }
1246
1247 if (!go && msg.group_id) {
1248 /* Store SSID for Provisioning step */
1249 p2p->ssid_len = msg.group_id_len - ETH_ALEN;
1250 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len);
1251 } else if (!go) {
1252 p2p_dbg(p2p, "Mandatory P2P Group ID attribute missing from GO Negotiation Response");
1253 p2p->ssid_len = 0;
1254 status = P2P_SC_FAIL_INVALID_PARAMS;
1255 goto fail;
1256 }
1257
1258 if (!msg.config_timeout) {
1259 p2p_dbg(p2p, "Mandatory Configuration Timeout attribute missing from GO Negotiation Response");
1260 #ifdef CONFIG_P2P_STRICT
1261 status = P2P_SC_FAIL_INVALID_PARAMS;
1262 goto fail;
1263 #endif /* CONFIG_P2P_STRICT */
1264 } else {
1265 dev->go_timeout = msg.config_timeout[0];
1266 dev->client_timeout = msg.config_timeout[1];
1267 }
1268
1269 if (msg.wfd_subelems) {
1270 wpabuf_free(dev->info.wfd_subelems);
1271 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
1272 }
1273
1274 if (!msg.operating_channel && !go) {
1275 /*
1276 * Note: P2P Client may omit Operating Channel attribute to
1277 * indicate it does not have a preference.
1278 */
1279 p2p_dbg(p2p, "No Operating Channel attribute received");
1280 status = P2P_SC_FAIL_INVALID_PARAMS;
1281 goto fail;
1282 }
1283 if (!msg.channel_list) {
1284 p2p_dbg(p2p, "No Channel List attribute received");
1285 status = P2P_SC_FAIL_INVALID_PARAMS;
1286 goto fail;
1287 }
1288
1289 if (p2p_peer_channels(p2p, dev, msg.channel_list,
1290 msg.channel_list_len) < 0) {
1291 p2p_dbg(p2p, "No common channels found");
1292 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
1293 goto fail;
1294 }
1295
1296 if (msg.operating_channel) {
1297 dev->oper_freq = p2p_channel_to_freq(msg.operating_channel[3],
1298 msg.operating_channel[4]);
1299 p2p_dbg(p2p, "Peer operating channel preference: %d MHz",
1300 dev->oper_freq);
1301 } else
1302 dev->oper_freq = 0;
1303
1304 switch (msg.dev_password_id) {
1305 case DEV_PW_REGISTRAR_SPECIFIED:
1306 p2p_dbg(p2p, "PIN from peer Display");
1307 if (dev->wps_method != WPS_PIN_KEYPAD) {
1308 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
1309 p2p_wps_method_str(dev->wps_method));
1310 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1311 goto fail;
1312 }
1313 break;
1314 case DEV_PW_USER_SPECIFIED:
1315 p2p_dbg(p2p, "Peer entered PIN on Keypad");
1316 if (dev->wps_method != WPS_PIN_DISPLAY) {
1317 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
1318 p2p_wps_method_str(dev->wps_method));
1319 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1320 goto fail;
1321 }
1322 break;
1323 case DEV_PW_PUSHBUTTON:
1324 p2p_dbg(p2p, "Peer using pushbutton");
1325 if (dev->wps_method != WPS_PBC) {
1326 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
1327 p2p_wps_method_str(dev->wps_method));
1328 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1329 goto fail;
1330 }
1331 break;
1332 case DEV_PW_P2PS_DEFAULT:
1333 p2p_dbg(p2p, "P2P: Peer using P2PS default pin");
1334 if (dev->wps_method != WPS_P2PS) {
1335 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
1336 p2p_wps_method_str(dev->wps_method));
1337 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1338 goto fail;
1339 }
1340 break;
1341 default:
1342 if (msg.dev_password_id &&
1343 msg.dev_password_id == dev->oob_pw_id) {
1344 p2p_dbg(p2p, "Peer using NFC");
1345 if (dev->wps_method != WPS_NFC) {
1346 p2p_dbg(p2p, "We have wps_method=%s -> incompatible",
1347 p2p_wps_method_str(dev->wps_method));
1348 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1349 goto fail;
1350 }
1351 break;
1352 }
1353 p2p_dbg(p2p, "Unsupported Device Password ID %d",
1354 msg.dev_password_id);
1355 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1356 goto fail;
1357 }
1358
1359 if (go && p2p_go_select_channel(p2p, dev, &status) < 0)
1360 goto fail;
1361
1362 /*
1363 * Use the driver preferred frequency list extension if local device is
1364 * GO.
1365 */
1366 if (go)
1367 p2p_check_pref_chan(p2p, go, dev, &msg);
1368
1369 p2p_set_state(p2p, P2P_GO_NEG);
1370 p2p_clear_timeout(p2p);
1371
1372 p2p_dbg(p2p, "GO Negotiation with " MACSTR, MAC2STR(sa));
1373 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN);
1374
1375 fail:
1376 /* Store GO Negotiation Confirmation to allow retransmission */
1377 wpabuf_free(dev->go_neg_conf);
1378 dev->go_neg_conf = p2p_build_go_neg_conf(p2p, dev, msg.dialog_token,
1379 status, msg.operating_channel,
1380 go);
1381 p2p_parse_free(&msg);
1382 if (dev->go_neg_conf == NULL)
1383 return;
1384 p2p_dbg(p2p, "Sending GO Negotiation Confirm");
1385 if (status == P2P_SC_SUCCESS) {
1386 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;
1387 dev->go_state = go ? LOCAL_GO : REMOTE_GO;
1388 } else
1389 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1390 if (rx_freq > 0)
1391 freq = rx_freq;
1392 else
1393 freq = dev->listen_freq;
1394
1395 dev->go_neg_conf_freq = freq;
1396 dev->go_neg_conf_sent = 0;
1397
1398 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr, sa,
1399 wpabuf_head(dev->go_neg_conf),
1400 wpabuf_len(dev->go_neg_conf), 50) < 0) {
1401 p2p_dbg(p2p, "Failed to send Action frame");
1402 p2p_go_neg_failed(p2p, -1);
1403 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1404 } else
1405 dev->go_neg_conf_sent++;
1406 if (status != P2P_SC_SUCCESS) {
1407 p2p_dbg(p2p, "GO Negotiation failed");
1408 p2p_go_neg_failed(p2p, status);
1409 }
1410 }
1411
1412
p2p_process_go_neg_conf(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len)1413 void p2p_process_go_neg_conf(struct p2p_data *p2p, const u8 *sa,
1414 const u8 *data, size_t len)
1415 {
1416 struct p2p_device *dev;
1417 struct p2p_message msg;
1418
1419 p2p_dbg(p2p, "Received GO Negotiation Confirm from " MACSTR,
1420 MAC2STR(sa));
1421 dev = p2p_get_device(p2p, sa);
1422 if (dev == NULL || dev->wps_method == WPS_NOT_READY ||
1423 dev != p2p->go_neg_peer) {
1424 p2p_dbg(p2p, "Not ready for GO negotiation with " MACSTR,
1425 MAC2STR(sa));
1426 return;
1427 }
1428
1429 if (p2p->pending_action_state == P2P_PENDING_GO_NEG_RESPONSE) {
1430 p2p_dbg(p2p, "Stopped waiting for TX status on GO Negotiation Response since we already received Confirmation");
1431 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1432 }
1433
1434 if (p2p_parse(data, len, &msg))
1435 return;
1436
1437 if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
1438 p2p_dbg(p2p, "Was not expecting GO Negotiation Confirm - ignore");
1439 p2p_parse_free(&msg);
1440 return;
1441 }
1442 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1443 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
1444
1445 if (msg.dialog_token != dev->dialog_token) {
1446 p2p_dbg(p2p, "Unexpected Dialog Token %u (expected %u)",
1447 msg.dialog_token, dev->dialog_token);
1448 p2p_parse_free(&msg);
1449 return;
1450 }
1451
1452 if (!msg.status) {
1453 p2p_dbg(p2p, "No Status attribute received");
1454 p2p_parse_free(&msg);
1455 return;
1456 }
1457 if (*msg.status) {
1458 p2p_dbg(p2p, "GO Negotiation rejected: status %d", *msg.status);
1459 p2p_go_neg_failed(p2p, *msg.status);
1460 p2p_parse_free(&msg);
1461 return;
1462 }
1463
1464 if (dev->go_state == REMOTE_GO && msg.group_id) {
1465 /* Store SSID for Provisioning step */
1466 p2p->ssid_len = msg.group_id_len - ETH_ALEN;
1467 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len);
1468 } else if (dev->go_state == REMOTE_GO) {
1469 p2p_dbg(p2p, "Mandatory P2P Group ID attribute missing from GO Negotiation Confirmation");
1470 p2p->ssid_len = 0;
1471 p2p_go_neg_failed(p2p, P2P_SC_FAIL_INVALID_PARAMS);
1472 p2p_parse_free(&msg);
1473 return;
1474 }
1475
1476 if (!msg.operating_channel) {
1477 p2p_dbg(p2p, "Mandatory Operating Channel attribute missing from GO Negotiation Confirmation");
1478 #ifdef CONFIG_P2P_STRICT
1479 p2p_parse_free(&msg);
1480 return;
1481 #endif /* CONFIG_P2P_STRICT */
1482 } else if (dev->go_state == REMOTE_GO) {
1483 int oper_freq = p2p_channel_to_freq(msg.operating_channel[3],
1484 msg.operating_channel[4]);
1485 if (oper_freq != dev->oper_freq) {
1486 p2p_dbg(p2p, "Updated peer (GO) operating channel preference from %d MHz to %d MHz",
1487 dev->oper_freq, oper_freq);
1488 dev->oper_freq = oper_freq;
1489 }
1490 }
1491
1492 if (!msg.channel_list) {
1493 p2p_dbg(p2p, "Mandatory Operating Channel attribute missing from GO Negotiation Confirmation");
1494 #ifdef CONFIG_P2P_STRICT
1495 p2p_parse_free(&msg);
1496 return;
1497 #endif /* CONFIG_P2P_STRICT */
1498 }
1499
1500 p2p_parse_free(&msg);
1501
1502 if (dev->go_state == UNKNOWN_GO) {
1503 /*
1504 * This should not happen since GO negotiation has already
1505 * been completed.
1506 */
1507 p2p_dbg(p2p, "Unexpected GO Neg state - do not know which end becomes GO");
1508 return;
1509 }
1510
1511 /*
1512 * The peer could have missed our ctrl::ack frame for GO Negotiation
1513 * Confirm and continue retransmitting the frame. To reduce the
1514 * likelihood of the peer not getting successful TX status for the
1515 * GO Negotiation Confirm frame, wait a short time here before starting
1516 * the group so that we will remain on the current channel to
1517 * acknowledge any possible retransmission from the peer.
1518 */
1519 p2p_dbg(p2p, "20 ms wait on current channel before starting group");
1520 os_sleep(0, 20000);
1521
1522 p2p_go_complete(p2p, dev);
1523 }
1524