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