/*

 * wpa_supplicant - Internal definitions

 * Copyright (c) 2003-2024, Jouni Malinen <j@w1.fi>

 *

 * This software may be distributed under the terms of the BSD license.

 * See README for more details.

 */

#ifndef WPA_SUPPLICANT_I_H

#define WPA_SUPPLICANT_I_H

#include "utils/bitfield.h"

#include "utils/list.h"

#include "common/defs.h"

#include "common/sae.h"

#include "common/wpa_ctrl.h"

#include "common/dpp.h"

#include "crypto/sha384.h"

#include "eapol_supp/eapol_supp_sm.h"

#include "wps/wps_defs.h"

#include "config_ssid.h"

#include "wmm_ac.h"

#include "pasn/pasn_common.h"

extern const char *const wpa_supplicant_version;

extern const char *const wpa_supplicant_license;

#ifndef CONFIG_NO_STDOUT_DEBUG

extern const char *const wpa_supplicant_full_license1;

extern const char *const wpa_supplicant_full_license2;

extern const char *const wpa_supplicant_full_license3;

extern const char *const wpa_supplicant_full_license4;

extern const char *const wpa_supplicant_full_license5;

#endif /* CONFIG_NO_STDOUT_DEBUG */

struct wpa_sm;

struct wpa_supplicant;

struct ibss_rsn;

struct scan_info;

struct wpa_bss;

struct wpa_scan_results;

struct hostapd_hw_modes;

struct wpa_driver_associate_params;

struct wpa_cred;

/*

 * Forward declarations of private structures used within the ctrl_iface

 * backends. Other parts of wpa_supplicant do not have access to data stored in

 * these structures.

 */

struct ctrl_iface_priv;

struct ctrl_iface_global_priv;

struct wpas_dbus_priv;

struct wpas_binder_priv;

/**

 * struct wpa_interface - Parameters for wpa_supplicant_add_iface()

 */

struct wpa_interface {

  /**

   * confname - Configuration name (file or profile) name

   *

   * This can also be %NULL when a configuration file is not used. In

   * that case, ctrl_interface must be set to allow the interface to be

   * configured.

   */

  const char *confname;

  /**

   * confanother - Additional configuration name (file or profile) name

   *

   * This can also be %NULL when the additional configuration file is not

   * used.

   */

  const char *confanother;

  /**

   * ctrl_interface - Control interface parameter

   *

   * If a configuration file is not used, this variable can be used to

   * set the ctrl_interface parameter that would have otherwise been read

   * from the configuration file. If both confname and ctrl_interface are

   * set, ctrl_interface is used to override the value from configuration

   * file.

   */

  const char *ctrl_interface;

  /**

   * driver - Driver interface name, or %NULL to use the default driver

   */

  const char *driver;

  /**

   * driver_param - Driver interface parameters

   *

   * If a configuration file is not used, this variable can be used to

   * set the driver_param parameters that would have otherwise been read

   * from the configuration file. If both confname and driver_param are

   * set, driver_param is used to override the value from configuration

   * file.

   */

  const char *driver_param;

  /**

   * ifname - Interface name

   */

  const char *ifname;

  /**

   * bridge_ifname - Optional bridge interface name

   *

   * If the driver interface (ifname) is included in a Linux bridge

   * device, the bridge interface may need to be used for receiving EAPOL

   * frames. This can be enabled by setting this variable to enable

   * receiving of EAPOL frames from an additional interface.

   */

  const char *bridge_ifname;

  /**

   * p2p_mgmt - Interface used for P2P management (P2P Device operations)

   *

   * Indicates whether wpas_p2p_init() must be called for this interface.

   * This is used only when the driver supports a dedicated P2P Device

   * interface that is not a network interface.

   */

  int p2p_mgmt;

#ifdef CONFIG_MATCH_IFACE

  /**

   * matched - Interface was matched rather than specified

   *

   */

  enum {

    WPA_IFACE_NOT_MATCHED,

    WPA_IFACE_MATCHED_NULL,

    WPA_IFACE_MATCHED

  } matched;

#endif /* CONFIG_MATCH_IFACE */

};

/**

 * struct wpa_params - Parameters for wpa_supplicant_init()

 */

struct wpa_params {

  /**

   * daemonize - Run %wpa_supplicant in the background

   */

  int daemonize;

  /**

   * wait_for_monitor - Wait for a monitor program before starting

   */

  int wait_for_monitor;

  /**

   * pid_file - Path to a PID (process ID) file

   *

   * If this and daemonize are set, process ID of the background process

   * will be written to the specified file.

   */

  char *pid_file;

