diff options
Diffstat (limited to 'engine/sv_uploadgamestats.cpp')
| -rw-r--r-- | engine/sv_uploadgamestats.cpp | 1253 |
1 files changed, 1253 insertions, 0 deletions
diff --git a/engine/sv_uploadgamestats.cpp b/engine/sv_uploadgamestats.cpp new file mode 100644 index 0000000..8665b06 --- /dev/null +++ b/engine/sv_uploadgamestats.cpp @@ -0,0 +1,1253 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +// +//=============================================================================// + +#ifdef _WIN32 + +#if !defined( _X360 ) +#include <winsock.h> +#else +#include "winsockx.h" +#endif + +#elif POSIX +#define INVALID_SOCKET -1 +#define SOCKET_ERROR -1 +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +//$ #include <uuid/uuid.h> +typedef unsigned char uuid_t[16]; +#ifdef OSX +#include <uuid/uuid.h> +#else +typedef unsigned char uuid_t[16]; +#endif +#include <pwd.h> +#define closesocket close +#include "quakedef.h" // build_number() +#endif + +#include "net.h" +#include "quakedef.h" +#include "sv_uploadgamestats.h" +#include "host.h" +#include "host_phonehome.h" +#include "mathlib/IceKey.H" +#include "bitbuf.h" +#include "tier0/icommandline.h" +#include "tier0/vcrmode.h" +#include "blockingudpsocket.h" +#include "cserserverprotocol_engine.h" +#include "utlbuffer.h" +#include "eiface.h" +#include "FindSteamServers.h" +#include <vstdlib/random.h> +#include "iregistry.h" +#include "filesystem_engine.h" +#include "checksum_md5.h" +#include "cl_steamauth.h" +#include "steam/steam_gameserver.h" +#include "materialsystem/imaterialsystemhardwareconfig.h" +#include "tier2/tier2.h" +#include "server.h" +#include "sv_steamauth.h" +#include "host_state.h" + +#if defined( _X360 ) +#include "xbox/xbox_win32stubs.h" +#endif + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +typedef unsigned int u32; +typedef unsigned char u8; +typedef unsigned short u16; + +namespace GameStatsHarvester +{ + + enum EFileType + { + eFileTypeGameStats, + + eFILETYPECOUNT // Count number of legal values + }; + + + enum ESendMethod + { + eSendMethodWholeRawFileNoBlocks, + eSendMethodCompressedBlocks, // TODO: Reenable compressed sending of minidumps + + eSENDMETHODCOUNT // Count number of legal values + }; + +} + +using namespace GameStatsHarvester; + +// TODO: cut protocol version down to u8 if possible, to reduce bandwidth usage +// for very frequent but tiny commands. +typedef u32 ProtocolVersion_t; + +typedef u8 ProtocolAcceptanceFlag_t; +typedef u8 ProtocolUnacceptableAck_t; + +typedef u32 MessageSequenceId_t; + +typedef u32 ServerSessionHandle_t; +typedef u32 ClientSessionHandle_t; + +typedef u32 NetworkTransactionId_t; + +// Command codes are intentionally as small as possible to minimize bandwidth usage +// for very frequent but tiny commands (e.g. GDS 'FindServer' commands). +typedef u8 Command_t; + +// ... likewise response codes are as small as possible - we use this when we +// ... can and revert to large types on a case by case basis. +typedef u8 CommandResponse_t; + + +// This define our standard type for length prefix for variable length messages +// in wire protocols. +// This is specifically used by CWSABUFWrapper::PrepareToReceiveLengthPrefixedMessage() +// and its supporting functions. +// It is defined here for generic (portable) network code to use when constructing +// messages to be sent to peers that use the above function. +// e.g. SteamValidateUserIDTickets.dll uses this for that purpose. + +// We support u16 or u32 (obviously switching between them breaks existing protocols +// unless all components are switched simultaneously). +typedef u32 NetworkMessageLengthPrefix_t; + + +// Similarly, strings should be preceeded by their length. +typedef u16 StringLengthPrefix_t; + + +const ProtocolAcceptanceFlag_t cuProtocolIsNotAcceptable + = static_cast<ProtocolAcceptanceFlag_t>( 0 ); + +const ProtocolAcceptanceFlag_t cuProtocolIsAcceptable + = static_cast<ProtocolAcceptanceFlag_t>( 1 ); + +const Command_t cuMaxCommand + = static_cast<Command_t>(255); + +const CommandResponse_t cuMaxCommandResponse + = static_cast<CommandResponse_t>(255); + +// This is for mapping requests back to error ids for placing into the database appropriately. +typedef u32 ContextID_t; + +// This is the version of the protocol used by latest-build clients. +const ProtocolVersion_t cuCurrentProtocolVersion = 1; + +// This is the minimum protocol version number that the client must +// be able to speak in order to communicate with the server. +// The client sends its protocol version this before every command, and if we +// don't support that version anymore then we tell it nicely. The client +// should respond by doing an auto-update. +const ProtocolVersion_t cuRequiredProtocolVersion = 1; + + +namespace Commands +{ + const Command_t cuGracefulClose = 0; + const Command_t cuSendGameStats = 1; + const Command_t cuNumCommands = 2; + const Command_t cuNoCommandReceivedYet = cuMaxCommand; +} + + +namespace HarvestFileCommand +{ + typedef u32 SenderTypeId_t; + typedef u32 SenderTypeUniqueId_t; + typedef u32 SenderSourceCodeControlId_t; + typedef u32 FileSize_t; + + // Legal values defined by EFileType + typedef u32 FileType_t; + + // Legal values defined by ESendMethod + typedef u32 SendMethod_t; + + const CommandResponse_t cuOkToSendFile = 0; + const CommandResponse_t cuFileTooBig = 1; + const CommandResponse_t cuInvalidSendMethod = 2; + const CommandResponse_t cuInvalidMaxCompressedChunkSize = 3; + const CommandResponse_t cuInvalidGameStatsContext = 4; + const uint cuNumCommandResponses = 5; +} + +//############################################################################# +// +// Class declaration: CWin32UploadGameStats +// +//############################################################################# +// +// Authors: +// +// Yahn Bernier +// +// Description and general notes: +// +// Handles uploading game stats data blobs to the CSERServer +// (Client Stats & Error Reporting Server) + +typedef enum +{ + // General status + eGameStatsUploadSucceeded = 0, + eGameStatsUploadFailed, + + // Specific status + eGameStatsBadParameter, + eGameStatsUnknownStatus, + eGameStatsSendingGameStatsHeaderSucceeded, + eGameStatsSendingGameStatsHeaderFailed, + eGameStatsReceivingResponseSucceeded, + eGameStatsReceivingResponseFailed, + eGameStatsConnectToCSERServerSucceeded, + eGameStatsConnectToCSERServerFailed, + eGameStatsUploadingGameStatsSucceeded, + eGameStatsUploadingGameStatsFailed +} EGameStatsUploadStatus; + +struct TGameStatsProgress +{ + // A text string describing the current progress + char m_sStatus[ 512 ]; +}; + +typedef void ( *GAMESTATSREPORTPROGRESSFUNC )( u32 uContext, const TGameStatsProgress & rGameStatsProgress ); + +struct TGameStatsParameters +{ + TGameStatsParameters() : + m_uAppId( 0 ) + { + } + + // IP Address of the CSERServer to send the report to + netadr_t m_ipCSERServer; + + // Source Control Id (or build_number) of the product + u32 m_uEngineBuildNumber; + // Name of the .exe + char m_sExecutableName[ 64 ]; + // Game directory + char m_sGameDirectory[ 64 ]; + // Map name the server wants to upload statistics about + char m_sMapName[ 64 ]; + + // Version id for stats blob + u32 m_uStatsBlobVersion; + + u32 m_uStatsBlobSize; + void *m_pStatsBlobData; + + u32 m_uProgressContext; + GAMESTATSREPORTPROGRESSFUNC m_pOptionalProgressFunc; + + u32 m_uAppId; +}; + +// Note that this API is blocking, though the callback, if passed, can occur during execution. +EGameStatsUploadStatus Win32UploadGameStatsBlocking +( + const TGameStatsParameters & rGameStatsParameters // Input +); + +class CUploadGameStats : public IUploadGameStats +{ +public: + + #define GAMESTATSUPLOADER_CONNECT_RETRY_TIME 1.0 + + CUploadGameStats() : m_bConnected(false), m_flNextConnectAttempt(0) {} + + //----------------------------------------------------------------------------- + // Purpose: Initializes the connection to the CSER + //----------------------------------------------------------------------------- + void InitConnection( void ) + { + AsyncUpload_Shutdown(); + + m_bConnected = false; + m_Adr.Clear(); + m_Adr.SetType( NA_IP ); + m_flNextConnectAttempt = 0; + // don't call UpdateConnection here, does bad things + } + + void UpdateConnection( void ) + { + if ( m_bConnected || HostState_IsShuttingDown() ) + return; + + // try getting client SteamUtils interface + ISteamUtils *pSteamUtils = NULL; +#ifndef SWDS + pSteamUtils = Steam3Client().SteamUtils(); +#endif + // if that fails, try the game server SteamUtils interface + if ( !pSteamUtils ) + { + pSteamUtils = Steam3Server().SteamGameServerUtils(); + } + + // can't determine CSER if Steam not running + if ( !pSteamUtils ) + return; + + float curTime = Sys_FloatTime(); + + if ( curTime < m_flNextConnectAttempt ) + return; + + uint32 unIP = 0; + uint16 usPort = 0; +#if !defined( NO_VCR ) + if ( VCRGetMode() != VCR_Playback ) +#endif + { + pSteamUtils->GetCSERIPPort( &unIP, &usPort ); + } +#if !defined( NO_VCR ) + VCRGenericValue( "a", &unIP, sizeof( unIP ) ); + VCRGenericValue( "b", &usPort, sizeof( usPort ) ); +#endif + + if ( unIP == 0 ) + { + m_flNextConnectAttempt = curTime + GAMESTATSUPLOADER_CONNECT_RETRY_TIME; + return; + } + else + { + m_Adr.SetIP( unIP ); + m_Adr.SetPort( usPort ); + m_Adr.SetType( NA_IP ); + m_bConnected = true; + } + } + + virtual bool UploadGameStats( char const *mapname, + unsigned int blobversion, unsigned int blobsize, const void *pvBlobData ) + { + AsyncUpload_QueueData( mapname, blobversion, blobsize, pvBlobData ); + return true; + //return UploadGameStatsInternal( mapname, blobversion, blobsize, pvBlobData ); + } + + // If user has disabled stats tracking, do nothing + virtual bool IsGameStatsLoggingEnabled() + { + if ( CommandLine()->FindParm( "-nogamestats" ) ) + return false; + +#ifdef SWDS + return true; +#else + IRegistry *temp = InstanceRegistry( "Steam" ); + Assert( temp ); + // Check registry + int iDisable = temp->ReadInt( "DisableGameStats", 0 ); + + ReleaseInstancedRegistry( temp ); + + if ( iDisable != 0 ) + { + return false; + } + + return true; +#endif + } + + // Gets a non-personally identifiable unique ID for this steam user, used for tracking total gameplay time across + // multiple stats sessions, but isn't trackable back to their Steam account or id. + // Buffer should be 16 bytes, ID will come back as a hexadecimal string version of a GUID + virtual void GetPseudoUniqueId( char *buf, size_t bufsize ) + { + Q_memset( buf, 0, bufsize ); + +#ifndef SWDS + IRegistry *temp = InstanceRegistry( "Steam" ); + Assert( temp ); + // Check registry + char const *uuid = temp->ReadString( "PseudoUUID", "" ); + + if ( !uuid || !*uuid ) + { + // Create a new one +#ifdef WIN32 + UUID newId; + UuidCreate( &newId ); +#elif defined(POSIX) + uuid_t newId; +#ifdef OSX + uuid_generate( newId ); +#endif +#else +#error +#endif + char hex[ 17 ]; + Q_memset( hex, 0, sizeof( hex ) ); + Q_binarytohex( (const byte *)&newId, sizeof( newId ), hex, sizeof( hex ) ); + + // If running at Valve, copy in the users name here + if ( Steam3Client().SteamUtils() && ( Steam3Client().SteamUser()->BLoggedOn() ) && + ( k_EUniverseBeta == Steam3Client().SteamUtils()->GetConnectedUniverse() ) ) + { + bool bOk = true; + char username[ 64 ]; +#if defined( _WIN32 ) + Q_memset( username, 0, sizeof( username ) ); + DWORD length = sizeof( username ) - 1; + if ( !GetUserName( username, &length ) ) + { + bOk = false; + } +#else + struct passwd *pass = getpwuid( getuid() ); + if ( pass ) + { + Q_strncpy( username, pass->pw_name, sizeof( username ) ); + } + else + { + bOk = false; + } + username[sizeof(username)-1] = '\0'; +#endif + if ( bOk ) + { + int nBytesToCopy = min( (size_t)Q_strlen( username ), sizeof( hex ) - 1 ); + // NOTE: This doesn't copy the NULL terminator from username because we want the "random" bits after the name + Q_memcpy( hex, username, nBytesToCopy ); + } + } + + temp->WriteString( "PseudoUUID", hex ); + + Q_strncpy( buf, hex, bufsize ); + } + else + { + Q_strncpy( buf, uuid, bufsize ); + } + + ReleaseInstancedRegistry( temp ); +#endif + + if ( ( buf[0] == 0 ) && sv.IsDedicated() ) + { + // For Linux dedicated servers, where we won't get a unique ID: set the ID to "unknown" so we have something. (If there's no ID, + // stats don't get sent.) This will later get altered to be a hash of IP&port, but this gets called early before IP is determined + // so we can't make the hash now. + Q_strncpy( buf, "unknown", bufsize ); + } + } + + virtual bool IsCyberCafeUser( void ) + { + // TODO: convert this to be aware of proper Steam3'ified cafes once we actually implement that + return false; + } + + // Only works in single player + virtual bool IsHDREnabled( void ) + { +#if defined( SWDS ) || defined( _X360 ) + return false; +#else + return g_pMaterialSystemHardwareConfig->GetHDREnabled(); +#endif + } + + bool UploadGameStatsInternal( char const *mapname, + unsigned int blobversion, unsigned int blobsize, const void *pvBlobData ) + { + // Attempt connection, for backwards compatibility + UpdateConnection(); + + if ( !m_bConnected ) + return false; + + unsigned int useAppId = GetSteamAppID(); + if ( useAppId == 0 ) + return false; + + TGameStatsParameters params; + Q_memset( ¶ms, 0, sizeof( params ) ); + + params.m_ipCSERServer = m_Adr; + + params.m_uEngineBuildNumber = build_number(); + Q_strncpy( params.m_sExecutableName, "hl2.exe", sizeof( params.m_sExecutableName ) ); + Q_FileBase( com_gamedir, params.m_sGameDirectory, sizeof( params.m_sGameDirectory ) ); + Q_FileBase( mapname, params.m_sMapName, sizeof( params.m_sMapName ) ); + params.m_uStatsBlobVersion = blobversion; + params.m_uStatsBlobSize = blobsize; + params.m_pStatsBlobData = ( void * )pvBlobData; + + //////////////////////////////////////////////////////////////////////////// + // New protocol sorts things by Steam AppId (4/6/06 ywb) + params.m_uAppId = useAppId; + //////////////////////////////////////////////////////////////////////////// + + EGameStatsUploadStatus result = Win32UploadGameStatsBlocking( params ); + return ( result == eGameStatsUploadSucceeded ) ? true : false; + } +private: + netadr_t m_Adr; + float m_flNextConnectAttempt; + bool m_bConnected; +}; + +static CUploadGameStats g_UploadGameStats; +IUploadGameStats *g_pUploadGameStats = &g_UploadGameStats; +EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CUploadGameStats, IUploadGameStats, INTERFACEVERSION_UPLOADGAMESTATS, g_UploadGameStats ); + +void UpdateProgress( const TGameStatsParameters & params, char const *fmt, ... ) +{ + if ( !params.m_pOptionalProgressFunc ) + { + return; + } + + char str[ 2048 ]; + va_list argptr; + va_start( argptr, fmt ); + _vsnprintf( str, sizeof( str ) - 1, fmt, argptr ); + va_end( argptr ); + + char outstr[ 2060 ]; + Q_snprintf( outstr, sizeof( outstr ), "(%u): %s", params.m_uProgressContext, str ); + + TGameStatsProgress progress; + Q_strncpy( progress.m_sStatus, outstr, sizeof( progress.m_sStatus ) ); + + // Invoke the callback + ( *params.m_pOptionalProgressFunc )( params.m_uProgressContext, progress ); +} + +class CWin32UploadGameStats +{ +public: + explicit CWin32UploadGameStats( + const netadr_t & harvester, + const TGameStatsParameters & rGameStatsParameters, + u32 contextid ); + ~CWin32UploadGameStats(); + + EGameStatsUploadStatus Upload( CUtlBuffer& buf ); + +private: + + enum States + { + eCreateTCPSocket = 0, + eConnectToHarvesterServer, + eSendProtocolVersion, + eReceiveProtocolOkay, + eSendUploadCommand, + eReceiveOKToSendFile, + eSendWholeFile, // This could push chunks onto the wire, but we'll just use a whole buffer for now. + eReceiveFileUploadSuccess, + eSendGracefulClose, + eCloseTCPSocket + }; + + bool CreateTCPSocket( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool ConnectToHarvesterServer( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool SendProtocolVersion( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool ReceiveProtocolOkay( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool SendUploadCommand( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool ReceiveOKToSendFile( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool SendWholeFile( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool ReceiveFileUploadSuccess( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool SendGracefulClose( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + bool CloseTCPSocket( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + + typedef bool ( CWin32UploadGameStats::*pfnProtocolStateHandler )( EGameStatsUploadStatus& status, CUtlBuffer& buf ); + struct FSMState_t + { + FSMState_t( uint f, pfnProtocolStateHandler s ) : + first( f ), + second( s ) + { + } + + uint first; + pfnProtocolStateHandler second; + }; + + void AddState( uint StateIndex, pfnProtocolStateHandler handler ); + void SetNextState( uint StateIndex ); + bool DoBlockingReceive( uint bytesExpected, CUtlBuffer& buf ); + + CUtlVector< FSMState_t > m_States; + uint m_uCurrentState; + struct sockaddr_in m_HarvesterSockAddr; + uint m_SocketTCP; + const TGameStatsParameters &m_rCrashParameters; //lint !e1725 + u32 m_ContextID; +}; + +CWin32UploadGameStats::CWin32UploadGameStats( + const netadr_t & harvester, + const TGameStatsParameters & rGameStatsParameters, + u32 contextid ) : + m_States(), + m_uCurrentState( eCreateTCPSocket ), + m_HarvesterSockAddr(), + m_SocketTCP( 0 ), + m_rCrashParameters( rGameStatsParameters ), + m_ContextID( contextid ) +{ + harvester.ToSockadr( (struct sockaddr *)&m_HarvesterSockAddr ); + + AddState( eCreateTCPSocket, &CWin32UploadGameStats::CreateTCPSocket ); + AddState( eConnectToHarvesterServer, &CWin32UploadGameStats::ConnectToHarvesterServer ); + AddState( eSendProtocolVersion, &CWin32UploadGameStats::SendProtocolVersion ); + AddState( eReceiveProtocolOkay, &CWin32UploadGameStats::ReceiveProtocolOkay ); + AddState( eSendUploadCommand, &CWin32UploadGameStats::SendUploadCommand ); + AddState( eReceiveOKToSendFile, &CWin32UploadGameStats::ReceiveOKToSendFile ); + AddState( eSendWholeFile, &CWin32UploadGameStats::SendWholeFile ); + AddState( eReceiveFileUploadSuccess, &CWin32UploadGameStats::ReceiveFileUploadSuccess ); + AddState( eSendGracefulClose, &CWin32UploadGameStats::SendGracefulClose ); + AddState( eCloseTCPSocket, &CWin32UploadGameStats::CloseTCPSocket ); +} + +CWin32UploadGameStats::~CWin32UploadGameStats() +{ + if ( m_SocketTCP != 0 ) + { + closesocket( m_SocketTCP ); //lint !e534 + m_SocketTCP = 0; + } +} + +//----------------------------------------------------------------------------- +// +// Function: DoBlockingReceive() +// +//----------------------------------------------------------------------------- +bool CWin32UploadGameStats::DoBlockingReceive( uint bytesExpected, CUtlBuffer& buf ) +{ + uint totalReceived = 0; + + buf.Purge(); + for ( ;; ) + { + char temp[ 8192 ]; + + int bytesReceived = recv( m_SocketTCP, temp, sizeof( temp ), 0 ); + if ( bytesReceived <= 0 ) + return false; + + buf.Put( ( const void * )temp, (u32)bytesReceived ); + totalReceived = buf.TellPut(); + if ( totalReceived >= bytesExpected ) + break; + + } + return true; +} + +void CWin32UploadGameStats::AddState( uint StateIndex, pfnProtocolStateHandler handler ) +{ + FSMState_t newState( StateIndex, handler ); + m_States.AddToTail( newState ); +} + +EGameStatsUploadStatus CWin32UploadGameStats::Upload( CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Commencing game stats upload connection." ); + + EGameStatsUploadStatus result = eGameStatsUploadSucceeded; + // Run the state machine + while ( 1 ) + { + Assert( m_States[ m_uCurrentState ].first == m_uCurrentState ); + pfnProtocolStateHandler handler = m_States[ m_uCurrentState ].second; + + if ( !(this->*handler)( result, buf ) ) + { + return result; + } + } +} + +void CWin32UploadGameStats::SetNextState( uint StateIndex ) +{ + Assert( StateIndex > m_uCurrentState ); + m_uCurrentState = StateIndex; +} + +bool CWin32UploadGameStats::CreateTCPSocket( EGameStatsUploadStatus& status, CUtlBuffer& /*buf*/ ) +{ + UpdateProgress( m_rCrashParameters, "Creating game stats upload socket." ); + + m_SocketTCP = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); + if ( m_SocketTCP == (uint)SOCKET_ERROR ) + { + UpdateProgress( m_rCrashParameters, "Socket creation failed." ); + + status = eGameStatsUploadFailed; + return false; + } + + SetNextState( eConnectToHarvesterServer ); + return true; +} + +bool CWin32UploadGameStats::ConnectToHarvesterServer( EGameStatsUploadStatus& status, CUtlBuffer& /*buf*/ ) +{ + UpdateProgress( m_rCrashParameters, "Connecting to game stats harvesting server." ); + + if ( connect( m_SocketTCP, (const sockaddr *)&m_HarvesterSockAddr, sizeof( m_HarvesterSockAddr ) ) == SOCKET_ERROR ) + { + UpdateProgress( m_rCrashParameters, "Connection failed." ); + + status = eGameStatsConnectToCSERServerFailed; + return false; + } + + SetNextState( eSendProtocolVersion ); + return true; +} + +bool CWin32UploadGameStats::SendProtocolVersion( EGameStatsUploadStatus& status, CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Sending game stats harvester protocol info." ); + buf.SetBigEndian( true ); + // Send protocol version + buf.Purge(); + buf.PutInt( cuCurrentProtocolVersion ); + + if ( send( m_SocketTCP, (const char *)buf.Base(), (int)buf.TellPut(), 0 ) == SOCKET_ERROR ) + { + UpdateProgress( m_rCrashParameters, "Send failed." ); + + status = eGameStatsUploadFailed; + return false; + } + + SetNextState( eReceiveProtocolOkay ); + return true; +} + +bool CWin32UploadGameStats::ReceiveProtocolOkay( EGameStatsUploadStatus& status, CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Receiving harvesting protocol acknowledgement." ); + buf.Purge(); + + // Now receive the protocol is acceptable token from the server + if ( !DoBlockingReceive( 1, buf ) ) + { + UpdateProgress( m_rCrashParameters, "Didn't receive protocol failure data." ); + + status = eGameStatsUploadFailed; + return false; + } + + bool protocolokay = buf.GetChar() ? true : false; + if ( !protocolokay ) + { + UpdateProgress( m_rCrashParameters, "Server rejected protocol." ); + + status = eGameStatsUploadFailed; + return false; + } + + UpdateProgress( m_rCrashParameters, "Protocol OK." ); + + SetNextState( eSendUploadCommand ); + return true; +} + +bool CWin32UploadGameStats::SendUploadCommand( EGameStatsUploadStatus& status, CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Sending harvesting protocol upload request." ); +// Send upload command + buf.Purge(); + + NetworkMessageLengthPrefix_t messageSize + ( + sizeof( Command_t ) + + sizeof( ContextID_t ) + + sizeof( HarvestFileCommand::FileSize_t ) + + sizeof( HarvestFileCommand::SendMethod_t ) + + sizeof( HarvestFileCommand::FileSize_t ) + ); + + // Prefix the length to the command + buf.PutInt( (int)messageSize ); + buf.PutChar( Commands::cuSendGameStats ); + buf.PutInt( (int)m_ContextID ); + + buf.PutInt( (int)m_rCrashParameters.m_uStatsBlobSize ); + buf.PutInt( static_cast<HarvestFileCommand::SendMethod_t>( eSendMethodWholeRawFileNoBlocks ) ); + buf.PutInt( static_cast<HarvestFileCommand::FileSize_t>( 0 ) ); + + // Send command to server + if ( send( m_SocketTCP, (const char *)buf.Base(), (int)buf.TellPut(), 0 ) == SOCKET_ERROR ) + { + UpdateProgress( m_rCrashParameters, "Send failed." ); + + status = eGameStatsUploadFailed; + return false; + } + + SetNextState( eReceiveOKToSendFile ); + return true; +} + +bool CWin32UploadGameStats::ReceiveOKToSendFile( EGameStatsUploadStatus& status, CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Receive game stats harvesting protocol upload permissible." ); + + // Now receive the protocol is acceptable token from the server + if ( !DoBlockingReceive( 1, buf ) ) + { + UpdateProgress( m_rCrashParameters, "Receive failed." ); + status = eGameStatsUploadFailed; + return false; + } + + bool dosend = false; + CommandResponse_t cmd = (CommandResponse_t)buf.GetChar(); + switch ( cmd ) + { + case HarvestFileCommand::cuOkToSendFile: + { + dosend = true; + } + break; + case HarvestFileCommand::cuFileTooBig: + case HarvestFileCommand::cuInvalidSendMethod: + case HarvestFileCommand::cuInvalidMaxCompressedChunkSize: + case HarvestFileCommand::cuInvalidGameStatsContext: + default: + break; + } + + if ( !dosend ) + { + UpdateProgress( m_rCrashParameters, "Server rejected upload command." ); + + status = eGameStatsUploadFailed; + return false; + } + + SetNextState( eSendWholeFile ); + return true; +} + +bool CWin32UploadGameStats::SendWholeFile( EGameStatsUploadStatus& status, CUtlBuffer& /*buf*/ ) +{ + UpdateProgress( m_rCrashParameters, "Uploading game stats data." ); + // Send to server + bool bret = true; + if ( send( m_SocketTCP, (const char *)m_rCrashParameters.m_pStatsBlobData, (int)m_rCrashParameters.m_uStatsBlobSize, 0 ) == SOCKET_ERROR ) + { + bret = false; + UpdateProgress( m_rCrashParameters, "Send failed." ); + + status = eGameStatsUploadFailed; + } + else + { + SetNextState( eReceiveFileUploadSuccess ); + } + + return bret; +} + +bool CWin32UploadGameStats::ReceiveFileUploadSuccess( EGameStatsUploadStatus& status, CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Receiving game stats upload success/fail message." ); + + // Now receive the protocol is acceptable token from the server + if ( !DoBlockingReceive( 1, buf ) ) + { + UpdateProgress( m_rCrashParameters, "Receive failed." ); + + status = eGameStatsUploadFailed; + return false; + } + + bool success = buf.GetChar() == 1 ? true : false; + if ( !success ) + { + UpdateProgress( m_rCrashParameters, "Upload failed." ); + + status = eGameStatsUploadFailed; + return false; + } + + UpdateProgress( m_rCrashParameters, "Upload OK." ); + + SetNextState( eSendGracefulClose ); + return true; +} + +bool CWin32UploadGameStats::SendGracefulClose( EGameStatsUploadStatus& status, CUtlBuffer& buf ) +{ + UpdateProgress( m_rCrashParameters, "Closing connection to server." ); + + // Now send disconnect command + buf.Purge(); + + size_t messageSize = sizeof( Command_t ); + + buf.PutInt( (int)messageSize ); + buf.PutChar( Commands::cuGracefulClose ); + + if ( send( m_SocketTCP, (const char *)buf.Base(), (int)buf.TellPut(), 0 ) == SOCKET_ERROR ) + { + UpdateProgress( m_rCrashParameters, "Send failed." ); + + status = eGameStatsUploadFailed; + return false; + } + + SetNextState( eCloseTCPSocket ); + return true; +} + +bool CWin32UploadGameStats::CloseTCPSocket( EGameStatsUploadStatus& status, CUtlBuffer& /*buf*/ ) +{ + UpdateProgress( m_rCrashParameters, "Closing socket, upload succeeded." ); + + closesocket( m_SocketTCP );//lint !e534 + m_SocketTCP = 0; + + status = eGameStatsUploadSucceeded; + // NOTE: Returning false here ends the state machine!!! + return false; +} + +EGameStatsUploadStatus Win32UploadGameStatsBlocking +( + const TGameStatsParameters & rGameStatsParameters +) +{ + EGameStatsUploadStatus status = eGameStatsUploadSucceeded; + + CUtlBuffer buf( rGameStatsParameters.m_uStatsBlobSize + 4096 ); + + UpdateProgress( rGameStatsParameters, "Creating initial report." ); + + buf.SetBigEndian( false ); + + buf.Purge(); + buf.PutChar( C2M_REPORT_GAMESTATISTICS ); + buf.PutChar( '\n' ); + buf.PutChar( C2M_REPORT_GAMESTATISTICS_PROTOCOL_VERSION ); + + // See CSERServerProtocol.h for format + + if ( 0 ) // This is the old protocol + { + buf.PutInt( (int)rGameStatsParameters.m_uEngineBuildNumber ); + buf.PutString( rGameStatsParameters.m_sExecutableName ); // exe name + buf.PutString( rGameStatsParameters.m_sGameDirectory ); // gamedir + buf.PutString( rGameStatsParameters.m_sMapName ); + + buf.PutInt( (int)rGameStatsParameters.m_uStatsBlobVersion ); // game stats blob version + buf.PutInt( (int)rGameStatsParameters.m_uStatsBlobSize ); // game stats blob size + } + else + { + buf.PutInt( (int)rGameStatsParameters.m_uAppId ); + buf.PutInt( (int)rGameStatsParameters.m_uStatsBlobSize ); // game stats blob size + } + + CBlockingUDPSocket bcs; + if ( !bcs.IsValid() ) + { + return eGameStatsUploadFailed; + } + + struct sockaddr_in sa; + rGameStatsParameters.m_ipCSERServer.ToSockadr( (struct sockaddr *)&sa ); + + UpdateProgress( rGameStatsParameters, "Sending game stats to server %s.", rGameStatsParameters.m_ipCSERServer.ToString() ); + + bcs.SendSocketMessage( sa, (const u8 *)buf.Base(), buf.TellPut() ); //lint !e534 + + UpdateProgress( rGameStatsParameters, "Waiting for response." ); + + if ( bcs.WaitForMessage( 2.0f ) ) + { + UpdateProgress( rGameStatsParameters, "Received response." ); + + struct sockaddr_in replyaddress; + buf.EnsureCapacity( 4096 ); + + uint bytesReceived = bcs.ReceiveSocketMessage( &replyaddress, (u8 *)buf.Base(), 4096 ); + if ( bytesReceived > 0 ) + { + // Fixup actual size + buf.SeekPut( CUtlBuffer::SEEK_HEAD, bytesReceived ); + + UpdateProgress( rGameStatsParameters, "Checking response." ); + + // Parse out data + u8 msgtype = (u8)buf.GetChar(); + if ( M2C_ACKREPORT_GAMESTATISTICS != msgtype ) + { + UpdateProgress( rGameStatsParameters, "Request denied, invalid message type." ); + return eGameStatsSendingGameStatsHeaderFailed; + } + bool validProtocol = (u8)buf.GetChar() == 1 ? true : false; + if ( !validProtocol ) + { + UpdateProgress( rGameStatsParameters, "Request denied, invalid message protocol." ); + return eGameStatsSendingGameStatsHeaderFailed; + } + + u8 disposition = (u8)buf.GetChar(); + if ( GS_UPLOAD_REQESTED != disposition ) + { + // Server doesn't want a gamestats, oh well + UpdateProgress( rGameStatsParameters, "Stats report accepted, data upload skipped." ); + + return eGameStatsUploadSucceeded; + } + + // Read in the game stats info parameters + u32 harvester_ip = (u32)buf.GetInt(); + u16 harvester_port = (u16)buf.GetShort(); + u32 dumpcontext = (u32)buf.GetInt(); + + sockaddr_in adr; + adr.sin_family = AF_INET; + adr.sin_port = htons( harvester_port ); +#ifdef _WIN32 + adr.sin_addr.S_un.S_addr = harvester_ip; +#elif POSIX + adr.sin_addr.s_addr = harvester_ip; +#endif + + netadr_t GameStatsHarvesterFSMIPAddress; + GameStatsHarvesterFSMIPAddress.SetFromSockadr( (struct sockaddr *)&adr ); + + UpdateProgress( rGameStatsParameters, "Server requested game stats upload to %s.", GameStatsHarvesterFSMIPAddress.ToString() ); + + // Keep using the same scratch buffer for messaging + CWin32UploadGameStats uploader( GameStatsHarvesterFSMIPAddress, rGameStatsParameters, dumpcontext ); + status = uploader.Upload( buf ); + } + } + else + { + UpdateProgress( rGameStatsParameters, "No response from server." ); + } + + return status; +} +////////////////////////////////////////////////////////////////////////// +// +// Implementation of async uploading +// + +class CAsyncUploaderThread +{ +public: + CAsyncUploaderThread() + : m_hThread( NULL ), m_bRunning( false ), m_eventQueue(false), m_eventInitShutdown(false) {} + + ThreadHandle_t m_hThread; + +protected: + + struct DataEntry + { + char const *szMapName; + uint uiBlobVersion; + uint uiBlobSize; + void const *pvBlob; + + DataEntry *AllocCopy() const; + void Free() { delete [] ( (char*)this ); } + }; + + CThreadEvent m_eventQueue; + CThreadEvent m_eventInitShutdown; + CThreadFastMutex m_mtx; + CUtlVector< DataEntry * > m_queue; + bool m_bRunning; + + void ThreadProc(); + + enum { + SLEEP_ENTRY_UPLOADED = 10 * 1000 + }; + +public: + static unsigned CallbackThreadProc( void *pvParam ) { ((CAsyncUploaderThread*) pvParam)->ThreadProc(); return 0; } + void QueueData( char const *szMapName, uint uiBlobVersion, uint uiBlobSize, const void *pvBlob ); + void TerminateAndSelfDelete(); +}; + +static CAsyncUploaderThread *g_pAsyncUploader = NULL; + +CAsyncUploaderThread::DataEntry * CAsyncUploaderThread::DataEntry::AllocCopy() const +{ + // Find out how much memory we would need + uint lenMapName = ( szMapName ? strlen( szMapName ) : 0 ); + uint numBytes = sizeof( DataEntry ) + uiBlobSize + lenMapName + 1; + + char *pbData = new char[ numBytes ]; + DataEntry *pNew = ( DataEntry * )( pbData ); + if ( !pNew ) + return NULL; + + pNew->uiBlobVersion = uiBlobVersion; + pNew->uiBlobSize = uiBlobSize; + + char *pbWriteMapName = ( char * )( pNew + 1 ); + pNew->szMapName = pbWriteMapName; + memcpy( pbWriteMapName, szMapName, lenMapName ); + pbWriteMapName[ lenMapName ] = 0; + + char *pbWriteBlob = pbWriteMapName + lenMapName + 1; + pNew->pvBlob = pbWriteBlob; + memcpy( pbWriteBlob, pvBlob, uiBlobSize ); + + return pNew; +} + +void CAsyncUploaderThread::QueueData( char const *szMapName, uint uiBlobVersion, uint uiBlobSize, const void *pvBlob ) +{ + // DevMsg( 3, "AsyncUploaderThread: Queue [%.*s]\n", uiBlobSize, pvBlob ); + + if ( !m_hThread ) + { + // Start the thread and wait for it to be running. + // There is a slightly complicated two-event negotiation: + // ThreadProc signals eventInitShutdown then waits on eventQueue + Assert( m_bRunning == false ); + m_hThread = CreateSimpleThread( CallbackThreadProc, this ); + m_eventInitShutdown.Wait(); + Assert( m_bRunning == true ); + // At this point, both events are unsignaled and the thread + // is in its main loop. + } + + // Prepare for a DataEntry + DataEntry de = { szMapName, uiBlobVersion, uiBlobSize, pvBlob }; + if ( DataEntry *pNew = de.AllocCopy() ) + { + { + AUTO_LOCK( m_mtx ); + m_queue.AddToTail( pNew ); + } + m_eventQueue.Set(); + } +} + +void CAsyncUploaderThread::TerminateAndSelfDelete() +{ + ThreadHandle_t hThread = m_hThread; + if ( hThread ) + { + m_bRunning = false; + m_eventQueue.Set(); + m_eventInitShutdown.Set(); // MUST BE LAST MEMBER ACCESS, other thread may now delete this + + // Wait for a while for upload to finish, but don't wait forever + ThreadJoin( hThread, 10 * 1000 ); + ReleaseThreadHandle( hThread ); + } + else + { + delete this; + } +} + +void CAsyncUploaderThread::ThreadProc() +{ + bool bQueueDrained = true; + bool bGotShutdownEvent = false; + + m_bRunning = true; + m_eventInitShutdown.Set(); + + while ( m_bRunning ) + { + if ( bQueueDrained ) + { + m_eventQueue.Wait(); + } + + DataEntry *pUpload = NULL; + { + AUTO_LOCK( m_mtx ); + if ( m_queue.Count() ) + { + pUpload = m_queue[0]; + m_queue.Remove( 0 ); + } + bQueueDrained = ( m_queue.Count() == 0 ); + } + + if ( m_bRunning && pUpload ) + { + // DevMsg( 3, "AsyncUploaderThread: Uploading [%.*s]\n", pUpload->uiBlobSize, pUpload->pvBlob ); + + // Attempt to upload the data until successful + bool bSuccess = g_UploadGameStats.UploadGameStatsInternal( pUpload->szMapName, pUpload->uiBlobVersion, pUpload->uiBlobSize, pUpload->pvBlob ); + bSuccess; + + pUpload->Free(); + + // After the data entry got uploaded, grab the next one + // DevMsg( 3, "AsyncUploaderThread: Upload finished (status=%d) for data [%.*s]\n", bSuccess, pUpload->uiBlobSize, pUpload->pvBlob ); + + // Using an event as an interruptable sleep; signaled if m_bRunning is cleared + bGotShutdownEvent |= m_eventInitShutdown.Wait( SLEEP_ENTRY_UPLOADED ); + } + } + + Assert( !m_bRunning ); + + // Deletes self at end of execution! + if ( !bGotShutdownEvent ) + { + m_eventInitShutdown.Wait(); + } + delete this; +} + +void AsyncUpload_QueueData( char const *szMapName, uint uiBlobVersion, uint uiBlobSize, const void *pvBlob ) +{ + if ( !g_pAsyncUploader ) + { + g_pAsyncUploader = new CAsyncUploaderThread; + } + g_pAsyncUploader->QueueData( szMapName, uiBlobVersion, uiBlobSize, pvBlob ); +} + +void AsyncUpload_Shutdown() +{ + if ( g_pAsyncUploader ) + { + g_pAsyncUploader->TerminateAndSelfDelete(); + g_pAsyncUploader = NULL; + } +} |