/***********************************************************************
* conn_ibssConfig
***********************************************************************
DESCRIPTION: IBSS Connection configuration function, called by the conection set param function
in the selection phase. Configures the connection state machine to IBSS connection mode
INPUT: hConn - Connection handle.
OUTPUT:
RETURN: TI_OK on success, TI_NOK otherwise
************************************************************************/
TI_STATUS conn_ibssConfig(conn_t *pConn)
{
fsm_actionCell_t smMatrix[CONN_IBSS_NUM_STATES][CONN_IBSS_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{ {STATE_CONN_IBSS_SELF_WAIT, idle_to_selfWait }, /* CONN_IBSS_CREATE */
{STATE_CONN_IBSS_RSN_WAIT, idle_to_rsnWait }, /* CONN_IBSS_CONNECT */
{STATE_CONN_IBSS_IDLE, actionNop }, /* CONN_IBSS_DISCONNECT */
{STATE_CONN_IBSS_IDLE, actionUnexpected }, /* CONN_IBSS_RSN_SUCC */
{STATE_CONN_IBSS_IDLE, actionUnexpected }, /* CONN_IBSS_STA_JOINED */
{STATE_CONN_IBSS_IDLE, actionUnexpected }, /* CONN_IBSS_MERGE */
{STATE_CONN_IBSS_IDLE, actionUnexpected } /* CONN_IBSS_DISCONN_COMPLETE */
},
/* next state and actions for SELF_WAIT state */
{ {STATE_CONN_IBSS_SELF_WAIT, actionUnexpected }, /* CONN_IBSS_CREATE */
{STATE_CONN_IBSS_SELF_WAIT, actionUnexpected }, /* CONN_IBSS_CONNECT */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, selfWait_to_waitToDisconnCmplt }, /* CONN_IBSS_DISCONNECT */
{STATE_CONN_IBSS_SELF_WAIT, actionUnexpected }, /* CONN_IBSS_RSN_SUCC */
{STATE_CONN_IBSS_RSN_WAIT, selfWait_to_rsnWait }, /* CONN_IBSS_STA_JOINED */
{STATE_CONN_IBSS_RSN_WAIT, selfw_merge_rsnw }, /* CONN_IBSS_MERGE */
{STATE_CONN_IBSS_SELF_WAIT, actionUnexpected } /* CONN_IBSS_DISCONN_COMPLETE */
},
/* next state and actions for RSN_WAIT state */
{ {STATE_CONN_IBSS_RSN_WAIT, actionUnexpected }, /* CONN_IBSS_CREATE */
{STATE_CONN_IBSS_RSN_WAIT, actionUnexpected }, /* CONN_IBSS_CONNECT */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, rsnWait_to_waitToDisconnCmplt }, /* CONN_IBSS_DISCONNECT */
{STATE_CONN_IBSS_CONNECTED, rsnWait_to_connected }, /* CONN_IBSS_RSN_SUCC */
{STATE_CONN_IBSS_RSN_WAIT, actionUnexpected }, /* CONN_IBSS_STA_JOINED */
{STATE_CONN_IBSS_RSN_WAIT, rsnw_merge_rsnw }, /* CONN_IBSS_MERGE */
{STATE_CONN_IBSS_RSN_WAIT, actionUnexpected } /* CONN_IBSS_DISCONN_COMPLETE */
},
/* next state and actions for CONNECTED state */
{ {STATE_CONN_IBSS_CONNECTED, actionUnexpected }, /* CONN_IBSS_CREATE */
{STATE_CONN_IBSS_CONNECTED, actionUnexpected }, /* CONN_IBSS_CONNECT */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, connected_to_waitToDisconnCmplt }, /* CONN_IBSS_DISCONNECT */
{STATE_CONN_IBSS_CONNECTED, actionUnexpected }, /* CONN_IBSS_RSN_SUCC */
{STATE_CONN_IBSS_CONNECTED, actionUnexpected }, /* CONN_IBSS_STA_JOINED */
{STATE_CONN_IBSS_CONNECTED, conn_merge_conn }, /* CONN_IBSS_MERGE */
{STATE_CONN_IBSS_CONNECTED, actionUnexpected } /* CONN_IBSS_DISCONN_COMPLETE */
},
/* next state and actions for STATE_CONN_IBSS_WAIT_DISCONN_CMPLT state */
{ {STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, actionUnexpected }, /* CONN_IBSS_CREATE */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, actionUnexpected }, /* CONN_IBSS_CONNECT */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, actionUnexpected }, /* CONN_IBSS_DISCONNECT */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, actionUnexpected }, /* CONN_IBSS_RSN_SUCC */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, actionUnexpected }, /* CONN_IBSS_STA_JOINED */
{STATE_CONN_IBSS_WAIT_DISCONN_CMPLT, actionUnexpected }, /* CONN_IBSS_MERGE */
{STATE_CONN_IBSS_IDLE, waitDisconnToCmplt_to_idle } /* CONN_IBSS_DISCONN_COMPLETE */
}
};
return fsm_Config(pConn->ibss_pFsm, (fsm_Matrix_t)smMatrix, CONN_IBSS_NUM_STATES, CONN_IBSS_NUM_EVENTS, conn_ibssSMEvent, pConn->hOs);
}
/**
*
* rsn_mainSecSmKeysOnlyInit
*
* \b Description:
*
* Init main security state machine state machine
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* OK on success, NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_config(mainSec_t *pMainSec,
rsn_paeConfig_t *pPaeConfig)
{
TI_STATUS status;
/** Main 802.1X State Machine matrix */
fsm_actionCell_t mainSecKeysOnly_matrix[MAIN_SEC_KEYS_ONLY_NUM_STATES][MAIN_SEC_KEYS_ONLY_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{{MAIN_KO_STATE_START, (fsm_Action_t)mainSecKeysOnly_startIdle},
{MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_Nop},
{MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_unexpected},
{MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_unexpected}
},
/* next state and actions for START state */
{{MAIN_KO_STATE_START, (fsm_Action_t)mainSecKeysOnly_Nop},
{MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_stopStart},
{MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_keysCompleteStart},
{MAIN_KO_STATE_NONAUTHORIZED, (fsm_Action_t)mainSecKeysOnly_keysTOStart},
},
/* next state and actions for AUTHORIZED state */
{{MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected},
{MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_stopAuthorized},
{MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_Nop},
{MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected},
},
/* next state and actions for NONAUTORIZED state */
{{MAIN_KO_STATE_START, (fsm_Action_t)mainSecKeysOnly_unexpected},
{MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_stopNonAuthorized},
{MAIN_KO_STATE_NONAUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected},
{MAIN_KO_STATE_NONAUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected},
}
};
status = fsm_Config(pMainSec->pMainSecSm, &mainSecKeysOnly_matrix[0][0],
MAIN_SEC_KEYS_ONLY_NUM_STATES, MAIN_SEC_KEYS_ONLY_NUM_EVENTS, NULL, pMainSec->hOs);
if (status != OK)
{
WLAN_REPORT_ERROR(pMainSec->hReport, RSN_MODULE_LOG,
("MAIN_SEC_SM: Error in configuring full SM\n"));
return status;
}
pMainSec->currentState = MAIN_KO_STATE_IDLE;
pMainSec->start = mainSecKeysOnly_start;
pMainSec->stop = mainSecKeysOnly_stop;
pMainSec->reportKeysStatus = mainSecKeysOnly_reportKeysStatus;
pMainSec->getAuthState = (mainSecSm_getAuthState_t)mainSecKeysOnly_getAuthState;
pMainSec->reportReAuthenticate = (mainSecSmReportReauthentication_t)mainSecKeysOnly_unexpected;
pMainSec->setSessionKey = (mainSecSmSetSessionKey_t)mainSecKeysOnly_unexpected;
pMainSec->getSessionKey = (mainSecSmGetSessionKey_t)mainSecKeysOnly_unexpected;
pMainSec->reportAuthStatus = (mainSecSmReportAuthStatus_t)mainSecKeysOnly_unexpected;
pMainSec->getAuthIdentity = (mainSecSm_getAuthIdentity_t)mainSecKeysOnly_unexpected;
pMainSec->setAuthIdentity = (mainSecSm_getAuthIdentity_t)mainSecKeysOnly_setAuthIdentity;
pMainSec->reportAuthFailure = (mainSecSm_reportAuthFailure_t)mainSecKeysOnly_reportAuthFailure;
WLAN_REPORT_INFORMATION(pMainSec->hReport, RSN_MODULE_LOG,
("mainSecKeysOnly_config\n"));
return OK;
}
/**
*
* assoc_config - configure a new association SM
*
* \b Description:
*
* Configure a new association SM.
*
* \b RETURNS:
*
* void
*
* \sa assoc_Create, assoc_Unload
*/
void assoc_init (TStadHandlesList *pStadHandles)
{
assoc_t *pHandle = (assoc_t*)(pStadHandles->hAssoc);
/** Main 802.1X State Machine matrix */
fsm_actionCell_t assoc_smMatrix[ASSOC_SM_NUM_STATES][ASSOC_SM_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{{ASSOC_SM_STATE_WAIT, (fsm_Action_t)assoc_smStartIdle},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected}
},
/* next state and actions for WAIT state */
{{ASSOC_SM_STATE_WAIT, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smStopWait},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smSuccessWait},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smFailureWait},
{ASSOC_SM_STATE_WAIT, (fsm_Action_t)assoc_smTimeoutWait},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smMaxRetryWait}
},
/* next state and actions for ASSOC state */
{{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smStopAssoc},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected}
}};
/* configure state machine */
fsm_Config (pHandle->pAssocSm, &assoc_smMatrix[0][0], ASSOC_SM_NUM_STATES, ASSOC_SM_NUM_EVENTS, NULL, pStadHandles->hOs);
pHandle->assocRejectCount = 0;
pHandle->assocTimeoutCount = 0;
pHandle->currentState = ASSOC_SM_STATE_IDLE;
pHandle->hMlme = pStadHandles->hMlmeSm;
pHandle->hRegulatoryDomain = pStadHandles->hRegulatoryDomain;
pHandle->hSiteMgr = pStadHandles->hSiteMgr;
pHandle->hCtrlData = pStadHandles->hCtrlData;
pHandle->hTWD = pStadHandles->hTWD;
pHandle->hRsn = pStadHandles->hRsn;
pHandle->hReport = pStadHandles->hReport;
pHandle->hOs = pStadHandles->hOs;
pHandle->hXCCMngr = pStadHandles->hXCCMngr;
pHandle->hQosMngr = pStadHandles->hQosMngr;
pHandle->hMeasurementMgr = pStadHandles->hMeasurementMgr;
pHandle->hApConn = pStadHandles->hAPConnection;
pHandle->hTimer = pStadHandles->hTimer;
pHandle->hStaCap = pStadHandles->hStaCap;
pHandle->hSme = pStadHandles->hSme;
}
/**
*
* openAuth_smConfig - configure a new authentication SM
*
* \b Description:
*
* Configure a new authentication SM.
*
* \b ARGS:
*
* I - hAuth - Association SM context \n
* I - hMlme - MLME SM context \n
* I - hSiteMgr - Site manager context \n
* I - hCtrlData - Control data context \n
* I - hTxData - TX data context \n
* I - hHalCtrl - Hal control context \n
* I - hReport - Report context \n
* I - hOs - OS context \n
* I - authTimeout - Association SM timeout \n
* I - authMaxCount - Max number of authentication requests to send \n
*
* \b RETURNS:
*
* TI_OK if successful, TI_NOK otherwise.
*
* \sa openAuth_Create, openAuth_Unload
*/
TI_STATUS openAuth_Config(TI_HANDLE hAuth, TI_HANDLE hOs)
{
auth_t *pHandle;
TI_STATUS status;
/** Main 802.1X State Machine matrix */
fsm_actionCell_t openAuth_smMatrix[OPEN_AUTH_SM_NUM_STATES][OPEN_AUTH_SM_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{{OPEN_AUTH_SM_STATE_WAIT, (fsm_Action_t)openAuth_smStartIdle},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smActionUnexpected}
},
/* next state and actions for WAIT state */
{{OPEN_AUTH_SM_STATE_WAIT, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smStopWait},
{OPEN_AUTH_SM_STATE_AUTH, (fsm_Action_t)openAuth_smSuccessWait},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smFailureWait},
{OPEN_AUTH_SM_STATE_WAIT, (fsm_Action_t)openAuth_smTimeoutWait},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smMaxRetryWait}
},
/* next state and actions for AUTH state */
{{OPEN_AUTH_SM_STATE_AUTH, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_IDLE, (fsm_Action_t)openAuth_smStopAuth},
{OPEN_AUTH_SM_STATE_AUTH, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_AUTH, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_AUTH, (fsm_Action_t)openAuth_smActionUnexpected},
{OPEN_AUTH_SM_STATE_AUTH, (fsm_Action_t)openAuth_smActionUnexpected}
}};
if (hAuth == NULL)
{
return TI_NOK;
}
pHandle = (auth_t*)hAuth;
status = fsm_Config(pHandle->pAuthSm, &openAuth_smMatrix[0][0],
OPEN_AUTH_SM_NUM_STATES, OPEN_AUTH_SM_NUM_EVENTS, auth_osSMEvent, hOs);
if (status != TI_OK)
{
return TI_NOK;
}
pHandle->currentState = OPEN_AUTH_SM_STATE_IDLE;
return TI_OK;
}
TI_STATUS broadcastKey802_1x_config(struct _broadcastKey_t *pBroadcastKey)
{
TI_STATUS status = TI_NOK;
/** Station broadcast key State Machine matrix */
fsm_actionCell_t broadcastKey802_1x_matrix[BCAST_KEY_802_1X_NUM_STATES][BCAST_KEY_802_1X_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{ {BCAST_KEY_802_1X_STATE_START, (fsm_Action_t)broadcastKeySmNop},
{BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop},
{BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop},
{BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmUnexpected}
},
/* next state and actions for START state */
{ {BCAST_KEY_802_1X_STATE_START, (fsm_Action_t)broadcastKeySmUnexpected},
{BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop},
{BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKey802_1x_distribute},
{BCAST_KEY_802_1X_STATE_START, (fsm_Action_t)broadcastKeySmNop}
},
/* next state and actions for COMPLETE state */
{ {BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKeySmUnexpected},
{BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop},
{BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKey802_1x_distribute},
{BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKeySmUnexpected}
}
};
pBroadcastKey->start = broadcastKey802_1x_start;
pBroadcastKey->stop = broadcastKey802_1x_stop;
pBroadcastKey->recvFailure = broadcastKey802_1x_recvFailure;
pBroadcastKey->recvSuccess = broadcastKey802_1x_recvSuccess;
pBroadcastKey->currentState = BCAST_KEY_802_1X_STATE_IDLE;
status = fsm_Config(pBroadcastKey->pBcastKeySm,
&broadcastKey802_1x_matrix[0][0],
BCAST_KEY_802_1X_NUM_STATES,
BCAST_KEY_802_1X_NUM_EVENTS,
NULL, pBroadcastKey->hOs);
return status;
}
TI_STATUS unicastKey802_1x_config(struct _unicastKey_t *pUnicastKey)
{
TI_STATUS status = TI_NOK;
/** 802.1X Station unicast key State Machine matrix */
fsm_actionCell_t unicastKey802_1x_matrix[UCAST_KEY_802_1X_NUM_STATES][UCAST_KEY_802_1X_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{ {UCAST_KEY_802_1X_STATE_START, (fsm_Action_t)unicastKeySmNop},
{UCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)unicastKeySmNop},
{UCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)unicastKeySmNop},
{UCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)unicastKeySmUnexpected}
},
/* next state and actions for START state */
{ {UCAST_KEY_802_1X_STATE_START, (fsm_Action_t)unicastKeySmUnexpected},
{UCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)unicastKeySmNop},
{UCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)unicastKey802_1x_distribute},
{UCAST_KEY_802_1X_STATE_START, (fsm_Action_t)unicastKeySmNop}
},
/* next state and actions for COMPLETE state */
{ {UCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)unicastKeySmUnexpected},
{UCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)unicastKeySmNop},
{UCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)unicastKey802_1x_distribute},
{UCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)unicastKeySmUnexpected}
}
};
pUnicastKey->start = unicastKey802_1x_start;
pUnicastKey->stop = unicastKey802_1x_stop;
pUnicastKey->recvFailure = unicastKey802_1x_recvFailure;
pUnicastKey->recvSuccess = unicastKey802_1x_recvSuccess;
pUnicastKey->currentState = UCAST_KEY_802_1X_STATE_IDLE;
status = fsm_Config(pUnicastKey->pUcastKeySm,
&unicastKey802_1x_matrix[0][0],
UCAST_KEY_802_1X_NUM_STATES,
UCAST_KEY_802_1X_NUM_EVENTS,
NULL, pUnicastKey->hOs);
return status;
}
/**
*
* Function - externalSec_config.
*
* \b Description:
*
* Called by mainSecSM (mainSec_config).
* builds the SM and register the mainSec start and stop events.
*
* \b ARGS:
*
*
* \b RETURNS:
*
* TI_STATUS - 0 on success, any other value on failure.
*
*/
TI_STATUS externalSec_config(mainSec_t *pMainSec)
{
struct externalSec_t *pExtSec = pMainSec-> pExternalSec;
TI_STATUS status = TI_NOK;
/** Station externalSec State Machine matrix */
fsm_actionCell_t externalSec_matrix[EXTERNAL_SEC_NUM_STATES][EXTERNAL_SEC_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{
{EXTERNAL_SEC_STATE_WAIT,(fsm_Action_t)externalSecSM_Nop}, /*EXTERNAL_SEC_EVENT_START */
{EXTERNAL_SEC_STATE_IDLE,(fsm_Action_t)externalSecSM_Unexpected}, /*EXTERNAL_SEC_EVENT_COMPLETE*/
{EXTERNAL_SEC_STATE_IDLE,(fsm_Action_t)externalSecSM_Nop} /*EXTERNAL_SEC_EVENT_STOP */
},
/* next state and actions for Wait state */
{
{EXTERNAL_SEC_STATE_WAIT,(fsm_Action_t)externalSecSM_Unexpected},/*EXTERNAL_SEC_EVENT_START */
{EXTERNAL_SEC_STATE_IDLE,(fsm_Action_t)externalSecSM_setPort}, /*EXTERNAL_SEC_EVENT_COMPLETE*/
{EXTERNAL_SEC_STATE_IDLE,(fsm_Action_t)externalSecSM_Nop} /*EXTERNAL_SEC_EVENT_STOP */
}
};
pExtSec->hOs = pMainSec->hOs;
pExtSec->hReport = pMainSec->hReport;
pExtSec->pParent = pMainSec;
pMainSec->start = (mainSecSmStart_t)externalSecSM_start;
pMainSec->stop = (mainSecSmStart_t)externalSecSM_stop;
pExtSec->currentState = EXTERNAL_SEC_STATE_IDLE;
status = fsm_Config(pExtSec->pExternalSecSm,
&externalSec_matrix[0][0],
EXTERNAL_SEC_NUM_STATES,
EXTERNAL_SEC_NUM_EVENTS,
NULL, pExtSec->hOs);
return status;
}
/**
* \\n
* \date 10-Jan-2005\n
* \brief Initialize the scan SRV SM.
*
* Function Scope \e Public.\n
* \param hScanSrv - handle to the scan SRV object.\n
* \return TI_OK if successful, TI_NOK otherwise.\n
*/
TI_STATUS scanSRVSM_init( TI_HANDLE hScanSrv )
{
scanSRV_t* pScanSRV = (scanSRV_t*)hScanSrv;
fsm_actionCell_t smMatrix[ SCAN_SRV_NUM_OF_STATES ][ SCAN_SRV_NUM_OF_EVENTS ] =
{
/* next state and actions for IDLE state */
{
{SCAN_SRV_STATE_PS_WAIT, scanSRVSM_requestPS}, /*"REQUEST_PS",*/
{SCAN_SRV_STATE_IDLE, actionUnexpected}, /*"PS_FAIL",*/
{SCAN_SRV_STATE_SCANNING, scanSRVSM_startActualScan}, /*"PS_SUCCESS", */
{SCAN_SRV_STATE_IDLE, actionUnexpected}, /*"PS_PEND",*/
{SCAN_SRV_STATE_IDLE, actionUnexpected}, /*"STOP_SCAN"*/
{SCAN_SRV_STATE_IDLE, actionNop}, /*"FW_RESET"*/
{SCAN_SRV_STATE_IDLE, actionUnexpected}, /*"TIMER_EXPIRED"*/
{SCAN_SRV_STATE_IDLE, actionUnexpected}, /*"SCAN_COMPLETE"*/
},
/* next state and actions for PS_WAIT state */
{
{SCAN_SRV_STATE_PS_WAIT, actionUnexpected}, /*"REQUEST_PS",*/
{SCAN_SRV_STATE_PS_EXIT, scanSRVSM_releasePS}, /*"PS_FAIL",*/
{SCAN_SRV_STATE_SCANNING, scanSRVSM_startActualScan}, /*"PS_SUCCESS", */
{SCAN_SRV_STATE_PS_WAIT, actionNop}, /*"PS_PEND",*/
{SCAN_SRV_STATE_STOPPING, actionNop}, /*"STOP_SCAN"*/
{SCAN_SRV_STATE_IDLE, scanSRVSM_handleRecovery}, /*"FW_RESET"*/
{SCAN_SRV_STATE_PS_WAIT, actionUnexpected}, /*"TIMER_EXPIRED"*/
{SCAN_SRV_STATE_PS_WAIT, actionUnexpected}, /*"SCAN_COMPLETE"*/
},
/* next state and actions for SCANNING state */
{
{SCAN_SRV_STATE_SCANNING, actionUnexpected}, /*"REQUEST_PS",*/
{SCAN_SRV_STATE_SCANNING, scanSRVSM_PsFailWhileScanning}, /*"PS_FAIL",*/
{SCAN_SRV_STATE_SCANNING, actionUnexpected}, /*"PS_SUCCESS", */
{SCAN_SRV_STATE_SCANNING, actionUnexpected}, /*"PS_PEND",*/
{SCAN_SRV_STATE_STOPPING, actionNop }, /*"STOP_SCAN"*/
{SCAN_SRV_STATE_IDLE, scanSRVSM_handleRecovery}, /*"FW_RESET"*/
{SCAN_SRV_STATE_SCANNING, scanSRVSM_handleTimerExpiry}, /*"TIMER_EXPIRED"*/
{SCAN_SRV_STATE_PS_EXIT, scanSRVSM_releasePS}, /*"SCAN_COMPLETE"*/
},
/* next state and actions for STOPPING state */
{
{SCAN_SRV_STATE_STOPPING, actionUnexpected}, /*"REQUEST_PS",*/
{SCAN_SRV_STATE_PS_EXIT, scanSRVSM_releasePS}, /*"PS_FAIL",*/
{SCAN_SRV_STATE_PS_EXIT, scanSRVSM_releasePS}, /*"PS_SUCCESS", */
{SCAN_SRV_STATE_STOPPING, actionUnexpected}, /*"PS_PEND",*/
{SCAN_SRV_STATE_STOPPING, actionNop }, /*"STOP_SCAN"*/
{SCAN_SRV_STATE_IDLE, scanSRVSM_handleRecovery}, /*"FW_RESET"*/
{SCAN_SRV_STATE_STOPPING, scanSRVSM_handleTimerExpiry}, /*"TIMER_EXPIRED"*/
{SCAN_SRV_STATE_PS_EXIT, scanSRVSM_releasePS} /*"SCAN_COMPLETE"*/
} ,
/* next state and actions for PS_EXIT state */
{
{SCAN_SRV_STATE_PS_EXIT, actionUnexpected}, /*"REQUEST_PS",*/
{SCAN_SRV_STATE_IDLE, scanSRVSM_notifyScanComplete}, /*"PS_FAIL",*/
{SCAN_SRV_STATE_IDLE, scanSRVSM_notifyScanComplete}, /*"PS_SUCCESS", */
{SCAN_SRV_STATE_PS_EXIT, actionNop}, /*"PS_PEND",*/
{SCAN_SRV_STATE_PS_EXIT, actionNop}, /*"STOP_SCAN"*/
{SCAN_SRV_STATE_IDLE, scanSRVSM_handleRecovery}, /*"FW_RESET"*/
{SCAN_SRV_STATE_PS_EXIT, actionUnexpected}, /*"TIMER_EXPIRED"*/
{SCAN_SRV_STATE_PS_EXIT, actionUnexpected}, /*"SCAN_COMPLETE"*/
}
};
/* initialize current state */
pScanSRV->SMState = SCAN_SRV_STATE_IDLE;
/* configure the state machine */
return fsm_Config( pScanSRV->SM, (fsm_Matrix_t)smMatrix,
(TI_UINT8)SCAN_SRV_NUM_OF_STATES, (TI_UINT8)SCAN_SRV_NUM_OF_EVENTS,
(fsm_eventActivation_t)scanSRVSM_SMEvent, pScanSRV->hOS );
}
/**
*
* 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)
{
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)
{
return status;
}
status = keyParser_config(pMainKeys->pKeyParser,
pPaeConfig,
pMainKeys->pUcastSm,
pMainKeys->pBcastSm,
pMainKeys,
hReport,
hOs,
hCtrlData);
if (status != TI_OK)
{
return status;
}
status = broadcastKey_config(pMainKeys->pBcastSm, pPaeConfig, pMainKeys, hReport, hOs);
if (status != TI_OK)
{
return status;
}
status = unicastKey_config(pMainKeys->pUcastSm, pPaeConfig, pMainKeys, hReport, hOs);
if (status != TI_OK)
{
return status;
}
return TI_OK;
}
/**
*
* mlme_smConfig - configure a new MLME SM
*
* \b Description:
*
* Configure a new MLME SM and other modules handles.
*
* \b RETURNS:
*
* void
*
* \sa mlme_Create, mlme_Unload
*/
void mlme_init (TStadHandlesList *pStadHandles)
{
mlme_t *pHandle = (mlme_t *)(pStadHandles->hMlmeSm);
/** Main 802.1X State Machine matrix */
fsm_actionCell_t mlme_smMatrix[MLME_SM_NUM_STATES][MLME_SM_NUM_EVENTS] = {
/* next state and actions for IDLE state */
{{MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smStartIdle}, /* MLME_SM_EVENT_START */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smNOP}, /* MLME_SM_EVENT_STOP */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_SUCCESS */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_FAIL */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_ASSOC_SUCCESS */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smActionUnexpected} /* MLME_SM_EVENT_ASSOC_FAIL */
},
/* next state and actions for AUTH_WAIT state */
{{MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_START */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smNOP}, /* MLME_SM_EVENT_STOP */
{MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smAuthSuccessAuthWait}, /* MLME_SM_EVENT_AUTH_SUCCESS */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smAuthFailAuthWait}, /* MLME_SM_EVENT_AUTH_FAIL */
{MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_ASSOC_SUCCESS */
{MLME_SM_STATE_AUTH_WAIT, (fsm_Action_t)mlme_smActionUnexpected} /* MLME_SM_EVENT_ASSOC_FAIL */
},
/* next state and actions for ASSOC_WAIT state */
{{MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_START */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smStopAssocWait}, /* MLME_SM_EVENT_STOP */
{MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_SUCCESS */
{MLME_SM_STATE_ASSOC_WAIT, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_FAIL */
{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smAssocSuccessAssocWait}, /* MLME_SM_EVENT_ASSOC_SUCCESS */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smAssocFailAssocWait} /* MLME_SM_EVENT_ASSOC_FAIL */
},
/* next state and actions for ASSOC state */
{{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_START */
{MLME_SM_STATE_IDLE, (fsm_Action_t)mlme_smStopAssoc}, /* MLME_SM_EVENT_STOP */
{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_SUCCESS */
{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_AUTH_FAIL */
{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected}, /* MLME_SM_EVENT_ASSOC_SUCCESS */
{MLME_SM_STATE_ASSOC, (fsm_Action_t)mlme_smActionUnexpected} /* MLME_SM_EVENT_ASSOC_FAIL */
}
};
fsm_Config(pHandle->pMlmeSm, &mlme_smMatrix[0][0], MLME_SM_NUM_STATES, MLME_SM_NUM_EVENTS, mlme_smEvent, pStadHandles->hOs);
pHandle->currentState = MLME_SM_STATE_IDLE;
pHandle->legacyAuthType = AUTH_LEGACY_NONE;
pHandle->reAssoc = TI_FALSE;
pHandle->disConnType = DISCONNECT_IMMEDIATE;
pHandle->disConnReason = STATUS_UNSPECIFIED;
pHandle->hAssoc = pStadHandles->hAssoc;
pHandle->hAuth = pStadHandles->hAuth;
pHandle->hSiteMgr = pStadHandles->hSiteMgr;
pHandle->hCtrlData = pStadHandles->hCtrlData;
pHandle->hTxMgmtQ = pStadHandles->hTxMgmtQ;
pHandle->hMeasurementMgr = pStadHandles->hMeasurementMgr;
pHandle->hSwitchChannel = pStadHandles->hSwitchChannel;
pHandle->hRegulatoryDomain = pStadHandles->hRegulatoryDomain;
pHandle->hReport = pStadHandles->hReport;
pHandle->hOs = pStadHandles->hOs;
pHandle->hConn = pStadHandles->hConn;
pHandle->hCurrBss = pStadHandles->hCurrBss;
pHandle->hApConn = pStadHandles->hAPConnection;
pHandle->hScanCncn = pStadHandles->hScanCncn;
pHandle->hQosMngr = pStadHandles->hQosMngr;
pHandle->hTWD = pStadHandles->hTWD;
pHandle->hTxCtrl = pStadHandles->hTxCtrl;
/*
debug info
*/
pHandle->debug_lastProbeRspTSFTime = 0;
pHandle->debug_lastDtimBcnTSFTime = 0;
pHandle->debug_lastBeaconTSFTime = 0;
pHandle->debug_isFunctionFirstTime = TI_TRUE;
pHandle->BeaconsCounterPS = 0;
}
/**
* Configures the Measurement Manager State Machine.
*
* @param hMeasurementMgr A handle to the Measurement Manager module.
*
* @date 01-Jan-2006
*/
TI_STATUS measurementMgrSM_config(TI_HANDLE hMeasurementMgr)
{
measurementMgr_t * pMeasurementMgr = (measurementMgr_t *) hMeasurementMgr;
TI_STATUS status;
/* MeasurementMgr State Machine matrix */
fsm_actionCell_t measurementMgr_matrix[MEASUREMENTMGR_NUM_STATES][MEASUREMENTMGR_NUM_EVENTS] = {
/* next state and actions for STATE_IDLE state */
{
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acConnected}, /* CONNECTED */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisconnected_fromIdle}, /* DISCONNECTED */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acEnable}, /* ENABLE */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisable_fromIdle}, /* DISABLE */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acFrameReceived_fromIdle}, /* FRAME_RECV */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acSendReportAndCleanObj}, /* SEND_REPORT */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acUnexpected}, /* REQUEST_SCR */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acUnexpected}, /* SCR_WAIT */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acUnexpected}, /* SCR_RUN */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acUnexpected}, /* ABORT */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acUnexpected}, /* COMPLETE */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acUnexpected} /* FW_RESET */
},
/* next state and actions for STATE_PROCESSING_REQUEST state */
{
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acUnexpected}, /* CONNECTED */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisconnected_fromProcessingRequest}, /* DISCONNECTED */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acNop}, /* ENABLE */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisable_fromProcessingRequest}, /* DISABLE */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acFrameReceived_fromProcessingRequest}, /* FRAME_RECV */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acSendReportAndCleanObj}, /* SEND_REPORT */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acRequestSCR}, /* REQUEST_SCR */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acUnexpected}, /* SCR_WAIT */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acUnexpected}, /* SCR_RUN */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acAbort_fromProcessingRequest}, /* ABORT */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acUnexpected}, /* COMPLETE */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acUnexpected} /* FW_RESET */
},
/* next state and actions for STATE_WAITING_FOR_SCR state */
{
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acUnexpected}, /* CONNECTED */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisconnected_fromWaitForSCR}, /* DISCONNECTED */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acNop}, /* ENABLE */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisable_fromWaitForSCR}, /* DISABLE */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acFrameReceived_fromWaitForSCR}, /* FRAME_RECV */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acUnexpected}, /* SEND_REPORT */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acUnexpected}, /* REQUEST_SCR */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acNop}, /* SCR_WAIT */
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acStartMeasurement}, /* SCR_RUN */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acAbort_fromWaitForSCR}, /* ABORT */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acUnexpected}, /* COMPLETE */
{MEASUREMENTMGR_STATE_WAITING_FOR_SCR, measurementMgrSM_acUnexpected} /* FW_RESET */
},
/* next state and actions for STATE_MEASURING state */
{
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acUnexpected}, /* CONNECTED */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisconnected_fromMeasuring}, /* DISCONNECTED */
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acNop}, /* ENABLE */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acDisable_fromMeasuring}, /* DISABLE */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acFrameReceived_fromMeasuring}, /* FRAME_RECV */
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acUnexpected}, /* SEND_REPORT */
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acUnexpected}, /* REQUEST_SCR */
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acUnexpected}, /* SCR_WAIT */
{MEASUREMENTMGR_STATE_MEASURING, measurementMgrSM_acUnexpected}, /* SCR_RUN */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acAbort_fromMeasuring}, /* ABORT */
{MEASUREMENTMGR_STATE_PROCESSING_REQUEST, measurementMgrSM_acMeasurementComplete}, /* COMPLETE */
{MEASUREMENTMGR_STATE_IDLE, measurementMgrSM_acFirmwareReset} /* FW_RESET */
}
};
TRACE0(pMeasurementMgr->hReport, REPORT_SEVERITY_INFORMATION, ": Configured MeasurementMgr state machine\n");
status = fsm_Config(pMeasurementMgr->pMeasurementMgrSm,
&measurementMgr_matrix[0][0],
MEASUREMENTMGR_NUM_STATES,
MEASUREMENTMGR_NUM_EVENTS,
measurementMgrSM_event, pMeasurementMgr->hOs);
return status;
}
/**
*
* 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_config(mainKeys_t *pMainKeys,
rsn_paeConfig_t *pPaeConfig,
void *pParent,
TI_HANDLE hReport,
TI_HANDLE hOs,
TI_HANDLE hCtrlData,
TI_HANDLE hEvHandler,
TI_HANDLE hConn,
TI_HANDLE hRsn )
{
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->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;
status = fsm_Config(pMainKeys->pMainKeysSm, &mainKeysSM_matrix[0][0],
MAIN_KEYS_NUM_STATES, MAIN_KEYS_NUM_EVENTS, NULL, pMainKeys->hOs);
if (status != OK)
{
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("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 != OK)
{
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error in configuring key parser\n"));
return status;
}
status = broadcastKey_config(pMainKeys->pBcastSm, pPaeConfig, pMainKeys, hReport, hOs);
if (status != OK)
{
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error in configuring broadcast key SM\n"));
return status;
}
status = unicastKey_config(pMainKeys->pUcastSm, pPaeConfig, pMainKeys, hReport, hOs);
if (status != OK)
{
WLAN_REPORT_ERROR(pMainKeys->hReport, RSN_MODULE_LOG,
("MAIN_KEYS_SM: Error in configuring unicast key SM\n"));
return status;
}
return OK;
}
/**
*
* \b Description:
*
* This procedure is called by the DrvMain when the driver is initialized.
* It initializes the SwitchChannel object's variables and handlers and creates the SwitchChannel SM.
*
* \b ARGS:
*
* I - pStadHandles - The driver modules handles \n
*
* \b RETURNS:
*
* void
*
* \sa
*/
void switchChannel_init (TStadHandlesList *pStadHandles)
{
switchChannel_t *pSwitchChannel = (switchChannel_t *)(pStadHandles->hSwitchChannel);
/** Roaming State Machine matrix */
fsm_actionCell_t switchChannel_SM[SC_NUM_STATES][SC_NUM_EVENTS] = {
/* next state and actions for IDLE state */
{ {SC_STATE_WAIT_4_CMD, switchChannel_smStart}, /* START */
{SC_STATE_IDLE, switchChannel_smNop}, /* STOP */
{SC_STATE_IDLE, switchChannel_smNop}, /* SC_CMD */
{SC_STATE_IDLE, switchChannel_smUnexpected}, /* SCR_RUN */
{SC_STATE_IDLE, switchChannel_smUnexpected}, /* SCR_FAIL */
{SC_STATE_IDLE, switchChannel_smUnexpected}, /* SC_CMPLT */
{SC_STATE_IDLE, switchChannel_smUnexpected} /* FW_RESET */
},
/* next state and actions for WAIT_4_CMD state */
{ {SC_STATE_WAIT_4_CMD, switchChannel_smNop}, /* START */
{SC_STATE_IDLE, switchChannel_smStopWhileWait4Cmd}, /* STOP */
{SC_STATE_WAIT_4_SCR, switchChannel_smReqSCR_UpdateCmd}, /* SC_CMD */
{SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SCR_RUN */
{SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SCR_FAIL */
{SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SC_CMPLT */
{SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected} /* FW_RESET */
},
/* next state and actions for WAIT_4_SCR state */
{ {SC_STATE_WAIT_4_SCR, switchChannel_smUnexpected}, /* START */
{SC_STATE_IDLE, switchChannel_smStopWhileWait4Scr}, /* STOP */
{SC_STATE_WAIT_4_SCR, switchChannel_smNop}, /* SC_CMD */
{SC_STATE_SC_IN_PROG, switchChannel_smStartSwitchChannelCmd}, /* SCR_RUN */
{SC_STATE_WAIT_4_CMD, switchChannel_smScrFailWhileWait4Scr}, /* SCR_FAIL */
{SC_STATE_WAIT_4_SCR, switchChannel_smUnexpected} , /* SC_CMPLT */
{SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected} /* FW_RESET */
},
/* next state and actions for switchChannel_IN_PROG state */
{ {SC_STATE_SC_IN_PROG, switchChannel_smUnexpected}, /* START */
{SC_STATE_IDLE, switchChannel_smStopWhileSwitchChannelInProg}, /* STOP */
{SC_STATE_SC_IN_PROG, switchChannel_smNop}, /* SC_CMD */
{SC_STATE_SC_IN_PROG, switchChannel_smUnexpected}, /* SCR_RUN */
{SC_STATE_WAIT_4_CMD, switchChannel_smUnexpected}, /* SCR_FAIL */
{SC_STATE_WAIT_4_CMD, switchChannel_smSwitchChannelCmplt}, /* SC_CMPLT */
{SC_STATE_WAIT_4_CMD, switchChannel_smFwResetWhileSCInProg} /* FW_RESET */
}
};
fsm_Config(pSwitchChannel->pSwitchChannelSm,
&switchChannel_SM[0][0],
SC_NUM_STATES,
SC_NUM_EVENTS,
switchChannel_smEvent, pSwitchChannel->hOs);
/* init handlers */
pSwitchChannel->hTWD = pStadHandles->hTWD;
pSwitchChannel->hSiteMgr = pStadHandles->hSiteMgr;
pSwitchChannel->hSCR = pStadHandles->hSCR;
pSwitchChannel->hRegulatoryDomain = pStadHandles->hRegulatoryDomain;
pSwitchChannel->hApConn = pStadHandles->hAPConnection;
pSwitchChannel->hReport = pStadHandles->hReport;
pSwitchChannel->hOs = pStadHandles->hOs;
}
/**
*
* assoc_config - configure a new association SM
*
* \b Description:
*
* Configure a new association SM.
*
* \b ARGS:
*
* I - hAssoc - Association SM context \n
* I - hMlme - MLME SM context \n
* I - hSiteMgr - Site manager context \n
* I - hCtrlData - Control data context \n
* I - hTxData - TX data context \n
* I - hHalCtrl - Hal control context \n
* I - hReport - Report context \n
* I - hOs - OS context \n
* I - assocTimeout - Association SM timeout \n
* I - assocMaxCount - Max number of association requests to send \n
*
* \b RETURNS:
*
* OK if successful, NOK otherwise.
*
* \sa assoc_Create, assoc_Unload
*/
TI_STATUS assoc_config(TI_HANDLE hAssoc,
TI_HANDLE hMlme,
TI_HANDLE hRegulatoryDomain,
TI_HANDLE hSiteMgr,
TI_HANDLE hCtrlData,
TI_HANDLE hTxData,
TI_HANDLE hHalCtrl,
TI_HANDLE hRsn,
TI_HANDLE hReport,
TI_HANDLE hOs,
TI_HANDLE hExcMngr,
TI_HANDLE hQosMngr,
TI_HANDLE hMeasurementMgr,
TI_HANDLE hApConn,
assocInitParams_t *pAssocInitParams)
{
assoc_t *pHandle;
TI_STATUS status;
/** Main 802.1X State Machine matrix */
fsm_actionCell_t assoc_smMatrix[ASSOC_SM_NUM_STATES][ASSOC_SM_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{{ASSOC_SM_STATE_WAIT, (fsm_Action_t)assoc_smStartIdle},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smActionUnexpected}
},
/* next state and actions for WAIT state */
{{ASSOC_SM_STATE_WAIT, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smStopWait},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smSuccessWait},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smFailureWait},
{ASSOC_SM_STATE_WAIT, (fsm_Action_t)assoc_smTimeoutWait},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smMaxRetryWait}
},
/* next state and actions for ASSOC state */
{{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_IDLE, (fsm_Action_t)assoc_smStopAssoc},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected},
{ASSOC_SM_STATE_ASSOC, (fsm_Action_t)assoc_smActionUnexpected}
}};
if (hAssoc == NULL)
{
return NOK;
}
pHandle = (assoc_t*)hAssoc;
/* configure state machine */
status = fsm_Config(pHandle->pAssocSm, &assoc_smMatrix[0][0],
ASSOC_SM_NUM_STATES, ASSOC_SM_NUM_EVENTS, NULL, hOs);
if (status != OK)
{
return NOK;
}
pHandle->assocRejectCount = 0;
pHandle->assocTimeoutCount = 0;
pHandle->currentState = ASSOC_SM_STATE_IDLE;
pHandle->hMlme = hMlme;
pHandle->hRegulatoryDomain = hRegulatoryDomain;
pHandle->hSiteMgr = hSiteMgr;
pHandle->hCtrlData = hCtrlData;
pHandle->hTxData = hTxData;
pHandle->hHalCtrl = hHalCtrl;
pHandle->hRsn = hRsn;
pHandle->hReport = hReport;
pHandle->hOs = hOs;
pHandle->hExcMngr = hExcMngr;
pHandle->hQosMngr = hQosMngr;
pHandle->hMeasurementMgr = hMeasurementMgr;
pHandle->hApConn = hApConn;
pHandle->timeout = pAssocInitParams->assocResponseTimeout;
pHandle->maxCount = pAssocInitParams->assocMaxRetryCount;
return OK;
}
/**
* \\n
* \date 08-November-2005\n
* \brief Initialize the measurement SRV SM.\n
*
* Function Scope \e Public.\n
* \param hMeasurementSrv - handle to the Measurement SRV object.\n
* \return TI_OK if successful, TI_NOK otherwise.\n
*/
TI_STATUS measurementSRVSM_init( TI_HANDLE hMeasurementSRV )
{
measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
fsm_actionCell_t smMatrix[ MSR_SRV_NUM_OF_STATES ][ MSR_SRV_NUM_OF_EVENTS ] =
{
/* next state and actions for IDLE state */
{
{MSR_SRV_STATE_WAIT_FOR_DRIVER_MODE, measurementSRVSM_requestDriverMode}, /*"MESSURE_START_REQUEST"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"ALL_TYPES_COMPLETE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"STOP_COMPLETE"*/
{MSR_SRV_STATE_IDLE, measurementSRVSRVSM_dummyStop} /*"MEASURE_STOP_REQUEST"*/
},
/* next state and actions for WAIT_FOR_DRIVER_MODE state */
{
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"MESSURE_START_REQUEST"*/
{MSR_SRV_STATE_WAIT_FOR_MEASURE_START, measurementSRVSM_requestMeasureStart}, /*"DRIVER_MODE_SUCCESS"*/
{MSR_SRV_STATE_IDLE, measurementSRVSM_DriverModeFailure}, /*"DRIVER_MODE_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"ALL_TYPES_COMPLETE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"STOP_COMPLETE"*/
{MSR_SRV_STATE_IDLE, measurementSRVSM_stopFromWaitForDriverMode} /*"MEASURE_STOP_REQUEST"*/
},
/* next state and actions for WAIT_FOR_MEASURE_START state */
{
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"MESSURE_START_REQUEST"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_FAILURE"*/
{MSR_SRV_STATE_MEASURE_IN_PROGRESS, measurementSRVSM_startMeasureTypes}, /*"START_SUCCESS"*/
{MSR_SRV_STATE_IDLE, measurementSRVSM_measureStartFailure}, /*"START_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"ALL_TYPES_COMPLETE"*/
{MSR_SRV_STATE_IDLE, measurementSRVSM_completeMeasure}, /*"STOP_COMPLETE"*/
{MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSM_stopFromWaitForMeasureStart}
/*"MEASURE_STOP_REQUEST"*/
},
/* next state and actions for MEASURE_IN_PROGRESS state */
{
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"MESSURE_START_REQUEST"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_FAILURE"*/
{MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSM_requestMeasureStop}, /*"ALL_TYPES_COMPLETE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"STOP_COMPLETE"*/
{MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSM_stopFromMeasureInProgress}
/*"MEASURE_STOP_REQUEST"*/
},
/* next state and actions for WAIT_FOR_MEASURE_STOP state */
{
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"MESSURE_START_REQUEST"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"DRIVER_MODE_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_SUCCESS"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"START_FAILURE"*/
{MSR_SRV_STATE_IDLE, actionUnexpected}, /*"ALL_TYPES_COMPLETE"*/
{MSR_SRV_STATE_IDLE, measurementSRVSM_completeMeasure}, /*"STOP_COMPLETE"*/
{MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSRVSM_dummyStop} /*"MEASURE_STOP_REQUEST"*/
}
};
/* initialize current state */
pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;
/* configure the state machine */
return fsm_Config( pMeasurementSRV->SM, (fsm_Matrix_t)smMatrix,
(TI_UINT8)MSR_SRV_NUM_OF_STATES, (TI_UINT8)MSR_SRV_NUM_OF_EVENTS,
(fsm_eventActivation_t)measurementSRVSM_SMEvent, pMeasurementSRV->hOS );
}
/***********************************************************************
* conn_infraConfig
***********************************************************************
DESCRIPTION: Infra Connection configuration function, called by the conection set param function
in the selection phase. Configures the connection state machine to Infra connection mode
INPUT: hConn - Connection handle.
OUTPUT:
RETURN: OK on success, NOK otherwise
************************************************************************/
TI_STATUS conn_infraConfig(conn_t *pConn)
{
fsm_actionCell_t smMatrix[CONN_INFRA_NUM_STATES][CONN_INFRA_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{ {STATE_CONN_INFRA_SCR_WAIT, Idle_to_ScrWait}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_IDLE, actionNop }, /* "EVENT_SCR_SUCC"*/
{STATE_CONN_INFRA_IDLE, actionNop }, /* "EVENT_JOIN_CMD_CMPLT */
{STATE_CONN_INFRA_IDLE, Idle_to_Idle }, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_IDLE, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_IDLE, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_IDLE, actionUnexpected}, /* "EVENT_CONFIG_HW" */
{STATE_CONN_INFRA_IDLE, actionUnexpected} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for SCR_WAIT state */
{ {STATE_CONN_INFRA_SCR_WAIT, actionUnexpected}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_WAIT_JOIN_CMPLT, ScrWait_to_JoinWait}, /* "EVENT_SCR_SUCC"*/
{STATE_CONN_INFRA_SCR_WAIT, actionUnexpected}, /* "EVENT_JOIN_CMD_CMPLT */
{STATE_CONN_INFRA_IDLE, ScrWait_to_idle}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_SCR_WAIT, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_SCR_WAIT, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_SCR_WAIT, actionUnexpected}, /* "EVENT_CONFIG_HW "*/
{STATE_CONN_INFRA_SCR_WAIT, actionNop} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for WAIT_JOIN_CMPLT */
{ {STATE_CONN_INFRA_WAIT_JOIN_CMPLT, actionUnexpected}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_WAIT_JOIN_CMPLT, actionUnexpected}, /* "EVENT_SCR_SUCC"*/
{STATE_CONN_INFRA_MLME_WAIT, JoinWait_to_mlmeWait}, /* "EVENT_JOIN_CMD_CMPLT" */
{STATE_CONN_INFRA_IDLE, JoinWait_to_Idle}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_WAIT_JOIN_CMPLT, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_WAIT_JOIN_CMPLT, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_WAIT_JOIN_CMPLT, actionUnexpected}, /* "EVENT_CONFIG_HW" */
{STATE_CONN_INFRA_WAIT_JOIN_CMPLT, actionUnexpected} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for MLME_WAIT state */
{ {STATE_CONN_INFRA_MLME_WAIT, actionUnexpected}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_MLME_WAIT, actionUnexpected}, /* "EVENT_SCR_SUCC" */
{STATE_CONN_INFRA_MLME_WAIT, actionUnexpected}, /* "EVENT_JOIN_CMD_CMPLT"*/
{STATE_CONN_INFRA_IDLE, mlmeWait_to_Idle}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_RSN_WAIT, mlmeWait_to_rsnWait}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_MLME_WAIT, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_MLME_WAIT, actionUnexpected}, /* "EVENT_CONFIG_HW" */
{STATE_CONN_INFRA_MLME_WAIT, actionUnexpected} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for RSN_WAIT state */
{ {STATE_CONN_INFRA_RSN_WAIT, actionUnexpected}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_RSN_WAIT, actionUnexpected}, /* "EVENT_SCR_SUCC" */
{STATE_CONN_INFRA_RSN_WAIT, actionUnexpected}, /* "EVENT_JOIN_CMD_CMPLT"*/
{STATE_CONN_INFRA_DISASSOCC, rsnWait_to_disassociate}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_RSN_WAIT, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_CONFIG_HW, rsnWait_to_configHW}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_RSN_WAIT, actionUnexpected}, /* "EVENT_CONFIG_HW" */
{STATE_CONN_INFRA_RSN_WAIT, actionUnexpected} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for CONFIG_HW state */
{ {STATE_CONN_INFRA_CONFIG_HW, actionUnexpected}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_CONFIG_HW, actionUnexpected}, /* "EVENT_SCR_SUCC" */
{STATE_CONN_INFRA_CONFIG_HW, actionUnexpected}, /* "EVENT_JOIN_CMD_CMPLT"*/
{STATE_CONN_INFRA_DISASSOCC, configHW_to_disassociate}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_CONFIG_HW, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_CONFIG_HW, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_CONNECTED, configHW_to_connected}, /* "EVENT_CONFIG_HW" */
{STATE_CONN_INFRA_CONFIG_HW, actionUnexpected} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for CONNECTED state */
{ {STATE_CONN_INFRA_SCR_WAIT, connect_to_ScrWait}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_CONNECTED, actionUnexpected}, /* "EVENT_SCR_SUCC"*/
{STATE_CONN_INFRA_CONNECTED, actionUnexpected}, /* "EVENT_JOIN_CMD_CMPLT" */
{STATE_CONN_INFRA_DISASSOCC, connect_to_disassociate}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_CONNECTED, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_CONNECTED, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_CONNECTED, actionUnexpected}, /* "STATE_CONN_INFRA_CONFIG_HW" */
{STATE_CONN_INFRA_CONNECTED, actionUnexpected} /* "EVENT_DISASSOC_FRAME_SENT" */
},
/* next state and actions for STATE_CONN_INFRA_DISASSOCC state */
{ {STATE_CONN_INFRA_DISASSOCC, actionUnexpected}, /* "EVENT_CONNECT" */
{STATE_CONN_INFRA_DISASSOCC, actionUnexpected}, /* "STATE_CONN_INFRA_SCR_WAIT"*/
{STATE_CONN_INFRA_DISASSOCC, actionUnexpected}, /* "EVENT_JOIN_CMD_CMPLT" */
{STATE_CONN_INFRA_DISASSOCC, actionUnexpected}, /* "EVENT_DISCONNECT" */
{STATE_CONN_INFRA_DISASSOCC, actionUnexpected}, /* "EVENT_MLME_SUCC"*/
{STATE_CONN_INFRA_DISASSOCC, actionUnexpected}, /* "EVENT_RSN_SUCC" */
{STATE_CONN_INFRA_DISASSOCC, actionNop }, /* "STATE_CONN_INFRA_CONFIG_HW" */
{STATE_CONN_INFRA_IDLE, disAssocc_to_idle} /* "EVENT_DISASSOC_FRAME_SENT" */
}
};
scr_registerClientCB( pConn->hScr, SCR_CID_CONNECT, InfraConnSM_ScrCB, pConn );
return fsm_Config(pConn->infra_pFsm, (fsm_Matrix_t)smMatrix, CONN_INFRA_NUM_STATES, CONN_INFRA_NUM_EVENTS, conn_infraSMEvent, pConn->hOs);
}
/**
*
* sharedKeyAuth_smConfig - configure a new authentication SM
*
* \b Description:
*
* Configure a new authentication SM.
*
* \b ARGS:
*
* I - hAuth - Association SM context \n
* I - hMlme - MLME SM context \n
* I - hSiteMgr - Site manager context \n
* I - hCtrlData - Control data context \n
* I - hTxData - TX data context \n
* I - hHalCtrl - Hal control context \n
* I - hReport - Report context \n
* I - hOs - OS context \n
* I - authTimeout - Association SM timeout \n
* I - authMaxCount - Max number of authentication requests to send \n
*
* \b RETURNS:
*
* TI_OK if successful, TI_NOK otherwise.
*
* \sa sharedKeyAuth_Create, sharedKeyAuth_Unload
*/
TI_STATUS sharedKeyAuth_Config(TI_HANDLE hAuth, TI_HANDLE hOs)
{
auth_t *pHandle;
TI_STATUS status;
/** Main 802.1X State Machine matrix */
fsm_actionCell_t sharedKeyAuth_smMatrix[SHARED_KEY_AUTH_SM_NUM_STATES][SHARED_KEY_AUTH_SM_NUM_EVENTS] =
{
/* next state and actions for IDLE state */
{{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smStartIdle},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}
},
/* next state and actions for WAIT_1 state */
{{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopWait},
{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smSuccess1Wait1},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smFailure1Wait1},
{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smTimeoutWait1},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smMaxRetryWait}
},
/* next state and actions for WAIT_2 state */
{{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopWait},
{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smSuccess2Wait2},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smFailure2Wait2},
{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smTimeoutWait2},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smMaxRetryWait}
},
/* next state and actions for AUTH state */
{{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopAuth},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected},
{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}
}};
if (hAuth == NULL)
{
return TI_NOK;
}
pHandle = (auth_t*)hAuth;
status = fsm_Config(pHandle->pAuthSm, &sharedKeyAuth_smMatrix[0][0],
SHARED_KEY_AUTH_SM_NUM_STATES, SHARED_KEY_AUTH_SM_NUM_EVENTS, auth_skSMEvent, hOs);
if (status != TI_OK)
{
return TI_NOK;
}
pHandle->currentState = SHARED_KEY_AUTH_SM_STATE_IDLE;
return TI_OK;
}