  /**

   * wpa_debug_level - Debugging verbosity level (e.g., MSG_INFO)

   */

  int wpa_debug_level;

  /**

   * wpa_debug_show_keys - Whether keying material is included in debug

   *

   * This parameter can be used to allow keying material to be included

   * in debug messages. This is a security risk and this option should

   * not be enabled in normal configuration. If needed during

   * development or while troubleshooting, this option can provide more

   * details for figuring out what is happening.

   */

  int wpa_debug_show_keys;

  /**

   * wpa_debug_timestamp - Whether to include timestamp in debug messages

   */

  int wpa_debug_timestamp;

  /**

   * ctrl_interface - Global ctrl_iface path/parameter

   */

  char *ctrl_interface;

  /**

   * ctrl_interface_group - Global ctrl_iface group

   */

  char *ctrl_interface_group;

  /**

   * dbus_ctrl_interface - Enable the DBus control interface

   */

  int dbus_ctrl_interface;

  /**

   * wpa_debug_file_path - Path of debug file or %NULL to use stdout

   */

  const char *wpa_debug_file_path;

  /**

   * wpa_debug_syslog - Enable log output through syslog

   */

  int wpa_debug_syslog;

  /**

   * wpa_debug_tracing - Enable log output through Linux tracing

   */

  int wpa_debug_tracing;

  /**

   * override_driver - Optional driver parameter override

   *

   * This parameter can be used to override the driver parameter in

   * dynamic interface addition to force a specific driver wrapper to be

   * used instead.

   */

  char *override_driver;

  /**

   * override_ctrl_interface - Optional ctrl_interface override

   *

   * This parameter can be used to override the ctrl_interface parameter

   * in dynamic interface addition to force a control interface to be

   * created.

   */

  char *override_ctrl_interface;

  /**

   * entropy_file - Optional entropy file

   *

   * This parameter can be used to configure wpa_supplicant to maintain

   * its internal entropy store over restarts.

   */

  char *entropy_file;

#ifdef CONFIG_P2P

  /**

   * conf_p2p_dev - Configuration file used to hold the

   * P2P Device configuration parameters.

   *

   * This can also be %NULL. In such a case, if a P2P Device dedicated

   * interfaces is created, the main configuration file will be used.

   */

  char *conf_p2p_dev;

#endif /* CONFIG_P2P */

#ifdef CONFIG_MATCH_IFACE

  /**

   * match_ifaces - Interface descriptions to match

   */

  struct wpa_interface *match_ifaces;

  /**

   * match_iface_count - Number of defined matching interfaces

   */

  int match_iface_count;

#endif /* CONFIG_MATCH_IFACE */

  /**

   * show_details - Whether to show config parsing details in debug log

   */

  bool show_details;

};

struct p2p_srv_bonjour {

  struct dl_list list;

  struct wpabuf *query;

  struct wpabuf *resp;

};

struct p2p_srv_upnp {

  struct dl_list list;

  u8 version;

  char *service;

};

/**

 * struct wpa_global - Internal, global data for all %wpa_supplicant interfaces

 *

 * This structure is initialized by calling wpa_supplicant_init() when starting

 * %wpa_supplicant.

 */

struct wpa_global {

  struct wpa_supplicant *ifaces;

  struct wpa_params params;

  struct ctrl_iface_global_priv *ctrl_iface;

  struct wpas_dbus_priv *dbus;

  struct wpas_binder_priv *binder;

  void **drv_priv;

  size_t drv_count;

  struct os_time suspend_time;

  struct p2p_data *p2p;

  struct wpa_supplicant *p2p_init_wpa_s;

  struct wpa_supplicant *p2p_group_formation;

  struct wpa_supplicant *p2p_invite_group;

  u8 p2p_dev_addr[ETH_ALEN];

  struct os_reltime p2p_go_wait_client;

  struct dl_list p2p_srv_bonjour; /* struct p2p_srv_bonjour */

  struct dl_list p2p_srv_upnp; /* struct p2p_srv_upnp */

  int p2p_disabled;

  int cross_connection;

  int p2p_long_listen; /* remaining time in long Listen state in ms */

  struct wpa_freq_range_list p2p_disallow_freq;

  struct wpa_freq_range_list p2p_go_avoid_freq;

  enum wpa_conc_pref {

    WPA_CONC_PREF_NOT_SET,

    WPA_CONC_PREF_STA,

    WPA_CONC_PREF_P2P

  } conc_pref;

  unsigned int p2p_per_sta_psk:1;

  unsigned int p2p_fail_on_wps_complete:1;

  unsigned int p2p_24ghz_social_channels:1;

  unsigned int pending_p2ps_group:1;

  unsigned int pending_group_iface_for_p2ps:1;

