Home | History | Annotate | Line # | Download | only in wpa_supplicant
driver_i.h revision 1.1 
      1 /*
      2  * wpa_supplicant - Internal driver interface wrappers
      3  * Copyright (c) 2003-2009, Jouni Malinen <j (at) 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