1214501Srpaulo/* 2214501Srpaulo * hostapd - Driver operations 3214501Srpaulo * Copyright (c) 2009-2010, Jouni Malinen <j@w1.fi> 4214501Srpaulo * 5214501Srpaulo * This program is free software; you can redistribute it and/or modify 6214501Srpaulo * it under the terms of the GNU General Public License version 2 as 7214501Srpaulo * published by the Free Software Foundation. 8214501Srpaulo * 9214501Srpaulo * Alternatively, this software may be distributed under the terms of BSD 10214501Srpaulo * license. 11214501Srpaulo * 12214501Srpaulo * See README and COPYING for more details. 13214501Srpaulo */ 14214501Srpaulo 15214501Srpaulo#include "utils/includes.h" 16214501Srpaulo 17214501Srpaulo#include "utils/common.h" 18214501Srpaulo#include "drivers/driver.h" 19214501Srpaulo#include "common/ieee802_11_defs.h" 20214501Srpaulo#include "hostapd.h" 21214501Srpaulo#include "ieee802_11.h" 22214501Srpaulo#include "sta_info.h" 23214501Srpaulo#include "ap_config.h" 24214501Srpaulo#include "ap_drv_ops.h" 25214501Srpaulo 26214501Srpaulo 27214501Srpaulostatic int hostapd_sta_flags_to_drv(int flags) 28214501Srpaulo{ 29214501Srpaulo int res = 0; 30214501Srpaulo if (flags & WLAN_STA_AUTHORIZED) 31214501Srpaulo res |= WPA_STA_AUTHORIZED; 32214501Srpaulo if (flags & WLAN_STA_WMM) 33214501Srpaulo res |= WPA_STA_WMM; 34214501Srpaulo if (flags & WLAN_STA_SHORT_PREAMBLE) 35214501Srpaulo res |= WPA_STA_SHORT_PREAMBLE; 36214501Srpaulo if (flags & WLAN_STA_MFP) 37214501Srpaulo res |= WPA_STA_MFP; 38214501Srpaulo return res; 39214501Srpaulo} 40214501Srpaulo 41214501Srpaulo 42214501Srpaulostatic int hostapd_set_ap_wps_ie(struct hostapd_data *hapd) 43214501Srpaulo{ 44214501Srpaulo struct wpabuf *beacon, *proberesp; 45214501Srpaulo int ret; 46214501Srpaulo 47214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_ap_wps_ie == NULL) 48214501Srpaulo return 0; 49214501Srpaulo 50214501Srpaulo beacon = hapd->wps_beacon_ie; 51214501Srpaulo proberesp = hapd->wps_probe_resp_ie; 52214501Srpaulo 53214501Srpaulo ret = hapd->driver->set_ap_wps_ie(hapd->drv_priv, beacon, proberesp); 54214501Srpaulo 55214501Srpaulo return ret; 56214501Srpaulo} 57214501Srpaulo 58214501Srpaulo 59214501Srpaulostatic int hostapd_send_mgmt_frame(struct hostapd_data *hapd, const void *msg, 60214501Srpaulo size_t len) 61214501Srpaulo{ 62214501Srpaulo if (hapd->driver == NULL || hapd->driver->send_mlme == NULL) 63214501Srpaulo return 0; 64214501Srpaulo return hapd->driver->send_mlme(hapd->drv_priv, msg, len); 65214501Srpaulo} 66214501Srpaulo 67214501Srpaulo 68214501Srpaulostatic int hostapd_send_eapol(struct hostapd_data *hapd, const u8 *addr, 69214501Srpaulo const u8 *data, size_t data_len, int encrypt) 70214501Srpaulo{ 71214501Srpaulo if (hapd->driver == NULL || hapd->driver->hapd_send_eapol == NULL) 72214501Srpaulo return 0; 73214501Srpaulo return hapd->driver->hapd_send_eapol(hapd->drv_priv, addr, data, 74214501Srpaulo data_len, encrypt, 75214501Srpaulo hapd->own_addr); 76214501Srpaulo} 77214501Srpaulo 78214501Srpaulo 79214501Srpaulostatic int hostapd_set_authorized(struct hostapd_data *hapd, 80214501Srpaulo struct sta_info *sta, int authorized) 81214501Srpaulo{ 82214501Srpaulo if (authorized) { 83214501Srpaulo return hostapd_sta_set_flags(hapd, sta->addr, 84214501Srpaulo hostapd_sta_flags_to_drv( 85214501Srpaulo sta->flags), 86214501Srpaulo WPA_STA_AUTHORIZED, ~0); 87214501Srpaulo } 88214501Srpaulo 89214501Srpaulo return hostapd_sta_set_flags(hapd, sta->addr, 90214501Srpaulo hostapd_sta_flags_to_drv(sta->flags), 91214501Srpaulo 0, ~WPA_STA_AUTHORIZED); 92214501Srpaulo} 93214501Srpaulo 94214501Srpaulo 95214501Srpaulostatic int hostapd_set_key(const char *ifname, struct hostapd_data *hapd, 96214501Srpaulo enum wpa_alg alg, const u8 *addr, int key_idx, 97214501Srpaulo int set_tx, const u8 *seq, size_t seq_len, 98214501Srpaulo const u8 *key, size_t key_len) 99214501Srpaulo{ 100214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_key == NULL) 101214501Srpaulo return 0; 102214501Srpaulo return hapd->driver->set_key(ifname, hapd->drv_priv, alg, addr, 103214501Srpaulo key_idx, set_tx, seq, seq_len, key, 104214501Srpaulo key_len); 105214501Srpaulo} 106214501Srpaulo 107214501Srpaulo 108214501Srpaulostatic int hostapd_read_sta_data(struct hostapd_data *hapd, 109214501Srpaulo struct hostap_sta_driver_data *data, 110214501Srpaulo const u8 *addr) 111214501Srpaulo{ 112214501Srpaulo if (hapd->driver == NULL || hapd->driver->read_sta_data == NULL) 113214501Srpaulo return -1; 114214501Srpaulo return hapd->driver->read_sta_data(hapd->drv_priv, data, addr); 115214501Srpaulo} 116214501Srpaulo 117214501Srpaulo 118214501Srpaulostatic int hostapd_sta_clear_stats(struct hostapd_data *hapd, const u8 *addr) 119214501Srpaulo{ 120214501Srpaulo if (hapd->driver == NULL || hapd->driver->sta_clear_stats == NULL) 121214501Srpaulo return 0; 122214501Srpaulo return hapd->driver->sta_clear_stats(hapd->drv_priv, addr); 123214501Srpaulo} 124214501Srpaulo 125214501Srpaulo 126214501Srpaulostatic int hostapd_set_sta_flags(struct hostapd_data *hapd, 127214501Srpaulo struct sta_info *sta) 128214501Srpaulo{ 129214501Srpaulo int set_flags, total_flags, flags_and, flags_or; 130214501Srpaulo total_flags = hostapd_sta_flags_to_drv(sta->flags); 131214501Srpaulo set_flags = WPA_STA_SHORT_PREAMBLE | WPA_STA_WMM | WPA_STA_MFP; 132214501Srpaulo if (((!hapd->conf->ieee802_1x && !hapd->conf->wpa) || 133214501Srpaulo sta->auth_alg == WLAN_AUTH_FT) && 134214501Srpaulo sta->flags & WLAN_STA_AUTHORIZED) 135214501Srpaulo set_flags |= WPA_STA_AUTHORIZED; 136214501Srpaulo flags_or = total_flags & set_flags; 137214501Srpaulo flags_and = total_flags | ~set_flags; 138214501Srpaulo return hostapd_sta_set_flags(hapd, sta->addr, total_flags, 139214501Srpaulo flags_or, flags_and); 140214501Srpaulo} 141214501Srpaulo 142214501Srpaulo 143214501Srpaulostatic int hostapd_set_drv_ieee8021x(struct hostapd_data *hapd, 144214501Srpaulo const char *ifname, int enabled) 145214501Srpaulo{ 146214501Srpaulo struct wpa_bss_params params; 147214501Srpaulo os_memset(¶ms, 0, sizeof(params)); 148214501Srpaulo params.ifname = ifname; 149214501Srpaulo params.enabled = enabled; 150214501Srpaulo if (enabled) { 151214501Srpaulo params.wpa = hapd->conf->wpa; 152214501Srpaulo params.ieee802_1x = hapd->conf->ieee802_1x; 153214501Srpaulo params.wpa_group = hapd->conf->wpa_group; 154214501Srpaulo params.wpa_pairwise = hapd->conf->wpa_pairwise; 155214501Srpaulo params.wpa_key_mgmt = hapd->conf->wpa_key_mgmt; 156214501Srpaulo params.rsn_preauth = hapd->conf->rsn_preauth; 157214501Srpaulo } 158214501Srpaulo return hostapd_set_ieee8021x(hapd, ¶ms); 159214501Srpaulo} 160214501Srpaulo 161214501Srpaulo 162214501Srpaulostatic int hostapd_set_radius_acl_auth(struct hostapd_data *hapd, 163214501Srpaulo const u8 *mac, int accepted, 164214501Srpaulo u32 session_timeout) 165214501Srpaulo{ 166214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_radius_acl_auth == NULL) 167214501Srpaulo return 0; 168214501Srpaulo return hapd->driver->set_radius_acl_auth(hapd->drv_priv, mac, accepted, 169214501Srpaulo session_timeout); 170214501Srpaulo} 171214501Srpaulo 172214501Srpaulo 173214501Srpaulostatic int hostapd_set_radius_acl_expire(struct hostapd_data *hapd, 174214501Srpaulo const u8 *mac) 175214501Srpaulo{ 176214501Srpaulo if (hapd->driver == NULL || 177214501Srpaulo hapd->driver->set_radius_acl_expire == NULL) 178214501Srpaulo return 0; 179214501Srpaulo return hapd->driver->set_radius_acl_expire(hapd->drv_priv, mac); 180214501Srpaulo} 181214501Srpaulo 182214501Srpaulo 183214501Srpaulostatic int hostapd_set_bss_params(struct hostapd_data *hapd, 184214501Srpaulo int use_protection) 185214501Srpaulo{ 186214501Srpaulo int ret = 0; 187214501Srpaulo int preamble; 188214501Srpaulo#ifdef CONFIG_IEEE80211N 189214501Srpaulo u8 buf[60], *ht_capab, *ht_oper, *pos; 190214501Srpaulo 191214501Srpaulo pos = buf; 192214501Srpaulo ht_capab = pos; 193214501Srpaulo pos = hostapd_eid_ht_capabilities(hapd, pos); 194214501Srpaulo ht_oper = pos; 195214501Srpaulo pos = hostapd_eid_ht_operation(hapd, pos); 196214501Srpaulo if (pos > ht_oper && ht_oper > ht_capab && 197214501Srpaulo hostapd_set_ht_params(hapd, ht_capab + 2, ht_capab[1], 198214501Srpaulo ht_oper + 2, ht_oper[1])) { 199214501Srpaulo wpa_printf(MSG_ERROR, "Could not set HT capabilities " 200214501Srpaulo "for kernel driver"); 201214501Srpaulo ret = -1; 202214501Srpaulo } 203214501Srpaulo 204214501Srpaulo#endif /* CONFIG_IEEE80211N */ 205214501Srpaulo 206214501Srpaulo if (hostapd_set_cts_protect(hapd, use_protection)) { 207214501Srpaulo wpa_printf(MSG_ERROR, "Failed to set CTS protect in kernel " 208214501Srpaulo "driver"); 209214501Srpaulo ret = -1; 210214501Srpaulo } 211214501Srpaulo 212214501Srpaulo if (hapd->iface->current_mode && 213214501Srpaulo hapd->iface->current_mode->mode == HOSTAPD_MODE_IEEE80211G && 214214501Srpaulo hostapd_set_short_slot_time(hapd, 215214501Srpaulo hapd->iface->num_sta_no_short_slot_time 216214501Srpaulo > 0 ? 0 : 1)) { 217214501Srpaulo wpa_printf(MSG_ERROR, "Failed to set Short Slot Time option " 218214501Srpaulo "in kernel driver"); 219214501Srpaulo ret = -1; 220214501Srpaulo } 221214501Srpaulo 222214501Srpaulo if (hapd->iface->num_sta_no_short_preamble == 0 && 223214501Srpaulo hapd->iconf->preamble == SHORT_PREAMBLE) 224214501Srpaulo preamble = SHORT_PREAMBLE; 225214501Srpaulo else 226214501Srpaulo preamble = LONG_PREAMBLE; 227214501Srpaulo if (hostapd_set_preamble(hapd, preamble)) { 228214501Srpaulo wpa_printf(MSG_ERROR, "Could not set preamble for kernel " 229214501Srpaulo "driver"); 230214501Srpaulo ret = -1; 231214501Srpaulo } 232214501Srpaulo 233214501Srpaulo return ret; 234214501Srpaulo} 235214501Srpaulo 236214501Srpaulo 237214501Srpaulostatic int hostapd_set_beacon(struct hostapd_data *hapd, 238214501Srpaulo const u8 *head, size_t head_len, 239214501Srpaulo const u8 *tail, size_t tail_len, int dtim_period, 240214501Srpaulo int beacon_int) 241214501Srpaulo{ 242214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_beacon == NULL) 243214501Srpaulo return 0; 244214501Srpaulo return hapd->driver->set_beacon(hapd->drv_priv, 245214501Srpaulo head, head_len, tail, tail_len, 246214501Srpaulo dtim_period, beacon_int); 247214501Srpaulo} 248214501Srpaulo 249214501Srpaulo 250214501Srpaulostatic int hostapd_vlan_if_add(struct hostapd_data *hapd, const char *ifname) 251214501Srpaulo{ 252214501Srpaulo char force_ifname[IFNAMSIZ]; 253214501Srpaulo u8 if_addr[ETH_ALEN]; 254214501Srpaulo return hostapd_if_add(hapd, WPA_IF_AP_VLAN, ifname, NULL, NULL, NULL, 255214501Srpaulo force_ifname, if_addr); 256214501Srpaulo} 257214501Srpaulo 258214501Srpaulostatic int hostapd_vlan_if_remove(struct hostapd_data *hapd, 259214501Srpaulo const char *ifname) 260214501Srpaulo{ 261214501Srpaulo return hostapd_if_remove(hapd, WPA_IF_AP_VLAN, ifname); 262214501Srpaulo} 263214501Srpaulo 264214501Srpaulo 265214501Srpaulostatic int hostapd_set_wds_sta(struct hostapd_data *hapd, const u8 *addr, 266214501Srpaulo int aid, int val) 267214501Srpaulo{ 268214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_wds_sta == NULL) 269214501Srpaulo return 0; 270214501Srpaulo return hapd->driver->set_wds_sta(hapd->drv_priv, addr, aid, val); 271214501Srpaulo} 272214501Srpaulo 273214501Srpaulo 274214501Srpaulostatic int hostapd_set_sta_vlan(const char *ifname, struct hostapd_data *hapd, 275214501Srpaulo const u8 *addr, int vlan_id) 276214501Srpaulo{ 277214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_sta_vlan == NULL) 278214501Srpaulo return 0; 279214501Srpaulo return hapd->driver->set_sta_vlan(hapd->drv_priv, addr, ifname, 280214501Srpaulo vlan_id); 281214501Srpaulo} 282214501Srpaulo 283214501Srpaulo 284214501Srpaulostatic int hostapd_get_inact_sec(struct hostapd_data *hapd, const u8 *addr) 285214501Srpaulo{ 286214501Srpaulo if (hapd->driver == NULL || hapd->driver->get_inact_sec == NULL) 287214501Srpaulo return 0; 288214501Srpaulo return hapd->driver->get_inact_sec(hapd->drv_priv, addr); 289214501Srpaulo} 290214501Srpaulo 291214501Srpaulo 292214501Srpaulostatic int hostapd_sta_deauth(struct hostapd_data *hapd, const u8 *addr, 293214501Srpaulo int reason) 294214501Srpaulo{ 295214501Srpaulo if (hapd->driver == NULL || hapd->driver->sta_deauth == NULL) 296214501Srpaulo return 0; 297214501Srpaulo return hapd->driver->sta_deauth(hapd->drv_priv, hapd->own_addr, addr, 298214501Srpaulo reason); 299214501Srpaulo} 300214501Srpaulo 301214501Srpaulo 302214501Srpaulostatic int hostapd_sta_disassoc(struct hostapd_data *hapd, const u8 *addr, 303214501Srpaulo int reason) 304214501Srpaulo{ 305214501Srpaulo if (hapd->driver == NULL || hapd->driver->sta_disassoc == NULL) 306214501Srpaulo return 0; 307214501Srpaulo return hapd->driver->sta_disassoc(hapd->drv_priv, hapd->own_addr, addr, 308214501Srpaulo reason); 309214501Srpaulo} 310214501Srpaulo 311214501Srpaulo 312214501Srpaulostatic int hostapd_sta_add(struct hostapd_data *hapd, 313214501Srpaulo const u8 *addr, u16 aid, u16 capability, 314214501Srpaulo const u8 *supp_rates, size_t supp_rates_len, 315214501Srpaulo u16 listen_interval, 316214501Srpaulo const struct ieee80211_ht_capabilities *ht_capab) 317214501Srpaulo{ 318214501Srpaulo struct hostapd_sta_add_params params; 319214501Srpaulo 320214501Srpaulo if (hapd->driver == NULL) 321214501Srpaulo return 0; 322214501Srpaulo if (hapd->driver->sta_add == NULL) 323214501Srpaulo return 0; 324214501Srpaulo 325214501Srpaulo os_memset(¶ms, 0, sizeof(params)); 326214501Srpaulo params.addr = addr; 327214501Srpaulo params.aid = aid; 328214501Srpaulo params.capability = capability; 329214501Srpaulo params.supp_rates = supp_rates; 330214501Srpaulo params.supp_rates_len = supp_rates_len; 331214501Srpaulo params.listen_interval = listen_interval; 332214501Srpaulo params.ht_capabilities = ht_capab; 333214501Srpaulo return hapd->driver->sta_add(hapd->drv_priv, ¶ms); 334214501Srpaulo} 335214501Srpaulo 336214501Srpaulo 337214501Srpaulostatic int hostapd_sta_remove(struct hostapd_data *hapd, const u8 *addr) 338214501Srpaulo{ 339214501Srpaulo if (hapd->driver == NULL || hapd->driver->sta_remove == NULL) 340214501Srpaulo return 0; 341214501Srpaulo return hapd->driver->sta_remove(hapd->drv_priv, addr); 342214501Srpaulo} 343214501Srpaulo 344214501Srpaulo 345214501Srpaulostatic int hostapd_set_countermeasures(struct hostapd_data *hapd, int enabled) 346214501Srpaulo{ 347214501Srpaulo if (hapd->driver == NULL || 348214501Srpaulo hapd->driver->hapd_set_countermeasures == NULL) 349214501Srpaulo return 0; 350214501Srpaulo return hapd->driver->hapd_set_countermeasures(hapd->drv_priv, enabled); 351214501Srpaulo} 352214501Srpaulo 353214501Srpaulo 354214501Srpaulovoid hostapd_set_driver_ops(struct hostapd_driver_ops *ops) 355214501Srpaulo{ 356214501Srpaulo ops->set_ap_wps_ie = hostapd_set_ap_wps_ie; 357214501Srpaulo ops->send_mgmt_frame = hostapd_send_mgmt_frame; 358214501Srpaulo ops->send_eapol = hostapd_send_eapol; 359214501Srpaulo ops->set_authorized = hostapd_set_authorized; 360214501Srpaulo ops->set_key = hostapd_set_key; 361214501Srpaulo ops->read_sta_data = hostapd_read_sta_data; 362214501Srpaulo ops->sta_clear_stats = hostapd_sta_clear_stats; 363214501Srpaulo ops->set_sta_flags = hostapd_set_sta_flags; 364214501Srpaulo ops->set_drv_ieee8021x = hostapd_set_drv_ieee8021x; 365214501Srpaulo ops->set_radius_acl_auth = hostapd_set_radius_acl_auth; 366214501Srpaulo ops->set_radius_acl_expire = hostapd_set_radius_acl_expire; 367214501Srpaulo ops->set_bss_params = hostapd_set_bss_params; 368214501Srpaulo ops->set_beacon = hostapd_set_beacon; 369214501Srpaulo ops->vlan_if_add = hostapd_vlan_if_add; 370214501Srpaulo ops->vlan_if_remove = hostapd_vlan_if_remove; 371214501Srpaulo ops->set_wds_sta = hostapd_set_wds_sta; 372214501Srpaulo ops->set_sta_vlan = hostapd_set_sta_vlan; 373214501Srpaulo ops->get_inact_sec = hostapd_get_inact_sec; 374214501Srpaulo ops->sta_deauth = hostapd_sta_deauth; 375214501Srpaulo ops->sta_disassoc = hostapd_sta_disassoc; 376214501Srpaulo ops->sta_add = hostapd_sta_add; 377214501Srpaulo ops->sta_remove = hostapd_sta_remove; 378214501Srpaulo ops->set_countermeasures = hostapd_set_countermeasures; 379214501Srpaulo} 380214501Srpaulo 381214501Srpaulo 382214501Srpauloint hostapd_set_privacy(struct hostapd_data *hapd, int enabled) 383214501Srpaulo{ 384214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_privacy == NULL) 385214501Srpaulo return 0; 386214501Srpaulo return hapd->driver->set_privacy(hapd->drv_priv, enabled); 387214501Srpaulo} 388214501Srpaulo 389214501Srpaulo 390214501Srpauloint hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem, 391214501Srpaulo size_t elem_len) 392214501Srpaulo{ 393214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL) 394214501Srpaulo return 0; 395214501Srpaulo return hapd->driver->set_generic_elem(hapd->drv_priv, elem, elem_len); 396214501Srpaulo} 397214501Srpaulo 398214501Srpaulo 399214501Srpauloint hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len) 400214501Srpaulo{ 401214501Srpaulo if (hapd->driver == NULL || hapd->driver->hapd_get_ssid == NULL) 402214501Srpaulo return 0; 403214501Srpaulo return hapd->driver->hapd_get_ssid(hapd->drv_priv, buf, len); 404214501Srpaulo} 405214501Srpaulo 406214501Srpaulo 407214501Srpauloint hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len) 408214501Srpaulo{ 409214501Srpaulo if (hapd->driver == NULL || hapd->driver->hapd_set_ssid == NULL) 410214501Srpaulo return 0; 411214501Srpaulo return hapd->driver->hapd_set_ssid(hapd->drv_priv, buf, len); 412214501Srpaulo} 413214501Srpaulo 414214501Srpaulo 415214501Srpauloint hostapd_if_add(struct hostapd_data *hapd, enum wpa_driver_if_type type, 416214501Srpaulo const char *ifname, const u8 *addr, void *bss_ctx, 417214501Srpaulo void **drv_priv, char *force_ifname, u8 *if_addr) 418214501Srpaulo{ 419214501Srpaulo if (hapd->driver == NULL || hapd->driver->if_add == NULL) 420214501Srpaulo return -1; 421214501Srpaulo return hapd->driver->if_add(hapd->drv_priv, type, ifname, addr, 422214501Srpaulo bss_ctx, drv_priv, force_ifname, if_addr); 423214501Srpaulo} 424214501Srpaulo 425214501Srpaulo 426214501Srpauloint hostapd_if_remove(struct hostapd_data *hapd, enum wpa_driver_if_type type, 427214501Srpaulo const char *ifname) 428214501Srpaulo{ 429214501Srpaulo if (hapd->driver == NULL || hapd->driver->if_remove == NULL) 430214501Srpaulo return -1; 431214501Srpaulo return hapd->driver->if_remove(hapd->drv_priv, type, ifname); 432214501Srpaulo} 433214501Srpaulo 434214501Srpaulo 435214501Srpauloint hostapd_set_ieee8021x(struct hostapd_data *hapd, 436214501Srpaulo struct wpa_bss_params *params) 437214501Srpaulo{ 438214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL) 439214501Srpaulo return 0; 440214501Srpaulo return hapd->driver->set_ieee8021x(hapd->drv_priv, params); 441214501Srpaulo} 442214501Srpaulo 443214501Srpaulo 444214501Srpauloint hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd, 445214501Srpaulo const u8 *addr, int idx, u8 *seq) 446214501Srpaulo{ 447214501Srpaulo if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL) 448214501Srpaulo return 0; 449214501Srpaulo return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx, 450214501Srpaulo seq); 451214501Srpaulo} 452214501Srpaulo 453214501Srpaulo 454214501Srpauloint hostapd_flush(struct hostapd_data *hapd) 455214501Srpaulo{ 456214501Srpaulo if (hapd->driver == NULL || hapd->driver->flush == NULL) 457214501Srpaulo return 0; 458214501Srpaulo return hapd->driver->flush(hapd->drv_priv); 459214501Srpaulo} 460214501Srpaulo 461214501Srpaulo 462214501Srpauloint hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq, 463214501Srpaulo int channel, int ht_enabled, int sec_channel_offset) 464214501Srpaulo{ 465214501Srpaulo struct hostapd_freq_params data; 466214501Srpaulo if (hapd->driver == NULL) 467214501Srpaulo return 0; 468214501Srpaulo if (hapd->driver->set_freq == NULL) 469214501Srpaulo return 0; 470214501Srpaulo os_memset(&data, 0, sizeof(data)); 471214501Srpaulo data.mode = mode; 472214501Srpaulo data.freq = freq; 473214501Srpaulo data.channel = channel; 474214501Srpaulo data.ht_enabled = ht_enabled; 475214501Srpaulo data.sec_channel_offset = sec_channel_offset; 476214501Srpaulo return hapd->driver->set_freq(hapd->drv_priv, &data); 477214501Srpaulo} 478214501Srpaulo 479214501Srpauloint hostapd_set_rts(struct hostapd_data *hapd, int rts) 480214501Srpaulo{ 481214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_rts == NULL) 482214501Srpaulo return 0; 483214501Srpaulo return hapd->driver->set_rts(hapd->drv_priv, rts); 484214501Srpaulo} 485214501Srpaulo 486214501Srpaulo 487214501Srpauloint hostapd_set_frag(struct hostapd_data *hapd, int frag) 488214501Srpaulo{ 489214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_frag == NULL) 490214501Srpaulo return 0; 491214501Srpaulo return hapd->driver->set_frag(hapd->drv_priv, frag); 492214501Srpaulo} 493214501Srpaulo 494214501Srpaulo 495214501Srpauloint hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr, 496214501Srpaulo int total_flags, int flags_or, int flags_and) 497214501Srpaulo{ 498214501Srpaulo if (hapd->driver == NULL || hapd->driver->sta_set_flags == NULL) 499214501Srpaulo return 0; 500214501Srpaulo return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags, 501214501Srpaulo flags_or, flags_and); 502214501Srpaulo} 503214501Srpaulo 504214501Srpaulo 505214501Srpauloint hostapd_set_rate_sets(struct hostapd_data *hapd, int *supp_rates, 506214501Srpaulo int *basic_rates, int mode) 507214501Srpaulo{ 508214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_rate_sets == NULL) 509214501Srpaulo return 0; 510214501Srpaulo return hapd->driver->set_rate_sets(hapd->drv_priv, supp_rates, 511214501Srpaulo basic_rates, mode); 512214501Srpaulo} 513214501Srpaulo 514214501Srpaulo 515214501Srpauloint hostapd_set_country(struct hostapd_data *hapd, const char *country) 516214501Srpaulo{ 517214501Srpaulo if (hapd->driver == NULL || 518214501Srpaulo hapd->driver->set_country == NULL) 519214501Srpaulo return 0; 520214501Srpaulo return hapd->driver->set_country(hapd->drv_priv, country); 521214501Srpaulo} 522214501Srpaulo 523214501Srpaulo 524214501Srpauloint hostapd_set_cts_protect(struct hostapd_data *hapd, int value) 525214501Srpaulo{ 526214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_cts_protect == NULL) 527214501Srpaulo return 0; 528214501Srpaulo return hapd->driver->set_cts_protect(hapd->drv_priv, value); 529214501Srpaulo} 530214501Srpaulo 531214501Srpaulo 532214501Srpauloint hostapd_set_preamble(struct hostapd_data *hapd, int value) 533214501Srpaulo{ 534214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_preamble == NULL) 535214501Srpaulo return 0; 536214501Srpaulo return hapd->driver->set_preamble(hapd->drv_priv, value); 537214501Srpaulo} 538214501Srpaulo 539214501Srpaulo 540214501Srpauloint hostapd_set_short_slot_time(struct hostapd_data *hapd, int value) 541214501Srpaulo{ 542214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_short_slot_time == NULL) 543214501Srpaulo return 0; 544214501Srpaulo return hapd->driver->set_short_slot_time(hapd->drv_priv, value); 545214501Srpaulo} 546214501Srpaulo 547214501Srpaulo 548214501Srpauloint hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs, 549214501Srpaulo int cw_min, int cw_max, int burst_time) 550214501Srpaulo{ 551214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL) 552214501Srpaulo return 0; 553214501Srpaulo return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs, 554214501Srpaulo cw_min, cw_max, burst_time); 555214501Srpaulo} 556214501Srpaulo 557214501Srpaulo 558214501Srpauloint hostapd_valid_bss_mask(struct hostapd_data *hapd, const u8 *addr, 559214501Srpaulo const u8 *mask) 560214501Srpaulo{ 561214501Srpaulo if (hapd->driver == NULL || hapd->driver->valid_bss_mask == NULL) 562214501Srpaulo return 1; 563214501Srpaulo return hapd->driver->valid_bss_mask(hapd->drv_priv, addr, mask); 564214501Srpaulo} 565214501Srpaulo 566214501Srpaulo 567214501Srpaulostruct hostapd_hw_modes * 568214501Srpaulohostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes, 569214501Srpaulo u16 *flags) 570214501Srpaulo{ 571214501Srpaulo if (hapd->driver == NULL || 572214501Srpaulo hapd->driver->get_hw_feature_data == NULL) 573214501Srpaulo return NULL; 574214501Srpaulo return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes, 575214501Srpaulo flags); 576214501Srpaulo} 577214501Srpaulo 578214501Srpaulo 579214501Srpauloint hostapd_driver_commit(struct hostapd_data *hapd) 580214501Srpaulo{ 581214501Srpaulo if (hapd->driver == NULL || hapd->driver->commit == NULL) 582214501Srpaulo return 0; 583214501Srpaulo return hapd->driver->commit(hapd->drv_priv); 584214501Srpaulo} 585214501Srpaulo 586214501Srpaulo 587214501Srpauloint hostapd_set_ht_params(struct hostapd_data *hapd, 588214501Srpaulo const u8 *ht_capab, size_t ht_capab_len, 589214501Srpaulo const u8 *ht_oper, size_t ht_oper_len) 590214501Srpaulo{ 591214501Srpaulo if (hapd->driver == NULL || hapd->driver->set_ht_params == NULL || 592214501Srpaulo ht_capab == NULL || ht_oper == NULL) 593214501Srpaulo return 0; 594214501Srpaulo return hapd->driver->set_ht_params(hapd->drv_priv, 595214501Srpaulo ht_capab, ht_capab_len, 596214501Srpaulo ht_oper, ht_oper_len); 597214501Srpaulo} 598214501Srpaulo 599214501Srpaulo 600214501Srpauloint hostapd_drv_none(struct hostapd_data *hapd) 601214501Srpaulo{ 602214501Srpaulo return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0; 603214501Srpaulo} 604214501Srpaulo 605214501Srpaulo 606214501Srpauloint hostapd_driver_scan(struct hostapd_data *hapd, 607214501Srpaulo struct wpa_driver_scan_params *params) 608214501Srpaulo{ 609214501Srpaulo if (hapd->driver && hapd->driver->scan2) 610214501Srpaulo return hapd->driver->scan2(hapd->drv_priv, params); 611214501Srpaulo return -1; 612214501Srpaulo} 613214501Srpaulo 614214501Srpaulo 615214501Srpaulostruct wpa_scan_results * hostapd_driver_get_scan_results( 616214501Srpaulo struct hostapd_data *hapd) 617214501Srpaulo{ 618214501Srpaulo if (hapd->driver && hapd->driver->get_scan_results2) 619214501Srpaulo return hapd->driver->get_scan_results2(hapd->drv_priv); 620214501Srpaulo return NULL; 621214501Srpaulo} 622