[thirdparty/hostap.git] / src / ap / ap_drv_ops.h

/*
 * hostapd - Driver operations
 * Copyright (c) 2009-2014, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#ifndef AP_DRV_OPS
#define AP_DRV_OPS

enum wpa_driver_if_type;
struct wpa_bss_params;
struct wpa_driver_scan_params;
struct ieee80211_ht_capabilities;
struct ieee80211_vht_capabilities;
struct hostapd_freq_params;

u32 hostapd_sta_flags_to_drv(u32 flags);
int hostapd_build_ap_extra_ies(struct hostapd_data *hapd,
			       struct wpabuf **beacon,
			       struct wpabuf **proberesp,
			       struct wpabuf **assocresp);
void hostapd_free_ap_extra_ies(struct hostapd_data *hapd, struct wpabuf *beacon,
			       struct wpabuf *proberesp,
			       struct wpabuf *assocresp);
int hostapd_set_ap_wps_ie(struct hostapd_data *hapd);
int hostapd_set_authorized(struct hostapd_data *hapd,
			   struct sta_info *sta, int authorized);
int hostapd_set_sta_flags(struct hostapd_data *hapd, struct sta_info *sta);
int hostapd_set_drv_ieee8021x(struct hostapd_data *hapd, const char *ifname,
			      int enabled);
int hostapd_vlan_if_add(struct hostapd_data *hapd, const char *ifname);
int hostapd_vlan_if_remove(struct hostapd_data *hapd, const char *ifname);
int hostapd_set_wds_sta(struct hostapd_data *hapd, char *ifname_wds,
			const u8 *addr, int aid, int val);
int hostapd_sta_add(struct hostapd_data *hapd,
		    const u8 *addr, u16 aid, u16 capability,
		    const u8 *supp_rates, size_t supp_rates_len,
		    u16 listen_interval,
		    const struct ieee80211_ht_capabilities *ht_capab,
		    const struct ieee80211_vht_capabilities *vht_capab,
		    u32 flags, u8 qosinfo, u8 vht_opmode);
int hostapd_set_privacy(struct hostapd_data *hapd, int enabled);
int hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem,
			     size_t elem_len);
int hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len);
int hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len);
int hostapd_if_add(struct hostapd_data *hapd, enum wpa_driver_if_type type,
		   const char *ifname, const u8 *addr, void *bss_ctx,
		   void **drv_priv, char *force_ifname, u8 *if_addr,
		   const char *bridge, int use_existing);
int hostapd_if_remove(struct hostapd_data *hapd, enum wpa_driver_if_type type,
		      const char *ifname);
int hostapd_set_ieee8021x(struct hostapd_data *hapd,
			  struct wpa_bss_params *params);
int hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd,
		       const u8 *addr, int idx, u8 *seq);
int hostapd_flush(struct hostapd_data *hapd);
int hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq,
		     int channel, int ht_enabled, int vht_enabled,
		     int sec_channel_offset, int vht_oper_chwidth,
		     int center_segment0, int center_segment1);
int hostapd_set_rts(struct hostapd_data *hapd, int rts);
int hostapd_set_frag(struct hostapd_data *hapd, int frag);
int hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr,
			  int total_flags, int flags_or, int flags_and);
int hostapd_set_country(struct hostapd_data *hapd, const char *country);
int hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs,
				int cw_min, int cw_max, int burst_time);
struct hostapd_hw_modes *
hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes,
			    u16 *flags);
int hostapd_driver_commit(struct hostapd_data *hapd);
int hostapd_drv_none(struct hostapd_data *hapd);
int hostapd_driver_scan(struct hostapd_data *hapd,
			struct wpa_driver_scan_params *params);
struct wpa_scan_results * hostapd_driver_get_scan_results(
	struct hostapd_data *hapd);
int hostapd_driver_set_noa(struct hostapd_data *hapd, u8 count, int start,
			   int duration);
int hostapd_drv_set_key(const char *ifname,
			struct hostapd_data *hapd,
			enum wpa_alg alg, const u8 *addr,
			int key_idx, int set_tx,
			const u8 *seq, size_t seq_len,
			const u8 *key, size_t key_len);
int hostapd_drv_send_mlme(struct hostapd_data *hapd,
			  const void *msg, size_t len, int noack);
int hostapd_drv_sta_deauth(struct hostapd_data *hapd,
			   const u8 *addr, int reason);
int hostapd_drv_sta_disassoc(struct hostapd_data *hapd,
			     const u8 *addr, int reason);
int hostapd_drv_send_action(struct hostapd_data *hapd, unsigned int freq,
			    unsigned int wait, const u8 *dst, const u8 *data,
			    size_t len);
int hostapd_add_sta_node(struct hostapd_data *hapd, const u8 *addr,
			 u16 auth_alg);
int hostapd_sta_auth(struct hostapd_data *hapd, const u8 *addr,
		     u16 seq, u16 status, const u8 *ie, size_t len);
int hostapd_sta_assoc(struct hostapd_data *hapd, const u8 *addr,
		      int reassoc, u16 status, const u8 *ie, size_t len);
int hostapd_add_tspec(struct hostapd_data *hapd, const u8 *addr,
		      u8 *tspec_ie, size_t tspec_ielen);
int hostapd_start_dfs_cac(struct hostapd_iface *iface, int mode, int freq,
			  int channel, int ht_enabled, int vht_enabled,
			  int sec_channel_offset, int vht_oper_chwidth,
			  int center_segment0, int center_segment1);
int hostapd_set_freq_params(struct hostapd_freq_params *data, int mode,
			    int freq, int channel, int ht_enabled,
			    int vht_enabled, int sec_channel_offset,
			    int vht_oper_chwidth, int center_segment0,
			    int center_segment1, u32 vht_caps);


#include "drivers/driver.h"

int hostapd_drv_wnm_oper(struct hostapd_data *hapd,
			 enum wnm_oper oper, const u8 *peer,
			 u8 *buf, u16 *buf_len);

int hostapd_drv_set_qos_map(struct hostapd_data *hapd, const u8 *qos_map_set,
			    u8 qos_map_set_len);

static inline int hostapd_drv_set_countermeasures(struct hostapd_data *hapd,
						  int enabled)
{
	if (hapd->driver == NULL ||
	    hapd->driver->hapd_set_countermeasures == NULL)
		return 0;
	return hapd->driver->hapd_set_countermeasures(hapd->drv_priv, enabled);
}

static inline int hostapd_drv_set_sta_vlan(const char *ifname,
					   struct hostapd_data *hapd,
					   const u8 *addr, int vlan_id)
{
	if (hapd->driver == NULL || hapd->driver->set_sta_vlan == NULL)
		return 0;
	return hapd->driver->set_sta_vlan(hapd->drv_priv, addr, ifname,
					  vlan_id);
}

static inline int hostapd_drv_get_inact_sec(struct hostapd_data *hapd,
					    const u8 *addr)
{
	if (hapd->driver == NULL || hapd->driver->get_inact_sec == NULL)
		return 0;
	return hapd->driver->get_inact_sec(hapd->drv_priv, addr);
}

static inline int hostapd_drv_sta_remove(struct hostapd_data *hapd,
					 const u8 *addr)
{
	if (hapd->driver == NULL || hapd->driver->sta_remove == NULL)
		return 0;
	return hapd->driver->sta_remove(hapd->drv_priv, addr);
}

static inline int hostapd_drv_hapd_send_eapol(struct hostapd_data *hapd,
					      const u8 *addr, const u8 *data,
					      size_t data_len, int encrypt,
					      u32 flags)
{
	if (hapd->driver == NULL || hapd->driver->hapd_send_eapol == NULL)
		return 0;
	return hapd->driver->hapd_send_eapol(hapd->drv_priv, addr, data,
					     data_len, encrypt,
					     hapd->own_addr, flags);
}

static inline int hostapd_drv_read_sta_data(
	struct hostapd_data *hapd, struct hostap_sta_driver_data *data,
	const u8 *addr)
{
	if (hapd->driver == NULL || hapd->driver->read_sta_data == NULL)
		return -1;
	return hapd->driver->read_sta_data(hapd->drv_priv, data, addr);
}

static inline int hostapd_drv_sta_clear_stats(struct hostapd_data *hapd,
					      const u8 *addr)
{
	if (hapd->driver == NULL || hapd->driver->sta_clear_stats == NULL)
		return 0;
	return hapd->driver->sta_clear_stats(hapd->drv_priv, addr);
}

static inline int hostapd_drv_set_acl(struct hostapd_data *hapd,
				      struct hostapd_acl_params *params)
{
	if (hapd->driver == NULL || hapd->driver->set_acl == NULL)
		return 0;
	return hapd->driver->set_acl(hapd->drv_priv, params);
}

static inline int hostapd_drv_set_ap(struct hostapd_data *hapd,
				     struct wpa_driver_ap_params *params)
{
	if (hapd->driver == NULL || hapd->driver->set_ap == NULL)
		return 0;
	return hapd->driver->set_ap(hapd->drv_priv, params);
}

static inline int hostapd_drv_set_radius_acl_auth(struct hostapd_data *hapd,
						  const u8 *mac, int accepted,
						  u32 session_timeout)
{
	if (hapd->driver == NULL || hapd->driver->set_radius_acl_auth == NULL)
		return 0;
	return hapd->driver->set_radius_acl_auth(hapd->drv_priv, mac, accepted,
						 session_timeout);
}

static inline int hostapd_drv_set_radius_acl_expire(struct hostapd_data *hapd,
						    const u8 *mac)
{
	if (hapd->driver == NULL ||
	    hapd->driver->set_radius_acl_expire == NULL)
		return 0;
	return hapd->driver->set_radius_acl_expire(hapd->drv_priv, mac);
}

static inline int hostapd_drv_set_authmode(struct hostapd_data *hapd,
					   int auth_algs)
{
	if (hapd->driver == NULL || hapd->driver->set_authmode == NULL)
		return 0;
	return hapd->driver->set_authmode(hapd->drv_priv, auth_algs);
}

static inline void hostapd_drv_poll_client(struct hostapd_data *hapd,
					   const u8 *own_addr, const u8 *addr,
					   int qos)
{
	if (hapd->driver == NULL || hapd->driver->poll_client == NULL)
		return;
	hapd->driver->poll_client(hapd->drv_priv, own_addr, addr, qos);
}

static inline int hostapd_drv_get_survey(struct hostapd_data *hapd,
					 unsigned int freq)
{
	if (hapd->driver == NULL)
		return -1;
	if (!hapd->driver->get_survey)
		return -1;
	return hapd->driver->get_survey(hapd->drv_priv, freq);
}

static inline int hostapd_get_country(struct hostapd_data *hapd, char *alpha2)
{
	if (hapd->driver == NULL || hapd->driver->get_country == NULL)
		return -1;
	return hapd->driver->get_country(hapd->drv_priv, alpha2);
}

static inline const char * hostapd_drv_get_radio_name(struct hostapd_data *hapd)
{
	if (hapd->driver == NULL || hapd->drv_priv == NULL ||
	    hapd->driver->get_radio_name == NULL)
		return NULL;
	return hapd->driver->get_radio_name(hapd->drv_priv);
}

static inline int hostapd_drv_switch_channel(struct hostapd_data *hapd,
					     struct csa_settings *settings)
{
	if (hapd->driver == NULL || hapd->driver->switch_channel == NULL)
		return -ENOTSUP;

	return hapd->driver->switch_channel(hapd->drv_priv, settings);
}

static inline int hostapd_drv_status(struct hostapd_data *hapd, char *buf,
				     size_t buflen)
{
	if (hapd->driver == NULL || hapd->driver->status == NULL)
		return -1;
	return hapd->driver->status(hapd->drv_priv, buf, buflen);
}

static inline int hostapd_drv_br_add_ip_neigh(struct hostapd_data *hapd,
					      int version, const u8 *ipaddr,
					      int prefixlen, const u8 *addr)
{
	if (hapd->driver == NULL || hapd->drv_priv == NULL ||
	    hapd->driver->br_add_ip_neigh == NULL)
		return -1;
	return hapd->driver->br_add_ip_neigh(hapd->drv_priv, version, ipaddr,
					     prefixlen, addr);
}

static inline int hostapd_drv_br_delete_ip_neigh(struct hostapd_data *hapd,
						 u8 version, const u8 *ipaddr)
{
	if (hapd->driver == NULL || hapd->drv_priv == NULL ||
	    hapd->driver->br_delete_ip_neigh == NULL)
		return -1;
	return hapd->driver->br_delete_ip_neigh(hapd->drv_priv, version,
						ipaddr);
}

static inline int hostapd_drv_br_port_set_attr(struct hostapd_data *hapd,
					       enum drv_br_port_attr attr,
					       unsigned int val)
{
	if (hapd->driver == NULL || hapd->drv_priv == NULL ||
	    hapd->driver->br_port_set_attr == NULL)
		return -1;
	return hapd->driver->br_port_set_attr(hapd->drv_priv, attr, val);
}

static inline int hostapd_drv_br_set_net_param(struct hostapd_data *hapd,
					       enum drv_br_net_param param,
					       unsigned int val)
{
	if (hapd->driver == NULL || hapd->drv_priv == NULL ||
	    hapd->driver->br_set_net_param == NULL)
		return -1;
	return hapd->driver->br_set_net_param(hapd->drv_priv, param, val);
}

static inline int hostapd_drv_vendor_cmd(struct hostapd_data *hapd,
					 int vendor_id, int subcmd,
					 const u8 *data, size_t data_len,
					 struct wpabuf *buf)
{
	if (hapd->driver == NULL || hapd->driver->vendor_cmd == NULL)
		return -1;
	return hapd->driver->vendor_cmd(hapd->drv_priv, vendor_id, subcmd, data,
					data_len, buf);
}

#endif /* AP_DRV_OPS */
Commit	Line	Data
a4f21109 JM	1	/*
a4f21109 JM	2	* hostapd - Driver operations
f0cbb986	3	* Copyright (c) 2009-2014, Jouni Malinen <j@w1.fi>
a4f21109	4	*
0f3d578e JM	5	* This software may be distributed under the terms of the BSD license.
0f3d578e JM	6	* See README for more details.
a4f21109 JM	7	*/
	8
	9	#ifndef AP_DRV_OPS
	10	#define AP_DRV_OPS
	11
