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