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