6e6e8c31 JM	12	enum wpa_driver_if_type;
	13	struct wpa_bss_params;
	14	struct wpa_driver_scan_params;
0e8a96a9	15	struct ieee80211_ht_capabilities;
a9a1d0f0	16	struct ieee80211_vht_capabilities;
6c6c58d1	17	struct hostapd_freq_params;
6e6e8c31	18
4378fc14	19	u32 hostapd_sta_flags_to_drv(u32 flags);
fb91db56 JM	20	int hostapd_build_ap_extra_ies(struct hostapd_data *hapd,
	21	struct wpabuf **beacon,
	22	struct wpabuf **proberesp,
	23	struct wpabuf **assocresp);
	24	void hostapd_free_ap_extra_ies(struct hostapd_data hapd, struct wpabuf beacon,
	25	struct wpabuf *proberesp,
	26	struct wpabuf *assocresp);
0e8a96a9 JM	27	int hostapd_set_ap_wps_ie(struct hostapd_data *hapd);
	28	int hostapd_set_authorized(struct hostapd_data *hapd,
	29	struct sta_info *sta, int authorized);
	30	int hostapd_set_sta_flags(struct hostapd_data hapd, struct sta_info sta);
	31	int hostapd_set_drv_ieee8021x(struct hostapd_data hapd, const char ifname,
	32	int enabled);
