Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

722 lines
18 KiB

//======177== (C) Copyright 1999, 2000 Valve, L.L.C. All rights reserved. ========
//
// The copyright to the contents herein is the property of Valve, L.L.C.
// The contents may be used and/or copied only with the written permission of
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose:
//
// $Workfile: $
// $Date: $
// $NoKeywords: $
//=============================================================================
#include "quakedef.h"
#include "server.h"
#include "master.h"
#include "proto_oob.h"
#include "host.h"
#include "eiface.h"
#include "server.h"
#include "utlmap.h"
extern ConVar sv_tags;
extern ConVar sv_lan;
#define S2A_EXTRA_DATA_HAS_GAMETAG_DATA 0x01 // Next bytes are the game tag string
#define RETRY_INFO_REQUEST_TIME 0.4 // seconds
#define MASTER_RESPONSE_TIMEOUT 1.5 // seconds
#define INFO_REQUEST_TIMEOUT 5.0 // seconds
static char g_MasterServers[][64] =
{
"185.192.97.130:27010",
"168.138.92.21:27016"
};
#ifdef DEDICATED
#define IsLan() false
#else
#define IsLan() sv_lan.GetInt()
#endif
//-----------------------------------------------------------------------------
// Purpose: List of master servers and some state info about them
//-----------------------------------------------------------------------------
typedef struct adrlist_s
{
// Next master in chain
struct adrlist_s *next;
// Challenge request sent to master
qboolean heartbeatwaiting;
// Challenge request send time
float heartbeatwaitingtime;
// Last one is Main master
int heartbeatchallenge;
// Time we sent last heartbeat
double last_heartbeat;
// Master server address
netadr_t adr;
} adrlist_t;
//-----------------------------------------------------------------------------
// Purpose: Implements the master server interface
//-----------------------------------------------------------------------------
class CMaster : public IMaster, public IServersInfo
{
public:
CMaster( void );
virtual ~CMaster( void );
// Heartbeat functions.
void Init( void );
void Shutdown( void );
// Sets up master address
void ShutdownConnection(void);
void SendHeartbeat( struct adrlist_s *p );
void AddServer( struct netadr_s *adr );
void UseDefault ( void );
void CheckHeartbeat (void);
void RespondToHeartbeatChallenge( netadr_t &from, bf_read &msg );
void PingServer( netadr_t &svadr );
void ProcessConnectionlessPacket( netpacket_t *packet );
void AddMaster_f( const CCommand &args );
void Heartbeat_f( void );
void RunFrame();
void RetryServersInfoRequest();
void ReplyInfo( const netadr_t &adr, uint sequence );
newgameserver_t &ProcessInfo( bf_read &buf );
// SeversInfo
void RequestInternetServerList( const char *gamedir, IServerListResponse *response );
void RequestLANServerList( const char *gamedir, IServerListResponse *response );
void AddServerAddresses( netadr_t **adr, int count );
void RequestServerInfo( const netadr_t &adr );
void StopRefresh();
private:
// List of known master servers
adrlist_t *m_pMasterAddresses;
bool m_bInitialized;
bool m_bRefreshing;
int m_iServersResponded;
double m_flStartRequestTime;
double m_flRetryRequestTime;
double m_flMasterRequestTime;
uint m_iInfoSequence;
char m_szGameDir[256];
// If nomaster is true, the server will not send heartbeats to the master server
bool m_bNoMasters;
CUtlMap<netadr_t, bool> m_serverAddresses;
CUtlMap<uint, double> m_serversRequestTime;
IServerListResponse *m_serverListResponse;
};
static CMaster s_MasterServer;
IMaster *master = (IMaster *)&s_MasterServer;
IServersInfo *g_pServersInfo = (IServersInfo*)&s_MasterServer;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CMaster, IServersInfo, SERVERLIST_INTERFACE_VERSION, s_MasterServer );
#define HEARTBEAT_SECONDS 140.0
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CMaster::CMaster( void )
{
m_pMasterAddresses = NULL;
m_bNoMasters = false;
m_bInitialized = false;
m_iServersResponded = 0;
m_serverListResponse = NULL;
SetDefLessFunc( m_serverAddresses );
SetDefLessFunc( m_serversRequestTime );
m_bRefreshing = false;
m_iInfoSequence = 1;
Init();
}
CMaster::~CMaster( void )
{
}
void CMaster::RunFrame()
{
CheckHeartbeat();
if( !m_bRefreshing )
return;
if( m_serverListResponse &&
m_flStartRequestTime < Plat_FloatTime()-INFO_REQUEST_TIMEOUT )
{
StopRefresh();
m_serverListResponse->RefreshComplete( NServerResponse::nServerFailedToRespond );
return;
}
if( m_iServersResponded > 0 &&
m_iServersResponded >= m_serverAddresses.Count() &&
m_flMasterRequestTime < Plat_FloatTime() - MASTER_RESPONSE_TIMEOUT )
{
StopRefresh();
m_serverListResponse->RefreshComplete( NServerResponse::nServerResponded );
return;
}
if( m_flRetryRequestTime < Plat_FloatTime() - RETRY_INFO_REQUEST_TIME )
{
m_flRetryRequestTime = Plat_FloatTime();
if( m_serverAddresses.Count() == 0 ) // Retry masterserver request
{
g_pServersInfo->RequestInternetServerList(m_szGameDir, NULL);
return;
}
if( m_iServersResponded < m_serverAddresses.Count() )
RetryServersInfoRequest();
}
}
void CMaster::StopRefresh()
{
if( !m_bRefreshing )
return;
m_iServersResponded = 0;
m_bRefreshing = false;
m_serverAddresses.RemoveAll();
m_serversRequestTime.RemoveAll();
}
void CMaster::ReplyInfo( const netadr_t &adr, uint sequence )
{
static char gamedir[MAX_OSPATH];
Q_FileBase( com_gamedir, gamedir, sizeof( gamedir ) );
CUtlBuffer buf;
buf.EnsureCapacity( 2048 );
buf.PutUnsignedInt( LittleDWord( CONNECTIONLESS_HEADER ) );
buf.PutUnsignedChar( S2C_INFOREPLY );
buf.PutUnsignedInt(sequence);
buf.PutUnsignedChar( PROTOCOL_VERSION ); // Hardcoded protocol version number
buf.PutString( sv.GetName() );
buf.PutString( sv.GetMapName() );
buf.PutString( gamedir );
buf.PutString( serverGameDLL->GetGameDescription() );
// player info
buf.PutUnsignedChar( sv.GetNumClients() );
buf.PutUnsignedChar( sv.GetMaxClients() );
buf.PutUnsignedChar( sv.GetNumFakeClients() );
// Password?
buf.PutUnsignedChar( sv.GetPassword() != NULL ? 1 : 0 );
// Write a byte with some flags that describe what is to follow.
const char *pchTags = sv_tags.GetString();
int nFlags = 0;
if ( pchTags && pchTags[0] != '\0' )
nFlags |= S2A_EXTRA_DATA_HAS_GAMETAG_DATA;
buf.PutUnsignedInt( nFlags );
if ( nFlags & S2A_EXTRA_DATA_HAS_GAMETAG_DATA )
buf.PutString( pchTags );
NET_SendPacket( NULL, NS_SERVER, adr, (unsigned char *)buf.Base(), buf.TellPut() );
}
newgameserver_t &CMaster::ProcessInfo(bf_read &buf)
{
static newgameserver_t s;
memset( &s, 0, sizeof(s) );
s.m_nProtocolVersion = buf.ReadByte();
buf.ReadString( s.m_szServerName, sizeof(s.m_szServerName) );
buf.ReadString( s.m_szMap, sizeof(s.m_szMap) );
buf.ReadString( s.m_szGameDir, sizeof(s.m_szGameDir) );
buf.ReadString( s.m_szGameDescription, sizeof(s.m_szGameDescription) );
// player info
s.m_nPlayers = buf.ReadByte();
s.m_nMaxPlayers = buf.ReadByte();
s.m_nBotPlayers = buf.ReadByte();
// Password?
s.m_bPassword = buf.ReadByte();
s.m_iFlags = buf.ReadLong();
if( s.m_iFlags & S2A_EXTRA_DATA_HAS_GAMETAG_DATA )
{
buf.ReadString( s.m_szGameTags, sizeof(s.m_szGameTags) );
}
return s;
}
void CMaster::ProcessConnectionlessPacket( netpacket_t *packet )
{
static ALIGN4 char string[2048] ALIGN4_POST; // Buffer for sending heartbeat
uint ip; uint16 port;
bf_read msg = packet->message;
char c = msg.ReadChar();
if ( c == 0 )
return;
switch( c )
{
case M2S_CHALLENGE:
{
RespondToHeartbeatChallenge( packet->from, msg );
break;
}
case M2C_QUERY:
{
if( !m_bRefreshing )
break;
ip = msg.ReadLong();
port = msg.ReadShort();
while( ip != 0 && port != 0 )
{
netadr_t adr(ip, port);
unsigned short index = m_serverAddresses.Find(adr);
if( index != m_serverAddresses.InvalidIndex() )
{
ip = msg.ReadLong();
port = msg.ReadShort();
continue;
}
m_serverAddresses.Insert(adr, false);
RequestServerInfo(adr);
ip = msg.ReadLong();
port = msg.ReadShort();
}
break;
}
case C2S_INFOREQUEST:
{
ReplyInfo(packet->from, msg.ReadLong());
break;
}
case S2C_INFOREPLY:
{
if( !m_bRefreshing )
break;
uint sequence = msg.ReadLong();
newgameserver_t &s = ProcessInfo( msg );
unsigned short index = m_serverAddresses.Find(packet->from);
unsigned short rindex = m_serversRequestTime.Find(sequence);
if( index == m_serverAddresses.InvalidIndex() ||
rindex == m_serversRequestTime.InvalidIndex() )
break;
double requestTime = m_serversRequestTime[rindex];
if( m_serverAddresses[index] ) // shit happens
return;
m_serverAddresses[index] = true;
s.m_nPing = (Plat_FloatTime()-requestTime)*1000.0;
s.m_NetAdr = packet->from;
m_serverListResponse->ServerResponded( s );
m_iServersResponded++;
break;
}
}
}
void CMaster::RequestServerInfo( const netadr_t &adr )
{
static ALIGN4 char string[256] ALIGN4_POST; // Buffer for sending heartbeat
bf_write msg( string, sizeof(string) );
msg.WriteLong( CONNECTIONLESS_HEADER );
msg.WriteByte( C2S_INFOREQUEST );
msg.WriteLong( m_iInfoSequence );
m_serversRequestTime.Insert(m_iInfoSequence, Plat_FloatTime());
m_iInfoSequence++;
NET_SendPacket( NULL, NS_CLIENT, adr, msg.GetData(), msg.GetNumBytesWritten() );
}
void CMaster::RetryServersInfoRequest()
{
FOR_EACH_MAP_FAST( m_serverAddresses, i )
{
bool bResponded = m_serverAddresses.Element(i);
if( bResponded )
continue;
const netadr_t adr = m_serverAddresses.Key(i);
RequestServerInfo( adr );
}
}
//-----------------------------------------------------------------------------
// Purpose: Sends a heartbeat to the master server
// Input : *p - x00\x00\x00\x00\x00\x00
//-----------------------------------------------------------------------------
void CMaster::SendHeartbeat ( adrlist_t *p )
{
static ALIGN4 char string[256] ALIGN4_POST; // Buffer for sending heartbeat
char szGD[ MAX_OSPATH ];
if ( !p )
return;
// Still waiting on challenge response?
if ( p->heartbeatwaiting )
return;
// Waited too long
if ( (realtime - p->heartbeatwaitingtime ) >= HB_TIMEOUT )
return;
// Send to master
Q_FileBase( com_gamedir, szGD, sizeof( szGD ) );
bf_write buf( string, sizeof(string) );
buf.WriteByte( S2M_HEARTBEAT );
buf.WriteLong( p->heartbeatchallenge );
buf.WriteShort( PROTOCOL_VERSION );
buf.WriteString( szGD );
NET_SendPacket( NULL, NS_SERVER, p->adr, buf.GetData(), buf.GetNumBytesWritten() );
}
//-----------------------------------------------------------------------------
// Purpose: Requests a challenge so we can then send a heartbeat
//-----------------------------------------------------------------------------
void CMaster::CheckHeartbeat (void)
{
adrlist_t *p;
ALIGN4 char buf[256] ALIGN4_POST;
if ( m_bNoMasters || // We are ignoring heartbeats
IsLan() || // Lan servers don't heartbeat
(sv.GetMaxClients() <= 1) || // not a multiplayer server.
!sv.IsActive() ) // only heartbeat if a server is running.
return;
p = m_pMasterAddresses;
while ( p )
{
// Time for another try?
if ( ( realtime - p->last_heartbeat) < HEARTBEAT_SECONDS) // not time to send yet
{
p = p->next;
continue;
}
// Should we resend challenge request?
if ( p->heartbeatwaiting &&
( ( realtime - p->heartbeatwaitingtime ) < HB_TIMEOUT ) )
{
p = p->next;
continue;
}
int32 challenge = RandomInt( 0, INT_MAX );
p->heartbeatwaiting = true;
p->heartbeatwaitingtime = realtime;
p->last_heartbeat = realtime; // Flag at start so we don't just keep trying for hb's when
p->heartbeatchallenge = challenge;
bf_write msg("Master Join", buf, sizeof(buf));
msg.WriteByte( S2M_GETCHALLENGE );
msg.WriteLong( challenge );
// Send to master asking for a challenge #
NET_SendPacket( NULL, NS_SERVER, p->adr, msg.GetData(), msg.GetNumBytesWritten() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Server is shutting down, unload master servers list, tell masters that we are closing the server
//-----------------------------------------------------------------------------
void CMaster::ShutdownConnection( void )
{
adrlist_t *p;
if ( !host_initialized )
return;
if ( m_bNoMasters || // We are ignoring heartbeats
IsLan() || // Lan servers don't heartbeat
(sv.GetMaxClients() <= 1) ) // not a multiplayer server.
return;
const char packet = S2M_SHUTDOWN;
p = m_pMasterAddresses;
while ( p )
{
NET_SendPacket( NULL, NS_SERVER, p->adr, (unsigned char*)&packet, 1);
p->last_heartbeat = -99999.0;
p = p->next;
}
}
//-----------------------------------------------------------------------------
// Purpose: Add server to the master list
// Input : *adr -
//-----------------------------------------------------------------------------
void CMaster::AddServer( netadr_t *adr )
{
adrlist_t *n;
// See if it's there
n = m_pMasterAddresses;
while ( n )
{
if ( n->adr.CompareAdr( *adr ) )
break;
n = n->next;
}
// Found it in the list.
if ( n )
return;
n = ( adrlist_t * ) malloc ( sizeof( adrlist_t ) );
if ( !n )
Sys_Error( "Error allocating %zd bytes for master address.", sizeof( adrlist_t ) );
memset( n, 0, sizeof( adrlist_t ) );
n->adr = *adr;
// Queue up a full heartbeat to all master servers.
n->last_heartbeat = -99999.0;
// Link it in.
n->next = m_pMasterAddresses;
m_pMasterAddresses = n;
}
//-----------------------------------------------------------------------------
// Purpose: Add built-in default master if woncomm.lst doesn't parse
//-----------------------------------------------------------------------------
void CMaster::UseDefault ( void )
{
netadr_t adr;
for( int i = 0; i < ARRAYSIZE(g_MasterServers);i++ )
{
// Convert to netadr_t
if ( NET_StringToAdr ( g_MasterServers[i], &adr ) )
{
// Add to master list
AddServer( &adr );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMaster::RespondToHeartbeatChallenge( netadr_t &from, bf_read &msg )
{
adrlist_t *p;
uint challenge, challenge2;
// No masters, just ignore.
if ( !m_pMasterAddresses )
return;
p = m_pMasterAddresses;
while ( p )
{
if ( from.CompareAdr( p->adr ) )
break;
p = p->next;
}
// Not a known master server.
if ( !p )
return;
challenge = msg.ReadLong();
challenge2 = msg.ReadLong();
if( p->heartbeatchallenge != challenge2 )
{
Warning("unexpected master server info query packet (wrong challenge!)\n");
return;
}
// Kill timer
p->heartbeatwaiting = false;
p->heartbeatchallenge = challenge;
// Send the actual heartbeat request to this master server.
SendHeartbeat( p );
}
//-----------------------------------------------------------------------------
// Purpose: Add/remove master servers
//-----------------------------------------------------------------------------
void CMaster::AddMaster_f ( const CCommand &args )
{
CUtlString cmd( ( args.ArgC() > 1 ) ? args[ 1 ] : "" );
netadr_t adr;
if( !NET_StringToAdr(cmd.String(), &adr) )
{
Warning("Invalid address\n");
return;
}
this->AddServer(&adr);
}
//-----------------------------------------------------------------------------
// Purpose: Send a new heartbeat to the master
//-----------------------------------------------------------------------------
void CMaster::Heartbeat_f (void)
{
adrlist_t *p;
p = m_pMasterAddresses;
while ( p )
{
// Queue up a full hearbeat
p->last_heartbeat = -9999.0;
p->heartbeatwaitingtime = -9999.0;
p = p->next;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void AddMaster_f( const CCommand &args )
{
master->AddMaster_f( args );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void Heartbeat1_f( void )
{
master->Heartbeat_f();
}
static ConCommand setmaster("addmaster", AddMaster_f );
static ConCommand heartbeat("heartbeat", Heartbeat1_f, "Force heartbeat of master servers" );
//-----------------------------------------------------------------------------
// Purpose: Adds master server console commands
//-----------------------------------------------------------------------------
void CMaster::Init( void )
{
// Already able to initialize at least once?
if ( m_bInitialized )
return;
// So we don't do this a send time.sv_mas
m_bInitialized = true;
UseDefault();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMaster::Shutdown(void)
{
adrlist_t *p, *n;
// Free the master list now.
p = m_pMasterAddresses;
while ( p )
{
n = p->next;
free( p );
p = n;
}
m_pMasterAddresses = NULL;
}
// ServersInfo
void CMaster::RequestInternetServerList(const char *gamedir, IServerListResponse *response)
{
if( m_bNoMasters ) return;
strncpy( m_szGameDir, gamedir, sizeof(m_szGameDir) );
if( response )
{
StopRefresh();
m_bRefreshing = true;
m_serverListResponse = response;
m_flRetryRequestTime = m_flStartRequestTime = m_flMasterRequestTime = Plat_FloatTime();
}
ALIGN4 char buf[256] ALIGN4_POST;
bf_write msg(buf, sizeof(buf));
msg.WriteByte( C2M_CLIENTQUERY );
msg.WriteString(gamedir);
adrlist_t *p;
p = m_pMasterAddresses;
while ( p )
{
NET_SendPacket(NULL, NS_CLIENT, p->adr, msg.GetData(), msg.GetNumBytesWritten() );
p = p->next;
}
}
void CMaster::RequestLANServerList(const char *gamedir, IServerListResponse *response)
{
}
void CMaster::AddServerAddresses( netadr_t **adr, int count )
{
}