  unsigned int pending_p2ps_group_freq;

#ifdef CONFIG_WIFI_DISPLAY

  int wifi_display;

#define MAX_WFD_SUBELEMS 12

  struct wpabuf *wfd_subelem[MAX_WFD_SUBELEMS];

#endif /* CONFIG_WIFI_DISPLAY */

  struct psk_list_entry *add_psk; /* From group formation */

};

/**

 * struct wpa_radio - Internal data for per-radio information

 *

 * This structure is used to share data about configured interfaces

 * (struct wpa_supplicant) that share the same physical radio, e.g., to allow

 * better coordination of offchannel operations.

 */

struct wpa_radio {

  char name[16]; /* from driver_ops get_radio_name() or empty if not

      * available */

  /** NULL if no external scan running. */

  struct wpa_supplicant *external_scan_req_interface;

  unsigned int num_active_works;

  struct dl_list ifaces; /* struct wpa_supplicant::radio_list entries */

  struct dl_list work; /* struct wpa_radio_work::list entries */

};

/**

 * Checks whether an external scan is running on a given radio.

 * @radio: Pointer to radio struct

 * Returns: true if an external scan is running, false otherwise.

 */

static inline bool external_scan_running(struct wpa_radio *radio)

{

  return radio && radio->external_scan_req_interface;

}

Unexecuted instantiation: bssid_ignore.c:external_scan_running

Unexecuted instantiation: bss.c:external_scan_running

Unexecuted instantiation: eap_register.c:external_scan_running

Unexecuted instantiation: events.c:external_scan_running

Unexecuted instantiation: gas_query.c:external_scan_running

Unexecuted instantiation: hs20_supplicant.c:external_scan_running

Unexecuted instantiation: interworking.c:external_scan_running

Unexecuted instantiation: notify.c:external_scan_running

Unexecuted instantiation: offchannel.c:external_scan_running

Unexecuted instantiation: op_classes.c:external_scan_running

Unexecuted instantiation: robust_av.c:external_scan_running

Unexecuted instantiation: rrm.c:external_scan_running

Unexecuted instantiation: scan.c:external_scan_running

Unexecuted instantiation: wmm_ac.c:external_scan_running

Unexecuted instantiation: wnm_sta.c:external_scan_running

Unexecuted instantiation: wpa_supplicant.c:external_scan_running

Unexecuted instantiation: wpas_glue.c:external_scan_running

Unexecuted instantiation: wnm.c:external_scan_running

#define MAX_ACTIVE_WORKS 2

/**

 * struct wpa_radio_work - Radio work item

 */

struct wpa_radio_work {

  struct dl_list list;

  unsigned int freq; /* known frequency (MHz) or 0 for multiple/unknown */

  const char *type;

  struct wpa_supplicant *wpa_s;

  void (*cb)(struct wpa_radio_work *work, int deinit);

  void *ctx;

  unsigned int started:1;

  struct os_reltime time;

  unsigned int bands;

};

int radio_add_work(struct wpa_supplicant *wpa_s, unsigned int freq,

       const char *type, int next,

       void (*cb)(struct wpa_radio_work *work, int deinit),

       void *ctx);

void radio_work_done(struct wpa_radio_work *work);

void radio_remove_works(struct wpa_supplicant *wpa_s,

      const char *type, int remove_all);

void radio_remove_pending_work(struct wpa_supplicant *wpa_s, void *ctx);

void radio_work_check_next(struct wpa_supplicant *wpa_s);

struct wpa_radio_work *

radio_work_pending(struct wpa_supplicant *wpa_s, const char *type);

struct wpa_connect_work {

  unsigned int sme:1;

  unsigned int bss_removed:1;

  struct wpa_bss *bss;

  struct wpa_ssid *ssid;

};

int wpas_valid_bss_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *test_bss,

      struct wpa_ssid *test_ssid);

void wpas_connect_work_free(struct wpa_connect_work *cwork);

void wpas_connect_work_done(struct wpa_supplicant *wpa_s);

struct wpa_external_work {

  unsigned int id;

  char type[100];

  unsigned int timeout;

};

enum wpa_radio_work_band wpas_freq_to_band(int freq);

unsigned int wpas_get_bands(struct wpa_supplicant *wpa_s, const int *freqs);

/**

 * offchannel_send_action_result - Result of offchannel send Action frame

 */

enum offchannel_send_action_result {

  OFFCHANNEL_SEND_ACTION_SUCCESS /**< Frame was send and acknowledged */,

  OFFCHANNEL_SEND_ACTION_NO_ACK /**< Frame was sent, but not acknowledged

               */,

