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