/*-----------------------------------------------------------------------------
Routine Name: wpa_driver_tista_scan
Routine Description: request scan from driver
Arguments:
priv - pointer to private data structure
ssid - ssid buffer
ssid_len - length of ssid
Return Value: 0 on success, -1 on failure
-----------------------------------------------------------------------------*/
static int wpa_driver_tista_scan( void *priv, const u8 *ssid, size_t ssid_len )
{
struct wpa_driver_ti_data *drv = (struct wpa_driver_ti_data *)priv;
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
struct wpa_ssid *issid;
scan_Params_t scanParams;
int scan_type, res, timeout, scan_probe_flag = 0;
wpa_printf(MSG_DEBUG, "%s", __func__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
#if 1
os_memset(&scanParams, 0, sizeof(scan_Params_t));
/* Initialize scan parameters */
scan_type = drv->scan_type;
if (wpa_s->prev_scan_ssid != BROADCAST_SSID_SCAN) {
if (wpa_s->prev_scan_ssid->scan_ssid) {
scan_type = SCAN_TYPE_NORMAL_ACTIVE;
scan_probe_flag = 1;
}
}
scanParams.scanType = scan_type;
scanParams.numOfChannels = drv->scan_channels;
scanParams.probeReqNumber = SCAN_DEFAULT_PROBE_REQUEST_NUM;
scanParams.probeRequestRate = RATE_MASK_UNSPECIFIED; /* Let the FW select */;
scanParams.desiredSsid.len = 0;
drv->force_merge_flag = 0; /* Set merge flag */
if ((scan_probe_flag && ssid) &&
(ssid_len > 0 && ssid_len <= sizeof(scanParams.desiredSsid.str))) {
os_memcpy(scanParams.desiredSsid.str, ssid, ssid_len);
if (ssid_len < sizeof(scanParams.desiredSsid.str))
scanParams.desiredSsid.str[ssid_len] = '\0';
scanParams.desiredSsid.len = ssid_len;
drv->force_merge_flag = 1;
}
drv->last_scan = scan_type; /* Remember scan type for last scan */
res = wpa_driver_tista_private_send(priv, TIWLN_802_11_START_OS_SCAN_SET, &scanParams, sizeof(scanParams), NULL, 0);
if (0 != res)
wpa_printf(MSG_ERROR, "ERROR - Failed to do tista scan!");
else
wpa_printf(MSG_DEBUG, "wpa_driver_tista_scan OS_SCAN success");
timeout = 30;
wpa_printf(MSG_DEBUG, "Scan requested (ret=%d) - scan timeout %d sec",
res, timeout);
eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv->wext, drv->ctx);
eloop_register_timeout(timeout, 0, wpa_driver_wext_scan_timeout,
drv->wext, drv->ctx);
return res;
#else
return wpa_driver_wext_scan(drv->wext, ssid, ssid_len);
#endif
}
int wpa_driver_tista_set_mode(void *priv, int mode)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __func__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_wext_set_mode(drv->wext, mode);
return ret;
}
static int wpa_driver_tista_flush_pmkid(void *priv)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_tista_pmksa(drv, IW_PMKSA_FLUSH, NULL, NULL);
return ret;
}
static int wpa_driver_tista_set_operstate(void *priv, int state)
{
struct wpa_driver_ti_data *drv = priv;
wpa_printf(MSG_DEBUG, "%s: operstate %d (%s)",
__func__, /*drv->operstate,*/ state, state ? "UP" : "DORMANT");
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
/* Dm: drv->operstate = state; */
return wpa_driver_wext_set_operstate(drv->wext, state);
}
static int wpa_driver_tista_set_wpa(void *priv, int enabled)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_tista_set_auth_param(drv, IW_AUTH_WPA_ENABLED,
enabled);
return ret;
}
static int wpa_driver_tista_remove_pmkid(void *priv, const u8 *bssid,
const u8 *pmkid)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_tista_pmksa(drv, IW_PMKSA_REMOVE, bssid, pmkid);
return ret;
}
static int wpa_driver_tista_set_operstate(void *priv, int state)
{
struct wpa_driver_ti_data *drv = priv;
wpa_printf(MSG_DEBUG, "%s: operstate %d (%s)",
__func__, /*drv->operstate,*/ state, state ? "UP" : "DORMANT");
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
/* Dm: drv->operstate = state; */
wpa_driver_tista_private_send(priv, RSN_PORT_STATUS_PARAM, &state, sizeof(state), NULL, 0);
return wpa_driver_wext_set_operstate(drv->wext, state);
}
static int wpa_driver_tista_disassociate(void *priv, const u8 *addr,
int reason_code)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_tista_mlme(drv, addr, IW_MLME_DISASSOC, reason_code);
return ret;
}
static int wpa_driver_tista_set_countermeasures(void *priv, int enabled)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_tista_set_auth_param(drv,
IW_AUTH_TKIP_COUNTERMEASURES,
enabled);
return ret;
}
static int wpa_driver_tista_set_drop_unencrypted(void *priv,
int enabled)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
/* Dm: drv->use_crypt = enabled; */
ret = wpa_driver_tista_set_auth_param(drv, IW_AUTH_DROP_UNENCRYPTED,
enabled);
return ret;
}
static int wpa_driver_tista_set_key(void *priv, wpa_alg alg,
const u8 *addr, int key_idx,
int set_tx, const u8 *seq, size_t seq_len,
const u8 *key, size_t key_len)
{
struct wpa_driver_ti_data *drv = priv;
int ret;
wpa_printf(MSG_DEBUG, "%s", __func__);
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ret = wpa_driver_wext_set_key(drv->wext, alg, addr, key_idx, set_tx,
seq, seq_len, key, key_len);
return ret;
}
/*-----------------------------------------------------------------------------
Routine Name: wpa_driver_tista_get_mac_addr
Routine Description: return WLAN MAC address
Arguments:
priv - pointer to private data structure
Return Value: pointer to BSSID
-----------------------------------------------------------------------------*/
const u8 *wpa_driver_tista_get_mac_addr( void *priv )
{
struct wpa_driver_ti_data *drv = (struct wpa_driver_ti_data *)priv;
u8 mac[ETH_ALEN] = {0};
TI_CHECK_DRIVER( drv->driver_is_loaded, NULL );
if(0 != wpa_driver_tista_private_send(priv, CTRL_DATA_MAC_ADDRESS, NULL, 0,
mac, ETH_ALEN))
{
wpa_printf(MSG_ERROR, "ERROR - Failed to get mac address!");
os_memset(drv->own_addr, 0, ETH_ALEN);
}
else
{
os_memcpy(drv->own_addr, mac, ETH_ALEN);
wpa_printf(MSG_DEBUG, "Macaddr = " MACSTR, MAC2STR(drv->own_addr));
}
wpa_printf(MSG_DEBUG, "wpa_driver_tista_get_mac_addr success");
return (const u8 *)&drv->own_addr;
}
static int wpa_driver_tista_get_scan_results(void *priv,
struct wpa_scan_result *results,
size_t max_size)
{
struct wpa_driver_ti_data *drv = priv;
int ap_num = 0;
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
ap_num = wpa_driver_wext_get_scan_results(drv->wext, results, max_size);
wpa_printf(MSG_DEBUG, "Actual APs number %d", ap_num);
if (ap_num < 0)
return -1;
/* Merge new results with previous */
ap_num = scan_merge(drv, results, drv->force_merge_flag, ap_num, max_size);
wpa_printf(MSG_DEBUG, "After merge, APs number %d", ap_num);
qsort(results, ap_num, sizeof(struct wpa_scan_result),
wpa_driver_tista_scan_result_compare);
return ap_num;
}
static int wpa_driver_tista_set_auth_alg(void *priv, int auth_alg)
{
struct wpa_driver_ti_data *drv = priv;
int algs = 0, res;
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
if (auth_alg & AUTH_ALG_OPEN_SYSTEM)
algs |= IW_AUTH_ALG_OPEN_SYSTEM;
if (auth_alg & AUTH_ALG_SHARED_KEY)
algs |= IW_AUTH_ALG_SHARED_KEY;
if (auth_alg & AUTH_ALG_LEAP)
algs |= IW_AUTH_ALG_LEAP;
if (algs == 0) {
/* at least one algorithm should be set */
algs = IW_AUTH_ALG_OPEN_SYSTEM;
}
res = wpa_driver_tista_set_auth_param(drv, IW_AUTH_80211_AUTH_ALG,
algs);
return res;
}
static struct wpa_scan_results *wpa_driver_tista_get_scan_results(void *priv)
{
struct wpa_driver_ti_data *drv = priv;
struct wpa_scan_results *res;
struct wpa_scan_res **tmp;
unsigned ap_num;
TI_CHECK_DRIVER( drv->driver_is_loaded, NULL );
res = wpa_driver_wext_get_scan_results(drv->wext);
if (res == NULL) {
return NULL;
}
wpa_printf(MSG_DEBUG, "Actual APs number %d", res->num);
ap_num = (unsigned)scan_count(drv) + res->num;
tmp = os_realloc(res->res, ap_num * sizeof(struct wpa_scan_res *));
if (tmp == NULL)
return res;
res->num = scan_merge(drv, tmp, drv->force_merge_flag, res->num, ap_num);
wpa_printf(MSG_DEBUG, "After merge, APs number %d", res->num);
tmp = os_realloc(tmp, res->num * sizeof(struct wpa_scan_res *));
res->res = tmp;
return res;
}
/*-----------------------------------------------------------------------------
Routine Name: wpa_driver_tista_driver_cmd
Routine Description: executes driver-specific commands
Arguments:
priv - pointer to private data structure
cmd - command
buf - return buffer
buf_len - buffer length
Return Value: actual buffer length - success, -1 - failure
-----------------------------------------------------------------------------*/
static int wpa_driver_tista_driver_cmd( void *priv, char *cmd, char *buf, size_t buf_len )
{
struct wpa_driver_ti_data *drv = (struct wpa_driver_ti_data *)priv;
int ret = -1, prev_events, flags;
wpa_printf(MSG_DEBUG, "%s %s", __func__, cmd);
if( os_strcasecmp(cmd, "start") == 0 ) {
wpa_printf(MSG_DEBUG,"Start command");
scan_exit(drv); /* Clear scan cache */
ret = wpa_driver_tista_driver_start(priv);
if( ret == 0 ) {
drv->driver_is_loaded = TRUE;
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
}
return( TI2WPA_STATUS(ret) );
}
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
if( os_strcasecmp(cmd, "stop") == 0 ) {
wpa_printf(MSG_DEBUG,"Stop command");
if ((wpa_driver_wext_get_ifflags(drv->wext, &flags) == 0) &&
(flags & IFF_UP)) {
wpa_printf(MSG_ERROR, "TI: %s when iface is UP", cmd);
wpa_driver_wext_set_ifflags(drv->wext, flags & ~IFF_UP);
}
ret = wpa_driver_tista_driver_stop(priv);
if( ret == 0 ) {
scan_exit(drv); /* Clear scan cache */
drv->driver_is_loaded = FALSE;
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
}
}
if( os_strcasecmp(cmd, "reload") == 0 ) {
wpa_printf(MSG_DEBUG,"Reload command");
ret = 0;
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
}
else if( os_strcasecmp(cmd, "macaddr") == 0 ) {
wpa_driver_tista_get_mac_addr(priv);
wpa_printf(MSG_DEBUG, "Macaddr command");
ret = sprintf(buf, "Macaddr = " MACSTR "\n", MAC2STR(drv->own_addr));
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
else if( os_strcasecmp(cmd, "scan-passive") == 0 ) {
wpa_printf(MSG_DEBUG,"Scan Passive command");
drv->scan_type = SCAN_TYPE_NORMAL_PASSIVE;
ret = 0;
}
else if( os_strcasecmp(cmd, "scan-active") == 0 ) {
wpa_printf(MSG_DEBUG,"Scan Active command");
drv->scan_type = SCAN_TYPE_NORMAL_ACTIVE;
ret = 0;
}
else if( os_strcasecmp(cmd, "scan-mode") == 0 ) {
wpa_printf(MSG_DEBUG,"Scan Mode command");
ret = snprintf(buf, buf_len, "ScanMode = %u\n", drv->scan_type);
if (ret < (int)buf_len) {
return( ret );
}
}
else if( os_strcasecmp(cmd, "linkspeed") == 0 ) {
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
wpa_printf(MSG_DEBUG,"Link Speed command");
drv->link_speed = wpa_s->link_speed / 1000000;
ret = sprintf(buf,"LinkSpeed %u\n", drv->link_speed);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
else if( os_strncasecmp(cmd, "scan-channels", 13) == 0 ) {
int noOfChan;
noOfChan = atoi(cmd + 13);
wpa_printf(MSG_DEBUG,"Scan Channels command = %d", noOfChan);
if( (noOfChan > 0) && (noOfChan <= MAX_NUMBER_OF_CHANNELS_PER_SCAN) )
drv->scan_channels = noOfChan;
ret = sprintf(buf,"Scan-Channels = %d\n", drv->scan_channels);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
else if( os_strcasecmp(cmd, "rssi-approx") == 0 ) {
scan_result_t *cur_res;
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
scan_ssid_t *p_ssid;
int rssi, len;
wpa_printf(MSG_DEBUG,"rssi-approx command");
if( !wpa_s )
return( ret );
cur_res = scan_get_by_bssid(drv, wpa_s->bssid);
if( cur_res ) {
p_ssid = scan_get_ssid(cur_res);
if( p_ssid ) {
len = (int)(p_ssid->ssid_len);
rssi = cur_res->level;
if( (len > 0) && (len <= MAX_SSID_LEN) && (len < (int)buf_len)) {
os_memcpy((void *)buf, (void *)(p_ssid->ssid), len);
ret = len;
ret += snprintf(&buf[ret], buf_len-len, " rssi %d\n", rssi);
}
}
}
}
else if( os_strcasecmp(cmd, "rssi") == 0 ) {
u8 ssid[MAX_SSID_LEN];
scan_result_t *cur_res;
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
int rssi_data, rssi_beacon, len;
wpa_printf(MSG_DEBUG,"rssi command");
ret = wpa_driver_tista_get_rssi(priv, &rssi_data, &rssi_beacon);
if( ret == 0 ) {
len = wpa_driver_tista_get_ssid(priv, (u8 *)ssid);
wpa_printf(MSG_DEBUG,"rssi_data %d rssi_beacon %d", rssi_data, rssi_beacon);
if( (len > 0) && (len <= MAX_SSID_LEN) ) {
os_memcpy((void *)buf, (void *)ssid, len);
ret = len;
ret += sprintf(&buf[ret], " rssi %d\n", rssi_beacon);
wpa_printf(MSG_DEBUG, "buf %s", buf);
/* Update cached value */
if( !wpa_s )
return( ret );
cur_res = scan_get_by_bssid(drv, wpa_s->bssid);
if( cur_res )
cur_res->level = rssi_beacon;
}
else
{
wpa_printf(MSG_DEBUG, "Fail to get ssid when reporting rssi");
ret = -1;
}
}
}
else if( os_strncasecmp(cmd, "powermode", 9) == 0 ) {
u32 mode;
TPowerMgr_PowerMode tMode;
mode = (u32)atoi(cmd + 9);
wpa_printf(MSG_DEBUG,"Power Mode command = %u", mode);
if( mode < POWER_MODE_MAX )
{
tMode.PowerMode = (PowerMgr_PowerMode_e)mode;
tMode.PowerMngPriority = POWER_MANAGER_USER_PRIORITY;
ret = wpa_driver_tista_config_power_management( priv, &tMode, 1 );
}
}
else if (os_strncasecmp(cmd, "getpower", 8) == 0 ) {
u32 mode;
TPowerMgr_PowerMode tMode;
os_memset(&tMode, 0, sizeof(TPowerMgr_PowerMode));
ret = wpa_driver_tista_config_power_management( priv, &tMode, 0 );
if( ret == 0 ) {
ret = sprintf(buf, "powermode = %u\n", tMode.PowerMode);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
}
else if( os_strncasecmp(cmd, "btcoexmode", 10) == 0 ) {
u32 mode;
mode = (u32)atoi(cmd + 10);
wpa_printf(MSG_DEBUG,"BtCoex Mode command = %u", mode);
ret = wpa_driver_tista_enable_bt_coe( priv, mode );
if( ret == 0 ) {
drv->btcoex_mode = mode;
}
}
else if( os_strcasecmp(cmd, "btcoexstat") == 0 ) {
u32 status = drv->btcoex_mode;
wpa_printf(MSG_DEBUG,"BtCoex Status");
ret = wpa_driver_tista_get_bt_coe_status( priv, &status );
if( ret == 0 ) {
ret = sprintf(buf, "btcoexstatus = 0x%x\n", status);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
}
else if( os_strcasecmp(cmd, "rxfilter-start") == 0 ) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Start command");
ret = wpa_driver_tista_driver_enable_rx_data_filter( priv );
}
else if( os_strcasecmp(cmd, "rxfilter-stop") == 0 ) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Stop command");
ret = wpa_driver_tista_driver_disable_rx_data_filter( priv );
}
else if( os_strcasecmp(cmd, "rxfilter-statistics") == 0 ) {
TCuCommon_RxDataFilteringStatistics stats;
int len, i;
os_memset(&stats, 0, sizeof(TCuCommon_RxDataFilteringStatistics));
wpa_printf(MSG_DEBUG,"Rx Data Filter Statistics command");
ret = wpa_driver_tista_driver_rx_data_filter_statistics( priv, &stats );
if( ret == 0 ) {
ret = snprintf(buf, buf_len, "RxFilterStat: %u", (u32)stats.unmatchedPacketsCount);
for(i=0; ( i < MAX_DATA_FILTERS ); i++) {
ret += snprintf(&buf[ret], buf_len-ret, " %u", (u32)stats.matchedPacketsCount[i]);
}
ret += snprintf(&buf[ret], buf_len-ret, "\n");
if (ret >= (int)buf_len) {
ret = -1;
}
}
}
else if( os_strncasecmp(cmd, "rxfilter-add", 12) == 0 ) {
TRxDataFilterRequest dfreq;
char *cp = cmd + 12;
char *endp;
int type;
if (*cp != '\0') {
type = (int)strtol(cp, &endp, 0);
if (endp != cp) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Add [%d] command", type);
ret = prepare_filter_struct( priv, type, &dfreq );
if( ret == 0 ) {
ret = wpa_driver_tista_driver_rx_data_filter( priv, &dfreq, 1 );
}
}
}
}
else if( os_strncasecmp(cmd, "rxfilter-remove",15) == 0 ) {
TRxDataFilterRequest dfreq;
char *cp = cmd + 15;
char *endp;
int type;
if (*cp != '\0') {
type = (int)strtol(cp, &endp, 0);
if (endp != cp) {
wpa_printf(MSG_DEBUG,"Rx Data Filter remove [%d] command", type);
ret = prepare_filter_struct( priv, type, &dfreq );
if( ret == 0 ) {
ret = wpa_driver_tista_driver_rx_data_filter( priv, &dfreq, 0 );
}
}
}
}
else {
wpa_printf(MSG_DEBUG,"Unsupported command");
}
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;
}
/*-----------------------------------------------------------------------------
Routine Name: wpa_driver_tista_set_probe_req_ie
Routine Description: set probe request ie for WSC mode change
Arguments:
priv - pointer to private data structure
ies - probe_req_ie data
ies_len - ie data length
Return Value: actual buffer length - success, -1 - failure
-----------------------------------------------------------------------------*/
static int wpa_driver_tista_set_probe_req_ie(void *priv, const u8* ies, size_t ies_len)
{
struct wpa_driver_ti_data *drv = (struct wpa_driver_ti_data *)priv;
#ifdef CONFIG_WPS
TWscMode WscModeStruct;
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
if ((!ies || (0 == ies_len)) && (NULL == drv->probe_req_ie)) {
return 0;
}
if (ies && drv->probe_req_ie) {
size_t len = wpabuf_len(drv->probe_req_ie);
u8* data = (u8*)wpabuf_head(drv->probe_req_ie);
if ((ies_len == len) && (0 == os_memcmp(ies, data, ies_len))) {
return 0;
}
}
os_memset(&WscModeStruct, 0, sizeof(TWscMode));
if (!ies || (0 == ies_len)) {
WscModeStruct.WSCMode = TIWLN_SIMPLE_CONFIG_OFF;
} else {
const size_t head_len = 6; /* probeReqIe head: dd xx 00 50 f2 04 */
u8 *pos, *end;
u16 password_id = 0;
size_t min_len = 0;
pos = (u8*)ies + head_len; /* Find the WSC mode in probe_req_ie by password_id */
end = (u8*)ies + ies_len;
while (pos < end) {
if (ATTR_DEV_PASSWORD_ID == WPA_GET_BE16(pos)) {
password_id = WPA_GET_BE16(pos+4);
break;
}
pos += (4 + WPA_GET_BE16(pos+2));
}
WscModeStruct.WSCMode = (DEV_PW_PUSHBUTTON == password_id)?TIWLN_SIMPLE_CONFIG_PBC_METHOD:TIWLN_SIMPLE_CONFIG_PIN_METHOD;
pos = (u8*)ies + head_len;
min_len = ies_len - head_len;
if (min_len > sizeof(WscModeStruct.probeReqWSCIE)) {
min_len = sizeof(WscModeStruct.probeReqWSCIE);
}
os_memcpy(WscModeStruct.probeReqWSCIE, pos, min_len);
}
wpa_hexdump(MSG_DEBUG, "SetProbeReqIe:WscModeStruct", (u8*)&WscModeStruct, sizeof(TWscMode));
if(0 == wpa_driver_tista_private_send(priv, SITE_MGR_SIMPLE_CONFIG_MODE, (void*)&WscModeStruct, sizeof(TWscMode), NULL, 0)) {
/* Update the cached probe req ie */
wpabuf_free(drv->probe_req_ie);
drv->probe_req_ie = NULL;
if (ies && ies_len) {
drv->probe_req_ie = wpabuf_alloc(sizeof(WscModeStruct.probeReqWSCIE));
if (drv->probe_req_ie) {
wpabuf_put_data(drv->probe_req_ie, ies, ies_len);
}
}
} else {
wpa_printf(MSG_ERROR, "ERROR - Failed to set wsc mode!");
return -1;
}
#endif
return 0;
}
static int wpa_driver_tista_get_bssid(void *priv, u8 *bssid)
{
struct wpa_driver_ti_data *drv = priv;
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
return wpa_driver_wext_get_bssid(drv->wext, bssid);
}
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);
}
