1 /* 2 * hostapd / Callback functions for driver wrappers 3 * Copyright (c) 2002-2013, 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 "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 46 void 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 106 int 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 457 skip_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 645 fail: 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 655 void 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 692 void 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 707 void 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 774 void hostapd_event_ch_switch(struct hostapd_data *hapd, int freq, int ht, 775 int offset, int width, int cf1, int cf2) 776 { 777 /* TODO: If OCV is enabled deauth STAs that don't perform a SA Query */ 778 779 #ifdef NEED_AP_MLME 780 int channel, chwidth, is_dfs; 781 u8 seg0_idx = 0, seg1_idx = 0; 782 size_t i; 783 784 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 785 HOSTAPD_LEVEL_INFO, 786 "driver had channel switch: freq=%d, ht=%d, vht_ch=0x%x, offset=%d, width=%d (%s), cf1=%d, cf2=%d", 787 freq, ht, hapd->iconf->ch_switch_vht_config, offset, 788 width, channel_width_to_string(width), cf1, cf2); 789 790 if (!hapd->iface->current_mode) { 791 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 792 HOSTAPD_LEVEL_WARNING, 793 "ignore channel switch since the interface is not yet ready"); 794 return; 795 } 796 797 hapd->iface->freq = freq; 798 799 channel = hostapd_hw_get_channel(hapd, freq); 800 if (!channel) { 801 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 802 HOSTAPD_LEVEL_WARNING, 803 "driver switched to bad channel!"); 804 return; 805 } 806 807 switch (width) { 808 case CHAN_WIDTH_80: 809 chwidth = VHT_CHANWIDTH_80MHZ; 810 break; 811 case CHAN_WIDTH_80P80: 812 chwidth = VHT_CHANWIDTH_80P80MHZ; 813 break; 814 case CHAN_WIDTH_160: 815 chwidth = VHT_CHANWIDTH_160MHZ; 816 break; 817 case CHAN_WIDTH_20_NOHT: 818 case CHAN_WIDTH_20: 819 case CHAN_WIDTH_40: 820 default: 821 chwidth = VHT_CHANWIDTH_USE_HT; 822 break; 823 } 824 825 switch (hapd->iface->current_mode->mode) { 826 case HOSTAPD_MODE_IEEE80211A: 827 if (cf1 > 5000) 828 seg0_idx = (cf1 - 5000) / 5; 829 if (cf2 > 5000) 830 seg1_idx = (cf2 - 5000) / 5; 831 break; 832 default: 833 ieee80211_freq_to_chan(cf1, &seg0_idx); 834 ieee80211_freq_to_chan(cf2, &seg1_idx); 835 break; 836 } 837 838 hapd->iconf->channel = channel; 839 hapd->iconf->ieee80211n = ht; 840 if (!ht) { 841 hapd->iconf->ieee80211ac = 0; 842 } else if (hapd->iconf->ch_switch_vht_config) { 843 /* CHAN_SWITCH VHT config */ 844 if (hapd->iconf->ch_switch_vht_config & 845 CH_SWITCH_VHT_ENABLED) 846 hapd->iconf->ieee80211ac = 1; 847 else if (hapd->iconf->ch_switch_vht_config & 848 CH_SWITCH_VHT_DISABLED) 849 hapd->iconf->ieee80211ac = 0; 850 } 851 hapd->iconf->ch_switch_vht_config = 0; 852 853 hapd->iconf->secondary_channel = offset; 854 hapd->iconf->vht_oper_chwidth = chwidth; 855 hapd->iconf->vht_oper_centr_freq_seg0_idx = seg0_idx; 856 hapd->iconf->vht_oper_centr_freq_seg1_idx = seg1_idx; 857 858 is_dfs = ieee80211_is_dfs(freq, hapd->iface->hw_features, 859 hapd->iface->num_hw_features); 860 861 if (hapd->csa_in_progress && 862 freq == hapd->cs_freq_params.freq) { 863 hostapd_cleanup_cs_params(hapd); 864 ieee802_11_set_beacon(hapd); 865 866 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED 867 "freq=%d dfs=%d", freq, is_dfs); 868 } else if (hapd->iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) { 869 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED 870 "freq=%d dfs=%d", freq, is_dfs); 871 } 872 873 for (i = 0; i < hapd->iface->num_bss; i++) 874 hostapd_neighbor_set_own_report(hapd->iface->bss[i]); 875 #endif /* NEED_AP_MLME */ 876 } 877 878 879 void hostapd_event_connect_failed_reason(struct hostapd_data *hapd, 880 const u8 *addr, int reason_code) 881 { 882 switch (reason_code) { 883 case MAX_CLIENT_REACHED: 884 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_REJECTED_MAX_STA MACSTR, 885 MAC2STR(addr)); 886 break; 887 case BLOCKED_CLIENT: 888 wpa_msg(hapd->msg_ctx, MSG_INFO, AP_REJECTED_BLOCKED_STA MACSTR, 889 MAC2STR(addr)); 890 break; 891 } 892 } 893 894 895 #ifdef CONFIG_ACS 896 void hostapd_acs_channel_selected(struct hostapd_data *hapd, 897 struct acs_selected_channels *acs_res) 898 { 899 int ret, i; 900 int err = 0; 901 902 if (hapd->iconf->channel) { 903 wpa_printf(MSG_INFO, "ACS: Channel was already set to %d", 904 hapd->iconf->channel); 905 return; 906 } 907 908 if (!hapd->iface->current_mode) { 909 for (i = 0; i < hapd->iface->num_hw_features; i++) { 910 struct hostapd_hw_modes *mode = 911 &hapd->iface->hw_features[i]; 912 913 if (mode->mode == acs_res->hw_mode) { 914 hapd->iface->current_mode = mode; 915 break; 916 } 917 } 918 if (!hapd->iface->current_mode) { 919 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 920 HOSTAPD_LEVEL_WARNING, 921 "driver selected to bad hw_mode"); 922 err = 1; 923 goto out; 924 } 925 } 926 927 hapd->iface->freq = hostapd_hw_get_freq(hapd, acs_res->pri_channel); 928 929 if (!acs_res->pri_channel) { 930 hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, 931 HOSTAPD_LEVEL_WARNING, 932 "driver switched to bad channel"); 933 err = 1; 934 goto out; 935 } 936 937 hapd->iconf->channel = acs_res->pri_channel; 938 hapd->iconf->acs = 1; 939 940 if (acs_res->sec_channel == 0) 941 hapd->iconf->secondary_channel = 0; 942 else if (acs_res->sec_channel < acs_res->pri_channel) 943 hapd->iconf->secondary_channel = -1; 944 else if (acs_res->sec_channel > acs_res->pri_channel) 945 hapd->iconf->secondary_channel = 1; 946 else { 947 wpa_printf(MSG_ERROR, "Invalid secondary channel!"); 948 err = 1; 949 goto out; 950 } 951 952 if (hapd->iface->conf->ieee80211ac) { 953 /* set defaults for backwards compatibility */ 954 hapd->iconf->vht_oper_centr_freq_seg1_idx = 0; 955 hapd->iconf->vht_oper_centr_freq_seg0_idx = 0; 956 hapd->iconf->vht_oper_chwidth = VHT_CHANWIDTH_USE_HT; 957 if (acs_res->ch_width == 80) { 958 hapd->iconf->vht_oper_centr_freq_seg0_idx = 959 acs_res->vht_seg0_center_ch; 960 hapd->iconf->vht_oper_chwidth = VHT_CHANWIDTH_80MHZ; 961 } else if (acs_res->ch_width == 160) { 962 if (acs_res->vht_seg1_center_ch == 0) { 963 hapd->iconf->vht_oper_centr_freq_seg0_idx = 964 acs_res->vht_seg0_center_ch; 965 hapd->iconf->vht_oper_chwidth = 966 VHT_CHANWIDTH_160MHZ; 967 } else { 968 hapd->iconf->vht_oper_centr_freq_seg0_idx = 969 acs_res->vht_seg0_center_ch; 970 hapd->iconf->vht_oper_centr_freq_seg1_idx = 971 acs_res->vht_seg1_center_ch; 972 hapd->iconf->vht_oper_chwidth = 973 VHT_CHANWIDTH_80P80MHZ; 974 } 975 } 976 } 977 978 out: 979 ret = hostapd_acs_completed(hapd->iface, err); 980 if (ret) { 981 wpa_printf(MSG_ERROR, 982 "ACS: Possibly channel configuration is invalid"); 983 } 984 } 985 #endif /* CONFIG_ACS */ 986 987 988 int hostapd_probe_req_rx(struct hostapd_data *hapd, const u8 *sa, const u8 *da, 989 const u8 *bssid, const u8 *ie, size_t ie_len, 990 int ssi_signal) 991 { 992 size_t i; 993 int ret = 0; 994 995 if (sa == NULL || ie == NULL) 996 return -1; 997 998 random_add_randomness(sa, ETH_ALEN); 999 for (i = 0; hapd->probereq_cb && i < hapd->num_probereq_cb; i++) { 1000 if (hapd->probereq_cb[i].cb(hapd->probereq_cb[i].ctx, 1001 sa, da, bssid, ie, ie_len, 1002 ssi_signal) > 0) { 1003 ret = 1; 1004 break; 1005 } 1006 } 1007 return ret; 1008 } 1009 1010 1011 #ifdef HOSTAPD 1012 1013 #ifdef CONFIG_IEEE80211R_AP 1014 static void hostapd_notify_auth_ft_finish(void *ctx, const u8 *dst, 1015 const u8 *bssid, 1016 u16 auth_transaction, u16 status, 1017 const u8 *ies, size_t ies_len) 1018 { 1019 struct hostapd_data *hapd = ctx; 1020 struct sta_info *sta; 1021 1022 sta = ap_get_sta(hapd, dst); 1023 if (sta == NULL) 1024 return; 1025 1026 hostapd_logger(hapd, dst, HOSTAPD_MODULE_IEEE80211, 1027 HOSTAPD_LEVEL_DEBUG, "authentication OK (FT)"); 1028 sta->flags |= WLAN_STA_AUTH; 1029 1030 hostapd_sta_auth(hapd, dst, auth_transaction, status, ies, ies_len); 1031 } 1032 #endif /* CONFIG_IEEE80211R_AP */ 1033 1034 1035 #ifdef CONFIG_FILS 1036 static void hostapd_notify_auth_fils_finish(struct hostapd_data *hapd, 1037 struct sta_info *sta, u16 resp, 1038 struct wpabuf *data, int pub) 1039 { 1040 if (resp == WLAN_STATUS_SUCCESS) { 1041 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211, 1042 HOSTAPD_LEVEL_DEBUG, "authentication OK (FILS)"); 1043 sta->flags |= WLAN_STA_AUTH; 1044 wpa_auth_sm_event(sta->wpa_sm, WPA_AUTH); 1045 sta->auth_alg = WLAN_AUTH_FILS_SK; 1046 mlme_authenticate_indication(hapd, sta); 1047 } else { 1048 hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211, 1049 HOSTAPD_LEVEL_DEBUG, 1050 "authentication failed (FILS)"); 1051 } 1052 1053 hostapd_sta_auth(hapd, sta->addr, 2, resp, 1054 data ? wpabuf_head(data) : NULL, 1055 data ? wpabuf_len(data) : 0); 1056 wpabuf_free(data); 1057 } 1058 #endif /* CONFIG_FILS */ 1059 1060 1061 static void hostapd_notif_auth(struct hostapd_data *hapd, 1062 struct auth_info *rx_auth) 1063 { 1064 struct sta_info *sta; 1065 u16 status = WLAN_STATUS_SUCCESS; 1066 u8 resp_ies[2 + WLAN_AUTH_CHALLENGE_LEN]; 1067 size_t resp_ies_len = 0; 1068 1069 sta = ap_get_sta(hapd, rx_auth->peer); 1070 if (!sta) { 1071 sta = ap_sta_add(hapd, rx_auth->peer); 1072 if (sta == NULL) { 1073 status = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA; 1074 goto fail; 1075 } 1076 } 1077 sta->flags &= ~WLAN_STA_PREAUTH; 1078 ieee802_1x_notify_pre_auth(sta->eapol_sm, 0); 1079 #ifdef CONFIG_IEEE80211R_AP 1080 if (rx_auth->auth_type == WLAN_AUTH_FT && hapd->wpa_auth) { 1081 sta->auth_alg = WLAN_AUTH_FT; 1082 if (sta->wpa_sm == NULL) 1083 sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, 1084 sta->addr, NULL); 1085 if (sta->wpa_sm == NULL) { 1086 wpa_printf(MSG_DEBUG, 1087 "FT: Failed to initialize WPA state machine"); 1088 status = WLAN_STATUS_UNSPECIFIED_FAILURE; 1089 goto fail; 1090 } 1091 wpa_ft_process_auth(sta->wpa_sm, rx_auth->bssid, 1092 rx_auth->auth_transaction, rx_auth->ies, 1093 rx_auth->ies_len, 1094 hostapd_notify_auth_ft_finish, hapd); 1095 return; 1096 } 1097 #endif /* CONFIG_IEEE80211R_AP */ 1098 1099 #ifdef CONFIG_FILS 1100 if (rx_auth->auth_type == WLAN_AUTH_FILS_SK) { 1101 sta->auth_alg = WLAN_AUTH_FILS_SK; 1102 handle_auth_fils(hapd, sta, rx_auth->ies, rx_auth->ies_len, 1103 rx_auth->auth_type, rx_auth->auth_transaction, 1104 rx_auth->status_code, 1105 hostapd_notify_auth_fils_finish); 1106 return; 1107 } 1108 #endif /* CONFIG_FILS */ 1109 1110 fail: 1111 hostapd_sta_auth(hapd, rx_auth->peer, rx_auth->auth_transaction + 1, 1112 status, resp_ies, resp_ies_len); 1113 } 1114 1115 1116 #ifndef NEED_AP_MLME 1117 static void hostapd_action_rx(struct hostapd_data *hapd, 1118 struct rx_mgmt *drv_mgmt) 1119 { 1120 struct ieee80211_mgmt *mgmt; 1121 struct sta_info *sta; 1122 size_t plen __maybe_unused; 1123 u16 fc; 1124 u8 *action __maybe_unused; 1125 1126 if (drv_mgmt->frame_len < IEEE80211_HDRLEN + 2 + 1) 1127 return; 1128 1129 plen = drv_mgmt->frame_len - IEEE80211_HDRLEN; 1130 1131 mgmt = (struct ieee80211_mgmt *) drv_mgmt->frame; 1132 fc = le_to_host16(mgmt->frame_control); 1133 if (WLAN_FC_GET_STYPE(fc) != WLAN_FC_STYPE_ACTION) 1134 return; /* handled by the driver */ 1135 1136 action = (u8 *) &mgmt->u.action.u; 1137 wpa_printf(MSG_DEBUG, "RX_ACTION category %u action %u sa " MACSTR 1138 " da " MACSTR " plen %d", 1139 mgmt->u.action.category, *action, 1140 MAC2STR(mgmt->sa), MAC2STR(mgmt->da), (int) plen); 1141 1142 sta = ap_get_sta(hapd, mgmt->sa); 1143 if (sta == NULL) { 1144 wpa_printf(MSG_DEBUG, "%s: station not found", __func__); 1145 return; 1146 } 1147 #ifdef CONFIG_IEEE80211R_AP 1148 if (mgmt->u.action.category == WLAN_ACTION_FT) { 1149 wpa_ft_action_rx(sta->wpa_sm, (u8 *) &mgmt->u.action, plen); 1150 return; 1151 } 1152 #endif /* CONFIG_IEEE80211R_AP */ 1153 #ifdef CONFIG_IEEE80211W 1154 if (mgmt->u.action.category == WLAN_ACTION_SA_QUERY) { 1155 ieee802_11_sa_query_action(hapd, mgmt, drv_mgmt->frame_len); 1156 return; 1157 } 1158 #endif /* CONFIG_IEEE80211W */ 1159 #ifdef CONFIG_WNM_AP 1160 if (mgmt->u.action.category == WLAN_ACTION_WNM) { 1161 ieee802_11_rx_wnm_action_ap(hapd, mgmt, drv_mgmt->frame_len); 1162 return; 1163 } 1164 #endif /* CONFIG_WNM_AP */ 1165 #ifdef CONFIG_FST 1166 if (mgmt->u.action.category == WLAN_ACTION_FST && hapd->iface->fst) { 1167 fst_rx_action(hapd->iface->fst, mgmt, drv_mgmt->frame_len); 1168 return; 1169 } 1170 #endif /* CONFIG_FST */ 1171 #ifdef CONFIG_DPP 1172 if (plen >= 2 + 4 && 1173 mgmt->u.action.u.vs_public_action.action == 1174 WLAN_PA_VENDOR_SPECIFIC && 1175 WPA_GET_BE24(mgmt->u.action.u.vs_public_action.oui) == 1176 OUI_WFA && 1177 mgmt->u.action.u.vs_public_action.variable[0] == 1178 DPP_OUI_TYPE) { 1179 const u8 *pos, *end; 1180 1181 pos = mgmt->u.action.u.vs_public_action.oui; 1182 end = drv_mgmt->frame + drv_mgmt->frame_len; 1183 hostapd_dpp_rx_action(hapd, mgmt->sa, pos, end - pos, 1184 drv_mgmt->freq); 1185 return; 1186 } 1187 #endif /* CONFIG_DPP */ 1188 } 1189 #endif /* NEED_AP_MLME */ 1190 1191 1192 #ifdef NEED_AP_MLME 1193 1194 #define HAPD_BROADCAST ((struct hostapd_data *) -1) 1195 1196 static struct hostapd_data * get_hapd_bssid(struct hostapd_iface *iface, 1197 const u8 *bssid) 1198 { 1199 size_t i; 1200 1201 if (bssid == NULL) 1202 return NULL; 1203 if (bssid[0] == 0xff && bssid[1] == 0xff && bssid[2] == 0xff && 1204 bssid[3] == 0xff && bssid[4] == 0xff && bssid[5] == 0xff) 1205 return HAPD_BROADCAST; 1206 1207 for (i = 0; i < iface->num_bss; i++) { 1208 if (os_memcmp(bssid, iface->bss[i]->own_addr, ETH_ALEN) == 0) 1209 return iface->bss[i]; 1210 } 1211 1212 return NULL; 1213 } 1214 1215 1216 static void hostapd_rx_from_unknown_sta(struct hostapd_data *hapd, 1217 const u8 *bssid, const u8 *addr, 1218 int wds) 1219 { 1220 hapd = get_hapd_bssid(hapd->iface, bssid); 1221 if (hapd == NULL || hapd == HAPD_BROADCAST) 1222 return; 1223 1224 ieee802_11_rx_from_unknown(hapd, addr, wds); 1225 } 1226 1227 1228 static int hostapd_mgmt_rx(struct hostapd_data *hapd, struct rx_mgmt *rx_mgmt) 1229 { 1230 struct hostapd_iface *iface = hapd->iface; 1231 const struct ieee80211_hdr *hdr; 1232 const u8 *bssid; 1233 struct hostapd_frame_info fi; 1234 int ret; 1235 1236 #ifdef CONFIG_TESTING_OPTIONS 1237 if (hapd->ext_mgmt_frame_handling) { 1238 size_t hex_len = 2 * rx_mgmt->frame_len + 1; 1239 char *hex = os_malloc(hex_len); 1240 1241 if (hex) { 1242 wpa_snprintf_hex(hex, hex_len, rx_mgmt->frame, 1243 rx_mgmt->frame_len); 1244 wpa_msg(hapd->msg_ctx, MSG_INFO, "MGMT-RX %s", hex); 1245 os_free(hex); 1246 } 1247 return 1; 1248 } 1249 #endif /* CONFIG_TESTING_OPTIONS */ 1250 1251 hdr = (const struct ieee80211_hdr *) rx_mgmt->frame; 1252 bssid = get_hdr_bssid(hdr, rx_mgmt->frame_len); 1253 if (bssid == NULL) 1254 return 0; 1255 1256 hapd = get_hapd_bssid(iface, bssid); 1257 if (hapd == NULL) { 1258 u16 fc = le_to_host16(hdr->frame_control); 1259 1260 /* 1261 * Drop frames to unknown BSSIDs except for Beacon frames which 1262 * could be used to update neighbor information. 1263 */ 1264 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1265 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) 1266 hapd = iface->bss[0]; 1267 else 1268 return 0; 1269 } 1270 1271 os_memset(&fi, 0, sizeof(fi)); 1272 fi.freq = rx_mgmt->freq; 1273 fi.datarate = rx_mgmt->datarate; 1274 fi.ssi_signal = rx_mgmt->ssi_signal; 1275 1276 if (hapd == HAPD_BROADCAST) { 1277 size_t i; 1278 1279 ret = 0; 1280 for (i = 0; i < iface->num_bss; i++) { 1281 /* if bss is set, driver will call this function for 1282 * each bss individually. */ 1283 if (rx_mgmt->drv_priv && 1284 (iface->bss[i]->drv_priv != rx_mgmt->drv_priv)) 1285 continue; 1286 1287 if (ieee802_11_mgmt(iface->bss[i], rx_mgmt->frame, 1288 rx_mgmt->frame_len, &fi) > 0) 1289 ret = 1; 1290 } 1291 } else 1292 ret = ieee802_11_mgmt(hapd, rx_mgmt->frame, rx_mgmt->frame_len, 1293 &fi); 1294 1295 random_add_randomness(&fi, sizeof(fi)); 1296 1297 return ret; 1298 } 1299 1300 1301 static void hostapd_mgmt_tx_cb(struct hostapd_data *hapd, const u8 *buf, 1302 size_t len, u16 stype, int ok) 1303 { 1304 struct ieee80211_hdr *hdr; 1305 struct hostapd_data *orig_hapd = hapd; 1306 1307 hdr = (struct ieee80211_hdr *) buf; 1308 hapd = get_hapd_bssid(hapd->iface, get_hdr_bssid(hdr, len)); 1309 if (!hapd) 1310 return; 1311 if (hapd == HAPD_BROADCAST) { 1312 if (stype != WLAN_FC_STYPE_ACTION || len <= 25 || 1313 buf[24] != WLAN_ACTION_PUBLIC) 1314 return; 1315 hapd = get_hapd_bssid(orig_hapd->iface, hdr->addr2); 1316 if (!hapd || hapd == HAPD_BROADCAST) 1317 return; 1318 /* 1319 * Allow processing of TX status for a Public Action frame that 1320 * used wildcard BBSID. 1321 */ 1322 } 1323 ieee802_11_mgmt_cb(hapd, buf, len, stype, ok); 1324 } 1325 1326 #endif /* NEED_AP_MLME */ 1327 1328 1329 static int hostapd_event_new_sta(struct hostapd_data *hapd, const u8 *addr) 1330 { 1331 struct sta_info *sta = ap_get_sta(hapd, addr); 1332 1333 if (sta) 1334 return 0; 1335 1336 wpa_printf(MSG_DEBUG, "Data frame from unknown STA " MACSTR 1337 " - adding a new STA", MAC2STR(addr)); 1338 sta = ap_sta_add(hapd, addr); 1339 if (sta) { 1340 hostapd_new_assoc_sta(hapd, sta, 0); 1341 } else { 1342 wpa_printf(MSG_DEBUG, "Failed to add STA entry for " MACSTR, 1343 MAC2STR(addr)); 1344 return -1; 1345 } 1346 1347 return 0; 1348 } 1349 1350 1351 static void hostapd_event_eapol_rx(struct hostapd_data *hapd, const u8 *src, 1352 const u8 *data, size_t data_len) 1353 { 1354 struct hostapd_iface *iface = hapd->iface; 1355 struct sta_info *sta; 1356 size_t j; 1357 1358 for (j = 0; j < iface->num_bss; j++) { 1359 sta = ap_get_sta(iface->bss[j], src); 1360 if (sta && sta->flags & WLAN_STA_ASSOC) { 1361 hapd = iface->bss[j]; 1362 break; 1363 } 1364 } 1365 1366 ieee802_1x_receive(hapd, src, data, data_len); 1367 } 1368 1369 #endif /* HOSTAPD */ 1370 1371 1372 static struct hostapd_channel_data * hostapd_get_mode_channel( 1373 struct hostapd_iface *iface, unsigned int freq) 1374 { 1375 int i; 1376 struct hostapd_channel_data *chan; 1377 1378 for (i = 0; i < iface->current_mode->num_channels; i++) { 1379 chan = &iface->current_mode->channels[i]; 1380 if ((unsigned int) chan->freq == freq) 1381 return chan; 1382 } 1383 1384 return NULL; 1385 } 1386 1387 1388 static void hostapd_update_nf(struct hostapd_iface *iface, 1389 struct hostapd_channel_data *chan, 1390 struct freq_survey *survey) 1391 { 1392 if (!iface->chans_surveyed) { 1393 chan->min_nf = survey->nf; 1394 iface->lowest_nf = survey->nf; 1395 } else { 1396 if (dl_list_empty(&chan->survey_list)) 1397 chan->min_nf = survey->nf; 1398 else if (survey->nf < chan->min_nf) 1399 chan->min_nf = survey->nf; 1400 if (survey->nf < iface->lowest_nf) 1401 iface->lowest_nf = survey->nf; 1402 } 1403 } 1404 1405 1406 static void hostapd_single_channel_get_survey(struct hostapd_iface *iface, 1407 struct survey_results *survey_res) 1408 { 1409 struct hostapd_channel_data *chan; 1410 struct freq_survey *survey; 1411 u64 divisor, dividend; 1412 1413 survey = dl_list_first(&survey_res->survey_list, struct freq_survey, 1414 list); 1415 if (!survey || !survey->freq) 1416 return; 1417 1418 chan = hostapd_get_mode_channel(iface, survey->freq); 1419 if (!chan || chan->flag & HOSTAPD_CHAN_DISABLED) 1420 return; 1421 1422 wpa_printf(MSG_DEBUG, 1423 "Single Channel Survey: (freq=%d channel_time=%ld channel_time_busy=%ld)", 1424 survey->freq, 1425 (unsigned long int) survey->channel_time, 1426 (unsigned long int) survey->channel_time_busy); 1427 1428 if (survey->channel_time > iface->last_channel_time && 1429 survey->channel_time > survey->channel_time_busy) { 1430 dividend = survey->channel_time_busy - 1431 iface->last_channel_time_busy; 1432 divisor = survey->channel_time - iface->last_channel_time; 1433 1434 iface->channel_utilization = dividend * 255 / divisor; 1435 wpa_printf(MSG_DEBUG, "Channel Utilization: %d", 1436 iface->channel_utilization); 1437 } 1438 iface->last_channel_time = survey->channel_time; 1439 iface->last_channel_time_busy = survey->channel_time_busy; 1440 } 1441 1442 1443 void hostapd_event_get_survey(struct hostapd_iface *iface, 1444 struct survey_results *survey_results) 1445 { 1446 struct freq_survey *survey, *tmp; 1447 struct hostapd_channel_data *chan; 1448 1449 if (dl_list_empty(&survey_results->survey_list)) { 1450 wpa_printf(MSG_DEBUG, "No survey data received"); 1451 return; 1452 } 1453 1454 if (survey_results->freq_filter) { 1455 hostapd_single_channel_get_survey(iface, survey_results); 1456 return; 1457 } 1458 1459 dl_list_for_each_safe(survey, tmp, &survey_results->survey_list, 1460 struct freq_survey, list) { 1461 chan = hostapd_get_mode_channel(iface, survey->freq); 1462 if (!chan) 1463 continue; 1464 if (chan->flag & HOSTAPD_CHAN_DISABLED) 1465 continue; 1466 1467 dl_list_del(&survey->list); 1468 dl_list_add_tail(&chan->survey_list, &survey->list); 1469 1470 hostapd_update_nf(iface, chan, survey); 1471 1472 iface->chans_surveyed++; 1473 } 1474 } 1475 1476 1477 #ifdef HOSTAPD 1478 #ifdef NEED_AP_MLME 1479 1480 static void hostapd_event_iface_unavailable(struct hostapd_data *hapd) 1481 { 1482 wpa_printf(MSG_DEBUG, "Interface %s is unavailable -- stopped", 1483 hapd->conf->iface); 1484 1485 if (hapd->csa_in_progress) { 1486 wpa_printf(MSG_INFO, "CSA failed (%s was stopped)", 1487 hapd->conf->iface); 1488 hostapd_switch_channel_fallback(hapd->iface, 1489 &hapd->cs_freq_params); 1490 } 1491 } 1492 1493 1494 static void hostapd_event_dfs_radar_detected(struct hostapd_data *hapd, 1495 struct dfs_event *radar) 1496 { 1497 wpa_printf(MSG_DEBUG, "DFS radar detected on %d MHz", radar->freq); 1498 hostapd_dfs_radar_detected(hapd->iface, radar->freq, radar->ht_enabled, 1499 radar->chan_offset, radar->chan_width, 1500 radar->cf1, radar->cf2); 1501 } 1502 1503 1504 static void hostapd_event_dfs_pre_cac_expired(struct hostapd_data *hapd, 1505 struct dfs_event *radar) 1506 { 1507 wpa_printf(MSG_DEBUG, "DFS Pre-CAC expired on %d MHz", radar->freq); 1508 hostapd_dfs_pre_cac_expired(hapd->iface, radar->freq, radar->ht_enabled, 1509 radar->chan_offset, radar->chan_width, 1510 radar->cf1, radar->cf2); 1511 } 1512 1513 1514 static void hostapd_event_dfs_cac_finished(struct hostapd_data *hapd, 1515 struct dfs_event *radar) 1516 { 1517 wpa_printf(MSG_DEBUG, "DFS CAC finished on %d MHz", radar->freq); 1518 hostapd_dfs_complete_cac(hapd->iface, 1, radar->freq, radar->ht_enabled, 1519 radar->chan_offset, radar->chan_width, 1520 radar->cf1, radar->cf2); 1521 } 1522 1523 1524 static void hostapd_event_dfs_cac_aborted(struct hostapd_data *hapd, 1525 struct dfs_event *radar) 1526 { 1527 wpa_printf(MSG_DEBUG, "DFS CAC aborted on %d MHz", radar->freq); 1528 hostapd_dfs_complete_cac(hapd->iface, 0, radar->freq, radar->ht_enabled, 1529 radar->chan_offset, radar->chan_width, 1530 radar->cf1, radar->cf2); 1531 } 1532 1533 1534 static void hostapd_event_dfs_nop_finished(struct hostapd_data *hapd, 1535 struct dfs_event *radar) 1536 { 1537 wpa_printf(MSG_DEBUG, "DFS NOP finished on %d MHz", radar->freq); 1538 hostapd_dfs_nop_finished(hapd->iface, radar->freq, radar->ht_enabled, 1539 radar->chan_offset, radar->chan_width, 1540 radar->cf1, radar->cf2); 1541 } 1542 1543 1544 static void hostapd_event_dfs_cac_started(struct hostapd_data *hapd, 1545 struct dfs_event *radar) 1546 { 1547 wpa_printf(MSG_DEBUG, "DFS offload CAC started on %d MHz", radar->freq); 1548 hostapd_dfs_start_cac(hapd->iface, radar->freq, radar->ht_enabled, 1549 radar->chan_offset, radar->chan_width, 1550 radar->cf1, radar->cf2); 1551 } 1552 1553 #endif /* NEED_AP_MLME */ 1554 1555 1556 static void hostapd_event_wds_sta_interface_status(struct hostapd_data *hapd, 1557 int istatus, 1558 const char *ifname, 1559 const u8 *addr) 1560 { 1561 struct sta_info *sta = ap_get_sta(hapd, addr); 1562 1563 if (sta) { 1564 os_free(sta->ifname_wds); 1565 if (istatus == INTERFACE_ADDED) 1566 sta->ifname_wds = os_strdup(ifname); 1567 else 1568 sta->ifname_wds = NULL; 1569 } 1570 1571 wpa_msg(hapd->msg_ctx, MSG_INFO, "%sifname=%s sta_addr=" MACSTR, 1572 istatus == INTERFACE_ADDED ? 1573 WDS_STA_INTERFACE_ADDED : WDS_STA_INTERFACE_REMOVED, 1574 ifname, MAC2STR(addr)); 1575 } 1576 1577 1578 void wpa_supplicant_event(void *ctx, enum wpa_event_type event, 1579 union wpa_event_data *data) 1580 { 1581 struct hostapd_data *hapd = ctx; 1582 #ifndef CONFIG_NO_STDOUT_DEBUG 1583 int level = MSG_DEBUG; 1584 1585 if (event == EVENT_RX_MGMT && data->rx_mgmt.frame && 1586 data->rx_mgmt.frame_len >= 24) { 1587 const struct ieee80211_hdr *hdr; 1588 u16 fc; 1589 1590 hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame; 1591 fc = le_to_host16(hdr->frame_control); 1592 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1593 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) 1594 level = MSG_EXCESSIVE; 1595 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && 1596 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_REQ) 1597 level = MSG_EXCESSIVE; 1598 } 1599 1600 wpa_dbg(hapd->msg_ctx, level, "Event %s (%d) received", 1601 event_to_string(event), event); 1602 #endif /* CONFIG_NO_STDOUT_DEBUG */ 1603 1604 switch (event) { 1605 case EVENT_MICHAEL_MIC_FAILURE: 1606 michael_mic_failure(hapd, data->michael_mic_failure.src, 1); 1607 break; 1608 case EVENT_SCAN_RESULTS: 1609 if (hapd->iface->scan_cb) 1610 hapd->iface->scan_cb(hapd->iface); 1611 break; 1612 case EVENT_WPS_BUTTON_PUSHED: 1613 hostapd_wps_button_pushed(hapd, NULL); 1614 break; 1615 #ifdef NEED_AP_MLME 1616 case EVENT_TX_STATUS: 1617 switch (data->tx_status.type) { 1618 case WLAN_FC_TYPE_MGMT: 1619 hostapd_mgmt_tx_cb(hapd, data->tx_status.data, 1620 data->tx_status.data_len, 1621 data->tx_status.stype, 1622 data->tx_status.ack); 1623 break; 1624 case WLAN_FC_TYPE_DATA: 1625 hostapd_tx_status(hapd, data->tx_status.dst, 1626 data->tx_status.data, 1627 data->tx_status.data_len, 1628 data->tx_status.ack); 1629 break; 1630 } 1631 break; 1632 case EVENT_EAPOL_TX_STATUS: 1633 hostapd_eapol_tx_status(hapd, data->eapol_tx_status.dst, 1634 data->eapol_tx_status.data, 1635 data->eapol_tx_status.data_len, 1636 data->eapol_tx_status.ack); 1637 break; 1638 case EVENT_DRIVER_CLIENT_POLL_OK: 1639 hostapd_client_poll_ok(hapd, data->client_poll.addr); 1640 break; 1641 case EVENT_RX_FROM_UNKNOWN: 1642 hostapd_rx_from_unknown_sta(hapd, data->rx_from_unknown.bssid, 1643 data->rx_from_unknown.addr, 1644 data->rx_from_unknown.wds); 1645 break; 1646 #endif /* NEED_AP_MLME */ 1647 case EVENT_RX_MGMT: 1648 if (!data->rx_mgmt.frame) 1649 break; 1650 #ifdef NEED_AP_MLME 1651 hostapd_mgmt_rx(hapd, &data->rx_mgmt); 1652 #else /* NEED_AP_MLME */ 1653 hostapd_action_rx(hapd, &data->rx_mgmt); 1654 #endif /* NEED_AP_MLME */ 1655 break; 1656 case EVENT_RX_PROBE_REQ: 1657 if (data->rx_probe_req.sa == NULL || 1658 data->rx_probe_req.ie == NULL) 1659 break; 1660 hostapd_probe_req_rx(hapd, data->rx_probe_req.sa, 1661 data->rx_probe_req.da, 1662 data->rx_probe_req.bssid, 1663 data->rx_probe_req.ie, 1664 data->rx_probe_req.ie_len, 1665 data->rx_probe_req.ssi_signal); 1666 break; 1667 case EVENT_NEW_STA: 1668 hostapd_event_new_sta(hapd, data->new_sta.addr); 1669 break; 1670 case EVENT_EAPOL_RX: 1671 hostapd_event_eapol_rx(hapd, data->eapol_rx.src, 1672 data->eapol_rx.data, 1673 data->eapol_rx.data_len); 1674 break; 1675 case EVENT_ASSOC: 1676 if (!data) 1677 return; 1678 hostapd_notif_assoc(hapd, data->assoc_info.addr, 1679 data->assoc_info.req_ies, 1680 data->assoc_info.req_ies_len, 1681 data->assoc_info.reassoc); 1682 break; 1683 case EVENT_DISASSOC: 1684 if (data) 1685 hostapd_notif_disassoc(hapd, data->disassoc_info.addr); 1686 break; 1687 case EVENT_DEAUTH: 1688 if (data) 1689 hostapd_notif_disassoc(hapd, data->deauth_info.addr); 1690 break; 1691 case EVENT_STATION_LOW_ACK: 1692 if (!data) 1693 break; 1694 hostapd_event_sta_low_ack(hapd, data->low_ack.addr); 1695 break; 1696 case EVENT_AUTH: 1697 hostapd_notif_auth(hapd, &data->auth); 1698 break; 1699 case EVENT_CH_SWITCH: 1700 if (!data) 1701 break; 1702 hostapd_event_ch_switch(hapd, data->ch_switch.freq, 1703 data->ch_switch.ht_enabled, 1704 data->ch_switch.ch_offset, 1705 data->ch_switch.ch_width, 1706 data->ch_switch.cf1, 1707 data->ch_switch.cf2); 1708 break; 1709 case EVENT_CONNECT_FAILED_REASON: 1710 if (!data) 1711 break; 1712 hostapd_event_connect_failed_reason( 1713 hapd, data->connect_failed_reason.addr, 1714 data->connect_failed_reason.code); 1715 break; 1716 case EVENT_SURVEY: 1717 hostapd_event_get_survey(hapd->iface, &data->survey_results); 1718 break; 1719 #ifdef NEED_AP_MLME 1720 case EVENT_INTERFACE_UNAVAILABLE: 1721 hostapd_event_iface_unavailable(hapd); 1722 break; 1723 case EVENT_DFS_RADAR_DETECTED: 1724 if (!data) 1725 break; 1726 hostapd_event_dfs_radar_detected(hapd, &data->dfs_event); 1727 break; 1728 case EVENT_DFS_PRE_CAC_EXPIRED: 1729 if (!data) 1730 break; 1731 hostapd_event_dfs_pre_cac_expired(hapd, &data->dfs_event); 1732 break; 1733 case EVENT_DFS_CAC_FINISHED: 1734 if (!data) 1735 break; 1736 hostapd_event_dfs_cac_finished(hapd, &data->dfs_event); 1737 break; 1738 case EVENT_DFS_CAC_ABORTED: 1739 if (!data) 1740 break; 1741 hostapd_event_dfs_cac_aborted(hapd, &data->dfs_event); 1742 break; 1743 case EVENT_DFS_NOP_FINISHED: 1744 if (!data) 1745 break; 1746 hostapd_event_dfs_nop_finished(hapd, &data->dfs_event); 1747 break; 1748 case EVENT_CHANNEL_LIST_CHANGED: 1749 /* channel list changed (regulatory?), update channel list */ 1750 /* TODO: check this. hostapd_get_hw_features() initializes 1751 * too much stuff. */ 1752 /* hostapd_get_hw_features(hapd->iface); */ 1753 hostapd_channel_list_updated( 1754 hapd->iface, data->channel_list_changed.initiator); 1755 break; 1756 case EVENT_DFS_CAC_STARTED: 1757 if (!data) 1758 break; 1759 hostapd_event_dfs_cac_started(hapd, &data->dfs_event); 1760 break; 1761 #endif /* NEED_AP_MLME */ 1762 case EVENT_INTERFACE_ENABLED: 1763 wpa_msg(hapd->msg_ctx, MSG_INFO, INTERFACE_ENABLED); 1764 if (hapd->disabled && hapd->started) { 1765 hapd->disabled = 0; 1766 /* 1767 * Try to re-enable interface if the driver stopped it 1768 * when the interface got disabled. 1769 */ 1770 if (hapd->wpa_auth) 1771 wpa_auth_reconfig_group_keys(hapd->wpa_auth); 1772 else 1773 hostapd_reconfig_encryption(hapd); 1774 hapd->reenable_beacon = 1; 1775 ieee802_11_set_beacon(hapd); 1776 #ifdef NEED_AP_MLME 1777 } else if (hapd->disabled && hapd->iface->cac_started) { 1778 wpa_printf(MSG_DEBUG, "DFS: restarting pending CAC"); 1779 hostapd_handle_dfs(hapd->iface); 1780 #endif /* NEED_AP_MLME */ 1781 } 1782 break; 1783 case EVENT_INTERFACE_DISABLED: 1784 hostapd_free_stas(hapd); 1785 wpa_msg(hapd->msg_ctx, MSG_INFO, INTERFACE_DISABLED); 1786 hapd->disabled = 1; 1787 break; 1788 #ifdef CONFIG_ACS 1789 case EVENT_ACS_CHANNEL_SELECTED: 1790 hostapd_acs_channel_selected(hapd, 1791 &data->acs_selected_channels); 1792 break; 1793 #endif /* CONFIG_ACS */ 1794 case EVENT_STATION_OPMODE_CHANGED: 1795 hostapd_event_sta_opmode_changed(hapd, data->sta_opmode.addr, 1796 data->sta_opmode.smps_mode, 1797 data->sta_opmode.chan_width, 1798 data->sta_opmode.rx_nss); 1799 break; 1800 case EVENT_WDS_STA_INTERFACE_STATUS: 1801 hostapd_event_wds_sta_interface_status( 1802 hapd, data->wds_sta_interface.istatus, 1803 data->wds_sta_interface.ifname, 1804 data->wds_sta_interface.sta_addr); 1805 break; 1806 default: 1807 wpa_printf(MSG_DEBUG, "Unknown event %d", event); 1808 break; 1809 } 1810 } 1811 1812 1813 void wpa_supplicant_event_global(void *ctx, enum wpa_event_type event, 1814 union wpa_event_data *data) 1815 { 1816 struct hapd_interfaces *interfaces = ctx; 1817 struct hostapd_data *hapd; 1818 1819 if (event != EVENT_INTERFACE_STATUS) 1820 return; 1821 1822 hapd = hostapd_get_iface(interfaces, data->interface_status.ifname); 1823 if (hapd && hapd->driver && hapd->driver->get_ifindex && 1824 hapd->drv_priv) { 1825 unsigned int ifindex; 1826 1827 ifindex = hapd->driver->get_ifindex(hapd->drv_priv); 1828 if (ifindex != data->interface_status.ifindex) { 1829 wpa_dbg(hapd->msg_ctx, MSG_DEBUG, 1830 "interface status ifindex %d mismatch (%d)", 1831 ifindex, data->interface_status.ifindex); 1832 return; 1833 } 1834 } 1835 if (hapd) 1836 wpa_supplicant_event(hapd, event, data); 1837 } 1838 1839 #endif /* HOSTAPD */ 1840
