/*****************************************************************************
函 数 名 : OM_Acpu_WriteLogFile
功能描述 : 将错误信息记录到ERRORLOG中
输入参数 : cFileName: log文件名，包含路径信息
pRecord: 记录数据内容
ulLen: 记录数据长度
输出参数 : VOID
返 回 值 : 其他:函数执行过程中出现错误
VOS_OK:函数执行正常
修改历史 :
1.日 期 : 2012年5月8日
作 者 : zhuli
修改内容 : 新生成函数
*****************************************************************************/
VOS_UINT32 OM_Acpu_WriteLogFile(VOS_CHAR * cFileName, void *pRecord, VOS_UINT32 ulLen)
{
OM_WRITELOG_REQ_STRU *pstLogReq;
/* 参数检测 */
if ((VOS_NULL_PTR == cFileName) || (VOS_NULL_PTR == pRecord))
{
return OM_ACPU_PARA_ERR;
}
pstLogReq = (OM_WRITELOG_REQ_STRU*)VOS_AllocMsg(ACPU_PID_OMAGENT,
(sizeof(OM_WRITELOG_REQ_STRU)-VOS_MSG_HEAD_LENGTH)+ulLen);
/* 分配消息失败 */
if (VOS_NULL_PTR == pstLogReq)
{
return OM_ACPU_ALLOC_FAIL;
}
pstLogReq->ulReceiverPid = CCPU_PID_OMAGENT;
pstLogReq->usPrimId = OM_WRITE_LOG_REQ;
pstLogReq->ulLen = ulLen;
/* 为了确保aucFileName最后字节为'\0',拷贝长度需要加1 */
VOS_MemCpy(pstLogReq->aucFileName, cFileName, VOS_StrLen(cFileName)+1);
VOS_MemCpy(pstLogReq->aucData, pRecord, ulLen);
/* 将请求消息发送给CCPU */
if (VOS_OK != VOS_SendMsg(ACPU_PID_OMAGENT, pstLogReq))
{
return OM_ACPU_SEND_FAIL;
}
return VOS_OK;
}
VOS_VOID STK_ProfileInit(USIMM_STK_CFG_STRU *pstSTKProfileContent, VOS_UINT32 ulCardType)
{
VOS_UINT8 aucUsimProfile[]=STK_USIM_PROFILE_DEFAULT;
VOS_UINT8 aucSimProfile[]= {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xC0,
0xFF,0xFF,0xFF,0xF9,0xFF,0xF7,0xC0,0xFF,0xF0,0xFF};
if (NV_OK == NV_Read(en_NV_Item_TerminalProfile_Set, pstSTKProfileContent, sizeof(USIMM_STK_CFG_STRU)))
{
return;
}
pstSTKProfileContent->ucTimer = STK_POROTECT_TIME_LEN; /*定时器长度的单位是秒*/
pstSTKProfileContent->ucFuncEnable = TAF_TRUE;
if (USIMM_CARD_USIM == ulCardType)
{
VOS_MemCpy(pstSTKProfileContent->stUsimProfile.aucProfile, aucUsimProfile, sizeof(aucUsimProfile));
pstSTKProfileContent->stUsimProfile.ucProfileLen = sizeof(aucUsimProfile);
}
else
{
VOS_MemCpy(pstSTKProfileContent->stSimProfile.aucProfile, aucSimProfile, sizeof(aucSimProfile));
pstSTKProfileContent->stSimProfile.ucProfileLen = sizeof(aucSimProfile);
}
return;
}
VOS_VOID USIMM_TelecomAuthCnf(USIMM_AUTH_REQ_STRU *pstMsg, USIMM_TELECOM_AUTH_INFO_STRU *pstCnfInfo)
{
USIMM_AUTH_CNF_STRU *pstCnfMsg;
/* 分配消息内存 */
pstCnfMsg = (USIMM_AUTH_CNF_STRU*)VOS_AllocMsg(WUEPS_PID_USIM, sizeof(USIMM_AUTH_CNF_STRU)-VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstCnfMsg)
{
USIMM_ERROR_LOG("USIMM_TelecomAuthCnf: VOS_AllocMsg is Failed");
return;
}
VOS_MemSet((VOS_UINT8*)pstCnfMsg + VOS_MSG_HEAD_LENGTH, 0, pstCnfMsg->ulLength);
pstCnfMsg->ulReceiverPid = pstMsg->ulSenderPid;
pstCnfMsg->ulMsgName = PS_USIM_AUTHENTICATION_CNF;
pstCnfMsg->enAppType = pstMsg->enAppType;
pstCnfMsg->enAuthType = pstMsg->enAuthType;
pstCnfMsg->ucOpId = pstMsg->ucOpId;
pstCnfMsg->enResult = pstCnfInfo->enResult;
if ((VOS_NULL_PTR != pstCnfInfo->pucIK)
&& (sizeof(pstCnfMsg->cnfdata.stTELECnf.aucIK) > pstCnfInfo->pucIK[0]))
{
VOS_MemCpy(pstCnfMsg->cnfdata.stTELECnf.aucIK, pstCnfInfo->pucIK, pstCnfInfo->pucIK[0] + 1);
}
if ((VOS_NULL_PTR != pstCnfInfo->pucCK)
&& (sizeof(pstCnfMsg->cnfdata.stTELECnf.aucCK) > pstCnfInfo->pucCK[0]))
{
VOS_MemCpy(pstCnfMsg->cnfdata.stTELECnf.aucCK, pstCnfInfo->pucCK, pstCnfInfo->pucCK[0] + 1);
}
if ((VOS_NULL_PTR != pstCnfInfo->pucGsmKC)
&& (sizeof(pstCnfMsg->cnfdata.stTELECnf.aucGsmKc) > pstCnfInfo->pucGsmKC[0]))
{
VOS_MemCpy(pstCnfMsg->cnfdata.stTELECnf.aucGsmKc, pstCnfInfo->pucGsmKC, pstCnfInfo->pucGsmKC[0] + 1);
}
if ((VOS_NULL_PTR != pstCnfInfo->pucAuts)
&& (sizeof(pstCnfMsg->cnfdata.stTELECnf.aucAuts) > pstCnfInfo->pucAuts[0]))
{
VOS_MemCpy(pstCnfMsg->cnfdata.stTELECnf.aucAuts, pstCnfInfo->pucAuts, pstCnfInfo->pucAuts[0] + 1);
}
if ((VOS_NULL_PTR != pstCnfInfo->pucAuthRes)
&& (sizeof(pstCnfMsg->cnfdata.stTELECnf.aucAuthRes) > pstCnfInfo->pucAuthRes[0]))
{
VOS_MemCpy(pstCnfMsg->cnfdata.stTELECnf.aucAuthRes, pstCnfInfo->pucAuthRes, pstCnfInfo->pucAuthRes[0] + 1);
}
/* 回复消息 */
(VOS_VOID)VOS_SendMsg(pstCnfMsg->ulSenderPid, pstCnfMsg);
return;
}
VOS_UINT32 USIMM_AuthenVirtulSim(USIMM_AUTH_REQ_STRU *pstMsg)
{
VOS_UINT8 aucOutPut[USIMM_AUTH_RES_LEN+USIMM_AUTH_KC_LEN] = {0}; /*RES+KC*/
VOS_UINT8 aucxRes[USIMM_AUTH_RES_LEN+1] = {0}; /*长度1Byte+内容*/
VOS_UINT8 aucGsmKC[USIMM_AUTH_KC_LEN+1] = {0}; /*长度1Byte+内容*/
VOS_UINT8 aucKi[USIMM_AUTH_KI_LEN];
VOS_UINT8 aucOpc[USIMM_AUTH_OPC_LEN]; /*不使用，但是需要避免XML里面有*/
USIMM_TELECOM_AUTH_INFO_STRU stCnfInfo;
VOS_MemSet(&stCnfInfo, 0, sizeof(stCnfInfo));
/* 解密全局变量中的Ki Opc */
if(VOS_OK != USIMM_VsimGetRealKiOpc(aucKi, aucOpc))
{
stCnfInfo.enResult = USIMM_AUTH_GSM_OTHER_FAILURE;
USIMM_TelecomAuthCnf(pstMsg, &stCnfInfo);
return VOS_ERR;
}
if(USIMM_VSIM_COMPV1 == g_stUSIMMVSimAuthInfo.enAuthType) /*comp 128 v1*/
{
RUNA3A8_V1(aucKi, &pstMsg->aucData[1], aucOutPut);
}
else if(USIMM_VSIM_COMPV2 == g_stUSIMMVSimAuthInfo.enAuthType) /*comp 128 v2*/
{
/* coverity[uninit_use_in_call] */
RUNA3A8_V2(aucKi, &pstMsg->aucData[1], aucOutPut);
}
else /*comp 128 v3*/
{
/* coverity[uninit_use_in_call] */
RUNA3A8_V3(aucKi, &pstMsg->aucData[1], aucOutPut);
}
aucxRes[0] = USIMM_AUTH_RES_LEN;
VOS_MemCpy(&aucxRes[1], aucOutPut, USIMM_AUTH_RES_LEN);
aucGsmKC[0] = USIMM_AUTH_KC_LEN;
VOS_MemCpy(&aucGsmKC[1], &aucOutPut[USIMM_AUTH_RES_LEN], USIMM_AUTH_KC_LEN);
stCnfInfo.pucAuthRes = aucxRes;
stCnfInfo.pucIK = VOS_NULL_PTR;
stCnfInfo.pucCK = VOS_NULL_PTR;
stCnfInfo.pucGsmKC = aucGsmKC;
stCnfInfo.pucAuts = VOS_NULL_PTR;
stCnfInfo.enResult = USIMM_AUTH_GSM_SUCCESS;
USIMM_TelecomAuthCnf(pstMsg, &stCnfInfo);
return VOS_OK;
}
VOS_UINT32 diag_FsQueryProc(VOS_UINT8* pstReq,VOS_UINT32 ulCmdId)
{
DIAG_CMD_FS_QUERY_REQ* pstFsReq = NULL;
DIAG_CMD_FS_QUERY_CNF stFsCnf = {0};
VOS_UINT32 ret = ERR_MSP_SUCCESS;
pstFsReq = (DIAG_CMD_FS_QUERY_REQ*)(DIAG_OFFSET_HEAD_GET_DATA(pstReq));
if (DIAG_FS_ROOT_FOLDER == pstFsReq->ulFolderType)
{
#if(VOS_OS_VER == VOS_LINUX)
/* 锁定状态下，根目录受限制 */
if(g_bAtDataLocked)
{
stFsCnf.ulLength = VOS_StrLen((VOS_CHAR*)g_acDiagLockedRootPath);
VOS_MemCpy(stFsCnf.aucDirPath,g_acDiagLockedRootPath, stFsCnf.ulLength);
}
else
{
stFsCnf.ulLength = VOS_StrLen((VOS_CHAR*)g_acDiagRootPath);
VOS_MemCpy(stFsCnf.aucDirPath,g_acDiagRootPath, stFsCnf.ulLength);
}
#else
stFsCnf.ulLength = VOS_StrLen((VOS_CHAR*)g_acDiagRootPath);
VOS_MemCpy(stFsCnf.aucDirPath,g_acDiagRootPath, stFsCnf.ulLength);
#endif
g_stDiagFileInfo.ulFileType = DIAG_FS_ROOT_FOLDER;
}
else if (DIAG_FS_LOG_FOLDER == pstFsReq->ulFolderType)
{
stFsCnf.ulLength = VOS_StrLen((VOS_CHAR*)g_acDiagLogDir);
VOS_MemCpy(stFsCnf.aucDirPath,g_acDiagLogDir, stFsCnf.ulLength);
g_stDiagFileInfo.ulFileType = DIAG_FS_LOG_FOLDER;
}
/*临终遗言文件所在的路径*/
else if (DIAG_FS_DUMP_FOLDER == pstFsReq->ulFolderType)
{
stFsCnf.ulLength = VOS_StrLen((VOS_CHAR*)g_acDiagDumpDir);
VOS_MemCpy(stFsCnf.aucDirPath, g_acDiagDumpDir, stFsCnf.ulLength);
g_stDiagFileInfo.ulFileType = DIAG_FS_DUMP_FOLDER;
}
else
{
ret = ERR_MSP_FAILURE;
}
stFsCnf.ulRet = ret;
/*打包回复给FW*/
ret = diag_AgentCnfFun((VOS_UINT8*)&stFsCnf,ulCmdId,sizeof(DIAG_CMD_FS_QUERY_CNF));
return ret;
}
SC_ERROR_CODE_ENUM_UINT32 SC_FAC_SetDhKey(
MODEM_ID_ENUM_UINT16 enModemID,
SC_DH_KEY_TYPE_ENUM_UINT32 enKeyType,
VOS_UINT32 ulKeyLen,
VOS_UINT8 *pucKey
)
{
VOS_UINT32 ulResult;
NVIM_VSIM_HVSDH_NV_STRU stDhNv;
/* 判断鉴权是否通过 */
if (SC_AUTH_STATUS_DONE != SC_CTX_GetFacAuthStatus())
{
SC_ERROR_LOG("SC_FAC_SetDhKey: SC_CTX_GetFacAuthStatus is not done.");
return SC_ERROR_CODE_IDENTIFY_NOT_FINISH;
}
/* 从NV项中读出密钥信息 */
ulResult = NV_ReadEx(enModemID, en_NV_Item_VSIM_HVSDH_INFO, &stDhNv, sizeof(stDhNv));
if (NV_OK != ulResult)
{
SC_ERROR_LOG("SC_FAC_SetDhKey: NV_Read fail.");
return SC_ERROR_CODE_NV_READ_FAIL;
}
if (SC_DH_KEY_SERVER_PUBLIC_KEY == enKeyType)
{
VOS_MemCpy(stDhNv.stSPublicKey.aucKey, pucKey, ulKeyLen);
stDhNv.stSPublicKey.ulKeyLen = ulKeyLen;
}
else if (SC_DH_KEY_MODEM_PUBLIC_KEY == enKeyType)
{
VOS_MemCpy(stDhNv.stCPublicKey.aucKey, pucKey, ulKeyLen);
stDhNv.stCPublicKey.ulKeyLen = ulKeyLen;
}
else
{
VOS_MemCpy(stDhNv.stCPrivateKey.aucKey, pucKey, ulKeyLen);
stDhNv.stCPrivateKey.ulKeyLen = ulKeyLen;
}
/* 将服务器公钥写入NV项中 */
ulResult = NV_WriteEx(enModemID, en_NV_Item_VSIM_HVSDH_INFO, &stDhNv, sizeof(stDhNv));
if (NV_OK != ulResult)
{
SC_ERROR_LOG("SC_FAC_SetDhKey: NV_Write fail.");
return SC_ERROR_CODE_NV_WRITE_FAIL;
}
return SC_ERROR_CODE_NO_ERROR;
}
VOS_VOID SI_STK_DecodeMoSmsRspSpecial(
VOS_UINT32 ulDataLen,
VOS_UINT8 *pucCmdData,
SI_STK_ENVELOPE_RSP_STRU *pstRspData)
{
VOS_UINT32 ulTagOffset;
ulTagOffset = SI_STKFindTag(ADDRESS_TAG, pucCmdData, ulDataLen, 1);
if(ulTagOffset != SI_TAGNOTFOUND)
{
pstRspData->uResp.MoSmsCtrlRsp.Addr1.ucLen = pucCmdData[ulTagOffset] - 1;
pstRspData->uResp.MoSmsCtrlRsp.Addr1.ucNumType = pucCmdData[ulTagOffset+1];
pstRspData->uResp.MoSmsCtrlRsp.Addr1.pucAddr
= (SI_UINT8*)VOS_MemAlloc(MAPS_STK_PID, DYNAMIC_MEM_PT, pstRspData->uResp.MoSmsCtrlRsp.Addr1.ucLen);
if(VOS_NULL_PTR != pstRspData->uResp.MoSmsCtrlRsp.Addr1.pucAddr)
{
/*lint -e534*/
VOS_MemCpy(pstRspData->uResp.MoSmsCtrlRsp.Addr1.pucAddr,
&pucCmdData[ulTagOffset+2], pstRspData->uResp.MoSmsCtrlRsp.Addr1.ucLen);
/*lint +e534*/
}
pstRspData->uResp.MoSmsCtrlRsp.OP_Addr1 = 1;
}
ulTagOffset = SI_STKFindTag(ADDRESS_TAG, pucCmdData, ulDataLen, 2);
if(ulTagOffset != SI_TAGNOTFOUND)
{
pstRspData->uResp.MoSmsCtrlRsp.Addr2.ucLen = pucCmdData[ulTagOffset] - 1;
pstRspData->uResp.MoSmsCtrlRsp.Addr2.ucNumType = pucCmdData[ulTagOffset+1];
pstRspData->uResp.MoSmsCtrlRsp.Addr2.pucAddr
= (SI_UINT8*)VOS_MemAlloc(MAPS_STK_PID, DYNAMIC_MEM_PT, pstRspData->uResp.MoSmsCtrlRsp.Addr2.ucLen);
if(VOS_NULL_PTR != pstRspData->uResp.MoSmsCtrlRsp.Addr2.pucAddr)
{
/*lint -e534*/
VOS_MemCpy(pstRspData->uResp.MoSmsCtrlRsp.Addr2.pucAddr,
&pucCmdData[ulTagOffset+2], pstRspData->uResp.MoSmsCtrlRsp.Addr2.ucLen);
/*lint +e534*/
}
pstRspData->uResp.MoSmsCtrlRsp.OP_Addr2 = 1;
}
return;
}
VOS_UINT32 USIMM_VsimHUKDecode(VOS_UINT8 *pucSrc,
VOS_UINT32 ulSrcLen,
VOS_UINT8 *pucDst,
VOS_UINT32 *pulDstLen)
{
#if (FEATURE_ON == FEATURE_SECURITY_PHONE)
VOS_UINT8 auckey[USIMM_HUK_LEN];
VOS_INT32 lDstLen;
if (BSP_OK != efuseReadHUK((BSP_U32 *)auckey, (sizeof(auckey)/sizeof(BSP_U32))))
{
USIMM_ERROR_LOG("USIMM_VsimHUKDecode: efuseReadHUK Failed");
return VOS_ERR;
}
lDstLen = AESDecryptS(pucSrc, (VOS_INT)ulSrcLen, auckey, USIMM_HUK_BITS, pucDst, VSIM_DH_AGREE_KEY);
if (VOS_NULL == lDstLen)
{
USIMM_ERROR_LOG("USIMM_VsimHUKDecode: AESEncrypt Fail");
return VOS_ERR;
}
*pulDstLen = (VOS_UINT32)lDstLen;
#else
VOS_MemCpy(pucDst, pucSrc, ulSrcLen);
*pulDstLen = ulSrcLen;
#endif /*(FEATURE_ON == FEATURE_SECURITY_PHONE)*/
return VOS_OK;
}
VOS_VOID diag_PortAddToDataBuf(DIAG_PORT_PHY_BEAR_ENUM enPort, VOS_UINT8 * data, VOS_UINT32 dataSize)
{
DIAG_PORT_DATA_BUF_STRU * pNewNode = NULL;
/*申请一个节点大小*/
pNewNode = (DIAG_PORT_DATA_BUF_STRU *)VOS_MemAlloc(MSP_PID_DIAG_APP_AGENT, DYNAMIC_MEM_PT, sizeof(DIAG_PORT_DATA_BUF_STRU));
if (NULL == pNewNode)
{
diag_printf("%s: alloc mem for new node fail\n", __FUNCTION__);
return;
}
/*申请数据空间*/
pNewNode->dataBuf = (VOS_UINT8 *)VOS_MemAlloc(MSP_PID_DIAG_APP_AGENT, DYNAMIC_MEM_PT, dataSize);
if (NULL == pNewNode->dataBuf)
{
diag_printf("%s: alloc mem for data buf fail\n", __FUNCTION__);
return;
}
pNewNode->port = enPort;
pNewNode->dataLen = dataSize;
VOS_MemCpy(pNewNode->dataBuf, data, dataSize);
(VOS_VOID)VOS_SmP(g_diagPortSem,0);
/* 插入节点到链表尾部 */
blist_add_tail(&pNewNode->dataList, &g_diagPortDataBuf.dataList);
(VOS_VOID)VOS_SmV(g_diagPortSem);
}
VOS_VOID USIMM_EccNumberInd(VOS_UINT8 ucEccType,
VOS_UINT16 usEfLen,
VOS_UINT8 ucRecordNum,
VOS_UINT8 *pucData)
{
PS_USIM_ECC_IND_STRU *pUsimMsg;
pUsimMsg = (PS_USIM_ECC_IND_STRU*)VOS_AllocMsg(WUEPS_PID_USIM, (sizeof(PS_USIM_ECC_IND_STRU)-VOS_MSG_HEAD_LENGTH)+usEfLen);
if (VOS_NULL_PTR == pUsimMsg)
{
return;
}
pUsimMsg->ulReceiverPid = MAPS_PB_PID; /*填写PB的PID*/
pUsimMsg->ulMsgName = PS_USIM_ECCNUMBER_IND;
pUsimMsg->ucEccType = ucEccType;
pUsimMsg->ucRecordNum = ucRecordNum;
pUsimMsg->usFileSize = usEfLen;
if(0 != usEfLen)
{
VOS_MemCpy(pUsimMsg->ucContent, pucData, usEfLen);
}
(VOS_VOID)VOS_SendMsg(pUsimMsg->ulSenderPid, pUsimMsg);
return;
}
VOS_VOID USIMM_SearchHandleCnf(VOS_UINT32 ulReceiverPid,
VOS_UINT32 ulErrorCode,
USIMM_SEARCHCNF_INFO_STRU *pstCnfInfo)
{
PS_USIM_SEARCH_CNF_STRU *pUsimMsg;
pUsimMsg = (PS_USIM_SEARCH_CNF_STRU *)VOS_AllocMsg(WUEPS_PID_USIM,
(sizeof(PS_USIM_SEARCH_CNF_STRU) - VOS_MSG_HEAD_LENGTH) + pstCnfInfo->ulLen);
if (VOS_NULL_PTR == pUsimMsg)
{
USIMM_ERROR_LOG("USIMM_SearchHandleCnf: VOS_AllocMsg is Failed");
return;
}
pUsimMsg->ulReceiverPid = ulReceiverPid;
pUsimMsg->ulMsgName = PS_USIM_SEARCH_CNF;
pUsimMsg->ulErrorCode = ulErrorCode;
pUsimMsg->usTotalRecNum = pstCnfInfo->usTotalRecNum;
pUsimMsg->usEfId = pstCnfInfo->usEfid;
pUsimMsg->ulResult = ulErrorCode;
pUsimMsg->ucLen = 0;
if ((VOS_NULL_PTR != pstCnfInfo->pucData) && (pstCnfInfo->ulLen <= 255))
{
VOS_MemCpy(pUsimMsg->aucContent, pstCnfInfo->pucData, pstCnfInfo->ulLen);
pUsimMsg->ucLen = (VOS_UINT8)pstCnfInfo->ulLen;
}
(VOS_VOID)VOS_SendMsg(pUsimMsg->ulSenderPid, pUsimMsg);
return;
}
VOS_VOID USIMM_PinHandleCnf(VOS_UINT32 ulReceiverPid,
USIMM_PIN_CMD_TYPE_ENUM_UINT32 enCmdType,
USIMM_PIN_TYPE_ENUM_UINT32 enPINType,
VOS_UINT32 ulResult,
USIMM_PIN_INFO_STRU *pstPINinfo)
{
PS_USIM_PIN_CNF_STRU *pUsimMsg;
pUsimMsg = (PS_USIM_PIN_CNF_STRU*)VOS_AllocMsg(WUEPS_PID_USIM, sizeof(PS_USIM_PIN_CNF_STRU)-VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pUsimMsg)
{
USIMM_ERROR_LOG("USIMM_PinHandleCnf: VOS_AllocMsg is Failed");
return;
}
pUsimMsg->ulReceiverPid = ulReceiverPid;
pUsimMsg->ulMsgName = PS_USIM_PIN_OPERATE_RSP;
pUsimMsg->ulResult = ulResult;
pUsimMsg->enCmdType = enCmdType;
pUsimMsg->enPinType = enPINType;
VOS_MemCpy(&pUsimMsg->stPinInfo, pstPINinfo, sizeof(USIMM_PIN_INFO_STRU));
(VOS_VOID)VOS_SendMsg(pUsimMsg->ulSenderPid, pUsimMsg);
return;
}
VOS_UINT32 diag_SendMsg(VOS_UINT32 ulSenderId, VOS_UINT32 ulRecverId, VOS_UINT32 ulMsgId, VOS_UINT8* pDta, VOS_UINT32 dtaSize)
{
VOS_UINT32 ret = ERR_MSP_UNKNOWN;
DIAG_DATA_MSG_STRU* pDataMsg = NULL;
/*lint -save -e740*/
pDataMsg = (DIAG_DATA_MSG_STRU*)VOS_AllocMsg(ulSenderId,(sizeof(DIAG_DATA_MSG_STRU)+ dtaSize - 20));
/*lint -restore*/
if (pDataMsg != NULL)
{
pDataMsg->ulReceiverPid = ulRecverId;
pDataMsg->ulSenderPid = ulSenderId;
pDataMsg->ulLength = sizeof(DIAG_DATA_MSG_STRU)+ dtaSize - 20;
pDataMsg->ulMsgId = ulMsgId;
pDataMsg->ulLen = dtaSize;
VOS_MemCpy(pDataMsg->pContext,pDta,dtaSize);
ret = VOS_SendMsg(ulSenderId, pDataMsg);
if (ret != VOS_OK)
{
diag_printf("diag_SendMsg ulSenderId=%d,ulRecverId=%d,ulMsgId=0x%x,pDta=%p,dtaSize=%d!\n",ulSenderId,ulRecverId,ulMsgId,pDta,dtaSize);
}
else
{
ret = ERR_MSP_SUCCESS;
}
}
return ret;
}
VOS_VOID USIMM_GetFileCnf(VOS_UINT32 ulReceiverPid,
VOS_UINT32 ulSendPara,
VOS_UINT32 ulErrorCode,
USIMM_GETCNF_INFO_STRU *pstCnfInfo)
{
PS_USIM_GET_FILE_CNF_STRU *pUsimMsg;
VOS_UINT32 ulResult;
if(ulErrorCode != USIMM_SW_OK)
{
ulResult = VOS_ERR;
}
else
{
ulResult = VOS_OK;
}
if( WUEPS_PID_OM == ulReceiverPid )
{
USIMM_OmFileCnf(ulResult,pstCnfInfo->usEfLen,pstCnfInfo->pucEf,USIMM_OM_GET_CNF);
return;
}
pUsimMsg = (PS_USIM_GET_FILE_CNF_STRU*)VOS_AllocMsg(WUEPS_PID_USIM, (sizeof(PS_USIM_GET_FILE_CNF_STRU)-VOS_MSG_HEAD_LENGTH)+pstCnfInfo->usDataLen);
if(VOS_NULL_PTR == pUsimMsg)
{
USIMM_ERROR_LOG("USIMM_GetFileCnf: VOS_AllocMsg is Failed");
return;
}
pUsimMsg->ulMsgName = PS_USIM_GET_FILE_RSP;
pUsimMsg->ulReceiverPid = ulReceiverPid;
pUsimMsg->ulErrorCode = ulErrorCode;
pUsimMsg->ulSendPara = ulSendPara;
pUsimMsg->usEfId = pstCnfInfo->usEfId;
if(USIMM_SW_OK == ulErrorCode)
{
pUsimMsg->ucRecordNum = pstCnfInfo->ucRecordNum;
pUsimMsg->usEfLen = pstCnfInfo->usEfLen;
pUsimMsg->ucTotalNum = pstCnfInfo->ucTotalNum;
pUsimMsg->ulResult = VOS_OK;
VOS_MemCpy(pUsimMsg->aucEf, pstCnfInfo->pucEf, pstCnfInfo->usDataLen);
}
else
{
pUsimMsg->ucRecordNum = 0;
pUsimMsg->usEfLen = 0;
pUsimMsg->ucTotalNum = 0;
pUsimMsg->ulResult = VOS_ERR;
}
(VOS_VOID)VOS_SendMsg(pUsimMsg->ulSenderPid, pUsimMsg);
return;
}
VOS_UINT32 diag_SendPsTransMsg(VOS_UINT32 ulRecverId, VOS_UINT8* pDta, VOS_UINT32 dtaSize)
{
VOS_UINT32 ret = ERR_MSP_UNKNOWN;
DIAG_PS_MSG_STRU* pDataMsg = NULL;
/*传进来的dtaSize已经包含了VOS HEADER，因此申请时需要-20*/
/*lint -save -e740*/
pDataMsg = (DIAG_PS_MSG_STRU*)VOS_AllocMsg(diag_GetAgentPid(),dtaSize -VOS_MSG_HEAD_LENGTH);
/*lint -restore*/
if (pDataMsg)
{
VOS_MemCpy(pDataMsg,pDta,dtaSize);
pDataMsg->ulReceiverPid = ulRecverId;
pDataMsg->ulSenderPid = diag_GetAgentPid();
/* coverity[overflow_const] */
pDataMsg->ulLength = dtaSize - VOS_MSG_HEAD_LENGTH;
ret = VOS_SendMsg(diag_GetAgentPid(), pDataMsg);
if (ret != VOS_OK)
{
diag_printf(" ulRecverId=%d,pDta=%p,dtaSize=%d!\n",ulRecverId,pDta,dtaSize);
}
else
{
ret = ERR_MSP_SUCCESS;
}
}
return ret;
}
/*****************************************************************************
函 数 名 : at_ftm_ltcommcmd_set
功能描述 : ID_MSG_FTM_SET_LTCOMMCMD_REQ 处理函数
进行LTE频段切换
输入参数 : 无
输出参数 : 无
返 回 值 : 成功返回ERR_MSP_SUCCESS, 否则返回其他结果
*****************************************************************************/
VOS_UINT32 at_ftm_ltcommcmd_set(VOS_VOID* pParam)
{
/*lint -save -e813*/
FTM_SET_LTCOMMCMD_CNF_STRU stCnf = { 0 };
FTM_SET_LTCOMMCMD_REQ_STRU* pstFtmReq = (FTM_SET_LTCOMMCMD_REQ_STRU*)pParam;
OM_PHY_COMM_CMD_SET_REQ_STRU stReqToDsp = { 0 };
/*lint -restore*/
VOS_UINT32 ulRet = ERR_MSP_SUCCESS;
VOS_UINT32 i = 0;
VOS_MemSet(&ftm_GetMainInfo()->stRdLtCommCmdCnf, 0, sizeof(FTM_RD_LTCOMMCMD_CNF_STRU));
ftm_GetMainInfo()->stRdLtCommCmdCnf.ulErrCode = ERR_MSP_SUCCESS;
stReqToDsp.ulMsgId = OM_PHY_COMM_CMD_SET_REQ;
stReqToDsp.ulDataLen = pstFtmReq->ulDataLen;
VOS_MemCpy(stReqToDsp.cData, pstFtmReq->cData, stReqToDsp.ulDataLen);
vos_printf("at_ftm_ltcommcmd_set: 1\n");
for(i=0; i<pstFtmReq->ulDataLen; i++)
{
if(i%10 == 0)
{
vos_printf("\n");
}
vos_printf("%02X", stReqToDsp.cData[i]);
}
vos_printf("\n");
switch(pstFtmReq->ulCmdDest)
{
case EN_LTCOMMCMD_DEST_LDSP_CT:
ulRet = ftm_mailbox_ltect_write(&stReqToDsp, sizeof(OM_PHY_COMM_CMD_SET_REQ_STRU));
break;
case EN_LTCOMMCMD_DEST_LDSP_BT:
ulRet = ftm_mailbox_ltebt_write(&stReqToDsp, sizeof(OM_PHY_COMM_CMD_SET_REQ_STRU));
break;
case EN_LTCOMMCMD_DEST_TDSP_CT:
ulRet = ftm_mailbox_tdsct_write(&stReqToDsp, sizeof(OM_PHY_COMM_CMD_SET_REQ_STRU));
break;
case EN_LTCOMMCMD_DEST_TDSP_BT:
ulRet = ftm_mailbox_tdsbt_write(&stReqToDsp, sizeof(OM_PHY_COMM_CMD_SET_REQ_STRU));
break;
default:
ulRet = ERR_MSP_FAILURE;
}
if (ERR_MSP_SUCCESS != ulRet)
{
stCnf.ulErrCode = ERR_MSP_UNKNOWN;
stCnf.ulDataLen = 0;
return ftm_comm_send(ID_MSG_FTM_SET_LTCOMMCMD_CNF,
(VOS_UINT32)&stCnf, sizeof(FTM_SET_LTCOMMCMD_CNF_STRU));
}
return ERR_MSP_WAIT_ASYNC;
}
VOS_UINT32 diag_AgentCnfFun(VOS_UINT8* pstCmdCnf,VOS_UINT32 ulCmdId,VOS_UINT32 ulDataSize )
{
DIAG_CMD_AGENT_TO_FW_CNF_STRU* pstCnf = NULL;
VOS_UINT32 ret = ERR_MSP_SUCCESS;
VOS_UINT32 ulSendSize =0;
ulSendSize = sizeof(DIAG_CMD_AGENT_TO_FW_CNF_STRU)+ ulDataSize;
pstCnf = VOS_MemAlloc(diag_GetAgentPid(),DYNAMIC_MEM_PT,ulSendSize);
if(NULL != pstCnf)
{
pstCnf->ulCmdId = ulCmdId;
VOS_MemCpy(pstCnf->aucData, pstCmdCnf, ulDataSize);
/*lint -save -e40*/
#if(VOS_OS_VER == VOS_LINUX)
ret = diag_SendMsg(diag_GetAgentPid(),MSP_PID_DIAG_FW,ID_MSG_DIAG_CMD_CNF_APP_AGENT_TO_FW,\
(VOS_UINT8*)pstCnf,ulSendSize);
#else
ret = diag_SendMsg(diag_GetAgentPid(),MSP_PID_DIAG_FW,ID_MSG_DIAG_CMD_CNF_AGENT_TO_FW,\
(VOS_UINT8*)pstCnf,ulSendSize);
#endif
/*lint -restore +e40*/
VOS_MemFree(diag_GetAgentPid(), pstCnf);
return ret;
}
else
{
diag_printf("[%s]: malloc fail!\n",__FUNCTION__);
return ERR_MSP_MALLOC_FAILUE;
}
}
VOS_VOID USIMM_AccessChannelCnf(VOS_UINT32 ulReceiverPid,
VOS_UINT32 ulResult,
VOS_UINT32 ulErrCode,
USIMM_ACCESS_CHANNEL_CNF_STRU *pstDataCnf)
{
PS_USIM_ACCESS_CHANNEL_CNF_STRU *pstUsimMsg = VOS_NULL_PTR;
pstUsimMsg = (PS_USIM_ACCESS_CHANNEL_CNF_STRU *)VOS_AllocMsg(WUEPS_PID_USIM,
sizeof(PS_USIM_ACCESS_CHANNEL_CNF_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstUsimMsg)
{
USIMM_ERROR_LOG("USIMM_AccessChannelCnf: VOS_AllocMsg is Failed");
return;
}
pstUsimMsg->ulReceiverPid = ulReceiverPid;
pstUsimMsg->ulMsgName = PS_USIMM_ACCESSCHANNEL_CNF;
pstUsimMsg->ulResult = ulResult;
pstUsimMsg->ulErrCode = ulErrCode;
pstUsimMsg->ucSw1 = pstDataCnf->ucSw1;
pstUsimMsg->ucSw2 = pstDataCnf->ucSw2;
pstUsimMsg->usLen = pstDataCnf->usDataLen;
if (VOS_NULL != pstDataCnf->usDataLen)
{
VOS_MemCpy(pstUsimMsg->aucContent, pstDataCnf->pucData, pstDataCnf->usDataLen);
}
(VOS_VOID)VOS_SendMsg(pstUsimMsg->ulSenderPid, pstUsimMsg);
return;
}
VOS_VOID OM_RecordInfoStart(VOS_EXC_DUMP_MEM_NUM_ENUM_UINT32 enNumber, VOS_UINT32 ulSendPid, VOS_UINT32 ulRcvPid, VOS_UINT32 ulMsgName)
{
OM_RECORD_INFO_STRU stRecordInfo;
if(VOS_EXC_DUMP_MEM_NUM_BUTT <= enNumber)
{
return;
}
if(VOS_NULL_PTR == g_astRecordInfo[enNumber].pucBuf)
{
return;
}
g_astRecordInfo[enNumber].ulLen %= VOS_TASK_DUMP_INFO_SIZE;
stRecordInfo.usSendPid = (VOS_UINT16)ulSendPid;
stRecordInfo.usRcvPid = (VOS_UINT16)ulRcvPid;
stRecordInfo.ulMsgName = ulMsgName;
stRecordInfo.ulSliceStart = VOS_GetSlice();
stRecordInfo.ulSliceEnd = 0;
/*lint -e534*/
VOS_MemCpy((g_astRecordInfo[enNumber].pucBuf + g_astRecordInfo[enNumber].ulLen),
&stRecordInfo, sizeof(OM_RECORD_INFO_STRU));
/*lint +e534*/
g_astRecordInfo[enNumber].ulLen += sizeof(OM_RECORD_INFO_STRU);
return;
}
VOS_UINT32 CBT_SendData(CBT_UNIFORM_MSG_STRU * pucMsg, VOS_UINT16 usMsgLen)
{
CBT_CTOA_MSG_STRU *pstCbtMsg;
/* 链路未建立 */
if (CBT_STATE_IDLE == g_ulCbtSwitchOnOff)
{
/* 记录可维可测信息 */
return VOS_ERR;
}
/* 将消息发到A核OM处理 */
pstCbtMsg = (CBT_CTOA_MSG_STRU *)VOS_AllocMsg(CCPU_PID_CBT, usMsgLen + 2*sizeof(VOS_UINT16));
if (VOS_NULL_PTR == pstCbtMsg)
{
return VOS_ERR;
}
pstCbtMsg->ulReceiverPid = ACPU_PID_CBT;
pstCbtMsg->usPrimId = CBT_CCPU_TO_ACPU_SEND_DATA_REQ;
pstCbtMsg->usLen = usMsgLen;
/*lint -e534*/
VOS_MemCpy(pstCbtMsg->aucData, pucMsg, usMsgLen);
/*lint +e534*/
return VOS_SendMsg(CCPU_PID_CBT, pstCbtMsg);
}
VOS_UINT32 SI_PB_FdnNumCheck(VOS_UINT32 ulPid, VOS_UINT32 ulContextIndex,VOS_UINT32 ulSendPara, PS_PB_FDN_NUM_STRU *pstFdnInfo)
{
SI_PB_FDN_CHECK_REQ_STRU *pstFDNCheckReq;
/*参数检查*/
if (VOS_NULL_PTR == pstFdnInfo)
{
PB_ERROR_LOG("SI_PB_FdnNumCheck: fdn num is null.\r\n");
return VOS_ERR;
}
pstFDNCheckReq = (SI_PB_FDN_CHECK_REQ_STRU*)VOS_AllocMsg(ulPid, sizeof(SI_PB_FDN_CHECK_REQ_STRU)-VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstFDNCheckReq)
{
PB_ERROR_LOG("SI_PB_FdnNumCheck: alloc msg failed.\r\n");
return VOS_ERR;
}
/*拷贝号码*/
VOS_MemCpy(&pstFDNCheckReq->stFDNNum, pstFdnInfo, sizeof(PS_PB_FDN_NUM_STRU));
pstFDNCheckReq->ulReceiverPid = MAPS_PB_PID;
pstFDNCheckReq->ulMsgName = SI_PB_FDN_CHECK_REQ;
pstFDNCheckReq->ulSendPara = ulSendPara;
pstFDNCheckReq->ulContextIndex = ulContextIndex;
(VOS_VOID)VOS_SendMsg(ulPid, pstFDNCheckReq);
return VOS_OK;
}
SI_UINT32 SI_PB_Modify( MN_CLIENT_ID_T ClientId,
MN_OPERATION_ID_T OpId,
SI_PB_STORATE_TYPE Storage,
SI_PB_RECORD_STRU *pRecord )
{
SI_PB_MODIFY_REP_STRU *pMsg;
VOS_UINT32 ulReceiverPid;
if (VOS_OK != SI_PB_GetReceiverPid(ClientId, &ulReceiverPid))
{
PB_ERROR_LOG("SI_PB_Modify:Get ulReceiverPid Error.");
return TAF_FAILURE;
}
if(VOS_NULL_PTR == pRecord)
{
PB_ERROR_LOG("SI_PB_Modify:pRecord is a NULL pointer");
return TAF_FAILURE;
}
pMsg = (SI_PB_MODIFY_REP_STRU *)VOS_AllocMsg(WUEPS_PID_AT, sizeof(SI_PB_MODIFY_REP_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pMsg)
{
PB_ERROR_LOG("SI_PB_Modify:VOS_AllocMsg Failed");
return TAF_FAILURE;
}
pMsg->ulReceiverPid = ulReceiverPid;
pMsg->ulMsgName = SI_PB_MODIFY_REQ;
pMsg->usClient = ClientId;
pMsg->ucOpID = OpId;
#if( FEATURE_MULTI_MODEM == FEATURE_ON )
pMsg->ulStorage = SI_PB_STORAGE_FD; /*只能够操作FDN号码*/
#else
if(SI_PB_STORAGE_UNSPECIFIED == Storage)
{
pMsg->ulStorage = gstPBCtrlInfo.enPBCurType;
}
else
{
pMsg->ulStorage = Storage;
}
#endif
VOS_MemCpy(&pMsg->Record, pRecord, sizeof(SI_PB_RECORD_STRU));
if(VOS_OK != VOS_SendMsg(WUEPS_PID_AT, pMsg))
{
PB_ERROR_LOG("SI_PB_Modify:VOS_SendMsg Failed");
return TAF_FAILURE;
}
return TAF_SUCCESS;
}
VOS_UINT32 SI_STK_CLSndTrMsg(
VOS_UINT32 ulDataLen,
VOS_UINT8 *pucData)
{
SI_STK_REQ_STRU *pstSTKReq;
pstSTKReq = (SI_STK_REQ_STRU *)VOS_AllocMsg(MAPS_STK_PID, sizeof(SI_STK_REQ_STRU) - VOS_MSG_HEAD_LENGTH + ulDataLen);
if (VOS_NULL_PTR == pstSTKReq)
{
STK_ERROR_LOG("SI_STK_CLSndTrMsg: VOS_AllocMsg Return Error");
return VOS_ERR;
}
pstSTKReq->MsgName = SI_STK_VIA_TRDOWN;
pstSTKReq->ulReceiverPid = MAPS_STK_PID;
pstSTKReq->OpId = 0;
pstSTKReq->ClientId = 0;
pstSTKReq->SatType = SI_STK_TRSEND;
pstSTKReq->Datalen = ulDataLen;
if (VOS_NULL != ulDataLen)
{
/*lint -e534*/
VOS_MemCpy(pstSTKReq->Data, pucData, ulDataLen);
/*lint +e534*/
}
if (VOS_OK != VOS_SendMsg(MAPS_STK_PID, pstSTKReq))
{
return VOS_ERR;
}
return VOS_OK;
}
VOS_UINT32 AT_RcvImsaMtStateInd(VOS_VOID * pMsg)
{
/* 定义局部变量 */
IMSA_AT_MT_STATES_IND_STRU *pstMtStatusInd;
VOS_UINT8 ucIndex;
VOS_CHAR acString[AT_IMSA_CALL_ASCII_NUM_MAX_LENGTH + 1];
/* 初始化消息变量 */
ucIndex = 0;
pstMtStatusInd = (IMSA_AT_MT_STATES_IND_STRU*)pMsg;
/* 通过ClientId获取ucIndex */
if ( AT_FAILURE == At_ClientIdToUserId(pstMtStatusInd->usClientId, &ucIndex) )
{
AT_WARN_LOG("AT_RcvImsaImpuSetCnf: WARNING:AT INDEX NOT FOUND!");
return VOS_ERR;
}
VOS_MemSet(acString, 0, sizeof(acString));
VOS_MemCpy(acString, pstMtStatusInd->aucAsciiCallNum, AT_IMSA_CALL_ASCII_NUM_MAX_LENGTH);
gstAtSendData.usBufLen= (VOS_UINT16)At_sprintf(AT_CMD_MAX_LEN,
(VOS_CHAR *)pgucAtSndCodeAddr,
(VOS_CHAR *)pgucAtSndCodeAddr,
"%s^IMSMTRPT: %s,%d,%d%s",
gaucAtCrLf,
acString,
pstMtStatusInd->ucMtStatus,
pstMtStatusInd->ulCauseCode,
gaucAtCrLf);
/* 调用At_SendResultData发送命令结果 */
At_SendResultData(ucIndex, pgucAtSndCodeAddr, gstAtSendData.usBufLen);
return VOS_OK;
}
SI_UINT32 SI_PB_SAdd( MN_CLIENT_ID_T ClientId,
MN_OPERATION_ID_T OpId,
SI_PB_STORATE_TYPE Storage,
SI_PB_RECORD_STRU *pRecord)
{
#if (( FEATURE_MULTI_MODEM == FEATURE_ON )&&(!defined(DMT)))
return TAF_FAILURE;
#else
SI_PB_ADD_REP_STRU *pMsg;
if(VOS_NULL_PTR == pRecord)
{
PB_ERROR_LOG("SI_PB_Add:pRecord is a NULL pointer");
return TAF_FAILURE;
}
/*lint -e433 修改人: j00174725; 检视人: xucheng */
pMsg = (SI_PB_ADD_REP_STRU *)VOS_AllocMsg(WUEPS_PID_AT, sizeof(SI_PB_ADD_REP_STRU) - VOS_MSG_HEAD_LENGTH);
/*lint +e433 修改人: j00174725; 检视人: xucheng */
if (VOS_NULL_PTR == pMsg)
{
PB_ERROR_LOG("SI_PB_Add:VOS_AllocMsg Failed");
return TAF_FAILURE;
}
pMsg->ulReceiverPid = MAPS_PB_PID;
pMsg->ulMsgName = SI_PB_SADD_REQ;
pMsg->usClient = ClientId;
pMsg->ucOpID = OpId;
if(SI_PB_STORAGE_UNSPECIFIED == Storage)
{
pMsg->ulStorage = gstPBCtrlInfo.enPBCurType;
}
else
{
pMsg->ulStorage = Storage;
}
pRecord->Index = 1;
VOS_MemCpy(&pMsg->stRecord, pRecord, sizeof(SI_PB_RECORD_STRU));
if(VOS_OK != VOS_SendMsg(WUEPS_PID_AT, pMsg))
{
PB_ERROR_LOG("SI_PB_Add:VOS_SendMsg Failed");
return TAF_FAILURE;
}
return TAF_SUCCESS;
#endif
}
VOS_UINT32 SI_STK_EnvelopeData_Code(
SI_STK_ENVELOPE_STRU *pstENStru,
VOS_UINT32 *pulDataLen,
VOS_UINT8 *pucData,
VOS_UINT32 *pulDataOffset)
{
if((pstENStru == VOS_NULL_PTR)
||(pulDataLen == VOS_NULL_PTR)
||(pucData == VOS_NULL_PTR)
||(pulDataOffset == VOS_NULL_PTR))
{
STK_ERROR_LOG("SI_STK_EnvelopeData_Code: The Input Data is Error");
return VOS_ERR;
}
SI_STK_InitEnvelope(pucData, &pstENStru->DeviceId, (VOS_UINT8)pstENStru->enEnvelopeType);
if (pstENStru->enEnvelopeType == SI_STK_ENVELOPE_CALLCRTL)
{
if(pstENStru->uEnvelope.CallCtrl.OP_SepcialData != 0)
{
pucData[2] += pstENStru->uEnvelope.CallCtrl.SpecialData.ucLen+2;
pucData[7] = pstENStru->uEnvelope.CallCtrl.SpecialData.ucTag;
pucData[8] = pstENStru->uEnvelope.CallCtrl.SpecialData.ucLen;
/*lint -e534*/
VOS_MemCpy(&pucData[9], pstENStru->uEnvelope.CallCtrl.SpecialData.pValue, pstENStru->uEnvelope.CallCtrl.SpecialData.ucLen);
/*lint +e534*/
}
}
if(VOS_OK != SI_STKCommCodeData(&pucData[1], SI_CODE_ENVELOPE_DATA, pstENStru->enEnvelopeType, (SI_SAT_COMMDATA_STRU*)pstENStru))
{
STK_ERROR_LOG("SI_STK_EnvelopeData_Code: The Code Data is Error");
return VOS_ERR;
}
if(pucData[2] > 0x7F)
{
pucData[1] = 0x81;
*pulDataLen = pucData[2] + 3;
*pulDataOffset = 0;
}
else
{
*pulDataLen = pucData[2] + 2;
*pulDataOffset = 1;
}
return VOS_OK;
}
VOS_VOID USIMM_CardStatusInd(VOS_UINT32 ulReceiverPid,
USIMM_CARD_TYPE_ENUM_UINT32 enCardType,
USIMM_CARD_SERVIC_ENUM_UINT32 enCardStatus)
{
PS_USIM_STATUS_IND_STRU *pUsimMsg = VOS_NULL_PTR;
VOS_UINT32 ulResult;
VOS_UINT32 ulFileNum;
VOS_UINT8 *pucIMSI = VOS_NULL_PTR;
if(USIMM_CARD_SERVIC_AVAILABLE == enCardStatus)
{
ulResult = USIMM_PoolFindFile(EFIMSI, &ulFileNum, USIMM_UNLIMIT_APP);
if(VOS_OK == ulResult)
{
pucIMSI = gstUSIMMPOOL.astpoolRecord[ulFileNum].pucContent;
}
}
pUsimMsg = (PS_USIM_STATUS_IND_STRU *)VOS_AllocMsg(WUEPS_PID_USIM, sizeof(PS_USIM_STATUS_IND_STRU)-VOS_MSG_HEAD_LENGTH);
if( VOS_NULL_PTR == pUsimMsg )
{
USIMM_ERROR_LOG("USIMM_CardStatusInd: VOS_AllocMsg is Failed");
return;
}
pUsimMsg->ulReceiverPid = ulReceiverPid;
pUsimMsg->ulMsgName = PS_USIM_GET_STATUS_IND; /* 设置消息名称 */
pUsimMsg->enCardType = enCardType;
pUsimMsg->enCardStatus = enCardStatus;
if(VOS_NULL_PTR != pucIMSI)
{
VOS_MemCpy(pUsimMsg->aucIMSI, pucIMSI, sizeof(pUsimMsg->aucIMSI));
pUsimMsg->ucIMSILen = sizeof(pUsimMsg->aucIMSI);
}
else
{
pUsimMsg->ucIMSILen = VOS_NULL;
}
(VOS_VOID)VOS_SendMsg(pUsimMsg->ulSenderPid, pUsimMsg);
if(USIMM_CARD_SERVIC_AVAILABLE != enCardStatus) /*卡状态不是有卡，保存数据*/
{
USIMM_SaveLogFile();
}
g_stUSIMMLogData.enLogState = USIMM_NO_NEED_LOG;/*上报卡状态就不需要记录log*/
return;
}
VOS_UINT32 SI_PIH_HvsDHSet(MN_CLIENT_ID_T ClientId,
MN_OPERATION_ID_T OpId,
VSIM_KEYDATA_STRU *pstSKey)
{
SI_PIH_HVSDH_SET_REQ_STRU *pstMsg;
VOS_UINT32 ulMsgLen;
VOS_UINT32 ulReceiverPid;
/* 参数检测 */
if(VOS_NULL_PTR == pstSKey)
{
PIH_ERROR_LOG("SI_PIH_HvsDHSet: Para is Error");
return TAF_FAILURE;
}
if ((VOS_NULL == pstSKey->ulKeyLen) || (VSIM_KEYLEN_MAX < pstSKey->ulKeyLen))
{
PIH_ERROR_LOG("SI_PIH_HvsDHSet: Data Len is Error");
return TAF_FAILURE;
}
if (VOS_OK != SI_PIH_GetReceiverPid(ClientId, &ulReceiverPid))
{
PIH_ERROR_LOG("SI_PIH_HvsDHSet:Get ulReceiverPid Error.");
return TAF_FAILURE;
}
/* 由于SI_PIH_HVSDH_SET_REQ_STRU中aucData字段多余，需要减去sizeof(VOS_UINT32) */
ulMsgLen = sizeof(SI_PIH_HVSDH_SET_REQ_STRU) - VOS_MSG_HEAD_LENGTH - sizeof(VOS_UINT32) + pstSKey->ulKeyLen;
pstMsg = (SI_PIH_HVSDH_SET_REQ_STRU*)VOS_AllocMsg(WUEPS_PID_AT, ulMsgLen);
if (VOS_NULL_PTR == pstMsg)
{
PIH_WARNING_LOG("SI_PIH_HvsDHSet: AllocMsg FAILED");
return TAF_FAILURE;
}
pstMsg->stMsgHeader.ulReceiverPid = ulReceiverPid;
pstMsg->stMsgHeader.ulMsgName = SI_PIH_HVSDH_SET_REQ;
pstMsg->stMsgHeader.usClient = ClientId;
pstMsg->stMsgHeader.ucOpID = OpId;
pstMsg->stMsgHeader.ulEventType = SI_PIH_EVENT_HVSDH_SET_CNF;
pstMsg->ulDataLen = pstSKey->ulKeyLen;
VOS_MemCpy(pstMsg->aucData, pstSKey->aucKey, pstSKey->ulKeyLen);
if(VOS_OK != VOS_SendMsg(WUEPS_PID_AT, pstMsg))
{
PIH_WARNING_LOG("SI_PIH_HvsDHSet:WARNING SendMsg FAILED");
return TAF_FAILURE;
}
return TAF_SUCCESS;
}
SI_UINT32 SI_PIH_CchoSetReq(
MN_CLIENT_ID_T ClientId,
MN_OPERATION_ID_T OpId,
SI_PIH_CCHO_COMMAND_STRU *pstCchoCmd)
{
SI_PIH_CCHO_SET_REQ_STRU *pstMsg;
VOS_UINT32 ulReceiverPid;
/* 参数检测 */
if ((0 == pstCchoCmd->ulAIDLen)
|| ((USIMM_AID_LEN_MAX*2) < pstCchoCmd->ulAIDLen))
{
PIH_ERROR_LOG("SI_PIH_CchoSetReq: AID length is incorrect.");
return TAF_FAILURE;
}
if (VOS_OK != SI_PIH_GetReceiverPid(ClientId, &ulReceiverPid))
{
PIH_ERROR_LOG("SI_PIH_CchoSetReq:Get ulReceiverPid Error.");
return TAF_FAILURE;
}
/* 分配消息内存 */
pstMsg = (SI_PIH_CCHO_SET_REQ_STRU*)VOS_AllocMsg(WUEPS_PID_AT, sizeof(SI_PIH_CCHO_SET_REQ_STRU) - VOS_MSG_HEAD_LENGTH);
if (VOS_NULL_PTR == pstMsg)
{
PIH_WARNING_LOG("SI_PIH_CchoSetReq: AllocMsg FAILED");
return TAF_FAILURE;
}
pstMsg->stMsgHeader.ulReceiverPid = ulReceiverPid;
pstMsg->stMsgHeader.ulMsgName = SI_PIH_CCHO_SET_REQ;
pstMsg->stMsgHeader.usClient = ClientId;
pstMsg->stMsgHeader.ucOpID = OpId;
pstMsg->stMsgHeader.ulEventType = SI_PIH_EVENT_CCHO_SET_CNF;
pstMsg->ulAIDLen = pstCchoCmd->ulAIDLen;
VOS_MemCpy(pstMsg->aucADFName, pstCchoCmd->pucADFName, pstCchoCmd->ulAIDLen);
if (VOS_OK != VOS_SendMsg(WUEPS_PID_AT, pstMsg))
{
PIH_WARNING_LOG("SI_PIH_CchoSetReq:WARNING SendMsg FAILED");
return TAF_FAILURE;
}
return TAF_SUCCESS;
}
/*****************************************************************************
函 数 名 : at_ftm_ltcommcmd_dspind
功能描述 : DSP原语PHY_OM_COMM_CMD_IND处理函数
输入参数 : pParam PHY_OM_COMM_CMD_IND_STRU指针
输出参数 : 无
返 回 值 : 成功返回ERR_MSP_SUCCESS, 否则返回其他结果
*****************************************************************************/
VOS_UINT32 at_ftm_ltcommcmd_dspind(VOS_VOID* pParam)
{
PHY_OM_COMM_CMD_IND_STRU* pDspInd = (PHY_OM_COMM_CMD_IND_STRU*)pParam;
FTM_RD_LTCOMMCMD_CNF_STRU* pstFtmCnf = (FTM_RD_LTCOMMCMD_CNF_STRU *)&ftm_GetMainInfo()->stRdLtCommCmdCnf;
VOS_MemSet(pstFtmCnf, 0, sizeof(FTM_RD_LTCOMMCMD_CNF_STRU));
pstFtmCnf->ulErrCode = ERR_MSP_SUCCESS;
pstFtmCnf->ulDataLen = pDspInd->ulDataLen;
VOS_MemCpy(pstFtmCnf->cData, pDspInd->cData, pstFtmCnf->ulDataLen);
return ERR_MSP_SUCCESS;
}
