bs_msghandle.c

wimax bs模拟器

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


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

			Subsystem		: WIMAX
			Group			: GW/AnchorDP/...
			File				: bs_init_call_fsm.c
			Version			: 
			Build			: 
			Author			: RCT
			Maintained by		: RCT
			FCreate Date		: 2007-01-26
			Last Modify		: 
			Description		: BS SIM message handler
																			  
\******************************************************************************/
/*
-----------------------------------------------------------
Software Develop CodeName :

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

07-01.26	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 "bs_msghandle.h"
#include "bs_common.h"
#include "gw_common.h"

#define UNAVAILABLE 0xFFFF
#define PRNT_MSID(pR64Msg) TRACE("  msId 0x%02x%02x%02x-%02x%02x%02x\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])

R64_BS_ID_S gBsId = {{0xFE,0xFE,0xFE,0xFE,0xFE,0xFE}};
DWORD gSourceIp;
DWORD gDestinationIp;

extern int BS_CreateTimer (BS_TMR_ID * pTmrId, BS_TMR_FUNC Func, St_BsUeCtxt * pUeCtxt);
extern void BS_RestartTimer(BS_TMR_ID tmrId, unsigned long expires);
extern void BS_StartTimer(BS_TMR_ID tmrId, unsigned long expires);
extern int BS_StopTimer(BS_TMR_ID tmrId);
extern void BS_DestroyTimer(BS_TMR_ID * pTmrId);
extern void BS_PostTimer(unsigned long arg);

extern int dhcp_client_send_discover();


/************************************************************************************
The Begining of a test flow--SBC
after this procedure,UE enter BSFS_SBC_NEGOTIATING state and wait for SBC_CTXT_REP
**************************************************************************************/
int InitNbcProcedure(St_BsUeCtxt *pUeCtxt)
{
	R64_MSG_S nwEntryStateChange;
	pUeCtxt->state = BSFS_SBC_NEGOTIATING;
	genNWEntryStateChange(pUeCtxt,&(nwEntryStateChange));
	bs_r6_msg_send(&(nwEntryStateChange));
	BS_CreateTimer(&(pUeCtxt->timer), (BS_TMR_FUNC )BS_PostTimer, pUeCtxt);
	BS_StartTimer(pUeCtxt->timer,EXPIRES);
	pUeCtxt->sendCount = 1;
	return SUCCESS;
	
}



/*************************************************************************************
retransmate SBC_CTXT_RSQ
*************************************************************************************/
void reSendNWEntryStateChange(St_BsUeCtxt *pUeCtxt)
{
	R64_MSG_S nwEntryStateChange;
	if(pUeCtxt->sendCount++>=TXTIME) 
	{
		TRACE3("NO RSP answer for SBC_ENTRY_STATE_CHANGE_REQ!\n");
		BS_StopTimer(pUeCtxt->timer) ;
		handle_bs_err (pUeCtxt);
		return ;
	}
	else
	{
		genNWEntryStateChange(pUeCtxt,&(nwEntryStateChange));
		bs_r6_msg_send(&(nwEntryStateChange));
		BS_RestartTimer(pUeCtxt->timer,EXPIRES);
		return ;
	}
}



/*************************************************************************************
Generate Context Requext MSG
*************************************************************************************/
 void genNWEntryStateChange(St_BsUeCtxt *pUeCtxt,R64_MSG_S* pR64Msg)
{
	bzero((char *)pR64Msg,sizeof(R64_MSG_S));
	pR64Msg->msgHead.destinationIp=gDestinationIp;
	pR64Msg->msgHead.destinationUdpPort=GW_R6_UDP_PORT;
	//pR64Msg->msgHead.flags=
	//pR64Msg->msgHead.fragmentId=
	pR64Msg->msgHead.functionType=R64_FUNCTION_TYPE_MS_STATE_CHANGE ;
	pR64Msg->msgHead.ifType=IF_TYPE_R6;
	pR64Msg->msgHead.messageType=R64_ID_NW_ENTRY_MS_STATE_CHANGE_REQUEST;
	pR64Msg->msgHead.msId=pUeCtxt->msId;
	pR64Msg->msgHead.sourceIp=gSourceIp;
	pR64Msg->msgHead.sourceUdpPort=BS_R6_UDP_PORT;
	pR64Msg->msgHead.transId=pUeCtxt->xid;
	//pR64Msg->msgHead.version=

	pR64Msg->u.nwEntryMsStateChangeReq.present.purposePresent=PRESENT;
       pR64Msg->u.nwEntryMsStateChangeReq.present.msInfoPresent=PRESENT;
       pR64Msg->u.nwEntryMsStateChangeReq.present.bsInfoPresent=PRESENT;
       pR64Msg->u.nwEntryMsStateChangeReq.present.authPolicyPresent=PRESENT;

	pR64Msg->u.nwEntryMsStateChangeReq.purpose.indicator=R64_CONTEXT_PURPOSE_CAPACITY_EXCHANGE;

	pR64Msg->u.nwEntryMsStateChangeReq.authPolicy.singleEap=0;
	pR64Msg->u.nwEntryMsStateChangeReq.authPolicy.doubleEap=0;
	pR64Msg->u.nwEntryMsStateChangeReq.authPolicy.none=1;

	pR64Msg->u.nwEntryMsStateChangeReq.bsInfo.present.bsIdPresent=PRESENT;
	pR64Msg->u.nwEntryMsStateChangeReq.msInfo.present.msIdPresent=PRESENT;
	pR64Msg->u.nwEntryMsStateChangeReq.bsInfo.bsId=gBsId;
 	pR64Msg->u.nwEntryMsStateChangeReq.msInfo.msId=pUeCtxt->msId;
	return;
	
}

