1 /* 2 * WPA Supplicant 3 * Copyright (c) 2003-2024, Jouni Malinen <j (at) w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 * 8 * This file implements functions for registering and unregistering 9 * %wpa_supplicant interfaces. In addition, this file contains number of 10 * functions for managing network connections. 11 */ 12 13 #include "includes.h" 14 #ifdef CONFIG_MATCH_IFACE 15 #include <net/if.h> 16 #include <fnmatch.h> 17 #endif /* CONFIG_MATCH_IFACE */ 18 19 #include "common.h" 20 #include "crypto/crypto.h" 21 #include "crypto/random.h" 22 #include "crypto/sha1.h" 23 #include "eapol_supp/eapol_supp_sm.h" 24 #include "eap_peer/eap.h" 25 #include "eap_peer/eap_proxy.h" 26 #include "eap_server/eap_methods.h" 27 #include "rsn_supp/wpa.h" 28 #include "eloop.h" 29 #include "config.h" 30 #include "utils/ext_password.h" 31 #include "l2_packet/l2_packet.h" 32 #include "wpa_supplicant_i.h" 33 #include "driver_i.h" 34 #include "ctrl_iface.h" 35 #include "pcsc_funcs.h" 36 #include "common/version.h" 37 #include "rsn_supp/preauth.h" 38 #include "rsn_supp/pmksa_cache.h" 39 #include "common/wpa_ctrl.h" 40 #include "common/ieee802_11_common.h" 41 #include "common/ieee802_11_defs.h" 42 #include "common/hw_features_common.h" 43 #include "common/gas_server.h" 44 #include "common/dpp.h" 45 #include "common/ptksa_cache.h" 46 #include "p2p/p2p.h" 47 #include "fst/fst.h" 48 #include "bssid_ignore.h" 49 #include "wpas_glue.h" 50 #include "wps_supplicant.h" 51 #include "ibss_rsn.h" 52 #include "sme.h" 53 #include "gas_query.h" 54 #include "ap.h" 55 #include "p2p_supplicant.h" 56 #include "wifi_display.h" 57 #include "notify.h" 58 #include "bgscan.h" 59 #include "autoscan.h" 60 #include "bss.h" 61 #include "scan.h" 62 #include "offchannel.h" 63 #include "hs20_supplicant.h" 64 #include "wnm_sta.h" 65 #include "wpas_kay.h" 66 #include "mesh.h" 67 #include "dpp_supplicant.h" 68 #include "nan_usd.h" 69 #ifdef CONFIG_MESH 70 #include "ap/ap_config.h" 71 #include "ap/hostapd.h" 72 #endif /* CONFIG_MESH */ 73 74 const char *const wpa_supplicant_version = 75 "wpa_supplicant v" VERSION_STR "\n" 76 "Copyright (c) 2003-2024, Jouni Malinen <j (at) w1.fi> and contributors"; 77 78 const char *const wpa_supplicant_license = 79 "This software may be distributed under the terms of the BSD license.\n" 80 "See README for more details.\n" 81 #ifdef EAP_TLS_OPENSSL 82 "\nThis product includes software developed by the OpenSSL Project\n" 83 "for use in the OpenSSL Toolkit (http://www.openssl.org/)\n" 84 #endif /* EAP_TLS_OPENSSL */ 85 ; 86 87 #ifndef CONFIG_NO_STDOUT_DEBUG 88 /* Long text divided into parts in order to fit in C89 strings size limits. */ 89 const char *const wpa_supplicant_full_license1 = 90 ""; 91 const char *const wpa_supplicant_full_license2 = 92 "This software may be distributed under the terms of the BSD license.\n" 93 "\n" 94 "Redistribution and use in source and binary forms, with or without\n" 95 "modification, are permitted provided that the following conditions are\n" 96 "met:\n" 97 "\n"; 98 const char *const wpa_supplicant_full_license3 = 99 "1. Redistributions of source code must retain the above copyright\n" 100 " notice, this list of conditions and the following disclaimer.\n" 101 "\n" 102 "2. Redistributions in binary form must reproduce the above copyright\n" 103 " notice, this list of conditions and the following disclaimer in the\n" 104 " documentation and/or other materials provided with the distribution.\n" 105 "\n"; 106 const char *const wpa_supplicant_full_license4 = 107 "3. Neither the name(s) of the above-listed copyright holder(s) nor the\n" 108 " names of its contributors may be used to endorse or promote products\n" 109 " derived from this software without specific prior written permission.\n" 110 "\n" 111 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n" 112 "\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n" 113 "LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n" 114 "A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"; 115 const char *const wpa_supplicant_full_license5 = 116 "OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n" 117 "SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n" 118 "LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n" 119 "DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n" 120 "THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n" 121 "(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n" 122 "OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" 123 "\n"; 124 #endif /* CONFIG_NO_STDOUT_DEBUG */ 125 126 127 static void wpa_bss_tmp_disallow_timeout(void *eloop_ctx, void *timeout_ctx); 128 static void wpas_verify_ssid_beacon(void *eloop_ctx, void *timeout_ctx); 129 #if defined(CONFIG_FILS) && defined(IEEE8021X_EAPOL) 130 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s); 131 #endif /* CONFIG_FILS && IEEE8021X_EAPOL */ 132 #ifdef CONFIG_OWE 133 static void wpas_update_owe_connect_params(struct wpa_supplicant *wpa_s); 134 #endif /* CONFIG_OWE */ 135 136 137 #ifdef CONFIG_WEP 138 /* Configure default/group WEP keys for static WEP */ 139 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid) 140 { 141 int i, set = 0; 142 143 for (i = 0; i < NUM_WEP_KEYS; i++) { 144 if (ssid->wep_key_len[i] == 0) 145 continue; 146 147 set = 1; 148 wpa_drv_set_key(wpa_s, -1, WPA_ALG_WEP, NULL, 149 i, i == ssid->wep_tx_keyidx, NULL, 0, 150 ssid->wep_key[i], ssid->wep_key_len[i], 151 i == ssid->wep_tx_keyidx ? 152 KEY_FLAG_GROUP_RX_TX_DEFAULT : 153 KEY_FLAG_GROUP_RX_TX); 154 } 155 156 return set; 157 } 158 #endif /* CONFIG_WEP */ 159 160 161 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s, 162 struct wpa_ssid *ssid) 163 { 164 u8 key[32]; 165 size_t keylen; 166 enum wpa_alg alg; 167 u8 seq[6] = { 0 }; 168 int ret; 169 170 /* IBSS/WPA-None uses only one key (Group) for both receiving and 171 * sending unicast and multicast packets. */ 172 173 if (ssid->mode != WPAS_MODE_IBSS) { 174 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not " 175 "IBSS/ad-hoc) for WPA-None", ssid->mode); 176 return -1; 177 } 178 179 if (!ssid->psk_set) { 180 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for " 181 "WPA-None"); 182 return -1; 183 } 184 185 switch (wpa_s->group_cipher) { 186 case WPA_CIPHER_CCMP: 187 os_memcpy(key, ssid->psk, 16); 188 keylen = 16; 189 alg = WPA_ALG_CCMP; 190 break; 191 case WPA_CIPHER_GCMP: 192 os_memcpy(key, ssid->psk, 16); 193 keylen = 16; 194 alg = WPA_ALG_GCMP; 195 break; 196 case WPA_CIPHER_TKIP: 197 /* WPA-None uses the same Michael MIC key for both TX and RX */ 198 os_memcpy(key, ssid->psk, 16 + 8); 199 os_memcpy(key + 16 + 8, ssid->psk + 16, 8); 200 keylen = 32; 201 alg = WPA_ALG_TKIP; 202 break; 203 default: 204 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for " 205 "WPA-None", wpa_s->group_cipher); 206 return -1; 207 } 208 209 /* TODO: should actually remember the previously used seq#, both for TX 210 * and RX from each STA.. */ 211 212 ret = wpa_drv_set_key(wpa_s, -1, alg, NULL, 0, 1, seq, 6, key, keylen, 213 KEY_FLAG_GROUP_RX_TX_DEFAULT); 214 os_memset(key, 0, sizeof(key)); 215 return ret; 216 } 217 218 219 static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx) 220 { 221 struct wpa_supplicant *wpa_s = eloop_ctx; 222 const u8 *bssid = wpa_s->bssid; 223 if (!is_zero_ether_addr(wpa_s->pending_bssid) && 224 (wpa_s->wpa_state == WPA_AUTHENTICATING || 225 wpa_s->wpa_state == WPA_ASSOCIATING)) 226 bssid = wpa_s->pending_bssid; 227 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.", 228 MAC2STR(bssid)); 229 wpa_bssid_ignore_add(wpa_s, bssid); 230 wpa_sm_notify_disassoc(wpa_s->wpa); 231 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING); 232 wpa_s->reassociate = 1; 233 234 /* 235 * If we timed out, the AP or the local radio may be busy. 236 * So, wait a second until scanning again. 237 */ 238 wpa_supplicant_req_scan(wpa_s, 1, 0); 239 } 240 241 242 /** 243 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication 244 * @wpa_s: Pointer to wpa_supplicant data 245 * @sec: Number of seconds after which to time out authentication 246 * @usec: Number of microseconds after which to time out authentication 247 * 248 * This function is used to schedule a timeout for the current authentication 249 * attempt. 250 */ 251 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s, 252 int sec, int usec) 253 { 254 if (wpa_s->conf->ap_scan == 0 && 255 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) 256 return; 257 258 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec " 259 "%d usec", sec, usec); 260 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 261 wpa_s->last_auth_timeout_sec = sec; 262 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL); 263 } 264 265 266 /* 267 * wpas_auth_timeout_restart - Restart and change timeout for authentication 268 * @wpa_s: Pointer to wpa_supplicant data 269 * @sec_diff: difference in seconds applied to original timeout value 270 */ 271 void wpas_auth_timeout_restart(struct wpa_supplicant *wpa_s, int sec_diff) 272 { 273 int new_sec = wpa_s->last_auth_timeout_sec + sec_diff; 274 275 if (eloop_is_timeout_registered(wpa_supplicant_timeout, wpa_s, NULL)) { 276 wpa_dbg(wpa_s, MSG_DEBUG, 277 "Authentication timeout restart: %d sec", new_sec); 278 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 279 eloop_register_timeout(new_sec, 0, wpa_supplicant_timeout, 280 wpa_s, NULL); 281 } 282 } 283 284 285 /** 286 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout 287 * @wpa_s: Pointer to wpa_supplicant data 288 * 289 * This function is used to cancel authentication timeout scheduled with 290 * wpa_supplicant_req_auth_timeout() and it is called when authentication has 291 * been completed. 292 */ 293 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s) 294 { 295 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout"); 296 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 297 wpa_bssid_ignore_del(wpa_s, wpa_s->bssid); 298 os_free(wpa_s->last_con_fail_realm); 299 wpa_s->last_con_fail_realm = NULL; 300 wpa_s->last_con_fail_realm_len = 0; 301 } 302 303 304 /** 305 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine 306 * @wpa_s: Pointer to wpa_supplicant data 307 * 308 * This function is used to configure EAPOL state machine based on the selected 309 * authentication mode. 310 */ 311 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s) 312 { 313 #ifdef IEEE8021X_EAPOL 314 struct eapol_config eapol_conf; 315 struct wpa_ssid *ssid = wpa_s->current_ssid; 316 317 #ifdef CONFIG_IBSS_RSN 318 if (ssid->mode == WPAS_MODE_IBSS && 319 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE && 320 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) { 321 /* 322 * RSN IBSS authentication is per-STA and we can disable the 323 * per-BSSID EAPOL authentication. 324 */ 325 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized); 326 eapol_sm_notify_eap_success(wpa_s->eapol, true); 327 eapol_sm_notify_eap_fail(wpa_s->eapol, false); 328 return; 329 } 330 #endif /* CONFIG_IBSS_RSN */ 331 332 eapol_sm_notify_eap_success(wpa_s->eapol, false); 333 eapol_sm_notify_eap_fail(wpa_s->eapol, false); 334 335 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 336 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) 337 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized); 338 else 339 eapol_sm_notify_portControl(wpa_s->eapol, Auto); 340 341 os_memset(&eapol_conf, 0, sizeof(eapol_conf)); 342 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 343 eapol_conf.accept_802_1x_keys = 1; 344 eapol_conf.required_keys = 0; 345 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) { 346 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST; 347 } 348 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) { 349 eapol_conf.required_keys |= 350 EAPOL_REQUIRE_KEY_BROADCAST; 351 } 352 353 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED) 354 eapol_conf.required_keys = 0; 355 } 356 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth; 357 eapol_conf.workaround = ssid->eap_workaround; 358 eapol_conf.eap_disabled = 359 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) && 360 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA && 361 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS; 362 eapol_conf.external_sim = wpa_s->conf->external_sim; 363 364 #ifdef CONFIG_WPS 365 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) { 366 eapol_conf.wps |= EAPOL_LOCAL_WPS_IN_USE; 367 if (wpa_s->current_bss) { 368 struct wpabuf *ie; 369 ie = wpa_bss_get_vendor_ie_multi(wpa_s->current_bss, 370 WPS_IE_VENDOR_TYPE); 371 if (ie) { 372 if (wps_is_20(ie)) 373 eapol_conf.wps |= 374 EAPOL_PEER_IS_WPS20_AP; 375 wpabuf_free(ie); 376 } 377 } 378 } 379 #endif /* CONFIG_WPS */ 380 381 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf); 382 383 #ifdef CONFIG_MACSEC 384 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE && ssid->mka_psk_set) 385 ieee802_1x_create_preshared_mka(wpa_s, ssid); 386 else 387 ieee802_1x_alloc_kay_sm(wpa_s, ssid); 388 #endif /* CONFIG_MACSEC */ 389 #endif /* IEEE8021X_EAPOL */ 390 } 391 392 393 /** 394 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode 395 * @wpa_s: Pointer to wpa_supplicant data 396 * @ssid: Configuration data for the network 397 * 398 * This function is used to configure WPA state machine and related parameters 399 * to a mode where WPA is not enabled. This is called as part of the 400 * authentication configuration when the selected network does not use WPA. 401 */ 402 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s, 403 struct wpa_ssid *ssid) 404 { 405 #ifdef CONFIG_WEP 406 int i; 407 #endif /* CONFIG_WEP */ 408 struct wpa_sm_mlo mlo; 409 410 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) 411 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS; 412 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) 413 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA; 414 else 415 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE; 416 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0); 417 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0); 418 wpa_sm_set_ap_rsnxe(wpa_s->wpa, NULL, 0); 419 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 420 wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0); 421 wpa_s->rsnxe_len = 0; 422 wpa_s->pairwise_cipher = WPA_CIPHER_NONE; 423 wpa_s->group_cipher = WPA_CIPHER_NONE; 424 wpa_s->mgmt_group_cipher = 0; 425 426 #ifdef CONFIG_WEP 427 for (i = 0; i < NUM_WEP_KEYS; i++) { 428 if (ssid->wep_key_len[i] > 5) { 429 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104; 430 wpa_s->group_cipher = WPA_CIPHER_WEP104; 431 break; 432 } else if (ssid->wep_key_len[i] > 0) { 433 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40; 434 wpa_s->group_cipher = WPA_CIPHER_WEP40; 435 break; 436 } 437 } 438 #endif /* CONFIG_WEP */ 439 440 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0); 441 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt); 442 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, 443 wpa_s->pairwise_cipher); 444 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher); 445 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP, 446 wpa_s->mgmt_group_cipher); 447 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SSID_PROTECTION, 0); 448 449 pmksa_cache_clear_current(wpa_s->wpa); 450 os_memset(&mlo, 0, sizeof(mlo)); 451 wpa_sm_set_mlo_params(wpa_s->wpa, &mlo); 452 } 453 454 455 void free_hw_features(struct wpa_supplicant *wpa_s) 456 { 457 int i; 458 if (wpa_s->hw.modes == NULL) 459 return; 460 461 for (i = 0; i < wpa_s->hw.num_modes; i++) { 462 os_free(wpa_s->hw.modes[i].channels); 463 os_free(wpa_s->hw.modes[i].rates); 464 } 465 466 os_free(wpa_s->hw.modes); 467 wpa_s->hw.modes = NULL; 468 } 469 470 471 static void remove_bss_tmp_disallowed_entry(struct wpa_supplicant *wpa_s, 472 struct wpa_bss_tmp_disallowed *bss) 473 { 474 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss); 475 dl_list_del(&bss->list); 476 os_free(bss); 477 } 478 479 480 void free_bss_tmp_disallowed(struct wpa_supplicant *wpa_s) 481 { 482 struct wpa_bss_tmp_disallowed *bss, *prev; 483 484 dl_list_for_each_safe(bss, prev, &wpa_s->bss_tmp_disallowed, 485 struct wpa_bss_tmp_disallowed, list) 486 remove_bss_tmp_disallowed_entry(wpa_s, bss); 487 } 488 489 490 void wpas_flush_fils_hlp_req(struct wpa_supplicant *wpa_s) 491 { 492 struct fils_hlp_req *req; 493 494 while ((req = dl_list_first(&wpa_s->fils_hlp_req, struct fils_hlp_req, 495 list)) != NULL) { 496 dl_list_del(&req->list); 497 wpabuf_free(req->pkt); 498 os_free(req); 499 } 500 } 501 502 503 void wpas_clear_disabled_interface(void *eloop_ctx, void *timeout_ctx) 504 { 505 struct wpa_supplicant *wpa_s = eloop_ctx; 506 507 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED) 508 return; 509 wpa_dbg(wpa_s, MSG_DEBUG, "Clear cached state on disabled interface"); 510 wpa_bss_flush(wpa_s); 511 } 512 513 514 #ifdef CONFIG_TESTING_OPTIONS 515 void wpas_clear_driver_signal_override(struct wpa_supplicant *wpa_s) 516 { 517 struct driver_signal_override *dso; 518 519 while ((dso = dl_list_first(&wpa_s->drv_signal_override, 520 struct driver_signal_override, list))) { 521 dl_list_del(&dso->list); 522 os_free(dso); 523 } 524 } 525 #endif /* CONFIG_TESTING_OPTIONS */ 526 527 528 static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s) 529 { 530 int i; 531 532 bgscan_deinit(wpa_s); 533 autoscan_deinit(wpa_s); 534 scard_deinit(wpa_s->scard); 535 wpa_s->scard = NULL; 536 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL); 537 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL); 538 l2_packet_deinit(wpa_s->l2); 539 wpa_s->l2 = NULL; 540 if (wpa_s->l2_br) { 541 l2_packet_deinit(wpa_s->l2_br); 542 wpa_s->l2_br = NULL; 543 } 544 #ifdef CONFIG_TESTING_OPTIONS 545 l2_packet_deinit(wpa_s->l2_test); 546 wpa_s->l2_test = NULL; 547 os_free(wpa_s->get_pref_freq_list_override); 548 wpa_s->get_pref_freq_list_override = NULL; 549 wpabuf_free(wpa_s->last_assoc_req_wpa_ie); 550 wpa_s->last_assoc_req_wpa_ie = NULL; 551 os_free(wpa_s->extra_sae_rejected_groups); 552 wpa_s->extra_sae_rejected_groups = NULL; 553 wpabuf_free(wpa_s->rsne_override_eapol); 554 wpa_s->rsne_override_eapol = NULL; 555 wpabuf_free(wpa_s->rsnxe_override_assoc); 556 wpa_s->rsnxe_override_assoc = NULL; 557 wpabuf_free(wpa_s->rsnxe_override_eapol); 558 wpa_s->rsnxe_override_eapol = NULL; 559 wpas_clear_driver_signal_override(wpa_s); 560 #endif /* CONFIG_TESTING_OPTIONS */ 561 562 if (wpa_s->conf != NULL) { 563 struct wpa_ssid *ssid; 564 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) 565 wpas_notify_network_removed(wpa_s, ssid); 566 } 567 568 os_free(wpa_s->confname); 569 wpa_s->confname = NULL; 570 571 os_free(wpa_s->confanother); 572 wpa_s->confanother = NULL; 573 574 os_free(wpa_s->last_con_fail_realm); 575 wpa_s->last_con_fail_realm = NULL; 576 wpa_s->last_con_fail_realm_len = 0; 577 578 wpa_sm_set_eapol(wpa_s->wpa, NULL); 579 eapol_sm_deinit(wpa_s->eapol); 580 wpa_s->eapol = NULL; 581 582 rsn_preauth_deinit(wpa_s->wpa); 583 584 #ifdef CONFIG_TDLS 585 wpa_tdls_deinit(wpa_s->wpa); 586 #endif /* CONFIG_TDLS */ 587 588 #ifndef CONFIG_NO_WMM_AC 589 wmm_ac_clear_saved_tspecs(wpa_s); 590 #endif /* CONFIG_NO_WMM_AC */ 591 pmksa_candidate_free(wpa_s->wpa); 592 ptksa_cache_deinit(wpa_s->ptksa); 593 wpa_s->ptksa = NULL; 594 wpa_sm_deinit(wpa_s->wpa); 595 wpa_s->wpa = NULL; 596 wpa_bssid_ignore_clear(wpa_s); 597 598 #ifdef CONFIG_PASN 599 wpas_pasn_auth_stop(wpa_s); 600 #endif /* CONFIG_PASN */ 601 602 wpa_bss_deinit(wpa_s); 603 604 wpa_supplicant_cancel_delayed_sched_scan(wpa_s); 605 wpa_supplicant_cancel_scan(wpa_s); 606 wpa_supplicant_cancel_auth_timeout(wpa_s); 607 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL); 608 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT 609 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report, 610 wpa_s, NULL); 611 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */ 612 613 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL); 614 eloop_cancel_timeout(wpas_clear_disabled_interface, wpa_s, NULL); 615 eloop_cancel_timeout(wpas_verify_ssid_beacon, wpa_s, NULL); 616 617 wpas_wps_deinit(wpa_s); 618 619 wpabuf_free(wpa_s->pending_eapol_rx); 620 wpa_s->pending_eapol_rx = NULL; 621 622 #ifdef CONFIG_IBSS_RSN 623 ibss_rsn_deinit(wpa_s->ibss_rsn); 624 wpa_s->ibss_rsn = NULL; 625 #endif /* CONFIG_IBSS_RSN */ 626 627 sme_deinit(wpa_s); 628 629 #ifdef CONFIG_AP 630 wpa_supplicant_ap_deinit(wpa_s); 631 #endif /* CONFIG_AP */ 632 633 wpas_p2p_deinit(wpa_s); 634 635 #ifdef CONFIG_OFFCHANNEL 636 offchannel_deinit(wpa_s); 637 #endif /* CONFIG_OFFCHANNEL */ 638 639 wpa_supplicant_cancel_sched_scan(wpa_s); 640 641 os_free(wpa_s->next_scan_freqs); 642 wpa_s->next_scan_freqs = NULL; 643 644 os_free(wpa_s->manual_scan_freqs); 645 wpa_s->manual_scan_freqs = NULL; 646 os_free(wpa_s->select_network_scan_freqs); 647 wpa_s->select_network_scan_freqs = NULL; 648 649 os_free(wpa_s->manual_sched_scan_freqs); 650 wpa_s->manual_sched_scan_freqs = NULL; 651 652 wpas_mac_addr_rand_scan_clear(wpa_s, MAC_ADDR_RAND_ALL); 653 654 /* 655 * Need to remove any pending gas-query radio work before the 656 * gas_query_deinit() call because gas_query::work has not yet been set 657 * for works that have not been started. gas_query_free() will be unable 658 * to cancel such pending radio works and once the pending gas-query 659 * radio work eventually gets removed, the deinit notification call to 660 * gas_query_start_cb() would result in dereferencing freed memory. 661 */ 662 if (wpa_s->radio) 663 radio_remove_works(wpa_s, "gas-query", 0); 664 gas_query_deinit(wpa_s->gas); 665 wpa_s->gas = NULL; 666 gas_server_deinit(wpa_s->gas_server); 667 wpa_s->gas_server = NULL; 668 669 free_hw_features(wpa_s); 670 671 ieee802_1x_dealloc_kay_sm(wpa_s); 672 673 os_free(wpa_s->bssid_filter); 674 wpa_s->bssid_filter = NULL; 675 676 os_free(wpa_s->disallow_aps_bssid); 677 wpa_s->disallow_aps_bssid = NULL; 678 os_free(wpa_s->disallow_aps_ssid); 679 wpa_s->disallow_aps_ssid = NULL; 680 681 wnm_bss_keep_alive_deinit(wpa_s); 682 wnm_btm_reset(wpa_s); 683 684 ext_password_deinit(wpa_s->ext_pw); 685 wpa_s->ext_pw = NULL; 686 687 wpabuf_free(wpa_s->last_gas_resp); 688 wpa_s->last_gas_resp = NULL; 689 wpabuf_free(wpa_s->prev_gas_resp); 690 wpa_s->prev_gas_resp = NULL; 691 692 os_free(wpa_s->last_scan_res); 693 wpa_s->last_scan_res = NULL; 694 695 #ifdef CONFIG_HS20 696 if (wpa_s->drv_priv) 697 wpa_drv_configure_frame_filters(wpa_s, 0); 698 hs20_deinit(wpa_s); 699 #endif /* CONFIG_HS20 */ 700 701 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) { 702 wpabuf_free(wpa_s->vendor_elem[i]); 703 wpa_s->vendor_elem[i] = NULL; 704 } 705 706 #ifndef CONFIG_NO_WMM_AC 707 wmm_ac_notify_disassoc(wpa_s); 708 #endif /* CONFIG_NO_WMM_AC */ 709 710 wpa_s->sched_scan_plans_num = 0; 711 os_free(wpa_s->sched_scan_plans); 712 wpa_s->sched_scan_plans = NULL; 713 714 #ifdef CONFIG_MBO 715 wpa_s->non_pref_chan_num = 0; 716 os_free(wpa_s->non_pref_chan); 717 wpa_s->non_pref_chan = NULL; 718 #endif /* CONFIG_MBO */ 719 720 free_bss_tmp_disallowed(wpa_s); 721 722 wpabuf_free(wpa_s->lci); 723 wpa_s->lci = NULL; 724 #ifndef CONFIG_NO_RRM 725 wpas_clear_beacon_rep_data(wpa_s); 726 #endif /* CONFIG_NO_RRM */ 727 728 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL 729 #ifdef CONFIG_MESH 730 { 731 struct external_pmksa_cache *entry; 732 733 while ((entry = dl_list_last(&wpa_s->mesh_external_pmksa_cache, 734 struct external_pmksa_cache, 735 list)) != NULL) { 736 dl_list_del(&entry->list); 737 os_free(entry->pmksa_cache); 738 os_free(entry); 739 } 740 } 741 #endif /* CONFIG_MESH */ 742 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */ 743 744 wpas_flush_fils_hlp_req(wpa_s); 745 746 wpabuf_free(wpa_s->ric_ies); 747 wpa_s->ric_ies = NULL; 748 749 #ifdef CONFIG_DPP 750 wpas_dpp_deinit(wpa_s); 751 dpp_global_deinit(wpa_s->dpp); 752 wpa_s->dpp = NULL; 753 #endif /* CONFIG_DPP */ 754 755 #ifdef CONFIG_NAN_USD 756 wpas_nan_usd_deinit(wpa_s); 757 #endif /* CONFIG_NAN_USD */ 758 759 #ifdef CONFIG_PASN 760 wpas_pasn_auth_stop(wpa_s); 761 #endif /* CONFIG_PASN */ 762 #ifndef CONFIG_NO_ROBUST_AV 763 wpas_scs_deinit(wpa_s); 764 wpas_dscp_deinit(wpa_s); 765 #endif /* CONFIG_NO_ROBUST_AV */ 766 767 #ifdef CONFIG_OWE 768 os_free(wpa_s->owe_trans_scan_freq); 769 wpa_s->owe_trans_scan_freq = NULL; 770 #endif /* CONFIG_OWE */ 771 } 772 773 774 /** 775 * wpa_clear_keys - Clear keys configured for the driver 776 * @wpa_s: Pointer to wpa_supplicant data 777 * @addr: Previously used BSSID or %NULL if not available 778 * 779 * This function clears the encryption keys that has been previously configured 780 * for the driver. 781 */ 782 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr) 783 { 784 int i, max = 6; 785 786 /* MLME-DELETEKEYS.request */ 787 for (i = 0; i < max; i++) { 788 if (wpa_s->keys_cleared & BIT(i)) 789 continue; 790 wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, NULL, i, 0, NULL, 0, 791 NULL, 0, KEY_FLAG_GROUP); 792 } 793 /* Pairwise Key ID 1 for Extended Key ID is tracked in bit 15 */ 794 if (~wpa_s->keys_cleared & (BIT(0) | BIT(15)) && addr && 795 !is_zero_ether_addr(addr)) { 796 if (!(wpa_s->keys_cleared & BIT(0))) 797 wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, addr, 0, 0, 798 NULL, 0, NULL, 0, KEY_FLAG_PAIRWISE); 799 if (!(wpa_s->keys_cleared & BIT(15))) 800 wpa_drv_set_key(wpa_s, -1, WPA_ALG_NONE, addr, 1, 0, 801 NULL, 0, NULL, 0, KEY_FLAG_PAIRWISE); 802 /* MLME-SETPROTECTION.request(None) */ 803 wpa_drv_mlme_setprotection( 804 wpa_s, addr, 805 MLME_SETPROTECTION_PROTECT_TYPE_NONE, 806 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE); 807 } 808 wpa_s->keys_cleared = (u32) -1; 809 } 810 811 812 /** 813 * wpa_supplicant_state_txt - Get the connection state name as a text string 814 * @state: State (wpa_state; WPA_*) 815 * Returns: The state name as a printable text string 816 */ 817 const char * wpa_supplicant_state_txt(enum wpa_states state) 818 { 819 switch (state) { 820 case WPA_DISCONNECTED: 821 return "DISCONNECTED"; 822 case WPA_INACTIVE: 823 return "INACTIVE"; 824 case WPA_INTERFACE_DISABLED: 825 return "INTERFACE_DISABLED"; 826 case WPA_SCANNING: 827 return "SCANNING"; 828 case WPA_AUTHENTICATING: 829 return "AUTHENTICATING"; 830 case WPA_ASSOCIATING: 831 return "ASSOCIATING"; 832 case WPA_ASSOCIATED: 833 return "ASSOCIATED"; 834 case WPA_4WAY_HANDSHAKE: 835 return "4WAY_HANDSHAKE"; 836 case WPA_GROUP_HANDSHAKE: 837 return "GROUP_HANDSHAKE"; 838 case WPA_COMPLETED: 839 return "COMPLETED"; 840 default: 841 return "UNKNOWN"; 842 } 843 } 844 845 846 #ifdef CONFIG_BGSCAN 847 848 static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s) 849 { 850 if (wpa_s->bgscan_ssid) { 851 bgscan_deinit(wpa_s); 852 wpa_s->bgscan_ssid = NULL; 853 } 854 } 855 856 857 /** 858 * wpa_supplicant_reset_bgscan - Reset the bgscan for the current SSID. 859 * @wpa_s: Pointer to the wpa_supplicant data 860 * 861 * Stop, start, or reconfigure the scan parameters depending on the method. 862 */ 863 void wpa_supplicant_reset_bgscan(struct wpa_supplicant *wpa_s) 864 { 865 const char *name; 866 867 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan) 868 name = wpa_s->current_ssid->bgscan; 869 else 870 name = wpa_s->conf->bgscan; 871 if (!name || name[0] == '\0') { 872 wpa_supplicant_stop_bgscan(wpa_s); 873 return; 874 } 875 if (wpas_driver_bss_selection(wpa_s)) 876 return; 877 #ifdef CONFIG_P2P 878 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) 879 return; 880 #endif /* CONFIG_P2P */ 881 882 bgscan_deinit(wpa_s); 883 if (wpa_s->current_ssid) { 884 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) { 885 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize " 886 "bgscan"); 887 /* 888 * Live without bgscan; it is only used as a roaming 889 * optimization, so the initial connection is not 890 * affected. 891 */ 892 } else { 893 struct wpa_scan_results *scan_res; 894 wpa_s->bgscan_ssid = wpa_s->current_ssid; 895 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 896 0, NULL); 897 if (scan_res) { 898 bgscan_notify_scan(wpa_s, scan_res); 899 wpa_scan_results_free(scan_res); 900 } 901 } 902 } else 903 wpa_s->bgscan_ssid = NULL; 904 } 905 906 #endif /* CONFIG_BGSCAN */ 907 908 909 static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s) 910 { 911 if (autoscan_init(wpa_s, 0)) 912 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan"); 913 } 914 915 916 static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s) 917 { 918 autoscan_deinit(wpa_s); 919 } 920 921 922 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s) 923 { 924 if (wpa_s->wpa_state == WPA_DISCONNECTED || 925 wpa_s->wpa_state == WPA_SCANNING) { 926 autoscan_deinit(wpa_s); 927 wpa_supplicant_start_autoscan(wpa_s); 928 } 929 } 930 931 932 static void wpas_verify_ssid_beacon(void *eloop_ctx, void *timeout_ctx) 933 { 934 struct wpa_supplicant *wpa_s = eloop_ctx; 935 struct wpa_bss *bss; 936 const u8 *ssid; 937 size_t ssid_len; 938 939 if (!wpa_s->current_ssid || !wpa_s->current_bss) 940 return; 941 942 ssid = wpa_s->current_bss->ssid; 943 ssid_len = wpa_s->current_bss->ssid_len; 944 945 if (wpa_s->current_ssid->ssid_len && 946 (wpa_s->current_ssid->ssid_len != ssid_len || 947 os_memcmp(wpa_s->current_ssid->ssid, ssid, ssid_len) != 0)) 948 return; 949 950 if (wpa_s->wpa_state < WPA_4WAY_HANDSHAKE || 951 !wpa_s->bigtk_set || wpa_s->ssid_verified) 952 return; 953 954 wpa_printf(MSG_DEBUG, 955 "SSID not yet verified; check if the driver has received a verified Beacon frame"); 956 if (wpa_supplicant_update_scan_results(wpa_s, wpa_s->bssid) < 0) 957 return; 958 959 bss = wpa_bss_get_bssid_latest(wpa_s, wpa_s->bssid); 960 if (!bss) 961 return; 962 wpa_printf(MSG_DEBUG, "The current beacon time stamp: 0x%llx", 963 (long long unsigned int) bss->tsf); 964 if (bss->tsf > wpa_s->first_beacon_tsf) { 965 const u8 *ie; 966 967 wpa_printf(MSG_DEBUG, 968 "Verified Beacon frame has been received"); 969 wpa_s->beacons_checked++; 970 971 ie = wpa_bss_get_ie_beacon(bss, WLAN_EID_SSID); 972 if (ie && ie[1] == ssid_len && 973 os_memcmp(&ie[2], ssid, ssid_len) == 0) { 974 wpa_printf(MSG_DEBUG, 975 "SSID verified based on a Beacon frame and beacon protection"); 976 wpa_s->ssid_verified = true; 977 return; 978 } 979 980 /* TODO: Multiple BSSID element */ 981 } 982 983 if (wpa_s->beacons_checked < 16) { 984 eloop_register_timeout(wpa_s->next_beacon_check, 0, 985 wpas_verify_ssid_beacon, wpa_s, NULL); 986 wpa_s->next_beacon_check++; 987 } 988 } 989 990 991 static void wpas_verify_ssid_beacon_prot(struct wpa_supplicant *wpa_s) 992 { 993 struct wpa_bss *bss; 994 995 wpa_printf(MSG_DEBUG, 996 "SSID not yet verified; try to verify using beacon protection"); 997 /* Fetch the current scan result which is likely based on not yet 998 * verified payload since the current BIGTK was just received. Any 999 * newer update in the future with a larger timestamp value is an 1000 * indication that a verified Beacon frame has been received. */ 1001 if (wpa_supplicant_update_scan_results(wpa_s, wpa_s->bssid) < 0) 1002 return; 1003 1004 bss = wpa_bss_get_bssid_latest(wpa_s, wpa_s->bssid); 1005 if (!bss) 1006 return; 1007 wpa_printf(MSG_DEBUG, "The initial beacon time stamp: 0x%llx", 1008 (long long unsigned int) bss->tsf); 1009 wpa_s->first_beacon_tsf = bss->tsf; 1010 wpa_s->beacons_checked = 0; 1011 wpa_s->next_beacon_check = 1; 1012 eloop_cancel_timeout(wpas_verify_ssid_beacon, wpa_s, NULL); 1013 eloop_register_timeout(1, 0, wpas_verify_ssid_beacon, wpa_s, NULL); 1014 } 1015 1016 1017 /** 1018 * wpa_supplicant_set_state - Set current connection state 1019 * @wpa_s: Pointer to wpa_supplicant data 1020 * @state: The new connection state 1021 * 1022 * This function is called whenever the connection state changes, e.g., 1023 * association is completed for WPA/WPA2 4-Way Handshake is started. 1024 */ 1025 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, 1026 enum wpa_states state) 1027 { 1028 enum wpa_states old_state = wpa_s->wpa_state; 1029 #if defined(CONFIG_FILS) && defined(IEEE8021X_EAPOL) 1030 bool update_fils_connect_params = false; 1031 #endif /* CONFIG_FILS && IEEE8021X_EAPOL */ 1032 1033 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s", 1034 wpa_supplicant_state_txt(wpa_s->wpa_state), 1035 wpa_supplicant_state_txt(state)); 1036 1037 if (state == WPA_COMPLETED && 1038 os_reltime_initialized(&wpa_s->roam_start)) { 1039 os_reltime_age(&wpa_s->roam_start, &wpa_s->roam_time); 1040 wpa_s->roam_start.sec = 0; 1041 wpa_s->roam_start.usec = 0; 1042 wpas_notify_auth_changed(wpa_s); 1043 wpas_notify_roam_time(wpa_s); 1044 wpas_notify_roam_complete(wpa_s); 1045 } else if (state == WPA_DISCONNECTED && 1046 os_reltime_initialized(&wpa_s->roam_start)) { 1047 wpa_s->roam_start.sec = 0; 1048 wpa_s->roam_start.usec = 0; 1049 wpa_s->roam_time.sec = 0; 1050 wpa_s->roam_time.usec = 0; 1051 wpas_notify_roam_complete(wpa_s); 1052 } 1053 1054 if (state == WPA_INTERFACE_DISABLED) { 1055 /* Assure normal scan when interface is restored */ 1056 wpa_s->normal_scans = 0; 1057 } 1058 1059 if (state == WPA_COMPLETED) { 1060 wpas_connect_work_done(wpa_s); 1061 /* Reinitialize normal_scan counter */ 1062 wpa_s->normal_scans = 0; 1063 } 1064 1065 #ifdef CONFIG_P2P 1066 /* 1067 * P2PS client has to reply to Probe Request frames received on the 1068 * group operating channel. Enable Probe Request frame reporting for 1069 * P2P connected client in case p2p_cli_probe configuration property is 1070 * set to 1. 1071 */ 1072 if (wpa_s->conf->p2p_cli_probe && wpa_s->current_ssid && 1073 wpa_s->current_ssid->mode == WPAS_MODE_INFRA && 1074 wpa_s->current_ssid->p2p_group) { 1075 if (state == WPA_COMPLETED && !wpa_s->p2p_cli_probe) { 1076 wpa_dbg(wpa_s, MSG_DEBUG, 1077 "P2P: Enable CLI Probe Request RX reporting"); 1078 wpa_s->p2p_cli_probe = 1079 wpa_drv_probe_req_report(wpa_s, 1) >= 0; 1080 } else if (state != WPA_COMPLETED && wpa_s->p2p_cli_probe) { 1081 wpa_dbg(wpa_s, MSG_DEBUG, 1082 "P2P: Disable CLI Probe Request RX reporting"); 1083 wpa_s->p2p_cli_probe = 0; 1084 wpa_drv_probe_req_report(wpa_s, 0); 1085 } 1086 } 1087 #endif /* CONFIG_P2P */ 1088 1089 if (state != WPA_SCANNING) 1090 wpa_supplicant_notify_scanning(wpa_s, 0); 1091 1092 if (state == WPA_COMPLETED && wpa_s->new_connection) { 1093 struct wpa_ssid *ssid = wpa_s->current_ssid; 1094 int fils_hlp_sent = 0; 1095 char mld_addr[50]; 1096 1097 mld_addr[0] = '\0'; 1098 if (wpa_s->valid_links) 1099 os_snprintf(mld_addr, sizeof(mld_addr), 1100 " ap_mld_addr=" MACSTR, 1101 MAC2STR(wpa_s->ap_mld_addr)); 1102 1103 #ifdef CONFIG_SME 1104 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 1105 wpa_auth_alg_fils(wpa_s->sme.auth_alg)) 1106 fils_hlp_sent = 1; 1107 #endif /* CONFIG_SME */ 1108 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 1109 wpa_auth_alg_fils(wpa_s->auth_alg)) 1110 fils_hlp_sent = 1; 1111 1112 #if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG) 1113 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to " 1114 MACSTR " completed [id=%d id_str=%s%s]%s", 1115 MAC2STR(wpa_s->bssid), 1116 ssid ? ssid->id : -1, 1117 ssid && ssid->id_str ? ssid->id_str : "", 1118 fils_hlp_sent ? " FILS_HLP_SENT" : "", mld_addr); 1119 #endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */ 1120 wpas_clear_temp_disabled(wpa_s, ssid, 1); 1121 wpa_s->consecutive_conn_failures = 0; 1122 wpa_s->new_connection = 0; 1123 wpa_drv_set_operstate(wpa_s, 1); 1124 #ifndef IEEE8021X_EAPOL 1125 wpa_drv_set_supp_port(wpa_s, 1); 1126 #endif /* IEEE8021X_EAPOL */ 1127 wpa_s->after_wps = 0; 1128 wpa_s->known_wps_freq = 0; 1129 wpas_p2p_completed(wpa_s); 1130 1131 sme_sched_obss_scan(wpa_s, 1); 1132 1133 #if defined(CONFIG_FILS) && defined(IEEE8021X_EAPOL) 1134 if (!fils_hlp_sent && ssid && ssid->eap.erp) 1135 update_fils_connect_params = true; 1136 #endif /* CONFIG_FILS && IEEE8021X_EAPOL */ 1137 #ifdef CONFIG_OWE 1138 if (ssid && (ssid->key_mgmt & WPA_KEY_MGMT_OWE)) 1139 wpas_update_owe_connect_params(wpa_s); 1140 #endif /* CONFIG_OWE */ 1141 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING || 1142 state == WPA_ASSOCIATED) { 1143 wpa_s->new_connection = 1; 1144 wpa_drv_set_operstate(wpa_s, 0); 1145 #ifndef IEEE8021X_EAPOL 1146 wpa_drv_set_supp_port(wpa_s, 0); 1147 #endif /* IEEE8021X_EAPOL */ 1148 sme_sched_obss_scan(wpa_s, 0); 1149 } 1150 wpa_s->wpa_state = state; 1151 1152 #ifdef CONFIG_BGSCAN 1153 if (state == WPA_COMPLETED && wpa_s->current_ssid != wpa_s->bgscan_ssid) 1154 wpa_supplicant_reset_bgscan(wpa_s); 1155 else if (state < WPA_ASSOCIATED) 1156 wpa_supplicant_stop_bgscan(wpa_s); 1157 #endif /* CONFIG_BGSCAN */ 1158 1159 if (state > WPA_SCANNING) 1160 wpa_supplicant_stop_autoscan(wpa_s); 1161 1162 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE) 1163 wpa_supplicant_start_autoscan(wpa_s); 1164 1165 if (state == WPA_COMPLETED || state == WPA_INTERFACE_DISABLED || 1166 state == WPA_INACTIVE) 1167 wnm_btm_reset(wpa_s); 1168 1169 #ifndef CONFIG_NO_WMM_AC 1170 if (old_state >= WPA_ASSOCIATED && wpa_s->wpa_state < WPA_ASSOCIATED) 1171 wmm_ac_notify_disassoc(wpa_s); 1172 #endif /* CONFIG_NO_WMM_AC */ 1173 1174 if (wpa_s->wpa_state != old_state) { 1175 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state); 1176 1177 /* 1178 * Notify the P2P Device interface about a state change in one 1179 * of the interfaces. 1180 */ 1181 wpas_p2p_indicate_state_change(wpa_s); 1182 1183 if (wpa_s->wpa_state == WPA_COMPLETED || 1184 old_state == WPA_COMPLETED) 1185 wpas_notify_auth_changed(wpa_s); 1186 #ifdef CONFIG_DPP2 1187 if (wpa_s->wpa_state == WPA_COMPLETED) 1188 wpas_dpp_connected(wpa_s); 1189 #endif /* CONFIG_DPP2 */ 1190 1191 if (wpa_s->wpa_state == WPA_COMPLETED && 1192 wpa_s->bigtk_set && !wpa_s->ssid_verified) 1193 wpas_verify_ssid_beacon_prot(wpa_s); 1194 } 1195 #if defined(CONFIG_FILS) && defined(IEEE8021X_EAPOL) 1196 if (update_fils_connect_params) 1197 wpas_update_fils_connect_params(wpa_s); 1198 #endif /* CONFIG_FILS && IEEE8021X_EAPOL */ 1199 } 1200 1201 1202 void wpa_supplicant_terminate_proc(struct wpa_global *global) 1203 { 1204 int pending = 0; 1205 #ifdef CONFIG_WPS 1206 struct wpa_supplicant *wpa_s = global->ifaces; 1207 while (wpa_s) { 1208 struct wpa_supplicant *next = wpa_s->next; 1209 if (wpas_wps_terminate_pending(wpa_s) == 1) 1210 pending = 1; 1211 #ifdef CONFIG_P2P 1212 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE || 1213 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group)) 1214 wpas_p2p_disconnect(wpa_s); 1215 #endif /* CONFIG_P2P */ 1216 wpa_s = next; 1217 } 1218 #endif /* CONFIG_WPS */ 1219 if (pending) 1220 return; 1221 eloop_terminate(); 1222 } 1223 1224 1225 static void wpa_supplicant_terminate(int sig, void *signal_ctx) 1226 { 1227 struct wpa_global *global = signal_ctx; 1228 wpa_supplicant_terminate_proc(global); 1229 } 1230 1231 1232 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s) 1233 { 1234 enum wpa_states old_state = wpa_s->wpa_state; 1235 enum wpa_states new_state; 1236 1237 if (old_state == WPA_SCANNING) 1238 new_state = WPA_SCANNING; 1239 else 1240 new_state = WPA_DISCONNECTED; 1241 1242 wpa_s->pairwise_cipher = 0; 1243 wpa_s->group_cipher = 0; 1244 wpa_s->mgmt_group_cipher = 0; 1245 wpa_s->key_mgmt = 0; 1246 wpa_s->allowed_key_mgmts = 0; 1247 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED) 1248 wpa_supplicant_set_state(wpa_s, new_state); 1249 1250 if (wpa_s->wpa_state != old_state) 1251 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state); 1252 } 1253 1254 1255 /** 1256 * wpa_supplicant_reload_configuration - Reload configuration data 1257 * @wpa_s: Pointer to wpa_supplicant data 1258 * Returns: 0 on success or -1 if configuration parsing failed 1259 * 1260 * This function can be used to request that the configuration data is reloaded 1261 * (e.g., after configuration file change). This function is reloading 1262 * configuration only for one interface, so this may need to be called multiple 1263 * times if %wpa_supplicant is controlling multiple interfaces and all 1264 * interfaces need reconfiguration. 1265 */ 1266 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s) 1267 { 1268 struct wpa_config *conf; 1269 int reconf_ctrl; 1270 int old_ap_scan; 1271 1272 if (wpa_s->confname == NULL) 1273 return -1; 1274 conf = wpa_config_read(wpa_s->confname, NULL, false); 1275 if (conf == NULL) { 1276 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration " 1277 "file '%s' - exiting", wpa_s->confname); 1278 return -1; 1279 } 1280 if (wpa_s->confanother && 1281 !wpa_config_read(wpa_s->confanother, conf, true)) { 1282 wpa_msg(wpa_s, MSG_ERROR, 1283 "Failed to parse the configuration file '%s' - exiting", 1284 wpa_s->confanother); 1285 return -1; 1286 } 1287 1288 conf->changed_parameters = (unsigned int) -1; 1289 1290 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface 1291 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface && 1292 os_strcmp(conf->ctrl_interface, 1293 wpa_s->conf->ctrl_interface) != 0); 1294 1295 if (reconf_ctrl) { 1296 wpa_supplicant_ctrl_iface_deinit(wpa_s, wpa_s->ctrl_iface); 1297 wpa_s->ctrl_iface = NULL; 1298 } 1299 1300 eapol_sm_invalidate_cached_session(wpa_s->eapol); 1301 if (wpa_s->current_ssid) { 1302 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 1303 wpa_s->own_disconnect_req = 1; 1304 wpa_supplicant_deauthenticate(wpa_s, 1305 WLAN_REASON_DEAUTH_LEAVING); 1306 } 1307 1308 /* 1309 * TODO: should notify EAPOL SM about changes in opensc_engine_path, 1310 * pkcs11_engine_path, pkcs11_module_path, openssl_ciphers. 1311 */ 1312 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || 1313 wpa_s->key_mgmt == WPA_KEY_MGMT_OWE || 1314 wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) { 1315 /* 1316 * Clear forced success to clear EAP state for next 1317 * authentication. 1318 */ 1319 eapol_sm_notify_eap_success(wpa_s->eapol, false); 1320 } 1321 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 1322 wpa_sm_set_config(wpa_s->wpa, NULL); 1323 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL); 1324 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth); 1325 rsn_preauth_deinit(wpa_s->wpa); 1326 1327 old_ap_scan = wpa_s->conf->ap_scan; 1328 wpa_config_free(wpa_s->conf); 1329 wpa_s->conf = conf; 1330 if (old_ap_scan != wpa_s->conf->ap_scan) 1331 wpas_notify_ap_scan_changed(wpa_s); 1332 1333 if (reconf_ctrl) 1334 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s); 1335 1336 wpa_supplicant_update_config(wpa_s); 1337 1338 wpa_supplicant_clear_status(wpa_s); 1339 if (wpa_supplicant_enabled_networks(wpa_s)) { 1340 wpa_s->reassociate = 1; 1341 wpa_supplicant_req_scan(wpa_s, 0, 0); 1342 } 1343 wpa_bssid_ignore_clear(wpa_s); 1344 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed"); 1345 return 0; 1346 } 1347 1348 1349 static void wpa_supplicant_reconfig(int sig, void *signal_ctx) 1350 { 1351 struct wpa_global *global = signal_ctx; 1352 struct wpa_supplicant *wpa_s; 1353 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 1354 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring", 1355 sig); 1356 if (wpa_supplicant_reload_configuration(wpa_s) < 0) { 1357 wpa_supplicant_terminate_proc(global); 1358 } 1359 } 1360 1361 if (wpa_debug_reopen_file() < 0) { 1362 /* Ignore errors since we cannot really do much to fix this */ 1363 wpa_printf(MSG_DEBUG, "Could not reopen debug log file"); 1364 } 1365 } 1366 1367 1368 static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s, 1369 struct wpa_ssid *ssid, 1370 struct wpa_ie_data *ie) 1371 { 1372 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie); 1373 if (ret) { 1374 if (ret == -2) { 1375 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE " 1376 "from association info"); 1377 } 1378 return -1; 1379 } 1380 1381 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set " 1382 "cipher suites"); 1383 if (!(ie->group_cipher & ssid->group_cipher)) { 1384 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group " 1385 "cipher 0x%x (mask 0x%x) - reject", 1386 ie->group_cipher, ssid->group_cipher); 1387 return -1; 1388 } 1389 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) { 1390 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise " 1391 "cipher 0x%x (mask 0x%x) - reject", 1392 ie->pairwise_cipher, ssid->pairwise_cipher); 1393 return -1; 1394 } 1395 if (!(ie->key_mgmt & ssid->key_mgmt)) { 1396 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key " 1397 "management 0x%x (mask 0x%x) - reject", 1398 ie->key_mgmt, ssid->key_mgmt); 1399 return -1; 1400 } 1401 1402 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) && 1403 wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED) { 1404 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP " 1405 "that does not support management frame protection - " 1406 "reject"); 1407 return -1; 1408 } 1409 1410 return 0; 1411 } 1412 1413 1414 static int matching_ciphers(struct wpa_ssid *ssid, struct wpa_ie_data *ie, 1415 int freq) 1416 { 1417 if (!ie->has_group) 1418 ie->group_cipher = wpa_default_rsn_cipher(freq); 1419 if (!ie->has_pairwise) 1420 ie->pairwise_cipher = wpa_default_rsn_cipher(freq); 1421 return (ie->group_cipher & ssid->group_cipher) && 1422 (ie->pairwise_cipher & ssid->pairwise_cipher); 1423 } 1424 1425 1426 void wpas_set_mgmt_group_cipher(struct wpa_supplicant *wpa_s, 1427 struct wpa_ssid *ssid, struct wpa_ie_data *ie) 1428 { 1429 int sel; 1430 1431 sel = ie->mgmt_group_cipher; 1432 if (ssid->group_mgmt_cipher) 1433 sel &= ssid->group_mgmt_cipher; 1434 if (wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION || 1435 !(ie->capabilities & WPA_CAPABILITY_MFPC)) 1436 sel = 0; 1437 wpa_dbg(wpa_s, MSG_DEBUG, 1438 "WPA: AP mgmt_group_cipher 0x%x network profile mgmt_group_cipher 0x%x; available mgmt_group_cipher 0x%x", 1439 ie->mgmt_group_cipher, ssid->group_mgmt_cipher, sel); 1440 if (sel & WPA_CIPHER_AES_128_CMAC) { 1441 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC; 1442 wpa_dbg(wpa_s, MSG_DEBUG, 1443 "WPA: using MGMT group cipher AES-128-CMAC"); 1444 } else if (sel & WPA_CIPHER_BIP_GMAC_128) { 1445 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128; 1446 wpa_dbg(wpa_s, MSG_DEBUG, 1447 "WPA: using MGMT group cipher BIP-GMAC-128"); 1448 } else if (sel & WPA_CIPHER_BIP_GMAC_256) { 1449 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256; 1450 wpa_dbg(wpa_s, MSG_DEBUG, 1451 "WPA: using MGMT group cipher BIP-GMAC-256"); 1452 } else if (sel & WPA_CIPHER_BIP_CMAC_256) { 1453 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256; 1454 wpa_dbg(wpa_s, MSG_DEBUG, 1455 "WPA: using MGMT group cipher BIP-CMAC-256"); 1456 } else { 1457 wpa_s->mgmt_group_cipher = 0; 1458 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher"); 1459 } 1460 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP, 1461 wpa_s->mgmt_group_cipher); 1462 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, 1463 wpas_get_ssid_pmf(wpa_s, ssid)); 1464 } 1465 1466 /** 1467 * wpa_supplicant_get_psk - Get PSK from config or external database 1468 * @wpa_s: Pointer to wpa_supplicant data 1469 * @bss: Scan results for the selected BSS, or %NULL if not available 1470 * @ssid: Configuration data for the selected network 1471 * @psk: Buffer for the PSK 1472 * Returns: 0 on success or -1 if configuration parsing failed 1473 * 1474 * This function obtains the PSK for a network, either included inline in the 1475 * config or retrieved from an external database. 1476 */ 1477 static int wpa_supplicant_get_psk(struct wpa_supplicant *wpa_s, 1478 struct wpa_bss *bss, struct wpa_ssid *ssid, 1479 u8 *psk) 1480 { 1481 if (ssid->psk_set) { 1482 wpa_hexdump_key(MSG_MSGDUMP, "PSK (set in config)", 1483 ssid->psk, PMK_LEN); 1484 os_memcpy(psk, ssid->psk, PMK_LEN); 1485 return 0; 1486 } 1487 1488 #ifndef CONFIG_NO_PBKDF2 1489 if (bss && ssid->bssid_set && ssid->ssid_len == 0 && ssid->passphrase) { 1490 if (pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len, 1491 4096, psk, PMK_LEN) != 0) { 1492 wpa_msg(wpa_s, MSG_WARNING, "Error in pbkdf2_sha1()"); 1493 return -1; 1494 } 1495 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)", 1496 psk, PMK_LEN); 1497 return 0; 1498 } 1499 #endif /* CONFIG_NO_PBKDF2 */ 1500 1501 #ifdef CONFIG_EXT_PASSWORD 1502 if (ssid->ext_psk) { 1503 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw, 1504 ssid->ext_psk); 1505 char pw_str[64 + 1]; 1506 1507 if (!pw) { 1508 wpa_msg(wpa_s, MSG_INFO, 1509 "EXT PW: No PSK found from external storage"); 1510 return -1; 1511 } 1512 1513 if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) { 1514 wpa_msg(wpa_s, MSG_INFO, 1515 "EXT PW: Unexpected PSK length %d in external storage", 1516 (int) wpabuf_len(pw)); 1517 ext_password_free(pw); 1518 return -1; 1519 } 1520 1521 os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw)); 1522 pw_str[wpabuf_len(pw)] = '\0'; 1523 1524 #ifndef CONFIG_NO_PBKDF2 1525 if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss) 1526 { 1527 if (pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len, 1528 4096, psk, PMK_LEN) != 0) { 1529 wpa_msg(wpa_s, MSG_WARNING, 1530 "Error in pbkdf2_sha1()"); 1531 forced_memzero(pw_str, sizeof(pw_str)); 1532 ext_password_free(pw); 1533 return -1; 1534 } 1535 wpa_hexdump_key(MSG_MSGDUMP, 1536 "PSK (from external passphrase)", 1537 psk, PMK_LEN); 1538 } else 1539 #endif /* CONFIG_NO_PBKDF2 */ 1540 if (wpabuf_len(pw) == 2 * PMK_LEN) { 1541 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) { 1542 wpa_msg(wpa_s, MSG_INFO, 1543 "EXT PW: Invalid PSK hex string"); 1544 forced_memzero(pw_str, sizeof(pw_str)); 1545 ext_password_free(pw); 1546 return -1; 1547 } 1548 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from external PSK)", 1549 psk, PMK_LEN); 1550 } else { 1551 wpa_msg(wpa_s, MSG_INFO, 1552 "EXT PW: No suitable PSK available"); 1553 forced_memzero(pw_str, sizeof(pw_str)); 1554 ext_password_free(pw); 1555 return -1; 1556 } 1557 1558 forced_memzero(pw_str, sizeof(pw_str)); 1559 ext_password_free(pw); 1560 1561 return 0; 1562 } 1563 #endif /* CONFIG_EXT_PASSWORD */ 1564 1565 return -1; 1566 } 1567 1568 1569 static void wpas_update_allowed_key_mgmt(struct wpa_supplicant *wpa_s, 1570 struct wpa_ssid *ssid) 1571 { 1572 int akm_count = wpa_s->max_num_akms; 1573 u8 capab = 0; 1574 1575 if (akm_count < 2) 1576 return; 1577 1578 akm_count--; 1579 wpa_s->allowed_key_mgmts = 0; 1580 switch (wpa_s->key_mgmt) { 1581 case WPA_KEY_MGMT_PSK: 1582 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE) { 1583 akm_count--; 1584 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE; 1585 } 1586 if (!akm_count) 1587 break; 1588 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE_EXT_KEY) { 1589 akm_count--; 1590 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE_EXT_KEY; 1591 } 1592 if (!akm_count) 1593 break; 1594 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK_SHA256) 1595 wpa_s->allowed_key_mgmts |= 1596 WPA_KEY_MGMT_PSK_SHA256; 1597 break; 1598 case WPA_KEY_MGMT_PSK_SHA256: 1599 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE) { 1600 akm_count--; 1601 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE; 1602 } 1603 if (!akm_count) 1604 break; 1605 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE_EXT_KEY) { 1606 akm_count--; 1607 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE_EXT_KEY; 1608 } 1609 if (!akm_count) 1610 break; 1611 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) 1612 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_PSK; 1613 break; 1614 case WPA_KEY_MGMT_SAE: 1615 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) { 1616 akm_count--; 1617 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_PSK; 1618 } 1619 if (!akm_count) 1620 break; 1621 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE_EXT_KEY) { 1622 akm_count--; 1623 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE_EXT_KEY; 1624 } 1625 if (!akm_count) 1626 break; 1627 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK_SHA256) 1628 wpa_s->allowed_key_mgmts |= 1629 WPA_KEY_MGMT_PSK_SHA256; 1630 break; 1631 case WPA_KEY_MGMT_SAE_EXT_KEY: 1632 if (ssid->key_mgmt & WPA_KEY_MGMT_SAE) { 1633 akm_count--; 1634 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_SAE; 1635 } 1636 if (!akm_count) 1637 break; 1638 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK) { 1639 akm_count--; 1640 wpa_s->allowed_key_mgmts |= WPA_KEY_MGMT_PSK; 1641 } 1642 if (!akm_count) 1643 break; 1644 if (ssid->key_mgmt & WPA_KEY_MGMT_PSK_SHA256) 1645 wpa_s->allowed_key_mgmts |= 1646 WPA_KEY_MGMT_PSK_SHA256; 1647 break; 1648 default: 1649 return; 1650 } 1651 1652 if (wpa_s->conf->sae_pwe != SAE_PWE_HUNT_AND_PECK && 1653 wpa_s->conf->sae_pwe != SAE_PWE_FORCE_HUNT_AND_PECK) 1654 capab |= BIT(WLAN_RSNX_CAPAB_SAE_H2E); 1655 #ifdef CONFIG_SAE_PK 1656 if (ssid->sae_pk) 1657 capab |= BIT(WLAN_RSNX_CAPAB_SAE_PK); 1658 #endif /* CONFIG_SAE_PK */ 1659 1660 if (!((wpa_s->allowed_key_mgmts & 1661 (WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_SAE_EXT_KEY)) && capab)) 1662 return; 1663 1664 if (!wpa_s->rsnxe_len) { 1665 wpa_s->rsnxe_len = 3; 1666 wpa_s->rsnxe[0] = WLAN_EID_RSNX; 1667 wpa_s->rsnxe[1] = 1; 1668 wpa_s->rsnxe[2] = 0; 1669 } 1670 1671 wpa_s->rsnxe[2] |= capab; 1672 } 1673 1674 1675 /** 1676 * wpa_supplicant_set_suites - Set authentication and encryption parameters 1677 * @wpa_s: Pointer to wpa_supplicant data 1678 * @bss: Scan results for the selected BSS, or %NULL if not available 1679 * @ssid: Configuration data for the selected network 1680 * @wpa_ie: Buffer for the WPA/RSN IE 1681 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the 1682 * used buffer length in case the functions returns success. 1683 * @skip_default_rsne: Whether to skip setting of the default RSNE/RSNXE 1684 * Returns: 0 on success or -1 on failure 1685 * 1686 * This function is used to configure authentication and encryption parameters 1687 * based on the network configuration and scan result for the selected BSS (if 1688 * available). 1689 */ 1690 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s, 1691 struct wpa_bss *bss, struct wpa_ssid *ssid, 1692 u8 *wpa_ie, size_t *wpa_ie_len, 1693 bool skip_default_rsne) 1694 { 1695 struct wpa_ie_data ie; 1696 int sel, proto; 1697 enum sae_pwe sae_pwe; 1698 const u8 *bss_wpa, *bss_rsn, *bss_rsnx, *bss_osen; 1699 bool wmm; 1700 1701 if (bss) { 1702 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE); 1703 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN); 1704 bss_rsnx = wpa_bss_get_ie(bss, WLAN_EID_RSNX); 1705 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE); 1706 } else { 1707 bss_wpa = bss_rsn = bss_rsnx = bss_osen = NULL; 1708 } 1709 1710 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) && 1711 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 && 1712 matching_ciphers(ssid, &ie, bss->freq) && 1713 (ie.key_mgmt & ssid->key_mgmt)) { 1714 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0"); 1715 proto = WPA_PROTO_RSN; 1716 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) && 1717 wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie) == 0 && 1718 (ie.group_cipher & ssid->group_cipher) && 1719 (ie.pairwise_cipher & ssid->pairwise_cipher) && 1720 (ie.key_mgmt & ssid->key_mgmt)) { 1721 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0"); 1722 proto = WPA_PROTO_WPA; 1723 #ifdef CONFIG_HS20 1724 } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN) && 1725 wpa_parse_wpa_ie(bss_osen, 2 + bss_osen[1], &ie) == 0 && 1726 (ie.group_cipher & ssid->group_cipher) && 1727 (ie.pairwise_cipher & ssid->pairwise_cipher) && 1728 (ie.key_mgmt & ssid->key_mgmt)) { 1729 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN"); 1730 proto = WPA_PROTO_OSEN; 1731 } else if (bss_rsn && (ssid->proto & WPA_PROTO_OSEN) && 1732 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 && 1733 (ie.group_cipher & ssid->group_cipher) && 1734 (ie.pairwise_cipher & ssid->pairwise_cipher) && 1735 (ie.key_mgmt & ssid->key_mgmt)) { 1736 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using OSEN (within RSN)"); 1737 proto = WPA_PROTO_RSN; 1738 #endif /* CONFIG_HS20 */ 1739 } else if (bss) { 1740 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN"); 1741 wpa_dbg(wpa_s, MSG_DEBUG, 1742 "WPA: ssid proto=0x%x pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x", 1743 ssid->proto, ssid->pairwise_cipher, ssid->group_cipher, 1744 ssid->key_mgmt); 1745 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: BSS " MACSTR " ssid='%s'%s%s%s", 1746 MAC2STR(bss->bssid), 1747 wpa_ssid_txt(bss->ssid, bss->ssid_len), 1748 bss_wpa ? " WPA" : "", 1749 bss_rsn ? " RSN" : "", 1750 bss_osen ? " OSEN" : ""); 1751 if (bss_rsn) { 1752 wpa_hexdump(MSG_DEBUG, "RSN", bss_rsn, 2 + bss_rsn[1]); 1753 if (wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie)) { 1754 wpa_dbg(wpa_s, MSG_DEBUG, 1755 "Could not parse RSN element"); 1756 } else { 1757 wpa_dbg(wpa_s, MSG_DEBUG, 1758 "RSN: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x", 1759 ie.pairwise_cipher, ie.group_cipher, 1760 ie.key_mgmt); 1761 } 1762 } 1763 if (bss_wpa) { 1764 wpa_hexdump(MSG_DEBUG, "WPA", bss_wpa, 2 + bss_wpa[1]); 1765 if (wpa_parse_wpa_ie(bss_wpa, 2 + bss_wpa[1], &ie)) { 1766 wpa_dbg(wpa_s, MSG_DEBUG, 1767 "Could not parse WPA element"); 1768 } else { 1769 wpa_dbg(wpa_s, MSG_DEBUG, 1770 "WPA: pairwise_cipher=0x%x group_cipher=0x%x key_mgmt=0x%x", 1771 ie.pairwise_cipher, ie.group_cipher, 1772 ie.key_mgmt); 1773 } 1774 } 1775 return -1; 1776 } else { 1777 if (ssid->proto & WPA_PROTO_OSEN) 1778 proto = WPA_PROTO_OSEN; 1779 else if (ssid->proto & WPA_PROTO_RSN) 1780 proto = WPA_PROTO_RSN; 1781 else 1782 proto = WPA_PROTO_WPA; 1783 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) { 1784 os_memset(&ie, 0, sizeof(ie)); 1785 ie.group_cipher = ssid->group_cipher; 1786 ie.pairwise_cipher = ssid->pairwise_cipher; 1787 ie.key_mgmt = ssid->key_mgmt; 1788 ie.mgmt_group_cipher = 0; 1789 if (ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION) { 1790 if (ssid->group_mgmt_cipher & 1791 WPA_CIPHER_BIP_GMAC_256) 1792 ie.mgmt_group_cipher = 1793 WPA_CIPHER_BIP_GMAC_256; 1794 else if (ssid->group_mgmt_cipher & 1795 WPA_CIPHER_BIP_CMAC_256) 1796 ie.mgmt_group_cipher = 1797 WPA_CIPHER_BIP_CMAC_256; 1798 else if (ssid->group_mgmt_cipher & 1799 WPA_CIPHER_BIP_GMAC_128) 1800 ie.mgmt_group_cipher = 1801 WPA_CIPHER_BIP_GMAC_128; 1802 else 1803 ie.mgmt_group_cipher = 1804 WPA_CIPHER_AES_128_CMAC; 1805 } 1806 #ifdef CONFIG_OWE 1807 if ((ssid->key_mgmt & WPA_KEY_MGMT_OWE) && 1808 !ssid->owe_only && 1809 !bss_wpa && !bss_rsn && !bss_osen) { 1810 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 1811 wpa_s->wpa_proto = 0; 1812 *wpa_ie_len = 0; 1813 return 0; 1814 } 1815 #endif /* CONFIG_OWE */ 1816 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites " 1817 "based on configuration"); 1818 } else 1819 proto = ie.proto; 1820 } 1821 1822 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d " 1823 "pairwise %d key_mgmt %d proto %d", 1824 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto); 1825 if (ssid->ieee80211w) { 1826 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d", 1827 ie.mgmt_group_cipher); 1828 } 1829 1830 wpa_s->wpa_proto = proto; 1831 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto); 1832 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 1833 !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN))); 1834 1835 if (bss || !wpa_s->ap_ies_from_associnfo) { 1836 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa, 1837 bss_wpa ? 2 + bss_wpa[1] : 0) || 1838 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn, 1839 bss_rsn ? 2 + bss_rsn[1] : 0) || 1840 wpa_sm_set_ap_rsnxe(wpa_s->wpa, bss_rsnx, 1841 bss_rsnx ? 2 + bss_rsnx[1] : 0)) 1842 return -1; 1843 } 1844 1845 #ifdef CONFIG_NO_WPA 1846 wpa_s->group_cipher = WPA_CIPHER_NONE; 1847 wpa_s->pairwise_cipher = WPA_CIPHER_NONE; 1848 #else /* CONFIG_NO_WPA */ 1849 sel = ie.group_cipher & ssid->group_cipher; 1850 wpa_dbg(wpa_s, MSG_DEBUG, 1851 "WPA: AP group 0x%x network profile group 0x%x; available group 0x%x", 1852 ie.group_cipher, ssid->group_cipher, sel); 1853 wpa_s->group_cipher = wpa_pick_group_cipher(sel); 1854 if (wpa_s->group_cipher < 0) { 1855 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group " 1856 "cipher"); 1857 return -1; 1858 } 1859 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s", 1860 wpa_cipher_txt(wpa_s->group_cipher)); 1861 1862 sel = ie.pairwise_cipher & ssid->pairwise_cipher; 1863 wpa_dbg(wpa_s, MSG_DEBUG, 1864 "WPA: AP pairwise 0x%x network profile pairwise 0x%x; available pairwise 0x%x", 1865 ie.pairwise_cipher, ssid->pairwise_cipher, sel); 1866 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1); 1867 if (wpa_s->pairwise_cipher < 0) { 1868 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise " 1869 "cipher"); 1870 return -1; 1871 } 1872 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s", 1873 wpa_cipher_txt(wpa_s->pairwise_cipher)); 1874 #endif /* CONFIG_NO_WPA */ 1875 1876 sel = ie.key_mgmt & ssid->key_mgmt; 1877 #ifdef CONFIG_SAE 1878 if ((!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE) && 1879 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA)) || 1880 wpas_is_sae_avoided(wpa_s, ssid, &ie)) 1881 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_SAE_EXT_KEY | 1882 WPA_KEY_MGMT_FT_SAE | WPA_KEY_MGMT_FT_SAE_EXT_KEY); 1883 #endif /* CONFIG_SAE */ 1884 #ifdef CONFIG_IEEE80211R 1885 if (!(wpa_s->drv_flags & (WPA_DRIVER_FLAGS_SME | 1886 WPA_DRIVER_FLAGS_UPDATE_FT_IES))) 1887 sel &= ~WPA_KEY_MGMT_FT; 1888 #endif /* CONFIG_IEEE80211R */ 1889 wpa_dbg(wpa_s, MSG_DEBUG, 1890 "WPA: AP key_mgmt 0x%x network profile key_mgmt 0x%x; available key_mgmt 0x%x", 1891 ie.key_mgmt, ssid->key_mgmt, sel); 1892 if (0) { 1893 #ifdef CONFIG_IEEE80211R 1894 #ifdef CONFIG_SHA384 1895 } else if ((sel & WPA_KEY_MGMT_FT_IEEE8021X_SHA384) && 1896 os_strcmp(wpa_supplicant_get_eap_mode(wpa_s), "LEAP") != 0) { 1897 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X_SHA384; 1898 wpa_dbg(wpa_s, MSG_DEBUG, 1899 "WPA: using KEY_MGMT FT/802.1X-SHA384"); 1900 if (!ssid->ft_eap_pmksa_caching && 1901 pmksa_cache_get_current(wpa_s->wpa)) { 1902 /* PMKSA caching with FT may have interoperability 1903 * issues, so disable that case by default for now. */ 1904 wpa_dbg(wpa_s, MSG_DEBUG, 1905 "WPA: Disable PMKSA caching for FT/802.1X connection"); 1906 pmksa_cache_clear_current(wpa_s->wpa); 1907 } 1908 #endif /* CONFIG_SHA384 */ 1909 #endif /* CONFIG_IEEE80211R */ 1910 #ifdef CONFIG_SUITEB192 1911 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) { 1912 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B_192; 1913 wpa_dbg(wpa_s, MSG_DEBUG, 1914 "WPA: using KEY_MGMT 802.1X with Suite B (192-bit)"); 1915 #endif /* CONFIG_SUITEB192 */ 1916 #ifdef CONFIG_SUITEB 1917 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SUITE_B) { 1918 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SUITE_B; 1919 wpa_dbg(wpa_s, MSG_DEBUG, 1920 "WPA: using KEY_MGMT 802.1X with Suite B"); 1921 #endif /* CONFIG_SUITEB */ 1922 #ifdef CONFIG_SHA384 1923 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA384) { 1924 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA384; 1925 wpa_dbg(wpa_s, MSG_DEBUG, 1926 "WPA: using KEY_MGMT 802.1X with SHA384"); 1927 #endif /* CONFIG_SHA384 */ 1928 #ifdef CONFIG_FILS 1929 #ifdef CONFIG_IEEE80211R 1930 } else if (sel & WPA_KEY_MGMT_FT_FILS_SHA384) { 1931 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA384; 1932 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA384"); 1933 #endif /* CONFIG_IEEE80211R */ 1934 } else if (sel & WPA_KEY_MGMT_FILS_SHA384) { 1935 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA384; 1936 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA384"); 1937 #ifdef CONFIG_IEEE80211R 1938 } else if (sel & WPA_KEY_MGMT_FT_FILS_SHA256) { 1939 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_FILS_SHA256; 1940 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT-FILS-SHA256"); 1941 #endif /* CONFIG_IEEE80211R */ 1942 } else if (sel & WPA_KEY_MGMT_FILS_SHA256) { 1943 wpa_s->key_mgmt = WPA_KEY_MGMT_FILS_SHA256; 1944 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FILS-SHA256"); 1945 #endif /* CONFIG_FILS */ 1946 #ifdef CONFIG_IEEE80211R 1947 } else if ((sel & WPA_KEY_MGMT_FT_IEEE8021X) && 1948 os_strcmp(wpa_supplicant_get_eap_mode(wpa_s), "LEAP") != 0) { 1949 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X; 1950 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X"); 1951 if (!ssid->ft_eap_pmksa_caching && 1952 pmksa_cache_get_current(wpa_s->wpa)) { 1953 /* PMKSA caching with FT may have interoperability 1954 * issues, so disable that case by default for now. */ 1955 wpa_dbg(wpa_s, MSG_DEBUG, 1956 "WPA: Disable PMKSA caching for FT/802.1X connection"); 1957 pmksa_cache_clear_current(wpa_s->wpa); 1958 } 1959 #endif /* CONFIG_IEEE80211R */ 1960 #ifdef CONFIG_DPP 1961 } else if (sel & WPA_KEY_MGMT_DPP) { 1962 wpa_s->key_mgmt = WPA_KEY_MGMT_DPP; 1963 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT DPP"); 1964 #endif /* CONFIG_DPP */ 1965 #ifdef CONFIG_SAE 1966 } else if (sel & WPA_KEY_MGMT_FT_SAE_EXT_KEY) { 1967 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE_EXT_KEY; 1968 wpa_dbg(wpa_s, MSG_DEBUG, 1969 "RSN: using KEY_MGMT FT/SAE (ext key)"); 1970 } else if (sel & WPA_KEY_MGMT_SAE_EXT_KEY) { 1971 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE_EXT_KEY; 1972 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE (ext key)"); 1973 } else if (sel & WPA_KEY_MGMT_FT_SAE) { 1974 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE; 1975 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE"); 1976 } else if (sel & WPA_KEY_MGMT_SAE) { 1977 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE; 1978 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE"); 1979 #endif /* CONFIG_SAE */ 1980 #ifdef CONFIG_IEEE80211R 1981 } else if (sel & WPA_KEY_MGMT_FT_PSK) { 1982 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK; 1983 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK"); 1984 #endif /* CONFIG_IEEE80211R */ 1985 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) { 1986 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256; 1987 wpa_dbg(wpa_s, MSG_DEBUG, 1988 "WPA: using KEY_MGMT 802.1X with SHA256"); 1989 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) { 1990 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256; 1991 wpa_dbg(wpa_s, MSG_DEBUG, 1992 "WPA: using KEY_MGMT PSK with SHA256"); 1993 } else if (sel & WPA_KEY_MGMT_IEEE8021X) { 1994 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X; 1995 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X"); 1996 } else if (sel & WPA_KEY_MGMT_PSK) { 1997 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK; 1998 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK"); 1999 } else if (sel & WPA_KEY_MGMT_WPA_NONE) { 2000 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE; 2001 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE"); 2002 #ifdef CONFIG_HS20 2003 } else if (sel & WPA_KEY_MGMT_OSEN) { 2004 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN; 2005 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN"); 2006 #endif /* CONFIG_HS20 */ 2007 #ifdef CONFIG_OWE 2008 } else if (sel & WPA_KEY_MGMT_OWE) { 2009 wpa_s->key_mgmt = WPA_KEY_MGMT_OWE; 2010 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT OWE"); 2011 #endif /* CONFIG_OWE */ 2012 } else { 2013 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select " 2014 "authenticated key management type"); 2015 return -1; 2016 } 2017 2018 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt); 2019 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, 2020 wpa_s->pairwise_cipher); 2021 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher); 2022 2023 if (!(ie.capabilities & WPA_CAPABILITY_MFPC) && 2024 (wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED || 2025 (bss && is_6ghz_freq(bss->freq)))) { 2026 wpa_msg(wpa_s, MSG_INFO, 2027 "RSN: Management frame protection required but the selected AP does not enable it"); 2028 return -1; 2029 } 2030 2031 wpas_set_mgmt_group_cipher(wpa_s, ssid, &ie); 2032 #ifdef CONFIG_OCV 2033 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) || 2034 (wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OCV)) 2035 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCV, ssid->ocv); 2036 #endif /* CONFIG_OCV */ 2037 sae_pwe = wpa_s->conf->sae_pwe; 2038 if ((ssid->sae_password_id || 2039 wpa_key_mgmt_sae_ext_key(wpa_s->key_mgmt)) && 2040 sae_pwe != SAE_PWE_FORCE_HUNT_AND_PECK) 2041 sae_pwe = SAE_PWE_HASH_TO_ELEMENT; 2042 if (bss && is_6ghz_freq(bss->freq) && 2043 sae_pwe == SAE_PWE_HUNT_AND_PECK) { 2044 wpa_dbg(wpa_s, MSG_DEBUG, 2045 "RSN: Enable SAE hash-to-element mode for 6 GHz BSS"); 2046 sae_pwe = SAE_PWE_BOTH; 2047 } 2048 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SAE_PWE, sae_pwe); 2049 #ifdef CONFIG_SAE_PK 2050 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SAE_PK, 2051 wpa_key_mgmt_sae(ssid->key_mgmt) && 2052 ssid->sae_pk != SAE_PK_MODE_DISABLED && 2053 ((ssid->sae_password && 2054 sae_pk_valid_password(ssid->sae_password)) || 2055 (!ssid->sae_password && ssid->passphrase && 2056 sae_pk_valid_password(ssid->passphrase)))); 2057 #endif /* CONFIG_SAE_PK */ 2058 if (bss && is_6ghz_freq(bss->freq) && 2059 wpas_get_ssid_pmf(wpa_s, ssid) != MGMT_FRAME_PROTECTION_REQUIRED) { 2060 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Force MFPR=1 on 6 GHz"); 2061 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, 2062 MGMT_FRAME_PROTECTION_REQUIRED); 2063 } 2064 #ifdef CONFIG_TESTING_OPTIONS 2065 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_FT_RSNXE_USED, 2066 wpa_s->ft_rsnxe_used); 2067 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_EAPOL, 2068 wpa_s->oci_freq_override_eapol); 2069 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_EAPOL_G2, 2070 wpa_s->oci_freq_override_eapol_g2); 2071 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_FT_ASSOC, 2072 wpa_s->oci_freq_override_ft_assoc); 2073 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_OCI_FREQ_FILS_ASSOC, 2074 wpa_s->oci_freq_override_fils_assoc); 2075 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DISABLE_EAPOL_G2_TX, 2076 wpa_s->disable_eapol_g2_tx); 2077 #endif /* CONFIG_TESTING_OPTIONS */ 2078 2079 /* Extended Key ID is only supported in infrastructure BSS so far */ 2080 if (ssid->mode == WPAS_MODE_INFRA && wpa_s->conf->extended_key_id && 2081 (ssid->proto & WPA_PROTO_RSN) && 2082 ssid->pairwise_cipher & (WPA_CIPHER_CCMP | WPA_CIPHER_CCMP_256 | 2083 WPA_CIPHER_GCMP | WPA_CIPHER_GCMP_256) && 2084 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_EXTENDED_KEY_ID)) { 2085 int use_ext_key_id = 0; 2086 2087 wpa_msg(wpa_s, MSG_DEBUG, 2088 "WPA: Enable Extended Key ID support"); 2089 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_EXT_KEY_ID, 2090 wpa_s->conf->extended_key_id); 2091 if (bss_rsn && 2092 wpa_s->conf->extended_key_id && 2093 wpa_s->pairwise_cipher != WPA_CIPHER_TKIP && 2094 (ie.capabilities & WPA_CAPABILITY_EXT_KEY_ID_FOR_UNICAST)) 2095 use_ext_key_id = 1; 2096 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_USE_EXT_KEY_ID, 2097 use_ext_key_id); 2098 } else { 2099 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_EXT_KEY_ID, 0); 2100 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_USE_EXT_KEY_ID, 0); 2101 } 2102 2103 /* Mark WMM enabled for any HT/VHT/HE/EHT association to get more 2104 * appropriate advertisement of the supported number of PTKSA receive 2105 * counters. In theory, this could be based on a driver capability, but 2106 * in practice all cases using WMM support at least eight replay 2107 * counters, so use a hardcoded value for now since there is no explicit 2108 * driver capability indication for this. 2109 * 2110 * In addition, claim WMM to be enabled if the AP supports it since it 2111 * is far more likely for any current device to support WMM. */ 2112 wmm = wpa_s->connection_set && 2113 (wpa_s->connection_ht || wpa_s->connection_vht || 2114 wpa_s->connection_he || wpa_s->connection_eht); 2115 if (!wmm && bss) 2116 wmm = !!wpa_bss_get_vendor_ie(bss, WMM_IE_VENDOR_TYPE); 2117 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_WMM_ENABLED, wmm); 2118 2119 if (ssid->ssid_protection && proto == WPA_PROTO_RSN) { 2120 bool ssid_prot; 2121 2122 /* Enable SSID protection based on the AP advertising support 2123 * for it to avoid potential interoperability issues with 2124 * incorrect AP behavior if we were to send an "unexpected" 2125 * RSNXE with multiple octets of payload. */ 2126 ssid_prot = ieee802_11_rsnx_capab( 2127 bss_rsnx, WLAN_RSNX_CAPAB_SSID_PROTECTION); 2128 if (!skip_default_rsne) 2129 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SSID_PROTECTION, 2130 proto == WPA_PROTO_RSN && ssid_prot); 2131 } else { 2132 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_SSID_PROTECTION, false); 2133 } 2134 2135 if (!skip_default_rsne) { 2136 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, 2137 wpa_ie_len)) { 2138 wpa_msg(wpa_s, MSG_WARNING, 2139 "RSN: Failed to generate RSNE/WPA IE"); 2140 return -1; 2141 } 2142 2143 wpa_s->rsnxe_len = sizeof(wpa_s->rsnxe); 2144 if (wpa_sm_set_assoc_rsnxe_default(wpa_s->wpa, wpa_s->rsnxe, 2145 &wpa_s->rsnxe_len)) { 2146 wpa_msg(wpa_s, MSG_WARNING, 2147 "RSN: Failed to generate RSNXE"); 2148 return -1; 2149 } 2150 } 2151 2152 if (0) { 2153 #ifdef CONFIG_DPP 2154 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_DPP) { 2155 /* Use PMK from DPP network introduction (PMKSA entry) */ 2156 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa); 2157 #ifdef CONFIG_DPP2 2158 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DPP_PFS, ssid->dpp_pfs); 2159 #endif /* CONFIG_DPP2 */ 2160 #endif /* CONFIG_DPP */ 2161 } else if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) { 2162 int psk_set = 0; 2163 2164 if (wpa_key_mgmt_wpa_psk_no_sae(ssid->key_mgmt)) { 2165 u8 psk[PMK_LEN]; 2166 2167 if (wpa_supplicant_get_psk(wpa_s, bss, ssid, 2168 psk) == 0) { 2169 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN, NULL, 2170 NULL); 2171 psk_set = 1; 2172 } 2173 forced_memzero(psk, sizeof(psk)); 2174 } 2175 2176 if (wpa_key_mgmt_sae(ssid->key_mgmt) && 2177 (ssid->sae_password || ssid->passphrase || ssid->ext_psk)) 2178 psk_set = 1; 2179 2180 if (!psk_set) { 2181 wpa_msg(wpa_s, MSG_INFO, 2182 "No PSK available for association"); 2183 wpas_auth_failed(wpa_s, "NO_PSK_AVAILABLE", NULL); 2184 return -1; 2185 } 2186 #ifdef CONFIG_OWE 2187 } else if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE) { 2188 /* OWE Diffie-Hellman exchange in (Re)Association 2189 * Request/Response frames set the PMK, so do not override it 2190 * here. */ 2191 #endif /* CONFIG_OWE */ 2192 } else 2193 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa); 2194 2195 if (ssid->mode != WPAS_MODE_IBSS && 2196 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED) && 2197 (ssid->wpa_deny_ptk0_rekey == PTK0_REKEY_ALLOW_NEVER || 2198 (ssid->wpa_deny_ptk0_rekey == PTK0_REKEY_ALLOW_LOCAL_OK && 2199 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAFE_PTK0_REKEYS)))) { 2200 wpa_msg(wpa_s, MSG_INFO, 2201 "Disable PTK0 rekey support - replaced with reconnect"); 2202 wpa_s->deny_ptk0_rekey = 1; 2203 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DENY_PTK0_REKEY, 1); 2204 } else { 2205 wpa_s->deny_ptk0_rekey = 0; 2206 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_DENY_PTK0_REKEY, 0); 2207 } 2208 2209 if (wpa_key_mgmt_cross_akm(wpa_s->key_mgmt) && 2210 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)) 2211 wpas_update_allowed_key_mgmt(wpa_s, ssid); 2212 2213 return 0; 2214 } 2215 2216 2217 static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx, 2218 struct wpa_bss *bss) 2219 { 2220 #ifndef CONFIG_NO_ROBUST_AV 2221 bool scs = true, mscs = true; 2222 #endif /* CONFIG_NO_ROBUST_AV */ 2223 2224 *pos = 0x00; 2225 2226 switch (idx) { 2227 case 0: /* Bits 0-7 */ 2228 break; 2229 case 1: /* Bits 8-15 */ 2230 if (wpa_s->conf->coloc_intf_reporting) { 2231 /* Bit 13 - Collocated Interference Reporting */ 2232 *pos |= 0x20; 2233 } 2234 break; 2235 case 2: /* Bits 16-23 */ 2236 #ifdef CONFIG_WNM 2237 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */ 2238 if ((wpas_driver_bss_selection(wpa_s) || 2239 !wpa_s->disable_mbo_oce) && 2240 !wpa_s->conf->disable_btm) 2241 *pos |= 0x08; /* Bit 19 - BSS Transition */ 2242 #endif /* CONFIG_WNM */ 2243 break; 2244 case 3: /* Bits 24-31 */ 2245 #ifdef CONFIG_WNM 2246 *pos |= 0x02; /* Bit 25 - SSID List */ 2247 #endif /* CONFIG_WNM */ 2248 #ifdef CONFIG_INTERWORKING 2249 if (wpa_s->conf->interworking) 2250 *pos |= 0x80; /* Bit 31 - Interworking */ 2251 #endif /* CONFIG_INTERWORKING */ 2252 break; 2253 case 4: /* Bits 32-39 */ 2254 #ifdef CONFIG_INTERWORKING 2255 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_QOS_MAPPING) 2256 *pos |= 0x01; /* Bit 32 - QoS Map */ 2257 #endif /* CONFIG_INTERWORKING */ 2258 break; 2259 case 5: /* Bits 40-47 */ 2260 #ifdef CONFIG_HS20 2261 if (wpa_s->conf->hs20) 2262 *pos |= 0x40; /* Bit 46 - WNM-Notification */ 2263 #endif /* CONFIG_HS20 */ 2264 #ifdef CONFIG_MBO 2265 *pos |= 0x40; /* Bit 46 - WNM-Notification */ 2266 #endif /* CONFIG_MBO */ 2267 break; 2268 case 6: /* Bits 48-55 */ 2269 #ifndef CONFIG_NO_ROBUST_AV 2270 #ifdef CONFIG_TESTING_OPTIONS 2271 if (wpa_s->disable_scs_support) 2272 scs = false; 2273 #endif /* CONFIG_TESTING_OPTIONS */ 2274 if (bss && !wpa_bss_ext_capab(bss, WLAN_EXT_CAPAB_SCS)) { 2275 /* Drop own SCS capability indication since the AP does 2276 * not support it. This is needed to avoid 2277 * interoperability issues with APs that get confused 2278 * with Extended Capabilities element. */ 2279 scs = false; 2280 } 2281 if (scs) 2282 *pos |= 0x40; /* Bit 54 - SCS */ 2283 #endif /* CONFIG_NO_ROBUST_AV */ 2284 break; 2285 case 7: /* Bits 56-63 */ 2286 break; 2287 case 8: /* Bits 64-71 */ 2288 if (wpa_s->conf->ftm_responder) 2289 *pos |= 0x40; /* Bit 70 - FTM responder */ 2290 if (wpa_s->conf->ftm_initiator) 2291 *pos |= 0x80; /* Bit 71 - FTM initiator */ 2292 break; 2293 case 9: /* Bits 72-79 */ 2294 #ifdef CONFIG_FILS 2295 if (!wpa_s->disable_fils) 2296 *pos |= 0x01; 2297 #endif /* CONFIG_FILS */ 2298 break; 2299 case 10: /* Bits 80-87 */ 2300 #ifndef CONFIG_NO_ROBUST_AV 2301 #ifdef CONFIG_TESTING_OPTIONS 2302 if (wpa_s->disable_mscs_support) 2303 mscs = false; 2304 #endif /* CONFIG_TESTING_OPTIONS */ 2305 if (bss && !wpa_bss_ext_capab(bss, WLAN_EXT_CAPAB_MSCS)) { 2306 /* Drop own MSCS capability indication since the AP does 2307 * not support it. This is needed to avoid 2308 * interoperability issues with APs that get confused 2309 * with Extended Capabilities element. */ 2310 mscs = false; 2311 } 2312 if (mscs) 2313 *pos |= 0x20; /* Bit 85 - Mirrored SCS */ 2314 #endif /* CONFIG_NO_ROBUST_AV */ 2315 break; 2316 } 2317 } 2318 2319 2320 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, 2321 size_t buflen, struct wpa_bss *bss) 2322 { 2323 u8 *pos = buf; 2324 u8 len = 11, i; 2325 2326 if (len < wpa_s->extended_capa_len) 2327 len = wpa_s->extended_capa_len; 2328 if (buflen < (size_t) len + 2) { 2329 wpa_printf(MSG_INFO, 2330 "Not enough room for building extended capabilities element"); 2331 return -1; 2332 } 2333 2334 *pos++ = WLAN_EID_EXT_CAPAB; 2335 *pos++ = len; 2336 for (i = 0; i < len; i++, pos++) { 2337 wpas_ext_capab_byte(wpa_s, pos, i, bss); 2338 2339 if (i < wpa_s->extended_capa_len) { 2340 *pos &= ~wpa_s->extended_capa_mask[i]; 2341 *pos |= wpa_s->extended_capa[i]; 2342 } 2343 } 2344 2345 while (len > 0 && buf[1 + len] == 0) { 2346 len--; 2347 buf[1] = len; 2348 } 2349 if (len == 0) 2350 return 0; 2351 2352 return 2 + len; 2353 } 2354 2355 2356 static int wpas_valid_bss(struct wpa_supplicant *wpa_s, 2357 struct wpa_bss *test_bss) 2358 { 2359 struct wpa_bss *bss; 2360 2361 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) { 2362 if (bss == test_bss) 2363 return 1; 2364 } 2365 2366 return 0; 2367 } 2368 2369 2370 static int wpas_valid_ssid(struct wpa_supplicant *wpa_s, 2371 struct wpa_ssid *test_ssid) 2372 { 2373 struct wpa_ssid *ssid; 2374 2375 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) { 2376 if (ssid == test_ssid) 2377 return 1; 2378 } 2379 2380 return 0; 2381 } 2382 2383 2384 int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss, 2385 struct wpa_ssid *test_ssid) 2386 { 2387 if (test_bss && !wpas_valid_bss(wpa_s, test_bss)) 2388 return 0; 2389 2390 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid); 2391 } 2392 2393 2394 void wpas_connect_work_free(struct wpa_connect_work *cwork) 2395 { 2396 if (cwork == NULL) 2397 return; 2398 os_free(cwork); 2399 } 2400 2401 2402 void wpas_connect_work_done(struct wpa_supplicant *wpa_s) 2403 { 2404 struct wpa_connect_work *cwork; 2405 struct wpa_radio_work *work = wpa_s->connect_work; 2406 2407 if (!work) 2408 return; 2409 2410 wpa_s->connect_work = NULL; 2411 cwork = work->ctx; 2412 work->ctx = NULL; 2413 wpas_connect_work_free(cwork); 2414 radio_work_done(work); 2415 } 2416 2417 2418 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, 2419 enum wpas_mac_addr_style style, 2420 struct wpa_ssid *ssid) 2421 { 2422 struct os_reltime now; 2423 u8 addr[ETH_ALEN]; 2424 2425 os_get_reltime(&now); 2426 /* Random addresses are valid within a given ESS so check 2427 * expiration/value only when continuing to use the same ESS. */ 2428 if (wpa_s->last_mac_addr_style == style && wpa_s->reassoc_same_ess) { 2429 if (style == WPAS_MAC_ADDR_STYLE_DEDICATED_PER_ESS) { 2430 /* Pregenerated addresses do not expire but their value 2431 * might have changed, so let's check that. */ 2432 if (ether_addr_equal(wpa_s->own_addr, ssid->mac_value)) 2433 return 0; 2434 } else if ((wpa_s->last_mac_addr_change.sec != 0 || 2435 wpa_s->last_mac_addr_change.usec != 0) && 2436 !os_reltime_expired( 2437 &now, 2438 &wpa_s->last_mac_addr_change, 2439 wpa_s->conf->rand_addr_lifetime)) { 2440 wpa_msg(wpa_s, MSG_DEBUG, 2441 "Previously selected random MAC address has not yet expired"); 2442 return 0; 2443 } 2444 } 2445 2446 switch (style) { 2447 case WPAS_MAC_ADDR_STYLE_RANDOM: 2448 if (random_mac_addr(addr) < 0) 2449 return -1; 2450 break; 2451 case WPAS_MAC_ADDR_STYLE_RANDOM_SAME_OUI: 2452 os_memcpy(addr, wpa_s->perm_addr, ETH_ALEN); 2453 if (random_mac_addr_keep_oui(addr) < 0) 2454 return -1; 2455 break; 2456 case WPAS_MAC_ADDR_STYLE_DEDICATED_PER_ESS: 2457 if (!ssid) { 2458 wpa_msg(wpa_s, MSG_INFO, 2459 "Invalid 'ssid' for address policy 3"); 2460 return -1; 2461 } 2462 os_memcpy(addr, ssid->mac_value, ETH_ALEN); 2463 break; 2464 default: 2465 return -1; 2466 } 2467 2468 if (wpa_drv_set_mac_addr(wpa_s, addr) < 0) { 2469 wpa_msg(wpa_s, MSG_INFO, 2470 "Failed to set random MAC address"); 2471 return -1; 2472 } 2473 2474 os_get_reltime(&wpa_s->last_mac_addr_change); 2475 wpa_s->mac_addr_changed = 1; 2476 wpa_s->last_mac_addr_style = style; 2477 2478 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) { 2479 wpa_msg(wpa_s, MSG_INFO, 2480 "Could not update MAC address information"); 2481 return -1; 2482 } 2483 2484 wpa_msg(wpa_s, MSG_DEBUG, "Using random MAC address " MACSTR, 2485 MAC2STR(addr)); 2486 2487 return 1; 2488 } 2489 2490 2491 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s) 2492 { 2493 if (wpa_s->wpa_state >= WPA_AUTHENTICATING || 2494 !wpa_s->conf->preassoc_mac_addr) 2495 return 0; 2496 2497 return wpas_update_random_addr(wpa_s, wpa_s->conf->preassoc_mac_addr, 2498 NULL); 2499 } 2500 2501 2502 void wpa_s_setup_sae_pt(struct wpa_config *conf, struct wpa_ssid *ssid, 2503 bool force) 2504 { 2505 #ifdef CONFIG_SAE 2506 int *groups = conf->sae_groups; 2507 int default_groups[] = { 19, 20, 21, 0 }; 2508 const char *password; 2509 2510 if (!groups || groups[0] <= 0) 2511 groups = default_groups; 2512 2513 password = ssid->sae_password; 2514 if (!password) 2515 password = ssid->passphrase; 2516 2517 if (!password || 2518 !wpa_key_mgmt_sae(ssid->key_mgmt) || 2519 (conf->sae_pwe == SAE_PWE_HUNT_AND_PECK && !ssid->sae_password_id && 2520 !wpa_key_mgmt_sae_ext_key(ssid->key_mgmt) && 2521 !force && 2522 !sae_pk_valid_password(password)) || 2523 conf->sae_pwe == SAE_PWE_FORCE_HUNT_AND_PECK) { 2524 /* PT derivation not needed */ 2525 sae_deinit_pt(ssid->pt); 2526 ssid->pt = NULL; 2527 return; 2528 } 2529 2530 if (ssid->pt) 2531 return; /* PT already derived */ 2532 ssid->pt = sae_derive_pt(groups, ssid->ssid, ssid->ssid_len, 2533 (const u8 *) password, os_strlen(password), 2534 ssid->sae_password_id); 2535 #endif /* CONFIG_SAE */ 2536 } 2537 2538 2539 void wpa_s_clear_sae_rejected(struct wpa_supplicant *wpa_s) 2540 { 2541 #if defined(CONFIG_SAE) && defined(CONFIG_SME) 2542 os_free(wpa_s->sme.sae_rejected_groups); 2543 wpa_s->sme.sae_rejected_groups = NULL; 2544 #ifdef CONFIG_TESTING_OPTIONS 2545 if (wpa_s->extra_sae_rejected_groups) { 2546 int i, *groups = wpa_s->extra_sae_rejected_groups; 2547 2548 for (i = 0; groups[i]; i++) { 2549 wpa_printf(MSG_DEBUG, 2550 "TESTING: Indicate rejection of an extra SAE group %d", 2551 groups[i]); 2552 int_array_add_unique(&wpa_s->sme.sae_rejected_groups, 2553 groups[i]); 2554 } 2555 } 2556 #endif /* CONFIG_TESTING_OPTIONS */ 2557 #endif /* CONFIG_SAE && CONFIG_SME */ 2558 } 2559 2560 2561 int wpas_restore_permanent_mac_addr(struct wpa_supplicant *wpa_s) 2562 { 2563 if (wpa_drv_set_mac_addr(wpa_s, NULL) < 0) { 2564 wpa_msg(wpa_s, MSG_INFO, 2565 "Could not restore permanent MAC address"); 2566 return -1; 2567 } 2568 wpa_s->mac_addr_changed = 0; 2569 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) { 2570 wpa_msg(wpa_s, MSG_INFO, 2571 "Could not update MAC address information"); 2572 return -1; 2573 } 2574 wpa_msg(wpa_s, MSG_DEBUG, "Using permanent MAC address"); 2575 return 0; 2576 } 2577 2578 2579 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit); 2580 2581 /** 2582 * wpa_supplicant_associate - Request association 2583 * @wpa_s: Pointer to wpa_supplicant data 2584 * @bss: Scan results for the selected BSS, or %NULL if not available 2585 * @ssid: Configuration data for the selected network 2586 * 2587 * This function is used to request %wpa_supplicant to associate with a BSS. 2588 */ 2589 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s, 2590 struct wpa_bss *bss, struct wpa_ssid *ssid) 2591 { 2592 bool clear_rejected = true; 2593 struct wpa_connect_work *cwork; 2594 enum wpas_mac_addr_style rand_style; 2595 2596 wpa_s->own_disconnect_req = 0; 2597 wpa_s->own_reconnect_req = 0; 2598 2599 /* 2600 * If we are starting a new connection, any previously pending EAPOL 2601 * RX cannot be valid anymore. 2602 */ 2603 wpabuf_free(wpa_s->pending_eapol_rx); 2604 wpa_s->pending_eapol_rx = NULL; 2605 2606 if (ssid->mac_addr == WPAS_MAC_ADDR_STYLE_NOT_SET) 2607 rand_style = wpa_s->conf->mac_addr; 2608 else 2609 rand_style = ssid->mac_addr; 2610 2611 wpa_s->eapol_failed = 0; 2612 wpa_s->multi_ap_ie = 0; 2613 #ifndef CONFIG_NO_WMM_AC 2614 wmm_ac_clear_saved_tspecs(wpa_s); 2615 #endif /* CONFIG_NO_WMM_AC */ 2616 #ifdef CONFIG_WNM 2617 wpa_s->wnm_mode = 0; 2618 wpa_s->wnm_target_bss = NULL; 2619 #endif /* CONFIG_WNM */ 2620 wpa_s->reassoc_same_bss = 0; 2621 wpa_s->reassoc_same_ess = 0; 2622 #ifdef CONFIG_TESTING_OPTIONS 2623 wpa_s->testing_resend_assoc = 0; 2624 #endif /* CONFIG_TESTING_OPTIONS */ 2625 2626 if (wpa_s->last_ssid == ssid) { 2627 wpa_dbg(wpa_s, MSG_DEBUG, "Re-association to the same ESS"); 2628 wpa_s->reassoc_same_ess = 1; 2629 if (wpa_s->current_bss && wpa_s->current_bss == bss) { 2630 #ifndef CONFIG_NO_WMM_AC 2631 wmm_ac_save_tspecs(wpa_s); 2632 #endif /* CONFIG_NO_WMM_AC */ 2633 wpa_s->reassoc_same_bss = 1; 2634 clear_rejected = false; 2635 } else if (wpa_s->current_bss && wpa_s->current_bss != bss) { 2636 os_get_reltime(&wpa_s->roam_start); 2637 } 2638 } 2639 2640 if (clear_rejected) 2641 wpa_s_clear_sae_rejected(wpa_s); 2642 2643 #ifdef CONFIG_SAE 2644 wpa_s_setup_sae_pt(wpa_s->conf, ssid, false); 2645 #endif /* CONFIG_SAE */ 2646 2647 if (rand_style > WPAS_MAC_ADDR_STYLE_PERMANENT) { 2648 int status = wpas_update_random_addr(wpa_s, rand_style, ssid); 2649 2650 if (status < 0) 2651 return; 2652 if (rand_style != WPAS_MAC_ADDR_STYLE_DEDICATED_PER_ESS && 2653 status > 0) /* MAC changed */ 2654 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid); 2655 } else if (rand_style == WPAS_MAC_ADDR_STYLE_PERMANENT && 2656 wpa_s->mac_addr_changed) { 2657 if (wpas_restore_permanent_mac_addr(wpa_s) < 0) 2658 return; 2659 } 2660 wpa_s->last_ssid = ssid; 2661 2662 #ifdef CONFIG_IBSS_RSN 2663 ibss_rsn_deinit(wpa_s->ibss_rsn); 2664 wpa_s->ibss_rsn = NULL; 2665 #else /* CONFIG_IBSS_RSN */ 2666 if (ssid->mode == WPAS_MODE_IBSS && 2667 !(ssid->key_mgmt & (WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPA_NONE))) { 2668 wpa_msg(wpa_s, MSG_INFO, 2669 "IBSS RSN not supported in the build"); 2670 return; 2671 } 2672 #endif /* CONFIG_IBSS_RSN */ 2673 2674 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO || 2675 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) { 2676 #ifdef CONFIG_AP 2677 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) { 2678 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP " 2679 "mode"); 2680 return; 2681 } 2682 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) { 2683 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 2684 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) 2685 wpas_p2p_ap_setup_failed(wpa_s); 2686 return; 2687 } 2688 wpa_s->current_bss = bss; 2689 #else /* CONFIG_AP */ 2690 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in " 2691 "the build"); 2692 #endif /* CONFIG_AP */ 2693 return; 2694 } 2695 2696 if (ssid->mode == WPAS_MODE_MESH) { 2697 #ifdef CONFIG_MESH 2698 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_MESH)) { 2699 wpa_msg(wpa_s, MSG_INFO, 2700 "Driver does not support mesh mode"); 2701 return; 2702 } 2703 if (bss) 2704 ssid->frequency = bss->freq; 2705 if (wpa_supplicant_join_mesh(wpa_s, ssid) < 0) { 2706 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE); 2707 wpa_msg(wpa_s, MSG_ERROR, "Could not join mesh"); 2708 return; 2709 } 2710 wpa_s->current_bss = bss; 2711 #else /* CONFIG_MESH */ 2712 wpa_msg(wpa_s, MSG_ERROR, 2713 "mesh mode support not included in the build"); 2714 #endif /* CONFIG_MESH */ 2715 return; 2716 } 2717 2718 /* 2719 * Set WPA state machine configuration to match the selected network now 2720 * so that the information is available before wpas_start_assoc_cb() 2721 * gets called. This is needed at least for RSN pre-authentication where 2722 * candidate APs are added to a list based on scan result processing 2723 * before completion of the first association. 2724 */ 2725 wpa_supplicant_rsn_supp_set_config(wpa_s, ssid); 2726 2727 #ifdef CONFIG_DPP 2728 if (wpas_dpp_check_connect(wpa_s, ssid, bss) != 0) 2729 return; 2730 #endif /* CONFIG_DPP */ 2731 2732 #ifdef CONFIG_TDLS 2733 if (bss) 2734 wpa_tdls_ap_ies(wpa_s->wpa, wpa_bss_ie_ptr(bss), bss->ie_len); 2735 #endif /* CONFIG_TDLS */ 2736 2737 #ifdef CONFIG_MBO 2738 wpas_mbo_check_pmf(wpa_s, bss, ssid); 2739 #endif /* CONFIG_MBO */ 2740 2741 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 2742 ssid->mode == WPAS_MODE_INFRA) { 2743 sme_authenticate(wpa_s, bss, ssid); 2744 return; 2745 } 2746 2747 if (wpa_s->connect_work) { 2748 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist"); 2749 return; 2750 } 2751 2752 if (radio_work_pending(wpa_s, "connect")) { 2753 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist"); 2754 return; 2755 } 2756 2757 #ifdef CONFIG_SME 2758 if (ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) { 2759 /* Clear possibly set auth_alg, if any, from last attempt. */ 2760 wpa_s->sme.auth_alg = WPA_AUTH_ALG_OPEN; 2761 } 2762 #endif /* CONFIG_SME */ 2763 2764 wpas_abort_ongoing_scan(wpa_s); 2765 2766 cwork = os_zalloc(sizeof(*cwork)); 2767 if (cwork == NULL) 2768 return; 2769 2770 cwork->bss = bss; 2771 cwork->ssid = ssid; 2772 2773 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1, 2774 wpas_start_assoc_cb, cwork) < 0) { 2775 os_free(cwork); 2776 } 2777 } 2778 2779 2780 static int bss_is_ibss(struct wpa_bss *bss) 2781 { 2782 return (bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) == 2783 IEEE80211_CAP_IBSS; 2784 } 2785 2786 2787 static int drv_supports_vht(struct wpa_supplicant *wpa_s, 2788 const struct wpa_ssid *ssid) 2789 { 2790 enum hostapd_hw_mode hw_mode; 2791 struct hostapd_hw_modes *mode = NULL; 2792 u8 channel; 2793 int i; 2794 2795 hw_mode = ieee80211_freq_to_chan(ssid->frequency, &channel); 2796 if (hw_mode == NUM_HOSTAPD_MODES) 2797 return 0; 2798 for (i = 0; wpa_s->hw.modes && i < wpa_s->hw.num_modes; i++) { 2799 if (wpa_s->hw.modes[i].mode == hw_mode) { 2800 mode = &wpa_s->hw.modes[i]; 2801 break; 2802 } 2803 } 2804 2805 if (!mode) 2806 return 0; 2807 2808 return mode->vht_capab != 0; 2809 } 2810 2811 2812 static bool ibss_mesh_is_80mhz_avail(int channel, struct hostapd_hw_modes *mode) 2813 { 2814 int i; 2815 2816 for (i = channel; i < channel + 16; i += 4) { 2817 struct hostapd_channel_data *chan; 2818 2819 chan = hw_get_channel_chan(mode, i, NULL); 2820 if (!chan || 2821 chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR)) 2822 return false; 2823 } 2824 2825 return true; 2826 } 2827 2828 2829 static struct wpa_bss * ibss_find_existing_bss(struct wpa_supplicant *wpa_s, 2830 const struct wpa_ssid *ssid) 2831 { 2832 unsigned int j; 2833 2834 for (j = 0; j < wpa_s->last_scan_res_used; j++) { 2835 struct wpa_bss *bss = wpa_s->last_scan_res[j]; 2836 2837 if (!bss_is_ibss(bss)) 2838 continue; 2839 2840 if (ssid->ssid_len == bss->ssid_len && 2841 os_memcmp(ssid->ssid, bss->ssid, bss->ssid_len) == 0) 2842 return bss; 2843 } 2844 return NULL; 2845 } 2846 2847 2848 static bool ibss_mesh_can_use_ht(struct wpa_supplicant *wpa_s, 2849 const struct wpa_ssid *ssid, 2850 struct hostapd_hw_modes *mode) 2851 { 2852 /* For IBSS check HT_IBSS flag */ 2853 if (ssid->mode == WPAS_MODE_IBSS && 2854 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_HT_IBSS)) 2855 return false; 2856 2857 if (wpa_s->group_cipher == WPA_CIPHER_WEP40 || 2858 wpa_s->group_cipher == WPA_CIPHER_WEP104 || 2859 wpa_s->pairwise_cipher == WPA_CIPHER_TKIP) { 2860 wpa_printf(MSG_DEBUG, 2861 "IBSS: WEP/TKIP detected, do not try to enable HT"); 2862 return false; 2863 } 2864 2865 if (!ht_supported(mode)) 2866 return false; 2867 2868 #ifdef CONFIG_HT_OVERRIDES 2869 if (ssid->disable_ht) 2870 return false; 2871 #endif /* CONFIG_HT_OVERRIDES */ 2872 2873 return true; 2874 } 2875 2876 2877 static bool ibss_mesh_can_use_vht(struct wpa_supplicant *wpa_s, 2878 const struct wpa_ssid *ssid, 2879 struct hostapd_hw_modes *mode) 2880 { 2881 if (mode->mode != HOSTAPD_MODE_IEEE80211A) 2882 return false; 2883 2884 if (!drv_supports_vht(wpa_s, ssid)) 2885 return false; 2886 2887 /* For IBSS check VHT_IBSS flag */ 2888 if (ssid->mode == WPAS_MODE_IBSS && 2889 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_VHT_IBSS)) 2890 return false; 2891 2892 if (!vht_supported(mode)) 2893 return false; 2894 2895 #ifdef CONFIG_VHT_OVERRIDES 2896 if (ssid->disable_vht) 2897 return false; 2898 #endif /* CONFIG_VHT_OVERRIDES */ 2899 2900 return true; 2901 } 2902 2903 2904 static bool ibss_mesh_can_use_he(struct wpa_supplicant *wpa_s, 2905 const struct wpa_ssid *ssid, 2906 const struct hostapd_hw_modes *mode, 2907 int ieee80211_mode) 2908 { 2909 #ifdef CONFIG_HE_OVERRIDES 2910 if (ssid->disable_he) 2911 return false; 2912 #endif /* CONFIG_HE_OVERRIDES */ 2913 2914 switch (mode->mode) { 2915 case HOSTAPD_MODE_IEEE80211G: 2916 case HOSTAPD_MODE_IEEE80211B: 2917 case HOSTAPD_MODE_IEEE80211A: 2918 return mode->he_capab[ieee80211_mode].he_supported; 2919 default: 2920 return false; 2921 } 2922 } 2923 2924 2925 static bool ibss_mesh_can_use_eht(struct wpa_supplicant *wpa_s, 2926 const struct wpa_ssid *ssid, 2927 const struct hostapd_hw_modes *mode, 2928 int ieee80211_mode) 2929 { 2930 if (ssid->disable_eht) 2931 return false; 2932 2933 switch(mode->mode) { 2934 case HOSTAPD_MODE_IEEE80211G: 2935 case HOSTAPD_MODE_IEEE80211B: 2936 case HOSTAPD_MODE_IEEE80211A: 2937 return mode->eht_capab[ieee80211_mode].eht_supported; 2938 default: 2939 return false; 2940 } 2941 } 2942 2943 2944 static void ibss_mesh_select_40mhz(struct wpa_supplicant *wpa_s, 2945 const struct wpa_ssid *ssid, 2946 struct hostapd_hw_modes *mode, 2947 struct hostapd_freq_params *freq, 2948 int obss_scan) { 2949 int chan_idx; 2950 struct hostapd_channel_data *pri_chan = NULL, *sec_chan = NULL; 2951 int i, res; 2952 unsigned int j; 2953 static const int ht40plus[] = { 2954 36, 44, 52, 60, 100, 108, 116, 124, 132, 140, 2955 149, 157, 165, 173, 184, 192 2956 }; 2957 int ht40 = -1; 2958 2959 if (!freq->ht_enabled) 2960 return; 2961 2962 for (chan_idx = 0; chan_idx < mode->num_channels; chan_idx++) { 2963 pri_chan = &mode->channels[chan_idx]; 2964 if (pri_chan->chan == freq->channel) 2965 break; 2966 pri_chan = NULL; 2967 } 2968 if (!pri_chan) 2969 return; 2970 2971 /* Check primary channel flags */ 2972 if (pri_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR)) 2973 return; 2974 2975 #ifdef CONFIG_HT_OVERRIDES 2976 if (ssid->disable_ht40) 2977 return; 2978 #endif 2979 2980 /* Check/setup HT40+/HT40- */ 2981 for (j = 0; j < ARRAY_SIZE(ht40plus); j++) { 2982 if (ht40plus[j] == freq->channel) { 2983 ht40 = 1; 2984 break; 2985 } 2986 } 2987 2988 /* Find secondary channel */ 2989 for (i = 0; i < mode->num_channels; i++) { 2990 sec_chan = &mode->channels[i]; 2991 if (sec_chan->chan == freq->channel + ht40 * 4) 2992 break; 2993 sec_chan = NULL; 2994 } 2995 if (!sec_chan) 2996 return; 2997 2998 /* Check secondary channel flags */ 2999 if (sec_chan->flag & (HOSTAPD_CHAN_DISABLED | HOSTAPD_CHAN_NO_IR)) 3000 return; 3001 3002 if (ht40 == -1) { 3003 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40MINUS)) 3004 return; 3005 } else { 3006 if (!(pri_chan->flag & HOSTAPD_CHAN_HT40PLUS)) 3007 return; 3008 } 3009 freq->sec_channel_offset = ht40; 3010 3011 if (obss_scan) { 3012 struct wpa_scan_results *scan_res; 3013 3014 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 0, 3015 NULL); 3016 if (scan_res == NULL) { 3017 /* Back to HT20 */ 3018 freq->sec_channel_offset = 0; 3019 return; 3020 } 3021 3022 res = check_40mhz_5g(scan_res, pri_chan, sec_chan); 3023 switch (res) { 3024 case 0: 3025 /* Back to HT20 */ 3026 freq->sec_channel_offset = 0; 3027 break; 3028 case 1: 3029 /* Configuration allowed */ 3030 break; 3031 case 2: 3032 /* Switch pri/sec channels */ 3033 freq->freq = hw_get_freq(mode, sec_chan->chan); 3034 freq->sec_channel_offset = -freq->sec_channel_offset; 3035 freq->channel = sec_chan->chan; 3036 break; 3037 default: 3038 freq->sec_channel_offset = 0; 3039 break; 3040 } 3041 3042 wpa_scan_results_free(scan_res); 3043 } 3044 3045 wpa_printf(MSG_DEBUG, 3046 "IBSS/mesh: setup freq channel %d, sec_channel_offset %d", 3047 freq->channel, freq->sec_channel_offset); 3048 } 3049 3050 3051 static bool ibss_mesh_select_80_160mhz(struct wpa_supplicant *wpa_s, 3052 const struct wpa_ssid *ssid, 3053 struct hostapd_hw_modes *mode, 3054 struct hostapd_freq_params *freq, 3055 int ieee80211_mode, bool is_6ghz) { 3056 static const int bw80[] = { 3057 5180, 5260, 5500, 5580, 5660, 5745, 5825, 3058 5955, 6035, 6115, 6195, 6275, 6355, 6435, 3059 6515, 6595, 6675, 6755, 6835, 6915, 6995 3060 }; 3061 static const int bw160[] = { 3062 5955, 6115, 6275, 6435, 6595, 6755, 6915 3063 }; 3064 struct hostapd_freq_params vht_freq; 3065 int i; 3066 unsigned int j, k; 3067 int chwidth, seg0, seg1; 3068 u32 vht_caps = 0; 3069 u8 channel = freq->channel; 3070 3071 if (!freq->vht_enabled && !freq->he_enabled) 3072 return true; 3073 3074 vht_freq = *freq; 3075 3076 chwidth = CONF_OPER_CHWIDTH_USE_HT; 3077 seg0 = freq->channel + 2 * freq->sec_channel_offset; 3078 seg1 = 0; 3079 if (freq->sec_channel_offset == 0) { 3080 seg0 = 0; 3081 /* Don't try 80 MHz if 40 MHz failed, except in 6 GHz */ 3082 if (freq->ht_enabled && !is_6ghz) 3083 goto skip_80mhz; 3084 } 3085 if (ssid->max_oper_chwidth == CONF_OPER_CHWIDTH_USE_HT) 3086 goto skip_80mhz; 3087 3088 /* setup center_freq1, bandwidth */ 3089 for (j = 0; j < ARRAY_SIZE(bw80); j++) { 3090 if (freq->freq >= bw80[j] && 3091 freq->freq < bw80[j] + 80) 3092 break; 3093 } 3094 3095 if (j == ARRAY_SIZE(bw80) || 3096 ieee80211_freq_to_chan(bw80[j], &channel) == NUM_HOSTAPD_MODES) 3097 goto skip_80mhz; 3098 3099 /* Use 40 MHz if channel not usable */ 3100 if (!ibss_mesh_is_80mhz_avail(channel, mode)) 3101 goto skip_80mhz; 3102 3103 chwidth = CONF_OPER_CHWIDTH_80MHZ; 3104 seg0 = channel + 6; 3105 seg1 = 0; 3106 3107 /* In 160 MHz, the initial four 20 MHz channels were validated 3108 * above. If 160 MHz is supported, check the remaining four 20 MHz 3109 * channels for the total of 160 MHz bandwidth for 6 GHz. 3110 */ 3111 if ((mode->he_capab[ieee80211_mode].phy_cap[ 3112 HE_PHYCAP_CHANNEL_WIDTH_SET_IDX] & 3113 HE_PHYCAP_CHANNEL_WIDTH_SET_160MHZ_IN_5G) && is_6ghz && 3114 ibss_mesh_is_80mhz_avail(channel + 16, mode)) { 3115 for (j = 0; j < ARRAY_SIZE(bw160); j++) { 3116 if (freq->freq == bw160[j]) { 3117 chwidth = CONF_OPER_CHWIDTH_160MHZ; 3118 seg0 = channel + 14; 3119 break; 3120 } 3121 } 3122 } 3123 3124 if (ssid->max_oper_chwidth == CONF_OPER_CHWIDTH_80P80MHZ) { 3125 /* setup center_freq2, bandwidth */ 3126 for (k = 0; k < ARRAY_SIZE(bw80); k++) { 3127 /* Only accept 80 MHz segments separated by a gap */ 3128 if (j == k || abs(bw80[j] - bw80[k]) == 80) 3129 continue; 3130 3131 if (ieee80211_freq_to_chan(bw80[k], &channel) == 3132 NUM_HOSTAPD_MODES) 3133 break; 3134 3135 for (i = channel; i < channel + 16; i += 4) { 3136 struct hostapd_channel_data *chan; 3137 3138 chan = hw_get_channel_chan(mode, i, NULL); 3139 if (!chan) 3140 continue; 3141 3142 if (chan->flag & (HOSTAPD_CHAN_DISABLED | 3143 HOSTAPD_CHAN_NO_IR | 3144 HOSTAPD_CHAN_RADAR)) 3145 continue; 3146 3147 /* Found a suitable second segment for 80+80 */ 3148 chwidth = CONF_OPER_CHWIDTH_80P80MHZ; 3149 if (!is_6ghz) 3150 vht_caps |= 3151 VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ; 3152 seg1 = channel + 6; 3153 } 3154 3155 if (chwidth == CONF_OPER_CHWIDTH_80P80MHZ) 3156 break; 3157 } 3158 } else if (ssid->max_oper_chwidth == CONF_OPER_CHWIDTH_160MHZ) { 3159 if (freq->freq == 5180) { 3160 chwidth = CONF_OPER_CHWIDTH_160MHZ; 3161 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ; 3162 seg0 = 50; 3163 } else if (freq->freq == 5520) { 3164 chwidth = CONF_OPER_CHWIDTH_160MHZ; 3165 vht_caps |= VHT_CAP_SUPP_CHAN_WIDTH_160MHZ; 3166 seg0 = 114; 3167 } 3168 } 3169 3170 skip_80mhz: 3171 if (hostapd_set_freq_params(&vht_freq, mode->mode, freq->freq, 3172 freq->channel, ssid->enable_edmg, 3173 ssid->edmg_channel, freq->ht_enabled, 3174 freq->vht_enabled, freq->he_enabled, 3175 freq->eht_enabled, 3176 freq->sec_channel_offset, 3177 chwidth, seg0, seg1, vht_caps, 3178 &mode->he_capab[ieee80211_mode], 3179 &mode->eht_capab[ieee80211_mode], 0) != 0) 3180 return false; 3181 3182 *freq = vht_freq; 3183 3184 wpa_printf(MSG_DEBUG, "IBSS: VHT setup freq cf1 %d, cf2 %d, bw %d", 3185 freq->center_freq1, freq->center_freq2, freq->bandwidth); 3186 return true; 3187 } 3188 3189 3190 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s, 3191 const struct wpa_ssid *ssid, 3192 struct hostapd_freq_params *freq) 3193 { 3194 int ieee80211_mode = wpas_mode_to_ieee80211_mode(ssid->mode); 3195 enum hostapd_hw_mode hw_mode; 3196 struct hostapd_hw_modes *mode = NULL; 3197 int obss_scan = 1; 3198 u8 channel; 3199 bool is_6ghz, is_24ghz; 3200 3201 freq->freq = ssid->frequency; 3202 3203 if (ssid->mode == WPAS_MODE_IBSS && !ssid->fixed_freq) { 3204 struct wpa_bss *bss = ibss_find_existing_bss(wpa_s, ssid); 3205 3206 if (bss) { 3207 wpa_printf(MSG_DEBUG, 3208 "IBSS already found in scan results, adjust control freq: %d", 3209 bss->freq); 3210 freq->freq = bss->freq; 3211 obss_scan = 0; 3212 } 3213 } 3214 3215 hw_mode = ieee80211_freq_to_chan(freq->freq, &channel); 3216 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, 3217 hw_mode, is_6ghz_freq(ssid->frequency)); 3218 3219 if (!mode) 3220 return; 3221 3222 is_24ghz = hw_mode == HOSTAPD_MODE_IEEE80211G || 3223 hw_mode == HOSTAPD_MODE_IEEE80211B; 3224 3225 is_6ghz = is_6ghz_freq(freq->freq); 3226 3227 freq->ht_enabled = 0; 3228 freq->vht_enabled = 0; 3229 freq->he_enabled = 0; 3230 freq->eht_enabled = 0; 3231 3232 if (!is_6ghz) 3233 freq->ht_enabled = ibss_mesh_can_use_ht(wpa_s, ssid, mode); 3234 if (freq->ht_enabled) 3235 freq->vht_enabled = ibss_mesh_can_use_vht(wpa_s, ssid, mode); 3236 if (freq->vht_enabled || (freq->ht_enabled && is_24ghz) || is_6ghz) 3237 freq->he_enabled = ibss_mesh_can_use_he(wpa_s, ssid, mode, 3238 ieee80211_mode); 3239 freq->channel = channel; 3240 /* Setup higher BW only for 5 GHz */ 3241 if (mode->mode == HOSTAPD_MODE_IEEE80211A) { 3242 ibss_mesh_select_40mhz(wpa_s, ssid, mode, freq, obss_scan); 3243 if (!ibss_mesh_select_80_160mhz(wpa_s, ssid, mode, freq, 3244 ieee80211_mode, is_6ghz)) 3245 freq->he_enabled = freq->vht_enabled = false; 3246 } 3247 3248 if (freq->he_enabled) 3249 freq->eht_enabled = ibss_mesh_can_use_eht(wpa_s, ssid, mode, 3250 ieee80211_mode); 3251 } 3252 3253 3254 #ifdef CONFIG_FILS 3255 static size_t wpas_add_fils_hlp_req(struct wpa_supplicant *wpa_s, u8 *ie_buf, 3256 size_t ie_buf_len) 3257 { 3258 struct fils_hlp_req *req; 3259 size_t rem_len, hdr_len, hlp_len, len, ie_len = 0; 3260 const u8 *pos; 3261 u8 *buf = ie_buf; 3262 3263 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req, 3264 list) { 3265 rem_len = ie_buf_len - ie_len; 3266 pos = wpabuf_head(req->pkt); 3267 hdr_len = 1 + 2 * ETH_ALEN + 6; 3268 hlp_len = wpabuf_len(req->pkt); 3269 3270 if (rem_len < 2 + hdr_len + hlp_len) { 3271 wpa_printf(MSG_ERROR, 3272 "FILS: Cannot fit HLP - rem_len=%lu to_fill=%lu", 3273 (unsigned long) rem_len, 3274 (unsigned long) (2 + hdr_len + hlp_len)); 3275 break; 3276 } 3277 3278 len = (hdr_len + hlp_len) > 255 ? 255 : hdr_len + hlp_len; 3279 /* Element ID */ 3280 *buf++ = WLAN_EID_EXTENSION; 3281 /* Length */ 3282 *buf++ = len; 3283 /* Element ID Extension */ 3284 *buf++ = WLAN_EID_EXT_FILS_HLP_CONTAINER; 3285 /* Destination MAC address */ 3286 os_memcpy(buf, req->dst, ETH_ALEN); 3287 buf += ETH_ALEN; 3288 /* Source MAC address */ 3289 os_memcpy(buf, wpa_s->own_addr, ETH_ALEN); 3290 buf += ETH_ALEN; 3291 /* LLC/SNAP Header */ 3292 os_memcpy(buf, "\xaa\xaa\x03\x00\x00\x00", 6); 3293 buf += 6; 3294 /* HLP Packet */ 3295 os_memcpy(buf, pos, len - hdr_len); 3296 buf += len - hdr_len; 3297 pos += len - hdr_len; 3298 3299 hlp_len -= len - hdr_len; 3300 ie_len += 2 + len; 3301 rem_len -= 2 + len; 3302 3303 while (hlp_len) { 3304 len = (hlp_len > 255) ? 255 : hlp_len; 3305 if (rem_len < 2 + len) 3306 break; 3307 *buf++ = WLAN_EID_FRAGMENT; 3308 *buf++ = len; 3309 os_memcpy(buf, pos, len); 3310 buf += len; 3311 pos += len; 3312 3313 hlp_len -= len; 3314 ie_len += 2 + len; 3315 rem_len -= 2 + len; 3316 } 3317 } 3318 3319 return ie_len; 3320 } 3321 3322 3323 int wpa_is_fils_supported(struct wpa_supplicant *wpa_s) 3324 { 3325 return (((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 3326 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_FILS)) || 3327 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 3328 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD))); 3329 } 3330 3331 3332 int wpa_is_fils_sk_pfs_supported(struct wpa_supplicant *wpa_s) 3333 { 3334 #ifdef CONFIG_FILS_SK_PFS 3335 return (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 3336 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SUPPORT_FILS); 3337 #else /* CONFIG_FILS_SK_PFS */ 3338 return 0; 3339 #endif /* CONFIG_FILS_SK_PFS */ 3340 } 3341 3342 #endif /* CONFIG_FILS */ 3343 3344 3345 bool wpa_is_non_eht_scs_traffic_desc_supported(struct wpa_bss *bss) 3346 { 3347 const u8 *wfa_capa; 3348 3349 if (!bss) 3350 return false; 3351 3352 /* Get WFA capability from Beacon or Probe Response frame elements */ 3353 wfa_capa = wpa_bss_get_vendor_ie(bss, WFA_CAPA_IE_VENDOR_TYPE); 3354 if (!wfa_capa) 3355 wfa_capa = wpa_bss_get_vendor_ie_beacon( 3356 bss, WFA_CAPA_IE_VENDOR_TYPE); 3357 3358 if (!wfa_capa || wfa_capa[1] < 6 || wfa_capa[6] < 1 || 3359 !(wfa_capa[7] & WFA_CAPA_QM_NON_EHT_SCS_TRAFFIC_DESC)) { 3360 /* AP does not enable QM non EHT traffic description policy */ 3361 return false; 3362 } 3363 3364 return true; 3365 } 3366 3367 3368 static int wpas_populate_wfa_capa(struct wpa_supplicant *wpa_s, 3369 struct wpa_bss *bss, 3370 u8 *wpa_ie, size_t wpa_ie_len, 3371 size_t max_wpa_ie_len) 3372 { 3373 struct wpabuf *wfa_ie = NULL; 3374 u8 wfa_capa[1]; 3375 size_t wfa_ie_len, buf_len; 3376 3377 os_memset(wfa_capa, 0, sizeof(wfa_capa)); 3378 #ifndef CONFIG_NO_ROBUST_AV 3379 if (wpa_s->enable_dscp_policy_capa) 3380 wfa_capa[0] |= WFA_CAPA_QM_DSCP_POLICY; 3381 #endif /* CONFIG_NO_ROBUST_AV */ 3382 3383 if (wpa_is_non_eht_scs_traffic_desc_supported(bss)) 3384 wfa_capa[0] |= WFA_CAPA_QM_NON_EHT_SCS_TRAFFIC_DESC; 3385 3386 if (!wfa_capa[0]) 3387 return wpa_ie_len; 3388 3389 /* Wi-Fi Alliance element */ 3390 buf_len = 1 + /* Element ID */ 3391 1 + /* Length */ 3392 3 + /* OUI */ 3393 1 + /* OUI Type */ 3394 1 + /* Capabilities Length */ 3395 sizeof(wfa_capa); /* Capabilities */ 3396 wfa_ie = wpabuf_alloc(buf_len); 3397 if (!wfa_ie) 3398 return wpa_ie_len; 3399 3400 wpabuf_put_u8(wfa_ie, WLAN_EID_VENDOR_SPECIFIC); 3401 wpabuf_put_u8(wfa_ie, buf_len - 2); 3402 wpabuf_put_be24(wfa_ie, OUI_WFA); 3403 wpabuf_put_u8(wfa_ie, WFA_CAPA_OUI_TYPE); 3404 wpabuf_put_u8(wfa_ie, sizeof(wfa_capa)); 3405 wpabuf_put_data(wfa_ie, wfa_capa, sizeof(wfa_capa)); 3406 3407 wfa_ie_len = wpabuf_len(wfa_ie); 3408 if (wpa_ie_len + wfa_ie_len <= max_wpa_ie_len) { 3409 wpa_hexdump_buf(MSG_MSGDUMP, "WFA Capabilities element", 3410 wfa_ie); 3411 os_memcpy(wpa_ie + wpa_ie_len, wpabuf_head(wfa_ie), 3412 wfa_ie_len); 3413 wpa_ie_len += wfa_ie_len; 3414 } 3415 3416 wpabuf_free(wfa_ie); 3417 return wpa_ie_len; 3418 } 3419 3420 3421 static u8 * wpas_populate_assoc_ies( 3422 struct wpa_supplicant *wpa_s, 3423 struct wpa_bss *bss, struct wpa_ssid *ssid, 3424 struct wpa_driver_associate_params *params, 3425 enum wpa_drv_update_connect_params_mask *mask) 3426 { 3427 u8 *wpa_ie; 3428 size_t max_wpa_ie_len = 500; 3429 size_t wpa_ie_len; 3430 int algs = WPA_AUTH_ALG_OPEN; 3431 #ifdef CONFIG_MBO 3432 const u8 *mbo_ie; 3433 #endif 3434 #if defined(CONFIG_SAE) || defined(CONFIG_FILS) 3435 int pmksa_cached = 0; 3436 #endif /* CONFIG_SAE || CONFIG_FILS */ 3437 #ifdef CONFIG_FILS 3438 const u8 *realm, *username, *rrk; 3439 size_t realm_len, username_len, rrk_len; 3440 u16 next_seq_num; 3441 struct fils_hlp_req *req; 3442 3443 dl_list_for_each(req, &wpa_s->fils_hlp_req, struct fils_hlp_req, 3444 list) { 3445 max_wpa_ie_len += 3 + 2 * ETH_ALEN + 6 + wpabuf_len(req->pkt) + 3446 2 + 2 * wpabuf_len(req->pkt) / 255; 3447 } 3448 #endif /* CONFIG_FILS */ 3449 3450 wpa_ie = os_malloc(max_wpa_ie_len); 3451 if (!wpa_ie) { 3452 wpa_printf(MSG_ERROR, 3453 "Failed to allocate connect IE buffer for %lu bytes", 3454 (unsigned long) max_wpa_ie_len); 3455 return NULL; 3456 } 3457 3458 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) || 3459 wpa_bss_get_ie(bss, WLAN_EID_RSN)) && 3460 wpa_key_mgmt_wpa(ssid->key_mgmt)) { 3461 int try_opportunistic; 3462 const u8 *cache_id = NULL; 3463 const u8 *addr = bss->bssid; 3464 3465 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 3466 (wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_MLO) && 3467 !is_zero_ether_addr(bss->mld_addr)) 3468 addr = bss->mld_addr; 3469 3470 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 3471 wpa_s->valid_links) 3472 addr = wpa_s->ap_mld_addr; 3473 3474 try_opportunistic = (ssid->proactive_key_caching < 0 ? 3475 wpa_s->conf->okc : 3476 ssid->proactive_key_caching) && 3477 (ssid->proto & WPA_PROTO_RSN); 3478 #ifdef CONFIG_FILS 3479 if (wpa_key_mgmt_fils(ssid->key_mgmt)) 3480 cache_id = wpa_bss_get_fils_cache_id(bss); 3481 #endif /* CONFIG_FILS */ 3482 if (pmksa_cache_set_current(wpa_s->wpa, NULL, addr, 3483 ssid, try_opportunistic, 3484 cache_id, 0, false) == 0) { 3485 eapol_sm_notify_pmkid_attempt(wpa_s->eapol); 3486 #if defined(CONFIG_SAE) || defined(CONFIG_FILS) 3487 pmksa_cached = 1; 3488 #endif /* CONFIG_SAE || CONFIG_FILS */ 3489 } 3490 wpa_ie_len = max_wpa_ie_len; 3491 if (wpa_supplicant_set_suites(wpa_s, bss, ssid, 3492 wpa_ie, &wpa_ie_len, false)) { 3493 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA " 3494 "key management and encryption suites"); 3495 os_free(wpa_ie); 3496 return NULL; 3497 } 3498 #ifdef CONFIG_HS20 3499 } else if (bss && wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE) && 3500 (ssid->key_mgmt & WPA_KEY_MGMT_OSEN)) { 3501 /* No PMKSA caching, but otherwise similar to RSN/WPA */ 3502 wpa_ie_len = max_wpa_ie_len; 3503 if (wpa_supplicant_set_suites(wpa_s, bss, ssid, 3504 wpa_ie, &wpa_ie_len, false)) { 3505 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA " 3506 "key management and encryption suites"); 3507 os_free(wpa_ie); 3508 return NULL; 3509 } 3510 #endif /* CONFIG_HS20 */ 3511 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss && 3512 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) { 3513 /* 3514 * Both WPA and non-WPA IEEE 802.1X enabled in configuration - 3515 * use non-WPA since the scan results did not indicate that the 3516 * AP is using WPA or WPA2. 3517 */ 3518 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 3519 wpa_ie_len = 0; 3520 wpa_s->wpa_proto = 0; 3521 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) { 3522 wpa_ie_len = max_wpa_ie_len; 3523 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid, 3524 wpa_ie, &wpa_ie_len, false)) { 3525 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA " 3526 "key management and encryption suites (no " 3527 "scan results)"); 3528 os_free(wpa_ie); 3529 return NULL; 3530 } 3531 #ifdef CONFIG_WPS 3532 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) { 3533 struct wpabuf *wps_ie; 3534 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid)); 3535 if (wps_ie && wpabuf_len(wps_ie) <= max_wpa_ie_len) { 3536 wpa_ie_len = wpabuf_len(wps_ie); 3537 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len); 3538 } else 3539 wpa_ie_len = 0; 3540 wpabuf_free(wps_ie); 3541 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 3542 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY)) 3543 params->wps = WPS_MODE_PRIVACY; 3544 else 3545 params->wps = WPS_MODE_OPEN; 3546 wpa_s->wpa_proto = 0; 3547 #endif /* CONFIG_WPS */ 3548 } else { 3549 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 3550 wpa_ie_len = 0; 3551 wpa_s->wpa_proto = 0; 3552 } 3553 3554 #ifdef IEEE8021X_EAPOL 3555 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 3556 if (ssid->leap) { 3557 if (ssid->non_leap == 0) 3558 algs = WPA_AUTH_ALG_LEAP; 3559 else 3560 algs |= WPA_AUTH_ALG_LEAP; 3561 } 3562 } 3563 3564 #ifdef CONFIG_FILS 3565 /* Clear FILS association */ 3566 wpa_sm_set_reset_fils_completed(wpa_s->wpa, 0); 3567 3568 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) && 3569 ssid->eap.erp && wpa_key_mgmt_fils(wpa_s->key_mgmt) && 3570 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, &username, 3571 &username_len, &realm, &realm_len, 3572 &next_seq_num, &rrk, &rrk_len) == 0 && 3573 (!wpa_s->last_con_fail_realm || 3574 wpa_s->last_con_fail_realm_len != realm_len || 3575 os_memcmp(wpa_s->last_con_fail_realm, realm, realm_len) != 0)) { 3576 algs = WPA_AUTH_ALG_FILS; 3577 params->fils_erp_username = username; 3578 params->fils_erp_username_len = username_len; 3579 params->fils_erp_realm = realm; 3580 params->fils_erp_realm_len = realm_len; 3581 params->fils_erp_next_seq_num = next_seq_num; 3582 params->fils_erp_rrk = rrk; 3583 params->fils_erp_rrk_len = rrk_len; 3584 3585 if (mask) 3586 *mask |= WPA_DRV_UPDATE_FILS_ERP_INFO; 3587 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_FILS_SK_OFFLOAD) && 3588 ssid->eap.erp && wpa_key_mgmt_fils(wpa_s->key_mgmt) && 3589 pmksa_cached) { 3590 algs = WPA_AUTH_ALG_FILS; 3591 } 3592 #endif /* CONFIG_FILS */ 3593 #endif /* IEEE8021X_EAPOL */ 3594 #ifdef CONFIG_SAE 3595 if (wpa_key_mgmt_sae(wpa_s->key_mgmt)) 3596 algs = WPA_AUTH_ALG_SAE; 3597 #endif /* CONFIG_SAE */ 3598 3599 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs); 3600 if (ssid->auth_alg) { 3601 algs = ssid->auth_alg; 3602 wpa_dbg(wpa_s, MSG_DEBUG, 3603 "Overriding auth_alg selection: 0x%x", algs); 3604 } 3605 3606 #ifdef CONFIG_SAE 3607 if (pmksa_cached && algs == WPA_AUTH_ALG_SAE) { 3608 wpa_dbg(wpa_s, MSG_DEBUG, 3609 "SAE: Use WPA_AUTH_ALG_OPEN for PMKSA caching attempt"); 3610 algs = WPA_AUTH_ALG_OPEN; 3611 } 3612 #endif /* CONFIG_SAE */ 3613 3614 #ifdef CONFIG_P2P 3615 if (wpa_s->global->p2p) { 3616 u8 *pos; 3617 size_t len; 3618 int res; 3619 pos = wpa_ie + wpa_ie_len; 3620 len = max_wpa_ie_len - wpa_ie_len; 3621 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len, 3622 ssid->p2p_group); 3623 if (res >= 0) 3624 wpa_ie_len += res; 3625 } 3626 3627 wpa_s->cross_connect_disallowed = 0; 3628 if (bss) { 3629 struct wpabuf *p2p; 3630 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE); 3631 if (p2p) { 3632 wpa_s->cross_connect_disallowed = 3633 p2p_get_cross_connect_disallowed(p2p); 3634 wpabuf_free(p2p); 3635 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross " 3636 "connection", 3637 wpa_s->cross_connect_disallowed ? 3638 "disallows" : "allows"); 3639 } 3640 } 3641 3642 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info)); 3643 #endif /* CONFIG_P2P */ 3644 3645 #ifndef CONFIG_NO_RRM 3646 if (bss) { 3647 wpa_ie_len += wpas_supp_op_class_ie(wpa_s, ssid, bss, 3648 wpa_ie + wpa_ie_len, 3649 max_wpa_ie_len - 3650 wpa_ie_len); 3651 } 3652 #endif /* CONFIG_NO_RRM */ 3653 3654 /* 3655 * Workaround: Add Extended Capabilities element only if the AP 3656 * included this element in Beacon/Probe Response frames. Some older 3657 * APs seem to have interoperability issues if this element is 3658 * included, so while the standard may require us to include the 3659 * element in all cases, it is justifiable to skip it to avoid 3660 * interoperability issues. 3661 */ 3662 if (ssid->p2p_group) 3663 wpa_drv_get_ext_capa(wpa_s, WPA_IF_P2P_CLIENT); 3664 else 3665 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION); 3666 3667 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) { 3668 u8 ext_capab[18]; 3669 int ext_capab_len; 3670 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab, 3671 sizeof(ext_capab), bss); 3672 if (ext_capab_len > 0 && 3673 wpa_ie_len + ext_capab_len <= max_wpa_ie_len) { 3674 u8 *pos = wpa_ie; 3675 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN) 3676 pos += 2 + pos[1]; 3677 os_memmove(pos + ext_capab_len, pos, 3678 wpa_ie_len - (pos - wpa_ie)); 3679 wpa_ie_len += ext_capab_len; 3680 os_memcpy(pos, ext_capab, ext_capab_len); 3681 } 3682 } 3683 3684 if (ssid->max_idle && wpa_ie_len + 5 <= max_wpa_ie_len) { 3685 u8 *pos = wpa_ie; 3686 3687 *pos++ = WLAN_EID_BSS_MAX_IDLE_PERIOD; 3688 *pos++ = 3; 3689 WPA_PUT_LE16(pos, ssid->max_idle); 3690 pos += 2; 3691 *pos = 0; /* Idle Options */ 3692 wpa_ie_len += 5; 3693 } 3694 3695 #ifdef CONFIG_HS20 3696 if (is_hs20_network(wpa_s, ssid, bss)) { 3697 struct wpabuf *hs20; 3698 3699 hs20 = wpabuf_alloc(20 + MAX_ROAMING_CONS_OI_LEN); 3700 if (hs20) { 3701 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid); 3702 size_t len; 3703 3704 wpas_hs20_add_indication(hs20, pps_mo_id, 3705 get_hs20_version(bss)); 3706 wpas_hs20_add_roam_cons_sel(hs20, ssid); 3707 len = max_wpa_ie_len - wpa_ie_len; 3708 if (wpabuf_len(hs20) <= len) { 3709 os_memcpy(wpa_ie + wpa_ie_len, 3710 wpabuf_head(hs20), wpabuf_len(hs20)); 3711 wpa_ie_len += wpabuf_len(hs20); 3712 } 3713 wpabuf_free(hs20); 3714 3715 hs20_configure_frame_filters(wpa_s); 3716 } 3717 } 3718 #endif /* CONFIG_HS20 */ 3719 3720 if (wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]) { 3721 struct wpabuf *buf = wpa_s->vendor_elem[VENDOR_ELEM_ASSOC_REQ]; 3722 size_t len; 3723 3724 len = max_wpa_ie_len - wpa_ie_len; 3725 if (wpabuf_len(buf) <= len) { 3726 os_memcpy(wpa_ie + wpa_ie_len, 3727 wpabuf_head(buf), wpabuf_len(buf)); 3728 wpa_ie_len += wpabuf_len(buf); 3729 } 3730 } 3731 3732 #ifdef CONFIG_FST 3733 if (wpa_s->fst_ies) { 3734 int fst_ies_len = wpabuf_len(wpa_s->fst_ies); 3735 3736 if (wpa_ie_len + fst_ies_len <= max_wpa_ie_len) { 3737 os_memcpy(wpa_ie + wpa_ie_len, 3738 wpabuf_head(wpa_s->fst_ies), fst_ies_len); 3739 wpa_ie_len += fst_ies_len; 3740 } 3741 } 3742 #endif /* CONFIG_FST */ 3743 3744 #ifdef CONFIG_MBO 3745 mbo_ie = bss ? wpa_bss_get_vendor_ie(bss, MBO_IE_VENDOR_TYPE) : NULL; 3746 if (!wpa_s->disable_mbo_oce && mbo_ie) { 3747 int len; 3748 3749 len = wpas_mbo_ie(wpa_s, wpa_ie + wpa_ie_len, 3750 max_wpa_ie_len - wpa_ie_len, 3751 !!mbo_attr_from_mbo_ie(mbo_ie, 3752 OCE_ATTR_ID_CAPA_IND)); 3753 if (len >= 0) 3754 wpa_ie_len += len; 3755 } 3756 #endif /* CONFIG_MBO */ 3757 3758 #ifdef CONFIG_FILS 3759 if (algs == WPA_AUTH_ALG_FILS) { 3760 size_t len; 3761 3762 len = wpas_add_fils_hlp_req(wpa_s, wpa_ie + wpa_ie_len, 3763 max_wpa_ie_len - wpa_ie_len); 3764 wpa_ie_len += len; 3765 } 3766 #endif /* CONFIG_FILS */ 3767 3768 #ifdef CONFIG_OWE 3769 #ifdef CONFIG_TESTING_OPTIONS 3770 if (get_ie_ext(wpa_ie, wpa_ie_len, WLAN_EID_EXT_OWE_DH_PARAM)) { 3771 wpa_printf(MSG_INFO, "TESTING: Override OWE DH element"); 3772 } else 3773 #endif /* CONFIG_TESTING_OPTIONS */ 3774 if (algs == WPA_AUTH_ALG_OPEN && 3775 ssid->key_mgmt == WPA_KEY_MGMT_OWE && 3776 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_OWE_OFFLOAD_STA)) { 3777 struct wpabuf *owe_ie; 3778 u16 group; 3779 3780 if (ssid->owe_group) { 3781 group = ssid->owe_group; 3782 } else if (wpa_s->assoc_status_code == 3783 WLAN_STATUS_FINITE_CYCLIC_GROUP_NOT_SUPPORTED) { 3784 if (wpa_s->last_owe_group == 19) 3785 group = 20; 3786 else if (wpa_s->last_owe_group == 20) 3787 group = 21; 3788 else 3789 group = OWE_DH_GROUP; 3790 } else { 3791 group = OWE_DH_GROUP; 3792 } 3793 3794 wpa_s->last_owe_group = group; 3795 wpa_printf(MSG_DEBUG, "OWE: Try to use group %u", group); 3796 owe_ie = owe_build_assoc_req(wpa_s->wpa, group); 3797 if (owe_ie && 3798 wpabuf_len(owe_ie) <= max_wpa_ie_len - wpa_ie_len) { 3799 os_memcpy(wpa_ie + wpa_ie_len, 3800 wpabuf_head(owe_ie), wpabuf_len(owe_ie)); 3801 wpa_ie_len += wpabuf_len(owe_ie); 3802 } 3803 wpabuf_free(owe_ie); 3804 } 3805 #endif /* CONFIG_OWE */ 3806 3807 #ifdef CONFIG_DPP2 3808 if (DPP_VERSION > 1 && 3809 wpa_sm_get_key_mgmt(wpa_s->wpa) == WPA_KEY_MGMT_DPP && 3810 ssid->dpp_netaccesskey && 3811 ssid->dpp_pfs != 2 && !ssid->dpp_pfs_fallback) { 3812 struct rsn_pmksa_cache_entry *pmksa; 3813 3814 pmksa = pmksa_cache_get_current(wpa_s->wpa); 3815 if (!pmksa || !pmksa->dpp_pfs) 3816 goto pfs_fail; 3817 3818 dpp_pfs_free(wpa_s->dpp_pfs); 3819 wpa_s->dpp_pfs = dpp_pfs_init(ssid->dpp_netaccesskey, 3820 ssid->dpp_netaccesskey_len); 3821 if (!wpa_s->dpp_pfs) { 3822 wpa_printf(MSG_DEBUG, "DPP: Could not initialize PFS"); 3823 /* Try to continue without PFS */ 3824 goto pfs_fail; 3825 } 3826 if (wpabuf_len(wpa_s->dpp_pfs->ie) <= 3827 max_wpa_ie_len - wpa_ie_len) { 3828 os_memcpy(wpa_ie + wpa_ie_len, 3829 wpabuf_head(wpa_s->dpp_pfs->ie), 3830 wpabuf_len(wpa_s->dpp_pfs->ie)); 3831 wpa_ie_len += wpabuf_len(wpa_s->dpp_pfs->ie); 3832 } 3833 } 3834 pfs_fail: 3835 #endif /* CONFIG_DPP2 */ 3836 3837 #ifdef CONFIG_IEEE80211R 3838 /* 3839 * Add MDIE under these conditions: the network profile allows FT, 3840 * the AP supports FT, and the mobility domain ID matches. 3841 */ 3842 if (bss && wpa_key_mgmt_ft(wpa_sm_get_key_mgmt(wpa_s->wpa))) { 3843 const u8 *mdie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN); 3844 3845 if (mdie && mdie[1] >= MOBILITY_DOMAIN_ID_LEN) { 3846 size_t len = 0; 3847 const u8 *md = mdie + 2; 3848 const u8 *wpa_md = wpa_sm_get_ft_md(wpa_s->wpa); 3849 3850 if (os_memcmp(md, wpa_md, 3851 MOBILITY_DOMAIN_ID_LEN) == 0) { 3852 /* Add mobility domain IE */ 3853 len = wpa_ft_add_mdie( 3854 wpa_s->wpa, wpa_ie + wpa_ie_len, 3855 max_wpa_ie_len - wpa_ie_len, mdie); 3856 wpa_ie_len += len; 3857 } 3858 #ifdef CONFIG_SME 3859 if (len > 0 && wpa_s->sme.ft_used && 3860 wpa_sm_has_ft_keys(wpa_s->wpa, md)) { 3861 wpa_dbg(wpa_s, MSG_DEBUG, 3862 "SME: Trying to use FT over-the-air"); 3863 algs |= WPA_AUTH_ALG_FT; 3864 } 3865 #endif /* CONFIG_SME */ 3866 } 3867 } 3868 #endif /* CONFIG_IEEE80211R */ 3869 3870 #ifdef CONFIG_TESTING_OPTIONS 3871 if (wpa_s->rsnxe_override_assoc && 3872 wpabuf_len(wpa_s->rsnxe_override_assoc) <= 3873 max_wpa_ie_len - wpa_ie_len) { 3874 wpa_printf(MSG_DEBUG, "TESTING: RSNXE AssocReq override"); 3875 os_memcpy(wpa_ie + wpa_ie_len, 3876 wpabuf_head(wpa_s->rsnxe_override_assoc), 3877 wpabuf_len(wpa_s->rsnxe_override_assoc)); 3878 wpa_ie_len += wpabuf_len(wpa_s->rsnxe_override_assoc); 3879 } else 3880 #endif /* CONFIG_TESTING_OPTIONS */ 3881 if (wpa_s->rsnxe_len > 0 && 3882 wpa_s->rsnxe_len <= max_wpa_ie_len - wpa_ie_len) { 3883 os_memcpy(wpa_ie + wpa_ie_len, wpa_s->rsnxe, wpa_s->rsnxe_len); 3884 wpa_ie_len += wpa_s->rsnxe_len; 3885 } 3886 3887 #ifndef CONFIG_NO_ROBUST_AV 3888 #ifdef CONFIG_TESTING_OPTIONS 3889 if (wpa_s->disable_mscs_support) 3890 goto mscs_end; 3891 #endif /* CONFIG_TESTING_OPTIONS */ 3892 if (wpa_bss_ext_capab(bss, WLAN_EXT_CAPAB_MSCS) && 3893 wpa_s->robust_av.valid_config) { 3894 struct wpabuf *mscs_ie; 3895 size_t mscs_ie_len, buf_len; 3896 3897 buf_len = 3 + /* MSCS descriptor IE header */ 3898 1 + /* Request type */ 3899 2 + /* User priority control */ 3900 4 + /* Stream timeout */ 3901 3 + /* TCLAS Mask IE header */ 3902 wpa_s->robust_av.frame_classifier_len; 3903 mscs_ie = wpabuf_alloc(buf_len); 3904 if (!mscs_ie) { 3905 wpa_printf(MSG_INFO, 3906 "MSCS: Failed to allocate MSCS IE"); 3907 goto mscs_end; 3908 } 3909 3910 wpas_populate_mscs_descriptor_ie(&wpa_s->robust_av, mscs_ie); 3911 if ((wpa_ie_len + wpabuf_len(mscs_ie)) <= max_wpa_ie_len) { 3912 wpa_hexdump_buf(MSG_MSGDUMP, "MSCS IE", mscs_ie); 3913 mscs_ie_len = wpabuf_len(mscs_ie); 3914 os_memcpy(wpa_ie + wpa_ie_len, wpabuf_head(mscs_ie), 3915 mscs_ie_len); 3916 wpa_ie_len += mscs_ie_len; 3917 } 3918 3919 wpabuf_free(mscs_ie); 3920 } 3921 mscs_end: 3922 #endif /* CONFIG_NO_ROBUST_AV */ 3923 3924 wpa_ie_len = wpas_populate_wfa_capa(wpa_s, bss, wpa_ie, wpa_ie_len, 3925 max_wpa_ie_len); 3926 3927 if (ssid->multi_ap_backhaul_sta) { 3928 size_t multi_ap_ie_len; 3929 struct multi_ap_params multi_ap = { 0 }; 3930 3931 multi_ap.capability = MULTI_AP_BACKHAUL_STA; 3932 multi_ap.profile = ssid->multi_ap_profile; 3933 3934 multi_ap_ie_len = add_multi_ap_ie(wpa_ie + wpa_ie_len, 3935 max_wpa_ie_len - wpa_ie_len, 3936 &multi_ap); 3937 if (multi_ap_ie_len == 0) { 3938 wpa_printf(MSG_ERROR, 3939 "Multi-AP: Failed to build Multi-AP IE"); 3940 os_free(wpa_ie); 3941 return NULL; 3942 } 3943 wpa_ie_len += multi_ap_ie_len; 3944 } 3945 3946 params->wpa_ie = wpa_ie; 3947 params->wpa_ie_len = wpa_ie_len; 3948 params->auth_alg = algs; 3949 if (mask) 3950 *mask |= WPA_DRV_UPDATE_ASSOC_IES | WPA_DRV_UPDATE_AUTH_TYPE; 3951 3952 return wpa_ie; 3953 } 3954 3955 3956 #ifdef CONFIG_OWE 3957 static void wpas_update_owe_connect_params(struct wpa_supplicant *wpa_s) 3958 { 3959 struct wpa_driver_associate_params params; 3960 u8 *wpa_ie; 3961 3962 os_memset(¶ms, 0, sizeof(params)); 3963 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss, 3964 wpa_s->current_ssid, ¶ms, NULL); 3965 if (!wpa_ie) 3966 return; 3967 3968 wpa_drv_update_connect_params(wpa_s, ¶ms, WPA_DRV_UPDATE_ASSOC_IES); 3969 os_free(wpa_ie); 3970 } 3971 #endif /* CONFIG_OWE */ 3972 3973 3974 #if defined(CONFIG_FILS) && defined(IEEE8021X_EAPOL) 3975 static void wpas_update_fils_connect_params(struct wpa_supplicant *wpa_s) 3976 { 3977 struct wpa_driver_associate_params params; 3978 enum wpa_drv_update_connect_params_mask mask = 0; 3979 u8 *wpa_ie; 3980 3981 if (wpa_s->auth_alg != WPA_AUTH_ALG_OPEN) 3982 return; /* nothing to do */ 3983 3984 os_memset(¶ms, 0, sizeof(params)); 3985 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss, 3986 wpa_s->current_ssid, ¶ms, &mask); 3987 if (!wpa_ie) 3988 return; 3989 3990 if (params.auth_alg == WPA_AUTH_ALG_FILS) { 3991 wpa_s->auth_alg = params.auth_alg; 3992 wpa_drv_update_connect_params(wpa_s, ¶ms, mask); 3993 } 3994 3995 os_free(wpa_ie); 3996 } 3997 #endif /* CONFIG_FILS && IEEE8021X_EAPOL */ 3998 3999 4000 static u8 wpa_ie_get_edmg_oper_chans(const u8 *edmg_ie) 4001 { 4002 if (!edmg_ie || edmg_ie[1] < 6) 4003 return 0; 4004 return edmg_ie[EDMG_BSS_OPERATING_CHANNELS_OFFSET]; 4005 } 4006 4007 4008 static u8 wpa_ie_get_edmg_oper_chan_width(const u8 *edmg_ie) 4009 { 4010 if (!edmg_ie || edmg_ie[1] < 6) 4011 return 0; 4012 return edmg_ie[EDMG_OPERATING_CHANNEL_WIDTH_OFFSET]; 4013 } 4014 4015 4016 /* Returns the intersection of two EDMG configurations. 4017 * Note: The current implementation is limited to CB2 only (CB1 included), 4018 * i.e., the implementation supports up to 2 contiguous channels. 4019 * For supporting non-contiguous (aggregated) channels and for supporting 4020 * CB3 and above, this function will need to be extended. 4021 */ 4022 static struct ieee80211_edmg_config 4023 get_edmg_intersection(struct ieee80211_edmg_config a, 4024 struct ieee80211_edmg_config b, 4025 u8 primary_channel) 4026 { 4027 struct ieee80211_edmg_config result; 4028 int i, contiguous = 0; 4029 int max_contiguous = 0; 4030 4031 result.channels = b.channels & a.channels; 4032 if (!result.channels) { 4033 wpa_printf(MSG_DEBUG, 4034 "EDMG not possible: cannot intersect channels 0x%x and 0x%x", 4035 a.channels, b.channels); 4036 goto fail; 4037 } 4038 4039 if (!(result.channels & BIT(primary_channel - 1))) { 4040 wpa_printf(MSG_DEBUG, 4041 "EDMG not possible: the primary channel %d is not one of the intersected channels 0x%x", 4042 primary_channel, result.channels); 4043 goto fail; 4044 } 4045 4046 /* Find max contiguous channels */ 4047 for (i = 0; i < 6; i++) { 4048 if (result.channels & BIT(i)) 4049 contiguous++; 4050 else 4051 contiguous = 0; 4052 4053 if (contiguous > max_contiguous) 4054 max_contiguous = contiguous; 4055 } 4056 4057 /* Assuming AP and STA supports ONLY contiguous channels, 4058 * bw configuration can have value between 4-7. 4059 */ 4060 if ((b.bw_config < a.bw_config)) 4061 result.bw_config = b.bw_config; 4062 else 4063 result.bw_config = a.bw_config; 4064 4065 if ((max_contiguous >= 2 && result.bw_config < EDMG_BW_CONFIG_5) || 4066 (max_contiguous >= 1 && result.bw_config < EDMG_BW_CONFIG_4)) { 4067 wpa_printf(MSG_DEBUG, 4068 "EDMG not possible: not enough contiguous channels %d for supporting CB1 or CB2", 4069 max_contiguous); 4070 goto fail; 4071 } 4072 4073 return result; 4074 4075 fail: 4076 result.channels = 0; 4077 result.bw_config = 0; 4078 return result; 4079 } 4080 4081 4082 static struct ieee80211_edmg_config 4083 get_supported_edmg(struct wpa_supplicant *wpa_s, 4084 struct hostapd_freq_params *freq, 4085 struct ieee80211_edmg_config request_edmg) 4086 { 4087 enum hostapd_hw_mode hw_mode; 4088 struct hostapd_hw_modes *mode = NULL; 4089 u8 primary_channel; 4090 4091 if (!wpa_s->hw.modes) 4092 goto fail; 4093 4094 hw_mode = ieee80211_freq_to_chan(freq->freq, &primary_channel); 4095 if (hw_mode == NUM_HOSTAPD_MODES) 4096 goto fail; 4097 4098 mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, hw_mode, false); 4099 if (!mode) 4100 goto fail; 4101 4102 return get_edmg_intersection(mode->edmg, request_edmg, primary_channel); 4103 4104 fail: 4105 request_edmg.channels = 0; 4106 request_edmg.bw_config = 0; 4107 return request_edmg; 4108 } 4109 4110 4111 #ifdef CONFIG_MBO 4112 void wpas_update_mbo_connect_params(struct wpa_supplicant *wpa_s) 4113 { 4114 struct wpa_driver_associate_params params; 4115 u8 *wpa_ie; 4116 4117 /* 4118 * Update MBO connect params only in case of change of MBO attributes 4119 * when connected, if the AP support MBO. 4120 */ 4121 4122 if (wpa_s->wpa_state != WPA_COMPLETED || !wpa_s->current_ssid || 4123 !wpa_s->current_bss || 4124 !wpa_bss_get_vendor_ie(wpa_s->current_bss, MBO_IE_VENDOR_TYPE)) 4125 return; 4126 4127 os_memset(¶ms, 0, sizeof(params)); 4128 wpa_ie = wpas_populate_assoc_ies(wpa_s, wpa_s->current_bss, 4129 wpa_s->current_ssid, ¶ms, NULL); 4130 if (!wpa_ie) 4131 return; 4132 4133 wpa_drv_update_connect_params(wpa_s, ¶ms, WPA_DRV_UPDATE_ASSOC_IES); 4134 os_free(wpa_ie); 4135 } 4136 #endif /* CONFIG_MBO */ 4137 4138 4139 static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit) 4140 { 4141 struct wpa_connect_work *cwork = work->ctx; 4142 struct wpa_bss *bss = cwork->bss; 4143 struct wpa_ssid *ssid = cwork->ssid; 4144 struct wpa_supplicant *wpa_s = work->wpa_s; 4145 u8 *wpa_ie; 4146 const u8 *edmg_ie_oper; 4147 int use_crypt, ret, bssid_changed; 4148 unsigned int cipher_pairwise, cipher_group, cipher_group_mgmt; 4149 struct wpa_driver_associate_params params; 4150 u8 psk[PMK_LEN]; 4151 #if defined(CONFIG_WEP) || defined(IEEE8021X_EAPOL) 4152 int wep_keys_set = 0; 4153 #endif /* CONFIG_WEP || IEEE8021X_EAPOL */ 4154 int assoc_failed = 0; 4155 struct wpa_ssid *old_ssid; 4156 u8 prev_bssid[ETH_ALEN]; 4157 #ifdef CONFIG_HT_OVERRIDES 4158 struct ieee80211_ht_capabilities htcaps; 4159 struct ieee80211_ht_capabilities htcaps_mask; 4160 #endif /* CONFIG_HT_OVERRIDES */ 4161 #ifdef CONFIG_VHT_OVERRIDES 4162 struct ieee80211_vht_capabilities vhtcaps; 4163 struct ieee80211_vht_capabilities vhtcaps_mask; 4164 #endif /* CONFIG_VHT_OVERRIDES */ 4165 4166 wpa_s->roam_in_progress = false; 4167 #ifdef CONFIG_WNM 4168 wpa_s->bss_trans_mgmt_in_progress = false; 4169 #endif /* CONFIG_WNM */ 4170 4171 if (deinit) { 4172 if (work->started) { 4173 wpa_s->connect_work = NULL; 4174 4175 /* cancel possible auth. timeout */ 4176 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, 4177 NULL); 4178 } 4179 wpas_connect_work_free(cwork); 4180 return; 4181 } 4182 4183 wpa_s->connect_work = work; 4184 4185 if (cwork->bss_removed || !wpas_valid_bss_ssid(wpa_s, bss, ssid) || 4186 wpas_network_disabled(wpa_s, ssid)) { 4187 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt"); 4188 wpas_connect_work_done(wpa_s); 4189 return; 4190 } 4191 4192 /* 4193 * Set the current AP's BSSID (for non-MLO connection) or MLD address 4194 * (for MLO connection) as the previous BSSID for reassociation requests 4195 * handled by SME-in-driver. If wpa_supplicant is in disconnected state, 4196 * prev_bssid will be zero as both wpa_s->valid_links and wpa_s->bssid 4197 * will be zero. 4198 */ 4199 os_memcpy(prev_bssid, 4200 wpa_s->valid_links ? wpa_s->ap_mld_addr : wpa_s->bssid, 4201 ETH_ALEN); 4202 os_memset(¶ms, 0, sizeof(params)); 4203 wpa_s->reassociate = 0; 4204 wpa_s->eap_expected_failure = 0; 4205 4206 /* Starting new association, so clear the possibly used WPA IE from the 4207 * previous association. */ 4208 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 4209 wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0); 4210 wpa_s->rsnxe_len = 0; 4211 #ifndef CONFIG_NO_ROBUST_AV 4212 wpa_s->mscs_setup_done = false; 4213 #endif /* CONFIG_NO_ROBUST_AV */ 4214 4215 wpa_ie = wpas_populate_assoc_ies(wpa_s, bss, ssid, ¶ms, NULL); 4216 if (!wpa_ie) { 4217 wpas_connect_work_done(wpa_s); 4218 return; 4219 } 4220 4221 if (bss && 4222 (!wpas_driver_bss_selection(wpa_s) || wpas_wps_searching(wpa_s))) { 4223 #ifdef CONFIG_IEEE80211R 4224 const u8 *ie, *md = NULL; 4225 #endif /* CONFIG_IEEE80211R */ 4226 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR 4227 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid), 4228 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq); 4229 bssid_changed = !is_zero_ether_addr(wpa_s->bssid); 4230 os_memset(wpa_s->bssid, 0, ETH_ALEN); 4231 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN); 4232 if (bssid_changed) 4233 wpas_notify_bssid_changed(wpa_s); 4234 #ifdef CONFIG_IEEE80211R 4235 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN); 4236 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN) 4237 md = ie + 2; 4238 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0); 4239 if (md) { 4240 /* Prepare for the next transition */ 4241 wpa_ft_prepare_auth_request(wpa_s->wpa, ie); 4242 } 4243 #endif /* CONFIG_IEEE80211R */ 4244 #ifdef CONFIG_WPS 4245 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) && 4246 wpa_s->conf->ap_scan == 2 && 4247 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) { 4248 /* Use ap_scan==1 style network selection to find the network 4249 */ 4250 wpas_connect_work_done(wpa_s); 4251 wpa_s->scan_req = MANUAL_SCAN_REQ; 4252 wpa_s->reassociate = 1; 4253 wpa_supplicant_req_scan(wpa_s, 0, 0); 4254 os_free(wpa_ie); 4255 return; 4256 #endif /* CONFIG_WPS */ 4257 } else { 4258 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'", 4259 wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); 4260 if (bss) 4261 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN); 4262 else 4263 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 4264 } 4265 if (!wpa_s->pno) 4266 wpa_supplicant_cancel_sched_scan(wpa_s); 4267 4268 wpa_supplicant_cancel_scan(wpa_s); 4269 4270 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL); 4271 use_crypt = 1; 4272 cipher_pairwise = wpa_s->pairwise_cipher; 4273 cipher_group = wpa_s->group_cipher; 4274 cipher_group_mgmt = wpa_s->mgmt_group_cipher; 4275 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 4276 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 4277 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) 4278 use_crypt = 0; 4279 #ifdef CONFIG_WEP 4280 if (wpa_set_wep_keys(wpa_s, ssid)) { 4281 use_crypt = 1; 4282 wep_keys_set = 1; 4283 } 4284 #endif /* CONFIG_WEP */ 4285 } 4286 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) 4287 use_crypt = 0; 4288 4289 #ifdef IEEE8021X_EAPOL 4290 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 4291 if ((ssid->eapol_flags & 4292 (EAPOL_FLAG_REQUIRE_KEY_UNICAST | 4293 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 && 4294 !wep_keys_set) { 4295 use_crypt = 0; 4296 } else { 4297 /* Assume that dynamic WEP-104 keys will be used and 4298 * set cipher suites in order for drivers to expect 4299 * encryption. */ 4300 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104; 4301 } 4302 } 4303 #endif /* IEEE8021X_EAPOL */ 4304 4305 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 4306 /* Set the key before (and later after) association */ 4307 wpa_supplicant_set_wpa_none_key(wpa_s, ssid); 4308 } 4309 4310 /* Set current_ssid before changing state to ASSOCIATING, so that the 4311 * selected SSID is available to wpas_notify_state_changed(). */ 4312 old_ssid = wpa_s->current_ssid; 4313 wpa_s->current_ssid = ssid; 4314 4315 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING); 4316 if (bss) { 4317 params.ssid = bss->ssid; 4318 params.ssid_len = bss->ssid_len; 4319 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set || 4320 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) { 4321 wpa_printf(MSG_DEBUG, "Limit connection to BSSID " 4322 MACSTR " freq=%u MHz based on scan results " 4323 "(bssid_set=%d wps=%d)", 4324 MAC2STR(bss->bssid), bss->freq, 4325 ssid->bssid_set, 4326 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS); 4327 params.bssid = bss->bssid; 4328 params.freq.freq = bss->freq; 4329 } 4330 params.bssid_hint = bss->bssid; 4331 params.freq_hint = bss->freq; 4332 params.pbss = bss_is_pbss(bss); 4333 } else { 4334 if (ssid->bssid_hint_set) 4335 params.bssid_hint = ssid->bssid_hint; 4336 4337 params.ssid = ssid->ssid; 4338 params.ssid_len = ssid->ssid_len; 4339 params.pbss = (ssid->pbss != 2) ? ssid->pbss : 0; 4340 } 4341 4342 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set && 4343 wpa_s->conf->ap_scan == 2) { 4344 params.bssid = ssid->bssid; 4345 params.fixed_bssid = 1; 4346 } 4347 4348 /* Initial frequency for IBSS/mesh */ 4349 if ((ssid->mode == WPAS_MODE_IBSS || ssid->mode == WPAS_MODE_MESH) && 4350 ssid->frequency > 0 && params.freq.freq == 0) 4351 ibss_mesh_setup_freq(wpa_s, ssid, ¶ms.freq); 4352 4353 if (ssid->mode == WPAS_MODE_IBSS) { 4354 params.fixed_freq = ssid->fixed_freq; 4355 if (ssid->beacon_int) 4356 params.beacon_int = ssid->beacon_int; 4357 else 4358 params.beacon_int = wpa_s->conf->beacon_int; 4359 } 4360 4361 if (bss && ssid->enable_edmg) 4362 edmg_ie_oper = wpa_bss_get_ie_ext(bss, 4363 WLAN_EID_EXT_EDMG_OPERATION); 4364 else 4365 edmg_ie_oper = NULL; 4366 4367 if (edmg_ie_oper) { 4368 params.freq.edmg.channels = 4369 wpa_ie_get_edmg_oper_chans(edmg_ie_oper); 4370 params.freq.edmg.bw_config = 4371 wpa_ie_get_edmg_oper_chan_width(edmg_ie_oper); 4372 wpa_printf(MSG_DEBUG, 4373 "AP supports EDMG channels 0x%x, bw_config %d", 4374 params.freq.edmg.channels, 4375 params.freq.edmg.bw_config); 4376 4377 /* User may ask for specific EDMG channel for EDMG connection 4378 * (must be supported by AP) 4379 */ 4380 if (ssid->edmg_channel) { 4381 struct ieee80211_edmg_config configured_edmg; 4382 enum hostapd_hw_mode hw_mode; 4383 u8 primary_channel; 4384 4385 hw_mode = ieee80211_freq_to_chan(bss->freq, 4386 &primary_channel); 4387 if (hw_mode == NUM_HOSTAPD_MODES) 4388 goto edmg_fail; 4389 4390 hostapd_encode_edmg_chan(ssid->enable_edmg, 4391 ssid->edmg_channel, 4392 primary_channel, 4393 &configured_edmg); 4394 4395 if (ieee802_edmg_is_allowed(params.freq.edmg, 4396 configured_edmg)) { 4397 params.freq.edmg = configured_edmg; 4398 wpa_printf(MSG_DEBUG, 4399 "Use EDMG channel %d for connection", 4400 ssid->edmg_channel); 4401 } else { 4402 edmg_fail: 4403 params.freq.edmg.channels = 0; 4404 params.freq.edmg.bw_config = 0; 4405 wpa_printf(MSG_WARNING, 4406 "EDMG channel %d not supported by AP, fallback to DMG", 4407 ssid->edmg_channel); 4408 } 4409 } 4410 4411 if (params.freq.edmg.channels) { 4412 wpa_printf(MSG_DEBUG, 4413 "EDMG before: channels 0x%x, bw_config %d", 4414 params.freq.edmg.channels, 4415 params.freq.edmg.bw_config); 4416 params.freq.edmg = get_supported_edmg(wpa_s, 4417 ¶ms.freq, 4418 params.freq.edmg); 4419 wpa_printf(MSG_DEBUG, 4420 "EDMG after: channels 0x%x, bw_config %d", 4421 params.freq.edmg.channels, 4422 params.freq.edmg.bw_config); 4423 } 4424 } 4425 4426 params.pairwise_suite = cipher_pairwise; 4427 params.group_suite = cipher_group; 4428 params.mgmt_group_suite = cipher_group_mgmt; 4429 params.key_mgmt_suite = wpa_s->key_mgmt; 4430 params.allowed_key_mgmts = wpa_s->allowed_key_mgmts; 4431 params.wpa_proto = wpa_s->wpa_proto; 4432 wpa_s->auth_alg = params.auth_alg; 4433 params.mode = ssid->mode; 4434 params.bg_scan_period = ssid->bg_scan_period; 4435 #ifdef CONFIG_WEP 4436 { 4437 int i; 4438 4439 for (i = 0; i < NUM_WEP_KEYS; i++) { 4440 if (ssid->wep_key_len[i]) 4441 params.wep_key[i] = ssid->wep_key[i]; 4442 params.wep_key_len[i] = ssid->wep_key_len[i]; 4443 } 4444 params.wep_tx_keyidx = ssid->wep_tx_keyidx; 4445 } 4446 #endif /* CONFIG_WEP */ 4447 4448 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) && 4449 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK || 4450 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK || 4451 (params.allowed_key_mgmts & 4452 (WPA_KEY_MGMT_PSK | WPA_KEY_MGMT_FT_PSK)))) { 4453 params.passphrase = ssid->passphrase; 4454 if (wpa_supplicant_get_psk(wpa_s, bss, ssid, psk) == 0) 4455 params.psk = psk; 4456 } 4457 4458 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X) && 4459 (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X || 4460 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 || 4461 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B || 4462 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192 || 4463 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA384)) 4464 params.req_handshake_offload = 1; 4465 4466 if (wpa_s->conf->key_mgmt_offload) { 4467 if (params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X || 4468 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 || 4469 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B || 4470 params.key_mgmt_suite == 4471 WPA_KEY_MGMT_IEEE8021X_SUITE_B_192 || 4472 params.key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA384) 4473 params.req_key_mgmt_offload = 4474 ssid->proactive_key_caching < 0 ? 4475 wpa_s->conf->okc : ssid->proactive_key_caching; 4476 else 4477 params.req_key_mgmt_offload = 1; 4478 4479 if ((wpa_key_mgmt_wpa_psk_no_sae(params.key_mgmt_suite) || 4480 wpa_key_mgmt_wpa_psk_no_sae(params.allowed_key_mgmts)) && 4481 wpa_supplicant_get_psk(wpa_s, bss, ssid, psk) == 0) 4482 params.psk = psk; 4483 } 4484 4485 if ((wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA) && 4486 wpa_key_mgmt_sae(params.key_mgmt_suite)) { 4487 params.auth_alg = WPA_AUTH_ALG_SAE; 4488 if (ssid->sae_password) { 4489 params.sae_password = ssid->sae_password; 4490 params.sae_password_id = ssid->sae_password_id; 4491 } else if (ssid->passphrase) { 4492 params.passphrase = ssid->passphrase; 4493 } 4494 } 4495 4496 params.drop_unencrypted = use_crypt; 4497 4498 params.mgmt_frame_protection = wpas_get_ssid_pmf(wpa_s, ssid); 4499 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) { 4500 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN); 4501 struct wpa_ie_data ie; 4502 if (!wpas_driver_bss_selection(wpa_s) && rsn && 4503 wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 && 4504 ie.capabilities & 4505 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) { 4506 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports " 4507 "MFP: require MFP"); 4508 params.mgmt_frame_protection = 4509 MGMT_FRAME_PROTECTION_REQUIRED; 4510 #ifdef CONFIG_OWE 4511 } else if (!rsn && (ssid->key_mgmt & WPA_KEY_MGMT_OWE) && 4512 !ssid->owe_only) { 4513 params.mgmt_frame_protection = NO_MGMT_FRAME_PROTECTION; 4514 #endif /* CONFIG_OWE */ 4515 } 4516 } 4517 4518 params.p2p = ssid->p2p_group; 4519 4520 if (wpa_s->p2pdev->set_sta_uapsd) 4521 params.uapsd = wpa_s->p2pdev->sta_uapsd; 4522 else 4523 params.uapsd = -1; 4524 4525 #ifdef CONFIG_HT_OVERRIDES 4526 os_memset(&htcaps, 0, sizeof(htcaps)); 4527 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask)); 4528 params.htcaps = (u8 *) &htcaps; 4529 params.htcaps_mask = (u8 *) &htcaps_mask; 4530 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms); 4531 #endif /* CONFIG_HT_OVERRIDES */ 4532 #ifdef CONFIG_VHT_OVERRIDES 4533 os_memset(&vhtcaps, 0, sizeof(vhtcaps)); 4534 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask)); 4535 params.vhtcaps = &vhtcaps; 4536 params.vhtcaps_mask = &vhtcaps_mask; 4537 wpa_supplicant_apply_vht_overrides(wpa_s, ssid, ¶ms); 4538 #endif /* CONFIG_VHT_OVERRIDES */ 4539 #ifdef CONFIG_HE_OVERRIDES 4540 wpa_supplicant_apply_he_overrides(wpa_s, ssid, ¶ms); 4541 #endif /* CONFIG_HE_OVERRIDES */ 4542 wpa_supplicant_apply_eht_overrides(wpa_s, ssid, ¶ms); 4543 4544 #ifdef CONFIG_P2P 4545 /* 4546 * If multi-channel concurrency is not supported, check for any 4547 * frequency conflict. In case of any frequency conflict, remove the 4548 * least prioritized connection. 4549 */ 4550 if (wpa_s->num_multichan_concurrent < 2) { 4551 int freq, num; 4552 num = get_shared_radio_freqs(wpa_s, &freq, 1, false); 4553 if (num > 0 && freq > 0 && freq != params.freq.freq) { 4554 wpa_printf(MSG_DEBUG, 4555 "Assoc conflicting freq found (%d != %d)", 4556 freq, params.freq.freq); 4557 if (wpas_p2p_handle_frequency_conflicts( 4558 wpa_s, params.freq.freq, ssid) < 0) { 4559 wpas_connect_work_done(wpa_s); 4560 os_free(wpa_ie); 4561 return; 4562 } 4563 } 4564 } 4565 #endif /* CONFIG_P2P */ 4566 4567 if (wpa_s->reassoc_same_ess && !is_zero_ether_addr(prev_bssid) && 4568 old_ssid) 4569 params.prev_bssid = prev_bssid; 4570 4571 #ifdef CONFIG_SAE 4572 params.sae_pwe = wpa_s->conf->sae_pwe; 4573 #endif /* CONFIG_SAE */ 4574 4575 ret = wpa_drv_associate(wpa_s, ¶ms); 4576 forced_memzero(psk, sizeof(psk)); 4577 os_free(wpa_ie); 4578 if (ret < 0) { 4579 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver " 4580 "failed"); 4581 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_VALID_ERROR_CODES) { 4582 /* 4583 * The driver is known to mean what is saying, so we 4584 * can stop right here; the association will not 4585 * succeed. 4586 */ 4587 wpas_connection_failed(wpa_s, wpa_s->pending_bssid, 4588 NULL); 4589 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 4590 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 4591 return; 4592 } 4593 /* try to continue anyway; new association will be tried again 4594 * after timeout */ 4595 assoc_failed = 1; 4596 } 4597 4598 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 4599 /* Set the key after the association just in case association 4600 * cleared the previously configured key. */ 4601 wpa_supplicant_set_wpa_none_key(wpa_s, ssid); 4602 /* No need to timeout authentication since there is no key 4603 * management. */ 4604 wpa_supplicant_cancel_auth_timeout(wpa_s); 4605 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 4606 #ifdef CONFIG_IBSS_RSN 4607 } else if (ssid->mode == WPAS_MODE_IBSS && 4608 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE && 4609 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) { 4610 /* 4611 * RSN IBSS authentication is per-STA and we can disable the 4612 * per-BSSID authentication. 4613 */ 4614 wpa_supplicant_cancel_auth_timeout(wpa_s); 4615 #endif /* CONFIG_IBSS_RSN */ 4616 } else { 4617 /* Timeout for IEEE 802.11 authentication and association */ 4618 int timeout = 60; 4619 4620 if (assoc_failed) { 4621 /* give IBSS a bit more time */ 4622 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5; 4623 } else if (wpa_s->conf->ap_scan == 1) { 4624 /* give IBSS a bit more time */ 4625 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10; 4626 } 4627 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0); 4628 } 4629 4630 #ifdef CONFIG_WEP 4631 if (wep_keys_set && 4632 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) { 4633 /* Set static WEP keys again */ 4634 wpa_set_wep_keys(wpa_s, ssid); 4635 } 4636 #endif /* CONFIG_WEP */ 4637 4638 if (old_ssid && old_ssid != ssid) { 4639 /* 4640 * Do not allow EAP session resumption between different 4641 * network configurations. 4642 */ 4643 eapol_sm_invalidate_cached_session(wpa_s->eapol); 4644 } 4645 4646 if (!wpas_driver_bss_selection(wpa_s) || 4647 #ifdef CONFIG_P2P 4648 wpa_s->p2p_in_invitation || 4649 #endif /* CONFIG_P2P */ 4650 ssid->bssid_set) { 4651 wpa_s->current_bss = bss; 4652 #ifdef CONFIG_HS20 4653 hs20_configure_frame_filters(wpa_s); 4654 #endif /* CONFIG_HS20 */ 4655 } 4656 4657 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid); 4658 if (bss) 4659 wpa_sm_set_ssid(wpa_s->wpa, bss->ssid, bss->ssid_len); 4660 wpa_supplicant_initiate_eapol(wpa_s); 4661 if (old_ssid != wpa_s->current_ssid) 4662 wpas_notify_network_changed(wpa_s); 4663 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)) 4664 wpas_notify_auth_changed(wpa_s); 4665 } 4666 4667 4668 static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s, 4669 const u8 *addr) 4670 { 4671 struct wpa_ssid *old_ssid; 4672 4673 wpa_s->ml_connect_probe_ssid = NULL; 4674 wpa_s->ml_connect_probe_bss = NULL; 4675 wpas_connect_work_done(wpa_s); 4676 wpa_clear_keys(wpa_s, addr); 4677 old_ssid = wpa_s->current_ssid; 4678 wpa_supplicant_mark_disassoc(wpa_s); 4679 wpa_sm_set_config(wpa_s->wpa, NULL); 4680 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 4681 if (old_ssid != wpa_s->current_ssid) 4682 wpas_notify_network_changed(wpa_s); 4683 4684 #ifndef CONFIG_NO_ROBUST_AV 4685 wpas_scs_deinit(wpa_s); 4686 wpas_dscp_deinit(wpa_s); 4687 #endif /* CONFIG_NO_ROBUST_AV */ 4688 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 4689 } 4690 4691 4692 /** 4693 * wpa_supplicant_deauthenticate - Deauthenticate the current connection 4694 * @wpa_s: Pointer to wpa_supplicant data 4695 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame 4696 * 4697 * This function is used to request %wpa_supplicant to deauthenticate from the 4698 * current AP. 4699 */ 4700 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s, 4701 u16 reason_code) 4702 { 4703 u8 *addr = NULL; 4704 union wpa_event_data event; 4705 int zero_addr = 0; 4706 4707 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR 4708 " pending_bssid=" MACSTR 4709 " reason=%d (%s) state=%s valid_links=0x%x ap_mld_addr=" MACSTR, 4710 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid), 4711 reason_code, reason2str(reason_code), 4712 wpa_supplicant_state_txt(wpa_s->wpa_state), wpa_s->valid_links, 4713 MAC2STR(wpa_s->ap_mld_addr)); 4714 4715 if (wpa_s->valid_links && !is_zero_ether_addr(wpa_s->ap_mld_addr)) 4716 addr = wpa_s->ap_mld_addr; 4717 else if (!is_zero_ether_addr(wpa_s->pending_bssid) && 4718 (wpa_s->wpa_state == WPA_AUTHENTICATING || 4719 wpa_s->wpa_state == WPA_ASSOCIATING)) 4720 addr = wpa_s->pending_bssid; 4721 else if (!is_zero_ether_addr(wpa_s->bssid)) 4722 addr = wpa_s->bssid; 4723 else if (wpa_s->wpa_state == WPA_ASSOCIATING) { 4724 /* 4725 * When using driver-based BSS selection, we may not know the 4726 * BSSID with which we are currently trying to associate. We 4727 * need to notify the driver of this disconnection even in such 4728 * a case, so use the all zeros address here. 4729 */ 4730 addr = wpa_s->bssid; 4731 zero_addr = 1; 4732 } 4733 4734 if (wpa_s->enabled_4addr_mode && wpa_drv_set_4addr_mode(wpa_s, 0) == 0) 4735 wpa_s->enabled_4addr_mode = 0; 4736 4737 #ifdef CONFIG_TDLS 4738 wpa_tdls_teardown_peers(wpa_s->wpa); 4739 #endif /* CONFIG_TDLS */ 4740 4741 #ifdef CONFIG_MESH 4742 if (wpa_s->ifmsh) { 4743 struct mesh_conf *mconf; 4744 4745 mconf = wpa_s->ifmsh->mconf; 4746 wpa_msg(wpa_s, MSG_INFO, MESH_GROUP_REMOVED "%s", 4747 wpa_s->ifname); 4748 wpas_notify_mesh_group_removed(wpa_s, mconf->meshid, 4749 mconf->meshid_len, reason_code); 4750 wpa_supplicant_leave_mesh(wpa_s, true); 4751 } 4752 #endif /* CONFIG_MESH */ 4753 4754 if (addr) { 4755 wpa_drv_deauthenticate(wpa_s, addr, reason_code); 4756 os_memset(&event, 0, sizeof(event)); 4757 event.deauth_info.reason_code = reason_code; 4758 event.deauth_info.locally_generated = 1; 4759 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event); 4760 if (zero_addr) 4761 addr = NULL; 4762 } 4763 4764 wpa_supplicant_clear_connection(wpa_s, addr); 4765 } 4766 4767 4768 void wpa_supplicant_reconnect(struct wpa_supplicant *wpa_s) 4769 { 4770 wpa_s->own_reconnect_req = 1; 4771 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_UNSPECIFIED); 4772 4773 } 4774 4775 4776 static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s, 4777 struct wpa_ssid *ssid) 4778 { 4779 if (!ssid || !ssid->disabled || ssid->disabled == 2) 4780 return; 4781 4782 ssid->disabled = 0; 4783 ssid->owe_transition_bss_select_count = 0; 4784 wpas_clear_temp_disabled(wpa_s, ssid, 1); 4785 wpas_notify_network_enabled_changed(wpa_s, ssid); 4786 4787 /* 4788 * Try to reassociate since there is no current configuration and a new 4789 * network was made available. 4790 */ 4791 if (!wpa_s->current_ssid && !wpa_s->disconnected) 4792 wpa_s->reassociate = 1; 4793 } 4794 4795 4796 /** 4797 * wpa_supplicant_add_network - Add a new network 4798 * @wpa_s: wpa_supplicant structure for a network interface 4799 * Returns: The new network configuration or %NULL if operation failed 4800 * 4801 * This function performs the following operations: 4802 * 1. Adds a new network. 4803 * 2. Send network addition notification. 4804 * 3. Marks the network disabled. 4805 * 4. Set network default parameters. 4806 */ 4807 struct wpa_ssid * wpa_supplicant_add_network(struct wpa_supplicant *wpa_s) 4808 { 4809 struct wpa_ssid *ssid; 4810 4811 ssid = wpa_config_add_network(wpa_s->conf); 4812 if (!ssid) 4813 return NULL; 4814 wpas_notify_network_added(wpa_s, ssid); 4815 ssid->disabled = 1; 4816 wpa_config_set_network_defaults(ssid); 4817 4818 return ssid; 4819 } 4820 4821 4822 /** 4823 * wpa_supplicant_remove_network - Remove a configured network based on id 4824 * @wpa_s: wpa_supplicant structure for a network interface 4825 * @id: Unique network id to search for 4826 * Returns: 0 on success, or -1 if the network was not found, -2 if the network 4827 * could not be removed 4828 * 4829 * This function performs the following operations: 4830 * 1. Removes the network. 4831 * 2. Send network removal notification. 4832 * 3. Update internal state machines. 4833 * 4. Stop any running sched scans. 4834 */ 4835 int wpa_supplicant_remove_network(struct wpa_supplicant *wpa_s, int id) 4836 { 4837 struct wpa_ssid *ssid, *prev = wpa_s->current_ssid; 4838 int was_disabled; 4839 4840 ssid = wpa_config_get_network(wpa_s->conf, id); 4841 if (!ssid) 4842 return -1; 4843 wpas_notify_network_removed(wpa_s, ssid); 4844 4845 if (ssid == prev || !prev) { 4846 #ifdef CONFIG_SME 4847 wpa_s->sme.prev_bssid_set = 0; 4848 #endif /* CONFIG_SME */ 4849 /* 4850 * Invalidate the EAP session cache if the current or 4851 * previously used network is removed. 4852 */ 4853 eapol_sm_invalidate_cached_session(wpa_s->eapol); 4854 } 4855 4856 if (ssid == prev) { 4857 wpa_sm_set_config(wpa_s->wpa, NULL); 4858 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 4859 4860 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 4861 wpa_s->own_disconnect_req = 1; 4862 wpa_supplicant_deauthenticate(wpa_s, 4863 WLAN_REASON_DEAUTH_LEAVING); 4864 } 4865 4866 was_disabled = ssid->disabled; 4867 4868 if (wpa_config_remove_network(wpa_s->conf, id) < 0) 4869 return -2; 4870 4871 if (!was_disabled && wpa_s->sched_scanning) { 4872 wpa_printf(MSG_DEBUG, 4873 "Stop ongoing sched_scan to remove network from filters"); 4874 wpa_supplicant_cancel_sched_scan(wpa_s); 4875 wpa_supplicant_req_scan(wpa_s, 0, 0); 4876 } 4877 4878 return 0; 4879 } 4880 4881 4882 /** 4883 * wpa_supplicant_remove_all_networks - Remove all configured networks 4884 * @wpa_s: wpa_supplicant structure for a network interface 4885 * Returns: 0 on success (errors are currently ignored) 4886 * 4887 * This function performs the following operations: 4888 * 1. Remove all networks. 4889 * 2. Send network removal notifications. 4890 * 3. Update internal state machines. 4891 * 4. Stop any running sched scans. 4892 */ 4893 int wpa_supplicant_remove_all_networks(struct wpa_supplicant *wpa_s) 4894 { 4895 struct wpa_ssid *ssid; 4896 4897 if (wpa_s->drv_flags2 & 4898 (WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA | 4899 WPA_DRIVER_FLAGS2_OWE_OFFLOAD_STA)) 4900 wpa_drv_flush_pmkid(wpa_s); 4901 4902 if (wpa_s->sched_scanning) 4903 wpa_supplicant_cancel_sched_scan(wpa_s); 4904 4905 eapol_sm_invalidate_cached_session(wpa_s->eapol); 4906 if (wpa_s->current_ssid) { 4907 #ifdef CONFIG_SME 4908 wpa_s->sme.prev_bssid_set = 0; 4909 #endif /* CONFIG_SME */ 4910 wpa_sm_set_config(wpa_s->wpa, NULL); 4911 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 4912 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 4913 wpa_s->own_disconnect_req = 1; 4914 wpa_supplicant_deauthenticate( 4915 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 4916 } 4917 ssid = wpa_s->conf->ssid; 4918 while (ssid) { 4919 struct wpa_ssid *remove_ssid = ssid; 4920 int id; 4921 4922 id = ssid->id; 4923 ssid = ssid->next; 4924 wpas_notify_network_removed(wpa_s, remove_ssid); 4925 wpa_config_remove_network(wpa_s->conf, id); 4926 } 4927 return 0; 4928 } 4929 4930 4931 /** 4932 * wpa_supplicant_enable_network - Mark a configured network as enabled 4933 * @wpa_s: wpa_supplicant structure for a network interface 4934 * @ssid: wpa_ssid structure for a configured network or %NULL 4935 * 4936 * Enables the specified network or all networks if no network specified. 4937 */ 4938 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s, 4939 struct wpa_ssid *ssid) 4940 { 4941 if (ssid == NULL) { 4942 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) 4943 wpa_supplicant_enable_one_network(wpa_s, ssid); 4944 } else 4945 wpa_supplicant_enable_one_network(wpa_s, ssid); 4946 4947 if (wpa_s->reassociate && !wpa_s->disconnected && 4948 (!wpa_s->current_ssid || 4949 wpa_s->wpa_state == WPA_DISCONNECTED || 4950 wpa_s->wpa_state == WPA_SCANNING)) { 4951 if (wpa_s->sched_scanning) { 4952 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add " 4953 "new network to scan filters"); 4954 wpa_supplicant_cancel_sched_scan(wpa_s); 4955 } 4956 4957 if (wpa_supplicant_fast_associate(wpa_s) != 1) { 4958 wpa_s->scan_req = NORMAL_SCAN_REQ; 4959 wpa_supplicant_req_scan(wpa_s, 0, 0); 4960 } 4961 } 4962 } 4963 4964 4965 /** 4966 * wpa_supplicant_disable_network - Mark a configured network as disabled 4967 * @wpa_s: wpa_supplicant structure for a network interface 4968 * @ssid: wpa_ssid structure for a configured network or %NULL 4969 * 4970 * Disables the specified network or all networks if no network specified. 4971 */ 4972 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s, 4973 struct wpa_ssid *ssid) 4974 { 4975 struct wpa_ssid *other_ssid; 4976 int was_disabled; 4977 4978 if (ssid == NULL) { 4979 if (wpa_s->sched_scanning) 4980 wpa_supplicant_cancel_sched_scan(wpa_s); 4981 4982 for (other_ssid = wpa_s->conf->ssid; other_ssid; 4983 other_ssid = other_ssid->next) { 4984 was_disabled = other_ssid->disabled; 4985 if (was_disabled == 2) 4986 continue; /* do not change persistent P2P group 4987 * data */ 4988 4989 other_ssid->disabled = 1; 4990 4991 if (was_disabled != other_ssid->disabled) 4992 wpas_notify_network_enabled_changed( 4993 wpa_s, other_ssid); 4994 } 4995 if (wpa_s->current_ssid) { 4996 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 4997 wpa_s->own_disconnect_req = 1; 4998 wpa_supplicant_deauthenticate( 4999 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 5000 } 5001 } else if (ssid->disabled != 2) { 5002 if (ssid == wpa_s->current_ssid) { 5003 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 5004 wpa_s->own_disconnect_req = 1; 5005 wpa_supplicant_deauthenticate( 5006 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 5007 } 5008 5009 was_disabled = ssid->disabled; 5010 5011 ssid->disabled = 1; 5012 5013 if (was_disabled != ssid->disabled) { 5014 wpas_notify_network_enabled_changed(wpa_s, ssid); 5015 if (wpa_s->sched_scanning) { 5016 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan " 5017 "to remove network from filters"); 5018 wpa_supplicant_cancel_sched_scan(wpa_s); 5019 wpa_supplicant_req_scan(wpa_s, 0, 0); 5020 } 5021 } 5022 } 5023 } 5024 5025 5026 /** 5027 * wpa_supplicant_select_network - Attempt association with a network 5028 * @wpa_s: wpa_supplicant structure for a network interface 5029 * @ssid: wpa_ssid structure for a configured network or %NULL for any network 5030 */ 5031 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s, 5032 struct wpa_ssid *ssid) 5033 { 5034 5035 struct wpa_ssid *other_ssid; 5036 int disconnected = 0; 5037 5038 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) { 5039 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 5040 wpa_s->own_disconnect_req = 1; 5041 wpa_supplicant_deauthenticate( 5042 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 5043 disconnected = 1; 5044 } 5045 5046 if (ssid) 5047 wpas_clear_temp_disabled(wpa_s, ssid, 1); 5048 5049 /* 5050 * Mark all other networks disabled or mark all networks enabled if no 5051 * network specified. 5052 */ 5053 for (other_ssid = wpa_s->conf->ssid; other_ssid; 5054 other_ssid = other_ssid->next) { 5055 int was_disabled = other_ssid->disabled; 5056 if (was_disabled == 2) 5057 continue; /* do not change persistent P2P group data */ 5058 5059 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0; 5060 if (was_disabled && !other_ssid->disabled) 5061 wpas_clear_temp_disabled(wpa_s, other_ssid, 0); 5062 5063 if (was_disabled != other_ssid->disabled) 5064 wpas_notify_network_enabled_changed(wpa_s, other_ssid); 5065 } 5066 5067 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid && 5068 wpa_s->wpa_state >= WPA_AUTHENTICATING) { 5069 /* We are already associated with the selected network */ 5070 wpa_printf(MSG_DEBUG, "Already associated with the " 5071 "selected network - do nothing"); 5072 return; 5073 } 5074 5075 if (ssid) { 5076 wpa_s->current_ssid = ssid; 5077 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 5078 wpa_s->connect_without_scan = 5079 (ssid->mode == WPAS_MODE_MESH || 5080 ssid->mode == WPAS_MODE_AP) ? ssid : NULL; 5081 5082 /* 5083 * Don't optimize next scan freqs since a new ESS has been 5084 * selected. 5085 */ 5086 os_free(wpa_s->next_scan_freqs); 5087 wpa_s->next_scan_freqs = NULL; 5088 } else { 5089 wpa_s->connect_without_scan = NULL; 5090 } 5091 5092 wpa_s->disconnected = 0; 5093 wpa_s->reassociate = 1; 5094 wpa_s_clear_sae_rejected(wpa_s); 5095 wpa_s->last_owe_group = 0; 5096 if (ssid) { 5097 ssid->owe_transition_bss_select_count = 0; 5098 wpa_s_setup_sae_pt(wpa_s->conf, ssid, false); 5099 } 5100 5101 if (wpa_s->connect_without_scan || 5102 wpa_supplicant_fast_associate(wpa_s) != 1) { 5103 wpa_s->scan_req = NORMAL_SCAN_REQ; 5104 wpas_scan_reset_sched_scan(wpa_s); 5105 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0); 5106 } 5107 5108 if (ssid) 5109 wpas_notify_network_selected(wpa_s, ssid); 5110 } 5111 5112 5113 /** 5114 * wpas_remove_cred - Remove the specified credential and all the network 5115 * entries created based on the removed credential 5116 * @wpa_s: wpa_supplicant structure for a network interface 5117 * @cred: The credential to remove 5118 * Returns: 0 on success, -1 on failure 5119 */ 5120 int wpas_remove_cred(struct wpa_supplicant *wpa_s, struct wpa_cred *cred) 5121 { 5122 struct wpa_ssid *ssid, *next; 5123 int id; 5124 5125 if (!cred) { 5126 wpa_printf(MSG_DEBUG, "Could not find cred"); 5127 return -1; 5128 } 5129 5130 id = cred->id; 5131 if (wpa_config_remove_cred(wpa_s->conf, id) < 0) { 5132 wpa_printf(MSG_DEBUG, "Could not find cred %d", id); 5133 return -1; 5134 } 5135 5136 wpa_msg(wpa_s, MSG_INFO, CRED_REMOVED "%d", id); 5137 5138 /* Remove any network entry created based on the removed credential */ 5139 ssid = wpa_s->conf->ssid; 5140 while (ssid) { 5141 next = ssid->next; 5142 5143 if (ssid->parent_cred == cred) { 5144 wpa_printf(MSG_DEBUG, 5145 "Remove network id %d since it used the removed credential", 5146 ssid->id); 5147 if (wpa_supplicant_remove_network(wpa_s, ssid->id) == 5148 -1) { 5149 wpa_printf(MSG_DEBUG, 5150 "Could not find network id=%d", 5151 ssid->id); 5152 } 5153 } 5154 5155 ssid = next; 5156 } 5157 5158 return 0; 5159 } 5160 5161 5162 /** 5163 * wpas_remove_cred - Remove all the Interworking credentials 5164 * @wpa_s: wpa_supplicant structure for a network interface 5165 * Returns: 0 on success, -1 on failure 5166 */ 5167 int wpas_remove_all_creds(struct wpa_supplicant *wpa_s) 5168 { 5169 int res, ret = 0; 5170 struct wpa_cred *cred, *prev; 5171 5172 cred = wpa_s->conf->cred; 5173 while (cred) { 5174 prev = cred; 5175 cred = cred->next; 5176 res = wpas_remove_cred(wpa_s, prev); 5177 if (res < 0) { 5178 wpa_printf(MSG_DEBUG, 5179 "Removal of all credentials failed - failed to remove credential id=%d", 5180 prev->id); 5181 ret = -1; 5182 } 5183 } 5184 5185 return ret; 5186 } 5187 5188 5189 /** 5190 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path 5191 * @wpa_s: wpa_supplicant structure for a network interface 5192 * @pkcs11_engine_path: PKCS #11 engine path or NULL 5193 * @pkcs11_module_path: PKCS #11 module path or NULL 5194 * Returns: 0 on success; -1 on failure 5195 * 5196 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid 5197 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and 5198 * module path fails the paths will be reset to the default value (NULL). 5199 */ 5200 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s, 5201 const char *pkcs11_engine_path, 5202 const char *pkcs11_module_path) 5203 { 5204 char *pkcs11_engine_path_copy = NULL; 5205 char *pkcs11_module_path_copy = NULL; 5206 5207 if (pkcs11_engine_path != NULL) { 5208 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path); 5209 if (pkcs11_engine_path_copy == NULL) 5210 return -1; 5211 } 5212 if (pkcs11_module_path != NULL) { 5213 pkcs11_module_path_copy = os_strdup(pkcs11_module_path); 5214 if (pkcs11_module_path_copy == NULL) { 5215 os_free(pkcs11_engine_path_copy); 5216 return -1; 5217 } 5218 } 5219 5220 #ifndef CONFIG_PKCS11_ENGINE_PATH 5221 os_free(wpa_s->conf->pkcs11_engine_path); 5222 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy; 5223 #endif /* CONFIG_PKCS11_ENGINE_PATH */ 5224 #ifndef CONFIG_PKCS11_MODULE_PATH 5225 os_free(wpa_s->conf->pkcs11_module_path); 5226 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy; 5227 #endif /* CONFIG_PKCS11_MODULE_PATH */ 5228 5229 wpa_sm_set_eapol(wpa_s->wpa, NULL); 5230 eapol_sm_deinit(wpa_s->eapol); 5231 wpa_s->eapol = NULL; 5232 if (wpa_supplicant_init_eapol(wpa_s)) { 5233 /* Error -> Reset paths to the default value (NULL) once. */ 5234 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL) 5235 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL, 5236 NULL); 5237 5238 return -1; 5239 } 5240 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol); 5241 5242 return 0; 5243 } 5244 5245 5246 /** 5247 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface 5248 * @wpa_s: wpa_supplicant structure for a network interface 5249 * @ap_scan: AP scan mode 5250 * Returns: 0 if succeed or -1 if ap_scan has an invalid value 5251 * 5252 */ 5253 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan) 5254 { 5255 5256 int old_ap_scan; 5257 5258 if (ap_scan < 0 || ap_scan > 2) 5259 return -1; 5260 5261 if (ap_scan == 2 && os_strcmp(wpa_s->driver->name, "nl80211") == 0) { 5262 wpa_printf(MSG_INFO, 5263 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures"); 5264 } 5265 5266 #ifdef ANDROID 5267 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan && 5268 wpa_s->wpa_state >= WPA_ASSOCIATING && 5269 wpa_s->wpa_state < WPA_COMPLETED) { 5270 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while " 5271 "associating", wpa_s->conf->ap_scan, ap_scan); 5272 return 0; 5273 } 5274 #endif /* ANDROID */ 5275 5276 old_ap_scan = wpa_s->conf->ap_scan; 5277 wpa_s->conf->ap_scan = ap_scan; 5278 5279 if (old_ap_scan != wpa_s->conf->ap_scan) 5280 wpas_notify_ap_scan_changed(wpa_s); 5281 5282 return 0; 5283 } 5284 5285 5286 /** 5287 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age 5288 * @wpa_s: wpa_supplicant structure for a network interface 5289 * @expire_age: Expiration age in seconds 5290 * Returns: 0 if succeed or -1 if expire_age has an invalid value 5291 * 5292 */ 5293 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s, 5294 unsigned int bss_expire_age) 5295 { 5296 if (bss_expire_age < 10) { 5297 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u", 5298 bss_expire_age); 5299 return -1; 5300 } 5301 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec", 5302 bss_expire_age); 5303 wpa_s->conf->bss_expiration_age = bss_expire_age; 5304 5305 return 0; 5306 } 5307 5308 5309 /** 5310 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count 5311 * @wpa_s: wpa_supplicant structure for a network interface 5312 * @expire_count: number of scans after which an unseen BSS is reclaimed 5313 * Returns: 0 if succeed or -1 if expire_count has an invalid value 5314 * 5315 */ 5316 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s, 5317 unsigned int bss_expire_count) 5318 { 5319 if (bss_expire_count < 1) { 5320 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u", 5321 bss_expire_count); 5322 return -1; 5323 } 5324 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u", 5325 bss_expire_count); 5326 wpa_s->conf->bss_expiration_scan_count = bss_expire_count; 5327 5328 return 0; 5329 } 5330 5331 5332 /** 5333 * wpa_supplicant_set_scan_interval - Set scan interval 5334 * @wpa_s: wpa_supplicant structure for a network interface 5335 * @scan_interval: scan interval in seconds 5336 * Returns: 0 if succeed or -1 if scan_interval has an invalid value 5337 * 5338 */ 5339 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s, 5340 int scan_interval) 5341 { 5342 if (scan_interval < 0) { 5343 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d", 5344 scan_interval); 5345 return -1; 5346 } 5347 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec", 5348 scan_interval); 5349 wpa_supplicant_update_scan_int(wpa_s, scan_interval); 5350 5351 return 0; 5352 } 5353 5354 5355 /** 5356 * wpa_supplicant_set_debug_params - Set global debug params 5357 * @global: wpa_global structure 5358 * @debug_level: debug level 5359 * @debug_timestamp: determines if show timestamp in debug data 5360 * @debug_show_keys: determines if show keys in debug data 5361 * Returns: 0 if succeed or -1 if debug_level has wrong value 5362 */ 5363 int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level, 5364 int debug_timestamp, int debug_show_keys) 5365 { 5366 5367 int old_level, old_timestamp, old_show_keys; 5368 5369 /* check for allowed debuglevels */ 5370 if (debug_level != MSG_EXCESSIVE && 5371 debug_level != MSG_MSGDUMP && 5372 debug_level != MSG_DEBUG && 5373 debug_level != MSG_INFO && 5374 debug_level != MSG_WARNING && 5375 debug_level != MSG_ERROR) 5376 return -1; 5377 5378 old_level = wpa_debug_level; 5379 old_timestamp = wpa_debug_timestamp; 5380 old_show_keys = wpa_debug_show_keys; 5381 5382 wpa_debug_level = debug_level; 5383 wpa_debug_timestamp = debug_timestamp ? 1 : 0; 5384 wpa_debug_show_keys = debug_show_keys ? 1 : 0; 5385 5386 if (wpa_debug_level != old_level) 5387 wpas_notify_debug_level_changed(global); 5388 if (wpa_debug_timestamp != old_timestamp) 5389 wpas_notify_debug_timestamp_changed(global); 5390 if (wpa_debug_show_keys != old_show_keys) 5391 wpas_notify_debug_show_keys_changed(global); 5392 5393 return 0; 5394 } 5395 5396 5397 #ifdef CONFIG_OWE 5398 static int owe_trans_ssid_match(struct wpa_supplicant *wpa_s, const u8 *bssid, 5399 const u8 *entry_ssid, size_t entry_ssid_len) 5400 { 5401 const u8 *owe, *pos, *end; 5402 u8 ssid_len; 5403 struct wpa_bss *bss; 5404 5405 /* Check network profile SSID aganst the SSID in the 5406 * OWE Transition Mode element. */ 5407 5408 bss = wpa_bss_get_bssid_latest(wpa_s, bssid); 5409 if (!bss) 5410 return 0; 5411 5412 owe = wpa_bss_get_vendor_ie(bss, OWE_IE_VENDOR_TYPE); 5413 if (!owe) 5414 return 0; 5415 5416 pos = owe + 6; 5417 end = owe + 2 + owe[1]; 5418 5419 if (end - pos < ETH_ALEN + 1) 5420 return 0; 5421 pos += ETH_ALEN; 5422 ssid_len = *pos++; 5423 if (end - pos < ssid_len || ssid_len > SSID_MAX_LEN) 5424 return 0; 5425 5426 return entry_ssid_len == ssid_len && 5427 os_memcmp(pos, entry_ssid, ssid_len) == 0; 5428 } 5429 #endif /* CONFIG_OWE */ 5430 5431 5432 /** 5433 * wpa_supplicant_get_ssid - Get a pointer to the current network structure 5434 * @wpa_s: Pointer to wpa_supplicant data 5435 * Returns: A pointer to the current network structure or %NULL on failure 5436 */ 5437 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s) 5438 { 5439 struct wpa_ssid *entry; 5440 u8 ssid[SSID_MAX_LEN]; 5441 int res; 5442 size_t ssid_len; 5443 u8 bssid[ETH_ALEN]; 5444 int wired; 5445 5446 res = wpa_drv_get_ssid(wpa_s, ssid); 5447 if (res < 0) { 5448 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from " 5449 "driver"); 5450 return NULL; 5451 } 5452 ssid_len = res; 5453 5454 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) { 5455 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from " 5456 "driver"); 5457 return NULL; 5458 } 5459 5460 wired = wpa_s->conf->ap_scan == 0 && 5461 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED); 5462 5463 entry = wpa_s->conf->ssid; 5464 while (entry) { 5465 if (!wpas_network_disabled(wpa_s, entry) && 5466 ((ssid_len == entry->ssid_len && 5467 (!entry->ssid || 5468 os_memcmp(ssid, entry->ssid, ssid_len) == 0)) || 5469 wired) && 5470 (!entry->bssid_set || 5471 ether_addr_equal(bssid, entry->bssid))) 5472 return entry; 5473 #ifdef CONFIG_WPS 5474 if (!wpas_network_disabled(wpa_s, entry) && 5475 (entry->key_mgmt & WPA_KEY_MGMT_WPS) && 5476 (entry->ssid == NULL || entry->ssid_len == 0) && 5477 (!entry->bssid_set || 5478 ether_addr_equal(bssid, entry->bssid))) 5479 return entry; 5480 #endif /* CONFIG_WPS */ 5481 5482 #ifdef CONFIG_OWE 5483 if (!wpas_network_disabled(wpa_s, entry) && 5484 (entry->ssid && 5485 owe_trans_ssid_match(wpa_s, bssid, entry->ssid, 5486 entry->ssid_len)) && 5487 (!entry->bssid_set || 5488 ether_addr_equal(bssid, entry->bssid))) 5489 return entry; 5490 #endif /* CONFIG_OWE */ 5491 5492 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set && 5493 entry->ssid_len == 0 && 5494 ether_addr_equal(bssid, entry->bssid)) 5495 return entry; 5496 5497 entry = entry->next; 5498 } 5499 5500 return NULL; 5501 } 5502 5503 5504 static int select_driver(struct wpa_supplicant *wpa_s, int i) 5505 { 5506 struct wpa_global *global = wpa_s->global; 5507 5508 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) { 5509 global->drv_priv[i] = wpa_drivers[i]->global_init(global); 5510 if (global->drv_priv[i] == NULL) { 5511 wpa_printf(MSG_ERROR, "Failed to initialize driver " 5512 "'%s'", wpa_drivers[i]->name); 5513 return -1; 5514 } 5515 } 5516 5517 wpa_s->driver = wpa_drivers[i]; 5518 wpa_s->global_drv_priv = global->drv_priv[i]; 5519 5520 return 0; 5521 } 5522 5523 5524 static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s, 5525 const char *name) 5526 { 5527 int i; 5528 size_t len; 5529 const char *pos, *driver = name; 5530 5531 if (wpa_s == NULL) 5532 return -1; 5533 5534 if (wpa_drivers[0] == NULL) { 5535 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into " 5536 "wpa_supplicant"); 5537 return -1; 5538 } 5539 5540 if (name == NULL) { 5541 /* Default to first successful driver in the list */ 5542 for (i = 0; wpa_drivers[i]; i++) { 5543 if (select_driver(wpa_s, i) == 0) 5544 return 0; 5545 } 5546 /* Drivers have each reported failure, so no wpa_msg() here. */ 5547 return -1; 5548 } 5549 5550 do { 5551 pos = os_strchr(driver, ','); 5552 if (pos) 5553 len = pos - driver; 5554 else 5555 len = os_strlen(driver); 5556 5557 for (i = 0; wpa_drivers[i]; i++) { 5558 if (os_strlen(wpa_drivers[i]->name) == len && 5559 os_strncmp(driver, wpa_drivers[i]->name, len) == 5560 0) { 5561 /* First driver that succeeds wins */ 5562 if (select_driver(wpa_s, i) == 0) 5563 return 0; 5564 } 5565 } 5566 5567 driver = pos + 1; 5568 } while (pos); 5569 5570 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name); 5571 return -1; 5572 } 5573 5574 5575 /** 5576 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant 5577 * @ctx: Context pointer (wpa_s); this is the ctx variable registered 5578 * with struct wpa_driver_ops::init() 5579 * @src_addr: Source address of the EAPOL frame 5580 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header) 5581 * @len: Length of the EAPOL data 5582 * @encrypted: Whether the frame was encrypted 5583 * 5584 * This function is called for each received EAPOL frame. Most driver 5585 * interfaces rely on more generic OS mechanism for receiving frames through 5586 * l2_packet, but if such a mechanism is not available, the driver wrapper may 5587 * take care of received EAPOL frames and deliver them to the core supplicant 5588 * code by calling this function. 5589 */ 5590 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr, 5591 const u8 *buf, size_t len, 5592 enum frame_encryption encrypted) 5593 { 5594 struct wpa_supplicant *wpa_s = ctx; 5595 const u8 *connected_addr = wpa_s->valid_links ? 5596 wpa_s->ap_mld_addr : wpa_s->bssid; 5597 5598 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " (encrypted=%d)", 5599 MAC2STR(src_addr), encrypted); 5600 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len); 5601 5602 if (wpa_s->own_disconnect_req) { 5603 wpa_printf(MSG_DEBUG, 5604 "Drop received EAPOL frame as we are disconnecting"); 5605 return; 5606 } 5607 5608 #ifdef CONFIG_TESTING_OPTIONS 5609 wpa_msg_ctrl(wpa_s, MSG_INFO, "EAPOL-RX " MACSTR " %zu", 5610 MAC2STR(src_addr), len); 5611 if (wpa_s->ignore_auth_resp) { 5612 wpa_printf(MSG_INFO, "RX EAPOL - ignore_auth_resp active!"); 5613 return; 5614 } 5615 #endif /* CONFIG_TESTING_OPTIONS */ 5616 5617 if (wpa_s->wpa_state < WPA_ASSOCIATED || 5618 (wpa_s->last_eapol_matches_bssid && 5619 #ifdef CONFIG_AP 5620 !wpa_s->ap_iface && 5621 #endif /* CONFIG_AP */ 5622 !ether_addr_equal(src_addr, connected_addr))) { 5623 /* 5624 * There is possible race condition between receiving the 5625 * association event and the EAPOL frame since they are coming 5626 * through different paths from the driver. In order to avoid 5627 * issues in trying to process the EAPOL frame before receiving 5628 * association information, lets queue it for processing until 5629 * the association event is received. This may also be needed in 5630 * driver-based roaming case, so also use src_addr != BSSID as a 5631 * trigger if we have previously confirmed that the 5632 * Authenticator uses BSSID as the src_addr (which is not the 5633 * case with wired IEEE 802.1X). 5634 */ 5635 wpa_dbg(wpa_s, MSG_DEBUG, 5636 "Not associated - Delay processing of received EAPOL frame (state=%s connected_addr=" 5637 MACSTR ")", 5638 wpa_supplicant_state_txt(wpa_s->wpa_state), 5639 MAC2STR(connected_addr)); 5640 wpabuf_free(wpa_s->pending_eapol_rx); 5641 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len); 5642 if (wpa_s->pending_eapol_rx) { 5643 os_get_reltime(&wpa_s->pending_eapol_rx_time); 5644 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr, 5645 ETH_ALEN); 5646 wpa_s->pending_eapol_encrypted = encrypted; 5647 } 5648 return; 5649 } 5650 5651 wpa_s->last_eapol_matches_bssid = 5652 ether_addr_equal(src_addr, connected_addr); 5653 5654 #ifdef CONFIG_AP 5655 if (wpa_s->ap_iface) { 5656 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len, 5657 encrypted); 5658 return; 5659 } 5660 #endif /* CONFIG_AP */ 5661 5662 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) { 5663 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since " 5664 "no key management is configured"); 5665 return; 5666 } 5667 5668 if (wpa_s->eapol_received == 0 && 5669 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) || 5670 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || 5671 wpa_s->wpa_state != WPA_COMPLETED) && 5672 (wpa_s->current_ssid == NULL || 5673 wpa_s->current_ssid->mode != WPAS_MODE_IBSS)) { 5674 /* Timeout for completing IEEE 802.1X and WPA authentication */ 5675 int timeout = 10; 5676 5677 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) || 5678 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA || 5679 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) { 5680 /* Use longer timeout for IEEE 802.1X/EAP */ 5681 timeout = 70; 5682 } 5683 5684 #ifdef CONFIG_WPS 5685 if (wpa_s->current_ssid && wpa_s->current_bss && 5686 (wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) && 5687 eap_is_wps_pin_enrollee(&wpa_s->current_ssid->eap)) { 5688 /* 5689 * Use shorter timeout if going through WPS AP iteration 5690 * for PIN config method with an AP that does not 5691 * advertise Selected Registrar. 5692 */ 5693 struct wpabuf *wps_ie; 5694 5695 wps_ie = wpa_bss_get_vendor_ie_multi( 5696 wpa_s->current_bss, WPS_IE_VENDOR_TYPE); 5697 if (wps_ie && 5698 !wps_is_addr_authorized(wps_ie, wpa_s->own_addr, 1)) 5699 timeout = 10; 5700 wpabuf_free(wps_ie); 5701 } 5702 #endif /* CONFIG_WPS */ 5703 5704 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0); 5705 } 5706 wpa_s->eapol_received++; 5707 5708 if (wpa_s->countermeasures) { 5709 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped " 5710 "EAPOL packet"); 5711 return; 5712 } 5713 5714 #ifdef CONFIG_IBSS_RSN 5715 if (wpa_s->current_ssid && 5716 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) { 5717 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len, 5718 encrypted); 5719 return; 5720 } 5721 #endif /* CONFIG_IBSS_RSN */ 5722 5723 /* Source address of the incoming EAPOL frame could be compared to the 5724 * current BSSID. However, it is possible that a centralized 5725 * Authenticator could be using another MAC address than the BSSID of 5726 * an AP, so just allow any address to be used for now. The replies are 5727 * still sent to the current BSSID (if available), though. */ 5728 5729 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN); 5730 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) && 5731 wpa_s->key_mgmt != WPA_KEY_MGMT_OWE && 5732 wpa_s->key_mgmt != WPA_KEY_MGMT_DPP && 5733 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len, 5734 encrypted) > 0) 5735 return; 5736 wpa_drv_poll(wpa_s); 5737 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK)) 5738 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len, encrypted); 5739 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) { 5740 /* 5741 * Set portValid = true here since we are going to skip 4-way 5742 * handshake processing which would normally set portValid. We 5743 * need this to allow the EAPOL state machines to be completed 5744 * without going through EAPOL-Key handshake. 5745 */ 5746 eapol_sm_notify_portValid(wpa_s->eapol, true); 5747 } 5748 } 5749 5750 5751 static void wpa_supplicant_rx_eapol_cb(void *ctx, const u8 *src_addr, 5752 const u8 *buf, size_t len) 5753 { 5754 wpa_supplicant_rx_eapol(ctx, src_addr, buf, len, 5755 FRAME_ENCRYPTION_UNKNOWN); 5756 } 5757 5758 5759 static int wpas_eapol_needs_l2_packet(struct wpa_supplicant *wpa_s) 5760 { 5761 return !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_CONTROL_PORT) || 5762 !(wpa_s->drv_flags2 & WPA_DRIVER_FLAGS2_CONTROL_PORT_RX); 5763 } 5764 5765 5766 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s) 5767 { 5768 u8 prev_mac_addr[ETH_ALEN]; 5769 5770 os_memcpy(prev_mac_addr, wpa_s->own_addr, ETH_ALEN); 5771 5772 if ((!wpa_s->p2p_mgmt || 5773 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) && 5774 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) { 5775 l2_packet_deinit(wpa_s->l2); 5776 wpa_s->l2 = l2_packet_init(wpa_s->ifname, 5777 wpa_drv_get_mac_addr(wpa_s), 5778 ETH_P_EAPOL, 5779 wpas_eapol_needs_l2_packet(wpa_s) ? 5780 wpa_supplicant_rx_eapol_cb : NULL, 5781 wpa_s, 0); 5782 if (wpa_s->l2 == NULL) 5783 return -1; 5784 5785 if (l2_packet_set_packet_filter(wpa_s->l2, 5786 L2_PACKET_FILTER_PKTTYPE)) 5787 wpa_dbg(wpa_s, MSG_DEBUG, 5788 "Failed to attach pkt_type filter"); 5789 5790 if (l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) { 5791 wpa_msg(wpa_s, MSG_ERROR, 5792 "Failed to get own L2 address"); 5793 return -1; 5794 } 5795 } else { 5796 const u8 *addr = wpa_drv_get_mac_addr(wpa_s); 5797 if (addr) 5798 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN); 5799 } 5800 5801 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr); 5802 wpas_wps_update_mac_addr(wpa_s); 5803 5804 #ifdef CONFIG_FST 5805 if (wpa_s->fst) 5806 fst_update_mac_addr(wpa_s->fst, wpa_s->own_addr); 5807 #endif /* CONFIG_FST */ 5808 5809 if (!ether_addr_equal(prev_mac_addr, wpa_s->own_addr)) 5810 wpas_notify_mac_address_changed(wpa_s); 5811 5812 return 0; 5813 } 5814 5815 5816 static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr, 5817 const u8 *buf, size_t len) 5818 { 5819 struct wpa_supplicant *wpa_s = ctx; 5820 const struct l2_ethhdr *eth; 5821 5822 if (len < sizeof(*eth)) 5823 return; 5824 eth = (const struct l2_ethhdr *) buf; 5825 5826 if (!ether_addr_equal(eth->h_dest, wpa_s->own_addr) && 5827 !(eth->h_dest[0] & 0x01)) { 5828 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR 5829 " (bridge - not for this interface - ignore)", 5830 MAC2STR(src_addr), MAC2STR(eth->h_dest)); 5831 return; 5832 } 5833 5834 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR 5835 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest)); 5836 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth), 5837 len - sizeof(*eth), FRAME_ENCRYPTION_UNKNOWN); 5838 } 5839 5840 5841 int wpa_supplicant_update_bridge_ifname(struct wpa_supplicant *wpa_s, 5842 const char *bridge_ifname) 5843 { 5844 if (wpa_s->wpa_state > WPA_SCANNING) 5845 return -EBUSY; 5846 5847 if (bridge_ifname && 5848 os_strlen(bridge_ifname) >= sizeof(wpa_s->bridge_ifname)) 5849 return -EINVAL; 5850 5851 if (!bridge_ifname) 5852 bridge_ifname = ""; 5853 5854 if (os_strcmp(wpa_s->bridge_ifname, bridge_ifname) == 0) 5855 return 0; 5856 5857 if (wpa_s->l2_br) { 5858 l2_packet_deinit(wpa_s->l2_br); 5859 wpa_s->l2_br = NULL; 5860 } 5861 5862 os_strlcpy(wpa_s->bridge_ifname, bridge_ifname, 5863 sizeof(wpa_s->bridge_ifname)); 5864 5865 if (wpa_s->bridge_ifname[0]) { 5866 wpa_dbg(wpa_s, MSG_DEBUG, 5867 "Receiving packets from bridge interface '%s'", 5868 wpa_s->bridge_ifname); 5869 wpa_s->l2_br = l2_packet_init_bridge( 5870 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr, 5871 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1); 5872 if (!wpa_s->l2_br) { 5873 wpa_msg(wpa_s, MSG_ERROR, 5874 "Failed to open l2_packet connection for the bridge interface '%s'", 5875 wpa_s->bridge_ifname); 5876 goto fail; 5877 } 5878 } 5879 5880 #ifdef CONFIG_TDLS 5881 if (!wpa_s->p2p_mgmt && wpa_tdls_init(wpa_s->wpa)) 5882 goto fail; 5883 #endif /* CONFIG_TDLS */ 5884 5885 return 0; 5886 fail: 5887 wpa_s->bridge_ifname[0] = 0; 5888 if (wpa_s->l2_br) { 5889 l2_packet_deinit(wpa_s->l2_br); 5890 wpa_s->l2_br = NULL; 5891 } 5892 #ifdef CONFIG_TDLS 5893 if (!wpa_s->p2p_mgmt) 5894 wpa_tdls_init(wpa_s->wpa); 5895 #endif /* CONFIG_TDLS */ 5896 return -EIO; 5897 } 5898 5899 5900 /** 5901 * wpa_supplicant_driver_init - Initialize driver interface parameters 5902 * @wpa_s: Pointer to wpa_supplicant data 5903 * Returns: 0 on success, -1 on failure 5904 * 5905 * This function is called to initialize driver interface parameters. 5906 * wpa_drv_init() must have been called before this function to initialize the 5907 * driver interface. 5908 */ 5909 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s) 5910 { 5911 static int interface_count = 0; 5912 5913 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) 5914 return -1; 5915 5916 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR, 5917 MAC2STR(wpa_s->own_addr)); 5918 os_memcpy(wpa_s->perm_addr, wpa_s->own_addr, ETH_ALEN); 5919 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr); 5920 5921 if (wpa_s->bridge_ifname[0] && wpas_eapol_needs_l2_packet(wpa_s)) { 5922 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge " 5923 "interface '%s'", wpa_s->bridge_ifname); 5924 wpa_s->l2_br = l2_packet_init_bridge( 5925 wpa_s->bridge_ifname, wpa_s->ifname, wpa_s->own_addr, 5926 ETH_P_EAPOL, wpa_supplicant_rx_eapol_bridge, wpa_s, 1); 5927 if (wpa_s->l2_br == NULL) { 5928 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet " 5929 "connection for the bridge interface '%s'", 5930 wpa_s->bridge_ifname); 5931 return -1; 5932 } 5933 } 5934 5935 if (wpa_s->conf->ap_scan == 2 && 5936 os_strcmp(wpa_s->driver->name, "nl80211") == 0) { 5937 wpa_printf(MSG_INFO, 5938 "Note: nl80211 driver interface is not designed to be used with ap_scan=2; this can result in connection failures"); 5939 } 5940 5941 wpa_clear_keys(wpa_s, NULL); 5942 5943 /* Make sure that TKIP countermeasures are not left enabled (could 5944 * happen if wpa_supplicant is killed during countermeasures. */ 5945 wpa_drv_set_countermeasures(wpa_s, 0); 5946 5947 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver"); 5948 wpa_drv_flush_pmkid(wpa_s); 5949 5950 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN; 5951 wpa_s->prev_scan_wildcard = 0; 5952 5953 if (wpa_supplicant_enabled_networks(wpa_s)) { 5954 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { 5955 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 5956 interface_count = 0; 5957 } 5958 #ifndef ANDROID 5959 if (!wpa_s->p2p_mgmt && 5960 wpa_supplicant_delayed_sched_scan(wpa_s, 5961 interface_count % 3, 5962 100000)) 5963 wpa_supplicant_req_scan(wpa_s, interface_count % 3, 5964 100000); 5965 #endif /* ANDROID */ 5966 interface_count++; 5967 } else 5968 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE); 5969 5970 return 0; 5971 } 5972 5973 5974 static int wpa_supplicant_daemon(const char *pid_file) 5975 { 5976 wpa_printf(MSG_DEBUG, "Daemonize.."); 5977 return os_daemonize(pid_file); 5978 } 5979 5980 5981 static struct wpa_supplicant * 5982 wpa_supplicant_alloc(struct wpa_supplicant *parent) 5983 { 5984 struct wpa_supplicant *wpa_s; 5985 5986 wpa_s = os_zalloc(sizeof(*wpa_s)); 5987 if (wpa_s == NULL) 5988 return NULL; 5989 wpa_s->scan_req = INITIAL_SCAN_REQ; 5990 wpa_s->scan_interval = 5; 5991 wpa_s->new_connection = 1; 5992 wpa_s->parent = parent ? parent : wpa_s; 5993 wpa_s->p2pdev = wpa_s->parent; 5994 wpa_s->sched_scanning = 0; 5995 wpa_s->setband_mask = WPA_SETBAND_AUTO; 5996 5997 dl_list_init(&wpa_s->bss_tmp_disallowed); 5998 dl_list_init(&wpa_s->fils_hlp_req); 5999 #ifdef CONFIG_TESTING_OPTIONS 6000 dl_list_init(&wpa_s->drv_signal_override); 6001 wpa_s->test_assoc_comeback_type = -1; 6002 #endif /* CONFIG_TESTING_OPTIONS */ 6003 #ifndef CONFIG_NO_ROBUST_AV 6004 dl_list_init(&wpa_s->active_scs_ids); 6005 #endif /* CONFIG_NO_ROBUST_AV */ 6006 wpa_s->ml_probe_mld_id = -1; 6007 6008 return wpa_s; 6009 } 6010 6011 6012 #ifdef CONFIG_HT_OVERRIDES 6013 6014 static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s, 6015 struct ieee80211_ht_capabilities *htcaps, 6016 struct ieee80211_ht_capabilities *htcaps_mask, 6017 const char *ht_mcs) 6018 { 6019 /* parse ht_mcs into hex array */ 6020 int i; 6021 const char *tmp = ht_mcs; 6022 char *end = NULL; 6023 6024 /* If ht_mcs is null, do not set anything */ 6025 if (!ht_mcs) 6026 return 0; 6027 6028 /* This is what we are setting in the kernel */ 6029 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN); 6030 6031 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs); 6032 6033 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 6034 long v; 6035 6036 errno = 0; 6037 v = strtol(tmp, &end, 16); 6038 6039 if (errno == 0) { 6040 wpa_msg(wpa_s, MSG_DEBUG, 6041 "htcap value[%i]: %ld end: %p tmp: %p", 6042 i, v, end, tmp); 6043 if (end == tmp) 6044 break; 6045 6046 htcaps->supported_mcs_set[i] = v; 6047 tmp = end; 6048 } else { 6049 wpa_msg(wpa_s, MSG_ERROR, 6050 "Failed to parse ht-mcs: %s, error: %s\n", 6051 ht_mcs, strerror(errno)); 6052 return -1; 6053 } 6054 } 6055 6056 /* 6057 * If we were able to parse any values, then set mask for the MCS set. 6058 */ 6059 if (i) { 6060 os_memset(&htcaps_mask->supported_mcs_set, 0xff, 6061 IEEE80211_HT_MCS_MASK_LEN - 1); 6062 /* skip the 3 reserved bits */ 6063 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] = 6064 0x1f; 6065 } 6066 6067 return 0; 6068 } 6069 6070 6071 static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s, 6072 struct ieee80211_ht_capabilities *htcaps, 6073 struct ieee80211_ht_capabilities *htcaps_mask, 6074 int disabled) 6075 { 6076 le16 msk; 6077 6078 if (disabled == -1) 6079 return 0; 6080 6081 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled); 6082 6083 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE); 6084 htcaps_mask->ht_capabilities_info |= msk; 6085 if (disabled) 6086 htcaps->ht_capabilities_info &= msk; 6087 else 6088 htcaps->ht_capabilities_info |= msk; 6089 6090 return 0; 6091 } 6092 6093 6094 static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s, 6095 struct ieee80211_ht_capabilities *htcaps, 6096 struct ieee80211_ht_capabilities *htcaps_mask, 6097 int factor) 6098 { 6099 if (factor == -1) 6100 return 0; 6101 6102 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor); 6103 6104 if (factor < 0 || factor > 3) { 6105 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. " 6106 "Must be 0-3 or -1", factor); 6107 return -EINVAL; 6108 } 6109 6110 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */ 6111 htcaps->a_mpdu_params &= ~0x3; 6112 htcaps->a_mpdu_params |= factor & 0x3; 6113 6114 return 0; 6115 } 6116 6117 6118 static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s, 6119 struct ieee80211_ht_capabilities *htcaps, 6120 struct ieee80211_ht_capabilities *htcaps_mask, 6121 int density) 6122 { 6123 if (density == -1) 6124 return 0; 6125 6126 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density); 6127 6128 if (density < 0 || density > 7) { 6129 wpa_msg(wpa_s, MSG_ERROR, 6130 "ampdu_density: %d out of range. Must be 0-7 or -1.", 6131 density); 6132 return -EINVAL; 6133 } 6134 6135 htcaps_mask->a_mpdu_params |= 0x1C; 6136 htcaps->a_mpdu_params &= ~(0x1C); 6137 htcaps->a_mpdu_params |= (density << 2) & 0x1C; 6138 6139 return 0; 6140 } 6141 6142 6143 static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s, 6144 struct ieee80211_ht_capabilities *htcaps, 6145 struct ieee80211_ht_capabilities *htcaps_mask, 6146 int disabled) 6147 { 6148 if (disabled) 6149 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled); 6150 6151 set_disable_ht40(htcaps, disabled); 6152 set_disable_ht40(htcaps_mask, 0); 6153 6154 return 0; 6155 } 6156 6157 6158 static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s, 6159 struct ieee80211_ht_capabilities *htcaps, 6160 struct ieee80211_ht_capabilities *htcaps_mask, 6161 int disabled) 6162 { 6163 /* Masking these out disables SGI */ 6164 le16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ | 6165 HT_CAP_INFO_SHORT_GI40MHZ); 6166 6167 if (disabled) 6168 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled); 6169 6170 if (disabled) 6171 htcaps->ht_capabilities_info &= ~msk; 6172 else 6173 htcaps->ht_capabilities_info |= msk; 6174 6175 htcaps_mask->ht_capabilities_info |= msk; 6176 6177 return 0; 6178 } 6179 6180 6181 static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s, 6182 struct ieee80211_ht_capabilities *htcaps, 6183 struct ieee80211_ht_capabilities *htcaps_mask, 6184 int disabled) 6185 { 6186 /* Masking these out disables LDPC */ 6187 le16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP); 6188 6189 if (disabled) 6190 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled); 6191 6192 if (disabled) 6193 htcaps->ht_capabilities_info &= ~msk; 6194 else 6195 htcaps->ht_capabilities_info |= msk; 6196 6197 htcaps_mask->ht_capabilities_info |= msk; 6198 6199 return 0; 6200 } 6201 6202 6203 static int wpa_set_tx_stbc(struct wpa_supplicant *wpa_s, 6204 struct ieee80211_ht_capabilities *htcaps, 6205 struct ieee80211_ht_capabilities *htcaps_mask, 6206 int tx_stbc) 6207 { 6208 le16 msk = host_to_le16(HT_CAP_INFO_TX_STBC); 6209 6210 if (tx_stbc == -1) 6211 return 0; 6212 6213 wpa_msg(wpa_s, MSG_DEBUG, "set_tx_stbc: %d", tx_stbc); 6214 6215 if (tx_stbc < 0 || tx_stbc > 1) { 6216 wpa_msg(wpa_s, MSG_ERROR, 6217 "tx_stbc: %d out of range. Must be 0-1 or -1", tx_stbc); 6218 return -EINVAL; 6219 } 6220 6221 htcaps_mask->ht_capabilities_info |= msk; 6222 htcaps->ht_capabilities_info &= ~msk; 6223 htcaps->ht_capabilities_info |= (tx_stbc << 7) & msk; 6224 6225 return 0; 6226 } 6227 6228 6229 static int wpa_set_rx_stbc(struct wpa_supplicant *wpa_s, 6230 struct ieee80211_ht_capabilities *htcaps, 6231 struct ieee80211_ht_capabilities *htcaps_mask, 6232 int rx_stbc) 6233 { 6234 le16 msk = host_to_le16(HT_CAP_INFO_RX_STBC_MASK); 6235 6236 if (rx_stbc == -1) 6237 return 0; 6238 6239 wpa_msg(wpa_s, MSG_DEBUG, "set_rx_stbc: %d", rx_stbc); 6240 6241 if (rx_stbc < 0 || rx_stbc > 3) { 6242 wpa_msg(wpa_s, MSG_ERROR, 6243 "rx_stbc: %d out of range. Must be 0-3 or -1", rx_stbc); 6244 return -EINVAL; 6245 } 6246 6247 htcaps_mask->ht_capabilities_info |= msk; 6248 htcaps->ht_capabilities_info &= ~msk; 6249 htcaps->ht_capabilities_info |= (rx_stbc << 8) & msk; 6250 6251 return 0; 6252 } 6253 6254 6255 void wpa_supplicant_apply_ht_overrides( 6256 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 6257 struct wpa_driver_associate_params *params) 6258 { 6259 struct ieee80211_ht_capabilities *htcaps; 6260 struct ieee80211_ht_capabilities *htcaps_mask; 6261 6262 if (!ssid) 6263 return; 6264 6265 params->disable_ht = ssid->disable_ht; 6266 if (!params->htcaps || !params->htcaps_mask) 6267 return; 6268 6269 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps; 6270 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask; 6271 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs); 6272 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask, 6273 ssid->disable_max_amsdu); 6274 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor); 6275 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density); 6276 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40); 6277 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi); 6278 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc); 6279 wpa_set_rx_stbc(wpa_s, htcaps, htcaps_mask, ssid->rx_stbc); 6280 wpa_set_tx_stbc(wpa_s, htcaps, htcaps_mask, ssid->tx_stbc); 6281 6282 if (ssid->ht40_intolerant) { 6283 le16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT); 6284 htcaps->ht_capabilities_info |= bit; 6285 htcaps_mask->ht_capabilities_info |= bit; 6286 } 6287 } 6288 6289 #endif /* CONFIG_HT_OVERRIDES */ 6290 6291 6292 #ifdef CONFIG_VHT_OVERRIDES 6293 void wpa_supplicant_apply_vht_overrides( 6294 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 6295 struct wpa_driver_associate_params *params) 6296 { 6297 struct ieee80211_vht_capabilities *vhtcaps; 6298 struct ieee80211_vht_capabilities *vhtcaps_mask; 6299 6300 if (!ssid) 6301 return; 6302 6303 params->disable_vht = ssid->disable_vht; 6304 6305 vhtcaps = (void *) params->vhtcaps; 6306 vhtcaps_mask = (void *) params->vhtcaps_mask; 6307 6308 if (!vhtcaps || !vhtcaps_mask) 6309 return; 6310 6311 vhtcaps->vht_capabilities_info = host_to_le32(ssid->vht_capa); 6312 vhtcaps_mask->vht_capabilities_info = host_to_le32(ssid->vht_capa_mask); 6313 6314 #ifdef CONFIG_HT_OVERRIDES 6315 if (ssid->disable_sgi) { 6316 vhtcaps_mask->vht_capabilities_info |= (VHT_CAP_SHORT_GI_80 | 6317 VHT_CAP_SHORT_GI_160); 6318 vhtcaps->vht_capabilities_info &= ~(VHT_CAP_SHORT_GI_80 | 6319 VHT_CAP_SHORT_GI_160); 6320 wpa_msg(wpa_s, MSG_DEBUG, 6321 "disable-sgi override specified, vht-caps: 0x%x", 6322 vhtcaps->vht_capabilities_info); 6323 } 6324 6325 /* if max ampdu is <= 3, we have to make the HT cap the same */ 6326 if (ssid->vht_capa_mask & VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) { 6327 int max_ampdu; 6328 6329 max_ampdu = (ssid->vht_capa & 6330 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX) >> 6331 VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX_SHIFT; 6332 6333 max_ampdu = max_ampdu < 3 ? max_ampdu : 3; 6334 wpa_set_ampdu_factor(wpa_s, 6335 (void *) params->htcaps, 6336 (void *) params->htcaps_mask, 6337 max_ampdu); 6338 } 6339 #endif /* CONFIG_HT_OVERRIDES */ 6340 6341 #define OVERRIDE_MCS(i) \ 6342 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \ 6343 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \ 6344 host_to_le16(3 << 2 * (i - 1)); \ 6345 vhtcaps->vht_supported_mcs_set.tx_map |= \ 6346 host_to_le16(ssid->vht_tx_mcs_nss_ ##i << \ 6347 2 * (i - 1)); \ 6348 } \ 6349 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \ 6350 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \ 6351 host_to_le16(3 << 2 * (i - 1)); \ 6352 vhtcaps->vht_supported_mcs_set.rx_map |= \ 6353 host_to_le16(ssid->vht_rx_mcs_nss_ ##i << \ 6354 2 * (i - 1)); \ 6355 } 6356 6357 OVERRIDE_MCS(1); 6358 OVERRIDE_MCS(2); 6359 OVERRIDE_MCS(3); 6360 OVERRIDE_MCS(4); 6361 OVERRIDE_MCS(5); 6362 OVERRIDE_MCS(6); 6363 OVERRIDE_MCS(7); 6364 OVERRIDE_MCS(8); 6365 } 6366 #endif /* CONFIG_VHT_OVERRIDES */ 6367 6368 6369 #ifdef CONFIG_HE_OVERRIDES 6370 void wpa_supplicant_apply_he_overrides( 6371 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 6372 struct wpa_driver_associate_params *params) 6373 { 6374 if (!ssid) 6375 return; 6376 6377 params->disable_he = ssid->disable_he; 6378 } 6379 #endif /* CONFIG_HE_OVERRIDES */ 6380 6381 6382 void wpa_supplicant_apply_eht_overrides( 6383 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 6384 struct wpa_driver_associate_params *params) 6385 { 6386 if (!ssid) 6387 return; 6388 6389 params->disable_eht = ssid->disable_eht; 6390 } 6391 6392 6393 static int pcsc_reader_init(struct wpa_supplicant *wpa_s) 6394 { 6395 #ifdef PCSC_FUNCS 6396 size_t len; 6397 6398 if (!wpa_s->conf->pcsc_reader) 6399 return 0; 6400 6401 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader); 6402 if (!wpa_s->scard) 6403 return 1; 6404 6405 if (wpa_s->conf->pcsc_pin && 6406 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) { 6407 scard_deinit(wpa_s->scard); 6408 wpa_s->scard = NULL; 6409 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed"); 6410 return -1; 6411 } 6412 6413 len = sizeof(wpa_s->imsi) - 1; 6414 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) { 6415 scard_deinit(wpa_s->scard); 6416 wpa_s->scard = NULL; 6417 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI"); 6418 return -1; 6419 } 6420 wpa_s->imsi[len] = '\0'; 6421 6422 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard); 6423 6424 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)", 6425 wpa_s->imsi, wpa_s->mnc_len); 6426 6427 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard); 6428 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard); 6429 #endif /* PCSC_FUNCS */ 6430 6431 return 0; 6432 } 6433 6434 6435 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s) 6436 { 6437 char *val, *pos; 6438 6439 ext_password_deinit(wpa_s->ext_pw); 6440 wpa_s->ext_pw = NULL; 6441 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL); 6442 6443 if (!wpa_s->conf->ext_password_backend) 6444 return 0; 6445 6446 val = os_strdup(wpa_s->conf->ext_password_backend); 6447 if (val == NULL) 6448 return -1; 6449 pos = os_strchr(val, ':'); 6450 if (pos) 6451 *pos++ = '\0'; 6452 6453 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val); 6454 6455 wpa_s->ext_pw = ext_password_init(val, pos); 6456 os_free(val); 6457 if (wpa_s->ext_pw == NULL) { 6458 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend"); 6459 return -1; 6460 } 6461 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw); 6462 6463 return 0; 6464 } 6465 6466 6467 #ifdef CONFIG_FST 6468 6469 static const u8 * wpas_fst_get_bssid_cb(void *ctx) 6470 { 6471 struct wpa_supplicant *wpa_s = ctx; 6472 6473 return (is_zero_ether_addr(wpa_s->bssid) || 6474 wpa_s->wpa_state != WPA_COMPLETED) ? NULL : wpa_s->bssid; 6475 } 6476 6477 6478 static void wpas_fst_get_channel_info_cb(void *ctx, 6479 enum hostapd_hw_mode *hw_mode, 6480 u8 *channel) 6481 { 6482 struct wpa_supplicant *wpa_s = ctx; 6483 6484 if (wpa_s->current_bss) { 6485 *hw_mode = ieee80211_freq_to_chan(wpa_s->current_bss->freq, 6486 channel); 6487 } else if (wpa_s->hw.num_modes) { 6488 *hw_mode = wpa_s->hw.modes[0].mode; 6489 } else { 6490 WPA_ASSERT(0); 6491 *hw_mode = 0; 6492 } 6493 } 6494 6495 6496 static int wpas_fst_get_hw_modes(void *ctx, struct hostapd_hw_modes **modes) 6497 { 6498 struct wpa_supplicant *wpa_s = ctx; 6499 6500 *modes = wpa_s->hw.modes; 6501 return wpa_s->hw.num_modes; 6502 } 6503 6504 6505 static void wpas_fst_set_ies_cb(void *ctx, const struct wpabuf *fst_ies) 6506 { 6507 struct wpa_supplicant *wpa_s = ctx; 6508 6509 wpa_hexdump_buf(MSG_DEBUG, "FST: Set IEs", fst_ies); 6510 wpa_s->fst_ies = fst_ies; 6511 } 6512 6513 6514 static int wpas_fst_send_action_cb(void *ctx, const u8 *da, struct wpabuf *data) 6515 { 6516 struct wpa_supplicant *wpa_s = ctx; 6517 6518 if (!ether_addr_equal(wpa_s->bssid, da)) { 6519 wpa_printf(MSG_INFO, "FST:%s:bssid=" MACSTR " != da=" MACSTR, 6520 __func__, MAC2STR(wpa_s->bssid), MAC2STR(da)); 6521 return -1; 6522 } 6523 return wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid, 6524 wpa_s->own_addr, wpa_s->bssid, 6525 wpabuf_head(data), wpabuf_len(data), 6526 0); 6527 } 6528 6529 6530 static const struct wpabuf * wpas_fst_get_mb_ie_cb(void *ctx, const u8 *addr) 6531 { 6532 struct wpa_supplicant *wpa_s = ctx; 6533 6534 WPA_ASSERT(ether_addr_equal(wpa_s->bssid, addr)); 6535 return wpa_s->received_mb_ies; 6536 } 6537 6538 6539 static void wpas_fst_update_mb_ie_cb(void *ctx, const u8 *addr, 6540 const u8 *buf, size_t size) 6541 { 6542 struct wpa_supplicant *wpa_s = ctx; 6543 struct mb_ies_info info; 6544 6545 WPA_ASSERT(ether_addr_equal(wpa_s->bssid, addr)); 6546 6547 if (!mb_ies_info_by_ies(&info, buf, size)) { 6548 wpabuf_free(wpa_s->received_mb_ies); 6549 wpa_s->received_mb_ies = mb_ies_by_info(&info); 6550 } 6551 } 6552 6553 6554 static const u8 * wpas_fst_get_peer_first(void *ctx, 6555 struct fst_get_peer_ctx **get_ctx, 6556 bool mb_only) 6557 { 6558 struct wpa_supplicant *wpa_s = ctx; 6559 6560 *get_ctx = NULL; 6561 if (!is_zero_ether_addr(wpa_s->bssid)) 6562 return (wpa_s->received_mb_ies || !mb_only) ? 6563 wpa_s->bssid : NULL; 6564 return NULL; 6565 } 6566 6567 6568 static const u8 * wpas_fst_get_peer_next(void *ctx, 6569 struct fst_get_peer_ctx **get_ctx, 6570 bool mb_only) 6571 { 6572 return NULL; 6573 } 6574 6575 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s, 6576 struct fst_wpa_obj *iface_obj) 6577 { 6578 os_memset(iface_obj, 0, sizeof(*iface_obj)); 6579 iface_obj->ctx = wpa_s; 6580 iface_obj->get_bssid = wpas_fst_get_bssid_cb; 6581 iface_obj->get_channel_info = wpas_fst_get_channel_info_cb; 6582 iface_obj->get_hw_modes = wpas_fst_get_hw_modes; 6583 iface_obj->set_ies = wpas_fst_set_ies_cb; 6584 iface_obj->send_action = wpas_fst_send_action_cb; 6585 iface_obj->get_mb_ie = wpas_fst_get_mb_ie_cb; 6586 iface_obj->update_mb_ie = wpas_fst_update_mb_ie_cb; 6587 iface_obj->get_peer_first = wpas_fst_get_peer_first; 6588 iface_obj->get_peer_next = wpas_fst_get_peer_next; 6589 } 6590 #endif /* CONFIG_FST */ 6591 6592 static int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s, 6593 const struct wpa_driver_capa *capa) 6594 { 6595 struct wowlan_triggers *triggers; 6596 int ret = 0; 6597 6598 if (!wpa_s->conf->wowlan_triggers) 6599 return 0; 6600 6601 triggers = wpa_get_wowlan_triggers(wpa_s->conf->wowlan_triggers, capa); 6602 if (triggers) { 6603 ret = wpa_drv_wowlan(wpa_s, triggers); 6604 os_free(triggers); 6605 } 6606 return ret; 6607 } 6608 6609 6610 enum wpa_radio_work_band wpas_freq_to_band(int freq) 6611 { 6612 if (freq < 3000) 6613 return BAND_2_4_GHZ; 6614 if (freq > 50000) 6615 return BAND_60_GHZ; 6616 return BAND_5_GHZ; 6617 } 6618 6619 6620 unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs) 6621 { 6622 int i; 6623 unsigned int band = 0; 6624 6625 if (freqs) { 6626 /* freqs are specified for the radio work */ 6627 for (i = 0; freqs[i]; i++) 6628 band |= wpas_freq_to_band(freqs[i]); 6629 } else { 6630 /* 6631 * freqs are not specified, implies all 6632 * the supported freqs by HW 6633 */ 6634 for (i = 0; i < wpa_s->hw.num_modes; i++) { 6635 if (wpa_s->hw.modes[i].num_channels != 0) { 6636 if (wpa_s->hw.modes[i].mode == 6637 HOSTAPD_MODE_IEEE80211B || 6638 wpa_s->hw.modes[i].mode == 6639 HOSTAPD_MODE_IEEE80211G) 6640 band |= BAND_2_4_GHZ; 6641 else if (wpa_s->hw.modes[i].mode == 6642 HOSTAPD_MODE_IEEE80211A) 6643 band |= BAND_5_GHZ; 6644 else if (wpa_s->hw.modes[i].mode == 6645 HOSTAPD_MODE_IEEE80211AD) 6646 band |= BAND_60_GHZ; 6647 else if (wpa_s->hw.modes[i].mode == 6648 HOSTAPD_MODE_IEEE80211ANY) 6649 band = BAND_2_4_GHZ | BAND_5_GHZ | 6650 BAND_60_GHZ; 6651 } 6652 } 6653 } 6654 6655 return band; 6656 } 6657 6658 6659 static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s, 6660 const char *rn) 6661 { 6662 struct wpa_supplicant *iface = wpa_s->global->ifaces; 6663 struct wpa_radio *radio; 6664 6665 while (rn && iface) { 6666 radio = iface->radio; 6667 if (radio && os_strcmp(rn, radio->name) == 0) { 6668 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s", 6669 wpa_s->ifname, rn); 6670 dl_list_add(&radio->ifaces, &wpa_s->radio_list); 6671 return radio; 6672 } 6673 6674 iface = iface->next; 6675 } 6676 6677 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s", 6678 wpa_s->ifname, rn ? rn : "N/A"); 6679 radio = os_zalloc(sizeof(*radio)); 6680 if (radio == NULL) 6681 return NULL; 6682 6683 if (rn) 6684 os_strlcpy(radio->name, rn, sizeof(radio->name)); 6685 dl_list_init(&radio->ifaces); 6686 dl_list_init(&radio->work); 6687 dl_list_add(&radio->ifaces, &wpa_s->radio_list); 6688 6689 return radio; 6690 } 6691 6692 6693 static void radio_work_free(struct wpa_radio_work *work) 6694 { 6695 if (work->wpa_s->scan_work == work) { 6696 /* This should not really happen. */ 6697 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work", 6698 work->type, work, work->started); 6699 work->wpa_s->scan_work = NULL; 6700 } 6701 6702 #ifdef CONFIG_P2P 6703 if (work->wpa_s->p2p_scan_work == work) { 6704 /* This should not really happen. */ 6705 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work", 6706 work->type, work, work->started); 6707 work->wpa_s->p2p_scan_work = NULL; 6708 } 6709 #endif /* CONFIG_P2P */ 6710 6711 if (work->started) { 6712 work->wpa_s->radio->num_active_works--; 6713 wpa_dbg(work->wpa_s, MSG_DEBUG, 6714 "radio_work_free('%s'@%p): num_active_works --> %u", 6715 work->type, work, 6716 work->wpa_s->radio->num_active_works); 6717 } 6718 6719 dl_list_del(&work->list); 6720 os_free(work); 6721 } 6722 6723 6724 static int radio_work_is_connect(struct wpa_radio_work *work) 6725 { 6726 return os_strcmp(work->type, "sme-connect") == 0 || 6727 os_strcmp(work->type, "connect") == 0; 6728 } 6729 6730 6731 static int radio_work_is_scan(struct wpa_radio_work *work) 6732 { 6733 return os_strcmp(work->type, "scan") == 0 || 6734 os_strcmp(work->type, "p2p-scan") == 0; 6735 } 6736 6737 6738 static struct wpa_radio_work * radio_work_get_next_work(struct wpa_radio *radio) 6739 { 6740 struct wpa_radio_work *active_work = NULL; 6741 struct wpa_radio_work *tmp; 6742 6743 /* Get the active work to know the type and band. */ 6744 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) { 6745 if (tmp->started) { 6746 active_work = tmp; 6747 break; 6748 } 6749 } 6750 6751 if (!active_work) { 6752 /* No active work, start one */ 6753 radio->num_active_works = 0; 6754 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, 6755 list) { 6756 if (os_strcmp(tmp->type, "scan") == 0 && 6757 external_scan_running(radio) && 6758 (((struct wpa_driver_scan_params *) 6759 tmp->ctx)->only_new_results || 6760 tmp->wpa_s->clear_driver_scan_cache)) 6761 continue; 6762 return tmp; 6763 } 6764 return NULL; 6765 } 6766 6767 if (radio_work_is_connect(active_work)) { 6768 /* 6769 * If the active work is either connect or sme-connect, 6770 * do not parallelize them with other radio works. 6771 */ 6772 wpa_dbg(active_work->wpa_s, MSG_DEBUG, 6773 "Do not parallelize radio work with %s", 6774 active_work->type); 6775 return NULL; 6776 } 6777 6778 dl_list_for_each(tmp, &radio->work, struct wpa_radio_work, list) { 6779 if (tmp->started) 6780 continue; 6781 6782 /* 6783 * If connect or sme-connect are enqueued, parallelize only 6784 * those operations ahead of them in the queue. 6785 */ 6786 if (radio_work_is_connect(tmp)) 6787 break; 6788 6789 /* Serialize parallel scan and p2p_scan operations on the same 6790 * interface since the driver_nl80211 mechanism for tracking 6791 * scan cookies does not yet have support for this. */ 6792 if (active_work->wpa_s == tmp->wpa_s && 6793 radio_work_is_scan(active_work) && 6794 radio_work_is_scan(tmp)) { 6795 wpa_dbg(active_work->wpa_s, MSG_DEBUG, 6796 "Do not start work '%s' when another work '%s' is already scheduled", 6797 tmp->type, active_work->type); 6798 continue; 6799 } 6800 /* 6801 * Check that the radio works are distinct and 6802 * on different bands. 6803 */ 6804 if (os_strcmp(active_work->type, tmp->type) != 0 && 6805 (active_work->bands != tmp->bands)) { 6806 /* 6807 * If a scan has to be scheduled through nl80211 scan 6808 * interface and if an external scan is already running, 6809 * do not schedule the scan since it is likely to get 6810 * rejected by kernel. 6811 */ 6812 if (os_strcmp(tmp->type, "scan") == 0 && 6813 external_scan_running(radio) && 6814 (((struct wpa_driver_scan_params *) 6815 tmp->ctx)->only_new_results || 6816 tmp->wpa_s->clear_driver_scan_cache)) 6817 continue; 6818 6819 wpa_dbg(active_work->wpa_s, MSG_DEBUG, 6820 "active_work:%s new_work:%s", 6821 active_work->type, tmp->type); 6822 return tmp; 6823 } 6824 } 6825 6826 /* Did not find a radio work to schedule in parallel. */ 6827 return NULL; 6828 } 6829 6830 6831 static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx) 6832 { 6833 struct wpa_radio *radio = eloop_ctx; 6834 struct wpa_radio_work *work; 6835 struct os_reltime now, diff; 6836 struct wpa_supplicant *wpa_s; 6837 6838 work = dl_list_first(&radio->work, struct wpa_radio_work, list); 6839 if (work == NULL) { 6840 radio->num_active_works = 0; 6841 return; 6842 } 6843 6844 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant, 6845 radio_list); 6846 6847 if (!(wpa_s && 6848 wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS)) { 6849 if (work->started) 6850 return; /* already started and still in progress */ 6851 6852 if (wpa_s && external_scan_running(wpa_s->radio)) { 6853 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes"); 6854 return; 6855 } 6856 } else { 6857 work = NULL; 6858 if (radio->num_active_works < MAX_ACTIVE_WORKS) { 6859 /* get the work to schedule next */ 6860 work = radio_work_get_next_work(radio); 6861 } 6862 if (!work) 6863 return; 6864 } 6865 6866 wpa_s = work->wpa_s; 6867 os_get_reltime(&now); 6868 os_reltime_sub(&now, &work->time, &diff); 6869 wpa_dbg(wpa_s, MSG_DEBUG, 6870 "Starting radio work '%s'@%p after %jd.%06jd second wait", 6871 work->type, work, (intmax_t)diff.sec, (intmax_t)diff.usec); 6872 work->started = 1; 6873 work->time = now; 6874 radio->num_active_works++; 6875 6876 work->cb(work, 0); 6877 6878 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) && 6879 radio->num_active_works < MAX_ACTIVE_WORKS) 6880 radio_work_check_next(wpa_s); 6881 } 6882 6883 6884 /* 6885 * This function removes both started and pending radio works running on 6886 * the provided interface's radio. 6887 * Prior to the removal of the radio work, its callback (cb) is called with 6888 * deinit set to be 1. Each work's callback is responsible for clearing its 6889 * internal data and restoring to a correct state. 6890 * @wpa_s: wpa_supplicant data 6891 * @type: type of works to be removed 6892 * @remove_all: 1 to remove all the works on this radio, 0 to remove only 6893 * this interface's works. 6894 */ 6895 void radio_remove_works(struct wpa_supplicant *wpa_s, 6896 const char *type, int remove_all) 6897 { 6898 struct wpa_radio_work *work, *tmp; 6899 struct wpa_radio *radio = wpa_s->radio; 6900 6901 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work, 6902 list) { 6903 if (type && os_strcmp(type, work->type) != 0) 6904 continue; 6905 6906 /* skip other ifaces' works */ 6907 if (!remove_all && work->wpa_s != wpa_s) 6908 continue; 6909 6910 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s", 6911 work->type, work, work->started ? " (started)" : ""); 6912 work->cb(work, 1); 6913 radio_work_free(work); 6914 } 6915 6916 /* in case we removed the started work */ 6917 radio_work_check_next(wpa_s); 6918 } 6919 6920 6921 void radio_remove_pending_work(struct wpa_supplicant *wpa_s, void *ctx) 6922 { 6923 struct wpa_radio_work *work; 6924 struct wpa_radio *radio = wpa_s->radio; 6925 6926 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) { 6927 if (work->ctx != ctx) 6928 continue; 6929 wpa_dbg(wpa_s, MSG_DEBUG, "Free pending radio work '%s'@%p%s", 6930 work->type, work, work->started ? " (started)" : ""); 6931 radio_work_free(work); 6932 break; 6933 } 6934 } 6935 6936 6937 static void radio_remove_interface(struct wpa_supplicant *wpa_s) 6938 { 6939 struct wpa_radio *radio = wpa_s->radio; 6940 6941 if (!radio) 6942 return; 6943 6944 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s", 6945 wpa_s->ifname, radio->name); 6946 dl_list_del(&wpa_s->radio_list); 6947 radio_remove_works(wpa_s, NULL, 0); 6948 /* If the interface that triggered the external scan was removed, the 6949 * external scan is no longer running. */ 6950 if (wpa_s == radio->external_scan_req_interface) 6951 radio->external_scan_req_interface = NULL; 6952 wpa_s->radio = NULL; 6953 if (!dl_list_empty(&radio->ifaces)) 6954 return; /* Interfaces remain for this radio */ 6955 6956 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name); 6957 eloop_cancel_timeout(radio_start_next_work, radio, NULL); 6958 os_free(radio); 6959 } 6960 6961 6962 void radio_work_check_next(struct wpa_supplicant *wpa_s) 6963 { 6964 struct wpa_radio *radio = wpa_s->radio; 6965 6966 if (dl_list_empty(&radio->work)) 6967 return; 6968 if (wpa_s->ext_work_in_progress) { 6969 wpa_printf(MSG_DEBUG, 6970 "External radio work in progress - delay start of pending item"); 6971 return; 6972 } 6973 eloop_cancel_timeout(radio_start_next_work, radio, NULL); 6974 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL); 6975 } 6976 6977 6978 /** 6979 * radio_add_work - Add a radio work item 6980 * @wpa_s: Pointer to wpa_supplicant data 6981 * @freq: Frequency of the offchannel operation in MHz or 0 6982 * @type: Unique identifier for each type of work 6983 * @next: Force as the next work to be executed 6984 * @cb: Callback function for indicating when radio is available 6985 * @ctx: Context pointer for the work (work->ctx in cb()) 6986 * Returns: 0 on success, -1 on failure 6987 * 6988 * This function is used to request time for an operation that requires 6989 * exclusive radio control. Once the radio is available, the registered callback 6990 * function will be called. radio_work_done() must be called once the exclusive 6991 * radio operation has been completed, so that the radio is freed for other 6992 * operations. The special case of deinit=1 is used to free the context data 6993 * during interface removal. That does not allow the callback function to start 6994 * the radio operation, i.e., it must free any resources allocated for the radio 6995 * work and return. 6996 * 6997 * The @freq parameter can be used to indicate a single channel on which the 6998 * offchannel operation will occur. This may allow multiple radio work 6999 * operations to be performed in parallel if they apply for the same channel. 7000 * Setting this to 0 indicates that the work item may use multiple channels or 7001 * requires exclusive control of the radio. 7002 */ 7003 int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq, 7004 const char *type, int next, 7005 void (*cb)(struct wpa_radio_work *work, int deinit), 7006 void *ctx) 7007 { 7008 struct wpa_radio *radio = wpa_s->radio; 7009 struct wpa_radio_work *work; 7010 int was_empty; 7011 7012 work = os_zalloc(sizeof(*work)); 7013 if (work == NULL) 7014 return -1; 7015 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work); 7016 os_get_reltime(&work->time); 7017 work->freq = freq; 7018 work->type = type; 7019 work->wpa_s = wpa_s; 7020 work->cb = cb; 7021 work->ctx = ctx; 7022 7023 if (freq) 7024 work->bands = wpas_freq_to_band(freq); 7025 else if (os_strcmp(type, "scan") == 0 || 7026 os_strcmp(type, "p2p-scan") == 0) 7027 work->bands = wpas_get_bands(wpa_s, 7028 ((struct wpa_driver_scan_params *) 7029 ctx)->freqs); 7030 else 7031 work->bands = wpas_get_bands(wpa_s, NULL); 7032 7033 was_empty = dl_list_empty(&wpa_s->radio->work); 7034 if (next) 7035 dl_list_add(&wpa_s->radio->work, &work->list); 7036 else 7037 dl_list_add_tail(&wpa_s->radio->work, &work->list); 7038 if (was_empty) { 7039 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately"); 7040 radio_work_check_next(wpa_s); 7041 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS) 7042 && radio->num_active_works < MAX_ACTIVE_WORKS) { 7043 wpa_dbg(wpa_s, MSG_DEBUG, 7044 "Try to schedule a radio work (num_active_works=%u)", 7045 radio->num_active_works); 7046 radio_work_check_next(wpa_s); 7047 } 7048 7049 return 0; 7050 } 7051 7052 7053 /** 7054 * radio_work_done - Indicate that a radio work item has been completed 7055 * @work: Completed work 7056 * 7057 * This function is called once the callback function registered with 7058 * radio_add_work() has completed its work. 7059 */ 7060 void radio_work_done(struct wpa_radio_work *work) 7061 { 7062 struct wpa_supplicant *wpa_s = work->wpa_s; 7063 struct os_reltime now, diff; 7064 unsigned int started = work->started; 7065 7066 os_get_reltime(&now); 7067 os_reltime_sub(&now, &work->time, &diff); 7068 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %jd.%06ld seconds", 7069 work->type, work, started ? "done" : "canceled", 7070 (intmax_t)diff.sec, (long)diff.usec); 7071 radio_work_free(work); 7072 if (started) 7073 radio_work_check_next(wpa_s); 7074 } 7075 7076 7077 struct wpa_radio_work * 7078 radio_work_pending(struct wpa_supplicant *wpa_s, const char *type) 7079 { 7080 struct wpa_radio_work *work; 7081 struct wpa_radio *radio = wpa_s->radio; 7082 7083 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) { 7084 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0) 7085 return work; 7086 } 7087 7088 return NULL; 7089 } 7090 7091 7092 static int wpas_init_driver(struct wpa_supplicant *wpa_s, 7093 const struct wpa_interface *iface) 7094 { 7095 const char *ifname, *driver, *rn; 7096 7097 driver = iface->driver; 7098 next_driver: 7099 if (wpa_supplicant_set_driver(wpa_s, driver) < 0) 7100 return -1; 7101 7102 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname); 7103 if (wpa_s->drv_priv == NULL) { 7104 const char *pos; 7105 int level = MSG_ERROR; 7106 7107 pos = driver ? os_strchr(driver, ',') : NULL; 7108 if (pos) { 7109 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize " 7110 "driver interface - try next driver wrapper"); 7111 driver = pos + 1; 7112 goto next_driver; 7113 } 7114 7115 #ifdef CONFIG_MATCH_IFACE 7116 if (wpa_s->matched == WPA_IFACE_MATCHED_NULL) 7117 level = MSG_DEBUG; 7118 #endif /* CONFIG_MATCH_IFACE */ 7119 wpa_msg(wpa_s, level, "Failed to initialize driver interface"); 7120 return -1; 7121 } 7122 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) { 7123 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected " 7124 "driver_param '%s'", wpa_s->conf->driver_param); 7125 return -1; 7126 } 7127 7128 ifname = wpa_drv_get_ifname(wpa_s); 7129 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) { 7130 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced " 7131 "interface name with '%s'", ifname); 7132 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname)); 7133 } 7134 7135 rn = wpa_driver_get_radio_name(wpa_s); 7136 if (rn && rn[0] == '\0') 7137 rn = NULL; 7138 7139 wpa_s->radio = radio_add_interface(wpa_s, rn); 7140 if (wpa_s->radio == NULL) 7141 return -1; 7142 7143 return 0; 7144 } 7145 7146 7147 #ifdef CONFIG_GAS_SERVER 7148 7149 static void wpas_gas_server_tx_status(struct wpa_supplicant *wpa_s, 7150 unsigned int freq, const u8 *dst, 7151 const u8 *src, const u8 *bssid, 7152 const u8 *data, size_t data_len, 7153 enum offchannel_send_action_result result) 7154 { 7155 wpa_printf(MSG_DEBUG, "GAS: TX status: freq=%u dst=" MACSTR 7156 " result=%s", 7157 freq, MAC2STR(dst), 7158 result == OFFCHANNEL_SEND_ACTION_SUCCESS ? "SUCCESS" : 7159 (result == OFFCHANNEL_SEND_ACTION_NO_ACK ? "no-ACK" : 7160 "FAILED")); 7161 gas_server_tx_status(wpa_s->gas_server, dst, data, data_len, 7162 result == OFFCHANNEL_SEND_ACTION_SUCCESS); 7163 } 7164 7165 7166 static void wpas_gas_server_tx(void *ctx, int freq, const u8 *da, 7167 struct wpabuf *buf, unsigned int wait_time) 7168 { 7169 struct wpa_supplicant *wpa_s = ctx; 7170 const u8 broadcast[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 7171 7172 if (wait_time > wpa_s->max_remain_on_chan) 7173 wait_time = wpa_s->max_remain_on_chan; 7174 7175 offchannel_send_action(wpa_s, freq, da, wpa_s->own_addr, broadcast, 7176 wpabuf_head(buf), wpabuf_len(buf), 7177 wait_time, wpas_gas_server_tx_status, 0); 7178 } 7179 7180 #endif /* CONFIG_GAS_SERVER */ 7181 7182 static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s, 7183 const struct wpa_interface *iface) 7184 { 7185 struct wpa_driver_capa capa; 7186 int capa_res; 7187 u8 dfs_domain; 7188 7189 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver " 7190 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname, 7191 iface->confname ? iface->confname : "N/A", 7192 iface->driver ? iface->driver : "default", 7193 iface->ctrl_interface ? iface->ctrl_interface : "N/A", 7194 iface->bridge_ifname ? iface->bridge_ifname : "N/A"); 7195 7196 if (iface->confname) { 7197 #ifdef CONFIG_BACKEND_FILE 7198 wpa_s->confname = os_rel2abs_path(iface->confname); 7199 if (wpa_s->confname == NULL) { 7200 wpa_printf(MSG_ERROR, "Failed to get absolute path " 7201 "for configuration file '%s'.", 7202 iface->confname); 7203 return -1; 7204 } 7205 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'", 7206 iface->confname, wpa_s->confname); 7207 #else /* CONFIG_BACKEND_FILE */ 7208 wpa_s->confname = os_strdup(iface->confname); 7209 #endif /* CONFIG_BACKEND_FILE */ 7210 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL, false); 7211 if (wpa_s->conf == NULL) { 7212 wpa_printf(MSG_ERROR, "Failed to read or parse " 7213 "configuration '%s'.", wpa_s->confname); 7214 return -1; 7215 } 7216 wpa_s->confanother = os_rel2abs_path(iface->confanother); 7217 if (wpa_s->confanother && 7218 !wpa_config_read(wpa_s->confanother, wpa_s->conf, true)) { 7219 wpa_printf(MSG_ERROR, 7220 "Failed to read or parse configuration '%s'.", 7221 wpa_s->confanother); 7222 return -1; 7223 } 7224 7225 /* 7226 * Override ctrl_interface and driver_param if set on command 7227 * line. 7228 */ 7229 if (iface->ctrl_interface) { 7230 os_free(wpa_s->conf->ctrl_interface); 7231 wpa_s->conf->ctrl_interface = 7232 os_strdup(iface->ctrl_interface); 7233 if (!wpa_s->conf->ctrl_interface) { 7234 wpa_printf(MSG_ERROR, 7235 "Failed to duplicate control interface '%s'.", 7236 iface->ctrl_interface); 7237 return -1; 7238 } 7239 } 7240 7241 if (iface->driver_param) { 7242 os_free(wpa_s->conf->driver_param); 7243 wpa_s->conf->driver_param = 7244 os_strdup(iface->driver_param); 7245 if (!wpa_s->conf->driver_param) { 7246 wpa_printf(MSG_ERROR, 7247 "Failed to duplicate driver param '%s'.", 7248 iface->driver_param); 7249 return -1; 7250 } 7251 } 7252 7253 if (iface->p2p_mgmt && !iface->ctrl_interface) { 7254 os_free(wpa_s->conf->ctrl_interface); 7255 wpa_s->conf->ctrl_interface = NULL; 7256 } 7257 } else 7258 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface, 7259 iface->driver_param); 7260 7261 if (wpa_s->conf == NULL) { 7262 wpa_printf(MSG_ERROR, "\nNo configuration found."); 7263 return -1; 7264 } 7265 7266 if (iface->ifname == NULL) { 7267 wpa_printf(MSG_ERROR, "\nInterface name is required."); 7268 return -1; 7269 } 7270 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) { 7271 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.", 7272 iface->ifname); 7273 return -1; 7274 } 7275 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname)); 7276 #ifdef CONFIG_MATCH_IFACE 7277 wpa_s->matched = iface->matched; 7278 #endif /* CONFIG_MATCH_IFACE */ 7279 7280 if (iface->bridge_ifname) { 7281 if (os_strlen(iface->bridge_ifname) >= 7282 sizeof(wpa_s->bridge_ifname)) { 7283 wpa_printf(MSG_ERROR, "\nToo long bridge interface " 7284 "name '%s'.", iface->bridge_ifname); 7285 return -1; 7286 } 7287 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname, 7288 sizeof(wpa_s->bridge_ifname)); 7289 } 7290 7291 /* RSNA Supplicant Key Management - INITIALIZE */ 7292 eapol_sm_notify_portEnabled(wpa_s->eapol, false); 7293 eapol_sm_notify_portValid(wpa_s->eapol, false); 7294 7295 /* Initialize driver interface and register driver event handler before 7296 * L2 receive handler so that association events are processed before 7297 * EAPOL-Key packets if both become available for the same select() 7298 * call. */ 7299 if (wpas_init_driver(wpa_s, iface) < 0) 7300 return -1; 7301 7302 if (wpa_supplicant_init_wpa(wpa_s) < 0) 7303 return -1; 7304 7305 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname, 7306 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname : 7307 NULL); 7308 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth); 7309 7310 if (wpa_s->conf->dot11RSNAConfigPMKLifetime && 7311 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME, 7312 wpa_s->conf->dot11RSNAConfigPMKLifetime)) { 7313 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for " 7314 "dot11RSNAConfigPMKLifetime"); 7315 return -1; 7316 } 7317 7318 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold && 7319 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD, 7320 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) { 7321 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for " 7322 "dot11RSNAConfigPMKReauthThreshold"); 7323 return -1; 7324 } 7325 7326 if (wpa_s->conf->dot11RSNAConfigSATimeout && 7327 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, 7328 wpa_s->conf->dot11RSNAConfigSATimeout)) { 7329 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for " 7330 "dot11RSNAConfigSATimeout"); 7331 return -1; 7332 } 7333 7334 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_FT_PREPEND_PMKID, 7335 wpa_s->conf->ft_prepend_pmkid); 7336 7337 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s, 7338 &wpa_s->hw.num_modes, 7339 &wpa_s->hw.flags, 7340 &dfs_domain); 7341 if (wpa_s->hw.modes) { 7342 u16 i; 7343 7344 for (i = 0; i < wpa_s->hw.num_modes; i++) { 7345 if (wpa_s->hw.modes[i].vht_capab) { 7346 wpa_s->hw_capab = CAPAB_VHT; 7347 break; 7348 } 7349 7350 if (wpa_s->hw.modes[i].ht_capab & 7351 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET) 7352 wpa_s->hw_capab = CAPAB_HT40; 7353 else if (wpa_s->hw.modes[i].ht_capab && 7354 wpa_s->hw_capab == CAPAB_NO_HT_VHT) 7355 wpa_s->hw_capab = CAPAB_HT; 7356 } 7357 wpa_s->support_6ghz = wpas_is_6ghz_supported(wpa_s, false); 7358 } 7359 7360 capa_res = wpa_drv_get_capa(wpa_s, &capa); 7361 if (capa_res == 0) { 7362 wpa_s->drv_capa_known = 1; 7363 wpa_s->drv_flags = capa.flags; 7364 wpa_s->drv_flags2 = capa.flags2; 7365 wpa_s->drv_enc = capa.enc; 7366 wpa_s->drv_rrm_flags = capa.rrm_flags; 7367 wpa_s->drv_max_acl_mac_addrs = capa.max_acl_mac_addrs; 7368 wpa_s->probe_resp_offloads = capa.probe_resp_offloads; 7369 wpa_s->max_scan_ssids = capa.max_scan_ssids; 7370 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids; 7371 wpa_s->max_sched_scan_plans = capa.max_sched_scan_plans; 7372 wpa_s->max_sched_scan_plan_interval = 7373 capa.max_sched_scan_plan_interval; 7374 wpa_s->max_sched_scan_plan_iterations = 7375 capa.max_sched_scan_plan_iterations; 7376 wpa_s->sched_scan_supported = capa.sched_scan_supported; 7377 wpa_s->max_match_sets = capa.max_match_sets; 7378 wpa_s->max_remain_on_chan = capa.max_remain_on_chan; 7379 wpa_s->max_stations = capa.max_stations; 7380 wpa_s->extended_capa = capa.extended_capa; 7381 wpa_s->extended_capa_mask = capa.extended_capa_mask; 7382 wpa_s->extended_capa_len = capa.extended_capa_len; 7383 wpa_s->num_multichan_concurrent = 7384 capa.num_multichan_concurrent; 7385 #ifndef CONFIG_NO_WMM_AC 7386 wpa_s->wmm_ac_supported = capa.wmm_ac_supported; 7387 #endif /* CONFIG_NO_WMM_AC */ 7388 wpa_s->max_num_akms = capa.max_num_akms; 7389 7390 if (capa.mac_addr_rand_scan_supported) 7391 wpa_s->mac_addr_rand_supported |= MAC_ADDR_RAND_SCAN; 7392 if (wpa_s->sched_scan_supported && 7393 capa.mac_addr_rand_sched_scan_supported) 7394 wpa_s->mac_addr_rand_supported |= 7395 (MAC_ADDR_RAND_SCHED_SCAN | MAC_ADDR_RAND_PNO); 7396 7397 wpa_drv_get_ext_capa(wpa_s, WPA_IF_STATION); 7398 if (wpa_s->extended_capa && 7399 wpa_s->extended_capa_len >= 3 && 7400 wpa_s->extended_capa[2] & 0x40) 7401 wpa_s->multi_bss_support = 1; 7402 } 7403 #ifdef CONFIG_PASN 7404 wpa_pasn_sm_set_caps(wpa_s->wpa, wpa_s->drv_flags2); 7405 #endif /* CONFIG_PASN */ 7406 wpa_sm_set_driver_bss_selection(wpa_s->wpa, 7407 !!(wpa_s->drv_flags & 7408 WPA_DRIVER_FLAGS_BSS_SELECTION)); 7409 if (wpa_s->max_remain_on_chan == 0) 7410 wpa_s->max_remain_on_chan = 1000; 7411 7412 /* 7413 * Only take p2p_mgmt parameters when P2P Device is supported. 7414 * Doing it here as it determines whether l2_packet_init() will be done 7415 * during wpa_supplicant_driver_init(). 7416 */ 7417 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) 7418 wpa_s->p2p_mgmt = iface->p2p_mgmt; 7419 7420 if (wpa_s->num_multichan_concurrent == 0) 7421 wpa_s->num_multichan_concurrent = 1; 7422 7423 if (wpa_supplicant_driver_init(wpa_s) < 0) 7424 return -1; 7425 7426 #ifdef CONFIG_TDLS 7427 if (!iface->p2p_mgmt && wpa_tdls_init(wpa_s->wpa)) 7428 return -1; 7429 #endif /* CONFIG_TDLS */ 7430 7431 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] && 7432 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) { 7433 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country"); 7434 return -1; 7435 } 7436 7437 #ifdef CONFIG_FST 7438 if (wpa_s->conf->fst_group_id) { 7439 struct fst_iface_cfg cfg; 7440 struct fst_wpa_obj iface_obj; 7441 7442 fst_wpa_supplicant_fill_iface_obj(wpa_s, &iface_obj); 7443 os_strlcpy(cfg.group_id, wpa_s->conf->fst_group_id, 7444 sizeof(cfg.group_id)); 7445 cfg.priority = wpa_s->conf->fst_priority; 7446 cfg.llt = wpa_s->conf->fst_llt; 7447 7448 wpa_s->fst = fst_attach(wpa_s->ifname, wpa_s->own_addr, 7449 &iface_obj, &cfg); 7450 if (!wpa_s->fst) { 7451 wpa_msg(wpa_s, MSG_ERROR, 7452 "FST: Cannot attach iface %s to group %s", 7453 wpa_s->ifname, cfg.group_id); 7454 return -1; 7455 } 7456 } 7457 #endif /* CONFIG_FST */ 7458 7459 if (wpas_wps_init(wpa_s)) 7460 return -1; 7461 7462 #ifdef CONFIG_GAS_SERVER 7463 wpa_s->gas_server = gas_server_init(wpa_s, wpas_gas_server_tx); 7464 if (!wpa_s->gas_server) { 7465 wpa_printf(MSG_ERROR, "Failed to initialize GAS server"); 7466 return -1; 7467 } 7468 #endif /* CONFIG_GAS_SERVER */ 7469 7470 #ifdef CONFIG_DPP 7471 if (wpas_dpp_init(wpa_s) < 0) 7472 return -1; 7473 #endif /* CONFIG_DPP */ 7474 7475 #ifdef CONFIG_NAN_USD 7476 if (wpas_nan_usd_init(wpa_s) < 0) 7477 return -1; 7478 #endif /* CONFIG_NAN_USD */ 7479 7480 if (wpa_supplicant_init_eapol(wpa_s) < 0) 7481 return -1; 7482 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol); 7483 7484 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s); 7485 if (wpa_s->ctrl_iface == NULL) { 7486 wpa_printf(MSG_ERROR, 7487 "Failed to initialize control interface '%s'.\n" 7488 "You may have another wpa_supplicant process " 7489 "already running or the file was\n" 7490 "left by an unclean termination of wpa_supplicant " 7491 "in which case you will need\n" 7492 "to manually remove this file before starting " 7493 "wpa_supplicant again.\n", 7494 wpa_s->conf->ctrl_interface); 7495 return -1; 7496 } 7497 7498 wpa_s->gas = gas_query_init(wpa_s); 7499 if (wpa_s->gas == NULL) { 7500 wpa_printf(MSG_ERROR, "Failed to initialize GAS query"); 7501 return -1; 7502 } 7503 7504 if ((!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) || 7505 wpa_s->p2p_mgmt) && 7506 wpas_p2p_init(wpa_s->global, wpa_s) < 0) { 7507 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P"); 7508 return -1; 7509 } 7510 7511 if (wpa_bss_init(wpa_s) < 0) 7512 return -1; 7513 7514 #ifdef CONFIG_PMKSA_CACHE_EXTERNAL 7515 #ifdef CONFIG_MESH 7516 dl_list_init(&wpa_s->mesh_external_pmksa_cache); 7517 #endif /* CONFIG_MESH */ 7518 #endif /* CONFIG_PMKSA_CACHE_EXTERNAL */ 7519 7520 /* 7521 * Set Wake-on-WLAN triggers, if configured. 7522 * Note: We don't restore/remove the triggers on shutdown (it doesn't 7523 * have effect anyway when the interface is down). 7524 */ 7525 if (capa_res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0) 7526 return -1; 7527 7528 #ifdef CONFIG_EAP_PROXY 7529 { 7530 size_t len; 7531 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, -1, 7532 wpa_s->imsi, &len); 7533 if (wpa_s->mnc_len > 0) { 7534 wpa_s->imsi[len] = '\0'; 7535 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)", 7536 wpa_s->imsi, wpa_s->mnc_len); 7537 } else { 7538 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available"); 7539 } 7540 } 7541 #endif /* CONFIG_EAP_PROXY */ 7542 7543 if (pcsc_reader_init(wpa_s) < 0) 7544 return -1; 7545 7546 if (wpas_init_ext_pw(wpa_s) < 0) 7547 return -1; 7548 7549 #ifndef CONFIG_NO_RRM 7550 wpas_rrm_reset(wpa_s); 7551 #endif /* CONFIG_NO_RRM */ 7552 7553 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans); 7554 7555 #ifdef CONFIG_HS20 7556 hs20_init(wpa_s); 7557 #endif /* CONFIG_HS20 */ 7558 #ifdef CONFIG_MBO 7559 if (!wpa_s->disable_mbo_oce && wpa_s->conf->oce) { 7560 if ((wpa_s->conf->oce & OCE_STA) && 7561 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA)) 7562 wpa_s->enable_oce = OCE_STA; 7563 if ((wpa_s->conf->oce & OCE_STA_CFON) && 7564 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_OCE_STA_CFON)) { 7565 /* TODO: Need to add STA-CFON support */ 7566 wpa_printf(MSG_ERROR, 7567 "OCE STA-CFON feature is not yet supported"); 7568 } 7569 } 7570 wpas_mbo_update_non_pref_chan(wpa_s, wpa_s->conf->non_pref_chan); 7571 #endif /* CONFIG_MBO */ 7572 7573 wpa_supplicant_set_default_scan_ies(wpa_s); 7574 7575 return 0; 7576 } 7577 7578 7579 static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s, 7580 int notify, int terminate) 7581 { 7582 struct wpa_global *global = wpa_s->global; 7583 struct wpa_supplicant *iface, *prev; 7584 7585 if (wpa_s == wpa_s->parent) 7586 wpas_p2p_group_remove(wpa_s, "*"); 7587 7588 iface = global->ifaces; 7589 while (iface) { 7590 if (iface->p2pdev == wpa_s) 7591 iface->p2pdev = iface->parent; 7592 if (iface == wpa_s || iface->parent != wpa_s) { 7593 iface = iface->next; 7594 continue; 7595 } 7596 wpa_printf(MSG_DEBUG, 7597 "Remove remaining child interface %s from parent %s", 7598 iface->ifname, wpa_s->ifname); 7599 prev = iface; 7600 iface = iface->next; 7601 wpa_supplicant_remove_iface(global, prev, terminate); 7602 } 7603 7604 wpa_s->disconnected = 1; 7605 if (wpa_s->drv_priv) { 7606 /* 7607 * Don't deauthenticate if WoWLAN is enable and not explicitly 7608 * been configured to disconnect. 7609 */ 7610 if (!wpa_drv_get_wowlan(wpa_s) || 7611 wpa_s->conf->wowlan_disconnect_on_deinit) { 7612 wpa_supplicant_deauthenticate( 7613 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 7614 7615 wpa_drv_set_countermeasures(wpa_s, 0); 7616 wpa_clear_keys(wpa_s, NULL); 7617 } else { 7618 wpa_msg(wpa_s, MSG_INFO, 7619 "Do not deauthenticate as part of interface deinit since WoWLAN is enabled"); 7620 } 7621 } 7622 7623 wpa_supplicant_cleanup(wpa_s); 7624 wpas_p2p_deinit_iface(wpa_s); 7625 7626 wpas_ctrl_radio_work_flush(wpa_s); 7627 radio_remove_interface(wpa_s); 7628 7629 #ifdef CONFIG_FST 7630 if (wpa_s->fst) { 7631 fst_detach(wpa_s->fst); 7632 wpa_s->fst = NULL; 7633 } 7634 if (wpa_s->received_mb_ies) { 7635 wpabuf_free(wpa_s->received_mb_ies); 7636 wpa_s->received_mb_ies = NULL; 7637 } 7638 #endif /* CONFIG_FST */ 7639 7640 if (wpa_s->drv_priv) 7641 wpa_drv_deinit(wpa_s); 7642 7643 if (notify) 7644 wpas_notify_iface_removed(wpa_s); 7645 7646 if (terminate) 7647 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING); 7648 7649 wpa_supplicant_ctrl_iface_deinit(wpa_s, wpa_s->ctrl_iface); 7650 wpa_s->ctrl_iface = NULL; 7651 7652 #ifdef CONFIG_MESH 7653 if (wpa_s->ifmsh) { 7654 wpa_supplicant_mesh_iface_deinit(wpa_s, wpa_s->ifmsh, true); 7655 wpa_s->ifmsh = NULL; 7656 } 7657 #endif /* CONFIG_MESH */ 7658 7659 if (wpa_s->conf != NULL) { 7660 wpa_config_free(wpa_s->conf); 7661 wpa_s->conf = NULL; 7662 } 7663 7664 os_free(wpa_s->ssids_from_scan_req); 7665 os_free(wpa_s->last_scan_freqs); 7666 7667 os_free(wpa_s); 7668 } 7669 7670 7671 #ifdef CONFIG_MATCH_IFACE 7672 7673 /** 7674 * wpa_supplicant_match_iface - Match an interface description to a name 7675 * @global: Pointer to global data from wpa_supplicant_init() 7676 * @ifname: Name of the interface to match 7677 * Returns: Pointer to the created interface description or %NULL on failure 7678 */ 7679 struct wpa_interface * wpa_supplicant_match_iface(struct wpa_global *global, 7680 const char *ifname) 7681 { 7682 int i; 7683 struct wpa_interface *iface, *miface; 7684 7685 for (i = 0; i < global->params.match_iface_count; i++) { 7686 miface = &global->params.match_ifaces[i]; 7687 if (!miface->ifname || 7688 fnmatch(miface->ifname, ifname, 0) == 0) { 7689 iface = os_zalloc(sizeof(*iface)); 7690 if (!iface) 7691 return NULL; 7692 *iface = *miface; 7693 if (!miface->ifname) 7694 iface->matched = WPA_IFACE_MATCHED_NULL; 7695 else 7696 iface->matched = WPA_IFACE_MATCHED; 7697 iface->ifname = ifname; 7698 return iface; 7699 } 7700 } 7701 7702 return NULL; 7703 } 7704 7705 7706 /** 7707 * wpa_supplicant_match_existing - Match existing interfaces 7708 * @global: Pointer to global data from wpa_supplicant_init() 7709 * Returns: 0 on success, -1 on failure 7710 */ 7711 static int wpa_supplicant_match_existing(struct wpa_global *global) 7712 { 7713 struct if_nameindex *ifi, *ifp; 7714 struct wpa_supplicant *wpa_s; 7715 struct wpa_interface *iface; 7716 7717 ifp = if_nameindex(); 7718 if (!ifp) { 7719 wpa_printf(MSG_ERROR, "if_nameindex: %s", strerror(errno)); 7720 return -1; 7721 } 7722 7723 for (ifi = ifp; ifi->if_name; ifi++) { 7724 wpa_s = wpa_supplicant_get_iface(global, ifi->if_name); 7725 if (wpa_s) 7726 continue; 7727 iface = wpa_supplicant_match_iface(global, ifi->if_name); 7728 if (iface) { 7729 wpa_supplicant_add_iface(global, iface, NULL); 7730 os_free(iface); 7731 } 7732 } 7733 7734 if_freenameindex(ifp); 7735 return 0; 7736 } 7737 7738 #endif /* CONFIG_MATCH_IFACE */ 7739 7740 7741 /** 7742 * wpa_supplicant_add_iface - Add a new network interface 7743 * @global: Pointer to global data from wpa_supplicant_init() 7744 * @iface: Interface configuration options 7745 * @parent: Parent interface or %NULL to assign new interface as parent 7746 * Returns: Pointer to the created interface or %NULL on failure 7747 * 7748 * This function is used to add new network interfaces for %wpa_supplicant. 7749 * This can be called before wpa_supplicant_run() to add interfaces before the 7750 * main event loop has been started. In addition, new interfaces can be added 7751 * dynamically while %wpa_supplicant is already running. This could happen, 7752 * e.g., when a hotplug network adapter is inserted. 7753 */ 7754 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global, 7755 struct wpa_interface *iface, 7756 struct wpa_supplicant *parent) 7757 { 7758 struct wpa_supplicant *wpa_s; 7759 struct wpa_interface t_iface; 7760 struct wpa_ssid *ssid; 7761 7762 if (global == NULL || iface == NULL) 7763 return NULL; 7764 7765 wpa_s = wpa_supplicant_alloc(parent); 7766 if (wpa_s == NULL) 7767 return NULL; 7768 7769 wpa_s->global = global; 7770 7771 t_iface = *iface; 7772 if (global->params.override_driver) { 7773 wpa_printf(MSG_DEBUG, "Override interface parameter: driver " 7774 "('%s' -> '%s')", 7775 iface->driver, global->params.override_driver); 7776 t_iface.driver = global->params.override_driver; 7777 } 7778 if (global->params.override_ctrl_interface) { 7779 wpa_printf(MSG_DEBUG, "Override interface parameter: " 7780 "ctrl_interface ('%s' -> '%s')", 7781 iface->ctrl_interface, 7782 global->params.override_ctrl_interface); 7783 t_iface.ctrl_interface = 7784 global->params.override_ctrl_interface; 7785 } 7786 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) { 7787 wpa_printf(MSG_DEBUG, "Failed to add interface %s", 7788 iface->ifname); 7789 wpa_supplicant_deinit_iface(wpa_s, 0, 0); 7790 return NULL; 7791 } 7792 7793 if (iface->p2p_mgmt == 0) { 7794 /* Notify the control interfaces about new iface */ 7795 if (wpas_notify_iface_added(wpa_s)) { 7796 wpa_supplicant_deinit_iface(wpa_s, 1, 0); 7797 return NULL; 7798 } 7799 7800 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) 7801 wpas_notify_network_added(wpa_s, ssid); 7802 } 7803 7804 wpa_s->next = global->ifaces; 7805 global->ifaces = wpa_s; 7806 7807 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname); 7808 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 7809 7810 #ifdef CONFIG_P2P 7811 if (wpa_s->global->p2p == NULL && 7812 !wpa_s->global->p2p_disabled && !wpa_s->conf->p2p_disabled && 7813 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) && 7814 wpas_p2p_add_p2pdev_interface( 7815 wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) { 7816 wpa_printf(MSG_INFO, 7817 "P2P: Failed to enable P2P Device interface"); 7818 /* Try to continue without. P2P will be disabled. */ 7819 } 7820 #endif /* CONFIG_P2P */ 7821 7822 return wpa_s; 7823 } 7824 7825 7826 /** 7827 * wpa_supplicant_remove_iface - Remove a network interface 7828 * @global: Pointer to global data from wpa_supplicant_init() 7829 * @wpa_s: Pointer to the network interface to be removed 7830 * Returns: 0 if interface was removed, -1 if interface was not found 7831 * 7832 * This function can be used to dynamically remove network interfaces from 7833 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In 7834 * addition, this function is used to remove all remaining interfaces when 7835 * %wpa_supplicant is terminated. 7836 */ 7837 int wpa_supplicant_remove_iface(struct wpa_global *global, 7838 struct wpa_supplicant *wpa_s, 7839 int terminate) 7840 { 7841 struct wpa_supplicant *prev; 7842 #ifdef CONFIG_MESH 7843 unsigned int mesh_if_created = wpa_s->mesh_if_created; 7844 char *ifname = NULL; 7845 struct wpa_supplicant *parent = wpa_s->parent; 7846 #endif /* CONFIG_MESH */ 7847 7848 /* Remove interface from the global list of interfaces */ 7849 prev = global->ifaces; 7850 if (prev == wpa_s) { 7851 global->ifaces = wpa_s->next; 7852 } else { 7853 while (prev && prev->next != wpa_s) 7854 prev = prev->next; 7855 if (prev == NULL) 7856 return -1; 7857 prev->next = wpa_s->next; 7858 } 7859 7860 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname); 7861 7862 #ifdef CONFIG_MESH 7863 if (mesh_if_created) { 7864 ifname = os_strdup(wpa_s->ifname); 7865 if (ifname == NULL) { 7866 wpa_dbg(wpa_s, MSG_ERROR, 7867 "mesh: Failed to malloc ifname"); 7868 return -1; 7869 } 7870 } 7871 #endif /* CONFIG_MESH */ 7872 7873 if (global->p2p_group_formation == wpa_s) 7874 global->p2p_group_formation = NULL; 7875 if (global->p2p_invite_group == wpa_s) 7876 global->p2p_invite_group = NULL; 7877 wpa_supplicant_deinit_iface(wpa_s, 1, terminate); 7878 7879 #ifdef CONFIG_MESH 7880 if (mesh_if_created) { 7881 wpa_drv_if_remove(parent, WPA_IF_MESH, ifname); 7882 os_free(ifname); 7883 } 7884 #endif /* CONFIG_MESH */ 7885 7886 return 0; 7887 } 7888 7889 7890 /** 7891 * wpa_supplicant_get_eap_mode - Get the current EAP mode 7892 * @wpa_s: Pointer to the network interface 7893 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found 7894 */ 7895 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s) 7896 { 7897 const char *eapol_method; 7898 7899 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 && 7900 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 7901 return "NO-EAP"; 7902 } 7903 7904 eapol_method = eapol_sm_get_method_name(wpa_s->eapol); 7905 if (eapol_method == NULL) 7906 return "UNKNOWN-EAP"; 7907 7908 return eapol_method; 7909 } 7910 7911 7912 /** 7913 * wpa_supplicant_get_iface - Get a new network interface 7914 * @global: Pointer to global data from wpa_supplicant_init() 7915 * @ifname: Interface name 7916 * Returns: Pointer to the interface or %NULL if not found 7917 */ 7918 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global, 7919 const char *ifname) 7920 { 7921 struct wpa_supplicant *wpa_s; 7922 7923 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 7924 if (os_strcmp(wpa_s->ifname, ifname) == 0) 7925 return wpa_s; 7926 } 7927 return NULL; 7928 } 7929 7930 7931 #ifndef CONFIG_NO_WPA_MSG 7932 static const char * wpa_supplicant_msg_ifname_cb(void *ctx) 7933 { 7934 struct wpa_supplicant *wpa_s = ctx; 7935 if (wpa_s == NULL) 7936 return NULL; 7937 return wpa_s->ifname; 7938 } 7939 #endif /* CONFIG_NO_WPA_MSG */ 7940 7941 7942 #ifndef WPA_SUPPLICANT_CLEANUP_INTERVAL 7943 #define WPA_SUPPLICANT_CLEANUP_INTERVAL 10 7944 #endif /* WPA_SUPPLICANT_CLEANUP_INTERVAL */ 7945 7946 /* Periodic cleanup tasks */ 7947 static void wpas_periodic(void *eloop_ctx, void *timeout_ctx) 7948 { 7949 struct wpa_global *global = eloop_ctx; 7950 struct wpa_supplicant *wpa_s; 7951 7952 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0, 7953 wpas_periodic, global, NULL); 7954 7955 #ifdef CONFIG_P2P 7956 if (global->p2p) 7957 p2p_expire_peers(global->p2p); 7958 #endif /* CONFIG_P2P */ 7959 7960 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 7961 wpa_bss_flush_by_age(wpa_s, wpa_s->conf->bss_expiration_age); 7962 #ifdef CONFIG_AP 7963 ap_periodic(wpa_s); 7964 #endif /* CONFIG_AP */ 7965 } 7966 } 7967 7968 7969 /** 7970 * wpa_supplicant_init - Initialize %wpa_supplicant 7971 * @params: Parameters for %wpa_supplicant 7972 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure 7973 * 7974 * This function is used to initialize %wpa_supplicant. After successful 7975 * initialization, the returned data pointer can be used to add and remove 7976 * network interfaces, and eventually, to deinitialize %wpa_supplicant. 7977 */ 7978 struct wpa_global * wpa_supplicant_init(struct wpa_params *params) 7979 { 7980 struct wpa_global *global; 7981 int ret, i; 7982 7983 if (params == NULL) 7984 return NULL; 7985 7986 #ifdef CONFIG_DRIVER_NDIS 7987 { 7988 void driver_ndis_init_ops(void); 7989 driver_ndis_init_ops(); 7990 } 7991 #endif /* CONFIG_DRIVER_NDIS */ 7992 7993 #ifndef CONFIG_NO_WPA_MSG 7994 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb); 7995 #endif /* CONFIG_NO_WPA_MSG */ 7996 7997 if (params->wpa_debug_file_path) 7998 wpa_debug_open_file(params->wpa_debug_file_path); 7999 if (!params->wpa_debug_file_path && !params->wpa_debug_syslog) 8000 wpa_debug_setup_stdout(); 8001 if (params->wpa_debug_syslog) 8002 wpa_debug_open_syslog(); 8003 if (params->wpa_debug_tracing) { 8004 ret = wpa_debug_open_linux_tracing(); 8005 if (ret) { 8006 wpa_printf(MSG_ERROR, 8007 "Failed to enable trace logging"); 8008 return NULL; 8009 } 8010 } 8011 8012 ret = eap_register_methods(); 8013 if (ret) { 8014 wpa_printf(MSG_ERROR, "Failed to register EAP methods"); 8015 if (ret == -2) 8016 wpa_printf(MSG_ERROR, "Two or more EAP methods used " 8017 "the same EAP type."); 8018 return NULL; 8019 } 8020 8021 global = os_zalloc(sizeof(*global)); 8022 if (global == NULL) 8023 return NULL; 8024 dl_list_init(&global->p2p_srv_bonjour); 8025 dl_list_init(&global->p2p_srv_upnp); 8026 global->params.daemonize = params->daemonize; 8027 global->params.wait_for_monitor = params->wait_for_monitor; 8028 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface; 8029 8030 if (params->pid_file) { 8031 global->params.pid_file = os_strdup(params->pid_file); 8032 if (!global->params.pid_file) { 8033 wpa_supplicant_deinit(global); 8034 return NULL; 8035 } 8036 } 8037 8038 if (params->ctrl_interface) { 8039 global->params.ctrl_interface = 8040 os_strdup(params->ctrl_interface); 8041 if (!global->params.ctrl_interface) { 8042 wpa_supplicant_deinit(global); 8043 return NULL; 8044 } 8045 } 8046 8047 if (params->ctrl_interface_group) { 8048 global->params.ctrl_interface_group = 8049 os_strdup(params->ctrl_interface_group); 8050 if (!global->params.ctrl_interface_group) { 8051 wpa_supplicant_deinit(global); 8052 return NULL; 8053 } 8054 } 8055 8056 if (params->override_driver) { 8057 global->params.override_driver = 8058 os_strdup(params->override_driver); 8059 if (!global->params.override_driver) { 8060 wpa_supplicant_deinit(global); 8061 return NULL; 8062 } 8063 } 8064 8065 if (params->override_ctrl_interface) { 8066 global->params.override_ctrl_interface = 8067 os_strdup(params->override_ctrl_interface); 8068 if (!global->params.override_ctrl_interface) { 8069 wpa_supplicant_deinit(global); 8070 return NULL; 8071 } 8072 } 8073 8074 #ifdef CONFIG_MATCH_IFACE 8075 global->params.match_iface_count = params->match_iface_count; 8076 if (params->match_iface_count) { 8077 global->params.match_ifaces = 8078 os_calloc(params->match_iface_count, 8079 sizeof(struct wpa_interface)); 8080 if (!global->params.match_ifaces) { 8081 wpa_printf(MSG_ERROR, 8082 "Failed to allocate match interfaces"); 8083 wpa_supplicant_deinit(global); 8084 return NULL; 8085 } 8086 os_memcpy(global->params.match_ifaces, 8087 params->match_ifaces, 8088 params->match_iface_count * 8089 sizeof(struct wpa_interface)); 8090 } 8091 #endif /* CONFIG_MATCH_IFACE */ 8092 #ifdef CONFIG_P2P 8093 if (params->conf_p2p_dev) { 8094 global->params.conf_p2p_dev = 8095 os_strdup(params->conf_p2p_dev); 8096 if (!global->params.conf_p2p_dev) { 8097 wpa_printf(MSG_ERROR, "Failed to allocate conf p2p"); 8098 wpa_supplicant_deinit(global); 8099 return NULL; 8100 } 8101 } 8102 #endif /* CONFIG_P2P */ 8103 wpa_debug_level = global->params.wpa_debug_level = 8104 params->wpa_debug_level; 8105 wpa_debug_show_keys = global->params.wpa_debug_show_keys = 8106 params->wpa_debug_show_keys; 8107 wpa_debug_timestamp = global->params.wpa_debug_timestamp = 8108 params->wpa_debug_timestamp; 8109 8110 wpa_printf(MSG_DEBUG, "wpa_supplicant v%s", VERSION_STR); 8111 8112 if (eloop_init()) { 8113 wpa_printf(MSG_ERROR, "Failed to initialize event loop"); 8114 wpa_supplicant_deinit(global); 8115 return NULL; 8116 } 8117 8118 random_init(params->entropy_file); 8119 8120 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global); 8121 if (global->ctrl_iface == NULL) { 8122 wpa_supplicant_deinit(global); 8123 return NULL; 8124 } 8125 8126 if (wpas_notify_supplicant_initialized(global)) { 8127 wpa_supplicant_deinit(global); 8128 return NULL; 8129 } 8130 8131 for (i = 0; wpa_drivers[i]; i++) 8132 global->drv_count++; 8133 if (global->drv_count == 0) { 8134 wpa_printf(MSG_ERROR, "No drivers enabled"); 8135 wpa_supplicant_deinit(global); 8136 return NULL; 8137 } 8138 global->drv_priv = os_calloc(global->drv_count, sizeof(void *)); 8139 if (global->drv_priv == NULL) { 8140 wpa_supplicant_deinit(global); 8141 return NULL; 8142 } 8143 8144 #ifdef CONFIG_WIFI_DISPLAY 8145 if (wifi_display_init(global) < 0) { 8146 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display"); 8147 wpa_supplicant_deinit(global); 8148 return NULL; 8149 } 8150 #endif /* CONFIG_WIFI_DISPLAY */ 8151 8152 eloop_register_timeout(WPA_SUPPLICANT_CLEANUP_INTERVAL, 0, 8153 wpas_periodic, global, NULL); 8154 8155 return global; 8156 } 8157 8158 8159 /** 8160 * wpa_supplicant_run - Run the %wpa_supplicant main event loop 8161 * @global: Pointer to global data from wpa_supplicant_init() 8162 * Returns: 0 after successful event loop run, -1 on failure 8163 * 8164 * This function starts the main event loop and continues running as long as 8165 * there are any remaining events. In most cases, this function is running as 8166 * long as the %wpa_supplicant process in still in use. 8167 */ 8168 int wpa_supplicant_run(struct wpa_global *global) 8169 { 8170 struct wpa_supplicant *wpa_s; 8171 8172 if (global->params.daemonize && 8173 (wpa_supplicant_daemon(global->params.pid_file) || 8174 eloop_sock_requeue())) 8175 return -1; 8176 8177 #ifdef CONFIG_MATCH_IFACE 8178 if (wpa_supplicant_match_existing(global)) 8179 return -1; 8180 #endif 8181 8182 if (global->params.wait_for_monitor) { 8183 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) 8184 if (wpa_s->ctrl_iface && !wpa_s->p2p_mgmt) 8185 wpa_supplicant_ctrl_iface_wait( 8186 wpa_s->ctrl_iface); 8187 } 8188 8189 eloop_register_signal_terminate(wpa_supplicant_terminate, global); 8190 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global); 8191 8192 eloop_run(); 8193 8194 return 0; 8195 } 8196 8197 8198 /** 8199 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant 8200 * @global: Pointer to global data from wpa_supplicant_init() 8201 * 8202 * This function is called to deinitialize %wpa_supplicant and to free all 8203 * allocated resources. Remaining network interfaces will also be removed. 8204 */ 8205 void wpa_supplicant_deinit(struct wpa_global *global) 8206 { 8207 int i; 8208 8209 if (global == NULL) 8210 return; 8211 8212 eloop_cancel_timeout(wpas_periodic, global, NULL); 8213 8214 #ifdef CONFIG_WIFI_DISPLAY 8215 wifi_display_deinit(global); 8216 #endif /* CONFIG_WIFI_DISPLAY */ 8217 8218 while (global->ifaces) 8219 wpa_supplicant_remove_iface(global, global->ifaces, 1); 8220 8221 if (global->ctrl_iface) 8222 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface); 8223 8224 wpas_notify_supplicant_deinitialized(global); 8225 8226 eap_peer_unregister_methods(); 8227 #ifdef CONFIG_AP 8228 eap_server_unregister_methods(); 8229 #endif /* CONFIG_AP */ 8230 8231 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) { 8232 if (!global->drv_priv[i]) 8233 continue; 8234 wpa_drivers[i]->global_deinit(global->drv_priv[i]); 8235 } 8236 os_free(global->drv_priv); 8237 8238 random_deinit(); 8239 8240 eloop_destroy(); 8241 8242 if (global->params.pid_file) { 8243 os_daemonize_terminate(global->params.pid_file); 8244 os_free(global->params.pid_file); 8245 } 8246 os_free(global->params.ctrl_interface); 8247 os_free(global->params.ctrl_interface_group); 8248 os_free(global->params.override_driver); 8249 os_free(global->params.override_ctrl_interface); 8250 #ifdef CONFIG_MATCH_IFACE 8251 os_free(global->params.match_ifaces); 8252 #endif /* CONFIG_MATCH_IFACE */ 8253 #ifdef CONFIG_P2P 8254 os_free(global->params.conf_p2p_dev); 8255 #endif /* CONFIG_P2P */ 8256 8257 os_free(global->p2p_disallow_freq.range); 8258 os_free(global->p2p_go_avoid_freq.range); 8259 os_free(global->add_psk); 8260 8261 os_free(global); 8262 wpa_debug_close_syslog(); 8263 wpa_debug_close_file(); 8264 wpa_debug_close_linux_tracing(); 8265 } 8266 8267 8268 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s) 8269 { 8270 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) && 8271 wpa_s->conf->country[0] && wpa_s->conf->country[1]) { 8272 char country[3]; 8273 country[0] = wpa_s->conf->country[0]; 8274 country[1] = wpa_s->conf->country[1]; 8275 country[2] = '\0'; 8276 if (wpa_drv_set_country(wpa_s, country) < 0) { 8277 wpa_printf(MSG_ERROR, "Failed to set country code " 8278 "'%s'", country); 8279 } 8280 } 8281 8282 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND) 8283 wpas_init_ext_pw(wpa_s); 8284 8285 if (wpa_s->conf->changed_parameters & CFG_CHANGED_SCHED_SCAN_PLANS) 8286 wpas_sched_scan_plans_set(wpa_s, wpa_s->conf->sched_scan_plans); 8287 8288 if (wpa_s->conf->changed_parameters & CFG_CHANGED_WOWLAN_TRIGGERS) { 8289 struct wpa_driver_capa capa; 8290 int res = wpa_drv_get_capa(wpa_s, &capa); 8291 8292 if (res == 0 && wpas_set_wowlan_triggers(wpa_s, &capa) < 0) 8293 wpa_printf(MSG_ERROR, 8294 "Failed to update wowlan_triggers to '%s'", 8295 wpa_s->conf->wowlan_triggers); 8296 } 8297 8298 if (wpa_s->conf->changed_parameters & CFG_CHANGED_DISABLE_BTM) 8299 wpa_supplicant_set_default_scan_ies(wpa_s); 8300 8301 if (wpa_s->conf->changed_parameters & CFG_CHANGED_FT_PREPEND_PMKID) 8302 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_FT_PREPEND_PMKID, 8303 wpa_s->conf->ft_prepend_pmkid); 8304 8305 #ifdef CONFIG_BGSCAN 8306 /* 8307 * We default to global bgscan parameters only when per-network bgscan 8308 * parameters aren't set. Only bother resetting bgscan parameters if 8309 * this is the case. 8310 */ 8311 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_BGSCAN) && 8312 wpa_s->current_ssid && !wpa_s->current_ssid->bgscan && 8313 wpa_s->wpa_state == WPA_COMPLETED) 8314 wpa_supplicant_reset_bgscan(wpa_s); 8315 #endif /* CONFIG_BGSCAN */ 8316 8317 #ifdef CONFIG_WPS 8318 wpas_wps_update_config(wpa_s); 8319 #endif /* CONFIG_WPS */ 8320 wpas_p2p_update_config(wpa_s); 8321 wpa_s->conf->changed_parameters = 0; 8322 } 8323 8324 8325 void add_freq(int *freqs, int *num_freqs, int freq) 8326 { 8327 int i; 8328 8329 for (i = 0; i < *num_freqs; i++) { 8330 if (freqs[i] == freq) 8331 return; 8332 } 8333 8334 freqs[*num_freqs] = freq; 8335 (*num_freqs)++; 8336 } 8337 8338 8339 static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s) 8340 { 8341 struct wpa_bss *bss, *cbss; 8342 const int max_freqs = 10; 8343 int *freqs; 8344 int num_freqs = 0; 8345 8346 freqs = os_calloc(max_freqs + 1, sizeof(int)); 8347 if (freqs == NULL) 8348 return NULL; 8349 8350 cbss = wpa_s->current_bss; 8351 8352 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) { 8353 if (bss == cbss) 8354 continue; 8355 if (bss->ssid_len == cbss->ssid_len && 8356 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 && 8357 !wpa_bssid_ignore_is_listed(wpa_s, bss->bssid)) { 8358 add_freq(freqs, &num_freqs, bss->freq); 8359 if (num_freqs == max_freqs) 8360 break; 8361 } 8362 } 8363 8364 if (num_freqs == 0) { 8365 os_free(freqs); 8366 freqs = NULL; 8367 } 8368 8369 return freqs; 8370 } 8371 8372 8373 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid, 8374 const u8 **link_bssids) 8375 { 8376 int timeout; 8377 int count; 8378 int *freqs = NULL; 8379 8380 wpas_connect_work_done(wpa_s); 8381 8382 /* 8383 * Remove possible authentication timeout since the connection failed. 8384 */ 8385 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 8386 8387 /* 8388 * There is no point in ignoring the AP temporarily if this event is 8389 * generated based on local request to disconnect. 8390 */ 8391 if (wpa_s->own_disconnect_req || wpa_s->own_reconnect_req) { 8392 wpa_s->own_disconnect_req = 0; 8393 wpa_dbg(wpa_s, MSG_DEBUG, 8394 "Ignore connection failure due to local request to disconnect"); 8395 return; 8396 } 8397 if (wpa_s->disconnected) { 8398 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure " 8399 "indication since interface has been put into " 8400 "disconnected state"); 8401 return; 8402 } 8403 8404 /* Also mark links as failed */ 8405 while (link_bssids && *link_bssids) { 8406 wpa_bssid_ignore_add(wpa_s, *link_bssids); 8407 link_bssids++; 8408 } 8409 8410 /* 8411 * Add the failed BSSID into the ignore list and speed up next scan 8412 * attempt if there could be other APs that could accept association. 8413 */ 8414 count = wpa_bssid_ignore_add(wpa_s, bssid); 8415 if (count == 1 && wpa_s->current_bss) { 8416 /* 8417 * This BSS was not in the ignore list before. If there is 8418 * another BSS available for the same ESS, we should try that 8419 * next. Otherwise, we may as well try this one once more 8420 * before allowing other, likely worse, ESSes to be considered. 8421 */ 8422 freqs = get_bss_freqs_in_ess(wpa_s); 8423 if (freqs) { 8424 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS " 8425 "has been seen; try it next"); 8426 wpa_bssid_ignore_add(wpa_s, bssid); 8427 /* 8428 * On the next scan, go through only the known channels 8429 * used in this ESS based on previous scans to speed up 8430 * common load balancing use case. 8431 */ 8432 os_free(wpa_s->next_scan_freqs); 8433 wpa_s->next_scan_freqs = freqs; 8434 } 8435 } 8436 8437 wpa_s->consecutive_conn_failures++; 8438 8439 if (wpa_s->consecutive_conn_failures > 3 && wpa_s->current_ssid) { 8440 wpa_printf(MSG_DEBUG, "Continuous association failures - " 8441 "consider temporary network disabling"); 8442 wpas_auth_failed(wpa_s, "CONN_FAILED", bssid); 8443 } 8444 /* 8445 * Multiple consecutive connection failures mean that other APs are 8446 * either not available or have already been tried, so we can start 8447 * increasing the delay here to avoid constant scanning. 8448 */ 8449 switch (wpa_s->consecutive_conn_failures) { 8450 case 1: 8451 timeout = 100; 8452 break; 8453 case 2: 8454 timeout = 500; 8455 break; 8456 case 3: 8457 timeout = 1000; 8458 break; 8459 case 4: 8460 timeout = 5000; 8461 break; 8462 default: 8463 timeout = 10000; 8464 break; 8465 } 8466 8467 wpa_dbg(wpa_s, MSG_DEBUG, 8468 "Consecutive connection failures: %d --> request scan in %d ms", 8469 wpa_s->consecutive_conn_failures, timeout); 8470 8471 /* 8472 * TODO: if more than one possible AP is available in scan results, 8473 * could try the other ones before requesting a new scan. 8474 */ 8475 8476 /* speed up the connection attempt with normal scan */ 8477 wpa_s->normal_scans = 0; 8478 wpa_supplicant_req_scan(wpa_s, timeout / 1000, 8479 1000 * (timeout % 1000)); 8480 } 8481 8482 8483 #ifdef CONFIG_FILS 8484 8485 void fils_pmksa_cache_flush(struct wpa_supplicant *wpa_s) 8486 { 8487 struct wpa_ssid *ssid = wpa_s->current_ssid; 8488 const u8 *realm, *username, *rrk; 8489 size_t realm_len, username_len, rrk_len; 8490 u16 next_seq_num; 8491 8492 /* Clear the PMKSA cache entry if FILS authentication was rejected. 8493 * Check for ERP keys existing to limit when this can be done since 8494 * the rejection response is not protected and such triggers should 8495 * really not allow internal state to be modified unless required to 8496 * avoid significant issues in functionality. In addition, drop 8497 * externally configure PMKSA entries even without ERP keys since it 8498 * is possible for an external component to add PMKSA entries for FILS 8499 * authentication without restoring previously generated ERP keys. 8500 * 8501 * In this case, this is needed to allow recovery from cases where the 8502 * AP or authentication server has dropped PMKSAs and ERP keys. */ 8503 if (!ssid || !ssid->eap.erp || !wpa_key_mgmt_fils(ssid->key_mgmt)) 8504 return; 8505 8506 if (eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, 8507 &username, &username_len, 8508 &realm, &realm_len, &next_seq_num, 8509 &rrk, &rrk_len) != 0 || 8510 !realm) { 8511 wpa_dbg(wpa_s, MSG_DEBUG, 8512 "FILS: Drop external PMKSA cache entry"); 8513 wpa_sm_aborted_external_cached(wpa_s->wpa); 8514 wpa_sm_external_pmksa_cache_flush(wpa_s->wpa, ssid); 8515 return; 8516 } 8517 8518 wpa_dbg(wpa_s, MSG_DEBUG, "FILS: Drop PMKSA cache entry"); 8519 wpa_sm_aborted_cached(wpa_s->wpa); 8520 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid); 8521 } 8522 8523 8524 void fils_connection_failure(struct wpa_supplicant *wpa_s) 8525 { 8526 struct wpa_ssid *ssid = wpa_s->current_ssid; 8527 const u8 *realm, *username, *rrk; 8528 size_t realm_len, username_len, rrk_len; 8529 u16 next_seq_num; 8530 8531 if (!ssid || !ssid->eap.erp || !wpa_key_mgmt_fils(ssid->key_mgmt) || 8532 eapol_sm_get_erp_info(wpa_s->eapol, &ssid->eap, 8533 &username, &username_len, 8534 &realm, &realm_len, &next_seq_num, 8535 &rrk, &rrk_len) != 0 || 8536 !realm) 8537 return; 8538 8539 wpa_hexdump_ascii(MSG_DEBUG, 8540 "FILS: Store last connection failure realm", 8541 realm, realm_len); 8542 os_free(wpa_s->last_con_fail_realm); 8543 wpa_s->last_con_fail_realm = os_malloc(realm_len); 8544 if (wpa_s->last_con_fail_realm) { 8545 wpa_s->last_con_fail_realm_len = realm_len; 8546 os_memcpy(wpa_s->last_con_fail_realm, realm, realm_len); 8547 } 8548 } 8549 #endif /* CONFIG_FILS */ 8550 8551 8552 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s) 8553 { 8554 return wpa_s->conf->ap_scan == 2 || 8555 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION); 8556 } 8557 8558 8559 #if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW) 8560 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s, 8561 struct wpa_ssid *ssid, 8562 const char *field, 8563 const char *value) 8564 { 8565 #ifdef IEEE8021X_EAPOL 8566 struct eap_peer_config *eap = &ssid->eap; 8567 8568 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field); 8569 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value", 8570 (const u8 *) value, os_strlen(value)); 8571 8572 switch (wpa_supplicant_ctrl_req_from_string(field)) { 8573 case WPA_CTRL_REQ_EAP_IDENTITY: 8574 os_free(eap->identity); 8575 eap->identity = (u8 *) os_strdup(value); 8576 if (!eap->identity) 8577 return -1; 8578 eap->identity_len = os_strlen(value); 8579 eap->pending_req_identity = 0; 8580 if (ssid == wpa_s->current_ssid) 8581 wpa_s->reassociate = 1; 8582 break; 8583 case WPA_CTRL_REQ_EAP_PASSWORD: 8584 bin_clear_free(eap->password, eap->password_len); 8585 eap->password = (u8 *) os_strdup(value); 8586 if (!eap->password) 8587 return -1; 8588 eap->password_len = os_strlen(value); 8589 eap->pending_req_password = 0; 8590 if (ssid == wpa_s->current_ssid) 8591 wpa_s->reassociate = 1; 8592 break; 8593 case WPA_CTRL_REQ_EAP_NEW_PASSWORD: 8594 bin_clear_free(eap->new_password, eap->new_password_len); 8595 eap->new_password = (u8 *) os_strdup(value); 8596 if (!eap->new_password) 8597 return -1; 8598 eap->new_password_len = os_strlen(value); 8599 eap->pending_req_new_password = 0; 8600 if (ssid == wpa_s->current_ssid) 8601 wpa_s->reassociate = 1; 8602 break; 8603 case WPA_CTRL_REQ_EAP_PIN: 8604 str_clear_free(eap->cert.pin); 8605 eap->cert.pin = os_strdup(value); 8606 if (!eap->cert.pin) 8607 return -1; 8608 eap->pending_req_pin = 0; 8609 if (ssid == wpa_s->current_ssid) 8610 wpa_s->reassociate = 1; 8611 break; 8612 case WPA_CTRL_REQ_EAP_OTP: 8613 bin_clear_free(eap->otp, eap->otp_len); 8614 eap->otp = (u8 *) os_strdup(value); 8615 if (!eap->otp) 8616 return -1; 8617 eap->otp_len = os_strlen(value); 8618 os_free(eap->pending_req_otp); 8619 eap->pending_req_otp = NULL; 8620 eap->pending_req_otp_len = 0; 8621 break; 8622 case WPA_CTRL_REQ_EAP_PASSPHRASE: 8623 str_clear_free(eap->cert.private_key_passwd); 8624 eap->cert.private_key_passwd = os_strdup(value); 8625 if (!eap->cert.private_key_passwd) 8626 return -1; 8627 eap->pending_req_passphrase = 0; 8628 if (ssid == wpa_s->current_ssid) 8629 wpa_s->reassociate = 1; 8630 break; 8631 case WPA_CTRL_REQ_SIM: 8632 str_clear_free(eap->external_sim_resp); 8633 eap->external_sim_resp = os_strdup(value); 8634 if (!eap->external_sim_resp) 8635 return -1; 8636 eap->pending_req_sim = 0; 8637 break; 8638 case WPA_CTRL_REQ_PSK_PASSPHRASE: 8639 if (wpa_config_set(ssid, "psk", value, 0) < 0) 8640 return -1; 8641 ssid->mem_only_psk = 1; 8642 if (ssid->passphrase) 8643 wpa_config_update_psk(ssid); 8644 if (wpa_s->wpa_state == WPA_SCANNING && !wpa_s->scanning) 8645 wpa_supplicant_req_scan(wpa_s, 0, 0); 8646 break; 8647 case WPA_CTRL_REQ_EXT_CERT_CHECK: 8648 if (eap->pending_ext_cert_check != PENDING_CHECK) 8649 return -1; 8650 if (os_strcmp(value, "good") == 0) 8651 eap->pending_ext_cert_check = EXT_CERT_CHECK_GOOD; 8652 else if (os_strcmp(value, "bad") == 0) 8653 eap->pending_ext_cert_check = EXT_CERT_CHECK_BAD; 8654 else 8655 return -1; 8656 break; 8657 default: 8658 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field); 8659 return -1; 8660 } 8661 8662 return 0; 8663 #else /* IEEE8021X_EAPOL */ 8664 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included"); 8665 return -1; 8666 #endif /* IEEE8021X_EAPOL */ 8667 } 8668 #endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */ 8669 8670 8671 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid) 8672 { 8673 #ifdef CONFIG_WEP 8674 int i; 8675 unsigned int drv_enc; 8676 #endif /* CONFIG_WEP */ 8677 8678 if (wpa_s->p2p_mgmt) 8679 return 1; /* no normal network profiles on p2p_mgmt interface */ 8680 8681 if (ssid == NULL) 8682 return 1; 8683 8684 if (ssid->disabled) 8685 return 1; 8686 8687 #ifdef CONFIG_WEP 8688 if (wpa_s->drv_capa_known) 8689 drv_enc = wpa_s->drv_enc; 8690 else 8691 drv_enc = (unsigned int) -1; 8692 8693 for (i = 0; i < NUM_WEP_KEYS; i++) { 8694 size_t len = ssid->wep_key_len[i]; 8695 if (len == 0) 8696 continue; 8697 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40)) 8698 continue; 8699 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104)) 8700 continue; 8701 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128)) 8702 continue; 8703 return 1; /* invalid WEP key */ 8704 } 8705 #endif /* CONFIG_WEP */ 8706 8707 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set && 8708 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk && 8709 !(wpa_key_mgmt_sae(ssid->key_mgmt) && ssid->sae_password) && 8710 !ssid->mem_only_psk) 8711 return 1; 8712 8713 #ifdef IEEE8021X_EAPOL 8714 #ifdef CRYPTO_RSA_OAEP_SHA256 8715 if (ssid->eap.imsi_privacy_cert) { 8716 struct crypto_rsa_key *key; 8717 bool failed = false; 8718 8719 key = crypto_rsa_key_read(ssid->eap.imsi_privacy_cert, false); 8720 if (!key) 8721 failed = true; 8722 crypto_rsa_key_free(key); 8723 if (failed) { 8724 wpa_printf(MSG_DEBUG, 8725 "Invalid imsi_privacy_cert (%s) - disable network", 8726 ssid->eap.imsi_privacy_cert); 8727 return 1; 8728 } 8729 } 8730 #endif /* CRYPTO_RSA_OAEP_SHA256 */ 8731 #endif /* IEEE8021X_EAPOL */ 8732 8733 return 0; 8734 } 8735 8736 8737 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid) 8738 { 8739 if (ssid == NULL || ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT) { 8740 if (wpa_s->conf->pmf == MGMT_FRAME_PROTECTION_OPTIONAL && 8741 !(wpa_s->drv_enc & WPA_DRIVER_CAPA_ENC_BIP)) { 8742 /* 8743 * Driver does not support BIP -- ignore pmf=1 default 8744 * since the connection with PMF would fail and the 8745 * configuration does not require PMF to be enabled. 8746 */ 8747 return NO_MGMT_FRAME_PROTECTION; 8748 } 8749 8750 if (ssid && 8751 (ssid->key_mgmt & 8752 ~(WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPS | 8753 WPA_KEY_MGMT_IEEE8021X_NO_WPA)) == 0) { 8754 /* 8755 * Do not use the default PMF value for non-RSN networks 8756 * since PMF is available only with RSN and pmf=2 8757 * configuration would otherwise prevent connections to 8758 * all open networks. 8759 */ 8760 return NO_MGMT_FRAME_PROTECTION; 8761 } 8762 8763 #ifdef CONFIG_OCV 8764 /* Enable PMF if OCV is being enabled */ 8765 if (wpa_s->conf->pmf == NO_MGMT_FRAME_PROTECTION && 8766 ssid && ssid->ocv) 8767 return MGMT_FRAME_PROTECTION_OPTIONAL; 8768 #endif /* CONFIG_OCV */ 8769 8770 return wpa_s->conf->pmf; 8771 } 8772 8773 return ssid->ieee80211w; 8774 } 8775 8776 8777 #ifdef CONFIG_SAE 8778 bool wpas_is_sae_avoided(struct wpa_supplicant *wpa_s, 8779 struct wpa_ssid *ssid, 8780 const struct wpa_ie_data *ie) 8781 { 8782 return wpa_s->conf->sae_check_mfp && 8783 (!(ie->capabilities & 8784 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) || 8785 wpas_get_ssid_pmf(wpa_s, ssid) == NO_MGMT_FRAME_PROTECTION); 8786 } 8787 #endif /* CONFIG_SAE */ 8788 8789 8790 int pmf_in_use(struct wpa_supplicant *wpa_s, const u8 *addr) 8791 { 8792 if (wpa_s->current_ssid == NULL || 8793 wpa_s->wpa_state < WPA_4WAY_HANDSHAKE) 8794 return 0; 8795 if (wpa_s->valid_links) { 8796 if (!ether_addr_equal(addr, wpa_s->ap_mld_addr) && 8797 !wpas_ap_link_address(wpa_s, addr)) 8798 return 0; 8799 } else { 8800 if (!ether_addr_equal(addr, wpa_s->bssid)) 8801 return 0; 8802 } 8803 return wpa_sm_pmf_enabled(wpa_s->wpa); 8804 } 8805 8806 8807 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s) 8808 { 8809 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P) 8810 return 1; 8811 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA) 8812 return 0; 8813 return -1; 8814 } 8815 8816 8817 void wpas_auth_failed(struct wpa_supplicant *wpa_s, const char *reason, 8818 const u8 *bssid) 8819 { 8820 struct wpa_ssid *ssid = wpa_s->current_ssid; 8821 int dur; 8822 struct os_reltime now; 8823 8824 if (ssid == NULL) { 8825 wpa_printf(MSG_DEBUG, "Authentication failure but no known " 8826 "SSID block"); 8827 return; 8828 } 8829 8830 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS) 8831 return; 8832 8833 ssid->auth_failures++; 8834 8835 #ifdef CONFIG_P2P 8836 if (ssid->p2p_group && 8837 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) { 8838 /* 8839 * Skip the wait time since there is a short timeout on the 8840 * connection to a P2P group. 8841 */ 8842 return; 8843 } 8844 #endif /* CONFIG_P2P */ 8845 8846 if (ssid->auth_failures > 50) 8847 dur = 300; 8848 else if (ssid->auth_failures > 10) 8849 dur = 120; 8850 else if (ssid->auth_failures > 5) 8851 dur = 90; 8852 else if (ssid->auth_failures > 3) 8853 dur = 60; 8854 else if (ssid->auth_failures > 2) 8855 dur = 30; 8856 else if (ssid->auth_failures > 1) 8857 dur = 20; 8858 else 8859 dur = 10; 8860 8861 if (ssid->auth_failures > 1 && 8862 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) 8863 dur += os_random() % (ssid->auth_failures * 10); 8864 8865 os_get_reltime(&now); 8866 if (now.sec + dur <= ssid->disabled_until.sec) 8867 return; 8868 8869 ssid->disabled_until.sec = now.sec + dur; 8870 8871 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED 8872 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s", 8873 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len), 8874 ssid->auth_failures, dur, reason); 8875 8876 if (bssid) 8877 os_memcpy(ssid->disabled_due_to, bssid, ETH_ALEN); 8878 } 8879 8880 8881 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s, 8882 struct wpa_ssid *ssid, int clear_failures) 8883 { 8884 if (ssid == NULL) 8885 return; 8886 8887 if (ssid->disabled_until.sec) { 8888 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED 8889 "id=%d ssid=\"%s\"", 8890 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); 8891 } 8892 ssid->disabled_until.sec = 0; 8893 ssid->disabled_until.usec = 0; 8894 if (clear_failures) { 8895 ssid->auth_failures = 0; 8896 } else if (!is_zero_ether_addr(ssid->disabled_due_to)) { 8897 wpa_printf(MSG_DEBUG, "Mark BSSID " MACSTR 8898 " ignored to allow a lower priority BSS, if any, to be tried next", 8899 MAC2STR(ssid->disabled_due_to)); 8900 wpa_bssid_ignore_add(wpa_s, ssid->disabled_due_to); 8901 os_memset(ssid->disabled_due_to, 0, ETH_ALEN); 8902 } 8903 } 8904 8905 8906 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid) 8907 { 8908 size_t i; 8909 8910 if (wpa_s->disallow_aps_bssid == NULL) 8911 return 0; 8912 8913 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) { 8914 if (ether_addr_equal(wpa_s->disallow_aps_bssid + i * ETH_ALEN, 8915 bssid)) 8916 return 1; 8917 } 8918 8919 return 0; 8920 } 8921 8922 8923 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid, 8924 size_t ssid_len) 8925 { 8926 size_t i; 8927 8928 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL) 8929 return 0; 8930 8931 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) { 8932 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i]; 8933 if (ssid_len == s->ssid_len && 8934 os_memcmp(ssid, s->ssid, ssid_len) == 0) 8935 return 1; 8936 } 8937 8938 return 0; 8939 } 8940 8941 8942 /** 8943 * wpas_request_connection - Request a new connection 8944 * @wpa_s: Pointer to the network interface 8945 * 8946 * This function is used to request a new connection to be found. It will mark 8947 * the interface to allow reassociation and request a new scan to find a 8948 * suitable network to connect to. 8949 */ 8950 void wpas_request_connection(struct wpa_supplicant *wpa_s) 8951 { 8952 wpa_s->normal_scans = 0; 8953 wpa_s->scan_req = NORMAL_SCAN_REQ; 8954 wpa_supplicant_reinit_autoscan(wpa_s); 8955 wpa_s->disconnected = 0; 8956 wpa_s->reassociate = 1; 8957 wpa_s->last_owe_group = 0; 8958 8959 if (wpa_supplicant_fast_associate(wpa_s) != 1) 8960 wpa_supplicant_req_scan(wpa_s, 0, 0); 8961 else 8962 wpa_s->reattach = 0; 8963 } 8964 8965 8966 /** 8967 * wpas_request_disconnection - Request disconnection 8968 * @wpa_s: Pointer to the network interface 8969 * 8970 * This function is used to request disconnection from the currently connected 8971 * network. This will stop any ongoing scans and initiate deauthentication. 8972 */ 8973 void wpas_request_disconnection(struct wpa_supplicant *wpa_s) 8974 { 8975 #ifdef CONFIG_SME 8976 wpa_s->sme.prev_bssid_set = 0; 8977 #endif /* CONFIG_SME */ 8978 wpa_s->reassociate = 0; 8979 wpa_s->disconnected = 1; 8980 wpa_supplicant_cancel_sched_scan(wpa_s); 8981 wpa_supplicant_cancel_scan(wpa_s); 8982 wpas_abort_ongoing_scan(wpa_s); 8983 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING); 8984 eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL); 8985 radio_remove_works(wpa_s, "connect", 0); 8986 radio_remove_works(wpa_s, "sme-connect", 0); 8987 wpa_s->roam_in_progress = false; 8988 #ifdef CONFIG_WNM 8989 wpa_s->bss_trans_mgmt_in_progress = false; 8990 #endif /* CONFIG_WNM */ 8991 } 8992 8993 8994 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title, 8995 struct wpa_used_freq_data *freqs_data, 8996 unsigned int len) 8997 { 8998 unsigned int i; 8999 9000 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s", 9001 len, title); 9002 for (i = 0; i < len; i++) { 9003 struct wpa_used_freq_data *cur = &freqs_data[i]; 9004 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d, flags=0x%X", 9005 i, cur->freq, cur->flags); 9006 } 9007 } 9008 9009 9010 /* 9011 * Find the operating frequencies of any of the virtual interfaces that 9012 * are using the same radio as the current interface, and in addition, get 9013 * information about the interface types that are using the frequency. 9014 */ 9015 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s, 9016 struct wpa_used_freq_data *freqs_data, 9017 unsigned int len, bool exclude_current) 9018 { 9019 struct wpa_supplicant *ifs; 9020 u8 bssid[ETH_ALEN]; 9021 int freq; 9022 unsigned int idx = 0, i; 9023 9024 wpa_dbg(wpa_s, MSG_DEBUG, 9025 "Determining shared radio frequencies (max len %u)", len); 9026 os_memset(freqs_data, 0, sizeof(struct wpa_used_freq_data) * len); 9027 9028 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant, 9029 radio_list) { 9030 if (idx == len) 9031 break; 9032 9033 if (exclude_current && ifs == wpa_s) 9034 continue; 9035 9036 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0) 9037 continue; 9038 9039 if (ifs->current_ssid->mode == WPAS_MODE_AP || 9040 ifs->current_ssid->mode == WPAS_MODE_P2P_GO || 9041 ifs->current_ssid->mode == WPAS_MODE_MESH) 9042 freq = ifs->current_ssid->frequency; 9043 else if (wpa_drv_get_bssid(ifs, bssid) == 0) 9044 freq = ifs->assoc_freq; 9045 else 9046 continue; 9047 9048 /* Hold only distinct freqs */ 9049 for (i = 0; i < idx; i++) 9050 if (freqs_data[i].freq == freq) 9051 break; 9052 9053 if (i == idx) 9054 freqs_data[idx++].freq = freq; 9055 9056 if (ifs->current_ssid->mode == WPAS_MODE_INFRA) { 9057 freqs_data[i].flags |= ifs->current_ssid->p2p_group ? 9058 WPA_FREQ_USED_BY_P2P_CLIENT : 9059 WPA_FREQ_USED_BY_INFRA_STATION; 9060 } 9061 } 9062 9063 dump_freq_data(wpa_s, "completed iteration", freqs_data, idx); 9064 return idx; 9065 } 9066 9067 9068 /* 9069 * Find the operating frequencies of any of the virtual interfaces that 9070 * are using the same radio as the current interface. 9071 */ 9072 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s, 9073 int *freq_array, unsigned int len, 9074 bool exclude_current) 9075 { 9076 struct wpa_used_freq_data *freqs_data; 9077 int num, i; 9078 9079 os_memset(freq_array, 0, sizeof(int) * len); 9080 9081 freqs_data = os_calloc(len, sizeof(struct wpa_used_freq_data)); 9082 if (!freqs_data) 9083 return -1; 9084 9085 num = get_shared_radio_freqs_data(wpa_s, freqs_data, len, 9086 exclude_current); 9087 for (i = 0; i < num; i++) 9088 freq_array[i] = freqs_data[i].freq; 9089 9090 os_free(freqs_data); 9091 9092 return num; 9093 } 9094 9095 9096 struct wpa_supplicant * 9097 wpas_vendor_elem(struct wpa_supplicant *wpa_s, enum wpa_vendor_elem_frame frame) 9098 { 9099 switch (frame) { 9100 #ifdef CONFIG_P2P 9101 case VENDOR_ELEM_PROBE_REQ_P2P: 9102 case VENDOR_ELEM_PROBE_RESP_P2P: 9103 case VENDOR_ELEM_PROBE_RESP_P2P_GO: 9104 case VENDOR_ELEM_BEACON_P2P_GO: 9105 case VENDOR_ELEM_P2P_PD_REQ: 9106 case VENDOR_ELEM_P2P_PD_RESP: 9107 case VENDOR_ELEM_P2P_GO_NEG_REQ: 9108 case VENDOR_ELEM_P2P_GO_NEG_RESP: 9109 case VENDOR_ELEM_P2P_GO_NEG_CONF: 9110 case VENDOR_ELEM_P2P_INV_REQ: 9111 case VENDOR_ELEM_P2P_INV_RESP: 9112 case VENDOR_ELEM_P2P_ASSOC_REQ: 9113 case VENDOR_ELEM_P2P_ASSOC_RESP: 9114 return wpa_s->p2pdev; 9115 #endif /* CONFIG_P2P */ 9116 default: 9117 return wpa_s; 9118 } 9119 } 9120 9121 9122 void wpas_vendor_elem_update(struct wpa_supplicant *wpa_s) 9123 { 9124 unsigned int i; 9125 char buf[30]; 9126 9127 wpa_printf(MSG_DEBUG, "Update vendor elements"); 9128 9129 for (i = 0; i < NUM_VENDOR_ELEM_FRAMES; i++) { 9130 if (wpa_s->vendor_elem[i]) { 9131 int res; 9132 9133 res = os_snprintf(buf, sizeof(buf), "frame[%u]", i); 9134 if (!os_snprintf_error(sizeof(buf), res)) { 9135 wpa_hexdump_buf(MSG_DEBUG, buf, 9136 wpa_s->vendor_elem[i]); 9137 } 9138 } 9139 } 9140 9141 #ifdef CONFIG_P2P 9142 if (wpa_s->parent == wpa_s && 9143 wpa_s->global->p2p && 9144 !wpa_s->global->p2p_disabled) 9145 p2p_set_vendor_elems(wpa_s->global->p2p, wpa_s->vendor_elem); 9146 #endif /* CONFIG_P2P */ 9147 } 9148 9149 9150 int wpas_vendor_elem_remove(struct wpa_supplicant *wpa_s, int frame, 9151 const u8 *elem, size_t len) 9152 { 9153 u8 *ie, *end; 9154 9155 ie = wpabuf_mhead_u8(wpa_s->vendor_elem[frame]); 9156 end = ie + wpabuf_len(wpa_s->vendor_elem[frame]); 9157 9158 for (; ie + 1 < end; ie += 2 + ie[1]) { 9159 if (ie + len > end) 9160 break; 9161 if (os_memcmp(ie, elem, len) != 0) 9162 continue; 9163 9164 if (wpabuf_len(wpa_s->vendor_elem[frame]) == len) { 9165 wpabuf_free(wpa_s->vendor_elem[frame]); 9166 wpa_s->vendor_elem[frame] = NULL; 9167 } else { 9168 os_memmove(ie, ie + len, end - (ie + len)); 9169 wpa_s->vendor_elem[frame]->used -= len; 9170 } 9171 wpas_vendor_elem_update(wpa_s); 9172 return 0; 9173 } 9174 9175 return -1; 9176 } 9177 9178 9179 struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes, 9180 u16 num_modes, enum hostapd_hw_mode mode, 9181 bool is_6ghz) 9182 { 9183 u16 i; 9184 9185 if (!modes) 9186 return NULL; 9187 9188 for (i = 0; i < num_modes; i++) { 9189 if (modes[i].mode != mode || 9190 !modes[i].num_channels || !modes[i].channels) 9191 continue; 9192 if (is_6ghz == modes[i].is_6ghz) 9193 return &modes[i]; 9194 } 9195 9196 return NULL; 9197 } 9198 9199 9200 struct hostapd_hw_modes * get_mode_with_freq(struct hostapd_hw_modes *modes, 9201 u16 num_modes, int freq) 9202 { 9203 int i, j; 9204 9205 for (i = 0; i < num_modes; i++) { 9206 for (j = 0; j < modes[i].num_channels; j++) { 9207 if (freq == modes[i].channels[j].freq) 9208 return &modes[i]; 9209 } 9210 } 9211 9212 return NULL; 9213 } 9214 9215 9216 static struct 9217 wpa_bss_tmp_disallowed * wpas_get_disallowed_bss(struct wpa_supplicant *wpa_s, 9218 const u8 *bssid) 9219 { 9220 struct wpa_bss_tmp_disallowed *bss; 9221 9222 dl_list_for_each(bss, &wpa_s->bss_tmp_disallowed, 9223 struct wpa_bss_tmp_disallowed, list) { 9224 if (ether_addr_equal(bssid, bss->bssid)) 9225 return bss; 9226 } 9227 9228 return NULL; 9229 } 9230 9231 9232 static int wpa_set_driver_tmp_disallow_list(struct wpa_supplicant *wpa_s) 9233 { 9234 struct wpa_bss_tmp_disallowed *tmp; 9235 unsigned int num_bssid = 0; 9236 u8 *bssids; 9237 int ret; 9238 9239 bssids = os_malloc(dl_list_len(&wpa_s->bss_tmp_disallowed) * ETH_ALEN); 9240 if (!bssids) 9241 return -1; 9242 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed, 9243 struct wpa_bss_tmp_disallowed, list) { 9244 os_memcpy(&bssids[num_bssid * ETH_ALEN], tmp->bssid, 9245 ETH_ALEN); 9246 num_bssid++; 9247 } 9248 ret = wpa_drv_set_bssid_tmp_disallow(wpa_s, num_bssid, bssids); 9249 os_free(bssids); 9250 return ret; 9251 } 9252 9253 9254 static void wpa_bss_tmp_disallow_timeout(void *eloop_ctx, void *timeout_ctx) 9255 { 9256 struct wpa_supplicant *wpa_s = eloop_ctx; 9257 struct wpa_bss_tmp_disallowed *tmp, *bss = timeout_ctx; 9258 9259 /* Make sure the bss is not already freed */ 9260 dl_list_for_each(tmp, &wpa_s->bss_tmp_disallowed, 9261 struct wpa_bss_tmp_disallowed, list) { 9262 if (bss == tmp) { 9263 remove_bss_tmp_disallowed_entry(wpa_s, tmp); 9264 wpa_set_driver_tmp_disallow_list(wpa_s); 9265 break; 9266 } 9267 } 9268 } 9269 9270 9271 void wpa_bss_tmp_disallow(struct wpa_supplicant *wpa_s, const u8 *bssid, 9272 unsigned int sec, int rssi_threshold) 9273 { 9274 struct wpa_bss_tmp_disallowed *bss; 9275 9276 bss = wpas_get_disallowed_bss(wpa_s, bssid); 9277 if (bss) { 9278 eloop_cancel_timeout(wpa_bss_tmp_disallow_timeout, wpa_s, bss); 9279 goto finish; 9280 } 9281 9282 bss = os_malloc(sizeof(*bss)); 9283 if (!bss) { 9284 wpa_printf(MSG_DEBUG, 9285 "Failed to allocate memory for temp disallow BSS"); 9286 return; 9287 } 9288 9289 os_memcpy(bss->bssid, bssid, ETH_ALEN); 9290 dl_list_add(&wpa_s->bss_tmp_disallowed, &bss->list); 9291 wpa_set_driver_tmp_disallow_list(wpa_s); 9292 9293 finish: 9294 bss->rssi_threshold = rssi_threshold; 9295 eloop_register_timeout(sec, 0, wpa_bss_tmp_disallow_timeout, 9296 wpa_s, bss); 9297 } 9298 9299 9300 int wpa_is_bss_tmp_disallowed(struct wpa_supplicant *wpa_s, 9301 struct wpa_bss *bss) 9302 { 9303 struct wpa_bss_tmp_disallowed *disallowed = NULL, *tmp, *prev; 9304 9305 dl_list_for_each_safe(tmp, prev, &wpa_s->bss_tmp_disallowed, 9306 struct wpa_bss_tmp_disallowed, list) { 9307 if (ether_addr_equal(bss->bssid, tmp->bssid)) { 9308 disallowed = tmp; 9309 break; 9310 } 9311 } 9312 if (!disallowed) 9313 return 0; 9314 9315 if (disallowed->rssi_threshold != 0 && 9316 bss->level > disallowed->rssi_threshold) { 9317 remove_bss_tmp_disallowed_entry(wpa_s, disallowed); 9318 wpa_set_driver_tmp_disallow_list(wpa_s); 9319 return 0; 9320 } 9321 9322 return 1; 9323 } 9324 9325 9326 int wpas_enable_mac_addr_randomization(struct wpa_supplicant *wpa_s, 9327 unsigned int type, const u8 *addr, 9328 const u8 *mask) 9329 { 9330 if ((addr && !mask) || (!addr && mask)) { 9331 wpa_printf(MSG_INFO, 9332 "MAC_ADDR_RAND_SCAN invalid addr/mask combination"); 9333 return -1; 9334 } 9335 9336 if (addr && mask && (!(mask[0] & 0x01) || (addr[0] & 0x01))) { 9337 wpa_printf(MSG_INFO, 9338 "MAC_ADDR_RAND_SCAN cannot allow multicast address"); 9339 return -1; 9340 } 9341 9342 if (type & MAC_ADDR_RAND_SCAN) { 9343 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCAN, 9344 addr, mask)) 9345 return -1; 9346 } 9347 9348 if (type & MAC_ADDR_RAND_SCHED_SCAN) { 9349 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_SCHED_SCAN, 9350 addr, mask)) 9351 return -1; 9352 9353 if (wpa_s->sched_scanning && !wpa_s->pno) 9354 wpas_scan_restart_sched_scan(wpa_s); 9355 } 9356 9357 if (type & MAC_ADDR_RAND_PNO) { 9358 if (wpas_mac_addr_rand_scan_set(wpa_s, MAC_ADDR_RAND_PNO, 9359 addr, mask)) 9360 return -1; 9361 9362 if (wpa_s->pno) { 9363 wpas_stop_pno(wpa_s); 9364 wpas_start_pno(wpa_s); 9365 } 9366 } 9367 9368 return 0; 9369 } 9370 9371 9372 int wpas_disable_mac_addr_randomization(struct wpa_supplicant *wpa_s, 9373 unsigned int type) 9374 { 9375 wpas_mac_addr_rand_scan_clear(wpa_s, type); 9376 if (wpa_s->pno) { 9377 if (type & MAC_ADDR_RAND_PNO) { 9378 wpas_stop_pno(wpa_s); 9379 wpas_start_pno(wpa_s); 9380 } 9381 } else if (wpa_s->sched_scanning && (type & MAC_ADDR_RAND_SCHED_SCAN)) { 9382 wpas_scan_restart_sched_scan(wpa_s); 9383 } 9384 9385 return 0; 9386 } 9387 9388 9389 int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s, 9390 struct wpa_signal_info *si) 9391 { 9392 int res; 9393 9394 if (!wpa_s->driver->signal_poll) 9395 return -1; 9396 9397 res = wpa_s->driver->signal_poll(wpa_s->drv_priv, si); 9398 9399 #ifdef CONFIG_TESTING_OPTIONS 9400 if (res == 0) { 9401 struct driver_signal_override *dso; 9402 9403 dl_list_for_each(dso, &wpa_s->drv_signal_override, 9404 struct driver_signal_override, list) { 9405 if (!ether_addr_equal(wpa_s->bssid, dso->bssid)) 9406 continue; 9407 wpa_printf(MSG_DEBUG, 9408 "Override driver signal_poll information: current_signal: %d->%d avg_signal: %d->%d avg_beacon_signal: %d->%d current_noise: %d->%d", 9409 si->data.signal, 9410 dso->si_current_signal, 9411 si->data.avg_signal, 9412 dso->si_avg_signal, 9413 si->data.avg_beacon_signal, 9414 dso->si_avg_beacon_signal, 9415 si->current_noise, 9416 dso->si_current_noise); 9417 si->data.signal = dso->si_current_signal; 9418 si->data.avg_signal = dso->si_avg_signal; 9419 si->data.avg_beacon_signal = dso->si_avg_beacon_signal; 9420 si->current_noise = dso->si_current_noise; 9421 break; 9422 } 9423 } 9424 #endif /* CONFIG_TESTING_OPTIONS */ 9425 9426 return res; 9427 } 9428 9429 9430 struct wpa_scan_results * 9431 wpa_drv_get_scan_results(struct wpa_supplicant *wpa_s, const u8 *bssid) 9432 { 9433 struct wpa_scan_results *scan_res; 9434 #ifdef CONFIG_TESTING_OPTIONS 9435 size_t idx; 9436 #endif /* CONFIG_TESTING_OPTIONS */ 9437 9438 if (wpa_s->driver->get_scan_results) 9439 scan_res = wpa_s->driver->get_scan_results(wpa_s->drv_priv, 9440 bssid); 9441 else if (wpa_s->driver->get_scan_results2) 9442 scan_res = wpa_s->driver->get_scan_results2(wpa_s->drv_priv); 9443 else 9444 return NULL; 9445 9446 9447 #ifdef CONFIG_TESTING_OPTIONS 9448 for (idx = 0; scan_res && idx < scan_res->num; idx++) { 9449 struct driver_signal_override *dso; 9450 struct wpa_scan_res *res = scan_res->res[idx]; 9451 9452 dl_list_for_each(dso, &wpa_s->drv_signal_override, 9453 struct driver_signal_override, list) { 9454 if (!ether_addr_equal(res->bssid, dso->bssid)) 9455 continue; 9456 wpa_printf(MSG_DEBUG, 9457 "Override driver scan signal level %d->%d for " 9458 MACSTR, 9459 res->level, dso->scan_level, 9460 MAC2STR(res->bssid)); 9461 res->flags |= WPA_SCAN_QUAL_INVALID; 9462 if (dso->scan_level < 0) 9463 res->flags |= WPA_SCAN_LEVEL_DBM; 9464 else 9465 res->flags &= ~WPA_SCAN_LEVEL_DBM; 9466 res->level = dso->scan_level; 9467 break; 9468 } 9469 } 9470 #endif /* CONFIG_TESTING_OPTIONS */ 9471 9472 return scan_res; 9473 } 9474 9475 9476 bool wpas_ap_link_address(struct wpa_supplicant *wpa_s, const u8 *addr) 9477 { 9478 int i; 9479 9480 if (!wpa_s->valid_links) 9481 return false; 9482 9483 for_each_link(wpa_s->valid_links, i) { 9484 if (ether_addr_equal(wpa_s->links[i].bssid, addr)) 9485 return true; 9486 } 9487 9488 return false; 9489 } 9490 9491 9492 int wpa_drv_send_action(struct wpa_supplicant *wpa_s, unsigned int freq, 9493 unsigned int wait, const u8 *dst, const u8 *src, 9494 const u8 *bssid, const u8 *data, size_t data_len, 9495 int no_cck) 9496 { 9497 if (!wpa_s->driver->send_action) 9498 return -1; 9499 9500 if (data_len > 0 && data[0] != WLAN_ACTION_PUBLIC) { 9501 if (wpas_ap_link_address(wpa_s, dst)) 9502 dst = wpa_s->ap_mld_addr; 9503 9504 if (wpas_ap_link_address(wpa_s, bssid)) 9505 bssid = wpa_s->ap_mld_addr; 9506 } 9507 9508 return wpa_s->driver->send_action(wpa_s->drv_priv, freq, wait, dst, src, 9509 bssid, data, data_len, no_cck); 9510 } 9511 9512 9513 bool wpas_is_6ghz_supported(struct wpa_supplicant *wpa_s, bool only_enabled) 9514 { 9515 struct hostapd_channel_data *chnl; 9516 int i, j; 9517 9518 for (i = 0; i < wpa_s->hw.num_modes; i++) { 9519 if (wpa_s->hw.modes[i].mode == HOSTAPD_MODE_IEEE80211A) { 9520 chnl = wpa_s->hw.modes[i].channels; 9521 for (j = 0; j < wpa_s->hw.modes[i].num_channels; j++) { 9522 if (only_enabled && 9523 (chnl[j].flag & HOSTAPD_CHAN_DISABLED)) 9524 continue; 9525 if (is_6ghz_freq(chnl[j].freq)) 9526 return true; 9527 } 9528 } 9529 } 9530 9531 return false; 9532 } 9533
Indexes created Sat Jun 13 00:24:39 UTC 2026