1 /* 2 * WPA Supplicant - Driver event processing 3 * Copyright (c) 2003-2014, Jouni Malinen <j (at) w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #include "includes.h" 10 11 #include "common.h" 12 #include "eapol_supp/eapol_supp_sm.h" 13 #include "rsn_supp/wpa.h" 14 #include "eloop.h" 15 #include "config.h" 16 #include "l2_packet/l2_packet.h" 17 #include "wpa_supplicant_i.h" 18 #include "driver_i.h" 19 #include "pcsc_funcs.h" 20 #include "rsn_supp/preauth.h" 21 #include "rsn_supp/pmksa_cache.h" 22 #include "common/wpa_ctrl.h" 23 #include "eap_peer/eap.h" 24 #include "ap/hostapd.h" 25 #include "p2p/p2p.h" 26 #include "wnm_sta.h" 27 #include "notify.h" 28 #include "common/ieee802_11_defs.h" 29 #include "common/ieee802_11_common.h" 30 #include "crypto/random.h" 31 #include "blacklist.h" 32 #include "wpas_glue.h" 33 #include "wps_supplicant.h" 34 #include "ibss_rsn.h" 35 #include "sme.h" 36 #include "gas_query.h" 37 #include "p2p_supplicant.h" 38 #include "bgscan.h" 39 #include "autoscan.h" 40 #include "ap.h" 41 #include "bss.h" 42 #include "scan.h" 43 #include "offchannel.h" 44 #include "interworking.h" 45 46 47 #ifndef CONFIG_NO_SCAN_PROCESSING 48 static int wpas_select_network_from_last_scan(struct wpa_supplicant *wpa_s, 49 int new_scan, int own_request); 50 #endif /* CONFIG_NO_SCAN_PROCESSING */ 51 52 53 static int wpas_temp_disabled(struct wpa_supplicant *wpa_s, 54 struct wpa_ssid *ssid) 55 { 56 struct os_reltime now; 57 58 if (ssid == NULL || ssid->disabled_until.sec == 0) 59 return 0; 60 61 os_get_reltime(&now); 62 if (ssid->disabled_until.sec > now.sec) 63 return ssid->disabled_until.sec - now.sec; 64 65 wpas_clear_temp_disabled(wpa_s, ssid, 0); 66 67 return 0; 68 } 69 70 71 static struct wpa_bss * wpa_supplicant_get_new_bss( 72 struct wpa_supplicant *wpa_s, const u8 *bssid) 73 { 74 struct wpa_bss *bss = NULL; 75 struct wpa_ssid *ssid = wpa_s->current_ssid; 76 77 if (ssid->ssid_len > 0) 78 bss = wpa_bss_get(wpa_s, bssid, ssid->ssid, ssid->ssid_len); 79 if (!bss) 80 bss = wpa_bss_get_bssid(wpa_s, bssid); 81 82 return bss; 83 } 84 85 86 static void wpa_supplicant_update_current_bss(struct wpa_supplicant *wpa_s) 87 { 88 struct wpa_bss *bss = wpa_supplicant_get_new_bss(wpa_s, wpa_s->bssid); 89 90 if (!bss) { 91 wpa_supplicant_update_scan_results(wpa_s); 92 93 /* Get the BSS from the new scan results */ 94 bss = wpa_supplicant_get_new_bss(wpa_s, wpa_s->bssid); 95 } 96 97 if (bss) 98 wpa_s->current_bss = bss; 99 } 100 101 102 static int wpa_supplicant_select_config(struct wpa_supplicant *wpa_s) 103 { 104 struct wpa_ssid *ssid, *old_ssid; 105 int res; 106 107 if (wpa_s->conf->ap_scan == 1 && wpa_s->current_ssid) { 108 wpa_supplicant_update_current_bss(wpa_s); 109 return 0; 110 } 111 112 wpa_dbg(wpa_s, MSG_DEBUG, "Select network based on association " 113 "information"); 114 ssid = wpa_supplicant_get_ssid(wpa_s); 115 if (ssid == NULL) { 116 wpa_msg(wpa_s, MSG_INFO, 117 "No network configuration found for the current AP"); 118 return -1; 119 } 120 121 if (wpas_network_disabled(wpa_s, ssid)) { 122 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is disabled"); 123 return -1; 124 } 125 126 if (disallowed_bssid(wpa_s, wpa_s->bssid) || 127 disallowed_ssid(wpa_s, ssid->ssid, ssid->ssid_len)) { 128 wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS is disallowed"); 129 return -1; 130 } 131 132 res = wpas_temp_disabled(wpa_s, ssid); 133 if (res > 0) { 134 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is temporarily " 135 "disabled for %d second(s)", res); 136 return -1; 137 } 138 139 wpa_dbg(wpa_s, MSG_DEBUG, "Network configuration found for the " 140 "current AP"); 141 if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) { 142 u8 wpa_ie[80]; 143 size_t wpa_ie_len = sizeof(wpa_ie); 144 if (wpa_supplicant_set_suites(wpa_s, NULL, ssid, 145 wpa_ie, &wpa_ie_len) < 0) 146 wpa_dbg(wpa_s, MSG_DEBUG, "Could not set WPA suites"); 147 } else { 148 wpa_supplicant_set_non_wpa_policy(wpa_s, ssid); 149 } 150 151 if (wpa_s->current_ssid && wpa_s->current_ssid != ssid) 152 eapol_sm_invalidate_cached_session(wpa_s->eapol); 153 old_ssid = wpa_s->current_ssid; 154 wpa_s->current_ssid = ssid; 155 156 wpa_supplicant_update_current_bss(wpa_s); 157 158 wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid); 159 wpa_supplicant_initiate_eapol(wpa_s); 160 if (old_ssid != wpa_s->current_ssid) 161 wpas_notify_network_changed(wpa_s); 162 163 return 0; 164 } 165 166 167 void wpa_supplicant_stop_countermeasures(void *eloop_ctx, void *sock_ctx) 168 { 169 struct wpa_supplicant *wpa_s = eloop_ctx; 170 171 if (wpa_s->countermeasures) { 172 wpa_s->countermeasures = 0; 173 wpa_drv_set_countermeasures(wpa_s, 0); 174 wpa_msg(wpa_s, MSG_INFO, "WPA: TKIP countermeasures stopped"); 175 wpa_supplicant_req_scan(wpa_s, 0, 0); 176 } 177 } 178 179 180 void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s) 181 { 182 int bssid_changed; 183 184 wnm_bss_keep_alive_deinit(wpa_s); 185 186 #ifdef CONFIG_IBSS_RSN 187 ibss_rsn_deinit(wpa_s->ibss_rsn); 188 wpa_s->ibss_rsn = NULL; 189 #endif /* CONFIG_IBSS_RSN */ 190 191 #ifdef CONFIG_AP 192 wpa_supplicant_ap_deinit(wpa_s); 193 #endif /* CONFIG_AP */ 194 195 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) 196 return; 197 198 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 199 bssid_changed = !is_zero_ether_addr(wpa_s->bssid); 200 os_memset(wpa_s->bssid, 0, ETH_ALEN); 201 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 202 #ifdef CONFIG_SME 203 wpa_s->sme.prev_bssid_set = 0; 204 #endif /* CONFIG_SME */ 205 #ifdef CONFIG_P2P 206 os_memset(wpa_s->go_dev_addr, 0, ETH_ALEN); 207 #endif /* CONFIG_P2P */ 208 wpa_s->current_bss = NULL; 209 wpa_s->assoc_freq = 0; 210 #ifdef CONFIG_IEEE80211R 211 #ifdef CONFIG_SME 212 if (wpa_s->sme.ft_ies) 213 sme_update_ft_ies(wpa_s, NULL, NULL, 0); 214 #endif /* CONFIG_SME */ 215 #endif /* CONFIG_IEEE80211R */ 216 217 if (bssid_changed) 218 wpas_notify_bssid_changed(wpa_s); 219 220 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE); 221 eapol_sm_notify_portValid(wpa_s->eapol, FALSE); 222 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) 223 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); 224 wpa_s->ap_ies_from_associnfo = 0; 225 wpa_s->current_ssid = NULL; 226 eapol_sm_notify_config(wpa_s->eapol, NULL, NULL); 227 wpa_s->key_mgmt = 0; 228 } 229 230 231 static void wpa_find_assoc_pmkid(struct wpa_supplicant *wpa_s) 232 { 233 struct wpa_ie_data ie; 234 int pmksa_set = -1; 235 size_t i; 236 237 if (wpa_sm_parse_own_wpa_ie(wpa_s->wpa, &ie) < 0 || 238 ie.pmkid == NULL) 239 return; 240 241 for (i = 0; i < ie.num_pmkid; i++) { 242 pmksa_set = pmksa_cache_set_current(wpa_s->wpa, 243 ie.pmkid + i * PMKID_LEN, 244 NULL, NULL, 0); 245 if (pmksa_set == 0) { 246 eapol_sm_notify_pmkid_attempt(wpa_s->eapol, 1); 247 break; 248 } 249 } 250 251 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID from assoc IE %sfound from " 252 "PMKSA cache", pmksa_set == 0 ? "" : "not "); 253 } 254 255 256 static void wpa_supplicant_event_pmkid_candidate(struct wpa_supplicant *wpa_s, 257 union wpa_event_data *data) 258 { 259 if (data == NULL) { 260 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: No data in PMKID candidate " 261 "event"); 262 return; 263 } 264 wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID candidate event - bssid=" MACSTR 265 " index=%d preauth=%d", 266 MAC2STR(data->pmkid_candidate.bssid), 267 data->pmkid_candidate.index, 268 data->pmkid_candidate.preauth); 269 270 pmksa_candidate_add(wpa_s->wpa, data->pmkid_candidate.bssid, 271 data->pmkid_candidate.index, 272 data->pmkid_candidate.preauth); 273 } 274 275 276 static int wpa_supplicant_dynamic_keys(struct wpa_supplicant *wpa_s) 277 { 278 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 279 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) 280 return 0; 281 282 #ifdef IEEE8021X_EAPOL 283 if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA && 284 wpa_s->current_ssid && 285 !(wpa_s->current_ssid->eapol_flags & 286 (EAPOL_FLAG_REQUIRE_KEY_UNICAST | 287 EAPOL_FLAG_REQUIRE_KEY_BROADCAST))) { 288 /* IEEE 802.1X, but not using dynamic WEP keys (i.e., either 289 * plaintext or static WEP keys). */ 290 return 0; 291 } 292 #endif /* IEEE8021X_EAPOL */ 293 294 return 1; 295 } 296 297 298 /** 299 * wpa_supplicant_scard_init - Initialize SIM/USIM access with PC/SC 300 * @wpa_s: pointer to wpa_supplicant data 301 * @ssid: Configuration data for the network 302 * Returns: 0 on success, -1 on failure 303 * 304 * This function is called when starting authentication with a network that is 305 * configured to use PC/SC for SIM/USIM access (EAP-SIM or EAP-AKA). 306 */ 307 int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s, 308 struct wpa_ssid *ssid) 309 { 310 #ifdef IEEE8021X_EAPOL 311 #ifdef PCSC_FUNCS 312 int aka = 0, sim = 0; 313 314 if ((ssid != NULL && ssid->eap.pcsc == NULL) || 315 wpa_s->scard != NULL || wpa_s->conf->external_sim) 316 return 0; 317 318 if (ssid == NULL || ssid->eap.eap_methods == NULL) { 319 sim = 1; 320 aka = 1; 321 } else { 322 struct eap_method_type *eap = ssid->eap.eap_methods; 323 while (eap->vendor != EAP_VENDOR_IETF || 324 eap->method != EAP_TYPE_NONE) { 325 if (eap->vendor == EAP_VENDOR_IETF) { 326 if (eap->method == EAP_TYPE_SIM) 327 sim = 1; 328 else if (eap->method == EAP_TYPE_AKA || 329 eap->method == EAP_TYPE_AKA_PRIME) 330 aka = 1; 331 } 332 eap++; 333 } 334 } 335 336 if (eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_SIM) == NULL) 337 sim = 0; 338 if (eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_AKA) == NULL && 339 eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_AKA_PRIME) == 340 NULL) 341 aka = 0; 342 343 if (!sim && !aka) { 344 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to " 345 "use SIM, but neither EAP-SIM nor EAP-AKA are " 346 "enabled"); 347 return 0; 348 } 349 350 wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to use SIM " 351 "(sim=%d aka=%d) - initialize PCSC", sim, aka); 352 353 wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader); 354 if (wpa_s->scard == NULL) { 355 wpa_msg(wpa_s, MSG_WARNING, "Failed to initialize SIM " 356 "(pcsc-lite)"); 357 return -1; 358 } 359 wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard); 360 eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard); 361 #endif /* PCSC_FUNCS */ 362 #endif /* IEEE8021X_EAPOL */ 363 364 return 0; 365 } 366 367 368 #ifndef CONFIG_NO_SCAN_PROCESSING 369 370 static int has_wep_key(struct wpa_ssid *ssid) 371 { 372 int i; 373 374 for (i = 0; i < NUM_WEP_KEYS; i++) { 375 if (ssid->wep_key_len[i]) 376 return 1; 377 } 378 379 return 0; 380 } 381 382 383 static int wpa_supplicant_match_privacy(struct wpa_bss *bss, 384 struct wpa_ssid *ssid) 385 { 386 int privacy = 0; 387 388 if (ssid->mixed_cell) 389 return 1; 390 391 #ifdef CONFIG_WPS 392 if (ssid->key_mgmt & WPA_KEY_MGMT_WPS) 393 return 1; 394 #endif /* CONFIG_WPS */ 395 396 if (has_wep_key(ssid)) 397 privacy = 1; 398 399 #ifdef IEEE8021X_EAPOL 400 if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && 401 ssid->eapol_flags & (EAPOL_FLAG_REQUIRE_KEY_UNICAST | 402 EAPOL_FLAG_REQUIRE_KEY_BROADCAST)) 403 privacy = 1; 404 #endif /* IEEE8021X_EAPOL */ 405 406 if (wpa_key_mgmt_wpa(ssid->key_mgmt)) 407 privacy = 1; 408 409 if (ssid->key_mgmt & WPA_KEY_MGMT_OSEN) 410 privacy = 1; 411 412 if (bss->caps & IEEE80211_CAP_PRIVACY) 413 return privacy; 414 return !privacy; 415 } 416 417 418 static int wpa_supplicant_ssid_bss_match(struct wpa_supplicant *wpa_s, 419 struct wpa_ssid *ssid, 420 struct wpa_bss *bss) 421 { 422 struct wpa_ie_data ie; 423 int proto_match = 0; 424 const u8 *rsn_ie, *wpa_ie; 425 int ret; 426 int wep_ok; 427 428 ret = wpas_wps_ssid_bss_match(wpa_s, ssid, bss); 429 if (ret >= 0) 430 return ret; 431 432 /* Allow TSN if local configuration accepts WEP use without WPA/WPA2 */ 433 wep_ok = !wpa_key_mgmt_wpa(ssid->key_mgmt) && 434 (((ssid->key_mgmt & WPA_KEY_MGMT_NONE) && 435 ssid->wep_key_len[ssid->wep_tx_keyidx] > 0) || 436 (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)); 437 438 rsn_ie = wpa_bss_get_ie(bss, WLAN_EID_RSN); 439 while ((ssid->proto & WPA_PROTO_RSN) && rsn_ie) { 440 proto_match++; 441 442 if (wpa_parse_wpa_ie(rsn_ie, 2 + rsn_ie[1], &ie)) { 443 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - parse " 444 "failed"); 445 break; 446 } 447 448 if (wep_ok && 449 (ie.group_cipher & (WPA_CIPHER_WEP40 | WPA_CIPHER_WEP104))) 450 { 451 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on TSN " 452 "in RSN IE"); 453 return 1; 454 } 455 456 if (!(ie.proto & ssid->proto)) { 457 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - proto " 458 "mismatch"); 459 break; 460 } 461 462 if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) { 463 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - PTK " 464 "cipher mismatch"); 465 break; 466 } 467 468 if (!(ie.group_cipher & ssid->group_cipher)) { 469 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - GTK " 470 "cipher mismatch"); 471 break; 472 } 473 474 if (!(ie.key_mgmt & ssid->key_mgmt)) { 475 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - key mgmt " 476 "mismatch"); 477 break; 478 } 479 480 #ifdef CONFIG_IEEE80211W 481 if (!(ie.capabilities & WPA_CAPABILITY_MFPC) && 482 (ssid->ieee80211w == MGMT_FRAME_PROTECTION_DEFAULT ? 483 wpa_s->conf->pmf : ssid->ieee80211w) == 484 MGMT_FRAME_PROTECTION_REQUIRED) { 485 wpa_dbg(wpa_s, MSG_DEBUG, " skip RSN IE - no mgmt " 486 "frame protection"); 487 break; 488 } 489 #endif /* CONFIG_IEEE80211W */ 490 491 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on RSN IE"); 492 return 1; 493 } 494 495 wpa_ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE); 496 while ((ssid->proto & WPA_PROTO_WPA) && wpa_ie) { 497 proto_match++; 498 499 if (wpa_parse_wpa_ie(wpa_ie, 2 + wpa_ie[1], &ie)) { 500 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - parse " 501 "failed"); 502 break; 503 } 504 505 if (wep_ok && 506 (ie.group_cipher & (WPA_CIPHER_WEP40 | WPA_CIPHER_WEP104))) 507 { 508 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on TSN " 509 "in WPA IE"); 510 return 1; 511 } 512 513 if (!(ie.proto & ssid->proto)) { 514 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - proto " 515 "mismatch"); 516 break; 517 } 518 519 if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) { 520 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - PTK " 521 "cipher mismatch"); 522 break; 523 } 524 525 if (!(ie.group_cipher & ssid->group_cipher)) { 526 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - GTK " 527 "cipher mismatch"); 528 break; 529 } 530 531 if (!(ie.key_mgmt & ssid->key_mgmt)) { 532 wpa_dbg(wpa_s, MSG_DEBUG, " skip WPA IE - key mgmt " 533 "mismatch"); 534 break; 535 } 536 537 wpa_dbg(wpa_s, MSG_DEBUG, " selected based on WPA IE"); 538 return 1; 539 } 540 541 if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && !wpa_ie && 542 !rsn_ie) { 543 wpa_dbg(wpa_s, MSG_DEBUG, " allow for non-WPA IEEE 802.1X"); 544 return 1; 545 } 546 547 if ((ssid->proto & (WPA_PROTO_WPA | WPA_PROTO_RSN)) && 548 wpa_key_mgmt_wpa(ssid->key_mgmt) && proto_match == 0) { 549 wpa_dbg(wpa_s, MSG_DEBUG, " skip - no WPA/RSN proto match"); 550 return 0; 551 } 552 553 if ((ssid->key_mgmt & WPA_KEY_MGMT_OSEN) && 554 wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE)) { 555 wpa_dbg(wpa_s, MSG_DEBUG, " allow in OSEN"); 556 return 1; 557 } 558 559 if (!wpa_key_mgmt_wpa(ssid->key_mgmt)) { 560 wpa_dbg(wpa_s, MSG_DEBUG, " allow in non-WPA/WPA2"); 561 return 1; 562 } 563 564 wpa_dbg(wpa_s, MSG_DEBUG, " reject due to mismatch with " 565 "WPA/WPA2"); 566 567 return 0; 568 } 569 570 571 static int freq_allowed(int *freqs, int freq) 572 { 573 int i; 574 575 if (freqs == NULL) 576 return 1; 577 578 for (i = 0; freqs[i]; i++) 579 if (freqs[i] == freq) 580 return 1; 581 return 0; 582 } 583 584 585 static int ht_supported(const struct hostapd_hw_modes *mode) 586 { 587 if (!(mode->flags & HOSTAPD_MODE_FLAG_HT_INFO_KNOWN)) { 588 /* 589 * The driver did not indicate whether it supports HT. Assume 590 * it does to avoid connection issues. 591 */ 592 return 1; 593 } 594 595 /* 596 * IEEE Std 802.11n-2009 20.1.1: 597 * An HT non-AP STA shall support all EQM rates for one spatial stream. 598 */ 599 return mode->mcs_set[0] == 0xff; 600 } 601 602 603 static int vht_supported(const struct hostapd_hw_modes *mode) 604 { 605 if (!(mode->flags & HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN)) { 606 /* 607 * The driver did not indicate whether it supports VHT. Assume 608 * it does to avoid connection issues. 609 */ 610 return 1; 611 } 612 613 /* 614 * A VHT non-AP STA shall support MCS 0-7 for one spatial stream. 615 * TODO: Verify if this complies with the standard 616 */ 617 return (mode->vht_mcs_set[0] & 0x3) != 3; 618 } 619 620 621 static int rate_match(struct wpa_supplicant *wpa_s, struct wpa_bss *bss) 622 { 623 const struct hostapd_hw_modes *mode = NULL, *modes; 624 const u8 scan_ie[2] = { WLAN_EID_SUPP_RATES, WLAN_EID_EXT_SUPP_RATES }; 625 const u8 *rate_ie; 626 int i, j, k; 627 628 if (bss->freq == 0) 629 return 1; /* Cannot do matching without knowing band */ 630 631 modes = wpa_s->hw.modes; 632 if (modes == NULL) { 633 /* 634 * The driver does not provide any additional information 635 * about the utilized hardware, so allow the connection attempt 636 * to continue. 637 */ 638 return 1; 639 } 640 641 for (i = 0; i < wpa_s->hw.num_modes; i++) { 642 for (j = 0; j < modes[i].num_channels; j++) { 643 int freq = modes[i].channels[j].freq; 644 if (freq == bss->freq) { 645 if (mode && 646 mode->mode == HOSTAPD_MODE_IEEE80211G) 647 break; /* do not allow 802.11b replace 648 * 802.11g */ 649 mode = &modes[i]; 650 break; 651 } 652 } 653 } 654 655 if (mode == NULL) 656 return 0; 657 658 for (i = 0; i < (int) sizeof(scan_ie); i++) { 659 rate_ie = wpa_bss_get_ie(bss, scan_ie[i]); 660 if (rate_ie == NULL) 661 continue; 662 663 for (j = 2; j < rate_ie[1] + 2; j++) { 664 int flagged = !!(rate_ie[j] & 0x80); 665 int r = (rate_ie[j] & 0x7f) * 5; 666 667 /* 668 * IEEE Std 802.11n-2009 7.3.2.2: 669 * The new BSS Membership selector value is encoded 670 * like a legacy basic rate, but it is not a rate and 671 * only indicates if the BSS members are required to 672 * support the mandatory features of Clause 20 [HT PHY] 673 * in order to join the BSS. 674 */ 675 if (flagged && ((rate_ie[j] & 0x7f) == 676 BSS_MEMBERSHIP_SELECTOR_HT_PHY)) { 677 if (!ht_supported(mode)) { 678 wpa_dbg(wpa_s, MSG_DEBUG, 679 " hardware does not support " 680 "HT PHY"); 681 return 0; 682 } 683 continue; 684 } 685 686 /* There's also a VHT selector for 802.11ac */ 687 if (flagged && ((rate_ie[j] & 0x7f) == 688 BSS_MEMBERSHIP_SELECTOR_VHT_PHY)) { 689 if (!vht_supported(mode)) { 690 wpa_dbg(wpa_s, MSG_DEBUG, 691 " hardware does not support " 692 "VHT PHY"); 693 return 0; 694 } 695 continue; 696 } 697 698 if (!flagged) 699 continue; 700 701 /* check for legacy basic rates */ 702 for (k = 0; k < mode->num_rates; k++) { 703 if (mode->rates[k] == r) 704 break; 705 } 706 if (k == mode->num_rates) { 707 /* 708 * IEEE Std 802.11-2007 7.3.2.2 demands that in 709 * order to join a BSS all required rates 710 * have to be supported by the hardware. 711 */ 712 wpa_dbg(wpa_s, MSG_DEBUG, " hardware does " 713 "not support required rate %d.%d Mbps", 714 r / 10, r % 10); 715 return 0; 716 } 717 } 718 } 719 720 return 1; 721 } 722 723 724 /* 725 * Test whether BSS is in an ESS. 726 * This is done differently in DMG (60 GHz) and non-DMG bands 727 */ 728 static int bss_is_ess(struct wpa_bss *bss) 729 { 730 if (bss_is_dmg(bss)) { 731 return (bss->caps & IEEE80211_CAP_DMG_MASK) == 732 IEEE80211_CAP_DMG_AP; 733 } 734 735 return ((bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) == 736 IEEE80211_CAP_ESS); 737 } 738 739 740 static struct wpa_ssid * wpa_scan_res_match(struct wpa_supplicant *wpa_s, 741 int i, struct wpa_bss *bss, 742 struct wpa_ssid *group, 743 int only_first_ssid) 744 { 745 u8 wpa_ie_len, rsn_ie_len; 746 int wpa; 747 struct wpa_blacklist *e; 748 const u8 *ie; 749 struct wpa_ssid *ssid; 750 int osen; 751 752 ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE); 753 wpa_ie_len = ie ? ie[1] : 0; 754 755 ie = wpa_bss_get_ie(bss, WLAN_EID_RSN); 756 rsn_ie_len = ie ? ie[1] : 0; 757 758 ie = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE); 759 osen = ie != NULL; 760 761 wpa_dbg(wpa_s, MSG_DEBUG, "%d: " MACSTR " ssid='%s' " 762 "wpa_ie_len=%u rsn_ie_len=%u caps=0x%x level=%d%s%s%s", 763 i, MAC2STR(bss->bssid), wpa_ssid_txt(bss->ssid, bss->ssid_len), 764 wpa_ie_len, rsn_ie_len, bss->caps, bss->level, 765 wpa_bss_get_vendor_ie(bss, WPS_IE_VENDOR_TYPE) ? " wps" : "", 766 (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) || 767 wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) ? 768 " p2p" : "", 769 osen ? " osen=1" : ""); 770 771 e = wpa_blacklist_get(wpa_s, bss->bssid); 772 if (e) { 773 int limit = 1; 774 if (wpa_supplicant_enabled_networks(wpa_s) == 1) { 775 /* 776 * When only a single network is enabled, we can 777 * trigger blacklisting on the first failure. This 778 * should not be done with multiple enabled networks to 779 * avoid getting forced to move into a worse ESS on 780 * single error if there are no other BSSes of the 781 * current ESS. 782 */ 783 limit = 0; 784 } 785 if (e->count > limit) { 786 wpa_dbg(wpa_s, MSG_DEBUG, " skip - blacklisted " 787 "(count=%d limit=%d)", e->count, limit); 788 return NULL; 789 } 790 } 791 792 if (bss->ssid_len == 0) { 793 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID not known"); 794 return NULL; 795 } 796 797 if (disallowed_bssid(wpa_s, bss->bssid)) { 798 wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID disallowed"); 799 return NULL; 800 } 801 802 if (disallowed_ssid(wpa_s, bss->ssid, bss->ssid_len)) { 803 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID disallowed"); 804 return NULL; 805 } 806 807 wpa = wpa_ie_len > 0 || rsn_ie_len > 0; 808 809 for (ssid = group; ssid; ssid = only_first_ssid ? NULL : ssid->pnext) { 810 int check_ssid = wpa ? 1 : (ssid->ssid_len != 0); 811 int res; 812 813 if (wpas_network_disabled(wpa_s, ssid)) { 814 wpa_dbg(wpa_s, MSG_DEBUG, " skip - disabled"); 815 continue; 816 } 817 818 res = wpas_temp_disabled(wpa_s, ssid); 819 if (res > 0) { 820 wpa_dbg(wpa_s, MSG_DEBUG, " skip - disabled " 821 "temporarily for %d second(s)", res); 822 continue; 823 } 824 825 #ifdef CONFIG_WPS 826 if ((ssid->key_mgmt & WPA_KEY_MGMT_WPS) && e && e->count > 0) { 827 wpa_dbg(wpa_s, MSG_DEBUG, " skip - blacklisted " 828 "(WPS)"); 829 continue; 830 } 831 832 if (wpa && ssid->ssid_len == 0 && 833 wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss)) 834 check_ssid = 0; 835 836 if (!wpa && (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) { 837 /* Only allow wildcard SSID match if an AP 838 * advertises active WPS operation that matches 839 * with our mode. */ 840 check_ssid = 1; 841 if (ssid->ssid_len == 0 && 842 wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss)) 843 check_ssid = 0; 844 } 845 #endif /* CONFIG_WPS */ 846 847 if (ssid->bssid_set && ssid->ssid_len == 0 && 848 os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) == 0) 849 check_ssid = 0; 850 851 if (check_ssid && 852 (bss->ssid_len != ssid->ssid_len || 853 os_memcmp(bss->ssid, ssid->ssid, bss->ssid_len) != 0)) { 854 wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID mismatch"); 855 continue; 856 } 857 858 if (ssid->bssid_set && 859 os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0) { 860 wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID mismatch"); 861 continue; 862 } 863 864 if (!wpa_supplicant_ssid_bss_match(wpa_s, ssid, bss)) 865 continue; 866 867 if (!osen && !wpa && 868 !(ssid->key_mgmt & WPA_KEY_MGMT_NONE) && 869 !(ssid->key_mgmt & WPA_KEY_MGMT_WPS) && 870 !(ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) { 871 wpa_dbg(wpa_s, MSG_DEBUG, " skip - non-WPA network " 872 "not allowed"); 873 continue; 874 } 875 876 if (wpa && !wpa_key_mgmt_wpa(ssid->key_mgmt) && 877 has_wep_key(ssid)) { 878 wpa_dbg(wpa_s, MSG_DEBUG, " skip - ignore WPA/WPA2 AP for WEP network block"); 879 continue; 880 } 881 882 if ((ssid->key_mgmt & WPA_KEY_MGMT_OSEN) && !osen) { 883 wpa_dbg(wpa_s, MSG_DEBUG, " skip - non-OSEN network " 884 "not allowed"); 885 continue; 886 } 887 888 if (!wpa_supplicant_match_privacy(bss, ssid)) { 889 wpa_dbg(wpa_s, MSG_DEBUG, " skip - privacy " 890 "mismatch"); 891 continue; 892 } 893 894 if (!bss_is_ess(bss)) { 895 wpa_dbg(wpa_s, MSG_DEBUG, " skip - not ESS network"); 896 continue; 897 } 898 899 if (!freq_allowed(ssid->freq_list, bss->freq)) { 900 wpa_dbg(wpa_s, MSG_DEBUG, " skip - frequency not " 901 "allowed"); 902 continue; 903 } 904 905 if (!rate_match(wpa_s, bss)) { 906 wpa_dbg(wpa_s, MSG_DEBUG, " skip - rate sets do " 907 "not match"); 908 continue; 909 } 910 911 #ifdef CONFIG_P2P 912 if (ssid->p2p_group && 913 !wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) && 914 !wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) { 915 wpa_dbg(wpa_s, MSG_DEBUG, " skip - no P2P IE seen"); 916 continue; 917 } 918 919 if (!is_zero_ether_addr(ssid->go_p2p_dev_addr)) { 920 struct wpabuf *p2p_ie; 921 u8 dev_addr[ETH_ALEN]; 922 923 ie = wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE); 924 if (ie == NULL) { 925 wpa_dbg(wpa_s, MSG_DEBUG, " skip - no P2P element"); 926 continue; 927 } 928 p2p_ie = wpa_bss_get_vendor_ie_multi( 929 bss, P2P_IE_VENDOR_TYPE); 930 if (p2p_ie == NULL) { 931 wpa_dbg(wpa_s, MSG_DEBUG, " skip - could not fetch P2P element"); 932 continue; 933 } 934 935 if (p2p_parse_dev_addr_in_p2p_ie(p2p_ie, dev_addr) < 0 936 || os_memcmp(dev_addr, ssid->go_p2p_dev_addr, 937 ETH_ALEN) != 0) { 938 wpa_dbg(wpa_s, MSG_DEBUG, " skip - no matching GO P2P Device Address in P2P element"); 939 wpabuf_free(p2p_ie); 940 continue; 941 } 942 wpabuf_free(p2p_ie); 943 } 944 945 /* 946 * TODO: skip the AP if its P2P IE has Group Formation 947 * bit set in the P2P Group Capability Bitmap and we 948 * are not in Group Formation with that device. 949 */ 950 #endif /* CONFIG_P2P */ 951 952 /* Matching configuration found */ 953 return ssid; 954 } 955 956 /* No matching configuration found */ 957 return NULL; 958 } 959 960 961 static struct wpa_bss * 962 wpa_supplicant_select_bss(struct wpa_supplicant *wpa_s, 963 struct wpa_ssid *group, 964 struct wpa_ssid **selected_ssid, 965 int only_first_ssid) 966 { 967 unsigned int i; 968 969 if (only_first_ssid) 970 wpa_dbg(wpa_s, MSG_DEBUG, "Try to find BSS matching pre-selected network id=%d", 971 group->id); 972 else 973 wpa_dbg(wpa_s, MSG_DEBUG, "Selecting BSS from priority group %d", 974 group->priority); 975 976 for (i = 0; i < wpa_s->last_scan_res_used; i++) { 977 struct wpa_bss *bss = wpa_s->last_scan_res[i]; 978 *selected_ssid = wpa_scan_res_match(wpa_s, i, bss, group, 979 only_first_ssid); 980 if (!*selected_ssid) 981 continue; 982 wpa_dbg(wpa_s, MSG_DEBUG, " selected BSS " MACSTR 983 " ssid='%s'", 984 MAC2STR(bss->bssid), 985 wpa_ssid_txt(bss->ssid, bss->ssid_len)); 986 return bss; 987 } 988 989 return NULL; 990 } 991 992 993 struct wpa_bss * wpa_supplicant_pick_network(struct wpa_supplicant *wpa_s, 994 struct wpa_ssid **selected_ssid) 995 { 996 struct wpa_bss *selected = NULL; 997 int prio; 998 struct wpa_ssid *next_ssid = NULL; 999 1000 if (wpa_s->last_scan_res == NULL || 1001 wpa_s->last_scan_res_used == 0) 1002 return NULL; /* no scan results from last update */ 1003 1004 if (wpa_s->next_ssid) { 1005 struct wpa_ssid *ssid; 1006 1007 /* check that next_ssid is still valid */ 1008 for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) { 1009 if (ssid == wpa_s->next_ssid) 1010 break; 1011 } 1012 next_ssid = ssid; 1013 wpa_s->next_ssid = NULL; 1014 } 1015 1016 while (selected == NULL) { 1017 for (prio = 0; prio < wpa_s->conf->num_prio; prio++) { 1018 if (next_ssid && next_ssid->priority == 1019 wpa_s->conf->pssid[prio]->priority) { 1020 selected = wpa_supplicant_select_bss( 1021 wpa_s, next_ssid, selected_ssid, 1); 1022 if (selected) 1023 break; 1024 } 1025 selected = wpa_supplicant_select_bss( 1026 wpa_s, wpa_s->conf->pssid[prio], 1027 selected_ssid, 0); 1028 if (selected) 1029 break; 1030 } 1031 1032 if (selected == NULL && wpa_s->blacklist && 1033 !wpa_s->countermeasures) { 1034 wpa_dbg(wpa_s, MSG_DEBUG, "No APs found - clear " 1035 "blacklist and try again"); 1036 wpa_blacklist_clear(wpa_s); 1037 wpa_s->blacklist_cleared++; 1038 } else if (selected == NULL) 1039 break; 1040 } 1041 1042 return selected; 1043 } 1044 1045 1046 static void wpa_supplicant_req_new_scan(struct wpa_supplicant *wpa_s, 1047 int timeout_sec, int timeout_usec) 1048 { 1049 if (!wpa_supplicant_enabled_networks(wpa_s)) { 1050 /* 1051 * No networks are enabled; short-circuit request so 1052 * we don't wait timeout seconds before transitioning 1053 * to INACTIVE state. 1054 */ 1055 wpa_dbg(wpa_s, MSG_DEBUG, "Short-circuit new scan request " 1056 "since there are no enabled networks"); 1057 wpa_supplicant_set_state(wpa_s, WPA_INACTIVE); 1058 return; 1059 } 1060 1061 wpa_s->scan_for_connection = 1; 1062 wpa_supplicant_req_scan(wpa_s, timeout_sec, timeout_usec); 1063 } 1064 1065 1066 int wpa_supplicant_connect(struct wpa_supplicant *wpa_s, 1067 struct wpa_bss *selected, 1068 struct wpa_ssid *ssid) 1069 { 1070 if (wpas_wps_scan_pbc_overlap(wpa_s, selected, ssid)) { 1071 wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_OVERLAP 1072 "PBC session overlap"); 1073 #ifdef CONFIG_P2P 1074 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT || 1075 wpa_s->p2p_in_provisioning) { 1076 eloop_register_timeout(0, 0, wpas_p2p_pbc_overlap_cb, 1077 wpa_s, NULL); 1078 return -1; 1079 } 1080 #endif /* CONFIG_P2P */ 1081 1082 #ifdef CONFIG_WPS 1083 wpas_wps_cancel(wpa_s); 1084 #endif /* CONFIG_WPS */ 1085 return -1; 1086 } 1087 1088 wpa_msg(wpa_s, MSG_DEBUG, 1089 "Considering connect request: reassociate: %d selected: " 1090 MACSTR " bssid: " MACSTR " pending: " MACSTR 1091 " wpa_state: %s ssid=%p current_ssid=%p", 1092 wpa_s->reassociate, MAC2STR(selected->bssid), 1093 MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid), 1094 wpa_supplicant_state_txt(wpa_s->wpa_state), 1095 ssid, wpa_s->current_ssid); 1096 1097 /* 1098 * Do not trigger new association unless the BSSID has changed or if 1099 * reassociation is requested. If we are in process of associating with 1100 * the selected BSSID, do not trigger new attempt. 1101 */ 1102 if (wpa_s->reassociate || 1103 (os_memcmp(selected->bssid, wpa_s->bssid, ETH_ALEN) != 0 && 1104 ((wpa_s->wpa_state != WPA_ASSOCIATING && 1105 wpa_s->wpa_state != WPA_AUTHENTICATING) || 1106 (!is_zero_ether_addr(wpa_s->pending_bssid) && 1107 os_memcmp(selected->bssid, wpa_s->pending_bssid, ETH_ALEN) != 1108 0) || 1109 (is_zero_ether_addr(wpa_s->pending_bssid) && 1110 ssid != wpa_s->current_ssid)))) { 1111 if (wpa_supplicant_scard_init(wpa_s, ssid)) { 1112 wpa_supplicant_req_new_scan(wpa_s, 10, 0); 1113 return 0; 1114 } 1115 wpa_msg(wpa_s, MSG_DEBUG, "Request association with " MACSTR, 1116 MAC2STR(selected->bssid)); 1117 wpa_supplicant_associate(wpa_s, selected, ssid); 1118 } else { 1119 wpa_dbg(wpa_s, MSG_DEBUG, "Already associated or trying to " 1120 "connect with the selected AP"); 1121 } 1122 1123 return 0; 1124 } 1125 1126 1127 static struct wpa_ssid * 1128 wpa_supplicant_pick_new_network(struct wpa_supplicant *wpa_s) 1129 { 1130 int prio; 1131 struct wpa_ssid *ssid; 1132 1133 for (prio = 0; prio < wpa_s->conf->num_prio; prio++) { 1134 for (ssid = wpa_s->conf->pssid[prio]; ssid; ssid = ssid->pnext) 1135 { 1136 if (wpas_network_disabled(wpa_s, ssid)) 1137 continue; 1138 if (ssid->mode == IEEE80211_MODE_IBSS || 1139 ssid->mode == IEEE80211_MODE_AP) 1140 return ssid; 1141 } 1142 } 1143 return NULL; 1144 } 1145 1146 1147 /* TODO: move the rsn_preauth_scan_result*() to be called from notify.c based 1148 * on BSS added and BSS changed events */ 1149 static void wpa_supplicant_rsn_preauth_scan_results( 1150 struct wpa_supplicant *wpa_s) 1151 { 1152 struct wpa_bss *bss; 1153 1154 if (rsn_preauth_scan_results(wpa_s->wpa) < 0) 1155 return; 1156 1157 dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) { 1158 const u8 *ssid, *rsn; 1159 1160 ssid = wpa_bss_get_ie(bss, WLAN_EID_SSID); 1161 if (ssid == NULL) 1162 continue; 1163 1164 rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN); 1165 if (rsn == NULL) 1166 continue; 1167 1168 rsn_preauth_scan_result(wpa_s->wpa, bss->bssid, ssid, rsn); 1169 } 1170 1171 } 1172 1173 1174 static int wpa_supplicant_need_to_roam(struct wpa_supplicant *wpa_s, 1175 struct wpa_bss *selected, 1176 struct wpa_ssid *ssid) 1177 { 1178 struct wpa_bss *current_bss = NULL; 1179 int min_diff; 1180 1181 if (wpa_s->reassociate) 1182 return 1; /* explicit request to reassociate */ 1183 if (wpa_s->wpa_state < WPA_ASSOCIATED) 1184 return 1; /* we are not associated; continue */ 1185 if (wpa_s->current_ssid == NULL) 1186 return 1; /* unknown current SSID */ 1187 if (wpa_s->current_ssid != ssid) 1188 return 1; /* different network block */ 1189 1190 if (wpas_driver_bss_selection(wpa_s)) 1191 return 0; /* Driver-based roaming */ 1192 1193 if (wpa_s->current_ssid->ssid) 1194 current_bss = wpa_bss_get(wpa_s, wpa_s->bssid, 1195 wpa_s->current_ssid->ssid, 1196 wpa_s->current_ssid->ssid_len); 1197 if (!current_bss) 1198 current_bss = wpa_bss_get_bssid(wpa_s, wpa_s->bssid); 1199 1200 if (!current_bss) 1201 return 1; /* current BSS not seen in scan results */ 1202 1203 if (current_bss == selected) 1204 return 0; 1205 1206 if (selected->last_update_idx > current_bss->last_update_idx) 1207 return 1; /* current BSS not seen in the last scan */ 1208 1209 #ifndef CONFIG_NO_ROAMING 1210 wpa_dbg(wpa_s, MSG_DEBUG, "Considering within-ESS reassociation"); 1211 wpa_dbg(wpa_s, MSG_DEBUG, "Current BSS: " MACSTR " level=%d", 1212 MAC2STR(current_bss->bssid), current_bss->level); 1213 wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS: " MACSTR " level=%d", 1214 MAC2STR(selected->bssid), selected->level); 1215 1216 if (wpa_s->current_ssid->bssid_set && 1217 os_memcmp(selected->bssid, wpa_s->current_ssid->bssid, ETH_ALEN) == 1218 0) { 1219 wpa_dbg(wpa_s, MSG_DEBUG, "Allow reassociation - selected BSS " 1220 "has preferred BSSID"); 1221 return 1; 1222 } 1223 1224 if (current_bss->level < 0 && current_bss->level > selected->level) { 1225 wpa_dbg(wpa_s, MSG_DEBUG, "Skip roam - Current BSS has better " 1226 "signal level"); 1227 return 0; 1228 } 1229 1230 min_diff = 2; 1231 if (current_bss->level < 0) { 1232 if (current_bss->level < -85) 1233 min_diff = 1; 1234 else if (current_bss->level < -80) 1235 min_diff = 2; 1236 else if (current_bss->level < -75) 1237 min_diff = 3; 1238 else if (current_bss->level < -70) 1239 min_diff = 4; 1240 else 1241 min_diff = 5; 1242 } 1243 if (abs(current_bss->level - selected->level) < min_diff) { 1244 wpa_dbg(wpa_s, MSG_DEBUG, "Skip roam - too small difference " 1245 "in signal level"); 1246 return 0; 1247 } 1248 1249 return 1; 1250 #else /* CONFIG_NO_ROAMING */ 1251 return 0; 1252 #endif /* CONFIG_NO_ROAMING */ 1253 } 1254 1255 1256 /* Return != 0 if no scan results could be fetched or if scan results should not 1257 * be shared with other virtual interfaces. */ 1258 static int _wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s, 1259 union wpa_event_data *data, 1260 int own_request) 1261 { 1262 struct wpa_scan_results *scan_res = NULL; 1263 int ret = 0; 1264 int ap = 0; 1265 #ifndef CONFIG_NO_RANDOM_POOL 1266 size_t i, num; 1267 #endif /* CONFIG_NO_RANDOM_POOL */ 1268 1269 #ifdef CONFIG_AP 1270 if (wpa_s->ap_iface) 1271 ap = 1; 1272 #endif /* CONFIG_AP */ 1273 1274 wpa_supplicant_notify_scanning(wpa_s, 0); 1275 1276 scan_res = wpa_supplicant_get_scan_results(wpa_s, 1277 data ? &data->scan_info : 1278 NULL, 1); 1279 if (scan_res == NULL) { 1280 if (wpa_s->conf->ap_scan == 2 || ap || 1281 wpa_s->scan_res_handler == scan_only_handler) 1282 return -1; 1283 if (!own_request) 1284 return -1; 1285 wpa_dbg(wpa_s, MSG_DEBUG, "Failed to get scan results - try " 1286 "scanning again"); 1287 wpa_supplicant_req_new_scan(wpa_s, 1, 0); 1288 ret = -1; 1289 goto scan_work_done; 1290 } 1291 1292 #ifndef CONFIG_NO_RANDOM_POOL 1293 num = scan_res->num; 1294 if (num > 10) 1295 num = 10; 1296 for (i = 0; i < num; i++) { 1297 u8 buf[5]; 1298 struct wpa_scan_res *res = scan_res->res[i]; 1299 buf[0] = res->bssid[5]; 1300 buf[1] = res->qual & 0xff; 1301 buf[2] = res->noise & 0xff; 1302 buf[3] = res->level & 0xff; 1303 buf[4] = res->tsf & 0xff; 1304 random_add_randomness(buf, sizeof(buf)); 1305 } 1306 #endif /* CONFIG_NO_RANDOM_POOL */ 1307 1308 if (own_request && wpa_s->scan_res_handler && 1309 (wpa_s->own_scan_running || !wpa_s->external_scan_running)) { 1310 void (*scan_res_handler)(struct wpa_supplicant *wpa_s, 1311 struct wpa_scan_results *scan_res); 1312 1313 scan_res_handler = wpa_s->scan_res_handler; 1314 wpa_s->scan_res_handler = NULL; 1315 scan_res_handler(wpa_s, scan_res); 1316 ret = -2; 1317 goto scan_work_done; 1318 } 1319 1320 if (ap) { 1321 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore scan results in AP mode"); 1322 #ifdef CONFIG_AP 1323 if (wpa_s->ap_iface->scan_cb) 1324 wpa_s->ap_iface->scan_cb(wpa_s->ap_iface); 1325 #endif /* CONFIG_AP */ 1326 goto scan_work_done; 1327 } 1328 1329 wpa_dbg(wpa_s, MSG_DEBUG, "New scan results available (own=%u ext=%u)", 1330 wpa_s->own_scan_running, wpa_s->external_scan_running); 1331 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ && 1332 wpa_s->manual_scan_use_id && wpa_s->own_scan_running) { 1333 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS "id=%u", 1334 wpa_s->manual_scan_id); 1335 wpa_s->manual_scan_use_id = 0; 1336 } else { 1337 wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS); 1338 } 1339 wpas_notify_scan_results(wpa_s); 1340 1341 wpas_notify_scan_done(wpa_s, 1); 1342 1343 if (!wpa_s->own_scan_running && wpa_s->external_scan_running) { 1344 wpa_dbg(wpa_s, MSG_DEBUG, "Do not use results from externally requested scan operation for network selection"); 1345 wpa_scan_results_free(scan_res); 1346 return 0; 1347 } 1348 1349 if (sme_proc_obss_scan(wpa_s) > 0) 1350 goto scan_work_done; 1351 1352 if ((wpa_s->conf->ap_scan == 2 && !wpas_wps_searching(wpa_s))) 1353 goto scan_work_done; 1354 1355 if (autoscan_notify_scan(wpa_s, scan_res)) 1356 goto scan_work_done; 1357 1358 if (wpa_s->disconnected) { 1359 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 1360 goto scan_work_done; 1361 } 1362 1363 if (!wpas_driver_bss_selection(wpa_s) && 1364 bgscan_notify_scan(wpa_s, scan_res) == 1) 1365 goto scan_work_done; 1366 1367 wpas_wps_update_ap_info(wpa_s, scan_res); 1368 1369 wpa_scan_results_free(scan_res); 1370 1371 if (wpa_s->scan_work) { 1372 struct wpa_radio_work *work = wpa_s->scan_work; 1373 wpa_s->scan_work = NULL; 1374 radio_work_done(work); 1375 } 1376 1377 return wpas_select_network_from_last_scan(wpa_s, 1, own_request); 1378 1379 scan_work_done: 1380 wpa_scan_results_free(scan_res); 1381 if (wpa_s->scan_work) { 1382 struct wpa_radio_work *work = wpa_s->scan_work; 1383 wpa_s->scan_work = NULL; 1384 radio_work_done(work); 1385 } 1386 return ret; 1387 } 1388 1389 1390 static int wpas_select_network_from_last_scan(struct wpa_supplicant *wpa_s, 1391 int new_scan, int own_request) 1392 { 1393 struct wpa_bss *selected; 1394 struct wpa_ssid *ssid = NULL; 1395 1396 selected = wpa_supplicant_pick_network(wpa_s, &ssid); 1397 1398 if (selected) { 1399 int skip; 1400 skip = !wpa_supplicant_need_to_roam(wpa_s, selected, ssid); 1401 if (skip) { 1402 if (new_scan) 1403 wpa_supplicant_rsn_preauth_scan_results(wpa_s); 1404 return 0; 1405 } 1406 1407 if (wpa_supplicant_connect(wpa_s, selected, ssid) < 0) { 1408 wpa_dbg(wpa_s, MSG_DEBUG, "Connect failed"); 1409 return -1; 1410 } 1411 if (new_scan) 1412 wpa_supplicant_rsn_preauth_scan_results(wpa_s); 1413 /* 1414 * Do not notify other virtual radios of scan results since we do not 1415 * want them to start other associations at the same time. 1416 */ 1417 return 1; 1418 } else { 1419 wpa_dbg(wpa_s, MSG_DEBUG, "No suitable network found"); 1420 ssid = wpa_supplicant_pick_new_network(wpa_s); 1421 if (ssid) { 1422 wpa_dbg(wpa_s, MSG_DEBUG, "Setup a new network"); 1423 wpa_supplicant_associate(wpa_s, NULL, ssid); 1424 if (new_scan) 1425 wpa_supplicant_rsn_preauth_scan_results(wpa_s); 1426 } else if (own_request) { 1427 /* 1428 * No SSID found. If SCAN results are as a result of 1429 * own scan request and not due to a scan request on 1430 * another shared interface, try another scan. 1431 */ 1432 int timeout_sec = wpa_s->scan_interval; 1433 int timeout_usec = 0; 1434 #ifdef CONFIG_P2P 1435 if (wpas_p2p_scan_no_go_seen(wpa_s) == 1) 1436 return 0; 1437 1438 if (wpa_s->p2p_in_provisioning || 1439 wpa_s->show_group_started || 1440 wpa_s->p2p_in_invitation) { 1441 /* 1442 * Use shorter wait during P2P Provisioning 1443 * state and during P2P join-a-group operation 1444 * to speed up group formation. 1445 */ 1446 timeout_sec = 0; 1447 timeout_usec = 250000; 1448 wpa_supplicant_req_new_scan(wpa_s, timeout_sec, 1449 timeout_usec); 1450 return 0; 1451 } 1452 #endif /* CONFIG_P2P */ 1453 #ifdef CONFIG_INTERWORKING 1454 if (wpa_s->conf->auto_interworking && 1455 wpa_s->conf->interworking && 1456 wpa_s->conf->cred) { 1457 wpa_dbg(wpa_s, MSG_DEBUG, "Interworking: " 1458 "start ANQP fetch since no matching " 1459 "networks found"); 1460 wpa_s->network_select = 1; 1461 wpa_s->auto_network_select = 1; 1462 interworking_start_fetch_anqp(wpa_s); 1463 return 1; 1464 } 1465 #endif /* CONFIG_INTERWORKING */ 1466 #ifdef CONFIG_WPS 1467 if (wpa_s->after_wps > 0 || wpas_wps_searching(wpa_s)) { 1468 wpa_dbg(wpa_s, MSG_DEBUG, "Use shorter wait during WPS processing"); 1469 timeout_sec = 0; 1470 timeout_usec = 500000; 1471 wpa_supplicant_req_new_scan(wpa_s, timeout_sec, 1472 timeout_usec); 1473 return 0; 1474 } 1475 #endif /* CONFIG_WPS */ 1476 if (wpa_supplicant_req_sched_scan(wpa_s)) 1477 wpa_supplicant_req_new_scan(wpa_s, timeout_sec, 1478 timeout_usec); 1479 } 1480 } 1481 return 0; 1482 } 1483 1484 1485 static void wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s, 1486 union wpa_event_data *data) 1487 { 1488 struct wpa_supplicant *ifs; 1489 1490 if (_wpa_supplicant_event_scan_results(wpa_s, data, 1) != 0) { 1491 /* 1492 * If no scan results could be fetched, then no need to 1493 * notify those interfaces that did not actually request 1494 * this scan. Similarly, if scan results started a new operation on this 1495 * interface, do not notify other interfaces to avoid concurrent 1496 * operations during a connection attempt. 1497 */ 1498 return; 1499 } 1500 1501 /* 1502 * Check other interfaces to see if they share the same radio. If 1503 * so, they get updated with this same scan info. 1504 */ 1505 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant, 1506 radio_list) { 1507 if (ifs != wpa_s) { 1508 wpa_printf(MSG_DEBUG, "%s: Updating scan results from " 1509 "sibling", ifs->ifname); 1510 _wpa_supplicant_event_scan_results(ifs, data, 0); 1511 } 1512 } 1513 } 1514 1515 #endif /* CONFIG_NO_SCAN_PROCESSING */ 1516 1517 1518 int wpa_supplicant_fast_associate(struct wpa_supplicant *wpa_s) 1519 { 1520 #ifdef CONFIG_NO_SCAN_PROCESSING 1521 return -1; 1522 #else /* CONFIG_NO_SCAN_PROCESSING */ 1523 struct os_reltime now; 1524 1525 if (wpa_s->last_scan_res_used <= 0) 1526 return -1; 1527 1528 os_get_reltime(&now); 1529 if (os_reltime_expired(&now, &wpa_s->last_scan, 5)) { 1530 wpa_printf(MSG_DEBUG, "Fast associate: Old scan results"); 1531 return -1; 1532 } 1533 1534 return wpas_select_network_from_last_scan(wpa_s, 0, 1); 1535 #endif /* CONFIG_NO_SCAN_PROCESSING */ 1536 } 1537 1538 #ifdef CONFIG_WNM 1539 1540 static void wnm_bss_keep_alive(void *eloop_ctx, void *sock_ctx) 1541 { 1542 struct wpa_supplicant *wpa_s = eloop_ctx; 1543 1544 if (wpa_s->wpa_state < WPA_ASSOCIATED) 1545 return; 1546 1547 if (!wpa_s->no_keep_alive) { 1548 wpa_printf(MSG_DEBUG, "WNM: Send keep-alive to AP " MACSTR, 1549 MAC2STR(wpa_s->bssid)); 1550 /* TODO: could skip this if normal data traffic has been sent */ 1551 /* TODO: Consider using some more appropriate data frame for 1552 * this */ 1553 if (wpa_s->l2) 1554 l2_packet_send(wpa_s->l2, wpa_s->bssid, 0x0800, 1555 (u8 *) "", 0); 1556 } 1557 1558 #ifdef CONFIG_SME 1559 if (wpa_s->sme.bss_max_idle_period) { 1560 unsigned int msec; 1561 msec = wpa_s->sme.bss_max_idle_period * 1024; /* times 1000 */ 1562 if (msec > 100) 1563 msec -= 100; 1564 eloop_register_timeout(msec / 1000, msec % 1000 * 1000, 1565 wnm_bss_keep_alive, wpa_s, NULL); 1566 } 1567 #endif /* CONFIG_SME */ 1568 } 1569 1570 1571 static void wnm_process_assoc_resp(struct wpa_supplicant *wpa_s, 1572 const u8 *ies, size_t ies_len) 1573 { 1574 struct ieee802_11_elems elems; 1575 1576 if (ies == NULL) 1577 return; 1578 1579 if (ieee802_11_parse_elems(ies, ies_len, &elems, 1) == ParseFailed) 1580 return; 1581 1582 #ifdef CONFIG_SME 1583 if (elems.bss_max_idle_period) { 1584 unsigned int msec; 1585 wpa_s->sme.bss_max_idle_period = 1586 WPA_GET_LE16(elems.bss_max_idle_period); 1587 wpa_printf(MSG_DEBUG, "WNM: BSS Max Idle Period: %u (* 1000 " 1588 "TU)%s", wpa_s->sme.bss_max_idle_period, 1589 (elems.bss_max_idle_period[2] & 0x01) ? 1590 " (protected keep-live required)" : ""); 1591 if (wpa_s->sme.bss_max_idle_period == 0) 1592 wpa_s->sme.bss_max_idle_period = 1; 1593 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) { 1594 eloop_cancel_timeout(wnm_bss_keep_alive, wpa_s, NULL); 1595 /* msec times 1000 */ 1596 msec = wpa_s->sme.bss_max_idle_period * 1024; 1597 if (msec > 100) 1598 msec -= 100; 1599 eloop_register_timeout(msec / 1000, msec % 1000 * 1000, 1600 wnm_bss_keep_alive, wpa_s, 1601 NULL); 1602 } 1603 } 1604 #endif /* CONFIG_SME */ 1605 } 1606 1607 #endif /* CONFIG_WNM */ 1608 1609 1610 void wnm_bss_keep_alive_deinit(struct wpa_supplicant *wpa_s) 1611 { 1612 #ifdef CONFIG_WNM 1613 eloop_cancel_timeout(wnm_bss_keep_alive, wpa_s, NULL); 1614 #endif /* CONFIG_WNM */ 1615 } 1616 1617 1618 #ifdef CONFIG_INTERWORKING 1619 1620 static int wpas_qos_map_set(struct wpa_supplicant *wpa_s, const u8 *qos_map, 1621 size_t len) 1622 { 1623 int res; 1624 1625 wpa_hexdump(MSG_DEBUG, "Interworking: QoS Map Set", qos_map, len); 1626 res = wpa_drv_set_qos_map(wpa_s, qos_map, len); 1627 if (res) { 1628 wpa_printf(MSG_DEBUG, "Interworking: Failed to configure QoS Map Set to the driver"); 1629 } 1630 1631 return res; 1632 } 1633 1634 1635 static void interworking_process_assoc_resp(struct wpa_supplicant *wpa_s, 1636 const u8 *ies, size_t ies_len) 1637 { 1638 struct ieee802_11_elems elems; 1639 1640 if (ies == NULL) 1641 return; 1642 1643 if (ieee802_11_parse_elems(ies, ies_len, &elems, 1) == ParseFailed) 1644 return; 1645 1646 if (elems.qos_map_set) { 1647 wpas_qos_map_set(wpa_s, elems.qos_map_set, 1648 elems.qos_map_set_len); 1649 } 1650 } 1651 1652 #endif /* CONFIG_INTERWORKING */ 1653 1654 1655 static int wpa_supplicant_event_associnfo(struct wpa_supplicant *wpa_s, 1656 union wpa_event_data *data) 1657 { 1658 int l, len, found = 0, wpa_found, rsn_found; 1659 const u8 *p; 1660 #ifdef CONFIG_IEEE80211R 1661 u8 bssid[ETH_ALEN]; 1662 #endif /* CONFIG_IEEE80211R */ 1663 1664 wpa_dbg(wpa_s, MSG_DEBUG, "Association info event"); 1665 if (data->assoc_info.req_ies) 1666 wpa_hexdump(MSG_DEBUG, "req_ies", data->assoc_info.req_ies, 1667 data->assoc_info.req_ies_len); 1668 if (data->assoc_info.resp_ies) { 1669 wpa_hexdump(MSG_DEBUG, "resp_ies", data->assoc_info.resp_ies, 1670 data->assoc_info.resp_ies_len); 1671 #ifdef CONFIG_TDLS 1672 wpa_tdls_assoc_resp_ies(wpa_s->wpa, data->assoc_info.resp_ies, 1673 data->assoc_info.resp_ies_len); 1674 #endif /* CONFIG_TDLS */ 1675 #ifdef CONFIG_WNM 1676 wnm_process_assoc_resp(wpa_s, data->assoc_info.resp_ies, 1677 data->assoc_info.resp_ies_len); 1678 #endif /* CONFIG_WNM */ 1679 #ifdef CONFIG_INTERWORKING 1680 interworking_process_assoc_resp(wpa_s, data->assoc_info.resp_ies, 1681 data->assoc_info.resp_ies_len); 1682 #endif /* CONFIG_INTERWORKING */ 1683 } 1684 if (data->assoc_info.beacon_ies) 1685 wpa_hexdump(MSG_DEBUG, "beacon_ies", 1686 data->assoc_info.beacon_ies, 1687 data->assoc_info.beacon_ies_len); 1688 if (data->assoc_info.freq) 1689 wpa_dbg(wpa_s, MSG_DEBUG, "freq=%u MHz", 1690 data->assoc_info.freq); 1691 1692 p = data->assoc_info.req_ies; 1693 l = data->assoc_info.req_ies_len; 1694 1695 /* Go through the IEs and make a copy of the WPA/RSN IE, if present. */ 1696 while (p && l >= 2) { 1697 len = p[1] + 2; 1698 if (len > l) { 1699 wpa_hexdump(MSG_DEBUG, "Truncated IE in assoc_info", 1700 p, l); 1701 break; 1702 } 1703 if ((p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 6 && 1704 (os_memcmp(&p[2], "\x00\x50\xF2\x01\x01\x00", 6) == 0)) || 1705 (p[0] == WLAN_EID_RSN && p[1] >= 2)) { 1706 if (wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, p, len)) 1707 break; 1708 found = 1; 1709 wpa_find_assoc_pmkid(wpa_s); 1710 break; 1711 } 1712 l -= len; 1713 p += len; 1714 } 1715 if (!found && data->assoc_info.req_ies) 1716 wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0); 1717 1718 #ifdef CONFIG_IEEE80211R 1719 #ifdef CONFIG_SME 1720 if (wpa_s->sme.auth_alg == WPA_AUTH_ALG_FT) { 1721 if (wpa_drv_get_bssid(wpa_s, bssid) < 0 || 1722 wpa_ft_validate_reassoc_resp(wpa_s->wpa, 1723 data->assoc_info.resp_ies, 1724 data->assoc_info.resp_ies_len, 1725 bssid) < 0) { 1726 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of " 1727 "Reassociation Response failed"); 1728 wpa_supplicant_deauthenticate( 1729 wpa_s, WLAN_REASON_INVALID_IE); 1730 return -1; 1731 } 1732 } 1733 1734 p = data->assoc_info.resp_ies; 1735 l = data->assoc_info.resp_ies_len; 1736 1737 #ifdef CONFIG_WPS_STRICT 1738 if (p && wpa_s->current_ssid && 1739 wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_WPS) { 1740 struct wpabuf *wps; 1741 wps = ieee802_11_vendor_ie_concat(p, l, WPS_IE_VENDOR_TYPE); 1742 if (wps == NULL) { 1743 wpa_msg(wpa_s, MSG_INFO, "WPS-STRICT: AP did not " 1744 "include WPS IE in (Re)Association Response"); 1745 return -1; 1746 } 1747 1748 if (wps_validate_assoc_resp(wps) < 0) { 1749 wpabuf_free(wps); 1750 wpa_supplicant_deauthenticate( 1751 wpa_s, WLAN_REASON_INVALID_IE); 1752 return -1; 1753 } 1754 wpabuf_free(wps); 1755 } 1756 #endif /* CONFIG_WPS_STRICT */ 1757 1758 /* Go through the IEs and make a copy of the MDIE, if present. */ 1759 while (p && l >= 2) { 1760 len = p[1] + 2; 1761 if (len > l) { 1762 wpa_hexdump(MSG_DEBUG, "Truncated IE in assoc_info", 1763 p, l); 1764 break; 1765 } 1766 if (p[0] == WLAN_EID_MOBILITY_DOMAIN && 1767 p[1] >= MOBILITY_DOMAIN_ID_LEN) { 1768 wpa_s->sme.ft_used = 1; 1769 os_memcpy(wpa_s->sme.mobility_domain, p + 2, 1770 MOBILITY_DOMAIN_ID_LEN); 1771 break; 1772 } 1773 l -= len; 1774 p += len; 1775 } 1776 #endif /* CONFIG_SME */ 1777 1778 /* Process FT when SME is in the driver */ 1779 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) && 1780 wpa_ft_is_completed(wpa_s->wpa)) { 1781 if (wpa_drv_get_bssid(wpa_s, bssid) < 0 || 1782 wpa_ft_validate_reassoc_resp(wpa_s->wpa, 1783 data->assoc_info.resp_ies, 1784 data->assoc_info.resp_ies_len, 1785 bssid) < 0) { 1786 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of " 1787 "Reassociation Response failed"); 1788 wpa_supplicant_deauthenticate( 1789 wpa_s, WLAN_REASON_INVALID_IE); 1790 return -1; 1791 } 1792 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Reassociation Response done"); 1793 } 1794 1795 wpa_sm_set_ft_params(wpa_s->wpa, data->assoc_info.resp_ies, 1796 data->assoc_info.resp_ies_len); 1797 #endif /* CONFIG_IEEE80211R */ 1798 1799 /* WPA/RSN IE from Beacon/ProbeResp */ 1800 p = data->assoc_info.beacon_ies; 1801 l = data->assoc_info.beacon_ies_len; 1802 1803 /* Go through the IEs and make a copy of the WPA/RSN IEs, if present. 1804 */ 1805 wpa_found = rsn_found = 0; 1806 while (p && l >= 2) { 1807 len = p[1] + 2; 1808 if (len > l) { 1809 wpa_hexdump(MSG_DEBUG, "Truncated IE in beacon_ies", 1810 p, l); 1811 break; 1812 } 1813 if (!wpa_found && 1814 p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 6 && 1815 os_memcmp(&p[2], "\x00\x50\xF2\x01\x01\x00", 6) == 0) { 1816 wpa_found = 1; 1817 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, p, len); 1818 } 1819 1820 if (!rsn_found && 1821 p[0] == WLAN_EID_RSN && p[1] >= 2) { 1822 rsn_found = 1; 1823 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, p, len); 1824 } 1825 1826 l -= len; 1827 p += len; 1828 } 1829 1830 if (!wpa_found && data->assoc_info.beacon_ies) 1831 wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0); 1832 if (!rsn_found && data->assoc_info.beacon_ies) 1833 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0); 1834 if (wpa_found || rsn_found) 1835 wpa_s->ap_ies_from_associnfo = 1; 1836 1837 if (wpa_s->assoc_freq && data->assoc_info.freq && 1838 wpa_s->assoc_freq != data->assoc_info.freq) { 1839 wpa_printf(MSG_DEBUG, "Operating frequency changed from " 1840 "%u to %u MHz", 1841 wpa_s->assoc_freq, data->assoc_info.freq); 1842 wpa_supplicant_update_scan_results(wpa_s); 1843 } 1844 1845 wpa_s->assoc_freq = data->assoc_info.freq; 1846 1847 return 0; 1848 } 1849 1850 1851 static int wpa_supplicant_assoc_update_ie(struct wpa_supplicant *wpa_s) 1852 { 1853 const u8 *bss_wpa = NULL, *bss_rsn = NULL; 1854 1855 if (!wpa_s->current_bss || !wpa_s->current_ssid) 1856 return -1; 1857 1858 if (!wpa_key_mgmt_wpa_any(wpa_s->current_ssid->key_mgmt)) 1859 return 0; 1860 1861 bss_wpa = wpa_bss_get_vendor_ie(wpa_s->current_bss, 1862 WPA_IE_VENDOR_TYPE); 1863 bss_rsn = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_RSN); 1864 1865 if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa, 1866 bss_wpa ? 2 + bss_wpa[1] : 0) || 1867 wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn, 1868 bss_rsn ? 2 + bss_rsn[1] : 0)) 1869 return -1; 1870 1871 return 0; 1872 } 1873 1874 1875 static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s, 1876 union wpa_event_data *data) 1877 { 1878 u8 bssid[ETH_ALEN]; 1879 int ft_completed; 1880 1881 #ifdef CONFIG_AP 1882 if (wpa_s->ap_iface) { 1883 if (!data) 1884 return; 1885 hostapd_notif_assoc(wpa_s->ap_iface->bss[0], 1886 data->assoc_info.addr, 1887 data->assoc_info.req_ies, 1888 data->assoc_info.req_ies_len, 1889 data->assoc_info.reassoc); 1890 return; 1891 } 1892 #endif /* CONFIG_AP */ 1893 1894 ft_completed = wpa_ft_is_completed(wpa_s->wpa); 1895 if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0) 1896 return; 1897 1898 if (wpa_drv_get_bssid(wpa_s, bssid) < 0) { 1899 wpa_dbg(wpa_s, MSG_ERROR, "Failed to get BSSID"); 1900 wpa_supplicant_deauthenticate( 1901 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 1902 return; 1903 } 1904 1905 wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED); 1906 if (os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0) { 1907 wpa_dbg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID=" 1908 MACSTR, MAC2STR(bssid)); 1909 random_add_randomness(bssid, ETH_ALEN); 1910 os_memcpy(wpa_s->bssid, bssid, ETH_ALEN); 1911 os_memset(wpa_s->pending_bssid, 0, ETH_ALEN); 1912 wpas_notify_bssid_changed(wpa_s); 1913 1914 if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) { 1915 wpa_clear_keys(wpa_s, bssid); 1916 } 1917 if (wpa_supplicant_select_config(wpa_s) < 0) { 1918 wpa_supplicant_deauthenticate( 1919 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 1920 return; 1921 } 1922 1923 #ifdef ANDROID 1924 if (wpa_s->conf->ap_scan == 1) { 1925 #else 1926 if (wpa_s->conf->ap_scan == 1 && 1927 wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION) { 1928 #endif 1929 if (wpa_supplicant_assoc_update_ie(wpa_s) < 0) 1930 wpa_msg(wpa_s, MSG_WARNING, 1931 "WPA/RSN IEs not updated"); 1932 } 1933 } 1934 1935 #ifdef CONFIG_SME 1936 os_memcpy(wpa_s->sme.prev_bssid, bssid, ETH_ALEN); 1937 wpa_s->sme.prev_bssid_set = 1; 1938 wpa_s->sme.last_unprot_disconnect.sec = 0; 1939 #endif /* CONFIG_SME */ 1940 1941 wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid)); 1942 if (wpa_s->current_ssid) { 1943 /* When using scanning (ap_scan=1), SIM PC/SC interface can be 1944 * initialized before association, but for other modes, 1945 * initialize PC/SC here, if the current configuration needs 1946 * smartcard or SIM/USIM. */ 1947 wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid); 1948 } 1949 wpa_sm_notify_assoc(wpa_s->wpa, bssid); 1950 if (wpa_s->l2) 1951 l2_packet_notify_auth_start(wpa_s->l2); 1952 1953 /* 1954 * Set portEnabled first to FALSE in order to get EAP state machine out 1955 * of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE 1956 * state machine may transit to AUTHENTICATING state based on obsolete 1957 * eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to 1958 * AUTHENTICATED without ever giving chance to EAP state machine to 1959 * reset the state. 1960 */ 1961 if (!ft_completed) { 1962 eapol_sm_notify_portEnabled(wpa_s->eapol, FALSE); 1963 eapol_sm_notify_portValid(wpa_s->eapol, FALSE); 1964 } 1965 if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) || ft_completed) 1966 eapol_sm_notify_eap_success(wpa_s->eapol, FALSE); 1967 /* 802.1X::portControl = Auto */ 1968 eapol_sm_notify_portEnabled(wpa_s->eapol, TRUE); 1969 wpa_s->eapol_received = 0; 1970 if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 1971 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE || 1972 (wpa_s->current_ssid && 1973 wpa_s->current_ssid->mode == IEEE80211_MODE_IBSS)) { 1974 if (wpa_s->current_ssid && 1975 wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE && 1976 (wpa_s->drv_flags & 1977 WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE)) { 1978 /* 1979 * Set the key after having received joined-IBSS event 1980 * from the driver. 1981 */ 1982 wpa_supplicant_set_wpa_none_key(wpa_s, 1983 wpa_s->current_ssid); 1984 } 1985 wpa_supplicant_cancel_auth_timeout(wpa_s); 1986 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 1987 } else if (!ft_completed) { 1988 /* Timeout for receiving the first EAPOL packet */ 1989 wpa_supplicant_req_auth_timeout(wpa_s, 10, 0); 1990 } 1991 wpa_supplicant_cancel_scan(wpa_s); 1992 1993 if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) && 1994 wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) { 1995 /* 1996 * We are done; the driver will take care of RSN 4-way 1997 * handshake. 1998 */ 1999 wpa_supplicant_cancel_auth_timeout(wpa_s); 2000 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 2001 eapol_sm_notify_portValid(wpa_s->eapol, TRUE); 2002 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE); 2003 } else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) && 2004 wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) { 2005 /* 2006 * The driver will take care of RSN 4-way handshake, so we need 2007 * to allow EAPOL supplicant to complete its work without 2008 * waiting for WPA supplicant. 2009 */ 2010 eapol_sm_notify_portValid(wpa_s->eapol, TRUE); 2011 } else if (ft_completed) { 2012 /* 2013 * FT protocol completed - make sure EAPOL state machine ends 2014 * up in authenticated. 2015 */ 2016 wpa_supplicant_cancel_auth_timeout(wpa_s); 2017 wpa_supplicant_set_state(wpa_s, WPA_COMPLETED); 2018 eapol_sm_notify_portValid(wpa_s->eapol, TRUE); 2019 eapol_sm_notify_eap_success(wpa_s->eapol, TRUE); 2020 } 2021 2022 wpa_s->last_eapol_matches_bssid = 0; 2023 2024 if (wpa_s->pending_eapol_rx) { 2025 struct os_reltime now, age; 2026 os_get_reltime(&now); 2027 os_reltime_sub(&now, &wpa_s->pending_eapol_rx_time, &age); 2028 if (age.sec == 0 && age.usec < 100000 && 2029 os_memcmp(wpa_s->pending_eapol_rx_src, bssid, ETH_ALEN) == 2030 0) { 2031 wpa_dbg(wpa_s, MSG_DEBUG, "Process pending EAPOL " 2032 "frame that was received just before " 2033 "association notification"); 2034 wpa_supplicant_rx_eapol( 2035 wpa_s, wpa_s->pending_eapol_rx_src, 2036 wpabuf_head(wpa_s->pending_eapol_rx), 2037 wpabuf_len(wpa_s->pending_eapol_rx)); 2038 } 2039 wpabuf_free(wpa_s->pending_eapol_rx); 2040 wpa_s->pending_eapol_rx = NULL; 2041 } 2042 2043 if ((wpa_s->key_mgmt == WPA_KEY_MGMT_NONE || 2044 wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) && 2045 wpa_s->current_ssid && 2046 (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE)) { 2047 /* Set static WEP keys again */ 2048 wpa_set_wep_keys(wpa_s, wpa_s->current_ssid); 2049 } 2050 2051 #ifdef CONFIG_IBSS_RSN 2052 if (wpa_s->current_ssid && 2053 wpa_s->current_ssid->mode == WPAS_MODE_IBSS && 2054 wpa_s->key_mgmt != WPA_KEY_MGMT_NONE && 2055 wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE && 2056 wpa_s->ibss_rsn == NULL) { 2057 wpa_s->ibss_rsn = ibss_rsn_init(wpa_s); 2058 if (!wpa_s->ibss_rsn) { 2059 wpa_msg(wpa_s, MSG_INFO, "Failed to init IBSS RSN"); 2060 wpa_supplicant_deauthenticate( 2061 wpa_s, WLAN_REASON_DEAUTH_LEAVING); 2062 return; 2063 } 2064 2065 ibss_rsn_set_psk(wpa_s->ibss_rsn, wpa_s->current_ssid->psk); 2066 } 2067 #endif /* CONFIG_IBSS_RSN */ 2068 2069 wpas_wps_notify_assoc(wpa_s, bssid); 2070 } 2071 2072 2073 static int disconnect_reason_recoverable(u16 reason_code) 2074 { 2075 return reason_code == WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY || 2076 reason_code == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA || 2077 reason_code == WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA; 2078 } 2079 2080 2081 static void wpa_supplicant_event_disassoc(struct wpa_supplicant *wpa_s, 2082 u16 reason_code, 2083 int locally_generated) 2084 { 2085 const u8 *bssid; 2086 2087 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 2088 /* 2089 * At least Host AP driver and a Prism3 card seemed to be 2090 * generating streams of disconnected events when configuring 2091 * IBSS for WPA-None. Ignore them for now. 2092 */ 2093 return; 2094 } 2095 2096 bssid = wpa_s->bssid; 2097 if (is_zero_ether_addr(bssid)) 2098 bssid = wpa_s->pending_bssid; 2099 2100 if (!is_zero_ether_addr(bssid) || 2101 wpa_s->wpa_state >= WPA_AUTHENTICATING) { 2102 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_DISCONNECTED "bssid=" MACSTR 2103 " reason=%d%s", 2104 MAC2STR(bssid), reason_code, 2105 locally_generated ? " locally_generated=1" : ""); 2106 } 2107 } 2108 2109 2110 static int could_be_psk_mismatch(struct wpa_supplicant *wpa_s, u16 reason_code, 2111 int locally_generated) 2112 { 2113 if (wpa_s->wpa_state != WPA_4WAY_HANDSHAKE || 2114 !wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) 2115 return 0; /* Not in 4-way handshake with PSK */ 2116 2117 /* 2118 * It looks like connection was lost while trying to go through PSK 2119 * 4-way handshake. Filter out known disconnection cases that are caused 2120 * by something else than PSK mismatch to avoid confusing reports. 2121 */ 2122 2123 if (locally_generated) { 2124 if (reason_code == WLAN_REASON_IE_IN_4WAY_DIFFERS) 2125 return 0; 2126 } 2127 2128 return 1; 2129 } 2130 2131 2132 static void wpa_supplicant_event_disassoc_finish(struct wpa_supplicant *wpa_s, 2133 u16 reason_code, 2134 int locally_generated) 2135 { 2136 const u8 *bssid; 2137 int authenticating; 2138 u8 prev_pending_bssid[ETH_ALEN]; 2139 struct wpa_bss *fast_reconnect = NULL; 2140 struct wpa_ssid *fast_reconnect_ssid = NULL; 2141 struct wpa_ssid *last_ssid; 2142 2143 authenticating = wpa_s->wpa_state == WPA_AUTHENTICATING; 2144 os_memcpy(prev_pending_bssid, wpa_s->pending_bssid, ETH_ALEN); 2145 2146 if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) { 2147 /* 2148 * At least Host AP driver and a Prism3 card seemed to be 2149 * generating streams of disconnected events when configuring 2150 * IBSS for WPA-None. Ignore them for now. 2151 */ 2152 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - ignore in " 2153 "IBSS/WPA-None mode"); 2154 return; 2155 } 2156 2157 if (could_be_psk_mismatch(wpa_s, reason_code, locally_generated)) { 2158 wpa_msg(wpa_s, MSG_INFO, "WPA: 4-Way Handshake failed - " 2159 "pre-shared key may be incorrect"); 2160 if (wpas_p2p_4way_hs_failed(wpa_s) > 0) 2161 return; /* P2P group removed */ 2162 wpas_auth_failed(wpa_s, "WRONG_KEY"); 2163 } 2164 if (!wpa_s->disconnected && 2165 (!wpa_s->auto_reconnect_disabled || 2166 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS)) { 2167 wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect enabled: try to " 2168 "reconnect (wps=%d wpa_state=%d)", 2169 wpa_s->key_mgmt == WPA_KEY_MGMT_WPS, 2170 wpa_s->wpa_state); 2171 if (wpa_s->wpa_state == WPA_COMPLETED && 2172 wpa_s->current_ssid && 2173 wpa_s->current_ssid->mode == WPAS_MODE_INFRA && 2174 !locally_generated && 2175 disconnect_reason_recoverable(reason_code)) { 2176 /* 2177 * It looks like the AP has dropped association with 2178 * us, but could allow us to get back in. Try to 2179 * reconnect to the same BSS without full scan to save 2180 * time for some common cases. 2181 */ 2182 fast_reconnect = wpa_s->current_bss; 2183 fast_reconnect_ssid = wpa_s->current_ssid; 2184 } else if (wpa_s->wpa_state >= WPA_ASSOCIATING) 2185 wpa_supplicant_req_scan(wpa_s, 0, 100000); 2186 else 2187 wpa_dbg(wpa_s, MSG_DEBUG, "Do not request new " 2188 "immediate scan"); 2189 } else { 2190 wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect disabled: do not " 2191 "try to re-connect"); 2192 wpa_s->reassociate = 0; 2193 wpa_s->disconnected = 1; 2194 wpa_supplicant_cancel_sched_scan(wpa_s); 2195 } 2196 bssid = wpa_s->bssid; 2197 if (is_zero_ether_addr(bssid)) 2198 bssid = wpa_s->pending_bssid; 2199 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) 2200 wpas_connection_failed(wpa_s, bssid); 2201 wpa_sm_notify_disassoc(wpa_s->wpa); 2202 if (locally_generated) 2203 wpa_s->disconnect_reason = -reason_code; 2204 else 2205 wpa_s->disconnect_reason = reason_code; 2206 wpas_notify_disconnect_reason(wpa_s); 2207 if (wpa_supplicant_dynamic_keys(wpa_s)) { 2208 wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - remove keys"); 2209 wpa_clear_keys(wpa_s, wpa_s->bssid); 2210 } 2211 last_ssid = wpa_s->current_ssid; 2212 wpa_supplicant_mark_disassoc(wpa_s); 2213 2214 if (authenticating && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)) { 2215 sme_disassoc_while_authenticating(wpa_s, prev_pending_bssid); 2216 wpa_s->current_ssid = last_ssid; 2217 } 2218 2219 if (fast_reconnect && 2220 !wpas_network_disabled(wpa_s, fast_reconnect_ssid) && 2221 !disallowed_bssid(wpa_s, fast_reconnect->bssid) && 2222 !disallowed_ssid(wpa_s, fast_reconnect->ssid, 2223 fast_reconnect->ssid_len) && 2224 !wpas_temp_disabled(wpa_s, fast_reconnect_ssid)) { 2225 #ifndef CONFIG_NO_SCAN_PROCESSING 2226 wpa_dbg(wpa_s, MSG_DEBUG, "Try to reconnect to the same BSS"); 2227 if (wpa_supplicant_connect(wpa_s, fast_reconnect, 2228 fast_reconnect_ssid) < 0) { 2229 /* Recover through full scan */ 2230 wpa_supplicant_req_scan(wpa_s, 0, 100000); 2231 } 2232 #endif /* CONFIG_NO_SCAN_PROCESSING */ 2233 } else if (fast_reconnect) { 2234 /* 2235 * Could not reconnect to the same BSS due to network being 2236 * disabled. Use a new scan to match the alternative behavior 2237 * above, i.e., to continue automatic reconnection attempt in a 2238 * way that enforces disabled network rules. 2239 */ 2240 wpa_supplicant_req_scan(wpa_s, 0, 100000); 2241 } 2242 } 2243 2244 2245 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT 2246 void wpa_supplicant_delayed_mic_error_report(void *eloop_ctx, void *sock_ctx) 2247 { 2248 struct wpa_supplicant *wpa_s = eloop_ctx; 2249 2250 if (!wpa_s->pending_mic_error_report) 2251 return; 2252 2253 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Sending pending MIC error report"); 2254 wpa_sm_key_request(wpa_s->wpa, 1, wpa_s->pending_mic_error_pairwise); 2255 wpa_s->pending_mic_error_report = 0; 2256 } 2257 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */ 2258 2259 2260 static void 2261 wpa_supplicant_event_michael_mic_failure(struct wpa_supplicant *wpa_s, 2262 union wpa_event_data *data) 2263 { 2264 int pairwise; 2265 struct os_reltime t; 2266 2267 wpa_msg(wpa_s, MSG_WARNING, "Michael MIC failure detected"); 2268 pairwise = (data && data->michael_mic_failure.unicast); 2269 os_get_reltime(&t); 2270 if ((wpa_s->last_michael_mic_error.sec && 2271 !os_reltime_expired(&t, &wpa_s->last_michael_mic_error, 60)) || 2272 wpa_s->pending_mic_error_report) { 2273 if (wpa_s->pending_mic_error_report) { 2274 /* 2275 * Send the pending MIC error report immediately since 2276 * we are going to start countermeasures and AP better 2277 * do the same. 2278 */ 2279 wpa_sm_key_request(wpa_s->wpa, 1, 2280 wpa_s->pending_mic_error_pairwise); 2281 } 2282 2283 /* Send the new MIC error report immediately since we are going 2284 * to start countermeasures and AP better do the same. 2285 */ 2286 wpa_sm_key_request(wpa_s->wpa, 1, pairwise); 2287 2288 /* initialize countermeasures */ 2289 wpa_s->countermeasures = 1; 2290 2291 wpa_blacklist_add(wpa_s, wpa_s->bssid); 2292 2293 wpa_msg(wpa_s, MSG_WARNING, "TKIP countermeasures started"); 2294 2295 /* 2296 * Need to wait for completion of request frame. We do not get 2297 * any callback for the message completion, so just wait a 2298 * short while and hope for the best. */ 2299 os_sleep(0, 10000); 2300 2301 wpa_drv_set_countermeasures(wpa_s, 1); 2302 wpa_supplicant_deauthenticate(wpa_s, 2303 WLAN_REASON_MICHAEL_MIC_FAILURE); 2304 eloop_cancel_timeout(wpa_supplicant_stop_countermeasures, 2305 wpa_s, NULL); 2306 eloop_register_timeout(60, 0, 2307 wpa_supplicant_stop_countermeasures, 2308 wpa_s, NULL); 2309 /* TODO: mark the AP rejected for 60 second. STA is 2310 * allowed to associate with another AP.. */ 2311 } else { 2312 #ifdef CONFIG_DELAYED_MIC_ERROR_REPORT 2313 if (wpa_s->mic_errors_seen) { 2314 /* 2315 * Reduce the effectiveness of Michael MIC error 2316 * reports as a means for attacking against TKIP if 2317 * more than one MIC failure is noticed with the same 2318 * PTK. We delay the transmission of the reports by a 2319 * random time between 0 and 60 seconds in order to 2320 * force the attacker wait 60 seconds before getting 2321 * the information on whether a frame resulted in a MIC 2322 * failure. 2323 */ 2324 u8 rval[4]; 2325 int sec; 2326 2327 if (os_get_random(rval, sizeof(rval)) < 0) 2328 sec = os_random() % 60; 2329 else 2330 sec = WPA_GET_BE32(rval) % 60; 2331 wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Delay MIC error " 2332 "report %d seconds", sec); 2333 wpa_s->pending_mic_error_report = 1; 2334 wpa_s->pending_mic_error_pairwise = pairwise; 2335 eloop_cancel_timeout( 2336 wpa_supplicant_delayed_mic_error_report, 2337 wpa_s, NULL); 2338 eloop_register_timeout( 2339 sec, os_random() % 1000000, 2340 wpa_supplicant_delayed_mic_error_report, 2341 wpa_s, NULL); 2342 } else { 2343 wpa_sm_key_request(wpa_s->wpa, 1, pairwise); 2344 } 2345 #else /* CONFIG_DELAYED_MIC_ERROR_REPORT */ 2346 wpa_sm_key_request(wpa_s->wpa, 1, pairwise); 2347 #endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */ 2348 } 2349 wpa_s->last_michael_mic_error = t; 2350 wpa_s->mic_errors_seen++; 2351 } 2352 2353 2354 #ifdef CONFIG_TERMINATE_ONLASTIF 2355 static int any_interfaces(struct wpa_supplicant *head) 2356 { 2357 struct wpa_supplicant *wpa_s; 2358 2359 for (wpa_s = head; wpa_s != NULL; wpa_s = wpa_s->next) 2360 if (!wpa_s->interface_removed) 2361 return 1; 2362 return 0; 2363 } 2364 #endif /* CONFIG_TERMINATE_ONLASTIF */ 2365 2366 2367 static void 2368 wpa_supplicant_event_interface_status(struct wpa_supplicant *wpa_s, 2369 union wpa_event_data *data) 2370 { 2371 if (os_strcmp(wpa_s->ifname, data->interface_status.ifname) != 0) 2372 return; 2373 2374 switch (data->interface_status.ievent) { 2375 case EVENT_INTERFACE_ADDED: 2376 if (!wpa_s->interface_removed) 2377 break; 2378 wpa_s->interface_removed = 0; 2379 wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was added"); 2380 if (wpa_supplicant_driver_init(wpa_s) < 0) { 2381 wpa_msg(wpa_s, MSG_INFO, "Failed to initialize the " 2382 "driver after interface was added"); 2383 } 2384 break; 2385 case EVENT_INTERFACE_REMOVED: 2386 wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was removed"); 2387 wpa_s->interface_removed = 1; 2388 wpa_supplicant_mark_disassoc(wpa_s); 2389 wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED); 2390 l2_packet_deinit(wpa_s->l2); 2391 wpa_s->l2 = NULL; 2392 #ifdef CONFIG_TERMINATE_ONLASTIF 2393 /* check if last interface */ 2394 if (!any_interfaces(wpa_s->global->ifaces)) 2395 eloop_terminate(); 2396 #endif /* CONFIG_TERMINATE_ONLASTIF */ 2397 break; 2398 } 2399 } 2400 2401 2402 #ifdef CONFIG_PEERKEY 2403 static void 2404 wpa_supplicant_event_stkstart(struct wpa_supplicant *wpa_s, 2405 union wpa_event_data *data) 2406 { 2407 if (data == NULL) 2408 return; 2409 wpa_sm_stkstart(wpa_s->wpa, data->stkstart.peer); 2410 } 2411 #endif /* CONFIG_PEERKEY */ 2412 2413 2414 #ifdef CONFIG_TDLS 2415 static void wpa_supplicant_event_tdls(struct wpa_supplicant *wpa_s, 2416 union wpa_event_data *data) 2417 { 2418 if (data == NULL) 2419 return; 2420 switch (data->tdls.oper) { 2421 case TDLS_REQUEST_SETUP: 2422 wpa_tdls_remove(wpa_s->wpa, data->tdls.peer); 2423 if (wpa_tdls_is_external_setup(wpa_s->wpa)) 2424 wpa_tdls_start(wpa_s->wpa, data->tdls.peer); 2425 else 2426 wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, data->tdls.peer); 2427 break; 2428 case TDLS_REQUEST_TEARDOWN: 2429 if (wpa_tdls_is_external_setup(wpa_s->wpa)) 2430 wpa_tdls_teardown_link(wpa_s->wpa, data->tdls.peer, 2431 data->tdls.reason_code); 2432 else 2433 wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN, 2434 data->tdls.peer); 2435 break; 2436 } 2437 } 2438 #endif /* CONFIG_TDLS */ 2439 2440 2441 #ifdef CONFIG_WNM 2442 static void wpa_supplicant_event_wnm(struct wpa_supplicant *wpa_s, 2443 union wpa_event_data *data) 2444 { 2445 if (data == NULL) 2446 return; 2447 switch (data->wnm.oper) { 2448 case WNM_OPER_SLEEP: 2449 wpa_printf(MSG_DEBUG, "Start sending WNM-Sleep Request " 2450 "(action=%d, intval=%d)", 2451 data->wnm.sleep_action, data->wnm.sleep_intval); 2452 ieee802_11_send_wnmsleep_req(wpa_s, data->wnm.sleep_action, 2453 data->wnm.sleep_intval, NULL); 2454 break; 2455 } 2456 } 2457 #endif /* CONFIG_WNM */ 2458 2459 2460 #ifdef CONFIG_IEEE80211R 2461 static void 2462 wpa_supplicant_event_ft_response(struct wpa_supplicant *wpa_s, 2463 union wpa_event_data *data) 2464 { 2465 if (data == NULL) 2466 return; 2467 2468 if (wpa_ft_process_response(wpa_s->wpa, data->ft_ies.ies, 2469 data->ft_ies.ies_len, 2470 data->ft_ies.ft_action, 2471 data->ft_ies.target_ap, 2472 data->ft_ies.ric_ies, 2473 data->ft_ies.ric_ies_len) < 0) { 2474 /* TODO: prevent MLME/driver from trying to associate? */ 2475 } 2476 } 2477 #endif /* CONFIG_IEEE80211R */ 2478 2479 2480 #ifdef CONFIG_IBSS_RSN 2481 static void wpa_supplicant_event_ibss_rsn_start(struct wpa_supplicant *wpa_s, 2482 union wpa_event_data *data) 2483 { 2484 struct wpa_ssid *ssid; 2485 if (wpa_s->wpa_state < WPA_ASSOCIATED) 2486 return; 2487 if (data == NULL) 2488 return; 2489 ssid = wpa_s->current_ssid; 2490 if (ssid == NULL) 2491 return; 2492 if (ssid->mode != WPAS_MODE_IBSS || !wpa_key_mgmt_wpa(ssid->key_mgmt)) 2493 return; 2494 2495 ibss_rsn_start(wpa_s->ibss_rsn, data->ibss_rsn_start.peer); 2496 } 2497 2498 2499 static void wpa_supplicant_event_ibss_auth(struct wpa_supplicant *wpa_s, 2500 union wpa_event_data *data) 2501 { 2502 struct wpa_ssid *ssid = wpa_s->current_ssid; 2503 2504 if (ssid == NULL) 2505 return; 2506 2507 /* check if the ssid is correctly configured as IBSS/RSN */ 2508 if (ssid->mode != WPAS_MODE_IBSS || !wpa_key_mgmt_wpa(ssid->key_mgmt)) 2509 return; 2510 2511 ibss_rsn_handle_auth(wpa_s->ibss_rsn, data->rx_mgmt.frame, 2512 data->rx_mgmt.frame_len); 2513 } 2514 #endif /* CONFIG_IBSS_RSN */ 2515 2516 2517 #ifdef CONFIG_IEEE80211R 2518 static void ft_rx_action(struct wpa_supplicant *wpa_s, const u8 *data, 2519 size_t len) 2520 { 2521 const u8 *sta_addr, *target_ap_addr; 2522 u16 status; 2523 2524 wpa_hexdump(MSG_MSGDUMP, "FT: RX Action", data, len); 2525 if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)) 2526 return; /* only SME case supported for now */ 2527 if (len < 1 + 2 * ETH_ALEN + 2) 2528 return; 2529 if (data[0] != 2) 2530 return; /* Only FT Action Response is supported for now */ 2531 sta_addr = data + 1; 2532 target_ap_addr = data + 1 + ETH_ALEN; 2533 status = WPA_GET_LE16(data + 1 + 2 * ETH_ALEN); 2534 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Received FT Action Response: STA " 2535 MACSTR " TargetAP " MACSTR " status %u", 2536 MAC2STR(sta_addr), MAC2STR(target_ap_addr), status); 2537 2538 if (os_memcmp(sta_addr, wpa_s->own_addr, ETH_ALEN) != 0) { 2539 wpa_dbg(wpa_s, MSG_DEBUG, "FT: Foreign STA Address " MACSTR 2540 " in FT Action Response", MAC2STR(sta_addr)); 2541 return; 2542 } 2543 2544 if (status) { 2545 wpa_dbg(wpa_s, MSG_DEBUG, "FT: FT Action Response indicates " 2546 "failure (status code %d)", status); 2547 /* TODO: report error to FT code(?) */ 2548 return; 2549 } 2550 2551 if (wpa_ft_process_response(wpa_s->wpa, data + 1 + 2 * ETH_ALEN + 2, 2552 len - (1 + 2 * ETH_ALEN + 2), 1, 2553 target_ap_addr, NULL, 0) < 0) 2554 return; 2555 2556 #ifdef CONFIG_SME 2557 { 2558 struct wpa_bss *bss; 2559 bss = wpa_bss_get_bssid(wpa_s, target_ap_addr); 2560 if (bss) 2561 wpa_s->sme.freq = bss->freq; 2562 wpa_s->sme.auth_alg = WPA_AUTH_ALG_FT; 2563 sme_associate(wpa_s, WPAS_MODE_INFRA, target_ap_addr, 2564 WLAN_AUTH_FT); 2565 } 2566 #endif /* CONFIG_SME */ 2567 } 2568 #endif /* CONFIG_IEEE80211R */ 2569 2570 2571 static void wpa_supplicant_event_unprot_deauth(struct wpa_supplicant *wpa_s, 2572 struct unprot_deauth *e) 2573 { 2574 #ifdef CONFIG_IEEE80211W 2575 wpa_printf(MSG_DEBUG, "Unprotected Deauthentication frame " 2576 "dropped: " MACSTR " -> " MACSTR 2577 " (reason code %u)", 2578 MAC2STR(e->sa), MAC2STR(e->da), e->reason_code); 2579 sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code); 2580 #endif /* CONFIG_IEEE80211W */ 2581 } 2582 2583 2584 static void wpa_supplicant_event_unprot_disassoc(struct wpa_supplicant *wpa_s, 2585 struct unprot_disassoc *e) 2586 { 2587 #ifdef CONFIG_IEEE80211W 2588 wpa_printf(MSG_DEBUG, "Unprotected Disassociation frame " 2589 "dropped: " MACSTR " -> " MACSTR 2590 " (reason code %u)", 2591 MAC2STR(e->sa), MAC2STR(e->da), e->reason_code); 2592 sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code); 2593 #endif /* CONFIG_IEEE80211W */ 2594 } 2595 2596 2597 static void wpas_event_disconnect(struct wpa_supplicant *wpa_s, const u8 *addr, 2598 u16 reason_code, int locally_generated, 2599 const u8 *ie, size_t ie_len, int deauth) 2600 { 2601 #ifdef CONFIG_AP 2602 if (wpa_s->ap_iface && addr) { 2603 hostapd_notif_disassoc(wpa_s->ap_iface->bss[0], addr); 2604 return; 2605 } 2606 2607 if (wpa_s->ap_iface) { 2608 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore deauth event in AP mode"); 2609 return; 2610 } 2611 #endif /* CONFIG_AP */ 2612 2613 wpa_supplicant_event_disassoc(wpa_s, reason_code, locally_generated); 2614 2615 if (((reason_code == WLAN_REASON_IEEE_802_1X_AUTH_FAILED || 2616 ((wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) || 2617 (wpa_s->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) && 2618 eapol_sm_failed(wpa_s->eapol))) && 2619 !wpa_s->eap_expected_failure)) 2620 wpas_auth_failed(wpa_s, "AUTH_FAILED"); 2621 2622 #ifdef CONFIG_P2P 2623 if (deauth && reason_code > 0) { 2624 if (wpas_p2p_deauth_notif(wpa_s, addr, reason_code, ie, ie_len, 2625 locally_generated) > 0) { 2626 /* 2627 * The interface was removed, so cannot continue 2628 * processing any additional operations after this. 2629 */ 2630 return; 2631 } 2632 } 2633 #endif /* CONFIG_P2P */ 2634 2635 wpa_supplicant_event_disassoc_finish(wpa_s, reason_code, 2636 locally_generated); 2637 } 2638 2639 2640 static void wpas_event_disassoc(struct wpa_supplicant *wpa_s, 2641 struct disassoc_info *info) 2642 { 2643 u16 reason_code = 0; 2644 int locally_generated = 0; 2645 const u8 *addr = NULL; 2646 const u8 *ie = NULL; 2647 size_t ie_len = 0; 2648 2649 wpa_dbg(wpa_s, MSG_DEBUG, "Disassociation notification"); 2650 2651 if (info) { 2652 addr = info->addr; 2653 ie = info->ie; 2654 ie_len = info->ie_len; 2655 reason_code = info->reason_code; 2656 locally_generated = info->locally_generated; 2657 wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u%s", reason_code, 2658 locally_generated ? " (locally generated)" : ""); 2659 if (addr) 2660 wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR, 2661 MAC2STR(addr)); 2662 wpa_hexdump(MSG_DEBUG, "Disassociation frame IE(s)", 2663 ie, ie_len); 2664 } 2665 2666 #ifdef CONFIG_AP 2667 if (wpa_s->ap_iface && info && info->addr) { 2668 hostapd_notif_disassoc(wpa_s->ap_iface->bss[0], info->addr); 2669 return; 2670 } 2671 2672 if (wpa_s->ap_iface) { 2673 wpa_dbg(wpa_s, MSG_DEBUG, "Ignore disassoc event in AP mode"); 2674 return; 2675 } 2676 #endif /* CONFIG_AP */ 2677 2678 #ifdef CONFIG_P2P 2679 if (info) { 2680 wpas_p2p_disassoc_notif( 2681 wpa_s, info->addr, reason_code, info->ie, info->ie_len, 2682 locally_generated); 2683 } 2684 #endif /* CONFIG_P2P */ 2685 2686 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) 2687 sme_event_disassoc(wpa_s, info); 2688 2689 wpas_event_disconnect(wpa_s, addr, reason_code, locally_generated, 2690 ie, ie_len, 0); 2691 } 2692 2693 2694 static void wpas_event_deauth(struct wpa_supplicant *wpa_s, 2695 struct deauth_info *info) 2696 { 2697 u16 reason_code = 0; 2698 int locally_generated = 0; 2699 const u8 *addr = NULL; 2700 const u8 *ie = NULL; 2701 size_t ie_len = 0; 2702 2703 wpa_dbg(wpa_s, MSG_DEBUG, "Deauthentication notification"); 2704 2705 if (info) { 2706 addr = info->addr; 2707 ie = info->ie; 2708 ie_len = info->ie_len; 2709 reason_code = info->reason_code; 2710 locally_generated = info->locally_generated; 2711 wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u%s", 2712 reason_code, 2713 locally_generated ? " (locally generated)" : ""); 2714 if (addr) { 2715 wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR, 2716 MAC2STR(addr)); 2717 } 2718 wpa_hexdump(MSG_DEBUG, "Deauthentication frame IE(s)", 2719 ie, ie_len); 2720 } 2721 2722 wpa_reset_ft_completed(wpa_s->wpa); 2723 2724 wpas_event_disconnect(wpa_s, addr, reason_code, 2725 locally_generated, ie, ie_len, 1); 2726 } 2727 2728 2729 static const char * reg_init_str(enum reg_change_initiator init) 2730 { 2731 switch (init) { 2732 case REGDOM_SET_BY_CORE: 2733 return "CORE"; 2734 case REGDOM_SET_BY_USER: 2735 return "USER"; 2736 case REGDOM_SET_BY_DRIVER: 2737 return "DRIVER"; 2738 case REGDOM_SET_BY_COUNTRY_IE: 2739 return "COUNTRY_IE"; 2740 case REGDOM_BEACON_HINT: 2741 return "BEACON_HINT"; 2742 } 2743 return "?"; 2744 } 2745 2746 2747 static const char * reg_type_str(enum reg_type type) 2748 { 2749 switch (type) { 2750 case REGDOM_TYPE_UNKNOWN: 2751 return "UNKNOWN"; 2752 case REGDOM_TYPE_COUNTRY: 2753 return "COUNTRY"; 2754 case REGDOM_TYPE_WORLD: 2755 return "WORLD"; 2756 case REGDOM_TYPE_CUSTOM_WORLD: 2757 return "CUSTOM_WORLD"; 2758 case REGDOM_TYPE_INTERSECTION: 2759 return "INTERSECTION"; 2760 } 2761 return "?"; 2762 } 2763 2764 2765 static void wpa_supplicant_update_channel_list( 2766 struct wpa_supplicant *wpa_s, struct channel_list_changed *info) 2767 { 2768 struct wpa_supplicant *ifs; 2769 2770 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_REGDOM_CHANGE "init=%s type=%s%s%s", 2771 reg_init_str(info->initiator), reg_type_str(info->type), 2772 info->alpha2[0] ? " alpha2=" : "", 2773 info->alpha2[0] ? info->alpha2 : ""); 2774 2775 if (wpa_s->drv_priv == NULL) 2776 return; /* Ignore event during drv initialization */ 2777 2778 free_hw_features(wpa_s); 2779 wpa_s->hw.modes = wpa_drv_get_hw_feature_data( 2780 wpa_s, &wpa_s->hw.num_modes, &wpa_s->hw.flags); 2781 2782 wpas_p2p_update_channel_list(wpa_s); 2783 2784 /* 2785 * Check other interfaces to see if they share the same radio. If 2786 * so, they get updated with this same hw mode info. 2787 */ 2788 dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant, 2789 radio_list) { 2790 if (ifs != wpa_s) { 2791 wpa_printf(MSG_DEBUG, "%s: Updating hw mode", 2792 ifs->ifname); 2793 free_hw_features(ifs); 2794 ifs->hw.modes = wpa_drv_get_hw_feature_data( 2795 ifs, &ifs->hw.num_modes, &ifs->hw.flags); 2796 } 2797 } 2798 } 2799 2800 2801 static void wpas_event_rx_mgmt_action(struct wpa_supplicant *wpa_s, 2802 const u8 *frame, size_t len, int freq) 2803 { 2804 const struct ieee80211_mgmt *mgmt; 2805 const u8 *payload; 2806 size_t plen; 2807 u8 category; 2808 2809 if (len < IEEE80211_HDRLEN + 2) 2810 return; 2811 2812 mgmt = (const struct ieee80211_mgmt *) frame; 2813 payload = frame + IEEE80211_HDRLEN; 2814 category = *payload++; 2815 plen = len - IEEE80211_HDRLEN - 1; 2816 2817 wpa_dbg(wpa_s, MSG_DEBUG, "Received Action frame: SA=" MACSTR 2818 " Category=%u DataLen=%d freq=%d MHz", 2819 MAC2STR(mgmt->sa), category, (int) plen, freq); 2820 2821 #ifdef CONFIG_IEEE80211R 2822 if (category == WLAN_ACTION_FT) { 2823 ft_rx_action(wpa_s, payload, plen); 2824 return; 2825 } 2826 #endif /* CONFIG_IEEE80211R */ 2827 2828 #ifdef CONFIG_IEEE80211W 2829 #ifdef CONFIG_SME 2830 if (category == WLAN_ACTION_SA_QUERY) { 2831 sme_sa_query_rx(wpa_s, mgmt->sa, payload, plen); 2832 return; 2833 } 2834 #endif /* CONFIG_SME */ 2835 #endif /* CONFIG_IEEE80211W */ 2836 2837 #ifdef CONFIG_WNM 2838 if (mgmt->u.action.category == WLAN_ACTION_WNM) { 2839 ieee802_11_rx_wnm_action(wpa_s, mgmt, len); 2840 return; 2841 } 2842 #endif /* CONFIG_WNM */ 2843 2844 #ifdef CONFIG_GAS 2845 if ((mgmt->u.action.category == WLAN_ACTION_PUBLIC || 2846 mgmt->u.action.category == WLAN_ACTION_PROTECTED_DUAL) && 2847 gas_query_rx(wpa_s->gas, mgmt->da, mgmt->sa, mgmt->bssid, 2848 mgmt->u.action.category, 2849 payload, plen, freq) == 0) 2850 return; 2851 #endif /* CONFIG_GAS */ 2852 2853 #ifdef CONFIG_TDLS 2854 if (category == WLAN_ACTION_PUBLIC && plen >= 4 && 2855 payload[0] == WLAN_TDLS_DISCOVERY_RESPONSE) { 2856 wpa_dbg(wpa_s, MSG_DEBUG, 2857 "TDLS: Received Discovery Response from " MACSTR, 2858 MAC2STR(mgmt->sa)); 2859 return; 2860 } 2861 #endif /* CONFIG_TDLS */ 2862 2863 #ifdef CONFIG_INTERWORKING 2864 if (category == WLAN_ACTION_QOS && plen >= 1 && 2865 payload[0] == QOS_QOS_MAP_CONFIG) { 2866 const u8 *pos = payload + 1; 2867 size_t qlen = plen - 1; 2868 wpa_dbg(wpa_s, MSG_DEBUG, "Interworking: Received QoS Map Configure frame from " 2869 MACSTR, MAC2STR(mgmt->sa)); 2870 if (os_memcmp(mgmt->sa, wpa_s->bssid, ETH_ALEN) == 0 && 2871 qlen > 2 && pos[0] == WLAN_EID_QOS_MAP_SET && 2872 pos[1] <= qlen - 2 && pos[1] >= 16) 2873 wpas_qos_map_set(wpa_s, pos + 2, pos[1]); 2874 return; 2875 } 2876 #endif /* CONFIG_INTERWORKING */ 2877 2878 wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid, 2879 category, payload, plen, freq); 2880 } 2881 2882 2883 static void wpa_supplicant_notify_avoid_freq(struct wpa_supplicant *wpa_s, 2884 union wpa_event_data *event) 2885 { 2886 #ifdef CONFIG_P2P 2887 struct wpa_supplicant *ifs; 2888 #endif /* CONFIG_P2P */ 2889 struct wpa_freq_range_list *list; 2890 char *str = NULL; 2891 2892 list = &event->freq_range; 2893 2894 if (list->num) 2895 str = freq_range_list_str(list); 2896 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_AVOID_FREQ "ranges=%s", 2897 str ? str : ""); 2898 2899 #ifdef CONFIG_P2P 2900 if (freq_range_list_parse(&wpa_s->global->p2p_go_avoid_freq, str)) { 2901 wpa_dbg(wpa_s, MSG_ERROR, "%s: Failed to parse freq range", 2902 __func__); 2903 } else { 2904 wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Update channel list based on frequency avoid event"); 2905 wpas_p2p_update_channel_list(wpa_s); 2906 } 2907 2908 for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) { 2909 int freq; 2910 if (!ifs->current_ssid || 2911 !ifs->current_ssid->p2p_group || 2912 (ifs->current_ssid->mode != WPAS_MODE_P2P_GO && 2913 ifs->current_ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)) 2914 continue; 2915 2916 freq = ifs->current_ssid->frequency; 2917 if (!freq_range_list_includes(list, freq)) { 2918 wpa_dbg(ifs, MSG_DEBUG, "P2P GO operating frequency %d MHz in safe range", 2919 freq); 2920 continue; 2921 } 2922 2923 wpa_dbg(ifs, MSG_DEBUG, "P2P GO operating in unsafe frequency %d MHz", 2924 freq); 2925 /* TODO: Consider using CSA or removing the group within 2926 * wpa_supplicant */ 2927 wpa_msg(ifs, MSG_INFO, P2P_EVENT_REMOVE_AND_REFORM_GROUP); 2928 } 2929 #endif /* CONFIG_P2P */ 2930 2931 os_free(str); 2932 } 2933 2934 2935 void wpa_supplicant_event(void *ctx, enum wpa_event_type event, 2936 union wpa_event_data *data) 2937 { 2938 struct wpa_supplicant *wpa_s = ctx; 2939 2940 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED && 2941 event != EVENT_INTERFACE_ENABLED && 2942 event != EVENT_INTERFACE_STATUS && 2943 event != EVENT_SCHED_SCAN_STOPPED) { 2944 wpa_dbg(wpa_s, MSG_DEBUG, 2945 "Ignore event %s (%d) while interface is disabled", 2946 event_to_string(event), event); 2947 return; 2948 } 2949 2950 #ifndef CONFIG_NO_STDOUT_DEBUG 2951 { 2952 int level = MSG_DEBUG; 2953 2954 if (event == EVENT_RX_MGMT && data->rx_mgmt.frame_len >= 24) { 2955 const struct ieee80211_hdr *hdr; 2956 u16 fc; 2957 hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame; 2958 fc = le_to_host16(hdr->frame_control); 2959 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 2960 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) 2961 level = MSG_EXCESSIVE; 2962 } 2963 2964 wpa_dbg(wpa_s, level, "Event %s (%d) received", 2965 event_to_string(event), event); 2966 } 2967 #endif /* CONFIG_NO_STDOUT_DEBUG */ 2968 2969 switch (event) { 2970 case EVENT_AUTH: 2971 sme_event_auth(wpa_s, data); 2972 break; 2973 case EVENT_ASSOC: 2974 wpa_supplicant_event_assoc(wpa_s, data); 2975 break; 2976 case EVENT_DISASSOC: 2977 wpas_event_disassoc(wpa_s, 2978 data ? &data->disassoc_info : NULL); 2979 break; 2980 case EVENT_DEAUTH: 2981 wpas_event_deauth(wpa_s, 2982 data ? &data->deauth_info : NULL); 2983 break; 2984 case EVENT_MICHAEL_MIC_FAILURE: 2985 wpa_supplicant_event_michael_mic_failure(wpa_s, data); 2986 break; 2987 #ifndef CONFIG_NO_SCAN_PROCESSING 2988 case EVENT_SCAN_STARTED: 2989 os_get_reltime(&wpa_s->scan_start_time); 2990 if (wpa_s->own_scan_requested) { 2991 struct os_reltime diff; 2992 2993 os_reltime_sub(&wpa_s->scan_start_time, 2994 &wpa_s->scan_trigger_time, &diff); 2995 wpa_dbg(wpa_s, MSG_DEBUG, "Own scan request started a scan in %ld.%06ld seconds", 2996 diff.sec, diff.usec); 2997 wpa_s->own_scan_requested = 0; 2998 wpa_s->own_scan_running = 1; 2999 if (wpa_s->last_scan_req == MANUAL_SCAN_REQ && 3000 wpa_s->manual_scan_use_id) { 3001 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SCAN_STARTED "id=%u", 3002 wpa_s->manual_scan_id); 3003 } else { 3004 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SCAN_STARTED); 3005 } 3006 } else { 3007 wpa_dbg(wpa_s, MSG_DEBUG, "External program started a scan"); 3008 wpa_s->external_scan_running = 1; 3009 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SCAN_STARTED); 3010 } 3011 break; 3012 case EVENT_SCAN_RESULTS: 3013 if (os_reltime_initialized(&wpa_s->scan_start_time)) { 3014 struct os_reltime now, diff; 3015 os_get_reltime(&now); 3016 os_reltime_sub(&now, &wpa_s->scan_start_time, &diff); 3017 wpa_s->scan_start_time.sec = 0; 3018 wpa_s->scan_start_time.usec = 0; 3019 wpa_dbg(wpa_s, MSG_DEBUG, "Scan completed in %ld.%06ld seconds", 3020 diff.sec, diff.usec); 3021 } 3022 wpa_supplicant_event_scan_results(wpa_s, data); 3023 wpa_s->own_scan_running = 0; 3024 wpa_s->external_scan_running = 0; 3025 radio_work_check_next(wpa_s); 3026 break; 3027 #endif /* CONFIG_NO_SCAN_PROCESSING */ 3028 case EVENT_ASSOCINFO: 3029 wpa_supplicant_event_associnfo(wpa_s, data); 3030 break; 3031 case EVENT_INTERFACE_STATUS: 3032 wpa_supplicant_event_interface_status(wpa_s, data); 3033 break; 3034 case EVENT_PMKID_CANDIDATE: 3035 wpa_supplicant_event_pmkid_candidate(wpa_s, data); 3036 break; 3037 #ifdef CONFIG_PEERKEY 3038 case EVENT_STKSTART: 3039 wpa_supplicant_event_stkstart(wpa_s, data); 3040 break; 3041 #endif /* CONFIG_PEERKEY */ 3042 #ifdef CONFIG_TDLS 3043 case EVENT_TDLS: 3044 wpa_supplicant_event_tdls(wpa_s, data); 3045 break; 3046 #endif /* CONFIG_TDLS */ 3047 #ifdef CONFIG_WNM 3048 case EVENT_WNM: 3049 wpa_supplicant_event_wnm(wpa_s, data); 3050 break; 3051 #endif /* CONFIG_WNM */ 3052 #ifdef CONFIG_IEEE80211R 3053 case EVENT_FT_RESPONSE: 3054 wpa_supplicant_event_ft_response(wpa_s, data); 3055 break; 3056 #endif /* CONFIG_IEEE80211R */ 3057 #ifdef CONFIG_IBSS_RSN 3058 case EVENT_IBSS_RSN_START: 3059 wpa_supplicant_event_ibss_rsn_start(wpa_s, data); 3060 break; 3061 #endif /* CONFIG_IBSS_RSN */ 3062 case EVENT_ASSOC_REJECT: 3063 if (data->assoc_reject.bssid) 3064 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT 3065 "bssid=" MACSTR " status_code=%u", 3066 MAC2STR(data->assoc_reject.bssid), 3067 data->assoc_reject.status_code); 3068 else 3069 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT 3070 "status_code=%u", 3071 data->assoc_reject.status_code); 3072 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) 3073 sme_event_assoc_reject(wpa_s, data); 3074 else { 3075 const u8 *bssid = data->assoc_reject.bssid; 3076 if (bssid == NULL || is_zero_ether_addr(bssid)) 3077 bssid = wpa_s->pending_bssid; 3078 wpas_connection_failed(wpa_s, bssid); 3079 wpa_supplicant_mark_disassoc(wpa_s); 3080 } 3081 break; 3082 case EVENT_AUTH_TIMED_OUT: 3083 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) 3084 sme_event_auth_timed_out(wpa_s, data); 3085 break; 3086 case EVENT_ASSOC_TIMED_OUT: 3087 if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) 3088 sme_event_assoc_timed_out(wpa_s, data); 3089 break; 3090 case EVENT_TX_STATUS: 3091 wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS dst=" MACSTR 3092 " type=%d stype=%d", 3093 MAC2STR(data->tx_status.dst), 3094 data->tx_status.type, data->tx_status.stype); 3095 #ifdef CONFIG_AP 3096 if (wpa_s->ap_iface == NULL) { 3097 #ifdef CONFIG_OFFCHANNEL 3098 if (data->tx_status.type == WLAN_FC_TYPE_MGMT && 3099 data->tx_status.stype == WLAN_FC_STYPE_ACTION) 3100 offchannel_send_action_tx_status( 3101 wpa_s, data->tx_status.dst, 3102 data->tx_status.data, 3103 data->tx_status.data_len, 3104 data->tx_status.ack ? 3105 OFFCHANNEL_SEND_ACTION_SUCCESS : 3106 OFFCHANNEL_SEND_ACTION_NO_ACK); 3107 #endif /* CONFIG_OFFCHANNEL */ 3108 break; 3109 } 3110 #endif /* CONFIG_AP */ 3111 #ifdef CONFIG_OFFCHANNEL 3112 wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS pending_dst=" 3113 MACSTR, MAC2STR(wpa_s->parent->pending_action_dst)); 3114 /* 3115 * Catch TX status events for Action frames we sent via group 3116 * interface in GO mode. 3117 */ 3118 if (data->tx_status.type == WLAN_FC_TYPE_MGMT && 3119 data->tx_status.stype == WLAN_FC_STYPE_ACTION && 3120 os_memcmp(wpa_s->parent->pending_action_dst, 3121 data->tx_status.dst, ETH_ALEN) == 0) { 3122 offchannel_send_action_tx_status( 3123 wpa_s->parent, data->tx_status.dst, 3124 data->tx_status.data, 3125 data->tx_status.data_len, 3126 data->tx_status.ack ? 3127 OFFCHANNEL_SEND_ACTION_SUCCESS : 3128 OFFCHANNEL_SEND_ACTION_NO_ACK); 3129 break; 3130 } 3131 #endif /* CONFIG_OFFCHANNEL */ 3132 #ifdef CONFIG_AP 3133 switch (data->tx_status.type) { 3134 case WLAN_FC_TYPE_MGMT: 3135 ap_mgmt_tx_cb(wpa_s, data->tx_status.data, 3136 data->tx_status.data_len, 3137 data->tx_status.stype, 3138 data->tx_status.ack); 3139 break; 3140 case WLAN_FC_TYPE_DATA: 3141 ap_tx_status(wpa_s, data->tx_status.dst, 3142 data->tx_status.data, 3143 data->tx_status.data_len, 3144 data->tx_status.ack); 3145 break; 3146 } 3147 #endif /* CONFIG_AP */ 3148 break; 3149 #ifdef CONFIG_AP 3150 case EVENT_EAPOL_TX_STATUS: 3151 ap_eapol_tx_status(wpa_s, data->eapol_tx_status.dst, 3152 data->eapol_tx_status.data, 3153 data->eapol_tx_status.data_len, 3154 data->eapol_tx_status.ack); 3155 break; 3156 case EVENT_DRIVER_CLIENT_POLL_OK: 3157 ap_client_poll_ok(wpa_s, data->client_poll.addr); 3158 break; 3159 case EVENT_RX_FROM_UNKNOWN: 3160 if (wpa_s->ap_iface == NULL) 3161 break; 3162 ap_rx_from_unknown_sta(wpa_s, data->rx_from_unknown.addr, 3163 data->rx_from_unknown.wds); 3164 break; 3165 case EVENT_CH_SWITCH: 3166 if (!data) 3167 break; 3168 if (!wpa_s->ap_iface) { 3169 wpa_dbg(wpa_s, MSG_DEBUG, "AP: Ignore channel switch " 3170 "event in non-AP mode"); 3171 break; 3172 } 3173 3174 wpas_ap_ch_switch(wpa_s, data->ch_switch.freq, 3175 data->ch_switch.ht_enabled, 3176 data->ch_switch.ch_offset, 3177 data->ch_switch.ch_width, 3178 data->ch_switch.cf1, 3179 data->ch_switch.cf2); 3180 break; 3181 #endif /* CONFIG_AP */ 3182 case EVENT_RX_MGMT: { 3183 u16 fc, stype; 3184 const struct ieee80211_mgmt *mgmt; 3185 3186 #ifdef CONFIG_TESTING_OPTIONS 3187 if (wpa_s->ext_mgmt_frame_handling) { 3188 struct rx_mgmt *rx = &data->rx_mgmt; 3189 size_t hex_len = 2 * rx->frame_len + 1; 3190 char *hex = os_malloc(hex_len); 3191 if (hex) { 3192 wpa_snprintf_hex(hex, hex_len, 3193 rx->frame, rx->frame_len); 3194 wpa_msg(wpa_s, MSG_INFO, "MGMT-RX freq=%d datarate=%u ssi_signal=%d %s", 3195 rx->freq, rx->datarate, rx->ssi_signal, 3196 hex); 3197 os_free(hex); 3198 } 3199 break; 3200 } 3201 #endif /* CONFIG_TESTING_OPTIONS */ 3202 3203 mgmt = (const struct ieee80211_mgmt *) 3204 data->rx_mgmt.frame; 3205 fc = le_to_host16(mgmt->frame_control); 3206 stype = WLAN_FC_GET_STYPE(fc); 3207 3208 #ifdef CONFIG_AP 3209 if (wpa_s->ap_iface == NULL) { 3210 #endif /* CONFIG_AP */ 3211 #ifdef CONFIG_P2P 3212 if (stype == WLAN_FC_STYPE_PROBE_REQ && 3213 data->rx_mgmt.frame_len > 24) { 3214 const u8 *src = mgmt->sa; 3215 const u8 *ie = mgmt->u.probe_req.variable; 3216 size_t ie_len = data->rx_mgmt.frame_len - 3217 (mgmt->u.probe_req.variable - 3218 data->rx_mgmt.frame); 3219 wpas_p2p_probe_req_rx( 3220 wpa_s, src, mgmt->da, 3221 mgmt->bssid, ie, ie_len, 3222 data->rx_mgmt.ssi_signal); 3223 break; 3224 } 3225 #endif /* CONFIG_P2P */ 3226 #ifdef CONFIG_IBSS_RSN 3227 if (stype == WLAN_FC_STYPE_AUTH && 3228 data->rx_mgmt.frame_len >= 30) { 3229 wpa_supplicant_event_ibss_auth(wpa_s, data); 3230 break; 3231 } 3232 #endif /* CONFIG_IBSS_RSN */ 3233 3234 if (stype == WLAN_FC_STYPE_ACTION) { 3235 wpas_event_rx_mgmt_action( 3236 wpa_s, data->rx_mgmt.frame, 3237 data->rx_mgmt.frame_len, 3238 data->rx_mgmt.freq); 3239 break; 3240 } 3241 3242 wpa_dbg(wpa_s, MSG_DEBUG, "AP: ignore received " 3243 "management frame in non-AP mode"); 3244 break; 3245 #ifdef CONFIG_AP 3246 } 3247 3248 if (stype == WLAN_FC_STYPE_PROBE_REQ && 3249 data->rx_mgmt.frame_len > 24) { 3250 const u8 *ie = mgmt->u.probe_req.variable; 3251 size_t ie_len = data->rx_mgmt.frame_len - 3252 (mgmt->u.probe_req.variable - 3253 data->rx_mgmt.frame); 3254 3255 wpas_notify_preq(wpa_s, mgmt->sa, mgmt->da, 3256 mgmt->bssid, ie, ie_len, 3257 data->rx_mgmt.ssi_signal); 3258 } 3259 3260 ap_mgmt_rx(wpa_s, &data->rx_mgmt); 3261 #endif /* CONFIG_AP */ 3262 break; 3263 } 3264 case EVENT_RX_PROBE_REQ: 3265 if (data->rx_probe_req.sa == NULL || 3266 data->rx_probe_req.ie == NULL) 3267 break; 3268 #ifdef CONFIG_AP 3269 if (wpa_s->ap_iface) { 3270 hostapd_probe_req_rx(wpa_s->ap_iface->bss[0], 3271 data->rx_probe_req.sa, 3272 data->rx_probe_req.da, 3273 data->rx_probe_req.bssid, 3274 data->rx_probe_req.ie, 3275 data->rx_probe_req.ie_len, 3276 data->rx_probe_req.ssi_signal); 3277 break; 3278 } 3279 #endif /* CONFIG_AP */ 3280 wpas_p2p_probe_req_rx(wpa_s, data->rx_probe_req.sa, 3281 data->rx_probe_req.da, 3282 data->rx_probe_req.bssid, 3283 data->rx_probe_req.ie, 3284 data->rx_probe_req.ie_len, 3285 data->rx_probe_req.ssi_signal); 3286 break; 3287 case EVENT_REMAIN_ON_CHANNEL: 3288 #ifdef CONFIG_OFFCHANNEL 3289 offchannel_remain_on_channel_cb( 3290 wpa_s, data->remain_on_channel.freq, 3291 data->remain_on_channel.duration); 3292 #endif /* CONFIG_OFFCHANNEL */ 3293 wpas_p2p_remain_on_channel_cb( 3294 wpa_s, data->remain_on_channel.freq, 3295 data->remain_on_channel.duration); 3296 break; 3297 case EVENT_CANCEL_REMAIN_ON_CHANNEL: 3298 #ifdef CONFIG_OFFCHANNEL 3299 offchannel_cancel_remain_on_channel_cb( 3300 wpa_s, data->remain_on_channel.freq); 3301 #endif /* CONFIG_OFFCHANNEL */ 3302 wpas_p2p_cancel_remain_on_channel_cb( 3303 wpa_s, data->remain_on_channel.freq); 3304 break; 3305 case EVENT_EAPOL_RX: 3306 wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src, 3307 data->eapol_rx.data, 3308 data->eapol_rx.data_len); 3309 break; 3310 case EVENT_SIGNAL_CHANGE: 3311 wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SIGNAL_CHANGE 3312 "above=%d signal=%d noise=%d txrate=%d", 3313 data->signal_change.above_threshold, 3314 data->signal_change.current_signal, 3315 data->signal_change.current_noise, 3316 data->signal_change.current_txrate); 3317 bgscan_notify_signal_change( 3318 wpa_s, data->signal_change.above_threshold, 3319 data->signal_change.current_signal, 3320 data->signal_change.current_noise, 3321 data->signal_change.current_txrate); 3322 break; 3323 case EVENT_INTERFACE_ENABLED: 3324 wpa_dbg(wpa_s, MSG_DEBUG, "Interface was enabled"); 3325 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) { 3326 wpa_supplicant_update_mac_addr(wpa_s); 3327 if (wpa_s->p2p_mgmt) { 3328 wpa_supplicant_set_state(wpa_s, 3329 WPA_DISCONNECTED); 3330 break; 3331 } 3332 3333 #ifdef CONFIG_AP 3334 if (!wpa_s->ap_iface) { 3335 wpa_supplicant_set_state(wpa_s, 3336 WPA_DISCONNECTED); 3337 wpa_supplicant_req_scan(wpa_s, 0, 0); 3338 } else 3339 wpa_supplicant_set_state(wpa_s, 3340 WPA_COMPLETED); 3341 #else /* CONFIG_AP */ 3342 wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED); 3343 wpa_supplicant_req_scan(wpa_s, 0, 0); 3344 #endif /* CONFIG_AP */ 3345 } 3346 break; 3347 case EVENT_INTERFACE_DISABLED: 3348 wpa_dbg(wpa_s, MSG_DEBUG, "Interface was disabled"); 3349 #ifdef CONFIG_P2P 3350 if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO || 3351 (wpa_s->current_ssid && wpa_s->current_ssid->p2p_group && 3352 wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)) { 3353 /* 3354 * The interface was externally disabled. Remove 3355 * it assuming an external entity will start a 3356 * new session if needed. 3357 */ 3358 wpas_p2p_disconnect(wpa_s); 3359 break; 3360 } 3361 if (wpa_s->p2p_scan_work && wpa_s->global->p2p && 3362 p2p_in_progress(wpa_s->global->p2p) > 1) { 3363 /* This radio work will be cancelled, so clear P2P 3364 * state as well. 3365 */ 3366 p2p_stop_find(wpa_s->global->p2p); 3367 } 3368 #endif /* CONFIG_P2P */ 3369 3370 if (wpa_s->wpa_state >= WPA_AUTHENTICATING) { 3371 /* 3372 * Indicate disconnection to keep ctrl_iface events 3373 * consistent. 3374 */ 3375 wpa_supplicant_event_disassoc( 3376 wpa_s, WLAN_REASON_DEAUTH_LEAVING, 1); 3377 } 3378 wpa_supplicant_mark_disassoc(wpa_s); 3379 radio_remove_works(wpa_s, NULL, 0); 3380 3381 wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED); 3382 break; 3383 case EVENT_CHANNEL_LIST_CHANGED: 3384 wpa_supplicant_update_channel_list( 3385 wpa_s, &data->channel_list_changed); 3386 break; 3387 case EVENT_INTERFACE_UNAVAILABLE: 3388 wpas_p2p_interface_unavailable(wpa_s); 3389 break; 3390 case EVENT_BEST_CHANNEL: 3391 wpa_dbg(wpa_s, MSG_DEBUG, "Best channel event received " 3392 "(%d %d %d)", 3393 data->best_chan.freq_24, data->best_chan.freq_5, 3394 data->best_chan.freq_overall); 3395 wpa_s->best_24_freq = data->best_chan.freq_24; 3396 wpa_s->best_5_freq = data->best_chan.freq_5; 3397 wpa_s->best_overall_freq = data->best_chan.freq_overall; 3398 wpas_p2p_update_best_channels(wpa_s, data->best_chan.freq_24, 3399 data->best_chan.freq_5, 3400 data->best_chan.freq_overall); 3401 break; 3402 case EVENT_UNPROT_DEAUTH: 3403 wpa_supplicant_event_unprot_deauth(wpa_s, 3404 &data->unprot_deauth); 3405 break; 3406 case EVENT_UNPROT_DISASSOC: 3407 wpa_supplicant_event_unprot_disassoc(wpa_s, 3408 &data->unprot_disassoc); 3409 break; 3410 case EVENT_STATION_LOW_ACK: 3411 #ifdef CONFIG_AP 3412 if (wpa_s->ap_iface && data) 3413 hostapd_event_sta_low_ack(wpa_s->ap_iface->bss[0], 3414 data->low_ack.addr); 3415 #endif /* CONFIG_AP */ 3416 #ifdef CONFIG_TDLS 3417 if (data) 3418 wpa_tdls_disable_unreachable_link(wpa_s->wpa, 3419 data->low_ack.addr); 3420 #endif /* CONFIG_TDLS */ 3421 break; 3422 case EVENT_IBSS_PEER_LOST: 3423 #ifdef CONFIG_IBSS_RSN 3424 ibss_rsn_stop(wpa_s->ibss_rsn, data->ibss_peer_lost.peer); 3425 #endif /* CONFIG_IBSS_RSN */ 3426 break; 3427 case EVENT_DRIVER_GTK_REKEY: 3428 if (os_memcmp(data->driver_gtk_rekey.bssid, 3429 wpa_s->bssid, ETH_ALEN)) 3430 break; 3431 if (!wpa_s->wpa) 3432 break; 3433 wpa_sm_update_replay_ctr(wpa_s->wpa, 3434 data->driver_gtk_rekey.replay_ctr); 3435 break; 3436 case EVENT_SCHED_SCAN_STOPPED: 3437 wpa_s->pno = 0; 3438 wpa_s->sched_scanning = 0; 3439 wpa_supplicant_notify_scanning(wpa_s, 0); 3440 3441 if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) 3442 break; 3443 3444 /* 3445 * Start a new sched scan to continue searching for more SSIDs 3446 * either if timed out or PNO schedule scan is pending. 3447 */ 3448 if (wpa_s->sched_scan_timed_out) { 3449 wpa_supplicant_req_sched_scan(wpa_s); 3450 } else if (wpa_s->pno_sched_pending) { 3451 wpa_s->pno_sched_pending = 0; 3452 wpas_start_pno(wpa_s); 3453 } 3454 3455 break; 3456 case EVENT_WPS_BUTTON_PUSHED: 3457 #ifdef CONFIG_WPS 3458 wpas_wps_start_pbc(wpa_s, NULL, 0); 3459 #endif /* CONFIG_WPS */ 3460 break; 3461 case EVENT_AVOID_FREQUENCIES: 3462 wpa_supplicant_notify_avoid_freq(wpa_s, data); 3463 break; 3464 case EVENT_CONNECT_FAILED_REASON: 3465 #ifdef CONFIG_AP 3466 if (!wpa_s->ap_iface || !data) 3467 break; 3468 hostapd_event_connect_failed_reason( 3469 wpa_s->ap_iface->bss[0], 3470 data->connect_failed_reason.addr, 3471 data->connect_failed_reason.code); 3472 #endif /* CONFIG_AP */ 3473 break; 3474 default: 3475 wpa_msg(wpa_s, MSG_INFO, "Unknown event %d", event); 3476 break; 3477 } 3478 } 3479
