VOS_UINT32 NAS_EMM_PreProcMsgT3423Exp(MsgBlock * pMsg )
{
(void)pMsg;
NAS_EMM_PUBU_LOG_INFO("NAS_EMM_PreProcMsgT3423Exp: GET MML PS BEARER INFO:");
NAS_COMM_PrintArray( NAS_COMM_GET_MM_PRINT_BUF(),
(VOS_UINT8*)NAS_MML_GetPsBearerCtx(),
sizeof(NAS_MML_PS_BEARER_CONTEXT_STRU)
*EMM_ESM_MAX_EPS_BEARER_NUM);
/*通知GU模t3423超时*/
NAS_EMM_SendTimerStateNotify(TI_NAS_EMM_PTL_T3423, LMM_MMC_TIMER_EXP);
if (MMC_LMM_TIN_RAT_RELATED_TMSI == NAS_EMM_GetTinType())
{
/*更新TIN值为P-TMSI*/
NAS_EMM_SetTinType(MMC_LMM_TIN_P_TMSI);
/*更新承载ISR标识*/
NAS_EMM_UpdateBearISRFlag(NAS_EMM_GetPsBearerCtx());
/*PC REPLAY MODIFY BY LEILI END*/
NAS_EMM_PUBU_LOG_INFO("NAS_EMM_PreProcMsgT3423Exp: UPDATE MML PS BEARER INFO:");
NAS_COMM_PrintArray( NAS_COMM_GET_MM_PRINT_BUF(),
(VOS_UINT8*)NAS_MML_GetPsBearerCtx(),
sizeof(NAS_MML_PS_BEARER_CONTEXT_STRU)
*EMM_ESM_MAX_EPS_BEARER_NUM);
}
/*不需要进入状态机处理*/
return NAS_LMM_MSG_HANDLED;
}
/*****************************************************************************
Function Name : NAS_LMM_DecodeSimImsi
Discription : 解码IMSI
Input : pstNvCtrlTbl:公共处理结构
Output : 解码后的数据
Return :
History:
*****************************************************************************/
VOS_UINT32 NAS_LMM_DecodeSimImsi(const NAS_NVIM_CTRL_TBL *pstNvCtrlTbl)
{
VOS_UINT8 *pucImsi;
NAS_EMM_UEID_STRU *pstUeId;
pstUeId = (VOS_VOID *)NAS_EMM_GetEmmGlobleAddr(NAS_LMM_GLOBLE_PAEA_UEID);
pucImsi = (VOS_VOID *)NAS_EMM_GetEmmGlobleAddr(NAS_LMM_GLOBLE_PAEA_IMSI);
if((NAS_NVIM_NULL_PTR == pstUeId) || (NAS_NVIM_NULL_PTR == pucImsi))
{
/* 打印查询的 类型 */
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimImsi: Point is Null");
return NAS_LMM_NVIM_FAIL;
}
if (NAS_LMM_NVIM_IMSI_FILE_LEN != pstNvCtrlTbl->usNvDataLen)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_DecodeSimImsi: USIM IMSI LENGTH ERR");
return NAS_LMM_NVIM_FAIL;
}
pstUeId->bitOpImsi = NAS_NVIM_BIT_SLCT;
NAS_LMM_MEM_CPY( pucImsi,
pstNvCtrlTbl->pNvData,
NAS_LMM_NVIM_IMSI_FILE_LEN);
/*PC REPLAY MODIFY BY LEILI DELETE*/
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_DecodeSimImsi: IMSI IS ");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(),pucImsi,NAS_LMM_NVIM_IMSI_FILE_LEN);
return NAS_LMM_NVIM_OK;
}
VOS_UINT32 NAS_EMM_PreProcMsgEsmBearModifyReq
(
MsgBlock * pMsg
)
{
EMM_ESM_BEARER_MODIFY_REQ_STRU *pstBearModReq = NAS_EMM_NULL_PTR;
VOS_UINT32 ulMatchRslt;
pstBearModReq = (VOS_VOID*)pMsg;
ulMatchRslt = NAS_EMM_IsBearIsrActBefore(pstBearModReq->ulEpsId);
NAS_LMM_PUBM_LOG3_INFO("NAS_EMM_PreProcMsgEsmBearStatusReq:NAS_EMM_GetCurLteState()=,\
NAS_EMM_GetTinType()= , NAS_EMM_IsBearIsrActBefore()= ",
NAS_EMM_GetCurLteState(),
NAS_EMM_GetTinType(),
ulMatchRslt);
if(NAS_LMM_CUR_LTE_SUSPEND == NAS_EMM_GetCurLteState())
{
return NAS_LMM_MSG_HANDLED;
}
NAS_EMM_PUBU_LOG_INFO("NAS_EMM_PreProcMsgEsmBearStatusReq: GET MML PS BEARER INFO:");
NAS_COMM_PrintArray( NAS_COMM_GET_MM_PRINT_BUF(),
(VOS_UINT8*)NAS_MML_GetPsBearerCtx(),
sizeof(NAS_MML_PS_BEARER_CONTEXT_STRU)
*EMM_ESM_MAX_EPS_BEARER_NUM);
if ((MMC_LMM_TIN_RAT_RELATED_TMSI == NAS_EMM_GetTinType()) &&
(NAS_EMM_SUCC == ulMatchRslt))
{
/*更新TIN值为GUTI*/
NAS_EMM_SetTinType(MMC_LMM_TIN_GUTI);
/*更新所有承载的ISR标识为ISR激活前*/
NAS_EMM_UpdateBearISRFlag(NAS_EMM_GetPsBearerCtx());
NAS_EMM_PUBU_LOG_INFO("NAS_EMM_PreProcMsgEsmBearStatusReq: UPDATE MML PS BEARER INFO:");
NAS_COMM_PrintArray( NAS_COMM_GET_MM_PRINT_BUF(),
(VOS_UINT8*)NAS_MML_GetPsBearerCtx(),
sizeof(NAS_MML_PS_BEARER_CONTEXT_STRU)
*EMM_ESM_MAX_EPS_BEARER_NUM);
}
return NAS_LMM_MSG_HANDLED;
}
VOS_UINT32 NAS_LMM_EncodeNvUplmn( NAS_NVIM_CTRL_TBL *pstNvCtrlTbl )
{
#if 0
LNAS_LMM_NV_PLMN_LIST_STRU *pstNvplmnList;
NAS_MM_PLMN_LIST_STRU *pstUplmnList;
VOS_UINT32 i;
VOS_UINT32 ulIndex;
VOS_UINT8 *pucMsg;
if(NAS_NVIM_NULL_PTR == pstNvCtrlTbl->pData)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_EncodeNvUplmn: WARNING->pData is Null");
return NAS_LMM_NVIM_FAIL;
}
if(NAS_EMM_USIM_FEATURE_HARD == NAS_LMM_GetUsimFeature())
{
pstNvplmnList = (LNAS_LMM_NV_PLMN_LIST_STRU *)pstNvCtrlTbl->pData;
pstUplmnList = &(pstNvplmnList->stPlmnList);
pucMsg = (VOS_UINT8 *)pstNvCtrlTbl->pNvData;
pstNvCtrlTbl->usNvDataLen = (VOS_UINT16)((pstUplmnList->ulPlmnNum) * NAS_LMM_PLMN_AND_ACT_LEN);
for(i = 0; i < pstUplmnList->ulPlmnNum; i++)
{
ulIndex = i * NAS_LMM_PLMN_AND_ACT_LEN;
NAS_LMM_MEM_CPY( &pucMsg[ulIndex],
&pstUplmnList->astPlmnId[i],
NAS_LMM_NVIM_PLMN_ID_LEN);
/* NAS_LMM_ACCESS_TECH_LTE 为 0x40 NAS_LMM_ACCESS_TECH_RSV 为 0x00*/
pucMsg[ulIndex + 3] = NAS_LMM_ACCESS_TECH_LTE;
pucMsg[ulIndex + 4] = NAS_LMM_ACCESS_TECH_RSV;
}
NAS_LMM_NVIM_LOG1_INFO("NAS_LMM_EncodeNvUplmn: LEN= ",
pstNvCtrlTbl->usNvDataLen);
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeNvUplmn: PLMN IS ");
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(),(VOS_UINT8 *)pstNvCtrlTbl->pNvData,pstNvCtrlTbl->usNvDataLen);
return NAS_LMM_NVIM_OK;
}
else
#endif
{
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_EncodeNvUplmn is entered");
return NAS_LMM_EncodeOneNvItem(pstNvCtrlTbl);
}
}
/*****************************************************************************
Function Name : NAS_LMM_ReadMmcUsimFile
Description : 部分USIM文件是MMC读取的，LMM从MMC那里读到LMM中来
和V1R1比较，这些文件在V7中不再读:
6F62 MMC_READ_HPLMN_SEL_FILE_ID
6F7B MMC_READ_FORBIDDEN_PLMN_LIST_FILE_ID
6F60 MMC_READ_UPLMN_SEL_FILE_ID
6F61 MMC_READ_OPLMN_SEL_FILE_ID
6F31 MMC_READ_HPLMN_PERI_FILE_ID
6FAD MMC_READ_MNC_LENGTH_FILE_ID
6FDC Last RPLMN Selection Indication
Input : None
Output : None
Return : VOS_UINT32
History :
1.HanLufeng 41410 2011-2-23 Draft Enact
*****************************************************************************/
NAS_LMM_USIM_READ_RST_ENUM_UINT32 NAS_LMM_ReadMmcUsimFile(VOS_VOID)
{
VOS_UINT32 ulRst;
PS_USIM_GET_FILE_CNF_STRU *pstUsimCnfMsg;
pstUsimCnfMsg = (PS_USIM_GET_FILE_CNF_STRU *)(g_aucNvimBuff);
/*PC REPLAY MODIFY BY LEILI BEGIN*/
/* 6F07 MMC_READ_IMSI_FILE_ID 读USIM卡提供的接口函数 */
ulRst = NAS_EMM_GetCardIMSI((VOS_UINT8 *)(pstUsimCnfMsg->aucEf));
/*PC REPLAY MODIFY BY LEILI END*/
if(USIMM_API_SUCCESS != ulRst)
{
NAS_LMM_EMM_PLMN_LOG1_ERR("NAS_LMM_ReadMmcUsimFile : read IMSI err: ",
ulRst);
return NAS_LMM_USIM_READ_HARD_IMSI_ERR;
}
else
{
/* 打印从USIM读出的原始码流 */
NAS_LMM_PUBM_LOG_NORM("\n");
NAS_LMM_PUBM_LOG_NORM("====== USIMM_GetCardIMSI: IMSI: ======");
NAS_COMM_PrintArray( NAS_COMM_GET_MM_PRINT_BUF(),
pstUsimCnfMsg->aucEf,
NAS_LMM_NVIM_IMSI_FILE_LEN);
NAS_LMM_PUBM_LOG_NORM("\n");
/* 准备一下 NAS_LMM_ProcessHardUsimCnf 的入口参数 */
pstUsimCnfMsg->usEfId = NAS_USIM_FILE_ID_IMSI;
pstUsimCnfMsg->usEfLen = NAS_LMM_NVIM_IMSI_FILE_LEN;
pstUsimCnfMsg->ucRecordNum = 0;
pstUsimCnfMsg->ucTotalNum = 0;
/* 解码 */
ulRst = NAS_LMM_ProcessHardUsimCnf(pstUsimCnfMsg);
if(NAS_LMM_NVIM_OK != ulRst)
{
NAS_LMM_EMM_PLMN_LOG1_ERR("NAS_LMM_ReadMmcUsimFile : Decode IMSI err: ", ulRst);
return NAS_LMM_USIM_READ_HARD_IMSI_ERR;
}
}
return NAS_LMM_USIM_READ_SUCC;
/* 不再读取 : 6F38 MMC_READ_UST_FILE_ID */
}
/*****************************************************************************
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);
}
}
/*****************************************************************************
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_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;
}
/*lint -e961*/
VOS_UINT32 NAS_LMM_NvimWrite( NAS_LMM_ITEM_TYPE_ENUM_UINT32 ulNVItemType,
VOS_VOID *pData,
VOS_UINT16 usDataLen )
{
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;
VOS_UINT16 usEfId = 0;
USIMM_SET_FILE_INFO_STRU stSetFileInfo ={0};
/*check input params*/
if((NAS_NVIM_NULL_PTR == pData) ||
(usDataLen == VOS_NULL) ||
(ulNVItemType > EN_NV_ID_PS_END))
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_NvimWrite:input para ERR");
return NAS_LMM_NVIM_FAIL;
}
/*Initalize NVIM ctrl tbl*/
stNvCtrlTbl.pData = pData;
stNvCtrlTbl.pNvData = g_aucNvimBuff;
stNvCtrlTbl.usDataLen = usDataLen;
stNvCtrlTbl.usNvDataLen = 0;
/* 在g_astNvDataMap中查找对应的NV TYPE*/
for(i = 0; i < g_ulNvDataMapNum; i++)
{
/* 若NV类型相同,则找到了,返回当前的NV动作函数，退出循环 */
if(ulNVItemType == g_astNvDataMap[i].ulEventType)
{
pActFun = g_astNvDataMap[i].pfEncodeActionFun;
usEfId = g_astNvDataMap[i].usUsimFileId;
break;
}
}
if (NAS_LMM_NULL_PTR == pActFun)
{
/* 如果找不到处理函数，表示当前没有该处理函数 */
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_NvimWrite:Action functin is ERR");
return NAS_LMM_NVIM_FAIL;
}
ulRslt = (*pActFun) (&stNvCtrlTbl);
if ( NAS_LMM_NVIM_WRITTEN_UNNEEDED == ulRslt)
{
NAS_LMM_NVIM_LOG_INFO("NAS_LMM_NvimWrite: Don't need to write usim.");
return NAS_LMM_NVIM_WRITTEN_UNNEEDED;
}
if(ulRslt != NAS_LMM_NVIM_OK)
{
NAS_LMM_NVIM_LOG_ERR("NAS_LMM_NvimWrite:Encode is ERR");
return NAS_LMM_NVIM_FAIL;
}
/*硬USIM下，并且NV ITEM属于USIM的范围，则向USIM中写文件*/
if((EN_NV_ID_USIM_BEGIN < ulNVItemType)
&&(EN_NV_ID_USIM_END > ulNVItemType))
{
NAS_LMM_NVIM_LOG1_INFO("NAS_LMM_NvimWrite:USIMM_SetFileReq, ulNVItemType = ", ulNVItemType);
/*ucRecordNum默认为1，NAS目前涉及的文件是线形文件，且只有一个记录*/
stSetFileInfo.enAppType = USIMM_UMTS_APP;
stSetFileInfo.ucRecordNum = 1;
stSetFileInfo.usEfId = usEfId;
stSetFileInfo.ulEfLen = stNvCtrlTbl.usNvDataLen;
stSetFileInfo.pucEfContent = stNvCtrlTbl.pNvData;
/*
ulRslt = USIMM_SetFileReq( PS_USIM_CLIENT_LMM,
usEfId,
(VOS_UINT8*)stNvCtrlTbl.pNvData,
(VOS_UINT8 )stNvCtrlTbl.usNvDataLen,
ucRecordNum );*/
ulRslt = USIMM_SetFileReq( PS_PID_MM,
0,
&stSetFileInfo );
NAS_LMM_NVIM_LOG3_INFO("usNvDataLen = , len = , usEfId = ",
stNvCtrlTbl.usNvDataLen,
stNvCtrlTbl.usNvDataLen,
usEfId);
NAS_COMM_PrintArray(NAS_COMM_GET_MM_PRINT_BUF(), (VOS_UINT8*)stNvCtrlTbl.pNvData,stNvCtrlTbl.usNvDataLen);
return ulRslt;
}
/*其他情况向NV中写信息*/
/*lint -e718*/
/*lint -e516*/
/*lint -e732*/
ulRslt = LPs_NvimItem_Write( ulNVItemType,
stNvCtrlTbl.pNvData,
stNvCtrlTbl.usNvDataLen);
/*lint +e732*/
/*lint +e516*/
/*lint +e718*/
return ulRslt;
}
VOS_VOID NAS_LPP_TaskEntry(MsgBlock * pMsg)
{
/* 定义消息头指针*/
#if (FEATURE_LPP == FEATURE_ON)
PS_MSG_HEADER_STRU *pHeader = VOS_NULL_PTR;
NAS_LPP_NORM_LOG("NAS_LPP_TaskEntry is entered!");
TLPS_PRINT2LAYER_INFO(NAS_LPP_TaskEntry_ENUM, LNAS_LPP_TaskEntryEnter);
/* 判断入口参数是否合法*/
if( VOS_NULL_PTR == pMsg)
{
NAS_LPP_ERR_LOG("NAS_LPP_TaskEntry:ERROR: No Msg!");
TLPS_PRINT2LAYER_ERROR(NAS_LPP_TaskEntry_ENUM, LNAS_LPP_TaskEntryNullMsg);
return;
}
/* 获取消息头指针*/
pHeader = (PS_MSG_HEADER_STRU *) pMsg;
/*打印收到的消息*/
NAS_LPP_PrintLppRevMsg(pHeader,NAS_COMM_GET_LPP_PRINT_BUF());
/*打印消息码流*/
NAS_LPP_NORM_LOG("====================IN MSG CONTENT is : ============");
NAS_COMM_PrintArray( NAS_COMM_GET_LPP_PRINT_BUF(),
(VOS_UINT8 *)pMsg,
(pMsg->ulLength + NAS_LPP_MSG_HEADER_LENGTH));
NAS_LPP_NORM_LOG("====================================================");
switch(pHeader->ulSenderPid)
{
case PS_PID_MM:
NAS_LPP_EmmMsgDistr(pMsg);
break;
case PS_PID_ERRC:
NAS_LPP_LrrcMsgDistr(pMsg);
break;
case VOS_PID_TIMER:
NAS_LPP_TimerMsgDistr(pMsg);
break;
case UEPS_PID_MTA:
NAS_LPP_MtaMsgDistr(pMsg);
break;
case PS_PID_LPP:
NAS_LPP_LppMsgDistr(pMsg);
break;
case PS_PID_TC:
NAS_LPP_EtcMsgDistr(pMsg);
break;
case WUEPS_PID_LCS:
NAS_LPP_LcsMsgDistr(pMsg);
break;
default:
NAS_LPP_WARN_LOG("NAS_LPP_TaskEntry:NORM: Error SenderPid!");
TLPS_PRINT2LAYER_ERROR(NAS_LPP_TaskEntry_ENUM, LNAS_LPP_TaskEntryNoThisMsg);
break;
}
#endif
return;
}
