diff options
Diffstat (limited to 'wilink_6_1/stad/src/Connection_Managment/rsn.c')
-rw-r--r-- | wilink_6_1/stad/src/Connection_Managment/rsn.c | 2237 |
1 files changed, 2237 insertions, 0 deletions
diff --git a/wilink_6_1/stad/src/Connection_Managment/rsn.c b/wilink_6_1/stad/src/Connection_Managment/rsn.c new file mode 100644 index 0000000..7565757 --- /dev/null +++ b/wilink_6_1/stad/src/Connection_Managment/rsn.c @@ -0,0 +1,2237 @@ +/* + * rsn.c + * + * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name Texas Instruments nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +/** \file rsn.c + * \brief 802.11 rsniation SM source + * + * \see rsnSM.h + */ + + +/***************************************************************************/ +/* */ +/* MODULE: rsnSM.c */ +/* PURPOSE: 802.11 rsniation SM source */ +/* */ +/***************************************************************************/ + +#define __FILE_ID__ FILE_ID_40 +#include "osApi.h" +#include "paramOut.h" +#include "timer.h" +#include "report.h" +#include "DataCtrl_Api.h" +#include "siteMgrApi.h" +#include "smeApi.h" +#include "mainSecSm.h" +#include "admCtrl.h" +#include "rsnApi.h" +#include "rsn.h" +#include "keyParser.h" +#include "EvHandler.h" +#include "TI_IPC_Api.h" +#include "sme.h" +#include "apConn.h" +#include "802_11Defs.h" +#include "externalSec.h" +#include "connApi.h" +#ifdef XCC_MODULE_INCLUDED +#include "admCtrlWpa.h" +#include "XCCMngr.h" +#include "admCtrlXCC.h" +#endif +#include "TWDriver.h" +#include "DrvMainModules.h" +#include "PowerMgr_API.h" + +/* Constants */ + +/* Enumerations */ + +/* Typedefs */ + +/* Structures */ + +/* External data definitions */ + +/* External functions definitions */ + +/* Global variables */ + +/* Local function prototypes */ +TI_STATUS rsn_sendKeysNotSet(rsn_t *pRsn); +void rsn_pairwiseReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured); +void rsn_groupReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured); +void rsn_micFailureReportTimeout (TI_HANDLE hRsn, TI_BOOL bTwdInitOccured); +static rsn_siteBanEntry_t * findEntryForInsert(TI_HANDLE hRsn); +static rsn_siteBanEntry_t * findBannedSiteAndCleanup(TI_HANDLE hRsn, TMacAddr siteBssid); + +/* functions */ + +/** +* +* rsn_Create - allocate memory for rsniation SM +* +* \b Description: +* +* Allocate memory for rsniation SM. \n +* Allocates memory for Rsniation context. \n +* Allocates memory for rsniation timer. \n +* Allocates memory for rsniation SM matrix. \n +* +* \b ARGS: +* +* I - hOs - OS context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_mainSecKeysOnlyStop() +*/ +TI_HANDLE rsn_create(TI_HANDLE hOs) +{ + rsn_t *pRsn; + + /* allocate rsniation context memory */ + pRsn = (rsn_t*)os_memoryAlloc (hOs, sizeof(rsn_t)); + if (pRsn == NULL) + { + return NULL; + } + + os_memoryZero (hOs, pRsn, sizeof(rsn_t)); + + /* create admission control */ + pRsn->pAdmCtrl = admCtrl_create (hOs); + if (pRsn->pAdmCtrl == NULL) + { + os_memoryFree (hOs, pRsn, sizeof(rsn_t)); + return NULL; + } + + /* create main security SM */ + pRsn->pMainSecSm = mainSec_create (hOs); + if (pRsn->pMainSecSm == NULL) + { + admCtrl_unload (pRsn->pAdmCtrl); + os_memoryFree (hOs, pRsn, sizeof(rsn_t)); + return NULL; + } + + pRsn->pKeyParser = pRsn->pMainSecSm->pKeyParser; + + pRsn->hOs = hOs; + + return pRsn; +} + + +/** +* +* rsn_Unload - unload rsniation SM from memory +* +* \b Description: +* +* Unload rsniation SM from memory +* +* \b ARGS: +* +* I - hRsn - rsniation SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_mainSecKeysOnlyStop() +*/ +TI_STATUS rsn_unload (TI_HANDLE hRsn) +{ + rsn_t *pRsn; + TI_STATUS status; + + if (hRsn == NULL) + { + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + if (pRsn->hMicFailureReportWaitTimer) + { + tmr_DestroyTimer (pRsn->hMicFailureReportWaitTimer); + } + if (pRsn->hMicFailureGroupReKeyTimer) + { + tmr_DestroyTimer (pRsn->hMicFailureGroupReKeyTimer); + } + if (pRsn->hMicFailurePairwiseReKeyTimer) + { + tmr_DestroyTimer (pRsn->hMicFailurePairwiseReKeyTimer); + } + + status = admCtrl_unload (pRsn->pAdmCtrl); + status = mainSec_unload (pRsn->pMainSecSm); + + os_memoryFree (pRsn->hOs, hRsn, sizeof(rsn_t)); + + return status; +} + + +/** +* +* rsn_init - Init module +* +* \b Description: +* +* Init module handles and variables. +* +* \b RETURNS: +* +* void +* +* \sa rsn_Create, rsn_Unload +*/ +void rsn_init (TStadHandlesList *pStadHandles) +{ + rsn_t *pRsn = (rsn_t*)(pStadHandles->hRsn); + + pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_FALSE; + pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_FALSE; + pRsn->PrivacyOptionImplemented = TI_TRUE; + + pRsn->hTxCtrl = pStadHandles->hTxCtrl; + pRsn->hRx = pStadHandles->hRxData; + pRsn->hConn = pStadHandles->hConn; + pRsn->hTWD = pStadHandles->hTWD; + pRsn->hCtrlData = pStadHandles->hCtrlData; + pRsn->hSiteMgr = pStadHandles->hSiteMgr; + pRsn->hReport = pStadHandles->hReport; + pRsn->hOs = pStadHandles->hOs; + pRsn->hXCCMngr = pStadHandles->hXCCMngr; + pRsn->hEvHandler= pStadHandles->hEvHandler; + pRsn->hSmeSm = pStadHandles->hSme; + pRsn->hAPConn = pStadHandles->hAPConnection; + pRsn->hMlme = pStadHandles->hMlmeSm; + pRsn->hPowerMgr = pStadHandles->hPowerMgr; + pRsn->hTimer = pStadHandles->hTimer; + pRsn->hCurrBss = pStadHandles->hCurrBss; + + pRsn->setPaeConfig = rsn_setPaeConfig; + pRsn->getNetworkMode = rsn_getNetworkMode; + pRsn->setKey = rsn_setKey; + pRsn->removeKey = rsn_removeKey; + pRsn->reportStatus = rsn_reportStatus; + pRsn->setDefaultKeyId = rsn_setDefaultKeyId; + pRsn->defaultKeysOn = TI_TRUE; + pRsn->eapType = OS_EAP_TYPE_NONE; + pRsn->numOfBannedSites = 0; +} + + +TI_STATUS rsn_SetDefaults (TI_HANDLE hRsn, TRsnInitParams *pInitParam) +{ + rsn_t *pRsn = (rsn_t*)hRsn; + TI_UINT8 keyIndex; + TI_STATUS status; + + /* Create the module's timers */ + pRsn->hMicFailureReportWaitTimer = tmr_CreateTimer (pRsn->hTimer); + if (pRsn->hMicFailureReportWaitTimer == NULL) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_SetDefaults(): Failed to create hMicFailureReportWaitTimer!\n"); + return TI_NOK; + } + pRsn->hMicFailureGroupReKeyTimer = tmr_CreateTimer (pRsn->hTimer); + if (pRsn->hMicFailureGroupReKeyTimer == NULL) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_SetDefaults(): Failed to create hMicFailureGroupReKeyTimer!\n"); + return TI_NOK; + } + + /* Configure the RSN external mode */ + pRsn->bRsnExternalMode = pInitParam->bRsnExternalMode; + + pRsn->hMicFailurePairwiseReKeyTimer = tmr_CreateTimer (pRsn->hTimer); + if (pRsn->hMicFailurePairwiseReKeyTimer == NULL) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_SetDefaults(): Failed to create hMicFailurePairwiseReKeyTimer!\n"); + return TI_NOK; + } + + pRsn->bPairwiseMicFailureFilter = pInitParam->bPairwiseMicFailureFilter; + /* config the admission control with the authentication suite selected. + Admission control will configure the main security SM. */ + status = admCtrl_config (pRsn->pAdmCtrl, + pRsn->hMlme, + pRsn->hRx, + pRsn->hReport, + pRsn->hOs, + pRsn, + pRsn->hXCCMngr, + pRsn->hPowerMgr, + pRsn->hEvHandler, + pRsn->hTimer, + pRsn->hCurrBss, + pInitParam); + + if (status != TI_OK) + { + return status; + } + + /* Configure keys from registry */ + if (pInitParam->privacyOn) + { + pRsn->wepStaticKey = TI_TRUE; + } + + pRsn->defaultKeyId = pInitParam->defaultKeyId; + for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) + { + os_memoryCopy (pRsn->hOs, &pRsn->keys[keyIndex], &pInitParam->keys[keyIndex], sizeof(TSecurityKeys)); + if (pRsn->keys[keyIndex].keyType != KEY_NULL) + { + pRsn->wepDefaultKeys[keyIndex] = TI_TRUE; + } + pRsn->keys_en [keyIndex] = TI_FALSE; + } + + return status; +} + + +/** +* +* rsn_reconfig - re-configure a rsniation +* +* \b Description: +* +* Re-configure rsniation +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Create, rsn_Unload +*/ +TI_STATUS rsn_reconfig (TI_HANDLE hRsn) +{ + rsn_t *pRsn = (rsn_t *)hRsn; + TI_UINT8 keyIndex; + + /* Mark all keys as removed */ + for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) + pRsn->keys_en [keyIndex] = TI_FALSE; + + return TI_OK; +} + + +/** +* +* rsn_setDefaultKeys - +* +* \b Description: +* +* +* +* \b ARGS: +* +* I - hRsn - Rsn SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Stop, rsn_Recv +*/ +TI_STATUS rsn_setDefaultKeys(rsn_t *pRsn) +{ + TI_STATUS status = TI_OK; + TTwdParamInfo tTwdParam; + TI_UINT8 keyIndex; + + for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) + { + /* Set the WEP key to the HAL */ + if (pRsn->wepDefaultKeys[keyIndex] /*pRsn->keys[keyIndex].encLen>0*/) + { + /* Change key type to WEP-key before setting*/ + pRsn->keys[keyIndex].keyType = KEY_WEP; + + status = pRsn->pMainSecSm->setKey (pRsn->pMainSecSm, &pRsn->keys[keyIndex]); + + if (status != TI_OK) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_ERROR, "RSN: Setting key #%d failed \n", keyIndex); + return status; + } + } + } + + /* Now we configure default key ID to the HAL */ + if (pRsn->defaultKeyId < MAX_KEYS_NUM) + { + tTwdParam.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID; + tTwdParam.content.configureCmdCBParams.pCb = &pRsn->defaultKeyId; + tTwdParam.content.configureCmdCBParams.fCb = NULL; + tTwdParam.content.configureCmdCBParams.hCb = NULL; + status = TWD_SetParam (pRsn->hTWD, &tTwdParam); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: default key ID =%d \n", pRsn->defaultKeyId); + } + + return status; +} + + +/** +* +* rsn_Start - Start event for the rsniation SM +* +* \b Description: +* +* Start event for the rsniation SM +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Stop, rsn_Recv +*/ +TI_STATUS rsn_start(TI_HANDLE hRsn) +{ + TI_STATUS status; + rsn_t *pRsn; + ECipherSuite suite; + EExternalAuthMode extAuthMode; + TTwdParamInfo tTwdParam; + + pRsn = (rsn_t*)hRsn; + + if (pRsn == NULL) + { + return TI_NOK; + } + + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_start ...\n"); + pRsn->rsnStartedTs = os_timeStampMs (pRsn->hOs); + + status = pRsn->pMainSecSm->start (pRsn->pMainSecSm); + /* Set keys that need to be set */ + pRsn->defaultKeysOn = TI_FALSE; + pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &suite); + pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &extAuthMode); + + if (pRsn->wepStaticKey && ( (suite == TWD_CIPHER_WEP) || (suite == TWD_CIPHER_CKIP) ) ) + { /* set default WEP keys */ + status = rsn_sendKeysNotSet (pRsn); + pRsn->eapType = OS_EAP_TYPE_NONE; + } + else if (suite == TWD_CIPHER_NONE && extAuthMode != RSN_EXT_AUTH_MODE_OPEN) + { /* remove previously WEP key for SHARED */ + pRsn->wepStaticKey = TI_FALSE; + status = rsn_removedDefKeys (pRsn); + + /* Set None to HAL */ + tTwdParam.paramType = TWD_RSN_SECURITY_MODE_PARAM_ID; + tTwdParam.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_NONE; + status = TWD_SetParam (pRsn->hTWD, &tTwdParam); + + } + else if (suite==TWD_CIPHER_NONE) + { + pRsn->eapType = OS_EAP_TYPE_NONE; + } + + return status; +} + + +TI_STATUS rsn_sendKeysNotSet(rsn_t *pRsn) +{ + TI_UINT8 keyIndex; + OS_802_11_KEY rsnOsKey; + TI_STATUS status = TI_OK; + + for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) + { + if (pRsn->wepDefaultKeys[keyIndex]) + { + rsnOsKey.KeyIndex = pRsn->keys[keyIndex].keyIndex; + rsnOsKey.KeyLength = pRsn->keys[keyIndex].encLen; + rsnOsKey.Length = sizeof(rsnOsKey); + + /* Change key type to WEP-key before setting*/ + pRsn->keys[keyIndex].keyType = KEY_WEP; + + MAC_COPY (rsnOsKey.BSSID, pRsn->keys[keyIndex].macAddress); + os_memoryCopy (pRsn->hOs, &rsnOsKey.KeyRSC, + (void *)pRsn->keys[keyIndex].keyRsc, + KEY_RSC_LEN); + os_memoryCopy (pRsn->hOs, rsnOsKey.KeyMaterial, + (void *)pRsn->keys[keyIndex].encKey, + MAX_KEY_LEN /*pRsn->keys[keyIndex].encLen*/); + + /* Set WEP transmit key mask on the default key */ + if (keyIndex == pRsn->defaultKeyId) + { + rsnOsKey.KeyIndex |= 0x80000000; + } + + status = pRsn->pKeyParser->recv (pRsn->pKeyParser, (TI_UINT8*)&rsnOsKey, sizeof(rsnOsKey)); + } + } + + return status; +} + + +TI_STATUS rsn_removedDefKeys (TI_HANDLE hRsn) +{ + TI_UINT8 keyIndex; + rsn_t *pRsn = (rsn_t*)hRsn; + + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removedDefKeys Enter \n"); + + for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) + { + TSecurityKeys key; + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removedDefKeys, Remove keyId=%d\n", keyIndex); + + pRsn->wepDefaultKeys[keyIndex] = TI_FALSE; + os_memoryCopy (pRsn->hOs, &key, &pRsn->keys[keyIndex], sizeof(TSecurityKeys)); + pRsn->removeKey (pRsn, &key); + + /* Set WEP transmit key mask on the default key */ + if (keyIndex == pRsn->defaultKeyId) + { + pRsn->defaultKeyId = 0; + } + } + + return TI_OK; +} + + +/** +* +* rsn_Stop - Stop event for the rsniation SM +* +* \b Description: +* +* Stop event for the rsniation SM +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Recv +*/ +TI_STATUS rsn_stop (TI_HANDLE hRsn, TI_BOOL removeKeys) +{ + TI_STATUS status; + rsn_t *pRsn; + TI_UINT8 keyIndex; + TSecurityKeys key; + + pRsn = (rsn_t*)hRsn; + + if (pRsn == NULL) + { + return TI_NOK; + } + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: calling STOP... removeKeys=%d\n", removeKeys); + + for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) + { + os_memoryCopy (pRsn->hOs, &key, &pRsn->keys[keyIndex], sizeof(TSecurityKeys)); + + if (!pRsn->wepDefaultKeys[keyIndex]) + { /* Remove only dynamic keys. Default keys are removed by calling: rsn_removedDefKeys() */ + TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_stop, Remove keyIndex=%d, key.keyIndex=%d\n",keyIndex, key.keyIndex); + + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)key.macAddress, 6); + + pRsn->removeKey (pRsn, &key); + } + + } + + tmr_StopTimer (pRsn->hMicFailureReportWaitTimer); + + /* Stop the pre-authentication timer in case we are disconnecting */ + tmr_StopTimer (pRsn->pAdmCtrl->hPreAuthTimerWpa2); + + status = pRsn->pMainSecSm->stop (pRsn->pMainSecSm); + + pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_FALSE; + pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_FALSE; + pRsn->defaultKeysOn = TI_TRUE; + + if (removeKeys) + { /* reset PMKID list if exist */ + pRsn->pAdmCtrl->resetPmkidList (pRsn->pAdmCtrl); + } + + return status; +} + +TI_STATUS rsn_getParamEncryptionStatus(TI_HANDLE hRsn, ECipherSuite *rsnStatus) +{ /* RSN_ENCRYPTION_STATUS_PARAM */ + rsn_t *pRsn = (rsn_t *)hRsn; + TI_STATUS status = TI_NOK; + + if ( (NULL == pRsn) || (NULL == rsnStatus) ) + { + return status; + } + status = pRsn->pAdmCtrl->getCipherSuite(pRsn->pAdmCtrl, rsnStatus); + return status; +} + +/** +* +* rsn_GetParam - Get a specific parameter from the rsniation SM +* +* \b Description: +* +* Get a specific parameter from the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_getParam(TI_HANDLE hRsn, void *param) +{ + rsn_t *pRsn = (rsn_t *)hRsn; + paramInfo_t *pParam = (paramInfo_t *)param; + TI_STATUS status = TI_OK; + + if ( (NULL == pRsn) || (NULL == pParam) ) + { + return TI_NOK; + } + + switch (pParam->paramType) + { + case RSN_PRIVACY_OPTION_IMPLEMENTED_PARAM: + pParam->content.rsnPrivacyOptionImplemented = TI_TRUE; + break; + + case RSN_KEY_PARAM: + pParam->content.pRsnKey = &pRsn->keys[pParam->content.pRsnKey->keyIndex]; + if (pParam->content.pRsnKey->keyIndex == pRsn->defaultKeyId) + { + pParam->content.pRsnKey->keyIndex |= 0x80000000; + TRACE1(pRsn->hReport, REPORT_SEVERITY_WARNING, "default Key: %d\n", pRsn->defaultKeyId); + } + break; + + case RSN_SECURITY_STATE_PARAM: + status = pRsn->pMainSecSm->getAuthState (pRsn->pMainSecSm, (TIWLN_SECURITY_STATE*)&(pParam->content.rsnAuthState)); + break; + + case RSN_ENCRYPTION_STATUS_PARAM: + status = pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &pParam->content.rsnEncryptionStatus); + break; + + case RSN_EXT_AUTHENTICATION_MODE: + status = pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &pParam->content.rsnExtAuthneticationMode); + break; + + case RSN_MIXED_MODE: + status = pRsn->pAdmCtrl->getMixedMode (pRsn->pAdmCtrl, &pParam->content.rsnMixedMode); + break; + + case RSN_AUTH_ENCR_CAPABILITY: + status = pRsn->pAdmCtrl->getAuthEncrCap(pRsn->pAdmCtrl, pParam->content.pRsnAuthEncrCapability); + break; + + case RSN_PMKID_LIST: + pParam->content.rsnPMKIDList.Length = pParam->paramLength; + status = pRsn->pAdmCtrl->getPmkidList (pRsn->pAdmCtrl, &pParam->content.rsnPMKIDList); + pParam->paramLength = pParam->content.rsnPMKIDList.Length + 2 * sizeof(TI_UINT32); + break; + + case RSN_PRE_AUTH_STATUS: + { + TI_UINT8 cacheIndex; + + pParam->content.rsnPreAuthStatus = pRsn->pAdmCtrl->getPreAuthStatus (pRsn->pAdmCtrl, &pParam->content.rsnApMac, &cacheIndex); + } + break; + + case RSN_WPA_PROMOTE_AVAILABLE_OPTIONS: + status = pRsn->pAdmCtrl->getWPAMixedModeSupport (pRsn->pAdmCtrl, &pParam->content.rsnWPAMixedModeSupport); + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get WPA Mixed MODE support %d \n",pParam->content.rsnWPAMixedModeSupport); + break; + + case RSN_WPA_PROMOTE_OPTIONS: + status = pRsn->pAdmCtrl->getPromoteFlags (pRsn->pAdmCtrl, + &pParam->content.rsnWPAPromoteFlags); + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get WPA promote flags %d \n",pParam->content.rsnWPAPromoteFlags); + + break; + +#ifdef XCC_MODULE_INCLUDED + case RSN_XCC_NETWORK_EAP: + status = pRsn->pAdmCtrl->getNetworkEap (pRsn->pAdmCtrl, &pParam->content.networkEap); + break; +#endif + case RSN_EAP_TYPE: + pParam->content.eapType = pRsn->eapType; + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get RSN_EAP_TYPE eapType %d \n", pParam->content.eapType); + break; + + case WPA_801_1X_AKM_EXISTS: + + status = pRsn->pAdmCtrl->get802_1x_AkmExists(pRsn->pAdmCtrl, &pParam->content.wpa_802_1x_AkmExists); + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get WPA_801_1X_AKM_EXISTS %d \n", pParam->content.wpa_802_1x_AkmExists); + break; + + case RSN_DEFAULT_KEY_ID: + pParam->content.rsnDefaultKeyID = pRsn->defaultKeyId; + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get RSN_DEFAULT_KEY_ID %d \n", pParam->content.rsnDefaultKeyID); + break; + + default: + return TI_NOK; + } + + return status; +} + + +/** +* +* rsn_SetParam - Set a specific parameter to the rsniation SM +* +* \b Description: +* +* Set a specific parameter to the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_setParam (TI_HANDLE hRsn, void *param) +{ + rsn_t *pRsn; + paramInfo_t *pParam = (paramInfo_t*)param; + TTwdParamInfo tTwdParam; + TI_STATUS status = TI_OK; + + pRsn = (rsn_t*)hRsn; + + if ( (NULL == pRsn) || (NULL == pParam) ) + { + return TI_NOK; + } + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set rsn_setParam %X \n", pParam->paramType); + + switch (pParam->paramType) + { + + case RSN_DEFAULT_KEY_ID: + { + TI_UINT8 defKeyId, i; + + defKeyId = pParam->content.rsnDefaultKeyID; + + if(defKeyId >= MAX_KEYS_NUM) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "RSN: Error - the value of the default Key Id is incorrect \n"); + return TI_NOK; + } + + /* Clean transmit flag (1 in the bit31) in the previous default key */ + for(i = 0; i < MAX_KEYS_NUM; i++) + { + pRsn->keys[i].keyIndex &= 0x7FFFFFFF; + } + + /* Set the default key ID value in the RSN data structure */ + pRsn->defaultKeyId = defKeyId; + + /* Set the default key ID in the HAL */ + tTwdParam.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID; + tTwdParam.content.configureCmdCBParams.pCb = &pRsn->defaultKeyId; + tTwdParam.content.configureCmdCBParams.fCb = NULL; + tTwdParam.content.configureCmdCBParams.hCb = NULL; + status = TWD_SetParam (pRsn->hTWD, &tTwdParam); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: default key ID =%d \n", pRsn->defaultKeyId); + + sme_Restart (pRsn->hSmeSm); + break; + } + + case RSN_ADD_KEY_PARAM: + { + TI_UINT8 keyIndex, i = 0; + ECipherSuite cipherSuite; + + status = pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &cipherSuite); + if (status !=TI_OK) + { + return status; + } + + TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_ADD_KEY_PARAM KeyIndex %x , keyLength=%d\n", pParam->content.rsnOsKey.KeyIndex,pParam->content.rsnOsKey.KeyLength); + keyIndex = (TI_UINT8)pParam->content.rsnOsKey.KeyIndex; + if (keyIndex >= MAX_KEYS_NUM) + { + return TI_NOK; + } + + status = pRsn->pKeyParser->recv (pRsn->pKeyParser, (TI_UINT8*)&pParam->content.rsnOsKey, sizeof(pParam->content.rsnOsKey)); + + if (status != TI_OK) + { +TRACE1(pRsn->hReport, REPORT_SEVERITY_WARNING, ": pRsn->pKeyParser->recv satus returned with status=%x. returning with NOK\n", status); + return TI_NOK; + } + + /* If the Key is not BAD, it may be that WEP key is sent before WEP status is set, + save the key, and set it later at rsn_start */ + + /* If default Key not cleaned by calling rsn_removedDefKeys for keyIndex, Clean it */ + if (pRsn->wepDefaultKeys[keyIndex] == TI_TRUE) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "Set RSN_ADD_KEY_PARAM KeyIndex %x\n", keyIndex); + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "Set RSN_ADD_KEY_PARAM wepDefaultKeys=%d\n", pRsn->wepDefaultKeys[keyIndex]); + + pRsn->wepDefaultKeys[keyIndex] = TI_FALSE; + + } + + pRsn->keys[keyIndex].keyIndex = pParam->content.rsnOsKey.KeyIndex; + pRsn->keys[keyIndex].encLen = pParam->content.rsnOsKey.KeyLength; + MAC_COPY (pRsn->keys[keyIndex].macAddress, pParam->content.rsnOsKey.BSSID); + os_memoryCopy (pRsn->hOs, (void *)pRsn->keys[keyIndex].keyRsc, (TI_UINT8*)&(pParam->content.rsnOsKey.KeyRSC), KEY_RSC_LEN); + os_memoryCopy (pRsn->hOs, (void *)pRsn->keys[keyIndex].encKey, pParam->content.rsnOsKey.KeyMaterial, MAX_KEY_LEN); + + /* Process the transmit flag (31-st bit of keyIndex). */ + /* If the added key has the TX bit set to TI_TRUE (i.e. the key */ + /* is the new transmit key (default key), update */ + /* RSN data def.key Id and clean this bit in all other keys */ + if (pParam->content.rsnOsKey.KeyIndex & 0x80000000) + { + pRsn->defaultKeyId = keyIndex; + + for (i = 0; i < MAX_KEYS_NUM; i ++) + { + if (i != keyIndex) + { + pRsn->keys[i].keyIndex &= 0x7FFFFFFF; + } + } + } + + if (pRsn->defaultKeysOn) + { /* This is a WEP default key */ + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN_ADD_KEY_PARAM, Default key configured - keyIndex=%d-TI_TRUE\n", keyIndex); + + pRsn->wepDefaultKeys[keyIndex] = TI_TRUE; + pRsn->wepStaticKey = TI_TRUE; + status = TI_OK; + } + break; + } + case RSN_REMOVE_KEY_PARAM: + { + TI_UINT8 keyIndex; + ECipherSuite cipherSuite; + + status = pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &cipherSuite); + if (status !=TI_OK) + { + return status; + } + /*if (cipherSuite == RSN_CIPHER_NONE) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "RSN: Error Remove Wep/Key when no encryption \n"); + return TI_NOK; + }*/ + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_REMOVE_KEY_PARAM KeyIndex %x \n", pParam->content.rsnOsKey.KeyIndex); + keyIndex = (TI_UINT8)pParam->content.rsnOsKey.KeyIndex; + if (keyIndex >= MAX_KEYS_NUM) + { + return TI_NOK; + } + + status = pRsn->pKeyParser->remove (pRsn->pKeyParser, + (TI_UINT8*)&pParam->content.rsnOsKey, + sizeof(pParam->content.rsnOsKey)); + + if (status == TI_OK) + { + pRsn->keys[keyIndex].keyType = KEY_NULL; + pRsn->keys[keyIndex].keyIndex &= 0x000000FF; + } + + break; + } + + case RSN_ENCRYPTION_STATUS_PARAM: + { + ECipherSuite cipherSuite; + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_ENCRYPTION_STATUS_PARAM rsnEncryptionStatus %d \n", pParam->content.rsnEncryptionStatus); + + pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &cipherSuite); + if (cipherSuite != pParam->content.rsnEncryptionStatus) + { + status = pRsn->pAdmCtrl->setUcastSuite (pRsn->pAdmCtrl, pParam->content.rsnEncryptionStatus); + status = pRsn->pAdmCtrl->setBcastSuite (pRsn->pAdmCtrl, pParam->content.rsnEncryptionStatus); + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, " status = %d \n", status); + } + pRsn->defaultKeysOn = TI_TRUE; + } + break; + + case RSN_EXT_AUTHENTICATION_MODE: + { + EExternalAuthMode extAuthMode; + + pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &extAuthMode); + if (pParam->content.rsnExtAuthneticationMode!=extAuthMode) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_EXT_AUTHENTICATION_MODE rsnExtAuthneticationMode %d \n", pParam->content.rsnExtAuthneticationMode); + + /* +TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: remove all Keys\n"); + + for (keyIndex=0; keyIndex<MAX_KEYS_NUM; keyIndex++) + { + os_memoryCopy(pRsn->hOs, &key, &pRsn->keys[keyIndex], sizeof(TSecurityKeys)); + pRsn->removeKey(pRsn, &key); + + }*/ + + status = pRsn->pAdmCtrl->setExtAuthMode (pRsn->pAdmCtrl, pParam->content.rsnExtAuthneticationMode); + } + pRsn->defaultKeysOn = TI_TRUE; + } + break; + +#ifdef XCC_MODULE_INCLUDED + case RSN_XCC_NETWORK_EAP: + { + OS_XCC_NETWORK_EAP networkEap; + + pRsn->pAdmCtrl->getNetworkEap (pRsn->pAdmCtrl, &networkEap); + if (networkEap != pParam->content.networkEap) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_XCC_NETWORK_EAP networkEap %d \n", pParam->content.networkEap); + + status = pRsn->pAdmCtrl->setNetworkEap (pRsn->pAdmCtrl, pParam->content.networkEap); + if (status == TI_OK) + { + /*status = RE_SCAN_NEEDED;*/ + } + } + } + break; +#endif + case RSN_MIXED_MODE: + { + TI_BOOL mixedMode; + + pRsn->pAdmCtrl->getMixedMode (pRsn->pAdmCtrl, &mixedMode); + if (mixedMode!=pParam->content.rsnMixedMode) + { + status = pRsn->pAdmCtrl->setMixedMode (pRsn->pAdmCtrl, pParam->content.rsnMixedMode); + + TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_MIXED_MODE mixedMode %d, status=%d \n", pParam->content.rsnMixedMode, status); + } + break; + } + + case RSN_PMKID_LIST: + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_PMKID_LIST \n"); + + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8*)&pParam->content.rsnPMKIDList ,sizeof(OS_802_11_PMKID)); + status = pRsn->pAdmCtrl->setPmkidList (pRsn->pAdmCtrl, + &pParam->content.rsnPMKIDList); + if(status == TI_OK) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_PMKID_LIST: %d PMKID entries has been added to the cache.\n", pParam->content.rsnPMKIDList.BSSIDInfoCount); + } + else + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_PMKID_LIST failure"); + } + break; + + case RSN_WPA_PROMOTE_OPTIONS: + status = pRsn->pAdmCtrl->setPromoteFlags (pRsn->pAdmCtrl, + pParam->content.rsnWPAPromoteFlags); + if(status == TI_OK) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set WPA promote options: %d \n", pParam->content.rsnWPAPromoteFlags); + } + else + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set WPA promote options failure"); + } + break; + + case RSN_EAP_TYPE: + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_EAP_TYPE eapType %d \n", pParam->content.eapType); + + pRsn->eapType = pParam->content.eapType; + pRsn->defaultKeysOn = TI_TRUE; + break; + + case RSN_SET_KEY_PARAM: + { + TSecurityKeys *pSecurityKey = pParam->content.pRsnKey; + TI_UINT32 keyIndex; + TI_UINT8 j=0; + + TRACE2(pRsn->hReport,REPORT_SEVERITY_INFORMATION,"RSN:Set RSN_SET_KEY_PARAM KeyIndex %x,keyLength=%d\n",pSecurityKey->keyIndex,pSecurityKey->encLen); + + if(pSecurityKey->keyIndex >= MAX_KEYS_NUM) + { + return TI_NOK; + } + + keyIndex = (TI_UINT8)pSecurityKey->keyIndex; + status = rsn_setKey (pRsn, pSecurityKey); /* send key to FW*/ + + if (status == TI_OK) + { + //os_memoryCopy(pKeyDerive->hOs,&pRsn->pKeyParser->pUcastKey/pBcastKey, pEncodedKey, sizeof(encodedKeyMaterial_t)); + } /* check this copy */ + + + /* If the Key is not BAD, it may be that WEP key is sent before WEP status is set, + save the key, and set it later at rsn_start */ + + pRsn->keys[keyIndex].keyIndex = pSecurityKey->keyIndex; + pRsn->keys[keyIndex].encLen = pSecurityKey->encLen; + MAC_COPY (pRsn->keys[keyIndex].macAddress, pSecurityKey->macAddress); + os_memoryCopy(pRsn->hOs,(void*)pRsn->keys[keyIndex].keyRsc, (TI_UINT8*)&(pSecurityKey->keyRsc), KEY_RSC_LEN); + os_memoryCopy (pRsn->hOs, (void *)pRsn->keys[keyIndex].encKey, (void*)pSecurityKey->encKey, MAX_KEY_LEN); + + /* Process the transmit flag (31-st bit of keyIndex). */ + /* If the added key has the TX bit set to TI_TRUE (i.e. the key */ + /* is the new transmit key (default key), update */ + /* RSN data def.key Id and clean this bit in all other keys */ + if (pSecurityKey->keyIndex & 0x80000000) + { + pRsn->defaultKeyId = keyIndex; + + for (j = 0; j < MAX_KEYS_NUM; j++) + { + if (j != keyIndex) + { + pRsn->keys[j].keyIndex &= 0x7FFFFFFF; + } + } + } + + if (pRsn->defaultKeysOn) + { /* This is a WEP default key */ + TRACE1(pRsn->hReport,REPORT_SEVERITY_INFORMATION, "RSN_SET_KEY_PARAM, Default key configured-keyIndex=%d-TI_TRUE\n", keyIndex); + + pRsn->wepDefaultKeys[keyIndex] = TI_TRUE; + pRsn->wepStaticKey = TI_TRUE; + status = TI_OK; + } + break; + } + + default: + return TI_NOK; + } + + return status; +} + + +/** +* +* rsn_eventRecv - Set a specific parameter to the rsniation SM +* +* \b Description: +* +* Set a specific parameter to the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_reportStatus (rsn_t *pRsn, TI_STATUS rsnStatus) +{ + TI_STATUS status = TI_OK; + paramInfo_t param; + EExternalAuthMode extAuthMode; + + if (pRsn == NULL) + { + return TI_NOK; + } + + if (rsnStatus == TI_OK) + { + /* set EAPOL encryption status according to authentication protocol */ + pRsn->rsnCompletedTs = os_timeStampMs (pRsn->hOs); + + status = pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &extAuthMode); + if (status != TI_OK) + { + return status; + } + + if (extAuthMode >= RSN_EXT_AUTH_MODE_WPA) + txCtrlParams_setEapolEncryptionStatus (pRsn->hTxCtrl, TI_TRUE); + else + txCtrlParams_setEapolEncryptionStatus (pRsn->hTxCtrl, TI_FALSE); + + /* set WEP invoked mode according to cipher suite */ + switch (pRsn->paeConfig.unicastSuite) + { + case TWD_CIPHER_NONE: + param.content.txDataCurrentPrivacyInvokedMode = TI_FALSE; + break; + + default: + param.content.txDataCurrentPrivacyInvokedMode = TI_TRUE; + break; + } + + txCtrlParams_setCurrentPrivacyInvokedMode(pRsn->hTxCtrl, param.content.txDataCurrentPrivacyInvokedMode); + /* The value of exclude unencrypted should be as privacy invoked */ + param.paramType = RX_DATA_EXCLUDE_UNENCRYPTED_PARAM; + rxData_setParam (pRsn->hRx, ¶m); + + param.paramType = RX_DATA_EXCLUDE_BROADCAST_UNENCRYPTED_PARAM; + if (pRsn->pAdmCtrl->mixedMode) + { /* do not exclude Broadcast packets */ + param.content.txDataCurrentPrivacyInvokedMode = TI_FALSE; + } + rxData_setParam (pRsn->hRx, ¶m); + } + + else + rsnStatus = (TI_STATUS)STATUS_SECURITY_FAILURE; + + status = conn_reportRsnStatus (pRsn->hConn, (mgmtStatus_e)rsnStatus); + + if (status!=TI_OK) + { + return status; + } + + if (rsnStatus == TI_OK) + { + EvHandlerSendEvent (pRsn->hEvHandler, IPC_EVENT_AUTH_SUCC, NULL, 0); + } + + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_reportStatus \n"); + + return TI_OK; +} + + +/** +* +* rsn_eventRecv - Set a specific parameter to the rsniation SM +* +* \b Description: +* +* Set a specific parameter to the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_setPaeConfig(rsn_t *pRsn, TRsnPaeConfig *pPaeConfig) +{ + TI_STATUS status; + mainSecInitData_t initData; + + if ( (NULL == pRsn) || (NULL == pPaeConfig) ) + { + return TI_NOK; + } + + TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Calling set PAE config..., unicastSuite = %d, broadcastSuite = %d \n", pPaeConfig->unicastSuite, pPaeConfig->broadcastSuite); + + os_memoryCopy(pRsn->hOs, &pRsn->paeConfig, pPaeConfig, sizeof(TRsnPaeConfig)); + + initData.pPaeConfig = &pRsn->paeConfig; + + status = mainSec_config (pRsn->pMainSecSm, + &initData, + pRsn, + pRsn->hReport, + pRsn->hOs, + pRsn->hCtrlData, + pRsn->hEvHandler, + pRsn->hConn, + pRsn->hTimer); + + return status; +} + + +/** +* +* rsn_eventRecv - Set a specific parameter to the rsniation SM +* +* \b Description: +* +* Set a specific parameter to the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_getNetworkMode(rsn_t *pRsn, ERsnNetworkMode *pNetMode) +{ + paramInfo_t param; + TI_STATUS status; + + param.paramType = CTRL_DATA_CURRENT_BSS_TYPE_PARAM; + + status = ctrlData_getParam (pRsn->hCtrlData, ¶m); + + if (status == TI_OK) + { + if (param.content.ctrlDataCurrentBssType == BSS_INFRASTRUCTURE) + { + *pNetMode = RSN_INFRASTRUCTURE; + } + else + { + *pNetMode = RSN_IBSS; + } + } + else + { + return TI_NOK; + } + + return TI_OK; +} + + +/** +* +* rsn_eventRecv - Set a specific parameter to the rsniation SM +* +* \b Description: +* +* Set a specific parameter to the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_evalSite(TI_HANDLE hRsn, TRsnData *pRsnData, TRsnSiteParams *pRsnSiteParams, TI_UINT32 *pMetric) +{ + + rsn_t *pRsn; + TI_STATUS status; + + if ( (NULL == pRsnData) || (NULL == hRsn) ) + { + *pMetric = 0; + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + if (rsn_isSiteBanned(hRsn, pRsnSiteParams->bssid) == TI_TRUE) + { + *pMetric = 0; + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site is banned!\n"); + return TI_NOK; + } + + status = pRsn->pAdmCtrl->evalSite (pRsn->pAdmCtrl, pRsnData, pRsnSiteParams, pMetric); + + TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": pMetric=%d status=%d\n", *pMetric, status); + + return status; +} + + +/** +* +* rsn_getInfoElement - +* +* \b Description: +* +* Get the RSN information element. +* +* \b ARGS: +* +* I - hRsn - Rsn SM context \n +* I/O - pRsnIe - Pointer to the return information element \n +* I/O - pRsnIeLen - Pointer to the returned IE's length \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa +*/ +TI_STATUS rsn_getInfoElement(TI_HANDLE hRsn, TI_UINT8 *pRsnIe, TI_UINT32 *pRsnIeLen) +{ + rsn_t *pRsn; + TI_STATUS status; + + if ( (NULL == hRsn) || (NULL == pRsnIe) || (NULL == pRsnIeLen) ) + { + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + status = pRsn->pAdmCtrl->getInfoElement (pRsn->pAdmCtrl, pRsnIe, pRsnIeLen); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_getInfoElement pRsnIeLen= %d\n",*pRsnIeLen); + + return status; +} + + +#ifdef XCC_MODULE_INCLUDED +/** +* +* rsn_getXCCExtendedInfoElement - +* +* \b Description: +* +* Get the Aironet information element. +* +* \b ARGS: +* +* I - hRsn - Rsn SM context \n +* I/O - pRsnIe - Pointer to the return information element \n +* I/O - pRsnIeLen - Pointer to the returned IE's length \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa +*/ +TI_STATUS rsn_getXCCExtendedInfoElement(TI_HANDLE hRsn, TI_UINT8 *pRsnIe, TI_UINT8 *pRsnIeLen) +{ + rsn_t *pRsn; + TI_STATUS status; + + if ( (NULL == hRsn) || (NULL == pRsnIe) || (NULL == pRsnIeLen) ) + { + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + status = admCtrlXCC_getInfoElement (pRsn->pAdmCtrl, pRsnIe, pRsnIeLen); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_getXCCExtendedInfoElement pRsnIeLen= %d\n",*pRsnIeLen); + + return status; +} +#endif + + +/** +* +* rsn_eventRecv - Set a specific parameter to the rsniation SM +* +* \b Description: +* +* Set a specific parameter to the rsniation SM. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pParam - Parameter \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa rsn_Start, rsn_Stop +*/ +TI_STATUS rsn_setSite(TI_HANDLE hRsn, TRsnData *pRsnData, TI_UINT8 *pAssocIe, TI_UINT8 *pAssocIeLen) +{ + rsn_t *pRsn; + TI_STATUS status; + + if ( (NULL == pRsnData) || (NULL == hRsn) ) + { + *pAssocIeLen = 0; + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + status = pRsn->pAdmCtrl->setSite (pRsn->pAdmCtrl, pRsnData, pAssocIe, pAssocIeLen); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_setSite ieLen= %d\n",pRsnData->ieLen); + return status; +} + + +TI_STATUS rsn_setKey (rsn_t *pRsn, TSecurityKeys *pKey) +{ + TTwdParamInfo tTwdParam; + TI_UINT8 keyIndex; + TI_BOOL macIsBroadcast = TI_FALSE; + TI_STATUS status = TI_OK; + + if (pRsn == NULL || pKey == NULL) + { + return TI_NOK; + } + + keyIndex = (TI_UINT8)pKey->keyIndex; + if (keyIndex >= MAX_KEYS_NUM) + { + return TI_NOK; + } + + if (pKey->keyType != KEY_NULL) + { + /* set the size to reserve for encryption to the tx */ + /* update this parameter only in accordance with pairwise key setting */ + if (!MAC_BROADCAST(pKey->macAddress)) + { + + /* set the size to reserve for encryption to the tx */ + switch (pKey->keyType) + { + case KEY_TKIP: + txCtrlParams_setEncryptionFieldSizes (pRsn->hTxCtrl, IV_FIELD_SIZE); + break; + case KEY_AES: + txCtrlParams_setEncryptionFieldSizes (pRsn->hTxCtrl, AES_AFTER_HEADER_FIELD_SIZE); + break; + case KEY_NULL: + case KEY_WEP: + case KEY_XCC: + default: + txCtrlParams_setEncryptionFieldSizes (pRsn->hTxCtrl, 0); + break; + } + + } + + + macIsBroadcast = MAC_BROADCAST (pKey->macAddress); + if ((pRsn->keys[keyIndex].keyType != KEY_NULL )&& + macIsBroadcast && !MAC_BROADCAST((pRsn->keys[keyIndex].macAddress))) + { /* In case a new Group key is set instead of a Unicast key, + first remove the UNIcast key from FW */ + rsn_removeKey(pRsn, &pRsn->keys[keyIndex]); + } + + pRsn->keys[keyIndex].keyType = pKey->keyType; + pRsn->keys[keyIndex].keyIndex = keyIndex; + + tTwdParam.paramType = TWD_RSN_KEY_ADD_PARAM_ID; + tTwdParam.content.configureCmdCBParams.pCb = (TI_UINT8*) pKey; + tTwdParam.content.configureCmdCBParams.fCb = NULL; + tTwdParam.content.configureCmdCBParams.hCb = NULL; + + if (macIsBroadcast) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setKey, Group ReKey timer started\n"); + tmr_StopTimer (pRsn->hMicFailureGroupReKeyTimer); + tmr_StartTimer (pRsn->hMicFailureGroupReKeyTimer, + rsn_groupReKeyTimeout, + (TI_HANDLE)pRsn, + RSN_MIC_FAILURE_RE_KEY_TIMEOUT, + TI_FALSE); + pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_TRUE; + } + else + { + if (pRsn->bPairwiseMicFailureFilter) /* the value of this flag is taken from registry */ + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setKey, Pairwise ReKey timer started\n"); + tmr_StopTimer (pRsn->hMicFailurePairwiseReKeyTimer); + tmr_StartTimer (pRsn->hMicFailurePairwiseReKeyTimer, + rsn_pairwiseReKeyTimeout, + (TI_HANDLE)pRsn, + RSN_MIC_FAILURE_RE_KEY_TIMEOUT, + TI_FALSE); + pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_TRUE; + } + } + + + /* Mark key as added */ + pRsn->keys_en [keyIndex] = TI_TRUE; + + status = TWD_SetParam (pRsn->hTWD, &tTwdParam); + } + + TRACE3(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setKey, KeyType=%d, KeyId = 0x%lx,encLen=0x%x\n", pKey->keyType,pKey->keyIndex, pKey->encLen); + + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nEncKey = "); + + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->encKey, pKey->encLen); + + if (pKey->keyType != KEY_WEP) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nMac address = "); + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->macAddress, MAC_ADDR_LEN); + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nRSC = "); + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->keyRsc, KEY_RSC_LEN); + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nMic RX = "); + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->micRxKey, MAX_KEY_LEN); + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nMic TX = "); + TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->micTxKey, MAX_KEY_LEN); + } + + return status; +} + + +TI_STATUS rsn_removeKey (rsn_t *pRsn, TSecurityKeys *pKey) +{ + TI_STATUS status = TI_OK; + TTwdParamInfo tTwdParam; + TI_UINT8 keyIndex; + + if (pRsn == NULL || pKey == NULL) + { + return TI_NOK; + } + + keyIndex = (TI_UINT8)pKey->keyIndex; + if (keyIndex >= MAX_KEYS_NUM) + { + return TI_NOK; + } + + TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removeKey Entry, keyType=%d, keyIndex=0x%lx\n",pKey->keyType, keyIndex); + + /* Now set to the RSN structure. */ + if (pKey->keyType != KEY_NULL && pRsn->keys_en[keyIndex]) + { + tTwdParam.paramType = TWD_RSN_KEY_REMOVE_PARAM_ID; + /*os_memoryCopy(pRsn->hOs, &tTwdParam.content.rsnKey, pKey, sizeof(TSecurityKeys));*/ + tTwdParam.content.configureCmdCBParams.pCb = (TI_UINT8*) pKey; + tTwdParam.content.configureCmdCBParams.fCb = NULL; + tTwdParam.content.configureCmdCBParams.hCb = NULL; + + /* If keyType is TKIP or AES, set the encLen to the KEY enc len - 16 */ + if (pKey->keyType == KEY_TKIP || pKey->keyType == KEY_AES) + { + pKey->encLen = 16; + if (keyIndex != 0) + { + const TI_UINT8 broadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; + /* + * if keyType is TKIP or AES, and the key index is broadcast, overwrite the MAC address as broadcast + * for removing the Broadcast key from the FW + */ + MAC_COPY (pKey->macAddress, broadcast); + } + } + else if (pKey->keyType == KEY_WEP) + { + /* In full driver we use only WEP default keys. To remove it we make sure that the MAC address is NULL */ + os_memoryZero(pRsn->hOs,(void*)pKey->macAddress,sizeof(TMacAddr)); + } + + + /* Mark key as deleted */ + pRsn->keys_en[keyIndex] = TI_FALSE; + + status = TWD_SetParam (pRsn->hTWD, &tTwdParam); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removeKey in whal, status =%d\n", status); + + /* clean the key flags*/ + pRsn->keys[keyIndex].keyIndex &= 0x000000FF; + pRsn->keys[keyIndex].keyType = KEY_NULL; + pRsn->keys[keyIndex].encLen = 0; + pRsn->wepDefaultKeys[keyIndex] = TI_FALSE; + } + + return status; +} + + +TI_STATUS rsn_setDefaultKeyId(rsn_t *pRsn, TI_UINT8 keyId) +{ + TI_STATUS status = TI_OK; + TTwdParamInfo tTwdParam; + + if (pRsn == NULL) + { + return TI_NOK; + } + pRsn->defaultKeyId = keyId; + /* Now we configure default key ID to the HAL */ + tTwdParam.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID; + tTwdParam.content.configureCmdCBParams.pCb = &keyId; + tTwdParam.content.configureCmdCBParams.fCb = NULL; + tTwdParam.content.configureCmdCBParams.hCb = NULL; + status = TWD_SetParam (pRsn->hTWD, &tTwdParam); + + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setDefaultKeyId, KeyId = 0x%lx\n", keyId); + return status; +} + + +TI_STATUS rsn_reportAuthFailure(TI_HANDLE hRsn, EAuthStatus authStatus) +{ + TI_STATUS status = TI_OK; + rsn_t *pRsn; + paramInfo_t param; + + if (hRsn==NULL) + { + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + /* Remove AP from candidate list for a specified amount of time */ + param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM; + status = ctrlData_getParam(pRsn->hCtrlData, ¶m); + if (status != TI_OK) + { +TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_reportAuthFailure, unable to retrieve BSSID \n"); + } + else + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "current station is banned from the roaming candidates list for %d Ms\n", RSN_AUTH_FAILURE_TIMEOUT); + + rsn_banSite(hRsn, param.content.ctrlDataCurrentBSSID, RSN_SITE_BAN_LEVEL_FULL, RSN_AUTH_FAILURE_TIMEOUT); + } + + +#ifdef XCC_MODULE_INCLUDED +TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "CALLING rougeAP, status= %d \n",authStatus); + status = XCCMngr_rogueApDetected (pRsn->hXCCMngr, authStatus); +#endif + TI_VOIDCAST(pRsn); + return status; +} + + +/****** +This is the CB function for mic failure event from the FW +*******/ +TI_STATUS rsn_reportMicFailure(TI_HANDLE hRsn, TI_UINT8 *pType, TI_UINT32 Length) +{ + rsn_t *pRsn = (rsn_t *) hRsn; + ERsnSiteBanLevel banLevel; + OS_802_11_AUTHENTICATION_REQUEST *request; + TI_UINT8 AuthBuf[sizeof(TI_UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)]; + paramInfo_t param; + TI_UINT8 failureType; + + failureType = *pType; + + if (((pRsn->paeConfig.unicastSuite == TWD_CIPHER_TKIP) && (failureType == KEY_TKIP_MIC_PAIRWISE)) || + ((pRsn->paeConfig.broadcastSuite == TWD_CIPHER_TKIP) && (failureType == KEY_TKIP_MIC_GROUP))) + { + /* check if the MIC failure is group and group key update */ + /* was performed during the last 3 seconds */ + if ((failureType == KEY_TKIP_MIC_GROUP) && + (pRsn->eGroupKeyUpdate == GROUP_KEY_UPDATE_TRUE)) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Group MIC failure ignored, key update was performed within the last 3 seconds.\n"); + return TI_OK; + } + + /* check if the MIC failure is pairwise and pairwise key update */ + /* was performed during the last 3 seconds */ + if ((failureType == KEY_TKIP_MIC_PAIRWISE) && + (pRsn->ePairwiseKeyUpdate == PAIRWISE_KEY_UPDATE_TRUE)) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Pairwise MIC failure ignored, key update was performed within the last 3 seconds.\n"); + return TI_OK; + } + + /* Prepare the Authentication Request */ + request = (OS_802_11_AUTHENTICATION_REQUEST *)(AuthBuf + sizeof(TI_UINT32)); + request->Length = sizeof(OS_802_11_AUTHENTICATION_REQUEST); + + param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM; + if (ctrlData_getParam (pRsn->hCtrlData, ¶m) != TI_OK) + { + return TI_NOK; + } + + /* Generate 802 Media specific indication event */ + *(TI_UINT32*)AuthBuf = os802_11StatusType_Authentication; + + MAC_COPY (request->BSSID, param.content.ctrlDataCurrentBSSID); + + if (failureType == KEY_TKIP_MIC_PAIRWISE) + { + request->Flags = OS_802_11_REQUEST_PAIRWISE_ERROR; + } + else + { + request->Flags = OS_802_11_REQUEST_GROUP_ERROR; + } + + EvHandlerSendEvent (pRsn->hEvHandler, + IPC_EVENT_MEDIA_SPECIFIC, + (TI_UINT8*)AuthBuf, + sizeof(TI_UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)); + /* Update and check the ban level to decide what actions need to take place */ + banLevel = rsn_banSite (hRsn, param.content.ctrlDataCurrentBSSID, RSN_SITE_BAN_LEVEL_HALF, RSN_MIC_FAILURE_TIMEOUT); + if (banLevel == RSN_SITE_BAN_LEVEL_FULL) + { + /* Site is banned so prepare to disconnect */ + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Second MIC failure, closing Rx port...\n"); + + param.paramType = RX_DATA_PORT_STATUS_PARAM; + param.content.rxDataPortStatus = CLOSE; + rxData_setParam(pRsn->hRx, ¶m); + + /* stop the mic failure Report timer and start a new one for 0.5 seconds */ + tmr_StopTimer (pRsn->hMicFailureReportWaitTimer); + apConn_setDeauthPacketReasonCode(pRsn->hAPConn, STATUS_MIC_FAILURE); + tmr_StartTimer (pRsn->hMicFailureReportWaitTimer, + rsn_micFailureReportTimeout, + (TI_HANDLE)pRsn, + RSN_MIC_FAILURE_REPORT_TIMEOUT, + TI_FALSE); + } + else + { + /* Site is only half banned so nothing needs to be done for now */ + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": First MIC failure, business as usual for now...\n"); + } + } + + return TI_OK; +} + + +void rsn_groupReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured) +{ + rsn_t *pRsn; + + pRsn = (rsn_t*)hRsn; + + if (pRsn == NULL) + { + return; + } + + pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_FALSE; +} + + +void rsn_pairwiseReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured) +{ + rsn_t *pRsn; + + pRsn = (rsn_t*)hRsn; + + if (pRsn == NULL) + { + return; + } + + pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_FALSE; +} + +void rsn_micFailureReportTimeout (TI_HANDLE hRsn, TI_BOOL bTwdInitOccured) +{ + rsn_t *pRsn; + + pRsn = (rsn_t*)hRsn; + + if (pRsn == NULL) + { + return; + } + + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": MIC failure reported, disassociating...\n"); + + apConn_reportRoamingEvent (pRsn->hAPConn, ROAMING_TRIGGER_SECURITY_ATTACK, NULL); +} + + +/** +* +* rsn_resetPMKIDList - +* +* \b Description: +* Cleans up the PMKID cache. +* Called when SSID is being changed. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +*/ + +TI_STATUS rsn_resetPMKIDList(TI_HANDLE hRsn) +{ + rsn_t *pRsn = (rsn_t*)hRsn; + + if (!pRsn) + return TI_NOK; + + return (pRsn->pAdmCtrl->resetPmkidList (pRsn->pAdmCtrl)); +} + + +void rsn_debugFunc(TI_HANDLE hRsn) +{ + rsn_t *pRsn; + + if (hRsn == NULL) + { + return; + } + pRsn = (rsn_t*)hRsn; + + WLAN_OS_REPORT(("rsnStartedTs, ts = %d\n", pRsn->rsnStartedTs)); + WLAN_OS_REPORT(("rsnCompletedTs, ts = %d\n", pRsn->rsnCompletedTs)); +} + + +/** +* +* rsn_startPreAuth - +* +* \b Description: +* +* Start pre-authentication on a list of given BSSIDs. +* +* \b ARGS: +* +* I - hRsn - Rsniation SM context \n +* I/O - pBssidList - list of BSSIDs that require Pre-Auth \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa +*/ +TI_STATUS rsn_startPreAuth(TI_HANDLE hRsn, TBssidList4PreAuth *pBssidList) +{ + rsn_t *pRsn; + TI_STATUS status; + + if ( (NULL == hRsn) || (NULL == pBssidList) ) + { + return TI_NOK; + } + + pRsn = (rsn_t*)hRsn; + + status = pRsn->pAdmCtrl->startPreAuth (pRsn->pAdmCtrl, pBssidList); + + TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_startPreAuth \n"); + + return status; +} + + +/** + * + * isSiteBanned - + * + * \b Description: + * + * Returns whether or not the site with the specified Bssid is banned or not. + * + * \b ARGS: + * + * I - hRsn - RSN module context \n + * I - siteBssid - The desired site's bssid \n + * + * \b RETURNS: + * + * TI_NOK iff site is banned. + * + */ +TI_BOOL rsn_isSiteBanned(TI_HANDLE hRsn, TMacAddr siteBssid) +{ + rsn_t * pRsn = (rsn_t *) hRsn; + rsn_siteBanEntry_t * entry; + + /* Check if site is in the list */ + if ((entry = findBannedSiteAndCleanup(hRsn, siteBssid)) == NULL) + { + return TI_FALSE; + } + + TRACE7(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X found with ban level %d...\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5], entry->banLevel); + + return (entry->banLevel == RSN_SITE_BAN_LEVEL_FULL); +} + + +/** + * + * rsn_PortStatus_Set API implementation- + * + * \b Description: + * + * set the status port according to the status flag + * + * \b ARGS: + * + * I - hRsn - RSN module context \n + * I - state - The status flag \n + * + * \b RETURNS: + * + * TI_STATUS. + * + */ +TI_STATUS rsn_setPortStatus(TI_HANDLE hRsn, TI_BOOL state) +{ + rsn_t *pRsn = (rsn_t *)hRsn; + struct externalSec_t *pExtSec; + + pExtSec = pRsn->pMainSecSm->pExternalSec; + pExtSec->bPortStatus = state; + return externalSec_rsnComplete(pExtSec); +} + + +/** + * + * rsn_banSite - + * + * \b Description: + * + * Bans the specified site from being associated to for the specified duration. + * If a ban level of WARNING is given and no previous ban was in effect the + * warning is marked down but other than that nothing happens. In case a previous + * warning (or ban of course) is still in effect + * + * \b ARGS: + * + * I - hRsn - RSN module context \n + * I - siteBssid - The desired site's bssid \n + * I - banLevel - The desired level of ban (Warning / Ban) + * I - durationMs - The duration of ban in milliseconds + * + * \b RETURNS: + * + * The level of ban (warning / banned). + * + */ +ERsnSiteBanLevel rsn_banSite(TI_HANDLE hRsn, TMacAddr siteBssid, ERsnSiteBanLevel banLevel, TI_UINT32 durationMs) +{ + rsn_t * pRsn = (rsn_t *) hRsn; + rsn_siteBanEntry_t * entry; + + /* Try finding the site in the list */ + if ((entry = findBannedSiteAndCleanup(hRsn, siteBssid)) != NULL) + { + /* Site found so a previous ban is still in effect */ + TRACE6(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X found and has been set to ban level full!\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5]); + + entry->banLevel = RSN_SITE_BAN_LEVEL_FULL; + } + else + { + /* Site doesn't appear in the list, so find a place to insert it */ + TRACE7(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X added with ban level %d!\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5], banLevel); + + entry = findEntryForInsert (hRsn); + + MAC_COPY (entry->siteBssid, siteBssid); + entry->banLevel = banLevel; + + pRsn->numOfBannedSites++; + } + + entry->banStartedMs = os_timeStampMs (pRsn->hOs); + entry->banDurationMs = durationMs; + + return entry->banLevel; +} + + +/** + * + * findEntryForInsert - + * + * \b Description: + * + * Returns a place to insert a new banned site. + * + * \b ARGS: + * + * I - hRsn - RSN module context \n + * + * \b RETURNS: + * + * A pointer to a suitable site entry. + * + */ +static rsn_siteBanEntry_t * findEntryForInsert(TI_HANDLE hRsn) +{ + rsn_t * pRsn = (rsn_t *) hRsn; + + /* In the extreme case that the list is full we overwrite an old entry */ + if (pRsn->numOfBannedSites == RSN_MAX_NUMBER_OF_BANNED_SITES) + { + TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, ": No room left to insert new banned site, overwriting old one!\n"); + + return &(pRsn->bannedSites[0]); + } + + return &(pRsn->bannedSites[pRsn->numOfBannedSites]); +} + + +/** + * + * findBannedSiteAndCleanup - + * + * \b Description: + * + * Searches the banned sites list for the desired site while cleaning up + * expired sites found along the way. + * + * Note that this function might change the structure of the banned sites + * list so old iterators into the list might be invalidated. + * + * \b ARGS: + * + * I - hRsn - RSN module context \n + * I - siteBssid - The desired site's bssid \n + * + * \b RETURNS: + * + * A pointer to the desired site's entry if found, + * NULL otherwise. + * + */ +static rsn_siteBanEntry_t * findBannedSiteAndCleanup(TI_HANDLE hRsn, TMacAddr siteBssid) +{ + rsn_t * pRsn = (rsn_t *) hRsn; + int iter; + + for (iter = 0; iter < pRsn->numOfBannedSites; iter++) + { + /* If this entry has expired we'd like to clean it up */ + if (os_timeStampMs(pRsn->hOs) - pRsn->bannedSites[iter].banStartedMs >= pRsn->bannedSites[iter].banDurationMs) + { + TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Found expired entry at index %d, cleaning it up...\n", iter); + + /* Replace this entry with the last one */ + pRsn->bannedSites[iter] = pRsn->bannedSites[pRsn->numOfBannedSites - 1]; + pRsn->numOfBannedSites--; + + /* we now repeat the iteration on this entry */ + iter--; + + continue; + } + + /* Is this the entry for the site we're looking for? */ + if (MAC_EQUAL (siteBssid, pRsn->bannedSites[iter].siteBssid)) + { + TRACE7(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X found at index %d!\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5], iter); + + return &pRsn->bannedSites[iter]; + } + } + + /* Entry not found... */ + TRACE6(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X not found...\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5]); + + return NULL; +} + +/** + * + * rsn_getPortStatus - + * + * \b Description: + * + * Returns the extrenalSec port status + * + * \b ARGS: + * + * pRsn - pointer to RSN module context \n + * + * \b RETURNS: + * + * TI_BOOL - the port status True = Open , False = Close + * + */ +TI_BOOL rsn_getPortStatus(rsn_t *pRsn) +{ + struct externalSec_t *pExtSec; + + pExtSec = pRsn->pMainSecSm->pExternalSec; + return pExtSec->bPortStatus; +} + + +#ifdef RSN_NOT_USED + +static TI_INT16 convertAscii2Unicode(TI_INT8* userPwd, TI_INT16 len) +{ + TI_INT16 i; + TI_INT8 unsiiPwd[MAX_PASSWD_LEN]; + + + for (i=0; i<len; i++) + { + unsiiPwd[i] = userPwd[i]; + } + for (i=0; i<len; i++) + { + userPwd[i*2] = unsiiPwd[i]; + userPwd[i*2+1] = 0; + } + return (TI_INT16)(len*2); +} + +#endif + +/*************************************************************************** +* rsn_reAuth * +**************************************************************************** +* DESCRIPTION: This is a callback function called by the whalWPA module whenever +* a broadcast TKIP key was configured to the FW. +* It does the following: +* - resets the ReAuth flag +* - stops the ReAuth timer +* - restore the PS state +* - Send RE_AUTH_COMPLETED event to the upper layer. +* +* INPUTS: hRsn - the object +* +* OUTPUT: None +* +* RETURNS: None +* +***************************************************************************/ +void rsn_reAuth(TI_HANDLE hRsn) +{ + rsn_t *pRsn; + + pRsn = (rsn_t*)hRsn; + + if (pRsn == NULL) + { + return; + } + + if (rxData_IsReAuthInProgress(pRsn->hRx)) + { + rxData_SetReAuthInProgress(pRsn->hRx, TI_FALSE); + rxData_StopReAuthActiveTimer(pRsn->hRx); + rxData_ReauthDisablePriority(pRsn->hRx); + EvHandlerSendEvent(pRsn->hEvHandler, IPC_EVENT_RE_AUTH_COMPLETED, NULL, 0); + } +} |