#include "eapol_supp/eapol_supp_sm.h"
#include "eap_peer/eap.h"
#include "eap_server/eap_methods.h"
-#include "wpa.h"
+#include "rsn_supp/wpa.h"
#include "eloop.h"
#include "config.h"
#include "l2_packet/l2_packet.h"
#include "driver_i.h"
#include "ctrl_iface.h"
#include "pcsc_funcs.h"
-#include "version.h"
-#include "preauth.h"
-#include "pmksa_cache.h"
-#include "wpa_ctrl.h"
+#include "common/version.h"
+#include "rsn_supp/preauth.h"
+#include "rsn_supp/pmksa_cache.h"
+#include "common/wpa_ctrl.h"
#include "mlme.h"
-#include "ieee802_11_defs.h"
+#include "common/ieee802_11_defs.h"
#include "blacklist.h"
#include "wpas_glue.h"
#include "wps_supplicant.h"
#include "ap.h"
#include "notify.h"
#include "bgscan.h"
+#include "bss.h"
const char *wpa_supplicant_version =
"wpa_supplicant v" VERSION_STR "\n"
{
u8 key[32];
size_t keylen;
- wpa_alg alg;
+ enum wpa_alg alg;
u8 seq[6] = { 0 };
/* IBSS/WPA-None uses only one key (Group) for both receiving and
* sending unicast and multicast packets. */
- if (ssid->mode != IEEE80211_MODE_IBSS) {
+ if (ssid->mode != WPAS_MODE_IBSS) {
wpa_printf(MSG_INFO, "WPA: Invalid mode %d (not IBSS/ad-hoc) "
"for WPA-None", ssid->mode);
return -1;
struct wpa_ssid *ssid = wpa_s->current_ssid;
#ifdef CONFIG_IBSS_RSN
- if (ssid->mode == IEEE80211_MODE_IBSS &&
+ if (ssid->mode == WPAS_MODE_IBSS &&
wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
/*
wpa_s->ctrl_iface = NULL;
}
if (wpa_s->conf != NULL) {
+ struct wpa_ssid *ssid;
+ for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
+ wpas_notify_network_removed(wpa_s, ssid);
wpa_config_free(wpa_s->conf);
wpa_s->conf = NULL;
}
wpa_scan_results_free(wpa_s->scan_res);
wpa_s->scan_res = NULL;
+ wpa_bss_deinit(wpa_s);
wpa_supplicant_cancel_scan(wpa_s);
wpa_supplicant_cancel_auth_timeout(wpa_s);
* @state: State (wpa_state; WPA_*)
* Returns: The state name as a printable text string
*/
-const char * wpa_supplicant_state_txt(int state)
+const char * wpa_supplicant_state_txt(enum wpa_states state)
{
switch (state) {
case WPA_DISCONNECTED:
* This function is called whenever the connection state changes, e.g.,
* association is completed for WPA/WPA2 4-Way Handshake is started.
*/
-void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s, wpa_states state)
+void wpa_supplicant_set_state(struct wpa_supplicant *wpa_s,
+ enum wpa_states state)
{
wpa_printf(MSG_DEBUG, "State: %s -> %s",
wpa_supplicant_state_txt(wpa_s->wpa_state),
}
-static void wpa_supplicant_terminate(int sig, void *eloop_ctx,
- void *signal_ctx)
+void wpa_supplicant_terminate_proc(struct wpa_global *global)
{
- struct wpa_global *global = eloop_ctx;
+ int pending = 0;
+#ifdef CONFIG_WPS
+ struct wpa_supplicant *wpa_s = global->ifaces;
+ while (wpa_s) {
+ if (wpas_wps_terminate_pending(wpa_s) == 1)
+ pending = 1;
+ wpa_s = wpa_s->next;
+ }
+#endif /* CONFIG_WPS */
+ if (pending)
+ return;
+ eloop_terminate();
+}
+
+
+static void wpa_supplicant_terminate(int sig, void *signal_ctx)
+{
+ struct wpa_global *global = signal_ctx;
struct wpa_supplicant *wpa_s;
for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_TERMINATING "- signal %d "
"received", sig);
}
- eloop_terminate();
+ wpa_supplicant_terminate_proc(global);
}
static void wpa_supplicant_clear_status(struct wpa_supplicant *wpa_s)
{
- wpa_states old_state = wpa_s->wpa_state;
+ enum wpa_states old_state = wpa_s->wpa_state;
wpa_s->pairwise_cipher = 0;
wpa_s->group_cipher = 0;
wpa_s->mgmt_group_cipher = 0;
}
-static void wpa_supplicant_reconfig(int sig, void *eloop_ctx,
- void *signal_ctx)
+static void wpa_supplicant_reconfig(int sig, void *signal_ctx)
{
- struct wpa_global *global = eloop_ctx;
+ struct wpa_global *global = signal_ctx;
struct wpa_supplicant *wpa_s;
wpa_printf(MSG_DEBUG, "Signal %d received - reconfiguring", sig);
for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
if (wpa_supplicant_reload_configuration(wpa_s) < 0) {
- eloop_terminate();
+ wpa_supplicant_terminate_proc(global);
}
}
}
-static wpa_cipher cipher_suite2driver(int cipher)
+static enum wpa_cipher cipher_suite2driver(int cipher)
{
switch (cipher) {
case WPA_CIPHER_NONE:
}
-static wpa_key_mgmt key_mgmt2driver(int key_mgmt)
+static enum wpa_key_mgmt key_mgmt2driver(int key_mgmt)
{
switch (key_mgmt) {
case WPA_KEY_MGMT_NONE:
* available).
*/
int wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
- struct wpa_scan_res *bss,
- struct wpa_ssid *ssid,
+ struct wpa_bss *bss, struct wpa_ssid *ssid,
u8 *wpa_ie, size_t *wpa_ie_len)
{
struct wpa_ie_data ie;
const u8 *bss_wpa, *bss_rsn;
if (bss) {
- bss_wpa = wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
- bss_rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
+ bss_wpa = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
+ bss_rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
} else
bss_wpa = bss_rsn = NULL;
* This function is used to request %wpa_supplicant to associate with a BSS.
*/
void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
- struct wpa_scan_res *bss, struct wpa_ssid *ssid)
+ struct wpa_bss *bss, struct wpa_ssid *ssid)
{
u8 wpa_ie[80];
size_t wpa_ie_len;
int use_crypt, ret, i, bssid_changed;
int algs = AUTH_ALG_OPEN_SYSTEM;
- wpa_cipher cipher_pairwise, cipher_group;
+ enum wpa_cipher cipher_pairwise, cipher_group;
struct wpa_driver_associate_params params;
int wep_keys_set = 0;
struct wpa_driver_capa capa;
int assoc_failed = 0;
struct wpa_ssid *old_ssid;
- if (ssid->mode == 2) {
+ if (ssid->mode == WPAS_MODE_AP) {
#ifdef CONFIG_AP
if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_AP)) {
wpa_printf(MSG_INFO, "Driver does not support AP "
return;
}
- if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) {
+ if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
+ ssid->mode == IEEE80211_MODE_INFRA) {
sme_authenticate(wpa_s, bss, ssid);
return;
}
wpa_s->reassociate = 0;
if (bss) {
#ifdef CONFIG_IEEE80211R
- const u8 *md = NULL;
+ const u8 *ie, *md = NULL;
#endif /* CONFIG_IEEE80211R */
- const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
wpa_msg(wpa_s, MSG_INFO, "Trying to associate with " MACSTR
" (SSID='%s' freq=%d MHz)", MAC2STR(bss->bssid),
- ie ? wpa_ssid_txt(ie + 2, ie[1]) : "", bss->freq);
+ wpa_ssid_txt(bss->ssid, bss->ssid_len), bss->freq);
bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
os_memset(wpa_s->bssid, 0, ETH_ALEN);
os_memcpy(wpa_s->pending_bssid, bss->bssid, ETH_ALEN);
if (bssid_changed)
wpas_notify_bssid_changed(wpa_s);
#ifdef CONFIG_IEEE80211R
- ie = wpa_scan_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
+ ie = wpa_bss_get_ie(bss, WLAN_EID_MOBILITY_DOMAIN);
if (ie && ie[1] >= MOBILITY_DOMAIN_ID_LEN)
md = ie + 2;
wpa_sm_set_ft_params(wpa_s->wpa, md, NULL, 0, NULL);
algs);
}
- if (bss && (wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
- wpa_scan_get_ie(bss, WLAN_EID_RSN)) &&
+ if (bss && (wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
+ wpa_bss_get_ie(bss, WLAN_EID_RSN)) &&
(ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK |
WPA_KEY_MGMT_FT_IEEE8021X |
WPA_KEY_MGMT_FT_PSK |
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
os_memset(¶ms, 0, sizeof(params));
if (bss) {
- const u8 *ie = wpa_scan_get_ie(bss, WLAN_EID_SSID);
params.bssid = bss->bssid;
- params.ssid = ie ? ie + 2 : (u8 *) "";
- params.ssid_len = ie ? ie[1] : 0;
+ params.ssid = bss->ssid;
+ params.ssid_len = bss->ssid_len;
params.freq = bss->freq;
} else {
params.ssid = ssid->ssid;
params.ssid_len = ssid->ssid_len;
}
- if (ssid->mode == 1 && ssid->frequency > 0 && params.freq == 0)
+ if (ssid->mode == WPAS_MODE_IBSS && ssid->frequency > 0 &&
+ params.freq == 0)
params.freq = ssid->frequency; /* Initial channel for IBSS */
params.wpa_ie = wpa_ie;
params.wpa_ie_len = wpa_ie_len;
break;
}
if (ssid->ieee80211w != NO_IEEE80211W && bss) {
- const u8 *rsn = wpa_scan_get_ie(bss, WLAN_EID_RSN);
+ const u8 *rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
struct wpa_ie_data ie;
if (rsn && wpa_parse_wpa_ie(rsn, 2 + rsn[1], &ie) == 0 &&
ie.capabilities &
wpa_supplicant_cancel_auth_timeout(wpa_s);
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
#ifdef CONFIG_IBSS_RSN
- } else if (ssid->mode == IEEE80211_MODE_IBSS &&
+ } else if (ssid->mode == WPAS_MODE_IBSS &&
wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE) {
ibss_rsn_set_psk(wpa_s->ibss_rsn, ssid->psk);
* per-BSSID authentication.
*/
wpa_supplicant_cancel_auth_timeout(wpa_s);
- wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
#endif /* CONFIG_IBSS_RSN */
} else {
/* Timeout for IEEE 802.11 authentication and association */
if (assoc_failed) {
/* give IBSS a bit more time */
- timeout = ssid->mode ? 10 : 5;
+ timeout = ssid->mode == WPAS_MODE_IBSS ? 10 : 5;
} else if (wpa_s->conf->ap_scan == 1) {
/* give IBSS a bit more time */
- timeout = ssid->mode ? 20 : 10;
+ timeout = ssid->mode == WPAS_MODE_IBSS ? 20 : 10;
}
wpa_supplicant_req_auth_timeout(wpa_s, timeout, 0);
}
wpa_debug_timestamp = debug_timestamp ? 1 : 0;
wpa_debug_show_keys = debug_show_keys ? 1 : 0;
- if (wpa_debug_level != old_level ||
- wpa_debug_timestamp != old_timestamp ||
- wpa_debug_show_keys != old_show_keys)
- wpas_notify_debug_params_changed(global);
+ if (wpa_debug_level != old_level)
+ wpas_notify_debug_level_changed(global);
+ if (wpa_debug_timestamp != old_timestamp)
+ wpas_notify_debug_timestamp_changed(global);
+ if (wpa_debug_show_keys != old_show_keys)
+ wpas_notify_debug_show_keys_changed(global);
return 0;
}
-static void notify_bss_changes(struct wpa_supplicant *wpa_s,
- u8 (*prev_bssids)[ETH_ALEN], int prev_num,
- struct wpa_scan_results *new)
-{
- int new_num, i, j;
-
- new_num = new != NULL ? new->num : 0;
- if (prev_bssids == NULL)
- prev_num = 0;
-
- for (i = 0; i < prev_num; i++) {
- for (j = 0; j < new_num; j++) {
- if (!os_memcmp(prev_bssids[i], new->res[j]->bssid,
- ETH_ALEN))
- break;
- }
- if (j == new_num)
- wpas_notify_bss_removed(wpa_s, prev_bssids[i]);
- }
- for (i = 0; i < new_num; i++) {
- for (j = 0; j < prev_num; j++) {
- if (!os_memcmp(new->res[i]->bssid, prev_bssids[j],
- ETH_ALEN))
- break;
- }
- if (j == prev_num)
- wpas_notify_bss_added(wpa_s, new->res[i]->bssid);
- }
-}
-
-
/**
* wpa_supplicant_get_scan_results - Get scan results
* @wpa_s: Pointer to wpa_supplicant data
+ * @info: Information about what was scanned or %NULL if not available
+ * @new_scan: Whether a new scan was performed
* Returns: 0 on success, -1 on failure
*
- * This function is request the current scan results from the driver and stores
- * a local copy of the results in wpa_s->scan_res.
+ * This function request the current scan results from the driver and updates
+ * the local BSS list wpa_s->bss.
*/
-int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s)
+int wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s,
+ struct scan_info *info, int new_scan)
{
- int ret, i, prev_scan_res_num;
- u8 (*prev_scan_bssids)[ETH_ALEN];
-
- prev_scan_res_num = wpa_s->scan_res ? wpa_s->scan_res->num : 0;
- prev_scan_bssids = os_malloc(prev_scan_res_num * ETH_ALEN);
-
- if (prev_scan_bssids) {
- for (i = 0; i < prev_scan_res_num; i++) {
- os_memcpy(prev_scan_bssids[i],
- wpa_s->scan_res->res[i]->bssid, ETH_ALEN);
- }
- } else {
- wpa_printf(MSG_WARNING, "Not enough memory for old scan "
- "results list");
- prev_scan_res_num = 0;
- }
+ size_t i;
wpa_scan_results_free(wpa_s->scan_res);
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_USER_SPACE_MLME)
wpa_s->scan_res = wpa_drv_get_scan_results2(wpa_s);
if (wpa_s->scan_res == NULL) {
wpa_printf(MSG_DEBUG, "Failed to get scan results");
- ret = -1;
- } else {
- ret = 0;
- wpa_scan_sort_results(wpa_s->scan_res);
+ return -1;
}
- notify_bss_changes(wpa_s, prev_scan_bssids, prev_scan_res_num,
- wpa_s->scan_res);
- os_free(prev_scan_bssids);
+ wpa_scan_sort_results(wpa_s->scan_res);
- return ret;
+ wpa_bss_update_start(wpa_s);
+ for (i = 0; i < wpa_s->scan_res->num; i++)
+ wpa_bss_update_scan_res(wpa_s, wpa_s->scan_res->res[i]);
+ wpa_bss_update_end(wpa_s, info, new_scan);
+
+ return 0;
}
if (wpa_s->eapol_received == 0 &&
(!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE) ||
!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
- wpa_s->wpa_state != WPA_COMPLETED)) {
+ wpa_s->wpa_state != WPA_COMPLETED) &&
+ (wpa_s->current_ssid == NULL ||
+ wpa_s->current_ssid->mode != IEEE80211_MODE_IBSS)) {
/* Timeout for completing IEEE 802.1X and WPA authentication */
wpa_supplicant_req_auth_timeout(
wpa_s,
#ifdef CONFIG_IBSS_RSN
if (wpa_s->current_ssid &&
- wpa_s->current_ssid->mode == IEEE80211_MODE_IBSS) {
+ wpa_s->current_ssid->mode == WPAS_MODE_IBSS) {
ibss_rsn_rx_eapol(wpa_s->ibss_rsn, src_addr, buf, len);
return;
}
if (wpa_s == NULL)
return NULL;
wpa_s->scan_req = 1;
+ wpa_s->new_connection = 1;
return wpa_s;
}
wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);
if (wpa_s->drv_priv == NULL) {
const char *pos;
- pos = os_strchr(driver, ',');
+ pos = driver ? os_strchr(driver, ',') : NULL;
if (pos) {
wpa_printf(MSG_DEBUG, "Failed to initialize driver "
"interface - try next driver wrapper");
}
#endif /* CONFIG_IBSS_RSN */
+ if (wpa_bss_init(wpa_s) < 0)
+ return -1;
+
return 0;
}
-static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s)
+static void wpa_supplicant_deinit_iface(struct wpa_supplicant *wpa_s,
+ int notify)
{
if (wpa_s->drv_priv) {
wpa_supplicant_deauthenticate(wpa_s,
wpa_clear_keys(wpa_s, NULL);
}
- wpas_notify_iface_removed(wpa_s);
-
wpa_supplicant_cleanup(wpa_s);
+ if (notify)
+ wpas_notify_iface_removed(wpa_s);
+
if (wpa_s->drv_priv)
wpa_drv_deinit(wpa_s);
}
{
struct wpa_supplicant *wpa_s;
struct wpa_interface t_iface;
+ struct wpa_ssid *ssid;
if (global == NULL || iface == NULL)
return NULL;
if (wpa_s == NULL)
return NULL;
+ wpa_s->global = global;
+
t_iface = *iface;
if (global->params.override_driver) {
wpa_printf(MSG_DEBUG, "Override interface parameter: driver "
if (wpa_supplicant_init_iface(wpa_s, &t_iface)) {
wpa_printf(MSG_DEBUG, "Failed to add interface %s",
iface->ifname);
- wpa_supplicant_deinit_iface(wpa_s);
+ wpa_supplicant_deinit_iface(wpa_s, 0);
os_free(wpa_s);
return NULL;
}
- wpa_s->global = global;
-
/* Notify the control interfaces about new iface */
if (wpas_notify_iface_added(wpa_s)) {
- wpa_supplicant_deinit_iface(wpa_s);
+ wpa_supplicant_deinit_iface(wpa_s, 1);
os_free(wpa_s);
return NULL;
}
+ for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next)
+ wpas_notify_network_added(wpa_s, ssid);
+
wpa_s->next = global->ifaces;
global->ifaces = wpa_s;
wpa_printf(MSG_DEBUG, "Removing interface %s", wpa_s->ifname);
- wpa_supplicant_deinit_iface(wpa_s);
+ wpa_supplicant_deinit_iface(wpa_s, 1);
os_free(wpa_s);
return 0;
if (params->wpa_debug_syslog)
wpa_debug_open_syslog();
- ret = eap_peer_register_methods();
+ ret = eap_register_methods();
if (ret) {
wpa_printf(MSG_ERROR, "Failed to register EAP methods");
if (ret == -2)
return NULL;
}
-#ifdef CONFIG_AP
- ret = eap_server_register_methods();
- if (ret) {
- wpa_printf(MSG_ERROR, "Failed to register EAP server methods");
- if (ret == -2)
- wpa_printf(MSG_ERROR, "Two or more EAP methods used "
- "the same EAP type.");
- return NULL;
- }
-#endif /* CONFIG_AP */
-
global = os_zalloc(sizeof(*global));
if (global == NULL)
return NULL;
wpa_debug_timestamp = global->params.wpa_debug_timestamp =
params->wpa_debug_timestamp;
- if (eloop_init(global)) {
+ if (eloop_init()) {
wpa_printf(MSG_ERROR, "Failed to initialize event loop");
wpa_supplicant_deinit(global);
return NULL;
wpa_s->ctrl_iface);
}
- eloop_register_signal_terminate(wpa_supplicant_terminate, NULL);
- eloop_register_signal_reconfig(wpa_supplicant_reconfig, NULL);
+ eloop_register_signal_terminate(wpa_supplicant_terminate, global);
+ eloop_register_signal_reconfig(wpa_supplicant_reconfig, global);
eloop_run();
projects / mech_eap.git / blobdiff