1HEADmaster

1 files changed, 993 insertions, 0 deletions

diff --git a/engine/matchmakingclient.cpp b/engine/matchmakingclient.cpp
new file mode 100644
index 0000000..907f1eb
--- /dev/null
+++ b/engine/matchmakingclient.cpp
@@ -0,0 +1,993 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Handles joining clients together in a matchmaking session before a multiplayer
+//			game, tracking new players and dropped players during the game, and reporting
+//			game results and stats after the game is complete.
+//
+//=============================================================================//
+
+#include "proto_oob.h"
+#include "vgui_baseui_interface.h"
+#include "cdll_engine_int.h"
+#include "matchmaking.h"
+#include "Session.h"
+#include "convar.h"
+#include "cmd.h"
+
+extern IVEngineClient *engineClient;
+
+// TODO: remove when UI sets all properties
+#include "hl2orange.spa.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+extern IXboxSystem *g_pXboxSystem;
+
+//-----------------------------------------------------------------------------
+// Purpose: Start a matchmaking client 
+//-----------------------------------------------------------------------------
+void CMatchmaking::StartClient( bool bSystemLink )
+{
+	NET_SetMutiplayer( true );
+
+	InitializeLocalClient( false );
+
+	m_Session.SetIsSystemLink( bSystemLink );
+
+	// SearchForSession is an async call
+	if ( !SearchForSession() )
+	{
+		// The call failed
+		SessionNotification( SESSION_NOTIFY_FAIL_CREATE );
+		return;
+	}
+
+	// Session search is underway
+	SwitchToState( MMSTATE_SEARCHING );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Set up to search for a system link host
+//-----------------------------------------------------------------------------
+bool CMatchmaking::StartSystemLinkSearch()
+{
+	// Create an random identifier and reset the send timer
+#if defined( _X360 )
+	XNetRandom( (byte*)&m_Nonce, sizeof( m_Nonce ) );
+#endif
+	m_fSendTimer = GetTime();
+	m_nSendCount = 0;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle replies from system link servers
+//-----------------------------------------------------------------------------
+void CMatchmaking::HandleSystemLinkReply( netpacket_t *pPacket )
+{
+	if ( !m_Session.IsSystemLink() || m_Session.IsHost() )
+		return;
+
+	uint64 nonce = pPacket->message.ReadLongLong();
+
+	if ( nonce != m_Nonce )
+	{
+		// Reply isn't a response to our request
+		return;
+	}
+
+	// Store the session information
+	bf_read &msg = pPacket->message;
+
+	char *pData = new char[MAX_ROUTABLE_PAYLOAD];
+
+	systemLinkInfo_s *pResultInfo = (systemLinkInfo_s*)pData;
+	XSESSION_SEARCHRESULT *pResult = &pResultInfo->Result;
+
+	msg.ReadBytes( &pResult->info, sizeof( pResult->info ) );
+
+	// Don't accept multiple replies from the same host
+	for ( int i = 0; i < m_pSystemLinkResults.Count(); ++i )
+	{
+		XSESSION_SEARCHRESULT *pCheck = &((systemLinkInfo_s*)m_pSystemLinkResults[i])->Result;
+		if ( Q_memcmp( &pCheck->info.sessionID, &pResult->info.sessionID, sizeof( pResult->info.sessionID ) ) == 0 )
+		{
+			// Already have this session
+			delete [] pData;
+			return;
+		}
+	}
+
+	pResult->dwOpenPublicSlots		= msg.ReadByte();
+	pResult->dwOpenPrivateSlots		= msg.ReadByte();
+	pResult->dwFilledPublicSlots	= msg.ReadByte();
+	pResult->dwFilledPrivateSlots	= msg.ReadByte();
+
+	m_nTotalTeams					= msg.ReadByte();
+	pResultInfo->gameState			= msg.ReadByte();
+	pResultInfo->gameTime			= msg.ReadByte();
+	msg.ReadBytes( &pResultInfo->szHostName, MAX_PLAYER_NAME_LENGTH );
+	msg.ReadBytes( &pResultInfo->szScenario, MAX_MAP_NAME );
+
+	pResult->cProperties			= msg.ReadByte();
+	pResult->cContexts				= msg.ReadByte();
+	const uint propSize = pResult->cProperties * sizeof( XUSER_PROPERTY );
+	const uint ctxSize = pResult->cContexts * sizeof( XUSER_CONTEXT );
+
+	pResult->pProperties = (XUSER_PROPERTY*)( (byte*)pResult + sizeof( XSESSION_SEARCHRESULT ) );
+	pResult->pContexts	 = (XUSER_CONTEXT*)( (byte*)pResult->pProperties + propSize );
+
+	msg.ReadBytes( pResult->pProperties, propSize );
+	msg.ReadBytes( pResult->pContexts, ctxSize);
+
+	pResultInfo->iScenarioIndex = msg.ReadByte();
+	pResultInfo->xuid = msg.ReadLongLong();
+
+	m_pSystemLinkResults.AddToTail( pData );
+
+	Msg( "Found a matching game\n" );
+	DevMsg( "Result #%d: %d open public, %d open private\n", m_pSystemLinkResults.Count()-1, pResult->dwOpenPublicSlots, pResult->dwOpenPrivateSlots );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Search for a session to join 
+//-----------------------------------------------------------------------------
+bool CMatchmaking::SearchForSession()
+{
+	if ( m_Session.IsSystemLink() )
+	{
+		return StartSystemLinkSearch();
+	}
+
+	m_pSearchResults = NULL;
+	uint cbResultsBytes = 0;
+	uint ret = 0;
+
+	// Call once to get the necessary buffer size
+	ret = g_pXboxSystem->SessionSearch( 
+		SESSION_MATCH_QUERY_PLAYER_MATCH,
+		XBX_GetPrimaryUserId(),
+		MAX_SEARCHRESULTS,
+		1,
+		0,
+		0,
+		NULL,
+		NULL,
+		&cbResultsBytes,	// must be 0
+		m_pSearchResults,			// must be NULL
+		false						// synchronous
+		);
+
+	m_hSearchHandle = g_pXboxSystem->CreateAsyncHandle();
+
+	// Allocate the buffer and call again
+	m_pSearchResults = (XSESSION_SEARCHRESULT_HEADER*)malloc( cbResultsBytes );
+	ret = g_pXboxSystem->SessionSearch( 
+		SESSION_MATCH_QUERY_PLAYER_MATCH,	// Procedure index
+		XBX_GetPrimaryUserId(),				// User index
+		MAX_SEARCHRESULTS,					// Maximum results
+		m_Local.m_cPlayers,					// Number of local players
+ 		m_SessionProperties.Count(),		// Number of properties
+ 		m_SessionContexts.Count(),			// Number of contexts
+		m_SessionProperties.Base(),			// Properties
+ 		m_SessionContexts.Base(),			// Contexts
+		&cbResultsBytes,					// Size of result buffer
+		m_pSearchResults,					// Pointer to results
+		true,
+		&m_hSearchHandle
+		);
+
+	if ( ret != ERROR_IO_PENDING )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check for session search results
+//-----------------------------------------------------------------------------
+void CMatchmaking::UpdateSearch()
+{
+	if ( !m_Session.IsSystemLink() )
+	{
+		// Check if the search has finished
+		DWORD ret = g_pXboxSystem->GetOverlappedResult( m_hSearchHandle, NULL, false );
+		if ( ret == ERROR_IO_INCOMPLETE )
+		{
+			// Still waiting
+			return;
+		}
+		else
+		{
+			if ( ret == ERROR_SUCCESS && m_pSearchResults && m_pSearchResults->dwSearchResults )
+			{
+				// A list of matching sessions was found.
+				Msg( "Found %d matching games\n", m_pSearchResults->dwSearchResults );
+#if defined( _X360 )
+				for ( unsigned int i = 0; i < m_pSearchResults->dwSearchResults; ++i )
+				{
+					m_QoSxnaddr[i] = &(m_pSearchResults->pResults[i].info.hostAddress);
+					m_QoSxnkid[i] = &(m_pSearchResults->pResults[i].info.sessionID);
+					m_QoSxnkey[i] = &(m_pSearchResults->pResults[i].info.keyExchangeKey);
+				}
+
+				//
+				// Note: XNetQosLookup requires only 2 successful probes to be received from the host.
+				// This is much less than the recommended 8 probes because on a 10% data loss profile
+				// it is impossible to find the host when requiring 8 probes to be received.
+				XNetQosLookup(  m_pSearchResults->dwSearchResults, 
+								m_QoSxnaddr,
+								m_QoSxnkid, 
+								m_QoSxnkey, 
+								0,				// number of security gateways to probe
+								NULL,			// gateway ip addresses
+								NULL,			// gateway service ids
+								2,				// number of probes
+								0,				// upstream bandwith to use (0 = default)
+								0,				// flags - not supported
+								NULL,			// signal event
+								&m_pQoSResult );// results
+#endif
+				SwitchToState( MMSTATE_WAITING_QOS );
+			}
+			else
+			{
+				SessionNotification( SESSION_NOTIFY_FAIL_SEARCH );
+			}
+
+			g_pXboxSystem->ReleaseAsyncHandle( m_hSearchHandle );
+		}
+	}
+	else
+	{
+		if ( GetTime() - m_fSendTimer > SYSTEMLINK_RETRYINTERVAL && m_nSendCount < SYSTEMLINK_MAXRETRIES )
+		{
+			// Send out a search for lan servers
+			ALIGN4 char	 msg_buffer[MAX_ROUTABLE_PAYLOAD] ALIGN4_POST;
+			bf_write msg( msg_buffer, sizeof(msg_buffer) );
+
+			msg.WriteLong( CONNECTIONLESS_HEADER );
+			msg.WriteByte( PTH_SYSTEMLINK_SEARCH );
+			msg.WriteLongLong( m_Nonce );		// 64 bit
+
+			// Send message
+			netadr_t adr;
+			adr.SetType( NA_BROADCAST );
+			adr.SetPort( PORT_SYSTEMLINK );
+
+			NET_SendPacket( NULL, NS_SYSTEMLINK, adr, msg.GetData(), msg.GetNumBytesWritten() );
+
+			m_fSendTimer = GetTime();
+			++m_nSendCount;
+		}
+		else if ( m_nSendCount >= SYSTEMLINK_MAXRETRIES )
+		{
+			if ( m_pSystemLinkResults.Count() )
+			{
+				SessionNotification( SESSION_NOTIFY_SEARCH_COMPLETED );
+
+				// Send the session info to gameui
+				for ( int i = 0; i < m_pSystemLinkResults.Count(); ++i )
+				{
+					systemLinkInfo_s *pSearchInfo = (systemLinkInfo_s*)m_pSystemLinkResults[i];
+					XSESSION_SEARCHRESULT *pResult = &pSearchInfo->Result;
+					
+					hostData_s hostData;
+					hostData.gameState = pSearchInfo->gameState;
+					hostData.gameTime = pSearchInfo->gameTime;
+					hostData.xuid = pSearchInfo->xuid;
+					Q_strncpy( hostData.hostName, pSearchInfo->szHostName, sizeof( hostData.hostName ) );
+					Q_strncpy( hostData.scenario, pSearchInfo->szScenario, sizeof( hostData.scenario ) );
+
+					EngineVGui()->SessionSearchResult( i, &hostData, pResult, -1 );
+				}
+			}
+			else
+			{
+				SessionNotification( SESSION_NOTIFY_FAIL_SEARCH );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check for QOS Results
+//-----------------------------------------------------------------------------
+void CMatchmaking::UpdateQosLookup()
+{
+#if defined( _X360 )
+	// Keep checking for results until the wait time expires
+	if ( GetTime() - m_fWaitTimer < QOSLOOKUP_WAITTIME )
+	{
+		for ( uint i = 0; i < m_pSearchResults->dwSearchResults; ++i )
+		{
+			if ( (m_pQoSResult->axnqosinfo[0].bFlags & XNET_XNQOSINFO_COMPLETE) == 0 )
+				return;
+		}
+	}
+
+	bool bNotifiedGameUI = false;
+	for ( unsigned int i = 0; i < m_pSearchResults->dwSearchResults; ++i )
+	{
+		// Make sure the host is available
+		if ( !(m_pQoSResult->axnqosinfo[i].bFlags & XNET_XNQOSINFO_TARGET_CONTACTED) )
+		{
+			DevMsg( "Result #%d: Host unreachable (!XNET_XNQOSINFO_TARGET_CONTACTED)\n", i );
+			continue;
+		}
+		else if ( (m_pQoSResult->axnqosinfo[i].bFlags & XNET_XNQOSINFO_TARGET_DISABLED) )
+		{
+			DevMsg( "Result #%d: Host disabled (XNET_XNQOSINFO_TARGET_DISABLED)\n", i );
+			continue;
+		}
+		else if ( !(m_pQoSResult->axnqosinfo[i].bFlags & XNET_XNQOSINFO_DATA_RECEIVED) ||
+				  !m_pQoSResult->axnqosinfo[i].cbData ||
+				  !m_pQoSResult->axnqosinfo[i].pbData )
+		{
+			DevMsg( "Result #%d: No data received (!XNET_XNQOSINFO_DATA_RECEIVED)\n", i );
+			continue;
+		}
+
+
+		// Check the ping before we accept this host
+		// unsigned short ping = m_pQoSResult->axnqosinfo[i].wRttMedInMsecs;
+		unsigned short ping = m_pQoSResult->axnqosinfo[i].wRttMinInMsecs;	// Use min ping to suit better for traffic bursts and lossy connections
+		DevMsg( "Result #%d: ping min %d ms, med %d ms\n", i, m_pQoSResult->axnqosinfo[i].wRttMinInMsecs, m_pQoSResult->axnqosinfo[i].wRttMedInMsecs );
+		
+		// On X360 ping calculations are reported between 4 and 5 times bigger
+		// than the actual upstream/downstream latency of the connection to Xbox LIVE
+		const int pingFactor = 5;
+		ping /= pingFactor;
+
+		if ( ping > PING_MAX_RED )
+		{
+			DevMsg( "Result #%d: Host connection too slow, ignoring\n", i );
+			continue;
+		}
+
+		// Determine the QOS quality to show to user
+		int pingDisplayedToUserIcon = -1;
+		if ( ping <= PING_MAX_GREEN )
+		{
+			pingDisplayedToUserIcon = 0;
+		}
+		else if ( ping <= PING_MAX_YELLOW )
+		{
+			pingDisplayedToUserIcon = 1;
+		}
+		else if ( ping <= PING_MAX_RED )
+		{
+			pingDisplayedToUserIcon = 2;
+		}
+
+		// Retrieve the search result
+		XSESSION_SEARCHRESULT &searchResult = m_pSearchResults->pResults[i];
+
+		// The host should have given us some game data
+		hostData_s hostData;
+		Q_memcpy( &hostData, m_pQoSResult->axnqosinfo[i].pbData, sizeof( hostData ) );
+
+		// This host is acceptable.  Get the info and notify gameUI
+		if ( !bNotifiedGameUI )
+		{
+			SessionNotification( SESSION_NOTIFY_SEARCH_COMPLETED );
+			bNotifiedGameUI = true;
+		}
+
+		// Send the host info to GameUI
+		EngineVGui()->SessionSearchResult( i, &hostData, &searchResult, pingDisplayedToUserIcon );
+		DevMsg( "Result #%d: %d open public slots, %d open private slots\n", i, searchResult.dwOpenPublicSlots, searchResult.dwOpenPrivateSlots );
+	}
+
+	if ( !bNotifiedGameUI )
+	{
+		SessionNotification( SESSION_NOTIFY_FAIL_SEARCH );
+	}
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cancel the current search operation
+//-----------------------------------------------------------------------------
+void CMatchmaking::CancelSearch()
+{
+	SwitchToState( MMSTATE_INITIAL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Cancel the current search operation
+//-----------------------------------------------------------------------------
+void CMatchmaking::CancelQosLookup()
+{
+#if defined( _X360 )
+	XNetQosRelease( m_pQoSResult );
+#endif
+	SwitchToState( MMSTATE_INITIAL );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: User has selected a session to join, create a local session with the same properties
+//-----------------------------------------------------------------------------
+void CMatchmaking::SelectSession( uint idx )
+{
+	XSESSION_SEARCHRESULT *pResult = NULL;
+	if ( m_Session.IsSystemLink() )
+	{
+		systemLinkInfo_s* pInfo = (systemLinkInfo_s*)m_pSystemLinkResults[idx];
+		pResult = &pInfo->Result;
+	}
+	else
+	{
+		pResult = &m_pSearchResults->pResults[idx];
+	}
+
+	if ( !pResult )
+		return;
+
+	m_Session.SetSessionInfo( &pResult->info );
+
+	ApplySessionProperties( pResult->cContexts, pResult->cProperties, pResult->pContexts, pResult->pProperties );
+
+	m_Session.SetIsHost( false );
+	m_Session.SetSessionSlots( SLOTS_TOTALPUBLIC, pResult->dwOpenPublicSlots + pResult->dwFilledPublicSlots );
+	m_Session.SetSessionSlots( SLOTS_TOTALPRIVATE, pResult->dwOpenPrivateSlots + pResult->dwFilledPrivateSlots );
+
+	if ( !m_Session.CreateSession() )
+	{
+		SessionNotification( SESSION_NOTIFY_FAIL_CREATE );
+		return;
+	}
+
+	// Waiting for session creation results
+	SwitchToState( MMSTATE_CREATING );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Join a session when invited to.
+//-----------------------------------------------------------------------------
+void CMatchmaking::JoinInviteSession( XSESSION_INFO *pHostInfo )
+{
+	if ( !pHostInfo )
+	{
+		Msg( "[JoinInviteSession] resetting.\n" );
+		InviteCancel();
+		return;
+	}
+
+	// Fetch our current session id
+	XNKID nSessionID = m_Session.GetSessionId();
+
+	// Check our invite state
+	switch ( m_InviteState )
+	{
+	case INVITE_NONE:
+		// Initial invite call
+		Msg( "[JoinInviteSession:INVITE_NONE] Initial call to join invite session.\n" );
+
+		// Don't bother if we're invited to join the same session
+		if ( !Q_memcmp( &(pHostInfo->sessionID), &(nSessionID), sizeof(nSessionID) ) )
+		{
+			Msg( "[JoinInviteSession:INVITE_NONE] Rejecting invite session since it is the current session.\n" );
+			return;
+		}
+
+		// Leave our current session, if we have one
+		KickPlayerFromSession( 0 );
+
+		if ( &m_InviteSessionInfo != pHostInfo )
+			memcpy( &m_InviteSessionInfo, pHostInfo, sizeof( XSESSION_INFO ) );
+
+		m_InviteState = INVITE_PENDING;
+
+		// If we are currently in progress of doing something, let it finish
+		if ( m_bInitialized )
+		{
+			if ( MMSTATE_INITIAL != m_CurrentState )
+			{
+				Msg( "[JoinInviteSession:INVITE_NONE] Yielding, current state = %d.\n", m_CurrentState );
+				return;
+			}
+		}
+		else
+		{
+			// We can be uninitialized due to the commentary mode - perform the disconnect to be sure
+			ConVarRef commentary( "commentary" );
+			if ( commentary.IsValid() && commentary.GetBool() )
+			{
+				Msg( "[JoinInviteSession:INVITE_NONE] Stopping commentary mode first.\n" );
+				engineClient->ClientCmd( "disconnect" );
+				Cbuf_Execute();
+				return;
+			}
+		}
+		// otherwise fall through to join
+
+	case INVITE_PENDING:
+		// While the invite is pending and user changed an invite, obey the user
+		if ( pHostInfo != &m_InviteSessionInfo )
+			memcpy( &m_InviteSessionInfo, pHostInfo, sizeof( XSESSION_INFO ) );
+
+		// Wait for the previous matchmaking session to finish and cleanup
+		if ( m_bInitialized && ( MMSTATE_INITIAL != m_CurrentState ) )
+		{
+			Msg( "[JoinInviteSession:INVITE_PENDING] Waiting, current state = %d.\n", m_CurrentState );
+			return;
+		}
+
+#if defined( _X360 )
+		// Switch into validating invite mode and do it right away
+		m_InviteState = INVITE_VALIDATING;
+		// fall through
+
+	case INVITE_VALIDATING:
+		// Validate user storage information
+		Msg( "[JoinInviteSession:INVITE_VALIDATING] Validating user storage before accepting invite.\n" );
+
+		//
+		// Configure and validate waiting info in case user will have to pick storage device
+		//
+		m_InviteWaitingInfo.m_InviteStorageDeviceSelected = 0;
+		m_InviteWaitingInfo.m_UserIdx = XBX_GetPrimaryUserId();
+		if ( m_InviteWaitingInfo.m_UserIdx == INVALID_USER_ID )
+		{
+			Msg( "[JoinInviteSession:INVITE_VALIDATING] Invalid user id, aborting.\n" );
+			InviteCancel();
+			return;
+		}
+
+		m_InviteWaitingInfo.m_SignInState = XUserGetSigninState( m_InviteWaitingInfo.m_UserIdx );
+		if ( ( m_InviteWaitingInfo.m_SignInState != eXUserSigninState_SignedInToLive ) ||
+			 ( ERROR_SUCCESS != XUserGetSigninInfo( m_InviteWaitingInfo.m_UserIdx, 0, &m_InviteWaitingInfo.m_SignInInfo ) ) ||
+			 ! ( m_InviteWaitingInfo.m_SignInInfo.dwInfoFlags & XUSER_INFO_FLAG_LIVE_ENABLED ) )
+		{
+			Msg( "[JoinInviteSession:INVITE_VALIDATING] Failed to get sign in to LIVE info, aborting.\n" );
+			InviteCancel();
+			return;
+		}
+
+		if ( ( ERROR_SUCCESS != XUserCheckPrivilege( m_InviteWaitingInfo.m_UserIdx, XPRIVILEGE_MULTIPLAYER_SESSIONS, &m_InviteWaitingInfo.m_PrivilegeMultiplayer ) ) ||
+			 ( !m_InviteWaitingInfo.m_PrivilegeMultiplayer ) )
+		{
+			Msg( "[JoinInviteSession:INVITE_VALIDATING] Privilege denied, aborting.\n" );
+			InviteCancel();
+			return;
+		}
+
+		//
+		// Enqueue the call to track storage device once it gets selected
+		//
+		if ( m_InviteWaitingInfo.m_bAcceptingInvite ||
+			EngineVGui()->ValidateStorageDevice( &m_InviteWaitingInfo.m_InviteStorageDeviceSelected ) )
+		{
+			m_InviteWaitingInfo.m_bAcceptingInvite = 0;
+			Msg( "[JoinInviteSession:INVITE_VALIDATING] Storage %s, accepting.\n", m_InviteWaitingInfo.m_bAcceptingInvite ? "already queried" : "valid" );
+			m_InviteState = INVITE_ACCEPTING;
+			// fall through
+		}
+		else
+		{
+			// User doesn't have a device selected and has to pick one
+			Msg( "[JoinInviteSession:INVITE_VALIDATING] Awaiting storage.\n" );
+			m_InviteState = INVITE_AWAITING_STORAGE;
+			return;
+		}
+#else
+		// Accept the invite right away
+		m_InviteState = INVITE_ACCEPTING;
+		// fall through
+#endif
+
+	case INVITE_ACCEPTING:
+		// Everything will finish this frame
+		Msg( "[JoinInviteSession:INVITE_ACCEPTING] Accepting the invite.\n" );
+		break;
+
+#if defined( _X360 )
+	case INVITE_AWAITING_STORAGE:
+		// Wait for user to select storage, but keep an eye on user change or logout or etc
+		{
+			InviteWaitingInfo_t InviteCurrentInfo;
+
+			InviteCurrentInfo.m_UserIdx = XBX_GetPrimaryUserId();
+			if ( InviteCurrentInfo.m_UserIdx != m_InviteWaitingInfo.m_UserIdx )
+			{
+				Msg( "[JoinInviteSession:INVITE_AWAITING_STORAGE] User index changed, aborting.\n" );
+				InviteCancel();
+				return;
+			}
+
+			InviteCurrentInfo.m_SignInState = XUserGetSigninState( InviteCurrentInfo.m_UserIdx );
+			if ( ( InviteCurrentInfo.m_SignInState != m_InviteWaitingInfo.m_SignInState ) ||
+				( ERROR_SUCCESS != XUserGetSigninInfo( InviteCurrentInfo.m_UserIdx, 0, &InviteCurrentInfo.m_SignInInfo ) ) ||
+				! ( InviteCurrentInfo.m_SignInInfo.dwInfoFlags & XUSER_INFO_FLAG_LIVE_ENABLED ) ||
+				!IsEqualXUID( InviteCurrentInfo.m_SignInInfo.xuid, m_InviteWaitingInfo.m_SignInInfo.xuid ) )
+			{
+				Msg( "[JoinInviteSession:INVITE_AWAITING_STORAGE] User xuid changed, aborting.\n" );
+				InviteCancel();
+				return;
+			}
+
+			if ( ( ERROR_SUCCESS != XUserCheckPrivilege( InviteCurrentInfo.m_UserIdx, XPRIVILEGE_MULTIPLAYER_SESSIONS, &InviteCurrentInfo.m_PrivilegeMultiplayer ) ) ||
+				( !InviteCurrentInfo.m_PrivilegeMultiplayer ) )
+			{
+				Msg( "[JoinInviteSession:INVITE_AWAITING_STORAGE] Privilege denied, aborting.\n" );
+				InviteCancel();
+				return;
+			}
+
+			// Check if we should keep waiting
+			switch ( m_InviteWaitingInfo.m_InviteStorageDeviceSelected )
+			{
+			case 0:
+				// Keep waiting
+				return;
+
+			case 1:
+				// Device selected, proceed
+				Msg( "[JoinInviteSession:INVITE_AWAITING_STORAGE] Device selected.\n" );
+				break;
+			case 2:
+				Msg( "[JoinInviteSession:INVITE_AWAITING_STORAGE] Device rejected.\n" );
+				// User opts to run with no storage device, proceed
+				break;
+
+			default:
+				// Device selection weird error
+				InviteCancel();
+				return;
+			}
+		}
+
+		// Otherwise user has selected the storage device, try to accept the invite once again
+		Msg( "[JoinInviteSession:INVITE_AWAITING_STORAGE] Accepting.\n" );
+		m_InviteWaitingInfo.m_bAcceptingInvite = 1;
+		m_InviteState = INVITE_NONE;
+		JoinInviteSession( pHostInfo );
+		return;
+#endif
+
+	default:
+		Msg( "[JoinInviteSession:UnknownState=%d] Aborting.\n", m_InviteState );
+		InviteCancel();
+		return;
+	}
+
+	// Initialize our state to accept the new connection
+	NET_SetMutiplayer( true );
+	InitializeLocalClient( false );
+
+	// Allow us to access private channels due to invite
+	m_Local.m_bInvited = true;
+
+#if defined( _X360 )
+	// "Spoof" certain information we don't yet know about the server, knowing that we'll modify it later once connected
+	m_Session.SetIsSystemLink( false );
+	m_Session.SetSessionInfo( pHostInfo );
+	m_Session.SetIsHost( false );
+	m_Session.SetContext( X_CONTEXT_GAME_TYPE, X_CONTEXT_GAME_TYPE_STANDARD, false );
+	m_Session.SetSessionFlags( XSESSION_CREATE_LIVE_MULTIPLAYER_STANDARD );
+	m_Session.SetSessionSlots( SLOTS_TOTALPUBLIC, 8 );
+	m_Session.SetSessionSlots( SLOTS_TOTALPRIVATE, 0 );
+	m_Session.SetSessionSlots( SLOTS_FILLEDPUBLIC, 0 );
+	m_Session.SetSessionSlots( SLOTS_FILLEDPRIVATE, 0 );
+#endif
+
+	// Create the session and kick off our UI
+	if ( !m_Session.CreateSession() )
+	{
+		SessionNotification( SESSION_NOTIFY_FAIL_CREATE );
+		return;
+	}
+
+	// Waiting for session creation results
+	SwitchToState( MMSTATE_CREATING );
+	InviteCancel();
+}
+
+void CMatchmaking::InviteCancel()
+{
+	m_InviteState = INVITE_NONE;
+	memset( &m_InviteWaitingInfo, 0, sizeof( m_InviteWaitingInfo ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Search for a session by ID and connect to it (done for cross-game invites)
+//-----------------------------------------------------------------------------
+void CMatchmaking::JoinInviteSessionByID( XNKID nSessionID )
+{
+#ifdef _X360
+	DWORD dwResultSize = 0;
+	XSESSION_SEARCHRESULT_HEADER *pSearchResults = NULL;
+
+	// Call this once to find the proper buffer size
+	DWORD dwError = XSessionSearchByID( nSessionID, XBX_GetPrimaryUserId(), &dwResultSize, pSearchResults, NULL );
+	if ( dwError != ERROR_INSUFFICIENT_BUFFER )
+		return;
+
+	// Create a buffer big enough to hold the requested information
+	pSearchResults = (XSESSION_SEARCHRESULT_HEADER *) new byte[dwResultSize];
+	ZeroMemory( pSearchResults, dwResultSize );
+
+	// Now get the real results
+	dwError = XSessionSearchByID( nSessionID, XBX_GetPrimaryUserId(), &dwResultSize, pSearchResults, NULL );
+	if ( dwError != ERROR_SUCCESS )
+	{
+		delete[] pSearchResults;
+		return;
+	}
+
+	// If we found something, connect to it
+	if ( pSearchResults->dwSearchResults > 0 )
+	{
+		JoinInviteSession( &(pSearchResults->pResults[0].info) );
+	}
+	else
+	{
+		SessionNotification( SESSION_NOTIFY_CONNECT_NOTAVAILABLE );
+	}
+
+	// Done
+	delete[] pSearchResults;
+#endif // _X360
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Tell a session host we'd like to join the session
+//-----------------------------------------------------------------------------
+void CMatchmaking::SendJoinRequest( netadr_t *adr )
+{
+	ALIGN4 char	 msg_buffer[MAX_ROUTABLE_PAYLOAD] ALIGN4_POST;
+	bf_write msg( msg_buffer, sizeof(msg_buffer) );
+
+	// Send local player info
+	msg.WriteLong( CONNECTIONLESS_HEADER );
+	msg.WriteByte( PTH_CONNECT );
+	msg.WriteLongLong( m_Local.m_id );		// 64 bit
+	msg.WriteByte( m_Local.m_cPlayers );
+	msg.WriteOneBit( m_Local.m_bInvited );
+	msg.WriteBytes( &m_Local.m_xnaddr, sizeof( m_Local.m_xnaddr ) );
+
+	for ( int i = 0; i < m_Local.m_cPlayers; ++i )
+	{
+		msg.WriteLongLong( m_Local.m_xuids[i] );	// 64 bit
+		msg.WriteBytes( &m_Local.m_cVoiceState, sizeof( m_Local.m_cVoiceState ) );	// TODO: has voice
+		msg.WriteString( m_Local.m_szGamertags[i] );
+	}
+
+	// Send message
+	NET_SendPacket( NULL, NS_MATCHMAKING, *adr, msg.GetData(), msg.GetNumBytesWritten() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Process the session host's response to our join request 
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ProcessJoinResponse( MM_JoinResponse *pMsg )
+{
+	switch( pMsg->m_ResponseType )
+	{
+	case MM_JoinResponse::JOINRESPONSE_NOTHOSTING:
+		if ( m_CurrentState != MMSTATE_SESSION_CONNECTING )
+		{
+			return true;
+		}
+		Msg( "This game is no longer available.\n" );
+		SessionNotification( SESSION_NOTIFY_CONNECT_NOTAVAILABLE );
+		break;
+
+	case MM_JoinResponse::JOINRESPONSE_SESSIONFULL:
+		if ( m_CurrentState != MMSTATE_SESSION_CONNECTING )
+		{
+			return true;
+		}
+		Msg( "This game is full.\n" );
+		SessionNotification( SESSION_NOTIFY_CONNECT_SESSIONFULL );
+		break;
+
+	case MM_JoinResponse::JOINRESPONSE_APPROVED:
+	case MM_JoinResponse::JOINRESPONSE_APPROVED_JOINGAME:
+		if ( m_CurrentState != MMSTATE_SESSION_CONNECTING )
+		{
+			return true;
+		}
+		// Fill in host data
+		m_Host.m_id = pMsg->m_id;					// 64 bit
+		m_Session.SetSessionNonce( pMsg->m_Nonce );	// 64 bit
+		m_Session.SetSessionFlags( pMsg->m_SessionFlags );
+		m_Session.SetOwnerId( pMsg->m_nOwnerId );
+
+		m_nHostOwnerId = pMsg->m_nOwnerId;
+
+		ApplySessionProperties( pMsg->m_ContextCount, pMsg->m_PropertyCount, pMsg->m_SessionContexts.Base(), pMsg->m_SessionProperties.Base() );
+		
+		for ( int i = 0; i < m_Local.m_cPlayers; ++i )
+		{
+			m_Local.m_iTeam[i] = pMsg->m_iTeam;
+		}
+
+		m_nTotalTeams = pMsg->m_nTotalTeams;
+
+		if ( pMsg->m_ResponseType == pMsg->JOINRESPONSE_APPROVED )
+		{
+			SessionNotification( SESSION_NOTIFY_CONNECTED_TOSESSION );
+			SendPlayerInfoToLobby( &m_Local );
+		}
+		break;
+
+	case MM_JoinResponse::JOINRESPONSE_MODIFY_SESSION:
+		if ( !m_Session.IsHost() )
+		{
+			if ( m_CurrentState != MMSTATE_SESSION_CONNECTED )
+			{
+				return true;
+			}
+			
+			// Host has sent us some new session properties
+			ApplySessionProperties( pMsg->m_ContextCount, pMsg->m_PropertyCount, pMsg->m_SessionContexts.Base(), pMsg->m_SessionProperties.Base() );
+
+			MM_JoinResponse response;
+			response.m_ResponseType = MM_JoinResponse::JOINRESPONSE_MODIFY_SESSION;
+			response.m_id = m_Local.m_id;
+			SendMessage( &response, &m_Host );
+
+			SessionNotification( SESSION_NOTIFY_MODIFYING_COMPLETED_CLIENT );
+		}
+		else
+		{
+			if ( m_CurrentState != MMSTATE_MODIFYING )
+			{
+				return true;
+			}
+
+			// Handle this client response
+			bool bWaiting = false;
+			for ( int i = 0; i < m_Remote.Count(); ++i )
+			{
+				if ( m_Remote[i]->m_id == pMsg->m_id )
+				{
+					m_Remote[i]->m_bModified = true;
+				}
+				else
+				{
+					if ( !m_Remote[i]->m_bModified )
+					{
+						bWaiting = true;
+					}
+				}
+			}
+
+			if ( !bWaiting )
+			{
+				// Everyone has modified their session
+				EndSessionModify();
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply the contexts and properties that came from the host, and build out keyvalues for GameUI
+//-----------------------------------------------------------------------------
+void CMatchmaking::ApplySessionProperties( int numContexts, int numProperties, XUSER_CONTEXT *pContexts, XUSER_PROPERTY *pProperties )
+{
+	// Clear our existing properties, as they should be completely replaced by these new ones
+	m_SessionContexts.RemoveAll();
+	m_SessionProperties.RemoveAll();
+
+	char szBuffer[MAX_PATH];
+	uint nGameTypeId = g_ClientDLL->GetPresenceID( "CONTEXT_GAME_TYPE" );
+
+	// Update the session properties
+	for ( int i = 0; i < numContexts; ++i )
+	{
+		XUSER_CONTEXT &ctx = pContexts[i];
+		m_SessionContexts.AddToTail( ctx );
+
+		const char *pID = g_ClientDLL->GetPropertyIdString( ctx.dwContextId );
+		g_ClientDLL->GetPropertyDisplayString( ctx.dwContextId, ctx.dwValue, szBuffer, sizeof( szBuffer ) );
+
+		// Set the display string for gameUI
+		KeyValues *pContextKey = m_pSessionKeys->FindKey( pID, true );
+		pContextKey->SetName( pID );
+		pContextKey->SetString( "displaystring", szBuffer );
+
+		// We need to set the game type
+		if ( ctx.dwContextId == nGameTypeId )
+		{
+			m_Session.SetContext( ctx.dwContextId, ctx.dwValue, false );
+		}
+	}
+
+	for ( int i = 0; i < numProperties; ++i )
+	{
+		XUSER_PROPERTY &prop = pProperties[i];
+		m_SessionProperties.AddToTail( prop );
+
+		const char *pID = g_ClientDLL->GetPropertyIdString( prop.dwPropertyId );
+		g_ClientDLL->GetPropertyDisplayString( prop.dwPropertyId, prop.value.nData, szBuffer, sizeof( szBuffer ) );
+
+		// Set the display string for gameUI
+		KeyValues *pPropertyKey = m_pSessionKeys->FindKey( pID, true );
+		pPropertyKey->SetName( pID );
+		pPropertyKey->SetString( "displaystring", szBuffer );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Send a join request to the session host 
+//-----------------------------------------------------------------------------
+bool CMatchmaking::ConnectToHost()
+{
+	AddPlayersToSession( &m_Local );
+
+	XSESSION_INFO info;
+	m_Session.GetSessionInfo( &info );
+
+#if defined( _X360 )
+	// Resolve the host's IP address
+	XNADDR xaddr = info.hostAddress;
+	XNKID xid = info.sessionID;
+	IN_ADDR winaddr;
+	if ( XNetXnAddrToInAddr( &xaddr, &xid, &winaddr ) != 0 )
+	{
+		Warning( "Error resolving host IP\n" );
+		return false;
+	}
+	m_Host.m_adr.SetType( NA_IP );
+	m_Host.m_adr.SetIPAndPort( winaddr.S_un.S_addr, PORT_MATCHMAKING );
+#endif
+
+	// Initiate the network channel
+	AddRemoteChannel( &m_Host.m_adr );
+
+	SendJoinRequest( &m_Host.m_adr );
+
+	m_fWaitTimer = GetTime();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Waiting for a connection response from the session host 
+//-----------------------------------------------------------------------------
+void CMatchmaking::UpdateConnecting()
+{
+	if ( GetTime() - m_fWaitTimer > JOINREPLY_WAITTIME )
+	{
+		SessionNotification( SESSION_NOTIFY_CONNECT_NOTAVAILABLE );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Clean up the search results arrays
+//-----------------------------------------------------------------------------
+void CMatchmaking::ClearSearchResults()
+{
+	if ( m_pSearchResults )
+	{
+		free( m_pSearchResults );
+		m_pSearchResults = NULL;
+	}
+
+	// This will call delete and we should technically be calling delete []
+	m_pSystemLinkResults.PurgeAndDeleteElements();
+}
+
+CON_COMMAND( mm_select_session, "Select a session" )
+{
+	if ( args.ArgC() >= 2 )
+	{
+		g_pMatchmaking->SelectSession( atoi( args[1] ) );
+	}
+}
+