| /* |
| * mainKeysSm.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 mainKeySM.c |
| * \brief Main key state machine implementation. |
| * |
| * \see mainKeySM.h |
| */ |
| |
| /**************************************************************************** |
| * * |
| * MODULE: Main key SM * |
| * PURPOSE: Main key SM implmentation * |
| * * |
| ****************************************************************************/ |
| |
| #define __FILE_ID__ FILE_ID_36 |
| #include "osApi.h" |
| #include "paramOut.h" |
| #include "timer.h" |
| #include "report.h" |
| #include "rsn.h" |
| #include "rsnApi.h" |
| #include "smeApi.h" |
| #include "mainSecSm.h" |
| #include "keyParser.h" |
| #include "broadcastKeySM.h" |
| #include "unicastKeySM.h" |
| #include "mainKeysSm.h" |
| #include "mainKeysSmInternal.h" |
| #include "DataCtrl_Api.h" |
| #include "admCtrl.h" |
| #include "EvHandler.h" |
| #include "TI_IPC_Api.h" |
| #include "connApi.h" |
| |
| static TI_STATUS mainKeys_smEvent(struct _mainKeys_t *pMainKeys, TI_UINT8 event, void* pData); |
| |
| /** |
| * |
| * mainKeys_create |
| * |
| * \b Description: |
| * |
| * Allocate memory for the main security context, and create all the rest of the needed contexts. |
| * |
| * \b ARGS: |
| * |
| * I - hOs - OS handle for OS operations. |
| * |
| * \b RETURNS: |
| * |
| * pointer to main security context. If failed, returns NULL. |
| * |
| * \sa |
| */ |
| mainKeys_t* mainKeys_create(TI_HANDLE hOs) |
| { |
| mainKeys_t *pHandle; |
| TI_STATUS status; |
| |
| /* allocate association context memory */ |
| pHandle = (mainKeys_t*)os_memoryAlloc(hOs, sizeof(mainKeys_t)); |
| if (pHandle == NULL) |
| { |
| return NULL; |
| } |
| |
| os_memoryZero(hOs, pHandle, sizeof(mainKeys_t)); |
| |
| /* allocate memory for association state machine */ |
| status = fsm_Create(hOs, &pHandle->pMainKeysSm, MAIN_KEYS_NUM_STATES, MAIN_KEYS_NUM_EVENTS); |
| if (status != TI_OK) |
| { |
| os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); |
| return NULL; |
| } |
| |
| pHandle->pKeyParser = keyParser_create(hOs); |
| if (pHandle->pKeyParser == NULL) |
| { |
| fsm_Unload(hOs, pHandle->pMainKeysSm); |
| os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); |
| return NULL; |
| } |
| |
| pHandle->pBcastSm = broadcastKey_create(hOs); |
| if (pHandle->pBcastSm == NULL) |
| { |
| keyParser_unload(pHandle->pKeyParser); |
| fsm_Unload(hOs, pHandle->pMainKeysSm); |
| os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); |
| return NULL; |
| } |
| |
| pHandle->pUcastSm = unicastKey_create(hOs); |
| if (pHandle->pBcastSm == NULL) |
| { |
| broadcastKey_unload(pHandle->pBcastSm); |
| keyParser_unload(pHandle->pKeyParser); |
| fsm_Unload(hOs, pHandle->pMainKeysSm); |
| os_memoryFree(hOs, pHandle, sizeof(mainKeys_t)); |
| return NULL; |
| } |
| |
| pHandle->hOs = hOs; |
| |
| /* At first Timeout we will send MediaSpecific Event */ |
| /* At any other Timeout we will send the Timeout Event */ |
| |
| pHandle->mainKeysTimeoutCounter = TI_FALSE; |
| |
| return pHandle; |
| } |
| |
| /** |
| * |
| * mainKeys_config |
| * |
| * \b Description: |
| * |
| * Init main security state machine state machine |
| * |
| * \b ARGS: |
| * |
| * none |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa |
| */ |
| TI_STATUS mainKeys_config (mainKeys_t *pMainKeys, |
| TRsnPaeConfig *pPaeConfig, |
| void *pParent, |
| TI_HANDLE hReport, |
| TI_HANDLE hOs, |
| TI_HANDLE hCtrlData, |
| TI_HANDLE hEvHandler, |
| TI_HANDLE hConn, |
| TI_HANDLE hRsn, |
| TI_HANDLE hTimer) |
| |
| { |
| TI_STATUS status; |
| |
| /** Main key State Machine matrix */ |
| fsm_actionCell_t mainKeysSM_matrix[MAIN_KEYS_NUM_STATES][MAIN_KEYS_NUM_EVENTS] = |
| { |
| /* next state and actions for IDLE state */ |
| { {MAIN_KEYS_STATE_START, (fsm_Action_t)mainKeys_startIdle}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmUnexpected}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmUnexpected}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeySmUnexpected} |
| }, |
| |
| /* next state and actions for START state */ |
| { {MAIN_KEYS_STATE_START, (fsm_Action_t)mainKeySmUnexpected}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopStart}, |
| {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_START, (fsm_Action_t)mainKeys_smTimeOut} |
| }, |
| |
| /* next state and actions for UNICAST COMPLETE state */ |
| { {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeySmUnexpected}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopUcastComplete}, |
| {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeys_bcastCompleteUcastComplete}, |
| {MAIN_KEYS_STATE_UNICAST_COMPLETE, (fsm_Action_t)mainKeys_smTimeOut} |
| }, |
| |
| /* next state and actions for BROADCAST COMPLETE state */ |
| { {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeySmUnexpected}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopBcastComplete}, |
| {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeys_ucastCompleteBcastComplete}, |
| {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_BROADCAST_COMPLETE, (fsm_Action_t)mainKeys_smTimeOut} |
| }, |
| |
| /* next state and actions for COMPLETE state */ |
| { {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmUnexpected}, |
| {MAIN_KEYS_STATE_IDLE, (fsm_Action_t)mainKeys_stopComplete}, |
| {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmNop}, |
| {MAIN_KEYS_STATE_COMPLETE, (fsm_Action_t)mainKeySmUnexpected} |
| } |
| }; |
| |
| pMainKeys->hCtrlData = hCtrlData; |
| pMainKeys->hOs = hOs; |
| pMainKeys->hReport = hReport; |
| pMainKeys->hEvHandler = hEvHandler; |
| pMainKeys->hConn = hConn; |
| pMainKeys->hRsn = hRsn; |
| pMainKeys->hTimer = hTimer; |
| |
| pMainKeys->pParent = pParent; |
| pMainKeys->keysTimeout = MAIN_KEYS_TIMEOUT; |
| |
| pMainKeys->start = mainKeys_start; |
| pMainKeys->stop = mainKeys_stop; |
| pMainKeys->reportUcastStatus = mainKeys_reportUcastStatus; |
| pMainKeys->reportBcastStatus = mainKeys_reportBcastStatus; |
| pMainKeys->setKey = mainKeys_setKey; |
| pMainKeys->removeKey = mainKeys_removeKey; |
| pMainKeys->setDefaultKeyId = mainKeys_setDefaultKeyId; |
| pMainKeys->getSessionKey = mainKeys_getSessionKey; |
| |
| pMainKeys->currentState = MAIN_KEYS_STATE_IDLE; |
| |
| /* allocate OS timer memory */ |
| if (pMainKeys->hSessionTimer == NULL) |
| { |
| pMainKeys->hSessionTimer = tmr_CreateTimer (pMainKeys->hTimer); |
| if (pMainKeys->hSessionTimer == NULL) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "mainKeys_config(): Failed to create hSessionTimer!\n"); |
| return TI_NOK; |
| } |
| } |
| |
| status = fsm_Config(pMainKeys->pMainKeysSm, &mainKeysSM_matrix[0][0], |
| MAIN_KEYS_NUM_STATES, MAIN_KEYS_NUM_EVENTS, NULL, pMainKeys->hOs); |
| if (status != TI_OK) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error in configuring SM\n"); |
| return status; |
| } |
| |
| status = keyParser_config(pMainKeys->pKeyParser, |
| pPaeConfig, |
| pMainKeys->pUcastSm, |
| pMainKeys->pBcastSm, |
| pMainKeys, |
| hReport, |
| hOs, |
| hCtrlData); |
| if (status != TI_OK) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error in configuring key parser\n"); |
| return status; |
| } |
| |
| status = broadcastKey_config(pMainKeys->pBcastSm, pPaeConfig, pMainKeys, hReport, hOs); |
| if (status != TI_OK) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error in configuring broadcast key SM\n"); |
| return status; |
| } |
| |
| status = unicastKey_config(pMainKeys->pUcastSm, pPaeConfig, pMainKeys, hReport, hOs); |
| if (status != TI_OK) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error in configuring unicast key SM\n"); |
| return status; |
| } |
| |
| return TI_OK; |
| } |
| |
| /** |
| * |
| * mainKeys_config |
| * |
| * \b Description: |
| * |
| * Init main security state machine state machine |
| * |
| * \b ARGS: |
| * |
| * none |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa |
| */ |
| TI_STATUS mainKeys_unload(mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status; |
| |
| if (pMainKeys == NULL) |
| { |
| return TI_NOK; |
| } |
| |
| status = fsm_Unload(pMainKeys->hOs, pMainKeys->pMainKeysSm); |
| if (status != TI_OK) |
| { |
| /* report failure but don't stop... */ |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error releasing FSM memory \n"); |
| } |
| |
| if (pMainKeys->hSessionTimer) |
| { |
| tmr_DestroyTimer (pMainKeys->hSessionTimer); |
| } |
| pMainKeys->hSessionTimer = NULL; |
| |
| status = keyParser_unload(pMainKeys->pKeyParser); |
| if (status != TI_OK) |
| { |
| /* report failure but don't stop... */ |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error unloading key parser\n"); |
| } |
| |
| status = broadcastKey_unload(pMainKeys->pBcastSm); |
| if (status != TI_OK) |
| { |
| /* report failure but don't stop... */ |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error unloading broadcast key SM\n"); |
| } |
| |
| status = unicastKey_unload(pMainKeys->pUcastSm); |
| if (status != TI_OK) |
| { |
| /* report failure but don't stop... */ |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: Error unloading unicast key SM\n"); |
| } |
| |
| os_memoryFree(pMainKeys->hOs, pMainKeys, sizeof(mainKeys_t)); |
| |
| return TI_OK; |
| } |
| |
| |
| /** |
| * |
| * rsn_mainKeySmStart |
| * |
| * \b Description: |
| * |
| * START event handler |
| * |
| * \b ARGS: |
| * |
| * I - pCtrlB - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa rsn_mainKeySmStop() |
| */ |
| |
| TI_STATUS mainKeys_start(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status; |
| |
| status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_START, pMainKeys); |
| |
| return status; |
| } |
| |
| /** |
| * |
| * rsn_mainKeySmStop |
| * |
| * \b Description: |
| * |
| * STOP event handler |
| * |
| * \b ARGS: |
| * |
| * I - pCtrlB - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa rsn_mainKeySmStart() |
| */ |
| |
| TI_STATUS mainKeys_stop(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status; |
| |
| status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_STOP, pMainKeys); |
| |
| return status; |
| } |
| |
| /** |
| * |
| * rsn_mainKeySmReportUnicastComplete |
| * |
| * \b Description: |
| * |
| * UNICAST_COMPLETE event handler |
| * |
| * \b ARGS: |
| * |
| * I - pCtrlB - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa rsn_mainKeySmReportBroadcastComplete() |
| */ |
| |
| TI_STATUS mainKeys_reportUcastStatus(struct _mainKeys_t *pMainKeys, TI_STATUS ucastStatus) |
| { |
| TI_STATUS status=TI_NOK; |
| EExternalAuthMode extAuthMode; |
| struct _rsn_t *pRsn = pMainKeys->pParent->pParent; |
| |
| if (ucastStatus == TI_OK) |
| { |
| |
| txCtrlParams_setCurrentPrivacyInvokedMode(pRsn->hTxCtrl, TI_TRUE); |
| |
| 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); |
| } |
| |
| status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_UCAST_COMPLETE, pMainKeys); |
| } |
| |
| return status; |
| } |
| |
| |
| /** |
| * |
| * rsn_mainKeySmReportBroadcastComplete |
| * |
| * \b Description: |
| * |
| * BROADCAST_COMPLETE event handler |
| * |
| * \b ARGS: |
| * |
| * I - pCtrlB - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| * |
| * \sa rsn_mainKeySmReportUnicastComplete() |
| */ |
| |
| TI_STATUS mainKeys_reportBcastStatus(struct _mainKeys_t *pMainKeys, TI_STATUS bcastStatus) |
| { |
| TI_STATUS status=TI_NOK; |
| |
| if (bcastStatus == TI_OK) |
| { |
| status = mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_BCAST_COMPLETE, pMainKeys); |
| } |
| |
| return status; |
| } |
| |
| /** |
| * |
| * mainKeySmSessionTimeout |
| * |
| * \b Description: |
| * |
| * SESSION_TIMEOUOT event handler |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_setKey(struct _mainKeys_t *pMainKeys, TSecurityKeys *pKey) |
| { |
| return (pMainKeys->pParent->setKey(pMainKeys->pParent, pKey)); |
| } |
| |
| /** |
| * |
| * mainKeySmSessionTimeout |
| * |
| * \b Description: |
| * |
| * SESSION_TIMEOUOT event handler |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_removeKey(struct _mainKeys_t *pMainKeys, TSecurityKeys *pKey) |
| { |
| return (pMainKeys->pParent->removeKey(pMainKeys->pParent, pKey)); |
| } |
| |
| /** |
| * |
| * mainKeySmSessionTimeout |
| * |
| * \b Description: |
| * |
| * SESSION_TIMEOUOT event handler |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_setDefaultKeyId(struct _mainKeys_t *pMainKeys, TI_UINT8 keyId) |
| { |
| return (pMainKeys->pParent->setDefaultKeyId(pMainKeys->pParent, keyId)); |
| } |
| |
| /** |
| * |
| * mainKeySmSessionTimeout |
| * |
| * \b Description: |
| * |
| * SESSION_TIMEOUOT event handler |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_getSessionKey(struct _mainKeys_t *pMainKeys, TI_UINT8 *pKey, TI_UINT32 *pKeyLen) |
| { |
| TI_STATUS status; |
| |
| status = pMainKeys->pParent->getSessionKey(pMainKeys->pParent, pKey, pKeyLen); |
| |
| return status; |
| } |
| |
| /** |
| * |
| * mainKeySmSessionTimeout |
| * |
| * \b Description: |
| * |
| * SESSION_TIMEOUOT event handler |
| * |
| * \b ARGS: |
| * |
| * I - pMainKeys - module handle \n |
| * I - bTwdInitOccured - Indicates if TWDriver recovery occured since timer started \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| |
| void mainKeys_sessionTimeout(void *pMainKeys, TI_BOOL bTwdInitOccured) |
| { |
| |
| mainKeys_smEvent(pMainKeys, MAIN_KEYS_EVENT_SESSION_TIMEOUOT, pMainKeys); |
| |
| } |
| |
| |
| static TI_STATUS mainKeys_smEvent(struct _mainKeys_t *pMainKeys, TI_UINT8 event, void* pData) |
| { |
| TI_STATUS status; |
| TI_UINT8 nextState; |
| |
| |
| status = fsm_GetNextState(pMainKeys->pMainKeysSm, pMainKeys->currentState, event, &nextState); |
| if (status != TI_OK) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEYS_SM: ERROR - failed getting next state \n"); |
| |
| return(TI_NOK); |
| } |
| |
| TRACE3( pMainKeys->hReport, REPORT_SEVERITY_INFORMATION, "mainKeys_smEvent: <currentState = %d, event = %d> --> nextState = %d\n", pMainKeys->currentState, event, nextState); |
| |
| status = fsm_Event(pMainKeys->pMainKeysSm, &pMainKeys->currentState, event, pData); |
| |
| return status; |
| } |
| /** |
| * |
| * mainKeySmStartSubKeySmsAndTimer |
| * |
| * \b Description: |
| * |
| * Starts unicast & broadcast key SMs and session timer. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| |
| TI_STATUS mainKeys_startIdle(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status; |
| |
| status = pMainKeys->pUcastSm->start(pMainKeys->pUcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| status = pMainKeys->pBcastSm->start(pMainKeys->pBcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| tmr_StartTimer (pMainKeys->hSessionTimer, |
| mainKeys_sessionTimeout, |
| (TI_HANDLE)pMainKeys, |
| pMainKeys->keysTimeout, |
| TI_FALSE); |
| |
| status = pMainKeys->pKeyParser->replayReset(pMainKeys->pKeyParser); |
| |
| return status; |
| } |
| |
| |
| /** |
| * |
| * mainKeySmStopSubKeySmsAndTimer |
| * |
| * \b Description: |
| * |
| * Stops unicast & broadcast key SMs and session timer. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_stopStart(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status = TI_OK; |
| |
| status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| tmr_StopTimer (pMainKeys->hSessionTimer); |
| |
| return status; |
| } |
| |
| |
| /** |
| * |
| * mainKeySmStopSubKeySmsAndTimer |
| * |
| * \b Description: |
| * |
| * Stops unicast & broadcast key SMs and session timer. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_stopUcastComplete(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status = TI_OK; |
| |
| status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| tmr_StopTimer (pMainKeys->hSessionTimer); |
| |
| return status; |
| } |
| |
| /** |
| * |
| * mainKeySmReportComplete |
| * |
| * \b Description: |
| * |
| * Report key complete to the main security SM. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_bcastCompleteUcastComplete(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status; |
| |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_INFORMATION, "mainKeys_bcastCompleteUcastComplete - sending Interrogate \n"); |
| |
| tmr_StopTimer (pMainKeys->hSessionTimer); |
| |
| status = pMainKeys->pParent->reportKeysStatus(pMainKeys->pParent, TI_OK); |
| |
| return status; |
| } |
| |
| |
| /** |
| * |
| * mainKeySmStopSubKeySmsAndTimer |
| * |
| * \b Description: |
| * |
| * Stops unicast & broadcast key SMs and session timer. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_stopBcastComplete(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status = TI_OK; |
| |
| status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| tmr_StopTimer (pMainKeys->hSessionTimer); |
| |
| return status; |
| } |
| |
| /** |
| * |
| * mainKeySmReportComplete |
| * |
| * \b Description: |
| * |
| * Report key complete to the main security SM. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_ucastCompleteBcastComplete(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status; |
| |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_INFORMATION, "mainKeys_ucastCompleteBcastComplete \n"); |
| |
| tmr_StopTimer (pMainKeys->hSessionTimer); |
| pMainKeys->mainKeysTimeoutCounter = TI_FALSE; |
| status = pMainKeys->pParent->reportKeysStatus(pMainKeys->pParent, TI_OK); |
| |
| return status; |
| } |
| |
| /** |
| * |
| * mainKeySmStopSubKeySmsAndTimer |
| * |
| * \b Description: |
| * |
| * Stops unicast & broadcast key SMs and session timer. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_stopComplete(struct _mainKeys_t *pMainKeys) |
| { |
| TI_STATUS status = TI_OK; |
| |
| status = pMainKeys->pUcastSm->stop(pMainKeys->pUcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| status = pMainKeys->pBcastSm->stop(pMainKeys->pBcastSm); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| return status; |
| } |
| |
| /** |
| * |
| * mainKeySmLogMessage |
| * |
| * \b Description: |
| * |
| * Prints Log messge.\n |
| * Start session timer. |
| * |
| * \b ARGS: |
| * |
| * I - pData - station control block \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK on success, TI_NOK otherwise. |
| */ |
| TI_STATUS mainKeys_smTimeOut(void* data) |
| { |
| OS_802_11_AUTHENTICATION_REQUEST *request; |
| TI_UINT8 AuthBuf[sizeof(TI_UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)]; |
| paramInfo_t param; |
| TI_STATUS status; |
| struct _mainKeys_t *pMainKeys = (struct _mainKeys_t *)data; |
| |
| |
| TRACE1(pMainKeys->hReport, REPORT_SEVERITY_INFORMATION, "MAIN_KEY_SM: TRAP: Session Timeout for station , mainKeysTimeoutCounter=%d\n", pMainKeys->mainKeysTimeoutCounter); |
| |
| 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; |
| status = ctrlData_getParam(pMainKeys->hCtrlData, ¶m); |
| if (status != TI_OK) |
| { |
| return TI_NOK; |
| } |
| |
| TRACE1(pMainKeys->hReport, REPORT_SEVERITY_INFORMATION, "current station is banned from the roaming candidates list for %d Ms\n", RSN_MAIN_KEYS_SESSION_TIMEOUT); |
| |
| rsn_banSite(pMainKeys->hRsn, param.content.ctrlDataCurrentBSSID, RSN_SITE_BAN_LEVEL_FULL, RSN_MAIN_KEYS_SESSION_TIMEOUT); |
| |
| |
| /* mainKeysTimeoutCounter is a boolean variable, With states: */ |
| /* TI_TRUE - It is a Timeout Association Event */ |
| /* TI_FALSE - It is a Media specific Event */ |
| |
| if (!pMainKeys->mainKeysTimeoutCounter) |
| { |
| /* Fill Media specific indication fields and send to OS/User */ |
| MAC_COPY (request->BSSID, param.content.ctrlDataCurrentBSSID); |
| |
| request->Flags = OS_802_11_REQUEST_REAUTH; |
| |
| *(TI_UINT32*)AuthBuf = os802_11StatusType_Authentication; |
| |
| TRACE1(pMainKeys->hReport, REPORT_SEVERITY_INFORMATION, " %d Ms\n",RSN_MAIN_KEYS_SESSION_TIMEOUT); |
| |
| EvHandlerSendEvent(pMainKeys->hEvHandler, IPC_EVENT_MEDIA_SPECIFIC, (TI_UINT8*)AuthBuf, |
| sizeof(TI_UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)); |
| |
| tmr_StartTimer (pMainKeys->hSessionTimer, |
| mainKeys_sessionTimeout, |
| (TI_HANDLE)pMainKeys, |
| pMainKeys->keysTimeout, |
| TI_FALSE); |
| |
| pMainKeys->mainKeysTimeoutCounter = TI_TRUE; |
| } |
| else |
| { |
| pMainKeys->mainKeysTimeoutCounter = TI_FALSE; |
| rsn_reportAuthFailure(pMainKeys->hRsn, RSN_AUTH_STATUS_TIMEOUT); |
| conn_reportRsnStatus(pMainKeys->hConn, (mgmtStatus_e)STATUS_SECURITY_FAILURE); |
| } |
| return TI_OK; |
| } |
| |
| |
| TI_STATUS mainKeySmUnexpected(struct _mainKeys_t *pMainKeys) |
| { |
| TRACE0(pMainKeys->hReport, REPORT_SEVERITY_ERROR, "MAIN_KEY_SM: ERROR UnExpected Event\n"); |
| |
| return(TI_OK); |
| } |
| |
| TI_STATUS mainKeySmNop(struct _mainKeys_t *pMainKeys) |
| { |
| return(TI_OK); |
| } |
| |
| void mainKeys_reAuth(TI_HANDLE pHandle) |
| { |
| mainKeys_t *pMainKeys = (mainKeys_t *)pHandle; |
| |
| rsn_reAuth(pMainKeys->hRsn); |
| } |
