driver.h

Go to the documentation of this file.

#ifndef DRIVER_H
#define DRIVER_H

#define WPA_SUPPLICANT_DRIVER_VERSION 4

#include "common/defs.h"
#include "common/ieee802_11_defs.h"
#include "utils/list.h"

#define HOSTAPD_CHAN_DISABLED 0x00000001
#define HOSTAPD_CHAN_NO_IR 0x00000002
#define HOSTAPD_CHAN_RADAR 0x00000008
#define HOSTAPD_CHAN_HT40PLUS 0x00000010
#define HOSTAPD_CHAN_HT40MINUS 0x00000020
#define HOSTAPD_CHAN_HT40 0x00000040
#define HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED 0x00000080

#define HOSTAPD_CHAN_DFS_UNKNOWN 0x00000000
#define HOSTAPD_CHAN_DFS_USABLE 0x00000100
#define HOSTAPD_CHAN_DFS_UNAVAILABLE 0x00000200
#define HOSTAPD_CHAN_DFS_AVAILABLE 0x00000300
#define HOSTAPD_CHAN_DFS_MASK 0x00000300

#define HOSTAPD_CHAN_VHT_10_70 0x00000800
#define HOSTAPD_CHAN_VHT_30_50 0x00001000
#define HOSTAPD_CHAN_VHT_50_30 0x00002000
#define HOSTAPD_CHAN_VHT_70_10 0x00004000

#define HOSTAPD_CHAN_INDOOR_ONLY 0x00010000
#define HOSTAPD_CHAN_GO_CONCURRENT 0x00020000

enum reg_change_initiator {
        REGDOM_SET_BY_CORE,
        REGDOM_SET_BY_USER,
        REGDOM_SET_BY_DRIVER,
        REGDOM_SET_BY_COUNTRY_IE,
        REGDOM_BEACON_HINT,
};

enum reg_type {
        REGDOM_TYPE_UNKNOWN,
        REGDOM_TYPE_COUNTRY,
        REGDOM_TYPE_WORLD,
        REGDOM_TYPE_CUSTOM_WORLD,
        REGDOM_TYPE_INTERSECTION,
};

struct hostapd_channel_data {
        short chan;

        int freq;

        int flag;

        u8 max_tx_power;

        struct dl_list survey_list;

        s8 min_nf;

#ifdef CONFIG_ACS

        long double interference_factor;
#endif /* CONFIG_ACS */

        unsigned int dfs_cac_ms;
};

#define HOSTAPD_MODE_FLAG_HT_INFO_KNOWN BIT(0)
#define HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN BIT(1)

struct hostapd_hw_modes {
        enum hostapd_hw_mode mode;

        int num_channels;

        struct hostapd_channel_data *channels;

        int num_rates;

        int *rates;

        u16 ht_capab;

        u8 mcs_set[16];

        u8 a_mpdu_params;

        u32 vht_capab;

        u8 vht_mcs_set[8];

        unsigned int flags; /* HOSTAPD_MODE_FLAG_* */
};


#define IEEE80211_MODE_INFRA    0
#define IEEE80211_MODE_IBSS     1
#define IEEE80211_MODE_AP       2
#define IEEE80211_MODE_MESH     5

#define IEEE80211_CAP_ESS       0x0001
#define IEEE80211_CAP_IBSS      0x0002
#define IEEE80211_CAP_PRIVACY   0x0010
#define IEEE80211_CAP_RRM       0x1000

/* DMG (60 GHz) IEEE 802.11ad */
/* type - bits 0..1 */
#define IEEE80211_CAP_DMG_MASK  0x0003
#define IEEE80211_CAP_DMG_IBSS  0x0001 /* Tx by: STA */
#define IEEE80211_CAP_DMG_PBSS  0x0002 /* Tx by: PCP */
#define IEEE80211_CAP_DMG_AP    0x0003 /* Tx by: AP */

#define WPA_SCAN_QUAL_INVALID           BIT(0)
#define WPA_SCAN_NOISE_INVALID          BIT(1)
#define WPA_SCAN_LEVEL_INVALID          BIT(2)
#define WPA_SCAN_LEVEL_DBM              BIT(3)
#define WPA_SCAN_ASSOCIATED             BIT(5)

struct wpa_scan_res {
        unsigned int flags;
        u8 bssid[ETH_ALEN];
        int freq;
        u16 beacon_int;
        u16 caps;
        int qual;
        int noise;
        int level;
        u64 tsf;
        unsigned int age;
        unsigned int est_throughput;
        int snr;
        size_t ie_len;
        size_t beacon_ie_len;
        /* Followed by ie_len + beacon_ie_len octets of IE data */
};

struct wpa_scan_results {
        struct wpa_scan_res **res;
        size_t num;
        struct os_reltime fetch_time;
};

struct wpa_interface_info {
        struct wpa_interface_info *next;
        char *ifname;
        char *desc;
        const char *drv_name;
};

#define WPAS_MAX_SCAN_SSIDS 16

struct wpa_driver_scan_params {
        struct wpa_driver_scan_ssid {
                const u8 *ssid;
                size_t ssid_len;
        } ssids[WPAS_MAX_SCAN_SSIDS];

        size_t num_ssids;

        const u8 *extra_ies;

        size_t extra_ies_len;

        int *freqs;

        struct wpa_driver_scan_filter {
                u8 ssid[SSID_MAX_LEN];
                size_t ssid_len;
        } *filter_ssids;

        size_t num_filter_ssids;

        s32 filter_rssi;

        unsigned int p2p_probe:1;

        unsigned int only_new_results:1;

        unsigned int low_priority:1;

        unsigned int mac_addr_rand:1;

        const u8 *mac_addr;

        const u8 *mac_addr_mask;

        /*
         * NOTE: Whenever adding new parameters here, please make sure
         * wpa_scan_clone_params() and wpa_scan_free_params() get updated with
         * matching changes.
         */
};

struct wpa_driver_auth_params {
        int freq;
        const u8 *bssid;
        const u8 *ssid;
        size_t ssid_len;
        int auth_alg;
        const u8 *ie;
        size_t ie_len;
        const u8 *wep_key[4];
        size_t wep_key_len[4];
        int wep_tx_keyidx;
        int local_state_change;

