wpa_supplicant/devel/wpa__supplicant__i_8h_source.html

 #ifndef WPA_SUPPLICANT_I_H

 #define WPA_SUPPLICANT_I_H


 #include "utils/list.h"

 #include "common/defs.h"

 #include "common/sae.h"

 #include "common/wpa_ctrl.h"

 #include "wps/wps_defs.h"

 #include "config_ssid.h"

 #include "wmm_ac.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;


 /*

  * 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 wpa_interface {

         const char *confname;


         const char *confanother;


         const char *ctrl_interface;


         const char *driver;


         const char *driver_param;


         const char *ifname;


         const char *bridge_ifname;


         int p2p_mgmt;

 };


 struct wpa_params {

         int daemonize;


         int wait_for_monitor;


         char *pid_file;


         int wpa_debug_level;


         int wpa_debug_show_keys;


         int wpa_debug_timestamp;


         char *ctrl_interface;


         char *ctrl_interface_group;


         int dbus_ctrl_interface;


         const char *wpa_debug_file_path;


         int wpa_debug_syslog;


         int wpa_debug_tracing;


         char *override_driver;


         char *override_ctrl_interface;


         char *entropy_file;


 #ifdef CONFIG_P2P


         char *conf_p2p_dev;

 #endif /* CONFIG_P2P */


 };


 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 {

         struct wpa_supplicant *ifaces;

         struct wpa_params params;

         struct ctrl_iface_global_priv *ctrl_iface;

         struct wpas_dbus_priv *dbus;

         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;

         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;


 #ifdef CONFIG_WIFI_DISPLAY

         int wifi_display;

 #define MAX_WFD_SUBELEMS 10

         struct wpabuf *wfd_subelem[MAX_WFD_SUBELEMS];

 #endif /* CONFIG_WIFI_DISPLAY */


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

 };


 struct wpa_radio {

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

                         * available */

         unsigned int external_scan_running:1;

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

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

 };


 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;

 };


 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_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 offchannel_send_action_result {

         OFFCHANNEL_SEND_ACTION_SUCCESS ,

         OFFCHANNEL_SEND_ACTION_NO_ACK ,

         OFFCHANNEL_SEND_ACTION_FAILED

 };


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

 };


 struct wpa_ssid_value {

         u8 ssid[SSID_MAX_LEN];

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

 };


 enum wpa_supplicant_test_failure {

         WPAS_TEST_FAILURE_NONE,

         WPAS_TEST_FAILURE_SCAN_TRIGGER,

 };


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

         struct l2_packet_data *l2;

         struct l2_packet_data *l2_br;

         unsigned char own_addr[ETH_ALEN];

         unsigned char perm_addr[ETH_ALEN];

         char ifname[100];

 #ifdef CONFIG_CTRL_IFACE_DBUS

         char *dbus_path;

 #endif /* CONFIG_CTRL_IFACE_DBUS */

 #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 */

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

         int reassoc_same_bss; /* reassociating to the same bss */

         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;


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

         int pairwise_cipher;

         int group_cipher;

         int key_mgmt;

         int wpa_proto;

         int mgmt_group_cipher;


         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;


         enum set_band setband;


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

         int first_sched_scan;

         int sched_scan_timed_out;


         void (*scan_res_handler)(struct wpa_supplicant *wpa_s,

                                  struct wpa_scan_results *scan_res);

         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;

         unsigned int last_scan_res_used;

         unsigned int last_scan_res_size;

         struct os_reltime last_scan;


         const struct wpa_driver_ops *driver;

         int interface_removed; /* whether the network interface has been

                                 * removed */

         struct wpa_sm *wpa;

         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;

         int new_connection;


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

                              * previous association event */


         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_blacklist *blacklist;


         int extra_blacklist_count;


         enum scan_req_type {

                 NORMAL_SCAN_REQ,


                 INITIAL_SCAN_REQ,


                 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 *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_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 */

 #define MAX_SCAN_ID 16

         int scan_id[MAX_SCAN_ID];

         unsigned int scan_id_count;


         struct wpa_ssid_value *ssids_from_scan_req;

         unsigned int num_ssids_from_scan_req;


         u64 drv_flags;

         unsigned int drv_enc;

         unsigned int drv_smps_modes;

         unsigned int drv_rrm_flags;


         /*

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

         int sched_scan_supported;

         unsigned int max_match_sets;

         unsigned int max_remain_on_chan;

         unsigned int max_stations;


         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;

         int blacklist_cleared;


         struct wpabuf *pending_eapol_rx;

         struct os_reltime pending_eapol_rx_time;

         u8 pending_eapol_rx_src[ETH_ALEN];

         unsigned int last_eapol_matches_bssid: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;


         struct os_reltime last_mac_addr_change;

         int last_mac_addr_style;


         struct ibss_rsn *ibss_rsn;


         int set_sta_uapsd;

         int sta_uapsd;

         int set_ap_uapsd;

         int ap_uapsd;


 #ifdef CONFIG_SME

         struct {

                 u8 ssid[SSID_MAX_LEN];

                 size_t ssid_len;

                 int freq;

                 u8 assoc_req_ie[200];

                 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;

 #ifdef CONFIG_SAE

                 struct sae_data sae;

                 struct wpabuf *sae_token;

                 int sae_group_index;

                 unsigned int sae_pmksa_caching:1;

 #endif /* CONFIG_SAE */

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

         int mesh_auth_block_duration; /* sec */

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


 #ifdef CONFIG_P2P

         struct p2p_go_neg_results *go_params;

         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;

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

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

         int pending_invite_ssid_id;

         int show_group_started;

         u8 go_dev_addr[ETH_ALEN];

         int pending_pd_before_join;

         u8 pending_join_iface_addr[ETH_ALEN];

         u8 pending_join_dev_addr[ETH_ALEN];

         int pending_join_wps_method;

         u8 p2p_join_ssid[SSID_MAX_LEN];

         size_t p2p_join_ssid_len;

         int p2p_join_scan_count;

         int auto_pd_scan_retry;

         int force_long_sd;

         u16 pending_pd_config_methods;

         enum {

                 NORMAL_PD, AUTO_PD_GO_NEG, AUTO_PD_JOIN, AUTO_PD_ASP

         } pending_pd_use;


         /*

          * Whether cross connection is disallowed by the AP to which this

          * interface is associated (only valid if there is an association).

          */

         int cross_connect_disallowed;


         /*

          * Whether this P2P group is configured to use cross connection (only

          * valid if this is P2P GO interface). The actual cross connect packet

          * forwarding may not be configured depending on the uplink status.

          */

         int cross_connect_enabled;


         /* Whether cross connection forwarding is in use at the moment. */

         int cross_connect_in_use;


         /*

          * Uplink interface name for cross connection

          */

         char cross_connect_uplink[100];


         unsigned int p2p_auto_join:1;

         unsigned int p2p_auto_pd:1;

         unsigned int p2p_persistent_group:1;

         unsigned int p2p_fallback_to_go_neg:1;

         unsigned int p2p_pd_before_go_neg:1;

         unsigned int p2p_go_ht40:1;

         unsigned int p2p_go_vht:1;

         unsigned int user_initiated_pd:1;

         unsigned int p2p_go_group_formation_completed:1;

         unsigned int group_formation_reported:1;

         unsigned int waiting_presence_resp;

         int p2p_first_connection_timeout;

         unsigned int p2p_nfc_tag_enabled:1;

         unsigned int p2p_peer_oob_pk_hash_known:1;

         unsigned int p2p_disable_ip_addr_req:1;

         unsigned int p2ps_method_config_any:1;

         unsigned int p2p_cli_probe:1;

         int p2p_persistent_go_freq;

         int p2p_persistent_id;

         int p2p_go_intent;

         int p2p_connect_freq;

         struct os_reltime p2p_auto_started;

         struct wpa_ssid *p2p_last_4way_hs_fail;

         struct wpa_radio_work *p2p_scan_work;

         struct wpa_radio_work *p2p_listen_work;

         struct wpa_radio_work *p2p_send_action_work;


         u16 p2p_oob_dev_pw_id; /* OOB Device Password Id for group formation */

         struct wpabuf *p2p_oob_dev_pw; /* OOB Device Password for group

                                         * formation */

         u8 p2p_peer_oob_pubkey_hash[WPS_OOB_PUBKEY_HASH_LEN];

         u8 p2p_ip_addr_info[3 * 4];


         /* group common frequencies */

         int *p2p_group_common_freqs;

         unsigned int p2p_group_common_freqs_num;

         u8 p2ps_join_addr[ETH_ALEN];

 #endif /* CONFIG_P2P */


         struct wpa_ssid *bgscan_ssid;

         const struct bgscan_ops *bgscan;

         void *bgscan_priv;


         const struct autoscan_ops *autoscan;

         struct wpa_driver_scan_params *autoscan_params;

         void *autoscan_priv;


         struct wpa_ssid *connect_without_scan;


         struct wps_ap_info *wps_ap;

         size_t num_wps_ap;

         int wps_ap_iter;


         int after_wps;

         int known_wps_freq;

         unsigned int wps_freq;

         int wps_fragment_size;

         int auto_reconnect_disabled;


          /* Channel preferences for AP/P2P GO use */

         int best_24_freq;

         int best_5_freq;

         int best_overall_freq;


         struct gas_query *gas;


 #ifdef CONFIG_INTERWORKING

         unsigned int fetch_anqp_in_progress:1;

         unsigned int network_select:1;

         unsigned int auto_select:1;

         unsigned int auto_network_select:1;

         unsigned int interworking_fast_assoc_tried:1;

         unsigned int fetch_all_anqp:1;

         unsigned int fetch_osu_info:1;

         unsigned int fetch_osu_waiting_scan:1;

         unsigned int fetch_osu_icon_in_progress:1;

         struct wpa_bss *interworking_gas_bss;

         unsigned int osu_icon_id;

         struct osu_provider *osu_prov;

         size_t osu_prov_count;

         struct os_reltime osu_icon_fetch_start;

         unsigned int num_osu_scans;

         unsigned int num_prov_found;

 #endif /* CONFIG_INTERWORKING */

         unsigned int drv_capa_known;


         struct {

                 struct hostapd_hw_modes *modes;

                 u16 num_modes;

                 u16 flags;

         } hw;

         enum local_hw_capab {

                 CAPAB_NO_HT_VHT,

                 CAPAB_HT,

                 CAPAB_HT40,

                 CAPAB_VHT,

         } hw_capab;

 #ifdef CONFIG_MACSEC

         struct ieee802_1x_kay *kay;

 #endif /* CONFIG_MACSEC */


         int pno;

         int pno_sched_pending;


         /* WLAN_REASON_* reason codes. Negative if locally generated. */

         int disconnect_reason;


         struct ext_password_data *ext_pw;


         struct wpabuf *last_gas_resp, *prev_gas_resp;

         u8 last_gas_addr[ETH_ALEN], prev_gas_addr[ETH_ALEN];

         u8 last_gas_dialog_token, prev_gas_dialog_token;


         unsigned int no_keep_alive:1;

         unsigned int ext_mgmt_frame_handling:1;

         unsigned int ext_eapol_frame_io:1;

         unsigned int wmm_ac_supported:1;

         unsigned int ext_work_in_progress:1;

         unsigned int own_disconnect_req:1;


 #define MAC_ADDR_RAND_SCAN       BIT(0)

 #define MAC_ADDR_RAND_SCHED_SCAN BIT(1)

 #define MAC_ADDR_RAND_PNO        BIT(2)

 #define MAC_ADDR_RAND_ALL        (MAC_ADDR_RAND_SCAN | \

                                   MAC_ADDR_RAND_SCHED_SCAN | \

                                   MAC_ADDR_RAND_PNO)

         unsigned int mac_addr_rand_supported;

         unsigned int mac_addr_rand_enable;


         /* MAC Address followed by mask (2 * ETH_ALEN) */

         u8 *mac_addr_scan;

         u8 *mac_addr_sched_scan;

         u8 *mac_addr_pno;


 #ifdef CONFIG_WNM

         u8 wnm_dialog_token;

         u8 wnm_reply;

         u8 wnm_num_neighbor_report;

         u8 wnm_mode;

         u16 wnm_dissoc_timer;

         u8 wnm_bss_termination_duration[12];

         struct neighbor_report *wnm_neighbor_report_elements;

         struct os_reltime wnm_cand_valid_until;

         u8 wnm_cand_from_bss[ETH_ALEN];

 #endif /* CONFIG_WNM */


 #ifdef CONFIG_TESTING_GET_GTK

         u8 last_gtk[32];

         size_t last_gtk_len;

 #endif /* CONFIG_TESTING_GET_GTK */


         unsigned int num_multichan_concurrent;

         struct wpa_radio_work *connect_work;


         unsigned int ext_work_id;


         struct wpabuf *vendor_elem[NUM_VENDOR_ELEM_FRAMES];


 #ifdef CONFIG_TESTING_OPTIONS

         struct l2_packet_data *l2_test;

         unsigned int extra_roc_dur;

         enum wpa_supplicant_test_failure test_failure;

 #endif /* CONFIG_TESTING_OPTIONS */


         struct wmm_ac_assoc_data *wmm_ac_assoc_info;

         struct wmm_tspec_element *tspecs[WMM_AC_NUM][TS_DIR_IDX_COUNT];

         struct wmm_ac_addts_request *addts_request;

         u8 wmm_ac_last_dialog_token;

         struct wmm_tspec_element *last_tspecs;

         u8 last_tspecs_count;


         struct rrm_data rrm;


 #ifdef CONFIG_FST

         struct fst_iface *fst;

         const struct wpabuf *fst_ies;

         struct wpabuf *received_mb_ies;

 #endif /* CONFIG_FST */

 };


 /* wpa_supplicant.c */

 void wpa_supplicant_apply_ht_overrides(

         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,

         struct wpa_driver_associate_params *params);

 void wpa_supplicant_apply_vht_overrides(

         struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,

         struct wpa_driver_associate_params *params);


 int wpa_set_wep_keys(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid);

 int wpa_supplicant_set_wpa_none_key(struct wpa_supplicant *wpa_s,

                                     struct wpa_ssid *ssid);


 int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s);


 const char * wpa_supplicant_state_txt(enum wpa_states state);

 int wpa_supplicant_update_mac_addr(struct wpa_supplicant *wpa_s);

 int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s);

 int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,

                               struct wpa_bss *bss, struct wpa_ssid *ssid,

                               u8 *wpa_ie, size_t *wpa_ie_len);

 void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,

                               struct wpa_bss *bss,

                               struct wpa_ssid *ssid);

 void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s,

                                        struct wpa_ssid *ssid);

 void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s);

 void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr);

 void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,

                                      int sec, int usec);

 void wpa_supplicant_reinit_autoscan(struct wpa_supplicant *wpa_s);

 void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,

                               enum wpa_states state);

 struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s);

 const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s);

 void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s);

 void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s,

                                    int reason_code);


 void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s,

                                    struct wpa_ssid *ssid);

 void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s,

                                     struct wpa_ssid *ssid);

 void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s,

                                    struct wpa_ssid *ssid);

 int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s,

                                            const char *pkcs11_engine_path,

                                            const char *pkcs11_module_path);

 int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s,

                                int ap_scan);

 int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s,

                                           unsigned int expire_age);

 int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s,

                                             unsigned int expire_count);

 int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s,

                                      int scan_interval);

 int wpa_supplicant_set_debug_params(struct wpa_global *global,

                                     int debug_level, int debug_timestamp,

                                     int debug_show_keys);

 void free_hw_features(struct wpa_supplicant *wpa_s);


 void wpa_show_license(void);


 struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global,

                                                  struct wpa_interface *iface,

                                                  struct wpa_supplicant *parent);

 int wpa_supplicant_remove_iface(struct wpa_global *global,

                                 struct wpa_supplicant *wpa_s,

                                 int terminate);

 struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global,

                                                  const char *ifname);

 struct wpa_global * wpa_supplicant_init(struct wpa_params *params);

 int wpa_supplicant_run(struct wpa_global *global);

 void wpa_supplicant_deinit(struct wpa_global *global);


 int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s,

                               struct wpa_ssid *ssid);

 void wpa_supplicant_terminate_proc(struct wpa_global *global);

 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,

                              const u8 *buf, size_t len);

 void wpa_supplicant_update_config(struct wpa_supplicant *wpa_s);

 void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s);

 void wpas_connection_failed(struct wpa_supplicant *wpa_s, const u8 *bssid);

 int wpas_driver_bss_selection(struct wpa_supplicant *wpa_s);

 int wpas_is_p2p_prioritized(struct wpa_supplicant *wpa_s);

 void wpas_auth_failed(struct wpa_supplicant *wpa_s, char *reason);

 void wpas_clear_temp_disabled(struct wpa_supplicant *wpa_s,

                               struct wpa_ssid *ssid, int clear_failures);

 int disallowed_bssid(struct wpa_supplicant *wpa_s, const u8 *bssid);

 int disallowed_ssid(struct wpa_supplicant *wpa_s, const u8 *ssid,

                     size_t ssid_len);

 void wpas_request_connection(struct wpa_supplicant *wpa_s);

 int wpas_build_ext_capab(struct wpa_supplicant *wpa_s, u8 *buf, size_t buflen);

 int wpas_update_random_addr(struct wpa_supplicant *wpa_s, int style);

 int wpas_update_random_addr_disassoc(struct wpa_supplicant *wpa_s);

 void add_freq(int *freqs, int *num_freqs, int freq);


 void wpas_rrm_reset(struct wpa_supplicant *wpa_s);

 void wpas_rrm_process_neighbor_rep(struct wpa_supplicant *wpa_s,

                                    const u8 *report, size_t report_len);

 int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s,

                                        const struct wpa_ssid *ssid,

                                        void (*cb)(void *ctx,

                                                   struct wpabuf *neighbor_rep),

                                        void *cb_ctx);

 void wpas_rrm_handle_link_measurement_request(struct wpa_supplicant *wpa_s,

                                               const u8 *src,

                                               const u8 *frame, size_t len,

                                               int rssi);


 int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s,

                                               struct wpa_ssid *ssid,

                                               const char *field,

                                               const char *value);


 void ibss_mesh_setup_freq(struct wpa_supplicant *wpa_s,

                           const struct wpa_ssid *ssid,

                           struct hostapd_freq_params *freq);


 /* events.c */

 void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s);

 int wpa_supplicant_connect(struct wpa_supplicant *wpa_s,

                            struct wpa_bss *selected,

                            struct wpa_ssid *ssid);

 void wpa_supplicant_stop_countermeasures(void *eloop_ctx, void *sock_ctx);

 void wpa_supplicant_delayed_mic_error_report(void *eloop_ctx, void *sock_ctx);

 void wnm_bss_keep_alive_deinit(struct wpa_supplicant *wpa_s);

 int wpa_supplicant_fast_associate(struct wpa_supplicant *wpa_s);

 struct wpa_bss * wpa_supplicant_pick_network(struct wpa_supplicant *wpa_s,

                                              struct wpa_ssid **selected_ssid);


 /* eap_register.c */

 int eap_register_methods(void);


 static inline int network_is_persistent_group(struct wpa_ssid *ssid)

 {

         return ssid->disabled == 2 && ssid->p2p_persistent_group;

 }


 int wpas_network_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid);

 int wpas_get_ssid_pmf(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid);


 int wpas_init_ext_pw(struct wpa_supplicant *wpa_s);


 void dump_freq_data(struct wpa_supplicant *wpa_s, const char *title,

                     struct wpa_used_freq_data *freqs_data,

                     unsigned int len);


 int get_shared_radio_freqs_data(struct wpa_supplicant *wpa_s,

                                 struct wpa_used_freq_data *freqs_data,

                                 unsigned int len);

 int get_shared_radio_freqs(struct wpa_supplicant *wpa_s,

                            int *freq_array, unsigned int len);


 void wpas_network_reenabled(void *eloop_ctx, void *timeout_ctx);


 #ifdef CONFIG_FST


 struct fst_wpa_obj;


 void fst_wpa_supplicant_fill_iface_obj(struct wpa_supplicant *wpa_s,

                                        struct fst_wpa_obj *iface_obj);


 #endif /* CONFIG_FST */


 #endif /* WPA_SUPPLICANT_I_H */

