2070 lines
52 KiB
C++
2070 lines
52 KiB
C++
//========= 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;
|
|
}
|
|
|