        int p2p;

        const u8 *sae_data;

        size_t sae_data_len;
};

enum wps_mode {
        WPS_MODE_NONE,

        WPS_MODE_OPEN,

        WPS_MODE_PRIVACY
};

struct hostapd_freq_params {
        enum hostapd_hw_mode mode;

        int freq;

        int channel;

        int ht_enabled;

        int sec_channel_offset;

        int vht_enabled;

        int center_freq1;

        int center_freq2;

        int bandwidth;
};

struct wpa_driver_associate_params {
        const u8 *bssid;

        const u8 *bssid_hint;

        const u8 *ssid;

        size_t ssid_len;

        struct hostapd_freq_params freq;

        int freq_hint;

        int bg_scan_period;

        int beacon_int;

        const u8 *wpa_ie;

        size_t wpa_ie_len;

        unsigned int wpa_proto;

        unsigned int pairwise_suite;

        unsigned int group_suite;

        unsigned int key_mgmt_suite;

        int auth_alg;

        int mode;

        const u8 *wep_key[4];

        size_t wep_key_len[4];

        int wep_tx_keyidx;

        enum mfp_options mgmt_frame_protection;

        const u8 *ft_ies;

        size_t ft_ies_len;

        const u8 *ft_md;

        const char *passphrase;

        const u8 *psk;

        int drop_unencrypted;

        const u8 *prev_bssid;

        enum wps_mode wps;

        int p2p;

        int uapsd;

        int fixed_bssid;

        int fixed_freq;

        int disable_ht;

        const u8 *htcaps;

        const u8 *htcaps_mask;

#ifdef CONFIG_VHT_OVERRIDES

        int disable_vht;

        const struct ieee80211_vht_capabilities *vhtcaps;
        const struct ieee80211_vht_capabilities *vhtcaps_mask;
#endif /* CONFIG_VHT_OVERRIDES */

        int req_key_mgmt_offload;

        int rrm_used;
};

enum hide_ssid {
        NO_SSID_HIDING,
        HIDDEN_SSID_ZERO_LEN,
        HIDDEN_SSID_ZERO_CONTENTS
};

struct wowlan_triggers {
        u8 any;
        u8 disconnect;
        u8 magic_pkt;
        u8 gtk_rekey_failure;
        u8 eap_identity_req;
        u8 four_way_handshake;
        u8 rfkill_release;
};

struct wpa_driver_ap_params {
        u8 *head;

        size_t head_len;

        u8 *tail;

        size_t tail_len;

        int dtim_period;

        int beacon_int;

        int *basic_rates;

        u8 *proberesp;

        size_t proberesp_len;

        const u8 *ssid;

        size_t ssid_len;

        enum hide_ssid hide_ssid;

        unsigned int pairwise_ciphers;

        unsigned int group_cipher;

        unsigned int key_mgmt_suites;

        unsigned int auth_algs;

        unsigned int wpa_version;

        int privacy;

        const struct wpabuf *beacon_ies;

        const struct wpabuf *proberesp_ies;

        const struct wpabuf *assocresp_ies;

        int isolate;

        int cts_protect;

        int preamble;

        int short_slot_time;

        int ht_opmode;

        int interworking;

        const u8 *hessid;

        u8 access_network_type;

        int ap_max_inactivity;

        u8 p2p_go_ctwindow;

        unsigned int smps_mode;

        int disable_dgaf;

        int osen;

        struct hostapd_freq_params *freq;

        int reenable;
};

struct wpa_driver_mesh_bss_params {
#define WPA_DRIVER_MESH_CONF_FLAG_AUTO_PLINKS   0x00000001
        /*
         * TODO: Other mesh configuration parameters would go here.
         * See NL80211_MESHCONF_* for all the mesh config parameters.
         */
        unsigned int flags;
        int peer_link_timeout;
};

struct wpa_driver_mesh_join_params {
        const u8 *meshid;
        int meshid_len;
        const int *basic_rates;
        const u8 *ies;
        int ie_len;
        struct hostapd_freq_params freq;
        int beacon_int;
        int max_peer_links;
        struct wpa_driver_mesh_bss_params conf;
#define WPA_DRIVER_MESH_FLAG_USER_MPM   0x00000001
#define WPA_DRIVER_MESH_FLAG_DRIVER_MPM 0x00000002
#define WPA_DRIVER_MESH_FLAG_SAE_AUTH   0x00000004
#define WPA_DRIVER_MESH_FLAG_AMPE       0x00000008
        unsigned int flags;
};

struct wpa_driver_capa {
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA            0x00000001
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2           0x00000002
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK        0x00000004
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK       0x00000008
#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE       0x00000010
#define WPA_DRIVER_CAPA_KEY_MGMT_FT             0x00000020
#define WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK         0x00000040
#define WPA_DRIVER_CAPA_KEY_MGMT_WAPI_PSK       0x00000080
#define WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B        0x00000100
#define WPA_DRIVER_CAPA_KEY_MGMT_SUITE_B_192    0x00000200

        unsigned int key_mgmt;

#define WPA_DRIVER_CAPA_ENC_WEP40       0x00000001
#define WPA_DRIVER_CAPA_ENC_WEP104      0x00000002
#define WPA_DRIVER_CAPA_ENC_TKIP        0x00000004
#define WPA_DRIVER_CAPA_ENC_CCMP        0x00000008
#define WPA_DRIVER_CAPA_ENC_WEP128      0x00000010
#define WPA_DRIVER_CAPA_ENC_GCMP        0x00000020
#define WPA_DRIVER_CAPA_ENC_GCMP_256    0x00000040
#define WPA_DRIVER_CAPA_ENC_CCMP_256    0x00000080
#define WPA_DRIVER_CAPA_ENC_BIP         0x00000100
#define WPA_DRIVER_CAPA_ENC_BIP_GMAC_128        0x00000200
#define WPA_DRIVER_CAPA_ENC_BIP_GMAC_256        0x00000400
#define WPA_DRIVER_CAPA_ENC_BIP_CMAC_256        0x00000800
#define WPA_DRIVER_CAPA_ENC_GTK_NOT_USED        0x00001000