wpa_ssid::p2p_persistent_group
int p2p_persistent_group
Whether this is a persistent group.
Definition: config_ssid.h:580

p2p_srv_bonjour
Definition: wpa_supplicant_i.h:254

wpa_supplicant_disable_network
void wpa_supplicant_disable_network(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
Mark a configured network as disabled.
Definition: wpa_supplicant.c:2598

wpa_params::override_ctrl_interface
char * override_ctrl_interface
Optional ctrl_interface override.
Definition: wpa_supplicant_i.h:230

wpa_connect_work
Definition: wpa_supplicant_i.h:356

wpa_supplicant_rx_eapol
void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr, const u8 *buf, size_t len)
Deliver a received EAPOL frame to wpa_supplicant.
Definition: wpa_priv.c:1001

neighbor_report
Definition: wnm_sta.h:20

wpa_params::wait_for_monitor
int wait_for_monitor
Wait for a monitor program before starting.
Definition: wpa_supplicant_i.h:141

wpa_supplicant::INITIAL_SCAN_REQ
Initial scan request.
Definition: wpa_supplicant_i.h:613

wps_defs.h
Wi-Fi Protected Setup - message definitions.

ctrl_iface_global_priv
Definition: ctrl_iface_named_pipe.c:548

wpa_supplicant_get_eap_mode
const char * wpa_supplicant_get_eap_mode(struct wpa_supplicant *wpa_s)
Get the current EAP mode.
Definition: wpa_supplicant.c:4715