0e8a96a9 JM	33	int hostapd_vlan_if_add(struct hostapd_data hapd, const char ifname);
0e8a96a9 JM	34	int hostapd_vlan_if_remove(struct hostapd_data hapd, const char ifname);
69dd2967 SM	35	int hostapd_set_wds_sta(struct hostapd_data hapd, char ifname_wds,
69dd2967 SM	36	const u8 *addr, int aid, int val);
0e8a96a9 JM	37	int hostapd_sta_add(struct hostapd_data *hapd,
	38	const u8 *addr, u16 aid, u16 capability,
	39	const u8 *supp_rates, size_t supp_rates_len,
	40	u16 listen_interval,
d83ab1fe	41	const struct ieee80211_ht_capabilities *ht_capab,
a9a1d0f0	42	const struct ieee80211_vht_capabilities *vht_capab,
8a458116	43	u32 flags, u8 qosinfo, u8 vht_opmode);
8b06c1ed JM	44	int hostapd_set_privacy(struct hostapd_data *hapd, int enabled);
	45	int hostapd_set_generic_elem(struct hostapd_data hapd, const u8 elem,
	46	size_t elem_len);
	47	int hostapd_get_ssid(struct hostapd_data hapd, u8 buf, size_t len);
	48	int hostapd_set_ssid(struct hostapd_data hapd, const u8 buf, size_t len);
	49	int hostapd_if_add(struct hostapd_data *hapd, enum wpa_driver_if_type type,
a2e40bb6	50	const char ifname, const u8 addr, void *bss_ctx,
e17a2477	51	void *drv_priv, char force_ifname, u8 *if_addr,
2aec4f3c	52	const char *bridge, int use_existing);
8b06c1ed JM	53	int hostapd_if_remove(struct hostapd_data *hapd, enum wpa_driver_if_type type,
8b06c1ed JM	54	const char *ifname);
6e6e8c31 JM	55	int hostapd_set_ieee8021x(struct hostapd_data *hapd,
	56	struct wpa_bss_params *params);
	57	int hostapd_get_seqnum(const char ifname, struct hostapd_data hapd,
	58	const u8 addr, int idx, u8 seq);
	59	int hostapd_flush(struct hostapd_data *hapd);
	60	int hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq,
