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