wpa_supplicant.c revision 623d63a3a443027e50efdaaec027befcc3882527
1/* 2 * WPA Supplicant 3 * Copyright (c) 2003-2014, Jouni Malinen <j@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 15#include "common.h" 16#include "crypto/random.h" 17#include "crypto/sha1.h" 18#include "eapol_supp/eapol_supp_sm.h" 19#include "eap_peer/eap.h" 20#include "eap_peer/eap_proxy.h" 21#include "eap_server/eap_methods.h" 22#include "rsn_supp/wpa.h" 23#include "eloop.h" 24#include "config.h" 25#include "utils/ext_password.h" 26#include "l2_packet/l2_packet.h" 27#include "wpa_supplicant_i.h" 28#include "driver_i.h" 29#include "ctrl_iface.h" 30#include "pcsc_funcs.h" 31#include "common/version.h" 32#include "rsn_supp/preauth.h" 33#include "rsn_supp/pmksa_cache.h" 34#include "common/wpa_ctrl.h" 35#include "common/ieee802_11_defs.h" 36#include "p2p/p2p.h" 37#include "blacklist.h" 38#include "wpas_glue.h" 39#include "wps_supplicant.h" 40#include "ibss_rsn.h" 41#include "sme.h" 42#include "gas_query.h" 43#include "ap.h" 44#include "p2p_supplicant.h" 45#include "wifi_display.h" 46#include "notify.h" 47#include "bgscan.h" 48#include "autoscan.h" 49#include "bss.h" 50#include "scan.h" 51#include "offchannel.h" 52#include "hs20_supplicant.h" 53#include "wnm_sta.h" 54#include "wpas_kay.h" 55 56const char *wpa_supplicant_version = 57"wpa_supplicant v" VERSION_STR "\n" 58"Copyright (c) 2003-2014, Jouni Malinen <j@w1.fi> and contributors"; 59 60const char *wpa_supplicant_license = 61"This software may be distributed under the terms of the BSD license.\n" 62"See README for more details.\n" 63#ifdef EAP_TLS_OPENSSL 64"\nThis product includes software developed by the OpenSSL Project\n" 65"for use in the OpenSSL Toolkit (http://www.openssl.org/)\n" 66#endif /* EAP_TLS_OPENSSL */ 67; 68 69#ifndef CONFIG_NO_STDOUT_DEBUG 70/* Long text divided into parts in order to fit in C89 strings size limits. */ 71const char *wpa_supplicant_full_license1 = 72""; 73const char *wpa_supplicant_full_license2 = 74"This software may be distributed under the terms of the BSD license.\n" 75"\n" 76"Redistribution and use in source and binary forms, with or without\n" 77"modification, are permitted provided that the following conditions are\n" 78"met:\n" 79"\n"; 80const char *wpa_supplicant_full_license3 = 81"1. Redistributions of source code must retain the above copyright\n" 82" notice, this list of conditions and the following disclaimer.\n" 83"\n" 84"2. Redistributions in binary form must reproduce the above copyright\n" 85" notice, this list of conditions and the following disclaimer in the\n" 86" documentation and/or other materials provided with the distribution.\n" 87"\n"; 88const char *wpa_supplicant_full_license4 = 89"3. Neither the name(s) of the above-listed copyright holder(s) nor the\n" 90" names of its contributors may be used to endorse or promote products\n" 91" derived from this software without specific prior written permission.\n" 92"\n" 93"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n" 94"\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n" 95"LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n" 96"A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"; 97const char *wpa_supplicant_full_license5 = 98"OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n" 99"SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n" 100"LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n" 101"DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n" 102"THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n" 103"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n" 104"OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" 105"\n"; 106#endif /* CONFIG_NO_STDOUT_DEBUG */ 107 108/* Configure default/group WEP keys for static WEP */ 109int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid) 110{ 111 int i, set = 0; 112 113 for (i = 0; i < NUM_WEP_KEYS; i++) { 114 if (ssid->wep_key_len[i] == 0) 115 continue; 116 117 set = 1; 118 wpa_drv_set_key(wpa_s, WPA_ALG_WEP, NULL, 119 i, i == ssid->wep_tx_keyidx, NULL, 0, 120 ssid->wep_key[i], ssid->wep_key_len[i]); 121 } 122 123 return set; 124} 125 126 127int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s, 128 struct wpa_ssid *ssid) 129{ 130 u8 key[32]; 131 size_t keylen; 132 enum wpa_alg alg; 133 u8 seq[6] = { 0 }; 134 135 /* IBSS/WPA-None uses only one key (Group) for both receiving and 136 * sending unicast and multicast packets. */ 137 138 if (ssid->mode != WPAS_MODE_IBSS) { 139 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid mode %d (not " 140 "IBSS/ad-hoc) for WPA-None", ssid->mode); 141 return -1; 142 } 143 144 if (!ssid->psk_set) { 145 wpa_msg(wpa_s, MSG_INFO, "WPA: No PSK configured for " 146 "WPA-None"); 147 return -1; 148 } 149 150 switch (wpa_s->group_cipher) { 151 case WPA_CIPHER_CCMP: 152 os_memcpy(key, ssid->psk, 16); 153 keylen = 16; 154 alg = WPA_ALG_CCMP; 155 break; 156 case WPA_CIPHER_GCMP: 157 os_memcpy(key, ssid->psk, 16); 158 keylen = 16; 159 alg = WPA_ALG_GCMP; 160 break; 161 case WPA_CIPHER_TKIP: 162 /* WPA-None uses the same Michael MIC key for both TX and RX */ 163 os_memcpy(key, ssid->psk, 16 + 8); 164 os_memcpy(key + 16 + 8, ssid->psk + 16, 8); 165 keylen = 32; 166 alg = WPA_ALG_TKIP; 167 break; 168 default: 169 wpa_msg(wpa_s, MSG_INFO, "WPA: Invalid group cipher %d for " 170 "WPA-None", wpa_s->group_cipher); 171 return -1; 172 } 173 174 /* TODO: should actually remember the previously used seq#, both for TX 175 * and RX from each STA.. */ 176 177 return wpa_drv_set_key(wpa_s, alg, NULL, 0, 1, seq, 6, key, keylen); 178} 179 180 181static void wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx) 182{ 183 struct wpa_supplicant *wpa_s = eloop_ctx; 184 const u8 *bssid = wpa_s->bssid; 185 if (is_zero_ether_addr(bssid)) 186 bssid = wpa_s->pending_bssid; 187 wpa_msg(wpa_s, MSG_INFO, "Authentication with " MACSTR " timed out.", 188 MAC2STR(bssid)); 189 wpa_blacklist_add(wpa_s, bssid); 190 wpa_sm_notify_disassoc(wpa_s->wpa); 191 wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING); 192 wpa_s->reassociate = 1; 193 194 /* 195 * If we timed out, the AP or the local radio may be busy. 196 * So, wait a second until scanning again. 197 */ 198 wpa_supplicant_req_scan(wpa_s, 1, 0); 199} 200 201 202/** 203 * wpa_supplicant_req_auth_timeout - Schedule a timeout for authentication 204 * @wpa_s: Pointer to wpa_supplicant data 205 * @sec: Number of seconds after which to time out authentication 206 * @usec: Number of microseconds after which to time out authentication 207 * 208 * This function is used to schedule a timeout for the current authentication 209 * attempt. 210 */ 211void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s, 212 int sec, int usec) 213{ 214 if (wpa_s->conf->ap_scan == 0 && 215 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED)) 216 return; 217 218 wpa_dbg(wpa_s, MSG_DEBUG, "Setting authentication timeout: %d sec " 219 "%d usec", sec, usec); 220 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 221 eloop_register_timeout(sec, usec, wpa_supplicant_timeout, wpa_s, NULL); 222} 223 224 225/** 226 * wpa_supplicant_cancel_auth_timeout - Cancel authentication timeout 227 * @wpa_s: Pointer to wpa_supplicant data 228 * 229 * This function is used to cancel authentication timeout scheduled with 230 * wpa_supplicant_req_auth_timeout() and it is called when authentication has 231 * been completed. 232 */ 233void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s) 234{ 235 wpa_dbg(wpa_s, MSG_DEBUG, "Cancelling authentication timeout"); 236 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 237 wpa_blacklist_del(wpa_s, wpa_s->bssid); 238} 239 240 241/** 242 * wpa_supplicant_initiate_eapol - Configure EAPOL state machine 243 * @wpa_s: Pointer to wpa_supplicant data 244 * 245 * This function is used to configure EAPOL state machine based on the selected 246 * authentication mode. 247 */ 248void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s) 249{ 250#ifdef IEEE8021X_EAPOL 251 struct eapol_config eapol_conf; 252 struct wpa_ssid *ssid = wpa_s->current_ssid; 253 254#ifdef CONFIG_IBSS_RSN 255 if (ssid->mode == WPAS_MODE_IBSS && 256 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE && 257 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) { 258 /* 259 * RSN IBSS authentication is per-STA and we can disable the 260 * per-BSSID EAPOL authentication. 261 */ 262 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized); 263 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE); 264 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE); 265 return; 266 } 267#endif /* CONFIG_IBSS_RSN */ 268 269 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); 270 eapol_sm_notify_eap_fail(wpa_s->eapol, FALSE); 271 272 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 273 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) 274 eapol_sm_notify_portControl(wpa_s->eapol, ForceAuthorized); 275 else 276 eapol_sm_notify_portControl(wpa_s->eapol, Auto); 277 278 os_memset(&eapol_conf, 0, sizeof(eapol_conf)); 279 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 280 eapol_conf.accept_802_1x_keys = 1; 281 eapol_conf.required_keys = 0; 282 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_UNICAST) { 283 eapol_conf.required_keys |= EAPOL_REQUIRE_KEY_UNICAST; 284 } 285 if (ssid->eapol_flags & EAPOL_FLAG_REQUIRE_KEY_BROADCAST) { 286 eapol_conf.required_keys |= 287 EAPOL_REQUIRE_KEY_BROADCAST; 288 } 289 290 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED) 291 eapol_conf.required_keys = 0; 292 } 293 eapol_conf.fast_reauth = wpa_s->conf->fast_reauth; 294 eapol_conf.workaround = ssid->eap_workaround; 295 eapol_conf.eap_disabled = 296 !wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) && 297 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA && 298 wpa_s->key_mgmt != WPA_KEY_MGMT_WPS; 299 eapol_conf.external_sim = wpa_s->conf->external_sim; 300 eapol_sm_notify_config(wpa_s->eapol, &ssid->eap, &eapol_conf); 301#endif /* IEEE8021X_EAPOL */ 302 303 ieee802_1x_alloc_kay_sm(wpa_s, ssid); 304} 305 306 307/** 308 * wpa_supplicant_set_non_wpa_policy - Set WPA parameters to non-WPA mode 309 * @wpa_s: Pointer to wpa_supplicant data 310 * @ssid: Configuration data for the network 311 * 312 * This function is used to configure WPA state machine and related parameters 313 * to a mode where WPA is not enabled. This is called as part of the 314 * authentication configuration when the selected network does not use WPA. 315 */ 316void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s, 317 struct wpa_ssid *ssid) 318{ 319 int i; 320 321 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) 322 wpa_s->key_mgmt = WPA_KEY_MGMT_WPS; 323 else if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) 324 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_NO_WPA; 325 else 326 wpa_s->key_mgmt = WPA_KEY_MGMT_NONE; 327 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0); 328 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0); 329 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 330 wpa_s->pairwise_cipher = WPA_CIPHER_NONE; 331 wpa_s->group_cipher = WPA_CIPHER_NONE; 332 wpa_s->mgmt_group_cipher = 0; 333 334 for (i = 0; i < NUM_WEP_KEYS; i++) { 335 if (ssid->wep_key_len[i] > 5) { 336 wpa_s->pairwise_cipher = WPA_CIPHER_WEP104; 337 wpa_s->group_cipher = WPA_CIPHER_WEP104; 338 break; 339 } else if (ssid->wep_key_len[i] > 0) { 340 wpa_s->pairwise_cipher = WPA_CIPHER_WEP40; 341 wpa_s->group_cipher = WPA_CIPHER_WEP40; 342 break; 343 } 344 } 345 346 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 0); 347 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt); 348 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, 349 wpa_s->pairwise_cipher); 350 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher); 351#ifdef CONFIG_IEEE80211W 352 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP, 353 wpa_s->mgmt_group_cipher); 354#endif /* CONFIG_IEEE80211W */ 355 356 pmksa_cache_clear_current(wpa_s->wpa); 357} 358 359 360void free_hw_features(struct wpa_supplicant *wpa_s) 361{ 362 int i; 363 if (wpa_s->hw.modes == NULL) 364 return; 365 366 for (i = 0; i < wpa_s->hw.num_modes; i++) { 367 os_free(wpa_s->hw.modes[i].channels); 368 os_free(wpa_s->hw.modes[i].rates); 369 } 370 371 os_free(wpa_s->hw.modes); 372 wpa_s->hw.modes = NULL; 373} 374 375 376static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s) 377{ 378 bgscan_deinit(wpa_s); 379 autoscan_deinit(wpa_s); 380 scard_deinit(wpa_s->scard); 381 wpa_s->scard = NULL; 382 wpa_sm_set_scard_ctx(wpa_s->wpa, NULL); 383 eapol_sm_register_scard_ctx(wpa_s->eapol, NULL); 384 l2_packet_deinit(wpa_s->l2); 385 wpa_s->l2 = NULL; 386 if (wpa_s->l2_br) { 387 l2_packet_deinit(wpa_s->l2_br); 388 wpa_s->l2_br = NULL; 389 } 390 391 if (wpa_s->conf != NULL) { 392 struct wpa_ssid *ssid; 393 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) 394 wpas_notify_network_removed(wpa_s, ssid); 395 } 396 397 os_free(wpa_s->confname); 398 wpa_s->confname = NULL; 399 400 os_free(wpa_s->confanother); 401 wpa_s->confanother = NULL; 402 403#ifdef CONFIG_P2P 404 os_free(wpa_s->conf_p2p_dev); 405 wpa_s->conf_p2p_dev = NULL; 406#endif /* CONFIG_P2P */ 407 408 wpa_sm_set_eapol(wpa_s->wpa, NULL); 409 eapol_sm_deinit(wpa_s->eapol); 410 wpa_s->eapol = NULL; 411 412 rsn_preauth_deinit(wpa_s->wpa); 413 414#ifdef CONFIG_TDLS 415 wpa_tdls_deinit(wpa_s->wpa); 416#endif /* CONFIG_TDLS */ 417 418 pmksa_candidate_free(wpa_s->wpa); 419 wpa_sm_deinit(wpa_s->wpa); 420 wpa_s->wpa = NULL; 421 wpa_blacklist_clear(wpa_s); 422 423 wpa_bss_deinit(wpa_s); 424 425 wpa_supplicant_cancel_delayed_sched_scan(wpa_s); 426 wpa_supplicant_cancel_scan(wpa_s); 427 wpa_supplicant_cancel_auth_timeout(wpa_s); 428 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, wpa_s, NULL); 429#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT 430 eloop_cancel_timeout(wpa_supplicant_delayed_mic_error_report, 431 wpa_s, NULL); 432#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */ 433 434 wpas_wps_deinit(wpa_s); 435 436 wpabuf_free(wpa_s->pending_eapol_rx); 437 wpa_s->pending_eapol_rx = NULL; 438 439#ifdef CONFIG_IBSS_RSN 440 ibss_rsn_deinit(wpa_s->ibss_rsn); 441 wpa_s->ibss_rsn = NULL; 442#endif /* CONFIG_IBSS_RSN */ 443 444 sme_deinit(wpa_s); 445 446#ifdef CONFIG_AP 447 wpa_supplicant_ap_deinit(wpa_s); 448#endif /* CONFIG_AP */ 449 450#ifdef CONFIG_P2P 451 wpas_p2p_deinit(wpa_s); 452#endif /* CONFIG_P2P */ 453 454#ifdef CONFIG_OFFCHANNEL 455 offchannel_deinit(wpa_s); 456#endif /* CONFIG_OFFCHANNEL */ 457 458 wpa_supplicant_cancel_sched_scan(wpa_s); 459 460 os_free(wpa_s->next_scan_freqs); 461 wpa_s->next_scan_freqs = NULL; 462 463 os_free(wpa_s->manual_scan_freqs); 464 wpa_s->manual_scan_freqs = NULL; 465 466 os_free(wpa_s->manual_sched_scan_freqs); 467 wpa_s->manual_sched_scan_freqs = NULL; 468 469 gas_query_deinit(wpa_s->gas); 470 wpa_s->gas = NULL; 471 472 free_hw_features(wpa_s); 473 474 ieee802_1x_dealloc_kay_sm(wpa_s); 475 476 os_free(wpa_s->bssid_filter); 477 wpa_s->bssid_filter = NULL; 478 479 os_free(wpa_s->disallow_aps_bssid); 480 wpa_s->disallow_aps_bssid = NULL; 481 os_free(wpa_s->disallow_aps_ssid); 482 wpa_s->disallow_aps_ssid = NULL; 483 484 wnm_bss_keep_alive_deinit(wpa_s); 485#ifdef CONFIG_WNM 486 wnm_deallocate_memory(wpa_s); 487#endif /* CONFIG_WNM */ 488 489 ext_password_deinit(wpa_s->ext_pw); 490 wpa_s->ext_pw = NULL; 491 492 wpabuf_free(wpa_s->last_gas_resp); 493 wpa_s->last_gas_resp = NULL; 494 wpabuf_free(wpa_s->prev_gas_resp); 495 wpa_s->prev_gas_resp = NULL; 496 497 os_free(wpa_s->last_scan_res); 498 wpa_s->last_scan_res = NULL; 499 500#ifdef CONFIG_HS20 501 hs20_deinit(wpa_s); 502#endif /* CONFIG_HS20 */ 503} 504 505 506/** 507 * wpa_clear_keys - Clear keys configured for the driver 508 * @wpa_s: Pointer to wpa_supplicant data 509 * @addr: Previously used BSSID or %NULL if not available 510 * 511 * This function clears the encryption keys that has been previously configured 512 * for the driver. 513 */ 514void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr) 515{ 516 int i, max; 517 518#ifdef CONFIG_IEEE80211W 519 max = 6; 520#else /* CONFIG_IEEE80211W */ 521 max = 4; 522#endif /* CONFIG_IEEE80211W */ 523 524 /* MLME-DELETEKEYS.request */ 525 for (i = 0; i < max; i++) { 526 if (wpa_s->keys_cleared & BIT(i)) 527 continue; 528 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, NULL, i, 0, NULL, 0, 529 NULL, 0); 530 } 531 if (!(wpa_s->keys_cleared & BIT(0)) && addr && 532 !is_zero_ether_addr(addr)) { 533 wpa_drv_set_key(wpa_s, WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL, 534 0); 535 /* MLME-SETPROTECTION.request(None) */ 536 wpa_drv_mlme_setprotection( 537 wpa_s, addr, 538 MLME_SETPROTECTION_PROTECT_TYPE_NONE, 539 MLME_SETPROTECTION_KEY_TYPE_PAIRWISE); 540 } 541 wpa_s->keys_cleared = (u32) -1; 542} 543 544 545/** 546 * wpa_supplicant_state_txt - Get the connection state name as a text string 547 * @state: State (wpa_state; WPA_*) 548 * Returns: The state name as a printable text string 549 */ 550const char * wpa_supplicant_state_txt(enum wpa_states state) 551{ 552 switch (state) { 553 case WPA_DISCONNECTED: 554 return "DISCONNECTED"; 555 case WPA_INACTIVE: 556 return "INACTIVE"; 557 case WPA_INTERFACE_DISABLED: 558 return "INTERFACE_DISABLED"; 559 case WPA_SCANNING: 560 return "SCANNING"; 561 case WPA_AUTHENTICATING: 562 return "AUTHENTICATING"; 563 case WPA_ASSOCIATING: 564 return "ASSOCIATING"; 565 case WPA_ASSOCIATED: 566 return "ASSOCIATED"; 567 case WPA_4WAY_HANDSHAKE: 568 return "4WAY_HANDSHAKE"; 569 case WPA_GROUP_HANDSHAKE: 570 return "GROUP_HANDSHAKE"; 571 case WPA_COMPLETED: 572 return "COMPLETED"; 573 default: 574 return "UNKNOWN"; 575 } 576} 577 578 579#ifdef CONFIG_BGSCAN 580 581static void wpa_supplicant_start_bgscan(struct wpa_supplicant *wpa_s) 582{ 583 const char *name; 584 585 if (wpa_s->current_ssid && wpa_s->current_ssid->bgscan) 586 name = wpa_s->current_ssid->bgscan; 587 else 588 name = wpa_s->conf->bgscan; 589 if (name == NULL || name[0] == '\0') 590 return; 591 if (wpas_driver_bss_selection(wpa_s)) 592 return; 593 if (wpa_s->current_ssid == wpa_s->bgscan_ssid) 594 return; 595#ifdef CONFIG_P2P 596 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) 597 return; 598#endif /* CONFIG_P2P */ 599 600 bgscan_deinit(wpa_s); 601 if (wpa_s->current_ssid) { 602 if (bgscan_init(wpa_s, wpa_s->current_ssid, name)) { 603 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize " 604 "bgscan"); 605 /* 606 * Live without bgscan; it is only used as a roaming 607 * optimization, so the initial connection is not 608 * affected. 609 */ 610 } else { 611 struct wpa_scan_results *scan_res; 612 wpa_s->bgscan_ssid = wpa_s->current_ssid; 613 scan_res = wpa_supplicant_get_scan_results(wpa_s, NULL, 614 0); 615 if (scan_res) { 616 bgscan_notify_scan(wpa_s, scan_res); 617 wpa_scan_results_free(scan_res); 618 } 619 } 620 } else 621 wpa_s->bgscan_ssid = NULL; 622} 623 624 625static void wpa_supplicant_stop_bgscan(struct wpa_supplicant *wpa_s) 626{ 627 if (wpa_s->bgscan_ssid != NULL) { 628 bgscan_deinit(wpa_s); 629 wpa_s->bgscan_ssid = NULL; 630 } 631} 632 633#endif /* CONFIG_BGSCAN */ 634 635 636static void wpa_supplicant_start_autoscan(struct wpa_supplicant *wpa_s) 637{ 638 if (autoscan_init(wpa_s, 0)) 639 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize autoscan"); 640} 641 642 643static void wpa_supplicant_stop_autoscan(struct wpa_supplicant *wpa_s) 644{ 645 autoscan_deinit(wpa_s); 646} 647 648 649void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s) 650{ 651 if (wpa_s->wpa_state == WPA_DISCONNECTED || 652 wpa_s->wpa_state == WPA_SCANNING) { 653 autoscan_deinit(wpa_s); 654 wpa_supplicant_start_autoscan(wpa_s); 655 } 656} 657 658 659/** 660 * wpa_supplicant_set_state - Set current connection state 661 * @wpa_s: Pointer to wpa_supplicant data 662 * @state: The new connection state 663 * 664 * This function is called whenever the connection state changes, e.g., 665 * association is completed for WPA/WPA2 4-Way Handshake is started. 666 */ 667void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, 668 enum wpa_states state) 669{ 670 enum wpa_states old_state = wpa_s->wpa_state; 671 672 wpa_dbg(wpa_s, MSG_DEBUG, "State: %s -> %s", 673 wpa_supplicant_state_txt(wpa_s->wpa_state), 674 wpa_supplicant_state_txt(state)); 675 676 if (state == WPA_INTERFACE_DISABLED) { 677 /* Assure normal scan when interface is restored */ 678 wpa_s->normal_scans = 0; 679 } 680 681 if (state == WPA_COMPLETED) { 682 wpas_connect_work_done(wpa_s); 683 /* Reinitialize normal_scan counter */ 684 wpa_s->normal_scans = 0; 685 } 686 687 if (state != WPA_SCANNING) 688 wpa_supplicant_notify_scanning(wpa_s, 0); 689 690 if (state == WPA_COMPLETED && wpa_s->new_connection) { 691 struct wpa_ssid *ssid = wpa_s->current_ssid; 692#if defined(CONFIG_CTRL_IFACE) || !defined(CONFIG_NO_STDOUT_DEBUG) 693 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_CONNECTED "- Connection to " 694 MACSTR " completed [id=%d id_str=%s]", 695 MAC2STR(wpa_s->bssid), 696 ssid ? ssid->id : -1, 697 ssid && ssid->id_str ? ssid->id_str : ""); 698#endif /* CONFIG_CTRL_IFACE || !CONFIG_NO_STDOUT_DEBUG */ 699 wpas_clear_temp_disabled(wpa_s, ssid, 1); 700 wpa_s->extra_blacklist_count = 0; 701 wpa_s->new_connection = 0; 702 wpa_drv_set_operstate(wpa_s, 1); 703#ifndef IEEE8021X_EAPOL 704 wpa_drv_set_supp_port(wpa_s, 1); 705#endif /* IEEE8021X_EAPOL */ 706 wpa_s->after_wps = 0; 707 wpa_s->known_wps_freq = 0; 708#ifdef CONFIG_P2P 709 wpas_p2p_completed(wpa_s); 710#endif /* CONFIG_P2P */ 711 712 sme_sched_obss_scan(wpa_s, 1); 713 } else if (state == WPA_DISCONNECTED || state == WPA_ASSOCIATING || 714 state == WPA_ASSOCIATED) { 715 wpa_s->new_connection = 1; 716 wpa_drv_set_operstate(wpa_s, 0); 717#ifndef IEEE8021X_EAPOL 718 wpa_drv_set_supp_port(wpa_s, 0); 719#endif /* IEEE8021X_EAPOL */ 720 sme_sched_obss_scan(wpa_s, 0); 721 } 722 wpa_s->wpa_state = state; 723 724#ifdef CONFIG_BGSCAN 725 if (state == WPA_COMPLETED) 726 wpa_supplicant_start_bgscan(wpa_s); 727 else if (state < WPA_ASSOCIATED) 728 wpa_supplicant_stop_bgscan(wpa_s); 729#endif /* CONFIG_BGSCAN */ 730 731 if (state == WPA_AUTHENTICATING) 732 wpa_supplicant_stop_autoscan(wpa_s); 733 734 if (state == WPA_DISCONNECTED || state == WPA_INACTIVE) 735 wpa_supplicant_start_autoscan(wpa_s); 736 737 if (wpa_s->wpa_state != old_state) { 738 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state); 739 740 if (wpa_s->wpa_state == WPA_COMPLETED || 741 old_state == WPA_COMPLETED) 742 wpas_notify_auth_changed(wpa_s); 743 } 744} 745 746 747void wpa_supplicant_terminate_proc(struct wpa_global *global) 748{ 749 int pending = 0; 750#ifdef CONFIG_WPS 751 struct wpa_supplicant *wpa_s = global->ifaces; 752 while (wpa_s) { 753 struct wpa_supplicant *next = wpa_s->next; 754 if (wpas_wps_terminate_pending(wpa_s) == 1) 755 pending = 1; 756#ifdef CONFIG_P2P 757 if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE || 758 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group)) 759 wpas_p2p_disconnect(wpa_s); 760#endif /* CONFIG_P2P */ 761 wpa_s = next; 762 } 763#endif /* CONFIG_WPS */ 764 if (pending) 765 return; 766 eloop_terminate(); 767} 768 769 770static void wpa_supplicant_terminate(int sig, void *signal_ctx) 771{ 772 struct wpa_global *global = signal_ctx; 773 wpa_supplicant_terminate_proc(global); 774} 775 776 777void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s) 778{ 779 enum wpa_states old_state = wpa_s->wpa_state; 780 781 wpa_s->pairwise_cipher = 0; 782 wpa_s->group_cipher = 0; 783 wpa_s->mgmt_group_cipher = 0; 784 wpa_s->key_mgmt = 0; 785 if (wpa_s->wpa_state != WPA_INTERFACE_DISABLED) 786 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 787 788 if (wpa_s->wpa_state != old_state) 789 wpas_notify_state_changed(wpa_s, wpa_s->wpa_state, old_state); 790} 791 792 793/** 794 * wpa_supplicant_reload_configuration - Reload configuration data 795 * @wpa_s: Pointer to wpa_supplicant data 796 * Returns: 0 on success or -1 if configuration parsing failed 797 * 798 * This function can be used to request that the configuration data is reloaded 799 * (e.g., after configuration file change). This function is reloading 800 * configuration only for one interface, so this may need to be called multiple 801 * times if %wpa_supplicant is controlling multiple interfaces and all 802 * interfaces need reconfiguration. 803 */ 804int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s) 805{ 806 struct wpa_config *conf; 807 int reconf_ctrl; 808 int old_ap_scan; 809 810 if (wpa_s->confname == NULL) 811 return -1; 812 conf = wpa_config_read(wpa_s->confname, NULL); 813 if (conf == NULL) { 814 wpa_msg(wpa_s, MSG_ERROR, "Failed to parse the configuration " 815 "file '%s' - exiting", wpa_s->confname); 816 return -1; 817 } 818 wpa_config_read(wpa_s->confanother, conf); 819 820 conf->changed_parameters = (unsigned int) -1; 821 822 reconf_ctrl = !!conf->ctrl_interface != !!wpa_s->conf->ctrl_interface 823 || (conf->ctrl_interface && wpa_s->conf->ctrl_interface && 824 os_strcmp(conf->ctrl_interface, 825 wpa_s->conf->ctrl_interface) != 0); 826 827 if (reconf_ctrl && wpa_s->ctrl_iface) { 828 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface); 829 wpa_s->ctrl_iface = NULL; 830 } 831 832 eapol_sm_invalidate_cached_session(wpa_s->eapol); 833 if (wpa_s->current_ssid) { 834 wpa_supplicant_deauthenticate(wpa_s, 835 WLAN_REASON_DEAUTH_LEAVING); 836 } 837 838 /* 839 * TODO: should notify EAPOL SM about changes in opensc_engine_path, 840 * pkcs11_engine_path, pkcs11_module_path. 841 */ 842 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) { 843 /* 844 * Clear forced success to clear EAP state for next 845 * authentication. 846 */ 847 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); 848 } 849 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 850 wpa_sm_set_config(wpa_s->wpa, NULL); 851 wpa_sm_pmksa_cache_flush(wpa_s->wpa, NULL); 852 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth); 853 rsn_preauth_deinit(wpa_s->wpa); 854 855 old_ap_scan = wpa_s->conf->ap_scan; 856 wpa_config_free(wpa_s->conf); 857 wpa_s->conf = conf; 858 if (old_ap_scan != wpa_s->conf->ap_scan) 859 wpas_notify_ap_scan_changed(wpa_s); 860 861 if (reconf_ctrl) 862 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s); 863 864 wpa_supplicant_update_config(wpa_s); 865 866 wpa_supplicant_clear_status(wpa_s); 867 if (wpa_supplicant_enabled_networks(wpa_s)) { 868 wpa_s->reassociate = 1; 869 wpa_supplicant_req_scan(wpa_s, 0, 0); 870 } 871 wpa_dbg(wpa_s, MSG_DEBUG, "Reconfiguration completed"); 872 return 0; 873} 874 875 876static void wpa_supplicant_reconfig(int sig, void *signal_ctx) 877{ 878 struct wpa_global *global = signal_ctx; 879 struct wpa_supplicant *wpa_s; 880 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 881 wpa_dbg(wpa_s, MSG_DEBUG, "Signal %d received - reconfiguring", 882 sig); 883 if (wpa_supplicant_reload_configuration(wpa_s) < 0) { 884 wpa_supplicant_terminate_proc(global); 885 } 886 } 887} 888 889 890static int wpa_supplicant_suites_from_ai(struct wpa_supplicant *wpa_s, 891 struct wpa_ssid *ssid, 892 struct wpa_ie_data *ie) 893{ 894 int ret = wpa_sm_parse_own_wpa_ie(wpa_s->wpa, ie); 895 if (ret) { 896 if (ret == -2) { 897 wpa_msg(wpa_s, MSG_INFO, "WPA: Failed to parse WPA IE " 898 "from association info"); 899 } 900 return -1; 901 } 902 903 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Using WPA IE from AssocReq to set " 904 "cipher suites"); 905 if (!(ie->group_cipher & ssid->group_cipher)) { 906 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled group " 907 "cipher 0x%x (mask 0x%x) - reject", 908 ie->group_cipher, ssid->group_cipher); 909 return -1; 910 } 911 if (!(ie->pairwise_cipher & ssid->pairwise_cipher)) { 912 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled pairwise " 913 "cipher 0x%x (mask 0x%x) - reject", 914 ie->pairwise_cipher, ssid->pairwise_cipher); 915 return -1; 916 } 917 if (!(ie->key_mgmt & ssid->key_mgmt)) { 918 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver used disabled key " 919 "management 0x%x (mask 0x%x) - reject", 920 ie->key_mgmt, ssid->key_mgmt); 921 return -1; 922 } 923 924#ifdef CONFIG_IEEE80211W 925 if (!(ie->capabilities & WPA_CAPABILITY_MFPC) && 926 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ? 927 wpa_s->conf->pmf : ssid->ieee80211w) == 928 MGMT_FRAME_PROTECTION_REQUIRED) { 929 wpa_msg(wpa_s, MSG_INFO, "WPA: Driver associated with an AP " 930 "that does not support management frame protection - " 931 "reject"); 932 return -1; 933 } 934#endif /* CONFIG_IEEE80211W */ 935 936 return 0; 937} 938 939 940/** 941 * wpa_supplicant_set_suites - Set authentication and encryption parameters 942 * @wpa_s: Pointer to wpa_supplicant data 943 * @bss: Scan results for the selected BSS, or %NULL if not available 944 * @ssid: Configuration data for the selected network 945 * @wpa_ie: Buffer for the WPA/RSN IE 946 * @wpa_ie_len: Maximum wpa_ie buffer size on input. This is changed to be the 947 * used buffer length in case the functions returns success. 948 * Returns: 0 on success or -1 on failure 949 * 950 * This function is used to configure authentication and encryption parameters 951 * based on the network configuration and scan result for the selected BSS (if 952 * available). 953 */ 954int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s, 955 struct wpa_bss *bss, struct wpa_ssid *ssid, 956 u8 *wpa_ie, size_t *wpa_ie_len) 957{ 958 struct wpa_ie_data ie; 959 int sel, proto; 960 const u8 *bss_wpa, *bss_rsn, *bss_osen; 961 962 if (bss) { 963 bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE); 964 bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN); 965 bss_osen = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE); 966 } else 967 bss_wpa = bss_rsn = bss_osen = NULL; 968 969 if (bss_rsn && (ssid->proto & WPA_PROTO_RSN) && 970 wpa_parse_wpa_ie(bss_rsn, 2 + bss_rsn[1], &ie) == 0 && 971 (ie.group_cipher & ssid->group_cipher) && 972 (ie.pairwise_cipher & ssid->pairwise_cipher) && 973 (ie.key_mgmt & ssid->key_mgmt)) { 974 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0"); 975 proto = WPA_PROTO_RSN; 976 } else if (bss_wpa && (ssid->proto & WPA_PROTO_WPA) && 977 wpa_parse_wpa_ie(bss_wpa, 2 +bss_wpa[1], &ie) == 0 && 978 (ie.group_cipher & ssid->group_cipher) && 979 (ie.pairwise_cipher & ssid->pairwise_cipher) && 980 (ie.key_mgmt & ssid->key_mgmt)) { 981 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0"); 982 proto = WPA_PROTO_WPA; 983#ifdef CONFIG_HS20 984 } else if (bss_osen && (ssid->proto & WPA_PROTO_OSEN)) { 985 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using OSEN"); 986 /* TODO: parse OSEN element */ 987 os_memset(&ie, 0, sizeof(ie)); 988 ie.group_cipher = WPA_CIPHER_CCMP; 989 ie.pairwise_cipher = WPA_CIPHER_CCMP; 990 ie.key_mgmt = WPA_KEY_MGMT_OSEN; 991 proto = WPA_PROTO_OSEN; 992#endif /* CONFIG_HS20 */ 993 } else if (bss) { 994 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select WPA/RSN"); 995 return -1; 996 } else { 997 if (ssid->proto & WPA_PROTO_OSEN) 998 proto = WPA_PROTO_OSEN; 999 else if (ssid->proto & WPA_PROTO_RSN) 1000 proto = WPA_PROTO_RSN; 1001 else 1002 proto = WPA_PROTO_WPA; 1003 if (wpa_supplicant_suites_from_ai(wpa_s, ssid, &ie) < 0) { 1004 os_memset(&ie, 0, sizeof(ie)); 1005 ie.group_cipher = ssid->group_cipher; 1006 ie.pairwise_cipher = ssid->pairwise_cipher; 1007 ie.key_mgmt = ssid->key_mgmt; 1008#ifdef CONFIG_IEEE80211W 1009 ie.mgmt_group_cipher = 1010 ssid->ieee80211w != NO_MGMT_FRAME_PROTECTION ? 1011 WPA_CIPHER_AES_128_CMAC : 0; 1012#endif /* CONFIG_IEEE80211W */ 1013 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Set cipher suites " 1014 "based on configuration"); 1015 } else 1016 proto = ie.proto; 1017 } 1018 1019 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected cipher suites: group %d " 1020 "pairwise %d key_mgmt %d proto %d", 1021 ie.group_cipher, ie.pairwise_cipher, ie.key_mgmt, proto); 1022#ifdef CONFIG_IEEE80211W 1023 if (ssid->ieee80211w) { 1024 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected mgmt group cipher %d", 1025 ie.mgmt_group_cipher); 1026 } 1027#endif /* CONFIG_IEEE80211W */ 1028 1029 wpa_s->wpa_proto = proto; 1030 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, proto); 1031 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_RSN_ENABLED, 1032 !!(ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN))); 1033 1034 if (bss || !wpa_s->ap_ies_from_associnfo) { 1035 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa, 1036 bss_wpa ? 2 + bss_wpa[1] : 0) || 1037 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn, 1038 bss_rsn ? 2 + bss_rsn[1] : 0)) 1039 return -1; 1040 } 1041 1042 sel = ie.group_cipher & ssid->group_cipher; 1043 wpa_s->group_cipher = wpa_pick_group_cipher(sel); 1044 if (wpa_s->group_cipher < 0) { 1045 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select group " 1046 "cipher"); 1047 return -1; 1048 } 1049 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using GTK %s", 1050 wpa_cipher_txt(wpa_s->group_cipher)); 1051 1052 sel = ie.pairwise_cipher & ssid->pairwise_cipher; 1053 wpa_s->pairwise_cipher = wpa_pick_pairwise_cipher(sel, 1); 1054 if (wpa_s->pairwise_cipher < 0) { 1055 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select pairwise " 1056 "cipher"); 1057 return -1; 1058 } 1059 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using PTK %s", 1060 wpa_cipher_txt(wpa_s->pairwise_cipher)); 1061 1062 sel = ie.key_mgmt & ssid->key_mgmt; 1063#ifdef CONFIG_SAE 1064 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) 1065 sel &= ~(WPA_KEY_MGMT_SAE | WPA_KEY_MGMT_FT_SAE); 1066#endif /* CONFIG_SAE */ 1067 if (0) { 1068#ifdef CONFIG_IEEE80211R 1069 } else if (sel & WPA_KEY_MGMT_FT_IEEE8021X) { 1070 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_IEEE8021X; 1071 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/802.1X"); 1072 } else if (sel & WPA_KEY_MGMT_FT_PSK) { 1073 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_PSK; 1074 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT FT/PSK"); 1075#endif /* CONFIG_IEEE80211R */ 1076#ifdef CONFIG_SAE 1077 } else if (sel & WPA_KEY_MGMT_SAE) { 1078 wpa_s->key_mgmt = WPA_KEY_MGMT_SAE; 1079 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT SAE"); 1080 } else if (sel & WPA_KEY_MGMT_FT_SAE) { 1081 wpa_s->key_mgmt = WPA_KEY_MGMT_FT_SAE; 1082 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: using KEY_MGMT FT/SAE"); 1083#endif /* CONFIG_SAE */ 1084#ifdef CONFIG_IEEE80211W 1085 } else if (sel & WPA_KEY_MGMT_IEEE8021X_SHA256) { 1086 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X_SHA256; 1087 wpa_dbg(wpa_s, MSG_DEBUG, 1088 "WPA: using KEY_MGMT 802.1X with SHA256"); 1089 } else if (sel & WPA_KEY_MGMT_PSK_SHA256) { 1090 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK_SHA256; 1091 wpa_dbg(wpa_s, MSG_DEBUG, 1092 "WPA: using KEY_MGMT PSK with SHA256"); 1093#endif /* CONFIG_IEEE80211W */ 1094 } else if (sel & WPA_KEY_MGMT_IEEE8021X) { 1095 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X; 1096 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT 802.1X"); 1097 } else if (sel & WPA_KEY_MGMT_PSK) { 1098 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK; 1099 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-PSK"); 1100 } else if (sel & WPA_KEY_MGMT_WPA_NONE) { 1101 wpa_s->key_mgmt = WPA_KEY_MGMT_WPA_NONE; 1102 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using KEY_MGMT WPA-NONE"); 1103#ifdef CONFIG_HS20 1104 } else if (sel & WPA_KEY_MGMT_OSEN) { 1105 wpa_s->key_mgmt = WPA_KEY_MGMT_OSEN; 1106 wpa_dbg(wpa_s, MSG_DEBUG, "HS 2.0: using KEY_MGMT OSEN"); 1107#endif /* CONFIG_HS20 */ 1108 } else { 1109 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to select " 1110 "authenticated key management type"); 1111 return -1; 1112 } 1113 1114 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_KEY_MGMT, wpa_s->key_mgmt); 1115 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PAIRWISE, 1116 wpa_s->pairwise_cipher); 1117 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_GROUP, wpa_s->group_cipher); 1118 1119#ifdef CONFIG_IEEE80211W 1120 sel = ie.mgmt_group_cipher; 1121 if ((ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ? 1122 wpa_s->conf->pmf : ssid->ieee80211w) == NO_MGMT_FRAME_PROTECTION || 1123 !(ie.capabilities & WPA_CAPABILITY_MFPC)) 1124 sel = 0; 1125 if (sel & WPA_CIPHER_AES_128_CMAC) { 1126 wpa_s->mgmt_group_cipher = WPA_CIPHER_AES_128_CMAC; 1127 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher " 1128 "AES-128-CMAC"); 1129 } else if (sel & WPA_CIPHER_BIP_GMAC_128) { 1130 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_128; 1131 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher " 1132 "BIP-GMAC-128"); 1133 } else if (sel & WPA_CIPHER_BIP_GMAC_256) { 1134 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_GMAC_256; 1135 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher " 1136 "BIP-GMAC-256"); 1137 } else if (sel & WPA_CIPHER_BIP_CMAC_256) { 1138 wpa_s->mgmt_group_cipher = WPA_CIPHER_BIP_CMAC_256; 1139 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: using MGMT group cipher " 1140 "BIP-CMAC-256"); 1141 } else { 1142 wpa_s->mgmt_group_cipher = 0; 1143 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: not using MGMT group cipher"); 1144 } 1145 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MGMT_GROUP, 1146 wpa_s->mgmt_group_cipher); 1147 wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_MFP, 1148 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ? 1149 wpa_s->conf->pmf : ssid->ieee80211w)); 1150#endif /* CONFIG_IEEE80211W */ 1151 1152 if (wpa_sm_set_assoc_wpa_ie_default(wpa_s->wpa, wpa_ie, wpa_ie_len)) { 1153 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to generate WPA IE"); 1154 return -1; 1155 } 1156 1157 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt)) { 1158 wpa_sm_set_pmk(wpa_s->wpa, ssid->psk, PMK_LEN); 1159#ifndef CONFIG_NO_PBKDF2 1160 if (bss && ssid->bssid_set && ssid->ssid_len == 0 && 1161 ssid->passphrase) { 1162 u8 psk[PMK_LEN]; 1163 pbkdf2_sha1(ssid->passphrase, bss->ssid, bss->ssid_len, 1164 4096, psk, PMK_LEN); 1165 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from passphrase)", 1166 psk, PMK_LEN); 1167 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN); 1168 } 1169#endif /* CONFIG_NO_PBKDF2 */ 1170#ifdef CONFIG_EXT_PASSWORD 1171 if (ssid->ext_psk) { 1172 struct wpabuf *pw = ext_password_get(wpa_s->ext_pw, 1173 ssid->ext_psk); 1174 char pw_str[64 + 1]; 1175 u8 psk[PMK_LEN]; 1176 1177 if (pw == NULL) { 1178 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No PSK " 1179 "found from external storage"); 1180 return -1; 1181 } 1182 1183 if (wpabuf_len(pw) < 8 || wpabuf_len(pw) > 64) { 1184 wpa_msg(wpa_s, MSG_INFO, "EXT PW: Unexpected " 1185 "PSK length %d in external storage", 1186 (int) wpabuf_len(pw)); 1187 ext_password_free(pw); 1188 return -1; 1189 } 1190 1191 os_memcpy(pw_str, wpabuf_head(pw), wpabuf_len(pw)); 1192 pw_str[wpabuf_len(pw)] = '\0'; 1193 1194#ifndef CONFIG_NO_PBKDF2 1195 if (wpabuf_len(pw) >= 8 && wpabuf_len(pw) < 64 && bss) 1196 { 1197 pbkdf2_sha1(pw_str, bss->ssid, bss->ssid_len, 1198 4096, psk, PMK_LEN); 1199 os_memset(pw_str, 0, sizeof(pw_str)); 1200 wpa_hexdump_key(MSG_MSGDUMP, "PSK (from " 1201 "external passphrase)", 1202 psk, PMK_LEN); 1203 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN); 1204 } else 1205#endif /* CONFIG_NO_PBKDF2 */ 1206 if (wpabuf_len(pw) == 2 * PMK_LEN) { 1207 if (hexstr2bin(pw_str, psk, PMK_LEN) < 0) { 1208 wpa_msg(wpa_s, MSG_INFO, "EXT PW: " 1209 "Invalid PSK hex string"); 1210 os_memset(pw_str, 0, sizeof(pw_str)); 1211 ext_password_free(pw); 1212 return -1; 1213 } 1214 wpa_sm_set_pmk(wpa_s->wpa, psk, PMK_LEN); 1215 } else { 1216 wpa_msg(wpa_s, MSG_INFO, "EXT PW: No suitable " 1217 "PSK available"); 1218 os_memset(pw_str, 0, sizeof(pw_str)); 1219 ext_password_free(pw); 1220 return -1; 1221 } 1222 1223 os_memset(pw_str, 0, sizeof(pw_str)); 1224 ext_password_free(pw); 1225 } 1226#endif /* CONFIG_EXT_PASSWORD */ 1227 } else 1228 wpa_sm_set_pmk_from_pmksa(wpa_s->wpa); 1229 1230 return 0; 1231} 1232 1233 1234static void wpas_ext_capab_byte(struct wpa_supplicant *wpa_s, u8 *pos, int idx) 1235{ 1236 *pos = 0x00; 1237 1238 switch (idx) { 1239 case 0: /* Bits 0-7 */ 1240 break; 1241 case 1: /* Bits 8-15 */ 1242 break; 1243 case 2: /* Bits 16-23 */ 1244#ifdef CONFIG_WNM 1245 *pos |= 0x02; /* Bit 17 - WNM-Sleep Mode */ 1246 *pos |= 0x08; /* Bit 19 - BSS Transition */ 1247#endif /* CONFIG_WNM */ 1248 break; 1249 case 3: /* Bits 24-31 */ 1250#ifdef CONFIG_WNM 1251 *pos |= 0x02; /* Bit 25 - SSID List */ 1252#endif /* CONFIG_WNM */ 1253#ifdef CONFIG_INTERWORKING 1254 if (wpa_s->conf->interworking) 1255 *pos |= 0x80; /* Bit 31 - Interworking */ 1256#endif /* CONFIG_INTERWORKING */ 1257 break; 1258 case 4: /* Bits 32-39 */ 1259#ifdef CONFIG_INTERWORKING 1260 if (wpa_s->drv_flags / WPA_DRIVER_FLAGS_QOS_MAPPING) 1261 *pos |= 0x01; /* Bit 32 - QoS Map */ 1262#endif /* CONFIG_INTERWORKING */ 1263 break; 1264 case 5: /* Bits 40-47 */ 1265#ifdef CONFIG_HS20 1266 if (wpa_s->conf->hs20) 1267 *pos |= 0x40; /* Bit 46 - WNM-Notification */ 1268#endif /* CONFIG_HS20 */ 1269 break; 1270 case 6: /* Bits 48-55 */ 1271 break; 1272 } 1273} 1274 1275 1276int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen) 1277{ 1278 u8 *pos = buf; 1279 u8 len = 6, i; 1280 1281 if (len < wpa_s->extended_capa_len) 1282 len = wpa_s->extended_capa_len; 1283 if (buflen < (size_t) len + 2) { 1284 wpa_printf(MSG_INFO, 1285 "Not enough room for building extended capabilities element"); 1286 return -1; 1287 } 1288 1289 *pos++ = WLAN_EID_EXT_CAPAB; 1290 *pos++ = len; 1291 for (i = 0; i < len; i++, pos++) { 1292 wpas_ext_capab_byte(wpa_s, pos, i); 1293 1294 if (i < wpa_s->extended_capa_len) { 1295 *pos &= ~wpa_s->extended_capa_mask[i]; 1296 *pos |= wpa_s->extended_capa[i]; 1297 } 1298 } 1299 1300 while (len > 0 && buf[1 + len] == 0) { 1301 len--; 1302 buf[1] = len; 1303 } 1304 if (len == 0) 1305 return 0; 1306 1307 return 2 + len; 1308} 1309 1310 1311static int wpas_valid_bss(struct wpa_supplicant *wpa_s, 1312 struct wpa_bss *test_bss) 1313{ 1314 struct wpa_bss *bss; 1315 1316 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) { 1317 if (bss == test_bss) 1318 return 1; 1319 } 1320 1321 return 0; 1322} 1323 1324 1325static int wpas_valid_ssid(struct wpa_supplicant *wpa_s, 1326 struct wpa_ssid *test_ssid) 1327{ 1328 struct wpa_ssid *ssid; 1329 1330 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) { 1331 if (ssid == test_ssid) 1332 return 1; 1333 } 1334 1335 return 0; 1336} 1337 1338 1339int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss, 1340 struct wpa_ssid *test_ssid) 1341{ 1342 if (test_bss && !wpas_valid_bss(wpa_s, test_bss)) 1343 return 0; 1344 1345 return test_ssid == NULL || wpas_valid_ssid(wpa_s, test_ssid); 1346} 1347 1348 1349void wpas_connect_work_free(struct wpa_connect_work *cwork) 1350{ 1351 if (cwork == NULL) 1352 return; 1353 os_free(cwork); 1354} 1355 1356 1357void wpas_connect_work_done(struct wpa_supplicant *wpa_s) 1358{ 1359 struct wpa_connect_work *cwork; 1360 struct wpa_radio_work *work = wpa_s->connect_work; 1361 1362 if (!work) 1363 return; 1364 1365 wpa_s->connect_work = NULL; 1366 cwork = work->ctx; 1367 work->ctx = NULL; 1368 wpas_connect_work_free(cwork); 1369 radio_work_done(work); 1370} 1371 1372 1373static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit); 1374 1375/** 1376 * wpa_supplicant_associate - Request association 1377 * @wpa_s: Pointer to wpa_supplicant data 1378 * @bss: Scan results for the selected BSS, or %NULL if not available 1379 * @ssid: Configuration data for the selected network 1380 * 1381 * This function is used to request %wpa_supplicant to associate with a BSS. 1382 */ 1383void wpa_supplicant_associate(struct wpa_supplicant *wpa_s, 1384 struct wpa_bss *bss, struct wpa_ssid *ssid) 1385{ 1386 struct wpa_connect_work *cwork; 1387 1388#ifdef CONFIG_IBSS_RSN 1389 ibss_rsn_deinit(wpa_s->ibss_rsn); 1390 wpa_s->ibss_rsn = NULL; 1391#endif /* CONFIG_IBSS_RSN */ 1392 1393 if (ssid->mode == WPAS_MODE_AP || ssid->mode == WPAS_MODE_P2P_GO || 1394 ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) { 1395#ifdef CONFIG_AP 1396 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) { 1397 wpa_msg(wpa_s, MSG_INFO, "Driver does not support AP " 1398 "mode"); 1399 return; 1400 } 1401 if (wpa_supplicant_create_ap(wpa_s, ssid) < 0) { 1402 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 1403 if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) 1404 wpas_p2p_ap_setup_failed(wpa_s); 1405 return; 1406 } 1407 wpa_s->current_bss = bss; 1408#else /* CONFIG_AP */ 1409 wpa_msg(wpa_s, MSG_ERROR, "AP mode support not included in " 1410 "the build"); 1411#endif /* CONFIG_AP */ 1412 return; 1413 } 1414 1415#ifdef CONFIG_TDLS 1416 if (bss) 1417 wpa_tdls_ap_ies(wpa_s->wpa, (const u8 *) (bss + 1), 1418 bss->ie_len); 1419#endif /* CONFIG_TDLS */ 1420 1421 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 1422 ssid->mode == IEEE80211_MODE_INFRA) { 1423 sme_authenticate(wpa_s, bss, ssid); 1424 return; 1425 } 1426 1427 if (wpa_s->connect_work) { 1428 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since connect_work exist"); 1429 return; 1430 } 1431 1432 if (radio_work_pending(wpa_s, "connect")) { 1433 wpa_dbg(wpa_s, MSG_DEBUG, "Reject wpa_supplicant_associate() call since pending work exist"); 1434 return; 1435 } 1436 1437 cwork = os_zalloc(sizeof(*cwork)); 1438 if (cwork == NULL) 1439 return; 1440 1441 cwork->bss = bss; 1442 cwork->ssid = ssid; 1443 1444 if (radio_add_work(wpa_s, bss ? bss->freq : 0, "connect", 1, 1445 wpas_start_assoc_cb, cwork) < 0) { 1446 os_free(cwork); 1447 } 1448} 1449 1450 1451static void wpas_start_assoc_cb(struct wpa_radio_work *work, int deinit) 1452{ 1453 struct wpa_connect_work *cwork = work->ctx; 1454 struct wpa_bss *bss = cwork->bss; 1455 struct wpa_ssid *ssid = cwork->ssid; 1456 struct wpa_supplicant *wpa_s = work->wpa_s; 1457 u8 wpa_ie[200]; 1458 size_t wpa_ie_len; 1459 int use_crypt, ret, i, bssid_changed; 1460 int algs = WPA_AUTH_ALG_OPEN; 1461 unsigned int cipher_pairwise, cipher_group; 1462 struct wpa_driver_associate_params params; 1463 int wep_keys_set = 0; 1464 int assoc_failed = 0; 1465 struct wpa_ssid *old_ssid; 1466#ifdef CONFIG_HT_OVERRIDES 1467 struct ieee80211_ht_capabilities htcaps; 1468 struct ieee80211_ht_capabilities htcaps_mask; 1469#endif /* CONFIG_HT_OVERRIDES */ 1470#ifdef CONFIG_VHT_OVERRIDES 1471 struct ieee80211_vht_capabilities vhtcaps; 1472 struct ieee80211_vht_capabilities vhtcaps_mask; 1473#endif /* CONFIG_VHT_OVERRIDES */ 1474 1475 if (deinit) { 1476 if (work->started) { 1477 wpa_s->connect_work = NULL; 1478 1479 /* cancel possible auth. timeout */ 1480 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, 1481 NULL); 1482 } 1483 wpas_connect_work_free(cwork); 1484 return; 1485 } 1486 1487 wpa_s->connect_work = work; 1488 1489 if (!wpas_valid_bss_ssid(wpa_s, bss, ssid)) { 1490 wpa_dbg(wpa_s, MSG_DEBUG, "BSS/SSID entry for association not valid anymore - drop connection attempt"); 1491 wpas_connect_work_done(wpa_s); 1492 return; 1493 } 1494 1495 os_memset(¶ms, 0, sizeof(params)); 1496 wpa_s->reassociate = 0; 1497 wpa_s->eap_expected_failure = 0; 1498 if (bss && !wpas_driver_bss_selection(wpa_s)) { 1499#ifdef CONFIG_IEEE80211R 1500 const u8 *ie, *md = NULL; 1501#endif /* CONFIG_IEEE80211R */ 1502 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR 1503 " (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid), 1504 wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq); 1505 bssid_changed = !is_zero_ether_addr(wpa_s->bssid); 1506 os_memset(wpa_s->bssid, 0, ETH_ALEN); 1507 os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN); 1508 if (bssid_changed) 1509 wpas_notify_bssid_changed(wpa_s); 1510#ifdef CONFIG_IEEE80211R 1511 ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN); 1512 if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN) 1513 md = ie + 2; 1514 wpa_sm_set_ft_params(wpa_s->wpa, ie, ie ? 2 + ie[1] : 0); 1515 if (md) { 1516 /* Prepare for the next transition */ 1517 wpa_ft_prepare_auth_request(wpa_s->wpa, ie); 1518 } 1519#endif /* CONFIG_IEEE80211R */ 1520#ifdef CONFIG_WPS 1521 } else if ((ssid->ssid == NULL || ssid->ssid_len == 0) && 1522 wpa_s->conf->ap_scan == 2 && 1523 (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) { 1524 /* Use ap_scan==1 style network selection to find the network 1525 */ 1526 wpa_s->scan_req = MANUAL_SCAN_REQ; 1527 wpa_s->reassociate = 1; 1528 wpa_supplicant_req_scan(wpa_s, 0, 0); 1529 return; 1530#endif /* CONFIG_WPS */ 1531 } else { 1532 wpa_msg(wpa_s, MSG_INFO, "Trying to associate with SSID '%s'", 1533 wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); 1534 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 1535 } 1536 wpa_supplicant_cancel_sched_scan(wpa_s); 1537 wpa_supplicant_cancel_scan(wpa_s); 1538 1539 /* Starting new association, so clear the possibly used WPA IE from the 1540 * previous association. */ 1541 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 1542 1543#ifdef IEEE8021X_EAPOL 1544 if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 1545 if (ssid->leap) { 1546 if (ssid->non_leap == 0) 1547 algs = WPA_AUTH_ALG_LEAP; 1548 else 1549 algs |= WPA_AUTH_ALG_LEAP; 1550 } 1551 } 1552#endif /* IEEE8021X_EAPOL */ 1553 wpa_dbg(wpa_s, MSG_DEBUG, "Automatic auth_alg selection: 0x%x", algs); 1554 if (ssid->auth_alg) { 1555 algs = ssid->auth_alg; 1556 wpa_dbg(wpa_s, MSG_DEBUG, "Overriding auth_alg selection: " 1557 "0x%x", algs); 1558 } 1559 1560 if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) || 1561 wpa_bss_get_ie(bss, WLAN_EID_RSN)) && 1562 wpa_key_mgmt_wpa(ssid->key_mgmt)) { 1563 int try_opportunistic; 1564 try_opportunistic = (ssid->proactive_key_caching < 0 ? 1565 wpa_s->conf->okc : 1566 ssid->proactive_key_caching) && 1567 (ssid->proto & WPA_PROTO_RSN); 1568 if (pmksa_cache_set_current(wpa_s->wpa, NULL, bss->bssid, 1569 ssid, try_opportunistic) == 0) 1570 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1); 1571 wpa_ie_len = sizeof(wpa_ie); 1572 if (wpa_supplicant_set_suites(wpa_s, bss, ssid, 1573 wpa_ie, &wpa_ie_len)) { 1574 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA " 1575 "key management and encryption suites"); 1576 return; 1577 } 1578 } else if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && bss && 1579 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) { 1580 /* 1581 * Both WPA and non-WPA IEEE 802.1X enabled in configuration - 1582 * use non-WPA since the scan results did not indicate that the 1583 * AP is using WPA or WPA2. 1584 */ 1585 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 1586 wpa_ie_len = 0; 1587 wpa_s->wpa_proto = 0; 1588 } else if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) { 1589 wpa_ie_len = sizeof(wpa_ie); 1590 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid, 1591 wpa_ie, &wpa_ie_len)) { 1592 wpa_msg(wpa_s, MSG_WARNING, "WPA: Failed to set WPA " 1593 "key management and encryption suites (no " 1594 "scan results)"); 1595 return; 1596 } 1597#ifdef CONFIG_WPS 1598 } else if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) { 1599 struct wpabuf *wps_ie; 1600 wps_ie = wps_build_assoc_req_ie(wpas_wps_get_req_type(ssid)); 1601 if (wps_ie && wpabuf_len(wps_ie) <= sizeof(wpa_ie)) { 1602 wpa_ie_len = wpabuf_len(wps_ie); 1603 os_memcpy(wpa_ie, wpabuf_head(wps_ie), wpa_ie_len); 1604 } else 1605 wpa_ie_len = 0; 1606 wpabuf_free(wps_ie); 1607 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 1608 if (!bss || (bss->caps & IEEE80211_CAP_PRIVACY)) 1609 params.wps = WPS_MODE_PRIVACY; 1610 else 1611 params.wps = WPS_MODE_OPEN; 1612 wpa_s->wpa_proto = 0; 1613#endif /* CONFIG_WPS */ 1614 } else { 1615 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 1616 wpa_ie_len = 0; 1617 wpa_s->wpa_proto = 0; 1618 } 1619 1620#ifdef CONFIG_P2P 1621 if (wpa_s->global->p2p) { 1622 u8 *pos; 1623 size_t len; 1624 int res; 1625 pos = wpa_ie + wpa_ie_len; 1626 len = sizeof(wpa_ie) - wpa_ie_len; 1627 res = wpas_p2p_assoc_req_ie(wpa_s, bss, pos, len, 1628 ssid->p2p_group); 1629 if (res >= 0) 1630 wpa_ie_len += res; 1631 } 1632 1633 wpa_s->cross_connect_disallowed = 0; 1634 if (bss) { 1635 struct wpabuf *p2p; 1636 p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE); 1637 if (p2p) { 1638 wpa_s->cross_connect_disallowed = 1639 p2p_get_cross_connect_disallowed(p2p); 1640 wpabuf_free(p2p); 1641 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: WLAN AP %s cross " 1642 "connection", 1643 wpa_s->cross_connect_disallowed ? 1644 "disallows" : "allows"); 1645 } 1646 } 1647 1648 os_memset(wpa_s->p2p_ip_addr_info, 0, sizeof(wpa_s->p2p_ip_addr_info)); 1649#endif /* CONFIG_P2P */ 1650 1651#ifdef CONFIG_HS20 1652 if (is_hs20_network(wpa_s, ssid, bss)) { 1653 struct wpabuf *hs20; 1654 hs20 = wpabuf_alloc(20); 1655 if (hs20) { 1656 int pps_mo_id = hs20_get_pps_mo_id(wpa_s, ssid); 1657 wpas_hs20_add_indication(hs20, pps_mo_id); 1658 os_memcpy(wpa_ie + wpa_ie_len, wpabuf_head(hs20), 1659 wpabuf_len(hs20)); 1660 wpa_ie_len += wpabuf_len(hs20); 1661 wpabuf_free(hs20); 1662 } 1663 } 1664#endif /* CONFIG_HS20 */ 1665 1666 /* 1667 * Workaround: Add Extended Capabilities element only if the AP 1668 * included this element in Beacon/Probe Response frames. Some older 1669 * APs seem to have interoperability issues if this element is 1670 * included, so while the standard may require us to include the 1671 * element in all cases, it is justifiable to skip it to avoid 1672 * interoperability issues. 1673 */ 1674 if (!bss || wpa_bss_get_ie(bss, WLAN_EID_EXT_CAPAB)) { 1675 u8 ext_capab[18]; 1676 int ext_capab_len; 1677 ext_capab_len = wpas_build_ext_capab(wpa_s, ext_capab, 1678 sizeof(ext_capab)); 1679 if (ext_capab_len > 0) { 1680 u8 *pos = wpa_ie; 1681 if (wpa_ie_len > 0 && pos[0] == WLAN_EID_RSN) 1682 pos += 2 + pos[1]; 1683 os_memmove(pos + ext_capab_len, pos, 1684 wpa_ie_len - (pos - wpa_ie)); 1685 wpa_ie_len += ext_capab_len; 1686 os_memcpy(pos, ext_capab, ext_capab_len); 1687 } 1688 } 1689 1690 wpa_clear_keys(wpa_s, bss ? bss->bssid : NULL); 1691 use_crypt = 1; 1692 cipher_pairwise = wpa_s->pairwise_cipher; 1693 cipher_group = wpa_s->group_cipher; 1694 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 1695 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 1696 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) 1697 use_crypt = 0; 1698 if (wpa_set_wep_keys(wpa_s, ssid)) { 1699 use_crypt = 1; 1700 wep_keys_set = 1; 1701 } 1702 } 1703 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) 1704 use_crypt = 0; 1705 1706#ifdef IEEE8021X_EAPOL 1707 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 1708 if ((ssid->eapol_flags & 1709 (EAPOL_FLAG_REQUIRE_KEY_UNICAST | 1710 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) == 0 && 1711 !wep_keys_set) { 1712 use_crypt = 0; 1713 } else { 1714 /* Assume that dynamic WEP-104 keys will be used and 1715 * set cipher suites in order for drivers to expect 1716 * encryption. */ 1717 cipher_pairwise = cipher_group = WPA_CIPHER_WEP104; 1718 } 1719 } 1720#endif /* IEEE8021X_EAPOL */ 1721 1722 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 1723 /* Set the key before (and later after) association */ 1724 wpa_supplicant_set_wpa_none_key(wpa_s, ssid); 1725 } 1726 1727 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING); 1728 if (bss) { 1729 params.ssid = bss->ssid; 1730 params.ssid_len = bss->ssid_len; 1731 if (!wpas_driver_bss_selection(wpa_s) || ssid->bssid_set) { 1732 wpa_printf(MSG_DEBUG, "Limit connection to BSSID " 1733 MACSTR " freq=%u MHz based on scan results " 1734 "(bssid_set=%d)", 1735 MAC2STR(bss->bssid), bss->freq, 1736 ssid->bssid_set); 1737 params.bssid = bss->bssid; 1738 params.freq = bss->freq; 1739 } 1740 params.bssid_hint = bss->bssid; 1741 params.freq_hint = bss->freq; 1742 } else { 1743 params.ssid = ssid->ssid; 1744 params.ssid_len = ssid->ssid_len; 1745 } 1746 1747 if (ssid->mode == WPAS_MODE_IBSS && ssid->bssid_set && 1748 wpa_s->conf->ap_scan == 2) { 1749 params.bssid = ssid->bssid; 1750 params.fixed_bssid = 1; 1751 } 1752 1753 if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 && 1754 params.freq == 0) 1755 params.freq = ssid->frequency; /* Initial channel for IBSS */ 1756 1757 if (ssid->mode == WPAS_MODE_IBSS) { 1758 if (ssid->beacon_int) 1759 params.beacon_int = ssid->beacon_int; 1760 else 1761 params.beacon_int = wpa_s->conf->beacon_int; 1762 } 1763 1764 params.wpa_ie = wpa_ie; 1765 params.wpa_ie_len = wpa_ie_len; 1766 params.pairwise_suite = cipher_pairwise; 1767 params.group_suite = cipher_group; 1768 params.key_mgmt_suite = wpa_s->key_mgmt; 1769 params.wpa_proto = wpa_s->wpa_proto; 1770 params.auth_alg = algs; 1771 params.mode = ssid->mode; 1772 params.bg_scan_period = ssid->bg_scan_period; 1773 for (i = 0; i < NUM_WEP_KEYS; i++) { 1774 if (ssid->wep_key_len[i]) 1775 params.wep_key[i] = ssid->wep_key[i]; 1776 params.wep_key_len[i] = ssid->wep_key_len[i]; 1777 } 1778 params.wep_tx_keyidx = ssid->wep_tx_keyidx; 1779 1780 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) && 1781 (params.key_mgmt_suite == WPA_KEY_MGMT_PSK || 1782 params.key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) { 1783 params.passphrase = ssid->passphrase; 1784 if (ssid->psk_set) 1785 params.psk = ssid->psk; 1786 } 1787 1788 params.drop_unencrypted = use_crypt; 1789 1790#ifdef CONFIG_IEEE80211W 1791 params.mgmt_frame_protection = 1792 ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ? 1793 wpa_s->conf->pmf : ssid->ieee80211w; 1794 if (params.mgmt_frame_protection != NO_MGMT_FRAME_PROTECTION && bss) { 1795 const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN); 1796 struct wpa_ie_data ie; 1797 if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 && 1798 ie.capabilities & 1799 (WPA_CAPABILITY_MFPC | WPA_CAPABILITY_MFPR)) { 1800 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Selected AP supports " 1801 "MFP: require MFP"); 1802 params.mgmt_frame_protection = 1803 MGMT_FRAME_PROTECTION_REQUIRED; 1804 } 1805 } 1806#endif /* CONFIG_IEEE80211W */ 1807 1808 params.p2p = ssid->p2p_group; 1809 1810 if (wpa_s->parent->set_sta_uapsd) 1811 params.uapsd = wpa_s->parent->sta_uapsd; 1812 else 1813 params.uapsd = -1; 1814 1815#ifdef CONFIG_HT_OVERRIDES 1816 os_memset(&htcaps, 0, sizeof(htcaps)); 1817 os_memset(&htcaps_mask, 0, sizeof(htcaps_mask)); 1818 params.htcaps = (u8 *) &htcaps; 1819 params.htcaps_mask = (u8 *) &htcaps_mask; 1820 wpa_supplicant_apply_ht_overrides(wpa_s, ssid, ¶ms); 1821#endif /* CONFIG_HT_OVERRIDES */ 1822#ifdef CONFIG_VHT_OVERRIDES 1823 os_memset(&vhtcaps, 0, sizeof(vhtcaps)); 1824 os_memset(&vhtcaps_mask, 0, sizeof(vhtcaps_mask)); 1825 params.vhtcaps = &vhtcaps; 1826 params.vhtcaps_mask = &vhtcaps_mask; 1827 wpa_supplicant_apply_vht_overrides(wpa_s, wpa_s->current_ssid, ¶ms); 1828#endif /* CONFIG_VHT_OVERRIDES */ 1829 1830#ifdef CONFIG_P2P 1831 /* 1832 * If multi-channel concurrency is not supported, check for any 1833 * frequency conflict. In case of any frequency conflict, remove the 1834 * least prioritized connection. 1835 */ 1836 if (wpa_s->num_multichan_concurrent < 2) { 1837 int freq, num; 1838 num = get_shared_radio_freqs(wpa_s, &freq, 1); 1839 if (num > 0 && freq > 0 && freq != params.freq) { 1840 wpa_printf(MSG_DEBUG, 1841 "Assoc conflicting freq found (%d != %d)", 1842 freq, params.freq); 1843 if (wpas_p2p_handle_frequency_conflicts(wpa_s, 1844 params.freq, 1845 ssid) < 0) 1846 return; 1847 } 1848 } 1849#endif /* CONFIG_P2P */ 1850 1851 ret = wpa_drv_associate(wpa_s, ¶ms); 1852 if (ret < 0) { 1853 wpa_msg(wpa_s, MSG_INFO, "Association request to the driver " 1854 "failed"); 1855 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SANE_ERROR_CODES) { 1856 /* 1857 * The driver is known to mean what is saying, so we 1858 * can stop right here; the association will not 1859 * succeed. 1860 */ 1861 wpas_connection_failed(wpa_s, wpa_s->pending_bssid); 1862 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 1863 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 1864 return; 1865 } 1866 /* try to continue anyway; new association will be tried again 1867 * after timeout */ 1868 assoc_failed = 1; 1869 } 1870 1871 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 1872 /* Set the key after the association just in case association 1873 * cleared the previously configured key. */ 1874 wpa_supplicant_set_wpa_none_key(wpa_s, ssid); 1875 /* No need to timeout authentication since there is no key 1876 * management. */ 1877 wpa_supplicant_cancel_auth_timeout(wpa_s); 1878 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 1879#ifdef CONFIG_IBSS_RSN 1880 } else if (ssid->mode == WPAS_MODE_IBSS && 1881 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE && 1882 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) { 1883 /* 1884 * RSN IBSS authentication is per-STA and we can disable the 1885 * per-BSSID authentication. 1886 */ 1887 wpa_supplicant_cancel_auth_timeout(wpa_s); 1888#endif /* CONFIG_IBSS_RSN */ 1889 } else { 1890 /* Timeout for IEEE 802.11 authentication and association */ 1891 int timeout = 60; 1892 1893 if (assoc_failed) { 1894 /* give IBSS a bit more time */ 1895 timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5; 1896 } else if (wpa_s->conf->ap_scan == 1) { 1897 /* give IBSS a bit more time */ 1898 timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10; 1899 } 1900 wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0); 1901 } 1902 1903 if (wep_keys_set && 1904 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC)) { 1905 /* Set static WEP keys again */ 1906 wpa_set_wep_keys(wpa_s, ssid); 1907 } 1908 1909 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) { 1910 /* 1911 * Do not allow EAP session resumption between different 1912 * network configurations. 1913 */ 1914 eapol_sm_invalidate_cached_session(wpa_s->eapol); 1915 } 1916 old_ssid = wpa_s->current_ssid; 1917 wpa_s->current_ssid = ssid; 1918 wpa_s->current_bss = bss; 1919 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid); 1920 wpa_supplicant_initiate_eapol(wpa_s); 1921 if (old_ssid != wpa_s->current_ssid) 1922 wpas_notify_network_changed(wpa_s); 1923} 1924 1925 1926static void wpa_supplicant_clear_connection(struct wpa_supplicant *wpa_s, 1927 const u8 *addr) 1928{ 1929 struct wpa_ssid *old_ssid; 1930 1931 wpa_clear_keys(wpa_s, addr); 1932 old_ssid = wpa_s->current_ssid; 1933 wpa_supplicant_mark_disassoc(wpa_s); 1934 wpa_sm_set_config(wpa_s->wpa, NULL); 1935 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 1936 if (old_ssid != wpa_s->current_ssid) 1937 wpas_notify_network_changed(wpa_s); 1938 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 1939} 1940 1941 1942/** 1943 * wpa_supplicant_deauthenticate - Deauthenticate the current connection 1944 * @wpa_s: Pointer to wpa_supplicant data 1945 * @reason_code: IEEE 802.11 reason code for the deauthenticate frame 1946 * 1947 * This function is used to request %wpa_supplicant to deauthenticate from the 1948 * current AP. 1949 */ 1950void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s, 1951 int reason_code) 1952{ 1953 u8 *addr = NULL; 1954 union wpa_event_data event; 1955 int zero_addr = 0; 1956 1957 wpa_dbg(wpa_s, MSG_DEBUG, "Request to deauthenticate - bssid=" MACSTR 1958 " pending_bssid=" MACSTR " reason=%d state=%s", 1959 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid), 1960 reason_code, wpa_supplicant_state_txt(wpa_s->wpa_state)); 1961 1962 if (!is_zero_ether_addr(wpa_s->bssid)) 1963 addr = wpa_s->bssid; 1964 else if (!is_zero_ether_addr(wpa_s->pending_bssid) && 1965 (wpa_s->wpa_state == WPA_AUTHENTICATING || 1966 wpa_s->wpa_state == WPA_ASSOCIATING)) 1967 addr = wpa_s->pending_bssid; 1968 else if (wpa_s->wpa_state == WPA_ASSOCIATING) { 1969 /* 1970 * When using driver-based BSS selection, we may not know the 1971 * BSSID with which we are currently trying to associate. We 1972 * need to notify the driver of this disconnection even in such 1973 * a case, so use the all zeros address here. 1974 */ 1975 addr = wpa_s->bssid; 1976 zero_addr = 1; 1977 } 1978 1979#ifdef CONFIG_TDLS 1980 wpa_tdls_teardown_peers(wpa_s->wpa); 1981#endif /* CONFIG_TDLS */ 1982 1983 if (addr) { 1984 wpa_drv_deauthenticate(wpa_s, addr, reason_code); 1985 os_memset(&event, 0, sizeof(event)); 1986 event.deauth_info.reason_code = (u16) reason_code; 1987 event.deauth_info.locally_generated = 1; 1988 wpa_supplicant_event(wpa_s, EVENT_DEAUTH, &event); 1989 if (zero_addr) 1990 addr = NULL; 1991 } 1992 1993 wpa_supplicant_clear_connection(wpa_s, addr); 1994} 1995 1996static void wpa_supplicant_enable_one_network(struct wpa_supplicant *wpa_s, 1997 struct wpa_ssid *ssid) 1998{ 1999 if (!ssid || !ssid->disabled || ssid->disabled == 2) 2000 return; 2001 2002 ssid->disabled = 0; 2003 wpas_clear_temp_disabled(wpa_s, ssid, 1); 2004 wpas_notify_network_enabled_changed(wpa_s, ssid); 2005 2006 /* 2007 * Try to reassociate since there is no current configuration and a new 2008 * network was made available. 2009 */ 2010 if (!wpa_s->current_ssid && !wpa_s->disconnected) 2011 wpa_s->reassociate = 1; 2012} 2013 2014 2015/** 2016 * wpa_supplicant_enable_network - Mark a configured network as enabled 2017 * @wpa_s: wpa_supplicant structure for a network interface 2018 * @ssid: wpa_ssid structure for a configured network or %NULL 2019 * 2020 * Enables the specified network or all networks if no network specified. 2021 */ 2022void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s, 2023 struct wpa_ssid *ssid) 2024{ 2025 if (ssid == NULL) { 2026 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) 2027 wpa_supplicant_enable_one_network(wpa_s, ssid); 2028 } else 2029 wpa_supplicant_enable_one_network(wpa_s, ssid); 2030 2031 if (wpa_s->reassociate && !wpa_s->disconnected) { 2032 if (wpa_s->sched_scanning) { 2033 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to add " 2034 "new network to scan filters"); 2035 wpa_supplicant_cancel_sched_scan(wpa_s); 2036 } 2037 2038 if (wpa_supplicant_fast_associate(wpa_s) != 1) 2039 wpa_supplicant_req_scan(wpa_s, 0, 0); 2040 } 2041} 2042 2043 2044/** 2045 * wpa_supplicant_disable_network - Mark a configured network as disabled 2046 * @wpa_s: wpa_supplicant structure for a network interface 2047 * @ssid: wpa_ssid structure for a configured network or %NULL 2048 * 2049 * Disables the specified network or all networks if no network specified. 2050 */ 2051void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s, 2052 struct wpa_ssid *ssid) 2053{ 2054 struct wpa_ssid *other_ssid; 2055 int was_disabled; 2056 2057 if (ssid == NULL) { 2058 if (wpa_s->sched_scanning) 2059 wpa_supplicant_cancel_sched_scan(wpa_s); 2060 2061 for (other_ssid = wpa_s->conf->ssid; other_ssid; 2062 other_ssid = other_ssid->next) { 2063 was_disabled = other_ssid->disabled; 2064 if (was_disabled == 2) 2065 continue; /* do not change persistent P2P group 2066 * data */ 2067 2068 other_ssid->disabled = 1; 2069 2070 if (was_disabled != other_ssid->disabled) 2071 wpas_notify_network_enabled_changed( 2072 wpa_s, other_ssid); 2073 } 2074 if (wpa_s->current_ssid) 2075 wpa_supplicant_deauthenticate( 2076 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 2077 } else if (ssid->disabled != 2) { 2078 if (ssid == wpa_s->current_ssid) 2079 wpa_supplicant_deauthenticate( 2080 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 2081 2082 was_disabled = ssid->disabled; 2083 2084 ssid->disabled = 1; 2085 2086 if (was_disabled != ssid->disabled) { 2087 wpas_notify_network_enabled_changed(wpa_s, ssid); 2088 if (wpa_s->sched_scanning) { 2089 wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan " 2090 "to remove network from filters"); 2091 wpa_supplicant_cancel_sched_scan(wpa_s); 2092 wpa_supplicant_req_scan(wpa_s, 0, 0); 2093 } 2094 } 2095 } 2096} 2097 2098 2099/** 2100 * wpa_supplicant_select_network - Attempt association with a network 2101 * @wpa_s: wpa_supplicant structure for a network interface 2102 * @ssid: wpa_ssid structure for a configured network or %NULL for any network 2103 */ 2104void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s, 2105 struct wpa_ssid *ssid) 2106{ 2107 2108 struct wpa_ssid *other_ssid; 2109 int disconnected = 0; 2110 2111 if (ssid && ssid != wpa_s->current_ssid && wpa_s->current_ssid) { 2112 wpa_supplicant_deauthenticate( 2113 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 2114 disconnected = 1; 2115 } 2116 2117 if (ssid) 2118 wpas_clear_temp_disabled(wpa_s, ssid, 1); 2119 2120 /* 2121 * Mark all other networks disabled or mark all networks enabled if no 2122 * network specified. 2123 */ 2124 for (other_ssid = wpa_s->conf->ssid; other_ssid; 2125 other_ssid = other_ssid->next) { 2126 int was_disabled = other_ssid->disabled; 2127 if (was_disabled == 2) 2128 continue; /* do not change persistent P2P group data */ 2129 2130 other_ssid->disabled = ssid ? (ssid->id != other_ssid->id) : 0; 2131 if (was_disabled && !other_ssid->disabled) 2132 wpas_clear_temp_disabled(wpa_s, other_ssid, 0); 2133 2134 if (was_disabled != other_ssid->disabled) 2135 wpas_notify_network_enabled_changed(wpa_s, other_ssid); 2136 } 2137 2138 if (ssid && ssid == wpa_s->current_ssid && wpa_s->current_ssid) { 2139 /* We are already associated with the selected network */ 2140 wpa_printf(MSG_DEBUG, "Already associated with the " 2141 "selected network - do nothing"); 2142 return; 2143 } 2144 2145 if (ssid) { 2146 wpa_s->current_ssid = ssid; 2147 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 2148 } 2149 wpa_s->connect_without_scan = NULL; 2150 wpa_s->disconnected = 0; 2151 wpa_s->reassociate = 1; 2152 2153 if (wpa_supplicant_fast_associate(wpa_s) != 1) 2154 wpa_supplicant_req_scan(wpa_s, 0, disconnected ? 100000 : 0); 2155 2156 if (ssid) 2157 wpas_notify_network_selected(wpa_s, ssid); 2158} 2159 2160 2161/** 2162 * wpas_set_pkcs11_engine_and_module_path - Set PKCS #11 engine and module path 2163 * @wpa_s: wpa_supplicant structure for a network interface 2164 * @pkcs11_engine_path: PKCS #11 engine path or NULL 2165 * @pkcs11_module_path: PKCS #11 module path or NULL 2166 * Returns: 0 on success; -1 on failure 2167 * 2168 * Sets the PKCS #11 engine and module path. Both have to be NULL or a valid 2169 * path. If resetting the EAPOL state machine with the new PKCS #11 engine and 2170 * module path fails the paths will be reset to the default value (NULL). 2171 */ 2172int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s, 2173 const char *pkcs11_engine_path, 2174 const char *pkcs11_module_path) 2175{ 2176 char *pkcs11_engine_path_copy = NULL; 2177 char *pkcs11_module_path_copy = NULL; 2178 2179 if (pkcs11_engine_path != NULL) { 2180 pkcs11_engine_path_copy = os_strdup(pkcs11_engine_path); 2181 if (pkcs11_engine_path_copy == NULL) 2182 return -1; 2183 } 2184 if (pkcs11_module_path != NULL) { 2185 pkcs11_module_path_copy = os_strdup(pkcs11_module_path); 2186 if (pkcs11_module_path_copy == NULL) { 2187 os_free(pkcs11_engine_path_copy); 2188 return -1; 2189 } 2190 } 2191 2192 os_free(wpa_s->conf->pkcs11_engine_path); 2193 os_free(wpa_s->conf->pkcs11_module_path); 2194 wpa_s->conf->pkcs11_engine_path = pkcs11_engine_path_copy; 2195 wpa_s->conf->pkcs11_module_path = pkcs11_module_path_copy; 2196 2197 wpa_sm_set_eapol(wpa_s->wpa, NULL); 2198 eapol_sm_deinit(wpa_s->eapol); 2199 wpa_s->eapol = NULL; 2200 if (wpa_supplicant_init_eapol(wpa_s)) { 2201 /* Error -> Reset paths to the default value (NULL) once. */ 2202 if (pkcs11_engine_path != NULL && pkcs11_module_path != NULL) 2203 wpas_set_pkcs11_engine_and_module_path(wpa_s, NULL, 2204 NULL); 2205 2206 return -1; 2207 } 2208 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol); 2209 2210 return 0; 2211} 2212 2213 2214/** 2215 * wpa_supplicant_set_ap_scan - Set AP scan mode for interface 2216 * @wpa_s: wpa_supplicant structure for a network interface 2217 * @ap_scan: AP scan mode 2218 * Returns: 0 if succeed or -1 if ap_scan has an invalid value 2219 * 2220 */ 2221int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan) 2222{ 2223 2224 int old_ap_scan; 2225 2226 if (ap_scan < 0 || ap_scan > 2) 2227 return -1; 2228 2229#ifdef ANDROID 2230 if (ap_scan == 2 && ap_scan != wpa_s->conf->ap_scan && 2231 wpa_s->wpa_state >= WPA_ASSOCIATING && 2232 wpa_s->wpa_state < WPA_COMPLETED) { 2233 wpa_printf(MSG_ERROR, "ap_scan = %d (%d) rejected while " 2234 "associating", wpa_s->conf->ap_scan, ap_scan); 2235 return 0; 2236 } 2237#endif /* ANDROID */ 2238 2239 old_ap_scan = wpa_s->conf->ap_scan; 2240 wpa_s->conf->ap_scan = ap_scan; 2241 2242 if (old_ap_scan != wpa_s->conf->ap_scan) 2243 wpas_notify_ap_scan_changed(wpa_s); 2244 2245 return 0; 2246} 2247 2248 2249/** 2250 * wpa_supplicant_set_bss_expiration_age - Set BSS entry expiration age 2251 * @wpa_s: wpa_supplicant structure for a network interface 2252 * @expire_age: Expiration age in seconds 2253 * Returns: 0 if succeed or -1 if expire_age has an invalid value 2254 * 2255 */ 2256int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s, 2257 unsigned int bss_expire_age) 2258{ 2259 if (bss_expire_age < 10) { 2260 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration age %u", 2261 bss_expire_age); 2262 return -1; 2263 } 2264 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration age: %d sec", 2265 bss_expire_age); 2266 wpa_s->conf->bss_expiration_age = bss_expire_age; 2267 2268 return 0; 2269} 2270 2271 2272/** 2273 * wpa_supplicant_set_bss_expiration_count - Set BSS entry expiration scan count 2274 * @wpa_s: wpa_supplicant structure for a network interface 2275 * @expire_count: number of scans after which an unseen BSS is reclaimed 2276 * Returns: 0 if succeed or -1 if expire_count has an invalid value 2277 * 2278 */ 2279int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s, 2280 unsigned int bss_expire_count) 2281{ 2282 if (bss_expire_count < 1) { 2283 wpa_msg(wpa_s, MSG_ERROR, "Invalid bss expiration count %u", 2284 bss_expire_count); 2285 return -1; 2286 } 2287 wpa_msg(wpa_s, MSG_DEBUG, "Setting bss expiration scan count: %u", 2288 bss_expire_count); 2289 wpa_s->conf->bss_expiration_scan_count = bss_expire_count; 2290 2291 return 0; 2292} 2293 2294 2295/** 2296 * wpa_supplicant_set_scan_interval - Set scan interval 2297 * @wpa_s: wpa_supplicant structure for a network interface 2298 * @scan_interval: scan interval in seconds 2299 * Returns: 0 if succeed or -1 if scan_interval has an invalid value 2300 * 2301 */ 2302int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s, 2303 int scan_interval) 2304{ 2305 if (scan_interval < 0) { 2306 wpa_msg(wpa_s, MSG_ERROR, "Invalid scan interval %d", 2307 scan_interval); 2308 return -1; 2309 } 2310 wpa_msg(wpa_s, MSG_DEBUG, "Setting scan interval: %d sec", 2311 scan_interval); 2312 wpa_supplicant_update_scan_int(wpa_s, scan_interval); 2313 2314 return 0; 2315} 2316 2317 2318/** 2319 * wpa_supplicant_set_debug_params - Set global debug params 2320 * @global: wpa_global structure 2321 * @debug_level: debug level 2322 * @debug_timestamp: determines if show timestamp in debug data 2323 * @debug_show_keys: determines if show keys in debug data 2324 * Returns: 0 if succeed or -1 if debug_level has wrong value 2325 */ 2326int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level, 2327 int debug_timestamp, int debug_show_keys) 2328{ 2329 2330 int old_level, old_timestamp, old_show_keys; 2331 2332 /* check for allowed debuglevels */ 2333 if (debug_level != MSG_EXCESSIVE && 2334 debug_level != MSG_MSGDUMP && 2335 debug_level != MSG_DEBUG && 2336 debug_level != MSG_INFO && 2337 debug_level != MSG_WARNING && 2338 debug_level != MSG_ERROR) 2339 return -1; 2340 2341 old_level = wpa_debug_level; 2342 old_timestamp = wpa_debug_timestamp; 2343 old_show_keys = wpa_debug_show_keys; 2344 2345 wpa_debug_level = debug_level; 2346 wpa_debug_timestamp = debug_timestamp ? 1 : 0; 2347 wpa_debug_show_keys = debug_show_keys ? 1 : 0; 2348 2349 if (wpa_debug_level != old_level) 2350 wpas_notify_debug_level_changed(global); 2351 if (wpa_debug_timestamp != old_timestamp) 2352 wpas_notify_debug_timestamp_changed(global); 2353 if (wpa_debug_show_keys != old_show_keys) 2354 wpas_notify_debug_show_keys_changed(global); 2355 2356 return 0; 2357} 2358 2359 2360/** 2361 * wpa_supplicant_get_ssid - Get a pointer to the current network structure 2362 * @wpa_s: Pointer to wpa_supplicant data 2363 * Returns: A pointer to the current network structure or %NULL on failure 2364 */ 2365struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s) 2366{ 2367 struct wpa_ssid *entry; 2368 u8 ssid[MAX_SSID_LEN]; 2369 int res; 2370 size_t ssid_len; 2371 u8 bssid[ETH_ALEN]; 2372 int wired; 2373 2374 res = wpa_drv_get_ssid(wpa_s, ssid); 2375 if (res < 0) { 2376 wpa_msg(wpa_s, MSG_WARNING, "Could not read SSID from " 2377 "driver"); 2378 return NULL; 2379 } 2380 ssid_len = res; 2381 2382 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) { 2383 wpa_msg(wpa_s, MSG_WARNING, "Could not read BSSID from " 2384 "driver"); 2385 return NULL; 2386 } 2387 2388 wired = wpa_s->conf->ap_scan == 0 && 2389 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_WIRED); 2390 2391 entry = wpa_s->conf->ssid; 2392 while (entry) { 2393 if (!wpas_network_disabled(wpa_s, entry) && 2394 ((ssid_len == entry->ssid_len && 2395 os_memcmp(ssid, entry->ssid, ssid_len) == 0) || wired) && 2396 (!entry->bssid_set || 2397 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)) 2398 return entry; 2399#ifdef CONFIG_WPS 2400 if (!wpas_network_disabled(wpa_s, entry) && 2401 (entry->key_mgmt & WPA_KEY_MGMT_WPS) && 2402 (entry->ssid == NULL || entry->ssid_len == 0) && 2403 (!entry->bssid_set || 2404 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0)) 2405 return entry; 2406#endif /* CONFIG_WPS */ 2407 2408 if (!wpas_network_disabled(wpa_s, entry) && entry->bssid_set && 2409 entry->ssid_len == 0 && 2410 os_memcmp(bssid, entry->bssid, ETH_ALEN) == 0) 2411 return entry; 2412 2413 entry = entry->next; 2414 } 2415 2416 return NULL; 2417} 2418 2419 2420static int select_driver(struct wpa_supplicant *wpa_s, int i) 2421{ 2422 struct wpa_global *global = wpa_s->global; 2423 2424 if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) { 2425 global->drv_priv[i] = wpa_drivers[i]->global_init(); 2426 if (global->drv_priv[i] == NULL) { 2427 wpa_printf(MSG_ERROR, "Failed to initialize driver " 2428 "'%s'", wpa_drivers[i]->name); 2429 return -1; 2430 } 2431 } 2432 2433 wpa_s->driver = wpa_drivers[i]; 2434 wpa_s->global_drv_priv = global->drv_priv[i]; 2435 2436 return 0; 2437} 2438 2439 2440static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s, 2441 const char *name) 2442{ 2443 int i; 2444 size_t len; 2445 const char *pos, *driver = name; 2446 2447 if (wpa_s == NULL) 2448 return -1; 2449 2450 if (wpa_drivers[0] == NULL) { 2451 wpa_msg(wpa_s, MSG_ERROR, "No driver interfaces build into " 2452 "wpa_supplicant"); 2453 return -1; 2454 } 2455 2456 if (name == NULL) { 2457 /* default to first driver in the list */ 2458 return select_driver(wpa_s, 0); 2459 } 2460 2461 do { 2462 pos = os_strchr(driver, ','); 2463 if (pos) 2464 len = pos - driver; 2465 else 2466 len = os_strlen(driver); 2467 2468 for (i = 0; wpa_drivers[i]; i++) { 2469 if (os_strlen(wpa_drivers[i]->name) == len && 2470 os_strncmp(driver, wpa_drivers[i]->name, len) == 2471 0) { 2472 /* First driver that succeeds wins */ 2473 if (select_driver(wpa_s, i) == 0) 2474 return 0; 2475 } 2476 } 2477 2478 driver = pos + 1; 2479 } while (pos); 2480 2481 wpa_msg(wpa_s, MSG_ERROR, "Unsupported driver '%s'", name); 2482 return -1; 2483} 2484 2485 2486/** 2487 * wpa_supplicant_rx_eapol - Deliver a received EAPOL frame to wpa_supplicant 2488 * @ctx: Context pointer (wpa_s); this is the ctx variable registered 2489 * with struct wpa_driver_ops::init() 2490 * @src_addr: Source address of the EAPOL frame 2491 * @buf: EAPOL data starting from the EAPOL header (i.e., no Ethernet header) 2492 * @len: Length of the EAPOL data 2493 * 2494 * This function is called for each received EAPOL frame. Most driver 2495 * interfaces rely on more generic OS mechanism for receiving frames through 2496 * l2_packet, but if such a mechanism is not available, the driver wrapper may 2497 * take care of received EAPOL frames and deliver them to the core supplicant 2498 * code by calling this function. 2499 */ 2500void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr, 2501 const u8 *buf, size_t len) 2502{ 2503 struct wpa_supplicant *wpa_s = ctx; 2504 2505 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR, MAC2STR(src_addr)); 2506 wpa_hexdump(MSG_MSGDUMP, "RX EAPOL", buf, len); 2507 2508#ifdef CONFIG_PEERKEY 2509 if (wpa_s->wpa_state > WPA_ASSOCIATED && wpa_s->current_ssid && 2510 wpa_s->current_ssid->peerkey && 2511 !(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) && 2512 wpa_sm_rx_eapol_peerkey(wpa_s->wpa, src_addr, buf, len) == 1) { 2513 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: Processed PeerKey EAPOL-Key"); 2514 return; 2515 } 2516#endif /* CONFIG_PEERKEY */ 2517 2518 if (wpa_s->wpa_state < WPA_ASSOCIATED || 2519 (wpa_s->last_eapol_matches_bssid && 2520#ifdef CONFIG_AP 2521 !wpa_s->ap_iface && 2522#endif /* CONFIG_AP */ 2523 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) != 0)) { 2524 /* 2525 * There is possible race condition between receiving the 2526 * association event and the EAPOL frame since they are coming 2527 * through different paths from the driver. In order to avoid 2528 * issues in trying to process the EAPOL frame before receiving 2529 * association information, lets queue it for processing until 2530 * the association event is received. This may also be needed in 2531 * driver-based roaming case, so also use src_addr != BSSID as a 2532 * trigger if we have previously confirmed that the 2533 * Authenticator uses BSSID as the src_addr (which is not the 2534 * case with wired IEEE 802.1X). 2535 */ 2536 wpa_dbg(wpa_s, MSG_DEBUG, "Not associated - Delay processing " 2537 "of received EAPOL frame (state=%s bssid=" MACSTR ")", 2538 wpa_supplicant_state_txt(wpa_s->wpa_state), 2539 MAC2STR(wpa_s->bssid)); 2540 wpabuf_free(wpa_s->pending_eapol_rx); 2541 wpa_s->pending_eapol_rx = wpabuf_alloc_copy(buf, len); 2542 if (wpa_s->pending_eapol_rx) { 2543 os_get_reltime(&wpa_s->pending_eapol_rx_time); 2544 os_memcpy(wpa_s->pending_eapol_rx_src, src_addr, 2545 ETH_ALEN); 2546 } 2547 return; 2548 } 2549 2550 wpa_s->last_eapol_matches_bssid = 2551 os_memcmp(src_addr, wpa_s->bssid, ETH_ALEN) == 0; 2552 2553#ifdef CONFIG_AP 2554 if (wpa_s->ap_iface) { 2555 wpa_supplicant_ap_rx_eapol(wpa_s, src_addr, buf, len); 2556 return; 2557 } 2558#endif /* CONFIG_AP */ 2559 2560 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) { 2561 wpa_dbg(wpa_s, MSG_DEBUG, "Ignored received EAPOL frame since " 2562 "no key management is configured"); 2563 return; 2564 } 2565 2566 if (wpa_s->eapol_received == 0 && 2567 (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) || 2568 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || 2569 wpa_s->wpa_state != WPA_COMPLETED) && 2570 (wpa_s->current_ssid == NULL || 2571 wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) { 2572 /* Timeout for completing IEEE 802.1X and WPA authentication */ 2573 wpa_supplicant_req_auth_timeout( 2574 wpa_s, 2575 (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) || 2576 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA || 2577 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS) ? 2578 70 : 10, 0); 2579 } 2580 wpa_s->eapol_received++; 2581 2582 if (wpa_s->countermeasures) { 2583 wpa_msg(wpa_s, MSG_INFO, "WPA: Countermeasures - dropped " 2584 "EAPOL packet"); 2585 return; 2586 } 2587 2588#ifdef CONFIG_IBSS_RSN 2589 if (wpa_s->current_ssid && 2590 wpa_s->current_ssid->mode == WPAS_MODE_IBSS) { 2591 ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len); 2592 return; 2593 } 2594#endif /* CONFIG_IBSS_RSN */ 2595 2596 /* Source address of the incoming EAPOL frame could be compared to the 2597 * current BSSID. However, it is possible that a centralized 2598 * Authenticator could be using another MAC address than the BSSID of 2599 * an AP, so just allow any address to be used for now. The replies are 2600 * still sent to the current BSSID (if available), though. */ 2601 2602 os_memcpy(wpa_s->last_eapol_src, src_addr, ETH_ALEN); 2603 if (!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) && 2604 eapol_sm_rx_eapol(wpa_s->eapol, src_addr, buf, len) > 0) 2605 return; 2606 wpa_drv_poll(wpa_s); 2607 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE)) 2608 wpa_sm_rx_eapol(wpa_s->wpa, src_addr, buf, len); 2609 else if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) { 2610 /* 2611 * Set portValid = TRUE here since we are going to skip 4-way 2612 * handshake processing which would normally set portValid. We 2613 * need this to allow the EAPOL state machines to be completed 2614 * without going through EAPOL-Key handshake. 2615 */ 2616 eapol_sm_notify_portValid(wpa_s->eapol, TRUE); 2617 } 2618} 2619 2620 2621int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s) 2622{ 2623 if (wpa_s->driver->send_eapol) { 2624 const u8 *addr = wpa_drv_get_mac_addr(wpa_s); 2625 if (addr) 2626 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN); 2627 } else if ((!wpa_s->p2p_mgmt || 2628 !(wpa_s->drv_flags & 2629 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) && 2630 !(wpa_s->drv_flags & 2631 WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)) { 2632 l2_packet_deinit(wpa_s->l2); 2633 wpa_s->l2 = l2_packet_init(wpa_s->ifname, 2634 wpa_drv_get_mac_addr(wpa_s), 2635 ETH_P_EAPOL, 2636 wpa_supplicant_rx_eapol, wpa_s, 0); 2637 if (wpa_s->l2 == NULL) 2638 return -1; 2639 } else { 2640 const u8 *addr = wpa_drv_get_mac_addr(wpa_s); 2641 if (addr) 2642 os_memcpy(wpa_s->own_addr, addr, ETH_ALEN); 2643 } 2644 2645 if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) { 2646 wpa_msg(wpa_s, MSG_ERROR, "Failed to get own L2 address"); 2647 return -1; 2648 } 2649 2650 return 0; 2651} 2652 2653 2654static void wpa_supplicant_rx_eapol_bridge(void *ctx, const u8 *src_addr, 2655 const u8 *buf, size_t len) 2656{ 2657 struct wpa_supplicant *wpa_s = ctx; 2658 const struct l2_ethhdr *eth; 2659 2660 if (len < sizeof(*eth)) 2661 return; 2662 eth = (const struct l2_ethhdr *) buf; 2663 2664 if (os_memcmp(eth->h_dest, wpa_s->own_addr, ETH_ALEN) != 0 && 2665 !(eth->h_dest[0] & 0x01)) { 2666 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR 2667 " (bridge - not for this interface - ignore)", 2668 MAC2STR(src_addr), MAC2STR(eth->h_dest)); 2669 return; 2670 } 2671 2672 wpa_dbg(wpa_s, MSG_DEBUG, "RX EAPOL from " MACSTR " to " MACSTR 2673 " (bridge)", MAC2STR(src_addr), MAC2STR(eth->h_dest)); 2674 wpa_supplicant_rx_eapol(wpa_s, src_addr, buf + sizeof(*eth), 2675 len - sizeof(*eth)); 2676} 2677 2678 2679/** 2680 * wpa_supplicant_driver_init - Initialize driver interface parameters 2681 * @wpa_s: Pointer to wpa_supplicant data 2682 * Returns: 0 on success, -1 on failure 2683 * 2684 * This function is called to initialize driver interface parameters. 2685 * wpa_drv_init() must have been called before this function to initialize the 2686 * driver interface. 2687 */ 2688int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s) 2689{ 2690 static int interface_count = 0; 2691 2692 if (wpa_supplicant_update_mac_addr(wpa_s) < 0) 2693 return -1; 2694 2695 wpa_dbg(wpa_s, MSG_DEBUG, "Own MAC address: " MACSTR, 2696 MAC2STR(wpa_s->own_addr)); 2697 wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr); 2698 2699 if (wpa_s->bridge_ifname[0]) { 2700 wpa_dbg(wpa_s, MSG_DEBUG, "Receiving packets from bridge " 2701 "interface '%s'", wpa_s->bridge_ifname); 2702 wpa_s->l2_br = l2_packet_init(wpa_s->bridge_ifname, 2703 wpa_s->own_addr, 2704 ETH_P_EAPOL, 2705 wpa_supplicant_rx_eapol_bridge, 2706 wpa_s, 1); 2707 if (wpa_s->l2_br == NULL) { 2708 wpa_msg(wpa_s, MSG_ERROR, "Failed to open l2_packet " 2709 "connection for the bridge interface '%s'", 2710 wpa_s->bridge_ifname); 2711 return -1; 2712 } 2713 } 2714 2715 wpa_clear_keys(wpa_s, NULL); 2716 2717 /* Make sure that TKIP countermeasures are not left enabled (could 2718 * happen if wpa_supplicant is killed during countermeasures. */ 2719 wpa_drv_set_countermeasures(wpa_s, 0); 2720 2721 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: flushing PMKID list in the driver"); 2722 wpa_drv_flush_pmkid(wpa_s); 2723 2724 wpa_s->prev_scan_ssid = WILDCARD_SSID_SCAN; 2725 wpa_s->prev_scan_wildcard = 0; 2726 2727 if (wpa_supplicant_enabled_networks(wpa_s)) { 2728 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { 2729 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 2730 interface_count = 0; 2731 } 2732 if (!wpa_s->p2p_mgmt && 2733 wpa_supplicant_delayed_sched_scan(wpa_s, 2734 interface_count % 3, 2735 100000)) 2736 wpa_supplicant_req_scan(wpa_s, interface_count % 3, 2737 100000); 2738 interface_count++; 2739 } else 2740 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE); 2741 2742 return 0; 2743} 2744 2745 2746static int wpa_supplicant_daemon(const char *pid_file) 2747{ 2748 wpa_printf(MSG_DEBUG, "Daemonize.."); 2749 return os_daemonize(pid_file); 2750} 2751 2752 2753static struct wpa_supplicant * wpa_supplicant_alloc(void) 2754{ 2755 struct wpa_supplicant *wpa_s; 2756 2757 wpa_s = os_zalloc(sizeof(*wpa_s)); 2758 if (wpa_s == NULL) 2759 return NULL; 2760 wpa_s->scan_req = INITIAL_SCAN_REQ; 2761 wpa_s->scan_interval = 5; 2762 wpa_s->new_connection = 1; 2763 wpa_s->parent = wpa_s; 2764 wpa_s->sched_scanning = 0; 2765 2766 return wpa_s; 2767} 2768 2769 2770#ifdef CONFIG_HT_OVERRIDES 2771 2772static int wpa_set_htcap_mcs(struct wpa_supplicant *wpa_s, 2773 struct ieee80211_ht_capabilities *htcaps, 2774 struct ieee80211_ht_capabilities *htcaps_mask, 2775 const char *ht_mcs) 2776{ 2777 /* parse ht_mcs into hex array */ 2778 int i; 2779 const char *tmp = ht_mcs; 2780 char *end = NULL; 2781 2782 /* If ht_mcs is null, do not set anything */ 2783 if (!ht_mcs) 2784 return 0; 2785 2786 /* This is what we are setting in the kernel */ 2787 os_memset(&htcaps->supported_mcs_set, 0, IEEE80211_HT_MCS_MASK_LEN); 2788 2789 wpa_msg(wpa_s, MSG_DEBUG, "set_htcap, ht_mcs -:%s:-", ht_mcs); 2790 2791 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 2792 errno = 0; 2793 long v = strtol(tmp, &end, 16); 2794 if (errno == 0) { 2795 wpa_msg(wpa_s, MSG_DEBUG, 2796 "htcap value[%i]: %ld end: %p tmp: %p", 2797 i, v, end, tmp); 2798 if (end == tmp) 2799 break; 2800 2801 htcaps->supported_mcs_set[i] = v; 2802 tmp = end; 2803 } else { 2804 wpa_msg(wpa_s, MSG_ERROR, 2805 "Failed to parse ht-mcs: %s, error: %s\n", 2806 ht_mcs, strerror(errno)); 2807 return -1; 2808 } 2809 } 2810 2811 /* 2812 * If we were able to parse any values, then set mask for the MCS set. 2813 */ 2814 if (i) { 2815 os_memset(&htcaps_mask->supported_mcs_set, 0xff, 2816 IEEE80211_HT_MCS_MASK_LEN - 1); 2817 /* skip the 3 reserved bits */ 2818 htcaps_mask->supported_mcs_set[IEEE80211_HT_MCS_MASK_LEN - 1] = 2819 0x1f; 2820 } 2821 2822 return 0; 2823} 2824 2825 2826static int wpa_disable_max_amsdu(struct wpa_supplicant *wpa_s, 2827 struct ieee80211_ht_capabilities *htcaps, 2828 struct ieee80211_ht_capabilities *htcaps_mask, 2829 int disabled) 2830{ 2831 u16 msk; 2832 2833 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_max_amsdu: %d", disabled); 2834 2835 if (disabled == -1) 2836 return 0; 2837 2838 msk = host_to_le16(HT_CAP_INFO_MAX_AMSDU_SIZE); 2839 htcaps_mask->ht_capabilities_info |= msk; 2840 if (disabled) 2841 htcaps->ht_capabilities_info &= msk; 2842 else 2843 htcaps->ht_capabilities_info |= msk; 2844 2845 return 0; 2846} 2847 2848 2849static int wpa_set_ampdu_factor(struct wpa_supplicant *wpa_s, 2850 struct ieee80211_ht_capabilities *htcaps, 2851 struct ieee80211_ht_capabilities *htcaps_mask, 2852 int factor) 2853{ 2854 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_factor: %d", factor); 2855 2856 if (factor == -1) 2857 return 0; 2858 2859 if (factor < 0 || factor > 3) { 2860 wpa_msg(wpa_s, MSG_ERROR, "ampdu_factor: %d out of range. " 2861 "Must be 0-3 or -1", factor); 2862 return -EINVAL; 2863 } 2864 2865 htcaps_mask->a_mpdu_params |= 0x3; /* 2 bits for factor */ 2866 htcaps->a_mpdu_params &= ~0x3; 2867 htcaps->a_mpdu_params |= factor & 0x3; 2868 2869 return 0; 2870} 2871 2872 2873static int wpa_set_ampdu_density(struct wpa_supplicant *wpa_s, 2874 struct ieee80211_ht_capabilities *htcaps, 2875 struct ieee80211_ht_capabilities *htcaps_mask, 2876 int density) 2877{ 2878 wpa_msg(wpa_s, MSG_DEBUG, "set_ampdu_density: %d", density); 2879 2880 if (density == -1) 2881 return 0; 2882 2883 if (density < 0 || density > 7) { 2884 wpa_msg(wpa_s, MSG_ERROR, 2885 "ampdu_density: %d out of range. Must be 0-7 or -1.", 2886 density); 2887 return -EINVAL; 2888 } 2889 2890 htcaps_mask->a_mpdu_params |= 0x1C; 2891 htcaps->a_mpdu_params &= ~(0x1C); 2892 htcaps->a_mpdu_params |= (density << 2) & 0x1C; 2893 2894 return 0; 2895} 2896 2897 2898static int wpa_set_disable_ht40(struct wpa_supplicant *wpa_s, 2899 struct ieee80211_ht_capabilities *htcaps, 2900 struct ieee80211_ht_capabilities *htcaps_mask, 2901 int disabled) 2902{ 2903 /* Masking these out disables HT40 */ 2904 u16 msk = host_to_le16(HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET | 2905 HT_CAP_INFO_SHORT_GI40MHZ); 2906 2907 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ht40: %d", disabled); 2908 2909 if (disabled) 2910 htcaps->ht_capabilities_info &= ~msk; 2911 else 2912 htcaps->ht_capabilities_info |= msk; 2913 2914 htcaps_mask->ht_capabilities_info |= msk; 2915 2916 return 0; 2917} 2918 2919 2920static int wpa_set_disable_sgi(struct wpa_supplicant *wpa_s, 2921 struct ieee80211_ht_capabilities *htcaps, 2922 struct ieee80211_ht_capabilities *htcaps_mask, 2923 int disabled) 2924{ 2925 /* Masking these out disables SGI */ 2926 u16 msk = host_to_le16(HT_CAP_INFO_SHORT_GI20MHZ | 2927 HT_CAP_INFO_SHORT_GI40MHZ); 2928 2929 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_sgi: %d", disabled); 2930 2931 if (disabled) 2932 htcaps->ht_capabilities_info &= ~msk; 2933 else 2934 htcaps->ht_capabilities_info |= msk; 2935 2936 htcaps_mask->ht_capabilities_info |= msk; 2937 2938 return 0; 2939} 2940 2941 2942static int wpa_set_disable_ldpc(struct wpa_supplicant *wpa_s, 2943 struct ieee80211_ht_capabilities *htcaps, 2944 struct ieee80211_ht_capabilities *htcaps_mask, 2945 int disabled) 2946{ 2947 /* Masking these out disables LDPC */ 2948 u16 msk = host_to_le16(HT_CAP_INFO_LDPC_CODING_CAP); 2949 2950 wpa_msg(wpa_s, MSG_DEBUG, "set_disable_ldpc: %d", disabled); 2951 2952 if (disabled) 2953 htcaps->ht_capabilities_info &= ~msk; 2954 else 2955 htcaps->ht_capabilities_info |= msk; 2956 2957 htcaps_mask->ht_capabilities_info |= msk; 2958 2959 return 0; 2960} 2961 2962 2963void wpa_supplicant_apply_ht_overrides( 2964 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 2965 struct wpa_driver_associate_params *params) 2966{ 2967 struct ieee80211_ht_capabilities *htcaps; 2968 struct ieee80211_ht_capabilities *htcaps_mask; 2969 2970 if (!ssid) 2971 return; 2972 2973 params->disable_ht = ssid->disable_ht; 2974 if (!params->htcaps || !params->htcaps_mask) 2975 return; 2976 2977 htcaps = (struct ieee80211_ht_capabilities *) params->htcaps; 2978 htcaps_mask = (struct ieee80211_ht_capabilities *) params->htcaps_mask; 2979 wpa_set_htcap_mcs(wpa_s, htcaps, htcaps_mask, ssid->ht_mcs); 2980 wpa_disable_max_amsdu(wpa_s, htcaps, htcaps_mask, 2981 ssid->disable_max_amsdu); 2982 wpa_set_ampdu_factor(wpa_s, htcaps, htcaps_mask, ssid->ampdu_factor); 2983 wpa_set_ampdu_density(wpa_s, htcaps, htcaps_mask, ssid->ampdu_density); 2984 wpa_set_disable_ht40(wpa_s, htcaps, htcaps_mask, ssid->disable_ht40); 2985 wpa_set_disable_sgi(wpa_s, htcaps, htcaps_mask, ssid->disable_sgi); 2986 wpa_set_disable_ldpc(wpa_s, htcaps, htcaps_mask, ssid->disable_ldpc); 2987 2988 if (ssid->ht40_intolerant) { 2989 u16 bit = host_to_le16(HT_CAP_INFO_40MHZ_INTOLERANT); 2990 htcaps->ht_capabilities_info |= bit; 2991 htcaps_mask->ht_capabilities_info |= bit; 2992 } 2993} 2994 2995#endif /* CONFIG_HT_OVERRIDES */ 2996 2997 2998#ifdef CONFIG_VHT_OVERRIDES 2999void wpa_supplicant_apply_vht_overrides( 3000 struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, 3001 struct wpa_driver_associate_params *params) 3002{ 3003 struct ieee80211_vht_capabilities *vhtcaps; 3004 struct ieee80211_vht_capabilities *vhtcaps_mask; 3005#ifdef CONFIG_HT_OVERRIDES 3006 int max_ampdu; 3007 const u32 max_ampdu_mask = VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MAX; 3008#endif /* CONFIG_HT_OVERRIDES */ 3009 3010 if (!ssid) 3011 return; 3012 3013 params->disable_vht = ssid->disable_vht; 3014 3015 vhtcaps = (void *) params->vhtcaps; 3016 vhtcaps_mask = (void *) params->vhtcaps_mask; 3017 3018 if (!vhtcaps || !vhtcaps_mask) 3019 return; 3020 3021 vhtcaps->vht_capabilities_info = ssid->vht_capa; 3022 vhtcaps_mask->vht_capabilities_info = ssid->vht_capa_mask; 3023 3024#ifdef CONFIG_HT_OVERRIDES 3025 /* if max ampdu is <= 3, we have to make the HT cap the same */ 3026 if (ssid->vht_capa_mask & max_ampdu_mask) { 3027 max_ampdu = (ssid->vht_capa & max_ampdu_mask) >> 3028 find_first_bit(max_ampdu_mask); 3029 3030 max_ampdu = max_ampdu < 3 ? max_ampdu : 3; 3031 wpa_set_ampdu_factor(wpa_s, 3032 (void *) params->htcaps, 3033 (void *) params->htcaps_mask, 3034 max_ampdu); 3035 } 3036#endif /* CONFIG_HT_OVERRIDES */ 3037 3038#define OVERRIDE_MCS(i) \ 3039 if (ssid->vht_tx_mcs_nss_ ##i >= 0) { \ 3040 vhtcaps_mask->vht_supported_mcs_set.tx_map |= \ 3041 3 << 2 * (i - 1); \ 3042 vhtcaps->vht_supported_mcs_set.tx_map |= \ 3043 ssid->vht_tx_mcs_nss_ ##i << 2 * (i - 1); \ 3044 } \ 3045 if (ssid->vht_rx_mcs_nss_ ##i >= 0) { \ 3046 vhtcaps_mask->vht_supported_mcs_set.rx_map |= \ 3047 3 << 2 * (i - 1); \ 3048 vhtcaps->vht_supported_mcs_set.rx_map |= \ 3049 ssid->vht_rx_mcs_nss_ ##i << 2 * (i - 1); \ 3050 } 3051 3052 OVERRIDE_MCS(1); 3053 OVERRIDE_MCS(2); 3054 OVERRIDE_MCS(3); 3055 OVERRIDE_MCS(4); 3056 OVERRIDE_MCS(5); 3057 OVERRIDE_MCS(6); 3058 OVERRIDE_MCS(7); 3059 OVERRIDE_MCS(8); 3060} 3061#endif /* CONFIG_VHT_OVERRIDES */ 3062 3063 3064static int pcsc_reader_init(struct wpa_supplicant *wpa_s) 3065{ 3066#ifdef PCSC_FUNCS 3067 size_t len; 3068 3069 if (!wpa_s->conf->pcsc_reader) 3070 return 0; 3071 3072 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader); 3073 if (!wpa_s->scard) 3074 return 1; 3075 3076 if (wpa_s->conf->pcsc_pin && 3077 scard_set_pin(wpa_s->scard, wpa_s->conf->pcsc_pin) < 0) { 3078 scard_deinit(wpa_s->scard); 3079 wpa_s->scard = NULL; 3080 wpa_msg(wpa_s, MSG_ERROR, "PC/SC PIN validation failed"); 3081 return -1; 3082 } 3083 3084 len = sizeof(wpa_s->imsi) - 1; 3085 if (scard_get_imsi(wpa_s->scard, wpa_s->imsi, &len)) { 3086 scard_deinit(wpa_s->scard); 3087 wpa_s->scard = NULL; 3088 wpa_msg(wpa_s, MSG_ERROR, "Could not read IMSI"); 3089 return -1; 3090 } 3091 wpa_s->imsi[len] = '\0'; 3092 3093 wpa_s->mnc_len = scard_get_mnc_len(wpa_s->scard); 3094 3095 wpa_printf(MSG_DEBUG, "SCARD: IMSI %s (MNC length %d)", 3096 wpa_s->imsi, wpa_s->mnc_len); 3097 3098 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard); 3099 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard); 3100#endif /* PCSC_FUNCS */ 3101 3102 return 0; 3103} 3104 3105 3106int wpas_init_ext_pw(struct wpa_supplicant *wpa_s) 3107{ 3108 char *val, *pos; 3109 3110 ext_password_deinit(wpa_s->ext_pw); 3111 wpa_s->ext_pw = NULL; 3112 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, NULL); 3113 3114 if (!wpa_s->conf->ext_password_backend) 3115 return 0; 3116 3117 val = os_strdup(wpa_s->conf->ext_password_backend); 3118 if (val == NULL) 3119 return -1; 3120 pos = os_strchr(val, ':'); 3121 if (pos) 3122 *pos++ = '\0'; 3123 3124 wpa_printf(MSG_DEBUG, "EXT PW: Initialize backend '%s'", val); 3125 3126 wpa_s->ext_pw = ext_password_init(val, pos); 3127 os_free(val); 3128 if (wpa_s->ext_pw == NULL) { 3129 wpa_printf(MSG_DEBUG, "EXT PW: Failed to initialize backend"); 3130 return -1; 3131 } 3132 eapol_sm_set_ext_pw_ctx(wpa_s->eapol, wpa_s->ext_pw); 3133 3134 return 0; 3135} 3136 3137 3138static int wpas_check_wowlan_trigger(const char *start, const char *trigger, 3139 int capa_trigger, u8 *param_trigger) 3140{ 3141 if (os_strcmp(start, trigger) != 0) 3142 return 0; 3143 if (!capa_trigger) 3144 return 0; 3145 3146 *param_trigger = 1; 3147 return 1; 3148} 3149 3150 3151int wpas_set_wowlan_triggers(struct wpa_supplicant *wpa_s, 3152 struct wpa_driver_capa *capa) 3153{ 3154 struct wowlan_triggers triggers; 3155 char *start, *end, *buf; 3156 int last, ret; 3157 3158 if (!wpa_s->conf->wowlan_triggers) 3159 return 0; 3160 3161 buf = os_strdup(wpa_s->conf->wowlan_triggers); 3162 if (buf == NULL) 3163 return -1; 3164 3165 os_memset(&triggers, 0, sizeof(triggers)); 3166 3167#define CHECK_TRIGGER(trigger) \ 3168 wpas_check_wowlan_trigger(start, #trigger, \ 3169 capa->wowlan_triggers.trigger, \ 3170 &triggers.trigger) 3171 3172 start = buf; 3173 while (*start != '\0') { 3174 while (isblank(*start)) 3175 start++; 3176 if (*start == '\0') 3177 break; 3178 end = start; 3179 while (!isblank(*end) && *end != '\0') 3180 end++; 3181 last = *end == '\0'; 3182 *end = '\0'; 3183 3184 if (!CHECK_TRIGGER(any) && 3185 !CHECK_TRIGGER(disconnect) && 3186 !CHECK_TRIGGER(magic_pkt) && 3187 !CHECK_TRIGGER(gtk_rekey_failure) && 3188 !CHECK_TRIGGER(eap_identity_req) && 3189 !CHECK_TRIGGER(four_way_handshake) && 3190 !CHECK_TRIGGER(rfkill_release)) { 3191 wpa_printf(MSG_DEBUG, 3192 "Unknown/unsupported wowlan trigger '%s'", 3193 start); 3194 ret = -1; 3195 goto out; 3196 } 3197 3198 if (last) 3199 break; 3200 start = end + 1; 3201 } 3202#undef CHECK_TRIGGER 3203 3204 ret = wpa_drv_wowlan(wpa_s, &triggers); 3205out: 3206 os_free(buf); 3207 return ret; 3208} 3209 3210 3211static struct wpa_radio * radio_add_interface(struct wpa_supplicant *wpa_s, 3212 const char *rn) 3213{ 3214 struct wpa_supplicant *iface = wpa_s->global->ifaces; 3215 struct wpa_radio *radio; 3216 3217 while (rn && iface) { 3218 radio = iface->radio; 3219 if (radio && os_strcmp(rn, radio->name) == 0) { 3220 wpa_printf(MSG_DEBUG, "Add interface %s to existing radio %s", 3221 wpa_s->ifname, rn); 3222 dl_list_add(&radio->ifaces, &wpa_s->radio_list); 3223 return radio; 3224 } 3225 3226 iface = iface->next; 3227 } 3228 3229 wpa_printf(MSG_DEBUG, "Add interface %s to a new radio %s", 3230 wpa_s->ifname, rn ? rn : "N/A"); 3231 radio = os_zalloc(sizeof(*radio)); 3232 if (radio == NULL) 3233 return NULL; 3234 3235 if (rn) 3236 os_strlcpy(radio->name, rn, sizeof(radio->name)); 3237 dl_list_init(&radio->ifaces); 3238 dl_list_init(&radio->work); 3239 dl_list_add(&radio->ifaces, &wpa_s->radio_list); 3240 3241 return radio; 3242} 3243 3244 3245static void radio_work_free(struct wpa_radio_work *work) 3246{ 3247 if (work->wpa_s->scan_work == work) { 3248 /* This should not really happen. */ 3249 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as scan_work", 3250 work->type, work, work->started); 3251 work->wpa_s->scan_work = NULL; 3252 } 3253 3254#ifdef CONFIG_P2P 3255 if (work->wpa_s->p2p_scan_work == work) { 3256 /* This should not really happen. */ 3257 wpa_dbg(work->wpa_s, MSG_INFO, "Freeing radio work '%s'@%p (started=%d) that is marked as p2p_scan_work", 3258 work->type, work, work->started); 3259 work->wpa_s->p2p_scan_work = NULL; 3260 } 3261#endif /* CONFIG_P2P */ 3262 3263 dl_list_del(&work->list); 3264 os_free(work); 3265} 3266 3267 3268static void radio_start_next_work(void *eloop_ctx, void *timeout_ctx) 3269{ 3270 struct wpa_radio *radio = eloop_ctx; 3271 struct wpa_radio_work *work; 3272 struct os_reltime now, diff; 3273 struct wpa_supplicant *wpa_s; 3274 3275 work = dl_list_first(&radio->work, struct wpa_radio_work, list); 3276 if (work == NULL) 3277 return; 3278 3279 if (work->started) 3280 return; /* already started and still in progress */ 3281 3282 wpa_s = dl_list_first(&radio->ifaces, struct wpa_supplicant, 3283 radio_list); 3284 if (wpa_s && wpa_s->external_scan_running) { 3285 wpa_printf(MSG_DEBUG, "Delay radio work start until externally triggered scan completes"); 3286 return; 3287 } 3288 3289 os_get_reltime(&now); 3290 os_reltime_sub(&now, &work->time, &diff); 3291 wpa_dbg(work->wpa_s, MSG_DEBUG, "Starting radio work '%s'@%p after %ld.%06ld second wait", 3292 work->type, work, diff.sec, diff.usec); 3293 work->started = 1; 3294 work->time = now; 3295 work->cb(work, 0); 3296} 3297 3298 3299/* 3300 * This function removes both started and pending radio works running on 3301 * the provided interface's radio. 3302 * Prior to the removal of the radio work, its callback (cb) is called with 3303 * deinit set to be 1. Each work's callback is responsible for clearing its 3304 * internal data and restoring to a correct state. 3305 * @wpa_s: wpa_supplicant data 3306 * @type: type of works to be removed 3307 * @remove_all: 1 to remove all the works on this radio, 0 to remove only 3308 * this interface's works. 3309 */ 3310void radio_remove_works(struct wpa_supplicant *wpa_s, 3311 const char *type, int remove_all) 3312{ 3313 struct wpa_radio_work *work, *tmp; 3314 struct wpa_radio *radio = wpa_s->radio; 3315 3316 dl_list_for_each_safe(work, tmp, &radio->work, struct wpa_radio_work, 3317 list) { 3318 if (type && os_strcmp(type, work->type) != 0) 3319 continue; 3320 3321 /* skip other ifaces' works */ 3322 if (!remove_all && work->wpa_s != wpa_s) 3323 continue; 3324 3325 wpa_dbg(wpa_s, MSG_DEBUG, "Remove radio work '%s'@%p%s", 3326 work->type, work, work->started ? " (started)" : ""); 3327 work->cb(work, 1); 3328 radio_work_free(work); 3329 } 3330 3331 /* in case we removed the started work */ 3332 radio_work_check_next(wpa_s); 3333} 3334 3335 3336static void radio_remove_interface(struct wpa_supplicant *wpa_s) 3337{ 3338 struct wpa_radio *radio = wpa_s->radio; 3339 3340 if (!radio) 3341 return; 3342 3343 wpa_printf(MSG_DEBUG, "Remove interface %s from radio %s", 3344 wpa_s->ifname, radio->name); 3345 dl_list_del(&wpa_s->radio_list); 3346 radio_remove_works(wpa_s, NULL, 0); 3347 wpa_s->radio = NULL; 3348 if (!dl_list_empty(&radio->ifaces)) 3349 return; /* Interfaces remain for this radio */ 3350 3351 wpa_printf(MSG_DEBUG, "Remove radio %s", radio->name); 3352 eloop_cancel_timeout(radio_start_next_work, radio, NULL); 3353 os_free(radio); 3354} 3355 3356 3357void radio_work_check_next(struct wpa_supplicant *wpa_s) 3358{ 3359 struct wpa_radio *radio = wpa_s->radio; 3360 3361 if (dl_list_empty(&radio->work)) 3362 return; 3363 eloop_cancel_timeout(radio_start_next_work, radio, NULL); 3364 eloop_register_timeout(0, 0, radio_start_next_work, radio, NULL); 3365} 3366 3367 3368/** 3369 * radio_add_work - Add a radio work item 3370 * @wpa_s: Pointer to wpa_supplicant data 3371 * @freq: Frequency of the offchannel operation in MHz or 0 3372 * @type: Unique identifier for each type of work 3373 * @next: Force as the next work to be executed 3374 * @cb: Callback function for indicating when radio is available 3375 * @ctx: Context pointer for the work (work->ctx in cb()) 3376 * Returns: 0 on success, -1 on failure 3377 * 3378 * This function is used to request time for an operation that requires 3379 * exclusive radio control. Once the radio is available, the registered callback 3380 * function will be called. radio_work_done() must be called once the exclusive 3381 * radio operation has been completed, so that the radio is freed for other 3382 * operations. The special case of deinit=1 is used to free the context data 3383 * during interface removal. That does not allow the callback function to start 3384 * the radio operation, i.e., it must free any resources allocated for the radio 3385 * work and return. 3386 * 3387 * The @freq parameter can be used to indicate a single channel on which the 3388 * offchannel operation will occur. This may allow multiple radio work 3389 * operations to be performed in parallel if they apply for the same channel. 3390 * Setting this to 0 indicates that the work item may use multiple channels or 3391 * requires exclusive control of the radio. 3392 */ 3393int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq, 3394 const char *type, int next, 3395 void (*cb)(struct wpa_radio_work *work, int deinit), 3396 void *ctx) 3397{ 3398 struct wpa_radio_work *work; 3399 int was_empty; 3400 3401 work = os_zalloc(sizeof(*work)); 3402 if (work == NULL) 3403 return -1; 3404 wpa_dbg(wpa_s, MSG_DEBUG, "Add radio work '%s'@%p", type, work); 3405 os_get_reltime(&work->time); 3406 work->freq = freq; 3407 work->type = type; 3408 work->wpa_s = wpa_s; 3409 work->cb = cb; 3410 work->ctx = ctx; 3411 3412 was_empty = dl_list_empty(&wpa_s->radio->work); 3413 if (next) 3414 dl_list_add(&wpa_s->radio->work, &work->list); 3415 else 3416 dl_list_add_tail(&wpa_s->radio->work, &work->list); 3417 if (was_empty) { 3418 wpa_dbg(wpa_s, MSG_DEBUG, "First radio work item in the queue - schedule start immediately"); 3419 radio_work_check_next(wpa_s); 3420 } 3421 3422 return 0; 3423} 3424 3425 3426/** 3427 * radio_work_done - Indicate that a radio work item has been completed 3428 * @work: Completed work 3429 * 3430 * This function is called once the callback function registered with 3431 * radio_add_work() has completed its work. 3432 */ 3433void radio_work_done(struct wpa_radio_work *work) 3434{ 3435 struct wpa_supplicant *wpa_s = work->wpa_s; 3436 struct os_reltime now, diff; 3437 unsigned int started = work->started; 3438 3439 os_get_reltime(&now); 3440 os_reltime_sub(&now, &work->time, &diff); 3441 wpa_dbg(wpa_s, MSG_DEBUG, "Radio work '%s'@%p %s in %ld.%06ld seconds", 3442 work->type, work, started ? "done" : "canceled", 3443 diff.sec, diff.usec); 3444 radio_work_free(work); 3445 if (started) 3446 radio_work_check_next(wpa_s); 3447} 3448 3449 3450int radio_work_pending(struct wpa_supplicant *wpa_s, const char *type) 3451{ 3452 struct wpa_radio_work *work; 3453 struct wpa_radio *radio = wpa_s->radio; 3454 3455 dl_list_for_each(work, &radio->work, struct wpa_radio_work, list) { 3456 if (work->wpa_s == wpa_s && os_strcmp(work->type, type) == 0) 3457 return 1; 3458 } 3459 3460 return 0; 3461} 3462 3463 3464static int wpas_init_driver(struct wpa_supplicant *wpa_s, 3465 struct wpa_interface *iface) 3466{ 3467 const char *ifname, *driver, *rn; 3468 3469 driver = iface->driver; 3470next_driver: 3471 if (wpa_supplicant_set_driver(wpa_s, driver) < 0) 3472 return -1; 3473 3474 wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname); 3475 if (wpa_s->drv_priv == NULL) { 3476 const char *pos; 3477 pos = driver ? os_strchr(driver, ',') : NULL; 3478 if (pos) { 3479 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to initialize " 3480 "driver interface - try next driver wrapper"); 3481 driver = pos + 1; 3482 goto next_driver; 3483 } 3484 wpa_msg(wpa_s, MSG_ERROR, "Failed to initialize driver " 3485 "interface"); 3486 return -1; 3487 } 3488 if (wpa_drv_set_param(wpa_s, wpa_s->conf->driver_param) < 0) { 3489 wpa_msg(wpa_s, MSG_ERROR, "Driver interface rejected " 3490 "driver_param '%s'", wpa_s->conf->driver_param); 3491 return -1; 3492 } 3493 3494 ifname = wpa_drv_get_ifname(wpa_s); 3495 if (ifname && os_strcmp(ifname, wpa_s->ifname) != 0) { 3496 wpa_dbg(wpa_s, MSG_DEBUG, "Driver interface replaced " 3497 "interface name with '%s'", ifname); 3498 os_strlcpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname)); 3499 } 3500 3501 rn = wpa_driver_get_radio_name(wpa_s); 3502 if (rn && rn[0] == '\0') 3503 rn = NULL; 3504 3505 wpa_s->radio = radio_add_interface(wpa_s, rn); 3506 if (wpa_s->radio == NULL) 3507 return -1; 3508 3509 return 0; 3510} 3511 3512 3513static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s, 3514 struct wpa_interface *iface) 3515{ 3516 struct wpa_driver_capa capa; 3517 3518 wpa_printf(MSG_DEBUG, "Initializing interface '%s' conf '%s' driver " 3519 "'%s' ctrl_interface '%s' bridge '%s'", iface->ifname, 3520 iface->confname ? iface->confname : "N/A", 3521 iface->driver ? iface->driver : "default", 3522 iface->ctrl_interface ? iface->ctrl_interface : "N/A", 3523 iface->bridge_ifname ? iface->bridge_ifname : "N/A"); 3524 3525 if (iface->confname) { 3526#ifdef CONFIG_BACKEND_FILE 3527 wpa_s->confname = os_rel2abs_path(iface->confname); 3528 if (wpa_s->confname == NULL) { 3529 wpa_printf(MSG_ERROR, "Failed to get absolute path " 3530 "for configuration file '%s'.", 3531 iface->confname); 3532 return -1; 3533 } 3534 wpa_printf(MSG_DEBUG, "Configuration file '%s' -> '%s'", 3535 iface->confname, wpa_s->confname); 3536#else /* CONFIG_BACKEND_FILE */ 3537 wpa_s->confname = os_strdup(iface->confname); 3538#endif /* CONFIG_BACKEND_FILE */ 3539 wpa_s->conf = wpa_config_read(wpa_s->confname, NULL); 3540 if (wpa_s->conf == NULL) { 3541 wpa_printf(MSG_ERROR, "Failed to read or parse " 3542 "configuration '%s'.", wpa_s->confname); 3543 return -1; 3544 } 3545 wpa_s->confanother = os_rel2abs_path(iface->confanother); 3546 wpa_config_read(wpa_s->confanother, wpa_s->conf); 3547 3548#ifdef CONFIG_P2P 3549 wpa_s->conf_p2p_dev = os_rel2abs_path(iface->conf_p2p_dev); 3550 wpa_config_read(wpa_s->conf_p2p_dev, wpa_s->conf); 3551#endif /* CONFIG_P2P */ 3552 3553 /* 3554 * Override ctrl_interface and driver_param if set on command 3555 * line. 3556 */ 3557 if (iface->ctrl_interface) { 3558 os_free(wpa_s->conf->ctrl_interface); 3559 wpa_s->conf->ctrl_interface = 3560 os_strdup(iface->ctrl_interface); 3561 } 3562 3563 if (iface->driver_param) { 3564 os_free(wpa_s->conf->driver_param); 3565 wpa_s->conf->driver_param = 3566 os_strdup(iface->driver_param); 3567 } 3568 3569 if (iface->p2p_mgmt && !iface->ctrl_interface) { 3570 os_free(wpa_s->conf->ctrl_interface); 3571 wpa_s->conf->ctrl_interface = NULL; 3572 } 3573 } else 3574 wpa_s->conf = wpa_config_alloc_empty(iface->ctrl_interface, 3575 iface->driver_param); 3576 3577 if (wpa_s->conf == NULL) { 3578 wpa_printf(MSG_ERROR, "\nNo configuration found."); 3579 return -1; 3580 } 3581 3582 if (iface->ifname == NULL) { 3583 wpa_printf(MSG_ERROR, "\nInterface name is required."); 3584 return -1; 3585 } 3586 if (os_strlen(iface->ifname) >= sizeof(wpa_s->ifname)) { 3587 wpa_printf(MSG_ERROR, "\nToo long interface name '%s'.", 3588 iface->ifname); 3589 return -1; 3590 } 3591 os_strlcpy(wpa_s->ifname, iface->ifname, sizeof(wpa_s->ifname)); 3592 3593 if (iface->bridge_ifname) { 3594 if (os_strlen(iface->bridge_ifname) >= 3595 sizeof(wpa_s->bridge_ifname)) { 3596 wpa_printf(MSG_ERROR, "\nToo long bridge interface " 3597 "name '%s'.", iface->bridge_ifname); 3598 return -1; 3599 } 3600 os_strlcpy(wpa_s->bridge_ifname, iface->bridge_ifname, 3601 sizeof(wpa_s->bridge_ifname)); 3602 } 3603 3604 /* RSNA Supplicant Key Management - INITIALIZE */ 3605 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE); 3606 eapol_sm_notify_portValid(wpa_s->eapol, FALSE); 3607 3608 /* Initialize driver interface and register driver event handler before 3609 * L2 receive handler so that association events are processed before 3610 * EAPOL-Key packets if both become available for the same select() 3611 * call. */ 3612 if (wpas_init_driver(wpa_s, iface) < 0) 3613 return -1; 3614 3615 if (wpa_supplicant_init_wpa(wpa_s) < 0) 3616 return -1; 3617 3618 wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname, 3619 wpa_s->bridge_ifname[0] ? wpa_s->bridge_ifname : 3620 NULL); 3621 wpa_sm_set_fast_reauth(wpa_s->wpa, wpa_s->conf->fast_reauth); 3622 3623 if (wpa_s->conf->dot11RSNAConfigPMKLifetime && 3624 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME, 3625 wpa_s->conf->dot11RSNAConfigPMKLifetime)) { 3626 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for " 3627 "dot11RSNAConfigPMKLifetime"); 3628 return -1; 3629 } 3630 3631 if (wpa_s->conf->dot11RSNAConfigPMKReauthThreshold && 3632 wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD, 3633 wpa_s->conf->dot11RSNAConfigPMKReauthThreshold)) { 3634 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for " 3635 "dot11RSNAConfigPMKReauthThreshold"); 3636 return -1; 3637 } 3638 3639 if (wpa_s->conf->dot11RSNAConfigSATimeout && 3640 wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, 3641 wpa_s->conf->dot11RSNAConfigSATimeout)) { 3642 wpa_msg(wpa_s, MSG_ERROR, "Invalid WPA parameter value for " 3643 "dot11RSNAConfigSATimeout"); 3644 return -1; 3645 } 3646 3647 wpa_s->hw.modes = wpa_drv_get_hw_feature_data(wpa_s, 3648 &wpa_s->hw.num_modes, 3649 &wpa_s->hw.flags); 3650 3651 if (wpa_drv_get_capa(wpa_s, &capa) == 0) { 3652 wpa_s->drv_capa_known = 1; 3653 wpa_s->drv_flags = capa.flags; 3654 wpa_s->drv_enc = capa.enc; 3655 wpa_s->probe_resp_offloads = capa.probe_resp_offloads; 3656 wpa_s->max_scan_ssids = capa.max_scan_ssids; 3657 wpa_s->max_sched_scan_ssids = capa.max_sched_scan_ssids; 3658 wpa_s->sched_scan_supported = capa.sched_scan_supported; 3659 wpa_s->max_match_sets = capa.max_match_sets; 3660 wpa_s->max_remain_on_chan = capa.max_remain_on_chan; 3661 wpa_s->max_stations = capa.max_stations; 3662 wpa_s->extended_capa = capa.extended_capa; 3663 wpa_s->extended_capa_mask = capa.extended_capa_mask; 3664 wpa_s->extended_capa_len = capa.extended_capa_len; 3665 wpa_s->num_multichan_concurrent = 3666 capa.num_multichan_concurrent; 3667 } 3668 if (wpa_s->max_remain_on_chan == 0) 3669 wpa_s->max_remain_on_chan = 1000; 3670 3671 /* 3672 * Only take p2p_mgmt parameters when P2P Device is supported. 3673 * Doing it here as it determines whether l2_packet_init() will be done 3674 * during wpa_supplicant_driver_init(). 3675 */ 3676 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) 3677 wpa_s->p2p_mgmt = iface->p2p_mgmt; 3678 else 3679 iface->p2p_mgmt = 1; 3680 3681 if (wpa_s->num_multichan_concurrent == 0) 3682 wpa_s->num_multichan_concurrent = 1; 3683 3684 if (wpa_supplicant_driver_init(wpa_s) < 0) 3685 return -1; 3686 3687#ifdef CONFIG_TDLS 3688 if ((!iface->p2p_mgmt || 3689 !(wpa_s->drv_flags & 3690 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) && 3691 wpa_tdls_init(wpa_s->wpa)) 3692 return -1; 3693#endif /* CONFIG_TDLS */ 3694 3695 if (wpa_s->conf->country[0] && wpa_s->conf->country[1] && 3696 wpa_drv_set_country(wpa_s, wpa_s->conf->country)) { 3697 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to set country"); 3698 return -1; 3699 } 3700 3701 if (wpas_wps_init(wpa_s)) 3702 return -1; 3703 3704 if (wpa_supplicant_init_eapol(wpa_s) < 0) 3705 return -1; 3706 wpa_sm_set_eapol(wpa_s->wpa, wpa_s->eapol); 3707 3708 wpa_s->ctrl_iface = wpa_supplicant_ctrl_iface_init(wpa_s); 3709 if (wpa_s->ctrl_iface == NULL) { 3710 wpa_printf(MSG_ERROR, 3711 "Failed to initialize control interface '%s'.\n" 3712 "You may have another wpa_supplicant process " 3713 "already running or the file was\n" 3714 "left by an unclean termination of wpa_supplicant " 3715 "in which case you will need\n" 3716 "to manually remove this file before starting " 3717 "wpa_supplicant again.\n", 3718 wpa_s->conf->ctrl_interface); 3719 return -1; 3720 } 3721 3722 wpa_s->gas = gas_query_init(wpa_s); 3723 if (wpa_s->gas == NULL) { 3724 wpa_printf(MSG_ERROR, "Failed to initialize GAS query"); 3725 return -1; 3726 } 3727 3728#ifdef CONFIG_P2P 3729 if (iface->p2p_mgmt && wpas_p2p_init(wpa_s->global, wpa_s) < 0) { 3730 wpa_msg(wpa_s, MSG_ERROR, "Failed to init P2P"); 3731 return -1; 3732 } 3733#endif /* CONFIG_P2P */ 3734 3735 if (wpa_bss_init(wpa_s) < 0) 3736 return -1; 3737 3738 /* 3739 * Set Wake-on-WLAN triggers, if configured. 3740 * Note: We don't restore/remove the triggers on shutdown (it doesn't 3741 * have effect anyway when the interface is down). 3742 */ 3743 if (wpas_set_wowlan_triggers(wpa_s, &capa) < 0) 3744 return -1; 3745 3746#ifdef CONFIG_EAP_PROXY 3747{ 3748 size_t len; 3749 wpa_s->mnc_len = eapol_sm_get_eap_proxy_imsi(wpa_s->eapol, wpa_s->imsi, 3750 &len); 3751 if (wpa_s->mnc_len > 0) { 3752 wpa_s->imsi[len] = '\0'; 3753 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI %s (MNC length %d)", 3754 wpa_s->imsi, wpa_s->mnc_len); 3755 } else { 3756 wpa_printf(MSG_DEBUG, "eap_proxy: IMSI not available"); 3757 } 3758} 3759#endif /* CONFIG_EAP_PROXY */ 3760 3761 if (pcsc_reader_init(wpa_s) < 0) 3762 return -1; 3763 3764 if (wpas_init_ext_pw(wpa_s) < 0) 3765 return -1; 3766 3767 return 0; 3768} 3769 3770 3771static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s, 3772 int notify, int terminate) 3773{ 3774 wpa_s->disconnected = 1; 3775 if (wpa_s->drv_priv) { 3776 wpa_supplicant_deauthenticate(wpa_s, 3777 WLAN_REASON_DEAUTH_LEAVING); 3778 3779 wpa_drv_set_countermeasures(wpa_s, 0); 3780 wpa_clear_keys(wpa_s, NULL); 3781 } 3782 3783 wpa_supplicant_cleanup(wpa_s); 3784 3785#ifdef CONFIG_P2P 3786 if (wpa_s == wpa_s->parent) 3787 wpas_p2p_group_remove(wpa_s, "*"); 3788 if (wpa_s == wpa_s->global->p2p_init_wpa_s && wpa_s->global->p2p) { 3789 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Disable P2P since removing " 3790 "the management interface is being removed"); 3791 wpas_p2p_deinit_global(wpa_s->global); 3792 } 3793#endif /* CONFIG_P2P */ 3794 3795 wpas_ctrl_radio_work_flush(wpa_s); 3796 radio_remove_interface(wpa_s); 3797 3798 if (wpa_s->drv_priv) 3799 wpa_drv_deinit(wpa_s); 3800 3801 if (notify) 3802 wpas_notify_iface_removed(wpa_s); 3803 3804 if (terminate) 3805 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING); 3806 3807 if (wpa_s->ctrl_iface) { 3808 wpa_supplicant_ctrl_iface_deinit(wpa_s->ctrl_iface); 3809 wpa_s->ctrl_iface = NULL; 3810 } 3811 3812 if (wpa_s->conf != NULL) { 3813 wpa_config_free(wpa_s->conf); 3814 wpa_s->conf = NULL; 3815 } 3816 3817 os_free(wpa_s); 3818} 3819 3820 3821/** 3822 * wpa_supplicant_add_iface - Add a new network interface 3823 * @global: Pointer to global data from wpa_supplicant_init() 3824 * @iface: Interface configuration options 3825 * Returns: Pointer to the created interface or %NULL on failure 3826 * 3827 * This function is used to add new network interfaces for %wpa_supplicant. 3828 * This can be called before wpa_supplicant_run() to add interfaces before the 3829 * main event loop has been started. In addition, new interfaces can be added 3830 * dynamically while %wpa_supplicant is already running. This could happen, 3831 * e.g., when a hotplug network adapter is inserted. 3832 */ 3833struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global, 3834 struct wpa_interface *iface) 3835{ 3836 struct wpa_supplicant *wpa_s; 3837 struct wpa_interface t_iface; 3838 struct wpa_ssid *ssid; 3839 3840 if (global == NULL || iface == NULL) 3841 return NULL; 3842 3843 wpa_s = wpa_supplicant_alloc(); 3844 if (wpa_s == NULL) 3845 return NULL; 3846 3847 wpa_s->global = global; 3848 3849 t_iface = *iface; 3850 if (global->params.override_driver) { 3851 wpa_printf(MSG_DEBUG, "Override interface parameter: driver " 3852 "('%s' -> '%s')", 3853 iface->driver, global->params.override_driver); 3854 t_iface.driver = global->params.override_driver; 3855 } 3856 if (global->params.override_ctrl_interface) { 3857 wpa_printf(MSG_DEBUG, "Override interface parameter: " 3858 "ctrl_interface ('%s' -> '%s')", 3859 iface->ctrl_interface, 3860 global->params.override_ctrl_interface); 3861 t_iface.ctrl_interface = 3862 global->params.override_ctrl_interface; 3863 } 3864 if (wpa_supplicant_init_iface(wpa_s, &t_iface)) { 3865 wpa_printf(MSG_DEBUG, "Failed to add interface %s", 3866 iface->ifname); 3867 wpa_supplicant_deinit_iface(wpa_s, 0, 0); 3868 return NULL; 3869 } 3870 3871 /* Notify the control interfaces about new iface */ 3872 if (wpas_notify_iface_added(wpa_s)) { 3873 wpa_supplicant_deinit_iface(wpa_s, 1, 0); 3874 return NULL; 3875 } 3876 3877 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) 3878 wpas_notify_network_added(wpa_s, ssid); 3879 3880 wpa_s->next = global->ifaces; 3881 global->ifaces = wpa_s; 3882 3883 wpa_dbg(wpa_s, MSG_DEBUG, "Added interface %s", wpa_s->ifname); 3884 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 3885 3886 return wpa_s; 3887} 3888 3889 3890/** 3891 * wpa_supplicant_remove_iface - Remove a network interface 3892 * @global: Pointer to global data from wpa_supplicant_init() 3893 * @wpa_s: Pointer to the network interface to be removed 3894 * Returns: 0 if interface was removed, -1 if interface was not found 3895 * 3896 * This function can be used to dynamically remove network interfaces from 3897 * %wpa_supplicant, e.g., when a hotplug network adapter is ejected. In 3898 * addition, this function is used to remove all remaining interfaces when 3899 * %wpa_supplicant is terminated. 3900 */ 3901int wpa_supplicant_remove_iface(struct wpa_global *global, 3902 struct wpa_supplicant *wpa_s, 3903 int terminate) 3904{ 3905 struct wpa_supplicant *prev; 3906 3907 /* Remove interface from the global list of interfaces */ 3908 prev = global->ifaces; 3909 if (prev == wpa_s) { 3910 global->ifaces = wpa_s->next; 3911 } else { 3912 while (prev && prev->next != wpa_s) 3913 prev = prev->next; 3914 if (prev == NULL) 3915 return -1; 3916 prev->next = wpa_s->next; 3917 } 3918 3919 wpa_dbg(wpa_s, MSG_DEBUG, "Removing interface %s", wpa_s->ifname); 3920 3921 if (global->p2p_group_formation == wpa_s) 3922 global->p2p_group_formation = NULL; 3923 if (global->p2p_invite_group == wpa_s) 3924 global->p2p_invite_group = NULL; 3925 wpa_supplicant_deinit_iface(wpa_s, 1, terminate); 3926 3927 return 0; 3928} 3929 3930 3931/** 3932 * wpa_supplicant_get_eap_mode - Get the current EAP mode 3933 * @wpa_s: Pointer to the network interface 3934 * Returns: Pointer to the eap mode or the string "UNKNOWN" if not found 3935 */ 3936const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s) 3937{ 3938 const char *eapol_method; 3939 3940 if (wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) == 0 && 3941 wpa_s->key_mgmt != WPA_KEY_MGMT_IEEE8021X_NO_WPA) { 3942 return "NO-EAP"; 3943 } 3944 3945 eapol_method = eapol_sm_get_method_name(wpa_s->eapol); 3946 if (eapol_method == NULL) 3947 return "UNKNOWN-EAP"; 3948 3949 return eapol_method; 3950} 3951 3952 3953/** 3954 * wpa_supplicant_get_iface - Get a new network interface 3955 * @global: Pointer to global data from wpa_supplicant_init() 3956 * @ifname: Interface name 3957 * Returns: Pointer to the interface or %NULL if not found 3958 */ 3959struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global, 3960 const char *ifname) 3961{ 3962 struct wpa_supplicant *wpa_s; 3963 3964 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) { 3965 if (os_strcmp(wpa_s->ifname, ifname) == 0) 3966 return wpa_s; 3967 } 3968 return NULL; 3969} 3970 3971 3972#ifndef CONFIG_NO_WPA_MSG 3973static const char * wpa_supplicant_msg_ifname_cb(void *ctx) 3974{ 3975 struct wpa_supplicant *wpa_s = ctx; 3976 if (wpa_s == NULL) 3977 return NULL; 3978 return wpa_s->ifname; 3979} 3980#endif /* CONFIG_NO_WPA_MSG */ 3981 3982 3983/** 3984 * wpa_supplicant_init - Initialize %wpa_supplicant 3985 * @params: Parameters for %wpa_supplicant 3986 * Returns: Pointer to global %wpa_supplicant data, or %NULL on failure 3987 * 3988 * This function is used to initialize %wpa_supplicant. After successful 3989 * initialization, the returned data pointer can be used to add and remove 3990 * network interfaces, and eventually, to deinitialize %wpa_supplicant. 3991 */ 3992struct wpa_global * wpa_supplicant_init(struct wpa_params *params) 3993{ 3994 struct wpa_global *global; 3995 int ret, i; 3996 3997 if (params == NULL) 3998 return NULL; 3999 4000#ifdef CONFIG_DRIVER_NDIS 4001 { 4002 void driver_ndis_init_ops(void); 4003 driver_ndis_init_ops(); 4004 } 4005#endif /* CONFIG_DRIVER_NDIS */ 4006 4007#ifndef CONFIG_NO_WPA_MSG 4008 wpa_msg_register_ifname_cb(wpa_supplicant_msg_ifname_cb); 4009#endif /* CONFIG_NO_WPA_MSG */ 4010 4011 wpa_debug_open_file(params->wpa_debug_file_path); 4012 if (params->wpa_debug_syslog) 4013 wpa_debug_open_syslog(); 4014 if (params->wpa_debug_tracing) { 4015 ret = wpa_debug_open_linux_tracing(); 4016 if (ret) { 4017 wpa_printf(MSG_ERROR, 4018 "Failed to enable trace logging"); 4019 return NULL; 4020 } 4021 } 4022 4023 ret = eap_register_methods(); 4024 if (ret) { 4025 wpa_printf(MSG_ERROR, "Failed to register EAP methods"); 4026 if (ret == -2) 4027 wpa_printf(MSG_ERROR, "Two or more EAP methods used " 4028 "the same EAP type."); 4029 return NULL; 4030 } 4031 4032 global = os_zalloc(sizeof(*global)); 4033 if (global == NULL) 4034 return NULL; 4035 dl_list_init(&global->p2p_srv_bonjour); 4036 dl_list_init(&global->p2p_srv_upnp); 4037 global->params.daemonize = params->daemonize; 4038 global->params.wait_for_monitor = params->wait_for_monitor; 4039 global->params.dbus_ctrl_interface = params->dbus_ctrl_interface; 4040 if (params->pid_file) 4041 global->params.pid_file = os_strdup(params->pid_file); 4042 if (params->ctrl_interface) 4043 global->params.ctrl_interface = 4044 os_strdup(params->ctrl_interface); 4045 if (params->ctrl_interface_group) 4046 global->params.ctrl_interface_group = 4047 os_strdup(params->ctrl_interface_group); 4048 if (params->override_driver) 4049 global->params.override_driver = 4050 os_strdup(params->override_driver); 4051 if (params->override_ctrl_interface) 4052 global->params.override_ctrl_interface = 4053 os_strdup(params->override_ctrl_interface); 4054 wpa_debug_level = global->params.wpa_debug_level = 4055 params->wpa_debug_level; 4056 wpa_debug_show_keys = global->params.wpa_debug_show_keys = 4057 params->wpa_debug_show_keys; 4058 wpa_debug_timestamp = global->params.wpa_debug_timestamp = 4059 params->wpa_debug_timestamp; 4060 4061 wpa_printf(MSG_DEBUG, "wpa_supplicant v" VERSION_STR); 4062 4063 if (eloop_init()) { 4064 wpa_printf(MSG_ERROR, "Failed to initialize event loop"); 4065 wpa_supplicant_deinit(global); 4066 return NULL; 4067 } 4068 4069 random_init(params->entropy_file); 4070 4071 global->ctrl_iface = wpa_supplicant_global_ctrl_iface_init(global); 4072 if (global->ctrl_iface == NULL) { 4073 wpa_supplicant_deinit(global); 4074 return NULL; 4075 } 4076 4077 if (wpas_notify_supplicant_initialized(global)) { 4078 wpa_supplicant_deinit(global); 4079 return NULL; 4080 } 4081 4082 for (i = 0; wpa_drivers[i]; i++) 4083 global->drv_count++; 4084 if (global->drv_count == 0) { 4085 wpa_printf(MSG_ERROR, "No drivers enabled"); 4086 wpa_supplicant_deinit(global); 4087 return NULL; 4088 } 4089 global->drv_priv = os_zalloc(global->drv_count * sizeof(void *)); 4090 if (global->drv_priv == NULL) { 4091 wpa_supplicant_deinit(global); 4092 return NULL; 4093 } 4094 4095#ifdef CONFIG_WIFI_DISPLAY 4096 if (wifi_display_init(global) < 0) { 4097 wpa_printf(MSG_ERROR, "Failed to initialize Wi-Fi Display"); 4098 wpa_supplicant_deinit(global); 4099 return NULL; 4100 } 4101#endif /* CONFIG_WIFI_DISPLAY */ 4102 4103 return global; 4104} 4105 4106 4107/** 4108 * wpa_supplicant_run - Run the %wpa_supplicant main event loop 4109 * @global: Pointer to global data from wpa_supplicant_init() 4110 * Returns: 0 after successful event loop run, -1 on failure 4111 * 4112 * This function starts the main event loop and continues running as long as 4113 * there are any remaining events. In most cases, this function is running as 4114 * long as the %wpa_supplicant process in still in use. 4115 */ 4116int wpa_supplicant_run(struct wpa_global *global) 4117{ 4118 struct wpa_supplicant *wpa_s; 4119 4120 if (global->params.daemonize && 4121 wpa_supplicant_daemon(global->params.pid_file)) 4122 return -1; 4123 4124 if (global->params.wait_for_monitor) { 4125 for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) 4126 if (wpa_s->ctrl_iface) 4127 wpa_supplicant_ctrl_iface_wait( 4128 wpa_s->ctrl_iface); 4129 } 4130 4131 eloop_register_signal_terminate(wpa_supplicant_terminate, global); 4132 eloop_register_signal_reconfig(wpa_supplicant_reconfig, global); 4133 4134 eloop_run(); 4135 4136 return 0; 4137} 4138 4139 4140/** 4141 * wpa_supplicant_deinit - Deinitialize %wpa_supplicant 4142 * @global: Pointer to global data from wpa_supplicant_init() 4143 * 4144 * This function is called to deinitialize %wpa_supplicant and to free all 4145 * allocated resources. Remaining network interfaces will also be removed. 4146 */ 4147void wpa_supplicant_deinit(struct wpa_global *global) 4148{ 4149 int i; 4150 4151 if (global == NULL) 4152 return; 4153 4154#ifdef CONFIG_WIFI_DISPLAY 4155 wifi_display_deinit(global); 4156#endif /* CONFIG_WIFI_DISPLAY */ 4157 4158 while (global->ifaces) 4159 wpa_supplicant_remove_iface(global, global->ifaces, 1); 4160 4161 if (global->ctrl_iface) 4162 wpa_supplicant_global_ctrl_iface_deinit(global->ctrl_iface); 4163 4164 wpas_notify_supplicant_deinitialized(global); 4165 4166 eap_peer_unregister_methods(); 4167#ifdef CONFIG_AP 4168 eap_server_unregister_methods(); 4169#endif /* CONFIG_AP */ 4170 4171 for (i = 0; wpa_drivers[i] && global->drv_priv; i++) { 4172 if (!global->drv_priv[i]) 4173 continue; 4174 wpa_drivers[i]->global_deinit(global->drv_priv[i]); 4175 } 4176 os_free(global->drv_priv); 4177 4178 random_deinit(); 4179 4180 eloop_destroy(); 4181 4182 if (global->params.pid_file) { 4183 os_daemonize_terminate(global->params.pid_file); 4184 os_free(global->params.pid_file); 4185 } 4186 os_free(global->params.ctrl_interface); 4187 os_free(global->params.ctrl_interface_group); 4188 os_free(global->params.override_driver); 4189 os_free(global->params.override_ctrl_interface); 4190 4191 os_free(global->p2p_disallow_freq.range); 4192 os_free(global->p2p_go_avoid_freq.range); 4193 os_free(global->add_psk); 4194 4195 os_free(global); 4196 wpa_debug_close_syslog(); 4197 wpa_debug_close_file(); 4198 wpa_debug_close_linux_tracing(); 4199} 4200 4201 4202void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s) 4203{ 4204 if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) && 4205 wpa_s->conf->country[0] && wpa_s->conf->country[1]) { 4206 char country[3]; 4207 country[0] = wpa_s->conf->country[0]; 4208 country[1] = wpa_s->conf->country[1]; 4209 country[2] = '\0'; 4210 if (wpa_drv_set_country(wpa_s, country) < 0) { 4211 wpa_printf(MSG_ERROR, "Failed to set country code " 4212 "'%s'", country); 4213 } 4214 } 4215 4216 if (wpa_s->conf->changed_parameters & CFG_CHANGED_EXT_PW_BACKEND) 4217 wpas_init_ext_pw(wpa_s); 4218 4219#ifdef CONFIG_WPS 4220 wpas_wps_update_config(wpa_s); 4221#endif /* CONFIG_WPS */ 4222 4223#ifdef CONFIG_P2P 4224 wpas_p2p_update_config(wpa_s); 4225#endif /* CONFIG_P2P */ 4226 4227 wpa_s->conf->changed_parameters = 0; 4228} 4229 4230 4231static void add_freq(int *freqs, int *num_freqs, int freq) 4232{ 4233 int i; 4234 4235 for (i = 0; i < *num_freqs; i++) { 4236 if (freqs[i] == freq) 4237 return; 4238 } 4239 4240 freqs[*num_freqs] = freq; 4241 (*num_freqs)++; 4242} 4243 4244 4245static int * get_bss_freqs_in_ess(struct wpa_supplicant *wpa_s) 4246{ 4247 struct wpa_bss *bss, *cbss; 4248 const int max_freqs = 10; 4249 int *freqs; 4250 int num_freqs = 0; 4251 4252 freqs = os_zalloc(sizeof(int) * (max_freqs + 1)); 4253 if (freqs == NULL) 4254 return NULL; 4255 4256 cbss = wpa_s->current_bss; 4257 4258 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) { 4259 if (bss == cbss) 4260 continue; 4261 if (bss->ssid_len == cbss->ssid_len && 4262 os_memcmp(bss->ssid, cbss->ssid, bss->ssid_len) == 0 && 4263 wpa_blacklist_get(wpa_s, bss->bssid) == NULL) { 4264 add_freq(freqs, &num_freqs, bss->freq); 4265 if (num_freqs == max_freqs) 4266 break; 4267 } 4268 } 4269 4270 if (num_freqs == 0) { 4271 os_free(freqs); 4272 freqs = NULL; 4273 } 4274 4275 return freqs; 4276} 4277 4278 4279void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid) 4280{ 4281 int timeout; 4282 int count; 4283 int *freqs = NULL; 4284 4285 wpas_connect_work_done(wpa_s); 4286 4287 /* 4288 * Remove possible authentication timeout since the connection failed. 4289 */ 4290 eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL); 4291 4292 if (wpa_s->disconnected) { 4293 /* 4294 * There is no point in blacklisting the AP if this event is 4295 * generated based on local request to disconnect. 4296 */ 4297 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore connection failure " 4298 "indication since interface has been put into " 4299 "disconnected state"); 4300 return; 4301 } 4302 4303 /* 4304 * Add the failed BSSID into the blacklist and speed up next scan 4305 * attempt if there could be other APs that could accept association. 4306 * The current blacklist count indicates how many times we have tried 4307 * connecting to this AP and multiple attempts mean that other APs are 4308 * either not available or has already been tried, so that we can start 4309 * increasing the delay here to avoid constant scanning. 4310 */ 4311 count = wpa_blacklist_add(wpa_s, bssid); 4312 if (count == 1 && wpa_s->current_bss) { 4313 /* 4314 * This BSS was not in the blacklist before. If there is 4315 * another BSS available for the same ESS, we should try that 4316 * next. Otherwise, we may as well try this one once more 4317 * before allowing other, likely worse, ESSes to be considered. 4318 */ 4319 freqs = get_bss_freqs_in_ess(wpa_s); 4320 if (freqs) { 4321 wpa_dbg(wpa_s, MSG_DEBUG, "Another BSS in this ESS " 4322 "has been seen; try it next"); 4323 wpa_blacklist_add(wpa_s, bssid); 4324 /* 4325 * On the next scan, go through only the known channels 4326 * used in this ESS based on previous scans to speed up 4327 * common load balancing use case. 4328 */ 4329 os_free(wpa_s->next_scan_freqs); 4330 wpa_s->next_scan_freqs = freqs; 4331 } 4332 } 4333 4334 /* 4335 * Add previous failure count in case the temporary blacklist was 4336 * cleared due to no other BSSes being available. 4337 */ 4338 count += wpa_s->extra_blacklist_count; 4339 4340 if (count > 3 && wpa_s->current_ssid) { 4341 wpa_printf(MSG_DEBUG, "Continuous association failures - " 4342 "consider temporary network disabling"); 4343 wpas_auth_failed(wpa_s, "CONN_FAILED"); 4344 } 4345 4346 switch (count) { 4347 case 1: 4348 timeout = 100; 4349 break; 4350 case 2: 4351 timeout = 500; 4352 break; 4353 case 3: 4354 timeout = 1000; 4355 break; 4356 case 4: 4357 timeout = 5000; 4358 break; 4359 default: 4360 timeout = 10000; 4361 break; 4362 } 4363 4364 wpa_dbg(wpa_s, MSG_DEBUG, "Blacklist count %d --> request scan in %d " 4365 "ms", count, timeout); 4366 4367 /* 4368 * TODO: if more than one possible AP is available in scan results, 4369 * could try the other ones before requesting a new scan. 4370 */ 4371 wpa_supplicant_req_scan(wpa_s, timeout / 1000, 4372 1000 * (timeout % 1000)); 4373} 4374 4375 4376int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s) 4377{ 4378 return wpa_s->conf->ap_scan == 2 || 4379 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION); 4380} 4381 4382 4383#if defined(CONFIG_CTRL_IFACE) || defined(CONFIG_CTRL_IFACE_DBUS_NEW) 4384int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s, 4385 struct wpa_ssid *ssid, 4386 const char *field, 4387 const char *value) 4388{ 4389#ifdef IEEE8021X_EAPOL 4390 struct eap_peer_config *eap = &ssid->eap; 4391 4392 wpa_printf(MSG_DEBUG, "CTRL_IFACE: response handle field=%s", field); 4393 wpa_hexdump_ascii_key(MSG_DEBUG, "CTRL_IFACE: response value", 4394 (const u8 *) value, os_strlen(value)); 4395 4396 switch (wpa_supplicant_ctrl_req_from_string(field)) { 4397 case WPA_CTRL_REQ_EAP_IDENTITY: 4398 os_free(eap->identity); 4399 eap->identity = (u8 *) os_strdup(value); 4400 eap->identity_len = os_strlen(value); 4401 eap->pending_req_identity = 0; 4402 if (ssid == wpa_s->current_ssid) 4403 wpa_s->reassociate = 1; 4404 break; 4405 case WPA_CTRL_REQ_EAP_PASSWORD: 4406 os_free(eap->password); 4407 eap->password = (u8 *) os_strdup(value); 4408 eap->password_len = os_strlen(value); 4409 eap->pending_req_password = 0; 4410 if (ssid == wpa_s->current_ssid) 4411 wpa_s->reassociate = 1; 4412 break; 4413 case WPA_CTRL_REQ_EAP_NEW_PASSWORD: 4414 os_free(eap->new_password); 4415 eap->new_password = (u8 *) os_strdup(value); 4416 eap->new_password_len = os_strlen(value); 4417 eap->pending_req_new_password = 0; 4418 if (ssid == wpa_s->current_ssid) 4419 wpa_s->reassociate = 1; 4420 break; 4421 case WPA_CTRL_REQ_EAP_PIN: 4422 os_free(eap->pin); 4423 eap->pin = os_strdup(value); 4424 eap->pending_req_pin = 0; 4425 if (ssid == wpa_s->current_ssid) 4426 wpa_s->reassociate = 1; 4427 break; 4428 case WPA_CTRL_REQ_EAP_OTP: 4429 os_free(eap->otp); 4430 eap->otp = (u8 *) os_strdup(value); 4431 eap->otp_len = os_strlen(value); 4432 os_free(eap->pending_req_otp); 4433 eap->pending_req_otp = NULL; 4434 eap->pending_req_otp_len = 0; 4435 break; 4436 case WPA_CTRL_REQ_EAP_PASSPHRASE: 4437 os_free(eap->private_key_passwd); 4438 eap->private_key_passwd = (u8 *) os_strdup(value); 4439 eap->pending_req_passphrase = 0; 4440 if (ssid == wpa_s->current_ssid) 4441 wpa_s->reassociate = 1; 4442 break; 4443 case WPA_CTRL_REQ_SIM: 4444 os_free(eap->external_sim_resp); 4445 eap->external_sim_resp = os_strdup(value); 4446 break; 4447 default: 4448 wpa_printf(MSG_DEBUG, "CTRL_IFACE: Unknown field '%s'", field); 4449 return -1; 4450 } 4451 4452 return 0; 4453#else /* IEEE8021X_EAPOL */ 4454 wpa_printf(MSG_DEBUG, "CTRL_IFACE: IEEE 802.1X not included"); 4455 return -1; 4456#endif /* IEEE8021X_EAPOL */ 4457} 4458#endif /* CONFIG_CTRL_IFACE || CONFIG_CTRL_IFACE_DBUS_NEW */ 4459 4460 4461int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid) 4462{ 4463 int i; 4464 unsigned int drv_enc; 4465 4466 if (ssid == NULL) 4467 return 1; 4468 4469 if (ssid->disabled) 4470 return 1; 4471 4472 if (wpa_s && wpa_s->drv_capa_known) 4473 drv_enc = wpa_s->drv_enc; 4474 else 4475 drv_enc = (unsigned int) -1; 4476 4477 for (i = 0; i < NUM_WEP_KEYS; i++) { 4478 size_t len = ssid->wep_key_len[i]; 4479 if (len == 0) 4480 continue; 4481 if (len == 5 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP40)) 4482 continue; 4483 if (len == 13 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP104)) 4484 continue; 4485 if (len == 16 && (drv_enc & WPA_DRIVER_CAPA_ENC_WEP128)) 4486 continue; 4487 return 1; /* invalid WEP key */ 4488 } 4489 4490 if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt) && !ssid->psk_set && 4491 (!ssid->passphrase || ssid->ssid_len != 0) && !ssid->ext_psk) 4492 return 1; 4493 4494 return 0; 4495} 4496 4497 4498int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s) 4499{ 4500 if (wpa_s->global->conc_pref == WPA_CONC_PREF_P2P) 4501 return 1; 4502 if (wpa_s->global->conc_pref == WPA_CONC_PREF_STA) 4503 return 0; 4504 return -1; 4505} 4506 4507 4508void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason) 4509{ 4510 struct wpa_ssid *ssid = wpa_s->current_ssid; 4511 int dur; 4512 struct os_reltime now; 4513 4514 if (ssid == NULL) { 4515 wpa_printf(MSG_DEBUG, "Authentication failure but no known " 4516 "SSID block"); 4517 return; 4518 } 4519 4520 if (ssid->key_mgmt == WPA_KEY_MGMT_WPS) 4521 return; 4522 4523 ssid->auth_failures++; 4524 4525#ifdef CONFIG_P2P 4526 if (ssid->p2p_group && 4527 (wpa_s->p2p_in_provisioning || wpa_s->show_group_started)) { 4528 /* 4529 * Skip the wait time since there is a short timeout on the 4530 * connection to a P2P group. 4531 */ 4532 return; 4533 } 4534#endif /* CONFIG_P2P */ 4535 4536 if (ssid->auth_failures > 50) 4537 dur = 300; 4538 else if (ssid->auth_failures > 10) 4539 dur = 120; 4540 else if (ssid->auth_failures > 5) 4541 dur = 90; 4542 else if (ssid->auth_failures > 3) 4543 dur = 60; 4544 else if (ssid->auth_failures > 2) 4545 dur = 30; 4546 else if (ssid->auth_failures > 1) 4547 dur = 20; 4548 else 4549 dur = 10; 4550 4551 if (ssid->auth_failures > 1 && 4552 wpa_key_mgmt_wpa_ieee8021x(ssid->key_mgmt)) 4553 dur += os_random() % (ssid->auth_failures * 10); 4554 4555 os_get_reltime(&now); 4556 if (now.sec + dur <= ssid->disabled_until.sec) 4557 return; 4558 4559 ssid->disabled_until.sec = now.sec + dur; 4560 4561 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TEMP_DISABLED 4562 "id=%d ssid=\"%s\" auth_failures=%u duration=%d reason=%s", 4563 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len), 4564 ssid->auth_failures, dur, reason); 4565} 4566 4567 4568void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s, 4569 struct wpa_ssid *ssid, int clear_failures) 4570{ 4571 if (ssid == NULL) 4572 return; 4573 4574 if (ssid->disabled_until.sec) { 4575 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REENABLED 4576 "id=%d ssid=\"%s\"", 4577 ssid->id, wpa_ssid_txt(ssid->ssid, ssid->ssid_len)); 4578 } 4579 ssid->disabled_until.sec = 0; 4580 ssid->disabled_until.usec = 0; 4581 if (clear_failures) 4582 ssid->auth_failures = 0; 4583} 4584 4585 4586int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid) 4587{ 4588 size_t i; 4589 4590 if (wpa_s->disallow_aps_bssid == NULL) 4591 return 0; 4592 4593 for (i = 0; i < wpa_s->disallow_aps_bssid_count; i++) { 4594 if (os_memcmp(wpa_s->disallow_aps_bssid + i * ETH_ALEN, 4595 bssid, ETH_ALEN) == 0) 4596 return 1; 4597 } 4598 4599 return 0; 4600} 4601 4602 4603int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid, 4604 size_t ssid_len) 4605{ 4606 size_t i; 4607 4608 if (wpa_s->disallow_aps_ssid == NULL || ssid == NULL) 4609 return 0; 4610 4611 for (i = 0; i < wpa_s->disallow_aps_ssid_count; i++) { 4612 struct wpa_ssid_value *s = &wpa_s->disallow_aps_ssid[i]; 4613 if (ssid_len == s->ssid_len && 4614 os_memcmp(ssid, s->ssid, ssid_len) == 0) 4615 return 1; 4616 } 4617 4618 return 0; 4619} 4620 4621 4622/** 4623 * wpas_request_connection - Request a new connection 4624 * @wpa_s: Pointer to the network interface 4625 * 4626 * This function is used to request a new connection to be found. It will mark 4627 * the interface to allow reassociation and request a new scan to find a 4628 * suitable network to connect to. 4629 */ 4630void wpas_request_connection(struct wpa_supplicant *wpa_s) 4631{ 4632 wpa_s->normal_scans = 0; 4633 wpa_supplicant_reinit_autoscan(wpa_s); 4634 wpa_s->extra_blacklist_count = 0; 4635 wpa_s->disconnected = 0; 4636 wpa_s->reassociate = 1; 4637 4638 if (wpa_supplicant_fast_associate(wpa_s) != 1) 4639 wpa_supplicant_req_scan(wpa_s, 0, 0); 4640} 4641 4642 4643void dump_freq_array(struct wpa_supplicant *wpa_s, const char *title, 4644 int *freq_array, unsigned int len) 4645{ 4646 unsigned int i; 4647 4648 wpa_dbg(wpa_s, MSG_DEBUG, "Shared frequencies (len=%u): %s", 4649 len, title); 4650 for (i = 0; i < len; i++) 4651 wpa_dbg(wpa_s, MSG_DEBUG, "freq[%u]: %d", i, freq_array[i]); 4652} 4653 4654 4655/* 4656 * Find the operating frequencies of any of the virtual interfaces that 4657 * are using the same radio as the current interface. 4658 */ 4659int get_shared_radio_freqs(struct wpa_supplicant *wpa_s, 4660 int *freq_array, unsigned int len) 4661{ 4662 struct wpa_supplicant *ifs; 4663 u8 bssid[ETH_ALEN]; 4664 int freq; 4665 unsigned int idx = 0, i; 4666 4667 wpa_dbg(wpa_s, MSG_DEBUG, 4668 "Determining shared radio frequencies (max len %u)", len); 4669 os_memset(freq_array, 0, sizeof(int) * len); 4670 4671 /* First add the frequency of the local interface */ 4672 if (wpa_s->current_ssid != NULL && wpa_s->assoc_freq != 0) { 4673 if (wpa_s->current_ssid->mode == WPAS_MODE_AP || 4674 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO) 4675 freq_array[idx++] = wpa_s->current_ssid->frequency; 4676 else if (wpa_drv_get_bssid(wpa_s, bssid) == 0) 4677 freq_array[idx++] = wpa_s->assoc_freq; 4678 } 4679 4680 /* If get_radio_name is not supported, use only the local freq */ 4681 if (!wpa_driver_get_radio_name(wpa_s)) { 4682 freq = wpa_drv_shared_freq(wpa_s); 4683 if (freq > 0 && idx < len && 4684 (idx == 0 || freq_array[0] != freq)) 4685 freq_array[idx++] = freq; 4686 dump_freq_array(wpa_s, "No get_radio_name", freq_array, idx); 4687 return idx; 4688 } 4689 4690 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant, 4691 radio_list) { 4692 if (wpa_s == ifs) 4693 continue; 4694 4695 if (ifs->current_ssid == NULL || ifs->assoc_freq == 0) 4696 continue; 4697 4698 if (ifs->current_ssid->mode == WPAS_MODE_AP || 4699 ifs->current_ssid->mode == WPAS_MODE_P2P_GO) 4700 freq = ifs->current_ssid->frequency; 4701 else if (wpa_drv_get_bssid(ifs, bssid) == 0) 4702 freq = ifs->assoc_freq; 4703 else 4704 continue; 4705 4706 /* Hold only distinct freqs */ 4707 for (i = 0; i < idx; i++) 4708 if (freq_array[i] == freq) 4709 break; 4710 4711 if (i == idx) 4712 freq_array[idx++] = freq; 4713 } 4714 4715 dump_freq_array(wpa_s, "completed iteration", freq_array, idx); 4716 return idx; 4717} 4718