os_time
Definition: os.h:17

wpa_supplicant::NORMAL_SCAN_REQ
Normal scan request.
Definition: wpa_supplicant_i.h:603

wpa_supplicant::MANUAL_SCAN_REQ
Manual scan request.
Definition: wpa_supplicant_i.h:623

wpas_request_connection
void wpas_request_connection(struct wpa_supplicant *wpa_s)
Request a new connection.
Definition: wpa_supplicant.c:5491

wpa_radio_work
Radio work item.
Definition: wpa_supplicant_i.h:334

rrm_data
Definition: wpa_supplicant_i.h:417

wpa_ctrl.h
wpa_supplicant/hostapd control interface library

hostapd_iface
hostapd per-interface data structure
Definition: hostapd.h:291

wpa_interface::driver_param
const char * driver_param
Driver interface parameters.
Definition: wpa_supplicant_i.h:96

sae.h
Simultaneous authentication of equals.

wpa_external_work
Definition: wpa_supplicant_i.h:368

config_ssid.h
WPA Supplicant / Network configuration structures.

wpa_supplicant_set_bss_expiration_age
int wpa_supplicant_set_bss_expiration_age(struct wpa_supplicant *wpa_s, unsigned int expire_age)
Set BSS entry expiration age.
Definition: wpa_supplicant.c:2824

