driver.h

/*
 * Driver interface definition
 * Copyright (c) 2003-2015, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 *
 * This file defines a driver interface used by both %wpa_supplicant and
 * hostapd. The first part of the file defines data structures used in various
 * driver operations. This is followed by the struct wpa_driver_ops that each
 * driver wrapper will beed to define with callback functions for requesting
 * driver operations. After this, there are definitions for driver event
 * reporting with wpa_supplicant_event() and some convenience helper functions
 * that can be used to report events.
 */

#ifndef DRIVER_H
#define DRIVER_H

#define WPA_SUPPLICANT_DRIVER_VERSION 4

#include "common/defs.h"
#include "common/ieee802_11_defs.h"
#ifdef CONFIG_MACSEC
#include "pae/ieee802_1x_kay.h"
#endif /* CONFIG_MACSEC */
#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

#define HOSTAPD_CHAN_VHT_10_150 0x00100000
#define HOSTAPD_CHAN_VHT_30_130 0x00200000
#define HOSTAPD_CHAN_VHT_50_110 0x00400000
#define HOSTAPD_CHAN_VHT_70_90  0x00800000
#define HOSTAPD_CHAN_VHT_90_70  0x01000000
#define HOSTAPD_CHAN_VHT_110_50 0x02000000
#define HOSTAPD_CHAN_VHT_130_30 0x04000000
#define HOSTAPD_CHAN_VHT_150_10 0x08000000

/* Filter gratuitous ARP */
#define WPA_DATA_FRAME_FILTER_FLAG_ARP BIT(0)
/* Filter unsolicited Neighbor Advertisement */
#define WPA_DATA_FRAME_FILTER_FLAG_NA BIT(1)
/* Filter unicast IP packets encrypted using the GTK */
#define WPA_DATA_FRAME_FILTER_FLAG_GTK BIT(2)

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;
    u64 parent_tsf;
    u8 tsf_bssid[ETH_ALEN];
    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_ssid {
    const u8 *ssid;
    size_t ssid_len;
};

struct wpa_driver_scan_params {
    struct wpa_driver_scan_ssid 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;

    struct sched_scan_plan {
         u32 interval; /* In seconds */
         u32 iterations; /* Zero to run infinitely */
     } *sched_scan_plans;

     unsigned int sched_scan_plans_num;

    const u8 *bssid;

    u64 scan_cookie;

     u16 duration;

     unsigned int duration_mandatory:1;

    /*
     * 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 *auth_data;

    size_t auth_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;

    int pbss;

    const u8 *fils_kek;

    size_t fils_kek_len;

    const u8 *fils_nonces;

    size_t fils_nonces_len;
};

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;

    unsigned int beacon_rate;

    enum beacon_rate_type rate_type;

    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;

    int pbss;

    int multicast_to_unicast;
};

struct wpa_driver_mesh_bss_params {
#define WPA_DRIVER_MESH_CONF_FLAG_AUTO_PLINKS       0x00000001
#define WPA_DRIVER_MESH_CONF_FLAG_PEER_LINK_TIMEOUT 0x00000002
#define WPA_DRIVER_MESH_CONF_FLAG_MAX_PEER_LINKS    0x00000004
#define WPA_DRIVER_MESH_CONF_FLAG_HT_OP_MODE        0x00000008
    /*
     * TODO: Other mesh configuration parameters would go here.
     * See NL80211_MESHCONF_* for all the mesh config parameters.
     */
    unsigned int flags;
    int auto_plinks;
    int peer_link_timeout;
    int max_peer_links;
    u16 ht_opmode;
};

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 dtim_period;
    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

#define WPA_DRIVER_FLAGS_OFFCHANNEL_SIMULTANEOUS    0x0000008000000000ULL

#define WPA_DRIVER_FLAGS_FULL_AP_CLIENT_STATE   0x0000010000000000ULL

#define WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD     0x0000020000000000ULL

