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.
236 lines
7.8 KiB
236 lines
7.8 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: Holds the CGCSession class |
|
// |
|
//============================================================================= |
|
|
|
#ifndef GCSESSION_H |
|
#define GCSESSION_H |
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
#include "scheduledfunction.h" |
|
#include "framefunction.h" |
|
#include "gcsdk/gc_sharedobjectcache.h" |
|
|
|
namespace GCSDK |
|
{ |
|
|
|
class CGCGSSession; |
|
|
|
// Spew group for anything related to sessions |
|
extern CGCEmitGroup g_EGSessions; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Utility class to handle rate limiting based upon a steam ID and message using two console variables to control rate |
|
//----------------------------------------------------------------------------- |
|
|
|
//utility class to handle rate limiting based upon a steam ID |
|
class CSteamIDRateLimit |
|
{ |
|
public: |
|
CSteamIDRateLimit( const GCConVar& cvNumPerPeriod, const GCConVar* pcvPeriodS = NULL ); |
|
~CSteamIDRateLimit(); |
|
//given a steam ID, this will determine if it should be rate limited |
|
bool BIsRateLimited( CSteamID steamID, uint32 unMsgType ); |
|
//frame function to clear the list after a period of time |
|
bool OnFrameFn( const CLimitTimer& timer ); |
|
private: |
|
//the last time we cleared our list |
|
RTime32 m_LastClear; |
|
//the frame function so we can detect when we need to clear |
|
CFrameFunction< CSteamIDRateLimit> m_FrameFunction; |
|
//the map of messages we have tracked for each user |
|
CUtlHashMapLarge< CSteamID, uint32 > m_Msgs; |
|
//the console variables that track the time window and the messages allowed |
|
const GCConVar& m_cvNumPerPeriod; |
|
const GCConVar* m_pcvPeriodS; |
|
}; |
|
|
|
//------------------------------------------------------------------------------------------ |
|
// CMsgRateLimitTracker |
|
// A utility class to track when messages go over so that we can see users/msgs that are being spammed |
|
//------------------------------------------------------------------------------------------ |
|
class CMsgRateLimitTracker |
|
{ |
|
public: |
|
|
|
CMsgRateLimitTracker(); |
|
|
|
//called to track a message that was rate limited |
|
void TrackRateLimitedMsg( const CSteamID steamID, MsgType_t eMsgType ); |
|
|
|
//called to report the collected rate limiting stats |
|
void ReportMsgStats() const; |
|
void ReportTopUsers( uint32 nMinMsgs, uint32 nListTop ) const; |
|
void ReportUserStats() const; |
|
|
|
//called to clear all collected stats |
|
void ClearStats(); |
|
|
|
private: |
|
|
|
//the time we started collecting stats at |
|
RTime32 m_StartTime; |
|
|
|
//map detailing the number of messages of each type that have been dropped |
|
CUtlHashMapLarge< MsgType_t, uint32 > m_MsgStats; |
|
CUtlHashMapLarge< CSteamID, uint32 > m_UserStats; |
|
}; |
|
extern CMsgRateLimitTracker g_RateLimitTracker; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Base class for sessions in the GC |
|
//----------------------------------------------------------------------------- |
|
class CGCSession |
|
{ |
|
public: |
|
CGCSession( const CSteamID & steamID, CGCSharedObjectCache *pCache ); |
|
virtual ~CGCSession(); |
|
|
|
const CSteamID & GetSteamID() const { return m_steamID; } |
|
|
|
const CGCSharedObjectCache *GetSOCache() const { return m_pSOCache; } |
|
CGCSharedObjectCache *GetSOCache() { return m_pSOCache; } |
|
void RemoveSOCache() { m_pSOCache = NULL; } |
|
|
|
EOSType GetOSType() const { return m_osType; }; |
|
bool IsTestSession() const { return m_bIsTestSession; } |
|
uint32 GetIPPublic() const { return m_unIPPublic; } |
|
bool IsSecure() const { return m_bIsSecure; } |
|
|
|
bool BIsShuttingDown() const { return m_bIsShuttingDown; } |
|
void SetIsShuttingDown( bool bIsShuttingDown ) { m_bIsShuttingDown = bIsShuttingDown; } |
|
|
|
virtual void Dump( bool bFull = true ) const = 0; |
|
|
|
bool BRateLimitMessage( MsgType_t unMsgType ); |
|
|
|
CJobTime GetLastPingSendTime() const { return m_jtTimeSentPing; } |
|
CJobTime GetLastMessageReceiveTime() const { return m_jtLastMessageReceived; } |
|
void SendPing() const; |
|
|
|
virtual void MarkAccess() { } |
|
virtual void Run(); |
|
virtual void YieldingSOCacheReloaded() {} |
|
#ifdef DBGFLAG_VALIDATE |
|
virtual void Validate( CValidator &validator, const char *pchName ); |
|
#endif // DBGFLAG_VALIDATE |
|
|
|
// Geolocation |
|
bool HasGeoLocation() const { return m_haveGeoLocation; } |
|
bool GetGeoLocation( float &latitude, float &longittude ) const; |
|
virtual void SetGeoLocation( float latitude, float longittude ); |
|
|
|
//track whether or not this session has been initialized or not |
|
bool BIsInitialized() const { return m_bInitialized; } |
|
void SetInitialized( bool b ) { m_bInitialized = b; } |
|
|
|
private: |
|
CSteamID m_steamID; |
|
CGCSharedObjectCache *m_pSOCache; |
|
|
|
// Tracks how many messages we've gotten this second so we can block attacks |
|
RTime32 m_rtLastMessageReceived; |
|
uint32 m_unMessagesRecievedThisSecond; |
|
CJobTime m_jtLastMessageReceived; |
|
|
|
// This is mutable because we update it when we send pings, but sending a |
|
// ping to a user/server isn't really a session changing event, so we don't |
|
// want to require locking the session to ping it and update its last |
|
// sent ping time. |
|
mutable CJobTime m_jtTimeSentPing; |
|
|
|
EOSType m_osType : 16; |
|
bool m_bIsShuttingDown : 1; |
|
bool m_bIsTestSession : 1; |
|
bool m_bIsSecure : 1; |
|
bool m_bInitialized : 1; |
|
protected: |
|
bool m_haveGeoLocation : 1; |
|
|
|
float m_flLatitude; |
|
float m_flLongitude; |
|
|
|
uint32 m_unIPPublic; |
|
|
|
friend class CGCBase; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Base class for user sessions in the GC |
|
//----------------------------------------------------------------------------- |
|
class CGCUserSession : public CGCSession |
|
{ |
|
public: |
|
CGCUserSession( const CSteamID & steamID, CGCSharedObjectCache *pCache ) : CGCSession( steamID, pCache ) { } |
|
virtual ~CGCUserSession(); |
|
|
|
virtual bool BInit(); |
|
|
|
const CSteamID &GetSteamIDGS() const { return m_steamIDGS; } |
|
const CSteamID &GetSteamIDGSPrev() const { return m_steamIDGSPrev; } |
|
|
|
virtual bool BSetServer( const CSteamID &steamIDGS ); |
|
virtual bool BLeaveServer(); |
|
virtual void Dump( bool bFull = true ) const; |
|
|
|
private: |
|
CSteamID m_steamIDGS; |
|
CSteamID m_steamIDGSPrev; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Base class for gameserver sessions in the GC |
|
//----------------------------------------------------------------------------- |
|
class CGCGSSession : public CGCSession |
|
{ |
|
public: |
|
|
|
CGCGSSession( const CSteamID & steamID, CGCSharedObjectCache *pCache, uint32 unServerAddr, uint16 usServerPort ) ; |
|
virtual ~CGCGSSession(); |
|
|
|
uint32 GetAddr() const { return m_unServerAddr; } |
|
uint16 GetPort() const { return m_usServerPort; } |
|
void SetIPAndPort( uint32 unServerAddr, uint16 usServerPort ); |
|
int GetUserCount() const { return m_vecUsers.Count(); } |
|
CSteamID GetUserID( int nIndex ) const { return m_vecUsers[nIndex]; } |
|
|
|
// Manages users on the server. It is very important that these are not |
|
// virtual and not yielding. For custom behavior override the Pre*() hooks below |
|
bool BAddUser( const CSteamID &steamIDUser ); |
|
bool BRemoveUser( const CSteamID &steamIDUser ); |
|
void RemoveAllUsers(); |
|
|
|
virtual void Dump( bool bFull = true ) const; |
|
|
|
protected: |
|
// Hooks to trigger custom behavior when users are added and removed. It is |
|
// very important that these do not yield. If you need to yield, start a job instead |
|
virtual void PreAddUser( const CSteamID &steamIDUser ) {} |
|
virtual void PostAddUser( const CSteamID &steamIDUser ) {} |
|
virtual void PreRemoveUser( const CSteamID &steamIDUser ) {} |
|
virtual void PostRemoveUser( const CSteamID &steamIDUser ) {} |
|
virtual void PreRemoveAllUsers() {} |
|
virtual void PostRemoveAllUsers() {} |
|
|
|
public: |
|
float m_lastUpdateTime; // Last time we received a message from the server |
|
|
|
#ifdef DBGFLAG_VALIDATE |
|
virtual void Validate( CValidator &validator, const char *pchName ); |
|
#endif // DBGFLAG_VALIDATE |
|
protected: |
|
CUtlVector<CSteamID> m_vecUsers; |
|
|
|
// These are the address of the server as connected to Steam |
|
uint32 m_unServerAddr; |
|
uint16 m_usServerPort; |
|
}; |
|
|
|
} // namespace GCSDK |
|
|
|
#endif // GCSESSION_H
|
|
|