/**
*
* 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;
}
/**
* \author Yuval Adler\n
* \date 16-Oct-2004\n
* \brief Creates the scan SRV object
*
* Function Scope \e Public.\n
* \param hOS - handle to the OS object.\n
* \return a handle to the scan SRV object, NULL if an error occurred.\n
*/
TI_HANDLE MacServices_scanSRV_create( TI_HANDLE hOS )
{
/* allocate the scan SRV object */
scanSRV_t *pScanSRV = os_memoryAlloc( hOS, sizeof(scanSRV_t) );
if ( NULL == pScanSRV )
{
WLAN_OS_REPORT( ("ERROR: Failed to create scan SRV module") );
return NULL;
}
/* allocate the state machine */
if ( OK != fsm_Create( hOS, &(pScanSRV->SM), SCAN_SRV_NUM_OF_STATES, SCAN_SRV_NUM_OF_EVENTS ) )
{
WLAN_OS_REPORT( ("ERROR: Failed to allocate scan SRV state machine") );
os_memoryFree( hOS, pScanSRV, sizeof(scanSRV_t) );
return NULL;
}
/* create the timer */
pScanSRV->timer = os_timerCreate( hOS, MacServices_scanSRV_scanTimerExpired, pScanSRV );
if ( NULL == pScanSRV->timer )
{
WLAN_OS_REPORT( ("ERROR: Failed to create timer for scan SRV module") );
fsm_Unload( hOS, pScanSRV->SM );
os_memoryFree( hOS, pScanSRV, sizeof(scanSRV_t) );
return NULL;
}
/* store the OS handle */
pScanSRV->hOS = hOS;
return pScanSRV;
}
/**
* \\n
* \date 08-November-2005\n
* \brief Destroys the measurement SRV object
*
* Function Scope \e Public.\n
* \param hMeasurementSRV - handle to the measurement SRV object.\n
*/
void MacServices_measurementSRV_destroy( TI_HANDLE hMeasurementSRV )
{
measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
TI_INT32 i;
/* sanity cehcking */
if ( NULL == hMeasurementSRV ) {
return;
}
/* release state machine */
if ( NULL != pMeasurementSRV->SM ) {
fsm_Unload( pMeasurementSRV->hOS, pMeasurementSRV->SM );
}
/* release timers */
for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ ) {
if (pMeasurementSRV->hRequestTimer[i]) {
tmr_DestroyTimer (pMeasurementSRV->hRequestTimer[i]);
}
}
if (pMeasurementSRV->hStartStopTimer) {
tmr_DestroyTimer (pMeasurementSRV->hStartStopTimer);
}
/* release object space */
os_memoryFree( pMeasurementSRV->hOS, (TI_HANDLE)pMeasurementSRV, sizeof(measurementSRV_t));
}
/**
*
* mainSec_config
*
* \b Description:
*
* Init main security state machine state machine
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* OK on success, NOK otherwise.
*
* \sa
*/
TI_STATUS mainSec_unload(mainSec_t *pMainSec)
{
TI_STATUS status;
if (pMainSec == NULL)
{
return NOK;
}
status = mainKeys_unload(pMainSec->pMainKeys);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pMainSec->hReport, RSN_MODULE_LOG,
("MAIN_SEC_SM: Error releasing Main Keys SM memory \n"));
}
status = fsm_Unload(pMainSec->hOs, pMainSec->pMainSecSm);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pMainSec->hReport, RSN_MODULE_LOG,
("MAIN_SEC_SM: Error releasing FSM memory \n"));
}
os_memoryFree(pMainSec->hOs, pMainSec, sizeof(mainSec_t));
return OK;
}
/**
* Releases the module's allocated objects according to the given init vector.
*
* @param pMeasurementMgr A handle to the Measurement Manager module.
* @param initVec The init vector with a bit set for each allocated object.
*
* @date 01-Jan-2006
*/
static void measurementMgr_releaseModule (measurementMgr_t * pMeasurementMgr)
{
#ifdef XCC_MODULE_INCLUDED
TI_UINT32 currAC;
#endif
if (pMeasurementMgr->hActivationDelayTimer)
{
tmr_DestroyTimer (pMeasurementMgr->hActivationDelayTimer);
}
#ifdef XCC_MODULE_INCLUDED
for (currAC = 0; currAC < MAX_NUM_OF_AC; currAC++)
{
if (pMeasurementMgr->hTsMetricsReportTimer[currAC])
{
tmr_DestroyTimer (pMeasurementMgr->hTsMetricsReportTimer[currAC]);
}
}
#endif
if (pMeasurementMgr->pMeasurementMgrSm)
{
fsm_Unload(pMeasurementMgr->hOs, pMeasurementMgr->pMeasurementMgrSm);
}
if (pMeasurementMgr->hRequestH)
{
requestHandler_destroy(pMeasurementMgr->hRequestH);
}
os_memoryFree(pMeasurementMgr->hOs, pMeasurementMgr, sizeof(measurementMgr_t));
}
broadcastKey_t* broadcastKey_create(TI_HANDLE hOs)
{
TI_STATUS status;
broadcastKey_t *pBroadcastKey;
/* allocate key parser context memory */
pBroadcastKey = (broadcastKey_t*)os_memoryAlloc(hOs, sizeof(broadcastKey_t));
if (pBroadcastKey == NULL)
{
return NULL;
}
os_memoryZero(hOs, pBroadcastKey, sizeof(broadcastKey_t));
/* allocate memory for association state machine */
status = fsm_Create(hOs, &pBroadcastKey->pBcastKeySm, BCAST_KEY_MAX_NUM_STATES, BCAST_KEY_MAX_NUM_EVENTS);
if (status != TI_OK)
{
os_memoryFree(hOs, pBroadcastKey, sizeof(broadcastKey_t));
return NULL;
}
pBroadcastKey->pKeyDerive = keyDerive_create(hOs);
if (pBroadcastKey->pKeyDerive == NULL)
{
fsm_Unload(hOs, pBroadcastKey->pBcastKeySm);
os_memoryFree(hOs, pBroadcastKey, sizeof(broadcastKey_t));
return NULL;
}
pBroadcastKey->hOs = hOs;
return pBroadcastKey;
}
/**
*
* mainSec_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 mainSec_unload(mainSec_t *pMainSec)
{
TI_STATUS status;
if (pMainSec == NULL)
{
return TI_NOK;
}
status = mainKeys_unload(pMainSec->pMainKeys);
if (status != TI_OK)
{
/* report failure but don't stop... */
TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error releasing Main Keys SM memory \n");
}
status = fsm_Unload(pMainSec->hOs, pMainSec->pMainSecSm);
if (status != TI_OK)
{
/* report failure but don't stop... */
TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error releasing FSM memory \n");
}
status = externalSec_Destroy (pMainSec->pExternalSec);
if (status != TI_OK)
{
/* report failure but don't stop... */
TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error releasing External Security SM memory \n");
}
os_memoryFree(pMainSec->hOs, pMainSec, sizeof(mainSec_t));
return TI_OK;
}
/**
*
* assoc_create - allocate memory for association SM
*
* \b Description:
*
* Allocate memory for association SM. \n
* Allocates memory for Association context. \n
* Allocates memory for association timer. \n
* Allocates memory for association SM matrix. \n
*
* \b ARGS:
*
* I - hOs - OS context \n
*
* \b RETURNS:
*
* OK if successful, NOK otherwise.
*
* \sa rsn_mainSecSmKeysOnlyStop()
*/
TI_HANDLE assoc_create(TI_HANDLE hOs)
{
assoc_t *pHandle;
TI_STATUS status;
/* allocate association context memory */
pHandle = (assoc_t*)os_memoryAlloc(hOs, sizeof(assoc_t));
if (pHandle == NULL)
{
return NULL;
}
os_memoryZero(hOs, pHandle, sizeof(assoc_t));
pHandle->hOs = hOs;
/* allocate memory for association state machine */
status = fsm_Create(hOs, &pHandle->pAssocSm, ASSOC_SM_NUM_STATES, ASSOC_SM_NUM_EVENTS);
if (status != OK)
{
os_memoryFree(hOs, pHandle, sizeof(assoc_t));
return NULL;
}
/* allocate OS timer memory */
pHandle->timer = os_timerCreate(hOs, assoc_smTimeout, pHandle);
if (pHandle->timer == NULL)
{
fsm_Unload(hOs, pHandle->pAssocSm);
os_memoryFree(hOs, pHandle, sizeof(assoc_t));
return NULL;
}
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_unload(mainKeys_t *pMainKeys)
{
TI_STATUS status;
if (pMainKeys == NULL)
{
return TI_NOK;
}
status = fsm_Unload(pMainKeys->hOs, pMainKeys->pMainKeysSm);
if (pMainKeys->hSessionTimer)
{
tmr_DestroyTimer (pMainKeys->hSessionTimer);
}
pMainKeys->hSessionTimer = NULL;
status = keyParser_unload(pMainKeys->pKeyParser);
status = broadcastKey_unload(pMainKeys->pBcastSm);
status = unicastKey_unload(pMainKeys->pUcastSm);
os_memoryFree(pMainKeys->hOs, pMainKeys, sizeof(mainKeys_t));
return TI_OK;
}
/**
*
* mainSec_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
*/
mainSec_t* mainSec_create(TI_HANDLE hOs)
{
mainSec_t *pHandle;
TI_STATUS status;
/* allocate association context memory */
pHandle = (mainSec_t*)os_memoryAlloc(hOs, sizeof(mainSec_t));
if (pHandle == NULL)
{
return NULL;
}
os_memoryZero(hOs, pHandle, sizeof(mainSec_t));
/* allocate memory for association state machine */
status = fsm_Create(hOs, &pHandle->pMainSecSm, MAIN_SEC_MAX_NUM_STATES, MAIN_SEC_MAX_NUM_EVENTS);
if (status != TI_OK)
{
os_memoryFree(hOs, pHandle, sizeof(mainSec_t));
return NULL;
}
pHandle->pMainKeys = mainKeys_create(hOs);
if (pHandle->pMainKeys == NULL)
{
fsm_Unload(hOs, pHandle->pMainSecSm);
os_memoryFree(hOs, pHandle, sizeof(mainSec_t));
return NULL;
}
pHandle->pKeyParser = pHandle->pMainKeys->pKeyParser;
pHandle->hOs = hOs;
/* created only for external security mode */
pHandle->pExternalSec = externalSec_create(hOs);
if (pHandle->pExternalSec == NULL)
{
fsm_Unload(hOs, pHandle->pMainSecSm);
mainKeys_unload(pHandle->pMainKeys);
os_memoryFree(hOs, pHandle, sizeof(mainSec_t));
return NULL;
}
return pHandle;
}
/***********************************************************************
* release_module
***********************************************************************
DESCRIPTION: Release all module resources - FSMs, timer and object.
INPUT: hConn - Connection handle.
OUTPUT:
RETURN: void
************************************************************************/
static void release_module(conn_t *pConn)
{
if (pConn->ibss_pFsm)
{
fsm_Unload (pConn->hOs, pConn->ibss_pFsm);
}
if (pConn->infra_pFsm)
{
fsm_Unload (pConn->hOs, pConn->infra_pFsm);
}
if (pConn->hConnTimer)
{
tmr_DestroyTimer (pConn->hConnTimer);
}
os_memoryFree(pConn->hOs, pConn, sizeof(conn_t));
}
/**
* \author Yuval Adler\n
* \date 29-Dec-2004\n
* \brief Finalizes the scan SRV module (releasing memory and timer)
*
* Function Scope \e Public.\n
* \param hScanSRV - handle to the scan SRV object.\n
*/
void MacServices_scanSRV_destroy( TI_HANDLE hScanSRV )
{
scanSRV_t *pScanSRV = (scanSRV_t*)hScanSRV;
/* free timer */
os_timerStop( pScanSRV->hOS, pScanSRV->timer );
os_timerDestroy( pScanSRV->hOS, pScanSRV->timer );
/* free memory */
fsm_Unload( pScanSRV->hOS, pScanSRV->SM );
os_memoryFree( pScanSRV->hOS, (TI_HANDLE)pScanSRV , sizeof(scanSRV_t) );
}
/**
*
* Function - externalSec_Destroy.
*
* \b Description:
*
* Called by mainSecSM (mainSec_unload).
*
* \b ARGS:
*
*
* \b RETURNS:
*
* TI_STATUS - 0 on success, any other value on failure.
*
*/
TI_STATUS externalSec_Destroy (struct externalSec_t *pExternalSec)
{
TI_STATUS status;
if (pExternalSec == NULL)
{
return TI_NOK;
}
status = fsm_Unload (pExternalSec->hOs, pExternalSec->pExternalSecSm);
os_memoryFree (pExternalSec->hOs, pExternalSec, sizeof(struct externalSec_t));
return TI_OK;
}
/*
DESCRIPTION: Called by the destroy function or by the create function (on failure)
Go over the vector, for each bit that is set, release the corresponding module.
INPUT: pSwitchChannel - SwitchChannel pointer.
initVec - Vector that contains a bit set for each module thah had been initiualized
OUTPUT:
RETURN: TI_OK on success, TI_NOK otherwise
************************************************************************/
static void release_module(switchChannel_t *pSwitchChannel, TI_UINT32 initVec)
{
if (pSwitchChannel == NULL) {
return;
}
if (initVec & (1 << SC_SM_INIT_BIT)) {
fsm_Unload(pSwitchChannel->hOs, pSwitchChannel->pSwitchChannelSm);
}
if (initVec & (1 << SC_INIT_BIT)) {
os_memoryFree(pSwitchChannel->hOs, pSwitchChannel, sizeof(switchChannel_t));
}
initVec = 0;
}
/**
*
* mainKeys_config
*
* \b Description:
*
* Init main security state machine state machine
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* OK on success, NOK otherwise.
*
* \sa
*/
TI_STATUS mainKeys_unload(mainKeys_t *pMainKeys)
{
TI_STATUS status;
if (pMainKeys == NULL)
{
return NOK;
}
status = fsm_Unload(pMainKeys->hOs, pMainKeys->pMainKeysSm);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error releasing FSM memory \n"));
}
os_timerStop(pMainKeys->hOs, pMainKeys->timer);
os_timerDestroy(pMainKeys->hOs, pMainKeys->timer);
status = keyParser_unload(pMainKeys->pKeyParser);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error unloading key parser\n"));
}
status = broadcastKey_unload(pMainKeys->pBcastSm);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error unloading broadcast key SM\n"));
}
status = unicastKey_unload(pMainKeys->pUcastSm);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error unloading unicast key SM\n"));
}
os_memoryFree(pMainKeys->hOs, pMainKeys, sizeof(mainKeys_t));
return OK;
}
/**
*
* mlme_Unload - unload MLME SM from memory
*
* \b Description:
*
* Unload MLME SM from memory
*
* \b ARGS:
*
* I - hMlme - MLME SM context \n
*
* \b RETURNS:
*
* TI_OK if successful, TI_NOK otherwise.
*
* \sa rsn_mainSecSmKeysOnlyStop()
*/
TI_STATUS mlme_unload(TI_HANDLE hMlme)
{
TI_STATUS status;
mlme_t *pHandle;
pHandle = (mlme_t*)hMlme;
status = fsm_Unload(pHandle->hOs, pHandle->pMlmeSm);
if (status != TI_OK) {
/* report failure but don't stop... */
}
os_memoryFree(pHandle->hOs, hMlme, sizeof(mlme_t));
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;
}
/**
*
* auth_unload - unload authentication SM from memory
*
* \b Description:
*
* Unload authentication SM from memory
*
* \b ARGS:
*
* I - hAuth - Authentication SM context \n
*
* \b RETURNS:
*
* TI_OK if successful, TI_NOK otherwise.
*
* \sa rsn_mainSecSmKeysOnlyStop()
*/
TI_STATUS auth_unload(TI_HANDLE hAuth)
{
TI_STATUS status;
auth_t *pHandle;
pHandle = (auth_t*)hAuth;
status = fsm_Unload(pHandle->hOs, pHandle->pAuthSm);
if (pHandle->hAuthSmTimer) {
tmr_DestroyTimer (pHandle->hAuthSmTimer);
}
os_memoryFree(pHandle->hOs, pHandle, sizeof(auth_t));
return TI_OK;
}
/**
*
* Function - externalSec_Destroy.
*
* \b Description:
*
* Called by mainSecSM (mainSec_unload).
*
* \b ARGS:
*
*
* \b RETURNS:
*
* TI_STATUS - 0 on success, any other value on failure.
*
*/
TI_STATUS externalSec_Destroy (struct externalSec_t *pExternalSec)
{
TI_STATUS status;
if (pExternalSec == NULL)
{
return TI_NOK;
}
status = fsm_Unload(pExternalSec->hOs, pExternalSec->pExternalSecSm);
if (status != TI_OK)
{
/* report failure but don't stop... */
TRACE0(pExternalSec->hReport, REPORT_SEVERITY_ERROR, "EXTERNAL SECURITY: Error releasing FSM memory \n");
}
os_memoryFree(pExternalSec->hOs, pExternalSec, sizeof(struct externalSec_t));
return TI_OK;
}
/**
*
* mainSec_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 mainSec_unload(mainSec_t *pMainSec)
{
TI_STATUS status;
if (pMainSec == NULL)
{
return TI_NOK;
}
status = mainKeys_unload(pMainSec->pMainKeys);
status = fsm_Unload(pMainSec->hOs, pMainSec->pMainSecSm);
status = externalSec_Destroy (pMainSec->pExternalSec);
os_memoryFree(pMainSec->hOs, pMainSec, sizeof(mainSec_t));
return TI_OK;
}
/**
*
* assocunload - unload association SM from memory
*
* \b Description:
*
* Unload association SM from memory
*
* \b ARGS:
*
* I - hAssoc - association SM context \n
*
* \b RETURNS:
*
* OK if successful, NOK otherwise.
*
* \sa rsn_mainSecSmKeysOnlyStop()
*/
TI_STATUS assoc_unload(TI_HANDLE hAssoc)
{
TI_STATUS status;
assoc_t *pHandle;
pHandle = (assoc_t*)hAssoc;
status = fsm_Unload(pHandle->hOs, pHandle->pAssocSm);
if (status != OK)
{
/* report failure but don't stop... */
WLAN_REPORT_ERROR(pHandle->hReport, ASSOC_MODULE_LOG,
("ASSOC_SM: Error releasing FSM memory \n"));
}
os_timerDestroy(pHandle->hOs, pHandle->timer);
os_memoryFree(pHandle->hOs, hAssoc, sizeof(assoc_t));
return OK;
}
/**
* Releases the module's allocated objects according to the given init vector.
*
* @param pMeasurementMgr A handle to the Measurement Manager module.
* @param initVec The init vector with a bit set for each allocated object.
*
* @date 01-Jan-2006
*/
static void measurementMgr_releaseModule (measurementMgr_t * pMeasurementMgr)
{
if (pMeasurementMgr->hActivationDelayTimer)
{
tmr_DestroyTimer (pMeasurementMgr->hActivationDelayTimer);
}
if (pMeasurementMgr->pMeasurementMgrSm)
{
fsm_Unload(pMeasurementMgr->hOs, pMeasurementMgr->pMeasurementMgrSm);
}
if (pMeasurementMgr->hRequestH)
{
requestHandler_destroy(pMeasurementMgr->hRequestH);
}
os_memoryFree(pMeasurementMgr->hOs, pMeasurementMgr, sizeof(measurementMgr_t));
}
TI_STATUS broadcastKey_unload(struct _broadcastKey_t *pBroadcastKey)
{
TI_STATUS status;
status = keyDerive_unload(pBroadcastKey->pKeyDerive);
if (status != TI_OK) {
TRACE0(pBroadcastKey->hReport, REPORT_SEVERITY_CONSOLE, "BCAST_KEY_SM: Error in unloading key derivation module\n");
WLAN_OS_REPORT(("BCAST_KEY_SM: Error in unloading key derivation module\n"));
}
status = fsm_Unload(pBroadcastKey->hOs, pBroadcastKey->pBcastKeySm);
if (status != TI_OK) {
TRACE0(pBroadcastKey->hReport, REPORT_SEVERITY_CONSOLE, "BCAST_KEY_SM: Error in unloading state machine\n");
WLAN_OS_REPORT(("BCAST_KEY_SM: Error in unloading state machine\n"));
}
/* free key parser context memory */
os_memoryFree(pBroadcastKey->hOs, pBroadcastKey, sizeof(broadcastKey_t));
return TI_OK;
}
/**
*
* assocunload - unload association SM from memory
*
* \b Description:
*
* Unload association SM from memory
*
* \b ARGS:
*
* I - hAssoc - association SM context \n
*
* \b RETURNS:
*
* TI_OK if successful, TI_NOK otherwise.
*
* \sa rsn_mainSecSmKeysOnlyStop()
*/
TI_STATUS assoc_unload(TI_HANDLE hAssoc)
{
TI_STATUS status;
assoc_t *pHandle;
pHandle = (assoc_t*)hAssoc;
status = fsm_Unload(pHandle->hOs, pHandle->pAssocSm);
if (status != TI_OK)
{
/* report failure but don't stop... */
TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR, "ASSOC_SM: Error releasing FSM memory \n");
}
if (pHandle->hAssocSmTimer)
{
tmr_DestroyTimer (pHandle->hAssocSmTimer);
}
os_memoryFree(pHandle->hOs, hAssoc, sizeof(assoc_t));
return TI_OK;
}
