NetBSD/dist/wpa_supplicant/driver.h

437 lines
15 KiB
C

#ifndef DRIVER_H
#define DRIVER_H
#define WPA_SUPPLICANT_DRIVER_VERSION 2
typedef enum { WPA_ALG_NONE, WPA_ALG_WEP, WPA_ALG_TKIP, WPA_ALG_CCMP } wpa_alg;
typedef enum { CIPHER_NONE, CIPHER_WEP40, CIPHER_TKIP, CIPHER_CCMP,
CIPHER_WEP104 } wpa_cipher;
typedef enum { KEY_MGMT_802_1X, KEY_MGMT_PSK, KEY_MGMT_NONE,
KEY_MGMT_802_1X_NO_WPA, KEY_MGMT_WPA_NONE } wpa_key_mgmt;
#define AUTH_ALG_OPEN_SYSTEM 0x01
#define AUTH_ALG_SHARED_KEY 0x02
#define AUTH_ALG_LEAP 0x04
#define IEEE80211_MODE_INFRA 0
#define IEEE80211_MODE_IBSS 1
#define SSID_MAX_WPA_IE_LEN 40
struct wpa_scan_result {
u8 bssid[ETH_ALEN];
u8 ssid[32];
size_t ssid_len;
u8 wpa_ie[SSID_MAX_WPA_IE_LEN];
size_t wpa_ie_len;
u8 rsn_ie[SSID_MAX_WPA_IE_LEN];
size_t rsn_ie_len;
int freq; /* MHz */
int caps; /* e.g. privacy */
int qual; /* signal quality */
int noise;
int level;
int maxrate;
};
/* Parameters for associate driver_ops. */
struct wpa_driver_associate_params {
/* BSSID of the selected AP */
const u8 *bssid;
/* The selected SSID and its length in bytes */
const u8 *ssid;
size_t ssid_len;
/* frequency that the selected AP is using (in MHz as
* reported in the scan results) */
int freq;
/* WPA information element to be included in (Re)Association
* Request (including information element id and length). Use
* of this WPA IE is optional. If the driver generates the WPA
* IE, it can use @pairwise_suite, @group_suite, and
* @key_mgmt_suite to select proper algorithms. In this case,
* the driver has to notify wpa_supplicant about the used WPA
* IE by generating an event that the interface code will
* convert into EVENT_ASSOCINFO data (see wpa_supplicant.h).
* When using WPA2/IEEE 802.11i, @wpa_ie is used for RSN IE
* instead. The driver can determine which version is used by
* looking at the first byte of the IE (0xdd for WPA, 0x30 for
* WPA2/RSN). @wpa_ie_len: length of the @wpa_ie */
const u8 *wpa_ie;
size_t wpa_ie_len;
/* The selected pairwise/group cipher and key management
* suites. These are usually ignored if @wpa_ie is used. */
wpa_cipher pairwise_suite;
wpa_cipher group_suite;
wpa_key_mgmt key_mgmt_suite;
int auth_alg; /* bit field of AUTH_ALG_* */
int mode; /* IEEE80211_MODE_* */
};
struct wpa_driver_capa {
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA 0x00000001
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2 0x00000002
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK 0x00000004
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK 0x00000008
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE 0x00000010
unsigned int key_mgmt;
#define WPA_DRIVER_CAPA_ENC_WEP40 0x00000001
#define WPA_DRIVER_CAPA_ENC_WEP104 0x00000002
#define WPA_DRIVER_CAPA_ENC_TKIP 0x00000004
#define WPA_DRIVER_CAPA_ENC_CCMP 0x00000008
unsigned int enc;
#define WPA_DRIVER_AUTH_OPEN 0x00000001
#define WPA_DRIVER_AUTH_SHARED 0x00000002
#define WPA_DRIVER_AUTH_LEAP 0x00000004
unsigned int auth;
/* Driver generated WPA/RSN IE */
#define WPA_DRIVER_FLAGS_DRIVER_IE 0x00000001
#define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC 0x00000002
unsigned int flags;
};
struct wpa_driver_ops {
/* name of the driver interface */
const char *name;
/* one line description of the driver interface */
const char *desc;
/**
* get_bssid - get the current BSSID
* @priv: private driver interface data
* @bssid: buffer for BSSID (ETH_ALEN = 6 bytes)
*
* Returns: 0 on success, -1 on failure
*
* Query kernel driver for the current BSSID and copy it to @bssid.
* Setting @bssid to 00:00:00:00:00:00 is recommended if the STA is not
* associated.
*/
int (*get_bssid)(void *priv, u8 *bssid);
/**
* get_ssid - get the current SSID
* @priv: private driver interface data
* @ssid: buffer for SSID (at least 32 bytes)
*
* Returns: length of the SSID on success, -1 on failure
*
* Query kernel driver for the current SSID and copy it to @ssid.
* Returning zero is recommended if the STA is not associated.
*
* Note: SSID is an array of octets, i.e., it is not nul terminated and
* can, at least in theory, contain control characters (including nul)
* and as such, should be processed as binary data, not a printable
* string.
*/
int (*get_ssid)(void *priv, u8 *ssid);
/**
* set_wpa - enable/disable WPA support
* @priv: private driver interface data
* @enabled: 1 = enable, 0 = disable
*
* Returns: 0 on success, -1 on failure
*
* Configure the kernel driver to enable/disable WPA support. This may
* be empty function, if WPA support is always enabled. Common
* configuration items are WPA IE (clearing it when WPA support is
* disabled), Privacy flag for capability field, roaming mode (need to
* allow wpa_supplicant to control roaming).
*/
int (*set_wpa)(void *priv, int enabled);
/**
* set_key - configure encryption key
* @priv: private driver interface data
* @alg: encryption algorithm (%WPA_ALG_NONE, %WPA_ALG_WEP,
* %WPA_ALG_TKIP, %WPA_ALG_CCMP); %WPA_ALG_NONE clears the key.
* @addr: address of the peer STA or ff:ff:ff:ff:ff:ff for
* broadcast/default keys
* @key_idx: key index (0..3), always 0 for unicast keys
* @set_tx: configure this key as the default Tx key (only used when
* driver does not support separate unicast/individual key
* @seq: sequence number/packet number, @seq_len octets, the next
* packet number to be used for in replay protection; configured
* for Rx keys (in most cases, this is only used with broadcast
* keys and set to zero for unicast keys)
* @seq_len: length of the @seq, depends on the algorithm:
* TKIP: 6 octets, CCMP: 6 octets
* @key: key buffer; TKIP: 16-byte temporal key, 8-byte Tx Mic key,
* 8-byte Rx Mic Key
* @key_len: length of the key buffer in octets (WEP: 5 or 13,
* TKIP: 32, CCMP: 16)
*
* Returns: 0 on success, -1 on failure
*
* Configure the given key for the kernel driver. If the driver
* supports separate individual keys (4 default keys + 1 individual),
* @addr can be used to determine whether the key is default or
* individual. If only 4 keys are supported, the default key with key
* index 0 is used as the individual key. STA must be configured to use
* it as the default Tx key (@set_tx is set) and accept Rx for all the
* key indexes. In most cases, WPA uses only key indexes 1 and 2 for
* broadcast keys, so key index 0 is available for this kind of
* configuration.
*/
int (*set_key)(void *priv, wpa_alg alg, const u8 *addr,
int key_idx, int set_tx, const u8 *seq, size_t seq_len,
const u8 *key, size_t key_len);
/**
* init - initialize driver interface
* @ctx: context to be used when calling wpa_supplicant functions,
* e.g., wpa_supplicant_event()
* @ifname: interface name, e.g., wlan0
*
* Return: pointer to private data, %NULL on failure
*
* Initialize driver interface, including event processing for kernel
* driver events (e.g., associated, scan results, Michael MIC failure).
* This function can allocate a private configuration data area for
* @ctx, file descriptor, interface name, etc. information that may be
* needed in future driver operations. If this is not used, non-NULL
* value will need to be returned because %NULL is used to indicate
* failure. The returned value will be used as 'void *priv' data for
* all other driver_ops functions.
*
* The main event loop (eloop.c) of wpa_supplicant can be used to
* register callback for read sockets (eloop_register_read_sock()).
*
* See wpa_supplicant.h for more information about events and
* wpa_supplicant_event() function.
*/
void * (*init)(void *ctx, const char *ifname);
/**
* deinit - deinitialize driver interface
* @priv: pointer to private data (from matching
* wpa_driver_events_init())
*
* Shut down driver interface and processing of driver events. Free
* private data buffer if one was allocated in init() handler.
*/
void (*deinit)(void *priv);
/**
* set_countermeasures - enable/disable TKIP countermeasures
* @priv: private driver interface data
* @enabled: 1 = countermeasures enabled, 0 = disabled
*
* Return: 0 on success, -1 on failure
*
* Configure TKIP countermeasures. When these are enabled, the driver
* should drop all received and queued frames that are using TKIP.
*/
int (*set_countermeasures)(void *priv, int enabled);
/**
* set_drop_unencrypted - enable/disable unencrypted frame filtering
* @priv: private driver interface data
* @enabled: 1 = unencrypted Tx/Rx frames will be dropped, 0 = disabled
*
* Return: 0 on success, -1 on failure
*
* Configure the driver to drop all non-EAPOL frames (both receive and
* transmit paths). Unencrypted EAPOL frames (ethertype 0x888e) must
* still be allowed for key negotiation.
*/
int (*set_drop_unencrypted)(void *priv, int enabled);
/**
* scan - request the driver to initiate scan
* @priv: private driver interface data
* @ssid: specific SSID to scan for (ProbeReq) or %NULL to scan for
* all SSIDs (either active scan with broadcast SSID or passive
* scan
* @ssid_len: length of the SSID
*
* Return: 0 on success, -1 on failure
*
* Once the scan results are ready, the driver should report scan
* results event for wpa_supplicant which will eventually request the
* results with wpa_driver_get_scan_results().
*/
int (*scan)(void *priv, const u8 *ssid, size_t ssid_len);
/**
* get_scan_results - fetch the latest scan results
* @priv: private driver interface data
* @results: pointer to buffer for scan results
* @max_size: maximum number of entries (buffer size)
*
* Return: number of scan result entries used on success, -1 on failure
*
* If scan results include more than @max_size BSSes, @max_size will be
* returned and the remaining entries will not be included in the
* buffer.
*/
int (*get_scan_results)(void *priv,
struct wpa_scan_result *results,
size_t max_size);
/**
* deauthenticate - request driver to deauthenticate
* @priv: private driver interface data
* @addr: peer address (BSSID of the AP)
* @reason_code: 16-bit reason code to be sent in the deauthentication
* frame
*
* Return: 0 on success, -1 on failure
*/
int (*deauthenticate)(void *priv, const u8 *addr, int reason_code);
/**
* disassociate - request driver to disassociate
* @priv: private driver interface data
* @addr: peer address (BSSID of the AP)
* @reason_code: 16-bit reason code to be sent in the disassociation
* frame
*
* Return: 0 on success, -1 on failure
*/
int (*disassociate)(void *priv, const u8 *addr, int reason_code);
/**
* associate - request driver to associate
* @priv: private driver interface data
* @params: association parameters
*
* Return: 0 on success, -1 on failure
*/
int (*associate)(void *priv,
struct wpa_driver_associate_params *params);
/**
* set_auth_alg - set IEEE 802.11 authentication algorithm
* @priv: private driver interface data
* @auth_alg: bit field of AUTH_ALG_*
*
* If the driver supports more than one authentication algorithm at the
* same time, it should configure all supported algorithms. If not, one
* algorithm needs to be selected arbitrarily. Open System
* authentication should be ok for most cases and it is recommended to
* be used if other options are not supported. Static WEP configuration
* may also use Shared Key authentication and LEAP requires its own
* algorithm number. For LEAP, user can make sure that only one
* algorithm is used at a time by configuring LEAP as the only
* supported EAP method. This information is also available in
* associate() params, so set_auth_alg may not be needed in case of
* most drivers.
*
* Return: 0 on success, -1 on failure
*/
int (*set_auth_alg)(void *priv, int auth_alg);
/**
* add_pmkid - add PMKSA cache entry to the driver
* @priv: private driver interface data
* @bssid: BSSID for the PMKSA cache entry
* @pmkid: PMKID for the PMKSA cache entry
*
* Return: 0 on success, -1 on failure
*
* This function is called when a new PMK is received, as a result of
* either normal authentication or RSN pre-authentication.
*
* If the driver generates RSN IE, i.e., it does not use @wpa_ie in
* associate(), add_pmkid() can be used to add new PMKSA cache entries
* in the driver. If the driver uses @wpa_ie from wpa_supplicant, this
* driver_ops function does not need to be implemented. Likewise, if
* the driver does not support WPA, this function is not needed.
*/
int (*add_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);
/**
* remove_pmkid - remove PMKSA cache entry to the driver
* @priv: private driver interface data
* @bssid: BSSID for the PMKSA cache entry
* @pmkid: PMKID for the PMKSA cache entry
*
* Return: 0 on success, -1 on failure
*
* This function is called when the supplicant drops a PMKSA cache
* entry for any reason.
*
* If the driver generates RSN IE, i.e., it does not use @wpa_ie in
* associate(), remove_pmkid() can be used to synchronize PMKSA caches
* between the driver and wpa_supplicant. If the driver uses @wpa_ie
* from wpa_supplicant, this driver_ops function does not need to be
* implemented. Likewise, if the driver does not support WPA, this
* function is not needed.
*/
int (*remove_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);
/**
* flush_pmkid - flush PMKSA cache
* @priv: private driver interface data
*
* Return: 0 on success, -1 on failure
*
* This function is called when the supplicant drops all PMKSA cache
* entries for any reason.
*
* If the driver generates RSN IE, i.e., it does not use @wpa_ie in
* associate(), remove_pmkid() can be used to synchronize PMKSA caches
* between the driver and wpa_supplicant. If the driver uses @wpa_ie
* from wpa_supplicant, this driver_ops function does not need to be
* implemented. Likewise, if the driver does not support WPA, this
* function is not needed.
*/
int (*flush_pmkid)(void *priv);
/**
* flush_pmkid - flush PMKSA cache
* @priv: private driver interface data
*
* Return: 0 on success, -1 on failure
*
* Get driver/firmware/hardware capabilities.
*/
int (*get_capa)(void *priv, struct wpa_driver_capa *capa);
/**
* poll - poll driver for association information
* @priv: private driver interface data
*
* This is an option callback that can be used when the driver does not
* provide event mechanism for association events. This is called when
* receiving WPA EAPOL-Key messages that require association
* information. The driver interface is supposed to generate associnfo
* event before returning from this callback function. In addition, the
* driver interface should generate an association event after having
* sent out associnfo.
*/
void (*poll)(void *priv);
/**
* get_ifname - get interface name
*
* This optional function can be used to allow the driver interface to
* replace the interface name with something else, e.g., based on an
* interface mapping from a more descriptive name.
*
* Returns a pointer to the interface name. This can differ from the
* interface name used in init() call.
*/
const char * (*get_ifname)(void *priv);
/**
* get_mac_addr - get own MAC address
*
* This optional function can be used to get the own MAC address of the
* device from the driver interface code. This is only needed if the
* l2_packet implementation for the OS does not provide easy access to
* a MAC address. */
const u8 * (*get_mac_addr)(void *priv);
};
#endif /* DRIVER_H */