static int
wpa_driver_realtek_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_realtek_data *drv = priv;
struct ieee80211req_mlme mlme;
int ret = 0, privacy = 1;
printf("Wpa_supplicant: %s +++\n", __FUNCTION__);
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
//_Eric ?? if ret = -1, why still run continuously?
if(realtek_config_security(drv, params) < 0)
ret = -9;
if (params->bssid == NULL) {
//_Eric ?? it means no MAC but have SSID(name), driver shall try to find this AP automatically?
if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0)
ret = -2;
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
params->ssid_len) < 0)
ret = -3;
} else {
if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0)
ret = -4;
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
params->ssid_len) < 0)
ret = -5;
os_memset(&mlme, 0, sizeof(mlme));
mlme.im_op = IEEE80211_MLME_ASSOC;
os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN);
printf("Try to assoc %02x:%02x:%02x:%02x:%02x:%02x \n",
params->bssid[0], params->bssid[1], params->bssid[2],
params->bssid[3], params->bssid[4], params->bssid[5]);
if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme,
sizeof(mlme), 1) < 0) {
wpa_printf(MSG_DEBUG, "%s: SETMLME[ASSOC] failed",
__func__);
ret = -1;
}
}
printf("Wpa_supplicant: %s --- ret = %d\n", __FUNCTION__, ret);
return ret;
}
static int
wpa_driver_ipw_associate(void *priv, struct wpa_driver_associate_params *params)
{
struct wpa_driver_ipw_data *drv = priv;
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,
params->ssid_len) < 0)
ret = -1;
if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0)
ret = -1;
if (params->key_mgmt_suite == KEY_MGMT_802_1X ||
params->key_mgmt_suite == KEY_MGMT_PSK)
unencrypted_eapol = 0;
else
unencrypted_eapol = 1;
if (ipw_set_wpa_param(drv, IPW_PARAM_IEEE_802_1X,
unencrypted_eapol) < 0) {
wpa_printf(MSG_DEBUG, "ipw: Failed to configure "
"ieee_802_1x param");
}
return ret;
}
static int
wpa_driver_madwifi_scan(void *priv, const u8 *ssid, size_t ssid_len)
{
struct wpa_driver_madwifi_data *drv = priv;
struct iwreq iwr;
int ret = 0;
os_memset(&iwr, 0, sizeof(iwr));
os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
/* set desired ssid before scan */
/* FIX: scan should not break the current association, so using
* set_ssid may not be the best way of doing this.. */
if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0)
ret = -1;
if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) {
perror("ioctl[SIOCSIWSCAN]");
ret = -1;
}
/*
* madwifi delivers a scan complete event so no need to poll, but
* register a backup timeout anyway to make sure that we recover even
* if the driver does not send this event for any reason. This timeout
* will only be used if the event is not delivered (event handler will
* cancel the timeout).
*/
eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext,
drv->ctx);
return ret;
}
static int
wpa_driver_realtek_scan(void *priv, const u8 *ssid, size_t ssid_len)
{
struct wpa_driver_realtek_data *drv = priv;
struct iwreq iwr;
int ret = 0;
printf("Wpa_supplicant: %s +++\n", __FUNCTION__);
os_memset(&iwr, 0, sizeof(iwr));
os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0)
ret = -1;
#ifdef RTK_INBAND
if (inband_ioctl(SIOCSIWSCAN, &iwr) < 0)
#else
if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0)
#endif
{
perror("ioctl[SIOCSIWSCAN]");
ret = -1;
}
eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv->wext,
drv->ctx);
eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext,
drv->ctx);
return ret;
}
static int
wpa_driver_hostap_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_hostap_data *drv = priv;
int ret = 0;
int allow_unencrypted_eapol;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
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. */
if (prism2param(drv, PRISM2_PARAM_HOST_ROAMING,
params->mode == IEEE80211_MODE_IBSS ? 0 : 2) <
0) {
wpa_printf(MSG_DEBUG, "%s: failed to set host_roaming",
__func__);
}
drv->current_mode = params->mode;
}
if (prism2param(drv, PRISM2_PARAM_PRIVACY_INVOKED,
params->key_mgmt_suite != KEY_MGMT_NONE) < 0)
ret = -1;
if (wpa_driver_hostap_set_wpa_ie(drv, params->wpa_ie,
params->wpa_ie_len) < 0)
ret = -1;
if (wpa_driver_wext_set_mode(drv->wext, params->mode) < 0)
ret = -1;
if (params->freq &&
wpa_driver_wext_set_freq(drv->wext, params->freq) < 0)
ret = -1;
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len)
< 0)
ret = -1;
if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0)
ret = -1;
/* Allow unencrypted EAPOL messages even if pairwise keys are set when
* not using WPA. IEEE 802.1X specifies that these frames are not
* encrypted, but WPA encrypts them when pairwise keys are in use. */
if (params->key_mgmt_suite == KEY_MGMT_802_1X ||
params->key_mgmt_suite == KEY_MGMT_PSK)
allow_unencrypted_eapol = 0;
else
allow_unencrypted_eapol = 1;
if (prism2param(drv, PRISM2_PARAM_IEEE_802_1X,
allow_unencrypted_eapol) < 0) {
wpa_printf(MSG_DEBUG, "hostap: Failed to configure "
"ieee_802_1x param");
/* Ignore this error.. driver_hostap.c can also be used with
* other drivers that do not support this prism2_param. */
}
return ret;
}
static int
wpa_driver_madwifi_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_madwifi_data *drv = priv;
struct ieee80211req_mlme mlme;
int ret = 0, privacy = 1;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
/*
* NB: Don't need to set the freq or cipher-related state as
* this is implied by the bssid which is used to locate
* the scanned node state which holds it. The ssid is
* needed to disambiguate an AP that broadcasts multiple
* ssid's but uses the same bssid.
*/
/* XXX error handling is wrong but unclear what to do... */
if (wpa_driver_madwifi_set_wpa_ie(drv, params->wpa_ie,
params->wpa_ie_len) < 0)
ret = -1;
if (params->pairwise_suite == CIPHER_NONE &&
params->group_suite == CIPHER_NONE &&
params->key_mgmt_suite == KEY_MGMT_NONE &&
params->wpa_ie_len == 0)
privacy = 0;
if (set80211param(drv, IEEE80211_PARAM_PRIVACY, privacy, 1) < 0)
ret = -1;
if (params->bssid == NULL) {
/* ap_scan=2 mode - driver takes care of AP selection and
* roaming */
/* FIX: this does not seem to work; would probably need to
* change something in the driver */
if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0)
ret = -1;
}
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
params->ssid_len) < 0)
ret = -1;
if (params->bssid) {
if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0)
ret = -1;
memset(&mlme, 0, sizeof(mlme));
mlme.im_op = IEEE80211_MLME_ASSOC;
memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN);
if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme,
sizeof(mlme), 1) < 0)
ret = -1;
}
return ret;
}
int wpa_driver_awext_set_ssid(void *priv, const u8 *ssid, size_t ssid_len)
{
struct wpa_driver_awext_data *drv = priv;
if (ssid_len > 32)
return -1;
os_memset(drv->ssid, 0, 32);
os_memcpy(drv->ssid, ssid, ssid_len);
drv->ssid_len = ssid_len;
return wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len);
}
static int
wpa_driver_prism54_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_prism54_data *drv = priv;
int ret = 0;
if (wpa_driver_prism54_set_wpa_ie(drv, params->wpa_ie,
params->wpa_ie_len) < 0)
ret = -1;
if (wpa_driver_wext_set_freq(drv->wext, params->freq) < 0)
ret = -1;
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid,
params->ssid_len) < 0)
ret = -1;
if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0)
ret = -1;
return ret;
}
static int wpa_driver_hostap_associate(const char *ifname, const char *bssid,
const char *ssid, size_t ssid_len,
int freq,
const char *wpa_ie, size_t wpa_ie_len,
wpa_cipher pairwise_suite,
wpa_cipher group_suite,
wpa_key_mgmt key_mgmt_suite)
{
int ret = 0;
int allow_unencrypted_eapol;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
if (wpa_driver_hostap_set_wpa_ie(ifname, wpa_ie, wpa_ie_len) < 0)
ret = -1;
if (wpa_driver_wext_set_freq(ifname, freq) < 0)
ret = -1;
if (wpa_driver_wext_set_ssid(ifname, ssid, ssid_len) < 0)
ret = -1;
if (wpa_driver_wext_set_bssid(ifname, bssid) < 0)
ret = -1;
/* Allow unencrypted EAPOL messages even if pairwise keys are set when
* not using WPA. IEEE 802.1X specifies that these frames are not
* encrypted, but WPA encrypts them when pairwise keys are in use. */
if (key_mgmt_suite == KEY_MGMT_802_1X ||
key_mgmt_suite == KEY_MGMT_PSK)
allow_unencrypted_eapol = 0;
else
allow_unencrypted_eapol = 1;
if (prism2param(ifname, PRISM2_PARAM_IEEE_802_1X,
allow_unencrypted_eapol) < 0) {
wpa_printf(MSG_DEBUG, "hostap: Failed to configure "
"ieee_802_1x param");
/* Ignore this error.. driver_hostap.c can also be used with
* other drivers that do not support this prism2_param. */
}
return ret;
}
static int wpa_driver_atmel_associate(const char *ifname, const char *bssid,
const char *ssid, size_t ssid_len,
int freq,
const char *wpa_ie, size_t wpa_ie_len,
wpa_cipher pairwise_suite,
wpa_cipher group_suite,
wpa_key_mgmt key_mgmt_suite)
{
int ret = 0;
u8 pairwise_suite_driver;
u8 group_suite_driver;
u8 key_mgmt_suite_driver;
pairwise_suite_driver = convertSuiteToDriver(pairwise_suite);
group_suite_driver = convertSuiteToDriver(group_suite);
key_mgmt_suite_driver = convertSuiteToDriver(key_mgmt_suite);
#if 0
if (wpa_driver_atmel_set_suites(ifname, pairwise_suite_driver, group_suite_driver, key_mgmt_suite_driver) < 0) {
printf("wpa_driver_atmel_set_suites.\n");
ret = -1;
}
if (wpa_driver_wext_set_freq(ifname, freq) < 0) {
printf("wpa_driver_atmel_set_freq.\n");
ret = -1;
}
#endif
if (wpa_driver_wext_set_ssid(ifname, ssid, ssid_len) < 0) {
printf("FAILED : wpa_driver_atmel_set_ssid.\n");
ret = -1;
}
if (wpa_driver_wext_set_bssid(ifname, bssid) < 0) {
printf("FAILED : wpa_driver_atmel_set_bssid.\n");
ret = -1;
}
return ret;
}
static int
wpa_driver_madwifi_scan(void *priv, const u8 *ssid, size_t ssid_len)
{
struct wpa_driver_madwifi_data *drv = priv;
struct iwreq iwr;
memset(&iwr, 0, sizeof(iwr));
strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
/* set desired ssid before scan */
/* FIX: scan should not break the current association, so using
* set_ssid may not be the best way of doing this.. */
if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0)
return -1;
if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) {
perror("ioctl[SIOCSIWSCAN]");
return -1;
}
/* NB: madwifi delivers a scan complete event so no need to poll */
return 0;
}
static int
wpa_driver_atmel_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_atmel_data *drv = priv;
int ret = 0;
u8 pairwise_suite_driver;
u8 group_suite_driver;
u8 key_mgmt_suite_driver;
pairwise_suite_driver = convertSuiteToDriver(params->pairwise_suite);
group_suite_driver = convertSuiteToDriver(params->group_suite);
key_mgmt_suite_driver = convertSuiteToDriver(params->key_mgmt_suite);
#if 0
if (wpa_driver_atmel_set_suites(drv, pairwise_suite_driver,
group_suite_driver,
key_mgmt_suite_driver) < 0){
printf("wpa_driver_atmel_set_suites.\n");
ret = -1;
}
if (wpa_driver_wext_set_freq(drv->wext, params->freq) < 0) {
printf("wpa_driver_atmel_set_freq.\n");
ret = -1;
}
#endif
if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len)
< 0) {
printf("FAILED : wpa_driver_atmel_set_ssid.\n");
ret = -1;
}
if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0) {
printf("FAILED : wpa_driver_atmel_set_bssid.\n");
ret = -1;
}
return ret;
}
static int wpa_driver_tista_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_ti_data *drv = priv;
int allow_unencrypted_eapol;
int value, flags, ret = 0;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
#ifdef WPA_SUPPLICANT_VER_0_6_X
#ifdef ANDROID
((struct wpa_driver_wext_data *)(drv->wext))->skip_disconnect = 0;
#endif
#endif
if (wpa_driver_wext_get_ifflags(drv->wext, &flags) == 0) {
if (!(flags & IFF_UP)) {
wpa_driver_wext_set_ifflags(drv->wext, flags | IFF_UP);
}
}
#if 0
if (!params->bssid)
wpa_driver_wext_set_bssid(drv->wext, NULL);
#endif
#ifdef WPA_SUPPLICANT_VER_0_5_X
/* Set driver network mode (Adhoc/Infrastructure) according to supplied parameters */
wpa_driver_wext_set_mode(drv->wext, params->mode);
#endif
wpa_driver_tista_set_gen_ie(drv, params->wpa_ie, params->wpa_ie_len);
if (params->wpa_ie == NULL || params->wpa_ie_len == 0)
value = IW_AUTH_WPA_VERSION_DISABLED;
#ifdef WPA_SUPPLICANT_VER_0_6_X
else if (params->wpa_ie[0] == WLAN_EID_RSN)
#else
else if (params->wpa_ie[0] == RSN_INFO_ELEM)
#endif
value = IW_AUTH_WPA_VERSION_WPA2;
#ifdef CONFIG_WPS
else if (params->key_mgmt_suite == KEY_MGMT_WPS)
value = IW_AUTH_WPA_VERSION_DISABLED;
#endif
else
value = IW_AUTH_WPA_VERSION_WPA;
wpa_driver_tista_set_auth_param(drv, IW_AUTH_WPA_VERSION, value);
value = wpa_driver_tista_cipher2wext(params->pairwise_suite);
wpa_driver_tista_set_auth_param(drv, IW_AUTH_CIPHER_PAIRWISE, value);
value = wpa_driver_tista_cipher2wext(params->group_suite);
wpa_driver_tista_set_auth_param(drv, IW_AUTH_CIPHER_GROUP, value);
value = wpa_driver_tista_keymgmt2wext(params->key_mgmt_suite);
wpa_driver_tista_set_auth_param(drv, IW_AUTH_KEY_MGMT, value);
value = params->key_mgmt_suite != KEY_MGMT_NONE ||
params->pairwise_suite != CIPHER_NONE ||
params->group_suite != CIPHER_NONE ||
#ifdef WPA_SUPPLICANT_VER_0_6_X
(params->wpa_ie_len && (params->key_mgmt_suite != KEY_MGMT_WPS));
#else
params->wpa_ie_len;
#endif
wpa_driver_tista_set_auth_param(drv, IW_AUTH_PRIVACY_INVOKED, value);
/* Allow unencrypted EAPOL messages even if pairwise keys are set when
* not using WPA. IEEE 802.1X specifies that these frames are not
* encrypted, but WPA encrypts them when pairwise keys are in use. */
if (params->key_mgmt_suite == KEY_MGMT_802_1X ||
params->key_mgmt_suite == KEY_MGMT_PSK)
allow_unencrypted_eapol = 0;
else
allow_unencrypted_eapol = 1;
wpa_driver_tista_set_auth_param(drv,
IW_AUTH_RX_UNENCRYPTED_EAPOL,
allow_unencrypted_eapol);
if (params->freq)
wpa_driver_wext_set_freq(drv->wext, params->freq);
if (params->bssid) {
wpa_printf(MSG_DEBUG, "wpa_driver_tista_associate: BSSID=" MACSTR,
MAC2STR(params->bssid));
/* if there is bssid -> set it */
if (os_memcmp(params->bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0) {
wpa_driver_wext_set_bssid(drv->wext, params->bssid);
}
}
ret = wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len);
return ret;
}
static int wpa_driver_ps3_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_wext_data *drv = priv;
int ret, value;
wpa_printf(MSG_DEBUG, "%s: <-", __func__);
/* clear BSSID */
if (!params->bssid &&
wpa_driver_wext_set_bssid(drv, NULL) < 0)
ret = -1;
if (wpa_driver_wext_set_mode(drv, params->mode) < 0)
ret = -1;
if (params->wpa_ie == NULL || params->wpa_ie_len == 0)
value = IW_AUTH_WPA_VERSION_DISABLED;
else if (params->wpa_ie[0] == WLAN_EID_RSN)
value = IW_AUTH_WPA_VERSION_WPA2;
else
value = IW_AUTH_WPA_VERSION_WPA;
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_WPA_VERSION, value) < 0)
ret = -1;
value = wpa_driver_wext_cipher2wext(params->pairwise_suite);
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_CIPHER_PAIRWISE, value) < 0)
ret = -1;
value = wpa_driver_wext_cipher2wext(params->group_suite);
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_CIPHER_GROUP, value) < 0)
ret = -1;
value = wpa_driver_wext_keymgmt2wext(params->key_mgmt_suite);
if (wpa_driver_wext_set_auth_param(drv, IW_AUTH_KEY_MGMT, value) < 0)
ret = -1;
/* set selected BSSID */
if (params->bssid &&
wpa_driver_wext_set_bssid(drv, params->bssid) < 0)
ret = -1;
switch (params->group_suite) {
case CIPHER_NONE:
ret = 0;
break;
case CIPHER_WEP40:
case CIPHER_WEP104:
ret = wpa_driver_ps3_set_wep_keys(drv, params);
break;
case CIPHER_TKIP:
case CIPHER_CCMP:
ret = wpa_driver_ps3_set_wpa_key(drv, params);
break;
}
/* start to associate */
ret = wpa_driver_wext_set_ssid(drv, params->ssid, params->ssid_len);
wpa_printf(MSG_DEBUG, "%s: ->", __func__);
return ret;
}
static int
wpa_driver_wext_associate(void *priv,
struct wpa_driver_associate_params *params)
{
struct wpa_driver_wext_data *drv = priv;
int ret = 0;
int allow_unencrypted_eapol;
int value;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
if (!params->bssid &&
wpa_driver_wext_set_bssid(drv, NULL) < 0)
ret = -1;
if (wpa_driver_wext_set_mode(drv, params->mode) < 0)
ret = -1;
/* TODO: should consider getting wpa version and cipher/key_mgmt suites
* from configuration, not from here, where only the selected suite is
* available */
if (wpa_driver_wext_set_gen_ie(drv, params->wpa_ie, params->wpa_ie_len)
< 0)
ret = -1;
if (params->wpa_ie == NULL || params->wpa_ie_len == 0)
value = IW_AUTH_WPA_VERSION_DISABLED;
else if (params->wpa_ie[0] == RSN_INFO_ELEM)
value = IW_AUTH_WPA_VERSION_WPA2;
else
value = IW_AUTH_WPA_VERSION_WPA;
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_WPA_VERSION, value) < 0)
ret = -1;
value = wpa_driver_wext_cipher2wext(params->pairwise_suite);
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_CIPHER_PAIRWISE, value) < 0)
ret = -1;
value = wpa_driver_wext_cipher2wext(params->group_suite);
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_CIPHER_GROUP, value) < 0)
ret = -1;
value = wpa_driver_wext_keymgmt2wext(params->key_mgmt_suite);
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_KEY_MGMT, value) < 0)
ret = -1;
value = params->key_mgmt_suite != KEY_MGMT_NONE;
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_PRIVACY_INVOKED, value) < 0)
ret = -1;
/* Allow unencrypted EAPOL messages even if pairwise keys are set when
* not using WPA. IEEE 802.1X specifies that these frames are not
* encrypted, but WPA encrypts them when pairwise keys are in use. */
if (params->key_mgmt_suite == KEY_MGMT_802_1X ||
params->key_mgmt_suite == KEY_MGMT_PSK)
allow_unencrypted_eapol = 0;
else
allow_unencrypted_eapol = 1;
if (wpa_driver_wext_set_auth_param(drv,
IW_AUTH_RX_UNENCRYPTED_EAPOL,
allow_unencrypted_eapol) < 0)
ret = -1;
if (params->freq && wpa_driver_wext_set_freq(drv, params->freq) < 0)
ret = -1;
if (wpa_driver_wext_set_ssid(drv, params->ssid, params->ssid_len) < 0)
ret = -1;
if (params->bssid &&
wpa_driver_wext_set_bssid(drv, params->bssid) < 0)
ret = -1;
return ret;
}
static int wpa_driver_tista_set_ssid(void *priv, const u8 *ssid, size_t ssid_len)
{
struct wpa_driver_ti_data *drv = priv;
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
return wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len);
}
