608 lines
20 KiB
C++
608 lines
20 KiB
C++
|
//========= 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
|
||
|
|
|