fa476336 JB	61	int channel, int ht_enabled, int vht_enabled,
	62	int sec_channel_offset, int vht_oper_chwidth,
	63	int center_segment0, int center_segment1);
6e6e8c31 JM	64	int hostapd_set_rts(struct hostapd_data *hapd, int rts);
	65	int hostapd_set_frag(struct hostapd_data *hapd, int frag);
	66	int hostapd_sta_set_flags(struct hostapd_data hapd, u8 addr,
	67	int total_flags, int flags_or, int flags_and);
6e6e8c31	68	int hostapd_set_country(struct hostapd_data hapd, const char country);
6e6e8c31 JM	69	int hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs,
6e6e8c31 JM	70	int cw_min, int cw_max, int burst_time);
6e6e8c31 JM	71	struct hostapd_hw_modes *
	72	hostapd_get_hw_feature_data(struct hostapd_data hapd, u16 num_modes,
	73	u16 *flags);
	74	int hostapd_driver_commit(struct hostapd_data *hapd);
6e6e8c31 JM	75	int hostapd_drv_none(struct hostapd_data *hapd);
	76	int hostapd_driver_scan(struct hostapd_data *hapd,
	77	struct wpa_driver_scan_params *params);
	78	struct wpa_scan_results * hostapd_driver_get_scan_results(
	79	struct hostapd_data *hapd);
