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 "common/ieee802_11_defs.h"
13 #include "wps/wps_defs.h"
14 #include "p2p_i.h"
15 #include "p2p.h"
16
17
p2p_go_det(u8 own_intent,u8 peer_value)18 static int p2p_go_det(u8 own_intent, u8 peer_value)
19 {
20 u8 peer_intent = peer_value >> 1;
21 if (own_intent == peer_intent) {
22 if (own_intent == P2P_MAX_GO_INTENT)
23 return -1; /* both devices want to become GO */
24
25 /* Use tie breaker bit to determine GO */
26 return (peer_value & 0x01) ? 0 : 1;
27 }
28
29 return own_intent > peer_intent;
30 }
31
32
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)33 int p2p_peer_channels_check(struct p2p_data *p2p, struct p2p_channels *own,
34 struct p2p_device *dev,
35 const u8 *channel_list, size_t channel_list_len)
36 {
37 const u8 *pos, *end;
38 struct p2p_channels *ch;
39 size_t channels;
40 struct p2p_channels intersection;
41
42 ch = &dev->channels;
43 os_memset(ch, 0, sizeof(*ch));
44 pos = channel_list;
45 end = channel_list + channel_list_len;
46
47 if (end - pos < 3)
48 return -1;
49 os_memcpy(dev->country, pos, 3);
50 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Peer country", pos, 3);
51 if (pos[2] != 0x04 && os_memcmp(pos, p2p->cfg->country, 2) != 0) {
52 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
53 "P2P: Mismatching country (ours=%c%c peer's=%c%c)",
54 p2p->cfg->country[0], p2p->cfg->country[1],
55 pos[0], pos[1]);
56 return -1;
57 }
58 pos += 3;
59
60 while (pos + 2 < end) {
61 struct p2p_reg_class *cl = &ch->reg_class[ch->reg_classes];
62 cl->reg_class = *pos++;
63 if (pos + 1 + pos[0] > end) {
64 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
65 "P2P: Invalid peer Channel List");
66 return -1;
67 }
68 channels = *pos++;
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 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Own reg_classes %d "
80 "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 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO,
86 "P2P: No common channels found");
87 return -1;
88 }
89 return 0;
90 }
91
92
p2p_peer_channels(struct p2p_data * p2p,struct p2p_device * dev,const u8 * channel_list,size_t channel_list_len)93 static int p2p_peer_channels(struct p2p_data *p2p, struct p2p_device *dev,
94 const u8 *channel_list, size_t channel_list_len)
95 {
96 return p2p_peer_channels_check(p2p, &p2p->channels, dev,
97 channel_list, channel_list_len);
98 }
99
100
p2p_wps_method_pw_id(enum p2p_wps_method wps_method)101 u16 p2p_wps_method_pw_id(enum p2p_wps_method wps_method)
102 {
103 switch (wps_method) {
104 case WPS_PIN_DISPLAY:
105 return DEV_PW_REGISTRAR_SPECIFIED;
106 case WPS_PIN_KEYPAD:
107 return DEV_PW_USER_SPECIFIED;
108 case WPS_PBC:
109 return DEV_PW_PUSHBUTTON;
110 default:
111 return DEV_PW_DEFAULT;
112 }
113 }
114
115
p2p_wps_method_str(enum p2p_wps_method wps_method)116 static const char * p2p_wps_method_str(enum p2p_wps_method wps_method)
117 {
118 switch (wps_method) {
119 case WPS_PIN_DISPLAY:
120 return "Display";
121 case WPS_PIN_KEYPAD:
122 return "Keypad";
123 case WPS_PBC:
124 return "PBC";
125 default:
126 return "??";
127 }
128 }
129
130
p2p_build_go_neg_req(struct p2p_data * p2p,struct p2p_device * peer)131 static struct wpabuf * p2p_build_go_neg_req(struct p2p_data *p2p,
132 struct p2p_device *peer)
133 {
134 struct wpabuf *buf;
135 u8 *len;
136 u8 group_capab;
137 size_t extra = 0;
138
139 #ifdef CONFIG_WIFI_DISPLAY
140 if (p2p->wfd_ie_go_neg)
141 extra = wpabuf_len(p2p->wfd_ie_go_neg);
142 #endif /* CONFIG_WIFI_DISPLAY */
143
144 buf = wpabuf_alloc(1000 + extra);
145 if (buf == NULL)
146 return NULL;
147
148 peer->dialog_token++;
149 if (peer->dialog_token == 0)
150 peer->dialog_token = 1;
151 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_REQ, peer->dialog_token);
152
153 len = p2p_buf_add_ie_hdr(buf);
154 group_capab = 0;
155 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
156 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
157 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
158 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_RECONN;
159 }
160 if (p2p->cross_connect)
161 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
162 if (p2p->cfg->p2p_intra_bss)
163 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
164 p2p_buf_add_capability(buf, p2p->dev_capab &
165 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
166 group_capab);
167 p2p_buf_add_go_intent(buf, (p2p->go_intent << 1) |
168 p2p->next_tie_breaker);
169 p2p->next_tie_breaker = !p2p->next_tie_breaker;
170 p2p_buf_add_config_timeout(buf, p2p->go_timeout, p2p->client_timeout);
171 p2p_buf_add_listen_channel(buf, p2p->cfg->country, p2p->cfg->reg_class,
172 p2p->cfg->channel);
173 if (p2p->ext_listen_interval)
174 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period,
175 p2p->ext_listen_interval);
176 p2p_buf_add_intended_addr(buf, p2p->intended_addr);
177 p2p_buf_add_channel_list(buf, p2p->cfg->country, &p2p->channels);
178 p2p_buf_add_device_info(buf, p2p, peer);
179 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
180 p2p->op_reg_class, p2p->op_channel);
181 p2p_buf_update_ie_hdr(buf, len);
182
183 /* WPS IE with Device Password ID attribute */
184 p2p_build_wps_ie(p2p, buf, p2p_wps_method_pw_id(peer->wps_method), 0);
185
186 #ifdef CONFIG_WIFI_DISPLAY
187 if (p2p->wfd_ie_go_neg)
188 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
189 #endif /* CONFIG_WIFI_DISPLAY */
190
191 return buf;
192 }
193
194
p2p_connect_send(struct p2p_data * p2p,struct p2p_device * dev)195 int p2p_connect_send(struct p2p_data *p2p, struct p2p_device *dev)
196 {
197 struct wpabuf *req;
198 int freq;
199
200 if (dev->flags & P2P_DEV_PD_BEFORE_GO_NEG) {
201 u16 config_method;
202 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
203 "P2P: Use PD-before-GO-Neg workaround for " MACSTR,
204 MAC2STR(dev->info.p2p_device_addr));
205 if (dev->wps_method == WPS_PIN_DISPLAY)
206 config_method = WPS_CONFIG_KEYPAD;
207 else if (dev->wps_method == WPS_PIN_KEYPAD)
208 config_method = WPS_CONFIG_DISPLAY;
209 else if (dev->wps_method == WPS_PBC)
210 config_method = WPS_CONFIG_PUSHBUTTON;
211 else
212 return -1;
213 return p2p_prov_disc_req(p2p, dev->info.p2p_device_addr,
214 config_method, 0, 0);
215 }
216
217 freq = dev->listen_freq > 0 ? dev->listen_freq : dev->oper_freq;
218 if (freq <= 0) {
219 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
220 "P2P: No Listen/Operating frequency known for the "
221 "peer " MACSTR " to send GO Negotiation Request",
222 MAC2STR(dev->info.p2p_device_addr));
223 return -1;
224 }
225
226 req = p2p_build_go_neg_req(p2p, dev);
227 if (req == NULL)
228 return -1;
229 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
230 "P2P: Sending GO Negotiation Request");
231 p2p_set_state(p2p, P2P_CONNECT);
232 p2p->pending_action_state = P2P_PENDING_GO_NEG_REQUEST;
233 p2p->go_neg_peer = dev;
234 dev->flags |= P2P_DEV_WAIT_GO_NEG_RESPONSE;
235 dev->connect_reqs++;
236 if (p2p_send_action(p2p, freq, dev->info.p2p_device_addr,
237 p2p->cfg->dev_addr, dev->info.p2p_device_addr,
238 wpabuf_head(req), wpabuf_len(req), 200) < 0) {
239 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
240 "P2P: Failed to send Action frame");
241 /* Use P2P find to recover and retry */
242 p2p_set_timeout(p2p, 0, 0);
243 } else
244 dev->go_neg_req_sent++;
245
246 wpabuf_free(req);
247
248 return 0;
249 }
250
251
p2p_build_go_neg_resp(struct p2p_data * p2p,struct p2p_device * peer,u8 dialog_token,u8 status,u8 tie_breaker)252 static struct wpabuf * p2p_build_go_neg_resp(struct p2p_data *p2p,
253 struct p2p_device *peer,
254 u8 dialog_token, u8 status,
255 u8 tie_breaker)
256 {
257 struct wpabuf *buf;
258 u8 *len;
259 u8 group_capab;
260 size_t extra = 0;
261
262 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
263 "P2P: Building GO Negotiation Response");
264
265 #ifdef CONFIG_WIFI_DISPLAY
266 if (p2p->wfd_ie_go_neg)
267 extra = wpabuf_len(p2p->wfd_ie_go_neg);
268 #endif /* CONFIG_WIFI_DISPLAY */
269
270 buf = wpabuf_alloc(1000 + extra);
271 if (buf == NULL)
272 return NULL;
273
274 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_RESP, dialog_token);
275
276 len = p2p_buf_add_ie_hdr(buf);
277 p2p_buf_add_status(buf, status);
278 group_capab = 0;
279 if (peer && peer->go_state == LOCAL_GO) {
280 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
281 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
282 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
283 group_capab |=
284 P2P_GROUP_CAPAB_PERSISTENT_RECONN;
285 }
286 if (p2p->cross_connect)
287 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
288 if (p2p->cfg->p2p_intra_bss)
289 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
290 }
291 p2p_buf_add_capability(buf, p2p->dev_capab &
292 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
293 group_capab);
294 p2p_buf_add_go_intent(buf, (p2p->go_intent << 1) | tie_breaker);
295 p2p_buf_add_config_timeout(buf, p2p->go_timeout, p2p->client_timeout);
296 if (peer && peer->go_state == REMOTE_GO) {
297 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Omit Operating "
298 "Channel attribute");
299 } else {
300 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
301 p2p->op_reg_class,
302 p2p->op_channel);
303 }
304 p2p_buf_add_intended_addr(buf, p2p->intended_addr);
305
306 if (status || peer == NULL) {
307 p2p_buf_add_channel_list(buf, p2p->cfg->country,
308 &p2p->channels);
309 } else if (peer->go_state == REMOTE_GO) {
310 p2p_buf_add_channel_list(buf, p2p->cfg->country,
311 &p2p->channels);
312 } else {
313 struct p2p_channels res;
314 p2p_channels_intersect(&p2p->channels, &peer->channels,
315 &res);
316 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res);
317 }
318
319 p2p_buf_add_device_info(buf, p2p, peer);
320 if (peer && peer->go_state == LOCAL_GO) {
321 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid,
322 p2p->ssid_len);
323 }
324 p2p_buf_update_ie_hdr(buf, len);
325
326 /* WPS IE with Device Password ID attribute */
327 p2p_build_wps_ie(p2p, buf,
328 p2p_wps_method_pw_id(peer ? peer->wps_method :
329 WPS_NOT_READY), 0);
330
331 #ifdef CONFIG_WIFI_DISPLAY
332 if (p2p->wfd_ie_go_neg)
333 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
334 #endif /* CONFIG_WIFI_DISPLAY */
335
336
337 return buf;
338 }
339
340
p2p_reselect_channel(struct p2p_data * p2p,struct p2p_channels * intersection)341 void p2p_reselect_channel(struct p2p_data *p2p,
342 struct p2p_channels *intersection)
343 {
344 struct p2p_reg_class *cl;
345 int freq;
346 u8 op_reg_class, op_channel;
347 unsigned int i;
348
349 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Selected operating "
350 "channel (reg_class %u channel %u) not acceptable to the "
351 "peer", p2p->op_reg_class, p2p->op_channel);
352
353 /* First, try to pick the best channel from another band */
354 freq = p2p_channel_to_freq(p2p->cfg->country, p2p->op_reg_class,
355 p2p->op_channel);
356 if (freq >= 2400 && freq < 2500 && p2p->best_freq_5 > 0 &&
357 p2p_freq_to_channel(p2p->cfg->country, p2p->best_freq_5,
358 &op_reg_class, &op_channel) == 0 &&
359 p2p_channels_includes(intersection, op_reg_class, op_channel)) {
360 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick best 5 GHz "
361 "channel (reg_class %u channel %u) from intersection",
362 op_reg_class, op_channel);
363 p2p->op_reg_class = op_reg_class;
364 p2p->op_channel = op_channel;
365 return;
366 }
367
368 if (freq >= 4900 && freq < 6000 && p2p->best_freq_24 > 0 &&
369 p2p_freq_to_channel(p2p->cfg->country, p2p->best_freq_24,
370 &op_reg_class, &op_channel) == 0 &&
371 p2p_channels_includes(intersection, op_reg_class, op_channel)) {
372 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick best 2.4 GHz "
373 "channel (reg_class %u channel %u) from intersection",
374 op_reg_class, op_channel);
375 p2p->op_reg_class = op_reg_class;
376 p2p->op_channel = op_channel;
377 return;
378 }
379
380 /* Select channel with highest preference if the peer supports it */
381 for (i = 0; p2p->cfg->pref_chan && i < p2p->cfg->num_pref_chan; i++) {
382 if (p2p_channels_includes(intersection,
383 p2p->cfg->pref_chan[i].op_class,
384 p2p->cfg->pref_chan[i].chan)) {
385 p2p->op_reg_class = p2p->cfg->pref_chan[i].op_class;
386 p2p->op_channel = p2p->cfg->pref_chan[i].chan;
387 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick "
388 "highest preferred chnnel (op_class %u "
389 "channel %u) from intersection",
390 p2p->op_reg_class, p2p->op_channel);
391 return;
392 }
393 }
394
395 /*
396 * Fall back to whatever is included in the channel intersection since
397 * no better options seems to be available.
398 */
399 cl = &intersection->reg_class[0];
400 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick another channel "
401 "(reg_class %u channel %u) from intersection",
402 cl->reg_class, cl->channel[0]);
403 p2p->op_reg_class = cl->reg_class;
404 p2p->op_channel = cl->channel[0];
405 }
406
407
p2p_process_go_neg_req(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)408 void p2p_process_go_neg_req(struct p2p_data *p2p, const u8 *sa,
409 const u8 *data, size_t len, int rx_freq)
410 {
411 struct p2p_device *dev = NULL;
412 struct wpabuf *resp;
413 struct p2p_message msg;
414 u8 status = P2P_SC_FAIL_INVALID_PARAMS;
415 int tie_breaker = 0;
416 int freq;
417
418 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
419 "P2P: Received GO Negotiation Request from " MACSTR
420 "(freq=%d)", MAC2STR(sa), rx_freq);
421
422 if (p2p_parse(data, len, &msg))
423 return;
424
425 if (!msg.capability) {
426 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
427 "P2P: Mandatory Capability attribute missing from GO "
428 "Negotiation Request");
429 #ifdef CONFIG_P2P_STRICT
430 goto fail;
431 #endif /* CONFIG_P2P_STRICT */
432 }
433
434 if (msg.go_intent)
435 tie_breaker = *msg.go_intent & 0x01;
436 else {
437 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
438 "P2P: Mandatory GO Intent attribute missing from GO "
439 "Negotiation Request");
440 #ifdef CONFIG_P2P_STRICT
441 goto fail;
442 #endif /* CONFIG_P2P_STRICT */
443 }
444
445 if (!msg.config_timeout) {
446 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
447 "P2P: Mandatory Configuration Timeout attribute "
448 "missing from GO Negotiation Request");
449 #ifdef CONFIG_P2P_STRICT
450 goto fail;
451 #endif /* CONFIG_P2P_STRICT */
452 }
453
454 if (!msg.listen_channel) {
455 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
456 "P2P: No Listen Channel attribute received");
457 goto fail;
458 }
459 if (!msg.operating_channel) {
460 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
461 "P2P: No Operating Channel attribute received");
462 goto fail;
463 }
464 if (!msg.channel_list) {
465 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
466 "P2P: No Channel List attribute received");
467 goto fail;
468 }
469 if (!msg.intended_addr) {
470 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
471 "P2P: No Intended P2P Interface Address attribute "
472 "received");
473 goto fail;
474 }
475 if (!msg.p2p_device_info) {
476 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
477 "P2P: No P2P Device Info attribute received");
478 goto fail;
479 }
480
481 if (os_memcmp(msg.p2p_device_addr, sa, ETH_ALEN) != 0) {
482 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
483 "P2P: Unexpected GO Negotiation Request SA=" MACSTR
484 " != dev_addr=" MACSTR,
485 MAC2STR(sa), MAC2STR(msg.p2p_device_addr));
486 goto fail;
487 }
488
489 dev = p2p_get_device(p2p, sa);
490
491 if (msg.status && *msg.status) {
492 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
493 "P2P: Unexpected Status attribute (%d) in GO "
494 "Negotiation Request", *msg.status);
495 goto fail;
496 }
497
498 if (dev == NULL)
499 dev = p2p_add_dev_from_go_neg_req(p2p, sa, &msg);
500 else if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
501 p2p_add_dev_info(p2p, sa, dev, &msg);
502 if (dev && dev->flags & P2P_DEV_USER_REJECTED) {
503 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
504 "P2P: User has rejected this peer");
505 status = P2P_SC_FAIL_REJECTED_BY_USER;
506 } else if (dev == NULL || dev->wps_method == WPS_NOT_READY) {
507 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
508 "P2P: Not ready for GO negotiation with " MACSTR,
509 MAC2STR(sa));
510 status = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
511 if (dev)
512 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE;
513 p2p->cfg->go_neg_req_rx(p2p->cfg->cb_ctx, sa,
514 msg.dev_password_id);
515 } else if (p2p->go_neg_peer && p2p->go_neg_peer != dev) {
516 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
517 "P2P: Already in Group Formation with another peer");
518 status = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
519 } else {
520 int go;
521
522 if (!p2p->go_neg_peer) {
523 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting "
524 "GO Negotiation with previously authorized "
525 "peer");
526 if (!(dev->flags & P2P_DEV_FORCE_FREQ)) {
527 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
528 "P2P: Use default channel settings");
529 p2p->op_reg_class = p2p->cfg->op_reg_class;
530 p2p->op_channel = p2p->cfg->op_channel;
531 os_memcpy(&p2p->channels, &p2p->cfg->channels,
532 sizeof(struct p2p_channels));
533 } else {
534 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
535 "P2P: Use previously configured "
536 "forced channel settings");
537 }
538 }
539
540 dev->flags &= ~P2P_DEV_NOT_YET_READY;
541
542 if (!msg.go_intent) {
543 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
544 "P2P: No GO Intent attribute received");
545 goto fail;
546 }
547 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) {
548 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
549 "P2P: Invalid GO Intent value (%u) received",
550 *msg.go_intent >> 1);
551 goto fail;
552 }
553
554 if (dev->go_neg_req_sent &&
555 os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) > 0) {
556 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
557 "P2P: Do not reply since peer has higher "
558 "address and GO Neg Request already sent");
559 p2p_parse_free(&msg);
560 return;
561 }
562
563 go = p2p_go_det(p2p->go_intent, *msg.go_intent);
564 if (go < 0) {
565 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
566 "P2P: Incompatible GO Intent");
567 status = P2P_SC_FAIL_BOTH_GO_INTENT_15;
568 goto fail;
569 }
570
571 if (p2p_peer_channels(p2p, dev, msg.channel_list,
572 msg.channel_list_len) < 0) {
573 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
574 "P2P: No common channels found");
575 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
576 goto fail;
577 }
578
579 switch (msg.dev_password_id) {
580 case DEV_PW_REGISTRAR_SPECIFIED:
581 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
582 "P2P: PIN from peer Display");
583 if (dev->wps_method != WPS_PIN_KEYPAD) {
584 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
585 "P2P: We have wps_method=%s -> "
586 "incompatible",
587 p2p_wps_method_str(dev->wps_method));
588 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
589 goto fail;
590 }
591 break;
592 case DEV_PW_USER_SPECIFIED:
593 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
594 "P2P: Peer entered PIN on Keypad");
595 if (dev->wps_method != WPS_PIN_DISPLAY) {
596 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
597 "P2P: We have wps_method=%s -> "
598 "incompatible",
599 p2p_wps_method_str(dev->wps_method));
600 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
601 goto fail;
602 }
603 break;
604 case DEV_PW_PUSHBUTTON:
605 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
606 "P2P: Peer using pushbutton");
607 if (dev->wps_method != WPS_PBC) {
608 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
609 "P2P: We have wps_method=%s -> "
610 "incompatible",
611 p2p_wps_method_str(dev->wps_method));
612 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
613 goto fail;
614 }
615 break;
616 default:
617 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
618 "P2P: Unsupported Device Password ID %d",
619 msg.dev_password_id);
620 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
621 goto fail;
622 }
623
624 if (go) {
625 struct p2p_channels intersection;
626 size_t i;
627 p2p_channels_intersect(&p2p->channels, &dev->channels,
628 &intersection);
629 if (intersection.reg_classes == 0 ||
630 intersection.reg_class[0].channels == 0) {
631 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
632 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
633 "P2P: No common channels found");
634 goto fail;
635 }
636 for (i = 0; i < intersection.reg_classes; i++) {
637 struct p2p_reg_class *c;
638 c = &intersection.reg_class[i];
639 wpa_printf(MSG_DEBUG, "P2P: reg_class %u",
640 c->reg_class);
641 wpa_hexdump(MSG_DEBUG, "P2P: channels",
642 c->channel, c->channels);
643 }
644 if (!p2p_channels_includes(&intersection,
645 p2p->op_reg_class,
646 p2p->op_channel))
647 p2p_reselect_channel(p2p, &intersection);
648
649 if (!p2p->ssid_set) {
650 p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
651 p2p->ssid_set = 1;
652 }
653 }
654
655 dev->go_state = go ? LOCAL_GO : REMOTE_GO;
656 dev->oper_freq = p2p_channel_to_freq((const char *)
657 msg.operating_channel,
658 msg.operating_channel[3],
659 msg.operating_channel[4]);
660 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer operating "
661 "channel preference: %d MHz", dev->oper_freq);
662
663 if (msg.config_timeout) {
664 dev->go_timeout = msg.config_timeout[0];
665 dev->client_timeout = msg.config_timeout[1];
666 }
667
668 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
669 "P2P: GO Negotiation with " MACSTR, MAC2STR(sa));
670 if (p2p->state != P2P_IDLE)
671 p2p_stop_find_for_freq(p2p, rx_freq);
672 p2p_set_state(p2p, P2P_GO_NEG);
673 p2p_clear_timeout(p2p);
674 dev->dialog_token = msg.dialog_token;
675 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN);
676 p2p->go_neg_peer = dev;
677 status = P2P_SC_SUCCESS;
678 }
679
680 fail:
681 if (dev)
682 dev->status = status;
683 resp = p2p_build_go_neg_resp(p2p, dev, msg.dialog_token, status,
684 !tie_breaker);
685 p2p_parse_free(&msg);
686 if (resp == NULL)
687 return;
688 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
689 "P2P: Sending GO Negotiation Response");
690 if (rx_freq > 0)
691 freq = rx_freq;
692 else
693 freq = p2p_channel_to_freq(p2p->cfg->country,
694 p2p->cfg->reg_class,
695 p2p->cfg->channel);
696 if (freq < 0) {
697 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
698 "P2P: Unknown regulatory class/channel");
699 wpabuf_free(resp);
700 return;
701 }
702 if (status == P2P_SC_SUCCESS) {
703 p2p->pending_action_state = P2P_PENDING_GO_NEG_RESPONSE;
704 dev->flags |= P2P_DEV_WAIT_GO_NEG_CONFIRM;
705 if (os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) < 0) {
706 /*
707 * Peer has smaller address, so the GO Negotiation
708 * Response from us is expected to complete
709 * negotiation. Ignore a GO Negotiation Response from
710 * the peer if it happens to be received after this
711 * point due to a race condition in GO Negotiation
712 * Request transmission and processing.
713 */
714 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
715 }
716 } else
717 p2p->pending_action_state =
718 P2P_PENDING_GO_NEG_RESPONSE_FAILURE;
719 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr,
720 p2p->cfg->dev_addr,
721 wpabuf_head(resp), wpabuf_len(resp), 250) < 0) {
722 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
723 "P2P: Failed to send Action frame");
724 }
725
726 wpabuf_free(resp);
727 }
728
729
p2p_build_go_neg_conf(struct p2p_data * p2p,struct p2p_device * peer,u8 dialog_token,u8 status,const u8 * resp_chan,int go)730 static struct wpabuf * p2p_build_go_neg_conf(struct p2p_data *p2p,
731 struct p2p_device *peer,
732 u8 dialog_token, u8 status,
733 const u8 *resp_chan, int go)
734 {
735 struct wpabuf *buf;
736 u8 *len;
737 struct p2p_channels res;
738 u8 group_capab;
739 size_t extra = 0;
740
741 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
742 "P2P: Building GO Negotiation Confirm");
743
744 #ifdef CONFIG_WIFI_DISPLAY
745 if (p2p->wfd_ie_go_neg)
746 extra = wpabuf_len(p2p->wfd_ie_go_neg);
747 #endif /* CONFIG_WIFI_DISPLAY */
748
749 buf = wpabuf_alloc(1000 + extra);
750 if (buf == NULL)
751 return NULL;
752
753 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_CONF, dialog_token);
754
755 len = p2p_buf_add_ie_hdr(buf);
756 p2p_buf_add_status(buf, status);
757 group_capab = 0;
758 if (peer->go_state == LOCAL_GO) {
759 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) {
760 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP;
761 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN)
762 group_capab |=
763 P2P_GROUP_CAPAB_PERSISTENT_RECONN;
764 }
765 if (p2p->cross_connect)
766 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN;
767 if (p2p->cfg->p2p_intra_bss)
768 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST;
769 }
770 p2p_buf_add_capability(buf, p2p->dev_capab &
771 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY,
772 group_capab);
773 if (go || resp_chan == NULL)
774 p2p_buf_add_operating_channel(buf, p2p->cfg->country,
775 p2p->op_reg_class,
776 p2p->op_channel);
777 else
778 p2p_buf_add_operating_channel(buf, (const char *) resp_chan,
779 resp_chan[3], resp_chan[4]);
780 p2p_channels_intersect(&p2p->channels, &peer->channels, &res);
781 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res);
782 if (go) {
783 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid,
784 p2p->ssid_len);
785 }
786 p2p_buf_update_ie_hdr(buf, len);
787
788 #ifdef CONFIG_WIFI_DISPLAY
789 if (p2p->wfd_ie_go_neg)
790 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg);
791 #endif /* CONFIG_WIFI_DISPLAY */
792
793 return buf;
794 }
795
796
p2p_process_go_neg_resp(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)797 void p2p_process_go_neg_resp(struct p2p_data *p2p, const u8 *sa,
798 const u8 *data, size_t len, int rx_freq)
799 {
800 struct p2p_device *dev;
801 struct wpabuf *conf;
802 int go = -1;
803 struct p2p_message msg;
804 u8 status = P2P_SC_SUCCESS;
805 int freq;
806
807 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
808 "P2P: Received GO Negotiation Response from " MACSTR
809 " (freq=%d)", MAC2STR(sa), rx_freq);
810 dev = p2p_get_device(p2p, sa);
811 if (dev == NULL || dev->wps_method == WPS_NOT_READY ||
812 dev != p2p->go_neg_peer) {
813 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
814 "P2P: Not ready for GO negotiation with " MACSTR,
815 MAC2STR(sa));
816 return;
817 }
818
819 if (p2p_parse(data, len, &msg))
820 return;
821
822 if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE)) {
823 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
824 "P2P: Was not expecting GO Negotiation Response - "
825 "ignore");
826 p2p_parse_free(&msg);
827 return;
828 }
829 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
830
831 if (msg.dialog_token != dev->dialog_token) {
832 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
833 "P2P: Unexpected Dialog Token %u (expected %u)",
834 msg.dialog_token, dev->dialog_token);
835 p2p_parse_free(&msg);
836 return;
837 }
838
839 if (!msg.status) {
840 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
841 "P2P: No Status attribute received");
842 status = P2P_SC_FAIL_INVALID_PARAMS;
843 goto fail;
844 }
845 if (*msg.status) {
846 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
847 "P2P: GO Negotiation rejected: status %d",
848 *msg.status);
849 dev->go_neg_req_sent = 0;
850 if (*msg.status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
851 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
852 "P2P: Wait for the peer to become ready for "
853 "GO Negotiation");
854 dev->flags |= P2P_DEV_NOT_YET_READY;
855 dev->wait_count = 0;
856 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE);
857 p2p_set_timeout(p2p, 0, 0);
858 } else {
859 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
860 "P2P: Stop GO Negotiation attempt");
861 p2p_go_neg_failed(p2p, dev, *msg.status);
862 }
863 p2p->cfg->send_action_done(p2p->cfg->cb_ctx);
864 p2p_parse_free(&msg);
865 return;
866 }
867
868 if (!msg.capability) {
869 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
870 "P2P: Mandatory Capability attribute missing from GO "
871 "Negotiation Response");
872 #ifdef CONFIG_P2P_STRICT
873 status = P2P_SC_FAIL_INVALID_PARAMS;
874 goto fail;
875 #endif /* CONFIG_P2P_STRICT */
876 }
877
878 if (!msg.p2p_device_info) {
879 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
880 "P2P: Mandatory P2P Device Info attribute missing "
881 "from GO Negotiation Response");
882 #ifdef CONFIG_P2P_STRICT
883 status = P2P_SC_FAIL_INVALID_PARAMS;
884 goto fail;
885 #endif /* CONFIG_P2P_STRICT */
886 }
887
888 if (!msg.intended_addr) {
889 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
890 "P2P: No Intended P2P Interface Address attribute "
891 "received");
892 status = P2P_SC_FAIL_INVALID_PARAMS;
893 goto fail;
894 }
895
896 if (!msg.go_intent) {
897 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
898 "P2P: No GO Intent attribute received");
899 status = P2P_SC_FAIL_INVALID_PARAMS;
900 goto fail;
901 }
902 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) {
903 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
904 "P2P: Invalid GO Intent value (%u) received",
905 *msg.go_intent >> 1);
906 status = P2P_SC_FAIL_INVALID_PARAMS;
907 goto fail;
908 }
909
910 go = p2p_go_det(p2p->go_intent, *msg.go_intent);
911 if (go < 0) {
912 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
913 "P2P: Incompatible GO Intent");
914 status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS;
915 goto fail;
916 }
917
918 if (!go && msg.group_id) {
919 /* Store SSID for Provisioning step */
920 p2p->ssid_len = msg.group_id_len - ETH_ALEN;
921 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len);
922 } else if (!go) {
923 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
924 "P2P: Mandatory P2P Group ID attribute missing from "
925 "GO Negotiation Response");
926 p2p->ssid_len = 0;
927 #ifdef CONFIG_P2P_STRICT
928 status = P2P_SC_FAIL_INVALID_PARAMS;
929 goto fail;
930 #endif /* CONFIG_P2P_STRICT */
931 }
932
933 if (!msg.config_timeout) {
934 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
935 "P2P: Mandatory Configuration Timeout attribute "
936 "missing from GO Negotiation Response");
937 #ifdef CONFIG_P2P_STRICT
938 status = P2P_SC_FAIL_INVALID_PARAMS;
939 goto fail;
940 #endif /* CONFIG_P2P_STRICT */
941 } else {
942 dev->go_timeout = msg.config_timeout[0];
943 dev->client_timeout = msg.config_timeout[1];
944 }
945
946 if (!msg.operating_channel && !go) {
947 /*
948 * Note: P2P Client may omit Operating Channel attribute to
949 * indicate it does not have a preference.
950 */
951 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
952 "P2P: No Operating Channel attribute received");
953 status = P2P_SC_FAIL_INVALID_PARAMS;
954 goto fail;
955 }
956 if (!msg.channel_list) {
957 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
958 "P2P: No Channel List attribute received");
959 status = P2P_SC_FAIL_INVALID_PARAMS;
960 goto fail;
961 }
962
963 if (p2p_peer_channels(p2p, dev, msg.channel_list,
964 msg.channel_list_len) < 0) {
965 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
966 "P2P: No common channels found");
967 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
968 goto fail;
969 }
970
971 if (msg.operating_channel) {
972 dev->oper_freq = p2p_channel_to_freq((const char *)
973 msg.operating_channel,
974 msg.operating_channel[3],
975 msg.operating_channel[4]);
976 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer operating "
977 "channel preference: %d MHz", dev->oper_freq);
978 } else
979 dev->oper_freq = 0;
980
981 switch (msg.dev_password_id) {
982 case DEV_PW_REGISTRAR_SPECIFIED:
983 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
984 "P2P: PIN from peer Display");
985 if (dev->wps_method != WPS_PIN_KEYPAD) {
986 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
987 "P2P: We have wps_method=%s -> "
988 "incompatible",
989 p2p_wps_method_str(dev->wps_method));
990 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
991 goto fail;
992 }
993 break;
994 case DEV_PW_USER_SPECIFIED:
995 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
996 "P2P: Peer entered PIN on Keypad");
997 if (dev->wps_method != WPS_PIN_DISPLAY) {
998 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
999 "P2P: We have wps_method=%s -> "
1000 "incompatible",
1001 p2p_wps_method_str(dev->wps_method));
1002 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1003 goto fail;
1004 }
1005 break;
1006 case DEV_PW_PUSHBUTTON:
1007 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1008 "P2P: Peer using pushbutton");
1009 if (dev->wps_method != WPS_PBC) {
1010 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1011 "P2P: We have wps_method=%s -> "
1012 "incompatible",
1013 p2p_wps_method_str(dev->wps_method));
1014 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1015 goto fail;
1016 }
1017 break;
1018 default:
1019 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1020 "P2P: Unsupported Device Password ID %d",
1021 msg.dev_password_id);
1022 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD;
1023 goto fail;
1024 }
1025
1026 if (go) {
1027 struct p2p_channels intersection;
1028 size_t i;
1029 p2p_channels_intersect(&p2p->channels, &dev->channels,
1030 &intersection);
1031 if (intersection.reg_classes == 0 ||
1032 intersection.reg_class[0].channels == 0) {
1033 status = P2P_SC_FAIL_NO_COMMON_CHANNELS;
1034 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1035 "P2P: No common channels found");
1036 goto fail;
1037 }
1038 for (i = 0; i < intersection.reg_classes; i++) {
1039 struct p2p_reg_class *c;
1040 c = &intersection.reg_class[i];
1041 wpa_printf(MSG_DEBUG, "P2P: reg_class %u",
1042 c->reg_class);
1043 wpa_hexdump(MSG_DEBUG, "P2P: channels",
1044 c->channel, c->channels);
1045 }
1046 if (!p2p_channels_includes(&intersection, p2p->op_reg_class,
1047 p2p->op_channel))
1048 p2p_reselect_channel(p2p, &intersection);
1049
1050 if (!p2p->ssid_set) {
1051 p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len);
1052 p2p->ssid_set = 1;
1053 }
1054 }
1055
1056 p2p_set_state(p2p, P2P_GO_NEG);
1057 p2p_clear_timeout(p2p);
1058
1059 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1060 "P2P: GO Negotiation with " MACSTR, MAC2STR(sa));
1061 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN);
1062
1063 fail:
1064 conf = p2p_build_go_neg_conf(p2p, dev, msg.dialog_token, status,
1065 msg.operating_channel, go);
1066 p2p_parse_free(&msg);
1067 if (conf == NULL)
1068 return;
1069 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1070 "P2P: Sending GO Negotiation Confirm");
1071 if (status == P2P_SC_SUCCESS) {
1072 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM;
1073 dev->go_state = go ? LOCAL_GO : REMOTE_GO;
1074 } else
1075 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1076 if (rx_freq > 0)
1077 freq = rx_freq;
1078 else
1079 freq = dev->listen_freq;
1080 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr, sa,
1081 wpabuf_head(conf), wpabuf_len(conf), 0) < 0) {
1082 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1083 "P2P: Failed to send Action frame");
1084 p2p_go_neg_failed(p2p, dev, -1);
1085 }
1086 wpabuf_free(conf);
1087 }
1088
1089
p2p_process_go_neg_conf(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len)1090 void p2p_process_go_neg_conf(struct p2p_data *p2p, const u8 *sa,
1091 const u8 *data, size_t len)
1092 {
1093 struct p2p_device *dev;
1094 struct p2p_message msg;
1095
1096 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1097 "P2P: Received GO Negotiation Confirm from " MACSTR,
1098 MAC2STR(sa));
1099 dev = p2p_get_device(p2p, sa);
1100 if (dev == NULL || dev->wps_method == WPS_NOT_READY ||
1101 dev != p2p->go_neg_peer) {
1102 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1103 "P2P: Not ready for GO negotiation with " MACSTR,
1104 MAC2STR(sa));
1105 return;
1106 }
1107
1108 if (p2p->pending_action_state == P2P_PENDING_GO_NEG_RESPONSE) {
1109 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Stopped waiting "
1110 "for TX status on GO Negotiation Response since we "
1111 "already received Confirmation");
1112 p2p->pending_action_state = P2P_NO_PENDING_ACTION;
1113 }
1114
1115 if (p2p_parse(data, len, &msg))
1116 return;
1117
1118 if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) {
1119 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1120 "P2P: Was not expecting GO Negotiation Confirm - "
1121 "ignore");
1122 return;
1123 }
1124 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1125
1126 if (msg.dialog_token != dev->dialog_token) {
1127 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1128 "P2P: Unexpected Dialog Token %u (expected %u)",
1129 msg.dialog_token, dev->dialog_token);
1130 p2p_parse_free(&msg);
1131 return;
1132 }
1133
1134 if (!msg.status) {
1135 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1136 "P2P: No Status attribute received");
1137 p2p_parse_free(&msg);
1138 return;
1139 }
1140 if (*msg.status) {
1141 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1142 "P2P: GO Negotiation rejected: status %d",
1143 *msg.status);
1144 p2p_parse_free(&msg);
1145 return;
1146 }
1147
1148 if (dev->go_state == REMOTE_GO && msg.group_id) {
1149 /* Store SSID for Provisioning step */
1150 p2p->ssid_len = msg.group_id_len - ETH_ALEN;
1151 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len);
1152 } else if (dev->go_state == REMOTE_GO) {
1153 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1154 "P2P: Mandatory P2P Group ID attribute missing from "
1155 "GO Negotiation Confirmation");
1156 p2p->ssid_len = 0;
1157 #ifdef CONFIG_P2P_STRICT
1158 p2p_parse_free(&msg);
1159 return;
1160 #endif /* CONFIG_P2P_STRICT */
1161 }
1162
1163 if (!msg.operating_channel) {
1164 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1165 "P2P: Mandatory Operating Channel attribute missing "
1166 "from GO Negotiation Confirmation");
1167 #ifdef CONFIG_P2P_STRICT
1168 p2p_parse_free(&msg);
1169 return;
1170 #endif /* CONFIG_P2P_STRICT */
1171 }
1172
1173 #ifdef ANDROID_P2P
1174 if (msg.operating_channel) {
1175 dev->oper_freq = p2p_channel_to_freq((const char *)
1176 msg.operating_channel,
1177 msg.operating_channel[3],
1178 msg.operating_channel[4]);
1179 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer operating "
1180 "channel preference: %d MHz", dev->oper_freq);
1181 } else
1182 dev->oper_freq = 0;
1183 #endif
1184
1185 if (!msg.channel_list) {
1186 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1187 "P2P: Mandatory Operating Channel attribute missing "
1188 "from GO Negotiation Confirmation");
1189 #ifdef CONFIG_P2P_STRICT
1190 p2p_parse_free(&msg);
1191 return;
1192 #endif /* CONFIG_P2P_STRICT */
1193 }
1194
1195 p2p_parse_free(&msg);
1196
1197 if (dev->go_state == UNKNOWN_GO) {
1198 /*
1199 * This should not happen since GO negotiation has already
1200 * been completed.
1201 */
1202 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG,
1203 "P2P: Unexpected GO Neg state - do not know which end "
1204 "becomes GO");
1205 return;
1206 }
1207
1208 /*
1209 * The peer could have missed our ctrl::ack frame for GO Negotiation
1210 * Confirm and continue retransmitting the frame. To reduce the
1211 * likelihood of the peer not getting successful TX status for the
1212 * GO Negotiation Confirm frame, wait a short time here before starting
1213 * the group so that we will remain on the current channel to
1214 * acknowledge any possible retransmission from the peer.
1215 */
1216 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: 20 ms wait on current "
1217 "channel before starting group");
1218 os_sleep(0, 20000);
1219
1220 p2p_go_complete(p2p, dev);
1221 }
1222