2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: baseclientstate.cpp: implementation of the CBaseClientState class.
//
//===============================================================================
# include "client_pch.h"
# include "baseclientstate.h"
# include "vstdlib/random.h"
# include <inetchannel.h>
# include <netmessages.h>
# include <proto_oob.h>
# include <ctype.h>
# include "cl_main.h"
# include "net.h"
# include "dt_recv_eng.h"
# include "ents_shared.h"
# include "net_synctags.h"
# include "filesystem_engine.h"
# include "host_cmd.h"
# include "GameEventManager.h"
# include "sv_rcon.h"
# include "cl_rcon.h"
# ifndef SWDS
# include "vgui_baseui_interface.h"
# include "cl_pluginhelpers.h"
# include "vgui_askconnectpanel.h"
# endif
# include "sv_steamauth.h"
# include "tier0/icommandline.h"
# include "tier0/vcrmode.h"
# include "snd_audio_source.h"
# include "cl_steamauth.h"
# include "server.h"
# include "steam/steam_api.h"
# include "matchmaking.h"
# include "sv_plugin.h"
# include "sys_dll.h"
# include "host.h"
# if defined( REPLAY_ENABLED )
# include "replay_internal.h"
# include "replayserver.h"
# endif
// memdbgon must be the last include file in a .cpp file!!!
# include "tier0/memdbgon.h"
# ifdef ENABLE_RPT
void CL_NotifyRPTOfDisconnect ( ) ;
# endif // ENABLE_RPT
# if !defined( NO_STEAM )
void UpdateNameFromSteamID ( IConVar * pConVar , CSteamID * pSteamID )
{
# ifndef SWDS
if ( ! pConVar | | ! pSteamID | | ! Steam3Client ( ) . SteamFriends ( ) )
return ;
const char * pszName = Steam3Client ( ) . SteamFriends ( ) - > GetFriendPersonaName ( * pSteamID ) ;
pConVar - > SetValue ( pszName ) ;
# endif // SWDS
}
void SetNameToSteamIDName ( IConVar * pConVar )
{
# ifndef SWDS
if ( Steam3Client ( ) . SteamUtils ( ) & & Steam3Client ( ) . SteamFriends ( ) & & Steam3Client ( ) . SteamUser ( ) )
{
CSteamID steamID = Steam3Client ( ) . SteamUser ( ) - > GetSteamID ( ) ;
UpdateNameFromSteamID ( pConVar , & steamID ) ;
}
# endif // SWDS
}
# endif // NO_STEAM
void CL_NameCvarChanged ( IConVar * pConVar , const char * pOldString , float flOldValue )
{
ConVarRef var ( pConVar ) ;
static bool bPreventRent = false ;
if ( ! bPreventRent )
{
bPreventRent = true ;
# if !defined( NO_STEAM )
SetNameToSteamIDName ( pConVar ) ;
# endif
// Remove any evil characters (ex: zero width no-break space)
char pchName [ MAX_PLAYER_NAME_LENGTH ] ;
V_strcpy_safe ( pchName , var . GetString ( ) ) ;
Q_RemoveAllEvilCharacters ( pchName ) ;
pConVar - > SetValue ( pchName ) ;
// store off the last known name, that isn't default, in the registry
// this is a transition step so it can be used to display in friends
if ( 0 ! = Q_stricmp ( var . GetString ( ) , var . GetDefault ( ) )
& & 0 ! = Q_stricmp ( var . GetString ( ) , " player " ) )
{
Sys_SetRegKeyValue ( " Software \\ Valve \\ Steam " , " LastGameNameUsed " , var . GetString ( ) ) ;
}
bPreventRent = false ;
}
}
# ifndef SWDS
void askconnect_accept_f ( )
{
char szHostName [ 256 ] ;
if ( IsAskConnectPanelActive ( szHostName , sizeof ( szHostName ) ) )
{
char szCommand [ 512 ] ;
V_snprintf ( szCommand , sizeof ( szCommand ) , " connect %s redirect " , szHostName ) ;
Cbuf_AddText ( szCommand ) ;
HideAskConnectPanel ( ) ;
}
}
ConCommand askconnect_accept ( " askconnect_accept " , askconnect_accept_f , " Accept a redirect request by the server. " , FCVAR_DONTRECORD ) ;
# endif
# ifndef SWDS
extern IVEngineClient * engineClient ;
// ---------------------------------------------------------------------------------------- //
static void SendClanTag ( const char * pTag )
{
KeyValues * kv = new KeyValues ( " ClanTagChanged " ) ;
kv - > SetString ( " tag " , pTag ) ;
engineClient - > ServerCmdKeyValues ( kv ) ;
}
# endif
// ---------------------------------------------------------------------------------------- //
void CL_ClanIdChanged ( IConVar * pConVar , const char * pOldString , float flOldValue )
{
# ifndef SWDS
// Get the clan ID we're trying to select
ConVarRef var ( pConVar ) ;
uint32 newId = var . GetInt ( ) ;
if ( newId = = 0 )
{
// Default value, equates to no tag
SendClanTag ( " " ) ;
return ;
}
# if !defined( NO_STEAM )
// Make sure this player is actually part of the desired clan
ISteamFriends * pFriends = Steam3Client ( ) . SteamFriends ( ) ;
if ( pFriends )
{
int iGroupCount = pFriends - > GetClanCount ( ) ;
for ( int k = 0 ; k < iGroupCount ; + + k )
{
CSteamID clanID = pFriends - > GetClanByIndex ( k ) ;
if ( clanID . GetAccountID ( ) = = newId )
{
// valid clan, accept the change
CSteamID clanIDNew ( newId , Steam3Client ( ) . SteamUtils ( ) - > GetConnectedUniverse ( ) , k_EAccountTypeClan ) ;
SendClanTag ( pFriends - > GetClanTag ( clanIDNew ) ) ;
return ;
}
}
}
# endif // NO_STEAM
// Couldn't validate the ID, so clear to the default (no tag)
var . SetValue ( 0 ) ;
# endif // !SWDS
}
ConVar cl_resend ( " cl_resend " , " 6 " , FCVAR_NONE , " Delay in seconds before the client will resend the 'connect' attempt " , true , CL_MIN_RESEND_TIME , true , CL_MAX_RESEND_TIME ) ;
ConVar cl_name ( " name " , " unnamed " , FCVAR_ARCHIVE | FCVAR_USERINFO | FCVAR_PRINTABLEONLY | FCVAR_SERVER_CAN_EXECUTE , " Current user name " , CL_NameCvarChanged ) ;
ConVar password ( " password " , " " , FCVAR_ARCHIVE | FCVAR_SERVER_CANNOT_QUERY | FCVAR_DONTRECORD , " Current server access password " ) ;
ConVar cl_interpolate ( " cl_interpolate " , " 1.0 " , FCVAR_USERINFO | FCVAR_DEVELOPMENTONLY | FCVAR_NOT_CONNECTED , " Interpolate entities on the client. " ) ;
ConVar cl_clanid ( " cl_clanid " , " 0 " , FCVAR_ARCHIVE | FCVAR_USERINFO | FCVAR_HIDDEN , " Current clan ID for name decoration " , CL_ClanIdChanged ) ;
ConVar cl_show_connectionless_packet_warnings ( " cl_show_connectionless_packet_warnings " , " 0 " , FCVAR_NONE , " Show console messages about ignored connectionless packets on the client. " ) ;
// ---------------------------------------------------------------------------------------- //
// C_ServerClassInfo implementation.
// ---------------------------------------------------------------------------------------- //
C_ServerClassInfo : : C_ServerClassInfo ( )
{
m_ClassName = NULL ;
m_DatatableName = NULL ;
m_InstanceBaselineIndex = INVALID_STRING_INDEX ;
}
C_ServerClassInfo : : ~ C_ServerClassInfo ( )
{
delete [ ] m_ClassName ;
delete [ ] m_DatatableName ;
}
// Returns false if you should stop reading entities.
inline static bool CL_DetermineUpdateType ( CEntityReadInfo & u )
{
if ( ! u . m_bIsEntity | | ( u . m_nNewEntity > u . m_nOldEntity ) )
{
// If we're at the last entity, preserve whatever entities followed it in the old packet.
// If newnum > oldnum, then the server skipped sending entities that it wants to leave the state alone for.
if ( ! u . m_pFrom | | ( u . m_nOldEntity > u . m_pFrom - > last_entity ) )
{
Assert ( ! u . m_bIsEntity ) ;
u . m_UpdateType = Finished ;
return false ;
}
// Preserve entities until we reach newnum (ie: the server didn't send certain entities because
// they haven't changed).
u . m_UpdateType = PreserveEnt ;
}
else
{
if ( u . m_UpdateFlags & FHDR_ENTERPVS )
{
u . m_UpdateType = EnterPVS ;
}
else if ( u . m_UpdateFlags & FHDR_LEAVEPVS )
{
u . m_UpdateType = LeavePVS ;
}
else
{
u . m_UpdateType = DeltaEnt ;
}
}
return true ;
}
//-----------------------------------------------------------------------------
// Purpose: When a delta command is received from the server
// We need to grab the entity # out of it any the bit settings, too.
// Returns -1 if there are no more entities.
// Input : &bRemove -
// &bIsNew -
// Output : int
//-----------------------------------------------------------------------------
static inline void CL_ParseDeltaHeader ( CEntityReadInfo & u )
{
u . m_UpdateFlags = FHDR_ZERO ;
# ifdef DEBUG_NETWORKING
int startbit = u . m_pBuf - > GetNumBitsRead ( ) ;
# endif
SyncTag_Read ( u . m_pBuf , " Hdr " ) ;
u . m_nNewEntity = u . m_nHeaderBase + 1 + u . m_pBuf - > ReadUBitVar ( ) ;
u . m_nHeaderBase = u . m_nNewEntity ;
// leave pvs flag
if ( u . m_pBuf - > ReadOneBit ( ) = = 0 )
{
// enter pvs flag
if ( u . m_pBuf - > ReadOneBit ( ) ! = 0 )
{
u . m_UpdateFlags | = FHDR_ENTERPVS ;
}
}
else
{
u . m_UpdateFlags | = FHDR_LEAVEPVS ;
// Force delete flag
if ( u . m_pBuf - > ReadOneBit ( ) ! = 0 )
{
u . m_UpdateFlags | = FHDR_DELETE ;
}
}
// Output the bitstream...
# ifdef DEBUG_NETWORKING
int lastbit = u . m_pBuf - > GetNumBitsRead ( ) ;
{
void SpewBitStream ( unsigned char * pMem , int bit , int lastbit ) ;
SpewBitStream ( ( byte * ) u . m_pBuf - > m_pData , startbit , lastbit ) ;
}
# endif
}
CBaseClientState : : CBaseClientState ( )
{
m_Socket = NS_CLIENT ;
m_pServerClasses = NULL ;
m_StringTableContainer = NULL ;
m_NetChannel = NULL ;
m_nSignonState = SIGNONSTATE_NONE ;
m_nChallengeNr = 0 ;
m_flConnectTime = 0 ;
m_nRetryNumber = 0 ;
m_szRetryAddress [ 0 ] = 0 ;
m_ulGameServerSteamID = 0 ;
m_retryChallenge = 0 ;
m_bRestrictServerCommands = true ;
m_bRestrictClientCommands = true ;
m_nServerCount = 0 ;
m_nCurrentSequence = 0 ;
m_nDeltaTick = 0 ;
m_bPaused = 0 ;
m_flPausedExpireTime = - 1.f ;
m_nViewEntity = 0 ;
m_nPlayerSlot = 0 ;
m_szLevelFileName [ 0 ] = 0 ;
m_szLevelBaseName [ 0 ] = 0 ;
m_nMaxClients = 0 ;
Q_memset ( m_pEntityBaselines , 0 , sizeof ( m_pEntityBaselines ) ) ;
m_nServerClasses = 0 ;
m_nServerClassBits = 0 ;
m_szEncrytionKey [ 0 ] = 0 ;
}
CBaseClientState : : ~ CBaseClientState ( )
{
}
void CBaseClientState : : Clear ( void )
{
m_nServerCount = - 1 ;
m_nDeltaTick = - 1 ;
m_ClockDriftMgr . Clear ( ) ;
m_nCurrentSequence = 0 ;
m_nServerClasses = 0 ;
m_nServerClassBits = 0 ;
m_nPlayerSlot = 0 ;
m_szLevelFileName [ 0 ] = 0 ;
m_szLevelBaseName [ 0 ] = 0 ;
m_nMaxClients = 0 ;
if ( m_pServerClasses )
{
delete [ ] m_pServerClasses ;
m_pServerClasses = NULL ;
}
if ( m_StringTableContainer )
{
# ifndef SHARED_NET_STRING_TABLES
m_StringTableContainer - > RemoveAllTables ( ) ;
# endif
m_StringTableContainer = NULL ;
}
FreeEntityBaselines ( ) ;
RecvTable_Term ( false ) ;
if ( m_NetChannel )
m_NetChannel - > Reset ( ) ;
m_bPaused = 0 ;
m_flPausedExpireTime = - 1.f ;
m_nViewEntity = 0 ;
m_nChallengeNr = 0 ;
m_flConnectTime = 0.0f ;
}
void CBaseClientState : : FileReceived ( const char * fileName , unsigned int transferID )
{
ConMsg ( " CBaseClientState::FileReceived: %s. \n " , fileName ) ;
}
void CBaseClientState : : FileDenied ( const char * fileName , unsigned int transferID )
{
ConMsg ( " CBaseClientState::FileDenied: %s. \n " , fileName ) ;
}
void CBaseClientState : : FileRequested ( const char * fileName , unsigned int transferID )
{
ConMsg ( " File '%s' requested from %s. \n " , fileName , m_NetChannel - > GetAddress ( ) ) ;
m_NetChannel - > SendFile ( fileName , transferID ) ; // CBaseCLisntState always sends file
}
void CBaseClientState : : FileSent ( const char * fileName , unsigned int transferID )
{
ConMsg ( " File '%s' sent. \n " , fileName ) ;
}
# define REGISTER_NET_MSG( name ) \
NET_ # # name * p # # name = new NET_ # # name ( ) ; \
p # # name - > m_pMessageHandler = this ; \
chan - > RegisterMessage ( p # # name ) ; \
# define REGISTER_SVC_MSG( name ) \
SVC_ # # name * p # # name = new SVC_ # # name ( ) ; \
p # # name - > m_pMessageHandler = this ; \
chan - > RegisterMessage ( p # # name ) ; \
void CBaseClientState : : ConnectionStart ( INetChannel * chan )
{
REGISTER_NET_MSG ( Tick ) ;
REGISTER_NET_MSG ( StringCmd ) ;
REGISTER_NET_MSG ( SetConVar ) ;
REGISTER_NET_MSG ( SignonState ) ;
REGISTER_SVC_MSG ( Print ) ;
REGISTER_SVC_MSG ( ServerInfo ) ;
REGISTER_SVC_MSG ( SendTable ) ;
REGISTER_SVC_MSG ( ClassInfo ) ;
REGISTER_SVC_MSG ( SetPause ) ;
REGISTER_SVC_MSG ( CreateStringTable ) ;
REGISTER_SVC_MSG ( UpdateStringTable ) ;
REGISTER_SVC_MSG ( VoiceInit ) ;
REGISTER_SVC_MSG ( VoiceData ) ;
REGISTER_SVC_MSG ( Sounds ) ;
REGISTER_SVC_MSG ( SetView ) ;
REGISTER_SVC_MSG ( FixAngle ) ;
REGISTER_SVC_MSG ( CrosshairAngle ) ;
REGISTER_SVC_MSG ( BSPDecal ) ;
REGISTER_SVC_MSG ( GameEvent ) ;
REGISTER_SVC_MSG ( UserMessage ) ;
REGISTER_SVC_MSG ( EntityMessage ) ;
REGISTER_SVC_MSG ( PacketEntities ) ;
REGISTER_SVC_MSG ( TempEntities ) ;
REGISTER_SVC_MSG ( Prefetch ) ;
REGISTER_SVC_MSG ( Menu ) ;
REGISTER_SVC_MSG ( GameEventList ) ;
REGISTER_SVC_MSG ( GetCvarValue ) ;
REGISTER_SVC_MSG ( CmdKeyValues ) ;
REGISTER_SVC_MSG ( SetPauseTimed ) ;
}
void CBaseClientState : : ConnectionClosing ( const char * reason )
{
ConMsg ( " Disconnect: %s. \n " , reason ? reason : " unknown reason " ) ;
Disconnect ( reason ? reason : " Connection closing " , true ) ;
}
//-----------------------------------------------------------------------------
// Purpose: A svc_signonnum has been received, perform a client side setup
// Output : void CL_SignonReply
//-----------------------------------------------------------------------------
bool CBaseClientState : : SetSignonState ( int state , int count )
{
// ConDMsg ("CL_SignonReply: %i\n", cl.signon);
if ( state < SIGNONSTATE_NONE | | state > SIGNONSTATE_CHANGELEVEL )
{
ConMsg ( " Received signon %i when at %i \n " , state , m_nSignonState ) ;
Assert ( 0 ) ;
return false ;
}
if ( ( state > SIGNONSTATE_CONNECTED ) & & ( state < = m_nSignonState ) & & ! m_NetChannel - > IsPlayback ( ) )
{
ConMsg ( " Received signon %i when at %i \n " , state , m_nSignonState ) ;
Assert ( 0 ) ;
return false ;
}
if ( ( count ! = m_nServerCount ) & & ( count ! = - 1 ) & & ( m_nServerCount ! = - 1 ) & & ! m_NetChannel - > IsPlayback ( ) )
{
ConMsg ( " Received wrong spawn count %i when at %i \n " , count , m_nServerCount ) ;
Assert ( 0 ) ;
return false ;
}
if ( state = = SIGNONSTATE_FULL )
{
# if defined( REPLAY_ENABLED ) && !defined( DEDICATED )
if ( g_pClientReplayContext )
{
g_pClientReplayContext - > OnSignonStateFull ( ) ;
}
# endif
if ( IsX360 ( ) & &
g_pMatchmaking - > PreventFullServerStartup ( ) )
{
return true ;
}
}
m_nSignonState = state ;
return true ;
}
//-----------------------------------------------------------------------------
// Purpose: called by CL_Connect and CL_CheckResend
// If we are in ca_connecting state and we have gotten a challenge
// response before the timeout, send another "connect" request.
// Output : void CL_SendConnectPacket
//-----------------------------------------------------------------------------
void CBaseClientState : : SendConnectPacket ( int challengeNr , int authProtocol , uint64 unGSSteamID , bool bGSSecure )
{
COM_TimestampedLog ( " SendConnectPacket " ) ;
netadr_t adr ;
char szServerName [ MAX_OSPATH ] ;
const char * CDKey = " NOCDKEY " ;
Q_strncpy ( szServerName , m_szRetryAddress , MAX_OSPATH ) ;
if ( ! NET_StringToAdr ( szServerName , & adr ) )
{
ConMsg ( " Bad server address (%s) \n " , szServerName ) ;
Disconnect ( " Bad server address " , true ) ;
// Host_Disconnect(); MOTODO
return ;
}
if ( adr . GetPort ( ) = = ( unsigned short ) 0 )
{
adr . SetPort ( PORT_SERVER ) ;
}
ALIGN4 char msg_buffer [ MAX_ROUTABLE_PAYLOAD ] ALIGN4_POST ;
bf_write msg ( msg_buffer , sizeof ( msg_buffer ) ) ;
msg . WriteLong ( CONNECTIONLESS_HEADER ) ;
msg . WriteByte ( C2S_CONNECT ) ;
msg . WriteLong ( PROTOCOL_VERSION ) ;
msg . WriteLong ( authProtocol ) ;
msg . WriteLong ( challengeNr ) ;
msg . WriteLong ( m_retryChallenge ) ;
msg . WriteString ( GetClientName ( ) ) ; // Name
msg . WriteString ( password . GetString ( ) ) ; // password
msg . WriteString ( GetSteamInfIDVersionInfo ( ) . szVersionString ) ; // product version
// msg.WriteByte( ( g_pServerPluginHandler->GetNumLoadedPlugins() > 0 ) ? 1 : 0 ); // have any client-side server plug-ins been loaded?
switch ( authProtocol )
{
// Fall through, bogus protocol type, use CD key hash.
case PROTOCOL_HASHEDCDKEY : CDKey = GetCDKeyHash ( ) ;
msg . WriteString ( CDKey ) ; // cdkey
break ;
case PROTOCOL_STEAM : if ( ! PrepareSteamConnectResponse ( unGSSteamID , bGSSecure , adr , msg ) )
{
return ;
}
break ;
default : Host_Error ( " Unexepected authentication protocol %i! \n " , authProtocol ) ;
return ;
}
// Mark time of this attempt for retransmit requests
m_flConnectTime = net_time ;
// remember challengenr for TCP connection
m_nChallengeNr = challengeNr ;
// Remember Steam ID, if any
m_ulGameServerSteamID = unGSSteamID ;
// Send protocol and challenge value
NET_SendPacket ( NULL , m_Socket , adr , msg . GetData ( ) , msg . GetNumBytesWritten ( ) ) ;
}
//-----------------------------------------------------------------------------
// Purpose: append steam specific data to a connection response
//-----------------------------------------------------------------------------
bool CBaseClientState : : PrepareSteamConnectResponse ( uint64 unGSSteamID , bool bGSSecure , const netadr_t & adr , bf_write & msg )
{
// X360TBD: Network - Steam Dedicated Server hack
if ( IsX360 ( ) )
{
return true ;
}
2022-03-02 08:42:47 +00:00
#if 0 //!defined( NO_STEAM ) && !defined( SWDS )
2020-04-22 16:56:21 +00:00
if ( ! Steam3Client ( ) . SteamUser ( ) )
{
COM_ExplainDisconnection ( true , " #GameUI_ServerRequireSteam " ) ;
Disconnect ( " #GameUI_ServerRequireSteam " , true ) ;
return false ;
}
# endif
2022-03-02 08:42:47 +00:00
2020-04-22 16:56:21 +00:00
netadr_t checkAdr = adr ;
if ( adr . GetType ( ) = = NA_LOOPBACK | | adr . IsLocalhost ( ) )
{
checkAdr . SetIP ( net_local_adr . GetIPHostByteOrder ( ) ) ;
}
2022-03-02 08:42:47 +00:00
#if 0 // #ifndef SWDS
2020-04-22 16:56:21 +00:00
// now append the steam3 cookie
char steam3Cookie [ STEAM_KEYSIZE ] ;
uint32 steam3CookieLen = 0 ;
Steam3Client ( ) . GetAuthSessionTicket ( steam3Cookie , sizeof ( steam3Cookie ) , & steam3CookieLen , checkAdr . GetIPHostByteOrder ( ) , checkAdr . GetPort ( ) , unGSSteamID , bGSSecure ) ;
if ( steam3CookieLen = = 0 )
{
COM_ExplainDisconnection ( true , " #GameUI_ServerRequireSteam " ) ;
Disconnect ( " #GameUI_ServerRequireSteam " , true ) ;
return false ;
}
msg . WriteShort ( steam3CookieLen ) ;
if ( steam3CookieLen > 0 )
msg . WriteBytes ( steam3Cookie , steam3CookieLen ) ;
# endif
return true ;
}
// Tracks how we connected to the current server.
static ConVar cl_connectmethod ( " cl_connectmethod " , " " , FCVAR_USERINFO | FCVAR_HIDDEN , " Method by which we connected to the current server. " ) ;
/* static */ bool CBaseClientState : : ConnectMethodAllowsRedirects ( )
{
// Only HLTV should be allowed to redirect clients, but malicious servers can answer a connect
// attempt as HLTV and then redirect elsewhere. A somewhat-more complete fix for this would
// involve tracking our redirected status and refusing to interact with non-HLTV servers. For
// now, however, we just blacklist server browser / matchmaking connect methods from allowing
// redirects and allow it for other types.
const char * pConnectMethod = cl_connectmethod . GetString ( ) ;
if ( V_strcmp ( pConnectMethod , " serverbrowser_internet " ) = = 0 | |
V_strncmp ( pConnectMethod , " quickpick " , 9 ) = = 0 | |
V_strncmp ( pConnectMethod , " quickplay " , 9 ) = = 0 | |
V_strcmp ( pConnectMethod , " matchmaking " ) = = 0 | |
V_strcmp ( pConnectMethod , " coaching " ) = = 0 )
{
return false ;
}
return true ;
}
void CBaseClientState : : Connect ( const char * adr , const char * pszSourceTag )
{
# if !defined( NO_STEAM )
// Get our name from steam. Needs to be done before connecting
// because we won't have triggered a check by changing our name.
IConVar * pVar = g_pCVar - > FindVar ( " name " ) ;
if ( pVar )
{
SetNameToSteamIDName ( pVar ) ;
}
# endif
Q_strncpy ( m_szRetryAddress , adr , sizeof ( m_szRetryAddress ) ) ;
m_retryChallenge = ( RandomInt ( 0 , 0x0FFF ) < < 16 ) | RandomInt ( 0 , 0xFFFF ) ;
m_ulGameServerSteamID = 0 ;
m_sRetrySourceTag = pszSourceTag ;
cl_connectmethod . SetValue ( m_sRetrySourceTag . String ( ) ) ;
// For the check for resend timer to fire a connection / getchallenge request.
SetSignonState ( SIGNONSTATE_CHALLENGE , - 1 ) ;
// Force connection request to fire.
m_flConnectTime = - FLT_MAX ;
m_nRetryNumber = 0 ;
}
INetworkStringTable * CBaseClientState : : GetStringTable ( const char * name ) const
{
if ( ! m_StringTableContainer )
{
Assert ( m_StringTableContainer ) ;
return NULL ;
}
return m_StringTableContainer - > FindTable ( name ) ;
}
void CBaseClientState : : ForceFullUpdate ( void )
{
if ( m_nDeltaTick = = - 1 )
return ;
FreeEntityBaselines ( ) ;
m_nDeltaTick = - 1 ;
DevMsg ( " Requesting full game update... \n " ) ;
}
void CBaseClientState : : FullConnect ( netadr_t & adr )
{
// Initiate the network channel
COM_TimestampedLog ( " CBaseClientState::FullConnect " ) ;
m_NetChannel = NET_CreateNetChannel ( m_Socket , & adr , " CLIENT " , this ) ;
Assert ( m_NetChannel ) ;
m_NetChannel - > StartStreaming ( m_nChallengeNr ) ; // open TCP stream
// Bump connection time to now so we don't resend a connection
// Request
m_flConnectTime = net_time ;
// We'll request a full delta from the baseline
m_nDeltaTick = - 1 ;
// We can send a cmd right away
m_flNextCmdTime = net_time ;
// Mark client as connected
SetSignonState ( SIGNONSTATE_CONNECTED , - 1 ) ;
# if !defined(SWDS)
RCONClient ( ) . SetAddress ( m_NetChannel - > GetRemoteAddress ( ) ) ;
# endif
// Fire an event when we get our connection
IGameEvent * event = g_GameEventManager . CreateEvent ( " client_connected " ) ;
if ( event )
{
event - > SetString ( " address " , m_NetChannel - > GetRemoteAddress ( ) . ToString ( true ) ) ;
event - > SetInt ( " ip " , m_NetChannel - > GetRemoteAddress ( ) . GetIPNetworkByteOrder ( ) ) ; // <<< Network byte order?
event - > SetInt ( " port " , m_NetChannel - > GetRemoteAddress ( ) . GetPort ( ) ) ;
g_GameEventManager . FireEventClientSide ( event ) ;
}
}
void CBaseClientState : : ConnectionCrashed ( const char * reason )
{
DebuggerBreakIfDebugging_StagingOnly ( ) ;
ConMsg ( " Connection lost: %s. \n " , reason ? reason : " unknown reason " ) ;
Disconnect ( reason ? reason : " Connection crashed " , true ) ;
}
void CBaseClientState : : Disconnect ( const char * pszReason , bool bShowMainMenu )
{
m_flConnectTime = - FLT_MAX ;
m_nRetryNumber = 0 ;
m_ulGameServerSteamID = 0 ;
if ( m_nSignonState = = SIGNONSTATE_NONE )
return ;
# if !defined( SWDS ) && defined( ENABLE_RPT )
CL_NotifyRPTOfDisconnect ( ) ;
# endif
m_nSignonState = SIGNONSTATE_NONE ;
netadr_t adr ;
if ( m_NetChannel )
{
adr = m_NetChannel - > GetRemoteAddress ( ) ;
}
else
{
NET_StringToAdr ( m_szRetryAddress , & adr ) ;
}
# ifndef SWDS
netadr_t checkAdr = adr ;
if ( adr . GetType ( ) = = NA_LOOPBACK | | adr . IsLocalhost ( ) )
{
checkAdr . SetIP ( net_local_adr . GetIPHostByteOrder ( ) ) ;
}
Steam3Client ( ) . CancelAuthTicket ( ) ;
# endif
if ( m_NetChannel )
{
m_NetChannel - > Shutdown ( ( pszReason & & * pszReason ) ? pszReason : " Disconnect by user. " ) ;
m_NetChannel = NULL ;
}
}
void CBaseClientState : : RunFrame ( void )
{
VPROF ( " CBaseClientState::RunFrame " ) ;
tmZone ( TELEMETRY_LEVEL0 , TMZF_NONE , " %s " , __FUNCTION__ ) ;
if ( ( m_nSignonState > SIGNONSTATE_NEW ) & & m_NetChannel & & g_GameEventManager . HasClientListenersChanged ( ) )
{
// assemble a list of all events we listening to and tell the server
CLC_ListenEvents msg ;
g_GameEventManager . WriteListenEventList ( & msg ) ;
m_NetChannel - > SendNetMsg ( msg ) ;
}
if ( m_nSignonState = = SIGNONSTATE_CHALLENGE )
{
CheckForResend ( ) ;
}
}
/*
= = = = = = = = = = = = = = = = =
CL_CheckForResend
Resend a connect message if the last one has timed out
= = = = = = = = = = = = = = = = =
*/
void CBaseClientState : : CheckForResend ( void )
{
// resend if we haven't gotten a reply yet
// We only resend during the connection process.
if ( m_nSignonState ! = SIGNONSTATE_CHALLENGE )
return ;
// Wait at least the resend # of seconds.
if ( ( net_time - m_flConnectTime ) < cl_resend . GetFloat ( ) )
return ;
netadr_t adr ;
if ( ! NET_StringToAdr ( m_szRetryAddress , & adr ) )
{
ConMsg ( " Bad server address (%s) \n " , m_szRetryAddress ) ;
//Host_Disconnect();
Disconnect ( " Bad server address " , true ) ;
return ;
}
if ( adr . GetPort ( ) = = 0 )
{
adr . SetPort ( PORT_SERVER ) ;
}
// Only retry so many times before failure.
if ( m_nRetryNumber > = GetConnectionRetryNumber ( ) )
{
COM_ExplainDisconnection ( true , " Connection failed after %i retries. \n " , CL_CONNECTION_RETRIES ) ;
// Host_Disconnect();
Disconnect ( " Connection failed " , true ) ;
return ;
}
// Mark time of this attempt.
m_flConnectTime = net_time ; // for retransmit requests
// Display appropriate message
if ( Q_strncmp ( m_szRetryAddress , " localhost " , 9 ) )
{
if ( m_nRetryNumber = = 0 )
ConMsg ( " Connecting to %s... \n " , m_szRetryAddress ) ;
else
ConMsg ( " Retrying %s... \n " , m_szRetryAddress ) ;
}
// Fire an event when we attempt connection
if ( m_nRetryNumber = = 0 )
{
IGameEvent * event = g_GameEventManager . CreateEvent ( " client_beginconnect " ) ;
if ( event )
{
event - > SetString ( " address " , m_szRetryAddress ) ;
event - > SetInt ( " ip " , adr . GetIPNetworkByteOrder ( ) ) ; // <<< Network byte order?
event - > SetInt ( " port " , adr . GetPort ( ) ) ;
//event->SetInt( "retry_number", m_nRetryNumber );
event - > SetString ( " source " , m_sRetrySourceTag ) ;
g_GameEventManager . FireEventClientSide ( event ) ;
}
}
m_nRetryNumber + + ;
// Request another challenge value.
{
ALIGN4 char msg_buffer [ MAX_ROUTABLE_PAYLOAD ] ALIGN4_POST ;
bf_write msg ( msg_buffer , sizeof ( msg_buffer ) ) ;
msg . WriteLong ( CONNECTIONLESS_HEADER ) ;
msg . WriteByte ( A2S_GETCHALLENGE ) ;
msg . WriteLong ( m_retryChallenge ) ;
msg . WriteString ( " 0000000000 " ) ; // pad out
NET_SendPacket ( NULL , m_Socket , adr , msg . GetData ( ) , msg . GetNumBytesWritten ( ) ) ;
}
}
bool CBaseClientState : : ProcessConnectionlessPacket ( netpacket_t * packet )
{
VPROF ( " ProcessConnectionlessPacket " ) ;
Assert ( packet ) ;
bf_read & msg = packet - > message ; // handy shortcut
int c = msg . ReadByte ( ) ;
// ignoring a specific packet that DOTA2 broadcasts
if ( c = = C2C_MOD )
return false ;
char string [ MAX_ROUTABLE_PAYLOAD ] ;
netadr_t adrServerConnectingTo ;
NET_StringToAdr ( m_szRetryAddress , & adrServerConnectingTo ) ;
if ( ( packet - > from . GetType ( ) ! = NA_LOOPBACK ) & & ( packet - > from . GetIPNetworkByteOrder ( ) ! = adrServerConnectingTo . GetIPNetworkByteOrder ( ) ) )
{
if ( cl_show_connectionless_packet_warnings . GetBool ( ) )
{
ConDMsg ( " Discarding connectionless packet ( CL '%c' ) from %s. \n " , c , packet - > from . ToString ( ) ) ;
}
return false ;
}
switch ( c )
{
case S2C_CONNECTION : if ( m_nSignonState = = SIGNONSTATE_CHALLENGE )
{
int myChallenge = msg . ReadLong ( ) ;
if ( myChallenge ! = m_retryChallenge )
{
Msg ( " Server connection did not have the correct challenge, ignoring. \n " ) ;
return false ;
}
// server accepted our connection request
FullConnect ( packet - > from ) ;
}
break ;
case S2C_CHALLENGE : // Response from getchallenge we sent to the server we are connecting to
// Blow it off if we are not connected.
if ( m_nSignonState = = SIGNONSTATE_CHALLENGE )
{
int magicVersion = msg . ReadLong ( ) ;
if ( magicVersion ! = S2C_MAGICVERSION )
{
COM_ExplainDisconnection ( true , " #GameUI_ServerConnectOutOfDate " ) ;
Disconnect ( " #GameUI_ServerConnectOutOfDate " , true ) ;
return false ;
}
int challenge = msg . ReadLong ( ) ;
int myChallenge = msg . ReadLong ( ) ;
if ( myChallenge ! = m_retryChallenge )
{
Msg ( " Server challenge did not have the correct challenge, ignoring. \n " ) ;
return false ;
}
int authprotocol = msg . ReadLong ( ) ;
uint64 unGSSteamID = 0 ;
bool bGSSecure = false ;
2022-03-02 08:42:47 +00:00
#if 0
2020-04-22 16:56:21 +00:00
if ( authprotocol = = PROTOCOL_STEAM )
{
if ( msg . ReadShort ( ) ! = 0 )
{
Msg ( " Invalid Steam key size. \n " ) ;
Disconnect ( " Invalid Steam key size " , true ) ;
return false ;
}
if ( msg . GetNumBytesLeft ( ) > sizeof ( unGSSteamID ) )
{
if ( ! msg . ReadBytes ( & unGSSteamID , sizeof ( unGSSteamID ) ) )
{
Msg ( " Invalid GS Steam ID. \n " ) ;
Disconnect ( " Invalid GS Steam ID " , true ) ;
return false ;
}
bGSSecure = ( msg . ReadByte ( ) = = 1 ) ;
}
// The host can disable access to secure servers if you load unsigned code (mods, plugins, hacks)
if ( bGSSecure & & ! Host_IsSecureServerAllowed ( ) )
{
COM_ExplainDisconnection ( true , " #GameUI_ServerInsecure " ) ;
Disconnect ( " #GameUI_ServerInsecure " , true ) ;
return false ;
}
}
2022-03-02 08:42:47 +00:00
# endif
2020-04-22 16:56:21 +00:00
SendConnectPacket ( challenge , authprotocol , unGSSteamID , bGSSecure ) ;
}
break ;
case S2C_CONNREJECT : if ( m_nSignonState = = SIGNONSTATE_CHALLENGE ) // Spoofed?
{
int myChallenge = msg . ReadLong ( ) ;
if ( myChallenge ! = m_retryChallenge )
{
Msg ( " Received connection rejection that didn't match my challenge, ignoring. \n " ) ;
return false ;
}
msg . ReadString ( string , sizeof ( string ) ) ;
// Force failure dialog to come up now.
COM_ExplainDisconnection ( true , " %s " , string ) ;
Disconnect ( string , true ) ;
// Host_Disconnect();
}
break ;
// Unknown?
default :
// Otherwise, don't do anything.
if ( cl_show_connectionless_packet_warnings . GetBool ( ) )
{
ConDMsg ( " Bad connectionless packet ( CL '%c' ) from %s. \n " , c , packet - > from . ToString ( ) ) ;
}
return false ;
}
return true ;
}
bool CBaseClientState : : ProcessTick ( NET_Tick * msg )
{
VPROF ( " ProcessTick " ) ;
m_NetChannel - > SetRemoteFramerate ( msg - > m_flHostFrameTime , msg - > m_flHostFrameTimeStdDeviation ) ;
// Note: CClientState separates the client and server clock states and drifts
// the client's clock to match the server's, but right here, we keep the two clocks in sync.
SetClientTickCount ( msg - > m_nTick ) ;
SetServerTickCount ( msg - > m_nTick ) ;
if ( m_StringTableContainer )
{
m_StringTableContainer - > SetTick ( GetServerTickCount ( ) ) ;
}
return ( GetServerTickCount ( ) > 0 ) ;
}
void CBaseClientState : : SendStringCmd ( const char * command )
{
if ( m_NetChannel )
{
NET_StringCmd stringCmd ( command ) ;
m_NetChannel - > SendNetMsg ( stringCmd ) ;
}
}
bool CBaseClientState : : ProcessStringCmd ( NET_StringCmd * msg )
{
VPROF ( " ProcessStringCmd " ) ;
// Don't restrict commands from the server in single player or if cl_restrict_stuffed_commands is 0.
if ( ! m_bRestrictServerCommands | | sv . IsActive ( ) )
{
Cbuf_AddText ( msg - > m_szCommand ) ;
return true ;
}
// Check that we can add the two execution markers
if ( ! Cbuf_HasRoomForExecutionMarkers ( 2 ) )
{
AssertMsg ( false , " CBaseClientState::ProcessStringCmd called but there is no room for the execution markers. Ignoring command. " ) ;
return true ;
}
// Run the command, but make sure the command parser knows to only execute commands marked with FCVAR_SERVER_CAN_EXECUTE.
Cbuf_AddTextWithMarkers ( eCmdExecutionMarker_Enable_FCVAR_SERVER_CAN_EXECUTE , msg - > m_szCommand , eCmdExecutionMarker_Disable_FCVAR_SERVER_CAN_EXECUTE ) ;
return true ;
}
bool CBaseClientState : : ProcessSetConVar ( NET_SetConVar * msg )
{
VPROF ( " ProcessSetConVar " ) ;
// Never process on local client, since the ConVar is directly linked here
if ( m_NetChannel - > IsLoopback ( ) )
return true ;
for ( int i = 0 ; i < msg - > m_ConVars . Count ( ) ; i + + )
{
const char * name = msg - > m_ConVars [ i ] . name ;
const char * value = msg - > m_ConVars [ i ] . value ;
// De-constify
ConVarRef var ( name ) ;
if ( ! var . IsValid ( ) )
{
ConMsg ( " SetConVar: No such cvar ( %s set to %s), skipping \n " ,
name , value ) ;
continue ;
}
// Make sure server is only setting replicated game ConVars
if ( ! var . IsFlagSet ( FCVAR_REPLICATED ) )
{
ConMsg ( " SetConVar: Can't set server cvar %s to %s, not marked as FCVAR_REPLICATED on client \n " ,
name , value ) ;
continue ;
}
// Set value directly ( don't call through cv->DirectSet!!! )
if ( ! sv . IsActive ( ) )
{
var . SetValue ( value ) ;
DevMsg ( " SetConVar: %s = \" %s \" \n " , name , value ) ;
}
}
return true ;
}
bool CBaseClientState : : ProcessSignonState ( NET_SignonState * msg )
{
VPROF ( " ProcessSignonState " ) ;
return SetSignonState ( msg - > m_nSignonState , msg - > m_nSpawnCount ) ;
}
bool CBaseClientState : : ProcessPrint ( SVC_Print * msg )
{
VPROF ( " ProcessPrint " ) ;
ConMsg ( " %s " , msg - > m_szText ) ;
return true ;
}
bool CBaseClientState : : ProcessMenu ( SVC_Menu * msg )
{
VPROF ( " ProcessMenu " ) ;
# if !defined(SWDS)
PluginHelpers_Menu ( msg ) ;
# endif
return true ;
}
bool CBaseClientState : : ProcessServerInfo ( SVC_ServerInfo * msg )
{
VPROF ( " ProcessServerInfo " ) ;
# ifndef SWDS
EngineVGui ( ) - > UpdateProgressBar ( PROGRESS_PROCESSSERVERINFO ) ;
# endif
COM_TimestampedLog ( " CBaseClient::ProcessServerInfo " ) ;
if ( msg - > m_nProtocol ! = PROTOCOL_VERSION
# if defined( DEMO_BACKWARDCOMPATABILITY ) && (! defined( SWDS ) )
& & ! ( demoplayer - > IsPlayingBack ( ) & & msg - > m_nProtocol > = PROTOCOL_VERSION_12 )
# endif
)
{
ConMsg ( " Server returned version %i, expected %i. \n " , msg - > m_nProtocol , PROTOCOL_VERSION ) ;
return false ;
}
// Parse servercount (i.e., # of servers spawned since server .exe started)
// So that we can detect new server startup during download, etc.
m_nServerCount = msg - > m_nServerCount ;
m_nMaxClients = msg - > m_nMaxClients ;
m_nServerClasses = msg - > m_nMaxClasses ;
m_nServerClassBits = Q_log2 ( m_nServerClasses ) + 1 ;
if ( m_nMaxClients < 1 | | m_nMaxClients > ABSOLUTE_PLAYER_LIMIT )
{
ConMsg ( " Bad maxclients (%u) from server. \n " , m_nMaxClients ) ;
return false ;
}
if ( m_nServerClasses < 1 | | m_nServerClasses > MAX_SERVER_CLASSES )
{
ConMsg ( " Bad maxclasses (%u) from server. \n " , m_nServerClasses ) ;
return false ;
}
# ifndef SWDS
if ( ! sv . IsActive ( ) & &
! ( m_NetChannel - > IsLoopback ( ) | | m_NetChannel - > IsNull ( ) ) )
{
// if you are joing a remote server it MUST be multipler and have maxplayer set to more than 1
// this prevents a spoofed ServerInfo packet from making the client think its in singleplayer
// and turning off a bunch of security checks
if ( m_nMaxClients < = 1 )
{
ConMsg ( " Bad maxclients (%u) from server. \n " , m_nMaxClients ) ;
return false ;
}
// reset server enforced cvars
g_pCVar - > RevertFlaggedConVars ( FCVAR_REPLICATED ) ;
// Cheats were disabled; revert all cheat cvars to their default values.
// This must be done heading into multiplayer games because people can play
// demos etc and set cheat cvars with sv_cheats 0.
g_pCVar - > RevertFlaggedConVars ( FCVAR_CHEAT ) ;
DevMsg ( " FCVAR_CHEAT cvars reverted to defaults. \n " ) ;
}
# endif
// clear all baselines still around from last game
FreeEntityBaselines ( ) ;
// force changed flag to being reset
g_GameEventManager . HasClientListenersChanged ( true ) ;
m_nPlayerSlot = msg - > m_nPlayerSlot ;
m_nViewEntity = m_nPlayerSlot + 1 ;
if ( msg - > m_fTickInterval < MINIMUM_TICK_INTERVAL | |
msg - > m_fTickInterval > MAXIMUM_TICK_INTERVAL )
{
ConMsg ( " Interval_per_tick %f out of range [%f to %f] \n " ,
msg - > m_fTickInterval , MINIMUM_TICK_INTERVAL , MAXIMUM_TICK_INTERVAL ) ;
return false ;
}
if ( ! COM_CheckGameDirectory ( msg - > m_szGameDir ) )
{
return false ;
}
Q_strncpy ( m_szLevelBaseName , msg - > m_szMapName , sizeof ( m_szLevelBaseName ) ) ;
# if !defined(SWDS)
audiosourcecache - > LevelInit ( m_szLevelBaseName ) ;
# endif
ConVarRef skyname ( " sv_skyname " ) ;
if ( skyname . IsValid ( ) )
{
skyname . SetValue ( msg - > m_szSkyName ) ;
}
m_nDeltaTick = - 1 ; // no valid snapshot for this game yet
// fire a client side event about server data
IGameEvent * event = g_GameEventManager . CreateEvent ( " server_spawn " ) ;
if ( event )
{
event - > SetString ( " hostname " , msg - > m_szHostName ) ;
event - > SetString ( " address " , m_NetChannel - > GetRemoteAddress ( ) . ToString ( true ) ) ;
event - > SetInt ( " ip " , m_NetChannel - > GetRemoteAddress ( ) . GetIPNetworkByteOrder ( ) ) ; // <<< Network byte order?
event - > SetInt ( " port " , m_NetChannel - > GetRemoteAddress ( ) . GetPort ( ) ) ;
event - > SetString ( " game " , msg - > m_szGameDir ) ;
event - > SetString ( " mapname " , msg - > m_szMapName ) ;
event - > SetInt ( " maxplayers " , msg - > m_nMaxClients ) ;
event - > SetInt ( " password " , 0 ) ; // TODO
event - > SetString ( " os " , va ( " %c " , toupper ( msg - > m_cOS ) ) ) ;
event - > SetInt ( " dedicated " , msg - > m_bIsDedicated ? 1 : 0 ) ;
if ( m_ulGameServerSteamID ! = 0 )
{
event - > SetString ( " steamid " , CSteamID ( m_ulGameServerSteamID ) . Render ( ) ) ;
}
g_GameEventManager . FireEventClientSide ( event ) ;
}
// Set default filename, but this is finalized by ClientState later, so it should not be depended on yet. See PrepareLevelResources call
Host_DefaultMapFileName ( msg - > m_szMapName , m_szLevelFileName , sizeof ( m_szLevelFileName ) ) ;
COM_TimestampedLog ( " CBaseClient::ProcessServerInfo(done) " ) ;
return true ;
}
bool CBaseClientState : : ProcessSendTable ( SVC_SendTable * msg )
{
VPROF ( " ProcessSendTable " ) ;
if ( ! RecvTable_RecvClassInfos ( & msg - > m_DataIn , msg - > m_bNeedsDecoder ) )
{
Host_EndGame ( true , " ProcessSendTable: RecvTable_RecvClassInfos failed. \n " ) ;
return false ;
}
return true ;
}
bool CBaseClientState : : ProcessClassInfo ( SVC_ClassInfo * msg )
{
VPROF ( " ProcessClassInfo " ) ;
COM_TimestampedLog ( " CBaseClient::ProcessClassInfo " ) ;
if ( msg - > m_bCreateOnClient )
{
ConMsg ( " Can't create class tables. \n " ) ;
Assert ( 0 ) ;
return false ;
}
if ( m_pServerClasses )
{
delete [ ] m_pServerClasses ;
}
m_nServerClasses = msg - > m_Classes . Count ( ) ;
m_pServerClasses = new C_ServerClassInfo [ m_nServerClasses ] ;
if ( ! m_pServerClasses )
{
Host_EndGame ( true , " ProcessClassInfo: can't allocate %d C_ServerClassInfos. \n " , m_nServerClasses ) ;
return false ;
}
// copy class names and class IDs from message to CClientState
for ( int i = 0 ; i < m_nServerClasses ; i + + )
{
SVC_ClassInfo : : class_t * svclass = & msg - > m_Classes [ i ] ;
if ( svclass - > classID > = m_nServerClasses )
{
Host_EndGame ( true , " ProcessClassInfo: invalid class index (%d). \n " , svclass - > classID ) ;
return false ;
}
C_ServerClassInfo * svclassinfo = & m_pServerClasses [ svclass - > classID ] ;
int len = Q_strlen ( svclass - > classname ) + 1 ;
svclassinfo - > m_ClassName = new char [ len ] ;
Q_strncpy ( svclassinfo - > m_ClassName , svclass - > classname , len ) ;
len = Q_strlen ( svclass - > datatablename ) + 1 ;
svclassinfo - > m_DatatableName = new char [ len ] ;
Q_strncpy ( svclassinfo - > m_DatatableName , svclass - > datatablename , len ) ;
}
COM_TimestampedLog ( " CBaseClient::ProcessClassInfo(done) " ) ;
return LinkClasses ( ) ; // link server and client classes
}
bool CBaseClientState : : ProcessSetPause ( SVC_SetPause * msg )
{
VPROF ( " ProcessSetPause " ) ;
m_bPaused = msg - > m_bPaused ;
return true ;
}
bool CBaseClientState : : ProcessSetPauseTimed ( SVC_SetPauseTimed * msg )
{
VPROF ( " ProcessSetPauseTimed " ) ;
m_bPaused = msg - > m_bPaused ;
m_flPausedExpireTime = msg - > m_flExpireTime ;
return true ;
}
bool CBaseClientState : : ProcessCreateStringTable ( SVC_CreateStringTable * msg )
{
VPROF ( " ProcessCreateStringTable " ) ;
# ifndef SWDS
EngineVGui ( ) - > UpdateProgressBar ( PROGRESS_PROCESSSTRINGTABLE ) ;
# endif
COM_TimestampedLog ( " CBaseClient::ProcessCreateStringTable(%s) " , msg - > m_szTableName ) ;
m_StringTableContainer - > AllowCreation ( true ) ;
int startbit = msg - > m_DataIn . GetNumBitsRead ( ) ;
# ifndef SHARED_NET_STRING_TABLES
CNetworkStringTable * table = ( CNetworkStringTable * )
m_StringTableContainer - > CreateStringTableEx ( msg - > m_szTableName , msg - > m_nMaxEntries , msg - > m_nUserDataSize , msg - > m_nUserDataSizeBits , msg - > m_bIsFilenames ) ;
Assert ( table ) ;
table - > SetTick ( GetServerTickCount ( ) ) ; // set creation tick
HookClientStringTable ( msg - > m_szTableName ) ;
if ( msg - > m_bDataCompressed )
{
unsigned int msgUncompressedSize = msg - > m_DataIn . ReadLong ( ) ;
unsigned int msgCompressedSize = msg - > m_DataIn . ReadLong ( ) ;
unsigned int uncompressedSize = msgUncompressedSize ;
/// XXX(JohnS): 11/08/2016 - The PAD_NUMBER() call below was overflowing on UINT32_MAX-3 values. Enforcing
// resource-usage limits at this level is a lost cause without a massive overhaul, but clamp these
// to somewhat reasonable ranges to prevent overflows with less-audited code in the engine.
bool bSuccess = false ;
if ( msg - > m_DataIn . TotalBytesAvailable ( ) > 0 & &
msgCompressedSize < = ( unsigned int ) msg - > m_DataIn . TotalBytesAvailable ( ) & &
msgCompressedSize < UINT_MAX / 2 & &
msgUncompressedSize < UINT_MAX / 2 )
{
// allocate buffer for uncompressed data, align to 4 bytes boundary
char * uncompressedBuffer = new char [ PAD_NUMBER ( msgUncompressedSize , 4 ) ] ;
char * compressedBuffer = new char [ PAD_NUMBER ( msgCompressedSize , 4 ) ] ;
msg - > m_DataIn . ReadBits ( compressedBuffer , msgCompressedSize * 8 ) ;
// uncompress data
bSuccess = COM_BufferToBufferDecompress ( uncompressedBuffer , & uncompressedSize , compressedBuffer , msgCompressedSize ) ;
bSuccess & = ( uncompressedSize = = msgUncompressedSize ) ;
if ( bSuccess )
{
bf_read data ( uncompressedBuffer , uncompressedSize ) ;
table - > ParseUpdate ( data , msg - > m_nNumEntries ) ;
}
delete [ ] uncompressedBuffer ;
delete [ ] compressedBuffer ;
}
if ( ! bSuccess )
{
Assert ( false ) ;
Warning ( " Malformed message in CBaseClientState::ProcessCreateStringTable \n " ) ;
}
}
else
{
table - > ParseUpdate ( msg - > m_DataIn , msg - > m_nNumEntries ) ;
}
# endif
m_StringTableContainer - > AllowCreation ( false ) ;
int endbit = msg - > m_DataIn . GetNumBitsRead ( ) ;
COM_TimestampedLog ( " CBaseClient::ProcessCreateStringTable(%s)-done " , msg - > m_szTableName ) ;
return ( endbit - startbit ) = = msg - > m_nLength ;
}
bool CBaseClientState : : ProcessUpdateStringTable ( SVC_UpdateStringTable * msg )
{
VPROF ( " ProcessUpdateStringTable " ) ;
int startbit = msg - > m_DataIn . GetNumBitsRead ( ) ;
# ifndef SHARED_NET_STRING_TABLES
//m_StringTableContainer is NULL on level transitions, Seems to be caused by a UpdateStringTable packet comming in before the ServerInfo packet
// I'm not sure this is safe, but at least we won't crash. The realy odd thing is this can happen on the server as well.//tmauer
if ( m_StringTableContainer ! = NULL )
{
CNetworkStringTable * table = ( CNetworkStringTable * )
m_StringTableContainer - > GetTable ( msg - > m_nTableID ) ;
table - > ParseUpdate ( msg - > m_DataIn , msg - > m_nChangedEntries ) ;
}
else
{
Warning ( " m_StringTableContainer is NULL in CBaseClientState::ProcessUpdateStringTable \n " ) ;
}
# endif
int endbit = msg - > m_DataIn . GetNumBitsRead ( ) ;
return ( endbit - startbit ) = = msg - > m_nLength ;
}
bool CBaseClientState : : ProcessSetView ( SVC_SetView * msg )
{
VPROF ( " ProcessSetView " ) ;
m_nViewEntity = msg - > m_nEntityIndex ;
return true ;
}
bool CBaseClientState : : ProcessPacketEntities ( SVC_PacketEntities * msg )
{
VPROF ( " ProcessPacketEntities " ) ;
// First update is the final signon stage where we actually receive an entity (i.e., the world at least)
if ( m_nSignonState < SIGNONSTATE_SPAWN )
{
ConMsg ( " Received packet entities while connecting! \n " ) ;
return false ;
}
if ( m_nSignonState = = SIGNONSTATE_SPAWN )
{
if ( ! msg - > m_bIsDelta )
{
// We are done with signon sequence.
SetSignonState ( SIGNONSTATE_FULL , m_nServerCount ) ;
}
else
{
ConMsg ( " Received delta packet entities while spawing! \n " ) ;
return false ;
}
}
// overwrite a -1 delta_tick only if packet was uncompressed
if ( ( m_nDeltaTick > = 0 ) | | ! msg - > m_bIsDelta )
{
// we received this snapshot successfully, now this is our delta reference
m_nDeltaTick = GetServerTickCount ( ) ;
}
return true ;
}
void CBaseClientState : : ReadPacketEntities ( CEntityReadInfo & u )
{
VPROF ( " ReadPacketEntities " ) ;
// Loop until there are no more entities to read
u . NextOldEntity ( ) ;
while ( u . m_UpdateType < Finished )
{
u . m_nHeaderCount - - ;
u . m_bIsEntity = ( u . m_nHeaderCount > = 0 ) ? true : false ;
if ( u . m_bIsEntity )
{
CL_ParseDeltaHeader ( u ) ;
}
u . m_UpdateType = PreserveEnt ;
while ( u . m_UpdateType = = PreserveEnt )
{
// Figure out what kind of an update this is.
if ( CL_DetermineUpdateType ( u ) )
{
switch ( u . m_UpdateType )
{
case EnterPVS : ReadEnterPVS ( u ) ;
break ;
case LeavePVS : ReadLeavePVS ( u ) ;
break ;
case DeltaEnt : ReadDeltaEnt ( u ) ;
break ;
case PreserveEnt : ReadPreserveEnt ( u ) ;
break ;
default : DevMsg ( 1 , " ReadPacketEntities: unknown updatetype %i \n " , u . m_UpdateType ) ;
break ;
}
}
}
}
// Now process explicit deletes
if ( u . m_bAsDelta & & u . m_UpdateType = = Finished )
{
ReadDeletions ( u ) ;
}
// Something didn't parse...
if ( u . m_pBuf - > IsOverflowed ( ) )
{
Host_Error ( " CL_ParsePacketEntities: buffer read overflow \n " ) ;
}
// If we get an uncompressed packet, then the server is waiting for us to ack the validsequence
// that we got the uncompressed packet on. So we stop reading packets here and force ourselves to
// send the clc_move on the next frame.
if ( ! u . m_bAsDelta )
{
m_flNextCmdTime = 0.0 ; // answer ASAP to confirm full update tick
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pHead -
// *pClassName -
// Output : static ClientClass*
//-----------------------------------------------------------------------------
ClientClass * CBaseClientState : : FindClientClass ( const char * pClassName )
{
if ( ! pClassName )
return NULL ;
for ( ClientClass * pCur = ClientDLL_GetAllClasses ( ) ; pCur ; pCur = pCur - > m_pNext )
{
if ( Q_stricmp ( pCur - > m_pNetworkName , pClassName ) = = 0 )
return pCur ;
}
return NULL ;
}
bool CBaseClientState : : LinkClasses ( )
{
// // Verify that we have received info about all classes.
// for ( int i=0; i < m_nServerClasses; i++ )
// {
// if ( !m_pServerClasses[i].m_DatatableName )
// {
// Host_EndGame(true, "CL_ParseClassInfo_EndClasses: class %d not initialized.\n", i);
// return false;
// }
// }
// Match the server classes to the client classes.
for ( int i = 0 ; i < m_nServerClasses ; i + + )
{
C_ServerClassInfo * pServerClass = & m_pServerClasses [ i ] ;
if ( ! pServerClass - > m_DatatableName )
continue ;
// (this can be null in which case we just use default behavior).
pServerClass - > m_pClientClass = FindClientClass ( pServerClass - > m_ClassName ) ;
if ( pServerClass - > m_pClientClass )
{
// If the class names match, then their datatables must match too.
// It's ok if the client is missing a class that the server has. In that case,
// if the server actually tries to use it, the client will bomb out.
const char * pServerName = pServerClass - > m_DatatableName ;
const char * pClientName = pServerClass - > m_pClientClass - > m_pRecvTable - > GetName ( ) ;
if ( Q_stricmp ( pServerName , pClientName ) ! = 0 )
{
Host_EndGame ( true , " CL_ParseClassInfo_EndClasses: server and client classes for '%s' use different datatables (server: %s, client: %s) " ,
pServerClass - > m_ClassName , pServerName , pClientName ) ;
return false ;
}
// copy class ID
pServerClass - > m_pClientClass - > m_ClassID = i ;
}
else
{
Msg ( " Client missing DT class %s \n " , pServerClass - > m_ClassName ) ;
}
}
return true ;
}
PackedEntity * CBaseClientState : : GetEntityBaseline ( int iBaseline , int nEntityIndex )
{
Assert ( ( iBaseline = = 0 ) | | ( iBaseline = = 1 ) ) ;
return m_pEntityBaselines [ iBaseline ] [ nEntityIndex ] ;
}
void CBaseClientState : : FreeEntityBaselines ( )
{
for ( int i = 0 ; i < 2 ; i + + )
{
for ( int j = 0 ; j < MAX_EDICTS ; j + + )
if ( m_pEntityBaselines [ i ] [ j ] )
{
delete m_pEntityBaselines [ i ] [ j ] ;
m_pEntityBaselines [ i ] [ j ] = NULL ;
}
}
}
void CBaseClientState : : SetEntityBaseline ( int iBaseline , ClientClass * pClientClass , int index , char * packedData , int length )
{
VPROF ( " CBaseClientState::SetEntityBaseline " ) ;
Assert ( index > = 0 & & index < MAX_EDICTS ) ;
Assert ( pClientClass ) ;
Assert ( ( iBaseline = = 0 ) | | ( iBaseline = = 1 ) ) ;
PackedEntity * entitybl = m_pEntityBaselines [ iBaseline ] [ index ] ;
if ( ! entitybl )
{
entitybl = m_pEntityBaselines [ iBaseline ] [ index ] = new PackedEntity ( ) ;
}
entitybl - > m_pClientClass = pClientClass ;
entitybl - > m_nEntityIndex = index ;
entitybl - > m_pServerClass = NULL ;
// Copy out the data we just decoded.
entitybl - > AllocAndCopyPadded ( packedData , length ) ;
}
void CBaseClientState : : CopyEntityBaseline ( int iFrom , int iTo )
{
Assert ( iFrom ! = iTo ) ;
for ( int i = 0 ; i < MAX_EDICTS ; i + + )
{
PackedEntity * blfrom = m_pEntityBaselines [ iFrom ] [ i ] ;
PackedEntity * blto = m_pEntityBaselines [ iTo ] [ i ] ;
if ( ! blfrom )
{
// make sure blto doesn't exists
if ( blto )
{
// ups, we already had this entity but our ack got lost
// we have to remove it again to stay in sync
delete m_pEntityBaselines [ iTo ] [ i ] ;
m_pEntityBaselines [ iTo ] [ i ] = NULL ;
}
continue ;
}
if ( ! blto )
{
// create new to baseline if none existed before
blto = m_pEntityBaselines [ iTo ] [ i ] = new PackedEntity ( ) ;
blto - > m_pClientClass = NULL ;
blto - > m_pServerClass = NULL ;
blto - > m_ReferenceCount = 0 ;
}
Assert ( blfrom - > m_nEntityIndex = = i ) ;
Assert ( ! blfrom - > IsCompressed ( ) ) ;
blto - > m_nEntityIndex = blfrom - > m_nEntityIndex ;
blto - > m_pClientClass = blfrom - > m_pClientClass ;
blto - > m_pServerClass = blfrom - > m_pServerClass ;
blto - > AllocAndCopyPadded ( blfrom - > GetData ( ) , blfrom - > GetNumBytes ( ) ) ;
}
}
ClientClass * CBaseClientState : : GetClientClass ( int index )
{
Assert ( index < m_nServerClasses ) ;
return m_pServerClasses [ index ] . m_pClientClass ;
}
bool CBaseClientState : : GetClassBaseline ( int iClass , void const * * pData , int * pDatalen )
{
ErrorIfNot (
iClass > = 0 & & iClass < m_nServerClasses ,
( " GetDynamicBaseline: invalid class index '%d' " , iClass ) ) ;
// We lazily update these because if you connect to a server that's already got some dynamic baselines,
// you'll get the baselines BEFORE you get the class descriptions.
C_ServerClassInfo * pInfo = & m_pServerClasses [ iClass ] ;
INetworkStringTable * pBaselineTable = GetStringTable ( INSTANCE_BASELINE_TABLENAME ) ;
ErrorIfNot ( pBaselineTable ! = NULL , ( " GetDynamicBaseline: NULL baseline table " ) ) ;
if ( pInfo - > m_InstanceBaselineIndex = = INVALID_STRING_INDEX )
{
// The key is the class index string.
char str [ 64 ] ;
Q_snprintf ( str , sizeof ( str ) , " %d " , iClass ) ;
pInfo - > m_InstanceBaselineIndex = pBaselineTable - > FindStringIndex ( str ) ;
if ( pInfo - > m_InstanceBaselineIndex = = INVALID_STRING_INDEX )
{
for ( int i = 0 ; i < pBaselineTable - > GetNumStrings ( ) ; + + i )
{
DevMsg ( " %i: %s \n " , i , pBaselineTable - > GetString ( i ) ) ;
}
// Gets a callstack, whereas ErrorIfNot(), does not.
Assert ( 0 ) ;
}
ErrorIfNot (
pInfo - > m_InstanceBaselineIndex ! = INVALID_STRING_INDEX ,
( " GetDynamicBaseline: FindStringIndex(%s-%s) failed. " , str , pInfo - > m_ClassName ) ;
) ;
}
* pData = pBaselineTable - > GetStringUserData ( pInfo - > m_InstanceBaselineIndex , pDatalen ) ;
return * pData ! = NULL ;
}
bool CBaseClientState : : ProcessGameEventList ( SVC_GameEventList * msg )
{
VPROF ( " ProcessGameEventList " ) ;
return g_GameEventManager . ParseEventList ( msg ) ;
}
bool CBaseClientState : : ProcessGetCvarValue ( SVC_GetCvarValue * msg )
{
VPROF ( " ProcessGetCvarValue " ) ;
// Prepare the response.
CLC_RespondCvarValue returnMsg ;
returnMsg . m_iCookie = msg - > m_iCookie ;
returnMsg . m_szCvarName = msg - > m_szCvarName ;
returnMsg . m_szCvarValue = " " ;
returnMsg . m_eStatusCode = eQueryCvarValueStatus_CvarNotFound ;
char tempValue [ 256 ] ;
// Does any ConCommand exist with this name?
const ConVar * pVar = g_pCVar - > FindVar ( msg - > m_szCvarName ) ;
if ( pVar )
{
if ( pVar - > IsFlagSet ( FCVAR_SERVER_CANNOT_QUERY ) )
{
// The server isn't allowed to query this.
returnMsg . m_eStatusCode = eQueryCvarValueStatus_CvarProtected ;
}
else
{
returnMsg . m_eStatusCode = eQueryCvarValueStatus_ValueIntact ;
if ( pVar - > IsFlagSet ( FCVAR_NEVER_AS_STRING ) )
{
// The cvar won't store a string, so we have to come up with a string for it ourselves.
if ( fabs ( pVar - > GetFloat ( ) - pVar - > GetInt ( ) ) < 0.001f )
{
Q_snprintf ( tempValue , sizeof ( tempValue ) , " %d " , pVar - > GetInt ( ) ) ;
}
else
{
Q_snprintf ( tempValue , sizeof ( tempValue ) , " %f " , pVar - > GetFloat ( ) ) ;
}
returnMsg . m_szCvarValue = tempValue ;
}
else
{
// The easy case..
returnMsg . m_szCvarValue = pVar - > GetString ( ) ;
}
}
}
else
{
if ( g_pCVar - > FindCommand ( msg - > m_szCvarName ) )
returnMsg . m_eStatusCode = eQueryCvarValueStatus_NotACvar ; // It's a command, not a cvar.
else
returnMsg . m_eStatusCode = eQueryCvarValueStatus_CvarNotFound ;
}
// Send back.
m_NetChannel - > SendNetMsg ( returnMsg ) ;
return true ;
}
// Returns dem file protocol version, or, if not playing a demo, just returns PROTOCOL_VERSION
int CBaseClientState : : GetDemoProtocolVersion ( ) const
{
# ifndef SWDS // why is demo play undefined? it shuold be fine on a dedicated server
if ( demoplayer - > IsPlayingBack ( ) )
{
return demoplayer - > GetProtocolVersion ( ) ;
}
# endif
return PROTOCOL_VERSION ;
}
bool CBaseClientState : : ProcessCmdKeyValues ( SVC_CmdKeyValues * msg )
{
return true ;
}
bool CBaseClientState : : IsClientConnectionViaMatchMaking ( void )
{
return ( V_strnistr ( cl_connectmethod . GetString ( ) , " quickplay " , 9 ) | | V_strnistr ( cl_connectmethod . GetString ( ) , " matchmaking " , 11 ) ) ;
}