        unsigned int enc;

#define WPA_DRIVER_AUTH_OPEN            0x00000001
#define WPA_DRIVER_AUTH_SHARED          0x00000002
#define WPA_DRIVER_AUTH_LEAP            0x00000004

        unsigned int auth;

#define WPA_DRIVER_FLAGS_DRIVER_IE      0x00000001

#define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC 0x00000002

#define WPA_DRIVER_FLAGS_DFS_OFFLOAD                    0x00000004

#define WPA_DRIVER_FLAGS_4WAY_HANDSHAKE 0x00000008

#define WPA_DRIVER_FLAGS_WIRED          0x00000010

#define WPA_DRIVER_FLAGS_SME            0x00000020

#define WPA_DRIVER_FLAGS_AP             0x00000040

#define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE      0x00000080

#define WPA_DRIVER_FLAGS_HT_2040_COEX                   0x00000100

#define WPA_DRIVER_FLAGS_P2P_CONCURRENT 0x00000200

#define WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE        0x00000400

#define WPA_DRIVER_FLAGS_P2P_CAPABLE    0x00000800

#define WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT            0x00001000

#define WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P           0x00002000

#define WPA_DRIVER_FLAGS_SANE_ERROR_CODES               0x00004000

#define WPA_DRIVER_FLAGS_OFFCHANNEL_TX                  0x00008000

#define WPA_DRIVER_FLAGS_EAPOL_TX_STATUS                0x00010000

#define WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS               0x00020000

#define WPA_DRIVER_FLAGS_BSS_SELECTION                  0x00040000

#define WPA_DRIVER_FLAGS_TDLS_SUPPORT                   0x00080000

#define WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP            0x00100000

#define WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD             0x00200000

#define WPA_DRIVER_FLAGS_AP_UAPSD                       0x00400000

#define WPA_DRIVER_FLAGS_INACTIVITY_TIMER               0x00800000

#define WPA_DRIVER_FLAGS_AP_MLME                        0x01000000

#define WPA_DRIVER_FLAGS_SAE                            0x02000000

#define WPA_DRIVER_FLAGS_OBSS_SCAN                      0x04000000

#define WPA_DRIVER_FLAGS_IBSS                           0x08000000

#define WPA_DRIVER_FLAGS_RADAR                          0x10000000

#define WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE           0x20000000

#define WPA_DRIVER_FLAGS_QOS_MAPPING                    0x40000000

#define WPA_DRIVER_FLAGS_AP_CSA                         0x80000000

#define WPA_DRIVER_FLAGS_MESH                   0x0000000100000000ULL

#define WPA_DRIVER_FLAGS_ACS_OFFLOAD            0x0000000200000000ULL

#define WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD       0x0000000400000000ULL

#define WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH    0x0000000800000000ULL

#define WPA_DRIVER_FLAGS_HT_IBSS                0x0000001000000000ULL

#define WPA_DRIVER_FLAGS_VHT_IBSS               0x0000002000000000ULL

#define WPA_DRIVER_FLAGS_SUPPORT_HW_MODE_ANY    0x0000004000000000ULL
        u64 flags;

#define WPA_DRIVER_SMPS_MODE_STATIC                     0x00000001
#define WPA_DRIVER_SMPS_MODE_DYNAMIC                    0x00000002
        unsigned int smps_modes;

        unsigned int wmm_ac_supported:1;

        unsigned int mac_addr_rand_scan_supported:1;
        unsigned int mac_addr_rand_sched_scan_supported:1;

        int max_scan_ssids;

        int max_sched_scan_ssids;

        int sched_scan_supported;

        int max_match_sets;

        unsigned int max_remain_on_chan;

        unsigned int max_stations;

#define WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS               0x00000001

#define WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2              0x00000002

#define WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P               0x00000004

#define WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING      0x00000008
        unsigned int probe_resp_offloads;

        unsigned int max_acl_mac_addrs;

        unsigned int num_multichan_concurrent;

        const u8 *extended_capa, *extended_capa_mask;
        unsigned int extended_capa_len;

        struct wowlan_triggers wowlan_triggers;

#define WPA_DRIVER_FLAGS_DS_PARAM_SET_IE_IN_PROBES      0x00000001

#define WPA_DRIVER_FLAGS_WFA_TPC_IE_IN_PROBES           0x00000002

#define WPA_DRIVER_FLAGS_QUIET                          0x00000004

#define WPA_DRIVER_FLAGS_TX_POWER_INSERTION             0x00000008
        u32 rrm_flags;

        /* Driver concurrency capabilities */
        unsigned int conc_capab;
        /* Maximum number of concurrent channels on 2.4 GHz */
        unsigned int max_conc_chan_2_4;
        /* Maximum number of concurrent channels on 5 GHz */
        unsigned int max_conc_chan_5_0;
};


struct hostapd_data;

struct hostap_sta_driver_data {
        unsigned long rx_packets, tx_packets, rx_bytes, tx_bytes;
        unsigned long current_tx_rate;
        unsigned long inactive_msec;
        unsigned long flags;
        unsigned long num_ps_buf_frames;
        unsigned long tx_retry_failed;
        unsigned long tx_retry_count;
        int last_rssi;
        int last_ack_rssi;
};

struct hostapd_sta_add_params {
        const u8 *addr;
        u16 aid;
        u16 capability;
        const u8 *supp_rates;
        size_t supp_rates_len;
        u16 listen_interval;
        const struct ieee80211_ht_capabilities *ht_capabilities;
        const struct ieee80211_vht_capabilities *vht_capabilities;
        int vht_opmode_enabled;
        u8 vht_opmode;
        u32 flags; /* bitmask of WPA_STA_* flags */
        u32 flags_mask; /* unset bits in flags */
#ifdef CONFIG_MESH
        enum mesh_plink_state plink_state;
#endif /* CONFIG_MESH */
        int set; /* Set STA parameters instead of add */
        u8 qosinfo;
        const u8 *ext_capab;
        size_t ext_capab_len;
        const u8 *supp_channels;
        size_t supp_channels_len;
        const u8 *supp_oper_classes;
        size_t supp_oper_classes_len;
};

