source-engine/gcsdk/gcsession.cpp

608 lines
20 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Holds the CGCSession class
//
//=============================================================================
#include "stdafx.h"
#include "gcsession.h"
#include "steamextra/rtime.h"
#include "gcsdk_gcmessages.pb.h"
#include "gcsdk/gcreportprinter.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Probably this makes more sense true by default, but we're spewing a ton and Fletcher says it
// isn't a big deal for TF so here we go.
GCConVar gs_session_assert_valid_addr_and_port( "gs_session_assert_valid_addr_and_port", "0" );
namespace GCSDK
{
DECLARE_GC_EMIT_GROUP( g_EGSessions, sessions );
DECLARE_GC_EMIT_GROUP_DEFAULTS( g_EGRateLimit, ratelimit, 2, 3 );
GCConVar max_user_messages_per_second( "max_user_messages_per_second", "20", 0, "Maximum number of messages a user can send per second. 0 disables the rate limiting" );
static GCConVar user_message_rate_limit_warning_period( "user_message_rate_limit_warning_period", "30", 0, "Number of seconds between warning about rate limiting for users" );
static GCConVar msg_rate_limit_report_user_bucket_1( "msg_rate_limit_report_user_bucket_1", "10", 0, "These values control where various users are bucketed in rate limiting reports to help identify how frequently users are running into rate limiting" );
static GCConVar msg_rate_limit_report_user_bucket_2( "msg_rate_limit_report_user_bucket_2", "100", 0, "These values control where various users are bucketed in rate limiting reports to help identify how frequently users are running into rate limiting" );
static GCConVar msg_rate_limit_list_user( "msg_rate_limit_list_user", "0", 0, "When set to a user account ID, this will report all the messages that are rate limited for that user to the console" );
CMsgRateLimitTracker g_RateLimitTracker;
CMsgRateLimitTracker::CMsgRateLimitTracker() :
m_StartTime( CRTime::RTime32TimeCur() )
{
}
void CMsgRateLimitTracker::TrackRateLimitedMsg( const CSteamID steamID, MsgType_t eMsgType )
{
//update message stat
{
uint32 nMsgIndex = m_MsgStats.Find( eMsgType );
if( !m_MsgStats.IsValidIndex( nMsgIndex ) )
{
nMsgIndex = m_MsgStats.Insert( eMsgType, 0 );
}
m_MsgStats[ nMsgIndex ]++;
}
//update user stats
{
uint32 nUserIndex = m_UserStats.Find( steamID );
if( !m_UserStats.IsValidIndex( nUserIndex ) )
{
nUserIndex = m_UserStats.Insert( steamID, 0 );
}
m_UserStats[ nUserIndex ]++;
}
//determine the severity to output the warning at. Assume verbose unless we are tracking a specific account ID (note that no account has 0 so 0 still effectively turns it off)
CGCEmitGroup::EMsgLevel eMsgLevel = CGCEmitGroup::kMsg_Verbose;
if( ( uint32 )msg_rate_limit_list_user.GetInt() == steamID.GetAccountID() )
{
eMsgLevel = CGCEmitGroup::kMsg_Msg;
}
EG_EMIT( g_EGMessages, eMsgLevel, "Dropped message %s (%d) for user %s\n", PchMsgNameFromEMsg( eMsgType ), eMsgType, steamID.Render() );
}
void CMsgRateLimitTracker::ReportMsgStats() const
{
CGCReportPrinter rp;
rp.AddStringColumn( "Msg" );
rp.AddIntColumn( "Count", CGCReportPrinter::eSummary_Total );
FOR_EACH_MAP_FAST( m_MsgStats, nCurrMsg )
{
rp.StrValue( PchMsgNameFromEMsg( m_MsgStats.Key( nCurrMsg ) ) );
rp.IntValue( m_MsgStats[ nCurrMsg ] );
rp.CommitRow();
}
rp.SortReport( "Count" );
rp.PrintReport( SPEW_CONSOLE );
}
void CMsgRateLimitTracker::ReportTopUsers( uint32 nMinMsgs, uint32 nListTop ) const
{
//collect a list of all messages, and sort them into order of frequency
CGCReportPrinter rp;
rp.AddSteamIDColumn( "User" );
rp.AddIntColumn( "Count", CGCReportPrinter::eSummary_Total );
FOR_EACH_MAP_FAST( m_UserStats, nCurrMsg )
{
rp.SteamIDValue( m_UserStats.Key( nCurrMsg ) );
rp.IntValue( m_UserStats[ nCurrMsg ] );
rp.CommitRow();
}
rp.SortReport( "Count" );
rp.PrintReport( SPEW_CONSOLE, nListTop );
}
void CMsgRateLimitTracker::ReportUserStats() const
{
//run through the users and aggregate stats
const uint32 nBucketLimit1 = ( uint32 )max( 0, min( msg_rate_limit_report_user_bucket_1.GetInt(), msg_rate_limit_report_user_bucket_2.GetInt() ) );
const uint32 nBucketLimit2 = ( uint32 )max( 0, max( msg_rate_limit_report_user_bucket_1.GetInt(), msg_rate_limit_report_user_bucket_2.GetInt() ) );
uint32 nTotalMsg = 0;
uint32 nMaxUser = 0;
uint32 nBucketCount1 = 0;
uint32 nBucketCount2 = 0;
FOR_EACH_MAP_FAST( m_UserStats, nCurrMsg )
{
//add user counts to the buckets
const uint32 nMsgs = m_UserStats[ nCurrMsg ];
if( nMsgs <= nBucketLimit1 )
nBucketCount1++;
else if( nMsgs <= nBucketLimit2 )
nBucketCount2++;
//add up our total number of offenses
nTotalMsg += nMsgs;
nMaxUser = max( nMaxUser, nMsgs );
}
EG_MSG( SPEW_CONSOLE, "Capture Duration: %ds\n", CRTime::RTime32TimeCur() - m_StartTime );
EG_MSG( SPEW_CONSOLE, "Total Dropped Messages: %d\n", nTotalMsg );
EG_MSG( SPEW_CONSOLE, "Message IDs: %d\n", m_MsgStats.Count() );
EG_MSG( SPEW_CONSOLE, "Users: %d (peak: %d)\n", m_UserStats.Count(), nMaxUser );
EG_MSG( SPEW_CONSOLE, " Below %d msgs: %d\n", nBucketLimit1, nBucketCount1 );
EG_MSG( SPEW_CONSOLE, " Below %d msgs: %d\n", nBucketLimit2, nBucketCount2 );
}
void CMsgRateLimitTracker::ClearStats()
{
m_StartTime = CRTime::RTime32TimeCur();
m_UserStats.RemoveAll();
m_MsgStats.RemoveAll();
}
//console command hooks
GC_CON_COMMAND( msg_rate_limit_dump, "Dumps stats about rate limiting of messages" )
{
g_RateLimitTracker.ReportUserStats();
g_RateLimitTracker.ReportMsgStats();
g_RateLimitTracker.ReportTopUsers( 0, 20 );
}
GC_CON_COMMAND( msg_rate_limit_dump_users, "Dumps a list of users that have been rate limited. Optional parameters can specify the number to dump or the minimum number of messages required." )
{
if( args.ArgC() < 3 )
{
EG_MSG( SPEW_CONSOLE, "Proper usage is: %s <min messages> <top users> - Specify 0 for one or both to have it be ignored\n", args[ 0 ] );
return;
}
g_RateLimitTracker.ReportTopUsers( ( uint32 )max( 0, atoi( args[ 1 ] ) ), ( uint32 )max( 0, atoi( args[ 2 ] ) ) );
}
GC_CON_COMMAND( msg_rate_limit_dump_msgs, "Dumps a list of messages that have been rate limited." )
{
g_RateLimitTracker.ReportMsgStats();
}
GC_CON_COMMAND( msg_rate_limit_clear, "Clears all the accumulated msg rate limit stats" )
{
g_RateLimitTracker.ClearStats();
}
//------------------------------------------------------------------------------------------
// CSteamIDRateLimit
//------------------------------------------------------------------------------------------
CSteamIDRateLimit::CSteamIDRateLimit( const GCConVar& cvNumPerPeriod, const GCConVar* pcvPeriodS ) :
m_cvNumPerPeriod( cvNumPerPeriod ),
m_pcvPeriodS( pcvPeriodS ),
m_LastClear( CRTime::RTime32TimeCur() ),
m_FrameFunction( "SteamIDRateLimit", CBaseFrameFunction::k_EFrameType_RunOnce )
{
m_FrameFunction.Register( this, &CSteamIDRateLimit::OnFrameFn );
}
CSteamIDRateLimit::~CSteamIDRateLimit()
{
}
bool CSteamIDRateLimit::BIsRateLimited( CSteamID steamID, uint32 unMsgType )
{
int nIndex = m_Msgs.FindOrInsert( steamID, 0 );
if( ++m_Msgs[ nIndex ] >= ( uint32 )m_cvNumPerPeriod.GetInt() )
{
g_RateLimitTracker.TrackRateLimitedMsg( steamID, unMsgType );
return true;
}
return false;
}
bool CSteamIDRateLimit::OnFrameFn( const CLimitTimer& timer )
{
//if no period is specified, assume one second
int nIntervalS = ( m_pcvPeriodS ) ? MAX( 1, m_pcvPeriodS->GetInt() ) : 1;
if( CRTime::RTime32TimeCur() >= m_LastClear + nIntervalS )
{
m_Msgs.RemoveAll();
m_LastClear = CRTime::RTime32TimeCur();
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGCSession::CGCSession( const CSteamID & steamID, CGCSharedObjectCache *pSOCache )
: m_steamID( steamID ),
m_pSOCache( pSOCache ),
m_bIsShuttingDown( false ),
m_osType( k_eOSUnknown ),
m_bIsTestSession( false ),
m_bIsSecure( false ),
m_unIPPublic( 0 ),
m_flLatitude( 0.0f ),
m_flLongitude( 0.0f ) ,
m_haveGeoLocation( false ),
m_bInitialized( false ),
m_rtLastMessageReceived( 0 )
{
m_jtLastMessageReceived.SetLTime( 0 );
m_jtTimeSentPing.SetLTime( 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGCSession::~CGCSession()
{
}
//-----------------------------------------------------------------------------
// Purpose: Checks the message against rate limiting. Returns true if we should
// drop the message. False otherwise. This default behavior is a very basic
// n messages / user / second rate limiting that's only meant to stop the
// worse abuses
//-----------------------------------------------------------------------------
bool CGCSession::BRateLimitMessage( MsgType_t unMsgType )
{
unMsgType &= ~k_EMsgProtoBufFlag;
if ( max_user_messages_per_second.GetInt() <= 0 )
return false;
RTime32 rtCur = CRTime::RTime32TimeCur();
m_jtLastMessageReceived.SetToJobTime();
if ( m_rtLastMessageReceived != rtCur )
{
m_rtLastMessageReceived = rtCur;
m_unMessagesRecievedThisSecond = 0;
}
m_unMessagesRecievedThisSecond++;
if ( m_unMessagesRecievedThisSecond > (uint32)max_user_messages_per_second.GetInt() )
{
//log this message
g_RateLimitTracker.TrackRateLimitedMsg( GetSteamID(), unMsgType );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: The run function is called on each session (user and gameserver)
// approximately every k_nUserSessionRunInterval microseconds (or
// k_nGSSessionRunInterval for GS Sessions)
//-----------------------------------------------------------------------------
void CGCSession::Run()
{
// These cached subscription messages are very expensive and only needed for a short period of time
// If we're hitting the run loop, it's been around long enough
GetSOCache()->ClearCachedSubscriptionMessage();
}
//-----------------------------------------------------------------------------
bool CGCSession::GetGeoLocation( float &latitude, float &longittude ) const
{
latitude = m_flLatitude;
longittude = m_flLongitude;
return m_haveGeoLocation;
}
//-----------------------------------------------------------------------------
void CGCSession::SetGeoLocation( float latitude, float longittude )
{
m_flLatitude = latitude;
m_flLongitude = longittude;
m_haveGeoLocation = true;
}
//-----------------------------------------------------------------------------
// Purpose: Claims all the memory for the session object
//-----------------------------------------------------------------------------
#ifdef DBGFLAG_VALIDATE
void CGCSession::Validate( CValidator &validator, const char *pchName )
{
VALIDATE_SCOPE();
}
#endif // DBGFLAG_VALIDATE
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGCUserSession::~CGCUserSession()
{
if ( m_steamIDGS.BGameServerAccount() )
{
EmitError( SPEW_GC, "Destroying user %s while still connected to server %s\n", GetSteamID().Render(), GetSteamIDGS().Render() );
}
}
bool CGCUserSession::BInit()
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the session's game server to the given SteamID. This will
// cause the session to leave the current server it's on, it any
// Returns: True if the user's session was added to the GS's session.
// False if the session could not be found or if the user was already
// on the server.
//-----------------------------------------------------------------------------
bool CGCUserSession::BSetServer( const CSteamID &steamIDGS )
{
if ( steamIDGS == m_steamIDGS )
return false;
BLeaveServer();
if( steamIDGS.IsValid() )
{
CGCGSSession *pGSSession = GGCBase()->FindGSSession( steamIDGS );
if ( !pGSSession )
{
EmitError( SPEW_GC, "User %s attempting to join server %s which has no session\n", GetSteamID().Render(), steamIDGS.Render() );
return false;
}
if ( !pGSSession->BAddUser( GetSteamID() ) )
{
EmitWarning( SPEW_GC, SPEW_ALWAYS, "Server %s already had user %s in its user list\n", steamIDGS.Render(), GetSteamID().Render() );
// Fall through
}
}
m_steamIDGS = steamIDGS;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Removes the session from the given game server
// Returns: True if the user's session was removed from the GS's session.
// False if the session could not be found or if the user was not found
// on the server.
//-----------------------------------------------------------------------------
bool CGCUserSession::BLeaveServer()
{
if( m_steamIDGS.IsValid() )
{
// Remember the last server we were connected to
m_steamIDGSPrev = m_steamIDGS;
CGCGSSession *pGSSession = GGCBase()->FindGSSession( m_steamIDGS );
if ( pGSSession )
{
pGSSession->BRemoveUser( GetSteamID() );
}
}
m_steamIDGS = CSteamID();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Dumps useful information about this session
//-----------------------------------------------------------------------------
void CGCUserSession::Dump( bool bFull ) const
{
// this is ifdef'd out in Steam because GCSDK can't depend on steamid.cpp
#ifndef STEAM
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "User Session %s (%s)\n", GetSteamID().Render(), BIsShuttingDown() ? "SHUTTING DOWN" : "Active" );
CJob *pJob = GGCBase()->PJobHoldingLock( GetSteamID() );
if( pJob )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\t LOCKED BY: %s\n", pJob->GetName() );
}
if( bFull && GetSOCache() )
GetSOCache()->Dump();
if( GetSteamIDGS().BGameServerAccount() )
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tGameserver: %s\n", GetSteamIDGS().Render() );
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tOS: %d Secure: %d\n", GetOSType(), IsSecure() ? 1 : 0 );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CGCGSSession::CGCGSSession( const CSteamID & steamID, CGCSharedObjectCache *pCache, uint32 unServerAddr, uint16 usServerPort )
: CGCSession( steamID, pCache ), m_unServerAddr( unServerAddr ), m_usServerPort( usServerPort )
{
if ( gs_session_assert_valid_addr_and_port.GetBool() )
{
Assert( unServerAddr );
Assert( usServerPort );
}
// Default our public IP to be the same as our IP address
m_unIPPublic = unServerAddr;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CGCGSSession::~CGCGSSession()
{
if ( m_vecUsers.Count() > 0 )
{
EmitError( SPEW_GC, "Destroying game server %s while %d users are still connected\n", GetSteamID().Render(), m_vecUsers.Count() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Adds a user to the list of users active on the game server
// Returns: True if the user was added, false if the user was already on this
// server.
//-----------------------------------------------------------------------------
bool CGCGSSession::BAddUser( const CSteamID &steamIDUser )
{
if( m_vecUsers.HasElement( steamIDUser ) )
return false;
PreAddUser( steamIDUser );
m_vecUsers.AddToTail( steamIDUser );
PostAddUser( steamIDUser );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Called if our IP / port changes after session is started
//-----------------------------------------------------------------------------
void CGCGSSession::SetIPAndPort( uint32 unServerAddr, uint16 usServerPort )
{
// If we didn't have an override for the public IP, then also
// update the public IP.
//
// !KLUDGE! This is gross for two reasons:
// - First, do we really need two different fields?
// - Second, why can the IP change after the session is created?
// Shouldn't we force the session to be destroyed and recreated?
// It cannot *really* be the same "session", can it?
if ( m_unIPPublic == m_unServerAddr )
m_unIPPublic = unServerAddr;
m_unServerAddr = unServerAddr;
m_usServerPort = usServerPort;
}
//-----------------------------------------------------------------------------
// Purpose: Removes a user from the list of users active on the game server
// Returns: True if the user was added, false if the user was not already on
// this server.
//-----------------------------------------------------------------------------
bool CGCGSSession::BRemoveUser( const CSteamID &steamIDUser )
{
int nIndex = m_vecUsers.Find( steamIDUser );
if ( !m_vecUsers.IsValidIndex( nIndex ) )
return false;
PreRemoveUser( steamIDUser );
m_vecUsers.Remove( nIndex );
PostRemoveUser( steamIDUser );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Removes all users from the list of game server users.
//-----------------------------------------------------------------------------
void CGCGSSession::RemoveAllUsers()
{
if ( 0 == m_vecUsers.Count() )
return;
PreRemoveAllUsers();
// Iterate all the users and tell them to leave this server.
// Using back because the users will remove themselves from
// this list during this function
FOR_EACH_VEC_BACK( m_vecUsers, i )
{
CGCUserSession *pUserSession = GGCBase()->FindUserSession( m_vecUsers[i] );
if ( pUserSession )
{
pUserSession->BLeaveServer();
}
}
// Catch anyone we don't have a session for anymore
m_vecUsers.RemoveAll();
PostRemoveAllUsers();
}
#define iptod(x) ((x)>>24&0xff), ((x)>>16&0xff), ((x)>>8&0xff), ((x)&0xff)
//-----------------------------------------------------------------------------
// Purpose: Dumps useful information about this session
//-----------------------------------------------------------------------------
void CGCGSSession::Dump( bool bFull ) const
{
// this is ifdef'd out in Steam because GCSDK can't depend on steamid.cpp
#ifndef STEAM
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "GS Session %s\n", GetSteamID().Render() );
CJob *pJob = GGCBase()->PJobHoldingLock( GetSteamID() );
if( pJob )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\t LOCKED BY: %s\n", pJob->GetName() );
}
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\t%d users:\n", m_vecUsers.Count() );
FOR_EACH_VEC( m_vecUsers, nUser )
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\t\t%s\n", m_vecUsers[nUser].Render() );
}
if( GetSOCache() )
{
if ( bFull )
{
GetSOCache()->Dump();
}
else
{
EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\t SO Cache Version: %llu\n", GetSOCache()->GetVersion() );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Claims all the memory for the session object
//-----------------------------------------------------------------------------
#ifdef DBGFLAG_VALIDATE
void CGCGSSession::Validate( CValidator &validator, const char *pchName )
{
CGCSession::Validate( validator, pchName);
VALIDATE_SCOPE();
ValidateObj( m_vecUsers );
}
#endif // DBGFLAG_VALIDATE
//-----------------------------------------------------------------------------
// Purpose: Client says it needs the SO Cache
// Input : pNetPacket - received message
//-----------------------------------------------------------------------------
class CGCCacheSubscriptionRefresh: public CGCJob
{
public:
CGCCacheSubscriptionRefresh( CGCBase *pGC ) : CGCJob( pGC ) { }
bool BYieldingRunJobFromMsg( IMsgNetPacket *pNetPacket );
};
bool CGCCacheSubscriptionRefresh::BYieldingRunJobFromMsg( IMsgNetPacket *pNetPacket )
{
CProtoBufMsg<CMsgSOCacheSubscriptionRefresh> msg( pNetPacket );
CSteamID steamID( msg.Hdr().client_steam_id() );
CSteamID steamIDCacheOwner( msg.Body().owner() );
CGCSharedObjectCache *pCache = m_pGC->FindSOCache( steamIDCacheOwner );
if ( pCache == NULL || !pCache->BIsSubscribed( steamID ) )
{
return false;
}
pCache->SendSubscriberMessage( steamID );
return true;
}
GC_REG_JOB( CGCBase, CGCCacheSubscriptionRefresh, "CGCCacheSubscriptionRefresh", k_ESOMsg_CacheSubscriptionRefresh, k_EServerTypeGC );
} // namespace GCSDK