/*---------------------------------------------------------------------------------------*/


 /*************************************************************************************
 when Ue at BSFS_SBC_NEGOTIATING state,receive a SBC_ENTRY_STATE_CHANGE_REP msg,call this procedure 
 *************************************************************************************/
int handleGwNwEntryStateChangeRsp(St_BsUeCtxt *pUeCtxt,R64_MSG_S * pR64Msg)
 {
	R64_NW_ENTRY_MS_STATE_CHANGE_RESPONSE_S * pEntryStateChangeResp;
	R64_MSG_S nwEntryStateChangeAck;
	
	BS_StopTimer(pUeCtxt->timer) ;
	pUeCtxt->transId=pR64Msg->msgHead.transId;

	pEntryStateChangeResp = &pR64Msg->u.nwEntryMsStateChangeRsp;
	if(pEntryStateChangeResp->authPolicy.none == 1)
	{
		pUeCtxt->state = BSFS_EAP_COMPLETE;
		genNwEntryStateChangeAck(pUeCtxt,&(nwEntryStateChangeAck));
		bs_r6_msg_send(&(nwEntryStateChangeAck));

#ifdef BSSIM_BINDED_2_GW
		taskDelay(sysClkRateGet()/50);
#endif
		taskDelay(sysClkRateGet()/50);

		pUeCtxt->xid++;		
		initMsReg(pUeCtxt);
	}
	else
	{
		pUeCtxt->state = BSFS_EAP_INITIATE;
		genNwEntryStateChangeAck(pUeCtxt,&(nwEntryStateChangeAck));
		bs_r6_msg_send(&(nwEntryStateChangeAck));
		BS_CreateTimer(&(pUeCtxt->timer), (BS_TMR_FUNC )BS_PostTimer, pUeCtxt);
		BS_StartTimer(pUeCtxt->timer,EXPIRES);
		pUeCtxt->sendCount = 1;
		pUeCtxt->xid++;
	}
	
	return SUCCESS;
	
 }




/*************************************************************************************
retransmate SBC_ENTRY_STATE_CHANGE_ACK
*************************************************************************************/
void reSendNwEntryStateChangeAck(St_BsUeCtxt* pUeCtxt)
 {
 	R64_MSG_S nwEntryStateChangeAck;
 	if(pUeCtxt->sendCount++>=TXTIME) 
	{
		TRACE3("Didn't receive EAP_IDENTITY_REQ after send out SBC_ENTRY_STATE_CHANGE_ACK for a long time\n");
		BS_StopTimer(pUeCtxt->timer) ;
		handle_bs_err (pUeCtxt);
		return ;
	}
	else
	{
		genNwEntryStateChangeAck(pUeCtxt,&(nwEntryStateChangeAck));
		bs_r6_msg_send(&(nwEntryStateChangeAck));
		BS_RestartTimer(pUeCtxt->timer,EXPIRES);
		return ;
	}
 }

 