wpa_params::conf_p2p_dev
char * conf_p2p_dev
Configuration file used to hold the P2P Device configuration parameters.
Definition: wpa_supplicant_i.h:249

autoscan_ops
Definition: autoscan.h:10

wpa_supplicant_deinit
void wpa_supplicant_deinit(struct wpa_global *global)
Deinitialize wpa_supplicant.
Definition: wpa_supplicant.c:4964

wpa_params::wpa_debug_syslog
int wpa_debug_syslog
Enable log output through syslog.
Definition: wpa_supplicant_i.h:204

defs.h
WPA Supplicant - Common definitions.

wpa_driver_scan_params
Scan parameters Data for struct wpa_driver_ops::scan2().
Definition: driver.h:306

wpa_supplicant_reload_configuration
int wpa_supplicant_reload_configuration(struct wpa_supplicant *wpa_s)
Reload configuration data.
Definition: wpa_supplicant.c:877

wps_er
Definition: wps_er.h:72

wpa_params::ctrl_interface
char * ctrl_interface
Global ctrl_iface path/parameter.
Definition: wpa_supplicant_i.h:180

bgscan_ops
Definition: bgscan.h:11

wpabuf
Definition: wpabuf.h:16

wpa_supplicant_req_auth_timeout
void wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s, int sec, int usec)
Schedule a timeout for authentication.
Definition: wpa_supplicant.c:213

