/*****************************************************************************
The Dark Mod GPL Source Code

This file is part of the The Dark Mod Source Code, originally based
on the Doom 3 GPL Source Code as published in 2011.

The Dark Mod 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. For details, see LICENSE.TXT.

Project: The Dark Mod (http://www.thedarkmod.com/)

******************************************************************************/

#include "precompiled.h"
#pragma hdrstop



#include "AsyncNetwork.h"

#include "../Session_local.h"

const int SETUP_CONNECTION_RESEND_TIME	= 1000;
const int EMPTY_RESEND_TIME				= 500;
const int PREDICTION_FAST_ADJUST		= 4;


/*
==================
idAsyncClient::idAsyncClient
==================
*/
idAsyncClient::idAsyncClient( void ) {
	guiNetMenu = NULL;
	updateState = UPDATE_NONE;
	Clear();
}

/*
==================
idAsyncClient::Clear
==================
*/
void idAsyncClient::Clear( void ) {
	active = false;
	realTime = 0;
	clientTime = 0;
	clientId = 0;
	clientDataChecksum = 0;
	clientNum = 0;
	clientState = CS_DISCONNECTED;
	clientPrediction = 0;
	clientPredictTime = 0;
	serverId = 0;
	serverChallenge = 0;
	serverMessageSequence = 0;
	lastConnectTime = -9999;
	lastEmptyTime = -9999;
	lastPacketTime = -9999;
	lastSnapshotTime = -9999;
	snapshotGameFrame = 0;
	snapshotGameTime = 0;
	snapshotSequence = 0;
	gameInitId = GAME_INIT_ID_INVALID;
	gameFrame = 0;
	gameTimeResidual = 0;
	gameTime = 0;
	memset( userCmds, 0, sizeof( userCmds ) );
	backgroundDownload.completed = true;
	lastRconTime = 0;
	showUpdateMessage = false;
	lastFrameDelta = 0;

	dlRequest = -1;
	dlCount = -1;
	memset( dlChecksums, 0, sizeof( int ) * MAX_PURE_PAKS );
	currentDlSize = 0;
	totalDlSize = 0;
}

/*
==================
idAsyncClient::Shutdown
==================
*/
void idAsyncClient::Shutdown( void ) {
	guiNetMenu = NULL;
	updateMSG.Clear();
	updateURL.Clear();
	updateFile.Clear();
	updateFallback.Clear();
	backgroundDownload.url.url.Clear();
	dlList.Clear();
}

/*
==================
idAsyncClient::InitPort
==================
*/
bool idAsyncClient::InitPort( void ) {
	// if this is the first time we connect to a server, open the UDP port
	if ( !clientPort.GetPort() ) {
		if ( !clientPort.InitForPort( PORT_ANY ) ) {
			common->Printf( "Couldn't open client network port.\n" );
			return false;
		}
	}
	// maintain it valid between connects and ui manager reloads
	guiNetMenu = uiManager->FindGui( "guis/netmenu.gui", true, false, true );

	return true;
}

/*
==================
idAsyncClient::ClosePort
==================
*/
void idAsyncClient::ClosePort( void ) {
	clientPort.Close();
}

/*
==================
idAsyncClient::ClearPendingPackets
==================
*/
void idAsyncClient::ClearPendingPackets( void ) {
	int			size;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	netadr_t	from;

	while( clientPort.GetPacket( from, msgBuf, size, sizeof( msgBuf ) ) ) {
	}
}

/*
==================
idAsyncClient::HandleGuiCommandInternal
==================
*/
const char* idAsyncClient::HandleGuiCommandInternal( const char *cmd ) {
	if ( !idStr::Cmp( cmd, "abort" ) ) {
		common->DPrintf( "connection aborted\n" );
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		return "";
	} else {
		common->DWarning( "idAsyncClient::HandleGuiCommand: unknown cmd %s", cmd );
	}
	return NULL;
}

/*
==================
idAsyncClient::HandleGuiCommand
==================
*/
const char* idAsyncClient::HandleGuiCommand( const char *cmd ) {
	return idAsyncNetwork::client.HandleGuiCommandInternal( cmd );
}

/*
==================
idAsyncClient::ConnectToServer
==================
*/
void idAsyncClient::ConnectToServer( const netadr_t adr ) {
	// shutdown any current game. that includes network disconnect
	session->Stop();

	if ( !InitPort() ) {
		return;
	}

	if ( cvarSystem->GetCVarBool( "net_serverDedicated" ) ) {
		common->Printf( "Can't connect to a server as dedicated\n" );
		return;
	}

	// trash any currently pending packets
	ClearPendingPackets();
	
	serverAddress = adr;

	// clear the client state
	Clear();

	// get a pseudo random client id, but don't use the id which is reserved for connectionless packets
	clientId = Sys_Milliseconds() & CONNECTIONLESS_MESSAGE_ID_MASK;

	// calculate a checksum on some of the essential data used
	clientDataChecksum = declManager->GetChecksum();

	// start challenging the server
	clientState = CS_CHALLENGING;

	active = true;

	guiNetMenu = uiManager->FindGui( "guis/netmenu.gui", true, false, true );
	guiNetMenu->SetStateString( "status", va( common->Translate( "#str_06749" ), Sys_NetAdrToString( adr ) ) );
	session->SetGUI( guiNetMenu, HandleGuiCommand );
}

/*
==================
idAsyncClient::Reconnect
==================
*/
void idAsyncClient::Reconnect( void ) {
	ConnectToServer( serverAddress );
}

/*
==================
idAsyncClient::ConnectToServer
==================
*/
void idAsyncClient::ConnectToServer( const char *address ) {
	int serverNum;
	netadr_t adr;

	if ( idStr::IsNumeric( address ) ) {
		serverNum = atoi( address );
		if ( serverNum < 0 || serverNum >= serverList.Num() ) {
			session->MessageBox( MSG_OK, va( common->Translate( "#str_06733" ), serverNum ), common->Translate( "#str_06735" ), true );
			return;
		}
		adr = serverList[ serverNum ].adr;
	} else {
		if ( !Sys_StringToNetAdr( address, &adr, true ) ) {
			session->MessageBox( MSG_OK, va( common->Translate( "#str_06734" ), address ), common->Translate( "#str_06735" ), true );
			return;
		}
	}
	if ( !adr.port ) {
		adr.port = PORT_SERVER;
	}

	common->Printf( "\"%s\" resolved to %s\n", address, Sys_NetAdrToString( adr ) );

	ConnectToServer( adr );
}

/*
==================
idAsyncClient::DisconnectFromServer
==================
*/
void idAsyncClient::DisconnectFromServer( void ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( clientState >= CS_CONNECTED ) {
		// send reliable disconnect to server
		msg.Init( msgBuf, sizeof( msgBuf ) );
		msg.WriteByte( CLIENT_RELIABLE_MESSAGE_DISCONNECT );
		msg.WriteString( "disconnect" );

		if ( !channel.SendReliableMessage( msg ) ) {
			common->Error( "client->server reliable messages overflow\n" );
		}

		SendEmptyToServer( true );
		SendEmptyToServer( true );
		SendEmptyToServer( true );
	}

	active = false;
}

/*
==================
idAsyncClient::GetServerInfo
==================
*/
void idAsyncClient::GetServerInfo( const netadr_t adr ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	
	if ( !InitPort() ) {
		return;
	}

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "getInfo" );
	msg.WriteLong( serverList.GetChallenge() );	// challenge

	clientPort.SendPacket( adr, msg.GetData(), msg.GetSize() );	
}

/*
==================
idAsyncClient::GetServerInfo
==================
*/
void idAsyncClient::GetServerInfo( const char *address ) {
	netadr_t	adr;

	if ( address && *address != '\0' ) {
		if ( !Sys_StringToNetAdr( address, &adr, true ) ) {
			common->Printf( "Couldn't get server address for \"%s\"\n", address );
			return;
		}
	} else if ( active ) {
		adr = serverAddress;
	} else if ( idAsyncNetwork::server.IsActive() ) {
		// used to be a Sys_StringToNetAdr( "localhost", &adr, true ); and send a packet over loopback
		// but this breaks with net_ip ( typically, for multi-homed servers )
		idAsyncNetwork::server.PrintLocalServerInfo();
		return;
	} else {
		common->Printf( "no server found\n" );
		return;
	}

	if ( !adr.port ) {
		adr.port = PORT_SERVER;
	}

	GetServerInfo( adr );
}

/*
==================
idAsyncClient::GetLANServers
==================
*/
void idAsyncClient::GetLANServers( void ) {
	int			i;
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	netadr_t	broadcastAddress;

	if ( !InitPort() ) {
		return;
	}

	idAsyncNetwork::LANServer.SetBool( true );

	serverList.SetupLANScan();

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "getInfo" );
	msg.WriteLong( serverList.GetChallenge() );

	broadcastAddress.type = NA_BROADCAST;
	for ( i = 0; i < MAX_SERVER_PORTS; i++ ) {
		broadcastAddress.port = PORT_SERVER + i;
		clientPort.SendPacket( broadcastAddress, msg.GetData(), msg.GetSize() );
	}
}

