コード例 #1
0
bool CurrencyPair::Load(PacketBase& packet)
{
    m_lstBids.clear();
    m_lstOffers.clear();

    if (!packet.ReadString(m_strCurrencyPair, 7))
        return false;

    int nBidsCount;
    if (!packet.ReadInt(nBidsCount, 4))
        return false;

    while (--nBidsCount >= 0)
    {
        BidOrOffer bid;
        if (!bid.Load(packet))
            return false;
        m_lstBids.push_back(bid);
    }

    int nOffersCount;
    if (!packet.ReadInt(nOffersCount, 4))
        return false;

    while (--nOffersCount >= 0)
    {
        BidOrOffer offer;
        if (!offer.Load(packet))
            return false;
        m_lstOffers.push_back(offer);
    }

    return true;
}
コード例 #2
0
ファイル: Dispatcher.cpp プロジェクト: dhgoo/Link
bool Dispatcher::parsing(Stream* raw)
{
	while (raw->length() >= (int)sizeof(PacketBase))
	{
		PacketBase* header = reinterpret_cast<PacketBase* >(raw->readptr());

		if (header->getLength() >= raw->length())
		{
			Stream* s = raw->split(header->getLength());
			if (s == nullptr)
			{
				return false;
			}

			// need to thread sync

			_recvQueue.push_back(s);
		}
		else
		{
			break;
		}
	}

	return true;
}
コード例 #3
0
bool Order::Load(PacketBase& packet)
{
    if (!packet.ReadDbl(m_lfAmount, 16))
        return false;
    if (!packet.ReadDbl(m_lfMinQty, 16))
        return false;
    if (!packet.ReadDbl(m_lfLotSize, 16))
        return false;
    if (!packet.ReadString(m_strOrderID, 15))
        return false;
    return true;
}
コード例 #4
0
bool ClientCurrencyPairMessage::Save ( PacketBase& packet ) const
{
    if ( !MessageBase::Save ( packet ) )
        return false;
    if ( !packet.WriteString ( m_strCurrencyPair, 7 ) )
        return false;
    return true;
}
コード例 #5
0
ファイル: PeerBase.cpp プロジェクト: ottoGithub/MyNet_Test
bool PeerBase::PeerSend(int32 socketid, PacketBase* pkt)
{
	if (socketid < 0 || !pkt)
	{
		return false;
	}
	PacketBase* tmppkt = (PacketBase*)s_PacketFactory.CreatePacket(pkt->GetPacketID());
	if (!tmppkt)
	{
		return false;
	}
	char buffer[MAX_PACKET_SIZE];
	pkt->WritePacket(buffer);
	tmppkt->ReadPacket(buffer);
	tmppkt->SetSocketID(socketid);
	tmppkt->m_isDrop = tmppkt->m_isDrop;
	return m_PktSendList.Push_Back(tmppkt);
}
コード例 #6
0
ファイル: FSMExtendData.cpp プロジェクト: singmelody/Test
void FSMExtendData::ProcessPacket(class PacketProcessor* pProccessor)
{
	char* pBuffer = m_vDataBuffer;

	for (int32 i = 0; i < m_nDataCnt; ++i)
	{
		const int32 nPktID = *((int32*)pBuffer);

		PacketBase* pPkt = (PacketBase*)PacketFactory::Instance().New(nPktID);
		if(!pPkt)
			return;

		pBuffer = pPkt->ReadPacket(pBuffer);
		pProccessor->ProcessPacket(pPkt);

		FACTORY_DEL_PACKET(pPkt);
	}
}
コード例 #7
0
ファイル: PeerBase.cpp プロジェクト: ottoGithub/MyNet_Test
void PeerBase::DoPeerSend()
{
	int32 realSndCount = 0;
	int32 curSndCount = 0;
	int32 dropCount = 0;
	PacketBase* pkt = m_PktSendList.Pop_Head();
	while (pkt)
	{
		SocketBase* s = m_NetManger->GetSocket(pkt->GetSocketID());
		if (s)
		{
			++curSndCount;
			if (!s->SendPacket(pkt))
			{
				if (!pkt->m_isDrop)
				{
					m_PktFailedList.Push_Back(pkt);
					pkt = m_PktSendList.Pop_Head();
					continue;
				}
				++dropCount;
			}
			++realSndCount;
			
			s_PacketFactory.DestroyPacket(pkt);
		}
		if (curSndCount >= 50)
		{
			break;
		}
		pkt = m_PktSendList.Pop_Head();
	}
	{
		PacketBase* failpkt = m_PktFailedList.Pop_Back();
		while (failpkt)
		{
			m_PktSendList.Push_Back(failpkt);
			failpkt = m_PktFailedList.Pop_Back();
		}
	}
}
コード例 #8
0
ファイル: NetManager.cpp プロジェクト: singmelody/Test
bool NetManager::SendPacket(PacketBase& pkt, int32 nSocketID)
{
	bool bSuceed = false;

	NetChannelBase* pChannel = GetChannel( nSocketID );
	if ( pChannel )
	{
		PacketBase* pPkt = DuplicatePacket(pkt);
		if(!pPkt)
			MyLog::error("NetManager::SendPacket failed to DuplicatePacket [%s]", pkt.GetClassName() );
		else
		{
			pPkt->SetSocketID( nSocketID );
			pChannel->AppendPacket( pPkt );
			bSuceed = true;
		}
		FreeChannel(pChannel);
	}

	return bSuceed;
}
コード例 #9
0
bool BidOrOffer::Load(PacketBase& packet)
{
    m_lstOrders.clear();

    if (!packet.ReadString(m_strBidPrice, 10))
        return false;

    int nOrderCount;
    if (!packet.ReadInt(nOrderCount, 4))
        return false;

    while (--nOrderCount >= 0)
    {
        Order order;
        if (!order.Load(packet))
            return false;
        m_lstOrders.push_back(order);
    }

    return true;
}
コード例 #10
0
bool HotspotFxMarketSnapshotMessage::Load(PacketBase& packet)
{
    m_lstCurrencyPairs.clear();

    if (!packet.ReadInt(m_nMessageLength, 6))
        return false;

    int nCurrencyPairCount;
    if (!packet.ReadInt(nCurrencyPairCount, 4))
        return false;

    while (--nCurrencyPairCount >= 0)
    {
        hotspotfx::CurrencyPair currencyPair;
        if (!currencyPair.Load(packet))
            return false;
        m_lstCurrencyPairs.push_back(currencyPair);
    }

    return MessageBase::Load(packet);
}
コード例 #11
0
ファイル: NetManager.cpp プロジェクト: singmelody/Test
PacketBase* NetManager::DuplicatePacket(PacketBase& pkt)
{
	PacketBase* pPktTmp = (PacketBase*)PacketFactory::Instance().New( pkt.GetPacketID() );
	if( pPktTmp == NULL )
		return 0;

#if PACKET_USE_INDEX_DATA
	bool bOri = pkt.IsUseIndex();
	pkt.IsUseIndex(false);
	pPktTmp->IsUseIndex(false);
#endif

	char buffer[PACKET_MAX_SIZE];
	pkt.WritePacket(buffer);
	pPktTmp->ReadPacket(buffer);

#if PACKET_USE_INDEX_DATA
	pkt.IsUseIndex(bOri);
#endif

	return pPktTmp;
}
コード例 #12
0
bool HotspotFxNewOrderMessage::Load ( PacketBase& packet )
{
    if (!packet.ReadChar(m_cBuyOrSell))
        return false;
    if (!packet.ReadString(m_strCurrencyPair, 7))
        return false;
    if (!packet.ReadString(m_strOrderID, 15))
        return false;
    if (!packet.ReadString(m_strPrice, 10))
        return false;
    if (!packet.ReadDbl(m_lfAmount, 16))
        return false;
    if (!packet.ReadDbl(m_lfMinQty, 16))
        return false;
    if (!packet.ReadDbl(m_lfLotSize, 16))
        return false;
    return MessageBase::Load(packet);
}
コード例 #13
0
ファイル: NetChannel.cpp プロジェクト: singmelody/Test
bool NetChannel::FillPackets2Block(DataBufferArg& arg)
{
	const uint32 cbHeader = sizeof(BlockHeadT);

	uint32 cbBuffer = CBBUFF;
	if( arg.cbBuffer < cbBuffer )
		cbBuffer = arg.cbBuffer;


	if( cbBuffer > BLOCK_SIZE_MASK )
		cbBuffer = BLOCK_SIZE_MASK;

	if( cbBuffer > SOCKET_MY_MAX_DATA_BLOCK_SIZE )
		cbBuffer = SOCKET_MY_MAX_DATA_BLOCK_SIZE;

	char* pBuffer = m_sendPacketBuffer + cbHeader;
	char* pBuffer2 = m_SendPacketBuffer2 + cbHeader;
	cbBuffer -= cbHeader;

	uint32 cbData = 0;

	// 开始合并数据包处理
	bool bFirstPacket = true;
	bool bEncrypt = true;

	PacketList& list = m_queueSendingPacket;

	int64 nPacketSend = 0;
	PacketBase* pPkt = list.Pop_Head();
	while ( pPkt != NULL )
	{
		pPkt->IsUseIndex( m_pMgr->UseIndexWhenSend() );
		pPkt->SetPacketIndex( m_nIndexOfSend );

		const uint32 PacketAttr = pPkt->GetStaticAttribute();
		if( PacketBase::IsDisconnectCommand( PacketAttr ) )
		{
			DisConnect();
			FACTORY_DEL_PACKET( pPkt );
			return false;
		}

		if( bFirstPacket )
		{
			bEncrypt = PacketBase::ShouldEncrypt( PacketAttr );
			bFirstPacket = false;
		}
		else
		{
			if( bEncrypt != PacketBase::ShouldEncrypt( PacketAttr ) )
				break;
		}

		char pktContent[PACKET_MAX_SIZE];
		size_t nPktSize = pPkt->WritePacket( pktContent )  - pktContent;
		assert( nPktSize < PACKET_MAX_SIZE && nPktSize > 0);

		if(cbData + nPktSize > cbBuffer)
			break;

		memcpy( pBuffer + cbData, pktContent, nPktSize);
		nPacketSend++;

		++m_nIndexOfSend;

		cbData += (uint32)nPktSize;
		FACTORY_DEL_PACKET( pPkt );
		pPkt = list.Pop_Head();
	}

	m_pMgr->PacketsSend().Add(nPacketSend);

	if(pPkt != NULL)
		list.Push_Head(pPkt);

	if( cbData == 0 )
		return false;

	bool bCompress = false;
	BlockHeadT blockFlag = 0;

#if LZO_COMPRESS
	if( m_pGLZOCompressor )
	{
		if( bCompress && cbData > 56 )
		{
			uint32 dstLen = cbBuffer;
			if(!m_pGLZOCompressor->Compress( pBuffer, cbData, pBuffer2, dstLen) )
			{
				assert(false);
				MyLog::error("Socket send packet size error, Compress Fail! sockid=[%d] size=[%u]!Will disconnect", GetID(), cbData);
				DisConnect();
				return false;
			}

			if( dstLen < cbData )
			{
				blockFlag |= BLOCK_FLAG_LZO;
				std::swap( pBuffer, pBuffer2);
				cbData = dstLen;
			}
		}
	}
#endif

#if USE_MY_BLOWFISH
	if(m_pBlowFishCipher)
	{
		if(bEncrypt)
		{
			blockFlag |= Block_FLAG_ENC;
			m_pBlowFishCipher->Encrypt( pBuffer, pBuffer2, nDataLen);
			std::swap( pBuffer, pBuffer2);
		}
	}
#endif

	if( cbData > BLOCK_SIZE_MASK )
	{
		MyLog::error("NetChannel::FillPackets2Block() Error , cbData > BLOCK_SIZE_MASK\n");
	}

	arg.pBuffer = pBuffer - cbHeader;
	arg.cbData = cbHeader + cbData;

	BlockHeadT blockHead = (BlockHeadT)(cbData);
	blockHead |= blockFlag;

	memcpy( arg.pBuffer, &blockHead, cbHeader);

	return true;
}
コード例 #14
0
ファイル: NetChannel.cpp プロジェクト: singmelody/Test
bool NetChannel::ParsePacketsInBlock(BlockHeadT blockHead, char* pBuffer, uint32 nBlockSize)
{
	char* pTempBuffer = m_recvPacketBuffer;

#if LZO_COMPRESS
	if( m_pGLZOCompressor && ( 0 != (blockHead & BLOCK_FLAG_LZO)))
	{
		uint32 nDestLen = CBBUFF;

		if( !m_pGLZOCompressor->DeCompress( pBuffer, nBlockSize, pTempBuffer, nDestLen))
		{
			MyLog::message("NetChannel::ParsePacketsInBlock Fail to DeCompress");
			return false;
		}

		nBlockSize = nDestLen;
		std::swap( pBuffer, pTempBuffer);
	}
#endif

	uint32 nDataLen = nBlockSize;

	int64 nPacketRecved = 0;
	bool bError = false;
	while( nDataLen > 0 && !bError )
	{
		const int32 nPktID = *((int32*)pBuffer);

		PacketBase* pPkt = (PacketBase*)PacketFactory::Instance().New(nPktID);

		if(pPkt)
		{
		#if PACKET_USE_INDEX_DATA
			pPkt->IsUseIndex( m_pMgr->UseIndexWhenRecv());
		#endif
			++nPacketRecved;

			IRecvPacketFilter* pFilter = m_pMgr->GetRecvPacketFilter();

			if( pFilter && (!pFilter->Thread_CheckPacketTypeValid(*pPkt)))
			{
				bError = true;

				const char* pPktName = pPkt->GetClassName();
				MyLog::error("NetChannel::RecvPacket() Packet Type Check Failed, Will Disconnect Socket! pktName=[%s] pktID=[%d]", \
					pPktName ? pPktName : "UNKOWN", pPkt->GetPacketID());
			}

			if(!bError)
			{
				char* pPacketEnd = pPkt->ReadPacket(pBuffer);
				if( 0 == pPacketEnd )
				{
					bError = true;
					const char* pPktName = pPkt->ReadPacket(pBuffer);
					MyLog::message("NetChannel::RecvPacket() Read Packet Failed, Will Disconnect Socket! pktName=[%s] pktID=[%d]", \
						pPktName ? pPktName :  "UNKOWN", pPkt->GetPacketID());
				}
				else
				{
					uint32 nPktDataLen = uint32(pPacketEnd - pBuffer);
					if( nPktDataLen > nDataLen )
					{
						bError = true;
						const char* pPktName = pPkt->GetClassName();
						MyLog::message("NetChannel::RecvPacket() Read Packet Failed, Will Disconnect Socket! pktName=[%s] pktID=[%d]", \
							pPktName ? pPktName :  "UNKOWN", pPkt->GetPacketID());
					}
					else
					{
						pBuffer += nPktDataLen;
						nDataLen -= nPktDataLen;
					}
				}
			}

			if(!bError)
			{
				MyLog::message("Recv Packet sock= %d id= %d \n", m_nID, nPktID);

				pPkt->SetSocketID( m_nID );

#if PACKET_USE_INDEX_DATA
				if( pPkt->IsUseIndex() && ( pPkt->GetPacketIndex() != m_nIndexOfRecv++ ))
				{
					MyLog::error("NetChannel::ParsePacketsInBlock Bad Index Recv! sock = [%d],pkt=[%s]", GetID(), pPkt->GetClass());
					bError = true;
					FACTORY_DEL_PACKET(pPkt);
				}
				else
#endif
				{
					OnPacketParsed(pPkt);
				}
			}
			else
			{
				FACTORY_DEL_PACKET(pPkt);
			}
		}
		else
		{
			bError = true;
			FactoryBase_Arg0* pFactory = PacketFactory::Instance().GetFactoryByPacketID(nPktID);
			if(pFactory)
			{
				MyLog::error("Packet Factory Create Packet name [%s] id[%d] fail", pFactory->ClassName(), nPktID);
			}
			else
			{
				MyLog::error("Packet Factroy Create Packet id[%d] fail", nPktID);
			}
		}
	}

	m_pMgr->PacketsRecv().Add(nPacketRecved);

	if(bError)
		DisConnect();

	return !bError;
}