struct mac_address {
        u8 addr[ETH_ALEN];
};

struct hostapd_acl_params {
        u8 acl_policy;
        unsigned int num_mac_acl;
        struct mac_address mac_acl[0];
};

enum wpa_driver_if_type {
        WPA_IF_STATION,

        WPA_IF_AP_VLAN,

        WPA_IF_AP_BSS,

        WPA_IF_P2P_GO,

        WPA_IF_P2P_CLIENT,

        WPA_IF_P2P_GROUP,

        WPA_IF_P2P_DEVICE,

        /*
         * WPA_IF_MESH - Mesh interface
         */
        WPA_IF_MESH,

        /*
         * WPA_IF_TDLS - TDLS offchannel interface (used for pref freq only)
         */
        WPA_IF_TDLS,

        /*
         * WPA_IF_IBSS - IBSS interface (used for pref freq only)
         */
        WPA_IF_IBSS,
};

struct wpa_init_params {
        void *global_priv;
        const u8 *bssid;
        const char *ifname;
        const char *driver_params;
        int use_pae_group_addr;
        char **bridge;
        size_t num_bridge;

        u8 *own_addr; /* buffer for writing own MAC address */
};


struct wpa_bss_params {
        const char *ifname;
        int enabled;

        int wpa;
        int ieee802_1x;
        int wpa_group;
        int wpa_pairwise;
        int wpa_key_mgmt;
        int rsn_preauth;
        enum mfp_options ieee80211w;
};

#define WPA_STA_AUTHORIZED BIT(0)
#define WPA_STA_WMM BIT(1)
#define WPA_STA_SHORT_PREAMBLE BIT(2)
#define WPA_STA_MFP BIT(3)
#define WPA_STA_TDLS_PEER BIT(4)
#define WPA_STA_AUTHENTICATED BIT(5)

enum tdls_oper {
        TDLS_DISCOVERY_REQ,
        TDLS_SETUP,
        TDLS_TEARDOWN,
        TDLS_ENABLE_LINK,
        TDLS_DISABLE_LINK,
        TDLS_ENABLE,
        TDLS_DISABLE
};

enum wnm_oper {
        WNM_SLEEP_ENTER_CONFIRM,
        WNM_SLEEP_ENTER_FAIL,
        WNM_SLEEP_EXIT_CONFIRM,
        WNM_SLEEP_EXIT_FAIL,
        WNM_SLEEP_TFS_REQ_IE_ADD,   /* STA requests driver to add TFS req IE */
        WNM_SLEEP_TFS_REQ_IE_NONE,  /* STA requests empty TFS req IE */
        WNM_SLEEP_TFS_REQ_IE_SET,   /* AP requests driver to set TFS req IE for
                                     * a STA */
        WNM_SLEEP_TFS_RESP_IE_ADD,  /* AP requests driver to add TFS resp IE
                                     * for a STA */
        WNM_SLEEP_TFS_RESP_IE_NONE, /* AP requests empty TFS resp IE */
        WNM_SLEEP_TFS_RESP_IE_SET,  /* AP requests driver to set TFS resp IE
                                     * for a STA */
        WNM_SLEEP_TFS_IE_DEL        /* AP delete the TFS IE */
};

/* enum chan_width - Channel width definitions */
enum chan_width {
        CHAN_WIDTH_20_NOHT,
        CHAN_WIDTH_20,
        CHAN_WIDTH_40,
        CHAN_WIDTH_80,
        CHAN_WIDTH_80P80,
        CHAN_WIDTH_160,
        CHAN_WIDTH_UNKNOWN
};

struct wpa_signal_info {
        u32 frequency;
        int above_threshold;
        int current_signal;
        int avg_signal;
        int avg_beacon_signal;
        int current_noise;
        int current_txrate;
        enum chan_width chanwidth;
        int center_frq1;
        int center_frq2;
};

struct beacon_data {
        u8 *head, *tail;
        u8 *beacon_ies;
        u8 *proberesp_ies;
        u8 *assocresp_ies;
        u8 *probe_resp;

        size_t head_len, tail_len;
        size_t beacon_ies_len;
        size_t proberesp_ies_len;
        size_t assocresp_ies_len;
        size_t probe_resp_len;
};

struct csa_settings {
        u8 cs_count;
        u8 block_tx;

        struct hostapd_freq_params freq_params;
        struct beacon_data beacon_csa;
        struct beacon_data beacon_after;

        u16 counter_offset_beacon;
        u16 counter_offset_presp;
};

/* TDLS peer capabilities for send_tdls_mgmt() */
enum tdls_peer_capability {
        TDLS_PEER_HT = BIT(0),
        TDLS_PEER_VHT = BIT(1),
        TDLS_PEER_WMM = BIT(2),
};

/* valid info in the wmm_params struct */
enum wmm_params_valid_info {
        WMM_PARAMS_UAPSD_QUEUES_INFO = BIT(0),
};

struct wmm_params {
        u8 info_bitmap;
        u8 uapsd_queues;
};

#ifdef CONFIG_MACSEC
struct macsec_init_params {
        Boolean always_include_sci;
        Boolean use_es;
        Boolean use_scb;
};
#endif /* CONFIG_MACSEC */

enum drv_br_port_attr {
        DRV_BR_PORT_ATTR_PROXYARP,
        DRV_BR_PORT_ATTR_HAIRPIN_MODE,
};

enum drv_br_net_param {
        DRV_BR_NET_PARAM_GARP_ACCEPT,
        DRV_BR_MULTICAST_SNOOPING,
};

struct drv_acs_params {
        /* Selected mode (HOSTAPD_MODE_*) */
        enum hostapd_hw_mode hw_mode;

        /* Indicates whether HT is enabled */
        int ht_enabled;

        /* Indicates whether HT40 is enabled */
        int ht40_enabled;

        /* Indicates whether VHT is enabled */
        int vht_enabled;

        /* Configured ACS channel width */
        u16 ch_width;

        /* ACS channel list info */
        unsigned int ch_list_len;
        const u8 *ch_list;
        const int *freq_list;
};


