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