able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dplay/dnet/lobby/dplcommon.cpp

1219 lines
34 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*==========================================================================
*
* Copyright (C) 2000 Microsoft Corporation. All Rights Reserved.
*
* File: DPLCommon.cpp
* Content: DirectPlay Lobby Common Functions
*@@BEGIN_MSINTERNAL
* History:
* Date By Reason
* ==== == ======
* 02/21/00 mjn Created
* 04/13/00 rmt First pass param validation
* 04/26/00 mjn Removed dwTimeOut from Send() API call
* 05/01/00 rmt Bug #33108 -- Initialize returns DPNERR_NORESPONSE when not lobbied
* 05/03/00 rmt Updated initialize so if lobby launched automatically establishes a
* connection and makes self unavailable. (Also waits for connection).
* 05/16/00 rmt Bug #34734 -- Init Client, Init App, Close App hangs --
* both client and app were using 'C' prefix, should have been 'C' for
* client and 'A' for app.
* 06/14/00 rmt Fixed build break with new compiler (added ')''s).
* 06/15/00 rmt Bug #33617 - Must provide method for providing automatic launch of DirectPlay instances
* 06/28/00 rmt Prefix Bug #38082
* 07/06/00 rmt Bug #38717 ASSERTION when sending data
* 07/08/2000 rmt Bug #38725 - Need to provide method to detect if app was lobby launched
* rmt Bug #38757 - Callback messages for connections may return AFTER WaitForConnection returns
* rmt Bug #38755 - No way to specify player name in Connection Settings
* rmt Bug #38758 - DPLOBBY8.H has incorrect comments
* rmt Bug #38783 - pvUserApplicationContext is only partially implemented
* rmt Added DPLHANDLE_ALLCONNECTIONS and dwFlags (reserved field to couple of funcs).
* 07/13/2000 rmt Fixed memory leak
* 07/14/2000 rmt Bug #39257 - LobbyClient::ReleaseApp returns E_OUTOFMEMORY when called when no one connected
* 07/21/2000 rmt Removed assert which wasn't needed
* 08/03/2000 rmt Removed assert which wasn't needed
* 08/05/2000 RichGr IA64: Use %p format specifier in DPFs for 32/64-bit pointers and handles.
* 08/18/2000 rmt Bug #42751 - DPLOBBY8: Prohibit more than one lobby client or lobby app per process
* 08/24/2000 rmt Bug #43317 - DP8LOBBY: Occasionally when closing Lobby App right after releasing handles, causes assertion.
* 02/06/2001 rodtoll WINBUG #293871: DPLOBBY8: [IA64] Lobby launching a 64-bit
* app from 64-bit lobby launcher crashes with unaligned memory error.
*
*@@END_MSINTERNAL
*
***************************************************************************/
#include "dnlobbyi.h"
//**********************************************************************
// Constant definitions
//**********************************************************************
//**********************************************************************
// Macro definitions
//**********************************************************************
//**********************************************************************
// Structure definitions
//**********************************************************************
//**********************************************************************
// Variable definitions
//**********************************************************************
BOOL g_fAppStarted = FALSE;
BOOL g_fClientStarted = FALSE;
DNCRITICAL_SECTION g_csSingleTon;
//**********************************************************************
// Function prototypes
//**********************************************************************
//**********************************************************************
// Function definitions
//**********************************************************************
// DPL_GetConnectionSettings
//
// Retrieves the pdplSessionInfo (if any) associated with the specified connection. This method
// is shared between the client and app interfaces.
//
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_GetConnectionSettings"
STDMETHODIMP DPL_GetConnectionSettings(LPVOID lpv,const DPNHANDLE hLobbyClient, DPL_CONNECTION_SETTINGS * const pdplSessionInfo, DWORD *pdwInfoSize, const DWORD dwFlags )
{
HRESULT hResultCode;
DPL_CONNECTION *pdplConnection;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
DPFX(DPFPREP, 3,"Parameters: hTarget [0x%lx], pdplSessionInfo [0x%p], pdwInfoSize [%p], dwFlags [0x%lx]",
hLobbyClient,pdplSessionInfo,pdwInfoSize,dwFlags);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(lpv));
if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_PARAMVALIDATION )
{
if( FAILED( hResultCode = DPL_ValidateGetConnectionSettings( lpv, hLobbyClient, pdplSessionInfo, pdwInfoSize, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating getconnectsettings params hr=[0x%lx]", hResultCode );
DPF_RETURN( hResultCode );
}
}
// Ensure we've been initialized
if (pdpLobbyObject->pReceiveQueue == NULL)
{
DPFERR("Not initialized");
DPF_RETURN(DPNERR_UNINITIALIZED);
}
}
EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Invalid object" );
DPF_RETURN(DPNERR_INVALIDOBJECT);
}
// Attempt to retrieve connection settings.
hResultCode = DPLConnectionGetConnectSettings( pdpLobbyObject, hLobbyClient, pdplSessionInfo, pdwInfoSize );
DPF_RETURN( hResultCode );
}
// DPL_SetConnectionSettings
//
// Sets the pdplSessionInfo structure associated with the specified connection. This method
// is shared between the client and app interfaces.
//
// This function will generate a DPL_MSGID_CONNECTION_SETTINGS message to be sent to the specified
// connection.
//
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_SetConnectionSettings"
STDMETHODIMP DPL_SetConnectionSettings(LPVOID lpv,const DPNHANDLE hLobbyClient, const DPL_CONNECTION_SETTINGS * const pdplSessionInfo, const DWORD dwFlags )
{
HRESULT hResultCode;
DPL_CONNECTION *pdplConnection;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
DPNHANDLE *hTargets = NULL;
DWORD dwNumTargets = 0;
DWORD dwTargetIndex = 0;
CConnectionSettings *pConnectionSettings = NULL;
DPFX(DPFPREP, 3,"Parameters: hLobbyClient [0x%lx], pBuffer [0x%p], dwFlags [0x%lx]",
hLobbyClient,pdplSessionInfo,dwFlags);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(lpv));
if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_PARAMVALIDATION )
{
if( FAILED( hResultCode = DPL_ValidateSetConnectionSettings( lpv, hLobbyClient, pdplSessionInfo, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating setconnectsettings params hr=[0x%lx]", hResultCode );
DPF_RETURN( hResultCode );
}
}
// Ensure we've been initialized
if (pdpLobbyObject->pReceiveQueue == NULL)
{
DPFERR("Not initialized");
DPF_RETURN(DPNERR_UNINITIALIZED);
}
}
EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Invalid object" );
DPF_RETURN(DPNERR_INVALIDOBJECT);
}
if( hLobbyClient == DPLHANDLE_ALLCONNECTIONS )
{
dwNumTargets = 0;
// We need loop so if someone adds a connection during our run
// it gets added to our list
//
while( 1 )
{
hResultCode = DPLConnectionEnum( pdpLobbyObject, hTargets, &dwNumTargets );
if( hResultCode == DPNERR_BUFFERTOOSMALL )
{
if( hTargets )
{
delete [] hTargets;
}
hTargets = new DPNHANDLE[dwNumTargets];
if( hTargets == NULL )
{
DPFERR("Error allocating memory" );
dwNumTargets = 0;
hResultCode = DPNERR_OUTOFMEMORY;
goto SETCONNECT_EXIT;
}
continue;
}
else if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error getting list of connections hr=0x%x", hResultCode );
break;
}
else
{
break;
}
}
// Failed getting connection information
if( FAILED( hResultCode ) )
{
if( hTargets )
{
delete [] hTargets;
hTargets = NULL;
}
dwNumTargets = 0;
goto SETCONNECT_EXIT;
}
}
else
{
hTargets = new DPNHANDLE[1]; // We use array delete below so we need array new
if( hTargets == NULL )
{
DPFERR("Error allocating memory" );
dwNumTargets = 0;
hResultCode = DPNERR_OUTOFMEMORY;
goto SETCONNECT_EXIT;
}
dwNumTargets = 1;
hTargets[0] = hLobbyClient;
}
for( dwTargetIndex = 0; dwTargetIndex < dwNumTargets; dwTargetIndex++ )
{
if ((hResultCode = DPLConnectionFind(pdpLobbyObject,hTargets[dwTargetIndex],&pdplConnection,TRUE)) != DPN_OK)
{
DPFERR("Invalid send target");
DisplayDNError(0,hResultCode);
continue;
}
if( pdplSessionInfo )
{
pConnectionSettings = new CConnectionSettings();
if( !pConnectionSettings )
{
DPFERR("Error allocating memory" );
hResultCode = DPNERR_OUTOFMEMORY;
goto SETCONNECT_EXIT;
}
hResultCode = pConnectionSettings->InitializeAndCopy( pdplSessionInfo );
if( FAILED( hResultCode ) )
{
DPFX( DPFPREP, 0, "Error setting up connection settings hr [0x%x]", hResultCode );
goto SETCONNECT_EXIT;
}
}
// Attempt to set connection settings.
hResultCode = DPLConnectionSetConnectSettings( pdpLobbyObject, hTargets[dwTargetIndex], pConnectionSettings );
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error setting connct settings for 0x%x hr=0x%x", hTargets[dwTargetIndex], hResultCode );
delete pConnectionSettings;
}
hResultCode = DPLSendConnectionSettings( pdpLobbyObject, hTargets[dwTargetIndex] );
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error sending connection settings to client 0x%x hr=0x%x", hTargets[dwTargetIndex], hResultCode );
}
pConnectionSettings = NULL;
}
SETCONNECT_EXIT:
for( dwTargetIndex = 0; dwTargetIndex < dwNumTargets; dwTargetIndex++ )
{
if( hTargets[dwTargetIndex] )
DPLConnectionRelease(pdpLobbyObject,hTargets[dwTargetIndex]);
}
if( hTargets )
delete [] hTargets;
DPF_RETURN(hResultCode);
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_RegisterMessageHandlerClient"
STDMETHODIMP DPL_RegisterMessageHandlerClient(PVOID pv,
const PVOID pvUserContext,
const PFNDPNMESSAGEHANDLER pfn,
const DWORD dwFlags)
{
return DPL_RegisterMessageHandler( pv, pvUserContext, pfn, NULL, dwFlags );
}
// HRESULT DPL_RegisterMessageHandler
// PVOID pv Interface pointer
// PVOID pvUserContext User context
// PFNDPNMESSAGEHANDLER pfn User supplied message handler
// DWORD dwFlags Not Used
//
// Returns
// DPN_OK If the message handler was registered without incident
// DPNERR_INVALIDPARAM If there was an invalid parameter
// DPNERR_GENERIC If there were any problems
//
// Notes
// This function registers a user supplied message handler function. This function should
// only be called once, even in cases where a game is being re-connected (i.e. after ending)
//
// This will set up the required message queues, handshake the lobby client's PID (if supplied on the
// command line) and spawn the application's receive message queue thread.
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_RegisterMessageHandler"
STDMETHODIMP DPL_RegisterMessageHandler(PVOID pv,
const PVOID pvUserContext,
const PFNDPNMESSAGEHANDLER pfn,
DPNHANDLE * const pdpnhConnection,
const DWORD dwFlags)
{
HRESULT hResultCode = DPN_OK;
DWORD dwCurrentPid;
DWORD dwThreadId;
PDIRECTPLAYLOBBYOBJECT pdpLobbyObject;
char cSuffix;
DPFX(DPFPREP, 3,"Parameters: pv [0x%p], pfn [0x%p], dwFlags [%lx]",pv,pfn,dwFlags);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(pv));
if( FAILED( hResultCode = DPL_ValidateRegisterMessageHandler( pv, pvUserContext, pfn, pdpnhConnection, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating register message handler params hr=[0x%lx]", hResultCode );
DPF_RETURN( hResultCode );
}
// Ensure we've been initialized
if (pdpLobbyObject->pReceiveQueue != NULL)
{
DPFERR("Already initialized");
DPF_RETURN(DPNERR_ALREADYINITIALIZED);
}
DNEnterCriticalSection( &g_csSingleTon );
if (pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBIEDAPPLICATION )
{
if( g_fAppStarted )
{
DPFERR( "You can only start one lobbied application per process!" );
DNLeaveCriticalSection( &g_csSingleTon );
DPF_RETURN( DPNERR_NOTALLOWED );
}
g_fAppStarted = TRUE;
}
else if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBYCLIENT )
{
if( g_fClientStarted )
{
DPFERR( "You can only start one lobby client per process!" );
DNLeaveCriticalSection( &g_csSingleTon );
DPF_RETURN( DPNERR_NOTALLOWED );
}
g_fClientStarted = TRUE;
}
DNLeaveCriticalSection( &g_csSingleTon );
}
EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Invalid object" );
DPF_RETURN(DPNERR_INVALIDOBJECT);
}
// Disable parameter validation flag if DPNINITIALIZE_DISABLEPARAMVAL
// is specified
if( dwFlags & DPLINITIALIZE_DISABLEPARAMVAL )
{
pdpLobbyObject->dwFlags &= ~(DPL_OBJECT_FLAG_PARAMVALIDATION);
}
pdpLobbyObject->pfnMessageHandler = pfn;
pdpLobbyObject->pvUserContext = pvUserContext;
pdpLobbyObject->pReceiveQueue = new CMessageQueue;
if( pdpLobbyObject->pReceiveQueue == NULL )
{
DPFX(DPFPREP, 0, "Error allocating receive queue" );
hResultCode = DPNERR_OUTOFMEMORY;
goto ERROR_DPL_RegisterMessageHandler;
}
pdpLobbyObject->pReceiveQueue->SetMessageHandler(static_cast<PVOID>(pdpLobbyObject),DPLMessageHandler);
if (pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBIEDAPPLICATION)
{
cSuffix = DPL_MSGQ_OBJECT_SUFFIX_APPLICATION;
}
else
{
cSuffix = DPL_MSGQ_OBJECT_SUFFIX_CLIENT;
}
// Open application receive message queue
dwCurrentPid = GetCurrentProcessId();
if ((hResultCode = pdpLobbyObject->pReceiveQueue->Open(dwCurrentPid,
cSuffix,DPL_MSGQ_SIZE,DPL_MSGQ_TIMEOUT_IDLE,0)) != DPN_OK)
{
DPFERR("Could not open App Rec Q");
goto ERROR_DPL_RegisterMessageHandler;
}
if ((pdpLobbyObject->hReceiveThread =
CreateThread(NULL,(DWORD)NULL,(LPTHREAD_START_ROUTINE)DPLProcessMessageQueue,
static_cast<void*>(pdpLobbyObject->pReceiveQueue),(DWORD)NULL,&dwThreadId)) == NULL)
{
DPFERR("CreateThread() failed");
hResultCode = DPNERR_GENERIC;
pdpLobbyObject->pReceiveQueue->Close();
goto ERROR_DPL_RegisterMessageHandler;
}
pdpLobbyObject->pReceiveQueue->WaitForReceiveThread(INFINITE);
if (pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBIEDAPPLICATION)
{
DPFX(DPFPREP, 5,"Attempt lobby connection");
hResultCode = DPLAttemptLobbyConnection(pdpLobbyObject);
if ( hResultCode == DPN_OK)
{
if( pdpnhConnection )
*pdpnhConnection = pdpLobbyObject->dpnhLaunchedConnection;
DPFX(DPFPREP, 5,"Application was lobby launched");
DPFX(DPFPREP, 5,"Waiting for true connect notification" );
DWORD dwReturnValue = WaitForSingleObject( pdpLobbyObject->hConnectEvent, DPL_LOBBYLAUNCHED_CONNECT_TIMEOUT );
DNASSERT( dwReturnValue == WAIT_OBJECT_0 );
}
else if( hResultCode != DPNERR_TIMEDOUT )
{
DPFX(DPFPREP, 5,"Application was not lobby launched");
if( pdpnhConnection )
*pdpnhConnection = NULL;
// Need to reset return code to OK.. this is not an error
hResultCode = DPN_OK;
}
else
{
DPFERR( "App was lobby launched but timed out establishing a connection" );
if( pdpnhConnection )
*pdpnhConnection = NULL;
}
}
EXIT_DPL_RegisterMessageHandler:
DPF_RETURN(hResultCode);
ERROR_DPL_RegisterMessageHandler:
DNEnterCriticalSection( &g_csSingleTon );
if (pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBIEDAPPLICATION )
{
g_fAppStarted = FALSE;
}
else if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBYCLIENT )
{
g_fClientStarted = FALSE;
}
DNLeaveCriticalSection( &g_csSingleTon );
goto EXIT_DPL_RegisterMessageHandler;
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_Close"
HRESULT DPL_Close(PVOID pv, const DWORD dwFlags )
{
HRESULT hResultCode;
DWORD dwNumHandles;
DPNHANDLE *prgHandles;
DWORD dw;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
DPL_CONNECTION *pConnection;
DPFX(DPFPREP, 3,"Parameters: (none)");
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(pv));
if( FAILED( hResultCode = DPL_ValidateClose( pv, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating close params hr=[0x%lx]", hResultCode );
return hResultCode;
}
// Ensure we've been initialized
if (pdpLobbyObject->pReceiveQueue == NULL)
{
DPFERR("Already closed");
return DPNERR_UNINITIALIZED;
}
}
EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Invalid object" );
return DPNERR_INVALIDOBJECT;
}
// Shutdown the queue first to ensure that we don't end up shutting down a connection
// twice! (E.g. disconnect comes in as we are disconnecting it).
if (pdpLobbyObject->pReceiveQueue)
{
if (pdpLobbyObject->pReceiveQueue->IsOpen())
{
// Ask receive thread to terminate
DPFX(DPFPREP, 5,"Terminate Receive Msg Thread");
pdpLobbyObject->pReceiveQueue->Terminate();
// Wait for termination to occur
if (WaitForSingleObject(pdpLobbyObject->hReceiveThread,INFINITE) != WAIT_OBJECT_0)
{
hResultCode = DPNERR_GENERIC;
DPFERR("WaitForSingleObject failed");
}
pdpLobbyObject->pReceiveQueue->Close();
if (pdpLobbyObject->pReceiveQueue)
{
delete pdpLobbyObject->pReceiveQueue;
pdpLobbyObject->pReceiveQueue = NULL;
}
CloseHandle(pdpLobbyObject->hReceiveThread);
pdpLobbyObject->hReceiveThread = NULL;
CloseHandle(pdpLobbyObject->hConnectEvent);
pdpLobbyObject->hConnectEvent = NULL;
CloseHandle(pdpLobbyObject->hLobbyLaunchConnectEvent);
pdpLobbyObject->hLobbyLaunchConnectEvent = NULL;
}
}
// Enumerate handles outstanding
dwNumHandles = 0;
prgHandles = NULL;
hResultCode = DPLConnectionEnum(pdpLobbyObject,prgHandles,&dwNumHandles);
while (hResultCode == DPNERR_BUFFERTOOSMALL)
{
if (prgHandles)
DNFree(prgHandles);
if ((prgHandles = static_cast<DPNHANDLE*>(DNMalloc(dwNumHandles*sizeof(DPNHANDLE)))) != NULL)
{
hResultCode = DPLConnectionEnum(pdpLobbyObject,prgHandles,&dwNumHandles);
}
else
{
DPFERR("Could not allocate space for handle array");
hResultCode = DPNERR_OUTOFMEMORY;
break;
}
}
// Send DISCONNECTs to all attached msg queues, for which there are handles
if (hResultCode == DPN_OK)
{
for (dw = 0 ; dw < dwNumHandles ; dw++)
{
hResultCode = DPLConnectionFind(pdpLobbyObject,prgHandles[dw],&pConnection,TRUE );
if( SUCCEEDED( hResultCode ) )
{
hResultCode = DPLConnectionDisconnect(pdpLobbyObject,prgHandles[dw]);
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error disconnecting connection 0x%x", hResultCode );
}
DPLConnectionRelease( pdpLobbyObject,prgHandles[dw]);
}
}
// Errors above are irrelevant, it's quite possible after building the list of outstanding
// connections that before we attempt to close the list one has gone away.
//
hResultCode = DPN_OK;
}
if (prgHandles)
{
DNFree(prgHandles);
prgHandles = NULL;
}
DNEnterCriticalSection( &g_csSingleTon );
if (pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBIEDAPPLICATION )
{
g_fAppStarted = FALSE;
}
else if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_LOBBYCLIENT )
{
g_fClientStarted = FALSE;
}
DNLeaveCriticalSection( &g_csSingleTon );
DPF_RETURN( hResultCode );
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_Send"
STDMETHODIMP DPL_Send(PVOID pv,
const DPNHANDLE hTarget,
BYTE *const pBuffer,
const DWORD dwBufferSize,
const DWORD dwFlags)
{
HRESULT hResultCode;
DPL_CONNECTION *pdplConnection;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
DPNHANDLE *hTargets = NULL;
DWORD dwNumTargets = 0;
DWORD dwTargetIndex = 0;
DPFX(DPFPREP, 3,"Parameters: hTarget [0x%lx], pBuffer [0x%p], dwBufferSize [%ld], dwFlags [0x%lx]",
hTarget,pBuffer,dwBufferSize,dwFlags);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(pv));
if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_PARAMVALIDATION )
{
if( FAILED( hResultCode = DPL_ValidateSend( pv, hTarget, pBuffer, dwBufferSize, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating send params hr=[0x%lx]", hResultCode );
DPF_RETURN( hResultCode );
}
}
// Ensure we've been initialized
if (pdpLobbyObject->pReceiveQueue == NULL)
{
DPFERR("Not initialized");
DPF_RETURN(DPNERR_UNINITIALIZED);
}
}
EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Invalid object" );
DPF_RETURN(DPNERR_INVALIDOBJECT);
}
if( hTarget == DPLHANDLE_ALLCONNECTIONS )
{
dwNumTargets = 0;
// We need loop so if someone adds a connection during our run
// it gets added to our list
//
while( 1 )
{
hResultCode = DPLConnectionEnum( pdpLobbyObject, hTargets, &dwNumTargets );
if( hResultCode == DPNERR_BUFFERTOOSMALL )
{
if( hTargets )
{
delete [] hTargets;
}
hTargets = new DPNHANDLE[dwNumTargets];
if( hTargets == NULL )
{
DPFERR("Error allocating memory" );
dwNumTargets = 0;
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_AND_CLEANUP;
}
memset( hTargets, 0x00, sizeof(DPNHANDLE)*dwNumTargets);
continue;
}
else if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error getting list of connections hr=0x%x", hResultCode );
break;
}
else
{
break;
}
}
// Failed getting connection information
if( FAILED( hResultCode ) )
{
if( hTargets )
{
delete [] hTargets;
hTargets = NULL;
}
dwNumTargets = 0;
goto EXIT_AND_CLEANUP;
}
}
else
{
hTargets = new DPNHANDLE[1]; // We use array delete below so we need array new
if( hTargets == NULL )
{
DPFERR("Error allocating memory" );
dwNumTargets = 0;
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_AND_CLEANUP;
}
dwNumTargets = 1;
hTargets[0] = hTarget;
}
for( dwTargetIndex = 0; dwTargetIndex < dwNumTargets; dwTargetIndex++ )
{
if ((hResultCode = DPLConnectionFind(pdpLobbyObject,hTargets[dwTargetIndex],&pdplConnection,TRUE)) != DPN_OK)
{
DPFERR("Invalid send target");
DisplayDNError(0,hResultCode);
hResultCode = DPNERR_INVALIDHANDLE;
goto EXIT_AND_CLEANUP;
}
DNASSERT(pdplConnection->pSendQueue != NULL);
if (!pdplConnection->pSendQueue->IsReceiving())
{
DPFERR("Other side is not listening");
DPLConnectionRelease(pdpLobbyObject,hTarget);
hResultCode = DPNERR_INVALIDHANDLE;
goto EXIT_AND_CLEANUP;
}
hResultCode = pdplConnection->pSendQueue->Send(pBuffer,dwBufferSize,INFINITE,DPL_MSGQ_MSGFLAGS_USER2,0);
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error sending to connection 0x%x hr=0x%x", hTargets[dwTargetIndex], hResultCode );
}
}
EXIT_AND_CLEANUP:
for( dwTargetIndex = 0; dwTargetIndex < dwNumTargets; dwTargetIndex++ )
{
if( hTargets[dwTargetIndex] )
DPLConnectionRelease(pdpLobbyObject,hTargets[dwTargetIndex]);
}
if( hTargets )
delete [] hTargets;
DPF_RETURN(hResultCode);
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPLReceiveIdleTimeout"
HRESULT DPLReceiveIdleTimeout(DIRECTPLAYLOBBYOBJECT *const pdpLobbyObject,
const DPNHANDLE hSender)
{
HRESULT hResultCode = DPNERR_BUFFERTOOSMALL;
DWORD dwHandleIndex;
DPL_CONNECTION *pConnection;
HANDLE hProcess;
DPFX(DPFPREP, 6, "Enumerating processes, checking for exit" );
while( 1 )
{
hResultCode = H_Enum( &pdpLobbyObject->hsHandles, &pdpLobbyObject->dwHandleBufferSize,
pdpLobbyObject->phHandleBuffer );
if( hResultCode == E_POINTER )
{
if( pdpLobbyObject->phHandleBuffer )
delete [] pdpLobbyObject->phHandleBuffer;
pdpLobbyObject->phHandleBuffer = new DPNHANDLE[pdpLobbyObject->dwHandleBufferSize];
if( pdpLobbyObject->phHandleBuffer == NULL )
{
DPFERR( "Out of memory" );
return DPNERR_OUTOFMEMORY;
}
hResultCode = H_Enum( &pdpLobbyObject->hsHandles, &pdpLobbyObject->dwHandleBufferSize,
pdpLobbyObject->phHandleBuffer );
}
else if( FAILED( hResultCode ) )
{
DPFERR( "Error getting handle list" );
return hResultCode;
}
else
{
break;
}
}
for( dwHandleIndex = 0; dwHandleIndex < pdpLobbyObject->dwHandleBufferSize; dwHandleIndex++ )
{
hResultCode = DPLConnectionFind( pdpLobbyObject, pdpLobbyObject->phHandleBuffer[dwHandleIndex],
&pConnection, TRUE );
if( hResultCode == DPN_OK )
{
hProcess = OpenProcess( PROCESS_DUP_HANDLE, FALSE, pConnection->dwTargetPID );
// We can close this handle.. after we're only just checking for existance.
if( hProcess )
CloseHandle( hProcess );
// Process has exited..
if( hProcess == NULL )
{
DPFX(DPFPREP, 6, "Process %d has exited", pConnection->dwTargetPID );
DPLConnectionReceiveDisconnect( pdpLobbyObject, pdpLobbyObject->phHandleBuffer[dwHandleIndex], NULL, DPNERR_CONNECTIONLOST );
}
DPLConnectionRelease( pdpLobbyObject, pdpLobbyObject->phHandleBuffer[dwHandleIndex] );
}
}
return DPN_OK;
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPLReceiveUserMessage"
HRESULT DPLReceiveUserMessage(DIRECTPLAYLOBBYOBJECT *const pdpLobbyObject,
const DPNHANDLE hSender,
BYTE *const pBuffer,
const DWORD dwBufferSize)
{
HRESULT hResultCode;
DPL_MESSAGE_RECEIVE Msg;
Msg.dwSize = sizeof(DPL_MESSAGE_RECEIVE);
Msg.pBuffer = pBuffer;
Msg.dwBufferSize = dwBufferSize;
Msg.hSender = hSender;
hResultCode = DPLConnectionGetContext( pdpLobbyObject, hSender, &Msg.pvConnectionContext );
// Failed to get the connection's context -- strange, but we're going to indicate anyhow.
//
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Failed getting connection context hResultCode = 0x%x", hResultCode );
}
hResultCode = (pdpLobbyObject->pfnMessageHandler)(pdpLobbyObject->pvUserContext,
DPL_MSGID_RECEIVE,
reinterpret_cast<BYTE*>(&Msg));
DPFX(DPFPREP, 3,"Returning: [0x%lx]",hResultCode);
return(hResultCode);
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPLMessageHandler"
HRESULT DPLMessageHandler(PVOID pvContext,
const DPNHANDLE hSender,
DWORD dwMessageFlags,
BYTE *const pBuffer,
const DWORD dwBufferSize)
{
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
HRESULT hResultCode;
DWORD *pdwMsgId;
// 7/17/2000(RichGr) - IA64: Use %p format specifier for 32/64-bit pointers and handles.
DPFX(DPFPREP, 3,"Parameters: hSender [0x%x], pBuffer [0x%p], dwBufferSize [%ld]",
hSender,pBuffer,dwBufferSize);
DNASSERT(pBuffer != NULL);
/*if (dwBufferSize < sizeof(DWORD))
{
DPFERR("Invalid message");
return(DPNERR_GENERIC);
}*/
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(pvContext);
pdwMsgId = reinterpret_cast<DWORD*>(pBuffer);
if( dwMessageFlags & DPL_MSGQ_MSGFLAGS_USER1 )
{
DPFX(DPFPREP, 5,"Received INTERNAL message");
switch(*pdwMsgId)
{
case DPL_MSGID_INTERNAL_IDLE_TIMEOUT:
{
DPFX(DPFPREP, 5,"Received: DPL_MSGID_INTERNAL_IDLE_TIMEOUT" );
DPLReceiveIdleTimeout(pdpLobbyObject,hSender);
break;
}
case DPL_MSGID_INTERNAL_DISCONNECT:
{
DPFX(DPFPREP, 5,"Received: DPL_MSGID_INTERNAL_DISCONNECT");
DPLConnectionReceiveDisconnect(pdpLobbyObject,hSender,pBuffer,DPN_OK);
break;
}
case DPL_MSGID_INTERNAL_CONNECT_REQ:
{
DPFX(DPFPREP, 5,"Received: DPL_MSGID_INTERNAL_CONNECT_REQ");
DPLConnectionReceiveREQ(pdpLobbyObject,pBuffer);
break;
}
case DPL_MSGID_INTERNAL_CONNECT_ACK:
{
DPFX(DPFPREP, 5,"Received: DPL_MSGID_INTERNAL_CONNECT_ACK");
DPLConnectionReceiveACK(pdpLobbyObject,hSender,pBuffer);
break;
}
case DPL_MSGID_INTERNAL_UPDATE_STATUS:
{
DPFX(DPFPREP, 5,"Received: DPL_MSGID_INTERNAL_UPDATE_STATUS");
DPLUpdateAppStatus(pdpLobbyObject,hSender,pBuffer);
break;
}
case DPL_MSGID_INTERNAL_CONNECTION_SETTINGS:
{
DPFX(DPFPREP, 5,"Received: DPL_MSGID_INTERNAL_CONNECTION_SETTINGS");
DPLUpdateConnectionSettings(pdpLobbyObject,hSender,pBuffer);
break;
}
default:
{
DPFX(DPFPREP, 5,"Received: Unknown message [0x%lx]",*pdwMsgId);
DNASSERT(FALSE);
break;
}
}
}
else if( dwMessageFlags & DPL_MSGQ_MSGFLAGS_USER2 )
{
DNASSERT( !(dwMessageFlags & DPL_MSGQ_MSGFLAGS_QUEUESYSTEM) );
DPFX(DPFPREP, 5,"Received USER message");
DPLReceiveUserMessage(pdpLobbyObject,hSender,pBuffer,dwBufferSize);
}
hResultCode = DPN_OK;
DPFX(DPFPREP, 3,"Returning: [0x%lx]",hResultCode);
return(hResultCode);
}
// DPLSendConnectionSettings
//
// This function is used to send a connection settings update message
#undef DPF_MODNAME
#define DPF_MODNAME "DPLSendConnectionSettings"
HRESULT DPLSendConnectionSettings( DIRECTPLAYLOBBYOBJECT * const pdpLobbyObject,
const DPNHANDLE hConnection )
{
BYTE *pbTransmitBuffer = NULL;
DWORD dwTransmitBufferSize = 0;
DPL_INTERNAL_CONNECTION_SETTINGS_UPDATE *pdplMsgSettings = NULL;
DPL_CONNECTION *pdplConnection = NULL;
CPackedBuffer PackBuffer;
HRESULT hResultCode = DPN_OK;
hResultCode = DPLConnectionFind(pdpLobbyObject, hConnection, &pdplConnection, TRUE );
if( FAILED( hResultCode ) )
{
DPFERR( "Unable to find specified connection" );
return hResultCode;
}
// Grab lock to prevent other people from interfering
DNEnterCriticalSection( &pdplConnection->csLock );
PackBuffer.Initialize( NULL, 0 );
PackBuffer.AddToFront( NULL, sizeof( DPL_INTERNAL_CONNECTION_SETTINGS_UPDATE_HEADER ) );
if( pdplConnection->pConnectionSettings )
{
pdplConnection->pConnectionSettings->BuildWireStruct( &PackBuffer );
}
dwTransmitBufferSize = PackBuffer.GetSizeRequired();
pbTransmitBuffer = new BYTE[ dwTransmitBufferSize ];
if( !pbTransmitBuffer )
{
DPFX( DPFPREP, 0, "Error allocating memory" );
hResultCode = DPNERR_OUTOFMEMORY;
goto DPLSENDCONNECTSETTINGS_DONE;
}
pdplMsgSettings = (DPL_INTERNAL_CONNECTION_SETTINGS_UPDATE *) pbTransmitBuffer;
PackBuffer.Initialize( pbTransmitBuffer, dwTransmitBufferSize );
DNASSERT( pdplMsgSettings );
hResultCode = PackBuffer.AddToFront( NULL, sizeof( DPL_INTERNAL_CONNECTION_SETTINGS_UPDATE_HEADER ) );
if( FAILED( hResultCode ) )
{
DPFX( DPFPREP, 0, "Error adding main struct hr [0x%x]", hResultCode );
goto DPLSENDCONNECTSETTINGS_DONE;
}
if( pdplConnection->pConnectionSettings )
{
hResultCode = pdplConnection->pConnectionSettings->BuildWireStruct( &PackBuffer );
if( FAILED( hResultCode ) )
{
DPFX( DPFPREP, 0, "Error adding connect struct hr [0x%x]", hResultCode );
goto DPLSENDCONNECTSETTINGS_DONE;
}
pdplMsgSettings->dwConnectionSettingsSize = 1;
}
else
{
pdplMsgSettings->dwConnectionSettingsSize = 0;
}
pdplMsgSettings->dwMsgId = DPL_MSGID_INTERNAL_CONNECTION_SETTINGS;
if (!pdplConnection->pSendQueue->IsReceiving())
{
DPFERR("Other side is not receiving");
goto DPLSENDCONNECTSETTINGS_DONE;
}
hResultCode = pdplConnection->pSendQueue->Send(reinterpret_cast<BYTE*>(pdplMsgSettings),
PackBuffer.GetSizeRequired(),
INFINITE,
DPL_MSGQ_MSGFLAGS_USER1,
0);
if ( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Could not send connect settings hr [0x%x]", hResultCode );
goto DPLSENDCONNECTSETTINGS_DONE;
}
hResultCode = DPN_OK;
DPLSENDCONNECTSETTINGS_DONE:
if( pbTransmitBuffer )
delete [] pbTransmitBuffer;
DNLeaveCriticalSection( &pdplConnection->csLock );
DPLConnectionRelease(pdpLobbyObject,hConnection);
return hResultCode;
}
// DPLUpdateConnectionSettings
//
// This function is called when a connection settings update message has been received.
//
#undef DPF_MODNAME
#define DPF_MODNAME "DPLUpdateConnectionSettings"
HRESULT DPLUpdateConnectionSettings(DIRECTPLAYLOBBYOBJECT *const pdpLobbyObject,
const DPNHANDLE hSender,
BYTE *const pBuffer )
{
HRESULT hr;
DPL_MESSAGE_CONNECTION_SETTINGS MsgConnectionSettings;
DPL_CONNECTION_SETTINGS *pSettingsBuffer = NULL;
DWORD dwSettingsBufferSize = 0;
BOOL fAddressReferences = FALSE;
CConnectionSettings *pConnectionSettings = NULL;
DPL_INTERNAL_CONNECTION_SETTINGS_UPDATE *pConnectionSettingsMsg = NULL;
DPFX(DPFPREP, 3,"Parameters: pBuffer [0x%p]",pBuffer);
DNASSERT(pdpLobbyObject != NULL);
DNASSERT(pBuffer != NULL);
pConnectionSettingsMsg = (DPL_INTERNAL_CONNECTION_SETTINGS_UPDATE *) pBuffer;
if( pConnectionSettingsMsg->dwConnectionSettingsSize )
{
pConnectionSettings = new CConnectionSettings();
if( !pConnectionSettings )
{
DPFX( DPFPREP, 0, "Error allocating connection settings" );
hr = DPNERR_OUTOFMEMORY;
goto UPDATESETTINGS_FAILURE;
}
hr = pConnectionSettings->Initialize( &pConnectionSettingsMsg->dplConnectionSettings, (UNALIGNED BYTE *) pConnectionSettingsMsg );
if( FAILED( hr ) )
{
DPFX( DPFPREP, 0, "Error building structure from wire struct hr [0x%x]", hr );
goto UPDATESETTINGS_FAILURE;
}
}
// Set the connection settings on the object
hr = DPLConnectionSetConnectSettings( pdpLobbyObject, hSender, pConnectionSettings );
if( FAILED( hr ) )
{
DPFX(DPFPREP, 0, "Error setting connection settings hr = 0x%x", hr );
goto UPDATESETTINGS_FAILURE;
}
// Setup message to indicate to user
MsgConnectionSettings.dwSize = sizeof(DPL_MESSAGE_CONNECTION_SETTINGS);
MsgConnectionSettings.hSender = hSender;
if( pConnectionSettings )
MsgConnectionSettings.pdplConnectionSettings = pConnectionSettings->GetConnectionSettings();
else
MsgConnectionSettings.pdplConnectionSettings = NULL;
hr = DPLConnectionGetContext( pdpLobbyObject, hSender, &MsgConnectionSettings.pvConnectionContext );
if( FAILED( hr ) )
{
DPFX(DPFPREP, 0, "Error getting connection's context value" );
goto UPDATESETTINGS_FAILURE;
}
hr = (pdpLobbyObject->pfnMessageHandler)(pdpLobbyObject->pvUserContext,
DPL_MSGID_CONNECTION_SETTINGS,
reinterpret_cast<BYTE*>(&MsgConnectionSettings));
if( FAILED( hr ) )
{
DPFX(DPFPREP, 1, "Error returned from user callback -- ignored hr [0x%x]", hr );
}
return DPN_OK;
UPDATESETTINGS_FAILURE:
if( pConnectionSettings )
delete pConnectionSettings;
return hr;
}
Reference in a new issue Copy permalink