  OFFCHANNEL_SEND_ACTION_FAILED /**< Frame was not sent due to a failure

               */

};

struct wps_ap_info {

  u8 bssid[ETH_ALEN];

  enum wps_ap_info_type {

    WPS_AP_NOT_SEL_REG,

    WPS_AP_SEL_REG,

    WPS_AP_SEL_REG_OUR

  } type;

  unsigned int tries;

  struct os_reltime last_attempt;

  unsigned int pbc_active;

  u8 uuid[WPS_UUID_LEN];

};

#define WPA_FREQ_USED_BY_INFRA_STATION BIT(0)

#define WPA_FREQ_USED_BY_P2P_CLIENT BIT(1)

struct wpa_used_freq_data {

  int freq;

  unsigned int flags;

};

#define RRM_NEIGHBOR_REPORT_TIMEOUT 1 /* 1 second for AP to send a report */

/*

 * struct rrm_data - Data used for managing RRM features

 */

struct rrm_data {

  /* rrm_used - indication regarding the current connection */

  unsigned int rrm_used:1;

  /*

   * notify_neighbor_rep - Callback for notifying report requester

   */

  void (*notify_neighbor_rep)(void *ctx, struct wpabuf *neighbor_rep);

  /*

   * neighbor_rep_cb_ctx - Callback context

   * Received in the callback registration, and sent to the callback

   * function as a parameter.

   */

  void *neighbor_rep_cb_ctx;

  /* next_neighbor_rep_token - Next request's dialog token */

  u8 next_neighbor_rep_token;

  /* token - Dialog token of the current radio measurement */

  u8 token;

  /* destination address of the current radio measurement request */

  u8 dst_addr[ETH_ALEN];

};

enum wpa_supplicant_test_failure {

  WPAS_TEST_FAILURE_NONE,

  WPAS_TEST_FAILURE_SCAN_TRIGGER,

};

struct wpa_bss_tmp_disallowed {

  struct dl_list list;

  u8 bssid[ETH_ALEN];

  int rssi_threshold;

};

struct beacon_rep_data {

  u8 token;

  u8 last_indication;

  struct wpa_driver_scan_params scan_params;

  u8 ssid[SSID_MAX_LEN];

  size_t ssid_len;

  u8 bssid[ETH_ALEN];

  enum beacon_report_detail report_detail;

  struct bitfield *eids;

  struct bitfield *ext_eids;

};

struct external_pmksa_cache {

  struct dl_list list;

  void *pmksa_cache;

};

struct fils_hlp_req {

  struct dl_list list;

  u8 dst[ETH_ALEN];

  struct wpabuf *pkt;

};

struct driver_signal_override {

  struct dl_list list;

  u8 bssid[ETH_ALEN];

  int si_current_signal;

  int si_avg_signal;

  int si_avg_beacon_signal;

  int si_current_noise;

  int scan_level;

};

struct robust_av_data {

  u8 dialog_token;

  enum scs_request_type request_type;

  u8 up_bitmap;

  u8 up_limit;

  u32 stream_timeout;

  u8 frame_classifier[48];

  size_t frame_classifier_len;

  bool valid_config;

};

struct dscp_policy_status {

  u8 id;

  u8 status;

};

struct dscp_resp_data {

  bool more;

  bool reset;

  bool solicited;

  struct dscp_policy_status *policy;

  int num_policies;

};

enum ip_version {

  IPV4 = 4,

  IPV6 = 6,

};

struct ipv4_params {

  struct in_addr src_ip;

  struct in_addr dst_ip;

  u16 src_port;

  u16 dst_port;

  u8 dscp;

  u8 protocol;

};

struct ipv6_params {

  struct in6_addr src_ip;

  struct in6_addr dst_ip;

  u16 src_port;

  u16 dst_port;

  u8 dscp;

  u8 next_header;

  u8 flow_label[3];

};

struct type4_params {

  u8 classifier_mask;

  enum ip_version ip_version;

  union {

    struct ipv4_params v4;

    struct ipv6_params v6;

  } ip_params;

};

struct type10_params {

  u8 prot_instance;

  u8 prot_number;

  u8 *filter_value;

  u8 *filter_mask;

  size_t filter_len;

};

struct tclas_element {

  u8 user_priority;

  u8 classifier_type;

  union {

    struct type4_params type4_param;

    struct type10_params type10_param;

  } frame_classifier;

};

struct qos_characteristics {

  bool available;

  /* Control Info Direction */

  u8 direction;

  /* Presence Bitmap Of Additional Parameters */

  u16 mask;

  /* Minimum Service Interval */

  u32 min_si;

  /* Maximum Service Interval */

