]>
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) | |
25 | return wpa_s->driver->init2(wpa_s, ifname, wpa_s->global); | |
26 | if (wpa_s->driver->init) { | |
27 | return wpa_s->driver->init(wpa_s, ifname); | |
28 | } | |
29 | return NULL; | |
30 | } | |
31 | ||
32 | static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s) | |
33 | { | |
34 | if (wpa_s->driver->deinit) | |
35 | wpa_s->driver->deinit(wpa_s->drv_priv); | |
36 | } | |
37 | ||
38 | static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s, | |
39 | const char *param) | |
40 | { | |
41 | if (wpa_s->driver->set_param) | |
42 | return wpa_s->driver->set_param(wpa_s->drv_priv, param); | |
43 | return 0; | |
44 | } | |
45 | ||
46 | static inline int wpa_drv_set_drop_unencrypted(struct wpa_supplicant *wpa_s, | |
47 | int enabled) | |
48 | { | |
49 | if (wpa_s->driver->set_drop_unencrypted) { | |
50 | return wpa_s->driver->set_drop_unencrypted(wpa_s->drv_priv, | |
51 | enabled); | |
52 | } | |
53 | return -1; | |
54 | } | |
55 | ||
56 | static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s, | |
57 | int enabled) | |
58 | { | |
59 | if (wpa_s->driver->set_countermeasures) { | |
60 | return wpa_s->driver->set_countermeasures(wpa_s->drv_priv, | |
61 | enabled); | |
62 | } | |
63 | return -1; | |
64 | } | |
65 | ||
66 | static inline int wpa_drv_set_auth_alg(struct wpa_supplicant *wpa_s, | |
67 | int auth_alg) | |
68 | { | |
69 | if (wpa_s->driver->set_auth_alg) { | |
70 | return wpa_s->driver->set_auth_alg(wpa_s->drv_priv, | |
71 | auth_alg); | |
72 | } | |
73 | return -1; | |
74 | } | |
75 | ||
76 | static inline int wpa_drv_set_wpa(struct wpa_supplicant *wpa_s, int enabled) | |
77 | { | |
78 | if (wpa_s->driver->set_wpa) { | |
79 | return wpa_s->driver->set_wpa(wpa_s->drv_priv, enabled); | |
80 | } | |
81 | return 0; | |
82 | } | |
83 | ||
84 | static inline int wpa_drv_set_mode(struct wpa_supplicant *wpa_s, int mode) | |
85 | { | |
86 | if (wpa_s->driver->set_mode) { | |
87 | return wpa_s->driver->set_mode(wpa_s->drv_priv, mode); | |
88 | } | |
89 | return 0; | |
90 | } | |
91 | ||
92 | static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s, | |
93 | struct wpa_driver_auth_params *params) | |
94 | { | |
95 | if (wpa_s->driver->authenticate) | |
96 | return wpa_s->driver->authenticate(wpa_s->drv_priv, params); | |
97 | return -1; | |
98 | } | |
99 | ||
100 | static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s, | |
101 | struct wpa_driver_associate_params *params) | |
102 | { | |
103 | if (wpa_s->driver->associate) { | |
104 | return wpa_s->driver->associate(wpa_s->drv_priv, params); | |
105 | } | |
106 | return -1; | |
107 | } | |
108 | ||
109 | static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s, | |
110 | struct wpa_driver_scan_params *params) | |
111 | { | |
112 | if (wpa_s->driver->scan2) | |
113 | return wpa_s->driver->scan2(wpa_s->drv_priv, params); | |
114 | if (wpa_s->driver->scan) | |
115 | return wpa_s->driver->scan(wpa_s->drv_priv, | |
116 | params->ssids[0].ssid, | |
117 | params->ssids[0].ssid_len); | |
118 | return -1; | |
119 | } | |
120 | ||
121 | static inline int wpa_drv_get_scan_results(struct wpa_supplicant *wpa_s, | |
122 | struct wpa_scan_result *results, | |
123 | size_t max_size) | |
124 | { | |
125 | if (wpa_s->driver->get_scan_results) { | |
126 | return wpa_s->driver->get_scan_results(wpa_s->drv_priv, | |
127 | results, max_size); | |
128 | } | |
129 | return -1; | |
130 | } | |
131 | ||
132 | static inline struct wpa_scan_results * wpa_drv_get_scan_results2( | |
133 | struct wpa_supplicant *wpa_s) | |
134 | { | |
135 | if (wpa_s->driver->get_scan_results2) | |
136 | return wpa_s->driver->get_scan_results2(wpa_s->drv_priv); | |
137 | return NULL; | |
138 | } | |
139 | ||
140 | static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid) | |
141 | { | |
142 | if (wpa_s->driver->get_bssid) { | |
143 | return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid); | |
144 | } | |
145 | return -1; | |
146 | } | |
147 | ||
148 | static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid) | |
149 | { | |
150 | if (wpa_s->driver->get_ssid) { | |
151 | return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid); | |
152 | } | |
153 | return -1; | |
154 | } | |
155 | ||
156 | static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s, wpa_alg alg, | |
157 | const u8 *addr, int key_idx, int set_tx, | |
158 | const u8 *seq, size_t seq_len, | |
159 | const u8 *key, size_t key_len) | |
160 | { | |
161 | if (wpa_s->driver->set_key) { | |
162 | wpa_s->keys_cleared = 0; | |
163 | return wpa_s->driver->set_key(wpa_s->drv_priv, alg, addr, | |
164 | key_idx, set_tx, seq, seq_len, | |
165 | key, key_len); | |
166 | } | |
167 | return -1; | |
168 | } | |
169 | ||
170 | static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s, | |
171 | const u8 *addr, int reason_code) | |
172 | { | |
173 | if (wpa_s->driver->deauthenticate) { | |
174 | return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr, | |
175 | reason_code); | |
176 | } | |
177 | return -1; | |
178 | } | |
179 | ||
180 | static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s, | |
181 | const u8 *addr, int reason_code) | |
182 | { | |
183 | if (wpa_s->driver->disassociate) { | |
184 | return wpa_s->driver->disassociate(wpa_s->drv_priv, addr, | |
185 | reason_code); | |
186 | } | |
187 | return -1; | |
188 | } | |
189 | ||
190 | static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s, | |
191 | const u8 *bssid, const u8 *pmkid) | |
192 | { | |
193 | if (wpa_s->driver->add_pmkid) { | |
194 | return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid); | |
195 | } | |
196 | return -1; | |
197 | } | |
198 | ||
199 | static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s, | |
200 | const u8 *bssid, const u8 *pmkid) | |
201 | { | |
202 | if (wpa_s->driver->remove_pmkid) { | |
203 | return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid, | |
204 | pmkid); | |
205 | } | |
206 | return -1; | |
207 | } | |
208 | ||
209 | static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s) | |
210 | { | |
211 | if (wpa_s->driver->flush_pmkid) { | |
212 | return wpa_s->driver->flush_pmkid(wpa_s->drv_priv); | |
213 | } | |
214 | return -1; | |
215 | } | |
216 | ||
217 | static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s, | |
218 | struct wpa_driver_capa *capa) | |
219 | { | |
220 | if (wpa_s->driver->get_capa) { | |
221 | return wpa_s->driver->get_capa(wpa_s->drv_priv, capa); | |
222 | } | |
223 | return -1; | |
224 | } | |
225 | ||
226 | static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s) | |
227 | { | |
228 | if (wpa_s->driver->poll) { | |
229 | wpa_s->driver->poll(wpa_s->drv_priv); | |
230 | } | |
231 | } | |
232 | ||
233 | static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s) | |
234 | { | |
235 | if (wpa_s->driver->get_ifname) { | |
236 | return wpa_s->driver->get_ifname(wpa_s->drv_priv); | |
237 | } | |
238 | return NULL; | |
239 | } | |
240 | ||
241 | static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s) | |
242 | { | |
243 | if (wpa_s->driver->get_mac_addr) { | |
244 | return wpa_s->driver->get_mac_addr(wpa_s->drv_priv); | |
245 | } | |
246 | return NULL; | |
247 | } | |
248 | ||
249 | static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s, | |
250 | const u8 *dst, u16 proto, | |
251 | const u8 *data, size_t data_len) | |
252 | { | |
253 | if (wpa_s->driver->send_eapol) | |
254 | return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto, | |
255 | data, data_len); | |
256 | return -1; | |
257 | } | |
258 | ||
259 | static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s, | |
260 | int state) | |
261 | { | |
262 | if (wpa_s->driver->set_operstate) | |
263 | return wpa_s->driver->set_operstate(wpa_s->drv_priv, state); | |
264 | return 0; | |
265 | } | |
266 | ||
267 | static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s, | |
268 | const u8 *addr, int protect_type, | |
269 | int key_type) | |
270 | { | |
271 | if (wpa_s->driver->mlme_setprotection) | |
272 | return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr, | |
273 | protect_type, | |
274 | key_type); | |
275 | return 0; | |
276 | } | |
277 | ||
278 | static inline struct wpa_hw_modes * | |
279 | wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes, | |
280 | u16 *flags) | |
281 | { | |
282 | if (wpa_s->driver->get_hw_feature_data) | |
283 | return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv, | |
284 | num_modes, flags); | |
285 | return NULL; | |
286 | } | |
287 | ||
288 | static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s, | |
289 | wpa_hw_mode phymode, int chan, | |
290 | int freq) | |
291 | { | |
292 | if (wpa_s->driver->set_channel) | |
293 | return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode, | |
294 | chan, freq); | |
295 | return -1; | |
296 | } | |
297 | ||
298 | static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s, | |
299 | const u8 *ssid, size_t ssid_len) | |
300 | { | |
301 | if (wpa_s->driver->set_ssid) { | |
302 | return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid, | |
303 | ssid_len); | |
304 | } | |
305 | return -1; | |
306 | } | |
307 | ||
308 | static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s, | |
309 | const u8 *bssid) | |
310 | { | |
311 | if (wpa_s->driver->set_bssid) { | |
312 | return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid); | |
313 | } | |
314 | return -1; | |
315 | } | |
316 | ||
317 | static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s, | |
318 | const char *alpha2) | |
319 | { | |
320 | if (wpa_s->driver->set_country) | |
321 | return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2); | |
322 | return 0; | |
323 | } | |
324 | ||
325 | static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s, | |
326 | const u8 *data, size_t data_len) | |
327 | { | |
328 | if (wpa_s->driver->send_mlme) | |
329 | return wpa_s->driver->send_mlme(wpa_s->drv_priv, | |
330 | data, data_len); | |
331 | return -1; | |
332 | } | |
333 | ||
334 | static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s, | |
335 | const u8 *addr, const u8 *supp_rates, | |
336 | size_t supp_rates_len) | |
337 | { | |
338 | if (wpa_s->driver->mlme_add_sta) | |
339 | return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr, | |
340 | supp_rates, supp_rates_len); | |
341 | return -1; | |
342 | } | |
343 | ||
344 | static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s, | |
345 | const u8 *addr) | |
346 | { | |
347 | if (wpa_s->driver->mlme_remove_sta) | |
348 | return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr); | |
349 | return -1; | |
350 | } | |
351 | ||
352 | static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s, | |
353 | const u8 *md, | |
354 | const u8 *ies, size_t ies_len) | |
355 | { | |
356 | if (wpa_s->driver->update_ft_ies) | |
357 | return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md, | |
358 | ies, ies_len); | |
359 | return -1; | |
360 | } | |
361 | ||
362 | static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s, | |
363 | u8 action, const u8 *target_ap, | |
364 | const u8 *ies, size_t ies_len) | |
365 | { | |
366 | if (wpa_s->driver->send_ft_action) | |
367 | return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action, | |
368 | target_ap, ies, ies_len); | |
369 | return -1; | |
370 | } | |
371 | ||
372 | static inline int wpa_drv_set_probe_req_ie(struct wpa_supplicant *wpa_s, | |
373 | const u8 *ies, size_t ies_len) | |
374 | { | |
375 | if (wpa_s->driver->set_probe_req_ie) | |
376 | return wpa_s->driver->set_probe_req_ie(wpa_s->drv_priv, ies, | |
377 | ies_len); | |
378 | return -1; | |
379 | } | |
380 | ||
d2440ba0 JM |
381 | static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s, |
382 | const u8 *head, size_t head_len, | |
383 | const u8 *tail, size_t tail_len, | |
384 | int dtim_period) | |
385 | { | |
386 | if (wpa_s->driver->set_beacon) | |
387 | return wpa_s->driver->set_beacon(wpa_s->drv_priv, head, | |
388 | head_len, tail, tail_len, | |
389 | dtim_period); | |
390 | return -1; | |
391 | } | |
392 | ||
393 | static inline int wpa_drv_set_beacon_int(struct wpa_supplicant *wpa_s, | |
394 | int value) | |
395 | { | |
396 | if (wpa_s->driver->set_beacon_int) | |
397 | return wpa_s->driver->set_beacon_int(wpa_s->drv_priv, value); | |
398 | return -1; | |
399 | } | |
400 | ||
2d5b792d | 401 | #endif /* DRIVER_I_H */ |