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,
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 
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 
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 
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);
79 	return -1;
80 }
81 
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 
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,
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 
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 
229 static inline struct hostapd_hw_modes *
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,
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 
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 
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,
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 
335 static 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 
343 static 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 
351 static 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 
363 static 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 
374 static 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 
384 static 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 
397 static 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 
410 static 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 
419 static 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 
429 static 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 
438 static 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 
447 static 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 
456 static 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 
463 static 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 
469 static 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 
475 static 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 
484 static 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