  u32 max_si;

  /* Minimum Data Rate */

  u32 min_data_rate;

  /* Delay Bound */

  u32 delay_bound;

  /* Maximum MSDU Size */

  u16 max_msdu_size;

  /* Service Start Time */

  u32 service_start_time;

  /* Service Start Time LinkID */

  u8 service_start_time_link_id;

  /* Mean Data Rate */

  u32 mean_data_rate;

  /* Delayed Bounded Burst Size */

  u32 burst_size;

  /* MSDU Lifetime */

  u16 msdu_lifetime;

  /* MSDU Delivery Info */

  u8 msdu_delivery_info;

  /* Medium Time */

  u16 medium_time;

};

struct scs_desc_elem {

  u8 scs_id;

  enum scs_request_type request_type;

  u8 intra_access_priority;

  bool scs_up_avail;

  struct tclas_element *tclas_elems;

  unsigned int num_tclas_elem;

  u8 tclas_processing;

  struct qos_characteristics qos_char_elem;

};

struct scs_robust_av_data {

  struct scs_desc_elem *scs_desc_elems;

  unsigned int num_scs_desc;

};

enum scs_response_status {

  SCS_DESC_SENT = 0,

  SCS_DESC_SUCCESS = 1,

};

struct active_scs_elem {

  struct dl_list list;

  u8 scs_id;

  enum scs_response_status status;

  struct scs_desc_elem desc_elem;

};

struct ml_sta_link_info {

  u8 link_id;

  u8 bssid[ETH_ALEN];

  u16 status;

};

enum local_hw_capab {

  CAPAB_HT,

  CAPAB_VHT,

  CAPAB_HE,

  CAPAB_EHT,

};

struct last_scan_ssid {

  u8 ssid[SSID_MAX_LEN];

  size_t ssid_len;

};

/**

 * struct wpa_supplicant - Internal data for wpa_supplicant interface

 *

 * This structure contains the internal data for core wpa_supplicant code. This

 * should be only used directly from the core code. However, a pointer to this

 * data is used from other files as an arbitrary context pointer in calls to

 * core functions.

 */

struct wpa_supplicant {

  struct wpa_global *global;

  struct wpa_radio *radio; /* shared radio context */

  struct dl_list radio_list; /* list head: struct wpa_radio::ifaces */

  struct wpa_supplicant *parent;

  struct wpa_supplicant *p2pdev;

  struct wpa_supplicant *next;

  struct l2_packet_data *l2;

  struct l2_packet_data *l2_br;

  struct os_reltime roam_start;

  struct os_reltime roam_time;

  struct os_reltime session_start;

  struct os_reltime session_length;

  unsigned char own_addr[ETH_ALEN];

  unsigned char perm_addr[ETH_ALEN];

  char ifname[100];

#ifdef CONFIG_MATCH_IFACE

  int matched;

#endif /* CONFIG_MATCH_IFACE */

#ifdef CONFIG_CTRL_IFACE_DBUS_NEW

  char *dbus_new_path;

  char *dbus_groupobj_path;

#ifdef CONFIG_AP

  char *preq_notify_peer;

#endif /* CONFIG_AP */

#endif /* CONFIG_CTRL_IFACE_DBUS_NEW */

#ifdef CONFIG_CTRL_IFACE_BINDER

  const void *binder_object_key;

#endif /* CONFIG_CTRL_IFACE_BINDER */

  char bridge_ifname[16];

  char *confname;

  char *confanother;

  struct wpa_config *conf;

  int countermeasures;

  struct os_reltime last_michael_mic_error;

  u8 bssid[ETH_ALEN];

  u8 pending_bssid[ETH_ALEN]; /* If wpa_state == WPA_ASSOCIATING, this

             * field contains the target BSSID. */

  int reassociate; /* reassociation requested */

  bool roam_in_progress; /* roam in progress */

  unsigned int reassoc_same_bss:1; /* reassociating to the same BSS */

  unsigned int reassoc_same_ess:1; /* reassociating to the same ESS */

  int disconnected; /* all connections disabled; i.e., do no reassociate

         * before this has been cleared */

  struct wpa_ssid *current_ssid;

  struct wpa_ssid *last_ssid;

  struct wpa_bss *current_bss;

  int ap_ies_from_associnfo;

  unsigned int assoc_freq;

  u8 ap_mld_addr[ETH_ALEN];

  u8 mlo_assoc_link_id;

  u16 valid_links; /* bitmap of valid MLO link IDs */

  struct {

    u8 addr[ETH_ALEN];

    u8 bssid[ETH_ALEN];

    unsigned int freq;

    struct wpa_bss *bss;

    bool disabled;

