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/hw_features_common.h" 14 #include "wps/wps.h" 15 #include "p2p/p2p.h" 16 #include "hostapd.h" 17 #include "ieee802_11.h" 18 #include "sta_info.h" 19 #include "ap_config.h" 20 #include "p2p_hostapd.h" 21 #include "hs20.h" 22 #include "ap_drv_ops.h" 23 24 25 u32 hostapd_sta_flags_to_drv(u32 flags) 26 { 27 int res = 0; 28 if (flags & WLAN_STA_AUTHORIZED) 29 res |= WPA_STA_AUTHORIZED; 30 if (flags & WLAN_STA_WMM) 31 res |= WPA_STA_WMM; 32 if (flags & WLAN_STA_SHORT_PREAMBLE) 33 res |= WPA_STA_SHORT_PREAMBLE; 34 if (flags & WLAN_STA_MFP) 35 res |= WPA_STA_MFP; 36 if (flags & WLAN_STA_AUTH) 37 res |= WPA_STA_AUTHENTICATED; 38 if (flags & WLAN_STA_ASSOC) 39 res |= WPA_STA_ASSOCIATED; 40 return res; 41 } 42 43 44 static int add_buf(struct wpabuf **dst, const struct wpabuf *src) 45 { 46 if (!src) 47 return 0; 48 if (wpabuf_resize(dst, wpabuf_len(src)) != 0) 49 return -1; 50 wpabuf_put_buf(*dst, src); 51 return 0; 52 } 53 54 55 static int add_buf_data(struct wpabuf **dst, const u8 *data, size_t len) 56 { 57 if (!data || !len) 58 return 0; 59 if (wpabuf_resize(dst, len) != 0) 60 return -1; 61 wpabuf_put_data(*dst, data, len); 62 return 0; 63 } 64 65 66 int hostapd_build_ap_extra_ies(struct hostapd_data *hapd, 67 struct wpabuf **beacon_ret, 68 struct wpabuf **proberesp_ret, 69 struct wpabuf **assocresp_ret) 70 { 71 struct wpabuf *beacon = NULL, *proberesp = NULL, *assocresp = NULL; 72 u8 buf[200], *pos; 73 74 *beacon_ret = *proberesp_ret = *assocresp_ret = NULL; 75 76 pos = buf; 77 pos = hostapd_eid_time_adv(hapd, pos); 78 if (add_buf_data(&beacon, buf, pos - buf) < 0) 79 goto fail; 80 pos = hostapd_eid_time_zone(hapd, pos); 81 if (add_buf_data(&proberesp, buf, pos - buf) < 0) 82 goto fail; 83 84 pos = buf; 85 pos = hostapd_eid_ext_capab(hapd, pos); 86 if (add_buf_data(&assocresp, buf, pos - buf) < 0) 87 goto fail; 88 pos = hostapd_eid_interworking(hapd, pos); 89 pos = hostapd_eid_adv_proto(hapd, pos); 90 pos = hostapd_eid_roaming_consortium(hapd, pos); 91 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 92 add_buf_data(&proberesp, buf, pos - buf) < 0) 93 goto fail; 94 95 #ifdef CONFIG_FST 96 if (add_buf(&beacon, hapd->iface->fst_ies) < 0 || 97 add_buf(&proberesp, hapd->iface->fst_ies) < 0 || 98 add_buf(&assocresp, hapd->iface->fst_ies) < 0) 99 goto fail; 100 #endif /* CONFIG_FST */ 101 102 if (add_buf(&beacon, hapd->wps_beacon_ie) < 0 || 103 add_buf(&proberesp, hapd->wps_probe_resp_ie) < 0) 104 goto fail; 105 106 #ifdef CONFIG_P2P 107 if (add_buf(&beacon, hapd->p2p_beacon_ie) < 0 || 108 add_buf(&proberesp, hapd->p2p_probe_resp_ie) < 0) 109 goto fail; 110 #endif /* CONFIG_P2P */ 111 112 #ifdef CONFIG_P2P_MANAGER 113 if (hapd->conf->p2p & P2P_MANAGE) { 114 if (wpabuf_resize(&beacon, 100) == 0) { 115 u8 *start, *p; 116 start = wpabuf_put(beacon, 0); 117 p = hostapd_eid_p2p_manage(hapd, start); 118 wpabuf_put(beacon, p - start); 119 } 120 121 if (wpabuf_resize(&proberesp, 100) == 0) { 122 u8 *start, *p; 123 start = wpabuf_put(proberesp, 0); 124 p = hostapd_eid_p2p_manage(hapd, start); 125 wpabuf_put(proberesp, p - start); 126 } 127 } 128 #endif /* CONFIG_P2P_MANAGER */ 129 130 #ifdef CONFIG_WPS 131 if (hapd->conf->wps_state) { 132 struct wpabuf *a = wps_build_assoc_resp_ie(); 133 add_buf(&assocresp, a); 134 wpabuf_free(a); 135 } 136 #endif /* CONFIG_WPS */ 137 138 #ifdef CONFIG_P2P_MANAGER 139 if (hapd->conf->p2p & P2P_MANAGE) { 140 if (wpabuf_resize(&assocresp, 100) == 0) { 141 u8 *start, *p; 142 start = wpabuf_put(assocresp, 0); 143 p = hostapd_eid_p2p_manage(hapd, start); 144 wpabuf_put(assocresp, p - start); 145 } 146 } 147 #endif /* CONFIG_P2P_MANAGER */ 148 149 #ifdef CONFIG_WIFI_DISPLAY 150 if (hapd->p2p_group) { 151 struct wpabuf *a; 152 a = p2p_group_assoc_resp_ie(hapd->p2p_group, P2P_SC_SUCCESS); 153 add_buf(&assocresp, a); 154 wpabuf_free(a); 155 } 156 #endif /* CONFIG_WIFI_DISPLAY */ 157 158 #ifdef CONFIG_HS20 159 pos = hostapd_eid_hs20_indication(hapd, buf); 160 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 161 add_buf_data(&proberesp, buf, pos - buf) < 0) 162 goto fail; 163 164 pos = hostapd_eid_osen(hapd, buf); 165 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 166 add_buf_data(&proberesp, buf, pos - buf) < 0) 167 goto fail; 168 #endif /* CONFIG_HS20 */ 169 170 #ifdef CONFIG_MBO 171 if (hapd->conf->mbo_enabled) { 172 pos = hostapd_eid_mbo(hapd, buf, sizeof(buf)); 173 if (add_buf_data(&beacon, buf, pos - buf) < 0 || 174 add_buf_data(&proberesp, buf, pos - buf) < 0 || 175 add_buf_data(&assocresp, buf, pos - buf) < 0) 176 goto fail; 177 } 178 #endif /* CONFIG_MBO */ 179 180 add_buf(&beacon, hapd->conf->vendor_elements); 181 add_buf(&proberesp, hapd->conf->vendor_elements); 182 add_buf(&assocresp, hapd->conf->assocresp_elements); 183 184 *beacon_ret = beacon; 185 *proberesp_ret = proberesp; 186 *assocresp_ret = assocresp; 187 188 return 0; 189 190 fail: 191 wpabuf_free(beacon); 192 wpabuf_free(proberesp); 193 wpabuf_free(assocresp); 194 return -1; 195 } 196 197 198 void hostapd_free_ap_extra_ies(struct hostapd_data *hapd, 199 struct wpabuf *beacon, 200 struct wpabuf *proberesp, 201 struct wpabuf *assocresp) 202 { 203 wpabuf_free(beacon); 204 wpabuf_free(proberesp); 205 wpabuf_free(assocresp); 206 } 207 208 209 int hostapd_reset_ap_wps_ie(struct hostapd_data *hapd) 210 { 211 if (hapd->driver == NULL || hapd->driver->set_ap_wps_ie == NULL) 212 return 0; 213 214 return hapd->driver->set_ap_wps_ie(hapd->drv_priv, NULL, NULL, NULL); 215 } 216 217 218 int hostapd_set_ap_wps_ie(struct hostapd_data *hapd) 219 { 220 struct wpabuf *beacon, *proberesp, *assocresp; 221 int ret; 222 223 if (hapd->driver == NULL || hapd->driver->set_ap_wps_ie == NULL) 224 return 0; 225 226 if (hostapd_build_ap_extra_ies(hapd, &beacon, &proberesp, &assocresp) < 227 0) 228 return -1; 229 230 ret = hapd->driver->set_ap_wps_ie(hapd->drv_priv, beacon, proberesp, 231 assocresp); 232 233 hostapd_free_ap_extra_ies(hapd, beacon, proberesp, assocresp); 234 235 return ret; 236 } 237 238 239 int hostapd_set_authorized(struct hostapd_data *hapd, 240 struct sta_info *sta, int authorized) 241 { 242 if (authorized) { 243 return hostapd_sta_set_flags(hapd, sta->addr, 244 hostapd_sta_flags_to_drv( 245 sta->flags), 246 WPA_STA_AUTHORIZED, ~0); 247 } 248 249 return hostapd_sta_set_flags(hapd, sta->addr, 250 hostapd_sta_flags_to_drv(sta->flags), 251 0, ~WPA_STA_AUTHORIZED); 252 } 253 254 255 int hostapd_set_sta_flags(struct hostapd_data *hapd, struct sta_info *sta) 256 { 257 int set_flags, total_flags, flags_and, flags_or; 258 total_flags = hostapd_sta_flags_to_drv(sta->flags); 259 set_flags = WPA_STA_SHORT_PREAMBLE | WPA_STA_WMM | WPA_STA_MFP; 260 if (((!hapd->conf->ieee802_1x && !hapd->conf->wpa) || 261 sta->auth_alg == WLAN_AUTH_FT) && 262 sta->flags & WLAN_STA_AUTHORIZED) 263 set_flags |= WPA_STA_AUTHORIZED; 264 flags_or = total_flags & set_flags; 265 flags_and = total_flags | ~set_flags; 266 return hostapd_sta_set_flags(hapd, sta->addr, total_flags, 267 flags_or, flags_and); 268 } 269 270 271 int hostapd_set_drv_ieee8021x(struct hostapd_data *hapd, const char *ifname, 272 int enabled) 273 { 274 struct wpa_bss_params params; 275 os_memset(¶ms, 0, sizeof(params)); 276 params.ifname = ifname; 277 params.enabled = enabled; 278 if (enabled) { 279 params.wpa = hapd->conf->wpa; 280 params.ieee802_1x = hapd->conf->ieee802_1x; 281 params.wpa_group = hapd->conf->wpa_group; 282 if ((hapd->conf->wpa & (WPA_PROTO_WPA | WPA_PROTO_RSN)) == 283 (WPA_PROTO_WPA | WPA_PROTO_RSN)) 284 params.wpa_pairwise = hapd->conf->wpa_pairwise | 285 hapd->conf->rsn_pairwise; 286 else if (hapd->conf->wpa & WPA_PROTO_RSN) 287 params.wpa_pairwise = hapd->conf->rsn_pairwise; 288 else if (hapd->conf->wpa & WPA_PROTO_WPA) 289 params.wpa_pairwise = hapd->conf->wpa_pairwise; 290 params.wpa_key_mgmt = hapd->conf->wpa_key_mgmt; 291 params.rsn_preauth = hapd->conf->rsn_preauth; 292 #ifdef CONFIG_IEEE80211W 293 params.ieee80211w = hapd->conf->ieee80211w; 294 #endif /* CONFIG_IEEE80211W */ 295 } 296 return hostapd_set_ieee8021x(hapd, ¶ms); 297 } 298 299 300 int hostapd_vlan_if_add(struct hostapd_data *hapd, const char *ifname) 301 { 302 char force_ifname[IFNAMSIZ]; 303 u8 if_addr[ETH_ALEN]; 304 return hostapd_if_add(hapd, WPA_IF_AP_VLAN, ifname, hapd->own_addr, 305 NULL, NULL, force_ifname, if_addr, NULL, 0); 306 } 307 308 309 int hostapd_vlan_if_remove(struct hostapd_data *hapd, const char *ifname) 310 { 311 return hostapd_if_remove(hapd, WPA_IF_AP_VLAN, ifname); 312 } 313 314 315 int hostapd_set_wds_sta(struct hostapd_data *hapd, char *ifname_wds, 316 const u8 *addr, int aid, int val) 317 { 318 const char *bridge = NULL; 319 320 if (hapd->driver == NULL || hapd->driver->set_wds_sta == NULL) 321 return -1; 322 if (hapd->conf->wds_bridge[0]) 323 bridge = hapd->conf->wds_bridge; 324 else if (hapd->conf->bridge[0]) 325 bridge = hapd->conf->bridge; 326 return hapd->driver->set_wds_sta(hapd->drv_priv, addr, aid, val, 327 bridge, ifname_wds); 328 } 329 330 331 int hostapd_add_sta_node(struct hostapd_data *hapd, const u8 *addr, 332 u16 auth_alg) 333 { 334 if (hapd->driver == NULL || hapd->driver->add_sta_node == NULL) 335 return 0; 336 return hapd->driver->add_sta_node(hapd->drv_priv, addr, auth_alg); 337 } 338 339 340 int hostapd_sta_auth(struct hostapd_data *hapd, const u8 *addr, 341 u16 seq, u16 status, const u8 *ie, size_t len) 342 { 343 if (hapd->driver == NULL || hapd->driver->sta_auth == NULL) 344 return 0; 345 return hapd->driver->sta_auth(hapd->drv_priv, hapd->own_addr, addr, 346 seq, status, ie, len); 347 } 348 349 350 int hostapd_sta_assoc(struct hostapd_data *hapd, const u8 *addr, 351 int reassoc, u16 status, const u8 *ie, size_t len) 352 { 353 if (hapd->driver == NULL || hapd->driver->sta_assoc == NULL) 354 return 0; 355 return hapd->driver->sta_assoc(hapd->drv_priv, hapd->own_addr, addr, 356 reassoc, status, ie, len); 357 } 358 359 360 int hostapd_sta_add(struct hostapd_data *hapd, 361 const u8 *addr, u16 aid, u16 capability, 362 const u8 *supp_rates, size_t supp_rates_len, 363 u16 listen_interval, 364 const struct ieee80211_ht_capabilities *ht_capab, 365 const struct ieee80211_vht_capabilities *vht_capab, 366 u32 flags, u8 qosinfo, u8 vht_opmode, int supp_p2p_ps, 367 int set) 368 { 369 struct hostapd_sta_add_params params; 370 371 if (hapd->driver == NULL) 372 return 0; 373 if (hapd->driver->sta_add == NULL) 374 return 0; 375 376 os_memset(¶ms, 0, sizeof(params)); 377 params.addr = addr; 378 params.aid = aid; 379 params.capability = capability; 380 params.supp_rates = supp_rates; 381 params.supp_rates_len = supp_rates_len; 382 params.listen_interval = listen_interval; 383 params.ht_capabilities = ht_capab; 384 params.vht_capabilities = vht_capab; 385 params.vht_opmode_enabled = !!(flags & WLAN_STA_VHT_OPMODE_ENABLED); 386 params.vht_opmode = vht_opmode; 387 params.flags = hostapd_sta_flags_to_drv(flags); 388 params.qosinfo = qosinfo; 389 params.support_p2p_ps = supp_p2p_ps; 390 params.set = set; 391 return hapd->driver->sta_add(hapd->drv_priv, ¶ms); 392 } 393 394 395 int hostapd_add_tspec(struct hostapd_data *hapd, const u8 *addr, 396 u8 *tspec_ie, size_t tspec_ielen) 397 { 398 if (hapd->driver == NULL || hapd->driver->add_tspec == NULL) 399 return 0; 400 return hapd->driver->add_tspec(hapd->drv_priv, addr, tspec_ie, 401 tspec_ielen); 402 } 403 404 405 int hostapd_set_privacy(struct hostapd_data *hapd, int enabled) 406 { 407 if (hapd->driver == NULL || hapd->driver->set_privacy == NULL) 408 return 0; 409 return hapd->driver->set_privacy(hapd->drv_priv, enabled); 410 } 411 412 413 int hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem, 414 size_t elem_len) 415 { 416 if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL) 417 return 0; 418 return hapd->driver->set_generic_elem(hapd->drv_priv, elem, elem_len); 419 } 420 421 422 int hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len) 423 { 424 if (hapd->driver == NULL || hapd->driver->hapd_get_ssid == NULL) 425 return 0; 426 return hapd->driver->hapd_get_ssid(hapd->drv_priv, buf, len); 427 } 428 429 430 int hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len) 431 { 432 if (hapd->driver == NULL || hapd->driver->hapd_set_ssid == NULL) 433 return 0; 434 return hapd->driver->hapd_set_ssid(hapd->drv_priv, buf, len); 435 } 436 437 438 int hostapd_if_add(struct hostapd_data *hapd, enum wpa_driver_if_type type, 439 const char *ifname, const u8 *addr, void *bss_ctx, 440 void **drv_priv, char *force_ifname, u8 *if_addr, 441 const char *bridge, int use_existing) 442 { 443 if (hapd->driver == NULL || hapd->driver->if_add == NULL) 444 return -1; 445 return hapd->driver->if_add(hapd->drv_priv, type, ifname, addr, 446 bss_ctx, drv_priv, force_ifname, if_addr, 447 bridge, use_existing, 1); 448 } 449 450 451 int hostapd_if_remove(struct hostapd_data *hapd, enum wpa_driver_if_type type, 452 const char *ifname) 453 { 454 if (hapd->driver == NULL || hapd->drv_priv == NULL || 455 hapd->driver->if_remove == NULL) 456 return -1; 457 return hapd->driver->if_remove(hapd->drv_priv, type, ifname); 458 } 459 460 461 int hostapd_set_ieee8021x(struct hostapd_data *hapd, 462 struct wpa_bss_params *params) 463 { 464 if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL) 465 return 0; 466 return hapd->driver->set_ieee8021x(hapd->drv_priv, params); 467 } 468 469 470 int hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd, 471 const u8 *addr, int idx, u8 *seq) 472 { 473 if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL) 474 return 0; 475 return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx, 476 seq); 477 } 478 479 480 int hostapd_flush(struct hostapd_data *hapd) 481 { 482 if (hapd->driver == NULL || hapd->driver->flush == NULL) 483 return 0; 484 return hapd->driver->flush(hapd->drv_priv); 485 } 486 487 488 int hostapd_set_freq(struct hostapd_data *hapd, enum hostapd_hw_mode mode, 489 int freq, int channel, int ht_enabled, int vht_enabled, 490 int sec_channel_offset, int vht_oper_chwidth, 491 int center_segment0, int center_segment1) 492 { 493 struct hostapd_freq_params data; 494 495 if (hapd->iface->current_mode && 496 hostapd_set_freq_params(&data, mode, freq, channel, ht_enabled, 497 vht_enabled, sec_channel_offset, 498 vht_oper_chwidth, 499 center_segment0, center_segment1, 500 hapd->iface->current_mode ? 501 hapd->iface->current_mode->vht_capab : 0)) 502 return -1; 503 504 if (hapd->driver == NULL) 505 return 0; 506 if (hapd->driver->set_freq == NULL) 507 return 0; 508 return hapd->driver->set_freq(hapd->drv_priv, &data); 509 } 510 511 int hostapd_set_rts(struct hostapd_data *hapd, int rts) 512 { 513 if (hapd->driver == NULL || hapd->driver->set_rts == NULL) 514 return 0; 515 return hapd->driver->set_rts(hapd->drv_priv, rts); 516 } 517 518 519 int hostapd_set_frag(struct hostapd_data *hapd, int frag) 520 { 521 if (hapd->driver == NULL || hapd->driver->set_frag == NULL) 522 return 0; 523 return hapd->driver->set_frag(hapd->drv_priv, frag); 524 } 525 526 527 int hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr, 528 int total_flags, int flags_or, int flags_and) 529 { 530 if (hapd->driver == NULL || hapd->driver->sta_set_flags == NULL) 531 return 0; 532 return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags, 533 flags_or, flags_and); 534 } 535 536 537 int hostapd_set_country(struct hostapd_data *hapd, const char *country) 538 { 539 if (hapd->driver == NULL || 540 hapd->driver->set_country == NULL) 541 return 0; 542 return hapd->driver->set_country(hapd->drv_priv, country); 543 } 544 545 546 int hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs, 547 int cw_min, int cw_max, int burst_time) 548 { 549 if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL) 550 return 0; 551 return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs, 552 cw_min, cw_max, burst_time); 553 } 554 555 556 struct hostapd_hw_modes * 557 hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes, 558 u16 *flags) 559 { 560 if (hapd->driver == NULL || 561 hapd->driver->get_hw_feature_data == NULL) 562 return NULL; 563 return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes, 564 flags); 565 } 566 567 568 int hostapd_driver_commit(struct hostapd_data *hapd) 569 { 570 if (hapd->driver == NULL || hapd->driver->commit == NULL) 571 return 0; 572 return hapd->driver->commit(hapd->drv_priv); 573 } 574 575 576 int hostapd_drv_none(struct hostapd_data *hapd) 577 { 578 return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0; 579 } 580 581 582 int hostapd_driver_scan(struct hostapd_data *hapd, 583 struct wpa_driver_scan_params *params) 584 { 585 if (hapd->driver && hapd->driver->scan2) 586 return hapd->driver->scan2(hapd->drv_priv, params); 587 return -1; 588 } 589 590 591 struct wpa_scan_results * hostapd_driver_get_scan_results( 592 struct hostapd_data *hapd) 593 { 594 if (hapd->driver && hapd->driver->get_scan_results2) 595 return hapd->driver->get_scan_results2(hapd->drv_priv); 596 return NULL; 597 } 598 599 600 int hostapd_driver_set_noa(struct hostapd_data *hapd, u8 count, int start, 601 int duration) 602 { 603 if (hapd->driver && hapd->driver->set_noa) 604 return hapd->driver->set_noa(hapd->drv_priv, count, start, 605 duration); 606 return -1; 607 } 608 609 610 int hostapd_drv_set_key(const char *ifname, struct hostapd_data *hapd, 611 enum wpa_alg alg, const u8 *addr, 612 int key_idx, int set_tx, 613 const u8 *seq, size_t seq_len, 614 const u8 *key, size_t key_len) 615 { 616 if (hapd->driver == NULL || hapd->driver->set_key == NULL) 617 return 0; 618 return hapd->driver->set_key(ifname, hapd->drv_priv, alg, addr, 619 key_idx, set_tx, seq, seq_len, key, 620 key_len); 621 } 622 623 624 int hostapd_drv_send_mlme(struct hostapd_data *hapd, 625 const void *msg, size_t len, int noack) 626 { 627 if (!hapd->driver || !hapd->driver->send_mlme || !hapd->drv_priv) 628 return 0; 629 return hapd->driver->send_mlme(hapd->drv_priv, msg, len, noack, 0, 630 NULL, 0); 631 } 632 633 634 int hostapd_drv_send_mlme_csa(struct hostapd_data *hapd, 635 const void *msg, size_t len, int noack, 636 const u16 *csa_offs, size_t csa_offs_len) 637 { 638 if (hapd->driver == NULL || hapd->driver->send_mlme == NULL) 639 return 0; 640 return hapd->driver->send_mlme(hapd->drv_priv, msg, len, noack, 0, 641 csa_offs, csa_offs_len); 642 } 643 644 645 int hostapd_drv_sta_deauth(struct hostapd_data *hapd, 646 const u8 *addr, int reason) 647 { 648 if (!hapd->driver || !hapd->driver->sta_deauth || !hapd->drv_priv) 649 return 0; 650 return hapd->driver->sta_deauth(hapd->drv_priv, hapd->own_addr, addr, 651 reason); 652 } 653 654 655 int hostapd_drv_sta_disassoc(struct hostapd_data *hapd, 656 const u8 *addr, int reason) 657 { 658 if (!hapd->driver || !hapd->driver->sta_disassoc || !hapd->drv_priv) 659 return 0; 660 return hapd->driver->sta_disassoc(hapd->drv_priv, hapd->own_addr, addr, 661 reason); 662 } 663 664 665 int hostapd_drv_wnm_oper(struct hostapd_data *hapd, enum wnm_oper oper, 666 const u8 *peer, u8 *buf, u16 *buf_len) 667 { 668 if (hapd->driver == NULL || hapd->driver->wnm_oper == NULL) 669 return -1; 670 return hapd->driver->wnm_oper(hapd->drv_priv, oper, peer, buf, 671 buf_len); 672 } 673 674 675 int hostapd_drv_send_action(struct hostapd_data *hapd, unsigned int freq, 676 unsigned int wait, const u8 *dst, const u8 *data, 677 size_t len) 678 { 679 const u8 *bssid; 680 const u8 wildcard_bssid[ETH_ALEN] = { 681 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 682 }; 683 684 if (!hapd->driver || !hapd->driver->send_action || !hapd->drv_priv) 685 return 0; 686 bssid = hapd->own_addr; 687 if (!is_multicast_ether_addr(dst) && 688 len > 0 && data[0] == WLAN_ACTION_PUBLIC) { 689 struct sta_info *sta; 690 691 /* 692 * Public Action frames to a STA that is not a member of the BSS 693 * shall use wildcard BSSID value. 694 */ 695 sta = ap_get_sta(hapd, dst); 696 if (!sta || !(sta->flags & WLAN_STA_ASSOC)) 697 bssid = wildcard_bssid; 698 } 699 return hapd->driver->send_action(hapd->drv_priv, freq, wait, dst, 700 hapd->own_addr, bssid, data, len, 0); 701 } 702 703 704 int hostapd_drv_send_action_addr3_ap(struct hostapd_data *hapd, 705 unsigned int freq, 706 unsigned int wait, const u8 *dst, 707 const u8 *data, size_t len) 708 { 709 if (hapd->driver == NULL || hapd->driver->send_action == NULL) 710 return 0; 711 return hapd->driver->send_action(hapd->drv_priv, freq, wait, dst, 712 hapd->own_addr, hapd->own_addr, data, 713 len, 0); 714 } 715 716 717 int hostapd_start_dfs_cac(struct hostapd_iface *iface, 718 enum hostapd_hw_mode mode, int freq, 719 int channel, int ht_enabled, int vht_enabled, 720 int sec_channel_offset, int vht_oper_chwidth, 721 int center_segment0, int center_segment1) 722 { 723 struct hostapd_data *hapd = iface->bss[0]; 724 struct hostapd_freq_params data; 725 int res; 726 727 if (!hapd->driver || !hapd->driver->start_dfs_cac) 728 return 0; 729 730 if (!iface->conf->ieee80211h) { 731 wpa_printf(MSG_ERROR, "Can't start DFS CAC, DFS functionality " 732 "is not enabled"); 733 return -1; 734 } 735 736 if (iface->current_mode && 737 hostapd_set_freq_params(&data, mode, freq, channel, ht_enabled, 738 vht_enabled, sec_channel_offset, 739 vht_oper_chwidth, center_segment0, 740 center_segment1, 741 iface->current_mode->vht_capab)) { 742 wpa_printf(MSG_ERROR, "Can't set freq params"); 743 return -1; 744 } 745 746 res = hapd->driver->start_dfs_cac(hapd->drv_priv, &data); 747 if (!res) { 748 iface->cac_started = 1; 749 os_get_reltime(&iface->dfs_cac_start); 750 } 751 752 return res; 753 } 754 755 756 int hostapd_drv_set_qos_map(struct hostapd_data *hapd, 757 const u8 *qos_map_set, u8 qos_map_set_len) 758 { 759 if (!hapd->driver || !hapd->driver->set_qos_map || !hapd->drv_priv) 760 return 0; 761 return hapd->driver->set_qos_map(hapd->drv_priv, qos_map_set, 762 qos_map_set_len); 763 } 764 765 766 static void hostapd_get_hw_mode_any_channels(struct hostapd_data *hapd, 767 struct hostapd_hw_modes *mode, 768 int acs_ch_list_all, 769 int **freq_list) 770 { 771 int i; 772 773 for (i = 0; i < mode->num_channels; i++) { 774 struct hostapd_channel_data *chan = &mode->channels[i]; 775 776 if ((acs_ch_list_all || 777 freq_range_list_includes(&hapd->iface->conf->acs_ch_list, 778 chan->chan)) && 779 !(chan->flag & HOSTAPD_CHAN_DISABLED)) 780 int_array_add_unique(freq_list, chan->freq); 781 } 782 } 783 784 785 void hostapd_get_ext_capa(struct hostapd_iface *iface) 786 { 787 struct hostapd_data *hapd = iface->bss[0]; 788 789 if (!hapd->driver || !hapd->driver->get_ext_capab) 790 return; 791 792 hapd->driver->get_ext_capab(hapd->drv_priv, WPA_IF_AP_BSS, 793 &iface->extended_capa, 794 &iface->extended_capa_mask, 795 &iface->extended_capa_len); 796 } 797 798 799 int hostapd_drv_do_acs(struct hostapd_data *hapd) 800 { 801 struct drv_acs_params params; 802 int ret, i, acs_ch_list_all = 0; 803 u8 *channels = NULL; 804 unsigned int num_channels = 0; 805 struct hostapd_hw_modes *mode; 806 int *freq_list = NULL; 807 808 if (hapd->driver == NULL || hapd->driver->do_acs == NULL) 809 return 0; 810 811 os_memset(¶ms, 0, sizeof(params)); 812 params.hw_mode = hapd->iface->conf->hw_mode; 813 814 /* 815 * If no chanlist config parameter is provided, include all enabled 816 * channels of the selected hw_mode. 817 */ 818 if (!hapd->iface->conf->acs_ch_list.num) 819 acs_ch_list_all = 1; 820 821 mode = hapd->iface->current_mode; 822 if (mode) { 823 channels = os_malloc(mode->num_channels); 824 if (channels == NULL) 825 return -1; 826 827 for (i = 0; i < mode->num_channels; i++) { 828 struct hostapd_channel_data *chan = &mode->channels[i]; 829 if (!acs_ch_list_all && 830 !freq_range_list_includes( 831 &hapd->iface->conf->acs_ch_list, 832 chan->chan)) 833 continue; 834 if (!(chan->flag & HOSTAPD_CHAN_DISABLED)) { 835 channels[num_channels++] = chan->chan; 836 int_array_add_unique(&freq_list, chan->freq); 837 } 838 } 839 } else { 840 for (i = 0; i < hapd->iface->num_hw_features; i++) { 841 mode = &hapd->iface->hw_features[i]; 842 hostapd_get_hw_mode_any_channels(hapd, mode, 843 acs_ch_list_all, 844 &freq_list); 845 } 846 } 847 848 params.ch_list = channels; 849 params.ch_list_len = num_channels; 850 params.freq_list = freq_list; 851 852 params.ht_enabled = !!(hapd->iface->conf->ieee80211n); 853 params.ht40_enabled = !!(hapd->iface->conf->ht_capab & 854 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET); 855 params.vht_enabled = !!(hapd->iface->conf->ieee80211ac); 856 params.ch_width = 20; 857 if (hapd->iface->conf->ieee80211n && params.ht40_enabled) 858 params.ch_width = 40; 859 860 /* Note: VHT20 is defined by combination of ht_capab & vht_oper_chwidth 861 */ 862 if (hapd->iface->conf->ieee80211ac && params.ht40_enabled) { 863 if (hapd->iface->conf->vht_oper_chwidth == VHT_CHANWIDTH_80MHZ) 864 params.ch_width = 80; 865 else if (hapd->iface->conf->vht_oper_chwidth == 866 VHT_CHANWIDTH_160MHZ || 867 hapd->iface->conf->vht_oper_chwidth == 868 VHT_CHANWIDTH_80P80MHZ) 869 params.ch_width = 160; 870 } 871 872 ret = hapd->driver->do_acs(hapd->drv_priv, ¶ms); 873 os_free(channels); 874 875 return ret; 876 } 877