/*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_APP_CEmailIMAP::BST_APP_CEmailIMAP( const EMAIL_ACCOUNT_STRU *penInAccountInfo )
: BST_APP_CEmailPacketProc( penInAccountInfo )
{
m_usTag = BST_IMAP_START_TAG;
m_lServerState = BST_EMAIL_UNCONNECT;
m_pstrImapIDCmd = BST_LIB_StrCreat( BST_LIB_SHORT_STR_LEN );
BST_ASSERT_NORM( BST_NULL_PTR == m_pstrImapIDCmd );
m_pcServerResponse0 = (BST_UINT8 *)BST_OS_MALLOC( BST_IMAP_COLUMN_MAX );
if ( BST_NULL_PTR == m_pcServerResponse0 )
{
BST_LIB_StrDelete( m_pstrImapIDCmd );
return;
}
m_pcServerResponse1 = (BST_UINT8 *)BST_OS_MALLOC( BST_IMAP_COLUMN_MAX );
if ( BST_NULL_PTR == m_pcServerResponse1 )
{
BST_LIB_StrDelete( m_pstrImapIDCmd );
BST_OS_FREE( m_pcServerResponse0 );
return;
}
m_pcServerResponse2 = (BST_UINT8 *)BST_OS_MALLOC( BST_IMAP_COLUMN_MAX );
if ( BST_NULL_PTR == m_pcServerResponse2 )
{
BST_LIB_StrDelete( m_pstrImapIDCmd );
BST_OS_FREE( m_pcServerResponse0 );
BST_OS_FREE( m_pcServerResponse1 );
return;
}
BST_OS_MEMSET( m_pcServerResponse0, 0, BST_IMAP_COLUMN_MAX );
BST_OS_MEMSET( m_pcServerResponse1, 0, BST_IMAP_COLUMN_MAX );
BST_OS_MEMSET( m_pcServerResponse2, 0, BST_IMAP_COLUMN_MAX );
}
/*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 );
}
/*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_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_ERR_ENUM_UINT8 BST_APP_CEmailIMAP::SendID( BST_VOID )
{
BST_CHAR *pucSendIDCmd;
BST_UINT16 usSendIDCmdLen;
BST_UINT16 usImapIDLen;
BST_ERR_ENUM_UINT8 enErrMsg;
pucSendIDCmd = (BST_CHAR *)BST_OS_MALLOC( BST_IMAP_ID_CMD_MAX_LEN );
if ( BST_NULL_PTR == pucSendIDCmd )
{
return BST_ERR_INVALID_PTR;
}
usImapIDLen = MakeImapID();
usSendIDCmdLen = ( BST_UINT16 )snprintf(
pucSendIDCmd,
BST_IMAP_ID_CMD_MAX_LEN,
"%d %.*s",
m_usTag,
usImapIDLen,
m_pstrImapIDCmd->pData);
enErrMsg = SendCommand( (BST_UINT8 *)pucSendIDCmd, usSendIDCmdLen );
BST_OS_FREE(pucSendIDCmd);
BST_APP_UPDATE_IMAP_TAG( m_usTag );
return enErrMsg;
}
BST_ERR_ENUM_UINT8 BST_APP_CEmailIMAP::QueryServer(
const BST_UINT8 *pucLastNum,
BST_UINT16 usLen )
{
BST_ERR_ENUM_UINT8 enErrMsg;
BST_CHAR *pucSearchCmd;
BST_UINT16 usSearchCmdLen;
if ( BST_NULL_PTR == pucLastNum )
{
return BST_ERR_INVALID_PTR;
}
if ( 0 == usLen )
{
return BST_ERR_PAR_LEN;
}
pucSearchCmd = (BST_CHAR *)BST_OS_MALLOC(BST_OTHER_CMD_MAX_LEN);
if ( BST_NULL_PTR == pucSearchCmd)
{
return BST_ERR_NO_MEMORY;
}
usSearchCmdLen = (BST_UINT16)snprintf(
pucSearchCmd,
BST_OTHER_CMD_MAX_LEN,
"%d UID Search %.*s\r\n",
m_usTag,
usLen,
pucLastNum );
enErrMsg = SendCommand( (BST_UINT8 *)pucSearchCmd, usSearchCmdLen );
BST_APP_UPDATE_IMAP_TAG( m_usTag );
BST_OS_FREE( pucSearchCmd );
return enErrMsg;
}
/*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 );
}
/*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 );
}
}
/*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_ERR_ENUM_UINT8 BST_APP_CEmailIMAP::LoginServer( BST_VOID )
{
BST_UINT8 *pucLoginCmd;
BST_UINT8 *pucUserName;
BST_UINT8 *pucPassWord;
BST_UINT16 usLoginCmdLen;
BST_UINT16 usUserNameLen;
BST_UINT16 usPassWordLen;
BST_ERR_ENUM_UINT8 enErrMsg;
if ( BST_NULL_PTR == m_pstAccountInfo )
{
return BST_ERR_INVALID_PTR;
}
if ( BST_NULL_PTR == m_pstAccountInfo->pUserName )
{
return BST_ERR_INVALID_PTR;
}
if ( BST_NULL_PTR == m_pstAccountInfo->pPassWord )
{
return BST_ERR_INVALID_PTR;
}
pucUserName = ( BST_UINT8 *)( m_pstAccountInfo->pUserName->pData );
usUserNameLen = m_pstAccountInfo->pUserName->usUsed;
pucPassWord = ( BST_UINT8 *)(m_pstAccountInfo->pPassWord->pData);
usPassWordLen = m_pstAccountInfo->pPassWord->usUsed;
pucLoginCmd = (BST_UINT8 *)BST_OS_MALLOC(BST_IMAP_AUTH_CMD_MAX_LEN);
if ( BST_NULL_PTR == pucLoginCmd )
{
return BST_ERR_NO_MEMORY;
}
usLoginCmdLen = (BST_UINT16)snprintf(
(BST_CHAR *)pucLoginCmd,
BST_IMAP_AUTH_CMD_MAX_LEN,
"%d LOGIN %.*s %.*s\r\n",
m_usTag,
usUserNameLen,
pucUserName,
usPassWordLen,
pucPassWord );
enErrMsg = SendCommand( pucLoginCmd, usLoginCmdLen);
BST_APP_UPDATE_IMAP_TAG( m_usTag );
BST_OS_FREE( pucLoginCmd );
return enErrMsg;
}
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_IP_ERR_T BST_IP_BsdReceive( BST_FD_T fd, BST_UINT8* pData, BST_UINT16 usLength )
{
BST_IP_ERR_T lRtnVal;
BST_IP_ERR_T lTmpVal;
BST_UINT8 *pucTmpData;
BST_UINT16 usDefLength;
usDefLength = BST_IP_MTU_SIZE;
if( !BST_IP_IsBsdFdValid(fd) )
{
return BST_IP_ERR_MEM;
}
if( BST_NULL_PTR == pData || usLength <= 0 )
{
return BST_IP_ERR_MEM;
}
lRtnVal = (BST_IP_ERR_T)lwip_read( fd.lFd, pData, usLength );
if ( lRtnVal < usLength )
{
return lRtnVal;
}
/* 读空socket缓冲区里的数据 */
pucTmpData = (BST_UINT8 *)BST_OS_MALLOC( usDefLength );
if ( BST_NULL_PTR == pucTmpData )
{
return lRtnVal;
}
BST_OS_MEMSET( pucTmpData, 0, usDefLength );
while( 1 )
{
lTmpVal = (BST_IP_ERR_T)lwip_read( fd.lFd, pucTmpData, usDefLength );
if ( lTmpVal < usDefLength )
{
break;
}
}
BST_OS_FREE( pucTmpData );
return lRtnVal;
}
//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 );
}
BST_ERR_ENUM_UINT8 BST_APP_CEmailIMAP::QuitServer( BST_VOID )
{
BST_CHAR *pucLogoutCmd;
BST_UINT16 usLogoutCmdLen;
BST_ERR_ENUM_UINT8 enErrMsg;
pucLogoutCmd = (BST_CHAR *)BST_OS_MALLOC(BST_OTHER_CMD_MAX_LEN);
BST_ASSERT_NULL_RTN( pucLogoutCmd, BST_ERR_NO_MEMORY );
usLogoutCmdLen = ( BST_UINT16 )snprintf(
pucLogoutCmd,
BST_OTHER_CMD_MAX_LEN,
"%d LOGOUT\r\n",
m_usTag );
enErrMsg = SendCommand( (BST_UINT8 *)pucLogoutCmd, usLogoutCmdLen );
BST_APP_UPDATE_IMAP_TAG( m_usTag );
BST_OS_FREE( pucLogoutCmd );
return enErrMsg;
}
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_APP_CEmailIMAP::SelectInBox( BST_VOID )
{
BST_CHAR *pcSelectCmd;
BST_UINT16 usSelectCmdLen;
BST_ERR_ENUM_UINT8 enErrMsg;
pcSelectCmd = (BST_CHAR *)BST_OS_MALLOC( BST_OTHER_CMD_MAX_LEN );
if ( BST_NULL_PTR == pcSelectCmd )
{
return BST_ERR_INVALID_PTR;
}
usSelectCmdLen = (BST_UINT16)snprintf(
pcSelectCmd,
BST_OTHER_CMD_MAX_LEN,
"%d Select \"INBOX\"\r\n",
m_usTag );
enErrMsg = SendCommand( (BST_UINT8 *)pcSelectCmd, usSelectCmdLen );
BST_APP_UPDATE_IMAP_TAG( m_usTag );
BST_OS_FREE( pcSelectCmd );
return enErrMsg;
}
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_ERR_ENUM_UINT8 BST_SRV_CHNL_Send_InCB(
BST_SRV_CHNL_LINK_STRU *pstChnlLink,
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_SRV_CHNL_SENT_STRU *pSentItem;
BST_IP_ERR_T enIpErr;
BST_UINT16 usFlags;
BST_UINT32 ulSpinlockCnt;
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_InCB 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_INVALID_PTR;
}
pstChnlLink->ulCurrentSeq += pstPktItem->ulUsed;
pstChnlLink->ulRetryTimes = 0;
pSentItem->usProcLevel = pstPktItem->usProcLevel;
pSentItem->pNext = BST_NULL_PTR;
pSentItem->ulAckNo = pstChnlLink->ulCurrentSeq;
BST_SRV_Q_PushToTail( (BST_SRV_CHNL_Q **)&pstChnlLink->pSentList,
(BST_SRV_CHNL_Q *)pSentItem );
if ( BST_DSPP_FLG_LVLTYPE_HS == pstPktItem->usProcLevel )
{
ulSpinlockCnt = BST_OS_SpinLock( &g_HighPriCntSpinLock );
g_ulHighPriCnt++;
BST_OS_SpinUnLock( &g_HighPriCntSpinLock , ulSpinlockCnt );
BST_DBG_LOG2(" g_ulHighPriCnt++, sent", g_ulHighPriCnt, pstPktItem->ulUsed);
}
}
else if( BST_IP_ERR_MEM == enIpErr )
{
pstChnlLink->ulRetryTimes++;
BST_OS_TimerStart( pstChnlLink->ulTimerId, BST_SRV_CHNL_RTX_INTERVAL );
return BST_ERR_NO_MEMORY;
}
else
{
return BST_ERR_SOCKET_CLSD;
}
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_ERR_ENUM_UINT8 BST_SRV_CHNL_Itf(
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_SRV_CHNL_LINK_STRU *pstLinkItem = BST_NULL_PTR;
BST_SRV_CHNL_LINK_STRU *pstLinkItem2;
BST_IP_CSocket *pcSocket;
BST_OS_TIMERID_T ulTimerId;
BST_ERR_ENUM_UINT8 enRtnVal;
BST_ASSERT_NULL_RTN( pstPktItem, BST_ERR_INVALID_PTR );
pstLinkItem = BST_SRV_Q_PeekHead( g_lstChnlMng );
enRtnVal = BST_NO_ERROR_MSG;
for(;;)
{
if( BST_NULL_PTR == pstLinkItem )
{
break;
}
if( ( pstLinkItem->stLink.ulMainLinkId == pstPktItem->ulMainLinkId )
&&( pstLinkItem->stLink.ulAuxLinkId == pstPktItem->ulAuxLinkId ) )
{
break;
}
pstLinkItem = pstLinkItem->pNext;
}
BST_DBG_LOG1( "CPC_PACKET_DROP pstPktItem->usCmdId", pstPktItem->usCmdId );
switch( pstPktItem->usCmdId )
{
case BST_DSPP_FLG_CMD_CLEAR:
if( BST_NULL_PTR != pstLinkItem )
{
BST_SRV_CHNL_Close( pstLinkItem );
delete pstLinkItem->pcSocket;
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&g_lstChnlMng,
(BST_SRV_CHNL_Q *)pstLinkItem,
(BST_SRV_CHNL_Q **)&pstLinkItem2 );
BST_OS_TimerRemove( pstLinkItem->ulTimerId );
BST_OS_FREE( pstLinkItem );
}
else
{
enRtnVal = BST_ERR_UNKNOW_OBJ;
}
break;
case BST_DSPP_FLG_CMD_CLOSE:
if( BST_NULL_PTR != pstLinkItem )
{
BST_SRV_CHNL_Close( pstLinkItem );
delete pstLinkItem->pcSocket;
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&g_lstChnlMng,
(BST_SRV_CHNL_Q *)pstLinkItem,
(BST_SRV_CHNL_Q **)&pstLinkItem2 );
BST_OS_TimerRemove( pstLinkItem->ulTimerId );
BST_OS_FREE( pstLinkItem );
}
else
{
enRtnVal = BST_ERR_UNKNOW_OBJ;
}
break;
case BST_DSPP_FLG_CMD_SEND:
BST_DBG_LOG1("BST_SRV_CHNL_Itf send pstLinkItem",pstLinkItem);
if( BST_NULL_PTR == pstLinkItem )
{
pstLinkItem = (BST_SRV_CHNL_LINK_STRU *)BST_OS_MALLOC
( BST_OS_SIZEOF(BST_SRV_CHNL_LINK_STRU) );
if( BST_NULL_PTR == pstLinkItem )
{
enRtnVal = BST_ERR_NO_MEMORY;
break;
}
pcSocket = BST_SRV_CHNL_CreateSocket( pstPktItem );
if ( BST_NULL_PTR == pcSocket )
{
BST_RLS_LOG("BST_SRV_CHNL_CreateSocket error");
enRtnVal = BST_ERR_PAR_UNKNOW;
break;
}
ulTimerId = BST_OS_TimerCreate
( BST_SRV_CHNL_SysTimerExpired, BST_NULL_PTR,
BST_SRV_GetChnlCtrlHandle( 0 ) );
BST_SRV_CHNL_InitLink( pstLinkItem, pcSocket, ulTimerId );
pstLinkItem->ulAddrType = BST_DSPP_FLG_ADDTYPE_INET;
pstLinkItem->stLink.ulMainLinkId = pstPktItem->ulMainLinkId;
pstLinkItem->stLink.ulAuxLinkId = pstPktItem->ulAuxLinkId;
BST_SRV_Q_PushToTail( (BST_SRV_CHNL_Q **)&g_lstChnlMng,
(BST_SRV_CHNL_Q *)pstLinkItem );
}
enRtnVal = BST_SRV_CHNL_Send( pstLinkItem, pstPktItem );
if( BST_ERR_ILLEGAL_PARAM == enRtnVal )
{
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&g_lstChnlMng,
(BST_SRV_CHNL_Q *)pstLinkItem,
(BST_SRV_CHNL_Q **)&pstLinkItem2 );
BST_OS_FREE( pstLinkItem );
}
return enRtnVal;
default:
break;
}
BST_SRV_FreeIpBlock( pstPktItem );
return enRtnVal;
}
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_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();
}
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;
}
/*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();
}
