hapd->drv_priv, ie, len);
}
-static inline int hostapd_driver_set_mode(struct hostapd_data *hapd, int mode)
-{
- if (hapd->driver == NULL || hapd->driver->set_mode == NULL)
- return 0;
- return hapd->driver->set_mode(hapd->drv_priv, mode);
-}
-
static inline int hostapd_driver_scan(struct hostapd_data *hapd,
struct wpa_driver_scan_params *params)
{
iface->bss[i]->drv_priv = hapd->drv_priv;
}
- if (hostapd_driver_set_mode(hapd, IEEE80211_MODE_AP)) {
- wpa_printf(MSG_ERROR, "Failed to set driver in AP mode");
- return -1;
- }
-
if (hostapd_validate_bssid_configuration(iface))
return -1;
enum privsep_cmd {
PRIVSEP_CMD_REGISTER,
PRIVSEP_CMD_UNREGISTER,
- PRIVSEP_CMD_SET_WPA,
PRIVSEP_CMD_SCAN,
PRIVSEP_CMD_GET_SCAN_RESULTS,
PRIVSEP_CMD_ASSOCIATE,
PRIVSEP_CMD_L2_UNREGISTER,
PRIVSEP_CMD_L2_NOTIFY_AUTH_START,
PRIVSEP_CMD_L2_SEND,
- PRIVSEP_CMD_SET_MODE,
PRIVSEP_CMD_SET_COUNTRY,
};
int (*get_ssid)(void *priv, u8 *ssid);
/**
- * set_wpa - Enable/disable WPA support (OBSOLETE)
- * @priv: private driver interface data
- * @enabled: 1 = enable, 0 = disable
- *
- * Returns: 0 on success, -1 on failure
- *
- * Note: This function is included for backwards compatibility. This is
- * called only just after init and just before deinit, so these
- * functions can be used to implement same functionality and the driver
- * interface need not define this function.
- *
- * Configure the kernel driver to enable/disable WPA support. This may
- * be empty function, if WPA support is always enabled. Common
- * configuration items are WPA IE (clearing it when WPA support is
- * disabled), Privacy flag configuration for capability field (note:
- * this the value need to set in associate handler to allow plaintext
- * mode to be used) when trying to associate with, roaming mode (can
- * allow wpa_supplicant to control roaming if ap_scan=1 is used;
- * however, drivers can also implement roaming if desired, especially
- * ap_scan=2 mode is used for this).
- */
- int (*set_wpa)(void *priv, int enabled);
-
- /**
* set_key - Configure encryption key
* @ifname: Interface name (for multi-SSID/VLAN support)
* @priv: private driver interface data
int (*set_countermeasures)(void *priv, int enabled);
/**
- * set_drop_unencrypted - Enable/disable unencrypted frame filtering
- * @priv: private driver interface data
- * @enabled: 1 = unencrypted Tx/Rx frames will be dropped, 0 = disabled
- *
- * Returns: 0 on success, -1 on failure
- *
- * Configure the driver to drop all non-EAPOL frames (both receive and
- * transmit paths). Unencrypted EAPOL frames (ethertype 0x888e) must
- * still be allowed for key negotiation.
- *
- * This function is deprecated. New driver wrapper implementations
- * should use associate() parameter drop_unencrypted instead.
- */
- int (*set_drop_unencrypted)(void *priv, int enabled);
-
- /**
* scan - Request the driver to initiate scan (old version)
* @priv: private driver interface data
* @ssid: specific SSID to scan for (ProbeReq) or %NULL to scan for
struct wpa_driver_associate_params *params);
/**
- * set_auth_alg - Set IEEE 802.11 authentication algorithm
- * @priv: private driver interface data
- * @auth_alg: bit field of AUTH_ALG_*
- *
- * If the driver supports more than one authentication algorithm at the
- * same time, it should configure all supported algorithms. If not, one
- * algorithm needs to be selected arbitrarily. Open System
- * authentication should be ok for most cases and it is recommended to
- * be used if other options are not supported. Static WEP configuration
- * may also use Shared Key authentication and LEAP requires its own
- * algorithm number. For LEAP, user can make sure that only one
- * algorithm is used at a time by configuring LEAP as the only
- * supported EAP method. This information is also available in
- * associate() params, so set_auth_alg may not be needed in case of
- * most drivers.
- *
- * This function is deprecated. New driver wrapper implementations
- * should use associate() parameter auth_alg instead.
- *
- * Returns: 0 on success, -1 on failure
- */
- int (*set_auth_alg)(void *priv, int auth_alg);
-
- /**
* add_pmkid - Add PMKSA cache entry to the driver
* @priv: private driver interface data
* @bssid: BSSID for the PMKSA cache entry
*/
int (*set_probe_req_ie)(void *priv, const u8 *ies, size_t ies_len);
- /**
- * set_mode - Request driver to set the operating mode
- * @priv: private driver interface data
- * @mode: Operation mode (infra/ibss) IEEE80211_MODE_*
- *
- * This handler will be called before any key configuration and call to
- * associate() handler in order to allow the operation mode to be
- * configured as early as possible. This information is also available
- * in associate() params and as such, driver wrappers may not need
- * to implement set_mode() handler.
- *
- * This function is deprecated. New driver wrapper implementations
- * should use associate() parameter mode instead.
- *
- * Returns: 0 on success, -1 on failure
- */
- int (*set_mode)(void *priv, int mode);
-
/**
* set_country - Set country
* @priv: Private driver interface data
}
-static int wpa_driver_atmel_set_drop_unencrypted(void *priv,
- int enabled)
-{
- /* FIX */
- printf("wpa_driver_atmel_set_drop_unencrypted - not yet "
- "implemented\n");
- return 0;
-}
-
-
static int wpa_driver_atmel_mlme(void *priv, const u8 *addr, int cmd,
int reason_code)
{
return NULL;
}
+ wpa_driver_atmel_set_wpa(drv, 1);
+
return drv;
}
static void wpa_driver_atmel_deinit(void *priv)
{
struct wpa_driver_atmel_data *drv = priv;
+ wpa_driver_atmel_set_wpa(drv, 0);
wpa_driver_wext_deinit(drv->wext);
close(drv->sock);
os_free(drv);
.desc = "ATMEL AT76C5XXx (USB, PCMCIA)",
.get_bssid = wpa_driver_atmel_get_bssid,
.get_ssid = wpa_driver_atmel_get_ssid,
- .set_wpa = wpa_driver_atmel_set_wpa,
.set_key = wpa_driver_atmel_set_key,
.init = wpa_driver_atmel_init,
.deinit = wpa_driver_atmel_deinit,
.set_countermeasures = wpa_driver_atmel_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_atmel_set_drop_unencrypted,
.scan = wpa_driver_atmel_scan,
.get_scan_results2 = wpa_driver_atmel_get_scan_results,
.deauthenticate = wpa_driver_atmel_deauthenticate,
eloop_register_read_sock(s, wpa_driver_broadcom_event_receive, ctx,
NULL);
drv->event_sock = s;
+ wpa_driver_broadcom_set_wpa(drv, 1);
return drv;
}
static void wpa_driver_broadcom_deinit(void *priv)
{
struct wpa_driver_broadcom_data *drv = priv;
+ wpa_driver_broadcom_set_wpa(drv, 0);
eloop_cancel_timeout(wpa_driver_broadcom_scan_timeout, drv, drv->ctx);
eloop_unregister_read_sock(drv->event_sock);
close(drv->event_sock);
int wsec = 4;
int dummy;
int wpa_auth;
-
+ int ret;
+
+ ret = wpa_driver_broadcom_set_drop_unencrypted(
+ drv, params->drop_unencrypted);
+
s.SSID_len = params->ssid_len;
os_memcpy(s.SSID, params->ssid, params->ssid_len);
broadcom_ioctl(drv, WLC_SET_SSID, &s, sizeof(s)) < 0)
return -1;
- return 0;
+ return ret;
}
const struct wpa_driver_ops wpa_driver_broadcom_ops = {
.desc = "Broadcom wl.o driver",
.get_bssid = wpa_driver_broadcom_get_bssid,
.get_ssid = wpa_driver_broadcom_get_ssid,
- .set_wpa = wpa_driver_broadcom_set_wpa,
.set_key = wpa_driver_broadcom_set_key,
.init = wpa_driver_broadcom_init,
.deinit = wpa_driver_broadcom_deinit,
.set_countermeasures = wpa_driver_broadcom_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_broadcom_set_drop_unencrypted,
.scan = wpa_driver_broadcom_scan,
.get_scan_results = wpa_driver_broadcom_get_scan_results,
.deauthenticate = wpa_driver_broadcom_deauthenticate,
struct wpa_driver_bsd_data *drv = priv;
struct ieee80211req_mlme mlme;
int privacy;
+ int ret = 0;
wpa_printf(MSG_DEBUG,
"%s: ssid '%.*s' wpa ie len %u pairwise %u group %u key mgmt %u"
, params->key_mgmt_suite
);
+ if (wpa_driver_bsd_set_drop_unencrypted(drv, params->drop_unencrypted)
+ < 0)
+ ret = -1;
+ if (wpa_driver_bsd_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
/* XXX error handling is wrong but unclear what to do... */
if (wpa_driver_bsd_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0)
return -1;
os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN);
if (set80211var(drv, IEEE80211_IOC_MLME, &mlme, sizeof(mlme)) < 0)
return -1;
- return 0;
+ return ret;
}
static int
goto fail;
}
+ wpa_driver_bsd_set_wpa(drv, 1);
+
return drv;
fail:
close(drv->sock);
struct wpa_driver_bsd_data *drv = priv;
int flags;
+ wpa_driver_bsd_set_wpa(drv, 0);
eloop_unregister_read_sock(drv->route);
/* NB: mark interface down */
.deinit = wpa_driver_bsd_deinit,
.get_bssid = wpa_driver_bsd_get_bssid,
.get_ssid = wpa_driver_bsd_get_ssid,
- .set_wpa = wpa_driver_bsd_set_wpa,
.set_key = wpa_driver_bsd_set_key,
.set_countermeasures = wpa_driver_bsd_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_bsd_set_drop_unencrypted,
.scan = wpa_driver_bsd_scan,
.get_scan_results2 = wpa_driver_bsd_get_scan_results2,
.deauthenticate = wpa_driver_bsd_deauthenticate,
.disassociate = wpa_driver_bsd_disassociate,
.associate = wpa_driver_bsd_associate,
- .set_auth_alg = wpa_driver_bsd_set_auth_alg,
};
#endif /* HOSTAPD */
};
+static int wpa_driver_hostap_set_auth_alg(void *priv, int auth_alg);
+
+
static int hostapd_ioctl(struct wpa_driver_hostap_data *drv,
struct prism2_hostapd_param *param,
int len, int show_err)
}
-static int wpa_driver_hostap_set_drop_unencrypted(void *priv, int enabled)
-{
- struct wpa_driver_hostap_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
- return prism2param(drv, PRISM2_PARAM_DROP_UNENCRYPTED, enabled);
-}
-
-
static int wpa_driver_hostap_reset(struct wpa_driver_hostap_data *drv,
int type)
{
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
+ if (prism2param(drv, PRISM2_PARAM_DROP_UNENCRYPTED,
+ params->drop_unencrypted) < 0)
+ ret = -1;
+ if (wpa_driver_hostap_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
if (params->mode != drv->current_mode) {
/* At the moment, Host AP driver requires host_roaming=2 for
* infrastructure mode and host_roaming=0 for adhoc. */
wpa_driver_wext_alternative_ifindex(drv->wext, ifname2);
}
+ wpa_driver_hostap_set_wpa(drv, 1);
+
return drv;
}
static void wpa_driver_hostap_deinit(void *priv)
{
struct wpa_driver_hostap_data *drv = priv;
+ wpa_driver_hostap_set_wpa(drv, 0);
wpa_driver_wext_deinit(drv->wext);
close(drv->sock);
os_free(drv);
#else /* HOSTAPD */
.get_bssid = wpa_driver_hostap_get_bssid,
.get_ssid = wpa_driver_hostap_get_ssid,
- .set_wpa = wpa_driver_hostap_set_wpa,
.set_countermeasures = wpa_driver_hostap_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_hostap_set_drop_unencrypted,
.scan = wpa_driver_hostap_scan,
.get_scan_results2 = wpa_driver_hostap_get_scan_results,
.deauthenticate = wpa_driver_hostap_deauthenticate,
.disassociate = wpa_driver_hostap_disassociate,
.associate = wpa_driver_hostap_associate,
- .set_auth_alg = wpa_driver_hostap_set_auth_alg,
.init = wpa_driver_hostap_init,
.deinit = wpa_driver_hostap_deinit,
.set_operstate = wpa_driver_hostap_set_operstate,
/* end of ipw2100.c and ipw2200.c code */
+static int wpa_driver_ipw_set_auth_alg(void *priv, int auth_alg);
+
static int ipw_ioctl(struct wpa_driver_ipw_data *drv,
struct ipw_param *param, int len, int show_err)
{
int ret = 0;
int unencrypted_eapol;
+ if (wpa_driver_ipw_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
+ if (wpa_driver_ipw_set_drop_unencrypted(drv, params->drop_unencrypted)
+ < 0)
+ ret = -1;
if (ipw_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len) < 0)
ret = -1;
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
return NULL;
}
+ wpa_driver_ipw_set_wpa(drv, 1);
+
return drv;
}
static void wpa_driver_ipw_deinit(void *priv)
{
struct wpa_driver_ipw_data *drv = priv;
+ wpa_driver_ipw_set_wpa(drv, 0);
wpa_driver_wext_deinit(drv->wext);
close(drv->sock);
os_free(drv);
"or newer)",
.get_bssid = wpa_driver_ipw_get_bssid,
.get_ssid = wpa_driver_ipw_get_ssid,
- .set_wpa = wpa_driver_ipw_set_wpa,
.set_key = wpa_driver_ipw_set_key,
.set_countermeasures = wpa_driver_ipw_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_ipw_set_drop_unencrypted,
.scan = wpa_driver_ipw_scan,
.get_scan_results2 = wpa_driver_ipw_get_scan_results,
.deauthenticate = wpa_driver_ipw_deauthenticate,
.disassociate = wpa_driver_ipw_disassociate,
.associate = wpa_driver_ipw_associate,
- .set_auth_alg = wpa_driver_ipw_set_auth_alg,
.init = wpa_driver_ipw_init,
.deinit = wpa_driver_ipw_deinit,
.set_operstate = wpa_driver_ipw_set_operstate,
int sock;
};
+static int wpa_driver_madwifi_set_auth_alg(void *priv, int auth_alg);
+
+
static int
set80211priv(struct wpa_driver_madwifi_data *drv, int op, void *data, int len,
int show_err)
return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled, 1);
}
-
-static int
-wpa_driver_madwifi_set_drop_unencrypted(void *priv, int enabled)
-{
- struct wpa_driver_madwifi_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
- return set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED, enabled, 1);
-}
-
static int
wpa_driver_madwifi_deauthenticate(void *priv, const u8 *addr, int reason_code)
{
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
+ if (set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED,
+ params->drop_unencrypted, 1) < 0)
+ ret = -1;
+ if (wpa_driver_madwifi_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
+
/*
* NB: Don't need to set the freq or cipher-related state as
* this is implied by the bssid which is used to locate
.init = wpa_driver_madwifi_init,
.deinit = wpa_driver_madwifi_deinit,
.set_countermeasures = wpa_driver_madwifi_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_madwifi_set_drop_unencrypted,
.scan = wpa_driver_madwifi_scan,
.get_scan_results2 = wpa_driver_madwifi_get_scan_results,
.deauthenticate = wpa_driver_madwifi_deauthenticate,
.disassociate = wpa_driver_madwifi_disassociate,
.associate = wpa_driver_madwifi_associate,
- .set_auth_alg = wpa_driver_madwifi_set_auth_alg,
.set_operstate = wpa_driver_madwifi_set_operstate,
.set_probe_req_ie = wpa_driver_madwifi_set_probe_req_ie,
#endif /* HOSTAPD */
}
-static int wpa_driver_ndis_set_wpa(void *priv, int enabled)
-{
- wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
- return 0;
-}
-
-
static void wpa_driver_ndis_scan_timeout(void *eloop_ctx, void *timeout_ctx)
{
wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
"Windows NDIS driver",
wpa_driver_ndis_get_bssid,
wpa_driver_ndis_get_ssid,
- wpa_driver_ndis_set_wpa,
wpa_driver_ndis_set_key,
wpa_driver_ndis_init,
wpa_driver_ndis_deinit,
NULL /* set_param */,
NULL /* set_countermeasures */,
- NULL /* set_drop_unencrypted */,
wpa_driver_ndis_scan,
NULL /* get_scan_results */,
wpa_driver_ndis_deauthenticate,
wpa_driver_ndis_disassociate,
wpa_driver_ndis_associate,
- NULL /* set_auth_alg */,
wpa_driver_ndis_add_pmkid,
wpa_driver_ndis_remove_pmkid,
wpa_driver_ndis_flush_pmkid,
NULL /* send_ft_action */,
wpa_driver_ndis_get_scan_results,
NULL /* set_probe_req_ie */,
- NULL /* set_mode */,
NULL /* set_country */,
NULL /* global_init */,
NULL /* global_deinit */,
#define WPA_DEINIT SIOCIWFIRSTPRIV+10
#define WPA_GET_CAPA SIOCIWFIRSTPRIV+11
+static int wpa_ndiswrapper_set_auth_alg(void *priv, int auth_alg);
+
static int get_socket(void)
{
static const int families[] = {
struct wpa_assoc_info wpa_assoc_info;
struct iwreq priv_req;
+ if (wpa_ndiswrapper_set_drop_unencrypted(drv,
+ params->drop_unencrypted) < 0)
+ ret = -1;
+ if (wpa_ndiswrapper_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
+
os_memset(&priv_req, 0, sizeof(priv_req));
os_memset(&wpa_assoc_info, 0, sizeof(wpa_assoc_info));
return NULL;
}
+ wpa_ndiswrapper_set_wpa(drv, 1);
+
return drv;
}
static void wpa_ndiswrapper_deinit(void *priv)
{
struct wpa_driver_ndiswrapper_data *drv = priv;
+ wpa_ndiswrapper_set_wpa(drv, 0);
wpa_driver_wext_deinit(drv->wext);
close(drv->sock);
os_free(drv);
const struct wpa_driver_ops wpa_driver_ndiswrapper_ops = {
.name = "ndiswrapper",
.desc = "Linux ndiswrapper (deprecated; use wext)",
- .set_wpa = wpa_ndiswrapper_set_wpa,
.set_key = wpa_ndiswrapper_set_key,
.set_countermeasures = wpa_ndiswrapper_set_countermeasures,
- .set_drop_unencrypted = wpa_ndiswrapper_set_drop_unencrypted,
.deauthenticate = wpa_ndiswrapper_deauthenticate,
.disassociate = wpa_ndiswrapper_disassociate,
.associate = wpa_ndiswrapper_associate,
- .set_auth_alg = wpa_ndiswrapper_set_auth_alg,
.get_bssid = wpa_ndiswrapper_get_bssid,
.get_ssid = wpa_ndiswrapper_get_ssid,
drv->associated = 0;
+ if (wpa_driver_nl80211_set_mode(drv, IEEE80211_MODE_INFRA) < 0)
+ return -1;
+
retry:
msg = nlmsg_alloc();
if (!msg)
return wpa_driver_nl80211_ap(drv, params);
#endif /* CONFIG_AP */
- if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME))
+ if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
+ if (wpa_driver_nl80211_set_mode(drv, params->mode) < 0)
+ return -1;
return wpa_driver_nl80211_connect(drv, params);
+ }
drv->associated = 0;
goto failed;
}
- if (nl80211_set_mode(drv, drv->ifindex, NL80211_IFTYPE_AP)) {
+ if (wpa_driver_nl80211_set_mode(drv, IEEE80211_MODE_AP)) {
wpa_printf(MSG_ERROR, "nl80211: Failed to set interface %s "
"into AP mode", drv->ifname);
goto failed;
.set_operstate = wpa_driver_nl80211_set_operstate,
.set_supp_port = wpa_driver_nl80211_set_supp_port,
.set_country = wpa_driver_nl80211_set_country,
- .set_mode = wpa_driver_nl80211_set_mode,
.set_beacon = wpa_driver_nl80211_set_beacon,
#if defined(CONFIG_AP) || defined(HOSTAPD)
.send_mlme = wpa_driver_nl80211_send_mlme,
struct wpa_driver_prism54_data *drv = priv;
int ret = 0;
+ if (wpa_driver_prism54_set_drop_unencrypted(drv,
+ params->drop_unencrypted)
+ < 0)
+ ret = -1;
if (wpa_driver_prism54_set_wpa_ie(drv, params->wpa_ie,
params->wpa_ie_len) < 0)
ret = -1;
return NULL;
}
+ wpa_driver_prism54_set_wpa(drv, 1);
+
return drv;
}
static void wpa_driver_prism54_deinit(void *priv)
{
struct wpa_driver_prism54_data *drv = priv;
+ wpa_driver_prism54_set_wpa(drv, 0);
wpa_driver_wext_deinit(drv->wext);
close(drv->sock);
os_free(drv);
#else /* HOSTAPD */
.get_bssid = wpa_driver_prism54_get_bssid,
.get_ssid = wpa_driver_prism54_get_ssid,
- .set_wpa = wpa_driver_prism54_set_wpa,
.set_countermeasures = wpa_driver_prism54_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_prism54_set_drop_unencrypted,
.scan = wpa_driver_prism54_scan,
.get_scan_results2 = wpa_driver_prism54_get_scan_results,
.deauthenticate = wpa_driver_prism54_deauthenticate,
}
-static int wpa_driver_privsep_set_wpa(void *priv, int enabled)
-{
- struct wpa_driver_privsep_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
- return wpa_priv_cmd(drv, PRIVSEP_CMD_SET_WPA, &enabled,
- sizeof(enabled), NULL, NULL);
-}
-
-
static int wpa_driver_privsep_scan(void *priv, const u8 *ssid, size_t ssid_len)
{
struct wpa_driver_privsep_data *drv = priv;
}
-static int wpa_driver_privsep_set_mode(void *priv, int mode)
-{
- struct wpa_driver_privsep_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s mode=%d", __func__, mode);
- return wpa_priv_cmd(drv, PRIVSEP_CMD_SET_MODE, &mode, sizeof(mode),
- NULL, NULL);
-}
-
-
static int wpa_driver_privsep_set_country(void *priv, const char *alpha2)
{
struct wpa_driver_privsep_data *drv = priv;
"wpa_supplicant privilege separated driver",
.get_bssid = wpa_driver_privsep_get_bssid,
.get_ssid = wpa_driver_privsep_get_ssid,
- .set_wpa = wpa_driver_privsep_set_wpa,
.set_key = wpa_driver_privsep_set_key,
.init = wpa_driver_privsep_init,
.deinit = wpa_driver_privsep_deinit,
.get_capa = wpa_driver_privsep_get_capa,
.get_mac_addr = wpa_driver_privsep_get_mac_addr,
.get_scan_results2 = wpa_driver_privsep_get_scan_results2,
- .set_mode = wpa_driver_privsep_set_mode,
.set_country = wpa_driver_privsep_set_country,
};
}
-static int wpa_driver_test_set_wpa(void *priv, int enabled)
-{
- wpa_printf(MSG_DEBUG, "%s: enabled=%d", __func__, enabled);
- return 0;
-}
-
-
static void wpa_driver_test_scan_timeout(void *eloop_ctx, void *timeout_ctx)
{
wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
}
-static int wpa_driver_test_set_mode(void *priv, int mode)
-{
- struct wpa_driver_test_data *drv = priv;
- return wpa_driver_update_mode(drv, mode == IEEE80211_MODE_AP);
-}
-
-
const struct wpa_driver_ops wpa_driver_test_ops = {
"test",
"wpa_supplicant test driver",
.set_wps_probe_resp_ie = test_driver_set_wps_probe_resp_ie,
.get_bssid = wpa_driver_test_get_bssid,
.get_ssid = wpa_driver_test_get_ssid,
- .set_wpa = wpa_driver_test_set_wpa,
.set_key = wpa_driver_test_set_key,
.deinit = wpa_driver_test_deinit,
.set_param = wpa_driver_test_set_param,
.init2 = wpa_driver_test_init2,
.get_interfaces = wpa_driver_test_get_interfaces,
.scan2 = wpa_driver_test_scan,
- .set_mode = wpa_driver_test_set_mode,
};
static int wpa_driver_wext_get_range(void *priv);
static int wpa_driver_wext_finish_drv_init(struct wpa_driver_wext_data *drv);
static void wpa_driver_wext_disconnect(struct wpa_driver_wext_data *drv);
+static int wpa_driver_wext_set_auth_alg(void *priv, int auth_alg);
static int wpa_driver_wext_send_oper_ifla(struct wpa_driver_wext_data *drv,
if (wpa_driver_wext_finish_drv_init(drv) < 0)
goto err4;
+ wpa_driver_wext_set_auth_param(drv, IW_AUTH_WPA_ENABLED, 1);
+
return drv;
err4:
struct wpa_driver_wext_data *drv = priv;
int flags;
+ wpa_driver_wext_set_auth_param(drv, IW_AUTH_WPA_ENABLED, 0);
+
eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv, drv->ctx);
/*
}
-static int wpa_driver_wext_set_wpa(void *priv, int enabled)
-{
- struct wpa_driver_wext_data *drv = priv;
- wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
-
- return wpa_driver_wext_set_auth_param(drv, IW_AUTH_WPA_ENABLED,
- enabled);
-}
-
-
static int wpa_driver_wext_set_psk(struct wpa_driver_wext_data *drv,
const u8 *psk)
{
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
+ if (wpa_driver_wext_set_drop_unencrypted(drv, params->drop_unencrypted)
+ < 0)
+ ret = -1;
+ if (wpa_driver_wext_set_auth_alg(drv, params->auth_alg) < 0)
+ ret = -1;
+ if (wpa_driver_wext_set_mode(drv, params->mode) < 0)
+ ret = -1;
+
/*
* If the driver did not support SIOCSIWAUTH, fallback to
* SIOCSIWENCODE here.
.desc = "Linux wireless extensions (generic)",
.get_bssid = wpa_driver_wext_get_bssid,
.get_ssid = wpa_driver_wext_get_ssid,
- .set_wpa = wpa_driver_wext_set_wpa,
.set_key = wpa_driver_wext_set_key,
.set_countermeasures = wpa_driver_wext_set_countermeasures,
- .set_drop_unencrypted = wpa_driver_wext_set_drop_unencrypted,
.scan = wpa_driver_wext_scan,
.get_scan_results2 = wpa_driver_wext_get_scan_results,
.deauthenticate = wpa_driver_wext_deauthenticate,
.disassociate = wpa_driver_wext_disassociate,
- .set_mode = wpa_driver_wext_set_mode,
.associate = wpa_driver_wext_associate,
- .set_auth_alg = wpa_driver_wext_set_auth_alg,
.init = wpa_driver_wext_init,
.deinit = wpa_driver_wext_deinit,
.add_pmkid = wpa_driver_wext_add_pmkid,
return 0;
}
-static inline int wpa_drv_set_drop_unencrypted(struct wpa_supplicant *wpa_s,
- int enabled)
-{
- if (wpa_s->driver->set_drop_unencrypted) {
- return wpa_s->driver->set_drop_unencrypted(wpa_s->drv_priv,
- enabled);
- }
- return -1;
-}
-
static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
int enabled)
{
return -1;
}
-static inline int wpa_drv_set_auth_alg(struct wpa_supplicant *wpa_s,
- int auth_alg)
-{
- if (wpa_s->driver->set_auth_alg) {
- return wpa_s->driver->set_auth_alg(wpa_s->drv_priv,
- auth_alg);
- }
- return -1;
-}
-
-static inline int wpa_drv_set_wpa(struct wpa_supplicant *wpa_s, int enabled)
-{
- if (wpa_s->driver->set_wpa) {
- return wpa_s->driver->set_wpa(wpa_s->drv_priv, enabled);
- }
- return 0;
-}
-
-static inline int wpa_drv_set_mode(struct wpa_supplicant *wpa_s, int mode)
-{
- if (wpa_s->driver->set_mode) {
- return wpa_s->driver->set_mode(wpa_s->drv_priv, mode);
- }
- return 0;
-}
-
static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
struct wpa_driver_auth_params *params)
{
{
if (iface->drv_priv) {
wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance");
- if (iface->driver->set_wpa)
- iface->driver->set_wpa(iface->drv_priv, 0);
if (iface->driver->deinit)
iface->driver->deinit(iface->drv_priv);
iface->drv_priv = NULL;
iface->driver->set_param(iface->drv_priv, NULL) < 0) {
wpa_printf(MSG_ERROR, "Driver interface rejected param");
}
-
- if (iface->driver->set_wpa)
- iface->driver->set_wpa(iface->drv_priv, 1);
}
struct sockaddr_un *from)
{
if (iface->drv_priv) {
- if (iface->driver->set_wpa)
- iface->driver->set_wpa(iface->drv_priv, 0);
if (iface->driver->deinit)
iface->driver->deinit(iface->drv_priv);
iface->drv_priv = NULL;
}
-static void wpa_priv_cmd_set_wpa(struct wpa_priv_interface *iface,
- char *buf, size_t len)
-{
- if (iface->drv_priv == NULL || len != sizeof(int))
- return;
-
- if (iface->driver->set_wpa)
- iface->driver->set_wpa(iface->drv_priv, *((int *) buf));
-}
-
-
static void wpa_priv_cmd_scan(struct wpa_priv_interface *iface,
char *buf, size_t len)
{
case PRIVSEP_CMD_UNREGISTER:
wpa_priv_cmd_unregister(iface, &from);
break;
- case PRIVSEP_CMD_SET_WPA:
- wpa_priv_cmd_set_wpa(iface, cmd_buf, cmd_len);
- break;
case PRIVSEP_CMD_SCAN:
wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
break;
* previous association. */
wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
- if (wpa_drv_set_mode(wpa_s, ssid->mode)) {
- wpa_printf(MSG_WARNING, "Failed to set operating mode");
- assoc_failed = 1;
- }
-
#ifdef IEEE8021X_EAPOL
if (ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) {
if (ssid->leap) {
wpa_printf(MSG_DEBUG, "Overriding auth_alg selection: 0x%x",
algs);
}
- wpa_drv_set_auth_alg(wpa_s, algs);
if (bss && (wpa_scan_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE) ||
wpa_scan_get_ie(bss, WLAN_EID_RSN)) &&
wpa_supplicant_set_wpa_none_key(wpa_s, ssid);
}
- wpa_drv_set_drop_unencrypted(wpa_s, use_crypt);
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATING);
os_memset(¶ms, 0, sizeof(params));
if (bss) {
}
}
- /* Backwards compatibility call to set_wpa() handler. This is called
- * only just after init and just before deinit, so these handler can be
- * used to implement same functionality. */
- if (wpa_drv_set_wpa(wpa_s, 1) < 0) {
- struct wpa_driver_capa capa;
- if (wpa_drv_get_capa(wpa_s, &capa) < 0 ||
- !(capa.flags & (WPA_DRIVER_CAPA_KEY_MGMT_WPA |
- WPA_DRIVER_CAPA_KEY_MGMT_WPA2))) {
- wpa_printf(MSG_DEBUG, "Driver does not support WPA.");
- /* Continue to allow non-WPA modes to be used. */
- } else {
- wpa_printf(MSG_ERROR, "Failed to enable WPA in the "
- "driver.");
- return -1;
- }
- }
-
wpa_clear_keys(wpa_s, NULL);
/* Make sure that TKIP countermeasures are not left enabled (could
* happen if wpa_supplicant is killed during countermeasures. */
wpa_drv_set_countermeasures(wpa_s, 0);
- wpa_drv_set_drop_unencrypted(wpa_s, 1);
-
wpa_printf(MSG_DEBUG, "RSN: flushing PMKID list in the driver");
wpa_drv_flush_pmkid(wpa_s);
wpa_supplicant_deauthenticate(wpa_s,
WLAN_REASON_DEAUTH_LEAVING);
- /* Backwards compatibility call to set_wpa() handler. This is
- * called only just after init and just before deinit, so these
- * handler can be used to implement same functionality. */
- if (wpa_drv_set_wpa(wpa_s, 0) < 0) {
- wpa_printf(MSG_ERROR, "Failed to disable WPA in the "
- "driver.");
- }
-
- wpa_drv_set_drop_unencrypted(wpa_s, 0);
wpa_drv_set_countermeasures(wpa_s, 0);
wpa_clear_keys(wpa_s, NULL);
}
projects / mech_eap.git / commitdiff