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.
 
 
 
 
 
 

267 lines
9.9 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#ifndef BASESERVER_H
#define BASESERVER_H
#ifdef _WIN32
#pragma once
#endif
#include <iserver.h>
#include <netadr.h>
#include <bitbuf.h>
#include <utlvector.h>
#include "baseclient.h"
#include "netmessages.h"
#include "net.h"
#include "event_system.h"
class CNetworkStringTableContainer;
class PackedEntity;
class ServerClass;
class INetworkStringTable;
enum server_state_t
{
ss_dead = 0, // Dead
ss_loading, // Spawning
ss_active, // Running
ss_paused, // Running, but paused
};
// See baseserver.cpp for #define which controls this
bool AllowDebugDedicatedServerOutsideSteam();
// time a challenge nonce is valid for, in seconds
#define CHALLENGE_NONCE_LIFETIME 6.0f
// MAX_DELTA_TICKS defines the maximum delta difference allowed
// for delta compression, if clients request on older tick as
// delta baseline, send a full update.
#define MAX_DELTA_TICKS 192 // this is about 3 seconds
typedef struct
{
netadr_t adr; // Address where challenge value was sent to.
int challenge; // To connect, adr IP address must respond with this #
float time; // # is valid for only a short duration.
} challenge_t;
class CBaseServer : public IServer
{
public:
CBaseServer();
virtual ~CBaseServer();
bool RestartOnLevelChange() { return m_bRestartOnLevelChange; }
public: // IServer implementation
virtual int GetNumClients( void ) const; // returns current number of clients
virtual int GetNumProxies( void ) const; // returns number of attached HLTV proxies
virtual int GetNumFakeClients() const; // returns number of fake clients/bots
virtual int GetMaxClients( void ) const { return m_nMaxclients; } // returns current client limit
virtual int GetUDPPort( void ) const { return NET_GetUDPPort( m_Socket ); }
virtual IClient *GetClient( int index ) { return m_Clients[index]; } // returns interface to client
virtual int GetClientCount() const { return m_Clients.Count(); } // for iteration;
virtual float GetTime( void ) const;
virtual int GetTick( void ) const { return m_nTickCount; }
virtual float GetTickInterval( void ) const { return m_flTickInterval; }
virtual const char *GetName( void ) const;
virtual const char *GetMapName( void ) const { return m_szMapname; }
virtual int GetSpawnCount( void ) const { return m_nSpawnCount; }
virtual int GetNumClasses( void ) const { return serverclasses; }
virtual int GetClassBits( void ) const { return serverclassbits; }
virtual void GetNetStats( float &avgIn, float &avgOut );
virtual int GetNumPlayers();
virtual bool GetPlayerInfo( int nClientIndex, player_info_t *pinfo );
virtual float GetCPUUsage( void ) { return m_fCPUPercent; }
virtual bool IsActive( void ) const { return m_State >= ss_active; }
virtual bool IsLoading( void ) const { return m_State == ss_loading; }
virtual bool IsDedicated( void ) const { return m_bIsDedicated; }
virtual bool IsPaused( void ) const { return m_State == ss_paused; }
virtual bool IsMultiplayer( void ) const { return m_nMaxclients > 1; }
virtual bool IsPausable( void ) const { return false; }
virtual bool IsHLTV( void ) const { return false; }
virtual bool IsReplay( void ) const { return false; }
virtual void BroadcastMessage( INetMessage &msg, bool onlyActive = false, bool reliable = false );
virtual void BroadcastMessage( INetMessage &msg, IRecipientFilter &filter );
virtual void BroadcastPrintf ( PRINTF_FORMAT_STRING const char *fmt, ...) FMTFUNCTION( 2, 3 );
virtual const char * GetPassword() const;
virtual void SetMaxClients( int number );
virtual void SetPaused(bool paused);
virtual void SetPassword(const char *password);
virtual void DisconnectClient(IClient *client, const char *reason );
virtual void WriteDeltaEntities( CBaseClient *client, CClientFrame *to, CClientFrame *from, bf_write &pBuf );
virtual void WriteTempEntities( CBaseClient *client, CFrameSnapshot *to, CFrameSnapshot *from, bf_write &pBuf, int nMaxEnts );
public: // IConnectionlessPacketHandler implementation
virtual bool ProcessConnectionlessPacket( netpacket_t * packet );
virtual void Init( bool isDedicated );
virtual void Clear( void );
virtual void Shutdown( void );
virtual CBaseClient *CreateFakeClient( const char *name );
virtual void RemoveClientFromGame( CBaseClient *client ) {};
virtual void SendClientMessages ( bool bSendSnapshots );
virtual void FillServerInfo(SVC_ServerInfo &serverinfo);
virtual void UserInfoChanged( int nClientIndex );
bool GetClassBaseline( ServerClass *pClass, void const **pData, int *pDatalen );
void RunFrame( void );
void InactivateClients( void );
void ReconnectClients( void );
void CheckTimeouts (void);
void UpdateUserSettings(void);
void SendPendingServerInfo(void);
const char *CompressPackedEntity(ServerClass *pServerClass, const char *data, int &bits);
const char *UncompressPackedEntity(PackedEntity *pPackedEntity, int &size);
INetworkStringTable *GetInstanceBaselineTable( void );
INetworkStringTable *GetLightStyleTable( void );
INetworkStringTable *GetUserInfoTable( void );
virtual void RejectConnection(const netadr_t &adr, int clientChallenge, const char *s );
float GetFinalTickTime( void ) const;
virtual bool CheckIPRestrictions( const netadr_t &adr, int nAuthProtocol );
void SetMasterServerRulesDirty();
void SendQueryPortToClient( netadr_t &adr );
void RecalculateTags( void );
void AddTag( const char *pszTag );
void RemoveTag( const char *pszTag );
int GetNumConnections( ) { return m_nNumConnections; }
void SetReportNewFakeClients( bool bReportNewFakeClients ) { m_bReportNewFakeClients = bReportNewFakeClients; }
void SetPausedForced( bool bPaused, float flDuration = -1.f );
protected:
virtual IClient *ConnectClient ( netadr_t &adr, int protocol, int challenge, int clientChallenge, int authProtocol,
const char *name, const char *password, const char *hashedCDkey, int cdKeyLen );
virtual CBaseClient *GetFreeClient( netadr_t &adr );
virtual CBaseClient *CreateNewClient( int slot ) { AssertMsg( 0, "CBaseServer::CreateNewClient() being called - must be implemented in derived class!" ); return NULL; }; // must be derived
virtual bool FinishCertificateCheck( netadr_t &adr, int nAuthProtocol, const char *szRawCertificate, int clientChallenge ) { return true; };
virtual int GetChallengeNr ( netadr_t &adr );
virtual int GetChallengeType ( netadr_t &adr );
virtual bool CheckProtocol( netadr_t &adr, int nProtocol, int clientChallenge );
virtual bool CheckChallengeNr( netadr_t &adr, int nChallengeValue );
virtual bool CheckChallengeType( CBaseClient *client, int nNewUserID, netadr_t & adr, int nAuthProtocol, const char *pchLogonCookie, int cbCookie, int clientChallenge );
virtual bool CheckPassword( netadr_t &adr, const char *password, const char *name );
virtual bool CheckIPConnectionReuse( netadr_t &adr );
virtual void ReplyChallenge(netadr_t &adr, int clientChallenge);
virtual void ReplyServerChallenge(netadr_t &adr);
virtual void CalculateCPUUsage();
// Keep the master server data updated.
virtual bool ShouldUpdateMasterServer();
void CheckMasterServerRequestRestart();
void UpdateMasterServer();
void UpdateMasterServerRules();
virtual void UpdateMasterServerPlayers() {}
void ForwardPacketsFromMasterServerUpdater();
void SetRestartOnLevelChange(bool state) { m_bRestartOnLevelChange = state; }
bool RequireValidChallenge( netadr_t &adr );
bool ValidChallenge( netadr_t & adr, int challengeNr );
bool ValidInfoChallenge( netadr_t & adr, const char *nugget );
// Data
public:
server_state_t m_State; // some actions are only valid during load
int m_Socket; // network socket
int m_nTickCount; // current server tick
bool m_bSimulatingTicks; // whether or not the server is currently simulating ticks
char m_szMapname[64]; // map name
char m_szMapFilename[64]; // map filename, may bear no resemblance to map name
char m_szSkyname[64]; // skybox name
char m_Password[32]; // server password
MD5Value_t worldmapMD5; // For detecting that client has a hacked local copy of map, the client will be dropped if this occurs.
CNetworkStringTableContainer *m_StringTables; // newtork string table container
INetworkStringTable *m_pInstanceBaselineTable;
INetworkStringTable *m_pLightStyleTable;
INetworkStringTable *m_pUserInfoTable;
INetworkStringTable *m_pServerStartupTable;
INetworkStringTable *m_pDownloadableFileTable;
// This will get set to NET_MAX_PAYLOAD if the server is MP.
bf_write m_Signon;
CUtlMemory<byte> m_SignonBuffer;
int serverclasses; // number of unique server classes
int serverclassbits; // log2 of serverclasses
private:
// Gets the next user ID mod SHRT_MAX and unique (not used by any active clients).
int GetNextUserID();
int m_nUserid; // increases by one with every new client
protected:
int m_nMaxclients; // Current max #
int m_nSpawnCount; // Number of servers spawned since start,
// used to check late spawns (e.g., when d/l'ing lots of
// data)
float m_flTickInterval; // time for 1 tick in seconds
CUtlVector<CBaseClient*> m_Clients; // array of up to [maxclients] client slots.
bool m_bIsDedicated;
uint32 m_CurrentRandomNonce;
uint32 m_LastRandomNonce;
float m_flLastRandomNumberGenerationTime;
float m_fCPUPercent;
float m_fStartTime;
float m_fLastCPUCheckTime;
// This is only used for Steam's master server updater to refer to this server uniquely.
bool m_bRestartOnLevelChange;
bool m_bMasterServerRulesDirty;
double m_flLastMasterServerUpdateTime;
int m_nNumConnections; //Number of successful client connections.
bool m_bReportNewFakeClients; // Whether or not newly created fake clients should be included in server browser totals
float m_flPausedTimeEnd;
};
extern CThreadFastMutex g_svInstanceBaselineMutex;
#endif // BASESERVER_H