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