aefb53bd JM	80	int hostapd_driver_set_noa(struct hostapd_data *hapd, u8 count, int start,
aefb53bd JM	81	int duration);
7392f11e JM	82	int hostapd_drv_set_key(const char *ifname,
	83	struct hostapd_data *hapd,
	84	enum wpa_alg alg, const u8 *addr,
	85	int key_idx, int set_tx,
	86	const u8 *seq, size_t seq_len,
	87	const u8 *key, size_t key_len);
	88	int hostapd_drv_send_mlme(struct hostapd_data *hapd,
8cfa3527	89	const void *msg, size_t len, int noack);
7392f11e JM	90	int hostapd_drv_sta_deauth(struct hostapd_data *hapd,
	91	const u8 *addr, int reason);
	92	int hostapd_drv_sta_disassoc(struct hostapd_data *hapd,
	93	const u8 *addr, int reason);
fb80e86e JK	94	int hostapd_drv_send_action(struct hostapd_data *hapd, unsigned int freq,
	95	unsigned int wait, const u8 dst, const u8 data,
	96	size_t len);
a52eba0f SP	97	int hostapd_add_sta_node(struct hostapd_data hapd, const u8 addr,
	98	u16 auth_alg);
	99	int hostapd_sta_auth(struct hostapd_data hapd, const u8 addr,
	100	u16 seq, u16 status, const u8 *ie, size_t len);
	101	int hostapd_sta_assoc(struct hostapd_data hapd, const u8 addr,
	102	int reassoc, u16 status, const u8 *ie, size_t len);
	103	int hostapd_add_tspec(struct hostapd_data hapd, const u8 addr,
	104	u8 *tspec_ie, size_t tspec_ielen);
