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