DOOM-3-BFG

PacketProcessor.cpp (21185B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #pragma hdrstop
 #include "../idLib/precompiled.h"
 
 idCVar net_maxRate( "net_maxRate", "50", CVAR_INTEGER, "max send rate in kilobytes per second" );
 
 idCVar net_showReliableCompression( "net_showReliableCompression", "0", CVAR_BOOL, "Show reliable compression ratio." );
 
 // we use an assert(0); return idiom in some places, which lint complains about
 //lint -e527	unreachable code at token 'return'
 
 /*
 ================================================
 idPacketProcessor::QueueReliableAck
 ================================================
 */
 void idPacketProcessor::QueueReliableAck( int lastReliable ) {
 	// NOTE - Even if it was the last known sequence, go ahead and ack it, in case our last ack for this sequence got dropped
 	if ( lastReliable >= reliableSequenceRecv ) {		
 		queuedReliableAck		= lastReliable;
 		reliableSequenceRecv	= lastReliable;
 	}
 }
 
 /*
 ================================================
 idPacketProcessor::FinalizeRead
 ================================================
 */
 int idPacketProcessor::FinalizeRead( idBitMsg & inMsg, idBitMsg & outMsg, int & userValue ) {
 	userValue = 0;
 	
 	idInnerPacketHeader header;	
 	header.ReadFromMsg( inMsg );
 	
 	if ( !verify( header.Type() != PACKET_TYPE_FRAGMENTED ) ) {		// We shouldn't be fragmented at this point
 		idLib::Printf("Received invalid fragmented packet.\n" );
 		return RETURN_TYPE_NONE;
 	}
 
 	if ( header.Type() == PACKET_TYPE_RELIABLE_ACK ) {
 		// Handle reliable ack
 		int reliableSequence = inMsg.ReadLong();
 		reliable.RemoveOlderThan( reliableSequence + 1 );
 		header.ReadFromMsg( inMsg );								// Read the new header, since the reliable ack sits on top the actual header of the message
 	}
 
 	if ( header.Type() == PACKET_TYPE_OOB ) {
 		// out-of-band packet
 		userValue = header.Value();
 	} else {
 		// At this point, this MUST be an in-band packet
 		if ( !verify( header.Type() == PACKET_TYPE_INBAND ) ) {
 			idLib::Printf("In-band packet expected, received type %i instead.\n", header.Type() );
 			return RETURN_TYPE_NONE;
 		}
 		
 		// Reset number of reliables received (NOTE - This means you MUST unload all reliables as they are received)
 		numReliable = 0;
 	
 		// Handle reliable portion of in-band packets
 		int numReliableRecv = header.Value();
 		int bufferPos = 0;
 		
 		if ( numReliableRecv > 0 ) {
 			// Byte align msg
 			inMsg.ReadByteAlign();
 
 			int compressedSize = inMsg.ReadShort();
 
 			lzwCompressionData_t	lzwData;
 			idLZWCompressor			lzwCompressor( &lzwData );
 	
 			lzwCompressor.Start( (uint8*)inMsg.GetReadData() + inMsg.GetReadCount(), compressedSize );		// Read from msg
 
 			int reliableSequence = 0;
 
 			lzwCompressor.ReadAgnostic< int >( reliableSequence );
 
 			for ( int r = 0; r < numReliableRecv; r++ ) {
 				uint8 uncompMem[ MAX_MSG_SIZE ];
 
 				uint16 reliableDataLength = 0;
 				lzwCompressor.ReadAgnostic< uint16 >( reliableDataLength );
 				lzwCompressor.Read( uncompMem, reliableDataLength );
 
 				if ( reliableSequence + r > reliableSequenceRecv ) {		// Only accept newer reliable msg's than we've currently already received
 					if ( !verify( bufferPos + reliableDataLength <= sizeof( reliableBuffer ) ) ) {
 						idLib::Printf( "Reliable msg size overflow.\n" );
 						return RETURN_TYPE_NONE;
 					}
 					if ( !verify( numReliable < MAX_RELIABLE_QUEUE ) ) {
 						idLib::Printf( "Reliable msg count overflow.\n" );
 						return RETURN_TYPE_NONE;
 					}
 					memcpy( reliableBuffer + bufferPos, uncompMem, reliableDataLength );
 					reliableMsgSize[ numReliable ] = reliableDataLength;
 					reliableMsgPtrs[ numReliable++ ] = &reliableBuffer[ bufferPos ];
 					bufferPos += reliableDataLength;					
 				} else {
 					extern idCVar net_verboseReliable;
 					if ( net_verboseReliable.GetBool() ) {
 						idLib::Printf( "Ignoring reliable msg %i because %i was already acked\n", ( reliableSequence + r ), reliableSequenceRecv );
 					}
 				}
 		
 				if ( !verify( lzwCompressor.IsOverflowed() == false ) ) {
 					idLib::Printf( "lzwCompressor.IsOverflowed() == true.\n" );
 					return RETURN_TYPE_NONE;
 				}
 			}
 	
 			inMsg.SetReadCount( inMsg.GetReadCount() + compressedSize );
 
 			QueueReliableAck( reliableSequence + numReliableRecv - 1 );
 		}
 	}
 	
 	// Load actual msg
 	outMsg.BeginWriting();
 	outMsg.WriteData( inMsg.GetReadData() + inMsg.GetReadCount(), inMsg.GetRemainingData() );
 	outMsg.SetSize( inMsg.GetRemainingData() );
 	
 	return ( header.Type() == PACKET_TYPE_OOB ) ? RETURN_TYPE_OOB : RETURN_TYPE_INBAND;
 }
 
 /*
 ================================================
 idPacketProcessor::QueueReliableMessage
 ================================================
 */
 bool idPacketProcessor::QueueReliableMessage( byte type, const byte * data, int dataLen ) {
 	return reliable.Append( reliableSequenceSend++, &type, 1, data, dataLen );
 }
 
 /*
 ========================
 idPacketProcessor::CanSendMoreData
 ========================
 */
 bool idPacketProcessor::CanSendMoreData() const {
 	if ( net_maxRate.GetInteger() == 0 ) {
 		return true;
 	}
 
 	return ( outgoingRateBytes <= net_maxRate.GetInteger() * 1024 );
 }
 
 /*
 ========================
 idPacketProcessor::UpdateOutgoingRate
 ========================
 */
 void idPacketProcessor::UpdateOutgoingRate( const int time, const int size ) {
 	outgoingBytes += size;
 
 	// update outgoing rate variables
 	if ( time > outgoingRateTime ) {
 		outgoingRateBytes -= outgoingRateBytes * (float)( time - outgoingRateTime ) / 1000.0f;
 		if ( outgoingRateBytes < 0.0f ) {
 			outgoingRateBytes = 0.0f;
 		}
 	}
 	
 	outgoingRateTime = time;
 	outgoingRateBytes += size;
 
 	// compute an average bandwidth at intervals
 	if ( time - lastOutgoingRateTime > BANDWIDTH_AVERAGE_PERIOD ) {
 		currentOutgoingRate = 1000 * ( outgoingBytes - lastOutgoingBytes ) / ( time - lastOutgoingRateTime );
 		lastOutgoingBytes = outgoingBytes;
 		lastOutgoingRateTime = time;
 	}
 }
 
 /*
 =================
 idPacketProcessor::UpdateIncomingRate
 =================
 */
 void idPacketProcessor::UpdateIncomingRate( const int time, const int size ) {
 	incomingBytes += size;
 
 	// update incoming rate variables
 	if ( time > incomingRateTime ) {
 		incomingRateBytes -= incomingRateBytes * (float)( time - incomingRateTime ) / 1000.0f;
 		if ( incomingRateBytes < 0.0f ) {
 			incomingRateBytes = 0.0f;
 		}
 	}
 	incomingRateTime = time;
 	incomingRateBytes += size;
 
 	// compute an average bandwidth at intervals
 	if ( time - lastIncomingRateTime > BANDWIDTH_AVERAGE_PERIOD ) {
 		currentIncomingRate = 1000 * ( incomingBytes - lastIncomingBytes ) / ( time - lastIncomingRateTime );
 		lastIncomingBytes = incomingBytes;
 		lastIncomingRateTime = time;
 	}
 }
 
 /*
 ================================================
 idPacketProcessor::ProcessOutgoing
 NOTE - We only compress reliables because we assume everything else has already been compressed.
 ================================================
 */
 bool idPacketProcessor::ProcessOutgoing( const int time, const idBitMsg & msg, bool isOOB, int userData ) {
 	// We can only do ONE ProcessOutgoing call, then we need to do GetSendFragment to
 	// COMPLETELY empty unsentMsg before calling ProcessOutgoing again.
 	if ( !verify( fragmentedSend == false ) ) {
 		idLib::Warning( "ProcessOutgoing: fragmentedSend == true!");
 		return false;
 	}
 	
 	if ( !verify( unsentMsg.GetRemainingData() == 0 ) ) {
 		idLib::Warning( "ProcessOutgoing: unsentMsg.GetRemainingData() > 0!");
 		return false;
 	}
 	
 	// Build the full msg to send, which could include reliable data
 	unsentMsg.InitWrite( unsentBuffer, sizeof( unsentBuffer ) );
 	unsentMsg.BeginWriting();
 	
 	// Ack reliables if we need to (NOTE - We will send this ack on both the in-band and out-of-band channels)
 	if ( queuedReliableAck >= 0 ) {
 		idInnerPacketHeader header( PACKET_TYPE_RELIABLE_ACK, 0 );
 		header.WriteToMsg( unsentMsg );
 		unsentMsg.WriteLong( queuedReliableAck );
 		queuedReliableAck = -1;
 	}
 
 	if ( isOOB ) {
 		if ( msg.GetSize() + unsentMsg.GetSize() > MAX_OOB_MSG_SIZE ) {		// Fragmentation not allowed for out-of-band msg's
 			idLib::Printf("Out-of-band packet too large %i\n", unsentMsg.GetSize() );
 			assert( 0 );
 			return false;
 		}
 		// We don't need to worry about reliable for out of band packets
 		idInnerPacketHeader header( PACKET_TYPE_OOB, userData );
 		header.WriteToMsg( unsentMsg );
 	} else {
 		// Add reliable msg's here if this is an in-band packet
 		idInnerPacketHeader header( PACKET_TYPE_INBAND, reliable.Num() );
 		header.WriteToMsg( unsentMsg );
 		if ( reliable.Num() > 0 ) {
 			// Byte align unsentMsg 
 			unsentMsg.WriteByteAlign();
 			
 			lzwCompressionData_t	lzwData;
 			idLZWCompressor			lzwCompressor( &lzwData );
 
 			lzwCompressor.Start( unsentMsg.GetWriteData() + unsentMsg.GetSize() + 2, unsentMsg.GetRemainingSpace() - 2 );		// Write to compressed mem, not exceeding MAX_MSG_SIZE (+2 to reserve space for compressed size)
 
 			int uncompressedSize = 4;
 			lzwCompressor.WriteAgnostic< int >( reliable.ItemSequence( 0 ) );
 			for ( int i = 0; i < reliable.Num(); i++ ) {
 				lzwCompressor.WriteAgnostic< uint16 >( reliable.ItemLength( i ) );
 				lzwCompressor.Write( reliable.ItemData( i ), reliable.ItemLength( i ) );
 				uncompressedSize += 2 + reliable.ItemLength( i );
 			}
 
 			lzwCompressor.End();
 
 			if ( lzwCompressor.IsOverflowed() ) {
 				idLib::Error( "reliable msg compressor overflow." );
 			}
 
 			unsentMsg.WriteShort( lzwCompressor.Length() );
 			unsentMsg.SetSize( unsentMsg.GetSize() + lzwCompressor.Length() );
 
 			if ( net_showReliableCompression.GetBool() ) {
 				static int totalUncompressed = 0;
 				static int totalCompressed = 0;
 
 				totalUncompressed += uncompressedSize;
 				totalCompressed += lzwCompressor.Length();
 
 				float ratio1 = (float)lzwCompressor.Length() / (float)uncompressedSize;
 				float ratio2 = (float)totalCompressed / (float)totalUncompressed;
 
 				idLib::Printf( "Uncompressed: %i, Compressed: %i, TotalUncompressed: %i, TotalCompressed: %i, (%2.2f / %2.2f )\n", uncompressedSize, lzwCompressor.Length(), totalUncompressed, totalCompressed, ratio1, ratio2 );
 			}
 		}
 	}
 	
 	// Fill up with actual msg
 	unsentMsg.WriteData( msg.GetReadData(), msg.GetSize() );
 
 	if ( unsentMsg.GetSize() > MAX_PACKET_SIZE ) {
 		if ( isOOB ) {
 			idLib::Error( "oob msg's cannot fragment" );
 		}
 		fragmentedSend = true;
 	}
 	
 	return true;
 }
 
 /*
 ================================================
 idPacketProcessor::GetSendFragment
 ================================================
 */
 bool idPacketProcessor::GetSendFragment( const int time, sessionId_t sessionID, idBitMsg & outMsg ) {
 	lastSendTime = time;
 
 	if ( unsentMsg.GetRemainingData() <= 0 ) {
 		return false;	// Nothing to send
 	}
 	
 	outMsg.BeginWriting();
 
 
 	idOuterPacketHeader	outerHeader( sessionID );
 
 	// Write outer packet header to the msg
 	outerHeader.WriteToMsg( outMsg );
 	
 	if ( !fragmentedSend ) {
 		// Simple case, no fragments to sent
 		outMsg.WriteData( unsentMsg.GetReadData(), unsentMsg.GetSize() );
 		unsentMsg.SetSize( 0 );
 	} else {
 		int currentSize = idMath::ClampInt( 0, MAX_PACKET_SIZE, unsentMsg.GetRemainingData() );
 		assert( currentSize > 0 );
 		assert( unsentMsg.GetRemainingData() - currentSize >= 0 );
 		
 		// See if we'll have more fragments once we subtract off how much we're about to write
 		bool moreFragments = ( unsentMsg.GetRemainingData() - currentSize > 0 ) ? true : false;
 		
 		if ( !unsentMsg.GetReadCount() ) {		// If this is the first read, then we know it's the first fragment
 			assert( moreFragments );			// If we have a first, we must have more or something went wrong
 			idInnerPacketHeader header( PACKET_TYPE_FRAGMENTED, FRAGMENT_START );
 			header.WriteToMsg( outMsg );
 		} else {
 			idInnerPacketHeader header( PACKET_TYPE_FRAGMENTED, moreFragments ? FRAGMENT_MIDDLE : FRAGMENT_END );
 			header.WriteToMsg( outMsg );
 		}
 		
 		outMsg.WriteLong( fragmentSequence );
 		outMsg.WriteData( unsentMsg.GetReadData() + unsentMsg.GetReadCount(), currentSize );
 		unsentMsg.ReadData( NULL, currentSize );
 
 		assert( moreFragments == unsentMsg.GetRemainingData() > 0 );
 		fragmentedSend = moreFragments;
 		
 		fragmentSequence++;				// Advance sequence
 
 		fragmentAccumulator++;			// update the counter for the net debug hud
 	}
 
 
 	// The caller needs to send this packet, so assume he did, and update rates
 	UpdateOutgoingRate( time, outMsg.GetSize() );
 	
 	return true;
 }
 
 /*
 ================================================
 idPacketProcessor::ProcessIncoming
 ================================================
 */
 int idPacketProcessor::ProcessIncoming( int time, sessionId_t expectedSessionID, idBitMsg & msg, idBitMsg & out, int & userData, const int peerNum ) {
 	assert( msg.GetSize() <= MAX_FINAL_PACKET_SIZE );
 	
 	UpdateIncomingRate( time, msg.GetSize() );
 
 
 	idOuterPacketHeader outerHeader;
 	outerHeader.ReadFromMsg( msg );
 
 	sessionId_t sessionID = outerHeader.GetSessionID();
 	assert( sessionID == expectedSessionID );
 	
 	if ( !verify( sessionID != SESSION_ID_CONNECTIONLESS_PARTY && sessionID != SESSION_ID_CONNECTIONLESS_GAME && sessionID != SESSION_ID_CONNECTIONLESS_GAME_STATE ) ) {
 		idLib::Printf( "Expected non connectionless ID, but got a connectionless one\n" );
 		return RETURN_TYPE_NONE;
 	}
 	
 	if ( sessionID != expectedSessionID ) {
 		idLib::Printf( "Expected session id: %8x but got %8x instead\n", expectedSessionID, sessionID );
 		return RETURN_TYPE_NONE;
 	}
 
 	int c,b;
 	msg.SaveReadState( c, b );
 
 	idInnerPacketHeader header;
 	header.ReadFromMsg( msg );
 
 	if ( header.Type() != PACKET_TYPE_FRAGMENTED ) {
 		// Non fragmented
 		msg.RestoreReadState( c, b );		// Reset since we took a byte to check the type
 		return FinalizeRead( msg, out, userData );
 	} 
 
 	// Decode fragmented packet
 	int readSequence = msg.ReadLong();	// Read sequence of fragment
 
 	if ( header.Value() == FRAGMENT_START ) {
 		msgWritePos = 0;				// Reset msg reconstruction write pos
 	} else if ( fragmentSequence == -1 || readSequence != fragmentSequence + 1 ) {
 		droppedFrags++;
 		idLib::Printf( "Dropped Fragments - PeerNum: %i FragmentSeq: %i, ReadSeq: %i, Total: %i\n", peerNum, fragmentSequence, readSequence, droppedFrags );
 
 		// If this is the middle or end, make sure we are reading in fragmentSequence
 		fragmentSequence = -1;
 		return RETURN_TYPE_NONE;		// Out of sequence
 	}
 	fragmentSequence = readSequence;
 	assert( msg.GetRemainingData() > 0 );
 
 	if ( !verify( msgWritePos + msg.GetRemainingData() < sizeof( msgBuffer ) ) ) {
 		idLib::Error( "ProcessIncoming: Fragmented msg buffer overflow." );
 	}
 
 	memcpy( msgBuffer + msgWritePos, msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
 	msgWritePos += msg.GetRemainingData();
 		
 	if ( header.Value() == FRAGMENT_END ) {
 		// Done reconstructing the msg
 		idBitMsg msg( msgBuffer, sizeof( msgBuffer ) );
 		msg.SetSize( msgWritePos );
 		return FinalizeRead( msg, out, userData );
 	}
 		
 	if ( !verify( header.Value() == FRAGMENT_START || header.Value() == FRAGMENT_MIDDLE ) ) {
 		idLib::Printf( "ProcessIncoming: Invalid packet.\n" );
 	}
 
 	// If we get here, this is part (either beginning or end) of a fragmented packet.
 	// We return RETURN_TYPE_NONE to let the caller know they don't need to do anything yet.
 	return RETURN_TYPE_NONE;
 }
 		
 /*
 ================================================
 idPacketProcessor::ProcessConnectionlessOutgoing
 ================================================
 */
 bool idPacketProcessor::ProcessConnectionlessOutgoing( idBitMsg & msg, idBitMsg & out, int lobbyType, int userData ) {
 	sessionId_t sessionID = lobbyType + 1;
 
 	
 	// Write outer header
 	idOuterPacketHeader outerHeader( sessionID );
 	outerHeader.WriteToMsg( out );
 
 	// Write inner header
 	idInnerPacketHeader header( PACKET_TYPE_OOB, userData );
 	header.WriteToMsg( out );
 
 	// Write msg
 	out.WriteData( msg.GetReadData(), msg.GetSize() );
 
 
 	return true;
 }
 
 /*
 ================================================
 idPacketProcessor::ProcessConnectionlessIncoming
 ================================================
 */
 bool idPacketProcessor::ProcessConnectionlessIncoming( idBitMsg & msg, idBitMsg & out, int & userData ) {
 
 	idOuterPacketHeader outerHeader;
 	outerHeader.ReadFromMsg( msg );
 
 	sessionId_t sessionID = outerHeader.GetSessionID();
 
 	if ( sessionID != SESSION_ID_CONNECTIONLESS_PARTY && sessionID != SESSION_ID_CONNECTIONLESS_GAME && sessionID != SESSION_ID_CONNECTIONLESS_GAME_STATE ) {
 		// Not a connectionless msg (this can happen if a previously connected peer keeps sending data for whatever reason)
 		idLib::Printf( "ProcessConnectionlessIncoming: Invalid session ID - %d\n", sessionID );
 		return false;
 	}
 
 	idInnerPacketHeader header;
 	header.ReadFromMsg( msg );
 
 	if ( header.Type() != PACKET_TYPE_OOB ) {
 		idLib::Printf( "ProcessConnectionlessIncoming: header.Type() != PACKET_TYPE_OOB\n" );
 		return false;		// Only out-of-band packets supported for connectionless
 	}
 	
 	userData = header.Value();
 	
 	out.BeginWriting();
 	out.WriteData( msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
 	out.SetSize( msg.GetRemainingData() );
 
 	return true;
 }
 
 /*
 ================================================
 idPacketProcessor::GetSessionID
 ================================================
 */
 idPacketProcessor::sessionId_t idPacketProcessor::GetSessionID( idBitMsg & msg ) {
 	sessionId_t sessionID;
 	int c,b;
 	msg.SaveReadState( c, b );
 	// Read outer header
 	idOuterPacketHeader outerHeader;
 	outerHeader.ReadFromMsg( msg );
 	
 	// Get session ID
 	sessionID = outerHeader.GetSessionID();
 
 	msg.RestoreReadState( c, b );
 	return sessionID;
 }
 
 /*
 ================================================
 idPacketProcessor::VerifyEmptyReliableQueue
 ================================================
 */
 idCVar net_verifyReliableQueue( "net_verifyReliableQueue", "2", CVAR_INTEGER, "0: warn only, 1: error, 2: fixup, 3: fixup and verbose, 4: force test" );
 #define RELIABLE_VERBOSE if ( net_verifyReliableQueue.GetInteger() >= 3 ) idLib::Printf
 void idPacketProcessor::VerifyEmptyReliableQueue( byte keepMsgBelowThis, byte replaceWithThisMsg ) {
 	if ( net_verifyReliableQueue.GetInteger() == 4 ) {
 		RELIABLE_VERBOSE( "pushing a fake game reliable\n" );
 		const char * garbage = "garbage";
 		QueueReliableMessage( keepMsgBelowThis + 4, (const byte *)garbage, 8 );
 		QueueReliableMessage( replaceWithThisMsg, NULL, 0 );
 	}
 	if ( reliable.Num() == 0 ) {
 		return;
 	}
 	if ( net_verifyReliableQueue.GetInteger() == 1 ) {
 		idLib::Error( "reliable queue is not empty: %d messages", reliable.Num() );
 		return;
 	}
 	idLib::Warning( "reliable queue is not empty: %d messages", reliable.Num() );
 	if ( net_verifyReliableQueue.GetInteger() == 0 ) {
 		return;
 	}
 	// drop some stuff that is potentially dangerous and should not transmit
 	idDataQueue< MAX_RELIABLE_QUEUE, MAX_MSG_SIZE > clean;
 	RELIABLE_VERBOSE( "rollback send sequence from %d to %d\n", reliableSequenceSend, reliable.ItemSequence( 0 ) );
 	for ( int i = 0; i < reliable.Num(); i++ ) {
 		byte peek = reliable.ItemData( i )[0];
 		if ( peek < keepMsgBelowThis ) {
 			RELIABLE_VERBOSE( "keeping %d\n", peek );
 			clean.Append( reliable.ItemSequence( i ), reliable.ItemData( i ), reliable.ItemLength( i ) );
 		} else {
 			// Replace with fake msg, so we retain itemsequence ordering.
 			// If we don't do this, it's possible we remove the last msg, then append a single msg before the next send, 
 			// and the client may think he already received the msg, since his last reliableSequenceRecv could be greater than our
 			// reliableSequenceSend if he already received the group of reliables we are mucking with
 			clean.Append( reliable.ItemSequence( i ), &replaceWithThisMsg, 1 );
 			RELIABLE_VERBOSE( "dropping %d\n", peek );
 		}
 	}
 
 	assert( reliable.Num() == clean.Num() );
 
 	reliable = clean;
 }