/*
* mainSecKeysOnly.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 mainSecSm.c
* \brief 802.1X finite state machine header file
*
* \see mainSecSm.h
*/
/***************************************************************************/
/* */
/* MODULE: mainSecSm.c */
/* PURPOSE: Main Security State Machine API */
/* */
/***************************************************************************/
#define __FILE_ID__ FILE_ID_37
#include "osApi.h"
#include "paramOut.h"
#include "fsm.h"
#include "report.h"
#include "DataCtrl_Api.h"
#include "smeApi.h"
#include "rsn.h"
#include "rsnApi.h"
#include "mainSecSm.h"
#include "mainSecKeysOnly.h"
#include "mainKeysSm.h"
/* Constants */
/* Enumerations */
/* Typedefs */
/* Structures */
/* External data definitions */
/* External functions definitions */
/* Global variables */
/* functions */
TI_STATUS mainSecKeysOnly_getAuthState(mainSec_t *pMainSec, TIWLN_SECURITY_STATE *supp1XState);
TI_STATUS mainSecKeysOnly_reportAuthFailure(mainSec_t *pMainSec, EAuthStatus authStatus) ;
TI_STATUS mainSecKeysOnly_setAuthIdentity(mainSec_t *pMainSec, authIdentity_t *authIdentity);
/**
*
* rsn_mainSecSmKeysOnlyInit
*
* \b Description:
*
* Init main security state machine state machine
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* TI_OK on success, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_config(mainSec_t *pMainSec,
TRsnPaeConfig *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 != TI_OK)
{
TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "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;
TRACE0(pMainSec->hReport, REPORT_SEVERITY_INFORMATION, "mainSecKeysOnly_config\n");
return TI_OK;
}
/**
*
* mainSecSmNull_Start
*
* \b Description:
*
* Start the NULL main security SM. Reports success to the rsn module immediately.
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* TI_OK on success, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_start(mainSec_t *pMainSec)
{
TI_STATUS status;
status = fsm_Event(pMainSec->pMainSecSm, &pMainSec->currentState, MAIN_KO_EVENT_START, pMainSec);
return status;
}
/**
*
* mainSecSmNull_Stop
*
* \b Description:
*
* Start the NULL main security SM. Reports success to the rsn module immediately.
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* TI_OK on success, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_stop(mainSec_t *pMainSec)
{
TI_STATUS status;
status = fsm_Event(pMainSec->pMainSecSm, &pMainSec->currentState, MAIN_KO_EVENT_STOP, pMainSec);
return status;
}
/**
*
* mainSecSmNull_Stop
*
* \b Description:
*
* Start the NULL main security SM. Reports success to the rsn module immediately.
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* TI_OK on success, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_reportKeysStatus(mainSec_t *pMainSec, TI_STATUS keysStatus)
{
TI_STATUS status;
pMainSec->data.status = keysStatus;
if (keysStatus == TI_OK)
{
status = fsm_Event(pMainSec->pMainSecSm, &pMainSec->currentState, MAIN_KO_EVENT_KEYS_COMPLETE, pMainSec);
} else {
TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error in Keys\n");
status = TI_OK;
}
return status;
}
/**
*
* mainSecSmNull_setKey
*
* \b Description:
*
* Start the NULL main security SM. Reports success to the rsn module immediately.
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* TI_OK on success, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_setSessionKey(mainSec_t *pMainSec, TI_UINT8* pKey, TI_UINT8 keyLen)
{
os_memoryCopy(pMainSec->hOs, pMainSec->sessionKey, pKey, keyLen);
pMainSec->sessionKeyLen = keyLen;
return TI_OK;
}
/**
*
* mainSecSmNull_setKey
*
* \b Description:
*
* Start the NULL main security SM. Reports success to the rsn module immediately.
*
* \b ARGS:
*
* none
*
* \b RETURNS:
*
* TI_OK on success, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_getSessionKey(mainSec_t *pMainSec, TI_UINT8* pKey, TI_UINT32* pKeyLen)
{
os_memoryCopy(pMainSec->hOs, pKey, pMainSec->sessionKey, pMainSec->sessionKeyLen);
*pKeyLen = pMainSec->sessionKeyLen;
return TI_OK;
}
/* State machine implementation functions */
TI_STATUS mainSecKeysOnly_startIdle(struct _mainSec_t *pMainSec)
{
TI_STATUS status = TI_OK;
TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StartIdle...\n");
status = pMainSec->pMainKeys->start(pMainSec->pMainKeys);
return status;
}
TI_STATUS mainSecKeysOnly_stopStart(struct _mainSec_t *pMainSec)
{
TI_STATUS status = TI_OK;
TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StopStart...\n");
status = pMainSec->pMainKeys->stop(pMainSec->pMainKeys);
return status;
}
TI_STATUS mainSecKeysOnly_keysCompleteStart(struct _mainSec_t *pMainSec)
{
TI_STATUS status = TI_OK;
TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_KeysCompleteAuthenticated...\n");
status = pMainSec->pParent->reportStatus(pMainSec->pParent, pMainSec->data.status);
return(status);
}
TI_STATUS mainSecKeysOnly_keysTOStart(struct _mainSec_t *pMainSec)
{
TI_STATUS status = TI_OK;
return(status);
}
TI_STATUS mainSecKeysOnly_stopAuthorized(struct _mainSec_t *pMainSec)
{
TI_STATUS status = TI_OK;
TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StopAuthorized...\n");
status = pMainSec->pMainKeys->stop(pMainSec->pMainKeys);
return(status);
}
TI_STATUS mainSecKeysOnly_stopNonAuthorized(struct _mainSec_t *pMainSec)
{
TI_STATUS status = TI_OK;
TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StopNonAuthorized...\n");
status = pMainSec->pMainKeys->stop(pMainSec->pMainKeys);
return(status);
}
/* state machine action functions */
TI_STATUS mainSecKeysOnly_Nop(void* pData)
{
return(TI_OK);
}
TI_STATUS mainSecKeysOnly_unexpected(void* pData)
{
return TI_NOK;
}
/**
*
* mainSecKeysOnly_getAuthState: \n
*
* \b Description:
*
* Get authentication state from supp1x SM.
*
* \b ARGS:
*
* I - pMainSec - pMainSec SM context \n
* I - authIdentity - pointer to authentication state \n
*
* \b RETURNS:
*
* TI_OK if successful, TI_NOK otherwise.
*
* \sa
*/
TI_STATUS mainSecKeysOnly_getAuthState(mainSec_t *pMainSec, TIWLN_SECURITY_STATE *secState)
{
switch (pMainSec->currentState)
{
case MAIN_KO_STATE_START:
*secState = eSecurityStateAuthenticating;
break;
case MAIN_KO_STATE_AUTHORIZED:
*secState = eSecurityStateAuthenticated;
break;
case MAIN_KO_STATE_NONAUTHORIZED:
*secState = eSecurityStateNotAuthenticated ;
break;
default:
*secState = eSecurityStateHalted;
break;
}
return TI_OK;
} /*mainSecKeysOnly_getAuthState*/
TI_STATUS mainSecKeysOnly_reportAuthFailure(mainSec_t *pMainSec, EAuthStatus authStatus)
{
return TI_OK;
}
TI_STATUS mainSecKeysOnly_setAuthIdentity(mainSec_t *pMainSec, authIdentity_t *authIdentity)
{
return TI_OK;
}