268 lines
9.9 KiB
C++
268 lines
9.9 KiB
C++
//========= 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
|