bs_common.c

wimax bs模拟器

/******************************************************************************\


			Copyright  (c)	2007,  UTStarcom,Inc. (ShenZhen R&D Center)
			All Rights Reserved.

			Subsystem		: WIMAX
			Group			: GW/AnchorDP/...
			File				: bs_common.c
			Version			: 
			Build			: 
			Author			: RCT
			Maintained by		: RCT
			Create Date		: 2007-01-22
			Last Modify		: 
			Description		: BS SIM Common
																			  
\******************************************************************************/
/*
-----------------------------------------------------------
Software Develop CodeName :

Module Reference :
	
-----------------------------------------------------------
Change History:

07-01.22	RCT		create file.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dbgLib.h>
#include <usrLib.h>
#include <inetLib.h>
#include <tickLib.h>
#include "global.h"
#include "xcommon.h"
#include "bs_common.h"
#include "bs_fsm.h"
#include "bs_ue.h"

#if (defined(_BS_DEBUG_ ) && defined(_BS_USING_PRIV_DEBUG_))
unsigned int gBsTraceLevel;
unsigned int gBsDumpLevel;
#endif


St_BsStat gBsStat;
R64_MS_ID_S gMsId;


int BS_CreateTimer(BS_TMR_ID *pTmrId, BS_TMR_FUNC pFunc,St_BsUeCtxt *pUeCtxt)
{
	if(pTmrId == NULL ||pUeCtxt == NULL) {
		TRACE3("input error\n");
		return FAILURE;
	}
	
	if(FAILURE== xCreateTimer(pTmrId, (BS_TMR_FUNC)pFunc, (unsigned long)pUeCtxt)){
		gBsStat.tmrCreateErr++;
		return FAILURE;
	} 
	else 
	{
		gBsStat.tmrCreateOk++;
	}
	
	return SUCCESS;
}


void BS_DestroyTimer(BS_TMR_ID *pTmrId) 
{
	if(pTmrId == NULL) {
		TRACE3("input error\n");
		return ;
	}

	xDestroyTimer (pTmrId);
	gBsStat.tmrDestroy++;
		
	return ;
}

void BS_StartTimer(BS_TMR_ID tmrId,unsigned long expires)
{
	xStartTimer(tmrId,expires);

	gBsStat.tmrStart++;
	
	return ;
}

void BS_RestartTimer(BS_TMR_ID tmrId,unsigned long expires)
{
	xRestartTimer(tmrId,expires);

	gBsStat.tmrRestart++;

	return ;
}

int BS_StopTimer(BS_TMR_ID tmrId)
{
	if(FAILURE== xStopTimer(tmrId)) {
		gBsStat.tmrStopErr++;
		return FAILURE;
	} 
	else 
	{
		gBsStat.tmrStopOk++;
	}
	
	return SUCCESS;
}

void BS_PostTimer(unsigned long arg)
{
	St_BsTmrMsg tmrMsg;
	extern MSG_Q_ID g_msgq_bscp;
		
	bzero((char *)&tmrMsg, sizeof(St_BsTmrMsg));
	tmrMsg.st_env.protocolSap = BS_TIMER_SAP;
	tmrMsg.st_env.MessageLength= sizeof(St_BsTmrMsg);
	tmrMsg.dw_data = arg;
	
	msgQSend(g_msgq_bscp, (char *)&tmrMsg, sizeof(St_BsTmrMsg), WAIT_FOREVER, MSG_PRI_NORMAL);

	return ;
}

int BS_FsmGetEventTimer(St_BsTmrMsg * pTmrMsg)
{
	unsigned int event = BS_FSM_NUM_EVENTS + 1;

	if(!pTmrMsg) 
	{
		TRACE3("input null for tmr.\n");
		return event;
	}

	if(pTmrMsg->st_env.protocolSap != BS_TIMER_SAP) 
	{
		return event;
	}
	
	event = BSFE_TIME_OUT;

	return event;
	
}


int BS_FsmGetEvent(R64_MSG_S * pR64Msg, St_BsUeCtxt * pUeCtxt)
{
	BYTE funcType = pR64Msg->msgHead.functionType;
	BYTE msgType = pR64Msg->msgHead.messageType;
	unsigned int event = BS_FSM_NUM_EVENTS + 1;

	if(!pR64Msg) 
	{
		TRACE3("input null pointer for r64 msg.\n");
		return event;
	}

	if(funcType == R64_FUNCTION_TYPE_CONTEXT)
	{
		switch(msgType)
		{
			case R64_ID_CONTEXT_REPORT:
			{
				if(pR64Msg->u.msContextRep.contextPurposeIndicator.indicator == R64_CONTEXT_PURPOSE_EAP_PROCEDURE)
					event = BSFE_EAP_CTXT_REP;
				else if(pR64Msg->u.msContextRep.contextPurposeIndicator.indicator == R64_CONTEXT_PURPOSE_MS_ERROR)
					event = BSFE_ERR_REP;
				break;
			}
				
			default:break; 
		} 
	}
	else if(funcType == R64_FUNCTION_TYPE_MS_STATE_CHANGE)
	{
		switch(msgType)
		{
			case R64_ID_NW_ENTRY_MS_STATE_CHANGE_RESPONSE:
			{
				if(pR64Msg->u.nwEntryMsStateChangeRsp.purpose.indicator == R64_CONTEXT_PURPOSE_CAPACITY_EXCHANGE)
					event = BSFE_SBC_ENTRY_STATE_CHANGE_RESP;
				else if(pR64Msg->u.nwEntryMsStateChangeRsp.purpose.indicator == R64_CONTEXT_PURPOSE_MS_REGISTRATION)
					event = BSFE_REG_ENTRY_STATE_CHANGE_RESP; 
				break;
			}
				
			default:break; 
		} 
	}
	else if(funcType == R64_FUNCTION_TYPE_AUTH_RELAY)
	{
		switch(msgType)
		{
			case R64_ID_AUTH_RELAY_EAP_TRANSFER:
				if(pUeCtxt->state == BSFS_EAP_INITIATE)
					event = BSFE_EAP_IDENTITY_REQ;
				else if(pUeCtxt->state == BSFS_EAP_START || pUeCtxt->state == BSFS_EAP_PENDING)
					event = BSFE_EAP_MESSAGE;
				break;
			default:break; 
		} 
	}
	else if(funcType == R64_FUNCTION_TYPE_DATA_PATH)
	{
		switch(msgType)
		{
			case R64_ID_DATA_PATH_REGISTRATION_REQUEST:
				event = BSFE_DP_REG_REQ;
				break;
			case R64_ID_DATA_PATH_REGISTRATION_ACK:
				event = BSFE_DP_REG_ACK;
				break;
			case R64_ID_DATA_PATH_DE_REGISTRATION_RESPONSE:
				event = BSFE_DP_DEREG_RESP;
				break;
			default:break; 
		} 
	}

	return event;
}

void BS_ProtoHandler(R64_MSG_S * pR64Msg)
{
	int event;
	St_BsUeCtxt *pUeCtxt = NULL;
	
	if(!pR64Msg) 
	{
		TRACE3("input r64 msg null\n");
		return ;
	}

	pUeCtxt = BS_Ue_Lookup_By_MSID(pR64Msg->msgHead.msId);
	if(NULL == pUeCtxt)
	{
		TRACE3("look for msId 0x%02x%02x%02x-%02x%02x%02x failed\n",
			pR64Msg->msgHead.msId.id[0],pR64Msg->msgHead.msId.id[1],
			pR64Msg->msgHead.msId.id[2],pR64Msg->msgHead.msId.id[3],
			pR64Msg->msgHead.msId.id[4],pR64Msg->msgHead.msId.id[5]);
		return;
	}
	
	event = BS_FsmGetEvent(pR64Msg, pUeCtxt);

	/* enter fsm*/
	if(pUeCtxt->state >= BS_FSM_NUM_STATES || event >= BS_FSM_NUM_EVENTS) 
	{
		TRACE3("fsm state %d(%d) or event %d(%d) exceeded\n",pUeCtxt->state,event,BS_FSM_NUM_STATES,BS_FSM_NUM_EVENTS);
		return;
	}

	if(FAILURE == bs_fsm_entry(pUeCtxt, pR64Msg, pUeCtxt->state,event)) {
		TRACE3("fsm process failed,msId 0x%02x%02x%02x-%02x%02x%02x state %d event %d\n",
				pR64Msg->msgHead.msId.id[0],pR64Msg->msgHead.msId.id[1],
				pR64Msg->msgHead.msId.id[2],pR64Msg->msgHead.msId.id[3],
				pR64Msg->msgHead.msId.id[4],pR64Msg->msgHead.msId.id[5],
				pUeCtxt->state,event);
		return ;
	}
	
	return;
}


