BST_VOID BST_SYS_MntnUpdateIpInfo(
BST_UINT16 usType,
BST_UINT16 usTaskId,
BST_VOID *pstIpInfo )
{
OM_BST_APP_INFO_STRU *pstAppInfo;
BST_IP_SOCKET_ADD_T *pstSocketInfo;
BST_OS_LOCKCNT_T tThreadLockCnt;
if ( !BST_SYS_MNTN_IsMntnInited() )
{
return;
}
if ( BST_NULL_PTR == pstIpInfo )
{
return;
}
pstSocketInfo = ( BST_IP_SOCKET_ADD_T *)pstIpInfo;
tThreadLockCnt = BST_OS_ThreadLock();
pstAppInfo = BST_SYS_MntnSrchAppByTask( usType, usTaskId );
if ( BST_NULL_PTR == pstAppInfo )
{
BST_OS_ThreadUnLock( tThreadLockCnt );
return;
}
pstAppInfo->usLocalPort = pstSocketInfo->usLocalPort;
pstAppInfo->usRemotePort = pstSocketInfo->usRemotePort;
BST_OS_MEMCPY( &pstAppInfo->aucLocalIp[0],
BST_SYS_MNTN_GetLocalIpHead(), OM_BST_IP_ADDR_LEN );
BST_OS_MEMCPY( &pstAppInfo->aucRemoteIp[0],
&pstSocketInfo->aucRemoteIp[0], OM_BST_IP_ADDR_LEN );
BST_RLS_LOG4( "[Mntn] Socket Configed_01: TypeId=, TaskId=, LocalPort=, RemotePort=",
usType, usTaskId, (pstSocketInfo)->usLocalPort, (pstSocketInfo)->usRemotePort );
BST_RLS_LOG4( "[Mntn] Socket Configed_02: Remote Ip Address",
(pstAppInfo)->aucRemoteIp[3], (pstAppInfo)->aucRemoteIp[2],
(pstAppInfo)->aucRemoteIp[1], (pstAppInfo)->aucRemoteIp[0]);
BST_RLS_LOG4( "[Mntn] Socket Configed_02: Local Ip Address",
(pstAppInfo)->aucLocalIp[3], (pstAppInfo)->aucLocalIp[2],
(pstAppInfo)->aucLocalIp[1], (pstAppInfo)->aucLocalIp[0]);
BST_SYS_MntnChangedInd();
BST_OS_ThreadUnLock( tThreadLockCnt );
}
/*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::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 );
}
/*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_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_VOID BST_SYS_MntnCofigLoacalIpAddress(
BST_UINT8 *aucLocalIp,
BST_UINT16 usBufLen )
{
if ( BST_NULL_PTR == aucLocalIp )
{
BST_RLS_LOG( "[Mntn] BST_SYS_MntnCofigLoacalIpAddress Error Pointer" );
return;
}
if ( OM_BST_IP_ADDR_LEN > usBufLen )
{
BST_RLS_LOG1( "[Mntn] BST_SYS_MntnCofigLoacalIpAddress Error Size:", usBufLen );
return;
}
BST_OS_MEMCPY( &g_stBstMntnEntity.aucLocalIp[0],
aucLocalIp, OM_BST_IP_ADDR_LEN );
return;
}
/*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_ERR_ENUM_UINT8 BST_Pal_DrvAcomSend( BST_UINT32 ulLength, BST_UINT8 *pucData )
{
#ifndef BST_MODEM_SELF
#ifndef BST_PEAK_SPEED_TEST
BST_ACOM_MSG_STRU *pstAcorMsg;
BST_UINT8 *ulTmpAddr;
BST_ASSERT_NULL_RTN( pucData, BST_ERR_INVALID_PTR );
pstAcorMsg = BST_ACOMM_ALLOC_MSG_WITH_HDR( ulLength );
BST_ASSERT_NULL_RTN( pstAcorMsg, BST_ERR_NO_MEMORY );
ulTmpAddr = (pstAcorMsg->aucValue);
BST_OS_MEMCPY((BST_VOID*)ulTmpAddr, pucData, ulLength);
pstAcorMsg->ulLen = ulLength;
BST_ACOMM_CFG_MSG_HDR( pstAcorMsg, ACPU_PID_BASTET_COMM );
BST_ACOMM_SEND_MSG( pstAcorMsg );
#endif
#endif
return BST_NO_ERROR_MSG;
}
BST_IP_ERR_T BST_IP_RawUdpSend( BST_FD_T fd, BST_UINT8* pData, BST_UINT16 usLength )
{
struct pbuf *pstPbuf;
struct udp_pcb *upcb;
if( BST_NULL_PTR == pData )
{
return BST_IP_ERR_MEM;
}
if( !BST_IP_IsRawFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
upcb = (struct udp_pcb *)fd.pFd;
pstPbuf = pbuf_alloc( PBUF_RAW, usLength, PBUF_POOL );
if( BST_IP_IsLwipNull(pstPbuf) )
{
return BST_IP_ERR_BUF;
}
BST_OS_MEMCPY( pstPbuf->payload, pData, usLength );
return udp_send( upcb, pstPbuf );
}
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;
}
/*lint -e48 -e18 -e438 -e516*/
void *realloc(void *mem_address, unsigned int newsize)
{
void * NewPtr;
if ( !mem_address)
{
return BST_OS_MALLOC( newsize );
}
else if ( newsize == 0 )
{
BST_OS_FREE( mem_address );
}
else
{
NewPtr = BST_OS_MALLOC(newsize);
if ( NewPtr )
{
BST_OS_MEMCPY( NewPtr, mem_address, newsize );
BST_OS_FREE( mem_address );
return NewPtr;
}
}
return BST_NULL_PTR;
}
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
}
}
BST_ERR_ENUM_UINT8 BST_CORE_DencryptChk ( BST_CORE_PID_ENUM_UINT16 enPid,
const BST_VOID *pvData,
BST_UINT16 usLen,
BST_VOID **ppOutData,
BST_UINT16 *pusOutLen )
{
BST_ERR_ENUM_UINT8 enRet;
BST_UINT32 ulInLen;
BST_UINT32 ulOutLen;
BST_UINT32 ulBase64DataLen;
BST_UINT8 *pucIn;
BST_UINT8 *pucOut;
BST_UINT8 *pucBase64Data;
ulInLen = 0;
ulOutLen = 0;
ulBase64DataLen = 0;
pucIn = BST_NULL_PTR;
pucOut = BST_NULL_PTR;
pucBase64Data = BST_NULL_PTR;
enRet = BST_NO_ERROR_MSG;
if ( ( BST_NULL_PTR == pvData )
|| ( BST_NULL_PTR == pusOutLen )
|| ( BST_NULL_PTR == ppOutData) )
{
return BST_ERR_INVALID_PTR;
}
if ( 0 == usLen )
{
return BST_ERR_PAR_LEN;
}
if ( CheckIfEcryOrDecry ( enPid ) )
{
pucIn = ( BST_UINT8 * )BST_OS_MALLOC ( usLen );
if ( BST_NULL_PTR == pucIn )
{
return BST_ERR_NO_MEMORY;
}
BST_OS_MEMCPY ( pucIn, pvData, usLen );
ulInLen = usLen;
pucBase64Data = ( BST_UINT8 * )BST_OS_MALLOC ( ulInLen );
if ( BST_NULL_PTR == pucBase64Data )
{
BST_OS_FREE ( pucIn );
pucIn = BST_NULL_PTR;
return BST_ERR_NO_MEMORY;
}
ulBase64DataLen = EVP_DecodeBlock ( pucBase64Data, pucIn, ulInLen );
while ( pucIn[--ulInLen] == '=' ) // Ecrypter string end is '='
{
ulBase64DataLen--;
}
pucOut = ( BST_UINT8 * )BST_OS_MALLOC ( ulInLen );
if ( BST_NULL_PTR == pucOut )
{
BST_OS_FREE ( pucIn );
pucIn = BST_NULL_PTR;
BST_OS_FREE ( pucBase64Data );
pucBase64Data = BST_NULL_PTR;
return BST_ERR_NO_MEMORY;
}
BST_OS_MEMSET ( pucOut, 0, ulInLen );
enRet = DecryptInternal ( pucBase64Data,
ulBase64DataLen,
pucOut,
&ulOutLen,
gs_BastetDsppKey );
if ( BST_NO_ERROR_MSG == enRet )
{
*ppOutData = ( BST_VOID * )pucOut;
*pusOutLen = ( BST_UINT16 )ulOutLen;
}
BST_OS_FREE ( pucIn );
pucIn = BST_NULL_PTR;
BST_OS_FREE ( pucBase64Data );
pucBase64Data = BST_NULL_PTR;
return enRet;
}
return BST_NO_ERROR_MSG;
}
BST_ERR_ENUM_UINT8 BST_CORE_EncryptChk ( BST_CORE_PID_ENUM_UINT16 enPid,
const BST_VOID *pvData,
BST_UINT16 usLen,
BST_VOID **ppOutData,
BST_UINT16 *pusOutLen )
{
BST_ERR_ENUM_UINT8 enRet;
BST_UINT32 ulInLen;
BST_UINT32 ulOutLen;
BST_UINT32 ulBase64DataLen;
BST_UINT8 *pucIn;
BST_UINT8 *pucOut;
BST_UINT8 *pucBase64Data;
ulInLen = 0;
ulOutLen = 0;
ulBase64DataLen = 0;
pucIn = BST_NULL_PTR;
pucOut = BST_NULL_PTR;
pucBase64Data = BST_NULL_PTR;
enRet = BST_NO_ERROR_MSG;
if ( ( BST_NULL_PTR == pvData )
|| ( BST_NULL_PTR == pusOutLen )
|| ( BST_NULL_PTR == ppOutData) )
{
return BST_ERR_INVALID_PTR;
}
if ( 0 == usLen )
{
return BST_ERR_PAR_LEN;
}
if ( CheckIfEcryOrDecry ( enPid ) )
{
pucIn = ( BST_UINT8 * )BST_OS_MALLOC ( usLen );
if ( BST_NULL_PTR == pucIn )
{
return BST_ERR_NO_MEMORY;
}
BST_OS_MEMCPY ( pucIn, pvData, usLen );
ulInLen = usLen;
pucOut = ( BST_UINT8 * )BST_OS_MALLOC ( ulInLen + EVP_MAX_IV_LENGTH );
if ( BST_NULL_PTR == pucOut )
{
BST_OS_FREE ( pucIn );
pucIn = BST_NULL_PTR;
return BST_ERR_NO_MEMORY;
}
enRet = EncryptInternal ( ( BST_UINT8 * )pucIn,
ulInLen,
pucOut,
&ulOutLen,
gs_BastetDsppKey );
if ( BST_NO_ERROR_MSG == enRet )
{
pucBase64Data = ( BST_UINT8 * )BST_OS_MALLOC ( ulOutLen * 2 );
if ( BST_NULL_PTR == pucBase64Data )
{
BST_OS_FREE ( pucIn );
pucIn = BST_NULL_PTR;
BST_OS_FREE ( pucOut );
pucOut = BST_NULL_PTR;
return BST_ERR_NO_MEMORY;
}
ulBase64DataLen = EVP_EncodeBlock ( pucBase64Data, pucOut, ulOutLen );
*ppOutData = pucBase64Data;
*pusOutLen = ulBase64DataLen;
}
BST_OS_FREE ( pucIn );
pucIn = BST_NULL_PTR;
BST_OS_FREE ( pucOut );
pucOut = BST_NULL_PTR;
return enRet;
}
return BST_NO_ERROR_MSG;
}
BST_ERR_ENUM_UINT8 BST_SRV_CHNL_Send_Runing(
BST_SRV_CHNL_LINK_STRU *pstChnlLink,
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_SRV_CHNL_SENT_STRU *pSentItem;
BST_SRV_CHNL_HEAD_STRU *pstUnsendItem;
BST_SRV_CHNL_LINK_STRU *pstLinkItem2;
BST_IP_ERR_T enIpErr;
BST_DSPP_CAppUlVc *pstDsppUl;
BST_UINT32 ulSpinlockCnt;
BST_UINT16 usFlags;
BST_ASSERT_NULL_RTN( pstChnlLink, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( pstPktItem, BST_ERR_INVALID_PTR );
enIpErr = BST_IP_ERR_OK;
if( BST_SRV_ChnlIsTail(pstPktItem) )
{
usFlags = BST_IP_SEND_FLAG_VOID;
}
else
{
usFlags = BST_IP_SEND_FLAG_MORE;
}
if( BST_IP_SKT_PROP_NONE != pstPktItem->ucPropType )
{
BST_SRV_CHNL_Set_LinkProp( pstChnlLink, pstPktItem );
pstChnlLink->ulCurrentSeq
= pstPktItem->stProp.ulSeqNum;
}
BST_DBG_LOG4("BST_SRV_CHNL_Send_Runing Length, ProcLevel, PackAddr, Flag",
pstPktItem->ulUsed,
pstPktItem->usProcLevel,
pstPktItem->ucPktAddr,
usFlags );
switch( pstPktItem->usProcLevel )
{
case BST_DSPP_FLG_LVLTYPE_NORMAL:
enIpErr = pstChnlLink->pcSocket->Write
( (const BST_UINT8 *)&pstPktItem->aucData[0],
(BST_UINT16)pstPktItem->ulUsed, BST_IP_BSTT_DATA, usFlags );
break;
case BST_DSPP_FLG_LVLTYPE_HS:
enIpErr = pstChnlLink->pcSocket->Write
( (const BST_UINT8 *)&pstPktItem->aucData[0],
(BST_UINT16)pstPktItem->ulUsed,
BST_IP_HPRI_DATA,
usFlags );
break;
case BST_DSPP_FLG_LVLTYPE_LP:
enIpErr = pstChnlLink->pcSocket->Write
( (const BST_UINT8 *)&pstPktItem->aucData[0],
(BST_UINT16)pstPktItem->ulUsed,
BST_IP_LPWR_DATA,
usFlags );
break;
default:
return BST_ERR_PAR_UNKNOW;
}
if( BST_IP_ERR_OK == enIpErr )
{
pSentItem = ( BST_SRV_CHNL_SENT_STRU *)BST_OS_MALLOC(
BST_OS_SIZEOF( BST_SRV_CHNL_SENT_STRU ) );
if( BST_NULL_PTR == pSentItem )
{
return BST_ERR_NO_MEMORY;
}
pstChnlLink->ulCurrentSeq += pstPktItem->ulUsed;
pSentItem->pNext = BST_NULL_PTR;
if ( BST_DSPP_FLG_LVLTYPE_HS == pstPktItem->usProcLevel )
{
ulSpinlockCnt = BST_OS_SpinLock( &g_HighPriCntSpinLock );
g_ulHighPriCnt++;
BST_OS_SpinUnLock( &g_HighPriCntSpinLock , ulSpinlockCnt );
}
pSentItem->usProcLevel = pstPktItem->usProcLevel;
pSentItem->ulAckNo = pstChnlLink->ulCurrentSeq;
BST_SRV_Q_PushToTail( (BST_SRV_CHNL_Q **)&pstChnlLink->pSentList,
(BST_SRV_CHNL_Q *)pSentItem );
BST_DBG_LOG3("tiger BST_SRV_FreeIpBlock1 g_ulHighPriCnt++, sent",pstPktItem, g_ulHighPriCnt, pstPktItem->ulUsed);
BST_SRV_FreeIpBlock( pstPktItem );
}
else if( BST_IP_ERR_MEM == enIpErr )
{
/*申请空间存储未发送的数据,避免在处理完成时将数据释放*/
pstUnsendItem = BST_SRV_AlocIpBlock();
if ( BST_NULL_PTR == pstUnsendItem )
{
return BST_ERR_NO_MEMORY;
}
BST_OS_MEMCPY( pstUnsendItem, pstPktItem, BST_OS_SIZEOF(BST_SRV_CHNL_HEAD_STRU));
BST_SRV_CHNL_Send_Suspend( pstChnlLink, pstUnsendItem );
pstChnlLink->enState = BST_SRV_CHNL_STATE_SUSPEND;
return BST_ERR_NO_MEMORY;
}
else
{
pstDsppUl = BST_DSPP_CAppUlVc::GetInstance();
if( pstChnlLink->ulAddrType == BST_DSPP_FLG_ADDTYPE_INET )
{
pstDsppUl->Report( BST_DSPP_FLG_CMD_CLOSE,
pstChnlLink->stLink.ulMainLinkId,
pstChnlLink->stLink.ulAuxLinkId );
BST_SRV_CHNL_ReportTrafficFlow( pstChnlLink );
}
else
{
pstDsppUl->Report( BST_DSPP_FLG_CMD_CLOSE,
pstChnlLink->stDspp.usProcId,
pstChnlLink->stDspp.usTaskId );
}
BST_SRV_CHNL_Close( pstChnlLink );
delete pstChnlLink->pcSocket;
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&g_lstChnlMng,
(BST_SRV_CHNL_Q *)pstChnlLink,
(BST_SRV_CHNL_Q **)&pstLinkItem2 );
BST_OS_FREE(pstChnlLink);
return BST_ERR_SOCKET_CLSD;
}
return BST_NO_ERROR_MSG;
}
BST_IP_ERR_T BST_IP_SslReceive( BST_FD_T fd, BST_UINT8* pData, BST_UINT16 usLength )
{
SSL *pstSsl;
BST_UINT8 *pucTmpBuf;
BST_INT32 lRtnVal;
BST_INT32 lCopyedLen;
BST_INT32 lSelect;
BST_INT32 lSockFd;
fd_set stRdFds;
timeval stTval;
stTval.tv_sec = 0;
stTval.tv_usec = 0;
if ( BST_NULL_PTR == fd.pFd )
{
return BST_IP_ERR_ARG;
}
if ( BST_NULL_PTR == pData )
{
return BST_IP_ERR_ARG;
}
lCopyedLen = 0;
pstSsl = (SSL *)fd.pFd;
lSockFd = SSL_get_fd( pstSsl );
pucTmpBuf = (BST_UINT8 *)BST_OS_MALLOC( usLength );
if ( BST_NULL_PTR == pucTmpBuf )
{
return BST_IP_ERR_MEM;
}
do {
FD_ZERO( &stRdFds );
FD_SET( lSockFd, &stRdFds );
lRtnVal = SSL_read( pstSsl, pucTmpBuf, usLength );
if ( lRtnVal <= 0 )
{
BST_RLS_LOG( "BST_IP_SslReceive SSL_read error" );
break;
}
if ( 0 == lCopyedLen )
{
BST_OS_MEMCPY( pData, pucTmpBuf, lRtnVal );
lCopyedLen = lRtnVal;
BST_DBG_LOG1( "BST_IP_SslReceive lCopyedLen", lCopyedLen );
}
/*如果ssl内部缓冲区没有数据可读，则判断IP协议栈是否有数据可读*/
if ( !SSL_pending( pstSsl ) )
{
lSelect = lwip_select( lSockFd + 1, &stRdFds, NULL, NULL, &stTval );
if ( lSelect < 0)
{
BST_RLS_LOG( "BST_IP_SslReceive lwip_select error" );
break;
}
/*如果协议栈也没有数据可读，则说明这次读取完毕，退出*/
if ( !FD_ISSET( lSockFd,&stRdFds ) )
{
BST_DBG_LOG( "BST_IP_SslReceive socket is not data" );
break;
}
}
} while( 1 );
BST_OS_FREE( pucTmpBuf );
return lCopyedLen;
}
/*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();
}
/*lint -e438*/
err_t BST_IP_TcpRecvCB( BST_VOID *arg, struct tcp_pcb * tpcb, struct pbuf *p, BST_IP_ERR_T err )
{
err_t ucErrMsg;
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_RTN( tpcb, ERR_ARG );
tThreadLockCnt = BST_OS_ThreadLock();
FdTmp.pFd = tpcb;
pcRcverMnger = BST_IP_CRcverMng::GetInstance();
pucSdu = BST_NULL_PTR;
q = BST_NULL_PTR;
usCopyedLength = 0;
ucErrMsg = ERR_OK;
enProcMode = BST_IP_PKT_REMOVE_PROC;
if( BST_NULL_PTR == pcRcverMnger )
{
ucErrMsg = ERR_MEM;
BST_IP_TCP_RCVAPI_FREE();
}
/* *
* p=NULL means this pcb is closed by Remote*
* */
if( BST_IP_IsLwipNull(p) )
{
pcRcverMnger->ClosedRcver ( FdTmp );
BST_OS_ThreadUnLock( tThreadLockCnt );
return ERR_OK;
}
if ( p->tot_len > 0 )
{
pucSdu = ( BST_UINT8 * )BST_OS_MALLOC( p->tot_len );
}
else
{
ucErrMsg = ERR_BUF;
tcp_recved( tpcb, p->tot_len );
BST_IP_TCP_RCVAPI_FREE();
}
if ( BST_NULL_PTR == pucSdu )
{
ucErrMsg = ERR_BUF;
tcp_recved( tpcb, p->tot_len );
BST_IP_TCP_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 )
{
BST_IP_ApiRecordLastSktProp( (BST_IP_PKT_ID_T)p );
/* *
*The Received Message must put it here where is before call Application CB.
*This can avoid app close socket in callback when the rcv_wnd != TCP_WND.
* */
tcp_recved( tpcb, p->tot_len );
enProcMode = pcRcverMnger->PacketRcver( FdTmp,
( BST_UINT8 * )pucSdu,
usCopyedLength );
if( BST_IP_PKT_FORWARD_PROC == enProcMode )
{
BST_IP_ApiForwordPacket( (BST_IP_PKT_ID_T)p );
}
ucErrMsg = ERR_OK;
}
else
{
ucErrMsg = ERR_BUF;
}
BST_OS_FREE( pucSdu );
BST_IP_TCP_RCVAPI_FREE();
}