/*
==================
idAsyncClient::GetNETServers
==================
*/
void idAsyncClient::GetNETServers( void ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	idAsyncNetwork::LANServer.SetBool( false );

	// NetScan only clears GUI and results, not the stored list
	serverList.Clear( );
	serverList.NetScan( );
	serverList.StartServers( true );

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "getServers" );
	msg.WriteLong( ASYNC_PROTOCOL_VERSION );
	msg.WriteString( cvarSystem->GetCVarString( "fs_mod" ) );
	msg.WriteBits( cvarSystem->GetCVarInteger( "gui_filter_password" ), 2 );
	msg.WriteBits( cvarSystem->GetCVarInteger( "gui_filter_players" ), 2 );
	msg.WriteBits( cvarSystem->GetCVarInteger( "gui_filter_gameType" ), 2 );

	netadr_t adr;
	if ( idAsyncNetwork::GetMasterAddress( 0, adr ) ) {
		clientPort.SendPacket( adr, msg.GetData(), msg.GetSize() );
	}
}

/*
==================
idAsyncClient::ListServers
==================
*/
void idAsyncClient::ListServers( void ) {
	int i;

	for ( i = 0; i < serverList.Num(); i++ ) {
		common->Printf( "%3d: %s %dms (%s)\n", i, serverList[i].serverInfo.GetString( "si_name" ), serverList[ i ].ping, Sys_NetAdrToString( serverList[i].adr ) );
	}
}

/*
==================
idAsyncClient::ClearServers
==================
*/
void idAsyncClient::ClearServers( void ) {
	serverList.Clear();
}

/*
==================
idAsyncClient::RemoteConsole
==================
*/
void idAsyncClient::RemoteConsole( const char *command ) {
	netadr_t	adr;
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( !InitPort() ) {
		return;
	}

	if ( active ) {
		adr = serverAddress;
	} else {
		Sys_StringToNetAdr( idAsyncNetwork::clientRemoteConsoleAddress.GetString(), &adr, true );
	}
	
	if ( !adr.port ) {
		adr.port = PORT_SERVER;
	}

	lastRconAddress = adr;
	lastRconTime = realTime;

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "rcon" );
	msg.WriteString( idAsyncNetwork::clientRemoteConsolePassword.GetString() );
	msg.WriteString( command );

	clientPort.SendPacket( adr, msg.GetData(), msg.GetSize() );	
}

/*
==================
idAsyncClient::GetPrediction
==================
*/
int idAsyncClient::GetPrediction( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return -1;
	} else {
		return clientPrediction;
	}
}

/*
==================
idAsyncClient::GetTimeSinceLastPacket
==================
*/
int idAsyncClient::GetTimeSinceLastPacket( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return -1;
	} else {
		return clientTime - lastPacketTime;
	}
}

/*
==================
idAsyncClient::GetOutgoingRate
==================
*/
int idAsyncClient::GetOutgoingRate( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return -1;
	} else {
		return channel.GetOutgoingRate();
	}
}

/*
==================
idAsyncClient::GetIncomingRate
==================
*/
int idAsyncClient::GetIncomingRate( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return -1;
	} else {
		return channel.GetIncomingRate();
	}
}

/*
==================
idAsyncClient::GetOutgoingCompression
==================
*/
float idAsyncClient::GetOutgoingCompression( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return 0.0f;
	} else {
		return channel.GetOutgoingCompression();
	}
}

/*
==================
idAsyncClient::GetIncomingCompression
==================
*/
float idAsyncClient::GetIncomingCompression( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return 0.0f;
	} else {
		return channel.GetIncomingCompression();
	}
}

/*
==================
idAsyncClient::GetIncomingPacketLoss
==================
*/
float idAsyncClient::GetIncomingPacketLoss( void ) const {
	if ( clientState < CS_CONNECTED ) {
		return 0.0f;
	} else {
		return channel.GetIncomingPacketLoss();
	}
}

/*
==================
idAsyncClient::DuplicateUsercmds
==================
*/
void idAsyncClient::DuplicateUsercmds( int frame, int time ) {
	int i, previousIndex, currentIndex;

	previousIndex = ( frame - 1 ) & ( MAX_USERCMD_BACKUP - 1 );
	currentIndex = frame & ( MAX_USERCMD_BACKUP - 1 );

	// duplicate previous user commands if no new commands are available for a client
	for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
		idAsyncNetwork::DuplicateUsercmd( userCmds[previousIndex][i], userCmds[currentIndex][i], frame, time );
	}
}

/*
==================
idAsyncClient::SendUserInfoToServer
==================
*/
void idAsyncClient::SendUserInfoToServer( void ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	idDict		info;

	if ( clientState < CS_CONNECTED ) {
		return;
	}

	info = *cvarSystem->MoveCVarsToDict( CVAR_USERINFO );
	
	// send reliable client info to server
	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteByte( CLIENT_RELIABLE_MESSAGE_CLIENTINFO );
	msg.WriteDeltaDict( info, &sessLocal.mapSpawnData.userInfo[ clientNum ] );

	if ( !channel.SendReliableMessage( msg ) ) {
		common->Error( "client->server reliable messages overflow\n" );
	}

	sessLocal.mapSpawnData.userInfo[clientNum] = info;
}

/*
==================
idAsyncClient::SendEmptyToServer
==================
*/
void idAsyncClient::SendEmptyToServer( bool force, bool mapLoad ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( lastEmptyTime > realTime ) {
		lastEmptyTime = realTime;
	}

	if ( !force && ( realTime - lastEmptyTime < EMPTY_RESEND_TIME ) ) {
		return;
	}

	if ( idAsyncNetwork::verbose.GetInteger() ) {
		common->Printf( "sending empty to server, gameInitId = %d\n", mapLoad ? GAME_INIT_ID_MAP_LOAD : gameInitId );
	}

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteLong( serverMessageSequence );
	msg.WriteLong( mapLoad ? GAME_INIT_ID_MAP_LOAD : gameInitId );
	msg.WriteLong( snapshotSequence );
	msg.WriteByte( CLIENT_UNRELIABLE_MESSAGE_EMPTY );

	channel.SendMessage( clientPort, clientTime, msg );

	while( channel.UnsentFragmentsLeft() ) {
		channel.SendNextFragment( clientPort, clientTime );
	}

	lastEmptyTime = realTime;
}

/*
==================
idAsyncClient::SendPingResponseToServer
==================
*/
void idAsyncClient::SendPingResponseToServer( int time ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
		common->Printf( "sending ping response to server, gameInitId = %d\n", gameInitId );
	}

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteLong( serverMessageSequence );
	msg.WriteLong( gameInitId );
	msg.WriteLong( snapshotSequence );
	msg.WriteByte( CLIENT_UNRELIABLE_MESSAGE_PINGRESPONSE );
	msg.WriteLong( time );

	channel.SendMessage( clientPort, clientTime, msg );
	while( channel.UnsentFragmentsLeft() ) {
		channel.SendNextFragment( clientPort, clientTime );
	}
}

/*
==================
idAsyncClient::SendUsercmdsToServer
==================
*/
void idAsyncClient::SendUsercmdsToServer( void ) {
	int			i, numUsercmds, index;
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	usercmd_t *	last;

	if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
		common->Printf( "sending usercmd to server: gameInitId = %d, gameFrame = %d, gameTime = %d\n", gameInitId, gameFrame, gameTime );
	}

	// generate user command for this client
	index = gameFrame & ( MAX_USERCMD_BACKUP - 1 );
	userCmds[index][clientNum] = usercmdGen->GetDirectUsercmd();
	userCmds[index][clientNum].gameFrame = gameFrame;
	userCmds[index][clientNum].gameTime = gameTime;

	// send the user commands to the server
	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteLong( serverMessageSequence );
	msg.WriteLong( gameInitId );
	msg.WriteLong( snapshotSequence );
	msg.WriteByte( CLIENT_UNRELIABLE_MESSAGE_USERCMD );
	msg.WriteShort( clientPrediction );

	numUsercmds = idMath::ClampInt( 0, 10, idAsyncNetwork::clientUsercmdBackup.GetInteger() ) + 1;

	// write the user commands
	msg.WriteLong( gameFrame );
	msg.WriteByte( numUsercmds );
	for ( last = NULL, i = gameFrame - numUsercmds + 1; i <= gameFrame; i++ ) {
		index = i & ( MAX_USERCMD_BACKUP - 1 );
		idAsyncNetwork::WriteUserCmdDelta( msg, userCmds[index][clientNum], last );
		last = &userCmds[index][clientNum];
	}

	channel.SendMessage( clientPort, clientTime, msg );
	while( channel.UnsentFragmentsLeft() ) {
		channel.SendNextFragment( clientPort, clientTime );
	}
}

