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; }