wpa_global
Internal, global data for all wpa_supplicant interfaces.
Definition: wpa_supplicant_i.h:273

wpa_interface::ctrl_interface
const char * ctrl_interface
Control interface parameter.
Definition: wpa_supplicant_i.h:78

wpa_interface::driver
const char * driver
Driver interface name, or NULL to use the default driver.
Definition: wpa_supplicant_i.h:84

wpa_params::override_driver
char * override_driver
Optional driver parameter override.
Definition: wpa_supplicant_i.h:220

wpa_supplicant_set_scan_interval
int wpa_supplicant_set_scan_interval(struct wpa_supplicant *wpa_s, int scan_interval)
Set scan interval.
Definition: wpa_supplicant.c:2870

wpa_supplicant_driver_init
int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s)
Initialize driver interface parameters.
Definition: wpa_supplicant.c:3276

wpa_config
wpa_supplicant configuration data
Definition: config.h:367

wpa_states
wpa_states
wpa_supplicant state
Definition: defs.h:161

wpa_supplicant_set_bss_expiration_count
int wpa_supplicant_set_bss_expiration_count(struct wpa_supplicant *wpa_s, unsigned int expire_count)
Set BSS entry expiration scan count.
Definition: wpa_supplicant.c:2847

wmm_ac_addts_request
ADDTS Request Information.
Definition: wmm_ac.h:90

