1/* 2 * wpa_supplicant - P2P 3 * Copyright (c) 2009-2010, Atheros Communications 4 * Copyright (c) 2010-2014, Jouni Malinen <j@w1.fi> 5 * 6 * This software may be distributed under the terms of the BSD license. 7 * See README for more details. 8 */ 9 10#include "includes.h" 11 12#include "common.h" 13#include "eloop.h" 14#include "common/ieee802_11_common.h" 15#include "common/ieee802_11_defs.h" 16#include "common/wpa_ctrl.h" 17#include "wps/wps_i.h" 18#include "p2p/p2p.h" 19#include "ap/hostapd.h" 20#include "ap/ap_config.h" 21#include "ap/sta_info.h" 22#include "ap/ap_drv_ops.h" 23#include "ap/wps_hostapd.h" 24#include "ap/p2p_hostapd.h" 25#include "eapol_supp/eapol_supp_sm.h" 26#include "rsn_supp/wpa.h" 27#include "wpa_supplicant_i.h" 28#include "driver_i.h" 29#include "ap.h" 30#include "config_ssid.h" 31#include "config.h" 32#include "notify.h" 33#include "scan.h" 34#include "bss.h" 35#include "offchannel.h" 36#include "wps_supplicant.h" 37#include "p2p_supplicant.h" 38#include "wifi_display.h" 39 40 41/* 42 * How many times to try to scan to find the GO before giving up on join 43 * request. 44 */ 45#define P2P_MAX_JOIN_SCAN_ATTEMPTS 10 46 47#define P2P_AUTO_PD_SCAN_ATTEMPTS 5 48 49#ifndef P2P_MAX_CLIENT_IDLE 50/* 51 * How many seconds to try to reconnect to the GO when connection in P2P client 52 * role has been lost. 53 */ 54#define P2P_MAX_CLIENT_IDLE 10 55#endif /* P2P_MAX_CLIENT_IDLE */ 56 57#ifndef P2P_MAX_INITIAL_CONN_WAIT 58/* 59 * How many seconds to wait for initial 4-way handshake to get completed after 60 * WPS provisioning step or after the re-invocation of a persistent group on a 61 * P2P Client. 62 */ 63#define P2P_MAX_INITIAL_CONN_WAIT 10 64#endif /* P2P_MAX_INITIAL_CONN_WAIT */ 65 66#ifndef P2P_MAX_INITIAL_CONN_WAIT_GO 67/* 68 * How many seconds to wait for initial 4-way handshake to get completed after 69 * WPS provisioning step on the GO. This controls the extra time the P2P 70 * operation is considered to be in progress (e.g., to delay other scans) after 71 * WPS provisioning has been completed on the GO during group formation. 72 */ 73#define P2P_MAX_INITIAL_CONN_WAIT_GO 10 74#endif /* P2P_MAX_INITIAL_CONN_WAIT_GO */ 75 76#ifndef P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE 77/* 78 * How many seconds to wait for initial 4-way handshake to get completed after 79 * re-invocation of a persistent group on the GO when the client is expected 80 * to connect automatically (no user interaction). 81 */ 82#define P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE 15 83#endif /* P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE */ 84 85#define P2P_MGMT_DEVICE_PREFIX "p2p-dev-" 86 87enum p2p_group_removal_reason { 88 P2P_GROUP_REMOVAL_UNKNOWN, 89 P2P_GROUP_REMOVAL_SILENT, 90 P2P_GROUP_REMOVAL_FORMATION_FAILED, 91 P2P_GROUP_REMOVAL_REQUESTED, 92 P2P_GROUP_REMOVAL_IDLE_TIMEOUT, 93 P2P_GROUP_REMOVAL_UNAVAILABLE, 94 P2P_GROUP_REMOVAL_GO_ENDING_SESSION, 95 P2P_GROUP_REMOVAL_PSK_FAILURE, 96 P2P_GROUP_REMOVAL_FREQ_CONFLICT 97}; 98 99 100static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx); 101static struct wpa_supplicant * 102wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated, 103 int go); 104static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq, 105 const u8 *ssid, size_t ssid_len); 106static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq, 107 const u8 *ssid, size_t ssid_len); 108static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx); 109static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr, 110 const u8 *dev_addr, enum p2p_wps_method wps_method, 111 int auto_join, int freq, 112 const u8 *ssid, size_t ssid_len); 113static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s); 114static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s); 115static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx); 116static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s); 117static void wpas_p2p_group_formation_timeout(void *eloop_ctx, 118 void *timeout_ctx); 119static void wpas_p2p_group_freq_conflict(void *eloop_ctx, void *timeout_ctx); 120static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s, 121 int group_added); 122static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s); 123static void wpas_stop_listen(void *ctx); 124static void wpas_p2p_psk_failure_removal(void *eloop_ctx, void *timeout_ctx); 125static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s); 126 127 128/* 129 * Get the number of concurrent channels that the HW can operate, but that are 130 * currently not in use by any of the wpa_supplicant interfaces. 131 */ 132static int wpas_p2p_num_unused_channels(struct wpa_supplicant *wpa_s) 133{ 134 int *freqs; 135 int num, unused; 136 137 freqs = os_calloc(wpa_s->num_multichan_concurrent, sizeof(int)); 138 if (!freqs) 139 return -1; 140 141 num = get_shared_radio_freqs(wpa_s, freqs, 142 wpa_s->num_multichan_concurrent); 143 os_free(freqs); 144 145 unused = wpa_s->num_multichan_concurrent - num; 146 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: num_unused_channels: %d", unused); 147 return unused; 148} 149 150 151/* 152 * Get the frequencies that are currently in use by one or more of the virtual 153 * interfaces, and that are also valid for P2P operation. 154 */ 155static unsigned int 156wpas_p2p_valid_oper_freqs(struct wpa_supplicant *wpa_s, 157 struct wpa_used_freq_data *p2p_freqs, 158 unsigned int len) 159{ 160 struct wpa_used_freq_data *freqs; 161 unsigned int num, i, j; 162 163 freqs = os_calloc(wpa_s->num_multichan_concurrent, 164 sizeof(struct wpa_used_freq_data)); 165 if (!freqs) 166 return 0; 167 168 num = get_shared_radio_freqs_data(wpa_s, freqs, 169 wpa_s->num_multichan_concurrent); 170 171 os_memset(p2p_freqs, 0, sizeof(struct wpa_used_freq_data) * len); 172 173 for (i = 0, j = 0; i < num && j < len; i++) { 174 if (p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq)) 175 p2p_freqs[j++] = freqs[i]; 176 } 177 178 os_free(freqs); 179 180 dump_freq_data(wpa_s, "valid for P2P", p2p_freqs, j); 181 182 return j; 183} 184 185 186static void wpas_p2p_set_own_freq_preference(struct wpa_supplicant *wpa_s, 187 int freq) 188{ 189 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 190 return; 191 if (wpa_s->parent->conf->p2p_ignore_shared_freq && 192 freq > 0 && wpa_s->num_multichan_concurrent > 1 && 193 wpas_p2p_num_unused_channels(wpa_s) > 0) { 194 wpa_printf(MSG_DEBUG, "P2P: Ignore own channel preference %d MHz due to p2p_ignore_shared_freq=1 configuration", 195 freq); 196 freq = 0; 197 } 198 p2p_set_own_freq_preference(wpa_s->global->p2p, freq); 199} 200 201 202static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s, 203 struct wpa_scan_results *scan_res) 204{ 205 size_t i; 206 207 if (wpa_s->p2p_scan_work) { 208 struct wpa_radio_work *work = wpa_s->p2p_scan_work; 209 wpa_s->p2p_scan_work = NULL; 210 radio_work_done(work); 211 } 212 213 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 214 return; 215 216 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS)", 217 (int) scan_res->num); 218 219 for (i = 0; i < scan_res->num; i++) { 220 struct wpa_scan_res *bss = scan_res->res[i]; 221 struct os_reltime time_tmp_age, entry_ts; 222 const u8 *ies; 223 size_t ies_len; 224 225 time_tmp_age.sec = bss->age / 1000; 226 time_tmp_age.usec = (bss->age % 1000) * 1000; 227 os_reltime_sub(&scan_res->fetch_time, &time_tmp_age, &entry_ts); 228 229 ies = (const u8 *) (bss + 1); 230 ies_len = bss->ie_len; 231 if (bss->beacon_ie_len > 0 && 232 !wpa_scan_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) && 233 wpa_scan_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) { 234 wpa_printf(MSG_DEBUG, "P2P: Use P2P IE(s) from Beacon frame since no P2P IE(s) in Probe Response frames received for " 235 MACSTR, MAC2STR(bss->bssid)); 236 ies = ies + ies_len; 237 ies_len = bss->beacon_ie_len; 238 } 239 240 241 if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid, 242 bss->freq, &entry_ts, bss->level, 243 ies, ies_len) > 0) 244 break; 245 } 246 247 p2p_scan_res_handled(wpa_s->global->p2p); 248} 249 250 251static void wpas_p2p_trigger_scan_cb(struct wpa_radio_work *work, int deinit) 252{ 253 struct wpa_supplicant *wpa_s = work->wpa_s; 254 struct wpa_driver_scan_params *params = work->ctx; 255 int ret; 256 257 if (deinit) { 258 if (!work->started) { 259 wpa_scan_free_params(params); 260 return; 261 } 262 263 wpa_s->p2p_scan_work = NULL; 264 return; 265 } 266 267 ret = wpa_drv_scan(wpa_s, params); 268 wpa_scan_free_params(params); 269 work->ctx = NULL; 270 if (ret) { 271 radio_work_done(work); 272 return; 273 } 274 275 os_get_reltime(&wpa_s->scan_trigger_time); 276 wpa_s->scan_res_handler = wpas_p2p_scan_res_handler; 277 wpa_s->own_scan_requested = 1; 278 wpa_s->p2p_scan_work = work; 279} 280 281 282static int wpas_p2p_scan(void *ctx, enum p2p_scan_type type, int freq, 283 unsigned int num_req_dev_types, 284 const u8 *req_dev_types, const u8 *dev_id, u16 pw_id) 285{ 286 struct wpa_supplicant *wpa_s = ctx; 287 struct wpa_driver_scan_params *params = NULL; 288 struct wpabuf *wps_ie, *ies; 289 size_t ielen; 290 u8 *n; 291 292 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 293 return -1; 294 295 if (wpa_s->p2p_scan_work) { 296 wpa_dbg(wpa_s, MSG_INFO, "P2P: Reject scan trigger since one is already pending"); 297 return -1; 298 } 299 300 params = os_zalloc(sizeof(*params)); 301 if (params == NULL) 302 return -1; 303 304 /* P2P Wildcard SSID */ 305 params->num_ssids = 1; 306 n = os_malloc(P2P_WILDCARD_SSID_LEN); 307 if (n == NULL) 308 goto fail; 309 os_memcpy(n, P2P_WILDCARD_SSID, P2P_WILDCARD_SSID_LEN); 310 params->ssids[0].ssid = n; 311 params->ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN; 312 313 wpa_s->wps->dev.p2p = 1; 314 wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev, 315 wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 316 num_req_dev_types, req_dev_types); 317 if (wps_ie == NULL) 318 goto fail; 319 320 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p); 321 ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen); 322 if (ies == NULL) { 323 wpabuf_free(wps_ie); 324 goto fail; 325 } 326 wpabuf_put_buf(ies, wps_ie); 327 wpabuf_free(wps_ie); 328 329 p2p_scan_ie(wpa_s->global->p2p, ies, dev_id); 330 331 params->p2p_probe = 1; 332 n = os_malloc(wpabuf_len(ies)); 333 if (n == NULL) { 334 wpabuf_free(ies); 335 goto fail; 336 } 337 os_memcpy(n, wpabuf_head(ies), wpabuf_len(ies)); 338 params->extra_ies = n; 339 params->extra_ies_len = wpabuf_len(ies); 340 wpabuf_free(ies); 341 342 switch (type) { 343 case P2P_SCAN_SOCIAL: 344 params->freqs = os_malloc(4 * sizeof(int)); 345 if (params->freqs == NULL) 346 goto fail; 347 params->freqs[0] = 2412; 348 params->freqs[1] = 2437; 349 params->freqs[2] = 2462; 350 params->freqs[3] = 0; 351 break; 352 case P2P_SCAN_FULL: 353 break; 354 case P2P_SCAN_SOCIAL_PLUS_ONE: 355 params->freqs = os_malloc(5 * sizeof(int)); 356 if (params->freqs == NULL) 357 goto fail; 358 params->freqs[0] = 2412; 359 params->freqs[1] = 2437; 360 params->freqs[2] = 2462; 361 params->freqs[3] = freq; 362 params->freqs[4] = 0; 363 break; 364 } 365 366 radio_remove_works(wpa_s, "p2p-scan", 0); 367 if (radio_add_work(wpa_s, 0, "p2p-scan", 0, wpas_p2p_trigger_scan_cb, 368 params) < 0) 369 goto fail; 370 return 0; 371 372fail: 373 wpa_scan_free_params(params); 374 return -1; 375} 376 377 378static enum wpa_driver_if_type wpas_p2p_if_type(int p2p_group_interface) 379{ 380 switch (p2p_group_interface) { 381 case P2P_GROUP_INTERFACE_PENDING: 382 return WPA_IF_P2P_GROUP; 383 case P2P_GROUP_INTERFACE_GO: 384 return WPA_IF_P2P_GO; 385 case P2P_GROUP_INTERFACE_CLIENT: 386 return WPA_IF_P2P_CLIENT; 387 } 388 389 return WPA_IF_P2P_GROUP; 390} 391 392 393static struct wpa_supplicant * wpas_get_p2p_group(struct wpa_supplicant *wpa_s, 394 const u8 *ssid, 395 size_t ssid_len, int *go) 396{ 397 struct wpa_ssid *s; 398 399 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) { 400 for (s = wpa_s->conf->ssid; s; s = s->next) { 401 if (s->disabled != 0 || !s->p2p_group || 402 s->ssid_len != ssid_len || 403 os_memcmp(ssid, s->ssid, ssid_len) != 0) 404 continue; 405 if (s->mode == WPAS_MODE_P2P_GO && 406 s != wpa_s->current_ssid) 407 continue; 408 if (go) 409 *go = s->mode == WPAS_MODE_P2P_GO; 410 return wpa_s; 411 } 412 } 413 414 return NULL; 415} 416 417 418static int wpas_p2p_group_delete(struct wpa_supplicant *wpa_s, 419 enum p2p_group_removal_reason removal_reason) 420{ 421 struct wpa_ssid *ssid; 422 char *gtype; 423 const char *reason; 424 425 ssid = wpa_s->current_ssid; 426 if (ssid == NULL) { 427 /* 428 * The current SSID was not known, but there may still be a 429 * pending P2P group interface waiting for provisioning or a 430 * P2P group that is trying to reconnect. 431 */ 432 ssid = wpa_s->conf->ssid; 433 while (ssid) { 434 if (ssid->p2p_group && ssid->disabled != 2) 435 break; 436 ssid = ssid->next; 437 } 438 if (ssid == NULL && 439 wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE) 440 { 441 wpa_printf(MSG_ERROR, "P2P: P2P group interface " 442 "not found"); 443 return -1; 444 } 445 } 446 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO) 447 gtype = "GO"; 448 else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT || 449 (ssid && ssid->mode == WPAS_MODE_INFRA)) { 450 wpa_s->reassociate = 0; 451 wpa_s->disconnected = 1; 452 wpa_supplicant_deauthenticate(wpa_s, 453 WLAN_REASON_DEAUTH_LEAVING); 454 gtype = "client"; 455 } else 456 gtype = "GO"; 457 if (wpa_s->cross_connect_in_use) { 458 wpa_s->cross_connect_in_use = 0; 459 wpa_msg_global(wpa_s->parent, MSG_INFO, 460 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s", 461 wpa_s->ifname, wpa_s->cross_connect_uplink); 462 } 463 switch (removal_reason) { 464 case P2P_GROUP_REMOVAL_REQUESTED: 465 reason = " reason=REQUESTED"; 466 break; 467 case P2P_GROUP_REMOVAL_FORMATION_FAILED: 468 reason = " reason=FORMATION_FAILED"; 469 break; 470 case P2P_GROUP_REMOVAL_IDLE_TIMEOUT: 471 reason = " reason=IDLE"; 472 break; 473 case P2P_GROUP_REMOVAL_UNAVAILABLE: 474 reason = " reason=UNAVAILABLE"; 475 break; 476 case P2P_GROUP_REMOVAL_GO_ENDING_SESSION: 477 reason = " reason=GO_ENDING_SESSION"; 478 break; 479 case P2P_GROUP_REMOVAL_PSK_FAILURE: 480 reason = " reason=PSK_FAILURE"; 481 break; 482 case P2P_GROUP_REMOVAL_FREQ_CONFLICT: 483 reason = " reason=FREQ_CONFLICT"; 484 break; 485 default: 486 reason = ""; 487 break; 488 } 489 if (removal_reason != P2P_GROUP_REMOVAL_SILENT) { 490 wpa_msg_global(wpa_s->parent, MSG_INFO, 491 P2P_EVENT_GROUP_REMOVED "%s %s%s", 492 wpa_s->ifname, gtype, reason); 493 } 494 495 if (eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL) > 0) 496 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group freq_conflict timeout"); 497 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0) 498 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout"); 499 if (eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 500 wpa_s->parent, NULL) > 0) { 501 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group formation " 502 "timeout"); 503 wpa_s->p2p_in_provisioning = 0; 504 } 505 506 wpa_s->p2p_in_invitation = 0; 507 508 /* 509 * Make sure wait for the first client does not remain active after the 510 * group has been removed. 511 */ 512 wpa_s->global->p2p_go_wait_client.sec = 0; 513 514 if (removal_reason != P2P_GROUP_REMOVAL_SILENT && ssid) 515 wpas_notify_p2p_group_removed(wpa_s, ssid, gtype); 516 517 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) { 518 struct wpa_global *global; 519 char *ifname; 520 enum wpa_driver_if_type type; 521 wpa_printf(MSG_DEBUG, "P2P: Remove group interface %s", 522 wpa_s->ifname); 523 global = wpa_s->global; 524 ifname = os_strdup(wpa_s->ifname); 525 type = wpas_p2p_if_type(wpa_s->p2p_group_interface); 526 wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0); 527 wpa_s = global->ifaces; 528 if (wpa_s && ifname) 529 wpa_drv_if_remove(wpa_s, type, ifname); 530 os_free(ifname); 531 return 1; 532 } 533 534 if (!wpa_s->p2p_go_group_formation_completed) { 535 wpa_s->global->p2p_group_formation = NULL; 536 wpa_s->p2p_in_provisioning = 0; 537 } 538 539 wpa_s->show_group_started = 0; 540 os_free(wpa_s->go_params); 541 wpa_s->go_params = NULL; 542 543 wpa_s->waiting_presence_resp = 0; 544 545 wpa_printf(MSG_DEBUG, "P2P: Remove temporary group network"); 546 if (ssid && (ssid->p2p_group || 547 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION || 548 (ssid->key_mgmt & WPA_KEY_MGMT_WPS))) { 549 int id = ssid->id; 550 if (ssid == wpa_s->current_ssid) { 551 wpa_sm_set_config(wpa_s->wpa, NULL); 552 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 553 wpa_s->current_ssid = NULL; 554 } 555 /* 556 * Networks objects created during any P2P activities are not 557 * exposed out as they might/will confuse certain non-P2P aware 558 * applications since these network objects won't behave like 559 * regular ones. 560 * 561 * Likewise, we don't send out network removed signals for such 562 * network objects. 563 */ 564 wpa_config_remove_network(wpa_s->conf, id); 565 wpa_supplicant_clear_status(wpa_s); 566 wpa_supplicant_cancel_sched_scan(wpa_s); 567 } else { 568 wpa_printf(MSG_DEBUG, "P2P: Temporary group network not " 569 "found"); 570 } 571 if (wpa_s->ap_iface) 572 wpa_supplicant_ap_deinit(wpa_s); 573 else 574 wpa_drv_deinit_p2p_cli(wpa_s); 575 576 return 0; 577} 578 579 580static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s, 581 u8 *go_dev_addr, 582 const u8 *ssid, size_t ssid_len) 583{ 584 struct wpa_bss *bss; 585 const u8 *bssid; 586 struct wpabuf *p2p; 587 u8 group_capab; 588 const u8 *addr; 589 590 if (wpa_s->go_params) 591 bssid = wpa_s->go_params->peer_interface_addr; 592 else 593 bssid = wpa_s->bssid; 594 595 bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len); 596 if (bss == NULL && wpa_s->go_params && 597 !is_zero_ether_addr(wpa_s->go_params->peer_device_addr)) 598 bss = wpa_bss_get_p2p_dev_addr( 599 wpa_s, wpa_s->go_params->peer_device_addr); 600 if (bss == NULL) { 601 u8 iface_addr[ETH_ALEN]; 602 if (p2p_get_interface_addr(wpa_s->global->p2p, bssid, 603 iface_addr) == 0) 604 bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len); 605 } 606 if (bss == NULL) { 607 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether " 608 "group is persistent - BSS " MACSTR " not found", 609 MAC2STR(bssid)); 610 return 0; 611 } 612 613 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE); 614 if (p2p == NULL) 615 p2p = wpa_bss_get_vendor_ie_multi_beacon(bss, 616 P2P_IE_VENDOR_TYPE); 617 if (p2p == NULL) { 618 wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether " 619 "group is persistent - BSS " MACSTR 620 " did not include P2P IE", MAC2STR(bssid)); 621 wpa_hexdump(MSG_DEBUG, "P2P: Probe Response IEs", 622 (u8 *) (bss + 1), bss->ie_len); 623 wpa_hexdump(MSG_DEBUG, "P2P: Beacon IEs", 624 ((u8 *) bss + 1) + bss->ie_len, 625 bss->beacon_ie_len); 626 return 0; 627 } 628 629 group_capab = p2p_get_group_capab(p2p); 630 addr = p2p_get_go_dev_addr(p2p); 631 wpa_printf(MSG_DEBUG, "P2P: Checking whether group is persistent: " 632 "group_capab=0x%x", group_capab); 633 if (addr) { 634 os_memcpy(go_dev_addr, addr, ETH_ALEN); 635 wpa_printf(MSG_DEBUG, "P2P: GO Device Address " MACSTR, 636 MAC2STR(addr)); 637 } else 638 os_memset(go_dev_addr, 0, ETH_ALEN); 639 wpabuf_free(p2p); 640 641 wpa_printf(MSG_DEBUG, "P2P: BSS " MACSTR " group_capab=0x%x " 642 "go_dev_addr=" MACSTR, 643 MAC2STR(bssid), group_capab, MAC2STR(go_dev_addr)); 644 645 return group_capab & P2P_GROUP_CAPAB_PERSISTENT_GROUP; 646} 647 648 649static int wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s, 650 struct wpa_ssid *ssid, 651 const u8 *go_dev_addr) 652{ 653 struct wpa_ssid *s; 654 int changed = 0; 655 656 wpa_printf(MSG_DEBUG, "P2P: Storing credentials for a persistent " 657 "group (GO Dev Addr " MACSTR ")", MAC2STR(go_dev_addr)); 658 for (s = wpa_s->conf->ssid; s; s = s->next) { 659 if (s->disabled == 2 && 660 os_memcmp(go_dev_addr, s->bssid, ETH_ALEN) == 0 && 661 s->ssid_len == ssid->ssid_len && 662 os_memcmp(ssid->ssid, s->ssid, ssid->ssid_len) == 0) 663 break; 664 } 665 666 if (s) { 667 wpa_printf(MSG_DEBUG, "P2P: Update existing persistent group " 668 "entry"); 669 if (ssid->passphrase && !s->passphrase) 670 changed = 1; 671 else if (ssid->passphrase && s->passphrase && 672 os_strcmp(ssid->passphrase, s->passphrase) != 0) 673 changed = 1; 674 } else { 675 wpa_printf(MSG_DEBUG, "P2P: Create a new persistent group " 676 "entry"); 677 changed = 1; 678 s = wpa_config_add_network(wpa_s->conf); 679 if (s == NULL) 680 return -1; 681 682 /* 683 * Instead of network_added we emit persistent_group_added 684 * notification. Also to keep the defense checks in 685 * persistent_group obj registration method, we set the 686 * relevant flags in s to designate it as a persistent group. 687 */ 688 s->p2p_group = 1; 689 s->p2p_persistent_group = 1; 690 wpas_notify_persistent_group_added(wpa_s, s); 691 wpa_config_set_network_defaults(s); 692 } 693 694 s->p2p_group = 1; 695 s->p2p_persistent_group = 1; 696 s->disabled = 2; 697 s->bssid_set = 1; 698 os_memcpy(s->bssid, go_dev_addr, ETH_ALEN); 699 s->mode = ssid->mode; 700 s->auth_alg = WPA_AUTH_ALG_OPEN; 701 s->key_mgmt = WPA_KEY_MGMT_PSK; 702 s->proto = WPA_PROTO_RSN; 703 s->pairwise_cipher = WPA_CIPHER_CCMP; 704 s->export_keys = 1; 705 if (ssid->passphrase) { 706 os_free(s->passphrase); 707 s->passphrase = os_strdup(ssid->passphrase); 708 } 709 if (ssid->psk_set) { 710 s->psk_set = 1; 711 os_memcpy(s->psk, ssid->psk, 32); 712 } 713 if (s->passphrase && !s->psk_set) 714 wpa_config_update_psk(s); 715 if (s->ssid == NULL || s->ssid_len < ssid->ssid_len) { 716 os_free(s->ssid); 717 s->ssid = os_malloc(ssid->ssid_len); 718 } 719 if (s->ssid) { 720 s->ssid_len = ssid->ssid_len; 721 os_memcpy(s->ssid, ssid->ssid, s->ssid_len); 722 } 723 if (ssid->mode == WPAS_MODE_P2P_GO && wpa_s->global->add_psk) { 724 dl_list_add(&s->psk_list, &wpa_s->global->add_psk->list); 725 wpa_s->global->add_psk = NULL; 726 changed = 1; 727 } 728 729 if (changed && wpa_s->conf->update_config && 730 wpa_config_write(wpa_s->confname, wpa_s->conf)) { 731 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration"); 732 } 733 734 return s->id; 735} 736 737 738static void wpas_p2p_add_persistent_group_client(struct wpa_supplicant *wpa_s, 739 const u8 *addr) 740{ 741 struct wpa_ssid *ssid, *s; 742 u8 *n; 743 size_t i; 744 int found = 0; 745 746 ssid = wpa_s->current_ssid; 747 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO || 748 !ssid->p2p_persistent_group) 749 return; 750 751 for (s = wpa_s->parent->conf->ssid; s; s = s->next) { 752 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO) 753 continue; 754 755 if (s->ssid_len == ssid->ssid_len && 756 os_memcmp(s->ssid, ssid->ssid, s->ssid_len) == 0) 757 break; 758 } 759 760 if (s == NULL) 761 return; 762 763 for (i = 0; s->p2p_client_list && i < s->num_p2p_clients; i++) { 764 if (os_memcmp(s->p2p_client_list + i * ETH_ALEN, addr, 765 ETH_ALEN) != 0) 766 continue; 767 768 if (i == s->num_p2p_clients - 1) 769 return; /* already the most recent entry */ 770 771 /* move the entry to mark it most recent */ 772 os_memmove(s->p2p_client_list + i * ETH_ALEN, 773 s->p2p_client_list + (i + 1) * ETH_ALEN, 774 (s->num_p2p_clients - i - 1) * ETH_ALEN); 775 os_memcpy(s->p2p_client_list + 776 (s->num_p2p_clients - 1) * ETH_ALEN, addr, ETH_ALEN); 777 found = 1; 778 break; 779 } 780 781 if (!found && s->num_p2p_clients < P2P_MAX_STORED_CLIENTS) { 782 n = os_realloc_array(s->p2p_client_list, 783 s->num_p2p_clients + 1, ETH_ALEN); 784 if (n == NULL) 785 return; 786 os_memcpy(n + s->num_p2p_clients * ETH_ALEN, addr, ETH_ALEN); 787 s->p2p_client_list = n; 788 s->num_p2p_clients++; 789 } else if (!found && s->p2p_client_list) { 790 /* Not enough room for an additional entry - drop the oldest 791 * entry */ 792 os_memmove(s->p2p_client_list, 793 s->p2p_client_list + ETH_ALEN, 794 (s->num_p2p_clients - 1) * ETH_ALEN); 795 os_memcpy(s->p2p_client_list + 796 (s->num_p2p_clients - 1) * ETH_ALEN, 797 addr, ETH_ALEN); 798 } 799 800 if (wpa_s->parent->conf->update_config && 801 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf)) 802 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration"); 803} 804 805 806static void wpas_p2p_group_started(struct wpa_supplicant *wpa_s, 807 int go, struct wpa_ssid *ssid, int freq, 808 const u8 *psk, const char *passphrase, 809 const u8 *go_dev_addr, int persistent, 810 const char *extra) 811{ 812 const char *ssid_txt; 813 char psk_txt[65]; 814 815 if (psk) 816 wpa_snprintf_hex(psk_txt, sizeof(psk_txt), psk, 32); 817 else 818 psk_txt[0] = '\0'; 819 820 if (ssid) 821 ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len); 822 else 823 ssid_txt = ""; 824 825 if (passphrase && passphrase[0] == '\0') 826 passphrase = NULL; 827 828 /* 829 * Include PSK/passphrase only in the control interface message and 830 * leave it out from the debug log entry. 831 */ 832 wpa_msg_global_ctrl(wpa_s->parent, MSG_INFO, 833 P2P_EVENT_GROUP_STARTED 834 "%s %s ssid=\"%s\" freq=%d%s%s%s%s%s go_dev_addr=" 835 MACSTR "%s%s", 836 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq, 837 psk ? " psk=" : "", psk_txt, 838 passphrase ? " passphrase=\"" : "", 839 passphrase ? passphrase : "", 840 passphrase ? "\"" : "", 841 MAC2STR(go_dev_addr), 842 persistent ? " [PERSISTENT]" : "", extra); 843 wpa_printf(MSG_INFO, P2P_EVENT_GROUP_STARTED 844 "%s %s ssid=\"%s\" freq=%d go_dev_addr=" MACSTR "%s%s", 845 wpa_s->ifname, go ? "GO" : "client", ssid_txt, freq, 846 MAC2STR(go_dev_addr), persistent ? " [PERSISTENT]" : "", 847 extra); 848} 849 850 851static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s, 852 int success) 853{ 854 struct wpa_ssid *ssid; 855 int client; 856 int persistent; 857 u8 go_dev_addr[ETH_ALEN]; 858 int network_id = -1; 859 860 /* 861 * This callback is likely called for the main interface. Update wpa_s 862 * to use the group interface if a new interface was created for the 863 * group. 864 */ 865 if (wpa_s->global->p2p_group_formation) 866 wpa_s = wpa_s->global->p2p_group_formation; 867 if (wpa_s->p2p_go_group_formation_completed) { 868 wpa_s->global->p2p_group_formation = NULL; 869 wpa_s->p2p_in_provisioning = 0; 870 } 871 wpa_s->p2p_in_invitation = 0; 872 873 if (!success) { 874 wpa_msg_global(wpa_s->parent, MSG_INFO, 875 P2P_EVENT_GROUP_FORMATION_FAILURE); 876 wpas_p2p_group_delete(wpa_s, 877 P2P_GROUP_REMOVAL_FORMATION_FAILED); 878 return; 879 } 880 881 wpa_msg_global(wpa_s->parent, MSG_INFO, 882 P2P_EVENT_GROUP_FORMATION_SUCCESS); 883 884 ssid = wpa_s->current_ssid; 885 if (ssid && ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) { 886 ssid->mode = WPAS_MODE_P2P_GO; 887 p2p_group_notif_formation_done(wpa_s->p2p_group); 888 wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL); 889 } 890 891 persistent = 0; 892 if (ssid) { 893 client = ssid->mode == WPAS_MODE_INFRA; 894 if (ssid->mode == WPAS_MODE_P2P_GO) { 895 persistent = ssid->p2p_persistent_group; 896 os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr, 897 ETH_ALEN); 898 } else 899 persistent = wpas_p2p_persistent_group(wpa_s, 900 go_dev_addr, 901 ssid->ssid, 902 ssid->ssid_len); 903 } else { 904 client = wpa_s->p2p_group_interface == 905 P2P_GROUP_INTERFACE_CLIENT; 906 os_memset(go_dev_addr, 0, ETH_ALEN); 907 } 908 909 wpa_s->show_group_started = 0; 910 if (client) { 911 /* 912 * Indicate event only after successfully completed 4-way 913 * handshake, i.e., when the interface is ready for data 914 * packets. 915 */ 916 wpa_s->show_group_started = 1; 917 } else { 918 wpas_p2p_group_started(wpa_s, 1, ssid, 919 ssid ? ssid->frequency : 0, 920 ssid && ssid->passphrase == NULL && 921 ssid->psk_set ? ssid->psk : NULL, 922 ssid ? ssid->passphrase : NULL, 923 go_dev_addr, persistent, ""); 924 wpas_p2p_cross_connect_setup(wpa_s); 925 wpas_p2p_set_group_idle_timeout(wpa_s); 926 } 927 928 if (persistent) 929 network_id = wpas_p2p_store_persistent_group(wpa_s->parent, 930 ssid, go_dev_addr); 931 else { 932 os_free(wpa_s->global->add_psk); 933 wpa_s->global->add_psk = NULL; 934 } 935 if (network_id < 0 && ssid) 936 network_id = ssid->id; 937 if (!client) { 938 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0); 939 os_get_reltime(&wpa_s->global->p2p_go_wait_client); 940 } 941} 942 943 944struct send_action_work { 945 unsigned int freq; 946 u8 dst[ETH_ALEN]; 947 u8 src[ETH_ALEN]; 948 u8 bssid[ETH_ALEN]; 949 size_t len; 950 unsigned int wait_time; 951 u8 buf[0]; 952}; 953 954 955static void wpas_p2p_send_action_work_timeout(void *eloop_ctx, 956 void *timeout_ctx) 957{ 958 struct wpa_supplicant *wpa_s = eloop_ctx; 959 960 if (!wpa_s->p2p_send_action_work) 961 return; 962 963 wpa_printf(MSG_DEBUG, "P2P: Send Action frame radio work timed out"); 964 os_free(wpa_s->p2p_send_action_work->ctx); 965 radio_work_done(wpa_s->p2p_send_action_work); 966 wpa_s->p2p_send_action_work = NULL; 967} 968 969 970static void wpas_p2p_action_tx_clear(struct wpa_supplicant *wpa_s) 971{ 972 if (wpa_s->p2p_send_action_work) { 973 struct send_action_work *awork; 974 awork = wpa_s->p2p_send_action_work->ctx; 975 if (awork->wait_time == 0) { 976 os_free(awork); 977 radio_work_done(wpa_s->p2p_send_action_work); 978 wpa_s->p2p_send_action_work = NULL; 979 } else { 980 /* 981 * In theory, this should not be needed, but number of 982 * places in the P2P code is still using non-zero wait 983 * time for the last Action frame in the sequence and 984 * some of these do not call send_action_done(). 985 */ 986 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, 987 wpa_s, NULL); 988 eloop_register_timeout( 989 0, awork->wait_time * 1000, 990 wpas_p2p_send_action_work_timeout, 991 wpa_s, NULL); 992 } 993 } 994} 995 996 997static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s, 998 unsigned int freq, 999 const u8 *dst, const u8 *src, 1000 const u8 *bssid, 1001 const u8 *data, size_t data_len, 1002 enum offchannel_send_action_result 1003 result) 1004{ 1005 enum p2p_send_action_result res = P2P_SEND_ACTION_SUCCESS; 1006 1007 wpas_p2p_action_tx_clear(wpa_s); 1008 1009 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) 1010 return; 1011 1012 switch (result) { 1013 case OFFCHANNEL_SEND_ACTION_SUCCESS: 1014 res = P2P_SEND_ACTION_SUCCESS; 1015 break; 1016 case OFFCHANNEL_SEND_ACTION_NO_ACK: 1017 res = P2P_SEND_ACTION_NO_ACK; 1018 break; 1019 case OFFCHANNEL_SEND_ACTION_FAILED: 1020 res = P2P_SEND_ACTION_FAILED; 1021 break; 1022 } 1023 1024 p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res); 1025 1026 if (result != OFFCHANNEL_SEND_ACTION_SUCCESS && 1027 wpa_s->pending_pd_before_join && 1028 (os_memcmp(dst, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 || 1029 os_memcmp(dst, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0) && 1030 wpa_s->p2p_fallback_to_go_neg) { 1031 wpa_s->pending_pd_before_join = 0; 1032 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No ACK for PD Req " 1033 "during p2p_connect-auto"); 1034 wpas_p2p_fallback_to_go_neg(wpa_s, 0); 1035 return; 1036 } 1037} 1038 1039 1040static void wpas_send_action_cb(struct wpa_radio_work *work, int deinit) 1041{ 1042 struct wpa_supplicant *wpa_s = work->wpa_s; 1043 struct send_action_work *awork = work->ctx; 1044 1045 if (deinit) { 1046 if (work->started) { 1047 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, 1048 wpa_s, NULL); 1049 wpa_s->p2p_send_action_work = NULL; 1050 offchannel_send_action_done(wpa_s); 1051 } 1052 os_free(awork); 1053 return; 1054 } 1055 1056 if (offchannel_send_action(wpa_s, awork->freq, awork->dst, awork->src, 1057 awork->bssid, awork->buf, awork->len, 1058 awork->wait_time, 1059 wpas_p2p_send_action_tx_status, 1) < 0) { 1060 os_free(awork); 1061 radio_work_done(work); 1062 return; 1063 } 1064 wpa_s->p2p_send_action_work = work; 1065} 1066 1067 1068static int wpas_send_action_work(struct wpa_supplicant *wpa_s, 1069 unsigned int freq, const u8 *dst, 1070 const u8 *src, const u8 *bssid, const u8 *buf, 1071 size_t len, unsigned int wait_time) 1072{ 1073 struct send_action_work *awork; 1074 1075 if (wpa_s->p2p_send_action_work) { 1076 wpa_printf(MSG_DEBUG, "P2P: Cannot schedule new p2p-send-action work since one is already pending"); 1077 return -1; 1078 } 1079 1080 awork = os_zalloc(sizeof(*awork) + len); 1081 if (awork == NULL) 1082 return -1; 1083 1084 awork->freq = freq; 1085 os_memcpy(awork->dst, dst, ETH_ALEN); 1086 os_memcpy(awork->src, src, ETH_ALEN); 1087 os_memcpy(awork->bssid, bssid, ETH_ALEN); 1088 awork->len = len; 1089 awork->wait_time = wait_time; 1090 os_memcpy(awork->buf, buf, len); 1091 1092 if (radio_add_work(wpa_s, freq, "p2p-send-action", 0, 1093 wpas_send_action_cb, awork) < 0) { 1094 os_free(awork); 1095 return -1; 1096 } 1097 1098 return 0; 1099} 1100 1101 1102static int wpas_send_action(void *ctx, unsigned int freq, const u8 *dst, 1103 const u8 *src, const u8 *bssid, const u8 *buf, 1104 size_t len, unsigned int wait_time) 1105{ 1106 struct wpa_supplicant *wpa_s = ctx; 1107 int listen_freq = -1, send_freq = -1; 1108 1109 if (wpa_s->p2p_listen_work) 1110 listen_freq = wpa_s->p2p_listen_work->freq; 1111 if (wpa_s->p2p_send_action_work) 1112 send_freq = wpa_s->p2p_send_action_work->freq; 1113 if (listen_freq != (int) freq && send_freq != (int) freq) { 1114 wpa_printf(MSG_DEBUG, "P2P: Schedule new radio work for Action frame TX (listen_freq=%d send_freq=%d)", 1115 listen_freq, send_freq); 1116 return wpas_send_action_work(wpa_s, freq, dst, src, bssid, buf, 1117 len, wait_time); 1118 } 1119 1120 wpa_printf(MSG_DEBUG, "P2P: Use ongoing radio work for Action frame TX"); 1121 return offchannel_send_action(wpa_s, freq, dst, src, bssid, buf, len, 1122 wait_time, 1123 wpas_p2p_send_action_tx_status, 1); 1124} 1125 1126 1127static void wpas_send_action_done(void *ctx) 1128{ 1129 struct wpa_supplicant *wpa_s = ctx; 1130 1131 if (wpa_s->p2p_send_action_work) { 1132 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, 1133 wpa_s, NULL); 1134 os_free(wpa_s->p2p_send_action_work->ctx); 1135 radio_work_done(wpa_s->p2p_send_action_work); 1136 wpa_s->p2p_send_action_work = NULL; 1137 } 1138 1139 offchannel_send_action_done(wpa_s); 1140} 1141 1142 1143static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s, 1144 struct p2p_go_neg_results *params) 1145{ 1146 if (wpa_s->go_params == NULL) { 1147 wpa_s->go_params = os_malloc(sizeof(*params)); 1148 if (wpa_s->go_params == NULL) 1149 return -1; 1150 } 1151 os_memcpy(wpa_s->go_params, params, sizeof(*params)); 1152 return 0; 1153} 1154 1155 1156static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s, 1157 struct p2p_go_neg_results *res) 1158{ 1159 wpa_printf(MSG_DEBUG, "P2P: Start WPS Enrollee for peer " MACSTR 1160 " dev_addr " MACSTR " wps_method %d", 1161 MAC2STR(res->peer_interface_addr), 1162 MAC2STR(res->peer_device_addr), res->wps_method); 1163 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Start WPS Enrollee for SSID", 1164 res->ssid, res->ssid_len); 1165 wpa_supplicant_ap_deinit(wpa_s); 1166 wpas_copy_go_neg_results(wpa_s, res); 1167 if (res->wps_method == WPS_PBC) { 1168 wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1); 1169#ifdef CONFIG_WPS_NFC 1170 } else if (res->wps_method == WPS_NFC) { 1171 wpas_wps_start_nfc(wpa_s, res->peer_device_addr, 1172 res->peer_interface_addr, 1173 wpa_s->parent->p2p_oob_dev_pw, 1174 wpa_s->parent->p2p_oob_dev_pw_id, 1, 1175 wpa_s->parent->p2p_oob_dev_pw_id == 1176 DEV_PW_NFC_CONNECTION_HANDOVER ? 1177 wpa_s->parent->p2p_peer_oob_pubkey_hash : 1178 NULL, 1179 NULL, 0, 0); 1180#endif /* CONFIG_WPS_NFC */ 1181 } else { 1182 u16 dev_pw_id = DEV_PW_DEFAULT; 1183 if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD) 1184 dev_pw_id = DEV_PW_REGISTRAR_SPECIFIED; 1185 wpas_wps_start_pin(wpa_s, res->peer_interface_addr, 1186 wpa_s->p2p_pin, 1, dev_pw_id); 1187 } 1188} 1189 1190 1191static void wpas_p2p_add_psk_list(struct wpa_supplicant *wpa_s, 1192 struct wpa_ssid *ssid) 1193{ 1194 struct wpa_ssid *persistent; 1195 struct psk_list_entry *psk; 1196 struct hostapd_data *hapd; 1197 1198 if (!wpa_s->ap_iface) 1199 return; 1200 1201 persistent = wpas_p2p_get_persistent(wpa_s->parent, NULL, ssid->ssid, 1202 ssid->ssid_len); 1203 if (persistent == NULL) 1204 return; 1205 1206 hapd = wpa_s->ap_iface->bss[0]; 1207 1208 dl_list_for_each(psk, &persistent->psk_list, struct psk_list_entry, 1209 list) { 1210 struct hostapd_wpa_psk *hpsk; 1211 1212 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add persistent group PSK entry for " 1213 MACSTR " psk=%d", 1214 MAC2STR(psk->addr), psk->p2p); 1215 hpsk = os_zalloc(sizeof(*hpsk)); 1216 if (hpsk == NULL) 1217 break; 1218 os_memcpy(hpsk->psk, psk->psk, PMK_LEN); 1219 if (psk->p2p) 1220 os_memcpy(hpsk->p2p_dev_addr, psk->addr, ETH_ALEN); 1221 else 1222 os_memcpy(hpsk->addr, psk->addr, ETH_ALEN); 1223 hpsk->next = hapd->conf->ssid.wpa_psk; 1224 hapd->conf->ssid.wpa_psk = hpsk; 1225 } 1226} 1227 1228 1229static void p2p_go_configured(void *ctx, void *data) 1230{ 1231 struct wpa_supplicant *wpa_s = ctx; 1232 struct p2p_go_neg_results *params = data; 1233 struct wpa_ssid *ssid; 1234 int network_id = -1; 1235 1236 ssid = wpa_s->current_ssid; 1237 if (ssid && ssid->mode == WPAS_MODE_P2P_GO) { 1238 wpa_printf(MSG_DEBUG, "P2P: Group setup without provisioning"); 1239 if (wpa_s->global->p2p_group_formation == wpa_s) 1240 wpa_s->global->p2p_group_formation = NULL; 1241 wpas_p2p_group_started(wpa_s, 1, ssid, ssid->frequency, 1242 params->passphrase[0] == '\0' ? 1243 params->psk : NULL, 1244 params->passphrase, 1245 wpa_s->global->p2p_dev_addr, 1246 params->persistent_group, ""); 1247 1248 os_get_reltime(&wpa_s->global->p2p_go_wait_client); 1249 if (params->persistent_group) { 1250 network_id = wpas_p2p_store_persistent_group( 1251 wpa_s->parent, ssid, 1252 wpa_s->global->p2p_dev_addr); 1253 wpas_p2p_add_psk_list(wpa_s, ssid); 1254 } 1255 if (network_id < 0) 1256 network_id = ssid->id; 1257 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0); 1258 wpas_p2p_cross_connect_setup(wpa_s); 1259 wpas_p2p_set_group_idle_timeout(wpa_s); 1260 1261 if (wpa_s->p2p_first_connection_timeout) { 1262 wpa_dbg(wpa_s, MSG_DEBUG, 1263 "P2P: Start group formation timeout of %d seconds until first data connection on GO", 1264 wpa_s->p2p_first_connection_timeout); 1265 wpa_s->p2p_go_group_formation_completed = 0; 1266 wpa_s->global->p2p_group_formation = wpa_s; 1267 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 1268 wpa_s->parent, NULL); 1269 eloop_register_timeout( 1270 wpa_s->p2p_first_connection_timeout, 0, 1271 wpas_p2p_group_formation_timeout, 1272 wpa_s->parent, NULL); 1273 } 1274 1275 return; 1276 } 1277 1278 wpa_printf(MSG_DEBUG, "P2P: Setting up WPS for GO provisioning"); 1279 if (wpa_supplicant_ap_mac_addr_filter(wpa_s, 1280 params->peer_interface_addr)) { 1281 wpa_printf(MSG_DEBUG, "P2P: Failed to setup MAC address " 1282 "filtering"); 1283 return; 1284 } 1285 if (params->wps_method == WPS_PBC) { 1286 wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr, 1287 params->peer_device_addr); 1288#ifdef CONFIG_WPS_NFC 1289 } else if (params->wps_method == WPS_NFC) { 1290 if (wpa_s->parent->p2p_oob_dev_pw_id != 1291 DEV_PW_NFC_CONNECTION_HANDOVER && 1292 !wpa_s->parent->p2p_oob_dev_pw) { 1293 wpa_printf(MSG_DEBUG, "P2P: No NFC Dev Pw known"); 1294 return; 1295 } 1296 wpas_ap_wps_add_nfc_pw( 1297 wpa_s, wpa_s->parent->p2p_oob_dev_pw_id, 1298 wpa_s->parent->p2p_oob_dev_pw, 1299 wpa_s->parent->p2p_peer_oob_pk_hash_known ? 1300 wpa_s->parent->p2p_peer_oob_pubkey_hash : NULL); 1301#endif /* CONFIG_WPS_NFC */ 1302 } else if (wpa_s->p2p_pin[0]) 1303 wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr, 1304 wpa_s->p2p_pin, NULL, 0, 0); 1305 os_free(wpa_s->go_params); 1306 wpa_s->go_params = NULL; 1307} 1308 1309 1310static void wpas_start_wps_go(struct wpa_supplicant *wpa_s, 1311 struct p2p_go_neg_results *params, 1312 int group_formation) 1313{ 1314 struct wpa_ssid *ssid; 1315 1316 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Starting GO"); 1317 if (wpas_copy_go_neg_results(wpa_s, params) < 0) { 1318 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not copy GO Negotiation " 1319 "results"); 1320 return; 1321 } 1322 1323 ssid = wpa_config_add_network(wpa_s->conf); 1324 if (ssid == NULL) { 1325 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not add network for GO"); 1326 return; 1327 } 1328 1329 wpa_s->show_group_started = 0; 1330 1331 wpa_config_set_network_defaults(ssid); 1332 ssid->temporary = 1; 1333 ssid->p2p_group = 1; 1334 ssid->p2p_persistent_group = params->persistent_group; 1335 ssid->mode = group_formation ? WPAS_MODE_P2P_GROUP_FORMATION : 1336 WPAS_MODE_P2P_GO; 1337 ssid->frequency = params->freq; 1338 ssid->ht40 = params->ht40; 1339 ssid->vht = params->vht; 1340 ssid->ssid = os_zalloc(params->ssid_len + 1); 1341 if (ssid->ssid) { 1342 os_memcpy(ssid->ssid, params->ssid, params->ssid_len); 1343 ssid->ssid_len = params->ssid_len; 1344 } 1345 ssid->auth_alg = WPA_AUTH_ALG_OPEN; 1346 ssid->key_mgmt = WPA_KEY_MGMT_PSK; 1347 ssid->proto = WPA_PROTO_RSN; 1348 ssid->pairwise_cipher = WPA_CIPHER_CCMP; 1349 if (os_strlen(params->passphrase) > 0) { 1350 ssid->passphrase = os_strdup(params->passphrase); 1351 if (ssid->passphrase == NULL) { 1352 wpa_msg_global(wpa_s, MSG_ERROR, 1353 "P2P: Failed to copy passphrase for GO"); 1354 wpa_config_remove_network(wpa_s->conf, ssid->id); 1355 return; 1356 } 1357 } else 1358 ssid->passphrase = NULL; 1359 ssid->psk_set = params->psk_set; 1360 if (ssid->psk_set) 1361 os_memcpy(ssid->psk, params->psk, sizeof(ssid->psk)); 1362 else if (ssid->passphrase) 1363 wpa_config_update_psk(ssid); 1364 ssid->ap_max_inactivity = wpa_s->parent->conf->p2p_go_max_inactivity; 1365 1366 wpa_s->ap_configured_cb = p2p_go_configured; 1367 wpa_s->ap_configured_cb_ctx = wpa_s; 1368 wpa_s->ap_configured_cb_data = wpa_s->go_params; 1369 wpa_s->scan_req = NORMAL_SCAN_REQ; 1370 wpa_s->connect_without_scan = ssid; 1371 wpa_s->reassociate = 1; 1372 wpa_s->disconnected = 0; 1373 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Request scan (that will be skipped) to " 1374 "start GO)"); 1375 wpa_supplicant_req_scan(wpa_s, 0, 0); 1376} 1377 1378 1379static void wpas_p2p_clone_config(struct wpa_supplicant *dst, 1380 const struct wpa_supplicant *src) 1381{ 1382 struct wpa_config *d; 1383 const struct wpa_config *s; 1384 1385 d = dst->conf; 1386 s = src->conf; 1387 1388#define C(n) if (s->n) d->n = os_strdup(s->n) 1389 C(device_name); 1390 C(manufacturer); 1391 C(model_name); 1392 C(model_number); 1393 C(serial_number); 1394 C(config_methods); 1395#undef C 1396 1397 os_memcpy(d->device_type, s->device_type, WPS_DEV_TYPE_LEN); 1398 os_memcpy(d->sec_device_type, s->sec_device_type, 1399 sizeof(d->sec_device_type)); 1400 d->num_sec_device_types = s->num_sec_device_types; 1401 1402 d->p2p_group_idle = s->p2p_group_idle; 1403 d->p2p_intra_bss = s->p2p_intra_bss; 1404 d->persistent_reconnect = s->persistent_reconnect; 1405 d->max_num_sta = s->max_num_sta; 1406 d->pbc_in_m1 = s->pbc_in_m1; 1407 d->ignore_old_scan_res = s->ignore_old_scan_res; 1408 d->beacon_int = s->beacon_int; 1409 d->dtim_period = s->dtim_period; 1410 d->disassoc_low_ack = s->disassoc_low_ack; 1411 d->disable_scan_offload = s->disable_scan_offload; 1412 1413 if (s->wps_nfc_dh_privkey && s->wps_nfc_dh_pubkey) { 1414 d->wps_nfc_dh_privkey = wpabuf_dup(s->wps_nfc_dh_privkey); 1415 d->wps_nfc_dh_pubkey = wpabuf_dup(s->wps_nfc_dh_pubkey); 1416 } 1417} 1418 1419 1420static void wpas_p2p_get_group_ifname(struct wpa_supplicant *wpa_s, 1421 char *ifname, size_t len) 1422{ 1423 char *ifname_ptr = wpa_s->ifname; 1424 1425 if (os_strncmp(wpa_s->ifname, P2P_MGMT_DEVICE_PREFIX, 1426 os_strlen(P2P_MGMT_DEVICE_PREFIX)) == 0) { 1427 ifname_ptr = os_strrchr(wpa_s->ifname, '-') + 1; 1428 } 1429 1430 os_snprintf(ifname, len, "p2p-%s-%d", ifname_ptr, wpa_s->p2p_group_idx); 1431 if (os_strlen(ifname) >= IFNAMSIZ && 1432 os_strlen(wpa_s->ifname) < IFNAMSIZ) { 1433 /* Try to avoid going over the IFNAMSIZ length limit */ 1434 os_snprintf(ifname, len, "p2p-%d", wpa_s->p2p_group_idx); 1435 } 1436} 1437 1438 1439static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s, 1440 enum wpa_driver_if_type type) 1441{ 1442 char ifname[120], force_ifname[120]; 1443 1444 if (wpa_s->pending_interface_name[0]) { 1445 wpa_printf(MSG_DEBUG, "P2P: Pending virtual interface exists " 1446 "- skip creation of a new one"); 1447 if (is_zero_ether_addr(wpa_s->pending_interface_addr)) { 1448 wpa_printf(MSG_DEBUG, "P2P: Pending virtual address " 1449 "unknown?! ifname='%s'", 1450 wpa_s->pending_interface_name); 1451 return -1; 1452 } 1453 return 0; 1454 } 1455 1456 wpas_p2p_get_group_ifname(wpa_s, ifname, sizeof(ifname)); 1457 force_ifname[0] = '\0'; 1458 1459 wpa_printf(MSG_DEBUG, "P2P: Create a new interface %s for the group", 1460 ifname); 1461 wpa_s->p2p_group_idx++; 1462 1463 wpa_s->pending_interface_type = type; 1464 if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname, 1465 wpa_s->pending_interface_addr, NULL) < 0) { 1466 wpa_printf(MSG_ERROR, "P2P: Failed to create new group " 1467 "interface"); 1468 return -1; 1469 } 1470 1471 if (force_ifname[0]) { 1472 wpa_printf(MSG_DEBUG, "P2P: Driver forced interface name %s", 1473 force_ifname); 1474 os_strlcpy(wpa_s->pending_interface_name, force_ifname, 1475 sizeof(wpa_s->pending_interface_name)); 1476 } else 1477 os_strlcpy(wpa_s->pending_interface_name, ifname, 1478 sizeof(wpa_s->pending_interface_name)); 1479 wpa_printf(MSG_DEBUG, "P2P: Created pending virtual interface %s addr " 1480 MACSTR, wpa_s->pending_interface_name, 1481 MAC2STR(wpa_s->pending_interface_addr)); 1482 1483 return 0; 1484} 1485 1486 1487static void wpas_p2p_remove_pending_group_interface( 1488 struct wpa_supplicant *wpa_s) 1489{ 1490 if (!wpa_s->pending_interface_name[0] || 1491 is_zero_ether_addr(wpa_s->pending_interface_addr)) 1492 return; /* No pending virtual interface */ 1493 1494 wpa_printf(MSG_DEBUG, "P2P: Removing pending group interface %s", 1495 wpa_s->pending_interface_name); 1496 wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type, 1497 wpa_s->pending_interface_name); 1498 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN); 1499 wpa_s->pending_interface_name[0] = '\0'; 1500} 1501 1502 1503static struct wpa_supplicant * 1504wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go) 1505{ 1506 struct wpa_interface iface; 1507 struct wpa_supplicant *group_wpa_s; 1508 1509 if (!wpa_s->pending_interface_name[0]) { 1510 wpa_printf(MSG_ERROR, "P2P: No pending group interface"); 1511 if (!wpas_p2p_create_iface(wpa_s)) 1512 return NULL; 1513 /* 1514 * Something has forced us to remove the pending interface; try 1515 * to create a new one and hope for the best that we will get 1516 * the same local address. 1517 */ 1518 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO : 1519 WPA_IF_P2P_CLIENT) < 0) 1520 return NULL; 1521 } 1522 1523 os_memset(&iface, 0, sizeof(iface)); 1524 iface.ifname = wpa_s->pending_interface_name; 1525 iface.driver = wpa_s->driver->name; 1526 if (wpa_s->conf->ctrl_interface == NULL && 1527 wpa_s->parent != wpa_s && 1528 wpa_s->p2p_mgmt && 1529 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) 1530 iface.ctrl_interface = wpa_s->parent->conf->ctrl_interface; 1531 else 1532 iface.ctrl_interface = wpa_s->conf->ctrl_interface; 1533 iface.driver_param = wpa_s->conf->driver_param; 1534 group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface); 1535 if (group_wpa_s == NULL) { 1536 wpa_printf(MSG_ERROR, "P2P: Failed to create new " 1537 "wpa_supplicant interface"); 1538 return NULL; 1539 } 1540 wpa_s->pending_interface_name[0] = '\0'; 1541 group_wpa_s->parent = wpa_s; 1542 group_wpa_s->p2p_group_interface = go ? P2P_GROUP_INTERFACE_GO : 1543 P2P_GROUP_INTERFACE_CLIENT; 1544 wpa_s->global->p2p_group_formation = group_wpa_s; 1545 1546 wpas_p2p_clone_config(group_wpa_s, wpa_s); 1547 1548 return group_wpa_s; 1549} 1550 1551 1552static void wpas_p2p_group_formation_timeout(void *eloop_ctx, 1553 void *timeout_ctx) 1554{ 1555 struct wpa_supplicant *wpa_s = eloop_ctx; 1556 wpa_printf(MSG_DEBUG, "P2P: Group Formation timed out"); 1557 wpas_p2p_group_formation_failed(wpa_s); 1558} 1559 1560 1561void wpas_p2p_group_formation_failed(struct wpa_supplicant *wpa_s) 1562{ 1563 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 1564 wpa_s->parent, NULL); 1565 if (wpa_s->global->p2p) 1566 p2p_group_formation_failed(wpa_s->global->p2p); 1567 wpas_group_formation_completed(wpa_s, 0); 1568} 1569 1570 1571static void wpas_p2p_grpform_fail_after_wps(struct wpa_supplicant *wpa_s) 1572{ 1573 wpa_printf(MSG_DEBUG, "P2P: Reject group formation due to WPS provisioning failure"); 1574 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 1575 wpa_s->parent, NULL); 1576 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout, 1577 wpa_s->parent, NULL); 1578 wpa_s->global->p2p_fail_on_wps_complete = 0; 1579} 1580 1581 1582void wpas_p2p_ap_setup_failed(struct wpa_supplicant *wpa_s) 1583{ 1584 if (wpa_s->global->p2p_group_formation != wpa_s) 1585 return; 1586 /* Speed up group formation timeout since this cannot succeed */ 1587 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 1588 wpa_s->parent, NULL); 1589 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout, 1590 wpa_s->parent, NULL); 1591} 1592 1593 1594static void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res) 1595{ 1596 struct wpa_supplicant *wpa_s = ctx; 1597 1598 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) { 1599 wpa_drv_cancel_remain_on_channel(wpa_s); 1600 wpa_s->off_channel_freq = 0; 1601 wpa_s->roc_waiting_drv_freq = 0; 1602 } 1603 1604 if (res->status) { 1605 wpa_msg_global(wpa_s, MSG_INFO, 1606 P2P_EVENT_GO_NEG_FAILURE "status=%d", 1607 res->status); 1608 wpas_notify_p2p_go_neg_completed(wpa_s, res); 1609 wpas_p2p_remove_pending_group_interface(wpa_s); 1610 return; 1611 } 1612 1613 if (wpa_s->p2p_go_ht40) 1614 res->ht40 = 1; 1615 if (wpa_s->p2p_go_vht) 1616 res->vht = 1; 1617 1618 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS "role=%s " 1619 "freq=%d ht40=%d peer_dev=" MACSTR " peer_iface=" MACSTR 1620 " wps_method=%s", 1621 res->role_go ? "GO" : "client", res->freq, res->ht40, 1622 MAC2STR(res->peer_device_addr), 1623 MAC2STR(res->peer_interface_addr), 1624 p2p_wps_method_text(res->wps_method)); 1625 wpas_notify_p2p_go_neg_completed(wpa_s, res); 1626 1627 if (res->role_go && wpa_s->p2p_persistent_id >= 0) { 1628 struct wpa_ssid *ssid; 1629 ssid = wpa_config_get_network(wpa_s->conf, 1630 wpa_s->p2p_persistent_id); 1631 if (ssid && ssid->disabled == 2 && 1632 ssid->mode == WPAS_MODE_P2P_GO && ssid->passphrase) { 1633 size_t len = os_strlen(ssid->passphrase); 1634 wpa_printf(MSG_DEBUG, "P2P: Override passphrase based " 1635 "on requested persistent group"); 1636 os_memcpy(res->passphrase, ssid->passphrase, len); 1637 res->passphrase[len] = '\0'; 1638 } 1639 } 1640 1641 if (wpa_s->create_p2p_iface) { 1642 struct wpa_supplicant *group_wpa_s = 1643 wpas_p2p_init_group_interface(wpa_s, res->role_go); 1644 if (group_wpa_s == NULL) { 1645 wpas_p2p_remove_pending_group_interface(wpa_s); 1646 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, 1647 wpa_s, NULL); 1648 wpas_p2p_group_formation_failed(wpa_s); 1649 return; 1650 } 1651 if (group_wpa_s != wpa_s) { 1652 os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin, 1653 sizeof(group_wpa_s->p2p_pin)); 1654 group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method; 1655 } 1656 os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN); 1657 wpa_s->pending_interface_name[0] = '\0'; 1658 group_wpa_s->p2p_in_provisioning = 1; 1659 1660 if (res->role_go) 1661 wpas_start_wps_go(group_wpa_s, res, 1); 1662 else 1663 wpas_start_wps_enrollee(group_wpa_s, res); 1664 } else { 1665 wpa_s->p2p_in_provisioning = 1; 1666 wpa_s->global->p2p_group_formation = wpa_s; 1667 1668 if (res->role_go) 1669 wpas_start_wps_go(wpa_s, res, 1); 1670 else 1671 wpas_start_wps_enrollee(ctx, res); 1672 } 1673 1674 wpa_s->p2p_long_listen = 0; 1675 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL); 1676 1677 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL); 1678 eloop_register_timeout(15 + res->peer_config_timeout / 100, 1679 (res->peer_config_timeout % 100) * 10000, 1680 wpas_p2p_group_formation_timeout, wpa_s, NULL); 1681} 1682 1683 1684static void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id) 1685{ 1686 struct wpa_supplicant *wpa_s = ctx; 1687 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR 1688 " dev_passwd_id=%u", MAC2STR(src), dev_passwd_id); 1689 1690 wpas_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id); 1691} 1692 1693 1694static void wpas_dev_found(void *ctx, const u8 *addr, 1695 const struct p2p_peer_info *info, 1696 int new_device) 1697{ 1698#ifndef CONFIG_NO_STDOUT_DEBUG 1699 struct wpa_supplicant *wpa_s = ctx; 1700 char devtype[WPS_DEV_TYPE_BUFSIZE]; 1701 char *wfd_dev_info_hex = NULL; 1702 1703#ifdef CONFIG_WIFI_DISPLAY 1704 wfd_dev_info_hex = wifi_display_subelem_hex(info->wfd_subelems, 1705 WFD_SUBELEM_DEVICE_INFO); 1706#endif /* CONFIG_WIFI_DISPLAY */ 1707 1708 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR 1709 " p2p_dev_addr=" MACSTR 1710 " pri_dev_type=%s name='%s' config_methods=0x%x " 1711 "dev_capab=0x%x group_capab=0x%x%s%s%s", 1712 MAC2STR(addr), MAC2STR(info->p2p_device_addr), 1713 wps_dev_type_bin2str(info->pri_dev_type, devtype, 1714 sizeof(devtype)), 1715 info->device_name, info->config_methods, 1716 info->dev_capab, info->group_capab, 1717 wfd_dev_info_hex ? " wfd_dev_info=0x" : "", 1718 wfd_dev_info_hex ? wfd_dev_info_hex : "", 1719 info->vendor_elems ? " vendor_elems=1" : ""); 1720 1721 os_free(wfd_dev_info_hex); 1722#endif /* CONFIG_NO_STDOUT_DEBUG */ 1723 1724 wpas_notify_p2p_device_found(ctx, info->p2p_device_addr, new_device); 1725} 1726 1727 1728static void wpas_dev_lost(void *ctx, const u8 *dev_addr) 1729{ 1730 struct wpa_supplicant *wpa_s = ctx; 1731 1732 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_LOST 1733 "p2p_dev_addr=" MACSTR, MAC2STR(dev_addr)); 1734 1735 wpas_notify_p2p_device_lost(wpa_s, dev_addr); 1736} 1737 1738 1739static void wpas_find_stopped(void *ctx) 1740{ 1741 struct wpa_supplicant *wpa_s = ctx; 1742 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_FIND_STOPPED); 1743} 1744 1745 1746struct wpas_p2p_listen_work { 1747 unsigned int freq; 1748 unsigned int duration; 1749 struct wpabuf *probe_resp_ie; 1750}; 1751 1752 1753static void wpas_p2p_listen_work_free(struct wpas_p2p_listen_work *lwork) 1754{ 1755 if (lwork == NULL) 1756 return; 1757 wpabuf_free(lwork->probe_resp_ie); 1758 os_free(lwork); 1759} 1760 1761 1762static void wpas_p2p_listen_work_done(struct wpa_supplicant *wpa_s) 1763{ 1764 struct wpas_p2p_listen_work *lwork; 1765 1766 if (!wpa_s->p2p_listen_work) 1767 return; 1768 1769 lwork = wpa_s->p2p_listen_work->ctx; 1770 wpas_p2p_listen_work_free(lwork); 1771 radio_work_done(wpa_s->p2p_listen_work); 1772 wpa_s->p2p_listen_work = NULL; 1773} 1774 1775 1776static void wpas_start_listen_cb(struct wpa_radio_work *work, int deinit) 1777{ 1778 struct wpa_supplicant *wpa_s = work->wpa_s; 1779 struct wpas_p2p_listen_work *lwork = work->ctx; 1780 1781 if (deinit) { 1782 if (work->started) { 1783 wpa_s->p2p_listen_work = NULL; 1784 wpas_stop_listen(wpa_s); 1785 } 1786 wpas_p2p_listen_work_free(lwork); 1787 return; 1788 } 1789 1790 wpa_s->p2p_listen_work = work; 1791 1792 wpa_drv_set_ap_wps_ie(wpa_s, NULL, lwork->probe_resp_ie, NULL); 1793 1794 if (wpa_drv_probe_req_report(wpa_s, 1) < 0) { 1795 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver to " 1796 "report received Probe Request frames"); 1797 wpas_p2p_listen_work_done(wpa_s); 1798 return; 1799 } 1800 1801 wpa_s->pending_listen_freq = lwork->freq; 1802 wpa_s->pending_listen_duration = lwork->duration; 1803 1804 if (wpa_drv_remain_on_channel(wpa_s, lwork->freq, lwork->duration) < 0) 1805 { 1806 wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver " 1807 "to remain on channel (%u MHz) for Listen " 1808 "state", lwork->freq); 1809 wpas_p2p_listen_work_done(wpa_s); 1810 wpa_s->pending_listen_freq = 0; 1811 return; 1812 } 1813 wpa_s->off_channel_freq = 0; 1814 wpa_s->roc_waiting_drv_freq = lwork->freq; 1815} 1816 1817 1818static int wpas_start_listen(void *ctx, unsigned int freq, 1819 unsigned int duration, 1820 const struct wpabuf *probe_resp_ie) 1821{ 1822 struct wpa_supplicant *wpa_s = ctx; 1823 struct wpas_p2p_listen_work *lwork; 1824 1825 if (wpa_s->p2p_listen_work) { 1826 wpa_printf(MSG_DEBUG, "P2P: Reject start_listen since p2p_listen_work already exists"); 1827 return -1; 1828 } 1829 1830 lwork = os_zalloc(sizeof(*lwork)); 1831 if (lwork == NULL) 1832 return -1; 1833 lwork->freq = freq; 1834 lwork->duration = duration; 1835 if (probe_resp_ie) { 1836 lwork->probe_resp_ie = wpabuf_dup(probe_resp_ie); 1837 if (lwork->probe_resp_ie == NULL) { 1838 wpas_p2p_listen_work_free(lwork); 1839 return -1; 1840 } 1841 } 1842 1843 if (radio_add_work(wpa_s, freq, "p2p-listen", 0, wpas_start_listen_cb, 1844 lwork) < 0) { 1845 wpas_p2p_listen_work_free(lwork); 1846 return -1; 1847 } 1848 1849 return 0; 1850} 1851 1852 1853static void wpas_stop_listen(void *ctx) 1854{ 1855 struct wpa_supplicant *wpa_s = ctx; 1856 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) { 1857 wpa_drv_cancel_remain_on_channel(wpa_s); 1858 wpa_s->off_channel_freq = 0; 1859 wpa_s->roc_waiting_drv_freq = 0; 1860 } 1861 wpa_drv_set_ap_wps_ie(wpa_s, NULL, NULL, NULL); 1862 wpa_drv_probe_req_report(wpa_s, 0); 1863 wpas_p2p_listen_work_done(wpa_s); 1864} 1865 1866 1867static int wpas_send_probe_resp(void *ctx, const struct wpabuf *buf) 1868{ 1869 struct wpa_supplicant *wpa_s = ctx; 1870 return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf), 1); 1871} 1872 1873 1874/* 1875 * DNS Header section is used only to calculate compression pointers, so the 1876 * contents of this data does not matter, but the length needs to be reserved 1877 * in the virtual packet. 1878 */ 1879#define DNS_HEADER_LEN 12 1880 1881/* 1882 * 27-octet in-memory packet from P2P specification containing two implied 1883 * queries for _tcp.lcoal. PTR IN and _udp.local. PTR IN 1884 */ 1885#define P2P_SD_IN_MEMORY_LEN 27 1886 1887static int p2p_sd_dns_uncompress_label(char **upos, char *uend, u8 *start, 1888 u8 **spos, const u8 *end) 1889{ 1890 while (*spos < end) { 1891 u8 val = ((*spos)[0] & 0xc0) >> 6; 1892 int len; 1893 1894 if (val == 1 || val == 2) { 1895 /* These are reserved values in RFC 1035 */ 1896 wpa_printf(MSG_DEBUG, "P2P: Invalid domain name " 1897 "sequence starting with 0x%x", val); 1898 return -1; 1899 } 1900 1901 if (val == 3) { 1902 u16 offset; 1903 u8 *spos_tmp; 1904 1905 /* Offset */ 1906 if (*spos + 2 > end) { 1907 wpa_printf(MSG_DEBUG, "P2P: No room for full " 1908 "DNS offset field"); 1909 return -1; 1910 } 1911 1912 offset = (((*spos)[0] & 0x3f) << 8) | (*spos)[1]; 1913 if (offset >= *spos - start) { 1914 wpa_printf(MSG_DEBUG, "P2P: Invalid DNS " 1915 "pointer offset %u", offset); 1916 return -1; 1917 } 1918 1919 (*spos) += 2; 1920 spos_tmp = start + offset; 1921 return p2p_sd_dns_uncompress_label(upos, uend, start, 1922 &spos_tmp, 1923 *spos - 2); 1924 } 1925 1926 /* Label */ 1927 len = (*spos)[0] & 0x3f; 1928 if (len == 0) 1929 return 0; 1930 1931 (*spos)++; 1932 if (*spos + len > end) { 1933 wpa_printf(MSG_DEBUG, "P2P: Invalid domain name " 1934 "sequence - no room for label with length " 1935 "%u", len); 1936 return -1; 1937 } 1938 1939 if (*upos + len + 2 > uend) 1940 return -2; 1941 1942 os_memcpy(*upos, *spos, len); 1943 *spos += len; 1944 *upos += len; 1945 (*upos)[0] = '.'; 1946 (*upos)++; 1947 (*upos)[0] = '\0'; 1948 } 1949 1950 return 0; 1951} 1952 1953 1954/* Uncompress domain names per RFC 1035 using the P2P SD in-memory packet. 1955 * Returns -1 on parsing error (invalid input sequence), -2 if output buffer is 1956 * not large enough */ 1957static int p2p_sd_dns_uncompress(char *buf, size_t buf_len, const u8 *msg, 1958 size_t msg_len, size_t offset) 1959{ 1960 /* 27-octet in-memory packet from P2P specification */ 1961 const char *prefix = "\x04_tcp\x05local\x00\x00\x0C\x00\x01" 1962 "\x04_udp\xC0\x11\x00\x0C\x00\x01"; 1963 u8 *tmp, *end, *spos; 1964 char *upos, *uend; 1965 int ret = 0; 1966 1967 if (buf_len < 2) 1968 return -1; 1969 if (offset > msg_len) 1970 return -1; 1971 1972 tmp = os_malloc(DNS_HEADER_LEN + P2P_SD_IN_MEMORY_LEN + msg_len); 1973 if (tmp == NULL) 1974 return -1; 1975 spos = tmp + DNS_HEADER_LEN + P2P_SD_IN_MEMORY_LEN; 1976 end = spos + msg_len; 1977 spos += offset; 1978 1979 os_memset(tmp, 0, DNS_HEADER_LEN); 1980 os_memcpy(tmp + DNS_HEADER_LEN, prefix, P2P_SD_IN_MEMORY_LEN); 1981 os_memcpy(tmp + DNS_HEADER_LEN + P2P_SD_IN_MEMORY_LEN, msg, msg_len); 1982 1983 upos = buf; 1984 uend = buf + buf_len; 1985 1986 ret = p2p_sd_dns_uncompress_label(&upos, uend, tmp, &spos, end); 1987 if (ret) { 1988 os_free(tmp); 1989 return ret; 1990 } 1991 1992 if (upos == buf) { 1993 upos[0] = '.'; 1994 upos[1] = '\0'; 1995 } else if (upos[-1] == '.') 1996 upos[-1] = '\0'; 1997 1998 os_free(tmp); 1999 return 0; 2000} 2001 2002 2003static struct p2p_srv_bonjour * 2004wpas_p2p_service_get_bonjour(struct wpa_supplicant *wpa_s, 2005 const struct wpabuf *query) 2006{ 2007 struct p2p_srv_bonjour *bsrv; 2008 size_t len; 2009 2010 len = wpabuf_len(query); 2011 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour, 2012 struct p2p_srv_bonjour, list) { 2013 if (len == wpabuf_len(bsrv->query) && 2014 os_memcmp(wpabuf_head(query), wpabuf_head(bsrv->query), 2015 len) == 0) 2016 return bsrv; 2017 } 2018 return NULL; 2019} 2020 2021 2022static struct p2p_srv_upnp * 2023wpas_p2p_service_get_upnp(struct wpa_supplicant *wpa_s, u8 version, 2024 const char *service) 2025{ 2026 struct p2p_srv_upnp *usrv; 2027 2028 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp, 2029 struct p2p_srv_upnp, list) { 2030 if (version == usrv->version && 2031 os_strcmp(service, usrv->service) == 0) 2032 return usrv; 2033 } 2034 return NULL; 2035} 2036 2037 2038static void wpas_sd_add_proto_not_avail(struct wpabuf *resp, u8 srv_proto, 2039 u8 srv_trans_id) 2040{ 2041 u8 *len_pos; 2042 2043 if (wpabuf_tailroom(resp) < 5) 2044 return; 2045 2046 /* Length (to be filled) */ 2047 len_pos = wpabuf_put(resp, 2); 2048 wpabuf_put_u8(resp, srv_proto); 2049 wpabuf_put_u8(resp, srv_trans_id); 2050 /* Status Code */ 2051 wpabuf_put_u8(resp, P2P_SD_PROTO_NOT_AVAILABLE); 2052 /* Response Data: empty */ 2053 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2); 2054} 2055 2056 2057static void wpas_sd_all_bonjour(struct wpa_supplicant *wpa_s, 2058 struct wpabuf *resp, u8 srv_trans_id) 2059{ 2060 struct p2p_srv_bonjour *bsrv; 2061 u8 *len_pos; 2062 2063 wpa_printf(MSG_DEBUG, "P2P: SD Request for all Bonjour services"); 2064 2065 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) { 2066 wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available"); 2067 return; 2068 } 2069 2070 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour, 2071 struct p2p_srv_bonjour, list) { 2072 if (wpabuf_tailroom(resp) < 2073 5 + wpabuf_len(bsrv->query) + wpabuf_len(bsrv->resp)) 2074 return; 2075 /* Length (to be filled) */ 2076 len_pos = wpabuf_put(resp, 2); 2077 wpabuf_put_u8(resp, P2P_SERV_BONJOUR); 2078 wpabuf_put_u8(resp, srv_trans_id); 2079 /* Status Code */ 2080 wpabuf_put_u8(resp, P2P_SD_SUCCESS); 2081 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service", 2082 wpabuf_head(bsrv->resp), 2083 wpabuf_len(bsrv->resp)); 2084 /* Response Data */ 2085 wpabuf_put_buf(resp, bsrv->query); /* Key */ 2086 wpabuf_put_buf(resp, bsrv->resp); /* Value */ 2087 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2088 2); 2089 } 2090} 2091 2092 2093static int match_bonjour_query(struct p2p_srv_bonjour *bsrv, const u8 *query, 2094 size_t query_len) 2095{ 2096 char str_rx[256], str_srv[256]; 2097 2098 if (query_len < 3 || wpabuf_len(bsrv->query) < 3) 2099 return 0; /* Too short to include DNS Type and Version */ 2100 if (os_memcmp(query + query_len - 3, 2101 wpabuf_head_u8(bsrv->query) + wpabuf_len(bsrv->query) - 3, 2102 3) != 0) 2103 return 0; /* Mismatch in DNS Type or Version */ 2104 if (query_len == wpabuf_len(bsrv->query) && 2105 os_memcmp(query, wpabuf_head(bsrv->query), query_len - 3) == 0) 2106 return 1; /* Binary match */ 2107 2108 if (p2p_sd_dns_uncompress(str_rx, sizeof(str_rx), query, query_len - 3, 2109 0)) 2110 return 0; /* Failed to uncompress query */ 2111 if (p2p_sd_dns_uncompress(str_srv, sizeof(str_srv), 2112 wpabuf_head(bsrv->query), 2113 wpabuf_len(bsrv->query) - 3, 0)) 2114 return 0; /* Failed to uncompress service */ 2115 2116 return os_strcmp(str_rx, str_srv) == 0; 2117} 2118 2119 2120static void wpas_sd_req_bonjour(struct wpa_supplicant *wpa_s, 2121 struct wpabuf *resp, u8 srv_trans_id, 2122 const u8 *query, size_t query_len) 2123{ 2124 struct p2p_srv_bonjour *bsrv; 2125 u8 *len_pos; 2126 int matches = 0; 2127 2128 wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for Bonjour", 2129 query, query_len); 2130 if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) { 2131 wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available"); 2132 wpas_sd_add_proto_not_avail(resp, P2P_SERV_BONJOUR, 2133 srv_trans_id); 2134 return; 2135 } 2136 2137 if (query_len == 0) { 2138 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id); 2139 return; 2140 } 2141 2142 dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour, 2143 struct p2p_srv_bonjour, list) { 2144 if (!match_bonjour_query(bsrv, query, query_len)) 2145 continue; 2146 2147 if (wpabuf_tailroom(resp) < 2148 5 + query_len + wpabuf_len(bsrv->resp)) 2149 return; 2150 2151 matches++; 2152 2153 /* Length (to be filled) */ 2154 len_pos = wpabuf_put(resp, 2); 2155 wpabuf_put_u8(resp, P2P_SERV_BONJOUR); 2156 wpabuf_put_u8(resp, srv_trans_id); 2157 2158 /* Status Code */ 2159 wpabuf_put_u8(resp, P2P_SD_SUCCESS); 2160 wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service", 2161 wpabuf_head(bsrv->resp), 2162 wpabuf_len(bsrv->resp)); 2163 2164 /* Response Data */ 2165 wpabuf_put_data(resp, query, query_len); /* Key */ 2166 wpabuf_put_buf(resp, bsrv->resp); /* Value */ 2167 2168 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2); 2169 } 2170 2171 if (matches == 0) { 2172 wpa_printf(MSG_DEBUG, "P2P: Requested Bonjour service not " 2173 "available"); 2174 if (wpabuf_tailroom(resp) < 5) 2175 return; 2176 2177 /* Length (to be filled) */ 2178 len_pos = wpabuf_put(resp, 2); 2179 wpabuf_put_u8(resp, P2P_SERV_BONJOUR); 2180 wpabuf_put_u8(resp, srv_trans_id); 2181 2182 /* Status Code */ 2183 wpabuf_put_u8(resp, P2P_SD_REQUESTED_INFO_NOT_AVAILABLE); 2184 /* Response Data: empty */ 2185 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2186 2); 2187 } 2188} 2189 2190 2191static void wpas_sd_all_upnp(struct wpa_supplicant *wpa_s, 2192 struct wpabuf *resp, u8 srv_trans_id) 2193{ 2194 struct p2p_srv_upnp *usrv; 2195 u8 *len_pos; 2196 2197 wpa_printf(MSG_DEBUG, "P2P: SD Request for all UPnP services"); 2198 2199 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) { 2200 wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available"); 2201 return; 2202 } 2203 2204 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp, 2205 struct p2p_srv_upnp, list) { 2206 if (wpabuf_tailroom(resp) < 5 + 1 + os_strlen(usrv->service)) 2207 return; 2208 2209 /* Length (to be filled) */ 2210 len_pos = wpabuf_put(resp, 2); 2211 wpabuf_put_u8(resp, P2P_SERV_UPNP); 2212 wpabuf_put_u8(resp, srv_trans_id); 2213 2214 /* Status Code */ 2215 wpabuf_put_u8(resp, P2P_SD_SUCCESS); 2216 /* Response Data */ 2217 wpabuf_put_u8(resp, usrv->version); 2218 wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s", 2219 usrv->service); 2220 wpabuf_put_str(resp, usrv->service); 2221 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2222 2); 2223 } 2224} 2225 2226 2227static void wpas_sd_req_upnp(struct wpa_supplicant *wpa_s, 2228 struct wpabuf *resp, u8 srv_trans_id, 2229 const u8 *query, size_t query_len) 2230{ 2231 struct p2p_srv_upnp *usrv; 2232 u8 *len_pos; 2233 u8 version; 2234 char *str; 2235 int count = 0; 2236 2237 wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for UPnP", 2238 query, query_len); 2239 2240 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) { 2241 wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available"); 2242 wpas_sd_add_proto_not_avail(resp, P2P_SERV_UPNP, 2243 srv_trans_id); 2244 return; 2245 } 2246 2247 if (query_len == 0) { 2248 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id); 2249 return; 2250 } 2251 2252 if (wpabuf_tailroom(resp) < 5) 2253 return; 2254 2255 /* Length (to be filled) */ 2256 len_pos = wpabuf_put(resp, 2); 2257 wpabuf_put_u8(resp, P2P_SERV_UPNP); 2258 wpabuf_put_u8(resp, srv_trans_id); 2259 2260 version = query[0]; 2261 str = os_malloc(query_len); 2262 if (str == NULL) 2263 return; 2264 os_memcpy(str, query + 1, query_len - 1); 2265 str[query_len - 1] = '\0'; 2266 2267 dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp, 2268 struct p2p_srv_upnp, list) { 2269 if (version != usrv->version) 2270 continue; 2271 2272 if (os_strcmp(str, "ssdp:all") != 0 && 2273 os_strstr(usrv->service, str) == NULL) 2274 continue; 2275 2276 if (wpabuf_tailroom(resp) < 2) 2277 break; 2278 if (count == 0) { 2279 /* Status Code */ 2280 wpabuf_put_u8(resp, P2P_SD_SUCCESS); 2281 /* Response Data */ 2282 wpabuf_put_u8(resp, version); 2283 } else 2284 wpabuf_put_u8(resp, ','); 2285 2286 count++; 2287 2288 wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s", 2289 usrv->service); 2290 if (wpabuf_tailroom(resp) < os_strlen(usrv->service)) 2291 break; 2292 wpabuf_put_str(resp, usrv->service); 2293 } 2294 os_free(str); 2295 2296 if (count == 0) { 2297 wpa_printf(MSG_DEBUG, "P2P: Requested UPnP service not " 2298 "available"); 2299 /* Status Code */ 2300 wpabuf_put_u8(resp, P2P_SD_REQUESTED_INFO_NOT_AVAILABLE); 2301 /* Response Data: empty */ 2302 } 2303 2304 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2); 2305} 2306 2307 2308#ifdef CONFIG_WIFI_DISPLAY 2309static void wpas_sd_req_wfd(struct wpa_supplicant *wpa_s, 2310 struct wpabuf *resp, u8 srv_trans_id, 2311 const u8 *query, size_t query_len) 2312{ 2313 const u8 *pos; 2314 u8 role; 2315 u8 *len_pos; 2316 2317 wpa_hexdump(MSG_DEBUG, "P2P: SD Request for WFD", query, query_len); 2318 2319 if (!wpa_s->global->wifi_display) { 2320 wpa_printf(MSG_DEBUG, "P2P: WFD protocol not available"); 2321 wpas_sd_add_proto_not_avail(resp, P2P_SERV_WIFI_DISPLAY, 2322 srv_trans_id); 2323 return; 2324 } 2325 2326 if (query_len < 1) { 2327 wpa_printf(MSG_DEBUG, "P2P: Missing WFD Requested Device " 2328 "Role"); 2329 return; 2330 } 2331 2332 if (wpabuf_tailroom(resp) < 5) 2333 return; 2334 2335 pos = query; 2336 role = *pos++; 2337 wpa_printf(MSG_DEBUG, "P2P: WSD for device role 0x%x", role); 2338 2339 /* TODO: role specific handling */ 2340 2341 /* Length (to be filled) */ 2342 len_pos = wpabuf_put(resp, 2); 2343 wpabuf_put_u8(resp, P2P_SERV_WIFI_DISPLAY); 2344 wpabuf_put_u8(resp, srv_trans_id); 2345 wpabuf_put_u8(resp, P2P_SD_SUCCESS); /* Status Code */ 2346 2347 while (pos < query + query_len) { 2348 if (*pos < MAX_WFD_SUBELEMS && 2349 wpa_s->global->wfd_subelem[*pos] && 2350 wpabuf_tailroom(resp) >= 2351 wpabuf_len(wpa_s->global->wfd_subelem[*pos])) { 2352 wpa_printf(MSG_DEBUG, "P2P: Add WSD response " 2353 "subelement %u", *pos); 2354 wpabuf_put_buf(resp, wpa_s->global->wfd_subelem[*pos]); 2355 } 2356 pos++; 2357 } 2358 2359 WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2); 2360} 2361#endif /* CONFIG_WIFI_DISPLAY */ 2362 2363 2364static void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token, 2365 u16 update_indic, const u8 *tlvs, size_t tlvs_len) 2366{ 2367 struct wpa_supplicant *wpa_s = ctx; 2368 const u8 *pos = tlvs; 2369 const u8 *end = tlvs + tlvs_len; 2370 const u8 *tlv_end; 2371 u16 slen; 2372 struct wpabuf *resp; 2373 u8 srv_proto, srv_trans_id; 2374 size_t buf_len; 2375 char *buf; 2376 2377 wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Request TLVs", 2378 tlvs, tlvs_len); 2379 buf_len = 2 * tlvs_len + 1; 2380 buf = os_malloc(buf_len); 2381 if (buf) { 2382 wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len); 2383 wpa_msg_ctrl(wpa_s, MSG_INFO, P2P_EVENT_SERV_DISC_REQ "%d " 2384 MACSTR " %u %u %s", 2385 freq, MAC2STR(sa), dialog_token, update_indic, 2386 buf); 2387 os_free(buf); 2388 } 2389 2390 if (wpa_s->p2p_sd_over_ctrl_iface) { 2391 wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token, 2392 update_indic, tlvs, tlvs_len); 2393 return; /* to be processed by an external program */ 2394 } 2395 2396 resp = wpabuf_alloc(10000); 2397 if (resp == NULL) 2398 return; 2399 2400 while (pos + 1 < end) { 2401 wpa_printf(MSG_DEBUG, "P2P: Service Request TLV"); 2402 slen = WPA_GET_LE16(pos); 2403 pos += 2; 2404 if (pos + slen > end || slen < 2) { 2405 wpa_printf(MSG_DEBUG, "P2P: Unexpected Query Data " 2406 "length"); 2407 wpabuf_free(resp); 2408 return; 2409 } 2410 tlv_end = pos + slen; 2411 2412 srv_proto = *pos++; 2413 wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u", 2414 srv_proto); 2415 srv_trans_id = *pos++; 2416 wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u", 2417 srv_trans_id); 2418 2419 wpa_hexdump(MSG_MSGDUMP, "P2P: Query Data", 2420 pos, tlv_end - pos); 2421 2422 2423 if (wpa_s->force_long_sd) { 2424 wpa_printf(MSG_DEBUG, "P2P: SD test - force long " 2425 "response"); 2426 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id); 2427 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id); 2428 goto done; 2429 } 2430 2431 switch (srv_proto) { 2432 case P2P_SERV_ALL_SERVICES: 2433 wpa_printf(MSG_DEBUG, "P2P: Service Discovery Request " 2434 "for all services"); 2435 if (dl_list_empty(&wpa_s->global->p2p_srv_upnp) && 2436 dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) { 2437 wpa_printf(MSG_DEBUG, "P2P: No service " 2438 "discovery protocols available"); 2439 wpas_sd_add_proto_not_avail( 2440 resp, P2P_SERV_ALL_SERVICES, 2441 srv_trans_id); 2442 break; 2443 } 2444 wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id); 2445 wpas_sd_all_upnp(wpa_s, resp, srv_trans_id); 2446 break; 2447 case P2P_SERV_BONJOUR: 2448 wpas_sd_req_bonjour(wpa_s, resp, srv_trans_id, 2449 pos, tlv_end - pos); 2450 break; 2451 case P2P_SERV_UPNP: 2452 wpas_sd_req_upnp(wpa_s, resp, srv_trans_id, 2453 pos, tlv_end - pos); 2454 break; 2455#ifdef CONFIG_WIFI_DISPLAY 2456 case P2P_SERV_WIFI_DISPLAY: 2457 wpas_sd_req_wfd(wpa_s, resp, srv_trans_id, 2458 pos, tlv_end - pos); 2459 break; 2460#endif /* CONFIG_WIFI_DISPLAY */ 2461 default: 2462 wpa_printf(MSG_DEBUG, "P2P: Unavailable service " 2463 "protocol %u", srv_proto); 2464 wpas_sd_add_proto_not_avail(resp, srv_proto, 2465 srv_trans_id); 2466 break; 2467 } 2468 2469 pos = tlv_end; 2470 } 2471 2472done: 2473 wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token, 2474 update_indic, tlvs, tlvs_len); 2475 2476 wpas_p2p_sd_response(wpa_s, freq, sa, dialog_token, resp); 2477 2478 wpabuf_free(resp); 2479} 2480 2481 2482static void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic, 2483 const u8 *tlvs, size_t tlvs_len) 2484{ 2485 struct wpa_supplicant *wpa_s = ctx; 2486 const u8 *pos = tlvs; 2487 const u8 *end = tlvs + tlvs_len; 2488 const u8 *tlv_end; 2489 u16 slen; 2490 size_t buf_len; 2491 char *buf; 2492 2493 wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Response TLVs", 2494 tlvs, tlvs_len); 2495 if (tlvs_len > 1500) { 2496 /* TODO: better way for handling this */ 2497 wpa_msg_ctrl(wpa_s, MSG_INFO, 2498 P2P_EVENT_SERV_DISC_RESP MACSTR 2499 " %u <long response: %u bytes>", 2500 MAC2STR(sa), update_indic, 2501 (unsigned int) tlvs_len); 2502 } else { 2503 buf_len = 2 * tlvs_len + 1; 2504 buf = os_malloc(buf_len); 2505 if (buf) { 2506 wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len); 2507 wpa_msg_ctrl(wpa_s, MSG_INFO, 2508 P2P_EVENT_SERV_DISC_RESP MACSTR " %u %s", 2509 MAC2STR(sa), update_indic, buf); 2510 os_free(buf); 2511 } 2512 } 2513 2514 while (pos < end) { 2515 u8 srv_proto, srv_trans_id, status; 2516 2517 wpa_printf(MSG_DEBUG, "P2P: Service Response TLV"); 2518 slen = WPA_GET_LE16(pos); 2519 pos += 2; 2520 if (pos + slen > end || slen < 3) { 2521 wpa_printf(MSG_DEBUG, "P2P: Unexpected Response Data " 2522 "length"); 2523 return; 2524 } 2525 tlv_end = pos + slen; 2526 2527 srv_proto = *pos++; 2528 wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u", 2529 srv_proto); 2530 srv_trans_id = *pos++; 2531 wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u", 2532 srv_trans_id); 2533 status = *pos++; 2534 wpa_printf(MSG_DEBUG, "P2P: Status Code ID %u", 2535 status); 2536 2537 wpa_hexdump(MSG_MSGDUMP, "P2P: Response Data", 2538 pos, tlv_end - pos); 2539 2540 pos = tlv_end; 2541 } 2542 2543 wpas_notify_p2p_sd_response(wpa_s, sa, update_indic, tlvs, tlvs_len); 2544} 2545 2546 2547u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst, 2548 const struct wpabuf *tlvs) 2549{ 2550 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 2551 return 0; 2552 return (uintptr_t) p2p_sd_request(wpa_s->global->p2p, dst, tlvs); 2553} 2554 2555 2556u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst, 2557 u8 version, const char *query) 2558{ 2559 struct wpabuf *tlvs; 2560 u64 ret; 2561 2562 tlvs = wpabuf_alloc(2 + 1 + 1 + 1 + os_strlen(query)); 2563 if (tlvs == NULL) 2564 return 0; 2565 wpabuf_put_le16(tlvs, 1 + 1 + 1 + os_strlen(query)); 2566 wpabuf_put_u8(tlvs, P2P_SERV_UPNP); /* Service Protocol Type */ 2567 wpabuf_put_u8(tlvs, 1); /* Service Transaction ID */ 2568 wpabuf_put_u8(tlvs, version); 2569 wpabuf_put_str(tlvs, query); 2570 ret = wpas_p2p_sd_request(wpa_s, dst, tlvs); 2571 wpabuf_free(tlvs); 2572 return ret; 2573} 2574 2575 2576#ifdef CONFIG_WIFI_DISPLAY 2577 2578static u64 wpas_p2p_sd_request_wfd(struct wpa_supplicant *wpa_s, const u8 *dst, 2579 const struct wpabuf *tlvs) 2580{ 2581 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 2582 return 0; 2583 return (uintptr_t) p2p_sd_request_wfd(wpa_s->global->p2p, dst, tlvs); 2584} 2585 2586 2587#define MAX_WFD_SD_SUBELEMS 20 2588 2589static void wfd_add_sd_req_role(struct wpabuf *tlvs, u8 id, u8 role, 2590 const char *subelems) 2591{ 2592 u8 *len; 2593 const char *pos; 2594 int val; 2595 int count = 0; 2596 2597 len = wpabuf_put(tlvs, 2); 2598 wpabuf_put_u8(tlvs, P2P_SERV_WIFI_DISPLAY); /* Service Protocol Type */ 2599 wpabuf_put_u8(tlvs, id); /* Service Transaction ID */ 2600 2601 wpabuf_put_u8(tlvs, role); 2602 2603 pos = subelems; 2604 while (*pos) { 2605 val = atoi(pos); 2606 if (val >= 0 && val < 256) { 2607 wpabuf_put_u8(tlvs, val); 2608 count++; 2609 if (count == MAX_WFD_SD_SUBELEMS) 2610 break; 2611 } 2612 pos = os_strchr(pos + 1, ','); 2613 if (pos == NULL) 2614 break; 2615 pos++; 2616 } 2617 2618 WPA_PUT_LE16(len, (u8 *) wpabuf_put(tlvs, 0) - len - 2); 2619} 2620 2621 2622u64 wpas_p2p_sd_request_wifi_display(struct wpa_supplicant *wpa_s, 2623 const u8 *dst, const char *role) 2624{ 2625 struct wpabuf *tlvs; 2626 u64 ret; 2627 const char *subelems; 2628 u8 id = 1; 2629 2630 subelems = os_strchr(role, ' '); 2631 if (subelems == NULL) 2632 return 0; 2633 subelems++; 2634 2635 tlvs = wpabuf_alloc(4 * (2 + 1 + 1 + 1 + MAX_WFD_SD_SUBELEMS)); 2636 if (tlvs == NULL) 2637 return 0; 2638 2639 if (os_strstr(role, "[source]")) 2640 wfd_add_sd_req_role(tlvs, id++, 0x00, subelems); 2641 if (os_strstr(role, "[pri-sink]")) 2642 wfd_add_sd_req_role(tlvs, id++, 0x01, subelems); 2643 if (os_strstr(role, "[sec-sink]")) 2644 wfd_add_sd_req_role(tlvs, id++, 0x02, subelems); 2645 if (os_strstr(role, "[source+sink]")) 2646 wfd_add_sd_req_role(tlvs, id++, 0x03, subelems); 2647 2648 ret = wpas_p2p_sd_request_wfd(wpa_s, dst, tlvs); 2649 wpabuf_free(tlvs); 2650 return ret; 2651} 2652 2653#endif /* CONFIG_WIFI_DISPLAY */ 2654 2655 2656int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, u64 req) 2657{ 2658 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 2659 return -1; 2660 return p2p_sd_cancel_request(wpa_s->global->p2p, 2661 (void *) (uintptr_t) req); 2662} 2663 2664 2665void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq, 2666 const u8 *dst, u8 dialog_token, 2667 const struct wpabuf *resp_tlvs) 2668{ 2669 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 2670 return; 2671 p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token, 2672 resp_tlvs); 2673} 2674 2675 2676void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s) 2677{ 2678 if (wpa_s->global->p2p) 2679 p2p_sd_service_update(wpa_s->global->p2p); 2680} 2681 2682 2683static void wpas_p2p_srv_bonjour_free(struct p2p_srv_bonjour *bsrv) 2684{ 2685 dl_list_del(&bsrv->list); 2686 wpabuf_free(bsrv->query); 2687 wpabuf_free(bsrv->resp); 2688 os_free(bsrv); 2689} 2690 2691 2692static void wpas_p2p_srv_upnp_free(struct p2p_srv_upnp *usrv) 2693{ 2694 dl_list_del(&usrv->list); 2695 os_free(usrv->service); 2696 os_free(usrv); 2697} 2698 2699 2700void wpas_p2p_service_flush(struct wpa_supplicant *wpa_s) 2701{ 2702 struct p2p_srv_bonjour *bsrv, *bn; 2703 struct p2p_srv_upnp *usrv, *un; 2704 2705 dl_list_for_each_safe(bsrv, bn, &wpa_s->global->p2p_srv_bonjour, 2706 struct p2p_srv_bonjour, list) 2707 wpas_p2p_srv_bonjour_free(bsrv); 2708 2709 dl_list_for_each_safe(usrv, un, &wpa_s->global->p2p_srv_upnp, 2710 struct p2p_srv_upnp, list) 2711 wpas_p2p_srv_upnp_free(usrv); 2712 2713 wpas_p2p_sd_service_update(wpa_s); 2714} 2715 2716 2717int wpas_p2p_service_add_bonjour(struct wpa_supplicant *wpa_s, 2718 struct wpabuf *query, struct wpabuf *resp) 2719{ 2720 struct p2p_srv_bonjour *bsrv; 2721 2722 bsrv = os_zalloc(sizeof(*bsrv)); 2723 if (bsrv == NULL) 2724 return -1; 2725 bsrv->query = query; 2726 bsrv->resp = resp; 2727 dl_list_add(&wpa_s->global->p2p_srv_bonjour, &bsrv->list); 2728 2729 wpas_p2p_sd_service_update(wpa_s); 2730 return 0; 2731} 2732 2733 2734int wpas_p2p_service_del_bonjour(struct wpa_supplicant *wpa_s, 2735 const struct wpabuf *query) 2736{ 2737 struct p2p_srv_bonjour *bsrv; 2738 2739 bsrv = wpas_p2p_service_get_bonjour(wpa_s, query); 2740 if (bsrv == NULL) 2741 return -1; 2742 wpas_p2p_srv_bonjour_free(bsrv); 2743 wpas_p2p_sd_service_update(wpa_s); 2744 return 0; 2745} 2746 2747 2748int wpas_p2p_service_add_upnp(struct wpa_supplicant *wpa_s, u8 version, 2749 const char *service) 2750{ 2751 struct p2p_srv_upnp *usrv; 2752 2753 if (wpas_p2p_service_get_upnp(wpa_s, version, service)) 2754 return 0; /* Already listed */ 2755 usrv = os_zalloc(sizeof(*usrv)); 2756 if (usrv == NULL) 2757 return -1; 2758 usrv->version = version; 2759 usrv->service = os_strdup(service); 2760 if (usrv->service == NULL) { 2761 os_free(usrv); 2762 return -1; 2763 } 2764 dl_list_add(&wpa_s->global->p2p_srv_upnp, &usrv->list); 2765 2766 wpas_p2p_sd_service_update(wpa_s); 2767 return 0; 2768} 2769 2770 2771int wpas_p2p_service_del_upnp(struct wpa_supplicant *wpa_s, u8 version, 2772 const char *service) 2773{ 2774 struct p2p_srv_upnp *usrv; 2775 2776 usrv = wpas_p2p_service_get_upnp(wpa_s, version, service); 2777 if (usrv == NULL) 2778 return -1; 2779 wpas_p2p_srv_upnp_free(usrv); 2780 wpas_p2p_sd_service_update(wpa_s); 2781 return 0; 2782} 2783 2784 2785static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s, 2786 const u8 *peer, const char *params, 2787 unsigned int generated_pin) 2788{ 2789 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR 2790 " %08d%s", MAC2STR(peer), generated_pin, params); 2791} 2792 2793 2794static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s, 2795 const u8 *peer, const char *params) 2796{ 2797 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR 2798 "%s", MAC2STR(peer), params); 2799} 2800 2801 2802static void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods, 2803 const u8 *dev_addr, const u8 *pri_dev_type, 2804 const char *dev_name, u16 supp_config_methods, 2805 u8 dev_capab, u8 group_capab, const u8 *group_id, 2806 size_t group_id_len) 2807{ 2808 struct wpa_supplicant *wpa_s = ctx; 2809 char devtype[WPS_DEV_TYPE_BUFSIZE]; 2810 char params[300]; 2811 u8 empty_dev_type[8]; 2812 unsigned int generated_pin = 0; 2813 struct wpa_supplicant *group = NULL; 2814 2815 if (group_id) { 2816 for (group = wpa_s->global->ifaces; group; group = group->next) 2817 { 2818 struct wpa_ssid *s = group->current_ssid; 2819 if (s != NULL && 2820 s->mode == WPAS_MODE_P2P_GO && 2821 group_id_len - ETH_ALEN == s->ssid_len && 2822 os_memcmp(group_id + ETH_ALEN, s->ssid, 2823 s->ssid_len) == 0) 2824 break; 2825 } 2826 } 2827 2828 if (pri_dev_type == NULL) { 2829 os_memset(empty_dev_type, 0, sizeof(empty_dev_type)); 2830 pri_dev_type = empty_dev_type; 2831 } 2832 os_snprintf(params, sizeof(params), " p2p_dev_addr=" MACSTR 2833 " pri_dev_type=%s name='%s' config_methods=0x%x " 2834 "dev_capab=0x%x group_capab=0x%x%s%s", 2835 MAC2STR(dev_addr), 2836 wps_dev_type_bin2str(pri_dev_type, devtype, 2837 sizeof(devtype)), 2838 dev_name, supp_config_methods, dev_capab, group_capab, 2839 group ? " group=" : "", 2840 group ? group->ifname : ""); 2841 params[sizeof(params) - 1] = '\0'; 2842 2843 if (config_methods & WPS_CONFIG_DISPLAY) { 2844 generated_pin = wps_generate_pin(); 2845 wpas_prov_disc_local_display(wpa_s, peer, params, 2846 generated_pin); 2847 } else if (config_methods & WPS_CONFIG_KEYPAD) 2848 wpas_prov_disc_local_keypad(wpa_s, peer, params); 2849 else if (config_methods & WPS_CONFIG_PUSHBUTTON) 2850 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ 2851 MACSTR "%s", MAC2STR(peer), params); 2852 2853 wpas_notify_p2p_provision_discovery(wpa_s, peer, 1 /* request */, 2854 P2P_PROV_DISC_SUCCESS, 2855 config_methods, generated_pin); 2856} 2857 2858 2859static void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods) 2860{ 2861 struct wpa_supplicant *wpa_s = ctx; 2862 unsigned int generated_pin = 0; 2863 char params[20]; 2864 2865 if (wpa_s->pending_pd_before_join && 2866 (os_memcmp(peer, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 || 2867 os_memcmp(peer, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) { 2868 wpa_s->pending_pd_before_join = 0; 2869 wpa_printf(MSG_DEBUG, "P2P: Starting pending " 2870 "join-existing-group operation"); 2871 wpas_p2p_join_start(wpa_s, 0, NULL, 0); 2872 return; 2873 } 2874 2875 if (wpa_s->pending_pd_use == AUTO_PD_JOIN || 2876 wpa_s->pending_pd_use == AUTO_PD_GO_NEG) 2877 os_snprintf(params, sizeof(params), " peer_go=%d", 2878 wpa_s->pending_pd_use == AUTO_PD_JOIN); 2879 else 2880 params[0] = '\0'; 2881 2882 if (config_methods & WPS_CONFIG_DISPLAY) 2883 wpas_prov_disc_local_keypad(wpa_s, peer, params); 2884 else if (config_methods & WPS_CONFIG_KEYPAD) { 2885 generated_pin = wps_generate_pin(); 2886 wpas_prov_disc_local_display(wpa_s, peer, params, 2887 generated_pin); 2888 } else if (config_methods & WPS_CONFIG_PUSHBUTTON) 2889 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP 2890 MACSTR "%s", MAC2STR(peer), params); 2891 2892 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */, 2893 P2P_PROV_DISC_SUCCESS, 2894 config_methods, generated_pin); 2895} 2896 2897 2898static void wpas_prov_disc_fail(void *ctx, const u8 *peer, 2899 enum p2p_prov_disc_status status) 2900{ 2901 struct wpa_supplicant *wpa_s = ctx; 2902 2903 if (wpa_s->p2p_fallback_to_go_neg) { 2904 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto " 2905 "failed - fall back to GO Negotiation"); 2906 wpas_p2p_fallback_to_go_neg(wpa_s, 0); 2907 return; 2908 } 2909 2910 if (status == P2P_PROV_DISC_TIMEOUT_JOIN) { 2911 wpa_s->pending_pd_before_join = 0; 2912 wpa_printf(MSG_DEBUG, "P2P: Starting pending " 2913 "join-existing-group operation (no ACK for PD " 2914 "Req attempts)"); 2915 wpas_p2p_join_start(wpa_s, 0, NULL, 0); 2916 return; 2917 } 2918 2919 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE 2920 " p2p_dev_addr=" MACSTR " status=%d", 2921 MAC2STR(peer), status); 2922 2923 wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */, 2924 status, 0, 0); 2925} 2926 2927 2928static int freq_included(const struct p2p_channels *channels, unsigned int freq) 2929{ 2930 if (channels == NULL) 2931 return 1; /* Assume no restrictions */ 2932 return p2p_channels_includes_freq(channels, freq); 2933 2934} 2935 2936 2937/** 2938 * Pick the best frequency to use from all the currently used frequencies. 2939 */ 2940static int wpas_p2p_pick_best_used_freq(struct wpa_supplicant *wpa_s, 2941 struct wpa_used_freq_data *freqs, 2942 unsigned int num) 2943{ 2944 unsigned int i, c; 2945 2946 /* find a candidate freq that is supported by P2P */ 2947 for (c = 0; c < num; c++) 2948 if (p2p_supported_freq(wpa_s->global->p2p, freqs[c].freq)) 2949 break; 2950 2951 if (c == num) 2952 return 0; 2953 2954 /* once we have a candidate, try to find a 'better' one */ 2955 for (i = c + 1; i < num; i++) { 2956 if (!p2p_supported_freq(wpa_s->global->p2p, freqs[i].freq)) 2957 continue; 2958 2959 /* 2960 * 1. Infrastructure station interfaces have higher preference. 2961 * 2. P2P Clients have higher preference. 2962 * 3. All others. 2963 */ 2964 if (freqs[i].flags & WPA_FREQ_USED_BY_INFRA_STATION) { 2965 c = i; 2966 break; 2967 } 2968 2969 if ((freqs[i].flags & WPA_FREQ_USED_BY_P2P_CLIENT)) 2970 c = i; 2971 } 2972 return freqs[c].freq; 2973} 2974 2975 2976static u8 wpas_invitation_process(void *ctx, const u8 *sa, const u8 *bssid, 2977 const u8 *go_dev_addr, const u8 *ssid, 2978 size_t ssid_len, int *go, u8 *group_bssid, 2979 int *force_freq, int persistent_group, 2980 const struct p2p_channels *channels, 2981 int dev_pw_id) 2982{ 2983 struct wpa_supplicant *wpa_s = ctx; 2984 struct wpa_ssid *s; 2985 struct wpa_used_freq_data *freqs; 2986 struct wpa_supplicant *grp; 2987 int best_freq; 2988 2989 if (!persistent_group) { 2990 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR 2991 " to join an active group (SSID: %s)", 2992 MAC2STR(sa), wpa_ssid_txt(ssid, ssid_len)); 2993 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) && 2994 (os_memcmp(go_dev_addr, wpa_s->p2p_auth_invite, ETH_ALEN) 2995 == 0 || 2996 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0)) { 2997 wpa_printf(MSG_DEBUG, "P2P: Accept previously " 2998 "authorized invitation"); 2999 goto accept_inv; 3000 } 3001 3002#ifdef CONFIG_WPS_NFC 3003 if (dev_pw_id >= 0 && wpa_s->parent->p2p_nfc_tag_enabled && 3004 dev_pw_id == wpa_s->parent->p2p_oob_dev_pw_id) { 3005 wpa_printf(MSG_DEBUG, "P2P: Accept invitation based on local enabled NFC Tag"); 3006 wpa_s->parent->p2p_wps_method = WPS_NFC; 3007 wpa_s->parent->pending_join_wps_method = WPS_NFC; 3008 os_memcpy(wpa_s->parent->pending_join_dev_addr, 3009 go_dev_addr, ETH_ALEN); 3010 os_memcpy(wpa_s->parent->pending_join_iface_addr, 3011 bssid, ETH_ALEN); 3012 goto accept_inv; 3013 } 3014#endif /* CONFIG_WPS_NFC */ 3015 3016 /* 3017 * Do not accept the invitation automatically; notify user and 3018 * request approval. 3019 */ 3020 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE; 3021 } 3022 3023 grp = wpas_get_p2p_group(wpa_s, ssid, ssid_len, go); 3024 if (grp) { 3025 wpa_printf(MSG_DEBUG, "P2P: Accept invitation to already " 3026 "running persistent group"); 3027 if (*go) 3028 os_memcpy(group_bssid, grp->own_addr, ETH_ALEN); 3029 goto accept_inv; 3030 } 3031 3032 if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) && 3033 os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0) { 3034 wpa_printf(MSG_DEBUG, "P2P: Accept previously initiated " 3035 "invitation to re-invoke a persistent group"); 3036 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN); 3037 } else if (!wpa_s->conf->persistent_reconnect) 3038 return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE; 3039 3040 for (s = wpa_s->conf->ssid; s; s = s->next) { 3041 if (s->disabled == 2 && 3042 os_memcmp(s->bssid, go_dev_addr, ETH_ALEN) == 0 && 3043 s->ssid_len == ssid_len && 3044 os_memcmp(ssid, s->ssid, ssid_len) == 0) 3045 break; 3046 } 3047 3048 if (!s) { 3049 wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR 3050 " requested reinvocation of an unknown group", 3051 MAC2STR(sa)); 3052 return P2P_SC_FAIL_UNKNOWN_GROUP; 3053 } 3054 3055 if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) { 3056 *go = 1; 3057 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) { 3058 wpa_printf(MSG_DEBUG, "P2P: The only available " 3059 "interface is already in use - reject " 3060 "invitation"); 3061 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE; 3062 } 3063 os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN); 3064 } else if (s->mode == WPAS_MODE_P2P_GO) { 3065 *go = 1; 3066 if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0) 3067 { 3068 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new " 3069 "interface address for the group"); 3070 return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE; 3071 } 3072 os_memcpy(group_bssid, wpa_s->pending_interface_addr, 3073 ETH_ALEN); 3074 } 3075 3076accept_inv: 3077 wpas_p2p_set_own_freq_preference(wpa_s, 0); 3078 3079 best_freq = 0; 3080 freqs = os_calloc(wpa_s->num_multichan_concurrent, 3081 sizeof(struct wpa_used_freq_data)); 3082 if (freqs) { 3083 int num_channels = wpa_s->num_multichan_concurrent; 3084 int num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, num_channels); 3085 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num); 3086 os_free(freqs); 3087 } 3088 3089 /* Get one of the frequencies currently in use */ 3090 if (best_freq > 0) { 3091 wpa_printf(MSG_DEBUG, "P2P: Trying to prefer a channel already used by one of the interfaces"); 3092 wpas_p2p_set_own_freq_preference(wpa_s, best_freq); 3093 3094 if (wpa_s->num_multichan_concurrent < 2 || 3095 wpas_p2p_num_unused_channels(wpa_s) < 1) { 3096 wpa_printf(MSG_DEBUG, "P2P: No extra channels available - trying to force channel to match a channel already used by one of the interfaces"); 3097 *force_freq = best_freq; 3098 } 3099 } 3100 3101 if (*force_freq > 0 && wpa_s->num_multichan_concurrent > 1 && 3102 wpas_p2p_num_unused_channels(wpa_s) > 0) { 3103 if (*go == 0) { 3104 /* We are the client */ 3105 wpa_printf(MSG_DEBUG, "P2P: Peer was found to be " 3106 "running a GO but we are capable of MCC, " 3107 "figure out the best channel to use"); 3108 *force_freq = 0; 3109 } else if (!freq_included(channels, *force_freq)) { 3110 /* We are the GO, and *force_freq is not in the 3111 * intersection */ 3112 wpa_printf(MSG_DEBUG, "P2P: Forced GO freq %d MHz not " 3113 "in intersection but we are capable of MCC, " 3114 "figure out the best channel to use", 3115 *force_freq); 3116 *force_freq = 0; 3117 } 3118 } 3119 3120 return P2P_SC_SUCCESS; 3121} 3122 3123 3124static void wpas_invitation_received(void *ctx, const u8 *sa, const u8 *bssid, 3125 const u8 *ssid, size_t ssid_len, 3126 const u8 *go_dev_addr, u8 status, 3127 int op_freq) 3128{ 3129 struct wpa_supplicant *wpa_s = ctx; 3130 struct wpa_ssid *s; 3131 3132 for (s = wpa_s->conf->ssid; s; s = s->next) { 3133 if (s->disabled == 2 && 3134 s->ssid_len == ssid_len && 3135 os_memcmp(ssid, s->ssid, ssid_len) == 0) 3136 break; 3137 } 3138 3139 if (status == P2P_SC_SUCCESS) { 3140 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR 3141 " was accepted; op_freq=%d MHz, SSID=%s", 3142 MAC2STR(sa), op_freq, wpa_ssid_txt(ssid, ssid_len)); 3143 if (s) { 3144 int go = s->mode == WPAS_MODE_P2P_GO; 3145 wpas_p2p_group_add_persistent( 3146 wpa_s, s, go, 0, op_freq, 0, 0, NULL, 3147 go ? P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE : 0); 3148 } else if (bssid) { 3149 wpa_s->user_initiated_pd = 0; 3150 wpas_p2p_join(wpa_s, bssid, go_dev_addr, 3151 wpa_s->p2p_wps_method, 0, op_freq, 3152 ssid, ssid_len); 3153 } 3154 return; 3155 } 3156 3157 if (status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) { 3158 wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR 3159 " was rejected (status %u)", MAC2STR(sa), status); 3160 return; 3161 } 3162 3163 if (!s) { 3164 if (bssid) { 3165 wpa_msg_global(wpa_s, MSG_INFO, 3166 P2P_EVENT_INVITATION_RECEIVED 3167 "sa=" MACSTR " go_dev_addr=" MACSTR 3168 " bssid=" MACSTR " unknown-network", 3169 MAC2STR(sa), MAC2STR(go_dev_addr), 3170 MAC2STR(bssid)); 3171 } else { 3172 wpa_msg_global(wpa_s, MSG_INFO, 3173 P2P_EVENT_INVITATION_RECEIVED 3174 "sa=" MACSTR " go_dev_addr=" MACSTR 3175 " unknown-network", 3176 MAC2STR(sa), MAC2STR(go_dev_addr)); 3177 } 3178 return; 3179 } 3180 3181 if (s->mode == WPAS_MODE_P2P_GO && op_freq) { 3182 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED 3183 "sa=" MACSTR " persistent=%d freq=%d", 3184 MAC2STR(sa), s->id, op_freq); 3185 } else { 3186 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED 3187 "sa=" MACSTR " persistent=%d", 3188 MAC2STR(sa), s->id); 3189 } 3190} 3191 3192 3193static void wpas_remove_persistent_peer(struct wpa_supplicant *wpa_s, 3194 struct wpa_ssid *ssid, 3195 const u8 *peer, int inv) 3196{ 3197 size_t i; 3198 3199 if (ssid == NULL) 3200 return; 3201 3202 for (i = 0; ssid->p2p_client_list && i < ssid->num_p2p_clients; i++) { 3203 if (os_memcmp(ssid->p2p_client_list + i * ETH_ALEN, peer, 3204 ETH_ALEN) == 0) 3205 break; 3206 } 3207 if (i >= ssid->num_p2p_clients || !ssid->p2p_client_list) { 3208 if (ssid->mode != WPAS_MODE_P2P_GO && 3209 os_memcmp(ssid->bssid, peer, ETH_ALEN) == 0) { 3210 wpa_printf(MSG_DEBUG, "P2P: Remove persistent group %d " 3211 "due to invitation result", ssid->id); 3212 wpas_notify_network_removed(wpa_s, ssid); 3213 wpa_config_remove_network(wpa_s->conf, ssid->id); 3214 return; 3215 } 3216 return; /* Peer not found in client list */ 3217 } 3218 3219 wpa_printf(MSG_DEBUG, "P2P: Remove peer " MACSTR " from persistent " 3220 "group %d client list%s", 3221 MAC2STR(peer), ssid->id, 3222 inv ? " due to invitation result" : ""); 3223 os_memmove(ssid->p2p_client_list + i * ETH_ALEN, 3224 ssid->p2p_client_list + (i + 1) * ETH_ALEN, 3225 (ssid->num_p2p_clients - i - 1) * ETH_ALEN); 3226 ssid->num_p2p_clients--; 3227 if (wpa_s->parent->conf->update_config && 3228 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf)) 3229 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration"); 3230} 3231 3232 3233static void wpas_remove_persistent_client(struct wpa_supplicant *wpa_s, 3234 const u8 *peer) 3235{ 3236 struct wpa_ssid *ssid; 3237 3238 wpa_s = wpa_s->global->p2p_invite_group; 3239 if (wpa_s == NULL) 3240 return; /* No known invitation group */ 3241 ssid = wpa_s->current_ssid; 3242 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO || 3243 !ssid->p2p_persistent_group) 3244 return; /* Not operating as a GO in persistent group */ 3245 ssid = wpas_p2p_get_persistent(wpa_s->parent, peer, 3246 ssid->ssid, ssid->ssid_len); 3247 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1); 3248} 3249 3250 3251static void wpas_invitation_result(void *ctx, int status, const u8 *bssid, 3252 const struct p2p_channels *channels, 3253 const u8 *peer, int neg_freq, 3254 int peer_oper_freq) 3255{ 3256 struct wpa_supplicant *wpa_s = ctx; 3257 struct wpa_ssid *ssid; 3258 int freq; 3259 3260 if (bssid) { 3261 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT 3262 "status=%d " MACSTR, 3263 status, MAC2STR(bssid)); 3264 } else { 3265 wpa_msg_global(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT 3266 "status=%d ", status); 3267 } 3268 wpas_notify_p2p_invitation_result(wpa_s, status, bssid); 3269 3270 wpa_printf(MSG_DEBUG, "P2P: Invitation result - status=%d peer=" MACSTR, 3271 status, MAC2STR(peer)); 3272 if (wpa_s->pending_invite_ssid_id == -1) { 3273 if (status == P2P_SC_FAIL_UNKNOWN_GROUP) 3274 wpas_remove_persistent_client(wpa_s, peer); 3275 return; /* Invitation to active group */ 3276 } 3277 3278 if (status == P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) { 3279 wpa_printf(MSG_DEBUG, "P2P: Waiting for peer to start another " 3280 "invitation exchange to indicate readiness for " 3281 "re-invocation"); 3282 } 3283 3284 if (status != P2P_SC_SUCCESS) { 3285 if (status == P2P_SC_FAIL_UNKNOWN_GROUP) { 3286 ssid = wpa_config_get_network( 3287 wpa_s->conf, wpa_s->pending_invite_ssid_id); 3288 wpas_remove_persistent_peer(wpa_s, ssid, peer, 1); 3289 } 3290 wpas_p2p_remove_pending_group_interface(wpa_s); 3291 return; 3292 } 3293 3294 ssid = wpa_config_get_network(wpa_s->conf, 3295 wpa_s->pending_invite_ssid_id); 3296 if (ssid == NULL) { 3297 wpa_printf(MSG_ERROR, "P2P: Could not find persistent group " 3298 "data matching with invitation"); 3299 return; 3300 } 3301 3302 /* 3303 * The peer could have missed our ctrl::ack frame for Invitation 3304 * Response and continue retransmitting the frame. To reduce the 3305 * likelihood of the peer not getting successful TX status for the 3306 * Invitation Response frame, wait a short time here before starting 3307 * the persistent group so that we will remain on the current channel to 3308 * acknowledge any possible retransmission from the peer. 3309 */ 3310 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 50 ms wait on current channel before " 3311 "starting persistent group"); 3312 os_sleep(0, 50000); 3313 3314 if (neg_freq > 0 && ssid->mode == WPAS_MODE_P2P_GO && 3315 freq_included(channels, neg_freq)) 3316 freq = neg_freq; 3317 else if (peer_oper_freq > 0 && ssid->mode != WPAS_MODE_P2P_GO && 3318 freq_included(channels, peer_oper_freq)) 3319 freq = peer_oper_freq; 3320 else 3321 freq = 0; 3322 3323 wpa_printf(MSG_DEBUG, "P2P: Persistent group invitation success - op_freq=%d MHz SSID=%s", 3324 freq, wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); 3325 wpas_p2p_group_add_persistent(wpa_s, ssid, 3326 ssid->mode == WPAS_MODE_P2P_GO, 3327 wpa_s->p2p_persistent_go_freq, 3328 freq, 3329 wpa_s->p2p_go_ht40, wpa_s->p2p_go_vht, 3330 channels, 3331 ssid->mode == WPAS_MODE_P2P_GO ? 3332 P2P_MAX_INITIAL_CONN_WAIT_GO_REINVOKE : 3333 0); 3334} 3335 3336 3337static int wpas_p2p_disallowed_freq(struct wpa_global *global, 3338 unsigned int freq) 3339{ 3340 if (freq_range_list_includes(&global->p2p_go_avoid_freq, freq)) 3341 return 1; 3342 return freq_range_list_includes(&global->p2p_disallow_freq, freq); 3343} 3344 3345 3346static void wpas_p2p_add_chan(struct p2p_reg_class *reg, u8 chan) 3347{ 3348 reg->channel[reg->channels] = chan; 3349 reg->channels++; 3350} 3351 3352 3353static int wpas_p2p_default_channels(struct wpa_supplicant *wpa_s, 3354 struct p2p_channels *chan, 3355 struct p2p_channels *cli_chan) 3356{ 3357 int i, cla = 0; 3358 3359 os_memset(cli_chan, 0, sizeof(*cli_chan)); 3360 3361 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for 2.4 GHz " 3362 "band"); 3363 3364 /* Operating class 81 - 2.4 GHz band channels 1..13 */ 3365 chan->reg_class[cla].reg_class = 81; 3366 chan->reg_class[cla].channels = 0; 3367 for (i = 0; i < 11; i++) { 3368 if (!wpas_p2p_disallowed_freq(wpa_s->global, 2412 + i * 5)) 3369 wpas_p2p_add_chan(&chan->reg_class[cla], i + 1); 3370 } 3371 if (chan->reg_class[cla].channels) 3372 cla++; 3373 3374 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for lower 5 GHz " 3375 "band"); 3376 3377 /* Operating class 115 - 5 GHz, channels 36-48 */ 3378 chan->reg_class[cla].reg_class = 115; 3379 chan->reg_class[cla].channels = 0; 3380 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5)) 3381 wpas_p2p_add_chan(&chan->reg_class[cla], 36); 3382 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5)) 3383 wpas_p2p_add_chan(&chan->reg_class[cla], 40); 3384 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5)) 3385 wpas_p2p_add_chan(&chan->reg_class[cla], 44); 3386 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5)) 3387 wpas_p2p_add_chan(&chan->reg_class[cla], 48); 3388 if (chan->reg_class[cla].channels) 3389 cla++; 3390 3391 wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for higher 5 GHz " 3392 "band"); 3393 3394 /* Operating class 124 - 5 GHz, channels 149,153,157,161 */ 3395 chan->reg_class[cla].reg_class = 124; 3396 chan->reg_class[cla].channels = 0; 3397 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5)) 3398 wpas_p2p_add_chan(&chan->reg_class[cla], 149); 3399 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5)) 3400 wpas_p2p_add_chan(&chan->reg_class[cla], 153); 3401 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5)) 3402 wpas_p2p_add_chan(&chan->reg_class[cla], 157); 3403 if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5)) 3404 wpas_p2p_add_chan(&chan->reg_class[cla], 161); 3405 if (chan->reg_class[cla].channels) 3406 cla++; 3407 3408 chan->reg_classes = cla; 3409 return 0; 3410} 3411 3412 3413static struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes, 3414 u16 num_modes, 3415 enum hostapd_hw_mode mode) 3416{ 3417 u16 i; 3418 3419 for (i = 0; i < num_modes; i++) { 3420 if (modes[i].mode == mode) 3421 return &modes[i]; 3422 } 3423 3424 return NULL; 3425} 3426 3427 3428enum chan_allowed { 3429 NOT_ALLOWED, PASSIVE_ONLY, ALLOWED 3430}; 3431 3432static int has_channel(struct wpa_global *global, 3433 struct hostapd_hw_modes *mode, u8 chan, int *flags) 3434{ 3435 int i; 3436 unsigned int freq; 3437 3438 freq = (mode->mode == HOSTAPD_MODE_IEEE80211A ? 5000 : 2407) + 3439 chan * 5; 3440 if (wpas_p2p_disallowed_freq(global, freq)) 3441 return NOT_ALLOWED; 3442 3443 for (i = 0; i < mode->num_channels; i++) { 3444 if (mode->channels[i].chan == chan) { 3445 if (flags) 3446 *flags = mode->channels[i].flag; 3447 if (mode->channels[i].flag & 3448 (HOSTAPD_CHAN_DISABLED | 3449 HOSTAPD_CHAN_RADAR)) 3450 return NOT_ALLOWED; 3451 if (mode->channels[i].flag & 3452 (HOSTAPD_CHAN_PASSIVE_SCAN | 3453 HOSTAPD_CHAN_NO_IBSS)) 3454 return PASSIVE_ONLY; 3455 return ALLOWED; 3456 } 3457 } 3458 3459 return NOT_ALLOWED; 3460} 3461 3462 3463struct p2p_oper_class_map { 3464 enum hostapd_hw_mode mode; 3465 u8 op_class; 3466 u8 min_chan; 3467 u8 max_chan; 3468 u8 inc; 3469 enum { BW20, BW40PLUS, BW40MINUS, BW80 } bw; 3470}; 3471 3472static struct p2p_oper_class_map op_class[] = { 3473 { HOSTAPD_MODE_IEEE80211G, 81, 1, 13, 1, BW20 }, 3474#if 0 /* Do not enable HT40 on 2 GHz for now */ 3475 { HOSTAPD_MODE_IEEE80211G, 83, 1, 9, 1, BW40PLUS }, 3476 { HOSTAPD_MODE_IEEE80211G, 84, 5, 13, 1, BW40MINUS }, 3477#endif 3478 { HOSTAPD_MODE_IEEE80211A, 115, 36, 48, 4, BW20 }, 3479 { HOSTAPD_MODE_IEEE80211A, 124, 149, 161, 4, BW20 }, 3480 { HOSTAPD_MODE_IEEE80211A, 116, 36, 44, 8, BW40PLUS }, 3481 { HOSTAPD_MODE_IEEE80211A, 117, 40, 48, 8, BW40MINUS }, 3482 { HOSTAPD_MODE_IEEE80211A, 126, 149, 157, 8, BW40PLUS }, 3483 { HOSTAPD_MODE_IEEE80211A, 127, 153, 161, 8, BW40MINUS }, 3484 3485 /* 3486 * IEEE P802.11ac/D7.0 Table E-4 actually talks about channel center 3487 * frequency index 42, 58, 106, 122, 138, 155 with channel spacing of 3488 * 80 MHz, but currently use the following definition for simplicity 3489 * (these center frequencies are not actual channels, which makes 3490 * has_channel() fail). wpas_p2p_verify_80mhz() should take care of 3491 * removing invalid channels. 3492 */ 3493 { HOSTAPD_MODE_IEEE80211A, 128, 36, 161, 4, BW80 }, 3494 { -1, 0, 0, 0, 0, BW20 } 3495}; 3496 3497 3498static int wpas_p2p_get_center_80mhz(struct wpa_supplicant *wpa_s, 3499 struct hostapd_hw_modes *mode, 3500 u8 channel) 3501{ 3502 u8 center_channels[] = { 42, 58, 106, 122, 138, 155 }; 3503 unsigned int i; 3504 3505 if (mode->mode != HOSTAPD_MODE_IEEE80211A) 3506 return 0; 3507 3508 for (i = 0; i < ARRAY_SIZE(center_channels); i++) 3509 /* 3510 * In 80 MHz, the bandwidth "spans" 12 channels (e.g., 36-48), 3511 * so the center channel is 6 channels away from the start/end. 3512 */ 3513 if (channel >= center_channels[i] - 6 && 3514 channel <= center_channels[i] + 6) 3515 return center_channels[i]; 3516 3517 return 0; 3518} 3519 3520 3521static enum chan_allowed wpas_p2p_verify_80mhz(struct wpa_supplicant *wpa_s, 3522 struct hostapd_hw_modes *mode, 3523 u8 channel, u8 bw) 3524{ 3525 u8 center_chan; 3526 int i, flags; 3527 enum chan_allowed res, ret = ALLOWED; 3528 3529 center_chan = wpas_p2p_get_center_80mhz(wpa_s, mode, channel); 3530 if (!center_chan) 3531 return NOT_ALLOWED; 3532 if (center_chan >= 58 && center_chan <= 138) 3533 return NOT_ALLOWED; /* Do not allow DFS channels for P2P */ 3534 3535 /* check all the channels are available */ 3536 for (i = 0; i < 4; i++) { 3537 int adj_chan = center_chan - 6 + i * 4; 3538 3539 res = has_channel(wpa_s->global, mode, adj_chan, &flags); 3540 if (res == NOT_ALLOWED) 3541 return NOT_ALLOWED; 3542 if (res == PASSIVE_ONLY) 3543 ret = PASSIVE_ONLY; 3544 3545 if (i == 0 && !(flags & HOSTAPD_CHAN_VHT_10_70)) 3546 return NOT_ALLOWED; 3547 if (i == 1 && !(flags & HOSTAPD_CHAN_VHT_30_50)) 3548 return NOT_ALLOWED; 3549 if (i == 2 && !(flags & HOSTAPD_CHAN_VHT_50_30)) 3550 return NOT_ALLOWED; 3551 if (i == 3 && !(flags & HOSTAPD_CHAN_VHT_70_10)) 3552 return NOT_ALLOWED; 3553 } 3554 3555 return ret; 3556} 3557 3558 3559static enum chan_allowed wpas_p2p_verify_channel(struct wpa_supplicant *wpa_s, 3560 struct hostapd_hw_modes *mode, 3561 u8 channel, u8 bw) 3562{ 3563 int flag = 0; 3564 enum chan_allowed res, res2; 3565 3566 res2 = res = has_channel(wpa_s->global, mode, channel, &flag); 3567 if (bw == BW40MINUS) { 3568 if (!(flag & HOSTAPD_CHAN_HT40MINUS)) 3569 return NOT_ALLOWED; 3570 res2 = has_channel(wpa_s->global, mode, channel - 4, NULL); 3571 } else if (bw == BW40PLUS) { 3572 if (!(flag & HOSTAPD_CHAN_HT40PLUS)) 3573 return NOT_ALLOWED; 3574 res2 = has_channel(wpa_s->global, mode, channel + 4, NULL); 3575 } else if (bw == BW80) { 3576 res2 = wpas_p2p_verify_80mhz(wpa_s, mode, channel, bw); 3577 } 3578 3579 if (res == NOT_ALLOWED || res2 == NOT_ALLOWED) 3580 return NOT_ALLOWED; 3581 if (res == PASSIVE_ONLY || res2 == PASSIVE_ONLY) 3582 return PASSIVE_ONLY; 3583 return res; 3584} 3585 3586 3587static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s, 3588 struct p2p_channels *chan, 3589 struct p2p_channels *cli_chan) 3590{ 3591 struct hostapd_hw_modes *mode; 3592 int cla, op, cli_cla; 3593 3594 if (wpa_s->hw.modes == NULL) { 3595 wpa_printf(MSG_DEBUG, "P2P: Driver did not support fetching " 3596 "of all supported channels; assume dualband " 3597 "support"); 3598 return wpas_p2p_default_channels(wpa_s, chan, cli_chan); 3599 } 3600 3601 cla = cli_cla = 0; 3602 3603 for (op = 0; op_class[op].op_class; op++) { 3604 struct p2p_oper_class_map *o = &op_class[op]; 3605 u8 ch; 3606 struct p2p_reg_class *reg = NULL, *cli_reg = NULL; 3607 3608 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode); 3609 if (mode == NULL) 3610 continue; 3611 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) { 3612 enum chan_allowed res; 3613 res = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw); 3614 if (res == ALLOWED) { 3615 if (reg == NULL) { 3616 wpa_printf(MSG_DEBUG, "P2P: Add operating class %u", 3617 o->op_class); 3618 reg = &chan->reg_class[cla]; 3619 cla++; 3620 reg->reg_class = o->op_class; 3621 } 3622 reg->channel[reg->channels] = ch; 3623 reg->channels++; 3624 } else if (res == PASSIVE_ONLY && 3625 wpa_s->conf->p2p_add_cli_chan) { 3626 if (cli_reg == NULL) { 3627 wpa_printf(MSG_DEBUG, "P2P: Add operating class %u (client only)", 3628 o->op_class); 3629 cli_reg = &cli_chan->reg_class[cli_cla]; 3630 cli_cla++; 3631 cli_reg->reg_class = o->op_class; 3632 } 3633 cli_reg->channel[cli_reg->channels] = ch; 3634 cli_reg->channels++; 3635 } 3636 } 3637 if (reg) { 3638 wpa_hexdump(MSG_DEBUG, "P2P: Channels", 3639 reg->channel, reg->channels); 3640 } 3641 if (cli_reg) { 3642 wpa_hexdump(MSG_DEBUG, "P2P: Channels (client only)", 3643 cli_reg->channel, cli_reg->channels); 3644 } 3645 } 3646 3647 chan->reg_classes = cla; 3648 cli_chan->reg_classes = cli_cla; 3649 3650 return 0; 3651} 3652 3653 3654int wpas_p2p_get_ht40_mode(struct wpa_supplicant *wpa_s, 3655 struct hostapd_hw_modes *mode, u8 channel) 3656{ 3657 int op; 3658 enum chan_allowed ret; 3659 3660 for (op = 0; op_class[op].op_class; op++) { 3661 struct p2p_oper_class_map *o = &op_class[op]; 3662 u8 ch; 3663 3664 for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) { 3665 if (o->mode != HOSTAPD_MODE_IEEE80211A || 3666 o->bw == BW20 || ch != channel) 3667 continue; 3668 ret = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw); 3669 if (ret == ALLOWED) 3670 return (o->bw == BW40MINUS) ? -1 : 1; 3671 } 3672 } 3673 return 0; 3674} 3675 3676 3677int wpas_p2p_get_vht80_center(struct wpa_supplicant *wpa_s, 3678 struct hostapd_hw_modes *mode, u8 channel) 3679{ 3680 if (!wpas_p2p_verify_channel(wpa_s, mode, channel, BW80)) 3681 return 0; 3682 3683 return wpas_p2p_get_center_80mhz(wpa_s, mode, channel); 3684} 3685 3686 3687static int wpas_get_noa(void *ctx, const u8 *interface_addr, u8 *buf, 3688 size_t buf_len) 3689{ 3690 struct wpa_supplicant *wpa_s = ctx; 3691 3692 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) { 3693 if (os_memcmp(wpa_s->own_addr, interface_addr, ETH_ALEN) == 0) 3694 break; 3695 } 3696 if (wpa_s == NULL) 3697 return -1; 3698 3699 return wpa_drv_get_noa(wpa_s, buf, buf_len); 3700} 3701 3702 3703struct wpa_supplicant * wpas_get_p2p_go_iface(struct wpa_supplicant *wpa_s, 3704 const u8 *ssid, size_t ssid_len) 3705{ 3706 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) { 3707 struct wpa_ssid *s = wpa_s->current_ssid; 3708 if (s == NULL) 3709 continue; 3710 if (s->mode != WPAS_MODE_P2P_GO && 3711 s->mode != WPAS_MODE_AP && 3712 s->mode != WPAS_MODE_P2P_GROUP_FORMATION) 3713 continue; 3714 if (s->ssid_len != ssid_len || 3715 os_memcmp(ssid, s->ssid, ssid_len) != 0) 3716 continue; 3717 return wpa_s; 3718 } 3719 3720 return NULL; 3721 3722} 3723 3724 3725struct wpa_supplicant * wpas_get_p2p_client_iface(struct wpa_supplicant *wpa_s, 3726 const u8 *peer_dev_addr) 3727{ 3728 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) { 3729 struct wpa_ssid *ssid = wpa_s->current_ssid; 3730 if (ssid == NULL) 3731 continue; 3732 if (ssid->mode != WPAS_MODE_INFRA) 3733 continue; 3734 if (wpa_s->wpa_state != WPA_COMPLETED && 3735 wpa_s->wpa_state != WPA_GROUP_HANDSHAKE) 3736 continue; 3737 if (os_memcmp(wpa_s->go_dev_addr, peer_dev_addr, ETH_ALEN) == 0) 3738 return wpa_s; 3739 } 3740 3741 return NULL; 3742} 3743 3744 3745static int wpas_go_connected(void *ctx, const u8 *dev_addr) 3746{ 3747 struct wpa_supplicant *wpa_s = ctx; 3748 3749 return wpas_get_p2p_client_iface(wpa_s, dev_addr) != NULL; 3750} 3751 3752 3753static int wpas_is_concurrent_session_active(void *ctx) 3754{ 3755 struct wpa_supplicant *wpa_s = ctx; 3756 struct wpa_supplicant *ifs; 3757 3758 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) { 3759 if (ifs == wpa_s) 3760 continue; 3761 if (ifs->wpa_state > WPA_ASSOCIATED) 3762 return 1; 3763 } 3764 return 0; 3765} 3766 3767 3768static void wpas_p2p_debug_print(void *ctx, int level, const char *msg) 3769{ 3770 struct wpa_supplicant *wpa_s = ctx; 3771 wpa_msg_global(wpa_s, level, "P2P: %s", msg); 3772} 3773 3774 3775int wpas_p2p_add_p2pdev_interface(struct wpa_supplicant *wpa_s) 3776{ 3777 struct wpa_interface iface; 3778 struct wpa_supplicant *p2pdev_wpa_s; 3779 char ifname[100]; 3780 char force_name[100]; 3781 int ret; 3782 3783 os_snprintf(ifname, sizeof(ifname), P2P_MGMT_DEVICE_PREFIX "%s", 3784 wpa_s->ifname); 3785 force_name[0] = '\0'; 3786 wpa_s->pending_interface_type = WPA_IF_P2P_DEVICE; 3787 ret = wpa_drv_if_add(wpa_s, WPA_IF_P2P_DEVICE, ifname, NULL, NULL, 3788 force_name, wpa_s->pending_interface_addr, NULL); 3789 if (ret < 0) { 3790 wpa_printf(MSG_DEBUG, "P2P: Failed to create P2P Device interface"); 3791 return ret; 3792 } 3793 os_strlcpy(wpa_s->pending_interface_name, ifname, 3794 sizeof(wpa_s->pending_interface_name)); 3795 3796 os_memset(&iface, 0, sizeof(iface)); 3797 iface.p2p_mgmt = 1; 3798 iface.ifname = wpa_s->pending_interface_name; 3799 iface.driver = wpa_s->driver->name; 3800 iface.driver_param = wpa_s->conf->driver_param; 3801 3802 /* 3803 * If a P2P Device configuration file was given, use it as the interface 3804 * configuration file (instead of using parent's configuration file. 3805 */ 3806 if (wpa_s->conf_p2p_dev) { 3807 iface.confname = wpa_s->conf_p2p_dev; 3808 iface.ctrl_interface = NULL; 3809 } else { 3810 iface.confname = wpa_s->confname; 3811 iface.ctrl_interface = wpa_s->conf->ctrl_interface; 3812 } 3813 iface.conf_p2p_dev = NULL; 3814 3815 p2pdev_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface); 3816 if (!p2pdev_wpa_s) { 3817 wpa_printf(MSG_DEBUG, "P2P: Failed to add P2P Device interface"); 3818 return -1; 3819 } 3820 p2pdev_wpa_s->parent = wpa_s; 3821 3822 wpa_s->pending_interface_name[0] = '\0'; 3823 return 0; 3824} 3825 3826 3827static void wpas_presence_resp(void *ctx, const u8 *src, u8 status, 3828 const u8 *noa, size_t noa_len) 3829{ 3830 struct wpa_supplicant *wpa_s, *intf = ctx; 3831 char hex[100]; 3832 3833 for (wpa_s = intf->global->ifaces; wpa_s; wpa_s = wpa_s->next) { 3834 if (wpa_s->waiting_presence_resp) 3835 break; 3836 } 3837 if (!wpa_s) { 3838 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No group interface was waiting for presence response"); 3839 return; 3840 } 3841 wpa_s->waiting_presence_resp = 0; 3842 3843 wpa_snprintf_hex(hex, sizeof(hex), noa, noa_len); 3844 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PRESENCE_RESPONSE "src=" MACSTR 3845 " status=%u noa=%s", MAC2STR(src), status, hex); 3846} 3847 3848 3849static int _wpas_p2p_in_progress(void *ctx) 3850{ 3851 struct wpa_supplicant *wpa_s = ctx; 3852 return wpas_p2p_in_progress(wpa_s); 3853} 3854 3855 3856/** 3857 * wpas_p2p_init - Initialize P2P module for %wpa_supplicant 3858 * @global: Pointer to global data from wpa_supplicant_init() 3859 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 3860 * Returns: 0 on success, -1 on failure 3861 */ 3862int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s) 3863{ 3864 struct p2p_config p2p; 3865 unsigned int r; 3866 int i; 3867 3868 if (wpa_s->conf->p2p_disabled) 3869 return 0; 3870 3871 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE)) 3872 return 0; 3873 3874 if (global->p2p) 3875 return 0; 3876 3877 os_memset(&p2p, 0, sizeof(p2p)); 3878 p2p.cb_ctx = wpa_s; 3879 p2p.debug_print = wpas_p2p_debug_print; 3880 p2p.p2p_scan = wpas_p2p_scan; 3881 p2p.send_action = wpas_send_action; 3882 p2p.send_action_done = wpas_send_action_done; 3883 p2p.go_neg_completed = wpas_go_neg_completed; 3884 p2p.go_neg_req_rx = wpas_go_neg_req_rx; 3885 p2p.dev_found = wpas_dev_found; 3886 p2p.dev_lost = wpas_dev_lost; 3887 p2p.find_stopped = wpas_find_stopped; 3888 p2p.start_listen = wpas_start_listen; 3889 p2p.stop_listen = wpas_stop_listen; 3890 p2p.send_probe_resp = wpas_send_probe_resp; 3891 p2p.sd_request = wpas_sd_request; 3892 p2p.sd_response = wpas_sd_response; 3893 p2p.prov_disc_req = wpas_prov_disc_req; 3894 p2p.prov_disc_resp = wpas_prov_disc_resp; 3895 p2p.prov_disc_fail = wpas_prov_disc_fail; 3896 p2p.invitation_process = wpas_invitation_process; 3897 p2p.invitation_received = wpas_invitation_received; 3898 p2p.invitation_result = wpas_invitation_result; 3899 p2p.get_noa = wpas_get_noa; 3900 p2p.go_connected = wpas_go_connected; 3901 p2p.presence_resp = wpas_presence_resp; 3902 p2p.is_concurrent_session_active = wpas_is_concurrent_session_active; 3903 p2p.is_p2p_in_progress = _wpas_p2p_in_progress; 3904 3905 os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN); 3906 os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN); 3907 p2p.dev_name = wpa_s->conf->device_name; 3908 p2p.manufacturer = wpa_s->conf->manufacturer; 3909 p2p.model_name = wpa_s->conf->model_name; 3910 p2p.model_number = wpa_s->conf->model_number; 3911 p2p.serial_number = wpa_s->conf->serial_number; 3912 if (wpa_s->wps) { 3913 os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16); 3914 p2p.config_methods = wpa_s->wps->config_methods; 3915 } 3916 3917 if (wpa_s->conf->p2p_listen_reg_class && 3918 wpa_s->conf->p2p_listen_channel) { 3919 p2p.reg_class = wpa_s->conf->p2p_listen_reg_class; 3920 p2p.channel = wpa_s->conf->p2p_listen_channel; 3921 p2p.channel_forced = 1; 3922 } else { 3923 p2p.reg_class = 81; 3924 /* 3925 * Pick one of the social channels randomly as the listen 3926 * channel. 3927 */ 3928 os_get_random((u8 *) &r, sizeof(r)); 3929 p2p.channel = 1 + (r % 3) * 5; 3930 p2p.channel_forced = 0; 3931 } 3932 wpa_printf(MSG_DEBUG, "P2P: Own listen channel: %d", p2p.channel); 3933 3934 if (wpa_s->conf->p2p_oper_reg_class && 3935 wpa_s->conf->p2p_oper_channel) { 3936 p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class; 3937 p2p.op_channel = wpa_s->conf->p2p_oper_channel; 3938 p2p.cfg_op_channel = 1; 3939 wpa_printf(MSG_DEBUG, "P2P: Configured operating channel: " 3940 "%d:%d", p2p.op_reg_class, p2p.op_channel); 3941 3942 } else { 3943 p2p.op_reg_class = 81; 3944 /* 3945 * Use random operation channel from (1, 6, 11) if no other 3946 * preference is indicated. 3947 */ 3948 os_get_random((u8 *) &r, sizeof(r)); 3949 p2p.op_channel = 1 + (r % 3) * 5; 3950 p2p.cfg_op_channel = 0; 3951 wpa_printf(MSG_DEBUG, "P2P: Random operating channel: " 3952 "%d:%d", p2p.op_reg_class, p2p.op_channel); 3953 } 3954 3955 if (wpa_s->conf->p2p_pref_chan && wpa_s->conf->num_p2p_pref_chan) { 3956 p2p.pref_chan = wpa_s->conf->p2p_pref_chan; 3957 p2p.num_pref_chan = wpa_s->conf->num_p2p_pref_chan; 3958 } 3959 3960 if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) { 3961 os_memcpy(p2p.country, wpa_s->conf->country, 2); 3962 p2p.country[2] = 0x04; 3963 } else 3964 os_memcpy(p2p.country, "XX\x04", 3); 3965 3966 if (wpas_p2p_setup_channels(wpa_s, &p2p.channels, &p2p.cli_channels)) { 3967 wpa_printf(MSG_ERROR, "P2P: Failed to configure supported " 3968 "channel list"); 3969 return -1; 3970 } 3971 3972 os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type, 3973 WPS_DEV_TYPE_LEN); 3974 3975 p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types; 3976 os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type, 3977 p2p.num_sec_dev_types * WPS_DEV_TYPE_LEN); 3978 3979 p2p.concurrent_operations = !!(wpa_s->drv_flags & 3980 WPA_DRIVER_FLAGS_P2P_CONCURRENT); 3981 3982 p2p.max_peers = 100; 3983 3984 if (wpa_s->conf->p2p_ssid_postfix) { 3985 p2p.ssid_postfix_len = 3986 os_strlen(wpa_s->conf->p2p_ssid_postfix); 3987 if (p2p.ssid_postfix_len > sizeof(p2p.ssid_postfix)) 3988 p2p.ssid_postfix_len = sizeof(p2p.ssid_postfix); 3989 os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix, 3990 p2p.ssid_postfix_len); 3991 } 3992 3993 p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss; 3994 3995 p2p.max_listen = wpa_s->max_remain_on_chan; 3996 3997 if (wpa_s->conf->p2p_passphrase_len >= 8 && 3998 wpa_s->conf->p2p_passphrase_len <= 63) 3999 p2p.passphrase_len = wpa_s->conf->p2p_passphrase_len; 4000 else 4001 p2p.passphrase_len = 8; 4002 4003 global->p2p = p2p_init(&p2p); 4004 if (global->p2p == NULL) 4005 return -1; 4006 global->p2p_init_wpa_s = wpa_s; 4007 4008 for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) { 4009 if (wpa_s->conf->wps_vendor_ext[i] == NULL) 4010 continue; 4011 p2p_add_wps_vendor_extension( 4012 global->p2p, wpa_s->conf->wps_vendor_ext[i]); 4013 } 4014 4015 p2p_set_no_go_freq(global->p2p, &wpa_s->conf->p2p_no_go_freq); 4016 4017 return 0; 4018} 4019 4020 4021/** 4022 * wpas_p2p_deinit - Deinitialize per-interface P2P data 4023 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 4024 * 4025 * This function deinitialize per-interface P2P data. 4026 */ 4027void wpas_p2p_deinit(struct wpa_supplicant *wpa_s) 4028{ 4029 if (wpa_s->driver && wpa_s->drv_priv) 4030 wpa_drv_probe_req_report(wpa_s, 0); 4031 4032 if (wpa_s->go_params) { 4033 /* Clear any stored provisioning info */ 4034 p2p_clear_provisioning_info( 4035 wpa_s->global->p2p, 4036 wpa_s->go_params->peer_device_addr); 4037 } 4038 4039 os_free(wpa_s->go_params); 4040 wpa_s->go_params = NULL; 4041 eloop_cancel_timeout(wpas_p2p_psk_failure_removal, wpa_s, NULL); 4042 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL); 4043 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); 4044 wpa_s->p2p_long_listen = 0; 4045 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL); 4046 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL); 4047 wpas_p2p_remove_pending_group_interface(wpa_s); 4048 eloop_cancel_timeout(wpas_p2p_group_freq_conflict, wpa_s, NULL); 4049 wpas_p2p_listen_work_done(wpa_s); 4050 if (wpa_s->p2p_send_action_work) { 4051 os_free(wpa_s->p2p_send_action_work->ctx); 4052 radio_work_done(wpa_s->p2p_send_action_work); 4053 wpa_s->p2p_send_action_work = NULL; 4054 } 4055 eloop_cancel_timeout(wpas_p2p_send_action_work_timeout, wpa_s, NULL); 4056 4057 wpabuf_free(wpa_s->p2p_oob_dev_pw); 4058 wpa_s->p2p_oob_dev_pw = NULL; 4059 4060 /* TODO: remove group interface from the driver if this wpa_s instance 4061 * is on top of a P2P group interface */ 4062} 4063 4064 4065/** 4066 * wpas_p2p_deinit_global - Deinitialize global P2P module 4067 * @global: Pointer to global data from wpa_supplicant_init() 4068 * 4069 * This function deinitializes the global (per device) P2P module. 4070 */ 4071static void wpas_p2p_deinit_global(struct wpa_global *global) 4072{ 4073 struct wpa_supplicant *wpa_s, *tmp; 4074 4075 wpa_s = global->ifaces; 4076 if (wpa_s) 4077 wpas_p2p_service_flush(wpa_s); 4078 4079 if (global->p2p == NULL) 4080 return; 4081 4082 /* Remove remaining P2P group interfaces */ 4083 while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) 4084 wpa_s = wpa_s->next; 4085 while (wpa_s) { 4086 tmp = global->ifaces; 4087 while (tmp && 4088 (tmp == wpa_s || 4089 tmp->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)) { 4090 tmp = tmp->next; 4091 } 4092 if (tmp == NULL) 4093 break; 4094 /* Disconnect from the P2P group and deinit the interface */ 4095 wpas_p2p_disconnect(tmp); 4096 } 4097 4098 /* 4099 * Deinit GO data on any possibly remaining interface (if main 4100 * interface is used as GO). 4101 */ 4102 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 4103 if (wpa_s->ap_iface) 4104 wpas_p2p_group_deinit(wpa_s); 4105 } 4106 4107 p2p_deinit(global->p2p); 4108 global->p2p = NULL; 4109 global->p2p_init_wpa_s = NULL; 4110} 4111 4112 4113static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s) 4114{ 4115 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) && 4116 wpa_s->conf->p2p_no_group_iface) 4117 return 0; /* separate interface disabled per configuration */ 4118 if (wpa_s->drv_flags & 4119 (WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE | 4120 WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P)) 4121 return 1; /* P2P group requires a new interface in every case 4122 */ 4123 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT)) 4124 return 0; /* driver does not support concurrent operations */ 4125 if (wpa_s->global->ifaces->next) 4126 return 1; /* more that one interface already in use */ 4127 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 4128 return 1; /* this interface is already in use */ 4129 return 0; 4130} 4131 4132 4133static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s, 4134 const u8 *peer_addr, 4135 enum p2p_wps_method wps_method, 4136 int go_intent, const u8 *own_interface_addr, 4137 unsigned int force_freq, int persistent_group, 4138 struct wpa_ssid *ssid, unsigned int pref_freq) 4139{ 4140 if (persistent_group && wpa_s->conf->persistent_reconnect) 4141 persistent_group = 2; 4142 4143 /* 4144 * Increase GO config timeout if HT40 is used since it takes some time 4145 * to scan channels for coex purposes before the BSS can be started. 4146 */ 4147 p2p_set_config_timeout(wpa_s->global->p2p, 4148 wpa_s->p2p_go_ht40 ? 255 : 100, 20); 4149 4150 return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method, 4151 go_intent, own_interface_addr, force_freq, 4152 persistent_group, ssid ? ssid->ssid : NULL, 4153 ssid ? ssid->ssid_len : 0, 4154 wpa_s->p2p_pd_before_go_neg, pref_freq, 4155 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id : 4156 0); 4157} 4158 4159 4160static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s, 4161 const u8 *peer_addr, 4162 enum p2p_wps_method wps_method, 4163 int go_intent, const u8 *own_interface_addr, 4164 unsigned int force_freq, int persistent_group, 4165 struct wpa_ssid *ssid, unsigned int pref_freq) 4166{ 4167 if (persistent_group && wpa_s->conf->persistent_reconnect) 4168 persistent_group = 2; 4169 4170 return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method, 4171 go_intent, own_interface_addr, force_freq, 4172 persistent_group, ssid ? ssid->ssid : NULL, 4173 ssid ? ssid->ssid_len : 0, pref_freq, 4174 wps_method == WPS_NFC ? wpa_s->p2p_oob_dev_pw_id : 4175 0); 4176} 4177 4178 4179static void wpas_p2p_check_join_scan_limit(struct wpa_supplicant *wpa_s) 4180{ 4181 wpa_s->p2p_join_scan_count++; 4182 wpa_printf(MSG_DEBUG, "P2P: Join scan attempt %d", 4183 wpa_s->p2p_join_scan_count); 4184 if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) { 4185 wpa_printf(MSG_DEBUG, "P2P: Failed to find GO " MACSTR 4186 " for join operationg - stop join attempt", 4187 MAC2STR(wpa_s->pending_join_iface_addr)); 4188 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); 4189 if (wpa_s->p2p_auto_pd) { 4190 wpa_s->p2p_auto_pd = 0; 4191 wpa_msg_global(wpa_s, MSG_INFO, 4192 P2P_EVENT_PROV_DISC_FAILURE 4193 " p2p_dev_addr=" MACSTR " status=N/A", 4194 MAC2STR(wpa_s->pending_join_dev_addr)); 4195 return; 4196 } 4197 wpa_msg_global(wpa_s->parent, MSG_INFO, 4198 P2P_EVENT_GROUP_FORMATION_FAILURE); 4199 } 4200} 4201 4202 4203static int wpas_check_freq_conflict(struct wpa_supplicant *wpa_s, int freq) 4204{ 4205 int res; 4206 unsigned int num, i; 4207 struct wpa_used_freq_data *freqs; 4208 4209 if (wpas_p2p_num_unused_channels(wpa_s) > 0) { 4210 /* Multiple channels are supported and not all are in use */ 4211 return 0; 4212 } 4213 4214 freqs = os_calloc(wpa_s->num_multichan_concurrent, 4215 sizeof(struct wpa_used_freq_data)); 4216 if (!freqs) 4217 return 1; 4218 4219 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, 4220 wpa_s->num_multichan_concurrent); 4221 4222 for (i = 0; i < num; i++) { 4223 if (freqs[i].freq == freq) { 4224 wpa_printf(MSG_DEBUG, "P2P: Frequency %d MHz in use by another virtual interface and can be used", 4225 freq); 4226 res = 0; 4227 goto exit_free; 4228 } 4229 } 4230 4231 wpa_printf(MSG_DEBUG, "P2P: No valid operating frequencies"); 4232 res = 1; 4233 4234exit_free: 4235 os_free(freqs); 4236 return res; 4237} 4238 4239 4240static int wpas_p2p_peer_go(struct wpa_supplicant *wpa_s, 4241 const u8 *peer_dev_addr) 4242{ 4243 struct wpa_bss *bss; 4244 int updated; 4245 4246 bss = wpa_bss_get_p2p_dev_addr(wpa_s, peer_dev_addr); 4247 if (bss == NULL) 4248 return -1; 4249 if (bss->last_update_idx < wpa_s->bss_update_idx) { 4250 wpa_printf(MSG_DEBUG, "P2P: Peer BSS entry not updated in the " 4251 "last scan"); 4252 return 0; 4253 } 4254 4255 updated = os_reltime_before(&wpa_s->p2p_auto_started, 4256 &bss->last_update); 4257 wpa_printf(MSG_DEBUG, "P2P: Current BSS entry for peer updated at " 4258 "%ld.%06ld (%supdated in last scan)", 4259 bss->last_update.sec, bss->last_update.usec, 4260 updated ? "": "not "); 4261 4262 return updated; 4263} 4264 4265 4266static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s, 4267 struct wpa_scan_results *scan_res) 4268{ 4269 struct wpa_bss *bss = NULL; 4270 int freq; 4271 u8 iface_addr[ETH_ALEN]; 4272 4273 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); 4274 4275 if (wpa_s->global->p2p_disabled) 4276 return; 4277 4278 wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS) for %sjoin", 4279 scan_res ? (int) scan_res->num : -1, 4280 wpa_s->p2p_auto_join ? "auto_" : ""); 4281 4282 if (scan_res) 4283 wpas_p2p_scan_res_handler(wpa_s, scan_res); 4284 4285 if (wpa_s->p2p_auto_pd) { 4286 int join = wpas_p2p_peer_go(wpa_s, 4287 wpa_s->pending_join_dev_addr); 4288 if (join == 0 && 4289 wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) { 4290 wpa_s->auto_pd_scan_retry++; 4291 bss = wpa_bss_get_bssid_latest( 4292 wpa_s, wpa_s->pending_join_dev_addr); 4293 if (bss) { 4294 freq = bss->freq; 4295 wpa_printf(MSG_DEBUG, "P2P: Scan retry %d for " 4296 "the peer " MACSTR " at %d MHz", 4297 wpa_s->auto_pd_scan_retry, 4298 MAC2STR(wpa_s-> 4299 pending_join_dev_addr), 4300 freq); 4301 wpas_p2p_join_scan_req(wpa_s, freq, NULL, 0); 4302 return; 4303 } 4304 } 4305 4306 if (join < 0) 4307 join = 0; 4308 4309 wpa_s->p2p_auto_pd = 0; 4310 wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG; 4311 wpa_printf(MSG_DEBUG, "P2P: Auto PD with " MACSTR " join=%d", 4312 MAC2STR(wpa_s->pending_join_dev_addr), join); 4313 if (p2p_prov_disc_req(wpa_s->global->p2p, 4314 wpa_s->pending_join_dev_addr, 4315 wpa_s->pending_pd_config_methods, join, 4316 0, wpa_s->user_initiated_pd) < 0) { 4317 wpa_s->p2p_auto_pd = 0; 4318 wpa_msg_global(wpa_s, MSG_INFO, 4319 P2P_EVENT_PROV_DISC_FAILURE 4320 " p2p_dev_addr=" MACSTR " status=N/A", 4321 MAC2STR(wpa_s->pending_join_dev_addr)); 4322 } 4323 return; 4324 } 4325 4326 if (wpa_s->p2p_auto_join) { 4327 int join = wpas_p2p_peer_go(wpa_s, 4328 wpa_s->pending_join_dev_addr); 4329 if (join < 0) { 4330 wpa_printf(MSG_DEBUG, "P2P: Peer was not found to be " 4331 "running a GO -> use GO Negotiation"); 4332 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, 4333 wpa_s->p2p_pin, wpa_s->p2p_wps_method, 4334 wpa_s->p2p_persistent_group, 0, 0, 0, 4335 wpa_s->p2p_go_intent, 4336 wpa_s->p2p_connect_freq, 4337 wpa_s->p2p_persistent_id, 4338 wpa_s->p2p_pd_before_go_neg, 4339 wpa_s->p2p_go_ht40, 4340 wpa_s->p2p_go_vht); 4341 return; 4342 } 4343 4344 wpa_printf(MSG_DEBUG, "P2P: Peer was found running GO%s -> " 4345 "try to join the group", join ? "" : 4346 " in older scan"); 4347 if (!join) 4348 wpa_s->p2p_fallback_to_go_neg = 1; 4349 } 4350 4351 freq = p2p_get_oper_freq(wpa_s->global->p2p, 4352 wpa_s->pending_join_iface_addr); 4353 if (freq < 0 && 4354 p2p_get_interface_addr(wpa_s->global->p2p, 4355 wpa_s->pending_join_dev_addr, 4356 iface_addr) == 0 && 4357 os_memcmp(iface_addr, wpa_s->pending_join_dev_addr, ETH_ALEN) != 0) 4358 { 4359 wpa_printf(MSG_DEBUG, "P2P: Overwrite pending interface " 4360 "address for join from " MACSTR " to " MACSTR 4361 " based on newly discovered P2P peer entry", 4362 MAC2STR(wpa_s->pending_join_iface_addr), 4363 MAC2STR(iface_addr)); 4364 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, 4365 ETH_ALEN); 4366 4367 freq = p2p_get_oper_freq(wpa_s->global->p2p, 4368 wpa_s->pending_join_iface_addr); 4369 } 4370 if (freq >= 0) { 4371 wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency " 4372 "from P2P peer table: %d MHz", freq); 4373 } 4374 if (wpa_s->p2p_join_ssid_len) { 4375 wpa_printf(MSG_DEBUG, "P2P: Trying to find target GO BSS entry based on BSSID " 4376 MACSTR " and SSID %s", 4377 MAC2STR(wpa_s->pending_join_iface_addr), 4378 wpa_ssid_txt(wpa_s->p2p_join_ssid, 4379 wpa_s->p2p_join_ssid_len)); 4380 bss = wpa_bss_get(wpa_s, wpa_s->pending_join_iface_addr, 4381 wpa_s->p2p_join_ssid, 4382 wpa_s->p2p_join_ssid_len); 4383 } 4384 if (!bss) { 4385 wpa_printf(MSG_DEBUG, "P2P: Trying to find target GO BSS entry based on BSSID " 4386 MACSTR, MAC2STR(wpa_s->pending_join_iface_addr)); 4387 bss = wpa_bss_get_bssid_latest(wpa_s, 4388 wpa_s->pending_join_iface_addr); 4389 } 4390 if (bss) { 4391 freq = bss->freq; 4392 wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency " 4393 "from BSS table: %d MHz (SSID %s)", freq, 4394 wpa_ssid_txt(bss->ssid, bss->ssid_len)); 4395 } 4396 if (freq > 0) { 4397 u16 method; 4398 4399 if (wpas_check_freq_conflict(wpa_s, freq) > 0) { 4400 wpa_msg_global(wpa_s->parent, MSG_INFO, 4401 P2P_EVENT_GROUP_FORMATION_FAILURE 4402 "reason=FREQ_CONFLICT"); 4403 return; 4404 } 4405 4406 wpa_printf(MSG_DEBUG, "P2P: Send Provision Discovery Request " 4407 "prior to joining an existing group (GO " MACSTR 4408 " freq=%u MHz)", 4409 MAC2STR(wpa_s->pending_join_dev_addr), freq); 4410 wpa_s->pending_pd_before_join = 1; 4411 4412 switch (wpa_s->pending_join_wps_method) { 4413 case WPS_PIN_DISPLAY: 4414 method = WPS_CONFIG_KEYPAD; 4415 break; 4416 case WPS_PIN_KEYPAD: 4417 method = WPS_CONFIG_DISPLAY; 4418 break; 4419 case WPS_PBC: 4420 method = WPS_CONFIG_PUSHBUTTON; 4421 break; 4422 default: 4423 method = 0; 4424 break; 4425 } 4426 4427 if ((p2p_get_provisioning_info(wpa_s->global->p2p, 4428 wpa_s->pending_join_dev_addr) == 4429 method)) { 4430 /* 4431 * We have already performed provision discovery for 4432 * joining the group. Proceed directly to join 4433 * operation without duplicated provision discovery. */ 4434 wpa_printf(MSG_DEBUG, "P2P: Provision discovery " 4435 "with " MACSTR " already done - proceed to " 4436 "join", 4437 MAC2STR(wpa_s->pending_join_dev_addr)); 4438 wpa_s->pending_pd_before_join = 0; 4439 goto start; 4440 } 4441 4442 if (p2p_prov_disc_req(wpa_s->global->p2p, 4443 wpa_s->pending_join_dev_addr, method, 1, 4444 freq, wpa_s->user_initiated_pd) < 0) { 4445 wpa_printf(MSG_DEBUG, "P2P: Failed to send Provision " 4446 "Discovery Request before joining an " 4447 "existing group"); 4448 wpa_s->pending_pd_before_join = 0; 4449 goto start; 4450 } 4451 return; 4452 } 4453 4454 wpa_printf(MSG_DEBUG, "P2P: Failed to find BSS/GO - try again later"); 4455 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); 4456 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL); 4457 wpas_p2p_check_join_scan_limit(wpa_s); 4458 return; 4459 4460start: 4461 /* Start join operation immediately */ 4462 wpas_p2p_join_start(wpa_s, 0, NULL, 0); 4463} 4464 4465 4466static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq, 4467 const u8 *ssid, size_t ssid_len) 4468{ 4469 int ret; 4470 struct wpa_driver_scan_params params; 4471 struct wpabuf *wps_ie, *ies; 4472 size_t ielen; 4473 int freqs[2] = { 0, 0 }; 4474 4475 os_memset(¶ms, 0, sizeof(params)); 4476 4477 /* P2P Wildcard SSID */ 4478 params.num_ssids = 1; 4479 if (ssid && ssid_len) { 4480 params.ssids[0].ssid = ssid; 4481 params.ssids[0].ssid_len = ssid_len; 4482 os_memcpy(wpa_s->p2p_join_ssid, ssid, ssid_len); 4483 wpa_s->p2p_join_ssid_len = ssid_len; 4484 } else { 4485 params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID; 4486 params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN; 4487 wpa_s->p2p_join_ssid_len = 0; 4488 } 4489 4490 wpa_s->wps->dev.p2p = 1; 4491 wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT, &wpa_s->wps->dev, 4492 wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 0, 4493 NULL); 4494 if (wps_ie == NULL) { 4495 wpas_p2p_scan_res_join(wpa_s, NULL); 4496 return; 4497 } 4498 4499 ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p); 4500 ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen); 4501 if (ies == NULL) { 4502 wpabuf_free(wps_ie); 4503 wpas_p2p_scan_res_join(wpa_s, NULL); 4504 return; 4505 } 4506 wpabuf_put_buf(ies, wps_ie); 4507 wpabuf_free(wps_ie); 4508 4509 p2p_scan_ie(wpa_s->global->p2p, ies, NULL); 4510 4511 params.p2p_probe = 1; 4512 params.extra_ies = wpabuf_head(ies); 4513 params.extra_ies_len = wpabuf_len(ies); 4514 4515 if (!freq) { 4516 int oper_freq; 4517 /* 4518 * If freq is not provided, check the operating freq of the GO 4519 * and use a single channel scan on if possible. 4520 */ 4521 oper_freq = p2p_get_oper_freq(wpa_s->global->p2p, 4522 wpa_s->pending_join_iface_addr); 4523 if (oper_freq > 0) 4524 freq = oper_freq; 4525 } 4526 if (freq > 0) { 4527 freqs[0] = freq; 4528 params.freqs = freqs; 4529 } 4530 4531 /* 4532 * Run a scan to update BSS table and start Provision Discovery once 4533 * the new scan results become available. 4534 */ 4535 ret = wpa_drv_scan(wpa_s, ¶ms); 4536 if (!ret) { 4537 os_get_reltime(&wpa_s->scan_trigger_time); 4538 wpa_s->scan_res_handler = wpas_p2p_scan_res_join; 4539 wpa_s->own_scan_requested = 1; 4540 } 4541 4542 wpabuf_free(ies); 4543 4544 if (ret) { 4545 wpa_printf(MSG_DEBUG, "P2P: Failed to start scan for join - " 4546 "try again later"); 4547 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); 4548 eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL); 4549 wpas_p2p_check_join_scan_limit(wpa_s); 4550 } 4551} 4552 4553 4554static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx) 4555{ 4556 struct wpa_supplicant *wpa_s = eloop_ctx; 4557 wpas_p2p_join_scan_req(wpa_s, 0, NULL, 0); 4558} 4559 4560 4561static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr, 4562 const u8 *dev_addr, enum p2p_wps_method wps_method, 4563 int auto_join, int op_freq, 4564 const u8 *ssid, size_t ssid_len) 4565{ 4566 wpa_printf(MSG_DEBUG, "P2P: Request to join existing group (iface " 4567 MACSTR " dev " MACSTR " op_freq=%d)%s", 4568 MAC2STR(iface_addr), MAC2STR(dev_addr), op_freq, 4569 auto_join ? " (auto_join)" : ""); 4570 if (ssid && ssid_len) { 4571 wpa_printf(MSG_DEBUG, "P2P: Group SSID specified: %s", 4572 wpa_ssid_txt(ssid, ssid_len)); 4573 } 4574 4575 wpa_s->p2p_auto_pd = 0; 4576 wpa_s->p2p_auto_join = !!auto_join; 4577 os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN); 4578 os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN); 4579 wpa_s->pending_join_wps_method = wps_method; 4580 4581 /* Make sure we are not running find during connection establishment */ 4582 wpas_p2p_stop_find(wpa_s); 4583 4584 wpa_s->p2p_join_scan_count = 0; 4585 wpas_p2p_join_scan_req(wpa_s, op_freq, ssid, ssid_len); 4586 return 0; 4587} 4588 4589 4590static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s, int freq, 4591 const u8 *ssid, size_t ssid_len) 4592{ 4593 struct wpa_supplicant *group; 4594 struct p2p_go_neg_results res; 4595 struct wpa_bss *bss; 4596 4597 group = wpas_p2p_get_group_iface(wpa_s, 0, 0); 4598 if (group == NULL) 4599 return -1; 4600 if (group != wpa_s) { 4601 os_memcpy(group->p2p_pin, wpa_s->p2p_pin, 4602 sizeof(group->p2p_pin)); 4603 group->p2p_wps_method = wpa_s->p2p_wps_method; 4604 } else { 4605 /* 4606 * Need to mark the current interface for p2p_group_formation 4607 * when a separate group interface is not used. This is needed 4608 * to allow p2p_cancel stop a pending p2p_connect-join. 4609 * wpas_p2p_init_group_interface() addresses this for the case 4610 * where a separate group interface is used. 4611 */ 4612 wpa_s->global->p2p_group_formation = wpa_s; 4613 } 4614 4615 group->p2p_in_provisioning = 1; 4616 group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg; 4617 4618 os_memset(&res, 0, sizeof(res)); 4619 os_memcpy(res.peer_device_addr, wpa_s->pending_join_dev_addr, ETH_ALEN); 4620 os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr, 4621 ETH_ALEN); 4622 res.wps_method = wpa_s->pending_join_wps_method; 4623 if (freq && ssid && ssid_len) { 4624 res.freq = freq; 4625 res.ssid_len = ssid_len; 4626 os_memcpy(res.ssid, ssid, ssid_len); 4627 } else { 4628 bss = wpa_bss_get_bssid_latest(wpa_s, 4629 wpa_s->pending_join_iface_addr); 4630 if (bss) { 4631 res.freq = bss->freq; 4632 res.ssid_len = bss->ssid_len; 4633 os_memcpy(res.ssid, bss->ssid, bss->ssid_len); 4634 wpa_printf(MSG_DEBUG, "P2P: Join target GO operating frequency from BSS table: %d MHz (SSID %s)", 4635 bss->freq, 4636 wpa_ssid_txt(bss->ssid, bss->ssid_len)); 4637 } 4638 } 4639 4640 if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) { 4641 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel prior to " 4642 "starting client"); 4643 wpa_drv_cancel_remain_on_channel(wpa_s); 4644 wpa_s->off_channel_freq = 0; 4645 wpa_s->roc_waiting_drv_freq = 0; 4646 } 4647 wpas_start_wps_enrollee(group, &res); 4648 4649 /* 4650 * Allow a longer timeout for join-a-running-group than normal 15 4651 * second group formation timeout since the GO may not have authorized 4652 * our connection yet. 4653 */ 4654 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL); 4655 eloop_register_timeout(60, 0, wpas_p2p_group_formation_timeout, 4656 wpa_s, NULL); 4657 4658 return 0; 4659} 4660 4661 4662static int wpas_p2p_setup_freqs(struct wpa_supplicant *wpa_s, int freq, 4663 int *force_freq, int *pref_freq, int go) 4664{ 4665 struct wpa_used_freq_data *freqs; 4666 int res, best_freq, num_unused; 4667 unsigned int freq_in_use = 0, num, i; 4668 4669 freqs = os_calloc(wpa_s->num_multichan_concurrent, 4670 sizeof(struct wpa_used_freq_data)); 4671 if (!freqs) 4672 return -1; 4673 4674 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, 4675 wpa_s->num_multichan_concurrent); 4676 4677 /* 4678 * It is possible that the total number of used frequencies is bigger 4679 * than the number of frequencies used for P2P, so get the system wide 4680 * number of unused frequencies. 4681 */ 4682 num_unused = wpas_p2p_num_unused_channels(wpa_s); 4683 4684 wpa_printf(MSG_DEBUG, 4685 "P2P: Setup freqs: freq=%d num_MCC=%d shared_freqs=%u num_unused=%d", 4686 freq, wpa_s->num_multichan_concurrent, num, num_unused); 4687 4688 if (freq > 0) { 4689 int ret; 4690 if (go) 4691 ret = p2p_supported_freq(wpa_s->global->p2p, freq); 4692 else 4693 ret = p2p_supported_freq_cli(wpa_s->global->p2p, freq); 4694 if (!ret) { 4695 wpa_printf(MSG_DEBUG, "P2P: The forced channel " 4696 "(%u MHz) is not supported for P2P uses", 4697 freq); 4698 res = -3; 4699 goto exit_free; 4700 } 4701 4702 for (i = 0; i < num; i++) { 4703 if (freqs[i].freq == freq) 4704 freq_in_use = 1; 4705 } 4706 4707 if (num_unused <= 0 && !freq_in_use) { 4708 wpa_printf(MSG_DEBUG, "P2P: Cannot start P2P group on %u MHz as there are no available channels", 4709 freq); 4710 res = -2; 4711 goto exit_free; 4712 } 4713 wpa_printf(MSG_DEBUG, "P2P: Trying to force us to use the " 4714 "requested channel (%u MHz)", freq); 4715 *force_freq = freq; 4716 goto exit_ok; 4717 } 4718 4719 best_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num); 4720 4721 /* We have a candidate frequency to use */ 4722 if (best_freq > 0) { 4723 if (*pref_freq == 0 && num_unused > 0) { 4724 wpa_printf(MSG_DEBUG, "P2P: Try to prefer a frequency (%u MHz) we are already using", 4725 best_freq); 4726 *pref_freq = best_freq; 4727 } else { 4728 wpa_printf(MSG_DEBUG, "P2P: Try to force us to use frequency (%u MHz) which is already in use", 4729 best_freq); 4730 *force_freq = best_freq; 4731 } 4732 } else if (num_unused > 0) { 4733 wpa_printf(MSG_DEBUG, 4734 "P2P: Current operating channels are not available for P2P. Try to use another channel"); 4735 *force_freq = 0; 4736 } else { 4737 wpa_printf(MSG_DEBUG, 4738 "P2P: All channels are in use and none of them are P2P enabled. Cannot start P2P group"); 4739 res = -2; 4740 goto exit_free; 4741 } 4742 4743exit_ok: 4744 res = 0; 4745exit_free: 4746 os_free(freqs); 4747 return res; 4748} 4749 4750 4751/** 4752 * wpas_p2p_connect - Request P2P Group Formation to be started 4753 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 4754 * @peer_addr: Address of the peer P2P Device 4755 * @pin: PIN to use during provisioning or %NULL to indicate PBC mode 4756 * @persistent_group: Whether to create a persistent group 4757 * @auto_join: Whether to select join vs. GO Negotiation automatically 4758 * @join: Whether to join an existing group (as a client) instead of starting 4759 * Group Owner negotiation; @peer_addr is BSSID in that case 4760 * @auth: Whether to only authorize the connection instead of doing that and 4761 * initiating Group Owner negotiation 4762 * @go_intent: GO Intent or -1 to use default 4763 * @freq: Frequency for the group or 0 for auto-selection 4764 * @persistent_id: Persistent group credentials to use for forcing GO 4765 * parameters or -1 to generate new values (SSID/passphrase) 4766 * @pd: Whether to send Provision Discovery prior to GO Negotiation as an 4767 * interoperability workaround when initiating group formation 4768 * @ht40: Start GO with 40 MHz channel width 4769 * @vht: Start GO with VHT support 4770 * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on unspecified 4771 * failure, -2 on failure due to channel not currently available, 4772 * -3 if forced channel is not supported 4773 */ 4774int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr, 4775 const char *pin, enum p2p_wps_method wps_method, 4776 int persistent_group, int auto_join, int join, int auth, 4777 int go_intent, int freq, int persistent_id, int pd, 4778 int ht40, int vht) 4779{ 4780 int force_freq = 0, pref_freq = 0; 4781 int ret = 0, res; 4782 enum wpa_driver_if_type iftype; 4783 const u8 *if_addr; 4784 struct wpa_ssid *ssid = NULL; 4785 4786 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 4787 return -1; 4788 4789 if (persistent_id >= 0) { 4790 ssid = wpa_config_get_network(wpa_s->conf, persistent_id); 4791 if (ssid == NULL || ssid->disabled != 2 || 4792 ssid->mode != WPAS_MODE_P2P_GO) 4793 return -1; 4794 } 4795 4796 os_free(wpa_s->global->add_psk); 4797 wpa_s->global->add_psk = NULL; 4798 4799 wpa_s->global->p2p_fail_on_wps_complete = 0; 4800 4801 if (go_intent < 0) 4802 go_intent = wpa_s->conf->p2p_go_intent; 4803 4804 if (!auth) 4805 wpa_s->p2p_long_listen = 0; 4806 4807 wpa_s->p2p_wps_method = wps_method; 4808 wpa_s->p2p_persistent_group = !!persistent_group; 4809 wpa_s->p2p_persistent_id = persistent_id; 4810 wpa_s->p2p_go_intent = go_intent; 4811 wpa_s->p2p_connect_freq = freq; 4812 wpa_s->p2p_fallback_to_go_neg = 0; 4813 wpa_s->p2p_pd_before_go_neg = !!pd; 4814 wpa_s->p2p_go_ht40 = !!ht40; 4815 wpa_s->p2p_go_vht = !!vht; 4816 4817 if (pin) 4818 os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin)); 4819 else if (wps_method == WPS_PIN_DISPLAY) { 4820 ret = wps_generate_pin(); 4821 os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin), "%08d", 4822 ret); 4823 wpa_printf(MSG_DEBUG, "P2P: Randomly generated PIN: %s", 4824 wpa_s->p2p_pin); 4825 } else 4826 wpa_s->p2p_pin[0] = '\0'; 4827 4828 if (join || auto_join) { 4829 u8 iface_addr[ETH_ALEN], dev_addr[ETH_ALEN]; 4830 if (auth) { 4831 wpa_printf(MSG_DEBUG, "P2P: Authorize invitation to " 4832 "connect a running group from " MACSTR, 4833 MAC2STR(peer_addr)); 4834 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN); 4835 return ret; 4836 } 4837 os_memcpy(dev_addr, peer_addr, ETH_ALEN); 4838 if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr, 4839 iface_addr) < 0) { 4840 os_memcpy(iface_addr, peer_addr, ETH_ALEN); 4841 p2p_get_dev_addr(wpa_s->global->p2p, peer_addr, 4842 dev_addr); 4843 } 4844 if (auto_join) { 4845 os_get_reltime(&wpa_s->p2p_auto_started); 4846 wpa_printf(MSG_DEBUG, "P2P: Auto join started at " 4847 "%ld.%06ld", 4848 wpa_s->p2p_auto_started.sec, 4849 wpa_s->p2p_auto_started.usec); 4850 } 4851 wpa_s->user_initiated_pd = 1; 4852 if (wpas_p2p_join(wpa_s, iface_addr, dev_addr, wps_method, 4853 auto_join, freq, NULL, 0) < 0) 4854 return -1; 4855 return ret; 4856 } 4857 4858 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq, 4859 go_intent == 15); 4860 if (res) 4861 return res; 4862 wpas_p2p_set_own_freq_preference(wpa_s, 4863 force_freq ? force_freq : pref_freq); 4864 4865 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s); 4866 4867 if (wpa_s->create_p2p_iface) { 4868 /* Prepare to add a new interface for the group */ 4869 iftype = WPA_IF_P2P_GROUP; 4870 if (go_intent == 15) 4871 iftype = WPA_IF_P2P_GO; 4872 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) { 4873 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new " 4874 "interface for the group"); 4875 return -1; 4876 } 4877 4878 if_addr = wpa_s->pending_interface_addr; 4879 } else 4880 if_addr = wpa_s->own_addr; 4881 4882 if (auth) { 4883 if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method, 4884 go_intent, if_addr, 4885 force_freq, persistent_group, ssid, 4886 pref_freq) < 0) 4887 return -1; 4888 return ret; 4889 } 4890 4891 if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method, 4892 go_intent, if_addr, force_freq, 4893 persistent_group, ssid, pref_freq) < 0) { 4894 if (wpa_s->create_p2p_iface) 4895 wpas_p2p_remove_pending_group_interface(wpa_s); 4896 return -1; 4897 } 4898 return ret; 4899} 4900 4901 4902/** 4903 * wpas_p2p_remain_on_channel_cb - Indication of remain-on-channel start 4904 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 4905 * @freq: Frequency of the channel in MHz 4906 * @duration: Duration of the stay on the channel in milliseconds 4907 * 4908 * This callback is called when the driver indicates that it has started the 4909 * requested remain-on-channel duration. 4910 */ 4911void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s, 4912 unsigned int freq, unsigned int duration) 4913{ 4914 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 4915 return; 4916 if (wpa_s->off_channel_freq == wpa_s->pending_listen_freq) { 4917 p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq, 4918 wpa_s->pending_listen_duration); 4919 wpa_s->pending_listen_freq = 0; 4920 } else { 4921 wpa_printf(MSG_DEBUG, "P2P: Ignore remain-on-channel callback (off_channel_freq=%u pending_listen_freq=%d freq=%u duration=%u)", 4922 wpa_s->off_channel_freq, wpa_s->pending_listen_freq, 4923 freq, duration); 4924 } 4925} 4926 4927 4928int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s, unsigned int timeout) 4929{ 4930 /* Limit maximum Listen state time based on driver limitation. */ 4931 if (timeout > wpa_s->max_remain_on_chan) 4932 timeout = wpa_s->max_remain_on_chan; 4933 4934 return p2p_listen(wpa_s->global->p2p, timeout); 4935} 4936 4937 4938/** 4939 * wpas_p2p_cancel_remain_on_channel_cb - Remain-on-channel timeout 4940 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 4941 * @freq: Frequency of the channel in MHz 4942 * 4943 * This callback is called when the driver indicates that a remain-on-channel 4944 * operation has been completed, i.e., the duration on the requested channel 4945 * has timed out. 4946 */ 4947void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s, 4948 unsigned int freq) 4949{ 4950 wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel callback " 4951 "(p2p_long_listen=%d ms pending_action_tx=%p)", 4952 wpa_s->p2p_long_listen, offchannel_pending_action_tx(wpa_s)); 4953 wpas_p2p_listen_work_done(wpa_s); 4954 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 4955 return; 4956 if (wpa_s->p2p_long_listen > 0) 4957 wpa_s->p2p_long_listen -= wpa_s->max_remain_on_chan; 4958 if (p2p_listen_end(wpa_s->global->p2p, freq) > 0) 4959 return; /* P2P module started a new operation */ 4960 if (offchannel_pending_action_tx(wpa_s)) 4961 return; 4962 if (wpa_s->p2p_long_listen > 0) { 4963 wpa_printf(MSG_DEBUG, "P2P: Continuing long Listen state"); 4964 wpas_p2p_listen_start(wpa_s, wpa_s->p2p_long_listen); 4965 } else { 4966 /* 4967 * When listen duration is over, stop listen & update p2p_state 4968 * to IDLE. 4969 */ 4970 p2p_stop_listen(wpa_s->global->p2p); 4971 } 4972} 4973 4974 4975/** 4976 * wpas_p2p_group_remove - Remove a P2P group 4977 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 4978 * @ifname: Network interface name of the group interface or "*" to remove all 4979 * groups 4980 * Returns: 0 on success, -1 on failure 4981 * 4982 * This function is used to remove a P2P group. This can be used to disconnect 4983 * from a group in which the local end is a P2P Client or to end a P2P Group in 4984 * case the local end is the Group Owner. If a virtual network interface was 4985 * created for this group, that interface will be removed. Otherwise, only the 4986 * configured P2P group network will be removed from the interface. 4987 */ 4988int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname) 4989{ 4990 struct wpa_global *global = wpa_s->global; 4991 4992 if (os_strcmp(ifname, "*") == 0) { 4993 struct wpa_supplicant *prev; 4994 wpa_s = global->ifaces; 4995 while (wpa_s) { 4996 prev = wpa_s; 4997 wpa_s = wpa_s->next; 4998 if (prev->p2p_group_interface != 4999 NOT_P2P_GROUP_INTERFACE || 5000 (prev->current_ssid && 5001 prev->current_ssid->p2p_group)) 5002 wpas_p2p_disconnect(prev); 5003 } 5004 return 0; 5005 } 5006 5007 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 5008 if (os_strcmp(wpa_s->ifname, ifname) == 0) 5009 break; 5010 } 5011 5012 return wpas_p2p_disconnect(wpa_s); 5013} 5014 5015 5016static int wpas_p2p_select_go_freq(struct wpa_supplicant *wpa_s, int freq) 5017{ 5018 unsigned int r; 5019 5020 if (freq == 2) { 5021 wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 2.4 GHz " 5022 "band"); 5023 if (wpa_s->best_24_freq > 0 && 5024 p2p_supported_freq_go(wpa_s->global->p2p, 5025 wpa_s->best_24_freq)) { 5026 freq = wpa_s->best_24_freq; 5027 wpa_printf(MSG_DEBUG, "P2P: Use best 2.4 GHz band " 5028 "channel: %d MHz", freq); 5029 } else { 5030 os_get_random((u8 *) &r, sizeof(r)); 5031 freq = 2412 + (r % 3) * 25; 5032 wpa_printf(MSG_DEBUG, "P2P: Use random 2.4 GHz band " 5033 "channel: %d MHz", freq); 5034 } 5035 } 5036 5037 if (freq == 5) { 5038 wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 5 GHz " 5039 "band"); 5040 if (wpa_s->best_5_freq > 0 && 5041 p2p_supported_freq_go(wpa_s->global->p2p, 5042 wpa_s->best_5_freq)) { 5043 freq = wpa_s->best_5_freq; 5044 wpa_printf(MSG_DEBUG, "P2P: Use best 5 GHz band " 5045 "channel: %d MHz", freq); 5046 } else { 5047 os_get_random((u8 *) &r, sizeof(r)); 5048 freq = 5180 + (r % 4) * 20; 5049 if (!p2p_supported_freq_go(wpa_s->global->p2p, freq)) { 5050 wpa_printf(MSG_DEBUG, "P2P: Could not select " 5051 "5 GHz channel for P2P group"); 5052 return -1; 5053 } 5054 wpa_printf(MSG_DEBUG, "P2P: Use random 5 GHz band " 5055 "channel: %d MHz", freq); 5056 } 5057 } 5058 5059 if (freq > 0 && !p2p_supported_freq_go(wpa_s->global->p2p, freq)) { 5060 wpa_printf(MSG_DEBUG, "P2P: The forced channel for GO " 5061 "(%u MHz) is not supported for P2P uses", 5062 freq); 5063 return -1; 5064 } 5065 5066 return freq; 5067} 5068 5069 5070static int wpas_p2p_select_freq_no_pref(struct wpa_supplicant *wpa_s, 5071 struct p2p_go_neg_results *params, 5072 const struct p2p_channels *channels) 5073{ 5074 unsigned int i, r; 5075 5076 /* first try some random selection of the social channels */ 5077 os_get_random((u8 *) &r, sizeof(r)); 5078 5079 for (i = 0; i < 3; i++) { 5080 params->freq = 2412 + ((r + i) % 3) * 25; 5081 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) && 5082 freq_included(channels, params->freq)) 5083 goto out; 5084 } 5085 5086 /* try all channels in reg. class 81 */ 5087 for (i = 0; i < 11; i++) { 5088 params->freq = 2412 + i * 5; 5089 if (!wpas_p2p_disallowed_freq(wpa_s->global, params->freq) && 5090 freq_included(channels, params->freq)) 5091 goto out; 5092 } 5093 5094 wpa_printf(MSG_DEBUG, "P2P: No 2.4 GHz channel allowed"); 5095 return -1; 5096out: 5097 wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz (no preference known)", 5098 params->freq); 5099 return 0; 5100} 5101 5102 5103static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s, 5104 struct p2p_go_neg_results *params, 5105 int freq, int ht40, int vht, 5106 const struct p2p_channels *channels) 5107{ 5108 struct wpa_used_freq_data *freqs; 5109 unsigned int pref_freq, cand_freq; 5110 unsigned int num, i; 5111 5112 os_memset(params, 0, sizeof(*params)); 5113 params->role_go = 1; 5114 params->ht40 = ht40; 5115 params->vht = vht; 5116 if (freq) { 5117 if (!freq_included(channels, freq)) { 5118 wpa_printf(MSG_DEBUG, "P2P: Forced GO freq %d MHz not " 5119 "accepted", freq); 5120 return -1; 5121 } 5122 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on forced " 5123 "frequency %d MHz", freq); 5124 params->freq = freq; 5125 } else if (wpa_s->conf->p2p_oper_reg_class == 81 && 5126 wpa_s->conf->p2p_oper_channel >= 1 && 5127 wpa_s->conf->p2p_oper_channel <= 11 && 5128 freq_included(channels, 5129 2407 + 5 * wpa_s->conf->p2p_oper_channel)) { 5130 params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel; 5131 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured " 5132 "frequency %d MHz", params->freq); 5133 } else if ((wpa_s->conf->p2p_oper_reg_class == 115 || 5134 wpa_s->conf->p2p_oper_reg_class == 116 || 5135 wpa_s->conf->p2p_oper_reg_class == 117 || 5136 wpa_s->conf->p2p_oper_reg_class == 124 || 5137 wpa_s->conf->p2p_oper_reg_class == 126 || 5138 wpa_s->conf->p2p_oper_reg_class == 127) && 5139 freq_included(channels, 5140 5000 + 5 * wpa_s->conf->p2p_oper_channel)) { 5141 params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel; 5142 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured " 5143 "frequency %d MHz", params->freq); 5144 } else if (wpa_s->conf->p2p_oper_channel == 0 && 5145 wpa_s->best_overall_freq > 0 && 5146 p2p_supported_freq_go(wpa_s->global->p2p, 5147 wpa_s->best_overall_freq) && 5148 freq_included(channels, wpa_s->best_overall_freq)) { 5149 params->freq = wpa_s->best_overall_freq; 5150 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best overall " 5151 "channel %d MHz", params->freq); 5152 } else if (wpa_s->conf->p2p_oper_channel == 0 && 5153 wpa_s->best_24_freq > 0 && 5154 p2p_supported_freq_go(wpa_s->global->p2p, 5155 wpa_s->best_24_freq) && 5156 freq_included(channels, wpa_s->best_24_freq)) { 5157 params->freq = wpa_s->best_24_freq; 5158 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 2.4 GHz " 5159 "channel %d MHz", params->freq); 5160 } else if (wpa_s->conf->p2p_oper_channel == 0 && 5161 wpa_s->best_5_freq > 0 && 5162 p2p_supported_freq_go(wpa_s->global->p2p, 5163 wpa_s->best_5_freq) && 5164 freq_included(channels, wpa_s->best_5_freq)) { 5165 params->freq = wpa_s->best_5_freq; 5166 wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 5 GHz " 5167 "channel %d MHz", params->freq); 5168 } else if ((pref_freq = p2p_get_pref_freq(wpa_s->global->p2p, 5169 channels))) { 5170 params->freq = pref_freq; 5171 wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz from preferred " 5172 "channels", params->freq); 5173 } else { 5174 /* no preference, select some channel */ 5175 if (wpas_p2p_select_freq_no_pref(wpa_s, params, channels) < 0) 5176 return -1; 5177 } 5178 5179 freqs = os_calloc(wpa_s->num_multichan_concurrent, 5180 sizeof(struct wpa_used_freq_data)); 5181 if (!freqs) 5182 return -1; 5183 5184 num = wpas_p2p_valid_oper_freqs(wpa_s, freqs, 5185 wpa_s->num_multichan_concurrent); 5186 5187 cand_freq = wpas_p2p_pick_best_used_freq(wpa_s, freqs, num); 5188 5189 /* First try the best used frequency if possible */ 5190 if (!freq && cand_freq > 0 && freq_included(channels, cand_freq)) { 5191 params->freq = cand_freq; 5192 } else if (!freq) { 5193 /* Try any of the used frequencies */ 5194 for (i = 0; i < num; i++) { 5195 if (freq_included(channels, freqs[i].freq)) { 5196 wpa_printf(MSG_DEBUG, "P2P: Force GO on a channel we are already using (%u MHz)", 5197 freqs[i].freq); 5198 params->freq = freqs[i].freq; 5199 break; 5200 } 5201 } 5202 5203 if (i == num) { 5204 if (wpas_p2p_num_unused_channels(wpa_s) <= 0) { 5205 wpa_printf(MSG_DEBUG, "P2P: Cannot force GO on any of the channels we are already using"); 5206 os_free(freqs); 5207 return -1; 5208 } else { 5209 wpa_printf(MSG_DEBUG, "P2P: Cannot force GO on any of the channels we are already using. Use one of the free channels"); 5210 } 5211 } 5212 } else { 5213 for (i = 0; i < num; i++) { 5214 if (freqs[i].freq == freq) 5215 break; 5216 } 5217 5218 if (i == num) { 5219 if (wpas_p2p_num_unused_channels(wpa_s) <= 0) { 5220 if (freq) 5221 wpa_printf(MSG_DEBUG, "P2P: Cannot force GO on freq (%u MHz) as all the channels are in use", freq); 5222 os_free(freqs); 5223 return -1; 5224 } else { 5225 wpa_printf(MSG_DEBUG, "P2P: Use one of the free channels"); 5226 } 5227 } 5228 } 5229 5230 os_free(freqs); 5231 return 0; 5232} 5233 5234 5235static struct wpa_supplicant * 5236wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated, 5237 int go) 5238{ 5239 struct wpa_supplicant *group_wpa_s; 5240 5241 if (!wpas_p2p_create_iface(wpa_s)) { 5242 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use same interface for group " 5243 "operations"); 5244 wpa_s->p2p_first_connection_timeout = 0; 5245 return wpa_s; 5246 } 5247 5248 if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO : 5249 WPA_IF_P2P_CLIENT) < 0) { 5250 wpa_msg_global(wpa_s, MSG_ERROR, 5251 "P2P: Failed to add group interface"); 5252 return NULL; 5253 } 5254 group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go); 5255 if (group_wpa_s == NULL) { 5256 wpa_msg_global(wpa_s, MSG_ERROR, 5257 "P2P: Failed to initialize group interface"); 5258 wpas_p2p_remove_pending_group_interface(wpa_s); 5259 return NULL; 5260 } 5261 5262 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use separate group interface %s", 5263 group_wpa_s->ifname); 5264 group_wpa_s->p2p_first_connection_timeout = 0; 5265 return group_wpa_s; 5266} 5267 5268 5269/** 5270 * wpas_p2p_group_add - Add a new P2P group with local end as Group Owner 5271 * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface() 5272 * @persistent_group: Whether to create a persistent group 5273 * @freq: Frequency for the group or 0 to indicate no hardcoding 5274 * @ht40: Start GO with 40 MHz channel width 5275 * @vht: Start GO with VHT support 5276 * Returns: 0 on success, -1 on failure 5277 * 5278 * This function creates a new P2P group with the local end as the Group Owner, 5279 * i.e., without using Group Owner Negotiation. 5280 */ 5281int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group, 5282 int freq, int ht40, int vht) 5283{ 5284 struct p2p_go_neg_results params; 5285 5286 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 5287 return -1; 5288 5289 os_free(wpa_s->global->add_psk); 5290 wpa_s->global->add_psk = NULL; 5291 5292 /* Make sure we are not running find during connection establishment */ 5293 wpa_printf(MSG_DEBUG, "P2P: Stop any on-going P2P FIND"); 5294 wpas_p2p_stop_find_oper(wpa_s); 5295 5296 freq = wpas_p2p_select_go_freq(wpa_s, freq); 5297 if (freq < 0) 5298 return -1; 5299 5300 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, ht40, vht, NULL)) 5301 return -1; 5302 if (params.freq && 5303 !p2p_supported_freq_go(wpa_s->global->p2p, params.freq)) { 5304 wpa_printf(MSG_DEBUG, "P2P: The selected channel for GO " 5305 "(%u MHz) is not supported for P2P uses", 5306 params.freq); 5307 return -1; 5308 } 5309 p2p_go_params(wpa_s->global->p2p, ¶ms); 5310 params.persistent_group = persistent_group; 5311 5312 wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1); 5313 if (wpa_s == NULL) 5314 return -1; 5315 wpas_start_wps_go(wpa_s, ¶ms, 0); 5316 5317 return 0; 5318} 5319 5320 5321static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s, 5322 struct wpa_ssid *params, int addr_allocated, 5323 int freq) 5324{ 5325 struct wpa_ssid *ssid; 5326 5327 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0); 5328 if (wpa_s == NULL) 5329 return -1; 5330 wpa_s->p2p_last_4way_hs_fail = NULL; 5331 5332 wpa_supplicant_ap_deinit(wpa_s); 5333 5334 ssid = wpa_config_add_network(wpa_s->conf); 5335 if (ssid == NULL) 5336 return -1; 5337 wpa_config_set_network_defaults(ssid); 5338 ssid->temporary = 1; 5339 ssid->proto = WPA_PROTO_RSN; 5340 ssid->pairwise_cipher = WPA_CIPHER_CCMP; 5341 ssid->group_cipher = WPA_CIPHER_CCMP; 5342 ssid->key_mgmt = WPA_KEY_MGMT_PSK; 5343 ssid->ssid = os_malloc(params->ssid_len); 5344 if (ssid->ssid == NULL) { 5345 wpa_config_remove_network(wpa_s->conf, ssid->id); 5346 return -1; 5347 } 5348 os_memcpy(ssid->ssid, params->ssid, params->ssid_len); 5349 ssid->ssid_len = params->ssid_len; 5350 ssid->p2p_group = 1; 5351 ssid->export_keys = 1; 5352 if (params->psk_set) { 5353 os_memcpy(ssid->psk, params->psk, 32); 5354 ssid->psk_set = 1; 5355 } 5356 if (params->passphrase) 5357 ssid->passphrase = os_strdup(params->passphrase); 5358 5359 wpa_s->show_group_started = 1; 5360 wpa_s->p2p_in_invitation = 1; 5361 wpa_s->p2p_invite_go_freq = freq; 5362 5363 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent, 5364 NULL); 5365 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0, 5366 wpas_p2p_group_formation_timeout, 5367 wpa_s->parent, NULL); 5368 wpa_supplicant_select_network(wpa_s, ssid); 5369 5370 return 0; 5371} 5372 5373 5374int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s, 5375 struct wpa_ssid *ssid, int addr_allocated, 5376 int force_freq, int neg_freq, int ht40, 5377 int vht, const struct p2p_channels *channels, 5378 int connection_timeout) 5379{ 5380 struct p2p_go_neg_results params; 5381 int go = 0, freq; 5382 5383 if (ssid->disabled != 2 || ssid->ssid == NULL) 5384 return -1; 5385 5386 if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) && 5387 go == (ssid->mode == WPAS_MODE_P2P_GO)) { 5388 wpa_printf(MSG_DEBUG, "P2P: Requested persistent group is " 5389 "already running"); 5390 return 0; 5391 } 5392 5393 os_free(wpa_s->global->add_psk); 5394 wpa_s->global->add_psk = NULL; 5395 5396 /* Make sure we are not running find during connection establishment */ 5397 wpas_p2p_stop_find_oper(wpa_s); 5398 5399 wpa_s->p2p_fallback_to_go_neg = 0; 5400 5401 if (force_freq > 0) { 5402 freq = wpas_p2p_select_go_freq(wpa_s, force_freq); 5403 if (freq < 0) 5404 return -1; 5405 } else { 5406 freq = wpas_p2p_select_go_freq(wpa_s, neg_freq); 5407 if (freq < 0 || (freq > 0 && !freq_included(channels, freq))) 5408 freq = 0; 5409 } 5410 5411 if (ssid->mode == WPAS_MODE_INFRA) 5412 return wpas_start_p2p_client(wpa_s, ssid, addr_allocated, freq); 5413 5414 if (ssid->mode != WPAS_MODE_P2P_GO) 5415 return -1; 5416 5417 if (wpas_p2p_init_go_params(wpa_s, ¶ms, freq, ht40, vht, channels)) 5418 return -1; 5419 5420 params.role_go = 1; 5421 params.psk_set = ssid->psk_set; 5422 if (params.psk_set) 5423 os_memcpy(params.psk, ssid->psk, sizeof(params.psk)); 5424 if (ssid->passphrase) { 5425 if (os_strlen(ssid->passphrase) >= sizeof(params.passphrase)) { 5426 wpa_printf(MSG_ERROR, "P2P: Invalid passphrase in " 5427 "persistent group"); 5428 return -1; 5429 } 5430 os_strlcpy(params.passphrase, ssid->passphrase, 5431 sizeof(params.passphrase)); 5432 } 5433 os_memcpy(params.ssid, ssid->ssid, ssid->ssid_len); 5434 params.ssid_len = ssid->ssid_len; 5435 params.persistent_group = 1; 5436 5437 wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1); 5438 if (wpa_s == NULL) 5439 return -1; 5440 5441 wpa_s->p2p_first_connection_timeout = connection_timeout; 5442 wpas_start_wps_go(wpa_s, ¶ms, 0); 5443 5444 return 0; 5445} 5446 5447 5448static void wpas_p2p_ie_update(void *ctx, struct wpabuf *beacon_ies, 5449 struct wpabuf *proberesp_ies) 5450{ 5451 struct wpa_supplicant *wpa_s = ctx; 5452 if (wpa_s->ap_iface) { 5453 struct hostapd_data *hapd = wpa_s->ap_iface->bss[0]; 5454 if (!(hapd->conf->p2p & P2P_GROUP_OWNER)) { 5455 wpabuf_free(beacon_ies); 5456 wpabuf_free(proberesp_ies); 5457 return; 5458 } 5459 if (beacon_ies) { 5460 wpabuf_free(hapd->p2p_beacon_ie); 5461 hapd->p2p_beacon_ie = beacon_ies; 5462 } 5463 wpabuf_free(hapd->p2p_probe_resp_ie); 5464 hapd->p2p_probe_resp_ie = proberesp_ies; 5465 } else { 5466 wpabuf_free(beacon_ies); 5467 wpabuf_free(proberesp_ies); 5468 } 5469 wpa_supplicant_ap_update_beacon(wpa_s); 5470} 5471 5472 5473static void wpas_p2p_idle_update(void *ctx, int idle) 5474{ 5475 struct wpa_supplicant *wpa_s = ctx; 5476 if (!wpa_s->ap_iface) 5477 return; 5478 wpa_printf(MSG_DEBUG, "P2P: GO - group %sidle", idle ? "" : "not "); 5479 if (idle) { 5480 if (wpa_s->global->p2p_fail_on_wps_complete && 5481 wpa_s->p2p_in_provisioning) { 5482 wpas_p2p_grpform_fail_after_wps(wpa_s); 5483 return; 5484 } 5485 wpas_p2p_set_group_idle_timeout(wpa_s); 5486 } else 5487 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL); 5488} 5489 5490 5491struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s, 5492 struct wpa_ssid *ssid) 5493{ 5494 struct p2p_group *group; 5495 struct p2p_group_config *cfg; 5496 5497 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 5498 return NULL; 5499 5500 cfg = os_zalloc(sizeof(*cfg)); 5501 if (cfg == NULL) 5502 return NULL; 5503 5504 if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect) 5505 cfg->persistent_group = 2; 5506 else if (ssid->p2p_persistent_group) 5507 cfg->persistent_group = 1; 5508 os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN); 5509 if (wpa_s->max_stations && 5510 wpa_s->max_stations < wpa_s->conf->max_num_sta) 5511 cfg->max_clients = wpa_s->max_stations; 5512 else 5513 cfg->max_clients = wpa_s->conf->max_num_sta; 5514 os_memcpy(cfg->ssid, ssid->ssid, ssid->ssid_len); 5515 cfg->ssid_len = ssid->ssid_len; 5516 cfg->freq = ssid->frequency; 5517 cfg->cb_ctx = wpa_s; 5518 cfg->ie_update = wpas_p2p_ie_update; 5519 cfg->idle_update = wpas_p2p_idle_update; 5520 5521 group = p2p_group_init(wpa_s->global->p2p, cfg); 5522 if (group == NULL) 5523 os_free(cfg); 5524 if (ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION) 5525 p2p_group_notif_formation_done(group); 5526 wpa_s->p2p_group = group; 5527 return group; 5528} 5529 5530 5531void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr, 5532 int registrar) 5533{ 5534 struct wpa_ssid *ssid = wpa_s->current_ssid; 5535 5536 if (!wpa_s->p2p_in_provisioning) { 5537 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS success event - P2P " 5538 "provisioning not in progress"); 5539 return; 5540 } 5541 5542 if (ssid && ssid->mode == WPAS_MODE_INFRA) { 5543 u8 go_dev_addr[ETH_ALEN]; 5544 os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN); 5545 wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid, 5546 ssid->ssid_len); 5547 /* Clear any stored provisioning info */ 5548 p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr); 5549 } 5550 5551 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent, 5552 NULL); 5553 wpa_s->p2p_go_group_formation_completed = 1; 5554 if (ssid && ssid->mode == WPAS_MODE_INFRA) { 5555 /* 5556 * Use a separate timeout for initial data connection to 5557 * complete to allow the group to be removed automatically if 5558 * something goes wrong in this step before the P2P group idle 5559 * timeout mechanism is taken into use. 5560 */ 5561 wpa_dbg(wpa_s, MSG_DEBUG, 5562 "P2P: Re-start group formation timeout (%d seconds) as client for initial connection", 5563 P2P_MAX_INITIAL_CONN_WAIT); 5564 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0, 5565 wpas_p2p_group_formation_timeout, 5566 wpa_s->parent, NULL); 5567 } else if (ssid) { 5568 /* 5569 * Use a separate timeout for initial data connection to 5570 * complete to allow the group to be removed automatically if 5571 * the client does not complete data connection successfully. 5572 */ 5573 wpa_dbg(wpa_s, MSG_DEBUG, 5574 "P2P: Re-start group formation timeout (%d seconds) as GO for initial connection", 5575 P2P_MAX_INITIAL_CONN_WAIT_GO); 5576 eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT_GO, 0, 5577 wpas_p2p_group_formation_timeout, 5578 wpa_s->parent, NULL); 5579 /* 5580 * Complete group formation on first successful data connection 5581 */ 5582 wpa_s->p2p_go_group_formation_completed = 0; 5583 } 5584 if (wpa_s->global->p2p) 5585 p2p_wps_success_cb(wpa_s->global->p2p, peer_addr); 5586 wpas_group_formation_completed(wpa_s, 1); 5587} 5588 5589 5590void wpas_p2p_wps_failed(struct wpa_supplicant *wpa_s, 5591 struct wps_event_fail *fail) 5592{ 5593 if (!wpa_s->p2p_in_provisioning) { 5594 wpa_printf(MSG_DEBUG, "P2P: Ignore WPS fail event - P2P " 5595 "provisioning not in progress"); 5596 return; 5597 } 5598 5599 if (wpa_s->go_params) { 5600 p2p_clear_provisioning_info( 5601 wpa_s->global->p2p, 5602 wpa_s->go_params->peer_device_addr); 5603 } 5604 5605 wpas_notify_p2p_wps_failed(wpa_s, fail); 5606 5607 if (wpa_s == wpa_s->global->p2p_group_formation) { 5608 /* 5609 * Allow some time for the failed WPS negotiation exchange to 5610 * complete, but remove the group since group formation cannot 5611 * succeed after provisioning failure. 5612 */ 5613 wpa_printf(MSG_DEBUG, "P2P: WPS step failed during group formation - reject connection from timeout"); 5614 wpa_s->global->p2p_fail_on_wps_complete = 1; 5615 eloop_deplete_timeout(0, 50000, 5616 wpas_p2p_group_formation_timeout, 5617 wpa_s->parent, NULL); 5618 } 5619} 5620 5621 5622int wpas_p2p_wps_eapol_cb(struct wpa_supplicant *wpa_s) 5623{ 5624 if (!wpa_s->global->p2p_fail_on_wps_complete || 5625 !wpa_s->p2p_in_provisioning) 5626 return 0; 5627 5628 wpas_p2p_grpform_fail_after_wps(wpa_s); 5629 5630 return 1; 5631} 5632 5633 5634int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr, 5635 const char *config_method, 5636 enum wpas_p2p_prov_disc_use use) 5637{ 5638 u16 config_methods; 5639 5640 wpa_s->p2p_fallback_to_go_neg = 0; 5641 wpa_s->pending_pd_use = NORMAL_PD; 5642 if (os_strncmp(config_method, "display", 7) == 0) 5643 config_methods = WPS_CONFIG_DISPLAY; 5644 else if (os_strncmp(config_method, "keypad", 6) == 0) 5645 config_methods = WPS_CONFIG_KEYPAD; 5646 else if (os_strncmp(config_method, "pbc", 3) == 0 || 5647 os_strncmp(config_method, "pushbutton", 10) == 0) 5648 config_methods = WPS_CONFIG_PUSHBUTTON; 5649 else { 5650 wpa_printf(MSG_DEBUG, "P2P: Unknown config method"); 5651 return -1; 5652 } 5653 5654 if (use == WPAS_P2P_PD_AUTO) { 5655 os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN); 5656 wpa_s->pending_pd_config_methods = config_methods; 5657 wpa_s->p2p_auto_pd = 1; 5658 wpa_s->p2p_auto_join = 0; 5659 wpa_s->pending_pd_before_join = 0; 5660 wpa_s->auto_pd_scan_retry = 0; 5661 wpas_p2p_stop_find(wpa_s); 5662 wpa_s->p2p_join_scan_count = 0; 5663 os_get_reltime(&wpa_s->p2p_auto_started); 5664 wpa_printf(MSG_DEBUG, "P2P: Auto PD started at %ld.%06ld", 5665 wpa_s->p2p_auto_started.sec, 5666 wpa_s->p2p_auto_started.usec); 5667 wpas_p2p_join_scan(wpa_s, NULL); 5668 return 0; 5669 } 5670 5671 if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled) 5672 return -1; 5673 5674 return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr, 5675 config_methods, use == WPAS_P2P_PD_FOR_JOIN, 5676 0, 1); 5677} 5678 5679 5680int wpas_p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, 5681 char *end) 5682{ 5683 return p2p_scan_result_text(ies, ies_len, buf, end); 5684} 5685 5686 5687static void wpas_p2p_clear_pending_action_tx(struct wpa_supplicant *wpa_s) 5688{ 5689 if (!offchannel_pending_action_tx(wpa_s)) 5690 return; 5691 5692 wpas_p2p_action_tx_clear(wpa_s); 5693 5694 wpa_printf(MSG_DEBUG, "P2P: Drop pending Action TX due to new " 5695 "operation request"); 5696 offchannel_clear_pending_action_tx(wpa_s); 5697} 5698 5699 5700int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout, 5701 enum p2p_discovery_type type, 5702 unsigned int num_req_dev_types, const u8 *req_dev_types, 5703 const u8 *dev_id, unsigned int search_delay) 5704{ 5705 wpas_p2p_clear_pending_action_tx(wpa_s); 5706 wpa_s->p2p_long_listen = 0; 5707 5708 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL || 5709 wpa_s->p2p_in_provisioning) 5710 return -1; 5711 5712 wpa_supplicant_cancel_sched_scan(wpa_s); 5713 5714 return p2p_find(wpa_s->global->p2p, timeout, type, 5715 num_req_dev_types, req_dev_types, dev_id, 5716 search_delay); 5717} 5718 5719 5720static int wpas_p2p_stop_find_oper(struct wpa_supplicant *wpa_s) 5721{ 5722 wpas_p2p_clear_pending_action_tx(wpa_s); 5723 wpa_s->p2p_long_listen = 0; 5724 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL); 5725 eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL); 5726 5727 if (wpa_s->global->p2p) 5728 p2p_stop_find(wpa_s->global->p2p); 5729 5730 return 0; 5731} 5732 5733 5734void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s) 5735{ 5736 if (wpas_p2p_stop_find_oper(wpa_s) > 0) 5737 return; 5738 wpas_p2p_remove_pending_group_interface(wpa_s); 5739} 5740 5741 5742static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx) 5743{ 5744 struct wpa_supplicant *wpa_s = eloop_ctx; 5745 wpa_s->p2p_long_listen = 0; 5746} 5747 5748 5749int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout) 5750{ 5751 int res; 5752 5753 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 5754 return -1; 5755 5756 wpa_supplicant_cancel_sched_scan(wpa_s); 5757 wpas_p2p_clear_pending_action_tx(wpa_s); 5758 5759 if (timeout == 0) { 5760 /* 5761 * This is a request for unlimited Listen state. However, at 5762 * least for now, this is mapped to a Listen state for one 5763 * hour. 5764 */ 5765 timeout = 3600; 5766 } 5767 eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL); 5768 wpa_s->p2p_long_listen = 0; 5769 5770 /* 5771 * Stop previous find/listen operation to avoid trying to request a new 5772 * remain-on-channel operation while the driver is still running the 5773 * previous one. 5774 */ 5775 if (wpa_s->global->p2p) 5776 p2p_stop_find(wpa_s->global->p2p); 5777 5778 res = wpas_p2p_listen_start(wpa_s, timeout * 1000); 5779 if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) { 5780 wpa_s->p2p_long_listen = timeout * 1000; 5781 eloop_register_timeout(timeout, 0, 5782 wpas_p2p_long_listen_timeout, 5783 wpa_s, NULL); 5784 } 5785 5786 return res; 5787} 5788 5789 5790int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, struct wpa_bss *bss, 5791 u8 *buf, size_t len, int p2p_group) 5792{ 5793 struct wpabuf *p2p_ie; 5794 int ret; 5795 5796 if (wpa_s->global->p2p_disabled) 5797 return -1; 5798 if (wpa_s->global->p2p == NULL) 5799 return -1; 5800 if (bss == NULL) 5801 return -1; 5802 5803 p2p_ie = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE); 5804 ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len, 5805 p2p_group, p2p_ie); 5806 wpabuf_free(p2p_ie); 5807 5808 return ret; 5809} 5810 5811 5812int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr, 5813 const u8 *dst, const u8 *bssid, 5814 const u8 *ie, size_t ie_len, int ssi_signal) 5815{ 5816 if (wpa_s->global->p2p_disabled) 5817 return 0; 5818 if (wpa_s->global->p2p == NULL) 5819 return 0; 5820 5821 switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid, 5822 ie, ie_len)) { 5823 case P2P_PREQ_NOT_P2P: 5824 wpas_notify_preq(wpa_s, addr, dst, bssid, ie, ie_len, 5825 ssi_signal); 5826 /* fall through */ 5827 case P2P_PREQ_MALFORMED: 5828 case P2P_PREQ_NOT_LISTEN: 5829 case P2P_PREQ_NOT_PROCESSED: 5830 default: /* make gcc happy */ 5831 return 0; 5832 case P2P_PREQ_PROCESSED: 5833 return 1; 5834 } 5835} 5836 5837 5838void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da, 5839 const u8 *sa, const u8 *bssid, 5840 u8 category, const u8 *data, size_t len, int freq) 5841{ 5842 if (wpa_s->global->p2p_disabled) 5843 return; 5844 if (wpa_s->global->p2p == NULL) 5845 return; 5846 5847 p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len, 5848 freq); 5849} 5850 5851 5852void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies) 5853{ 5854 if (wpa_s->global->p2p_disabled) 5855 return; 5856 if (wpa_s->global->p2p == NULL) 5857 return; 5858 5859 p2p_scan_ie(wpa_s->global->p2p, ies, NULL); 5860} 5861 5862 5863static void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s) 5864{ 5865 p2p_group_deinit(wpa_s->p2p_group); 5866 wpa_s->p2p_group = NULL; 5867 5868 wpa_s->ap_configured_cb = NULL; 5869 wpa_s->ap_configured_cb_ctx = NULL; 5870 wpa_s->ap_configured_cb_data = NULL; 5871 wpa_s->connect_without_scan = NULL; 5872} 5873 5874 5875int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr) 5876{ 5877 wpa_s->p2p_long_listen = 0; 5878 5879 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 5880 return -1; 5881 5882 return p2p_reject(wpa_s->global->p2p, addr); 5883} 5884 5885 5886/* Invite to reinvoke a persistent group */ 5887int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr, 5888 struct wpa_ssid *ssid, const u8 *go_dev_addr, int freq, 5889 int ht40, int vht, int pref_freq) 5890{ 5891 enum p2p_invite_role role; 5892 u8 *bssid = NULL; 5893 int force_freq = 0; 5894 int res; 5895 int no_pref_freq_given = pref_freq == 0; 5896 5897 wpa_s->global->p2p_invite_group = NULL; 5898 if (peer_addr) 5899 os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN); 5900 else 5901 os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN); 5902 5903 wpa_s->p2p_persistent_go_freq = freq; 5904 wpa_s->p2p_go_ht40 = !!ht40; 5905 if (ssid->mode == WPAS_MODE_P2P_GO) { 5906 role = P2P_INVITE_ROLE_GO; 5907 if (peer_addr == NULL) { 5908 wpa_printf(MSG_DEBUG, "P2P: Missing peer " 5909 "address in invitation command"); 5910 return -1; 5911 } 5912 if (wpas_p2p_create_iface(wpa_s)) { 5913 if (wpas_p2p_add_group_interface(wpa_s, 5914 WPA_IF_P2P_GO) < 0) { 5915 wpa_printf(MSG_ERROR, "P2P: Failed to " 5916 "allocate a new interface for the " 5917 "group"); 5918 return -1; 5919 } 5920 bssid = wpa_s->pending_interface_addr; 5921 } else 5922 bssid = wpa_s->own_addr; 5923 } else { 5924 role = P2P_INVITE_ROLE_CLIENT; 5925 peer_addr = ssid->bssid; 5926 } 5927 wpa_s->pending_invite_ssid_id = ssid->id; 5928 5929 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq, 5930 role == P2P_INVITE_ROLE_GO); 5931 if (res) 5932 return res; 5933 5934 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 5935 return -1; 5936 5937 if (wpa_s->parent->conf->p2p_ignore_shared_freq && 5938 no_pref_freq_given && pref_freq > 0 && 5939 wpa_s->num_multichan_concurrent > 1 && 5940 wpas_p2p_num_unused_channels(wpa_s) > 0) { 5941 wpa_printf(MSG_DEBUG, "P2P: Ignore own channel preference %d MHz for invitation due to p2p_ignore_shared_freq=1 configuration", 5942 pref_freq); 5943 pref_freq = 0; 5944 } 5945 5946 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid, 5947 ssid->ssid, ssid->ssid_len, force_freq, go_dev_addr, 5948 1, pref_freq, -1); 5949} 5950 5951 5952/* Invite to join an active group */ 5953int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname, 5954 const u8 *peer_addr, const u8 *go_dev_addr) 5955{ 5956 struct wpa_global *global = wpa_s->global; 5957 enum p2p_invite_role role; 5958 u8 *bssid = NULL; 5959 struct wpa_ssid *ssid; 5960 int persistent; 5961 int freq = 0, force_freq = 0, pref_freq = 0; 5962 int res; 5963 5964 wpa_s->p2p_persistent_go_freq = 0; 5965 wpa_s->p2p_go_ht40 = 0; 5966 wpa_s->p2p_go_vht = 0; 5967 5968 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 5969 if (os_strcmp(wpa_s->ifname, ifname) == 0) 5970 break; 5971 } 5972 if (wpa_s == NULL) { 5973 wpa_printf(MSG_DEBUG, "P2P: Interface '%s' not found", ifname); 5974 return -1; 5975 } 5976 5977 ssid = wpa_s->current_ssid; 5978 if (ssid == NULL) { 5979 wpa_printf(MSG_DEBUG, "P2P: No current SSID to use for " 5980 "invitation"); 5981 return -1; 5982 } 5983 5984 wpa_s->global->p2p_invite_group = wpa_s; 5985 persistent = ssid->p2p_persistent_group && 5986 wpas_p2p_get_persistent(wpa_s->parent, peer_addr, 5987 ssid->ssid, ssid->ssid_len); 5988 5989 if (ssid->mode == WPAS_MODE_P2P_GO) { 5990 role = P2P_INVITE_ROLE_ACTIVE_GO; 5991 bssid = wpa_s->own_addr; 5992 if (go_dev_addr == NULL) 5993 go_dev_addr = wpa_s->global->p2p_dev_addr; 5994 freq = ssid->frequency; 5995 } else { 5996 role = P2P_INVITE_ROLE_CLIENT; 5997 if (wpa_s->wpa_state < WPA_ASSOCIATED) { 5998 wpa_printf(MSG_DEBUG, "P2P: Not associated - cannot " 5999 "invite to current group"); 6000 return -1; 6001 } 6002 bssid = wpa_s->bssid; 6003 if (go_dev_addr == NULL && 6004 !is_zero_ether_addr(wpa_s->go_dev_addr)) 6005 go_dev_addr = wpa_s->go_dev_addr; 6006 freq = wpa_s->current_bss ? wpa_s->current_bss->freq : 6007 (int) wpa_s->assoc_freq; 6008 } 6009 wpa_s->parent->pending_invite_ssid_id = -1; 6010 6011 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6012 return -1; 6013 6014 res = wpas_p2p_setup_freqs(wpa_s, freq, &force_freq, &pref_freq, 6015 role == P2P_INVITE_ROLE_ACTIVE_GO); 6016 if (res) 6017 return res; 6018 wpas_p2p_set_own_freq_preference(wpa_s, force_freq); 6019 6020 return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid, 6021 ssid->ssid, ssid->ssid_len, force_freq, 6022 go_dev_addr, persistent, pref_freq, -1); 6023} 6024 6025 6026void wpas_p2p_completed(struct wpa_supplicant *wpa_s) 6027{ 6028 struct wpa_ssid *ssid = wpa_s->current_ssid; 6029 u8 go_dev_addr[ETH_ALEN]; 6030 int network_id = -1; 6031 int persistent; 6032 int freq; 6033 u8 ip[3 * 4]; 6034 char ip_addr[100]; 6035 6036 if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION) { 6037 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 6038 wpa_s->parent, NULL); 6039 } 6040 6041 if (!wpa_s->show_group_started || !ssid) 6042 return; 6043 6044 wpa_s->show_group_started = 0; 6045 6046 os_memset(go_dev_addr, 0, ETH_ALEN); 6047 if (ssid->bssid_set) 6048 os_memcpy(go_dev_addr, ssid->bssid, ETH_ALEN); 6049 persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid, 6050 ssid->ssid_len); 6051 os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN); 6052 6053 if (wpa_s->global->p2p_group_formation == wpa_s) 6054 wpa_s->global->p2p_group_formation = NULL; 6055 6056 freq = wpa_s->current_bss ? wpa_s->current_bss->freq : 6057 (int) wpa_s->assoc_freq; 6058 6059 ip_addr[0] = '\0'; 6060 if (wpa_sm_get_p2p_ip_addr(wpa_s->wpa, ip) == 0) { 6061 os_snprintf(ip_addr, sizeof(ip_addr), " ip_addr=%u.%u.%u.%u " 6062 "ip_mask=%u.%u.%u.%u go_ip_addr=%u.%u.%u.%u", 6063 ip[0], ip[1], ip[2], ip[3], 6064 ip[4], ip[5], ip[6], ip[7], 6065 ip[8], ip[9], ip[10], ip[11]); 6066 } 6067 6068 wpas_p2p_group_started(wpa_s, 0, ssid, freq, 6069 ssid->passphrase == NULL && ssid->psk_set ? 6070 ssid->psk : NULL, 6071 ssid->passphrase, go_dev_addr, persistent, 6072 ip_addr); 6073 6074 if (persistent) 6075 network_id = wpas_p2p_store_persistent_group(wpa_s->parent, 6076 ssid, go_dev_addr); 6077 if (network_id < 0) 6078 network_id = ssid->id; 6079 wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 1); 6080} 6081 6082 6083int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1, 6084 u32 interval1, u32 duration2, u32 interval2) 6085{ 6086 int ret; 6087 6088 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6089 return -1; 6090 6091 if (wpa_s->wpa_state < WPA_ASSOCIATED || 6092 wpa_s->current_ssid == NULL || 6093 wpa_s->current_ssid->mode != WPAS_MODE_INFRA) 6094 return -1; 6095 6096 ret = p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid, 6097 wpa_s->own_addr, wpa_s->assoc_freq, 6098 duration1, interval1, duration2, interval2); 6099 if (ret == 0) 6100 wpa_s->waiting_presence_resp = 1; 6101 6102 return ret; 6103} 6104 6105 6106int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period, 6107 unsigned int interval) 6108{ 6109 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6110 return -1; 6111 6112 return p2p_ext_listen(wpa_s->global->p2p, period, interval); 6113} 6114 6115 6116static int wpas_p2p_is_client(struct wpa_supplicant *wpa_s) 6117{ 6118 if (wpa_s->current_ssid == NULL) { 6119 /* 6120 * current_ssid can be cleared when P2P client interface gets 6121 * disconnected, so assume this interface was used as P2P 6122 * client. 6123 */ 6124 return 1; 6125 } 6126 return wpa_s->current_ssid->p2p_group && 6127 wpa_s->current_ssid->mode == WPAS_MODE_INFRA; 6128} 6129 6130 6131static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx) 6132{ 6133 struct wpa_supplicant *wpa_s = eloop_ctx; 6134 6135 if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) { 6136 wpa_printf(MSG_DEBUG, "P2P: Ignore group idle timeout - " 6137 "disabled"); 6138 return; 6139 } 6140 6141 wpa_printf(MSG_DEBUG, "P2P: Group idle timeout reached - terminate " 6142 "group"); 6143 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_IDLE_TIMEOUT); 6144} 6145 6146 6147static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s) 6148{ 6149 int timeout; 6150 6151 if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0) 6152 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout"); 6153 6154 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group) 6155 return; 6156 6157 timeout = wpa_s->conf->p2p_group_idle; 6158 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA && 6159 (timeout == 0 || timeout > P2P_MAX_CLIENT_IDLE)) 6160 timeout = P2P_MAX_CLIENT_IDLE; 6161 6162 if (timeout == 0) 6163 return; 6164 6165 if (timeout < 0) { 6166 if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA) 6167 timeout = 0; /* special client mode no-timeout */ 6168 else 6169 return; 6170 } 6171 6172 if (wpa_s->p2p_in_provisioning) { 6173 /* 6174 * Use the normal group formation timeout during the 6175 * provisioning phase to avoid terminating this process too 6176 * early due to group idle timeout. 6177 */ 6178 wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout " 6179 "during provisioning"); 6180 return; 6181 } 6182 6183 if (wpa_s->show_group_started) { 6184 /* 6185 * Use the normal group formation timeout between the end of 6186 * the provisioning phase and completion of 4-way handshake to 6187 * avoid terminating this process too early due to group idle 6188 * timeout. 6189 */ 6190 wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout " 6191 "while waiting for initial 4-way handshake to " 6192 "complete"); 6193 return; 6194 } 6195 6196 wpa_printf(MSG_DEBUG, "P2P: Set P2P group idle timeout to %u seconds", 6197 timeout); 6198 eloop_register_timeout(timeout, 0, wpas_p2p_group_idle_timeout, 6199 wpa_s, NULL); 6200} 6201 6202 6203/* Returns 1 if the interface was removed */ 6204int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid, 6205 u16 reason_code, const u8 *ie, size_t ie_len, 6206 int locally_generated) 6207{ 6208 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6209 return 0; 6210 6211 if (!locally_generated) 6212 p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie, 6213 ie_len); 6214 6215 if (reason_code == WLAN_REASON_DEAUTH_LEAVING && !locally_generated && 6216 wpa_s->current_ssid && 6217 wpa_s->current_ssid->p2p_group && 6218 wpa_s->current_ssid->mode == WPAS_MODE_INFRA) { 6219 wpa_printf(MSG_DEBUG, "P2P: GO indicated that the P2P Group " 6220 "session is ending"); 6221 if (wpas_p2p_group_delete(wpa_s, 6222 P2P_GROUP_REMOVAL_GO_ENDING_SESSION) 6223 > 0) 6224 return 1; 6225 } 6226 6227 return 0; 6228} 6229 6230 6231void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid, 6232 u16 reason_code, const u8 *ie, size_t ie_len, 6233 int locally_generated) 6234{ 6235 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6236 return; 6237 6238 if (!locally_generated) 6239 p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie, 6240 ie_len); 6241} 6242 6243 6244void wpas_p2p_update_config(struct wpa_supplicant *wpa_s) 6245{ 6246 struct p2p_data *p2p = wpa_s->global->p2p; 6247 6248 if (p2p == NULL) 6249 return; 6250 6251 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE)) 6252 return; 6253 6254 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME) 6255 p2p_set_dev_name(p2p, wpa_s->conf->device_name); 6256 6257 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE) 6258 p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type); 6259 6260 if (wpa_s->wps && 6261 (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS)) 6262 p2p_set_config_methods(p2p, wpa_s->wps->config_methods); 6263 6264 if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID)) 6265 p2p_set_uuid(p2p, wpa_s->wps->uuid); 6266 6267 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) { 6268 p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer); 6269 p2p_set_model_name(p2p, wpa_s->conf->model_name); 6270 p2p_set_model_number(p2p, wpa_s->conf->model_number); 6271 p2p_set_serial_number(p2p, wpa_s->conf->serial_number); 6272 } 6273 6274 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE) 6275 p2p_set_sec_dev_types(p2p, 6276 (void *) wpa_s->conf->sec_device_type, 6277 wpa_s->conf->num_sec_device_types); 6278 6279 if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) { 6280 int i; 6281 p2p_remove_wps_vendor_extensions(p2p); 6282 for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) { 6283 if (wpa_s->conf->wps_vendor_ext[i] == NULL) 6284 continue; 6285 p2p_add_wps_vendor_extension( 6286 p2p, wpa_s->conf->wps_vendor_ext[i]); 6287 } 6288 } 6289 6290 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) && 6291 wpa_s->conf->country[0] && wpa_s->conf->country[1]) { 6292 char country[3]; 6293 country[0] = wpa_s->conf->country[0]; 6294 country[1] = wpa_s->conf->country[1]; 6295 country[2] = 0x04; 6296 p2p_set_country(p2p, country); 6297 } 6298 6299 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) { 6300 p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix, 6301 wpa_s->conf->p2p_ssid_postfix ? 6302 os_strlen(wpa_s->conf->p2p_ssid_postfix) : 6303 0); 6304 } 6305 6306 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS) 6307 p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss); 6308 6309 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) { 6310 u8 reg_class, channel; 6311 int ret; 6312 unsigned int r; 6313 u8 channel_forced; 6314 6315 if (wpa_s->conf->p2p_listen_reg_class && 6316 wpa_s->conf->p2p_listen_channel) { 6317 reg_class = wpa_s->conf->p2p_listen_reg_class; 6318 channel = wpa_s->conf->p2p_listen_channel; 6319 channel_forced = 1; 6320 } else { 6321 reg_class = 81; 6322 /* 6323 * Pick one of the social channels randomly as the 6324 * listen channel. 6325 */ 6326 os_get_random((u8 *) &r, sizeof(r)); 6327 channel = 1 + (r % 3) * 5; 6328 channel_forced = 0; 6329 } 6330 ret = p2p_set_listen_channel(p2p, reg_class, channel, 6331 channel_forced); 6332 if (ret) 6333 wpa_printf(MSG_ERROR, "P2P: Own listen channel update " 6334 "failed: %d", ret); 6335 } 6336 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) { 6337 u8 op_reg_class, op_channel, cfg_op_channel; 6338 int ret = 0; 6339 unsigned int r; 6340 if (wpa_s->conf->p2p_oper_reg_class && 6341 wpa_s->conf->p2p_oper_channel) { 6342 op_reg_class = wpa_s->conf->p2p_oper_reg_class; 6343 op_channel = wpa_s->conf->p2p_oper_channel; 6344 cfg_op_channel = 1; 6345 } else { 6346 op_reg_class = 81; 6347 /* 6348 * Use random operation channel from (1, 6, 11) 6349 *if no other preference is indicated. 6350 */ 6351 os_get_random((u8 *) &r, sizeof(r)); 6352 op_channel = 1 + (r % 3) * 5; 6353 cfg_op_channel = 0; 6354 } 6355 ret = p2p_set_oper_channel(p2p, op_reg_class, op_channel, 6356 cfg_op_channel); 6357 if (ret) 6358 wpa_printf(MSG_ERROR, "P2P: Own oper channel update " 6359 "failed: %d", ret); 6360 } 6361 6362 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) { 6363 if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan, 6364 wpa_s->conf->p2p_pref_chan) < 0) { 6365 wpa_printf(MSG_ERROR, "P2P: Preferred channel list " 6366 "update failed"); 6367 } 6368 6369 if (p2p_set_no_go_freq(p2p, &wpa_s->conf->p2p_no_go_freq) < 0) { 6370 wpa_printf(MSG_ERROR, "P2P: No GO channel list " 6371 "update failed"); 6372 } 6373 } 6374 6375 if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PASSPHRASE_LEN) 6376 p2p_set_passphrase_len(p2p, wpa_s->conf->p2p_passphrase_len); 6377} 6378 6379 6380int wpas_p2p_set_noa(struct wpa_supplicant *wpa_s, u8 count, int start, 6381 int duration) 6382{ 6383 if (!wpa_s->ap_iface) 6384 return -1; 6385 return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start, 6386 duration); 6387} 6388 6389 6390int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled) 6391{ 6392 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6393 return -1; 6394 6395 wpa_s->global->cross_connection = enabled; 6396 p2p_set_cross_connect(wpa_s->global->p2p, enabled); 6397 6398 if (!enabled) { 6399 struct wpa_supplicant *iface; 6400 6401 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) 6402 { 6403 if (iface->cross_connect_enabled == 0) 6404 continue; 6405 6406 iface->cross_connect_enabled = 0; 6407 iface->cross_connect_in_use = 0; 6408 wpa_msg_global(iface->parent, MSG_INFO, 6409 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s", 6410 iface->ifname, 6411 iface->cross_connect_uplink); 6412 } 6413 } 6414 6415 return 0; 6416} 6417 6418 6419static void wpas_p2p_enable_cross_connect(struct wpa_supplicant *uplink) 6420{ 6421 struct wpa_supplicant *iface; 6422 6423 if (!uplink->global->cross_connection) 6424 return; 6425 6426 for (iface = uplink->global->ifaces; iface; iface = iface->next) { 6427 if (!iface->cross_connect_enabled) 6428 continue; 6429 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) != 6430 0) 6431 continue; 6432 if (iface->ap_iface == NULL) 6433 continue; 6434 if (iface->cross_connect_in_use) 6435 continue; 6436 6437 iface->cross_connect_in_use = 1; 6438 wpa_msg_global(iface->parent, MSG_INFO, 6439 P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s", 6440 iface->ifname, iface->cross_connect_uplink); 6441 } 6442} 6443 6444 6445static void wpas_p2p_disable_cross_connect(struct wpa_supplicant *uplink) 6446{ 6447 struct wpa_supplicant *iface; 6448 6449 for (iface = uplink->global->ifaces; iface; iface = iface->next) { 6450 if (!iface->cross_connect_enabled) 6451 continue; 6452 if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) != 6453 0) 6454 continue; 6455 if (!iface->cross_connect_in_use) 6456 continue; 6457 6458 wpa_msg_global(iface->parent, MSG_INFO, 6459 P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s", 6460 iface->ifname, iface->cross_connect_uplink); 6461 iface->cross_connect_in_use = 0; 6462 } 6463} 6464 6465 6466void wpas_p2p_notif_connected(struct wpa_supplicant *wpa_s) 6467{ 6468 if (wpa_s->ap_iface || wpa_s->current_ssid == NULL || 6469 wpa_s->current_ssid->mode != WPAS_MODE_INFRA || 6470 wpa_s->cross_connect_disallowed) 6471 wpas_p2p_disable_cross_connect(wpa_s); 6472 else 6473 wpas_p2p_enable_cross_connect(wpa_s); 6474 if (!wpa_s->ap_iface && 6475 eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0) 6476 wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout"); 6477} 6478 6479 6480void wpas_p2p_notif_disconnected(struct wpa_supplicant *wpa_s) 6481{ 6482 wpas_p2p_disable_cross_connect(wpa_s); 6483 if (!wpa_s->ap_iface && 6484 !eloop_is_timeout_registered(wpas_p2p_group_idle_timeout, 6485 wpa_s, NULL)) 6486 wpas_p2p_set_group_idle_timeout(wpa_s); 6487} 6488 6489 6490static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s) 6491{ 6492 struct wpa_supplicant *iface; 6493 6494 if (!wpa_s->global->cross_connection) 6495 return; 6496 6497 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) { 6498 if (iface == wpa_s) 6499 continue; 6500 if (iface->drv_flags & 6501 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE) 6502 continue; 6503 if (iface->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE) 6504 continue; 6505 6506 wpa_s->cross_connect_enabled = 1; 6507 os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname, 6508 sizeof(wpa_s->cross_connect_uplink)); 6509 wpa_printf(MSG_DEBUG, "P2P: Enable cross connection from " 6510 "%s to %s whenever uplink is available", 6511 wpa_s->ifname, wpa_s->cross_connect_uplink); 6512 6513 if (iface->ap_iface || iface->current_ssid == NULL || 6514 iface->current_ssid->mode != WPAS_MODE_INFRA || 6515 iface->cross_connect_disallowed || 6516 iface->wpa_state != WPA_COMPLETED) 6517 break; 6518 6519 wpa_s->cross_connect_in_use = 1; 6520 wpa_msg_global(wpa_s->parent, MSG_INFO, 6521 P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s", 6522 wpa_s->ifname, wpa_s->cross_connect_uplink); 6523 break; 6524 } 6525} 6526 6527 6528int wpas_p2p_notif_pbc_overlap(struct wpa_supplicant *wpa_s) 6529{ 6530 if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT && 6531 !wpa_s->p2p_in_provisioning) 6532 return 0; /* not P2P client operation */ 6533 6534 wpa_printf(MSG_DEBUG, "P2P: Terminate connection due to WPS PBC " 6535 "session overlap"); 6536 if (wpa_s != wpa_s->parent) 6537 wpa_msg_ctrl(wpa_s->parent, MSG_INFO, WPS_EVENT_OVERLAP); 6538 wpas_p2p_group_formation_failed(wpa_s); 6539 return 1; 6540} 6541 6542 6543void wpas_p2p_pbc_overlap_cb(void *eloop_ctx, void *timeout_ctx) 6544{ 6545 struct wpa_supplicant *wpa_s = eloop_ctx; 6546 wpas_p2p_notif_pbc_overlap(wpa_s); 6547} 6548 6549 6550void wpas_p2p_update_channel_list(struct wpa_supplicant *wpa_s) 6551{ 6552 struct p2p_channels chan, cli_chan; 6553 struct wpa_supplicant *ifs; 6554 6555 if (wpa_s->global == NULL || wpa_s->global->p2p == NULL) 6556 return; 6557 6558 os_memset(&chan, 0, sizeof(chan)); 6559 os_memset(&cli_chan, 0, sizeof(cli_chan)); 6560 if (wpas_p2p_setup_channels(wpa_s, &chan, &cli_chan)) { 6561 wpa_printf(MSG_ERROR, "P2P: Failed to update supported " 6562 "channel list"); 6563 return; 6564 } 6565 6566 p2p_update_channel_list(wpa_s->global->p2p, &chan, &cli_chan); 6567 6568 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) { 6569 int freq; 6570 if (!ifs->current_ssid || 6571 !ifs->current_ssid->p2p_group || 6572 (ifs->current_ssid->mode != WPAS_MODE_P2P_GO && 6573 ifs->current_ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)) 6574 continue; 6575 freq = ifs->current_ssid->frequency; 6576 if (freq_included(&chan, freq)) { 6577 wpa_dbg(ifs, MSG_DEBUG, 6578 "P2P GO operating frequency %d MHz in valid range", 6579 freq); 6580 continue; 6581 } 6582 6583 wpa_dbg(ifs, MSG_DEBUG, 6584 "P2P GO operating in invalid frequency %d MHz", freq); 6585 /* TODO: Consider using CSA or removing the group within 6586 * wpa_supplicant */ 6587 wpa_msg(ifs, MSG_INFO, P2P_EVENT_REMOVE_AND_REFORM_GROUP); 6588 } 6589} 6590 6591 6592static void wpas_p2p_scan_res_ignore(struct wpa_supplicant *wpa_s, 6593 struct wpa_scan_results *scan_res) 6594{ 6595 wpa_printf(MSG_DEBUG, "P2P: Ignore scan results"); 6596} 6597 6598 6599int wpas_p2p_cancel(struct wpa_supplicant *wpa_s) 6600{ 6601 struct wpa_global *global = wpa_s->global; 6602 int found = 0; 6603 const u8 *peer; 6604 6605 if (global->p2p == NULL) 6606 return -1; 6607 6608 wpa_printf(MSG_DEBUG, "P2P: Request to cancel group formation"); 6609 6610 if (wpa_s->pending_interface_name[0] && 6611 !is_zero_ether_addr(wpa_s->pending_interface_addr)) 6612 found = 1; 6613 6614 peer = p2p_get_go_neg_peer(global->p2p); 6615 if (peer) { 6616 wpa_printf(MSG_DEBUG, "P2P: Unauthorize pending GO Neg peer " 6617 MACSTR, MAC2STR(peer)); 6618 p2p_unauthorize(global->p2p, peer); 6619 found = 1; 6620 } 6621 6622 if (wpa_s->scan_res_handler == wpas_p2p_scan_res_join) { 6623 wpa_printf(MSG_DEBUG, "P2P: Stop pending scan for join"); 6624 wpa_s->scan_res_handler = wpas_p2p_scan_res_ignore; 6625 found = 1; 6626 } 6627 6628 if (wpa_s->pending_pd_before_join) { 6629 wpa_printf(MSG_DEBUG, "P2P: Stop pending PD before join"); 6630 wpa_s->pending_pd_before_join = 0; 6631 found = 1; 6632 } 6633 6634 wpas_p2p_stop_find(wpa_s); 6635 6636 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 6637 if (wpa_s == global->p2p_group_formation && 6638 (wpa_s->p2p_in_provisioning || 6639 wpa_s->parent->pending_interface_type == 6640 WPA_IF_P2P_CLIENT)) { 6641 wpa_printf(MSG_DEBUG, "P2P: Interface %s in group " 6642 "formation found - cancelling", 6643 wpa_s->ifname); 6644 found = 1; 6645 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 6646 wpa_s->parent, NULL); 6647 if (wpa_s->p2p_in_provisioning) { 6648 wpas_group_formation_completed(wpa_s, 0); 6649 break; 6650 } 6651 wpas_p2p_group_delete(wpa_s, 6652 P2P_GROUP_REMOVAL_REQUESTED); 6653 break; 6654 } else if (wpa_s->p2p_in_invitation) { 6655 wpa_printf(MSG_DEBUG, "P2P: Interface %s in invitation found - cancelling", 6656 wpa_s->ifname); 6657 found = 1; 6658 wpas_p2p_group_formation_failed(wpa_s); 6659 } 6660 } 6661 6662 if (!found) { 6663 wpa_printf(MSG_DEBUG, "P2P: No ongoing group formation found"); 6664 return -1; 6665 } 6666 6667 return 0; 6668} 6669 6670 6671void wpas_p2p_interface_unavailable(struct wpa_supplicant *wpa_s) 6672{ 6673 if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group) 6674 return; 6675 6676 wpa_printf(MSG_DEBUG, "P2P: Remove group due to driver resource not " 6677 "being available anymore"); 6678 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_UNAVAILABLE); 6679} 6680 6681 6682void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s, 6683 int freq_24, int freq_5, int freq_overall) 6684{ 6685 struct p2p_data *p2p = wpa_s->global->p2p; 6686 if (p2p == NULL) 6687 return; 6688 p2p_set_best_channels(p2p, freq_24, freq_5, freq_overall); 6689} 6690 6691 6692int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr) 6693{ 6694 u8 peer[ETH_ALEN]; 6695 struct p2p_data *p2p = wpa_s->global->p2p; 6696 6697 if (p2p == NULL) 6698 return -1; 6699 6700 if (hwaddr_aton(addr, peer)) 6701 return -1; 6702 6703 return p2p_unauthorize(p2p, peer); 6704} 6705 6706 6707/** 6708 * wpas_p2p_disconnect - Disconnect from a P2P Group 6709 * @wpa_s: Pointer to wpa_supplicant data 6710 * Returns: 0 on success, -1 on failure 6711 * 6712 * This can be used to disconnect from a group in which the local end is a P2P 6713 * Client or to end a P2P Group in case the local end is the Group Owner. If a 6714 * virtual network interface was created for this group, that interface will be 6715 * removed. Otherwise, only the configured P2P group network will be removed 6716 * from the interface. 6717 */ 6718int wpas_p2p_disconnect(struct wpa_supplicant *wpa_s) 6719{ 6720 6721 if (wpa_s == NULL) 6722 return -1; 6723 6724 return wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_REQUESTED) < 0 ? 6725 -1 : 0; 6726} 6727 6728 6729int wpas_p2p_in_progress(struct wpa_supplicant *wpa_s) 6730{ 6731 int ret; 6732 6733 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 6734 return 0; 6735 6736 ret = p2p_in_progress(wpa_s->global->p2p); 6737 if (ret == 0) { 6738 /* 6739 * Check whether there is an ongoing WPS provisioning step (or 6740 * other parts of group formation) on another interface since 6741 * p2p_in_progress() does not report this to avoid issues for 6742 * scans during such provisioning step. 6743 */ 6744 if (wpa_s->global->p2p_group_formation && 6745 wpa_s->global->p2p_group_formation != wpa_s) { 6746 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Another interface (%s) " 6747 "in group formation", 6748 wpa_s->global->p2p_group_formation->ifname); 6749 ret = 1; 6750 } 6751 } 6752 6753 if (!ret && wpa_s->global->p2p_go_wait_client.sec) { 6754 struct os_reltime now; 6755 os_get_reltime(&now); 6756 if (os_reltime_expired(&now, &wpa_s->global->p2p_go_wait_client, 6757 P2P_MAX_INITIAL_CONN_WAIT_GO)) { 6758 /* Wait for the first client has expired */ 6759 wpa_s->global->p2p_go_wait_client.sec = 0; 6760 } else { 6761 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Waiting for initial client connection during group formation"); 6762 ret = 1; 6763 } 6764 } 6765 6766 return ret; 6767} 6768 6769 6770void wpas_p2p_network_removed(struct wpa_supplicant *wpa_s, 6771 struct wpa_ssid *ssid) 6772{ 6773 if (wpa_s->p2p_in_provisioning && ssid->p2p_group && 6774 eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 6775 wpa_s->parent, NULL) > 0) { 6776 /** 6777 * Remove the network by scheduling the group formation 6778 * timeout to happen immediately. The teardown code 6779 * needs to be scheduled to run asynch later so that we 6780 * don't delete data from under ourselves unexpectedly. 6781 * Calling wpas_p2p_group_formation_timeout directly 6782 * causes a series of crashes in WPS failure scenarios. 6783 */ 6784 wpa_printf(MSG_DEBUG, "P2P: Canceled group formation due to " 6785 "P2P group network getting removed"); 6786 eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout, 6787 wpa_s->parent, NULL); 6788 } 6789} 6790 6791 6792struct wpa_ssid * wpas_p2p_get_persistent(struct wpa_supplicant *wpa_s, 6793 const u8 *addr, const u8 *ssid, 6794 size_t ssid_len) 6795{ 6796 struct wpa_ssid *s; 6797 size_t i; 6798 6799 for (s = wpa_s->conf->ssid; s; s = s->next) { 6800 if (s->disabled != 2) 6801 continue; 6802 if (ssid && 6803 (ssid_len != s->ssid_len || 6804 os_memcmp(ssid, s->ssid, ssid_len) != 0)) 6805 continue; 6806 if (addr == NULL) { 6807 if (s->mode == WPAS_MODE_P2P_GO) 6808 return s; 6809 continue; 6810 } 6811 if (os_memcmp(s->bssid, addr, ETH_ALEN) == 0) 6812 return s; /* peer is GO in the persistent group */ 6813 if (s->mode != WPAS_MODE_P2P_GO || s->p2p_client_list == NULL) 6814 continue; 6815 for (i = 0; i < s->num_p2p_clients; i++) { 6816 if (os_memcmp(s->p2p_client_list + i * ETH_ALEN, 6817 addr, ETH_ALEN) == 0) 6818 return s; /* peer is P2P client in persistent 6819 * group */ 6820 } 6821 } 6822 6823 return NULL; 6824} 6825 6826 6827void wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s, 6828 const u8 *addr) 6829{ 6830 if (eloop_cancel_timeout(wpas_p2p_group_formation_timeout, 6831 wpa_s->parent, NULL) > 0) { 6832 /* 6833 * This can happen if WPS provisioning step is not terminated 6834 * cleanly (e.g., P2P Client does not send WSC_Done). Since the 6835 * peer was able to connect, there is no need to time out group 6836 * formation after this, though. In addition, this is used with 6837 * the initial connection wait on the GO as a separate formation 6838 * timeout and as such, expected to be hit after the initial WPS 6839 * provisioning step. 6840 */ 6841 wpa_printf(MSG_DEBUG, "P2P: Canceled P2P group formation timeout on data connection"); 6842 } 6843 if (!wpa_s->p2p_go_group_formation_completed) { 6844 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Marking group formation completed on GO on first data connection"); 6845 wpa_s->p2p_go_group_formation_completed = 1; 6846 wpa_s->global->p2p_group_formation = NULL; 6847 wpa_s->p2p_in_provisioning = 0; 6848 wpa_s->p2p_in_invitation = 0; 6849 } 6850 wpa_s->global->p2p_go_wait_client.sec = 0; 6851 if (addr == NULL) 6852 return; 6853 wpas_p2p_add_persistent_group_client(wpa_s, addr); 6854} 6855 6856 6857static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s, 6858 int group_added) 6859{ 6860 struct wpa_supplicant *group = wpa_s; 6861 if (wpa_s->global->p2p_group_formation) 6862 group = wpa_s->global->p2p_group_formation; 6863 wpa_s = wpa_s->parent; 6864 offchannel_send_action_done(wpa_s); 6865 if (group_added) 6866 wpas_p2p_group_delete(group, P2P_GROUP_REMOVAL_SILENT); 6867 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Fall back to GO Negotiation"); 6868 wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin, 6869 wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0, 6870 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq, 6871 wpa_s->p2p_persistent_id, 6872 wpa_s->p2p_pd_before_go_neg, 6873 wpa_s->p2p_go_ht40, 6874 wpa_s->p2p_go_vht); 6875} 6876 6877 6878int wpas_p2p_scan_no_go_seen(struct wpa_supplicant *wpa_s) 6879{ 6880 if (!wpa_s->p2p_fallback_to_go_neg || 6881 wpa_s->p2p_in_provisioning <= 5) 6882 return 0; 6883 6884 if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0) 6885 return 0; /* peer operating as a GO */ 6886 6887 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - " 6888 "fallback to GO Negotiation"); 6889 wpas_p2p_fallback_to_go_neg(wpa_s, 1); 6890 6891 return 1; 6892} 6893 6894 6895unsigned int wpas_p2p_search_delay(struct wpa_supplicant *wpa_s) 6896{ 6897 struct wpa_supplicant *ifs; 6898 6899 if (wpa_s->wpa_state > WPA_SCANNING) { 6900 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search delay due to " 6901 "concurrent operation", 6902 wpa_s->conf->p2p_search_delay); 6903 return wpa_s->conf->p2p_search_delay; 6904 } 6905 6906 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant, 6907 radio_list) { 6908 if (ifs != wpa_s && ifs->wpa_state > WPA_SCANNING) { 6909 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search " 6910 "delay due to concurrent operation on " 6911 "interface %s", 6912 wpa_s->conf->p2p_search_delay, 6913 ifs->ifname); 6914 return wpa_s->conf->p2p_search_delay; 6915 } 6916 } 6917 6918 return 0; 6919} 6920 6921 6922static int wpas_p2p_remove_psk_entry(struct wpa_supplicant *wpa_s, 6923 struct wpa_ssid *s, const u8 *addr, 6924 int iface_addr) 6925{ 6926 struct psk_list_entry *psk, *tmp; 6927 int changed = 0; 6928 6929 dl_list_for_each_safe(psk, tmp, &s->psk_list, struct psk_list_entry, 6930 list) { 6931 if ((iface_addr && !psk->p2p && 6932 os_memcmp(addr, psk->addr, ETH_ALEN) == 0) || 6933 (!iface_addr && psk->p2p && 6934 os_memcmp(addr, psk->addr, ETH_ALEN) == 0)) { 6935 wpa_dbg(wpa_s, MSG_DEBUG, 6936 "P2P: Remove persistent group PSK list entry for " 6937 MACSTR " p2p=%u", 6938 MAC2STR(psk->addr), psk->p2p); 6939 dl_list_del(&psk->list); 6940 os_free(psk); 6941 changed++; 6942 } 6943 } 6944 6945 return changed; 6946} 6947 6948 6949void wpas_p2p_new_psk_cb(struct wpa_supplicant *wpa_s, const u8 *mac_addr, 6950 const u8 *p2p_dev_addr, 6951 const u8 *psk, size_t psk_len) 6952{ 6953 struct wpa_ssid *ssid = wpa_s->current_ssid; 6954 struct wpa_ssid *persistent; 6955 struct psk_list_entry *p, *last; 6956 6957 if (psk_len != sizeof(p->psk)) 6958 return; 6959 6960 if (p2p_dev_addr) { 6961 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR 6962 " p2p_dev_addr=" MACSTR, 6963 MAC2STR(mac_addr), MAC2STR(p2p_dev_addr)); 6964 if (is_zero_ether_addr(p2p_dev_addr)) 6965 p2p_dev_addr = NULL; 6966 } else { 6967 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: New PSK for addr=" MACSTR, 6968 MAC2STR(mac_addr)); 6969 } 6970 6971 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) { 6972 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: new_psk_cb during group formation"); 6973 /* To be added to persistent group once created */ 6974 if (wpa_s->global->add_psk == NULL) { 6975 wpa_s->global->add_psk = os_zalloc(sizeof(*p)); 6976 if (wpa_s->global->add_psk == NULL) 6977 return; 6978 } 6979 p = wpa_s->global->add_psk; 6980 if (p2p_dev_addr) { 6981 p->p2p = 1; 6982 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN); 6983 } else { 6984 p->p2p = 0; 6985 os_memcpy(p->addr, mac_addr, ETH_ALEN); 6986 } 6987 os_memcpy(p->psk, psk, psk_len); 6988 return; 6989 } 6990 6991 if (ssid->mode != WPAS_MODE_P2P_GO || !ssid->p2p_persistent_group) { 6992 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Ignore new_psk_cb on not-persistent GO"); 6993 return; 6994 } 6995 6996 persistent = wpas_p2p_get_persistent(wpa_s->parent, NULL, ssid->ssid, 6997 ssid->ssid_len); 6998 if (!persistent) { 6999 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not find persistent group information to store the new PSK"); 7000 return; 7001 } 7002 7003 p = os_zalloc(sizeof(*p)); 7004 if (p == NULL) 7005 return; 7006 if (p2p_dev_addr) { 7007 p->p2p = 1; 7008 os_memcpy(p->addr, p2p_dev_addr, ETH_ALEN); 7009 } else { 7010 p->p2p = 0; 7011 os_memcpy(p->addr, mac_addr, ETH_ALEN); 7012 } 7013 os_memcpy(p->psk, psk, psk_len); 7014 7015 if (dl_list_len(&persistent->psk_list) > P2P_MAX_STORED_CLIENTS && 7016 (last = dl_list_last(&persistent->psk_list, 7017 struct psk_list_entry, list))) { 7018 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove oldest PSK entry for " 7019 MACSTR " (p2p=%u) to make room for a new one", 7020 MAC2STR(last->addr), last->p2p); 7021 dl_list_del(&last->list); 7022 os_free(last); 7023 } 7024 7025 wpas_p2p_remove_psk_entry(wpa_s->parent, persistent, 7026 p2p_dev_addr ? p2p_dev_addr : mac_addr, 7027 p2p_dev_addr == NULL); 7028 if (p2p_dev_addr) { 7029 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for p2p_dev_addr=" 7030 MACSTR, MAC2STR(p2p_dev_addr)); 7031 } else { 7032 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Add new PSK for addr=" MACSTR, 7033 MAC2STR(mac_addr)); 7034 } 7035 dl_list_add(&persistent->psk_list, &p->list); 7036 7037 if (wpa_s->parent->conf->update_config && 7038 wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf)) 7039 wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration"); 7040} 7041 7042 7043static void wpas_p2p_remove_psk(struct wpa_supplicant *wpa_s, 7044 struct wpa_ssid *s, const u8 *addr, 7045 int iface_addr) 7046{ 7047 int res; 7048 7049 res = wpas_p2p_remove_psk_entry(wpa_s, s, addr, iface_addr); 7050 if (res > 0 && wpa_s->conf->update_config && 7051 wpa_config_write(wpa_s->confname, wpa_s->conf)) 7052 wpa_dbg(wpa_s, MSG_DEBUG, 7053 "P2P: Failed to update configuration"); 7054} 7055 7056 7057static void wpas_p2p_remove_client_go(struct wpa_supplicant *wpa_s, 7058 const u8 *peer, int iface_addr) 7059{ 7060 struct hostapd_data *hapd; 7061 struct hostapd_wpa_psk *psk, *prev, *rem; 7062 struct sta_info *sta; 7063 7064 if (wpa_s->ap_iface == NULL || wpa_s->current_ssid == NULL || 7065 wpa_s->current_ssid->mode != WPAS_MODE_P2P_GO) 7066 return; 7067 7068 /* Remove per-station PSK entry */ 7069 hapd = wpa_s->ap_iface->bss[0]; 7070 prev = NULL; 7071 psk = hapd->conf->ssid.wpa_psk; 7072 while (psk) { 7073 if ((iface_addr && os_memcmp(peer, psk->addr, ETH_ALEN) == 0) || 7074 (!iface_addr && 7075 os_memcmp(peer, psk->p2p_dev_addr, ETH_ALEN) == 0)) { 7076 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove operating group PSK entry for " 7077 MACSTR " iface_addr=%d", 7078 MAC2STR(peer), iface_addr); 7079 if (prev) 7080 prev->next = psk->next; 7081 else 7082 hapd->conf->ssid.wpa_psk = psk->next; 7083 rem = psk; 7084 psk = psk->next; 7085 os_free(rem); 7086 } else { 7087 prev = psk; 7088 psk = psk->next; 7089 } 7090 } 7091 7092 /* Disconnect from group */ 7093 if (iface_addr) 7094 sta = ap_get_sta(hapd, peer); 7095 else 7096 sta = ap_get_sta_p2p(hapd, peer); 7097 if (sta) { 7098 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disconnect peer " MACSTR 7099 " (iface_addr=%d) from group", 7100 MAC2STR(peer), iface_addr); 7101 hostapd_drv_sta_deauth(hapd, sta->addr, 7102 WLAN_REASON_DEAUTH_LEAVING); 7103 ap_sta_deauthenticate(hapd, sta, WLAN_REASON_DEAUTH_LEAVING); 7104 } 7105} 7106 7107 7108void wpas_p2p_remove_client(struct wpa_supplicant *wpa_s, const u8 *peer, 7109 int iface_addr) 7110{ 7111 struct wpa_ssid *s; 7112 struct wpa_supplicant *w; 7113 7114 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Remove client " MACSTR, MAC2STR(peer)); 7115 7116 /* Remove from any persistent group */ 7117 for (s = wpa_s->parent->conf->ssid; s; s = s->next) { 7118 if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO) 7119 continue; 7120 if (!iface_addr) 7121 wpas_remove_persistent_peer(wpa_s, s, peer, 0); 7122 wpas_p2p_remove_psk(wpa_s->parent, s, peer, iface_addr); 7123 } 7124 7125 /* Remove from any operating group */ 7126 for (w = wpa_s->global->ifaces; w; w = w->next) 7127 wpas_p2p_remove_client_go(w, peer, iface_addr); 7128} 7129 7130 7131static void wpas_p2p_psk_failure_removal(void *eloop_ctx, void *timeout_ctx) 7132{ 7133 struct wpa_supplicant *wpa_s = eloop_ctx; 7134 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_PSK_FAILURE); 7135} 7136 7137 7138static void wpas_p2p_group_freq_conflict(void *eloop_ctx, void *timeout_ctx) 7139{ 7140 struct wpa_supplicant *wpa_s = eloop_ctx; 7141 7142 wpa_printf(MSG_DEBUG, "P2P: Frequency conflict - terminate group"); 7143 wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_FREQ_CONFLICT); 7144} 7145 7146 7147int wpas_p2p_handle_frequency_conflicts(struct wpa_supplicant *wpa_s, int freq, 7148 struct wpa_ssid *ssid) 7149{ 7150 struct wpa_supplicant *iface; 7151 7152 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) { 7153 if (!iface->current_ssid || 7154 iface->current_ssid->frequency == freq || 7155 (iface->p2p_group_interface == NOT_P2P_GROUP_INTERFACE && 7156 !iface->current_ssid->p2p_group)) 7157 continue; 7158 7159 /* Remove the connection with least priority */ 7160 if (!wpas_is_p2p_prioritized(iface)) { 7161 /* STA connection has priority over existing 7162 * P2P connection, so remove the interface. */ 7163 wpa_printf(MSG_DEBUG, "P2P: Removing P2P connection due to single channel concurrent mode frequency conflict"); 7164 eloop_register_timeout(0, 0, 7165 wpas_p2p_group_freq_conflict, 7166 iface, NULL); 7167 /* If connection in progress is P2P connection, do not 7168 * proceed for the connection. */ 7169 if (wpa_s == iface) 7170 return -1; 7171 else 7172 return 0; 7173 } else { 7174 /* P2P connection has priority, disable the STA network 7175 */ 7176 wpa_supplicant_disable_network(wpa_s->global->ifaces, 7177 ssid); 7178 wpa_msg(wpa_s->global->ifaces, MSG_INFO, 7179 WPA_EVENT_FREQ_CONFLICT " id=%d", ssid->id); 7180 os_memset(wpa_s->global->ifaces->pending_bssid, 0, 7181 ETH_ALEN); 7182 /* If P2P connection is in progress, continue 7183 * connecting...*/ 7184 if (wpa_s == iface) 7185 return 0; 7186 else 7187 return -1; 7188 } 7189 } 7190 7191 return 0; 7192} 7193 7194 7195int wpas_p2p_4way_hs_failed(struct wpa_supplicant *wpa_s) 7196{ 7197 struct wpa_ssid *ssid = wpa_s->current_ssid; 7198 7199 if (ssid == NULL || !ssid->p2p_group) 7200 return 0; 7201 7202 if (wpa_s->p2p_last_4way_hs_fail && 7203 wpa_s->p2p_last_4way_hs_fail == ssid) { 7204 u8 go_dev_addr[ETH_ALEN]; 7205 struct wpa_ssid *persistent; 7206 7207 if (wpas_p2p_persistent_group(wpa_s, go_dev_addr, 7208 ssid->ssid, 7209 ssid->ssid_len) <= 0) { 7210 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not determine whether 4-way handshake failures were for a persistent group"); 7211 goto disconnect; 7212 } 7213 7214 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Two 4-way handshake failures for a P2P group - go_dev_addr=" 7215 MACSTR, MAC2STR(go_dev_addr)); 7216 persistent = wpas_p2p_get_persistent(wpa_s->parent, go_dev_addr, 7217 ssid->ssid, 7218 ssid->ssid_len); 7219 if (persistent == NULL || persistent->mode != WPAS_MODE_INFRA) { 7220 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No matching persistent group stored"); 7221 goto disconnect; 7222 } 7223 wpa_msg_global(wpa_s->parent, MSG_INFO, 7224 P2P_EVENT_PERSISTENT_PSK_FAIL "%d", 7225 persistent->id); 7226 disconnect: 7227 wpa_s->p2p_last_4way_hs_fail = NULL; 7228 /* 7229 * Remove the group from a timeout to avoid issues with caller 7230 * continuing to use the interface if this is on a P2P group 7231 * interface. 7232 */ 7233 eloop_register_timeout(0, 0, wpas_p2p_psk_failure_removal, 7234 wpa_s, NULL); 7235 return 1; 7236 } 7237 7238 wpa_s->p2p_last_4way_hs_fail = ssid; 7239 return 0; 7240} 7241 7242 7243#ifdef CONFIG_WPS_NFC 7244 7245static struct wpabuf * wpas_p2p_nfc_handover(int ndef, struct wpabuf *wsc, 7246 struct wpabuf *p2p) 7247{ 7248 struct wpabuf *ret; 7249 size_t wsc_len; 7250 7251 if (p2p == NULL) { 7252 wpabuf_free(wsc); 7253 wpa_printf(MSG_DEBUG, "P2P: No p2p buffer for handover"); 7254 return NULL; 7255 } 7256 7257 wsc_len = wsc ? wpabuf_len(wsc) : 0; 7258 ret = wpabuf_alloc(2 + wsc_len + 2 + wpabuf_len(p2p)); 7259 if (ret == NULL) { 7260 wpabuf_free(wsc); 7261 wpabuf_free(p2p); 7262 return NULL; 7263 } 7264 7265 wpabuf_put_be16(ret, wsc_len); 7266 if (wsc) 7267 wpabuf_put_buf(ret, wsc); 7268 wpabuf_put_be16(ret, wpabuf_len(p2p)); 7269 wpabuf_put_buf(ret, p2p); 7270 7271 wpabuf_free(wsc); 7272 wpabuf_free(p2p); 7273 wpa_hexdump_buf(MSG_DEBUG, 7274 "P2P: Generated NFC connection handover message", ret); 7275 7276 if (ndef && ret) { 7277 struct wpabuf *tmp; 7278 tmp = ndef_build_p2p(ret); 7279 wpabuf_free(ret); 7280 if (tmp == NULL) { 7281 wpa_printf(MSG_DEBUG, "P2P: Failed to NDEF encapsulate handover request"); 7282 return NULL; 7283 } 7284 ret = tmp; 7285 } 7286 7287 return ret; 7288} 7289 7290 7291static int wpas_p2p_cli_freq(struct wpa_supplicant *wpa_s, 7292 struct wpa_ssid **ssid, u8 *go_dev_addr) 7293{ 7294 struct wpa_supplicant *iface; 7295 7296 if (go_dev_addr) 7297 os_memset(go_dev_addr, 0, ETH_ALEN); 7298 if (ssid) 7299 *ssid = NULL; 7300 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) { 7301 if (iface->wpa_state < WPA_ASSOCIATING || 7302 iface->current_ssid == NULL || iface->assoc_freq == 0 || 7303 !iface->current_ssid->p2p_group || 7304 iface->current_ssid->mode != WPAS_MODE_INFRA) 7305 continue; 7306 if (ssid) 7307 *ssid = iface->current_ssid; 7308 if (go_dev_addr) 7309 os_memcpy(go_dev_addr, iface->go_dev_addr, ETH_ALEN); 7310 return iface->assoc_freq; 7311 } 7312 return 0; 7313} 7314 7315 7316struct wpabuf * wpas_p2p_nfc_handover_req(struct wpa_supplicant *wpa_s, 7317 int ndef) 7318{ 7319 struct wpabuf *wsc, *p2p; 7320 struct wpa_ssid *ssid; 7321 u8 go_dev_addr[ETH_ALEN]; 7322 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr); 7323 7324 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) { 7325 wpa_printf(MSG_DEBUG, "P2P: P2P disabled - cannot build handover request"); 7326 return NULL; 7327 } 7328 7329 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL && 7330 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey, 7331 &wpa_s->conf->wps_nfc_dh_privkey) < 0) { 7332 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No DH key available for handover request"); 7333 return NULL; 7334 } 7335 7336 if (cli_freq == 0) { 7337 wsc = wps_build_nfc_handover_req_p2p( 7338 wpa_s->parent->wps, wpa_s->conf->wps_nfc_dh_pubkey); 7339 } else 7340 wsc = NULL; 7341 p2p = p2p_build_nfc_handover_req(wpa_s->global->p2p, cli_freq, 7342 go_dev_addr, ssid ? ssid->ssid : NULL, 7343 ssid ? ssid->ssid_len : 0); 7344 7345 return wpas_p2p_nfc_handover(ndef, wsc, p2p); 7346} 7347 7348 7349struct wpabuf * wpas_p2p_nfc_handover_sel(struct wpa_supplicant *wpa_s, 7350 int ndef, int tag) 7351{ 7352 struct wpabuf *wsc, *p2p; 7353 struct wpa_ssid *ssid; 7354 u8 go_dev_addr[ETH_ALEN]; 7355 int cli_freq = wpas_p2p_cli_freq(wpa_s, &ssid, go_dev_addr); 7356 7357 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 7358 return NULL; 7359 7360 if (!tag && wpa_s->conf->wps_nfc_dh_pubkey == NULL && 7361 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey, 7362 &wpa_s->conf->wps_nfc_dh_privkey) < 0) 7363 return NULL; 7364 7365 if (cli_freq == 0) { 7366 wsc = wps_build_nfc_handover_sel_p2p( 7367 wpa_s->parent->wps, 7368 tag ? wpa_s->conf->wps_nfc_dev_pw_id : 7369 DEV_PW_NFC_CONNECTION_HANDOVER, 7370 wpa_s->conf->wps_nfc_dh_pubkey, 7371 tag ? wpa_s->conf->wps_nfc_dev_pw : NULL); 7372 } else 7373 wsc = NULL; 7374 p2p = p2p_build_nfc_handover_sel(wpa_s->global->p2p, cli_freq, 7375 go_dev_addr, ssid ? ssid->ssid : NULL, 7376 ssid ? ssid->ssid_len : 0); 7377 7378 return wpas_p2p_nfc_handover(ndef, wsc, p2p); 7379} 7380 7381 7382static int wpas_p2p_nfc_join_group(struct wpa_supplicant *wpa_s, 7383 struct p2p_nfc_params *params) 7384{ 7385 wpa_printf(MSG_DEBUG, "P2P: Initiate join-group based on NFC " 7386 "connection handover (freq=%d)", 7387 params->go_freq); 7388 7389 if (params->go_freq && params->go_ssid_len) { 7390 wpa_s->p2p_wps_method = WPS_NFC; 7391 wpa_s->pending_join_wps_method = WPS_NFC; 7392 os_memset(wpa_s->pending_join_iface_addr, 0, ETH_ALEN); 7393 os_memcpy(wpa_s->pending_join_dev_addr, params->go_dev_addr, 7394 ETH_ALEN); 7395 return wpas_p2p_join_start(wpa_s, params->go_freq, 7396 params->go_ssid, 7397 params->go_ssid_len); 7398 } 7399 7400 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL, 7401 WPS_NFC, 0, 0, 1, 0, wpa_s->conf->p2p_go_intent, 7402 params->go_freq, -1, 0, 1, 1); 7403} 7404 7405 7406static int wpas_p2p_nfc_auth_join(struct wpa_supplicant *wpa_s, 7407 struct p2p_nfc_params *params, int tag) 7408{ 7409 int res, persistent; 7410 struct wpa_ssid *ssid; 7411 7412 wpa_printf(MSG_DEBUG, "P2P: Authorize join-group based on NFC " 7413 "connection handover"); 7414 for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) { 7415 ssid = wpa_s->current_ssid; 7416 if (ssid == NULL) 7417 continue; 7418 if (ssid->mode != WPAS_MODE_P2P_GO) 7419 continue; 7420 if (wpa_s->ap_iface == NULL) 7421 continue; 7422 break; 7423 } 7424 if (wpa_s == NULL) { 7425 wpa_printf(MSG_DEBUG, "P2P: Could not find GO interface"); 7426 return -1; 7427 } 7428 7429 if (wpa_s->parent->p2p_oob_dev_pw_id != 7430 DEV_PW_NFC_CONNECTION_HANDOVER && 7431 !wpa_s->parent->p2p_oob_dev_pw) { 7432 wpa_printf(MSG_DEBUG, "P2P: No NFC Dev Pw known"); 7433 return -1; 7434 } 7435 res = wpas_ap_wps_add_nfc_pw( 7436 wpa_s, wpa_s->parent->p2p_oob_dev_pw_id, 7437 wpa_s->parent->p2p_oob_dev_pw, 7438 wpa_s->parent->p2p_peer_oob_pk_hash_known ? 7439 wpa_s->parent->p2p_peer_oob_pubkey_hash : NULL); 7440 if (res) 7441 return res; 7442 7443 if (!tag) { 7444 wpa_printf(MSG_DEBUG, "P2P: Negotiated handover - wait for peer to join without invitation"); 7445 return 0; 7446 } 7447 7448 if (!params->peer || 7449 !(params->peer->dev_capab & P2P_DEV_CAPAB_INVITATION_PROCEDURE)) 7450 return 0; 7451 7452 wpa_printf(MSG_DEBUG, "P2P: Static handover - invite peer " MACSTR 7453 " to join", MAC2STR(params->peer->p2p_device_addr)); 7454 7455 wpa_s->global->p2p_invite_group = wpa_s; 7456 persistent = ssid->p2p_persistent_group && 7457 wpas_p2p_get_persistent(wpa_s->parent, 7458 params->peer->p2p_device_addr, 7459 ssid->ssid, ssid->ssid_len); 7460 wpa_s->parent->pending_invite_ssid_id = -1; 7461 7462 return p2p_invite(wpa_s->global->p2p, params->peer->p2p_device_addr, 7463 P2P_INVITE_ROLE_ACTIVE_GO, wpa_s->own_addr, 7464 ssid->ssid, ssid->ssid_len, ssid->frequency, 7465 wpa_s->global->p2p_dev_addr, persistent, 0, 7466 wpa_s->parent->p2p_oob_dev_pw_id); 7467} 7468 7469 7470static int wpas_p2p_nfc_init_go_neg(struct wpa_supplicant *wpa_s, 7471 struct p2p_nfc_params *params, 7472 int forced_freq) 7473{ 7474 wpa_printf(MSG_DEBUG, "P2P: Initiate GO Negotiation based on NFC " 7475 "connection handover"); 7476 return wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL, 7477 WPS_NFC, 0, 0, 0, 0, wpa_s->conf->p2p_go_intent, 7478 forced_freq, -1, 0, 1, 1); 7479} 7480 7481 7482static int wpas_p2p_nfc_resp_go_neg(struct wpa_supplicant *wpa_s, 7483 struct p2p_nfc_params *params, 7484 int forced_freq) 7485{ 7486 int res; 7487 7488 wpa_printf(MSG_DEBUG, "P2P: Authorize GO Negotiation based on NFC " 7489 "connection handover"); 7490 res = wpas_p2p_connect(wpa_s, params->peer->p2p_device_addr, NULL, 7491 WPS_NFC, 0, 0, 0, 1, wpa_s->conf->p2p_go_intent, 7492 forced_freq, -1, 0, 1, 1); 7493 if (res) 7494 return res; 7495 7496 res = wpas_p2p_listen(wpa_s, 60); 7497 if (res) { 7498 p2p_unauthorize(wpa_s->global->p2p, 7499 params->peer->p2p_device_addr); 7500 } 7501 7502 return res; 7503} 7504 7505 7506static int wpas_p2p_nfc_connection_handover(struct wpa_supplicant *wpa_s, 7507 const struct wpabuf *data, 7508 int sel, int tag, int forced_freq) 7509{ 7510 const u8 *pos, *end; 7511 u16 len, id; 7512 struct p2p_nfc_params params; 7513 int res; 7514 7515 os_memset(¶ms, 0, sizeof(params)); 7516 params.sel = sel; 7517 7518 wpa_hexdump_buf(MSG_DEBUG, "P2P: Received NFC tag payload", data); 7519 7520 pos = wpabuf_head(data); 7521 end = pos + wpabuf_len(data); 7522 7523 if (end - pos < 2) { 7524 wpa_printf(MSG_DEBUG, "P2P: Not enough data for Length of WSC " 7525 "attributes"); 7526 return -1; 7527 } 7528 len = WPA_GET_BE16(pos); 7529 pos += 2; 7530 if (pos + len > end) { 7531 wpa_printf(MSG_DEBUG, "P2P: Not enough data for WSC " 7532 "attributes"); 7533 return -1; 7534 } 7535 params.wsc_attr = pos; 7536 params.wsc_len = len; 7537 pos += len; 7538 7539 if (end - pos < 2) { 7540 wpa_printf(MSG_DEBUG, "P2P: Not enough data for Length of P2P " 7541 "attributes"); 7542 return -1; 7543 } 7544 len = WPA_GET_BE16(pos); 7545 pos += 2; 7546 if (pos + len > end) { 7547 wpa_printf(MSG_DEBUG, "P2P: Not enough data for P2P " 7548 "attributes"); 7549 return -1; 7550 } 7551 params.p2p_attr = pos; 7552 params.p2p_len = len; 7553 pos += len; 7554 7555 wpa_hexdump(MSG_DEBUG, "P2P: WSC attributes", 7556 params.wsc_attr, params.wsc_len); 7557 wpa_hexdump(MSG_DEBUG, "P2P: P2P attributes", 7558 params.p2p_attr, params.p2p_len); 7559 if (pos < end) { 7560 wpa_hexdump(MSG_DEBUG, 7561 "P2P: Ignored extra data after P2P attributes", 7562 pos, end - pos); 7563 } 7564 7565 res = p2p_process_nfc_connection_handover(wpa_s->global->p2p, ¶ms); 7566 if (res) 7567 return res; 7568 7569 if (params.next_step == NO_ACTION) 7570 return 0; 7571 7572 if (params.next_step == BOTH_GO) { 7573 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_BOTH_GO "peer=" MACSTR, 7574 MAC2STR(params.peer->p2p_device_addr)); 7575 return 0; 7576 } 7577 7578 if (params.next_step == PEER_CLIENT) { 7579 if (!is_zero_ether_addr(params.go_dev_addr)) { 7580 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT 7581 "peer=" MACSTR " freq=%d go_dev_addr=" MACSTR 7582 " ssid=\"%s\"", 7583 MAC2STR(params.peer->p2p_device_addr), 7584 params.go_freq, 7585 MAC2STR(params.go_dev_addr), 7586 wpa_ssid_txt(params.go_ssid, 7587 params.go_ssid_len)); 7588 } else { 7589 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_PEER_CLIENT 7590 "peer=" MACSTR " freq=%d", 7591 MAC2STR(params.peer->p2p_device_addr), 7592 params.go_freq); 7593 } 7594 return 0; 7595 } 7596 7597 if (wpas_p2p_cli_freq(wpa_s, NULL, NULL)) { 7598 wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_NFC_WHILE_CLIENT "peer=" 7599 MACSTR, MAC2STR(params.peer->p2p_device_addr)); 7600 return 0; 7601 } 7602 7603 wpabuf_free(wpa_s->p2p_oob_dev_pw); 7604 wpa_s->p2p_oob_dev_pw = NULL; 7605 7606 if (params.oob_dev_pw_len < WPS_OOB_PUBKEY_HASH_LEN + 2) { 7607 wpa_printf(MSG_DEBUG, "P2P: No peer OOB Dev Pw " 7608 "received"); 7609 return -1; 7610 } 7611 7612 id = WPA_GET_BE16(params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN); 7613 wpa_printf(MSG_DEBUG, "P2P: Peer OOB Dev Pw %u", id); 7614 wpa_hexdump(MSG_DEBUG, "P2P: Peer OOB Public Key hash", 7615 params.oob_dev_pw, WPS_OOB_PUBKEY_HASH_LEN); 7616 os_memcpy(wpa_s->p2p_peer_oob_pubkey_hash, 7617 params.oob_dev_pw, WPS_OOB_PUBKEY_HASH_LEN); 7618 wpa_s->p2p_peer_oob_pk_hash_known = 1; 7619 7620 if (tag) { 7621 if (id < 0x10) { 7622 wpa_printf(MSG_DEBUG, "P2P: Static handover - invalid " 7623 "peer OOB Device Password Id %u", id); 7624 return -1; 7625 } 7626 wpa_printf(MSG_DEBUG, "P2P: Static handover - use peer OOB " 7627 "Device Password Id %u", id); 7628 wpa_hexdump_key(MSG_DEBUG, "P2P: Peer OOB Device Password", 7629 params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN + 2, 7630 params.oob_dev_pw_len - 7631 WPS_OOB_PUBKEY_HASH_LEN - 2); 7632 wpa_s->p2p_oob_dev_pw_id = id; 7633 wpa_s->p2p_oob_dev_pw = wpabuf_alloc_copy( 7634 params.oob_dev_pw + WPS_OOB_PUBKEY_HASH_LEN + 2, 7635 params.oob_dev_pw_len - 7636 WPS_OOB_PUBKEY_HASH_LEN - 2); 7637 if (wpa_s->p2p_oob_dev_pw == NULL) 7638 return -1; 7639 7640 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL && 7641 wps_nfc_gen_dh(&wpa_s->conf->wps_nfc_dh_pubkey, 7642 &wpa_s->conf->wps_nfc_dh_privkey) < 0) 7643 return -1; 7644 } else { 7645 wpa_printf(MSG_DEBUG, "P2P: Using abbreviated WPS handshake " 7646 "without Device Password"); 7647 wpa_s->p2p_oob_dev_pw_id = DEV_PW_NFC_CONNECTION_HANDOVER; 7648 } 7649 7650 switch (params.next_step) { 7651 case NO_ACTION: 7652 case BOTH_GO: 7653 case PEER_CLIENT: 7654 /* already covered above */ 7655 return 0; 7656 case JOIN_GROUP: 7657 return wpas_p2p_nfc_join_group(wpa_s, ¶ms); 7658 case AUTH_JOIN: 7659 return wpas_p2p_nfc_auth_join(wpa_s, ¶ms, tag); 7660 case INIT_GO_NEG: 7661 return wpas_p2p_nfc_init_go_neg(wpa_s, ¶ms, forced_freq); 7662 case RESP_GO_NEG: 7663 /* TODO: use own OOB Dev Pw */ 7664 return wpas_p2p_nfc_resp_go_neg(wpa_s, ¶ms, forced_freq); 7665 } 7666 7667 return -1; 7668} 7669 7670 7671int wpas_p2p_nfc_tag_process(struct wpa_supplicant *wpa_s, 7672 const struct wpabuf *data, int forced_freq) 7673{ 7674 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 7675 return -1; 7676 7677 return wpas_p2p_nfc_connection_handover(wpa_s, data, 1, 1, forced_freq); 7678} 7679 7680 7681int wpas_p2p_nfc_report_handover(struct wpa_supplicant *wpa_s, int init, 7682 const struct wpabuf *req, 7683 const struct wpabuf *sel, int forced_freq) 7684{ 7685 struct wpabuf *tmp; 7686 int ret; 7687 7688 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 7689 return -1; 7690 7691 wpa_printf(MSG_DEBUG, "NFC: P2P connection handover reported"); 7692 7693 wpa_hexdump_ascii(MSG_DEBUG, "NFC: Req", 7694 wpabuf_head(req), wpabuf_len(req)); 7695 wpa_hexdump_ascii(MSG_DEBUG, "NFC: Sel", 7696 wpabuf_head(sel), wpabuf_len(sel)); 7697 if (forced_freq) 7698 wpa_printf(MSG_DEBUG, "NFC: Forced freq %d", forced_freq); 7699 tmp = ndef_parse_p2p(init ? sel : req); 7700 if (tmp == NULL) { 7701 wpa_printf(MSG_DEBUG, "P2P: Could not parse NDEF"); 7702 return -1; 7703 } 7704 7705 ret = wpas_p2p_nfc_connection_handover(wpa_s, tmp, init, 0, 7706 forced_freq); 7707 wpabuf_free(tmp); 7708 7709 return ret; 7710} 7711 7712 7713int wpas_p2p_nfc_tag_enabled(struct wpa_supplicant *wpa_s, int enabled) 7714{ 7715 const u8 *if_addr; 7716 int go_intent = wpa_s->conf->p2p_go_intent; 7717 struct wpa_supplicant *iface; 7718 7719 if (wpa_s->global->p2p == NULL) 7720 return -1; 7721 7722 if (!enabled) { 7723 wpa_printf(MSG_DEBUG, "P2P: Disable use of own NFC Tag"); 7724 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) 7725 { 7726 if (!iface->ap_iface) 7727 continue; 7728 hostapd_wps_nfc_token_disable(iface->ap_iface->bss[0]); 7729 } 7730 p2p_set_authorized_oob_dev_pw_id(wpa_s->global->p2p, 0, 7731 0, NULL); 7732 if (wpa_s->p2p_nfc_tag_enabled) 7733 wpas_p2p_remove_pending_group_interface(wpa_s); 7734 wpa_s->p2p_nfc_tag_enabled = 0; 7735 return 0; 7736 } 7737 7738 if (wpa_s->global->p2p_disabled) 7739 return -1; 7740 7741 if (wpa_s->conf->wps_nfc_dh_pubkey == NULL || 7742 wpa_s->conf->wps_nfc_dh_privkey == NULL || 7743 wpa_s->conf->wps_nfc_dev_pw == NULL || 7744 wpa_s->conf->wps_nfc_dev_pw_id < 0x10) { 7745 wpa_printf(MSG_DEBUG, "P2P: NFC password token not configured " 7746 "to allow static handover cases"); 7747 return -1; 7748 } 7749 7750 wpa_printf(MSG_DEBUG, "P2P: Enable use of own NFC Tag"); 7751 7752 wpa_s->p2p_oob_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id; 7753 wpabuf_free(wpa_s->p2p_oob_dev_pw); 7754 wpa_s->p2p_oob_dev_pw = wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw); 7755 if (wpa_s->p2p_oob_dev_pw == NULL) 7756 return -1; 7757 wpa_s->p2p_peer_oob_pk_hash_known = 0; 7758 7759 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO || 7760 wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT) { 7761 /* 7762 * P2P Group Interface present and the command came on group 7763 * interface, so enable the token for the current interface. 7764 */ 7765 wpa_s->create_p2p_iface = 0; 7766 } else { 7767 wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s); 7768 } 7769 7770 if (wpa_s->create_p2p_iface) { 7771 enum wpa_driver_if_type iftype; 7772 /* Prepare to add a new interface for the group */ 7773 iftype = WPA_IF_P2P_GROUP; 7774 if (go_intent == 15) 7775 iftype = WPA_IF_P2P_GO; 7776 if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) { 7777 wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new " 7778 "interface for the group"); 7779 return -1; 7780 } 7781 7782 if_addr = wpa_s->pending_interface_addr; 7783 } else 7784 if_addr = wpa_s->own_addr; 7785 7786 wpa_s->p2p_nfc_tag_enabled = enabled; 7787 7788 for (iface = wpa_s->global->ifaces; iface; iface = iface->next) { 7789 struct hostapd_data *hapd; 7790 if (iface->ap_iface == NULL) 7791 continue; 7792 hapd = iface->ap_iface->bss[0]; 7793 wpabuf_free(hapd->conf->wps_nfc_dh_pubkey); 7794 hapd->conf->wps_nfc_dh_pubkey = 7795 wpabuf_dup(wpa_s->conf->wps_nfc_dh_pubkey); 7796 wpabuf_free(hapd->conf->wps_nfc_dh_privkey); 7797 hapd->conf->wps_nfc_dh_privkey = 7798 wpabuf_dup(wpa_s->conf->wps_nfc_dh_privkey); 7799 wpabuf_free(hapd->conf->wps_nfc_dev_pw); 7800 hapd->conf->wps_nfc_dev_pw = 7801 wpabuf_dup(wpa_s->conf->wps_nfc_dev_pw); 7802 hapd->conf->wps_nfc_dev_pw_id = wpa_s->conf->wps_nfc_dev_pw_id; 7803 7804 if (hostapd_wps_nfc_token_enable(iface->ap_iface->bss[0]) < 0) { 7805 wpa_dbg(iface, MSG_DEBUG, 7806 "P2P: Failed to enable NFC Tag for GO"); 7807 } 7808 } 7809 p2p_set_authorized_oob_dev_pw_id( 7810 wpa_s->global->p2p, wpa_s->conf->wps_nfc_dev_pw_id, go_intent, 7811 if_addr); 7812 7813 return 0; 7814} 7815 7816#endif /* CONFIG_WPS_NFC */ 7817 7818 7819static void wpas_p2p_optimize_listen_channel(struct wpa_supplicant *wpa_s, 7820 struct wpa_used_freq_data *freqs, 7821 unsigned int num) 7822{ 7823 u8 curr_chan, cand, chan; 7824 unsigned int i; 7825 7826 curr_chan = p2p_get_listen_channel(wpa_s->global->p2p); 7827 for (i = 0, cand = 0; i < num; i++) { 7828 ieee80211_freq_to_chan(freqs[i].freq, &chan); 7829 if (curr_chan == chan) { 7830 cand = 0; 7831 break; 7832 } 7833 7834 if (chan == 1 || chan == 6 || chan == 11) 7835 cand = chan; 7836 } 7837 7838 if (cand) { 7839 wpa_dbg(wpa_s, MSG_DEBUG, 7840 "P2P: Update Listen channel to %u baased on operating channel", 7841 cand); 7842 p2p_set_listen_channel(wpa_s->global->p2p, 81, cand, 0); 7843 } 7844} 7845 7846 7847void wpas_p2p_indicate_state_change(struct wpa_supplicant *wpa_s) 7848{ 7849 struct wpa_used_freq_data *freqs; 7850 unsigned int num = wpa_s->num_multichan_concurrent; 7851 7852 if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL) 7853 return; 7854 7855 /* 7856 * If possible, optimize the Listen channel to be a channel that is 7857 * already used by one of the other interfaces. 7858 */ 7859 if (!wpa_s->conf->p2p_optimize_listen_chan) 7860 return; 7861 7862 if (!wpa_s->current_ssid || wpa_s->wpa_state != WPA_COMPLETED) 7863 return; 7864 7865 freqs = os_calloc(num, sizeof(struct wpa_used_freq_data)); 7866 if (!freqs) 7867 return; 7868 7869 num = get_shared_radio_freqs_data(wpa_s, freqs, num); 7870 7871 wpas_p2p_optimize_listen_channel(wpa_s, freqs, num); 7872 os_free(freqs); 7873} 7874 7875 7876void wpas_p2p_deinit_iface(struct wpa_supplicant *wpa_s) 7877{ 7878 if (wpa_s == wpa_s->parent) 7879 wpas_p2p_group_remove(wpa_s, "*"); 7880 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) { 7881 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing " 7882 "the management interface is being removed"); 7883 wpas_p2p_deinit_global(wpa_s->global); 7884 } 7885} 7886 7887 7888void wpas_p2p_ap_deinit(struct wpa_supplicant *wpa_s) 7889{ 7890 if (wpa_s->ap_iface->bss) 7891 wpa_s->ap_iface->bss[0]->p2p_group = NULL; 7892 wpas_p2p_group_deinit(wpa_s); 7893} 7894