void MSID_Increment(R64_MS_ID_S * pMsId)
{
	int i;
	
	for(i = R64_MSID_LENGTH;i > 0;i--)
		{
			if(pMsId->id[i-1] < 0xFF) 
			{
				pMsId->id[i-1]++;
				break;
			}
		}
	
	return;
}


int BS_CallInit (unsigned int msNum)
{
	int i;
	St_BsUeCtxt * pUeCtxt = NULL;	

	for(i = 0;i < msNum;i++)
	{
		/* alloc new ms context */
		if(NULL == (pUeCtxt = BS_UeAlloc(gMsId))) 
		{
			TRACE3("alloc ms context failed, msId: 0x%02x%02x%02x-%02x%02x%02x\n",
				gMsId.id[0],gMsId.id[1],gMsId.id[2],gMsId.id[3],gMsId.id[4],gMsId.id[5]);
			return FAILURE;
		}
		MSID_Increment(&gMsId);
		TRACE2("new ue entered, msId: 0x%02x%02x%02x-%02x%02x%02x, ueId: %d\n",
			pUeCtxt->msId.id[0],pUeCtxt->msId.id[1],pUeCtxt->msId.id[2],
			pUeCtxt->msId.id[3],pUeCtxt->msId.id[4],pUeCtxt->msId.id[5],pUeCtxt->ueId);
		if(FAILURE == bs_fsm_entry(pUeCtxt, NULL, BSFS_NULL,BSFE_INIT_CALL))
		{
			TRACE3("ms init call flow failed, msId: 0x%02x%02x%02x-%02x%02x%02x, ueId: %d\\n",
			pUeCtxt->msId.id[0],pUeCtxt->msId.id[1],pUeCtxt->msId.id[2],
			pUeCtxt->msId.id[3],pUeCtxt->msId.id[4],pUeCtxt->msId.id[5],pUeCtxt->ueId);
			return FAILURE;
		}
	}
	return SUCCESS;
}


int BS_UeDreg (unsigned short ueId)
{
	St_BsUeCtxt * pUeCtxt = NULL;
	if(NULL == (pUeCtxt = BS_Ue_Lookup_By_UEID(ueId)))
	{
		TRACE3("ms dose not exist, ueId %d\n",ueId);
		return FAILURE;
	}
	if(FAILURE == bs_fsm_entry(pUeCtxt, NULL, BSFS_DATA_TRANSFER, BSFE_INIT_DEREG))
	{
		TRACE3("bs init deregistration failed, msId0x%02x%02x%02x-%02x%02x%02x, ueId:%d\n",
			pUeCtxt->msId.id[0],pUeCtxt->msId.id[1],pUeCtxt->msId.id[2],
			pUeCtxt->msId.id[3],pUeCtxt->msId.id[4],pUeCtxt->msId.id[5],ueId);
		return FAILURE;
	}
	return SUCCESS;
}


void bssim_help()
{
	int i = 1;
	printf("Compile by gcc: %d.%d, date: %s  %s\n",__GNUC__, __GNUC_MINOR__, __DATE__, __TIME__);

	printf("%d: dhcp_client_dump_all_binding()\n",i++);


	return ;
}