[thirdparty/hostap.git] / wpa_supplicant / driver_i.h

/*
 * wpa_supplicant - Internal driver interface wrappers
 * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#ifndef DRIVER_I_H
#define DRIVER_I_H

#include "drivers/driver.h"

/* driver_ops */
static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
				  const char *ifname)
{
	if (wpa_s->driver->init2)
		return wpa_s->driver->init2(wpa_s, ifname,
					    wpa_s->global_drv_priv);
	if (wpa_s->driver->init) {
		return wpa_s->driver->init(wpa_s, ifname);
	}
	return NULL;
}

static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->deinit)
		wpa_s->driver->deinit(wpa_s->drv_priv);
}

static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
				    const char *param)
{
	if (wpa_s->driver->set_param)
		return wpa_s->driver->set_param(wpa_s->drv_priv, param);
	return 0;
}

static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
					      int enabled)
{
	if (wpa_s->driver->set_countermeasures) {
		return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
							  enabled);
	}
	return -1;
}

static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
				       struct wpa_driver_auth_params *params)
{
	if (wpa_s->driver->authenticate)
		return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
	return -1;
}

static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
				    struct wpa_driver_associate_params *params)
{
	if (wpa_s->driver->associate) {
		return wpa_s->driver->associate(wpa_s->drv_priv, params);
	}
	return -1;
}

static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
			       struct wpa_driver_scan_params *params)
{
	if (wpa_s->driver->scan2)
		return wpa_s->driver->scan2(wpa_s->drv_priv, params);
	return -1;
}

static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
	struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->get_scan_results2)
		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
	return NULL;
}

static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
{
	if (wpa_s->driver->get_bssid) {
		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
	}
	return -1;
}

static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
{
	if (wpa_s->driver->get_ssid) {
		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
	}
	return -1;
}

static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
				  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)
{
	if (wpa_s->driver->set_key) {
		wpa_s->keys_cleared = 0;
		return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
					      alg, addr, key_idx, set_tx,
					      seq, seq_len, key, key_len);
	}
	return -1;
}

static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
					 const u8 *addr, int reason_code)
{
	if (wpa_s->driver->deauthenticate) {
		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
						     reason_code);
	}
	return -1;
}

static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
				       const u8 *addr, int reason_code)
{
	if (wpa_s->driver->disassociate) {
		return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
						   reason_code);
	}
	return -1;
}

static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
				    const u8 *bssid, const u8 *pmkid)
{
	if (wpa_s->driver->add_pmkid) {
		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
	}
	return -1;
}

static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
				       const u8 *bssid, const u8 *pmkid)
{
	if (wpa_s->driver->remove_pmkid) {
		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
						   pmkid);
	}
	return -1;
}

static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->flush_pmkid) {
		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
	}
	return -1;
}

static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
				   struct wpa_driver_capa *capa)
{
	if (wpa_s->driver->get_capa) {
		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
	}
	return -1;
}

static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->poll) {
		wpa_s->driver->poll(wpa_s->drv_priv);
	}
}

static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->get_ifname) {
		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
	}
	return NULL;
}

static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->get_mac_addr) {
		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
	}
	return NULL;
}

static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
				     const u8 *dst, u16 proto,
				     const u8 *data, size_t data_len)
{
	if (wpa_s->driver->send_eapol)
		return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
						 data, data_len);
	return -1;
}

static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
					int state)
{
	if (wpa_s->driver->set_operstate)
		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
	return 0;
}

static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
					     const u8 *addr, int protect_type,
					     int key_type)
{
	if (wpa_s->driver->mlme_setprotection)
		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
							 protect_type,
							 key_type);
	return 0;
}

static inline struct hostapd_hw_modes *
wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
			    u16 *flags)
{
	if (wpa_s->driver->get_hw_feature_data)
		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
							  num_modes, flags);
	return NULL;
}

static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
				      enum hostapd_hw_mode phymode, int chan,
				      int freq)
{
	if (wpa_s->driver->set_channel)
		return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
						  chan, freq);
	return -1;
}

