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