driver_i.h revision fb79edc9df1f20461e90e478363d207348213d35 
1/*
2 * wpa_supplicant - Internal driver interface wrappers
3 * Copyright (c) 2003-2009, 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#ifndef DRIVER_I_H
10#define DRIVER_I_H
11
12#include "drivers/driver.h"
13
14/* driver_ops */
15static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
16				  const char *ifname)
17{
18	if (wpa_s->driver->init2)
19		return wpa_s->driver->init2(wpa_s, ifname,
20					    wpa_s->global_drv_priv);
21	if (wpa_s->driver->init) {
22		return wpa_s->driver->init(wpa_s, ifname);
23	}
24	return NULL;
25}
26
27static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
28{
29	if (wpa_s->driver->deinit)
30		wpa_s->driver->deinit(wpa_s->drv_priv);
31}
32
33static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
34				    const char *param)
35{
36	if (wpa_s->driver->set_param)
37		return wpa_s->driver->set_param(wpa_s->drv_priv, param);
38	return 0;
39}
40
41static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
42					      int enabled)
43{
44	if (wpa_s->driver->set_countermeasures) {
45		return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
46							  enabled);
47	}
48	return -1;
49}
50
51static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
52				       struct wpa_driver_auth_params *params)
53{
54	if (wpa_s->driver->authenticate)
55		return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
56	return -1;
57}
58
59static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
60				    struct wpa_driver_associate_params *params)
61{
62	if (wpa_s->driver->associate) {
63		return wpa_s->driver->associate(wpa_s->drv_priv, params);
64	}
65	return -1;
66}
67
68static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
69			       struct wpa_driver_scan_params *params)
70{
71	if (wpa_s->driver->scan2)
72		return wpa_s->driver->scan2(wpa_s->drv_priv, params);
73	return -1;
74}
75
76static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
77				     struct wpa_driver_scan_params *params,
78				     u32 interval)
79{
80	if (wpa_s->driver->sched_scan)
81		return wpa_s->driver->sched_scan(wpa_s->drv_priv,
82						 params, interval);
83	return -1;
84}
85
86static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
87{
88	if (wpa_s->driver->stop_sched_scan)
89		return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
90	return -1;
91}
92
93static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
94	struct wpa_supplicant *wpa_s)
95{
96	if (wpa_s->driver->get_scan_results2)
97		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
98	return NULL;
99}
100
101static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
102{
103	if (wpa_s->driver->get_bssid) {
104		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
105	}
106	return -1;
107}
108
109static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
110{
111	if (wpa_s->driver->get_ssid) {
112		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
113	}
114	return -1;
115}
116
117static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
118				  enum wpa_alg alg, const u8 *addr,
119				  int key_idx, int set_tx,
120				  const u8 *seq, size_t seq_len,
121				  const u8 *key, size_t key_len)
122{
123	if (alg != WPA_ALG_NONE) {
124		if (key_idx >= 0 && key_idx <= 6)
125			wpa_s->keys_cleared &= ~BIT(key_idx);
126		else
127			wpa_s->keys_cleared = 0;
128	}
129	if (wpa_s->driver->set_key) {
130		return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
131					      alg, addr, key_idx, set_tx,
132					      seq, seq_len, key, key_len);
133	}
134	return -1;
135}
136
137static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
138				     const u8 *addr, int reason_code)
139{
140	if (wpa_s->driver->sta_deauth) {
141		return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
142						 wpa_s->own_addr, addr,
143						 reason_code);
144	}
145	return -1;
146}
147
148static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
149					 const u8 *addr, int reason_code)
150{
151	if (wpa_s->driver->deauthenticate) {
152		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
153						     reason_code);
154	}
155	return -1;
156}
157
158static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
159				    const u8 *bssid, const u8 *pmkid)
160{
161	if (wpa_s->driver->add_pmkid) {
162		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
163	}
164	return -1;
165}
166
167static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
168				       const u8 *bssid, const u8 *pmkid)
169{
170	if (wpa_s->driver->remove_pmkid) {
171		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
172						   pmkid);
173	}
174	return -1;
175}
176
177static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
178{
179	if (wpa_s->driver->flush_pmkid) {
180		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
181	}
182	return -1;
183}
184
185static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
186				   struct wpa_driver_capa *capa)
187{
188	if (wpa_s->driver->get_capa) {
189		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
190	}
191	return -1;
192}
193
194static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
195{
196	if (wpa_s->driver->poll) {
197		wpa_s->driver->poll(wpa_s->drv_priv);
198	}
199}
200
201static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
202{
203	if (wpa_s->driver->get_ifname) {
204		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
205	}
206	return NULL;
207}
208
209static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
210{
211	if (wpa_s->driver->get_mac_addr) {
212		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
213	}
214	return NULL;
215}
216
217static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
218				     const u8 *dst, u16 proto,
219				     const u8 *data, size_t data_len)
220{
221	if (wpa_s->driver->send_eapol)
222		return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
223						 data, data_len);
224	return -1;
225}
226
227static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
228					int state)
229{
230	if (wpa_s->driver->set_operstate)
231		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
232	return 0;
233}
234
235static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
236					     const u8 *addr, int protect_type,
237					     int key_type)
238{
239	if (wpa_s->driver->mlme_setprotection)
240		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
241							 protect_type,
242							 key_type);
243	return 0;
244}
245
246static inline struct hostapd_hw_modes *
247wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
248			    u16 *flags)
249{
250	if (wpa_s->driver->get_hw_feature_data)
251		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
252							  num_modes, flags);
253	return NULL;
254}
255
256static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
257				      const char *alpha2)
258{
259	if (wpa_s->driver->set_country)
260		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
261	return 0;
262}
263
264static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
265				    const u8 *data, size_t data_len, int noack)
266{
267	if (wpa_s->driver->send_mlme)
268		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
269						data, data_len, noack);
270	return -1;
271}
272
273static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
274					const u8 *md,
275					const u8 *ies, size_t ies_len)
276{
277	if (wpa_s->driver->update_ft_ies)
278		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
279						    ies, ies_len);
280	return -1;
281}
282
283static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
284					 u8 action, const u8 *target_ap,
285					 const u8 *ies, size_t ies_len)
286{
287	if (wpa_s->driver->send_ft_action)
288		return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
289						     target_ap, ies, ies_len);
290	return -1;
291}
292
293static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
294				 struct wpa_driver_ap_params *params)
295{
296	if (wpa_s->driver->set_ap)
297		return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
298	return -1;
299}
300
301static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
302				  struct hostapd_sta_add_params *params)
303{
304	if (wpa_s->driver->sta_add)
305		return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
306	return -1;
307}
308
309static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
310				     const u8 *addr)
311{
312	if (wpa_s->driver->sta_remove)
313		return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
314	return -1;
315}
316
317static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
318					  const u8 *addr, const u8 *data,
319					  size_t data_len, int encrypt,
320					  const u8 *own_addr, u32 flags)
321{
322	if (wpa_s->driver->hapd_send_eapol)
323		return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
324						      data, data_len, encrypt,
325						      own_addr, flags);
326	return -1;
327}
328
329static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
330					const u8 *addr, int total_flags,
331					int flags_or, int flags_and)
332{
333	if (wpa_s->driver->sta_set_flags)
334		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
335						    total_flags, flags_or,
336						    flags_and);
337	return -1;
338}
339
340static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
341					int authorized)
342{
343	if (wpa_s->driver->set_supp_port) {
344		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
345						    authorized);
346	}
347	return 0;
348}
349
350static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
351				      unsigned int freq,
352				      unsigned int wait,
353				      const u8 *dst, const u8 *src,
354				      const u8 *bssid,
355				      const u8 *data, size_t data_len,
356				      int no_cck)
357{
358	if (wpa_s->driver->send_action)
359		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
360						  wait, dst, src, bssid,
361						  data, data_len, no_cck);
362	return -1;
363}
364
365static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
366{
367	if (wpa_s->driver->send_action_cancel_wait)
368		wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
369}
370
371static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
372				   struct hostapd_freq_params *freq)
373{
374	if (wpa_s->driver->set_freq)
375		return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
376	return -1;
377}
378
379static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
380				 enum wpa_driver_if_type type,
381				 const char *ifname, const u8 *addr,
382				 void *bss_ctx, char *force_ifname,
383				 u8 *if_addr, const char *bridge)
384{
385	if (wpa_s->driver->if_add)
386		return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
387					     addr, bss_ctx, NULL, force_ifname,
388					     if_addr, bridge, 0);
389	return -1;
390}
391
392static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
393				    enum wpa_driver_if_type type,
394				    const char *ifname)
395{
396	if (wpa_s->driver->if_remove)
397		return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
398	return -1;
399}
400
401static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
402					    unsigned int freq,
403					    unsigned int duration)
404{
405	if (wpa_s->driver->remain_on_channel)
406		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
407							duration);
408	return -1;
409}
410
411static inline int wpa_drv_cancel_remain_on_channel(
412	struct wpa_supplicant *wpa_s)
413{
414	if (wpa_s->driver->cancel_remain_on_channel)
415		return wpa_s->driver->cancel_remain_on_channel(
416			wpa_s->drv_priv);
417	return -1;
418}
419
420static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
421					   int report)
422{
423	if (wpa_s->driver->probe_req_report)
424		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
425						       report);
426	return -1;
427}
428
429static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
430{
431	if (wpa_s->driver->deinit_ap)
432		return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
433	return 0;
434}
435
436static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
437{
438	if (wpa_s->driver->deinit_p2p_cli)
439		return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
440	return 0;
441}
442
443static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
444{
445	if (wpa_s->driver->suspend)
446		wpa_s->driver->suspend(wpa_s->drv_priv);
447}
448
449static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
450{
451	if (wpa_s->driver->resume)
452		wpa_s->driver->resume(wpa_s->drv_priv);
453}
454
455static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
456					 int threshold, int hysteresis)
457{
458	if (wpa_s->driver->signal_monitor)
459		return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
460						     threshold, hysteresis);
461	return -1;
462}
463
464static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
465				      struct wpa_signal_info *si)
466{
467	if (wpa_s->driver->signal_poll)
468		return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
469	return -1;
470}
471
472static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
473				      struct hostap_sta_driver_data *sta)
474{
475	if (wpa_s->driver->read_sta_data)
476		return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
477						    wpa_s->bssid);
478	return -1;
479}
480
481static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
482					const struct wpabuf *beacon,
483					const struct wpabuf *proberesp,
484					const struct wpabuf *assocresp)
485{
486	if (!wpa_s->driver->set_ap_wps_ie)
487		return -1;
488	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
489					    proberesp, assocresp);
490}
491
492static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
493{
494	if (!wpa_s->driver->shared_freq)
495		return -1;
496	return wpa_s->driver->shared_freq(wpa_s->drv_priv);
497}
498
499static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
500				  u8 *buf, size_t buf_len)
501{
502	if (!wpa_s->driver->get_noa)
503		return -1;
504	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
505}
506
507static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
508					    int legacy_ps, int opp_ps,
509					    int ctwindow)
510{
511	if (!wpa_s->driver->set_p2p_powersave)
512		return -1;
513	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
514						opp_ps, ctwindow);
515}
516
517static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
518{
519	if (!wpa_s->driver->ampdu)
520		return -1;
521	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
522}
523
524static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
525					 const u8 *dst, u8 action_code,
526					 u8 dialog_token, u16 status_code,
527					 const u8 *buf, size_t len)
528{
529	if (wpa_s->driver->send_tdls_mgmt) {
530		return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
531						     action_code, dialog_token,
532						     status_code, buf, len);
533	}
534	return -1;
535}
536
537static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
538				    enum tdls_oper oper, const u8 *peer)
539{
540	if (!wpa_s->driver->tdls_oper)
541		return -1;
542	return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
543}
544
545#ifdef ANDROID
546static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
547				     char *cmd, char *buf, size_t buf_len)
548{
549	if (!wpa_s->driver->driver_cmd)
550		return -1;
551	return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
552}
553#endif /* ANDROID */
554
555static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
556					  const u8 *kek, const u8 *kck,
557					  const u8 *replay_ctr)
558{
559	if (!wpa_s->driver->set_rekey_info)
560		return;
561	wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
562}
563
564static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
565					int disabled)
566{
567	if (!wpa_s->driver->radio_disable)
568		return -1;
569	return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
570}
571
572static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
573					 struct csa_settings *settings)
574{
575	if (!wpa_s->driver->switch_channel)
576		return -1;
577	return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
578}
579
580static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
581				   enum wnm_oper oper, const u8 *peer,
582				   u8 *buf, u16 *buf_len)
583{
584	if (!wpa_s->driver->wnm_oper)
585		return -1;
586	return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
587				       buf_len);
588}
589
590static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
591				 char *buf, size_t buflen)
592{
593	if (!wpa_s->driver->status)
594		return -1;
595	return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
596}
597
598static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
599				      const u8 *qos_map_set, u8 qos_map_set_len)
600{
601	if (!wpa_s->driver->set_qos_map)
602		return -1;
603	return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
604					  qos_map_set_len);
605}
606
607#endif /* DRIVER_I_H */
608