static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
				   const u8 *ssid, size_t ssid_len)
{
	if (wpa_s->driver->set_ssid) {
		return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
					       ssid_len);
	}
	return -1;
}

static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
				    const u8 *bssid)
{
	if (wpa_s->driver->set_bssid) {
		return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
	}
	return -1;
}

static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
				      const char *alpha2)
{
	if (wpa_s->driver->set_country)
		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
	return 0;
}

static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
				    const u8 *data, size_t data_len)
{
	if (wpa_s->driver->send_mlme)
		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
						data, data_len);
	return -1;
}

static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
				       const u8 *addr, const u8 *supp_rates,
				       size_t supp_rates_len)
{
	if (wpa_s->driver->mlme_add_sta)
		return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
						   supp_rates, supp_rates_len);
	return -1;
}

static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
					  const u8 *addr)
{
	if (wpa_s->driver->mlme_remove_sta)
		return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
	return -1;
}

static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
					const u8 *md,
					const u8 *ies, size_t ies_len)
{
	if (wpa_s->driver->update_ft_ies)
		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
						    ies, ies_len);
	return -1;
}

static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
					 u8 action, const u8 *target_ap,
					 const u8 *ies, size_t ies_len)
{
	if (wpa_s->driver->send_ft_action)
		return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
						     target_ap, ies, ies_len);
	return -1;
}

static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
				     const u8 *head, size_t head_len,
				     const u8 *tail, size_t tail_len,
				     int dtim_period, int beacon_int)
{
	if (wpa_s->driver->set_beacon)
		return wpa_s->driver->set_beacon(wpa_s->ifname,
						 wpa_s->drv_priv, head,
						 head_len, tail, tail_len,
						 dtim_period, beacon_int);
	return -1;
}

static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
				  struct hostapd_sta_add_params *params)
{
	if (wpa_s->driver->sta_add)
		return wpa_s->driver->sta_add(wpa_s->ifname, wpa_s->drv_priv,
					      params);
	return -1;
}

static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
				     const u8 *addr)
{
	if (wpa_s->driver->sta_remove)
		return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
	return -1;
}

static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
					  const u8 *addr, const u8 *data,
					  size_t data_len, int encrypt,
					  const u8 *own_addr)
{
	if (wpa_s->driver->hapd_send_eapol)
		return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
						      data, data_len, encrypt,
						      own_addr);
	return -1;
}

static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
					const u8 *addr, int total_flags,
					int flags_or, int flags_and)
{
	if (wpa_s->driver->sta_set_flags)
		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
						    total_flags, flags_or,
						    flags_and);
	return -1;
}

static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
					int authorized)
{
	if (wpa_s->driver->set_supp_port) {
		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
						    authorized);
	}
	return 0;
}

static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
				      unsigned int freq,
				      const u8 *dst, const u8 *src,
				      const u8 *data, size_t data_len)
{
	if (wpa_s->driver->send_action)
		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
						  dst, src, data, data_len);
	return -1;
}

static inline int wpa_drv_alloc_interface_addr(struct wpa_supplicant *wpa_s,
					       u8 *addr)
{
	if (wpa_s->driver->alloc_interface_addr)
		return wpa_s->driver->alloc_interface_addr(wpa_s->drv_priv,
							   addr);
	return -1;
}

static inline void wpa_drv_release_interface_addr(struct wpa_supplicant *wpa_s,
						  const u8 *addr)
{
	if (wpa_s->driver->release_interface_addr)
		wpa_s->driver->release_interface_addr(wpa_s->drv_priv, addr);
}

static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
					    unsigned int freq,
					    unsigned int duration)
{
	if (wpa_s->driver->remain_on_channel)
		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
							duration);
	return -1;
}

static inline int wpa_drv_cancel_remain_on_channel(
	struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->cancel_remain_on_channel)
		return wpa_s->driver->cancel_remain_on_channel(
			wpa_s->drv_priv);
	return -1;
}

static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
					   int report)
{
	if (wpa_s->driver->probe_req_report)
		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
						       report);
	return -1;
}