#define WPA_DRIVER_FLAGS_SUPPORT_FILS       0x0000040000000000ULL

#define WPA_DRIVER_FLAGS_BEACON_RATE_LEGACY 0x0000080000000000ULL

#define WPA_DRIVER_FLAGS_BEACON_RATE_HT     0x0000100000000000ULL

#define WPA_DRIVER_FLAGS_BEACON_RATE_VHT    0x0000200000000000ULL
    u64 flags;

#define FULL_AP_CLIENT_STATE_SUPP(drv_flags) \
    (drv_flags & WPA_DRIVER_FLAGS_FULL_AP_CLIENT_STATE)

#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;

    unsigned int max_sched_scan_plans;

    u32 max_sched_scan_plan_interval;

    u32 max_sched_scan_plan_iterations;

    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

#define WPA_DRIVER_FLAGS_SUPPORT_RRM            0x00000010

#define WPA_DRIVER_FLAGS_SUPPORT_SET_SCAN_DWELL     0x00000020

#define WPA_DRIVER_FLAGS_SUPPORT_BEACON_REPORT      0x00000040

    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;

    /* Maximum number of supported CSA counters */
    u16 max_csa_counters;
};


struct hostapd_data;

struct hostap_sta_driver_data {
    unsigned long rx_packets, tx_packets;
    unsigned long long rx_bytes, tx_bytes;
    int bytes_64bit; /* whether 64-bit byte counters are supported */
    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;
    u16 peer_aid;
#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;
    int support_p2p_ps;
};

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)
#define WPA_STA_ASSOCIATED BIT(6)

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[2];
    u16 counter_offset_presp[2];
};

/* 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);

    unsigned int (*get_ifindex)(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, const u16 *csa_offs,
             size_t csa_offs_len);

    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 *ctx);

    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 setup_ap);

    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);

    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 (*macsec_get_capability)(void *priv, enum macsec_cap *cap);

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

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

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

    int (*set_current_cipher_suite)(void *priv, u64 cs);

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

    int (*get_receive_lowest_pn)(void *priv, struct receive_sa *sa);

    int (*get_transmit_next_pn)(void *priv, struct transmit_sa *sa);

    int (*set_transmit_next_pn)(void *priv, struct transmit_sa *sa);

    int (*create_receive_sc)(void *priv, struct receive_sc *sc,
                 unsigned int conf_offset,
                 int validation);

    int (*delete_receive_sc)(void *priv, struct receive_sc *sc);

    int (*create_receive_sa)(void *priv, struct receive_sa *sa);

    int (*delete_receive_sa)(void *priv, struct receive_sa *sa);

    int (*enable_receive_sa)(void *priv, struct receive_sa *sa);

    int (*disable_receive_sa)(void *priv, struct receive_sa *sa);

    int (*create_transmit_sc)(void *priv, struct transmit_sc *sc,
                  unsigned int conf_offset);

    int (*delete_transmit_sc)(void *priv, struct transmit_sc *sc);

    int (*create_transmit_sa)(void *priv, struct transmit_sa *sa);

    int (*delete_transmit_sa)(void *priv, struct transmit_sa *sa);

    int (*enable_transmit_sa)(void *priv, struct transmit_sa *sa);

    int (*disable_transmit_sa)(void *priv, struct transmit_sa *sa);
#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);

    int (*abort_scan)(void *priv, u64 scan_cookie);

    int (*configure_data_frame_filters)(void *priv, u32 filter_flags);

    int (*get_ext_capab)(void *priv, enum wpa_driver_if_type type,
                 const u8 **ext_capab, const u8 **ext_capab_mask,
                 unsigned int *ext_capab_len);

    int (*p2p_lo_start)(void *priv, unsigned int freq,
                unsigned int period, unsigned int interval,
                unsigned int count,
                const u8 *device_types, size_t dev_types_len,
                const u8 *ies, size_t ies_len);

    int (*p2p_lo_stop)(void *priv);

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

    int (*set_tdls_mode)(void *priv, int tdls_external_control);
};


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,

    EVENT_P2P_LO_STOP,
};


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 *resp_frame;

        size_t resp_frame_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;

        u8 subnet_status;
    } 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 {
        unsigned int ifindex;
        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;

        int timed_out;
    } 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;
        int external_scan;
        int nl_scan_event;
        u64 scan_start_tsf;
        u8 scan_start_tsf_bssid[ETH_ALEN];
    } 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;

    struct p2p_lo_stop {
        enum {
            P2P_LO_STOPPED_REASON_COMPLETE = 0,
            P2P_LO_STOPPED_REASON_RECV_STOP_CMD,
            P2P_LO_STOPPED_REASON_INVALID_PARAM,
            P2P_LO_STOPPED_REASON_NOT_SUPPORTED,
        } reason_code;
    } p2p_lo_stop;
};

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

void wpa_supplicant_event_global(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);
/* Convert driver flag to string */
const char * driver_flag_to_string(u64 flag);

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


