p2p.c revision 4b06059785b935dd1f4f09314e4e12c417d2c6a4
1/* 2 * Wi-Fi Direct - P2P module 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 "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_i.h" 17#include "p2p_i.h" 18#include "p2p.h" 19 20 21static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx); 22static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev); 23static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da, 24 const u8 *sa, const u8 *data, size_t len, 25 int rx_freq); 26static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da, 27 const u8 *sa, const u8 *data, 28 size_t len); 29static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx); 30static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx); 31 32 33/* 34 * p2p_scan recovery timeout 35 * 36 * Many drivers are using 30 second timeout on scan results. Allow a bit larger 37 * timeout for this to avoid hitting P2P timeout unnecessarily. 38 */ 39#define P2P_SCAN_TIMEOUT 35 40 41/** 42 * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer 43 * entries will be removed 44 */ 45#ifdef ANDROID_P2P 46#define P2P_PEER_EXPIRATION_AGE 30 47#else 48#define P2P_PEER_EXPIRATION_AGE 300 49#endif 50 51#define P2P_PEER_EXPIRATION_INTERVAL (P2P_PEER_EXPIRATION_AGE / 2) 52 53#ifdef ANDROID_P2P 54int p2p_connection_in_progress(struct p2p_data *p2p) 55{ 56 int ret = 0; 57 58 switch (p2p->state) { 59 case P2P_CONNECT: 60 case P2P_CONNECT_LISTEN: 61 case P2P_GO_NEG: 62 case P2P_WAIT_PEER_CONNECT: 63 case P2P_WAIT_PEER_IDLE: 64 case P2P_PROVISIONING: 65 case P2P_INVITE: 66 case P2P_INVITE_LISTEN: 67 ret = 1; 68 break; 69 70 default: 71 wpa_printf(MSG_DEBUG, "p2p_connection_in_progress state %d", p2p->state); 72 ret = 0; 73 } 74 75 return ret; 76} 77#endif 78 79static void p2p_expire_peers(struct p2p_data *p2p) 80{ 81 struct p2p_device *dev, *n; 82 struct os_time now; 83 size_t i; 84 85 os_get_time(&now); 86 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) { 87 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec) 88 continue; 89 90 if (p2p->cfg->go_connected && 91 p2p->cfg->go_connected(p2p->cfg->cb_ctx, 92 dev->info.p2p_device_addr)) { 93 /* 94 * We are connected as a client to a group in which the 95 * peer is the GO, so do not expire the peer entry. 96 */ 97 os_get_time(&dev->last_seen); 98 continue; 99 } 100 101 for (i = 0; i < p2p->num_groups; i++) { 102 if (p2p_group_is_client_connected( 103 p2p->groups[i], dev->info.p2p_device_addr)) 104 break; 105 } 106 if (i < p2p->num_groups) { 107 /* 108 * The peer is connected as a client in a group where 109 * we are the GO, so do not expire the peer entry. 110 */ 111 os_get_time(&dev->last_seen); 112 continue; 113 } 114 115#ifdef ANDROID_P2P 116 /* If Connection is in progress, don't expire the peer 117 */ 118 if (p2p_connection_in_progress(p2p)) 119 continue; 120#endif 121 122 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Expiring old peer " 123 "entry " MACSTR, MAC2STR(dev->info.p2p_device_addr)); 124#ifdef ANDROID_P2P 125 /* SD_FAIR_POLICY: Update the current sd_dev_list pointer to next device */ 126 if(&dev->list == p2p->sd_dev_list) 127 p2p->sd_dev_list = dev->list.next; 128#endif 129 dl_list_del(&dev->list); 130 p2p_device_free(p2p, dev); 131 } 132} 133 134 135static void p2p_expiration_timeout(void *eloop_ctx, void *timeout_ctx) 136{ 137 struct p2p_data *p2p = eloop_ctx; 138 p2p_expire_peers(p2p); 139 eloop_register_timeout(P2P_PEER_EXPIRATION_INTERVAL, 0, 140 p2p_expiration_timeout, p2p, NULL); 141} 142 143 144static const char * p2p_state_txt(int state) 145{ 146 switch (state) { 147 case P2P_IDLE: 148 return "IDLE"; 149 case P2P_SEARCH: 150 return "SEARCH"; 151 case P2P_CONNECT: 152 return "CONNECT"; 153 case P2P_CONNECT_LISTEN: 154 return "CONNECT_LISTEN"; 155 case P2P_GO_NEG: 156 return "GO_NEG"; 157 case P2P_LISTEN_ONLY: 158 return "LISTEN_ONLY"; 159 case P2P_WAIT_PEER_CONNECT: 160 return "WAIT_PEER_CONNECT"; 161 case P2P_WAIT_PEER_IDLE: 162 return "WAIT_PEER_IDLE"; 163 case P2P_SD_DURING_FIND: 164 return "SD_DURING_FIND"; 165 case P2P_PROVISIONING: 166 return "PROVISIONING"; 167 case P2P_PD_DURING_FIND: 168 return "PD_DURING_FIND"; 169 case P2P_INVITE: 170 return "INVITE"; 171 case P2P_INVITE_LISTEN: 172 return "INVITE_LISTEN"; 173 case P2P_SEARCH_WHEN_READY: 174 return "SEARCH_WHEN_READY"; 175 case P2P_CONTINUE_SEARCH_WHEN_READY: 176 return "CONTINUE_SEARCH_WHEN_READY"; 177 default: 178 return "?"; 179 } 180} 181 182 183u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr) 184{ 185 struct p2p_device *dev = NULL; 186 187 if (!addr || !p2p) 188 return 0; 189 190 dev = p2p_get_device(p2p, addr); 191 if (dev) 192 return dev->wps_prov_info; 193 else 194 return 0; 195} 196 197 198void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr) 199{ 200 struct p2p_device *dev = NULL; 201 202 if (!addr || !p2p) 203 return; 204 205 dev = p2p_get_device(p2p, addr); 206 if (dev) 207 dev->wps_prov_info = 0; 208} 209 210 211void p2p_set_state(struct p2p_data *p2p, int new_state) 212{ 213 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: State %s -> %s", 214 p2p_state_txt(p2p->state), p2p_state_txt(new_state)); 215 p2p->state = new_state; 216} 217 218 219void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec) 220{ 221 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 222 "P2P: Set timeout (state=%s): %u.%06u sec", 223 p2p_state_txt(p2p->state), sec, usec); 224 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL); 225 eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL); 226} 227 228 229void p2p_clear_timeout(struct p2p_data *p2p) 230{ 231 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Clear timeout (state=%s)", 232 p2p_state_txt(p2p->state)); 233 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL); 234} 235 236 237void p2p_go_neg_failed(struct p2p_data *p2p, struct p2p_device *peer, 238 int status) 239{ 240 struct p2p_go_neg_results res; 241 p2p_clear_timeout(p2p); 242 p2p_set_state(p2p, P2P_IDLE); 243 if (p2p->go_neg_peer) { 244 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; 245 p2p->go_neg_peer->wps_method = WPS_NOT_READY; 246 } 247 p2p->go_neg_peer = NULL; 248 249 os_memset(&res, 0, sizeof(res)); 250 res.status = status; 251 if (peer) { 252 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, 253 ETH_ALEN); 254 os_memcpy(res.peer_interface_addr, peer->intended_addr, 255 ETH_ALEN); 256 } 257 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res); 258} 259 260 261static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc) 262{ 263 unsigned int r, tu; 264 int freq; 265 struct wpabuf *ies; 266 267 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 268 "P2P: Starting short listen state (state=%s)", 269 p2p_state_txt(p2p->state)); 270 271 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel); 272 if (freq < 0) { 273 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 274 "P2P: Unknown regulatory class/channel"); 275 return; 276 } 277 278 os_get_random((u8 *) &r, sizeof(r)); 279 tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) + 280 p2p->min_disc_int) * 100; 281 if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu) 282 tu = p2p->max_disc_tu; 283 if (!dev_disc && tu < 100) 284 tu = 100; /* Need to wait in non-device discovery use cases */ 285 if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen) 286 tu = p2p->cfg->max_listen * 1000 / 1024; 287 288 if (tu == 0) { 289 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip listen state " 290 "since duration was 0 TU"); 291 p2p_set_timeout(p2p, 0, 0); 292 return; 293 } 294 295 p2p->pending_listen_freq = freq; 296 p2p->pending_listen_sec = 0; 297 p2p->pending_listen_usec = 1024 * tu; 298 299 ies = p2p_build_probe_resp_ies(p2p); 300 if (ies == NULL) 301 return; 302 303 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000, 304 ies) < 0) { 305 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 306 "P2P: Failed to start listen mode"); 307 p2p->pending_listen_freq = 0; 308 } 309 wpabuf_free(ies); 310} 311 312 313int p2p_listen(struct p2p_data *p2p, unsigned int timeout) 314{ 315 int freq; 316 struct wpabuf *ies; 317 318 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 319 "P2P: Going to listen(only) state"); 320 321 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel); 322 if (freq < 0) { 323 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 324 "P2P: Unknown regulatory class/channel"); 325 return -1; 326 } 327 328 p2p->pending_listen_freq = freq; 329 p2p->pending_listen_sec = timeout / 1000; 330 p2p->pending_listen_usec = (timeout % 1000) * 1000; 331 332 if (p2p->p2p_scan_running) { 333 if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) { 334 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 335 "P2P: p2p_scan running - connect is already " 336 "pending - skip listen"); 337 return 0; 338 } 339 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 340 "P2P: p2p_scan running - delay start of listen state"); 341 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN; 342 return 0; 343 } 344 345 ies = p2p_build_probe_resp_ies(p2p); 346 if (ies == NULL) 347 return -1; 348 349 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) { 350 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 351 "P2P: Failed to start listen mode"); 352 p2p->pending_listen_freq = 0; 353 wpabuf_free(ies); 354 return -1; 355 } 356 wpabuf_free(ies); 357 358 p2p_set_state(p2p, P2P_LISTEN_ONLY); 359 360 return 0; 361} 362 363 364static void p2p_device_clear_reported(struct p2p_data *p2p) 365{ 366 struct p2p_device *dev; 367 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) 368 dev->flags &= ~P2P_DEV_REPORTED; 369} 370 371 372/** 373 * p2p_get_device - Fetch a peer entry 374 * @p2p: P2P module context from p2p_init() 375 * @addr: P2P Device Address of the peer 376 * Returns: Pointer to the device entry or %NULL if not found 377 */ 378struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr) 379{ 380 struct p2p_device *dev; 381 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 382 if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0) 383 return dev; 384 } 385 return NULL; 386} 387 388 389/** 390 * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address 391 * @p2p: P2P module context from p2p_init() 392 * @addr: P2P Interface Address of the peer 393 * Returns: Pointer to the device entry or %NULL if not found 394 */ 395struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p, 396 const u8 *addr) 397{ 398 struct p2p_device *dev; 399 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 400 if (os_memcmp(dev->interface_addr, addr, ETH_ALEN) == 0) 401 return dev; 402 } 403 return NULL; 404} 405 406 407/** 408 * p2p_create_device - Create a peer entry 409 * @p2p: P2P module context from p2p_init() 410 * @addr: P2P Device Address of the peer 411 * Returns: Pointer to the device entry or %NULL on failure 412 * 413 * If there is already an entry for the peer, it will be returned instead of 414 * creating a new one. 415 */ 416static struct p2p_device * p2p_create_device(struct p2p_data *p2p, 417 const u8 *addr) 418{ 419 struct p2p_device *dev, *oldest = NULL; 420 size_t count = 0; 421 422 dev = p2p_get_device(p2p, addr); 423 if (dev) 424 return dev; 425 426 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 427 count++; 428 if (oldest == NULL || 429 os_time_before(&dev->last_seen, &oldest->last_seen)) 430 oldest = dev; 431 } 432 if (count + 1 > p2p->cfg->max_peers && oldest) { 433 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 434 "P2P: Remove oldest peer entry to make room for a new " 435 "peer"); 436#ifdef ANDROID_P2P 437 /* SD_FAIR_POLICY: Update the current sd_dev_list pointer to next device */ 438 if(&oldest->list == p2p->sd_dev_list) 439 p2p->sd_dev_list = oldest->list.next; 440#endif 441 dl_list_del(&oldest->list); 442 p2p_device_free(p2p, oldest); 443 } 444 445 dev = os_zalloc(sizeof(*dev)); 446 if (dev == NULL) 447 return NULL; 448 dl_list_add(&p2p->devices, &dev->list); 449 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN); 450 451 return dev; 452} 453 454 455static void p2p_copy_client_info(struct p2p_device *dev, 456 struct p2p_client_info *cli) 457{ 458 os_memcpy(dev->info.device_name, cli->dev_name, cli->dev_name_len); 459 dev->info.device_name[cli->dev_name_len] = '\0'; 460 dev->info.dev_capab = cli->dev_capab; 461 dev->info.config_methods = cli->config_methods; 462 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8); 463 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types; 464 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types, 465 dev->info.wps_sec_dev_type_list_len); 466} 467 468 469static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr, 470 const u8 *go_interface_addr, int freq, 471 const u8 *gi, size_t gi_len) 472{ 473 struct p2p_group_info info; 474 size_t c; 475 struct p2p_device *dev; 476 477 if (gi == NULL) 478 return 0; 479 480 if (p2p_group_info_parse(gi, gi_len, &info) < 0) 481 return -1; 482 483 /* 484 * Clear old data for this group; if the devices are still in the 485 * group, the information will be restored in the loop following this. 486 */ 487 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 488 if (os_memcmp(dev->member_in_go_iface, go_interface_addr, 489 ETH_ALEN) == 0) { 490 os_memset(dev->member_in_go_iface, 0, ETH_ALEN); 491 os_memset(dev->member_in_go_dev, 0, ETH_ALEN); 492 } 493 } 494 495 for (c = 0; c < info.num_clients; c++) { 496 struct p2p_client_info *cli = &info.client[c]; 497 if (os_memcmp(cli->p2p_device_addr, p2p->cfg->dev_addr, 498 ETH_ALEN) == 0) 499 continue; /* ignore our own entry */ 500 dev = p2p_get_device(p2p, cli->p2p_device_addr); 501 if (dev) { 502 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY | 503 P2P_DEV_PROBE_REQ_ONLY)) { 504 /* 505 * Update information since we have not 506 * received this directly from the client. 507 */ 508 p2p_copy_client_info(dev, cli); 509 } else { 510 /* 511 * Need to update P2P Client Discoverability 512 * flag since it is valid only in P2P Group 513 * Info attribute. 514 */ 515 dev->info.dev_capab &= 516 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 517 dev->info.dev_capab |= 518 cli->dev_capab & 519 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 520 } 521 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { 522 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY; 523 } 524 } else { 525 dev = p2p_create_device(p2p, cli->p2p_device_addr); 526 if (dev == NULL) 527 continue; 528 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY; 529 p2p_copy_client_info(dev, cli); 530 dev->oper_freq = freq; 531 p2p->cfg->dev_found(p2p->cfg->cb_ctx, 532 dev->info.p2p_device_addr, 533 &dev->info, 1); 534 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 535 } 536 537 os_memcpy(dev->interface_addr, cli->p2p_interface_addr, 538 ETH_ALEN); 539 os_get_time(&dev->last_seen); 540 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN); 541 os_memcpy(dev->member_in_go_iface, go_interface_addr, 542 ETH_ALEN); 543 } 544 545 return 0; 546} 547 548 549static void p2p_copy_wps_info(struct p2p_device *dev, int probe_req, 550 const struct p2p_message *msg) 551{ 552 os_memcpy(dev->info.device_name, msg->device_name, 553 sizeof(dev->info.device_name)); 554 555 if (msg->manufacturer && 556 msg->manufacturer_len < sizeof(dev->info.manufacturer)) { 557 os_memset(dev->info.manufacturer, 0, 558 sizeof(dev->info.manufacturer)); 559 os_memcpy(dev->info.manufacturer, msg->manufacturer, 560 msg->manufacturer_len); 561 } 562 563 if (msg->model_name && 564 msg->model_name_len < sizeof(dev->info.model_name)) { 565 os_memset(dev->info.model_name, 0, 566 sizeof(dev->info.model_name)); 567 os_memcpy(dev->info.model_name, msg->model_name, 568 msg->model_name_len); 569 } 570 571 if (msg->model_number && 572 msg->model_number_len < sizeof(dev->info.model_number)) { 573 os_memset(dev->info.model_number, 0, 574 sizeof(dev->info.model_number)); 575 os_memcpy(dev->info.model_number, msg->model_number, 576 msg->model_number_len); 577 } 578 579 if (msg->serial_number && 580 msg->serial_number_len < sizeof(dev->info.serial_number)) { 581 os_memset(dev->info.serial_number, 0, 582 sizeof(dev->info.serial_number)); 583 os_memcpy(dev->info.serial_number, msg->serial_number, 584 msg->serial_number_len); 585 } 586 587 if (msg->pri_dev_type) 588 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type, 589 sizeof(dev->info.pri_dev_type)); 590 else if (msg->wps_pri_dev_type) 591 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type, 592 sizeof(dev->info.pri_dev_type)); 593 594 if (msg->wps_sec_dev_type_list) { 595 os_memcpy(dev->info.wps_sec_dev_type_list, 596 msg->wps_sec_dev_type_list, 597 msg->wps_sec_dev_type_list_len); 598 dev->info.wps_sec_dev_type_list_len = 599 msg->wps_sec_dev_type_list_len; 600 } 601 602 if (msg->capability) { 603 /* 604 * P2P Client Discoverability bit is reserved in all frames 605 * that use this function, so do not change its value here. 606 */ 607 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 608 dev->info.dev_capab |= msg->capability[0] & 609 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 610 dev->info.group_capab = msg->capability[1]; 611 } 612 613 if (msg->ext_listen_timing) { 614 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing); 615 dev->ext_listen_interval = 616 WPA_GET_LE16(msg->ext_listen_timing + 2); 617 } 618 619 if (!probe_req) { 620 u16 new_config_methods; 621 new_config_methods = msg->config_methods ? 622 msg->config_methods : msg->wps_config_methods; 623 if (new_config_methods && 624 dev->info.config_methods != new_config_methods) { 625 wpa_printf(MSG_DEBUG, "P2P: Update peer " MACSTR 626 " config_methods 0x%x -> 0x%x", 627 MAC2STR(dev->info.p2p_device_addr), 628 dev->info.config_methods, 629 new_config_methods); 630 dev->info.config_methods = new_config_methods; 631 } 632 } 633} 634 635 636/** 637 * p2p_add_device - Add peer entries based on scan results or P2P frames 638 * @p2p: P2P module context from p2p_init() 639 * @addr: Source address of Beacon or Probe Response frame (may be either 640 * P2P Device Address or P2P Interface Address) 641 * @level: Signal level (signal strength of the received frame from the peer) 642 * @freq: Frequency on which the Beacon or Probe Response frame was received 643 * @rx_time: Time when the result was received 644 * @ies: IEs from the Beacon or Probe Response frame 645 * @ies_len: Length of ies buffer in octets 646 * @scan_res: Whether this was based on scan results 647 * Returns: 0 on success, -1 on failure 648 * 649 * If the scan result is for a GO, the clients in the group will also be added 650 * to the peer table. This function can also be used with some other frames 651 * like Provision Discovery Request that contains P2P Capability and P2P Device 652 * Info attributes. 653 */ 654int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq, 655 struct os_time *rx_time, int level, const u8 *ies, 656 size_t ies_len, int scan_res) 657{ 658 struct p2p_device *dev; 659 struct p2p_message msg; 660 const u8 *p2p_dev_addr; 661 int i; 662 struct os_time time_now; 663 664 os_memset(&msg, 0, sizeof(msg)); 665 if (p2p_parse_ies(ies, ies_len, &msg)) { 666 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 667 "P2P: Failed to parse P2P IE for a device entry"); 668 p2p_parse_free(&msg); 669 return -1; 670 } 671 672 if (msg.p2p_device_addr) 673 p2p_dev_addr = msg.p2p_device_addr; 674 else if (msg.device_id) 675 p2p_dev_addr = msg.device_id; 676 else { 677 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 678 "P2P: Ignore scan data without P2P Device Info or " 679 "P2P Device Id"); 680 p2p_parse_free(&msg); 681 return -1; 682 } 683 684 if (!is_zero_ether_addr(p2p->peer_filter) && 685 os_memcmp(p2p_dev_addr, p2p->peer_filter, ETH_ALEN) != 0) { 686 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Do not add peer " 687 "filter for " MACSTR " due to peer filter", 688 MAC2STR(p2p_dev_addr)); 689 p2p_parse_free(&msg); 690 return 0; 691 } 692 693 dev = p2p_create_device(p2p, p2p_dev_addr); 694 if (dev == NULL) { 695 p2p_parse_free(&msg); 696 return -1; 697 } 698 699 if (rx_time == NULL) { 700 os_get_time(&time_now); 701 rx_time = &time_now; 702 } 703 704 /* 705 * Update the device entry only if the new peer 706 * entry is newer than the one previously stored. 707 */ 708 if (dev->last_seen.sec > 0 && 709 os_time_before(rx_time, &dev->last_seen)) { 710 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Do not update peer " 711 "entry based on old frame (rx_time=%u.%06u " 712 "last_seen=%u.%06u)", 713 (unsigned int) rx_time->sec, 714 (unsigned int) rx_time->usec, 715 (unsigned int) dev->last_seen.sec, 716 (unsigned int) dev->last_seen.usec); 717 p2p_parse_free(&msg); 718 return -1; 719 } 720 721 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_time)); 722 723 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY); 724 725 if (os_memcmp(addr, p2p_dev_addr, ETH_ALEN) != 0) 726 os_memcpy(dev->interface_addr, addr, ETH_ALEN); 727 if (msg.ssid && 728 (msg.ssid[1] != P2P_WILDCARD_SSID_LEN || 729 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) 730 != 0)) { 731 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]); 732 dev->oper_ssid_len = msg.ssid[1]; 733 } 734 735 if (freq >= 2412 && freq <= 2484 && msg.ds_params && 736 *msg.ds_params >= 1 && *msg.ds_params <= 14) { 737 int ds_freq; 738 if (*msg.ds_params == 14) 739 ds_freq = 2484; 740 else 741 ds_freq = 2407 + *msg.ds_params * 5; 742 if (freq != ds_freq) { 743 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 744 "P2P: Update Listen frequency based on DS " 745 "Parameter Set IE: %d -> %d MHz", 746 freq, ds_freq); 747 freq = ds_freq; 748 } 749 } 750 751 if (dev->listen_freq && dev->listen_freq != freq && scan_res) { 752 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 753 "P2P: Update Listen frequency based on scan " 754 "results (" MACSTR " %d -> %d MHz (DS param %d)", 755 MAC2STR(dev->info.p2p_device_addr), dev->listen_freq, 756 freq, msg.ds_params ? *msg.ds_params : -1); 757 } 758 if (scan_res) { 759 dev->listen_freq = freq; 760 if (msg.group_info) 761 dev->oper_freq = freq; 762 } 763 dev->info.level = level; 764 765 p2p_copy_wps_info(dev, 0, &msg); 766 767 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 768 wpabuf_free(dev->info.wps_vendor_ext[i]); 769 dev->info.wps_vendor_ext[i] = NULL; 770 } 771 772 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 773 if (msg.wps_vendor_ext[i] == NULL) 774 break; 775 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy( 776 msg.wps_vendor_ext[i], msg.wps_vendor_ext_len[i]); 777 if (dev->info.wps_vendor_ext[i] == NULL) 778 break; 779 } 780 781 if (msg.wfd_subelems) { 782 wpabuf_free(dev->info.wfd_subelems); 783 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems); 784 } 785 786 if (scan_res) { 787 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq, 788 msg.group_info, msg.group_info_len); 789 } 790 791 p2p_parse_free(&msg); 792 793 if (p2p_pending_sd_req(p2p, dev)) 794 dev->flags |= P2P_DEV_SD_SCHEDULE; 795 796 if (dev->flags & P2P_DEV_REPORTED) 797 return 0; 798 799 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 800 "P2P: Peer found with Listen frequency %d MHz " 801 "(rx_time=%u.%06u)", freq, (unsigned int) rx_time->sec, 802 (unsigned int) rx_time->usec); 803 if (dev->flags & P2P_DEV_USER_REJECTED) { 804 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 805 "P2P: Do not report rejected device"); 806 return 0; 807 } 808 809 if (dev->info.config_methods == 0 && 810 (freq == 2412 || freq == 2437 || freq == 2462)) { 811 /* 812 * If we have only seen a Beacon frame from a GO, we do not yet 813 * know what WPS config methods it supports. Since some 814 * applications use config_methods value from P2P-DEVICE-FOUND 815 * events, postpone reporting this peer until we've fully 816 * discovered its capabilities. 817 * 818 * At least for now, do this only if the peer was detected on 819 * one of the social channels since that peer can be easily be 820 * found again and there are no limitations of having to use 821 * passive scan on this channels, so this can be done through 822 * Probe Response frame that includes the config_methods 823 * information. 824 */ 825 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 826 "P2P: Do not report peer " MACSTR " with unknown " 827 "config methods", MAC2STR(addr)); 828 return 0; 829 } 830 831 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info, 832 !(dev->flags & P2P_DEV_REPORTED_ONCE)); 833 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 834 835 return 0; 836} 837 838 839static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev) 840{ 841 int i; 842 843 if (p2p->go_neg_peer == dev) { 844 /* 845 * If GO Negotiation is in progress, report that it has failed. 846 */ 847 p2p_go_neg_failed(p2p, dev, -1); 848 p2p->go_neg_peer = NULL; 849 } 850 if (p2p->invite_peer == dev) 851 p2p->invite_peer = NULL; 852 if (p2p->sd_peer == dev) 853 p2p->sd_peer = NULL; 854 if (p2p->pending_client_disc_go == dev) 855 p2p->pending_client_disc_go = NULL; 856 857 /* dev_lost() device, but only if it was previously dev_found() */ 858 if (dev->flags & P2P_DEV_REPORTED_ONCE) 859 p2p->cfg->dev_lost(p2p->cfg->cb_ctx, 860 dev->info.p2p_device_addr); 861 862 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 863 wpabuf_free(dev->info.wps_vendor_ext[i]); 864 dev->info.wps_vendor_ext[i] = NULL; 865 } 866 867 wpabuf_free(dev->info.wfd_subelems); 868 869 os_free(dev); 870} 871 872 873static int p2p_get_next_prog_freq(struct p2p_data *p2p) 874{ 875 struct p2p_channels *c; 876 struct p2p_reg_class *cla; 877 size_t cl, ch; 878 int found = 0; 879 u8 reg_class; 880 u8 channel; 881 int freq; 882 883 c = &p2p->cfg->channels; 884 for (cl = 0; cl < c->reg_classes; cl++) { 885 cla = &c->reg_class[cl]; 886 if (cla->reg_class != p2p->last_prog_scan_class) 887 continue; 888 for (ch = 0; ch < cla->channels; ch++) { 889 if (cla->channel[ch] == p2p->last_prog_scan_chan) { 890 found = 1; 891 break; 892 } 893 } 894 if (found) 895 break; 896 } 897 898 if (!found) { 899 /* Start from beginning */ 900 reg_class = c->reg_class[0].reg_class; 901 channel = c->reg_class[0].channel[0]; 902 } else { 903 /* Pick the next channel */ 904 ch++; 905 if (ch == cla->channels) { 906 cl++; 907 if (cl == c->reg_classes) 908 cl = 0; 909 ch = 0; 910 } 911 reg_class = c->reg_class[cl].reg_class; 912 channel = c->reg_class[cl].channel[ch]; 913 } 914 915 freq = p2p_channel_to_freq(reg_class, channel); 916 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Next progressive search " 917 "channel: reg_class %u channel %u -> %d MHz", 918 reg_class, channel, freq); 919 p2p->last_prog_scan_class = reg_class; 920 p2p->last_prog_scan_chan = channel; 921 922 if (freq == 2412 || freq == 2437 || freq == 2462) 923 return 0; /* No need to add social channels */ 924 return freq; 925} 926 927 928static void p2p_search(struct p2p_data *p2p) 929{ 930 int freq = 0; 931 enum p2p_scan_type type; 932 u16 pw_id = DEV_PW_DEFAULT; 933 int res; 934 935 if (p2p->drv_in_listen) { 936 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver is still " 937 "in Listen state - wait for it to end before " 938 "continuing"); 939 return; 940 } 941 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 942 943 if (p2p->find_type == P2P_FIND_PROGRESSIVE && 944 (freq = p2p_get_next_prog_freq(p2p)) > 0) { 945 type = P2P_SCAN_SOCIAL_PLUS_ONE; 946 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search " 947 "(+ freq %u)", freq); 948 } else { 949 type = P2P_SCAN_SOCIAL; 950 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting search"); 951 } 952 953 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq, 954 p2p->num_req_dev_types, p2p->req_dev_types, 955 p2p->find_dev_id, pw_id); 956 if (res < 0) { 957 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 958 "P2P: Scan request failed"); 959 p2p_continue_find(p2p); 960 } else if (res == 1) { 961 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Could not start " 962 "p2p_scan at this point - will try again after " 963 "previous scan completes"); 964 p2p_set_state(p2p, P2P_CONTINUE_SEARCH_WHEN_READY); 965 } else { 966 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Running p2p_scan"); 967 p2p->p2p_scan_running = 1; 968 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 969 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout, 970 p2p, NULL); 971 } 972} 973 974 975static void p2p_find_timeout(void *eloop_ctx, void *timeout_ctx) 976{ 977 struct p2p_data *p2p = eloop_ctx; 978 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Find timeout -> stop"); 979 p2p_stop_find(p2p); 980} 981 982 983static int p2p_run_after_scan(struct p2p_data *p2p) 984{ 985 struct p2p_device *dev; 986 enum p2p_after_scan op; 987 988 if (p2p->after_scan_tx) { 989 p2p->after_scan_tx_in_progress = 1; 990 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send pending " 991 "Action frame at p2p_scan completion"); 992 p2p->cfg->send_action(p2p->cfg->cb_ctx, 993 p2p->after_scan_tx->freq, 994 p2p->after_scan_tx->dst, 995 p2p->after_scan_tx->src, 996 p2p->after_scan_tx->bssid, 997 (u8 *) (p2p->after_scan_tx + 1), 998 p2p->after_scan_tx->len, 999 p2p->after_scan_tx->wait_time); 1000 os_free(p2p->after_scan_tx); 1001 p2p->after_scan_tx = NULL; 1002#ifdef ANDROID_P2P 1003 /* For SD frames, there is a scenario, where we can receive a SD request frame during p2p_scan. 1004 * At that moment, we will send the SD response from this context. After sending the SD response, 1005 * we need to continue p2p_find. But if we return 1 from here, p2p_find is going to be stopped. 1006 */ 1007 return 0; 1008#else 1009 return 1; 1010#endif 1011 } 1012 1013 op = p2p->start_after_scan; 1014 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1015 switch (op) { 1016 case P2P_AFTER_SCAN_NOTHING: 1017 break; 1018 case P2P_AFTER_SCAN_LISTEN: 1019 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Start previously " 1020 "requested Listen state"); 1021 p2p_listen(p2p, p2p->pending_listen_sec * 1000 + 1022 p2p->pending_listen_usec / 1000); 1023 return 1; 1024 case P2P_AFTER_SCAN_CONNECT: 1025 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Start previously " 1026 "requested connect with " MACSTR, 1027 MAC2STR(p2p->after_scan_peer)); 1028 dev = p2p_get_device(p2p, p2p->after_scan_peer); 1029 if (dev == NULL) { 1030 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer not " 1031 "known anymore"); 1032 break; 1033 } 1034 p2p_connect_send(p2p, dev); 1035 return 1; 1036 } 1037 1038 return 0; 1039} 1040 1041 1042static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx) 1043{ 1044 struct p2p_data *p2p = eloop_ctx; 1045 int running; 1046 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan timeout " 1047 "(running=%d)", p2p->p2p_scan_running); 1048 running = p2p->p2p_scan_running; 1049 /* Make sure we recover from missed scan results callback */ 1050 p2p->p2p_scan_running = 0; 1051 1052 if (running) 1053 p2p_run_after_scan(p2p); 1054} 1055 1056 1057static void p2p_free_req_dev_types(struct p2p_data *p2p) 1058{ 1059 p2p->num_req_dev_types = 0; 1060 os_free(p2p->req_dev_types); 1061 p2p->req_dev_types = NULL; 1062} 1063 1064 1065int p2p_find(struct p2p_data *p2p, unsigned int timeout, 1066 enum p2p_discovery_type type, 1067 unsigned int num_req_dev_types, const u8 *req_dev_types, 1068 const u8 *dev_id, unsigned int search_delay) 1069{ 1070 int res; 1071 1072 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting find (type=%d)", 1073 type); 1074 os_get_time(&p2p->find_start); 1075 if (p2p->p2p_scan_running) { 1076 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan is " 1077 "already running"); 1078 } 1079 1080 p2p_free_req_dev_types(p2p); 1081 if (req_dev_types && num_req_dev_types) { 1082 p2p->req_dev_types = os_malloc(num_req_dev_types * 1083 WPS_DEV_TYPE_LEN); 1084 if (p2p->req_dev_types == NULL) 1085 return -1; 1086 os_memcpy(p2p->req_dev_types, req_dev_types, 1087 num_req_dev_types * WPS_DEV_TYPE_LEN); 1088 p2p->num_req_dev_types = num_req_dev_types; 1089 } 1090 1091 if (dev_id) { 1092 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN); 1093 p2p->find_dev_id = p2p->find_dev_id_buf; 1094 } else 1095 p2p->find_dev_id = NULL; 1096 1097 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1098 p2p_clear_timeout(p2p); 1099 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1100 p2p->find_type = type; 1101 p2p_device_clear_reported(p2p); 1102 p2p_set_state(p2p, P2P_SEARCH); 1103 p2p->search_delay = search_delay; 1104 p2p->in_search_delay = 0; 1105 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1106 p2p->last_p2p_find_timeout = timeout; 1107 if (timeout) 1108 eloop_register_timeout(timeout, 0, p2p_find_timeout, 1109 p2p, NULL); 1110 switch (type) { 1111 case P2P_FIND_START_WITH_FULL: 1112 case P2P_FIND_PROGRESSIVE: 1113 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0, 1114 p2p->num_req_dev_types, 1115 p2p->req_dev_types, dev_id, 1116 DEV_PW_DEFAULT); 1117 break; 1118 case P2P_FIND_ONLY_SOCIAL: 1119 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0, 1120 p2p->num_req_dev_types, 1121 p2p->req_dev_types, dev_id, 1122 DEV_PW_DEFAULT); 1123 break; 1124 default: 1125 return -1; 1126 } 1127 1128 if (res == 0) { 1129 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Running p2p_scan"); 1130 p2p->p2p_scan_running = 1; 1131 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 1132 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout, 1133 p2p, NULL); 1134 } else if (res == 1) { 1135 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Could not start " 1136 "p2p_scan at this point - will try again after " 1137 "previous scan completes"); 1138 res = 0; 1139 p2p_set_state(p2p, P2P_SEARCH_WHEN_READY); 1140 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1141 } else { 1142 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Failed to start " 1143 "p2p_scan"); 1144 p2p_set_state(p2p, P2P_IDLE); 1145 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1146 } 1147 1148 return res; 1149} 1150 1151#ifdef ANDROID_P2P 1152int p2p_search_pending(struct p2p_data *p2p) 1153{ 1154 if(p2p == NULL) 1155 return 0; 1156 1157 if(p2p->state == P2P_SEARCH_WHEN_READY) 1158 return 1; 1159 1160 return 0; 1161} 1162#endif 1163 1164int p2p_other_scan_completed(struct p2p_data *p2p) 1165{ 1166 if (p2p->state == P2P_CONTINUE_SEARCH_WHEN_READY) { 1167 p2p_set_state(p2p, P2P_SEARCH); 1168 p2p_search(p2p); 1169 return 1; 1170 } 1171 if (p2p->state != P2P_SEARCH_WHEN_READY) 1172 return 0; 1173 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Starting pending P2P find " 1174 "now that previous scan was completed"); 1175 if (p2p_find(p2p, p2p->last_p2p_find_timeout, p2p->find_type, 1176 p2p->num_req_dev_types, p2p->req_dev_types, 1177 p2p->find_dev_id, p2p->search_delay) < 0) { 1178 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, P2P_EVENT_FIND_STOPPED); 1179 return 0; 1180 } 1181 return 1; 1182} 1183 1184 1185void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq) 1186{ 1187 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Stopping find"); 1188 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1189 p2p_clear_timeout(p2p); 1190 if (p2p->state == P2P_SEARCH || 1191 p2p->state == P2P_CONTINUE_SEARCH_WHEN_READY || 1192 p2p->state == P2P_SEARCH_WHEN_READY) 1193 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, P2P_EVENT_FIND_STOPPED); 1194 p2p_set_state(p2p, P2P_IDLE); 1195 p2p_free_req_dev_types(p2p); 1196 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1197 if (p2p->go_neg_peer) 1198 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; 1199 p2p->go_neg_peer = NULL; 1200 p2p->sd_peer = NULL; 1201 p2p->invite_peer = NULL; 1202 p2p_stop_listen_for_freq(p2p, freq); 1203} 1204 1205 1206void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq) 1207{ 1208 if (freq > 0 && p2p->drv_in_listen == freq && p2p->in_listen) { 1209 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip stop_listen " 1210 "since we are on correct channel for response"); 1211 return; 1212 } 1213 if (p2p->in_listen) { 1214 p2p->in_listen = 0; 1215 p2p_clear_timeout(p2p); 1216 } 1217 if (p2p->drv_in_listen) { 1218 /* 1219 * The driver may not deliver callback to p2p_listen_end() 1220 * when the operation gets canceled, so clear the internal 1221 * variable that is tracking driver state. 1222 */ 1223 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Clear " 1224 "drv_in_listen (%d)", p2p->drv_in_listen); 1225 p2p->drv_in_listen = 0; 1226 } 1227 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1228} 1229 1230 1231void p2p_stop_find(struct p2p_data *p2p) 1232{ 1233 p2p_stop_find_for_freq(p2p, 0); 1234} 1235 1236 1237static int p2p_prepare_channel_pref(struct p2p_data *p2p, 1238 unsigned int force_freq, 1239 unsigned int pref_freq) 1240{ 1241 u8 op_class, op_channel; 1242 unsigned int freq = force_freq ? force_freq : pref_freq; 1243 1244 if (p2p_freq_to_channel(freq, &op_class, &op_channel) < 0) { 1245 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1246 "P2P: Unsupported frequency %u MHz", freq); 1247 return -1; 1248 } 1249 1250 if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel)) { 1251 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1252 "P2P: Frequency %u MHz (oper_class %u channel %u) not " 1253 "allowed for P2P", freq, op_class, op_channel); 1254 return -1; 1255 } 1256 1257 p2p->op_reg_class = op_class; 1258 p2p->op_channel = op_channel; 1259 1260 if (force_freq) { 1261 p2p->channels.reg_classes = 1; 1262 p2p->channels.reg_class[0].channels = 1; 1263 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class; 1264 p2p->channels.reg_class[0].channel[0] = p2p->op_channel; 1265 } else { 1266 os_memcpy(&p2p->channels, &p2p->cfg->channels, 1267 sizeof(struct p2p_channels)); 1268 } 1269 1270 return 0; 1271} 1272 1273 1274static void p2p_prepare_channel_best(struct p2p_data *p2p) 1275{ 1276 u8 op_class, op_channel; 1277 1278 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 && 1279 p2p_supported_freq(p2p, p2p->best_freq_overall) && 1280 p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel) 1281 == 0) { 1282 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Select best " 1283 "overall channel as operating channel preference"); 1284 p2p->op_reg_class = op_class; 1285 p2p->op_channel = op_channel; 1286 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 && 1287 p2p_supported_freq(p2p, p2p->best_freq_5) && 1288 p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel) 1289 == 0) { 1290 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Select best 5 GHz " 1291 "channel as operating channel preference"); 1292 p2p->op_reg_class = op_class; 1293 p2p->op_channel = op_channel; 1294 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 && 1295 p2p_supported_freq(p2p, p2p->best_freq_24) && 1296 p2p_freq_to_channel(p2p->best_freq_24, &op_class, 1297 &op_channel) == 0) { 1298 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Select best 2.4 " 1299 "GHz channel as operating channel preference"); 1300 p2p->op_reg_class = op_class; 1301 p2p->op_channel = op_channel; 1302 } else { 1303 p2p->op_reg_class = p2p->cfg->op_reg_class; 1304 p2p->op_channel = p2p->cfg->op_channel; 1305 } 1306 1307 os_memcpy(&p2p->channels, &p2p->cfg->channels, 1308 sizeof(struct p2p_channels)); 1309} 1310 1311 1312/** 1313 * p2p_prepare_channel - Select operating channel for GO Negotiation 1314 * @p2p: P2P module context from p2p_init() 1315 * @dev: Selected peer device 1316 * @force_freq: Forced frequency in MHz or 0 if not forced 1317 * @pref_freq: Preferred frequency in MHz or 0 if no preference 1318 * Returns: 0 on success, -1 on failure (channel not supported for P2P) 1319 * 1320 * This function is used to do initial operating channel selection for GO 1321 * Negotiation prior to having received peer information. The selected channel 1322 * may be further optimized in p2p_reselect_channel() once the peer information 1323 * is available. 1324 */ 1325int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev, 1326 unsigned int force_freq, unsigned int pref_freq) 1327{ 1328 if (force_freq || pref_freq) { 1329 if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq) < 0) 1330 return -1; 1331 } else { 1332 p2p_prepare_channel_best(p2p); 1333 } 1334 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1335 "P2P: Own preference for operation channel: " 1336 "Operating Class %u Channel %u%s", 1337 p2p->op_reg_class, p2p->op_channel, 1338 force_freq ? " (forced)" : ""); 1339 1340 if (force_freq) 1341 dev->flags |= P2P_DEV_FORCE_FREQ; 1342 else 1343 dev->flags &= ~P2P_DEV_FORCE_FREQ; 1344 1345 return 0; 1346} 1347 1348 1349static void p2p_set_dev_persistent(struct p2p_device *dev, 1350 int persistent_group) 1351{ 1352 switch (persistent_group) { 1353 case 0: 1354 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP | 1355 P2P_DEV_PREFER_PERSISTENT_RECONN); 1356 break; 1357 case 1: 1358 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP; 1359 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN; 1360 break; 1361 case 2: 1362 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP | 1363 P2P_DEV_PREFER_PERSISTENT_RECONN; 1364 break; 1365 } 1366} 1367 1368 1369int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr, 1370 enum p2p_wps_method wps_method, 1371 int go_intent, const u8 *own_interface_addr, 1372 unsigned int force_freq, int persistent_group, 1373 const u8 *force_ssid, size_t force_ssid_len, 1374 int pd_before_go_neg, unsigned int pref_freq) 1375{ 1376 struct p2p_device *dev; 1377 1378 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1379 "P2P: Request to start group negotiation - peer=" MACSTR 1380 " GO Intent=%d Intended Interface Address=" MACSTR 1381 " wps_method=%d persistent_group=%d pd_before_go_neg=%d", 1382 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr), 1383 wps_method, persistent_group, pd_before_go_neg); 1384 1385 dev = p2p_get_device(p2p, peer_addr); 1386 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) { 1387 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1388 "P2P: Cannot connect to unknown P2P Device " MACSTR, 1389 MAC2STR(peer_addr)); 1390 return -1; 1391 } 1392 1393 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq) < 0) 1394 return -1; 1395 1396 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) { 1397 if (!(dev->info.dev_capab & 1398 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) { 1399 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1400 "P2P: Cannot connect to P2P Device " MACSTR 1401 " that is in a group and is not discoverable", 1402 MAC2STR(peer_addr)); 1403 return -1; 1404 } 1405 if (dev->oper_freq <= 0) { 1406 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1407 "P2P: Cannot connect to P2P Device " MACSTR 1408 " with incomplete information", 1409 MAC2STR(peer_addr)); 1410 return -1; 1411 } 1412 1413 /* 1414 * First, try to connect directly. If the peer does not 1415 * acknowledge frames, assume it is sleeping and use device 1416 * discoverability via the GO at that point. 1417 */ 1418 } 1419 1420 p2p->ssid_set = 0; 1421 if (force_ssid) { 1422 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID", 1423 force_ssid, force_ssid_len); 1424 os_memcpy(p2p->ssid, force_ssid, force_ssid_len); 1425 p2p->ssid_len = force_ssid_len; 1426 p2p->ssid_set = 1; 1427 } 1428 1429 dev->flags &= ~P2P_DEV_NOT_YET_READY; 1430 dev->flags &= ~P2P_DEV_USER_REJECTED; 1431 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; 1432 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; 1433 if (pd_before_go_neg) 1434 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG; 1435 else { 1436 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG; 1437 /* 1438 * Assign dialog token and tie breaker here to use the same 1439 * values in each retry within the same GO Negotiation exchange. 1440 */ 1441 dev->dialog_token++; 1442 if (dev->dialog_token == 0) 1443 dev->dialog_token = 1; 1444 dev->tie_breaker = p2p->next_tie_breaker; 1445 p2p->next_tie_breaker = !p2p->next_tie_breaker; 1446 } 1447 dev->connect_reqs = 0; 1448 dev->go_neg_req_sent = 0; 1449 dev->go_state = UNKNOWN_GO; 1450 p2p_set_dev_persistent(dev, persistent_group); 1451 p2p->go_intent = go_intent; 1452 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); 1453 1454 if (p2p->state != P2P_IDLE) 1455 p2p_stop_find(p2p); 1456 1457 if (p2p->after_scan_tx) { 1458 /* 1459 * We need to drop the pending frame to avoid issues with the 1460 * new GO Negotiation, e.g., when the pending frame was from a 1461 * previous attempt at starting a GO Negotiation. 1462 */ 1463 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Dropped " 1464 "previous pending Action frame TX that was waiting " 1465 "for p2p_scan completion"); 1466 os_free(p2p->after_scan_tx); 1467 p2p->after_scan_tx = NULL; 1468 } 1469 1470 dev->wps_method = wps_method; 1471 dev->status = P2P_SC_SUCCESS; 1472 1473 if (p2p->p2p_scan_running) { 1474 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1475 "P2P: p2p_scan running - delay connect send"); 1476 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT; 1477 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN); 1478 return 0; 1479 } 1480 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1481 1482 return p2p_connect_send(p2p, dev); 1483} 1484 1485 1486int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr, 1487 enum p2p_wps_method wps_method, 1488 int go_intent, const u8 *own_interface_addr, 1489 unsigned int force_freq, int persistent_group, 1490 const u8 *force_ssid, size_t force_ssid_len, 1491 unsigned int pref_freq) 1492{ 1493 struct p2p_device *dev; 1494 1495 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1496 "P2P: Request to authorize group negotiation - peer=" MACSTR 1497 " GO Intent=%d Intended Interface Address=" MACSTR 1498 " wps_method=%d persistent_group=%d", 1499 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr), 1500 wps_method, persistent_group); 1501 1502 dev = p2p_get_device(p2p, peer_addr); 1503 if (dev == NULL) { 1504 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1505 "P2P: Cannot authorize unknown P2P Device " MACSTR, 1506 MAC2STR(peer_addr)); 1507 return -1; 1508 } 1509 1510 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq) < 0) 1511 return -1; 1512 1513 p2p->ssid_set = 0; 1514 if (force_ssid) { 1515 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID", 1516 force_ssid, force_ssid_len); 1517 os_memcpy(p2p->ssid, force_ssid, force_ssid_len); 1518 p2p->ssid_len = force_ssid_len; 1519 p2p->ssid_set = 1; 1520 } 1521 1522 dev->flags &= ~P2P_DEV_NOT_YET_READY; 1523 dev->flags &= ~P2P_DEV_USER_REJECTED; 1524 dev->go_neg_req_sent = 0; 1525 dev->go_state = UNKNOWN_GO; 1526 p2p_set_dev_persistent(dev, persistent_group); 1527 p2p->go_intent = go_intent; 1528 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); 1529 1530 dev->wps_method = wps_method; 1531 dev->status = P2P_SC_SUCCESS; 1532 1533 return 0; 1534} 1535 1536 1537void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr, 1538 struct p2p_device *dev, struct p2p_message *msg) 1539{ 1540 os_get_time(&dev->last_seen); 1541 1542 p2p_copy_wps_info(dev, 0, msg); 1543 1544 if (msg->listen_channel) { 1545 int freq; 1546 freq = p2p_channel_to_freq(msg->listen_channel[3], 1547 msg->listen_channel[4]); 1548 if (freq < 0) { 1549 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1550 "P2P: Unknown peer Listen channel: " 1551 "country=%c%c(0x%02x) reg_class=%u channel=%u", 1552 msg->listen_channel[0], 1553 msg->listen_channel[1], 1554 msg->listen_channel[2], 1555 msg->listen_channel[3], 1556 msg->listen_channel[4]); 1557 } else { 1558 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update " 1559 "peer " MACSTR " Listen channel: %u -> %u MHz", 1560 MAC2STR(dev->info.p2p_device_addr), 1561 dev->listen_freq, freq); 1562 dev->listen_freq = freq; 1563 } 1564 } 1565 1566 if (msg->wfd_subelems) { 1567 wpabuf_free(dev->info.wfd_subelems); 1568 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems); 1569 } 1570 1571 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { 1572 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY; 1573 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1574 "P2P: Completed device entry based on data from " 1575 "GO Negotiation Request"); 1576 } else { 1577 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1578 "P2P: Created device entry based on GO Neg Req: " 1579 MACSTR " dev_capab=0x%x group_capab=0x%x name='%s' " 1580 "listen_freq=%d", 1581 MAC2STR(dev->info.p2p_device_addr), 1582 dev->info.dev_capab, dev->info.group_capab, 1583 dev->info.device_name, dev->listen_freq); 1584 } 1585 1586 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY; 1587 1588 if (dev->flags & P2P_DEV_USER_REJECTED) { 1589 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1590 "P2P: Do not report rejected device"); 1591 return; 1592 } 1593 1594 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info, 1595 !(dev->flags & P2P_DEV_REPORTED_ONCE)); 1596 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 1597} 1598 1599 1600void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len) 1601{ 1602 os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); 1603 p2p_random((char *) &ssid[P2P_WILDCARD_SSID_LEN], 2); 1604 os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN + 2], 1605 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len); 1606 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len; 1607} 1608 1609 1610int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params) 1611{ 1612 p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len); 1613 p2p_random(params->passphrase, 8); 1614 return 0; 1615} 1616 1617 1618void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer) 1619{ 1620 struct p2p_go_neg_results res; 1621 int go = peer->go_state == LOCAL_GO; 1622 struct p2p_channels intersection; 1623 int freqs; 1624 size_t i, j; 1625 1626 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1627 "P2P: GO Negotiation with " MACSTR " completed (%s will be " 1628 "GO)", MAC2STR(peer->info.p2p_device_addr), 1629 go ? "local end" : "peer"); 1630 1631 os_memset(&res, 0, sizeof(res)); 1632 res.role_go = go; 1633 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN); 1634 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN); 1635 res.wps_method = peer->wps_method; 1636 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) { 1637 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN) 1638 res.persistent_group = 2; 1639 else 1640 res.persistent_group = 1; 1641 } 1642 1643 if (go) { 1644 /* Setup AP mode for WPS provisioning */ 1645 res.freq = p2p_channel_to_freq(p2p->op_reg_class, 1646 p2p->op_channel); 1647 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len); 1648 res.ssid_len = p2p->ssid_len; 1649 p2p_random(res.passphrase, 8); 1650 } else { 1651 res.freq = peer->oper_freq; 1652 if (p2p->ssid_len) { 1653 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len); 1654 res.ssid_len = p2p->ssid_len; 1655 } 1656 } 1657 1658 p2p_channels_intersect(&p2p->channels, &peer->channels, 1659 &intersection); 1660 freqs = 0; 1661 for (i = 0; i < intersection.reg_classes; i++) { 1662 struct p2p_reg_class *c = &intersection.reg_class[i]; 1663 if (freqs + 1 == P2P_MAX_CHANNELS) 1664 break; 1665 for (j = 0; j < c->channels; j++) { 1666 int freq; 1667 if (freqs + 1 == P2P_MAX_CHANNELS) 1668 break; 1669 freq = p2p_channel_to_freq(c->reg_class, c->channel[j]); 1670 if (freq < 0) 1671 continue; 1672 res.freq_list[freqs++] = freq; 1673 } 1674 } 1675 1676 res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout; 1677 1678 p2p_clear_timeout(p2p); 1679 p2p->ssid_set = 0; 1680 peer->go_neg_req_sent = 0; 1681 peer->wps_method = WPS_NOT_READY; 1682 1683 p2p_set_state(p2p, P2P_PROVISIONING); 1684 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res); 1685} 1686 1687 1688static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa, 1689 const u8 *data, size_t len, int rx_freq) 1690{ 1691 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1692 "P2P: RX P2P Public Action from " MACSTR, MAC2STR(sa)); 1693 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len); 1694 1695 if (len < 1) 1696 return; 1697 1698 switch (data[0]) { 1699 case P2P_GO_NEG_REQ: 1700 p2p_process_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq); 1701 break; 1702 case P2P_GO_NEG_RESP: 1703 p2p_process_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq); 1704 break; 1705 case P2P_GO_NEG_CONF: 1706 p2p_process_go_neg_conf(p2p, sa, data + 1, len - 1); 1707 break; 1708 case P2P_INVITATION_REQ: 1709 p2p_process_invitation_req(p2p, sa, data + 1, len - 1, 1710 rx_freq); 1711 break; 1712 case P2P_INVITATION_RESP: 1713 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1); 1714 break; 1715 case P2P_PROV_DISC_REQ: 1716 p2p_process_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq); 1717 break; 1718 case P2P_PROV_DISC_RESP: 1719 p2p_process_prov_disc_resp(p2p, sa, data + 1, len - 1); 1720 break; 1721 case P2P_DEV_DISC_REQ: 1722 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq); 1723 break; 1724 case P2P_DEV_DISC_RESP: 1725 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1); 1726 break; 1727 default: 1728 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1729 "P2P: Unsupported P2P Public Action frame type %d", 1730 data[0]); 1731 break; 1732 } 1733} 1734 1735 1736static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da, 1737 const u8 *sa, const u8 *bssid, const u8 *data, 1738 size_t len, int freq) 1739{ 1740 if (len < 1) 1741 return; 1742 1743 switch (data[0]) { 1744 case WLAN_PA_VENDOR_SPECIFIC: 1745 data++; 1746 len--; 1747 if (len < 3) 1748 return; 1749 if (WPA_GET_BE24(data) != OUI_WFA) 1750 return; 1751 1752 data += 3; 1753 len -= 3; 1754 if (len < 1) 1755 return; 1756 1757 if (*data != P2P_OUI_TYPE) 1758 return; 1759 1760 p2p_rx_p2p_action(p2p, sa, data + 1, len - 1, freq); 1761 break; 1762 case WLAN_PA_GAS_INITIAL_REQ: 1763 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq); 1764 break; 1765 case WLAN_PA_GAS_INITIAL_RESP: 1766 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq); 1767 break; 1768 case WLAN_PA_GAS_COMEBACK_REQ: 1769 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq); 1770 break; 1771 case WLAN_PA_GAS_COMEBACK_RESP: 1772 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq); 1773 break; 1774 } 1775} 1776 1777 1778void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa, 1779 const u8 *bssid, u8 category, 1780 const u8 *data, size_t len, int freq) 1781{ 1782 if (category == WLAN_ACTION_PUBLIC) { 1783 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq); 1784 return; 1785 } 1786 1787 if (category != WLAN_ACTION_VENDOR_SPECIFIC) 1788 return; 1789 1790 if (len < 4) 1791 return; 1792 1793 if (WPA_GET_BE24(data) != OUI_WFA) 1794 return; 1795 data += 3; 1796 len -= 3; 1797 1798 if (*data != P2P_OUI_TYPE) 1799 return; 1800 data++; 1801 len--; 1802 1803 /* P2P action frame */ 1804 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1805 "P2P: RX P2P Action from " MACSTR, MAC2STR(sa)); 1806 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len); 1807 1808 if (len < 1) 1809 return; 1810 switch (data[0]) { 1811 case P2P_NOA: 1812 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1813 "P2P: Received P2P Action - Notice of Absence"); 1814 /* TODO */ 1815 break; 1816 case P2P_PRESENCE_REQ: 1817 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq); 1818 break; 1819 case P2P_PRESENCE_RESP: 1820 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1); 1821 break; 1822 case P2P_GO_DISC_REQ: 1823 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq); 1824 break; 1825 default: 1826 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1827 "P2P: Received P2P Action - unknown type %u", data[0]); 1828 break; 1829 } 1830} 1831 1832 1833static void p2p_go_neg_start(void *eloop_ctx, void *timeout_ctx) 1834{ 1835 struct p2p_data *p2p = eloop_ctx; 1836 if (p2p->go_neg_peer == NULL) 1837 return; 1838 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1839 p2p->go_neg_peer->status = P2P_SC_SUCCESS; 1840 p2p_connect_send(p2p, p2p->go_neg_peer); 1841} 1842 1843 1844static void p2p_invite_start(void *eloop_ctx, void *timeout_ctx) 1845{ 1846 struct p2p_data *p2p = eloop_ctx; 1847 if (p2p->invite_peer == NULL) 1848 return; 1849 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1850 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr); 1851} 1852 1853 1854static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr, 1855 const u8 *ie, size_t ie_len) 1856{ 1857 struct p2p_message msg; 1858 struct p2p_device *dev; 1859 1860 os_memset(&msg, 0, sizeof(msg)); 1861 if (p2p_parse_ies(ie, ie_len, &msg) < 0 || msg.p2p_attributes == NULL) 1862 { 1863 p2p_parse_free(&msg); 1864 return; /* not a P2P probe */ 1865 } 1866 1867 if (msg.ssid == NULL || msg.ssid[1] != P2P_WILDCARD_SSID_LEN || 1868 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) 1869 != 0) { 1870 /* The Probe Request is not part of P2P Device Discovery. It is 1871 * not known whether the source address of the frame is the P2P 1872 * Device Address or P2P Interface Address. Do not add a new 1873 * peer entry based on this frames. 1874 */ 1875 p2p_parse_free(&msg); 1876 return; 1877 } 1878 1879 dev = p2p_get_device(p2p, addr); 1880 if (dev) { 1881 if (dev->country[0] == 0 && msg.listen_channel) 1882 os_memcpy(dev->country, msg.listen_channel, 3); 1883 os_get_time(&dev->last_seen); 1884 p2p_parse_free(&msg); 1885 return; /* already known */ 1886 } 1887 1888 dev = p2p_create_device(p2p, addr); 1889 if (dev == NULL) { 1890 p2p_parse_free(&msg); 1891 return; 1892 } 1893 1894 os_get_time(&dev->last_seen); 1895 dev->flags |= P2P_DEV_PROBE_REQ_ONLY; 1896 1897 if (msg.listen_channel) { 1898 os_memcpy(dev->country, msg.listen_channel, 3); 1899 dev->listen_freq = p2p_channel_to_freq(msg.listen_channel[3], 1900 msg.listen_channel[4]); 1901 } 1902 1903 p2p_copy_wps_info(dev, 1, &msg); 1904 1905 if (msg.wfd_subelems) { 1906 wpabuf_free(dev->info.wfd_subelems); 1907 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems); 1908 } 1909 1910 p2p_parse_free(&msg); 1911 1912 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 1913 "P2P: Created device entry based on Probe Req: " MACSTR 1914 " dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d", 1915 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab, 1916 dev->info.group_capab, dev->info.device_name, 1917 dev->listen_freq); 1918} 1919 1920 1921struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p, 1922 const u8 *addr, 1923 struct p2p_message *msg) 1924{ 1925 struct p2p_device *dev; 1926 1927 dev = p2p_get_device(p2p, addr); 1928 if (dev) { 1929 os_get_time(&dev->last_seen); 1930 return dev; /* already known */ 1931 } 1932 1933 dev = p2p_create_device(p2p, addr); 1934 if (dev == NULL) 1935 return NULL; 1936 1937 p2p_add_dev_info(p2p, addr, dev, msg); 1938 1939 return dev; 1940} 1941 1942 1943static int dev_type_match(const u8 *dev_type, const u8 *req_dev_type) 1944{ 1945 if (os_memcmp(dev_type, req_dev_type, WPS_DEV_TYPE_LEN) == 0) 1946 return 1; 1947 if (os_memcmp(dev_type, req_dev_type, 2) == 0 && 1948 WPA_GET_BE32(&req_dev_type[2]) == 0 && 1949 WPA_GET_BE16(&req_dev_type[6]) == 0) 1950 return 1; /* Category match with wildcard OUI/sub-category */ 1951 return 0; 1952} 1953 1954 1955int dev_type_list_match(const u8 *dev_type, const u8 *req_dev_type[], 1956 size_t num_req_dev_type) 1957{ 1958 size_t i; 1959 for (i = 0; i < num_req_dev_type; i++) { 1960 if (dev_type_match(dev_type, req_dev_type[i])) 1961 return 1; 1962 } 1963 return 0; 1964} 1965 1966 1967/** 1968 * p2p_match_dev_type - Match local device type with requested type 1969 * @p2p: P2P module context from p2p_init() 1970 * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs) 1971 * Returns: 1 on match, 0 on mismatch 1972 * 1973 * This function can be used to match the Requested Device Type attribute in 1974 * WPS IE with the local device types for deciding whether to reply to a Probe 1975 * Request frame. 1976 */ 1977int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps) 1978{ 1979 struct wps_parse_attr attr; 1980 size_t i; 1981 1982 if (wps_parse_msg(wps, &attr)) 1983 return 1; /* assume no Requested Device Type attributes */ 1984 1985 if (attr.num_req_dev_type == 0) 1986 return 1; /* no Requested Device Type attributes -> match */ 1987 1988 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type, 1989 attr.num_req_dev_type)) 1990 return 1; /* Own Primary Device Type matches */ 1991 1992 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) 1993 if (dev_type_list_match(p2p->cfg->sec_dev_type[i], 1994 attr.req_dev_type, 1995 attr.num_req_dev_type)) 1996 return 1; /* Own Secondary Device Type matches */ 1997 1998 /* No matching device type found */ 1999 return 0; 2000} 2001 2002 2003struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p) 2004{ 2005 struct wpabuf *buf; 2006 u8 *len; 2007 int pw_id = -1; 2008 size_t extra = 0; 2009 2010#ifdef CONFIG_WIFI_DISPLAY 2011 if (p2p->wfd_ie_probe_resp) 2012 extra = wpabuf_len(p2p->wfd_ie_probe_resp); 2013#endif /* CONFIG_WIFI_DISPLAY */ 2014 2015 buf = wpabuf_alloc(1000 + extra); 2016 if (buf == NULL) 2017 return NULL; 2018 2019 if (p2p->go_neg_peer) { 2020 /* Advertise immediate availability of WPS credential */ 2021 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method); 2022 } 2023 2024 p2p_build_wps_ie(p2p, buf, pw_id, 1); 2025 2026#ifdef CONFIG_WIFI_DISPLAY 2027 if (p2p->wfd_ie_probe_resp) 2028 wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp); 2029#endif /* CONFIG_WIFI_DISPLAY */ 2030 2031 /* P2P IE */ 2032 len = p2p_buf_add_ie_hdr(buf); 2033 p2p_buf_add_capability(buf, p2p->dev_capab & 2034 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0); 2035 if (p2p->ext_listen_interval) 2036 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period, 2037 p2p->ext_listen_interval); 2038 p2p_buf_add_device_info(buf, p2p, NULL); 2039 p2p_buf_update_ie_hdr(buf, len); 2040 2041 return buf; 2042} 2043 2044 2045static int is_11b(u8 rate) 2046{ 2047 return rate == 0x02 || rate == 0x04 || rate == 0x0b || rate == 0x16; 2048} 2049 2050 2051static int supp_rates_11b_only(struct ieee802_11_elems *elems) 2052{ 2053 int num_11b = 0, num_others = 0; 2054 int i; 2055 2056 if (elems->supp_rates == NULL && elems->ext_supp_rates == NULL) 2057 return 0; 2058 2059 for (i = 0; elems->supp_rates && i < elems->supp_rates_len; i++) { 2060 if (is_11b(elems->supp_rates[i])) 2061 num_11b++; 2062 else 2063 num_others++; 2064 } 2065 2066 for (i = 0; elems->ext_supp_rates && i < elems->ext_supp_rates_len; 2067 i++) { 2068 if (is_11b(elems->ext_supp_rates[i])) 2069 num_11b++; 2070 else 2071 num_others++; 2072 } 2073 2074 return num_11b > 0 && num_others == 0; 2075} 2076 2077 2078static enum p2p_probe_req_status 2079p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst, 2080 const u8 *bssid, const u8 *ie, size_t ie_len) 2081{ 2082 struct ieee802_11_elems elems; 2083 struct wpabuf *buf; 2084 struct ieee80211_mgmt *resp; 2085 struct p2p_message msg; 2086 struct wpabuf *ies; 2087 2088 if (!p2p->in_listen || !p2p->drv_in_listen) { 2089 /* not in Listen state - ignore Probe Request */ 2090 return P2P_PREQ_NOT_LISTEN; 2091 } 2092 2093 if (ieee802_11_parse_elems((u8 *) ie, ie_len, &elems, 0) == 2094 ParseFailed) { 2095 /* Ignore invalid Probe Request frames */ 2096 return P2P_PREQ_MALFORMED; 2097 } 2098 2099 if (elems.p2p == NULL) { 2100 /* not a P2P probe - ignore it */ 2101 return P2P_PREQ_NOT_P2P; 2102 } 2103 2104 if (dst && !is_broadcast_ether_addr(dst) && 2105 os_memcmp(dst, p2p->cfg->dev_addr, ETH_ALEN) != 0) { 2106 /* Not sent to the broadcast address or our P2P Device Address 2107 */ 2108 return P2P_PREQ_NOT_PROCESSED; 2109 } 2110 2111 if (bssid && !is_broadcast_ether_addr(bssid)) { 2112 /* Not sent to the Wildcard BSSID */ 2113 return P2P_PREQ_NOT_PROCESSED; 2114 } 2115 2116 if (elems.ssid == NULL || elems.ssid_len != P2P_WILDCARD_SSID_LEN || 2117 os_memcmp(elems.ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) != 2118 0) { 2119 /* not using P2P Wildcard SSID - ignore */ 2120 return P2P_PREQ_NOT_PROCESSED; 2121 } 2122 2123 if (supp_rates_11b_only(&elems)) { 2124 /* Indicates support for 11b rates only */ 2125 return P2P_PREQ_NOT_P2P; 2126 } 2127 2128 os_memset(&msg, 0, sizeof(msg)); 2129 if (p2p_parse_ies(ie, ie_len, &msg) < 0) { 2130 /* Could not parse P2P attributes */ 2131 return P2P_PREQ_NOT_P2P; 2132 } 2133 2134 if (msg.device_id && 2135 os_memcmp(msg.device_id, p2p->cfg->dev_addr, ETH_ALEN) != 0) { 2136 /* Device ID did not match */ 2137 p2p_parse_free(&msg); 2138 return P2P_PREQ_NOT_PROCESSED; 2139 } 2140 2141 /* Check Requested Device Type match */ 2142 if (msg.wps_attributes && 2143 !p2p_match_dev_type(p2p, msg.wps_attributes)) { 2144 /* No match with Requested Device Type */ 2145 p2p_parse_free(&msg); 2146 return P2P_PREQ_NOT_PROCESSED; 2147 } 2148 p2p_parse_free(&msg); 2149 2150 if (!p2p->cfg->send_probe_resp) { 2151 /* Response generated elsewhere */ 2152 return P2P_PREQ_NOT_PROCESSED; 2153 } 2154 2155 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2156 "P2P: Reply to P2P Probe Request in Listen state"); 2157 2158 /* 2159 * We do not really have a specific BSS that this frame is advertising, 2160 * so build a frame that has some information in valid format. This is 2161 * really only used for discovery purposes, not to learn exact BSS 2162 * parameters. 2163 */ 2164 ies = p2p_build_probe_resp_ies(p2p); 2165 if (ies == NULL) 2166 return P2P_PREQ_NOT_PROCESSED; 2167 2168 buf = wpabuf_alloc(200 + wpabuf_len(ies)); 2169 if (buf == NULL) { 2170 wpabuf_free(ies); 2171 return P2P_PREQ_NOT_PROCESSED; 2172 } 2173 2174 resp = NULL; 2175 resp = wpabuf_put(buf, resp->u.probe_resp.variable - (u8 *) resp); 2176 2177 resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) | 2178 (WLAN_FC_STYPE_PROBE_RESP << 4)); 2179 os_memcpy(resp->da, addr, ETH_ALEN); 2180 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN); 2181 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN); 2182 resp->u.probe_resp.beacon_int = host_to_le16(100); 2183 /* hardware or low-level driver will setup seq_ctrl and timestamp */ 2184 resp->u.probe_resp.capab_info = 2185 host_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE | 2186 WLAN_CAPABILITY_PRIVACY | 2187 WLAN_CAPABILITY_SHORT_SLOT_TIME); 2188 2189 wpabuf_put_u8(buf, WLAN_EID_SSID); 2190 wpabuf_put_u8(buf, P2P_WILDCARD_SSID_LEN); 2191 wpabuf_put_data(buf, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); 2192 2193 wpabuf_put_u8(buf, WLAN_EID_SUPP_RATES); 2194 wpabuf_put_u8(buf, 8); 2195 wpabuf_put_u8(buf, (60 / 5) | 0x80); 2196 wpabuf_put_u8(buf, 90 / 5); 2197 wpabuf_put_u8(buf, (120 / 5) | 0x80); 2198 wpabuf_put_u8(buf, 180 / 5); 2199 wpabuf_put_u8(buf, (240 / 5) | 0x80); 2200 wpabuf_put_u8(buf, 360 / 5); 2201 wpabuf_put_u8(buf, 480 / 5); 2202 wpabuf_put_u8(buf, 540 / 5); 2203 2204 wpabuf_put_u8(buf, WLAN_EID_DS_PARAMS); 2205 wpabuf_put_u8(buf, 1); 2206 wpabuf_put_u8(buf, p2p->cfg->channel); 2207 2208 wpabuf_put_buf(buf, ies); 2209 wpabuf_free(ies); 2210 2211 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf); 2212 2213 wpabuf_free(buf); 2214 2215 return P2P_PREQ_NOT_PROCESSED; 2216} 2217 2218 2219enum p2p_probe_req_status 2220p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst, 2221 const u8 *bssid, const u8 *ie, size_t ie_len) 2222{ 2223 enum p2p_probe_req_status res; 2224 2225 p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len); 2226 2227 res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len); 2228 2229 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) && 2230 p2p->go_neg_peer && 2231 os_memcmp(addr, p2p->go_neg_peer->info.p2p_device_addr, ETH_ALEN) 2232 == 0 && 2233 !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { 2234 /* Received a Probe Request from GO Negotiation peer */ 2235 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2236 "P2P: Found GO Negotiation peer - try to start GO " 2237 "negotiation from timeout"); 2238 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL); 2239 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL); 2240 return P2P_PREQ_PROCESSED; 2241 } 2242 2243 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) && 2244 p2p->invite_peer && 2245 os_memcmp(addr, p2p->invite_peer->info.p2p_device_addr, ETH_ALEN) 2246 == 0) { 2247 /* Received a Probe Request from Invite peer */ 2248 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2249 "P2P: Found Invite peer - try to start Invite from " 2250 "timeout"); 2251 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL); 2252 return P2P_PREQ_PROCESSED; 2253 } 2254 2255 return res; 2256} 2257 2258 2259static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid, 2260 u8 *buf, size_t len, struct wpabuf *p2p_ie) 2261{ 2262 struct wpabuf *tmp; 2263 u8 *lpos; 2264 size_t tmplen; 2265 int res; 2266 u8 group_capab; 2267 2268 if (p2p_ie == NULL) 2269 return 0; /* WLAN AP is not a P2P manager */ 2270 2271 /* 2272 * (Re)Association Request - P2P IE 2273 * P2P Capability attribute (shall be present) 2274 * P2P Interface attribute (present if concurrent device and 2275 * P2P Management is enabled) 2276 */ 2277 tmp = wpabuf_alloc(200); 2278 if (tmp == NULL) 2279 return -1; 2280 2281 lpos = p2p_buf_add_ie_hdr(tmp); 2282 group_capab = 0; 2283 if (p2p->num_groups > 0) { 2284 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER; 2285 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && 2286 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) && 2287 p2p->cross_connect) 2288 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN; 2289 } 2290 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab); 2291 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && 2292 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED)) 2293 p2p_buf_add_p2p_interface(tmp, p2p); 2294 p2p_buf_update_ie_hdr(tmp, lpos); 2295 2296 tmplen = wpabuf_len(tmp); 2297 if (tmplen > len) 2298 res = -1; 2299 else { 2300 os_memcpy(buf, wpabuf_head(tmp), tmplen); 2301 res = tmplen; 2302 } 2303 wpabuf_free(tmp); 2304 2305 return res; 2306} 2307 2308 2309int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf, 2310 size_t len, int p2p_group, struct wpabuf *p2p_ie) 2311{ 2312 struct wpabuf *tmp; 2313 u8 *lpos; 2314 struct p2p_device *peer; 2315 size_t tmplen; 2316 int res; 2317 size_t extra = 0; 2318 2319 if (!p2p_group) 2320 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie); 2321 2322#ifdef CONFIG_WIFI_DISPLAY 2323 if (p2p->wfd_ie_assoc_req) 2324 extra = wpabuf_len(p2p->wfd_ie_assoc_req); 2325#endif /* CONFIG_WIFI_DISPLAY */ 2326 2327 /* 2328 * (Re)Association Request - P2P IE 2329 * P2P Capability attribute (shall be present) 2330 * Extended Listen Timing (may be present) 2331 * P2P Device Info attribute (shall be present) 2332 */ 2333 tmp = wpabuf_alloc(200 + extra); 2334 if (tmp == NULL) 2335 return -1; 2336 2337#ifdef CONFIG_WIFI_DISPLAY 2338 if (p2p->wfd_ie_assoc_req) 2339 wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req); 2340#endif /* CONFIG_WIFI_DISPLAY */ 2341 2342 peer = bssid ? p2p_get_device(p2p, bssid) : NULL; 2343 2344 lpos = p2p_buf_add_ie_hdr(tmp); 2345 p2p_buf_add_capability(tmp, p2p->dev_capab, 0); 2346 if (p2p->ext_listen_interval) 2347 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period, 2348 p2p->ext_listen_interval); 2349 p2p_buf_add_device_info(tmp, p2p, peer); 2350 p2p_buf_update_ie_hdr(tmp, lpos); 2351 2352 tmplen = wpabuf_len(tmp); 2353 if (tmplen > len) 2354 res = -1; 2355 else { 2356 os_memcpy(buf, wpabuf_head(tmp), tmplen); 2357 res = tmplen; 2358 } 2359 wpabuf_free(tmp); 2360 2361 return res; 2362} 2363 2364 2365int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end) 2366{ 2367 struct wpabuf *p2p_ie; 2368 int ret; 2369 2370 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, P2P_IE_VENDOR_TYPE); 2371 if (p2p_ie == NULL) 2372 return 0; 2373 2374 ret = p2p_attr_text(p2p_ie, buf, end); 2375 wpabuf_free(p2p_ie); 2376 return ret; 2377} 2378 2379 2380int p2p_parse_dev_addr_in_p2p_ie(struct wpabuf *p2p_ie, u8 *dev_addr) 2381{ 2382 struct p2p_message msg; 2383 2384 os_memset(&msg, 0, sizeof(msg)); 2385 if (p2p_parse_p2p_ie(p2p_ie, &msg)) 2386 return -1; 2387 2388 if (msg.p2p_device_addr) { 2389 os_memcpy(dev_addr, msg.p2p_device_addr, ETH_ALEN); 2390 return 0; 2391 } else if (msg.device_id) { 2392 os_memcpy(dev_addr, msg.device_id, ETH_ALEN); 2393 return 0; 2394 } 2395 return -1; 2396} 2397 2398 2399int p2p_parse_dev_addr(const u8 *ies, size_t ies_len, u8 *dev_addr) 2400{ 2401 struct wpabuf *p2p_ie; 2402 int ret; 2403 2404 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, 2405 P2P_IE_VENDOR_TYPE); 2406 if (p2p_ie == NULL) 2407 return -1; 2408 ret = p2p_parse_dev_addr_in_p2p_ie(p2p_ie, dev_addr); 2409 wpabuf_free(p2p_ie); 2410 return ret; 2411} 2412 2413 2414static void p2p_clear_go_neg(struct p2p_data *p2p) 2415{ 2416 p2p->go_neg_peer = NULL; 2417 p2p_clear_timeout(p2p); 2418 p2p_set_state(p2p, P2P_IDLE); 2419} 2420 2421 2422void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr) 2423{ 2424 if (p2p->go_neg_peer == NULL) { 2425 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2426 "P2P: No pending Group Formation - " 2427 "ignore WPS registration success notification"); 2428 return; /* No pending Group Formation */ 2429 } 2430 2431 if (os_memcmp(mac_addr, p2p->go_neg_peer->intended_addr, ETH_ALEN) != 2432 0) { 2433 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2434 "P2P: Ignore WPS registration success notification " 2435 "for " MACSTR " (GO Negotiation peer " MACSTR ")", 2436 MAC2STR(mac_addr), 2437 MAC2STR(p2p->go_neg_peer->intended_addr)); 2438 return; /* Ignore unexpected peer address */ 2439 } 2440 2441 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2442 "P2P: Group Formation completed successfully with " MACSTR, 2443 MAC2STR(mac_addr)); 2444 2445 p2p_clear_go_neg(p2p); 2446} 2447 2448 2449void p2p_group_formation_failed(struct p2p_data *p2p) 2450{ 2451 if (p2p->go_neg_peer == NULL) { 2452 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2453 "P2P: No pending Group Formation - " 2454 "ignore group formation failure notification"); 2455 return; /* No pending Group Formation */ 2456 } 2457 2458 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2459 "P2P: Group Formation failed with " MACSTR, 2460 MAC2STR(p2p->go_neg_peer->intended_addr)); 2461 2462 p2p_clear_go_neg(p2p); 2463} 2464 2465 2466struct p2p_data * p2p_init(const struct p2p_config *cfg) 2467{ 2468 struct p2p_data *p2p; 2469 2470 if (cfg->max_peers < 1) 2471 return NULL; 2472 2473 p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg)); 2474 if (p2p == NULL) 2475 return NULL; 2476 p2p->cfg = (struct p2p_config *) (p2p + 1); 2477 os_memcpy(p2p->cfg, cfg, sizeof(*cfg)); 2478 if (cfg->dev_name) 2479 p2p->cfg->dev_name = os_strdup(cfg->dev_name); 2480 if (cfg->manufacturer) 2481 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer); 2482 if (cfg->model_name) 2483 p2p->cfg->model_name = os_strdup(cfg->model_name); 2484 if (cfg->model_number) 2485 p2p->cfg->model_number = os_strdup(cfg->model_number); 2486 if (cfg->serial_number) 2487 p2p->cfg->serial_number = os_strdup(cfg->serial_number); 2488 if (cfg->pref_chan) { 2489 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan * 2490 sizeof(struct p2p_channel)); 2491 if (p2p->cfg->pref_chan) { 2492 os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan, 2493 cfg->num_pref_chan * 2494 sizeof(struct p2p_channel)); 2495 } else 2496 p2p->cfg->num_pref_chan = 0; 2497 } 2498 2499#ifdef ANDROID_P2P 2500 /* 100ms listen time is too less to receive the response frames in some scenarios 2501 * increasing min listen time to 200ms. 2502 */ 2503 p2p->min_disc_int = 2; 2504 /* SD_FAIR_POLICY: Initializing the SD current serviced pointer to NULL */ 2505 p2p->sd_dev_list = NULL; 2506#else 2507 p2p->min_disc_int = 1; 2508#endif 2509 p2p->max_disc_int = 3; 2510 p2p->max_disc_tu = -1; 2511 2512 os_get_random(&p2p->next_tie_breaker, 1); 2513 p2p->next_tie_breaker &= 0x01; 2514 if (cfg->sd_request) 2515 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY; 2516 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE; 2517 if (cfg->concurrent_operations) 2518 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER; 2519 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 2520 2521 dl_list_init(&p2p->devices); 2522 2523 eloop_register_timeout(P2P_PEER_EXPIRATION_INTERVAL, 0, 2524 p2p_expiration_timeout, p2p, NULL); 2525 2526 p2p->go_timeout = 100; 2527 p2p->client_timeout = 20; 2528 2529 return p2p; 2530} 2531 2532 2533void p2p_deinit(struct p2p_data *p2p) 2534{ 2535#ifdef CONFIG_WIFI_DISPLAY 2536 wpabuf_free(p2p->wfd_ie_beacon); 2537 wpabuf_free(p2p->wfd_ie_probe_req); 2538 wpabuf_free(p2p->wfd_ie_probe_resp); 2539 wpabuf_free(p2p->wfd_ie_assoc_req); 2540 wpabuf_free(p2p->wfd_ie_invitation); 2541 wpabuf_free(p2p->wfd_ie_prov_disc_req); 2542 wpabuf_free(p2p->wfd_ie_prov_disc_resp); 2543 wpabuf_free(p2p->wfd_ie_go_neg); 2544 wpabuf_free(p2p->wfd_dev_info); 2545 wpabuf_free(p2p->wfd_assoc_bssid); 2546 wpabuf_free(p2p->wfd_coupled_sink_info); 2547#endif /* CONFIG_WIFI_DISPLAY */ 2548 2549 eloop_cancel_timeout(p2p_expiration_timeout, p2p, NULL); 2550 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL); 2551 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 2552 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL); 2553 p2p_flush(p2p); 2554 p2p_free_req_dev_types(p2p); 2555 os_free(p2p->cfg->dev_name); 2556 os_free(p2p->cfg->manufacturer); 2557 os_free(p2p->cfg->model_name); 2558 os_free(p2p->cfg->model_number); 2559 os_free(p2p->cfg->serial_number); 2560 os_free(p2p->cfg->pref_chan); 2561 os_free(p2p->groups); 2562 wpabuf_free(p2p->sd_resp); 2563 os_free(p2p->after_scan_tx); 2564 p2p_remove_wps_vendor_extensions(p2p); 2565 os_free(p2p); 2566} 2567 2568 2569void p2p_flush(struct p2p_data *p2p) 2570{ 2571 struct p2p_device *dev, *prev; 2572 p2p_stop_find(p2p); 2573 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device, 2574 list) { 2575 dl_list_del(&dev->list); 2576 p2p_device_free(p2p, dev); 2577 } 2578#ifdef ANDROID_P2P 2579 /* SD_FAIR_POLICY: Initializing the SD current serviced pointer to NULL */ 2580 p2p->sd_dev_list = NULL; 2581#endif 2582 p2p_free_sd_queries(p2p); 2583 os_free(p2p->after_scan_tx); 2584 p2p->after_scan_tx = NULL; 2585} 2586 2587 2588int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr) 2589{ 2590 struct p2p_device *dev; 2591 2592 dev = p2p_get_device(p2p, addr); 2593 if (dev == NULL) 2594 return -1; 2595 2596 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Unauthorizing " MACSTR, 2597 MAC2STR(addr)); 2598 2599 if (p2p->go_neg_peer == dev) 2600 p2p->go_neg_peer = NULL; 2601 2602 dev->wps_method = WPS_NOT_READY; 2603 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; 2604 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; 2605 2606 /* Check if after_scan_tx is for this peer. If so free it */ 2607 if (p2p->after_scan_tx && 2608 os_memcmp(addr, p2p->after_scan_tx->dst, ETH_ALEN) == 0) { 2609 os_free(p2p->after_scan_tx); 2610 p2p->after_scan_tx = NULL; 2611 } 2612 2613 return 0; 2614} 2615 2616 2617int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name) 2618{ 2619 os_free(p2p->cfg->dev_name); 2620 if (dev_name) { 2621 p2p->cfg->dev_name = os_strdup(dev_name); 2622 if (p2p->cfg->dev_name == NULL) 2623 return -1; 2624 } else 2625 p2p->cfg->dev_name = NULL; 2626 return 0; 2627} 2628 2629 2630int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer) 2631{ 2632 os_free(p2p->cfg->manufacturer); 2633 p2p->cfg->manufacturer = NULL; 2634 if (manufacturer) { 2635 p2p->cfg->manufacturer = os_strdup(manufacturer); 2636 if (p2p->cfg->manufacturer == NULL) 2637 return -1; 2638 } 2639 2640 return 0; 2641} 2642 2643 2644int p2p_set_model_name(struct p2p_data *p2p, const char *model_name) 2645{ 2646 os_free(p2p->cfg->model_name); 2647 p2p->cfg->model_name = NULL; 2648 if (model_name) { 2649 p2p->cfg->model_name = os_strdup(model_name); 2650 if (p2p->cfg->model_name == NULL) 2651 return -1; 2652 } 2653 2654 return 0; 2655} 2656 2657 2658int p2p_set_model_number(struct p2p_data *p2p, const char *model_number) 2659{ 2660 os_free(p2p->cfg->model_number); 2661 p2p->cfg->model_number = NULL; 2662 if (model_number) { 2663 p2p->cfg->model_number = os_strdup(model_number); 2664 if (p2p->cfg->model_number == NULL) 2665 return -1; 2666 } 2667 2668 return 0; 2669} 2670 2671 2672int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number) 2673{ 2674 os_free(p2p->cfg->serial_number); 2675 p2p->cfg->serial_number = NULL; 2676 if (serial_number) { 2677 p2p->cfg->serial_number = os_strdup(serial_number); 2678 if (p2p->cfg->serial_number == NULL) 2679 return -1; 2680 } 2681 2682 return 0; 2683} 2684 2685 2686void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods) 2687{ 2688 p2p->cfg->config_methods = config_methods; 2689} 2690 2691 2692void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid) 2693{ 2694 os_memcpy(p2p->cfg->uuid, uuid, 16); 2695} 2696 2697 2698int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type) 2699{ 2700 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8); 2701 return 0; 2702} 2703 2704 2705int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8], 2706 size_t num_dev_types) 2707{ 2708 if (num_dev_types > P2P_SEC_DEVICE_TYPES) 2709 num_dev_types = P2P_SEC_DEVICE_TYPES; 2710 p2p->cfg->num_sec_dev_types = num_dev_types; 2711 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8); 2712 return 0; 2713} 2714 2715 2716void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p) 2717{ 2718 int i; 2719 2720 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 2721 wpabuf_free(p2p->wps_vendor_ext[i]); 2722 p2p->wps_vendor_ext[i] = NULL; 2723 } 2724} 2725 2726 2727int p2p_add_wps_vendor_extension(struct p2p_data *p2p, 2728 const struct wpabuf *vendor_ext) 2729{ 2730 int i; 2731 2732 if (vendor_ext == NULL) 2733 return -1; 2734 2735 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 2736 if (p2p->wps_vendor_ext[i] == NULL) 2737 break; 2738 } 2739 if (i >= P2P_MAX_WPS_VENDOR_EXT) 2740 return -1; 2741 2742 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext); 2743 if (p2p->wps_vendor_ext[i] == NULL) 2744 return -1; 2745 2746 return 0; 2747} 2748 2749 2750int p2p_set_country(struct p2p_data *p2p, const char *country) 2751{ 2752 os_memcpy(p2p->cfg->country, country, 3); 2753 return 0; 2754} 2755 2756 2757void p2p_continue_find(struct p2p_data *p2p) 2758{ 2759 struct p2p_device *dev; 2760#ifdef ANDROID_P2P 2761 int skip=1; 2762#endif 2763 p2p_set_state(p2p, P2P_SEARCH); 2764 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 2765#ifdef ANDROID_P2P 2766 /* SD_FAIR_POLICY: We need to give chance to all devices in the device list 2767 * There may be a scenario, where a particular peer device have 2768 * not registered any query response. When we send a SD request to such device, 2769 * no response will be received. And if we continue to get probe responses from that device, 2770 * and if that device happens to be on top in our device list, 2771 * we will always continue to send SD requests always to that peer only. 2772 * We will not be able to send SD requests to other devices in that case. 2773 * This implementation keeps track of last serviced peer device. 2774 * And then takes the next one from the device list, in the next iteration. 2775 */ 2776 if (p2p->sd_dev_list && p2p->sd_dev_list != &p2p->devices) { 2777 if(skip) { 2778 if ((&dev->list == p2p->sd_dev_list) ) { 2779 skip = 0; 2780 if (dev->list.next == &p2p->devices) 2781 p2p->sd_dev_list = NULL; 2782 } 2783 continue; 2784 } 2785 } 2786 p2p->sd_dev_list = &dev->list; 2787 wpa_printf(MSG_DEBUG, "P2P: ### Servicing %p dev->flags 0x%x SD schedule %s devaddr " MACSTR, 2788 p2p->sd_dev_list, dev->flags, dev->flags & P2P_DEV_SD_SCHEDULE ? "TRUE": "FALSE", 2789 MAC2STR(dev->info.p2p_device_addr)); 2790#endif 2791 if (dev->flags & P2P_DEV_SD_SCHEDULE) { 2792 if (p2p_start_sd(p2p, dev) == 0) 2793 return; 2794 else 2795 break; 2796 } else if (dev->req_config_methods && 2797 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) { 2798 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send " 2799 "pending Provision Discovery Request to " 2800 MACSTR " (config methods 0x%x)", 2801 MAC2STR(dev->info.p2p_device_addr), 2802 dev->req_config_methods); 2803 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0) 2804 return; 2805 } 2806 } 2807 2808 p2p_listen_in_find(p2p, 1); 2809} 2810 2811 2812static void p2p_sd_cb(struct p2p_data *p2p, int success) 2813{ 2814 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2815 "P2P: Service Discovery Query TX callback: success=%d", 2816 success); 2817 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 2818 2819 if (!success) { 2820 if (p2p->sd_peer) { 2821 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE; 2822 p2p->sd_peer = NULL; 2823 } 2824 p2p_continue_find(p2p); 2825 return; 2826 } 2827 2828 if (p2p->sd_peer == NULL) { 2829 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2830 "P2P: No SD peer entry known"); 2831 p2p_continue_find(p2p); 2832 return; 2833 } 2834 2835 /* Wait for response from the peer */ 2836 p2p_set_state(p2p, P2P_SD_DURING_FIND); 2837 p2p_set_timeout(p2p, 0, 200000); 2838} 2839 2840 2841/** 2842 * p2p_retry_pd - Retry any pending provision disc requests in IDLE state 2843 * @p2p: P2P module context from p2p_init() 2844 */ 2845static void p2p_retry_pd(struct p2p_data *p2p) 2846{ 2847 struct p2p_device *dev; 2848 2849 if (p2p->state != P2P_IDLE) 2850 return; 2851 2852 /* 2853 * Retry the prov disc req attempt only for the peer that the user had 2854 * requested. 2855 */ 2856 2857 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 2858 if (os_memcmp(p2p->pending_pd_devaddr, 2859 dev->info.p2p_device_addr, ETH_ALEN) != 0) 2860 continue; 2861 if (!dev->req_config_methods) 2862 continue; 2863 2864 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send " 2865 "pending Provision Discovery Request to " 2866 MACSTR " (config methods 0x%x)", 2867 MAC2STR(dev->info.p2p_device_addr), 2868 dev->req_config_methods); 2869 p2p_send_prov_disc_req(p2p, dev, 2870 dev->flags & P2P_DEV_PD_FOR_JOIN, 0); 2871 return; 2872 } 2873} 2874 2875 2876static void p2p_prov_disc_cb(struct p2p_data *p2p, int success) 2877{ 2878 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 2879 "P2P: Provision Discovery Request TX callback: success=%d", 2880 success); 2881 2882 /* 2883 * Postpone resetting the pending action state till after we actually 2884 * time out. This allows us to take some action like notifying any 2885 * interested parties about no response to the request. 2886 * 2887 * When the timer (below) goes off we check in IDLE, SEARCH, or 2888 * LISTEN_ONLY state, which are the only allowed states to issue a PD 2889 * requests in, if this was still pending and then raise notification. 2890 */ 2891 2892 if (!success) { 2893 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 2894 2895 if (p2p->user_initiated_pd && 2896 (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY)) 2897 { 2898 /* Retry request from timeout to avoid busy loops */ 2899 p2p->pending_action_state = P2P_PENDING_PD; 2900 p2p_set_timeout(p2p, 0, 50000); 2901 } else if (p2p->state != P2P_IDLE) 2902 p2p_continue_find(p2p); 2903 else if (p2p->user_initiated_pd) { 2904 p2p->pending_action_state = P2P_PENDING_PD; 2905#ifdef ANDROID_P2P 2906 p2p_set_timeout(p2p, 0, 350000); 2907#else 2908 p2p_set_timeout(p2p, 0, 300000); 2909#endif 2910 } 2911 return; 2912 } 2913 2914 /* 2915 * This postponing, of resetting pending_action_state, needs to be 2916 * done only for user initiated PD requests and not internal ones. 2917 */ 2918 if (p2p->user_initiated_pd) 2919 p2p->pending_action_state = P2P_PENDING_PD; 2920 else 2921 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 2922 2923 /* Wait for response from the peer */ 2924 if (p2p->state == P2P_SEARCH) 2925 p2p_set_state(p2p, P2P_PD_DURING_FIND); 2926#ifdef ANDROID_P2P 2927 p2p_set_timeout(p2p, 0, 350000); 2928#else 2929 p2p_set_timeout(p2p, 0, 200000); 2930#endif 2931} 2932 2933 2934int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq, 2935 struct os_time *rx_time, int level, const u8 *ies, 2936 size_t ies_len) 2937{ 2938 if (os_time_before(rx_time, &p2p->find_start)) { 2939 /* 2940 * The driver may have cached (e.g., in cfg80211 BSS table) the 2941 * scan results for relatively long time. To avoid reporting 2942 * stale information, update P2P peers only based on results 2943 * that have based on frames received after the last p2p_find 2944 * operation was started. 2945 */ 2946 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Ignore old scan " 2947 "result for " MACSTR " (rx_time=%u.%06u)", 2948 MAC2STR(bssid), (unsigned int) rx_time->sec, 2949 (unsigned int) rx_time->usec); 2950 return 0; 2951 } 2952 2953 p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1); 2954 2955 return 0; 2956} 2957 2958 2959void p2p_scan_res_handled(struct p2p_data *p2p) 2960{ 2961 if (!p2p->p2p_scan_running) { 2962 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan was not " 2963 "running, but scan results received"); 2964 } 2965 p2p->p2p_scan_running = 0; 2966 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 2967 2968 if (p2p_run_after_scan(p2p)) 2969 return; 2970 if (p2p->state == P2P_SEARCH) 2971 p2p_continue_find(p2p); 2972} 2973 2974 2975void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id) 2976{ 2977 u8 *len; 2978 2979#ifdef CONFIG_WIFI_DISPLAY 2980 if (p2p->wfd_ie_probe_req) 2981 wpabuf_put_buf(ies, p2p->wfd_ie_probe_req); 2982#endif /* CONFIG_WIFI_DISPLAY */ 2983 2984 len = p2p_buf_add_ie_hdr(ies); 2985 p2p_buf_add_capability(ies, p2p->dev_capab & 2986 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0); 2987 if (dev_id) 2988 p2p_buf_add_device_id(ies, dev_id); 2989 if (p2p->cfg->reg_class && p2p->cfg->channel) 2990 p2p_buf_add_listen_channel(ies, p2p->cfg->country, 2991 p2p->cfg->reg_class, 2992 p2p->cfg->channel); 2993 if (p2p->ext_listen_interval) 2994 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period, 2995 p2p->ext_listen_interval); 2996 /* TODO: p2p_buf_add_operating_channel() if GO */ 2997 p2p_buf_update_ie_hdr(ies, len); 2998} 2999 3000 3001size_t p2p_scan_ie_buf_len(struct p2p_data *p2p) 3002{ 3003 size_t len = 100; 3004 3005#ifdef CONFIG_WIFI_DISPLAY 3006 if (p2p && p2p->wfd_ie_probe_req) 3007 len += wpabuf_len(p2p->wfd_ie_probe_req); 3008#endif /* CONFIG_WIFI_DISPLAY */ 3009 3010 return len; 3011} 3012 3013 3014int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end) 3015{ 3016 return p2p_attr_text(p2p_ie, buf, end); 3017} 3018 3019 3020static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success) 3021{ 3022 struct p2p_device *dev = p2p->go_neg_peer; 3023 int timeout; 3024 3025 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3026 "P2P: GO Negotiation Request TX callback: success=%d", 3027 success); 3028 3029 if (dev == NULL) { 3030 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3031 "P2P: No pending GO Negotiation"); 3032 return; 3033 } 3034 3035 if (success) { 3036 if (dev->flags & P2P_DEV_USER_REJECTED) { 3037 p2p_set_state(p2p, P2P_IDLE); 3038 return; 3039 } 3040 } else if (dev->go_neg_req_sent) { 3041 /* Cancel the increment from p2p_connect_send() on failure */ 3042 dev->go_neg_req_sent--; 3043 } 3044 3045 if (!success && 3046 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) && 3047 !is_zero_ether_addr(dev->member_in_go_dev)) { 3048 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3049 "P2P: Peer " MACSTR " did not acknowledge request - " 3050 "try to use device discoverability through its GO", 3051 MAC2STR(dev->info.p2p_device_addr)); 3052 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3053 p2p_send_dev_disc_req(p2p, dev); 3054 return; 3055 } 3056 3057 /* 3058 * Use P2P find, if needed, to find the other device from its listen 3059 * channel. 3060 */ 3061 p2p_set_state(p2p, P2P_CONNECT); 3062 timeout = success ? 500000 : 100000; 3063 if (!success && p2p->go_neg_peer && 3064 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) { 3065 unsigned int r; 3066 /* 3067 * Peer is expected to wait our response and we will skip the 3068 * listen phase. Add some randomness to the wait time here to 3069 * make it less likely to hit cases where we could end up in 3070 * sync with peer not listening. 3071 */ 3072 os_get_random((u8 *) &r, sizeof(r)); 3073 timeout += r % 100000; 3074 } 3075 p2p_set_timeout(p2p, 0, timeout); 3076} 3077 3078 3079static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success) 3080{ 3081 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3082 "P2P: GO Negotiation Response TX callback: success=%d", 3083 success); 3084 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) { 3085 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3086 "P2P: Ignore TX callback event - GO Negotiation is " 3087 "not running anymore"); 3088 return; 3089 } 3090 p2p_set_state(p2p, P2P_CONNECT); 3091 p2p_set_timeout(p2p, 0, 500000); 3092} 3093 3094 3095static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success, 3096 const u8 *addr) 3097{ 3098 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3099 "P2P: GO Negotiation Response (failure) TX callback: " 3100 "success=%d", success); 3101 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) { 3102 p2p_go_neg_failed(p2p, p2p->go_neg_peer, 3103 p2p->go_neg_peer->status); 3104 } else if (success) { 3105 struct p2p_device *dev; 3106 dev = p2p_get_device(p2p, addr); 3107 if (dev && 3108 dev->status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) 3109 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE; 3110 } 3111} 3112 3113 3114static void p2p_go_neg_conf_cb(struct p2p_data *p2p, 3115 enum p2p_send_action_result result) 3116{ 3117 struct p2p_device *dev; 3118 3119 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3120 "P2P: GO Negotiation Confirm TX callback: result=%d", 3121 result); 3122 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3123 if (result == P2P_SEND_ACTION_FAILED) { 3124 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1); 3125 return; 3126 } 3127 if (result == P2P_SEND_ACTION_NO_ACK) { 3128 /* 3129 * It looks like the TX status for GO Negotiation Confirm is 3130 * often showing failure even when the peer has actually 3131 * received the frame. Since the peer may change channels 3132 * immediately after having received the frame, we may not see 3133 * an Ack for retries, so just dropping a single frame may 3134 * trigger this. To allow the group formation to succeed if the 3135 * peer did indeed receive the frame, continue regardless of 3136 * the TX status. 3137 */ 3138 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3139 "P2P: Assume GO Negotiation Confirm TX was actually " 3140 "received by the peer even though Ack was not " 3141 "reported"); 3142 } 3143 3144 dev = p2p->go_neg_peer; 3145 if (dev == NULL) 3146 return; 3147 3148 p2p_go_complete(p2p, dev); 3149} 3150 3151 3152void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst, 3153 const u8 *src, const u8 *bssid, 3154 enum p2p_send_action_result result) 3155{ 3156 enum p2p_pending_action_state state; 3157 int success; 3158 3159 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3160 "P2P: Action frame TX callback (state=%d freq=%u dst=" MACSTR 3161 " src=" MACSTR " bssid=" MACSTR " result=%d", 3162 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src), 3163 MAC2STR(bssid), result); 3164 success = result == P2P_SEND_ACTION_SUCCESS; 3165 state = p2p->pending_action_state; 3166 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3167 switch (state) { 3168 case P2P_NO_PENDING_ACTION: 3169 if (p2p->after_scan_tx_in_progress) { 3170 p2p->after_scan_tx_in_progress = 0; 3171 if (p2p->start_after_scan != P2P_AFTER_SCAN_NOTHING && 3172 p2p_run_after_scan(p2p)) 3173 break; 3174 if (p2p->state == P2P_SEARCH) { 3175 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3176 "P2P: Continue find after " 3177 "after_scan_tx completion"); 3178 p2p_continue_find(p2p); 3179 } 3180 } 3181 break; 3182 case P2P_PENDING_GO_NEG_REQUEST: 3183 p2p_go_neg_req_cb(p2p, success); 3184 break; 3185 case P2P_PENDING_GO_NEG_RESPONSE: 3186 p2p_go_neg_resp_cb(p2p, success); 3187 break; 3188 case P2P_PENDING_GO_NEG_RESPONSE_FAILURE: 3189 p2p_go_neg_resp_failure_cb(p2p, success, dst); 3190 break; 3191 case P2P_PENDING_GO_NEG_CONFIRM: 3192 p2p_go_neg_conf_cb(p2p, result); 3193 break; 3194 case P2P_PENDING_SD: 3195 p2p_sd_cb(p2p, success); 3196 break; 3197 case P2P_PENDING_PD: 3198 p2p_prov_disc_cb(p2p, success); 3199 break; 3200 case P2P_PENDING_INVITATION_REQUEST: 3201 p2p_invitation_req_cb(p2p, success); 3202 break; 3203 case P2P_PENDING_INVITATION_RESPONSE: 3204 p2p_invitation_resp_cb(p2p, success); 3205 break; 3206 case P2P_PENDING_DEV_DISC_REQUEST: 3207 p2p_dev_disc_req_cb(p2p, success); 3208 break; 3209 case P2P_PENDING_DEV_DISC_RESPONSE: 3210 p2p_dev_disc_resp_cb(p2p, success); 3211 break; 3212 case P2P_PENDING_GO_DISC_REQ: 3213 p2p_go_disc_req_cb(p2p, success); 3214 break; 3215 } 3216 3217 p2p->after_scan_tx_in_progress = 0; 3218} 3219 3220 3221void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq, 3222 unsigned int duration) 3223{ 3224 if (freq == p2p->pending_client_disc_freq) { 3225 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3226 "P2P: Client discoverability remain-awake completed"); 3227 p2p->pending_client_disc_freq = 0; 3228 return; 3229 } 3230 3231 if (freq != p2p->pending_listen_freq) { 3232 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3233 "P2P: Unexpected listen callback for freq=%u " 3234 "duration=%u (pending_listen_freq=%u)", 3235 freq, duration, p2p->pending_listen_freq); 3236 return; 3237 } 3238 3239 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3240 "P2P: Starting Listen timeout(%u,%u) on freq=%u based on " 3241 "callback", 3242 p2p->pending_listen_sec, p2p->pending_listen_usec, 3243 p2p->pending_listen_freq); 3244 p2p->in_listen = 1; 3245 p2p->drv_in_listen = freq; 3246 if (p2p->pending_listen_sec || p2p->pending_listen_usec) { 3247 /* 3248 * Add 20 msec extra wait to avoid race condition with driver 3249 * remain-on-channel end event, i.e., give driver more time to 3250 * complete the operation before our timeout expires. 3251 */ 3252 p2p_set_timeout(p2p, p2p->pending_listen_sec, 3253 p2p->pending_listen_usec + 20000); 3254 } 3255 3256 p2p->pending_listen_freq = 0; 3257} 3258 3259 3260int p2p_listen_end(struct p2p_data *p2p, unsigned int freq) 3261{ 3262 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver ended Listen " 3263 "state (freq=%u)", freq); 3264 p2p->drv_in_listen = 0; 3265 if (p2p->in_listen) 3266 return 0; /* Internal timeout will trigger the next step */ 3267 3268 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) { 3269 if (p2p->go_neg_peer->connect_reqs >= 120) { 3270 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3271 "P2P: Timeout on sending GO Negotiation " 3272 "Request without getting response"); 3273 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1); 3274 return 0; 3275 } 3276 3277 p2p_set_state(p2p, P2P_CONNECT); 3278 p2p_connect_send(p2p, p2p->go_neg_peer); 3279 return 1; 3280 } else if (p2p->state == P2P_SEARCH) { 3281 if (p2p->p2p_scan_running) { 3282 /* 3283 * Search is already in progress. This can happen if 3284 * an Action frame RX is reported immediately after 3285 * the end of a remain-on-channel operation and the 3286 * response frame to that is sent using an offchannel 3287 * operation while in p2p_find. Avoid an attempt to 3288 * restart a scan here. 3289 */ 3290 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: p2p_scan " 3291 "already in progress - do not try to start a " 3292 "new one"); 3293 return 1; 3294 } 3295 if (p2p->pending_listen_freq) { 3296 /* 3297 * Better wait a bit if the driver is unable to start 3298 * offchannel operation for some reason. p2p_search() 3299 * will be started from internal timeout. 3300 */ 3301 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Listen " 3302 "operation did not seem to start - delay " 3303 "search phase to avoid busy loop"); 3304 p2p_set_timeout(p2p, 0, 100000); 3305 return 1; 3306 } 3307 if (p2p->search_delay) { 3308 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Delay " 3309 "search operation by %u ms", 3310 p2p->search_delay); 3311 p2p_set_timeout(p2p, p2p->search_delay / 1000, 3312 (p2p->search_delay % 1000) * 1000); 3313 return 1; 3314 } 3315 p2p_search(p2p); 3316 return 1; 3317 } 3318 3319 return 0; 3320} 3321 3322 3323static void p2p_timeout_connect(struct p2p_data *p2p) 3324{ 3325 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3326 if (p2p->go_neg_peer && 3327 (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { 3328 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Wait for GO " 3329 "Negotiation Confirm timed out - assume GO " 3330 "Negotiation failed"); 3331 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1); 3332 return; 3333 } 3334 if (p2p->go_neg_peer && 3335 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) && 3336 p2p->go_neg_peer->connect_reqs < 120) { 3337 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer expected to " 3338 "wait our response - skip listen"); 3339 p2p_connect_send(p2p, p2p->go_neg_peer); 3340 return; 3341 } 3342 3343 p2p_set_state(p2p, P2P_CONNECT_LISTEN); 3344 p2p_listen_in_find(p2p, 0); 3345} 3346 3347 3348static void p2p_timeout_connect_listen(struct p2p_data *p2p) 3349{ 3350 if (p2p->go_neg_peer) { 3351 if (p2p->drv_in_listen) { 3352 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Driver is " 3353 "still in Listen state; wait for it to " 3354 "complete"); 3355 return; 3356 } 3357 3358 if (p2p->go_neg_peer->connect_reqs >= 120) { 3359 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3360 "P2P: Timeout on sending GO Negotiation " 3361 "Request without getting response"); 3362 p2p_go_neg_failed(p2p, p2p->go_neg_peer, -1); 3363 return; 3364 } 3365 3366 p2p_set_state(p2p, P2P_CONNECT); 3367 p2p_connect_send(p2p, p2p->go_neg_peer); 3368 } else 3369 p2p_set_state(p2p, P2P_IDLE); 3370} 3371 3372 3373static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p) 3374{ 3375 /* 3376 * TODO: could remain constantly in Listen state for some time if there 3377 * are no other concurrent uses for the radio. For now, go to listen 3378 * state once per second to give other uses a chance to use the radio. 3379 */ 3380 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE); 3381 p2p_set_timeout(p2p, 0, 500000); 3382} 3383 3384 3385static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p) 3386{ 3387 struct p2p_device *dev = p2p->go_neg_peer; 3388 3389 if (dev == NULL) { 3390 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3391 "P2P: Unknown GO Neg peer - stop GO Neg wait"); 3392 return; 3393 } 3394 3395 dev->wait_count++; 3396 if (dev->wait_count >= 120) { 3397 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3398 "P2P: Timeout on waiting peer to become ready for GO " 3399 "Negotiation"); 3400 p2p_go_neg_failed(p2p, dev, -1); 3401 return; 3402 } 3403 3404 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3405 "P2P: Go to Listen state while waiting for the peer to become " 3406 "ready for GO Negotiation"); 3407 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT); 3408 p2p_listen_in_find(p2p, 0); 3409} 3410 3411 3412static void p2p_timeout_sd_during_find(struct p2p_data *p2p) 3413{ 3414 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3415 "P2P: Service Discovery Query timeout"); 3416 if (p2p->sd_peer) { 3417 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3418 p2p->sd_peer->flags &= ~P2P_DEV_SD_SCHEDULE; 3419 p2p->sd_peer = NULL; 3420 } 3421 p2p_continue_find(p2p); 3422} 3423 3424 3425static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p) 3426{ 3427 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3428 "P2P: Provision Discovery Request timeout"); 3429 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3430 p2p_continue_find(p2p); 3431} 3432 3433 3434static void p2p_timeout_prov_disc_req(struct p2p_data *p2p) 3435{ 3436 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3437 3438 /* 3439 * For user initiated PD requests that we have not gotten any responses 3440 * for while in IDLE state, we retry them a couple of times before 3441 * giving up. 3442 */ 3443 if (!p2p->user_initiated_pd) 3444 return; 3445 3446 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3447 "P2P: User initiated Provision Discovery Request timeout"); 3448 3449 if (p2p->pd_retries) { 3450 p2p->pd_retries--; 3451 p2p_retry_pd(p2p); 3452 } else { 3453 struct p2p_device *dev; 3454 int for_join = 0; 3455 3456 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 3457 if (os_memcmp(p2p->pending_pd_devaddr, 3458 dev->info.p2p_device_addr, ETH_ALEN) != 0) 3459 continue; 3460 if (dev->req_config_methods && 3461 (dev->flags & P2P_DEV_PD_FOR_JOIN)) 3462 for_join = 1; 3463 } 3464 3465 if (p2p->cfg->prov_disc_fail) 3466 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, 3467 p2p->pending_pd_devaddr, 3468 for_join ? 3469 P2P_PROV_DISC_TIMEOUT_JOIN : 3470 P2P_PROV_DISC_TIMEOUT); 3471 p2p_reset_pending_pd(p2p); 3472 } 3473} 3474 3475 3476static void p2p_timeout_invite(struct p2p_data *p2p) 3477{ 3478 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3479 p2p_set_state(p2p, P2P_INVITE_LISTEN); 3480 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) { 3481 /* 3482 * Better remain on operating channel instead of listen channel 3483 * when running a group. 3484 */ 3485 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Inviting in " 3486 "active GO role - wait on operating channel"); 3487 p2p_set_timeout(p2p, 0, 100000); 3488 return; 3489 } 3490 p2p_listen_in_find(p2p, 0); 3491} 3492 3493 3494static void p2p_timeout_invite_listen(struct p2p_data *p2p) 3495{ 3496 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) { 3497 p2p_set_state(p2p, P2P_INVITE); 3498 p2p_invite_send(p2p, p2p->invite_peer, 3499 p2p->invite_go_dev_addr); 3500 } else { 3501 if (p2p->invite_peer) { 3502 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3503 "P2P: Invitation Request retry limit reached"); 3504 if (p2p->cfg->invitation_result) 3505 p2p->cfg->invitation_result( 3506 p2p->cfg->cb_ctx, -1, NULL, NULL, 3507 p2p->invite_peer->info.p2p_device_addr); 3508 } 3509 p2p_set_state(p2p, P2P_IDLE); 3510 } 3511} 3512 3513 3514static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx) 3515{ 3516 struct p2p_data *p2p = eloop_ctx; 3517 3518 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Timeout (state=%s)", 3519 p2p_state_txt(p2p->state)); 3520 3521 p2p->in_listen = 0; 3522 3523 switch (p2p->state) { 3524 case P2P_IDLE: 3525 /* Check if we timed out waiting for PD req */ 3526 if (p2p->pending_action_state == P2P_PENDING_PD) 3527 p2p_timeout_prov_disc_req(p2p); 3528 break; 3529 case P2P_SEARCH: 3530 /* Check if we timed out waiting for PD req */ 3531 if (p2p->pending_action_state == P2P_PENDING_PD) 3532 p2p_timeout_prov_disc_req(p2p); 3533 if (p2p->search_delay && !p2p->in_search_delay) { 3534 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Delay " 3535 "search operation by %u ms", 3536 p2p->search_delay); 3537 p2p->in_search_delay = 1; 3538 p2p_set_timeout(p2p, p2p->search_delay / 1000, 3539 (p2p->search_delay % 1000) * 1000); 3540 break; 3541 } 3542 p2p->in_search_delay = 0; 3543 p2p_search(p2p); 3544 break; 3545 case P2P_CONNECT: 3546 p2p_timeout_connect(p2p); 3547 break; 3548 case P2P_CONNECT_LISTEN: 3549 p2p_timeout_connect_listen(p2p); 3550 break; 3551 case P2P_GO_NEG: 3552 break; 3553 case P2P_LISTEN_ONLY: 3554 /* Check if we timed out waiting for PD req */ 3555 if (p2p->pending_action_state == P2P_PENDING_PD) 3556 p2p_timeout_prov_disc_req(p2p); 3557 3558 if (p2p->ext_listen_only) { 3559 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3560 "P2P: Extended Listen Timing - Listen State " 3561 "completed"); 3562 p2p->ext_listen_only = 0; 3563 p2p_set_state(p2p, P2P_IDLE); 3564 } 3565 break; 3566 case P2P_WAIT_PEER_CONNECT: 3567 p2p_timeout_wait_peer_connect(p2p); 3568 break; 3569 case P2P_WAIT_PEER_IDLE: 3570 p2p_timeout_wait_peer_idle(p2p); 3571 break; 3572 case P2P_SD_DURING_FIND: 3573 p2p_timeout_sd_during_find(p2p); 3574 break; 3575 case P2P_PROVISIONING: 3576 break; 3577 case P2P_PD_DURING_FIND: 3578 p2p_timeout_prov_disc_during_find(p2p); 3579 break; 3580 case P2P_INVITE: 3581 p2p_timeout_invite(p2p); 3582 break; 3583 case P2P_INVITE_LISTEN: 3584 p2p_timeout_invite_listen(p2p); 3585 break; 3586 case P2P_SEARCH_WHEN_READY: 3587 break; 3588 case P2P_CONTINUE_SEARCH_WHEN_READY: 3589 break; 3590 } 3591} 3592 3593 3594int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr) 3595{ 3596 struct p2p_device *dev; 3597 3598 dev = p2p_get_device(p2p, peer_addr); 3599 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Local request to reject " 3600 "connection attempts by peer " MACSTR, MAC2STR(peer_addr)); 3601 if (dev == NULL) { 3602 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Peer " MACSTR 3603 " unknown", MAC2STR(peer_addr)); 3604 return -1; 3605 } 3606 dev->status = P2P_SC_FAIL_REJECTED_BY_USER; 3607 dev->flags |= P2P_DEV_USER_REJECTED; 3608 return 0; 3609} 3610 3611 3612const char * p2p_wps_method_text(enum p2p_wps_method method) 3613{ 3614 switch (method) { 3615 case WPS_NOT_READY: 3616 return "not-ready"; 3617 case WPS_PIN_DISPLAY: 3618 return "Display"; 3619 case WPS_PIN_KEYPAD: 3620 return "Keypad"; 3621 case WPS_PBC: 3622 return "PBC"; 3623 } 3624 3625 return "??"; 3626} 3627 3628 3629static const char * p2p_go_state_text(enum p2p_go_state go_state) 3630{ 3631 switch (go_state) { 3632 case UNKNOWN_GO: 3633 return "unknown"; 3634 case LOCAL_GO: 3635 return "local"; 3636 case REMOTE_GO: 3637 return "remote"; 3638 } 3639 3640 return "??"; 3641} 3642 3643 3644const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p, 3645 const u8 *addr, int next) 3646{ 3647 struct p2p_device *dev; 3648 3649 if (addr) 3650 dev = p2p_get_device(p2p, addr); 3651 else 3652 dev = dl_list_first(&p2p->devices, struct p2p_device, list); 3653 3654 if (dev && next) { 3655 dev = dl_list_first(&dev->list, struct p2p_device, list); 3656 if (&dev->list == &p2p->devices) 3657 dev = NULL; 3658 } 3659 3660 if (dev == NULL) 3661 return NULL; 3662 3663 return &dev->info; 3664} 3665 3666 3667int p2p_get_peer_info_txt(const struct p2p_peer_info *info, 3668 char *buf, size_t buflen) 3669{ 3670 struct p2p_device *dev; 3671 int res; 3672 char *pos, *end; 3673 struct os_time now; 3674 3675 if (info == NULL) 3676 return -1; 3677 3678 dev = (struct p2p_device *) (((u8 *) info) - 3679 offsetof(struct p2p_device, info)); 3680 3681 pos = buf; 3682 end = buf + buflen; 3683 3684 os_get_time(&now); 3685 res = os_snprintf(pos, end - pos, 3686 "age=%d\n" 3687 "listen_freq=%d\n" 3688 "wps_method=%s\n" 3689 "interface_addr=" MACSTR "\n" 3690 "member_in_go_dev=" MACSTR "\n" 3691 "member_in_go_iface=" MACSTR "\n" 3692 "go_neg_req_sent=%d\n" 3693 "go_state=%s\n" 3694 "dialog_token=%u\n" 3695 "intended_addr=" MACSTR "\n" 3696 "country=%c%c\n" 3697 "oper_freq=%d\n" 3698 "req_config_methods=0x%x\n" 3699 "flags=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n" 3700 "status=%d\n" 3701 "wait_count=%u\n" 3702 "invitation_reqs=%u\n", 3703 (int) (now.sec - dev->last_seen.sec), 3704 dev->listen_freq, 3705 p2p_wps_method_text(dev->wps_method), 3706 MAC2STR(dev->interface_addr), 3707 MAC2STR(dev->member_in_go_dev), 3708 MAC2STR(dev->member_in_go_iface), 3709 dev->go_neg_req_sent, 3710 p2p_go_state_text(dev->go_state), 3711 dev->dialog_token, 3712 MAC2STR(dev->intended_addr), 3713 dev->country[0] ? dev->country[0] : '_', 3714 dev->country[1] ? dev->country[1] : '_', 3715 dev->oper_freq, 3716 dev->req_config_methods, 3717 dev->flags & P2P_DEV_PROBE_REQ_ONLY ? 3718 "[PROBE_REQ_ONLY]" : "", 3719 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "", 3720 dev->flags & P2P_DEV_NOT_YET_READY ? 3721 "[NOT_YET_READY]" : "", 3722 dev->flags & P2P_DEV_SD_INFO ? "[SD_INFO]" : "", 3723 dev->flags & P2P_DEV_SD_SCHEDULE ? "[SD_SCHEDULE]" : 3724 "", 3725 dev->flags & P2P_DEV_PD_PEER_DISPLAY ? 3726 "[PD_PEER_DISPLAY]" : "", 3727 dev->flags & P2P_DEV_PD_PEER_KEYPAD ? 3728 "[PD_PEER_KEYPAD]" : "", 3729 dev->flags & P2P_DEV_USER_REJECTED ? 3730 "[USER_REJECTED]" : "", 3731 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ? 3732 "[PEER_WAITING_RESPONSE]" : "", 3733 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ? 3734 "[PREFER_PERSISTENT_GROUP]" : "", 3735 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ? 3736 "[WAIT_GO_NEG_RESPONSE]" : "", 3737 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ? 3738 "[WAIT_GO_NEG_CONFIRM]" : "", 3739 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ? 3740 "[GROUP_CLIENT_ONLY]" : "", 3741 dev->flags & P2P_DEV_FORCE_FREQ ? 3742 "[FORCE_FREQ]" : "", 3743 dev->flags & P2P_DEV_PD_FOR_JOIN ? 3744 "[PD_FOR_JOIN]" : "", 3745 dev->status, 3746 dev->wait_count, 3747 dev->invitation_reqs); 3748 if (res < 0 || res >= end - pos) 3749 return pos - buf; 3750 pos += res; 3751 3752 if (dev->ext_listen_period) { 3753 res = os_snprintf(pos, end - pos, 3754 "ext_listen_period=%u\n" 3755 "ext_listen_interval=%u\n", 3756 dev->ext_listen_period, 3757 dev->ext_listen_interval); 3758 if (res < 0 || res >= end - pos) 3759 return pos - buf; 3760 pos += res; 3761 } 3762 3763 if (dev->oper_ssid_len) { 3764 res = os_snprintf(pos, end - pos, 3765 "oper_ssid=%s\n", 3766 wpa_ssid_txt(dev->oper_ssid, 3767 dev->oper_ssid_len)); 3768 if (res < 0 || res >= end - pos) 3769 return pos - buf; 3770 pos += res; 3771 } 3772 3773#ifdef CONFIG_WIFI_DISPLAY 3774 if (dev->info.wfd_subelems) { 3775 res = os_snprintf(pos, end - pos, "wfd_subelems="); 3776 if (res < 0 || res >= end - pos) 3777 return pos - buf; 3778 pos += res; 3779 3780 pos += wpa_snprintf_hex(pos, end - pos, 3781 wpabuf_head(dev->info.wfd_subelems), 3782 wpabuf_len(dev->info.wfd_subelems)); 3783 3784 res = os_snprintf(pos, end - pos, "\n"); 3785 if (res < 0 || res >= end - pos) 3786 return pos - buf; 3787 pos += res; 3788 } 3789#endif /* CONFIG_WIFI_DISPLAY */ 3790 3791 return pos - buf; 3792} 3793 3794 3795int p2p_peer_known(struct p2p_data *p2p, const u8 *addr) 3796{ 3797 return p2p_get_device(p2p, addr) != NULL; 3798} 3799 3800 3801void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled) 3802{ 3803 if (enabled) { 3804 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Client " 3805 "discoverability enabled"); 3806 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 3807 } else { 3808 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Client " 3809 "discoverability disabled"); 3810 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 3811 } 3812} 3813 3814 3815static struct wpabuf * p2p_build_presence_req(u32 duration1, u32 interval1, 3816 u32 duration2, u32 interval2) 3817{ 3818 struct wpabuf *req; 3819 struct p2p_noa_desc desc1, desc2, *ptr1 = NULL, *ptr2 = NULL; 3820 u8 *len; 3821 3822 req = wpabuf_alloc(100); 3823 if (req == NULL) 3824 return NULL; 3825 3826 if (duration1 || interval1) { 3827 os_memset(&desc1, 0, sizeof(desc1)); 3828 desc1.count_type = 1; 3829 desc1.duration = duration1; 3830 desc1.interval = interval1; 3831 ptr1 = &desc1; 3832 3833 if (duration2 || interval2) { 3834 os_memset(&desc2, 0, sizeof(desc2)); 3835 desc2.count_type = 2; 3836 desc2.duration = duration2; 3837 desc2.interval = interval2; 3838 ptr2 = &desc2; 3839 } 3840 } 3841 3842 p2p_buf_add_action_hdr(req, P2P_PRESENCE_REQ, 1); 3843 len = p2p_buf_add_ie_hdr(req); 3844 p2p_buf_add_noa(req, 0, 0, 0, ptr1, ptr2); 3845 p2p_buf_update_ie_hdr(req, len); 3846 3847 return req; 3848} 3849 3850 3851int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr, 3852 const u8 *own_interface_addr, unsigned int freq, 3853 u32 duration1, u32 interval1, u32 duration2, 3854 u32 interval2) 3855{ 3856 struct wpabuf *req; 3857 3858 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Send Presence Request to " 3859 "GO " MACSTR " (own interface " MACSTR ") freq=%u dur1=%u " 3860 "int1=%u dur2=%u int2=%u", 3861 MAC2STR(go_interface_addr), MAC2STR(own_interface_addr), 3862 freq, duration1, interval1, duration2, interval2); 3863 3864 req = p2p_build_presence_req(duration1, interval1, duration2, 3865 interval2); 3866 if (req == NULL) 3867 return -1; 3868 3869 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3870 if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr, 3871 go_interface_addr, 3872 wpabuf_head(req), wpabuf_len(req), 200) < 0) { 3873 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3874 "P2P: Failed to send Action frame"); 3875 } 3876 wpabuf_free(req); 3877 3878 return 0; 3879} 3880 3881 3882static struct wpabuf * p2p_build_presence_resp(u8 status, const u8 *noa, 3883 size_t noa_len, u8 dialog_token) 3884{ 3885 struct wpabuf *resp; 3886 u8 *len; 3887 3888 resp = wpabuf_alloc(100 + noa_len); 3889 if (resp == NULL) 3890 return NULL; 3891 3892 p2p_buf_add_action_hdr(resp, P2P_PRESENCE_RESP, dialog_token); 3893 len = p2p_buf_add_ie_hdr(resp); 3894 p2p_buf_add_status(resp, status); 3895 if (noa) { 3896 wpabuf_put_u8(resp, P2P_ATTR_NOTICE_OF_ABSENCE); 3897 wpabuf_put_le16(resp, noa_len); 3898 wpabuf_put_data(resp, noa, noa_len); 3899 } else 3900 p2p_buf_add_noa(resp, 0, 0, 0, NULL, NULL); 3901 p2p_buf_update_ie_hdr(resp, len); 3902 3903 return resp; 3904} 3905 3906 3907static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da, 3908 const u8 *sa, const u8 *data, size_t len, 3909 int rx_freq) 3910{ 3911 struct p2p_message msg; 3912 u8 status; 3913 struct wpabuf *resp; 3914 size_t g; 3915 struct p2p_group *group = NULL; 3916 int parsed = 0; 3917 u8 noa[50]; 3918 int noa_len; 3919 3920 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3921 "P2P: Received P2P Action - P2P Presence Request"); 3922 3923 for (g = 0; g < p2p->num_groups; g++) { 3924 if (os_memcmp(da, p2p_group_get_interface_addr(p2p->groups[g]), 3925 ETH_ALEN) == 0) { 3926 group = p2p->groups[g]; 3927 break; 3928 } 3929 } 3930 if (group == NULL) { 3931 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3932 "P2P: Ignore P2P Presence Request for unknown group " 3933 MACSTR, MAC2STR(da)); 3934 return; 3935 } 3936 3937 if (p2p_parse(data, len, &msg) < 0) { 3938 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3939 "P2P: Failed to parse P2P Presence Request"); 3940 status = P2P_SC_FAIL_INVALID_PARAMS; 3941 goto fail; 3942 } 3943 parsed = 1; 3944 3945 if (msg.noa == NULL) { 3946 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3947 "P2P: No NoA attribute in P2P Presence Request"); 3948 status = P2P_SC_FAIL_INVALID_PARAMS; 3949 goto fail; 3950 } 3951 3952 status = p2p_group_presence_req(group, sa, msg.noa, msg.noa_len); 3953 3954fail: 3955 if (p2p->cfg->get_noa) 3956 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa, 3957 sizeof(noa)); 3958 else 3959 noa_len = -1; 3960 resp = p2p_build_presence_resp(status, noa_len > 0 ? noa : NULL, 3961 noa_len > 0 ? noa_len : 0, 3962 msg.dialog_token); 3963 if (parsed) 3964 p2p_parse_free(&msg); 3965 if (resp == NULL) 3966 return; 3967 3968 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3969 if (p2p_send_action(p2p, rx_freq, sa, da, da, 3970 wpabuf_head(resp), wpabuf_len(resp), 200) < 0) { 3971 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3972 "P2P: Failed to send Action frame"); 3973 } 3974 wpabuf_free(resp); 3975} 3976 3977 3978static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da, 3979 const u8 *sa, const u8 *data, size_t len) 3980{ 3981 struct p2p_message msg; 3982 3983 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3984 "P2P: Received P2P Action - P2P Presence Response"); 3985 3986 if (p2p_parse(data, len, &msg) < 0) { 3987 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3988 "P2P: Failed to parse P2P Presence Response"); 3989 return; 3990 } 3991 3992 if (msg.status == NULL || msg.noa == NULL) { 3993 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 3994 "P2P: No Status or NoA attribute in P2P Presence " 3995 "Response"); 3996 p2p_parse_free(&msg); 3997 return; 3998 } 3999 4000 if (*msg.status) { 4001 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 4002 "P2P: P2P Presence Request was rejected: status %u", 4003 *msg.status); 4004 p2p_parse_free(&msg); 4005 return; 4006 } 4007 4008 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 4009 "P2P: P2P Presence Request was accepted"); 4010 wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA", 4011 msg.noa, msg.noa_len); 4012 /* TODO: process NoA */ 4013 p2p_parse_free(&msg); 4014} 4015 4016 4017static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx) 4018{ 4019 struct p2p_data *p2p = eloop_ctx; 4020 4021 if (p2p->ext_listen_interval) { 4022 /* Schedule next extended listen timeout */ 4023 eloop_register_timeout(p2p->ext_listen_interval_sec, 4024 p2p->ext_listen_interval_usec, 4025 p2p_ext_listen_timeout, p2p, NULL); 4026 } 4027 4028 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) { 4029 /* 4030 * This should not really happen, but it looks like the Listen 4031 * command may fail is something else (e.g., a scan) was 4032 * running at an inconvenient time. As a workaround, allow new 4033 * Extended Listen operation to be started. 4034 */ 4035 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Previous " 4036 "Extended Listen operation had not been completed - " 4037 "try again"); 4038 p2p->ext_listen_only = 0; 4039 p2p_set_state(p2p, P2P_IDLE); 4040 } 4041 4042 if (p2p->state != P2P_IDLE) { 4043 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Skip Extended " 4044 "Listen timeout in active state (%s)", 4045 p2p_state_txt(p2p->state)); 4046 return; 4047 } 4048 4049 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Extended Listen timeout"); 4050 p2p->ext_listen_only = 1; 4051 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) { 4052 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Failed to start " 4053 "Listen state for Extended Listen Timing"); 4054 p2p->ext_listen_only = 0; 4055 } 4056} 4057 4058 4059int p2p_ext_listen(struct p2p_data *p2p, unsigned int period, 4060 unsigned int interval) 4061{ 4062 if (period > 65535 || interval > 65535 || period > interval || 4063 (period == 0 && interval > 0) || (period > 0 && interval == 0)) { 4064 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 4065 "P2P: Invalid Extended Listen Timing request: " 4066 "period=%u interval=%u", period, interval); 4067 return -1; 4068 } 4069 4070 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL); 4071 4072 if (interval == 0) { 4073 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 4074 "P2P: Disabling Extended Listen Timing"); 4075 p2p->ext_listen_period = 0; 4076 p2p->ext_listen_interval = 0; 4077 return 0; 4078 } 4079 4080 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, 4081 "P2P: Enabling Extended Listen Timing: period %u msec, " 4082 "interval %u msec", period, interval); 4083 p2p->ext_listen_period = period; 4084 p2p->ext_listen_interval = interval; 4085 p2p->ext_listen_interval_sec = interval / 1000; 4086 p2p->ext_listen_interval_usec = (interval % 1000) * 1000; 4087 4088 eloop_register_timeout(p2p->ext_listen_interval_sec, 4089 p2p->ext_listen_interval_usec, 4090 p2p_ext_listen_timeout, p2p, NULL); 4091 4092 return 0; 4093} 4094 4095 4096void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, 4097 const u8 *ie, size_t ie_len) 4098{ 4099 struct p2p_message msg; 4100 4101 if (bssid == NULL || ie == NULL) 4102 return; 4103 4104 os_memset(&msg, 0, sizeof(msg)); 4105 if (p2p_parse_ies(ie, ie_len, &msg)) 4106 return; 4107 if (msg.minor_reason_code == NULL) 4108 return; 4109 4110 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, 4111 "P2P: Deauthentication notification BSSID " MACSTR 4112 " reason_code=%u minor_reason_code=%u", 4113 MAC2STR(bssid), reason_code, *msg.minor_reason_code); 4114 4115 p2p_parse_free(&msg); 4116} 4117 4118 4119void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, 4120 const u8 *ie, size_t ie_len) 4121{ 4122 struct p2p_message msg; 4123 4124 if (bssid == NULL || ie == NULL) 4125 return; 4126 4127 os_memset(&msg, 0, sizeof(msg)); 4128 if (p2p_parse_ies(ie, ie_len, &msg)) 4129 return; 4130 if (msg.minor_reason_code == NULL) 4131 return; 4132 4133 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, 4134 "P2P: Disassociation notification BSSID " MACSTR 4135 " reason_code=%u minor_reason_code=%u", 4136 MAC2STR(bssid), reason_code, *msg.minor_reason_code); 4137 4138 p2p_parse_free(&msg); 4139} 4140 4141 4142void p2p_set_managed_oper(struct p2p_data *p2p, int enabled) 4143{ 4144 if (enabled) { 4145 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Managed P2P " 4146 "Device operations enabled"); 4147 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED; 4148 } else { 4149 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Managed P2P " 4150 "Device operations disabled"); 4151 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED; 4152 } 4153} 4154 4155 4156int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel) 4157{ 4158 if (p2p_channel_to_freq(reg_class, channel) < 0) 4159 return -1; 4160 4161 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Set Listen channel: " 4162 "reg_class %u channel %u", reg_class, channel); 4163 p2p->cfg->reg_class = reg_class; 4164 p2p->cfg->channel = channel; 4165 4166 return 0; 4167} 4168 4169 4170int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len) 4171{ 4172 wpa_hexdump_ascii(MSG_DEBUG, "P2P: New SSID postfix", postfix, len); 4173 if (postfix == NULL) { 4174 p2p->cfg->ssid_postfix_len = 0; 4175 return 0; 4176 } 4177 if (len > sizeof(p2p->cfg->ssid_postfix)) 4178 return -1; 4179 os_memcpy(p2p->cfg->ssid_postfix, postfix, len); 4180 p2p->cfg->ssid_postfix_len = len; 4181 return 0; 4182} 4183 4184 4185int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel, 4186 int cfg_op_channel) 4187{ 4188 if (p2p_channel_to_freq(op_reg_class, op_channel) < 0) 4189 return -1; 4190 4191 wpa_msg(p2p->cfg->msg_ctx, MSG_INFO, "P2P: Set Operating channel: " 4192 "reg_class %u channel %u", op_reg_class, op_channel); 4193 p2p->cfg->op_reg_class = op_reg_class; 4194 p2p->cfg->op_channel = op_channel; 4195 p2p->cfg->cfg_op_channel = cfg_op_channel; 4196 return 0; 4197} 4198 4199 4200int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan, 4201 const struct p2p_channel *pref_chan) 4202{ 4203 struct p2p_channel *n; 4204 4205 if (pref_chan) { 4206 n = os_malloc(num_pref_chan * sizeof(struct p2p_channel)); 4207 if (n == NULL) 4208 return -1; 4209 os_memcpy(n, pref_chan, 4210 num_pref_chan * sizeof(struct p2p_channel)); 4211 } else 4212 n = NULL; 4213 4214 os_free(p2p->cfg->pref_chan); 4215 p2p->cfg->pref_chan = n; 4216 p2p->cfg->num_pref_chan = num_pref_chan; 4217 4218 return 0; 4219} 4220 4221 4222int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr, 4223 u8 *iface_addr) 4224{ 4225 struct p2p_device *dev = p2p_get_device(p2p, dev_addr); 4226 if (dev == NULL || is_zero_ether_addr(dev->interface_addr)) 4227 return -1; 4228 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN); 4229 return 0; 4230} 4231 4232 4233int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr, 4234 u8 *dev_addr) 4235{ 4236 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr); 4237 if (dev == NULL) 4238 return -1; 4239 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN); 4240 return 0; 4241} 4242 4243 4244void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr) 4245{ 4246 os_memcpy(p2p->peer_filter, addr, ETH_ALEN); 4247 if (is_zero_ether_addr(p2p->peer_filter)) 4248 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Disable peer " 4249 "filter"); 4250 else 4251 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Enable peer " 4252 "filter for " MACSTR, MAC2STR(p2p->peer_filter)); 4253} 4254 4255 4256void p2p_set_cross_connect(struct p2p_data *p2p, int enabled) 4257{ 4258 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Cross connection %s", 4259 enabled ? "enabled" : "disabled"); 4260 if (p2p->cross_connect == enabled) 4261 return; 4262 p2p->cross_connect = enabled; 4263 /* TODO: may need to tear down any action group where we are GO(?) */ 4264} 4265 4266 4267int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr) 4268{ 4269 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr); 4270 if (dev == NULL) 4271 return -1; 4272 if (dev->oper_freq <= 0) 4273 return -1; 4274 return dev->oper_freq; 4275} 4276 4277 4278void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled) 4279{ 4280 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Intra BSS distribution %s", 4281 enabled ? "enabled" : "disabled"); 4282 p2p->cfg->p2p_intra_bss = enabled; 4283} 4284 4285 4286void p2p_update_channel_list(struct p2p_data *p2p, struct p2p_channels *chan) 4287{ 4288 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Update channel list"); 4289 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels)); 4290} 4291 4292 4293int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst, 4294 const u8 *src, const u8 *bssid, const u8 *buf, 4295 size_t len, unsigned int wait_time) 4296{ 4297 if (p2p->p2p_scan_running) { 4298 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Delay Action " 4299 "frame TX until p2p_scan completes"); 4300 if (p2p->after_scan_tx) { 4301 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Dropped " 4302 "previous pending Action frame TX"); 4303 os_free(p2p->after_scan_tx); 4304 } 4305 p2p->after_scan_tx = os_malloc(sizeof(*p2p->after_scan_tx) + 4306 len); 4307 if (p2p->after_scan_tx == NULL) 4308 return -1; 4309 p2p->after_scan_tx->freq = freq; 4310 os_memcpy(p2p->after_scan_tx->dst, dst, ETH_ALEN); 4311 os_memcpy(p2p->after_scan_tx->src, src, ETH_ALEN); 4312 os_memcpy(p2p->after_scan_tx->bssid, bssid, ETH_ALEN); 4313 p2p->after_scan_tx->len = len; 4314 p2p->after_scan_tx->wait_time = wait_time; 4315 os_memcpy(p2p->after_scan_tx + 1, buf, len); 4316 return 0; 4317 } 4318 4319 return p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid, 4320 buf, len, wait_time); 4321} 4322 4323 4324void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5, 4325 int freq_overall) 4326{ 4327 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Best channel: 2.4 GHz: %d," 4328 " 5 GHz: %d, overall: %d", freq_24, freq_5, freq_overall); 4329 p2p->best_freq_24 = freq_24; 4330 p2p->best_freq_5 = freq_5; 4331 p2p->best_freq_overall = freq_overall; 4332} 4333 4334 4335void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq) 4336{ 4337 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Own frequency preference: " 4338 "%d MHz", freq); 4339 p2p->own_freq_preference = freq; 4340} 4341 4342 4343const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p) 4344{ 4345 if (p2p == NULL || p2p->go_neg_peer == NULL) 4346 return NULL; 4347 return p2p->go_neg_peer->info.p2p_device_addr; 4348} 4349 4350 4351const struct p2p_peer_info * 4352p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next) 4353{ 4354 struct p2p_device *dev; 4355 4356 if (addr) { 4357 dev = p2p_get_device(p2p, addr); 4358 if (!dev) 4359 return NULL; 4360 4361 if (!next) { 4362 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) 4363 return NULL; 4364 4365 return &dev->info; 4366 } else { 4367 do { 4368 dev = dl_list_first(&dev->list, 4369 struct p2p_device, 4370 list); 4371 if (&dev->list == &p2p->devices) 4372 return NULL; 4373 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY); 4374 } 4375 } else { 4376 dev = dl_list_first(&p2p->devices, struct p2p_device, list); 4377 if (!dev) 4378 return NULL; 4379 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { 4380 dev = dl_list_first(&dev->list, 4381 struct p2p_device, 4382 list); 4383 if (&dev->list == &p2p->devices) 4384 return NULL; 4385 } 4386 } 4387 4388 return &dev->info; 4389} 4390 4391#ifdef ANDROID_P2P 4392int p2p_search_in_progress(struct p2p_data *p2p) 4393{ 4394 if (p2p == NULL) 4395 return 0; 4396 4397 return p2p->state == P2P_SEARCH; 4398} 4399#endif 4400 4401int p2p_in_progress(struct p2p_data *p2p) 4402{ 4403 if (p2p == NULL) 4404 return 0; 4405 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SEARCH_WHEN_READY || 4406 p2p->state == P2P_CONTINUE_SEARCH_WHEN_READY) 4407 return 2; 4408 return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING; 4409} 4410 4411 4412void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout, 4413 u8 client_timeout) 4414{ 4415 if (p2p) { 4416 p2p->go_timeout = go_timeout; 4417 p2p->client_timeout = client_timeout; 4418 } 4419} 4420 4421 4422void p2p_increase_search_delay(struct p2p_data *p2p, unsigned int delay) 4423{ 4424 if (p2p && p2p->search_delay < delay) 4425 p2p->search_delay = delay; 4426} 4427 4428 4429#ifdef CONFIG_WIFI_DISPLAY 4430 4431static void p2p_update_wfd_ie_groups(struct p2p_data *p2p) 4432{ 4433 size_t g; 4434 struct p2p_group *group; 4435 4436 for (g = 0; g < p2p->num_groups; g++) { 4437 group = p2p->groups[g]; 4438 p2p_group_update_ies(group); 4439 } 4440} 4441 4442 4443int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie) 4444{ 4445 wpabuf_free(p2p->wfd_ie_beacon); 4446 p2p->wfd_ie_beacon = ie; 4447 p2p_update_wfd_ie_groups(p2p); 4448 return 0; 4449} 4450 4451 4452int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie) 4453{ 4454 wpabuf_free(p2p->wfd_ie_probe_req); 4455 p2p->wfd_ie_probe_req = ie; 4456 return 0; 4457} 4458 4459 4460int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie) 4461{ 4462 wpabuf_free(p2p->wfd_ie_probe_resp); 4463 p2p->wfd_ie_probe_resp = ie; 4464 p2p_update_wfd_ie_groups(p2p); 4465 return 0; 4466} 4467 4468 4469int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie) 4470{ 4471 wpabuf_free(p2p->wfd_ie_assoc_req); 4472 p2p->wfd_ie_assoc_req = ie; 4473 return 0; 4474} 4475 4476 4477int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie) 4478{ 4479 wpabuf_free(p2p->wfd_ie_invitation); 4480 p2p->wfd_ie_invitation = ie; 4481 return 0; 4482} 4483 4484 4485int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie) 4486{ 4487 wpabuf_free(p2p->wfd_ie_prov_disc_req); 4488 p2p->wfd_ie_prov_disc_req = ie; 4489 return 0; 4490} 4491 4492 4493int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie) 4494{ 4495 wpabuf_free(p2p->wfd_ie_prov_disc_resp); 4496 p2p->wfd_ie_prov_disc_resp = ie; 4497 return 0; 4498} 4499 4500 4501int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie) 4502{ 4503 wpabuf_free(p2p->wfd_ie_go_neg); 4504 p2p->wfd_ie_go_neg = ie; 4505 return 0; 4506} 4507 4508 4509int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem) 4510{ 4511 wpabuf_free(p2p->wfd_dev_info); 4512 if (elem) { 4513 p2p->wfd_dev_info = wpabuf_dup(elem); 4514 if (p2p->wfd_dev_info == NULL) 4515 return -1; 4516 } else 4517 p2p->wfd_dev_info = NULL; 4518 4519 return 0; 4520} 4521 4522 4523int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem) 4524{ 4525 wpabuf_free(p2p->wfd_assoc_bssid); 4526 if (elem) { 4527 p2p->wfd_assoc_bssid = wpabuf_dup(elem); 4528 if (p2p->wfd_assoc_bssid == NULL) 4529 return -1; 4530 } else 4531 p2p->wfd_assoc_bssid = NULL; 4532 4533 return 0; 4534} 4535 4536 4537int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p, 4538 const struct wpabuf *elem) 4539{ 4540 wpabuf_free(p2p->wfd_coupled_sink_info); 4541 if (elem) { 4542 p2p->wfd_coupled_sink_info = wpabuf_dup(elem); 4543 if (p2p->wfd_coupled_sink_info == NULL) 4544 return -1; 4545 } else 4546 p2p->wfd_coupled_sink_info = NULL; 4547 4548 return 0; 4549} 4550 4551#endif /* CONFIG_WIFI_DISPLAY */ 4552 4553 4554int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int, 4555 int max_disc_tu) 4556{ 4557 if (min_disc_int > max_disc_int || min_disc_int < 0 || max_disc_int < 0) 4558 return -1; 4559 4560 p2p->min_disc_int = min_disc_int; 4561 p2p->max_disc_int = max_disc_int; 4562 p2p->max_disc_tu = max_disc_tu; 4563 wpa_msg(p2p->cfg->msg_ctx, MSG_DEBUG, "P2P: Set discoverable interval: " 4564 "min=%d max=%d max_tu=%d", min_disc_int, max_disc_int, 4565 max_disc_tu); 4566 4567 return 0; 4568} 4569