dc036d9e	105	int hostapd_start_dfs_cac(struct hostapd_iface *iface, int mode, int freq,
58b73e3d JD	106	int channel, int ht_enabled, int vht_enabled,
	107	int sec_channel_offset, int vht_oper_chwidth,
	108	int center_segment0, int center_segment1);
6c6c58d1 JD	109	int hostapd_set_freq_params(struct hostapd_freq_params *data, int mode,
	110	int freq, int channel, int ht_enabled,
	111	int vht_enabled, int sec_channel_offset,
	112	int vht_oper_chwidth, int center_segment0,
	113	int center_segment1, u32 vht_caps);
a4f21109	114
cee7d66b JM	115
	116	#include "drivers/driver.h"
	117
a884be9d XC	118	int hostapd_drv_wnm_oper(struct hostapd_data *hapd,
	119	enum wnm_oper oper, const u8 *peer,
	120	u8 buf, u16 buf_len);
	121
c551700f KP	122	int hostapd_drv_set_qos_map(struct hostapd_data hapd, const u8 qos_map_set,
	123	u8 qos_map_set_len);
	124
b5b1b18f JM	125	static inline int hostapd_drv_set_countermeasures(struct hostapd_data *hapd,
	126	int enabled)
	127	{
	128	if (hapd->driver == NULL \|\|
	129	hapd->driver->hapd_set_countermeasures == NULL)
	130	return 0;
	131	return hapd->driver->hapd_set_countermeasures(hapd->drv_priv, enabled);
	132	}
	133
51e2a27a JM	134	static inline int hostapd_drv_set_sta_vlan(const char *ifname,
	135	struct hostapd_data *hapd,
	136	const u8 *addr, int vlan_id)
	137	{
	138	if (hapd->driver == NULL \|\| hapd->driver->set_sta_vlan == NULL)
	139	return 0;
	140	return hapd->driver->set_sta_vlan(hapd->drv_priv, addr, ifname,
	141	vlan_id);
	142	}
	143
	144	static inline int hostapd_drv_get_inact_sec(struct hostapd_data *hapd,
	145	const u8 *addr)
	146	{
	147	if (hapd->driver == NULL \|\| hapd->driver->get_inact_sec == NULL)
	148	return 0;
	149	return hapd->driver->get_inact_sec(hapd->drv_priv, addr);
	150	}
	151
51e2a27a JM	152	static inline int hostapd_drv_sta_remove(struct hostapd_data *hapd,
	153	const u8 *addr)
	154	{
	155	if (hapd->driver == NULL \|\| hapd->driver->sta_remove == NULL)
	156	return 0;
	157	return hapd->driver->sta_remove(hapd->drv_priv, addr);
	158	}
	159