/*
==================
idAsyncClient::InitGame
==================
*/
void idAsyncClient::InitGame( int serverGameInitId, int serverGameFrame, int serverGameTime, const idDict &serverSI ) {
	gameInitId = serverGameInitId;
	gameFrame = snapshotGameFrame = serverGameFrame;
	gameTime = snapshotGameTime = serverGameTime;
	gameTimeResidual = 0;
	memset( userCmds, 0, sizeof( userCmds ) );

	for ( int i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
		sessLocal.mapSpawnData.userInfo[ i ].Clear();
	}

	sessLocal.mapSpawnData.serverInfo = serverSI;
}

/*
==================
idAsyncClient::ProcessUnreliableServerMessage
==================
*/
void idAsyncClient::ProcessUnreliableServerMessage( const idBitMsg &msg ) {
	int i, j, index, id, numDuplicatedUsercmds, aheadOfServer, numUsercmds, delta;
	int serverGameInitId, serverGameFrame, serverGameTime;
	idDict serverSI;
	usercmd_t *last;

	serverGameInitId = msg.ReadLong();

	id = msg.ReadByte();
	switch( id ) {
		case SERVER_UNRELIABLE_MESSAGE_EMPTY: {
			if ( idAsyncNetwork::verbose.GetInteger() ) {
				common->Printf( "received empty message from server\n" );
			}
			break;
		}
		case SERVER_UNRELIABLE_MESSAGE_PING: {
			if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
				common->Printf( "received ping message from server\n" );
			}
			SendPingResponseToServer( msg.ReadLong() );
			break;
		}
		case SERVER_UNRELIABLE_MESSAGE_GAMEINIT: {
			serverGameFrame = msg.ReadLong();
			serverGameTime = msg.ReadLong();
			msg.ReadDeltaDict( serverSI, NULL );

			InitGame( serverGameInitId, serverGameFrame, serverGameTime, serverSI );

			channel.ResetRate();

			if ( idAsyncNetwork::verbose.GetInteger() ) {
				common->Printf( "received gameinit, gameInitId = %d, gameFrame = %d, gameTime = %d\n", gameInitId, gameFrame, gameTime );
			}

			// mute sound
			soundSystem->SetMute( true );

			// ensure chat icon goes away when the GUI is changed...
			//cvarSystem->SetCVarBool( "ui_chat", false );

			// load map
			session->SetGUI( NULL, NULL );
			sessLocal.ExecuteMapChange();

			break;
		}
		case SERVER_UNRELIABLE_MESSAGE_SNAPSHOT: {
			// if the snapshot is from a different game
			if ( serverGameInitId != gameInitId ) {
				if ( idAsyncNetwork::verbose.GetInteger() ) {
					common->Printf( "ignoring snapshot with != gameInitId\n" );
				}
				break;
			}

			snapshotSequence = msg.ReadLong();
			snapshotGameFrame = msg.ReadLong();
			snapshotGameTime = msg.ReadLong();
			numDuplicatedUsercmds = msg.ReadByte();
			aheadOfServer = msg.ReadShort();

			// read the game snapshot
			game->ClientReadSnapshot( clientNum, snapshotSequence, snapshotGameFrame, snapshotGameTime, numDuplicatedUsercmds, aheadOfServer, msg );

			// read user commands of other clients from the snapshot
			for ( last = NULL, i = msg.ReadByte(); i < MAX_ASYNC_CLIENTS; i = msg.ReadByte() ) {
				numUsercmds = msg.ReadByte();
				if ( numUsercmds > MAX_USERCMD_RELAY ) {
					common->Error( "snapshot %d contains too many user commands for client %d", snapshotSequence, i );
					break;
				}
				for ( j = 0; j < numUsercmds; j++ ) {
					index = ( snapshotGameFrame + j ) & ( MAX_USERCMD_BACKUP - 1 );
					idAsyncNetwork::ReadUserCmdDelta( msg, userCmds[index][i], last );
					userCmds[index][i].gameFrame = snapshotGameFrame + j;
					userCmds[index][i].duplicateCount = 0;
					last = &userCmds[index][i];
				}
				// clear all user commands after the ones just read from the snapshot
				for ( j = numUsercmds; j < MAX_USERCMD_BACKUP; j++ ) {
					index = ( snapshotGameFrame + j ) & ( MAX_USERCMD_BACKUP - 1 );
					userCmds[index][i].gameFrame = 0;
					userCmds[index][i].gameTime = 0;
				}
			}

			// if this is the first snapshot after a game init was received
			if ( clientState == CS_CONNECTED ) {
				gameTimeResidual = 0;
				clientState = CS_INGAME;
				assert( !sessLocal.GetActiveMenu( ) );
				if ( idAsyncNetwork::verbose.GetInteger() ) {
					common->Printf( "received first snapshot, gameInitId = %d, gameFrame %d gameTime %d\n", gameInitId, snapshotGameFrame, snapshotGameTime );
				}
			}

			// if the snapshot is newer than the clients current game time
			if ( gameTime < snapshotGameTime || gameTime > snapshotGameTime + idAsyncNetwork::clientMaxPrediction.GetInteger() ) {
				gameFrame = snapshotGameFrame;
				gameTime = snapshotGameTime;
				gameTimeResidual = idMath::ClampInt( -idAsyncNetwork::clientMaxPrediction.GetInteger(), idAsyncNetwork::clientMaxPrediction.GetInteger(), gameTimeResidual );
				clientPredictTime = idMath::ClampInt( -idAsyncNetwork::clientMaxPrediction.GetInteger(), idAsyncNetwork::clientMaxPrediction.GetInteger(), clientPredictTime );
			}

			// adjust the client prediction time based on the snapshot time
			clientPrediction -= ( 1 - ( INTSIGNBITSET( aheadOfServer - idAsyncNetwork::clientPrediction.GetInteger() ) << 1 ) );
			clientPrediction = idMath::ClampInt( idAsyncNetwork::clientPrediction.GetInteger(), idAsyncNetwork::clientMaxPrediction.GetInteger(), clientPrediction );
			delta = gameTime - ( snapshotGameTime + clientPrediction );
			clientPredictTime -= ( delta / PREDICTION_FAST_ADJUST ) + ( 1 - ( INTSIGNBITSET( delta ) << 1 ) );

			lastSnapshotTime = clientTime;

			if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
				common->Printf( "received snapshot, gameInitId = %d, gameFrame = %d, gameTime = %d\n", gameInitId, gameFrame, gameTime );
			}

			if ( numDuplicatedUsercmds && ( idAsyncNetwork::verbose.GetInteger() == 2 ) ) {
				common->Printf( "server duplicated %d user commands before snapshot %d\n", numDuplicatedUsercmds, snapshotGameFrame );
			}
			break;
		}
		default: {
			common->Printf( "unknown unreliable server message %d\n", id );
			break;
		}
	}
}

/*
===============
idAsyncClient::ReadLocalizedServerString
===============
*/
void idAsyncClient::ReadLocalizedServerString( const idBitMsg &msg, char *out, int maxLen ) {
	msg.ReadString( out, maxLen );
	// look up localized string. if the message is not an #str_ format, we'll just get it back unchanged
	idStr::snPrintf( out, maxLen - 1, "%s", common->Translate( out ) );
}

