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 */
15 static 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 
27 static 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 
33 static 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 
41 static 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 
51 static 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 
59 static 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 
68 static 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 
76 static 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 
86 static 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 
93 static 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 
101 static 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 
109 static 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 
117 static 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 
137 static 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 
148 static 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 
158 static 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 
167 static 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 
177 static 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 
185 static 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 
194 static 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 
201 static 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 
209 static 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 
217 static 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 
227 static 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 
235 static 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 
246 static inline struct hostapd_hw_modes *
247 wpa_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 
256 static 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 
264 static 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 
273 static 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 
283 static 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 
293 static 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 
301 static 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 
309 static 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 
317 static 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 
329 static 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 
340 static 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 
350 static 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 
365 static 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 
371 static 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 
379 static 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 
392 static 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 
401 static 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 
411 static 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 
420 static 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 
429 static 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 
436 static 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 
443 static 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 
449 static 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 
455 static 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 
464 static 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 
472 static 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 
481 static 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 
492 static 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 
499 static 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 
507 static 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 
517 static 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 
524 static 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 
537 static 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
546 static 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 
555 static 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 
564 static 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 
572 static 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 
580 static 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 
590 static 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 
598 static 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