3acdf771 JM	160	static inline int hostapd_drv_hapd_send_eapol(struct hostapd_data *hapd,
3acdf771 JM	161	const u8 addr, const u8 data,
4378fc14 FF	162	size_t data_len, int encrypt,
4378fc14 FF	163	u32 flags)
3acdf771 JM	164	{
	165	if (hapd->driver == NULL \|\| hapd->driver->hapd_send_eapol == NULL)
	166	return 0;
	167	return hapd->driver->hapd_send_eapol(hapd->drv_priv, addr, data,
	168	data_len, encrypt,
4378fc14	169	hapd->own_addr, flags);
3acdf771 JM	170	}
3acdf771 JM	171
3acdf771 JM	172	static inline int hostapd_drv_read_sta_data(
	173	struct hostapd_data hapd, struct hostap_sta_driver_data data,
	174	const u8 *addr)
	175	{
	176	if (hapd->driver == NULL \|\| hapd->driver->read_sta_data == NULL)
	177	return -1;
	178	return hapd->driver->read_sta_data(hapd->drv_priv, data, addr);
	179	}
	180
	181	static inline int hostapd_drv_sta_clear_stats(struct hostapd_data *hapd,
	182	const u8 *addr)
	183	{
	184	if (hapd->driver == NULL \|\| hapd->driver->sta_clear_stats == NULL)
	185	return 0;
	186	return hapd->driver->sta_clear_stats(hapd->drv_priv, addr);
	187	}
	188
3c4ca363 VN	189	static inline int hostapd_drv_set_acl(struct hostapd_data *hapd,
	190	struct hostapd_acl_params *params)
	191	{
	192	if (hapd->driver == NULL \|\| hapd->driver->set_acl == NULL)
	193	return 0;
	194	return hapd->driver->set_acl(hapd->drv_priv, params);
	195	}
	196
19c3b566 JM	197	static inline int hostapd_drv_set_ap(struct hostapd_data *hapd,
19c3b566 JM	198	struct wpa_driver_ap_params *params)
3acdf771	199	{
19c3b566	200	if (hapd->driver == NULL \|\| hapd->driver->set_ap == NULL)
3acdf771	201	return 0;
19c3b566	202	return hapd->driver->set_ap(hapd->drv_priv, params);
3acdf771 JM	203	}
	204
	205	static inline int hostapd_drv_set_radius_acl_auth(struct hostapd_data *hapd,
	206	const u8 *mac, int accepted,
	207	u32 session_timeout)
	208	{
	209	if (hapd->driver == NULL \|\| hapd->driver->set_radius_acl_auth == NULL)
	210	return 0;
	211	return hapd->driver->set_radius_acl_auth(hapd->drv_priv, mac, accepted,
	212	session_timeout);
	213	}
	214
	215	static inline int hostapd_drv_set_radius_acl_expire(struct hostapd_data *hapd,
	216	const u8 *mac)
	217	{
	218	if (hapd->driver == NULL \|\|
	219	hapd->driver->set_radius_acl_expire == NULL)
	220	return 0;
	221	return hapd->driver->set_radius_acl_expire(hapd->drv_priv, mac);
	222	}
	223
41fd1d9e KZ	224	static inline int hostapd_drv_set_authmode(struct hostapd_data *hapd,
	225	int auth_algs)
	226	{
	227	if (hapd->driver == NULL \|\| hapd->driver->set_authmode == NULL)
	228	return 0;
	229	return hapd->driver->set_authmode(hapd->drv_priv, auth_algs);
	230	}
	231
bcf24348 JB	232	static inline void hostapd_drv_poll_client(struct hostapd_data *hapd,
	233	const u8 own_addr, const u8 addr,
	234	int qos)
	235	{
	236	if (hapd->driver == NULL \|\| hapd->driver->poll_client == NULL)
	237	return;
	238	hapd->driver->poll_client(hapd->drv_priv, own_addr, addr, qos);
	239	}
	240
0185007c MK	241	static inline int hostapd_drv_get_survey(struct hostapd_data *hapd,
	242	unsigned int freq)
	243	{
	244	if (hapd->driver == NULL)
	245	return -1;
	246	if (!hapd->driver->get_survey)
	247	return -1;
	248	return hapd->driver->get_survey(hapd->drv_priv, freq);
	249	}
	250
f0793bf1 JM	251	static inline int hostapd_get_country(struct hostapd_data hapd, char alpha2)
	252	{
	253	if (hapd->driver == NULL \|\| hapd->driver->get_country == NULL)
	254	return -1;
	255	return hapd->driver->get_country(hapd->drv_priv, alpha2);
	256	}
	257
