1/* 2 * hostapd / Callback functions for driver wrappers 3 * Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi> 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9#include "utils/includes.h" 10 11#include "utils/common.h" 12#include "utils/eloop.h" 13#include "radius/radius.h" 14#include "drivers/driver.h" 15#include "common/ieee802_11_defs.h" 16#include "common/ieee802_11_common.h" 17#include "common/wpa_ctrl.h" 18#include "common/dpp.h" 19#include "crypto/random.h" 20#include "p2p/p2p.h" 21#include "wps/wps.h" 22#include "fst/fst.h" 23#include "wnm_ap.h" 24#include "hostapd.h" 25#include "ieee802_11.h" 26#include "ieee802_11_auth.h" 27#include "sta_info.h" 28#include "accounting.h" 29#include "tkip_countermeasures.h" 30#include "ieee802_1x.h" 31#include "wpa_auth.h" 32#include "wps_hostapd.h" 33#include "ap_drv_ops.h" 34#include "ap_config.h" 35#include "ap_mlme.h" 36#include "hw_features.h" 37#include "dfs.h" 38#include "beacon.h" 39#include "mbo_ap.h" 40#include "dpp_hostapd.h" 41#include "fils_hlp.h" 42#include "neighbor_db.h" 43 44 45#ifdef CONFIG_FILS 46void hostapd_notify_assoc_fils_finish(struct hostapd_data *hapd, 47 struct sta_info *sta) 48{ 49 u16 reply_res = WLAN_STATUS_SUCCESS; 50 struct ieee802_11_elems elems; 51 u8 buf[IEEE80211_MAX_MMPDU_SIZE], *p = buf; 52 int new_assoc; 53 54 wpa_printf(MSG_DEBUG, "%s FILS: Finish association with " MACSTR, 55 __func__, MAC2STR(sta->addr)); 56 eloop_cancel_timeout(fils_hlp_timeout, hapd, sta); 57 if (!sta->fils_pending_assoc_req) 58 return; 59 60 ieee802_11_parse_elems(sta->fils_pending_assoc_req, 61 sta->fils_pending_assoc_req_len, &elems, 0); 62 if (!elems.fils_session) { 63 wpa_printf(MSG_DEBUG, "%s failed to find FILS Session element", 64 __func__); 65 return; 66 } 67 68 p = hostapd_eid_assoc_fils_session(sta->wpa_sm, p, 69 elems.fils_session, 70 sta->fils_hlp_resp); 71 72 reply_res = hostapd_sta_assoc(hapd, sta->addr, 73 sta->fils_pending_assoc_is_reassoc, 74 WLAN_STATUS_SUCCESS, 75 buf, p - buf); 76 ap_sta_set_authorized(hapd, sta, 1); 77 new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0; 78 sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC; 79 sta->flags &= ~WLAN_STA_WNM_SLEEP_MODE; 80 hostapd_set_sta_flags(hapd, sta); 81 wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC_FILS); 82 ieee802_1x_notify_port_enabled(sta->eapol_sm, 1); 83 hostapd_new_assoc_sta(hapd, sta, !new_assoc); 84 os_free(sta->fils_pending_assoc_req); 85 sta->fils_pending_assoc_req = NULL; 86 sta->fils_pending_assoc_req_len = 0; 87 wpabuf_free(sta->fils_hlp_resp); 88 sta->fils_hlp_resp = NULL; 89 wpabuf_free(sta->hlp_dhcp_discover); 90 sta->hlp_dhcp_discover = NULL; 91 fils_hlp_deinit(hapd); 92 93 /* 94 * Remove the station in case transmission of a success response fails 95 * (the STA was added associated to the driver) or if the station was 96 * previously added unassociated. 97 */ 98 if (reply_res != WLAN_STATUS_SUCCESS || sta->added_unassoc) { 99 hostapd_drv_sta_remove(hapd, sta->addr); 100 sta->added_unassoc = 0; 101 } 102} 103#endif /* CONFIG_FILS */ 104 105 106int hostapd_notif_assoc(struct hostapd_data *hapd, const u8 *addr, 107 const u8 *req_ies, size_t req_ies_len, int reassoc) 108{ 109 struct sta_info *sta; 110 int new_assoc, res; 111 struct ieee802_11_elems elems; 112 const u8 *ie; 113 size_t ielen; 114#if defined(CONFIG_IEEE80211R_AP) || defined(CONFIG_IEEE80211W) || defined(CONFIG_FILS) || defined(CONFIG_OWE) 115 u8 buf[sizeof(struct ieee80211_mgmt) + 1024]; 116 u8 *p = buf; 117#endif /* CONFIG_IEEE80211R_AP || CONFIG_IEEE80211W || CONFIG_FILS || CONFIG_OWE */ 118 u16 reason = WLAN_REASON_UNSPECIFIED; 119 u16 status = WLAN_STATUS_SUCCESS; 120 const u8 *p2p_dev_addr = NULL; 121 122 if (addr == NULL) { 123 /* 124 * This could potentially happen with unexpected event from the 125 * driver wrapper. This was seen at least in one case where the 126 * driver ended up being set to station mode while hostapd was 127 * running, so better make sure we stop processing such an 128 * event here. 129 */ 130 wpa_printf(MSG_DEBUG, 131 "hostapd_notif_assoc: Skip event with no address"); 132 return -1; 133 } 134 random_add_randomness(addr, ETH_ALEN); 135 136 hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, 137 HOSTAPD_LEVEL_INFO, "associated"); 138 139 ieee802_11_parse_elems(req_ies, req_ies_len, &elems, 0); 140 if (elems.wps_ie) { 141 ie = elems.wps_ie - 2; 142 ielen = elems.wps_ie_len + 2; 143 wpa_printf(MSG_DEBUG, "STA included WPS IE in (Re)AssocReq"); 144 } else if (elems.rsn_ie) { 145 ie = elems.rsn_ie - 2; 146 ielen = elems.rsn_ie_len + 2; 147 wpa_printf(MSG_DEBUG, "STA included RSN IE in (Re)AssocReq"); 148 } else if (elems.wpa_ie) { 149 ie = elems.wpa_ie - 2; 150 ielen = elems.wpa_ie_len + 2; 151 wpa_printf(MSG_DEBUG, "STA included WPA IE in (Re)AssocReq"); 152#ifdef CONFIG_HS20 153 } else if (elems.osen) { 154 ie = elems.osen - 2; 155 ielen = elems.osen_len + 2; 156 wpa_printf(MSG_DEBUG, "STA included OSEN IE in (Re)AssocReq"); 157#endif /* CONFIG_HS20 */ 158 } else { 159 ie = NULL; 160 ielen = 0; 161 wpa_printf(MSG_DEBUG, 162 "STA did not include WPS/RSN/WPA IE in (Re)AssocReq"); 163 } 164 165 sta = ap_get_sta(hapd, addr); 166 if (sta) { 167 ap_sta_no_session_timeout(hapd, sta); 168 accounting_sta_stop(hapd, sta); 169 170 /* 171 * Make sure that the previously registered inactivity timer 172 * will not remove the STA immediately. 173 */ 174 sta->timeout_next = STA_NULLFUNC; 175 } else { 176 sta = ap_sta_add(hapd, addr); 177 if (sta == NULL) { 178 hostapd_drv_sta_disassoc(hapd, addr, 179 WLAN_REASON_DISASSOC_AP_BUSY); 180 return -1; 181 } 182 } 183 sta->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS | WLAN_STA_WPS2); 184 185 /* 186 * ACL configurations to the drivers (implementing AP SME and ACL 187 * offload) without hostapd's knowledge, can result in a disconnection 188 * though the driver accepts the connection. Skip the hostapd check for 189 * ACL if the driver supports ACL offload to avoid potentially 190 * conflicting ACL rules. 191 */ 192 if (hapd->iface->drv_max_acl_mac_addrs == 0 && 193 hostapd_check_acl(hapd, addr, NULL) != HOSTAPD_ACL_ACCEPT) { 194 wpa_printf(MSG_INFO, "STA " MACSTR " not allowed to connect", 195 MAC2STR(addr)); 196 reason = WLAN_REASON_UNSPECIFIED; 197 goto fail; 198 } 199 200#ifdef CONFIG_P2P 201 if (elems.p2p) { 202 wpabuf_free(sta->p2p_ie); 203 sta->p2p_ie = ieee802_11_vendor_ie_concat(req_ies, req_ies_len, 204 P2P_IE_VENDOR_TYPE); 205 if (sta->p2p_ie) 206 p2p_dev_addr = p2p_get_go_dev_addr(sta->p2p_ie); 207 } 208#endif /* CONFIG_P2P */ 209 210#ifdef CONFIG_IEEE80211N 211#ifdef NEED_AP_MLME 212 if (elems.ht_capabilities && 213 (hapd->iface->conf->ht_capab & 214 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) { 215 struct ieee80211_ht_capabilities *ht_cap = 216 (struct ieee80211_ht_capabilities *) 217 elems.ht_capabilities; 218 219 if (le_to_host16(ht_cap->ht_capabilities_info) & 220 HT_CAP_INFO_40MHZ_INTOLERANT) 221 ht40_intolerant_add(hapd->iface, sta); 222 } 223#endif /* NEED_AP_MLME */ 224#endif /* CONFIG_IEEE80211N */ 225 226#ifdef CONFIG_INTERWORKING 227 if (elems.ext_capab && elems.ext_capab_len > 4) { 228 if (elems.ext_capab[4] & 0x01) 229 sta->qos_map_enabled = 1; 230 } 231#endif /* CONFIG_INTERWORKING */ 232 233#ifdef CONFIG_HS20 234 wpabuf_free(sta->hs20_ie); 235 if (elems.hs20 && elems.hs20_len > 4) { 236 sta->hs20_ie = wpabuf_alloc_copy(elems.hs20 + 4, 237 elems.hs20_len - 4); 238 } else 239 sta->hs20_ie = NULL; 240 241 wpabuf_free(sta->roaming_consortium); 242 if (elems.roaming_cons_sel) 243 sta->roaming_consortium = wpabuf_alloc_copy( 244 elems.roaming_cons_sel + 4, 245 elems.roaming_cons_sel_len - 4); 246 else 247 sta->roaming_consortium = NULL; 248#endif /* CONFIG_HS20 */ 249 250#ifdef CONFIG_FST 251 wpabuf_free(sta->mb_ies); 252 if (hapd->iface->fst) 253 sta->mb_ies = mb_ies_by_info(&elems.mb_ies); 254 else 255 sta->mb_ies = NULL; 256#endif /* CONFIG_FST */ 257 258 mbo_ap_check_sta_assoc(hapd, sta, &elems); 259 260 ap_copy_sta_supp_op_classes(sta, elems.supp_op_classes, 261 elems.supp_op_classes_len); 262 263 if (hapd->conf->wpa) { 264 if (ie == NULL || ielen == 0) { 265#ifdef CONFIG_WPS 266 if (hapd->conf->wps_state) { 267 wpa_printf(MSG_DEBUG, 268 "STA did not include WPA/RSN IE in (Re)Association Request - possible WPS use"); 269 sta->flags |= WLAN_STA_MAYBE_WPS; 270 goto skip_wpa_check; 271 } 272#endif /* CONFIG_WPS */ 273 274 wpa_printf(MSG_DEBUG, "No WPA/RSN IE from STA"); 275 reason = WLAN_REASON_INVALID_IE; 276 status = WLAN_STATUS_INVALID_IE; 277 goto fail; 278 } 279#ifdef CONFIG_WPS 280 if (hapd->conf->wps_state && ie[0] == 0xdd && ie[1] >= 4 && 281 os_memcmp(ie + 2, "\x00\x50\xf2\x04", 4) == 0) { 282 struct wpabuf *wps; 283 284 sta->flags |= WLAN_STA_WPS; 285 wps = ieee802_11_vendor_ie_concat(ie, ielen, 286 WPS_IE_VENDOR_TYPE); 287 if (wps) { 288 if (wps_is_20(wps)) { 289 wpa_printf(MSG_DEBUG, 290 "WPS: STA supports WPS 2.0"); 291 sta->flags |= WLAN_STA_WPS2; 292 } 293 wpabuf_free(wps); 294 } 295 goto skip_wpa_check; 296 } 297#endif /* CONFIG_WPS */ 298 299 if (sta->wpa_sm == NULL) 300 sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, 301 sta->addr, 302 p2p_dev_addr); 303 if (sta->wpa_sm == NULL) { 304 wpa_printf(MSG_ERROR, 305 "Failed to initialize WPA state machine"); 306 return -1; 307 } 308 res = wpa_validate_wpa_ie(hapd->wpa_auth, sta->wpa_sm, 309 hapd->iface->freq, 310 ie, ielen, 311 elems.mdie, elems.mdie_len, 312 elems.owe_dh, elems.owe_dh_len); 313 if (res != WPA_IE_OK) { 314 wpa_printf(MSG_DEBUG, 315 "WPA/RSN information element rejected? (res %u)", 316 res); 317 wpa_hexdump(MSG_DEBUG, "IE", ie, ielen); 318 if (res == WPA_INVALID_GROUP) { 319 reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID; 320 status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID; 321 } else if (res == WPA_INVALID_PAIRWISE) { 322 reason = WLAN_REASON_PAIRWISE_CIPHER_NOT_VALID; 323 status = WLAN_STATUS_PAIRWISE_CIPHER_NOT_VALID; 324 } else if (res == WPA_INVALID_AKMP) { 325 reason = WLAN_REASON_AKMP_NOT_VALID; 326 status = WLAN_STATUS_AKMP_NOT_VALID; 327 } 328#ifdef CONFIG_IEEE80211W 329 else if (res == WPA_MGMT_FRAME_PROTECTION_VIOLATION) { 330 reason = WLAN_REASON_INVALID_IE; 331 status = WLAN_STATUS_INVALID_IE; 332 } else if (res == WPA_INVALID_MGMT_GROUP_CIPHER) { 333 reason = WLAN_REASON_CIPHER_SUITE_REJECTED; 334 status = WLAN_STATUS_CIPHER_REJECTED_PER_POLICY; 335 } 336#endif /* CONFIG_IEEE80211W */ 337 else { 338 reason = WLAN_REASON_INVALID_IE; 339 status = WLAN_STATUS_INVALID_IE; 340 } 341 goto fail; 342 } 343#ifdef CONFIG_IEEE80211W 344 if ((sta->flags & (WLAN_STA_ASSOC | WLAN_STA_MFP)) == 345 (WLAN_STA_ASSOC | WLAN_STA_MFP) && 346 !sta->sa_query_timed_out && 347 sta->sa_query_count > 0) 348 ap_check_sa_query_timeout(hapd, sta); 349 if ((sta->flags & (WLAN_STA_ASSOC | WLAN_STA_MFP)) == 350 (WLAN_STA_ASSOC | WLAN_STA_MFP) && 351 !sta->sa_query_timed_out && 352 (sta->auth_alg != WLAN_AUTH_FT)) { 353 /* 354 * STA has already been associated with MFP and SA 355 * Query timeout has not been reached. Reject the 356 * association attempt temporarily and start SA Query, 357 * if one is not pending. 358 */ 359 360 if (sta->sa_query_count == 0) 361 ap_sta_start_sa_query(hapd, sta); 362 363 status = WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY; 364 365 p = hostapd_eid_assoc_comeback_time(hapd, sta, p); 366 367 hostapd_sta_assoc(hapd, addr, reassoc, status, buf, 368 p - buf); 369 return 0; 370 } 371 372 if (wpa_auth_uses_mfp(sta->wpa_sm)) 373 sta->flags |= WLAN_STA_MFP; 374 else 375 sta->flags &= ~WLAN_STA_MFP; 376#endif /* CONFIG_IEEE80211W */ 377 378#ifdef CONFIG_IEEE80211R_AP 379 if (sta->auth_alg == WLAN_AUTH_FT) { 380 status = wpa_ft_validate_reassoc(sta->wpa_sm, req_ies, 381 req_ies_len); 382 if (status != WLAN_STATUS_SUCCESS) { 383 if (status == WLAN_STATUS_INVALID_PMKID) 384 reason = WLAN_REASON_INVALID_IE; 385 if (status == WLAN_STATUS_INVALID_MDIE) 386 reason = WLAN_REASON_INVALID_IE; 387 if (status == WLAN_STATUS_INVALID_FTIE) 388 reason = WLAN_REASON_INVALID_IE; 389 goto fail; 390 } 391 } 392#endif /* CONFIG_IEEE80211R_AP */ 393 } else if (hapd->conf->wps_state) { 394#ifdef CONFIG_WPS 395 struct wpabuf *wps; 396 397 if (req_ies) 398 wps = ieee802_11_vendor_ie_concat(req_ies, req_ies_len, 399 WPS_IE_VENDOR_TYPE); 400 else 401 wps = NULL; 402#ifdef CONFIG_WPS_STRICT 403 if (wps && wps_validate_assoc_req(wps) < 0) { 404 reason = WLAN_REASON_INVALID_IE; 405 status = WLAN_STATUS_INVALID_IE; 406 wpabuf_free(wps); 407 goto fail; 408 } 409#endif /* CONFIG_WPS_STRICT */ 410 if (wps) { 411 sta->flags |= WLAN_STA_WPS; 412 if (wps_is_20(wps)) { 413 wpa_printf(MSG_DEBUG, 414 "WPS: STA supports WPS 2.0"); 415 sta->flags |= WLAN_STA_WPS2; 416 } 417 } else 418 sta->flags |= WLAN_STA_MAYBE_WPS; 419 wpabuf_free(wps); 420#endif /* CONFIG_WPS */ 421#ifdef CONFIG_HS20 422 } else if (hapd->conf->osen) { 423 if (elems.osen == NULL) { 424 hostapd_logger( 425 hapd, sta->addr, HOSTAPD_MODULE_IEEE80211, 426 HOSTAPD_LEVEL_INFO, 427 "No HS 2.0 OSEN element in association request"); 428 return WLAN_STATUS_INVALID_IE; 429 } 430 431 wpa_printf(MSG_DEBUG, "HS 2.0: OSEN association"); 432 if (sta->wpa_sm == NULL) 433 sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, 434 sta->addr, NULL); 435 if (sta->wpa_sm == NULL) { 436 wpa_printf(MSG_WARNING, 437 "Failed to initialize WPA state machine"); 438 return WLAN_STATUS_UNSPECIFIED_FAILURE; 439 } 440 if (wpa_validate_osen(hapd->wpa_auth, sta->wpa_sm, 441 elems.osen - 2, elems.osen_len + 2) < 0) 442 return WLAN_STATUS_INVALID_IE; 443#endif /* CONFIG_HS20 */ 444 } 445 446#ifdef CONFIG_MBO 447 if (hapd->conf->mbo_enabled && (hapd->conf->wpa & 2) && 448 elems.mbo && sta->cell_capa && !(sta->flags & WLAN_STA_MFP) && 449 hapd->conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) { 450 wpa_printf(MSG_INFO, 451 "MBO: Reject WPA2 association without PMF"); 452 return WLAN_STATUS_UNSPECIFIED_FAILURE; 453 } 454#endif /* CONFIG_MBO */ 455 456#ifdef CONFIG_WPS 457skip_wpa_check: 458#endif /* CONFIG_WPS */ 459 460#ifdef CONFIG_IEEE80211R_AP 461 p = wpa_sm_write_assoc_resp_ies(sta->wpa_sm, buf, sizeof(buf), 462 sta->auth_alg, req_ies, req_ies_len); 463 if (!p) { 464 wpa_printf(MSG_DEBUG, "FT: Failed to write AssocResp IEs"); 465 return WLAN_STATUS_UNSPECIFIED_FAILURE; 466 } 467#endif /* CONFIG_IEEE80211R_AP */ 468 469#ifdef CONFIG_FILS 470 if (sta->auth_alg == WLAN_AUTH_FILS_SK || 471 sta->auth_alg == WLAN_AUTH_FILS_SK_PFS || 472 sta->auth_alg == WLAN_AUTH_FILS_PK) { 473 int delay_assoc = 0; 474 475 if (!req_ies) 476 return WLAN_STATUS_UNSPECIFIED_FAILURE; 477 478 if (!wpa_fils_validate_fils_session(sta->wpa_sm, req_ies, 479 req_ies_len, 480 sta->fils_session)) { 481 wpa_printf(MSG_DEBUG, 482 "FILS: Session validation failed"); 483 return WLAN_STATUS_UNSPECIFIED_FAILURE; 484 } 485 486 res = wpa_fils_validate_key_confirm(sta->wpa_sm, req_ies, 487 req_ies_len); 488 if (res < 0) { 489 wpa_printf(MSG_DEBUG, 490 "FILS: Key Confirm validation failed"); 491 return WLAN_STATUS_UNSPECIFIED_FAILURE; 492 } 493 494 if (fils_process_hlp(hapd, sta, req_ies, req_ies_len) > 0) { 495 wpa_printf(MSG_DEBUG, 496 "FILS: Delaying Assoc Response (HLP)"); 497 delay_assoc = 1; 498 } else { 499 wpa_printf(MSG_DEBUG, 500 "FILS: Going ahead with Assoc Response (no HLP)"); 501 } 502 503 if (sta) { 504 wpa_printf(MSG_DEBUG, "FILS: HLP callback cleanup"); 505 eloop_cancel_timeout(fils_hlp_timeout, hapd, sta); 506 os_free(sta->fils_pending_assoc_req); 507 sta->fils_pending_assoc_req = NULL; 508 sta->fils_pending_assoc_req_len = 0; 509 wpabuf_free(sta->fils_hlp_resp); 510 sta->fils_hlp_resp = NULL; 511 sta->fils_drv_assoc_finish = 0; 512 } 513 514 if (sta && delay_assoc && status == WLAN_STATUS_SUCCESS) { 515 u8 *req_tmp; 516 517 req_tmp = os_malloc(req_ies_len); 518 if (!req_tmp) { 519 wpa_printf(MSG_DEBUG, 520 "FILS: buffer allocation failed for assoc req"); 521 goto fail; 522 } 523 os_memcpy(req_tmp, req_ies, req_ies_len); 524 sta->fils_pending_assoc_req = req_tmp; 525 sta->fils_pending_assoc_req_len = req_ies_len; 526 sta->fils_pending_assoc_is_reassoc = reassoc; 527 sta->fils_drv_assoc_finish = 1; 528 wpa_printf(MSG_DEBUG, 529 "FILS: Waiting for HLP processing before sending (Re)Association Response frame to " 530 MACSTR, MAC2STR(sta->addr)); 531 eloop_register_timeout( 532 0, hapd->conf->fils_hlp_wait_time * 1024, 533 fils_hlp_timeout, hapd, sta); 534 return 0; 535 } 536 p = hostapd_eid_assoc_fils_session(sta->wpa_sm, p, 537 elems.fils_session, 538 sta->fils_hlp_resp); 539 wpa_hexdump(MSG_DEBUG, "FILS Assoc Resp BUF (IEs)", 540 buf, p - buf); 541 } 542#endif /* CONFIG_FILS */ 543 544#ifdef CONFIG_OWE 545 if ((hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_OWE) && 546 wpa_auth_sta_key_mgmt(sta->wpa_sm) == WPA_KEY_MGMT_OWE && 547 elems.owe_dh) { 548 u8 *npos; 549 550 npos = owe_assoc_req_process(hapd, sta, 551 elems.owe_dh, elems.owe_dh_len, 552 p, sizeof(buf) - (p - buf), 553 &reason); 554 if (npos) 555 p = npos; 556 if (!npos && 557 reason == WLAN_STATUS_FINITE_CYCLIC_GROUP_NOT_SUPPORTED) { 558 status = WLAN_STATUS_FINITE_CYCLIC_GROUP_NOT_SUPPORTED; 559 hostapd_sta_assoc(hapd, addr, reassoc, status, buf, 560 p - buf); 561 return 0; 562 } 563 564 if (!npos || reason != WLAN_STATUS_SUCCESS) 565 goto fail; 566 } 567#endif /* CONFIG_OWE */ 568 569#ifdef CONFIG_DPP2 570 dpp_pfs_free(sta->dpp_pfs); 571 sta->dpp_pfs = NULL; 572 573 if ((hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_DPP) && 574 hapd->conf->dpp_netaccesskey && sta->wpa_sm && 575 wpa_auth_sta_key_mgmt(sta->wpa_sm) == WPA_KEY_MGMT_DPP && 576 elems.owe_dh) { 577 sta->dpp_pfs = dpp_pfs_init( 578 wpabuf_head(hapd->conf->dpp_netaccesskey), 579 wpabuf_len(hapd->conf->dpp_netaccesskey)); 580 if (!sta->dpp_pfs) { 581 wpa_printf(MSG_DEBUG, 582 "DPP: Could not initialize PFS"); 583 /* Try to continue without PFS */ 584 goto pfs_fail; 585 } 586 587 if (dpp_pfs_process(sta->dpp_pfs, elems.owe_dh, 588 elems.owe_dh_len) < 0) { 589 dpp_pfs_free(sta->dpp_pfs); 590 sta->dpp_pfs = NULL; 591 reason = WLAN_REASON_UNSPECIFIED; 592 goto fail; 593 } 594 } 595 596 wpa_auth_set_dpp_z(sta->wpa_sm, sta->dpp_pfs ? 597 sta->dpp_pfs->secret : NULL); 598 pfs_fail: 599#endif /* CONFIG_DPP2 */ 600 601#if defined(CONFIG_IEEE80211R_AP) || defined(CONFIG_FILS) || defined(CONFIG_OWE) 602 hostapd_sta_assoc(hapd, addr, reassoc, status, buf, p - buf); 603 604 if (sta->auth_alg == WLAN_AUTH_FT || 605 sta->auth_alg == WLAN_AUTH_FILS_SK || 606 sta->auth_alg == WLAN_AUTH_FILS_SK_PFS || 607 sta->auth_alg == WLAN_AUTH_FILS_PK) 608 ap_sta_set_authorized(hapd, sta, 1); 609#else /* CONFIG_IEEE80211R_AP || CONFIG_FILS */ 610 /* Keep compiler silent about unused variables */ 611 if (status) { 612 } 613#endif /* CONFIG_IEEE80211R_AP || CONFIG_FILS */ 614 615 new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0; 616 sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC; 617 sta->flags &= ~WLAN_STA_WNM_SLEEP_MODE; 618 619 hostapd_set_sta_flags(hapd, sta); 620 621 if (reassoc && (sta->auth_alg == WLAN_AUTH_FT)) 622 wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC_FT); 623#ifdef CONFIG_FILS 624 else if (sta->auth_alg == WLAN_AUTH_FILS_SK || 625 sta->auth_alg == WLAN_AUTH_FILS_SK_PFS || 626 sta->auth_alg == WLAN_AUTH_FILS_PK) 627 wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC_FILS); 628#endif /* CONFIG_FILS */ 629 else 630 wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC); 631 632 hostapd_new_assoc_sta(hapd, sta, !new_assoc); 633 634 ieee802_1x_notify_port_enabled(sta->eapol_sm, 1); 635 636#ifdef CONFIG_P2P 637 if (req_ies) { 638 p2p_group_notif_assoc(hapd->p2p_group, sta->addr, 639 req_ies, req_ies_len); 640 } 641#endif /* CONFIG_P2P */ 642 643 return 0; 644 645fail: 646#ifdef CONFIG_IEEE80211R_AP 647 hostapd_sta_assoc(hapd, addr, reassoc, status, buf, p - buf); 648#endif /* CONFIG_IEEE80211R_AP */ 649 hostapd_drv_sta_disassoc(hapd, sta->addr, reason); 650 ap_free_sta(hapd, sta); 651 return -1; 652} 653 654 655void hostapd_notif_disassoc(struct hostapd_data *hapd, const u8 *addr) 656{ 657 struct sta_info *sta; 658 659 if (addr == NULL) { 660 /* 661 * This could potentially happen with unexpected event from the 662 * driver wrapper. This was seen at least in one case where the 663 * driver ended up reporting a station mode event while hostapd 664 * was running, so better make sure we stop processing such an 665 * event here. 666 */ 667 wpa_printf(MSG_DEBUG, 668 "hostapd_notif_disassoc: Skip event with no address"); 669 return; 670 } 671 672 hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, 673 HOSTAPD_LEVEL_INFO, "disassociated"); 674 675 sta = ap_get_sta(hapd, addr); 676 if (sta == NULL) { 677 wpa_printf(MSG_DEBUG, 678 "Disassociation notification for unknown STA " 679 MACSTR, MAC2STR(addr)); 680 return; 681 } 682 683 ap_sta_set_authorized(hapd, sta, 0); 684 sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC); 685 wpa_auth_sm_event(sta->wpa_sm, WPA_DISASSOC); 686 sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST; 687 ieee802_1x_notify_port_enabled(sta->eapol_sm, 0); 688 ap_free_sta(hapd, sta); 689} 690 691 692void hostapd_event_sta_low_ack(struct hostapd_data *hapd, const u8 *addr) 693{ 694 struct sta_info *sta = ap_get_sta(hapd, addr); 695 696 if (!sta || !hapd->conf->disassoc_low_ack || sta->agreed_to_steer) 697 return; 698 699 hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, 700 HOSTAPD_LEVEL_INFO, 701 "disconnected due to excessive missing ACKs"); 702 hostapd_drv_sta_disassoc(hapd, addr, WLAN_REASON_DISASSOC_LOW_ACK); 703 ap_sta_disassociate(hapd, sta, WLAN_REASON_DISASSOC_LOW_ACK); 704} 705 706 707void hostapd_event_sta_opmode_changed(struct hostapd_data *hapd, const u8 *addr, 708 enum smps_mode smps_mode, 709 enum chan_width chan_width, u8 rx_nss) 710{ 711 struct sta_info *sta = ap_get_sta(hapd, addr); 712 const char *txt; 713 714 if (!sta) 715 return; 716 717 switch (smps_mode) { 718 case SMPS_AUTOMATIC: 719 txt = "automatic"; 720 break; 721 case SMPS_OFF: 722 txt = "off"; 723 break; 724 case SMPS_DYNAMIC: 725 txt = "dynamic"; 726 break; 727 case SMPS_STATIC: 728 txt = "static"; 729 break; 730 default: 731 txt = NULL; 732 break; 733 } 734 if (txt) { 735 wpa_msg(hapd->msg_ctx, MSG_INFO, STA_OPMODE_SMPS_MODE_CHANGED 736 MACSTR " %s", MAC2STR(addr), txt); 737 } 738 739 switch (chan_width) { 740 case CHAN_WIDTH_20_NOHT: 741 txt = "20(no-HT)"; 742 break; 743 case CHAN_WIDTH_20: 744 txt = "20"; 745 break; 746 case CHAN_WIDTH_40: 747 txt = "40"; 748 break; 749 case CHAN_WIDTH_80: 750 txt = "80"; 751 break; 752 case CHAN_WIDTH_80P80: 753 txt = "80+80"; 754 break; 755 case CHAN_WIDTH_160: 756 txt = "160"; 757 break; 758 default: 759 txt = NULL; 760 break; 761 } 762 if (txt) { 763 wpa_msg(hapd->msg_ctx, MSG_INFO, STA_OPMODE_MAX_BW_CHANGED 764 MACSTR " %s", MAC2STR(addr), txt); 765 } 766 767 if (rx_nss != 0xff) { 768 wpa_msg(hapd->msg_ctx, MSG_INFO, STA_OPMODE_N_SS_CHANGED 769 MACSTR " %d", MAC2STR(addr), rx_nss); 770 } 771} 772 773 774void hostapd_event_ch_switch(struct hostapd_data *hapd, int freq, int ht, 775 int offset, int width, int cf1, int cf2, 776 int finished) 777{ 778 /* TODO: If OCV is enabled deauth STAs that don't perform a SA Query */ 779 780#ifdef NEED_AP_MLME 781 int channel, chwidth, is_dfs; 782 u8 seg0_idx = 0, seg1_idx = 0; 783 size_t i; 784 785 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 786 HOSTAPD_LEVEL_INFO, 787 "driver %s channel switch: freq=%d, ht=%d, vht_ch=0x%x, offset=%d, width=%d (%s), cf1=%d, cf2=%d", 788 finished ? "had" : "starting", 789 freq, ht, hapd->iconf->ch_switch_vht_config, offset, 790 width, channel_width_to_string(width), cf1, cf2); 791 792 if (!hapd->iface->current_mode) { 793 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 794 HOSTAPD_LEVEL_WARNING, 795 "ignore channel switch since the interface is not yet ready"); 796 return; 797 } 798 799 hapd->iface->freq = freq; 800 801 channel = hostapd_hw_get_channel(hapd, freq); 802 if (!channel) { 803 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 804 HOSTAPD_LEVEL_WARNING, 805 "driver switched to bad channel!"); 806 return; 807 } 808 809 switch (width) { 810 case CHAN_WIDTH_80: 811 chwidth = CHANWIDTH_80MHZ; 812 break; 813 case CHAN_WIDTH_80P80: 814 chwidth = CHANWIDTH_80P80MHZ; 815 break; 816 case CHAN_WIDTH_160: 817 chwidth = CHANWIDTH_160MHZ; 818 break; 819 case CHAN_WIDTH_20_NOHT: 820 case CHAN_WIDTH_20: 821 case CHAN_WIDTH_40: 822 default: 823 chwidth = CHANWIDTH_USE_HT; 824 break; 825 } 826 827 switch (hapd->iface->current_mode->mode) { 828 case HOSTAPD_MODE_IEEE80211A: 829 if (cf1 > 5000) 830 seg0_idx = (cf1 - 5000) / 5; 831 if (cf2 > 5000) 832 seg1_idx = (cf2 - 5000) / 5; 833 break; 834 default: 835 ieee80211_freq_to_chan(cf1, &seg0_idx); 836 ieee80211_freq_to_chan(cf2, &seg1_idx); 837 break; 838 } 839 840 hapd->iconf->channel = channel; 841 hapd->iconf->ieee80211n = ht; 842 if (!ht) { 843 hapd->iconf->ieee80211ac = 0; 844 } else if (hapd->iconf->ch_switch_vht_config) { 845 /* CHAN_SWITCH VHT config */ 846 if (hapd->iconf->ch_switch_vht_config & 847 CH_SWITCH_VHT_ENABLED) 848 hapd->iconf->ieee80211ac = 1; 849 else if (hapd->iconf->ch_switch_vht_config & 850 CH_SWITCH_VHT_DISABLED) 851 hapd->iconf->ieee80211ac = 0; 852 } 853 hapd->iconf->ch_switch_vht_config = 0; 854 855 hapd->iconf->secondary_channel = offset; 856 hostapd_set_oper_chwidth(hapd->iconf, chwidth); 857 hostapd_set_oper_centr_freq_seg0_idx(hapd->iconf, seg0_idx); 858 hostapd_set_oper_centr_freq_seg1_idx(hapd->iconf, seg1_idx); 859 860 is_dfs = ieee80211_is_dfs(freq, hapd->iface->hw_features, 861 hapd->iface->num_hw_features); 862 863 wpa_msg(hapd->msg_ctx, MSG_INFO, 864 "%sfreq=%d ht_enabled=%d ch_offset=%d ch_width=%s cf1=%d cf2=%d dfs=%d", 865 finished ? WPA_EVENT_CHANNEL_SWITCH : 866 WPA_EVENT_CHANNEL_SWITCH_STARTED, 867 freq, ht, offset, channel_width_to_string(width), 868 cf1, cf2, is_dfs); 869 if (!finished) 870 return; 871 872 if (hapd->csa_in_progress && 873 freq == hapd->cs_freq_params.freq) { 874 hostapd_cleanup_cs_params(hapd); 875 ieee802_11_set_beacon(hapd); 876 877 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED 878 "freq=%d dfs=%d", freq, is_dfs); 879 } else if (hapd->iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) { 880 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED 881 "freq=%d dfs=%d", freq, is_dfs); 882 } 883 884 for (i = 0; i < hapd->iface->num_bss; i++) 885 hostapd_neighbor_set_own_report(hapd->iface->bss[i]); 886#endif /* NEED_AP_MLME */ 887} 888 889 890void hostapd_event_connect_failed_reason(struct hostapd_data *hapd, 891 const u8 *addr, int reason_code) 892{ 893 switch (reason_code) { 894 case MAX_CLIENT_REACHED: 895 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_REJECTED_MAX_STA MACSTR, 896 MAC2STR(addr)); 897 break; 898 case BLOCKED_CLIENT: 899 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_REJECTED_BLOCKED_STA MACSTR, 900 MAC2STR(addr)); 901 break; 902 } 903} 904 905 906#ifdef CONFIG_ACS 907void hostapd_acs_channel_selected(struct hostapd_data *hapd, 908 struct acs_selected_channels *acs_res) 909{ 910 int ret, i; 911 int err = 0; 912 913 if (hapd->iconf->channel) { 914 wpa_printf(MSG_INFO, "ACS: Channel was already set to %d", 915 hapd->iconf->channel); 916 return; 917 } 918 919 if (!hapd->iface->current_mode) { 920 for (i = 0; i < hapd->iface->num_hw_features; i++) { 921 struct hostapd_hw_modes *mode = 922 &hapd->iface->hw_features[i]; 923 924 if (mode->mode == acs_res->hw_mode) { 925 hapd->iface->current_mode = mode; 926 break; 927 } 928 } 929 if (!hapd->iface->current_mode) { 930 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 931 HOSTAPD_LEVEL_WARNING, 932 "driver selected to bad hw_mode"); 933 err = 1; 934 goto out; 935 } 936 } 937 938 hapd->iface->freq = hostapd_hw_get_freq(hapd, acs_res->pri_channel); 939 940 if (!acs_res->pri_channel) { 941 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 942 HOSTAPD_LEVEL_WARNING, 943 "driver switched to bad channel"); 944 err = 1; 945 goto out; 946 } 947 948 hapd->iconf->channel = acs_res->pri_channel; 949 hapd->iconf->acs = 1; 950 951 if (acs_res->sec_channel == 0) 952 hapd->iconf->secondary_channel = 0; 953 else if (acs_res->sec_channel < acs_res->pri_channel) 954 hapd->iconf->secondary_channel = -1; 955 else if (acs_res->sec_channel > acs_res->pri_channel) 956 hapd->iconf->secondary_channel = 1; 957 else { 958 wpa_printf(MSG_ERROR, "Invalid secondary channel!"); 959 err = 1; 960 goto out; 961 } 962 963 if (hapd->iface->conf->ieee80211ac || hapd->iface->conf->ieee80211ax) { 964 /* set defaults for backwards compatibility */ 965 hostapd_set_oper_centr_freq_seg1_idx(hapd->iconf, 0); 966 hostapd_set_oper_centr_freq_seg0_idx(hapd->iconf, 0); 967 hostapd_set_oper_chwidth(hapd->iconf, CHANWIDTH_USE_HT); 968 if (acs_res->ch_width == 80) { 969 hostapd_set_oper_centr_freq_seg0_idx( 970 hapd->iconf, acs_res->vht_seg0_center_ch); 971 hostapd_set_oper_chwidth(hapd->iconf, CHANWIDTH_80MHZ); 972 } else if (acs_res->ch_width == 160) { 973 if (acs_res->vht_seg1_center_ch == 0) { 974 hostapd_set_oper_centr_freq_seg0_idx( 975 hapd->iconf, 976 acs_res->vht_seg0_center_ch); 977 hostapd_set_oper_chwidth(hapd->iconf, 978 CHANWIDTH_160MHZ); 979 } else { 980 hostapd_set_oper_centr_freq_seg0_idx( 981 hapd->iconf, 982 acs_res->vht_seg0_center_ch); 983 hostapd_set_oper_centr_freq_seg1_idx( 984 hapd->iconf, 985 acs_res->vht_seg1_center_ch); 986 hostapd_set_oper_chwidth(hapd->iconf, 987 CHANWIDTH_80P80MHZ); 988 } 989 } 990 } 991 992out: 993 ret = hostapd_acs_completed(hapd->iface, err); 994 if (ret) { 995 wpa_printf(MSG_ERROR, 996 "ACS: Possibly channel configuration is invalid"); 997 } 998} 999#endif /* CONFIG_ACS */ 1000 1001 1002int hostapd_probe_req_rx(struct hostapd_data *hapd, const u8 *sa, const u8 *da, 1003 const u8 *bssid, const u8 *ie, size_t ie_len, 1004 int ssi_signal) 1005{ 1006 size_t i; 1007 int ret = 0; 1008 1009 if (sa == NULL || ie == NULL) 1010 return -1; 1011 1012 random_add_randomness(sa, ETH_ALEN); 1013 for (i = 0; hapd->probereq_cb && i < hapd->num_probereq_cb; i++) { 1014 if (hapd->probereq_cb[i].cb(hapd->probereq_cb[i].ctx, 1015 sa, da, bssid, ie, ie_len, 1016 ssi_signal) > 0) { 1017 ret = 1; 1018 break; 1019 } 1020 } 1021 return ret; 1022} 1023 1024 1025#ifdef HOSTAPD 1026 1027#ifdef CONFIG_IEEE80211R_AP 1028static void hostapd_notify_auth_ft_finish(void *ctx, const u8 *dst, 1029 const u8 *bssid, 1030 u16 auth_transaction, u16 status, 1031 const u8 *ies, size_t ies_len) 1032{ 1033 struct hostapd_data *hapd = ctx; 1034 struct sta_info *sta; 1035 1036 sta = ap_get_sta(hapd, dst); 1037 if (sta == NULL) 1038 return; 1039 1040 hostapd_logger(hapd, dst, HOSTAPD_MODULE_IEEE80211, 1041 HOSTAPD_LEVEL_DEBUG, "authentication OK (FT)"); 1042 sta->flags |= WLAN_STA_AUTH; 1043 1044 hostapd_sta_auth(hapd, dst, auth_transaction, status, ies, ies_len); 1045} 1046#endif /* CONFIG_IEEE80211R_AP */ 1047 1048 1049#ifdef CONFIG_FILS 1050static void hostapd_notify_auth_fils_finish(struct hostapd_data *hapd, 1051 struct sta_info *sta, u16 resp, 1052 struct wpabuf *data, int pub) 1053{ 1054 if (resp == WLAN_STATUS_SUCCESS) { 1055 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211, 1056 HOSTAPD_LEVEL_DEBUG, "authentication OK (FILS)"); 1057 sta->flags |= WLAN_STA_AUTH; 1058 wpa_auth_sm_event(sta->wpa_sm, WPA_AUTH); 1059 sta->auth_alg = WLAN_AUTH_FILS_SK; 1060 mlme_authenticate_indication(hapd, sta); 1061 } else { 1062 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211, 1063 HOSTAPD_LEVEL_DEBUG, 1064 "authentication failed (FILS)"); 1065 } 1066 1067 hostapd_sta_auth(hapd, sta->addr, 2, resp, 1068 data ? wpabuf_head(data) : NULL, 1069 data ? wpabuf_len(data) : 0); 1070 wpabuf_free(data); 1071} 1072#endif /* CONFIG_FILS */ 1073 1074 1075static void hostapd_notif_auth(struct hostapd_data *hapd, 1076 struct auth_info *rx_auth) 1077{ 1078 struct sta_info *sta; 1079 u16 status = WLAN_STATUS_SUCCESS; 1080 u8 resp_ies[2 + WLAN_AUTH_CHALLENGE_LEN]; 1081 size_t resp_ies_len = 0; 1082 1083 sta = ap_get_sta(hapd, rx_auth->peer); 1084 if (!sta) { 1085 sta = ap_sta_add(hapd, rx_auth->peer); 1086 if (sta == NULL) { 1087 status = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA; 1088 goto fail; 1089 } 1090 } 1091 sta->flags &= ~WLAN_STA_PREAUTH; 1092 ieee802_1x_notify_pre_auth(sta->eapol_sm, 0); 1093#ifdef CONFIG_IEEE80211R_AP 1094 if (rx_auth->auth_type == WLAN_AUTH_FT && hapd->wpa_auth) { 1095 sta->auth_alg = WLAN_AUTH_FT; 1096 if (sta->wpa_sm == NULL) 1097 sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, 1098 sta->addr, NULL); 1099 if (sta->wpa_sm == NULL) { 1100 wpa_printf(MSG_DEBUG, 1101 "FT: Failed to initialize WPA state machine"); 1102 status = WLAN_STATUS_UNSPECIFIED_FAILURE; 1103 goto fail; 1104 } 1105 wpa_ft_process_auth(sta->wpa_sm, rx_auth->bssid, 1106 rx_auth->auth_transaction, rx_auth->ies, 1107 rx_auth->ies_len, 1108 hostapd_notify_auth_ft_finish, hapd); 1109 return; 1110 } 1111#endif /* CONFIG_IEEE80211R_AP */ 1112 1113#ifdef CONFIG_FILS 1114 if (rx_auth->auth_type == WLAN_AUTH_FILS_SK) { 1115 sta->auth_alg = WLAN_AUTH_FILS_SK; 1116 handle_auth_fils(hapd, sta, rx_auth->ies, rx_auth->ies_len, 1117 rx_auth->auth_type, rx_auth->auth_transaction, 1118 rx_auth->status_code, 1119 hostapd_notify_auth_fils_finish); 1120 return; 1121 } 1122#endif /* CONFIG_FILS */ 1123 1124fail: 1125 hostapd_sta_auth(hapd, rx_auth->peer, rx_auth->auth_transaction + 1, 1126 status, resp_ies, resp_ies_len); 1127} 1128 1129 1130#ifndef NEED_AP_MLME 1131static void hostapd_action_rx(struct hostapd_data *hapd, 1132 struct rx_mgmt *drv_mgmt) 1133{ 1134 struct ieee80211_mgmt *mgmt; 1135 struct sta_info *sta; 1136 size_t plen __maybe_unused; 1137 u16 fc; 1138 u8 *action __maybe_unused; 1139 1140 if (drv_mgmt->frame_len < IEEE80211_HDRLEN + 2 + 1) 1141 return; 1142 1143 plen = drv_mgmt->frame_len - IEEE80211_HDRLEN; 1144 1145 mgmt = (struct ieee80211_mgmt *) drv_mgmt->frame; 1146 fc = le_to_host16(mgmt->frame_control); 1147 if (WLAN_FC_GET_STYPE(fc) != WLAN_FC_STYPE_ACTION) 1148 return; /* handled by the driver */ 1149 1150 action = (u8 *) &mgmt->u.action.u; 1151 wpa_printf(MSG_DEBUG, "RX_ACTION category %u action %u sa " MACSTR 1152 " da " MACSTR " plen %d", 1153 mgmt->u.action.category, *action, 1154 MAC2STR(mgmt->sa), MAC2STR(mgmt->da), (int) plen); 1155 1156 sta = ap_get_sta(hapd, mgmt->sa); 1157 if (sta == NULL) { 1158 wpa_printf(MSG_DEBUG, "%s: station not found", __func__); 1159 return; 1160 } 1161#ifdef CONFIG_IEEE80211R_AP 1162 if (mgmt->u.action.category == WLAN_ACTION_FT) { 1163 wpa_ft_action_rx(sta->wpa_sm, (u8 *) &mgmt->u.action, plen); 1164 return; 1165 } 1166#endif /* CONFIG_IEEE80211R_AP */ 1167#ifdef CONFIG_IEEE80211W 1168 if (mgmt->u.action.category == WLAN_ACTION_SA_QUERY) { 1169 ieee802_11_sa_query_action(hapd, mgmt, drv_mgmt->frame_len); 1170 return; 1171 } 1172#endif /* CONFIG_IEEE80211W */ 1173#ifdef CONFIG_WNM_AP 1174 if (mgmt->u.action.category == WLAN_ACTION_WNM) { 1175 ieee802_11_rx_wnm_action_ap(hapd, mgmt, drv_mgmt->frame_len); 1176 return; 1177 } 1178#endif /* CONFIG_WNM_AP */ 1179#ifdef CONFIG_FST 1180 if (mgmt->u.action.category == WLAN_ACTION_FST && hapd->iface->fst) { 1181 fst_rx_action(hapd->iface->fst, mgmt, drv_mgmt->frame_len); 1182 return; 1183 } 1184#endif /* CONFIG_FST */ 1185#ifdef CONFIG_DPP 1186 if (plen >= 2 + 4 && 1187 mgmt->u.action.u.vs_public_action.action == 1188 WLAN_PA_VENDOR_SPECIFIC && 1189 WPA_GET_BE24(mgmt->u.action.u.vs_public_action.oui) == 1190 OUI_WFA && 1191 mgmt->u.action.u.vs_public_action.variable[0] == 1192 DPP_OUI_TYPE) { 1193 const u8 *pos, *end; 1194 1195 pos = mgmt->u.action.u.vs_public_action.oui; 1196 end = drv_mgmt->frame + drv_mgmt->frame_len; 1197 hostapd_dpp_rx_action(hapd, mgmt->sa, pos, end - pos, 1198 drv_mgmt->freq); 1199 return; 1200 } 1201#endif /* CONFIG_DPP */ 1202} 1203#endif /* NEED_AP_MLME */ 1204 1205 1206#ifdef NEED_AP_MLME 1207 1208#define HAPD_BROADCAST ((struct hostapd_data *) -1) 1209 1210static struct hostapd_data * get_hapd_bssid(struct hostapd_iface *iface, 1211 const u8 *bssid) 1212{ 1213 size_t i; 1214 1215 if (bssid == NULL) 1216 return NULL; 1217 if (bssid[0] == 0xff && bssid[1] == 0xff && bssid[2] == 0xff && 1218 bssid[3] == 0xff && bssid[4] == 0xff && bssid[5] == 0xff) 1219 return HAPD_BROADCAST; 1220 1221 for (i = 0; i < iface->num_bss; i++) { 1222 if (os_memcmp(bssid, iface->bss[i]->own_addr, ETH_ALEN) == 0) 1223 return iface->bss[i]; 1224 } 1225 1226 return NULL; 1227} 1228 1229 1230static void hostapd_rx_from_unknown_sta(struct hostapd_data *hapd, 1231 const u8 *bssid, const u8 *addr, 1232 int wds) 1233{ 1234 hapd = get_hapd_bssid(hapd->iface, bssid); 1235 if (hapd == NULL || hapd == HAPD_BROADCAST) 1236 return; 1237 1238 ieee802_11_rx_from_unknown(hapd, addr, wds); 1239} 1240 1241 1242static int hostapd_mgmt_rx(struct hostapd_data *hapd, struct rx_mgmt *rx_mgmt) 1243{ 1244 struct hostapd_iface *iface = hapd->iface; 1245 const struct ieee80211_hdr *hdr; 1246 const u8 *bssid; 1247 struct hostapd_frame_info fi; 1248 int ret; 1249 1250#ifdef CONFIG_TESTING_OPTIONS 1251 if (hapd->ext_mgmt_frame_handling) { 1252 size_t hex_len = 2 * rx_mgmt->frame_len + 1; 1253 char *hex = os_malloc(hex_len); 1254 1255 if (hex) { 1256 wpa_snprintf_hex(hex, hex_len, rx_mgmt->frame, 1257 rx_mgmt->frame_len); 1258 wpa_msg(hapd->msg_ctx, MSG_INFO, "MGMT-RX %s", hex); 1259 os_free(hex); 1260 } 1261 return 1; 1262 } 1263#endif /* CONFIG_TESTING_OPTIONS */ 1264 1265 hdr = (const struct ieee80211_hdr *) rx_mgmt->frame; 1266 bssid = get_hdr_bssid(hdr, rx_mgmt->frame_len); 1267 if (bssid == NULL) 1268 return 0; 1269 1270 hapd = get_hapd_bssid(iface, bssid); 1271 if (hapd == NULL) { 1272 u16 fc = le_to_host16(hdr->frame_control); 1273 1274 /* 1275 * Drop frames to unknown BSSIDs except for Beacon frames which 1276 * could be used to update neighbor information. 1277 */ 1278 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1279 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) 1280 hapd = iface->bss[0]; 1281 else 1282 return 0; 1283 } 1284 1285 os_memset(&fi, 0, sizeof(fi)); 1286 fi.freq = rx_mgmt->freq; 1287 fi.datarate = rx_mgmt->datarate; 1288 fi.ssi_signal = rx_mgmt->ssi_signal; 1289 1290 if (hapd == HAPD_BROADCAST) { 1291 size_t i; 1292 1293 ret = 0; 1294 for (i = 0; i < iface->num_bss; i++) { 1295 /* if bss is set, driver will call this function for 1296 * each bss individually. */ 1297 if (rx_mgmt->drv_priv && 1298 (iface->bss[i]->drv_priv != rx_mgmt->drv_priv)) 1299 continue; 1300 1301 if (ieee802_11_mgmt(iface->bss[i], rx_mgmt->frame, 1302 rx_mgmt->frame_len, &fi) > 0) 1303 ret = 1; 1304 } 1305 } else 1306 ret = ieee802_11_mgmt(hapd, rx_mgmt->frame, rx_mgmt->frame_len, 1307 &fi); 1308 1309 random_add_randomness(&fi, sizeof(fi)); 1310 1311 return ret; 1312} 1313 1314 1315static void hostapd_mgmt_tx_cb(struct hostapd_data *hapd, const u8 *buf, 1316 size_t len, u16 stype, int ok) 1317{ 1318 struct ieee80211_hdr *hdr; 1319 struct hostapd_data *orig_hapd = hapd; 1320 1321 hdr = (struct ieee80211_hdr *) buf; 1322 hapd = get_hapd_bssid(hapd->iface, get_hdr_bssid(hdr, len)); 1323 if (!hapd) 1324 return; 1325 if (hapd == HAPD_BROADCAST) { 1326 if (stype != WLAN_FC_STYPE_ACTION || len <= 25 || 1327 buf[24] != WLAN_ACTION_PUBLIC) 1328 return; 1329 hapd = get_hapd_bssid(orig_hapd->iface, hdr->addr2); 1330 if (!hapd || hapd == HAPD_BROADCAST) 1331 return; 1332 /* 1333 * Allow processing of TX status for a Public Action frame that 1334 * used wildcard BBSID. 1335 */ 1336 } 1337 ieee802_11_mgmt_cb(hapd, buf, len, stype, ok); 1338} 1339 1340#endif /* NEED_AP_MLME */ 1341 1342 1343static int hostapd_event_new_sta(struct hostapd_data *hapd, const u8 *addr) 1344{ 1345 struct sta_info *sta = ap_get_sta(hapd, addr); 1346 1347 if (sta) 1348 return 0; 1349 1350 wpa_printf(MSG_DEBUG, "Data frame from unknown STA " MACSTR 1351 " - adding a new STA", MAC2STR(addr)); 1352 sta = ap_sta_add(hapd, addr); 1353 if (sta) { 1354 hostapd_new_assoc_sta(hapd, sta, 0); 1355 } else { 1356 wpa_printf(MSG_DEBUG, "Failed to add STA entry for " MACSTR, 1357 MAC2STR(addr)); 1358 return -1; 1359 } 1360 1361 return 0; 1362} 1363 1364 1365static void hostapd_event_eapol_rx(struct hostapd_data *hapd, const u8 *src, 1366 const u8 *data, size_t data_len) 1367{ 1368 struct hostapd_iface *iface = hapd->iface; 1369 struct sta_info *sta; 1370 size_t j; 1371 1372 for (j = 0; j < iface->num_bss; j++) { 1373 sta = ap_get_sta(iface->bss[j], src); 1374 if (sta && sta->flags & WLAN_STA_ASSOC) { 1375 hapd = iface->bss[j]; 1376 break; 1377 } 1378 } 1379 1380 ieee802_1x_receive(hapd, src, data, data_len); 1381} 1382 1383#endif /* HOSTAPD */ 1384 1385 1386static struct hostapd_channel_data * hostapd_get_mode_channel( 1387 struct hostapd_iface *iface, unsigned int freq) 1388{ 1389 int i; 1390 struct hostapd_channel_data *chan; 1391 1392 for (i = 0; i < iface->current_mode->num_channels; i++) { 1393 chan = &iface->current_mode->channels[i]; 1394 if ((unsigned int) chan->freq == freq) 1395 return chan; 1396 } 1397 1398 return NULL; 1399} 1400 1401 1402static void hostapd_update_nf(struct hostapd_iface *iface, 1403 struct hostapd_channel_data *chan, 1404 struct freq_survey *survey) 1405{ 1406 if (!iface->chans_surveyed) { 1407 chan->min_nf = survey->nf; 1408 iface->lowest_nf = survey->nf; 1409 } else { 1410 if (dl_list_empty(&chan->survey_list)) 1411 chan->min_nf = survey->nf; 1412 else if (survey->nf < chan->min_nf) 1413 chan->min_nf = survey->nf; 1414 if (survey->nf < iface->lowest_nf) 1415 iface->lowest_nf = survey->nf; 1416 } 1417} 1418 1419 1420static void hostapd_single_channel_get_survey(struct hostapd_iface *iface, 1421 struct survey_results *survey_res) 1422{ 1423 struct hostapd_channel_data *chan; 1424 struct freq_survey *survey; 1425 u64 divisor, dividend; 1426 1427 survey = dl_list_first(&survey_res->survey_list, struct freq_survey, 1428 list); 1429 if (!survey || !survey->freq) 1430 return; 1431 1432 chan = hostapd_get_mode_channel(iface, survey->freq); 1433 if (!chan || chan->flag & HOSTAPD_CHAN_DISABLED) 1434 return; 1435 1436 wpa_printf(MSG_DEBUG, 1437 "Single Channel Survey: (freq=%d channel_time=%ld channel_time_busy=%ld)", 1438 survey->freq, 1439 (unsigned long int) survey->channel_time, 1440 (unsigned long int) survey->channel_time_busy); 1441 1442 if (survey->channel_time > iface->last_channel_time && 1443 survey->channel_time > survey->channel_time_busy) { 1444 dividend = survey->channel_time_busy - 1445 iface->last_channel_time_busy; 1446 divisor = survey->channel_time - iface->last_channel_time; 1447 1448 iface->channel_utilization = dividend * 255 / divisor; 1449 wpa_printf(MSG_DEBUG, "Channel Utilization: %d", 1450 iface->channel_utilization); 1451 } 1452 iface->last_channel_time = survey->channel_time; 1453 iface->last_channel_time_busy = survey->channel_time_busy; 1454} 1455 1456 1457void hostapd_event_get_survey(struct hostapd_iface *iface, 1458 struct survey_results *survey_results) 1459{ 1460 struct freq_survey *survey, *tmp; 1461 struct hostapd_channel_data *chan; 1462 1463 if (dl_list_empty(&survey_results->survey_list)) { 1464 wpa_printf(MSG_DEBUG, "No survey data received"); 1465 return; 1466 } 1467 1468 if (survey_results->freq_filter) { 1469 hostapd_single_channel_get_survey(iface, survey_results); 1470 return; 1471 } 1472 1473 dl_list_for_each_safe(survey, tmp, &survey_results->survey_list, 1474 struct freq_survey, list) { 1475 chan = hostapd_get_mode_channel(iface, survey->freq); 1476 if (!chan) 1477 continue; 1478 if (chan->flag & HOSTAPD_CHAN_DISABLED) 1479 continue; 1480 1481 dl_list_del(&survey->list); 1482 dl_list_add_tail(&chan->survey_list, &survey->list); 1483 1484 hostapd_update_nf(iface, chan, survey); 1485 1486 iface->chans_surveyed++; 1487 } 1488} 1489 1490 1491#ifdef HOSTAPD 1492#ifdef NEED_AP_MLME 1493 1494static void hostapd_event_iface_unavailable(struct hostapd_data *hapd) 1495{ 1496 wpa_printf(MSG_DEBUG, "Interface %s is unavailable -- stopped", 1497 hapd->conf->iface); 1498 1499 if (hapd->csa_in_progress) { 1500 wpa_printf(MSG_INFO, "CSA failed (%s was stopped)", 1501 hapd->conf->iface); 1502 hostapd_switch_channel_fallback(hapd->iface, 1503 &hapd->cs_freq_params); 1504 } 1505} 1506 1507 1508static void hostapd_event_dfs_radar_detected(struct hostapd_data *hapd, 1509 struct dfs_event *radar) 1510{ 1511 wpa_printf(MSG_DEBUG, "DFS radar detected on %d MHz", radar->freq); 1512 hostapd_dfs_radar_detected(hapd->iface, radar->freq, radar->ht_enabled, 1513 radar->chan_offset, radar->chan_width, 1514 radar->cf1, radar->cf2); 1515} 1516 1517 1518static void hostapd_event_dfs_pre_cac_expired(struct hostapd_data *hapd, 1519 struct dfs_event *radar) 1520{ 1521 wpa_printf(MSG_DEBUG, "DFS Pre-CAC expired on %d MHz", radar->freq); 1522 hostapd_dfs_pre_cac_expired(hapd->iface, radar->freq, radar->ht_enabled, 1523 radar->chan_offset, radar->chan_width, 1524 radar->cf1, radar->cf2); 1525} 1526 1527 1528static void hostapd_event_dfs_cac_finished(struct hostapd_data *hapd, 1529 struct dfs_event *radar) 1530{ 1531 wpa_printf(MSG_DEBUG, "DFS CAC finished on %d MHz", radar->freq); 1532 hostapd_dfs_complete_cac(hapd->iface, 1, radar->freq, radar->ht_enabled, 1533 radar->chan_offset, radar->chan_width, 1534 radar->cf1, radar->cf2); 1535} 1536 1537 1538static void hostapd_event_dfs_cac_aborted(struct hostapd_data *hapd, 1539 struct dfs_event *radar) 1540{ 1541 wpa_printf(MSG_DEBUG, "DFS CAC aborted on %d MHz", radar->freq); 1542 hostapd_dfs_complete_cac(hapd->iface, 0, radar->freq, radar->ht_enabled, 1543 radar->chan_offset, radar->chan_width, 1544 radar->cf1, radar->cf2); 1545} 1546 1547 1548static void hostapd_event_dfs_nop_finished(struct hostapd_data *hapd, 1549 struct dfs_event *radar) 1550{ 1551 wpa_printf(MSG_DEBUG, "DFS NOP finished on %d MHz", radar->freq); 1552 hostapd_dfs_nop_finished(hapd->iface, radar->freq, radar->ht_enabled, 1553 radar->chan_offset, radar->chan_width, 1554 radar->cf1, radar->cf2); 1555} 1556 1557 1558static void hostapd_event_dfs_cac_started(struct hostapd_data *hapd, 1559 struct dfs_event *radar) 1560{ 1561 wpa_printf(MSG_DEBUG, "DFS offload CAC started on %d MHz", radar->freq); 1562 hostapd_dfs_start_cac(hapd->iface, radar->freq, radar->ht_enabled, 1563 radar->chan_offset, radar->chan_width, 1564 radar->cf1, radar->cf2); 1565} 1566 1567#endif /* NEED_AP_MLME */ 1568 1569 1570static void hostapd_event_wds_sta_interface_status(struct hostapd_data *hapd, 1571 int istatus, 1572 const char *ifname, 1573 const u8 *addr) 1574{ 1575 struct sta_info *sta = ap_get_sta(hapd, addr); 1576 1577 if (sta) { 1578 os_free(sta->ifname_wds); 1579 if (istatus == INTERFACE_ADDED) 1580 sta->ifname_wds = os_strdup(ifname); 1581 else 1582 sta->ifname_wds = NULL; 1583 } 1584 1585 wpa_msg(hapd->msg_ctx, MSG_INFO, "%sifname=%s sta_addr=" MACSTR, 1586 istatus == INTERFACE_ADDED ? 1587 WDS_STA_INTERFACE_ADDED : WDS_STA_INTERFACE_REMOVED, 1588 ifname, MAC2STR(addr)); 1589} 1590 1591 1592#ifdef CONFIG_OWE 1593static int hostapd_notif_update_dh_ie(struct hostapd_data *hapd, 1594 const u8 *peer, const u8 *ie, 1595 size_t ie_len) 1596{ 1597 u16 status; 1598 struct sta_info *sta; 1599 struct ieee802_11_elems elems; 1600 1601 if (!hapd || !hapd->wpa_auth) { 1602 wpa_printf(MSG_DEBUG, "OWE: Invalid hapd context"); 1603 return -1; 1604 } 1605 if (!peer) { 1606 wpa_printf(MSG_DEBUG, "OWE: Peer unknown"); 1607 return -1; 1608 } 1609 if (!(hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_OWE)) { 1610 wpa_printf(MSG_DEBUG, "OWE: No OWE AKM configured"); 1611 status = WLAN_STATUS_AKMP_NOT_VALID; 1612 goto err; 1613 } 1614 if (ieee802_11_parse_elems(ie, ie_len, &elems, 1) == ParseFailed) { 1615 wpa_printf(MSG_DEBUG, "OWE: Failed to parse OWE IE for " 1616 MACSTR, MAC2STR(peer)); 1617 status = WLAN_STATUS_UNSPECIFIED_FAILURE; 1618 goto err; 1619 } 1620 status = owe_validate_request(hapd, peer, elems.rsn_ie, 1621 elems.rsn_ie_len, 1622 elems.owe_dh, elems.owe_dh_len); 1623 if (status != WLAN_STATUS_SUCCESS) 1624 goto err; 1625 1626 sta = ap_get_sta(hapd, peer); 1627 if (sta) { 1628 ap_sta_no_session_timeout(hapd, sta); 1629 accounting_sta_stop(hapd, sta); 1630 1631 /* 1632 * Make sure that the previously registered inactivity timer 1633 * will not remove the STA immediately. 1634 */ 1635 sta->timeout_next = STA_NULLFUNC; 1636 } else { 1637 sta = ap_sta_add(hapd, peer); 1638 if (!sta) { 1639 status = WLAN_STATUS_UNSPECIFIED_FAILURE; 1640 goto err; 1641 } 1642 } 1643 sta->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS | WLAN_STA_WPS2); 1644 1645 status = owe_process_rsn_ie(hapd, sta, elems.rsn_ie, 1646 elems.rsn_ie_len, elems.owe_dh, 1647 elems.owe_dh_len); 1648 if (status != WLAN_STATUS_SUCCESS) 1649 ap_free_sta(hapd, sta); 1650 1651 return 0; 1652err: 1653 hostapd_drv_update_dh_ie(hapd, peer, status, NULL, 0); 1654 return 0; 1655} 1656#endif /* CONFIG_OWE */ 1657 1658 1659void wpa_supplicant_event(void *ctx, enum wpa_event_type event, 1660 union wpa_event_data *data) 1661{ 1662 struct hostapd_data *hapd = ctx; 1663#ifndef CONFIG_NO_STDOUT_DEBUG 1664 int level = MSG_DEBUG; 1665 1666 if (event == EVENT_RX_MGMT && data->rx_mgmt.frame && 1667 data->rx_mgmt.frame_len >= 24) { 1668 const struct ieee80211_hdr *hdr; 1669 u16 fc; 1670 1671 hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame; 1672 fc = le_to_host16(hdr->frame_control); 1673 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1674 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) 1675 level = MSG_EXCESSIVE; 1676 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1677 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_REQ) 1678 level = MSG_EXCESSIVE; 1679 } 1680 1681 wpa_dbg(hapd->msg_ctx, level, "Event %s (%d) received", 1682 event_to_string(event), event); 1683#endif /* CONFIG_NO_STDOUT_DEBUG */ 1684 1685 switch (event) { 1686 case EVENT_MICHAEL_MIC_FAILURE: 1687 michael_mic_failure(hapd, data->michael_mic_failure.src, 1); 1688 break; 1689 case EVENT_SCAN_RESULTS: 1690 if (hapd->iface->scan_cb) 1691 hapd->iface->scan_cb(hapd->iface); 1692 break; 1693 case EVENT_WPS_BUTTON_PUSHED: 1694 hostapd_wps_button_pushed(hapd, NULL); 1695 break; 1696#ifdef NEED_AP_MLME 1697 case EVENT_TX_STATUS: 1698 switch (data->tx_status.type) { 1699 case WLAN_FC_TYPE_MGMT: 1700 hostapd_mgmt_tx_cb(hapd, data->tx_status.data, 1701 data->tx_status.data_len, 1702 data->tx_status.stype, 1703 data->tx_status.ack); 1704 break; 1705 case WLAN_FC_TYPE_DATA: 1706 hostapd_tx_status(hapd, data->tx_status.dst, 1707 data->tx_status.data, 1708 data->tx_status.data_len, 1709 data->tx_status.ack); 1710 break; 1711 } 1712 break; 1713 case EVENT_EAPOL_TX_STATUS: 1714 hostapd_eapol_tx_status(hapd, data->eapol_tx_status.dst, 1715 data->eapol_tx_status.data, 1716 data->eapol_tx_status.data_len, 1717 data->eapol_tx_status.ack); 1718 break; 1719 case EVENT_DRIVER_CLIENT_POLL_OK: 1720 hostapd_client_poll_ok(hapd, data->client_poll.addr); 1721 break; 1722 case EVENT_RX_FROM_UNKNOWN: 1723 hostapd_rx_from_unknown_sta(hapd, data->rx_from_unknown.bssid, 1724 data->rx_from_unknown.addr, 1725 data->rx_from_unknown.wds); 1726 break; 1727#endif /* NEED_AP_MLME */ 1728 case EVENT_RX_MGMT: 1729 if (!data->rx_mgmt.frame) 1730 break; 1731#ifdef NEED_AP_MLME 1732 hostapd_mgmt_rx(hapd, &data->rx_mgmt); 1733#else /* NEED_AP_MLME */ 1734 hostapd_action_rx(hapd, &data->rx_mgmt); 1735#endif /* NEED_AP_MLME */ 1736 break; 1737 case EVENT_RX_PROBE_REQ: 1738 if (data->rx_probe_req.sa == NULL || 1739 data->rx_probe_req.ie == NULL) 1740 break; 1741 hostapd_probe_req_rx(hapd, data->rx_probe_req.sa, 1742 data->rx_probe_req.da, 1743 data->rx_probe_req.bssid, 1744 data->rx_probe_req.ie, 1745 data->rx_probe_req.ie_len, 1746 data->rx_probe_req.ssi_signal); 1747 break; 1748 case EVENT_NEW_STA: 1749 hostapd_event_new_sta(hapd, data->new_sta.addr); 1750 break; 1751 case EVENT_EAPOL_RX: 1752 hostapd_event_eapol_rx(hapd, data->eapol_rx.src, 1753 data->eapol_rx.data, 1754 data->eapol_rx.data_len); 1755 break; 1756 case EVENT_ASSOC: 1757 if (!data) 1758 return; 1759 hostapd_notif_assoc(hapd, data->assoc_info.addr, 1760 data->assoc_info.req_ies, 1761 data->assoc_info.req_ies_len, 1762 data->assoc_info.reassoc); 1763 break; 1764#ifdef CONFIG_OWE 1765 case EVENT_UPDATE_DH: 1766 if (!data) 1767 return; 1768 hostapd_notif_update_dh_ie(hapd, data->update_dh.peer, 1769 data->update_dh.ie, 1770 data->update_dh.ie_len); 1771 break; 1772#endif /* CONFIG_OWE */ 1773 case EVENT_DISASSOC: 1774 if (data) 1775 hostapd_notif_disassoc(hapd, data->disassoc_info.addr); 1776 break; 1777 case EVENT_DEAUTH: 1778 if (data) 1779 hostapd_notif_disassoc(hapd, data->deauth_info.addr); 1780 break; 1781 case EVENT_STATION_LOW_ACK: 1782 if (!data) 1783 break; 1784 hostapd_event_sta_low_ack(hapd, data->low_ack.addr); 1785 break; 1786 case EVENT_AUTH: 1787 hostapd_notif_auth(hapd, &data->auth); 1788 break; 1789 case EVENT_CH_SWITCH_STARTED: 1790 case EVENT_CH_SWITCH: 1791 if (!data) 1792 break; 1793 hostapd_event_ch_switch(hapd, data->ch_switch.freq, 1794 data->ch_switch.ht_enabled, 1795 data->ch_switch.ch_offset, 1796 data->ch_switch.ch_width, 1797 data->ch_switch.cf1, 1798 data->ch_switch.cf2, 1799 event == EVENT_CH_SWITCH); 1800 break; 1801 case EVENT_CONNECT_FAILED_REASON: 1802 if (!data) 1803 break; 1804 hostapd_event_connect_failed_reason( 1805 hapd, data->connect_failed_reason.addr, 1806 data->connect_failed_reason.code); 1807 break; 1808 case EVENT_SURVEY: 1809 hostapd_event_get_survey(hapd->iface, &data->survey_results); 1810 break; 1811#ifdef NEED_AP_MLME 1812 case EVENT_INTERFACE_UNAVAILABLE: 1813 hostapd_event_iface_unavailable(hapd); 1814 break; 1815 case EVENT_DFS_RADAR_DETECTED: 1816 if (!data) 1817 break; 1818 hostapd_event_dfs_radar_detected(hapd, &data->dfs_event); 1819 break; 1820 case EVENT_DFS_PRE_CAC_EXPIRED: 1821 if (!data) 1822 break; 1823 hostapd_event_dfs_pre_cac_expired(hapd, &data->dfs_event); 1824 break; 1825 case EVENT_DFS_CAC_FINISHED: 1826 if (!data) 1827 break; 1828 hostapd_event_dfs_cac_finished(hapd, &data->dfs_event); 1829 break; 1830 case EVENT_DFS_CAC_ABORTED: 1831 if (!data) 1832 break; 1833 hostapd_event_dfs_cac_aborted(hapd, &data->dfs_event); 1834 break; 1835 case EVENT_DFS_NOP_FINISHED: 1836 if (!data) 1837 break; 1838 hostapd_event_dfs_nop_finished(hapd, &data->dfs_event); 1839 break; 1840 case EVENT_CHANNEL_LIST_CHANGED: 1841 /* channel list changed (regulatory?), update channel list */ 1842 /* TODO: check this. hostapd_get_hw_features() initializes 1843 * too much stuff. */ 1844 /* hostapd_get_hw_features(hapd->iface); */ 1845 hostapd_channel_list_updated( 1846 hapd->iface, data->channel_list_changed.initiator); 1847 break; 1848 case EVENT_DFS_CAC_STARTED: 1849 if (!data) 1850 break; 1851 hostapd_event_dfs_cac_started(hapd, &data->dfs_event); 1852 break; 1853#endif /* NEED_AP_MLME */ 1854 case EVENT_INTERFACE_ENABLED: 1855 wpa_msg(hapd->msg_ctx, MSG_INFO, INTERFACE_ENABLED); 1856 if (hapd->disabled && hapd->started) { 1857 hapd->disabled = 0; 1858 /* 1859 * Try to re-enable interface if the driver stopped it 1860 * when the interface got disabled. 1861 */ 1862 if (hapd->wpa_auth) 1863 wpa_auth_reconfig_group_keys(hapd->wpa_auth); 1864 else 1865 hostapd_reconfig_encryption(hapd); 1866 hapd->reenable_beacon = 1; 1867 ieee802_11_set_beacon(hapd); 1868#ifdef NEED_AP_MLME 1869 } else if (hapd->disabled && hapd->iface->cac_started) { 1870 wpa_printf(MSG_DEBUG, "DFS: restarting pending CAC"); 1871 hostapd_handle_dfs(hapd->iface); 1872#endif /* NEED_AP_MLME */ 1873 } 1874 break; 1875 case EVENT_INTERFACE_DISABLED: 1876 hostapd_free_stas(hapd); 1877 wpa_msg(hapd->msg_ctx, MSG_INFO, INTERFACE_DISABLED); 1878 hapd->disabled = 1; 1879 break; 1880#ifdef CONFIG_ACS 1881 case EVENT_ACS_CHANNEL_SELECTED: 1882 hostapd_acs_channel_selected(hapd, 1883 &data->acs_selected_channels); 1884 break; 1885#endif /* CONFIG_ACS */ 1886 case EVENT_STATION_OPMODE_CHANGED: 1887 hostapd_event_sta_opmode_changed(hapd, data->sta_opmode.addr, 1888 data->sta_opmode.smps_mode, 1889 data->sta_opmode.chan_width, 1890 data->sta_opmode.rx_nss); 1891 break; 1892 case EVENT_WDS_STA_INTERFACE_STATUS: 1893 hostapd_event_wds_sta_interface_status( 1894 hapd, data->wds_sta_interface.istatus, 1895 data->wds_sta_interface.ifname, 1896 data->wds_sta_interface.sta_addr); 1897 break; 1898 default: 1899 wpa_printf(MSG_DEBUG, "Unknown event %d", event); 1900 break; 1901 } 1902} 1903 1904 1905void wpa_supplicant_event_global(void *ctx, enum wpa_event_type event, 1906 union wpa_event_data *data) 1907{ 1908 struct hapd_interfaces *interfaces = ctx; 1909 struct hostapd_data *hapd; 1910 1911 if (event != EVENT_INTERFACE_STATUS) 1912 return; 1913 1914 hapd = hostapd_get_iface(interfaces, data->interface_status.ifname); 1915 if (hapd && hapd->driver && hapd->driver->get_ifindex && 1916 hapd->drv_priv) { 1917 unsigned int ifindex; 1918 1919 ifindex = hapd->driver->get_ifindex(hapd->drv_priv); 1920 if (ifindex != data->interface_status.ifindex) { 1921 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, 1922 "interface status ifindex %d mismatch (%d)", 1923 ifindex, data->interface_status.ifindex); 1924 return; 1925 } 1926 } 1927 if (hapd) 1928 wpa_supplicant_event(hapd, event, data); 1929} 1930 1931#endif /* HOSTAPD */ 1932