1 /* 2 * Wi-Fi Direct - P2P module 3 * Copyright (c) 2009-2010, Atheros Communications 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #include "includes.h" 10 11 #include "common.h" 12 #include "eloop.h" 13 #include "common/defs.h" 14 #include "common/ieee802_11_defs.h" 15 #include "common/ieee802_11_common.h" 16 #include "common/wpa_common.h" 17 #include "common/wpa_ctrl.h" 18 #include "common/sae.h" 19 #include "crypto/sha256.h" 20 #include "crypto/sha384.h" 21 #include "crypto/crypto.h" 22 #include "pasn/pasn_common.h" 23 #include "wps/wps_i.h" 24 #include "p2p_i.h" 25 #include "p2p.h" 26 27 28 static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx); 29 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev); 30 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da, 31 const u8 *sa, const u8 *data, size_t len, 32 int rx_freq); 33 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da, 34 const u8 *sa, const u8 *data, 35 size_t len); 36 static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx); 37 static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx); 38 39 40 /* 41 * p2p_scan recovery timeout 42 * 43 * Many drivers are using 30 second timeout on scan results. Allow a bit larger 44 * timeout for this to avoid hitting P2P timeout unnecessarily. 45 */ 46 #define P2P_SCAN_TIMEOUT 35 47 48 /** 49 * P2P_PEER_EXPIRATION_AGE - Number of seconds after which inactive peer 50 * entries will be removed 51 */ 52 #ifndef P2P_PEER_EXPIRATION_AGE 53 #define P2P_PEER_EXPIRATION_AGE 60 54 #endif /* P2P_PEER_EXPIRATION_AGE */ 55 56 p2p_expire_peers(struct p2p_data * p2p)57 void p2p_expire_peers(struct p2p_data *p2p) 58 { 59 struct p2p_device *dev, *n; 60 struct os_reltime now; 61 size_t i; 62 63 os_get_reltime(&now); 64 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) { 65 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec) 66 continue; 67 68 if (dev == p2p->go_neg_peer) { 69 /* 70 * GO Negotiation is in progress with the peer, so 71 * don't expire the peer entry until GO Negotiation 72 * fails or times out. 73 */ 74 continue; 75 } 76 77 if (p2p->cfg->go_connected && 78 p2p->cfg->go_connected(p2p->cfg->cb_ctx, 79 dev->info.p2p_device_addr)) { 80 /* 81 * We are connected as a client to a group in which the 82 * peer is the GO, so do not expire the peer entry. 83 */ 84 os_get_reltime(&dev->last_seen); 85 continue; 86 } 87 88 for (i = 0; i < p2p->num_groups; i++) { 89 if (p2p_group_is_client_connected( 90 p2p->groups[i], dev->info.p2p_device_addr)) 91 break; 92 } 93 if (i < p2p->num_groups) { 94 /* 95 * The peer is connected as a client in a group where 96 * we are the GO, so do not expire the peer entry. 97 */ 98 os_get_reltime(&dev->last_seen); 99 continue; 100 } 101 102 p2p_dbg(p2p, "Expiring old peer entry " MACSTR, 103 MAC2STR(dev->info.p2p_device_addr)); 104 dl_list_del(&dev->list); 105 p2p_device_free(p2p, dev); 106 } 107 } 108 109 p2p_state_txt(int state)110 static const char * p2p_state_txt(int state) 111 { 112 switch (state) { 113 case P2P_IDLE: 114 return "IDLE"; 115 case P2P_SEARCH: 116 return "SEARCH"; 117 case P2P_CONNECT: 118 return "CONNECT"; 119 case P2P_CONNECT_LISTEN: 120 return "CONNECT_LISTEN"; 121 case P2P_GO_NEG: 122 return "GO_NEG"; 123 case P2P_LISTEN_ONLY: 124 return "LISTEN_ONLY"; 125 case P2P_WAIT_PEER_CONNECT: 126 return "WAIT_PEER_CONNECT"; 127 case P2P_WAIT_PEER_IDLE: 128 return "WAIT_PEER_IDLE"; 129 case P2P_SD_DURING_FIND: 130 return "SD_DURING_FIND"; 131 case P2P_PROVISIONING: 132 return "PROVISIONING"; 133 case P2P_PD_DURING_FIND: 134 return "PD_DURING_FIND"; 135 case P2P_INVITE: 136 return "INVITE"; 137 case P2P_INVITE_LISTEN: 138 return "INVITE_LISTEN"; 139 default: 140 return "?"; 141 } 142 } 143 144 p2p_get_state_txt(struct p2p_data * p2p)145 const char * p2p_get_state_txt(struct p2p_data *p2p) 146 { 147 return p2p_state_txt(p2p->state); 148 } 149 150 p2p_get_p2ps_adv_list(struct p2p_data * p2p)151 struct p2ps_advertisement * p2p_get_p2ps_adv_list(struct p2p_data *p2p) 152 { 153 return p2p ? p2p->p2ps_adv_list : NULL; 154 } 155 156 p2p_set_intended_addr(struct p2p_data * p2p,const u8 * intended_addr)157 void p2p_set_intended_addr(struct p2p_data *p2p, const u8 *intended_addr) 158 { 159 if (p2p && intended_addr) 160 os_memcpy(p2p->intended_addr, intended_addr, ETH_ALEN); 161 } 162 163 p2p_get_provisioning_info(struct p2p_data * p2p,const u8 * addr)164 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr) 165 { 166 struct p2p_device *dev = NULL; 167 168 if (!addr || !p2p) 169 return 0; 170 171 dev = p2p_get_device(p2p, addr); 172 if (dev) 173 return dev->wps_prov_info; 174 else 175 return 0; 176 } 177 178 p2p_clear_provisioning_info(struct p2p_data * p2p,const u8 * addr)179 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *addr) 180 { 181 struct p2p_device *dev = NULL; 182 183 if (!addr || !p2p) 184 return; 185 186 dev = p2p_get_device(p2p, addr); 187 if (dev) 188 dev->wps_prov_info = 0; 189 } 190 191 p2p_set_state(struct p2p_data * p2p,int new_state)192 void p2p_set_state(struct p2p_data *p2p, int new_state) 193 { 194 p2p_dbg(p2p, "State %s -> %s", 195 p2p_state_txt(p2p->state), p2p_state_txt(new_state)); 196 p2p->state = new_state; 197 198 if (new_state == P2P_IDLE && p2p->pending_channel) { 199 p2p_dbg(p2p, "Apply change in listen channel"); 200 p2p->cfg->reg_class = p2p->pending_reg_class; 201 p2p->cfg->channel = p2p->pending_channel; 202 p2p->pending_reg_class = 0; 203 p2p->pending_channel = 0; 204 } 205 } 206 207 p2p_set_timeout(struct p2p_data * p2p,unsigned int sec,unsigned int usec)208 void p2p_set_timeout(struct p2p_data *p2p, unsigned int sec, unsigned int usec) 209 { 210 p2p_dbg(p2p, "Set timeout (state=%s): %u.%06u sec", 211 p2p_state_txt(p2p->state), sec, usec); 212 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL); 213 eloop_register_timeout(sec, usec, p2p_state_timeout, p2p, NULL); 214 } 215 216 p2p_clear_timeout(struct p2p_data * p2p)217 void p2p_clear_timeout(struct p2p_data *p2p) 218 { 219 p2p_dbg(p2p, "Clear timeout (state=%s)", p2p_state_txt(p2p->state)); 220 eloop_cancel_timeout(p2p_state_timeout, p2p, NULL); 221 } 222 223 p2p_go_neg_failed(struct p2p_data * p2p,int status)224 void p2p_go_neg_failed(struct p2p_data *p2p, int status) 225 { 226 struct p2p_go_neg_results res; 227 struct p2p_device *peer = p2p->go_neg_peer; 228 229 if (!peer) 230 return; 231 232 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL); 233 if (p2p->state != P2P_SEARCH) { 234 /* 235 * Clear timeouts related to GO Negotiation if no new p2p_find 236 * has been started. 237 */ 238 p2p_clear_timeout(p2p); 239 p2p_set_state(p2p, P2P_IDLE); 240 } 241 242 peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; 243 peer->wps_method = WPS_NOT_READY; 244 peer->oob_pw_id = 0; 245 wpabuf_free(peer->go_neg_conf); 246 peer->go_neg_conf = NULL; 247 p2p->go_neg_peer = NULL; 248 249 #ifdef CONFIG_PASN 250 if (peer->p2p2 && peer->pasn) 251 wpa_pasn_reset(peer->pasn); 252 os_memset(p2p->dev_sae_password, 0, sizeof(p2p->dev_sae_password)); 253 os_memset(p2p->peer_sae_password, 0, sizeof(p2p->peer_sae_password)); 254 #endif /* CONFIG_PASN */ 255 256 os_memset(&res, 0, sizeof(res)); 257 res.status = status; 258 res.p2p2 = peer->p2p2; 259 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN); 260 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN); 261 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res); 262 } 263 264 p2p_listen_in_find(struct p2p_data * p2p,int dev_disc)265 static void p2p_listen_in_find(struct p2p_data *p2p, int dev_disc) 266 { 267 unsigned int r, tu; 268 int freq; 269 struct wpabuf *ies; 270 271 p2p_dbg(p2p, "Starting short listen state (state=%s)", 272 p2p_state_txt(p2p->state)); 273 274 if (p2p->pending_listen_freq) { 275 /* We have a pending p2p_listen request */ 276 p2p_dbg(p2p, "p2p_listen command pending already"); 277 return; 278 } 279 280 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel); 281 if (freq < 0) { 282 p2p_dbg(p2p, "Unknown regulatory class/channel"); 283 return; 284 } 285 286 if (os_get_random((u8 *) &r, sizeof(r)) < 0) 287 r = 0; 288 tu = (r % ((p2p->max_disc_int - p2p->min_disc_int) + 1) + 289 p2p->min_disc_int) * 100; 290 if (p2p->max_disc_tu >= 0 && tu > (unsigned int) p2p->max_disc_tu) 291 tu = p2p->max_disc_tu; 292 if (!dev_disc && tu < 100) 293 tu = 100; /* Need to wait in non-device discovery use cases */ 294 if (p2p->cfg->max_listen && 1024 * tu / 1000 > p2p->cfg->max_listen) 295 tu = p2p->cfg->max_listen * 1000 / 1024; 296 297 if (tu == 0) { 298 p2p_dbg(p2p, "Skip listen state since duration was 0 TU"); 299 p2p_set_timeout(p2p, 0, 0); 300 return; 301 } 302 303 ies = p2p_build_probe_resp_ies(p2p, NULL, 0); 304 if (ies == NULL) 305 return; 306 307 p2p->pending_listen_freq = freq; 308 p2p->pending_listen_sec = 0; 309 p2p->pending_listen_usec = 1024 * tu; 310 311 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, 1024 * tu / 1000, 312 ies) < 0) { 313 p2p_dbg(p2p, "Failed to start listen mode"); 314 p2p->pending_listen_freq = 0; 315 } else { 316 p2p->pending_listen_wait_drv = true; 317 } 318 wpabuf_free(ies); 319 } 320 321 p2p_listen(struct p2p_data * p2p,unsigned int timeout)322 int p2p_listen(struct p2p_data *p2p, unsigned int timeout) 323 { 324 int freq; 325 struct wpabuf *ies; 326 327 p2p_dbg(p2p, "Going to listen(only) state"); 328 329 if (p2p->pending_listen_freq) { 330 /* We have a pending p2p_listen request */ 331 p2p_dbg(p2p, "p2p_listen command pending already"); 332 return -1; 333 } 334 335 freq = p2p_channel_to_freq(p2p->cfg->reg_class, p2p->cfg->channel); 336 if (freq < 0) { 337 p2p_dbg(p2p, "Unknown regulatory class/channel"); 338 return -1; 339 } 340 341 p2p->pending_listen_sec = timeout / 1000; 342 p2p->pending_listen_usec = (timeout % 1000) * 1000; 343 344 if (p2p->p2p_scan_running) { 345 if (p2p->start_after_scan == P2P_AFTER_SCAN_CONNECT) { 346 p2p_dbg(p2p, "p2p_scan running - connect is already pending - skip listen"); 347 return 0; 348 } 349 p2p_dbg(p2p, "p2p_scan running - delay start of listen state"); 350 p2p->start_after_scan = P2P_AFTER_SCAN_LISTEN; 351 return 0; 352 } 353 354 ies = p2p_build_probe_resp_ies(p2p, NULL, 0); 355 if (ies == NULL) 356 return -1; 357 358 p2p->pending_listen_freq = freq; 359 360 if (p2p->cfg->start_listen(p2p->cfg->cb_ctx, freq, timeout, ies) < 0) { 361 p2p_dbg(p2p, "Failed to start listen mode"); 362 p2p->pending_listen_freq = 0; 363 wpabuf_free(ies); 364 return -1; 365 } 366 p2p->pending_listen_wait_drv = true; 367 wpabuf_free(ies); 368 369 p2p_set_state(p2p, P2P_LISTEN_ONLY); 370 371 return 0; 372 } 373 374 p2p_device_clear_reported(struct p2p_data * p2p)375 static void p2p_device_clear_reported(struct p2p_data *p2p) 376 { 377 struct p2p_device *dev; 378 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 379 dev->flags &= ~P2P_DEV_REPORTED; 380 dev->sd_reqs = 0; 381 } 382 } 383 384 385 /** 386 * p2p_get_device - Fetch a peer entry 387 * @p2p: P2P module context from p2p_init() 388 * @addr: P2P Device Address of the peer 389 * Returns: Pointer to the device entry or %NULL if not found 390 */ p2p_get_device(struct p2p_data * p2p,const u8 * addr)391 struct p2p_device * p2p_get_device(struct p2p_data *p2p, const u8 *addr) 392 { 393 struct p2p_device *dev; 394 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 395 if (ether_addr_equal(dev->info.p2p_device_addr, addr)) 396 return dev; 397 } 398 return NULL; 399 } 400 401 402 /** 403 * p2p_get_device_interface - Fetch a peer entry based on P2P Interface Address 404 * @p2p: P2P module context from p2p_init() 405 * @addr: P2P Interface Address of the peer 406 * Returns: Pointer to the device entry or %NULL if not found 407 */ p2p_get_device_interface(struct p2p_data * p2p,const u8 * addr)408 struct p2p_device * p2p_get_device_interface(struct p2p_data *p2p, 409 const u8 *addr) 410 { 411 struct p2p_device *dev; 412 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 413 if (ether_addr_equal(dev->interface_addr, addr)) 414 return dev; 415 } 416 return NULL; 417 } 418 419 420 /** 421 * p2p_create_device - Create a peer entry 422 * @p2p: P2P module context from p2p_init() 423 * @addr: P2P Device Address of the peer 424 * Returns: Pointer to the device entry or %NULL on failure 425 * 426 * If there is already an entry for the peer, it will be returned instead of 427 * creating a new one. 428 */ p2p_create_device(struct p2p_data * p2p,const u8 * addr)429 static struct p2p_device * p2p_create_device(struct p2p_data *p2p, 430 const u8 *addr) 431 { 432 struct p2p_device *dev, *oldest = NULL; 433 size_t count = 0; 434 435 dev = p2p_get_device(p2p, addr); 436 if (dev) 437 return dev; 438 439 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 440 count++; 441 if (oldest == NULL || 442 os_reltime_before(&dev->last_seen, &oldest->last_seen)) 443 oldest = dev; 444 } 445 if (count + 1 > p2p->cfg->max_peers && oldest) { 446 p2p_dbg(p2p, 447 "Remove oldest peer entry to make room for a new peer " 448 MACSTR, MAC2STR(oldest->info.p2p_device_addr)); 449 dl_list_del(&oldest->list); 450 p2p_device_free(p2p, oldest); 451 } 452 453 dev = os_zalloc(sizeof(*dev)); 454 if (dev == NULL) 455 return NULL; 456 dl_list_add(&p2p->devices, &dev->list); 457 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN); 458 dev->support_6ghz = false; 459 460 return dev; 461 } 462 463 p2p_copy_client_info(struct p2p_device * dev,struct p2p_client_info * cli)464 static void p2p_copy_client_info(struct p2p_device *dev, 465 struct p2p_client_info *cli) 466 { 467 p2p_copy_filter_devname(dev->info.device_name, 468 sizeof(dev->info.device_name), 469 cli->dev_name, cli->dev_name_len); 470 dev->info.dev_capab = cli->dev_capab; 471 dev->info.config_methods = cli->config_methods; 472 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8); 473 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types; 474 if (dev->info.wps_sec_dev_type_list_len > WPS_SEC_DEV_TYPE_MAX_LEN) 475 dev->info.wps_sec_dev_type_list_len = WPS_SEC_DEV_TYPE_MAX_LEN; 476 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types, 477 dev->info.wps_sec_dev_type_list_len); 478 } 479 480 p2p_add_group_clients(struct p2p_data * p2p,const u8 * go_dev_addr,const u8 * go_interface_addr,int freq,const u8 * gi,size_t gi_len,struct os_reltime * rx_time)481 static int p2p_add_group_clients(struct p2p_data *p2p, const u8 *go_dev_addr, 482 const u8 *go_interface_addr, int freq, 483 const u8 *gi, size_t gi_len, 484 struct os_reltime *rx_time) 485 { 486 struct p2p_group_info info; 487 size_t c; 488 struct p2p_device *dev; 489 490 if (gi == NULL) 491 return 0; 492 493 if (p2p_group_info_parse(gi, gi_len, &info) < 0) 494 return -1; 495 496 /* 497 * Clear old data for this group; if the devices are still in the 498 * group, the information will be restored in the loop following this. 499 */ 500 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 501 if (ether_addr_equal(dev->member_in_go_iface, 502 go_interface_addr)) { 503 os_memset(dev->member_in_go_iface, 0, ETH_ALEN); 504 os_memset(dev->member_in_go_dev, 0, ETH_ALEN); 505 } 506 } 507 508 for (c = 0; c < info.num_clients; c++) { 509 struct p2p_client_info *cli = &info.client[c]; 510 if (ether_addr_equal(cli->p2p_device_addr, p2p->cfg->dev_addr)) 511 continue; /* ignore our own entry */ 512 dev = p2p_get_device(p2p, cli->p2p_device_addr); 513 if (dev) { 514 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY | 515 P2P_DEV_PROBE_REQ_ONLY)) { 516 /* 517 * Update information since we have not 518 * received this directly from the client. 519 */ 520 p2p_copy_client_info(dev, cli); 521 } else { 522 /* 523 * Need to update P2P Client Discoverability 524 * flag since it is valid only in P2P Group 525 * Info attribute. 526 */ 527 dev->info.dev_capab &= 528 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 529 dev->info.dev_capab |= 530 cli->dev_capab & 531 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 532 } 533 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { 534 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY; 535 } 536 } else { 537 dev = p2p_create_device(p2p, cli->p2p_device_addr); 538 if (dev == NULL) 539 continue; 540 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY; 541 p2p_copy_client_info(dev, cli); 542 dev->oper_freq = freq; 543 p2p->cfg->dev_found(p2p->cfg->cb_ctx, 544 dev->info.p2p_device_addr, 545 &dev->info, 1); 546 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 547 } 548 549 os_memcpy(dev->interface_addr, cli->p2p_interface_addr, 550 ETH_ALEN); 551 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime)); 552 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN); 553 os_memcpy(dev->member_in_go_iface, go_interface_addr, 554 ETH_ALEN); 555 dev->flags |= P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT; 556 } 557 558 return 0; 559 } 560 561 p2p_copy_wps_info(struct p2p_data * p2p,struct p2p_device * dev,int probe_req,const struct p2p_message * msg)562 static void p2p_copy_wps_info(struct p2p_data *p2p, struct p2p_device *dev, 563 int probe_req, const struct p2p_message *msg) 564 { 565 os_memcpy(dev->info.device_name, msg->device_name, 566 sizeof(dev->info.device_name)); 567 568 if (msg->manufacturer && 569 msg->manufacturer_len < sizeof(dev->info.manufacturer)) { 570 os_memset(dev->info.manufacturer, 0, 571 sizeof(dev->info.manufacturer)); 572 os_memcpy(dev->info.manufacturer, msg->manufacturer, 573 msg->manufacturer_len); 574 } 575 576 if (msg->model_name && 577 msg->model_name_len < sizeof(dev->info.model_name)) { 578 os_memset(dev->info.model_name, 0, 579 sizeof(dev->info.model_name)); 580 os_memcpy(dev->info.model_name, msg->model_name, 581 msg->model_name_len); 582 } 583 584 if (msg->model_number && 585 msg->model_number_len < sizeof(dev->info.model_number)) { 586 os_memset(dev->info.model_number, 0, 587 sizeof(dev->info.model_number)); 588 os_memcpy(dev->info.model_number, msg->model_number, 589 msg->model_number_len); 590 } 591 592 if (msg->serial_number && 593 msg->serial_number_len < sizeof(dev->info.serial_number)) { 594 os_memset(dev->info.serial_number, 0, 595 sizeof(dev->info.serial_number)); 596 os_memcpy(dev->info.serial_number, msg->serial_number, 597 msg->serial_number_len); 598 } 599 600 if (msg->pri_dev_type) 601 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type, 602 sizeof(dev->info.pri_dev_type)); 603 else if (msg->wps_pri_dev_type) 604 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type, 605 sizeof(dev->info.pri_dev_type)); 606 607 if (msg->wps_sec_dev_type_list) { 608 os_memcpy(dev->info.wps_sec_dev_type_list, 609 msg->wps_sec_dev_type_list, 610 msg->wps_sec_dev_type_list_len); 611 dev->info.wps_sec_dev_type_list_len = 612 msg->wps_sec_dev_type_list_len; 613 } 614 615 if (msg->capability) { 616 /* 617 * P2P Client Discoverability bit is reserved in all frames 618 * that use this function, so do not change its value here. 619 */ 620 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 621 dev->info.dev_capab |= msg->capability[0] & 622 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 623 dev->info.group_capab = msg->capability[1]; 624 } 625 626 p2p_update_peer_6ghz_capab(dev, msg); 627 628 if (msg->ext_listen_timing) { 629 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing); 630 dev->ext_listen_interval = 631 WPA_GET_LE16(msg->ext_listen_timing + 2); 632 } 633 634 if (!probe_req) { 635 u16 new_config_methods; 636 new_config_methods = msg->config_methods ? 637 msg->config_methods : msg->wps_config_methods; 638 if (new_config_methods && 639 dev->info.config_methods != new_config_methods) { 640 p2p_dbg(p2p, "Update peer " MACSTR 641 " config_methods 0x%x -> 0x%x", 642 MAC2STR(dev->info.p2p_device_addr), 643 dev->info.config_methods, 644 new_config_methods); 645 dev->info.config_methods = new_config_methods; 646 } 647 } 648 } 649 650 p2p_update_peer_6ghz_capab(struct p2p_device * dev,const struct p2p_message * msg)651 void p2p_update_peer_6ghz_capab(struct p2p_device *dev, 652 const struct p2p_message *msg) 653 { 654 if (msg->capability && 655 (msg->capability[0] & P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE)) 656 dev->support_6ghz = true; 657 } 658 659 p2p_update_peer_vendor_elems(struct p2p_device * dev,const u8 * ies,size_t ies_len)660 static void p2p_update_peer_vendor_elems(struct p2p_device *dev, const u8 *ies, 661 size_t ies_len) 662 { 663 const u8 *pos, *end; 664 u8 id, len; 665 666 wpabuf_free(dev->info.vendor_elems); 667 dev->info.vendor_elems = NULL; 668 669 end = ies + ies_len; 670 671 for (pos = ies; end - pos > 1; pos += len) { 672 id = *pos++; 673 len = *pos++; 674 675 if (len > end - pos) 676 break; 677 678 if (id != WLAN_EID_VENDOR_SPECIFIC || len < 3) 679 continue; 680 681 if (len >= 4) { 682 u32 type = WPA_GET_BE32(pos); 683 684 if (type == WPA_IE_VENDOR_TYPE || 685 type == WMM_IE_VENDOR_TYPE || 686 type == WPS_IE_VENDOR_TYPE || 687 type == P2P_IE_VENDOR_TYPE || 688 type == WFD_IE_VENDOR_TYPE) 689 continue; 690 } 691 692 /* Unknown vendor element - make raw IE data available */ 693 if (wpabuf_resize(&dev->info.vendor_elems, 2 + len) < 0) 694 break; 695 wpabuf_put_data(dev->info.vendor_elems, pos - 2, 2 + len); 696 if (wpabuf_size(dev->info.vendor_elems) > 2000) 697 break; 698 } 699 } 700 701 p2p_compare_wfd_info(struct p2p_device * dev,const struct p2p_message * msg)702 static int p2p_compare_wfd_info(struct p2p_device *dev, 703 const struct p2p_message *msg) 704 { 705 if (dev->info.wfd_subelems && msg->wfd_subelems) { 706 if (dev->info.wfd_subelems->used != msg->wfd_subelems->used) 707 return 1; 708 709 return os_memcmp(dev->info.wfd_subelems->buf, 710 msg->wfd_subelems->buf, 711 dev->info.wfd_subelems->used); 712 } 713 if (dev->info.wfd_subelems || msg->wfd_subelems) 714 return 1; 715 716 return 0; 717 } 718 719 720 /** 721 * p2p_add_device - Add peer entries based on scan results or P2P frames 722 * @p2p: P2P module context from p2p_init() 723 * @addr: Source address of Beacon or Probe Response frame (may be either 724 * P2P Device Address or P2P Interface Address) 725 * @level: Signal level (signal strength of the received frame from the peer) 726 * @freq: Frequency on which the Beacon or Probe Response frame was received 727 * @rx_time: Time when the result was received 728 * @ies: IEs from the Beacon or Probe Response frame 729 * @ies_len: Length of ies buffer in octets 730 * @scan_res: Whether this was based on scan results 731 * Returns: 0 on success, -1 on failure 732 * 733 * If the scan result is for a GO, the clients in the group will also be added 734 * to the peer table. This function can also be used with some other frames 735 * like Provision Discovery Request that contains P2P Capability and P2P Device 736 * Info attributes. 737 */ p2p_add_device(struct p2p_data * p2p,const u8 * addr,int freq,struct os_reltime * rx_time,int level,const u8 * ies,size_t ies_len,int scan_res)738 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq, 739 struct os_reltime *rx_time, int level, const u8 *ies, 740 size_t ies_len, int scan_res) 741 { 742 struct p2p_device *dev; 743 struct p2p_message msg; 744 const u8 *p2p_dev_addr; 745 int wfd_changed; 746 int dev_name_changed; 747 int i; 748 struct os_reltime time_now; 749 750 os_memset(&msg, 0, sizeof(msg)); 751 if (p2p_parse_ies(ies, ies_len, &msg)) { 752 p2p_dbg(p2p, "Failed to parse P2P IE for a device entry"); 753 p2p_parse_free(&msg); 754 return -1; 755 } 756 757 if (msg.p2p_device_addr) 758 p2p_dev_addr = msg.p2p_device_addr; 759 else if (msg.device_id) 760 p2p_dev_addr = msg.device_id; 761 else { 762 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id"); 763 p2p_parse_free(&msg); 764 return -1; 765 } 766 767 if (!is_zero_ether_addr(p2p->peer_filter) && 768 !ether_addr_equal(p2p_dev_addr, p2p->peer_filter)) { 769 p2p_dbg(p2p, "Do not add peer filter for " MACSTR 770 " due to peer filter", MAC2STR(p2p_dev_addr)); 771 p2p_parse_free(&msg); 772 return 0; 773 } 774 775 dev = p2p_create_device(p2p, p2p_dev_addr); 776 if (dev == NULL) { 777 p2p_parse_free(&msg); 778 return -1; 779 } 780 781 if (rx_time == NULL) { 782 os_get_reltime(&time_now); 783 rx_time = &time_now; 784 } 785 786 /* 787 * Update the device entry only if the new peer 788 * entry is newer than the one previously stored, or if 789 * the device was previously seen as a P2P Client in a group 790 * and the new entry isn't older than a threshold. 791 */ 792 if (dev->last_seen.sec > 0 && 793 os_reltime_before(rx_time, &dev->last_seen) && 794 (!(dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT) || 795 os_reltime_expired(&dev->last_seen, rx_time, 796 P2P_DEV_GROUP_CLIENT_RESP_THRESHOLD))) { 797 p2p_dbg(p2p, 798 "Do not update peer entry based on old frame (rx_time=%u.%06u last_seen=%u.%06u flags=0x%x)", 799 (unsigned int) rx_time->sec, 800 (unsigned int) rx_time->usec, 801 (unsigned int) dev->last_seen.sec, 802 (unsigned int) dev->last_seen.usec, 803 dev->flags); 804 p2p_parse_free(&msg); 805 return -1; 806 } 807 808 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_reltime)); 809 810 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY | 811 P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT); 812 813 if (!ether_addr_equal(addr, p2p_dev_addr)) 814 os_memcpy(dev->interface_addr, addr, ETH_ALEN); 815 if (msg.ssid && 816 msg.ssid[1] <= sizeof(dev->oper_ssid) && 817 (msg.ssid[1] != P2P_WILDCARD_SSID_LEN || 818 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) 819 != 0)) { 820 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]); 821 dev->oper_ssid_len = msg.ssid[1]; 822 } 823 824 wpabuf_free(dev->info.p2ps_instance); 825 dev->info.p2ps_instance = NULL; 826 if (msg.adv_service_instance && msg.adv_service_instance_len) 827 dev->info.p2ps_instance = wpabuf_alloc_copy( 828 msg.adv_service_instance, msg.adv_service_instance_len); 829 830 if (freq >= 2412 && freq <= 2484 && msg.ds_params && 831 *msg.ds_params >= 1 && *msg.ds_params <= 14) { 832 int ds_freq; 833 if (*msg.ds_params == 14) 834 ds_freq = 2484; 835 else 836 ds_freq = 2407 + *msg.ds_params * 5; 837 if (freq != ds_freq) { 838 p2p_dbg(p2p, "Update Listen frequency based on DS Parameter Set IE: %d -> %d MHz", 839 freq, ds_freq); 840 freq = ds_freq; 841 } 842 } 843 844 if (dev->listen_freq && dev->listen_freq != freq && scan_res) { 845 p2p_dbg(p2p, "Update Listen frequency based on scan results (" 846 MACSTR " %d -> %d MHz (DS param %d)", 847 MAC2STR(dev->info.p2p_device_addr), dev->listen_freq, 848 freq, msg.ds_params ? *msg.ds_params : -1); 849 } 850 if (scan_res) { 851 dev->listen_freq = freq; 852 if (msg.group_info) 853 dev->oper_freq = freq; 854 } 855 dev->info.level = level; 856 857 dev_name_changed = os_strncmp(dev->info.device_name, msg.device_name, 858 WPS_DEV_NAME_MAX_LEN) != 0; 859 860 p2p_copy_wps_info(p2p, dev, 0, &msg); 861 862 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 863 wpabuf_free(dev->info.wps_vendor_ext[i]); 864 dev->info.wps_vendor_ext[i] = NULL; 865 } 866 867 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 868 if (msg.wps_vendor_ext[i] == NULL) 869 break; 870 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy( 871 msg.wps_vendor_ext[i], msg.wps_vendor_ext_len[i]); 872 if (dev->info.wps_vendor_ext[i] == NULL) 873 break; 874 } 875 876 wfd_changed = p2p_compare_wfd_info(dev, &msg); 877 878 if (wfd_changed) { 879 wpabuf_free(dev->info.wfd_subelems); 880 if (msg.wfd_subelems) 881 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems); 882 else 883 dev->info.wfd_subelems = NULL; 884 } 885 886 if (scan_res) { 887 p2p_add_group_clients(p2p, p2p_dev_addr, addr, freq, 888 msg.group_info, msg.group_info_len, 889 rx_time); 890 } 891 892 p2p_parse_free(&msg); 893 894 p2p_update_peer_vendor_elems(dev, ies, ies_len); 895 896 if (dev->flags & P2P_DEV_REPORTED && !wfd_changed && 897 !dev_name_changed && 898 (!msg.adv_service_instance || 899 (dev->flags & P2P_DEV_P2PS_REPORTED))) 900 return 0; 901 902 p2p_dbg(p2p, "Peer found with Listen frequency %d MHz (rx_time=%u.%06u)", 903 freq, (unsigned int) rx_time->sec, 904 (unsigned int) rx_time->usec); 905 if (dev->flags & P2P_DEV_USER_REJECTED) { 906 p2p_dbg(p2p, "Do not report rejected device"); 907 return 0; 908 } 909 910 if (dev->info.config_methods == 0 && 911 (freq == 2412 || freq == 2437 || freq == 2462)) { 912 /* 913 * If we have only seen a Beacon frame from a GO, we do not yet 914 * know what WPS config methods it supports. Since some 915 * applications use config_methods value from P2P-DEVICE-FOUND 916 * events, postpone reporting this peer until we've fully 917 * discovered its capabilities. 918 * 919 * At least for now, do this only if the peer was detected on 920 * one of the social channels since that peer can be easily be 921 * found again and there are no limitations of having to use 922 * passive scan on this channels, so this can be done through 923 * Probe Response frame that includes the config_methods 924 * information. 925 */ 926 p2p_dbg(p2p, "Do not report peer " MACSTR 927 " with unknown config methods", MAC2STR(addr)); 928 return 0; 929 } 930 931 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info, 932 !(dev->flags & P2P_DEV_REPORTED_ONCE)); 933 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 934 935 if (msg.adv_service_instance) 936 dev->flags |= P2P_DEV_P2PS_REPORTED; 937 938 return 0; 939 } 940 941 p2p_device_free(struct p2p_data * p2p,struct p2p_device * dev)942 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev) 943 { 944 int i; 945 946 if (p2p->go_neg_peer == dev) { 947 /* 948 * If GO Negotiation is in progress, report that it has failed. 949 */ 950 p2p_go_neg_failed(p2p, -1); 951 } 952 if (p2p->invite_peer == dev) 953 p2p->invite_peer = NULL; 954 if (p2p->sd_peer == dev) 955 p2p->sd_peer = NULL; 956 if (p2p->pending_client_disc_go == dev) 957 p2p->pending_client_disc_go = NULL; 958 959 /* dev_lost() device, but only if it was previously dev_found() */ 960 if (dev->flags & P2P_DEV_REPORTED_ONCE) 961 p2p->cfg->dev_lost(p2p->cfg->cb_ctx, 962 dev->info.p2p_device_addr); 963 964 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 965 wpabuf_free(dev->info.wps_vendor_ext[i]); 966 dev->info.wps_vendor_ext[i] = NULL; 967 } 968 969 os_free(dev->bootstrap_params); 970 971 wpabuf_free(dev->action_frame_wrapper); 972 973 #ifdef CONFIG_PASN 974 if (dev->pasn) { 975 wpa_pasn_reset(dev->pasn); 976 pasn_data_deinit(dev->pasn); 977 } 978 #endif /* CONFIG_PASN */ 979 980 wpabuf_free(dev->info.wfd_subelems); 981 wpabuf_free(dev->info.vendor_elems); 982 wpabuf_free(dev->go_neg_conf); 983 wpabuf_free(dev->info.p2ps_instance); 984 985 os_free(dev); 986 } 987 988 p2p_get_next_prog_freq(struct p2p_data * p2p)989 static int p2p_get_next_prog_freq(struct p2p_data *p2p) 990 { 991 struct p2p_channels *c; 992 struct p2p_reg_class *cla; 993 size_t cl, ch; 994 int found = 0; 995 u8 reg_class; 996 u8 channel; 997 int freq; 998 999 c = &p2p->cfg->channels; 1000 for (cl = 0; cl < c->reg_classes; cl++) { 1001 cla = &c->reg_class[cl]; 1002 if (cla->reg_class != p2p->last_prog_scan_class) 1003 continue; 1004 for (ch = 0; ch < cla->channels; ch++) { 1005 if (cla->channel[ch] == p2p->last_prog_scan_chan) { 1006 found = 1; 1007 break; 1008 } 1009 } 1010 if (found) 1011 break; 1012 } 1013 1014 if (!found) { 1015 /* Start from beginning */ 1016 reg_class = c->reg_class[0].reg_class; 1017 channel = c->reg_class[0].channel[0]; 1018 } else { 1019 /* Pick the next channel */ 1020 ch++; 1021 if (ch == cla->channels) { 1022 cl++; 1023 if (cl == c->reg_classes) 1024 cl = 0; 1025 ch = 0; 1026 } 1027 reg_class = c->reg_class[cl].reg_class; 1028 channel = c->reg_class[cl].channel[ch]; 1029 } 1030 1031 freq = p2p_channel_to_freq(reg_class, channel); 1032 p2p_dbg(p2p, "Next progressive search channel: reg_class %u channel %u -> %d MHz", 1033 reg_class, channel, freq); 1034 p2p->last_prog_scan_class = reg_class; 1035 p2p->last_prog_scan_chan = channel; 1036 1037 if (freq == 2412 || freq == 2437 || freq == 2462) 1038 return 0; /* No need to add social channels */ 1039 return freq; 1040 } 1041 1042 p2p_search(struct p2p_data * p2p)1043 static void p2p_search(struct p2p_data *p2p) 1044 { 1045 int freq = 0; 1046 enum p2p_scan_type type; 1047 u16 pw_id = DEV_PW_DEFAULT; 1048 int res; 1049 1050 if (p2p->drv_in_listen) { 1051 p2p_dbg(p2p, "Driver is still in Listen state - wait for it to end before continuing"); 1052 return; 1053 } 1054 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1055 p2p->pending_listen_wait_drv = false; 1056 1057 if (p2p->find_pending_full && 1058 (p2p->find_type == P2P_FIND_PROGRESSIVE || 1059 p2p->find_type == P2P_FIND_START_WITH_FULL)) { 1060 type = P2P_SCAN_FULL; 1061 p2p_dbg(p2p, "Starting search (pending full scan)"); 1062 p2p->find_pending_full = 0; 1063 } else if ((p2p->find_type == P2P_FIND_PROGRESSIVE && 1064 (freq = p2p_get_next_prog_freq(p2p)) > 0) || 1065 (p2p->find_type == P2P_FIND_START_WITH_FULL && 1066 (freq = p2p->find_specified_freq) > 0)) { 1067 type = P2P_SCAN_SOCIAL_PLUS_ONE; 1068 p2p_dbg(p2p, "Starting search (+ freq %u)", freq); 1069 } else { 1070 type = P2P_SCAN_SOCIAL; 1071 p2p_dbg(p2p, "Starting search"); 1072 } 1073 1074 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, type, freq, 1075 p2p->num_req_dev_types, p2p->req_dev_types, 1076 p2p->find_dev_id, pw_id, p2p->include_6ghz); 1077 if (res < 0) { 1078 p2p_dbg(p2p, "Scan request schedule failed"); 1079 p2p_continue_find(p2p); 1080 } 1081 } 1082 1083 p2p_find_timeout(void * eloop_ctx,void * timeout_ctx)1084 static void p2p_find_timeout(void *eloop_ctx, void *timeout_ctx) 1085 { 1086 struct p2p_data *p2p = eloop_ctx; 1087 p2p_dbg(p2p, "Find timeout -> stop"); 1088 p2p_stop_find(p2p); 1089 } 1090 1091 p2p_notify_scan_trigger_status(struct p2p_data * p2p,int status)1092 void p2p_notify_scan_trigger_status(struct p2p_data *p2p, int status) 1093 { 1094 if (status != 0) { 1095 p2p_dbg(p2p, "Scan request failed"); 1096 /* Do continue find even for the first p2p_find_scan */ 1097 p2p_continue_find(p2p); 1098 } else { 1099 p2p_dbg(p2p, "Running p2p_scan"); 1100 p2p->p2p_scan_running = 1; 1101 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 1102 eloop_register_timeout(P2P_SCAN_TIMEOUT, 0, p2p_scan_timeout, 1103 p2p, NULL); 1104 } 1105 } 1106 1107 p2p_run_after_scan(struct p2p_data * p2p)1108 static int p2p_run_after_scan(struct p2p_data *p2p) 1109 { 1110 struct p2p_device *dev; 1111 enum p2p_after_scan op; 1112 1113 op = p2p->start_after_scan; 1114 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1115 switch (op) { 1116 case P2P_AFTER_SCAN_NOTHING: 1117 break; 1118 case P2P_AFTER_SCAN_LISTEN: 1119 p2p_dbg(p2p, "Start previously requested Listen state"); 1120 p2p_listen(p2p, p2p->pending_listen_sec * 1000 + 1121 p2p->pending_listen_usec / 1000); 1122 return 1; 1123 case P2P_AFTER_SCAN_CONNECT: 1124 p2p_dbg(p2p, "Start previously requested connect with " MACSTR, 1125 MAC2STR(p2p->after_scan_peer)); 1126 dev = p2p_get_device(p2p, p2p->after_scan_peer); 1127 if (dev == NULL) { 1128 p2p_dbg(p2p, "Peer not known anymore"); 1129 break; 1130 } 1131 p2p_connect_send(p2p, dev); 1132 return 1; 1133 } 1134 1135 return 0; 1136 } 1137 1138 p2p_scan_timeout(void * eloop_ctx,void * timeout_ctx)1139 static void p2p_scan_timeout(void *eloop_ctx, void *timeout_ctx) 1140 { 1141 struct p2p_data *p2p = eloop_ctx; 1142 int running; 1143 p2p_dbg(p2p, "p2p_scan timeout (running=%d)", p2p->p2p_scan_running); 1144 running = p2p->p2p_scan_running; 1145 /* Make sure we recover from missed scan results callback */ 1146 p2p->p2p_scan_running = 0; 1147 1148 if (running) 1149 p2p_run_after_scan(p2p); 1150 } 1151 1152 p2p_free_req_dev_types(struct p2p_data * p2p)1153 static void p2p_free_req_dev_types(struct p2p_data *p2p) 1154 { 1155 p2p->num_req_dev_types = 0; 1156 os_free(p2p->req_dev_types); 1157 p2p->req_dev_types = NULL; 1158 } 1159 1160 p2ps_gen_hash(struct p2p_data * p2p,const char * str,u8 * hash)1161 static int p2ps_gen_hash(struct p2p_data *p2p, const char *str, u8 *hash) 1162 { 1163 u8 buf[SHA256_MAC_LEN]; 1164 char str_buf[256]; 1165 const u8 *adv_array; 1166 size_t i, adv_len; 1167 1168 if (!str || !hash) 1169 return 0; 1170 1171 if (!str[0]) { 1172 os_memcpy(hash, p2p->wild_card_hash, P2PS_HASH_LEN); 1173 return 1; 1174 } 1175 1176 adv_array = (u8 *) str_buf; 1177 adv_len = os_strlen(str); 1178 if (adv_len >= sizeof(str_buf)) 1179 return 0; 1180 1181 for (i = 0; i < adv_len; i++) { 1182 if (str[i] >= 'A' && str[i] <= 'Z') 1183 str_buf[i] = str[i] - 'A' + 'a'; 1184 else 1185 str_buf[i] = str[i]; 1186 } 1187 1188 if (sha256_vector(1, &adv_array, &adv_len, buf)) 1189 return 0; 1190 1191 os_memcpy(hash, buf, P2PS_HASH_LEN); 1192 return 1; 1193 } 1194 1195 p2p_find(struct p2p_data * p2p,unsigned int timeout,enum p2p_discovery_type type,unsigned int num_req_dev_types,const u8 * req_dev_types,const u8 * dev_id,unsigned int search_delay,u8 seek_count,const char ** seek,int freq,bool include_6ghz)1196 int p2p_find(struct p2p_data *p2p, unsigned int timeout, 1197 enum p2p_discovery_type type, 1198 unsigned int num_req_dev_types, const u8 *req_dev_types, 1199 const u8 *dev_id, unsigned int search_delay, 1200 u8 seek_count, const char **seek, int freq, bool include_6ghz) 1201 { 1202 int res; 1203 struct os_reltime start; 1204 1205 p2p_dbg(p2p, "Starting find (type=%d)", type); 1206 if (p2p->p2p_scan_running) { 1207 p2p_dbg(p2p, "p2p_scan is already running"); 1208 } 1209 1210 p2p_free_req_dev_types(p2p); 1211 if (req_dev_types && num_req_dev_types) { 1212 p2p->req_dev_types = os_memdup(req_dev_types, 1213 num_req_dev_types * 1214 WPS_DEV_TYPE_LEN); 1215 if (p2p->req_dev_types == NULL) 1216 return -1; 1217 p2p->num_req_dev_types = num_req_dev_types; 1218 } 1219 1220 if (dev_id) { 1221 os_memcpy(p2p->find_dev_id_buf, dev_id, ETH_ALEN); 1222 p2p->find_dev_id = p2p->find_dev_id_buf; 1223 } else 1224 p2p->find_dev_id = NULL; 1225 p2p->include_6ghz = p2p_wfd_enabled(p2p) && include_6ghz; 1226 if (seek_count == 0 || !seek) { 1227 /* Not an ASP search */ 1228 p2p->p2ps_seek = 0; 1229 } else if (seek_count == 1 && seek && (!seek[0] || !seek[0][0])) { 1230 /* 1231 * An empty seek string means no hash values, but still an ASP 1232 * search. 1233 */ 1234 p2p_dbg(p2p, "ASP search"); 1235 p2p->p2ps_seek_count = 0; 1236 p2p->p2ps_seek = 1; 1237 } else if (seek && seek_count <= P2P_MAX_QUERY_HASH) { 1238 u8 buf[P2PS_HASH_LEN]; 1239 int i, count = 0; 1240 1241 for (i = 0; i < seek_count; i++) { 1242 if (!p2ps_gen_hash(p2p, seek[i], buf)) 1243 continue; 1244 1245 p2p_dbg(p2p, "Seek service %s hash " MACSTR, 1246 seek[i], MAC2STR(buf)); 1247 os_memcpy(&p2p->p2ps_seek_hash[count * P2PS_HASH_LEN], 1248 buf, P2PS_HASH_LEN); 1249 count++; 1250 } 1251 1252 p2p->p2ps_seek_count = count; 1253 p2p->p2ps_seek = 1; 1254 } else { 1255 p2p->p2ps_seek_count = 0; 1256 p2p->p2ps_seek = 1; 1257 } 1258 1259 /* Special case to perform wildcard search */ 1260 if (p2p->p2ps_seek_count == 0 && p2p->p2ps_seek) { 1261 p2p->p2ps_seek_count = 1; 1262 os_memcpy(&p2p->p2ps_seek_hash, p2p->wild_card_hash, 1263 P2PS_HASH_LEN); 1264 } 1265 1266 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1267 p2p_clear_timeout(p2p); 1268 if (p2p->pending_listen_freq) { 1269 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_find"); 1270 p2p->pending_listen_freq = 0; 1271 } 1272 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1273 p2p->pending_listen_wait_drv = false; 1274 p2p->find_pending_full = 0; 1275 p2p->find_type = type; 1276 if (freq != 2412 && freq != 2437 && freq != 2462 && freq != 60480) 1277 p2p->find_specified_freq = freq; 1278 else 1279 p2p->find_specified_freq = 0; 1280 p2p_device_clear_reported(p2p); 1281 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN); 1282 p2p_set_state(p2p, P2P_SEARCH); 1283 p2p->search_delay = search_delay; 1284 p2p->in_search_delay = 0; 1285 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1286 p2p->last_p2p_find_timeout = timeout; 1287 if (timeout) 1288 eloop_register_timeout(timeout, 0, p2p_find_timeout, 1289 p2p, NULL); 1290 os_get_reltime(&start); 1291 switch (type) { 1292 case P2P_FIND_START_WITH_FULL: 1293 if (freq > 0) { 1294 /* 1295 * Start with the specified channel and then move to 1296 * scans for social channels and this specific channel. 1297 */ 1298 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, 1299 P2P_SCAN_SPECIFIC, freq, 1300 p2p->num_req_dev_types, 1301 p2p->req_dev_types, dev_id, 1302 DEV_PW_DEFAULT, 1303 p2p->include_6ghz); 1304 break; 1305 } 1306 /* fall through */ 1307 case P2P_FIND_PROGRESSIVE: 1308 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_FULL, 0, 1309 p2p->num_req_dev_types, 1310 p2p->req_dev_types, dev_id, 1311 DEV_PW_DEFAULT, p2p->include_6ghz); 1312 break; 1313 case P2P_FIND_ONLY_SOCIAL: 1314 res = p2p->cfg->p2p_scan(p2p->cfg->cb_ctx, P2P_SCAN_SOCIAL, 0, 1315 p2p->num_req_dev_types, 1316 p2p->req_dev_types, dev_id, 1317 DEV_PW_DEFAULT, p2p->include_6ghz); 1318 break; 1319 default: 1320 return -1; 1321 } 1322 1323 if (!res) 1324 p2p->find_start = start; 1325 1326 if (res != 0 && p2p->p2p_scan_running) { 1327 p2p_dbg(p2p, "Failed to start p2p_scan - another p2p_scan was already running"); 1328 /* wait for the previous p2p_scan to complete */ 1329 if (type == P2P_FIND_PROGRESSIVE || 1330 (type == P2P_FIND_START_WITH_FULL && freq == 0)) 1331 p2p->find_pending_full = 1; 1332 res = 0; /* do not report failure */ 1333 } else if (res != 0) { 1334 p2p_dbg(p2p, "Failed to start p2p_scan"); 1335 p2p_set_state(p2p, P2P_IDLE); 1336 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1337 } 1338 1339 return res; 1340 } 1341 1342 p2p_stop_find_for_freq(struct p2p_data * p2p,int freq)1343 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq) 1344 { 1345 p2p_dbg(p2p, "Stopping find"); 1346 eloop_cancel_timeout(p2p_find_timeout, p2p, NULL); 1347 p2p_clear_timeout(p2p); 1348 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND) 1349 p2p->cfg->find_stopped(p2p->cfg->cb_ctx); 1350 1351 p2p->p2ps_seek_count = 0; 1352 1353 p2p_set_state(p2p, P2P_IDLE); 1354 p2p_free_req_dev_types(p2p); 1355 p2p->start_after_scan = P2P_AFTER_SCAN_NOTHING; 1356 if (p2p->go_neg_peer) 1357 p2p->go_neg_peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; 1358 p2p->go_neg_peer = NULL; 1359 p2p->sd_peer = NULL; 1360 p2p->invite_peer = NULL; 1361 p2p_stop_listen_for_freq(p2p, freq); 1362 p2p->send_action_in_progress = 0; 1363 } 1364 1365 p2p_stop_listen_for_freq(struct p2p_data * p2p,int freq)1366 void p2p_stop_listen_for_freq(struct p2p_data *p2p, int freq) 1367 { 1368 p2p_dbg(p2p, 1369 "%s(freq=%d) pending_listen_freq=%d in_listen=%d drv_in_listen=%d", 1370 __func__, freq, p2p->pending_listen_freq, p2p->in_listen, 1371 p2p->drv_in_listen); 1372 if (freq > 0 && 1373 ((p2p->drv_in_listen == freq && p2p->in_listen) || 1374 p2p->pending_listen_freq == (unsigned int) freq)) { 1375 p2p_dbg(p2p, "Skip stop_listen since we are on correct channel for response"); 1376 return; 1377 } 1378 if (p2p->in_listen) { 1379 p2p->in_listen = 0; 1380 p2p_clear_timeout(p2p); 1381 } 1382 if (p2p->drv_in_listen) { 1383 /* 1384 * The driver may not deliver callback to p2p_listen_end() 1385 * when the operation gets canceled, so clear the internal 1386 * variable that is tracking driver state. 1387 */ 1388 p2p_dbg(p2p, "Clear drv_in_listen (%d)", p2p->drv_in_listen); 1389 p2p->drv_in_listen = 0; 1390 } 1391 if (p2p->pending_listen_freq && 1392 p2p->pending_listen_freq != (unsigned int) freq && 1393 !p2p->drv_in_listen && p2p->pending_listen_wait_drv) { 1394 p2p_dbg(p2p, 1395 "Clear pending_listen_freq since the started listen did not complete before being stopped"); 1396 p2p->pending_listen_freq = 0; 1397 } 1398 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 1399 p2p->pending_listen_wait_drv = false; 1400 } 1401 1402 p2p_stop_listen(struct p2p_data * p2p)1403 void p2p_stop_listen(struct p2p_data *p2p) 1404 { 1405 if (p2p->state != P2P_LISTEN_ONLY) { 1406 p2p_dbg(p2p, "Skip stop_listen since not in listen_only state."); 1407 return; 1408 } 1409 1410 p2p_stop_listen_for_freq(p2p, 0); 1411 p2p_set_state(p2p, P2P_IDLE); 1412 } 1413 1414 p2p_stop_find(struct p2p_data * p2p)1415 void p2p_stop_find(struct p2p_data *p2p) 1416 { 1417 p2p->pending_listen_freq = 0; 1418 p2p_stop_find_for_freq(p2p, 0); 1419 } 1420 1421 p2p_prepare_channel_pref(struct p2p_data * p2p,unsigned int force_freq,unsigned int pref_freq,int go)1422 static int p2p_prepare_channel_pref(struct p2p_data *p2p, 1423 unsigned int force_freq, 1424 unsigned int pref_freq, int go) 1425 { 1426 u8 op_class, op_channel; 1427 unsigned int freq = force_freq ? force_freq : pref_freq; 1428 1429 p2p_dbg(p2p, "Prepare channel pref - force_freq=%u pref_freq=%u go=%d", 1430 force_freq, pref_freq, go); 1431 if (p2p_freq_to_channel(freq, &op_class, &op_channel) < 0) { 1432 p2p_dbg(p2p, "Unsupported frequency %u MHz", freq); 1433 return -1; 1434 } 1435 1436 if (!p2p_channels_includes(&p2p->cfg->channels, op_class, op_channel) && 1437 (go || !p2p_channels_includes(&p2p->cfg->cli_channels, op_class, 1438 op_channel))) { 1439 p2p_dbg(p2p, "Frequency %u MHz (oper_class %u channel %u) not allowed for P2P", 1440 freq, op_class, op_channel); 1441 return -1; 1442 } 1443 1444 p2p->op_reg_class = op_class; 1445 p2p->op_channel = op_channel; 1446 1447 if (force_freq) { 1448 p2p->channels.reg_classes = 1; 1449 p2p->channels.reg_class[0].channels = 1; 1450 p2p->channels.reg_class[0].reg_class = p2p->op_reg_class; 1451 p2p->channels.reg_class[0].channel[0] = p2p->op_channel; 1452 } else { 1453 p2p_copy_channels(&p2p->channels, &p2p->cfg->channels, 1454 p2p->allow_6ghz); 1455 } 1456 1457 return 0; 1458 } 1459 1460 p2p_prepare_channel_best(struct p2p_data * p2p)1461 static void p2p_prepare_channel_best(struct p2p_data *p2p) 1462 { 1463 u8 op_class, op_channel; 1464 const int op_classes_5ghz[] = { 124, 125, 115, 0 }; 1465 const int op_classes_ht40[] = { 126, 127, 116, 117, 0 }; 1466 const int op_classes_vht[] = { 128, 0 }; 1467 const int op_classes_edmg[] = { 181, 182, 183, 0 }; 1468 const int op_classes_6ghz[] = { 131, 0 }; 1469 1470 p2p_dbg(p2p, "Prepare channel best"); 1471 1472 if (!p2p->cfg->cfg_op_channel && p2p->best_freq_overall > 0 && 1473 p2p_supported_freq(p2p, p2p->best_freq_overall) && 1474 p2p_freq_to_channel(p2p->best_freq_overall, &op_class, &op_channel) 1475 == 0) { 1476 p2p_dbg(p2p, "Select best overall channel as operating channel preference"); 1477 p2p->op_reg_class = op_class; 1478 p2p->op_channel = op_channel; 1479 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_5 > 0 && 1480 p2p_supported_freq(p2p, p2p->best_freq_5) && 1481 p2p_freq_to_channel(p2p->best_freq_5, &op_class, &op_channel) 1482 == 0) { 1483 p2p_dbg(p2p, "Select best 5 GHz channel as operating channel preference"); 1484 p2p->op_reg_class = op_class; 1485 p2p->op_channel = op_channel; 1486 } else if (!p2p->cfg->cfg_op_channel && p2p->best_freq_24 > 0 && 1487 p2p_supported_freq(p2p, p2p->best_freq_24) && 1488 p2p_freq_to_channel(p2p->best_freq_24, &op_class, 1489 &op_channel) == 0) { 1490 p2p_dbg(p2p, "Select best 2.4 GHz channel as operating channel preference"); 1491 p2p->op_reg_class = op_class; 1492 p2p->op_channel = op_channel; 1493 } else if (p2p->cfg->num_pref_chan > 0 && 1494 p2p_channels_includes(&p2p->cfg->channels, 1495 p2p->cfg->pref_chan[0].op_class, 1496 p2p->cfg->pref_chan[0].chan)) { 1497 p2p_dbg(p2p, "Select first pref_chan entry as operating channel preference"); 1498 p2p->op_reg_class = p2p->cfg->pref_chan[0].op_class; 1499 p2p->op_channel = p2p->cfg->pref_chan[0].chan; 1500 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_edmg, 1501 &p2p->op_reg_class, &p2p->op_channel) == 1502 0) { 1503 p2p_dbg(p2p, "Select possible EDMG channel (op_class %u channel %u) as operating channel preference", 1504 p2p->op_reg_class, p2p->op_channel); 1505 } else if (p2p->allow_6ghz && 1506 (p2p_channel_select(&p2p->cfg->channels, op_classes_6ghz, 1507 &p2p->op_reg_class, &p2p->op_channel) == 1508 0)) { 1509 p2p_dbg(p2p, "Select possible 6 GHz channel (op_class %u channel %u) as operating channel preference", 1510 p2p->op_reg_class, p2p->op_channel); 1511 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_vht, 1512 &p2p->op_reg_class, &p2p->op_channel) == 1513 0) { 1514 p2p_dbg(p2p, "Select possible VHT channel (op_class %u channel %u) as operating channel preference", 1515 p2p->op_reg_class, p2p->op_channel); 1516 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_ht40, 1517 &p2p->op_reg_class, &p2p->op_channel) == 1518 0) { 1519 p2p_dbg(p2p, "Select possible HT40 channel (op_class %u channel %u) as operating channel preference", 1520 p2p->op_reg_class, p2p->op_channel); 1521 } else if (p2p_channel_select(&p2p->cfg->channels, op_classes_5ghz, 1522 &p2p->op_reg_class, &p2p->op_channel) == 1523 0) { 1524 p2p_dbg(p2p, "Select possible 5 GHz channel (op_class %u channel %u) as operating channel preference", 1525 p2p->op_reg_class, p2p->op_channel); 1526 } else if (p2p_channels_includes(&p2p->cfg->channels, 1527 p2p->cfg->op_reg_class, 1528 p2p->cfg->op_channel)) { 1529 p2p_dbg(p2p, "Select pre-configured channel as operating channel preference"); 1530 p2p->op_reg_class = p2p->cfg->op_reg_class; 1531 p2p->op_channel = p2p->cfg->op_channel; 1532 } else if (p2p_channel_random_social(&p2p->cfg->channels, 1533 &p2p->op_reg_class, 1534 &p2p->op_channel, 1535 NULL, NULL) == 0) { 1536 p2p_dbg(p2p, "Select random available social channel (op_class %u channel %u) as operating channel preference", 1537 p2p->op_reg_class, p2p->op_channel); 1538 } else { 1539 /* Select any random available channel from the first available 1540 * operating class */ 1541 if (p2p_channel_select(&p2p->cfg->channels, NULL, 1542 &p2p->op_reg_class, 1543 &p2p->op_channel) == 0) 1544 p2p_dbg(p2p, 1545 "Select random available channel %d from operating class %d as operating channel preference", 1546 p2p->op_channel, p2p->op_reg_class); 1547 } 1548 1549 p2p_copy_channels(&p2p->channels, &p2p->cfg->channels, p2p->allow_6ghz); 1550 } 1551 1552 1553 /** 1554 * p2p_prepare_channel - Select operating channel for GO Negotiation or P2PS PD 1555 * @p2p: P2P module context from p2p_init() 1556 * @dev: Selected peer device 1557 * @force_freq: Forced frequency in MHz or 0 if not forced 1558 * @pref_freq: Preferred frequency in MHz or 0 if no preference 1559 * @go: Whether the local end will be forced to be GO 1560 * Returns: 0 on success, -1 on failure (channel not supported for P2P) 1561 * 1562 * This function is used to do initial operating channel selection for GO 1563 * Negotiation prior to having received peer information or for P2PS PD 1564 * signalling. The selected channel may be further optimized in 1565 * p2p_reselect_channel() once the peer information is available. 1566 */ p2p_prepare_channel(struct p2p_data * p2p,struct p2p_device * dev,unsigned int force_freq,unsigned int pref_freq,int go)1567 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev, 1568 unsigned int force_freq, unsigned int pref_freq, int go) 1569 { 1570 p2p_dbg(p2p, "Prepare channel - force_freq=%u pref_freq=%u go=%d", 1571 force_freq, pref_freq, go); 1572 if (force_freq || pref_freq) { 1573 if (p2p_prepare_channel_pref(p2p, force_freq, pref_freq, go) < 1574 0) 1575 return -1; 1576 } else { 1577 p2p_prepare_channel_best(p2p); 1578 } 1579 p2p_channels_dump(p2p, "prepared channels", &p2p->channels); 1580 if (go) 1581 p2p_channels_remove_freqs(&p2p->channels, &p2p->no_go_freq); 1582 else if (!force_freq) 1583 p2p_channels_union_inplace(&p2p->channels, 1584 &p2p->cfg->cli_channels); 1585 p2p_channels_dump(p2p, "after go/cli filter/add", &p2p->channels); 1586 1587 p2p_dbg(p2p, "Own preference for operation channel: Operating Class %u Channel %u%s", 1588 p2p->op_reg_class, p2p->op_channel, 1589 force_freq ? " (forced)" : ""); 1590 1591 if (force_freq) 1592 dev->flags |= P2P_DEV_FORCE_FREQ; 1593 else 1594 dev->flags &= ~P2P_DEV_FORCE_FREQ; 1595 1596 return 0; 1597 } 1598 1599 p2p_set_dev_persistent(struct p2p_device * dev,int persistent_group)1600 static void p2p_set_dev_persistent(struct p2p_device *dev, 1601 int persistent_group) 1602 { 1603 switch (persistent_group) { 1604 case 0: 1605 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP | 1606 P2P_DEV_PREFER_PERSISTENT_RECONN); 1607 break; 1608 case 1: 1609 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP; 1610 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN; 1611 break; 1612 case 2: 1613 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP | 1614 P2P_DEV_PREFER_PERSISTENT_RECONN; 1615 break; 1616 } 1617 } 1618 1619 p2p_connect(struct p2p_data * p2p,const u8 * peer_addr,enum p2p_wps_method wps_method,int go_intent,const u8 * own_interface_addr,unsigned int force_freq,int persistent_group,const u8 * force_ssid,size_t force_ssid_len,int pd_before_go_neg,unsigned int pref_freq,u16 oob_pw_id,bool p2p2,u16 bootstrap,const char * password)1620 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr, 1621 enum p2p_wps_method wps_method, 1622 int go_intent, const u8 *own_interface_addr, 1623 unsigned int force_freq, int persistent_group, 1624 const u8 *force_ssid, size_t force_ssid_len, 1625 int pd_before_go_neg, unsigned int pref_freq, u16 oob_pw_id, 1626 bool p2p2, u16 bootstrap, const char *password) 1627 { 1628 struct p2p_device *dev; 1629 1630 p2p_dbg(p2p, "Request to start group negotiation - peer=" MACSTR 1631 " GO Intent=%d Intended Interface Address=" MACSTR 1632 " wps_method=%d persistent_group=%d pd_before_go_neg=%d " 1633 "oob_pw_id=%u allow_6ghz=%d", 1634 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr), 1635 wps_method, persistent_group, pd_before_go_neg, oob_pw_id, 1636 p2p->allow_6ghz); 1637 1638 dev = p2p_get_device(p2p, peer_addr); 1639 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) { 1640 p2p_dbg(p2p, "Cannot connect to unknown P2P Device " MACSTR, 1641 MAC2STR(peer_addr)); 1642 return -1; 1643 } 1644 1645 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, 1646 go_intent == 15) < 0) 1647 return -1; 1648 1649 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) { 1650 if (!(dev->info.dev_capab & 1651 P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY)) { 1652 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR 1653 " that is in a group and is not discoverable", 1654 MAC2STR(peer_addr)); 1655 return -1; 1656 } 1657 if (dev->oper_freq <= 0) { 1658 p2p_dbg(p2p, "Cannot connect to P2P Device " MACSTR 1659 " with incomplete information", 1660 MAC2STR(peer_addr)); 1661 return -1; 1662 } 1663 1664 /* 1665 * First, try to connect directly. If the peer does not 1666 * acknowledge frames, assume it is sleeping and use device 1667 * discoverability via the GO at that point. 1668 */ 1669 } 1670 1671 p2p->ssid_set = 0; 1672 if (force_ssid) { 1673 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID", 1674 force_ssid, force_ssid_len); 1675 os_memcpy(p2p->ssid, force_ssid, force_ssid_len); 1676 p2p->ssid_len = force_ssid_len; 1677 p2p->ssid_set = 1; 1678 } 1679 1680 dev->flags &= ~P2P_DEV_NOT_YET_READY; 1681 dev->flags &= ~P2P_DEV_USER_REJECTED; 1682 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; 1683 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; 1684 if (pd_before_go_neg) 1685 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG; 1686 else { 1687 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG; 1688 /* 1689 * Assign dialog token and tie breaker here to use the same 1690 * values in each retry within the same GO Negotiation exchange. 1691 */ 1692 dev->dialog_token++; 1693 if (dev->dialog_token == 0) 1694 dev->dialog_token = 1; 1695 dev->tie_breaker = p2p->next_tie_breaker; 1696 p2p->next_tie_breaker = !p2p->next_tie_breaker; 1697 } 1698 dev->connect_reqs = 0; 1699 dev->go_neg_req_sent = 0; 1700 dev->go_state = UNKNOWN_GO; 1701 p2p_set_dev_persistent(dev, persistent_group); 1702 p2p->go_intent = go_intent; 1703 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); 1704 1705 if (p2p->state != P2P_IDLE) 1706 p2p_stop_find(p2p); 1707 1708 dev->wps_method = wps_method; 1709 dev->oob_pw_id = oob_pw_id; 1710 dev->p2p2 = p2p2; 1711 dev->req_bootstrap_method = bootstrap; 1712 if (password && os_strlen(password) < sizeof(dev->password)) 1713 os_strlcpy(dev->password, password, sizeof(dev->password)); 1714 dev->status = P2P_SC_SUCCESS; 1715 1716 if (p2p->p2p_scan_running) { 1717 p2p_dbg(p2p, "p2p_scan running - delay connect send"); 1718 p2p->start_after_scan = P2P_AFTER_SCAN_CONNECT; 1719 os_memcpy(p2p->after_scan_peer, peer_addr, ETH_ALEN); 1720 return 0; 1721 } 1722 1723 return p2p_connect_send(p2p, dev); 1724 } 1725 1726 p2p_authorize(struct p2p_data * p2p,const u8 * peer_addr,enum p2p_wps_method wps_method,int go_intent,const u8 * own_interface_addr,unsigned int force_freq,int persistent_group,const u8 * force_ssid,size_t force_ssid_len,unsigned int pref_freq,u16 oob_pw_id,u16 bootstrap,const char * password)1727 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr, 1728 enum p2p_wps_method wps_method, 1729 int go_intent, const u8 *own_interface_addr, 1730 unsigned int force_freq, int persistent_group, 1731 const u8 *force_ssid, size_t force_ssid_len, 1732 unsigned int pref_freq, u16 oob_pw_id, u16 bootstrap, 1733 const char *password) 1734 { 1735 struct p2p_device *dev; 1736 1737 p2p_dbg(p2p, "Request to authorize group negotiation - peer=" MACSTR 1738 " GO Intent=%d Intended Interface Address=" MACSTR 1739 " wps_method=%d persistent_group=%d oob_pw_id=%u allow_6ghz=%d", 1740 MAC2STR(peer_addr), go_intent, MAC2STR(own_interface_addr), 1741 wps_method, persistent_group, oob_pw_id, p2p->allow_6ghz); 1742 1743 dev = p2p_get_device(p2p, peer_addr); 1744 if (dev == NULL) { 1745 p2p_dbg(p2p, "Cannot authorize unknown P2P Device " MACSTR, 1746 MAC2STR(peer_addr)); 1747 return -1; 1748 } 1749 1750 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq, go_intent == 1751 15) < 0) 1752 return -1; 1753 1754 p2p->ssid_set = 0; 1755 if (force_ssid) { 1756 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Forced SSID", 1757 force_ssid, force_ssid_len); 1758 os_memcpy(p2p->ssid, force_ssid, force_ssid_len); 1759 p2p->ssid_len = force_ssid_len; 1760 p2p->ssid_set = 1; 1761 } 1762 1763 dev->flags &= ~P2P_DEV_NOT_YET_READY; 1764 dev->flags &= ~P2P_DEV_USER_REJECTED; 1765 dev->go_neg_req_sent = 0; 1766 dev->go_state = UNKNOWN_GO; 1767 dev->req_bootstrap_method = bootstrap; 1768 1769 if (password && os_strlen(password) < sizeof(dev->password)) 1770 os_strlcpy(dev->password, password, sizeof(dev->password)); 1771 p2p_set_dev_persistent(dev, persistent_group); 1772 p2p->go_intent = go_intent; 1773 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); 1774 1775 dev->wps_method = wps_method; 1776 dev->oob_pw_id = oob_pw_id; 1777 dev->status = P2P_SC_SUCCESS; 1778 1779 return 0; 1780 } 1781 1782 p2p_add_dev_info(struct p2p_data * p2p,const u8 * addr,struct p2p_device * dev,struct p2p_message * msg)1783 void p2p_add_dev_info(struct p2p_data *p2p, const u8 *addr, 1784 struct p2p_device *dev, struct p2p_message *msg) 1785 { 1786 os_get_reltime(&dev->last_seen); 1787 1788 p2p_copy_wps_info(p2p, dev, 0, msg); 1789 1790 if (msg->listen_channel) { 1791 int freq; 1792 freq = p2p_channel_to_freq(msg->listen_channel[3], 1793 msg->listen_channel[4]); 1794 if (freq < 0) { 1795 p2p_dbg(p2p, "Unknown peer Listen channel: " 1796 "country=%c%c(0x%02x) reg_class=%u channel=%u", 1797 msg->listen_channel[0], 1798 msg->listen_channel[1], 1799 msg->listen_channel[2], 1800 msg->listen_channel[3], 1801 msg->listen_channel[4]); 1802 } else { 1803 p2p_dbg(p2p, "Update peer " MACSTR 1804 " Listen channel: %u -> %u MHz", 1805 MAC2STR(dev->info.p2p_device_addr), 1806 dev->listen_freq, freq); 1807 dev->listen_freq = freq; 1808 } 1809 } 1810 1811 if (msg->wfd_subelems) { 1812 wpabuf_free(dev->info.wfd_subelems); 1813 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems); 1814 } 1815 1816 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { 1817 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY; 1818 p2p_dbg(p2p, "Completed device entry based on data from GO Negotiation Request"); 1819 } else { 1820 p2p_dbg(p2p, "Created device entry based on GO Neg Req: " 1821 MACSTR " dev_capab=0x%x group_capab=0x%x name='%s' " 1822 "listen_freq=%d", 1823 MAC2STR(dev->info.p2p_device_addr), 1824 dev->info.dev_capab, dev->info.group_capab, 1825 dev->info.device_name, dev->listen_freq); 1826 } 1827 1828 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY; 1829 1830 if (dev->flags & P2P_DEV_USER_REJECTED) { 1831 p2p_dbg(p2p, "Do not report rejected device"); 1832 return; 1833 } 1834 1835 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info, 1836 !(dev->flags & P2P_DEV_REPORTED_ONCE)); 1837 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 1838 } 1839 1840 p2p_build_ssid(struct p2p_data * p2p,u8 * ssid,size_t * ssid_len)1841 void p2p_build_ssid(struct p2p_data *p2p, u8 *ssid, size_t *ssid_len) 1842 { 1843 os_memcpy(ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); 1844 p2p_random((char *) &ssid[P2P_WILDCARD_SSID_LEN], 2); 1845 os_memcpy(&ssid[P2P_WILDCARD_SSID_LEN + 2], 1846 p2p->cfg->ssid_postfix, p2p->cfg->ssid_postfix_len); 1847 *ssid_len = P2P_WILDCARD_SSID_LEN + 2 + p2p->cfg->ssid_postfix_len; 1848 } 1849 1850 p2p_go_params(struct p2p_data * p2p,struct p2p_go_neg_results * params)1851 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params) 1852 { 1853 if (p2p->ssid_set) { 1854 os_memcpy(params->ssid, p2p->ssid, p2p->ssid_len); 1855 params->ssid_len = p2p->ssid_len; 1856 } else { 1857 p2p_build_ssid(p2p, params->ssid, ¶ms->ssid_len); 1858 } 1859 p2p->ssid_set = 0; 1860 1861 params->cipher = WPA_CIPHER_CCMP; 1862 if (p2p->cfg->pairing_config.pasn_type & 0xc) 1863 params->cipher |= WPA_CIPHER_GCMP_256; 1864 1865 p2p_random(params->passphrase, p2p->cfg->passphrase_len); 1866 params->passphrase[p2p->cfg->passphrase_len] = '\0'; 1867 1868 if (params->p2p2) { 1869 os_strlcpy(p2p->dev_sae_password, params->passphrase, 1870 sizeof(p2p->dev_sae_password)); 1871 os_strlcpy(params->sae_password, p2p->dev_sae_password, 1872 sizeof(params->sae_password)); 1873 } 1874 1875 return 0; 1876 } 1877 1878 p2p_set_go_role(struct p2p_data * p2p,bool val)1879 void p2p_set_go_role(struct p2p_data *p2p, bool val) 1880 { 1881 p2p->go_role = val; 1882 } 1883 1884 p2p_go_complete(struct p2p_data * p2p,struct p2p_device * peer)1885 void p2p_go_complete(struct p2p_data *p2p, struct p2p_device *peer) 1886 { 1887 struct p2p_go_neg_results res; 1888 int go = peer->go_state == LOCAL_GO; 1889 struct p2p_channels intersection; 1890 1891 p2p_dbg(p2p, "GO Negotiation with " MACSTR " completed (%s will be GO)", 1892 MAC2STR(peer->info.p2p_device_addr), go ? "local end" : "peer"); 1893 1894 os_memset(&res, 0, sizeof(res)); 1895 res.role_go = go; 1896 os_memcpy(res.peer_device_addr, peer->info.p2p_device_addr, ETH_ALEN); 1897 os_memcpy(res.peer_interface_addr, peer->intended_addr, ETH_ALEN); 1898 res.wps_method = peer->wps_method; 1899 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_GROUP) { 1900 if (peer->flags & P2P_DEV_PREFER_PERSISTENT_RECONN) 1901 res.persistent_group = 2; 1902 else 1903 res.persistent_group = 1; 1904 } 1905 1906 if (go) { 1907 /* Setup AP mode for WPS provisioning */ 1908 res.freq = p2p_channel_to_freq(p2p->op_reg_class, 1909 p2p->op_channel); 1910 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len); 1911 res.ssid_len = p2p->ssid_len; 1912 p2p_random(res.passphrase, p2p->cfg->passphrase_len); 1913 res.passphrase[p2p->cfg->passphrase_len] = '\0'; 1914 } else { 1915 res.freq = peer->oper_freq; 1916 if (p2p->ssid_len) { 1917 os_memcpy(res.ssid, p2p->ssid, p2p->ssid_len); 1918 res.ssid_len = p2p->ssid_len; 1919 } 1920 } 1921 1922 p2p_channels_dump(p2p, "own channels", &p2p->channels); 1923 p2p_channels_dump(p2p, "peer channels", &peer->channels); 1924 p2p_channels_intersect(&p2p->channels, &peer->channels, 1925 &intersection); 1926 if (go) { 1927 p2p_channels_remove_freqs(&intersection, &p2p->no_go_freq); 1928 p2p_channels_dump(p2p, "intersection after no-GO removal", 1929 &intersection); 1930 } 1931 1932 p2p_channels_to_freqs(&intersection, res.freq_list, 1933 P2P_MAX_CHANNELS); 1934 1935 res.peer_config_timeout = go ? peer->client_timeout : peer->go_timeout; 1936 1937 p2p_clear_timeout(p2p); 1938 p2p->ssid_set = 0; 1939 peer->go_neg_req_sent = 0; 1940 peer->flags &= ~P2P_DEV_PEER_WAITING_RESPONSE; 1941 peer->wps_method = WPS_NOT_READY; 1942 peer->oob_pw_id = 0; 1943 wpabuf_free(peer->go_neg_conf); 1944 peer->go_neg_conf = NULL; 1945 1946 #ifdef CONFIG_PASN 1947 if (peer->p2p2 && peer->pasn) { 1948 res.p2p2 = peer->p2p2; 1949 res.akmp = peer->pasn->akmp; 1950 res.cipher = peer->pasn->cipher; 1951 1952 if (res.akmp == WPA_KEY_MGMT_PASN) { 1953 if (go) { 1954 os_strlcpy(res.sae_password, 1955 p2p->dev_sae_password, 1956 sizeof(res.sae_password)); 1957 } else { 1958 if (!os_strlen(p2p->peer_sae_password)) { 1959 p2p_dbg(p2p, "No password from peer GO for P2P2 group formation"); 1960 return; 1961 } 1962 os_strlcpy(res.sae_password, 1963 p2p->peer_sae_password, 1964 sizeof(res.sae_password)); 1965 } 1966 } else if (res.akmp == WPA_KEY_MGMT_SAE) { 1967 if (peer->role == P2P_ROLE_PAIRING_INITIATOR) { 1968 pasn_initiator_pmksa_cache_get( 1969 peer->pasn->pmksa, 1970 peer->pasn->peer_addr, 1971 res.pmkid, res.pmk, &res.pmk_len); 1972 } else { 1973 pasn_responder_pmksa_cache_get( 1974 peer->pasn->pmksa, 1975 peer->pasn->peer_addr, 1976 res.pmkid, res.pmk, &res.pmk_len); 1977 } 1978 } 1979 1980 os_memset(p2p->dev_sae_password, 0, 1981 sizeof(p2p->dev_sae_password)); 1982 os_memset(p2p->peer_sae_password, 0, 1983 sizeof(p2p->peer_sae_password)); 1984 wpa_pasn_reset(peer->pasn); 1985 } 1986 #endif /* CONFIG_PASN */ 1987 1988 if (p2p->go_role && peer->p2p2) { 1989 p2p->cfg->set_go_security_config(p2p->cfg->cb_ctx, &res); 1990 p2p->go_role = false; 1991 } else { 1992 p2p_set_state(p2p, P2P_PROVISIONING); 1993 p2p->cfg->go_neg_completed(p2p->cfg->cb_ctx, &res); 1994 } 1995 1996 forced_memzero(&res, sizeof(res)); 1997 } 1998 1999 p2p_rx_p2p_action(struct p2p_data * p2p,const u8 * sa,const u8 * data,size_t len,int rx_freq)2000 static void p2p_rx_p2p_action(struct p2p_data *p2p, const u8 *sa, 2001 const u8 *data, size_t len, int rx_freq) 2002 { 2003 p2p_dbg(p2p, "RX P2P Public Action from " MACSTR, MAC2STR(sa)); 2004 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Public Action contents", data, len); 2005 2006 if (len < 1) 2007 return; 2008 2009 switch (data[0]) { 2010 case P2P_GO_NEG_REQ: 2011 p2p_handle_go_neg_req(p2p, sa, data + 1, len - 1, rx_freq); 2012 break; 2013 case P2P_GO_NEG_RESP: 2014 p2p_handle_go_neg_resp(p2p, sa, data + 1, len - 1, rx_freq); 2015 break; 2016 case P2P_GO_NEG_CONF: 2017 p2p_handle_go_neg_conf(p2p, sa, data + 1, len - 1, false); 2018 break; 2019 case P2P_INVITATION_REQ: 2020 p2p_handle_invitation_req(p2p, sa, data + 1, len - 1, rx_freq); 2021 break; 2022 case P2P_INVITATION_RESP: 2023 p2p_process_invitation_resp(p2p, sa, data + 1, len - 1); 2024 break; 2025 case P2P_PROV_DISC_REQ: 2026 p2p_handle_prov_disc_req(p2p, sa, data + 1, len - 1, rx_freq); 2027 break; 2028 case P2P_PROV_DISC_RESP: 2029 p2p_handle_prov_disc_resp(p2p, sa, data + 1, len - 1, rx_freq); 2030 break; 2031 case P2P_DEV_DISC_REQ: 2032 p2p_process_dev_disc_req(p2p, sa, data + 1, len - 1, rx_freq); 2033 break; 2034 case P2P_DEV_DISC_RESP: 2035 p2p_process_dev_disc_resp(p2p, sa, data + 1, len - 1); 2036 break; 2037 default: 2038 p2p_dbg(p2p, "Unsupported P2P Public Action frame type %d", 2039 data[0]); 2040 break; 2041 } 2042 } 2043 2044 p2p_rx_action_public(struct p2p_data * p2p,const u8 * da,const u8 * sa,const u8 * bssid,const u8 * data,size_t len,int freq)2045 static void p2p_rx_action_public(struct p2p_data *p2p, const u8 *da, 2046 const u8 *sa, const u8 *bssid, const u8 *data, 2047 size_t len, int freq) 2048 { 2049 if (len < 1) 2050 return; 2051 2052 switch (data[0]) { 2053 case WLAN_PA_VENDOR_SPECIFIC: 2054 data++; 2055 len--; 2056 if (len < 4) 2057 return; 2058 if (WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE) 2059 return; 2060 2061 data += 4; 2062 len -= 4; 2063 2064 p2p_rx_p2p_action(p2p, sa, data, len, freq); 2065 break; 2066 case WLAN_PA_GAS_INITIAL_REQ: 2067 p2p_rx_gas_initial_req(p2p, sa, data + 1, len - 1, freq); 2068 break; 2069 case WLAN_PA_GAS_INITIAL_RESP: 2070 p2p_rx_gas_initial_resp(p2p, sa, data + 1, len - 1, freq); 2071 break; 2072 case WLAN_PA_GAS_COMEBACK_REQ: 2073 p2p_rx_gas_comeback_req(p2p, sa, data + 1, len - 1, freq); 2074 break; 2075 case WLAN_PA_GAS_COMEBACK_RESP: 2076 p2p_rx_gas_comeback_resp(p2p, sa, data + 1, len - 1, freq); 2077 break; 2078 } 2079 } 2080 2081 p2p_rx_action(struct p2p_data * p2p,const u8 * da,const u8 * sa,const u8 * bssid,u8 category,const u8 * data,size_t len,int freq)2082 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa, 2083 const u8 *bssid, u8 category, 2084 const u8 *data, size_t len, int freq) 2085 { 2086 if (category == WLAN_ACTION_PUBLIC) { 2087 p2p_rx_action_public(p2p, da, sa, bssid, data, len, freq); 2088 return; 2089 } 2090 2091 if (category != WLAN_ACTION_VENDOR_SPECIFIC) 2092 return; 2093 2094 if (len < 4) 2095 return; 2096 2097 if (WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE) 2098 return; 2099 data += 4; 2100 len -= 4; 2101 2102 /* P2P action frame */ 2103 p2p_dbg(p2p, "RX P2P Action from " MACSTR, MAC2STR(sa)); 2104 wpa_hexdump(MSG_MSGDUMP, "P2P: P2P Action contents", data, len); 2105 2106 if (len < 1) 2107 return; 2108 switch (data[0]) { 2109 case P2P_NOA: 2110 p2p_dbg(p2p, "Received P2P Action - Notice of Absence"); 2111 /* TODO */ 2112 break; 2113 case P2P_PRESENCE_REQ: 2114 p2p_process_presence_req(p2p, da, sa, data + 1, len - 1, freq); 2115 break; 2116 case P2P_PRESENCE_RESP: 2117 p2p_process_presence_resp(p2p, da, sa, data + 1, len - 1); 2118 break; 2119 case P2P_GO_DISC_REQ: 2120 p2p_process_go_disc_req(p2p, da, sa, data + 1, len - 1, freq); 2121 break; 2122 default: 2123 p2p_dbg(p2p, "Received P2P Action - unknown type %u", data[0]); 2124 break; 2125 } 2126 } 2127 2128 p2p_go_neg_start(void * eloop_ctx,void * timeout_ctx)2129 static void p2p_go_neg_start(void *eloop_ctx, void *timeout_ctx) 2130 { 2131 struct p2p_data *p2p = eloop_ctx; 2132 if (p2p->go_neg_peer == NULL) 2133 return; 2134 if (p2p->pending_listen_freq) { 2135 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_go_neg_start"); 2136 p2p->pending_listen_freq = 0; 2137 } 2138 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 2139 p2p->pending_listen_wait_drv = false; 2140 p2p->go_neg_peer->status = P2P_SC_SUCCESS; 2141 /* 2142 * Set new timeout to make sure a previously set one does not expire 2143 * too quickly while waiting for the GO Negotiation to complete. 2144 */ 2145 p2p_set_timeout(p2p, 0, 500000); 2146 p2p_connect_send(p2p, p2p->go_neg_peer); 2147 } 2148 2149 p2p_invite_start(void * eloop_ctx,void * timeout_ctx)2150 static void p2p_invite_start(void *eloop_ctx, void *timeout_ctx) 2151 { 2152 struct p2p_data *p2p = eloop_ctx; 2153 if (p2p->invite_peer == NULL) 2154 return; 2155 if (p2p->pending_listen_freq) { 2156 p2p_dbg(p2p, "Clear pending_listen_freq for p2p_invite_start"); 2157 p2p->pending_listen_freq = 0; 2158 } 2159 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 2160 p2p->pending_listen_wait_drv = false; 2161 p2p_invite_send(p2p, p2p->invite_peer, p2p->invite_go_dev_addr, 2162 p2p->invite_dev_pw_id); 2163 } 2164 2165 p2p_add_dev_from_probe_req(struct p2p_data * p2p,const u8 * addr,const u8 * ie,size_t ie_len)2166 static void p2p_add_dev_from_probe_req(struct p2p_data *p2p, const u8 *addr, 2167 const u8 *ie, size_t ie_len) 2168 { 2169 struct p2p_message msg; 2170 struct p2p_device *dev; 2171 2172 os_memset(&msg, 0, sizeof(msg)); 2173 if (p2p_parse_ies(ie, ie_len, &msg) < 0 || msg.p2p_attributes == NULL) 2174 { 2175 p2p_parse_free(&msg); 2176 return; /* not a P2P probe */ 2177 } 2178 2179 if (msg.ssid == NULL || msg.ssid[1] != P2P_WILDCARD_SSID_LEN || 2180 os_memcmp(msg.ssid + 2, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) 2181 != 0) { 2182 /* The Probe Request is not part of P2P Device Discovery. It is 2183 * not known whether the source address of the frame is the P2P 2184 * Device Address or P2P Interface Address. Do not add a new 2185 * peer entry based on this frames. 2186 */ 2187 p2p_parse_free(&msg); 2188 return; 2189 } 2190 2191 dev = p2p_get_device(p2p, addr); 2192 if (dev) { 2193 if (msg.listen_channel) { 2194 int freq; 2195 2196 if (dev->country[0] == 0) 2197 os_memcpy(dev->country, msg.listen_channel, 3); 2198 2199 freq = p2p_channel_to_freq(msg.listen_channel[3], 2200 msg.listen_channel[4]); 2201 2202 if (freq > 0 && dev->listen_freq != freq) { 2203 p2p_dbg(p2p, 2204 "Updated peer " MACSTR " Listen channel (Probe Request): %d -> %d MHz", 2205 MAC2STR(addr), dev->listen_freq, freq); 2206 dev->listen_freq = freq; 2207 } 2208 } 2209 2210 p2p_update_peer_6ghz_capab(dev, &msg); 2211 os_get_reltime(&dev->last_seen); 2212 p2p_parse_free(&msg); 2213 return; /* already known */ 2214 } 2215 2216 dev = p2p_create_device(p2p, addr); 2217 if (dev == NULL) { 2218 p2p_parse_free(&msg); 2219 return; 2220 } 2221 2222 os_get_reltime(&dev->last_seen); 2223 dev->flags |= P2P_DEV_PROBE_REQ_ONLY; 2224 2225 if (msg.listen_channel) { 2226 os_memcpy(dev->country, msg.listen_channel, 3); 2227 dev->listen_freq = p2p_channel_to_freq(msg.listen_channel[3], 2228 msg.listen_channel[4]); 2229 } 2230 2231 p2p_copy_wps_info(p2p, dev, 1, &msg); 2232 2233 if (msg.wfd_subelems) { 2234 wpabuf_free(dev->info.wfd_subelems); 2235 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems); 2236 } 2237 2238 p2p_parse_free(&msg); 2239 2240 p2p_dbg(p2p, "Created device entry based on Probe Req: " MACSTR 2241 " dev_capab=0x%x group_capab=0x%x name='%s' listen_freq=%d", 2242 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab, 2243 dev->info.group_capab, dev->info.device_name, 2244 dev->listen_freq); 2245 } 2246 2247 p2p_add_dev_from_go_neg_req(struct p2p_data * p2p,const u8 * addr,struct p2p_message * msg)2248 struct p2p_device * p2p_add_dev_from_go_neg_req(struct p2p_data *p2p, 2249 const u8 *addr, 2250 struct p2p_message *msg) 2251 { 2252 struct p2p_device *dev; 2253 2254 dev = p2p_get_device(p2p, addr); 2255 if (dev) { 2256 os_get_reltime(&dev->last_seen); 2257 return dev; /* already known */ 2258 } 2259 2260 dev = p2p_create_device(p2p, addr); 2261 if (dev == NULL) 2262 return NULL; 2263 2264 p2p_add_dev_info(p2p, addr, dev, msg); 2265 2266 return dev; 2267 } 2268 2269 dev_type_match(const u8 * dev_type,const u8 * req_dev_type)2270 static int dev_type_match(const u8 *dev_type, const u8 *req_dev_type) 2271 { 2272 if (os_memcmp(dev_type, req_dev_type, WPS_DEV_TYPE_LEN) == 0) 2273 return 1; 2274 if (os_memcmp(dev_type, req_dev_type, 2) == 0 && 2275 WPA_GET_BE32(&req_dev_type[2]) == 0 && 2276 WPA_GET_BE16(&req_dev_type[6]) == 0) 2277 return 1; /* Category match with wildcard OUI/sub-category */ 2278 return 0; 2279 } 2280 2281 dev_type_list_match(const u8 * dev_type,const u8 * req_dev_type[],size_t num_req_dev_type)2282 int dev_type_list_match(const u8 *dev_type, const u8 *req_dev_type[], 2283 size_t num_req_dev_type) 2284 { 2285 size_t i; 2286 for (i = 0; i < num_req_dev_type; i++) { 2287 if (dev_type_match(dev_type, req_dev_type[i])) 2288 return 1; 2289 } 2290 return 0; 2291 } 2292 2293 2294 /** 2295 * p2p_match_dev_type - Match local device type with requested type 2296 * @p2p: P2P module context from p2p_init() 2297 * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs) 2298 * Returns: 1 on match, 0 on mismatch 2299 * 2300 * This function can be used to match the Requested Device Type attribute in 2301 * WPS IE with the local device types for deciding whether to reply to a Probe 2302 * Request frame. 2303 */ p2p_match_dev_type(struct p2p_data * p2p,struct wpabuf * wps)2304 int p2p_match_dev_type(struct p2p_data *p2p, struct wpabuf *wps) 2305 { 2306 struct wps_parse_attr attr; 2307 size_t i; 2308 2309 if (wps_parse_msg(wps, &attr)) 2310 return 1; /* assume no Requested Device Type attributes */ 2311 2312 if (attr.num_req_dev_type == 0) 2313 return 1; /* no Requested Device Type attributes -> match */ 2314 2315 if (dev_type_list_match(p2p->cfg->pri_dev_type, attr.req_dev_type, 2316 attr.num_req_dev_type)) 2317 return 1; /* Own Primary Device Type matches */ 2318 2319 for (i = 0; i < p2p->cfg->num_sec_dev_types; i++) { 2320 if (dev_type_list_match(p2p->cfg->sec_dev_type[i], 2321 attr.req_dev_type, 2322 attr.num_req_dev_type)) 2323 return 1; /* Own Secondary Device Type matches */ 2324 } 2325 2326 /* No matching device type found */ 2327 return 0; 2328 } 2329 2330 p2p_build_probe_resp_ies(struct p2p_data * p2p,const u8 * query_hash,u8 query_count)2331 struct wpabuf * p2p_build_probe_resp_ies(struct p2p_data *p2p, 2332 const u8 *query_hash, 2333 u8 query_count) 2334 { 2335 struct wpabuf *buf; 2336 u8 *len; 2337 int pw_id = -1; 2338 size_t extra = 0; 2339 2340 #ifdef CONFIG_WIFI_DISPLAY 2341 if (p2p->wfd_ie_probe_resp) 2342 extra = wpabuf_len(p2p->wfd_ie_probe_resp); 2343 #endif /* CONFIG_WIFI_DISPLAY */ 2344 2345 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]) 2346 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]); 2347 2348 if (query_count) 2349 extra += MAX_SVC_ADV_IE_LEN; 2350 2351 buf = wpabuf_alloc(1000 + extra); 2352 if (buf == NULL) 2353 return NULL; 2354 2355 if (p2p->go_neg_peer) { 2356 /* Advertise immediate availability of WPS credential */ 2357 pw_id = p2p_wps_method_pw_id(p2p->go_neg_peer->wps_method); 2358 } 2359 2360 if (p2p_build_wps_ie(p2p, buf, pw_id, 1) < 0) { 2361 p2p_dbg(p2p, "Failed to build WPS IE for Probe Response"); 2362 wpabuf_free(buf); 2363 return NULL; 2364 } 2365 2366 #ifdef CONFIG_WIFI_DISPLAY 2367 if (p2p->wfd_ie_probe_resp) 2368 wpabuf_put_buf(buf, p2p->wfd_ie_probe_resp); 2369 #endif /* CONFIG_WIFI_DISPLAY */ 2370 2371 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]) 2372 wpabuf_put_buf(buf, 2373 p2p->vendor_elem[VENDOR_ELEM_PROBE_RESP_P2P]); 2374 2375 /* P2P IE */ 2376 len = p2p_buf_add_ie_hdr(buf); 2377 p2p_buf_add_capability(buf, p2p->dev_capab & 2378 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0); 2379 if (p2p->ext_listen_interval) 2380 p2p_buf_add_ext_listen_timing(buf, p2p->ext_listen_period, 2381 p2p->ext_listen_interval); 2382 p2p_buf_add_device_info(buf, p2p, NULL); 2383 p2p_buf_update_ie_hdr(buf, len); 2384 2385 if (query_count) { 2386 p2p_buf_add_service_instance(buf, p2p, query_count, query_hash, 2387 p2p->p2ps_adv_list); 2388 } 2389 2390 return buf; 2391 } 2392 p2p_build_probe_resp_buf(struct p2p_data * p2p,struct wpabuf * buf,struct wpabuf * ies,const u8 * addr,int rx_freq)2393 static int p2p_build_probe_resp_buf(struct p2p_data *p2p, struct wpabuf *buf, 2394 struct wpabuf *ies, 2395 const u8 *addr, int rx_freq) 2396 { 2397 struct ieee80211_mgmt *resp; 2398 u8 channel, op_class; 2399 2400 resp = wpabuf_put(buf, offsetof(struct ieee80211_mgmt, 2401 u.probe_resp.variable)); 2402 2403 resp->frame_control = host_to_le16((WLAN_FC_TYPE_MGMT << 2) | 2404 (WLAN_FC_STYPE_PROBE_RESP << 4)); 2405 os_memcpy(resp->da, addr, ETH_ALEN); 2406 os_memcpy(resp->sa, p2p->cfg->dev_addr, ETH_ALEN); 2407 os_memcpy(resp->bssid, p2p->cfg->dev_addr, ETH_ALEN); 2408 resp->u.probe_resp.beacon_int = host_to_le16(100); 2409 /* hardware or low-level driver will setup seq_ctrl and timestamp */ 2410 resp->u.probe_resp.capab_info = 2411 host_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE | 2412 WLAN_CAPABILITY_PRIVACY | 2413 WLAN_CAPABILITY_SHORT_SLOT_TIME); 2414 2415 wpabuf_put_u8(buf, WLAN_EID_SSID); 2416 wpabuf_put_u8(buf, P2P_WILDCARD_SSID_LEN); 2417 wpabuf_put_data(buf, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); 2418 2419 wpabuf_put_u8(buf, WLAN_EID_SUPP_RATES); 2420 wpabuf_put_u8(buf, 8); 2421 wpabuf_put_u8(buf, (60 / 5) | 0x80); 2422 wpabuf_put_u8(buf, 90 / 5); 2423 wpabuf_put_u8(buf, (120 / 5) | 0x80); 2424 wpabuf_put_u8(buf, 180 / 5); 2425 wpabuf_put_u8(buf, (240 / 5) | 0x80); 2426 wpabuf_put_u8(buf, 360 / 5); 2427 wpabuf_put_u8(buf, 480 / 5); 2428 wpabuf_put_u8(buf, 540 / 5); 2429 2430 if (!rx_freq) { 2431 channel = p2p->cfg->channel; 2432 } else if (p2p_freq_to_channel(rx_freq, &op_class, &channel)) { 2433 p2p_err(p2p, "Failed to convert freq to channel"); 2434 return -1; 2435 } 2436 2437 wpabuf_put_u8(buf, WLAN_EID_DS_PARAMS); 2438 wpabuf_put_u8(buf, 1); 2439 wpabuf_put_u8(buf, channel); 2440 2441 wpabuf_put_buf(buf, ies); 2442 2443 return 0; 2444 } 2445 p2p_service_find_asp(struct p2p_data * p2p,const u8 * hash)2446 static int p2p_service_find_asp(struct p2p_data *p2p, const u8 *hash) 2447 { 2448 struct p2ps_advertisement *adv_data; 2449 int any_wfa; 2450 2451 p2p_dbg(p2p, "ASP find - ASP list: %p", p2p->p2ps_adv_list); 2452 2453 /* Wildcard org.wi-fi.wfds matches any WFA spec defined service */ 2454 any_wfa = os_memcmp(hash, p2p->wild_card_hash, P2PS_HASH_LEN) == 0; 2455 2456 adv_data = p2p->p2ps_adv_list; 2457 while (adv_data) { 2458 if (os_memcmp(hash, adv_data->hash, P2PS_HASH_LEN) == 0) 2459 return 1; /* exact hash match */ 2460 if (any_wfa && 2461 os_strncmp(adv_data->svc_name, P2PS_WILD_HASH_STR, 2462 os_strlen(P2PS_WILD_HASH_STR)) == 0) 2463 return 1; /* WFA service match */ 2464 adv_data = adv_data->next; 2465 } 2466 2467 return 0; 2468 } 2469 2470 2471 static enum p2p_probe_req_status p2p_reply_probe(struct p2p_data * p2p,const u8 * addr,const u8 * dst,const u8 * bssid,const u8 * ie,size_t ie_len,unsigned int rx_freq)2472 p2p_reply_probe(struct p2p_data *p2p, const u8 *addr, const u8 *dst, 2473 const u8 *bssid, const u8 *ie, size_t ie_len, 2474 unsigned int rx_freq) 2475 { 2476 struct ieee802_11_elems elems; 2477 struct wpabuf *buf; 2478 struct p2p_message msg; 2479 struct wpabuf *ies; 2480 2481 if (ieee802_11_parse_elems((u8 *) ie, ie_len, &elems, 0) == 2482 ParseFailed) { 2483 /* Ignore invalid Probe Request frames */ 2484 p2p_dbg(p2p, "Could not parse Probe Request frame - ignore it"); 2485 return P2P_PREQ_MALFORMED; 2486 } 2487 2488 if (elems.p2p == NULL) { 2489 /* not a P2P probe - ignore it */ 2490 p2p_dbg(p2p, "Not a P2P probe - ignore it"); 2491 return P2P_PREQ_NOT_P2P; 2492 } 2493 2494 if (dst && !is_broadcast_ether_addr(dst) && 2495 !ether_addr_equal(dst, p2p->cfg->dev_addr)) { 2496 /* Not sent to the broadcast address or our P2P Device Address 2497 */ 2498 p2p_dbg(p2p, "Probe Req DA " MACSTR " not ours - ignore it", 2499 MAC2STR(dst)); 2500 return P2P_PREQ_NOT_PROCESSED; 2501 } 2502 2503 if (bssid && !is_broadcast_ether_addr(bssid)) { 2504 /* Not sent to the Wildcard BSSID */ 2505 p2p_dbg(p2p, "Probe Req BSSID " MACSTR " not wildcard - ignore it", 2506 MAC2STR(bssid)); 2507 return P2P_PREQ_NOT_PROCESSED; 2508 } 2509 2510 if (elems.ssid == NULL || elems.ssid_len != P2P_WILDCARD_SSID_LEN || 2511 os_memcmp(elems.ssid, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN) != 2512 0) { 2513 /* not using P2P Wildcard SSID - ignore */ 2514 p2p_dbg(p2p, "Probe Req not using P2P Wildcard SSID - ignore it"); 2515 return P2P_PREQ_NOT_PROCESSED; 2516 } 2517 2518 if (supp_rates_11b_only(&elems)) { 2519 /* Indicates support for 11b rates only */ 2520 p2p_dbg(p2p, "Probe Req with 11b rates only supported - ignore it"); 2521 return P2P_PREQ_NOT_P2P; 2522 } 2523 2524 os_memset(&msg, 0, sizeof(msg)); 2525 if (p2p_parse_ies(ie, ie_len, &msg) < 0) { 2526 /* Could not parse P2P attributes */ 2527 p2p_dbg(p2p, "Could not parse P2P attributes in Probe Req - ignore it"); 2528 return P2P_PREQ_NOT_P2P; 2529 } 2530 2531 if (msg.service_hash && msg.service_hash_count) { 2532 const u8 *hash = msg.service_hash; 2533 u8 i; 2534 int p2ps_svc_found = 0; 2535 2536 p2p_dbg(p2p, "in_listen=%d drv_in_listen=%d when received P2PS Probe Request at %u MHz; own Listen channel %u, pending listen freq %u MHz", 2537 p2p->in_listen, p2p->drv_in_listen, rx_freq, 2538 p2p->cfg->channel, p2p->pending_listen_freq); 2539 2540 if (!p2p->in_listen && !p2p->drv_in_listen && 2541 p2p->pending_listen_freq && rx_freq && 2542 rx_freq != p2p->pending_listen_freq) { 2543 p2p_dbg(p2p, "Do not reply to Probe Request frame that was received on %u MHz while waiting to start Listen state on %u MHz", 2544 rx_freq, p2p->pending_listen_freq); 2545 p2p_parse_free(&msg); 2546 return P2P_PREQ_NOT_LISTEN; 2547 } 2548 2549 for (i = 0; i < msg.service_hash_count; i++) { 2550 if (p2p_service_find_asp(p2p, hash)) { 2551 p2p_dbg(p2p, "Service Hash match found: " 2552 MACSTR, MAC2STR(hash)); 2553 p2ps_svc_found = 1; 2554 break; 2555 } 2556 hash += P2PS_HASH_LEN; 2557 } 2558 2559 /* Probed hash unknown */ 2560 if (!p2ps_svc_found) { 2561 p2p_dbg(p2p, "No Service Hash match found"); 2562 p2p_parse_free(&msg); 2563 return P2P_PREQ_NOT_PROCESSED; 2564 } 2565 } else { 2566 /* This is not a P2PS Probe Request */ 2567 p2p_dbg(p2p, "No P2PS Hash in Probe Request"); 2568 2569 if (!p2p->in_listen || !p2p->drv_in_listen) { 2570 /* not in Listen state - ignore Probe Request */ 2571 p2p_dbg(p2p, "Not in Listen state (in_listen=%d drv_in_listen=%d) - ignore Probe Request", 2572 p2p->in_listen, p2p->drv_in_listen); 2573 p2p_parse_free(&msg); 2574 return P2P_PREQ_NOT_LISTEN; 2575 } 2576 } 2577 2578 if (msg.device_id && 2579 !ether_addr_equal(msg.device_id, p2p->cfg->dev_addr)) { 2580 /* Device ID did not match */ 2581 p2p_dbg(p2p, "Probe Req requested Device ID " MACSTR " did not match - ignore it", 2582 MAC2STR(msg.device_id)); 2583 p2p_parse_free(&msg); 2584 return P2P_PREQ_NOT_PROCESSED; 2585 } 2586 2587 /* Check Requested Device Type match */ 2588 if (msg.wps_attributes && 2589 !p2p_match_dev_type(p2p, msg.wps_attributes)) { 2590 /* No match with Requested Device Type */ 2591 p2p_dbg(p2p, "Probe Req requested Device Type did not match - ignore it"); 2592 p2p_parse_free(&msg); 2593 return P2P_PREQ_NOT_PROCESSED; 2594 } 2595 2596 if (!p2p->cfg->send_probe_resp) { 2597 /* Response generated elsewhere */ 2598 p2p_dbg(p2p, "Probe Resp generated elsewhere - do not generate additional response"); 2599 p2p_parse_free(&msg); 2600 return P2P_PREQ_NOT_PROCESSED; 2601 } 2602 2603 p2p_dbg(p2p, "Reply to P2P Probe Request in Listen state"); 2604 2605 /* 2606 * We do not really have a specific BSS that this frame is advertising, 2607 * so build a frame that has some information in valid format. This is 2608 * really only used for discovery purposes, not to learn exact BSS 2609 * parameters. 2610 */ 2611 ies = p2p_build_probe_resp_ies(p2p, msg.service_hash, 2612 msg.service_hash_count); 2613 p2p_parse_free(&msg); 2614 if (ies == NULL) 2615 return P2P_PREQ_NOT_PROCESSED; 2616 2617 buf = wpabuf_alloc(200 + wpabuf_len(ies)); 2618 if (buf == NULL) { 2619 wpabuf_free(ies); 2620 return P2P_PREQ_NOT_PROCESSED; 2621 } 2622 2623 if (p2p_build_probe_resp_buf(p2p, buf, ies, addr, rx_freq)) { 2624 wpabuf_free(ies); 2625 wpabuf_free(buf); 2626 return P2P_PREQ_NOT_PROCESSED; 2627 } 2628 2629 wpabuf_free(ies); 2630 2631 p2p->cfg->send_probe_resp(p2p->cfg->cb_ctx, buf, rx_freq); 2632 2633 wpabuf_free(buf); 2634 2635 return P2P_PREQ_PROCESSED; 2636 } 2637 2638 2639 enum p2p_probe_req_status p2p_probe_req_rx(struct p2p_data * p2p,const u8 * addr,const u8 * dst,const u8 * bssid,const u8 * ie,size_t ie_len,unsigned int rx_freq,int p2p_lo_started)2640 p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst, 2641 const u8 *bssid, const u8 *ie, size_t ie_len, 2642 unsigned int rx_freq, int p2p_lo_started) 2643 { 2644 enum p2p_probe_req_status res; 2645 2646 p2p_add_dev_from_probe_req(p2p, addr, ie, ie_len); 2647 2648 if (p2p_lo_started) { 2649 p2p_dbg(p2p, 2650 "Probe Response is offloaded, do not reply Probe Request"); 2651 return P2P_PREQ_PROCESSED; 2652 } 2653 2654 res = p2p_reply_probe(p2p, addr, dst, bssid, ie, ie_len, rx_freq); 2655 if (res != P2P_PREQ_PROCESSED && res != P2P_PREQ_NOT_PROCESSED) 2656 return res; 2657 2658 /* 2659 * Activate a pending GO Negotiation/Invite flow if a received Probe 2660 * Request frame is from an expected peer. Some devices may share the 2661 * same address for P2P and non-P2P STA running simultaneously. The 2662 * P2P_PREQ_PROCESSED and P2P_PREQ_NOT_PROCESSED p2p_reply_probe() 2663 * return values verified above ensure we are handling a Probe Request 2664 * frame from a P2P peer. 2665 */ 2666 if ((p2p->state == P2P_CONNECT || p2p->state == P2P_CONNECT_LISTEN) && 2667 p2p->go_neg_peer && 2668 ether_addr_equal(addr, p2p->go_neg_peer->info.p2p_device_addr) && 2669 !(p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { 2670 /* Received a Probe Request from GO Negotiation peer */ 2671 p2p_dbg(p2p, "Found GO Negotiation peer - try to start GO negotiation from timeout"); 2672 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL); 2673 eloop_register_timeout(0, 0, p2p_go_neg_start, p2p, NULL); 2674 return res; 2675 } 2676 2677 if ((p2p->state == P2P_INVITE || p2p->state == P2P_INVITE_LISTEN) && 2678 p2p->invite_peer && 2679 (p2p->invite_peer->flags & P2P_DEV_WAIT_INV_REQ_ACK) && 2680 ether_addr_equal(addr, p2p->invite_peer->info.p2p_device_addr)) { 2681 /* Received a Probe Request from Invite peer */ 2682 p2p_dbg(p2p, "Found Invite peer - try to start Invite from timeout"); 2683 eloop_cancel_timeout(p2p_invite_start, p2p, NULL); 2684 eloop_register_timeout(0, 0, p2p_invite_start, p2p, NULL); 2685 return res; 2686 } 2687 2688 return res; 2689 } 2690 2691 p2p_assoc_req_ie_wlan_ap(struct p2p_data * p2p,const u8 * bssid,u8 * buf,size_t len,struct wpabuf * p2p_ie)2692 static int p2p_assoc_req_ie_wlan_ap(struct p2p_data *p2p, const u8 *bssid, 2693 u8 *buf, size_t len, struct wpabuf *p2p_ie) 2694 { 2695 struct wpabuf *tmp; 2696 u8 *lpos; 2697 size_t tmplen; 2698 int res; 2699 u8 group_capab; 2700 struct p2p_message msg; 2701 2702 if (p2p_ie == NULL) 2703 return 0; /* WLAN AP is not a P2P manager */ 2704 2705 os_memset(&msg, 0, sizeof(msg)); 2706 if (p2p_parse_p2p_ie(p2p_ie, &msg) < 0) 2707 return 0; 2708 2709 p2p_dbg(p2p, "BSS P2P manageability %s", 2710 msg.manageability ? "enabled" : "disabled"); 2711 2712 if (!msg.manageability) 2713 return 0; 2714 2715 /* 2716 * (Re)Association Request - P2P IE 2717 * P2P Capability attribute (shall be present) 2718 * P2P Interface attribute (present if concurrent device and 2719 * P2P Management is enabled) 2720 */ 2721 tmp = wpabuf_alloc(200); 2722 if (tmp == NULL) 2723 return -1; 2724 2725 lpos = p2p_buf_add_ie_hdr(tmp); 2726 group_capab = 0; 2727 if (p2p->num_groups > 0) { 2728 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER; 2729 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && 2730 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) && 2731 p2p->cross_connect) 2732 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN; 2733 } 2734 p2p_buf_add_capability(tmp, p2p->dev_capab, group_capab); 2735 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && 2736 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED)) 2737 p2p_buf_add_p2p_interface(tmp, p2p); 2738 p2p_buf_update_ie_hdr(tmp, lpos); 2739 2740 tmplen = wpabuf_len(tmp); 2741 if (tmplen > len) 2742 res = -1; 2743 else { 2744 os_memcpy(buf, wpabuf_head(tmp), tmplen); 2745 res = tmplen; 2746 } 2747 wpabuf_free(tmp); 2748 2749 return res; 2750 } 2751 2752 p2p_assoc_req_ie(struct p2p_data * p2p,const u8 * bssid,u8 * buf,size_t len,int p2p_group,struct wpabuf * p2p_ie)2753 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf, 2754 size_t len, int p2p_group, struct wpabuf *p2p_ie) 2755 { 2756 struct wpabuf *tmp; 2757 u8 *lpos; 2758 struct p2p_device *peer; 2759 size_t tmplen; 2760 int res; 2761 size_t extra = 0; 2762 2763 if (!p2p_group) 2764 return p2p_assoc_req_ie_wlan_ap(p2p, bssid, buf, len, p2p_ie); 2765 2766 #ifdef CONFIG_WIFI_DISPLAY 2767 if (p2p->wfd_ie_assoc_req) 2768 extra = wpabuf_len(p2p->wfd_ie_assoc_req); 2769 #endif /* CONFIG_WIFI_DISPLAY */ 2770 2771 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]) 2772 extra += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]); 2773 2774 /* 2775 * (Re)Association Request - P2P IE 2776 * P2P Capability attribute (shall be present) 2777 * Extended Listen Timing (may be present) 2778 * P2P Device Info attribute (shall be present) 2779 */ 2780 tmp = wpabuf_alloc(200 + extra); 2781 if (tmp == NULL) 2782 return -1; 2783 2784 #ifdef CONFIG_WIFI_DISPLAY 2785 if (p2p->wfd_ie_assoc_req) 2786 wpabuf_put_buf(tmp, p2p->wfd_ie_assoc_req); 2787 #endif /* CONFIG_WIFI_DISPLAY */ 2788 2789 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]) 2790 wpabuf_put_buf(tmp, 2791 p2p->vendor_elem[VENDOR_ELEM_P2P_ASSOC_REQ]); 2792 2793 peer = bssid ? p2p_get_device(p2p, bssid) : NULL; 2794 2795 lpos = p2p_buf_add_ie_hdr(tmp); 2796 p2p_buf_add_capability(tmp, p2p->dev_capab, 0); 2797 if (p2p->ext_listen_interval) 2798 p2p_buf_add_ext_listen_timing(tmp, p2p->ext_listen_period, 2799 p2p->ext_listen_interval); 2800 p2p_buf_add_device_info(tmp, p2p, peer); 2801 p2p_buf_update_ie_hdr(tmp, lpos); 2802 2803 tmplen = wpabuf_len(tmp); 2804 if (tmplen > len) 2805 res = -1; 2806 else { 2807 os_memcpy(buf, wpabuf_head(tmp), tmplen); 2808 res = tmplen; 2809 } 2810 wpabuf_free(tmp); 2811 2812 return res; 2813 } 2814 2815 p2p_scan_result_text(const u8 * ies,size_t ies_len,char * buf,char * end)2816 int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end) 2817 { 2818 struct wpabuf *p2p_ie; 2819 int ret; 2820 2821 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, P2P_IE_VENDOR_TYPE); 2822 if (p2p_ie == NULL) 2823 return 0; 2824 2825 ret = p2p_attr_text(p2p_ie, buf, end); 2826 wpabuf_free(p2p_ie); 2827 return ret; 2828 } 2829 2830 2831 struct p2ps_advertisement * p2p_service_p2ps_id(struct p2p_data * p2p,u32 adv_id)2832 p2p_service_p2ps_id(struct p2p_data *p2p, u32 adv_id) 2833 { 2834 struct p2ps_advertisement *adv_data; 2835 2836 if (!p2p) 2837 return NULL; 2838 2839 adv_data = p2p->p2ps_adv_list; 2840 while (adv_data) { 2841 if (adv_data->id == adv_id) 2842 return adv_data; 2843 adv_data = adv_data->next; 2844 } 2845 2846 return NULL; 2847 } 2848 2849 p2p_service_del_asp(struct p2p_data * p2p,u32 adv_id)2850 int p2p_service_del_asp(struct p2p_data *p2p, u32 adv_id) 2851 { 2852 struct p2ps_advertisement *adv_data; 2853 struct p2ps_advertisement **prior; 2854 2855 if (!p2p) 2856 return -1; 2857 2858 adv_data = p2p->p2ps_adv_list; 2859 prior = &p2p->p2ps_adv_list; 2860 while (adv_data) { 2861 if (adv_data->id == adv_id) { 2862 p2p_dbg(p2p, "Delete ASP adv_id=0x%x", adv_id); 2863 *prior = adv_data->next; 2864 os_free(adv_data); 2865 return 0; 2866 } 2867 prior = &adv_data->next; 2868 adv_data = adv_data->next; 2869 } 2870 2871 return -1; 2872 } 2873 2874 p2p_service_add_asp(struct p2p_data * p2p,int auto_accept,u32 adv_id,const char * adv_str,u8 svc_state,u16 config_methods,const char * svc_info,const u8 * cpt_priority)2875 int p2p_service_add_asp(struct p2p_data *p2p, int auto_accept, u32 adv_id, 2876 const char *adv_str, u8 svc_state, u16 config_methods, 2877 const char *svc_info, const u8 *cpt_priority) 2878 { 2879 struct p2ps_advertisement *adv_data, *tmp, **prev; 2880 u8 buf[P2PS_HASH_LEN]; 2881 size_t adv_data_len, adv_len, info_len = 0; 2882 int i; 2883 2884 if (!p2p || !adv_str || !adv_str[0] || !cpt_priority) 2885 return -1; 2886 2887 if (!(config_methods & p2p->cfg->config_methods)) { 2888 p2p_dbg(p2p, "Config methods not supported svc: 0x%x dev: 0x%x", 2889 config_methods, p2p->cfg->config_methods); 2890 return -1; 2891 } 2892 2893 if (!p2ps_gen_hash(p2p, adv_str, buf)) 2894 return -1; 2895 2896 if (svc_info) 2897 info_len = os_strlen(svc_info); 2898 adv_len = os_strlen(adv_str); 2899 adv_data_len = sizeof(struct p2ps_advertisement) + adv_len + 1 + 2900 info_len + 1; 2901 2902 adv_data = os_zalloc(adv_data_len); 2903 if (!adv_data) 2904 return -1; 2905 2906 os_memcpy(adv_data->hash, buf, P2PS_HASH_LEN); 2907 adv_data->id = adv_id; 2908 adv_data->state = svc_state; 2909 adv_data->config_methods = config_methods & p2p->cfg->config_methods; 2910 adv_data->auto_accept = (u8) auto_accept; 2911 os_memcpy(adv_data->svc_name, adv_str, adv_len); 2912 2913 for (i = 0; cpt_priority[i] && i < P2PS_FEATURE_CAPAB_CPT_MAX; i++) { 2914 adv_data->cpt_priority[i] = cpt_priority[i]; 2915 adv_data->cpt_mask |= cpt_priority[i]; 2916 } 2917 2918 if (svc_info && info_len) { 2919 adv_data->svc_info = &adv_data->svc_name[adv_len + 1]; 2920 os_memcpy(adv_data->svc_info, svc_info, info_len); 2921 } 2922 2923 /* 2924 * Group Advertisements by service string. They do not need to be 2925 * sorted, but groups allow easier Probe Response instance grouping 2926 */ 2927 tmp = p2p->p2ps_adv_list; 2928 prev = &p2p->p2ps_adv_list; 2929 while (tmp) { 2930 if (tmp->id == adv_data->id) { 2931 if (os_strcmp(tmp->svc_name, adv_data->svc_name) != 0) { 2932 os_free(adv_data); 2933 return -1; 2934 } 2935 adv_data->next = tmp->next; 2936 *prev = adv_data; 2937 os_free(tmp); 2938 goto inserted; 2939 } else { 2940 if (os_strcmp(tmp->svc_name, adv_data->svc_name) == 0) { 2941 adv_data->next = tmp->next; 2942 tmp->next = adv_data; 2943 goto inserted; 2944 } 2945 } 2946 prev = &tmp->next; 2947 tmp = tmp->next; 2948 } 2949 2950 /* No svc_name match found */ 2951 adv_data->next = p2p->p2ps_adv_list; 2952 p2p->p2ps_adv_list = adv_data; 2953 2954 inserted: 2955 p2p_dbg(p2p, 2956 "Added ASP advertisement adv_id=0x%x config_methods=0x%x svc_state=0x%x adv_str='%s' cpt_mask=0x%x", 2957 adv_id, adv_data->config_methods, svc_state, adv_str, 2958 adv_data->cpt_mask); 2959 2960 return 0; 2961 } 2962 2963 p2p_service_flush_asp(struct p2p_data * p2p)2964 void p2p_service_flush_asp(struct p2p_data *p2p) 2965 { 2966 struct p2ps_advertisement *adv, *prev; 2967 2968 if (!p2p) 2969 return; 2970 2971 adv = p2p->p2ps_adv_list; 2972 while (adv) { 2973 prev = adv; 2974 adv = adv->next; 2975 os_free(prev); 2976 } 2977 2978 p2p->p2ps_adv_list = NULL; 2979 p2ps_prov_free(p2p); 2980 p2p_dbg(p2p, "All ASP advertisements flushed"); 2981 } 2982 2983 p2p_parse_dev_addr_in_p2p_ie(struct wpabuf * p2p_ie,u8 * dev_addr)2984 int p2p_parse_dev_addr_in_p2p_ie(struct wpabuf *p2p_ie, u8 *dev_addr) 2985 { 2986 struct p2p_message msg; 2987 2988 os_memset(&msg, 0, sizeof(msg)); 2989 if (p2p_parse_p2p_ie(p2p_ie, &msg)) 2990 return -1; 2991 2992 if (msg.p2p_device_addr) { 2993 os_memcpy(dev_addr, msg.p2p_device_addr, ETH_ALEN); 2994 return 0; 2995 } else if (msg.device_id) { 2996 os_memcpy(dev_addr, msg.device_id, ETH_ALEN); 2997 return 0; 2998 } 2999 return -1; 3000 } 3001 3002 p2p_parse_dev_addr(const u8 * ies,size_t ies_len,u8 * dev_addr)3003 int p2p_parse_dev_addr(const u8 *ies, size_t ies_len, u8 *dev_addr) 3004 { 3005 struct wpabuf *p2p_ie; 3006 int ret; 3007 3008 p2p_ie = ieee802_11_vendor_ie_concat(ies, ies_len, 3009 P2P_IE_VENDOR_TYPE); 3010 if (p2p_ie == NULL) 3011 return -1; 3012 ret = p2p_parse_dev_addr_in_p2p_ie(p2p_ie, dev_addr); 3013 wpabuf_free(p2p_ie); 3014 return ret; 3015 } 3016 3017 p2p_clear_go_neg(struct p2p_data * p2p)3018 static void p2p_clear_go_neg(struct p2p_data *p2p) 3019 { 3020 p2p->go_neg_peer = NULL; 3021 p2p_clear_timeout(p2p); 3022 p2p_set_state(p2p, P2P_IDLE); 3023 } 3024 3025 p2p_wps_success_cb(struct p2p_data * p2p,const u8 * mac_addr)3026 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr) 3027 { 3028 if (p2p->go_neg_peer == NULL) { 3029 p2p_dbg(p2p, "No pending Group Formation - ignore WPS registration success notification"); 3030 return; /* No pending Group Formation */ 3031 } 3032 3033 if (!ether_addr_equal(mac_addr, p2p->go_neg_peer->intended_addr)) { 3034 p2p_dbg(p2p, "Ignore WPS registration success notification for " 3035 MACSTR " (GO Negotiation peer " MACSTR ")", 3036 MAC2STR(mac_addr), 3037 MAC2STR(p2p->go_neg_peer->intended_addr)); 3038 return; /* Ignore unexpected peer address */ 3039 } 3040 3041 p2p_dbg(p2p, "Group Formation completed successfully with " MACSTR, 3042 MAC2STR(mac_addr)); 3043 3044 p2p_clear_go_neg(p2p); 3045 } 3046 3047 p2p_group_formation_failed(struct p2p_data * p2p)3048 void p2p_group_formation_failed(struct p2p_data *p2p) 3049 { 3050 if (p2p->go_neg_peer == NULL) { 3051 p2p_dbg(p2p, "No pending Group Formation - ignore group formation failure notification"); 3052 return; /* No pending Group Formation */ 3053 } 3054 3055 p2p_dbg(p2p, "Group Formation failed with " MACSTR, 3056 MAC2STR(p2p->go_neg_peer->intended_addr)); 3057 3058 p2p_clear_go_neg(p2p); 3059 } 3060 3061 is_p2p_6ghz_disabled(struct p2p_data * p2p)3062 bool is_p2p_6ghz_disabled(struct p2p_data *p2p) 3063 { 3064 if (p2p) 3065 return p2p->cfg->p2p_6ghz_disable; 3066 return false; 3067 } 3068 3069 p2p_set_dev_addr(struct p2p_data * p2p,const u8 * addr)3070 void p2p_set_dev_addr(struct p2p_data *p2p, const u8 *addr) 3071 { 3072 if (p2p && addr) 3073 os_memcpy(p2p->cfg->dev_addr, addr, ETH_ALEN); 3074 } 3075 3076 p2p_pairing_info_deinit(struct p2p_data * p2p)3077 static void p2p_pairing_info_deinit(struct p2p_data *p2p) 3078 { 3079 #ifdef CONFIG_PASN 3080 pasn_initiator_pmksa_cache_deinit(p2p->initiator_pmksa); 3081 pasn_responder_pmksa_cache_deinit(p2p->responder_pmksa); 3082 #endif /* CONFIG_PASN */ 3083 os_free(p2p->pairing_info); 3084 } 3085 3086 p2p_pairing_info_init(struct p2p_data * p2p)3087 static int p2p_pairing_info_init(struct p2p_data *p2p) 3088 { 3089 struct p2p_pairing_info *pairing_info; 3090 3091 if (p2p->cfg->pairing_config.dik_len > DEVICE_IDENTITY_KEY_MAX_LEN) 3092 return -1; 3093 3094 pairing_info = os_zalloc(sizeof(struct p2p_pairing_info)); 3095 if (!pairing_info) 3096 return -1; 3097 3098 pairing_info->enable_pairing_setup = 3099 p2p->cfg->pairing_config.enable_pairing_setup; 3100 pairing_info->enable_pairing_cache = 3101 p2p->cfg->pairing_config.enable_pairing_cache; 3102 pairing_info->supported_bootstrap = 3103 p2p->cfg->pairing_config.bootstrap_methods; 3104 3105 pairing_info->dev_ik.cipher_version = 3106 p2p->cfg->pairing_config.dik_cipher; 3107 pairing_info->dev_ik.dik_len = p2p->cfg->pairing_config.dik_len; 3108 os_memcpy(pairing_info->dev_ik.dik_data, 3109 p2p->cfg->pairing_config.dik_data, 3110 p2p->cfg->pairing_config.dik_len); 3111 pairing_info->dev_ik.expiration = 24; /* hours */ 3112 3113 p2p_pairing_info_deinit(p2p); 3114 3115 p2p->pairing_info = pairing_info; 3116 #ifdef CONFIG_PASN 3117 p2p->initiator_pmksa = pasn_initiator_pmksa_cache_init(); 3118 p2p->responder_pmksa = pasn_responder_pmksa_cache_init(); 3119 #endif /* CONFIG_PASN */ 3120 3121 return 0; 3122 } 3123 3124 p2p_init(const struct p2p_config * cfg)3125 struct p2p_data * p2p_init(const struct p2p_config *cfg) 3126 { 3127 struct p2p_data *p2p; 3128 3129 if (cfg->max_peers < 1 || 3130 cfg->passphrase_len < 8 || cfg->passphrase_len > 63) 3131 return NULL; 3132 3133 p2p = os_zalloc(sizeof(*p2p) + sizeof(*cfg)); 3134 if (p2p == NULL) 3135 return NULL; 3136 p2p->cfg = (struct p2p_config *) (p2p + 1); 3137 os_memcpy(p2p->cfg, cfg, sizeof(*cfg)); 3138 if (cfg->dev_name) 3139 p2p->cfg->dev_name = os_strdup(cfg->dev_name); 3140 if (cfg->manufacturer) 3141 p2p->cfg->manufacturer = os_strdup(cfg->manufacturer); 3142 if (cfg->model_name) 3143 p2p->cfg->model_name = os_strdup(cfg->model_name); 3144 if (cfg->model_number) 3145 p2p->cfg->model_number = os_strdup(cfg->model_number); 3146 if (cfg->serial_number) 3147 p2p->cfg->serial_number = os_strdup(cfg->serial_number); 3148 if (cfg->pref_chan) { 3149 p2p->cfg->pref_chan = os_malloc(cfg->num_pref_chan * 3150 sizeof(struct p2p_channel)); 3151 if (p2p->cfg->pref_chan) { 3152 os_memcpy(p2p->cfg->pref_chan, cfg->pref_chan, 3153 cfg->num_pref_chan * 3154 sizeof(struct p2p_channel)); 3155 } else 3156 p2p->cfg->num_pref_chan = 0; 3157 } 3158 3159 p2ps_gen_hash(p2p, P2PS_WILD_HASH_STR, p2p->wild_card_hash); 3160 3161 p2p->min_disc_int = 1; 3162 p2p->max_disc_int = 3; 3163 p2p->max_disc_tu = -1; 3164 3165 if (os_get_random(&p2p->next_tie_breaker, 1) < 0) 3166 p2p->next_tie_breaker = 0; 3167 p2p->next_tie_breaker &= 0x01; 3168 if (cfg->sd_request) 3169 p2p->dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY; 3170 p2p->dev_capab |= P2P_DEV_CAPAB_INVITATION_PROCEDURE; 3171 if (cfg->concurrent_operations) 3172 p2p->dev_capab |= P2P_DEV_CAPAB_CONCURRENT_OPER; 3173 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 3174 3175 dl_list_init(&p2p->devices); 3176 3177 p2p->go_timeout = 100; 3178 p2p->client_timeout = 20; 3179 p2p->num_p2p_sd_queries = 0; 3180 /* Default comeback after one second */ 3181 if (!p2p->cfg->comeback_after) 3182 p2p->cfg->comeback_after = 977; /* TUs */ 3183 p2p_pairing_info_init(p2p); 3184 3185 p2p_dbg(p2p, "initialized"); 3186 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels); 3187 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels); 3188 3189 return p2p; 3190 } 3191 3192 p2p_deinit(struct p2p_data * p2p)3193 void p2p_deinit(struct p2p_data *p2p) 3194 { 3195 #ifdef CONFIG_WIFI_DISPLAY 3196 wpabuf_free(p2p->wfd_ie_beacon); 3197 wpabuf_free(p2p->wfd_ie_probe_req); 3198 wpabuf_free(p2p->wfd_ie_probe_resp); 3199 wpabuf_free(p2p->wfd_ie_assoc_req); 3200 wpabuf_free(p2p->wfd_ie_invitation); 3201 wpabuf_free(p2p->wfd_ie_prov_disc_req); 3202 wpabuf_free(p2p->wfd_ie_prov_disc_resp); 3203 wpabuf_free(p2p->wfd_ie_go_neg); 3204 wpabuf_free(p2p->wfd_dev_info); 3205 wpabuf_free(p2p->wfd_assoc_bssid); 3206 wpabuf_free(p2p->wfd_coupled_sink_info); 3207 wpabuf_free(p2p->wfd_r2_dev_info); 3208 #endif /* CONFIG_WIFI_DISPLAY */ 3209 3210 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 3211 eloop_cancel_timeout(p2p_go_neg_start, p2p, NULL); 3212 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL); 3213 p2p_flush(p2p); 3214 p2p_free_req_dev_types(p2p); 3215 os_free(p2p->cfg->dev_name); 3216 os_free(p2p->cfg->manufacturer); 3217 os_free(p2p->cfg->model_name); 3218 os_free(p2p->cfg->model_number); 3219 os_free(p2p->cfg->serial_number); 3220 os_free(p2p->cfg->pref_chan); 3221 os_free(p2p->groups); 3222 p2ps_prov_free(p2p); 3223 wpabuf_free(p2p->sd_resp); 3224 p2p_remove_wps_vendor_extensions(p2p); 3225 os_free(p2p->no_go_freq.range); 3226 p2p_service_flush_asp(p2p); 3227 p2p_pairing_info_deinit(p2p); 3228 3229 os_free(p2p); 3230 } 3231 3232 p2p_flush(struct p2p_data * p2p)3233 void p2p_flush(struct p2p_data *p2p) 3234 { 3235 struct p2p_device *dev, *prev; 3236 3237 p2p_ext_listen(p2p, 0, 0); 3238 p2p_stop_find(p2p); 3239 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device, 3240 list) { 3241 dl_list_del(&dev->list); 3242 p2p_device_free(p2p, dev); 3243 } 3244 p2p_free_sd_queries(p2p); 3245 p2p->ssid_set = 0; 3246 p2ps_prov_free(p2p); 3247 p2p_reset_pending_pd(p2p); 3248 p2p->override_pref_op_class = 0; 3249 p2p->override_pref_channel = 0; 3250 } 3251 3252 p2p_unauthorize(struct p2p_data * p2p,const u8 * addr)3253 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr) 3254 { 3255 struct p2p_device *dev; 3256 3257 dev = p2p_get_device(p2p, addr); 3258 if (dev == NULL) 3259 return -1; 3260 3261 p2p_dbg(p2p, "Unauthorizing " MACSTR, MAC2STR(addr)); 3262 3263 if (p2p->go_neg_peer == dev) { 3264 eloop_cancel_timeout(p2p_go_neg_wait_timeout, p2p, NULL); 3265 p2p->go_neg_peer = NULL; 3266 } 3267 3268 dev->wps_method = WPS_NOT_READY; 3269 dev->oob_pw_id = 0; 3270 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE; 3271 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM; 3272 3273 return 0; 3274 } 3275 3276 p2p_set_dev_name(struct p2p_data * p2p,const char * dev_name)3277 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name) 3278 { 3279 os_free(p2p->cfg->dev_name); 3280 if (dev_name) { 3281 p2p->cfg->dev_name = os_strdup(dev_name); 3282 if (p2p->cfg->dev_name == NULL) 3283 return -1; 3284 } else 3285 p2p->cfg->dev_name = NULL; 3286 return 0; 3287 } 3288 3289 p2p_set_manufacturer(struct p2p_data * p2p,const char * manufacturer)3290 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer) 3291 { 3292 os_free(p2p->cfg->manufacturer); 3293 p2p->cfg->manufacturer = NULL; 3294 if (manufacturer) { 3295 p2p->cfg->manufacturer = os_strdup(manufacturer); 3296 if (p2p->cfg->manufacturer == NULL) 3297 return -1; 3298 } 3299 3300 return 0; 3301 } 3302 3303 p2p_set_model_name(struct p2p_data * p2p,const char * model_name)3304 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name) 3305 { 3306 os_free(p2p->cfg->model_name); 3307 p2p->cfg->model_name = NULL; 3308 if (model_name) { 3309 p2p->cfg->model_name = os_strdup(model_name); 3310 if (p2p->cfg->model_name == NULL) 3311 return -1; 3312 } 3313 3314 return 0; 3315 } 3316 3317 p2p_set_model_number(struct p2p_data * p2p,const char * model_number)3318 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number) 3319 { 3320 os_free(p2p->cfg->model_number); 3321 p2p->cfg->model_number = NULL; 3322 if (model_number) { 3323 p2p->cfg->model_number = os_strdup(model_number); 3324 if (p2p->cfg->model_number == NULL) 3325 return -1; 3326 } 3327 3328 return 0; 3329 } 3330 3331 p2p_set_serial_number(struct p2p_data * p2p,const char * serial_number)3332 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number) 3333 { 3334 os_free(p2p->cfg->serial_number); 3335 p2p->cfg->serial_number = NULL; 3336 if (serial_number) { 3337 p2p->cfg->serial_number = os_strdup(serial_number); 3338 if (p2p->cfg->serial_number == NULL) 3339 return -1; 3340 } 3341 3342 return 0; 3343 } 3344 3345 p2p_set_config_methods(struct p2p_data * p2p,u16 config_methods)3346 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods) 3347 { 3348 p2p->cfg->config_methods = config_methods; 3349 } 3350 3351 p2p_set_uuid(struct p2p_data * p2p,const u8 * uuid)3352 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid) 3353 { 3354 os_memcpy(p2p->cfg->uuid, uuid, 16); 3355 } 3356 3357 p2p_set_pri_dev_type(struct p2p_data * p2p,const u8 * pri_dev_type)3358 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type) 3359 { 3360 os_memcpy(p2p->cfg->pri_dev_type, pri_dev_type, 8); 3361 return 0; 3362 } 3363 3364 p2p_set_sec_dev_types(struct p2p_data * p2p,const u8 dev_types[][8],size_t num_dev_types)3365 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8], 3366 size_t num_dev_types) 3367 { 3368 if (num_dev_types > P2P_SEC_DEVICE_TYPES) 3369 num_dev_types = P2P_SEC_DEVICE_TYPES; 3370 p2p->cfg->num_sec_dev_types = num_dev_types; 3371 os_memcpy(p2p->cfg->sec_dev_type, dev_types, num_dev_types * 8); 3372 return 0; 3373 } 3374 3375 p2p_remove_wps_vendor_extensions(struct p2p_data * p2p)3376 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p) 3377 { 3378 int i; 3379 3380 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 3381 wpabuf_free(p2p->wps_vendor_ext[i]); 3382 p2p->wps_vendor_ext[i] = NULL; 3383 } 3384 } 3385 3386 p2p_add_wps_vendor_extension(struct p2p_data * p2p,const struct wpabuf * vendor_ext)3387 int p2p_add_wps_vendor_extension(struct p2p_data *p2p, 3388 const struct wpabuf *vendor_ext) 3389 { 3390 int i; 3391 3392 if (vendor_ext == NULL) 3393 return -1; 3394 3395 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 3396 if (p2p->wps_vendor_ext[i] == NULL) 3397 break; 3398 } 3399 if (i >= P2P_MAX_WPS_VENDOR_EXT) 3400 return -1; 3401 3402 p2p->wps_vendor_ext[i] = wpabuf_dup(vendor_ext); 3403 if (p2p->wps_vendor_ext[i] == NULL) 3404 return -1; 3405 3406 return 0; 3407 } 3408 3409 p2p_set_country(struct p2p_data * p2p,const char * country)3410 int p2p_set_country(struct p2p_data *p2p, const char *country) 3411 { 3412 os_memcpy(p2p->cfg->country, country, 3); 3413 return 0; 3414 } 3415 3416 p2p_pre_find_operation(struct p2p_data * p2p,struct p2p_device * dev)3417 static int p2p_pre_find_operation(struct p2p_data *p2p, struct p2p_device *dev) 3418 { 3419 int res; 3420 3421 if (dev->sd_pending_bcast_queries == 0) { 3422 /* Initialize with total number of registered broadcast 3423 * SD queries. */ 3424 dev->sd_pending_bcast_queries = p2p->num_p2p_sd_queries; 3425 } 3426 3427 res = p2p_start_sd(p2p, dev); 3428 if (res == -2) 3429 return -2; 3430 if (res == 0) 3431 return 1; 3432 3433 if (dev->req_config_methods && 3434 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) { 3435 p2p_dbg(p2p, "Send pending Provision Discovery Request to " 3436 MACSTR " (config methods 0x%x)", 3437 MAC2STR(dev->info.p2p_device_addr), 3438 dev->req_config_methods); 3439 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0) 3440 return 1; 3441 } 3442 3443 return 0; 3444 } 3445 3446 p2p_continue_find(struct p2p_data * p2p)3447 void p2p_continue_find(struct p2p_data *p2p) 3448 { 3449 struct p2p_device *dev; 3450 int found, res; 3451 3452 p2p_set_state(p2p, P2P_SEARCH); 3453 3454 /* Continue from the device following the last iteration */ 3455 found = 0; 3456 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 3457 if (dev == p2p->last_p2p_find_oper) { 3458 found = 1; 3459 continue; 3460 } 3461 if (!found) 3462 continue; 3463 res = p2p_pre_find_operation(p2p, dev); 3464 if (res > 0) { 3465 p2p->last_p2p_find_oper = dev; 3466 return; 3467 } 3468 if (res == -2) 3469 goto skip_sd; 3470 } 3471 3472 /* 3473 * Wrap around to the beginning of the list and continue until the last 3474 * iteration device. 3475 */ 3476 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 3477 res = p2p_pre_find_operation(p2p, dev); 3478 if (res > 0) { 3479 p2p->last_p2p_find_oper = dev; 3480 return; 3481 } 3482 if (res == -2) 3483 goto skip_sd; 3484 if (dev == p2p->last_p2p_find_oper) 3485 break; 3486 } 3487 3488 skip_sd: 3489 os_memset(p2p->sd_query_no_ack, 0, ETH_ALEN); 3490 p2p_listen_in_find(p2p, 1); 3491 } 3492 3493 p2p_sd_query_cb(struct p2p_data * p2p,int success)3494 void p2p_sd_query_cb(struct p2p_data *p2p, int success) 3495 { 3496 p2p_dbg(p2p, "Service Discovery Query TX callback: success=%d", 3497 success); 3498 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3499 3500 if (!success) { 3501 if (p2p->sd_peer) { 3502 if (is_zero_ether_addr(p2p->sd_query_no_ack)) { 3503 os_memcpy(p2p->sd_query_no_ack, 3504 p2p->sd_peer->info.p2p_device_addr, 3505 ETH_ALEN); 3506 p2p_dbg(p2p, 3507 "First SD Query no-ACK in this search iteration: " 3508 MACSTR, MAC2STR(p2p->sd_query_no_ack)); 3509 } 3510 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3511 } 3512 p2p->sd_peer = NULL; 3513 if (p2p->state != P2P_IDLE) 3514 p2p_continue_find(p2p); 3515 return; 3516 } 3517 3518 if (p2p->sd_peer == NULL) { 3519 p2p_dbg(p2p, "No SD peer entry known"); 3520 if (p2p->state != P2P_IDLE) 3521 p2p_continue_find(p2p); 3522 return; 3523 } 3524 3525 if (p2p->sd_query && p2p->sd_query->for_all_peers) { 3526 /* Update the pending broadcast SD query count for this device 3527 */ 3528 p2p->sd_peer->sd_pending_bcast_queries--; 3529 3530 /* 3531 * If there are no pending broadcast queries for this device, 3532 * mark it as done (-1). 3533 */ 3534 if (p2p->sd_peer->sd_pending_bcast_queries == 0) 3535 p2p->sd_peer->sd_pending_bcast_queries = -1; 3536 } 3537 3538 /* Wait for response from the peer */ 3539 p2p_set_state(p2p, P2P_SD_DURING_FIND); 3540 p2p_set_timeout(p2p, 0, 200000); 3541 } 3542 3543 3544 /** 3545 * p2p_retry_pd - Retry any pending provision disc requests in IDLE state 3546 * @p2p: P2P module context from p2p_init() 3547 */ p2p_retry_pd(struct p2p_data * p2p)3548 static void p2p_retry_pd(struct p2p_data *p2p) 3549 { 3550 struct p2p_device *dev; 3551 3552 /* 3553 * Retry the prov disc req attempt only for the peer that the user had 3554 * requested. 3555 */ 3556 3557 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 3558 if (!ether_addr_equal(p2p->pending_pd_devaddr, 3559 dev->info.p2p_device_addr)) 3560 continue; 3561 if (!dev->req_config_methods && !dev->req_bootstrap_method) 3562 continue; 3563 3564 p2p_dbg(p2p, "Send pending Provision Discovery Request to " 3565 MACSTR " (config methods 0x%x)", 3566 MAC2STR(dev->info.p2p_device_addr), 3567 dev->req_config_methods); 3568 p2p_send_prov_disc_req(p2p, dev, 3569 dev->flags & P2P_DEV_PD_FOR_JOIN, 3570 p2p->pd_force_freq); 3571 return; 3572 } 3573 } 3574 3575 p2p_prov_disc_cb(struct p2p_data * p2p,int success)3576 static void p2p_prov_disc_cb(struct p2p_data *p2p, int success) 3577 { 3578 p2p_dbg(p2p, "Provision Discovery Request TX callback: success=%d", 3579 success); 3580 3581 /* 3582 * Postpone resetting the pending action state till after we actually 3583 * time out. This allows us to take some action like notifying any 3584 * interested parties about no response to the request. 3585 * 3586 * When the timer (below) goes off we check in IDLE, SEARCH, or 3587 * LISTEN_ONLY state, which are the only allowed states to issue a PD 3588 * requests in, if this was still pending and then raise notification. 3589 */ 3590 3591 if (!success) { 3592 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3593 3594 if (p2p->user_initiated_pd && 3595 (p2p->state == P2P_SEARCH || p2p->state == P2P_LISTEN_ONLY)) 3596 { 3597 /* Retry request from timeout to avoid busy loops */ 3598 p2p->pending_action_state = P2P_PENDING_PD; 3599 p2p_set_timeout(p2p, 0, 50000); 3600 } else if (p2p->state != P2P_IDLE) 3601 p2p_continue_find(p2p); 3602 else if (p2p->user_initiated_pd) { 3603 p2p->pending_action_state = P2P_PENDING_PD; 3604 p2p_set_timeout(p2p, 0, 300000); 3605 } 3606 return; 3607 } 3608 3609 /* 3610 * If after PD Request the peer doesn't expect to receive PD Response 3611 * the PD Request ACK indicates a completion of the current PD. This 3612 * happens only on the advertiser side sending the follow-on PD Request 3613 * with the status different than 12 (Success: accepted by user). 3614 */ 3615 if (p2p->p2ps_prov && !p2p->p2ps_prov->pd_seeker && 3616 p2p->p2ps_prov->status != P2P_SC_SUCCESS_DEFERRED) { 3617 p2p_dbg(p2p, "P2PS PD completion on Follow-on PD Request ACK"); 3618 3619 if (p2p->send_action_in_progress) { 3620 p2p->send_action_in_progress = 0; 3621 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3622 } 3623 3624 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3625 3626 if (p2p->cfg->p2ps_prov_complete) { 3627 p2p->cfg->p2ps_prov_complete( 3628 p2p->cfg->cb_ctx, 3629 p2p->p2ps_prov->status, 3630 p2p->p2ps_prov->adv_mac, 3631 p2p->p2ps_prov->adv_mac, 3632 p2p->p2ps_prov->session_mac, 3633 NULL, p2p->p2ps_prov->adv_id, 3634 p2p->p2ps_prov->session_id, 3635 0, 0, NULL, 0, 0, 0, 3636 NULL, NULL, 0, 0, NULL, 0); 3637 } 3638 3639 if (p2p->user_initiated_pd) 3640 p2p_reset_pending_pd(p2p); 3641 3642 p2ps_prov_free(p2p); 3643 return; 3644 } 3645 3646 /* 3647 * This postponing, of resetting pending_action_state, needs to be 3648 * done only for user initiated PD requests and not internal ones. 3649 */ 3650 if (p2p->user_initiated_pd) 3651 p2p->pending_action_state = P2P_PENDING_PD; 3652 else 3653 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3654 3655 /* Wait for response from the peer */ 3656 if (p2p->state == P2P_SEARCH) 3657 p2p_set_state(p2p, P2P_PD_DURING_FIND); 3658 p2p_set_timeout(p2p, 0, 200000); 3659 } 3660 3661 p2p_prov_disc_resp_cb(struct p2p_data * p2p,int success)3662 static void p2p_prov_disc_resp_cb(struct p2p_data *p2p, int success) 3663 { 3664 p2p_dbg(p2p, "Provision Discovery Response TX callback: success=%d", 3665 success); 3666 3667 if (p2p->send_action_in_progress) { 3668 p2p->send_action_in_progress = 0; 3669 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3670 } 3671 3672 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3673 3674 if (!success) { 3675 if (p2p->state == P2P_SEARCH) 3676 p2p_continue_find(p2p); 3677 return; 3678 } 3679 3680 if (!p2p->cfg->prov_disc_resp_cb || 3681 p2p->cfg->prov_disc_resp_cb(p2p->cfg->cb_ctx) < 1) { 3682 if (p2p->state == P2P_SEARCH) 3683 p2p_continue_find(p2p); 3684 return; 3685 } 3686 3687 p2p_dbg(p2p, 3688 "Post-Provision Discovery operations started - do not try to continue other P2P operations"); 3689 } 3690 3691 p2p_scan_res_handler(struct p2p_data * p2p,const u8 * bssid,int freq,struct os_reltime * rx_time,int level,const u8 * ies,size_t ies_len)3692 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq, 3693 struct os_reltime *rx_time, int level, const u8 *ies, 3694 size_t ies_len) 3695 { 3696 if (os_reltime_before(rx_time, &p2p->find_start)) { 3697 /* 3698 * The driver may have cached (e.g., in cfg80211 BSS table) the 3699 * scan results for relatively long time. To avoid reporting 3700 * stale information, update P2P peers only based on results 3701 * that have based on frames received after the last p2p_find 3702 * operation was started. 3703 */ 3704 p2p_dbg(p2p, "Ignore old scan result for " MACSTR 3705 " (rx_time=%u.%06u find_start=%u.%06u)", 3706 MAC2STR(bssid), (unsigned int) rx_time->sec, 3707 (unsigned int) rx_time->usec, 3708 (unsigned int) p2p->find_start.sec, 3709 (unsigned int) p2p->find_start.usec); 3710 return 0; 3711 } 3712 3713 p2p_add_device(p2p, bssid, freq, rx_time, level, ies, ies_len, 1); 3714 3715 return 0; 3716 } 3717 3718 p2p_scan_res_handled(struct p2p_data * p2p,unsigned int delay)3719 void p2p_scan_res_handled(struct p2p_data *p2p, unsigned int delay) 3720 { 3721 if (!p2p->p2p_scan_running) { 3722 p2p_dbg(p2p, "p2p_scan was not running, but scan results received"); 3723 } 3724 p2p->p2p_scan_running = 0; 3725 3726 /* Use this delay only when p2p_find doesn't set it */ 3727 if (!p2p->search_delay) 3728 p2p->search_delay = delay; 3729 3730 eloop_cancel_timeout(p2p_scan_timeout, p2p, NULL); 3731 3732 if (p2p_run_after_scan(p2p)) 3733 return; 3734 if (p2p->state == P2P_SEARCH) 3735 p2p_continue_find(p2p); 3736 } 3737 3738 p2p_scan_ie(struct p2p_data * p2p,struct wpabuf * ies,const u8 * dev_id,unsigned int bands)3739 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id, 3740 unsigned int bands) 3741 { 3742 u8 dev_capab; 3743 u8 *len; 3744 3745 #ifdef CONFIG_WIFI_DISPLAY 3746 if (p2p->wfd_ie_probe_req) 3747 wpabuf_put_buf(ies, p2p->wfd_ie_probe_req); 3748 #endif /* CONFIG_WIFI_DISPLAY */ 3749 3750 if (p2p->vendor_elem && p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]) 3751 wpabuf_put_buf(ies, 3752 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]); 3753 3754 len = p2p_buf_add_ie_hdr(ies); 3755 3756 dev_capab = p2p->dev_capab & ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 3757 3758 /* P2PS requires Probe Request frames to include SD bit */ 3759 if (p2p->p2ps_seek && p2p->p2ps_seek_count) 3760 dev_capab |= P2P_DEV_CAPAB_SERVICE_DISCOVERY; 3761 3762 p2p_buf_add_capability(ies, dev_capab, 0); 3763 3764 if (dev_id) 3765 p2p_buf_add_device_id(ies, dev_id); 3766 if (p2p->cfg->reg_class && p2p->cfg->channel) 3767 p2p_buf_add_listen_channel(ies, p2p->cfg->country, 3768 p2p->cfg->reg_class, 3769 p2p->cfg->channel); 3770 if (p2p->ext_listen_interval) 3771 p2p_buf_add_ext_listen_timing(ies, p2p->ext_listen_period, 3772 p2p->ext_listen_interval); 3773 3774 if (bands & BAND_60_GHZ) 3775 p2p_buf_add_device_info(ies, p2p, NULL); 3776 3777 if (p2p->p2ps_seek && p2p->p2ps_seek_count) 3778 p2p_buf_add_service_hash(ies, p2p); 3779 3780 /* TODO: p2p_buf_add_operating_channel() if GO */ 3781 p2p_buf_update_ie_hdr(ies, len); 3782 } 3783 3784 p2p_scan_ie_buf_len(struct p2p_data * p2p)3785 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p) 3786 { 3787 size_t len = 100; 3788 3789 #ifdef CONFIG_WIFI_DISPLAY 3790 if (p2p && p2p->wfd_ie_probe_req) 3791 len += wpabuf_len(p2p->wfd_ie_probe_req); 3792 #endif /* CONFIG_WIFI_DISPLAY */ 3793 3794 if (p2p && p2p->vendor_elem && 3795 p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]) 3796 len += wpabuf_len(p2p->vendor_elem[VENDOR_ELEM_PROBE_REQ_P2P]); 3797 3798 return len; 3799 } 3800 3801 p2p_ie_text(struct wpabuf * p2p_ie,char * buf,char * end)3802 int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end) 3803 { 3804 return p2p_attr_text(p2p_ie, buf, end); 3805 } 3806 3807 p2p_go_neg_req_cb(struct p2p_data * p2p,int success)3808 static void p2p_go_neg_req_cb(struct p2p_data *p2p, int success) 3809 { 3810 struct p2p_device *dev = p2p->go_neg_peer; 3811 int timeout; 3812 3813 p2p_dbg(p2p, "GO Negotiation Request TX callback: success=%d", success); 3814 3815 if (dev == NULL) { 3816 p2p_dbg(p2p, "No pending GO Negotiation"); 3817 return; 3818 } 3819 3820 if (success) { 3821 if (dev->flags & P2P_DEV_USER_REJECTED) { 3822 p2p_set_state(p2p, P2P_IDLE); 3823 return; 3824 } 3825 } else if (dev->go_neg_req_sent) { 3826 /* Cancel the increment from p2p_connect_send() on failure */ 3827 dev->go_neg_req_sent--; 3828 } 3829 3830 if (!success && 3831 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) && 3832 !is_zero_ether_addr(dev->member_in_go_dev)) { 3833 p2p_dbg(p2p, "Peer " MACSTR " did not acknowledge request - try to use device discoverability through its GO", 3834 MAC2STR(dev->info.p2p_device_addr)); 3835 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3836 p2p_send_dev_disc_req(p2p, dev); 3837 return; 3838 } 3839 3840 /* 3841 * Use P2P find, if needed, to find the other device from its listen 3842 * channel. 3843 */ 3844 p2p_set_state(p2p, P2P_CONNECT); 3845 timeout = success ? 500000 : 100000; 3846 if (!success && p2p->go_neg_peer && 3847 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE)) { 3848 unsigned int r; 3849 /* 3850 * Peer is expected to wait our response and we will skip the 3851 * listen phase. Add some randomness to the wait time here to 3852 * make it less likely to hit cases where we could end up in 3853 * sync with peer not listening. 3854 */ 3855 if (os_get_random((u8 *) &r, sizeof(r)) < 0) 3856 r = 0; 3857 timeout += r % 100000; 3858 } 3859 p2p_set_timeout(p2p, 0, timeout); 3860 } 3861 3862 p2p_go_neg_resp_cb(struct p2p_data * p2p,int success)3863 static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success) 3864 { 3865 p2p_dbg(p2p, "GO Negotiation Response TX callback: success=%d", 3866 success); 3867 if (!p2p->go_neg_peer && p2p->state == P2P_PROVISIONING) { 3868 p2p_dbg(p2p, "Ignore TX callback event - GO Negotiation is not running anymore"); 3869 return; 3870 } 3871 p2p_set_state(p2p, P2P_CONNECT); 3872 p2p_set_timeout(p2p, 0, 500000); 3873 } 3874 3875 p2p_go_neg_resp_failure_cb(struct p2p_data * p2p,int success,const u8 * addr)3876 static void p2p_go_neg_resp_failure_cb(struct p2p_data *p2p, int success, 3877 const u8 *addr) 3878 { 3879 p2p_dbg(p2p, "GO Negotiation Response (failure) TX callback: success=%d", success); 3880 if (p2p->go_neg_peer && p2p->go_neg_peer->status != P2P_SC_SUCCESS) { 3881 p2p_go_neg_failed(p2p, p2p->go_neg_peer->status); 3882 return; 3883 } 3884 3885 if (success) { 3886 struct p2p_device *dev; 3887 dev = p2p_get_device(p2p, addr); 3888 if (dev && 3889 dev->status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) 3890 dev->flags |= P2P_DEV_PEER_WAITING_RESPONSE; 3891 } 3892 3893 if (p2p->state == P2P_SEARCH || p2p->state == P2P_SD_DURING_FIND) 3894 p2p_continue_find(p2p); 3895 } 3896 3897 p2p_go_neg_conf_cb(struct p2p_data * p2p,enum p2p_send_action_result result)3898 static void p2p_go_neg_conf_cb(struct p2p_data *p2p, 3899 enum p2p_send_action_result result) 3900 { 3901 struct p2p_device *dev; 3902 3903 p2p_dbg(p2p, "GO Negotiation Confirm TX callback: result=%d", result); 3904 if (result == P2P_SEND_ACTION_FAILED) { 3905 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3906 p2p_go_neg_failed(p2p, -1); 3907 return; 3908 } 3909 3910 dev = p2p->go_neg_peer; 3911 3912 if (result == P2P_SEND_ACTION_NO_ACK) { 3913 /* 3914 * Retry GO Negotiation Confirmation 3915 * P2P_GO_NEG_CNF_MAX_RETRY_COUNT times if we did not receive 3916 * ACK for confirmation. 3917 */ 3918 if (dev && dev->go_neg_conf && 3919 dev->go_neg_conf_sent <= P2P_GO_NEG_CNF_MAX_RETRY_COUNT) { 3920 p2p_dbg(p2p, "GO Negotiation Confirm retry %d", 3921 dev->go_neg_conf_sent); 3922 p2p->pending_action_state = P2P_PENDING_GO_NEG_CONFIRM; 3923 if (p2p_send_action(p2p, dev->go_neg_conf_freq, 3924 dev->info.p2p_device_addr, 3925 p2p->cfg->dev_addr, 3926 dev->info.p2p_device_addr, 3927 wpabuf_head(dev->go_neg_conf), 3928 wpabuf_len(dev->go_neg_conf), 0) >= 3929 0) { 3930 dev->go_neg_conf_sent++; 3931 return; 3932 } 3933 p2p_dbg(p2p, "Failed to re-send Action frame"); 3934 3935 /* 3936 * Continue with the assumption that the first attempt 3937 * went through and just the ACK frame was lost. 3938 */ 3939 } 3940 3941 /* 3942 * It looks like the TX status for GO Negotiation Confirm is 3943 * often showing failure even when the peer has actually 3944 * received the frame. Since the peer may change channels 3945 * immediately after having received the frame, we may not see 3946 * an Ack for retries, so just dropping a single frame may 3947 * trigger this. To allow the group formation to succeed if the 3948 * peer did indeed receive the frame, continue regardless of 3949 * the TX status. 3950 */ 3951 p2p_dbg(p2p, "Assume GO Negotiation Confirm TX was actually received by the peer even though Ack was not reported"); 3952 } 3953 3954 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3955 3956 if (dev == NULL) 3957 return; 3958 3959 p2p_go_complete(p2p, dev); 3960 } 3961 3962 p2p_send_action_cb(struct p2p_data * p2p,unsigned int freq,const u8 * dst,const u8 * src,const u8 * bssid,enum p2p_send_action_result result)3963 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst, 3964 const u8 *src, const u8 *bssid, 3965 enum p2p_send_action_result result) 3966 { 3967 enum p2p_pending_action_state state; 3968 int success; 3969 3970 p2p_dbg(p2p, "Action frame TX callback (state=%d freq=%u dst=" MACSTR 3971 " src=" MACSTR " bssid=" MACSTR " result=%d p2p_state=%s)", 3972 p2p->pending_action_state, freq, MAC2STR(dst), MAC2STR(src), 3973 MAC2STR(bssid), result, p2p_state_txt(p2p->state)); 3974 success = result == P2P_SEND_ACTION_SUCCESS; 3975 state = p2p->pending_action_state; 3976 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 3977 switch (state) { 3978 case P2P_NO_PENDING_ACTION: 3979 if (p2p->send_action_in_progress) { 3980 p2p->send_action_in_progress = 0; 3981 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 3982 } 3983 break; 3984 case P2P_PENDING_GO_NEG_REQUEST: 3985 p2p_go_neg_req_cb(p2p, success); 3986 break; 3987 case P2P_PENDING_GO_NEG_RESPONSE: 3988 p2p_go_neg_resp_cb(p2p, success); 3989 break; 3990 case P2P_PENDING_GO_NEG_RESPONSE_FAILURE: 3991 p2p_go_neg_resp_failure_cb(p2p, success, dst); 3992 break; 3993 case P2P_PENDING_GO_NEG_CONFIRM: 3994 p2p_go_neg_conf_cb(p2p, result); 3995 break; 3996 case P2P_PENDING_SD: 3997 p2p_sd_query_cb(p2p, success); 3998 break; 3999 case P2P_PENDING_PD: 4000 p2p_prov_disc_cb(p2p, success); 4001 break; 4002 case P2P_PENDING_PD_RESPONSE: 4003 p2p_prov_disc_resp_cb(p2p, success); 4004 break; 4005 case P2P_PENDING_INVITATION_REQUEST: 4006 p2p_invitation_req_cb(p2p, success); 4007 break; 4008 case P2P_PENDING_INVITATION_RESPONSE: 4009 p2p_invitation_resp_cb(p2p, dst, success); 4010 break; 4011 case P2P_PENDING_DEV_DISC_REQUEST: 4012 p2p_dev_disc_req_cb(p2p, success); 4013 break; 4014 case P2P_PENDING_DEV_DISC_RESPONSE: 4015 p2p_dev_disc_resp_cb(p2p, success); 4016 break; 4017 case P2P_PENDING_GO_DISC_REQ: 4018 p2p_go_disc_req_cb(p2p, success); 4019 break; 4020 } 4021 } 4022 4023 p2p_listen_cb(struct p2p_data * p2p,unsigned int freq,unsigned int duration)4024 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq, 4025 unsigned int duration) 4026 { 4027 if (freq == p2p->pending_client_disc_freq) { 4028 p2p_dbg(p2p, "Client discoverability remain-awake completed"); 4029 p2p->pending_client_disc_freq = 0; 4030 return; 4031 } 4032 4033 if (freq != p2p->pending_listen_freq) { 4034 p2p_dbg(p2p, "Unexpected listen callback for freq=%u duration=%u (pending_listen_freq=%u)", 4035 freq, duration, p2p->pending_listen_freq); 4036 return; 4037 } 4038 4039 p2p_dbg(p2p, "Starting Listen timeout(%u,%u) on freq=%u based on callback", 4040 p2p->pending_listen_sec, p2p->pending_listen_usec, 4041 p2p->pending_listen_freq); 4042 p2p->pending_listen_wait_drv = false; 4043 p2p->in_listen = 1; 4044 p2p->drv_in_listen = freq; 4045 if (p2p->pending_listen_sec || p2p->pending_listen_usec) { 4046 /* 4047 * Add 20 msec extra wait to avoid race condition with driver 4048 * remain-on-channel end event, i.e., give driver more time to 4049 * complete the operation before our timeout expires. 4050 */ 4051 p2p_set_timeout(p2p, p2p->pending_listen_sec, 4052 p2p->pending_listen_usec + 20000); 4053 } 4054 4055 p2p->pending_listen_freq = 0; 4056 } 4057 4058 p2p_listen_end(struct p2p_data * p2p,unsigned int freq)4059 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq) 4060 { 4061 p2p_dbg(p2p, "Driver ended Listen state (freq=%u)", freq); 4062 p2p->drv_in_listen = 0; 4063 if (p2p->in_listen) 4064 return 0; /* Internal timeout will trigger the next step */ 4065 4066 if (p2p->state == P2P_WAIT_PEER_CONNECT && p2p->go_neg_peer && 4067 p2p->pending_listen_freq) { 4068 /* 4069 * Better wait a bit if the driver is unable to start 4070 * offchannel operation for some reason to continue with 4071 * P2P_WAIT_PEER_(IDLE/CONNECT) state transitions. 4072 */ 4073 p2p_dbg(p2p, 4074 "Listen operation did not seem to start - delay idle phase to avoid busy loop"); 4075 p2p_set_timeout(p2p, 0, 100000); 4076 return 1; 4077 } 4078 4079 if (p2p->state == P2P_CONNECT_LISTEN && p2p->go_neg_peer) { 4080 if (p2p->go_neg_peer->connect_reqs >= 120) { 4081 p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response"); 4082 p2p_go_neg_failed(p2p, -1); 4083 return 0; 4084 } 4085 4086 p2p_set_state(p2p, P2P_CONNECT); 4087 p2p_connect_send(p2p, p2p->go_neg_peer); 4088 return 1; 4089 } else if (p2p->state == P2P_SEARCH) { 4090 if (p2p->p2p_scan_running) { 4091 /* 4092 * Search is already in progress. This can happen if 4093 * an Action frame RX is reported immediately after 4094 * the end of a remain-on-channel operation and the 4095 * response frame to that is sent using an offchannel 4096 * operation while in p2p_find. Avoid an attempt to 4097 * restart a scan here. 4098 */ 4099 p2p_dbg(p2p, "p2p_scan already in progress - do not try to start a new one"); 4100 return 1; 4101 } 4102 if (p2p->pending_listen_freq) { 4103 /* 4104 * Better wait a bit if the driver is unable to start 4105 * offchannel operation for some reason. p2p_search() 4106 * will be started from internal timeout. 4107 */ 4108 p2p_dbg(p2p, "Listen operation did not seem to start - delay search phase to avoid busy loop"); 4109 p2p_set_timeout(p2p, 0, 100000); 4110 return 1; 4111 } 4112 if (p2p->search_delay) { 4113 p2p_dbg(p2p, "Delay search operation by %u ms", 4114 p2p->search_delay); 4115 p2p_set_timeout(p2p, p2p->search_delay / 1000, 4116 (p2p->search_delay % 1000) * 1000); 4117 return 1; 4118 } 4119 p2p_search(p2p); 4120 return 1; 4121 } 4122 4123 return 0; 4124 } 4125 4126 p2p_listen_failed(struct p2p_data * p2p,unsigned int freq)4127 void p2p_listen_failed(struct p2p_data *p2p, unsigned int freq) 4128 { 4129 if (freq != p2p->pending_listen_freq) { 4130 p2p_dbg(p2p, 4131 "Unexpected listen failed callback for freq=%u (pending_listen_freq=%u)", 4132 freq, p2p->pending_listen_freq); 4133 return; 4134 } 4135 4136 p2p_dbg(p2p, "Listen failed on freq=%u", freq); 4137 p2p->pending_listen_freq = 0; 4138 } 4139 4140 p2p_timeout_connect(struct p2p_data * p2p)4141 static void p2p_timeout_connect(struct p2p_data *p2p) 4142 { 4143 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 4144 if (p2p->go_neg_peer && 4145 (p2p->go_neg_peer->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM)) { 4146 p2p_dbg(p2p, "Wait for GO Negotiation Confirm timed out - assume GO Negotiation failed"); 4147 p2p_go_neg_failed(p2p, -1); 4148 return; 4149 } 4150 if (p2p->go_neg_peer && 4151 (p2p->go_neg_peer->flags & P2P_DEV_PEER_WAITING_RESPONSE) && 4152 p2p->go_neg_peer->connect_reqs < 120) { 4153 p2p_dbg(p2p, "Peer expected to wait our response - skip listen"); 4154 p2p_connect_send(p2p, p2p->go_neg_peer); 4155 return; 4156 } 4157 if (p2p->go_neg_peer && p2p->go_neg_peer->oob_go_neg_freq > 0) { 4158 p2p_dbg(p2p, "Skip connect-listen since GO Neg channel known (OOB)"); 4159 p2p_set_state(p2p, P2P_CONNECT_LISTEN); 4160 p2p_set_timeout(p2p, 0, 30000); 4161 return; 4162 } 4163 p2p_set_state(p2p, P2P_CONNECT_LISTEN); 4164 p2p_listen_in_find(p2p, 0); 4165 } 4166 4167 p2p_timeout_connect_listen(struct p2p_data * p2p)4168 static void p2p_timeout_connect_listen(struct p2p_data *p2p) 4169 { 4170 if (p2p->go_neg_peer) { 4171 if (p2p->drv_in_listen) { 4172 p2p_dbg(p2p, "Driver is still in Listen state; wait for it to complete"); 4173 return; 4174 } 4175 4176 if (p2p->go_neg_peer->connect_reqs >= 120) { 4177 p2p_dbg(p2p, "Timeout on sending GO Negotiation Request without getting response"); 4178 p2p_go_neg_failed(p2p, -1); 4179 return; 4180 } 4181 4182 p2p_set_state(p2p, P2P_CONNECT); 4183 p2p_connect_send(p2p, p2p->go_neg_peer); 4184 } else 4185 p2p_set_state(p2p, P2P_IDLE); 4186 } 4187 4188 p2p_timeout_wait_peer_connect(struct p2p_data * p2p)4189 static void p2p_timeout_wait_peer_connect(struct p2p_data *p2p) 4190 { 4191 p2p_set_state(p2p, P2P_WAIT_PEER_IDLE); 4192 4193 if (p2p->cfg->is_concurrent_session_active && 4194 p2p->cfg->is_concurrent_session_active(p2p->cfg->cb_ctx)) 4195 p2p_set_timeout(p2p, 0, 500000); 4196 else 4197 p2p_set_timeout(p2p, 0, 200000); 4198 } 4199 4200 p2p_timeout_wait_peer_idle(struct p2p_data * p2p)4201 static void p2p_timeout_wait_peer_idle(struct p2p_data *p2p) 4202 { 4203 struct p2p_device *dev = p2p->go_neg_peer; 4204 4205 if (dev == NULL) { 4206 p2p_dbg(p2p, "Unknown GO Neg peer - stop GO Neg wait"); 4207 return; 4208 } 4209 4210 p2p_dbg(p2p, "Go to Listen state while waiting for the peer to become ready for GO Negotiation"); 4211 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 4212 p2p->pending_listen_wait_drv = false; 4213 if (p2p->pending_listen_freq) { 4214 p2p_dbg(p2p, "Clear pending_listen_freq for %s", __func__); 4215 p2p->pending_listen_freq = 0; 4216 } 4217 p2p_set_state(p2p, P2P_WAIT_PEER_CONNECT); 4218 p2p_listen_in_find(p2p, 0); 4219 } 4220 4221 p2p_timeout_sd_during_find(struct p2p_data * p2p)4222 static void p2p_timeout_sd_during_find(struct p2p_data *p2p) 4223 { 4224 p2p_dbg(p2p, "Service Discovery Query timeout"); 4225 if (p2p->sd_peer) { 4226 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 4227 p2p->sd_peer = NULL; 4228 } 4229 p2p_continue_find(p2p); 4230 } 4231 4232 p2p_timeout_prov_disc_during_find(struct p2p_data * p2p)4233 static void p2p_timeout_prov_disc_during_find(struct p2p_data *p2p) 4234 { 4235 p2p_dbg(p2p, "Provision Discovery Request timeout"); 4236 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 4237 p2p_continue_find(p2p); 4238 } 4239 4240 p2p_timeout_prov_disc_req(struct p2p_data * p2p)4241 static void p2p_timeout_prov_disc_req(struct p2p_data *p2p) 4242 { 4243 u32 adv_id = 0; 4244 u8 *adv_mac = NULL; 4245 4246 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 4247 4248 /* 4249 * For user initiated PD requests that we have not gotten any responses 4250 * for while in IDLE state, we retry them a couple of times before 4251 * giving up. 4252 */ 4253 if (!p2p->user_initiated_pd) 4254 return; 4255 4256 p2p_dbg(p2p, "User initiated Provision Discovery Request timeout"); 4257 4258 if (p2p->pd_retries) { 4259 p2p->pd_retries--; 4260 p2p_retry_pd(p2p); 4261 } else { 4262 struct p2p_device *dev; 4263 int for_join = 0; 4264 4265 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) { 4266 if (!ether_addr_equal(p2p->pending_pd_devaddr, 4267 dev->info.p2p_device_addr)) 4268 continue; 4269 if (dev->req_config_methods && 4270 (dev->flags & P2P_DEV_PD_FOR_JOIN)) 4271 for_join = 1; 4272 } 4273 4274 if (p2p->p2ps_prov) { 4275 adv_id = p2p->p2ps_prov->adv_id; 4276 adv_mac = p2p->p2ps_prov->adv_mac; 4277 } 4278 4279 if (p2p->cfg->prov_disc_fail) 4280 p2p->cfg->prov_disc_fail(p2p->cfg->cb_ctx, 4281 p2p->pending_pd_devaddr, 4282 for_join ? 4283 P2P_PROV_DISC_TIMEOUT_JOIN : 4284 P2P_PROV_DISC_TIMEOUT, 4285 adv_id, adv_mac, NULL); 4286 p2p_reset_pending_pd(p2p); 4287 } 4288 } 4289 4290 p2p_timeout_invite(struct p2p_data * p2p)4291 static void p2p_timeout_invite(struct p2p_data *p2p) 4292 { 4293 p2p->cfg->send_action_done(p2p->cfg->cb_ctx); 4294 p2p_set_state(p2p, P2P_INVITE_LISTEN); 4295 if (p2p->inv_role == P2P_INVITE_ROLE_ACTIVE_GO) { 4296 /* 4297 * Better remain on operating channel instead of listen channel 4298 * when running a group. 4299 * Wait 120 ms to let the P2P GO to send its beacon on the 4300 * intended TBTT. 4301 */ 4302 p2p_dbg(p2p, "Inviting in active GO role - wait on operating channel"); 4303 p2p_set_timeout(p2p, 0, 120000); 4304 return; 4305 } 4306 p2p_listen_in_find(p2p, 0); 4307 } 4308 4309 p2p_timeout_invite_listen(struct p2p_data * p2p)4310 static void p2p_timeout_invite_listen(struct p2p_data *p2p) 4311 { 4312 if (p2p->invite_peer && p2p->invite_peer->invitation_reqs < 100) { 4313 p2p_set_state(p2p, P2P_INVITE); 4314 p2p_invite_send(p2p, p2p->invite_peer, 4315 p2p->invite_go_dev_addr, p2p->invite_dev_pw_id); 4316 } else { 4317 if (p2p->invite_peer) { 4318 p2p_dbg(p2p, "Invitation Request retry limit reached"); 4319 if (p2p->cfg->invitation_result) 4320 p2p->cfg->invitation_result( 4321 p2p->cfg->cb_ctx, -1, NULL, 0, NULL, 4322 NULL, 4323 p2p->invite_peer->info.p2p_device_addr, 4324 0, 0, NULL, NULL, 0, 4325 p2p->invite_go_dev_addr); 4326 } 4327 p2p_set_state(p2p, P2P_IDLE); 4328 } 4329 } 4330 4331 p2p_state_timeout(void * eloop_ctx,void * timeout_ctx)4332 static void p2p_state_timeout(void *eloop_ctx, void *timeout_ctx) 4333 { 4334 struct p2p_data *p2p = eloop_ctx; 4335 4336 p2p_dbg(p2p, "Timeout (state=%s)", p2p_state_txt(p2p->state)); 4337 4338 p2p->in_listen = 0; 4339 if (p2p->drv_in_listen) { 4340 p2p_dbg(p2p, "Driver is still in listen state - stop it"); 4341 p2p->cfg->stop_listen(p2p->cfg->cb_ctx); 4342 p2p->pending_listen_wait_drv = false; 4343 } 4344 4345 switch (p2p->state) { 4346 case P2P_IDLE: 4347 /* Check if we timed out waiting for PD req */ 4348 if (p2p->pending_action_state == P2P_PENDING_PD) 4349 p2p_timeout_prov_disc_req(p2p); 4350 break; 4351 case P2P_SEARCH: 4352 /* Check if we timed out waiting for PD req */ 4353 if (p2p->pending_action_state == P2P_PENDING_PD) 4354 p2p_timeout_prov_disc_req(p2p); 4355 if (p2p->search_delay && !p2p->in_search_delay) { 4356 p2p_dbg(p2p, "Delay search operation by %u ms", 4357 p2p->search_delay); 4358 p2p->in_search_delay = 1; 4359 p2p_set_timeout(p2p, p2p->search_delay / 1000, 4360 (p2p->search_delay % 1000) * 1000); 4361 break; 4362 } 4363 p2p->in_search_delay = 0; 4364 p2p_search(p2p); 4365 break; 4366 case P2P_CONNECT: 4367 p2p_timeout_connect(p2p); 4368 break; 4369 case P2P_CONNECT_LISTEN: 4370 p2p_timeout_connect_listen(p2p); 4371 break; 4372 case P2P_GO_NEG: 4373 break; 4374 case P2P_LISTEN_ONLY: 4375 /* Check if we timed out waiting for PD req */ 4376 if (p2p->pending_action_state == P2P_PENDING_PD) 4377 p2p_timeout_prov_disc_req(p2p); 4378 4379 if (p2p->ext_listen_only) { 4380 p2p_dbg(p2p, "Extended Listen Timing - Listen State completed"); 4381 p2p->ext_listen_only = 0; 4382 p2p_set_state(p2p, P2P_IDLE); 4383 } 4384 break; 4385 case P2P_WAIT_PEER_CONNECT: 4386 p2p_timeout_wait_peer_connect(p2p); 4387 break; 4388 case P2P_WAIT_PEER_IDLE: 4389 p2p_timeout_wait_peer_idle(p2p); 4390 break; 4391 case P2P_SD_DURING_FIND: 4392 p2p_timeout_sd_during_find(p2p); 4393 break; 4394 case P2P_PROVISIONING: 4395 break; 4396 case P2P_PD_DURING_FIND: 4397 p2p_timeout_prov_disc_during_find(p2p); 4398 break; 4399 case P2P_INVITE: 4400 p2p_timeout_invite(p2p); 4401 break; 4402 case P2P_INVITE_LISTEN: 4403 p2p_timeout_invite_listen(p2p); 4404 break; 4405 } 4406 } 4407 4408 p2p_reject(struct p2p_data * p2p,const u8 * peer_addr)4409 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr) 4410 { 4411 struct p2p_device *dev; 4412 4413 dev = p2p_get_device(p2p, peer_addr); 4414 p2p_dbg(p2p, "Local request to reject connection attempts by peer " 4415 MACSTR, MAC2STR(peer_addr)); 4416 if (dev == NULL) { 4417 p2p_dbg(p2p, "Peer " MACSTR " unknown", MAC2STR(peer_addr)); 4418 return -1; 4419 } 4420 dev->status = P2P_SC_FAIL_REJECTED_BY_USER; 4421 dev->flags |= P2P_DEV_USER_REJECTED; 4422 return 0; 4423 } 4424 4425 p2p_wps_method_text(enum p2p_wps_method method)4426 const char * p2p_wps_method_text(enum p2p_wps_method method) 4427 { 4428 switch (method) { 4429 case WPS_NOT_READY: 4430 return "not-ready"; 4431 case WPS_PIN_DISPLAY: 4432 return "Display"; 4433 case WPS_PIN_KEYPAD: 4434 return "Keypad"; 4435 case WPS_PBC: 4436 return "PBC"; 4437 case WPS_NFC: 4438 return "NFC"; 4439 case WPS_P2PS: 4440 return "P2PS"; 4441 } 4442 4443 return "??"; 4444 } 4445 4446 p2p_go_state_text(enum p2p_go_state go_state)4447 static const char * p2p_go_state_text(enum p2p_go_state go_state) 4448 { 4449 switch (go_state) { 4450 case UNKNOWN_GO: 4451 return "unknown"; 4452 case LOCAL_GO: 4453 return "local"; 4454 case REMOTE_GO: 4455 return "remote"; 4456 } 4457 4458 return "??"; 4459 } 4460 4461 p2p_get_peer_info(struct p2p_data * p2p,const u8 * addr,int next)4462 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p, 4463 const u8 *addr, int next) 4464 { 4465 struct p2p_device *dev; 4466 4467 if (addr) 4468 dev = p2p_get_device(p2p, addr); 4469 else 4470 dev = dl_list_first(&p2p->devices, struct p2p_device, list); 4471 4472 if (dev && next) { 4473 dev = dl_list_first(&dev->list, struct p2p_device, list); 4474 if (&dev->list == &p2p->devices) 4475 dev = NULL; 4476 } 4477 4478 if (dev == NULL) 4479 return NULL; 4480 4481 return &dev->info; 4482 } 4483 4484 p2p_get_peer_info_txt(const struct p2p_peer_info * info,char * buf,size_t buflen)4485 int p2p_get_peer_info_txt(const struct p2p_peer_info *info, 4486 char *buf, size_t buflen) 4487 { 4488 struct p2p_device *dev; 4489 int res; 4490 char *pos, *end; 4491 struct os_reltime now; 4492 4493 if (info == NULL) 4494 return -1; 4495 4496 dev = (struct p2p_device *) (((u8 *) info) - 4497 offsetof(struct p2p_device, info)); 4498 4499 pos = buf; 4500 end = buf + buflen; 4501 4502 os_get_reltime(&now); 4503 res = os_snprintf(pos, end - pos, 4504 "age=%d\n" 4505 "listen_freq=%d\n" 4506 "wps_method=%s\n" 4507 "interface_addr=" MACSTR "\n" 4508 "member_in_go_dev=" MACSTR "\n" 4509 "member_in_go_iface=" MACSTR "\n" 4510 "go_neg_req_sent=%d\n" 4511 "go_state=%s\n" 4512 "dialog_token=%u\n" 4513 "intended_addr=" MACSTR "\n" 4514 "country=%c%c\n" 4515 "oper_freq=%d\n" 4516 "req_config_methods=0x%x\n" 4517 "flags=%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n" 4518 "status=%d\n" 4519 "invitation_reqs=%u\n", 4520 (int) (now.sec - dev->last_seen.sec), 4521 dev->listen_freq, 4522 p2p_wps_method_text(dev->wps_method), 4523 MAC2STR(dev->interface_addr), 4524 MAC2STR(dev->member_in_go_dev), 4525 MAC2STR(dev->member_in_go_iface), 4526 dev->go_neg_req_sent, 4527 p2p_go_state_text(dev->go_state), 4528 dev->dialog_token, 4529 MAC2STR(dev->intended_addr), 4530 dev->country[0] ? dev->country[0] : '_', 4531 dev->country[1] ? dev->country[1] : '_', 4532 dev->oper_freq, 4533 dev->req_config_methods, 4534 dev->flags & P2P_DEV_PROBE_REQ_ONLY ? 4535 "[PROBE_REQ_ONLY]" : "", 4536 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "", 4537 dev->flags & P2P_DEV_NOT_YET_READY ? 4538 "[NOT_YET_READY]" : "", 4539 dev->flags & P2P_DEV_PD_PEER_DISPLAY ? 4540 "[PD_PEER_DISPLAY]" : "", 4541 dev->flags & P2P_DEV_PD_PEER_KEYPAD ? 4542 "[PD_PEER_KEYPAD]" : "", 4543 dev->flags & P2P_DEV_PD_PEER_P2PS ? 4544 "[PD_PEER_P2PS]" : "", 4545 dev->flags & P2P_DEV_USER_REJECTED ? 4546 "[USER_REJECTED]" : "", 4547 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ? 4548 "[PEER_WAITING_RESPONSE]" : "", 4549 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ? 4550 "[PREFER_PERSISTENT_GROUP]" : "", 4551 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ? 4552 "[WAIT_GO_NEG_RESPONSE]" : "", 4553 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ? 4554 "[WAIT_GO_NEG_CONFIRM]" : "", 4555 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ? 4556 "[GROUP_CLIENT_ONLY]" : "", 4557 dev->flags & P2P_DEV_FORCE_FREQ ? 4558 "[FORCE_FREQ]" : "", 4559 dev->flags & P2P_DEV_PD_FOR_JOIN ? 4560 "[PD_FOR_JOIN]" : "", 4561 dev->flags & P2P_DEV_LAST_SEEN_AS_GROUP_CLIENT ? 4562 "[LAST_SEEN_AS_GROUP_CLIENT]" : "", 4563 dev->status, 4564 dev->invitation_reqs); 4565 if (os_snprintf_error(end - pos, res)) 4566 return pos - buf; 4567 pos += res; 4568 4569 if (dev->ext_listen_period) { 4570 res = os_snprintf(pos, end - pos, 4571 "ext_listen_period=%u\n" 4572 "ext_listen_interval=%u\n", 4573 dev->ext_listen_period, 4574 dev->ext_listen_interval); 4575 if (os_snprintf_error(end - pos, res)) 4576 return pos - buf; 4577 pos += res; 4578 } 4579 4580 if (dev->oper_ssid_len) { 4581 res = os_snprintf(pos, end - pos, 4582 "oper_ssid=%s\n", 4583 wpa_ssid_txt(dev->oper_ssid, 4584 dev->oper_ssid_len)); 4585 if (os_snprintf_error(end - pos, res)) 4586 return pos - buf; 4587 pos += res; 4588 } 4589 4590 #ifdef CONFIG_WIFI_DISPLAY 4591 if (dev->info.wfd_subelems) { 4592 res = os_snprintf(pos, end - pos, "wfd_subelems="); 4593 if (os_snprintf_error(end - pos, res)) 4594 return pos - buf; 4595 pos += res; 4596 4597 pos += wpa_snprintf_hex(pos, end - pos, 4598 wpabuf_head(dev->info.wfd_subelems), 4599 wpabuf_len(dev->info.wfd_subelems)); 4600 4601 res = os_snprintf(pos, end - pos, "\n"); 4602 if (os_snprintf_error(end - pos, res)) 4603 return pos - buf; 4604 pos += res; 4605 } 4606 #endif /* CONFIG_WIFI_DISPLAY */ 4607 4608 return pos - buf; 4609 } 4610 4611 p2p_peer_known(struct p2p_data * p2p,const u8 * addr)4612 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr) 4613 { 4614 return p2p_get_device(p2p, addr) != NULL; 4615 } 4616 4617 p2p_set_client_discoverability(struct p2p_data * p2p,int enabled)4618 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled) 4619 { 4620 if (enabled) { 4621 p2p_dbg(p2p, "Client discoverability enabled"); 4622 p2p->dev_capab |= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 4623 } else { 4624 p2p_dbg(p2p, "Client discoverability disabled"); 4625 p2p->dev_capab &= ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 4626 } 4627 } 4628 4629 p2p_build_presence_req(u32 duration1,u32 interval1,u32 duration2,u32 interval2)4630 static struct wpabuf * p2p_build_presence_req(u32 duration1, u32 interval1, 4631 u32 duration2, u32 interval2) 4632 { 4633 struct wpabuf *req; 4634 struct p2p_noa_desc desc1, desc2, *ptr1 = NULL, *ptr2 = NULL; 4635 u8 *len; 4636 4637 req = wpabuf_alloc(100); 4638 if (req == NULL) 4639 return NULL; 4640 4641 if (duration1 || interval1) { 4642 os_memset(&desc1, 0, sizeof(desc1)); 4643 desc1.count_type = 1; 4644 desc1.duration = duration1; 4645 desc1.interval = interval1; 4646 ptr1 = &desc1; 4647 4648 if (duration2 || interval2) { 4649 os_memset(&desc2, 0, sizeof(desc2)); 4650 desc2.count_type = 2; 4651 desc2.duration = duration2; 4652 desc2.interval = interval2; 4653 ptr2 = &desc2; 4654 } 4655 } 4656 4657 p2p_buf_add_action_hdr(req, P2P_PRESENCE_REQ, 1); 4658 len = p2p_buf_add_ie_hdr(req); 4659 p2p_buf_add_noa(req, 0, 0, 0, ptr1, ptr2); 4660 p2p_buf_update_ie_hdr(req, len); 4661 4662 return req; 4663 } 4664 4665 p2p_presence_req(struct p2p_data * p2p,const u8 * go_interface_addr,const u8 * own_interface_addr,unsigned int freq,u32 duration1,u32 interval1,u32 duration2,u32 interval2)4666 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr, 4667 const u8 *own_interface_addr, unsigned int freq, 4668 u32 duration1, u32 interval1, u32 duration2, 4669 u32 interval2) 4670 { 4671 struct wpabuf *req; 4672 4673 p2p_dbg(p2p, "Send Presence Request to GO " MACSTR 4674 " (own interface " MACSTR ") freq=%u dur1=%u int1=%u " 4675 "dur2=%u int2=%u", 4676 MAC2STR(go_interface_addr), MAC2STR(own_interface_addr), 4677 freq, duration1, interval1, duration2, interval2); 4678 4679 req = p2p_build_presence_req(duration1, interval1, duration2, 4680 interval2); 4681 if (req == NULL) 4682 return -1; 4683 4684 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 4685 if (p2p_send_action(p2p, freq, go_interface_addr, own_interface_addr, 4686 go_interface_addr, 4687 wpabuf_head(req), wpabuf_len(req), 200) < 0) { 4688 p2p_dbg(p2p, "Failed to send Action frame"); 4689 } 4690 wpabuf_free(req); 4691 4692 return 0; 4693 } 4694 4695 p2p_build_presence_resp(u8 status,const u8 * noa,size_t noa_len,u8 dialog_token)4696 static struct wpabuf * p2p_build_presence_resp(u8 status, const u8 *noa, 4697 size_t noa_len, u8 dialog_token) 4698 { 4699 struct wpabuf *resp; 4700 u8 *len; 4701 4702 resp = wpabuf_alloc(100 + noa_len); 4703 if (resp == NULL) 4704 return NULL; 4705 4706 p2p_buf_add_action_hdr(resp, P2P_PRESENCE_RESP, dialog_token); 4707 len = p2p_buf_add_ie_hdr(resp); 4708 p2p_buf_add_status(resp, status); 4709 if (noa) { 4710 wpabuf_put_u8(resp, P2P_ATTR_NOTICE_OF_ABSENCE); 4711 wpabuf_put_le16(resp, noa_len); 4712 wpabuf_put_data(resp, noa, noa_len); 4713 } else 4714 p2p_buf_add_noa(resp, 0, 0, 0, NULL, NULL); 4715 p2p_buf_update_ie_hdr(resp, len); 4716 4717 return resp; 4718 } 4719 4720 p2p_process_presence_req(struct p2p_data * p2p,const u8 * da,const u8 * sa,const u8 * data,size_t len,int rx_freq)4721 static void p2p_process_presence_req(struct p2p_data *p2p, const u8 *da, 4722 const u8 *sa, const u8 *data, size_t len, 4723 int rx_freq) 4724 { 4725 struct p2p_message msg; 4726 u8 status; 4727 struct wpabuf *resp; 4728 size_t g; 4729 struct p2p_group *group = NULL; 4730 int parsed = 0; 4731 u8 noa[50]; 4732 int noa_len; 4733 4734 p2p_dbg(p2p, "Received P2P Action - P2P Presence Request"); 4735 4736 for (g = 0; g < p2p->num_groups; g++) { 4737 if (ether_addr_equal( 4738 da, p2p_group_get_interface_addr(p2p->groups[g]))) { 4739 group = p2p->groups[g]; 4740 break; 4741 } 4742 } 4743 if (group == NULL) { 4744 p2p_dbg(p2p, "Ignore P2P Presence Request for unknown group " 4745 MACSTR, MAC2STR(da)); 4746 return; 4747 } 4748 4749 if (p2p_parse(data, len, &msg) < 0) { 4750 p2p_dbg(p2p, "Failed to parse P2P Presence Request"); 4751 status = P2P_SC_FAIL_INVALID_PARAMS; 4752 goto fail; 4753 } 4754 parsed = 1; 4755 4756 if (msg.noa == NULL) { 4757 p2p_dbg(p2p, "No NoA attribute in P2P Presence Request"); 4758 status = P2P_SC_FAIL_INVALID_PARAMS; 4759 goto fail; 4760 } 4761 4762 status = p2p_group_presence_req(group, sa, msg.noa, msg.noa_len); 4763 4764 fail: 4765 if (p2p->cfg->get_noa) 4766 noa_len = p2p->cfg->get_noa(p2p->cfg->cb_ctx, da, noa, 4767 sizeof(noa)); 4768 else 4769 noa_len = -1; 4770 resp = p2p_build_presence_resp(status, noa_len > 0 ? noa : NULL, 4771 noa_len > 0 ? noa_len : 0, 4772 msg.dialog_token); 4773 if (parsed) 4774 p2p_parse_free(&msg); 4775 if (resp == NULL) 4776 return; 4777 4778 p2p->pending_action_state = P2P_NO_PENDING_ACTION; 4779 if (p2p_send_action(p2p, rx_freq, sa, da, da, 4780 wpabuf_head(resp), wpabuf_len(resp), 200) < 0) { 4781 p2p_dbg(p2p, "Failed to send Action frame"); 4782 } 4783 wpabuf_free(resp); 4784 } 4785 4786 p2p_process_presence_resp(struct p2p_data * p2p,const u8 * da,const u8 * sa,const u8 * data,size_t len)4787 static void p2p_process_presence_resp(struct p2p_data *p2p, const u8 *da, 4788 const u8 *sa, const u8 *data, size_t len) 4789 { 4790 struct p2p_message msg; 4791 4792 p2p_dbg(p2p, "Received P2P Action - P2P Presence Response"); 4793 4794 if (p2p_parse(data, len, &msg) < 0) { 4795 p2p_dbg(p2p, "Failed to parse P2P Presence Response"); 4796 return; 4797 } 4798 4799 if (msg.status == NULL || msg.noa == NULL) { 4800 p2p_dbg(p2p, "No Status or NoA attribute in P2P Presence Response"); 4801 p2p_parse_free(&msg); 4802 return; 4803 } 4804 4805 if (p2p->cfg->presence_resp) { 4806 p2p->cfg->presence_resp(p2p->cfg->cb_ctx, sa, *msg.status, 4807 msg.noa, msg.noa_len); 4808 } 4809 4810 if (*msg.status) { 4811 p2p_dbg(p2p, "P2P Presence Request was rejected: status %u", 4812 *msg.status); 4813 p2p_parse_free(&msg); 4814 return; 4815 } 4816 4817 p2p_dbg(p2p, "P2P Presence Request was accepted"); 4818 wpa_hexdump(MSG_DEBUG, "P2P: P2P Presence Response - NoA", 4819 msg.noa, msg.noa_len); 4820 /* TODO: process NoA */ 4821 p2p_parse_free(&msg); 4822 } 4823 4824 p2p_ext_listen_timeout(void * eloop_ctx,void * timeout_ctx)4825 static void p2p_ext_listen_timeout(void *eloop_ctx, void *timeout_ctx) 4826 { 4827 struct p2p_data *p2p = eloop_ctx; 4828 4829 if (p2p->ext_listen_interval) { 4830 /* Schedule next extended listen timeout */ 4831 eloop_register_timeout(p2p->ext_listen_interval_sec, 4832 p2p->ext_listen_interval_usec, 4833 p2p_ext_listen_timeout, p2p, NULL); 4834 } 4835 4836 if (p2p->state == P2P_LISTEN_ONLY && p2p->ext_listen_only) { 4837 /* 4838 * This should not really happen, but it looks like the Listen 4839 * command may fail is something else (e.g., a scan) was 4840 * running at an inconvenient time. As a workaround, allow new 4841 * Extended Listen operation to be started. 4842 */ 4843 p2p_dbg(p2p, "Previous Extended Listen operation had not been completed - try again"); 4844 p2p->ext_listen_only = 0; 4845 p2p_set_state(p2p, P2P_IDLE); 4846 } 4847 4848 if ((p2p->cfg->is_p2p_in_progress && 4849 p2p->cfg->is_p2p_in_progress(p2p->cfg->cb_ctx)) || 4850 (p2p->pending_action_state == P2P_PENDING_PD && 4851 p2p->pd_retries > 0)) { 4852 p2p_dbg(p2p, "Operation in progress - skip Extended Listen timeout (%s)", 4853 p2p_state_txt(p2p->state)); 4854 return; 4855 } 4856 4857 if (p2p->state != P2P_IDLE) { 4858 p2p_dbg(p2p, "Skip Extended Listen timeout in active state (%s)", p2p_state_txt(p2p->state)); 4859 return; 4860 } 4861 4862 p2p_dbg(p2p, "Extended Listen timeout"); 4863 p2p->ext_listen_only = 1; 4864 if (p2p_listen(p2p, p2p->ext_listen_period) < 0) { 4865 p2p_dbg(p2p, "Failed to start Listen state for Extended Listen Timing"); 4866 p2p->ext_listen_only = 0; 4867 } 4868 } 4869 4870 p2p_ext_listen(struct p2p_data * p2p,unsigned int period,unsigned int interval)4871 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period, 4872 unsigned int interval) 4873 { 4874 if (period > 65535 || interval > 65535 || period > interval || 4875 (period == 0 && interval > 0) || (period > 0 && interval == 0)) { 4876 p2p_dbg(p2p, "Invalid Extended Listen Timing request: period=%u interval=%u", 4877 period, interval); 4878 return -1; 4879 } 4880 4881 eloop_cancel_timeout(p2p_ext_listen_timeout, p2p, NULL); 4882 4883 if (interval == 0) { 4884 p2p_dbg(p2p, "Disabling Extended Listen Timing"); 4885 p2p->ext_listen_period = 0; 4886 p2p->ext_listen_interval = 0; 4887 return 0; 4888 } 4889 4890 p2p_dbg(p2p, "Enabling Extended Listen Timing: period %u msec, interval %u msec", 4891 period, interval); 4892 p2p->ext_listen_period = period; 4893 p2p->ext_listen_interval = interval; 4894 p2p->ext_listen_interval_sec = interval / 1000; 4895 p2p->ext_listen_interval_usec = (interval % 1000) * 1000; 4896 4897 eloop_register_timeout(p2p->ext_listen_interval_sec, 4898 p2p->ext_listen_interval_usec, 4899 p2p_ext_listen_timeout, p2p, NULL); 4900 4901 return 0; 4902 } 4903 4904 p2p_deauth_notif(struct p2p_data * p2p,const u8 * bssid,u16 reason_code,const u8 * ie,size_t ie_len)4905 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, 4906 const u8 *ie, size_t ie_len) 4907 { 4908 struct p2p_message msg; 4909 4910 if (bssid == NULL || ie == NULL) 4911 return; 4912 4913 os_memset(&msg, 0, sizeof(msg)); 4914 if (p2p_parse_ies(ie, ie_len, &msg)) 4915 return; 4916 if (msg.minor_reason_code == NULL) { 4917 p2p_parse_free(&msg); 4918 return; 4919 } 4920 4921 p2p_dbg(p2p, "Deauthentication notification BSSID " MACSTR 4922 " reason_code=%u minor_reason_code=%u", 4923 MAC2STR(bssid), reason_code, *msg.minor_reason_code); 4924 4925 p2p_parse_free(&msg); 4926 } 4927 4928 p2p_disassoc_notif(struct p2p_data * p2p,const u8 * bssid,u16 reason_code,const u8 * ie,size_t ie_len)4929 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, 4930 const u8 *ie, size_t ie_len) 4931 { 4932 struct p2p_message msg; 4933 4934 if (bssid == NULL || ie == NULL) 4935 return; 4936 4937 os_memset(&msg, 0, sizeof(msg)); 4938 if (p2p_parse_ies(ie, ie_len, &msg)) 4939 return; 4940 if (msg.minor_reason_code == NULL) { 4941 p2p_parse_free(&msg); 4942 return; 4943 } 4944 4945 p2p_dbg(p2p, "Disassociation notification BSSID " MACSTR 4946 " reason_code=%u minor_reason_code=%u", 4947 MAC2STR(bssid), reason_code, *msg.minor_reason_code); 4948 4949 p2p_parse_free(&msg); 4950 } 4951 4952 p2p_set_managed_oper(struct p2p_data * p2p,int enabled)4953 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled) 4954 { 4955 if (enabled) { 4956 p2p_dbg(p2p, "Managed P2P Device operations enabled"); 4957 p2p->dev_capab |= P2P_DEV_CAPAB_INFRA_MANAGED; 4958 } else { 4959 p2p_dbg(p2p, "Managed P2P Device operations disabled"); 4960 p2p->dev_capab &= ~P2P_DEV_CAPAB_INFRA_MANAGED; 4961 } 4962 } 4963 4964 4965 #ifdef CONFIG_TESTING_OPTIONS 4966 p2p_set_pairing_setup(struct p2p_data * p2p,int pairing_setup)4967 void p2p_set_pairing_setup(struct p2p_data *p2p, int pairing_setup) 4968 { 4969 p2p_dbg(p2p, "Pairing Setup %s", 4970 pairing_setup ? "Enabled" : "Disabled"); 4971 if (pairing_setup) { 4972 p2p->cfg->pairing_config.pairing_capable = true; 4973 p2p->cfg->pairing_config.enable_pairing_setup = true; 4974 if (p2p->pairing_info) 4975 p2p->pairing_info->enable_pairing_setup = true; 4976 } else { 4977 p2p->cfg->pairing_config.pairing_capable = false; 4978 p2p->cfg->pairing_config.enable_pairing_setup = false; 4979 if (p2p->pairing_info) 4980 p2p->pairing_info->enable_pairing_setup = false; 4981 } 4982 } 4983 4984 p2p_set_pairing_cache(struct p2p_data * p2p,int pairing_cache)4985 void p2p_set_pairing_cache(struct p2p_data *p2p, int pairing_cache) 4986 { 4987 p2p_dbg(p2p, "Pairing Cache %s", 4988 pairing_cache ? "Enabled" : "Disabled"); 4989 if (pairing_cache) { 4990 p2p->cfg->pairing_config.enable_pairing_cache = true; 4991 if (p2p->pairing_info) 4992 p2p->pairing_info->enable_pairing_cache = true; 4993 } else { 4994 p2p->cfg->pairing_config.enable_pairing_cache = false; 4995 if (p2p->pairing_info) 4996 p2p->pairing_info->enable_pairing_cache = false; 4997 } 4998 } 4999 5000 p2p_set_bootstrapmethods(struct p2p_data * p2p,int bootstrap_methods)5001 void p2p_set_bootstrapmethods(struct p2p_data *p2p, int bootstrap_methods) 5002 { 5003 p2p_dbg(p2p, "Bootstraping methods: 0x%x", bootstrap_methods); 5004 p2p->cfg->pairing_config.bootstrap_methods = bootstrap_methods; 5005 if (p2p->pairing_info) 5006 p2p->pairing_info->supported_bootstrap = bootstrap_methods; 5007 } 5008 5009 p2p_set_pasn_type(struct p2p_data * p2p,u8 pasn_type)5010 void p2p_set_pasn_type(struct p2p_data *p2p, u8 pasn_type) 5011 { 5012 p2p_dbg(p2p, "PASN type: 0x%x", pasn_type); 5013 p2p->cfg->pairing_config.pasn_type = pasn_type; 5014 } 5015 5016 p2p_set_comeback_after(struct p2p_data * p2p,int comeback_after)5017 void p2p_set_comeback_after(struct p2p_data *p2p, int comeback_after) 5018 { 5019 p2p_dbg(p2p, "Comeback after: %d", comeback_after); 5020 p2p->cfg->comeback_after = comeback_after; 5021 } 5022 5023 p2p_set_reg_info(struct p2p_data * p2p,u8 val)5024 void p2p_set_reg_info(struct p2p_data *p2p, u8 val) 5025 { 5026 p2p->cfg->reg_info = val; 5027 } 5028 5029 p2p_set_twt_power_mgmt(struct p2p_data * p2p,int val)5030 void p2p_set_twt_power_mgmt(struct p2p_data *p2p, int val) 5031 { 5032 p2p_dbg(p2p, "TWT-based P2P Power Mgmt: %s", 5033 val ? "Enabled" : "Disabled"); 5034 if (val) 5035 p2p->cfg->twt_power_mgmt = true; 5036 else 5037 p2p->cfg->twt_power_mgmt = false; 5038 } 5039 5040 p2p_set_chan_switch_req_enable(struct p2p_data * p2p,bool val)5041 void p2p_set_chan_switch_req_enable(struct p2p_data *p2p, bool val) 5042 { 5043 p2p->cfg->chan_switch_req_enable = val; 5044 } 5045 5046 p2p_set_invitation_op_freq(struct p2p_data * p2p,int freq)5047 void p2p_set_invitation_op_freq(struct p2p_data *p2p, int freq) 5048 { 5049 u8 op_class, channel; 5050 5051 if (freq == -1) { 5052 p2p->cfg->inv_op_class = 0; 5053 p2p->cfg->inv_op_channel = 0; 5054 return; 5055 } 5056 5057 if (p2p_freq_to_channel(freq, &op_class, &channel) < 0) 5058 return; 5059 5060 p2p->cfg->inv_op_class = op_class; 5061 p2p->cfg->inv_op_channel = channel; 5062 } 5063 5064 #endif /* CONFIG_TESTING_OPTIONS */ 5065 5066 p2p_config_get_random_social(struct p2p_config * p2p,u8 * op_class,u8 * op_channel,struct wpa_freq_range_list * avoid_list,struct wpa_freq_range_list * disallow_list)5067 int p2p_config_get_random_social(struct p2p_config *p2p, u8 *op_class, 5068 u8 *op_channel, 5069 struct wpa_freq_range_list *avoid_list, 5070 struct wpa_freq_range_list *disallow_list) 5071 { 5072 return p2p_channel_random_social(&p2p->channels, op_class, op_channel, 5073 avoid_list, disallow_list); 5074 } 5075 5076 p2p_set_listen_channel(struct p2p_data * p2p,u8 reg_class,u8 channel,u8 forced)5077 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel, 5078 u8 forced) 5079 { 5080 if (p2p_channel_to_freq(reg_class, channel) < 0) 5081 return -1; 5082 5083 /* 5084 * Listen channel was set in configuration or set by control interface; 5085 * cannot override it. 5086 */ 5087 if (p2p->cfg->channel_forced && forced == 0) { 5088 p2p_dbg(p2p, 5089 "Listen channel was previously configured - do not override based on optimization"); 5090 return -1; 5091 } 5092 5093 p2p_dbg(p2p, "Set Listen channel: reg_class %u channel %u", 5094 reg_class, channel); 5095 5096 if (p2p->state == P2P_IDLE) { 5097 p2p->cfg->reg_class = reg_class; 5098 p2p->cfg->channel = channel; 5099 p2p->cfg->channel_forced = forced; 5100 } else { 5101 p2p_dbg(p2p, "Defer setting listen channel"); 5102 p2p->pending_reg_class = reg_class; 5103 p2p->pending_channel = channel; 5104 p2p->pending_channel_forced = forced; 5105 } 5106 5107 return 0; 5108 } 5109 5110 p2p_get_listen_channel(struct p2p_data * p2p)5111 u8 p2p_get_listen_channel(struct p2p_data *p2p) 5112 { 5113 return p2p->cfg->channel; 5114 } 5115 5116 p2p_set_ssid_postfix(struct p2p_data * p2p,const u8 * postfix,size_t len)5117 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len) 5118 { 5119 p2p_dbg(p2p, "New SSID postfix: %s", wpa_ssid_txt(postfix, len)); 5120 if (postfix == NULL) { 5121 p2p->cfg->ssid_postfix_len = 0; 5122 return 0; 5123 } 5124 if (len > sizeof(p2p->cfg->ssid_postfix)) 5125 return -1; 5126 os_memcpy(p2p->cfg->ssid_postfix, postfix, len); 5127 p2p->cfg->ssid_postfix_len = len; 5128 return 0; 5129 } 5130 5131 p2p_set_oper_channel(struct p2p_data * p2p,u8 op_reg_class,u8 op_channel,int cfg_op_channel)5132 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel, 5133 int cfg_op_channel) 5134 { 5135 if (p2p_channel_to_freq(op_reg_class, op_channel) < 0) 5136 return -1; 5137 5138 p2p_dbg(p2p, "Set Operating channel: reg_class %u channel %u", 5139 op_reg_class, op_channel); 5140 p2p->cfg->op_reg_class = op_reg_class; 5141 p2p->cfg->op_channel = op_channel; 5142 p2p->cfg->cfg_op_channel = cfg_op_channel; 5143 return 0; 5144 } 5145 5146 p2p_set_pref_chan(struct p2p_data * p2p,unsigned int num_pref_chan,const struct p2p_channel * pref_chan)5147 int p2p_set_pref_chan(struct p2p_data *p2p, unsigned int num_pref_chan, 5148 const struct p2p_channel *pref_chan) 5149 { 5150 struct p2p_channel *n; 5151 5152 if (pref_chan) { 5153 n = os_memdup(pref_chan, 5154 num_pref_chan * sizeof(struct p2p_channel)); 5155 if (n == NULL) 5156 return -1; 5157 } else 5158 n = NULL; 5159 5160 os_free(p2p->cfg->pref_chan); 5161 p2p->cfg->pref_chan = n; 5162 p2p->cfg->num_pref_chan = num_pref_chan; 5163 5164 return 0; 5165 } 5166 5167 p2p_set_no_go_freq(struct p2p_data * p2p,const struct wpa_freq_range_list * list)5168 int p2p_set_no_go_freq(struct p2p_data *p2p, 5169 const struct wpa_freq_range_list *list) 5170 { 5171 struct wpa_freq_range *tmp; 5172 5173 if (list == NULL || list->num == 0) { 5174 os_free(p2p->no_go_freq.range); 5175 p2p->no_go_freq.range = NULL; 5176 p2p->no_go_freq.num = 0; 5177 return 0; 5178 } 5179 5180 tmp = os_calloc(list->num, sizeof(struct wpa_freq_range)); 5181 if (tmp == NULL) 5182 return -1; 5183 os_memcpy(tmp, list->range, list->num * sizeof(struct wpa_freq_range)); 5184 os_free(p2p->no_go_freq.range); 5185 p2p->no_go_freq.range = tmp; 5186 p2p->no_go_freq.num = list->num; 5187 p2p_dbg(p2p, "Updated no GO chan list"); 5188 5189 return 0; 5190 } 5191 5192 p2p_get_interface_addr(struct p2p_data * p2p,const u8 * dev_addr,u8 * iface_addr)5193 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr, 5194 u8 *iface_addr) 5195 { 5196 struct p2p_device *dev = p2p_get_device(p2p, dev_addr); 5197 5198 if (!dev || is_zero_ether_addr(dev->interface_addr)) { 5199 p2p_dbg(p2p, 5200 "P2P: Failed to get interface address from device addr " 5201 MACSTR, MAC2STR(dev_addr)); 5202 return -1; 5203 } 5204 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN); 5205 return 0; 5206 } 5207 5208 p2p_get_dev_addr(struct p2p_data * p2p,const u8 * iface_addr,u8 * dev_addr)5209 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr, 5210 u8 *dev_addr) 5211 { 5212 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr); 5213 5214 if (!dev) { 5215 p2p_dbg(p2p, 5216 "P2P: Failed to get device address from interface address " 5217 MACSTR, MAC2STR(iface_addr)); 5218 return -1; 5219 } 5220 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN); 5221 return 0; 5222 } 5223 5224 p2p_get_dev_identity_key(struct p2p_data * p2p,const u8 * dev_addr,const u8 ** dik_data,size_t * dik_len,u8 * cipher)5225 int p2p_get_dev_identity_key(struct p2p_data *p2p, const u8 *dev_addr, 5226 const u8 **dik_data, size_t *dik_len, u8 *cipher) 5227 { 5228 if (!p2p || !p2p->peer_dik_len) { 5229 wpa_printf(MSG_DEBUG, 5230 "P2P2: Failed to get device identity key for " 5231 MACSTR, MAC2STR(dev_addr)); 5232 return -1; 5233 } 5234 5235 *dik_data = p2p->peer_dik_data; 5236 *dik_len = p2p->peer_dik_len; 5237 *cipher = p2p->dik_cipher_version; 5238 5239 /* Reset DIK length to invalidate DIK for successive iteration of a new 5240 * peer. */ 5241 p2p->peer_dik_len = 0; 5242 5243 return 0; 5244 } 5245 5246 p2p_set_peer_filter(struct p2p_data * p2p,const u8 * addr)5247 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr) 5248 { 5249 os_memcpy(p2p->peer_filter, addr, ETH_ALEN); 5250 if (is_zero_ether_addr(p2p->peer_filter)) 5251 p2p_dbg(p2p, "Disable peer filter"); 5252 else 5253 p2p_dbg(p2p, "Enable peer filter for " MACSTR, 5254 MAC2STR(p2p->peer_filter)); 5255 } 5256 5257 p2p_set_cross_connect(struct p2p_data * p2p,int enabled)5258 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled) 5259 { 5260 p2p_dbg(p2p, "Cross connection %s", enabled ? "enabled" : "disabled"); 5261 if (p2p->cross_connect == enabled) 5262 return; 5263 p2p->cross_connect = enabled; 5264 /* TODO: may need to tear down any action group where we are GO(?) */ 5265 } 5266 5267 p2p_get_oper_freq(struct p2p_data * p2p,const u8 * iface_addr)5268 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr) 5269 { 5270 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr); 5271 if (dev == NULL) 5272 return -1; 5273 if (dev->oper_freq <= 0) 5274 return -1; 5275 return dev->oper_freq; 5276 } 5277 5278 p2p_set_intra_bss_dist(struct p2p_data * p2p,int enabled)5279 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled) 5280 { 5281 p2p_dbg(p2p, "Intra BSS distribution %s", 5282 enabled ? "enabled" : "disabled"); 5283 p2p->cfg->p2p_intra_bss = enabled; 5284 } 5285 5286 p2p_update_channel_list(struct p2p_data * p2p,const struct p2p_channels * chan,const struct p2p_channels * cli_chan)5287 void p2p_update_channel_list(struct p2p_data *p2p, 5288 const struct p2p_channels *chan, 5289 const struct p2p_channels *cli_chan) 5290 { 5291 p2p_dbg(p2p, "Update channel list"); 5292 os_memcpy(&p2p->cfg->channels, chan, sizeof(struct p2p_channels)); 5293 p2p_channels_dump(p2p, "channels", &p2p->cfg->channels); 5294 os_memcpy(&p2p->cfg->cli_channels, cli_chan, 5295 sizeof(struct p2p_channels)); 5296 p2p_channels_dump(p2p, "cli_channels", &p2p->cfg->cli_channels); 5297 } 5298 5299 p2p_send_action(struct p2p_data * p2p,unsigned int freq,const u8 * dst,const u8 * src,const u8 * bssid,const u8 * buf,size_t len,unsigned int wait_time)5300 int p2p_send_action(struct p2p_data *p2p, unsigned int freq, const u8 *dst, 5301 const u8 *src, const u8 *bssid, const u8 *buf, 5302 size_t len, unsigned int wait_time) 5303 { 5304 int res, scheduled; 5305 5306 res = p2p->cfg->send_action(p2p->cfg->cb_ctx, freq, dst, src, bssid, 5307 buf, len, wait_time, &scheduled); 5308 if (res == 0 && scheduled && p2p->in_listen && freq > 0 && 5309 p2p->drv_in_listen > 0 && 5310 (unsigned int) p2p->drv_in_listen != freq) { 5311 p2p_dbg(p2p, 5312 "Stop listen on %d MHz to allow a frame to be sent immediately on %d MHz", 5313 p2p->drv_in_listen, freq); 5314 p2p_stop_listen_for_freq(p2p, freq); 5315 } 5316 return res; 5317 } 5318 5319 p2p_set_best_channels(struct p2p_data * p2p,int freq_24,int freq_5,int freq_overall)5320 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5, 5321 int freq_overall) 5322 { 5323 p2p_dbg(p2p, "Best channel: 2.4 GHz: %d, 5 GHz: %d, overall: %d", 5324 freq_24, freq_5, freq_overall); 5325 p2p->best_freq_24 = freq_24; 5326 p2p->best_freq_5 = freq_5; 5327 p2p->best_freq_overall = freq_overall; 5328 } 5329 5330 p2p_set_own_freq_preference(struct p2p_data * p2p,int freq)5331 void p2p_set_own_freq_preference(struct p2p_data *p2p, int freq) 5332 { 5333 p2p_dbg(p2p, "Own frequency preference: %d MHz", freq); 5334 p2p->own_freq_preference = freq; 5335 } 5336 5337 p2p_get_go_neg_peer(struct p2p_data * p2p)5338 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p) 5339 { 5340 if (p2p == NULL || p2p->go_neg_peer == NULL) 5341 return NULL; 5342 return p2p->go_neg_peer->info.p2p_device_addr; 5343 } 5344 5345 5346 const struct p2p_peer_info * p2p_get_peer_found(struct p2p_data * p2p,const u8 * addr,int next)5347 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next) 5348 { 5349 struct p2p_device *dev; 5350 5351 if (addr) { 5352 dev = p2p_get_device(p2p, addr); 5353 if (!dev) 5354 return NULL; 5355 5356 if (!next) { 5357 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) 5358 return NULL; 5359 5360 return &dev->info; 5361 } else { 5362 do { 5363 dev = dl_list_first(&dev->list, 5364 struct p2p_device, 5365 list); 5366 if (!dev || &dev->list == &p2p->devices) 5367 return NULL; 5368 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY); 5369 } 5370 } else { 5371 dev = dl_list_first(&p2p->devices, struct p2p_device, list); 5372 if (!dev) 5373 return NULL; 5374 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) { 5375 dev = dl_list_first(&dev->list, 5376 struct p2p_device, 5377 list); 5378 if (!dev || &dev->list == &p2p->devices) 5379 return NULL; 5380 } 5381 } 5382 5383 return &dev->info; 5384 } 5385 5386 p2p_in_progress(struct p2p_data * p2p)5387 int p2p_in_progress(struct p2p_data *p2p) 5388 { 5389 if (p2p == NULL) 5390 return 0; 5391 if (p2p->state == P2P_SEARCH) 5392 return 2; 5393 return p2p->state != P2P_IDLE && p2p->state != P2P_PROVISIONING; 5394 } 5395 5396 p2p_set_config_timeout(struct p2p_data * p2p,u8 go_timeout,u8 client_timeout)5397 void p2p_set_config_timeout(struct p2p_data *p2p, u8 go_timeout, 5398 u8 client_timeout) 5399 { 5400 if (p2p) { 5401 p2p->go_timeout = go_timeout; 5402 p2p->client_timeout = client_timeout; 5403 } 5404 } 5405 5406 5407 #ifdef CONFIG_WIFI_DISPLAY 5408 p2p_update_wfd_ie_groups(struct p2p_data * p2p)5409 static void p2p_update_wfd_ie_groups(struct p2p_data *p2p) 5410 { 5411 size_t g; 5412 struct p2p_group *group; 5413 5414 for (g = 0; g < p2p->num_groups; g++) { 5415 group = p2p->groups[g]; 5416 p2p_group_force_beacon_update_ies(group); 5417 } 5418 } 5419 5420 p2p_set_wfd_ie_beacon(struct p2p_data * p2p,struct wpabuf * ie)5421 int p2p_set_wfd_ie_beacon(struct p2p_data *p2p, struct wpabuf *ie) 5422 { 5423 wpabuf_free(p2p->wfd_ie_beacon); 5424 p2p->wfd_ie_beacon = ie; 5425 p2p_update_wfd_ie_groups(p2p); 5426 return 0; 5427 } 5428 5429 p2p_set_wfd_ie_probe_req(struct p2p_data * p2p,struct wpabuf * ie)5430 int p2p_set_wfd_ie_probe_req(struct p2p_data *p2p, struct wpabuf *ie) 5431 { 5432 wpabuf_free(p2p->wfd_ie_probe_req); 5433 p2p->wfd_ie_probe_req = ie; 5434 return 0; 5435 } 5436 5437 p2p_set_wfd_ie_probe_resp(struct p2p_data * p2p,struct wpabuf * ie)5438 int p2p_set_wfd_ie_probe_resp(struct p2p_data *p2p, struct wpabuf *ie) 5439 { 5440 wpabuf_free(p2p->wfd_ie_probe_resp); 5441 p2p->wfd_ie_probe_resp = ie; 5442 p2p_update_wfd_ie_groups(p2p); 5443 return 0; 5444 } 5445 5446 p2p_set_wfd_ie_assoc_req(struct p2p_data * p2p,struct wpabuf * ie)5447 int p2p_set_wfd_ie_assoc_req(struct p2p_data *p2p, struct wpabuf *ie) 5448 { 5449 wpabuf_free(p2p->wfd_ie_assoc_req); 5450 p2p->wfd_ie_assoc_req = ie; 5451 return 0; 5452 } 5453 5454 p2p_set_wfd_ie_invitation(struct p2p_data * p2p,struct wpabuf * ie)5455 int p2p_set_wfd_ie_invitation(struct p2p_data *p2p, struct wpabuf *ie) 5456 { 5457 wpabuf_free(p2p->wfd_ie_invitation); 5458 p2p->wfd_ie_invitation = ie; 5459 return 0; 5460 } 5461 5462 p2p_set_wfd_ie_prov_disc_req(struct p2p_data * p2p,struct wpabuf * ie)5463 int p2p_set_wfd_ie_prov_disc_req(struct p2p_data *p2p, struct wpabuf *ie) 5464 { 5465 wpabuf_free(p2p->wfd_ie_prov_disc_req); 5466 p2p->wfd_ie_prov_disc_req = ie; 5467 return 0; 5468 } 5469 5470 p2p_set_wfd_ie_prov_disc_resp(struct p2p_data * p2p,struct wpabuf * ie)5471 int p2p_set_wfd_ie_prov_disc_resp(struct p2p_data *p2p, struct wpabuf *ie) 5472 { 5473 wpabuf_free(p2p->wfd_ie_prov_disc_resp); 5474 p2p->wfd_ie_prov_disc_resp = ie; 5475 return 0; 5476 } 5477 5478 p2p_set_wfd_ie_go_neg(struct p2p_data * p2p,struct wpabuf * ie)5479 int p2p_set_wfd_ie_go_neg(struct p2p_data *p2p, struct wpabuf *ie) 5480 { 5481 wpabuf_free(p2p->wfd_ie_go_neg); 5482 p2p->wfd_ie_go_neg = ie; 5483 return 0; 5484 } 5485 5486 p2p_set_wfd_dev_info(struct p2p_data * p2p,const struct wpabuf * elem)5487 int p2p_set_wfd_dev_info(struct p2p_data *p2p, const struct wpabuf *elem) 5488 { 5489 wpabuf_free(p2p->wfd_dev_info); 5490 if (elem) { 5491 p2p->wfd_dev_info = wpabuf_dup(elem); 5492 if (p2p->wfd_dev_info == NULL) 5493 return -1; 5494 } else 5495 p2p->wfd_dev_info = NULL; 5496 5497 return 0; 5498 } 5499 5500 p2p_set_wfd_r2_dev_info(struct p2p_data * p2p,const struct wpabuf * elem)5501 int p2p_set_wfd_r2_dev_info(struct p2p_data *p2p, const struct wpabuf *elem) 5502 { 5503 wpabuf_free(p2p->wfd_r2_dev_info); 5504 if (elem) { 5505 p2p->wfd_r2_dev_info = wpabuf_dup(elem); 5506 if (p2p->wfd_r2_dev_info == NULL) 5507 return -1; 5508 } else 5509 p2p->wfd_r2_dev_info = NULL; 5510 5511 return 0; 5512 } 5513 5514 p2p_set_wfd_assoc_bssid(struct p2p_data * p2p,const struct wpabuf * elem)5515 int p2p_set_wfd_assoc_bssid(struct p2p_data *p2p, const struct wpabuf *elem) 5516 { 5517 wpabuf_free(p2p->wfd_assoc_bssid); 5518 if (elem) { 5519 p2p->wfd_assoc_bssid = wpabuf_dup(elem); 5520 if (p2p->wfd_assoc_bssid == NULL) 5521 return -1; 5522 } else 5523 p2p->wfd_assoc_bssid = NULL; 5524 5525 return 0; 5526 } 5527 5528 p2p_set_wfd_coupled_sink_info(struct p2p_data * p2p,const struct wpabuf * elem)5529 int p2p_set_wfd_coupled_sink_info(struct p2p_data *p2p, 5530 const struct wpabuf *elem) 5531 { 5532 wpabuf_free(p2p->wfd_coupled_sink_info); 5533 if (elem) { 5534 p2p->wfd_coupled_sink_info = wpabuf_dup(elem); 5535 if (p2p->wfd_coupled_sink_info == NULL) 5536 return -1; 5537 } else 5538 p2p->wfd_coupled_sink_info = NULL; 5539 5540 return 0; 5541 } 5542 5543 #endif /* CONFIG_WIFI_DISPLAY */ 5544 5545 p2p_set_disc_int(struct p2p_data * p2p,int min_disc_int,int max_disc_int,int max_disc_tu)5546 int p2p_set_disc_int(struct p2p_data *p2p, int min_disc_int, int max_disc_int, 5547 int max_disc_tu) 5548 { 5549 if (min_disc_int > max_disc_int || min_disc_int < 0 || max_disc_int < 0) 5550 return -1; 5551 5552 p2p->min_disc_int = min_disc_int; 5553 p2p->max_disc_int = max_disc_int; 5554 p2p->max_disc_tu = max_disc_tu; 5555 p2p_dbg(p2p, "Set discoverable interval: min=%d max=%d max_tu=%d", 5556 min_disc_int, max_disc_int, max_disc_tu); 5557 5558 return 0; 5559 } 5560 5561 p2p_dbg(struct p2p_data * p2p,const char * fmt,...)5562 void p2p_dbg(struct p2p_data *p2p, const char *fmt, ...) 5563 { 5564 va_list ap; 5565 char buf[500]; 5566 5567 if (!p2p->cfg->debug_print) 5568 return; 5569 5570 va_start(ap, fmt); 5571 vsnprintf(buf, sizeof(buf), fmt, ap); 5572 buf[sizeof(buf) - 1] = '\0'; 5573 va_end(ap); 5574 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_DEBUG, buf); 5575 } 5576 5577 p2p_info(struct p2p_data * p2p,const char * fmt,...)5578 void p2p_info(struct p2p_data *p2p, const char *fmt, ...) 5579 { 5580 va_list ap; 5581 char buf[500]; 5582 5583 if (!p2p->cfg->debug_print) 5584 return; 5585 5586 va_start(ap, fmt); 5587 vsnprintf(buf, sizeof(buf), fmt, ap); 5588 buf[sizeof(buf) - 1] = '\0'; 5589 va_end(ap); 5590 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_INFO, buf); 5591 } 5592 5593 p2p_err(struct p2p_data * p2p,const char * fmt,...)5594 void p2p_err(struct p2p_data *p2p, const char *fmt, ...) 5595 { 5596 va_list ap; 5597 char buf[500]; 5598 5599 if (!p2p->cfg->debug_print) 5600 return; 5601 5602 va_start(ap, fmt); 5603 vsnprintf(buf, sizeof(buf), fmt, ap); 5604 buf[sizeof(buf) - 1] = '\0'; 5605 va_end(ap); 5606 p2p->cfg->debug_print(p2p->cfg->cb_ctx, MSG_ERROR, buf); 5607 } 5608 5609 p2p_loop_on_known_peers(struct p2p_data * p2p,void (* peer_callback)(struct p2p_peer_info * peer,void * user_data),void * user_data)5610 void p2p_loop_on_known_peers(struct p2p_data *p2p, 5611 void (*peer_callback)(struct p2p_peer_info *peer, 5612 void *user_data), 5613 void *user_data) 5614 { 5615 struct p2p_device *dev, *n; 5616 5617 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) { 5618 peer_callback(&dev->info, user_data); 5619 } 5620 } 5621 5622 5623 #ifdef CONFIG_WPS_NFC 5624 p2p_build_nfc_handover(struct p2p_data * p2p,int client_freq,const u8 * go_dev_addr,const u8 * ssid,size_t ssid_len)5625 static struct wpabuf * p2p_build_nfc_handover(struct p2p_data *p2p, 5626 int client_freq, 5627 const u8 *go_dev_addr, 5628 const u8 *ssid, size_t ssid_len) 5629 { 5630 struct wpabuf *buf; 5631 u8 op_class, channel; 5632 enum p2p_role_indication role = P2P_DEVICE_NOT_IN_GROUP; 5633 5634 buf = wpabuf_alloc(1000); 5635 if (buf == NULL) 5636 return NULL; 5637 5638 op_class = p2p->cfg->reg_class; 5639 channel = p2p->cfg->channel; 5640 5641 p2p_buf_add_capability(buf, p2p->dev_capab & 5642 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 0); 5643 p2p_buf_add_device_info(buf, p2p, NULL); 5644 5645 if (p2p->num_groups > 0) { 5646 int freq = p2p_group_get_freq(p2p->groups[0]); 5647 role = P2P_GO_IN_A_GROUP; 5648 if (p2p_freq_to_channel(freq, &op_class, &channel) < 0) { 5649 p2p_dbg(p2p, 5650 "Unknown GO operating frequency %d MHz for NFC handover", 5651 freq); 5652 wpabuf_free(buf); 5653 return NULL; 5654 } 5655 } else if (client_freq > 0) { 5656 role = P2P_CLIENT_IN_A_GROUP; 5657 if (p2p_freq_to_channel(client_freq, &op_class, &channel) < 0) { 5658 p2p_dbg(p2p, 5659 "Unknown client operating frequency %d MHz for NFC handover", 5660 client_freq); 5661 wpabuf_free(buf); 5662 return NULL; 5663 } 5664 } 5665 5666 p2p_buf_add_oob_go_neg_channel(buf, p2p->cfg->country, op_class, 5667 channel, role); 5668 5669 if (p2p->num_groups > 0) { 5670 /* Limit number of clients to avoid very long message */ 5671 p2p_buf_add_group_info(p2p->groups[0], buf, 5); 5672 p2p_group_buf_add_id(p2p->groups[0], buf); 5673 } else if (client_freq > 0 && 5674 go_dev_addr && !is_zero_ether_addr(go_dev_addr) && 5675 ssid && ssid_len > 0) { 5676 /* 5677 * Add the optional P2P Group ID to indicate in which group this 5678 * device is a P2P Client. 5679 */ 5680 p2p_buf_add_group_id(buf, go_dev_addr, ssid, ssid_len); 5681 } 5682 5683 return buf; 5684 } 5685 5686 p2p_build_nfc_handover_req(struct p2p_data * p2p,int client_freq,const u8 * go_dev_addr,const u8 * ssid,size_t ssid_len)5687 struct wpabuf * p2p_build_nfc_handover_req(struct p2p_data *p2p, 5688 int client_freq, 5689 const u8 *go_dev_addr, 5690 const u8 *ssid, size_t ssid_len) 5691 { 5692 return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid, 5693 ssid_len); 5694 } 5695 5696 p2p_build_nfc_handover_sel(struct p2p_data * p2p,int client_freq,const u8 * go_dev_addr,const u8 * ssid,size_t ssid_len)5697 struct wpabuf * p2p_build_nfc_handover_sel(struct p2p_data *p2p, 5698 int client_freq, 5699 const u8 *go_dev_addr, 5700 const u8 *ssid, size_t ssid_len) 5701 { 5702 return p2p_build_nfc_handover(p2p, client_freq, go_dev_addr, ssid, 5703 ssid_len); 5704 } 5705 5706 p2p_process_nfc_connection_handover(struct p2p_data * p2p,struct p2p_nfc_params * params)5707 int p2p_process_nfc_connection_handover(struct p2p_data *p2p, 5708 struct p2p_nfc_params *params) 5709 { 5710 struct p2p_message msg; 5711 struct p2p_device *dev; 5712 const u8 *p2p_dev_addr; 5713 int freq; 5714 enum p2p_role_indication role; 5715 5716 params->next_step = NO_ACTION; 5717 5718 if (p2p_parse_ies_separate(params->wsc_attr, params->wsc_len, 5719 params->p2p_attr, params->p2p_len, &msg)) { 5720 p2p_dbg(p2p, "Failed to parse WSC/P2P attributes from NFC"); 5721 p2p_parse_free(&msg); 5722 return -1; 5723 } 5724 5725 if (msg.p2p_device_addr) 5726 p2p_dev_addr = msg.p2p_device_addr; 5727 else if (msg.device_id) 5728 p2p_dev_addr = msg.device_id; 5729 else { 5730 p2p_dbg(p2p, "Ignore scan data without P2P Device Info or P2P Device Id"); 5731 p2p_parse_free(&msg); 5732 return -1; 5733 } 5734 5735 if (msg.oob_dev_password) { 5736 os_memcpy(params->oob_dev_pw, msg.oob_dev_password, 5737 msg.oob_dev_password_len); 5738 params->oob_dev_pw_len = msg.oob_dev_password_len; 5739 } 5740 5741 dev = p2p_create_device(p2p, p2p_dev_addr); 5742 if (dev == NULL) { 5743 p2p_parse_free(&msg); 5744 return -1; 5745 } 5746 5747 params->peer = &dev->info; 5748 5749 os_get_reltime(&dev->last_seen); 5750 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY); 5751 p2p_copy_wps_info(p2p, dev, 0, &msg); 5752 5753 if (!msg.oob_go_neg_channel) { 5754 p2p_dbg(p2p, "OOB GO Negotiation Channel attribute not included"); 5755 p2p_parse_free(&msg); 5756 return -1; 5757 } 5758 5759 if (msg.oob_go_neg_channel[3] == 0 && 5760 msg.oob_go_neg_channel[4] == 0) 5761 freq = 0; 5762 else 5763 freq = p2p_channel_to_freq(msg.oob_go_neg_channel[3], 5764 msg.oob_go_neg_channel[4]); 5765 if (freq < 0) { 5766 p2p_dbg(p2p, "Unknown peer OOB GO Neg channel"); 5767 p2p_parse_free(&msg); 5768 return -1; 5769 } 5770 role = msg.oob_go_neg_channel[5]; 5771 5772 if (role == P2P_GO_IN_A_GROUP) { 5773 p2p_dbg(p2p, "Peer OOB GO operating channel: %u MHz", freq); 5774 params->go_freq = freq; 5775 } else if (role == P2P_CLIENT_IN_A_GROUP) { 5776 p2p_dbg(p2p, "Peer (client) OOB GO operating channel: %u MHz", 5777 freq); 5778 params->go_freq = freq; 5779 } else 5780 p2p_dbg(p2p, "Peer OOB GO Neg channel: %u MHz", freq); 5781 dev->oob_go_neg_freq = freq; 5782 5783 if (!params->sel && role != P2P_GO_IN_A_GROUP) { 5784 freq = p2p_channel_to_freq(p2p->cfg->reg_class, 5785 p2p->cfg->channel); 5786 if (freq < 0) { 5787 p2p_dbg(p2p, "Own listen channel not known"); 5788 p2p_parse_free(&msg); 5789 return -1; 5790 } 5791 p2p_dbg(p2p, "Use own Listen channel as OOB GO Neg channel: %u MHz", freq); 5792 dev->oob_go_neg_freq = freq; 5793 } 5794 5795 if (msg.group_id) { 5796 os_memcpy(params->go_dev_addr, msg.group_id, ETH_ALEN); 5797 params->go_ssid_len = msg.group_id_len - ETH_ALEN; 5798 os_memcpy(params->go_ssid, msg.group_id + ETH_ALEN, 5799 params->go_ssid_len); 5800 } 5801 5802 if (dev->flags & P2P_DEV_USER_REJECTED) { 5803 p2p_dbg(p2p, "Do not report rejected device"); 5804 p2p_parse_free(&msg); 5805 return 0; 5806 } 5807 5808 if (!(dev->flags & P2P_DEV_REPORTED)) { 5809 p2p->cfg->dev_found(p2p->cfg->cb_ctx, p2p_dev_addr, &dev->info, 5810 !(dev->flags & P2P_DEV_REPORTED_ONCE)); 5811 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 5812 } 5813 p2p_parse_free(&msg); 5814 5815 if (role == P2P_GO_IN_A_GROUP && p2p->num_groups > 0) 5816 params->next_step = BOTH_GO; 5817 else if (role == P2P_GO_IN_A_GROUP) 5818 params->next_step = JOIN_GROUP; 5819 else if (role == P2P_CLIENT_IN_A_GROUP) { 5820 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY; 5821 params->next_step = PEER_CLIENT; 5822 } else if (p2p->num_groups > 0) 5823 params->next_step = AUTH_JOIN; 5824 else if (params->sel) 5825 params->next_step = INIT_GO_NEG; 5826 else 5827 params->next_step = RESP_GO_NEG; 5828 5829 return 0; 5830 } 5831 5832 p2p_set_authorized_oob_dev_pw_id(struct p2p_data * p2p,u16 dev_pw_id,int go_intent,const u8 * own_interface_addr)5833 void p2p_set_authorized_oob_dev_pw_id(struct p2p_data *p2p, u16 dev_pw_id, 5834 int go_intent, 5835 const u8 *own_interface_addr) 5836 { 5837 5838 p2p->authorized_oob_dev_pw_id = dev_pw_id; 5839 if (dev_pw_id == 0) { 5840 p2p_dbg(p2p, "NFC OOB Password unauthorized for static handover"); 5841 return; 5842 } 5843 5844 p2p_dbg(p2p, "NFC OOB Password (id=%u) authorized for static handover", 5845 dev_pw_id); 5846 5847 p2p->go_intent = go_intent; 5848 os_memcpy(p2p->intended_addr, own_interface_addr, ETH_ALEN); 5849 } 5850 5851 #endif /* CONFIG_WPS_NFC */ 5852 5853 p2p_set_passphrase_len(struct p2p_data * p2p,unsigned int len)5854 int p2p_set_passphrase_len(struct p2p_data *p2p, unsigned int len) 5855 { 5856 if (len < 8 || len > 63) 5857 return -1; 5858 p2p->cfg->passphrase_len = len; 5859 return 0; 5860 } 5861 5862 p2p_set_vendor_elems(struct p2p_data * p2p,struct wpabuf ** vendor_elem)5863 void p2p_set_vendor_elems(struct p2p_data *p2p, struct wpabuf **vendor_elem) 5864 { 5865 p2p->vendor_elem = vendor_elem; 5866 } 5867 5868 p2p_go_neg_wait_timeout(void * eloop_ctx,void * timeout_ctx)5869 void p2p_go_neg_wait_timeout(void *eloop_ctx, void *timeout_ctx) 5870 { 5871 struct p2p_data *p2p = eloop_ctx; 5872 5873 p2p_dbg(p2p, 5874 "Timeout on waiting peer to become ready for GO Negotiation"); 5875 p2p_go_neg_failed(p2p, -1); 5876 } 5877 5878 p2p_set_own_pref_freq_list(struct p2p_data * p2p,const struct weighted_pcl * pref_freq_list,unsigned int size)5879 void p2p_set_own_pref_freq_list(struct p2p_data *p2p, 5880 const struct weighted_pcl *pref_freq_list, 5881 unsigned int size) 5882 { 5883 unsigned int i; 5884 5885 if (size > P2P_MAX_PREF_CHANNELS) 5886 size = P2P_MAX_PREF_CHANNELS; 5887 p2p->num_pref_freq = size; 5888 os_memcpy(p2p->pref_freq_list, pref_freq_list, 5889 size * sizeof(struct weighted_pcl)); 5890 for (i = 0; i < size; i++) { 5891 p2p_dbg(p2p, "Own preferred frequency list[%u]=%u MHz", 5892 i, p2p->pref_freq_list[i].freq); 5893 } 5894 } 5895 5896 p2p_set_override_pref_op_chan(struct p2p_data * p2p,u8 op_class,u8 chan)5897 void p2p_set_override_pref_op_chan(struct p2p_data *p2p, u8 op_class, 5898 u8 chan) 5899 { 5900 p2p->override_pref_op_class = op_class; 5901 p2p->override_pref_channel = chan; 5902 } 5903 5904 p2p_build_probe_resp_template(struct p2p_data * p2p,unsigned int freq)5905 struct wpabuf * p2p_build_probe_resp_template(struct p2p_data *p2p, 5906 unsigned int freq) 5907 { 5908 struct wpabuf *ies, *buf; 5909 u8 addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 5910 int ret; 5911 5912 ies = p2p_build_probe_resp_ies(p2p, NULL, 0); 5913 if (!ies) { 5914 wpa_printf(MSG_ERROR, 5915 "CTRL: Failed to build Probe Response IEs"); 5916 return NULL; 5917 } 5918 5919 buf = wpabuf_alloc(200 + wpabuf_len(ies)); 5920 if (!buf) { 5921 wpabuf_free(ies); 5922 return NULL; 5923 } 5924 5925 ret = p2p_build_probe_resp_buf(p2p, buf, ies, addr, freq); 5926 wpabuf_free(ies); 5927 if (ret) { 5928 wpabuf_free(buf); 5929 return NULL; 5930 } 5931 5932 return buf; 5933 } 5934 5935 p2p_is_peer_6ghz_capab(struct p2p_data * p2p,const u8 * addr)5936 bool p2p_is_peer_6ghz_capab(struct p2p_data *p2p, const u8 *addr) 5937 { 5938 struct p2p_device *dev; 5939 5940 dev = p2p_get_device(p2p, addr); 5941 if (!dev) 5942 return false; 5943 5944 return dev->support_6ghz; 5945 } 5946 5947 p2p_set_6ghz_dev_capab(struct p2p_data * p2p,bool allow_6ghz)5948 void p2p_set_6ghz_dev_capab(struct p2p_data *p2p, bool allow_6ghz) 5949 { 5950 p2p->p2p_6ghz_capable = allow_6ghz; 5951 p2p->allow_6ghz = allow_6ghz; 5952 p2p_dbg(p2p, "Set 6 GHz capability to %d", allow_6ghz); 5953 5954 if (allow_6ghz) 5955 p2p->dev_capab |= P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE; 5956 else 5957 p2p->dev_capab &= ~P2P_DEV_CAPAB_6GHZ_BAND_CAPABLE; 5958 } 5959 5960 is_p2p_6ghz_capable(struct p2p_data * p2p)5961 bool is_p2p_6ghz_capable(struct p2p_data *p2p) 5962 { 5963 return p2p->p2p_6ghz_capable; 5964 } 5965 5966 p2p_wfd_enabled(struct p2p_data * p2p)5967 bool p2p_wfd_enabled(struct p2p_data *p2p) 5968 { 5969 #ifdef CONFIG_WIFI_DISPLAY 5970 return p2p->wfd_ie_probe_req != NULL; 5971 #else /* CONFIG_WIFI_DISPLAY */ 5972 return false; 5973 #endif /* CONFIG_WIFI_DISPLAY */ 5974 } 5975 5976 p2p_peer_wfd_enabled(struct p2p_data * p2p,const u8 * peer_addr)5977 bool p2p_peer_wfd_enabled(struct p2p_data *p2p, const u8 *peer_addr) 5978 { 5979 #ifdef CONFIG_WIFI_DISPLAY 5980 struct p2p_device *dev; 5981 5982 dev = p2p_get_device(p2p, peer_addr); 5983 return dev && dev->info.wfd_subelems != NULL; 5984 #else /* CONFIG_WIFI_DISPLAY */ 5985 return false; 5986 #endif /* CONFIG_WIFI_DISPLAY */ 5987 } 5988 5989 is_p2p_allow_6ghz(struct p2p_data * p2p)5990 bool is_p2p_allow_6ghz(struct p2p_data *p2p) 5991 { 5992 return p2p->allow_6ghz; 5993 } 5994 5995 set_p2p_allow_6ghz(struct p2p_data * p2p,bool value)5996 void set_p2p_allow_6ghz(struct p2p_data *p2p, bool value) 5997 { 5998 p2p->allow_6ghz = value; 5999 } 6000 6001 p2p_derive_nonce_tag(struct p2p_data * p2p)6002 static int p2p_derive_nonce_tag(struct p2p_data *p2p) 6003 { 6004 u8 dira_nonce[DEVICE_IDENTITY_NONCE_LEN]; 6005 u8 dira_tag[DEVICE_MAX_HASH_LEN]; 6006 u8 data[DIR_STR_LEN + DEVICE_IDENTITY_NONCE_LEN + ETH_ALEN]; 6007 struct p2p_id_key *dev_ik; 6008 6009 dev_ik = &p2p->pairing_info->dev_ik; 6010 6011 if (dev_ik->cipher_version != DIRA_CIPHER_VERSION_128) { 6012 wpa_printf(MSG_INFO, 6013 "P2P: Unsupported DIRA Cipher version = %d", 6014 dev_ik->cipher_version); 6015 return -1; 6016 } 6017 6018 if (dev_ik->dik_len != DEVICE_IDENTITY_KEY_LEN) { 6019 wpa_printf(MSG_INFO, "P2P: Invalid DIK length = %zu", 6020 dev_ik->dik_len); 6021 return -1; 6022 } 6023 6024 os_memset(data, 0, sizeof(data)); 6025 6026 if (os_get_random(dira_nonce, DEVICE_IDENTITY_NONCE_LEN) < 0) { 6027 wpa_printf(MSG_ERROR, "P2P: Failed to generate DIRA nonce"); 6028 return -1; 6029 } 6030 6031 /* Tag = Truncate-64(HMAC-SHA-256(DevIK, 6032 * "DIR" || P2P Device Address || Nonce)) 6033 */ 6034 os_memcpy(data, "DIR", DIR_STR_LEN); 6035 os_memcpy(&data[DIR_STR_LEN], p2p->cfg->dev_addr, ETH_ALEN); 6036 os_memcpy(&data[DIR_STR_LEN + ETH_ALEN], dira_nonce, 6037 DEVICE_IDENTITY_NONCE_LEN); 6038 6039 if (hmac_sha256(dev_ik->dik_data, dev_ik->dik_len, data, sizeof(data), 6040 dira_tag) < 0) { 6041 wpa_printf(MSG_ERROR, "P2P: Could not derive DIRA tag"); 6042 return -1; 6043 } 6044 6045 dev_ik->dira_nonce_len = DEVICE_IDENTITY_NONCE_LEN; 6046 os_memcpy(dev_ik->dira_nonce, dira_nonce, DEVICE_IDENTITY_NONCE_LEN); 6047 dev_ik->dira_tag_len = DEVICE_IDENTITY_TAG_LEN; 6048 os_memcpy(dev_ik->dira_tag, dira_tag, DEVICE_IDENTITY_TAG_LEN); 6049 6050 wpa_hexdump_key(MSG_DEBUG, "P2P: DIK", dev_ik->dik_data, 6051 dev_ik->dik_len); 6052 wpa_hexdump_key(MSG_DEBUG, "P2P: DIRA-NONCE", dev_ik->dira_nonce, 6053 dev_ik->dira_nonce_len); 6054 wpa_hexdump_key(MSG_DEBUG, "P2P: DIRA-TAG", dev_ik->dira_tag, 6055 dev_ik->dira_tag_len); 6056 return 0; 6057 } 6058 6059 p2p_validate_dira(struct p2p_data * p2p,struct p2p_device * dev,const u8 * dira,u16 dira_len)6060 static int p2p_validate_dira(struct p2p_data *p2p, struct p2p_device *dev, 6061 const u8 *dira, u16 dira_len) 6062 { 6063 if (dira_len < 1 || dira[0] != DIRA_CIPHER_VERSION_128) { 6064 p2p_dbg(p2p, "Unsupported DIRA cipher version %d", 6065 dira[0]); 6066 return 0; 6067 } 6068 6069 if (dira_len < 1 + DEVICE_IDENTITY_NONCE_LEN + DEVICE_IDENTITY_TAG_LEN) 6070 { 6071 p2p_dbg(p2p, "Truncated DIRA (length %u)", dira_len); 6072 return 0; 6073 } 6074 6075 if (p2p->cfg->validate_dira) { 6076 const u8 *nonce = &dira[1]; 6077 const u8 *tag = &dira[1 + DEVICE_IDENTITY_NONCE_LEN]; 6078 6079 return p2p->cfg->validate_dira(p2p->cfg->cb_ctx, 6080 dev->info.p2p_device_addr, 6081 nonce, tag); 6082 } 6083 6084 return 0; 6085 } 6086 6087 p2p_usd_service_hash(struct p2p_data * p2p,const char * service_name)6088 void p2p_usd_service_hash(struct p2p_data *p2p, const char *service_name) 6089 { 6090 u8 buf[P2PS_HASH_LEN]; 6091 6092 p2p->usd_service = false; 6093 6094 if (!service_name) 6095 return; 6096 6097 if (!p2ps_gen_hash(p2p, service_name, buf)) 6098 return; 6099 p2p_dbg(p2p, "USD service %s hash " MACSTR, 6100 service_name, MAC2STR(buf)); 6101 p2p->usd_service = true; 6102 os_memcpy(&p2p->p2p_service_hash, buf, P2PS_HASH_LEN); 6103 } 6104 6105 p2p_usd_elems(struct p2p_data * p2p)6106 struct wpabuf * p2p_usd_elems(struct p2p_data *p2p) 6107 { 6108 struct wpabuf *buf; 6109 u8 *len; 6110 u8 group_capab; 6111 6112 buf = wpabuf_alloc(1000); 6113 if (!buf) 6114 return NULL; 6115 6116 len = p2p_buf_add_ie_hdr(buf); 6117 6118 /* P2P Capability attribute */ 6119 group_capab = 0; 6120 if (p2p->num_groups) { 6121 group_capab |= P2P_GROUP_CAPAB_GROUP_OWNER; 6122 if ((p2p->dev_capab & P2P_DEV_CAPAB_CONCURRENT_OPER) && 6123 (p2p->dev_capab & P2P_DEV_CAPAB_INFRA_MANAGED) && 6124 p2p->cross_connect) 6125 group_capab |= P2P_GROUP_CAPAB_CROSS_CONN; 6126 } 6127 if (p2p->cfg->p2p_intra_bss) 6128 group_capab |= P2P_GROUP_CAPAB_INTRA_BSS_DIST; 6129 p2p_buf_add_capability(buf, p2p->dev_capab & 6130 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY, 6131 group_capab); 6132 6133 /* P2P Device Info attribute */ 6134 p2p_buf_add_device_info(buf, p2p, NULL); 6135 6136 p2p_buf_update_ie_hdr(buf, len); 6137 6138 len = p2p_buf_add_p2p2_ie_hdr(buf); 6139 6140 /* P2P Capability Extension attribute */ 6141 p2p_buf_add_pcea(buf, p2p); 6142 6143 /* P2P Pairing Bootstrapping Method attribute */ 6144 p2p_buf_add_pbma(buf, p2p->cfg->pairing_config.bootstrap_methods, NULL, 6145 0, 0); 6146 6147 /* P2P Device Identity Resolution attribute */ 6148 if (p2p->pairing_info && 6149 p2p->cfg->pairing_config.pairing_capable && 6150 p2p->cfg->pairing_config.enable_pairing_cache && 6151 p2p_derive_nonce_tag(p2p) == 0) 6152 p2p_buf_add_dira(buf, p2p); 6153 6154 p2p_buf_update_ie_hdr(buf, len); 6155 6156 return buf; 6157 } 6158 6159 p2p_process_usd_elems(struct p2p_data * p2p,const u8 * ies,u16 ies_len,const u8 * peer_addr,unsigned int freq)6160 void p2p_process_usd_elems(struct p2p_data *p2p, const u8 *ies, u16 ies_len, 6161 const u8 *peer_addr, unsigned int freq) 6162 { 6163 struct p2p_device *dev; 6164 struct p2p_message msg; 6165 const u8 *p2p_dev_addr; 6166 6167 os_memset(&msg, 0, sizeof(msg)); 6168 if (p2p_parse_ies(ies, ies_len, &msg)) { 6169 p2p_dbg(p2p, "Failed to parse P2P IE for a device entry"); 6170 p2p_parse_free(&msg); 6171 return; 6172 } 6173 if (msg.p2p_device_addr) 6174 p2p_dev_addr = msg.p2p_device_addr; 6175 else 6176 p2p_dev_addr = peer_addr; 6177 6178 dev = p2p_create_device(p2p, p2p_dev_addr); 6179 if (!dev) { 6180 p2p_parse_free(&msg); 6181 p2p_dbg(p2p, "Failed to add a peer P2P Device"); 6182 return; 6183 } 6184 6185 dev->p2p2 = true; 6186 /* Reset info from old IEs */ 6187 dev->info.reg_info = 0; 6188 os_memset(&dev->info.pairing_config, 0, 6189 sizeof(struct p2p_pairing_config)); 6190 6191 os_get_reltime(&dev->last_seen); 6192 dev->listen_freq = freq; 6193 dev->oper_freq = freq; 6194 6195 if (msg.capability) { 6196 /* 6197 * P2P Client Discoverability bit is reserved in all frames 6198 * that use this function, so do not change its value here. 6199 */ 6200 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 6201 dev->info.dev_capab |= msg.capability[0] & 6202 ~P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY; 6203 dev->info.group_capab = msg.capability[1]; 6204 } 6205 6206 if (msg.pcea_info && msg.pcea_info_len >= 2) 6207 p2p_process_pcea(p2p, &msg, dev); 6208 6209 if (msg.pbma_info && msg.pbma_info_len == 2) 6210 dev->info.pairing_config.bootstrap_methods = 6211 WPA_GET_LE16(msg.pbma_info); 6212 6213 if (!ether_addr_equal(peer_addr, p2p_dev_addr)) 6214 os_memcpy(dev->interface_addr, peer_addr, ETH_ALEN); 6215 6216 if (msg.dira && msg.dira_len) { 6217 dev->info.nonce_tag_valid = false; 6218 dev->info.dik_id = p2p_validate_dira(p2p, dev, msg.dira, 6219 msg.dira_len); 6220 if (dev->info.dik_id) { 6221 os_memcpy(dev->info.nonce, &msg.dira[1], 6222 DEVICE_IDENTITY_NONCE_LEN); 6223 os_memcpy(dev->info.tag, 6224 &msg.dira[1 + DEVICE_IDENTITY_NONCE_LEN], 6225 DEVICE_IDENTITY_TAG_LEN); 6226 dev->info.pairing_config.dik_cipher = msg.dira[0]; 6227 dev->info.nonce_tag_valid = true; 6228 } 6229 } 6230 6231 p2p_dbg(p2p, "Updated device entry based on USD frame: " MACSTR 6232 " dev_capab=0x%x group_capab=0x%x listen_freq=%d", 6233 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab, 6234 dev->info.group_capab, dev->listen_freq); 6235 6236 p2p->cfg->dev_found(p2p->cfg->cb_ctx, dev->info.p2p_device_addr, 6237 &dev->info, !(dev->flags & P2P_DEV_REPORTED_ONCE)); 6238 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE; 6239 6240 p2p_parse_free(&msg); 6241 } 6242 6243 p2p_get_dik_id(struct p2p_data * p2p,const u8 * peer)6244 int p2p_get_dik_id(struct p2p_data *p2p, const u8 *peer) 6245 { 6246 struct p2p_device *dev; 6247 6248 dev = p2p_get_device(p2p, peer); 6249 if (!dev) 6250 return 0; 6251 6252 return dev->info.dik_id; 6253 } 6254 6255 6256 #ifdef CONFIG_PASN 6257 p2p_config_sae_password(struct p2p_data * p2p,const char * pw)6258 int p2p_config_sae_password(struct p2p_data *p2p, const char *pw) 6259 { 6260 os_memset(p2p->dev_sae_password, 0, sizeof(p2p->dev_sae_password)); 6261 if (os_strlen(pw) >= sizeof(p2p->dev_sae_password)) 6262 return -1; 6263 6264 os_strlcpy(p2p->dev_sae_password, pw, sizeof(p2p->dev_sae_password)); 6265 return 0; 6266 } 6267 6268 p2p_prepare_pasn_extra_ie(struct p2p_data * p2p,struct wpabuf * extra_ies,const struct wpabuf * frame,bool add_dira)6269 static int p2p_prepare_pasn_extra_ie(struct p2p_data *p2p, 6270 struct wpabuf *extra_ies, 6271 const struct wpabuf *frame, bool add_dira) 6272 { 6273 struct wpabuf *buf, *buf2; 6274 size_t len; 6275 6276 len = 100; 6277 if (frame) 6278 len += wpabuf_len(frame); 6279 buf = wpabuf_alloc(len); 6280 if (!buf) 6281 return -1; 6282 6283 /* P2P Capability Extension attribute */ 6284 p2p_buf_add_pcea(buf, p2p); 6285 6286 if (add_dira) { 6287 /* Device Identity Resolution attribute */ 6288 p2p_buf_add_dira(buf, p2p); 6289 } 6290 6291 if (frame) { 6292 p2p_dbg(p2p, "Add Action frame wrapper for PASN"); 6293 wpabuf_put_u8(buf, P2P_ATTR_ACTION_FRAME_WRAPPER); 6294 wpabuf_put_le16(buf, wpabuf_len(frame)); 6295 wpabuf_put_buf(buf, frame); 6296 } 6297 6298 buf2 = p2p_encaps_ie(buf, P2P2_IE_VENDOR_TYPE); 6299 wpabuf_free(buf); 6300 6301 if (wpabuf_tailroom(extra_ies) < wpabuf_len(buf2)) { 6302 p2p_err(p2p, "Not enough room for P2P2 IE in PASN extra IEs"); 6303 wpabuf_free(buf2); 6304 return -1; 6305 } 6306 wpabuf_put_buf(extra_ies, buf2); 6307 wpabuf_free(buf2); 6308 6309 return 0; 6310 } 6311 6312 p2p_pasn_service_hash(struct p2p_data * p2p,struct wpabuf * extra_ies)6313 static struct wpabuf * p2p_pasn_service_hash(struct p2p_data *p2p, 6314 struct wpabuf *extra_ies) 6315 { 6316 struct wpabuf *buf; 6317 u8 *ie_len = NULL; 6318 6319 if (!p2p->usd_service) 6320 return extra_ies; 6321 6322 p2p_dbg(p2p, "Add P2P2 USD service hash in extra IE"); 6323 buf = wpabuf_alloc(100); 6324 if (!buf) { 6325 wpabuf_free(extra_ies); 6326 return NULL; 6327 } 6328 6329 ie_len = p2p_buf_add_ie_hdr(buf); 6330 p2p_buf_add_usd_service_hash(buf, p2p); 6331 p2p_buf_update_ie_hdr(buf, ie_len); 6332 6333 return wpabuf_concat(buf, extra_ies); 6334 } 6335 6336 p2p_pairing_generate_rsnxe(struct p2p_data * p2p,int akmp)6337 static struct wpabuf * p2p_pairing_generate_rsnxe(struct p2p_data *p2p, 6338 int akmp) 6339 { 6340 u32 capab; 6341 size_t flen = 0; 6342 struct wpabuf *buf; 6343 6344 capab = BIT(WLAN_RSNX_CAPAB_KEK_IN_PASN); 6345 6346 if (wpa_key_mgmt_sae(akmp)) 6347 capab |= BIT(WLAN_RSNX_CAPAB_SAE_H2E); 6348 6349 while (capab >> flen * 8) 6350 flen++; 6351 6352 buf = wpabuf_alloc(2 + flen); 6353 if (!buf) 6354 return NULL; 6355 6356 if (wpabuf_tailroom(buf) < 2 + flen) { 6357 p2p_dbg(p2p, "wpabuf tail room too small"); 6358 wpabuf_free(buf); 6359 return NULL; 6360 } 6361 capab |= flen - 1; /* bit 0-3 = Field length (n - 1) */ 6362 6363 p2p_dbg(p2p, "RSNXE capabilities: %04x", capab); 6364 wpabuf_put_u8(buf, WLAN_EID_RSNX); 6365 wpabuf_put_u8(buf, flen); 6366 while (flen--) { 6367 wpabuf_put_u8(buf, (capab & 0xff)); 6368 capab = capab >> 8; 6369 } 6370 return buf; 6371 } 6372 6373 6374 /* SSID used for deriving SAE pt for pairing */ 6375 #define P2P_PAIRING_SSID "516F9A020000" 6376 p2p_pairing_set_password(struct pasn_data * pasn,u8 pasn_type,const char * passphrase)6377 static void p2p_pairing_set_password(struct pasn_data *pasn, u8 pasn_type, 6378 const char *passphrase) 6379 { 6380 int pasn_groups[4] = { 0 }; 6381 size_t len; 6382 6383 if (!passphrase) 6384 return; 6385 6386 len = os_strlen(passphrase); 6387 6388 if (pasn_type & 0xc && pasn_type & 0x3) { 6389 pasn_groups[0] = 20; 6390 pasn_groups[1] = 19; 6391 } else if (pasn_type & 0xc) { 6392 pasn_groups[0] = 20; 6393 } else { 6394 pasn_groups[0] = 19; 6395 } 6396 pasn->pt = sae_derive_pt(pasn_groups, (const u8 *) P2P_PAIRING_SSID, 6397 os_strlen(P2P_PAIRING_SSID), 6398 (const u8 *) passphrase, len, NULL); 6399 /* Set passphrase for pairing responder to validate PASN auth 1 frame */ 6400 pasn->password = passphrase; 6401 } 6402 6403 p2p_pasn_initialize(struct p2p_data * p2p,struct p2p_device * dev,const u8 * addr,int freq,bool verify,bool derive_kek)6404 void p2p_pasn_initialize(struct p2p_data *p2p, struct p2p_device *dev, 6405 const u8 *addr, int freq, bool verify, bool derive_kek) 6406 { 6407 struct pasn_data *pasn; 6408 struct wpabuf *rsnxe; 6409 6410 if (!p2p || !dev) 6411 return; 6412 6413 if (dev->pasn) { 6414 wpa_pasn_reset(dev->pasn); 6415 } else { 6416 dev->pasn = pasn_data_init(); 6417 if (!dev->pasn) 6418 return; 6419 } 6420 6421 pasn = dev->pasn; 6422 6423 os_memcpy(pasn->own_addr, p2p->cfg->dev_addr, ETH_ALEN); 6424 os_memcpy(pasn->peer_addr, addr, ETH_ALEN); 6425 6426 os_memcpy(pasn->bssid, dev->role == P2P_ROLE_PAIRING_INITIATOR ? 6427 pasn->peer_addr : pasn->own_addr, ETH_ALEN); 6428 6429 pasn->noauth = 1; 6430 6431 if ((p2p->cfg->pairing_config.pasn_type & 0xc) && 6432 (dev->info.pairing_config.pasn_type & 0xc)) { 6433 pasn->group = 20; 6434 pasn->cipher = WPA_CIPHER_GCMP_256; 6435 pasn->kek_len = 32; 6436 pasn->derive_kek = true; 6437 } else { 6438 pasn->group = 19; 6439 pasn->cipher = WPA_CIPHER_CCMP; 6440 pasn->kek_len = 16; 6441 pasn->derive_kek = true; 6442 } 6443 6444 if (!derive_kek) { 6445 pasn->derive_kek = false; 6446 pasn->kek_len = 0; 6447 } 6448 6449 if (dev->password[0]) { 6450 pasn->akmp = WPA_KEY_MGMT_SAE; 6451 p2p_pairing_set_password(pasn, 6452 p2p->cfg->pairing_config.pasn_type, 6453 dev->password); 6454 } else if (verify) { 6455 pasn->akmp = WPA_KEY_MGMT_SAE; 6456 } else { 6457 pasn->akmp = WPA_KEY_MGMT_PASN; 6458 } 6459 6460 pasn->rsn_pairwise = pasn->cipher; 6461 pasn->wpa_key_mgmt = pasn->akmp; 6462 6463 rsnxe = p2p_pairing_generate_rsnxe(p2p, pasn->akmp); 6464 if (rsnxe) { 6465 os_free(pasn->rsnxe_ie); 6466 pasn->rsnxe_ie = os_memdup(wpabuf_head_u8(rsnxe), 6467 wpabuf_len(rsnxe)); 6468 if (!pasn->rsnxe_ie) { 6469 wpabuf_free(rsnxe); 6470 return; 6471 } 6472 wpabuf_free(rsnxe); 6473 } 6474 6475 if (dev->role == P2P_ROLE_PAIRING_INITIATOR) 6476 pasn->pmksa = p2p->initiator_pmksa; 6477 else 6478 pasn->pmksa = p2p->responder_pmksa; 6479 6480 pasn->cb_ctx = p2p->cfg->cb_ctx; 6481 pasn->send_mgmt = p2p->cfg->pasn_send_mgmt; 6482 pasn->prepare_data_element = p2p->cfg->prepare_data_element; 6483 pasn->parse_data_element = p2p->cfg->parse_data_element; 6484 pasn->validate_custom_pmkid = p2p->cfg->pasn_validate_pmkid; 6485 6486 pasn->freq = freq; 6487 } 6488 6489 p2p_get_listen_freq(struct p2p_data * p2p,const u8 * peer_addr)6490 int p2p_get_listen_freq(struct p2p_data *p2p, const u8 *peer_addr) 6491 { 6492 int freq; 6493 struct p2p_device *dev; 6494 6495 if (!peer_addr) { 6496 p2p_dbg(p2p, "Peer address NULL"); 6497 return -1; 6498 } 6499 6500 dev = p2p_get_device(p2p, peer_addr); 6501 if (!dev) { 6502 p2p_dbg(p2p, "Peer not known"); 6503 return -1; 6504 } 6505 6506 freq = dev->listen_freq > 0 ? dev->listen_freq : dev->oper_freq; 6507 if (freq <= 0) 6508 freq = dev->oob_go_neg_freq; 6509 if (freq <= 0) { 6510 p2p_dbg(p2p, "No listen/operating frequency known for the peer " 6511 MACSTR, MAC2STR(dev->info.p2p_device_addr)); 6512 return -1; 6513 } 6514 return freq; 6515 } 6516 6517 p2p_initiate_pasn_verify(struct p2p_data * p2p,const u8 * peer_addr,int freq,enum p2p_invite_role role,const u8 * bssid,const u8 * ssid,size_t ssid_len,unsigned int force_freq,const u8 * go_dev_addr,unsigned int pref_freq)6518 int p2p_initiate_pasn_verify(struct p2p_data *p2p, const u8 *peer_addr, 6519 int freq, enum p2p_invite_role role, 6520 const u8 *bssid, const u8 *ssid, size_t ssid_len, 6521 unsigned int force_freq, const u8 *go_dev_addr, 6522 unsigned int pref_freq) 6523 { 6524 struct pasn_data *pasn; 6525 struct p2p_device *dev; 6526 struct wpabuf *extra_ies, *req; 6527 int ret = 0; 6528 u8 *pasn_extra_ies = NULL; 6529 u8 pmkid[PMKID_LEN]; 6530 6531 if (!peer_addr) { 6532 p2p_dbg(p2p, "Peer address NULL"); 6533 return -1; 6534 } 6535 6536 dev = p2p_get_device(p2p, peer_addr); 6537 if (!dev) { 6538 p2p_dbg(p2p, "Peer not known"); 6539 return -1; 6540 } 6541 6542 if (p2p_invite(p2p, peer_addr, role, bssid, ssid, ssid_len, force_freq, 6543 go_dev_addr, 1, pref_freq, -1, 1)) { 6544 p2p_dbg(p2p, "p2p_invite() failed"); 6545 return -1; 6546 } 6547 6548 dev->role = P2P_ROLE_PAIRING_INITIATOR; 6549 p2p_pasn_initialize(p2p, dev, peer_addr, freq, true, true); 6550 pasn = dev->pasn; 6551 6552 req = p2p_build_invitation_req(p2p, dev, go_dev_addr, -1); 6553 if (!req) 6554 return -1; 6555 6556 p2p_set_state(p2p, P2P_INVITE); 6557 p2p->pending_action_state = P2P_PENDING_INVITATION_REQUEST; 6558 p2p->invite_peer = dev; 6559 dev->invitation_reqs++; 6560 6561 extra_ies = wpabuf_alloc(1500); 6562 if (!extra_ies) { 6563 wpabuf_free(req); 6564 p2p_dbg(p2p, "Memory allocation failed for extra_ies"); 6565 return -1; 6566 } 6567 6568 if (os_get_random(pmkid, PMKID_LEN) < 0) { 6569 wpabuf_free(req); 6570 wpabuf_free(extra_ies); 6571 return -1; 6572 } 6573 wpa_hexdump(MSG_DEBUG, 6574 "P2P2: Use new random PMKID for pairing verification", 6575 pmkid, PMKID_LEN); 6576 pasn_set_custom_pmkid(pasn, pmkid); 6577 6578 if (p2p_prepare_pasn_extra_ie(p2p, extra_ies, req, true)) { 6579 p2p_dbg(p2p, "Prepare PASN extra IEs failed"); 6580 ret = -1; 6581 goto out; 6582 } 6583 6584 extra_ies = p2p_pasn_service_hash(p2p, extra_ies); 6585 if (!extra_ies) 6586 goto out; 6587 6588 pasn_extra_ies = os_memdup(wpabuf_head_u8(extra_ies), 6589 wpabuf_len(extra_ies)); 6590 if (!pasn_extra_ies) { 6591 p2p_dbg(p2p, "Memory allocation failed for PASN extra IEs"); 6592 ret = -1; 6593 goto out; 6594 } 6595 6596 pasn->extra_ies = pasn_extra_ies; 6597 pasn->extra_ies_len = wpabuf_len(extra_ies); 6598 6599 /* Start PASN verify */ 6600 if (wpa_pasn_verify(pasn, pasn->own_addr, pasn->peer_addr, pasn->bssid, 6601 pasn->akmp, pasn->cipher, pasn->group, pasn->freq, 6602 NULL, 0, NULL, 0, NULL)) { 6603 p2p_dbg(p2p, "PASN verify failed"); 6604 ret = -1; 6605 } else { 6606 dev->flags |= P2P_DEV_WAIT_INV_REQ_ACK; 6607 } 6608 out: 6609 pasn->extra_ies = NULL; 6610 pasn->extra_ies_len = 0; 6611 os_free(pasn_extra_ies); 6612 wpabuf_free(req); 6613 wpabuf_free(extra_ies); 6614 return ret; 6615 } 6616 6617 p2p_initiate_pasn_auth(struct p2p_data * p2p,const u8 * addr,int freq)6618 int p2p_initiate_pasn_auth(struct p2p_data *p2p, const u8 *addr, int freq) 6619 { 6620 struct pasn_data *pasn; 6621 struct p2p_device *dev; 6622 struct wpabuf *extra_ies, *req; 6623 u8 *ies = NULL; 6624 int ret = 0; 6625 size_t ies_len; 6626 6627 if (!addr) { 6628 p2p_dbg(p2p, "Peer address NULL"); 6629 return -1; 6630 } 6631 6632 dev = p2p_get_device(p2p, addr); 6633 if (!dev) { 6634 p2p_dbg(p2p, "Peer not known"); 6635 return -1; 6636 } 6637 6638 if (freq == 0) 6639 freq = dev->listen_freq > 0 ? dev->listen_freq : dev->oper_freq; 6640 6641 dev->role = P2P_ROLE_PAIRING_INITIATOR; 6642 p2p_pasn_initialize(p2p, dev, addr, freq, false, true); 6643 pasn = dev->pasn; 6644 6645 pasn_initiator_pmksa_cache_remove(pasn->pmksa, (u8 *)addr); 6646 6647 req = p2p_build_go_neg_req(p2p, dev); 6648 if (!req) 6649 return -1; 6650 6651 p2p->go_neg_peer = dev; 6652 dev->flags |= P2P_DEV_WAIT_GO_NEG_RESPONSE; 6653 6654 extra_ies = wpabuf_alloc(1500); 6655 if (!extra_ies) { 6656 wpabuf_free(req); 6657 return -1; 6658 } 6659 6660 if (p2p_prepare_pasn_extra_ie(p2p, extra_ies, req, false)) { 6661 p2p_dbg(p2p, "Failed to prepare PASN extra elements"); 6662 ret = -1; 6663 goto out; 6664 } 6665 6666 extra_ies = p2p_pasn_service_hash(p2p, extra_ies); 6667 if (!extra_ies) 6668 goto out; 6669 6670 ies_len = wpabuf_len(extra_ies); 6671 ies = os_memdup(wpabuf_head_u8(extra_ies), ies_len); 6672 if (!ies) { 6673 ret = -1; 6674 goto out; 6675 } 6676 6677 pasn->extra_ies = ies; 6678 pasn->extra_ies_len = ies_len; 6679 6680 /* Start PASN authentication */ 6681 if (wpas_pasn_start(pasn, pasn->own_addr, pasn->peer_addr, pasn->bssid, 6682 pasn->akmp, pasn->cipher, pasn->group, pasn->freq, 6683 NULL, 0, NULL, 0, NULL)) { 6684 p2p_dbg(p2p, "Failed to start PASN"); 6685 ret = -1; 6686 } 6687 out: 6688 os_free(ies); 6689 pasn->extra_ies = NULL; 6690 pasn->extra_ies_len = 0; 6691 wpabuf_free(req); 6692 wpabuf_free(extra_ies); 6693 return ret; 6694 } 6695 6696 p2p_pasn_handle_action_wrapper(struct p2p_data * p2p,struct p2p_device * dev,const struct ieee80211_mgmt * mgmt,size_t len,int freq,int trans_seq)6697 static int p2p_pasn_handle_action_wrapper(struct p2p_data *p2p, 6698 struct p2p_device *dev, 6699 const struct ieee80211_mgmt *mgmt, 6700 size_t len, int freq, int trans_seq) 6701 { 6702 const u8 *ies; 6703 size_t ies_len; 6704 size_t data_len = 0; 6705 bool derive_kek; 6706 const u8 *data = NULL; 6707 struct p2p_message msg; 6708 struct ieee802_11_elems elems; 6709 6710 ies = mgmt->u.auth.variable; 6711 ies_len = len - offsetof(struct ieee80211_mgmt, u.auth.variable); 6712 6713 os_memset(&msg, 0, sizeof(msg)); 6714 if (p2p_parse_ies(ies, ies_len, &msg)) { 6715 p2p_dbg(p2p, 6716 "Failed to parse P2P IE from PASN Authentication frame"); 6717 p2p_parse_free(&msg); 6718 return -1; 6719 } 6720 6721 if (msg.action_frame_wrapper && msg.action_frame_wrapper_len) { 6722 data = msg.action_frame_wrapper; 6723 data_len = msg.action_frame_wrapper_len; 6724 if (data_len >= 2 && 6725 data[0] == WLAN_ACTION_PUBLIC && 6726 data[1] == WLAN_PA_VENDOR_SPECIFIC) { 6727 data += 2; 6728 data_len -= 2; 6729 if (data_len < 4 || 6730 WPA_GET_BE32(data) != P2P_IE_VENDOR_TYPE) { 6731 p2p_parse_free(&msg); 6732 return -1; 6733 } 6734 data += 4; 6735 data_len -= 4; 6736 } else { 6737 p2p_dbg(p2p, 6738 "Invalid category in Action frame wrapper in Authentication frame seq %d", 6739 trans_seq); 6740 p2p_parse_free(&msg); 6741 return -1; 6742 } 6743 } 6744 6745 if (trans_seq == 1) { 6746 if (ieee802_11_parse_elems(mgmt->u.auth.variable, 6747 len - offsetof(struct ieee80211_mgmt, 6748 u.auth.variable), 6749 &elems, 0) == ParseFailed) { 6750 wpa_printf(MSG_DEBUG, 6751 "PASN: Failed parsing Authentication frame"); 6752 return -1; 6753 } 6754 derive_kek = ieee802_11_rsnx_capab_len( 6755 elems.rsnxe, elems.rsnxe_len, 6756 WLAN_RSNX_CAPAB_KEK_IN_PASN); 6757 if (data && data_len >= 1 && data[0] == P2P_INVITATION_REQ) { 6758 struct wpabuf *resp; 6759 6760 resp = p2p_process_invitation_req(p2p, mgmt->sa, 6761 data + 1, 6762 data_len - 1, freq, 6763 true); 6764 if (!resp) 6765 p2p_dbg(p2p, "No Invitation Response found"); 6766 6767 dev->role = P2P_ROLE_PAIRING_RESPONDER; 6768 p2p_pasn_initialize(p2p, dev, mgmt->sa, freq, true, 6769 derive_kek); 6770 wpabuf_free(dev->action_frame_wrapper); 6771 dev->action_frame_wrapper = resp; 6772 if (msg.dira && msg.dira_len && 6773 p2p_validate_dira(p2p, dev, msg.dira, 6774 msg.dira_len)) { 6775 struct wpa_ie_data rsn_data; 6776 6777 if (wpa_parse_wpa_ie_rsn(elems.rsn_ie - 2, 6778 elems.rsn_ie_len + 2, 6779 &rsn_data) == 0 && 6780 rsn_data.num_pmkid) 6781 pasn_set_custom_pmkid(dev->pasn, 6782 rsn_data.pmkid); 6783 } 6784 } else if (data && data_len >= 1 && data[0] == P2P_GO_NEG_REQ) { 6785 struct wpabuf *resp; 6786 6787 if (!derive_kek) { 6788 p2p_dbg(p2p, "KEK-in-PASN not set in RSNXE"); 6789 return -1; 6790 } 6791 resp = p2p_process_go_neg_req(p2p, mgmt->sa, data + 1, 6792 data_len - 1, freq, true); 6793 if (!resp) 6794 p2p_dbg(p2p, 6795 "No GO Negotiation Response found"); 6796 wpabuf_free(dev->action_frame_wrapper); 6797 dev->action_frame_wrapper = resp; 6798 } else { 6799 p2p_dbg(p2p, "Invalid action frame wrapper in Auth1"); 6800 } 6801 } else if (trans_seq == 2) { 6802 if (data && data_len >= 1 && data[0] == P2P_INVITATION_RESP) { 6803 p2p_process_invitation_resp(p2p, mgmt->sa, data + 1, 6804 data_len - 1); 6805 wpabuf_free(dev->action_frame_wrapper); 6806 dev->action_frame_wrapper = NULL; 6807 } else if (data && data_len >= 1 && 6808 data[0] == P2P_GO_NEG_RESP) { 6809 struct wpabuf *conf; 6810 6811 conf = p2p_process_go_neg_resp(p2p, mgmt->sa, data + 1, 6812 data_len - 1, freq, 6813 true); 6814 if (!conf) 6815 p2p_dbg(p2p, "No GO Negotiation Confirm found"); 6816 wpabuf_free(dev->action_frame_wrapper); 6817 dev->action_frame_wrapper = conf; 6818 } else { 6819 p2p_dbg(p2p, "Invalid action frame wrapper in Auth2"); 6820 } 6821 } else if (trans_seq == 3) { 6822 if (data && data_len >= 1 && data[0] == P2P_GO_NEG_CONF) 6823 p2p_handle_go_neg_conf(p2p, mgmt->sa, data + 1, 6824 data_len - 1, true); 6825 else 6826 p2p_invitation_resp_cb(p2p, mgmt->sa, 6827 P2P_SEND_ACTION_SUCCESS); 6828 } 6829 p2p_parse_free(&msg); 6830 return 0; 6831 } 6832 6833 p2p_pasn_add_encrypted_data(struct p2p_data * p2p,struct p2p_device * dev,struct wpabuf * buf)6834 static int p2p_pasn_add_encrypted_data(struct p2p_data *p2p, 6835 struct p2p_device *dev, 6836 struct wpabuf *buf) 6837 { 6838 struct pasn_data *pasn; 6839 struct wpabuf *p2p2_ie; 6840 u8 *dika_len, *p2p2_ie_len; 6841 int ret; 6842 6843 if (!p2p || !dev || !dev->pasn) 6844 return 0; 6845 6846 pasn = dev->pasn; 6847 6848 if (dev->req_bootstrap_method != P2P_PBMA_OPPORTUNISTIC && 6849 !p2p->pairing_info->enable_pairing_cache) 6850 return 0; 6851 6852 p2p2_ie = wpabuf_alloc(100); 6853 if (!p2p2_ie) 6854 return -1; 6855 6856 p2p2_ie_len = p2p_buf_add_p2p2_ie_hdr(p2p2_ie); 6857 6858 if (p2p->pairing_info->enable_pairing_cache) { 6859 wpabuf_put_u8(p2p2_ie, P2P_ATTR_DEVICE_IDENTITY_KEY); 6860 dika_len = wpabuf_put(p2p2_ie, 2); 6861 6862 wpabuf_put_u8(p2p2_ie, 6863 p2p->pairing_info->dev_ik.cipher_version); 6864 wpabuf_put_data(p2p2_ie, p2p->pairing_info->dev_ik.dik_data, 6865 p2p->pairing_info->dev_ik.dik_len); 6866 wpabuf_put_be32(p2p2_ie, p2p->pairing_info->dev_ik.expiration); 6867 6868 WPA_PUT_LE16(dika_len, 6869 (u8 *) wpabuf_put(p2p2_ie, 0) - dika_len - 2); 6870 } 6871 6872 if (dev->req_bootstrap_method == P2P_PBMA_OPPORTUNISTIC) { 6873 if (!p2p->dev_sae_password[0]) { 6874 int password_len; 6875 6876 /* SAE password is not available as the request is not 6877 * for an existing GO. Pick a random SAE password of 6878 * length between 10 and 20. */ 6879 password_len = 10 + os_random() % 10; 6880 if (p2p_random(p2p->dev_sae_password, 6881 password_len) < 0) { 6882 wpabuf_free(p2p2_ie); 6883 return -1; 6884 } 6885 p2p->dev_sae_password[password_len] = '\0'; 6886 } 6887 6888 wpabuf_put_u8(p2p2_ie, P2P_ATTR_PASSWORD); 6889 wpabuf_put_le16(p2p2_ie, os_strlen(p2p->dev_sae_password)); 6890 wpabuf_put_str(p2p2_ie, p2p->dev_sae_password); 6891 } 6892 6893 p2p_buf_update_ie_hdr(p2p2_ie, p2p2_ie_len); 6894 6895 ret = pasn_add_encrypted_data(pasn, buf, wpabuf_mhead_u8(p2p2_ie), 6896 wpabuf_len(p2p2_ie)); 6897 wpabuf_free(p2p2_ie); 6898 return ret; 6899 } 6900 6901 p2p_prepare_data_element(struct p2p_data * p2p,const u8 * peer_addr)6902 int p2p_prepare_data_element(struct p2p_data *p2p, const u8 *peer_addr) 6903 { 6904 int ret = -1; 6905 struct p2p_device *dev; 6906 struct pasn_data *pasn; 6907 struct wpabuf *extra_ies; 6908 6909 if (!p2p) 6910 return -1; 6911 6912 dev = p2p_get_device(p2p, peer_addr); 6913 if (!dev || !dev->pasn) { 6914 p2p_dbg(p2p, "PASN: Peer not found " MACSTR, 6915 MAC2STR(peer_addr)); 6916 return -1; 6917 } 6918 pasn = dev->pasn; 6919 6920 extra_ies = wpabuf_alloc(1500); 6921 if (!extra_ies || 6922 p2p_prepare_pasn_extra_ie(p2p, extra_ies, 6923 dev->action_frame_wrapper, false)) { 6924 p2p_dbg(p2p, "Failed to prepare PASN extra elements"); 6925 goto out; 6926 } 6927 6928 if (p2p_pasn_add_encrypted_data(p2p, dev, extra_ies) < 0) 6929 p2p_dbg(p2p, "Failed to add PASN encrypted elements"); 6930 6931 pasn->extra_ies = os_memdup(wpabuf_head_u8(extra_ies), 6932 wpabuf_len(extra_ies)); 6933 if (!pasn->extra_ies) 6934 goto out; 6935 pasn->extra_ies_len = wpabuf_len(extra_ies); 6936 ret = 0; 6937 6938 out: 6939 wpabuf_free(extra_ies); 6940 wpabuf_free(dev->action_frame_wrapper); 6941 dev->action_frame_wrapper = NULL; 6942 6943 return ret; 6944 } 6945 6946 p2p_parse_data_element(struct p2p_data * p2p,const u8 * data,size_t len)6947 int p2p_parse_data_element(struct p2p_data *p2p, const u8 *data, size_t len) 6948 { 6949 u8 attr_id; 6950 const u8 *pos, *next; 6951 u16 rem_len, attr_len; 6952 6953 if (!p2p || !data || !len) 6954 return -1; 6955 6956 pos = data; 6957 rem_len = len; 6958 6959 if (rem_len < 6 || 6960 pos[0] != WLAN_EID_VENDOR_SPECIFIC || 6961 pos[1] < 4 || 6962 rem_len < 2 + pos[1] || 6963 WPA_GET_BE32(&pos[2]) != P2P2_IE_VENDOR_TYPE) { 6964 p2p_dbg(p2p, 6965 "P2P: P2P2 IE not present in PASN Encrypted Data element"); 6966 return -1; 6967 } 6968 6969 pos += 6; 6970 rem_len -= 6; 6971 6972 while (rem_len >= 3) { 6973 attr_id = *pos++; 6974 attr_len = WPA_GET_LE16(pos); 6975 pos += 2; 6976 rem_len -= 3; 6977 if (rem_len < attr_len) 6978 return -1; 6979 next = pos + attr_len; 6980 rem_len -= attr_len; 6981 6982 switch (attr_id) { 6983 case P2P_ATTR_DEVICE_IDENTITY_KEY: 6984 if (attr_len < 1) { 6985 p2p_dbg(p2p, 6986 "Too short Device Identity Key attribute"); 6987 return -1; 6988 } 6989 p2p->dik_cipher_version = *pos++; 6990 attr_len--; 6991 if (p2p->dik_cipher_version == 6992 DIRA_CIPHER_VERSION_128) { 6993 if (attr_len < DEVICE_IDENTITY_KEY_LEN) { 6994 p2p_dbg(p2p, "Too short DevIK"); 6995 return -1; 6996 } 6997 os_memcpy(p2p->peer_dik_data, pos, 6998 DEVICE_IDENTITY_KEY_LEN); 6999 p2p->peer_dik_len = DEVICE_IDENTITY_KEY_LEN; 7000 pos += DEVICE_IDENTITY_KEY_LEN; 7001 attr_len -= DEVICE_IDENTITY_KEY_LEN; 7002 } else { 7003 p2p_dbg(p2p, 7004 "Unsupported cipher version %u in Device Identity Key attribute", 7005 p2p->dik_cipher_version); 7006 return -1; 7007 } 7008 if (attr_len < 4) { 7009 p2p_dbg(p2p, 7010 "Not enough room for DevIK lifetime"); 7011 return -1; 7012 } 7013 p2p->peer_dik_lifetime = WPA_GET_BE32(pos); 7014 p2p_dbg(p2p, 7015 "Received peer DevIK of length %zu octets and lifetime %u", 7016 p2p->peer_dik_len, p2p->peer_dik_lifetime); 7017 break; 7018 case P2P_ATTR_PASSWORD: 7019 if (attr_len < 1 || 7020 attr_len > sizeof(p2p->peer_sae_password) - 1) { 7021 p2p_dbg(p2p, 7022 "P2P: Invalid password length %d", 7023 attr_len); 7024 return -1; 7025 } 7026 os_memset(p2p->peer_sae_password, 0, 7027 sizeof(p2p->peer_sae_password)); 7028 os_memcpy(p2p->peer_sae_password, pos, attr_len); 7029 break; 7030 default: 7031 p2p_dbg(p2p, 7032 "Unsupported Attribute ID %u in P2P2 IE in PASN Encrypted Data element", 7033 attr_id); 7034 break; 7035 } 7036 pos = next; 7037 } 7038 7039 return 0; 7040 } 7041 7042 p2p_validate_custom_pmkid(struct p2p_data * p2p,struct p2p_device * dev,const u8 * pmkid)7043 static int p2p_validate_custom_pmkid(struct p2p_data *p2p, 7044 struct p2p_device *dev, const u8 *pmkid) 7045 { 7046 if (dev->pasn->custom_pmkid_valid && 7047 os_memcmp(dev->pasn->custom_pmkid, pmkid, PMKID_LEN) == 0) { 7048 p2p_dbg(p2p, "Customized PMKID valid"); 7049 return 0; 7050 } 7051 return -1; 7052 } 7053 7054 p2p_pasn_pmksa_get_pmk(struct p2p_data * p2p,const u8 * addr,u8 * pmkid,u8 * pmk,size_t * pmk_len)7055 static int p2p_pasn_pmksa_get_pmk(struct p2p_data *p2p, const u8 *addr, 7056 u8 *pmkid, u8 *pmk, size_t *pmk_len) 7057 { 7058 struct p2p_device *dev; 7059 7060 dev = p2p_get_device(p2p, addr); 7061 if (!dev) { 7062 p2p_dbg(p2p, "PASN: Peer not found " MACSTR, MAC2STR(addr)); 7063 return -1; 7064 } 7065 7066 if (dev->role == P2P_ROLE_PAIRING_INITIATOR) 7067 return pasn_initiator_pmksa_cache_get(p2p->initiator_pmksa, 7068 addr, pmkid, pmk, 7069 pmk_len); 7070 else 7071 return pasn_responder_pmksa_cache_get(p2p->responder_pmksa, 7072 addr, pmkid, pmk, 7073 pmk_len); 7074 } 7075 7076 p2p_pasn_validate_and_update_pmkid(struct p2p_data * p2p,const u8 * addr,const u8 * rsn_pmkid)7077 int p2p_pasn_validate_and_update_pmkid(struct p2p_data *p2p, const u8 *addr, 7078 const u8 *rsn_pmkid) 7079 { 7080 size_t pmk_len; 7081 u8 pmkid[PMKID_LEN]; 7082 u8 pmk[PMK_LEN_MAX]; 7083 struct p2p_device *dev; 7084 7085 if (!p2p) 7086 return -1; 7087 7088 dev = p2p_get_device(p2p, addr); 7089 if (!dev || !dev->pasn) { 7090 p2p_dbg(p2p, "P2P PASN: Peer not found " MACSTR, 7091 MAC2STR(addr)); 7092 return -1; 7093 } 7094 7095 if (p2p_validate_custom_pmkid(p2p, dev, rsn_pmkid)) 7096 return -1; 7097 7098 if (p2p_pasn_pmksa_get_pmk(p2p, addr, pmkid, pmk, &pmk_len)) { 7099 p2p_dbg(p2p, "P2P PASN: Failed to get PMK from cache"); 7100 return -1; 7101 } 7102 7103 p2p_pasn_pmksa_set_pmk(p2p, p2p->cfg->dev_addr, addr, pmk, pmk_len, 7104 rsn_pmkid); 7105 return 0; 7106 } 7107 7108 p2p_pasn_auth_tx_status(struct p2p_data * p2p,const u8 * data,size_t data_len,bool acked,bool verify)7109 int p2p_pasn_auth_tx_status(struct p2p_data *p2p, const u8 *data, 7110 size_t data_len, bool acked, bool verify) 7111 { 7112 int ret = 0; 7113 struct p2p_device *dev; 7114 struct pasn_data *pasn; 7115 const struct ieee80211_mgmt *mgmt = 7116 (const struct ieee80211_mgmt *) data; 7117 7118 if (!p2p) 7119 return -1; 7120 7121 dev = p2p_get_device(p2p, mgmt->da); 7122 if (!dev || !dev->pasn) { 7123 p2p_dbg(p2p, "P2P PASN: Peer not found " MACSTR, 7124 MAC2STR(mgmt->da)); 7125 return -1; 7126 } 7127 7128 pasn = dev->pasn; 7129 7130 ret = wpa_pasn_auth_tx_status(pasn, data, data_len, acked); 7131 if (ret != 1 && !acked && pasn->frame) 7132 return pasn->send_mgmt(pasn->cb_ctx, wpabuf_head(pasn->frame), 7133 wpabuf_len(pasn->frame), 0, pasn->freq, 7134 1000); 7135 7136 wpabuf_free(pasn->frame); 7137 pasn->frame = NULL; 7138 7139 if (ret != 1) 7140 return ret; 7141 7142 if (verify && dev == p2p->invite_peer) 7143 p2p_start_invitation_connect(p2p, dev); 7144 else if (dev == p2p->go_neg_peer) 7145 p2p_go_complete(p2p, dev); 7146 7147 return 0; 7148 } 7149 7150 p2p_handle_pasn_auth(struct p2p_data * p2p,struct p2p_device * dev,const struct ieee80211_mgmt * mgmt,size_t len,int freq)7151 static int p2p_handle_pasn_auth(struct p2p_data *p2p, struct p2p_device *dev, 7152 const struct ieee80211_mgmt *mgmt, size_t len, 7153 int freq) 7154 { 7155 struct pasn_data *pasn; 7156 u8 pasn_type; 7157 int pasn_groups[4] = { 0 }; 7158 u16 auth_alg, auth_transaction, status_code; 7159 7160 if (!p2p || !dev || !dev->pasn) 7161 return -1; 7162 7163 if (os_memcmp(mgmt->da, p2p->cfg->dev_addr, ETH_ALEN) != 0) { 7164 p2p_dbg(p2p, "PASN Responder: Not our frame"); 7165 return -1; 7166 } 7167 7168 if (len < offsetof(struct ieee80211_mgmt, u.auth.variable)) 7169 return -1; 7170 7171 pasn = dev->pasn; 7172 auth_alg = le_to_host16(mgmt->u.auth.auth_alg); 7173 status_code = le_to_host16(mgmt->u.auth.status_code); 7174 7175 auth_transaction = le_to_host16(mgmt->u.auth.auth_transaction); 7176 7177 if (status_code != WLAN_STATUS_SUCCESS && 7178 status_code != WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY) { 7179 p2p_dbg(p2p, "PASN: Authentication rejected - status=%u", 7180 status_code); 7181 return -1; 7182 } 7183 7184 if (auth_alg != WLAN_AUTH_PASN || auth_transaction == 2) { 7185 p2p_dbg(p2p, 7186 "PASN Responder: Not a PASN frame or unexpected Authentication frame, auth_alg=%d", 7187 auth_alg); 7188 return -1; 7189 } 7190 if (auth_transaction == 1) { 7191 pasn_type = p2p->cfg->pairing_config.pasn_type; 7192 if (pasn_type & 0xc && pasn_type & 0x3) { 7193 pasn_groups[0] = 20; 7194 pasn_groups[1] = 19; 7195 } else if (pasn_type & 0xc) { 7196 pasn_groups[0] = 20; 7197 } else { 7198 pasn_groups[0] = 19; 7199 } 7200 pasn->pasn_groups = pasn_groups; 7201 7202 if (p2p_pasn_handle_action_wrapper(p2p, dev, mgmt, len, freq, 7203 auth_transaction)) { 7204 p2p_dbg(p2p, 7205 "PASN Responder: Handle Auth 1 action wrapper failed"); 7206 return -1; 7207 } 7208 if (handle_auth_pasn_1(pasn, p2p->cfg->dev_addr, mgmt->sa, mgmt, 7209 len, false) < 0) { 7210 p2p_dbg(p2p, 7211 "PASN Responder: Handle Auth 1 failed"); 7212 return -1; 7213 } 7214 } else if (auth_transaction == 3) { 7215 if (handle_auth_pasn_3(pasn, p2p->cfg->dev_addr, mgmt->sa, mgmt, 7216 len) < 0) { 7217 p2p_dbg(p2p, 7218 "PASN Responder: Handle Auth 3 failed"); 7219 return -1; 7220 } 7221 #ifdef CONFIG_TESTING_OPTIONS 7222 p2p_pasn_store_ptk(p2p, &pasn->ptk); 7223 #endif /* CONFIG_TESTING_OPTIONS */ 7224 if (p2p_pasn_handle_action_wrapper(p2p, dev, mgmt, len, freq, 7225 auth_transaction)) { 7226 p2p_dbg(p2p, 7227 "PASN Responder: Handle Auth 3 action wrapper failed"); 7228 /* Drop keying material from a failed pairing attempt */ 7229 os_memset(p2p->peer_dik_data, 0, 7230 sizeof(p2p->peer_dik_data)); 7231 os_memset(p2p->peer_sae_password, 0, 7232 sizeof(p2p->peer_sae_password)); 7233 return -1; 7234 } 7235 forced_memzero(pasn_get_ptk(pasn), sizeof(pasn->ptk)); 7236 } 7237 return 0; 7238 } 7239 7240 p2p_pasn_auth_rx(struct p2p_data * p2p,const struct ieee80211_mgmt * mgmt,size_t len,int freq)7241 int p2p_pasn_auth_rx(struct p2p_data *p2p, const struct ieee80211_mgmt *mgmt, 7242 size_t len, int freq) 7243 { 7244 int ret = 0; 7245 u8 auth_transaction; 7246 struct p2p_device *dev; 7247 struct pasn_data *pasn; 7248 struct wpa_pasn_params_data pasn_data; 7249 7250 dev = p2p_get_device(p2p, mgmt->sa); 7251 if (!dev) { 7252 p2p_dbg(p2p, "PASN: Peer not found " MACSTR, 7253 MAC2STR(mgmt->sa)); 7254 return -1; 7255 } 7256 7257 if (!dev->pasn) { 7258 p2p_dbg(p2p, "PASN: Uninitialized"); 7259 return -1; 7260 } 7261 7262 pasn = dev->pasn; 7263 7264 wpabuf_free(pasn->frame); 7265 pasn->frame = NULL; 7266 7267 pasn_register_callbacks(pasn, p2p->cfg->cb_ctx, 7268 p2p->cfg->pasn_send_mgmt, 7269 p2p->cfg->pasn_validate_pmkid); 7270 auth_transaction = le_to_host16(mgmt->u.auth.auth_transaction); 7271 7272 if (dev->role == P2P_ROLE_PAIRING_INITIATOR && auth_transaction == 2) { 7273 if (p2p_pasn_handle_action_wrapper(p2p, dev, mgmt, len, freq, 7274 auth_transaction)) { 7275 p2p_dbg(p2p, 7276 "PASN Initiator: Handle Auth 2 action wrapper failed"); 7277 return -1; 7278 } 7279 ret = wpa_pasn_auth_rx(pasn, (const u8 *) mgmt, len, 7280 &pasn_data); 7281 if (ret < 0) { 7282 p2p_dbg(p2p, "PASN: wpa_pasn_auth_rx() failed"); 7283 dev->role = P2P_ROLE_IDLE; 7284 } 7285 #ifdef CONFIG_TESTING_OPTIONS 7286 p2p_pasn_store_ptk(p2p, &pasn->ptk); 7287 #endif /* CONFIG_TESTING_OPTIONS */ 7288 forced_memzero(pasn_get_ptk(pasn), sizeof(pasn->ptk)); 7289 } else { 7290 ret = p2p_handle_pasn_auth(p2p, dev, mgmt, len, freq); 7291 } 7292 return ret; 7293 } 7294 7295 p2p_pasn_pmksa_set_pmk(struct p2p_data * p2p,const u8 * src,const u8 * dst,const u8 * pmk,size_t pmk_len,const u8 * pmkid)7296 void p2p_pasn_pmksa_set_pmk(struct p2p_data *p2p, const u8 *src, const u8 *dst, 7297 const u8 *pmk, size_t pmk_len, const u8 *pmkid) 7298 { 7299 pasn_initiator_pmksa_cache_add(p2p->initiator_pmksa, src, dst, pmk, 7300 pmk_len, pmkid); 7301 pasn_responder_pmksa_cache_add(p2p->responder_pmksa, src, dst, pmk, 7302 pmk_len, pmkid); 7303 } 7304 7305 7306 #ifdef CONFIG_TESTING_OPTIONS 7307 p2p_pasn_store_ptk(struct p2p_data * p2p,struct wpa_ptk * ptk)7308 void p2p_pasn_store_ptk(struct p2p_data *p2p, struct wpa_ptk *ptk) 7309 { 7310 u8 *pos; 7311 7312 if (ptk->ptk_len > sizeof(p2p->pasn_ptk)) { 7313 p2p_dbg(p2p, "P2P PASN PTK exceeds: (len=%ld)", ptk->ptk_len); 7314 return; 7315 } 7316 7317 pos = p2p->pasn_ptk; 7318 p2p->pasn_ptk_len = ptk->ptk_len; 7319 if (ptk->kck_len) { 7320 os_memcpy(pos, ptk->kck, ptk->kck_len); 7321 pos += ptk->kck_len; 7322 } 7323 if (ptk->kek_len) { 7324 os_memcpy(pos, ptk->kek, ptk->kek_len); 7325 pos += ptk->kek_len; 7326 } 7327 if (ptk->tk_len) { 7328 os_memcpy(pos, ptk->tk, ptk->tk_len); 7329 pos += ptk->tk_len; 7330 } 7331 if (ptk->kdk_len) { 7332 os_memcpy(pos, ptk->kdk, ptk->kdk_len); 7333 pos += ptk->kdk_len; 7334 } 7335 } 7336 7337 p2p_pasn_get_ptk(struct p2p_data * p2p,const u8 ** buf,size_t * buf_len)7338 int p2p_pasn_get_ptk(struct p2p_data *p2p, const u8 **buf, size_t *buf_len) 7339 { 7340 if (!p2p || !p2p->pasn_ptk_len) 7341 return -1; 7342 7343 *buf_len = p2p->pasn_ptk_len; 7344 *buf = p2p->pasn_ptk; 7345 return 0; 7346 } 7347 7348 #endif /* CONFIG_TESTING_OPTIONS */ 7349 7350 #endif /* CONFIG_PASN */ 7351 7352 p2p_get_dira_info(struct p2p_data * p2p,char * buf,size_t buflen)7353 int p2p_get_dira_info(struct p2p_data *p2p, char *buf, size_t buflen) 7354 { 7355 int res; 7356 char *pos, *end; 7357 struct p2p_id_key *dev_ik; 7358 7359 if (!p2p->pairing_info || 7360 !p2p->cfg->pairing_config.pairing_capable || 7361 !p2p->cfg->pairing_config.enable_pairing_cache) 7362 return 0; 7363 7364 if (p2p_derive_nonce_tag(p2p)) 7365 return 0; 7366 7367 pos = buf; 7368 end = buf + buflen; 7369 dev_ik = &p2p->pairing_info->dev_ik; 7370 7371 res = os_snprintf(pos, end - pos, MACSTR, 7372 MAC2STR(p2p->cfg->dev_addr)); 7373 if (os_snprintf_error(end - pos, res)) 7374 return pos - buf; 7375 pos += res; 7376 7377 res = os_snprintf(pos, end - pos, " "); 7378 if (os_snprintf_error(end - pos, res)) 7379 return pos - buf; 7380 pos += res; 7381 7382 pos += wpa_snprintf_hex(pos, end - pos, dev_ik->dira_nonce, 7383 dev_ik->dira_nonce_len); 7384 7385 res = os_snprintf(pos, end - pos, " "); 7386 if (os_snprintf_error(end - pos, res)) 7387 return pos - buf; 7388 pos += res; 7389 7390 pos += wpa_snprintf_hex(pos, end - pos, dev_ik->dira_tag, 7391 dev_ik->dira_tag_len); 7392 7393 res = os_snprintf(pos, end - pos, "\n"); 7394 if (os_snprintf_error(end - pos, res)) 7395 return pos - buf; 7396 pos += res; 7397 7398 return pos - buf; 7399 } 7400