struct wpa_driver_ops {
        const char *name;
        const char *desc;

        int (*get_bssid)(void *priv, u8 *bssid);

        int (*get_ssid)(void *priv, u8 *ssid);

        int (*set_key)(const char *ifname, void *priv, enum wpa_alg alg,
                       const u8 *addr, int key_idx, int set_tx,
                       const u8 *seq, size_t seq_len,
                       const u8 *key, size_t key_len);

        void * (*init)(void *ctx, const char *ifname);

        void (*deinit)(void *priv);

        int (*set_param)(void *priv, const char *param);

        int (*set_countermeasures)(void *priv, int enabled);

        int (*deauthenticate)(void *priv, const u8 *addr, int reason_code);

        int (*associate)(void *priv,
                         struct wpa_driver_associate_params *params);

        int (*add_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);

        int (*remove_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid);

        int (*flush_pmkid)(void *priv);

        int (*get_capa)(void *priv, struct wpa_driver_capa *capa);

        void (*poll)(void *priv);

        const char * (*get_ifname)(void *priv);

        const u8 * (*get_mac_addr)(void *priv);

        int (*set_operstate)(void *priv, int state);

        int (*mlme_setprotection)(void *priv, const u8 *addr, int protect_type,
                                  int key_type);

        struct hostapd_hw_modes * (*get_hw_feature_data)(void *priv,
                                                         u16 *num_modes,
                                                         u16 *flags);

        int (*send_mlme)(void *priv, const u8 *data, size_t data_len,
                         int noack, unsigned int freq);

        int (*update_ft_ies)(void *priv, const u8 *md, const u8 *ies,
                             size_t ies_len);

         struct wpa_scan_results * (*get_scan_results2)(void *priv);

        int (*set_country)(void *priv, const char *alpha2);

        int (*get_country)(void *priv, char *alpha2);

        void * (*global_init)(void);

        void (*global_deinit)(void *priv);

        void * (*init2)(void *ctx, const char *ifname, void *global_priv);

        struct wpa_interface_info * (*get_interfaces)(void *global_priv);

        int (*scan2)(void *priv, struct wpa_driver_scan_params *params);

        int (*authenticate)(void *priv,
                            struct wpa_driver_auth_params *params);

        int (*set_ap)(void *priv, struct wpa_driver_ap_params *params);

        int (*set_acl)(void *priv, struct hostapd_acl_params *params);

        void * (*hapd_init)(struct hostapd_data *hapd,
                            struct wpa_init_params *params);

        void (*hapd_deinit)(void *priv);

        int (*set_ieee8021x)(void *priv, struct wpa_bss_params *params);

        int (*set_privacy)(void *priv, int enabled);

        int (*get_seqnum)(const char *ifname, void *priv, const u8 *addr,
                          int idx, u8 *seq);

        int (*flush)(void *priv);

        int (*set_generic_elem)(void *priv, const u8 *elem, size_t elem_len);

        int (*read_sta_data)(void *priv, struct hostap_sta_driver_data *data,
                             const u8 *addr);

        int (*hapd_send_eapol)(void *priv, const u8 *addr, const u8 *data,
                               size_t data_len, int encrypt,
                               const u8 *own_addr, u32 flags);

        int (*sta_deauth)(void *priv, const u8 *own_addr, const u8 *addr,
                          int reason);

        int (*sta_disassoc)(void *priv, const u8 *own_addr, const u8 *addr,
                            int reason);

        int (*sta_remove)(void *priv, const u8 *addr);

        int (*hapd_get_ssid)(void *priv, u8 *buf, int len);

        int (*hapd_set_ssid)(void *priv, const u8 *buf, int len);

        int (*hapd_set_countermeasures)(void *priv, int enabled);

        int (*sta_add)(void *priv, struct hostapd_sta_add_params *params);

        int (*get_inact_sec)(void *priv, const u8 *addr);

        int (*sta_clear_stats)(void *priv, const u8 *addr);

        int (*set_freq)(void *priv, struct hostapd_freq_params *freq);

        int (*set_rts)(void *priv, int rts);

        int (*set_frag)(void *priv, int frag);

        int (*sta_set_flags)(void *priv, const u8 *addr,
                             unsigned int total_flags, unsigned int flags_or,
                             unsigned int flags_and);

        int (*set_tx_queue_params)(void *priv, int queue, int aifs, int cw_min,
                                   int cw_max, int burst_time);

        int (*if_add)(void *priv, enum wpa_driver_if_type type,
                      const char *ifname, const u8 *addr, void *bss_ctx,
                      void **drv_priv, char *force_ifname, u8 *if_addr,
                      const char *bridge, int use_existing);

        int (*if_remove)(void *priv, enum wpa_driver_if_type type,
                         const char *ifname);

        int (*set_sta_vlan)(void *priv, const u8 *addr, const char *ifname,
                            int vlan_id);

        int (*commit)(void *priv);

        int (*send_ether)(void *priv, const u8 *dst, const u8 *src, u16 proto,
                          const u8 *data, size_t data_len);

        int (*set_radius_acl_auth)(void *priv, const u8 *mac, int accepted,
                                   u32 session_timeout);

        int (*set_radius_acl_expire)(void *priv, const u8 *mac);

        int (*set_ap_wps_ie)(void *priv, const struct wpabuf *beacon,
                             const struct wpabuf *proberesp,
                             const struct wpabuf *assocresp);

        int (*set_supp_port)(void *priv, int authorized);

        int (*set_wds_sta)(void *priv, const u8 *addr, int aid, int val,
                           const char *bridge_ifname, char *ifname_wds);

        int (*send_action)(void *priv, unsigned int freq, unsigned int wait,
                           const u8 *dst, const u8 *src, const u8 *bssid,
                           const u8 *data, size_t data_len, int no_cck);

        void (*send_action_cancel_wait)(void *priv);

        int (*remain_on_channel)(void *priv, unsigned int freq,
                                 unsigned int duration);

        int (*cancel_remain_on_channel)(void *priv);

        int (*probe_req_report)(void *priv, int report);

        int (*deinit_ap)(void *priv);

        int (*deinit_p2p_cli)(void *priv);

