netshakehand.cc

五行MMORPG引擎系统V1.0

/*///////////////////////////////////////////////////////////////////////////
UDP连接封装管理


李亦
2006.6.15
/*///////////////////////////////////////////////////////////////////////////

#include "platform/platform.h"
#include "platform/event.h"
#include "sim/netConnection.h"
#include "server/net/netShakeHand.h"
#include "core/bitStream.h"
#include "math/mRandom.h"
#include "platform/gameInterface.h"
#include "server/net/AuthSocket.h"
#include "server/net/AuthSocket.h"

//NetShakeHand *GNet = NULL;
 
//namespace CS
//{

NetShakeHand::NetShakeHand(CS::CAuthSocket* pSocket)
{
	m_pAuthSocket	= pSocket;
   //AssertFatal(GNet == NULL, "ERROR: Multiple net interfaces declared.");
   //GNet = this;
	//m_pNetManager = pManager;
   //mLastTimeoutCheckTime = 0;
   //mAllowConnections = true;

}



void NetShakeHand::ProcessRecvPackets()
{
 	AssertFatal(m_pAuthSocket,"需要关联AuthSocket对象");
	//NetConnection *conn = m_pAuthSocket->GetConnection();
	//AssertFatal(conn,"需要AuthSocket对象需要关联Connection对象");

	//  if(prEvent->data[0] & 0x01)
	//{
	//	Parent::processPacketReceiveEvent(prEvent);
	//	return;
	//}

   //U32 dataSize = prEvent->size - PacketReceiveEventHeaderSize;
   //BitStream pStream(prEvent->data, dataSize);

      // Otherwise, it's either a game info packet or a
      // connection handshake packet.

	NetAddress *addr	= (NetAddress *)m_pAuthSocket->GetNetAddress();
	BitStream *stream	= m_pAuthSocket->RequestRecvStream(0,FALSE);

	if(m_pAuthSocket->ProcessRecvStream() != CS::E_IOOK)
		return;

   U8 packetType;
   stream->read(&packetType);
   //NetAddress *addr = &prEvent->sourceAddress;

   // check if there's a connection already:
   //NetConnection *conn;
   switch(packetType)
   {
      case ConnectChallengeRequest:
         SvrHandleChallengeRequest(addr, stream);
         break;
      case ConnectRequest:
         SvrHandleConnectRequest(addr, stream);
         break;
      case ConnectChallengeResponse:
         CltHandleChallengeResponse(addr, stream);
         break;
      case ConnectAccept:
         CltHandleConnectAccept(addr, stream);
         break;
      case Disconnect:
         CltHandleDisconnect(addr, stream);
         break;
      case ConnectReject:
         CltHandleConnectReject(addr, stream);
         break;
		default:
		   HandleInfoPacket(addr, packetType, stream);
			break;
   }//switch

	m_pAuthSocket->ResponseRecvStream(FALSE);
}



//Client
void NetShakeHand::CltSendChallengeRequest(/*NetConnection *conn*/)
{
	AssertFatal(m_pAuthSocket,"需要关联AuthSocket对象");
	NetConnection *conn = m_pAuthSocket->GetConnection();
	AssertFatal(conn,"需要AuthSocket对象需要关联Connection对象");

   Con::printf("Sending Connect challenge Request");
   BitStream *out = m_pAuthSocket->RequestSendStream(0,FALSE);//BitStream::getPacketStream();

	//识别码
   out->write(U8(ConnectChallengeRequest));
	//数据
   out->write(conn->getSequence());

   conn->mConnectSendCount++;
   conn->mConnectLastSendTime = Platform::getVirtualMilliseconds();
	m_pAuthSocket->ProcessSendStream();
   //BitStream::sendPacketStream(conn->getNetAddress());
}