/*
==================
idAsyncClient::ProcessReliableServerMessages
==================
*/
void idAsyncClient::ProcessReliableServerMessages( void ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	byte		id;

	msg.Init( msgBuf, sizeof( msgBuf ) );

	while ( channel.GetReliableMessage( msg ) ) {
		id = msg.ReadByte();
		switch( id ) {
			case SERVER_RELIABLE_MESSAGE_CLIENTINFO: {
				int clientNum;
				clientNum = msg.ReadByte();

				idDict &info = sessLocal.mapSpawnData.userInfo[ clientNum ];
				bool haveBase = ( msg.ReadBits( 1 ) != 0 );

#if ID_CLIENTINFO_TAGS
				int checksum = info.Checksum();
				int srv_checksum = msg.ReadLong();
				if ( checksum != srv_checksum ) {
					common->DPrintf( "SERVER_RELIABLE_MESSAGE_CLIENTINFO %d (haveBase: %s): != checksums srv: 0x%x local: 0x%x\n", clientNum, haveBase ? "true" : "false", checksum, srv_checksum );
					info.Print();
				} else {
					common->DPrintf( "SERVER_RELIABLE_MESSAGE_CLIENTINFO %d (haveBase: %s): checksums ok 0x%x\n", clientNum, haveBase ? "true" : "false", checksum );
				}
#endif

				if ( haveBase ) {
					msg.ReadDeltaDict( info, &info );
				} else {
					msg.ReadDeltaDict( info, NULL );
				}

				// server forces us to a different userinfo
				if ( clientNum == idAsyncClient::clientNum ) {
					common->DPrintf( "local user info modified by server\n" );
					cvarSystem->SetCVarsFromDict( info );
					cvarSystem->ClearModifiedFlags( CVAR_USERINFO ); // don't emit back
				}
				game->SetUserInfo( clientNum, info, true, false );
				break;
			}
			case SERVER_RELIABLE_MESSAGE_SYNCEDCVARS: {
				idDict &info = sessLocal.mapSpawnData.syncedCVars;
				msg.ReadDeltaDict( info, &info );
				cvarSystem->SetCVarsFromDict( info );
				if ( !idAsyncNetwork::allowCheats.GetBool() ) {
					cvarSystem->ResetFlaggedVariables( CVAR_CHEAT );
				}
				break;
			}
			case SERVER_RELIABLE_MESSAGE_PRINT: {
				char string[MAX_STRING_CHARS];
				msg.ReadString( string, MAX_STRING_CHARS );
				common->Printf( "%s\n", string );
				break;
			}
			case SERVER_RELIABLE_MESSAGE_DISCONNECT: {
				int clientNum;
				char string[MAX_STRING_CHARS];
				clientNum = msg.ReadLong( );
				ReadLocalizedServerString( msg, string, MAX_STRING_CHARS );
				if ( clientNum == idAsyncClient::clientNum ) {
					session->Stop();
					session->MessageBox( MSG_OK, string, common->Translate ( "#str_04319" ), true );
					session->StartMenu();
				} else {
					common->Printf( "client %d %s\n", clientNum, string );
					cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "addChatLine \"%s^0 %s\"", sessLocal.mapSpawnData.userInfo[ clientNum ].GetString( "ui_name" ), string ) );
					sessLocal.mapSpawnData.userInfo[ clientNum ].Clear();
				}
				break;
			}
			case SERVER_RELIABLE_MESSAGE_APPLYSNAPSHOT: {
				int sequence;
				sequence = msg.ReadLong();
				if ( !game->ClientApplySnapshot( clientNum, sequence ) ) {
					session->Stop();
					common->Error( "couldn't apply snapshot %d", sequence );
				}
				break;
			}
			case SERVER_RELIABLE_MESSAGE_RELOAD: {
				if ( idAsyncNetwork::verbose.GetBool() ) {
					common->Printf( "got MESSAGE_RELOAD from server\n" );
				}
				// simply reconnect, avoid spurious reloads
				cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "reconnect\n" );
				break;
			}
			case SERVER_RELIABLE_MESSAGE_ENTERGAME: {
				SendUserInfoToServer();
				game->SetUserInfo( clientNum, sessLocal.mapSpawnData.userInfo[ clientNum ], true, false );
				cvarSystem->ClearModifiedFlags( CVAR_USERINFO );
				break;
			}
			default: {
				// pass reliable message on to game code
				game->ClientProcessReliableMessage( clientNum, msg );
				break;
			}
		}
	}
}

/*
==================
idAsyncClient::ProcessChallengeResponseMessage
==================
*/
void idAsyncClient::ProcessChallengeResponseMessage( const netadr_t from, const idBitMsg &msg ) {	
	char serverGame[ MAX_STRING_CHARS ], serverGameBase[ MAX_STRING_CHARS ];

	if ( clientState != CS_CHALLENGING ) {
		common->Printf( "Unwanted challenge response received.\n" );
		return;
	}

	serverChallenge = msg.ReadLong();
	serverId = msg.ReadShort();
	msg.ReadString( serverGameBase, MAX_STRING_CHARS );
	msg.ReadString( serverGame, MAX_STRING_CHARS );

	// the server is running a different game... we need to reload in the correct fs_mod
	// NOTE: if the client can restart directly with the right pak order, then we avoid an extra reloadEngine later..
	if ( idStr::Icmp( cvarSystem->GetCVarString( "fs_mod" ), serverGameBase ) || idStr::Icmp( cvarSystem->GetCVarString( "fs_currentfm" ), serverGame ) ) {
		common->Printf( "The server is running a different mod (%s-%s). Restarting..\n", serverGameBase, serverGame );
		cvarSystem->SetCVarString( "fs_mod", serverGameBase );
		cvarSystem->SetCVarString( "fs_currentfm", serverGame );
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "reloadEngine" );
		cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "reconnect\n" );
		return;
	}

	common->Printf( "received challenge response 0x%x from %s\n", serverChallenge, Sys_NetAdrToString( from ) );

	// start sending connect packets instead of challenge request packets
	clientState = CS_CONNECTING;
	lastConnectTime = -9999;

	// take this address as the new server address.  This allows
	// a server proxy to hand off connections to multiple servers
	serverAddress = from;
}

/*
==================
idAsyncClient::ProcessConnectResponseMessage
==================
*/
void idAsyncClient::ProcessConnectResponseMessage( const netadr_t from, const idBitMsg &msg ) {
	int serverGameInitId, serverGameFrame, serverGameTime;
	idDict serverSI;

	if ( clientState >= CS_CONNECTED ) {
		common->Printf( "Duplicate connect received.\n" );
		return;
	}
	if ( clientState != CS_CONNECTING ) {
		common->Printf( "Connect response packet while not connecting.\n" );
		return;
	}
	if ( !Sys_CompareNetAdrBase( from, serverAddress ) ) {
		common->Printf( "Connect response from a different server.\n" );
		common->Printf( "%s should have been %s\n", Sys_NetAdrToString( from ), Sys_NetAdrToString( serverAddress ) );
		return;
	}

	common->Printf( "received connect response from %s\n", Sys_NetAdrToString( from ) );

	channel.Init( from, clientId );
	clientNum = msg.ReadLong();
	clientState = CS_CONNECTED;
	lastPacketTime = -9999;

	serverGameInitId = msg.ReadLong();
	serverGameFrame = msg.ReadLong();
	serverGameTime = msg.ReadLong();
	msg.ReadDeltaDict( serverSI, NULL );

	InitGame( serverGameInitId, serverGameFrame, serverGameTime, serverSI );

	// load map
	session->SetGUI( NULL, NULL );
	sessLocal.ExecuteMapChange();

	clientPredictTime = clientPrediction = idMath::ClampInt( 0, idAsyncNetwork::clientMaxPrediction.GetInteger(), clientTime - lastConnectTime );
}

/*
==================
idAsyncClient::ProcessDisconnectMessage
==================
*/
void idAsyncClient::ProcessDisconnectMessage( const netadr_t from, const idBitMsg &msg ) {
	if ( clientState == CS_DISCONNECTED ) {
		common->Printf( "Disconnect packet while not connected.\n" );
		return;
	}
	if ( !Sys_CompareNetAdrBase( from, serverAddress ) ) {
		common->Printf( "Disconnect packet from unknown server.\n" );
		return;
	}
	session->Stop();
	session->MessageBox( MSG_OK, common->Translate ( "#str_04320" ), NULL, true );
	session->StartMenu();
}

/*
==================
idAsyncClient::ProcessInfoResponseMessage
==================
*/
void idAsyncClient::ProcessInfoResponseMessage( const netadr_t from, const idBitMsg &msg ) {
	int i, protocol, index;
	networkServer_t serverInfo;
	bool verbose = false;

	if ( from.type == NA_LOOPBACK || cvarSystem->GetCVarBool( "developer" ) ) {
		verbose = true;
	}

	serverInfo.clients = 0;
	serverInfo.adr = from;
	serverInfo.challenge = msg.ReadLong();			// challenge
	protocol = msg.ReadLong();
	if ( protocol != ASYNC_PROTOCOL_VERSION ) {
		common->Printf( "server %s ignored - protocol %d.%d, expected %d.%d\n", Sys_NetAdrToString( serverInfo.adr ), protocol >> 16, protocol & 0xffff, ASYNC_PROTOCOL_MAJOR, ASYNC_PROTOCOL_MINOR );
		return;
	}
	msg.ReadDeltaDict( serverInfo.serverInfo, NULL );

	if ( verbose ) {
		common->Printf( "server IP = %s\n", Sys_NetAdrToString( serverInfo.adr ) );
		serverInfo.serverInfo.Print();
	}
	for ( i = msg.ReadByte(); i < MAX_ASYNC_CLIENTS; i = msg.ReadByte() ) {
		serverInfo.pings[ serverInfo.clients ] = msg.ReadShort();
		serverInfo.rate[ serverInfo.clients ] = msg.ReadLong();
		msg.ReadString( serverInfo.nickname[ serverInfo.clients ], MAX_NICKLEN );
		if ( verbose ) {
			common->Printf( "client %2d: %s, ping = %d, rate = %d\n", i, serverInfo.nickname[ serverInfo.clients ], serverInfo.pings[ serverInfo.clients ], serverInfo.rate[ serverInfo.clients ] );
		}
		serverInfo.clients++;
	}
	serverInfo.OSMask = msg.ReadLong();
	index = serverList.InfoResponse( serverInfo );

	common->Printf( "%d: server %s - protocol %d.%d - %s\n", index, Sys_NetAdrToString( serverInfo.adr ), protocol >> 16, protocol & 0xffff, serverInfo.serverInfo.GetString( "si_name" ) );
}