#endif /* DRIVER_I_H */
Commit	Line	Data
2d5b792d JM	1	/*
	2	* wpa_supplicant - Internal driver interface wrappers
	3	* Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* Alternatively, this software may be distributed under the terms of BSD
	10	* license.
	11	*
	12	* See README and COPYING for more details.
	13	*/
	14
	15	#ifndef DRIVER_I_H
	16	#define DRIVER_I_H
	17
	18	#include "drivers/driver.h"
	19
	20	/* driver_ops */
	21	static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
	22	const char *ifname)
	23	{
	24	if (wpa_s->driver->init2)
8a5ab9f5 JM	25	return wpa_s->driver->init2(wpa_s, ifname,
8a5ab9f5 JM	26	wpa_s->global_drv_priv);
2d5b792d JM	27	if (wpa_s->driver->init) {
	28	return wpa_s->driver->init(wpa_s, ifname);
	29	}
	30	return NULL;
	31	}
	32
	33	static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
	34	{
	35	if (wpa_s->driver->deinit)
	36	wpa_s->driver->deinit(wpa_s->drv_priv);
	37	}
	38
	39	static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
	40	const char *param)
	41	{
	42	if (wpa_s->driver->set_param)
	43	return wpa_s->driver->set_param(wpa_s->drv_priv, param);
	44	return 0;
	45	}
	46
2d5b792d JM	47	static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
	48	int enabled)
	49	{
	50	if (wpa_s->driver->set_countermeasures) {
	51	return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
	52	enabled);
	53	}
	54	return -1;
	55	}
	56
2d5b792d JM	57	static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
	58	struct wpa_driver_auth_params *params)
	59	{
	60	if (wpa_s->driver->authenticate)
	61	return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
	62	return -1;
	63	}
	64
	65	static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
	66	struct wpa_driver_associate_params *params)
	67	{
	68	if (wpa_s->driver->associate) {
	69	return wpa_s->driver->associate(wpa_s->drv_priv, params);
	70	}
	71	return -1;
	72	}
	73
	74	static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
	75	struct wpa_driver_scan_params *params)
	76	{
	77	if (wpa_s->driver->scan2)
	78	return wpa_s->driver->scan2(wpa_s->drv_priv, params);
2d5b792d JM	79	return -1;
	80	}
	81
2d5b792d JM	82	static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
	83	struct wpa_supplicant *wpa_s)
	84	{
	85	if (wpa_s->driver->get_scan_results2)
	86	return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
	87	return NULL;
	88	}
	89
	90	static inline int wpa_drv_get_bssid(struct wpa_supplicant wpa_s, u8 bssid)
	91	{
	92	if (wpa_s->driver->get_bssid) {
	93	return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
	94	}
	95	return -1;
	96	}
	97
	98	static inline int wpa_drv_get_ssid(struct wpa_supplicant wpa_s, u8 ssid)
	99	{
	100	if (wpa_s->driver->get_ssid) {
	101	return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
	102	}
	103	return -1;
	104	}
	105
71934751 JM	106	static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
	107	enum wpa_alg alg, const u8 *addr,
	108	int key_idx, int set_tx,