        void (*suspend)(void *priv);

        void (*resume)(void *priv);

        int (*signal_monitor)(void *priv, int threshold, int hysteresis);

        int (*send_frame)(void *priv, const u8 *data, size_t data_len,
                          int encrypt);

        int (*get_noa)(void *priv, u8 *buf, size_t buf_len);

        int (*set_noa)(void *priv, u8 count, int start, int duration);

        int (*set_p2p_powersave)(void *priv, int legacy_ps, int opp_ps,
                                 int ctwindow);

        int (*ampdu)(void *priv, int ampdu);

        const char * (*get_radio_name)(void *priv);

        int (*send_tdls_mgmt)(void *priv, const u8 *dst, u8 action_code,
                              u8 dialog_token, u16 status_code, u32 peer_capab,
                              int initiator, const u8 *buf, size_t len);

        int (*tdls_oper)(void *priv, enum tdls_oper oper, const u8 *peer);

        int (*wnm_oper)(void *priv, enum wnm_oper oper, const u8 *peer,
                        u8 *buf, u16 *buf_len);

        int (*set_qos_map)(void *priv, const u8 *qos_map_set,
                           u8 qos_map_set_len);

        int (*br_add_ip_neigh)(void *priv, u8 version, const u8 *ipaddr,
                               int prefixlen, const u8 *addr);

        int (*br_delete_ip_neigh)(void *priv, u8 version, const u8 *ipaddr);

        int (*br_port_set_attr)(void *priv, enum drv_br_port_attr attr,
                                unsigned int val);

        int (*br_set_net_param)(void *priv, enum drv_br_net_param param,
                                unsigned int val);

        int (*set_wowlan)(void *priv, const struct wowlan_triggers *triggers);

        int (*signal_poll)(void *priv, struct wpa_signal_info *signal_info);

        int (*set_authmode)(void *priv, int authmode);

#ifdef ANDROID

        int (*driver_cmd)(void *priv, char *cmd, char *buf, size_t buf_len);
#endif /* ANDROID */

        int (*vendor_cmd)(void *priv, unsigned int vendor_id,
                          unsigned int subcmd, const u8 *data, size_t data_len,
                          struct wpabuf *buf);

        void (*set_rekey_info)(void *priv, const u8 *kek, size_t kek_len,
                               const u8 *kck, size_t kck_len,
                               const u8 *replay_ctr);

         int (*sta_assoc)(void *priv, const u8 *own_addr, const u8 *addr,
                          int reassoc, u16 status, const u8 *ie, size_t len);

         int (*sta_auth)(void *priv, const u8 *own_addr, const u8 *addr,
                         u16 seq, u16 status, const u8 *ie, size_t len);

         int (*add_tspec)(void *priv, const u8 *addr, u8 *tspec_ie,
                          size_t tspec_ielen);

        int (*add_sta_node)(void *priv, const u8 *addr, u16 auth_alg);

        int (*sched_scan)(void *priv, struct wpa_driver_scan_params *params,
                          u32 interval);

        int (*stop_sched_scan)(void *priv);

        void (*poll_client)(void *priv, const u8 *own_addr,
                            const u8 *addr, int qos);

        int (*radio_disable)(void *priv, int disabled);

        int (*switch_channel)(void *priv, struct csa_settings *settings);

        int (*add_tx_ts)(void *priv, u8 tsid, const u8 *addr, u8 user_prio,
                         u16 admitted_time);

        int (*del_tx_ts)(void *priv, u8 tsid, const u8 *addr);

        int (*tdls_enable_channel_switch)(
                void *priv, const u8 *addr, u8 oper_class,
                const struct hostapd_freq_params *params);

        int (*tdls_disable_channel_switch)(void *priv, const u8 *addr);

        int (*start_dfs_cac)(void *priv, struct hostapd_freq_params *freq);

        int (*stop_ap)(void *priv);

        int (*get_survey)(void *priv, unsigned int freq);

        int (*status)(void *priv, char *buf, size_t buflen);

        int (*roaming)(void *priv, int allowed, const u8 *bssid);

        int (*set_mac_addr)(void *priv, const u8 *addr);

#ifdef CONFIG_MACSEC
        int (*macsec_init)(void *priv, struct macsec_init_params *params);

        int (*macsec_deinit)(void *priv);

        int (*enable_protect_frames)(void *priv, Boolean enabled);

        int (*set_replay_protect)(void *priv, Boolean enabled, u32 window);

        int (*set_current_cipher_suite)(void *priv, const u8 *cs,
                                        size_t cs_len);

        int (*enable_controlled_port)(void *priv, Boolean enabled);

        int (*get_receive_lowest_pn)(void *priv, u32 channel, u8 an,
                                     u32 *lowest_pn);

        int (*get_transmit_next_pn)(void *priv, u32 channel, u8 an,
                                    u32 *next_pn);

        int (*set_transmit_next_pn)(void *priv, u32 channel, u8 an,
                                    u32 next_pn);

        int (*get_available_receive_sc)(void *priv, u32 *channel);

        int (*create_receive_sc)(void *priv, u32 channel, const u8 *sci_addr,
                                 u16 sci_port, unsigned int conf_offset,
                                 int validation);

        int (*delete_receive_sc)(void *priv, u32 channel);

        int (*create_receive_sa)(void *priv, u32 channel, u8 an,
                                 u32 lowest_pn, const u8 *sak);

        int (*enable_receive_sa)(void *priv, u32 channel, u8 an);

        int (*disable_receive_sa)(void *priv, u32 channel, u8 an);

        int (*get_available_transmit_sc)(void *priv, u32 *channel);

        int (*create_transmit_sc)(void *priv, u32 channel, const u8 *sci_addr,
                                  u16 sci_port, unsigned int conf_offset);

        int (*delete_transmit_sc)(void *priv, u32 channel);

        int (*create_transmit_sa)(void *priv, u32 channel, u8 an, u32 next_pn,
                                  Boolean confidentiality, const u8 *sak);

        int (*enable_transmit_sa)(void *priv, u32 channel, u8 an);

        int (*disable_transmit_sa)(void *priv, u32 channel, u8 an);
#endif /* CONFIG_MACSEC */

