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 */
21static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
22				  const char *ifname)
23{
24	if (wpa_s->driver->init2)
25		return wpa_s->driver->init2(wpa_s, ifname,
26					    wpa_s->global_drv_priv);
27	if (wpa_s->driver->init) {
28		return wpa_s->driver->init(wpa_s, ifname);
29	}
30	return NULL;
31}
32
33static 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
39static 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
47static 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
57static 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
65static 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
74static 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);
79	return -1;
80}
81
82static 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
90static 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
98static 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
106static 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,
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;
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);
117	}
118	return -1;
119}
120
121static 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
131static 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
141static 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
150static 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
160static 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
168static 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
177static 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
184static 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
192static 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
200static 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
210static 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
218static 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
229static inline struct hostapd_hw_modes *
230wpa_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
239static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
240				      enum hostapd_hw_mode phymode, int chan,
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
249static 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
259static 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
268static 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
276static 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
285static 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
295static 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
303static 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
313static 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
323static 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,
326				     int dtim_period, int beacon_int)
327{
328	if (wpa_s->driver->set_beacon)
329		return wpa_s->driver->set_beacon(wpa_s->drv_priv, head,
330						 head_len, tail, tail_len,
331						 dtim_period, beacon_int);
332	return -1;
333}
334
335static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
336				  struct hostapd_sta_add_params *params)
337{
338	if (wpa_s->driver->sta_add)
339		return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
340	return -1;
341}
342
343static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
344				     const u8 *addr)
345{
346	if (wpa_s->driver->sta_remove)
347		return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
348	return -1;
349}
350
351static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
352					  const u8 *addr, const u8 *data,
353					  size_t data_len, int encrypt,
354					  const u8 *own_addr)
355{
356	if (wpa_s->driver->hapd_send_eapol)
357		return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
358						      data, data_len, encrypt,
359						      own_addr);
360	return -1;
361}
362
363static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
364					const u8 *addr, int total_flags,
365					int flags_or, int flags_and)
366{
367	if (wpa_s->driver->sta_set_flags)
368		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
369						    total_flags, flags_or,
370						    flags_and);
371	return -1;
372}
373
374static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
375					int authorized)
376{
377	if (wpa_s->driver->set_supp_port) {
378		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
379						    authorized);
380	}
381	return 0;
382}
383
384static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
385				      unsigned int freq,
386				      const u8 *dst, const u8 *src,
387				      const u8 *bssid,
388				      const u8 *data, size_t data_len)
389{
390	if (wpa_s->driver->send_action)
391		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
392						  dst, src, bssid, data,
393						  data_len);
394	return -1;
395}
396
397static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
398				 enum wpa_driver_if_type type,
399				 const char *ifname, const u8 *addr,
400				 void *bss_ctx, char *force_ifname,
401				 u8 *if_addr)
402{
403	if (wpa_s->driver->if_add)
404		return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
405					     addr, bss_ctx, NULL, force_ifname,
406					     if_addr);
407	return -1;
408}
409
410static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
411				    enum wpa_driver_if_type type,
412				    const char *ifname)
413{
414	if (wpa_s->driver->if_remove)
415		return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
416	return -1;
417}
418
419static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
420					    unsigned int freq,
421					    unsigned int duration)
422{
423	if (wpa_s->driver->remain_on_channel)
424		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
425							duration);
426	return -1;
427}
428
429static inline int wpa_drv_cancel_remain_on_channel(
430	struct wpa_supplicant *wpa_s)
431{
432	if (wpa_s->driver->cancel_remain_on_channel)
433		return wpa_s->driver->cancel_remain_on_channel(
434			wpa_s->drv_priv);
435	return -1;
436}
437
438static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
439					   int report)
440{
441	if (wpa_s->driver->probe_req_report)
442		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
443						       report);
444	return -1;
445}
446
447static inline int wpa_drv_disable_11b_rates(struct wpa_supplicant *wpa_s,
448					    int disabled)
449{
450	if (wpa_s->driver->disable_11b_rates)
451		return wpa_s->driver->disable_11b_rates(wpa_s->drv_priv,
452							disabled);
453	return -1;
454}
455
456static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
457{
458	if (wpa_s->driver->deinit_ap)
459		return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
460	return 0;
461}
462
463static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
464{
465	if (wpa_s->driver->suspend)
466		wpa_s->driver->suspend(wpa_s->drv_priv);
467}
468
469static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
470{
471	if (wpa_s->driver->resume)
472		wpa_s->driver->resume(wpa_s->drv_priv);
473}
474
475static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
476					 int threshold, int hysteresis)
477{
478	if (wpa_s->driver->signal_monitor)
479		return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
480						     threshold, hysteresis);
481	return -1;
482}
483
484static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
485					const struct wpabuf *beacon,
486					const struct wpabuf *proberesp)
487{
488	if (!wpa_s->driver->set_ap_wps_ie)
489		return -1;
490	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
491					    proberesp);
492}
493
494#endif /* DRIVER_I_H */
495