2d5b792d JM	109	const u8 *seq, size_t seq_len,
	110	const u8 *key, size_t key_len)
	111	{
	112	if (wpa_s->driver->set_key) {
	113	wpa_s->keys_cleared = 0;
642187d6 JM	114	return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
	115	alg, addr, key_idx, set_tx,
	116	seq, seq_len, key, key_len);
2d5b792d JM	117	}
	118	return -1;
	119	}
	120
	121	static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
	122	const u8 *addr, int reason_code)
	123	{
	124	if (wpa_s->driver->deauthenticate) {
	125	return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
	126	reason_code);
	127	}
	128	return -1;
	129	}
	130
	131	static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
	132	const u8 *addr, int reason_code)
	133	{
	134	if (wpa_s->driver->disassociate) {
	135	return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
	136	reason_code);
	137	}
	138	return -1;
	139	}
	140
	141	static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
	142	const u8 bssid, const u8 pmkid)
	143	{
	144	if (wpa_s->driver->add_pmkid) {
	145	return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
	146	}
	147	return -1;
	148	}
	149
	150	static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
	151	const u8 bssid, const u8 pmkid)
	152	{
	153	if (wpa_s->driver->remove_pmkid) {
	154	return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
	155	pmkid);
	156	}
	157	return -1;
	158	}
	159
	160	static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
	161	{
	162	if (wpa_s->driver->flush_pmkid) {
	163	return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
	164	}
	165	return -1;
	166	}
	167
	168	static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
	169	struct wpa_driver_capa *capa)
	170	{
	171	if (wpa_s->driver->get_capa) {
	172	return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
	173	}
	174	return -1;
	175	}
	176
	177	static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
	178	{
	179	if (wpa_s->driver->poll) {
	180	wpa_s->driver->poll(wpa_s->drv_priv);
181	}
182	}
183
184	static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
185	{
186	if (wpa_s->driver->get_ifname) {
187	return wpa_s->driver->get_ifname(wpa_s->drv_priv);
188	}
189	return NULL;
190	}
191
192	static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
193	{
194	if (wpa_s->driver->get_mac_addr) {
195	return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
196	}
197	return NULL;
198	}
199
200	static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
201	const u8 *dst, u16 proto,
202	const u8 *data, size_t data_len)
203	{
204	if (wpa_s->driver->send_eapol)
205	return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
206	data, data_len);
207	return -1;
208	}
209
210	static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
211	int state)
212	{
213	if (wpa_s->driver->set_operstate)
214	return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
215	return 0;
216	}
217
218	static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
219	const u8 *addr, int protect_type,
220	int key_type)
221	{
222	if (wpa_s->driver->mlme_setprotection)
223	return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
224	protect_type,
225	key_type);
226	return 0;
227	}
228
6caf9ca6	229	static inline struct hostapd_hw_modes *
2d5b792d JM	230	wpa_drv_get_hw_feature_data(struct wpa_supplicant wpa_s, u16 num_modes,
	231	u16 *flags)
	232	{
	233	if (wpa_s->driver->get_hw_feature_data)
	234	return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
	235	num_modes, flags);
	236	return NULL;
	237	}
	238
	239	static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
71934751	240	enum hostapd_hw_mode phymode, int chan,
2d5b792d JM	241	int freq)
	242	{
	243	if (wpa_s->driver->set_channel)
	244	return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
	245	chan, freq);
	246	return -1;
	247	}
	248
	249	static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
	250	const u8 *ssid, size_t ssid_len)
	251	{
	252	if (wpa_s->driver->set_ssid) {
	253	return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
	254	ssid_len);
	255	}
	256	return -1;
	257	}
	258
	259	static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
	260	const u8 *bssid)
	261	{
	262	if (wpa_s->driver->set_bssid) {
	263	return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
	264	}
	265	return -1;
	266	}
	267
	268	static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
	269	const char *alpha2)
	270	{
	271	if (wpa_s->driver->set_country)
	272	return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
	273	return 0;
	274	}
	275
	276	static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
	277	const u8 *data, size_t data_len)
	278	{
	279	if (wpa_s->driver->send_mlme)
	280	return wpa_s->driver->send_mlme(wpa_s->drv_priv,
	281	data, data_len);
	282	return -1;
	283	}
	284
	285	static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
	286	const u8 addr, const u8 supp_rates,
	287	size_t supp_rates_len)
	288	{
	289	if (wpa_s->driver->mlme_add_sta)
	290	return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
	291	supp_rates, supp_rates_len);
	292	return -1;
	293	}
	294
	295	static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
	296	const u8 *addr)
	297	{
	298	if (wpa_s->driver->mlme_remove_sta)
	299	return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
	300	return -1;
	301	}
	302
	303	static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
	304	const u8 *md,