    struct wpabuf *ies;

  } links[MAX_NUM_MLD_LINKS];

  u8 *last_con_fail_realm;

  size_t last_con_fail_realm_len;

  bool sta_roaming_disabled;

  /* Selected configuration (based on Beacon/ProbeResp WPA IE) */

  int pairwise_cipher;

  int deny_ptk0_rekey;

  int group_cipher;

  int key_mgmt;

  int wpa_proto;

  int mgmt_group_cipher;

  /*

   * Allowed key management suites for roaming/initial connection

   * when the driver's SME is in use.

   */

  int allowed_key_mgmts;

  void *drv_priv; /* private data used by driver_ops */

  void *global_drv_priv;

  u8 *bssid_filter;

  size_t bssid_filter_count;

  u8 *disallow_aps_bssid;

  size_t disallow_aps_bssid_count;

  struct wpa_ssid_value *disallow_aps_ssid;

  size_t disallow_aps_ssid_count;

  u32 setband_mask;

  /* Preferred network for the next connection attempt */

  struct wpa_ssid *next_ssid;

  /* previous scan was wildcard when interleaving between

   * wildcard scans and specific SSID scan when max_ssids=1 */

  int prev_scan_wildcard;

  struct wpa_ssid *prev_scan_ssid; /* previously scanned SSID;

            * NULL = not yet initialized (start

            * with wildcard SSID)

            * WILDCARD_SSID_SCAN = wildcard

            * SSID was used in the previous scan

            */

#define WILDCARD_SSID_SCAN ((struct wpa_ssid *) 1)

  struct wpa_ssid *prev_sched_ssid; /* last SSID used in sched scan */

  int sched_scan_timeout;

  int first_sched_scan;

  int sched_scan_timed_out;

  struct sched_scan_plan *sched_scan_plans;

  size_t sched_scan_plans_num;

  void (*scan_res_handler)(struct wpa_supplicant *wpa_s,

         struct wpa_scan_results *scan_res);

  void (*scan_res_fail_handler)(struct wpa_supplicant *wpa_s);

  struct dl_list bss; /* struct wpa_bss::list */

  struct dl_list bss_id; /* struct wpa_bss::list_id */

  size_t num_bss;

  unsigned int bss_update_idx;

  unsigned int bss_next_id;

   /*

    * Pointers to BSS entries in the order they were in the last scan

    * results.

    */

  struct wpa_bss **last_scan_res;

  size_t last_scan_res_used;

  size_t last_scan_res_size;

  struct os_reltime last_scan;

  bool last_scan_external;

  struct last_scan_ssid last_scan_ssids[WPAS_MAX_SCAN_SSIDS];

  size_t last_scan_num_ssids;

  const struct wpa_driver_ops *driver;

  int interface_removed; /* whether the network interface has been

        * removed */

  struct wpa_sm *wpa;

  struct ptksa_cache *ptksa;

  struct eapol_sm *eapol;

  struct ctrl_iface_priv *ctrl_iface;

  enum wpa_states wpa_state;

  struct wpa_radio_work *scan_work;

  int scanning;

  int sched_scanning;

  unsigned int sched_scan_stop_req:1;

  int new_connection;

  int eapol_received; /* number of EAPOL packets received after the

           * previous association event */

  u8 rsnxe[257];

  size_t rsnxe_len;

  struct scard_data *scard;

  char imsi[20];

  int mnc_len;

  unsigned char last_eapol_src[ETH_ALEN];

  unsigned int keys_cleared; /* bitfield of key indexes that the driver is

            * known not to be configured with a key */

  struct wpa_bssid_ignore *bssid_ignore;

  /* Number of connection failures since last successful connection */

  unsigned int consecutive_conn_failures;

  /**

   * scan_req - Type of the scan request

   */

  enum scan_req_type {

    /**

     * NORMAL_SCAN_REQ - Normal scan request

     *

     * This is used for scans initiated by wpa_supplicant to find an

     * AP for a connection.

     */

    NORMAL_SCAN_REQ,

    /**

     * INITIAL_SCAN_REQ - Initial scan request

     *

     * This is used for the first scan on an interface to force at

     * least one scan to be run even if the configuration does not

     * include any enabled networks.

     */

    INITIAL_SCAN_REQ,

    /**

     * MANUAL_SCAN_REQ - Manual scan request

     *

     * This is used for scans where the user request a scan or

     * a specific wpa_supplicant operation (e.g., WPS) requires scan

     * to be run.

     */

    MANUAL_SCAN_REQ

  } scan_req, last_scan_req;

  enum wpa_states scan_prev_wpa_state;

  struct os_reltime scan_trigger_time, scan_start_time;