/*
==================
idAsyncClient::ProcessPrintMessage
==================
*/
void idAsyncClient::ProcessPrintMessage( const netadr_t from, const idBitMsg &msg ) {
	char		string[ MAX_STRING_CHARS ];
	int			opcode;
	int			game_opcode = ALLOW_YES;
	const char	*retpass;

	opcode = msg.ReadLong();
	if ( opcode == SERVER_PRINT_GAMEDENY ) {
		game_opcode = msg.ReadLong();
	}
	ReadLocalizedServerString( msg, string, MAX_STRING_CHARS );
	common->Printf( "%s\n", string );
	guiNetMenu->SetStateString( "status", string );
	if ( opcode == SERVER_PRINT_GAMEDENY ) {
		if ( game_opcode == ALLOW_BADPASS ) {
			retpass = session->MessageBox( MSG_PROMPT, common->Translate ( "#str_04321" ), string, true, "passprompt_ok" );
			ClearPendingPackets();
			guiNetMenu->SetStateString( "status",  common->Translate ( "#str_04322" ));
			if ( retpass ) {
				// #790
				cvarSystem->SetCVarString( "password", "" );
				cvarSystem->SetCVarString( "password", retpass );			
			} else {
				cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
			}
		} else if ( game_opcode == ALLOW_NO ) {
			session->MessageBox( MSG_OK, string, common->Translate ( "#str_04323" ), true );
			ClearPendingPackets();
			cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		}
		// ALLOW_NOTYET just keeps running as usual. The GUI has an abort button
	} else if ( opcode == SERVER_PRINT_BADCHALLENGE && clientState >= CS_CONNECTING ) {
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "reconnect" );
	}
}

/*
==================
idAsyncClient::ProcessServersListMessage
==================
*/
void idAsyncClient::ProcessServersListMessage( const netadr_t from, const idBitMsg &msg ) {
	if ( !Sys_CompareNetAdrBase( idAsyncNetwork::GetMasterAddress(), from ) ) {
		common->DPrintf( "received a server list from %s - not a valid master\n", Sys_NetAdrToString( from ) );
		return;
	}
	while ( msg.GetRemaingData() ) {
		int a,b,c,d;
		a = msg.ReadByte(); b = msg.ReadByte(); c = msg.ReadByte(); d = msg.ReadByte();
		serverList.AddServer( serverList.Num(), va( "%i.%i.%i.%i:%i", a, b, c, d, msg.ReadShort() ) );
	}
}

/*
==================
idAsyncClient::ProcessAuthKeyMessage
==================
*/
/*void idAsyncClient::ProcessAuthKeyMessage( const netadr_t from, const idBitMsg &msg ) {
	authKeyMsg_t		authMsg;
	char				read_string[ MAX_STRING_CHARS ];
	const char			*retkey;
	authBadKeyStatus_t	authBadStatus;
	int					key_index;
	bool				valid[ 2 ];
	idStr				auth_msg;

	if ( clientState != CS_CONNECTING && !session->WaitingForGameAuth() ) {
		common->Printf( "clientState != CS_CONNECTING, not waiting for game auth, authKey ignored\n" );
		return;
	}

	authMsg = (authKeyMsg_t)msg.ReadByte();
	if ( authMsg == AUTHKEY_BADKEY ) {
		valid[ 0 ] = valid[ 1 ] = true;
		key_index = 0;
		authBadStatus = (authBadKeyStatus_t)msg.ReadByte();
		switch ( authBadStatus ) {
		case AUTHKEY_BAD_INVALID:
			valid[ 0 ] = ( msg.ReadByte() == 1 );
			valid[ 1 ] = ( msg.ReadByte() == 1 );
			idAsyncNetwork::BuildInvalidKeyMsg( auth_msg, valid );
			break;
		case AUTHKEY_BAD_BANNED:
			key_index = msg.ReadByte();
			auth_msg = common->Translate( va( "#str_0719%1d", 6 + key_index ) );
			auth_msg += "\n";
			auth_msg += common->Translate( "#str_04304" );
			valid[ key_index ] = false;
			break;
		case AUTHKEY_BAD_INUSE:
			key_index = msg.ReadByte();
			auth_msg = common->Translate( va( "#str_0719%1d", 8 + key_index ) );
			auth_msg += "\n";
			auth_msg += common->Translate( "#str_04304" );
			valid[ key_index ] = false;
			break;
		case AUTHKEY_BAD_MSG:
			// a general message explaining why this key is denied
			// no specific use for this atm. let's not clear the keys either
			msg.ReadString( read_string, MAX_STRING_CHARS );
			auth_msg = read_string;
			break;
		}
		common->DPrintf( "auth deny: %s\n", auth_msg.c_str() );
		
		// keys to be cleared. applies to both net connect and game auth
		session->ClearCDKey( valid );

		// get rid of the bad key - at least that's gonna annoy people who stole a fake key
		if ( clientState == CS_CONNECTING ) {
			while ( 1 ) {
				// here we use the auth status message
				retkey = session->MessageBox( MSG_CDKEY, auth_msg, common->Translate( "#str_04325" ), true );
				if ( retkey ) {
					if ( session->CheckKey( retkey, true, valid ) ) {
						cmdSystem->BufferCommandText( CMD_EXEC_NOW, "reconnect" );
					} else {
						// build a more precise message about the offline check failure
						idAsyncNetwork::BuildInvalidKeyMsg( auth_msg, valid );
						session->MessageBox( MSG_OK, auth_msg.c_str(), common->Translate( "#str_04327" ), true );
						continue;
					}
				} else {
					cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
				}
				break;
			}
		} else {
			// forward the auth status information to the session code
			session->CDKeysAuthReply( false, auth_msg );
		}
	} else {
		msg.ReadString( read_string, MAX_STRING_CHARS );
		cvarSystem->SetCVarString( "com_guid", read_string );
		common->Printf( "guid set to %s\n", read_string );
		session->CDKeysAuthReply( true, NULL );
	}
}*/

/*
==================
idAsyncClient::ProcessVersionMessage
==================
*/
void idAsyncClient::ProcessVersionMessage( const netadr_t from, const idBitMsg &msg ) {
	char string[ MAX_STRING_CHARS ];

	if ( updateState != UPDATE_SENT ) {
		common->Printf( "ProcessVersionMessage: version reply, != UPDATE_SENT\n" );
		return;
	}

	common->Printf( "A new version is available\n" );
	msg.ReadString( string, MAX_STRING_CHARS );
	updateMSG = string;
	updateDirectDownload = ( msg.ReadByte() != 0 );
	msg.ReadString( string, MAX_STRING_CHARS );
	updateURL = string;
	updateMime = (dlMime_t)msg.ReadByte();
	msg.ReadString( string, MAX_STRING_CHARS );
	updateFallback = string;
	updateState = UPDATE_READY;
}

/*
==================
idAsyncClient::ConnectionlessMessage
==================
*/
void idAsyncClient::ConnectionlessMessage( const netadr_t from, const idBitMsg &msg ) {
	char string[MAX_STRING_CHARS*2];  // M. Quinn - Even Balance - PB packets can go beyond 1024

	msg.ReadString( string, sizeof( string ) );

	// info response from a server, are accepted from any source
	if ( idStr::Icmp( string, "infoResponse" ) == 0 ) {
		ProcessInfoResponseMessage( from, msg );
		return;
	}

	// from master server:
	if ( Sys_CompareNetAdrBase( from, idAsyncNetwork::GetMasterAddress( ) ) ) {
		// server list
		if ( idStr::Icmp( string, "servers" ) == 0 ) {
			ProcessServersListMessage( from, msg );
			return;
		}
		
		/*
		if ( idStr::Icmp( string, "authKey" ) == 0 ) {
			ProcessAuthKeyMessage( from, msg );
			return;
		}
		*/

		if ( idStr::Icmp( string, "newVersion" ) == 0 ) {
			ProcessVersionMessage( from, msg );
			return;
		}
	}

	// ignore if not from the current/last server
	if ( !Sys_CompareNetAdrBase( from, serverAddress ) && ( lastRconTime + 10000 < realTime || !Sys_CompareNetAdrBase( from, lastRconAddress ) ) ) {
		common->DPrintf( "got message '%s' from bad source: %s\n", string, Sys_NetAdrToString( from ) );
		return;
	}

	// challenge response from the server we are connecting to
	if ( idStr::Icmp( string, "challengeResponse" ) == 0 ) {
		ProcessChallengeResponseMessage( from, msg );
		return;
	}

	// connect response from the server we are connecting to
	if ( idStr::Icmp( string, "connectResponse" ) == 0 ) {
		ProcessConnectResponseMessage( from, msg );
		return;
	}

	// a disconnect message from the server, which will happen if the server
	// dropped the connection but is still getting packets from this client
	if ( idStr::Icmp( string, "disconnect" ) == 0 ) {
		ProcessDisconnectMessage( from, msg );
		return;
	}

	// print request from server
	if ( idStr::Icmp( string, "print" ) == 0 ) {
		ProcessPrintMessage( from, msg );
		return;
	}

	if ( idStr::Icmp( string, "downloadInfo" ) == 0 ) {
		ProcessDownloadInfoMessage( from, msg );
	}

	if ( idStr::Icmp( string, "authrequired" ) == 0 ) {
		// server telling us that he's expecting an auth mode connect, just in case we're trying to connect in LAN mode
		if ( idAsyncNetwork::LANServer.GetBool() ) {
			common->Warning( "server %s requests master authorization for this client. Turning off LAN mode", Sys_NetAdrToString( from ) );
			idAsyncNetwork::LANServer.SetBool( false );
		}
	}

	common->DPrintf( "ignored message from %s: %s\n", Sys_NetAdrToString( from ), string );
}