wpa_supplicant_set_state
void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, enum wpa_states state)
Set current connection state.
Definition: wpa_supplicant.c:708

wpa_blacklist
Definition: blacklist.h:8

wpa_supplicant_cancel_auth_timeout
void wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
Cancel authentication timeout.
Definition: wpa_supplicant.c:235

wpa_freq_range_list
Definition: common.h:501

wpa_supplicant_get_ssid
struct wpa_ssid * wpa_supplicant_get_ssid(struct wpa_supplicant *wpa_s)
Get a pointer to the current network structure.
Definition: wpa_supplicant.c:2933

wpa_interface::bridge_ifname
const char * bridge_ifname
Optional bridge interface name.
Definition: wpa_supplicant_i.h:113

wpa_params::entropy_file
char * entropy_file
Optional entropy file.
Definition: wpa_supplicant_i.h:239

gas_query
Internal GAS query data.
Definition: gas_query.c:54

l2_packet_data
Definition: l2_packet_freebsd.c:32

ieee802_1x_kay
Definition: ieee802_1x_kay.h:88

wpa_params::wpa_debug_timestamp
int wpa_debug_timestamp
Whether to include timestamp in debug messages.
Definition: wpa_supplicant_i.h:174

os_reltime
Definition: os.h:22

list.h
Doubly-linked list.

sae_data
Definition: sae.h:40

wpa_params::wpa_debug_tracing
int wpa_debug_tracing
Enable log output through Linux tracing.
Definition: wpa_supplicant_i.h:210

p2p_data
P2P module data (internal to P2P module)
Definition: p2p_i.h:177

wpa_supplicant::extra_blacklist_count
int extra_blacklist_count
Sum of blacklist counts after last connection.
Definition: wpa_supplicant_i.h:589

hostapd_hw_modes
Supported hardware mode information.
Definition: driver.h:132

mesh_rsn
Definition: mesh_rsn.h:8

OFFCHANNEL_SEND_ACTION_SUCCESS
Definition: wpa_supplicant_i.h:379