/*************************************************************************************
Generate the MSG  SBC_CTXT_REP_ACK
*************************************************************************************/
void genNwEntryStateChangeAck(St_BsUeCtxt *ueCtxt,R64_MSG_S* pR64Msg)
{
	bzero((char *)pR64Msg,sizeof(R64_MSG_S));
	
	pR64Msg->msgHead.destinationIp=gDestinationIp;
	pR64Msg->msgHead.destinationUdpPort=GW_R6_UDP_PORT;
	//pR64Msg->msgHead.flags=
	//pR64Msg->msgHead.fragmentId=
	pR64Msg->msgHead.functionType=R64_FUNCTION_TYPE_MS_STATE_CHANGE ;
	pR64Msg->msgHead.ifType=IF_TYPE_R6;
	pR64Msg->msgHead.messageType=R64_ID_NW_ENTRY_MS_STATE_CHANGE_ACK;
	pR64Msg->msgHead.msId=ueCtxt->msId;
	pR64Msg->msgHead.sourceIp=gSourceIp;
	pR64Msg->msgHead.sourceUdpPort=BS_R6_UDP_PORT;
	pR64Msg->msgHead.transId=ueCtxt->xid;
	//pR64Msg->msgHead.version=

	pR64Msg->u.nwEntryMsStateChangeAck.present.purposePresent=PRESENT;
       pR64Msg->u.nwEntryMsStateChangeAck.present.msInfoPresent=PRESENT;
       pR64Msg->u.nwEntryMsStateChangeAck.present.bsInfoPresent=PRESENT;
	pR64Msg->u.nwEntryMsStateChangeAck.present.causeCodePresent = PRESENT;

	pR64Msg->u.nwEntryMsStateChangeAck.purpose.indicator =R64_CONTEXT_PURPOSE_CAPACITY_EXCHANGE;

	pR64Msg->u.nwEntryMsStateChangeAck.bsInfo.present.bsIdPresent=PRESENT;
	pR64Msg->u.nwEntryMsStateChangeAck.msInfo.present.msIdPresent=PRESENT;
	pR64Msg->u.nwEntryMsStateChangeAck.bsInfo.bsId=gBsId;
 	pR64Msg->u.nwEntryMsStateChangeAck.msInfo.msId=ueCtxt->msId;

	pR64Msg->u.nwEntryMsStateChangeAck.causeCode.code = R64_CAUSE_SUCCESS;

	return ;

}

/*---------------------------------------------------------------------------------------*/


/*****************************************************************************
whe UE on BSFS_EAP_INITIATE state receive EAP_IDENTITY_REQ MSG call this procedure
*****************************************************************************/

int handleGwEapReq(St_BsUeCtxt *pUeCtxt,R64_MSG_S * pR64Msg)
{
	R64_MSG_S EapRsp;
	BS_StopTimer(pUeCtxt->timer) ;
	pUeCtxt->transId=pR64Msg->msgHead.transId;
 	pUeCtxt->state = BSFS_EAP_START;
	genEapRsp(pUeCtxt,&(EapRsp) );
	bs_r6_msg_send( &(EapRsp));
	BS_CreateTimer(&(pUeCtxt->timer), (BS_TMR_FUNC )BS_PostTimer, pUeCtxt);
	BS_StartTimer(pUeCtxt->timer,EXPIRES);
	pUeCtxt->sendCount = 0;
	return SUCCESS;
}


/*************************************************************************************
retransmate EAP_IDENTITY_RESP
*************************************************************************************/
void reSendEapRsp(St_BsUeCtxt *pUeCtxt)
 {
 	R64_MSG_S EapRsp;
 	if(pUeCtxt->sendCount++>=TXTIME) 
	{
		TRACE3("Didn't receive EAP_MESSAGE after send out EAP_IDENTITY_RESP for a long time\n");
		BS_StopTimer(pUeCtxt->timer) ;
		handle_bs_err (pUeCtxt);
		return ;
	}
	else
	{
		genEapRsp(pUeCtxt,&(EapRsp) );
		bs_r6_msg_send( &(EapRsp));
		BS_RestartTimer(pUeCtxt->timer,EXPIRES);
		return ;
	}
 }
/*************************************************************************************
Generate EAP_IDENTITY_RESP
*************************************************************************************/
void genEapRsp(St_BsUeCtxt *pUeCtxt,R64_MSG_S* pR64Msg)
{
	
	bzero((char *)pR64Msg,sizeof(R64_MSG_S));
	
	pR64Msg->msgHead.destinationIp=gDestinationIp;
	pR64Msg->msgHead.destinationUdpPort=GW_R6_UDP_PORT;
	//pR64Msg->msgHead.flags=
	//pR64Msg->msgHead.fragmentId=
	pR64Msg->msgHead.functionType=R64_FUNCTION_TYPE_AUTH_RELAY  ;
	pR64Msg->msgHead.ifType=IF_TYPE_R6;
	pR64Msg->msgHead.messageType=R64_ID_AUTH_RELAY_EAP_START ;
	pR64Msg->msgHead.msId=pUeCtxt->msId;
	pR64Msg->msgHead.sourceIp=gSourceIp;
	pR64Msg->msgHead.sourceUdpPort=BS_R6_UDP_PORT;
	pR64Msg->msgHead.transId=pUeCtxt->transId;
	//pR64Msg->msgHead.version=

	pR64Msg->u.authRelayEapTransfer.present.msInfoPresent=PRESENT;
	pR64Msg->u.authRelayEapTransfer.present.eapMessagePresent=PRESENT;
	pR64Msg->u.authRelayEapTransfer.msInfo.present.msIdPresent=PRESENT;
	pR64Msg->u.authRelayEapTransfer.msInfo.msId=pUeCtxt->msId;
	return ;
	
	
}