BST_VOID BST_SRV_CHNL_Set_LinkProp(
BST_SRV_CHNL_LINK_STRU *pstChnlLink,
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_IP_ERR_T enIpErrMsg;
BST_ASSERT_NULL( pstChnlLink );
BST_ASSERT_NULL( pstPktItem );
BST_ASSERT_NULL( pstChnlLink->pcSocket );
enIpErrMsg = BST_IP_ERR_OK;
BST_DBG_LOG1("BST_SRV_CHNL_Set_LinkProp pstPktItem->ucPropType",
pstPktItem->ucPropType);
BST_DBG_LOG4("BST_SRV_CHNL_Set_LinkProp seq,ack,sndwnd,sndscale",
pstPktItem->stProp.ulSeqNum,
pstPktItem->stProp.ulAckNum,
pstPktItem->stProp.ulSndWnd,
pstPktItem->stProp.usSndWscale);
switch( pstPktItem->ucPropType )
{
case BST_IP_SKT_PROP_NONE: /* 0 没有property */
return;
case BST_IP_SKT_PROP_SEQNO: /* 1 只有seqno */
enIpErrMsg = pstChnlLink->pcSocket->IoCtrl
( BST_SCKT_CMD_SET_SEQNO,
( BST_VOID *)&(pstPktItem->stProp) );
break;
case BST_IP_SKT_PROP_SEQNO_TS: /* 2 只有seqno+timestamp */
enIpErrMsg = pstChnlLink->pcSocket->IoCtrl
( BST_SCKT_CMD_SET_SEQNO_TS,
( BST_VOID *)&(pstPktItem->stProp) );
break;
case BST_IP_SKT_PROP_TOTAL: /* 3 完整property */
if( BST_TRUE == pstChnlLink->ulIsPropSet )
{
enIpErrMsg = pstChnlLink->pcSocket->IoCtrl
( BST_SCKT_CMD_SET_SEQNO_TS,
( BST_VOID *)&(pstPktItem->stProp) );
break;
}
enIpErrMsg = pstChnlLink->pcSocket->IoCtrl
( BST_SCKT_CMD_DBL_PROPERTY,
( BST_VOID *)&(pstPktItem->stProp) );
if( BST_IP_ERR_OK == enIpErrMsg )
{
pstChnlLink->ulIsPropSet
= BST_TRUE;
}
break;
default: /*4 无效*/
return;
}
BST_DBG_LOG1( "BST_SRV_CHNL_Set_LinkProp enIpErrMsg=%d",
enIpErrMsg );
}
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_VOID BST_CTaskSchdler::TrigScheduleTask( BST_CORE_CPTask *pC_PTask)
{
BST_SRV_CTaskMng *pcTaskManager;
BST_TASK_STATE_ENUM_UINT8 enTaskState;
BST_UINT32 ulRemainTickNum;
pcTaskManager = BST_SRV_CTaskMng::GetInstance ();
BST_ASSERT_NULL( pcTaskManager );
/*
* 入口检查
*/
if ( BST_NULL_PTR == pC_PTask )
{
BST_RLS_LOG( "BST_CTaskSchdler::TrigScheduleTask pC_PTask=NULL" );
return;
}
/*
* 如果上次执行的事件尚未完成，本次不运行
*/
if ( BST_TRUE == pC_PTask->IsBusy () )
{
BST_RLS_LOG( "BST_CTaskSchdler::TrigScheduleTask pC_PTask Is Busy" );
return;
}
/*
* 如果系统TICK可以被任务周期整除，说明到了整数倍对齐时间
*/
enTaskState = pC_PTask->GetState ();
BST_DBG_LOG2( "BST_CTaskSchdler::TrigScheduleTask enTaskState:%d,m_ulTaskBlockState:%d",
enTaskState,pC_PTask->m_ulTaskBlockState );
switch ( enTaskState )
{
case BST_TASK_STATE_START:
if( BST_TASK_BLOCK_STATE_EXPIRED == pC_PTask->m_ulTaskBlockState )
{
Execute( pC_PTask );
ulRemainTickNum = pC_PTask->m_ulCycle - (m_ulSystemTick % pC_PTask->m_ulCycle);
if( ulRemainTickNum > BST_TASK_SYS_TICKS )
{
pC_PTask->m_ulTaskBlockState = BST_TASK_BLOCK_STATE_NORMAL;
}
else
{
pC_PTask->m_ulTaskBlockState = BST_TASK_BLOCK_STATE_IGNORE;
}
m_bTaskMissExec = BST_FALSE;
}
return;
default:
break;
}
}
BST_VOID BST_SRV_CHNL_Send_Suspend(
BST_SRV_CHNL_LINK_STRU *pstChnlLink,
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_ASSERT_NULL( pstChnlLink );
BST_ASSERT_NULL( pstPktItem );
BST_DBG_LOG1("BST_SRV_CHNL_Send_Suspend state",pstChnlLink->enState);
BST_SRV_Q_PushToTail( (BST_SRV_CHNL_Q **)&pstChnlLink->pUnsendList,
(BST_SRV_CHNL_Q *)pstPktItem );
if( BST_SRV_CHNL_STATE_RUN == pstChnlLink->enState )
{
pstChnlLink->ulRetryTimes = 0;
}
if( BST_OS_TimerIsStop( pstChnlLink->ulTimerId ) )
{
BST_OS_TimerStart( pstChnlLink->ulTimerId, BST_SRV_CHNL_RTX_INTERVAL );
}
}
BST_VOID BST_SRV_CHNL_Clear(
BST_SRV_CHNL_LINK_STRU *pstChnlLink )
{
BST_SRV_CHNL_SENT_STRU *pSentItem;
BST_SRV_CHNL_SENT_STRU *pSentItem2;
BST_SRV_CHNL_HEAD_STRU *pstPktItem;
BST_SRV_CHNL_HEAD_STRU *pstPktItem2;
BST_DRV_STRU *pNetDrvHandle;
BST_UINT8 ucUnused;
BST_UINT32 ulSpinlockCnt;
BST_ASSERT_NULL( pstChnlLink );
pstChnlLink->ulIsPropSet = BST_FALSE;
for(;;)
{
pSentItem = BST_SRV_Q_PeekHead(pstChnlLink->pSentList);
if( BST_NULL_PTR == pSentItem )
{
break;
}
if( BST_DSPP_FLG_LVLTYPE_HS == pSentItem->usProcLevel )
{
ulSpinlockCnt = BST_OS_SpinLock( &g_HighPriCntSpinLock );
if ( g_ulHighPriCnt > 0 )
{
g_ulHighPriCnt--;
if ( 0 == g_ulHighPriCnt )
{
pNetDrvHandle= BST_DRV_NetGetDvcHandle();
ucUnused = 0;
pNetDrvHandle->pfIoCtrl( BST_DRV_CMD_HPR_DATA_FINISH, (BST_VOID *)&ucUnused );
}
}
BST_OS_SpinUnLock( &g_HighPriCntSpinLock , ulSpinlockCnt );
}
BST_DBG_LOG1("BST_SRV_CHNL_Clear,g_ulHighPriCnt--",g_ulHighPriCnt);
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&pstChnlLink->pSentList,
(BST_SRV_CHNL_Q *)pSentItem,
(BST_SRV_CHNL_Q **)&pSentItem2 );
BST_OS_FREE( pSentItem );
}
for(;;)
{
pstPktItem = BST_SRV_Q_PeekHead(pstChnlLink->pUnsendList);
if( BST_NULL_PTR == pstPktItem )
{
break;
}
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&pstChnlLink->pUnsendList,
(BST_SRV_CHNL_Q *)pstPktItem,
(BST_SRV_CHNL_Q **)&pstPktItem2 );
BST_SRV_FreeIpBlock( pstPktItem );
}
}
BST_VOID BST_SRV_CHNL_InitLink(
BST_SRV_CHNL_LINK_STRU *pstChnlLink,
BST_IP_CSocket *pcSocket,
BST_OS_TIMERID_T ulTimerId )
{
BST_ASSERT_NULL( pcSocket );
BST_ASSERT_NULL( pstChnlLink );
BST_ASSERT_NORM( BST_OS_INVALID_TIMER_ID == ulTimerId );
pstChnlLink->enState = BST_SRV_CHNL_STATE_UN_INITED;
pstChnlLink->pNext = BST_NULL_PTR;
pstChnlLink->pSentList = BST_NULL_PTR;
pstChnlLink->pUnsendList = BST_NULL_PTR;
pstChnlLink->stLink.ulMainLinkId = 0;
pstChnlLink->stLink.ulAuxLinkId = 0;
pstChnlLink->ulRetryTimes = 0;
pstChnlLink->ulCurrentSeq = 0;
pstChnlLink->ulIsPropSet = BST_FALSE;
pstChnlLink->ulAddrType = BST_DSPP_FLG_ADDTYPE_VOID;
pstChnlLink->ulTimerId = ulTimerId;
pstChnlLink->pcSocket = pcSocket;
}
BST_VOID BST_SRV_CHNL_Close(
BST_SRV_CHNL_LINK_STRU *pstChnlLink )
{
BST_ASSERT_NULL( pstChnlLink );
BST_SRV_CHNL_Clear( pstChnlLink );
BST_DBG_LOG("BST_SRV_CHNL_Close");
pstChnlLink->ulIsPropSet = BST_FALSE;
if( BST_NULL_PTR != pstChnlLink->pcSocket )
{
pstChnlLink->pcSocket->CloneClose();
}
return;
}
BST_VOID BST_CTaskSchdler::ScheduleTask( BST_CORE_CPTask *pC_PTask )
{
BST_SRV_CTaskMng *pcTaskManager;
BST_TASK_STATE_ENUM_UINT8 enTaskState;
pcTaskManager = BST_SRV_CTaskMng::GetInstance ();
BST_ASSERT_NULL( pcTaskManager );
/*
* 入口检查
*/
if ( BST_NULL_PTR == pC_PTask )
{
BST_RLS_LOG( "BST_CTaskSchdler::ScheduleTask pC_PTask=NULL" );
return;
}
/*
* 如果上次执行的事件尚未完成，本次不运行
*/
if ( BST_TRUE == pC_PTask->IsBusy () )
{
BST_RLS_LOG( "BST_CTaskSchdler::ScheduleTask pC_PTask Is Busy" );
return;
}
/*
* 如果系统TICK可以被任务周期整除，说明到了整数倍对齐时间
*/
if ( 0 != m_ulSystemTick%pC_PTask->m_ulCycle )
{
return;
}
enTaskState = pC_PTask->GetState ();
BST_DBG_LOG3( "BST_CTaskSchdler::ScheduleTask enTaskState:%d,m_ulTaskBlockState:%d,m_ulBlockInfo:%d",
enTaskState, pC_PTask->m_ulTaskBlockState,m_ulBlockInfo);
switch ( enTaskState )
{
/*
* 如果任务停止，只设置suspendCounter为0，不做任何事情
*/
case BST_TASK_STATE_STOPED:
pC_PTask->m_ulSuspCounter = 0;
break;
/*
* 如果任务挂起超过最大限度，则立即删除之
*/
case BST_TASK_STATE_SUSPEND:
pC_PTask->m_ulSuspCounter ++;
if ( pC_PTask->m_ulSuspCounter >= BST_TASK_MAX_SYSPEND )
{
pcTaskManager->Remove ( pC_PTask->m_usProcId, pC_PTask->m_usTaskId );
}
break;
/*
* 如果认为处于运行态，则调度执行
*/
case BST_TASK_STATE_START:
switch(pC_PTask->m_ulTaskBlockState)
{
/*当前处于normal状态，在周期的整数倍时，如果当前为unblock状态，则执行任务
否则设置当前task的任务状态为expired
*/
case BST_TASK_BLOCK_STATE_NORMAL:
if( BST_AS_UNBLOCKED == m_ulBlockInfo )
{
Execute( pC_PTask );
}
else
{
pC_PTask->m_ulTaskBlockState = BST_TASK_BLOCK_STATE_EXPIRED;
m_bTaskMissExec = BST_TRUE;
}
break;
/*当前处于EXPIRED状态，如果恢复unblock状态，直接调度，该分支为异常保护分支*/
case BST_TASK_BLOCK_STATE_EXPIRED:
if( BST_AS_UNBLOCKED == m_ulBlockInfo )
{
Execute( pC_PTask );
pC_PTask->m_ulTaskBlockState = BST_TASK_BLOCK_STATE_NORMAL;
}
break;
default:
break;
}
break;
default:
break;
}
if(BST_TASK_BLOCK_STATE_IGNORE == pC_PTask->m_ulTaskBlockState)
{
pC_PTask->m_ulTaskBlockState = BST_TASK_BLOCK_STATE_NORMAL;
}
}
/*lint -e438*/
BST_VOID BST_IP_UdpRecvCB( BST_VOID *arg, struct udp_pcb *upcb, struct pbuf *p, BST_IPADDR_U32T *addr, BST_UINT16 port )
{
BST_UINT16 usCopyedLength;
BST_IP_CRcverMng *pcRcverMnger;
BST_IP_PKTPROC_MODE_ENUM enProcMode;
struct pbuf *q;
BST_UINT8 *pucSdu;
BST_FD_T FdTmp;
BST_OS_LOCKCNT_T tThreadLockCnt;
BST_ASSERT_NULL( addr );
BST_ASSERT_NULL( upcb );
BST_ASSERT_NULL( p );
tThreadLockCnt = BST_OS_ThreadLock();
FdTmp.pFd = upcb;
pucSdu = BST_NULL_PTR;
q = BST_NULL_PTR;
usCopyedLength = 0;
enProcMode = BST_IP_PKT_REMOVE_PROC;
pcRcverMnger = BST_IP_CRcverMng::GetInstance();
if( BST_NULL_PTR == pcRcverMnger )
{
BST_IP_UDP_RCVAPI_FREE();
}
if ( p->tot_len > 0 )
{
pucSdu = ( BST_UINT8 * )BST_OS_MALLOC( p->tot_len );
}
else
{
BST_IP_UDP_RCVAPI_FREE();
}
if ( BST_NULL_PTR == pucSdu )
{
BST_IP_UDP_RCVAPI_FREE();
}
q = p;
usCopyedLength = 0;
while ( BST_NULL_PTR != q )
{
if ( ( q->len > 0 ) && ( BST_NULL_PTR != q->payload )
&& ( q->len + usCopyedLength <= p->tot_len ) )
{
BST_OS_MEMCPY( pucSdu + usCopyedLength, q->payload, q->len );
}
else
{
break;
}
usCopyedLength += q->len;
q = q->next;
}
if ( usCopyedLength > 0 )
{
enProcMode = pcRcverMnger->PacketRcver( FdTmp,
( BST_UINT8 * )pucSdu,
usCopyedLength );
if( BST_IP_PKT_FORWARD_PROC == enProcMode )
{
BST_IP_ApiForwordPacket( (BST_IP_PKT_ID_T)p );
}
}
BST_OS_FREE( pucSdu );
BST_IP_UDP_RCVAPI_FREE();
}
BST_VOID BST_PAL_NetProcDlPacket( const TTF_MEM_ST *pstTtfPacket )
{
BST_IP_PKT_PROC_ENUM_INT8 enPktProcMode;
BST_UINT8 *pucTmpdata;
BST_UINT32 ulIsMalloced;
BST_UINT32 ulTotalBytes;
pucTmpdata = BST_NULL_PTR;
ulTotalBytes = 0x00U;
ulIsMalloced = BST_FALSE;
if ( BST_NULL_PTR == pstTtfPacket )
{
BST_RLS_LOG( "BST_PAL_NetProcDlPacket: pstTtfPacket Invalide" );
return;
}
if( ( 0 == pstTtfPacket->usUsed )
||( BST_NULL_PTR == pstTtfPacket->pData ) )
{
BST_RLS_LOG2( "BST_PAL_NetProcDlPacket: No Data tot=%u, used=%u, pData=%p",
pstTtfPacket->usUsed, pstTtfPacket->pData );
return;
}
ulTotalBytes = BST_PAL_NetApiPacketLen( (BST_VOID*)pstTtfPacket );
if ( BST_NULL_PTR == pstTtfPacket->pNext )
{
pucTmpdata = pstTtfPacket->pData;
ulIsMalloced = BST_FALSE;
}
else
{
pucTmpdata = (BST_UINT8 *)BST_OS_MALLOC( ulTotalBytes );
BST_ASSERT_NULL( pucTmpdata );
if( TTF_MemGet( UEPS_PID_BASTET, ( TTF_MEM_ST *)pstTtfPacket,
0U, pucTmpdata, (BST_UINT16)ulTotalBytes ) )
{
/*lint -e438*/
BST_OS_FREE( pucTmpdata );
return;
/*lint +e438*/
}
ulIsMalloced = BST_TRUE;
}
BST_DBG_LOG1( "BST_PAL_NetProcDlPacket: TolLen=%u", ulTotalBytes );
enPktProcMode = BST_IP_ApiFastCheckDL( pucTmpdata, ulTotalBytes );
if ( BST_IP_PKT_TO_AP == enPktProcMode)
{
BST_RLS_LOG( "BST_PAL_NetProcDlPacket: NOT Bastet Packet" );
BST_PAL_NetApiPacketResume( (BST_VOID*)pstTtfPacket );
}
else
{
if ( BST_IP_PKT_FREE == enPktProcMode )
{
BST_RLS_LOG( "BST_PAL_NetProcDlPacket: Free Packet" );
BST_PAL_NetApiPacketFree( (BST_VOID*)pstTtfPacket );
}
else
{
BST_RLS_LOG1( "BST_PAL_NetProcDlPacket: Bastet Packet, Length=", ulTotalBytes );
if ( ulTotalBytes != BST_PAL_NetIpStackInput( ulTotalBytes, pucTmpdata, pstTtfPacket ) )
{
BST_RLS_LOG( "BST_PAL_NetProcDlPacket: BST_PAL_NetIpStackInput Error" );
BST_PAL_NetApiPacketFree( (BST_VOID*)pstTtfPacket );
}
}
}
if ( BST_TRUE == ulIsMalloced )
{
BST_OS_FREE( pucTmpdata );
}
/*lint -e429 -e438 */
} /*pucTmpdata 是否free需要判断ulIsMalloced，如果指针不是Malloc的，则不需FREE*/
BST_VOID BST_SRV_CEvent::RcvThread( BST_VOID *pvArg )
{
BST_OS_MBX_T **pstMailBox;
BST_EVT_HEAD_STRU *pstEvtMsg;
BST_AS_EVT_STRU *pstAsEvt;
BST_ACOM_EVT_STRU *pstAcomEvt;
BST_TIMER_EVT_STRU *pstTimerEvt;
BST_NET_EVENT_STRU *pstNetEvt;
BST_DSPP_CTrsDlVa *pcTrslayer;
BST_SRV_CAsEvt *pcAsMng;
BST_OS_TIMERID_T ulTimerId;
BST_UINT32 ulRtnVal;
BST_ASSERT_NULL( pvArg );
pstMailBox = (BST_OS_MBX_T **)pvArg;
*pstMailBox = BST_OS_CreateMbx( BST_OS_GetCurrentThreadId(), BST_M_MBOX_SIZE );
BST_ASSERT_NULL( *pstMailBox );
BST_SetThreadInitFlag( BST_MAIN_THREAD_FLAG );
for (;;)
{
ulRtnVal = BST_OS_RecvMail( *pstMailBox, (BST_VOID **)&pstEvtMsg, BST_OS_SYS_FOREVER );
if( BST_OS_SYS_TIMEOUT == ulRtnVal )
{
continue;
}
if( BST_NULL_PTR == pstEvtMsg )
{
continue;
}
BST_DBG_LOG1( "BST_SRV_CEvent::RcvThread pstEvtMsg->enId=%d",
pstEvtMsg->enId );
switch( pstEvtMsg->enId )
{
case BST_SRV_ACOM_EVENT:
pcTrslayer = BST_DSPP_CTrsDlVa::GetInstance();
if ( BST_NULL_PTR == pcTrslayer )
{
break;
}
pstAcomEvt = (BST_ACOM_EVT_STRU *)pstEvtMsg;
pcTrslayer->RxApi( pstAcomEvt->pucData, (BST_UINT16)pstAcomEvt->ulLength );
break;
case BST_SRV_AS_EVENT:
pcAsMng = BST_SRV_CAsEvt::GetInstance();
if ( BST_NULL_PTR == pcAsMng )
{
break;
}
pstAsEvt = (BST_AS_EVT_STRU *)pstEvtMsg;
pcAsMng->AsEventRcv( pstAsEvt->enAsEvent, pstAsEvt->ulLength,(BST_VOID *)pstAsEvt->pucData );
break;
case BST_SRV_TIMER_EVENT:
pstTimerEvt = (BST_TIMER_EVT_STRU *)pstEvtMsg;
if( BST_OS_SIZEOF(ulTimerId) != pstTimerEvt->ulLength )
{
break;
}
BST_OS_MEMCPY( &ulTimerId, pstTimerEvt->pucData, BST_OS_SIZEOF(ulTimerId) );
BST_OS_TimerDoCallBack( ulTimerId );
break;
case BST_SRV_TCPIP_EVENT:
pstNetEvt = (BST_NET_EVENT_STRU *)pstEvtMsg;
if( BST_OS_SIZEOF(BST_IP_EVENT_STRU) != pstNetEvt->ulLength )
{
break;
}
BST_IP_CallBackEntry ( ( BST_IP_EVENT_STRU * )pstNetEvt->pucData );
break;
default:
break;
}
if( BST_NULL_PTR != pstEvtMsg->pucData )
{
BST_OS_FREE( pstEvtMsg->pucData );
}
BST_OS_FREE( pstEvtMsg );
#if ( BST_VER_TYPE == BST_UT_VER )
break;
#endif
}
}
