VOS_VOID NAS_ESM_ProcTimerMsgDeferRelNonEmcExp(const VOS_VOID * pMsg)
{
NAS_ESM_INFO_LOG("NAS_ESM_ProcTimerMsgDeferRelNonEmcExp: enter");
(VOS_VOID)pMsg;
if (PS_TRUE == NAS_ESM_HasEstingEmergencyPdn())
{
NAS_ESM_INFO_LOG("NAS_ESM_ProcTimerMsgDeferRelNonEmcExp: esting emergency PDN");
/*如果紧急承载还未建立成功，重新启动延迟定时器*/
NAS_ESM_TimerStart(0, TI_NAS_ESM_REL_NON_EMC_BEARER);
}
else if (PS_TRUE == NAS_ESM_HasExistedEmergencyPdn())
{
NAS_ESM_INFO_LOG("NAS_ESM_ProcTimerMsgDeferRelNonEmcExp: existed emergency PDN");
/*如果紧急承载建立成功，则释放所有非紧急承载*/
NAS_ESM_DeactAllNonEmcPdn();
}
else
{
/*如果紧急承载建立失败，不做处理*/
NAS_ESM_INFO_LOG("NAS_ESM_ProcTimerMsgDeferRelNonEmcExp: no emergency PDN");
}
return;
}
VOS_VOID NAS_ESM_UpdateEsmDatabaseInfo(VOS_VOID)
{
NAS_ESM_INFO_LOG("NAS_ESM_UpdateEsmDatabaseInfo.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_UpdateEsmDatabaseInfo_ENUM, LNAS_ENTRY);
NAS_ESM_GetEsmInfoAddr()->ucEsmCause = NAS_ESM_GetFtmInfoEsmCause();
}
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;
}
/*lint -e961*/
VOS_VOID NAS_ESM_SndEsmOmTpCmdCnfMsg(const VOS_UINT8 *pucData,
VOS_UINT32 ulLength)
{
PS_OM_TRANSPARENT_CMD_CNF_STRU *pPsOmTpCmdCnf = VOS_NULL_PTR;
VOS_UINT16 usOriginalId = 0;
VOS_UINT16 usTerminalId = 0;
/*打印进入该函数*/
NAS_ESM_INFO_LOG("NAS_ESM_SndEsmOmTpCmdCnfMsg is entered.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_SndEsmOmTpCmdCnfMsg_ENUM, LNAS_ENTRY);
/*根据空口消息的长度分配空间，处于消息头外*/
if(ulLength > ESM_MIN_SND_MSG_LEN)
{
pPsOmTpCmdCnf = (VOS_VOID*)NAS_ESM_ALLOC_MSG(sizeof(PS_OM_TRANSPARENT_CMD_CNF_STRU) + (ulLength - ESM_MIN_SND_MSG_LEN));
}
else/*如果长度小于ESM_MIN_SND_MSG_LEN，分配的空间等于ESM_MIN_SND_MSG_LEN*/
{
pPsOmTpCmdCnf = (VOS_VOID*)NAS_ESM_ALLOC_MSG(sizeof(PS_OM_TRANSPARENT_CMD_CNF_STRU));
}
/*检测是否分配成功*/
if (VOS_NULL_PTR == pPsOmTpCmdCnf)
{
/*打印异常信息*/
NAS_ESM_ERR_LOG("NAS_ESM_SndEsmOmTpCmdCnfMsg:ERROR:Alloc Msg fail!");
TLPS_PRINT2LAYER_ERROR(NAS_ESM_SndEsmOmTpCmdCnfMsg_ENUM, 1);
return ;
}
/*清空*/
NAS_ESM_MEM_SET_S( NAS_ESM_GET_MSG_ENTITY(pPsOmTpCmdCnf),
NAS_ESM_GET_MSG_LENGTH(pPsOmTpCmdCnf),
0,
NAS_ESM_GET_MSG_LENGTH(pPsOmTpCmdCnf));
/*将空口消息存放到EMM_ESM_DATA_REQ_STRU结构中*/
/*lint -e669*/
NAS_ESM_MEM_CPY_S(pPsOmTpCmdCnf->aucTransCmdCnf, ulLength, pucData, ulLength);
/*lint +e669*/
/*分配本次过程APP_MSG_HEADER*/
NAS_ESM_AssignMidHeader(&usOriginalId,&usTerminalId);
/*填写消息头*/
NAS_ESM_WRITE_APP_MSG_HEAD(pPsOmTpCmdCnf,OM_PS_TRANSPARENT_CMD_CNF,\
usOriginalId,usTerminalId,0);
/*调用消息发送函数 */
NAS_ESM_SND_MSG(pPsOmTpCmdCnf);
}
VOS_VOID NAS_ESM_SendOmFtmMsg(VOS_VOID)
{
LNAS_OM_FTM_REPROT_IND_STRU *pFtmMsg;
NAS_ESM_INFO_LOG("NAS_ESM_SendOmFtmMsg.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_SendOmFtmMsg_ENUM, LNAS_ENTRY);
/* 若工程模式关闭，则不发送 */
if(NAS_ESM_FTM_ACTION_FLAG_OPEN != NAS_ESM_GetFtmInfoActionFlag())
{
NAS_ESM_INFO_LOG1("NAS_ESM_SendOmFtmMsg: ActionFlag = ", NAS_ESM_GetFtmInfoActionFlag());
TLPS_PRINT2LAYER_INFO1(NAS_ESM_SendOmFtmMsg_ENUM, 1, NAS_ESM_GetFtmInfoActionFlag());
return;
}
/*分配空间并检验分配是否成功*/
pFtmMsg = (VOS_VOID*)NAS_ESM_ALLOC_MSG(sizeof(LNAS_OM_FTM_REPROT_IND_STRU));
if ( VOS_NULL_PTR == pFtmMsg )
{
/*打印异常信息*/
NAS_ESM_ERR_LOG("NAS_ESM_SendOmFtmMsg:ERROR:Alloc Msg fail!");
TLPS_PRINT2LAYER_ERROR(NAS_ESM_SendOmFtmMsg_ENUM, LNAS_EMM_ALLOC_FAIL);
return ;
}
/*构造ID_EMM_ESM_PDN_CON_IND消息*/
/*填充消息头*/
NAS_ESM_COMP_OM_MSG_HEADER( pFtmMsg,
(sizeof(LNAS_OM_FTM_REPROT_IND_STRU)-
NAS_ESM_LEN_VOS_MSG_HEADER));
/*填充消息ID*/
pFtmMsg->ulMsgName = ID_OM_FTM_REPROT_IND;
/*填充消息内容*/
pFtmMsg->ulMsgType = OM_ERR_LOG_MSG_FTM_REPORT;
pFtmMsg->ulMsgSN = (NAS_ESM_GetFtmInfoMsgSN());
NAS_ESM_GetFtmInfoMsgSN()++;
pFtmMsg->ulRptlen = sizeof(LNAS_OM_FTM_REPROT_CONTENT_STRU);
pFtmMsg->stLnasFtmContent.ulMsgModuleID = OM_ERR_LOG_MOUDLE_ID_ESM;
pFtmMsg->stLnasFtmContent.usModemId = 0;
pFtmMsg->stLnasFtmContent.usProjectID = 0;
pFtmMsg->stLnasFtmContent.ulLength = sizeof(LNAS_ESM_FTM_INFO_STRU);
pFtmMsg->stLnasFtmContent.u.stEsmFtmInfo.ucEsmCause = g_astEsmInfo.ucEsmCause;
/*向OM发送消息*/
NAS_ESM_SND_MSG( pFtmMsg);
return;
}
VOS_UINT32 NAS_ESM_CompareEsmDatabaseInfo(VOS_VOID)
{
NAS_ESM_INFO_LOG("NAS_ESM_CompareEsmDatabaseInfo.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_CompareEsmDatabaseInfo_ENUM, LNAS_ENTRY);
if(NAS_ESM_GetFtmInfoEsmCause() != NAS_ESM_GetEsmInfoAddr()->ucEsmCause)
{
return NAS_ESM_SUCCESS;
}
return NAS_ESM_FAILURE;
}
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_VOID NAS_ESM_ReadInitInfoFromNv()
{
VOS_UINT32 ulCid = NAS_ESM_NULL;
NAS_ESM_INFO_LOG("NAS_ESM_ReadInitInfoFromNv is entered.");
/* 从NV中读取数据流的静态信息 */
for(ulCid = 0; ulCid < NAS_ESM_MAX_EPSB_NUM; ulCid++)
{
NAS_ESM_ReadSdfParaFromNV(ulCid);
}
/* 从NV中读取承载管理方式 */
NAS_ESM_ReadPdpManInfoFromNv();
}
VOS_VOID NAS_ESM_ClearEsmResoureWhenEstingEmcPdn(VOS_VOID)
{
VOS_UINT32 ulCnt = 0;
NAS_ESM_INFO_LOG("NAS_ESM_ClearEsmResoureWhenEstingEmcPdn: enter");
/*设置ESM状态为正在注册*/
NAS_ESM_SetEmmStatus(NAS_ESM_PS_REGISTER_STATUS_ATTACHING);
/* 如果支持双APN，则停止对应定时器，并设置注册承载无效 */
if (NAS_ESM_OP_TRUE == NAS_ESM_AttachBearerReestEnable())
{
NAS_ESM_TimerStop(0, TI_NAS_ESM_ATTACH_BEARER_REEST);
NAS_ESM_SetAttachBearerId(NAS_ESM_UNASSIGNED_EPSB_ID);
}
/* 本地去激活除紧急之外的所有承载 */
for( ulCnt = NAS_ESM_MIN_EPSB_ID; ulCnt <= NAS_ESM_MAX_EPSB_ID; ulCnt++ )
{
/*
* 如果是激活的非紧急默认承载，则去激活；
* 如果是非激活的默认承载或紧急的默认承载，不需要去激活，跳过
* 如果是专有承载，则在NAS_ESM_DeactBearerAndInformApp中进行去激活
*/
if ((NAS_ESM_BEARER_TYPE_DEFAULT == NAS_ESM_GetBearCntxtType(ulCnt)) &&
(NAS_ESM_BEARER_STATE_ACTIVE == NAS_ESM_GetBearCntxtState(ulCnt)))
{
NAS_ESM_DeactBearerAndInformApp(ulCnt);
}
}
/* 初始化PDN连接的个数 */
NAS_ESM_SetCurPdnNum(NAS_ESM_NULL);
/* 通知RABM清除资源 */
NAS_ESM_SndEsmRabmRelIndMsg();
/*清除动态表，紧急相关除外*/
NAS_ESM_ClearStateTable(APP_ERR_SM_NON_EMERGENCY_NOT_ALLOWED, PS_TRUE);
/* 初始化发送空口消息的结构体 */
NAS_ESM_ClearEsmSndNwMsgAddr();
/* 清除ESM缓存区 */
NAS_ESM_ClearEsmBuff();
}
VOS_VOID NAS_ESM_FtmInfoInit(VOS_VOID)
{
NAS_ESM_INFO_LOG("NAS_ESM_FtmInfoInit.");
TLPS_PRINT2LAYER_INFO(NAS_ESM_FtmInfoInit_ENUM, LNAS_ENTRY);
NAS_ESM_MEM_SET_S( NAS_ESM_GetFtmInfoManageAddr(),
sizeof(ESM_FTM_INFO_MANAGE_STRU),
0,
sizeof(ESM_FTM_INFO_MANAGE_STRU));
NAS_ESM_MEM_SET_S( NAS_ESM_GetEsmInfoAddr(),
sizeof(ESM_DATABASE_INFO_STRU),
0,
sizeof(ESM_DATABASE_INFO_STRU));
NAS_ESM_GetFtmInfoActionFlag() = NAS_ESM_FTM_ACTION_FLAG_CLOSE;
return;
}
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;
}
}
VOS_VOID NAS_ESM_ClearEsmResource( VOS_VOID )
{
VOS_UINT32 ulCnt = NAS_ESM_NULL;
/*打印进入该函数*/
NAS_ESM_INFO_LOG("NAS_ESM_ClearEsmResource is entered.");
/*根据消息记录通知APP*/
NAS_ESM_ClearStateTable(APP_ERR_SM_DETACHED, PS_FALSE);
/* 设置EMM的状态为未注册 */
NAS_ESM_SetEmmStatus(NAS_ESM_PS_REGISTER_STATUS_DETACHED);
/* 如果支持双APN，则停止对应定时器，并设置注册承载无效 */
if (NAS_ESM_OP_TRUE == NAS_ESM_AttachBearerReestEnable())
{
NAS_ESM_TimerStop(0, TI_NAS_ESM_ATTACH_BEARER_REEST);
NAS_ESM_SetAttachBearerId(NAS_ESM_UNASSIGNED_EPSB_ID);
}
/* 设置已激活的承载数目为零 */
NAS_ESM_SetCurMaxOpIdValue(NAS_ESM_MIN_OPID_VALUE);
#ifdef PS_ITT_PC_TEST_NAS
/*NAS ST场景下，由于现有用例在注册时使用了PTI值为2，所以PTI初始化为1，调用PTI分配函数，会从2开始使用*/
NAS_ESM_SetCurMaxPTIValue(NAS_ESM_PTI_MIN_VALUE);
#else
/*PTI初始化为0，注册时，调用PTI分配函数，会从1开始使用*/
/*lint -e778*/
NAS_ESM_SetCurMaxPTIValue(NAS_ESM_PTI_MIN_VALUE-1);
/*lint +e778*/
/* CID0在PS融合后比较特殊，在ESM维护的内容与NV的内容会存在不一致, 需将CID0初始化为专有类型 */
NAS_ESM_ClearCid0StaticInfo();
#endif
NAS_ESM_SetCurMaxGwAuthIdVaule(NAS_ESM_GWAUTHID_MIN_VALUE);
/* 初始化CID 21~31 关联静态信息 */
NAS_ESM_ClearNwCtrlSdfPara();
/* 通知APP和SM 激活承载被释放，初始化承载信息 */
for( ulCnt = NAS_ESM_MIN_EPSB_ID; ulCnt <= NAS_ESM_MAX_EPSB_ID; ulCnt++ )
{
if (NAS_ESM_BEARER_STATE_ACTIVE != NAS_ESM_GetBearCntxtState(ulCnt))
{
/* 初始化承载信息 */
NAS_ESM_InitEpsbCntxtInfo(ulCnt);
continue;
}
#ifndef PS_ITT_PC_TEST_NAS
/* 通知APP 激活承载被释放 */
NAS_ESM_InformAppBearerRel(ulCnt);
/* 通知SM 激活承载被释放 */
NAS_ESM_SndSmEspBearerDeactIndMsg(ulCnt);
#endif
/* 初始化承载信息 */
NAS_ESM_InitEpsbCntxtInfo(ulCnt);
}
/* 初始化业务流的动态信息 */
for( ulCnt = 0; ulCnt < NAS_ESM_MAX_CID_NUM; ulCnt++ )
{
NAS_ESM_MEM_SET(NAS_ESM_GetSdfCntxtInfo(ulCnt),
NAS_ESM_NULL,
sizeof(NAS_ESM_SDF_CNTXT_INFO_STRU));
}
/* 初始化PDN连接的个数 */
NAS_ESM_SetCurPdnNum(NAS_ESM_NULL);
/* 初始化发送空口消息的结构体 */
NAS_ESM_ClearEsmSndNwMsgAddr();
/* 清除ESM缓存区 */
NAS_ESM_ClearEsmBuff();
}
VOS_VOID NAS_ESM_Init(VOS_VOID)
{
VOS_UINT32 ulCnt = NAS_ESM_NULL;
/*打印进入该函数*/
NAS_ESM_INFO_LOG("NAS_SM START INIT...");
/*初始化SM实体*/
NAS_ESM_MEM_SET((VOS_VOID*)NAS_ESM_Entity(),NAS_ESM_NULL,sizeof(NAS_ESM_ENTITY_STRU));
/*设置EMM的状态为未注册*/
NAS_ESM_SetEmmStatus(NAS_ESM_PS_REGISTER_STATUS_DETACHED);
/*设置L MODE的状态为SUSPENDED*/
NAS_ESM_SetLModeStatus(NAS_ESM_L_MODE_STATUS_SUSPENDED);
/*设置已激活的承载数目为零*/
NAS_ESM_SetCurMaxOpIdValue(NAS_ESM_MIN_OPID_VALUE);
#ifdef PS_ITT_PC_TEST_NAS
/*NAS ST场景下，由于现有用例在注册时使用了PTI值为2，所以PTI初始化为1，调用PTI分配函数，会从2开始使用*/
NAS_ESM_SetCurMaxPTIValue(NAS_ESM_PTI_MIN_VALUE);
#else
/*PTI初始化为0，注册时，调用PTI分配函数，会从1开始使用*/
/*lint -e778*/
NAS_ESM_SetCurMaxPTIValue(NAS_ESM_PTI_MIN_VALUE-1);
/*lint +e778*/
#endif
NAS_ESM_SetCurMaxGwAuthIdVaule(NAS_ESM_GWAUTHID_MIN_VALUE);
/*初始化承载参数*/
NAS_ESM_BearerCntxtParaInit();
/*初始化承载管理方式*/
NAS_ESM_BearerManageInfoInit(NAS_ESM_GetBearerManageInfoAddr());
/*初始化状态表信息*/
for( ulCnt = 0; ulCnt < NAS_ESM_MAX_STATETBL_NUM; ulCnt++ )
{
NAS_ESM_RelStateTblResource(ulCnt);
}
/*初始化承载信息*/
for( ulCnt = NAS_ESM_MIN_EPSB_ID; ulCnt <= NAS_ESM_MAX_EPSB_ID; ulCnt++ )
{
NAS_ESM_InitEpsbCntxtInfo(ulCnt);
NAS_ESM_MEM_SET(&(g_stEsmOmInfo[ulCnt - NAS_ESM_MIN_EPSB_ID]),
NAS_ESM_NULL,
sizeof(OM_ESM_STATE_INFO_STRU));
}
/* 初始化ESM缓存区 */
NAS_COMM_InitBuff(NAS_COMM_BUFF_TYPE_ESM);
/* 初始化注册承载相关内容 */
NAS_ESM_InitAttachBearerReestInfo();
/* ESM软调初始化 */
NAS_ESM_DebugInit();
/* 初始化延迟释放非紧急PDN连接定时器 */
NAS_ESM_Entity()->stDeferRelNonEmcTimerInfo.enPara = TI_NAS_ESM_REL_NON_EMC_BEARER;
/* xiongxianghui00253310 modify for ftmerrlog begin */
#if (FEATURE_PTM == FEATURE_ON)
NAS_ESM_FtmInfoInit();
NAS_ESM_ErrlogInfoInit();
#endif
/* xiongxianghui00253310 modify for ftmerrlog end */
}
