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