mirror of
https://github.com/blendogames/quadrilateralcowboy.git
synced 2024-11-21 19:51:04 +00:00
2825 lines
79 KiB
C++
2825 lines
79 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 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 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 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 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 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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "AsyncNetwork.h"
|
|
|
|
#include "../Session_local.h"
|
|
|
|
const int MIN_RECONNECT_TIME = 2000;
|
|
const int EMPTY_RESEND_TIME = 500;
|
|
const int PING_RESEND_TIME = 500;
|
|
const int NOINPUT_IDLE_TIME = 30000;
|
|
|
|
const int HEARTBEAT_MSEC = 5*60*1000;
|
|
|
|
// must be kept in sync with authReplyMsg_t
|
|
const char* authReplyMsg[] = {
|
|
// "Waiting for authorization",
|
|
"#str_07204",
|
|
// "Client unknown to auth",
|
|
"#str_07205",
|
|
// "Access denied - CD Key in use",
|
|
"#str_07206",
|
|
// "Auth custom message", // placeholder - we propagate a message from the master
|
|
"#str_07207",
|
|
// "Authorize Server - Waiting for client"
|
|
"#str_07208"
|
|
};
|
|
|
|
const char* authReplyStr[] = {
|
|
"AUTH_NONE",
|
|
"AUTH_OK",
|
|
"AUTH_WAIT",
|
|
"AUTH_DENY"
|
|
};
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::idAsyncServer
|
|
==================
|
|
*/
|
|
idAsyncServer::idAsyncServer( void ) {
|
|
int i;
|
|
|
|
active = false;
|
|
realTime = 0;
|
|
serverTime = 0;
|
|
serverId = 0;
|
|
serverDataChecksum = 0;
|
|
localClientNum = -1;
|
|
gameInitId = 0;
|
|
gameFrame = 0;
|
|
gameTime = 0;
|
|
gameTimeResidual = 0;
|
|
memset( challenges, 0, sizeof( challenges ) );
|
|
memset( userCmds, 0, sizeof( userCmds ) );
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
ClearClient( i );
|
|
}
|
|
serverReloadingEngine = false;
|
|
nextHeartbeatTime = 0;
|
|
nextAsyncStatsTime = 0;
|
|
noRconOutput = true;
|
|
lastAuthTime = 0;
|
|
|
|
memset( stats_outrate, 0, sizeof( stats_outrate ) );
|
|
stats_current = 0;
|
|
stats_average_sum = 0;
|
|
stats_max = 0;
|
|
stats_max_index = 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::InitPort
|
|
==================
|
|
*/
|
|
bool idAsyncServer::InitPort( void ) {
|
|
int lastPort;
|
|
|
|
// if this is the first time we have spawned a server, open the UDP port
|
|
if ( !serverPort.GetPort() ) {
|
|
if ( cvarSystem->GetCVarInteger( "net_port" ) != 0 ) {
|
|
if ( !serverPort.InitForPort( cvarSystem->GetCVarInteger( "net_port" ) ) ) {
|
|
common->Printf( "Unable to open server on port %d (net_port)\n", cvarSystem->GetCVarInteger( "net_port" ) );
|
|
return false;
|
|
}
|
|
} else {
|
|
// scan for multiple ports, in case other servers are running on this IP already
|
|
for ( lastPort = 0; lastPort < NUM_SERVER_PORTS; lastPort++ ) {
|
|
if ( serverPort.InitForPort( PORT_SERVER + lastPort ) ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( lastPort >= NUM_SERVER_PORTS ) {
|
|
common->Printf( "Unable to open server network port.\n" );
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ClosePort
|
|
==================
|
|
*/
|
|
void idAsyncServer::ClosePort( void ) {
|
|
int i;
|
|
|
|
serverPort.Close();
|
|
for ( i = 0; i < MAX_CHALLENGES; i++ ) {
|
|
challenges[ i ].authReplyPrint.Clear();
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::Spawn
|
|
==================
|
|
*/
|
|
void idAsyncServer::Spawn( void ) {
|
|
int i, size;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
netadr_t from;
|
|
|
|
// shutdown any current game
|
|
session->Stop();
|
|
|
|
if ( active ) {
|
|
return;
|
|
}
|
|
|
|
if ( !InitPort() ) {
|
|
return;
|
|
}
|
|
|
|
// trash any currently pending packets
|
|
while( serverPort.GetPacket( from, msgBuf, size, sizeof( msgBuf ) ) ) {
|
|
}
|
|
|
|
// reset cheats cvars
|
|
if ( !idAsyncNetwork::allowCheats.GetBool() ) {
|
|
cvarSystem->ResetFlaggedVariables( CVAR_CHEAT );
|
|
}
|
|
|
|
memset( challenges, 0, sizeof( challenges ) );
|
|
memset( userCmds, 0, sizeof( userCmds ) );
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
ClearClient( i );
|
|
}
|
|
|
|
common->Printf( "Server spawned on port %i.\n", serverPort.GetPort() );
|
|
|
|
// calculate a checksum on some of the essential data used
|
|
serverDataChecksum = declManager->GetChecksum();
|
|
|
|
// get a pseudo random server id, but don't use the id which is reserved for connectionless packets
|
|
serverId = Sys_Milliseconds() & CONNECTIONLESS_MESSAGE_ID_MASK;
|
|
|
|
active = true;
|
|
|
|
nextHeartbeatTime = 0;
|
|
nextAsyncStatsTime = 0;
|
|
|
|
ExecuteMapChange();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::Kill
|
|
==================
|
|
*/
|
|
void idAsyncServer::Kill( void ) {
|
|
int i, j;
|
|
|
|
if ( !active ) {
|
|
return;
|
|
}
|
|
|
|
// drop all clients
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
DropClient( i, "#str_07135" );
|
|
}
|
|
|
|
// send some empty messages to the zombie clients to make sure they disconnect
|
|
for ( j = 0; j < 4; j++ ) {
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState == SCS_ZOMBIE ) {
|
|
if ( clients[i].channel.UnsentFragmentsLeft() ) {
|
|
clients[i].channel.SendNextFragment( serverPort, serverTime );
|
|
} else {
|
|
SendEmptyToClient( i, true );
|
|
}
|
|
}
|
|
}
|
|
Sys_Sleep( 10 );
|
|
}
|
|
|
|
// reset any pureness
|
|
fileSystem->ClearPureChecksums();
|
|
|
|
active = false;
|
|
|
|
// shutdown any current game
|
|
session->Stop();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ExecuteMapChange
|
|
==================
|
|
*/
|
|
void idAsyncServer::ExecuteMapChange( void ) {
|
|
int i;
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
idStr mapName;
|
|
findFile_t ff;
|
|
bool addonReload = false;
|
|
char bestGameType[ MAX_STRING_CHARS ];
|
|
|
|
assert( active );
|
|
|
|
// reset any pureness
|
|
fileSystem->ClearPureChecksums();
|
|
|
|
// make sure the map/gametype combo is good
|
|
game->GetBestGameType( cvarSystem->GetCVarString("si_map"), cvarSystem->GetCVarString("si_gametype"), bestGameType );
|
|
cvarSystem->SetCVarString("si_gametype", bestGameType );
|
|
|
|
// initialize map settings
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, "rescanSI" );
|
|
|
|
sprintf( mapName, "maps/%s", sessLocal.mapSpawnData.serverInfo.GetString( "si_map" ) );
|
|
mapName.SetFileExtension( ".map" );
|
|
ff = fileSystem->FindFile( mapName, !serverReloadingEngine );
|
|
switch( ff ) {
|
|
case FIND_NO:
|
|
common->Printf( "Can't find map %s\n", mapName.c_str() );
|
|
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "disconnect\n" );
|
|
return;
|
|
case FIND_ADDON:
|
|
// NOTE: we have no problem with addon dependencies here because if the map is in
|
|
// an addon pack that's already on search list, then all it's deps are assumed to be on search as well
|
|
common->Printf( "map %s is in an addon pak - reloading\n", mapName.c_str() );
|
|
addonReload = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// if we are asked to do a full reload, the strategy is completely different
|
|
if ( !serverReloadingEngine && ( addonReload || idAsyncNetwork::serverReloadEngine.GetInteger() != 0 ) ) {
|
|
if ( idAsyncNetwork::serverReloadEngine.GetInteger() != 0 ) {
|
|
common->Printf( "net_serverReloadEngine enabled - doing a full reload\n" );
|
|
}
|
|
// tell the clients to reconnect
|
|
// FIXME: shouldn't they wait for the new pure list, then reload?
|
|
// in a lot of cases this is going to trigger two reloadEngines for the clients
|
|
// one to restart, the other one to set paks right ( with addon for instance )
|
|
// can fix by reconnecting without reloading and waiting for the server to tell..
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[ i ].clientState >= SCS_PUREWAIT && i != localClientNum ) {
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_RELOAD );
|
|
SendReliableMessage( i, msg );
|
|
clients[ i ].clientState = SCS_ZOMBIE; // so we don't bother sending a disconnect
|
|
}
|
|
}
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, "reloadEngine" );
|
|
serverReloadingEngine = true; // don't get caught in endless loop
|
|
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "spawnServer\n" );
|
|
// decrease feature
|
|
if ( idAsyncNetwork::serverReloadEngine.GetInteger() > 0 ) {
|
|
idAsyncNetwork::serverReloadEngine.SetInteger( idAsyncNetwork::serverReloadEngine.GetInteger() - 1 );
|
|
}
|
|
return;
|
|
}
|
|
serverReloadingEngine = false;
|
|
|
|
serverTime = 0;
|
|
|
|
// initialize game id and time
|
|
gameInitId ^= Sys_Milliseconds(); // NOTE: make sure the gameInitId is always a positive number because negative numbers have special meaning
|
|
gameFrame = 0;
|
|
gameTime = 0;
|
|
gameTimeResidual = 0;
|
|
memset( userCmds, 0, sizeof( userCmds ) );
|
|
|
|
if ( idAsyncNetwork::serverDedicated.GetInteger() == 0 ) {
|
|
InitLocalClient( 0 );
|
|
} else {
|
|
localClientNum = -1;
|
|
}
|
|
|
|
// re-initialize all connected clients for the new map
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState >= SCS_PUREWAIT && i != localClientNum ) {
|
|
|
|
InitClient( i, clients[i].clientId, clients[i].clientRate );
|
|
|
|
SendGameInitToClient( i );
|
|
|
|
if ( sessLocal.mapSpawnData.serverInfo.GetBool( "si_pure" ) ) {
|
|
clients[ i ].clientState = SCS_PUREWAIT;
|
|
}
|
|
}
|
|
}
|
|
|
|
// setup the game pak checksums
|
|
// since this is not dependant on si_pure we catch anything bad before loading map
|
|
if ( sessLocal.mapSpawnData.serverInfo.GetInt( "si_pure" ) ) {
|
|
if ( !fileSystem->UpdateGamePakChecksums( ) ) {
|
|
session->MessageBox( MSG_OK, common->GetLanguageDict()->GetString ( "#str_04337" ), common->GetLanguageDict()->GetString ( "#str_04338" ), true );
|
|
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "disconnect\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// load map
|
|
sessLocal.ExecuteMapChange();
|
|
|
|
if ( localClientNum >= 0 ) {
|
|
BeginLocalClient();
|
|
} else {
|
|
game->SetLocalClient( -1 );
|
|
}
|
|
|
|
if ( sessLocal.mapSpawnData.serverInfo.GetInt( "si_pure" ) ) {
|
|
// lock down the pak list
|
|
fileSystem->UpdatePureServerChecksums( );
|
|
// tell the clients so they can work out their pure lists
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[ i ].clientState == SCS_PUREWAIT ) {
|
|
if ( !SendReliablePureToClient( i ) ) {
|
|
clients[ i ].clientState = SCS_CONNECTED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// serverTime gets reset, force a heartbeat so timings restart
|
|
MasterHeartbeat( true );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetPort
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetPort( void ) const {
|
|
return serverPort.GetPort();
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idAsyncServer::GetBoundAdr
|
|
===============
|
|
*/
|
|
netadr_t idAsyncServer::GetBoundAdr( void ) const {
|
|
return serverPort.GetAdr();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetOutgoingRate
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetOutgoingRate( void ) const {
|
|
int i, rate;
|
|
|
|
rate = 0;
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
const serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState >= SCS_CONNECTED ) {
|
|
rate += client.channel.GetOutgoingRate();
|
|
}
|
|
}
|
|
return rate;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetIncomingRate
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetIncomingRate( void ) const {
|
|
int i, rate;
|
|
|
|
rate = 0;
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
const serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState >= SCS_CONNECTED ) {
|
|
rate += client.channel.GetIncomingRate();
|
|
}
|
|
}
|
|
return rate;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::IsClientInGame
|
|
==================
|
|
*/
|
|
bool idAsyncServer::IsClientInGame( int clientNum ) const {
|
|
return ( clients[clientNum].clientState >= SCS_INGAME );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientPing
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetClientPing( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 99999;
|
|
} else {
|
|
return client.clientPing;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientPrediction
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetClientPrediction( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 99999;
|
|
} else {
|
|
return client.clientPrediction;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientTimeSinceLastPacket
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetClientTimeSinceLastPacket( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 99999;
|
|
} else {
|
|
return serverTime - client.lastPacketTime;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientTimeSinceLastInput
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetClientTimeSinceLastInput( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 99999;
|
|
} else {
|
|
return serverTime - client.lastInputTime;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientOutgoingRate
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetClientOutgoingRate( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return -1;
|
|
} else {
|
|
return client.channel.GetOutgoingRate();
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientIncomingRate
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetClientIncomingRate( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return -1;
|
|
} else {
|
|
return client.channel.GetIncomingRate();
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientOutgoingCompression
|
|
==================
|
|
*/
|
|
float idAsyncServer::GetClientOutgoingCompression( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 0.0f;
|
|
} else {
|
|
return client.channel.GetOutgoingCompression();
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientIncomingCompression
|
|
==================
|
|
*/
|
|
float idAsyncServer::GetClientIncomingCompression( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 0.0f;
|
|
} else {
|
|
return client.channel.GetIncomingCompression();
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetClientIncomingPacketLoss
|
|
==================
|
|
*/
|
|
float idAsyncServer::GetClientIncomingPacketLoss( int clientNum ) const {
|
|
const serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return 0.0f;
|
|
} else {
|
|
return client.channel.GetIncomingPacketLoss();
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetNumClients
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetNumClients( void ) const {
|
|
int ret = 0;
|
|
for ( int i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[ i ].clientState >= SCS_CONNECTED ) {
|
|
ret++;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::GetNumIdleClients
|
|
==================
|
|
*/
|
|
int idAsyncServer::GetNumIdleClients( void ) const {
|
|
int ret = 0;
|
|
for ( int i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[ i ].clientState >= SCS_CONNECTED ) {
|
|
if ( serverTime - clients[ i ].lastInputTime > NOINPUT_IDLE_TIME ) {
|
|
ret++;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::DuplicateUsercmds
|
|
==================
|
|
*/
|
|
void idAsyncServer::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++ ) {
|
|
if ( clients[i].clientState == SCS_FREE ) {
|
|
continue;
|
|
}
|
|
|
|
if ( idAsyncNetwork::DuplicateUsercmd( userCmds[previousIndex][i], userCmds[currentIndex][i], frame, time ) ) {
|
|
clients[i].numDuplicatedUsercmds++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ClearClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::ClearClient( int clientNum ) {
|
|
serverClient_t &client = clients[clientNum];
|
|
client.clientId = 0;
|
|
client.clientState = SCS_FREE;
|
|
client.clientPrediction = 0;
|
|
client.clientAheadTime = 0;
|
|
client.clientRate = 0;
|
|
client.clientPing = 0;
|
|
client.gameInitSequence = 0;
|
|
client.gameFrame = 0;
|
|
client.gameTime = 0;
|
|
client.channel.Shutdown();
|
|
client.lastConnectTime = 0;
|
|
client.lastEmptyTime = 0;
|
|
client.lastPingTime = 0;
|
|
client.lastSnapshotTime = 0;
|
|
client.lastPacketTime = 0;
|
|
client.lastInputTime = 0;
|
|
client.snapshotSequence = 0;
|
|
client.acknowledgeSnapshotSequence = 0;
|
|
client.numDuplicatedUsercmds = 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::InitClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::InitClient( int clientNum, int clientId, int clientRate ) {
|
|
int i;
|
|
|
|
// clear the user info
|
|
sessLocal.mapSpawnData.userInfo[ clientNum ].Clear(); // always start with a clean base
|
|
|
|
// clear the server client
|
|
serverClient_t &client = clients[clientNum];
|
|
client.clientId = clientId;
|
|
client.clientState = SCS_CONNECTED;
|
|
client.clientPrediction = 0;
|
|
client.clientAheadTime = 0;
|
|
client.gameInitSequence = -1;
|
|
client.gameFrame = 0;
|
|
client.gameTime = 0;
|
|
client.channel.ResetRate();
|
|
client.clientRate = clientRate ? clientRate : idAsyncNetwork::serverMaxClientRate.GetInteger();
|
|
client.channel.SetMaxOutgoingRate( Min( idAsyncNetwork::serverMaxClientRate.GetInteger(), client.clientRate ) );
|
|
client.clientPing = 0;
|
|
client.lastConnectTime = serverTime;
|
|
client.lastEmptyTime = serverTime;
|
|
client.lastPingTime = serverTime;
|
|
client.lastSnapshotTime = serverTime;
|
|
client.lastPacketTime = serverTime;
|
|
client.lastInputTime = serverTime;
|
|
client.acknowledgeSnapshotSequence = 0;
|
|
client.numDuplicatedUsercmds = 0;
|
|
|
|
// clear the user commands
|
|
for ( i = 0; i < MAX_USERCMD_BACKUP; i++ ) {
|
|
memset( &userCmds[i][clientNum], 0, sizeof( userCmds[i][clientNum] ) );
|
|
}
|
|
|
|
// let the game know a player connected
|
|
game->ServerClientConnect( clientNum, client.guid );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::InitLocalClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::InitLocalClient( int clientNum ) {
|
|
netadr_t badAddress;
|
|
|
|
localClientNum = clientNum;
|
|
InitClient( clientNum, 0, 0 );
|
|
memset( &badAddress, 0, sizeof( badAddress ) );
|
|
badAddress.type = NA_BAD;
|
|
clients[clientNum].channel.Init( badAddress, serverId );
|
|
clients[clientNum].clientState = SCS_INGAME;
|
|
sessLocal.mapSpawnData.userInfo[clientNum] = *cvarSystem->MoveCVarsToDict( CVAR_USERINFO );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::BeginLocalClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::BeginLocalClient( void ) {
|
|
game->SetLocalClient( localClientNum );
|
|
game->SetUserInfo( localClientNum, sessLocal.mapSpawnData.userInfo[localClientNum], false, false );
|
|
game->ServerClientBegin( localClientNum );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::LocalClientInput
|
|
==================
|
|
*/
|
|
void idAsyncServer::LocalClientInput( void ) {
|
|
int index;
|
|
|
|
if ( localClientNum < 0 ) {
|
|
return;
|
|
}
|
|
|
|
index = gameFrame & ( MAX_USERCMD_BACKUP - 1 );
|
|
userCmds[index][localClientNum] = usercmdGen->GetDirectUsercmd();
|
|
userCmds[index][localClientNum].gameFrame = gameFrame;
|
|
userCmds[index][localClientNum].gameTime = gameTime;
|
|
if ( idAsyncNetwork::UsercmdInputChanged( userCmds[( gameFrame - 1 ) & ( MAX_USERCMD_BACKUP - 1 )][localClientNum], userCmds[index][localClientNum] ) ) {
|
|
clients[localClientNum].lastInputTime = serverTime;
|
|
}
|
|
clients[localClientNum].gameFrame = gameFrame;
|
|
clients[localClientNum].gameTime = gameTime;
|
|
clients[localClientNum].lastPacketTime = serverTime;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::DropClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::DropClient( int clientNum, const char *reason ) {
|
|
int i;
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState <= SCS_ZOMBIE ) {
|
|
return;
|
|
}
|
|
|
|
if ( client.clientState >= SCS_PUREWAIT && clientNum != localClientNum ) {
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_DISCONNECT );
|
|
msg.WriteLong( clientNum );
|
|
msg.WriteString( reason );
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
// clientNum so SCS_PUREWAIT client gets it's own disconnect msg
|
|
if ( i == clientNum || clients[i].clientState >= SCS_CONNECTED ) {
|
|
SendReliableMessage( i, msg );
|
|
}
|
|
}
|
|
}
|
|
|
|
reason = common->GetLanguageDict()->GetString( reason );
|
|
common->Printf( "client %d %s\n", clientNum, reason );
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "addChatLine \"%s^0 %s\"", sessLocal.mapSpawnData.userInfo[ clientNum ].GetString( "ui_name" ), reason ) );
|
|
|
|
// remove the player from the game
|
|
game->ServerClientDisconnect( clientNum );
|
|
|
|
client.clientState = SCS_ZOMBIE;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendReliableMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendReliableMessage( int clientNum, const idBitMsg &msg ) {
|
|
if ( clientNum == localClientNum ) {
|
|
return;
|
|
}
|
|
if ( !clients[ clientNum ].channel.SendReliableMessage( msg ) ) {
|
|
clients[ clientNum ].channel.ClearReliableMessages();
|
|
DropClient( clientNum, "#str_07136" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::CheckClientTimeouts
|
|
==================
|
|
*/
|
|
void idAsyncServer::CheckClientTimeouts( void ) {
|
|
int i, zombieTimeout, clientTimeout;
|
|
|
|
zombieTimeout = serverTime - idAsyncNetwork::serverZombieTimeout.GetInteger() * 1000;
|
|
clientTimeout = serverTime - idAsyncNetwork::serverClientTimeout.GetInteger() * 1000;
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[i];
|
|
|
|
if ( i == localClientNum ) {
|
|
continue;
|
|
}
|
|
|
|
if ( client.lastPacketTime > serverTime ) {
|
|
client.lastPacketTime = serverTime;
|
|
continue;
|
|
}
|
|
|
|
if ( client.clientState == SCS_ZOMBIE && client.lastPacketTime < zombieTimeout ) {
|
|
client.channel.Shutdown();
|
|
client.clientState = SCS_FREE;
|
|
continue;
|
|
}
|
|
|
|
if ( client.clientState >= SCS_PUREWAIT && client.lastPacketTime < clientTimeout ) {
|
|
DropClient( i, "#str_07137" );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendPrintBroadcast
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendPrintBroadcast( const char *string ) {
|
|
int i;
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_PRINT );
|
|
msg.WriteString( string );
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState >= SCS_CONNECTED ) {
|
|
SendReliableMessage( i, msg );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendPrintToClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendPrintToClient( int clientNum, const char *string ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
return;
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_PRINT );
|
|
msg.WriteString( string );
|
|
|
|
SendReliableMessage( clientNum, msg );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendUserInfoBroadcast
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendUserInfoBroadcast( int userInfoNum, const idDict &info, bool sendToAll ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
const idDict *gameInfo;
|
|
bool gameModifiedInfo;
|
|
|
|
gameInfo = game->SetUserInfo( userInfoNum, info, false, true );
|
|
if ( gameInfo ) {
|
|
gameModifiedInfo = true;
|
|
} else {
|
|
gameModifiedInfo = false;
|
|
gameInfo = &info;
|
|
}
|
|
|
|
if ( userInfoNum == localClientNum ) {
|
|
common->DPrintf( "local user info modified by server\n" );
|
|
cvarSystem->SetCVarsFromDict( *gameInfo );
|
|
cvarSystem->ClearModifiedFlags( CVAR_USERINFO ); // don't emit back
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_CLIENTINFO );
|
|
msg.WriteByte( userInfoNum );
|
|
if ( gameModifiedInfo || sendToAll ) {
|
|
msg.WriteBits( 0, 1 );
|
|
} else {
|
|
msg.WriteBits( 1, 1 );
|
|
}
|
|
|
|
#if ID_CLIENTINFO_TAGS
|
|
msg.WriteLong( sessLocal.mapSpawnData.userInfo[userInfoNum].Checksum() );
|
|
common->DPrintf( "broadcast for client %d: 0x%x\n", userInfoNum, sessLocal.mapSpawnData.userInfo[userInfoNum].Checksum() );
|
|
sessLocal.mapSpawnData.userInfo[userInfoNum].Print();
|
|
#endif
|
|
|
|
if ( gameModifiedInfo || sendToAll ) {
|
|
msg.WriteDeltaDict( *gameInfo, NULL );
|
|
} else {
|
|
msg.WriteDeltaDict( *gameInfo, &sessLocal.mapSpawnData.userInfo[userInfoNum] );
|
|
}
|
|
|
|
for ( int i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState >= SCS_CONNECTED && ( sendToAll || i != userInfoNum || gameModifiedInfo ) ) {
|
|
SendReliableMessage( i, msg );
|
|
}
|
|
}
|
|
|
|
sessLocal.mapSpawnData.userInfo[userInfoNum] = *gameInfo;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::UpdateUI
|
|
if the game modifies userInfo, it will call this through command system
|
|
we then need to get the info from the game, and broadcast to clients
|
|
( using DeltaDict and our current mapSpawnData as a base )
|
|
==================
|
|
*/
|
|
void idAsyncServer::UpdateUI( int clientNum ) {
|
|
const idDict *info = game->GetUserInfo( clientNum );
|
|
|
|
if ( !info ) {
|
|
common->Warning( "idAsyncServer::UpdateUI: no info from game\n" );
|
|
return;
|
|
}
|
|
|
|
SendUserInfoBroadcast( clientNum, *info, true );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendUserInfoToClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendUserInfoToClient( int clientNum, int userInfoNum, const idDict &info ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
if ( clients[clientNum].clientState < SCS_CONNECTED ) {
|
|
return;
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_CLIENTINFO );
|
|
msg.WriteByte( userInfoNum );
|
|
msg.WriteBits( 0, 1 );
|
|
|
|
#if ID_CLIENTINFO_TAGS
|
|
msg.WriteLong( 0 );
|
|
common->DPrintf( "user info %d to client %d: NULL base\n", userInfoNum, clientNum );
|
|
#endif
|
|
|
|
msg.WriteDeltaDict( info, NULL );
|
|
|
|
SendReliableMessage( clientNum, msg );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendSyncedCvarsBroadcast
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendSyncedCvarsBroadcast( const idDict &cvars ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
int i;
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_SYNCEDCVARS );
|
|
msg.WriteDeltaDict( cvars, &sessLocal.mapSpawnData.syncedCVars );
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState >= SCS_CONNECTED ) {
|
|
SendReliableMessage( i, msg );
|
|
}
|
|
}
|
|
|
|
sessLocal.mapSpawnData.syncedCVars = cvars;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendSyncedCvarsToClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendSyncedCvarsToClient( int clientNum, const idDict &cvars ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
if ( clients[clientNum].clientState < SCS_CONNECTED ) {
|
|
return;
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_SYNCEDCVARS );
|
|
msg.WriteDeltaDict( cvars, NULL );
|
|
|
|
SendReliableMessage( clientNum, msg );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendApplySnapshotToClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendApplySnapshotToClient( int clientNum, int sequence ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_APPLYSNAPSHOT );
|
|
msg.WriteLong( sequence );
|
|
|
|
SendReliableMessage( clientNum, msg );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendEmptyToClient
|
|
==================
|
|
*/
|
|
bool idAsyncServer::SendEmptyToClient( int clientNum, bool force ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.lastEmptyTime > realTime ) {
|
|
client.lastEmptyTime = realTime;
|
|
}
|
|
|
|
if ( !force && ( realTime - client.lastEmptyTime < EMPTY_RESEND_TIME ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( idAsyncNetwork::verbose.GetInteger() ) {
|
|
common->Printf( "sending empty to client %d: gameInitId = %d, gameFrame = %d, gameTime = %d\n", clientNum, gameInitId, gameFrame, gameTime );
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteLong( gameInitId );
|
|
msg.WriteByte( SERVER_UNRELIABLE_MESSAGE_EMPTY );
|
|
|
|
client.channel.SendMessage( serverPort, serverTime, msg );
|
|
|
|
client.lastEmptyTime = realTime;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendPingToClient
|
|
==================
|
|
*/
|
|
bool idAsyncServer::SendPingToClient( int clientNum ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.lastPingTime > realTime ) {
|
|
client.lastPingTime = realTime;
|
|
}
|
|
|
|
if ( realTime - client.lastPingTime < PING_RESEND_TIME ) {
|
|
return false;
|
|
}
|
|
|
|
if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
|
|
common->Printf( "pinging client %d: gameInitId = %d, gameFrame = %d, gameTime = %d\n", clientNum, gameInitId, gameFrame, gameTime );
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteLong( gameInitId );
|
|
msg.WriteByte( SERVER_UNRELIABLE_MESSAGE_PING );
|
|
msg.WriteLong( realTime );
|
|
|
|
client.channel.SendMessage( serverPort, serverTime, msg );
|
|
|
|
client.lastPingTime = realTime;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendGameInitToClient
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendGameInitToClient( int clientNum ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
if ( idAsyncNetwork::verbose.GetInteger() ) {
|
|
common->Printf( "sending gameinit to client %d: gameInitId = %d, gameFrame = %d, gameTime = %d\n", clientNum, gameInitId, gameFrame, gameTime );
|
|
}
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
// clear the unsent fragments. might flood winsock but that's ok
|
|
while( client.channel.UnsentFragmentsLeft() ) {
|
|
client.channel.SendNextFragment( serverPort, serverTime );
|
|
}
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteLong( gameInitId );
|
|
msg.WriteByte( SERVER_UNRELIABLE_MESSAGE_GAMEINIT );
|
|
msg.WriteLong( gameFrame );
|
|
msg.WriteLong( gameTime );
|
|
msg.WriteDeltaDict( sessLocal.mapSpawnData.serverInfo, NULL );
|
|
client.gameInitSequence = client.channel.SendMessage( serverPort, serverTime, msg );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendSnapshotToClient
|
|
==================
|
|
*/
|
|
bool idAsyncServer::SendSnapshotToClient( int clientNum ) {
|
|
int i, j, index, numUsercmds;
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
usercmd_t * last;
|
|
byte clientInPVS[MAX_ASYNC_CLIENTS >> 3];
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
if ( serverTime - client.lastSnapshotTime < idAsyncNetwork::serverSnapshotDelay.GetInteger() ) {
|
|
return false;
|
|
}
|
|
|
|
if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
|
|
common->Printf( "sending snapshot to client %d: gameInitId = %d, gameFrame = %d, gameTime = %d\n", clientNum, gameInitId, gameFrame, gameTime );
|
|
}
|
|
|
|
// how far is the client ahead of the server minus the packet delay
|
|
client.clientAheadTime = client.gameTime - ( gameTime + gameTimeResidual );
|
|
|
|
// write the snapshot
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteLong( gameInitId );
|
|
msg.WriteByte( SERVER_UNRELIABLE_MESSAGE_SNAPSHOT );
|
|
msg.WriteLong( client.snapshotSequence );
|
|
msg.WriteLong( gameFrame );
|
|
msg.WriteLong( gameTime );
|
|
msg.WriteByte( idMath::ClampChar( client.numDuplicatedUsercmds ) );
|
|
msg.WriteShort( idMath::ClampShort( client.clientAheadTime ) );
|
|
|
|
// write the game snapshot
|
|
game->ServerWriteSnapshot( clientNum, client.snapshotSequence, msg, clientInPVS, MAX_ASYNC_CLIENTS );
|
|
|
|
// write the latest user commands from the other clients in the PVS to the snapshot
|
|
for ( last = NULL, i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState == SCS_FREE || i == clientNum ) {
|
|
continue;
|
|
}
|
|
|
|
// if the client is not in the PVS
|
|
if ( !( clientInPVS[i >> 3] & ( 1 << ( i & 7 ) ) ) ) {
|
|
continue;
|
|
}
|
|
|
|
int maxRelay = idMath::ClampInt( 1, MAX_USERCMD_RELAY, idAsyncNetwork::serverMaxUsercmdRelay.GetInteger() );
|
|
|
|
// Max( 1, to always send at least one cmd, which we know we have because we call DuplicateUsercmds in RunFrame
|
|
numUsercmds = Max( 1, Min( client.gameFrame, gameFrame + maxRelay ) - gameFrame );
|
|
msg.WriteByte( i );
|
|
msg.WriteByte( numUsercmds );
|
|
for ( j = 0; j < numUsercmds; j++ ) {
|
|
index = ( gameFrame + j ) & ( MAX_USERCMD_BACKUP - 1 );
|
|
idAsyncNetwork::WriteUserCmdDelta( msg, userCmds[index][i], last );
|
|
last = &userCmds[index][i];
|
|
}
|
|
}
|
|
msg.WriteByte( MAX_ASYNC_CLIENTS );
|
|
|
|
client.channel.SendMessage( serverPort, serverTime, msg );
|
|
|
|
client.lastSnapshotTime = serverTime;
|
|
client.snapshotSequence++;
|
|
client.numDuplicatedUsercmds = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessUnreliableClientMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessUnreliableClientMessage( int clientNum, const idBitMsg &msg ) {
|
|
int i, id, acknowledgeSequence, clientGameInitId, clientGameFrame, numUsercmds, index;
|
|
usercmd_t *last;
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
if ( client.clientState == SCS_ZOMBIE ) {
|
|
return;
|
|
}
|
|
|
|
acknowledgeSequence = msg.ReadLong();
|
|
clientGameInitId = msg.ReadLong();
|
|
|
|
// while loading a map the client may send empty messages to keep the connection alive
|
|
if ( clientGameInitId == GAME_INIT_ID_MAP_LOAD ) {
|
|
if ( idAsyncNetwork::verbose.GetInteger() ) {
|
|
common->Printf( "ignore unreliable msg from client %d, gameInitId == ID_MAP_LOAD\n", clientNum );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// check if the client is in the right game
|
|
if ( clientGameInitId != gameInitId ) {
|
|
if ( acknowledgeSequence > client.gameInitSequence ) {
|
|
// the client is connected but not in the right game
|
|
client.clientState = SCS_CONNECTED;
|
|
|
|
// send game init to client
|
|
SendGameInitToClient( clientNum );
|
|
|
|
if ( sessLocal.mapSpawnData.serverInfo.GetBool( "si_pure" ) ) {
|
|
client.clientState = SCS_PUREWAIT;
|
|
if ( !SendReliablePureToClient( clientNum ) ) {
|
|
client.clientState = SCS_CONNECTED;
|
|
}
|
|
}
|
|
} else if ( idAsyncNetwork::verbose.GetInteger() ) {
|
|
common->Printf( "ignore unreliable msg from client %d, wrong gameInit, old sequence\n", clientNum );
|
|
}
|
|
return;
|
|
}
|
|
|
|
client.acknowledgeSnapshotSequence = msg.ReadLong();
|
|
|
|
if ( client.clientState == SCS_CONNECTED ) {
|
|
|
|
// the client is in the right game
|
|
client.clientState = SCS_INGAME;
|
|
|
|
// send the user info of other clients
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState >= SCS_CONNECTED && i != clientNum ) {
|
|
SendUserInfoToClient( clientNum, i, sessLocal.mapSpawnData.userInfo[i] );
|
|
}
|
|
}
|
|
|
|
// send synchronized cvars to client
|
|
SendSyncedCvarsToClient( clientNum, sessLocal.mapSpawnData.syncedCVars );
|
|
|
|
SendEnterGameToClient( clientNum );
|
|
|
|
// get the client running in the game
|
|
game->ServerClientBegin( clientNum );
|
|
|
|
// write any reliable messages to initialize the client game state
|
|
game->ServerWriteInitialReliableMessages( clientNum );
|
|
} else if ( client.clientState == SCS_INGAME ) {
|
|
|
|
// apply the last snapshot the client received
|
|
if ( game->ServerApplySnapshot( clientNum, client.acknowledgeSnapshotSequence ) ) {
|
|
SendApplySnapshotToClient( clientNum, client.acknowledgeSnapshotSequence );
|
|
}
|
|
}
|
|
|
|
// process the unreliable message
|
|
id = msg.ReadByte();
|
|
switch( id ) {
|
|
case CLIENT_UNRELIABLE_MESSAGE_EMPTY: {
|
|
if ( idAsyncNetwork::verbose.GetInteger() ) {
|
|
common->Printf( "received empty message for client %d\n", clientNum );
|
|
}
|
|
break;
|
|
}
|
|
case CLIENT_UNRELIABLE_MESSAGE_PINGRESPONSE: {
|
|
client.clientPing = realTime - msg.ReadLong();
|
|
break;
|
|
}
|
|
case CLIENT_UNRELIABLE_MESSAGE_USERCMD: {
|
|
|
|
client.clientPrediction = msg.ReadShort();
|
|
|
|
// read user commands
|
|
clientGameFrame = msg.ReadLong();
|
|
numUsercmds = msg.ReadByte();
|
|
for ( last = NULL, i = clientGameFrame - numUsercmds + 1; i <= clientGameFrame; i++ ) {
|
|
index = i & ( MAX_USERCMD_BACKUP - 1 );
|
|
idAsyncNetwork::ReadUserCmdDelta( msg, userCmds[index][clientNum], last );
|
|
userCmds[index][clientNum].gameFrame = i;
|
|
userCmds[index][clientNum].duplicateCount = 0;
|
|
if ( idAsyncNetwork::UsercmdInputChanged( userCmds[( i - 1 ) & ( MAX_USERCMD_BACKUP - 1 )][clientNum], userCmds[index][clientNum] ) ) {
|
|
client.lastInputTime = serverTime;
|
|
}
|
|
last = &userCmds[index][clientNum];
|
|
}
|
|
|
|
if ( last ) {
|
|
client.gameFrame = last->gameFrame;
|
|
client.gameTime = last->gameTime;
|
|
}
|
|
|
|
if ( idAsyncNetwork::verbose.GetInteger() == 2 ) {
|
|
common->Printf( "received user command for client %d, gameInitId = %d, gameFrame, %d gameTime %d\n", clientNum, clientGameInitId, client.gameFrame, client.gameTime );
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
common->Printf( "unknown unreliable message %d from client %d\n", id, clientNum );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessReliableClientMessages
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessReliableClientMessages( int clientNum ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
byte id;
|
|
|
|
serverClient_t &client = clients[clientNum];
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
|
|
while ( client.channel.GetReliableMessage( msg ) ) {
|
|
id = msg.ReadByte();
|
|
switch( id ) {
|
|
case CLIENT_RELIABLE_MESSAGE_CLIENTINFO: {
|
|
idDict info;
|
|
msg.ReadDeltaDict( info, &sessLocal.mapSpawnData.userInfo[clientNum] );
|
|
SendUserInfoBroadcast( clientNum, info );
|
|
break;
|
|
}
|
|
case CLIENT_RELIABLE_MESSAGE_PRINT: {
|
|
char string[MAX_STRING_CHARS];
|
|
msg.ReadString( string, sizeof( string ) );
|
|
common->Printf( "%s\n", string );
|
|
break;
|
|
}
|
|
case CLIENT_RELIABLE_MESSAGE_DISCONNECT: {
|
|
DropClient( clientNum, "#str_07138" );
|
|
break;
|
|
}
|
|
case CLIENT_RELIABLE_MESSAGE_PURE: {
|
|
// we get this message once the client has successfully updated it's pure list
|
|
ProcessReliablePure( clientNum, msg );
|
|
break;
|
|
}
|
|
default: {
|
|
// pass reliable message on to game code
|
|
game->ServerProcessReliableMessage( clientNum, msg );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessAuthMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessAuthMessage( const idBitMsg &msg ) {
|
|
netadr_t client_from;
|
|
char client_guid[ 12 ], string[ MAX_STRING_CHARS ];
|
|
int i, clientId;
|
|
authReply_t reply;
|
|
authReplyMsg_t replyMsg = AUTH_REPLY_WAITING;
|
|
idStr replyPrintMsg;
|
|
|
|
reply = (authReply_t)msg.ReadByte();
|
|
if ( reply <= 0 || reply >= AUTH_MAXSTATES ) {
|
|
common->DPrintf( "auth: invalid reply %d\n", reply );
|
|
return;
|
|
}
|
|
clientId = msg.ReadShort( );
|
|
msg.ReadNetadr( &client_from );
|
|
msg.ReadString( client_guid, sizeof( client_guid ) );
|
|
if ( reply != AUTH_OK ) {
|
|
replyMsg = (authReplyMsg_t)msg.ReadByte();
|
|
if ( replyMsg <= 0 || replyMsg >= AUTH_REPLY_MAXSTATES ) {
|
|
common->DPrintf( "auth: invalid reply msg %d\n", replyMsg );
|
|
return;
|
|
}
|
|
if ( replyMsg == AUTH_REPLY_PRINT ) {
|
|
msg.ReadString( string, MAX_STRING_CHARS );
|
|
replyPrintMsg = string;
|
|
}
|
|
}
|
|
|
|
lastAuthTime = serverTime;
|
|
|
|
// no message parsing below
|
|
|
|
for ( i = 0; i < MAX_CHALLENGES; i++ ) {
|
|
if ( !challenges[i].connected && challenges[ i ].clientId == clientId ) {
|
|
// return if something is wrong
|
|
// break if we have found a valid auth
|
|
if ( !strlen( challenges[ i ].guid ) ) {
|
|
common->DPrintf( "auth: client %s has no guid yet\n", Sys_NetAdrToString( challenges[ i ].address ) );
|
|
return;
|
|
}
|
|
if ( idStr::Cmp( challenges[ i ].guid, client_guid ) ) {
|
|
common->DPrintf( "auth: client %s %s not matched, auth server says guid %s\n", Sys_NetAdrToString( challenges[ i ].address ), challenges[i].guid, client_guid );
|
|
return;
|
|
}
|
|
if ( !Sys_CompareNetAdrBase( client_from, challenges[i].address ) ) {
|
|
// let auth work when server and master don't see the same IP
|
|
common->DPrintf( "auth: matched guid '%s' for != IPs %s and %s\n", client_guid, Sys_NetAdrToString( client_from ), Sys_NetAdrToString( challenges[i].address ) );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ( i >= MAX_CHALLENGES ) {
|
|
common->DPrintf( "auth: failed client lookup %s %s\n", Sys_NetAdrToString( client_from ), client_guid );
|
|
return;
|
|
}
|
|
|
|
if ( challenges[ i ].authState != CDK_WAIT ) {
|
|
common->DWarning( "auth: challenge 0x%x %s authState %d != CDK_WAIT", challenges[ i ].challenge, Sys_NetAdrToString( challenges[ i ].address ), challenges[ i ].authState );
|
|
return;
|
|
}
|
|
|
|
idStr::snPrintf( challenges[ i ].guid, 12, client_guid );
|
|
if ( reply == AUTH_OK ) {
|
|
challenges[ i ].authState = CDK_OK;
|
|
common->Printf( "client %s %s is authed\n", Sys_NetAdrToString( client_from ), client_guid );
|
|
} else {
|
|
const char *msg;
|
|
if ( replyMsg != AUTH_REPLY_PRINT ) {
|
|
msg = authReplyMsg[ replyMsg ];
|
|
} else {
|
|
msg = replyPrintMsg.c_str();
|
|
}
|
|
// maybe localize it
|
|
const char *l_msg = common->GetLanguageDict()->GetString( msg );
|
|
common->DPrintf( "auth: client %s %s - %s %s\n", Sys_NetAdrToString( client_from ), client_guid, authReplyStr[ reply ], l_msg );
|
|
challenges[ i ].authReply = reply;
|
|
challenges[ i ].authReplyMsg = replyMsg;
|
|
challenges[ i ].authReplyPrint = replyPrintMsg;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessChallengeMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessChallengeMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
int i, clientId, oldest, oldestTime;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
clientId = msg.ReadLong();
|
|
|
|
oldest = 0;
|
|
oldestTime = 0x7fffffff;
|
|
|
|
// see if we already have a challenge for this ip
|
|
for ( i = 0; i < MAX_CHALLENGES; i++ ) {
|
|
if ( !challenges[i].connected && Sys_CompareNetAdrBase( from, challenges[i].address ) && clientId == challenges[i].clientId ) {
|
|
break;
|
|
}
|
|
if ( challenges[i].time < oldestTime ) {
|
|
oldestTime = challenges[i].time;
|
|
oldest = i;
|
|
}
|
|
}
|
|
|
|
if ( i >= MAX_CHALLENGES ) {
|
|
// this is the first time this client has asked for a challenge
|
|
i = oldest;
|
|
challenges[i].address = from;
|
|
challenges[i].clientId = clientId;
|
|
challenges[i].challenge = ( (rand() << 16) ^ rand() ) ^ serverTime;
|
|
challenges[i].time = serverTime;
|
|
challenges[i].connected = false;
|
|
challenges[i].authState = CDK_WAIT;
|
|
challenges[i].authReply = AUTH_NONE;
|
|
challenges[i].authReplyMsg = AUTH_REPLY_WAITING;
|
|
challenges[i].authReplyPrint = "";
|
|
challenges[i].guid[0] = '\0';
|
|
}
|
|
challenges[i].pingTime = serverTime;
|
|
|
|
common->Printf( "sending challenge 0x%x to %s\n", challenges[i].challenge, Sys_NetAdrToString( from ) );
|
|
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "challengeResponse" );
|
|
outMsg.WriteLong( challenges[i].challenge );
|
|
outMsg.WriteShort( serverId );
|
|
outMsg.WriteString( cvarSystem->GetCVarString( "fs_game_base" ) );
|
|
outMsg.WriteString( cvarSystem->GetCVarString( "fs_game" ) );
|
|
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
|
|
if ( Sys_IsLANAddress( from ) ) {
|
|
// no CD Key check for LAN clients
|
|
challenges[i].authState = CDK_OK;
|
|
} else {
|
|
if ( idAsyncNetwork::LANServer.GetBool() ) {
|
|
common->Printf( "net_LANServer is enabled. Client %s is not a LAN address, will be rejected\n", Sys_NetAdrToString( from ) );
|
|
challenges[ i ].authState = CDK_ONLYLAN;
|
|
} else {
|
|
// emit a cd key confirmation request
|
|
outMsg.BeginWriting();
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "srvAuth" );
|
|
outMsg.WriteLong( ASYNC_PROTOCOL_VERSION );
|
|
outMsg.WriteNetadr( from );
|
|
outMsg.WriteLong( -1 ); // this identifies "challenge" auth vs "connect" auth
|
|
// protocol 1.37 addition
|
|
outMsg.WriteByte( fileSystem->RunningD3XP() );
|
|
serverPort.SendPacket( idAsyncNetwork::GetMasterAddress(), outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendPureServerMessage
|
|
==================
|
|
*/
|
|
bool idAsyncServer::SendPureServerMessage( const netadr_t to, int OS ) {
|
|
idBitMsg outMsg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
int serverChecksums[ MAX_PURE_PAKS ];
|
|
int gamePakChecksum;
|
|
int i;
|
|
|
|
fileSystem->GetPureServerChecksums( serverChecksums, OS, &gamePakChecksum );
|
|
if ( !serverChecksums[ 0 ] ) {
|
|
// happens if you run fully expanded assets with si_pure 1
|
|
common->Warning( "pure server has no pak files referenced" );
|
|
return false;
|
|
}
|
|
common->DPrintf( "client %s: sending pure pak list\n", Sys_NetAdrToString( to ) );
|
|
|
|
// send our list of required paks
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "pureServer" );
|
|
|
|
i = 0;
|
|
while ( serverChecksums[ i ] ) {
|
|
outMsg.WriteLong( serverChecksums[ i++ ] );
|
|
}
|
|
outMsg.WriteLong( 0 );
|
|
|
|
// write the pak checksum for game code
|
|
outMsg.WriteLong( gamePakChecksum );
|
|
|
|
serverPort.SendPacket( to, outMsg.GetData(), outMsg.GetSize() );
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendReliablePureToClient
|
|
==================
|
|
*/
|
|
bool idAsyncServer::SendReliablePureToClient( int clientNum ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
int serverChecksums[ MAX_PURE_PAKS ];
|
|
int i;
|
|
int gamePakChecksum;
|
|
|
|
fileSystem->GetPureServerChecksums( serverChecksums, clients[ clientNum ].OS, &gamePakChecksum );
|
|
if ( !serverChecksums[ 0 ] ) {
|
|
// happens if you run fully expanded assets with si_pure 1
|
|
common->Warning( "pure server has no pak files referenced" );
|
|
return false;
|
|
}
|
|
|
|
common->DPrintf( "client %d: sending pure pak list (reliable channel) @ gameInitId %d\n", clientNum, gameInitId );
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_PURE );
|
|
|
|
msg.WriteLong( gameInitId );
|
|
|
|
i = 0;
|
|
while ( serverChecksums[ i ] ) {
|
|
msg.WriteLong( serverChecksums[ i++ ] );
|
|
}
|
|
msg.WriteLong( 0 );
|
|
msg.WriteLong( gamePakChecksum );
|
|
|
|
SendReliableMessage( clientNum, msg );
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ValidateChallenge
|
|
==================
|
|
*/
|
|
int idAsyncServer::ValidateChallenge( const netadr_t from, int challenge, int clientId ) {
|
|
int i;
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
const serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState == SCS_FREE ) {
|
|
continue;
|
|
}
|
|
if ( Sys_CompareNetAdrBase( from, client.channel.GetRemoteAddress() ) &&
|
|
( clientId == client.clientId || from.port == client.channel.GetRemoteAddress().port ) ) {
|
|
if ( serverTime - client.lastConnectTime < MIN_RECONNECT_TIME ) {
|
|
common->Printf( "%s: reconnect rejected : too soon\n", Sys_NetAdrToString( from ) );
|
|
return -1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
for ( i = 0; i < MAX_CHALLENGES; i++ ) {
|
|
if ( Sys_CompareNetAdrBase( from, challenges[i].address ) && from.port == challenges[i].address.port ) {
|
|
if ( challenge == challenges[i].challenge ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ( i == MAX_CHALLENGES ) {
|
|
PrintOOB( from, SERVER_PRINT_BADCHALLENGE, "#str_04840" );
|
|
return -1;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessConnectMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessConnectMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
int clientNum, protocol, clientDataChecksum, challenge, clientId, ping, clientRate;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
char guid[ 12 ];
|
|
char password[ 17 ];
|
|
int i, ichallenge, islot, OS, numClients;
|
|
|
|
protocol = msg.ReadLong();
|
|
OS = msg.ReadShort();
|
|
|
|
// check the protocol version
|
|
if ( protocol != ASYNC_PROTOCOL_VERSION ) {
|
|
// that's a msg back to a client, we don't know about it's localization, so send english
|
|
PrintOOB( from, SERVER_PRINT_BADPROTOCOL, va( "server uses protocol %d.%d\n", ASYNC_PROTOCOL_MAJOR, ASYNC_PROTOCOL_MINOR ) );
|
|
return;
|
|
}
|
|
|
|
clientDataChecksum = msg.ReadLong();
|
|
challenge = msg.ReadLong();
|
|
clientId = msg.ReadShort();
|
|
clientRate = msg.ReadLong();
|
|
|
|
// check the client data - only for non pure servers
|
|
if ( !sessLocal.mapSpawnData.serverInfo.GetInt( "si_pure" ) && clientDataChecksum != serverDataChecksum ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04842" );
|
|
return;
|
|
}
|
|
|
|
if ( ( ichallenge = ValidateChallenge( from, challenge, clientId ) ) == -1 ) {
|
|
return;
|
|
}
|
|
challenges[ ichallenge ].OS = OS;
|
|
|
|
msg.ReadString( guid, sizeof( guid ) );
|
|
|
|
switch ( challenges[ ichallenge ].authState ) {
|
|
case CDK_PUREWAIT:
|
|
SendPureServerMessage( from, OS );
|
|
return;
|
|
case CDK_ONLYLAN:
|
|
common->DPrintf( "%s: not a lan client\n", Sys_NetAdrToString( from ) );
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04843" );
|
|
return;
|
|
case CDK_WAIT:
|
|
if ( challenges[ ichallenge ].authReply == AUTH_NONE && Min( serverTime - lastAuthTime, serverTime - challenges[ ichallenge ].time ) > AUTHORIZE_TIMEOUT ) {
|
|
common->DPrintf( "%s: Authorize server timed out\n", Sys_NetAdrToString( from ) );
|
|
break; // will continue with the connecting process
|
|
}
|
|
const char *msg, *l_msg;
|
|
if ( challenges[ ichallenge ].authReplyMsg != AUTH_REPLY_PRINT ) {
|
|
msg = authReplyMsg[ challenges[ ichallenge ].authReplyMsg ];
|
|
} else {
|
|
msg = challenges[ ichallenge ].authReplyPrint.c_str();
|
|
}
|
|
l_msg = common->GetLanguageDict()->GetString( msg );
|
|
|
|
common->DPrintf( "%s: %s\n", Sys_NetAdrToString( from ), l_msg );
|
|
|
|
if ( challenges[ ichallenge ].authReplyMsg == AUTH_REPLY_UNKNOWN || challenges[ ichallenge ].authReplyMsg == AUTH_REPLY_WAITING ) {
|
|
// the client may be trying to connect to us in LAN mode, and the server disagrees
|
|
// let the client know so it would switch to authed connection
|
|
idBitMsg outMsg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "authrequired" );
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
|
|
PrintOOB( from, SERVER_PRINT_MISC, msg );
|
|
|
|
// update the guid in the challenges
|
|
idStr::snPrintf( challenges[ ichallenge ].guid, sizeof( challenges[ ichallenge ].guid ), guid );
|
|
|
|
// once auth replied denied, stop sending further requests
|
|
if ( challenges[ ichallenge ].authReply != AUTH_DENY ) {
|
|
// emit a cd key confirmation request
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "srvAuth" );
|
|
outMsg.WriteLong( ASYNC_PROTOCOL_VERSION );
|
|
outMsg.WriteNetadr( from );
|
|
outMsg.WriteLong( clientId );
|
|
outMsg.WriteString( guid );
|
|
// protocol 1.37 addition
|
|
outMsg.WriteByte( fileSystem->RunningD3XP() );
|
|
serverPort.SendPacket( idAsyncNetwork::GetMasterAddress(), outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
return;
|
|
default:
|
|
assert( challenges[ ichallenge ].authState == CDK_OK || challenges[ ichallenge ].authState == CDK_PUREOK );
|
|
}
|
|
|
|
numClients = 0;
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[ i ];
|
|
if ( client.clientState >= SCS_PUREWAIT ) {
|
|
numClients++;
|
|
}
|
|
}
|
|
|
|
// game may be passworded, client banned by IP or GUID
|
|
// if authState == CDK_PUREOK, the check was already performed once before entering pure checks
|
|
// but meanwhile, the max players may have been reached
|
|
msg.ReadString( password, sizeof( password ) );
|
|
char reason[MAX_STRING_CHARS];
|
|
allowReply_t reply = game->ServerAllowClient( numClients, Sys_NetAdrToString( from ), guid, password, reason );
|
|
if ( reply != ALLOW_YES ) {
|
|
common->DPrintf( "game denied connection for %s\n", Sys_NetAdrToString( from ) );
|
|
|
|
// SERVER_PRINT_GAMEDENY passes the game opcode through. Don't use PrintOOB
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "print" );
|
|
outMsg.WriteLong( SERVER_PRINT_GAMEDENY );
|
|
outMsg.WriteLong( reply );
|
|
outMsg.WriteString( reason );
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
|
|
return;
|
|
}
|
|
|
|
// enter pure checks if necessary
|
|
if ( sessLocal.mapSpawnData.serverInfo.GetInt( "si_pure" ) && challenges[ ichallenge ].authState != CDK_PUREOK ) {
|
|
if ( SendPureServerMessage( from, OS ) ) {
|
|
challenges[ ichallenge ].authState = CDK_PUREWAIT;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// push back decl checksum here when running pure. just an additional safe check
|
|
if ( sessLocal.mapSpawnData.serverInfo.GetInt( "si_pure" ) && clientDataChecksum != serverDataChecksum ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04844" );
|
|
return;
|
|
}
|
|
|
|
ping = serverTime - challenges[ ichallenge ].pingTime;
|
|
common->Printf( "challenge from %s connecting with %d ping\n", Sys_NetAdrToString( from ), ping );
|
|
challenges[ ichallenge ].connected = true;
|
|
|
|
// find a slot for the client
|
|
for ( islot = 0; islot < 3; islot++ ) {
|
|
for ( clientNum = 0; clientNum < MAX_ASYNC_CLIENTS; clientNum++ ) {
|
|
serverClient_t &client = clients[ clientNum ];
|
|
|
|
if ( islot == 0 ) {
|
|
// if this slot uses the same IP and port
|
|
if ( Sys_CompareNetAdrBase( from, client.channel.GetRemoteAddress() ) &&
|
|
( clientId == client.clientId || from.port == client.channel.GetRemoteAddress().port ) ) {
|
|
break;
|
|
}
|
|
} else if ( islot == 1 ) {
|
|
// if this client is not connected and the slot uses the same IP
|
|
if ( client.clientState >= SCS_PUREWAIT ) {
|
|
continue;
|
|
}
|
|
if ( Sys_CompareNetAdrBase( from, client.channel.GetRemoteAddress() ) ) {
|
|
break;
|
|
}
|
|
} else if ( islot == 2 ) {
|
|
// if this slot is free
|
|
if ( client.clientState == SCS_FREE ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( clientNum < MAX_ASYNC_CLIENTS ) {
|
|
// initialize
|
|
clients[ clientNum ].channel.Init( from, serverId );
|
|
clients[ clientNum ].OS = OS;
|
|
strncpy( clients[ clientNum ].guid, guid, 12 );
|
|
clients[ clientNum ].guid[11] = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if no free spots available
|
|
if ( clientNum >= MAX_ASYNC_CLIENTS ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04845" );
|
|
return;
|
|
}
|
|
|
|
common->Printf( "sending connect response to %s\n", Sys_NetAdrToString( from ) );
|
|
|
|
// send connect response message
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "connectResponse" );
|
|
outMsg.WriteLong( clientNum );
|
|
outMsg.WriteLong( gameInitId );
|
|
outMsg.WriteLong( gameFrame );
|
|
outMsg.WriteLong( gameTime );
|
|
outMsg.WriteDeltaDict( sessLocal.mapSpawnData.serverInfo, NULL );
|
|
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
|
|
InitClient( clientNum, clientId, clientRate );
|
|
|
|
clients[clientNum].gameInitSequence = 1;
|
|
clients[clientNum].snapshotSequence = 1;
|
|
|
|
// clear the challenge struct so a reconnect from this client IP starts clean
|
|
memset( &challenges[ ichallenge ], 0, sizeof( challenge_t ) );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::VerifyChecksumMessage
|
|
==================
|
|
*/
|
|
bool idAsyncServer::VerifyChecksumMessage( int clientNum, const netadr_t *from, const idBitMsg &msg, idStr &reply, int OS ) {
|
|
int i, numChecksums;
|
|
int checksums[ MAX_PURE_PAKS ];
|
|
int gamePakChecksum;
|
|
int serverChecksums[ MAX_PURE_PAKS ];
|
|
int serverGamePakChecksum;
|
|
|
|
// pak checksums, in a 0-terminated list
|
|
numChecksums = 0;
|
|
do {
|
|
i = msg.ReadLong( );
|
|
checksums[ numChecksums++ ] = i;
|
|
// just to make sure a broken client doesn't crash us
|
|
if ( numChecksums >= MAX_PURE_PAKS ) {
|
|
common->Warning( "MAX_PURE_PAKS ( %d ) exceeded in idAsyncServer::ProcessPureMessage\n", MAX_PURE_PAKS );
|
|
sprintf( reply, "#str_07144" );
|
|
return false;
|
|
}
|
|
} while ( i );
|
|
numChecksums--;
|
|
|
|
// code pak checksum
|
|
gamePakChecksum = msg.ReadLong( );
|
|
|
|
fileSystem->GetPureServerChecksums( serverChecksums, OS, &serverGamePakChecksum );
|
|
assert( serverChecksums[ 0 ] );
|
|
|
|
// compare the lists
|
|
if ( serverGamePakChecksum != gamePakChecksum ) {
|
|
common->Printf( "client %s: invalid game code pak ( 0x%x )\n", from ? Sys_NetAdrToString( *from ) : va( "%d", clientNum ), gamePakChecksum );
|
|
sprintf( reply, "#str_07145" );
|
|
return false;
|
|
}
|
|
for ( i = 0; serverChecksums[ i ] != 0; i++ ) {
|
|
if ( checksums[ i ] != serverChecksums[ i ] ) {
|
|
common->DPrintf( "client %s: pak missing ( 0x%x )\n", from ? Sys_NetAdrToString( *from ) : va( "%d", clientNum ), serverChecksums[ i ] );
|
|
sprintf( reply, "pak missing ( 0x%x )\n", serverChecksums[ i ] );
|
|
return false;
|
|
}
|
|
}
|
|
if ( checksums[ i ] != 0 ) {
|
|
common->DPrintf( "client %s: extra pak file referenced ( 0x%x )\n", from ? Sys_NetAdrToString( *from ) : va( "%d", clientNum ), checksums[ i ] );
|
|
sprintf( reply, "extra pak file referenced ( 0x%x )\n", checksums[ i ] );
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessPureMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessPureMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
int iclient, challenge, clientId;
|
|
idStr reply;
|
|
|
|
challenge = msg.ReadLong();
|
|
clientId = msg.ReadShort();
|
|
|
|
if ( ( iclient = ValidateChallenge( from, challenge, clientId ) ) == -1 ) {
|
|
return;
|
|
}
|
|
|
|
if ( challenges[ iclient ].authState != CDK_PUREWAIT ) {
|
|
common->DPrintf( "client %s: got pure message, not in CDK_PUREWAIT\n", Sys_NetAdrToString( from ) );
|
|
return;
|
|
}
|
|
|
|
if ( !VerifyChecksumMessage( iclient, &from, msg, reply, challenges[ iclient ].OS ) ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, reply );
|
|
return;
|
|
}
|
|
|
|
common->DPrintf( "client %s: passed pure checks\n", Sys_NetAdrToString( from ) );
|
|
challenges[ iclient ].authState = CDK_PUREOK; // next connect message will get the client through completely
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessReliablePure
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessReliablePure( int clientNum, const idBitMsg &msg ) {
|
|
idStr reply;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
int clientGameInitId;
|
|
|
|
clientGameInitId = msg.ReadLong();
|
|
if ( clientGameInitId != gameInitId ) {
|
|
common->DPrintf( "client %d: ignoring reliable pure from an old gameInit (%d)\n", clientNum, clientGameInitId );
|
|
return;
|
|
}
|
|
|
|
if ( clients[ clientNum ].clientState != SCS_PUREWAIT ) {
|
|
// should not happen unless something is very wrong. still, don't let this crash us, just get rid of the client
|
|
common->DPrintf( "client %d: got reliable pure while != SCS_PUREWAIT, sending a reload\n", clientNum );
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteByte( SERVER_RELIABLE_MESSAGE_RELOAD );
|
|
SendReliableMessage( clientNum, msg );
|
|
// go back to SCS_CONNECTED to sleep on the client until it goes away for a reconnect
|
|
clients[ clientNum ].clientState = SCS_CONNECTED;
|
|
return;
|
|
}
|
|
|
|
if ( !VerifyChecksumMessage( clientNum, NULL, msg, reply, clients[ clientNum ].OS ) ) {
|
|
DropClient( clientNum, reply );
|
|
return;
|
|
}
|
|
common->DPrintf( "client %d: passed pure checks (reliable channel)\n", clientNum );
|
|
clients[ clientNum ].clientState = SCS_CONNECTED;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::RemoteConsoleOutput
|
|
==================
|
|
*/
|
|
void idAsyncServer::RemoteConsoleOutput( const char *string ) {
|
|
noRconOutput = false;
|
|
PrintOOB( rconAddress, SERVER_PRINT_RCON, string );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
RConRedirect
|
|
==================
|
|
*/
|
|
void RConRedirect( const char *string ) {
|
|
idAsyncNetwork::server.RemoteConsoleOutput( string );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessRemoteConsoleMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessRemoteConsoleMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
idBitMsg outMsg;
|
|
byte msgBuf[952];
|
|
char string[MAX_STRING_CHARS];
|
|
|
|
if ( idAsyncNetwork::serverRemoteConsolePassword.GetString()[0] == '\0' ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04846" );
|
|
return;
|
|
}
|
|
|
|
msg.ReadString( string, sizeof( string ) );
|
|
|
|
if ( idStr::Icmp( string, idAsyncNetwork::serverRemoteConsolePassword.GetString() ) != 0 ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04847" );
|
|
return;
|
|
}
|
|
|
|
msg.ReadString( string, sizeof( string ) );
|
|
|
|
common->Printf( "rcon from %s: %s\n", Sys_NetAdrToString( from ), string );
|
|
|
|
rconAddress = from;
|
|
noRconOutput = true;
|
|
common->BeginRedirect( (char *)msgBuf, sizeof( msgBuf ), RConRedirect );
|
|
|
|
cmdSystem->BufferCommandText( CMD_EXEC_NOW, string );
|
|
|
|
common->EndRedirect();
|
|
|
|
if ( noRconOutput ) {
|
|
PrintOOB( rconAddress, SERVER_PRINT_RCON, "#str_04848" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessGetInfoMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessGetInfoMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
int i, challenge;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
if ( !IsActive() ) {
|
|
return;
|
|
}
|
|
|
|
common->DPrintf( "Sending info response to %s\n", Sys_NetAdrToString( from ) );
|
|
|
|
challenge = msg.ReadLong();
|
|
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "infoResponse" );
|
|
outMsg.WriteLong( challenge );
|
|
outMsg.WriteLong( ASYNC_PROTOCOL_VERSION );
|
|
outMsg.WriteDeltaDict( sessLocal.mapSpawnData.serverInfo, NULL );
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
continue;
|
|
}
|
|
|
|
outMsg.WriteByte( i );
|
|
outMsg.WriteShort( client.clientPing );
|
|
outMsg.WriteLong( client.channel.GetMaxOutgoingRate() );
|
|
outMsg.WriteString( sessLocal.mapSpawnData.userInfo[i].GetString( "ui_name", "Player" ) );
|
|
}
|
|
outMsg.WriteByte( MAX_ASYNC_CLIENTS );
|
|
outMsg.WriteLong( fileSystem->GetOSMask() );
|
|
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idAsyncServer::PrintLocalServerInfo
|
|
see (client) "getInfo" -> (server) "infoResponse" -> (client)ProcessGetInfoMessage
|
|
===============
|
|
*/
|
|
void idAsyncServer::PrintLocalServerInfo( void ) {
|
|
int i;
|
|
|
|
common->Printf( "server '%s' IP = %s\nprotocol %d.%d OS mask 0x%x\n",
|
|
sessLocal.mapSpawnData.serverInfo.GetString( "si_name" ),
|
|
Sys_NetAdrToString( serverPort.GetAdr() ),
|
|
ASYNC_PROTOCOL_MAJOR,
|
|
ASYNC_PROTOCOL_MINOR,
|
|
fileSystem->GetOSMask() );
|
|
sessLocal.mapSpawnData.serverInfo.Print();
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[i];
|
|
if ( client.clientState < SCS_CONNECTED ) {
|
|
continue;
|
|
}
|
|
common->Printf( "client %2d: %s, ping = %d, rate = %d\n", i,
|
|
sessLocal.mapSpawnData.userInfo[i].GetString( "ui_name", "Player" ),
|
|
client.clientPing, client.channel.GetMaxOutgoingRate() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ConnectionlessMessage
|
|
==================
|
|
*/
|
|
bool idAsyncServer::ConnectionlessMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
char string[MAX_STRING_CHARS*2]; // M. Quinn - Even Balance - PB Packets need more than 1024
|
|
|
|
msg.ReadString( string, sizeof( string ) );
|
|
|
|
// info request
|
|
if ( idStr::Icmp( string, "getInfo" ) == 0 ) {
|
|
ProcessGetInfoMessage( from, msg );
|
|
return false;
|
|
}
|
|
|
|
// remote console
|
|
if ( idStr::Icmp( string, "rcon" ) == 0 ) {
|
|
ProcessRemoteConsoleMessage( from, msg );
|
|
return true;
|
|
}
|
|
|
|
if ( !active ) {
|
|
PrintOOB( from, SERVER_PRINT_MISC, "#str_04849" );
|
|
return false;
|
|
}
|
|
|
|
// challenge from a client
|
|
if ( idStr::Icmp( string, "challenge" ) == 0 ) {
|
|
ProcessChallengeMessage( from, msg );
|
|
return false;
|
|
}
|
|
|
|
// connect from a client
|
|
if ( idStr::Icmp( string, "connect" ) == 0 ) {
|
|
ProcessConnectMessage( from, msg );
|
|
return false;
|
|
}
|
|
|
|
// pure mesasge from a client
|
|
if ( idStr::Icmp( string, "pureClient" ) == 0 ) {
|
|
ProcessPureMessage( from, msg );
|
|
return false;
|
|
}
|
|
|
|
// download request
|
|
if ( idStr::Icmp( string, "downloadRequest" ) == 0 ) {
|
|
ProcessDownloadRequestMessage( from, msg );
|
|
}
|
|
|
|
// auth server
|
|
if ( idStr::Icmp( string, "auth" ) == 0 ) {
|
|
if ( !Sys_CompareNetAdrBase( from, idAsyncNetwork::GetMasterAddress() ) ) {
|
|
common->Printf( "auth: bad source %s\n", Sys_NetAdrToString( from ) );
|
|
return false;
|
|
}
|
|
if ( idAsyncNetwork::LANServer.GetBool() ) {
|
|
common->Printf( "auth message from master. net_LANServer is enabled, ignored.\n" );
|
|
}
|
|
ProcessAuthMessage( msg );
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessMessage
|
|
==================
|
|
*/
|
|
bool idAsyncServer::ProcessMessage( const netadr_t from, idBitMsg &msg ) {
|
|
int i, id, sequence;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
id = msg.ReadShort();
|
|
|
|
// check for a connectionless message
|
|
if ( id == CONNECTIONLESS_MESSAGE_ID ) {
|
|
return ConnectionlessMessage( from, msg );
|
|
}
|
|
|
|
if ( msg.GetRemaingData() < 4 ) {
|
|
common->DPrintf( "%s: tiny packet\n", Sys_NetAdrToString( from ) );
|
|
return false;
|
|
}
|
|
|
|
// find out which client the message is from
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState == SCS_FREE ) {
|
|
continue;
|
|
}
|
|
|
|
// This does not compare the UDP port, because some address translating
|
|
// routers will change that at arbitrary times.
|
|
if ( !Sys_CompareNetAdrBase( from, client.channel.GetRemoteAddress() ) || id != client.clientId ) {
|
|
continue;
|
|
}
|
|
|
|
// make sure it is a valid, in sequence packet
|
|
if ( !client.channel.Process( from, serverTime, msg, sequence ) ) {
|
|
return false; // out of order, duplicated, fragment, etc.
|
|
}
|
|
|
|
// zombie clients still need to do the channel processing to make sure they don't
|
|
// need to retransmit the final reliable message, but they don't do any other processing
|
|
if ( client.clientState == SCS_ZOMBIE ) {
|
|
return false;
|
|
}
|
|
|
|
client.lastPacketTime = serverTime;
|
|
|
|
ProcessReliableClientMessages( i );
|
|
ProcessUnreliableClientMessage( i, msg );
|
|
|
|
return false;
|
|
}
|
|
|
|
// if we received a sequenced packet from an address we don't recognize,
|
|
// send an out of band disconnect packet to it
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "disconnect" );
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::SendReliableGameMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendReliableGameMessage( int clientNum, const idBitMsg &msg ) {
|
|
int i;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteByte( SERVER_RELIABLE_MESSAGE_GAME );
|
|
outMsg.WriteData( msg.GetData(), msg.GetSize() );
|
|
|
|
if ( clientNum >= 0 && clientNum < MAX_ASYNC_CLIENTS ) {
|
|
if ( clients[clientNum].clientState == SCS_INGAME ) {
|
|
SendReliableMessage( clientNum, outMsg );
|
|
}
|
|
return;
|
|
}
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState != SCS_INGAME ) {
|
|
continue;
|
|
}
|
|
SendReliableMessage( i, outMsg );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::LocalClientSendReliableMessageExcluding
|
|
==================
|
|
*/
|
|
void idAsyncServer::SendReliableGameMessageExcluding( int clientNum, const idBitMsg &msg ) {
|
|
int i;
|
|
idBitMsg outMsg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
|
|
assert( clientNum >= 0 && clientNum < MAX_ASYNC_CLIENTS );
|
|
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteByte( SERVER_RELIABLE_MESSAGE_GAME );
|
|
outMsg.WriteData( msg.GetData(), msg.GetSize() );
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( i == clientNum ) {
|
|
continue;
|
|
}
|
|
if ( clients[i].clientState != SCS_INGAME ) {
|
|
continue;
|
|
}
|
|
SendReliableMessage( i, outMsg );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::LocalClientSendReliableMessage
|
|
==================
|
|
*/
|
|
void idAsyncServer::LocalClientSendReliableMessage( const idBitMsg &msg ) {
|
|
if ( localClientNum < 0 ) {
|
|
common->Printf( "LocalClientSendReliableMessage: no local client\n" );
|
|
return;
|
|
}
|
|
game->ServerProcessReliableMessage( localClientNum, msg );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::ProcessConnectionLessMessages
|
|
==================
|
|
*/
|
|
void idAsyncServer::ProcessConnectionLessMessages( void ) {
|
|
int size, id;
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
netadr_t from;
|
|
|
|
if ( !serverPort.GetPort() ) {
|
|
return;
|
|
}
|
|
|
|
while( serverPort.GetPacket( from, msgBuf, size, sizeof( msgBuf ) ) ) {
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.SetSize( size );
|
|
msg.BeginReading();
|
|
id = msg.ReadShort();
|
|
if ( id == CONNECTIONLESS_MESSAGE_ID ) {
|
|
ConnectionlessMessage( from, msg );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::UpdateTime
|
|
==================
|
|
*/
|
|
int idAsyncServer::UpdateTime( int clamp ) {
|
|
int time, msec;
|
|
|
|
time = Sys_Milliseconds();
|
|
msec = idMath::ClampInt( 0, clamp, time - realTime );
|
|
realTime = time;
|
|
serverTime += msec;
|
|
return msec;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::RunFrame
|
|
==================
|
|
*/
|
|
void idAsyncServer::RunFrame( void ) {
|
|
int i, msec, size;
|
|
bool newPacket;
|
|
idBitMsg msg;
|
|
byte msgBuf[MAX_MESSAGE_SIZE];
|
|
netadr_t from;
|
|
int outgoingRate, incomingRate;
|
|
float outgoingCompression, incomingCompression;
|
|
|
|
msec = UpdateTime( 100 );
|
|
|
|
if ( !serverPort.GetPort() ) {
|
|
return;
|
|
}
|
|
|
|
if ( !active ) {
|
|
ProcessConnectionLessMessages();
|
|
return;
|
|
}
|
|
|
|
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 = serverPort.GetPacketBlocking( from, msgBuf, size, sizeof( msgBuf ), USERCMD_MSEC - gameTimeResidual - 1 );
|
|
if ( newPacket ) {
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.SetSize( size );
|
|
msg.BeginReading();
|
|
if ( ProcessMessage( from, msg ) ) {
|
|
return; // return because rcon was used
|
|
}
|
|
}
|
|
|
|
msec = UpdateTime( 100 );
|
|
gameTimeResidual += msec;
|
|
|
|
} while( newPacket );
|
|
|
|
} while( gameTimeResidual < USERCMD_MSEC );
|
|
|
|
// send heart beat to master servers
|
|
MasterHeartbeat();
|
|
|
|
// check for clients that timed out
|
|
CheckClientTimeouts();
|
|
|
|
if ( idAsyncNetwork::idleServer.GetBool() == ( !GetNumClients() || GetNumIdleClients() != GetNumClients() ) ) {
|
|
idAsyncNetwork::idleServer.SetBool( !idAsyncNetwork::idleServer.GetBool() );
|
|
// the need to propagate right away, only this
|
|
sessLocal.mapSpawnData.serverInfo.Set( "si_idleServer", idAsyncNetwork::idleServer.GetString() );
|
|
game->SetServerInfo( sessLocal.mapSpawnData.serverInfo );
|
|
}
|
|
|
|
// make sure the time doesn't wrap
|
|
if ( serverTime > 0x70000000 ) {
|
|
ExecuteMapChange();
|
|
return;
|
|
}
|
|
|
|
// check for synchronized cvar changes
|
|
if ( cvarSystem->GetModifiedFlags() & CVAR_NETWORKSYNC ) {
|
|
idDict newCvars;
|
|
newCvars = *cvarSystem->MoveCVarsToDict( CVAR_NETWORKSYNC );
|
|
SendSyncedCvarsBroadcast( newCvars );
|
|
cvarSystem->ClearModifiedFlags( CVAR_NETWORKSYNC );
|
|
}
|
|
|
|
// check for user info changes of the local client
|
|
if ( cvarSystem->GetModifiedFlags() & CVAR_USERINFO ) {
|
|
if ( localClientNum >= 0 ) {
|
|
idDict newInfo;
|
|
game->ThrottleUserInfo( );
|
|
newInfo = *cvarSystem->MoveCVarsToDict( CVAR_USERINFO );
|
|
SendUserInfoBroadcast( localClientNum, newInfo );
|
|
}
|
|
cvarSystem->ClearModifiedFlags( CVAR_USERINFO );
|
|
}
|
|
|
|
// advance the server game
|
|
while( gameTimeResidual >= USERCMD_MSEC ) {
|
|
|
|
// sample input for the local client
|
|
LocalClientInput();
|
|
|
|
// duplicate usercmds for clients if no new ones are available
|
|
DuplicateUsercmds( gameFrame, gameTime );
|
|
|
|
// advance game
|
|
gameReturn_t ret = game->RunFrame( userCmds[gameFrame & ( MAX_USERCMD_BACKUP - 1 ) ] );
|
|
|
|
idAsyncNetwork::ExecuteSessionCommand( ret.sessionCommand );
|
|
|
|
// update time
|
|
gameFrame++;
|
|
gameTime += USERCMD_MSEC;
|
|
gameTimeResidual -= USERCMD_MSEC;
|
|
}
|
|
|
|
// duplicate usercmds so there is always at least one available to send with snapshots
|
|
DuplicateUsercmds( gameFrame, gameTime );
|
|
|
|
// send snapshots to connected clients
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
serverClient_t &client = clients[i];
|
|
|
|
if ( client.clientState == SCS_FREE || i == localClientNum ) {
|
|
continue;
|
|
}
|
|
|
|
// modify maximum rate if necesary
|
|
if ( idAsyncNetwork::serverMaxClientRate.IsModified() ) {
|
|
client.channel.SetMaxOutgoingRate( Min( client.clientRate, idAsyncNetwork::serverMaxClientRate.GetInteger() ) );
|
|
}
|
|
|
|
// if the channel is not yet ready to send new data
|
|
if ( !client.channel.ReadyToSend( serverTime ) ) {
|
|
continue;
|
|
}
|
|
|
|
// send additional message fragments if the last message was too large to send at once
|
|
if ( client.channel.UnsentFragmentsLeft() ) {
|
|
client.channel.SendNextFragment( serverPort, serverTime );
|
|
continue;
|
|
}
|
|
|
|
if ( client.clientState == SCS_INGAME ) {
|
|
if ( !SendSnapshotToClient( i ) ) {
|
|
SendPingToClient( i );
|
|
}
|
|
} else {
|
|
SendEmptyToClient( i );
|
|
}
|
|
}
|
|
|
|
if ( com_showAsyncStats.GetBool() ) {
|
|
|
|
UpdateAsyncStatsAvg();
|
|
|
|
// dedicated will verbose to console
|
|
if ( idAsyncNetwork::serverDedicated.GetBool() && serverTime >= nextAsyncStatsTime ) {
|
|
common->Printf( "delay = %d msec, total outgoing rate = %d KB/s, total incoming rate = %d KB/s\n", GetDelay(),
|
|
GetOutgoingRate() >> 10, GetIncomingRate() >> 10 );
|
|
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
|
|
outgoingRate = GetClientOutgoingRate( i );
|
|
incomingRate = GetClientIncomingRate( i );
|
|
outgoingCompression = GetClientOutgoingCompression( i );
|
|
incomingCompression = GetClientIncomingCompression( i );
|
|
|
|
if ( outgoingRate != -1 && incomingRate != -1 ) {
|
|
common->Printf( "client %d: out rate = %d B/s (% -2.1f%%), in rate = %d B/s (% -2.1f%%)\n",
|
|
i, outgoingRate, outgoingCompression, incomingRate, incomingCompression );
|
|
}
|
|
}
|
|
|
|
idStr msg;
|
|
GetAsyncStatsAvgMsg( msg );
|
|
common->Printf( va( "%s\n", msg.c_str() ) );
|
|
|
|
nextAsyncStatsTime = serverTime + 1000;
|
|
}
|
|
}
|
|
|
|
idAsyncNetwork::serverMaxClientRate.ClearModified();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::PacifierUpdate
|
|
==================
|
|
*/
|
|
void idAsyncServer::PacifierUpdate( void ) {
|
|
int i;
|
|
|
|
if ( !IsActive() ) {
|
|
return;
|
|
}
|
|
realTime = Sys_Milliseconds();
|
|
ProcessConnectionLessMessages();
|
|
for ( i = 0; i < MAX_ASYNC_CLIENTS; i++ ) {
|
|
if ( clients[i].clientState >= SCS_PUREWAIT ) {
|
|
if ( clients[i].channel.UnsentFragmentsLeft() ) {
|
|
clients[i].channel.SendNextFragment( serverPort, serverTime );
|
|
} else {
|
|
SendEmptyToClient( i );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::PrintOOB
|
|
==================
|
|
*/
|
|
void idAsyncServer::PrintOOB( const netadr_t to, int opcode, const char *string ) {
|
|
idBitMsg outMsg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "print" );
|
|
outMsg.WriteLong( opcode );
|
|
outMsg.WriteString( string );
|
|
serverPort.SendPacket( to, outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idAsyncServer::MasterHeartbeat
|
|
==================
|
|
*/
|
|
void idAsyncServer::MasterHeartbeat( bool force ) {
|
|
if ( idAsyncNetwork::LANServer.GetBool() ) {
|
|
if ( force ) {
|
|
common->Printf( "net_LANServer is enabled. Not sending heartbeats\n" );
|
|
}
|
|
return;
|
|
}
|
|
if ( force ) {
|
|
nextHeartbeatTime = 0;
|
|
}
|
|
// not yet
|
|
if ( serverTime < nextHeartbeatTime ) {
|
|
return;
|
|
}
|
|
nextHeartbeatTime = serverTime + HEARTBEAT_MSEC;
|
|
for ( int i = 0 ; i < MAX_MASTER_SERVERS ; i++ ) {
|
|
netadr_t adr;
|
|
if ( idAsyncNetwork::GetMasterAddress( i, adr ) ) {
|
|
common->Printf( "Sending heartbeat to %s\n", Sys_NetAdrToString( adr ) );
|
|
idBitMsg outMsg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "heartbeat" );
|
|
serverPort.SendPacket( adr, outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idAsyncServer::SendEnterGameToClient
|
|
===============
|
|
*/
|
|
void idAsyncServer::SendEnterGameToClient( int clientNum ) {
|
|
idBitMsg msg;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
|
|
msg.Init( msgBuf, sizeof( msgBuf ) );
|
|
msg.WriteByte( SERVER_RELIABLE_MESSAGE_ENTERGAME );
|
|
SendReliableMessage( clientNum, msg );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idAsyncServer::UpdateAsyncStatsAvg
|
|
===============
|
|
*/
|
|
void idAsyncServer::UpdateAsyncStatsAvg( void ) {
|
|
stats_average_sum -= stats_outrate[ stats_current ];
|
|
stats_outrate[ stats_current ] = idAsyncNetwork::server.GetOutgoingRate();
|
|
if ( stats_outrate[ stats_current ] > stats_max ) {
|
|
stats_max = stats_outrate[ stats_current ];
|
|
stats_max_index = stats_current;
|
|
} else if ( stats_current == stats_max_index ) {
|
|
// find the new max
|
|
int i;
|
|
stats_max = 0;
|
|
for ( i = 0; i < stats_numsamples ; i++ ) {
|
|
if ( stats_outrate[ i ] > stats_max ) {
|
|
stats_max = stats_outrate[ i ];
|
|
stats_max_index = i;
|
|
}
|
|
}
|
|
}
|
|
stats_average_sum += stats_outrate[ stats_current ];
|
|
stats_current++; stats_current %= stats_numsamples;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idAsyncServer::GetAsyncStatsAvgMsg
|
|
===============
|
|
*/
|
|
void idAsyncServer::GetAsyncStatsAvgMsg( idStr &msg ) {
|
|
sprintf( msg, "avrg out: %d B/s - max %d B/s ( over %d ms )", stats_average_sum / stats_numsamples, stats_max, idAsyncNetwork::serverSnapshotDelay.GetInteger() * stats_numsamples );
|
|
}
|
|
|
|
/*
|
|
===============
|
|
idAsyncServer::ProcessDownloadRequestMessage
|
|
===============
|
|
*/
|
|
void idAsyncServer::ProcessDownloadRequestMessage( const netadr_t from, const idBitMsg &msg ) {
|
|
int challenge, clientId, iclient, numPaks, i;
|
|
int dlGamePak;
|
|
int dlPakChecksum;
|
|
int dlSize[ MAX_PURE_PAKS ]; // sizes
|
|
idStrList pakNames; // relative path
|
|
idStrList pakURLs; // game URLs
|
|
char pakbuf[ MAX_STRING_CHARS ];
|
|
idStr paklist;
|
|
byte msgBuf[ MAX_MESSAGE_SIZE ];
|
|
byte tmpBuf[ MAX_MESSAGE_SIZE ];
|
|
idBitMsg outMsg, tmpMsg;
|
|
int dlRequest;
|
|
int voidSlots = 0; // to count and verbose the right number of paks requested for downloads
|
|
|
|
challenge = msg.ReadLong();
|
|
clientId = msg.ReadShort();
|
|
dlRequest = msg.ReadLong();
|
|
|
|
if ( ( iclient = ValidateChallenge( from, challenge, clientId ) ) == -1 ) {
|
|
return;
|
|
}
|
|
|
|
if ( challenges[ iclient ].authState != CDK_PUREWAIT ) {
|
|
common->DPrintf( "client %s: got download request message, not in CDK_PUREWAIT\n", Sys_NetAdrToString( from ) );
|
|
return;
|
|
}
|
|
|
|
// the first token of the pak names list passed to the game will be empty if no game pak is requested
|
|
dlGamePak = msg.ReadLong();
|
|
if ( dlGamePak ) {
|
|
if ( !( dlSize[ 0 ] = fileSystem->ValidateDownloadPakForChecksum( dlGamePak, pakbuf, true ) ) ) {
|
|
common->Warning( "client requested unknown game pak 0x%x", dlGamePak );
|
|
pakbuf[ 0 ] = '\0';
|
|
voidSlots++;
|
|
}
|
|
} else {
|
|
pakbuf[ 0 ] = '\0';
|
|
voidSlots++;
|
|
}
|
|
pakNames.Append( pakbuf );
|
|
numPaks = 1;
|
|
|
|
// read the checksums, build path names and pass that to the game code
|
|
dlPakChecksum = msg.ReadLong();
|
|
while ( dlPakChecksum ) {
|
|
if ( !( dlSize[ numPaks ] = fileSystem->ValidateDownloadPakForChecksum( dlPakChecksum, pakbuf, false ) ) ) {
|
|
// we pass an empty token to the game so our list doesn't get offset
|
|
common->Warning( "client requested an unknown pak 0x%x", dlPakChecksum );
|
|
pakbuf[ 0 ] = '\0';
|
|
voidSlots++;
|
|
}
|
|
pakNames.Append( pakbuf );
|
|
numPaks++;
|
|
dlPakChecksum = msg.ReadLong();
|
|
}
|
|
|
|
for ( i = 0; i < pakNames.Num(); i++ ) {
|
|
if ( i > 0 ) {
|
|
paklist += ";";
|
|
}
|
|
paklist += pakNames[ i ].c_str();
|
|
}
|
|
|
|
// read the message and pass it to the game code
|
|
common->DPrintf( "got download request for %d paks - %s\n", numPaks - voidSlots, paklist.c_str() );
|
|
|
|
outMsg.Init( msgBuf, sizeof( msgBuf ) );
|
|
outMsg.WriteShort( CONNECTIONLESS_MESSAGE_ID );
|
|
outMsg.WriteString( "downloadInfo" );
|
|
outMsg.WriteLong( dlRequest );
|
|
if ( !game->DownloadRequest( Sys_NetAdrToString( from ), challenges[ iclient ].guid, paklist.c_str(), pakbuf ) ) {
|
|
common->DPrintf( "game: no downloads\n" );
|
|
outMsg.WriteByte( SERVER_DL_NONE );
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
return;
|
|
}
|
|
|
|
char *token, *next;
|
|
int type = 0;
|
|
|
|
token = pakbuf;
|
|
next = strchr( token, ';' );
|
|
while ( token ) {
|
|
if ( next ) {
|
|
*next = '\0';
|
|
}
|
|
|
|
if ( type == 0 ) {
|
|
type = atoi( token );
|
|
} else if ( type == SERVER_DL_REDIRECT ) {
|
|
common->DPrintf( "download request: redirect to URL %s\n", token );
|
|
outMsg.WriteByte( SERVER_DL_REDIRECT );
|
|
outMsg.WriteString( token );
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
return;
|
|
} else if ( type == SERVER_DL_LIST ) {
|
|
pakURLs.Append( token );
|
|
} else {
|
|
common->DPrintf( "wrong op type %d\n", type );
|
|
next = token = NULL;
|
|
}
|
|
|
|
if ( next ) {
|
|
token = next + 1;
|
|
next = strchr( token, ';' );
|
|
} else {
|
|
token = NULL;
|
|
}
|
|
}
|
|
|
|
if ( type == SERVER_DL_LIST ) {
|
|
int totalDlSize = 0;
|
|
int numActualPaks = 0;
|
|
|
|
// put the answer packet together
|
|
outMsg.WriteByte( SERVER_DL_LIST );
|
|
|
|
tmpMsg.Init( tmpBuf, MAX_MESSAGE_SIZE );
|
|
|
|
for ( i = 0; i < pakURLs.Num(); i++ ) {
|
|
tmpMsg.BeginWriting();
|
|
if ( !dlSize[ i ] || !pakURLs[ i ].Length() ) {
|
|
// still send the relative path so the client knows what it missed
|
|
tmpMsg.WriteByte( SERVER_PAK_NO );
|
|
tmpMsg.WriteString( pakNames[ i ] );
|
|
} else {
|
|
totalDlSize += dlSize[ i ];
|
|
numActualPaks++;
|
|
tmpMsg.WriteByte( SERVER_PAK_YES );
|
|
tmpMsg.WriteString( pakNames[ i ] );
|
|
tmpMsg.WriteString( pakURLs[ i ] );
|
|
tmpMsg.WriteLong( dlSize[ i ] );
|
|
}
|
|
|
|
// keep last 5 bytes for an 'end of message' - SERVER_PAK_END and the totalDlSize long
|
|
if ( outMsg.GetRemainingSpace() - tmpMsg.GetSize() > 5 ) {
|
|
outMsg.WriteData( tmpMsg.GetData(), tmpMsg.GetSize() );
|
|
} else {
|
|
outMsg.WriteByte( SERVER_PAK_END );
|
|
break;
|
|
}
|
|
}
|
|
if ( i == pakURLs.Num() ) {
|
|
// put a closure even if size not exceeded
|
|
outMsg.WriteByte( SERVER_PAK_END );
|
|
}
|
|
common->DPrintf( "download request: download %d paks, %d bytes\n", numActualPaks, totalDlSize );
|
|
|
|
serverPort.SendPacket( from, outMsg.GetData(), outMsg.GetSize() );
|
|
}
|
|
}
|