Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.

732 lines
21 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#if defined( STEAM ) || defined( HL1 )
#include "stdafx.h"
#else
#include <stdio.h>
#include "dbg.h"
#define INCLUDED_STEAM2_USERID_STRUCTS
#include "steamcommon.h"
#include "steam/steamclientpublic.h"
#include "strtools.h"
#endif
#ifdef HL1
#include "steamcommon.h"
#include "steam/steamclientpublic.h"
#endif
#ifndef UINT64_MAX
#define UINT64_MAX ((uint64)-1)
#endif
static const char *DecimalToUint64( const char *pchStr, uint64 unLimit,
uint64 *punVal )
{
const char *pchStart = pchStr;
uint64 unVal = 0;
while ( *pchStr >= '0' && *pchStr <= '9' )
{
uint64 unNext = unVal * 10;
if ( unNext < unVal )
{
// 64-bit overflow.
return NULL;
}
unVal = unNext + (uint64)( *pchStr - '0' );
if ( unVal > unLimit )
{
// Limit overflow.
return NULL;
}
pchStr++;
}
if ( pchStr == pchStart )
{
// No number at all.
return NULL;
}
*punVal = unVal;
return pchStr;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input : pchSteamID - text representation of a Steam ID
//-----------------------------------------------------------------------------
CSteamID::CSteamID( const char *pchSteamID, EUniverse eDefaultUniverse /* = k_EUniverseInvalid */ )
{
SetFromString( pchSteamID, eDefaultUniverse );
}
//-----------------------------------------------------------------------------
// Purpose: Initializes a steam ID from a string
// Input : pchSteamID - text representation of a Steam ID
//-----------------------------------------------------------------------------
void CSteamID::SetFromString( const char *pchSteamID, EUniverse eDefaultUniverse )
{
uint nAccountID = 0;
uint nInstance = 1;
EUniverse eUniverse = eDefaultUniverse;
EAccountType eAccountType = k_EAccountTypeIndividual;
#ifdef DBGFLAG_ASSERT
// TF Merge -- Assert is debug-only and we have unused variable warnings on :-/
const char *pchSteamIDString = pchSteamID;
#endif
CSteamID StrictID;
StrictID.SetFromStringStrict( pchSteamID, eDefaultUniverse );
if ( *pchSteamID == '[' )
pchSteamID++;
// BUGBUG Rich use the Q_ functions
if (*pchSteamID == 'A')
{
// This is test only
pchSteamID++; // skip the A
eAccountType = k_EAccountTypeAnonGameServer;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
if ( strchr( pchSteamID, '(' ) )
sscanf( strchr( pchSteamID, '(' ), "(%u)", &nInstance );
const char *pchColon = strchr( pchSteamID, ':' );
if ( pchColon && *pchColon != 0 && strchr( pchColon+1, ':' ))
{
sscanf( pchSteamID, "%u:%u:%u", (uint*)&eUniverse, &nAccountID, &nInstance );
}
else if ( pchColon )
{
sscanf( pchSteamID, "%u:%u", (uint*)&eUniverse, &nAccountID );
}
else
{
sscanf( pchSteamID, "%u", &nAccountID );
}
if ( nAccountID == 0 )
{
// i dont care what number you entered
CreateBlankAnonLogon(eUniverse);
}
else
{
InstancedSet( nAccountID, nInstance, eUniverse, eAccountType );
}
// Catch cases where we're allowing sloppy input that we
// might not want to allow.
AssertMsg1( this->operator==( StrictID ), "Steam ID does not pass strict parsing: '%s'", pchSteamIDString );
return;
}
else if (*pchSteamID == 'G')
{
pchSteamID++; // skip the G
eAccountType = k_EAccountTypeGameServer;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'C')
{
pchSteamID++; // skip the C
eAccountType = k_EAccountTypeContentServer;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'g')
{
pchSteamID++; // skip the g
eAccountType = k_EAccountTypeClan;
nInstance = 0;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'c')
{
pchSteamID++; // skip the c
eAccountType = k_EAccountTypeChat;
nInstance = k_EChatInstanceFlagClan;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'L')
{
pchSteamID++; // skip the c
eAccountType = k_EAccountTypeChat;
nInstance = k_EChatInstanceFlagLobby;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'T')
{
pchSteamID++; // skip the T
eAccountType = k_EAccountTypeChat;
nInstance = 0; // Anon chat
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'U')
{
pchSteamID++; // skip the U
eAccountType = k_EAccountTypeIndividual;
nInstance = 1;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
else if (*pchSteamID == 'i')
{
pchSteamID++; // skip the i
eAccountType = k_EAccountTypeInvalid;
nInstance = 1;
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
if ( strchr( pchSteamID, ':' ) )
{
if (*pchSteamID == '[')
pchSteamID++; // skip the optional [
sscanf( pchSteamID, "%u:%u", (uint*)&eUniverse, &nAccountID );
if ( eUniverse == k_EUniverseInvalid )
eUniverse = eDefaultUniverse;
}
else
{
uint64 unVal64 = 0;
sscanf( pchSteamID, "%llu", &unVal64 );
if ( unVal64 > UINT64_MAX )
{
// Assume a full 64-bit Steam ID.
SetFromUint64( unVal64 );
// Catch cases where we're allowing sloppy input that we
// might not want to allow.
AssertMsg1( this->operator==( StrictID ), "Steam ID does not pass strict parsing: '%s'", pchSteamIDString );
return;
}
else
{
nAccountID = (uint)unVal64;
}
}
Assert( (eUniverse > k_EUniverseInvalid) && (eUniverse < k_EUniverseMax) );
InstancedSet( nAccountID, nInstance, eUniverse, eAccountType );
// Catch cases where we're allowing sloppy input that we
// might not want to allow.
AssertMsg1( this->operator==( StrictID ), "Steam ID does not pass strict parsing: '%s'", pchSteamIDString );
}
// SetFromString allows many partially-correct strings, constraining how
// we might be able to change things in the future.
// SetFromStringStrict requires the exact string forms that we support
// and is preferred when the caller knows it's safe to be strict.
// Returns whether the string parsed correctly. The ID may
// still be invalid even if the string parsed correctly.
// If the string didn't parse correctly the ID will always be invalid.
bool CSteamID::SetFromStringStrict( const char *pchSteamID, EUniverse eDefaultUniverse )
{
uint nAccountID = 0;
uint nInstance = 1;
uint unMaxVal = 2;
EUniverse eUniverse = eDefaultUniverse;
EAccountType eAccountType = k_EAccountTypeIndividual;
char chPrefix;
bool bBracket = false;
bool bValid = true;
uint64 unVal[3];
const char *pchEnd;
// Start invalid.
Clear();
if ( !pchSteamID )
{
return false;
}
if ( *pchSteamID == '[' )
{
pchSteamID++;
bBracket = true;
}
chPrefix = *pchSteamID;
switch( chPrefix )
{
case 'A':
// This is test only
eAccountType = k_EAccountTypeAnonGameServer;
unMaxVal = 3;
break;
case 'G':
eAccountType = k_EAccountTypeGameServer;
break;
case 'C':
eAccountType = k_EAccountTypeContentServer;
break;
case 'g':
eAccountType = k_EAccountTypeClan;
nInstance = 0;
break;
case 'c':
eAccountType = k_EAccountTypeChat;
nInstance = k_EChatInstanceFlagClan;
break;
case 'L':
eAccountType = k_EAccountTypeChat;
nInstance = k_EChatInstanceFlagLobby;
break;
case 'T':
eAccountType = k_EAccountTypeChat;
nInstance = 0; // Anon chat
break;
case 'U':
eAccountType = k_EAccountTypeIndividual;
nInstance = 1;
break;
case 'i':
eAccountType = k_EAccountTypeInvalid;
nInstance = 1;
break;
default:
// We're reserving other leading characters so
// this should only be the plain-digits case.
if (chPrefix < '0' || chPrefix > '9')
{
bValid = false;
}
chPrefix = 0;
break;
}
if ( chPrefix )
{
pchSteamID++; // skip the prefix
if (*pchSteamID == '-' || *pchSteamID == ':')
pchSteamID++; // skip the optional - or :
}
uint unIdx = 0;
for (;;)
{
pchEnd = DecimalToUint64( pchSteamID, UINT64_MAX, &unVal[unIdx] );
if ( !pchEnd )
{
bValid = false;
break;
}
unIdx++;
// For 'A' we can have a trailing instance, which must
// be the end of the string.
if ( *pchEnd == '(' &&
chPrefix == 'A' )
{
if ( unIdx > 2 )
{
// Two instance IDs provided.
bValid = false;
}
pchEnd = DecimalToUint64( pchEnd + 1, k_unSteamAccountInstanceMask, &unVal[2] );
if ( !pchEnd ||
*pchEnd != ')' )
{
bValid = false;
break;
}
else
{
nInstance = (uint)unVal[2];
pchEnd++;
if ( *pchEnd == ':' )
{
// Not expecting more values.
bValid = false;
break;
}
}
}
if ( *pchEnd != ':' )
{
if ( bBracket )
{
if ( *pchEnd != ']' ||
*(pchEnd + 1) != 0 )
{
bValid = false;
}
}
else if ( *pchEnd != 0 )
{
bValid = false;
}
break;
}
if ( unIdx >= unMaxVal )
{
bValid = false;
break;
}
pchSteamID = pchEnd + 1;
}
if ( unIdx > 2 )
{
if ( unVal[2] <= k_unSteamAccountInstanceMask )
{
nInstance = (uint)unVal[2];
}
else
{
bValid = false;
}
}
if ( unIdx > 1 )
{
if ( unVal[0] >= k_EUniverseInvalid &&
unVal[0] < k_EUniverseMax )
{
eUniverse = (EUniverse)unVal[0];
if ( eUniverse == k_EUniverseInvalid )
eUniverse = eDefaultUniverse;
}
else
{
bValid = false;
}
if ( unVal[1] <= k_unSteamAccountIDMask )
{
nAccountID = (uint)unVal[1];
}
else
{
bValid = false;
}
}
else if ( unIdx > 0 )
{
if ( unVal[0] <= k_unSteamAccountIDMask )
{
nAccountID = (uint)unVal[0];
}
else if ( !chPrefix )
{
if ( bValid )
{
SetFromUint64( unVal[0] );
}
return bValid;
}
else
{
bValid = false;
}
}
else
{
bValid = false;
}
if ( bValid )
{
if ( chPrefix == 'A' )
{
if ( nAccountID == 0 )
{
// i dont care what number you entered
CreateBlankAnonLogon(eUniverse);
return bValid;
}
}
InstancedSet( nAccountID, nInstance, eUniverse, eAccountType );
}
return bValid;
}
#if defined( INCLUDED_STEAM2_USERID_STRUCTS )
//-----------------------------------------------------------------------------
// Purpose: Initializes a steam ID from a Steam2 ID string
// Input: pchSteam2ID - Steam2 ID (as a string #:#:#) to convert
// eUniverse - universe this ID belongs to
// Output: true if successful, false otherwise
//-----------------------------------------------------------------------------
bool CSteamID::SetFromSteam2String( const char *pchSteam2ID, EUniverse eUniverse )
{
Assert( pchSteam2ID );
// Convert the Steam2 ID string to a Steam2 ID structure
TSteamGlobalUserID steam2ID;
steam2ID.m_SteamInstanceID = 0;
steam2ID.m_SteamLocalUserID.Split.High32bits = 0;
steam2ID.m_SteamLocalUserID.Split.Low32bits = 0;
const char *pchTSteam2ID = pchSteam2ID;
// Customer support is fond of entering steam IDs in the following form: STEAM_n:x:y
const char *pchOptionalLeadString = "STEAM_";
if ( V_strnicmp( pchSteam2ID, pchOptionalLeadString, V_strlen( pchOptionalLeadString ) ) == 0 )
pchTSteam2ID = pchSteam2ID + V_strlen( pchOptionalLeadString );
char cExtraCharCheck = 0;
int cFieldConverted = sscanf( pchTSteam2ID, "%hu:%u:%u%c", &steam2ID.m_SteamInstanceID,
&steam2ID.m_SteamLocalUserID.Split.High32bits, &steam2ID.m_SteamLocalUserID.Split.Low32bits, &cExtraCharCheck );
// Validate the conversion ... a special case is steam2 instance ID 1 which is reserved for special DoD handling
if ( cExtraCharCheck != 0 || cFieldConverted == EOF || cFieldConverted < 2 || ( cFieldConverted < 3 && steam2ID.m_SteamInstanceID != 1 ) )
return false;
// Now convert to steam ID from the Steam2 ID structure
SetFromSteam2( &steam2ID, eUniverse );
return true;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Renders the steam ID to a buffer. NOTE: for convenience of calling
// code, this code returns a pointer to a static buffer and is NOT thread-safe.
// Output: buffer with rendered Steam ID
//-----------------------------------------------------------------------------
const char * CSteamID::Render() const
{
// longest length of returned string is k_cBufLen
// [A:%u:%u:%u]
// %u == 10 * 3 + 6 == 36, plus terminator == 37
const int k_cBufLen = 37;
const int k_cBufs = 4; // # of static bufs to use (so people can compose output with multiple calls to Render() )
static char rgchBuf[k_cBufs][k_cBufLen];
static int nBuf = 0;
char * pchBuf = rgchBuf[nBuf]; // get pointer to current static buf
nBuf ++; // use next buffer for next call to this method
nBuf %= k_cBufs;
if ( k_EAccountTypeAnonGameServer == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[A:%u:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID, m_steamid.m_comp.m_unAccountInstance );
}
else if ( k_EAccountTypeGameServer == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[G:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( k_EAccountTypeMultiseat == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[M:%u:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID, m_steamid.m_comp.m_unAccountInstance );
}
else if ( k_EAccountTypePending == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[P:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( k_EAccountTypeContentServer == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[C:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( k_EAccountTypeClan == m_steamid.m_comp.m_EAccountType )
{
// 'g' for "group"
V_snprintf( pchBuf, k_cBufLen, "[g:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( k_EAccountTypeChat == m_steamid.m_comp.m_EAccountType )
{
if ( m_steamid.m_comp.m_unAccountInstance & k_EChatInstanceFlagClan )
{
V_snprintf( pchBuf, k_cBufLen, "[c:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( m_steamid.m_comp.m_unAccountInstance & k_EChatInstanceFlagLobby )
{
V_snprintf( pchBuf, k_cBufLen, "[L:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else // Anon chat
{
V_snprintf( pchBuf, k_cBufLen, "[T:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
}
else if ( k_EAccountTypeInvalid == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[I:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( k_EAccountTypeIndividual == m_steamid.m_comp.m_EAccountType )
{
if ( m_steamid.m_comp.m_unAccountInstance != k_unSteamUserDesktopInstance )
V_snprintf( pchBuf, k_cBufLen, "[U:%u:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID, m_steamid.m_comp.m_unAccountInstance );
else
V_snprintf( pchBuf, k_cBufLen, "[U:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else if ( k_EAccountTypeAnonUser == m_steamid.m_comp.m_EAccountType )
{
V_snprintf( pchBuf, k_cBufLen, "[a:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
else
{
V_snprintf( pchBuf, k_cBufLen, "[i:%u:%u]", m_steamid.m_comp.m_EUniverse, m_steamid.m_comp.m_unAccountID );
}
return pchBuf;
}
//-----------------------------------------------------------------------------
// Purpose: Renders the passed-in steam ID to a buffer. NOTE: for convenience of calling
// code, this code returns a pointer to a static buffer and is NOT thread-safe.
// Input: 64-bit representation of Steam ID to render
// Output: buffer with rendered Steam ID
//-----------------------------------------------------------------------------
const char * CSteamID::Render( uint64 ulSteamID )
{
CSteamID steamID( ulSteamID );
return steamID.Render();
}
//-----------------------------------------------------------------------------
// Purpose: some steamIDs are for internal use only
// This is really debug code, but we run with asserts on in retail, so ...
//-----------------------------------------------------------------------------
bool CSteamID::BValidExternalSteamID() const
{
if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypePending )
return false;
if ( m_steamid.m_comp.m_EAccountType != k_EAccountTypeAnonGameServer && m_steamid.m_comp.m_EAccountType != k_EAccountTypeContentServer && m_steamid.m_comp.m_EAccountType != k_EAccountTypeAnonUser )
{
if ( m_steamid.m_comp.m_unAccountID == 0 && m_steamid.m_comp.m_unAccountInstance == 0 )
return false;
}
return true;
}
#ifdef STEAM
//-----------------------------------------------------------------------------
// Purpose: Returns the matching chat steamID, with the default instance of 0
// Input: SteamID, either a Clan or a Chat type
// Output: SteamID with account type changed to chat, and the Clan flag set.
// If account type was not chat to start with, instance will be set to 0
//-----------------------------------------------------------------------------
CSteamID ChatIDFromSteamID( const CSteamID &steamID )
{
if ( steamID.GetEAccountType() == k_EAccountTypeChat )
return steamID;
return ChatIDFromClanID( steamID );
}
//-----------------------------------------------------------------------------
// Purpose: Returns the matching chat steamID, with the default instance of 0
// Input: SteamID, either a Clan type or a Chat type w/ the Clan flag set
// Output: SteamID with account type changed to clan.
// If account type was not clan to start with, instance will be set to 0
//-----------------------------------------------------------------------------
CSteamID ClanIDFromSteamID( const CSteamID &steamID )
{
if ( steamID.GetEAccountType() == k_EAccountTypeClan )
return steamID;
return ClanIDFromChatID( steamID );
}
// Asserts steamID type before conversion
CSteamID ChatIDFromClanID( const CSteamID &steamIDClan )
{
Assert( steamIDClan.GetEAccountType() == k_EAccountTypeClan );
return CSteamID( steamIDClan.GetAccountID(), k_EChatInstanceFlagClan, steamIDClan.GetEUniverse(), k_EAccountTypeChat );
}
// Asserts steamID type before conversion
CSteamID ClanIDFromChatID( const CSteamID &steamIDChat )
{
Assert( steamIDChat.GetEAccountType() == k_EAccountTypeChat );
Assert( k_EChatInstanceFlagClan & steamIDChat.GetUnAccountInstance() );
return CSteamID( steamIDChat.GetAccountID(), 0, steamIDChat.GetEUniverse(), k_EAccountTypeClan );
}
//-----------------------------------------------------------------------------
// Purpose: CGameID "hidden" functions
// move these somewhere else maybe
//-----------------------------------------------------------------------------
CGameID::CGameID( const char *pchGameID )
{
m_ulGameID = 0;
sscanf( pchGameID, "%llu", &m_ulGameID );
switch ( m_gameID.m_nType )
{
default:
AssertMsg( false, "Unknown GameID type" );
m_ulGameID = 0;
break;
case k_EGameIDTypeApp:
case k_EGameIDTypeGameMod:
case k_EGameIDTypeShortcut:
case k_EGameIDTypeP2P:
break;
}
}
// renders this Game ID to string
const char * CGameID::Render() const
{
// longest buffer is log10(2**64) == 20 + 1 == 21
const int k_cBufLen = 21;
const int k_cBufs = 4; // # of static bufs to use (so people can compose output with multiple calls to Render() )
static char rgchBuf[k_cBufs][k_cBufLen];
static int nBuf = 0;
char * pchBuf = rgchBuf[nBuf]; // get pointer to current static buf
nBuf ++; // use next buffer for next call to this method
nBuf %= k_cBufs;
V_snprintf( pchBuf, k_cBufLen, "%llu", m_ulGameID );
return pchBuf;
}
// static method to render a uint64 representation of a Game ID to a string
const char * CGameID::Render( uint64 ulGameID )
{
CGameID nGameID( ulGameID );
return nGameID.Render();
}
#endif