/*
=================
idAsyncClient::ProcessMessage
=================
*/
void idAsyncClient::ProcessMessage( const netadr_t from, idBitMsg &msg ) {
	int id;

	id = msg.ReadShort();

	// check for a connectionless packet
	if ( id == CONNECTIONLESS_MESSAGE_ID ) {
		ConnectionlessMessage( from, msg );
		return;
	}

	if ( clientState < CS_CONNECTED ) {
		return;		// can't be a valid sequenced packet
	}

	if ( msg.GetRemaingData() < 4 ) {
		common->DPrintf( "%s: tiny packet\n", Sys_NetAdrToString( from ) );
		return;
	}

	// is this a packet from the server
	if ( !Sys_CompareNetAdrBase( from, channel.GetRemoteAddress() ) || id != serverId ) {
		common->DPrintf( "%s: sequenced server packet without connection\n", Sys_NetAdrToString( from ) );
		return;
	}

	if ( !channel.Process( from, clientTime, msg, serverMessageSequence ) ) {
		return;		// out of order, duplicated, fragment, etc.
	}

	lastPacketTime = clientTime;
	ProcessReliableServerMessages();
	ProcessUnreliableServerMessage( msg );
}

/*
==================
idAsyncClient::SetupConnection
==================
*/
void idAsyncClient::SetupConnection( void ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( clientTime - lastConnectTime < SETUP_CONNECTION_RESEND_TIME ) {
		return;
	}

	if ( clientState == CS_CHALLENGING ) {
		common->Printf( "sending challenge to %s\n", Sys_NetAdrToString( serverAddress ) );
		msg.Init( msgBuf, sizeof( msgBuf ) );
		msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
		msg.WriteString( "challenge" );
		msg.WriteInt( clientId );
		clientPort.SendPacket( serverAddress, msg.GetData(), msg.GetSize() );
	} else if ( clientState == CS_CONNECTING ) {
		common->Printf( "sending connect to %s with challenge 0x%x\n", Sys_NetAdrToString( serverAddress ), serverChallenge );
		msg.Init( msgBuf, sizeof( msgBuf ) );
		msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
		msg.WriteString( "connect" );
		msg.WriteInt( ASYNC_PROTOCOL_VERSION );
		msg.WriteShort( BUILD_OS_ID ); // 0 to fake win32
		msg.WriteInt( clientDataChecksum );
		msg.WriteInt( serverChallenge );
		msg.WriteShort( clientId );
		msg.WriteInt( cvarSystem->GetCVarInteger( "net_clientMaxRate" ) );
		msg.WriteString( cvarSystem->GetCVarString( "com_guid" ) );
		msg.WriteString( cvarSystem->GetCVarString( "password" ), -1, false );
		// do not make the protocol depend on PB
		msg.WriteShort( 0 );
		clientPort.SendPacket( serverAddress, msg.GetData(), msg.GetSize() );
		
		if ( idAsyncNetwork::LANServer.GetBool() ) {
			common->Printf( "net_LANServer is set, connecting in LAN mode\n" );
		}/* else {
			// emit a cd key authorization request
			// modified at protocol 1.37 for XP key addition
			msg.BeginWriting();
			msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
			msg.WriteString( "clAuth" );
			msg.WriteInt( ASYNC_PROTOCOL_VERSION );
			msg.WriteNetadr( serverAddress );
			// if we don't have a com_guid, this will request a direct reply from auth with it
			msg.WriteByte( cvarSystem->GetCVarString( "com_guid" )[0] ? 1 : 0 );
			// send the main key, and flag an extra byte to add XP key
			msg.WriteString( session->GetCDKey( false ) );
			const char *xpkey = session->GetCDKey( true );
			msg.WriteByte( xpkey ? 1 : 0 );
			if ( xpkey ) {
				msg.WriteString( xpkey );
			}
			clientPort.SendPacket( idAsyncNetwork::GetMasterAddress(), msg.GetData(), msg.GetSize() );
		}*/
	} else {
		return;
	}

	lastConnectTime = clientTime;
}

/*
==================
idAsyncClient::SendReliableGameMessage
==================
*/
void idAsyncClient::SendReliableGameMessage( const idBitMsg &msg ) {
	idBitMsg	outMsg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( clientState < CS_INGAME ) {
		return;
	}

	outMsg.Init( msgBuf, sizeof( msgBuf ) );
	outMsg.WriteByte( CLIENT_RELIABLE_MESSAGE_GAME );
	outMsg.WriteData( msg.GetData(), msg.GetSize() );
	if ( !channel.SendReliableMessage( outMsg ) ) {
		common->Error( "client->server reliable messages overflow\n" );
	}
}

/*
==================
idAsyncClient::Idle
==================
*/
void idAsyncClient::Idle( void ) {
	// also need to read mouse for the connecting guis
	usercmdGen->GetDirectUsercmd();

	SendEmptyToServer();
}

/*
==================
idAsyncClient::UpdateTime
==================
*/
int idAsyncClient::UpdateTime( int clamp ) {
	int time, msec;

	time = Sys_Milliseconds();
	msec = idMath::ClampInt( 0, clamp, time - realTime );
	realTime = time;
	clientTime += msec;
	return msec;
}

/*
==================
idAsyncClient::RunFrame
==================
*/
void idAsyncClient::RunFrame( void ) {
	int			msec, size;
	bool		newPacket;
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];
	netadr_t	from;

	msec = UpdateTime( 100 );

	if ( !clientPort.GetPort() ) {
		return;
	}

	// handle ongoing pk4 downloads and patch downloads
	HandleDownloads();

	gameTimeResidual += msec;

	// spin in place processing incoming packets until enough time lapsed to run a new game frame
	do {

		do {

			// blocking read with game time residual timeout
			newPacket = clientPort.GetPacketBlocking( from, msgBuf, size, sizeof( msgBuf ), USERCMD_MSEC - ( gameTimeResidual + clientPredictTime ) - 1 );
			if ( newPacket ) {
				msg.Init( msgBuf, sizeof( msgBuf ) );
				msg.SetSize( size );
				msg.BeginReading();
				ProcessMessage( from, msg );
			}

			msec = UpdateTime( 100 );
			gameTimeResidual += msec;

		} while( newPacket );

	} while( gameTimeResidual + clientPredictTime < USERCMD_MSEC );

	// update server list
	serverList.RunFrame();

	if ( clientState == CS_DISCONNECTED ) {
		usercmdGen->GetDirectUsercmd();
		gameTimeResidual = USERCMD_MSEC - 1;
		clientPredictTime = 0;
		return;
	}

	// if not connected setup a connection
	if ( clientState < CS_CONNECTED ) {
		// also need to read mouse for the connecting guis
		usercmdGen->GetDirectUsercmd();
		SetupConnection();
		gameTimeResidual = USERCMD_MSEC - 1;
		clientPredictTime = 0;
		return;
	}

	if ( CheckTimeout() ) {
		return;
	}

	// if not yet in the game send empty messages to keep data flowing through the channel
	if ( clientState < CS_INGAME ) {
		Idle();
		gameTimeResidual = 0;
		return;
	}

	// check for user info changes
	if ( cvarSystem->GetModifiedFlags() & CVAR_USERINFO ) {
		game->ThrottleUserInfo( );
		SendUserInfoToServer( );
		game->SetUserInfo( clientNum, sessLocal.mapSpawnData.userInfo[ clientNum ], true, false );
		cvarSystem->ClearModifiedFlags( CVAR_USERINFO );
	}

	if ( gameTimeResidual + clientPredictTime >= USERCMD_MSEC ) {
		lastFrameDelta = 0;
	}

	// generate user commands for the predicted time
	while ( gameTimeResidual + clientPredictTime >= USERCMD_MSEC ) {

		// send the user commands of this client to the server
		SendUsercmdsToServer();

		// update time
		gameFrame++;
		gameTime += USERCMD_MSEC;
		gameTimeResidual -= USERCMD_MSEC;

		// run from the snapshot up to the local game frame
		while ( snapshotGameFrame < gameFrame ) {

			lastFrameDelta++;

			// duplicate usercmds for clients if no new ones are available
			DuplicateUsercmds( snapshotGameFrame, snapshotGameTime );

			// indicate the last prediction frame before a render
			bool lastPredictFrame = ( snapshotGameFrame + 1 >= gameFrame && gameTimeResidual + clientPredictTime < USERCMD_MSEC );

			// run client prediction
			gameReturn_t ret = game->ClientPrediction( clientNum, userCmds[ snapshotGameFrame & ( MAX_USERCMD_BACKUP - 1 ) ], lastPredictFrame );

			idAsyncNetwork::ExecuteSessionCommand( ret.sessionCommand );

			snapshotGameFrame++;
			snapshotGameTime += USERCMD_MSEC;
		}
	}
}

