BST_ERR_ENUM_UINT8 BST_OS_DeleteMbx( BST_OS_MBX_T *pstMbx )
{
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 );
BST_OS_DeleteSem( pstMbx->hSem );
tThreadLockCnt = BST_OS_ThreadLock();
for (;;)
{
if( 0 == lstCount( &pstMbx->hList ) )
{
break;
}
pstContent = (BST_OS_MAIL_T *)lstGet( &pstMbx->hList );
BST_OS_FREE( pstContent );
}
lstFree( &pstMbx->hList);
BST_OS_FREE( pstMbx );
BST_OS_ThreadUnLock( tThreadLockCnt );
/*lint -e438*/
return( BST_NO_ERROR_MSG );
/*lint +e438*/
}
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 );
}
BST_VOID BST_SRV_CHNL_ThreadEntry( BST_VOID *pvArg )
{
BST_OS_MBX_T **pstMailBox;
BST_OS_LOCKCNT_T tThreadLockCnt;
BST_EVT_HEAD_STRU *pstEvent;
BST_UINT32 ulRtnVal;
if ( BST_NULL_PTR == pvArg )
{
return;
}
/*
* 线程参数初始化，包括邮箱，运行标识
*/
tThreadLockCnt = BST_OS_ThreadLock ();
pstMailBox = (BST_OS_MBX_T **)pvArg;
*pstMailBox = BST_OS_CreateMbx
( BST_OS_GetCurrentThreadId(), BST_L_MBOX_SIZE );
if ( BST_NULL_PTR == *pstMailBox )
{
BST_OS_ThreadUnLock ( tThreadLockCnt );
return;
}
BST_SetThreadInitFlag( BST_CHNL_CTRL_THREAD_FLAG );
g_lstChnlMng = BST_NULL_PTR;
BST_OS_InitSpinLock( &g_HighPriCntSpinLock );
BST_OS_ThreadUnLock ( tThreadLockCnt );
/*
* 进入线程主循环，等待邮件，邮件内容为即将执行的任务
*/
for(;;)
{
ulRtnVal = BST_OS_RecvMail
( *pstMailBox, (BST_VOID **)&pstEvent, BST_OS_SYS_FOREVER );
BST_ASSERT_NORM( BST_OS_SYS_TIMEOUT == ulRtnVal );
BST_SRV_ProcChnlCtrEvent( pstEvent );
/*这里判断指针不为空再次释放，因此需要传递指针的指针*/
if( BST_NULL_PTR != pstEvent->pucData )
{
BST_DBG_LOG1( "tiger BST_OS_FREE 8,", pstEvent->pucData );
BST_OS_FREE( pstEvent->pucData );
}
BST_OS_FREE( pstEvent );
#if ( BST_VER_TYPE == BST_UT_VER )
break;
#endif
}
}
/*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_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;
}
/*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 );
}
/*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_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;
}
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_IP_ERR_T BST_SRV_CChnlIpRcver::Connectd( BST_IP_CSocket *pcSocket )
{
BST_DBG_LOG("BST_SRV_CChnlIpRcver Connectd. ");
#if ( ( BST_OS_VER == BST_WIN32 && BST_VER_TYPE == BST_DBG_VER ) || (BST_MODEM_SELF == 1) )
BST_SRV_CHNL_LINK_STRU *pstLinkItem = BST_NULL_PTR;
BST_SRV_CHNL_LINK_STRU *pstLinkItem2;
BST_SRV_CHNL_HEAD_STRU *pstPktItem;
BST_ERR_ENUM_UINT8 enRtnVal;
pstLinkItem = BST_SRV_Q_PeekHead( g_lstChnlMng );
pstPktItem = BST_SRV_Q_PeekHead( pstLinkItem->pUnsendList );
pstPktItem->ucPropType = BST_IP_SKT_PROP_NONE; /*不使用包中的socket属性*/
enRtnVal = BST_SRV_CHNL_Send_Runing( 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_TimerRemove( pstLinkItem->ulTimerId );
BST_DBG_LOG1( "tiger BST_OS_FREE 10,", pstLinkItem );
BST_OS_FREE( pstLinkItem );
}
#endif
return BST_IP_ERR_OK;
}
BST_UINT32 BST_OS_RecvMail(
BST_OS_MBX_T *pstMbx,
BST_VOID **pMsg,
BST_UINT32 ulExTime )
{
BST_OS_MAIL_T *pstContent;
BST_UINT32 ulPendTime;
BST_UINT32 ulPastTime;
BST_OS_LOCKCNT_T tThreadLockCnt;
BST_ASSERT_NULL_RTN( pstMbx, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( pstMbx->hSem, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( pMsg, BST_ERR_INVALID_PTR );
*pMsg = BST_NULL_PTR;
if( (BST_UINT32)BST_OS_SYS_FOREVER == ulExTime )
{
ulPendTime = (BST_UINT32)BST_OS_SYS_FOREVER;
}
else if( ulExTime < BST_OS_TICKS_MS )
{
ulPendTime = BST_OS_TICKS_MS;
}
else
{
ulPendTime = ulExTime;
}
ulPastTime = BST_OS_RecvSem( pstMbx->hSem, ulPendTime );
if( BST_OS_SYS_TIMEOUT == ulPastTime )
{
return BST_OS_SYS_TIMEOUT;
}
tThreadLockCnt = (BST_OS_LOCKCNT_T)BST_OS_SpinLock( &g_MboxLock );
pstContent = (BST_OS_MAIL_T *)lstGet( &pstMbx->hList );
if ( BST_NULL_PTR == pstContent )
{
*pMsg = BST_NULL_PTR;
BST_OS_SpinUnLock( &g_MboxLock, (BST_UINT32)tThreadLockCnt );
return BST_OS_SYS_TIMEOUT;
}
*pMsg = pstContent->ulContent;
BST_OS_FREE( pstContent );
BST_OS_SpinUnLock( &g_MboxLock, (BST_UINT32)tThreadLockCnt );
/*lint -e438*/
return( ulPastTime );
/*lint +e438*/
}
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_APP_CEmailIMAP::~BST_APP_CEmailIMAP()
{
if ( BST_NULL_PTR != m_pcServerResponse0 )
{
BST_OS_FREE( m_pcServerResponse0 );
}
if ( BST_NULL_PTR != m_pcServerResponse1 )
{
BST_OS_FREE( m_pcServerResponse1 );
}
if ( BST_NULL_PTR != m_pcServerResponse2 )
{
BST_OS_FREE( m_pcServerResponse2 );
}
if ( BST_NULL_PTR!= m_pstrImapIDCmd )
{
BST_LIB_StrDelete( m_pstrImapIDCmd );
}
BST_RLS_LOG("BST_APP_CEmailIMAP destructor");
}
/*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_ERR_ENUM_UINT8 BST_OS_DeleteSem( BST_OS_SEM_STRU *pstSemHandle )
{
BST_ERR_ENUM_UINT8 ucRtnVal;
if( BST_NULL_PTR == pstSemHandle )
{
return BST_ERR_INVALID_PTR;
}
ucRtnVal = BST_OS_PalDeleteSem( pstSemHandle->stHandle );
if( BST_NO_ERROR_MSG == ucRtnVal )
{
BST_OS_FREE( pstSemHandle );
}
/*lint -e438*/
return ucRtnVal;
/*lint +e438*/
}
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;
}
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;
}
/*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_VOID BST_SRV_CChnlIpRcver::IpErr (
BST_IP_CSocket *pcSocket,
BST_IP_ERR_T InIpErrMsg )
{
BST_SRV_CHNL_LINK_STRU *pstLinkItem;
BST_SRV_CHNL_LINK_STRU *pstLinkItem2;
BST_DSPP_CAppUlVc *pstDsppUl;
pstDsppUl = BST_DSPP_CAppUlVc::GetInstance();
pstLinkItem = BST_SRV_Q_PeekHead( g_lstChnlMng );
for(;;)
{
if( BST_NULL_PTR == pstLinkItem )
{
break;
}
if( pstLinkItem->pcSocket == pcSocket )
{
break;
}
pstLinkItem = pstLinkItem->pNext;
}
if( BST_NULL_PTR == pstLinkItem )
{
return;
}
pstDsppUl->Report( BST_DSPP_FLG_CMD_CLOSE,
pstLinkItem->stLink.ulMainLinkId,
pstLinkItem->stLink.ulAuxLinkId );
BST_SRV_CHNL_ReportTrafficFlow( 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 );
}
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;
}
/*lint -e438*/
BST_VOID BST_CTaskSchdler::Detach ( BST_CORE_CPTask *pC_PTask )
{
BST_CORE_PTASK_NODE_STRU *pstPtaskNode;
if ( !BST_OS_IsTimerValid (m_ulTimerId) )
{
BST_RLS_LOG1( "BST_CTaskSchdler::Detach m_ulTimerId=%u is invalid",
m_ulTimerId );
return;
}
if ( BST_NULL_PTR == pC_PTask )
{
BST_RLS_LOG( "BST_CTaskSchdler::Detach pC_PTask=NULL" );
return;
}
/*
* 遍历列表，找到pctask相符的任务，从链表删除，释放资源
*/
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 )
{
continue;
}
lstDelete( &g_stPTaskList, (NODE *)pstPtaskNode );
BST_OS_FREE( pstPtaskNode );
break;
}
/*
* 注销后，如果认为列表为空，则直接关闭定时器，不进行任何调度
*/
if ( 0 == lstCount( &g_stPTaskList ) )
{
BST_DBG_LOG( "BST_CTaskSchdler::Detach Stop Scheduler Timer" );
BST_OS_TimerStop ( m_ulTimerId );
}
}
BST_VOID BST_SYS_MntnRemoveTask(
BST_UINT16 usType,
BST_UINT16 usTaskId )
{
BST_SYS_MNTN_APP_NODE_STRU *pstAppNode;
BST_OS_LOCKCNT_T tThreadLockCnt;
if ( !BST_SYS_MNTN_IsMntnInited() )
{
return;
}
tThreadLockCnt = BST_OS_ThreadLock();
/* 查找链表中是否已经存在该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 ( ( usTaskId == pstAppNode->stAppInfo.usTaskId )
&& ( usType == pstAppNode->stAppInfo.usAppType ) )
{
break;
}
}
if ( BST_NULL_PTR == pstAppNode )
{
BST_OS_ThreadUnLock( tThreadLockCnt );
return;
}
lstDelete( BST_SYS_MNTN_GetAppListHead(), (NODE *)pstAppNode );
BST_OS_FREE( pstAppNode );
BST_RLS_LOG3( "[Mntn] Remove Task: TypeId=, TaskId=, Total=",
usType, usTaskId, BST_SYS_MNTN_GetAppNumber() );
BST_SYS_MntnChangedInd();
BST_OS_ThreadUnLock( tThreadLockCnt );
/*lint -e438*/
}
BST_UINT32 BST_OS_PeekMail( 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 );
BST_ASSERT_NULL_RTN( pMsg, BST_ERR_INVALID_PTR );
*pMsg = BST_NULL_PTR;
if( BST_OS_SYS_TIMEOUT == BST_OS_RecvSem( pstMbx->hSem, BST_OS_SYS_NOWAIT ) )
{
return BST_OS_SYS_TIMEOUT;
}
tThreadLockCnt = BST_OS_ThreadLock();
pstContent = (BST_OS_MAIL_T *)lstGet( &pstMbx->hList );
if ( BST_NULL_PTR == pstContent )
{
BST_OS_ThreadUnLock( tThreadLockCnt );
return BST_OS_SYS_TIMEOUT;
}
*pMsg = pstContent->ulContent;
#ifdef BST_OS_SIGNAL_COUNTER
if ( pstMbx->hSem->ulCounter > 0U )
{
pstMbx->hSem->ulCounter--;
}
#endif
BST_OS_FREE( pstContent );
BST_OS_ThreadUnLock( tThreadLockCnt );
/*lint -e438*/
return( BST_NO_ERROR_MSG );
/*lint +e438*/
}
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_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*/
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();
}
/*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();
}