        int (*init_mesh)(void *priv);

        int (*join_mesh)(void *priv,
                         struct wpa_driver_mesh_join_params *params);

        int (*leave_mesh)(void *priv);

        int (*do_acs)(void *priv, struct drv_acs_params *params);

        int (*set_band)(void *priv, enum set_band band);

        int (*get_pref_freq_list)(void *priv, enum wpa_driver_if_type if_type,
                                  unsigned int *num, unsigned int *freq_list);

        int (*set_prob_oper_freq)(void *priv, unsigned int freq);
};


enum wpa_event_type {
        EVENT_ASSOC,

        EVENT_DISASSOC,

        EVENT_MICHAEL_MIC_FAILURE,

        EVENT_SCAN_RESULTS,

        EVENT_ASSOCINFO,

        EVENT_INTERFACE_STATUS,

        EVENT_PMKID_CANDIDATE,

        EVENT_STKSTART,

        EVENT_TDLS,

        EVENT_FT_RESPONSE,

        EVENT_IBSS_RSN_START,

        EVENT_AUTH,

        EVENT_DEAUTH,

        EVENT_ASSOC_REJECT,

        EVENT_AUTH_TIMED_OUT,

        EVENT_ASSOC_TIMED_OUT,

        EVENT_WPS_BUTTON_PUSHED,

        EVENT_TX_STATUS,

        EVENT_RX_FROM_UNKNOWN,

        EVENT_RX_MGMT,

        EVENT_REMAIN_ON_CHANNEL,

        EVENT_CANCEL_REMAIN_ON_CHANNEL,

        EVENT_RX_PROBE_REQ,

        EVENT_NEW_STA,

        EVENT_EAPOL_RX,

        EVENT_SIGNAL_CHANGE,

        EVENT_INTERFACE_ENABLED,

        EVENT_INTERFACE_DISABLED,

        EVENT_CHANNEL_LIST_CHANGED,

        EVENT_INTERFACE_UNAVAILABLE,

        EVENT_BEST_CHANNEL,

        EVENT_UNPROT_DEAUTH,

        EVENT_UNPROT_DISASSOC,

        EVENT_STATION_LOW_ACK,

        EVENT_IBSS_PEER_LOST,

        EVENT_DRIVER_GTK_REKEY,

        EVENT_SCHED_SCAN_STOPPED,

        EVENT_DRIVER_CLIENT_POLL_OK,

        EVENT_EAPOL_TX_STATUS,

        EVENT_CH_SWITCH,

        EVENT_WNM,

        EVENT_CONNECT_FAILED_REASON,

        EVENT_DFS_RADAR_DETECTED,

        EVENT_DFS_CAC_FINISHED,

        EVENT_DFS_CAC_ABORTED,

        EVENT_DFS_NOP_FINISHED,

        EVENT_SURVEY,

        EVENT_SCAN_STARTED,

        EVENT_AVOID_FREQUENCIES,

        EVENT_NEW_PEER_CANDIDATE,

        EVENT_ACS_CHANNEL_SELECTED,

        EVENT_DFS_CAC_STARTED,
};


struct freq_survey {
        u32 ifidx;
        unsigned int freq;
        s8 nf;
        u64 channel_time;
        u64 channel_time_busy;
        u64 channel_time_rx;
        u64 channel_time_tx;
        unsigned int filled;
        struct dl_list list;
};

#define SURVEY_HAS_NF BIT(0)
#define SURVEY_HAS_CHAN_TIME BIT(1)
#define SURVEY_HAS_CHAN_TIME_BUSY BIT(2)
#define SURVEY_HAS_CHAN_TIME_RX BIT(3)
#define SURVEY_HAS_CHAN_TIME_TX BIT(4)


union wpa_event_data {
        struct assoc_info {
                int reassoc;

                const u8 *req_ies;

                size_t req_ies_len;

                const u8 *resp_ies;

                size_t resp_ies_len;

                const u8 *beacon_ies;

                size_t beacon_ies_len;

                unsigned int freq;

                struct wmm_params wmm_params;

                const u8 *addr;

                int authorized;

                const u8 *key_replay_ctr;

                size_t key_replay_ctr_len;

                const u8 *ptk_kck;

                size_t ptk_kck_len;

                const u8 *ptk_kek;

                size_t ptk_kek_len;
        } assoc_info;

        struct disassoc_info {
                const u8 *addr;

                u16 reason_code;

                const u8 *ie;

                size_t ie_len;

                int locally_generated;
        } disassoc_info;

        struct deauth_info {
                const u8 *addr;

                u16 reason_code;

                const u8 *ie;

                size_t ie_len;

                int locally_generated;
        } deauth_info;

        struct michael_mic_failure {
                int unicast;
                const u8 *src;
        } michael_mic_failure;

        struct interface_status {
                char ifname[100];
                enum {
                        EVENT_INTERFACE_ADDED, EVENT_INTERFACE_REMOVED
                } ievent;
        } interface_status;

        struct pmkid_candidate {
                u8 bssid[ETH_ALEN];
                int index;
                int preauth;
        } pmkid_candidate;

        struct stkstart {
                u8 peer[ETH_ALEN];
        } stkstart;

        struct tdls {
                u8 peer[ETH_ALEN];
                enum {
                        TDLS_REQUEST_SETUP,
                        TDLS_REQUEST_TEARDOWN,
                        TDLS_REQUEST_DISCOVER,
                } oper;
                u16 reason_code; /* for teardown */
        } tdls;

        struct wnm {
                u8 addr[ETH_ALEN];
                enum {
                        WNM_OPER_SLEEP,
                } oper;
                enum {
                        WNM_SLEEP_ENTER,
                        WNM_SLEEP_EXIT
                } sleep_action;
                int sleep_intval;
                u16 reason_code;
                u8 *buf;
                u16 buf_len;
        } wnm;

        struct ft_ies {
                const u8 *ies;
                size_t ies_len;
                int ft_action;
                u8 target_ap[ETH_ALEN];
                const u8 *ric_ies;
                size_t ric_ies_len;
        } ft_ies;

