/*lint -e438 -e429*/
BST_UINT32 BST_SRV_CEvent::RcvTimerExpired ( BST_OS_TIMERID_T ulTimerId )
{
BST_TIMER_EVT_STRU *pstSendTimerEvent;
if( BST_NULL_PTR == m_pstEventMbx )
{
return BST_ERR_INVALID_PTR;
}
pstSendTimerEvent = ( BST_TIMER_EVT_STRU *)BST_OS_MALLOC
( BST_OS_SIZEOF(BST_TIMER_EVT_STRU) );
BST_ASSERT_NULL_RTN( pstSendTimerEvent, BST_ERR_NO_MEMORY );
pstSendTimerEvent->pucData = ( BST_UINT8 *)BST_OS_MALLOC
( BST_OS_SIZEOF(ulTimerId) );
if ( BST_NULL_PTR == pstSendTimerEvent->pucData )
{
BST_OS_FREE( pstSendTimerEvent );
return BST_ERR_NO_MEMORY;
}
pstSendTimerEvent->ulLength = BST_OS_SIZEOF( ulTimerId );
BST_OS_MEMCPY( pstSendTimerEvent->pucData, &ulTimerId, pstSendTimerEvent->ulLength );
pstSendTimerEvent->enId = BST_SRV_TIMER_EVENT;
return BST_OS_SendMail( m_pstEventMbx, pstSendTimerEvent );
}
BST_ERR_ENUM_UINT8 BST_CORE_CNPTask::ConfigedPriodic(
BST_UINT16 usLen,
const BST_VOID *const pData,
BST_UINT8 **pucNewAddr )
{
BST_UINT32 ulTimerTicks;
BST_ERR_ENUM_UINT8 ucRtnVal;
if ( usLen < BST_OS_SIZEOF ( BST_UINT32 ) )
{
BST_RLS_LOG1( "BST_CORE_CNPTask::ConfigedPriodic usLen=%u",
usLen );
return BST_ERR_PAR_LEN;
}
BST_OS_MEMCPY( &ulTimerTicks, pData, BST_OS_SIZEOF(BST_UINT32) );
ucRtnVal = ConfigCycleTicks ( ulTimerTicks );
if ( ucRtnVal == BST_NO_ERROR_MSG )
{
*pucNewAddr = ( BST_UINT8 * )&m_ulCycle;
BST_SetConfigFlag ( BST_CFGFLG_CYCL );
}
else
{
*pucNewAddr = BST_NULL_PTR;
}
return ucRtnVal;
}
/*lint -e438 -e429*/
BST_ERR_ENUM_UINT8 BST_SRV_CEvent::RcvTcpIpEvent ( BST_IP_EVENT_STRU *pstEvent )
{
BST_NET_EVENT_STRU *pstNetEvent;
BST_IP_EVENT_STRU *pstLwipEvent;
if ( BST_NULL_PTR == m_pstEventMbx )
{
return BST_ERR_INVALID_PTR;
}
if ( BST_NULL_PTR == pstEvent )
{
return BST_ERR_INVALID_PTR;
}
pstLwipEvent = ( BST_IP_EVENT_STRU *)BST_OS_MALLOC
( BST_OS_SIZEOF ( BST_IP_EVENT_STRU ) );
BST_ASSERT_NULL_RTN( pstLwipEvent, BST_ERR_NO_MEMORY );
pstNetEvent = ( BST_NET_EVENT_STRU *)BST_OS_MALLOC
( BST_OS_SIZEOF ( BST_NET_EVENT_STRU ) );
if ( BST_NULL_PTR == pstNetEvent )
{
BST_OS_FREE( pstLwipEvent );
return BST_ERR_INVALID_PTR;
}
BST_OS_MEMCPY ( pstLwipEvent, pstEvent, BST_OS_SIZEOF ( BST_IP_EVENT_STRU ) );
pstNetEvent->enId = BST_SRV_TCPIP_EVENT;
pstNetEvent->pucData = ( BST_UINT8 * )pstLwipEvent;
pstNetEvent->ulLength = BST_OS_SIZEOF ( BST_IP_EVENT_STRU );
return BST_OS_SendMail( m_pstEventMbx, pstNetEvent );
}
BST_IP_ERR_T BST_IP_BsdTcpClone( BST_FD_T fd, BST_IP_SOCKET_ADD_T *pAddr )
{
struct sockaddr_in stRemoteAddr;
if( !BST_IP_IsBsdFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
if( BST_NULL_PTR == pAddr )
{
return BST_IP_ERR_MEM;
}
stRemoteAddr.sin_len = BST_OS_SIZEOF(stRemoteAddr);
stRemoteAddr.sin_family = AF_INET;
stRemoteAddr.sin_port = pAddr->usRemotePort;
BST_IP_GetU32Addr( stRemoteAddr.sin_addr.s_addr,
pAddr->aucRemoteIp[3],
pAddr->aucRemoteIp[2],
pAddr->aucRemoteIp[1],
pAddr->aucRemoteIp[0] );
return (BST_IP_ERR_T)lwip_cloneconnect( fd.lFd,
(struct sockaddr*)&stRemoteAddr,
BST_OS_SIZEOF(stRemoteAddr) );
}
BST_CORE_CNPTask::BST_CORE_CNPTask(
BST_PROCID_T in_usProcId,
BST_TASKID_T in_usTaskId ) :BST_CORE_CPTask ( in_usProcId, in_usTaskId )
{
BST_CORE_CRegedit *pcRegedit;
BST_APP_CMainTask *pcMainTask;
pcRegedit = BST_CORE_CRegedit::GetInstance();
pcMainTask = BST_APP_CMainTask::GetInstance();
BST_ASSERT_NULL( pcRegedit );
m_CfgedFlag = BST_CFGFLG_NONE;
m_pExptReport = new BST_DSPP_CReport ( in_usProcId, in_usTaskId );
#if( BST_VER_TYPE == BST_DBG_VER )
m_pSocket = new BST_IP_CSocket ( in_usProcId, in_usTaskId );
#else
m_pSocket = new BST_IP_CSocket();
#endif
m_ProtolType = BST_PRTC_TYPE_INVALID;
pcRegedit->Regist ( this, this, BST_PID_PERIODIC, BST_OS_SIZEOF ( BST_TICK_T ),
BST_NULL_PTR);
pcRegedit->Regist ( this, this, BST_PID_PROTOCOL_TYPE, BST_OS_SIZEOF ( BST_SCKT_TYPE_ENUM_UINT32 ),
BST_NULL_PTR );
pcRegedit->Regist ( this, this, BST_PID_SOCKET_INFO, BST_OS_SIZEOF ( BST_IP_SOCKET_ADD_T ),
BST_NULL_PTR );
pcRegedit->Regist ( this, this, BST_PID_SOCKET_PROPERTY, BST_OS_SIZEOF ( BST_IP_SKT_PROPTY_STRU),
BST_NULL_PTR ) ;
pcRegedit->Regist ( this, this, BST_PID_TRAFFIC_FLOW, BST_OS_SIZEOF ( BST_IP_TRAFFIC_FLOW_STRU),
BST_NULL_PTR );/*注册EMAIL流量查询*/
if ( BST_NULL_PTR != pcMainTask )
{
pcMainTask->Attach( this );
}
}
BST_UINT16 BST_CORE_CNPTask::InquiredSocketProperty(
BST_UINT16 usDataSize,
BST_VOID *const pData )
{
BST_IP_ERR_T enIpErr;
BST_DBG_LOG ( " BST_CORE_CNPTask::InquiredSocketProperty Enter.");
if ( usDataSize < BST_OS_SIZEOF ( BST_IP_SKT_PROPTY_STRU ) )
{
BST_RLS_LOG1 ( "BST_CORE_CNPTask::InquiredSocketProperty usDataSize=%d",
usDataSize );
return BST_CORE_INVALID_INQUIRED_LEN;
}
Stop();
enIpErr = m_pSocket->IoCtrl ( BST_SCKT_CMD_GET_PROPERTY, pData );
BST_ResetPrptyFlag();
( BST_VOID )PidInquired ( BST_PID_SOCKET_PROPERTY, usDataSize, pData );
if ( BST_IP_ERR_OK == enIpErr )
{
return ( BST_OS_SIZEOF ( BST_IP_SKT_PROPTY_STRU ) );
}
else
{
return BST_CORE_INVALID_INQUIRED_LEN;
}
}
BST_VOID BST_SYS_MntnTrigReport( BST_VOID )
{
OM_BST_MSG_STRU *pstBstOmIndMsg;
OM_BST_AGENT_APP_NUM_STRU *pstBstAppNum;
BST_UINT32 ulRslt;
BST_UINT32 ulLength;
BST_UINT16 usAppNum;
OM_BST_APP_INFO_STRU *pstAppInfo;
ulRslt = BST_TRUE;
/* 申请的大小等于消息头BST_OM_MSG_STRU -4个字节的指针占位 + 实际代理信息大小 */
usAppNum = (BST_UINT16)BST_SYS_MNTN_GetAppNumber();
ulLength = (BST_OS_SIZEOF(OM_BST_MSG_STRU) - 4)
+ (BST_OS_SIZEOF(OM_BST_AGENT_APP_NUM_STRU));
pstBstOmIndMsg = (OM_BST_MSG_STRU *)BST_SYS_MntnGetSendExternalMsgBuffAddr(UEPS_PID_BASTET, ulLength);
if (BST_NULL_PTR == pstBstOmIndMsg)
{
BST_DBG_LOG1("BST_SYS_MntnTrigReport, Agent Info Msg Alloc Mem Fail",
0);
return;
}
/* 填写消息头 */
BST_SYS_MntnFillBstOmMsgHead( pstBstOmIndMsg,
ulLength,
ID_BST_OM_AGENT_INFO_IND,
0 );
pstBstAppNum = (OM_BST_AGENT_APP_NUM_STRU *)(pstBstOmIndMsg->aucData);
pstBstAppNum->usAgentAppNum = usAppNum;
pstAppInfo = ( (OM_BST_APP_INFO_STRU *)(pstBstAppNum->stBstAppList ) );
ulRslt = BST_SYS_MntnBuildAgentInfoInd( pstAppInfo, usAppNum );
if (BST_TRUE != ulRslt)
{
BST_DBG_LOG1("BST_SYS_MntnTrigReport, Get Bst Agent Info Error: ulRslt",
ulRslt);
return;
}
/* 发送IND消息 */
ulRslt = OM_SendData( (OM_RSP_PACKET_STRU *)pstBstOmIndMsg, (BST_UINT16)ulLength );
/* 释放传入的消息包 */
BST_FREE_MSG( UEPS_PID_BASTET, pstBstOmIndMsg );
if (VOS_OK != ulRslt)
{
BST_RLS_LOG1( "[Mntn] Send Maintain Message Fail:", ulRslt );
return;
}
BST_RLS_LOG( "[Mntn] Send Maintain Message Success" );
return;
}
BST_VOID BST_CTaskSchdler::AsEventCallback(
BST_AS_EVT_ENUM_UINT32 enEvent,
BST_UINT32 ulLength,
BST_VOID *pvData )
{
BST_UINT32 ulPara;
switch( enEvent )
{
/*
* 仅处理RRC状态信息，当RRC连接成功时，查看当前剩余时间是否靠近
*/
case BST_AS_EVT_L3_RRC_STATE:
if ( BST_OS_SIZEOF(ulPara) != ulLength )
{
break;
}
if ( BST_NULL_PTR == pvData )
{
break;
}
BST_OS_MEMCPY( &ulPara, pvData, ulLength );
if( BST_AS_RRC_CONNECTED == ulPara )
{
ulPara = BST_OS_TimerIsStop( m_ulTimerId );
if ( BST_TRUE == ulPara )
{
break;
}
ulPara = BST_OS_TimeGetRemain( m_ulTimerId );
if ( 0 == ulPara )
{
break;
}
ulPara = NearRrcTrig ( ulPara );
BST_OS_TimerStart( m_ulTimerId, ulPara );
}
break;
case BST_AS_EVT_L3_BLOCK_INFO:
if ( BST_OS_SIZEOF(BST_UINT32) != ulLength )
{
BST_RLS_LOG1("BST_CTaskSchdler::AsEventCallback Error blockinfo Length = %u:", ulLength );
break;
}
UtranBlockInfoChgProc( (BST_UINT32 *)pvData );
break;
default:
break;
}
}
BST_UINT32 BST_PAL_NetApiPacketRcved( const BST_UINT8 *pData, const BST_UINT32 ulLen )
{
BST_OS_LOCKCNT_T tThreadLockCnt;
BST_PAL_NET_ENTITY_STRU *pstBstNetEntity;
pstBstNetEntity = BST_PAL_NetGetEntity();
/*入参判断*/
if ( ulLen != BST_OS_SIZEOF(TTF_MEM_ST) )
{
BST_RLS_LOG( "BST_EnQueueOtaData: Wrong Size" );
return 0;
}
if ( BST_NULL_PTR == pData )
{
BST_RLS_LOG( "BST_EnQueueOtaData: NULL pData" );
return 0;
}
/*入队*/
tThreadLockCnt = BST_OS_ThreadLock();
if ( PS_SUCC != LUP_EnQue( pstBstNetEntity->pstDlDataQue,
(BST_VOID *)pData ) )
{
BST_PAL_NetApiPacketFree( (BST_VOID *)pData );
BST_OS_ThreadUnLock( tThreadLockCnt );
BST_RLS_LOG( "BST_EnQueueOtaData: EnQueue Fail" );
return 0;
}
BST_OS_ThreadUnLock( tThreadLockCnt );
/*wakeup cds*/
BST_SYS_ApiSndEvtToBastet( BST_CDS_EVENT_RCV_DL_PROC );
return ulLen;
}
/*lint -e438 -e429*/
BST_ERR_ENUM_UINT8 BST_SRV_CEvent::RcvAcomData( BST_UINT32 ulLength, BST_UINT8 *pucData )
{
BST_ACOM_EVT_STRU *pstAcpuEvent;
if( BST_NULL_PTR == m_pstEventMbx )
{
return BST_ERR_INVALID_PTR;
}
if( BST_NULL_PTR == pucData )
{
return BST_ERR_INVALID_PTR;
}
if( 0 == ulLength )
{
return BST_ERR_PAR_LEN;
}
pstAcpuEvent = (BST_ACOM_EVT_STRU *)BST_OS_MALLOC( BST_OS_SIZEOF(BST_ACOM_EVT_STRU) );
BST_ASSERT_NULL_RTN( pstAcpuEvent, BST_ERR_NO_MEMORY );
pstAcpuEvent->pucData = (BST_UINT8 *)BST_OS_MALLOC( ulLength );
if ( BST_NULL_PTR == pstAcpuEvent->pucData )
{
BST_OS_FREE( pstAcpuEvent );
return BST_ERR_NO_MEMORY;
}
pstAcpuEvent->enId = BST_SRV_ACOM_EVENT;
pstAcpuEvent->ulLength = ulLength;
BST_OS_MEMCPY( pstAcpuEvent->pucData, pucData, ulLength );
return BST_OS_SendMail( m_pstEventMbx, pstAcpuEvent );
}
BST_ERR_ENUM_UINT8 BST_CORE_CNPTask::ReportTrafficFlow( BST_VOID )
{
BST_ERR_ENUM_UINT8 enRtnVal;
BST_IP_ERR_T enIpErr;
BST_IP_TRAFFIC_FLOW_STRU stSktTrFlow;
enRtnVal = BST_ERR_UNREACHABLE;
stSktTrFlow.ulRxByte = 0;
stSktTrFlow.ulTxByte = 0;
enIpErr = m_pSocket->IoCtrl ( BST_SCKT_CMD_GET_TRAFFIC_FLOW,
&stSktTrFlow );
if ( BST_IP_ERR_OK == enIpErr )
{
if( ( 0 != stSktTrFlow.ulRxByte ) || ( 0 != stSktTrFlow.ulTxByte ) )
{
enRtnVal = m_pExptReport->Report ( BST_PID_TRAFFIC_FLOW,
BST_OS_SIZEOF ( BST_IP_TRAFFIC_FLOW_STRU ),
&stSktTrFlow );
}
if ( BST_NO_ERROR_MSG == enRtnVal )
{
return enRtnVal;
}
}
BST_RLS_LOG2( "BST_CORE_CNPTask::Report Traffic Flow, Ip_Err =%u, Rpt_Err=%u",\
enIpErr, enRtnVal );
return BST_ERR_UNREACHABLE;
}
BST_IP_ERR_T BST_IP_BsdSocket( BST_FD_T *pfd, BST_ARG_T *Arg, BST_UINT16 usProtocol )
{
BST_UINT32 ulTimeout;
ulTimeout = BST_IP_RX_TIME_OUT;
if( BST_NULL_PTR == pfd )
{
return BST_IP_ERR_ARG;
}
switch( usProtocol )
{
case BST_IP_PROTOCOL_UDP:
pfd->lFd = lwip_socket( AF_INET, SOCK_DGRAM, 0 );
break;
case BST_IP_PROTOCOL_TCP:
pfd->lFd = lwip_socket( AF_INET, SOCK_STREAM, 0 ); //TCP对应SOCK_STREAM
break;
default :
pfd->lFd = BST_IP_ERR_MEM;
return BST_IP_ERR_ARG;
}
if( BST_IP_IsBsdFdValid( (*pfd) ) )
{
if ( 0 == lwip_setsockopt( pfd->lFd, SOL_SOCKET, SO_RCVTIMEO, &ulTimeout, BST_OS_SIZEOF( ulTimeout ) ) )
{
return BST_IP_ERR_OK;
}
return BST_IP_ERR_VAL;
}
else
{
return BST_IP_ERR_MEM;
}
}
BST_OS_SEM_STRU *BST_OS_CreateSem( BST_VOID *pvArg, BST_UINT32 ulInitCnt )
{
BST_OS_SEM_STRU *pstOsSem;
BST_OS_LOCKCNT_T tThreadLockCnt;
pstOsSem = (BST_OS_SEM_STRU *)BST_OS_MALLOC( BST_OS_SIZEOF( BST_OS_SEM_STRU ) );
if( BST_NULL_PTR == pstOsSem )
{
return BST_NULL_PTR;
}
tThreadLockCnt = BST_OS_ThreadLock();
pstOsSem->pvArg = BST_OS_GetCurrentThreadId();
pstOsSem->stHandle = BST_OS_PalCreateSem( ulInitCnt );
if ( BST_OS_SYS_IsSemValid(pstOsSem->stHandle) )
{
BST_OS_FREE( pstOsSem );
BST_OS_ThreadUnLock( tThreadLockCnt );
/*lint -e438*/
return BST_NULL_PTR;
/*lint +e438*/
}
#ifdef BST_OS_SIGNAL_COUNTER
pstOsSem->ulCounter = ulInitCnt;
if ( 0U != pstOsSem->ulCounter )
{
BST_OS_PalSendSem( pstOsSem->stHandle, pstOsSem->pvArg );
}
#endif
BST_OS_ThreadUnLock( tThreadLockCnt );
return pstOsSem;
}
BST_IP_ERR_T BST_IP_BsdBind( BST_FD_T fd, BST_UINT16 usPort )
{
struct sockaddr_in stLocalAddr;
if( !BST_IP_IsBsdFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
stLocalAddr.sin_len = BST_OS_SIZEOF(stLocalAddr);
stLocalAddr.sin_family = AF_INET;
stLocalAddr.sin_port = PP_HTONS( usPort );
stLocalAddr.sin_addr.s_addr = BST_IP_ADDRESS_ANY;
return (BST_IP_ERR_T)lwip_bind( fd.lFd, ( struct sockaddr *)&stLocalAddr, BST_OS_SIZEOF(stLocalAddr) );
}
BST_VOID BST_PAL_NetMsgEntry( MsgBlock *pstMsg )
{
BST_UINT32 ulTrsFlg;
if ( BST_NULL_PTR == pstMsg )
{
BST_RLS_LOG( "BST_PAL_NetMsgEntry : Input NULL PTR." );
return;
}
BST_RLS_LOG1( "BST_PAL_NetMsgEntry : MsgId", TTF_GET_MSG_NAME(pstMsg) );
switch( TTF_GET_MSG_NAME(pstMsg) )
{
/* CDS发给BASTET的消息原语: 有其他IP包在运行中 */
case ID_BST_CDS_TX_RX_IND:
ulTrsFlg = BST_TRUE;
BST_PalAsEventRcvCb( BST_AS_EVT_L3_AP_TRS_RCV_IND,
( BST_UINT16 )BST_OS_SIZEOF(ulTrsFlg),
&ulTrsFlg );
break;
/* CDS发给BASTET的消息原语: 当前MODEM数据业务使用的MODEM ID*/
case ID_BST_CDS_CHANNEL_INFO_IND:
BST_PAL_NetMsgCfgCallBack( (const BST_CDS_SEND_CB_INFO_STRU *)pstMsg );
break;
default:
BST_RLS_LOG( "BST_PAL_NetMsgEntry : Unknown Message." );
break;
}
return;
}
BST_VOID BST_SYS_MntnAddTask(
BST_UINT16 usType,
BST_UINT16 usTaskId )
{
BST_SYS_MNTN_APP_NODE_STRU *pstAppInfoNode;
BST_OS_LOCKCNT_T tThreadLockCnt;
if ( !BST_SYS_MNTN_IsMntnInited() )
{
return;
}
if ( (BST_UINT32)BST_SYS_MNTN_GetAppNumber() >= BST_SYS_MNTN_MAX_APP_NUMBER )
{
return;
}
tThreadLockCnt = BST_OS_ThreadLock();
if ( BST_NULL_PTR != BST_SYS_MntnSrchAppByTask( usType, usTaskId ) )
{
BST_OS_ThreadUnLock( tThreadLockCnt );
return;
}
pstAppInfoNode = ( BST_SYS_MNTN_APP_NODE_STRU *)BST_OS_MALLOC
( BST_OS_SIZEOF(BST_SYS_MNTN_APP_NODE_STRU) );
if ( BST_NULL_PTR == pstAppInfoNode )
{
BST_OS_ThreadUnLock( tThreadLockCnt );
return;
}
BST_OS_MEMSET( &(pstAppInfoNode->stAppInfo),
0,
BST_OS_SIZEOF(OM_BST_APP_INFO_STRU) );
pstAppInfoNode->stAppInfo.usAppType = usType;
pstAppInfoNode->stAppInfo.usTaskId = usTaskId;
lstAdd( BST_SYS_MNTN_GetAppListHead(), (NODE *)pstAppInfoNode );
BST_RLS_LOG3( "[Mntn] Add Task: TypeId=, TaskId=, Total=",
usType, usTaskId, BST_SYS_MNTN_GetAppNumber() );
BST_SYS_MntnChangedInd();
BST_OS_ThreadUnLock( tThreadLockCnt );
/*lint -e429*/
}
BST_INT32 RAND_poll( BST_VOID )
{
BST_UINT32 ulRnd;
BST_UINT32 i;
ulRnd = 0;
BST_UINT8 ucBuf[ENTROPY_NEEDED];
for ( i = 0; i < BST_OS_SIZEOF(ucBuf); i++ )
{
if ( 0 == (i % 4) )
{
ulRnd = VOS_Rand(0xff);/*此处调用rtos平台的随机数生成函数*/
}
ucBuf[i] = ulRnd;
ulRnd >>= 8;
}
RAND_add( ucBuf, BST_OS_SIZEOF(ucBuf), (double)ENTROPY_NEEDED );
BST_OS_MEMSET( ucBuf, 0, BST_OS_SIZEOF(ucBuf) );
return 1;
}
VOS_VOID BST_SYS_MsgProcEntry( MsgBlock *pstMsg )
{
if(BST_FALSE == BST_SYS_ApiGetSupported())
{
BST_DBG_LOG("BST_SYS_MsgProcEntry: bastet nv disabled");
return;
}
switch(pstMsg->ulSenderPid)
{
case WUEPS_PID_USIM:
break;
case VOS_PID_TIMER:
BST_DBG_LOG("BST_SYS_MsgProcEntry: VOS_PID_TIMER");
BST_OS_PalTimerCallBack();
break;
case ACPU_PID_BASTET_COMM:
BST_DBG_LOG("BST_SYS_MsgProcEntry: ACPU_PID_BASTET_COMM");
BST_Pal_DrvAcomRecv( ( BST_UINT32 ) BST_OS_SIZEOF( BST_ACOM_MSG_STRU ),
( BST_UINT8 *) pstMsg );
break;
case UEPS_PID_CDS:
BST_DBG_LOG("BST_SYS_MsgProcEntry: UEPS_PID_CDS");
OM_TraceMsgHook(pstMsg);
BST_PAL_NetMsgEntry( pstMsg );
break;
case I0_WUEPS_PID_MMA:
OM_TraceMsgHook(pstMsg);
BST_MSG_ProcMmaRecv(pstMsg,BST_MODEM_ID_1);
break;
case I1_WUEPS_PID_MMA:
OM_TraceMsgHook(pstMsg);
BST_MSG_ProcMmaRecv(pstMsg,BST_MODEM_ID_2);
break;
case WUEPS_PID_WRR:
OM_TraceMsgHook(pstMsg);
BST_MSG_ProcWrrcRecv(pstMsg);
break;
case TPS_PID_RRC:
OM_TraceMsgHook(pstMsg);
BST_MSG_ProcTrrcRecv(pstMsg);
break;
case PS_PID_ERRC:
OM_TraceMsgHook(pstMsg);
BST_MSG_ProcLrrcRecv(pstMsg);
break;
default:
break;
}
}
BST_ERR_ENUM_UINT8 BST_CORE_CNPTask::ConfigedSockeInfo(
BST_UINT16 usLen,
const BST_VOID *const pData,
BST_UINT8 **pucNewAddr )
{
BST_IP_ERR_T enIpErrMsg;
BST_ERR_ENUM_UINT8 ucRtnVal;
if ( usLen < BST_OS_SIZEOF ( BST_IP_SOCKET_ADD_T ) )
{
BST_RLS_LOG1( "BST_CORE_CNPTask::ConfigedPriodic usLen=%u",
usLen );
return BST_ERR_PAR_LEN;
}
if ( !BST_IP_IsValidIpAddress( ( BST_IP_SOCKET_ADD_T * )pData ) )
{
Report( BST_TRAFFIC_FLOW_REPORT );
}
enIpErrMsg = m_pSocket->IoCtrl ( BST_SCKT_CMD_SET_ADDRESS,
( BST_VOID *)pData );
BST_DBG_UPDATE_IP_INFO( m_usProcId, m_usTaskId, (( BST_IP_SOCKET_ADD_T * )pData) );
if ( BST_IP_ERR_OK == enIpErrMsg )
{
enIpErrMsg = m_pSocket->IoCtrl ( BST_SCKT_CMD_GET_ADDRPTR,
( BST_VOID *)pucNewAddr );
if ( BST_IP_ERR_OK == enIpErrMsg )
{
if ( BST_IP_IsValidIpAddress( ( BST_IP_SOCKET_ADD_T * )( *pucNewAddr ) ) )
{
BST_SetConfigFlag ( BST_CFGFLG_ADDR );
}
else
{
/* 清除Config， 防止Socket进行Clone，并挂起任务 */
BST_UnsetConfigFlag ( BST_CFGFLG_ADDR );
Suspend();
}
ucRtnVal = BST_NO_ERROR_MSG;
}
else
{
BST_UnsetConfigFlag ( BST_CFGFLG_ADDR );
ucRtnVal = BST_ERR_ILLEGAL_PARAM;
}
}
else
{
ucRtnVal = BST_ERR_ILLEGAL_PARAM;
}
return ucRtnVal;
}
inline BST_BOOL CheckIfEcryOrDecry ( BST_CORE_PID_ENUM_UINT16 enPid )
{
BST_UINT32 i;
for ( i = 0; i < BST_OS_SIZEOF ( g_enEncrypterParamTable ); i++ )
{
if ( enPid == g_enEncrypterParamTable[i] )
{
return BST_TRUE;
}
}
return BST_FALSE;
}
/*lint -e429*/
BST_VOID BST_CTaskSchdler::Attach ( BST_CORE_CPTask *pC_PTask )
{
BST_CORE_PTASK_NODE_STRU *pstPtaskNode;
if ( !BST_OS_IsTimerValid (m_ulTimerId) )
{
BST_RLS_LOG1( "BST_CTaskSchdler::Attach m_ulTimerId=%u is invalid",
m_ulTimerId );
return;
}
if ( BST_NULL_PTR == pC_PTask )
{
BST_RLS_LOG( "BST_CTaskSchdler::Attach pC_PTask=NULL" );
return;
}
for ( pstPtaskNode = (BST_CORE_PTASK_NODE_STRU *)lstFirst( &g_stPTaskList );
pstPtaskNode!= BST_NULL_PTR;
pstPtaskNode = (BST_CORE_PTASK_NODE_STRU *)lstNext((NODE *)pstPtaskNode) )
{
if( pstPtaskNode->pcTask == pC_PTask )
{
return;
}
}
/*
* 申请链表节点资源，用于存储任务
*/
pstPtaskNode = ( BST_CORE_PTASK_NODE_STRU *)BST_OS_MALLOC
( BST_OS_SIZEOF( BST_CORE_PTASK_NODE_STRU ) );
if( BST_NULL_PTR == pstPtaskNode )
{
BST_RLS_LOG( "BST_CTaskSchdler::Attach pstPtaskNode=NULL" );
return;
}
/*
* 初始化任务数据，添加如任务列表
*/
pC_PTask->m_ulSuspCounter = 0;
pstPtaskNode->pcTask = pC_PTask;
lstAdd( &g_stPTaskList, (NODE *)pstPtaskNode );
/*
* 如果此时系统TICK定时已经关闭，且PS域服务状态正常，那么需要再次启动定时
*/
if( BST_TRUE == BST_OS_TimerIsStop( m_ulTimerId ) )
{
m_ulSystemTick = 0;
BST_OS_TimerStart ( m_ulTimerId, BST_TASK_SYS_BASE_TIMELEN );
BST_DBG_LOG1( "BST_CTaskSchdler::Attach Start Scheduler Timer:%u",
BST_TASK_SYS_BASE_TIMELEN );
}
}
BST_UINT32 BST_PAL_NetApiPacketPppRcvd( BST_UINT32 ulLength,
BST_UINT8 *pucData )
{
if( BST_NULL_PTR == pucData )
{
return 0x00U;
}
if( BST_OS_SIZEOF( TTF_MEM_ST )!= ulLength )
{
return 0x00U;
}
BST_PAL_NetApiPacketFree( pucData );
return ulLength;
}
BST_UINT16 BST_CORE_CNPTask::InquiredTrafficFlow(
BST_UINT16 usDataSize,
BST_VOID *const pData )
{
BST_IP_ERR_T enIpErr;
BST_DBG_LOG( "BST_CORE_CNPTask::InquiredTrafficFlow email traffic flow info");
if ( usDataSize < BST_OS_SIZEOF ( BST_IP_TRAFFIC_FLOW_STRU ) )
{
BST_RLS_LOG1( "BST_CORE_CNPTask::InquiredTrafficFlow usDataSize=%u",
usDataSize );
return BST_CORE_INVALID_INQUIRED_LEN;
}
enIpErr = m_pSocket->IoCtrl ( BST_SCKT_CMD_GET_TRAFFIC_FLOW, pData );
( BST_VOID )PidInquired ( BST_PID_TRAFFIC_FLOW, usDataSize, pData );
if ( BST_IP_ERR_OK == enIpErr )
{
return ( BST_OS_SIZEOF ( BST_IP_TRAFFIC_FLOW_STRU ) );
}
else
{
return BST_CORE_INVALID_INQUIRED_LEN;
}
}
BST_UINT32 BST_SRV_RcvTimerEvent( BST_OS_TIMERID_T ulTimerId )
{
BST_SRV_CEvent *pEvtProc;
BST_UINT32 ulRtnVal;
pEvtProc = BST_SRV_CEvent::GetInstance();
BST_ASSERT_NULL_RTN( pEvtProc, 0 );
ulRtnVal = pEvtProc->RcvTimerExpired( ulTimerId );
if( BST_NO_ERROR_MSG == ulRtnVal )
{
return BST_OS_SIZEOF(BST_OS_TIMER_STRU);
}
BST_RLS_LOG1( "BST_SRV_RcvTimerEvent pEvtProc->RcvTimerExpired Err=%u",
ulRtnVal );
return 0;
}
//lint -sem(lstAdd,custodial(2))
BST_ERR_ENUM_UINT8 BST_OS_SendMail( BST_OS_MBX_T *pstMbx, BST_VOID *pMsg )
{
BST_OS_MAIL_T *pstContent;
BST_OS_LOCKCNT_T tThreadLockCnt;
BST_ASSERT_NULL_RTN( pstMbx, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( pstMbx->hSem, BST_ERR_INVALID_PTR );
pstContent = BST_OS_MALLOC( BST_OS_SIZEOF(BST_OS_MAIL_T) );
BST_ASSERT_NULL_RTN( pstContent, BST_ERR_NO_MEMORY );
tThreadLockCnt = (BST_OS_LOCKCNT_T)BST_OS_SpinLock( &g_MboxLock );
pstContent->ulContent = pMsg;
lstAdd( &pstMbx->hList, ( NODE * )pstContent );
BST_OS_SpinUnLock( &g_MboxLock,(BST_UINT32)tThreadLockCnt );
BST_OS_SendSem( pstMbx->hSem );
return( BST_NO_ERROR_MSG );
}
/*lint -e438 -e429*/
BST_ERR_ENUM_UINT8 BST_SRV_CEvent::RcvAsEvent(
BST_AS_EVT_ENUM_UINT32 enAsEvent,
BST_UINT32 ulLength,
BST_VOID *pvData )
{
BST_AS_EVT_STRU *pstSendAsEvent;
if( BST_NULL_PTR == m_pstEventMbx )
{
return BST_ERR_INVALID_PTR;
}
if( !BST_SRV_IsValidAsEvent( enAsEvent ) )
{
return BST_ERR_INVALID_PTR;
}
pstSendAsEvent = (BST_AS_EVT_STRU *)BST_OS_MALLOC( BST_OS_SIZEOF(BST_AS_EVT_STRU) );
BST_ASSERT_NULL_RTN( pstSendAsEvent, BST_ERR_NO_MEMORY );
if( ( BST_NULL_PTR == pvData ) || ( 0 == ulLength ) )
{
pstSendAsEvent->pucData = BST_NULL_PTR;
pstSendAsEvent->ulLength = 0;
}
else
{
pstSendAsEvent->pucData = (BST_UINT8 *)BST_OS_MALLOC( ulLength );
if ( BST_NULL_PTR == pstSendAsEvent->pucData )
{
BST_RLS_LOG( "BST_SRV_CEvent::RcvAsEvent No Memory" );
BST_OS_FREE( pstSendAsEvent );
return BST_ERR_NO_MEMORY;
}
pstSendAsEvent->ulLength = ulLength;
BST_OS_MEMCPY( pstSendAsEvent->pucData, pvData, ulLength );
}
pstSendAsEvent->enId = BST_SRV_AS_EVENT;
pstSendAsEvent->enAsEvent = enAsEvent;
return BST_OS_SendMail( m_pstEventMbx, pstSendAsEvent );
}
BST_OS_MBX_T *BST_OS_CreateMbx( BST_VOID *pvArg, BST_UINT32 ulSize )
{
BST_OS_MBX_T *pstMbx;
pstMbx = BST_OS_MALLOC( BST_OS_SIZEOF(BST_OS_MBX_T) );
BST_ASSERT_NULL_RTN( pstMbx, BST_NULL_PTR );
pstMbx->hSem = BST_NULL_PTR;
lstInit( &pstMbx->hList );
pstMbx->hSem = BST_OS_CreateSem( pvArg, 0U );
if( BST_NULL_PTR == pstMbx->hSem )
{
BST_DBG_LOG("Create Mail Box Fail.\n");
lstFree( &pstMbx->hList );
BST_OS_FREE(pstMbx);
/*lint -e438*/
return BST_NULL_PTR;
/*lint +e438*/
}
return( pstMbx );
}
BST_ERR_ENUM_UINT8 BST_CORE_CNPTask::ReportNoneHb( BST_VOID )
{
BST_ERR_ENUM_UINT8 enRtnVal;
BST_IP_ERR_T enIpErr;
BST_IP_SKT_PROPTY_STRU stSktProperty;
enRtnVal = BST_ERR_UNREACHABLE;
enIpErr = m_pSocket->IoCtrl ( BST_SCKT_CMD_RPT_PROPERTY,
&stSktProperty );
if ( BST_IP_ERR_OK == enIpErr )
{
enRtnVal = m_pExptReport->Report ( BST_PID_SOCKET_PROPERTY,
BST_OS_SIZEOF ( BST_IP_SKT_PROPTY_STRU ),
&stSktProperty );
if ( BST_NO_ERROR_MSG == enRtnVal )
{
return enRtnVal;
}
}
BST_RLS_LOG2( "BST_CORE_CNPTask::Report Get Propery Error, Ip_Err =%u, Rpt_Err=%u",\
enIpErr, enRtnVal );
return BST_ERR_UNREACHABLE;
}
BST_ERR_ENUM_UINT8 BST_PAL_NetApiPacketResume( BST_VOID *pstItem )
{
BST_PAL_NET_ENTITY_STRU *pstBstNetEntity;
pstBstNetEntity = BST_PAL_NetGetEntity();
if ( BST_NULL_PTR == pstItem )
{
BST_RLS_LOG( "BST_PAL_NetApiPacketResume : Mst Pointer Is Null ." );
return BST_ERR_INVALID_PTR;
}
if ( BST_NULL_PTR == pstBstNetEntity->pfRsmItf )
{
BST_RLS_LOG( "BST_PAL_NetApiPacketResume : pfRsmItf Pointer Is Null ." );
return BST_ERR_INVALID_PTR;
}
if( 0 == pstBstNetEntity->pfRsmItf( (BST_UINT8 *)pstItem,
(BST_UINT16)BST_OS_SIZEOF (TTF_MEM_ST ) ) )
{
BST_PAL_NetApiPacketFree( pstItem );
return BST_ERR_ILLEGAL_PARAM;
}
return BST_NO_ERROR_MSG;
}
BST_UINT32 BST_SYS_MntnBuildAgentInfoInd(
OM_BST_APP_INFO_STRU *pstAgentInfo,
const BST_UINT16 usAppNumber )
{
BST_SYS_MNTN_APP_NODE_STRU *pstAppNode;
BST_UINT16 usAppCounter;
BST_OS_LOCKCNT_T tThreadLockCnt;
if ( BST_NULL_PTR == pstAgentInfo )
{
return BST_FALSE;
}
tThreadLockCnt = BST_OS_ThreadLock();
usAppCounter = 0;
/* 查找链表中是否已经存在该Task信息 */
for ( pstAppNode = ( BST_SYS_MNTN_APP_NODE_STRU *)lstFirst(BST_SYS_MNTN_GetAppListHead());
pstAppNode != BST_NULL_PTR;
pstAppNode = ( BST_SYS_MNTN_APP_NODE_STRU *)lstNext( (NODE *)pstAppNode ) )
{
if ( ID_BST_OM_TASK_TYPE_MAIN == pstAppNode->stAppInfo.usAppType )
{
continue;
}
BST_OS_MEMCPY( &pstAgentInfo[usAppCounter],
&(pstAppNode->stAppInfo),
BST_OS_SIZEOF(OM_BST_APP_INFO_STRU) );
usAppCounter++;
if ( usAppCounter >= usAppNumber )
{
break;
}
}
BST_OS_ThreadUnLock( tThreadLockCnt );
return BST_TRUE;
}
