VOS_VOID NAS_ESM_TimerMsgDistr(const VOS_VOID *pRcvMsg )
{
VOS_UINT32 ulIndex = NAS_ESM_NULL;
NAS_ESM_TIMER_PARA_ENUM_UINT8 enTimerType = TI_NAS_ESM_TIMER_PARA_BUTT;
NAS_ESM_INFO_LOG("NAS_ESM_TimerMsgDistr is entered.");
/*从消息中取出状态表ID*/
ulIndex = PS_GET_REL_TIMER_NAME(pRcvMsg);
enTimerType = (NAS_ESM_TIMER_PARA_ENUM_UINT8)PS_GET_REL_TIMER_PARA(pRcvMsg);
/*判断承载ulStateTblIndex合法性*/
if (PS_FALSE == NAS_ESM_IsTimerNameValid(ulIndex, enTimerType))
{
/*打印异常信息*/
NAS_ESM_WARN_LOG("NAS_ESM_TimerMsgDistr:WARNING:Timer->SM ,Invalid Timer Name or Para !");
return;
}
/*定时器超时处理*/
switch(enTimerType)
{
case TI_NAS_ESM_T3482:
NAS_ESM_ProcTimerMsgT3482Exp(pRcvMsg);
break;
case TI_NAS_ESM_T3492:
NAS_ESM_ProcTimerMsgT3492Exp(pRcvMsg);
break;
case TI_NAS_ESM_T3480:
NAS_ESM_ProcTimerMsgT3480Exp(pRcvMsg);
break;
case TI_NAS_ESM_T3481:
NAS_ESM_ProcTimerMsgT3481Exp(pRcvMsg);
break;
case TI_NAS_ESM_WAIT_APP_CNF:
NAS_ESM_ProcTimerMsgWaitAppCnfExp(pRcvMsg);
break;
case TI_NAS_ESM_WAIT_PTI_INVALID:
NAS_ESM_ProcTimerMsgWaitPtiInvaidExp(pRcvMsg);
break;
case TI_NAS_ESM_ATTACH_BEARER_REEST:
NAS_ESM_ProcTimerMsgAttachBearerReestExp(pRcvMsg);
break;
case TI_NAS_ESM_REL_NON_EMC_BEARER:
NAS_ESM_ProcTimerMsgDeferRelNonEmcExp(pRcvMsg);
break;
default:
NAS_ESM_WARN_LOG("NAS_ESM_TimerMsgDistr:WARNING:Illegal Timer Type!");
break;
}
}
VOS_UINT32 NAS_ESM_RevOmFtmCtrlMsg(MsgBlock *pMsgStru)
{
OM_FTM_CTRL_IND_STRU *pstOmFtmCtrlInfo;
NAS_ESM_INFO_LOG("NAS_ESM_RevOmFtmCtrlMsg.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_RevOmFtmCtrlMsg_ENUM, LNAS_ENTRY);
if (VOS_NULL_PTR == pMsgStru)
{
NAS_ESM_WARN_LOG("NAS_ESM_RevOmFtmCtrlMsg, input point is null!");
TLPS_PRINT2LAYER_WARNING(NAS_ESM_RevOmFtmCtrlMsg_ENUM, LNAS_NULL_PTR);
return NAS_ESM_MSG_DISCARD;
}
pstOmFtmCtrlInfo = (OM_FTM_CTRL_IND_STRU *)(VOS_VOID *)pMsgStru;
NAS_ESM_INFO_LOG1("ESM_OM_ProcOmFtmCtrlInfo, ucActionFlag = ", pstOmFtmCtrlInfo->ucActionFlag);
TLPS_PRINT2LAYER_INFO1(NAS_ESM_RevOmFtmCtrlMsg_ENUM, 1, pstOmFtmCtrlInfo->ucActionFlag);
if(1 == pstOmFtmCtrlInfo->ucActionFlag)
{
/*设置工程模式上报功能打开*/
NAS_ESM_SetFtmOmManageFtmActionFlag(NAS_ESM_FTM_ACTION_FLAG_OPEN);
/*上报当前信息 */
NAS_ESM_SendOmFtmMsg();
}
else
{
/*关闭工程模式上报，*/
NAS_ESM_SetFtmOmManageFtmActionFlag(NAS_ESM_FTM_ACTION_FLAG_CLOSE);
}
return NAS_ESM_MSG_HANDLED;
}
VOS_VOID NAS_ESM_SndKeyEventReportInd(OM_PS_KEY_EVENT_ENUM_UINT8 enKeyEvent)
{
#if (VOS_WIN32 != VOS_OS_VER)
DIAG_EVENT_IND_STRU stDiagEventInd;
#ifndef PS_ITT_PC_TEST
NAS_ESM_MEM_SET_S( &stDiagEventInd,
sizeof(DIAG_EVENT_IND_STRU),
0,
sizeof(DIAG_EVENT_IND_STRU));
stDiagEventInd.ulModule = LPS_OM_ID(UE_MODULE_ESM_ID, DIAG_LOG_TYPE_INFO);
stDiagEventInd.ulPid = UE_MODULE_ESM_ID;
stDiagEventInd.ulEventId = (VOS_UINT32)(enKeyEvent+OM_PS_KEY_EVENT_BASE_ID);
/*lint -e778*/
/*lint -e648*/
if(ERR_MSP_SUCCESS != LDRV_DIAG_EVENTREPORT(&stDiagEventInd))
{
NAS_ESM_WARN_LOG("NAS_ESM_SndKeyEventReportInd: Send Msg Fail!");
TLPS_PRINT2LAYER_WARNING(NAS_ESM_SndKeyEventReportInd_ENUM, LNAS_FAIL);
}
/*lint +e648*/
/*lint +e778*/
#endif
#endif
NAS_ESM_NORM_LOG("ESM->OMT: PS_OMT_KEY_EVT_REPORT_IND\r");
TLPS_PRINT2LAYER_INFO(NAS_ESM_SndKeyEventReportInd_ENUM, 1);
}
VOS_VOID NAS_ESM_SndAirMsgReportInd
(
const VOS_UINT8 *pucData,
VOS_UINT32 ulLength,
NAS_ESM_AIR_MSG_DIR_ENUM_UINT8 enMsgDir,
OM_PS_AIR_MSG_ENUM_UINT8 enMsgId
)
{
#ifndef PS_ITT_PC_TEST
DIAG_AIR_IND_STRU stAirMsg;
VOS_UINT8 *pucTmpData = VOS_NULL_PTR;
/*分配空口消息空间*/
pucTmpData = (VOS_UINT8*)
NAS_ESM_MEM_ALLOC(ulLength);
if(VOS_NULL_PTR== pucTmpData)
{
NAS_ESM_ERR_LOG("NAS_ESM_SndAirMsgReportInd: MEM_ALLOC ERR!");
TLPS_PRINT2LAYER_ERROR(NAS_ESM_SndAirMsgReportInd_ENUM, LNAS_EMM_ALLOC_FAIL);
return;
}
NAS_ESM_MEM_CPY_S(pucTmpData, ulLength, pucData, ulLength);
/*设置空口消息方向*/
if(NAS_ESM_AIR_MSG_DIR_ENUM_UP == enMsgDir)
{
stAirMsg.ulModule = LPS_OM_ID(PS_PID_ESM, OS_MSG_UL);
stAirMsg.ulPid = PS_PID_ESM;
stAirMsg.ulDirection = DIAG_SIDE_NET;
}
else
{
stAirMsg.ulModule = LPS_OM_ID(PS_PID_ESM, OS_MSG_DL);
stAirMsg.ulPid = PS_PID_ESM;
stAirMsg.ulDirection = DIAG_SIDE_UE;
}
stAirMsg.ulMsgId = (VOS_UINT32)(enMsgId+ PS_MSG_ID_AIR_BASE);
stAirMsg.ulLength = ulLength;
stAirMsg.pData = (void*)pucTmpData;
/*上报空口消息*/
if(ERR_MSP_SUCCESS != LDRV_DIAG_AIRMSGREPORT(&stAirMsg))
{
NAS_ESM_WARN_LOG("NAS_ESM_SndAirMsgReportInd: Send Msg Fail!");
TLPS_PRINT2LAYER_WARNING(NAS_ESM_SndAirMsgReportInd_ENUM, LNAS_FAIL);
}
/*释放空口消息空间*/
NAS_ESM_MEM_FREE(pucTmpData);
#endif
NAS_ESM_NORM_LOG("ESM->OMT: PS_OMT_AIR_MSG_REPORT_IND\r");
TLPS_PRINT2LAYER_INFO(NAS_ESM_SndAirMsgReportInd_ENUM, 1);
}
VOS_VOID NAS_ESM_OmMsgDistr
(
VOS_VOID *pRcvMsg
)
{
PS_MSG_HEADER_STRU *pOmMsg = VOS_NULL_PTR;
/*打印进入该函数*/
NAS_ESM_INFO_LOG("NAS_ESM_SmMsgDistr is entered.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_OmMsgDistr_ENUM, LNAS_ENTRY);
pOmMsg = (PS_MSG_HEADER_STRU*)pRcvMsg;
/*根据消息名，调用相应的消息处理函数*/
switch(pOmMsg->ulMsgName)
{
/*如果收到的是ID_SM_ESM_PDP_CONTEXT_INFO_IND消息*/
case ID_OM_ESM_INFO_REPORT_REQ:
(VOS_VOID)LTE_MsgHook((VOS_VOID*)pRcvMsg);
NAS_ESM_OmInfoIndMsgProc(pRcvMsg );
break;
case ID_APP_ESM_DT_INQ_PDP_INFO_REQ:
NAS_ESM_AppQueryActPdpInfoMsgProc(pRcvMsg);
break;
#if (FEATURE_PTM == FEATURE_ON)
case ID_OM_FTM_CTRL_IND:
(VOS_VOID)NAS_ESM_RevOmFtmCtrlMsg((MsgBlock *)pRcvMsg);
break;
#endif
default:
/*打印异常信息*/
NAS_ESM_WARN_LOG("NAS_ESM_OmMsgDistr:WARNING:OM->ESM Message name non-existent!");
TLPS_PRINT2LAYER_WARNING(NAS_ESM_OmMsgDistr_ENUM, 1);
break;
}
}
/*****************************************************************************
Function Name : NAS_ESM_TransparentMsgProc
Description : 透明传输命令处理函数
Input : VOS_VOID* pRcvMsg
Output : None
Return : VOS_VOID
History :
1.sunbing49683 2008-12-30 Draft Enact
*****************************************************************************/
VOS_VOID NAS_ESM_TransparentMsgProc( VOS_VOID* pRcvMsg )
{
NAS_ESM_TRANSPARENT_CMD_REQ_STRU *pAppMsg = VOS_NULL_PTR;
/*打印进入该函数*/
NAS_ESM_INFO_LOG("NAS_ESM_TransparentMsgProc is entered.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_TransparentMsgProc_ENUM, LNAS_ENTRY);
pAppMsg = (NAS_ESM_TRANSPARENT_CMD_REQ_STRU*)pRcvMsg;
switch(pAppMsg->enEsmTpCmdType)
{
case NAS_ESM_TP_CMD_TYPE_TEST:
break;
default:
NAS_ESM_WARN_LOG("NAS_ESM_TransparentMsgProc:NORM: Transparent Cmd not support!");
TLPS_PRINT2LAYER_WARNING(NAS_ESM_TransparentMsgProc_ENUM, 1);
break;
}
}
/*****************************************************************************
Function Name : NAS_ESM_ProcTimerMsgWaitAppCnfExp
Description : 等待APP回复定时器超时处理函数
Input : VOS_VOID *pMsg
Output : None
Return : VOS_VOID
History :
1.lihong00150010 2009-12-4 Draft Enact
*****************************************************************************/
VOS_VOID NAS_ESM_ProcTimerMsgWaitAppCnfExp(const VOS_VOID * pMsg)
{
VOS_UINT32 ulStateTblIndex = NAS_ESM_NULL;
/*打印进入该函数*/
NAS_ESM_NORM_LOG("NAS_ESM_ProcTimerMsgWaitAppCnfExp is entered.");
/*获取消息中包含的状态表StateTblIndex*/
ulStateTblIndex = PS_GET_REL_TIMER_NAME(pMsg);
if (NAS_ESM_L_MODE_STATUS_NORMAL != NAS_ESM_GetLModeStatus())
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgWaitAppCnfExp: L mode is already suspended!");
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
return ;
}
/* App拒绝承载激活或承载修改的处理 */
NAS_ESM_AppPdpManageRspMsgRefuseProc(ulStateTblIndex);
}
/*lint -e961*/
VOS_VOID NAS_ESM_ProcTimerMsgWaitPtiInvaidExp(const VOS_VOID * pMsg)
{
VOS_UINT32 ulEsmBuffIndex = NAS_ESM_NULL;
NAS_ESM_PTI_BUFF_ITEM_STRU *pstPtiBuffItem = VOS_NULL_PTR;
/* 获取消息中包含的ESM缓存记录索引号 */
ulEsmBuffIndex = PS_GET_REL_TIMER_NAME(pMsg);
/* 获取缓存记录 */
pstPtiBuffItem = (NAS_ESM_PTI_BUFF_ITEM_STRU*)
NAS_ESM_GetBuffItemAddr(NAS_ESM_BUFF_ITEM_TYPE_PTI, ulEsmBuffIndex);
if (pstPtiBuffItem == VOS_NULL_PTR)
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgWaitPtiInvaidExp:WARN:Get buffer item failed!");
return ;
}
NAS_ESM_INFO_LOG2("NAS_ESM_ProcTimerMsgWaitPtiInvaidExp:NORM:PTI is deleted from Esm Buffer!",
pstPtiBuffItem->ucPti, ulEsmBuffIndex);
/* 清除缓存记录 */
NAS_ESM_ClearEsmBuffItem(NAS_ESM_BUFF_ITEM_TYPE_PTI, ulEsmBuffIndex);
}
VOS_VOID NAS_ESM_OmInfoIndMsgProc(VOS_VOID *pRcvMsg)
{
OM_ESM_INFO_REPORT_REQ_STRU *pEsmOmInfoReqMsg;
OM_ESM_INFO_REPORT_CNF_STRU *pEsmOmInfoCnfMsg;
NAS_ESM_NORM_LOG("NAS_ESM_OMInfoIndMsgProc: enter !!");
TLPS_PRINT2LAYER_INFO(NAS_ESM_OmInfoIndMsgProc_ENUM, LNAS_ENTRY);
pEsmOmInfoReqMsg = (OM_ESM_INFO_REPORT_REQ_STRU *)pRcvMsg;
if (OM_ESM_INFO_REPORT_OPEN == pEsmOmInfoReqMsg->enRptCtrl)
{
g_NasEsmOmInfoIndFlag = OM_ESM_REPORT_INFO_OPEN;
}
else
{
g_NasEsmOmInfoIndFlag = OM_ESM_REPORT_INFO_CLOSE;
}
/* 将保存上报信息的全局变量清除 */
NAS_ESM_MEM_SET_S( g_stEsmOmInfo,
sizeof(OM_ESM_STATE_INFO_STRU)*APP_ESM_MAX_EPSB_NUM,
NAS_ESM_NULL,
sizeof(OM_ESM_STATE_INFO_STRU)*APP_ESM_MAX_EPSB_NUM);
/* 为消息分配地址 */
pEsmOmInfoCnfMsg = (VOS_VOID *)NAS_ESM_ALLOC_MSG(sizeof(OM_ESM_INFO_REPORT_CNF_STRU));
if(VOS_NULL_PTR == pEsmOmInfoCnfMsg)
{
NAS_ESM_WARN_LOG("NAS_ESM_AppInfoIndMsgProc: NAS_LMM_ALLOC_MSG alloc NULL_PTR !!");
TLPS_PRINT2LAYER_WARNING(NAS_ESM_OmInfoIndMsgProc_ENUM, LNAS_EMM_ALLOC_FAIL);
return;
}
/*清空*/
NAS_ESM_MEM_SET_S( NAS_ESM_GET_MSG_ENTITY(pEsmOmInfoCnfMsg),
NAS_ESM_GET_MSG_LENGTH(pEsmOmInfoCnfMsg),
0,
NAS_ESM_GET_MSG_LENGTH(pEsmOmInfoCnfMsg));
/* 打包消息头 */
pEsmOmInfoCnfMsg->ulMsgId = ID_OM_ESM_INFO_REPORT_CNF;
pEsmOmInfoCnfMsg->ulSenderCpuId = pEsmOmInfoReqMsg->ulReceiverCpuId;
pEsmOmInfoCnfMsg->ulSenderPid = pEsmOmInfoReqMsg->ulReceiverPid;
pEsmOmInfoCnfMsg->ulReceiverPid = pEsmOmInfoReqMsg->ulSenderPid;
pEsmOmInfoCnfMsg->ulReceiverCpuId = pEsmOmInfoReqMsg->ulSenderCpuId;
/* OM融合，所有透传消息CNF和REQ中的usOriginalId和usTerminalId必须对应，不能颠倒 */
pEsmOmInfoCnfMsg->usOriginalId = pEsmOmInfoReqMsg->usOriginalId;
pEsmOmInfoCnfMsg->usTerminalId = pEsmOmInfoReqMsg->usTerminalId;
pEsmOmInfoCnfMsg->ulSN = pEsmOmInfoReqMsg->ulSN;
/*设置OPID*/
pEsmOmInfoCnfMsg->ulOpId = pEsmOmInfoReqMsg->ulOpId;
pEsmOmInfoCnfMsg->ulRslt = APP_SUCCESS;
/* 发送消息 */
NAS_ESM_SND_MSG(pEsmOmInfoCnfMsg);
return;
}
VOS_VOID NAS_ESM_TaskEntry(MsgBlock * pMsg)
{
/* 定义消息头指针*/
PS_MSG_HEADER_STRU *pHeader = VOS_NULL_PTR;
/* 判断入口参数是否合法*/
if( VOS_NULL_PTR == pMsg)
{
NAS_ESM_WARN_LOG("NAS_ESM_TaskEntry:ERROR: No Msg!");
return;
}
/* 获取消息头指针*/
pHeader = (PS_MSG_HEADER_STRU *) pMsg;
NAS_ESM_PrintEsmRevMsg(pHeader,NAS_COMM_GET_ESM_PRINT_BUF());
switch(pHeader->ulSenderPid)
{
/*如果是EMM消息，调用EMM处理函数*/
case PS_PID_MM:
NAS_ESM_EmmMsgDistr(pMsg);
break;
/*如果是RABM消息，调用RABM处理函数*/
case PS_PID_RABM:
NAS_ESM_RabmMsgDistr(pMsg);
break;
/*如果是APP消息，调用APP处理函数*/
case PS_PID_APP:
NAS_ESM_AppMsgDistr(pMsg);
break;
case WUEPS_PID_TAF:
NAS_ESM_SmMsgDistr(pMsg);
break;
case MSP_PID_DIAG_APP_AGENT:
(VOS_VOID)LTE_MsgHook((VOS_VOID*)pMsg);
NAS_ESM_OmMsgDistr(pMsg);
break;
/*如果是Timer消息，调用Timer溢出处理函数*/
case VOS_PID_TIMER:
NAS_ESM_TimerMsgDistr(pMsg);
break;
/* xiongxianghui00253310 add fot errlog 20131212 begin */
/*如果是OM消息，调用OM处理函数*/
#if (FEATURE_PTM == FEATURE_ON)
case ACPU_PID_OM:
NAS_ESM_OmMsgDistrForAcpuPidOm(pMsg);
break;
#endif
/* xiongxianghui00253310 add fot errlog 20131212 end */
/*发送对象错误，报警*/
default:
NAS_ESM_WARN_LOG("NAS_ESM_TaskEntry:NORM: Error SenderPid!");
break;
}
if (OM_ESM_REPORT_INFO_OPEN == g_NasEsmOmInfoIndFlag)
{
if (NAS_ESM_FAILURE == NAS_ESM_CompareEsmInfo())
{
/* 通过DIAG上报 */
#if (VOS_WIN32 != VOS_OS_VER)
(VOS_VOID)DIAG_ReportCommand(DIAG_CMD_ESM_APP_ESM_INFO_IND, (sizeof(OM_ESM_STATE_INFO_STRU))*OM_ESM_MAX_EPSB_NUM, (VOS_VOID*)g_stEsmOmInfo);
#endif
}
}
NAS_ESM_DtJudgeifNeedRpt();
/* xiongxianghui00253310 modify for ftmerrlog begin */
#if (FEATURE_PTM == FEATURE_ON)
NAS_ESM_OmInfoIndProc();
#endif
/* xiongxianghui00253310 modify for ftmerrlog end */
}
VOS_VOID NAS_ESM_ProcTimerMsgT3481Exp(const VOS_VOID * pMsg)
{
VOS_UINT32 ulStateTblIndex = NAS_ESM_NULL;
VOS_UINT32 ulErrorCode = APP_ERR_TIME_OUT;
VOS_UINT32 ulActCidNum = NAS_ESM_NULL;
NAS_ESM_TIMER_STRU *pTimer3481 = VOS_NULL_PTR;
NAS_ESM_STATE_INFO_STRU *pstStateAddr = VOS_NULL_PTR;
/*打印进入该函数*/
NAS_ESM_NORM_LOG("NAS_ESM_ProcTimerMsgT3481Exp is entered.");
/*获取消息中包含的状态表StateTblIndex*/
ulStateTblIndex = PS_GET_REL_TIMER_NAME(pMsg);
pstStateAddr = NAS_ESM_GetStateTblAddr(ulStateTblIndex);
if (NAS_ESM_L_MODE_STATUS_NORMAL != NAS_ESM_GetLModeStatus())
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgT3481Exp: L mode is already suspended!");
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
return ;
}
/*根据消息对应的ulStateTblIndex,获取相关联的定时器*/
pTimer3481 = NAS_ESM_GetStateTblTimer(ulStateTblIndex);
/*超时次数++*/
pTimer3481->ucExpireTimes++;
/*如果当前定时器超时次数小于NAS_ESM_MAX_TIMER_EXPIRE_TIMES次*/
if(pTimer3481->ucExpireTimes < TI_NAS_ESM_T3481_TIMER_MAX_EXP_NUM)
{
/*调用函数:SM向MM发送消息:NAS_ESMCN_BEARER_RES_MOD_REQ*/
NAS_ESM_SndEsmEmmDataReqMsg(pstStateAddr->stNwMsgRecord.ulOpId,
pstStateAddr->stNwMsgRecord.ucIsEmcPdnReq,
pstStateAddr->stNwMsgRecord.ulMsgLength,
pstStateAddr->stNwMsgRecord.aucMsgBuff);
/*重新启动定时器*/
NAS_ESM_TimerStart(ulStateTblIndex,TI_NAS_ESM_T3481);
/*上报空口消息*/
NAS_ESM_SndAirMsgReportInd(pstStateAddr->stNwMsgRecord.aucMsgBuff,
pstStateAddr->stNwMsgRecord.ulMsgLength,
NAS_ESM_AIR_MSG_DIR_ENUM_UP,
ESM_BEARER_RESOUCE_MOD_REQ);
return;
}
if(ID_APP_ESM_PDP_SETUP_REQ == NAS_ESM_GetStateTblAppMsgType(ulStateTblIndex) )
{
/*调用函数:发送确认消息通知APP，本次承载资源分配过程失败*/
NAS_ESM_SndEsmAppSdfSetupCnfFailMsg(ulStateTblIndex, ulErrorCode);
}
else if(ID_APP_ESM_PDP_RELEASE_REQ == NAS_ESM_GetStateTblAppMsgType(ulStateTblIndex) )
{
ulActCidNum = NAS_ESM_GetBearerLinkedCidNum(pstStateAddr->ulEpsbId);
/* 如果只对应一个激活的Cid,说明App要释放所有的SDF */
if (ulActCidNum == NAS_ESM_BEARER_ACT_CID_NUM_ONE)
{
/* 本地释放此承载 */
NAS_ESM_DeactBearerAndInformApp(pstStateAddr->ulEpsbId);
/*通知EMM当前承载状态信息，发送ID_EMM_ESM_BEARER_STATUS_REQ*/
NAS_ESM_SndEsmEmmBearerStatusReqMsg(EMM_ESM_BEARER_CNTXT_MOD_LOCAL);
}
else
{
NAS_ESM_SndEsmAppSdfModCnfFailMsg(ulStateTblIndex, ulErrorCode);
}
}
else
{
NAS_ESM_SndEsmAppSdfModCnfFailMsg(ulStateTblIndex, ulErrorCode);
}
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
}
VOS_VOID NAS_ESM_ProcTimerMsgT3480Exp
(
const VOS_VOID * pMsg
)
{
VOS_UINT32 ulStateTblIndex = NAS_ESM_NULL;
VOS_UINT32 ulErrorCode = APP_ERR_TIME_OUT;
NAS_ESM_TIMER_STRU *pTimer3480 = VOS_NULL_PTR;
NAS_ESM_STATE_INFO_STRU *pstStateAddr = VOS_NULL_PTR;
/*打印进入该函数*/
NAS_ESM_NORM_LOG("NAS_ESM_ProcTimerMsgT3480Exp is entered.");
/*获取消息中包含的状态表StateTblIndex*/
ulStateTblIndex = PS_GET_REL_TIMER_NAME(pMsg);
pstStateAddr = NAS_ESM_GetStateTblAddr(ulStateTblIndex);
if (NAS_ESM_L_MODE_STATUS_NORMAL != NAS_ESM_GetLModeStatus())
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgT3480Exp: L mode is already suspended!");
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
return ;
}
/*根据消息对应的ulStateTblIndex,获取相关联的定时器*/
pTimer3480 = NAS_ESM_GetStateTblTimer(ulStateTblIndex);
/*超时次数++*/
pTimer3480->ucExpireTimes++;
/*如果当前定时器超时次数小于NAS_ESM_MAX_TIMER_EXPIRE_TIMES次*/
if(pTimer3480->ucExpireTimes < TI_NAS_ESM_T3480_TIMER_MAX_EXP_NUM)
{
/*调用函数:SM向MM发送消息:NAS_ESMCN_BEARER_RES_MOD_REQ*/
NAS_ESM_SndEsmEmmDataReqMsg(pstStateAddr->stNwMsgRecord.ulOpId,
pstStateAddr->stNwMsgRecord.ucIsEmcPdnReq,
pstStateAddr->stNwMsgRecord.ulMsgLength,
pstStateAddr->stNwMsgRecord.aucMsgBuff);
/*重新启动定时器*/
NAS_ESM_TimerStart(ulStateTblIndex,TI_NAS_ESM_T3480);
/*上报空口消息*/
NAS_ESM_SndAirMsgReportInd(pstStateAddr->stNwMsgRecord.aucMsgBuff,
pstStateAddr->stNwMsgRecord.ulMsgLength,
NAS_ESM_AIR_MSG_DIR_ENUM_UP,
ESM_BEARER_RESOUCE_ALLOC_REQ);
return;
}
if(ID_APP_ESM_PDP_SETUP_REQ == NAS_ESM_GetStateTblAppMsgType(ulStateTblIndex) )
{
/*调用函数:发送确认消息通知APP，本次承载资源分配过程失败*/
NAS_ESM_SndEsmAppSdfSetupCnfFailMsg(ulStateTblIndex, ulErrorCode);
}
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
}
VOS_VOID NAS_ESM_ProcTimerMsgT3492Exp(const VOS_VOID * pMsg)
{
VOS_UINT32 ulStateTblIndex = NAS_ESM_NULL;
NAS_ESM_TIMER_STRU *pTimer3492 = VOS_NULL_PTR;
NAS_ESM_STATE_INFO_STRU *pstStateAddr = VOS_NULL_PTR;
/*打印进入该函数*/
NAS_ESM_NORM_LOG("NAS_ESM_ProcTimerMsgT3492Exp is entered.");
/*获取消息中包含的状态表StateTblIndex*/
ulStateTblIndex = PS_GET_REL_TIMER_NAME(pMsg);
pstStateAddr = NAS_ESM_GetStateTblAddr(ulStateTblIndex);
if (NAS_ESM_L_MODE_STATUS_NORMAL != NAS_ESM_GetLModeStatus())
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgT3492Exp: L mode is already suspended!");
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
return ;
}
/*根据消息对应的ulStateTblIndex,获取相关联的定时器*/
pTimer3492 = NAS_ESM_GetStateTblTimer(ulStateTblIndex);
/*超时次数++*/
pTimer3492->ucExpireTimes++;
/*如果当前定时器超时次数小于NAS_ESM_MAX_TIMER_EXPIRE_TIMES次*/
if(pTimer3492->ucExpireTimes < TI_NAS_ESM_T3492_TIMER_MAX_EXP_NUM)
{
/*调用函数:SM向MM发送消息:NAS_ESMCN_PDN_DISCONNECT_REQ*/
NAS_ESM_SndEsmEmmDataReqMsg(pstStateAddr->stNwMsgRecord.ulOpId,
pstStateAddr->stNwMsgRecord.ucIsEmcPdnReq,
pstStateAddr->stNwMsgRecord.ulMsgLength,
pstStateAddr->stNwMsgRecord.aucMsgBuff);
/*重新启动定时器*/
NAS_ESM_TimerStart(ulStateTblIndex,TI_NAS_ESM_T3492);
/*上报空口消息*/
NAS_ESM_SndAirMsgReportInd(pstStateAddr->stNwMsgRecord.aucMsgBuff,
pstStateAddr->stNwMsgRecord.ulMsgLength,
NAS_ESM_AIR_MSG_DIR_ENUM_UP,
ESM_PDN_DISCONNECT_REQ);
return;
}
else
{
NAS_ESM_WARN_LOG("NAS_ESM_DefltAttingBInactPPendMsgT3492Exp:WARNING:ExpireTimes exceed!");
/*本地释放缺省承载资源,向APP回复释放成功消息*/
NAS_ESM_DeactBearerAndInformApp(pstStateAddr->ulEpsbId);
/*通知EMM当前承载状态信息，发送ID_EMM_ESM_BEARER_STATUS_REQ*/
NAS_ESM_SndEsmEmmBearerStatusReqMsg(EMM_ESM_BEARER_CNTXT_MOD_LOCAL);
}
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
}
VOS_VOID NAS_ESM_ProcTimerMsgT3482Exp(const VOS_VOID * pMsg)
{
VOS_UINT32 ulStateTblIndex = NAS_ESM_NULL;
NAS_ESM_TIMER_STRU *pTimer3482 = VOS_NULL_PTR;
VOS_UINT32 ulErrorCode = APP_ERR_TIME_OUT;
NAS_ESM_STATE_INFO_STRU *pstStateAddr = VOS_NULL_PTR;
/*打印进入该函数*/
NAS_ESM_NORM_LOG("NAS_ESM_ProcTimerMsgT3482Exp is entered.");
/*获取消息中包含的状态表StateTblIndex*/
ulStateTblIndex = PS_GET_REL_TIMER_NAME(pMsg);
pstStateAddr = NAS_ESM_GetStateTblAddr(ulStateTblIndex);
if (NAS_ESM_L_MODE_STATUS_NORMAL != NAS_ESM_GetLModeStatus())
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgT3482Exp: L mode is already suspended!");
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
return ;
}
#if (FEATURE_PTM == FEATURE_ON)
NAS_ESM_PdnConFailRecord(VOS_NULL_PTR, ESM_OM_ERRLOG_TIMEOUT_T3482);
#endif
/*根据消息对应的ulStateTblIndex,获取相关联的定时器T3482*/
pTimer3482 = NAS_ESM_GetStateTblTimer(ulStateTblIndex);
/*超时次数++*/
pTimer3482->ucExpireTimes++;
/*如果当前定时器超时次数小于NAS_ESM_MAX_TIMER_EXPIRE_TIMES次*/
if(pTimer3482->ucExpireTimes < TI_NAS_ESM_T3482_TIMER_MAX_EXP_NUM)
{
/*调用函数:SM向MM发送消息:NAS_ESMCN_MSG_TYPE_PDN_CONNECT_REQ*/
NAS_ESM_SndEsmEmmDataReqMsg(pstStateAddr->stNwMsgRecord.ulOpId,
pstStateAddr->stNwMsgRecord.ucIsEmcPdnReq,
pstStateAddr->stNwMsgRecord.ulMsgLength,
pstStateAddr->stNwMsgRecord.aucMsgBuff);
/*重新启动定时器*/
NAS_ESM_TimerStart(ulStateTblIndex,TI_NAS_ESM_T3482);
/*上报空口消息*/
NAS_ESM_SndAirMsgReportInd(pstStateAddr->stNwMsgRecord.aucMsgBuff,
pstStateAddr->stNwMsgRecord.ulMsgLength,
NAS_ESM_AIR_MSG_DIR_ENUM_UP,
ESM_PDN_CONNECT_REQ);
return;
}
else if(ID_APP_ESM_NDISCONN_REQ == NAS_ESM_GetStateTblAppMsgType(ulStateTblIndex) )
{
/*调用函数:发送确认消息通知APP，本次承载资源分配过程失败*/
NAS_ESM_LOG1("NAS_ESM_ProcTimerMsgT3482Exp:ERROR =", ulErrorCode);
NAS_ESM_SndEsmAppNdisConnCnfFailMsg(ulStateTblIndex, ulErrorCode);
}
else
{
NAS_ESM_WARN_LOG("NAS_ESM_ProcTimerMsgT3482Exp:WARNING:ExpireTimes exceed!");
/*向APP回复消息*/
NAS_ESM_SndEsmAppSdfSetupCnfFailMsg(ulStateTblIndex, \
APP_ERR_TIME_OUT);
}
/*释放状态表资源*/
NAS_ESM_RelStateTblResource(ulStateTblIndex);
}