  /* Minimum freshness requirement for connection purposes */

  struct os_reltime scan_min_time;

  int scan_runs; /* number of scan runs since WPS was started */

  int *next_scan_freqs;

  int *select_network_scan_freqs;

  int *manual_scan_freqs;

  int *manual_sched_scan_freqs;

  unsigned int manual_scan_passive:1;

  unsigned int manual_scan_use_id:1;

  unsigned int manual_scan_only_new:1;

  unsigned int own_scan_requested:1;

  unsigned int own_scan_running:1;

  unsigned int clear_driver_scan_cache:1;

  unsigned int manual_non_coloc_6ghz:1;

  unsigned int manual_scan_id;

  int scan_interval; /* time in sec between scans to find suitable AP */

  int normal_scans; /* normal scans run before sched_scan */

  int scan_for_connection; /* whether the scan request was triggered for

          * finding a connection */

  /*

   * A unique cookie representing the vendor scan request. This cookie is

   * returned from the driver interface. 0 indicates that there is no

   * pending vendor scan request.

   */

  u64 curr_scan_cookie;

#define MAX_SCAN_ID 16

  int scan_id[MAX_SCAN_ID];

  unsigned int scan_id_count;

  u8 next_scan_bssid[ETH_ALEN];

  unsigned int next_scan_bssid_wildcard_ssid:1;

  struct wpa_ssid_value *ssids_from_scan_req;

  unsigned int num_ssids_from_scan_req;

  int *last_scan_freqs;

  unsigned int num_last_scan_freqs;

  unsigned int suitable_network;

  unsigned int no_suitable_network;

  u8 ml_probe_bssid[ETH_ALEN];

  int ml_probe_mld_id;

  u16 ml_probe_links;

  u64 drv_flags;

  u64 drv_flags2;

  unsigned int drv_enc;

  unsigned int drv_key_mgmt;

  unsigned int drv_rrm_flags;

  unsigned int drv_max_acl_mac_addrs;

  size_t drv_max_probe_req_ie_len;

  /*

   * A bitmap of supported protocols for probe response offload. See

   * struct wpa_driver_capa in driver.h

   */

  unsigned int probe_resp_offloads;

  /* extended capabilities supported by the driver */

  const u8 *extended_capa, *extended_capa_mask;

  unsigned int extended_capa_len;

  int max_scan_ssids;

  int max_sched_scan_ssids;

  unsigned int max_sched_scan_plans;

  unsigned int max_sched_scan_plan_interval;

  unsigned int max_sched_scan_plan_iterations;

  int sched_scan_supported;

  unsigned int max_match_sets;

  unsigned int max_remain_on_chan;

  unsigned int max_stations;

  unsigned int max_num_akms;

  int pending_mic_error_report;

  int pending_mic_error_pairwise;

  int mic_errors_seen; /* Michael MIC errors with the current PTK */

  struct wps_context *wps;

  int wps_success; /* WPS success event received */

  struct wps_er *wps_er;

  unsigned int wps_run;

  struct os_reltime wps_pin_start_time;

  bool bssid_ignore_cleared;

  struct wpabuf *pending_eapol_rx;

  struct os_reltime pending_eapol_rx_time;

  u8 pending_eapol_rx_src[ETH_ALEN];

  enum frame_encryption pending_eapol_encrypted;

  unsigned int last_eapol_matches_bssid:1;

  unsigned int eapol_failed:1;

  unsigned int eap_expected_failure:1;

  unsigned int reattach:1; /* reassociation to the same BSS requested */

  unsigned int mac_addr_changed:1;

  unsigned int added_vif:1;

  unsigned int wnmsleep_used:1;

  unsigned int owe_transition_select:1;

  unsigned int owe_transition_search:1;

  unsigned int connection_set:1;

  unsigned int connection_ht:1;

  unsigned int connection_vht:1;

  unsigned int connection_he:1;

  unsigned int connection_eht:1;

  unsigned int disable_mbo_oce:1;

  struct os_reltime last_mac_addr_change;

  enum wpas_mac_addr_style last_mac_addr_style;

  struct ibss_rsn *ibss_rsn;

  int set_sta_uapsd;

  int sta_uapsd;

  int set_ap_uapsd;

  int ap_uapsd;

  int auth_alg;

  u16 last_owe_group;

#ifdef CONFIG_SME

  struct {

    u8 ssid[SSID_MAX_LEN];

    size_t ssid_len;

    int freq;

    u8 assoc_req_ie[1500];

    size_t assoc_req_ie_len;

    int mfp;

    int ft_used;

    u8 mobility_domain[2];

    u8 *ft_ies;