305	const u8 *ies, size_t ies_len)
306	{
307	if (wpa_s->driver->update_ft_ies)
308	return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
309	ies, ies_len);
310	return -1;
311	}
312
313	static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
314	u8 action, const u8 *target_ap,
315	const u8 *ies, size_t ies_len)
316	{
317	if (wpa_s->driver->send_ft_action)
318	return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
319	target_ap, ies, ies_len);
320	return -1;
321	}
322
d2440ba0 JM	323	static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
	324	const u8 *head, size_t head_len,
	325	const u8 *tail, size_t tail_len,
5d674872	326	int dtim_period, int beacon_int)
d2440ba0 JM	327	{
d2440ba0 JM	328	if (wpa_s->driver->set_beacon)
5d674872 JM	329	return wpa_s->driver->set_beacon(wpa_s->ifname,
5d674872 JM	330	wpa_s->drv_priv, head,
d2440ba0	331	head_len, tail, tail_len,
5d674872	332	dtim_period, beacon_int);
d2440ba0 JM	333	return -1;
	334	}
	335
0f4e8b4f JM	336	static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
	337	struct hostapd_sta_add_params *params)
	338	{
	339	if (wpa_s->driver->sta_add)
	340	return wpa_s->driver->sta_add(wpa_s->ifname, wpa_s->drv_priv,
	341	params);
	342	return -1;
	343	}
	344
	345	static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
	346	const u8 *addr)
	347	{
	348	if (wpa_s->driver->sta_remove)
	349	return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
	350	return -1;
	351	}
	352
db149ac9 JM	353	static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
	354	const u8 addr, const u8 data,
	355	size_t data_len, int encrypt,
	356	const u8 *own_addr)
	357	{
	358	if (wpa_s->driver->hapd_send_eapol)
	359	return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
	360	data, data_len, encrypt,
	361	own_addr);
	362	return -1;
	363	}
	364
a8d6ffa4 JM	365	static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
	366	const u8 *addr, int total_flags,
	367	int flags_or, int flags_and)
	368	{
	369	if (wpa_s->driver->sta_set_flags)
	370	return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
	371	total_flags, flags_or,
	372	flags_and);
	373	return -1;
	374	}
	375
4bc181ec JM	376	static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
	377	int authorized)
	378	{
	379	if (wpa_s->driver->set_supp_port) {
	380	return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
	381	authorized);
	382	}
	383	return 0;
	384	}
	385
55777702 JM	386	static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
	387	unsigned int freq,
	388	const u8 dst, const u8 src,
	389	const u8 *data, size_t data_len)
	390	{
	391	if (wpa_s->driver->send_action)
	392	return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
	393	dst, src, data, data_len);
	394	return -1;
	395	}
	396
7bfc47c3 JM	397	static inline int wpa_drv_alloc_interface_addr(struct wpa_supplicant *wpa_s,
	398	u8 *addr)
	399	{
	400	if (wpa_s->driver->alloc_interface_addr)
	401	return wpa_s->driver->alloc_interface_addr(wpa_s->drv_priv,
	402	addr);
	403	return -1;
	404	}
	405
	406	static inline void wpa_drv_release_interface_addr(struct wpa_supplicant *wpa_s,
	407	const u8 *addr)
	408	{
	409	if (wpa_s->driver->release_interface_addr)
	410	wpa_s->driver->release_interface_addr(wpa_s->drv_priv, addr);
	411	}
	412
55777702 JM	413	static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
	414	unsigned int freq,
	415	unsigned int duration)
	416	{
	417	if (wpa_s->driver->remain_on_channel)
	418	return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
	419	duration);
	420	return -1;
	421	}
	422
	423	static inline int wpa_drv_cancel_remain_on_channel(
	424	struct wpa_supplicant *wpa_s)
	425	{
	426	if (wpa_s->driver->cancel_remain_on_channel)
	427	return wpa_s->driver->cancel_remain_on_channel(
	428	wpa_s->drv_priv);
	429	return -1;
	430	}
	431
504e905c JM	432	static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
	433	int report)
	434	{
	435	if (wpa_s->driver->probe_req_report)
	436	return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
	437	report);
	438	return -1;
	439	}
	440
2d5b792d	441	#endif /* DRIVER_I_H */