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 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 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 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 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 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 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 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, 1); 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 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 if (status || peer == NULL) { 306 p2p_buf_add_channel_list(buf, p2p->cfg->country, 307 &p2p->channels); 308 } else if (peer->go_state == REMOTE_GO) { 309 p2p_buf_add_channel_list(buf, p2p->cfg->country, 310 &p2p->channels); 311 } else { 312 struct p2p_channels res; 313 p2p_channels_intersect(&p2p->channels, &peer->channels, 314 &res); 315 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res); 316 } 317 p2p_buf_add_device_info(buf, p2p, peer); 318 if (peer && peer->go_state == LOCAL_GO) { 319 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid, 320 p2p->ssid_len); 321 } 322 p2p_buf_update_ie_hdr(buf, len); 323 324 /* WPS IE with Device Password ID attribute */ 325 p2p_build_wps_ie(p2p, buf, 326 p2p_wps_method_pw_id(peer ? peer->wps_method : 327 WPS_NOT_READY), 0); 328 329 #ifdef CONFIG_WIFI_DISPLAY 330 if (p2p->wfd_ie_go_neg) 331 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg); 332 #endif /* CONFIG_WIFI_DISPLAY */ 333 334 335 return buf; 336 } 337 338 339 /** 340 * p2p_reselect_channel - Re-select operating channel based on peer information 341 * @p2p: P2P module context from p2p_init() 342 * @intersection: Support channel list intersection from local and peer 343 * 344 * This function is used to re-select the best channel after having received 345 * information from the peer to allow supported channel lists to be intersected. 346 * This can be used to improve initial channel selection done in 347 * p2p_prepare_channel() prior to the start of GO Negotiation. In addition, this 348 * can be used for Invitation case. 349 */ 350 void p2p_reselect_channel(struct p2p_data *p2p, 351 struct p2p_channels *intersection) 352 { 353 struct p2p_reg_class *cl; 354 int freq; 355 u8 op_reg_class, op_channel; 356 unsigned int i; 357 358 /* First, try to pick the best channel from another band */ 359 freq = p2p_channel_to_freq(p2p->cfg->country, p2p->op_reg_class, 360 p2p->op_channel); 361 if (freq >= 2400 && freq < 2500 && p2p->best_freq_5 > 0 && 362 p2p_freq_to_channel(p2p->cfg->country, p2p->best_freq_5, 363 &op_reg_class, &op_channel) == 0 && 364 p2p_channels_includes(intersection, op_reg_class, op_channel)) { 365 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick best 5 GHz " 366 "channel (reg_class %u channel %u) from intersection", 367 op_reg_class, op_channel); 368 p2p->op_reg_class = op_reg_class; 369 p2p->op_channel = op_channel; 370 return; 371 } 372 373 if (freq >= 4900 && freq < 6000 && p2p->best_freq_24 > 0 && 374 p2p_freq_to_channel(p2p->cfg->country, p2p->best_freq_24, 375 &op_reg_class, &op_channel) == 0 && 376 p2p_channels_includes(intersection, op_reg_class, op_channel)) { 377 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick best 2.4 GHz " 378 "channel (reg_class %u channel %u) from intersection", 379 op_reg_class, op_channel); 380 p2p->op_reg_class = op_reg_class; 381 p2p->op_channel = op_channel; 382 return; 383 } 384 385 /* Select channel with highest preference if the peer supports it */ 386 for (i = 0; p2p->cfg->pref_chan && i < p2p->cfg->num_pref_chan; i++) { 387 if (p2p_channels_includes(intersection, 388 p2p->cfg->pref_chan[i].op_class, 389 p2p->cfg->pref_chan[i].chan)) { 390 p2p->op_reg_class = p2p->cfg->pref_chan[i].op_class; 391 p2p->op_channel = p2p->cfg->pref_chan[i].chan; 392 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick " 393 "highest preferred chnnel (op_class %u " 394 "channel %u) from intersection", 395 p2p->op_reg_class, p2p->op_channel); 396 return; 397 } 398 } 399 400 /* Try a channel where we might be able to use HT40 */ 401 for (i = 0; i < intersection->reg_classes; i++) { 402 struct p2p_reg_class *c = &intersection->reg_class[i]; 403 if (c->reg_class == 116 || c->reg_class == 117 || 404 c->reg_class == 126 || c->reg_class == 127) { 405 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 406 "P2P: Pick possible HT40 channel (reg_class " 407 "%u channel %u) from intersection", 408 c->reg_class, c->channel[0]); 409 p2p->op_reg_class = c->reg_class; 410 p2p->op_channel = c->channel[0]; 411 return; 412 } 413 } 414 415 /* 416 * Try to see if the original channel is in the intersection. If 417 * so, no need to change anything, as it already contains some 418 * randomness. 419 */ 420 if (p2p_channels_includes(intersection, p2p->op_reg_class, 421 p2p->op_channel)) { 422 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 423 "P2P: Using original operating class and channel " 424 "(op_class %u channel %u) from intersection", 425 p2p->op_reg_class, p2p->op_channel); 426 return; 427 } 428 429 /* 430 * Fall back to whatever is included in the channel intersection since 431 * no better options seems to be available. 432 */ 433 cl = &intersection->reg_class[0]; 434 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Pick another channel " 435 "(reg_class %u channel %u) from intersection", 436 cl->reg_class, cl->channel[0]); 437 p2p->op_reg_class = cl->reg_class; 438 p2p->op_channel = cl->channel[0]; 439 } 440 441 442 static int p2p_go_select_channel(struct p2p_data *p2p, struct p2p_device *dev, 443 u8 *status) 444 { 445 struct p2p_channels intersection; 446 size_t i; 447 448 p2p_channels_intersect(&p2p->channels, &dev->channels, &intersection); 449 if (intersection.reg_classes == 0 || 450 intersection.reg_class[0].channels == 0) { 451 *status = P2P_SC_FAIL_NO_COMMON_CHANNELS; 452 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 453 "P2P: No common channels found"); 454 return -1; 455 } 456 457 for (i = 0; i < intersection.reg_classes; i++) { 458 struct p2p_reg_class *c; 459 c = &intersection.reg_class[i]; 460 wpa_printf(MSG_DEBUG, "P2P: reg_class %u", c->reg_class); 461 wpa_hexdump(MSG_DEBUG, "P2P: channels", 462 c->channel, c->channels); 463 } 464 465 if (!p2p_channels_includes(&intersection, p2p->op_reg_class, 466 p2p->op_channel)) { 467 if (dev->flags & P2P_DEV_FORCE_FREQ) { 468 *status = P2P_SC_FAIL_NO_COMMON_CHANNELS; 469 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer does " 470 "not support the forced channel"); 471 return -1; 472 } 473 474 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Selected operating " 475 "channel (op_class %u channel %u) not acceptable to " 476 "the peer", p2p->op_reg_class, p2p->op_channel); 477 p2p_reselect_channel(p2p, &intersection); 478 } else if (!(dev->flags & P2P_DEV_FORCE_FREQ) && 479 !p2p->cfg->cfg_op_channel) { 480 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Try to optimize " 481 "channel selection with peer information received; " 482 "previously selected op_class %u channel %u", 483 p2p->op_reg_class, p2p->op_channel); 484 p2p_reselect_channel(p2p, &intersection); 485 } 486 487 if (!p2p->ssid_set) { 488 p2p_build_ssid(p2p, p2p->ssid, &p2p->ssid_len); 489 p2p->ssid_set = 1; 490 } 491 492 return 0; 493 } 494 495 496 void p2p_process_go_neg_req(struct p2p_data *p2p, const u8 *sa, 497 const u8 *data, size_t len, int rx_freq) 498 { 499 struct p2p_device *dev = NULL; 500 struct wpabuf *resp; 501 struct p2p_message msg; 502 u8 status = P2P_SC_FAIL_INVALID_PARAMS; 503 int tie_breaker = 0; 504 int freq; 505 506 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 507 "P2P: Received GO Negotiation Request from " MACSTR 508 "(freq=%d)", MAC2STR(sa), rx_freq); 509 510 if (p2p_parse(data, len, &msg)) 511 return; 512 513 if (!msg.capability) { 514 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 515 "P2P: Mandatory Capability attribute missing from GO " 516 "Negotiation Request"); 517 #ifdef CONFIG_P2P_STRICT 518 goto fail; 519 #endif /* CONFIG_P2P_STRICT */ 520 } 521 522 if (msg.go_intent) 523 tie_breaker = *msg.go_intent & 0x01; 524 else { 525 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 526 "P2P: Mandatory GO Intent attribute missing from GO " 527 "Negotiation Request"); 528 #ifdef CONFIG_P2P_STRICT 529 goto fail; 530 #endif /* CONFIG_P2P_STRICT */ 531 } 532 533 if (!msg.config_timeout) { 534 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 535 "P2P: Mandatory Configuration Timeout attribute " 536 "missing from GO Negotiation Request"); 537 #ifdef CONFIG_P2P_STRICT 538 goto fail; 539 #endif /* CONFIG_P2P_STRICT */ 540 } 541 542 if (!msg.listen_channel) { 543 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 544 "P2P: No Listen Channel attribute received"); 545 goto fail; 546 } 547 if (!msg.operating_channel) { 548 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 549 "P2P: No Operating Channel attribute received"); 550 goto fail; 551 } 552 if (!msg.channel_list) { 553 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 554 "P2P: No Channel List attribute received"); 555 goto fail; 556 } 557 if (!msg.intended_addr) { 558 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 559 "P2P: No Intended P2P Interface Address attribute " 560 "received"); 561 goto fail; 562 } 563 if (!msg.p2p_device_info) { 564 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 565 "P2P: No P2P Device Info attribute received"); 566 goto fail; 567 } 568 569 if (os_memcmp(msg.p2p_device_addr, sa, ETH_ALEN) != 0) { 570 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 571 "P2P: Unexpected GO Negotiation Request SA=" MACSTR 572 " != dev_addr=" MACSTR, 573 MAC2STR(sa), MAC2STR(msg.p2p_device_addr)); 574 goto fail; 575 } 576 577 dev = p2p_get_device(p2p, sa); 578 579 if (msg.status && *msg.status) { 580 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 581 "P2P: Unexpected Status attribute (%d) in GO " 582 "Negotiation Request", *msg.status); 583 goto fail; 584 } 585 586 if (dev == NULL) 587 dev = p2p_add_dev_from_go_neg_req(p2p, sa, &msg); 588 else if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) 589 p2p_add_dev_info(p2p, sa, dev, &msg); 590 if (dev && dev->flags & P2P_DEV_USER_REJECTED) { 591 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 592 "P2P: User has rejected this peer"); 593 status = P2P_SC_FAIL_REJECTED_BY_USER; 594 } else if (dev == NULL || dev->wps_method == WPS_NOT_READY) { 595 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 596 "P2P: Not ready for GO negotiation with " MACSTR, 597 MAC2STR(sa)); 598 status = P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE; 599 if (dev) 600 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE; 601 p2p->cfg->go_neg_req_rx(p2p->cfg->cb_ctx, sa, 602 msg.dev_password_id); 603 } else if (p2p->go_neg_peer && p2p->go_neg_peer != dev) { 604 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 605 "P2P: Already in Group Formation with another peer"); 606 status = P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE; 607 } else { 608 int go; 609 610 if (!p2p->go_neg_peer) { 611 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting " 612 "GO Negotiation with previously authorized " 613 "peer"); 614 if (!(dev->flags & P2P_DEV_FORCE_FREQ)) { 615 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 616 "P2P: Use default channel settings"); 617 p2p->op_reg_class = p2p->cfg->op_reg_class; 618 p2p->op_channel = p2p->cfg->op_channel; 619 os_memcpy(&p2p->channels, &p2p->cfg->channels, 620 sizeof(struct p2p_channels)); 621 } else { 622 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 623 "P2P: Use previously configured " 624 "forced channel settings"); 625 } 626 } 627 628 dev->flags &= ~P2P_DEV_NOT_YET_READY; 629 630 if (!msg.go_intent) { 631 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 632 "P2P: No GO Intent attribute received"); 633 goto fail; 634 } 635 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) { 636 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 637 "P2P: Invalid GO Intent value (%u) received", 638 *msg.go_intent >> 1); 639 goto fail; 640 } 641 642 if (dev->go_neg_req_sent && 643 os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) > 0) { 644 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 645 "P2P: Do not reply since peer has higher " 646 "address and GO Neg Request already sent"); 647 p2p_parse_free(&msg); 648 return; 649 } 650 651 go = p2p_go_det(p2p->go_intent, *msg.go_intent); 652 if (go < 0) { 653 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 654 "P2P: Incompatible GO Intent"); 655 status = P2P_SC_FAIL_BOTH_GO_INTENT_15; 656 goto fail; 657 } 658 659 if (p2p_peer_channels(p2p, dev, msg.channel_list, 660 msg.channel_list_len) < 0) { 661 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 662 "P2P: No common channels found"); 663 status = P2P_SC_FAIL_NO_COMMON_CHANNELS; 664 goto fail; 665 } 666 667 switch (msg.dev_password_id) { 668 case DEV_PW_REGISTRAR_SPECIFIED: 669 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 670 "P2P: PIN from peer Display"); 671 if (dev->wps_method != WPS_PIN_KEYPAD) { 672 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 673 "P2P: We have wps_method=%s -> " 674 "incompatible", 675 p2p_wps_method_str(dev->wps_method)); 676 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 677 goto fail; 678 } 679 break; 680 case DEV_PW_USER_SPECIFIED: 681 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 682 "P2P: Peer entered PIN on Keypad"); 683 if (dev->wps_method != WPS_PIN_DISPLAY) { 684 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 685 "P2P: We have wps_method=%s -> " 686 "incompatible", 687 p2p_wps_method_str(dev->wps_method)); 688 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 689 goto fail; 690 } 691 break; 692 case DEV_PW_PUSHBUTTON: 693 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 694 "P2P: Peer using pushbutton"); 695 if (dev->wps_method != WPS_PBC) { 696 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 697 "P2P: We have wps_method=%s -> " 698 "incompatible", 699 p2p_wps_method_str(dev->wps_method)); 700 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 701 goto fail; 702 } 703 break; 704 default: 705 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 706 "P2P: Unsupported Device Password ID %d", 707 msg.dev_password_id); 708 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 709 goto fail; 710 } 711 712 if (go && p2p_go_select_channel(p2p, dev, &status) < 0) 713 goto fail; 714 715 dev->go_state = go ? LOCAL_GO : REMOTE_GO; 716 dev->oper_freq = p2p_channel_to_freq((const char *) 717 msg.operating_channel, 718 msg.operating_channel[3], 719 msg.operating_channel[4]); 720 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer operating " 721 "channel preference: %d MHz", dev->oper_freq); 722 723 if (msg.config_timeout) { 724 dev->go_timeout = msg.config_timeout[0]; 725 dev->client_timeout = msg.config_timeout[1]; 726 } 727 728 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 729 "P2P: GO Negotiation with " MACSTR, MAC2STR(sa)); 730 if (p2p->state != P2P_IDLE) 731 p2p_stop_find_for_freq(p2p, rx_freq); 732 p2p_set_state(p2p, P2P_GO_NEG); 733 p2p_clear_timeout(p2p); 734 dev->dialog_token = msg.dialog_token; 735 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN); 736 p2p->go_neg_peer = dev; 737 status = P2P_SC_SUCCESS; 738 } 739 740 fail: 741 if (dev) 742 dev->status = status; 743 resp = p2p_build_go_neg_resp(p2p, dev, msg.dialog_token, status, 744 !tie_breaker); 745 p2p_parse_free(&msg); 746 if (resp == NULL) 747 return; 748 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 749 "P2P: Sending GO Negotiation Response"); 750 if (rx_freq > 0) 751 freq = rx_freq; 752 else 753 freq = p2p_channel_to_freq(p2p->cfg->country, 754 p2p->cfg->reg_class, 755 p2p->cfg->channel); 756 if (freq < 0) { 757 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 758 "P2P: Unknown regulatory class/channel"); 759 wpabuf_free(resp); 760 return; 761 } 762 if (status == P2P_SC_SUCCESS) { 763 p2p->pending_action_state = P2P_PENDING_GO_NEG_RESPONSE; 764 dev->flags |= P2P_DEV_WAIT_GO_NEG_CONFIRM; 765 if (os_memcmp(sa, p2p->cfg->dev_addr, ETH_ALEN) < 0) { 766 /* 767 * Peer has smaller address, so the GO Negotiation 768 * Response from us is expected to complete 769 * negotiation. Ignore a GO Negotiation Response from 770 * the peer if it happens to be received after this 771 * point due to a race condition in GO Negotiation 772 * Request transmission and processing. 773 */ 774 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; 775 } 776 } else 777 p2p->pending_action_state = 778 P2P_PENDING_GO_NEG_RESPONSE_FAILURE; 779 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr, 780 p2p->cfg->dev_addr, 781 wpabuf_head(resp), wpabuf_len(resp), 250) < 0) { 782 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 783 "P2P: Failed to send Action frame"); 784 } 785 786 wpabuf_free(resp); 787 } 788 789 790 static struct wpabuf * p2p_build_go_neg_conf(struct p2p_data *p2p, 791 struct p2p_device *peer, 792 u8 dialog_token, u8 status, 793 const u8 *resp_chan, int go) 794 { 795 struct wpabuf *buf; 796 u8 *len; 797 struct p2p_channels res; 798 u8 group_capab; 799 size_t extra = 0; 800 801 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 802 "P2P: Building GO Negotiation Confirm"); 803 804 #ifdef CONFIG_WIFI_DISPLAY 805 if (p2p->wfd_ie_go_neg) 806 extra = wpabuf_len(p2p->wfd_ie_go_neg); 807 #endif /* CONFIG_WIFI_DISPLAY */ 808 809 buf = wpabuf_alloc(1000 + extra); 810 if (buf == NULL) 811 return NULL; 812 813 p2p_buf_add_public_action_hdr(buf, P2P_GO_NEG_CONF, dialog_token); 814 815 len = p2p_buf_add_ie_hdr(buf); 816 p2p_buf_add_status(buf, status); 817 group_capab = 0; 818 if (peer->go_state == LOCAL_GO) { 819 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) { 820 group_capab |= P2P_GROUP_CAPAB_PERSISTENT_GROUP; 821 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN) 822 group_capab |= 823 P2P_GROUP_CAPAB_PERSISTENT_RECONN; 824 } 825 if (p2p->cross_connect) 826 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN; 827 if (p2p->cfg->p2p_intra_bss) 828 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST; 829 } 830 p2p_buf_add_capability(buf, p2p->dev_capab & 831 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 832 group_capab); 833 if (go || resp_chan == NULL) 834 p2p_buf_add_operating_channel(buf, p2p->cfg->country, 835 p2p->op_reg_class, 836 p2p->op_channel); 837 else 838 p2p_buf_add_operating_channel(buf, (const char *) resp_chan, 839 resp_chan[3], resp_chan[4]); 840 p2p_channels_intersect(&p2p->channels, &peer->channels, &res); 841 p2p_buf_add_channel_list(buf, p2p->cfg->country, &res); 842 if (go) { 843 p2p_buf_add_group_id(buf, p2p->cfg->dev_addr, p2p->ssid, 844 p2p->ssid_len); 845 } 846 p2p_buf_update_ie_hdr(buf, len); 847 848 #ifdef CONFIG_WIFI_DISPLAY 849 if (p2p->wfd_ie_go_neg) 850 wpabuf_put_buf(buf, p2p->wfd_ie_go_neg); 851 #endif /* CONFIG_WIFI_DISPLAY */ 852 853 return buf; 854 } 855 856 857 void p2p_process_go_neg_resp(struct p2p_data *p2p, const u8 *sa, 858 const u8 *data, size_t len, int rx_freq) 859 { 860 struct p2p_device *dev; 861 struct wpabuf *conf; 862 int go = -1; 863 struct p2p_message msg; 864 u8 status = P2P_SC_SUCCESS; 865 int freq; 866 867 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 868 "P2P: Received GO Negotiation Response from " MACSTR 869 " (freq=%d)", MAC2STR(sa), rx_freq); 870 dev = p2p_get_device(p2p, sa); 871 if (dev == NULL || dev->wps_method == WPS_NOT_READY || 872 dev != p2p->go_neg_peer) { 873 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 874 "P2P: Not ready for GO negotiation with " MACSTR, 875 MAC2STR(sa)); 876 return; 877 } 878 879 if (p2p_parse(data, len, &msg)) 880 return; 881 882 if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE)) { 883 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 884 "P2P: Was not expecting GO Negotiation Response - " 885 "ignore"); 886 p2p_parse_free(&msg); 887 return; 888 } 889 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; 890 891 if (msg.dialog_token != dev->dialog_token) { 892 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 893 "P2P: Unexpected Dialog Token %u (expected %u)", 894 msg.dialog_token, dev->dialog_token); 895 p2p_parse_free(&msg); 896 return; 897 } 898 899 if (!msg.status) { 900 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 901 "P2P: No Status attribute received"); 902 status = P2P_SC_FAIL_INVALID_PARAMS; 903 goto fail; 904 } 905 if (*msg.status) { 906 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 907 "P2P: GO Negotiation rejected: status %d", 908 *msg.status); 909 dev->go_neg_req_sent = 0; 910 if (*msg.status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) { 911 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 912 "P2P: Wait for the peer to become ready for " 913 "GO Negotiation"); 914 dev->flags |= P2P_DEV_NOT_YET_READY; 915 dev->wait_count = 0; 916 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE); 917 p2p_set_timeout(p2p, 0, 0); 918 } else { 919 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 920 "P2P: Stop GO Negotiation attempt"); 921 p2p_go_neg_failed(p2p, dev, *msg.status); 922 } 923 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 924 p2p_parse_free(&msg); 925 return; 926 } 927 928 if (!msg.capability) { 929 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 930 "P2P: Mandatory Capability attribute missing from GO " 931 "Negotiation Response"); 932 #ifdef CONFIG_P2P_STRICT 933 status = P2P_SC_FAIL_INVALID_PARAMS; 934 goto fail; 935 #endif /* CONFIG_P2P_STRICT */ 936 } 937 938 if (!msg.p2p_device_info) { 939 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 940 "P2P: Mandatory P2P Device Info attribute missing " 941 "from GO Negotiation Response"); 942 #ifdef CONFIG_P2P_STRICT 943 status = P2P_SC_FAIL_INVALID_PARAMS; 944 goto fail; 945 #endif /* CONFIG_P2P_STRICT */ 946 } 947 948 if (!msg.intended_addr) { 949 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 950 "P2P: No Intended P2P Interface Address attribute " 951 "received"); 952 status = P2P_SC_FAIL_INVALID_PARAMS; 953 goto fail; 954 } 955 956 if (!msg.go_intent) { 957 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 958 "P2P: No GO Intent attribute received"); 959 status = P2P_SC_FAIL_INVALID_PARAMS; 960 goto fail; 961 } 962 if ((*msg.go_intent >> 1) > P2P_MAX_GO_INTENT) { 963 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 964 "P2P: Invalid GO Intent value (%u) received", 965 *msg.go_intent >> 1); 966 status = P2P_SC_FAIL_INVALID_PARAMS; 967 goto fail; 968 } 969 970 go = p2p_go_det(p2p->go_intent, *msg.go_intent); 971 if (go < 0) { 972 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 973 "P2P: Incompatible GO Intent"); 974 status = P2P_SC_FAIL_INCOMPATIBLE_PARAMS; 975 goto fail; 976 } 977 978 if (!go && msg.group_id) { 979 /* Store SSID for Provisioning step */ 980 p2p->ssid_len = msg.group_id_len - ETH_ALEN; 981 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len); 982 } else if (!go) { 983 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 984 "P2P: Mandatory P2P Group ID attribute missing from " 985 "GO Negotiation Response"); 986 p2p->ssid_len = 0; 987 #ifdef CONFIG_P2P_STRICT 988 status = P2P_SC_FAIL_INVALID_PARAMS; 989 goto fail; 990 #endif /* CONFIG_P2P_STRICT */ 991 } 992 993 if (!msg.config_timeout) { 994 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 995 "P2P: Mandatory Configuration Timeout attribute " 996 "missing from GO Negotiation Response"); 997 #ifdef CONFIG_P2P_STRICT 998 status = P2P_SC_FAIL_INVALID_PARAMS; 999 goto fail; 1000 #endif /* CONFIG_P2P_STRICT */ 1001 } else { 1002 dev->go_timeout = msg.config_timeout[0]; 1003 dev->client_timeout = msg.config_timeout[1]; 1004 } 1005 1006 if (!msg.operating_channel && !go) { 1007 /* 1008 * Note: P2P Client may omit Operating Channel attribute to 1009 * indicate it does not have a preference. 1010 */ 1011 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1012 "P2P: No Operating Channel attribute received"); 1013 status = P2P_SC_FAIL_INVALID_PARAMS; 1014 goto fail; 1015 } 1016 if (!msg.channel_list) { 1017 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1018 "P2P: No Channel List attribute received"); 1019 status = P2P_SC_FAIL_INVALID_PARAMS; 1020 goto fail; 1021 } 1022 1023 if (p2p_peer_channels(p2p, dev, msg.channel_list, 1024 msg.channel_list_len) < 0) { 1025 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1026 "P2P: No common channels found"); 1027 status = P2P_SC_FAIL_NO_COMMON_CHANNELS; 1028 goto fail; 1029 } 1030 1031 if (msg.operating_channel) { 1032 dev->oper_freq = p2p_channel_to_freq((const char *) 1033 msg.operating_channel, 1034 msg.operating_channel[3], 1035 msg.operating_channel[4]); 1036 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer operating " 1037 "channel preference: %d MHz", dev->oper_freq); 1038 } else 1039 dev->oper_freq = 0; 1040 1041 switch (msg.dev_password_id) { 1042 case DEV_PW_REGISTRAR_SPECIFIED: 1043 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1044 "P2P: PIN from peer Display"); 1045 if (dev->wps_method != WPS_PIN_KEYPAD) { 1046 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1047 "P2P: We have wps_method=%s -> " 1048 "incompatible", 1049 p2p_wps_method_str(dev->wps_method)); 1050 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 1051 goto fail; 1052 } 1053 break; 1054 case DEV_PW_USER_SPECIFIED: 1055 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1056 "P2P: Peer entered PIN on Keypad"); 1057 if (dev->wps_method != WPS_PIN_DISPLAY) { 1058 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1059 "P2P: We have wps_method=%s -> " 1060 "incompatible", 1061 p2p_wps_method_str(dev->wps_method)); 1062 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 1063 goto fail; 1064 } 1065 break; 1066 case DEV_PW_PUSHBUTTON: 1067 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1068 "P2P: Peer using pushbutton"); 1069 if (dev->wps_method != WPS_PBC) { 1070 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1071 "P2P: We have wps_method=%s -> " 1072 "incompatible", 1073 p2p_wps_method_str(dev->wps_method)); 1074 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 1075 goto fail; 1076 } 1077 break; 1078 default: 1079 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1080 "P2P: Unsupported Device Password ID %d", 1081 msg.dev_password_id); 1082 status = P2P_SC_FAIL_INCOMPATIBLE_PROV_METHOD; 1083 goto fail; 1084 } 1085 1086 if (go && p2p_go_select_channel(p2p, dev, &status) < 0) 1087 goto fail; 1088 1089 p2p_set_state(p2p, P2P_GO_NEG); 1090 p2p_clear_timeout(p2p); 1091 1092 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1093 "P2P: GO Negotiation with " MACSTR, MAC2STR(sa)); 1094 os_memcpy(dev->intended_addr, msg.intended_addr, ETH_ALEN); 1095 1096 fail: 1097 conf = p2p_build_go_neg_conf(p2p, dev, msg.dialog_token, status, 1098 msg.operating_channel, go); 1099 p2p_parse_free(&msg); 1100 if (conf == NULL) 1101 return; 1102 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1103 "P2P: Sending GO Negotiation Confirm"); 1104 if (status == P2P_SC_SUCCESS) { 1105 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM; 1106 dev->go_state = go ? LOCAL_GO : REMOTE_GO; 1107 } else 1108 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 1109 if (rx_freq > 0) 1110 freq = rx_freq; 1111 else 1112 freq = dev->listen_freq; 1113 if (p2p_send_action(p2p, freq, sa, p2p->cfg->dev_addr, sa, 1114 wpabuf_head(conf), wpabuf_len(conf), 0) < 0) { 1115 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1116 "P2P: Failed to send Action frame"); 1117 p2p_go_neg_failed(p2p, dev, -1); 1118 } 1119 wpabuf_free(conf); 1120 } 1121 1122 1123 void p2p_process_go_neg_conf(struct p2p_data *p2p, const u8 *sa, 1124 const u8 *data, size_t len) 1125 { 1126 struct p2p_device *dev; 1127 struct p2p_message msg; 1128 1129 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1130 "P2P: Received GO Negotiation Confirm from " MACSTR, 1131 MAC2STR(sa)); 1132 dev = p2p_get_device(p2p, sa); 1133 if (dev == NULL || dev->wps_method == WPS_NOT_READY || 1134 dev != p2p->go_neg_peer) { 1135 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1136 "P2P: Not ready for GO negotiation with " MACSTR, 1137 MAC2STR(sa)); 1138 return; 1139 } 1140 1141 if (p2p->pending_action_state == P2P_PENDING_GO_NEG_RESPONSE) { 1142 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Stopped waiting " 1143 "for TX status on GO Negotiation Response since we " 1144 "already received Confirmation"); 1145 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 1146 } 1147 1148 if (p2p_parse(data, len, &msg)) 1149 return; 1150 1151 if (!(dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { 1152 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1153 "P2P: Was not expecting GO Negotiation Confirm - " 1154 "ignore"); 1155 return; 1156 } 1157 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; 1158 1159 if (msg.dialog_token != dev->dialog_token) { 1160 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1161 "P2P: Unexpected Dialog Token %u (expected %u)", 1162 msg.dialog_token, dev->dialog_token); 1163 p2p_parse_free(&msg); 1164 return; 1165 } 1166 1167 if (!msg.status) { 1168 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1169 "P2P: No Status attribute received"); 1170 p2p_parse_free(&msg); 1171 return; 1172 } 1173 if (*msg.status) { 1174 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1175 "P2P: GO Negotiation rejected: status %d", 1176 *msg.status); 1177 p2p_parse_free(&msg); 1178 return; 1179 } 1180 1181 if (dev->go_state == REMOTE_GO && msg.group_id) { 1182 /* Store SSID for Provisioning step */ 1183 p2p->ssid_len = msg.group_id_len - ETH_ALEN; 1184 os_memcpy(p2p->ssid, msg.group_id + ETH_ALEN, p2p->ssid_len); 1185 } else if (dev->go_state == REMOTE_GO) { 1186 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1187 "P2P: Mandatory P2P Group ID attribute missing from " 1188 "GO Negotiation Confirmation"); 1189 p2p->ssid_len = 0; 1190 #ifdef CONFIG_P2P_STRICT 1191 p2p_parse_free(&msg); 1192 return; 1193 #endif /* CONFIG_P2P_STRICT */ 1194 } 1195 1196 if (!msg.operating_channel) { 1197 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1198 "P2P: Mandatory Operating Channel attribute missing " 1199 "from GO Negotiation Confirmation"); 1200 #ifdef CONFIG_P2P_STRICT 1201 p2p_parse_free(&msg); 1202 return; 1203 #endif /* CONFIG_P2P_STRICT */ 1204 } 1205 1206 if (!msg.channel_list) { 1207 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1208 "P2P: Mandatory Operating Channel attribute missing " 1209 "from GO Negotiation Confirmation"); 1210 #ifdef CONFIG_P2P_STRICT 1211 p2p_parse_free(&msg); 1212 return; 1213 #endif /* CONFIG_P2P_STRICT */ 1214 } 1215 1216 p2p_parse_free(&msg); 1217 1218 if (dev->go_state == UNKNOWN_GO) { 1219 /* 1220 * This should not happen since GO negotiation has already 1221 * been completed. 1222 */ 1223 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1224 "P2P: Unexpected GO Neg state - do not know which end " 1225 "becomes GO"); 1226 return; 1227 } 1228 1229 /* 1230 * The peer could have missed our ctrl::ack frame for GO Negotiation 1231 * Confirm and continue retransmitting the frame. To reduce the 1232 * likelihood of the peer not getting successful TX status for the 1233 * GO Negotiation Confirm frame, wait a short time here before starting 1234 * the group so that we will remain on the current channel to 1235 * acknowledge any possible retransmission from the peer. 1236 */ 1237 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: 20 ms wait on current " 1238 "channel before starting group"); 1239 os_sleep(0, 20000); 1240 1241 p2p_go_complete(p2p, dev); 1242 } 1243