dl_list
Doubly-linked list.
Definition: list.h:12

wpa_supplicant_associate
void wpa_supplicant_associate(struct wpa_supplicant *wpa_s, struct wpa_bss *bss, struct wpa_ssid *ssid)
Request association.
Definition: wpa_supplicant.c:1579

wpas_rrm_send_neighbor_rep_request
int wpas_rrm_send_neighbor_rep_request(struct wpa_supplicant *wpa_s, const struct wpa_ssid *ssid, void(*cb)(void *ctx, struct wpabuf *neighbor_rep), void *cb_ctx)
Request a neighbor report from our AP.
Definition: wpa_supplicant.c:5706

wpa_driver_associate_params
Association parameters Data for struct wpa_driver_ops::associate().
Definition: driver.h:578

wpa_interface::confname
const char * confname
Configuration name (file or profile) name.
Definition: wpa_supplicant_i.h:57

wpa_supplicant_scard_init
int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
Initialize SIM/USIM access with PC/SC.
Definition: events.c:381

wps_ap_info
Definition: wpa_supplicant_i.h:386

ext_password_data
Definition: ext_password.c:26

offchannel_send_action_result
offchannel_send_action_result
Result of offchannel send Action frame.
Definition: wpa_supplicant_i.h:378

wpa_interface::confanother
const char * confanother
Additional configuration name (file or profile) name.
Definition: wpa_supplicant_i.h:66

wpa_supplicant_init
struct wpa_global * wpa_supplicant_init(struct wpa_params *params)
Initialize wpa_supplicant.
Definition: wpa_supplicant.c:4798

wpa_driver_ops
Driver interface API definition.
Definition: driver.h:1746

wmm_ac_assoc_data
WMM Admission Control Association Data.
Definition: wmm_ac.h:32

wpa_supplicant_state_txt
const char * wpa_supplicant_state_txt(enum wpa_states state)
Get the connection state name as a text string.
Definition: wpa_supplicant.c:591

p2p_go_neg_results
P2P Group Owner Negotiation results.
Definition: p2p.h:85

scard_data
Definition: pcsc_funcs.c:106

wpa_bss
BSS table.
Definition: bss.h:52

wpa_interface
Parameters for wpa_supplicant_add_iface()
Definition: wpa_supplicant_i.h:48

wpa_params::pid_file
char * pid_file
Path to a PID (process ID) file.
Definition: wpa_supplicant_i.h:150

wpa_supplicant_set_debug_params
int wpa_supplicant_set_debug_params(struct wpa_global *global, int debug_level, int debug_timestamp, int debug_show_keys)
Set global debug params.
Definition: wpa_supplicant.c:2894

wpas_dbus_priv
Definition: dbus_common_i.h:12

wpa_ssid::ssid
u8 * ssid
Service set identifier (network name)
Definition: config_ssid.h:115

wmm_ac.h
Wi-Fi Multimedia Admission Control (WMM-AC) Copyright(c) 2014, Intel Mobile Communication GmbH...

radio_work_done
void radio_work_done(struct wpa_radio_work *work)
Indicate that a radio work item has been completed.
Definition: wpa_supplicant.c:4096

wpa_scan_results
Scan results.
Definition: driver.h:277

psk_list_entry
Definition: config_ssid.h:36

wpa_supplicant_ctrl_iface_ctrl_rsp_handle
int wpa_supplicant_ctrl_iface_ctrl_rsp_handle(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, const char *field, const char *value)
Handle a control response.
Definition: wpa_supplicant.c:5208

OFFCHANNEL_SEND_ACTION_NO_ACK
Definition: wpa_supplicant_i.h:380

wpa_supplicant_remove_iface
int wpa_supplicant_remove_iface(struct wpa_global *global, struct wpa_supplicant *wpa_s, int terminate)
Remove a network interface.
Definition: wpa_supplicant.c:4658

wpa_supplicant_add_iface
struct wpa_supplicant * wpa_supplicant_add_iface(struct wpa_global *global, struct wpa_interface *iface, struct wpa_supplicant *parent)
Add a new network interface.
Definition: wpa_supplicant.c:4575

wpa_params::daemonize
int daemonize
Run wpa_supplicant in the background.
Definition: wpa_supplicant_i.h:135

eap_register_methods
int eap_register_methods(void)
Register statically linked EAP methods.
Definition: eap_register.c:20

eapol_sm
Internal data for EAPOL state machines.
Definition: eapol_supp_sm.c:28

wpa_supplicant
Internal data for wpa_supplicant interface.
Definition: wpa_supplicant_i.h:451

wpa_supplicant_deauthenticate
void wpa_supplicant_deauthenticate(struct wpa_supplicant *wpa_s, int reason_code)
Deauthenticate the current connection.
Definition: wpa_supplicant.c:2484