2db938e8 JM	258	static inline const char * hostapd_drv_get_radio_name(struct hostapd_data *hapd)
	259	{
	260	if (hapd->driver == NULL \|\| hapd->drv_priv == NULL \|\|
	261	hapd->driver->get_radio_name == NULL)
	262	return NULL;
	263	return hapd->driver->get_radio_name(hapd->drv_priv);
	264	}
	265
bf281c12 AO	266	static inline int hostapd_drv_switch_channel(struct hostapd_data *hapd,
	267	struct csa_settings *settings)
	268	{
	269	if (hapd->driver == NULL \|\| hapd->driver->switch_channel == NULL)
	270	return -ENOTSUP;
	271
	272	return hapd->driver->switch_channel(hapd->drv_priv, settings);
	273	}
	274
f0cbb986 JM	275	static inline int hostapd_drv_status(struct hostapd_data hapd, char buf,
	276	size_t buflen)
	277	{
	278	if (hapd->driver == NULL \|\| hapd->driver->status == NULL)
	279	return -1;
	280	return hapd->driver->status(hapd->drv_priv, buf, buflen);
	281	}
	282
71103bed	283	static inline int hostapd_drv_br_add_ip_neigh(struct hostapd_data *hapd,
ed4ddb6d KP	284	int version, const u8 *ipaddr,
ed4ddb6d KP	285	int prefixlen, const u8 *addr)
71103bed KP	286	{
	287	if (hapd->driver == NULL \|\| hapd->drv_priv == NULL \|\|
	288	hapd->driver->br_add_ip_neigh == NULL)
	289	return -1;
ed4ddb6d KP	290	return hapd->driver->br_add_ip_neigh(hapd->drv_priv, version, ipaddr,
ed4ddb6d KP	291	prefixlen, addr);
71103bed KP	292	}
	293
	294	static inline int hostapd_drv_br_delete_ip_neigh(struct hostapd_data *hapd,
ed4ddb6d	295	u8 version, const u8 *ipaddr)
71103bed KP	296	{
	297	if (hapd->driver == NULL \|\| hapd->drv_priv == NULL \|\|
	298	hapd->driver->br_delete_ip_neigh == NULL)
	299	return -1;
ed4ddb6d KP	300	return hapd->driver->br_delete_ip_neigh(hapd->drv_priv, version,
ed4ddb6d KP	301	ipaddr);
71103bed KP	302	}
71103bed KP	303
73d2294f KP	304	static inline int hostapd_drv_br_port_set_attr(struct hostapd_data *hapd,
	305	enum drv_br_port_attr attr,
	306	unsigned int val)
	307	{
	308	if (hapd->driver == NULL \|\| hapd->drv_priv == NULL \|\|
	309	hapd->driver->br_port_set_attr == NULL)
	310	return -1;
	311	return hapd->driver->br_port_set_attr(hapd->drv_priv, attr, val);
	312	}
	313
7565752d KP	314	static inline int hostapd_drv_br_set_net_param(struct hostapd_data *hapd,
	315	enum drv_br_net_param param,
	316	unsigned int val)
	317	{
	318	if (hapd->driver == NULL \|\| hapd->drv_priv == NULL \|\|
	319	hapd->driver->br_set_net_param == NULL)
	320	return -1;
	321	return hapd->driver->br_set_net_param(hapd->drv_priv, param, val);
	322	}
	323
3ae8b7b7 AS	324	static inline int hostapd_drv_vendor_cmd(struct hostapd_data *hapd,
	325	int vendor_id, int subcmd,
	326	const u8 *data, size_t data_len,
	327	struct wpabuf *buf)
	328	{
	329	if (hapd->driver == NULL \|\| hapd->driver->vendor_cmd == NULL)
	330	return -1;
	331	return hapd->driver->vendor_cmd(hapd->drv_priv, vendor_id, subcmd, data,
	332	data_len, buf);
	333	}
	334
a4f21109	335	#endif /* AP_DRV_OPS */