Home | History | Annotate | Download | only in wpa_supplicant
      1 /*
      2  * wpa_supplicant - Internal definitions
      3  * Copyright (c) 2003-2007, 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 WPA_SUPPLICANT_I_H
     16 #define WPA_SUPPLICANT_I_H
     17 
     18 #include "drivers/driver.h"
     19 
     20 extern const char *wpa_supplicant_version;
     21 extern const char *wpa_supplicant_license;
     22 #ifndef CONFIG_NO_STDOUT_DEBUG
     23 extern const char *wpa_supplicant_full_license1;
     24 extern const char *wpa_supplicant_full_license2;
     25 extern const char *wpa_supplicant_full_license3;
     26 extern const char *wpa_supplicant_full_license4;
     27 extern const char *wpa_supplicant_full_license5;
     28 #endif /* CONFIG_NO_STDOUT_DEBUG */
     29 
     30 extern struct wpa_driver_ops *wpa_supplicant_drivers[];
     31 
     32 
     33 struct wpa_scan_result;
     34 struct wpa_sm;
     35 struct wpa_supplicant;
     36 
     37 /*
     38  * Forward declarations of private structures used within the ctrl_iface
     39  * backends. Other parts of wpa_supplicant do not have access to data stored in
     40  * these structures.
     41  */
     42 struct ctrl_iface_priv;
     43 struct ctrl_iface_global_priv;
     44 struct ctrl_iface_dbus_priv;
     45 
     46 /**
     47  * struct wpa_interface - Parameters for wpa_supplicant_add_iface()
     48  */
     49 struct wpa_interface {
     50 	/**
     51 	 * confname - Configuration name (file or profile) name
     52 	 *
     53 	 * This can also be %NULL when a configuration file is not used. In
     54 	 * that case, ctrl_interface must be set to allow the interface to be
     55 	 * configured.
     56 	 */
     57 	const char *confname;
     58 
     59 	/**
     60 	 * ctrl_interface - Control interface parameter
     61 	 *
     62 	 * If a configuration file is not used, this variable can be used to
     63 	 * set the ctrl_interface parameter that would have otherwise been read
     64 	 * from the configuration file. If both confname and ctrl_interface are
     65 	 * set, ctrl_interface is used to override the value from configuration
     66 	 * file.
     67 	 */
     68 	const char *ctrl_interface;
     69 
     70 	/**
     71 	 * driver - Driver interface name, or %NULL to use the default driver
     72 	 */
     73 	const char *driver;
     74 
     75 	/**
     76 	 * driver_param - Driver interface parameters
     77 	 *
     78 	 * If a configuration file is not used, this variable can be used to
     79 	 * set the driver_param parameters that would have otherwise been read
     80 	 * from the configuration file. If both confname and driver_param are
     81 	 * set, driver_param is used to override the value from configuration
     82 	 * file.
     83 	 */
     84 	const char *driver_param;
     85 
     86 	/**
     87 	 * ifname - Interface name
     88 	 */
     89 	const char *ifname;
     90 
     91 	/**
     92 	 * bridge_ifname - Optional bridge interface name
     93 	 *
     94 	 * If the driver interface (ifname) is included in a Linux bridge
     95 	 * device, the bridge interface may need to be used for receiving EAPOL
     96 	 * frames. This can be enabled by setting this variable to enable
     97 	 * receiving of EAPOL frames from an additional interface.
     98 	 */
     99 	const char *bridge_ifname;
    100 };
    101 
    102 /**
    103  * struct wpa_params - Parameters for wpa_supplicant_init()
    104  */
    105 struct wpa_params {
    106 	/**
    107 	 * daemonize - Run %wpa_supplicant in the background
    108 	 */
    109 	int daemonize;
    110 
    111 	/**
    112 	 * wait_for_monitor - Wait for a monitor program before starting
    113 	 */
    114 	int wait_for_monitor;
    115 
    116 	/**
    117 	 * pid_file - Path to a PID (process ID) file
    118 	 *
    119 	 * If this and daemonize are set, process ID of the background process
    120 	 * will be written to the specified file.
    121 	 */
    122 	char *pid_file;
    123 
    124 	/**
    125 	 * wpa_debug_level - Debugging verbosity level (e.g., MSG_INFO)
    126 	 */
    127 	int wpa_debug_level;
    128 
    129 	/**
    130 	 * wpa_debug_show_keys - Whether keying material is included in debug
    131 	 *
    132 	 * This parameter can be used to allow keying material to be included
    133 	 * in debug messages. This is a security risk and this option should
    134 	 * not be enabled in normal configuration. If needed during
    135 	 * development or while troubleshooting, this option can provide more
    136 	 * details for figuring out what is happening.
    137 	 */
    138 	int wpa_debug_show_keys;
    139 
    140 	/**
    141 	 * wpa_debug_timestamp - Whether to include timestamp in debug messages
    142 	 */
    143 	int wpa_debug_timestamp;
    144 
    145 	/**
    146 	 * ctrl_interface - Global ctrl_iface path/parameter
    147 	 */
    148 	char *ctrl_interface;
    149 
    150 	/**
    151 	 * dbus_ctrl_interface - Enable the DBus control interface
    152 	 */
    153 	int dbus_ctrl_interface;
    154 
    155 	/**
    156 	 * wpa_debug_file_path - Path of debug file or %NULL to use stdout
    157 	 */
    158 	const char *wpa_debug_file_path;
    159 };
    160 
    161 /**
    162  * struct wpa_global - Internal, global data for all %wpa_supplicant interfaces
    163  *
    164  * This structure is initialized by calling wpa_supplicant_init() when starting
    165  * %wpa_supplicant.
    166  */
    167 struct wpa_global {
    168 	struct wpa_supplicant *ifaces;
    169 	struct wpa_params params;
    170 	struct ctrl_iface_global_priv *ctrl_iface;
    171 	struct ctrl_iface_dbus_priv *dbus_ctrl_iface;
    172 	void **drv_priv;
    173 	size_t drv_count;
    174 };
    175 
    176 
    177 struct wpa_client_mlme {
    178 #ifdef CONFIG_CLIENT_MLME
    179 	enum {
    180 		IEEE80211_DISABLED, IEEE80211_AUTHENTICATE,
    181 		IEEE80211_ASSOCIATE, IEEE80211_ASSOCIATED,
    182 		IEEE80211_IBSS_SEARCH, IEEE80211_IBSS_JOINED
    183 	} state;
    184 	u8 prev_bssid[ETH_ALEN];
    185 	u8 ssid[32];
    186 	size_t ssid_len;
    187 	u16 aid;
    188 	u16 ap_capab, capab;
    189 	u8 *extra_ie; /* to be added to the end of AssocReq */
    190 	size_t extra_ie_len;
    191 	u8 *extra_probe_ie; /* to be added to the end of ProbeReq */
    192 	size_t extra_probe_ie_len;
    193 	wpa_key_mgmt key_mgmt;
    194 
    195 	/* The last AssocReq/Resp IEs */
    196 	u8 *assocreq_ies, *assocresp_ies;
    197 	size_t assocreq_ies_len, assocresp_ies_len;
    198 
    199 	int auth_tries, assoc_tries;
    200 
    201 	unsigned int ssid_set:1;
    202 	unsigned int bssid_set:1;
    203 	unsigned int prev_bssid_set:1;
    204 	unsigned int authenticated:1;
    205 	unsigned int associated:1;
    206 	unsigned int probereq_poll:1;
    207 	unsigned int use_protection:1;
    208 	unsigned int create_ibss:1;
    209 	unsigned int mixed_cell:1;
    210 	unsigned int wmm_enabled:1;
    211 
    212 	struct os_time last_probe;
    213 
    214 #define IEEE80211_AUTH_ALG_OPEN BIT(0)
    215 #define IEEE80211_AUTH_ALG_SHARED_KEY BIT(1)
    216 #define IEEE80211_AUTH_ALG_LEAP BIT(2)
    217 	unsigned int auth_algs; /* bitfield of allowed auth algs */
    218 	int auth_alg; /* currently used IEEE 802.11 authentication algorithm */
    219 	int auth_transaction;
    220 
    221 	struct os_time ibss_join_req;
    222 	u8 *probe_resp; /* ProbeResp template for IBSS */
    223 	size_t probe_resp_len;
    224 	u32 supp_rates_bits;
    225 
    226 	int wmm_last_param_set;
    227 
    228 	int sta_scanning;
    229 	int scan_hw_mode_idx;
    230 	int scan_channel_idx;
    231 	enum { SCAN_SET_CHANNEL, SCAN_SEND_PROBE } scan_state;
    232 	struct os_time last_scan_completed;
    233 	int scan_oper_channel;
    234 	int scan_oper_freq;
    235 	int scan_oper_phymode;
    236 	u8 scan_ssid[32];
    237 	size_t scan_ssid_len;
    238 	int scan_skip_11b;
    239 
    240 	struct ieee80211_sta_bss *sta_bss_list;
    241 #define STA_HASH_SIZE 256
    242 #define STA_HASH(sta) (sta[5])
    243 	struct ieee80211_sta_bss *sta_bss_hash[STA_HASH_SIZE];
    244 
    245 	int cts_protect_erp_frames;
    246 
    247 	int phymode; /* current mode; WPA_MODE_IEEE80211A, .. */
    248 	struct wpa_hw_modes *modes;
    249 	size_t num_modes;
    250 	unsigned int hw_modes; /* bitfield of allowed hardware modes;
    251 				* (1 << MODE_*) */
    252 	int num_curr_rates;
    253 	struct wpa_rate_data *curr_rates;
    254 	int freq; /* The current frequency in MHz */
    255 	int channel; /* The current IEEE 802.11 channel number */
    256 
    257 #ifdef CONFIG_IEEE80211R
    258 	u8 current_md[6];
    259 	u8 *ft_ies;
    260 	size_t ft_ies_len;
    261 #endif /* CONFIG_IEEE80211R */
    262 
    263 #else /* CONFIG_CLIENT_MLME */
    264 	int dummy; /* to keep MSVC happy */
    265 #endif /* CONFIG_CLIENT_MLME */
    266 };
    267 
    268 /**
    269  * struct wpa_supplicant - Internal data for wpa_supplicant interface
    270  *
    271  * This structure contains the internal data for core wpa_supplicant code. This
    272  * should be only used directly from the core code. However, a pointer to this
    273  * data is used from other files as an arbitrary context pointer in calls to
    274  * core functions.
    275  */
    276 struct wpa_supplicant {
    277 	struct wpa_global *global;
    278 	struct wpa_supplicant *next;
    279 	struct l2_packet_data *l2;
    280 	struct l2_packet_data *l2_br;
    281 	unsigned char own_addr[ETH_ALEN];
    282 	char ifname[100];
    283 #ifdef CONFIG_CTRL_IFACE_DBUS
    284 	char *dbus_path;
    285 #endif /* CONFIG_CTRL_IFACE_DBUS */
    286 	char bridge_ifname[16];
    287 
    288 	char *confname;
    289 	struct wpa_config *conf;
    290 	int countermeasures;
    291 	os_time_t last_michael_mic_error;
    292 	u8 bssid[ETH_ALEN];
    293 	u8 pending_bssid[ETH_ALEN]; /* If wpa_state == WPA_ASSOCIATING, this
    294 				     * field contains the targer BSSID. */
    295 	int reassociate; /* reassociation requested */
    296 	int disconnected; /* all connections disabled; i.e., do no reassociate
    297 			   * before this has been cleared */
    298 	struct wpa_ssid *current_ssid;
    299 	int ap_ies_from_associnfo;
    300 
    301 	/* Selected configuration (based on Beacon/ProbeResp WPA IE) */
    302 	int pairwise_cipher;
    303 	int group_cipher;
    304 	int key_mgmt;
    305 	int mgmt_group_cipher;
    306 
    307 	void *drv_priv; /* private data used by driver_ops */
    308 	void *global_drv_priv;
    309 
    310 	struct wpa_ssid *prev_scan_ssid; /* previously scanned SSID;
    311 					  * NULL = not yet initialized (start
    312 					  * with broadcast SSID)
    313 					  * BROADCAST_SSID_SCAN = broadcast
    314 					  * SSID was used in the previous scan
    315 					  */
    316 #define BROADCAST_SSID_SCAN ((struct wpa_ssid *) 1)
    317 
    318 	struct wpa_scan_results *scan_res;
    319 
    320 	struct wpa_driver_ops *driver;
    321 	int interface_removed; /* whether the network interface has been
    322 				* removed */
    323 	struct wpa_sm *wpa;
    324 	struct eapol_sm *eapol;
    325 
    326 	struct ctrl_iface_priv *ctrl_iface;
    327 
    328 	wpa_states wpa_state;
    329 	int scanning;
    330 	int new_connection;
    331 	int reassociated_connection;
    332 
    333 	int eapol_received; /* number of EAPOL packets received after the
    334 			     * previous association event */
    335 
    336 	struct scard_data *scard;
    337 
    338 	unsigned char last_eapol_src[ETH_ALEN];
    339 
    340 	int keys_cleared;
    341 
    342 	struct wpa_blacklist *blacklist;
    343 
    344 	int scan_req; /* manual scan request; this forces a scan even if there
    345 		       * are no enabled networks in the configuration */
    346 	int scan_res_tried; /* whether ap_scan=1 mode has tried to fetch scan
    347 			     * results without a new scan request; this is used
    348 			     * to speed up the first association if the driver
    349 			     * has already available scan results. */
    350 	int scan_runs; /* number of scan runs since WPS was started */
    351 
    352 	struct wpa_client_mlme mlme;
    353 	int use_client_mlme;
    354 	int driver_4way_handshake;
    355 
    356 	int pending_mic_error_report;
    357 	int pending_mic_error_pairwise;
    358 	int mic_errors_seen; /* Michael MIC errors with the current PTK */
    359 
    360 	struct wps_context *wps;
    361 	int wps_success; /* WPS success event received */
    362 	int blacklist_cleared;
    363 
    364 	struct wpabuf *pending_eapol_rx;
    365 	struct os_time pending_eapol_rx_time;
    366 	u8 pending_eapol_rx_src[ETH_ALEN];
    367 
    368 	int link_speed;   /* current link speed */
    369 	int rssi;         /* current signal level */
    370 #ifdef ANDROID
    371 	int scan_interval; /* time between scans when no APs available */
    372 #endif
    373 };
    374 
    375 
    376 /* wpa_supplicant.c */
    377 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s);
    378 
    379 const char * wpa_supplicant_state_txt(int state);
    380 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s);
    381 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
    382 			      struct wpa_scan_res *bss,
    383 			      struct wpa_ssid *ssid,
    384 			      u8 *wpa_ie, size_t *wpa_ie_len);
    385 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
    386 			      struct wpa_scan_res *bss,
    387 			      struct wpa_ssid *ssid);
    388 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,
    389 				       struct wpa_ssid *ssid);
    390 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s);
    391 int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s);
    392 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr);
    393 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
    394 				     int sec, int usec);
    395 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state);
    396 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s);
    397 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s);
    398 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,
    399 				   int reason_code);
    400 void wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s,
    401 				 int reason_code);
    402 
    403 void wpa_show_license(void);
    404 
    405 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,
    406 						 struct wpa_interface *iface);
    407 int wpa_supplicant_remove_iface(struct wpa_global *global,
    408 				struct wpa_supplicant *wpa_s);
    409 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,
    410 						 const char *ifname);
    411 struct wpa_global * wpa_supplicant_init(struct wpa_params *params);
    412 int wpa_supplicant_run(struct wpa_global *global);
    413 void wpa_supplicant_deinit(struct wpa_global *global);
    414 
    415 int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s,
    416 			      struct wpa_ssid *ssid);
    417 
    418 /* scan.c */
    419 int wpa_supplicant_enabled_networks(struct wpa_config *conf);
    420 void wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec);
    421 void wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s);
    422 void wpa_supplicant_notify_scanning(struct wpa_supplicant *wpa_s,
    423 				    int scanning);
    424 int wpa_drv_scan(struct wpa_supplicant *wpa_s, struct wpa_ssid **ssid_prt);
    425 
    426 /* events.c */
    427 void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s);
    428 
    429 /* driver_ops */
    430 static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
    431 				  const char *ifname)
    432 {
    433 	if (wpa_s->driver->init2)
    434 		return wpa_s->driver->init2(wpa_s, ifname,
    435 					    wpa_s->global_drv_priv);
    436 	if (wpa_s->driver->init) {
    437 		return wpa_s->driver->init(wpa_s, ifname);
    438 	}
    439 	return NULL;
    440 }
    441 
    442 static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
    443 {
    444 	if (wpa_s->driver->deinit)
    445 		wpa_s->driver->deinit(wpa_s->drv_priv);
    446 }
    447 
    448 static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
    449 				    const char *param)
    450 {
    451 	if (wpa_s->driver->set_param)
    452 		return wpa_s->driver->set_param(wpa_s->drv_priv, param);
    453 	return 0;
    454 }
    455 
    456 static inline int wpa_drv_set_drop_unencrypted(struct wpa_supplicant *wpa_s,
    457 					       int enabled)
    458 {
    459 	if (wpa_s->driver->set_drop_unencrypted) {
    460 		return wpa_s->driver->set_drop_unencrypted(wpa_s->drv_priv,
    461 							   enabled);
    462 	}
    463 	return -1;
    464 }
    465 
    466 static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
    467 					      int enabled)
    468 {
    469 	if (wpa_s->driver->set_countermeasures) {
    470 		return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
    471 							  enabled);
    472 	}
    473 	return -1;
    474 }
    475 
    476 static inline int wpa_drv_set_auth_alg(struct wpa_supplicant *wpa_s,
    477 				       int auth_alg)
    478 {
    479 	if (wpa_s->driver->set_auth_alg) {
    480 		return wpa_s->driver->set_auth_alg(wpa_s->drv_priv,
    481 						   auth_alg);
    482 	}
    483 	return -1;
    484 }
    485 
    486 static inline int wpa_drv_set_wpa(struct wpa_supplicant *wpa_s, int enabled)
    487 {
    488 	if (wpa_s->driver->set_wpa) {
    489 		return wpa_s->driver->set_wpa(wpa_s->drv_priv, enabled);
    490 	}
    491 	return 0;
    492 }
    493 
    494 static inline int wpa_drv_set_mode(struct wpa_supplicant *wpa_s, int mode)
    495 {
    496 	if (wpa_s->driver->set_mode) {
    497 		return wpa_s->driver->set_mode(wpa_s->drv_priv, mode);
    498 	}
    499 	return 0;
    500 }
    501 
    502 static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
    503 				    struct wpa_driver_associate_params *params)
    504 {
    505 	if (wpa_s->driver->associate) {
    506 		return wpa_s->driver->associate(wpa_s->drv_priv, params);
    507 	}
    508 	return -1;
    509 }
    510 
    511 static inline int wpa_drv_get_scan_results(struct wpa_supplicant *wpa_s,
    512 					   struct wpa_scan_result *results,
    513 					   size_t max_size)
    514 {
    515 	if (wpa_s->driver->get_scan_results) {
    516 		return wpa_s->driver->get_scan_results(wpa_s->drv_priv,
    517 						       results, max_size);
    518 	}
    519 	return -1;
    520 }
    521 
    522 static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
    523 	struct wpa_supplicant *wpa_s)
    524 {
    525 	if (wpa_s->driver->get_scan_results2)
    526 		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
    527 	return NULL;
    528 }
    529 
    530 static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
    531 {
    532 	if (wpa_s->driver->get_bssid) {
    533 		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
    534 	}
    535 	return -1;
    536 }
    537 
    538 static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
    539 {
    540 	if (wpa_s->driver->get_ssid) {
    541 		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
    542 	}
    543 	return -1;
    544 }
    545 
    546 static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s, wpa_alg alg,
    547 				   const u8 *addr, int key_idx, int set_tx,
    548 				   const u8 *seq, size_t seq_len,
    549 				   const u8 *key, size_t key_len)
    550 {
    551 	if (wpa_s->driver->set_key) {
    552 		wpa_s->keys_cleared = 0;
    553 		return wpa_s->driver->set_key(wpa_s->drv_priv, alg, addr,
    554 					      key_idx, set_tx, seq, seq_len,
    555 					      key, key_len);
    556 	}
    557 	return -1;
    558 }
    559 
    560 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
    561 					 const u8 *addr, int reason_code)
    562 {
    563 	if (wpa_s->driver->deauthenticate) {
    564 		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
    565 						     reason_code);
    566 	}
    567 	return -1;
    568 }
    569 
    570 static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
    571 				       const u8 *addr, int reason_code)
    572 {
    573 	if (wpa_s->driver->disassociate) {
    574 		return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
    575 						   reason_code);
    576 	}
    577 	return -1;
    578 }
    579 
    580 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
    581 				    const u8 *bssid, const u8 *pmkid)
    582 {
    583 	if (wpa_s->driver->add_pmkid) {
    584 		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
    585 	}
    586 	return -1;
    587 }
    588 
    589 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
    590 				       const u8 *bssid, const u8 *pmkid)
    591 {
    592 	if (wpa_s->driver->remove_pmkid) {
    593 		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
    594 						   pmkid);
    595 	}
    596 	return -1;
    597 }
    598 
    599 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
    600 {
    601 	if (wpa_s->driver->flush_pmkid) {
    602 		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
    603 	}
    604 	return -1;
    605 }
    606 
    607 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
    608 				   struct wpa_driver_capa *capa)
    609 {
    610 	if (wpa_s->driver->get_capa) {
    611 		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
    612 	}
    613 	return -1;
    614 }
    615 
    616 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
    617 {
    618 	if (wpa_s->driver->poll) {
    619 		wpa_s->driver->poll(wpa_s->drv_priv);
    620 	}
    621 }
    622 
    623 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
    624 {
    625 	if (wpa_s->driver->get_ifname) {
    626 		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
    627 	}
    628 	return NULL;
    629 }
    630 
    631 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
    632 {
    633 	if (wpa_s->driver->get_mac_addr) {
    634 		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
    635 	}
    636 	return NULL;
    637 }
    638 
    639 static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
    640 				     const u8 *dst, u16 proto,
    641 				     const u8 *data, size_t data_len)
    642 {
    643 	if (wpa_s->driver->send_eapol)
    644 		return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
    645 						 data, data_len);
    646 	return -1;
    647 }
    648 
    649 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
    650 					int state)
    651 {
    652 	if (wpa_s->driver->set_operstate)
    653 		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
    654 	return 0;
    655 }
    656 
    657 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
    658 					     const u8 *addr, int protect_type,
    659 					     int key_type)
    660 {
    661 	if (wpa_s->driver->mlme_setprotection)
    662 		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
    663 							 protect_type,
    664 							 key_type);
    665 	return 0;
    666 }
    667 
    668 static inline struct wpa_hw_modes *
    669 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
    670 			    u16 *flags)
    671 {
    672 	if (wpa_s->driver->get_hw_feature_data)
    673 		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
    674 							  num_modes, flags);
    675 	return NULL;
    676 }
    677 
    678 static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
    679 				      wpa_hw_mode phymode, int chan,
    680 				      int freq)
    681 {
    682 	if (wpa_s->driver->set_channel)
    683 		return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
    684 						  chan, freq);
    685 	return -1;
    686 }
    687 
    688 static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
    689 				   const u8 *ssid, size_t ssid_len)
    690 {
    691 	if (wpa_s->driver->set_ssid) {
    692 		return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
    693 					       ssid_len);
    694 	}
    695 	return -1;
    696 }
    697 
    698 static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
    699 				    const u8 *bssid)
    700 {
    701 	if (wpa_s->driver->set_bssid) {
    702 		return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
    703 	}
    704 	return -1;
    705 }
    706 
    707 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
    708 				      const char *alpha2)
    709 {
    710 	if (wpa_s->driver->set_country)
    711 		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
    712 	return 0;
    713 }
    714 
    715 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
    716 				    const u8 *data, size_t data_len)
    717 {
    718 	if (wpa_s->driver->send_mlme)
    719 		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
    720 						data, data_len);
    721 	return -1;
    722 }
    723 
    724 static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
    725 				       const u8 *addr, const u8 *supp_rates,
    726 				       size_t supp_rates_len)
    727 {
    728 	if (wpa_s->driver->mlme_add_sta)
    729 		return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
    730 						   supp_rates, supp_rates_len);
    731 	return -1;
    732 }
    733 
    734 static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
    735 					  const u8 *addr)
    736 {
    737 	if (wpa_s->driver->mlme_remove_sta)
    738 		return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
    739 	return -1;
    740 }
    741 
    742 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
    743 					const u8 *md,
    744 					const u8 *ies, size_t ies_len)
    745 {
    746 	if (wpa_s->driver->update_ft_ies)
    747 		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
    748 						    ies, ies_len);
    749 	return -1;
    750 }
    751 
    752 static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
    753 					 u8 action, const u8 *target_ap,
    754 					 const u8 *ies, size_t ies_len)
    755 {
    756 	if (wpa_s->driver->send_ft_action)
    757 		return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
    758 						     target_ap, ies, ies_len);
    759 	return -1;
    760 }
    761 
    762 static inline int wpa_drv_set_probe_req_ie(struct wpa_supplicant *wpa_s,
    763 					   const u8 *ies, size_t ies_len)
    764 {
    765 	if (wpa_s->driver->set_probe_req_ie)
    766 		return wpa_s->driver->set_probe_req_ie(wpa_s->drv_priv, ies,
    767 						       ies_len);
    768 	return -1;
    769 }
    770 
    771 #ifdef ANDROID
    772 static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
    773 					  char *cmd, char *buf, size_t buf_len)
    774 {
    775 	if (wpa_s->driver->driver_cmd)
    776 		return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
    777 	return -1;
    778 }
    779 #endif
    780 #endif /* WPA_SUPPLICANT_I_H */
    781