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.

2070 lines
52 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "netmessages.h"
#include "bitbuf.h"
#include "const.h"
#include "../engine/net_chan.h"
#include "mathlib/mathlib.h"
#include "networkstringtabledefs.h"
#include "../engine/event_system.h"
#include "../engine/dt.h"
#include "tier0/vprof.h"
#include "convar.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// XXX(JohnS): This is no longer used, but we're keeping it so we can check if old network streams set it to work around
// missing information in the older SVC_VoiceInit packet. See SVC_VoiceInit::ReadFromBuffer
ConVar sv_use_steam_voice( "sv_use_steam_voice", "0", FCVAR_HIDDEN | FCVAR_REPLICATED,
"Deprecated - placeholder convar for handling old network streams that "
"had an incomplete SVC_VoiceInit packet. Use \"sv_voicecodec steam\"" );
static char s_text[1024];
const char *CLC_VoiceData::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: %i bytes", GetName(), Bits2Bytes(m_nLength) );
return s_text;
}
bool CLC_VoiceData::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteWord( m_nLength ); // length in bits
//Send this client's XUID (only needed on the 360)
#if defined ( _X360 )
buffer.WriteLongLong( m_xuid );
#endif
return buffer.WriteBits( m_DataOut.GetBasePointer(), m_nLength );
}
bool CLC_VoiceData::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_VoiceData::ReadFromBuffer" );
m_nLength = buffer.ReadWord(); // length in bits
#if defined ( _X360 )
m_xuid = buffer.ReadLongLong();
#endif
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *CLC_Move::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: backup %i, new %i, bytes %i", GetName(),
m_nNewCommands, m_nBackupCommands, Bits2Bytes(m_nLength) );
return s_text;
}
bool CLC_Move::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( m_nNewCommands, NUM_NEW_COMMAND_BITS );
buffer.WriteUBitLong( m_nBackupCommands, NUM_BACKUP_COMMAND_BITS );
buffer.WriteWord( m_nLength );
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool CLC_Move::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_Move::ReadFromBuffer" );
m_nNewCommands = buffer.ReadUBitLong( NUM_NEW_COMMAND_BITS );
m_nBackupCommands = buffer.ReadUBitLong( NUM_BACKUP_COMMAND_BITS );
m_nLength = buffer.ReadWord();
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *CLC_ClientInfo::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: SendTableCRC %i", GetName(),
m_nSendTableCRC );
return s_text;
}
bool CLC_ClientInfo::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteLong( m_nServerCount );
buffer.WriteLong( m_nSendTableCRC );
buffer.WriteOneBit( m_bIsHLTV?1:0 );
buffer.WriteLong( m_nFriendsID );
buffer.WriteString( m_FriendsName );
for ( int i=0; i<MAX_CUSTOM_FILES; i++ )
{
if ( m_nCustomFiles[i] != 0 )
{
buffer.WriteOneBit( 1 );
buffer.WriteUBitLong( m_nCustomFiles[i], 32 );
}
else
{
buffer.WriteOneBit( 0 );
}
}
#if defined( REPLAY_ENABLED )
buffer.WriteOneBit( m_bIsReplay?1:0 );
#endif
return !buffer.IsOverflowed();
}
bool CLC_ClientInfo::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_ClientInfo::ReadFromBuffer" );
m_nServerCount = buffer.ReadLong();
m_nSendTableCRC = buffer.ReadLong();
m_bIsHLTV = buffer.ReadOneBit()!=0;
m_nFriendsID = buffer.ReadLong();
buffer.ReadString( m_FriendsName, sizeof(m_FriendsName) );
for ( int i=0; i<MAX_CUSTOM_FILES; i++ )
{
if ( buffer.ReadOneBit() != 0 )
{
m_nCustomFiles[i] = buffer.ReadUBitLong( 32 );
}
else
{
m_nCustomFiles[i] = 0;
}
}
#if defined( REPLAY_ENABLED )
m_bIsReplay = buffer.ReadOneBit()!=0;
#endif
return !buffer.IsOverflowed();
}
bool CLC_BaselineAck::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteLong( m_nBaselineTick );
buffer.WriteUBitLong( m_nBaselineNr, 1 );
return !buffer.IsOverflowed();
}
bool CLC_BaselineAck::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_BaselineAck::ReadFromBuffer" );
m_nBaselineTick = buffer.ReadLong();
m_nBaselineNr = buffer.ReadUBitLong( 1 );
return !buffer.IsOverflowed();
}
const char *CLC_BaselineAck::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: tick %i", GetName(), m_nBaselineTick );
return s_text;
}
bool CLC_ListenEvents::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
int count = MAX_EVENT_NUMBER / 32;
for ( int i = 0; i < count; ++i )
{
buffer.WriteUBitLong( m_EventArray.GetDWord( i ), 32 );
}
return !buffer.IsOverflowed();
}
bool CLC_ListenEvents::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_ListenEvents::ReadFromBuffer" );
int count = MAX_EVENT_NUMBER / 32;
for ( int i = 0; i < count; ++i )
{
m_EventArray.SetDWord( i, buffer.ReadUBitLong( 32 ) );
}
return !buffer.IsOverflowed();
}
const char *CLC_ListenEvents::ToString(void) const
{
int count = 0;
for ( int i = 0; i<MAX_EVENT_NUMBER; i++ )
{
if ( m_EventArray.Get( i ) )
count++;
}
Q_snprintf(s_text, sizeof(s_text), "%s: registered events %i", GetName(), count );
return s_text;
}
bool CLC_RespondCvarValue::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteSBitLong( m_iCookie, 32 );
buffer.WriteSBitLong( m_eStatusCode, 4 );
buffer.WriteString( m_szCvarName );
buffer.WriteString( m_szCvarValue );
return !buffer.IsOverflowed();
}
bool CLC_RespondCvarValue::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_RespondCvarValue::ReadFromBuffer" );
m_iCookie = buffer.ReadSBitLong( 32 );
m_eStatusCode = (EQueryCvarValueStatus)buffer.ReadSBitLong( 4 );
// Read the name.
buffer.ReadString( m_szCvarNameBuffer, sizeof( m_szCvarNameBuffer ) );
m_szCvarName = m_szCvarNameBuffer;
// Read the value.
buffer.ReadString( m_szCvarValueBuffer, sizeof( m_szCvarValueBuffer ) );
m_szCvarValue = m_szCvarValueBuffer;
return !buffer.IsOverflowed();
}
const char *CLC_RespondCvarValue::ToString(void) const
{
Q_snprintf( s_text, sizeof(s_text), "%s: status: %d, value: %s, cookie: %d", GetName(), m_eStatusCode, m_szCvarValue, m_iCookie );
return s_text;
}
const char *g_MostCommonPathIDs[] =
{
"GAME",
"MOD"
};
const char *g_MostCommonPrefixes[] =
{
"materials",
"models",
"sounds",
"scripts"
};
static int FindCommonPathID( const char *pPathID )
{
for ( int i=0; i < ARRAYSIZE( g_MostCommonPathIDs ); i++ )
{
if ( V_stricmp( pPathID, g_MostCommonPathIDs[i] ) == 0 )
return i;
}
return -1;
}
static int FindCommonPrefix( const char *pStr )
{
for ( int i=0; i < ARRAYSIZE( g_MostCommonPrefixes ); i++ )
{
if ( V_stristr( pStr, g_MostCommonPrefixes[i] ) == pStr )
{
int iNextChar = V_strlen( g_MostCommonPrefixes[i] );
if ( pStr[iNextChar] == '/' || pStr[iNextChar] == '\\' )
return i;
}
}
return -1;
}
bool CLC_FileCRCCheck::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
// Reserved for future use.
buffer.WriteOneBit( 0 );
// Just write a couple bits for the path ID if it's one of the common ones.
int iCode = FindCommonPathID( m_szPathID );
if ( iCode == -1 )
{
buffer.WriteUBitLong( 0, 2 );
buffer.WriteString( m_szPathID );
}
else
{
buffer.WriteUBitLong( iCode+1, 2 );
}
iCode = FindCommonPrefix( m_szFilename );
if ( iCode == -1 )
{
buffer.WriteUBitLong( 0, 3 );
buffer.WriteChar( 1 ); // so we can detect the new message version
buffer.WriteString( m_szFilename );
}
else
{
buffer.WriteUBitLong( iCode+1, 3 );
buffer.WriteChar( 1 ); // so we can detect the new message version
buffer.WriteString( &m_szFilename[ V_strlen(g_MostCommonPrefixes[iCode])+1 ] );
}
buffer.WriteBits( &m_MD5.bits, sizeof(m_MD5.bits)*8 );
buffer.WriteUBitLong( m_CRCIOs, 32 );
buffer.WriteUBitLong( m_eFileHashType, 32 );
buffer.WriteUBitLong( m_cbFileLen, 32 );
buffer.WriteUBitLong( m_nPackFileNumber, 32 );
buffer.WriteUBitLong( m_PackFileID, 32 );
buffer.WriteUBitLong( m_nFileFraction, 32 );
return !buffer.IsOverflowed();
}
bool CLC_FileCRCCheck::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_FileCRCCheck::ReadFromBuffer" );
// Reserved for future use.
buffer.ReadOneBit();
// Read the path ID.
int iCode = buffer.ReadUBitLong( 2 );
if ( iCode == 0 )
{
buffer.ReadString( m_szPathID, sizeof( m_szPathID ) );
}
else if ( (iCode-1) < ARRAYSIZE( g_MostCommonPathIDs ) )
{
V_strncpy( m_szPathID, g_MostCommonPathIDs[iCode-1], sizeof( m_szPathID ) );
}
else
{
Assert( !"Invalid path ID code in CLC_FileCRCCheck" );
return false;
}
// Prefix string
iCode = buffer.ReadUBitLong( 3 );
// Read filename, and check for the new message format version?
char szTemp[ MAX_PATH ];
int c = buffer.ReadChar();
bool bNewVersion = false;
if ( c == 1 )
{
bNewVersion = true;
buffer.ReadString( szTemp, sizeof( szTemp ) );
}
else
{
szTemp[0] = (char)c;
buffer.ReadString( szTemp+1, sizeof( szTemp)-1 );
}
if ( iCode == 0 )
{
V_strcpy_safe( m_szFilename, szTemp );
}
else if ( (iCode-1) < ARRAYSIZE( g_MostCommonPrefixes ) )
{
V_sprintf_safe( m_szFilename, "%s%c%s", g_MostCommonPrefixes[iCode-1], CORRECT_PATH_SEPARATOR, szTemp );
}
else
{
Assert( !"Invalid prefix code in CLC_FileCRCCheck." );
return false;
}
if ( bNewVersion )
{
buffer.ReadBits( &m_MD5.bits, sizeof(m_MD5.bits)*8 );
m_CRCIOs = buffer.ReadUBitLong( 32 );
m_eFileHashType = buffer.ReadUBitLong( 32 );
m_cbFileLen = buffer.ReadUBitLong( 32 );
m_nPackFileNumber = buffer.ReadUBitLong( 32 );
m_PackFileID = buffer.ReadUBitLong( 32 );
m_nFileFraction = buffer.ReadUBitLong( 32 );
}
else
{
/* m_CRC */ buffer.ReadUBitLong( 32 );
m_CRCIOs = buffer.ReadUBitLong( 32 );
m_eFileHashType = buffer.ReadUBitLong( 32 );
}
return !buffer.IsOverflowed();
}
const char *CLC_FileCRCCheck::ToString(void) const
{
V_snprintf( s_text, sizeof(s_text), "%s: path: %s, file: %s", GetName(), m_szPathID, m_szFilename );
return s_text;
}
bool CLC_FileMD5Check::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
// Reserved for future use.
buffer.WriteOneBit( 0 );
// Just write a couple bits for the path ID if it's one of the common ones.
int iCode = FindCommonPathID( m_szPathID );
if ( iCode == -1 )
{
buffer.WriteUBitLong( 0, 2 );
buffer.WriteString( m_szPathID );
}
else
{
buffer.WriteUBitLong( iCode+1, 2 );
}
iCode = FindCommonPrefix( m_szFilename );
if ( iCode == -1 )
{
buffer.WriteUBitLong( 0, 3 );
buffer.WriteString( m_szFilename );
}
else
{
buffer.WriteUBitLong( iCode+1, 3 );
buffer.WriteString( &m_szFilename[ V_strlen(g_MostCommonPrefixes[iCode])+1 ] );
}
buffer.WriteBytes( m_MD5.bits, MD5_DIGEST_LENGTH );
return !buffer.IsOverflowed();
}
bool CLC_FileMD5Check::ReadFromBuffer( bf_read &buffer )
{
VPROF( "CLC_FileMD5Check::ReadFromBuffer" );
// Reserved for future use.
buffer.ReadOneBit();
// Read the path ID.
int iCode = buffer.ReadUBitLong( 2 );
if ( iCode == 0 )
{
buffer.ReadString( m_szPathID, sizeof( m_szPathID ) );
}
else if ( (iCode-1) < ARRAYSIZE( g_MostCommonPathIDs ) )
{
V_strncpy( m_szPathID, g_MostCommonPathIDs[iCode-1], sizeof( m_szPathID ) );
}
else
{
Assert( !"Invalid path ID code in CLC_FileMD5Check" );
return false;
}
// Read the filename.
iCode = buffer.ReadUBitLong( 3 );
if ( iCode == 0 )
{
buffer.ReadString( m_szFilename, sizeof( m_szFilename ) );
}
else if ( (iCode-1) < ARRAYSIZE( g_MostCommonPrefixes ) )
{
char szTemp[MAX_PATH];
buffer.ReadString( szTemp, sizeof( szTemp ) );
V_snprintf( m_szFilename, sizeof( m_szFilename ), "%s%c%s", g_MostCommonPrefixes[iCode-1], CORRECT_PATH_SEPARATOR, szTemp );
}
else
{
Assert( !"Invalid prefix code in CLC_FileMD5Check." );
return false;
}
buffer.ReadBytes( m_MD5.bits, MD5_DIGEST_LENGTH );
return !buffer.IsOverflowed();
}
const char *CLC_FileMD5Check::ToString(void) const
{
V_snprintf( s_text, sizeof(s_text), "%s: path: %s, file: %s", GetName(), m_szPathID, m_szFilename );
return s_text;
}
#if defined( REPLAY_ENABLED )
bool CLC_SaveReplay::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteString( m_szFilename );
buffer.WriteUBitLong( m_nStartSendByte, sizeof( m_nStartSendByte ) );
buffer.WriteFloat( m_flPostDeathRecordTime );
return !buffer.IsOverflowed();
}
bool CLC_SaveReplay::ReadFromBuffer( bf_read &buffer )
{
buffer.ReadString( m_szFilename, sizeof( m_szFilename ) );
m_nStartSendByte = buffer.ReadUBitLong( sizeof( m_nStartSendByte ) );
m_flPostDeathRecordTime = buffer.ReadFloat();
return !buffer.IsOverflowed();
}
const char *CLC_SaveReplay::ToString() const
{
V_snprintf( s_text, sizeof( s_text ), "%s: filename: %s, start byte: %i, post death record time: %f", GetName(), m_szFilename, m_nStartSendByte, m_flPostDeathRecordTime );
return s_text;
}
#endif
//
// CmdKeyValues message
//
Base_CmdKeyValues::Base_CmdKeyValues( KeyValues *pKeyValues /* = NULL */ ) :
m_pKeyValues( pKeyValues )
{
}
Base_CmdKeyValues::~Base_CmdKeyValues()
{
if ( m_pKeyValues )
m_pKeyValues->deleteThis();
m_pKeyValues = NULL;
}
bool Base_CmdKeyValues::WriteToBuffer( bf_write &buffer )
{
Assert( m_pKeyValues );
if ( !m_pKeyValues )
return false;
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
CUtlBuffer bufData;
if ( !m_pKeyValues->WriteAsBinary( bufData ) )
{
Assert( false );
return false;
}
// Note how many we're sending
int numBytes = bufData.TellMaxPut();
buffer.WriteLong( numBytes );
buffer.WriteBits( bufData.Base(), numBytes * 8 );
return !buffer.IsOverflowed();
}
bool Base_CmdKeyValues::ReadFromBuffer( bf_read &buffer )
{
VPROF( "Base_CmdKeyValues::ReadFromBuffer" );
if ( !m_pKeyValues )
m_pKeyValues = new KeyValues( "" );
m_pKeyValues->Clear();
int numBytes = buffer.ReadLong();
if ( numBytes <= 0 || numBytes > buffer.GetNumBytesLeft() )
{
return false; // don't read past the end of the buffer
}
void *pvBuffer = malloc( numBytes );
if ( !pvBuffer )
{
return false;
}
buffer.ReadBits( pvBuffer, numBytes * 8 );
CUtlBuffer bufRead( pvBuffer, numBytes, CUtlBuffer::READ_ONLY );
if ( !m_pKeyValues->ReadAsBinary( bufRead ) )
{
Assert( false );
free( pvBuffer );
return false;
}
free( pvBuffer );
return !buffer.IsOverflowed();
}
const char * Base_CmdKeyValues::ToString(void) const
{
Q_snprintf( s_text, sizeof(s_text), "%s: %s",
GetName(), m_pKeyValues ? m_pKeyValues->GetName() : "<<null>>" );
return s_text;
}
CLC_CmdKeyValues::CLC_CmdKeyValues( KeyValues *pKeyValues /* = NULL */ ) : Base_CmdKeyValues( pKeyValues )
{
}
bool CLC_CmdKeyValues::WriteToBuffer( bf_write &buffer )
{
return Base_CmdKeyValues::WriteToBuffer( buffer );
}
bool CLC_CmdKeyValues::ReadFromBuffer( bf_read &buffer )
{
return Base_CmdKeyValues::ReadFromBuffer( buffer );
}
const char *CLC_CmdKeyValues::ToString(void) const
{
return Base_CmdKeyValues::ToString();
}
SVC_CmdKeyValues::SVC_CmdKeyValues( KeyValues *pKeyValues /* = NULL */ ) : Base_CmdKeyValues( pKeyValues )
{
}
bool SVC_CmdKeyValues::WriteToBuffer( bf_write &buffer )
{
return Base_CmdKeyValues::WriteToBuffer( buffer );
}
bool SVC_CmdKeyValues::ReadFromBuffer( bf_read &buffer )
{
return Base_CmdKeyValues::ReadFromBuffer( buffer );
}
const char *SVC_CmdKeyValues::ToString(void) const
{
return Base_CmdKeyValues::ToString();
}
//
// SVC_Print message
//
bool SVC_Print::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
return buffer.WriteString( m_szText ? m_szText : " svc_print NULL" );
}
bool SVC_Print::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_Print::ReadFromBuffer" );
m_szText = m_szTextBuffer;
return buffer.ReadString(m_szTextBuffer, sizeof(m_szTextBuffer) );
}
const char *SVC_Print::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: \"%s\"", GetName(), m_szText );
return s_text;
}
bool NET_StringCmd::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
return buffer.WriteString( m_szCommand ? m_szCommand : " NET_StringCmd NULL" );
}
bool NET_StringCmd::ReadFromBuffer( bf_read &buffer )
{
VPROF( "NET_StringCmd::ReadFromBuffer" );
m_szCommand = m_szCommandBuffer;
return buffer.ReadString(m_szCommandBuffer, sizeof(m_szCommandBuffer) );
}
const char *NET_StringCmd::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: \"%s\"", GetName(), m_szCommand );
return s_text;
}
bool SVC_ServerInfo::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteShort ( m_nProtocol );
buffer.WriteLong ( m_nServerCount );
buffer.WriteOneBit( m_bIsHLTV?1:0);
buffer.WriteOneBit( m_bIsDedicated?1:0);
buffer.WriteLong ( 0xffffffff ); // Used to be client.dll CRC. This was far before signed binaries, VAC, and cross-platform play
buffer.WriteWord ( m_nMaxClasses );
buffer.WriteBytes( m_nMapMD5.bits, MD5_DIGEST_LENGTH ); // To prevent cheating with hacked maps
buffer.WriteByte ( m_nPlayerSlot );
buffer.WriteByte ( m_nMaxClients );
buffer.WriteFloat ( m_fTickInterval );
buffer.WriteChar ( m_cOS );
buffer.WriteString( m_szGameDir );
buffer.WriteString( m_szMapName );
buffer.WriteString( m_szSkyName );
buffer.WriteString( m_szHostName );
#if defined( REPLAY_ENABLED )
buffer.WriteOneBit( m_bIsReplay?1:0);
#endif
return !buffer.IsOverflowed();
}
bool SVC_ServerInfo::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_ServerInfo::ReadFromBuffer" );
m_szGameDir = m_szGameDirBuffer;
m_szMapName = m_szMapNameBuffer;
m_szSkyName = m_szSkyNameBuffer;
m_szHostName = m_szHostNameBuffer;
m_nProtocol = buffer.ReadShort();
m_nServerCount = buffer.ReadLong();
m_bIsHLTV = buffer.ReadOneBit()!=0;
m_bIsDedicated = buffer.ReadOneBit()!=0;
buffer.ReadLong(); // Legacy client CRC.
m_nMaxClasses = buffer.ReadWord();
// Prevent cheating with hacked maps
if ( m_nProtocol > PROTOCOL_VERSION_17 )
{
buffer.ReadBytes( m_nMapMD5.bits, MD5_DIGEST_LENGTH );
}
else
{
m_nMapCRC = buffer.ReadLong();
}
m_nPlayerSlot = buffer.ReadByte();
m_nMaxClients = buffer.ReadByte();
m_fTickInterval = buffer.ReadFloat();
m_cOS = buffer.ReadChar();
buffer.ReadString( m_szGameDirBuffer, sizeof(m_szGameDirBuffer) );
buffer.ReadString( m_szMapNameBuffer, sizeof(m_szMapNameBuffer) );
buffer.ReadString( m_szSkyNameBuffer, sizeof(m_szSkyNameBuffer) );
buffer.ReadString( m_szHostNameBuffer, sizeof(m_szHostNameBuffer) );
#if defined( REPLAY_ENABLED )
// Only attempt to read the 'replay' bit if the net channel's protocol
// version is greater or equal than the protocol version for replay's release.
// INetChannel::GetProtocolVersion() will return PROTOCOL_VERSION for
// a regular net channel, or the network protocol version from the demo
// file, if we're playing back a demo.
if ( m_NetChannel->GetProtocolVersion() >= PROTOCOL_VERSION_REPLAY )
{
m_bIsReplay = buffer.ReadOneBit() != 0;
}
#endif
return !buffer.IsOverflowed();
}
const char *SVC_ServerInfo::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: game \"%s\", map \"%s\", max %i", GetName(), m_szGameDir, m_szMapName, m_nMaxClients );
return s_text;
}
bool NET_SignonState::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteByte( m_nSignonState );
buffer.WriteLong( m_nSpawnCount );
return !buffer.IsOverflowed();
}
bool NET_SignonState::ReadFromBuffer( bf_read &buffer )
{
VPROF( "NET_SignonState::ReadFromBuffer" );
m_nSignonState = buffer.ReadByte();
m_nSpawnCount = buffer.ReadLong();
return !buffer.IsOverflowed();
}
const char *NET_SignonState::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: state %i, count %i", GetName(), m_nSignonState, m_nSpawnCount );
return s_text;
}
bool SVC_BSPDecal::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteBitVec3Coord( m_Pos );
buffer.WriteUBitLong( m_nDecalTextureIndex, MAX_DECAL_INDEX_BITS );
if ( m_nEntityIndex != 0)
{
buffer.WriteOneBit( 1 );
buffer.WriteUBitLong( m_nEntityIndex, MAX_EDICT_BITS );
buffer.WriteUBitLong( m_nModelIndex, SP_MODEL_INDEX_BITS );
}
else
{
buffer.WriteOneBit( 0 );
}
buffer.WriteOneBit( m_bLowPriority ? 1 : 0 );
return !buffer.IsOverflowed();
}
bool SVC_BSPDecal::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_BSPDecal::ReadFromBuffer" );
buffer.ReadBitVec3Coord( m_Pos );
m_nDecalTextureIndex = buffer.ReadUBitLong( MAX_DECAL_INDEX_BITS );
if ( buffer.ReadOneBit() != 0 )
{
m_nEntityIndex = buffer.ReadUBitLong( MAX_EDICT_BITS );
m_nModelIndex = buffer.ReadUBitLong( SP_MODEL_INDEX_BITS );
}
else
{
m_nEntityIndex = 0;
m_nModelIndex = 0;
}
m_bLowPriority = buffer.ReadOneBit() ? true : false;
return !buffer.IsOverflowed();
}
const char *SVC_BSPDecal::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: tex %i, ent %i, mod %i lowpriority %i",
GetName(), m_nDecalTextureIndex, m_nEntityIndex, m_nModelIndex, m_bLowPriority ? 1 : 0 );
return s_text;
}
bool SVC_SetView::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nEntityIndex, MAX_EDICT_BITS );
return !buffer.IsOverflowed();
}
bool SVC_SetView::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_SetView::ReadFromBuffer" );
m_nEntityIndex = buffer.ReadUBitLong( MAX_EDICT_BITS );
return !buffer.IsOverflowed();
}
const char *SVC_SetView::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: view entity %i", GetName(), m_nEntityIndex );
return s_text;
}
bool SVC_FixAngle::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteOneBit( m_bRelative ? 1 : 0 );
buffer.WriteBitAngle( m_Angle.x, 16 );
buffer.WriteBitAngle( m_Angle.y, 16 );
buffer.WriteBitAngle( m_Angle.z, 16 );
return !buffer.IsOverflowed();
}
bool SVC_FixAngle::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_FixAngle::ReadFromBuffer" );
m_bRelative = buffer.ReadOneBit() != 0;
m_Angle.x = buffer.ReadBitAngle( 16 );
m_Angle.y = buffer.ReadBitAngle( 16 );
m_Angle.z = buffer.ReadBitAngle( 16 );
return !buffer.IsOverflowed();
}
const char *SVC_FixAngle::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: %s %.1f %.1f %.1f ", GetName(), m_bRelative?"relative":"absolute",
m_Angle[0], m_Angle[1], m_Angle[2] );
return s_text;
}
bool SVC_CrosshairAngle::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteBitAngle( m_Angle.x, 16 );
buffer.WriteBitAngle( m_Angle.y, 16 );
buffer.WriteBitAngle( m_Angle.z, 16 );
return !buffer.IsOverflowed();
}
bool SVC_CrosshairAngle::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_CrosshairAngle::ReadFromBuffer" );
m_Angle.x = buffer.ReadBitAngle( 16 );
m_Angle.y = buffer.ReadBitAngle( 16 );
m_Angle.z = buffer.ReadBitAngle( 16 );
return !buffer.IsOverflowed();
}
const char *SVC_CrosshairAngle::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: (%.1f %.1f %.1f)", GetName(), m_Angle[0], m_Angle[1], m_Angle[2] );
return s_text;
}
bool SVC_VoiceInit::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteString( m_szVoiceCodec );
buffer.WriteByte( /* Legacy Quality Field */ 255 );
buffer.WriteShort( m_nSampleRate );
return !buffer.IsOverflowed();
}
bool SVC_VoiceInit::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_VoiceInit::ReadFromBuffer" );
buffer.ReadString( m_szVoiceCodec, sizeof(m_szVoiceCodec) );
unsigned char nLegacyQuality = buffer.ReadByte();
if ( nLegacyQuality == 255 )
{
// v2 packet
m_nSampleRate = buffer.ReadShort();
}
else
{
// v1 packet
//
// Hacky workaround for v1 packets not actually indicating if we were using steam voice -- we've kept the steam
// voice separate convar that was in use at the time as replicated&hidden, and if whatever network stream we're
// interpreting sets it, lie about the subsequent voice init's codec & sample rate.
if ( sv_use_steam_voice.GetBool() )
{
Msg( "Legacy SVC_VoiceInit - got a set for sv_use_steam_voice convar, assuming Steam voice\n" );
V_strncpy( m_szVoiceCodec, "steam", sizeof( m_szVoiceCodec ) );
// Legacy steam voice can always be parsed as auto sample rate.
m_nSampleRate = 0;
}
else if ( V_strncasecmp( m_szVoiceCodec, "vaudio_celt", sizeof( m_szVoiceCodec ) ) == 0 )
{
// Legacy rate vaudio_celt always selected during v1 packet era
m_nSampleRate = 22050;
}
else
{
// Legacy rate everything but CELT always selected during v1 packet era
m_nSampleRate = 11025;
}
}
return !buffer.IsOverflowed();
}
const char *SVC_VoiceInit::ToString(void) const
{
Q_snprintf( s_text, sizeof(s_text), "%s: codec \"%s\", sample rate %i", GetName(), m_szVoiceCodec, m_nSampleRate );
return s_text;
}
bool SVC_VoiceData::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteByte( m_nFromClient );
buffer.WriteByte( m_bProximity );
buffer.WriteWord( m_nLength );
if ( IsX360() )
{
buffer.WriteLongLong( m_xuid );
}
return buffer.WriteBits( m_DataOut, m_nLength );
}
bool SVC_VoiceData::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_VoiceData::ReadFromBuffer" );
m_nFromClient = buffer.ReadByte();
m_bProximity = !!buffer.ReadByte();
m_nLength = buffer.ReadWord();
if ( IsX360() )
{
m_xuid = buffer.ReadLongLong();
}
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_VoiceData::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: client %i, bytes %i", GetName(), m_nFromClient, Bits2Bytes(m_nLength) );
return s_text;
}
#define NET_TICK_SCALEUP 100000.0f
bool NET_Tick::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteLong( m_nTick );
#if PROTOCOL_VERSION > 10
buffer.WriteUBitLong( clamp( (int)( NET_TICK_SCALEUP * m_flHostFrameTime ), 0, 65535 ), 16 );
buffer.WriteUBitLong( clamp( (int)( NET_TICK_SCALEUP * m_flHostFrameTimeStdDeviation ), 0, 65535 ), 16 );
#endif
return !buffer.IsOverflowed();
}
bool NET_Tick::ReadFromBuffer( bf_read &buffer )
{
VPROF( "NET_Tick::ReadFromBuffer" );
m_nTick = buffer.ReadLong();
#if PROTOCOL_VERSION > 10
m_flHostFrameTime = (float)buffer.ReadUBitLong( 16 ) / NET_TICK_SCALEUP;
m_flHostFrameTimeStdDeviation = (float)buffer.ReadUBitLong( 16 ) / NET_TICK_SCALEUP;
#endif
return !buffer.IsOverflowed();
}
const char *NET_Tick::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: tick %i", GetName(), m_nTick );
return s_text;
}
bool SVC_UserMessage::WriteToBuffer( bf_write &buffer )
{
m_nLength = m_DataOut.GetNumBitsWritten();
Assert( m_nLength < (1 << NETMSG_LENGTH_BITS) );
if ( m_nLength >= (1 << NETMSG_LENGTH_BITS) )
return false;
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteByte( m_nMsgType );
buffer.WriteUBitLong( m_nLength, NETMSG_LENGTH_BITS ); // max 256 * 8 bits, see MAX_USER_MSG_DATA
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_UserMessage::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_UserMessage::ReadFromBuffer" );
m_nMsgType = buffer.ReadByte();
m_nLength = buffer.ReadUBitLong( NETMSG_LENGTH_BITS ); // max 256 * 8 bits, see MAX_USER_MSG_DATA
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_UserMessage::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: type %i, bytes %i", GetName(), m_nMsgType, Bits2Bytes(m_nLength) );
return s_text;
}
bool SVC_SetPause::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteOneBit( m_bPaused?1:0 );
return !buffer.IsOverflowed();
}
bool SVC_SetPause::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_SetPause::ReadFromBuffer" );
m_bPaused = buffer.ReadOneBit() != 0;
return !buffer.IsOverflowed();
}
const char *SVC_SetPause::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: %s", GetName(), m_bPaused?"paused":"unpaused" );
return s_text;
}
bool SVC_SetPauseTimed::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteOneBit( m_bPaused ? 1 : 0 );
buffer.WriteFloat( m_flExpireTime );
return !buffer.IsOverflowed();
}
bool SVC_SetPauseTimed::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_SetPauseTimed::ReadFromBuffer" );
m_bPaused = buffer.ReadOneBit() != 0;
m_flExpireTime = buffer.ReadFloat();
return !buffer.IsOverflowed();
}
const char *SVC_SetPauseTimed::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "%s: %s", GetName(), m_bPaused ? "paused" : "unpaused" );
return s_text;
}
bool NET_SetConVar::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
int numvars = m_ConVars.Count();
// Note how many we're sending
buffer.WriteByte( numvars );
for (int i=0; i< numvars; i++ )
{
cvar_t * var = &m_ConVars[i];
buffer.WriteString( var->name );
buffer.WriteString( var->value );
}
return !buffer.IsOverflowed();
}
bool NET_SetConVar::ReadFromBuffer( bf_read &buffer )
{
VPROF( "NET_SetConVar::ReadFromBuffer" );
int numvars = buffer.ReadByte();
m_ConVars.RemoveAll();
for (int i=0; i< numvars; i++ )
{
cvar_t var;
buffer.ReadString( var.name, sizeof(var.name) );
buffer.ReadString( var.value, sizeof(var.value) );
m_ConVars.AddToTail( var );
}
return !buffer.IsOverflowed();
}
const char *NET_SetConVar::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: %i cvars, \"%s\"=\"%s\"",
GetName(), m_ConVars.Count(),
m_ConVars[0].name, m_ConVars[0].value );
return s_text;
}
bool SVC_UpdateStringTable::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( m_nTableID, Q_log2( MAX_TABLES ) ); // TODO check bounds
if ( m_nChangedEntries == 1 )
{
buffer.WriteOneBit( 0 ); // only one entry changed
}
else
{
buffer.WriteOneBit( 1 );
buffer.WriteWord( m_nChangedEntries ); // more entries changed
}
buffer.WriteUBitLong( m_nLength, 20 );
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_UpdateStringTable::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_UpdateStringTable::ReadFromBuffer" );
m_nTableID = buffer.ReadUBitLong( Q_log2( MAX_TABLES ) );
if ( buffer.ReadOneBit() != 0 )
{
m_nChangedEntries = buffer.ReadWord();
}
else
{
m_nChangedEntries = 1;
}
m_nLength = buffer.ReadUBitLong( 20 );
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_UpdateStringTable::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: table %i, changed %i, bytes %i", GetName(), m_nTableID, m_nChangedEntries, Bits2Bytes(m_nLength) );
return s_text;
}
SVC_CreateStringTable::SVC_CreateStringTable()
{
}
bool SVC_CreateStringTable::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
m_nLength = m_DataOut.GetNumBitsWritten();
/*
JASON: this code is no longer needed; the ':' is prepended to the table name at table creation time.
if ( m_bIsFilenames )
{
// identifies a table that hosts filenames
buffer.WriteByte( ':' );
}
*/
buffer.WriteString( m_szTableName );
buffer.WriteWord( m_nMaxEntries );
int encodeBits = Q_log2( m_nMaxEntries );
buffer.WriteUBitLong( m_nNumEntries, encodeBits+1 );
buffer.WriteVarInt32( m_nLength ); // length in bits
buffer.WriteOneBit( m_bUserDataFixedSize ? 1 : 0 );
if ( m_bUserDataFixedSize )
{
buffer.WriteUBitLong( m_nUserDataSize, 12 );
buffer.WriteUBitLong( m_nUserDataSizeBits, 4 );
}
buffer.WriteOneBit( m_bDataCompressed ? 1 : 0 );
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_CreateStringTable::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_CreateStringTable::ReadFromBuffer" );
char prefix = buffer.PeekUBitLong( 8 );
if ( prefix == ':' )
{
// table hosts filenames
m_bIsFilenames = true;
buffer.ReadByte();
}
else
{
m_bIsFilenames = false;
}
m_szTableName = m_szTableNameBuffer;
buffer.ReadString( m_szTableNameBuffer, sizeof(m_szTableNameBuffer) );
m_nMaxEntries = buffer.ReadWord();
int encodeBits = Q_log2( m_nMaxEntries );
m_nNumEntries = buffer.ReadUBitLong( encodeBits+1 );
if ( m_NetChannel->GetProtocolVersion() > PROTOCOL_VERSION_23 )
m_nLength = buffer.ReadVarInt32();
else
m_nLength = buffer.ReadUBitLong( NET_MAX_PAYLOAD_BITS_V23 + 3 );
m_bUserDataFixedSize = buffer.ReadOneBit() ? true : false;
if ( m_bUserDataFixedSize )
{
m_nUserDataSize = buffer.ReadUBitLong( 12 );
m_nUserDataSizeBits = buffer.ReadUBitLong( 4 );
}
else
{
m_nUserDataSize = 0;
m_nUserDataSizeBits = 0;
}
if ( m_pMessageHandler->GetDemoProtocolVersion() > PROTOCOL_VERSION_14 )
{
m_bDataCompressed = buffer.ReadOneBit() != 0;
}
else
{
m_bDataCompressed = false;
}
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_CreateStringTable::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: table %s, entries %i, bytes %i userdatasize %i userdatabits %i",
GetName(), m_szTableName, m_nNumEntries, Bits2Bytes(m_nLength), m_nUserDataSize, m_nUserDataSizeBits );
return s_text;
}
bool SVC_Sounds::WriteToBuffer( bf_write &buffer )
{
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
Assert( m_nNumSounds > 0 );
if ( m_bReliableSound )
{
// as single sound message is 32 bytes long maximum
buffer.WriteOneBit( 1 );
buffer.WriteUBitLong( m_nLength, 8 );
}
else
{
// a bunch of unreliable messages
buffer.WriteOneBit( 0 );
buffer.WriteUBitLong( m_nNumSounds, 8 );
buffer.WriteUBitLong( m_nLength, 16 );
}
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_Sounds::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_Sounds::ReadFromBuffer" );
m_bReliableSound = buffer.ReadOneBit() != 0;
if ( m_bReliableSound )
{
m_nNumSounds = 1;
m_nLength = buffer.ReadUBitLong( 8 );
}
else
{
m_nNumSounds = buffer.ReadUBitLong( 8 );
m_nLength = buffer.ReadUBitLong( 16 );
}
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_Sounds::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: number %i,%s bytes %i",
GetName(), m_nNumSounds, m_bReliableSound?" reliable,":"", Bits2Bytes(m_nLength) );
return s_text;
}
bool SVC_Prefetch::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
// Don't write type until we have more thanone
// buffer.WriteUBitLong( m_fType, 1 );
buffer.WriteUBitLong( m_nSoundIndex, MAX_SOUND_INDEX_BITS );
return !buffer.IsOverflowed();
}
bool SVC_Prefetch::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_Prefetch::ReadFromBuffer" );
m_fType = SOUND; // buffer.ReadUBitLong( 1 );
if( m_pMessageHandler->GetDemoProtocolVersion() > 22 )
{
m_nSoundIndex = buffer.ReadUBitLong( MAX_SOUND_INDEX_BITS );
}
else
{
m_nSoundIndex = buffer.ReadUBitLong( 13 );
}
return !buffer.IsOverflowed();
}
const char *SVC_Prefetch::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: type %i index %i",
GetName(),
(int)m_fType,
(int)m_nSoundIndex );
return s_text;
}
bool SVC_TempEntities::WriteToBuffer( bf_write &buffer )
{
Assert( m_nNumEntries > 0 );
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nNumEntries, CEventInfo::EVENT_INDEX_BITS );
buffer.WriteVarInt32( m_nLength );
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_TempEntities::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_TempEntities::ReadFromBuffer" );
m_nNumEntries = buffer.ReadUBitLong( CEventInfo::EVENT_INDEX_BITS );
if ( m_pMessageHandler->GetDemoProtocolVersion() > PROTOCOL_VERSION_23 )
m_nLength = buffer.ReadVarInt32();
else
m_nLength = buffer.ReadUBitLong( NET_MAX_PAYLOAD_BITS_V23 );
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_TempEntities::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: number %i, bytes %i", GetName(), m_nNumEntries, Bits2Bytes(m_nLength) );
return s_text;
}
bool SVC_ClassInfo::WriteToBuffer( bf_write &buffer )
{
if ( !m_bCreateOnClient )
{
m_nNumServerClasses = m_Classes.Count(); // use number from list list
}
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteShort( m_nNumServerClasses );
int serverClassBits = Q_log2( m_nNumServerClasses ) + 1;
buffer.WriteOneBit( m_bCreateOnClient?1:0 );
if ( m_bCreateOnClient )
return !buffer.IsOverflowed();
for ( int i=0; i< m_nNumServerClasses; i++ )
{
class_t * serverclass = &m_Classes[i];
buffer.WriteUBitLong( serverclass->classID, serverClassBits );
buffer.WriteString( serverclass->classname );
buffer.WriteString( serverclass->datatablename );
}
return !buffer.IsOverflowed();
}
bool SVC_ClassInfo::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_ClassInfo::ReadFromBuffer" );
m_Classes.RemoveAll();
m_nNumServerClasses = buffer.ReadShort();
int nServerClassBits = Q_log2( m_nNumServerClasses ) + 1;
m_bCreateOnClient = buffer.ReadOneBit() != 0;
if ( m_bCreateOnClient )
{
return !buffer.IsOverflowed(); // stop here
}
for ( int i=0; i<m_nNumServerClasses; i++ )
{
class_t serverclass;
serverclass.classID = buffer.ReadUBitLong( nServerClassBits );
buffer.ReadString( serverclass.classname, sizeof(serverclass.classname) );
buffer.ReadString( serverclass.datatablename, sizeof(serverclass.datatablename) );
m_Classes.AddToTail( serverclass );
}
return !buffer.IsOverflowed();
}
const char *SVC_ClassInfo::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: num %i, %s", GetName(),
m_nNumServerClasses, m_bCreateOnClient?"use client classes":"full update" );
return s_text;
}
/*
bool SVC_SpawnBaseline::WriteToBuffer( bf_write &buffer )
{
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nEntityIndex, MAX_EDICT_BITS );
buffer.WriteUBitLong( m_nClassID, MAX_SERVER_CLASS_BITS );
buffer.WriteUBitLong( m_nLength, Q_log2(MAX_PACKEDENTITY_DATA<<3) ); // TODO see below
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_SpawnBaseline::ReadFromBuffer( bf_read &buffer )
{
m_nEntityIndex = buffer.ReadUBitLong( MAX_EDICT_BITS );
m_nClassID = buffer.ReadUBitLong( MAX_SERVER_CLASS_BITS );
m_nLength = buffer.ReadUBitLong( Q_log2(MAX_PACKEDENTITY_DATA<<3) ); // TODO wrong, check bounds
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_SpawnBaseline::ToString(void) const
{
static char text[256];
Q_snprintf(text, sizeof(text), "%s: ent %i, class %i, bytes %i",
GetName(), m_nEntityIndex, m_nClassID, Bits2Bytes(m_nLength) );
return text;
} */
bool SVC_GameEvent::WriteToBuffer( bf_write &buffer )
{
m_nLength = m_DataOut.GetNumBitsWritten();
Assert( m_nLength < (1 << NETMSG_LENGTH_BITS) );
if ( m_nLength >= (1 << NETMSG_LENGTH_BITS) )
return false;
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nLength, NETMSG_LENGTH_BITS ); // max 8 * 256 bits
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_GameEvent::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_GameEvent::ReadFromBuffer" );
m_nLength = buffer.ReadUBitLong( NETMSG_LENGTH_BITS ); // max 8 * 256 bits
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_GameEvent::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: bytes %i", GetName(), Bits2Bytes(m_nLength) );
return s_text;
}
bool SVC_SendTable::WriteToBuffer( bf_write &buffer )
{
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteOneBit( m_bNeedsDecoder?1:0 );
buffer.WriteShort( m_nLength );
buffer.WriteBits( m_DataOut.GetData(), m_nLength );
return !buffer.IsOverflowed();
}
bool SVC_SendTable::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_SendTable::ReadFromBuffer" );
m_bNeedsDecoder = buffer.ReadOneBit() != 0;
m_nLength = buffer.ReadShort(); // TODO do we have a maximum length ? check that
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_SendTable::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: needs Decoder %s,bytes %i",
GetName(), m_bNeedsDecoder?"yes":"no", Bits2Bytes(m_nLength) );
return s_text;
}
bool SVC_EntityMessage::WriteToBuffer( bf_write &buffer )
{
m_nLength = m_DataOut.GetNumBitsWritten();
Assert( m_nLength < (1 << NETMSG_LENGTH_BITS) );
if ( m_nLength >= (1 << NETMSG_LENGTH_BITS) )
return false;
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nEntityIndex, MAX_EDICT_BITS );
buffer.WriteUBitLong( m_nClassID, MAX_SERVER_CLASS_BITS );
buffer.WriteUBitLong( m_nLength, NETMSG_LENGTH_BITS ); // max 8 * 256 bits
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_EntityMessage::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_EntityMessage::ReadFromBuffer" );
m_nEntityIndex = buffer.ReadUBitLong( MAX_EDICT_BITS );
m_nClassID = buffer.ReadUBitLong( MAX_SERVER_CLASS_BITS );
m_nLength = buffer.ReadUBitLong( NETMSG_LENGTH_BITS ); // max 8 * 256 bits
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_EntityMessage::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: entity %i, class %i, bytes %i",
GetName(), m_nEntityIndex, m_nClassID, Bits2Bytes(m_nLength) );
return s_text;
}
bool SVC_PacketEntities::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nMaxEntries, MAX_EDICT_BITS );
buffer.WriteOneBit( m_bIsDelta?1:0 );
if ( m_bIsDelta )
{
buffer.WriteLong( m_nDeltaFrom );
}
buffer.WriteUBitLong( m_nBaseline, 1 );
buffer.WriteUBitLong( m_nUpdatedEntries, MAX_EDICT_BITS );
buffer.WriteUBitLong( m_nLength, DELTASIZE_BITS );
buffer.WriteOneBit( m_bUpdateBaseline?1:0 );
buffer.WriteBits( m_DataOut.GetData(), m_nLength );
return !buffer.IsOverflowed();
}
bool SVC_PacketEntities::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_PacketEntities::ReadFromBuffer" );
m_nMaxEntries = buffer.ReadUBitLong( MAX_EDICT_BITS );
m_bIsDelta = buffer.ReadOneBit()!=0;
if ( m_bIsDelta )
{
m_nDeltaFrom = buffer.ReadLong();
}
else
{
m_nDeltaFrom = -1;
}
m_nBaseline = buffer.ReadUBitLong( 1 );
m_nUpdatedEntries = buffer.ReadUBitLong( MAX_EDICT_BITS );
m_nLength = buffer.ReadUBitLong( DELTASIZE_BITS );
m_bUpdateBaseline = buffer.ReadOneBit() != 0;
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_PacketEntities::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: delta %i, max %i, changed %i,%s bytes %i",
GetName(), m_nDeltaFrom, m_nMaxEntries, m_nUpdatedEntries, m_bUpdateBaseline?" BL update,":"", Bits2Bytes(m_nLength) );
return s_text;
}
SVC_Menu::SVC_Menu( DIALOG_TYPE type, KeyValues *data )
{
m_bReliable = true;
m_Type = type;
m_MenuKeyValues = data->MakeCopy();
m_iLength = -1;
}
SVC_Menu::~SVC_Menu()
{
if ( m_MenuKeyValues )
{
m_MenuKeyValues->deleteThis();
}
}
bool SVC_Menu::WriteToBuffer( bf_write &buffer )
{
if ( !m_MenuKeyValues )
{
return false;
}
CUtlBuffer buf;
m_MenuKeyValues->WriteAsBinary( buf );
if ( buf.TellPut() > 4096 )
{
Msg( "Too much menu data (4096 bytes max)\n" );
return false;
}
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteShort( m_Type );
buffer.WriteWord( buf.TellPut() );
buffer.WriteBytes( buf.Base(), buf.TellPut() );
return !buffer.IsOverflowed();
}
bool SVC_Menu::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_Menu::ReadFromBuffer" );
m_Type = (DIALOG_TYPE)buffer.ReadShort();
m_iLength = buffer.ReadWord();
CUtlBuffer buf( 0, m_iLength );
buffer.ReadBytes( buf.Base(), m_iLength );
buf.SeekPut( CUtlBuffer::SEEK_HEAD, m_iLength );
if ( m_MenuKeyValues )
{
m_MenuKeyValues->deleteThis();
}
m_MenuKeyValues = new KeyValues( "menu" );
Assert( m_MenuKeyValues );
m_MenuKeyValues->ReadAsBinary( buf );
return !buffer.IsOverflowed();
}
const char *SVC_Menu::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: %i \"%s\" (len:%i)", GetName(),
m_Type, m_MenuKeyValues ? m_MenuKeyValues->GetName() : "No KeyValues", m_iLength );
return s_text;
}
bool SVC_GameEventList::WriteToBuffer( bf_write &buffer )
{
Assert( m_nNumEvents > 0 );
m_nLength = m_DataOut.GetNumBitsWritten();
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteUBitLong( m_nNumEvents, MAX_EVENT_BITS );
buffer.WriteUBitLong( m_nLength, 20 );
return buffer.WriteBits( m_DataOut.GetData(), m_nLength );
}
bool SVC_GameEventList::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_GameEventList::ReadFromBuffer" );
m_nNumEvents = buffer.ReadUBitLong( MAX_EVENT_BITS );
m_nLength = buffer.ReadUBitLong( 20 );
m_DataIn = buffer;
return buffer.SeekRelative( m_nLength );
}
const char *SVC_GameEventList::ToString(void) const
{
Q_snprintf(s_text, sizeof(s_text), "%s: number %i, bytes %i", GetName(), m_nNumEvents, Bits2Bytes(m_nLength) );
return s_text;
}
///////////////////////////////////////////////////////////////////////////////////////
// Matchmaking messages:
///////////////////////////////////////////////////////////////////////////////////////
bool MM_Heartbeat::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
return !buffer.IsOverflowed();
}
bool MM_Heartbeat::ReadFromBuffer( bf_read &buffer )
{
return true;
}
const char *MM_Heartbeat::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "Heartbeat" );
return s_text;
}
bool MM_ClientInfo::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteBytes( &m_xnaddr, sizeof( m_xnaddr ) );
buffer.WriteLongLong( m_id ); // 64 bit
buffer.WriteByte( m_cPlayers );
buffer.WriteByte( m_bInvited );
for ( int i = 0; i < m_cPlayers; ++i )
{
buffer.WriteLongLong( m_xuids[i] ); // 64 bit
buffer.WriteBytes( &m_cVoiceState, sizeof( m_cVoiceState ) );
buffer.WriteLong( m_iTeam[i] );
buffer.WriteByte( m_iControllers[i] );
buffer.WriteString( m_szGamertags[i] );
}
return !buffer.IsOverflowed();
}
bool MM_ClientInfo::ReadFromBuffer( bf_read &buffer )
{
buffer.ReadBytes( &m_xnaddr, sizeof( m_xnaddr ) );
m_id = buffer.ReadLongLong(); // 64 bit
m_cPlayers = buffer.ReadByte();
m_bInvited = (buffer.ReadByte() != 0);
for ( int i = 0; i < m_cPlayers; ++i )
{
m_xuids[i] = buffer.ReadLongLong(); // 64 bit
buffer.ReadBytes( &m_cVoiceState, sizeof( m_cVoiceState ) );
m_iTeam[i] = buffer.ReadLong();
m_iControllers[i] = buffer.ReadByte();
buffer.ReadString( m_szGamertags[i], sizeof( m_szGamertags[i] ), true );
}
return !buffer.IsOverflowed();
}
const char *MM_ClientInfo::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "Client Info: ID: %llu, Players: %d", m_id, m_cPlayers );
return s_text;
}
bool MM_RegisterResponse::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
return !buffer.IsOverflowed();
}
bool MM_RegisterResponse::ReadFromBuffer( bf_read &buffer )
{
return true;
}
const char *MM_RegisterResponse::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "Register Response" );
return s_text;
}
bool MM_Mutelist::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteLongLong( m_id );
buffer.WriteByte( m_cPlayers );
for ( int i = 0; i < m_cPlayers; ++i )
{
buffer.WriteByte( m_cRemoteTalkers[i] );
buffer.WriteLongLong( m_xuid[i] ); // 64 bit
buffer.WriteByte( m_cMuted[i] );
for ( int j = 0; j < m_cMuted[i]; ++j )
{
buffer.WriteLongLong( m_Muted[i][j] );
}
}
return !buffer.IsOverflowed();
}
bool MM_Mutelist::ReadFromBuffer( bf_read &buffer )
{
m_id = buffer.ReadLongLong();
m_cPlayers = buffer.ReadByte();
for ( int i = 0; i < m_cPlayers; ++i )
{
m_cRemoteTalkers[i] = buffer.ReadByte();
m_xuid[i] = buffer.ReadLongLong(); // 64 bit
m_cMuted[i] = buffer.ReadByte();
for ( int j = 0; j < m_cMuted[i]; ++j )
{
m_Muted[i].AddToTail( buffer.ReadLongLong() );
}
}
return !buffer.IsOverflowed();
}
const char *MM_Mutelist::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "Mutelist" );
return s_text;
}
bool MM_Checkpoint::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteByte( m_Checkpoint );
return !buffer.IsOverflowed();
}
bool MM_Checkpoint::ReadFromBuffer( bf_read &buffer )
{
m_Checkpoint = buffer.ReadByte();
return !buffer.IsOverflowed();
}
const char *MM_Checkpoint::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "Checkpoint: %d", m_Checkpoint );
return s_text;
}
// NOTE: This message is not network-endian compliant, due to the
// transmission of structures instead of their component parts
bool MM_JoinResponse::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteLong( m_ResponseType );
buffer.WriteLongLong( m_id ); // 64 bit
buffer.WriteLongLong( m_Nonce ); // 64 bit
buffer.WriteLong( m_SessionFlags );
buffer.WriteLong( m_nOwnerId );
buffer.WriteLong( m_iTeam );
buffer.WriteLong( m_nTotalTeams );
buffer.WriteByte( m_PropertyCount );
buffer.WriteByte( m_ContextCount );
for ( int i = 0; i < m_PropertyCount; ++i )
{
buffer.WriteBytes( &m_SessionProperties[i], sizeof( XUSER_PROPERTY ) );
}
for ( int i = 0; i < m_ContextCount; ++i )
{
buffer.WriteBytes( &m_SessionContexts[i], sizeof( XUSER_CONTEXT ) );
}
return !buffer.IsOverflowed();
}
bool MM_JoinResponse::ReadFromBuffer( bf_read &buffer )
{
m_ResponseType = buffer.ReadLong();
m_id = buffer.ReadLongLong(); // 64 bit
m_Nonce = buffer.ReadLongLong(); // 64 bit
m_SessionFlags = buffer.ReadLong();
m_nOwnerId = buffer.ReadLong();
m_iTeam = buffer.ReadLong();
m_nTotalTeams = buffer.ReadLong();
m_PropertyCount = buffer.ReadByte();
m_ContextCount = buffer.ReadByte();
XUSER_PROPERTY prop;
m_SessionProperties.RemoveAll();
for ( int i = 0; i < m_PropertyCount; ++i )
{
buffer.ReadBytes( &prop, sizeof( XUSER_PROPERTY ) );
m_SessionProperties.AddToTail( prop );
}
XUSER_CONTEXT ctx;
m_SessionContexts.RemoveAll();
for ( int i = 0; i < m_ContextCount; ++i )
{
buffer.ReadBytes( &ctx, sizeof( XUSER_CONTEXT ) );
m_SessionContexts.AddToTail( ctx );
}
return !buffer.IsOverflowed();
}
const char *MM_JoinResponse::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "ID: %llu, Nonce: %llu, Flags: %u", m_id, m_Nonce, m_SessionFlags );
return s_text;
}
// NOTE: This message is not network-endian compliant, due to the
// transmission of structures instead of their component parts
bool MM_Migrate::WriteToBuffer( bf_write &buffer )
{
Assert( IsX360() );
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteByte( m_MsgType );
buffer.WriteLongLong( m_Id );
buffer.WriteBytes( &m_sessionId, sizeof( m_sessionId ) );
buffer.WriteBytes( &m_xnaddr, sizeof( m_xnaddr ) );
buffer.WriteBytes( &m_key, sizeof( m_key ) );
return !buffer.IsOverflowed();
}
bool MM_Migrate::ReadFromBuffer( bf_read &buffer )
{
Assert( IsX360() );
m_MsgType = buffer.ReadByte();
m_Id = buffer.ReadLongLong();
buffer.ReadBytes( &m_sessionId, sizeof( m_sessionId ) );
buffer.ReadBytes( &m_xnaddr, sizeof( m_xnaddr ) );
buffer.ReadBytes( &m_key, sizeof( m_key ) );
return !buffer.IsOverflowed();
}
const char *MM_Migrate::ToString( void ) const
{
Q_snprintf( s_text, sizeof( s_text ), "Migrate Message" );
return s_text;
}
bool SVC_GetCvarValue::WriteToBuffer( bf_write &buffer )
{
buffer.WriteUBitLong( GetType(), NETMSG_TYPE_BITS );
buffer.WriteSBitLong( m_iCookie, 32 );
buffer.WriteString( m_szCvarName );
return !buffer.IsOverflowed();
}
bool SVC_GetCvarValue::ReadFromBuffer( bf_read &buffer )
{
VPROF( "SVC_GetCvarValue::ReadFromBuffer" );
m_iCookie = buffer.ReadSBitLong( 32 );
buffer.ReadString( m_szCvarNameBuffer, sizeof( m_szCvarNameBuffer ) );
m_szCvarName = m_szCvarNameBuffer;
return !buffer.IsOverflowed();
}
const char *SVC_GetCvarValue::ToString(void) const
{
Q_snprintf( s_text, sizeof(s_text), "%s: cvar: %s, cookie: %d", GetName(), m_szCvarName, m_iCookie );
return s_text;
}