wmm_tspec_element
Definition: ieee802_11_defs.h:957

wpa_supplicant_enable_network
void wpa_supplicant_enable_network(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
Mark a configured network as enabled.
Definition: wpa_supplicant.c:2564

osu_provider
Definition: hs20_supplicant.c:43

hostapd_freq_params
Channel parameters.
Definition: driver.h:510

wpa_supplicant_initiate_eapol
void wpa_supplicant_initiate_eapol(struct wpa_supplicant *wpa_s)
Configure EAPOL state machine.
Definition: wpa_supplicant.c:250

wpas_set_pkcs11_engine_and_module_path
int wpas_set_pkcs11_engine_and_module_path(struct wpa_supplicant *wpa_s, const char *pkcs11_engine_path, const char *pkcs11_module_path)
Set PKCS #11 engine and module path.
Definition: wpa_supplicant.c:2735

wpa_radio
Internal data for per-radio information.
Definition: wpa_supplicant_i.h:322

wpa_sm
Internal WPA state machine data.
Definition: wpa_i.h:18

p2p_group
Internal P2P module per-group data.
Definition: p2p_group.c:31

wpa_params::wpa_debug_file_path
const char * wpa_debug_file_path
Path of debug file or NULL to use stdout.
Definition: wpa_supplicant_i.h:198

wpa_clear_keys
void wpa_clear_keys(struct wpa_supplicant *wpa_s, const u8 *addr)
Clear keys configured for the driver.
Definition: wpa_supplicant.c:555

wpa_supplicant_select_network
void wpa_supplicant_select_network(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
Attempt association with a network.
Definition: wpa_supplicant.c:2651

wpa_interface::p2p_mgmt
int p2p_mgmt
Interface used for P2P management (P2P Device operations)
Definition: wpa_supplicant_i.h:123

wpa_params::ctrl_interface_group
char * ctrl_interface_group
Global ctrl_iface group.
Definition: wpa_supplicant_i.h:186

radio_add_work
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)
Add a radio work item.
Definition: wpa_supplicant.c:4056

wpa_params::wpa_debug_level
int wpa_debug_level
Debugging verbosity level (e.g., MSG_INFO)
Definition: wpa_supplicant_i.h:156

wpa_supplicant_run
int wpa_supplicant_run(struct wpa_global *global)
Run the wpa_supplicant main event loop.
Definition: wpa_supplicant.c:4933

wpa_params
Parameters for wpa_supplicant_init()
Definition: wpa_supplicant_i.h:130

wpa_supplicant_set_ap_scan
int wpa_supplicant_set_ap_scan(struct wpa_supplicant *wpa_s, int ap_scan)
Set AP scan mode for interface.
Definition: wpa_supplicant.c:2784

wpa_supplicant_set_suites
int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s, struct wpa_bss *bss, struct wpa_ssid *ssid, u8 *wpa_ie, size_t *wpa_ie_len)
Set authentication and encryption parameters.
Definition: wpa_supplicant.c:1027

wpa_ssid
Network configuration data.
Definition: config_ssid.h:52

wpa_interface::ifname
const char * ifname
Interface name.
Definition: wpa_supplicant_i.h:102

wpa_used_freq_data
Definition: wpa_supplicant_i.h:407

p2p_srv_upnp
Definition: wpa_supplicant_i.h:260

wpa_params::wpa_debug_show_keys
int wpa_debug_show_keys
Whether keying material is included in debug.
Definition: wpa_supplicant_i.h:168

OFFCHANNEL_SEND_ACTION_FAILED
Definition: wpa_supplicant_i.h:382

wpa_supplicant_set_non_wpa_policy
void wpa_supplicant_set_non_wpa_policy(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
Set WPA parameters to non-WPA mode.
Definition: wpa_supplicant.c:336

wps_context
Long term WPS context data.
Definition: wps.h:623

wpa_ssid_value
Definition: wpa_supplicant_i.h:399

wpa_params::dbus_ctrl_interface
int dbus_ctrl_interface
Enable the DBus control interface.
Definition: wpa_supplicant_i.h:192

ibss_rsn
Definition: ibss_rsn.h:42

wpa_ssid::disabled
int disabled
Whether this network is currently disabled.
Definition: config_ssid.h:402

wpa_supplicant_get_iface
struct wpa_supplicant * wpa_supplicant_get_iface(struct wpa_global *global, const char *ifname)
Get a new network interface.
Definition: wpa_supplicant.c:4738

ctrl_iface_priv
Definition: ctrl_iface_named_pipe.c:72

wpa_supplicant::scan_req_type
scan_req_type
Type of the scan request.
Definition: wpa_supplicant_i.h:595