/*
==================
idAsyncClient::PacifierUpdate
==================
*/
void idAsyncClient::PacifierUpdate( void ) {
	if ( !IsActive() ) {
		return;
	}
	realTime = Sys_Milliseconds();
	SendEmptyToServer( false, true );
}

/*
==================
idAsyncClient::SendVersionCheck
==================
*/
void idAsyncClient::SendVersionCheck( bool fromMenu ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	if ( updateState != UPDATE_NONE && !fromMenu ) {
		common->DPrintf( "up-to-date check was already performed\n" );
		return;
	}

	InitPort();
	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "versionCheck" );
	msg.WriteLong( ASYNC_PROTOCOL_VERSION );
	msg.WriteShort( BUILD_OS_ID );
	msg.WriteString( cvarSystem->GetCVarString( "si_version" ) );
	msg.WriteString( cvarSystem->GetCVarString( "com_guid" ) );
	clientPort.SendPacket( idAsyncNetwork::GetMasterAddress(), msg.GetData(), msg.GetSize() );

	common->DPrintf( "sent a version check request\n" );

	updateState = UPDATE_SENT;
	updateSentTime = clientTime;
	showUpdateMessage = fromMenu;
}

/*
==================
idAsyncClient::SendVersionDLUpdate

sending those packets is not strictly necessary. just a way to tell the update server
about what is going on. allows the update server to have a more precise view of the overall
network load for the updates
==================
*/
void idAsyncClient::SendVersionDLUpdate( int state ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "versionDL" );
	msg.WriteLong( ASYNC_PROTOCOL_VERSION );
	msg.WriteShort( state );
	clientPort.SendPacket( idAsyncNetwork::GetMasterAddress(), msg.GetData(), msg.GetSize() );
}

/*
==================
idAsyncClient::HandleDownloads
==================
*/
void idAsyncClient::HandleDownloads( void ) {

	if ( updateState == UPDATE_SENT && clientTime > updateSentTime + 2000 ) {
		// timing out on no reply
		updateState = UPDATE_DONE;
		if ( showUpdateMessage ) {
			session->MessageBox( MSG_OK, common->Translate ( "#str_04839" ), common->Translate ( "#str_04837" ), true );
			showUpdateMessage = false;
		}
		common->DPrintf( "No update available\n" );
	} else if ( backgroundDownload.completed ) {
		// only enter these if the download slot is free
		if ( updateState == UPDATE_READY ) {
			// 
			if ( session->MessageBox( MSG_YESNO, updateMSG, common->Translate ( "#str_04330" ), true, "yes" )[0] ) {
				if ( !updateDirectDownload ) {
					sys->OpenURL( updateURL, true );
					updateState = UPDATE_DONE;
				} else {

					// we're just creating the file at toplevel inside fs_savepath
					updateURL.ExtractFileName( updateFile );
					idFile_Permanent *f = static_cast< idFile_Permanent *>( fileSystem->OpenFileWrite( updateFile ) );
					dltotal = 0;
					dlnow = 0;

					backgroundDownload.completed = false;
					backgroundDownload.opcode = DLTYPE_URL;
					backgroundDownload.f = f;
					backgroundDownload.url.status = DL_WAIT;
					backgroundDownload.url.dlnow = 0;
					backgroundDownload.url.dltotal = 0;
					backgroundDownload.url.url = updateURL;
					fileSystem->BackgroundDownload( &backgroundDownload );

					updateState = UPDATE_DLING;
					SendVersionDLUpdate( 0 );
					session->DownloadProgressBox( &backgroundDownload, va( "Downloading %s\n", updateFile.c_str() ) );
					updateState = UPDATE_DONE;
					if ( backgroundDownload.url.status == DL_DONE ) {				
						SendVersionDLUpdate( 1 );
						idStr fullPath = f->GetFullPath();
						fileSystem->CloseFile( f );
						if ( session->MessageBox( MSG_YESNO, common->Translate ( "#str_04331" ), common->Translate ( "#str_04332" ), true, "yes" )[0] ) {
							if ( updateMime == FILE_EXEC ) {
								sys->StartProcess( fullPath, true );
							} else {
								sys->OpenURL( va( "file://%s", fullPath.c_str() ), true );
							}
						} else {
							session->MessageBox( MSG_OK, va( common->Translate ( "#str_04333" ), fullPath.c_str() ), common->Translate ( "#str_04334" ), true );
						}
					} else {
						if ( backgroundDownload.url.dlerror[ 0 ] ) {
							common->Warning( "update download failed. curl error: %s", backgroundDownload.url.dlerror );
						}
						SendVersionDLUpdate( 2 );
						idStr name = f->GetName();
						fileSystem->CloseFile( f );
						fileSystem->RemoveFile( name );
						session->MessageBox( MSG_OK, common->Translate ( "#str_04335" ), common->Translate ( "#str_04336" ), true );
						if ( updateFallback.Length() ) {
							sys->OpenURL( updateFallback.c_str(), true );
						} else {
							common->Printf( "no fallback URL\n" );
						}
					}
				}
			} else {
				updateState = UPDATE_DONE;
			}
		} else if ( dlList.Num() ) {

			int numPaks = dlList.Num();
			int pakCount = 1;
			int progress_start, progress_end;
			currentDlSize = 0;

			do {

				if ( dlList[ 0 ].url[ 0 ] == '\0' ) {
					// ignore empty files
					dlList.RemoveIndex( 0 );
					continue;
				}
				common->Printf( "start download for %s\n", dlList[ 0 ].url.c_str() );

				idFile_Permanent *f = static_cast< idFile_Permanent *>( fileSystem->MakeTemporaryFile( ) );
				if ( !f ) {
					common->Warning( "could not create temporary file" );
					dlList.Clear();
					return;
				}

				backgroundDownload.completed = false;
				backgroundDownload.opcode = DLTYPE_URL;
				backgroundDownload.f = f;
				backgroundDownload.url.status = DL_WAIT;
				backgroundDownload.url.dlnow = 0;
				backgroundDownload.url.dltotal = dlList[ 0 ].size;
				backgroundDownload.url.url = dlList[ 0 ].url;
				fileSystem->BackgroundDownload( &backgroundDownload );
				idStr dltitle;
				// "Downloading %s"
				sprintf( dltitle, common->Translate( "#str_07213" ), dlList[ 0 ].filename.c_str() );
				if ( numPaks > 1 ) {
					dltitle += va( " (%d/%d)", pakCount, numPaks );
				}
				if ( totalDlSize ) {
					progress_start = (int)( (float)currentDlSize * 100.0f / (float)totalDlSize );
					progress_end = (int)( (float)( currentDlSize + dlList[ 0 ].size ) * 100.0f / (float)totalDlSize );
				} else {
					progress_start = 0;
					progress_end = 100;
				}
				session->DownloadProgressBox( &backgroundDownload, dltitle, progress_start, progress_end );
				if ( backgroundDownload.url.status == DL_DONE ) {				
					idFile		*saveas;
					const int	CHUNK_SIZE = 1024 * 1024;
					byte		*buf;
					int			remainlen;
					int			readlen;
					int			retlen;
					int			checksum;

					common->Printf( "file downloaded\n" );
					idStr finalPath = cvarSystem->GetCVarString( "fs_savepath" );
					finalPath.AppendPath( dlList[ 0 ].filename );
					fileSystem->CreateOSPath( finalPath );
					// do the final copy ourselves so we do by small chunks in case the file is big
					saveas = fileSystem->OpenExplicitFileWrite( finalPath );
					buf = (byte*)Mem_Alloc( CHUNK_SIZE );
					f->Seek( 0, FS_SEEK_END );
					remainlen = f->Tell();
					f->Seek( 0, FS_SEEK_SET );
					while ( remainlen ) {
						readlen = Min( remainlen, CHUNK_SIZE );
						retlen = f->Read( buf, readlen );
						if ( retlen != readlen ) {
							common->FatalError( "short read %d of %d in idFileSystem::HandleDownload", retlen, readlen );
						}
						retlen = saveas->Write( buf, readlen );
						if ( retlen != readlen ) {
							common->FatalError( "short write %d of %d in idFileSystem::HandleDownload", retlen, readlen );
						}
						remainlen -= readlen;
					}
					fileSystem->CloseFile( f );
					fileSystem->CloseFile( saveas );
					common->Printf( "saved as %s\n", finalPath.c_str() );
					Mem_Free( buf );
					
					// add that file to our paks list
					checksum = fileSystem->AddZipFile( dlList[ 0 ].filename );

					// verify the checksum to be what the server says
					if ( !checksum || checksum != dlList[ 0 ].checksum ) {
						// "pak is corrupted ( checksum 0x%x, expected 0x%x )"
						session->MessageBox( MSG_OK, va( common->Translate( "#str_07214" ) , checksum, dlList[0].checksum ), "Download failed", true );
						fileSystem->RemoveFile( dlList[ 0 ].filename );
						dlList.Clear();
						return;
					}

					currentDlSize += dlList[ 0 ].size;
					
				} else {
					common->Warning( "download failed: %s", dlList[ 0 ].url.c_str() );
					if ( backgroundDownload.url.dlerror[ 0 ] ) {
						common->Warning( "curl error: %s", backgroundDownload.url.dlerror );
					}
					// "The download failed or was cancelled"
					// "Download failed"
					session->MessageBox( MSG_OK, common->Translate( "#str_07215" ), common->Translate( "#str_07216" ), true );
					dlList.Clear();
					return;
				}

				pakCount++;
				dlList.RemoveIndex( 0 );			
			} while ( dlList.Num() );
			
			// all downloads successful - do the dew
			cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "reconnect\n" );
		}
	}
}

