BST_VOID BST_SYS_MntnUpdateIpInfo( BST_UINT16 usType, BST_UINT16 usTaskId, BST_VOID *pstIpInfo ) { OM_BST_APP_INFO_STRU *pstAppInfo; BST_IP_SOCKET_ADD_T *pstSocketInfo; BST_OS_LOCKCNT_T tThreadLockCnt; if ( !BST_SYS_MNTN_IsMntnInited() ) { return; } if ( BST_NULL_PTR == pstIpInfo ) { return; } pstSocketInfo = ( BST_IP_SOCKET_ADD_T *)pstIpInfo; tThreadLockCnt = BST_OS_ThreadLock(); pstAppInfo = BST_SYS_MntnSrchAppByTask( usType, usTaskId ); if ( BST_NULL_PTR == pstAppInfo ) { BST_OS_ThreadUnLock( tThreadLockCnt ); return; } pstAppInfo->usLocalPort = pstSocketInfo->usLocalPort; pstAppInfo->usRemotePort = pstSocketInfo->usRemotePort; BST_OS_MEMCPY( &pstAppInfo->aucLocalIp[0], BST_SYS_MNTN_GetLocalIpHead(), OM_BST_IP_ADDR_LEN ); BST_OS_MEMCPY( &pstAppInfo->aucRemoteIp[0], &pstSocketInfo->aucRemoteIp[0], OM_BST_IP_ADDR_LEN ); BST_RLS_LOG4( "[Mntn] Socket Configed_01: TypeId=, TaskId=, LocalPort=, RemotePort=", usType, usTaskId, (pstSocketInfo)->usLocalPort, (pstSocketInfo)->usRemotePort ); BST_RLS_LOG4( "[Mntn] Socket Configed_02: Remote Ip Address", (pstAppInfo)->aucRemoteIp[3], (pstAppInfo)->aucRemoteIp[2], (pstAppInfo)->aucRemoteIp[1], (pstAppInfo)->aucRemoteIp[0]); BST_RLS_LOG4( "[Mntn] Socket Configed_02: Local Ip Address", (pstAppInfo)->aucLocalIp[3], (pstAppInfo)->aucLocalIp[2], (pstAppInfo)->aucLocalIp[1], (pstAppInfo)->aucLocalIp[0]); BST_SYS_MntnChangedInd(); BST_OS_ThreadUnLock( tThreadLockCnt ); }
/*lint -e438 -e429*/ BST_UINT32 BST_SRV_CEvent::RcvTimerExpired ( BST_OS_TIMERID_T ulTimerId ) { BST_TIMER_EVT_STRU *pstSendTimerEvent; if( BST_NULL_PTR == m_pstEventMbx ) { return BST_ERR_INVALID_PTR; } pstSendTimerEvent = ( BST_TIMER_EVT_STRU *)BST_OS_MALLOC ( BST_OS_SIZEOF(BST_TIMER_EVT_STRU) ); BST_ASSERT_NULL_RTN( pstSendTimerEvent, BST_ERR_NO_MEMORY ); pstSendTimerEvent->pucData = ( BST_UINT8 *)BST_OS_MALLOC ( BST_OS_SIZEOF(ulTimerId) ); if ( BST_NULL_PTR == pstSendTimerEvent->pucData ) { BST_OS_FREE( pstSendTimerEvent ); return BST_ERR_NO_MEMORY; } pstSendTimerEvent->ulLength = BST_OS_SIZEOF( ulTimerId ); BST_OS_MEMCPY( pstSendTimerEvent->pucData, &ulTimerId, pstSendTimerEvent->ulLength ); pstSendTimerEvent->enId = BST_SRV_TIMER_EVENT; return BST_OS_SendMail( m_pstEventMbx, pstSendTimerEvent ); }
BST_ERR_ENUM_UINT8 BST_CORE_CNPTask::ConfigedPriodic( BST_UINT16 usLen, const BST_VOID *const pData, BST_UINT8 **pucNewAddr ) { BST_UINT32 ulTimerTicks; BST_ERR_ENUM_UINT8 ucRtnVal; if ( usLen < BST_OS_SIZEOF ( BST_UINT32 ) ) { BST_RLS_LOG1( "BST_CORE_CNPTask::ConfigedPriodic usLen=%u", usLen ); return BST_ERR_PAR_LEN; } BST_OS_MEMCPY( &ulTimerTicks, pData, BST_OS_SIZEOF(BST_UINT32) ); ucRtnVal = ConfigCycleTicks ( ulTimerTicks ); if ( ucRtnVal == BST_NO_ERROR_MSG ) { *pucNewAddr = ( BST_UINT8 * )&m_ulCycle; BST_SetConfigFlag ( BST_CFGFLG_CYCL ); } else { *pucNewAddr = BST_NULL_PTR; } return ucRtnVal; }
/*lint -e438 -e429*/ BST_ERR_ENUM_UINT8 BST_SRV_CEvent::RcvAcomData( BST_UINT32 ulLength, BST_UINT8 *pucData ) { BST_ACOM_EVT_STRU *pstAcpuEvent; if( BST_NULL_PTR == m_pstEventMbx ) { return BST_ERR_INVALID_PTR; } if( BST_NULL_PTR == pucData ) { return BST_ERR_INVALID_PTR; } if( 0 == ulLength ) { return BST_ERR_PAR_LEN; } pstAcpuEvent = (BST_ACOM_EVT_STRU *)BST_OS_MALLOC( BST_OS_SIZEOF(BST_ACOM_EVT_STRU) ); BST_ASSERT_NULL_RTN( pstAcpuEvent, BST_ERR_NO_MEMORY ); pstAcpuEvent->pucData = (BST_UINT8 *)BST_OS_MALLOC( ulLength ); if ( BST_NULL_PTR == pstAcpuEvent->pucData ) { BST_OS_FREE( pstAcpuEvent ); return BST_ERR_NO_MEMORY; } pstAcpuEvent->enId = BST_SRV_ACOM_EVENT; pstAcpuEvent->ulLength = ulLength; BST_OS_MEMCPY( pstAcpuEvent->pucData, pucData, ulLength ); return BST_OS_SendMail( m_pstEventMbx, pstAcpuEvent ); }
/*lint -e438 -e429*/ BST_ERR_ENUM_UINT8 BST_SRV_CEvent::RcvTcpIpEvent ( BST_IP_EVENT_STRU *pstEvent ) { BST_NET_EVENT_STRU *pstNetEvent; BST_IP_EVENT_STRU *pstLwipEvent; if ( BST_NULL_PTR == m_pstEventMbx ) { return BST_ERR_INVALID_PTR; } if ( BST_NULL_PTR == pstEvent ) { return BST_ERR_INVALID_PTR; } pstLwipEvent = ( BST_IP_EVENT_STRU *)BST_OS_MALLOC ( BST_OS_SIZEOF ( BST_IP_EVENT_STRU ) ); BST_ASSERT_NULL_RTN( pstLwipEvent, BST_ERR_NO_MEMORY ); pstNetEvent = ( BST_NET_EVENT_STRU *)BST_OS_MALLOC ( BST_OS_SIZEOF ( BST_NET_EVENT_STRU ) ); if ( BST_NULL_PTR == pstNetEvent ) { BST_OS_FREE( pstLwipEvent ); return BST_ERR_INVALID_PTR; } BST_OS_MEMCPY ( pstLwipEvent, pstEvent, BST_OS_SIZEOF ( BST_IP_EVENT_STRU ) ); pstNetEvent->enId = BST_SRV_TCPIP_EVENT; pstNetEvent->pucData = ( BST_UINT8 * )pstLwipEvent; pstNetEvent->ulLength = BST_OS_SIZEOF ( BST_IP_EVENT_STRU ); return BST_OS_SendMail( m_pstEventMbx, pstNetEvent ); }
BST_VOID BST_CTaskSchdler::AsEventCallback( BST_AS_EVT_ENUM_UINT32 enEvent, BST_UINT32 ulLength, BST_VOID *pvData ) { BST_UINT32 ulPara; switch( enEvent ) { /* * 仅处理RRC状态信息,当RRC连接成功时,查看当前剩余时间是否靠近 */ case BST_AS_EVT_L3_RRC_STATE: if ( BST_OS_SIZEOF(ulPara) != ulLength ) { break; } if ( BST_NULL_PTR == pvData ) { break; } BST_OS_MEMCPY( &ulPara, pvData, ulLength ); if( BST_AS_RRC_CONNECTED == ulPara ) { ulPara = BST_OS_TimerIsStop( m_ulTimerId ); if ( BST_TRUE == ulPara ) { break; } ulPara = BST_OS_TimeGetRemain( m_ulTimerId ); if ( 0 == ulPara ) { break; } ulPara = NearRrcTrig ( ulPara ); BST_OS_TimerStart( m_ulTimerId, ulPara ); } break; case BST_AS_EVT_L3_BLOCK_INFO: if ( BST_OS_SIZEOF(BST_UINT32) != ulLength ) { BST_RLS_LOG1("BST_CTaskSchdler::AsEventCallback Error blockinfo Length = %u:", ulLength ); break; } UtranBlockInfoChgProc( (BST_UINT32 *)pvData ); break; default: break; } }
BST_VOID BST_SYS_MntnCofigLoacalIpAddress( BST_UINT8 *aucLocalIp, BST_UINT16 usBufLen ) { if ( BST_NULL_PTR == aucLocalIp ) { BST_RLS_LOG( "[Mntn] BST_SYS_MntnCofigLoacalIpAddress Error Pointer" ); return; } if ( OM_BST_IP_ADDR_LEN > usBufLen ) { BST_RLS_LOG1( "[Mntn] BST_SYS_MntnCofigLoacalIpAddress Error Size:", usBufLen ); return; } BST_OS_MEMCPY( &g_stBstMntnEntity.aucLocalIp[0], aucLocalIp, OM_BST_IP_ADDR_LEN ); return; }
/*lint -e438 -e429*/ BST_ERR_ENUM_UINT8 BST_SRV_CEvent::RcvAsEvent( BST_AS_EVT_ENUM_UINT32 enAsEvent, BST_UINT32 ulLength, BST_VOID *pvData ) { BST_AS_EVT_STRU *pstSendAsEvent; if( BST_NULL_PTR == m_pstEventMbx ) { return BST_ERR_INVALID_PTR; } if( !BST_SRV_IsValidAsEvent( enAsEvent ) ) { return BST_ERR_INVALID_PTR; } pstSendAsEvent = (BST_AS_EVT_STRU *)BST_OS_MALLOC( BST_OS_SIZEOF(BST_AS_EVT_STRU) ); BST_ASSERT_NULL_RTN( pstSendAsEvent, BST_ERR_NO_MEMORY ); if( ( BST_NULL_PTR == pvData ) || ( 0 == ulLength ) ) { pstSendAsEvent->pucData = BST_NULL_PTR; pstSendAsEvent->ulLength = 0; } else { pstSendAsEvent->pucData = (BST_UINT8 *)BST_OS_MALLOC( ulLength ); if ( BST_NULL_PTR == pstSendAsEvent->pucData ) { BST_RLS_LOG( "BST_SRV_CEvent::RcvAsEvent No Memory" ); BST_OS_FREE( pstSendAsEvent ); return BST_ERR_NO_MEMORY; } pstSendAsEvent->ulLength = ulLength; BST_OS_MEMCPY( pstSendAsEvent->pucData, pvData, ulLength ); } pstSendAsEvent->enId = BST_SRV_AS_EVENT; pstSendAsEvent->enAsEvent = enAsEvent; return BST_OS_SendMail( m_pstEventMbx, pstSendAsEvent ); }
BST_ERR_ENUM_UINT8 BST_Pal_DrvAcomSend( BST_UINT32 ulLength, BST_UINT8 *pucData ) { #ifndef BST_MODEM_SELF #ifndef BST_PEAK_SPEED_TEST BST_ACOM_MSG_STRU *pstAcorMsg; BST_UINT8 *ulTmpAddr; BST_ASSERT_NULL_RTN( pucData, BST_ERR_INVALID_PTR ); pstAcorMsg = BST_ACOMM_ALLOC_MSG_WITH_HDR( ulLength ); BST_ASSERT_NULL_RTN( pstAcorMsg, BST_ERR_NO_MEMORY ); ulTmpAddr = (pstAcorMsg->aucValue); BST_OS_MEMCPY((BST_VOID*)ulTmpAddr, pucData, ulLength); pstAcorMsg->ulLen = ulLength; BST_ACOMM_CFG_MSG_HDR( pstAcorMsg, ACPU_PID_BASTET_COMM ); BST_ACOMM_SEND_MSG( pstAcorMsg ); #endif #endif return BST_NO_ERROR_MSG; }
BST_IP_ERR_T BST_IP_RawUdpSend( BST_FD_T fd, BST_UINT8* pData, BST_UINT16 usLength ) { struct pbuf *pstPbuf; struct udp_pcb *upcb; if( BST_NULL_PTR == pData ) { return BST_IP_ERR_MEM; } if( !BST_IP_IsRawFdValid(fd) ) { return BST_IP_ERR_MEM; } upcb = (struct udp_pcb *)fd.pFd; pstPbuf = pbuf_alloc( PBUF_RAW, usLength, PBUF_POOL ); if( BST_IP_IsLwipNull(pstPbuf) ) { return BST_IP_ERR_BUF; } BST_OS_MEMCPY( pstPbuf->payload, pData, usLength ); return udp_send( upcb, pstPbuf ); }
BST_UINT32 BST_SYS_MntnBuildAgentInfoInd( OM_BST_APP_INFO_STRU *pstAgentInfo, const BST_UINT16 usAppNumber ) { BST_SYS_MNTN_APP_NODE_STRU *pstAppNode; BST_UINT16 usAppCounter; BST_OS_LOCKCNT_T tThreadLockCnt; if ( BST_NULL_PTR == pstAgentInfo ) { return BST_FALSE; } tThreadLockCnt = BST_OS_ThreadLock(); usAppCounter = 0; /* 查找链表中是否已经存在该Task信息 */ for ( pstAppNode = ( BST_SYS_MNTN_APP_NODE_STRU *)lstFirst(BST_SYS_MNTN_GetAppListHead()); pstAppNode != BST_NULL_PTR; pstAppNode = ( BST_SYS_MNTN_APP_NODE_STRU *)lstNext( (NODE *)pstAppNode ) ) { if ( ID_BST_OM_TASK_TYPE_MAIN == pstAppNode->stAppInfo.usAppType ) { continue; } BST_OS_MEMCPY( &pstAgentInfo[usAppCounter], &(pstAppNode->stAppInfo), BST_OS_SIZEOF(OM_BST_APP_INFO_STRU) ); usAppCounter++; if ( usAppCounter >= usAppNumber ) { break; } } BST_OS_ThreadUnLock( tThreadLockCnt ); return BST_TRUE; }
/*lint -e48 -e18 -e438 -e516*/ void *realloc(void *mem_address, unsigned int newsize) { void * NewPtr; if ( !mem_address) { return BST_OS_MALLOC( newsize ); } else if ( newsize == 0 ) { BST_OS_FREE( mem_address ); } else { NewPtr = BST_OS_MALLOC(newsize); if ( NewPtr ) { BST_OS_MEMCPY( NewPtr, mem_address, newsize ); BST_OS_FREE( mem_address ); return NewPtr; } } return BST_NULL_PTR; }
BST_VOID BST_SRV_CEvent::RcvThread( BST_VOID *pvArg ) { BST_OS_MBX_T **pstMailBox; BST_EVT_HEAD_STRU *pstEvtMsg; BST_AS_EVT_STRU *pstAsEvt; BST_ACOM_EVT_STRU *pstAcomEvt; BST_TIMER_EVT_STRU *pstTimerEvt; BST_NET_EVENT_STRU *pstNetEvt; BST_DSPP_CTrsDlVa *pcTrslayer; BST_SRV_CAsEvt *pcAsMng; BST_OS_TIMERID_T ulTimerId; BST_UINT32 ulRtnVal; BST_ASSERT_NULL( pvArg ); pstMailBox = (BST_OS_MBX_T **)pvArg; *pstMailBox = BST_OS_CreateMbx( BST_OS_GetCurrentThreadId(), BST_M_MBOX_SIZE ); BST_ASSERT_NULL( *pstMailBox ); BST_SetThreadInitFlag( BST_MAIN_THREAD_FLAG ); for (;;) { ulRtnVal = BST_OS_RecvMail( *pstMailBox, (BST_VOID **)&pstEvtMsg, BST_OS_SYS_FOREVER ); if( BST_OS_SYS_TIMEOUT == ulRtnVal ) { continue; } if( BST_NULL_PTR == pstEvtMsg ) { continue; } BST_DBG_LOG1( "BST_SRV_CEvent::RcvThread pstEvtMsg->enId=%d", pstEvtMsg->enId ); switch( pstEvtMsg->enId ) { case BST_SRV_ACOM_EVENT: pcTrslayer = BST_DSPP_CTrsDlVa::GetInstance(); if ( BST_NULL_PTR == pcTrslayer ) { break; } pstAcomEvt = (BST_ACOM_EVT_STRU *)pstEvtMsg; pcTrslayer->RxApi( pstAcomEvt->pucData, (BST_UINT16)pstAcomEvt->ulLength ); break; case BST_SRV_AS_EVENT: pcAsMng = BST_SRV_CAsEvt::GetInstance(); if ( BST_NULL_PTR == pcAsMng ) { break; } pstAsEvt = (BST_AS_EVT_STRU *)pstEvtMsg; pcAsMng->AsEventRcv( pstAsEvt->enAsEvent, pstAsEvt->ulLength,(BST_VOID *)pstAsEvt->pucData ); break; case BST_SRV_TIMER_EVENT: pstTimerEvt = (BST_TIMER_EVT_STRU *)pstEvtMsg; if( BST_OS_SIZEOF(ulTimerId) != pstTimerEvt->ulLength ) { break; } BST_OS_MEMCPY( &ulTimerId, pstTimerEvt->pucData, BST_OS_SIZEOF(ulTimerId) ); BST_OS_TimerDoCallBack( ulTimerId ); break; case BST_SRV_TCPIP_EVENT: pstNetEvt = (BST_NET_EVENT_STRU *)pstEvtMsg; if( BST_OS_SIZEOF(BST_IP_EVENT_STRU) != pstNetEvt->ulLength ) { break; } BST_IP_CallBackEntry ( ( BST_IP_EVENT_STRU * )pstNetEvt->pucData ); break; default: break; } if( BST_NULL_PTR != pstEvtMsg->pucData ) { BST_OS_FREE( pstEvtMsg->pucData ); } BST_OS_FREE( pstEvtMsg ); #if ( BST_VER_TYPE == BST_UT_VER ) break; #endif } }
BST_ERR_ENUM_UINT8 BST_CORE_DencryptChk ( BST_CORE_PID_ENUM_UINT16 enPid, const BST_VOID *pvData, BST_UINT16 usLen, BST_VOID **ppOutData, BST_UINT16 *pusOutLen ) { BST_ERR_ENUM_UINT8 enRet; BST_UINT32 ulInLen; BST_UINT32 ulOutLen; BST_UINT32 ulBase64DataLen; BST_UINT8 *pucIn; BST_UINT8 *pucOut; BST_UINT8 *pucBase64Data; ulInLen = 0; ulOutLen = 0; ulBase64DataLen = 0; pucIn = BST_NULL_PTR; pucOut = BST_NULL_PTR; pucBase64Data = BST_NULL_PTR; enRet = BST_NO_ERROR_MSG; if ( ( BST_NULL_PTR == pvData ) || ( BST_NULL_PTR == pusOutLen ) || ( BST_NULL_PTR == ppOutData) ) { return BST_ERR_INVALID_PTR; } if ( 0 == usLen ) { return BST_ERR_PAR_LEN; } if ( CheckIfEcryOrDecry ( enPid ) ) { pucIn = ( BST_UINT8 * )BST_OS_MALLOC ( usLen ); if ( BST_NULL_PTR == pucIn ) { return BST_ERR_NO_MEMORY; } BST_OS_MEMCPY ( pucIn, pvData, usLen ); ulInLen = usLen; pucBase64Data = ( BST_UINT8 * )BST_OS_MALLOC ( ulInLen ); if ( BST_NULL_PTR == pucBase64Data ) { BST_OS_FREE ( pucIn ); pucIn = BST_NULL_PTR; return BST_ERR_NO_MEMORY; } ulBase64DataLen = EVP_DecodeBlock ( pucBase64Data, pucIn, ulInLen ); while ( pucIn[--ulInLen] == '=' ) // Ecrypter string end is '=' { ulBase64DataLen--; } pucOut = ( BST_UINT8 * )BST_OS_MALLOC ( ulInLen ); if ( BST_NULL_PTR == pucOut ) { BST_OS_FREE ( pucIn ); pucIn = BST_NULL_PTR; BST_OS_FREE ( pucBase64Data ); pucBase64Data = BST_NULL_PTR; return BST_ERR_NO_MEMORY; } BST_OS_MEMSET ( pucOut, 0, ulInLen ); enRet = DecryptInternal ( pucBase64Data, ulBase64DataLen, pucOut, &ulOutLen, gs_BastetDsppKey ); if ( BST_NO_ERROR_MSG == enRet ) { *ppOutData = ( BST_VOID * )pucOut; *pusOutLen = ( BST_UINT16 )ulOutLen; } BST_OS_FREE ( pucIn ); pucIn = BST_NULL_PTR; BST_OS_FREE ( pucBase64Data ); pucBase64Data = BST_NULL_PTR; return enRet; } return BST_NO_ERROR_MSG; }
BST_ERR_ENUM_UINT8 BST_CORE_EncryptChk ( BST_CORE_PID_ENUM_UINT16 enPid, const BST_VOID *pvData, BST_UINT16 usLen, BST_VOID **ppOutData, BST_UINT16 *pusOutLen ) { BST_ERR_ENUM_UINT8 enRet; BST_UINT32 ulInLen; BST_UINT32 ulOutLen; BST_UINT32 ulBase64DataLen; BST_UINT8 *pucIn; BST_UINT8 *pucOut; BST_UINT8 *pucBase64Data; ulInLen = 0; ulOutLen = 0; ulBase64DataLen = 0; pucIn = BST_NULL_PTR; pucOut = BST_NULL_PTR; pucBase64Data = BST_NULL_PTR; enRet = BST_NO_ERROR_MSG; if ( ( BST_NULL_PTR == pvData ) || ( BST_NULL_PTR == pusOutLen ) || ( BST_NULL_PTR == ppOutData) ) { return BST_ERR_INVALID_PTR; } if ( 0 == usLen ) { return BST_ERR_PAR_LEN; } if ( CheckIfEcryOrDecry ( enPid ) ) { pucIn = ( BST_UINT8 * )BST_OS_MALLOC ( usLen ); if ( BST_NULL_PTR == pucIn ) { return BST_ERR_NO_MEMORY; } BST_OS_MEMCPY ( pucIn, pvData, usLen ); ulInLen = usLen; pucOut = ( BST_UINT8 * )BST_OS_MALLOC ( ulInLen + EVP_MAX_IV_LENGTH ); if ( BST_NULL_PTR == pucOut ) { BST_OS_FREE ( pucIn ); pucIn = BST_NULL_PTR; return BST_ERR_NO_MEMORY; } enRet = EncryptInternal ( ( BST_UINT8 * )pucIn, ulInLen, pucOut, &ulOutLen, gs_BastetDsppKey ); if ( BST_NO_ERROR_MSG == enRet ) { pucBase64Data = ( BST_UINT8 * )BST_OS_MALLOC ( ulOutLen * 2 ); if ( BST_NULL_PTR == pucBase64Data ) { BST_OS_FREE ( pucIn ); pucIn = BST_NULL_PTR; BST_OS_FREE ( pucOut ); pucOut = BST_NULL_PTR; return BST_ERR_NO_MEMORY; } ulBase64DataLen = EVP_EncodeBlock ( pucBase64Data, pucOut, ulOutLen ); *ppOutData = pucBase64Data; *pusOutLen = ulBase64DataLen; } BST_OS_FREE ( pucIn ); pucIn = BST_NULL_PTR; BST_OS_FREE ( pucOut ); pucOut = BST_NULL_PTR; return enRet; } return BST_NO_ERROR_MSG; }
BST_ERR_ENUM_UINT8 BST_SRV_CHNL_Send_Runing( BST_SRV_CHNL_LINK_STRU *pstChnlLink, BST_SRV_CHNL_HEAD_STRU *pstPktItem ) { BST_SRV_CHNL_SENT_STRU *pSentItem; BST_SRV_CHNL_HEAD_STRU *pstUnsendItem; BST_SRV_CHNL_LINK_STRU *pstLinkItem2; BST_IP_ERR_T enIpErr; BST_DSPP_CAppUlVc *pstDsppUl; BST_UINT32 ulSpinlockCnt; BST_UINT16 usFlags; BST_ASSERT_NULL_RTN( pstChnlLink, BST_ERR_INVALID_PTR ); BST_ASSERT_NULL_RTN( pstPktItem, BST_ERR_INVALID_PTR ); enIpErr = BST_IP_ERR_OK; if( BST_SRV_ChnlIsTail(pstPktItem) ) { usFlags = BST_IP_SEND_FLAG_VOID; } else { usFlags = BST_IP_SEND_FLAG_MORE; } if( BST_IP_SKT_PROP_NONE != pstPktItem->ucPropType ) { BST_SRV_CHNL_Set_LinkProp( pstChnlLink, pstPktItem ); pstChnlLink->ulCurrentSeq = pstPktItem->stProp.ulSeqNum; } BST_DBG_LOG4("BST_SRV_CHNL_Send_Runing Length, ProcLevel, PackAddr, Flag", pstPktItem->ulUsed, pstPktItem->usProcLevel, pstPktItem->ucPktAddr, usFlags ); switch( pstPktItem->usProcLevel ) { case BST_DSPP_FLG_LVLTYPE_NORMAL: enIpErr = pstChnlLink->pcSocket->Write ( (const BST_UINT8 *)&pstPktItem->aucData[0], (BST_UINT16)pstPktItem->ulUsed, BST_IP_BSTT_DATA, usFlags ); break; case BST_DSPP_FLG_LVLTYPE_HS: enIpErr = pstChnlLink->pcSocket->Write ( (const BST_UINT8 *)&pstPktItem->aucData[0], (BST_UINT16)pstPktItem->ulUsed, BST_IP_HPRI_DATA, usFlags ); break; case BST_DSPP_FLG_LVLTYPE_LP: enIpErr = pstChnlLink->pcSocket->Write ( (const BST_UINT8 *)&pstPktItem->aucData[0], (BST_UINT16)pstPktItem->ulUsed, BST_IP_LPWR_DATA, usFlags ); break; default: return BST_ERR_PAR_UNKNOW; } if( BST_IP_ERR_OK == enIpErr ) { pSentItem = ( BST_SRV_CHNL_SENT_STRU *)BST_OS_MALLOC( BST_OS_SIZEOF( BST_SRV_CHNL_SENT_STRU ) ); if( BST_NULL_PTR == pSentItem ) { return BST_ERR_NO_MEMORY; } pstChnlLink->ulCurrentSeq += pstPktItem->ulUsed; pSentItem->pNext = BST_NULL_PTR; if ( BST_DSPP_FLG_LVLTYPE_HS == pstPktItem->usProcLevel ) { ulSpinlockCnt = BST_OS_SpinLock( &g_HighPriCntSpinLock ); g_ulHighPriCnt++; BST_OS_SpinUnLock( &g_HighPriCntSpinLock , ulSpinlockCnt ); } pSentItem->usProcLevel = pstPktItem->usProcLevel; pSentItem->ulAckNo = pstChnlLink->ulCurrentSeq; BST_SRV_Q_PushToTail( (BST_SRV_CHNL_Q **)&pstChnlLink->pSentList, (BST_SRV_CHNL_Q *)pSentItem ); BST_DBG_LOG3("tiger BST_SRV_FreeIpBlock1 g_ulHighPriCnt++, sent",pstPktItem, g_ulHighPriCnt, pstPktItem->ulUsed); BST_SRV_FreeIpBlock( pstPktItem ); } else if( BST_IP_ERR_MEM == enIpErr ) { /*申请空间存储未发送的数据,避免在处理完成时将数据释放*/ pstUnsendItem = BST_SRV_AlocIpBlock(); if ( BST_NULL_PTR == pstUnsendItem ) { return BST_ERR_NO_MEMORY; } BST_OS_MEMCPY( pstUnsendItem, pstPktItem, BST_OS_SIZEOF(BST_SRV_CHNL_HEAD_STRU)); BST_SRV_CHNL_Send_Suspend( pstChnlLink, pstUnsendItem ); pstChnlLink->enState = BST_SRV_CHNL_STATE_SUSPEND; return BST_ERR_NO_MEMORY; } else { pstDsppUl = BST_DSPP_CAppUlVc::GetInstance(); if( pstChnlLink->ulAddrType == BST_DSPP_FLG_ADDTYPE_INET ) { pstDsppUl->Report( BST_DSPP_FLG_CMD_CLOSE, pstChnlLink->stLink.ulMainLinkId, pstChnlLink->stLink.ulAuxLinkId ); BST_SRV_CHNL_ReportTrafficFlow( pstChnlLink ); } else { pstDsppUl->Report( BST_DSPP_FLG_CMD_CLOSE, pstChnlLink->stDspp.usProcId, pstChnlLink->stDspp.usTaskId ); } BST_SRV_CHNL_Close( pstChnlLink ); delete pstChnlLink->pcSocket; BST_SRV_Q_RmvItem( (BST_SRV_CHNL_Q **)&g_lstChnlMng, (BST_SRV_CHNL_Q *)pstChnlLink, (BST_SRV_CHNL_Q **)&pstLinkItem2 ); BST_OS_FREE(pstChnlLink); return BST_ERR_SOCKET_CLSD; } return BST_NO_ERROR_MSG; }
BST_IP_ERR_T BST_IP_SslReceive( BST_FD_T fd, BST_UINT8* pData, BST_UINT16 usLength ) { SSL *pstSsl; BST_UINT8 *pucTmpBuf; BST_INT32 lRtnVal; BST_INT32 lCopyedLen; BST_INT32 lSelect; BST_INT32 lSockFd; fd_set stRdFds; timeval stTval; stTval.tv_sec = 0; stTval.tv_usec = 0; if ( BST_NULL_PTR == fd.pFd ) { return BST_IP_ERR_ARG; } if ( BST_NULL_PTR == pData ) { return BST_IP_ERR_ARG; } lCopyedLen = 0; pstSsl = (SSL *)fd.pFd; lSockFd = SSL_get_fd( pstSsl ); pucTmpBuf = (BST_UINT8 *)BST_OS_MALLOC( usLength ); if ( BST_NULL_PTR == pucTmpBuf ) { return BST_IP_ERR_MEM; } do { FD_ZERO( &stRdFds ); FD_SET( lSockFd, &stRdFds ); lRtnVal = SSL_read( pstSsl, pucTmpBuf, usLength ); if ( lRtnVal <= 0 ) { BST_RLS_LOG( "BST_IP_SslReceive SSL_read error" ); break; } if ( 0 == lCopyedLen ) { BST_OS_MEMCPY( pData, pucTmpBuf, lRtnVal ); lCopyedLen = lRtnVal; BST_DBG_LOG1( "BST_IP_SslReceive lCopyedLen", lCopyedLen ); } /*如果ssl内部缓冲区没有数据可读,则判断IP协议栈是否有数据可读*/ if ( !SSL_pending( pstSsl ) ) { lSelect = lwip_select( lSockFd + 1, &stRdFds, NULL, NULL, &stTval ); if ( lSelect < 0) { BST_RLS_LOG( "BST_IP_SslReceive lwip_select error" ); break; } /*如果协议栈也没有数据可读,则说明这次读取完毕,退出*/ if ( !FD_ISSET( lSockFd,&stRdFds ) ) { BST_DBG_LOG( "BST_IP_SslReceive socket is not data" ); break; } } } while( 1 ); BST_OS_FREE( pucTmpBuf ); return lCopyedLen; }
/*lint -e438*/ BST_VOID BST_IP_UdpRecvCB( BST_VOID *arg, struct udp_pcb *upcb, struct pbuf *p, BST_IPADDR_U32T *addr, BST_UINT16 port ) { BST_UINT16 usCopyedLength; BST_IP_CRcverMng *pcRcverMnger; BST_IP_PKTPROC_MODE_ENUM enProcMode; struct pbuf *q; BST_UINT8 *pucSdu; BST_FD_T FdTmp; BST_OS_LOCKCNT_T tThreadLockCnt; BST_ASSERT_NULL( addr ); BST_ASSERT_NULL( upcb ); BST_ASSERT_NULL( p ); tThreadLockCnt = BST_OS_ThreadLock(); FdTmp.pFd = upcb; pucSdu = BST_NULL_PTR; q = BST_NULL_PTR; usCopyedLength = 0; enProcMode = BST_IP_PKT_REMOVE_PROC; pcRcverMnger = BST_IP_CRcverMng::GetInstance(); if( BST_NULL_PTR == pcRcverMnger ) { BST_IP_UDP_RCVAPI_FREE(); } if ( p->tot_len > 0 ) { pucSdu = ( BST_UINT8 * )BST_OS_MALLOC( p->tot_len ); } else { BST_IP_UDP_RCVAPI_FREE(); } if ( BST_NULL_PTR == pucSdu ) { BST_IP_UDP_RCVAPI_FREE(); } q = p; usCopyedLength = 0; while ( BST_NULL_PTR != q ) { if ( ( q->len > 0 ) && ( BST_NULL_PTR != q->payload ) && ( q->len + usCopyedLength <= p->tot_len ) ) { BST_OS_MEMCPY( pucSdu + usCopyedLength, q->payload, q->len ); } else { break; } usCopyedLength += q->len; q = q->next; } if ( usCopyedLength > 0 ) { enProcMode = pcRcverMnger->PacketRcver( FdTmp, ( BST_UINT8 * )pucSdu, usCopyedLength ); if( BST_IP_PKT_FORWARD_PROC == enProcMode ) { BST_IP_ApiForwordPacket( (BST_IP_PKT_ID_T)p ); } } BST_OS_FREE( pucSdu ); BST_IP_UDP_RCVAPI_FREE(); }
/*lint -e438*/ err_t BST_IP_TcpRecvCB( BST_VOID *arg, struct tcp_pcb * tpcb, struct pbuf *p, BST_IP_ERR_T err ) { err_t ucErrMsg; BST_UINT16 usCopyedLength; BST_IP_CRcverMng *pcRcverMnger; BST_IP_PKTPROC_MODE_ENUM enProcMode; struct pbuf *q; BST_UINT8 *pucSdu; BST_FD_T FdTmp; BST_OS_LOCKCNT_T tThreadLockCnt; BST_ASSERT_NULL_RTN( tpcb, ERR_ARG ); tThreadLockCnt = BST_OS_ThreadLock(); FdTmp.pFd = tpcb; pcRcverMnger = BST_IP_CRcverMng::GetInstance(); pucSdu = BST_NULL_PTR; q = BST_NULL_PTR; usCopyedLength = 0; ucErrMsg = ERR_OK; enProcMode = BST_IP_PKT_REMOVE_PROC; if( BST_NULL_PTR == pcRcverMnger ) { ucErrMsg = ERR_MEM; BST_IP_TCP_RCVAPI_FREE(); } /* * * p=NULL means this pcb is closed by Remote* * */ if( BST_IP_IsLwipNull(p) ) { pcRcverMnger->ClosedRcver ( FdTmp ); BST_OS_ThreadUnLock( tThreadLockCnt ); return ERR_OK; } if ( p->tot_len > 0 ) { pucSdu = ( BST_UINT8 * )BST_OS_MALLOC( p->tot_len ); } else { ucErrMsg = ERR_BUF; tcp_recved( tpcb, p->tot_len ); BST_IP_TCP_RCVAPI_FREE(); } if ( BST_NULL_PTR == pucSdu ) { ucErrMsg = ERR_BUF; tcp_recved( tpcb, p->tot_len ); BST_IP_TCP_RCVAPI_FREE(); } q = p; usCopyedLength = 0; while ( BST_NULL_PTR != q ) { if ( ( q->len > 0 ) && ( BST_NULL_PTR != q->payload ) && ( q->len + usCopyedLength <= p->tot_len ) ) { BST_OS_MEMCPY( pucSdu + usCopyedLength, q->payload, q->len ); } else { break; } usCopyedLength += q->len; q = q->next; } if ( usCopyedLength > 0 ) { BST_IP_ApiRecordLastSktProp( (BST_IP_PKT_ID_T)p ); /* * *The Received Message must put it here where is before call Application CB. *This can avoid app close socket in callback when the rcv_wnd != TCP_WND. * */ tcp_recved( tpcb, p->tot_len ); enProcMode = pcRcverMnger->PacketRcver( FdTmp, ( BST_UINT8 * )pucSdu, usCopyedLength ); if( BST_IP_PKT_FORWARD_PROC == enProcMode ) { BST_IP_ApiForwordPacket( (BST_IP_PKT_ID_T)p ); } ucErrMsg = ERR_OK; } else { ucErrMsg = ERR_BUF; } BST_OS_FREE( pucSdu ); BST_IP_TCP_RCVAPI_FREE(); }