/* Available drivers */

#ifdef CONFIG_DRIVER_WEXT
extern const struct wpa_driver_ops wpa_driver_wext_ops; /* driver_wext.c */
#endif /* CONFIG_DRIVER_WEXT */
#ifdef CONFIG_DRIVER_NL80211
/* driver_nl80211.c */
extern const struct wpa_driver_ops wpa_driver_nl80211_ops;
#endif /* CONFIG_DRIVER_NL80211 */
#ifdef CONFIG_DRIVER_HOSTAP
extern const struct wpa_driver_ops wpa_driver_hostap_ops; /* driver_hostap.c */
#endif /* CONFIG_DRIVER_HOSTAP */
#ifdef CONFIG_DRIVER_BSD
extern const struct wpa_driver_ops wpa_driver_bsd_ops; /* driver_bsd.c */
#endif /* CONFIG_DRIVER_BSD */
#ifdef CONFIG_DRIVER_OPENBSD
/* driver_openbsd.c */
extern const struct wpa_driver_ops wpa_driver_openbsd_ops;
#endif /* CONFIG_DRIVER_OPENBSD */
#ifdef CONFIG_DRIVER_NDIS
extern struct wpa_driver_ops wpa_driver_ndis_ops; /* driver_ndis.c */
#endif /* CONFIG_DRIVER_NDIS */
#ifdef CONFIG_DRIVER_WIRED
extern const struct wpa_driver_ops wpa_driver_wired_ops; /* driver_wired.c */
#endif /* CONFIG_DRIVER_WIRED */
#ifdef CONFIG_DRIVER_MACSEC_QCA
/* driver_macsec_qca.c */
extern const struct wpa_driver_ops wpa_driver_macsec_qca_ops;
#endif /* CONFIG_DRIVER_MACSEC_QCA */
#ifdef CONFIG_DRIVER_MACSEC_LINUX
/* driver_macsec_linux.c */
extern const struct wpa_driver_ops wpa_driver_macsec_linux_ops;
#endif /* CONFIG_DRIVER_MACSEC_LINUX */
#ifdef CONFIG_DRIVER_ROBOSWITCH
/* driver_roboswitch.c */
extern const struct wpa_driver_ops wpa_driver_roboswitch_ops;
#endif /* CONFIG_DRIVER_ROBOSWITCH */
#ifdef CONFIG_DRIVER_ATHEROS
/* driver_atheros.c */
extern const struct wpa_driver_ops wpa_driver_atheros_ops;
#endif /* CONFIG_DRIVER_ATHEROS */
#ifdef CONFIG_DRIVER_NONE
extern const struct wpa_driver_ops wpa_driver_none_ops; /* driver_none.c */
#endif /* CONFIG_DRIVER_NONE */

#endif /* DRIVER_H */