//Server
void NetShakeHand::SvrHandleChallengeRequest(const NetAddress *addr, BitStream *stream)
{
	//NetAddress *addr	= (NetAddress *)m_pAuthSocket->GetNetAddress();
	//BitStream *stream	= m_pAuthSocket->RequestRecvStream(0,FALSE);
   char	buf[256];

   Net::addressToString(addr, buf);
   Con::printf("Got Connect challenge Request from %s", buf);
   if(!mAllowConnections)
      return;

   U32	connectSequence;
   U32	addressDigest[4];

	//数据读
   stream->read(&connectSequence);

   if(!mRandomDataInitialized)
      initRandomData();

   computeNetMD5(addr, connectSequence, addressDigest);

   BitStream *out = m_pAuthSocket->RequestSendStream(0,FALSE);//BitStream::getPacketStream();
   //BitStream *out = BitStream::getPacketStream();

	//识别码
   out->write(U8(ConnectChallengeResponse));

	//数据写
   out->write(connectSequence);
   out->write(addressDigest[0]);
   out->write(addressDigest[1]);
   out->write(addressDigest[2]);
   out->write(addressDigest[3]);

	m_pAuthSocket->ProcessSendStream();
   //BitStream::sendPacketStream(conn->getNetAddress());
}


//-----------------------------------------------------------------------------
//Client
void NetShakeHand::CltHandleChallengeResponse(const NetAddress *address, BitStream *stream)
{
   Con::printf("Got Connect challenge Response");
   U32 connectSequence;

	//数据
   stream->read(&connectSequence);

   NetConnection *conn = m_pAuthSocket->GetConnection();// findPendingConnection(address, connectSequence);
   if(!conn || conn->getConnectionState() != NetConnection::AwaitingChallengeResponse)
      return;

   U32 addressDigest[4];
	//数据
   stream->read(&addressDigest[0]);
   stream->read(&addressDigest[1]);
   stream->read(&addressDigest[2]);
   stream->read(&addressDigest[3]);

   conn->setAddressDigest(addressDigest);

   conn->setConnectionState(NetConnection::AwaitingConnectResponse);
   conn->mConnectSendCount = 0;
   Con::printf("Sending Connect Request");

   CltSendConnectRequest(/*conn*/);
}

//-----------------------------------------------------------------------------

//Client
void NetShakeHand::CltSendConnectRequest(/*NetConnection *conn*/)
{
 	AssertFatal(m_pAuthSocket,"需要关联AuthSocket对象");
	NetConnection *conn = m_pAuthSocket->GetConnection();
	AssertFatal(conn,"需要AuthSocket对象需要关联Connection对象");

	BitStream *out = m_pAuthSocket->RequestSendStream(0,FALSE);//BitStream::getPacketStream();

   U32 addressDigest[4];
   conn->getAddressDigest(addressDigest);

	//识别码
	out->write(U8(ConnectRequest));
	//数据
   out->write(conn->getSequence());
   out->write(addressDigest[0]);
   out->write(addressDigest[1]);
   out->write(addressDigest[2]);
   out->write(addressDigest[3]);

	////////////////////////////////////////////////
	//传递connection的类名、连接参数...
   out->writeString(conn->getClassName());
   conn->writeConnectRequest(out);


   conn->mConnectSendCount++;
   conn->mConnectLastSendTime = Platform::getVirtualMilliseconds();

	m_pAuthSocket->ProcessSendStream();
   //BitStream::sendPacketStream(conn->getNetAddress());
}


//-----------------------------------------------------------------------------

void NetShakeHand::SvrHandleConnectRequest(const NetAddress *address, BitStream *stream)
{
   if(!mAllowConnections)
      return;
   Con::printf("Got Connect Request");

   U32 connectSequence;
	//数据
   stream->read(&connectSequence);

   // see if the connection is in the main connection table:
   NetConnection *connect = m_pAuthSocket->GetConnection();//NetConnection::lookup(address);
   if(connect && connect->getSequence() == connectSequence)
   {
      SvrSendConnectAccept(/*connect*/);
      return;
   }


   U32 addressDigest[4];
   U32 computedAddressDigest[4];
	//数据
   stream->read(&addressDigest[0]);
   stream->read(&addressDigest[1]);
   stream->read(&addressDigest[2]);
   stream->read(&addressDigest[3]);

   computeNetMD5(address, connectSequence, computedAddressDigest);
   if(addressDigest[0] != computedAddressDigest[0] ||
      addressDigest[1] != computedAddressDigest[1] ||
      addressDigest[2] != computedAddressDigest[2] ||
      addressDigest[3] != computedAddressDigest[3])
      return; // bogus connection attempt

   if(connect)
   {
      if(connect->getSequence() > connectSequence)