/*
===============
idAsyncClient::SendAuthCheck
===============
*/
/*bool idAsyncClient::SendAuthCheck( const char *cdkey, const char *xpkey ) {
	idBitMsg	msg;
	byte		msgBuf[MAX_MESSAGE_SIZE];

	msg.Init( msgBuf, sizeof( msgBuf ) );
	msg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
	msg.WriteString( "gameAuth" );
	msg.WriteLong( ASYNC_PROTOCOL_VERSION );
	msg.WriteByte( cdkey ? 1 : 0 );
	msg.WriteString( cdkey ? cdkey : "" );
	msg.WriteByte( xpkey ? 1 : 0 );
	msg.WriteString( xpkey ? xpkey : "" );
	InitPort();
	clientPort.SendPacket( idAsyncNetwork::GetMasterAddress(), msg.GetData(), msg.GetSize() );
	return true;
}*/

/*
===============
idAsyncClient::CheckTimeout
===============
*/
bool idAsyncClient::CheckTimeout( void ) {
	if ( lastPacketTime > 0 && ( lastPacketTime + idAsyncNetwork::clientServerTimeout.GetInteger()*1000 < clientTime ) ) {
		session->StopBox();
		session->MessageBox( MSG_OK, common->Translate ( "#str_04328" ), common->Translate ( "#str_04329" ), true );
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		return true;
	}
	return false;
}

/*
===============
idAsyncClient::ProcessDownloadInfoMessage
===============
*/
void idAsyncClient::ProcessDownloadInfoMessage( const netadr_t from, const idBitMsg &msg ) {
	char			buf[ MAX_STRING_CHARS ];
	int				srvDlRequest = msg.ReadLong();
	int				infoType = msg.ReadByte();
	int				pakDl;
	int				pakIndex;
	
	pakDlEntry_t	entry;
	bool			gotAllFiles = true;
	idStr			sizeStr;
	bool			gotGame = false;

	if ( dlRequest == -1 || srvDlRequest != dlRequest ) {
		common->Warning( "bad download id from server, ignored" );
		return;
	}
	// mark the dlRequest as dead now whatever how we process it
	dlRequest = -1;

	if ( infoType == SERVER_DL_REDIRECT ) {
		msg.ReadString( buf, MAX_STRING_CHARS );
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		// "You are missing required pak files to connect to this server.\nThe server gave a web page though:\n%s\nDo you want to go there now?"
		// "Missing required files"
		if ( session->MessageBox( MSG_YESNO, va( common->Translate( "#str_07217" ), buf ),
								  common->Translate( "#str_07218" ), true, "yes" )[ 0 ] ) {
			sys->OpenURL( buf, true );
		}
	} else if ( infoType == SERVER_DL_LIST ) {
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		if ( dlList.Num() ) {
			common->Warning( "tried to process a download list while already busy downloading things" );
			return;
		}
		// read the URLs, check against what we requested, prompt for download
		pakIndex = -1;
		totalDlSize = 0;
		do {
			pakIndex++;
			pakDl = msg.ReadByte();
			if ( pakDl == SERVER_PAK_YES ) {
				if ( pakIndex == 0 ) {
					gotGame = true;
				}
				msg.ReadString( buf, MAX_STRING_CHARS );
				entry.filename = buf;
				msg.ReadString( buf, MAX_STRING_CHARS );
				entry.url = buf;
				entry.size = msg.ReadLong();
				// checksums are not transmitted, we read them from the dl request we sent
				entry.checksum = dlChecksums[ pakIndex ];
				totalDlSize += entry.size;
				dlList.Append( entry );
				common->Printf( "download %s from %s ( 0x%x )\n", entry.filename.c_str(), entry.url.c_str(), entry.checksum );
			} else if ( pakDl == SERVER_PAK_NO ) {
				msg.ReadString( buf, MAX_STRING_CHARS );
				entry.filename = buf;
				entry.url = "";
				entry.size = 0;
				entry.checksum = 0;
				dlList.Append( entry );
				// first pak is game pak, only fail it if we actually requested it
				if ( pakIndex != 0 || dlChecksums[ 0 ] != 0 ) {
					common->Printf( "no download offered for %s ( 0x%x )\n", entry.filename.c_str(), dlChecksums[ pakIndex ] );
					gotAllFiles = false;
				}
			} else {
				assert( pakDl == SERVER_PAK_END );
			}			
		} while ( pakDl != SERVER_PAK_END );
		if ( dlList.Num() < dlCount ) {
			common->Printf( "%d files were ignored by the server\n", dlCount - dlList.Num() );
			gotAllFiles = false;
		}
		sizeStr.BestUnit( "%.2f", totalDlSize, MEASURE_SIZE );
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		if ( totalDlSize == 0 ) {
			// was no downloadable stuff for us
			// "Can't connect to the pure server: no downloads offered"
			// "Missing required files"
			dlList.Clear();
			session->MessageBox( MSG_OK, common->Translate( "#str_07219" ), common->Translate( "#str_07218" ), true );
			return;
		}
		bool asked = false;
		if ( gotGame ) {
			asked = true;
			// "You need to download game code to connect to this server. Are you sure? You should only answer yes if you trust the server administrators."
			// "Missing game binaries"
			if ( !session->MessageBox( MSG_YESNO, common->Translate( "#str_07220" ), common->Translate( "#str_07221" ), true, "yes" )[ 0 ] ) {
				dlList.Clear();
				return;
			}
		}
		if ( !gotAllFiles ) {
			asked = true;
			// "The server only offers to download some of the files required to connect ( %s ). Download anyway?"
			// "Missing required files"
			if ( !session->MessageBox( MSG_YESNO, va( common->Translate( "#str_07222" ), sizeStr.c_str() ),
									   common->Translate( "#str_07218" ), true, "yes" )[ 0 ] ) {
				dlList.Clear();
				return;
			}
		}
		if ( !asked && idAsyncNetwork::clientDownload.GetInteger() == 1 ) {
			// "You need to download some files to connect to this server ( %s ), proceed?"
			// "Missing required files"
			if ( !session->MessageBox( MSG_YESNO, va( common->Translate( "#str_07224" ), sizeStr.c_str() ),
									   common->Translate( "#str_07218" ), true, "yes" )[ 0 ] ) {
				dlList.Clear();
				return;
			}
		}
	} else {
		cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
		// "You are missing some files to connect to this server, and the server doesn't provide downloads."
		// "Missing required files"
		session->MessageBox( MSG_OK, common->Translate( "#str_07223" ), common->Translate( "#str_07218" ), true );
	}
}

/*
===============
idAsyncClient::GetDownloadRequest
===============
*/
int idAsyncClient::GetDownloadRequest( const int checksums[ MAX_PURE_PAKS ], int count, int gamePakChecksum ) {
	assert( !checksums[ count ] ); // 0-terminated
	if ( memcmp( dlChecksums + 1, checksums, sizeof( int ) * count ) || gamePakChecksum != dlChecksums[ 0 ] ) {
		idRandom newreq;

		dlChecksums[ 0 ] = gamePakChecksum;
		memcpy( dlChecksums + 1, checksums, sizeof( int ) * MAX_PURE_PAKS );

		newreq.SetSeed( Sys_Milliseconds() );
		dlRequest = newreq.RandomInt();
		dlCount = count + ( gamePakChecksum ? 1 : 0 );
		return dlRequest;
	}
	// this is the same dlRequest, we haven't heard from the server. keep the same id
	return dlRequest;
}