1

common/netmessages.h

@@ -0,0 +1,917 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef NETMESSAGES_H
+#define NETMESSAGES_H
+
+#ifdef _WIN32
+#pragma once
+#pragma warning(disable : 4100)	// unreferenced formal parameter
+#endif
+
+#include <inetmessage.h>
+#include <checksum_crc.h>
+#include <checksum_md5.h>
+#include <const.h>
+#include <utlvector.h>
+#include "qlimits.h"
+#include "mathlib/vector.h"
+#include <soundflags.h>
+#include <bitbuf.h>
+#include <inetchannel.h>
+#include "protocol.h"
+#include <inetmsghandler.h>
+#include <igameevents.h>
+#include <bitvec.h>
+#include <engine/iserverplugin.h>
+#include <Color.h>
+#include "proto_version.h"
+
+#if !defined( _X360 )
+#include "xbox/xboxstubs.h"
+#endif
+
+class SendTable;
+class KeyValue;
+class KeyValues;
+class INetMessageHandler;
+class IServerMessageHandler;
+class IClientMessageHandler;
+
+#define DECLARE_BASE_MESSAGE( msgtype )						\
+	public:													\
+		bool			ReadFromBuffer( bf_read &buffer );	\
+		bool			WriteToBuffer( bf_write &buffer );	\
+		const char		*ToString() const;					\
+		int				GetType() const { return msgtype; } \
+		const char		*GetName() const { return #msgtype;}\
+			
+#define DECLARE_NET_MESSAGE( name )			\
+	DECLARE_BASE_MESSAGE( net_##name );		\
+	INetMessageHandler *m_pMessageHandler;	\
+	bool Process() { return m_pMessageHandler->Process##name( this ); }\
+	
+#define DECLARE_SVC_MESSAGE( name )		\
+	DECLARE_BASE_MESSAGE( svc_##name );	\
+	IServerMessageHandler *m_pMessageHandler;\
+	bool Process() { return m_pMessageHandler->Process##name( this ); }\
+	
+#define DECLARE_CLC_MESSAGE( name )		\
+	DECLARE_BASE_MESSAGE( clc_##name );	\
+	IClientMessageHandler *m_pMessageHandler;\
+	bool Process() { return m_pMessageHandler->Process##name( this ); }\
+		
+#define DECLARE_MM_MESSAGE( name )		\
+	DECLARE_BASE_MESSAGE( mm_##name );	\
+	IMatchmakingMessageHandler *m_pMessageHandler;\
+	bool Process() { return m_pMessageHandler->Process##name( this ); }\
+
+class CNetMessage : public INetMessage
+{
+public:
+	CNetMessage() {	m_bReliable = true;
+					m_NetChannel = NULL; }
+
+	virtual ~CNetMessage() {};
+
+	virtual int		GetGroup() const { return INetChannelInfo::GENERIC; }
+	INetChannel		*GetNetChannel() const { return m_NetChannel; }
+		
+	virtual void	SetReliable( bool state) {m_bReliable = state;};
+	virtual bool	IsReliable() const { return m_bReliable; };
+	virtual void    SetNetChannel(INetChannel * netchan) { m_NetChannel = netchan; }	
+	virtual bool	Process() { Assert( 0 ); return false; };	// no handler set
+
+protected:
+	bool				m_bReliable;	// true if message should be send reliable
+	INetChannel			*m_NetChannel;	// netchannel this message is from/for
+};
+
+
+///////////////////////////////////////////////////////////////////////////////////////
+// bidirectional net messages:
+///////////////////////////////////////////////////////////////////////////////////////
+
+
+class NET_SetConVar : public CNetMessage
+{
+	DECLARE_NET_MESSAGE( SetConVar );
+
+	int	GetGroup() const { return INetChannelInfo::STRINGCMD; }
+
+	NET_SetConVar() {}
+	NET_SetConVar( const char * name, const char * value)
+	{
+		cvar_t localCvar;
+		Q_strncpy( localCvar.name, name, MAX_OSPATH );
+		Q_strncpy( localCvar.value, value, MAX_OSPATH );
+		m_ConVars.AddToTail( localCvar );	
+	}
+
+public:	
+	
+	typedef struct cvar_s
+	{
+		char	name[MAX_OSPATH];
+		char	value[MAX_OSPATH];
+	} cvar_t;
+
+	CUtlVector<cvar_t> m_ConVars;
+};
+
+class NET_StringCmd : public CNetMessage
+{
+	DECLARE_NET_MESSAGE( StringCmd );
+
+	int	GetGroup() const { return INetChannelInfo::STRINGCMD; }
+
+	NET_StringCmd() { m_szCommand = NULL; };
+	NET_StringCmd(const char *cmd) { m_szCommand = cmd; };
+
+public:	
+	const char	*m_szCommand;	// execute this command
+	
+private:
+	char		m_szCommandBuffer[1024];	// buffer for received messages
+	
+};
+
+class NET_Tick : public CNetMessage
+{
+	DECLARE_NET_MESSAGE( Tick );
+
+	NET_Tick() 
+	{ 
+		m_bReliable = false; 
+#if PROTOCOL_VERSION > 10
+		m_flHostFrameTime				= 0;
+		m_flHostFrameTimeStdDeviation	= 0;
+#endif
+	};
+
+	NET_Tick( int tick, float hostFrametime, float hostFrametime_stddeviation ) 
+	{ 
+		m_bReliable = false; 
+		m_nTick = tick; 
+#if PROTOCOL_VERSION > 10
+		m_flHostFrameTime			= hostFrametime;
+		m_flHostFrameTimeStdDeviation	= hostFrametime_stddeviation;
+#else
+		NOTE_UNUSED( hostFrametime );
+		NOTE_UNUSED( hostFrametime_stddeviation );
+#endif
+	};
+	
+public:
+	int			m_nTick; 
+#if PROTOCOL_VERSION > 10
+	float		m_flHostFrameTime;
+	float		m_flHostFrameTimeStdDeviation;
+#endif
+};
+
+class NET_SignonState : public CNetMessage
+{
+	DECLARE_NET_MESSAGE( SignonState );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+
+	NET_SignonState() {};
+	NET_SignonState( int state, int spawncount ) { m_nSignonState = state; m_nSpawnCount = spawncount; };
+
+public:
+	int			m_nSignonState;			// See SIGNONSTATE_ defines
+	int			m_nSpawnCount;			// server spawn count (session number)
+};
+
+
+///////////////////////////////////////////////////////////////////////////////////////
+// Client messages:
+///////////////////////////////////////////////////////////////////////////////////////
+
+class CLC_ClientInfo : public CNetMessage
+{
+	DECLARE_CLC_MESSAGE( ClientInfo );
+
+public:
+	CRC32_t			m_nSendTableCRC;
+	int				m_nServerCount;
+	bool			m_bIsHLTV;
+#if defined( REPLAY_ENABLED )
+	bool			m_bIsReplay;
+#endif
+	uint32			m_nFriendsID;
+	char			m_FriendsName[MAX_PLAYER_NAME_LENGTH];
+	CRC32_t			m_nCustomFiles[MAX_CUSTOM_FILES];
+};
+
+
+
+class CLC_Move : public CNetMessage
+{
+	DECLARE_CLC_MESSAGE( Move );
+
+	int	GetGroup() const { return INetChannelInfo::MOVE; }
+
+	CLC_Move() { m_bReliable = false; }
+
+public:
+	int				m_nBackupCommands;
+	int				m_nNewCommands;
+	int				m_nLength;
+	bf_read			m_DataIn;
+	bf_write		m_DataOut;
+};
+
+class CLC_VoiceData : public CNetMessage
+{
+	DECLARE_CLC_MESSAGE( VoiceData );
+
+	int	GetGroup() const { return INetChannelInfo::VOICE; }
+
+	CLC_VoiceData() { m_bReliable = false; };
+
+public:
+	int				m_nLength;
+	bf_read			m_DataIn;
+	bf_write		m_DataOut;
+	uint64			m_xuid;
+};
+
+class CLC_BaselineAck : public CNetMessage
+{
+	DECLARE_CLC_MESSAGE( BaselineAck );
+
+	CLC_BaselineAck() {};
+	CLC_BaselineAck(int tick, int baseline ) { m_nBaselineTick = tick; m_nBaselineNr = baseline; }
+
+	int	GetGroup() const { return INetChannelInfo::ENTITIES; }
+
+public:
+	int		m_nBaselineTick;	// sequence number of baseline
+	int		m_nBaselineNr;		// 0 or 1 		
+};
+
+class CLC_ListenEvents : public CNetMessage
+{
+	DECLARE_CLC_MESSAGE( ListenEvents );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+
+public:
+	CBitVec<MAX_EVENT_NUMBER> m_EventArray;
+};
+
+#if defined( REPLAY_ENABLED )
+class CLC_SaveReplay : public CNetMessage
+{
+	DECLARE_CLC_MESSAGE( SaveReplay );
+
+	CLC_SaveReplay() {}
+
+	int		m_nStartSendByte;
+	char	m_szFilename[ MAX_OSPATH ];
+	float	m_flPostDeathRecordTime;
+};
+#endif
+
+class CLC_RespondCvarValue : public CNetMessage
+{
+public:
+	DECLARE_CLC_MESSAGE( RespondCvarValue );
+
+	QueryCvarCookie_t		m_iCookie;
+	
+	const char				*m_szCvarName;
+	const char				*m_szCvarValue;	// The sender sets this, and it automatically points it at m_szCvarNameBuffer when receiving.
+
+	EQueryCvarValueStatus	m_eStatusCode;
+
+private:
+	char		m_szCvarNameBuffer[256];
+	char		m_szCvarValueBuffer[256];
+};
+
+class CLC_FileCRCCheck : public CNetMessage
+{
+public:
+	DECLARE_CLC_MESSAGE( FileCRCCheck );
+	char		m_szPathID[MAX_PATH];
+	char		m_szFilename[MAX_PATH];
+	MD5Value_t	m_MD5;
+	CRC32_t		m_CRCIOs;
+	int			m_eFileHashType;
+	int			m_cbFileLen;
+	int			m_nPackFileNumber;
+	int			m_PackFileID;
+	int			m_nFileFraction;
+};
+
+class CLC_FileMD5Check : public CNetMessage
+{
+public:
+	DECLARE_CLC_MESSAGE( FileMD5Check );
+
+	char		m_szPathID[MAX_PATH];
+	char		m_szFilename[MAX_PATH];
+	MD5Value_t	m_MD5;
+};
+
+class Base_CmdKeyValues : public CNetMessage
+{
+protected:
+	explicit Base_CmdKeyValues( KeyValues *pKeyValues = NULL ); // takes ownership
+	~Base_CmdKeyValues();
+
+public:
+	KeyValues * GetKeyValues() const { return m_pKeyValues; }
+
+public:
+	bool ReadFromBuffer( bf_read &buffer );
+	bool WriteToBuffer( bf_write &buffer );
+	const char * ToString() const;
+
+protected:
+	KeyValues *m_pKeyValues;
+};
+
+class CLC_CmdKeyValues : public Base_CmdKeyValues
+{
+public:
+	DECLARE_CLC_MESSAGE( CmdKeyValues );
+
+public:
+	explicit CLC_CmdKeyValues( KeyValues *pKeyValues = NULL );	// takes ownership
+};
+
+class SVC_CmdKeyValues : public Base_CmdKeyValues
+{
+public:
+	DECLARE_SVC_MESSAGE( CmdKeyValues );
+
+public:
+	explicit SVC_CmdKeyValues( KeyValues *pKeyValues = NULL );	// takes ownership
+};
+
+///////////////////////////////////////////////////////////////////////////////////////
+// server messages:
+///////////////////////////////////////////////////////////////////////////////////////
+
+
+
+class SVC_Print : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( Print );
+
+	SVC_Print() { m_bReliable = false; m_szText = NULL; };
+
+	SVC_Print(const char * text) { m_bReliable = false; m_szText = text; };
+
+public:	
+	const char	*m_szText;	// show this text
+	
+private:
+	char		m_szTextBuffer[2048];	// buffer for received messages
+};
+
+class SVC_ServerInfo : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( ServerInfo );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+
+public:	// member vars are public for faster handling
+	int			m_nProtocol;	// protocol version
+	int			m_nServerCount;	// number of changelevels since server start
+	bool		m_bIsDedicated;  // dedicated server ?	
+	bool		m_bIsHLTV;		// HLTV server ?
+#if defined( REPLAY_ENABLED )
+	bool		m_bIsReplay;	// Replay server ?
+#endif
+	char		m_cOS;			// L = linux, W = Win32
+	CRC32_t		m_nMapCRC;		// server map CRC (only used by older demos)
+	MD5Value_t	m_nMapMD5;		// server map MD5
+	int			m_nMaxClients;	// max number of clients on server
+	int			m_nMaxClasses;	// max number of server classes
+	int			m_nPlayerSlot;	// our client slot number
+	float		m_fTickInterval;// server tick interval
+	const char	*m_szGameDir;	// game directory eg "tf2"
+	const char	*m_szMapName;	// name of current map 
+	const char	*m_szSkyName;	// name of current skybox 
+	const char	*m_szHostName;	// server name
+
+private:
+	char		m_szGameDirBuffer[MAX_OSPATH];// game directory eg "tf2"
+	char		m_szMapNameBuffer[MAX_OSPATH];// name of current map 
+	char		m_szSkyNameBuffer[MAX_OSPATH];// name of current skybox 
+	char		m_szHostNameBuffer[MAX_OSPATH];// name of current skybox 
+};
+
+class SVC_SendTable : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( SendTable );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+		
+public:
+	bool			m_bNeedsDecoder;
+	int				m_nLength;
+	bf_read			m_DataIn;
+	bf_write		m_DataOut;
+};
+
+class SVC_ClassInfo : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( ClassInfo );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+
+	SVC_ClassInfo() {};
+	SVC_ClassInfo( bool createFromSendTables, int numClasses ) 
+		{ m_bCreateOnClient = createFromSendTables; 
+		  m_nNumServerClasses = numClasses; };
+
+public:
+		
+	typedef struct class_s
+	{
+		int		classID;
+		char	datatablename[256];
+		char	classname[256];
+	} class_t;
+
+	bool					m_bCreateOnClient;	// if true, client creates own SendTables & classinfos from game.dll
+	CUtlVector<class_t>		m_Classes;			
+	int						m_nNumServerClasses;
+};
+	
+
+class SVC_SetPause : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( SetPause );
+	
+	SVC_SetPause() {}
+	SVC_SetPause( bool state, float end = -1.f ) { m_bPaused = state; }
+	
+public:
+	bool		m_bPaused;		// true or false, what else
+};
+
+class SVC_SetPauseTimed : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( SetPauseTimed );
+
+	SVC_SetPauseTimed() {}
+	SVC_SetPauseTimed( bool bState, float flExpireTime = -1.f ) { m_bPaused = bState; m_flExpireTime = flExpireTime; }
+
+public:
+	bool		m_bPaused;
+	float		m_flExpireTime;
+};
+
+
+class CNetworkStringTable;
+
+class SVC_CreateStringTable : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( CreateStringTable );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+
+public:
+
+	SVC_CreateStringTable();
+
+public:	
+	
+	const char	*m_szTableName;
+	int			m_nMaxEntries;
+	int			m_nNumEntries;
+	bool		m_bUserDataFixedSize;
+	int			m_nUserDataSize;
+	int			m_nUserDataSizeBits;
+	bool		m_bIsFilenames;
+	int			m_nLength;
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+	bool		m_bDataCompressed;
+
+private:
+	char		m_szTableNameBuffer[256];
+};
+
+class SVC_UpdateStringTable : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( UpdateStringTable );
+
+	int	GetGroup() const { return INetChannelInfo::STRINGTABLE; }
+
+public:
+	int				m_nTableID;	// table to be updated
+	int				m_nChangedEntries; // number of how many entries has changed
+	int				m_nLength;	// data length in bits
+	bf_read			m_DataIn;
+	bf_write		m_DataOut;
+};
+
+// SVC_VoiceInit
+//   v2 - 2017/02/07
+//     - Can detect v2 packets by nLegacyQuality == 255 and presence of additional nSampleRate field.
+//     - Added nSampleRate field. Previously, nSampleRate was hard-coded per codec type. ::ReadFromBuffer does a
+//       one-time conversion of these old types (which can no longer change)
+//     - Marked quality field as deprecated. This was already being ignored. v2 clients send 255
+//     - Prior to this the sv_use_steam_voice convar was used to switch to steam voice. With this, we properly set
+//       szVoiceCodec to "steam".  See ::ReadFromBuffer for shim to fallback to the convar for old streams.
+//     - We no longer pass "svc_voiceinit NULL" as szVoiceCodec if it is not selected, just the empty string.  Nothing
+//       used this that I could find.
+class SVC_VoiceInit : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( VoiceInit );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+
+	SVC_VoiceInit()
+		: m_nSampleRate( 0 )
+	{
+		V_memset( m_szVoiceCodec, 0, sizeof( m_szVoiceCodec ) );
+	}
+
+	SVC_VoiceInit( const char * codec, int nSampleRate )
+		: m_nSampleRate( nSampleRate )
+	{
+		V_strncpy( m_szVoiceCodec, codec ? codec : "", sizeof( m_szVoiceCodec ) );
+	}
+
+
+public:
+	// Used voice codec for voice_init.
+	//
+	// This used to be a DLL name, then became a whitelisted list of codecs.
+	char		m_szVoiceCodec[MAX_OSPATH];
+
+	// DEPRECATED:
+	//
+	// This field used to be a custom quality setting, but it was not honored for a long time: codecs use their own
+	// pre-configured quality settings. We never sent anything besides 5, which was then ignored for some codecs.
+	//
+	// New clients always set 255 here, old clients probably send 5. This could be re-purposed in the future, but beware
+	// that very old demos may have non-5 values. It would take more archaeology to determine how to properly interpret
+	// those packets -- they're probably using settings we simply don't support any longer.
+	//
+	// int m_nQuality;
+
+	// The sample rate we are using
+	int			m_nSampleRate;
+};
+
+class SVC_VoiceData : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( VoiceData );
+
+	int	GetGroup() const { return INetChannelInfo::VOICE; }
+
+	SVC_VoiceData() { m_bReliable = false; }
+
+public:	
+	int				m_nFromClient;	// client who has spoken
+	bool			m_bProximity;
+	int				m_nLength;		// data length in bits
+	uint64			m_xuid;			// X360 player ID
+
+	bf_read			m_DataIn;
+	void			*m_DataOut;
+};
+
+class SVC_Sounds : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( Sounds );
+
+	int	GetGroup() const { return INetChannelInfo::SOUNDS; }
+
+public:	
+
+	bool		m_bReliableSound;
+	int			m_nNumSounds;
+	int			m_nLength;
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+class SVC_Prefetch : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( Prefetch );
+
+	int	GetGroup() const { return INetChannelInfo::SOUNDS; }
+
+	enum
+	{
+		SOUND = 0,
+	};
+
+public:	
+
+	unsigned short	m_fType;
+	unsigned short	m_nSoundIndex;
+};
+
+class SVC_SetView : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( SetView );
+
+	SVC_SetView() {}
+	SVC_SetView( int entity ) { m_nEntityIndex = entity; }
+
+public:	
+	int				m_nEntityIndex;
+		
+};
+
+class SVC_FixAngle: public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( FixAngle );
+
+	SVC_FixAngle() { m_bReliable = false; };
+	SVC_FixAngle( bool bRelative, QAngle angle ) 
+		{ m_bReliable = false; m_bRelative = bRelative; m_Angle = angle; }
+
+public:	
+	bool			m_bRelative; 
+	QAngle			m_Angle;
+};
+
+class SVC_CrosshairAngle : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( CrosshairAngle );
+
+	SVC_CrosshairAngle() {}
+	SVC_CrosshairAngle( QAngle angle ) { m_Angle = angle; }
+	
+public:
+	QAngle			m_Angle;
+};
+
+class SVC_BSPDecal : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( BSPDecal );
+	
+public:
+	Vector		m_Pos;
+	int			m_nDecalTextureIndex;
+	int			m_nEntityIndex;
+	int			m_nModelIndex;
+	bool		m_bLowPriority;
+};
+
+class SVC_GameEvent : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( GameEvent );
+
+	int	GetGroup() const { return INetChannelInfo::EVENTS; }
+	
+public:
+	int			m_nLength;	// data length in bits
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+class SVC_UserMessage: public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( UserMessage );
+
+	SVC_UserMessage() { m_bReliable = false; }
+
+	int	GetGroup() const { return INetChannelInfo::USERMESSAGES; }
+	
+public:
+	int			m_nMsgType;
+	int			m_nLength;	// data length in bits
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+class SVC_EntityMessage : public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( EntityMessage );
+
+	SVC_EntityMessage() { m_bReliable = false; }
+
+	int	GetGroup() const { return INetChannelInfo::ENTMESSAGES	; }
+
+public:
+	int			m_nEntityIndex;
+	int			m_nClassID;
+	int			m_nLength;	// data length in bits
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+/* class SVC_SpawnBaseline: public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( SpawnBaseline );
+
+	int	GetGroup() const { return INetChannelInfo::SIGNON; }
+	
+public:
+	int			m_nEntityIndex;
+	int			m_nClassID;
+	int			m_nLength;
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+	
+}; */
+
+class SVC_PacketEntities: public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( PacketEntities );
+	
+	int	GetGroup() const { return INetChannelInfo::ENTITIES	; }
+	
+public:
+
+	int			m_nMaxEntries;
+	int			m_nUpdatedEntries;
+	bool		m_bIsDelta;	
+	bool		m_bUpdateBaseline;
+	int			m_nBaseline;
+	int			m_nDeltaFrom;
+	int			m_nLength;
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+class SVC_TempEntities: public CNetMessage
+{
+	DECLARE_SVC_MESSAGE( TempEntities );
+
+	SVC_TempEntities() { m_bReliable = false; }
+
+	int	GetGroup() const { return INetChannelInfo::EVENTS; }
+
+	int			m_nNumEntries;
+	int			m_nLength;
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+class SVC_Menu : public CNetMessage
+{
+public:
+	DECLARE_SVC_MESSAGE( Menu );
+
+	SVC_Menu() { m_bReliable = true; m_Type = DIALOG_MENU; m_MenuKeyValues = NULL; };
+	SVC_Menu( DIALOG_TYPE type, KeyValues *data ); 
+	~SVC_Menu();
+
+	KeyValues	*m_MenuKeyValues;
+	DIALOG_TYPE m_Type;
+	int			m_iLength;
+};
+
+class SVC_GameEventList : public CNetMessage
+{
+public:
+	DECLARE_SVC_MESSAGE( GameEventList );
+
+	int			m_nNumEvents;
+	int			m_nLength;
+	bf_read		m_DataIn;
+	bf_write	m_DataOut;
+};
+
+///////////////////////////////////////////////////////////////////////////////////////
+// Matchmaking messages:
+///////////////////////////////////////////////////////////////////////////////////////
+
+class MM_Heartbeat : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( Heartbeat );
+};
+
+class MM_ClientInfo : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( ClientInfo );
+
+	XNADDR	m_xnaddr;	// xbox net address
+	uint64	m_id;		// machine ID
+	uint64	m_xuids[MAX_PLAYERS_PER_CLIENT];
+	byte	m_cVoiceState[MAX_PLAYERS_PER_CLIENT];
+	bool	m_bInvited;
+	char	m_cPlayers;
+	char	m_iControllers[MAX_PLAYERS_PER_CLIENT];
+	char	m_iTeam[MAX_PLAYERS_PER_CLIENT];
+	char	m_szGamertags[MAX_PLAYERS_PER_CLIENT][MAX_PLAYER_NAME_LENGTH];
+};
+
+class MM_RegisterResponse : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( RegisterResponse );
+};
+
+class MM_Mutelist : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( Mutelist );
+
+	uint64	m_id;
+	byte	m_cPlayers;
+	byte	m_cRemoteTalkers[MAX_PLAYERS_PER_CLIENT];
+	XUID	m_xuid[MAX_PLAYERS_PER_CLIENT];
+	byte	m_cMuted[MAX_PLAYERS_PER_CLIENT];
+	CUtlVector< XUID >	m_Muted[MAX_PLAYERS_PER_CLIENT];
+};
+
+class MM_Checkpoint : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( Checkpoint );
+
+	enum eCheckpoint
+	{
+		CHECKPOINT_CHANGETEAM,
+		CHECKPOINT_GAME_LOBBY,
+		CHECKPOINT_PREGAME,
+		CHECKPOINT_LOADING_COMPLETE,
+		CHECKPOINT_CONNECT,
+		CHECKPOINT_SESSION_DISCONNECT,
+		CHECKPOINT_REPORT_STATS,
+		CHECKPOINT_REPORTING_COMPLETE,
+		CHECKPOINT_POSTGAME,
+	};
+
+	byte m_Checkpoint;
+};
+
+// NOTE: The following messages are not network-endian compliant, due to the
+// transmission of structures instead of their component parts
+class MM_JoinResponse : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( JoinResponse );
+
+	MM_JoinResponse()
+	{
+		m_ContextCount = 0;
+		m_PropertyCount = 0;
+	}
+
+	enum
+	{
+		JOINRESPONSE_APPROVED,
+		JOINRESPONSE_APPROVED_JOINGAME,
+		JOINRESPONSE_SESSIONFULL,
+		JOINRESPONSE_NOTHOSTING,
+		JOINRESPONSE_MODIFY_SESSION,
+	};
+	uint	m_ResponseType;
+
+	// host info
+	uint64	m_id;				// Host's machine ID
+	uint64	m_Nonce;			// Session nonce
+	uint	m_SessionFlags;
+	uint	m_nOwnerId;
+	int		m_iTeam;
+	int		m_nTotalTeams;
+	int		m_PropertyCount;
+	int		m_ContextCount;
+	CUtlVector< XUSER_PROPERTY >m_SessionProperties;
+	CUtlVector< XUSER_CONTEXT >m_SessionContexts;
+};
+
+class MM_Migrate : public CNetMessage
+{
+public:
+	DECLARE_MM_MESSAGE( Migrate );
+
+	enum eMsgType
+	{
+		MESSAGE_HOSTING,
+		MESSAGE_MIGRATED,
+		MESSAGE_STANDBY,
+	};
+
+	byte	m_MsgType;
+	uint64	m_Id;
+	XNKID	m_sessionId; 
+	XNADDR	m_xnaddr;  
+	XNKEY	m_key;
+};
+
+class SVC_GetCvarValue : public CNetMessage
+{
+public:
+	DECLARE_SVC_MESSAGE( GetCvarValue );
+
+	QueryCvarCookie_t	m_iCookie;
+	const char			*m_szCvarName;	// The sender sets this, and it automatically points it at m_szCvarNameBuffer when receiving.
+
+private:
+	char		m_szCvarNameBuffer[256];
+};
+
+#endif // NETMESSAGES_H