1 /* 2 * hostapd - Driver operations 3 * Copyright (c) 2009-2010, 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 "common/ieee802_11_defs.h" 13 #include "common/ieee802_11_common.h" 14 #include "common/hw_features_common.h" 15 #include "wps/wps.h" 16 #include "p2p/p2p.h" 17 #include "hostapd.h" 18 #include "ieee802_11.h" 19 #include "sta_info.h" 20 #include "ap_config.h" 21 #include "p2p_hostapd.h" 22 #include "hs20.h" 23 #include "wpa_auth.h" 24 #include "ap_drv_ops.h" 25 26 27 u32 hostapd_sta_flags_to_drv(u32 flags) 28 { 29 int res = 0; 30 if (flags & WLAN_STA_AUTHORIZED) 31 res |= WPA_STA_AUTHORIZED; 32 if (flags & WLAN_STA_WMM) 33 res |= WPA_STA_WMM; 34 if (flags & WLAN_STA_SHORT_PREAMBLE) 35 res |= WPA_STA_SHORT_PREAMBLE; 36 if (flags & WLAN_STA_MFP) 37 res |= WPA_STA_MFP; 38 if (flags & WLAN_STA_AUTH) 39 res |= WPA_STA_AUTHENTICATED; 40 if (flags & WLAN_STA_ASSOC) 41 res |= WPA_STA_ASSOCIATED; 42 return res; 43 } 44 45 46 static int add_buf(struct wpabuf **dst, const struct wpabuf *src) 47 { 48 if (!src) 49 return 0; 50 if (wpabuf_resize(dst, wpabuf_len(src)) != 0) 51 return -1; 52 wpabuf_put_buf(*dst, src); 53 return 0; 54 } 55 56 57 static int add_buf_data(struct wpabuf **dst, const u8 *data, size_t len) 58 { 59 if (!data || !len) 60 return 0; 61 if (wpabuf_resize(dst, len) != 0) 62 return -1; 63 wpabuf_put_data(*dst, data, len); 64 return 0; 65 } 66 67 68 int hostapd_build_ap_extra_ies(struct hostapd_data *hapd, 69 struct wpabuf **beacon_ret, 70 struct wpabuf **proberesp_ret, 71 struct wpabuf **assocresp_ret) 72 { 73 struct wpabuf *beacon = NULL, *proberesp = NULL, *assocresp = NULL; 74 u8 buf[200], *pos; 75 76 *beacon_ret = *proberesp_ret = *assocresp_ret = NULL; 77 78 #ifdef NEED_AP_MLME 79 pos = buf; 80 pos = hostapd_eid_rm_enabled_capab(hapd, pos, sizeof(buf)); 81 if (add_buf_data(&assocresp, buf, pos - buf) < 0 || 82 add_buf_data(&proberesp, buf, pos - buf) < 0) 83 goto fail; 84 #endif /* NEED_AP_MLME */ 85 86 pos = buf; 87 pos = hostapd_eid_time_adv(hapd, pos); 88 if (add_buf_data(&beacon, buf, pos - buf) < 0) 89 goto fail; 90 pos = hostapd_eid_time_zone(hapd, pos); 91 if (add_buf_data(&proberesp, buf, pos - buf) < 0) 92 goto fail; 93 94 pos = buf; 95 pos = hostapd_eid_ext_capab(hapd, pos, false); 96 if (add_buf_data(&assocresp, buf, pos - buf) < 0) 97 goto fail; 98 pos = hostapd_eid_interworking(hapd, pos); 99 pos = hostapd_eid_adv_proto(hapd, pos); 100 pos = hostapd_eid_roaming_consortium(hapd, pos); 101 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 102 add_buf_data(&proberesp, buf, pos - buf) < 0) 103 goto fail; 104 105 #ifdef CONFIG_FST 106 if (add_buf(&beacon, hapd->iface->fst_ies) < 0 || 107 add_buf(&proberesp, hapd->iface->fst_ies) < 0 || 108 add_buf(&assocresp, hapd->iface->fst_ies) < 0) 109 goto fail; 110 #endif /* CONFIG_FST */ 111 112 #ifdef CONFIG_FILS 113 pos = hostapd_eid_fils_indic(hapd, buf, 0); 114 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 115 add_buf_data(&proberesp, buf, pos - buf) < 0) 116 goto fail; 117 #endif /* CONFIG_FILS */ 118 119 pos = hostapd_eid_rsnxe(hapd, buf, sizeof(buf)); 120 if (add_buf_data(&assocresp, buf, pos - buf) < 0) 121 goto fail; 122 123 if (add_buf(&beacon, hapd->wps_beacon_ie) < 0 || 124 add_buf(&proberesp, hapd->wps_probe_resp_ie) < 0) 125 goto fail; 126 127 #ifdef CONFIG_P2P 128 if (add_buf(&beacon, hapd->p2p_beacon_ie) < 0 || 129 add_buf(&proberesp, hapd->p2p_probe_resp_ie) < 0) 130 goto fail; 131 #endif /* CONFIG_P2P */ 132 133 #ifdef CONFIG_P2P_MANAGER 134 if (hapd->conf->p2p & P2P_MANAGE) { 135 if (wpabuf_resize(&beacon, 100) == 0) { 136 u8 *start, *p; 137 start = wpabuf_put(beacon, 0); 138 p = hostapd_eid_p2p_manage(hapd, start); 139 wpabuf_put(beacon, p - start); 140 } 141 142 if (wpabuf_resize(&proberesp, 100) == 0) { 143 u8 *start, *p; 144 start = wpabuf_put(proberesp, 0); 145 p = hostapd_eid_p2p_manage(hapd, start); 146 wpabuf_put(proberesp, p - start); 147 } 148 } 149 #endif /* CONFIG_P2P_MANAGER */ 150 151 #ifdef CONFIG_WPS 152 if (hapd->conf->wps_state) { 153 struct wpabuf *a = wps_build_assoc_resp_ie(); 154 add_buf(&assocresp, a); 155 wpabuf_free(a); 156 } 157 #endif /* CONFIG_WPS */ 158 159 #ifdef CONFIG_P2P_MANAGER 160 if (hapd->conf->p2p & P2P_MANAGE) { 161 if (wpabuf_resize(&assocresp, 100) == 0) { 162 u8 *start, *p; 163 start = wpabuf_put(assocresp, 0); 164 p = hostapd_eid_p2p_manage(hapd, start); 165 wpabuf_put(assocresp, p - start); 166 } 167 } 168 #endif /* CONFIG_P2P_MANAGER */ 169 170 #ifdef CONFIG_WIFI_DISPLAY 171 if (hapd->p2p_group) { 172 struct wpabuf *a; 173 a = p2p_group_assoc_resp_ie(hapd->p2p_group, P2P_SC_SUCCESS); 174 add_buf(&assocresp, a); 175 wpabuf_free(a); 176 } 177 #endif /* CONFIG_WIFI_DISPLAY */ 178 179 #ifdef CONFIG_HS20 180 pos = hostapd_eid_hs20_indication(hapd, buf); 181 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 182 add_buf_data(&proberesp, buf, pos - buf) < 0) 183 goto fail; 184 185 pos = hostapd_eid_osen(hapd, buf); 186 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 187 add_buf_data(&proberesp, buf, pos - buf) < 0) 188 goto fail; 189 #endif /* CONFIG_HS20 */ 190 191 #ifdef CONFIG_MBO 192 if (hapd->conf->mbo_enabled || 193 OCE_STA_CFON_ENABLED(hapd) || OCE_AP_ENABLED(hapd)) { 194 pos = hostapd_eid_mbo(hapd, buf, sizeof(buf)); 195 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 196 add_buf_data(&proberesp, buf, pos - buf) < 0 || 197 add_buf_data(&assocresp, buf, pos - buf) < 0) 198 goto fail; 199 } 200 #endif /* CONFIG_MBO */ 201 202 #ifdef CONFIG_OWE 203 pos = hostapd_eid_owe_trans(hapd, buf, sizeof(buf)); 204 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 205 add_buf_data(&proberesp, buf, pos - buf) < 0) 206 goto fail; 207 #endif /* CONFIG_OWE */ 208 209 add_buf(&beacon, hapd->conf->vendor_elements); 210 add_buf(&proberesp, hapd->conf->vendor_elements); 211 #ifdef CONFIG_TESTING_OPTIONS 212 add_buf(&proberesp, hapd->conf->presp_elements); 213 #endif /* CONFIG_TESTING_OPTIONS */ 214 add_buf(&assocresp, hapd->conf->assocresp_elements); 215 216 *beacon_ret = beacon; 217 *proberesp_ret = proberesp; 218 *assocresp_ret = assocresp; 219 220 return 0; 221 222 fail: 223 wpabuf_free(beacon); 224 wpabuf_free(proberesp); 225 wpabuf_free(assocresp); 226 return -1; 227 } 228 229 230 void hostapd_free_ap_extra_ies(struct hostapd_data *hapd, 231 struct wpabuf *beacon, 232 struct wpabuf *proberesp, 233 struct wpabuf *assocresp) 234 { 235 wpabuf_free(beacon); 236 wpabuf_free(proberesp); 237 wpabuf_free(assocresp); 238 } 239 240 241 int hostapd_reset_ap_wps_ie(struct hostapd_data *hapd) 242 { 243 if (hapd->driver == NULL || hapd->driver->set_ap_wps_ie == NULL) 244 return 0; 245 246 return hapd->driver->set_ap_wps_ie(hapd->drv_priv, NULL, NULL, NULL); 247 } 248 249 250 int hostapd_set_ap_wps_ie(struct hostapd_data *hapd) 251 { 252 struct wpabuf *beacon, *proberesp, *assocresp; 253 int ret; 254 255 if (hapd->driver == NULL || hapd->driver->set_ap_wps_ie == NULL) 256 return 0; 257 258 if (hostapd_build_ap_extra_ies(hapd, &beacon, &proberesp, &assocresp) < 259 0) 260 return -1; 261 262 ret = hapd->driver->set_ap_wps_ie(hapd->drv_priv, beacon, proberesp, 263 assocresp); 264 265 hostapd_free_ap_extra_ies(hapd, beacon, proberesp, assocresp); 266 267 return ret; 268 } 269 270 271 bool hostapd_sta_is_link_sta(struct hostapd_data *hapd, 272 struct sta_info *sta) 273 { 274 #ifdef CONFIG_IEEE80211BE 275 if (ap_sta_is_mld(hapd, sta) && 276 sta->mld_assoc_link_id != hapd->mld_link_id) 277 return true; 278 #endif /* CONFIG_IEEE80211BE */ 279 280 return false; 281 } 282 283 284 int hostapd_set_authorized(struct hostapd_data *hapd, 285 struct sta_info *sta, int authorized) 286 { 287 /* 288 * The WPA_STA_AUTHORIZED flag is relevant only for the MLD station and 289 * not to the link stations (as the authorization is done between the 290 * MLD peers). Thus, do not propagate the change to the driver for the 291 * link stations. 292 */ 293 if (hostapd_sta_is_link_sta(hapd, sta)) { 294 wpa_printf(MSG_DEBUG, 295 "%s: Do not update link station flags (" MACSTR ")", 296 __func__, MAC2STR(sta->addr)); 297 return 0; 298 } 299 300 if (authorized) { 301 return hostapd_sta_set_flags(hapd, sta->addr, 302 hostapd_sta_flags_to_drv( 303 sta->flags), 304 WPA_STA_AUTHORIZED, ~0); 305 } 306 307 return hostapd_sta_set_flags(hapd, sta->addr, 308 hostapd_sta_flags_to_drv(sta->flags), 309 0, ~WPA_STA_AUTHORIZED); 310 } 311 312 313 int hostapd_set_sta_flags(struct hostapd_data *hapd, struct sta_info *sta) 314 { 315 int set_flags, total_flags, flags_and, flags_or; 316 total_flags = hostapd_sta_flags_to_drv(sta->flags); 317 set_flags = WPA_STA_SHORT_PREAMBLE | WPA_STA_WMM | WPA_STA_MFP | 318 WPA_STA_AUTHORIZED; 319 320 /* 321 * All the station flags other than WPA_STA_SHORT_PREAMBLE are relevant 322 * only for the MLD station and not to the link stations (as these flags 323 * are related to the MLD state and not the link state). As for the 324 * WPA_STA_SHORT_PREAMBLE, since the station is an EHT station, it must 325 * support short preamble. Thus, do not propagate the change to the 326 * driver for the link stations. 327 */ 328 if (hostapd_sta_is_link_sta(hapd, sta)) { 329 wpa_printf(MSG_DEBUG, 330 "%s: Do not update link station flags (" MACSTR ")", 331 __func__, MAC2STR(sta->addr)); 332 return 0; 333 } 334 335 flags_or = total_flags & set_flags; 336 flags_and = total_flags | ~set_flags; 337 return hostapd_sta_set_flags(hapd, sta->addr, total_flags, 338 flags_or, flags_and); 339 } 340 341 342 int hostapd_set_drv_ieee8021x(struct hostapd_data *hapd, const char *ifname, 343 int enabled) 344 { 345 struct wpa_bss_params params; 346 os_memset(¶ms, 0, sizeof(params)); 347 params.ifname = ifname; 348 params.enabled = enabled; 349 if (enabled) { 350 params.wpa = hapd->conf->wpa; 351 params.ieee802_1x = hapd->conf->ieee802_1x; 352 params.wpa_group = hapd->conf->wpa_group; 353 if ((hapd->conf->wpa & (WPA_PROTO_WPA | WPA_PROTO_RSN)) == 354 (WPA_PROTO_WPA | WPA_PROTO_RSN)) 355 params.wpa_pairwise = hapd->conf->wpa_pairwise | 356 hapd->conf->rsn_pairwise; 357 else if (hapd->conf->wpa & WPA_PROTO_RSN) 358 params.wpa_pairwise = hapd->conf->rsn_pairwise; 359 else if (hapd->conf->wpa & WPA_PROTO_WPA) 360 params.wpa_pairwise = hapd->conf->wpa_pairwise; 361 params.wpa_key_mgmt = hapd->conf->wpa_key_mgmt; 362 params.rsn_preauth = hapd->conf->rsn_preauth; 363 params.ieee80211w = hapd->conf->ieee80211w; 364 } 365 return hostapd_set_ieee8021x(hapd, ¶ms); 366 } 367 368 369 int hostapd_vlan_if_add(struct hostapd_data *hapd, const char *ifname) 370 { 371 char force_ifname[IFNAMSIZ]; 372 u8 if_addr[ETH_ALEN]; 373 return hostapd_if_add(hapd, WPA_IF_AP_VLAN, ifname, hapd->own_addr, 374 NULL, NULL, force_ifname, if_addr, NULL, 0); 375 } 376 377 378 int hostapd_vlan_if_remove(struct hostapd_data *hapd, const char *ifname) 379 { 380 return hostapd_if_remove(hapd, WPA_IF_AP_VLAN, ifname); 381 } 382 383 384 int hostapd_set_wds_sta(struct hostapd_data *hapd, char *ifname_wds, 385 const u8 *addr, int aid, int val) 386 { 387 const char *bridge = NULL; 388 389 if (hapd->driver == NULL || hapd->driver->set_wds_sta == NULL) 390 return -1; 391 if (hapd->conf->wds_bridge[0]) 392 bridge = hapd->conf->wds_bridge; 393 else if (hapd->conf->bridge[0]) 394 bridge = hapd->conf->bridge; 395 return hapd->driver->set_wds_sta(hapd->drv_priv, addr, aid, val, 396 bridge, ifname_wds); 397 } 398 399 400 int hostapd_add_sta_node(struct hostapd_data *hapd, const u8 *addr, 401 u16 auth_alg) 402 { 403 if (hapd->driver == NULL || hapd->driver->add_sta_node == NULL) 404 return -EOPNOTSUPP; 405 return hapd->driver->add_sta_node(hapd->drv_priv, addr, auth_alg); 406 } 407 408 409 int hostapd_sta_auth(struct hostapd_data *hapd, const u8 *addr, 410 u16 seq, u16 status, const u8 *ie, size_t len) 411 { 412 struct wpa_driver_sta_auth_params params; 413 #ifdef CONFIG_FILS 414 struct sta_info *sta; 415 #endif /* CONFIG_FILS */ 416 417 if (hapd->driver == NULL || hapd->driver->sta_auth == NULL) 418 return 0; 419 420 os_memset(¶ms, 0, sizeof(params)); 421 422 #ifdef CONFIG_FILS 423 sta = ap_get_sta(hapd, addr); 424 if (!sta) { 425 wpa_printf(MSG_DEBUG, "Station " MACSTR 426 " not found for sta_auth processing", 427 MAC2STR(addr)); 428 return 0; 429 } 430 431 if (sta->auth_alg == WLAN_AUTH_FILS_SK || 432 sta->auth_alg == WLAN_AUTH_FILS_SK_PFS || 433 sta->auth_alg == WLAN_AUTH_FILS_PK) { 434 params.fils_auth = 1; 435 wpa_auth_get_fils_aead_params(sta->wpa_sm, params.fils_anonce, 436 params.fils_snonce, 437 params.fils_kek, 438 ¶ms.fils_kek_len); 439 } 440 #endif /* CONFIG_FILS */ 441 442 params.own_addr = hapd->own_addr; 443 params.addr = addr; 444 params.seq = seq; 445 params.status = status; 446 params.ie = ie; 447 params.len = len; 448 449 return hapd->driver->sta_auth(hapd->drv_priv, ¶ms); 450 } 451 452 453 int hostapd_sta_assoc(struct hostapd_data *hapd, const u8 *addr, 454 int reassoc, u16 status, const u8 *ie, size_t len) 455 { 456 if (hapd->driver == NULL || hapd->driver->sta_assoc == NULL) 457 return 0; 458 return hapd->driver->sta_assoc(hapd->drv_priv, hapd->own_addr, addr, 459 reassoc, status, ie, len); 460 } 461 462 463 int hostapd_sta_add(struct hostapd_data *hapd, 464 const u8 *addr, u16 aid, u16 capability, 465 const u8 *supp_rates, size_t supp_rates_len, 466 u16 listen_interval, 467 const struct ieee80211_ht_capabilities *ht_capab, 468 const struct ieee80211_vht_capabilities *vht_capab, 469 const struct ieee80211_he_capabilities *he_capab, 470 size_t he_capab_len, 471 const struct ieee80211_eht_capabilities *eht_capab, 472 size_t eht_capab_len, 473 const struct ieee80211_he_6ghz_band_cap *he_6ghz_capab, 474 u32 flags, u8 qosinfo, u8 vht_opmode, int supp_p2p_ps, 475 int set, const u8 *link_addr, bool mld_link_sta) 476 { 477 struct hostapd_sta_add_params params; 478 479 if (hapd->driver == NULL) 480 return 0; 481 if (hapd->driver->sta_add == NULL) 482 return 0; 483 484 os_memset(¶ms, 0, sizeof(params)); 485 params.addr = addr; 486 params.aid = aid; 487 params.capability = capability; 488 params.supp_rates = supp_rates; 489 params.supp_rates_len = supp_rates_len; 490 params.listen_interval = listen_interval; 491 params.ht_capabilities = ht_capab; 492 params.vht_capabilities = vht_capab; 493 params.he_capab = he_capab; 494 params.he_capab_len = he_capab_len; 495 params.eht_capab = eht_capab; 496 params.eht_capab_len = eht_capab_len; 497 params.he_6ghz_capab = he_6ghz_capab; 498 params.vht_opmode_enabled = !!(flags & WLAN_STA_VHT_OPMODE_ENABLED); 499 params.vht_opmode = vht_opmode; 500 params.flags = hostapd_sta_flags_to_drv(flags); 501 params.qosinfo = qosinfo; 502 params.support_p2p_ps = supp_p2p_ps; 503 params.set = set; 504 params.mld_link_id = -1; 505 506 #ifdef CONFIG_IEEE80211BE 507 /* 508 * An AP MLD needs to always specify to what link the station needs 509 * to be added. 510 */ 511 if (hapd->conf->mld_ap) { 512 params.mld_link_id = hapd->mld_link_id; 513 params.mld_link_addr = link_addr; 514 params.mld_link_sta = mld_link_sta; 515 } 516 #endif /* CONFIG_IEEE80211BE */ 517 518 return hapd->driver->sta_add(hapd->drv_priv, ¶ms); 519 } 520 521 522 int hostapd_add_tspec(struct hostapd_data *hapd, const u8 *addr, 523 u8 *tspec_ie, size_t tspec_ielen) 524 { 525 if (hapd->driver == NULL || hapd->driver->add_tspec == NULL) 526 return 0; 527 return hapd->driver->add_tspec(hapd->drv_priv, addr, tspec_ie, 528 tspec_ielen); 529 } 530 531 532 int hostapd_set_privacy(struct hostapd_data *hapd, int enabled) 533 { 534 if (hapd->driver == NULL || hapd->driver->set_privacy == NULL) 535 return 0; 536 return hapd->driver->set_privacy(hapd->drv_priv, enabled); 537 } 538 539 540 int hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem, 541 size_t elem_len) 542 { 543 if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL) 544 return 0; 545 return hapd->driver->set_generic_elem(hapd->drv_priv, elem, elem_len); 546 } 547 548 549 int hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len) 550 { 551 if (hapd->driver == NULL || hapd->driver->hapd_get_ssid == NULL) 552 return 0; 553 return hapd->driver->hapd_get_ssid(hapd->drv_priv, buf, len); 554 } 555 556 557 int hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len) 558 { 559 if (hapd->driver == NULL || hapd->driver->hapd_set_ssid == NULL) 560 return 0; 561 return hapd->driver->hapd_set_ssid(hapd->drv_priv, buf, len); 562 } 563 564 565 int hostapd_if_add(struct hostapd_data *hapd, enum wpa_driver_if_type type, 566 const char *ifname, const u8 *addr, void *bss_ctx, 567 void **drv_priv, char *force_ifname, u8 *if_addr, 568 const char *bridge, int use_existing) 569 { 570 if (hapd->driver == NULL || hapd->driver->if_add == NULL) 571 return -1; 572 return hapd->driver->if_add(hapd->drv_priv, type, ifname, addr, 573 bss_ctx, drv_priv, force_ifname, if_addr, 574 bridge, use_existing, 1); 575 } 576 577 578 #ifdef CONFIG_IEEE80211BE 579 int hostapd_if_link_remove(struct hostapd_data *hapd, 580 enum wpa_driver_if_type type, 581 const char *ifname, u8 link_id) 582 { 583 if (!hapd->driver || !hapd->drv_priv || !hapd->driver->link_remove) 584 return -1; 585 586 return hapd->driver->link_remove(hapd->drv_priv, type, ifname, 587 hapd->mld_link_id); 588 } 589 #endif /* CONFIG_IEEE80211BE */ 590 591 592 int hostapd_if_remove(struct hostapd_data *hapd, enum wpa_driver_if_type type, 593 const char *ifname) 594 { 595 if (hapd->driver == NULL || hapd->drv_priv == NULL || 596 hapd->driver->if_remove == NULL) 597 return -1; 598 599 #ifdef CONFIG_IEEE80211BE 600 if (hapd->conf->mld_ap) 601 return hostapd_if_link_remove(hapd, type, ifname, 602 hapd->mld_link_id); 603 #endif /* CONFIG_IEEE80211BE */ 604 605 return hapd->driver->if_remove(hapd->drv_priv, type, ifname); 606 } 607 608 609 int hostapd_set_ieee8021x(struct hostapd_data *hapd, 610 struct wpa_bss_params *params) 611 { 612 if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL) 613 return 0; 614 return hapd->driver->set_ieee8021x(hapd->drv_priv, params); 615 } 616 617 618 int hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd, 619 const u8 *addr, int idx, int link_id, u8 *seq) 620 { 621 if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL) 622 return 0; 623 return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx, 624 link_id, seq); 625 } 626 627 628 int hostapd_flush(struct hostapd_data *hapd) 629 { 630 int link_id = -1; 631 632 if (hapd->driver == NULL || hapd->driver->flush == NULL) 633 return 0; 634 635 #ifdef CONFIG_IEEE80211BE 636 if (hapd->conf && hapd->conf->mld_ap) 637 link_id = hapd->mld_link_id; 638 #endif /* CONFIG_IEEE80211BE */ 639 640 return hapd->driver->flush(hapd->drv_priv, link_id); 641 } 642 643 644 int hostapd_set_freq(struct hostapd_data *hapd, enum hostapd_hw_mode mode, 645 int freq, int channel, int edmg, u8 edmg_channel, 646 int ht_enabled, int vht_enabled, 647 int he_enabled, bool eht_enabled, 648 int sec_channel_offset, int oper_chwidth, 649 int center_segment0, int center_segment1) 650 { 651 struct hostapd_freq_params data; 652 struct hostapd_hw_modes *cmode = hapd->iface->current_mode; 653 654 if (hostapd_set_freq_params(&data, mode, freq, channel, edmg, 655 edmg_channel, ht_enabled, 656 vht_enabled, he_enabled, eht_enabled, 657 sec_channel_offset, oper_chwidth, 658 center_segment0, center_segment1, 659 cmode ? cmode->vht_capab : 0, 660 cmode ? 661 &cmode->he_capab[IEEE80211_MODE_AP] : NULL, 662 cmode ? 663 &cmode->eht_capab[IEEE80211_MODE_AP] : 664 NULL, hostapd_get_punct_bitmap(hapd))) 665 return -1; 666 667 if (hapd->driver == NULL) 668 return 0; 669 if (hapd->driver->set_freq == NULL) 670 return 0; 671 672 data.link_id = -1; 673 674 #ifdef CONFIG_IEEE80211BE 675 if (hapd->conf->mld_ap) { 676 data.link_id = hapd->mld_link_id; 677 wpa_printf(MSG_DEBUG, 678 "hostapd_set_freq: link_id=%d", data.link_id); 679 } 680 #endif /* CONFIG_IEEE80211BE */ 681 682 return hapd->driver->set_freq(hapd->drv_priv, &data); 683 } 684 685 int hostapd_set_rts(struct hostapd_data *hapd, int rts) 686 { 687 if (hapd->driver == NULL || hapd->driver->set_rts == NULL) 688 return 0; 689 return hapd->driver->set_rts(hapd->drv_priv, rts); 690 } 691 692 693 int hostapd_set_frag(struct hostapd_data *hapd, int frag) 694 { 695 if (hapd->driver == NULL || hapd->driver->set_frag == NULL) 696 return 0; 697 return hapd->driver->set_frag(hapd->drv_priv, frag); 698 } 699 700 701 int hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr, 702 int total_flags, int flags_or, int flags_and) 703 { 704 if (!hapd->driver || !hapd->drv_priv || !hapd->driver->sta_set_flags) 705 return 0; 706 return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags, 707 flags_or, flags_and); 708 } 709 710 711 int hostapd_sta_set_airtime_weight(struct hostapd_data *hapd, const u8 *addr, 712 unsigned int weight) 713 { 714 if (!hapd->driver || !hapd->driver->sta_set_airtime_weight) 715 return 0; 716 return hapd->driver->sta_set_airtime_weight(hapd->drv_priv, addr, 717 weight); 718 } 719 720 721 int hostapd_set_country(struct hostapd_data *hapd, const char *country) 722 { 723 if (hapd->driver == NULL || 724 hapd->driver->set_country == NULL) 725 return 0; 726 return hapd->driver->set_country(hapd->drv_priv, country); 727 } 728 729 730 int hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs, 731 int cw_min, int cw_max, int burst_time) 732 { 733 int link_id = -1; 734 735 if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL) 736 return 0; 737 738 #ifdef CONFIG_IEEE80211BE 739 if (hapd->conf->mld_ap) 740 link_id = hapd->mld_link_id; 741 #endif /* CONFIG_IEEE80211BE */ 742 743 return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs, 744 cw_min, cw_max, burst_time, 745 link_id); 746 } 747 748 749 struct hostapd_hw_modes * 750 hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes, 751 u16 *flags, u8 *dfs_domain) 752 { 753 if (!hapd->driver || !hapd->driver->get_hw_feature_data || 754 !hapd->drv_priv) 755 return NULL; 756 return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes, 757 flags, dfs_domain); 758 } 759 760 761 int hostapd_driver_commit(struct hostapd_data *hapd) 762 { 763 if (hapd->driver == NULL || hapd->driver->commit == NULL) 764 return 0; 765 return hapd->driver->commit(hapd->drv_priv); 766 } 767 768 769 int hostapd_drv_none(struct hostapd_data *hapd) 770 { 771 return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0; 772 } 773 774 775 bool hostapd_drv_nl80211(struct hostapd_data *hapd) 776 { 777 return hapd->driver && os_strcmp(hapd->driver->name, "nl80211") == 0; 778 } 779 780 781 int hostapd_driver_scan(struct hostapd_data *hapd, 782 struct wpa_driver_scan_params *params) 783 { 784 if (hapd->driver && hapd->driver->scan2) 785 return hapd->driver->scan2(hapd->drv_priv, params); 786 return -1; 787 } 788 789 790 struct wpa_scan_results * hostapd_driver_get_scan_results( 791 struct hostapd_data *hapd) 792 { 793 if (hapd->driver && hapd->driver->get_scan_results) 794 return hapd->driver->get_scan_results(hapd->drv_priv, NULL); 795 if (hapd->driver && hapd->driver->get_scan_results2) 796 return hapd->driver->get_scan_results2(hapd->drv_priv); 797 return NULL; 798 } 799 800 801 int hostapd_driver_set_noa(struct hostapd_data *hapd, u8 count, int start, 802 int duration) 803 { 804 if (hapd->driver && hapd->driver->set_noa) 805 return hapd->driver->set_noa(hapd->drv_priv, count, start, 806 duration); 807 return -1; 808 } 809 810 811 int hostapd_drv_set_key(const char *ifname, struct hostapd_data *hapd, 812 enum wpa_alg alg, const u8 *addr, 813 int key_idx, int vlan_id, int set_tx, 814 const u8 *seq, size_t seq_len, 815 const u8 *key, size_t key_len, enum key_flag key_flag) 816 { 817 struct wpa_driver_set_key_params params; 818 819 if (hapd->driver == NULL || hapd->driver->set_key == NULL) 820 return 0; 821 822 os_memset(¶ms, 0, sizeof(params)); 823 params.ifname = ifname; 824 params.alg = alg; 825 params.addr = addr; 826 params.key_idx = key_idx; 827 params.set_tx = set_tx; 828 params.seq = seq; 829 params.seq_len = seq_len; 830 params.key = key; 831 params.key_len = key_len; 832 params.vlan_id = vlan_id; 833 params.key_flag = key_flag; 834 params.link_id = -1; 835 836 #ifdef CONFIG_IEEE80211BE 837 if (hapd->conf->mld_ap && !(key_flag & KEY_FLAG_PAIRWISE)) 838 params.link_id = hapd->mld_link_id; 839 #endif /* CONFIG_IEEE80211BE */ 840 841 return hapd->driver->set_key(hapd->drv_priv, ¶ms); 842 } 843 844 845 int hostapd_drv_send_mlme(struct hostapd_data *hapd, 846 const void *msg, size_t len, int noack, 847 const u16 *csa_offs, size_t csa_offs_len, 848 int no_encrypt) 849 { 850 int link_id = -1; 851 852 #ifdef CONFIG_IEEE80211BE 853 if (hapd->conf->mld_ap) 854 link_id = hapd->mld_link_id; 855 #endif /* CONFIG_IEEE80211BE */ 856 857 if (!hapd->driver || !hapd->driver->send_mlme || !hapd->drv_priv) 858 return 0; 859 return hapd->driver->send_mlme(hapd->drv_priv, msg, len, noack, 0, 860 csa_offs, csa_offs_len, no_encrypt, 0, 861 link_id); 862 } 863 864 865 int hostapd_drv_sta_deauth(struct hostapd_data *hapd, 866 const u8 *addr, int reason) 867 { 868 int link_id = -1; 869 const u8 *own_addr = hapd->own_addr; 870 871 #ifdef CONFIG_IEEE80211BE 872 if (hapd->conf->mld_ap) { 873 struct sta_info *sta = ap_get_sta(hapd, addr); 874 875 link_id = hapd->mld_link_id; 876 if (ap_sta_is_mld(hapd, sta)) 877 own_addr = hapd->mld->mld_addr; 878 } 879 #endif /* CONFIG_IEEE80211BE */ 880 881 if (!hapd->driver || !hapd->driver->sta_deauth || !hapd->drv_priv) 882 return 0; 883 return hapd->driver->sta_deauth(hapd->drv_priv, own_addr, addr, 884 reason, link_id); 885 } 886 887 888 int hostapd_drv_sta_disassoc(struct hostapd_data *hapd, 889 const u8 *addr, int reason) 890 { 891 const u8 *own_addr = hapd->own_addr; 892 893 #ifdef CONFIG_IEEE80211BE 894 if (hapd->conf->mld_ap) { 895 struct sta_info *sta = ap_get_sta(hapd, addr); 896 897 if (ap_sta_is_mld(hapd, sta)) 898 own_addr = hapd->mld->mld_addr; 899 } 900 #endif /* CONFIG_IEEE80211BE */ 901 902 if (!hapd->driver || !hapd->driver->sta_disassoc || !hapd->drv_priv) 903 return 0; 904 return hapd->driver->sta_disassoc(hapd->drv_priv, own_addr, addr, 905 reason); 906 } 907 908 909 int hostapd_drv_wnm_oper(struct hostapd_data *hapd, enum wnm_oper oper, 910 const u8 *peer, u8 *buf, u16 *buf_len) 911 { 912 if (hapd->driver == NULL || hapd->driver->wnm_oper == NULL) 913 return -1; 914 return hapd->driver->wnm_oper(hapd->drv_priv, oper, peer, buf, 915 buf_len); 916 } 917 918 919 static int hapd_drv_send_action(struct hostapd_data *hapd, unsigned int freq, 920 unsigned int wait, const u8 *dst, 921 const u8 *data, size_t len, bool addr3_ap) 922 { 923 const u8 *own_addr = hapd->own_addr; 924 const u8 *bssid; 925 const u8 wildcard_bssid[ETH_ALEN] = { 926 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 927 }; 928 struct sta_info *sta; 929 930 if (!hapd->driver || !hapd->driver->send_action || !hapd->drv_priv) 931 return 0; 932 bssid = hapd->own_addr; 933 if (!addr3_ap && !is_multicast_ether_addr(dst) && 934 len > 0 && data[0] == WLAN_ACTION_PUBLIC) { 935 /* 936 * Public Action frames to a STA that is not a member of the BSS 937 * shall use wildcard BSSID value. 938 */ 939 sta = ap_get_sta(hapd, dst); 940 if (!sta || !(sta->flags & WLAN_STA_ASSOC)) 941 bssid = wildcard_bssid; 942 } else if (!addr3_ap && is_broadcast_ether_addr(dst) && 943 len > 0 && data[0] == WLAN_ACTION_PUBLIC) { 944 /* 945 * The only current use case of Public Action frames with 946 * broadcast destination address is DPP PKEX. That case is 947 * directing all devices and not just the STAs within the BSS, 948 * so have to use the wildcard BSSID value. 949 */ 950 bssid = wildcard_bssid; 951 #ifdef CONFIG_IEEE80211BE 952 } else if (hapd->conf->mld_ap) { 953 sta = ap_get_sta(hapd, dst); 954 955 if (ap_sta_is_mld(hapd, sta)) { 956 own_addr = hapd->mld->mld_addr; 957 bssid = own_addr; 958 } 959 #endif /* CONFIG_IEEE80211BE */ 960 } 961 962 return hapd->driver->send_action(hapd->drv_priv, freq, wait, dst, 963 own_addr, bssid, data, len, 0); 964 } 965 966 967 int hostapd_drv_send_action(struct hostapd_data *hapd, unsigned int freq, 968 unsigned int wait, const u8 *dst, const u8 *data, 969 size_t len) 970 { 971 return hapd_drv_send_action(hapd, freq, wait, dst, data, len, false); 972 } 973 974 975 int hostapd_drv_send_action_addr3_ap(struct hostapd_data *hapd, 976 unsigned int freq, 977 unsigned int wait, const u8 *dst, 978 const u8 *data, size_t len) 979 { 980 return hapd_drv_send_action(hapd, freq, wait, dst, data, len, true); 981 } 982 983 984 int hostapd_start_dfs_cac(struct hostapd_iface *iface, 985 enum hostapd_hw_mode mode, int freq, 986 int channel, int ht_enabled, int vht_enabled, 987 int he_enabled, bool eht_enabled, 988 int sec_channel_offset, int oper_chwidth, 989 int center_segment0, int center_segment1, 990 bool radar_background) 991 { 992 struct hostapd_data *hapd = iface->bss[0]; 993 struct hostapd_freq_params data; 994 int res; 995 struct hostapd_hw_modes *cmode = iface->current_mode; 996 997 if (!hapd->driver || !hapd->driver->start_dfs_cac || !cmode) 998 return 0; 999 1000 if (!iface->conf->ieee80211h) { 1001 wpa_printf(MSG_ERROR, "Can't start DFS CAC, DFS functionality " 1002 "is not enabled"); 1003 return -1; 1004 } 1005 1006 if (hostapd_set_freq_params(&data, mode, freq, channel, 0, 0, 1007 ht_enabled, 1008 vht_enabled, he_enabled, eht_enabled, 1009 sec_channel_offset, 1010 oper_chwidth, center_segment0, 1011 center_segment1, 1012 cmode->vht_capab, 1013 &cmode->he_capab[IEEE80211_MODE_AP], 1014 &cmode->eht_capab[IEEE80211_MODE_AP], 1015 hostapd_get_punct_bitmap(hapd))) { 1016 wpa_printf(MSG_ERROR, "Can't set freq params"); 1017 return -1; 1018 } 1019 data.radar_background = radar_background; 1020 1021 res = hapd->driver->start_dfs_cac(hapd->drv_priv, &data); 1022 if (!res) { 1023 if (radar_background) 1024 iface->radar_background.cac_started = 1; 1025 else 1026 iface->cac_started = 1; 1027 os_get_reltime(&iface->dfs_cac_start); 1028 } 1029 1030 return res; 1031 } 1032 1033 1034 int hostapd_drv_set_qos_map(struct hostapd_data *hapd, 1035 const u8 *qos_map_set, u8 qos_map_set_len) 1036 { 1037 if (!hapd->driver || !hapd->driver->set_qos_map || !hapd->drv_priv || 1038 !(hapd->iface->drv_flags & WPA_DRIVER_FLAGS_QOS_MAPPING)) 1039 return 0; 1040 return hapd->driver->set_qos_map(hapd->drv_priv, qos_map_set, 1041 qos_map_set_len); 1042 } 1043 1044 1045 void hostapd_get_hw_mode_any_channels(struct hostapd_data *hapd, 1046 struct hostapd_hw_modes *mode, 1047 int acs_ch_list_all, bool allow_disabled, 1048 int **freq_list) 1049 { 1050 int i; 1051 bool is_no_ir = false; 1052 1053 for (i = 0; i < mode->num_channels; i++) { 1054 struct hostapd_channel_data *chan = &mode->channels[i]; 1055 1056 if (!acs_ch_list_all && 1057 (hapd->iface->conf->acs_freq_list.num && 1058 !freq_range_list_includes( 1059 &hapd->iface->conf->acs_freq_list, 1060 chan->freq))) 1061 continue; 1062 if (!acs_ch_list_all && 1063 (!hapd->iface->conf->acs_freq_list_present && 1064 hapd->iface->conf->acs_ch_list.num && 1065 !freq_range_list_includes( 1066 &hapd->iface->conf->acs_ch_list, 1067 chan->chan))) 1068 continue; 1069 if (is_6ghz_freq(chan->freq) && 1070 ((hapd->iface->conf->acs_exclude_6ghz_non_psc && 1071 !is_6ghz_psc_frequency(chan->freq)) || 1072 (!hapd->iface->conf->ieee80211ax && 1073 !hapd->iface->conf->ieee80211be))) 1074 continue; 1075 if ((!(chan->flag & HOSTAPD_CHAN_DISABLED) || allow_disabled) && 1076 !(hapd->iface->conf->acs_exclude_dfs && 1077 (chan->flag & HOSTAPD_CHAN_RADAR)) && 1078 !(chan->max_tx_power < hapd->iface->conf->min_tx_power)) 1079 int_array_add_unique(freq_list, chan->freq); 1080 else if ((chan->flag & HOSTAPD_CHAN_NO_IR) && 1081 is_6ghz_freq(chan->freq)) 1082 is_no_ir = true; 1083 } 1084 1085 hapd->iface->is_no_ir = is_no_ir; 1086 } 1087 1088 1089 void hostapd_get_ext_capa(struct hostapd_iface *iface) 1090 { 1091 struct hostapd_data *hapd = iface->bss[0]; 1092 1093 if (!hapd->driver || !hapd->driver->get_ext_capab) 1094 return; 1095 1096 hapd->driver->get_ext_capab(hapd->drv_priv, WPA_IF_AP_BSS, 1097 &iface->extended_capa, 1098 &iface->extended_capa_mask, 1099 &iface->extended_capa_len); 1100 } 1101 1102 1103 void hostapd_get_mld_capa(struct hostapd_iface *iface) 1104 { 1105 struct hostapd_data *hapd = iface->bss[0]; 1106 1107 if (!hapd->driver || !hapd->driver->get_mld_capab) 1108 return; 1109 1110 hapd->driver->get_mld_capab(hapd->drv_priv, WPA_IF_AP_BSS, 1111 &iface->mld_eml_capa, 1112 &iface->mld_mld_capa); 1113 } 1114 1115 1116 /** 1117 * hostapd_drv_do_acs - Start automatic channel selection 1118 * @hapd: BSS data for the device initiating ACS 1119 * Returns: 0 on success, -1 on failure, 1 on failure due to NO_IR (AFC) 1120 */ 1121 int hostapd_drv_do_acs(struct hostapd_data *hapd) 1122 { 1123 struct drv_acs_params params; 1124 int ret, i, acs_ch_list_all = 0; 1125 struct hostapd_hw_modes *mode; 1126 int *freq_list = NULL; 1127 enum hostapd_hw_mode selected_mode; 1128 1129 if (hapd->driver == NULL || hapd->driver->do_acs == NULL) 1130 return 0; 1131 1132 os_memset(¶ms, 0, sizeof(params)); 1133 params.hw_mode = hapd->iface->conf->hw_mode; 1134 params.link_id = -1; 1135 #ifdef CONFIG_IEEE80211BE 1136 if (hapd->conf->mld_ap && hapd->iconf->ieee80211be && 1137 !hapd->conf->disable_11be) 1138 params.link_id = hapd->mld_link_id; 1139 #endif /* CONFIG_IEEE80211BE */ 1140 1141 /* 1142 * If no chanlist config parameter is provided, include all enabled 1143 * channels of the selected hw_mode. 1144 */ 1145 if (hapd->iface->conf->acs_freq_list_present) 1146 acs_ch_list_all = !hapd->iface->conf->acs_freq_list.num; 1147 else 1148 acs_ch_list_all = !hapd->iface->conf->acs_ch_list.num; 1149 1150 if (hapd->iface->current_mode) 1151 selected_mode = hapd->iface->current_mode->mode; 1152 else 1153 selected_mode = HOSTAPD_MODE_IEEE80211ANY; 1154 1155 for (i = 0; i < hapd->iface->num_hw_features; i++) { 1156 mode = &hapd->iface->hw_features[i]; 1157 if (selected_mode != HOSTAPD_MODE_IEEE80211ANY && 1158 selected_mode != mode->mode) 1159 continue; 1160 hostapd_get_hw_mode_any_channels(hapd, mode, acs_ch_list_all, 1161 false, &freq_list); 1162 } 1163 1164 if (!freq_list && hapd->iface->is_no_ir) { 1165 wpa_printf(MSG_ERROR, 1166 "NO_IR: Interface freq_list is empty. Failing do_acs."); 1167 return 1; 1168 } 1169 1170 params.freq_list = freq_list; 1171 params.edmg_enabled = hapd->iface->conf->enable_edmg; 1172 1173 params.ht_enabled = !!(hapd->iface->conf->ieee80211n); 1174 params.ht40_enabled = !!(hapd->iface->conf->ht_capab & 1175 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET); 1176 params.vht_enabled = !!(hapd->iface->conf->ieee80211ac); 1177 params.eht_enabled = !!(hapd->iface->conf->ieee80211be); 1178 params.ch_width = 20; 1179 if (hapd->iface->conf->ieee80211n && params.ht40_enabled) 1180 params.ch_width = 40; 1181 1182 /* Note: VHT20 is defined by combination of ht_capab & oper_chwidth 1183 */ 1184 if ((hapd->iface->conf->ieee80211be || 1185 hapd->iface->conf->ieee80211ax || 1186 hapd->iface->conf->ieee80211ac) && 1187 params.ht40_enabled) { 1188 enum oper_chan_width oper_chwidth; 1189 1190 oper_chwidth = hostapd_get_oper_chwidth(hapd->iface->conf); 1191 if (oper_chwidth == CONF_OPER_CHWIDTH_80MHZ) 1192 params.ch_width = 80; 1193 else if (oper_chwidth == CONF_OPER_CHWIDTH_160MHZ || 1194 oper_chwidth == CONF_OPER_CHWIDTH_80P80MHZ) 1195 params.ch_width = 160; 1196 else if (oper_chwidth == CONF_OPER_CHWIDTH_320MHZ) 1197 params.ch_width = 320; 1198 } 1199 1200 if (hapd->iface->conf->op_class) 1201 params.ch_width = op_class_to_bandwidth( 1202 hapd->iface->conf->op_class); 1203 ret = hapd->driver->do_acs(hapd->drv_priv, ¶ms); 1204 os_free(freq_list); 1205 1206 return ret; 1207 } 1208 1209 1210 int hostapd_drv_update_dh_ie(struct hostapd_data *hapd, const u8 *peer, 1211 u16 reason_code, const u8 *ie, size_t ielen) 1212 { 1213 if (!hapd->driver || !hapd->driver->update_dh_ie || !hapd->drv_priv) 1214 return 0; 1215 return hapd->driver->update_dh_ie(hapd->drv_priv, peer, reason_code, 1216 ie, ielen); 1217 } 1218 1219 1220 int hostapd_drv_dpp_listen(struct hostapd_data *hapd, bool enable) 1221 { 1222 if (!hapd->driver || !hapd->driver->dpp_listen || !hapd->drv_priv) 1223 return 0; 1224 return hapd->driver->dpp_listen(hapd->drv_priv, enable); 1225 } 1226 1227 1228 #ifdef CONFIG_PASN 1229 int hostapd_drv_set_secure_ranging_ctx(struct hostapd_data *hapd, 1230 const u8 *own_addr, const u8 *peer_addr, 1231 u32 cipher, u8 tk_len, const u8 *tk, 1232 u8 ltf_keyseed_len, 1233 const u8 *ltf_keyseed, u32 action) 1234 { 1235 struct secure_ranging_params params; 1236 1237 if (!hapd->driver || !hapd->driver->set_secure_ranging_ctx) 1238 return 0; 1239 1240 os_memset(¶ms, 0, sizeof(params)); 1241 params.own_addr = own_addr; 1242 params.peer_addr = peer_addr; 1243 params.cipher = cipher; 1244 params.tk_len = tk_len; 1245 params.tk = tk; 1246 params.ltf_keyseed_len = ltf_keyseed_len; 1247 params.ltf_keyseed = ltf_keyseed; 1248 params.action = action; 1249 1250 return hapd->driver->set_secure_ranging_ctx(hapd->drv_priv, ¶ms); 1251 } 1252 #endif /* CONFIG_PASN */ 1253