LCOV - code coverage report
Current view: top level - drivers - driver.h (source / functions) Hit Total Coverage
Test: hostapd hwsim test run 1412854115 Lines: 7 20 35.0 %
Date: 2014-10-09 Functions: 1 3 33.3 %

          Line data    Source code
       1             : /*
       2             :  * Driver interface definition
       3             :  * Copyright (c) 2003-2014, 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             :  * This file defines a driver interface used by both %wpa_supplicant and
       9             :  * hostapd. The first part of the file defines data structures used in various
      10             :  * driver operations. This is followed by the struct wpa_driver_ops that each
      11             :  * driver wrapper will beed to define with callback functions for requesting
      12             :  * driver operations. After this, there are definitions for driver event
      13             :  * reporting with wpa_supplicant_event() and some convenience helper functions
      14             :  * that can be used to report events.
      15             :  */
      16             : 
      17             : #ifndef DRIVER_H
      18             : #define DRIVER_H
      19             : 
      20             : #define WPA_SUPPLICANT_DRIVER_VERSION 4
      21             : 
      22             : #include "common/defs.h"
      23             : #include "utils/list.h"
      24             : 
      25             : #define HOSTAPD_CHAN_DISABLED 0x00000001
      26             : #define HOSTAPD_CHAN_PASSIVE_SCAN 0x00000002
      27             : #define HOSTAPD_CHAN_NO_IBSS 0x00000004
      28             : #define HOSTAPD_CHAN_RADAR 0x00000008
      29             : #define HOSTAPD_CHAN_HT40PLUS 0x00000010
      30             : #define HOSTAPD_CHAN_HT40MINUS 0x00000020
      31             : #define HOSTAPD_CHAN_HT40 0x00000040
      32             : #define HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED 0x00000080
      33             : 
      34             : #define HOSTAPD_CHAN_DFS_UNKNOWN 0x00000000
      35             : #define HOSTAPD_CHAN_DFS_USABLE 0x00000100
      36             : #define HOSTAPD_CHAN_DFS_UNAVAILABLE 0x00000200
      37             : #define HOSTAPD_CHAN_DFS_AVAILABLE 0x00000300
      38             : #define HOSTAPD_CHAN_DFS_MASK 0x00000300
      39             : 
      40             : #define HOSTAPD_CHAN_VHT_10_70 0x00000800
      41             : #define HOSTAPD_CHAN_VHT_30_50 0x00001000
      42             : #define HOSTAPD_CHAN_VHT_50_30 0x00002000
      43             : #define HOSTAPD_CHAN_VHT_70_10 0x00004000
      44             : 
      45             : enum reg_change_initiator {
      46             :         REGDOM_SET_BY_CORE,
      47             :         REGDOM_SET_BY_USER,
      48             :         REGDOM_SET_BY_DRIVER,
      49             :         REGDOM_SET_BY_COUNTRY_IE,
      50             :         REGDOM_BEACON_HINT,
      51             : };
      52             : 
      53             : enum reg_type {
      54             :         REGDOM_TYPE_UNKNOWN,
      55             :         REGDOM_TYPE_COUNTRY,
      56             :         REGDOM_TYPE_WORLD,
      57             :         REGDOM_TYPE_CUSTOM_WORLD,
      58             :         REGDOM_TYPE_INTERSECTION,
      59             : };
      60             : 
      61             : /**
      62             :  * struct hostapd_channel_data - Channel information
      63             :  */
      64             : struct hostapd_channel_data {
      65             :         /**
      66             :          * chan - Channel number (IEEE 802.11)
      67             :          */
      68             :         short chan;
      69             : 
      70             :         /**
      71             :          * freq - Frequency in MHz
      72             :          */
      73             :         int freq;
      74             : 
      75             :         /**
      76             :          * flag - Channel flags (HOSTAPD_CHAN_*)
      77             :          */
      78             :         int flag;
      79             : 
      80             :         /**
      81             :          * max_tx_power - Regulatory transmit power limit in dBm
      82             :          */
      83             :         u8 max_tx_power;
      84             : 
      85             :         /*
      86             :          * survey_list - Linked list of surveys
      87             :          */
      88             :         struct dl_list survey_list;
      89             : 
      90             :         /**
      91             :          * min_nf - Minimum observed noise floor, in dBm, based on all
      92             :          * surveyed channel data
      93             :          */
      94             :         s8 min_nf;
      95             : 
      96             : #ifdef CONFIG_ACS
      97             :         /**
      98             :          * interference_factor - Computed interference factor on this
      99             :          * channel (used internally in src/ap/acs.c; driver wrappers do not
     100             :          * need to set this)
     101             :          */
     102             :         long double interference_factor;
     103             : #endif /* CONFIG_ACS */
     104             : 
     105             :         /* DFS CAC time in milliseconds */
     106             :         unsigned int dfs_cac_ms;
     107             : };
     108             : 
     109             : #define HOSTAPD_MODE_FLAG_HT_INFO_KNOWN BIT(0)
     110             : #define HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN BIT(1)
     111             : 
     112             : /**
     113             :  * struct hostapd_hw_modes - Supported hardware mode information
     114             :  */
     115             : struct hostapd_hw_modes {
     116             :         /**
     117             :          * mode - Hardware mode
     118             :          */
     119             :         enum hostapd_hw_mode mode;
     120             : 
     121             :         /**
     122             :          * num_channels - Number of entries in the channels array
     123             :          */
     124             :         int num_channels;
     125             : 
     126             :         /**
     127             :          * channels - Array of supported channels
     128             :          */
     129             :         struct hostapd_channel_data *channels;
     130             : 
     131             :         /**
     132             :          * num_rates - Number of entries in the rates array
     133             :          */
     134             :         int num_rates;
     135             : 
     136             :         /**
     137             :          * rates - Array of supported rates in 100 kbps units
     138             :          */
     139             :         int *rates;
     140             : 
     141             :         /**
     142             :          * ht_capab - HT (IEEE 802.11n) capabilities
     143             :          */
     144             :         u16 ht_capab;
     145             : 
     146             :         /**
     147             :          * mcs_set - MCS (IEEE 802.11n) rate parameters
     148             :          */
     149             :         u8 mcs_set[16];
     150             : 
     151             :         /**
     152             :          * a_mpdu_params - A-MPDU (IEEE 802.11n) parameters
     153             :          */
     154             :         u8 a_mpdu_params;
     155             : 
     156             :         /**
     157             :          * vht_capab - VHT (IEEE 802.11ac) capabilities
     158             :          */
     159             :         u32 vht_capab;
     160             : 
     161             :         /**
     162             :          * vht_mcs_set - VHT MCS (IEEE 802.11ac) rate parameters
     163             :          */
     164             :         u8 vht_mcs_set[8];
     165             : 
     166             :         unsigned int flags; /* HOSTAPD_MODE_FLAG_* */
     167             : };
     168             : 
     169             : 
     170             : #define IEEE80211_MODE_INFRA    0
     171             : #define IEEE80211_MODE_IBSS     1
     172             : #define IEEE80211_MODE_AP       2
     173             : 
     174             : #define IEEE80211_CAP_ESS       0x0001
     175             : #define IEEE80211_CAP_IBSS      0x0002
     176             : #define IEEE80211_CAP_PRIVACY   0x0010
     177             : 
     178             : /* DMG (60 GHz) IEEE 802.11ad */
     179             : /* type - bits 0..1 */
     180             : #define IEEE80211_CAP_DMG_MASK  0x0003
     181             : #define IEEE80211_CAP_DMG_IBSS  0x0001 /* Tx by: STA */
     182             : #define IEEE80211_CAP_DMG_PBSS  0x0002 /* Tx by: PCP */
     183             : #define IEEE80211_CAP_DMG_AP    0x0003 /* Tx by: AP */
     184             : 
     185             : #define WPA_SCAN_QUAL_INVALID           BIT(0)
     186             : #define WPA_SCAN_NOISE_INVALID          BIT(1)
     187             : #define WPA_SCAN_LEVEL_INVALID          BIT(2)
     188             : #define WPA_SCAN_LEVEL_DBM              BIT(3)
     189             : #define WPA_SCAN_AUTHENTICATED          BIT(4)
     190             : #define WPA_SCAN_ASSOCIATED             BIT(5)
     191             : 
     192             : /**
     193             :  * struct wpa_scan_res - Scan result for an BSS/IBSS
     194             :  * @flags: information flags about the BSS/IBSS (WPA_SCAN_*)
     195             :  * @bssid: BSSID
     196             :  * @freq: frequency of the channel in MHz (e.g., 2412 = channel 1)
     197             :  * @beacon_int: beacon interval in TUs (host byte order)
     198             :  * @caps: capability information field in host byte order
     199             :  * @qual: signal quality
     200             :  * @noise: noise level
     201             :  * @level: signal level
     202             :  * @tsf: Timestamp
     203             :  * @age: Age of the information in milliseconds (i.e., how many milliseconds
     204             :  * ago the last Beacon or Probe Response frame was received)
     205             :  * @ie_len: length of the following IE field in octets
     206             :  * @beacon_ie_len: length of the following Beacon IE field in octets
     207             :  *
     208             :  * This structure is used as a generic format for scan results from the
     209             :  * driver. Each driver interface implementation is responsible for converting
     210             :  * the driver or OS specific scan results into this format.
     211             :  *
     212             :  * If the driver does not support reporting all IEs, the IE data structure is
     213             :  * constructed of the IEs that are available. This field will also need to
     214             :  * include SSID in IE format. All drivers are encouraged to be extended to
     215             :  * report all IEs to make it easier to support future additions.
     216             :  */
     217             : struct wpa_scan_res {
     218             :         unsigned int flags;
     219             :         u8 bssid[ETH_ALEN];
     220             :         int freq;
     221             :         u16 beacon_int;
     222             :         u16 caps;
     223             :         int qual;
     224             :         int noise;
     225             :         int level;
     226             :         u64 tsf;
     227             :         unsigned int age;
     228             :         size_t ie_len;
     229             :         size_t beacon_ie_len;
     230             :         /*
     231             :          * Followed by ie_len octets of IEs from Probe Response frame (or if
     232             :          * the driver does not indicate source of IEs, these may also be from
     233             :          * Beacon frame). After the first set of IEs, another set of IEs may
     234             :          * follow (with beacon_ie_len octets of data) if the driver provides
     235             :          * both IE sets.
     236             :          */
     237             : };
     238             : 
     239             : /**
     240             :  * struct wpa_scan_results - Scan results
     241             :  * @res: Array of pointers to allocated variable length scan result entries
     242             :  * @num: Number of entries in the scan result array
     243             :  * @fetch_time: Time when the results were fetched from the driver
     244             :  */
     245             : struct wpa_scan_results {
     246             :         struct wpa_scan_res **res;
     247             :         size_t num;
     248             :         struct os_reltime fetch_time;
     249             : };
     250             : 
     251             : /**
     252             :  * struct wpa_interface_info - Network interface information
     253             :  * @next: Pointer to the next interface or NULL if this is the last one
     254             :  * @ifname: Interface name that can be used with init() or init2()
     255             :  * @desc: Human readable adapter description (e.g., vendor/model) or NULL if
     256             :  *      not available
     257             :  * @drv_name: struct wpa_driver_ops::name (note: unlike other strings, this one
     258             :  *      is not an allocated copy, i.e., get_interfaces() caller will not free
     259             :  *      this)
     260             :  */
     261             : struct wpa_interface_info {
     262             :         struct wpa_interface_info *next;
     263             :         char *ifname;
     264             :         char *desc;
     265             :         const char *drv_name;
     266             : };
     267             : 
     268             : #define WPAS_MAX_SCAN_SSIDS 16
     269             : 
     270             : /**
     271             :  * struct wpa_driver_scan_params - Scan parameters
     272             :  * Data for struct wpa_driver_ops::scan2().
     273             :  */
     274             : struct wpa_driver_scan_params {
     275             :         /**
     276             :          * ssids - SSIDs to scan for
     277             :          */
     278             :         struct wpa_driver_scan_ssid {
     279             :                 /**
     280             :                  * ssid - specific SSID to scan for (ProbeReq)
     281             :                  * %NULL or zero-length SSID is used to indicate active scan
     282             :                  * with wildcard SSID.
     283             :                  */
     284             :                 const u8 *ssid;
     285             :                 /**
     286             :                  * ssid_len: Length of the SSID in octets
     287             :                  */
     288             :                 size_t ssid_len;
     289             :         } ssids[WPAS_MAX_SCAN_SSIDS];
     290             : 
     291             :         /**
     292             :          * num_ssids - Number of entries in ssids array
     293             :          * Zero indicates a request for a passive scan.
     294             :          */
     295             :         size_t num_ssids;
     296             : 
     297             :         /**
     298             :          * extra_ies - Extra IE(s) to add into Probe Request or %NULL
     299             :          */
     300             :         const u8 *extra_ies;
     301             : 
     302             :         /**
     303             :          * extra_ies_len - Length of extra_ies in octets
     304             :          */
     305             :         size_t extra_ies_len;
     306             : 
     307             :         /**
     308             :          * freqs - Array of frequencies to scan or %NULL for all frequencies
     309             :          *
     310             :          * The frequency is set in MHz. The array is zero-terminated.
     311             :          */
     312             :         int *freqs;
     313             : 
     314             :         /**
     315             :          * filter_ssids - Filter for reporting SSIDs
     316             :          *
     317             :          * This optional parameter can be used to request the driver wrapper to
     318             :          * filter scan results to include only the specified SSIDs. %NULL
     319             :          * indicates that no filtering is to be done. This can be used to
     320             :          * reduce memory needs for scan results in environments that have large
     321             :          * number of APs with different SSIDs.
     322             :          *
     323             :          * The driver wrapper is allowed to take this allocated buffer into its
     324             :          * own use by setting the pointer to %NULL. In that case, the driver
     325             :          * wrapper is responsible for freeing the buffer with os_free() once it
     326             :          * is not needed anymore.
     327             :          */
     328             :         struct wpa_driver_scan_filter {
     329             :                 u8 ssid[32];
     330             :                 size_t ssid_len;
     331             :         } *filter_ssids;
     332             : 
     333             :         /**
     334             :          * num_filter_ssids - Number of entries in filter_ssids array
     335             :          */
     336             :         size_t num_filter_ssids;
     337             : 
     338             :         /**
     339             :          * filter_rssi - Filter by RSSI
     340             :          *
     341             :          * The driver may filter scan results in firmware to reduce host
     342             :          * wakeups and thereby save power. Specify the RSSI threshold in s32
     343             :          * dBm.
     344             :          */
     345             :         s32 filter_rssi;
     346             : 
     347             :         /**
     348             :          * p2p_probe - Used to disable CCK (802.11b) rates for P2P probes
     349             :          *
     350             :          * When set, the driver is expected to remove rates 1, 2, 5.5, and 11
     351             :          * Mbps from the support rates element(s) in the Probe Request frames
     352             :          * and not to transmit the frames at any of those rates.
     353             :          */
     354             :         unsigned int p2p_probe:1;
     355             : 
     356             :         /**
     357             :          * only_new_results - Request driver to report only new results
     358             :          *
     359             :          * This is used to request the driver to report only BSSes that have
     360             :          * been detected after this scan request has been started, i.e., to
     361             :          * flush old cached BSS entries.
     362             :          */
     363             :         unsigned int only_new_results:1;
     364             : 
     365             :         /**
     366             :          * low_priority - Requests driver to use a lower scan priority
     367             :          *
     368             :          * This is used to request the driver to use a lower scan priority
     369             :          * if it supports such a thing.
     370             :          */
     371             :         unsigned int low_priority:1;
     372             : 
     373             :         /*
     374             :          * NOTE: Whenever adding new parameters here, please make sure
     375             :          * wpa_scan_clone_params() and wpa_scan_free_params() get updated with
     376             :          * matching changes.
     377             :          */
     378             : };
     379             : 
     380             : /**
     381             :  * struct wpa_driver_auth_params - Authentication parameters
     382             :  * Data for struct wpa_driver_ops::authenticate().
     383             :  */
     384             : struct wpa_driver_auth_params {
     385             :         int freq;
     386             :         const u8 *bssid;
     387             :         const u8 *ssid;
     388             :         size_t ssid_len;
     389             :         int auth_alg;
     390             :         const u8 *ie;
     391             :         size_t ie_len;
     392             :         const u8 *wep_key[4];
     393             :         size_t wep_key_len[4];
     394             :         int wep_tx_keyidx;
     395             :         int local_state_change;
     396             : 
     397             :         /**
     398             :          * p2p - Whether this connection is a P2P group
     399             :          */
     400             :         int p2p;
     401             : 
     402             :         const u8 *sae_data;
     403             :         size_t sae_data_len;
     404             : 
     405             : };
     406             : 
     407             : enum wps_mode {
     408             :         WPS_MODE_NONE /* no WPS provisioning being used */,
     409             :         WPS_MODE_OPEN /* WPS provisioning with AP that is in open mode */,
     410             :         WPS_MODE_PRIVACY /* WPS provisioning with AP that is using protection
     411             :                           */
     412             : };
     413             : 
     414             : struct hostapd_freq_params {
     415             :         int mode;
     416             :         int freq;
     417             :         int channel;
     418             :         /* for HT */
     419             :         int ht_enabled;
     420             :         int sec_channel_offset; /* 0 = HT40 disabled, -1 = HT40 enabled,
     421             :                                  * secondary channel below primary, 1 = HT40
     422             :                                  * enabled, secondary channel above primary */
     423             : 
     424             :         /* for VHT */
     425             :         int vht_enabled;
     426             : 
     427             :         /* valid for both HT and VHT, center_freq2 is non-zero
     428             :          * only for bandwidth 80 and an 80+80 channel */
     429             :         int center_freq1, center_freq2;
     430             :         int bandwidth;
     431             : };
     432             : 
     433             : /**
     434             :  * struct wpa_driver_associate_params - Association parameters
     435             :  * Data for struct wpa_driver_ops::associate().
     436             :  */
     437             : struct wpa_driver_associate_params {
     438             :         /**
     439             :          * bssid - BSSID of the selected AP
     440             :          * This can be %NULL, if ap_scan=2 mode is used and the driver is
     441             :          * responsible for selecting with which BSS to associate. */
     442             :         const u8 *bssid;
     443             : 
     444             :         /**
     445             :          * bssid_hint - BSSID of a proposed AP
     446             :          *
     447             :          * This indicates which BSS has been found a suitable candidate for
     448             :          * initial association for drivers that use driver/firmwate-based BSS
     449             :          * selection. Unlike the @bssid parameter, @bssid_hint does not limit
     450             :          * the driver from selecting other BSSes in the ESS.
     451             :          */
     452             :         const u8 *bssid_hint;
     453             : 
     454             :         /**
     455             :          * ssid - The selected SSID
     456             :          */
     457             :         const u8 *ssid;
     458             : 
     459             :         /**
     460             :          * ssid_len - Length of the SSID (1..32)
     461             :          */
     462             :         size_t ssid_len;
     463             : 
     464             :         /**
     465             :          * freq - channel parameters
     466             :          */
     467             :         struct hostapd_freq_params freq;
     468             : 
     469             :         /**
     470             :          * freq_hint - Frequency of the channel the proposed AP is using
     471             :          *
     472             :          * This provides a channel on which a suitable BSS has been found as a
     473             :          * hint for the driver. Unlike the @freq parameter, @freq_hint does not
     474             :          * limit the driver from selecting other channels for
     475             :          * driver/firmware-based BSS selection.
     476             :          */
     477             :         int freq_hint;
     478             : 
     479             :         /**
     480             :          * bg_scan_period - Background scan period in seconds, 0 to disable
     481             :          * background scan, or -1 to indicate no change to default driver
     482             :          * configuration
     483             :          */
     484             :         int bg_scan_period;
     485             : 
     486             :         /**
     487             :          * beacon_int - Beacon interval for IBSS or 0 to use driver default
     488             :          */
     489             :         int beacon_int;
     490             : 
     491             :         /**
     492             :          * wpa_ie - WPA information element for (Re)Association Request
     493             :          * WPA information element to be included in (Re)Association
     494             :          * Request (including information element id and length). Use
     495             :          * of this WPA IE is optional. If the driver generates the WPA
     496             :          * IE, it can use pairwise_suite, group_suite, and
     497             :          * key_mgmt_suite to select proper algorithms. In this case,
     498             :          * the driver has to notify wpa_supplicant about the used WPA
     499             :          * IE by generating an event that the interface code will
     500             :          * convert into EVENT_ASSOCINFO data (see below).
     501             :          *
     502             :          * When using WPA2/IEEE 802.11i, wpa_ie is used for RSN IE
     503             :          * instead. The driver can determine which version is used by
     504             :          * looking at the first byte of the IE (0xdd for WPA, 0x30 for
     505             :          * WPA2/RSN).
     506             :          *
     507             :          * When using WPS, wpa_ie is used for WPS IE instead of WPA/RSN IE.
     508             :          */
     509             :         const u8 *wpa_ie;
     510             : 
     511             :         /**
     512             :          * wpa_ie_len - length of the wpa_ie
     513             :          */
     514             :         size_t wpa_ie_len;
     515             : 
     516             :         /**
     517             :          * wpa_proto - Bitfield of WPA_PROTO_* values to indicate WPA/WPA2
     518             :          */
     519             :         unsigned int wpa_proto;
     520             : 
     521             :         /**
     522             :          * pairwise_suite - Selected pairwise cipher suite (WPA_CIPHER_*)
     523             :          *
     524             :          * This is usually ignored if @wpa_ie is used.
     525             :          */
     526             :         unsigned int pairwise_suite;
     527             : 
     528             :         /**
     529             :          * group_suite - Selected group cipher suite (WPA_CIPHER_*)
     530             :          *
     531             :          * This is usually ignored if @wpa_ie is used.
     532             :          */
     533             :         unsigned int group_suite;
     534             : 
     535             :         /**
     536             :          * key_mgmt_suite - Selected key management suite (WPA_KEY_MGMT_*)
     537             :          *
     538             :          * This is usually ignored if @wpa_ie is used.
     539             :          */
     540             :         unsigned int key_mgmt_suite;
     541             : 
     542             :         /**
     543             :          * auth_alg - Allowed authentication algorithms
     544             :          * Bit field of WPA_AUTH_ALG_*
     545             :          */
     546             :         int auth_alg;
     547             : 
     548             :         /**
     549             :          * mode - Operation mode (infra/ibss) IEEE80211_MODE_*
     550             :          */
     551             :         int mode;
     552             : 
     553             :         /**
     554             :          * wep_key - WEP keys for static WEP configuration
     555             :          */
     556             :         const u8 *wep_key[4];
     557             : 
     558             :         /**
     559             :          * wep_key_len - WEP key length for static WEP configuration
     560             :          */
     561             :         size_t wep_key_len[4];
     562             : 
     563             :         /**
     564             :          * wep_tx_keyidx - WEP TX key index for static WEP configuration
     565             :          */
     566             :         int wep_tx_keyidx;
     567             : 
     568             :         /**
     569             :          * mgmt_frame_protection - IEEE 802.11w management frame protection
     570             :          */
     571             :         enum mfp_options mgmt_frame_protection;
     572             : 
     573             :         /**
     574             :          * ft_ies - IEEE 802.11r / FT information elements
     575             :          * If the supplicant is using IEEE 802.11r (FT) and has the needed keys
     576             :          * for fast transition, this parameter is set to include the IEs that
     577             :          * are to be sent in the next FT Authentication Request message.
     578             :          * update_ft_ies() handler is called to update the IEs for further
     579             :          * FT messages in the sequence.
     580             :          *
     581             :          * The driver should use these IEs only if the target AP is advertising
     582             :          * the same mobility domain as the one included in the MDIE here.
     583             :          *
     584             :          * In ap_scan=2 mode, the driver can use these IEs when moving to a new
     585             :          * AP after the initial association. These IEs can only be used if the
     586             :          * target AP is advertising support for FT and is using the same MDIE
     587             :          * and SSID as the current AP.
     588             :          *
     589             :          * The driver is responsible for reporting the FT IEs received from the
     590             :          * AP's response using wpa_supplicant_event() with EVENT_FT_RESPONSE
     591             :          * type. update_ft_ies() handler will then be called with the FT IEs to
     592             :          * include in the next frame in the authentication sequence.
     593             :          */
     594             :         const u8 *ft_ies;
     595             : 
     596             :         /**
     597             :          * ft_ies_len - Length of ft_ies in bytes
     598             :          */
     599             :         size_t ft_ies_len;
     600             : 
     601             :         /**
     602             :          * ft_md - FT Mobility domain (6 octets) (also included inside ft_ies)
     603             :          *
     604             :          * This value is provided to allow the driver interface easier access
     605             :          * to the current mobility domain. This value is set to %NULL if no
     606             :          * mobility domain is currently active.
     607             :          */
     608             :         const u8 *ft_md;
     609             : 
     610             :         /**
     611             :          * passphrase - RSN passphrase for PSK
     612             :          *
     613             :          * This value is made available only for WPA/WPA2-Personal (PSK) and
     614             :          * only for drivers that set WPA_DRIVER_FLAGS_4WAY_HANDSHAKE. This is
     615             :          * the 8..63 character ASCII passphrase, if available. Please note that
     616             :          * this can be %NULL if passphrase was not used to generate the PSK. In
     617             :          * that case, the psk field must be used to fetch the PSK.
     618             :          */
     619             :         const char *passphrase;
     620             : 
     621             :         /**
     622             :          * psk - RSN PSK (alternative for passphrase for PSK)
     623             :          *
     624             :          * This value is made available only for WPA/WPA2-Personal (PSK) and
     625             :          * only for drivers that set WPA_DRIVER_FLAGS_4WAY_HANDSHAKE. This is
     626             :          * the 32-octet (256-bit) PSK, if available. The driver wrapper should
     627             :          * be prepared to handle %NULL value as an error.
     628             :          */
     629             :         const u8 *psk;
     630             : 
     631             :         /**
     632             :          * drop_unencrypted - Enable/disable unencrypted frame filtering
     633             :          *
     634             :          * Configure the driver to drop all non-EAPOL frames (both receive and
     635             :          * transmit paths). Unencrypted EAPOL frames (ethertype 0x888e) must
     636             :          * still be allowed for key negotiation.
     637             :          */
     638             :         int drop_unencrypted;
     639             : 
     640             :         /**
     641             :          * prev_bssid - Previously used BSSID in this ESS
     642             :          *
     643             :          * When not %NULL, this is a request to use reassociation instead of
     644             :          * association.
     645             :          */
     646             :         const u8 *prev_bssid;
     647             : 
     648             :         /**
     649             :          * wps - WPS mode
     650             :          *
     651             :          * If the driver needs to do special configuration for WPS association,
     652             :          * this variable provides more information on what type of association
     653             :          * is being requested. Most drivers should not need ot use this.
     654             :          */
     655             :         enum wps_mode wps;
     656             : 
     657             :         /**
     658             :          * p2p - Whether this connection is a P2P group
     659             :          */
     660             :         int p2p;
     661             : 
     662             :         /**
     663             :          * uapsd - UAPSD parameters for the network
     664             :          * -1 = do not change defaults
     665             :          * AP mode: 1 = enabled, 0 = disabled
     666             :          * STA mode: bits 0..3 UAPSD enabled for VO,VI,BK,BE
     667             :          */
     668             :         int uapsd;
     669             : 
     670             :         /**
     671             :          * fixed_bssid - Whether to force this BSSID in IBSS mode
     672             :          * 1 = Fix this BSSID and prevent merges.
     673             :          * 0 = Do not fix BSSID.
     674             :          */
     675             :         int fixed_bssid;
     676             : 
     677             :         /**
     678             :          * disable_ht - Disable HT (IEEE 802.11n) for this connection
     679             :          */
     680             :         int disable_ht;
     681             : 
     682             :         /**
     683             :          * HT Capabilities over-rides. Only bits set in the mask will be used,
     684             :          * and not all values are used by the kernel anyway. Currently, MCS,
     685             :          * MPDU and MSDU fields are used.
     686             :          */
     687             :         const u8 *htcaps;       /* struct ieee80211_ht_capabilities * */
     688             :         const u8 *htcaps_mask;  /* struct ieee80211_ht_capabilities * */
     689             : 
     690             : #ifdef CONFIG_VHT_OVERRIDES
     691             :         /**
     692             :          * disable_vht - Disable VHT for this connection
     693             :          */
     694             :         int disable_vht;
     695             : 
     696             :         /**
     697             :          * VHT capability overrides.
     698             :          */
     699             :         const struct ieee80211_vht_capabilities *vhtcaps;
     700             :         const struct ieee80211_vht_capabilities *vhtcaps_mask;
     701             : #endif /* CONFIG_VHT_OVERRIDES */
     702             : };
     703             : 
     704             : enum hide_ssid {
     705             :         NO_SSID_HIDING,
     706             :         HIDDEN_SSID_ZERO_LEN,
     707             :         HIDDEN_SSID_ZERO_CONTENTS
     708             : };
     709             : 
     710             : struct wowlan_triggers {
     711             :         u8 any;
     712             :         u8 disconnect;
     713             :         u8 magic_pkt;
     714             :         u8 gtk_rekey_failure;
     715             :         u8 eap_identity_req;
     716             :         u8 four_way_handshake;
     717             :         u8 rfkill_release;
     718             : };
     719             : 
     720             : struct wpa_driver_ap_params {
     721             :         /**
     722             :          * head - Beacon head from IEEE 802.11 header to IEs before TIM IE
     723             :          */
     724             :         u8 *head;
     725             : 
     726             :         /**
     727             :          * head_len - Length of the head buffer in octets
     728             :          */
     729             :         size_t head_len;
     730             : 
     731             :         /**
     732             :          * tail - Beacon tail following TIM IE
     733             :          */
     734             :         u8 *tail;
     735             : 
     736             :         /**
     737             :          * tail_len - Length of the tail buffer in octets
     738             :          */
     739             :         size_t tail_len;
     740             : 
     741             :         /**
     742             :          * dtim_period - DTIM period
     743             :          */
     744             :         int dtim_period;
     745             : 
     746             :         /**
     747             :          * beacon_int - Beacon interval
     748             :          */
     749             :         int beacon_int;
     750             : 
     751             :         /**
     752             :          * basic_rates: -1 terminated array of basic rates in 100 kbps
     753             :          *
     754             :          * This parameter can be used to set a specific basic rate set for the
     755             :          * BSS. If %NULL, default basic rate set is used.
     756             :          */
     757             :         int *basic_rates;
     758             : 
     759             :         /**
     760             :          * proberesp - Probe Response template
     761             :          *
     762             :          * This is used by drivers that reply to Probe Requests internally in
     763             :          * AP mode and require the full Probe Response template.
     764             :          */
     765             :         u8 *proberesp;
     766             : 
     767             :         /**
     768             :          * proberesp_len - Length of the proberesp buffer in octets
     769             :          */
     770             :         size_t proberesp_len;
     771             : 
     772             :         /**
     773             :          * ssid - The SSID to use in Beacon/Probe Response frames
     774             :          */
     775             :         const u8 *ssid;
     776             : 
     777             :         /**
     778             :          * ssid_len - Length of the SSID (1..32)
     779             :          */
     780             :         size_t ssid_len;
     781             : 
     782             :         /**
     783             :          * hide_ssid - Whether to hide the SSID
     784             :          */
     785             :         enum hide_ssid hide_ssid;
     786             : 
     787             :         /**
     788             :          * pairwise_ciphers - WPA_CIPHER_* bitfield
     789             :          */
     790             :         unsigned int pairwise_ciphers;
     791             : 
     792             :         /**
     793             :          * group_cipher - WPA_CIPHER_*
     794             :          */
     795             :         unsigned int group_cipher;
     796             : 
     797             :         /**
     798             :          * key_mgmt_suites - WPA_KEY_MGMT_* bitfield
     799             :          */
     800             :         unsigned int key_mgmt_suites;
     801             : 
     802             :         /**
     803             :          * auth_algs - WPA_AUTH_ALG_* bitfield
     804             :          */
     805             :         unsigned int auth_algs;
     806             : 
     807             :         /**
     808             :          * wpa_version - WPA_PROTO_* bitfield
     809             :          */
     810             :         unsigned int wpa_version;
     811             : 
     812             :         /**
     813             :          * privacy - Whether privacy is used in the BSS
     814             :          */
     815             :         int privacy;
     816             : 
     817             :         /**
     818             :          * beacon_ies - WPS/P2P IE(s) for Beacon frames
     819             :          *
     820             :          * This is used to add IEs like WPS IE and P2P IE by drivers that do
     821             :          * not use the full Beacon template.
     822             :          */
     823             :         const struct wpabuf *beacon_ies;
     824             : 
     825             :         /**
     826             :          * proberesp_ies - P2P/WPS IE(s) for Probe Response frames
     827             :          *
     828             :          * This is used to add IEs like WPS IE and P2P IE by drivers that
     829             :          * reply to Probe Request frames internally.
     830             :          */
     831             :         const struct wpabuf *proberesp_ies;
     832             : 
     833             :         /**
     834             :          * assocresp_ies - WPS IE(s) for (Re)Association Response frames
     835             :          *
     836             :          * This is used to add IEs like WPS IE by drivers that reply to
     837             :          * (Re)Association Request frames internally.
     838             :          */
     839             :         const struct wpabuf *assocresp_ies;
     840             : 
     841             :         /**
     842             :          * isolate - Whether to isolate frames between associated stations
     843             :          *
     844             :          * If this is non-zero, the AP is requested to disable forwarding of
     845             :          * frames between associated stations.
     846             :          */
     847             :         int isolate;
     848             : 
     849             :         /**
     850             :          * cts_protect - Whether CTS protection is enabled
     851             :          */
     852             :         int cts_protect;
     853             : 
     854             :         /**
     855             :          * preamble - Whether short preamble is enabled
     856             :          */
     857             :         int preamble;
     858             : 
     859             :         /**
     860             :          * short_slot_time - Whether short slot time is enabled
     861             :          *
     862             :          * 0 = short slot time disable, 1 = short slot time enabled, -1 = do
     863             :          * not set (e.g., when 802.11g mode is not in use)
     864             :          */
     865             :         int short_slot_time;
     866             : 
     867             :         /**
     868             :          * ht_opmode - HT operation mode or -1 if HT not in use
     869             :          */
     870             :         int ht_opmode;
     871             : 
     872             :         /**
     873             :          * interworking - Whether Interworking is enabled
     874             :          */
     875             :         int interworking;
     876             : 
     877             :         /**
     878             :          * hessid - Homogeneous ESS identifier or %NULL if not set
     879             :          */
     880             :         const u8 *hessid;
     881             : 
     882             :         /**
     883             :          * access_network_type - Access Network Type (0..15)
     884             :          *
     885             :          * This is used for filtering Probe Request frames when Interworking is
     886             :          * enabled.
     887             :          */
     888             :         u8 access_network_type;
     889             : 
     890             :         /**
     891             :          * ap_max_inactivity - Timeout in seconds to detect STA's inactivity
     892             :          *
     893             :          * This is used by driver which advertises this capability.
     894             :          */
     895             :         int ap_max_inactivity;
     896             : 
     897             :         /**
     898             :          * disable_dgaf - Whether group-addressed frames are disabled
     899             :          */
     900             :         int disable_dgaf;
     901             : 
     902             :         /**
     903             :          * osen - Whether OSEN security is enabled
     904             :          */
     905             :         int osen;
     906             : 
     907             :         /**
     908             :          * freq - Channel parameters for dynamic bandwidth changes
     909             :          */
     910             :         struct hostapd_freq_params *freq;
     911             : };
     912             : 
     913             : /**
     914             :  * struct wpa_driver_capa - Driver capability information
     915             :  */
     916             : struct wpa_driver_capa {
     917             : #define WPA_DRIVER_CAPA_KEY_MGMT_WPA            0x00000001
     918             : #define WPA_DRIVER_CAPA_KEY_MGMT_WPA2           0x00000002
     919             : #define WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK        0x00000004
     920             : #define WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK       0x00000008
     921             : #define WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE       0x00000010
     922             : #define WPA_DRIVER_CAPA_KEY_MGMT_FT             0x00000020
     923             : #define WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK         0x00000040
     924             : #define WPA_DRIVER_CAPA_KEY_MGMT_WAPI_PSK       0x00000080
     925             :         unsigned int key_mgmt;
     926             : 
     927             : #define WPA_DRIVER_CAPA_ENC_WEP40       0x00000001
     928             : #define WPA_DRIVER_CAPA_ENC_WEP104      0x00000002
     929             : #define WPA_DRIVER_CAPA_ENC_TKIP        0x00000004
     930             : #define WPA_DRIVER_CAPA_ENC_CCMP        0x00000008
     931             : #define WPA_DRIVER_CAPA_ENC_WEP128      0x00000010
     932             : #define WPA_DRIVER_CAPA_ENC_GCMP        0x00000020
     933             : #define WPA_DRIVER_CAPA_ENC_GCMP_256    0x00000040
     934             : #define WPA_DRIVER_CAPA_ENC_CCMP_256    0x00000080
     935             : #define WPA_DRIVER_CAPA_ENC_BIP         0x00000100
     936             : #define WPA_DRIVER_CAPA_ENC_BIP_GMAC_128        0x00000200
     937             : #define WPA_DRIVER_CAPA_ENC_BIP_GMAC_256        0x00000400
     938             : #define WPA_DRIVER_CAPA_ENC_BIP_CMAC_256        0x00000800
     939             : #define WPA_DRIVER_CAPA_ENC_GTK_NOT_USED        0x00001000
     940             :         unsigned int enc;
     941             : 
     942             : #define WPA_DRIVER_AUTH_OPEN            0x00000001
     943             : #define WPA_DRIVER_AUTH_SHARED          0x00000002
     944             : #define WPA_DRIVER_AUTH_LEAP            0x00000004
     945             :         unsigned int auth;
     946             : 
     947             : /* Driver generated WPA/RSN IE */
     948             : #define WPA_DRIVER_FLAGS_DRIVER_IE      0x00000001
     949             : /* Driver needs static WEP key setup after association command */
     950             : #define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC 0x00000002
     951             : /* Driver takes care of all DFS operations */
     952             : #define WPA_DRIVER_FLAGS_DFS_OFFLOAD                    0x00000004
     953             : /* Driver takes care of RSN 4-way handshake internally; PMK is configured with
     954             :  * struct wpa_driver_ops::set_key using alg = WPA_ALG_PMK */
     955             : #define WPA_DRIVER_FLAGS_4WAY_HANDSHAKE 0x00000008
     956             : #define WPA_DRIVER_FLAGS_WIRED          0x00000010
     957             : /* Driver provides separate commands for authentication and association (SME in
     958             :  * wpa_supplicant). */
     959             : #define WPA_DRIVER_FLAGS_SME            0x00000020
     960             : /* Driver supports AP mode */
     961             : #define WPA_DRIVER_FLAGS_AP             0x00000040
     962             : /* Driver needs static WEP key setup after association has been completed */
     963             : #define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE      0x00000080
     964             : /* Driver supports dynamic HT 20/40 MHz channel changes during BSS lifetime */
     965             : #define WPA_DRIVER_FLAGS_HT_2040_COEX                   0x00000100
     966             : /* Driver supports concurrent P2P operations */
     967             : #define WPA_DRIVER_FLAGS_P2P_CONCURRENT 0x00000200
     968             : /*
     969             :  * Driver uses the initial interface as a dedicated management interface, i.e.,
     970             :  * it cannot be used for P2P group operations or non-P2P purposes.
     971             :  */
     972             : #define WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE        0x00000400
     973             : /* This interface is P2P capable (P2P GO or P2P Client) */
     974             : #define WPA_DRIVER_FLAGS_P2P_CAPABLE    0x00000800
     975             : /* Driver supports station and key removal when stopping an AP */
     976             : #define WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT            0x00001000
     977             : /*
     978             :  * Driver uses the initial interface for P2P management interface and non-P2P
     979             :  * purposes (e.g., connect to infra AP), but this interface cannot be used for
     980             :  * P2P group operations.
     981             :  */
     982             : #define WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P           0x00002000
     983             : /*
     984             :  * Driver is known to use sane error codes, i.e., when it indicates that
     985             :  * something (e.g., association) fails, there was indeed a failure and the
     986             :  * operation does not end up getting completed successfully later.
     987             :  */
     988             : #define WPA_DRIVER_FLAGS_SANE_ERROR_CODES               0x00004000
     989             : /* Driver supports off-channel TX */
     990             : #define WPA_DRIVER_FLAGS_OFFCHANNEL_TX                  0x00008000
     991             : /* Driver indicates TX status events for EAPOL Data frames */
     992             : #define WPA_DRIVER_FLAGS_EAPOL_TX_STATUS                0x00010000
     993             : /* Driver indicates TX status events for Deauth/Disassoc frames */
     994             : #define WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS               0x00020000
     995             : /* Driver supports roaming (BSS selection) in firmware */
     996             : #define WPA_DRIVER_FLAGS_BSS_SELECTION                  0x00040000
     997             : /* Driver supports operating as a TDLS peer */
     998             : #define WPA_DRIVER_FLAGS_TDLS_SUPPORT                   0x00080000
     999             : /* Driver requires external TDLS setup/teardown/discovery */
    1000             : #define WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP            0x00100000
    1001             : /* Driver indicates support for Probe Response offloading in AP mode */
    1002             : #define WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD             0x00200000
    1003             : /* Driver supports U-APSD in AP mode */
    1004             : #define WPA_DRIVER_FLAGS_AP_UAPSD                       0x00400000
    1005             : /* Driver supports inactivity timer in AP mode */
    1006             : #define WPA_DRIVER_FLAGS_INACTIVITY_TIMER               0x00800000
    1007             : /* Driver expects user space implementation of MLME in AP mode */
    1008             : #define WPA_DRIVER_FLAGS_AP_MLME                        0x01000000
    1009             : /* Driver supports SAE with user space SME */
    1010             : #define WPA_DRIVER_FLAGS_SAE                            0x02000000
    1011             : /* Driver makes use of OBSS scan mechanism in wpa_supplicant */
    1012             : #define WPA_DRIVER_FLAGS_OBSS_SCAN                      0x04000000
    1013             : /* Driver supports IBSS (Ad-hoc) mode */
    1014             : #define WPA_DRIVER_FLAGS_IBSS                           0x08000000
    1015             : /* Driver supports radar detection */
    1016             : #define WPA_DRIVER_FLAGS_RADAR                          0x10000000
    1017             : /* Driver supports a dedicated interface for P2P Device */
    1018             : #define WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE           0x20000000
    1019             : /* Driver supports QoS Mapping */
    1020             : #define WPA_DRIVER_FLAGS_QOS_MAPPING                    0x40000000
    1021             : /* Driver supports CSA in AP mode */
    1022             : #define WPA_DRIVER_FLAGS_AP_CSA                         0x80000000
    1023             :         unsigned int flags;
    1024             : 
    1025             :         int max_scan_ssids;
    1026             :         int max_sched_scan_ssids;
    1027             :         int sched_scan_supported;
    1028             :         int max_match_sets;
    1029             : 
    1030             :         /**
    1031             :          * max_remain_on_chan - Maximum remain-on-channel duration in msec
    1032             :          */
    1033             :         unsigned int max_remain_on_chan;
    1034             : 
    1035             :         /**
    1036             :          * max_stations - Maximum number of associated stations the driver
    1037             :          * supports in AP mode
    1038             :          */
    1039             :         unsigned int max_stations;
    1040             : 
    1041             :         /**
    1042             :          * probe_resp_offloads - Bitmap of supported protocols by the driver
    1043             :          * for Probe Response offloading.
    1044             :          */
    1045             : /* Driver Probe Response offloading support for WPS ver. 1 */
    1046             : #define WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS               0x00000001
    1047             : /* Driver Probe Response offloading support for WPS ver. 2 */
    1048             : #define WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2              0x00000002
    1049             : /* Driver Probe Response offloading support for P2P */
    1050             : #define WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P               0x00000004
    1051             : /* Driver Probe Response offloading support for IEEE 802.11u (Interworking) */
    1052             : #define WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING      0x00000008
    1053             :         unsigned int probe_resp_offloads;
    1054             : 
    1055             :         unsigned int max_acl_mac_addrs;
    1056             : 
    1057             :         /**
    1058             :          * Number of supported concurrent channels
    1059             :          */
    1060             :         unsigned int num_multichan_concurrent;
    1061             : 
    1062             :         /**
    1063             :          * extended_capa - extended capabilities in driver/device
    1064             :          *
    1065             :          * Must be allocated and freed by driver and the pointers must be
    1066             :          * valid for the lifetime of the driver, i.e., freed in deinit()
    1067             :          */
    1068             :         const u8 *extended_capa, *extended_capa_mask;
    1069             :         unsigned int extended_capa_len;
    1070             : 
    1071             :         struct wowlan_triggers wowlan_triggers;
    1072             : };
    1073             : 
    1074             : 
    1075             : struct hostapd_data;
    1076             : 
    1077             : struct hostap_sta_driver_data {
    1078             :         unsigned long rx_packets, tx_packets, rx_bytes, tx_bytes;
    1079             :         unsigned long current_tx_rate;
    1080             :         unsigned long inactive_msec;
    1081             :         unsigned long flags;
    1082             :         unsigned long num_ps_buf_frames;
    1083             :         unsigned long tx_retry_failed;
    1084             :         unsigned long tx_retry_count;
    1085             :         int last_rssi;
    1086             :         int last_ack_rssi;
    1087             : };
    1088             : 
    1089             : struct hostapd_sta_add_params {
    1090             :         const u8 *addr;
    1091             :         u16 aid;
    1092             :         u16 capability;
    1093             :         const u8 *supp_rates;
    1094             :         size_t supp_rates_len;
    1095             :         u16 listen_interval;
    1096             :         const struct ieee80211_ht_capabilities *ht_capabilities;
    1097             :         const struct ieee80211_vht_capabilities *vht_capabilities;
    1098             :         int vht_opmode_enabled;
    1099             :         u8 vht_opmode;
    1100             :         u32 flags; /* bitmask of WPA_STA_* flags */
    1101             :         int set; /* Set STA parameters instead of add */
    1102             :         u8 qosinfo;
    1103             :         const u8 *ext_capab;
    1104             :         size_t ext_capab_len;
    1105             :         const u8 *supp_channels;
    1106             :         size_t supp_channels_len;
    1107             :         const u8 *supp_oper_classes;
    1108             :         size_t supp_oper_classes_len;
    1109             : };
    1110             : 
    1111             : struct mac_address {
    1112             :         u8 addr[ETH_ALEN];
    1113             : };
    1114             : 
    1115             : struct hostapd_acl_params {
    1116             :         u8 acl_policy;
    1117             :         unsigned int num_mac_acl;
    1118             :         struct mac_address mac_acl[0];
    1119             : };
    1120             : 
    1121             : enum wpa_driver_if_type {
    1122             :         /**
    1123             :          * WPA_IF_STATION - Station mode interface
    1124             :          */
    1125             :         WPA_IF_STATION,
    1126             : 
    1127             :         /**
    1128             :          * WPA_IF_AP_VLAN - AP mode VLAN interface
    1129             :          *
    1130             :          * This interface shares its address and Beacon frame with the main
    1131             :          * BSS.
    1132             :          */
    1133             :         WPA_IF_AP_VLAN,
    1134             : 
    1135             :         /**
    1136             :          * WPA_IF_AP_BSS - AP mode BSS interface
    1137             :          *
    1138             :          * This interface has its own address and Beacon frame.
    1139             :          */
    1140             :         WPA_IF_AP_BSS,
    1141             : 
    1142             :         /**
    1143             :          * WPA_IF_P2P_GO - P2P Group Owner
    1144             :          */
    1145             :         WPA_IF_P2P_GO,
    1146             : 
    1147             :         /**
    1148             :          * WPA_IF_P2P_CLIENT - P2P Client
    1149             :          */
    1150             :         WPA_IF_P2P_CLIENT,
    1151             : 
    1152             :         /**
    1153             :          * WPA_IF_P2P_GROUP - P2P Group interface (will become either
    1154             :          * WPA_IF_P2P_GO or WPA_IF_P2P_CLIENT, but the role is not yet known)
    1155             :          */
    1156             :         WPA_IF_P2P_GROUP,
    1157             : 
    1158             :         /**
    1159             :          * WPA_IF_P2P_DEVICE - P2P Device interface is used to indentify the
    1160             :          * abstracted P2P Device function in the driver
    1161             :          */
    1162             :         WPA_IF_P2P_DEVICE
    1163             : };
    1164             : 
    1165             : struct wpa_init_params {
    1166             :         void *global_priv;
    1167             :         const u8 *bssid;
    1168             :         const char *ifname;
    1169             :         const u8 *ssid;
    1170             :         size_t ssid_len;
    1171             :         const char *test_socket;
    1172             :         int use_pae_group_addr;
    1173             :         char **bridge;
    1174             :         size_t num_bridge;
    1175             : 
    1176             :         u8 *own_addr; /* buffer for writing own MAC address */
    1177             : };
    1178             : 
    1179             : 
    1180             : struct wpa_bss_params {
    1181             :         /** Interface name (for multi-SSID/VLAN support) */
    1182             :         const char *ifname;
    1183             :         /** Whether IEEE 802.1X or WPA/WPA2 is enabled */
    1184             :         int enabled;
    1185             : 
    1186             :         int wpa;
    1187             :         int ieee802_1x;
    1188             :         int wpa_group;
    1189             :         int wpa_pairwise;
    1190             :         int wpa_key_mgmt;
    1191             :         int rsn_preauth;
    1192             :         enum mfp_options ieee80211w;
    1193             : };
    1194             : 
    1195             : #define WPA_STA_AUTHORIZED BIT(0)
    1196             : #define WPA_STA_WMM BIT(1)
    1197             : #define WPA_STA_SHORT_PREAMBLE BIT(2)
    1198             : #define WPA_STA_MFP BIT(3)
    1199             : #define WPA_STA_TDLS_PEER BIT(4)
    1200             : 
    1201             : enum tdls_oper {
    1202             :         TDLS_DISCOVERY_REQ,
    1203             :         TDLS_SETUP,
    1204             :         TDLS_TEARDOWN,
    1205             :         TDLS_ENABLE_LINK,
    1206             :         TDLS_DISABLE_LINK,
    1207             :         TDLS_ENABLE,
    1208             :         TDLS_DISABLE
    1209             : };
    1210             : 
    1211             : enum wnm_oper {
    1212             :         WNM_SLEEP_ENTER_CONFIRM,
    1213             :         WNM_SLEEP_ENTER_FAIL,
    1214             :         WNM_SLEEP_EXIT_CONFIRM,
    1215             :         WNM_SLEEP_EXIT_FAIL,
    1216             :         WNM_SLEEP_TFS_REQ_IE_ADD,   /* STA requests driver to add TFS req IE */
    1217             :         WNM_SLEEP_TFS_REQ_IE_NONE,  /* STA requests empty TFS req IE */
    1218             :         WNM_SLEEP_TFS_REQ_IE_SET,   /* AP requests driver to set TFS req IE for
    1219             :                                      * a STA */
    1220             :         WNM_SLEEP_TFS_RESP_IE_ADD,  /* AP requests driver to add TFS resp IE
    1221             :                                      * for a STA */
    1222             :         WNM_SLEEP_TFS_RESP_IE_NONE, /* AP requests empty TFS resp IE */
    1223             :         WNM_SLEEP_TFS_RESP_IE_SET,  /* AP requests driver to set TFS resp IE
    1224             :                                      * for a STA */
    1225             :         WNM_SLEEP_TFS_IE_DEL        /* AP delete the TFS IE */
    1226             : };
    1227             : 
    1228             : /* enum chan_width - Channel width definitions */
    1229             : enum chan_width {
    1230             :         CHAN_WIDTH_20_NOHT,
    1231             :         CHAN_WIDTH_20,
    1232             :         CHAN_WIDTH_40,
    1233             :         CHAN_WIDTH_80,
    1234             :         CHAN_WIDTH_80P80,
    1235             :         CHAN_WIDTH_160,
    1236             :         CHAN_WIDTH_UNKNOWN
    1237             : };
    1238             : 
    1239             : /**
    1240             :  * struct wpa_signal_info - Information about channel signal quality
    1241             :  */
    1242             : struct wpa_signal_info {
    1243             :         u32 frequency;
    1244             :         int above_threshold;
    1245             :         int current_signal;
    1246             :         int avg_signal;
    1247             :         int current_noise;
    1248             :         int current_txrate;
    1249             :         enum chan_width chanwidth;
    1250             :         int center_frq1;
    1251             :         int center_frq2;
    1252             : };
    1253             : 
    1254             : /**
    1255             :  * struct beacon_data - Beacon data
    1256             :  * @head: Head portion of Beacon frame (before TIM IE)
    1257             :  * @tail: Tail portion of Beacon frame (after TIM IE)
    1258             :  * @beacon_ies: Extra information element(s) to add into Beacon frames or %NULL
    1259             :  * @proberesp_ies: Extra information element(s) to add into Probe Response
    1260             :  *      frames or %NULL
    1261             :  * @assocresp_ies: Extra information element(s) to add into (Re)Association
    1262             :  *      Response frames or %NULL
    1263             :  * @probe_resp: Probe Response frame template
    1264             :  * @head_len: Length of @head
    1265             :  * @tail_len: Length of @tail
    1266             :  * @beacon_ies_len: Length of beacon_ies in octets
    1267             :  * @proberesp_ies_len: Length of proberesp_ies in octets
    1268             :  * @proberesp_ies_len: Length of proberesp_ies in octets
    1269             :  * @probe_resp_len: Length of probe response template (@probe_resp)
    1270             :  */
    1271             : struct beacon_data {
    1272             :         u8 *head, *tail;
    1273             :         u8 *beacon_ies;
    1274             :         u8 *proberesp_ies;
    1275             :         u8 *assocresp_ies;
    1276             :         u8 *probe_resp;
    1277             : 
    1278             :         size_t head_len, tail_len;
    1279             :         size_t beacon_ies_len;
    1280             :         size_t proberesp_ies_len;
    1281             :         size_t assocresp_ies_len;
    1282             :         size_t probe_resp_len;
    1283             : };
    1284             : 
    1285             : /**
    1286             :  * struct csa_settings - Settings for channel switch command
    1287             :  * @cs_count: Count in Beacon frames (TBTT) to perform the switch
    1288             :  * @block_tx: 1 - block transmission for CSA period
    1289             :  * @freq_params: Next channel frequency parameter
    1290             :  * @beacon_csa: Beacon/probe resp/asooc resp info for CSA period
    1291             :  * @beacon_after: Next beacon/probe resp/asooc resp info
    1292             :  * @counter_offset_beacon: Offset to the count field in beacon's tail
    1293             :  * @counter_offset_presp: Offset to the count field in probe resp.
    1294             :  */
    1295             : struct csa_settings {
    1296             :         u8 cs_count;
    1297             :         u8 block_tx;
    1298             : 
    1299             :         struct hostapd_freq_params freq_params;
    1300             :         struct beacon_data beacon_csa;
    1301             :         struct beacon_data beacon_after;
    1302             : 
    1303             :         u16 counter_offset_beacon;
    1304             :         u16 counter_offset_presp;
    1305             : };
    1306             : 
    1307             : /* TDLS peer capabilities for send_tdls_mgmt() */
    1308             : enum tdls_peer_capability {
    1309             :         TDLS_PEER_HT = BIT(0),
    1310             :         TDLS_PEER_VHT = BIT(1),
    1311             :         TDLS_PEER_WMM = BIT(2),
    1312             : };
    1313             : 
    1314             : #ifdef CONFIG_MACSEC
    1315             : struct macsec_init_params {
    1316             :         Boolean always_include_sci;
    1317             :         Boolean use_es;
    1318             :         Boolean use_scb;
    1319             : };
    1320             : #endif /* CONFIG_MACSEC */
    1321             : 
    1322             : 
    1323             : /**
    1324             :  * struct wpa_driver_ops - Driver interface API definition
    1325             :  *
    1326             :  * This structure defines the API that each driver interface needs to implement
    1327             :  * for core wpa_supplicant code. All driver specific functionality is captured
    1328             :  * in this wrapper.
    1329             :  */
    1330             : struct wpa_driver_ops {
    1331             :         /** Name of the driver interface */
    1332             :         const char *name;
    1333             :         /** One line description of the driver interface */
    1334             :         const char *desc;
    1335             : 
    1336             :         /**
    1337             :          * get_bssid - Get the current BSSID
    1338             :          * @priv: private driver interface data
    1339             :          * @bssid: buffer for BSSID (ETH_ALEN = 6 bytes)
    1340             :          *
    1341             :          * Returns: 0 on success, -1 on failure
    1342             :          *
    1343             :          * Query kernel driver for the current BSSID and copy it to bssid.
    1344             :          * Setting bssid to 00:00:00:00:00:00 is recommended if the STA is not
    1345             :          * associated.
    1346             :          */
    1347             :         int (*get_bssid)(void *priv, u8 *bssid);
    1348             : 
    1349             :         /**
    1350             :          * get_ssid - Get the current SSID
    1351             :          * @priv: private driver interface data
    1352             :          * @ssid: buffer for SSID (at least 32 bytes)
    1353             :          *
    1354             :          * Returns: Length of the SSID on success, -1 on failure
    1355             :          *
    1356             :          * Query kernel driver for the current SSID and copy it to ssid.
    1357             :          * Returning zero is recommended if the STA is not associated.
    1358             :          *
    1359             :          * Note: SSID is an array of octets, i.e., it is not nul terminated and
    1360             :          * can, at least in theory, contain control characters (including nul)
    1361             :          * and as such, should be processed as binary data, not a printable
    1362             :          * string.
    1363             :          */
    1364             :         int (*get_ssid)(void *priv, u8 *ssid);
    1365             : 
    1366             :         /**
    1367             :          * set_key - Configure encryption key
    1368             :          * @ifname: Interface name (for multi-SSID/VLAN support)
    1369             :          * @priv: private driver interface data
    1370             :          * @alg: encryption algorithm (%WPA_ALG_NONE, %WPA_ALG_WEP,
    1371             :          *      %WPA_ALG_TKIP, %WPA_ALG_CCMP, %WPA_ALG_IGTK, %WPA_ALG_PMK,
    1372             :          *      %WPA_ALG_GCMP, %WPA_ALG_GCMP_256, %WPA_ALG_CCMP_256,
    1373             :          *      %WPA_ALG_BIP_GMAC_128, %WPA_ALG_BIP_GMAC_256,
    1374             :          *      %WPA_ALG_BIP_CMAC_256);
    1375             :          *      %WPA_ALG_NONE clears the key.
    1376             :          * @addr: Address of the peer STA (BSSID of the current AP when setting
    1377             :          *      pairwise key in station mode), ff:ff:ff:ff:ff:ff for
    1378             :          *      broadcast keys, %NULL for default keys that are used both for
    1379             :          *      broadcast and unicast; when clearing keys, %NULL is used to
    1380             :          *      indicate that both the broadcast-only and default key of the
    1381             :          *      specified key index is to be cleared
    1382             :          * @key_idx: key index (0..3), usually 0 for unicast keys; 0..4095 for
    1383             :          *      IGTK
    1384             :          * @set_tx: configure this key as the default Tx key (only used when
    1385             :          *      driver does not support separate unicast/individual key
    1386             :          * @seq: sequence number/packet number, seq_len octets, the next
    1387             :          *      packet number to be used for in replay protection; configured
    1388             :          *      for Rx keys (in most cases, this is only used with broadcast
    1389             :          *      keys and set to zero for unicast keys); %NULL if not set
    1390             :          * @seq_len: length of the seq, depends on the algorithm:
    1391             :          *      TKIP: 6 octets, CCMP/GCMP: 6 octets, IGTK: 6 octets
    1392             :          * @key: key buffer; TKIP: 16-byte temporal key, 8-byte Tx Mic key,
    1393             :          *      8-byte Rx Mic Key
    1394             :          * @key_len: length of the key buffer in octets (WEP: 5 or 13,
    1395             :          *      TKIP: 32, CCMP/GCMP: 16, IGTK: 16)
    1396             :          *
    1397             :          * Returns: 0 on success, -1 on failure
    1398             :          *
    1399             :          * Configure the given key for the kernel driver. If the driver
    1400             :          * supports separate individual keys (4 default keys + 1 individual),
    1401             :          * addr can be used to determine whether the key is default or
    1402             :          * individual. If only 4 keys are supported, the default key with key
    1403             :          * index 0 is used as the individual key. STA must be configured to use
    1404             :          * it as the default Tx key (set_tx is set) and accept Rx for all the
    1405             :          * key indexes. In most cases, WPA uses only key indexes 1 and 2 for
    1406             :          * broadcast keys, so key index 0 is available for this kind of
    1407             :          * configuration.
    1408             :          *
    1409             :          * Please note that TKIP keys include separate TX and RX MIC keys and
    1410             :          * some drivers may expect them in different order than wpa_supplicant
    1411             :          * is using. If the TX/RX keys are swapped, all TKIP encrypted packets
    1412             :          * will trigger Michael MIC errors. This can be fixed by changing the
    1413             :          * order of MIC keys by swapping te bytes 16..23 and 24..31 of the key
    1414             :          * in driver_*.c set_key() implementation, see driver_ndis.c for an
    1415             :          * example on how this can be done.
    1416             :          */
    1417             :         int (*set_key)(const char *ifname, void *priv, enum wpa_alg alg,
    1418             :                        const u8 *addr, int key_idx, int set_tx,
    1419             :                        const u8 *seq, size_t seq_len,
    1420             :                        const u8 *key, size_t key_len);
    1421             : 
    1422             :         /**
    1423             :          * init - Initialize driver interface
    1424             :          * @ctx: context to be used when calling wpa_supplicant functions,
    1425             :          * e.g., wpa_supplicant_event()
    1426             :          * @ifname: interface name, e.g., wlan0
    1427             :          *
    1428             :          * Returns: Pointer to private data, %NULL on failure
    1429             :          *
    1430             :          * Initialize driver interface, including event processing for kernel
    1431             :          * driver events (e.g., associated, scan results, Michael MIC failure).
    1432             :          * This function can allocate a private configuration data area for
    1433             :          * @ctx, file descriptor, interface name, etc. information that may be
    1434             :          * needed in future driver operations. If this is not used, non-NULL
    1435             :          * value will need to be returned because %NULL is used to indicate
    1436             :          * failure. The returned value will be used as 'void *priv' data for
    1437             :          * all other driver_ops functions.
    1438             :          *
    1439             :          * The main event loop (eloop.c) of wpa_supplicant can be used to
    1440             :          * register callback for read sockets (eloop_register_read_sock()).
    1441             :          *
    1442             :          * See below for more information about events and
    1443             :          * wpa_supplicant_event() function.
    1444             :          */
    1445             :         void * (*init)(void *ctx, const char *ifname);
    1446             : 
    1447             :         /**
    1448             :          * deinit - Deinitialize driver interface
    1449             :          * @priv: private driver interface data from init()
    1450             :          *
    1451             :          * Shut down driver interface and processing of driver events. Free
    1452             :          * private data buffer if one was allocated in init() handler.
    1453             :          */
    1454             :         void (*deinit)(void *priv);
    1455             : 
    1456             :         /**
    1457             :          * set_param - Set driver configuration parameters
    1458             :          * @priv: private driver interface data from init()
    1459             :          * @param: driver specific configuration parameters
    1460             :          *
    1461             :          * Returns: 0 on success, -1 on failure
    1462             :          *
    1463             :          * Optional handler for notifying driver interface about configuration
    1464             :          * parameters (driver_param).
    1465             :          */
    1466             :         int (*set_param)(void *priv, const char *param);
    1467             : 
    1468             :         /**
    1469             :          * set_countermeasures - Enable/disable TKIP countermeasures
    1470             :          * @priv: private driver interface data
    1471             :          * @enabled: 1 = countermeasures enabled, 0 = disabled
    1472             :          *
    1473             :          * Returns: 0 on success, -1 on failure
    1474             :          *
    1475             :          * Configure TKIP countermeasures. When these are enabled, the driver
    1476             :          * should drop all received and queued frames that are using TKIP.
    1477             :          */
    1478             :         int (*set_countermeasures)(void *priv, int enabled);
    1479             : 
    1480             :         /**
    1481             :          * deauthenticate - Request driver to deauthenticate
    1482             :          * @priv: private driver interface data
    1483             :          * @addr: peer address (BSSID of the AP)
    1484             :          * @reason_code: 16-bit reason code to be sent in the deauthentication
    1485             :          *      frame
    1486             :          *
    1487             :          * Returns: 0 on success, -1 on failure
    1488             :          */
    1489             :         int (*deauthenticate)(void *priv, const u8 *addr, int reason_code);
    1490             : 
    1491             :         /**
    1492             :          * associate - Request driver to associate
    1493             :          * @priv: private driver interface data
    1494             :          * @params: association parameters
    1495             :          *
    1496             :          * Returns: 0 on success, -1 on failure
    1497             :          */
    1498             :         int (*associate)(void *priv,
    1499             :                          struct wpa_driver_associate_params *params);
    1500             : 
    1501             :         /**
    1502             :          * add_pmkid - Add PMKSA cache entry to the driver
    1503             :          * @priv: private driver interface data
    1504             :          * @bssid: BSSID for the PMKSA cache entry
    1505             :          * @pmkid: PMKID for the PMKSA cache entry
    1506             :          *
    1507             :          * Returns: 0 on success, -1 on failure
    1508             :          *
    1509             :          * This function is called when a new PMK is received, as a result of
    1510             :          * either normal authentication or RSN pre-authentication.
    1511             :          *
    1512             :          * If the driver generates RSN IE, i.e., it does not use wpa_ie in
    1513             :          * associate(), add_pmkid() can be used to add new PMKSA cache entries
    1514             :          * in the driver. If the driver uses wpa_ie from wpa_supplicant, this
    1515             :          * driver_ops function does not need to be implemented. Likewise, if
    1516             :          * the driver does not support WPA, this function is not needed.
    1517             :          */
    1518             :         int (*add_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);
    1519             : 
    1520             :         /**
    1521             :          * remove_pmkid - Remove PMKSA cache entry to the driver
    1522             :          * @priv: private driver interface data
    1523             :          * @bssid: BSSID for the PMKSA cache entry
    1524             :          * @pmkid: PMKID for the PMKSA cache entry
    1525             :          *
    1526             :          * Returns: 0 on success, -1 on failure
    1527             :          *
    1528             :          * This function is called when the supplicant drops a PMKSA cache
    1529             :          * entry for any reason.
    1530             :          *
    1531             :          * If the driver generates RSN IE, i.e., it does not use wpa_ie in
    1532             :          * associate(), remove_pmkid() can be used to synchronize PMKSA caches
    1533             :          * between the driver and wpa_supplicant. If the driver uses wpa_ie
    1534             :          * from wpa_supplicant, this driver_ops function does not need to be
    1535             :          * implemented. Likewise, if the driver does not support WPA, this
    1536             :          * function is not needed.
    1537             :          */
    1538             :         int (*remove_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);
    1539             : 
    1540             :         /**
    1541             :          * flush_pmkid - Flush PMKSA cache
    1542             :          * @priv: private driver interface data
    1543             :          *
    1544             :          * Returns: 0 on success, -1 on failure
    1545             :          *
    1546             :          * This function is called when the supplicant drops all PMKSA cache
    1547             :          * entries for any reason.
    1548             :          *
    1549             :          * If the driver generates RSN IE, i.e., it does not use wpa_ie in
    1550             :          * associate(), remove_pmkid() can be used to synchronize PMKSA caches
    1551             :          * between the driver and wpa_supplicant. If the driver uses wpa_ie
    1552             :          * from wpa_supplicant, this driver_ops function does not need to be
    1553             :          * implemented. Likewise, if the driver does not support WPA, this
    1554             :          * function is not needed.
    1555             :          */
    1556             :         int (*flush_pmkid)(void *priv);
    1557             : 
    1558             :         /**
    1559             :          * get_capa - Get driver capabilities
    1560             :          * @priv: private driver interface data
    1561             :          *
    1562             :          * Returns: 0 on success, -1 on failure
    1563             :          *
    1564             :          * Get driver/firmware/hardware capabilities.
    1565             :          */
    1566             :         int (*get_capa)(void *priv, struct wpa_driver_capa *capa);
    1567             : 
    1568             :         /**
    1569             :          * poll - Poll driver for association information
    1570             :          * @priv: private driver interface data
    1571             :          *
    1572             :          * This is an option callback that can be used when the driver does not
    1573             :          * provide event mechanism for association events. This is called when
    1574             :          * receiving WPA EAPOL-Key messages that require association
    1575             :          * information. The driver interface is supposed to generate associnfo
    1576             :          * event before returning from this callback function. In addition, the
    1577             :          * driver interface should generate an association event after having
    1578             :          * sent out associnfo.
    1579             :          */
    1580             :         void (*poll)(void *priv);
    1581             : 
    1582             :         /**
    1583             :          * get_ifname - Get interface name
    1584             :          * @priv: private driver interface data
    1585             :          *
    1586             :          * Returns: Pointer to the interface name. This can differ from the
    1587             :          * interface name used in init() call. Init() is called first.
    1588             :          *
    1589             :          * This optional function can be used to allow the driver interface to
    1590             :          * replace the interface name with something else, e.g., based on an
    1591             :          * interface mapping from a more descriptive name.
    1592             :          */
    1593             :         const char * (*get_ifname)(void *priv);
    1594             : 
    1595             :         /**
    1596             :          * get_mac_addr - Get own MAC address
    1597             :          * @priv: private driver interface data
    1598             :          *
    1599             :          * Returns: Pointer to own MAC address or %NULL on failure
    1600             :          *
    1601             :          * This optional function can be used to get the own MAC address of the
    1602             :          * device from the driver interface code. This is only needed if the
    1603             :          * l2_packet implementation for the OS does not provide easy access to
    1604             :          * a MAC address. */
    1605             :         const u8 * (*get_mac_addr)(void *priv);
    1606             : 
    1607             :         /**
    1608             :          * send_eapol - Optional function for sending EAPOL packets
    1609             :          * @priv: private driver interface data
    1610             :          * @dest: Destination MAC address
    1611             :          * @proto: Ethertype
    1612             :          * @data: EAPOL packet starting with IEEE 802.1X header
    1613             :          * @data_len: Size of the EAPOL packet
    1614             :          *
    1615             :          * Returns: 0 on success, -1 on failure
    1616             :          *
    1617             :          * This optional function can be used to override l2_packet operations
    1618             :          * with driver specific functionality. If this function pointer is set,
    1619             :          * l2_packet module is not used at all and the driver interface code is
    1620             :          * responsible for receiving and sending all EAPOL packets. The
    1621             :          * received EAPOL packets are sent to core code with EVENT_EAPOL_RX
    1622             :          * event. The driver interface is required to implement get_mac_addr()
    1623             :          * handler if send_eapol() is used.
    1624             :          */
    1625             :         int (*send_eapol)(void *priv, const u8 *dest, u16 proto,
    1626             :                           const u8 *data, size_t data_len);
    1627             : 
    1628             :         /**
    1629             :          * set_operstate - Sets device operating state to DORMANT or UP
    1630             :          * @priv: private driver interface data
    1631             :          * @state: 0 = dormant, 1 = up
    1632             :          * Returns: 0 on success, -1 on failure
    1633             :          *
    1634             :          * This is an optional function that can be used on operating systems
    1635             :          * that support a concept of controlling network device state from user
    1636             :          * space applications. This function, if set, gets called with
    1637             :          * state = 1 when authentication has been completed and with state = 0
    1638             :          * when connection is lost.
    1639             :          */
    1640             :         int (*set_operstate)(void *priv, int state);
    1641             : 
    1642             :         /**
    1643             :          * mlme_setprotection - MLME-SETPROTECTION.request primitive
    1644             :          * @priv: Private driver interface data
    1645             :          * @addr: Address of the station for which to set protection (may be
    1646             :          * %NULL for group keys)
    1647             :          * @protect_type: MLME_SETPROTECTION_PROTECT_TYPE_*
    1648             :          * @key_type: MLME_SETPROTECTION_KEY_TYPE_*
    1649             :          * Returns: 0 on success, -1 on failure
    1650             :          *
    1651             :          * This is an optional function that can be used to set the driver to
    1652             :          * require protection for Tx and/or Rx frames. This uses the layer
    1653             :          * interface defined in IEEE 802.11i-2004 clause 10.3.22.1
    1654             :          * (MLME-SETPROTECTION.request). Many drivers do not use explicit
    1655             :          * set protection operation; instead, they set protection implicitly
    1656             :          * based on configured keys.
    1657             :          */
    1658             :         int (*mlme_setprotection)(void *priv, const u8 *addr, int protect_type,
    1659             :                                   int key_type);
    1660             : 
    1661             :         /**
    1662             :          * get_hw_feature_data - Get hardware support data (channels and rates)
    1663             :          * @priv: Private driver interface data
    1664             :          * @num_modes: Variable for returning the number of returned modes
    1665             :          * flags: Variable for returning hardware feature flags
    1666             :          * Returns: Pointer to allocated hardware data on success or %NULL on
    1667             :          * failure. Caller is responsible for freeing this.
    1668             :          */
    1669             :         struct hostapd_hw_modes * (*get_hw_feature_data)(void *priv,
    1670             :                                                          u16 *num_modes,
    1671             :                                                          u16 *flags);
    1672             : 
    1673             :         /**
    1674             :          * send_mlme - Send management frame from MLME
    1675             :          * @priv: Private driver interface data
    1676             :          * @data: IEEE 802.11 management frame with IEEE 802.11 header
    1677             :          * @data_len: Size of the management frame
    1678             :          * @noack: Do not wait for this frame to be acked (disable retries)
    1679             :          * Returns: 0 on success, -1 on failure
    1680             :          */
    1681             :         int (*send_mlme)(void *priv, const u8 *data, size_t data_len,
    1682             :                          int noack);
    1683             : 
    1684             :         /**
    1685             :          * update_ft_ies - Update FT (IEEE 802.11r) IEs
    1686             :          * @priv: Private driver interface data
    1687             :          * @md: Mobility domain (2 octets) (also included inside ies)
    1688             :          * @ies: FT IEs (MDIE, FTIE, ...) or %NULL to remove IEs
    1689             :          * @ies_len: Length of FT IEs in bytes
    1690             :          * Returns: 0 on success, -1 on failure
    1691             :          *
    1692             :          * The supplicant uses this callback to let the driver know that keying
    1693             :          * material for FT is available and that the driver can use the
    1694             :          * provided IEs in the next message in FT authentication sequence.
    1695             :          *
    1696             :          * This function is only needed for driver that support IEEE 802.11r
    1697             :          * (Fast BSS Transition).
    1698             :          */
    1699             :         int (*update_ft_ies)(void *priv, const u8 *md, const u8 *ies,
    1700             :                              size_t ies_len);
    1701             : 
    1702             :         /**
    1703             :          * send_ft_action - Send FT Action frame (IEEE 802.11r)
    1704             :          * @priv: Private driver interface data
    1705             :          * @action: Action field value
    1706             :          * @target_ap: Target AP address
    1707             :          * @ies: FT IEs (MDIE, FTIE, ...) (FT Request action frame body)
    1708             :          * @ies_len: Length of FT IEs in bytes
    1709             :          * Returns: 0 on success, -1 on failure
    1710             :          *
    1711             :          * The supplicant uses this callback to request the driver to transmit
    1712             :          * an FT Action frame (action category 6) for over-the-DS fast BSS
    1713             :          * transition.
    1714             :          */
    1715             :         int (*send_ft_action)(void *priv, u8 action, const u8 *target_ap,
    1716             :                               const u8 *ies, size_t ies_len);
    1717             : 
    1718             :         /**
    1719             :          * get_scan_results2 - Fetch the latest scan results
    1720             :          * @priv: private driver interface data
    1721             :          *
    1722             :          * Returns: Allocated buffer of scan results (caller is responsible for
    1723             :          * freeing the data structure) on success, NULL on failure
    1724             :          */
    1725             :          struct wpa_scan_results * (*get_scan_results2)(void *priv);
    1726             : 
    1727             :         /**
    1728             :          * set_country - Set country
    1729             :          * @priv: Private driver interface data
    1730             :          * @alpha2: country to which to switch to
    1731             :          * Returns: 0 on success, -1 on failure
    1732             :          *
    1733             :          * This function is for drivers which support some form
    1734             :          * of setting a regulatory domain.
    1735             :          */
    1736             :         int (*set_country)(void *priv, const char *alpha2);
    1737             : 
    1738             :         /**
    1739             :          * get_country - Get country
    1740             :          * @priv: Private driver interface data
    1741             :          * @alpha2: Buffer for returning country code (at least 3 octets)
    1742             :          * Returns: 0 on success, -1 on failure
    1743             :          */
    1744             :         int (*get_country)(void *priv, char *alpha2);
    1745             : 
    1746             :         /**
    1747             :          * global_init - Global driver initialization
    1748             :          * Returns: Pointer to private data (global), %NULL on failure
    1749             :          *
    1750             :          * This optional function is called to initialize the driver wrapper
    1751             :          * for global data, i.e., data that applies to all interfaces. If this
    1752             :          * function is implemented, global_deinit() will also need to be
    1753             :          * implemented to free the private data. The driver will also likely
    1754             :          * use init2() function instead of init() to get the pointer to global
    1755             :          * data available to per-interface initializer.
    1756             :          */
    1757             :         void * (*global_init)(void);
    1758             : 
    1759             :         /**
    1760             :          * global_deinit - Global driver deinitialization
    1761             :          * @priv: private driver global data from global_init()
    1762             :          *
    1763             :          * Terminate any global driver related functionality and free the
    1764             :          * global data structure.
    1765             :          */
    1766             :         void (*global_deinit)(void *priv);
    1767             : 
    1768             :         /**
    1769             :          * init2 - Initialize driver interface (with global data)
    1770             :          * @ctx: context to be used when calling wpa_supplicant functions,
    1771             :          * e.g., wpa_supplicant_event()
    1772             :          * @ifname: interface name, e.g., wlan0
    1773             :          * @global_priv: private driver global data from global_init()
    1774             :          * Returns: Pointer to private data, %NULL on failure
    1775             :          *
    1776             :          * This function can be used instead of init() if the driver wrapper
    1777             :          * uses global data.
    1778             :          */
    1779             :         void * (*init2)(void *ctx, const char *ifname, void *global_priv);
    1780             : 
    1781             :         /**
    1782             :          * get_interfaces - Get information about available interfaces
    1783             :          * @global_priv: private driver global data from global_init()
    1784             :          * Returns: Allocated buffer of interface information (caller is
    1785             :          * responsible for freeing the data structure) on success, NULL on
    1786             :          * failure
    1787             :          */
    1788             :         struct wpa_interface_info * (*get_interfaces)(void *global_priv);
    1789             : 
    1790             :         /**
    1791             :          * scan2 - Request the driver to initiate scan
    1792             :          * @priv: private driver interface data
    1793             :          * @params: Scan parameters
    1794             :          *
    1795             :          * Returns: 0 on success, -1 on failure
    1796             :          *
    1797             :          * Once the scan results are ready, the driver should report scan
    1798             :          * results event for wpa_supplicant which will eventually request the
    1799             :          * results with wpa_driver_get_scan_results2().
    1800             :          */
    1801             :         int (*scan2)(void *priv, struct wpa_driver_scan_params *params);
    1802             : 
    1803             :         /**
    1804             :          * authenticate - Request driver to authenticate
    1805             :          * @priv: private driver interface data
    1806             :          * @params: authentication parameters
    1807             :          * Returns: 0 on success, -1 on failure
    1808             :          *
    1809             :          * This is an optional function that can be used with drivers that
    1810             :          * support separate authentication and association steps, i.e., when
    1811             :          * wpa_supplicant can act as the SME. If not implemented, associate()
    1812             :          * function is expected to take care of IEEE 802.11 authentication,
    1813             :          * too.
    1814             :          */
    1815             :         int (*authenticate)(void *priv,
    1816             :                             struct wpa_driver_auth_params *params);
    1817             : 
    1818             :         /**
    1819             :          * set_ap - Set Beacon and Probe Response information for AP mode
    1820             :          * @priv: Private driver interface data
    1821             :          * @params: Parameters to use in AP mode
    1822             :          *
    1823             :          * This function is used to configure Beacon template and/or extra IEs
    1824             :          * to add for Beacon and Probe Response frames for the driver in
    1825             :          * AP mode. The driver is responsible for building the full Beacon
    1826             :          * frame by concatenating the head part with TIM IE generated by the
    1827             :          * driver/firmware and finishing with the tail part. Depending on the
    1828             :          * driver architectue, this can be done either by using the full
    1829             :          * template or the set of additional IEs (e.g., WPS and P2P IE).
    1830             :          * Similarly, Probe Response processing depends on the driver design.
    1831             :          * If the driver (or firmware) takes care of replying to Probe Request
    1832             :          * frames, the extra IEs provided here needs to be added to the Probe
    1833             :          * Response frames.
    1834             :          *
    1835             :          * Returns: 0 on success, -1 on failure
    1836             :          */
    1837             :         int (*set_ap)(void *priv, struct wpa_driver_ap_params *params);
    1838             : 
    1839             :         /**
    1840             :          * set_acl - Set ACL in AP mode
    1841             :          * @priv: Private driver interface data
    1842             :          * @params: Parameters to configure ACL
    1843             :          * Returns: 0 on success, -1 on failure
    1844             :          *
    1845             :          * This is used only for the drivers which support MAC address ACL.
    1846             :          */
    1847             :         int (*set_acl)(void *priv, struct hostapd_acl_params *params);
    1848             : 
    1849             :         /**
    1850             :          * hapd_init - Initialize driver interface (hostapd only)
    1851             :          * @hapd: Pointer to hostapd context
    1852             :          * @params: Configuration for the driver wrapper
    1853             :          * Returns: Pointer to private data, %NULL on failure
    1854             :          *
    1855             :          * This function is used instead of init() or init2() when the driver
    1856             :          * wrapper is used with hostapd.
    1857             :          */
    1858             :         void * (*hapd_init)(struct hostapd_data *hapd,
    1859             :                             struct wpa_init_params *params);
    1860             : 
    1861             :         /**
    1862             :          * hapd_deinit - Deinitialize driver interface (hostapd only)
    1863             :          * @priv: Private driver interface data from hapd_init()
    1864             :          */
    1865             :         void (*hapd_deinit)(void *priv);
    1866             : 
    1867             :         /**
    1868             :          * set_ieee8021x - Enable/disable IEEE 802.1X support (AP only)
    1869             :          * @priv: Private driver interface data
    1870             :          * @params: BSS parameters
    1871             :          * Returns: 0 on success, -1 on failure
    1872             :          *
    1873             :          * This is an optional function to configure the kernel driver to
    1874             :          * enable/disable IEEE 802.1X support and set WPA/WPA2 parameters. This
    1875             :          * can be left undefined (set to %NULL) if IEEE 802.1X support is
    1876             :          * always enabled and the driver uses set_ap() to set WPA/RSN IE
    1877             :          * for Beacon frames.
    1878             :          *
    1879             :          * DEPRECATED - use set_ap() instead
    1880             :          */
    1881             :         int (*set_ieee8021x)(void *priv, struct wpa_bss_params *params);
    1882             : 
    1883             :         /**
    1884             :          * set_privacy - Enable/disable privacy (AP only)
    1885             :          * @priv: Private driver interface data
    1886             :          * @enabled: 1 = privacy enabled, 0 = disabled
    1887             :          * Returns: 0 on success, -1 on failure
    1888             :          *
    1889             :          * This is an optional function to configure privacy field in the
    1890             :          * kernel driver for Beacon frames. This can be left undefined (set to
    1891             :          * %NULL) if the driver uses the Beacon template from set_ap().
    1892             :          *
    1893             :          * DEPRECATED - use set_ap() instead
    1894             :          */
    1895             :         int (*set_privacy)(void *priv, int enabled);
    1896             : 
    1897             :         /**
    1898             :          * get_seqnum - Fetch the current TSC/packet number (AP only)
    1899             :          * @ifname: The interface name (main or virtual)
    1900             :          * @priv: Private driver interface data
    1901             :          * @addr: MAC address of the station or %NULL for group keys
    1902             :          * @idx: Key index
    1903             :          * @seq: Buffer for returning the latest used TSC/packet number
    1904             :          * Returns: 0 on success, -1 on failure
    1905             :          *
    1906             :          * This function is used to fetch the last used TSC/packet number for
    1907             :          * a TKIP, CCMP, GCMP, or BIP/IGTK key. It is mainly used with group
    1908             :          * keys, so there is no strict requirement on implementing support for
    1909             :          * unicast keys (i.e., addr != %NULL).
    1910             :          */
    1911             :         int (*get_seqnum)(const char *ifname, void *priv, const u8 *addr,
    1912             :                           int idx, u8 *seq);
    1913             : 
    1914             :         /**
    1915             :          * flush - Flush all association stations (AP only)
    1916             :          * @priv: Private driver interface data
    1917             :          * Returns: 0 on success, -1 on failure
    1918             :          *
    1919             :          * This function requests the driver to disassociate all associated
    1920             :          * stations. This function does not need to be implemented if the
    1921             :          * driver does not process association frames internally.
    1922             :          */
    1923             :         int (*flush)(void *priv);
    1924             : 
    1925             :         /**
    1926             :          * set_generic_elem - Add IEs into Beacon/Probe Response frames (AP)
    1927             :          * @priv: Private driver interface data
    1928             :          * @elem: Information elements
    1929             :          * @elem_len: Length of the elem buffer in octets
    1930             :          * Returns: 0 on success, -1 on failure
    1931             :          *
    1932             :          * This is an optional function to add information elements in the
    1933             :          * kernel driver for Beacon and Probe Response frames. This can be left
    1934             :          * undefined (set to %NULL) if the driver uses the Beacon template from
    1935             :          * set_ap().
    1936             :          *
    1937             :          * DEPRECATED - use set_ap() instead
    1938             :          */
    1939             :         int (*set_generic_elem)(void *priv, const u8 *elem, size_t elem_len);
    1940             : 
    1941             :         /**
    1942             :          * read_sta_data - Fetch station data
    1943             :          * @priv: Private driver interface data
    1944             :          * @data: Buffer for returning station information
    1945             :          * @addr: MAC address of the station
    1946             :          * Returns: 0 on success, -1 on failure
    1947             :          */
    1948             :         int (*read_sta_data)(void *priv, struct hostap_sta_driver_data *data,
    1949             :                              const u8 *addr);
    1950             : 
    1951             :         /**
    1952             :          * hapd_send_eapol - Send an EAPOL packet (AP only)
    1953             :          * @priv: private driver interface data
    1954             :          * @addr: Destination MAC address
    1955             :          * @data: EAPOL packet starting with IEEE 802.1X header
    1956             :          * @data_len: Length of the EAPOL packet in octets
    1957             :          * @encrypt: Whether the frame should be encrypted
    1958             :          * @own_addr: Source MAC address
    1959             :          * @flags: WPA_STA_* flags for the destination station
    1960             :          *
    1961             :          * Returns: 0 on success, -1 on failure
    1962             :          */
    1963             :         int (*hapd_send_eapol)(void *priv, const u8 *addr, const u8 *data,
    1964             :                                size_t data_len, int encrypt,
    1965             :                                const u8 *own_addr, u32 flags);
    1966             : 
    1967             :         /**
    1968             :          * sta_deauth - Deauthenticate a station (AP only)
    1969             :          * @priv: Private driver interface data
    1970             :          * @own_addr: Source address and BSSID for the Deauthentication frame
    1971             :          * @addr: MAC address of the station to deauthenticate
    1972             :          * @reason: Reason code for the Deauthentiation frame
    1973             :          * Returns: 0 on success, -1 on failure
    1974             :          *
    1975             :          * This function requests a specific station to be deauthenticated and
    1976             :          * a Deauthentication frame to be sent to it.
    1977             :          */
    1978             :         int (*sta_deauth)(void *priv, const u8 *own_addr, const u8 *addr,
    1979             :                           int reason);
    1980             : 
    1981             :         /**
    1982             :          * sta_disassoc - Disassociate a station (AP only)
    1983             :          * @priv: Private driver interface data
    1984             :          * @own_addr: Source address and BSSID for the Disassociation frame
    1985             :          * @addr: MAC address of the station to disassociate
    1986             :          * @reason: Reason code for the Disassociation frame
    1987             :          * Returns: 0 on success, -1 on failure
    1988             :          *
    1989             :          * This function requests a specific station to be disassociated and
    1990             :          * a Disassociation frame to be sent to it.
    1991             :          */
    1992             :         int (*sta_disassoc)(void *priv, const u8 *own_addr, const u8 *addr,
    1993             :                             int reason);
    1994             : 
    1995             :         /**
    1996             :          * sta_remove - Remove a station entry (AP only)
    1997             :          * @priv: Private driver interface data
    1998             :          * @addr: MAC address of the station to be removed
    1999             :          * Returns: 0 on success, -1 on failure
    2000             :          */
    2001             :         int (*sta_remove)(void *priv, const u8 *addr);
    2002             : 
    2003             :         /**
    2004             :          * hapd_get_ssid - Get the current SSID (AP only)
    2005             :          * @priv: Private driver interface data
    2006             :          * @buf: Buffer for returning the SSID
    2007             :          * @len: Maximum length of the buffer
    2008             :          * Returns: Length of the SSID on success, -1 on failure
    2009             :          *
    2010             :          * This function need not be implemented if the driver uses Beacon
    2011             :          * template from set_ap() and does not reply to Probe Request frames.
    2012             :          */
    2013             :         int (*hapd_get_ssid)(void *priv, u8 *buf, int len);
    2014             : 
    2015             :         /**
    2016             :          * hapd_set_ssid - Set SSID (AP only)
    2017             :          * @priv: Private driver interface data
    2018             :          * @buf: SSID
    2019             :          * @len: Length of the SSID in octets
    2020             :          * Returns: 0 on success, -1 on failure
    2021             :          *
    2022             :          * DEPRECATED - use set_ap() instead
    2023             :          */
    2024             :         int (*hapd_set_ssid)(void *priv, const u8 *buf, int len);
    2025             : 
    2026             :         /**
    2027             :          * hapd_set_countermeasures - Enable/disable TKIP countermeasures (AP)
    2028             :          * @priv: Private driver interface data
    2029             :          * @enabled: 1 = countermeasures enabled, 0 = disabled
    2030             :          * Returns: 0 on success, -1 on failure
    2031             :          *
    2032             :          * This need not be implemented if the driver does not take care of
    2033             :          * association processing.
    2034             :          */
    2035             :         int (*hapd_set_countermeasures)(void *priv, int enabled);
    2036             : 
    2037             :         /**
    2038             :          * sta_add - Add a station entry
    2039             :          * @priv: Private driver interface data
    2040             :          * @params: Station parameters
    2041             :          * Returns: 0 on success, -1 on failure
    2042             :          *
    2043             :          * This function is used to add a station entry to the driver once the
    2044             :          * station has completed association. This is only used if the driver
    2045             :          * does not take care of association processing.
    2046             :          *
    2047             :          * With TDLS, this function is also used to add or set (params->set 1)
    2048             :          * TDLS peer entries.
    2049             :          */
    2050             :         int (*sta_add)(void *priv, struct hostapd_sta_add_params *params);
    2051             : 
    2052             :         /**
    2053             :          * get_inact_sec - Get station inactivity duration (AP only)
    2054             :          * @priv: Private driver interface data
    2055             :          * @addr: Station address
    2056             :          * Returns: Number of seconds station has been inactive, -1 on failure
    2057             :          */
    2058             :         int (*get_inact_sec)(void *priv, const u8 *addr);
    2059             : 
    2060             :         /**
    2061             :          * sta_clear_stats - Clear station statistics (AP only)
    2062             :          * @priv: Private driver interface data
    2063             :          * @addr: Station address
    2064             :          * Returns: 0 on success, -1 on failure
    2065             :          */
    2066             :         int (*sta_clear_stats)(void *priv, const u8 *addr);
    2067             : 
    2068             :         /**
    2069             :          * set_freq - Set channel/frequency (AP only)
    2070             :          * @priv: Private driver interface data
    2071             :          * @freq: Channel parameters
    2072             :          * Returns: 0 on success, -1 on failure
    2073             :          */
    2074             :         int (*set_freq)(void *priv, struct hostapd_freq_params *freq);
    2075             : 
    2076             :         /**
    2077             :          * set_rts - Set RTS threshold
    2078             :          * @priv: Private driver interface data
    2079             :          * @rts: RTS threshold in octets
    2080             :          * Returns: 0 on success, -1 on failure
    2081             :          */
    2082             :         int (*set_rts)(void *priv, int rts);
    2083             : 
    2084             :         /**
    2085             :          * set_frag - Set fragmentation threshold
    2086             :          * @priv: Private driver interface data
    2087             :          * @frag: Fragmentation threshold in octets
    2088             :          * Returns: 0 on success, -1 on failure
    2089             :          */
    2090             :         int (*set_frag)(void *priv, int frag);
    2091             : 
    2092             :         /**
    2093             :          * sta_set_flags - Set station flags (AP only)
    2094             :          * @priv: Private driver interface data
    2095             :          * @addr: Station address
    2096             :          * @total_flags: Bitmap of all WPA_STA_* flags currently set
    2097             :          * @flags_or: Bitmap of WPA_STA_* flags to add
    2098             :          * @flags_and: Bitmap of WPA_STA_* flags to us as a mask
    2099             :          * Returns: 0 on success, -1 on failure
    2100             :          */
    2101             :         int (*sta_set_flags)(void *priv, const u8 *addr,
    2102             :                              int total_flags, int flags_or, int flags_and);
    2103             : 
    2104             :         /**
    2105             :          * set_tx_queue_params - Set TX queue parameters
    2106             :          * @priv: Private driver interface data
    2107             :          * @queue: Queue number (0 = VO, 1 = VI, 2 = BE, 3 = BK)
    2108             :          * @aifs: AIFS
    2109             :          * @cw_min: cwMin
    2110             :          * @cw_max: cwMax
    2111             :          * @burst_time: Maximum length for bursting in 0.1 msec units
    2112             :          */
    2113             :         int (*set_tx_queue_params)(void *priv, int queue, int aifs, int cw_min,
    2114             :                                    int cw_max, int burst_time);
    2115             : 
    2116             :         /**
    2117             :          * if_add - Add a virtual interface
    2118             :          * @priv: Private driver interface data
    2119             :          * @type: Interface type
    2120             :          * @ifname: Interface name for the new virtual interface
    2121             :          * @addr: Local address to use for the interface or %NULL to use the
    2122             :          *      parent interface address
    2123             :          * @bss_ctx: BSS context for %WPA_IF_AP_BSS interfaces
    2124             :          * @drv_priv: Pointer for overwriting the driver context or %NULL if
    2125             :          *      not allowed (applies only to %WPA_IF_AP_BSS type)
    2126             :          * @force_ifname: Buffer for returning an interface name that the
    2127             :          *      driver ended up using if it differs from the requested ifname
    2128             :          * @if_addr: Buffer for returning the allocated interface address
    2129             :          *      (this may differ from the requested addr if the driver cannot
    2130             :          *      change interface address)
    2131             :          * @bridge: Bridge interface to use or %NULL if no bridge configured
    2132             :          * @use_existing: Whether to allow existing interface to be used
    2133             :          * Returns: 0 on success, -1 on failure
    2134             :          */
    2135             :         int (*if_add)(void *priv, enum wpa_driver_if_type type,
    2136             :                       const char *ifname, const u8 *addr, void *bss_ctx,
    2137             :                       void **drv_priv, char *force_ifname, u8 *if_addr,
    2138             :                       const char *bridge, int use_existing);
    2139             : 
    2140             :         /**
    2141             :          * if_remove - Remove a virtual interface
    2142             :          * @priv: Private driver interface data
    2143             :          * @type: Interface type
    2144             :          * @ifname: Interface name of the virtual interface to be removed
    2145             :          * Returns: 0 on success, -1 on failure
    2146             :          */
    2147             :         int (*if_remove)(void *priv, enum wpa_driver_if_type type,
    2148             :                          const char *ifname);
    2149             : 
    2150             :         /**
    2151             :          * set_sta_vlan - Bind a station into a specific interface (AP only)
    2152             :          * @priv: Private driver interface data
    2153             :          * @ifname: Interface (main or virtual BSS or VLAN)
    2154             :          * @addr: MAC address of the associated station
    2155             :          * @vlan_id: VLAN ID
    2156             :          * Returns: 0 on success, -1 on failure
    2157             :          *
    2158             :          * This function is used to bind a station to a specific virtual
    2159             :          * interface. It is only used if when virtual interfaces are supported,
    2160             :          * e.g., to assign stations to different VLAN interfaces based on
    2161             :          * information from a RADIUS server. This allows separate broadcast
    2162             :          * domains to be used with a single BSS.
    2163             :          */
    2164             :         int (*set_sta_vlan)(void *priv, const u8 *addr, const char *ifname,
    2165             :                             int vlan_id);
    2166             : 
    2167             :         /**
    2168             :          * commit - Optional commit changes handler (AP only)
    2169             :          * @priv: driver private data
    2170             :          * Returns: 0 on success, -1 on failure
    2171             :          *
    2172             :          * This optional handler function can be registered if the driver
    2173             :          * interface implementation needs to commit changes (e.g., by setting
    2174             :          * network interface up) at the end of initial configuration. If set,
    2175             :          * this handler will be called after initial setup has been completed.
    2176             :          */
    2177             :         int (*commit)(void *priv);
    2178             : 
    2179             :         /**
    2180             :          * send_ether - Send an ethernet packet (AP only)
    2181             :          * @priv: private driver interface data
    2182             :          * @dst: Destination MAC address
    2183             :          * @src: Source MAC address
    2184             :          * @proto: Ethertype
    2185             :          * @data: EAPOL packet starting with IEEE 802.1X header
    2186             :          * @data_len: Length of the EAPOL packet in octets
    2187             :          * Returns: 0 on success, -1 on failure
    2188             :          */
    2189             :         int (*send_ether)(void *priv, const u8 *dst, const u8 *src, u16 proto,
    2190             :                           const u8 *data, size_t data_len);
    2191             : 
    2192             :         /**
    2193             :          * set_radius_acl_auth - Notification of RADIUS ACL change
    2194             :          * @priv: Private driver interface data
    2195             :          * @mac: MAC address of the station
    2196             :          * @accepted: Whether the station was accepted
    2197             :          * @session_timeout: Session timeout for the station
    2198             :          * Returns: 0 on success, -1 on failure
    2199             :          */
    2200             :         int (*set_radius_acl_auth)(void *priv, const u8 *mac, int accepted,
    2201             :                                    u32 session_timeout);
    2202             : 
    2203             :         /**
    2204             :          * set_radius_acl_expire - Notification of RADIUS ACL expiration
    2205             :          * @priv: Private driver interface data
    2206             :          * @mac: MAC address of the station
    2207             :          * Returns: 0 on success, -1 on failure
    2208             :          */
    2209             :         int (*set_radius_acl_expire)(void *priv, const u8 *mac);
    2210             : 
    2211             :         /**
    2212             :          * set_ap_wps_ie - Add WPS IE(s) into Beacon/Probe Response frames (AP)
    2213             :          * @priv: Private driver interface data
    2214             :          * @beacon: WPS IE(s) for Beacon frames or %NULL to remove extra IE(s)
    2215             :          * @proberesp: WPS IE(s) for Probe Response frames or %NULL to remove
    2216             :          *      extra IE(s)
    2217             :          * @assocresp: WPS IE(s) for (Re)Association Response frames or %NULL
    2218             :          *      to remove extra IE(s)
    2219             :          * Returns: 0 on success, -1 on failure
    2220             :          *
    2221             :          * This is an optional function to add WPS IE in the kernel driver for
    2222             :          * Beacon and Probe Response frames. This can be left undefined (set
    2223             :          * to %NULL) if the driver uses the Beacon template from set_ap()
    2224             :          * and does not process Probe Request frames. If the driver takes care
    2225             :          * of (Re)Association frame processing, the assocresp buffer includes
    2226             :          * WPS IE(s) that need to be added to (Re)Association Response frames
    2227             :          * whenever a (Re)Association Request frame indicated use of WPS.
    2228             :          *
    2229             :          * This will also be used to add P2P IE(s) into Beacon/Probe Response
    2230             :          * frames when operating as a GO. The driver is responsible for adding
    2231             :          * timing related attributes (e.g., NoA) in addition to the IEs
    2232             :          * included here by appending them after these buffers. This call is
    2233             :          * also used to provide Probe Response IEs for P2P Listen state
    2234             :          * operations for drivers that generate the Probe Response frames
    2235             :          * internally.
    2236             :          *
    2237             :          * DEPRECATED - use set_ap() instead
    2238             :          */
    2239             :         int (*set_ap_wps_ie)(void *priv, const struct wpabuf *beacon,
    2240             :                              const struct wpabuf *proberesp,
    2241             :                              const struct wpabuf *assocresp);
    2242             : 
    2243             :         /**
    2244             :          * set_supp_port - Set IEEE 802.1X Supplicant Port status
    2245             :          * @priv: Private driver interface data
    2246             :          * @authorized: Whether the port is authorized
    2247             :          * Returns: 0 on success, -1 on failure
    2248             :          */
    2249             :         int (*set_supp_port)(void *priv, int authorized);
    2250             : 
    2251             :         /**
    2252             :          * set_wds_sta - Bind a station into a 4-address WDS (AP only)
    2253             :          * @priv: Private driver interface data
    2254             :          * @addr: MAC address of the associated station
    2255             :          * @aid: Association ID
    2256             :          * @val: 1 = bind to 4-address WDS; 0 = unbind
    2257             :          * @bridge_ifname: Bridge interface to use for the WDS station or %NULL
    2258             :          *      to indicate that bridge is not to be used
    2259             :          * @ifname_wds: Buffer to return the interface name for the new WDS
    2260             :          *      station or %NULL to indicate name is not returned.
    2261             :          * Returns: 0 on success, -1 on failure
    2262             :          */
    2263             :         int (*set_wds_sta)(void *priv, const u8 *addr, int aid, int val,
    2264             :                            const char *bridge_ifname, char *ifname_wds);
    2265             : 
    2266             :         /**
    2267             :          * send_action - Transmit an Action frame
    2268             :          * @priv: Private driver interface data
    2269             :          * @freq: Frequency (in MHz) of the channel
    2270             :          * @wait: Time to wait off-channel for a response (in ms), or zero
    2271             :          * @dst: Destination MAC address (Address 1)
    2272             :          * @src: Source MAC address (Address 2)
    2273             :          * @bssid: BSSID (Address 3)
    2274             :          * @data: Frame body
    2275             :          * @data_len: data length in octets
    2276             :          @ @no_cck: Whether CCK rates must not be used to transmit this frame
    2277             :          * Returns: 0 on success, -1 on failure
    2278             :          *
    2279             :          * This command can be used to request the driver to transmit an action
    2280             :          * frame to the specified destination.
    2281             :          *
    2282             :          * If the %WPA_DRIVER_FLAGS_OFFCHANNEL_TX flag is set, the frame will
    2283             :          * be transmitted on the given channel and the device will wait for a
    2284             :          * response on that channel for the given wait time.
    2285             :          *
    2286             :          * If the flag is not set, the wait time will be ignored. In this case,
    2287             :          * if a remain-on-channel duration is in progress, the frame must be
    2288             :          * transmitted on that channel; alternatively the frame may be sent on
    2289             :          * the current operational channel (if in associated state in station
    2290             :          * mode or while operating as an AP.)
    2291             :          */
    2292             :         int (*send_action)(void *priv, unsigned int freq, unsigned int wait,
    2293             :                            const u8 *dst, const u8 *src, const u8 *bssid,
    2294             :                            const u8 *data, size_t data_len, int no_cck);
    2295             : 
    2296             :         /**
    2297             :          * send_action_cancel_wait - Cancel action frame TX wait
    2298             :          * @priv: Private driver interface data
    2299             :          *
    2300             :          * This command cancels the wait time associated with sending an action
    2301             :          * frame. It is only available when %WPA_DRIVER_FLAGS_OFFCHANNEL_TX is
    2302             :          * set in the driver flags.
    2303             :          */
    2304             :         void (*send_action_cancel_wait)(void *priv);
    2305             : 
    2306             :         /**
    2307             :          * remain_on_channel - Remain awake on a channel
    2308             :          * @priv: Private driver interface data
    2309             :          * @freq: Frequency (in MHz) of the channel
    2310             :          * @duration: Duration in milliseconds
    2311             :          * Returns: 0 on success, -1 on failure
    2312             :          *
    2313             :          * This command is used to request the driver to remain awake on the
    2314             :          * specified channel for the specified duration and report received
    2315             :          * Action frames with EVENT_RX_MGMT events. Optionally, received
    2316             :          * Probe Request frames may also be requested to be reported by calling
    2317             :          * probe_req_report(). These will be reported with EVENT_RX_PROBE_REQ.
    2318             :          *
    2319             :          * The driver may not be at the requested channel when this function
    2320             :          * returns, i.e., the return code is only indicating whether the
    2321             :          * request was accepted. The caller will need to wait until the
    2322             :          * EVENT_REMAIN_ON_CHANNEL event indicates that the driver has
    2323             :          * completed the channel change. This may take some time due to other
    2324             :          * need for the radio and the caller should be prepared to timing out
    2325             :          * its wait since there are no guarantees on when this request can be
    2326             :          * executed.
    2327             :          */
    2328             :         int (*remain_on_channel)(void *priv, unsigned int freq,
    2329             :                                  unsigned int duration);
    2330             : 
    2331             :         /**
    2332             :          * cancel_remain_on_channel - Cancel remain-on-channel operation
    2333             :          * @priv: Private driver interface data
    2334             :          *
    2335             :          * This command can be used to cancel a remain-on-channel operation
    2336             :          * before its originally requested duration has passed. This could be
    2337             :          * used, e.g., when remain_on_channel() is used to request extra time
    2338             :          * to receive a response to an Action frame and the response is
    2339             :          * received when there is still unneeded time remaining on the
    2340             :          * remain-on-channel operation.
    2341             :          */
    2342             :         int (*cancel_remain_on_channel)(void *priv);
    2343             : 
    2344             :         /**
    2345             :          * probe_req_report - Request Probe Request frames to be indicated
    2346             :          * @priv: Private driver interface data
    2347             :          * @report: Whether to report received Probe Request frames
    2348             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2349             :          *
    2350             :          * This command can be used to request the driver to indicate when
    2351             :          * Probe Request frames are received with EVENT_RX_PROBE_REQ events.
    2352             :          * Since this operation may require extra resources, e.g., due to less
    2353             :          * optimal hardware/firmware RX filtering, many drivers may disable
    2354             :          * Probe Request reporting at least in station mode. This command is
    2355             :          * used to notify the driver when the Probe Request frames need to be
    2356             :          * reported, e.g., during remain-on-channel operations.
    2357             :          */
    2358             :         int (*probe_req_report)(void *priv, int report);
    2359             : 
    2360             :         /**
    2361             :          * deinit_ap - Deinitialize AP mode
    2362             :          * @priv: Private driver interface data
    2363             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2364             :          *
    2365             :          * This optional function can be used to disable AP mode related
    2366             :          * configuration. If the interface was not dynamically added,
    2367             :          * change the driver mode to station mode to allow normal station
    2368             :          * operations like scanning to be completed.
    2369             :          */
    2370             :         int (*deinit_ap)(void *priv);
    2371             : 
    2372             :         /**
    2373             :          * deinit_p2p_cli - Deinitialize P2P client mode
    2374             :          * @priv: Private driver interface data
    2375             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2376             :          *
    2377             :          * This optional function can be used to disable P2P client mode. If the
    2378             :          * interface was not dynamically added, change the interface type back
    2379             :          * to station mode.
    2380             :          */
    2381             :         int (*deinit_p2p_cli)(void *priv);
    2382             : 
    2383             :         /**
    2384             :          * suspend - Notification on system suspend/hibernate event
    2385             :          * @priv: Private driver interface data
    2386             :          */
    2387             :         void (*suspend)(void *priv);
    2388             : 
    2389             :         /**
    2390             :          * resume - Notification on system resume/thaw event
    2391             :          * @priv: Private driver interface data
    2392             :          */
    2393             :         void (*resume)(void *priv);
    2394             : 
    2395             :         /**
    2396             :          * signal_monitor - Set signal monitoring parameters
    2397             :          * @priv: Private driver interface data
    2398             :          * @threshold: Threshold value for signal change events; 0 = disabled
    2399             :          * @hysteresis: Minimum change in signal strength before indicating a
    2400             :          *      new event
    2401             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2402             :          *
    2403             :          * This function can be used to configure monitoring of signal strength
    2404             :          * with the current AP. Whenever signal strength drops below the
    2405             :          * %threshold value or increases above it, EVENT_SIGNAL_CHANGE event
    2406             :          * should be generated assuming the signal strength has changed at
    2407             :          * least %hysteresis from the previously indicated signal change event.
    2408             :          */
    2409             :         int (*signal_monitor)(void *priv, int threshold, int hysteresis);
    2410             : 
    2411             :         /**
    2412             :          * send_frame - Send IEEE 802.11 frame (testing use only)
    2413             :          * @priv: Private driver interface data
    2414             :          * @data: IEEE 802.11 frame with IEEE 802.11 header
    2415             :          * @data_len: Size of the frame
    2416             :          * @encrypt: Whether to encrypt the frame (if keys are set)
    2417             :          * Returns: 0 on success, -1 on failure
    2418             :          *
    2419             :          * This function is only used for debugging purposes and is not
    2420             :          * required to be implemented for normal operations.
    2421             :          */
    2422             :         int (*send_frame)(void *priv, const u8 *data, size_t data_len,
    2423             :                           int encrypt);
    2424             : 
    2425             :         /**
    2426             :          * shared_freq - Get operating frequency of shared interface(s)
    2427             :          * @priv: Private driver interface data
    2428             :          * Returns: Operating frequency in MHz, 0 if no shared operation in
    2429             :          * use, or -1 on failure
    2430             :          *
    2431             :          * This command can be used to request the current operating frequency
    2432             :          * of any virtual interface that shares the same radio to provide
    2433             :          * information for channel selection for other virtual interfaces.
    2434             :          */
    2435             :         int (*shared_freq)(void *priv);
    2436             : 
    2437             :         /**
    2438             :          * get_noa - Get current Notice of Absence attribute payload
    2439             :          * @priv: Private driver interface data
    2440             :          * @buf: Buffer for returning NoA
    2441             :          * @buf_len: Buffer length in octets
    2442             :          * Returns: Number of octets used in buf, 0 to indicate no NoA is being
    2443             :          * advertized, or -1 on failure
    2444             :          *
    2445             :          * This function is used to fetch the current Notice of Absence
    2446             :          * attribute value from GO.
    2447             :          */
    2448             :         int (*get_noa)(void *priv, u8 *buf, size_t buf_len);
    2449             : 
    2450             :         /**
    2451             :          * set_noa - Set Notice of Absence parameters for GO (testing)
    2452             :          * @priv: Private driver interface data
    2453             :          * @count: Count
    2454             :          * @start: Start time in ms from next TBTT
    2455             :          * @duration: Duration in ms
    2456             :          * Returns: 0 on success or -1 on failure
    2457             :          *
    2458             :          * This function is used to set Notice of Absence parameters for GO. It
    2459             :          * is used only for testing. To disable NoA, all parameters are set to
    2460             :          * 0.
    2461             :          */
    2462             :         int (*set_noa)(void *priv, u8 count, int start, int duration);
    2463             : 
    2464             :         /**
    2465             :          * set_p2p_powersave - Set P2P power save options
    2466             :          * @priv: Private driver interface data
    2467             :          * @legacy_ps: 0 = disable, 1 = enable, 2 = maximum PS, -1 = no change
    2468             :          * @opp_ps: 0 = disable, 1 = enable, -1 = no change
    2469             :          * @ctwindow: 0.. = change (msec), -1 = no change
    2470             :          * Returns: 0 on success or -1 on failure
    2471             :          */
    2472             :         int (*set_p2p_powersave)(void *priv, int legacy_ps, int opp_ps,
    2473             :                                  int ctwindow);
    2474             : 
    2475             :         /**
    2476             :          * ampdu - Enable/disable aggregation
    2477             :          * @priv: Private driver interface data
    2478             :          * @ampdu: 1/0 = enable/disable A-MPDU aggregation
    2479             :          * Returns: 0 on success or -1 on failure
    2480             :          */
    2481             :         int (*ampdu)(void *priv, int ampdu);
    2482             : 
    2483             :         /**
    2484             :          * get_radio_name - Get physical radio name for the device
    2485             :          * @priv: Private driver interface data
    2486             :          * Returns: Radio name or %NULL if not known
    2487             :          *
    2488             :          * The returned data must not be modified by the caller. It is assumed
    2489             :          * that any interface that has the same radio name as another is
    2490             :          * sharing the same physical radio. This information can be used to
    2491             :          * share scan results etc. information between the virtual interfaces
    2492             :          * to speed up various operations.
    2493             :          */
    2494             :         const char * (*get_radio_name)(void *priv);
    2495             : 
    2496             :         /**
    2497             :          * send_tdls_mgmt - for sending TDLS management packets
    2498             :          * @priv: private driver interface data
    2499             :          * @dst: Destination (peer) MAC address
    2500             :          * @action_code: TDLS action code for the mssage
    2501             :          * @dialog_token: Dialog Token to use in the message (if needed)
    2502             :          * @status_code: Status Code or Reason Code to use (if needed)
    2503             :          * @peer_capab: TDLS peer capability (TDLS_PEER_* bitfield)
    2504             :          * @initiator: Is the current end the TDLS link initiator
    2505             :          * @buf: TDLS IEs to add to the message
    2506             :          * @len: Length of buf in octets
    2507             :          * Returns: 0 on success, negative (<0) on failure
    2508             :          *
    2509             :          * This optional function can be used to send packet to driver which is
    2510             :          * responsible for receiving and sending all TDLS packets.
    2511             :          */
    2512             :         int (*send_tdls_mgmt)(void *priv, const u8 *dst, u8 action_code,
    2513             :                               u8 dialog_token, u16 status_code, u32 peer_capab,
    2514             :                               int initiator, const u8 *buf, size_t len);
    2515             : 
    2516             :         /**
    2517             :          * tdls_oper - Ask the driver to perform high-level TDLS operations
    2518             :          * @priv: Private driver interface data
    2519             :          * @oper: TDLS high-level operation. See %enum tdls_oper
    2520             :          * @peer: Destination (peer) MAC address
    2521             :          * Returns: 0 on success, negative (<0) on failure
    2522             :          *
    2523             :          * This optional function can be used to send high-level TDLS commands
    2524             :          * to the driver.
    2525             :          */
    2526             :         int (*tdls_oper)(void *priv, enum tdls_oper oper, const u8 *peer);
    2527             : 
    2528             :         /**
    2529             :          * wnm_oper - Notify driver of the WNM frame reception
    2530             :          * @priv: Private driver interface data
    2531             :          * @oper: WNM operation. See %enum wnm_oper
    2532             :          * @peer: Destination (peer) MAC address
    2533             :          * @buf: Buffer for the driver to fill in (for getting IE)
    2534             :          * @buf_len: Return the len of buf
    2535             :          * Returns: 0 on success, negative (<0) on failure
    2536             :          */
    2537             :         int (*wnm_oper)(void *priv, enum wnm_oper oper, const u8 *peer,
    2538             :                         u8 *buf, u16 *buf_len);
    2539             : 
    2540             :         /**
    2541             :          * set_qos_map - Set QoS Map
    2542             :          * @priv: Private driver interface data
    2543             :          * @qos_map_set: QoS Map
    2544             :          * @qos_map_set_len: Length of QoS Map
    2545             :          */
    2546             :         int (*set_qos_map)(void *priv, const u8 *qos_map_set,
    2547             :                            u8 qos_map_set_len);
    2548             : 
    2549             :         /**
    2550             :          * set_wowlan - Set wake-on-wireless triggers
    2551             :          * @priv: Private driver interface data
    2552             :          * @triggers: wowlan triggers
    2553             :          */
    2554             :         int (*set_wowlan)(void *priv, const struct wowlan_triggers *triggers);
    2555             : 
    2556             :         /**
    2557             :          * signal_poll - Get current connection information
    2558             :          * @priv: Private driver interface data
    2559             :          * @signal_info: Connection info structure
    2560             :          */
    2561             :         int (*signal_poll)(void *priv, struct wpa_signal_info *signal_info);
    2562             : 
    2563             :         /**
    2564             :          * set_authmode - Set authentication algorithm(s) for static WEP
    2565             :          * @priv: Private driver interface data
    2566             :          * @authmode: 1=Open System, 2=Shared Key, 3=both
    2567             :          * Returns: 0 on success, -1 on failure
    2568             :          *
    2569             :          * This function can be used to set authentication algorithms for AP
    2570             :          * mode when static WEP is used. If the driver uses user space MLME/SME
    2571             :          * implementation, there is no need to implement this function.
    2572             :          *
    2573             :          * DEPRECATED - use set_ap() instead
    2574             :          */
    2575             :         int (*set_authmode)(void *priv, int authmode);
    2576             : 
    2577             : #ifdef ANDROID
    2578             :         /**
    2579             :          * driver_cmd - Execute driver-specific command
    2580             :          * @priv: Private driver interface data
    2581             :          * @cmd: Command to execute
    2582             :          * @buf: Return buffer
    2583             :          * @buf_len: Buffer length
    2584             :          * Returns: 0 on success, -1 on failure
    2585             :          */
    2586             :         int (*driver_cmd)(void *priv, char *cmd, char *buf, size_t buf_len);
    2587             : #endif /* ANDROID */
    2588             : 
    2589             :         /**
    2590             :          * vendor_cmd - Execute vendor specific command
    2591             :          * @priv: Private driver interface data
    2592             :          * @vendor_id: Vendor id
    2593             :          * @subcmd: Vendor command id
    2594             :          * @data: Vendor command parameters (%NULL if no parameters)
    2595             :          * @data_len: Data length
    2596             :          * @buf: Return buffer (%NULL to ignore reply)
    2597             :          * Returns: 0 on success, negative (<0) on failure
    2598             :          *
    2599             :          * This function handles vendor specific commands that are passed to
    2600             :          * the driver/device. The command is identified by vendor id and
    2601             :          * command id. Parameters can be passed as argument to the command
    2602             :          * in the data buffer. Reply (if any) will be filled in the supplied
    2603             :          * return buffer.
    2604             :          *
    2605             :          * The exact driver behavior is driver interface and vendor specific. As
    2606             :          * an example, this will be converted to a vendor specific cfg80211
    2607             :          * command in case of the nl80211 driver interface.
    2608             :          */
    2609             :         int (*vendor_cmd)(void *priv, unsigned int vendor_id,
    2610             :                           unsigned int subcmd, const u8 *data, size_t data_len,
    2611             :                           struct wpabuf *buf);
    2612             : 
    2613             :         /**
    2614             :          * set_rekey_info - Set rekey information
    2615             :          * @priv: Private driver interface data
    2616             :          * @kek: Current KEK
    2617             :          * @kck: Current KCK
    2618             :          * @replay_ctr: Current EAPOL-Key Replay Counter
    2619             :          *
    2620             :          * This optional function can be used to provide information for the
    2621             :          * driver/firmware to process EAPOL-Key frames in Group Key Handshake
    2622             :          * while the host (including wpa_supplicant) is sleeping.
    2623             :          */
    2624             :         void (*set_rekey_info)(void *priv, const u8 *kek, const u8 *kck,
    2625             :                                const u8 *replay_ctr);
    2626             : 
    2627             :         /**
    2628             :          * sta_assoc - Station association indication
    2629             :          * @priv: Private driver interface data
    2630             :          * @own_addr: Source address and BSSID for association frame
    2631             :          * @addr: MAC address of the station to associate
    2632             :          * @reassoc: flag to indicate re-association
    2633             :          * @status: association response status code
    2634             :          * @ie: assoc response ie buffer
    2635             :          * @len: ie buffer length
    2636             :          * Returns: 0 on success, -1 on failure
    2637             :          *
    2638             :          * This function indicates the driver to send (Re)Association
    2639             :          * Response frame to the station.
    2640             :          */
    2641             :          int (*sta_assoc)(void *priv, const u8 *own_addr, const u8 *addr,
    2642             :                           int reassoc, u16 status, const u8 *ie, size_t len);
    2643             : 
    2644             :         /**
    2645             :          * sta_auth - Station authentication indication
    2646             :          * @priv: Private driver interface data
    2647             :          * @own_addr: Source address and BSSID for authentication frame
    2648             :          * @addr: MAC address of the station to associate
    2649             :          * @seq: authentication sequence number
    2650             :          * @status: authentication response status code
    2651             :          * @ie: authentication frame ie buffer
    2652             :          * @len: ie buffer length
    2653             :          *
    2654             :          * This function indicates the driver to send Authentication frame
    2655             :          * to the station.
    2656             :          */
    2657             :          int (*sta_auth)(void *priv, const u8 *own_addr, const u8 *addr,
    2658             :                          u16 seq, u16 status, const u8 *ie, size_t len);
    2659             : 
    2660             :         /**
    2661             :          * add_tspec - Add traffic stream
    2662             :          * @priv: Private driver interface data
    2663             :          * @addr: MAC address of the station to associate
    2664             :          * @tspec_ie: tspec ie buffer
    2665             :          * @tspec_ielen: tspec ie length
    2666             :          * Returns: 0 on success, -1 on failure
    2667             :          *
    2668             :          * This function adds the traffic steam for the station
    2669             :          * and fills the medium_time in tspec_ie.
    2670             :          */
    2671             :          int (*add_tspec)(void *priv, const u8 *addr, u8 *tspec_ie,
    2672             :                           size_t tspec_ielen);
    2673             : 
    2674             :         /**
    2675             :          * add_sta_node - Add a station node in the driver
    2676             :          * @priv: Private driver interface data
    2677             :          * @addr: MAC address of the station to add
    2678             :          * @auth_alg: authentication algorithm used by the station
    2679             :          * Returns: 0 on success, -1 on failure
    2680             :          *
    2681             :          * This function adds the station node in the driver, when
    2682             :          * the station gets added by FT-over-DS.
    2683             :          */
    2684             :         int (*add_sta_node)(void *priv, const u8 *addr, u16 auth_alg);
    2685             : 
    2686             :         /**
    2687             :          * sched_scan - Request the driver to initiate scheduled scan
    2688             :          * @priv: Private driver interface data
    2689             :          * @params: Scan parameters
    2690             :          * @interval: Interval between scan cycles in milliseconds
    2691             :          * Returns: 0 on success, -1 on failure
    2692             :          *
    2693             :          * This operation should be used for scheduled scan offload to
    2694             :          * the hardware. Every time scan results are available, the
    2695             :          * driver should report scan results event for wpa_supplicant
    2696             :          * which will eventually request the results with
    2697             :          * wpa_driver_get_scan_results2(). This operation is optional
    2698             :          * and if not provided or if it returns -1, we fall back to
    2699             :          * normal host-scheduled scans.
    2700             :          */
    2701             :         int (*sched_scan)(void *priv, struct wpa_driver_scan_params *params,
    2702             :                           u32 interval);
    2703             : 
    2704             :         /**
    2705             :          * stop_sched_scan - Request the driver to stop a scheduled scan
    2706             :          * @priv: Private driver interface data
    2707             :          * Returns: 0 on success, -1 on failure
    2708             :          *
    2709             :          * This should cause the scheduled scan to be stopped and
    2710             :          * results should stop being sent. Must be supported if
    2711             :          * sched_scan is supported.
    2712             :          */
    2713             :         int (*stop_sched_scan)(void *priv);
    2714             : 
    2715             :         /**
    2716             :          * poll_client - Probe (null data or such) the given station
    2717             :          * @priv: Private driver interface data
    2718             :          * @own_addr: MAC address of sending interface
    2719             :          * @addr: MAC address of the station to probe
    2720             :          * @qos: Indicates whether station is QoS station
    2721             :          *
    2722             :          * This function is used to verify whether an associated station is
    2723             :          * still present. This function does not need to be implemented if the
    2724             :          * driver provides such inactivity polling mechanism.
    2725             :          */
    2726             :         void (*poll_client)(void *priv, const u8 *own_addr,
    2727             :                             const u8 *addr, int qos);
    2728             : 
    2729             :         /**
    2730             :          * radio_disable - Disable/enable radio
    2731             :          * @priv: Private driver interface data
    2732             :          * @disabled: 1=disable 0=enable radio
    2733             :          * Returns: 0 on success, -1 on failure
    2734             :          *
    2735             :          * This optional command is for testing purposes. It can be used to
    2736             :          * disable the radio on a testbed device to simulate out-of-radio-range
    2737             :          * conditions.
    2738             :          */
    2739             :         int (*radio_disable)(void *priv, int disabled);
    2740             : 
    2741             :         /**
    2742             :          * switch_channel - Announce channel switch and migrate the GO to the
    2743             :          * given frequency
    2744             :          * @priv: Private driver interface data
    2745             :          * @settings: Settings for CSA period and new channel
    2746             :          * Returns: 0 on success, -1 on failure
    2747             :          *
    2748             :          * This function is used to move the GO to the legacy STA channel to
    2749             :          * avoid frequency conflict in single channel concurrency.
    2750             :          */
    2751             :         int (*switch_channel)(void *priv, struct csa_settings *settings);
    2752             : 
    2753             :         /**
    2754             :          * start_dfs_cac - Listen for radar interference on the channel
    2755             :          * @priv: Private driver interface data
    2756             :          * @freq: Channel parameters
    2757             :          * Returns: 0 on success, -1 on failure
    2758             :          */
    2759             :         int (*start_dfs_cac)(void *priv, struct hostapd_freq_params *freq);
    2760             : 
    2761             :         /**
    2762             :          * stop_ap - Removes beacon from AP
    2763             :          * @priv: Private driver interface data
    2764             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2765             :          *
    2766             :          * This optional function can be used to disable AP mode related
    2767             :          * configuration. Unlike deinit_ap, it does not change to station
    2768             :          * mode.
    2769             :          */
    2770             :         int (*stop_ap)(void *priv);
    2771             : 
    2772             :         /**
    2773             :          * get_survey - Retrieve survey data
    2774             :          * @priv: Private driver interface data
    2775             :          * @freq: If set, survey data for the specified frequency is only
    2776             :          *      being requested. If not set, all survey data is requested.
    2777             :          * Returns: 0 on success, -1 on failure
    2778             :          *
    2779             :          * Use this to retrieve:
    2780             :          *
    2781             :          * - the observed channel noise floor
    2782             :          * - the amount of time we have spent on the channel
    2783             :          * - the amount of time during which we have spent on the channel that
    2784             :          *   the radio has determined the medium is busy and we cannot
    2785             :          *   transmit
    2786             :          * - the amount of time we have spent receiving data
    2787             :          * - the amount of time we have spent transmitting data
    2788             :          *
    2789             :          * This data can be used for spectrum heuristics. One example is
    2790             :          * Automatic Channel Selection (ACS). The channel survey data is
    2791             :          * kept on a linked list on the channel data, one entry is added
    2792             :          * for each survey. The min_nf of the channel is updated for each
    2793             :          * survey.
    2794             :          */
    2795             :         int (*get_survey)(void *priv, unsigned int freq);
    2796             : 
    2797             :         /**
    2798             :          * status - Get driver interface status information
    2799             :          * @priv: Private driver interface data
    2800             :          * @buf: Buffer for printing tou the status information
    2801             :          * @buflen: Maximum length of the buffer
    2802             :          * Returns: Length of written status information or -1 on failure
    2803             :          */
    2804             :         int (*status)(void *priv, char *buf, size_t buflen);
    2805             : 
    2806             :         /**
    2807             :          * roaming - Set roaming policy for driver-based BSS selection
    2808             :          * @priv: Private driver interface data
    2809             :          * @allowed: Whether roaming within ESS is allowed
    2810             :          * @bssid: Forced BSSID if roaming is disabled or %NULL if not set
    2811             :          * Returns: Length of written status information or -1 on failure
    2812             :          *
    2813             :          * This optional callback can be used to update roaming policy from the
    2814             :          * associate() command (bssid being set there indicates that the driver
    2815             :          * should not roam before getting this roaming() call to allow roaming.
    2816             :          * If the driver does not indicate WPA_DRIVER_FLAGS_BSS_SELECTION
    2817             :          * capability, roaming policy is handled within wpa_supplicant and there
    2818             :          * is no need to implement or react to this callback.
    2819             :          */
    2820             :         int (*roaming)(void *priv, int allowed, const u8 *bssid);
    2821             : 
    2822             :         /**
    2823             :          * set_mac_addr - Set MAC address
    2824             :          * @priv: Private driver interface data
    2825             :          * @addr: MAC address to use or %NULL for setting back to permanent
    2826             :          * Returns: 0 on success, -1 on failure
    2827             :          */
    2828             :         int (*set_mac_addr)(void *priv, const u8 *addr);
    2829             : 
    2830             : #ifdef CONFIG_MACSEC
    2831             :         int (*macsec_init)(void *priv, struct macsec_init_params *params);
    2832             : 
    2833             :         int (*macsec_deinit)(void *priv);
    2834             : 
    2835             :         /**
    2836             :          * enable_protect_frames - Set protect frames status
    2837             :          * @priv: Private driver interface data
    2838             :          * @enabled: TRUE = protect frames enabled
    2839             :          *           FALSE = protect frames disabled
    2840             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2841             :          */
    2842             :         int (*enable_protect_frames)(void *priv, Boolean enabled);
    2843             : 
    2844             :         /**
    2845             :          * set_replay_protect - Set replay protect status and window size
    2846             :          * @priv: Private driver interface data
    2847             :          * @enabled: TRUE = replay protect enabled
    2848             :          *           FALSE = replay protect disabled
    2849             :          * @window: replay window size, valid only when replay protect enabled
    2850             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2851             :          */
    2852             :         int (*set_replay_protect)(void *priv, Boolean enabled, u32 window);
    2853             : 
    2854             :         /**
    2855             :          * set_current_cipher_suite - Set current cipher suite
    2856             :          * @priv: Private driver interface data
    2857             :          * @cs: EUI64 identifier
    2858             :          * @cs_len: Length of the cs buffer in octets
    2859             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2860             :          */
    2861             :         int (*set_current_cipher_suite)(void *priv, const u8 *cs,
    2862             :                                         size_t cs_len);
    2863             : 
    2864             :         /**
    2865             :          * enable_controlled_port - Set controlled port status
    2866             :          * @priv: Private driver interface data
    2867             :          * @enabled: TRUE = controlled port enabled
    2868             :          *           FALSE = controlled port disabled
    2869             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2870             :          */
    2871             :         int (*enable_controlled_port)(void *priv, Boolean enabled);
    2872             : 
    2873             :         /**
    2874             :          * get_receive_lowest_pn - Get receive lowest pn
    2875             :          * @priv: Private driver interface data
    2876             :          * @channel: secure channel
    2877             :          * @an: association number
    2878             :          * @lowest_pn: lowest accept pn
    2879             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2880             :          */
    2881             :         int (*get_receive_lowest_pn)(void *priv, u32 channel, u8 an,
    2882             :                                      u32 *lowest_pn);
    2883             : 
    2884             :         /**
    2885             :          * get_transmit_next_pn - Get transmit next pn
    2886             :          * @priv: Private driver interface data
    2887             :          * @channel: secure channel
    2888             :          * @an: association number
    2889             :          * @next_pn: next pn
    2890             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2891             :          */
    2892             :         int (*get_transmit_next_pn)(void *priv, u32 channel, u8 an,
    2893             :                                     u32 *next_pn);
    2894             : 
    2895             :         /**
    2896             :          * set_transmit_next_pn - Set transmit next pn
    2897             :          * @priv: Private driver interface data
    2898             :          * @channel: secure channel
    2899             :          * @an: association number
    2900             :          * @next_pn: next pn
    2901             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2902             :          */
    2903             :         int (*set_transmit_next_pn)(void *priv, u32 channel, u8 an,
    2904             :                                     u32 next_pn);
    2905             : 
    2906             :         /**
    2907             :          * get_available_receive_sc - get available receive channel
    2908             :          * @priv: Private driver interface data
    2909             :          * @channel: secure channel
    2910             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2911             :          */
    2912             :         int (*get_available_receive_sc)(void *priv, u32 *channel);
    2913             : 
    2914             :         /**
    2915             :          * create_receive_sc - create secure channel for receiving
    2916             :          * @priv: Private driver interface data
    2917             :          * @channel: secure channel
    2918             :          * @sci_addr: secure channel identifier - address
    2919             :          * @sci_port: secure channel identifier - port
    2920             :          * @conf_offset: confidentiality offset (0, 30, or 50)
    2921             :          * @validation: frame validation policy (0 = Disabled, 1 = Checked,
    2922             :          *      2 = Strict)
    2923             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2924             :          */
    2925             :         int (*create_receive_sc)(void *priv, u32 channel, const u8 *sci_addr,
    2926             :                                  u16 sci_port, unsigned int conf_offset,
    2927             :                                  int validation);
    2928             : 
    2929             :         /**
    2930             :          * delete_receive_sc - delete secure connection for receiving
    2931             :          * @priv: private driver interface data from init()
    2932             :          * @channel: secure channel
    2933             :          * Returns: 0 on success, -1 on failure
    2934             :          */
    2935             :         int (*delete_receive_sc)(void *priv, u32 channel);
    2936             : 
    2937             :         /**
    2938             :          * create_receive_sa - create secure association for receive
    2939             :          * @priv: private driver interface data from init()
    2940             :          * @channel: secure channel
    2941             :          * @an: association number
    2942             :          * @lowest_pn: the lowest packet number can be received
    2943             :          * @sak: the secure association key
    2944             :          * Returns: 0 on success, -1 on failure
    2945             :          */
    2946             :         int (*create_receive_sa)(void *priv, u32 channel, u8 an,
    2947             :                                  u32 lowest_pn, const u8 *sak);
    2948             : 
    2949             :         /**
    2950             :          * enable_receive_sa - enable the SA for receive
    2951             :          * @priv: private driver interface data from init()
    2952             :          * @channel: secure channel
    2953             :          * @an: association number
    2954             :          * Returns: 0 on success, -1 on failure
    2955             :          */
    2956             :         int (*enable_receive_sa)(void *priv, u32 channel, u8 an);
    2957             : 
    2958             :         /**
    2959             :          * disable_receive_sa - disable SA for receive
    2960             :          * @priv: private driver interface data from init()
    2961             :          * @channel: secure channel index
    2962             :          * @an: association number
    2963             :          * Returns: 0 on success, -1 on failure
    2964             :          */
    2965             :         int (*disable_receive_sa)(void *priv, u32 channel, u8 an);
    2966             : 
    2967             :         /**
    2968             :          * get_available_transmit_sc - get available transmit channel
    2969             :          * @priv: Private driver interface data
    2970             :          * @channel: secure channel
    2971             :          * Returns: 0 on success, -1 on failure (or if not supported)
    2972             :          */
    2973             :         int (*get_available_transmit_sc)(void *priv, u32 *channel);
    2974             : 
    2975             :         /**
    2976             :          * create_transmit_sc - create secure connection for transmit
    2977             :          * @priv: private driver interface data from init()
    2978             :          * @channel: secure channel
    2979             :          * @sci_addr: secure channel identifier - address
    2980             :          * @sci_port: secure channel identifier - port
    2981             :          * Returns: 0 on success, -1 on failure
    2982             :          */
    2983             :         int (*create_transmit_sc)(void *priv, u32 channel, const u8 *sci_addr,
    2984             :                                   u16 sci_port, unsigned int conf_offset);
    2985             : 
    2986             :         /**
    2987             :          * delete_transmit_sc - delete secure connection for transmit
    2988             :          * @priv: private driver interface data from init()
    2989             :          * @channel: secure channel
    2990             :          * Returns: 0 on success, -1 on failure
    2991             :          */
    2992             :         int (*delete_transmit_sc)(void *priv, u32 channel);
    2993             : 
    2994             :         /**
    2995             :          * create_transmit_sa - create secure association for transmit
    2996             :          * @priv: private driver interface data from init()
    2997             :          * @channel: secure channel index
    2998             :          * @an: association number
    2999             :          * @next_pn: the packet number used as next transmit packet
    3000             :          * @confidentiality: True if the SA is to provide confidentiality
    3001             :          *                   as well as integrity
    3002             :          * @sak: the secure association key
    3003             :          * Returns: 0 on success, -1 on failure
    3004             :          */
    3005             :         int (*create_transmit_sa)(void *priv, u32 channel, u8 an, u32 next_pn,
    3006             :                                   Boolean confidentiality, const u8 *sak);
    3007             : 
    3008             :         /**
    3009             :          * enable_transmit_sa - enable SA for transmit
    3010             :          * @priv: private driver interface data from init()
    3011             :          * @channel: secure channel
    3012             :          * @an: association number
    3013             :          * Returns: 0 on success, -1 on failure
    3014             :          */
    3015             :         int (*enable_transmit_sa)(void *priv, u32 channel, u8 an);
    3016             : 
    3017             :         /**
    3018             :          * disable_transmit_sa - disable SA for transmit
    3019             :          * @priv: private driver interface data from init()
    3020             :          * @channel: secure channel
    3021             :          * @an: association number
    3022             :          * Returns: 0 on success, -1 on failure
    3023             :          */
    3024             :         int (*disable_transmit_sa)(void *priv, u32 channel, u8 an);
    3025             : #endif /* CONFIG_MACSEC */
    3026             : };
    3027             : 
    3028             : 
    3029             : /**
    3030             :  * enum wpa_event_type - Event type for wpa_supplicant_event() calls
    3031             :  */
    3032             : enum wpa_event_type {
    3033             :         /**
    3034             :          * EVENT_ASSOC - Association completed
    3035             :          *
    3036             :          * This event needs to be delivered when the driver completes IEEE
    3037             :          * 802.11 association or reassociation successfully.
    3038             :          * wpa_driver_ops::get_bssid() is expected to provide the current BSSID
    3039             :          * after this event has been generated. In addition, optional
    3040             :          * EVENT_ASSOCINFO may be generated just before EVENT_ASSOC to provide
    3041             :          * more information about the association. If the driver interface gets
    3042             :          * both of these events at the same time, it can also include the
    3043             :          * assoc_info data in EVENT_ASSOC call.
    3044             :          */
    3045             :         EVENT_ASSOC,
    3046             : 
    3047             :         /**
    3048             :          * EVENT_DISASSOC - Association lost
    3049             :          *
    3050             :          * This event should be called when association is lost either due to
    3051             :          * receiving deauthenticate or disassociate frame from the AP or when
    3052             :          * sending either of these frames to the current AP. If the driver
    3053             :          * supports separate deauthentication event, EVENT_DISASSOC should only
    3054             :          * be used for disassociation and EVENT_DEAUTH for deauthentication.
    3055             :          * In AP mode, union wpa_event_data::disassoc_info is required.
    3056             :          */
    3057             :         EVENT_DISASSOC,
    3058             : 
    3059             :         /**
    3060             :          * EVENT_MICHAEL_MIC_FAILURE - Michael MIC (TKIP) detected
    3061             :          *
    3062             :          * This event must be delivered when a Michael MIC error is detected by
    3063             :          * the local driver. Additional data for event processing is
    3064             :          * provided with union wpa_event_data::michael_mic_failure. This
    3065             :          * information is used to request new encyption key and to initiate
    3066             :          * TKIP countermeasures if needed.
    3067             :          */
    3068             :         EVENT_MICHAEL_MIC_FAILURE,
    3069             : 
    3070             :         /**
    3071             :          * EVENT_SCAN_RESULTS - Scan results available
    3072             :          *
    3073             :          * This event must be called whenever scan results are available to be
    3074             :          * fetched with struct wpa_driver_ops::get_scan_results(). This event
    3075             :          * is expected to be used some time after struct wpa_driver_ops::scan()
    3076             :          * is called. If the driver provides an unsolicited event when the scan
    3077             :          * has been completed, this event can be used to trigger
    3078             :          * EVENT_SCAN_RESULTS call. If such event is not available from the
    3079             :          * driver, the driver wrapper code is expected to use a registered
    3080             :          * timeout to generate EVENT_SCAN_RESULTS call after the time that the
    3081             :          * scan is expected to be completed. Optional information about
    3082             :          * completed scan can be provided with union wpa_event_data::scan_info.
    3083             :          */
    3084             :         EVENT_SCAN_RESULTS,
    3085             : 
    3086             :         /**
    3087             :          * EVENT_ASSOCINFO - Report optional extra information for association
    3088             :          *
    3089             :          * This event can be used to report extra association information for
    3090             :          * EVENT_ASSOC processing. This extra information includes IEs from
    3091             :          * association frames and Beacon/Probe Response frames in union
    3092             :          * wpa_event_data::assoc_info. EVENT_ASSOCINFO must be send just before
    3093             :          * EVENT_ASSOC. Alternatively, the driver interface can include
    3094             :          * assoc_info data in the EVENT_ASSOC call if it has all the
    3095             :          * information available at the same point.
    3096             :          */
    3097             :         EVENT_ASSOCINFO,
    3098             : 
    3099             :         /**
    3100             :          * EVENT_INTERFACE_STATUS - Report interface status changes
    3101             :          *
    3102             :          * This optional event can be used to report changes in interface
    3103             :          * status (interface added/removed) using union
    3104             :          * wpa_event_data::interface_status. This can be used to trigger
    3105             :          * wpa_supplicant to stop and re-start processing for the interface,
    3106             :          * e.g., when a cardbus card is ejected/inserted.
    3107             :          */
    3108             :         EVENT_INTERFACE_STATUS,
    3109             : 
    3110             :         /**
    3111             :          * EVENT_PMKID_CANDIDATE - Report a candidate AP for pre-authentication
    3112             :          *
    3113             :          * This event can be used to inform wpa_supplicant about candidates for
    3114             :          * RSN (WPA2) pre-authentication. If wpa_supplicant is not responsible
    3115             :          * for scan request (ap_scan=2 mode), this event is required for
    3116             :          * pre-authentication. If wpa_supplicant is performing scan request
    3117             :          * (ap_scan=1), this event is optional since scan results can be used
    3118             :          * to add pre-authentication candidates. union
    3119             :          * wpa_event_data::pmkid_candidate is used to report the BSSID of the
    3120             :          * candidate and priority of the candidate, e.g., based on the signal
    3121             :          * strength, in order to try to pre-authenticate first with candidates
    3122             :          * that are most likely targets for re-association.
    3123             :          *
    3124             :          * EVENT_PMKID_CANDIDATE can be called whenever the driver has updates
    3125             :          * on the candidate list. In addition, it can be called for the current
    3126             :          * AP and APs that have existing PMKSA cache entries. wpa_supplicant
    3127             :          * will automatically skip pre-authentication in cases where a valid
    3128             :          * PMKSA exists. When more than one candidate exists, this event should
    3129             :          * be generated once for each candidate.
    3130             :          *
    3131             :          * Driver will be notified about successful pre-authentication with
    3132             :          * struct wpa_driver_ops::add_pmkid() calls.
    3133             :          */
    3134             :         EVENT_PMKID_CANDIDATE,
    3135             : 
    3136             :         /**
    3137             :          * EVENT_STKSTART - Request STK handshake (MLME-STKSTART.request)
    3138             :          *
    3139             :          * This event can be used to inform wpa_supplicant about desire to set
    3140             :          * up secure direct link connection between two stations as defined in
    3141             :          * IEEE 802.11e with a new PeerKey mechanism that replaced the original
    3142             :          * STAKey negotiation. The caller will need to set peer address for the
    3143             :          * event.
    3144             :          */
    3145             :         EVENT_STKSTART,
    3146             : 
    3147             :         /**
    3148             :          * EVENT_TDLS - Request TDLS operation
    3149             :          *
    3150             :          * This event can be used to request a TDLS operation to be performed.
    3151             :          */
    3152             :         EVENT_TDLS,
    3153             : 
    3154             :         /**
    3155             :          * EVENT_FT_RESPONSE - Report FT (IEEE 802.11r) response IEs
    3156             :          *
    3157             :          * The driver is expected to report the received FT IEs from
    3158             :          * FT authentication sequence from the AP. The FT IEs are included in
    3159             :          * the extra information in union wpa_event_data::ft_ies.
    3160             :          */
    3161             :         EVENT_FT_RESPONSE,
    3162             : 
    3163             :         /**
    3164             :          * EVENT_IBSS_RSN_START - Request RSN authentication in IBSS
    3165             :          *
    3166             :          * The driver can use this event to inform wpa_supplicant about a STA
    3167             :          * in an IBSS with which protected frames could be exchanged. This
    3168             :          * event starts RSN authentication with the other STA to authenticate
    3169             :          * the STA and set up encryption keys with it.
    3170             :          */
    3171             :         EVENT_IBSS_RSN_START,
    3172             : 
    3173             :         /**
    3174             :          * EVENT_AUTH - Authentication result
    3175             :          *
    3176             :          * This event should be called when authentication attempt has been
    3177             :          * completed. This is only used if the driver supports separate
    3178             :          * authentication step (struct wpa_driver_ops::authenticate).
    3179             :          * Information about authentication result is included in
    3180             :          * union wpa_event_data::auth.
    3181             :          */
    3182             :         EVENT_AUTH,
    3183             : 
    3184             :         /**
    3185             :          * EVENT_DEAUTH - Authentication lost
    3186             :          *
    3187             :          * This event should be called when authentication is lost either due
    3188             :          * to receiving deauthenticate frame from the AP or when sending that
    3189             :          * frame to the current AP.
    3190             :          * In AP mode, union wpa_event_data::deauth_info is required.
    3191             :          */
    3192             :         EVENT_DEAUTH,
    3193             : 
    3194             :         /**
    3195             :          * EVENT_ASSOC_REJECT - Association rejected
    3196             :          *
    3197             :          * This event should be called when (re)association attempt has been
    3198             :          * rejected by the AP. Information about the association response is
    3199             :          * included in union wpa_event_data::assoc_reject.
    3200             :          */
    3201             :         EVENT_ASSOC_REJECT,
    3202             : 
    3203             :         /**
    3204             :          * EVENT_AUTH_TIMED_OUT - Authentication timed out
    3205             :          */
    3206             :         EVENT_AUTH_TIMED_OUT,
    3207             : 
    3208             :         /**
    3209             :          * EVENT_ASSOC_TIMED_OUT - Association timed out
    3210             :          */
    3211             :         EVENT_ASSOC_TIMED_OUT,
    3212             : 
    3213             :         /**
    3214             :          * EVENT_FT_RRB_RX - FT (IEEE 802.11r) RRB frame received
    3215             :          */
    3216             :         EVENT_FT_RRB_RX,
    3217             : 
    3218             :         /**
    3219             :          * EVENT_WPS_BUTTON_PUSHED - Report hardware push button press for WPS
    3220             :          */
    3221             :         EVENT_WPS_BUTTON_PUSHED,
    3222             : 
    3223             :         /**
    3224             :          * EVENT_TX_STATUS - Report TX status
    3225             :          */
    3226             :         EVENT_TX_STATUS,
    3227             : 
    3228             :         /**
    3229             :          * EVENT_RX_FROM_UNKNOWN - Report RX from unknown STA
    3230             :          */
    3231             :         EVENT_RX_FROM_UNKNOWN,
    3232             : 
    3233             :         /**
    3234             :          * EVENT_RX_MGMT - Report RX of a management frame
    3235             :          */
    3236             :         EVENT_RX_MGMT,
    3237             : 
    3238             :         /**
    3239             :          * EVENT_REMAIN_ON_CHANNEL - Remain-on-channel duration started
    3240             :          *
    3241             :          * This event is used to indicate when the driver has started the
    3242             :          * requested remain-on-channel duration. Information about the
    3243             :          * operation is included in union wpa_event_data::remain_on_channel.
    3244             :          */
    3245             :         EVENT_REMAIN_ON_CHANNEL,
    3246             : 
    3247             :         /**
    3248             :          * EVENT_CANCEL_REMAIN_ON_CHANNEL - Remain-on-channel timed out
    3249             :          *
    3250             :          * This event is used to indicate when the driver has completed
    3251             :          * remain-on-channel duration, i.e., may noot be available on the
    3252             :          * requested channel anymore. Information about the
    3253             :          * operation is included in union wpa_event_data::remain_on_channel.
    3254             :          */
    3255             :         EVENT_CANCEL_REMAIN_ON_CHANNEL,
    3256             : 
    3257             :         /**
    3258             :          * EVENT_MLME_RX - Report reception of frame for MLME (test use only)
    3259             :          *
    3260             :          * This event is used only by driver_test.c and userspace MLME.
    3261             :          */
    3262             :         EVENT_MLME_RX,
    3263             : 
    3264             :         /**
    3265             :          * EVENT_RX_PROBE_REQ - Indicate received Probe Request frame
    3266             :          *
    3267             :          * This event is used to indicate when a Probe Request frame has been
    3268             :          * received. Information about the received frame is included in
    3269             :          * union wpa_event_data::rx_probe_req. The driver is required to report
    3270             :          * these events only after successfully completed probe_req_report()
    3271             :          * commands to request the events (i.e., report parameter is non-zero)
    3272             :          * in station mode. In AP mode, Probe Request frames should always be
    3273             :          * reported.
    3274             :          */
    3275             :         EVENT_RX_PROBE_REQ,
    3276             : 
    3277             :         /**
    3278             :          * EVENT_NEW_STA - New wired device noticed
    3279             :          *
    3280             :          * This event is used to indicate that a new device has been detected
    3281             :          * in a network that does not use association-like functionality (i.e.,
    3282             :          * mainly wired Ethernet). This can be used to start EAPOL
    3283             :          * authenticator when receiving a frame from a device. The address of
    3284             :          * the device is included in union wpa_event_data::new_sta.
    3285             :          */
    3286             :         EVENT_NEW_STA,
    3287             : 
    3288             :         /**
    3289             :          * EVENT_EAPOL_RX - Report received EAPOL frame
    3290             :          *
    3291             :          * When in AP mode with hostapd, this event is required to be used to
    3292             :          * deliver the receive EAPOL frames from the driver. With
    3293             :          * %wpa_supplicant, this event is used only if the send_eapol() handler
    3294             :          * is used to override the use of l2_packet for EAPOL frame TX.
    3295             :          */
    3296             :         EVENT_EAPOL_RX,
    3297             : 
    3298             :         /**
    3299             :          * EVENT_SIGNAL_CHANGE - Indicate change in signal strength
    3300             :          *
    3301             :          * This event is used to indicate changes in the signal strength
    3302             :          * observed in frames received from the current AP if signal strength
    3303             :          * monitoring has been enabled with signal_monitor().
    3304             :          */
    3305             :         EVENT_SIGNAL_CHANGE,
    3306             : 
    3307             :         /**
    3308             :          * EVENT_INTERFACE_ENABLED - Notify that interface was enabled
    3309             :          *
    3310             :          * This event is used to indicate that the interface was enabled after
    3311             :          * having been previously disabled, e.g., due to rfkill.
    3312             :          */
    3313             :         EVENT_INTERFACE_ENABLED,
    3314             : 
    3315             :         /**
    3316             :          * EVENT_INTERFACE_DISABLED - Notify that interface was disabled
    3317             :          *
    3318             :          * This event is used to indicate that the interface was disabled,
    3319             :          * e.g., due to rfkill.
    3320             :          */
    3321             :         EVENT_INTERFACE_DISABLED,
    3322             : 
    3323             :         /**
    3324             :          * EVENT_CHANNEL_LIST_CHANGED - Channel list changed
    3325             :          *
    3326             :          * This event is used to indicate that the channel list has changed,
    3327             :          * e.g., because of a regulatory domain change triggered by scan
    3328             :          * results including an AP advertising a country code.
    3329             :          */
    3330             :         EVENT_CHANNEL_LIST_CHANGED,
    3331             : 
    3332             :         /**
    3333             :          * EVENT_INTERFACE_UNAVAILABLE - Notify that interface is unavailable
    3334             :          *
    3335             :          * This event is used to indicate that the driver cannot maintain this
    3336             :          * interface in its operation mode anymore. The most likely use for
    3337             :          * this is to indicate that AP mode operation is not available due to
    3338             :          * operating channel would need to be changed to a DFS channel when
    3339             :          * the driver does not support radar detection and another virtual
    3340             :          * interfaces caused the operating channel to change. Other similar
    3341             :          * resource conflicts could also trigger this for station mode
    3342             :          * interfaces. This event can be propagated when channel switching
    3343             :          * fails.
    3344             :          */
    3345             :         EVENT_INTERFACE_UNAVAILABLE,
    3346             : 
    3347             :         /**
    3348             :          * EVENT_BEST_CHANNEL
    3349             :          *
    3350             :          * Driver generates this event whenever it detects a better channel
    3351             :          * (e.g., based on RSSI or channel use). This information can be used
    3352             :          * to improve channel selection for a new AP/P2P group.
    3353             :          */
    3354             :         EVENT_BEST_CHANNEL,
    3355             : 
    3356             :         /**
    3357             :          * EVENT_UNPROT_DEAUTH - Unprotected Deauthentication frame received
    3358             :          *
    3359             :          * This event should be called when a Deauthentication frame is dropped
    3360             :          * due to it not being protected (MFP/IEEE 802.11w).
    3361             :          * union wpa_event_data::unprot_deauth is required to provide more
    3362             :          * details of the frame.
    3363             :          */
    3364             :         EVENT_UNPROT_DEAUTH,
    3365             : 
    3366             :         /**
    3367             :          * EVENT_UNPROT_DISASSOC - Unprotected Disassociation frame received
    3368             :          *
    3369             :          * This event should be called when a Disassociation frame is dropped
    3370             :          * due to it not being protected (MFP/IEEE 802.11w).
    3371             :          * union wpa_event_data::unprot_disassoc is required to provide more
    3372             :          * details of the frame.
    3373             :          */
    3374             :         EVENT_UNPROT_DISASSOC,
    3375             : 
    3376             :         /**
    3377             :          * EVENT_STATION_LOW_ACK
    3378             :          *
    3379             :          * Driver generates this event whenever it detected that a particular
    3380             :          * station was lost. Detection can be through massive transmission
    3381             :          * failures for example.
    3382             :          */
    3383             :         EVENT_STATION_LOW_ACK,
    3384             : 
    3385             :         /**
    3386             :          * EVENT_IBSS_PEER_LOST - IBSS peer not reachable anymore
    3387             :          */
    3388             :         EVENT_IBSS_PEER_LOST,
    3389             : 
    3390             :         /**
    3391             :          * EVENT_DRIVER_GTK_REKEY - Device/driver did GTK rekey
    3392             :          *
    3393             :          * This event carries the new replay counter to notify wpa_supplicant
    3394             :          * of the current EAPOL-Key Replay Counter in case the driver/firmware
    3395             :          * completed Group Key Handshake while the host (including
    3396             :          * wpa_supplicant was sleeping).
    3397             :          */
    3398             :         EVENT_DRIVER_GTK_REKEY,
    3399             : 
    3400             :         /**
    3401             :          * EVENT_SCHED_SCAN_STOPPED - Scheduled scan was stopped
    3402             :          */
    3403             :         EVENT_SCHED_SCAN_STOPPED,
    3404             : 
    3405             :         /**
    3406             :          * EVENT_DRIVER_CLIENT_POLL_OK - Station responded to poll
    3407             :          *
    3408             :          * This event indicates that the station responded to the poll
    3409             :          * initiated with @poll_client.
    3410             :          */
    3411             :         EVENT_DRIVER_CLIENT_POLL_OK,
    3412             : 
    3413             :         /**
    3414             :          * EVENT_EAPOL_TX_STATUS - notify of EAPOL TX status
    3415             :          */
    3416             :         EVENT_EAPOL_TX_STATUS,
    3417             : 
    3418             :         /**
    3419             :          * EVENT_CH_SWITCH - AP or GO decided to switch channels
    3420             :          *
    3421             :          * Described in wpa_event_data.ch_switch
    3422             :          * */
    3423             :         EVENT_CH_SWITCH,
    3424             : 
    3425             :         /**
    3426             :          * EVENT_WNM - Request WNM operation
    3427             :          *
    3428             :          * This event can be used to request a WNM operation to be performed.
    3429             :          */
    3430             :         EVENT_WNM,
    3431             : 
    3432             :         /**
    3433             :          * EVENT_CONNECT_FAILED_REASON - Connection failure reason in AP mode
    3434             :          *
    3435             :          * This event indicates that the driver reported a connection failure
    3436             :          * with the specified client (for example, max client reached, etc.) in
    3437             :          * AP mode.
    3438             :          */
    3439             :         EVENT_CONNECT_FAILED_REASON,
    3440             : 
    3441             :         /**
    3442             :          * EVENT_RADAR_DETECTED - Notify of radar detection
    3443             :          *
    3444             :          * A radar has been detected on the supplied frequency, hostapd should
    3445             :          * react accordingly (e.g., change channel).
    3446             :          */
    3447             :         EVENT_DFS_RADAR_DETECTED,
    3448             : 
    3449             :         /**
    3450             :          * EVENT_CAC_FINISHED - Notify that channel availability check has been completed
    3451             :          *
    3452             :          * After a successful CAC, the channel can be marked clear and used.
    3453             :          */
    3454             :         EVENT_DFS_CAC_FINISHED,
    3455             : 
    3456             :         /**
    3457             :          * EVENT_CAC_ABORTED - Notify that channel availability check has been aborted
    3458             :          *
    3459             :          * The CAC was not successful, and the channel remains in the previous
    3460             :          * state. This may happen due to a radar beeing detected or other
    3461             :          * external influences.
    3462             :          */
    3463             :         EVENT_DFS_CAC_ABORTED,
    3464             : 
    3465             :         /**
    3466             :          * EVENT_DFS_CAC_NOP_FINISHED - Notify that non-occupancy period is over
    3467             :          *
    3468             :          * The channel which was previously unavailable is now available again.
    3469             :          */
    3470             :         EVENT_DFS_NOP_FINISHED,
    3471             : 
    3472             :         /**
    3473             :          * EVENT_SURVEY - Received survey data
    3474             :          *
    3475             :          * This event gets triggered when a driver query is issued for survey
    3476             :          * data and the requested data becomes available. The returned data is
    3477             :          * stored in struct survey_results. The results provide at most one
    3478             :          * survey entry for each frequency and at minimum will provide one
    3479             :          * survey entry for one frequency. The survey data can be os_malloc()'d
    3480             :          * and then os_free()'d, so the event callback must only copy data.
    3481             :          */
    3482             :         EVENT_SURVEY,
    3483             : 
    3484             :         /**
    3485             :          * EVENT_SCAN_STARTED - Scan started
    3486             :          *
    3487             :          * This indicates that driver has started a scan operation either based
    3488             :          * on a request from wpa_supplicant/hostapd or from another application.
    3489             :          * EVENT_SCAN_RESULTS is used to indicate when the scan has been
    3490             :          * completed (either successfully or by getting cancelled).
    3491             :          */
    3492             :         EVENT_SCAN_STARTED,
    3493             : 
    3494             :         /**
    3495             :          * EVENT_AVOID_FREQUENCIES - Received avoid frequency range
    3496             :          *
    3497             :          * This event indicates a set of frequency ranges that should be avoided
    3498             :          * to reduce issues due to interference or internal co-existence
    3499             :          * information in the driver.
    3500             :          */
    3501             :         EVENT_AVOID_FREQUENCIES
    3502             : };
    3503             : 
    3504             : 
    3505             : /**
    3506             :  * struct freq_survey - Channel survey info
    3507             :  *
    3508             :  * @ifidx: Interface index in which this survey was observed
    3509             :  * @freq: Center of frequency of the surveyed channel
    3510             :  * @nf: Channel noise floor in dBm
    3511             :  * @channel_time: Amount of time in ms the radio spent on the channel
    3512             :  * @channel_time_busy: Amount of time in ms the radio detected some signal
    3513             :  *     that indicated to the radio the channel was not clear
    3514             :  * @channel_time_rx: Amount of time the radio spent receiving data
    3515             :  * @channel_time_tx: Amount of time the radio spent transmitting data
    3516             :  * @filled: bitmask indicating which fields have been reported, see
    3517             :  *     SURVEY_HAS_* defines.
    3518             :  * @list: Internal list pointers
    3519             :  */
    3520             : struct freq_survey {
    3521             :         u32 ifidx;
    3522             :         unsigned int freq;
    3523             :         s8 nf;
    3524             :         u64 channel_time;
    3525             :         u64 channel_time_busy;
    3526             :         u64 channel_time_rx;
    3527             :         u64 channel_time_tx;
    3528             :         unsigned int filled;
    3529             :         struct dl_list list;
    3530             : };
    3531             : 
    3532             : #define SURVEY_HAS_NF BIT(0)
    3533             : #define SURVEY_HAS_CHAN_TIME BIT(1)
    3534             : #define SURVEY_HAS_CHAN_TIME_BUSY BIT(2)
    3535             : #define SURVEY_HAS_CHAN_TIME_RX BIT(3)
    3536             : #define SURVEY_HAS_CHAN_TIME_TX BIT(4)
    3537             : 
    3538             : 
    3539             : /**
    3540             :  * union wpa_event_data - Additional data for wpa_supplicant_event() calls
    3541             :  */
    3542             : union wpa_event_data {
    3543             :         /**
    3544             :          * struct assoc_info - Data for EVENT_ASSOC and EVENT_ASSOCINFO events
    3545             :          *
    3546             :          * This structure is optional for EVENT_ASSOC calls and required for
    3547             :          * EVENT_ASSOCINFO calls. By using EVENT_ASSOC with this data, the
    3548             :          * driver interface does not need to generate separate EVENT_ASSOCINFO
    3549             :          * calls.
    3550             :          */
    3551             :         struct assoc_info {
    3552             :                 /**
    3553             :                  * reassoc - Flag to indicate association or reassociation
    3554             :                  */
    3555             :                 int reassoc;
    3556             : 
    3557             :                 /**
    3558             :                  * req_ies - (Re)Association Request IEs
    3559             :                  *
    3560             :                  * If the driver generates WPA/RSN IE, this event data must be
    3561             :                  * returned for WPA handshake to have needed information. If
    3562             :                  * wpa_supplicant-generated WPA/RSN IE is used, this
    3563             :                  * information event is optional.
    3564             :                  *
    3565             :                  * This should start with the first IE (fixed fields before IEs
    3566             :                  * are not included).
    3567             :                  */
    3568             :                 const u8 *req_ies;
    3569             : 
    3570             :                 /**
    3571             :                  * req_ies_len - Length of req_ies in bytes
    3572             :                  */
    3573             :                 size_t req_ies_len;
    3574             : 
    3575             :                 /**
    3576             :                  * resp_ies - (Re)Association Response IEs
    3577             :                  *
    3578             :                  * Optional association data from the driver. This data is not
    3579             :                  * required WPA, but may be useful for some protocols and as
    3580             :                  * such, should be reported if this is available to the driver
    3581             :                  * interface.
    3582             :                  *
    3583             :                  * This should start with the first IE (fixed fields before IEs
    3584             :                  * are not included).
    3585             :                  */
    3586             :                 const u8 *resp_ies;
    3587             : 
    3588             :                 /**
    3589             :                  * resp_ies_len - Length of resp_ies in bytes
    3590             :                  */
    3591             :                 size_t resp_ies_len;
    3592             : 
    3593             :                 /**
    3594             :                  * beacon_ies - Beacon or Probe Response IEs
    3595             :                  *
    3596             :                  * Optional Beacon/ProbeResp data: IEs included in Beacon or
    3597             :                  * Probe Response frames from the current AP (i.e., the one
    3598             :                  * that the client just associated with). This information is
    3599             :                  * used to update WPA/RSN IE for the AP. If this field is not
    3600             :                  * set, the results from previous scan will be used. If no
    3601             :                  * data for the new AP is found, scan results will be requested
    3602             :                  * again (without scan request). At this point, the driver is
    3603             :                  * expected to provide WPA/RSN IE for the AP (if WPA/WPA2 is
    3604             :                  * used).
    3605             :                  *
    3606             :                  * This should start with the first IE (fixed fields before IEs
    3607             :                  * are not included).
    3608             :                  */
    3609             :                 const u8 *beacon_ies;
    3610             : 
    3611             :                 /**
    3612             :                  * beacon_ies_len - Length of beacon_ies */
    3613             :                 size_t beacon_ies_len;
    3614             : 
    3615             :                 /**
    3616             :                  * freq - Frequency of the operational channel in MHz
    3617             :                  */
    3618             :                 unsigned int freq;
    3619             : 
    3620             :                 /**
    3621             :                  * addr - Station address (for AP mode)
    3622             :                  */
    3623             :                 const u8 *addr;
    3624             :         } assoc_info;
    3625             : 
    3626             :         /**
    3627             :          * struct disassoc_info - Data for EVENT_DISASSOC events
    3628             :          */
    3629             :         struct disassoc_info {
    3630             :                 /**
    3631             :                  * addr - Station address (for AP mode)
    3632             :                  */
    3633             :                 const u8 *addr;
    3634             : 
    3635             :                 /**
    3636             :                  * reason_code - Reason Code (host byte order) used in
    3637             :                  *      Deauthentication frame
    3638             :                  */
    3639             :                 u16 reason_code;
    3640             : 
    3641             :                 /**
    3642             :                  * ie - Optional IE(s) in Disassociation frame
    3643             :                  */
    3644             :                 const u8 *ie;
    3645             : 
    3646             :                 /**
    3647             :                  * ie_len - Length of ie buffer in octets
    3648             :                  */
    3649             :                 size_t ie_len;
    3650             : 
    3651             :                 /**
    3652             :                  * locally_generated - Whether the frame was locally generated
    3653             :                  */
    3654             :                 int locally_generated;
    3655             :         } disassoc_info;
    3656             : 
    3657             :         /**
    3658             :          * struct deauth_info - Data for EVENT_DEAUTH events
    3659             :          */
    3660             :         struct deauth_info {
    3661             :                 /**
    3662             :                  * addr - Station address (for AP mode)
    3663             :                  */
    3664             :                 const u8 *addr;
    3665             : 
    3666             :                 /**
    3667             :                  * reason_code - Reason Code (host byte order) used in
    3668             :                  *      Deauthentication frame
    3669             :                  */
    3670             :                 u16 reason_code;
    3671             : 
    3672             :                 /**
    3673             :                  * ie - Optional IE(s) in Deauthentication frame
    3674             :                  */
    3675             :                 const u8 *ie;
    3676             : 
    3677             :                 /**
    3678             :                  * ie_len - Length of ie buffer in octets
    3679             :                  */
    3680             :                 size_t ie_len;
    3681             : 
    3682             :                 /**
    3683             :                  * locally_generated - Whether the frame was locally generated
    3684             :                  */
    3685             :                 int locally_generated;
    3686             :         } deauth_info;
    3687             : 
    3688             :         /**
    3689             :          * struct michael_mic_failure - Data for EVENT_MICHAEL_MIC_FAILURE
    3690             :          */
    3691             :         struct michael_mic_failure {
    3692             :                 int unicast;
    3693             :                 const u8 *src;
    3694             :         } michael_mic_failure;
    3695             : 
    3696             :         /**
    3697             :          * struct interface_status - Data for EVENT_INTERFACE_STATUS
    3698             :          */
    3699             :         struct interface_status {
    3700             :                 char ifname[100];
    3701             :                 enum {
    3702             :                         EVENT_INTERFACE_ADDED, EVENT_INTERFACE_REMOVED
    3703             :                 } ievent;
    3704             :         } interface_status;
    3705             : 
    3706             :         /**
    3707             :          * struct pmkid_candidate - Data for EVENT_PMKID_CANDIDATE
    3708             :          */
    3709             :         struct pmkid_candidate {
    3710             :                 /** BSSID of the PMKID candidate */
    3711             :                 u8 bssid[ETH_ALEN];
    3712             :                 /** Smaller the index, higher the priority */
    3713             :                 int index;
    3714             :                 /** Whether RSN IE includes pre-authenticate flag */
    3715             :                 int preauth;
    3716             :         } pmkid_candidate;
    3717             : 
    3718             :         /**
    3719             :          * struct stkstart - Data for EVENT_STKSTART
    3720             :          */
    3721             :         struct stkstart {
    3722             :                 u8 peer[ETH_ALEN];
    3723             :         } stkstart;
    3724             : 
    3725             :         /**
    3726             :          * struct tdls - Data for EVENT_TDLS
    3727             :          */
    3728             :         struct tdls {
    3729             :                 u8 peer[ETH_ALEN];
    3730             :                 enum {
    3731             :                         TDLS_REQUEST_SETUP,
    3732             :                         TDLS_REQUEST_TEARDOWN
    3733             :                 } oper;
    3734             :                 u16 reason_code; /* for teardown */
    3735             :         } tdls;
    3736             : 
    3737             :         /**
    3738             :          * struct wnm - Data for EVENT_WNM
    3739             :          */
    3740             :         struct wnm {
    3741             :                 u8 addr[ETH_ALEN];
    3742             :                 enum {
    3743             :                         WNM_OPER_SLEEP,
    3744             :                 } oper;
    3745             :                 enum {
    3746             :                         WNM_SLEEP_ENTER,
    3747             :                         WNM_SLEEP_EXIT
    3748             :                 } sleep_action;
    3749             :                 int sleep_intval;
    3750             :                 u16 reason_code;
    3751             :                 u8 *buf;
    3752             :                 u16 buf_len;
    3753             :         } wnm;
    3754             : 
    3755             :         /**
    3756             :          * struct ft_ies - FT information elements (EVENT_FT_RESPONSE)
    3757             :          *
    3758             :          * During FT (IEEE 802.11r) authentication sequence, the driver is
    3759             :          * expected to use this event to report received FT IEs (MDIE, FTIE,
    3760             :          * RSN IE, TIE, possible resource request) to the supplicant. The FT
    3761             :          * IEs for the next message will be delivered through the
    3762             :          * struct wpa_driver_ops::update_ft_ies() callback.
    3763             :          */
    3764             :         struct ft_ies {
    3765             :                 const u8 *ies;
    3766             :                 size_t ies_len;
    3767             :                 int ft_action;
    3768             :                 u8 target_ap[ETH_ALEN];
    3769             :                 /** Optional IE(s), e.g., WMM TSPEC(s), for RIC-Request */
    3770             :                 const u8 *ric_ies;
    3771             :                 /** Length of ric_ies buffer in octets */
    3772             :                 size_t ric_ies_len;
    3773             :         } ft_ies;
    3774             : 
    3775             :         /**
    3776             :          * struct ibss_rsn_start - Data for EVENT_IBSS_RSN_START
    3777             :          */
    3778             :         struct ibss_rsn_start {
    3779             :                 u8 peer[ETH_ALEN];
    3780             :         } ibss_rsn_start;
    3781             : 
    3782             :         /**
    3783             :          * struct auth_info - Data for EVENT_AUTH events
    3784             :          */
    3785             :         struct auth_info {
    3786             :                 u8 peer[ETH_ALEN];
    3787             :                 u8 bssid[ETH_ALEN];
    3788             :                 u16 auth_type;
    3789             :                 u16 auth_transaction;
    3790             :                 u16 status_code;
    3791             :                 const u8 *ies;
    3792             :                 size_t ies_len;
    3793             :         } auth;
    3794             : 
    3795             :         /**
    3796             :          * struct assoc_reject - Data for EVENT_ASSOC_REJECT events
    3797             :          */
    3798             :         struct assoc_reject {
    3799             :                 /**
    3800             :                  * bssid - BSSID of the AP that rejected association
    3801             :                  */
    3802             :                 const u8 *bssid;
    3803             : 
    3804             :                 /**
    3805             :                  * resp_ies - (Re)Association Response IEs
    3806             :                  *
    3807             :                  * Optional association data from the driver. This data is not
    3808             :                  * required WPA, but may be useful for some protocols and as
    3809             :                  * such, should be reported if this is available to the driver
    3810             :                  * interface.
    3811             :                  *
    3812             :                  * This should start with the first IE (fixed fields before IEs
    3813             :                  * are not included).
    3814             :                  */
    3815             :                 const u8 *resp_ies;
    3816             : 
    3817             :                 /**
    3818             :                  * resp_ies_len - Length of resp_ies in bytes
    3819             :                  */
    3820             :                 size_t resp_ies_len;
    3821             : 
    3822             :                 /**
    3823             :                  * status_code - Status Code from (Re)association Response
    3824             :                  */
    3825             :                 u16 status_code;
    3826             :         } assoc_reject;
    3827             : 
    3828             :         struct timeout_event {
    3829             :                 u8 addr[ETH_ALEN];
    3830             :         } timeout_event;
    3831             : 
    3832             :         /**
    3833             :          * struct ft_rrb_rx - Data for EVENT_FT_RRB_RX events
    3834             :          */
    3835             :         struct ft_rrb_rx {
    3836             :                 const u8 *src;
    3837             :                 const u8 *data;
    3838             :                 size_t data_len;
    3839             :         } ft_rrb_rx;
    3840             : 
    3841             :         /**
    3842             :          * struct tx_status - Data for EVENT_TX_STATUS events
    3843             :          */
    3844             :         struct tx_status {
    3845             :                 u16 type;
    3846             :                 u16 stype;
    3847             :                 const u8 *dst;
    3848             :                 const u8 *data;
    3849             :                 size_t data_len;
    3850             :                 int ack;
    3851             :         } tx_status;
    3852             : 
    3853             :         /**
    3854             :          * struct rx_from_unknown - Data for EVENT_RX_FROM_UNKNOWN events
    3855             :          */
    3856             :         struct rx_from_unknown {
    3857             :                 const u8 *bssid;
    3858             :                 const u8 *addr;
    3859             :                 int wds;
    3860             :         } rx_from_unknown;
    3861             : 
    3862             :         /**
    3863             :          * struct rx_mgmt - Data for EVENT_RX_MGMT events
    3864             :          */
    3865             :         struct rx_mgmt {
    3866             :                 const u8 *frame;
    3867             :                 size_t frame_len;
    3868             :                 u32 datarate;
    3869             : 
    3870             :                 /**
    3871             :                  * drv_priv - Pointer to store driver private BSS information
    3872             :                  *
    3873             :                  * If not set to NULL, this is used for comparison with
    3874             :                  * hostapd_data->drv_priv to determine which BSS should process
    3875             :                  * the frame.
    3876             :                  */
    3877             :                 void *drv_priv;
    3878             : 
    3879             :                 /**
    3880             :                  * freq - Frequency (in MHz) on which the frame was received
    3881             :                  */
    3882             :                 int freq;
    3883             : 
    3884             :                 /**
    3885             :                  * ssi_signal - Signal strength in dBm (or 0 if not available)
    3886             :                  */
    3887             :                 int ssi_signal;
    3888             :         } rx_mgmt;
    3889             : 
    3890             :         /**
    3891             :          * struct remain_on_channel - Data for EVENT_REMAIN_ON_CHANNEL events
    3892             :          *
    3893             :          * This is also used with EVENT_CANCEL_REMAIN_ON_CHANNEL events.
    3894             :          */
    3895             :         struct remain_on_channel {
    3896             :                 /**
    3897             :                  * freq - Channel frequency in MHz
    3898             :                  */
    3899             :                 unsigned int freq;
    3900             : 
    3901             :                 /**
    3902             :                  * duration - Duration to remain on the channel in milliseconds
    3903             :                  */
    3904             :                 unsigned int duration;
    3905             :         } remain_on_channel;
    3906             : 
    3907             :         /**
    3908             :          * struct scan_info - Optional data for EVENT_SCAN_RESULTS events
    3909             :          * @aborted: Whether the scan was aborted
    3910             :          * @freqs: Scanned frequencies in MHz (%NULL = all channels scanned)
    3911             :          * @num_freqs: Number of entries in freqs array
    3912             :          * @ssids: Scanned SSIDs (%NULL or zero-length SSID indicates wildcard
    3913             :          *      SSID)
    3914             :          * @num_ssids: Number of entries in ssids array
    3915             :          */
    3916             :         struct scan_info {
    3917             :                 int aborted;
    3918             :                 const int *freqs;
    3919             :                 size_t num_freqs;
    3920             :                 struct wpa_driver_scan_ssid ssids[WPAS_MAX_SCAN_SSIDS];
    3921             :                 size_t num_ssids;
    3922             :         } scan_info;
    3923             : 
    3924             :         /**
    3925             :          * struct mlme_rx - Data for EVENT_MLME_RX events
    3926             :          */
    3927             :         struct mlme_rx {
    3928             :                 const u8 *buf;
    3929             :                 size_t len;
    3930             :                 int freq;
    3931             :                 int channel;
    3932             :                 int ssi;
    3933             :         } mlme_rx;
    3934             : 
    3935             :         /**
    3936             :          * struct rx_probe_req - Data for EVENT_RX_PROBE_REQ events
    3937             :          */
    3938             :         struct rx_probe_req {
    3939             :                 /**
    3940             :                  * sa - Source address of the received Probe Request frame
    3941             :                  */
    3942             :                 const u8 *sa;
    3943             : 
    3944             :                 /**
    3945             :                  * da - Destination address of the received Probe Request frame
    3946             :                  *      or %NULL if not available
    3947             :                  */
    3948             :                 const u8 *da;
    3949             : 
    3950             :                 /**
    3951             :                  * bssid - BSSID of the received Probe Request frame or %NULL
    3952             :                  *      if not available
    3953             :                  */
    3954             :                 const u8 *bssid;
    3955             : 
    3956             :                 /**
    3957             :                  * ie - IEs from the Probe Request body
    3958             :                  */
    3959             :                 const u8 *ie;
    3960             : 
    3961             :                 /**
    3962             :                  * ie_len - Length of ie buffer in octets
    3963             :                  */
    3964             :                 size_t ie_len;
    3965             : 
    3966             :                 /**
    3967             :                  * signal - signal strength in dBm (or 0 if not available)
    3968             :                  */
    3969             :                 int ssi_signal;
    3970             :         } rx_probe_req;
    3971             : 
    3972             :         /**
    3973             :          * struct new_sta - Data for EVENT_NEW_STA events
    3974             :          */
    3975             :         struct new_sta {
    3976             :                 const u8 *addr;
    3977             :         } new_sta;
    3978             : 
    3979             :         /**
    3980             :          * struct eapol_rx - Data for EVENT_EAPOL_RX events
    3981             :          */
    3982             :         struct eapol_rx {
    3983             :                 const u8 *src;
    3984             :                 const u8 *data;
    3985             :                 size_t data_len;
    3986             :         } eapol_rx;
    3987             : 
    3988             :         /**
    3989             :          * signal_change - Data for EVENT_SIGNAL_CHANGE events
    3990             :          */
    3991             :         struct wpa_signal_info signal_change;
    3992             : 
    3993             :         /**
    3994             :          * struct best_channel - Data for EVENT_BEST_CHANNEL events
    3995             :          * @freq_24: Best 2.4 GHz band channel frequency in MHz
    3996             :          * @freq_5: Best 5 GHz band channel frequency in MHz
    3997             :          * @freq_overall: Best channel frequency in MHz
    3998             :          *
    3999             :          * 0 can be used to indicate no preference in either band.
    4000             :          */
    4001             :         struct best_channel {
    4002             :                 int freq_24;
    4003             :                 int freq_5;
    4004             :                 int freq_overall;
    4005             :         } best_chan;
    4006             : 
    4007             :         struct unprot_deauth {
    4008             :                 const u8 *sa;
    4009             :                 const u8 *da;
    4010             :                 u16 reason_code;
    4011             :         } unprot_deauth;
    4012             : 
    4013             :         struct unprot_disassoc {
    4014             :                 const u8 *sa;
    4015             :                 const u8 *da;
    4016             :                 u16 reason_code;
    4017             :         } unprot_disassoc;
    4018             : 
    4019             :         /**
    4020             :          * struct low_ack - Data for EVENT_STATION_LOW_ACK events
    4021             :          * @addr: station address
    4022             :          */
    4023             :         struct low_ack {
    4024             :                 u8 addr[ETH_ALEN];
    4025             :         } low_ack;
    4026             : 
    4027             :         /**
    4028             :          * struct ibss_peer_lost - Data for EVENT_IBSS_PEER_LOST
    4029             :          */
    4030             :         struct ibss_peer_lost {
    4031             :                 u8 peer[ETH_ALEN];
    4032             :         } ibss_peer_lost;
    4033             : 
    4034             :         /**
    4035             :          * struct driver_gtk_rekey - Data for EVENT_DRIVER_GTK_REKEY
    4036             :          */
    4037             :         struct driver_gtk_rekey {
    4038             :                 const u8 *bssid;
    4039             :                 const u8 *replay_ctr;
    4040             :         } driver_gtk_rekey;
    4041             : 
    4042             :         /**
    4043             :          * struct client_poll - Data for EVENT_DRIVER_CLIENT_POLL_OK events
    4044             :          * @addr: station address
    4045             :          */
    4046             :         struct client_poll {
    4047             :                 u8 addr[ETH_ALEN];
    4048             :         } client_poll;
    4049             : 
    4050             :         /**
    4051             :          * struct eapol_tx_status
    4052             :          * @dst: Original destination
    4053             :          * @data: Data starting with IEEE 802.1X header (!)
    4054             :          * @data_len: Length of data
    4055             :          * @ack: Indicates ack or lost frame
    4056             :          *
    4057             :          * This corresponds to hapd_send_eapol if the frame sent
    4058             :          * there isn't just reported as EVENT_TX_STATUS.
    4059             :          */
    4060             :         struct eapol_tx_status {
    4061             :                 const u8 *dst;
    4062             :                 const u8 *data;
    4063             :                 int data_len;
    4064             :                 int ack;
    4065             :         } eapol_tx_status;
    4066             : 
    4067             :         /**
    4068             :          * struct ch_switch
    4069             :          * @freq: Frequency of new channel in MHz
    4070             :          * @ht_enabled: Whether this is an HT channel
    4071             :          * @ch_offset: Secondary channel offset
    4072             :          * @ch_width: Channel width
    4073             :          * @cf1: Center frequency 1
    4074             :          * @cf2: Center frequency 2
    4075             :          */
    4076             :         struct ch_switch {
    4077             :                 int freq;
    4078             :                 int ht_enabled;
    4079             :                 int ch_offset;
    4080             :                 enum chan_width ch_width;
    4081             :                 int cf1;
    4082             :                 int cf2;
    4083             :         } ch_switch;
    4084             : 
    4085             :         /**
    4086             :          * struct connect_failed - Data for EVENT_CONNECT_FAILED_REASON
    4087             :          * @addr: Remote client address
    4088             :          * @code: Reason code for connection failure
    4089             :          */
    4090             :         struct connect_failed_reason {
    4091             :                 u8 addr[ETH_ALEN];
    4092             :                 enum {
    4093             :                         MAX_CLIENT_REACHED,
    4094             :                         BLOCKED_CLIENT
    4095             :                 } code;
    4096             :         } connect_failed_reason;
    4097             : 
    4098             :         /**
    4099             :          * struct dfs_event - Data for radar detected events
    4100             :          * @freq: Frequency of the channel in MHz
    4101             :          */
    4102             :         struct dfs_event {
    4103             :                 int freq;
    4104             :                 int ht_enabled;
    4105             :                 int chan_offset;
    4106             :                 enum chan_width chan_width;
    4107             :                 int cf1;
    4108             :                 int cf2;
    4109             :         } dfs_event;
    4110             : 
    4111             :         /**
    4112             :          * survey_results - Survey result data for EVENT_SURVEY
    4113             :          * @freq_filter: Requested frequency survey filter, 0 if request
    4114             :          *      was for all survey data
    4115             :          * @survey_list: Linked list of survey data
    4116             :          */
    4117             :         struct survey_results {
    4118             :                 unsigned int freq_filter;
    4119             :                 struct dl_list survey_list; /* struct freq_survey */
    4120             :         } survey_results;
    4121             : 
    4122             :         /**
    4123             :          * channel_list_changed - Data for EVENT_CHANNEL_LIST_CHANGED
    4124             :          * @initiator: Initiator of the regulatory change
    4125             :          * @type: Regulatory change type
    4126             :          * @alpha2: Country code (or "" if not available)
    4127             :          */
    4128             :         struct channel_list_changed {
    4129             :                 enum reg_change_initiator initiator;
    4130             :                 enum reg_type type;
    4131             :                 char alpha2[3];
    4132             :         } channel_list_changed;
    4133             : 
    4134             :         /**
    4135             :          * freq_range - List of frequency ranges
    4136             :          *
    4137             :          * This is used as the data with EVENT_AVOID_FREQUENCIES.
    4138             :          */
    4139             :         struct wpa_freq_range_list freq_range;
    4140             : };
    4141             : 
    4142             : /**
    4143             :  * wpa_supplicant_event - Report a driver event for wpa_supplicant
    4144             :  * @ctx: Context pointer (wpa_s); this is the ctx variable registered
    4145             :  *      with struct wpa_driver_ops::init()
    4146             :  * @event: event type (defined above)
    4147             :  * @data: possible extra data for the event
    4148             :  *
    4149             :  * Driver wrapper code should call this function whenever an event is received
    4150             :  * from the driver.
    4151             :  */
    4152             : void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
    4153             :                           union wpa_event_data *data);
    4154             : 
    4155             : 
    4156             : /*
    4157             :  * The following inline functions are provided for convenience to simplify
    4158             :  * event indication for some of the common events.
    4159             :  */
    4160             : 
    4161           0 : static inline void drv_event_assoc(void *ctx, const u8 *addr, const u8 *ie,
    4162             :                                    size_t ielen, int reassoc)
    4163             : {
    4164             :         union wpa_event_data event;
    4165           0 :         os_memset(&event, 0, sizeof(event));
    4166           0 :         event.assoc_info.reassoc = reassoc;
    4167           0 :         event.assoc_info.req_ies = ie;
    4168           0 :         event.assoc_info.req_ies_len = ielen;
    4169           0 :         event.assoc_info.addr = addr;
    4170           0 :         wpa_supplicant_event(ctx, EVENT_ASSOC, &event);
    4171           0 : }
    4172             : 
    4173           0 : static inline void drv_event_disassoc(void *ctx, const u8 *addr)
    4174             : {
    4175             :         union wpa_event_data event;
    4176           0 :         os_memset(&event, 0, sizeof(event));
    4177           0 :         event.disassoc_info.addr = addr;
    4178           0 :         wpa_supplicant_event(ctx, EVENT_DISASSOC, &event);
    4179           0 : }
    4180             : 
    4181        4171 : static inline void drv_event_eapol_rx(void *ctx, const u8 *src, const u8 *data,
    4182             :                                       size_t data_len)
    4183             : {
    4184             :         union wpa_event_data event;
    4185        4171 :         os_memset(&event, 0, sizeof(event));
    4186        4171 :         event.eapol_rx.src = src;
    4187        4171 :         event.eapol_rx.data = data;
    4188        4171 :         event.eapol_rx.data_len = data_len;
    4189        4171 :         wpa_supplicant_event(ctx, EVENT_EAPOL_RX, &event);
    4190        4171 : }
    4191             : 
    4192             : /* driver_common.c */
    4193             : void wpa_scan_results_free(struct wpa_scan_results *res);
    4194             : 
    4195             : /* Convert wpa_event_type to a string for logging */
    4196             : const char * event_to_string(enum wpa_event_type event);
    4197             : 
    4198             : /* Convert chan_width to a string for logging and control interfaces */
    4199             : const char * channel_width_to_string(enum chan_width width);
    4200             : 
    4201             : /* NULL terminated array of linked in driver wrappers */
    4202             : extern struct wpa_driver_ops *wpa_drivers[];
    4203             : 
    4204             : #endif /* DRIVER_H */

Generated by: LCOV version 1.10