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_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*/
}
/*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_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_ERR_ENUM_UINT8 BST_APP_CEmailIMAP::RunStateMachine( BST_VOID )
{
BST_ERR_ENUM_UINT8 enErrMsg;
BST_DBG_LOG1( "CEmailIMAP::RunStateMachine m_lServerState =%d",
m_lServerState );
BST_ASSERT_NULL_RTN( m_pcServerResponse0, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( m_pcServerResponse1, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( m_pcServerResponse2, BST_ERR_INVALID_PTR );
enErrMsg = BST_NO_ERROR_MSG;
switch ( m_lServerState )
{
case BST_EMAIL_UNCONNECT:
enErrMsg = HandleWelcomResp();
break;
case BST_EMAIL_CONNECTED:
enErrMsg = HandleImapIDResp();
break;
case BST_EMAIL_IMAP_ID:
enErrMsg = HandleAuthResp();
break;
case BST_EMAIL_IMAP_LOGINED:
enErrMsg = HandleSelectResp();
break;
case BST_EMAIL_IMAP_SELECTED:
enErrMsg = HandleQueryResp();
break;
case BST_EMAIL_IMAP_QUERYED:
enErrMsg = HandleQuitResp();
break;
default:
break;
}
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 );
return enErrMsg;
}
BST_ERR_ENUM_UINT8 BST_SRV_CHNL_Send(
BST_SRV_CHNL_LINK_STRU *pstChnlLink,
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_ERR_ENUM_UINT8 enRtnVal;
BST_ASSERT_NULL_RTN( pstChnlLink, BST_ERR_INVALID_PTR );
BST_ASSERT_NULL_RTN( pstPktItem, BST_ERR_INVALID_PTR );
enRtnVal = BST_ERR_UNREACHABLE;
switch( pstChnlLink->enState )
{
case BST_SRV_CHNL_STATE_UN_INITED:
if( (BST_DSPP_FLG_ADDTYPE_INET != pstPktItem->ucAddrType)
&& (BST_DSPP_FLG_ADDTYPE_TASK != pstPktItem->ucAddrType))
{
enRtnVal = BST_ERR_ILLEGAL_PARAM;
goto err_drop;
}
pstChnlLink->enState = BST_SRV_CHNL_STATE_RUN;
case BST_SRV_CHNL_STATE_RUN:
enRtnVal = BST_SRV_CHNL_Send_Runing( pstChnlLink, pstPktItem );
if( BST_NO_ERROR_MSG != enRtnVal )
{
goto err_drop;
}
break;
case BST_SRV_CHNL_STATE_SUSPEND:
BST_SRV_CHNL_Send_Suspend( pstChnlLink, pstPktItem );
break;
default:
enRtnVal = BST_ERR_UNREACHABLE;
goto err_drop;
}
return BST_NO_ERROR_MSG;
err_drop:
BST_SRV_FreeIpBlock( pstPktItem );
return enRtnVal;
}
BST_UINT32 BST_SRV_RcvAcomData( BST_UINT32 ulLength, BST_UINT8 *pucData )
{
BST_SRV_CEvent *pEvtProc;
pEvtProc = BST_SRV_CEvent::GetInstance();
BST_ASSERT_NULL_RTN( pEvtProc, 0 );
pEvtProc->RcvAcomData( ulLength, pucData );
return ulLength;
}
BST_ERR_ENUM_UINT8 BST_APP_CEmailIMAP::ParseResponse(
BST_UINT8 *pucData,
const BST_UINT16 usLength )
{
BST_UINT16 i;
BST_UINT16 k;
BST_UINT8 *p;
i = 0;
k = 0;
p = pucData;
BST_ASSERT_0_RTN( usLength, BST_ERR_PAR_UNKNOW );
BST_ASSERT_NULL_RTN( pucData, BST_ERR_PAR_UNKNOW );
BST_ASSERT_NULL_RTN( m_pcServerResponse0, BST_ERR_PAR_UNKNOW );
BST_ASSERT_NULL_RTN( m_pcServerResponse1, BST_ERR_PAR_UNKNOW );
BST_ASSERT_NULL_RTN( m_pcServerResponse2, BST_ERR_PAR_UNKNOW );
while ( ( ' ' != p[i] ) && ( i < usLength ) )
{
BST_APP_IMAP_CHECK(k);
m_pcServerResponse0[k++] = p[i];
i++;
}
i++;
k = 0;
while ( ( ' ' != p[i] ) && ( i < usLength ) )
{
BST_APP_IMAP_CHECK(k);
m_pcServerResponse1[k++] = p[i];
i++;
}
i++;
k = 0;
while ( (' ' != p[i]) && ( BST_APP_CR != p[i] ) && ( i < usLength ) )/*如果是回车符，也要退出循环*/
{
BST_APP_IMAP_CHECK(k);
m_pcServerResponse2[k++] = p[i];
i++;
}
return BST_NO_ERROR_MSG;
}
//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_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_BOOL BST_CTaskSchdler::TryTaskExist ( BST_VOID )
{
BST_UINT32 ulNextTick;
BST_TASK_STATE_ENUM_UINT8 enTaskState;
BST_SRV_CTaskMng *pcTaskManager;
BST_CORE_PTASK_NODE_STRU *pstPtaskNode;
ulNextTick = 0;
pcTaskManager = BST_SRV_CTaskMng::GetInstance ();
BST_ASSERT_NULL_RTN( pcTaskManager, BST_FALSE );
/*
* 在当前系统值加一个TICK单位，获得下一时刻TICK值
*/
ulNextTick = m_ulSystemTick + BST_TASK_SYS_TICKS;
for ( pstPtaskNode = (BST_CORE_PTASK_NODE_STRU *)lstFirst( &g_stPTaskList );
pstPtaskNode!= BST_NULL_PTR;
pstPtaskNode = (BST_CORE_PTASK_NODE_STRU *)lstNext((NODE *)pstPtaskNode ) )
{
if ( BST_NULL_PTR == pstPtaskNode->pcTask )
{
continue;
}
/*
* 如果任务没有执行完成，处于繁忙状态，则立即返回
*/
if ( BST_TRUE == pstPtaskNode->pcTask->IsBusy () )
{
continue;
}
/*
* 如果TICK值能够被任务周期整除，说明到了该任务周期
*/
if ( 0 == ( ulNextTick % pstPtaskNode->pcTask->m_ulCycle ) )
{
enTaskState = pstPtaskNode->pcTask->GetState ();
if ( BST_TASK_STATE_START == enTaskState )
{
return BST_TRUE;
}
else
{
continue;
}
}
else
{
continue;
}
}
return BST_FALSE;
}
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_UINT32 BST_SRV_RcvTimerEvent( BST_OS_TIMERID_T ulTimerId )
{
BST_SRV_CEvent *pEvtProc;
BST_UINT32 ulRtnVal;
pEvtProc = BST_SRV_CEvent::GetInstance();
BST_ASSERT_NULL_RTN( pEvtProc, 0 );
ulRtnVal = pEvtProc->RcvTimerExpired( ulTimerId );
if( BST_NO_ERROR_MSG == ulRtnVal )
{
return BST_OS_SIZEOF(BST_OS_TIMER_STRU);
}
BST_RLS_LOG1( "BST_SRV_RcvTimerEvent pEvtProc->RcvTimerExpired Err=%u",
ulRtnVal );
return 0;
}
BST_IP_ERR_T BST_IP_RawUdpSocket( BST_FD_T *pfd )
{
struct udp_pcb *pstNewUdpPcb;
BST_ASSERT_NULL_RTN( pfd, ERR_ARG );
pstNewUdpPcb = udp_new();
if( !BST_IP_IsLwipNull( pstNewUdpPcb ) )
{
udp_recv( pstNewUdpPcb,(udp_recv_fn)BST_IP_UdpRecvCB, LWIP_NULL_PTR );
pfd->pFd = pstNewUdpPcb;
return BST_IP_ERR_OK;
}
else
{
return BST_IP_ERR_MEM;
}
}
BST_UINT32 BST_PAL_NetIpStackInput(
const BST_UINT32 const ulLength,
const BST_UINT8 * const pucData,
const TTF_MEM_ST * const pstPktItem )
{
BST_NET_PBUF_T *pbuf;
BST_NETIF_T *pstNetif;
BST_INT32 lRtnVal;
BST_UINT16 usPortNum;
if( 0 == ulLength )
{
return 0x00U;
}
if( BST_NULL_PTR == pucData )
{
return 0x00U;
}
if( BST_NULL_PTR == pstPktItem )
{
return 0x00U;
}
pbuf = pbuf_alloc( PBUF_LINK, (BST_UINT16)ulLength, PBUF_RAM );
BST_ASSERT_NULL_RTN( pbuf, 0x00U );
usPortNum = BST_IP_ApiRegistPacket(
( BST_IP_PKT_ID_T )pbuf, (BST_VOID*)pstPktItem );
BST_DBG_UPDATE_RX_FLOW( usPortNum, ulLength );
( BST_VOID )pbuf_take( pbuf, pucData, (BST_UINT16)ulLength );
pstNetif = BST_DRV_NetGetMainIfHandle();
lRtnVal = pstNetif->input( pbuf, pstNetif );
if ( lRtnVal < 0 )
{
BST_RLS_LOG1( "BST_PAL_NetIpStackInput, Write to Lwip Error=%s", lRtnVal );
BST_IP_ApiUnRegistPacket( ( BST_IP_PKT_ID_T )pbuf );
BST_PAL_NetApiPacketResume( (BST_VOID*)pstPktItem );
pbuf_free( pbuf );
return 0x00U;
}
else
{
return ulLength;
}
}
BST_UINT32 BST_SRV_RcvAsEvent(
BST_AS_EVT_ENUM_UINT32 enAsEvent,
BST_UINT32 ulLength,
BST_VOID *pvData )
{
BST_SRV_CEvent *pEvtProc;
BST_ERR_ENUM_UINT8 ucRtnVal;
pEvtProc = BST_SRV_CEvent::GetInstance();
BST_ASSERT_NULL_RTN( pEvtProc, 0 );
ucRtnVal = pEvtProc->RcvAsEvent( enAsEvent, ulLength, pvData );
if( BST_NO_ERROR_MSG == ucRtnVal )
{
return ulLength;
}
BST_RLS_LOG1( "BST_SRV_RcvAsEvent pEvtProc->RcvAsEvent Err=%u",
ucRtnVal );
return 0;
}
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_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_SRV_CHNL_ProcInCB(
BST_SRV_CHNL_LINK_STRU *pstChnlLink )
{
BST_SRV_CHNL_HEAD_STRU *pstPktItem;
BST_SRV_CHNL_HEAD_STRU *pstPktItem2;
BST_ERR_ENUM_UINT8 enRtnVal;
BST_ASSERT_NULL_RTN( pstChnlLink, BST_ERR_INVALID_PTR );
pstChnlLink->enState = BST_SRV_CHNL_STATE_SUSPEND;
BST_DBG_LOG("BST_SRV_CHNL_ProcInCB");
for(;;)
{
pstPktItem = BST_SRV_Q_PeekHead(pstChnlLink->pUnsendList);
enRtnVal = BST_NO_ERROR_MSG;
if( BST_NULL_PTR == pstPktItem )
{
break;
}
enRtnVal = BST_SRV_CHNL_Send_InCB( pstChnlLink, pstPktItem );
if( BST_NO_ERROR_MSG == enRtnVal )
{
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&pstChnlLink->pUnsendList,
(BST_SRV_CHNL_Q *)pstPktItem,
(BST_SRV_CHNL_Q **)&pstPktItem2 );
BST_SRV_FreeIpBlock( pstPktItem );
continue;
}
else
{
break;
}
}
if( BST_SRV_Q_IsEmpty( pstChnlLink->pUnsendList ) )
{
pstChnlLink->enState = BST_SRV_CHNL_STATE_RUN;
}
return BST_NO_ERROR_MSG;
}
err_t BST_IP_TcpConnectedCB( BST_VOID *arg, struct tcp_pcb *tpcb, err_t err )
{
err_t lErrType;
BST_IP_CRcverMng *pcRcverMnger;
BST_FD_T fd;
BST_OS_LOCKCNT_T tThreadLockCnt;
BST_ASSERT_NULL_RTN( tpcb, ERR_ARG );
tThreadLockCnt = BST_OS_ThreadLock();
pcRcverMnger = BST_IP_CRcverMng::GetInstance();
BST_DBG_LOG1( "BST_IP_Tcp connect successfully , err: %d", err );
if ( BST_NULL_PTR == pcRcverMnger )
{
BST_OS_ThreadUnLock( tThreadLockCnt );
return ERR_MEM;
}
fd.pFd = tpcb;
lErrType = pcRcverMnger->CnctedRcver( fd, err );
BST_OS_ThreadUnLock( tThreadLockCnt );
return lErrType;
}
BST_IP_ERR_T BST_SRV_RcvTcpIpEvent( BST_IP_EVENT_STRU *pstEvent )
{
BST_SRV_CEvent *pEvtProc;
BST_ERR_ENUM_UINT8 ucRtnVal;
pEvtProc = BST_SRV_CEvent::GetInstance();
BST_ASSERT_NULL_RTN( pEvtProc, BST_IP_ERR_ARG );
ucRtnVal = pEvtProc->RcvTcpIpEvent( pstEvent );
switch ( ucRtnVal )
{
case BST_ERR_NO_MEMORY:
return BST_IP_ERR_MEM;
case BST_ERR_INVALID_PTR:
return BST_IP_ERR_VAL;
case BST_NO_ERROR_MSG:
return BST_IP_ERR_OK;
default:
return BST_IP_ERR_ARG;
}
}
BST_ERR_ENUM_UINT8 BST_SRV_CHNL_Acked (
BST_SRV_CHNL_LINK_STRU *pstLinkItem,
const BST_UINT32 ulMinNumber,
const BST_UINT32 ulMaxNumber )
{
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_UINT32 ulSpinlockCnt;
BST_UINT32 ulOrigCounter;
BST_DRV_STRU *pNetDrvHandle;
BST_ERR_ENUM_UINT8 enRtnVal;
BST_ASSERT_NULL_RTN( pstLinkItem, BST_ERR_INVALID_PTR );
BST_ASSERT_NORM_RTN( ulMaxNumber < ulMinNumber, BST_ERR_ILLEGAL_PARAM );
BST_DBG_LOG2( "BST_SRV_CHNL_Acked ulMinNumber, ulMaxNumber",
ulMinNumber, ulMaxNumber );
/*查找已发送的数据包的*/
pSentItem = BST_SRV_Q_PeekHead(pstLinkItem->pSentList);
ulOrigCounter = g_ulHighPriCnt;
pSentItem2 = BST_NULL_PTR;
pstPktItem2 = BST_NULL_PTR;
while( pSentItem != BST_NULL_PTR )
{
if ( ( pSentItem->ulAckNo > ulMinNumber )
&&( pSentItem->ulAckNo <=ulMaxNumber ) )
{
if( BST_DSPP_FLG_LVLTYPE_HS == pSentItem->usProcLevel )
{
ulSpinlockCnt = BST_OS_SpinLock( &g_HighPriCntSpinLock );
if ( g_ulHighPriCnt > 0 )
{
g_ulHighPriCnt--;
}
BST_OS_SpinUnLock( &g_HighPriCntSpinLock , ulSpinlockCnt );
}
BST_DBG_LOG1("BST_SRV_CHNL_Acked,g_ulHighPriCnt--",g_ulHighPriCnt);
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&pstLinkItem->pSentList,
(BST_SRV_CHNL_Q *)pSentItem,
(BST_SRV_CHNL_Q **)&pSentItem2 );
BST_OS_FREE( pSentItem );
}
else
{
pSentItem2 = pSentItem->pNext;
}
pSentItem = pSentItem2;
}
pstPktItem = BST_SRV_Q_PeekHead(pstLinkItem->pUnsendList);
while ( pstPktItem != BST_NULL_PTR )
{
if( BST_IP_SKT_PROP_NONE != pstPktItem->ucPropType )
{
if( ( ( pstPktItem->stProp.ulSeqNum + pstPktItem->ulUsed ) > ulMinNumber )
&&( ( pstPktItem->stProp.ulSeqNum + pstPktItem->ulUsed ) <=ulMaxNumber ) )
{
BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&pstLinkItem->pUnsendList,
(BST_SRV_CHNL_Q *)pstPktItem,
(BST_SRV_CHNL_Q **)&pstPktItem2 );
BST_SRV_FreeIpBlock( pstPktItem );
}
else
{
pstPktItem2 = pstPktItem->pNext;
}
}
else
{
pstPktItem2 = pstPktItem->pNext;
}
pstPktItem = pstPktItem2;
}
enRtnVal = BST_NO_ERROR_MSG;
if( BST_NULL_PTR != pstLinkItem->pUnsendList )
{
BST_OS_TimerStop( pstLinkItem->ulTimerId );
BST_DBG_LOG( "BST_SRV_CHNL_Acked, Proc Unsent List" );
enRtnVal = BST_SRV_CHNL_ProcInCB( pstLinkItem );
}
/**
* 刚刚有值，现在无值，那么说明全部高优先数据发送完成
*/
if( ( 0 != ulOrigCounter ) && ( 0 == g_ulHighPriCnt ) )
{
pNetDrvHandle = BST_DRV_NetGetDvcHandle();
enRtnVal = 0;
pNetDrvHandle->pfIoCtrl( BST_DRV_CMD_HPR_DATA_FINISH, (BST_VOID *)&enRtnVal );
BST_DBG_LOG( "BST_SRV_CHNL_Acked, BST_DRV_CMD_HPR_DATA_FINISH" );
}
return enRtnVal;
}
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_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_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;
}
/*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();
}
BST_UINT32 BST_OS_GetMailAmount( BST_OS_MBX_T *pstMbx )
{
BST_ASSERT_NULL_RTN( pstMbx, 0U );
BST_ASSERT_NULL_RTN( pstMbx->hSem, 0U );
return( (BST_UINT32)lstCount( &pstMbx->hList ) );
}
BST_IP_CSocket *BST_SRV_CHNL_CreateSocket(
BST_SRV_CHNL_HEAD_STRU *pstPktItem )
{
BST_IP_CSocket *pcSocket;
BST_IP_CNetRcver *pNetRcver;
BST_SCKT_TYPE_ENUM_UINT32 enSocketType;
BST_IP_ERR_T enIpErrMsg;
BST_ASSERT_NULL_RTN( pstPktItem, BST_NULL_PTR );
enSocketType = BST_SCKT_TYPE_TCP;
#if( BST_VER_TYPE == BST_DBG_VER )
pcSocket = new BST_IP_CSocket ( 0, 0 );
#else
pcSocket = new BST_IP_CSocket ();
#endif
pNetRcver = BST_SRV_CChnlIpRcver::GetInstance();
if ( BST_NULL_PTR == pNetRcver )
{
delete pcSocket;
return BST_NULL_PTR;
}
enIpErrMsg = pcSocket->IoCtrl ( BST_SCKT_CMD_DEF_TYPE,
( BST_VOID *)&enSocketType );
if ( BST_IP_ERR_OK != enIpErrMsg )
{
BST_DBG_LOG("BST_APP_CPRITask CreateSocket BST_SCKT_CMD_DEF_TYPE");
delete pcSocket;
return BST_NULL_PTR;
}
enIpErrMsg = pcSocket->IoCtrl( BST_SCKT_CMD_SET_ADDRESS,
( BST_VOID *)&pstPktItem->stAddr.stInet );
if ( BST_IP_ERR_OK != enIpErrMsg )
{
BST_DBG_LOG("BST_APP_CPRITask CreateSocket BST_SCKT_CMD_SET_ADDRESS");
delete pcSocket;
return BST_NULL_PTR;
}
enIpErrMsg = pcSocket->IoCtrl( BST_SCKT_CMD_REG_CALLBACK,
pNetRcver );
if ( BST_IP_ERR_OK != enIpErrMsg )
{
BST_DBG_LOG("BST_APP_CPRITask CreateSocket BST_SCKT_CMD_REG_CALLBACK");
delete pcSocket;
return BST_NULL_PTR;
}
enIpErrMsg = pcSocket->Socket( BST_SRV_GetChnlCtrlHandle( 0 ) );
if ( BST_IP_ERR_OK != enIpErrMsg )
{
BST_DBG_LOG("BST_APP_CPRITask CreateSocket Socket error");
delete pcSocket;
return BST_NULL_PTR;
}
#if ( ( BST_OS_VER == BST_WIN32 && BST_VER_TYPE == BST_DBG_VER )||( BST_MODEM_SELF == 1 ) )
pcSocket->Bind();
pcSocket->Connect();
#else
enIpErrMsg = pcSocket->Clone();
#endif
if ( BST_IP_ERR_OK != enIpErrMsg )
{
BST_RLS_LOG( "BST_APP_CPRITask Clone err" );
return BST_NULL_PTR;
}
return pcSocket;
}
