VOS_VOID NAS_EMM_SECU_ClearResource(VOS_VOID)
{
NAS_EMM_SECU_LOG_NORM("NAS_EMM_SECU_ClearResource: enter.");
NAS_LMM_MEM_SET( NAS_EMM_GetSecuUsimAuthParamAddr(),
0,
sizeof(NAS_LMM_USIM_AUTH_PARAM_STRU));
NAS_EMM_GetSmcType() = NAS_EMM_SMC_UPDATE_BUTT;
NAS_LMM_MEM_SET( NAS_EMM_GetSecuSrcSpace(),
0,
LRRC_LNAS_MAX_DATA_LENGTH - NAS_EMM_CATCH_OP_UINT);
NAS_LMM_MEM_SET( NAS_EMM_GetSecuDstSpace(),
0,
LRRC_LNAS_MAX_DATA_LENGTH - NAS_EMM_CATCH_OP_UINT);
NAS_LMM_MEM_SET( NAS_EMM_GetSecuBufSpace(),
0,
LRRC_LNAS_MAX_DATA_LENGTH);
NAS_LMM_MEM_SET( NAS_EMM_GetAuthReqParamAddr(),
0,
sizeof(NAS_LMM_AUTH_REQ_PARAM_STRU));
NAS_EMM_AuthReqKsi() = NAS_LMM_NKSI_NO_KEY_IS_AVAILABLE;
NAS_EMM_GetAuthFailTimes() = 0;
return;
}
/*lint -e961*/
VOS_VOID NAS_EMM_SER_Init(VOS_VOID)
{
NAS_EMM_SER_LOG_NORM("NAS_EMM_SER_Init START INIT...");
NAS_LMM_MEM_SET(&g_stEmmSERCtrlTbl, 0, sizeof(g_stEmmSERCtrlTbl));
NAS_LMM_MEM_SET(&g_stEmmEsmMsgBuf, 0, sizeof(g_stEmmEsmMsgBuf));
return;
}
VOS_VOID NAS_EMM_SecuClearRandRes( VOS_VOID )
{
NAS_EMM_SECU_LOG_INFO("NAS_EMM_SecuClearRandRes entered!");
/* 删除RAND and RES */
NAS_EMM_GetSecuAuthOpRand() = NAS_EMM_BIT_NO_SLCT;
NAS_LMM_MEM_SET( NAS_EMM_GetSecuAuthRandAddr(),
0,
NAS_EMM_SECU_AUTH_RAND_LEN);
NAS_LMM_MEM_SET( NAS_EMM_GetSecuAuthResAddr(),
0,
sizeof(NAS_EMM_SECU_AUTH_RES_STRU));
return;
}
/*lint -e961*/
VOS_VOID NAS_LMM_SndLmmSmsEstCnf( VOS_VOID )
{
LMM_SMS_EST_CNF_STRU *pLmmSmsEstCnfMsg;
/*申请消息内存*/
pLmmSmsEstCnfMsg = (VOS_VOID *)NAS_LMM_ALLOC_MSG(sizeof(LMM_SMS_EST_CNF_STRU));
/*判断申请结果，若失败打印错误并退出*/
if (NAS_EMM_NULL_PTR == pLmmSmsEstCnfMsg)
{
/*打印错误*/
NAS_EMM_PUBU_LOG_ERR("NAS_LMM_SndLmmSmsEstCnf: MSG ALLOC ERR!");
return;
}
NAS_LMM_MEM_SET(pLmmSmsEstCnfMsg,0,sizeof(LMM_SMS_EST_CNF_STRU));
/* 打包消息头 */
NAS_LMM_COMP_SMS_MSG_HEADER( pLmmSmsEstCnfMsg,
sizeof(LMM_SMS_EST_CNF_STRU)-NAS_EMM_LEN_VOS_MSG_HEADER);
/*填充消息ID*/
pLmmSmsEstCnfMsg->ulMsgId = ID_LMM_SMS_EST_CNF;
/*填充消息内容*/
pLmmSmsEstCnfMsg->ulOpId = 0;
NAS_LMM_SEND_MSG(pLmmSmsEstCnfMsg);
}
VOS_VOID NAS_EMM_AttSetEplms(VOS_VOID *pstRcvMsg)
{
NAS_EMM_CN_ATTACH_ACP_STRU *pstAttAcp;
if (NAS_EMM_NULL_PTR == pstRcvMsg)
{
/*打印错误*/
NAS_EMM_ATTACH_LOG_ERR("NAS_EMM_AppSendAttSucc: Input para is invalid!");
return;
}
pstAttAcp = (NAS_EMM_CN_ATTACH_ACP_STRU *)pstRcvMsg;
if(pstAttAcp->ucBitOpPlmnList == NAS_EMM_AD_BIT_SLCT)
{
NAS_LMM_GetEmmInfoNetInfoOpEplmnListAddr() = NAS_EMM_AD_BIT_SLCT;
NAS_LMM_MEM_CPY( NAS_LMM_GetEmmInfoNetInfoEplmnListAddr(),
&pstAttAcp->stPlmnList,
sizeof(MMC_LMM_EPLMN_STRU));
}
else
{
NAS_LMM_GetEmmInfoNetInfoOpEplmnListAddr() = NAS_EMM_AD_BIT_NO_SLCT;
NAS_LMM_MEM_SET( NAS_LMM_GetEmmInfoNetInfoEplmnListAddr(),
0,
sizeof(MMC_LMM_EPLMN_STRU));
}
return;
}
/*****************************************************************************
Function Name : NAS_LMM_SndLmmSmsErrInd
Description : 发送消息通知SMS模块，没有链路透传SMS消息
Input : VOS_VOID
Output : None
Return : VOS_VOID
History :
1.sunbing 49683 2011-11-3 Draft Enact
*****************************************************************************/
VOS_VOID NAS_LMM_SndLmmSmsErrInd(LMM_SMS_ERR_CAUSE_ENUM_UINT32 enErrCause)
{
LMM_SMS_ERR_IND_STRU *pLmmSmsErrIndMsg;
/*申请消息内存*/
pLmmSmsErrIndMsg = (VOS_VOID *)NAS_LMM_ALLOC_MSG(sizeof(LMM_SMS_ERR_IND_STRU));
/*判断申请结果，若失败打印错误并退出*/
if (NAS_EMM_NULL_PTR == pLmmSmsErrIndMsg)
{
/*打印错误*/
NAS_EMM_PUBU_LOG_ERR("NAS_LMM_SndLmmSmsErrInd: MSG ALLOC ERR!");
return;
}
NAS_LMM_MEM_SET(pLmmSmsErrIndMsg,0,sizeof(LMM_SMS_ERR_IND_STRU));
/* 打包消息头 */
NAS_LMM_COMP_SMS_MSG_HEADER( pLmmSmsErrIndMsg,
sizeof(LMM_SMS_ERR_IND_STRU)-NAS_EMM_LEN_VOS_MSG_HEADER);
/*填充消息ID*/
pLmmSmsErrIndMsg->ulMsgId = ID_LMM_SMS_ERR_IND;
/*填充消息内容*/
pLmmSmsErrIndMsg->ulOpId = 0;
pLmmSmsErrIndMsg->enErrCause = enErrCause;
NAS_LMM_SEND_MSG(pLmmSmsErrIndMsg);
}
VOS_VOID NAS_EMM_AttSetMsId(VOS_VOID *pstRcvMsg)
{
NAS_EMM_CN_ATTACH_ACP_STRU *pstAttAcp;
if (NAS_EMM_NULL_PTR == pstRcvMsg)
{
/*打印错误*/
NAS_EMM_ATTACH_LOG_ERR("NAS_EMM_AppSendAttSucc: Input para is invalid!");
return;
}
pstAttAcp = (NAS_EMM_CN_ATTACH_ACP_STRU *)pstRcvMsg;
if(pstAttAcp->ucBitOpMsId == NAS_EMM_AD_BIT_SLCT)
{
NAS_EMM_GLO_AD_OP_GetMsId() = NAS_EMM_AD_BIT_SLCT;
NAS_LMM_MEM_CPY( NAS_EMM_GLO_AD_GetMsIdAddr(),
&pstAttAcp->stMsId,
sizeof(NAS_EMM_MSID_STRU));
}
else
{
NAS_EMM_GLO_AD_OP_GetMsId() = NAS_EMM_AD_BIT_NO_SLCT;
NAS_LMM_MEM_SET( NAS_EMM_GLO_AD_GetMsIdAddr(),
0,
sizeof(NAS_EMM_MSID_STRU));
}
return;
}
VOS_VOID NAS_EMMC_Init(VOS_VOID )
{
/*打印进入该函数*/
NAS_LMM_EMMC_LOG_NORM("NAS_EMMC START INIT...");
/*初始化EMMC全局变量*/
/*NAS_LMM_MEM_SET(NAS_EMMC_GetEmmcInfoAddr(), (VOS_CHAR)0xff, sizeof(NAS_EMMC_GLOBAL_STRU));*/
NAS_LMM_MEM_SET(NAS_EMMC_GetEmmcInfoAddr(), 0, sizeof(NAS_EMMC_GLOBAL_STRU));
return;
}
/*lint -e961*/
VOS_VOID NAS_EMM_DetachInit()
{
NAS_EMM_DETACH_LOG_NORM("NAS_EMM_DetachInit START INIT...");
/* 初始化 detach全局变量 */
NAS_LMM_MEM_SET(&g_stEmmDetCtrl, 0, sizeof(g_stEmmDetCtrl));
NAS_EMM_GLO_AD_GetDetTypeMo() = MMC_LMM_MO_DET_PS_ONLY;
/*初始化 UE 发起 detach 的默认类型*/
NAS_EMM_GLO_AD_GetDetMode() = NAS_EMM_DETACH_MODE_NOT_SWITCH_OFF;
return;
}
VOS_VOID NAS_LMM_ClearTaList(NAS_MM_FORB_TA_LIST_STRU *pstTaList)
{
NAS_LMM_PUBM_LOG_INFO("NAS_LMM_ClearTaList: is entered !!");
/* 传入指针非空检查 */
if (VOS_NULL_PTR == pstTaList)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_ClearTaList: ERR--input NULL !!");
return;
}
NAS_LMM_MEM_SET(pstTaList,0,sizeof(NAS_MM_FORB_TA_LIST_STRU));
return;
}
VOS_VOID NAS_EMM_MmSendCsfbSerEndInd
(
MM_LMM_CSFB_SERVICE_RSLT_ENUM_UINT32 enCsfbSrvRslt,
NAS_EMM_CN_CAUSE_ENUM_UINT8 ucEMMCnCause
)
{
LMM_MM_CSFB_SERVICE_END_IND_STRU *pstMmCsfbSerEndInd = VOS_NULL_PTR;
/* 如果已经收到ABORT消息，则不用通知MM终止CSFB流程 */
if (NAS_EMM_CSFB_ABORT_FLAG_VALID == NAS_EMM_SER_GetEmmSerCsfbAbortFlag())
{
NAS_EMM_SER_LOG_NORM("NAS_EMM_MmSendCsfbSerEndInd:CSFB is already aborted!");
return ;
}
/* 申请DOPRA消息 */
pstMmCsfbSerEndInd = (VOS_VOID *) NAS_LMM_GetLmmMmcMsgBuf(sizeof(LMM_MM_CSFB_SERVICE_END_IND_STRU));
if (NAS_LMM_NULL_PTR == pstMmCsfbSerEndInd)
{
/* 打印异常，ERROR_LEVEL */
NAS_EMM_SER_LOG_ERR("NAS_EMM_MmSendCsfbSerEndInd: MSG ALLOC ERROR!!!");
return ;
}
/* 清空 */
NAS_LMM_MEM_SET(pstMmCsfbSerEndInd, 0, sizeof(LMM_MM_CSFB_SERVICE_END_IND_STRU));
/* 打包VOS消息头 */
EMM_PUBU_COMP_MM_MSG_HEADER((pstMmCsfbSerEndInd),
NAS_EMM_GET_MSG_LENGTH_NO_HEADER(LMM_MM_CSFB_SERVICE_END_IND_STRU));
/* 填充消息ID */
pstMmCsfbSerEndInd->ulMsgId = ID_LMM_MM_CSFB_SERVICE_END_IND;
/* 填充消息体 */
pstMmCsfbSerEndInd->ulOpId = NAS_EMM_OPID_MM;
pstMmCsfbSerEndInd->enCsfbSrvRslt = enCsfbSrvRslt;
pstMmCsfbSerEndInd->ulCnCause = ucEMMCnCause;
/* 发送DOPRA消息 */
NAS_LMM_SendLmmMmcMsg((VOS_VOID*)pstMmCsfbSerEndInd);
return;
}
VOS_VOID NAS_LMM_ClearPlmnList(NAS_MM_PLMN_LIST_STRU *pstPlmnList)
{
NAS_LMM_PUBM_LOG_INFO("NAS_LMM_ClearPlmnList: is entered !!");
/* 传入指针非空检查 */
if (VOS_NULL_PTR == pstPlmnList)
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_ClearPlmnList: ERR--input NULL !!");
return;
}
pstPlmnList->ulPlmnNum = 0;
NAS_LMM_MEM_SET( pstPlmnList->astPlmnId,
0,
NAS_MM_MAX_PLMN_NUM * sizeof(NAS_MM_PLMN_ID_STRU));
return;
}
VOS_VOID NAS_EMM_Detach_ClearResourse(VOS_VOID)
{
/*动态内存释放*/
NAS_EMM_FreeDetDyn();
/* 停止DETACH定时器 */
NAS_LMM_StopStateTimer( TI_NAS_EMM_T3421);
/*赋初值*/
NAS_LMM_MEM_SET(NAS_EMM_GLO_AD_GetDetCtrlAddr(), 0, sizeof(NAS_EMM_DETACH_CTRL_STRU));
NAS_EMM_GLO_AD_GetDetTypeMo() = MMC_LMM_MO_DET_PS_ONLY;
/*初始化 UE 发起 detach 的默认类型*/
NAS_EMM_GLO_AD_GetDetMode() = NAS_EMM_DETACH_MODE_NOT_SWITCH_OFF;
return;
}
VOS_VOID NAS_EMM_SER_ClearResource( VOS_VOID )
{
NAS_EMM_SER_LOG_NORM("NAS_EMM_SER_ClearResource entered.");
/* 清空SER全局变量*/
NAS_LMM_MEM_SET(&g_stEmmSERCtrlTbl, 0, sizeof(g_stEmmSERCtrlTbl));
/* 释放缓存的ESM消息*/
NAS_EMM_SerClearEsmDataBuf();
/* 清空接入Bar信息*/
NAS_EMM_ClearBarResouce();
/* 停止Service流程相关的所有定时器*/
NAS_LMM_StopStateTimer(TI_NAS_EMM_STATE_SERVICE_T3417);
NAS_LMM_StopStateTimer(TI_NAS_EMM_STATE_T3440);
NAS_LMM_StopStateTimer(TI_NAS_EMM_STATE_SERVICE_T3417_EXT);
return;
}
VOS_VOID NAS_LMM_FSM_ClearState( NAS_LMM_PARALLEL_FSM_ENUM_UINT16 enParalFsmId )
{
NAS_LMM_FSM_STATE_STACK_STRU *pstFsmStack; /* 状态机栈地址 */
/* 入口检查 */
if ( NAS_LMM_PARA_FSM_ID_INVALID(enParalFsmId))
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PopState, FsmId error, FsmId", enParalFsmId);
return;
}
/* 获取EMM状态机当前状态的地址和状态机栈的地址 */
pstFsmStack = NAS_LMM_GetFsmStackAddr(enParalFsmId);
/* 栈越界 */
if ( (pstFsmStack->ucStackDepth) > NAS_LMM_MAX_STACK_DEPTH )
{
NAS_LMM_PUBM_LOG1_ERR("NAS_LMM_FSM_PopState, The stack depth overflow, ucStackDepth",
(pstFsmStack->ucStackDepth));
return;
}
/* 栈已空 */
if ( 0 == (pstFsmStack->ucStackDepth) )
{
NAS_LMM_PUBM_LOG_ERR("NAS_LMM_FSM_PopState, The stack is empty!");
return;
}
/*清除栈内存储的状态机*/
pstFsmStack->ucStackDepth = 0;
NAS_LMM_MEM_SET(pstFsmStack,0,sizeof(NAS_LMM_FSM_STATE_STACK_STRU));
return;
}
VOS_VOID NAS_EMM_SendMsgEmmStatus( VOS_UINT8 ucRes )
{
NAS_EMM_MRRC_DATA_REQ_STRU *pIntraMsg;
VOS_UINT32 ulDataReqMsgLenNoHeader;
NAS_MSG_STRU *pstNasMsg;
VOS_UINT32 ulIndex =0;
NAS_EMM_ATTACH_LOG_INFO("Enter NAS_EMM_SendMsgEmmStatus,Status MSG LEN");
/*申请消息内存*/
pIntraMsg = (VOS_VOID *) NAS_LMM_MEM_ALLOC(NAS_EMM_INTRA_MSG_MAX_SIZE);
/*判断申请结果，若失败退出*/
if (NAS_EMM_NULL_PTR == pIntraMsg)
{
return;
}
/* xiongxianghui00253310 add memset 2013-11-26 begin */
NAS_LMM_MEM_SET(pIntraMsg, 0, NAS_EMM_INTRA_MSG_MAX_SIZE);
/* xiongxianghui00253310 add memset 2013-11-26 end */
/*构造EmmStatus消息*/
NAS_EMM_CompCnEmmStatus( &(pIntraMsg->stNasMsg),&ulIndex,ucRes);
ulDataReqMsgLenNoHeader = NAS_EMM_CountMrrcDataReqLen(ulIndex);
if ( NAS_EMM_INTRA_MSG_MAX_SIZE < ulDataReqMsgLenNoHeader )
{
/* 打印错误信息 */
NAS_LMM_PUBM_LOG_ERR("NAS_EMM_SendMsgEmmStatus, Size error");
NAS_LMM_MEM_FREE(pIntraMsg);
return ;
}
/*填充消息头*/
NAS_EMM_INTRA_MSG_HEADER(pIntraMsg, ulDataReqMsgLenNoHeader);
/*填充消息ID*/
pIntraMsg->ulMsgId = ID_NAS_LMM_INTRA_MRRC_DATA_REQ;
/*填充消息内容*/
pIntraMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_SIGNALLING;
pIntraMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_SIGNALLING;
pIntraMsg->enEmmMsgType = NAS_EMM_NAS_STATUS;
pIntraMsg->enDataCnf = LRRC_LMM_DATA_CNF_NOT_NEED;
/*填充消息长度*/
pIntraMsg->stNasMsg.ulNasMsgSize = ulIndex;
/*向OM发送空口消息ATTACH COMPLETE*/
pstNasMsg = (NAS_MSG_STRU *)(&(pIntraMsg->stNasMsg));
NAS_LMM_SendOmtAirMsg(NAS_EMM_OMT_AIR_MSG_UP, NAS_EMM_STATUS, pstNasMsg);
/*向MRRC发送消息*/
NAS_EMM_SndUplinkNasMsg( pIntraMsg);
NAS_LMM_MEM_FREE(pIntraMsg);
return;
}
VOS_UINT32 NAS_EMM_PreProcMsgEmmInfo( NAS_EMM_CN_MSG_STRU_UNION * pCnMsg )
{
NAS_EMM_INFO_STRU *pstEmmInfo;
NAS_EMM_CN_EMM_INFO_STRU *pstTmpRcvMsg = NAS_EMM_NULL_PTR;
VOS_UINT8 ucCount = 0;
NAS_LMM_PUBM_LOG_NORM("NAS_EMM_PreProcMsgEmmInfo enter!");
pstTmpRcvMsg = (NAS_EMM_CN_EMM_INFO_STRU*)pCnMsg;
pstEmmInfo = NAS_LMM_GetEmmInfoNasEmmInfoListAddr();
NAS_LMM_MEM_SET(pstEmmInfo, 0, sizeof(NAS_EMM_INFO_STRU));
/* 上报网络时间和网络名称，只要能收到，就可以上报给AT，对流程没有影响，可以不做限制；
而且未注册时，网络也不会有下行消息下发*/
if(NAS_EMM_BIT_SLCT == pstTmpRcvMsg->bitOpFullName)
{
pstEmmInfo->bitOpFullName = NAS_EMM_BIT_SLCT;
NAS_LMM_MEM_CPY( pstEmmInfo->aucOperatorNameLong,
pstTmpRcvMsg->aucOperatorNameLong,
MMC_LMM_MAX_OPER_LONG_NAME_LEN);
ucCount++;
}
if(NAS_EMM_BIT_SLCT == pstTmpRcvMsg->bitOpShortName)
{
pstEmmInfo->bitOpShortName = NAS_EMM_BIT_SLCT;
NAS_LMM_MEM_CPY( pstEmmInfo->aucOperatorNameShort,
pstTmpRcvMsg->aucOperatorNameShort,
MMC_LMM_MAX_OPER_SHORT_NAME_LEN);
ucCount++;
}
if(NAS_EMM_BIT_SLCT == pstTmpRcvMsg->bitOpLocTimeZone)
{
pstEmmInfo->bitOpLocTimeZone = NAS_EMM_BIT_SLCT;
NAS_LMM_MEM_CPY( &(pstEmmInfo->stLocTimeZone),
&(pstTmpRcvMsg->stLocTimeZone),
sizeof(NAS_EMM_CN_TIMEZONE_STRU));
ucCount++;
}
if(NAS_EMM_BIT_SLCT == pstTmpRcvMsg->bitOpUniTimeLocTimeZone)
{
pstEmmInfo->bitOpUniTimeLocTimeZone = NAS_EMM_BIT_SLCT;
NAS_LMM_MEM_CPY( &(pstEmmInfo->stTimeZoneAndTime),
&(pstTmpRcvMsg->stTimeZoneAndTime),
sizeof(NAS_EMM_CN_TIMEZONE_UNITIME_STRU));
ucCount++;
}
if(NAS_EMM_BIT_SLCT == pstTmpRcvMsg->bitOpDaylightTime)
{
pstEmmInfo->bitOpDaylightTime = NAS_EMM_BIT_SLCT;
NAS_LMM_MEM_CPY( &(pstEmmInfo->enDaylightSavingTime),
&(pstTmpRcvMsg->enDaylightSavingTime),
sizeof(NAS_LMM_DAYLIGHT_SAVE_TIME_ENUM_UINT8));
ucCount++;
}
if(0 != ucCount)
{
NAS_EMM_SendMmcEmmInfoInd(pstEmmInfo);
}
return NAS_LMM_MSG_HANDLED;
}
VOS_UINT32 NAS_EMM_MsgPreProcess( NAS_EMM_EVENT_TYPE_ENUM_UINT32 ulEt,
MsgBlock *pMsg )
{
VOS_UINT32 ulRet;
LRRC_LMM_DATA_IND_STRU *pstTmpRcvMsg = NAS_EMM_NULL_PTR;
VOS_UINT8 *pRcvMsg = NAS_EMM_NULL_PTR;
VOS_UINT8 ucPD = NAS_EMM_NULL;
VOS_UINT8 ucAirMsg = NAS_EMM_NULL;
VOS_UINT8 ucKeyEvent = NAS_EMM_NULL;
NAS_LMM_FSM_STATE_STRU *pstFsmCtx = NAS_LMM_NULL_PTR;
ulRet = NAS_LMM_MSG_DISCARD;
/*结构化消息，取出消息体*/
pstTmpRcvMsg = (LRRC_LMM_DATA_IND_STRU*)pMsg;
pRcvMsg = pstTmpRcvMsg->stNasMsg.aucNasMsg;
if(ID_LRRC_LMM_DATA_IND == pstTmpRcvMsg->enMsgId)
{
/*取出PD*/
ucPD = pRcvMsg[NAS_EMM_NULL]& EMM_CN_MSG_PDMASK;
/* 如果是ESM消息直接上报ESM */
if (EMM_CN_MSG_PD_ESM == ucPD)
{
/* 转发给ESM消息 */
NAS_EMM_EsmSendDataInd((NAS_EMM_CN_MSGCON_STRU *)&(pstTmpRcvMsg->stNasMsg));
return NAS_LMM_MSG_HANDLED;
}
/* 如果是TC消息直接上报TC */
if (EMM_CN_MSG_PD_TC == ucPD)
{
/* 转发给TC消息 */
NAS_EMM_TcSendDataInd((NAS_EMM_CN_MSGCON_STRU *)&(pstTmpRcvMsg->stNasMsg));
return NAS_LMM_MSG_HANDLED;
}
/*空口消息上报*/
if(EMM_CN_MSG_PD_EMM == ucPD)
{
NAS_LMM_FindAirMsgId(pRcvMsg[NAS_LMM_CN_MSG_MT_POS], &ucAirMsg, &ucKeyEvent);
NAS_LMM_SendOmtAirMsg(NAS_EMM_OMT_AIR_MSG_DOWN,
ucAirMsg,
(NAS_MSG_STRU*)&(pstTmpRcvMsg->stNasMsg));
if (NAS_EMM_NULL != ucKeyEvent)
{
NAS_LMM_SendOmtKeyEvent(ucKeyEvent);
}
NAS_LMM_MEM_SET(&g_stCnDecodeMsgStru, 0, sizeof(NAS_EMM_CN_MSG_STRU));
ulRet = NAS_EMM_DecodeCnMsg(pMsg, &g_stCnDecodeMsgStru);
if(NAS_EMM_FAIL == ulRet )
{/* 若解码出错,打印报警 */
NAS_LMM_PUBM_LOG1_ERR("NAS_EMM_MsgProcessInFsm, ulEventType = ", ulEt);
/*发送EMM STATUS, 接收到不识别的消息 */
NAS_EMM_SendMsgEmmStatus( NAS_LMM_CAUSE_MSG_NONEXIST_NOTIMPLEMENTE );
return NAS_LMM_MSG_HANDLED;
}
/* 对EMM INFO 和 EMM STATUS 进行处理 */
ulRet = NAS_EMM_PreProcMsgDataInd();
return ulRet;
}
ulRet = NAS_LMM_MSG_DISCARD;
}
/* SM异常消息的处理*/
if(ID_EMM_ESM_REL_REQ == pstTmpRcvMsg->enMsgId)
{
/* 获取状态机地址,用于取状态 */
pstFsmCtx = NAS_LMM_GetCurFsmAddr(NAS_LMM_PARALLEL_FSM_EMM);
switch(pstFsmCtx->enMainState)
{
case EMM_MS_REG:
case EMM_MS_REG_INIT:
case EMM_MS_TAU_INIT:
case EMM_MS_SER_INIT:
NAS_EMM_SmRabmAbnarmalProc();
break;
default:
NAS_LMM_PUBM_LOG1_INFO("current MS discard abnormal MSG=========>>>>",
pstTmpRcvMsg->enMsgId);
break;
}
ulRet = NAS_LMM_MSG_HANDLED;
}
return ulRet;
}
VOS_UINT32 NAS_LMM_DecodeSimSecContext( NAS_NVIM_CTRL_TBL *pstNvCtrlTbl )
{
NAS_LMM_SECU_CONTEXT_STRU stCurSecuContext;
VOS_UINT16 usIndex = 0;
VOS_UINT8 *pucMsg;
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeSimSecContext is entered");
/*初始化stCurSecuContext*/
NAS_LMM_MEM_SET(&(stCurSecuContext), 0, sizeof(NAS_LMM_SECU_CONTEXT_STRU));
/*保存安全上下文的长度*/
NAS_EMM_GET_USIM_SECU_FILE_LEN() = pstNvCtrlTbl->usNvDataLen;
pucMsg = (VOS_UINT8*)pstNvCtrlTbl->pNvData;
NAS_LMM_MEM_SET(NAS_LMM_GET_USIM_EPS_SECU_CONTEXT_ADDR(),
0,
NAS_NVIM_SECU_CONTEXT_MAX_LEN);
/* 检测文件Tag是否合法 */
if ( NAS_LMM_NVIM_SECU_CONTEXT_TAG != pucMsg[usIndex++])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: File Tag Err ");
return NAS_LMM_NVIM_FAIL;
}
/* 检测文件Length是否合法 */
if ( NAS_LMM_NVIM_SEC_MSG_LEN != pucMsg[usIndex++] )/*待确认*/
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: File LEN Err ");
return NAS_LMM_NVIM_FAIL;
}
/********************************* KSIASME *****************************************/
if ( NAS_LMM_NVIM_SEC_KSI_TAG != pucMsg[usIndex++] )
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: KSI TAG Err ");
return NAS_LMM_NVIM_FAIL;
}
if (NAS_LMM_NVIM_SEC_KSI_LEN != pucMsg[usIndex++])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: KSI LEN Err ");
return NAS_LMM_NVIM_FAIL;
}
/* 检测KSI的合法性 */
if ( NAS_LMM_NKSI_NO_KEY_IS_AVAILABLE < pucMsg[usIndex] )
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: KSI Content Err ");
return NAS_LMM_NVIM_FAIL;
}
stCurSecuContext.ucKSIasme = pucMsg[usIndex];
usIndex += NAS_LMM_NVIM_SEC_KSI_LEN ;
/*********************************** KASME ******************************************/
if ( NAS_LMM_NVIM_SEC_KASME_TAG != pucMsg[usIndex++] )
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: KASME TAG Err ");
return NAS_LMM_NVIM_FAIL;
}
if (NAS_LMM_NVIM_SEC_KASME_LEN != pucMsg[usIndex++])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: KASME LEN Err ");
return NAS_LMM_NVIM_FAIL;
}
NAS_LMM_MEM_CPY( (stCurSecuContext.aucKasme),
&(pucMsg[usIndex]),
NAS_LMM_NVIM_SEC_KASME_LEN);
usIndex += NAS_LMM_NVIM_SEC_KASME_LEN ;
/**************************** Uplink NAS count ************************************/
if ( NAS_LMM_NVIM_SEC_UPNASCOUNT_TAG != pucMsg[usIndex++] )
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: UPNASCOUNT TAG Err ");
return NAS_LMM_NVIM_FAIL;
}
if (NAS_LMM_NVIM_SEC_NAS_COUNT_LEN != pucMsg[usIndex++])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: UPNASCOUNT LEN Err ");
return NAS_LMM_NVIM_FAIL;
}
stCurSecuContext.ulUlNasCount = stCurSecuContext.ulUlNasCount | ((VOS_UINT32)pucMsg[usIndex++] << NAS_LMM_NVIM_MOVE_24_BIT);
stCurSecuContext.ulUlNasCount = stCurSecuContext.ulUlNasCount | ((VOS_UINT32)pucMsg[usIndex++] << NAS_LMM_NVIM_MOVE_16_BIT);
stCurSecuContext.ulUlNasCount = stCurSecuContext.ulUlNasCount | ((VOS_UINT32)pucMsg[usIndex++] << NAS_LMM_NVIM_MOVE_8_BIT);
stCurSecuContext.ulUlNasCount = stCurSecuContext.ulUlNasCount | (VOS_UINT32)pucMsg[usIndex++];
/* 检测NAS count的合法性 */
if (NAS_LMM_NVIM_MAX_NASCOUNT < stCurSecuContext.ulUlNasCount)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: UPNASCOUNT Content Err ");
return NAS_LMM_NVIM_FAIL;
}
/*************************** Downlink NAS count ***********************************/
if ( NAS_LMM_NVIM_SEC_DNNASCOUNT_TAG != pucMsg[usIndex++] )
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: DNNASCOUNT Tag Err ");
return NAS_LMM_NVIM_FAIL;
}
if (NAS_LMM_NVIM_SEC_NAS_COUNT_LEN != pucMsg[usIndex++])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: DNNASCOUNT Len Err ");
return NAS_LMM_NVIM_FAIL;
}
stCurSecuContext.ulDlNasCount = stCurSecuContext.ulDlNasCount | ((VOS_UINT32)pucMsg[usIndex++] << NAS_LMM_NVIM_MOVE_24_BIT);
stCurSecuContext.ulDlNasCount = stCurSecuContext.ulDlNasCount | ((VOS_UINT32)pucMsg[usIndex++]<< NAS_LMM_NVIM_MOVE_16_BIT);
stCurSecuContext.ulDlNasCount = stCurSecuContext.ulDlNasCount | ((VOS_UINT32)pucMsg[usIndex++]<< NAS_LMM_NVIM_MOVE_8_BIT);
stCurSecuContext.ulDlNasCount = stCurSecuContext.ulDlNasCount | (VOS_UINT32)pucMsg[usIndex++];
/* 检测NAS count的合法性 */
if (NAS_LMM_NVIM_MAX_NASCOUNT < stCurSecuContext.ulDlNasCount)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: DNNASCOUNT Content Err ");
return NAS_LMM_NVIM_FAIL;
}
/******** Identifiers of selected NAS integrity and encryption algorithms *********/
if ( NAS_LMM_NVIM_SEC_ALG_TAG != pucMsg[usIndex++] )
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: Alg Tag Err ");
return NAS_LMM_NVIM_FAIL;
}
if (NAS_LMM_NVIM_SEC_ENCINT_LEN != pucMsg[usIndex++])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: Alg LEN Err ");
return NAS_LMM_NVIM_FAIL;
}
stCurSecuContext.ucSecuAlg = pucMsg[usIndex];
usIndex += NAS_LMM_NVIM_SEC_ENCINT_LEN;
/*检测合法性*/
if ( VOS_TRUE != NAS_LMM_CheckSecuAlgValid(stCurSecuContext.ucSecuAlg))
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimSecContext: Alg Content Err ");
return NAS_LMM_NVIM_FAIL;
}
/* 如果长度超过缓存区，则认为异常不保存读出的码流，如果短于缓存区，多出长度位置已初始化为0 */
if(NAS_NVIM_SECU_CONTEXT_MAX_LEN >= pstNvCtrlTbl->usNvDataLen)
{
/* 保存从USIM卡中读取出的安全上下文码流*/
NAS_LMM_MEM_CPY(NAS_LMM_GET_USIM_EPS_SECU_CONTEXT_ADDR(),
pucMsg,
pstNvCtrlTbl->usNvDataLen);
}
pstNvCtrlTbl->usDataLen = usIndex;
/*调用安全上下文更新函数,并计算NasCK ,NasIk*/
NAS_EMM_SecuSetCurCntxt(&stCurSecuContext);
return NAS_LMM_NVIM_OK;
}
/*****************************************************************************
Function Name : NAS_LMM_DecodeSimPsLoc
Discription : 解码PS_LOC_FILE
Input : pstNvCtrlTbl:公共处理结构
Output : 解码后的数据
Return :
History:
*****************************************************************************/
VOS_UINT32 NAS_LMM_DecodeSimPsLoc( NAS_NVIM_CTRL_TBL *pstNvCtrlTbl)
{
VOS_UINT8 *pucMsg;
NAS_LMM_UEID_STRU *pstUeId;
VOS_UINT32 usIndex = 0;
VOS_UINT32 ulRslt = VOS_TRUE;
VOS_UINT32 ulRslt2 = VOS_TRUE;
NAS_LMM_GUTI_STRU stGuti;
NAS_MM_NETWORK_ID_STRU stLrvTai;
VOS_UINT8 ucUpdataSta;
VOS_UINT8 *pstLastPsLoc;
NAS_MM_PLMN_ID_STRU stPlmnId;
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeSimPsLoc is entered ");
NAS_LMM_MEM_SET(&stGuti, 0, sizeof(NAS_LMM_GUTI_STRU));
NAS_LMM_MEM_SET(&stLrvTai, 0, sizeof(NAS_MM_NETWORK_ID_STRU));
pstUeId = NAS_LMM_GetEmmInfoUeidAddr();
pstLastPsLoc = NAS_LMM_GetEmmInfoLastWriteUsimPsLocAddr();
pucMsg = (VOS_UINT8*)pstNvCtrlTbl->pNvData;
/* 读出卡中的码流保存到上次写卡的全局变量中*/
NAS_LMM_MEM_CPY( pstLastPsLoc,
pucMsg,
pstNvCtrlTbl->usNvDataLen);
/*****************GUTI*********************/
/*检测文件GUTI头的有效性*/
if ( NAS_LMM_NVIM_GUTI_AND_OETOI_LEN != pucMsg[usIndex])
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimPsLoc: GUTI HEAD ERR");
usIndex += NAS_LMM_NVIM_GUTI_AND_OETOI_LEN;
usIndex ++;
pstUeId->bitOpGuti = NAS_NVIM_BIT_NO_SLCT;
}
else
{
stGuti.stGutiHead.ucLenth = NAS_LMM_NVIM_GUTI_AND_OETOI_LEN;
usIndex ++;
stGuti.stGutiHead.ucOeToi = pucMsg[usIndex] & NAS_EMM_LOW_HALF_BYTE_F;
if (NAS_LMM_NVIM_GUTI_OETOI != stGuti.stGutiHead.ucOeToi)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimPsLoc: GUTI OETOI ERR");
usIndex += NAS_LMM_NVIM_GUTI_AND_OETOI_LEN;
pstUeId->bitOpGuti = NAS_NVIM_BIT_NO_SLCT;
}
else
{
usIndex ++;
/*检测GUTI内容的合法性*/
ulRslt = NAS_EMM_CheckSimGutiValid(pucMsg, usIndex, NAS_LMM_NVIM_GUTI_LEN);
/*检测GUTI中PLMN ID的合法性 */
stPlmnId.aucPlmnId[0] = pucMsg[0 + usIndex];
stPlmnId.aucPlmnId[1] = pucMsg[1 + usIndex];
stPlmnId.aucPlmnId[2] = pucMsg[2 + usIndex];
ulRslt2 &= NAS_LMM_CheckPlmnIsInvalid(&stPlmnId);
/*检测内容的有效性*/
if ((VOS_FALSE == ulRslt) || (VOS_TRUE == ulRslt2))
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimPsLoc: GUTI Content ERR");
usIndex = usIndex + NAS_LMM_NVIM_GUTI_LEN;
pstUeId->bitOpGuti = NAS_NVIM_BIT_NO_SLCT;
}
else
{
NAS_LMM_MEM_CPY( &stGuti.stPlmnId,
&stPlmnId,
sizeof(NAS_MM_PLMN_ID_STRU));
usIndex += 3;
stGuti.stMmeGroupId.ucGroupId = pucMsg[usIndex];
usIndex ++;
stGuti.stMmeGroupId.ucGroupIdCnt = pucMsg[usIndex];
usIndex ++;
stGuti.stMmeCode.ucMmeCode = pucMsg[usIndex];
usIndex ++;
NAS_LMM_MEM_CPY( &(stGuti.stMTmsi),
&(pucMsg[usIndex]),
sizeof(NAS_LMM_MTMSI_STRU));
usIndex += sizeof(NAS_LMM_MTMSI_STRU);
pstUeId->bitOpGuti = NAS_NVIM_BIT_SLCT;
NAS_LMM_MEM_CPY( &(pstUeId->stGuti),
&stGuti,
sizeof(NAS_LMM_GUTI_STRU));
}
}
}
/****************L.R.V TAI******************/
/* 检测LRV TAI中 PLMN合法性 */
/*检查PLMN中MCC和MNC是否有效*/
NAS_LMM_MEM_CPY( &(stLrvTai.stPlmnId),
&(pucMsg[usIndex]),
NAS_LMM_NVIM_PLMN_ID_LEN);
usIndex += NAS_LMM_NVIM_PLMN_ID_LEN;
ulRslt = NAS_LMM_CheckPlmnIsInvalid(&(stLrvTai.stPlmnId));
/*ulRslt = NAS_LMM_CheckWhetherAllBytesAreFF(pucMsg, usIndex, NAS_LMM_NVIM_PLMN_ID_LEN);*/
/*plmn无效，设置全局变量中PLMN为0XFFFFFF,TAC为0xfffe*/
if (VOS_TRUE == ulRslt)
{
NAS_EMM_ClearLVRTai();
usIndex = usIndex + NAS_LMM_NVIM_TAC_LEN;
}
else
{
NAS_LMM_MEM_CPY( &(stLrvTai.stTac),
&(pucMsg[usIndex]),
NAS_LMM_NVIM_TAC_LEN);
usIndex += NAS_LMM_NVIM_TAC_LEN;
if (VOS_TRUE == NAS_LMM_TacIsUnexist(&(stLrvTai.stTac)))
{
NAS_LMM_UndefTac(&(stLrvTai.stTac));
}
NAS_EMM_SetLVRTai(&stLrvTai);
}
/***************UPDATE STATUS**************/
/*检测文件UPDATE STATUS项的有效性*/
ucUpdataSta = (pucMsg[usIndex])& NAS_LMM_NVIM_LOW_3_BIT_1;
if ( NAS_LMM_NVIM_VALID_UPDATESTA < ucUpdataSta)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimPsLoc: UPDATE STATUS Content ERR");
}
else
{
NAS_EMM_MAIN_CONTEXT_SET_AUX_UPDATE_STAE(pucMsg[usIndex]);
}
usIndex ++;
pstNvCtrlTbl->usNvDataLen = (VOS_UINT16)(usIndex);
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeSimPsLoc:GUTI IS: ");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(),(VOS_UINT8 *)&pstUeId->stGuti,20);
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeSimPsLoc:L.R.V TAI IS: ");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(),(VOS_UINT8*)NAS_LMM_GetEmmInfoLastRegPlmnAddr(),4);
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(),(VOS_UINT8*)NAS_LMM_GetEmmInfoLastRegTacAddr(),4);
NAS_LMM_NVIM_LOG1_INFO("NAS_LMM_DecodeSimPsLoc:UPDATE STATUS IS: ",NAS_EMM_UPDATE_STAE);
return NAS_LMM_NVIM_OK;
}
VOS_UINT32 NAS_LMM_DecodeNvOplmn(NAS_NVIM_CTRL_TBL *pstNvCtrlTbl)
{
#if 0
NAS_LMM_PLMN_ACT_LIST_STRU *pstOplmnAct;
VOS_UINT8 *pucMsg;
VOS_UINT32 i;
VOS_UINT32 ulValidPlmnNum = NAS_LMM_NULL;
NAS_MM_PLMN_ID_STRU stPlmnId;
NAS_LMM_MEM_SET(&stPlmnId,(VOS_CHAR)0xff,sizeof(stPlmnId));
NAS_LMM_UndefPlmn(&stPlmnId);
if(NAS_EMM_USIM_FEATURE_HARD == NAS_LMM_GetUsimFeature())
{
pucMsg = (VOS_UINT8 *)pstNvCtrlTbl->pNvData;
pstOplmnAct = (VOS_VOID *)NAS_EMMC_GetMmcGlobleAddr(NAS_LMM_GLOBLE_PARA_OPLMNLIST);
if((NAS_NVIM_NULL_PTR == pstOplmnAct)
|| (NAS_NVIM_NULL_PTR == pstNvCtrlTbl->pNvData))
{
/* 打印查询的 类型 */
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeNvOplmn: Point is Null");
return NAS_LMM_NVIM_FAIL;
}
if ((NAS_USIM_MIN_PLMN_LEN > pstNvCtrlTbl->usNvDataLen)
|| (NAS_LMM_NULL != pstNvCtrlTbl->usNvDataLen % NAS_LMM_PLMN_AND_ACT_LEN))
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeNvOplmn:len is err!");
/*return NAS_LMM_NVIM_FAIL;*/
}
pstOplmnAct->ulPlmnNum = pstNvCtrlTbl->usNvDataLen / NAS_LMM_PLMN_AND_ACT_LEN;
for(i= 0; i < pstOplmnAct->ulPlmnNum; i++ )
{
NAS_LMM_MEM_CPY( &stPlmnId,
&pucMsg[NAS_LMM_PLMN_AND_ACT_LEN*i],
NAS_LMM_NVIM_PLMN_ID_LEN);
if (VOS_FALSE == NAS_LMM_PlmnIsUndef(&stPlmnId))
{
NAS_LMM_MEM_CPY(&(pstOplmnAct->aucPlmnId[NAS_LMM_PLMN_AND_ACT_LEN*ulValidPlmnNum]),
&pucMsg[NAS_LMM_PLMN_AND_ACT_LEN*i],
NAS_LMM_PLMN_AND_ACT_LEN);
ulValidPlmnNum ++;
}
if (NAS_EMMC_MAX_OPLMN_NUM == ulValidPlmnNum)
{
NAS_LMM_NVIM_LOG_ERR("pstOplmnAct: Valid PlmnNum is overflow");
break;
}
}
pstOplmnAct->ulPlmnNum = ulValidPlmnNum;
NAS_LMM_NVIM_LOG1_INFO("NAS_LMM_DecodeNvOplmn: ulPlmnNum = ",
pstOplmnAct->ulPlmnNum);
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeNvOplmn: PLMN IS ");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(), (VOS_UINT8 *)pstOplmnAct->aucPlmnId,pstOplmnAct->ulPlmnNum * NAS_LMM_PLMN_AND_ACT_LEN);
return NAS_LMM_NVIM_OK;
}
else
#endif
{
return NAS_LMM_DecodeOneNvItem(pstNvCtrlTbl);
}
}
VOS_VOID NAS_EMM_MmcSendSerResultIndOtherType
(
MMC_LMM_SERVICE_RSLT_ENUM_UINT32 ulSerRslt
)
{
LMM_MMC_SERVICE_RESULT_IND_STRU *pstRsltInd = NAS_EMM_NULL_PTR;
/* 打印进入该函数*/
NAS_EMM_SER_LOG_INFO("NAS_EMM_MmcSendSerResultIndOtherType is entered.");
/* 申请MMC内部消息*/
pstRsltInd = (VOS_VOID *)NAS_LMM_GetLmmMmcMsgBuf(sizeof(LMM_MMC_SERVICE_RESULT_IND_STRU));
if(NAS_EMM_NULL_PTR == pstRsltInd)
{
NAS_EMM_SER_LOG_ERR("NAS_EMM_MmcSendSerResultIndOtherType: MSG ALLOC ERR !!");
return;
}
NAS_LMM_MEM_SET(pstRsltInd, 0, sizeof(LMM_MMC_SERVICE_RESULT_IND_STRU));
/* 填充给RRC的DOPRA头 */
EMM_PUBU_COMP_MMC_MSG_HEADER( pstRsltInd,
sizeof(LMM_MMC_SERVICE_RESULT_IND_STRU) -
EMM_LEN_VOS_MSG_HEADER);
/*填充OPID*/
/* 填充消息ID */
pstRsltInd->ulMsgId = ID_LMM_MMC_SERVICE_RESULT_IND;
/* 填充消息内容----SERVCIE结果 */
if ((MMC_LMM_SERVICE_RSLT_FAILURE== ulSerRslt) ||
(MMC_LMM_SERVICE_RSLT_ACCESS_BARED == ulSerRslt) ||
(MMC_LMM_SERVICE_RSLT_AUTH_REJ == ulSerRslt))
{
NAS_EMM_SER_LOG1_NORM("NAS_EMM_MmcSendSerResultIndOtherType: ulSerRslt = ",
ulSerRslt);
pstRsltInd->ulServiceRst = ulSerRslt;
}
else
{
NAS_EMM_SER_LOG_WARN("NAS_EMM_MmcSendSerResultIndOtherType: ulSerRslt is err! ");
}
/*填充消息内容----请求类型*/
/* 如果ARBOT标识无效，则是CSFB流程，则填写请求类型 */
if (NAS_EMM_CSFB_ABORT_FLAG_VALID != NAS_EMM_SER_GetEmmSerCsfbAbortFlag())
{
if (NAS_EMM_SER_START_CAUSE_MO_CSFB_REQ == NAS_EMM_SER_GetEmmSERStartCause())
{
pstRsltInd->bitOpReqType = NAS_EMM_BIT_SLCT;
pstRsltInd->ulReqType = MMC_LMM_SERVICE_MO_CSFB_1XCSFB;
}
else if (NAS_EMM_SER_START_CAUSE_MT_CSFB_REQ == NAS_EMM_SER_GetEmmSERStartCause())
{
pstRsltInd->bitOpReqType = NAS_EMM_BIT_SLCT;
pstRsltInd->ulReqType = MMC_LMM_SERVICR_MT_CSFB_1XCSFB;
}
else if (NAS_EMM_SER_START_CAUSE_MO_EMERGENCY_CSFB_REQ == NAS_EMM_SER_GetEmmSERStartCause())
{
pstRsltInd->bitOpReqType = NAS_EMM_BIT_SLCT;
pstRsltInd->ulReqType = MMC_LMM_SERVICR_MO_CSFB_1XCSFB_EMERGENCY;
}
else
{
/* 非CSFB类型不填写ulReqType */
}
}
/* 发送LMM_MMC_SERVICE_RESULT_IND消息 */
NAS_LMM_SendLmmMmcMsg( pstRsltInd);
return;
}
VOS_UINT32 NAS_LMM_EncodeSimPsLoc( NAS_NVIM_CTRL_TBL *pstNvCtrlTbl )
{
NAS_LMM_GUTI_STRU stGuti;
NAS_MM_TA_STRU stTai;
VOS_UINT8 *pucNvData;
VOS_UINT8 *pucData;
VOS_UINT16 usIndex = 0;
VOS_UINT32 ulLen = 0;
VOS_UINT8 *pstLastPsLoc;
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeSimPsLoc is entered");
pstLastPsLoc = NAS_LMM_GetEmmInfoLastWriteUsimPsLocAddr();
if(NAS_NVIM_NULL_PTR == pstNvCtrlTbl->pData)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_EncodeSimPsLoc: WARNING->pData is Null");
return NAS_LMM_NVIM_FAIL;
}
pucData = (VOS_UINT8 *)pstNvCtrlTbl->pData;
pucNvData = (VOS_UINT8 *)pstNvCtrlTbl->pNvData;
/*****************GUTI*******************/
ulLen = sizeof(VOS_UINT32);
NAS_LMM_MEM_CPY( &stGuti,
&(pucData[ulLen]),
sizeof(NAS_LMM_GUTI_STRU));
pucNvData[usIndex ++] = NAS_LMM_NVIM_GUTI_AND_OETOI_LEN;
pucNvData[usIndex ++] = (stGuti.stGutiHead.ucOeToi |
NAS_EMM_HIGH_HALF_BYTE_F);
pucNvData[usIndex ++] = stGuti.stPlmnId.aucPlmnId[0];
pucNvData[usIndex ++] = stGuti.stPlmnId.aucPlmnId[1];
pucNvData[usIndex ++] = stGuti.stPlmnId.aucPlmnId[2];
pucNvData[usIndex ++] = stGuti.stMmeGroupId.ucGroupId;
pucNvData[usIndex ++] = stGuti.stMmeGroupId.ucGroupIdCnt;
pucNvData[usIndex ++] = stGuti.stMmeCode.ucMmeCode;
/*pucNvData[usIndex ++] = stGuti.stMTmsi.ucMTmsi;*/
NAS_LMM_MEM_CPY( &(pucNvData[usIndex]),
&(stGuti.stMTmsi),
sizeof(NAS_LMM_MTMSI_STRU));
usIndex += sizeof(NAS_EMM_MTMSI_STRU);
/*L.V.R TAI*/
ulLen += sizeof(NAS_LMM_GUTI_STRU);
NAS_LMM_MEM_CPY( &stTai,
&(pucData[ulLen]),
sizeof(NAS_MM_TA_STRU));
pucNvData[usIndex ++] = stTai.stPlmnId.aucPlmnId[0];
pucNvData[usIndex ++] = stTai.stPlmnId.aucPlmnId[1];
pucNvData[usIndex ++] = stTai.stPlmnId.aucPlmnId[2];
pucNvData[usIndex ++] = stTai.stTac.ucTac;
pucNvData[usIndex ++] = stTai.stTac.ucTacCnt;
/*UPDATE STATUS*/
ulLen += sizeof(NAS_MM_TA_STRU);
pucNvData[usIndex++] = pucData[ulLen];
pstNvCtrlTbl->usNvDataLen = usIndex;
/* 如果上次写卡的码流与本次要写入的完全相同，则无需写入 */
if((0 == NAS_LMM_MEM_CMP( (const VOS_VOID *)pstLastPsLoc,
(const VOS_VOID *)pucNvData,
pstNvCtrlTbl->usNvDataLen)))
{
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeSimPsLoc: Equal value!");
return NAS_LMM_NVIM_WRITTEN_UNNEEDED;
}
/* 不相同，更新为本次写卡码流 */
NAS_LMM_MEM_SET( pstLastPsLoc,
0,
sizeof(LNAS_LMM_NV_EPS_LOC_STRU));
NAS_LMM_MEM_CPY( pstLastPsLoc,
pucNvData,
pstNvCtrlTbl->usNvDataLen);
return NAS_LMM_NVIM_OK;
}
VOS_UINT32 NAS_LMM_EncodeSimSecContext( NAS_NVIM_CTRL_TBL *pstNvCtrlTbl )
{
VOS_UINT8 *pucNvData = VOS_NULL_PTR;
LNAS_LMM_NV_EPS_SEC_CONTEXT_STRU *pstNvSecContext = VOS_NULL_PTR;
VOS_UINT16 usIndex = 0;
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeSimSecContext is entered");
if(NAS_NVIM_NULL_PTR == pstNvCtrlTbl->pData)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_EncodeSimSecContext: WARNING->pData is Null");
return NAS_LMM_NVIM_FAIL;
}
pstNvSecContext = (LNAS_LMM_NV_EPS_SEC_CONTEXT_STRU *)pstNvCtrlTbl->pData;
pucNvData = (VOS_UINT8 *)pstNvCtrlTbl->pNvData;
/*初始化安全上下文为全FF*/
NAS_LMM_SetArrayAllBytesFF(pucNvData,NAS_EMM_GET_USIM_SECU_FILE_LEN());
/*EPS NAS Security Context Tag SMC 长度*/
pucNvData[usIndex ++] = NAS_LMM_NVIM_SECU_CONTEXT_TAG;
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_MSG_LEN;
/*********** KSIASME ************/
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_KSI_TAG;
pucNvData[usIndex ++] = sizeof(VOS_UINT8);
pucNvData[usIndex ++] = pstNvSecContext->ucKSIasme;
/*********** KASME **************/
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_KASME_TAG;
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_KASME_LEN;
NAS_LMM_MEM_CPY( &(pucNvData[usIndex]),
pstNvSecContext->aucKasme,
NAS_LMM_NVIM_SEC_KASME_LEN);
usIndex += NAS_LMM_NVIM_SEC_KASME_LEN;
/*********** Uplink NAS count **************/
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_UPNASCOUNT_TAG;
pucNvData[usIndex ++] = sizeof(VOS_UINT32);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulUlNasCount >> NAS_LMM_NVIM_MOVE_24_BIT)
& NAS_LMM_NVIM_BYTE_FF);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulUlNasCount >> NAS_LMM_NVIM_MOVE_16_BIT)
& NAS_LMM_NVIM_BYTE_FF);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulUlNasCount >> NAS_LMM_NVIM_MOVE_8_BIT)
& NAS_LMM_NVIM_BYTE_FF);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulUlNasCount)
& NAS_LMM_NVIM_BYTE_FF);
/*********** Downlink NAS count **************/
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_DNNASCOUNT_TAG;
pucNvData[usIndex ++] = sizeof(VOS_UINT32);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulDlNasCount >> NAS_LMM_NVIM_MOVE_24_BIT)
& NAS_LMM_NVIM_BYTE_FF);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulDlNasCount >> NAS_LMM_NVIM_MOVE_16_BIT)
& NAS_LMM_NVIM_BYTE_FF);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulDlNasCount >> NAS_LMM_NVIM_MOVE_8_BIT)
& NAS_LMM_NVIM_BYTE_FF);
pucNvData[usIndex ++] = (VOS_UINT8)((pstNvSecContext->ulDlNasCount)
& NAS_LMM_NVIM_BYTE_FF);
/*********** Identifiers of selected NAS integrity and encryption algorithms **************/
pucNvData[usIndex ++] = NAS_LMM_NVIM_SEC_ALG_TAG;
pucNvData[usIndex ++] = sizeof(VOS_UINT8);
pucNvData[usIndex ++] = pstNvSecContext->ucSecuAlg;
pstNvCtrlTbl->usNvDataLen = (VOS_UINT16)NAS_EMM_GET_USIM_SECU_FILE_LEN();
NAS_LMM_NVIM_LOG1_INFO("NAS_LMM_EncodeSimSecContext: ESP SEC CONTEXT",pstNvCtrlTbl->usNvDataLen);
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeSimSecContext: ESP SEC CONTEXT");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(),pucNvData,pstNvCtrlTbl->usNvDataLen);
/* 如果上次写卡的码流与本次要写入的完全相同，则无需写入 */
if((0 == NAS_LMM_MEM_CMP( (const VOS_VOID *)NAS_LMM_GET_USIM_EPS_SECU_CONTEXT_ADDR(),
(const VOS_VOID *)pucNvData,
pstNvCtrlTbl->usNvDataLen)))
{
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeSimPsLoc: Equal value!");
return NAS_LMM_NVIM_WRITTEN_UNNEEDED;
}
/* 不相同，更新为本次写卡码流 */
NAS_LMM_MEM_SET(NAS_LMM_GET_USIM_EPS_SECU_CONTEXT_ADDR(),
0,
NAS_NVIM_SECU_CONTEXT_MAX_LEN);
/* 如果长度大于缓存区，则认为异常不保存上次写卡码流 */
if(NAS_NVIM_SECU_CONTEXT_MAX_LEN >= pstNvCtrlTbl->usNvDataLen)
{
NAS_LMM_MEM_CPY(NAS_LMM_GET_USIM_EPS_SECU_CONTEXT_ADDR(),
pucNvData,
pstNvCtrlTbl->usNvDataLen);
}
return NAS_LMM_NVIM_OK;
}
VOS_VOID NAS_EMM_SER_SendMrrcDataReq_ServiceReq()
{
NAS_EMM_MRRC_DATA_REQ_STRU *pMrrcDataReqMsg = NAS_EMM_NULL_PTR;
VOS_UINT32 ulDataReqMsgLenNoHeader;
VOS_UINT32 ulCnMsgLen;
NAS_EMM_SER_LOG_INFO("NAS_EMM_SER_SendMrrcDataReq_ServiceReq is entered.");
/* 计算NAS_MSG_STRU消息长度 */
ulCnMsgLen = NAS_EMM_COUNT_CN_SER_REQ_LEN;
ulDataReqMsgLenNoHeader = EMM_COUNT_DATA_REQ_LEN(ulCnMsgLen);
/* 申请DOPRA消息 */
pMrrcDataReqMsg = (VOS_VOID *)NAS_LMM_MEM_ALLOC(NAS_EMM_INTRA_MSG_MAX_SIZE);
if(NAS_EMM_NULL_PTR == pMrrcDataReqMsg)
{
NAS_EMM_SER_LOG_ERR( "Nas_Emm_SER_SendMrrcDataReq_ServiceReq: MSG ALLOC ERR !!");
return;
}
/* xiongxianghui00253310 add memset 2013-11-26 begin */
NAS_LMM_MEM_SET(pMrrcDataReqMsg, 0, NAS_EMM_INTRA_MSG_MAX_SIZE);
/* xiongxianghui00253310 add memset 2013-11-26 end */
/* 清除CSFB ABORT标识 */
NAS_EMM_SER_SaveEmmSerCsfbAbortFlag(NAS_EMM_CSFB_ABORT_FLAG_INVALID);
/* 填写MRRC_DATA_REQ 的DOPRA消息头 */
EMM_COMP_MM_MSG_HEADER(pMrrcDataReqMsg, ulDataReqMsgLenNoHeader);
/* 填写MRRC_DATA_REQ 的消息ID标识 */
pMrrcDataReqMsg->ulMsgId = ID_NAS_LMM_INTRA_MRRC_DATA_REQ;
/*填写建立原因*/
switch(NAS_EMM_SER_GetEmmSERStartCause())
{
case NAS_EMM_SER_START_CAUSE_RRC_PAGING:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MT_ACCESS;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_TERMINATING_CALL;
break;
case NAS_EMM_SER_START_CAUSE_RABM_REEST:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_DATA;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_CALL;
break;
case NAS_EMM_SER_START_CAUSE_ESM_DATA_REQ:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_DATA;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_CALL;
break;
case NAS_ESM_SER_START_CAUSE_UPLINK_PENDING:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_DATA;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_CALL;
break;
case NAS_EMM_SER_START_CAUSE_SMS_EST_REQ:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_MO_DATA;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_ORIGINATING_CALL;
break;
/* lihong00150010 emergency tau&service begin */
case NAS_EMM_SER_START_CAUSE_ESM_DATA_REQ_EMC:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_EMERGENCY_CALL;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_EMERGENCY_CALL;
break;
case NAS_EMM_SER_START_CAUSE_RABM_REEST_EMC:
pMrrcDataReqMsg->enEstCaue = LRRC_LNAS_EST_CAUSE_EMERGENCY_CALL;
pMrrcDataReqMsg->enCallType = LRRC_LNAS_CALL_TYPE_EMERGENCY_CALL;
break;
/* lihong00150010 emergency tau&service end */
default:
NAS_EMM_SER_LOG_ERR("Nas_Emm_SER_SendMrrcDataReq_ServiceReq:StartCause ERR");
break;
}
pMrrcDataReqMsg->enEmmMsgType = NAS_EMM_MSG_SERVICE_REQ;
/* 填写MRRC_DATA_REQ 的NAS消息长度标识 */
pMrrcDataReqMsg->stNasMsg.ulNasMsgSize = ulCnMsgLen;
pMrrcDataReqMsg->enDataCnf = LRRC_LMM_DATA_CNF_NEED;
/* 构造MRRC_DATA_REQ 中的 NAS_MSG_STRU,即CN消息(Compose the msg of): SER_REQ */
NAS_EMM_SER_CompCnServiceReq( &(pMrrcDataReqMsg->stNasMsg));
/*空口消息上报SER REQ*/
NAS_LMM_SendOmtAirMsg(NAS_EMM_OMT_AIR_MSG_UP, NAS_EMM_SER_REQ, (NAS_MSG_STRU*)&(pMrrcDataReqMsg->stNasMsg));
/*关键事件上报SER REQ*/
NAS_LMM_SendOmtKeyEvent( EMM_OMT_KE_SER_REQ);
/* 发送消息(Send the msg of) MRRC_DATA_REQ(SER_REQ) */
NAS_EMM_SndUplinkNasMsg((VOS_VOID*)pMrrcDataReqMsg);
NAS_LMM_MEM_FREE(pMrrcDataReqMsg);
return;
}
/*****************************************************************************
Function Name : NAS_LMM_NvimRead
Discription : 其他模块调用本函数读一个指定的NV_Item
Input : ulNVItemType: NV_Item类型
*pData ：数据缓存指针
*pusDataLen：返回数据长度
Output : pusDataLen ：返回数据长度
Return : 0：数据成功读取，函数正常返回
1：未找到要读取的NV项
3：传入的缓存不够出错
4：系统异常，读取出错
History:
1.sunbing 49683 2010-7-22 modify
*****************************************************************************/
NAS_LMM_USIM_NV_RESULT NAS_LMM_NvimRead( NAS_LMM_ITEM_TYPE_ENUM_UINT32 ulNVItemType,
VOS_VOID *pData,
const VOS_UINT16 *pusDataLen )
{
VOS_UINT32 ulRslt = NAS_LMM_NVIM_FAIL;
NAS_NVIM_CTRL_TBL stNvCtrlTbl;
VOS_UINT32 i;
NAS_LMM_NV_ACTION_FUN pActFun = NAS_LMM_NULL_PTR;
USIMM_GET_FILE_INFO_STRU stGetFileInfo = {0};
/*check input params*/
if((NAS_NVIM_NULL_PTR == pData) ||
(NAS_NVIM_NULL_PTR == pusDataLen) ||
(ulNVItemType > EN_NV_ID_PS_END))
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_NvimRead :Input Para is error");
return NAS_LMM_NVIM_FAIL;
}
NAS_LMM_MEM_SET(g_aucNvimBuff, 0, sizeof(g_aucNvimBuff));
/*Initalize NVIM ctrl tbl*/
stNvCtrlTbl.pData = pData;
stNvCtrlTbl.pNvData = g_aucNvimBuff;
stNvCtrlTbl.usDataLen = *pusDataLen;
stNvCtrlTbl.usNvDataLen = *pusDataLen;
/*lint -e438*/
/*硬USIM下，并且NV ITEM属于USIM的范围，则从USIM中读取文件*/
if((EN_NV_ID_USIM_BEGIN < ulNVItemType)
&&(EN_NV_ID_USIM_END > ulNVItemType))
{
for(i = 0; i < g_ulNvDataMapNum; i++)
{
/* 若NV类型相同,则找到了,返回当前的NV动作函数，退出循环 */
if(ulNVItemType == g_astNvDataMap[i].ulEventType)
{
stGetFileInfo.usEfId = g_astNvDataMap[i].usUsimFileId;
break;
}
}
if(NAS_USIM_FILE_ID_INVALID == stGetFileInfo.usEfId)
{
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_NvimRead :Donot find Usim file ID.");
return NAS_LMM_NVIM_FAIL;
}
/*ucRecordNum默认为1，NAS目前涉及的文件是线形文件，且只有一个记录*/
stGetFileInfo.ucRecordNum = 1;
stGetFileInfo.enAppType = USIMM_UMTS_APP;
/*
ulRslt = Api_UsimGetFileReq(PS_USIM_CLIENT_MM,
usEfId,
ucRecordNum);
*/
ulRslt = USIMM_GetFileReq( PS_PID_MM,
0,
&stGetFileInfo);
NAS_EMM_GET_SEND_COUNTER()++;
/*需要返回失败，这样，调用处发现返回失败后，就把全局变量内存清空，
而不会向里面赋值，真正的赋值要等待收到USIM的READ FILE消息后，才做。*/
return NAS_LMM_NVIM_HARD_USIM;
}
/*lint +e438*/
/*其他情况从NV中读取信息*/
/*lint -e718*/
/*lint -e516*/
/*lint -e732*/
ulRslt = LPs_NvimItem_Read( ulNVItemType,
stNvCtrlTbl.pNvData,
stNvCtrlTbl.usNvDataLen);
/*lint +e732*/
/*lint +e516*/
/*lint +e718*/
if(ulRslt != EN_NV_OK)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_NvimRead:PS_NVIM_Read is fail");
return NAS_LMM_NVIM_FAIL;
}
/* 在g_astNvDataMap中查找对应的NV TYPE*/
for(i = 0; i < g_ulNvDataMapNum; i++)
{
/* 若NV类型相同,则找到了,返回当前的NV动作函数，退出循环 */
if(ulNVItemType == g_astNvDataMap[i].ulEventType)
{
pActFun = g_astNvDataMap[i].pfDecodeActionFun;
break;
}
}
if (NAS_LMM_NULL_PTR != pActFun)
{
ulRslt = (*pActFun) (&stNvCtrlTbl);
if(NAS_LMM_NVIM_OK == ulRslt)
{
return NAS_LMM_NVIM_OK;
}
else
{
return NAS_LMM_NVIM_FAIL;
}
}
else /* 如果找不到处理函数，表示当前没有该处理函数 */
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_NvimRead:Action functin is ERR");
return NAS_LMM_NVIM_FAIL;
}
}
VOS_VOID NAS_EMM_MmcSendSerResultIndRej
(
NAS_EMM_CN_CAUSE_ENUM_UINT8 ucCnCause
)
{
LMM_MMC_SERVICE_RESULT_IND_STRU *pstRsltInd = NAS_EMM_NULL_PTR;
/* 打印进入该函数， INFO_LEVEL */
NAS_EMM_SER_LOG_INFO( "NAS_EMM_MmcSendSerResultIndRej is entered.");
/* 申请MMC内部消息 */
pstRsltInd = (VOS_VOID *)NAS_LMM_GetLmmMmcMsgBuf(sizeof(LMM_MMC_SERVICE_RESULT_IND_STRU));
if(NAS_EMM_NULL_PTR == pstRsltInd)
{
NAS_EMM_SER_LOG_ERR( "NAS_EMM_SER_SendMmcActionResultReq: MSG ALLOC ERR !!");
return;
}
NAS_LMM_MEM_SET(pstRsltInd, 0, sizeof(LMM_MMC_SERVICE_RESULT_IND_STRU));
/* 填充给RRC的DOPRA头 */
EMM_PUBU_COMP_MMC_MSG_HEADER( pstRsltInd,
sizeof(LMM_MMC_SERVICE_RESULT_IND_STRU) -
EMM_LEN_VOS_MSG_HEADER);
/*填充OPID*/
/* 填充消息ID */
pstRsltInd->ulMsgId = ID_LMM_MMC_SERVICE_RESULT_IND;
/* 填充消息内容----SERVCIE结果 */
pstRsltInd->ulServiceRst = MMC_LMM_SERVICE_RSLT_CN_REJ;
/*填充消息内容----拒绝原因值*/
pstRsltInd->bitOpCnCause = NAS_EMM_BIT_SLCT;
pstRsltInd->ucCnCause = ucCnCause;
/*填充消息内容----请求类型*/
/* 如果ARBOT标识无效，则是CSFB流程，则填写请求类型 */
if (NAS_EMM_CSFB_ABORT_FLAG_VALID != NAS_EMM_SER_GetEmmSerCsfbAbortFlag())
{
if (NAS_EMM_SER_START_CAUSE_MO_CSFB_REQ == NAS_EMM_SER_GetEmmSERStartCause())
{
pstRsltInd->bitOpReqType = NAS_EMM_BIT_SLCT;
pstRsltInd->ulReqType = MMC_LMM_SERVICE_MO_CSFB_1XCSFB;
}
else if (NAS_EMM_SER_START_CAUSE_MT_CSFB_REQ == NAS_EMM_SER_GetEmmSERStartCause())
{
pstRsltInd->bitOpReqType = NAS_EMM_BIT_SLCT;
pstRsltInd->ulReqType = MMC_LMM_SERVICR_MT_CSFB_1XCSFB;
}
else if (NAS_EMM_SER_START_CAUSE_MO_EMERGENCY_CSFB_REQ == NAS_EMM_SER_GetEmmSERStartCause())
{
pstRsltInd->bitOpReqType = NAS_EMM_BIT_SLCT;
pstRsltInd->ulReqType = MMC_LMM_SERVICR_MO_CSFB_1XCSFB_EMERGENCY;
}
else
{
/* 非CSFB类型不填写ulReqType */
}
}
/* 发送LMM_MMC_SERVICE_RESULT_IND消息 */
NAS_LMM_SendLmmMmcMsg( pstRsltInd);
return;
}
/*****************************************************************************
Function Name : NAS_LMM_DecodeNvFplmnList
Discription : 解码Forbidden PLMN List
Input : pstNvCtrlTbl:公共处理结构
Output : 解码后的数据
Return :
History:
*****************************************************************************/
VOS_UINT32 NAS_LMM_DecodeNvFplmnList(NAS_NVIM_CTRL_TBL *pstNvCtrlTbl)
{
#if 0
VOS_UINT32 i = 0;
VOS_UINT32 ulValidPlmnNum = NAS_LMM_NULL;
VOS_UINT8 *pucMsg;
NAS_EMMC_PLMN_LIST_STRU *pstFplmn;
VOS_UINT32 *pulMaxNumOfFplmnByUsim = VOS_NULL_PTR;
NAS_EMMC_PLMN_ID_STRU stPlmnId;
if(NAS_EMM_USIM_FEATURE_HARD == NAS_LMM_GetUsimFeature())
{
NAS_LMM_MEM_SET(&stPlmnId,0,sizeof(NAS_MM_PLMN_ID_STRU));
pstFplmn = (VOS_VOID*)NAS_EMMC_GetMmcGlobleAddr(NAS_LMM_GLOBLE_PARA_FPLMNLIST);
pucMsg = (VOS_UINT8*)pstNvCtrlTbl->pNvData;
/* 获取存放USIM中的 FPLMN列表中 PLMN个数的 全局变量的地址 */
pulMaxNumOfFplmnByUsim = (VOS_UINT32 *)NAS_EMMC_GetMmcGlobleAddr(NAS_LMM_GLOBLE_PARA_MAX_NUM_OF_FPLMN_BY_USIM);
/* 计算USIM 中的 FPLMN列表中 PLMN的个数*/
*pulMaxNumOfFplmnByUsim = pstNvCtrlTbl->usNvDataLen / NAS_LMM_NVIM_PLMN_ID_LEN;
/* 若 USIM 中的 FPLMN列表中 PLMN的个数 超过NAS内存允许的最大值，则将此
个数限制为NAS内存运行的最大值*/
if (NAS_MM_MAX_PLMN_NUM < (*pulMaxNumOfFplmnByUsim))
{
(*pulMaxNumOfFplmnByUsim) = NAS_MM_MAX_PLMN_NUM;
}
for(i = 0; i < (*pulMaxNumOfFplmnByUsim); i++)
{
/* 顺序拷贝PLMN ID，接着判断是否有效 */
NAS_LMM_MEM_CPY( &stPlmnId,
&pucMsg[NAS_LMM_NVIM_PLMN_ID_LEN*i],
NAS_LMM_NVIM_PLMN_ID_LEN);
/*如果PLMN ID有效，赋值给全局变量*/
if (VOS_FALSE == NAS_LMM_PlmnIsUndef(&stPlmnId))
{
NAS_LMM_MEM_CPY(&(pstFplmn->astPlmnId[ulValidPlmnNum]),
&pucMsg[NAS_LMM_NVIM_PLMN_ID_LEN*i],
NAS_LMM_NVIM_PLMN_ID_LEN);
ulValidPlmnNum ++;
}
}
/* 赋值全局变量: 总有效FPLMN ID个数 */
pstFplmn->ulPlmnNum = ulValidPlmnNum;
NAS_LMM_NVIM_LOG1_INFO("NAS_LMM_DecodeNvFplmnList: ulPlmnNum = ",
pstFplmn->ulPlmnNum);
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeNvFplmnList: PLMN IS ");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(), (VOS_UINT8*)pstFplmn->astPlmnId,(pstFplmn->ulPlmnNum) * 4);
return NAS_LMM_NVIM_OK;
}
else
#endif
{
return NAS_LMM_DecodeOneNvItem(pstNvCtrlTbl);
}
}
VOS_VOID NAS_EMM_MmSendCsfbSerPaingInd
(
NAS_EMM_MT_CSFB_TYPE_ENUM_UINT8 enMtCsfbType,
const NAS_EMM_CN_CS_SER_NOTIFICAIOTN_STRU *pstCsSerNotification,
LRRC_LNAS_PAGING_UE_ID_ENUM_UINT32 enPagingUeId
)
{
LMM_MM_CSFB_SERVICE_PAGING_IND_STRU *pstMmCsfbSerPaingInd = VOS_NULL_PTR;
/* 申请DOPRA消息 */
pstMmCsfbSerPaingInd = (VOS_VOID *) NAS_LMM_GetLmmMmcMsgBuf(sizeof(LMM_MM_CSFB_SERVICE_PAGING_IND_STRU));
if (NAS_LMM_NULL_PTR == pstMmCsfbSerPaingInd)
{
/* 打印异常，ERROR_LEVEL */
NAS_EMM_SER_LOG_ERR("NAS_EMM_MmSendCsfbSerPaingInd: MSG ALLOC ERROR!!!");
return ;
}
/* 清空 */
NAS_LMM_MEM_SET(pstMmCsfbSerPaingInd, 0, sizeof(LMM_MM_CSFB_SERVICE_PAGING_IND_STRU));
/* 打包VOS消息头 */
EMM_PUBU_COMP_MM_MSG_HEADER((pstMmCsfbSerPaingInd),
NAS_EMM_GET_MSG_LENGTH_NO_HEADER(LMM_MM_CSFB_SERVICE_PAGING_IND_STRU));
/* 填充消息ID */
pstMmCsfbSerPaingInd->ulMsgId = ID_LMM_MM_CSFB_SERVICE_PAGING_IND;
/* 填充消息体 */
pstMmCsfbSerPaingInd->ulOpId = NAS_EMM_OPID_MM;
if (NAS_EMM_MT_CSFB_TYPE_CS_SER_NOTIFICATION == enMtCsfbType)
{
/* 填充CLI */
pstMmCsfbSerPaingInd->bitOpCli = pstCsSerNotification->bitOpCli;
pstMmCsfbSerPaingInd->ucCliLength = pstCsSerNotification->ucCliLength;
NAS_LMM_MEM_CPY( pstMmCsfbSerPaingInd->aucCliValue,
pstCsSerNotification->aucCliValue,
pstCsSerNotification->ucCliLength);
/* 填充SS CODE */
pstMmCsfbSerPaingInd->bitOpSsCodeValue = pstCsSerNotification->bitOpSsCode;
pstMmCsfbSerPaingInd->ucSsCodeValue = pstCsSerNotification->ucSsCodeValue;
if (0 == pstCsSerNotification->ucPagingIdenity)
{
pstMmCsfbSerPaingInd->enPagingUeId = LMM_MM_PAGING_IND_UE_ID_IMSI;
}
else
{
pstMmCsfbSerPaingInd->enPagingUeId = LMM_MM_PAGING_IND_UE_ID_TMSI;
}
}
else
{
if(LRRC_LNAS_S_TMSI_LTE == enPagingUeId)
{
pstMmCsfbSerPaingInd->enPagingUeId = LMM_MM_PAGING_IND_UE_ID_S_TMSI;
}
else if(LRRC_LNAS_IMSI_LTE == enPagingUeId)
{
pstMmCsfbSerPaingInd->enPagingUeId = LMM_MM_PAGING_IND_UE_ID_IMSI;
}
else
{
}
}
/* 发送DOPRA消息 */
NAS_LMM_SendLmmMmcMsg((VOS_VOID*)pstMmCsfbSerPaingInd);
return;
}
