Packet *PacketizedTCP::ReturnOutgoingPacket(void)
{
Packet *outgoingPacket=0;
unsigned int i;
while (outgoingPacket==0 && waitingPackets.IsEmpty()==false)
{
outgoingPacket=waitingPackets.Pop();
PluginReceiveResult pluginResult;
for (i=0; i < messageHandlerList.Size(); i++)
{
pluginResult=messageHandlerList[i]->OnReceive(outgoingPacket);
if (pluginResult==RR_STOP_PROCESSING_AND_DEALLOCATE)
{
DeallocatePacket( outgoingPacket );
outgoingPacket=0; // Will do the loop again and get another packet
break; // break out of the enclosing for
}
else if (pluginResult==RR_STOP_PROCESSING)
{
outgoingPacket=0;
break;
}
}
}
return outgoingPacket;
}
void PacketizedTCP::Stop(void)
{
unsigned int i;
for (i=0; i < messageHandlerList.Size(); i++)
messageHandlerList[i]->OnRakPeerShutdown();
for (i=0; i < waitingPackets.Size(); i++)
DeallocatePacket(waitingPackets[i]);
TCPInterface::Stop();
ClearAllConnections();
}
void CNetServer::Process()
{
CPacket * pPacket = NULL;
// Loop until we have processed all packets in the packet queue (if any)
while(pPacket = Receive())
{
// Do we have a packet handler?
if(m_pfnPacketHandler)
{
// Pass it to the packet handler
m_pfnPacketHandler(pPacket);
}
// Deallocate the packet memory used
DeallocatePacket(pPacket);
}
}
void TCPInterface::Stop(void)
{
if (isStarted==false)
return;
unsigned i;
#if defined(OPEN_SSL_CLIENT_SUPPORT)
for (i=0; i < remoteClientsLength; i++)
remoteClients[i].DisconnectSSL();
#endif
isStarted=false;
if (listenSocket!=(SOCKET) -1)
{
#ifdef _WIN32
shutdown(listenSocket, SD_BOTH);
#else
shutdown(listenSocket, SHUT_RDWR);
#endif
closesocket(listenSocket);
listenSocket=(SOCKET) -1;
}
// Abort waiting connect calls
blockingSocketListMutex.Lock();
for (i=0; i < blockingSocketList.Size(); i++)
{
closesocket(blockingSocketList[i]);
}
blockingSocketListMutex.Unlock();
// Wait for the thread to stop
while ( threadRunning )
RakSleep(15);
RakSleep(100);
// Stuff from here on to the end of the function is not threadsafe
for (i=0; i < (unsigned int) remoteClientsLength; i++)
{
closesocket(remoteClients[i].socket);
#if defined(OPEN_SSL_CLIENT_SUPPORT)
remoteClients[i].FreeSSL();
#endif
}
remoteClientsLength=0;
RakNet::OP_DELETE_ARRAY(remoteClients,__FILE__,__LINE__);
remoteClients=0;
incomingMessages.Clear(__FILE__, __LINE__);
newIncomingConnections.Clear(__FILE__, __LINE__);
newRemoteClients.Clear(__FILE__, __LINE__);
lostConnections.Clear(__FILE__, __LINE__);
requestedCloseConnections.Clear(__FILE__, __LINE__);
failedConnectionAttempts.Clear(__FILE__, __LINE__);
completedConnectionAttempts.Clear(__FILE__, __LINE__);
failedConnectionAttempts.Clear(__FILE__, __LINE__);
for (i=0; i < headPush.Size(); i++)
DeallocatePacket(headPush[i]);
headPush.Clear(__FILE__, __LINE__);
for (i=0; i < tailPush.Size(); i++)
DeallocatePacket(tailPush[i]);
tailPush.Clear(__FILE__, __LINE__);
#if defined(OPEN_SSL_CLIENT_SUPPORT)
SSL_CTX_free (ctx);
startSSL.Clear(__FILE__, __LINE__);
activeSSLConnections.Clear(false, __FILE__, __LINE__);
#endif
}
Packet* PacketizedTCP::Receive( void )
{
PushNotificationsToQueues();
unsigned int i;
for (i=0; i < messageHandlerList.Size(); i++)
messageHandlerList[i]->Update();
Packet *outgoingPacket=ReturnOutgoingPacket();
if (outgoingPacket)
return outgoingPacket;
Packet *incomingPacket;
incomingPacket = TCPInterface::Receive();
unsigned int index;
while (incomingPacket)
{
if (connections.Has(incomingPacket->systemAddress))
index = connections.GetIndexAtKey(incomingPacket->systemAddress);
else
index=(unsigned int) -1;
if ((unsigned int)index==(unsigned int)-1)
{
DeallocatePacket(incomingPacket);
incomingPacket = TCPInterface::Receive();
continue;
}
if (incomingPacket->deleteData==true)
{
// Came from network
SystemAddress systemAddressFromPacket;
if (index < connections.Size())
{
DataStructures::ByteQueue *bq = connections[index];
// Buffer data
bq->WriteBytes((const char*) incomingPacket->data,incomingPacket->length, __FILE__,__LINE__);
systemAddressFromPacket=incomingPacket->systemAddress;
PTCPHeader dataLength;
// Peek the header to see if a full message is waiting
bq->ReadBytes((char*) &dataLength,sizeof(PTCPHeader),true);
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &dataLength,sizeof(dataLength));
// Header indicates packet length. If enough data is available, read out and return one packet
if (bq->GetBytesWritten()>=dataLength+sizeof(PTCPHeader))
{
do
{
bq->IncrementReadOffset(sizeof(PTCPHeader));
outgoingPacket = RakNet::OP_NEW<Packet>(__FILE__, __LINE__);
outgoingPacket->length=dataLength;
outgoingPacket->bitSize=BYTES_TO_BITS(dataLength);
outgoingPacket->guid=UNASSIGNED_RAKNET_GUID;
outgoingPacket->systemAddress=systemAddressFromPacket;
outgoingPacket->deleteData=false; // Did not come from the network
outgoingPacket->data=(unsigned char*) rakMalloc_Ex(dataLength, __FILE__, __LINE__);
if (outgoingPacket->data==0)
{
notifyOutOfMemory(__FILE__, __LINE__);
RakNet::OP_DELETE(outgoingPacket,__FILE__,__LINE__);
return 0;
}
bq->ReadBytes((char*) outgoingPacket->data,dataLength,false);
waitingPackets.Push(outgoingPacket, __FILE__, __LINE__ );
// Peek the header to see if a full message is waiting
if (bq->ReadBytes((char*) &dataLength,sizeof(PTCPHeader),true))
{
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &dataLength,sizeof(dataLength));
}
else
break;
} while (bq->GetBytesWritten()>=dataLength+sizeof(PTCPHeader));
}
else
{
unsigned int oldWritten = bq->GetBytesWritten()-incomingPacket->length;
unsigned int newWritten = bq->GetBytesWritten();
// Return ID_DOWNLOAD_PROGRESS
if (newWritten/65536!=oldWritten/65536)
{
outgoingPacket = RakNet::OP_NEW<Packet>(__FILE__, __LINE__);
outgoingPacket->length=sizeof(MessageID) +
sizeof(unsigned int)*2 +
sizeof(unsigned int) +
65536;
outgoingPacket->bitSize=BYTES_TO_BITS(incomingPacket->length);
outgoingPacket->guid=UNASSIGNED_RAKNET_GUID;
outgoingPacket->systemAddress=incomingPacket->systemAddress;
outgoingPacket->deleteData=false;
outgoingPacket->data=(unsigned char*) rakMalloc_Ex(outgoingPacket->length, __FILE__, __LINE__);
if (outgoingPacket->data==0)
{
notifyOutOfMemory(__FILE__, __LINE__);
RakNet::OP_DELETE(outgoingPacket,__FILE__,__LINE__);
return 0;
}
outgoingPacket->data[0]=(MessageID)ID_DOWNLOAD_PROGRESS;
unsigned int totalParts=dataLength/65536;
unsigned int partIndex=newWritten/65536;
unsigned int oneChunkSize=65536;
memcpy(outgoingPacket->data+sizeof(MessageID), &partIndex, sizeof(unsigned int));
memcpy(outgoingPacket->data+sizeof(MessageID)+sizeof(unsigned int)*1, &totalParts, sizeof(unsigned int));
memcpy(outgoingPacket->data+sizeof(MessageID)+sizeof(unsigned int)*2, &oneChunkSize, sizeof(unsigned int));
bq->IncrementReadOffset(sizeof(PTCPHeader));
bq->ReadBytes((char*) outgoingPacket->data+sizeof(MessageID)+sizeof(unsigned int)*3,oneChunkSize,true);
bq->DecrementReadOffset(sizeof(PTCPHeader));
waitingPackets.Push(outgoingPacket, __FILE__, __LINE__ );
}
}
}
DeallocatePacket(incomingPacket);
incomingPacket=0;
}
else
waitingPackets.Push(incomingPacket, __FILE__, __LINE__ );
incomingPacket = TCPInterface::Receive();
}
return ReturnOutgoingPacket();
}
Packet* RakClient::Receive( void )
{
Packet * packet = RakPeer::Receive();
// Intercept specific client / server feature packets
if ( packet )
{
RakNet::BitStream bitStream( ( char* ) packet->data, packet->length, false );
int i;
if ( packet->data[ 0 ] == ID_CONNECTION_REQUEST_ACCEPTED )
{
// ConnectionAcceptStruct cas;
// cas.Deserialize(bitStream);
// unsigned short remotePort;
// PlayerID externalID;
PlayerIndex playerIndex;
RakNet::BitStream inBitStream((char*)packet->data, packet->length, false);
inBitStream.IgnoreBits(8); // ID_CONNECTION_REQUEST_ACCEPTED
inBitStream.IgnoreBits(8 * sizeof(unsigned short)); //inBitStream.Read(remotePort);
inBitStream.IgnoreBits(8 * sizeof(unsigned int)); //inBitStream.Read(externalID.binaryAddress);
inBitStream.IgnoreBits(8 * sizeof(unsigned short)); //inBitStream.Read(externalID.port);
inBitStream.Read(playerIndex);
localPlayerIndex = playerIndex;
packet->playerIndex = playerIndex;
}
else if (
packet->data[ 0 ] == ID_REMOTE_NEW_INCOMING_CONNECTION ||
packet->data[ 0 ] == ID_REMOTE_EXISTING_CONNECTION ||
packet->data[ 0 ] == ID_REMOTE_DISCONNECTION_NOTIFICATION ||
packet->data[ 0 ] == ID_REMOTE_CONNECTION_LOST )
{
bitStream.IgnoreBits( 8 ); // Ignore identifier
bitStream.Read( packet->playerId.binaryAddress );
bitStream.Read( packet->playerId.port );
if ( bitStream.Read( ( unsigned short& ) packet->playerIndex ) == false )
{
DeallocatePacket( packet );
return 0;
}
if ( packet->data[ 0 ] == ID_REMOTE_DISCONNECTION_NOTIFICATION ||
packet->data[ 0 ] == ID_REMOTE_CONNECTION_LOST )
{
i = GetOtherClientIndexByPlayerID( packet->playerId );
if ( i >= 0 )
otherClients[ i ].isActive = false;
}
}
else if ( packet->data[ 0 ] == ID_REMOTE_STATIC_DATA )
{
bitStream.IgnoreBits( 8 ); // Ignore identifier
bitStream.Read( packet->playerId.binaryAddress );
bitStream.Read( packet->playerId.port );
bitStream.Read( packet->playerIndex ); // ADDED BY KURI
i = GetOtherClientIndexByPlayerID( packet->playerId );
if ( i < 0 )
i = GetFreeOtherClientIndex();
if ( i >= 0 )
{
otherClients[ i ].playerId = packet->playerId;
otherClients[ i ].isActive = true;
otherClients[ i ].staticData.Reset();
// The static data is what is left over in the stream
otherClients[ i ].staticData.Write( ( char* ) bitStream.GetData() + BITS_TO_BYTES( bitStream.GetReadOffset() ), bitStream.GetNumberOfBytesUsed() - BITS_TO_BYTES( bitStream.GetReadOffset() ) );
}
}
else if ( packet->data[ 0 ] == ID_BROADCAST_PINGS )
{
PlayerID playerId;
int index;
bitStream.IgnoreBits( 8 ); // Ignore identifier
for ( i = 0; i < 32; i++ )
{
if ( bitStream.Read( playerId.binaryAddress ) == false )
break; // No remaining data!
bitStream.Read( playerId.port );
index = GetOtherClientIndexByPlayerID( playerId );
if ( index >= 0 )
bitStream.Read( otherClients[ index ].ping );
else
{
index = GetFreeOtherClientIndex();
if ( index >= 0 )
{
otherClients[ index ].isActive = true;
bitStream.Read( otherClients[ index ].ping );
otherClients[ index ].playerId = playerId;
otherClients[ index ].staticData.Reset();
}
else
bitStream.IgnoreBits( sizeof( short ) * 8 );
}
}
DeallocatePacket( packet );
return 0;
}
else if ( packet->data[ 0 ] == ID_TIMESTAMP &&
packet->length == sizeof(unsigned char)+sizeof(unsigned int)+sizeof(unsigned char)+sizeof(unsigned int)+sizeof(unsigned int) )
{
/*
RakNet::BitStream s_BitS( (char *)packet->data, SetRandomNumberSeedStruct_Size, false );
SetRandomNumberSeedStruct s;
s.Deserialize( s_BitS );
*/
RakNet::BitStream inBitStream((char *)packet->data, packet->length, false);
/*
unsigned char ts;
unsigned int timeStamp;
unsigned char typeId;
unsigned int seed;
unsigned int nextSeed;
*/
unsigned int timeStamp;
unsigned char typeId;
unsigned int in_seed;
unsigned int in_nextSeed;
inBitStream.IgnoreBits(8); // ID_TIMESTAMP
inBitStream.Read(timeStamp);
inBitStream.Read(typeId); // ID_SET_RANDOM_NUMBER_SEED ?
// Check to see if this is a user TIMESTAMP message which
// accidentally has length SetRandomNumberSeedStruct_Size
if ( typeId != ID_SET_RANDOM_NUMBER_SEED )
return packet;
inBitStream.Read(in_seed);
inBitStream.Read(in_nextSeed);
seed = in_seed;
nextSeed = in_nextSeed;
nextSeedUpdate = timeStamp + 9000; // Seeds are updated every 9 seconds
DeallocatePacket( packet );
return 0;
}
}
return packet;
}