    size_t ft_ies_len;

    u8 prev_bssid[ETH_ALEN];

    int prev_bssid_set;

    int auth_alg;

    int proto;

    int sa_query_count; /* number of pending SA Query requests;

             * 0 = no SA Query in progress */

    int sa_query_timed_out;

    u8 *sa_query_trans_id; /* buffer of WLAN_SA_QUERY_TR_ID_LEN *

          * sa_query_count octets of pending

          * SA Query transaction identifiers */

    struct os_reltime sa_query_start;

    struct os_reltime last_unprot_disconnect;

    enum { HT_SEC_CHAN_UNKNOWN,

           HT_SEC_CHAN_ABOVE,

           HT_SEC_CHAN_BELOW } ht_sec_chan;

    u8 sched_obss_scan;

    u16 obss_scan_int;

    u16 bss_max_idle_period;

    bool spp_amsdu;

#ifdef CONFIG_SAE

    struct sae_data sae;

    struct wpabuf *sae_token;

    int sae_group_index;

    unsigned int sae_pmksa_caching:1;

    u16 seq_num;

    u8 ext_auth_bssid[ETH_ALEN];

    struct wpa_ssid *ext_auth_wpa_ssid;

    u8 ext_auth_ssid[SSID_MAX_LEN];

    size_t ext_auth_ssid_len;

    int ext_auth_key_mgmt;

    u8 ext_auth_ap_mld_addr[ETH_ALEN];

    bool ext_ml_auth;

    int *sae_rejected_groups;

#endif /* CONFIG_SAE */

    u16 assoc_auth_type;

  } sme;

#endif /* CONFIG_SME */

#ifdef CONFIG_AP

  struct hostapd_iface *ap_iface;

  void (*ap_configured_cb)(void *ctx, void *data);

  void *ap_configured_cb_ctx;

  void *ap_configured_cb_data;

#endif /* CONFIG_AP */

  struct hostapd_iface *ifmsh;

#ifdef CONFIG_MESH

  struct mesh_rsn *mesh_rsn;

  int mesh_if_idx;

  unsigned int mesh_if_created:1;

  unsigned int mesh_ht_enabled:1;

  unsigned int mesh_vht_enabled:1;

  unsigned int mesh_he_enabled:1;

  unsigned int mesh_eht_enabled:1;

  struct wpa_driver_mesh_join_params *mesh_params;

#ifdef CONFIG_PMKSA_CACHE_EXTERNAL

  /* struct external_pmksa_cache::list */

  struct dl_list mesh_external_pmksa_cache;

#endif /* CONFIG_PMKSA_CACHE_EXTERNAL */

#endif /* CONFIG_MESH */

  unsigned int off_channel_freq;

  struct wpabuf *pending_action_tx;

  u8 pending_action_src[ETH_ALEN];

  u8 pending_action_dst[ETH_ALEN];

  u8 pending_action_bssid[ETH_ALEN];

  unsigned int pending_action_freq;

  int pending_action_no_cck;

  int pending_action_without_roc;

  unsigned int pending_action_tx_done:1;

  void (*pending_action_tx_status_cb)(struct wpa_supplicant *wpa_s,

              unsigned int freq, const u8 *dst,

              const u8 *src, const u8 *bssid,

              const u8 *data, size_t data_len,

              enum offchannel_send_action_result

              result);

  unsigned int roc_waiting_drv_freq;

  int action_tx_wait_time;

  int action_tx_wait_time_used;

  int p2p_mgmt;

#ifdef CONFIG_P2P

  struct p2p_go_neg_results *go_params;

  struct rsn_pmksa_cache_entry *p2p_pmksa_entry;

  int create_p2p_iface;

  u8 pending_interface_addr[ETH_ALEN];

  char pending_interface_name[100];

  int pending_interface_type;

  int p2p_group_idx;

  unsigned int pending_listen_freq;

  unsigned int pending_listen_duration;

  enum {

    NOT_P2P_GROUP_INTERFACE,

    P2P_GROUP_INTERFACE_PENDING,

    P2P_GROUP_INTERFACE_GO,

    P2P_GROUP_INTERFACE_CLIENT

  } p2p_group_interface;

  struct p2p_group *p2p_group;

  char p2p_pin[10];

  int p2p_wps_method;

  u8 p2p_auth_invite[ETH_ALEN];

  int p2p_sd_over_ctrl_iface;

  int p2p_in_provisioning;

  int p2p_in_invitation;

  int p2p_retry_limit;

  int p2p_invite_go_freq;

  bool p2p_pairing_setup;

  bool p2p_pairing_cache;

  int pending_invite_ssid_id;

  int show_group_started;