        struct ibss_rsn_start {
                u8 peer[ETH_ALEN];
        } ibss_rsn_start;

        struct auth_info {
                u8 peer[ETH_ALEN];
                u8 bssid[ETH_ALEN];
                u16 auth_type;
                u16 auth_transaction;
                u16 status_code;
                const u8 *ies;
                size_t ies_len;
        } auth;

        struct assoc_reject {
                const u8 *bssid;

                const u8 *resp_ies;

                size_t resp_ies_len;

                u16 status_code;
        } assoc_reject;

        struct timeout_event {
                u8 addr[ETH_ALEN];
        } timeout_event;

        struct tx_status {
                u16 type;
                u16 stype;
                const u8 *dst;
                const u8 *data;
                size_t data_len;
                int ack;
        } tx_status;

        struct rx_from_unknown {
                const u8 *bssid;
                const u8 *addr;
                int wds;
        } rx_from_unknown;

        struct rx_mgmt {
                const u8 *frame;
                size_t frame_len;
                u32 datarate;

                void *drv_priv;

                int freq;

                int ssi_signal;
        } rx_mgmt;

        struct remain_on_channel {
                unsigned int freq;

                unsigned int duration;
        } remain_on_channel;

        struct scan_info {
                int aborted;
                const int *freqs;
                size_t num_freqs;
                struct wpa_driver_scan_ssid ssids[WPAS_MAX_SCAN_SSIDS];
                size_t num_ssids;
        } scan_info;

        struct rx_probe_req {
                const u8 *sa;

                const u8 *da;

                const u8 *bssid;

                const u8 *ie;

                size_t ie_len;

                int ssi_signal;
        } rx_probe_req;

        struct new_sta {
                const u8 *addr;
        } new_sta;

        struct eapol_rx {
                const u8 *src;
                const u8 *data;
                size_t data_len;
        } eapol_rx;

        struct wpa_signal_info signal_change;

        struct best_channel {
                int freq_24;
                int freq_5;
                int freq_overall;
        } best_chan;

        struct unprot_deauth {
                const u8 *sa;
                const u8 *da;
                u16 reason_code;
        } unprot_deauth;

        struct unprot_disassoc {
                const u8 *sa;
                const u8 *da;
                u16 reason_code;
        } unprot_disassoc;

        struct low_ack {
                u8 addr[ETH_ALEN];
        } low_ack;

        struct ibss_peer_lost {
                u8 peer[ETH_ALEN];
        } ibss_peer_lost;

        struct driver_gtk_rekey {
                const u8 *bssid;
                const u8 *replay_ctr;
        } driver_gtk_rekey;

        struct client_poll {
                u8 addr[ETH_ALEN];
        } client_poll;

        struct eapol_tx_status {
                const u8 *dst;
                const u8 *data;
                int data_len;
                int ack;
        } eapol_tx_status;

        struct ch_switch {
                int freq;
                int ht_enabled;
                int ch_offset;
                enum chan_width ch_width;
                int cf1;
                int cf2;
        } ch_switch;

        struct connect_failed_reason {
                u8 addr[ETH_ALEN];
                enum {
                        MAX_CLIENT_REACHED,
                        BLOCKED_CLIENT
                } code;
        } connect_failed_reason;

        struct dfs_event {
                int freq;
                int ht_enabled;
                int chan_offset;
                enum chan_width chan_width;
                int cf1;
                int cf2;
        } dfs_event;

        struct survey_results {
                unsigned int freq_filter;
                struct dl_list survey_list; /* struct freq_survey */
        } survey_results;

        struct channel_list_changed {
                enum reg_change_initiator initiator;
                enum reg_type type;
                char alpha2[3];
        } channel_list_changed;

        struct wpa_freq_range_list freq_range;

        struct mesh_peer {
                const u8 *peer;
                const u8 *ies;
                size_t ie_len;
        } mesh_peer;

        struct acs_selected_channels {
                u8 pri_channel;
                u8 sec_channel;
                u8 vht_seg0_center_ch;
                u8 vht_seg1_center_ch;
                u16 ch_width;
                enum hostapd_hw_mode hw_mode;
        } acs_selected_channels;
};

void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
                          union wpa_event_data *data);


/*
 * The following inline functions are provided for convenience to simplify
 * event indication for some of the common events.
 */

static inline void drv_event_assoc(void *ctx, const u8 *addr, const u8 *ie,
                                   size_t ielen, int reassoc)
{
        union wpa_event_data event;
        os_memset(&event, 0, sizeof(event));
        event.assoc_info.reassoc = reassoc;
        event.assoc_info.req_ies = ie;
        event.assoc_info.req_ies_len = ielen;
        event.assoc_info.addr = addr;
        wpa_supplicant_event(ctx, EVENT_ASSOC, &event);
}

static inline void drv_event_disassoc(void *ctx, const u8 *addr)
{
        union wpa_event_data event;
        os_memset(&event, 0, sizeof(event));
        event.disassoc_info.addr = addr;
        wpa_supplicant_event(ctx, EVENT_DISASSOC, &event);
}

static inline void drv_event_eapol_rx(void *ctx, const u8 *src, const u8 *data,
                                      size_t data_len)
{
        union wpa_event_data event;
        os_memset(&event, 0, sizeof(event));
        event.eapol_rx.src = src;
        event.eapol_rx.data = data;
        event.eapol_rx.data_len = data_len;
        wpa_supplicant_event(ctx, EVENT_EAPOL_RX, &event);
}

/* driver_common.c */
void wpa_scan_results_free(struct wpa_scan_results *res);

/* Convert wpa_event_type to a string for logging */
const char * event_to_string(enum wpa_event_type event);

/* Convert chan_width to a string for logging and control interfaces */
const char * channel_width_to_string(enum chan_width width);

int ht_supported(const struct hostapd_hw_modes *mode);
int vht_supported(const struct hostapd_hw_modes *mode);

struct wowlan_triggers *
wpa_get_wowlan_triggers(const char *wowlan_triggers,
                        const struct wpa_driver_capa *capa);

/* NULL terminated array of linked in driver wrappers */
extern const struct wpa_driver_ops *const wpa_drivers[];

#endif /* DRIVER_H */