Stripped down import of wpa_supplicant v0.3.8

1 files changed, 436 insertions, 0 deletions

diff --git a/contrib/wpa_supplicant/driver.h b/contrib/wpa_supplicant/driver.h
new file mode 100644
index 0000000..da28014
--- /dev/null
+++ b/contrib/wpa_supplicant/driver.h
@@ -0,0 +1,436 @@
+#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 */