/*==========================================================================
*
* Copyright (C) 2000 Microsoft Corporation. All Rights Reserved.
*
* File: DNLClient.cpp
* Content: DirectNet Lobby Client Functions
*@@BEGIN_MSINTERNAL
* History:
* Date By Reason
* ==== == ======
* 02/21/00 mjn Created
* 03/22/2000 jtk Changed interface names
* 04/05/2000 jtk Changed GetValueSize to GetValueLength
* 04/13/00 rmt First pass param validation
* 04/25/2000 rmt Bug #s 33138, 33145, 33150
* 04/26/00 mjn Removed dwTimeOut from Send() API call
* 05/01/2000 rmt Bug #33678
* 05/03/00 rmt Bug #33879 -- Status messsage missing from field
* 05/30/00 rmt Bug #35618 -- ConnectApp with ShortTimeout returns DPN_OK
* 06/07/00 rmt Bug #36452 -- Calling ConnectApplication twice could result in disconnection
* 06/15/00 rmt Bug #33617 - Must provide method for providing automatic launch of DirectPlay instances
* 07/06/00 rmt Updated for new registry parameters
* 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/14/2000 rmt Bug #39257 - LobbyClient::ReleaseApp returns E_OUTOFMEMORY when called when no one connected
* 07/21/2000 rmt Bug #39578 - LobbyClient sample errors and quits -- memory corruption due to length vs. size problem
* 08/05/2000 RichGr IA64: Use %p format specifier in DPFs for 32/64-bit pointers and handles.
* 12/15/2000 rmt Bug #48445 - Specifying empty launcher name results in error
* 04/19/2001 simonpow Bug #369842 - Altered CreateProcess calls to take app name and cmd
* line as 2 separate arguments rather than one.
* 06/16/2001 rodtoll WINBUG #416983 - RC1: World has full control to HKLM\Software\Microsoft\DirectPlay\Applications on Personal
* Implementing mirror of keys into HKCU. Algorithm is now:
* - Read of entries tries HKCU first, then HKLM
* - Enum of entires is combination of HKCU and HKLM entries with duplicates removed. HKCU takes priority.
* - Write of entries is HKLM and HKCU. (HKLM may fail, but is ignored).
*@@END_MSINTERNAL
*
***************************************************************************/
#include "dnlobbyi.h"
//**********************************************************************
// Constant definitions
//**********************************************************************
//**********************************************************************
// Macro definitions
//**********************************************************************
//**********************************************************************
// Structure definitions
//**********************************************************************
//**********************************************************************
// Variable definitions
//**********************************************************************
typedef STDMETHODIMP ClientQueryInterface(IDirectPlay8LobbyClient *pInterface,REFIID ridd,PVOID *ppvObj);
typedef STDMETHODIMP_(ULONG) ClientAddRef(IDirectPlay8LobbyClient *pInterface);
typedef STDMETHODIMP_(ULONG) ClientRelease(IDirectPlay8LobbyClient *pInterface);
typedef STDMETHODIMP ClientRegisterMessageHandler(IDirectPlay8LobbyClient *pInterface,const PVOID pvUserContext,const PFNDPNMESSAGEHANDLER pfn,const DWORD dwFlags);
typedef STDMETHODIMP ClientSend(IDirectPlay8LobbyClient *pInterface,const DPNHANDLE hTarget,BYTE *const pBuffer,const DWORD pBufferSize,const DWORD dwFlags);
typedef STDMETHODIMP ClientClose(IDirectPlay8LobbyClient *pInterface,const DWORD dwFlags);
typedef STDMETHODIMP ClientGetConnectionSettings(IDirectPlay8LobbyClient *pInterface, const DPNHANDLE hLobbyClient, DPL_CONNECTION_SETTINGS * const pdplSessionInfo, DWORD *pdwInfoSize, const DWORD dwFlags );
typedef STDMETHODIMP ClientSetConnectionSettings(IDirectPlay8LobbyClient *pInterface, const DPNHANDLE hTarget, const DPL_CONNECTION_SETTINGS * const pdplSessionInfo, const DWORD dwFlags );
IDirectPlay8LobbyClientVtbl DPL_Lobby8ClientVtbl =
{
(ClientQueryInterface*) DPL_QueryInterface,
(ClientAddRef*) DPL_AddRef,
(ClientRelease*) DPL_Release,
(ClientRegisterMessageHandler*) DPL_RegisterMessageHandlerClient,
DPL_EnumLocalPrograms,
DPL_ConnectApplication,
(ClientSend*) DPL_Send,
DPL_ReleaseApplication,
(ClientClose*) DPL_Close,
(ClientGetConnectionSettings*) DPL_GetConnectionSettings,
(ClientSetConnectionSettings*) DPL_SetConnectionSettings
};
//**********************************************************************
// Function prototypes
//**********************************************************************
//**********************************************************************
// Function definitions
//**********************************************************************
#define DPL_ENUM_APPGUID_BUFFER_INITIAL 8
#define DPL_ENUM_APPGUID_BUFFER_GROWBY 4
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_EnumLocalPrograms"
STDMETHODIMP DPL_EnumLocalPrograms(IDirectPlay8LobbyClient *pInterface,
GUID *const pGuidApplication,
BYTE *const pEnumData,
DWORD *const pdwEnumDataSize,
DWORD *const pdwEnumDataItems,
const DWORD dwFlags )
{
HRESULT hResultCode;
CMessageQueue MessageQueue;
CPackedBuffer PackedBuffer;
CRegistry RegistryEntry;
CRegistry SubEntry;
DWORD dwSizeRequired;
DWORD dwMaxKeyLen;
PWSTR pwszKeyName = NULL;
// Application name variables
PWSTR pwszApplicationName = NULL;
DWORD dwMaxApplicationNameLength; // Includes null terminator
DWORD dwApplicationNameLength; // Includes null terminator
// Executable name variables
PWSTR pwszExecutableFilename = NULL;
DWORD dwMaxExecutableFilenameLength; // Includes null terminator
DWORD dwExecutableFilenameLength; // Includes null terminator
DWORD *pdwPID;
DWORD dwMaxPID;
DWORD dwNumPID;
DWORD dwEnumIndex;
DWORD dwEnumCount;
DWORD dwKeyLen;
DWORD dw;
DPL_APPLICATION_INFO dplAppInfo;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
GUID *pAppLoadedList = NULL; // List of GUIDs of app's we've enumerated
DWORD dwSizeAppLoadedList = 0; // size of list pAppLoadedList
DWORD dwLengthAppLoadedList = 0; // # of elements in list
HKEY hkCurrentBranch = HKEY_LOCAL_MACHINE;
DPFX(DPFPREP, 3,"Parameters: pInterface [0x%p], pGuidApplication [0x%p], pEnumData [0x%p], pdwEnumDataSize [0x%p], pdwEnumDataItems [0x%p], dwFlags [0x%lx]",
pInterface,pGuidApplication,pEnumData,pdwEnumDataSize,pdwEnumDataItems,dwFlags);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(pInterface));
if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_PARAMVALIDATION )
{
if( FAILED( hResultCode = DPL_ValidateEnumLocalPrograms( pInterface, pGuidApplication, pEnumData, pdwEnumDataSize, pdwEnumDataItems, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating enum local programs 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);
}
dwSizeRequired = *pdwEnumDataSize;
PackedBuffer.Initialize(pEnumData,dwSizeRequired);
pwszApplicationName = NULL;
pwszExecutableFilename = NULL;
pdwPID = NULL;
dwMaxPID = 0;
dwLengthAppLoadedList = 0;
dwSizeAppLoadedList = DPL_ENUM_APPGUID_BUFFER_INITIAL;
pAppLoadedList = static_cast<GUID*>(DNMalloc(sizeof(GUID)*dwSizeAppLoadedList));
if( !pAppLoadedList )
{
DPFERR("Failed allocating memory" );
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
dwEnumCount = 0;
for( DWORD dwIndex = 0; dwIndex < 2; dwIndex++ )
{
if( dwIndex == 0 )
{
hkCurrentBranch = HKEY_CURRENT_USER;
}
else
{
hkCurrentBranch = HKEY_LOCAL_MACHINE;
}
if (!RegistryEntry.Open(hkCurrentBranch,DPL_REG_LOCAL_APPL_SUBKEY,TRUE,FALSE,TRUE,DPL_REGISTRY_READ_ACCESS))
{
DPFX(DPFPREP,1,"On pass %i could not find app key", dwIndex);
continue;
}
// Set up to enumerate
if (!RegistryEntry.GetMaxKeyLen(dwMaxKeyLen))
{
DPFERR("RegistryEntry.GetMaxKeyLen() failed");
hResultCode = DPNERR_GENERIC;
goto EXIT_DPL_EnumLocalPrograms;
}
dwMaxKeyLen++; // Null terminator
DPFX(DPFPREP, 7,"dwMaxKeyLen = %ld",dwMaxKeyLen);
if ((pwszKeyName = static_cast<WCHAR*>(DNMalloc(dwMaxKeyLen*sizeof(WCHAR)))) == NULL)
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
dwMaxApplicationNameLength = dwMaxKeyLen * sizeof(WCHAR);
dwMaxExecutableFilenameLength = dwMaxApplicationNameLength;
if ((pwszApplicationName = static_cast<WCHAR*>(DNMalloc(dwMaxApplicationNameLength*sizeof(WCHAR)))) == NULL) // Seed Application name size
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
if ((pwszExecutableFilename = static_cast<WCHAR*>(DNMalloc(dwMaxExecutableFilenameLength*sizeof(WCHAR)))) == NULL)
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
dwEnumIndex = 0;
dwKeyLen = dwMaxKeyLen;
// Enumerate !
while (RegistryEntry.EnumKeys(pwszKeyName,&dwKeyLen,dwEnumIndex))
{
DPFX(DPFPREP, 7,"%ld - %S (%ld)",dwEnumIndex,pwszKeyName,dwKeyLen);
// Get Application name and GUID from each sub key
if (!SubEntry.Open(RegistryEntry,pwszKeyName,TRUE,FALSE))
{
DPFX(DPFPREP, 7,"skipping %S",pwszKeyName);
goto LOOP_END;
}
//
// Minara, double-check size vs. length for names
//
if (!SubEntry.GetValueLength(DPL_REG_KEYNAME_APPLICATIONNAME,&dwApplicationNameLength))
{
DPFX(DPFPREP, 7,"Could not get ApplicationName size. Skipping [%S]",pwszKeyName);
goto LOOP_END;
}
// To include null terminator
dwApplicationNameLength++;
if (dwApplicationNameLength > dwMaxApplicationNameLength)
{
// grow buffer (taking into account that the reg functions always return WCHAR) and try again
DPFX(DPFPREP, 7,"Need to grow pwszApplicationName from %ld to %ld",dwMaxApplicationNameLength,dwApplicationNameLength);
if (pwszApplicationName != NULL)
{
DNFree(pwszApplicationName);
pwszApplicationName = NULL;
}
if ((pwszApplicationName = static_cast<WCHAR*>(DNMalloc(dwApplicationNameLength*sizeof(WCHAR)))) == NULL)
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
dwMaxApplicationNameLength = dwApplicationNameLength;
}
if (!SubEntry.ReadString(DPL_REG_KEYNAME_APPLICATIONNAME,pwszApplicationName,&dwApplicationNameLength))
{
DPFX(DPFPREP, 7,"Could not read ApplicationName. Skipping [%S]",pwszKeyName);
goto LOOP_END;
}
DPFX(DPFPREP, 7,"ApplicationName = %S (%ld WCHARs)",pwszApplicationName,dwApplicationNameLength);
if (!SubEntry.ReadGUID(DPL_REG_KEYNAME_GUID,dplAppInfo.guidApplication))
{
DPFERR("SubEntry.ReadGUID failed - skipping entry");
goto LOOP_END;
}
for( DWORD dwGuidSearchIndex = 0; dwGuidSearchIndex < dwLengthAppLoadedList; dwGuidSearchIndex++ )
{
if( pAppLoadedList[dwGuidSearchIndex] == dplAppInfo.guidApplication )
{
DPFX(DPFPREP, 1, "Ignoring local machine entry for current user version of entry [%S]", pwszApplicationName );
goto LOOP_END;
}
}
if ((pGuidApplication == NULL) || (*pGuidApplication == dplAppInfo.guidApplication))
{
// Get process count - need executable filename
//
// Minara, check size vs. length
//
if (!SubEntry.GetValueLength(DPL_REG_KEYNAME_EXECUTABLEFILENAME,&dwExecutableFilenameLength))
{
DPFX(DPFPREP, 7,"Could not get ExecutableFilename size. Skipping [%S]",pwszKeyName);
goto LOOP_END;
}
// So we include null terminator
dwExecutableFilenameLength++;
if (dwExecutableFilenameLength > dwMaxExecutableFilenameLength)
{
// grow buffer (noting that all strings from the registry are WCHAR) and try again
DPFX(DPFPREP, 7,"Need to grow pwszExecutableFilename from %ld to %ld",dwMaxExecutableFilenameLength,dwExecutableFilenameLength);
if (pwszExecutableFilename != NULL)
{
DNFree(pwszExecutableFilename);
pwszExecutableFilename = NULL;
}
if ((pwszExecutableFilename = static_cast<WCHAR*>(DNMalloc(dwExecutableFilenameLength*sizeof(WCHAR)))) == NULL)
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
dwMaxExecutableFilenameLength = dwExecutableFilenameLength;
}
if (!SubEntry.ReadString(DPL_REG_KEYNAME_EXECUTABLEFILENAME,pwszExecutableFilename,&dwExecutableFilenameLength))
{
DPFX(DPFPREP, 7,"Could not read ExecutableFilename. Skipping [%S]",pwszKeyName);
goto LOOP_END;
}
DPFX(DPFPREP, 7,"ExecutableFilename [%S]",pwszExecutableFilename);
// Count running apps
dwNumPID = dwMaxPID;
while ((hResultCode = DPLGetProcessList(pwszExecutableFilename,pdwPID,&dwNumPID,
pdpLobbyObject->bIsUnicodePlatform)) == DPNERR_BUFFERTOOSMALL)
{
if (pdwPID)
{
DNFree(pdwPID);
pdwPID = NULL;
}
dwMaxPID = dwNumPID;
if ((pdwPID = static_cast<DWORD*>(DNMalloc(dwNumPID*sizeof(DWORD)))) == NULL)
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
}
if (hResultCode != DPN_OK)
{
DPFERR("DPLGetProcessList() failed");
DisplayDNError(0,hResultCode);
hResultCode = DPNERR_GENERIC;
goto EXIT_DPL_EnumLocalPrograms;
}
// Count waiting apps
dplAppInfo.dwNumWaiting = 0;
for (dw = 0 ; dw < dwNumPID ; dw++)
{
if ((hResultCode = MessageQueue.Open( pdwPID[dw],
DPL_MSGQ_OBJECT_SUFFIX_APPLICATION,
DPL_MSGQ_SIZE,
DPL_MSGQ_OPEN_FLAG_NO_CREATE, INFINITE)) == DPN_OK)
{
if (MessageQueue.IsAvailable())
{
dplAppInfo.dwNumWaiting++;
}
MessageQueue.Close();
}
}
hResultCode = PackedBuffer.AddWCHARStringToBack(pwszApplicationName);
dplAppInfo.pwszApplicationName = (PWSTR)(PackedBuffer.GetTailAddress());
dplAppInfo.dwFlags = 0;
dplAppInfo.dwNumRunning = dwNumPID;
hResultCode = PackedBuffer.AddToFront(&dplAppInfo,sizeof(DPL_APPLICATION_INFO));
if( dwLengthAppLoadedList+1 > dwSizeAppLoadedList )
{
GUID *pTmpArray = NULL;
pTmpArray = static_cast<GUID*>(DNMalloc(sizeof(GUID)*(dwSizeAppLoadedList+DPL_ENUM_APPGUID_BUFFER_GROWBY)));
if( !pTmpArray )
{
DPFERR("DNMalloc() failed");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_EnumLocalPrograms;
}
memcpy( pTmpArray, pAppLoadedList, sizeof(GUID)*dwLengthAppLoadedList);
dwSizeAppLoadedList += DPL_ENUM_APPGUID_BUFFER_GROWBY;
DNFree(pAppLoadedList);
pAppLoadedList = pTmpArray;
}
pAppLoadedList[dwLengthAppLoadedList] = dplAppInfo.guidApplication;
dwLengthAppLoadedList++;
dwEnumCount++;
}
LOOP_END:
SubEntry.Close();
dwEnumIndex++;
dwKeyLen = dwMaxKeyLen;
}
RegistryEntry.Close();
if( pwszKeyName )
{
DNFree(pwszKeyName);
pwszKeyName= NULL;
}
if( pwszApplicationName )
{
DNFree(pwszApplicationName);
pwszApplicationName = NULL;
}
if( pwszExecutableFilename )
{
DNFree(pwszExecutableFilename);
pwszExecutableFilename = NULL;
}
}
dwSizeRequired = PackedBuffer.GetSizeRequired();
if (dwSizeRequired > *pdwEnumDataSize)
{
DPFX(DPFPREP, 7,"Buffer too small");
*pdwEnumDataSize = dwSizeRequired;
hResultCode = DPNERR_BUFFERTOOSMALL;
}
else
{
*pdwEnumDataItems = dwEnumCount;
}
if( pGuidApplication != NULL && dwEnumCount == 0 )
{
DPFX(DPFPREP, 0, "Specified application was not registered" );
hResultCode = DPNERR_DOESNOTEXIST;
}
EXIT_DPL_EnumLocalPrograms:
if (pwszKeyName != NULL)
DNFree(pwszKeyName);
if (pwszApplicationName != NULL)
DNFree(pwszApplicationName);
if (pwszExecutableFilename != NULL)
DNFree(pwszExecutableFilename);
if (pdwPID != NULL)
DNFree(pdwPID);
if( pAppLoadedList )
DNFree(pAppLoadedList);
DPF_RETURN(hResultCode);
}
// DPL_ConnectApplication
//
// Try to connect to a lobbied application. Based on DPL_CONNECT_INFO flags,
// we may have to launch an application.
//
// If we have to launch an application, we will need to handshake the PID of the
// application (as it may be ripple launched). We will pass the LobbyClient's PID on the
// command line to the application launcher and expect it to be passed down to the
// application. The application will open a named shared memory block using the PID and
// write its PID there, and then signal a named event (using the LobbyClient's PID again).
// When the waiting LobbyClient is signaled by this event, it continues its connection
// process as if this was an existing running and available application.
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_ConnectApplication"
STDMETHODIMP DPL_ConnectApplication(IDirectPlay8LobbyClient *pInterface,
DPL_CONNECT_INFO *const pdplConnectInfo,
void *pvConnectionContext,
DPNHANDLE *const hApplication,
const DWORD dwTimeOut,
const DWORD dwFlags)
{
HRESULT hResultCode = DPN_OK;
DWORD dwSize = 0;
BYTE *pBuffer = NULL;
DPL_PROGRAM_DESC *pdplProgramDesc;
DWORD *pdwProcessList = NULL;
DWORD dwNumProcesses = 0;
DWORD dwPID = 0;
DWORD dw = 0;
DPNHANDLE handle = NULL;
DPL_CONNECTION *pdplConnection = NULL;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject = NULL;
DPFX(DPFPREP, 3,"Parameters: pdplConnectInfo [0x%p], pvUserAppContext [0x%p], hApplication [0x%lx], dwFlags [0x%lx]",
pdplConnectInfo,pvConnectionContext,hApplication,dwFlags);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(pInterface));
if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_PARAMVALIDATION )
{
if( FAILED( hResultCode = DPL_ValidateConnectApplication( pInterface, pdplConnectInfo, pvConnectionContext, hApplication, dwTimeOut, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating connect application 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);
}
// Get program description
dwSize = 0;
pBuffer = NULL;
hResultCode = DPLGetProgramDesc(&pdplConnectInfo->guidApplication,pBuffer,&dwSize);
if (hResultCode != DPNERR_BUFFERTOOSMALL)
{
DPFERR("Could not get Program Description");
goto EXIT_DPL_ConnectApplication;
}
if ((pBuffer = static_cast<BYTE*>(DNMalloc(dwSize))) == NULL)
{
DPFERR("Could not allocate space for buffer");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_ConnectApplication;
}
if ((hResultCode = DPLGetProgramDesc(&pdplConnectInfo->guidApplication,pBuffer,&dwSize)) != DPN_OK)
{
DPFERR("Could not get Program Description");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
pdplProgramDesc = reinterpret_cast<DPL_PROGRAM_DESC*>(pBuffer);
dwPID = 0;
dwNumProcesses = 0;
pdwProcessList = NULL;
if (!(pdplConnectInfo->dwFlags & DPLCONNECT_LAUNCHNEW)) // Only if not forcing launch
{
// Get process list
hResultCode = DPLGetProcessList(pdplProgramDesc->pwszExecutableFilename,NULL,&dwNumProcesses,
pdpLobbyObject->bIsUnicodePlatform);
if (hResultCode != DPN_OK && hResultCode != DPNERR_BUFFERTOOSMALL)
{
DPFERR("Could not retrieve process list");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
if (hResultCode == DPNERR_BUFFERTOOSMALL)
{
if ((pdwProcessList = static_cast<DWORD*>(DNMalloc(dwNumProcesses*sizeof(DWORD)))) == NULL)
{
DPFERR("Could not create process list buffer");
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DPL_ConnectApplication;
}
if ((hResultCode = DPLGetProcessList(pdplProgramDesc->pwszExecutableFilename,pdwProcessList,
&dwNumProcesses,pdpLobbyObject->bIsUnicodePlatform)) != DPN_OK)
{
DPFERR("Could not get process list");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
}
// Try to connect to an already running application
for (dw = 0 ; dw < dwNumProcesses ; dw++)
{
if ((hResultCode = DPLMakeApplicationUnavailable(pdwProcessList[dw])) == DPN_OK)
{
DPFX(DPFPREP, 1, "Found Existing Process=%d", pdwProcessList[dw] );
dwPID = pdwProcessList[dw];
break;
}
}
if (pdwProcessList)
{
DNFree(pdwProcessList);
pdwProcessList = NULL;
}
}
// Launch application if none are ready to connect
if ((dwPID == 0) && (pdplConnectInfo->dwFlags & (DPLCONNECT_LAUNCHNEW | DPLCONNECT_LAUNCHNOTFOUND)))
{
if ((hResultCode = DPLLaunchApplication(pdpLobbyObject,pdplProgramDesc,&dwPID,dwTimeOut)) != DPN_OK)
{
DPFERR("Could not launch application");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
else
{
DPFX(DPFPREP, 1, "Launched process dwID=%d", dwPID );
}
}
if (dwPID == 0) // Could not make any connection
{
DPFERR("Could not connect to an existing application or launch a new one");
hResultCode = DPNERR_NOCONNECTION;
DisplayDNError( 0, hResultCode );
goto EXIT_DPL_ConnectApplication;
}
handle = NULL;
// Create connection
if ((hResultCode = DPLConnectionNew(pdpLobbyObject,&handle,&pdplConnection)) != DPN_OK)
{
DPFERR("Could not create connection entry");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
pdplConnection->dwTargetPID = dwPID;
DPFX(DPFPREP, 0, "PID=%d", dwPID );
// Set the context for this connection
if ((hResultCode = DPLConnectionSetContext( pdpLobbyObject, handle, pvConnectionContext )) != DPN_OK )
{
DPFERR( "Could not set contect for connection" );
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
// Connect to selected application instance
if ((hResultCode = DPLConnectionConnect(pdpLobbyObject,handle,dwPID,TRUE)) != DPN_OK)
{
DPFERR("Could not connect to application");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
ResetEvent(pdplConnection->hConnectEvent);
// Pass lobby client info to application
if ((hResultCode = DPLConnectionSendREQ(pdpLobbyObject,handle,pdpLobbyObject->dwPID,
pdplConnectInfo)) != DPN_OK)
{
DPFERR("Could not send connection request");
DisplayDNError(0,hResultCode);
goto EXIT_DPL_ConnectApplication;
}
if (WaitForSingleObject(pdplConnection->hConnectEvent,INFINITE) != WAIT_OBJECT_0)
{
DPFERR("Wait for connection terminated");
hResultCode = DPNERR_GENERIC;
goto EXIT_DPL_ConnectApplication;
}
*hApplication = handle;
hResultCode = DPN_OK;
EXIT_DPL_ConnectApplication:
if( FAILED(hResultCode) && handle )
{
DPLConnectionDisconnect(pdpLobbyObject,handle);
DPLConnectionRelease(pdpLobbyObject,handle);
}
if (pBuffer)
DNFree(pBuffer);
if (pdwProcessList)
DNFree(pdwProcessList);
DPF_RETURN(hResultCode);
}
#undef DPF_MODNAME
#define DPF_MODNAME "DPL_ReleaseApplication"
STDMETHODIMP DPL_ReleaseApplication(IDirectPlay8LobbyClient *pInterface,
const DPNHANDLE hApplication,
const DWORD dwFlags )
{
HRESULT hResultCode;
DIRECTPLAYLOBBYOBJECT *pdpLobbyObject;
DPNHANDLE *hTargets = NULL;
DWORD dwNumTargets = 0;
DWORD dwTargetIndex = 0;
DPFX(DPFPREP, 3,"Parameters: hApplication [0x%lx]",hApplication);
TRY
{
pdpLobbyObject = static_cast<DIRECTPLAYLOBBYOBJECT*>(GET_OBJECT_FROM_INTERFACE(pInterface));
if( pdpLobbyObject->dwFlags & DPL_OBJECT_FLAG_PARAMVALIDATION )
{
if( FAILED( hResultCode = DPL_ValidateReleaseApplication( pInterface, hApplication, dwFlags ) ) )
{
DPFX(DPFPREP, 0, "Error validating release application 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( hApplication == 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" );
hResultCode = DPNERR_OUTOFMEMORY;
dwNumTargets = 0;
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" );
hResultCode = DPNERR_OUTOFMEMORY;
dwNumTargets = 0;
goto EXIT_AND_CLEANUP;
}
dwNumTargets = 1;
hTargets[0] = hApplication;
}
for( dwTargetIndex = 0; dwTargetIndex < dwNumTargets; dwTargetIndex++ )
{
hResultCode = DPLConnectionDisconnect(pdpLobbyObject,hTargets[dwTargetIndex]);
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error disconnecting connection 0x%x hr=0x%x", hTargets[dwTargetIndex], hResultCode );
}
}
EXIT_AND_CLEANUP:
if( hTargets )
delete [] hTargets;
DPF_RETURN(hResultCode);
}
// DPLLaunchApplication
//
// Launch the application with a command-line argument of:
// DPLID=PIDn PID=Lobby Client PID, n=launch counter (each launch increases it)
// Wait for the application to signal the event (or die)
#undef DPF_MODNAME
#define DPF_MODNAME "DPLLaunchApplication"
HRESULT DPLLaunchApplication(DIRECTPLAYLOBBYOBJECT *const pdpLobbyObject,
DPL_PROGRAM_DESC *const pdplProgramDesc,
DWORD *const pdwPID,
const DWORD dwTimeOut)
{
HRESULT hResultCode;
DWORD dwAppNameLen=0; //Length of the application full name (path+exe)
PWSTR pwszAppName=NULL; //Unicode version of application full name
DWORD dwCmdLineLen=0; //Length of the command line string
PWSTR pwszCmdLine=NULL; //Unicode version of command line to supply
CHAR * pszAppName=NULL; //Ascii version of application full name
CHAR * pszCmdLine=NULL; //Acii version of command line string
LONG lc;
STARTUPINFOW siW; // Unicode startup info (place holder)
STARTUPINFOA siA;
PROCESS_INFORMATION pi;
DWORD dwError;
HANDLE hSyncEvents[2] = { NULL, NULL };
WCHAR pwszObjectName[(sizeof(DWORD)*2)*2 + 1];
CHAR pszObjectName[(sizeof(DWORD)*2)*2 + 1 + 1];
DPL_SHARED_CONNECT_BLOCK *pSharedBlock = NULL;
HANDLE hFileMap = NULL;
DWORD dwPID;
CHAR *pszDefaultDir = NULL;
WCHAR *wszToLaunchPath = NULL;
WCHAR *wszToLaunchExecutable = NULL;
DWORD dwToLaunchPathLen;
// Are we launching the launcher or the executable?
if( !pdplProgramDesc->pwszLauncherFilename || wcslen(pdplProgramDesc->pwszLauncherFilename) == 0 )
{
wszToLaunchPath = pdplProgramDesc->pwszExecutablePath;
wszToLaunchExecutable = pdplProgramDesc->pwszExecutableFilename;
}
else
{
wszToLaunchPath = pdplProgramDesc->pwszLauncherPath;
wszToLaunchExecutable = pdplProgramDesc->pwszLauncherFilename;
}
DPFX(DPFPREP, 3,"Parameters: pdplProgramDesc [0x%p]",pdplProgramDesc);
DNASSERT(pdplProgramDesc != NULL);
// Increment launch count
lc = InterlockedIncrement(&pdpLobbyObject->lLaunchCount);
// Synchronization event and shared memory names
swprintf(pwszObjectName,L"%lx%lx",pdpLobbyObject->dwPID,lc);
sprintf(pszObjectName,"-%lx%lx",pdpLobbyObject->dwPID,lc);
// Compute the size of the full application name string (combination of path and exe name)
if (wszToLaunchPath)
dwAppNameLen += (wcslen(wszToLaunchPath) + 1);
if (wszToLaunchExecutable)
dwAppNameLen += (wcslen(wszToLaunchExecutable) + 1);
// Compute the size of the command line string
dwCmdLineLen=dwAppNameLen+1;
if (pdplProgramDesc->pwszCommandLine)
dwCmdLineLen += wcslen(pdplProgramDesc->pwszCommandLine);
dwCmdLineLen += (1 + wcslen(DPL_ID_STR_W) + (sizeof(DWORD)*2*2) + 1);
DPFX(DPFPREP, 5,"Application full name string length [%ld] WCHARs", dwAppNameLen);
DPFX(DPFPREP, 5,"Command Line string length [%ld] WCHARs", dwCmdLineLen);
// Allocate memory to hold the full app name and command line + check allocation was OK
pwszAppName=static_cast<WCHAR *>(DNMalloc(dwAppNameLen * sizeof(WCHAR)));
pwszCmdLine=static_cast<WCHAR *>(DNMalloc(dwCmdLineLen * sizeof(WCHAR)));
if (pwszAppName==NULL || pwszCmdLine==NULL)
{
DPFERR("Could not allocate strings for app name and command line");
hResultCode = DPNERR_OUTOFMEMORY;
goto CLEANUP_DPLLaunch;
}
// Build the application full name by combining launch path with exe name
*pwszAppName = L'\0';
if (wszToLaunchPath)
{
dwToLaunchPathLen = wcslen(wszToLaunchPath);
if (dwToLaunchPathLen > 0)
{
wcscat(pwszAppName,wszToLaunchPath);
if (wszToLaunchPath[dwToLaunchPathLen - 1] != L'\\')
{
wcscat(pwszAppName,L"\\");
}
}
}
if (wszToLaunchExecutable)
{
wcscat(pwszAppName,wszToLaunchExecutable);
}
//Build the command line from app name, program description and the lobby related parameters
wcscpy(pwszCmdLine, pwszAppName);
wcscat(pwszCmdLine,L" ");
if (pdplProgramDesc->pwszCommandLine)
{
wcscat(pwszCmdLine,pdplProgramDesc->pwszCommandLine);
wcscat(pwszCmdLine,L" ");
}
wcscat(pwszCmdLine,DPL_ID_STR_W);
wcscat(pwszCmdLine,pwszObjectName);
DPFX(DPFPREP, 5,"Application full name string [%S]",pwszAppName);
DPFX(DPFPREP, 5,"Command Line string [%S]",pwszCmdLine);
// Create shared connect block to receive Application's PID
*pszObjectName = DPL_MSGQ_OBJECT_IDCHAR_FILEMAP;
hFileMap = CreateFileMappingA(INVALID_HANDLE_VALUE,(LPSECURITY_ATTRIBUTES) NULL,
PAGE_READWRITE,(DWORD)0,sizeof(DPL_SHARED_CONNECT_BLOCK),pszObjectName);
if (hFileMap == NULL)
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "CreateFileMapping() failed dwLastError [0x%lx]", dwError );
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
// Map file
pSharedBlock = reinterpret_cast<DPL_SHARED_CONNECT_BLOCK*>(MapViewOfFile(hFileMap,FILE_MAP_ALL_ACCESS,0,0,0));
if (pSharedBlock == NULL)
{
dwError = GetLastError();
DPFX(DPFPREP, 0,"MapViewOfFile() failed dwLastError [0x%lx]", dwError);
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
// Create synchronization event
*pszObjectName = DPL_MSGQ_OBJECT_IDCHAR_EVENT;
if ((hSyncEvents[0] = CreateEventA(NULL,TRUE,FALSE,pszObjectName)) == NULL)
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "Create Event Failed dwLastError [0x%lx]", dwError );
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
if( DNGetOSType() == VER_PLATFORM_WIN32_NT )
{
// More setup
siW.cb = sizeof(STARTUPINFO);
siW.lpReserved = NULL;
siW.lpDesktop = NULL;
siW.lpTitle = NULL;
siW.dwFlags = 0;
siW.cbReserved2 = 0;
siW.lpReserved2 = NULL;
// Launch !
if (CreateProcessW(pwszAppName, pwszCmdLine, NULL,NULL,FALSE,NORMAL_PRIORITY_CLASS,NULL,
pdplProgramDesc->pwszCurrentDirectory,&siW,&pi) == 0)
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "CreateProcess Failed dwLastError [0x%lx]", dwError );
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
}
else
{
// More setup
siA.cb = sizeof(STARTUPINFO);
siA.lpReserved = NULL;
siA.lpDesktop = NULL;
siA.lpTitle = NULL;
siA.dwFlags = 0;
siA.cbReserved2 = 0;
siA.lpReserved2 = NULL;
DPFX(DPFPREP, 1, "Detected 9x, Doing Ansi launch" );
//Convert full app name, command line and default dir from unicode to ascii format
if( FAILED( hResultCode = STR_AllocAndConvertToANSI( &pszAppName, pwszAppName ) ) )
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "String conversion failed dwError = [0x%lx]", dwError );
hResultCode = DPNERR_CONVERSION;
goto CLEANUP_DPLLaunch;
}
if( FAILED( hResultCode = STR_AllocAndConvertToANSI( &pszCmdLine, pwszCmdLine ) ) )
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "String conversion failed dwError = [0x%lx]", dwError );
hResultCode = DPNERR_CONVERSION;
goto CLEANUP_DPLLaunch;
}
if( FAILED( hResultCode = STR_AllocAndConvertToANSI( &pszDefaultDir, pdplProgramDesc->pwszCurrentDirectory ) ) )
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "String conversion failed dwError = [0x%lx]", dwError );
hResultCode = DPNERR_CONVERSION;
goto CLEANUP_DPLLaunch;
}
// Launch !
if (CreateProcessA(pszAppName,pszCmdLine,NULL,NULL,FALSE,NORMAL_PRIORITY_CLASS,NULL,
pszDefaultDir,&siA,&pi) == 0)
{
dwError = GetLastError();
DPFX(DPFPREP, 0, "CreateProcess Failed dwLastError [0x%lx]", dwError );
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
}
hSyncEvents[1] = pi.hProcess;
// Wait for connection or application termination
dwError = WaitForMultipleObjects(2,hSyncEvents,FALSE,dwTimeOut);
// Immediately clean up
dwPID = pSharedBlock->dwPID;
/* CloseHandle(hSyncEvents[0]);
UnmapViewOfFile(pSharedBlock);
CloseHandle(hFileMap); */
// Ensure we can continue
if (dwError - WAIT_OBJECT_0 > 1)
{
if (dwError == WAIT_TIMEOUT)
{
DPFERR("Wait for application connection timed out");
hResultCode = DPNERR_TIMEDOUT;
goto CLEANUP_DPLLaunch;
}
else
{
DPFERR("Wait for application connection terminated mysteriously");
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
}
// Check if application terminated
if (dwError == 1)
{
DPFERR("Application was terminated");
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
goto CLEANUP_DPLLaunch;
}
*pdwPID = dwPID;
hResultCode = DPN_OK;
CLEANUP_DPLLaunch:
if( hSyncEvents[0] != NULL )
CloseHandle( hSyncEvents[0] );
if( pSharedBlock != NULL )
UnmapViewOfFile(pSharedBlock);
if( hFileMap != NULL )
CloseHandle( hFileMap );
if( pwszAppName != NULL )
DNFree( pwszAppName );
if (pwszCmdLine!=NULL)
DNFree( pwszCmdLine );
if( pszAppName != NULL )
delete[] pszAppName;
if (pszCmdLine!=NULL)
delete[] pszCmdLine;
if( pszDefaultDir != NULL )
delete [] pszDefaultDir;
DPF_RETURN(hResultCode);
}
HRESULT DPLUpdateAppStatus(DIRECTPLAYLOBBYOBJECT *const pdpLobbyObject,
const DPNHANDLE hSender,
BYTE *const pBuffer)
{
HRESULT hResultCode;
DPL_INTERNAL_MESSAGE_UPDATE_STATUS *pStatus;
DPL_MESSAGE_SESSION_STATUS MsgStatus;
DPFX(DPFPREP, 3,"Parameters: pBuffer [0x%p]",pBuffer);
DNASSERT(pdpLobbyObject != NULL);
DNASSERT(pBuffer != NULL);
pStatus = reinterpret_cast<DPL_INTERNAL_MESSAGE_UPDATE_STATUS*>(pBuffer);
MsgStatus.dwSize = sizeof(DPL_MESSAGE_SESSION_STATUS);
MsgStatus.dwStatus = pStatus->dwStatus;
MsgStatus.hSender = hSender;
// Return code is irrelevant, at this point we're going to indicate regardless
hResultCode = DPLConnectionGetContext( pdpLobbyObject, hSender, &MsgStatus.pvConnectionContext );
if( FAILED( hResultCode ) )
{
DPFX(DPFPREP, 0, "Error getting connection context for 0x%x hr=0x%x", hSender, hResultCode );
}
hResultCode = (pdpLobbyObject->pfnMessageHandler)(pdpLobbyObject->pvUserContext,
DPL_MSGID_SESSION_STATUS,
reinterpret_cast<BYTE*>(&MsgStatus));
DPFX(DPFPREP, 3,"Returning: [0x%lx]",hResultCode);
return(hResultCode);
}
// ----------------------------------------------------------------------------
#if 0
// HRESULT DNL_RegisterLcMessageHandler
// LPVOID lpv Interface pointer
// LPFNDNLCMESSAGEHANDLER lpfn Pointer to user supplied lobby client message handler function
// 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 lobby client message handler function. This function should
// only be called once, when the lobby client is launched.
//
// This will set up the required message queues, and spawn the lobby client's receive message queue thread.
// HRESULT DNL_EnumLocalPrograms
// LPVOID lpv Interface pointer
// LPGUID lpGuidApplication GUID of application to enumerate (optional)
// LPVOID lpvEnumData Buffer to be filled with DNAPPINFO structs and Unicode strings
// LPDWORD lpdwEnumData Size of lpvEnumData and number of bytes needed on return
// LPDWORD lpdwItems Number of DNAPPINFO structs in lpvEnumData
//
// Returns
// DPN_OK If the key was added successfully
// DPNERR_INVALIDPARAM If there was a problem with a parameter
// DPNERR_OUTOFMEMORY If it could not allocate memory
// DPNERR_DOESNOTEXIST If there was a problem opening reading a registry key
//
// Notes
// - This is ugly because of the need to support both WinNT and Win9x at runtime.
// WinNT registry is kept in Unicode, whereas Win9x is in ANSI. Application root key
// names should be ANSI compatible (or their GUIDs are used instead) i.e. Will be stored
// in Unicode under WinNT, but only if convertable to ANSI
// - Strings are placed in the buffer, starting at the end of the buffer and working
// backwards.
// - In most cases, errors will cause the current app being enumerated to be ignored
// and not included in the enumeration buffer.
// HRESULT DNL_ConnectApplication
// LPVOID lpv Interface pointer
// LPDNCONNECTINFO lpdnConnectionInfo Pointer to connection info structure
// LPVOID lpvUserApplicationContext User supplied application context value
// LPDWORD lpdwAppId Pointer to receive application ID (handle) in
// DWORD dwFlags Flags
//
// Returns
// DPN_OK If the application was connected to without incident
// DPNERR_INVALIDPARAM If there was an invalid parameter
// DPNERR_OUTOFMEMORY If there were any memory allocation problems
// DPNERR_GENERIC If there were any problems
//
// Notes
// This function connects the lobby client to a user specified application. If successfull, the
// DNLobby assigned application ID will be returned in lpdwAppId.
#undef DPF_MODNAME
#define DPF_MODNAME "DNL_ConnectApplication"
STDMETHODIMP DNL_ConnectApplication(LPVOID lpv,LPDNCONNECTINFO lpdnConnectionInfo,
LPVOID lpvUserApplicationContext,LPDWORD lpdwAppId, DWORD dwFlags)
{
LPDIRECTPLAYLOBBYOBJECT lpdnLobbyObject;
HRESULT hResultCode = DPN_OK;
DNPROGRAMDESC dnProgramDesc; // Program descriptor for launching applications
DWORD dwNumApps; // Number of applications currently running
LPDWORD lpdwProcessList = NULL; // Pointer to process list
DWORD dwProcessId; // Process ID of target applications
DWORD dw; // Counter
DWORD dwStrLen; // Various string lengths
LPWSTR lpwszCommandLine = NULL; // Expanded Unicode command line
LPWSTR lpwszCurrentDirectory = NULL; // Expanded Unicode current directory
LPSTR lpszCommandLine = NULL; // Expanded ANSI command line
LPSTR lpszCurrentDirectory = NULL; // Expanded ANSI current directory
LPWSTR lpwszUnexpanded = NULL; // Unexpanded command line
LPSTR lpszUnexpanded = NULL; // Unexpanded ANSI strings converted from Unicode
STARTUPINFOA siA; // ANSI startup info (place holder)
STARTUPINFOW siW; // Unicode startup info (place holder)
PROCESS_INFORMATION pi;
UUID uuid;
RPC_STATUS rpcStatus;
DWORD dwHandle;
LPDN_APP_HANDLE_ENTRY lpdnAppHandleEntry;
LPDN_MESSAGE_STRUCT lpdnMsg = NULL;
DPFX(DPFPREP, 9,"Parameters: lpv [%p], lpdnConnectionInfo [%p], lpvUserApplicationContext [%p], lpdwAppId [%p], dwFlags [%lx]",
lpv,lpdnConnectionInfo,lpvUserApplicationContext,lpdwAppId,dwFlags);
// Parameter validation
TRY
{
if (lpv == NULL || lpdnConnectionInfo == NULL || lpdwAppId == NULL)
return(DPNERR_INVALIDPARAM);
}
EXCEPT (EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Exception encountered validating parameters");
return(DPNERR_INVALIDPARAM);
}
lpdnLobbyObject = (LPDIRECTPLAYLOBBYOBJECT) GET_OBJECT_FROM_INTERFACE(lpv);
// Get program description from registry
if ((hResultCode = DnGetProgramDesc(lpdnConnectionInfo->lpGuidApplication,&dnProgramDesc))
!= DPN_OK)
{
goto EXIT_DNL_ConnectApplication;
}
hResultCode = DnGetProcessListW(dnProgramDesc.lpwszFilename,NULL,&dwNumApps); // Num apps
if (hResultCode != DPN_OK && hResultCode != DPNERR_BUFFERTOOSMALL)
{
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
while (hResultCode == DPNERR_BUFFERTOOSMALL) // New processes may get launched !
{
if (lpdwProcessList != NULL)
GlobalFree(lpdwProcessList);
if ((lpdwProcessList = (LPDWORD)GLOBALALLOC(dwNumApps*sizeof(DWORD))) == NULL)
{
hResultCode = DPNERR_OUTOFMEMORY;
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
hResultCode = DnGetProcessListW(dnProgramDesc.lpwszFilename,lpdwProcessList,&dwNumApps);
}
if (hResultCode != DPN_OK) // Some sort of error occurred
{
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
dwProcessId = 0;
for (dw = 0; dw < dwNumApps ; dw++)
{
if (DnCheckMsgQueueWaiting(lpdwProcessList[dw]))
{
if (DnSetMsgQueueWaiting(lpdwProcessList[dw],FALSE,TRUE) == DPN_OK)
{
// This is the process ID of the existing app to connect to !
dwProcessId = lpdwProcessList[dw];
break;
}
}
}
if (dwProcessId == 0) // Could not find an app to connect to - launch a new one
{
dwStrLen = wcslen(dnProgramDesc.lpwszPath) + 1
+ wcslen(dnProgramDesc.lpwszApplicationLauncher) + 1
+ wcslen(dnProgramDesc.lpwszCommandLine) + 1 + DN_LC_ID_STR_LEN + DN_GUID_STR_LEN + 1;
if ((lpwszUnexpanded = (LPWSTR)GLOBALALLOC(dwStrLen*sizeof(WCHAR))) == NULL)
{
DnFreeProgramDesc(&dnProgramDesc);
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_ConnectApplication;
}
*lpwszUnexpanded = L'\0';
if (wcslen(dnProgramDesc.lpwszPath) > 0)
{
wcscpy(lpwszUnexpanded,dnProgramDesc.lpwszPath);
wcscat(lpwszUnexpanded,L"\\");
}
wcscat(lpwszUnexpanded,dnProgramDesc.lpwszApplicationLauncher);
wcscat(lpwszUnexpanded,L" ");
wcscat(lpwszUnexpanded,dnProgramDesc.lpwszCommandLine);
wcscat(lpwszUnexpanded,L" ");
wcscat(lpwszUnexpanded,DN_LC_ID_WSTR);
rpcStatus = CoCreateGuid(&uuid);
if (rpcStatus != RPC_S_OK && rpcStatus != RPC_S_UUID_LOCAL_ONLY)
{
DnFreeProgramDesc(&dnProgramDesc);
hResultCode = DPNERR_GENERIC;
goto EXIT_DNL_ConnectApplication;
}
StringFromGUID(&uuid,lpwszUnexpanded+wcslen(lpwszUnexpanded),DN_GUID_STR_LEN+1);
if (DN_RUNNING_NT) // Unicode on WinNT
{
// Expand environment strings
if ((hResultCode = DnExpandEnvStringW(lpwszUnexpanded,&lpwszCommandLine)) != DPN_OK)
{
DPFX(DPFPREP, 0,"DnExpandEnvStringW() failed [%lX]",hResultCode);
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
if ((hResultCode = DnExpandEnvStringW(dnProgramDesc.lpwszCurrentDirectory,
&lpwszCurrentDirectory)) != DPN_OK)
{
DPFX(DPFPREP, 0,"DnExpandEnvStringW() failed [%lX]",hResultCode);
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
// Set up to Launch application
siW.cb = sizeof(STARTUPINFO);
siW.lpReserved = NULL;
siW.lpDesktop = NULL;
siW.lpTitle = NULL;
siW.dwFlags = (DWORD)NULL;
siW.cbReserved2 = (BYTE)NULL;
siW.lpReserved2 = NULL;
// Launch application (finally !)
if (CreateProcessW(NULL,lpwszCommandLine,NULL,NULL,FALSE,NORMAL_PRIORITY_CLASS,NULL,
lpwszCurrentDirectory,&siW,&pi) == 0)
{
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
}
else // ANSI on Win9x
{
// Convert command line from Unicode to ANSI
if ((lpszUnexpanded = (LPSTR)GLOBALALLOC(dwStrLen)) == NULL)
{
DnFreeProgramDesc(&dnProgramDesc);
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_ConnectApplication;
}
WideToAnsi(lpszUnexpanded,lpwszUnexpanded,dwStrLen);
DPFX(DPFPREP, 7,"Unexpanded Command Line [%s]",lpszUnexpanded);
// Expand command line environment strings
if ((hResultCode = DnExpandEnvStringA(lpszUnexpanded,&lpszCommandLine)) != DPN_OK)
{
DPFX(DPFPREP, 0,"DnExpandEnvStringA() failed [%lX]",hResultCode);
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
DPFX(DPFPREP, 7,"Expanded Command Line [%s]",lpszCommandLine);
// Convert current directory from Unicode to ANSI
GlobalFree(lpszUnexpanded);
lpszUnexpanded = NULL;
dwStrLen = wcslen(dnProgramDesc.lpwszCurrentDirectory);
if ((lpszUnexpanded = (LPSTR)GLOBALALLOC(dwStrLen+1)) == NULL)
{
DnFreeProgramDesc(&dnProgramDesc);
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_ConnectApplication;
}
WideToAnsi(lpszUnexpanded,dnProgramDesc.lpwszCurrentDirectory,dwStrLen+1);
DPFX(DPFPREP, 7,"Unexpanded Current Directory [%s]",lpszUnexpanded);
// Expand current directory environment strings
if ((hResultCode = DnExpandEnvStringA(lpszUnexpanded,&lpszCurrentDirectory)) != DPN_OK)
{
DPFX(DPFPREP, 0,"DnExpandEnvStringA() failed [%lX]",hResultCode);
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
DPFX(DPFPREP, 7,"Expanded Current Directory [%s]",lpszCurrentDirectory);
// Set up to Launch application
siA.cb = sizeof(STARTUPINFO);
siA.lpReserved = NULL;
siA.lpDesktop = NULL;
siA.lpTitle = NULL;
siA.dwFlags = (DWORD)NULL;
siA.cbReserved2 = (BYTE)NULL;
siA.lpReserved2 = NULL;
// Launch application (finally !)
if (CreateProcessA(NULL,lpszCommandLine,NULL,NULL,FALSE,NORMAL_PRIORITY_CLASS,NULL,
lpszCurrentDirectory,&siA,&pi) == 0)
{
DPFERR("CreateProcess() failed !");
hResultCode = DPNERR_CANTLAUNCHAPPLICATION;
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
}
// Get Application Process ID
if ((hResultCode = DnHandShakeAppPid(TRUE,&uuid,&dwProcessId)) != DPN_OK)
{
DPFERR("Hand shake to retrieve App PID failed !");
DnFreeProgramDesc(&dnProgramDesc);
goto EXIT_DNL_ConnectApplication;
}
DPFX(DPFPREP, 0,"Application PID = [0x%08lX]",dwProcessId);
}
DnFreeProgramDesc(&dnProgramDesc);
// Create application handle
if ((lpdnAppHandleEntry = (LPDN_APP_HANDLE_ENTRY)GLOBALALLOC(
sizeof(DN_APP_HANDLE_ENTRY))) == NULL)
{
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_ConnectApplication;
}
lpdnAppHandleEntry->dwAppProcessId = dwProcessId;
if ((lpdnAppHandleEntry->lpmqSendMsgQueue =
(DN_MSG_QUEUE_STRUCT *)GLOBALALLOC(sizeof(DN_MSG_QUEUE_STRUCT))) == NULL)
{
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_ConnectApplication;
}
if ((hResultCode = CreateHandle(lpdnLobbyObject->lphsApplicationHandles,&dwHandle,lpdnAppHandleEntry)) != DPN_OK)
{
goto EXIT_DNL_ConnectApplication;
}
lpdnAppHandleEntry->dwHandle = dwHandle;
lpdnAppHandleEntry->lpvUserApplicationContext = lpvUserApplicationContext;
*lpdwAppId = dwHandle;
// Connect to Application's receive message queue
if ((hResultCode = DnOpenMsgQueue(lpdnAppHandleEntry->lpmqSendMsgQueue,dwProcessId,
DN_MSG_OBJECT_SUFFIX_APPLICATION,DN_MSG_QUEUE_SIZE,(DWORD)NULL)) != DPN_OK)
{
goto EXIT_DNL_ConnectApplication;
}
// Pass lobby client connection info to application
if ((hResultCode = DnSendLcInfo(lpdnAppHandleEntry->lpmqSendMsgQueue,dwHandle,
GetCurrentProcessId())) != DPN_OK)
{
goto EXIT_DNL_ConnectApplication;
}
// Pass connection info - TODO check if valid
DPFX(DPFPREP, 9,"Sending Connection Info ...");
// Get string lengths
dwStrLen = ((wcslen(lpdnConnectionInfo->lpwszPlayerName)+ 1 ) * sizeof(WCHAR))
+ strlen(lpdnConnectionInfo->lpszDNAddressLocalSettings) + 1
+ strlen(lpdnConnectionInfo->lpszDNAddressRemote) + 1
+ sizeof(GUID);
dw = sizeof(DN_MESSAGE_STRUCT) + dwStrLen;
// Create message
if ((lpdnMsg = (LPDN_MESSAGE_STRUCT)GLOBALALLOC(dw)) == NULL)
{
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_ConnectApplication;
}
lpdnMsg->dwMessageType = DN_MSGTYPE_CONNECTION_SETTINGS;
lpdnMsg->dwParam1 = 0;
lpdnMsg->dwParam2 = (wcslen(lpdnConnectionInfo->lpwszPlayerName) + 1) * sizeof(WCHAR);
lpdnMsg->dwParam3 = lpdnMsg->dwParam2 + strlen(lpdnConnectionInfo->lpszDNAddressRemote) + 1;
lpdnMsg->dwParam4 = lpdnMsg->dwParam3 + strlen(lpdnConnectionInfo->lpszDNAddressLocalSettings) + 1;
lpdnMsg->dwTagLen = dwStrLen;
memcpy(&lpdnMsg->cTags + lpdnMsg->dwParam1,lpdnConnectionInfo->lpwszPlayerName,
lpdnMsg->dwParam2);
memcpy(&lpdnMsg->cTags + lpdnMsg->dwParam2,lpdnConnectionInfo->lpszDNAddressRemote,
lpdnMsg->dwParam3-lpdnMsg->dwParam2);
memcpy(&lpdnMsg->cTags + lpdnMsg->dwParam3,lpdnConnectionInfo->lpszDNAddressLocalSettings,
lpdnMsg->dwParam4-lpdnMsg->dwParam3);
memcpy(&lpdnMsg->cTags + lpdnMsg->dwParam4,lpdnConnectionInfo->lpGuidApplication,
dwStrLen-lpdnMsg->dwParam4);
if ((hResultCode = DnSendMsg(lpdnAppHandleEntry->lpmqSendMsgQueue,lpdnMsg,dw,FALSE,
0)) != DPN_OK)
{
GlobalFree(lpdnMsg);
goto EXIT_DNL_ConnectApplication;
}
GlobalFree(lpdnMsg);
EXIT_DNL_ConnectApplication:
if (lpwszUnexpanded != NULL)
GlobalFree(lpwszUnexpanded);
if (lpwszCommandLine != NULL)
GlobalFree(lpwszCommandLine);
if (lpwszCurrentDirectory != NULL)
GlobalFree(lpwszCurrentDirectory);
if (lpszUnexpanded != NULL)
GlobalFree(lpszUnexpanded);
if (lpszCommandLine != NULL)
GlobalFree(lpszCommandLine);
if (lpszCurrentDirectory != NULL)
GlobalFree(lpszCurrentDirectory);
if (lpdwProcessList != NULL)
GlobalFree(lpdwProcessList);
return(hResultCode);
}
// HRESULT DnProcessLcMessage
// LPDIRECTNETLOBBYOBJECT lpdnLobbyObject Pointer to lobby object
// LPVOID lpvUserHandler Pointer to user message handler routine
// LPVOID lpvMsgBuff Pointer to message buffer
// DWORD dwMsgLen Length of message buffer
// DWORD dwId Application ID which sent the message
// LPVOID lpvContext User context value associated with the app ID
//
// Returns
// DPN_OK If the message was processed without incident
// DPNERR_GENERIC If there were any problems from the user supplied handler
//
// Notes
// This function processes messages received by the lobby client from the applications it is connected to.
// One Lobby Client may be connected to one or more applications. Internal messages are processed here,
// and all others are passed to the user supplied message handler.
#undef DPF_MODNAME
#define DPF_MODNAME "DnProcessLcMessage"
HRESULT DnProcessLcMessage(LPDIRECTNETLOBBYOBJECT lpdnLobbyObject,LPVOID lpvUserHandler,
LPVOID lpvMsgBuff, DWORD dwMsgLen,DWORD dwId,LPVOID lpvContext)
{
HRESULT hResultCode = DPN_OK;
LPDN_MESSAGE_STRUCT lpdnMsg;
DPFX(DPFPREP, 9,"Parameters: lpdnLobbyObject [0x%p], lpvUserHandler [0x%p], lpvMsgBuff [0x%p], dwMsgLen [%lx], dwId [%lx], lpvContext [0x%p]",
lpdnLobbyObject,lpvUserHandler,lpvMsgBuff,dwMsgLen,dwId,lpvContext);
lpdnMsg = (LPDN_MESSAGE_STRUCT)lpvMsgBuff;
switch(lpdnMsg->dwMessageType)
{
case DN_MSGTYPE_TERMINATE:
DPFX(DPFPREP, 9,"Received Terminate");
ExitThread(0);
break;
default: // Pass message to user message handler
DPFX(DPFPREP, 9,"User Message ...");
hResultCode = ((LPFNDNLCMESSAGEHANDLER)lpvUserHandler)(dwId,lpvContext,lpdnMsg->dwMessageType,lpdnMsg->dwUserToken,
lpdnMsg->dwParam1,lpdnMsg->dwParam2,lpdnMsg->dwParam3,lpdnMsg->dwParam4,
lpdnMsg->dwTagLen,&(lpdnMsg->cTags));
break;
}
return(hResultCode);
}
// HRESULT DNL_SendToApplication
// LPVOID lpv Interface pointer
// DWORD dwAppId Application ID to send message to
// DWORD dwMessageId Message ID code
// DWORD dwUserToken User supplied token
// DWORD dwParam1
// DWORD dwParam2
// DWORD dwParam3
// DWORD dwParam4
// DWORD dwFlags
// DWORD dwTagLen Length of tags field (in bytes)
// LPVOID lpvTags Tag field
//
// Returns
// DPN_OK If the message was sent without incident
// DPNERR_INVALIDPARAM If there was an invalid parameter
// DPNERR_OUTOFMEMORY If there were any memory allocation problems
// DPNERR_GENERIC If there were any problems
//
// Notes
// This function sends messages from the lobby client to a specified application.
#undef DPF_MODNAME
#define DPF_MODNAME "DNL_SendToApplication"
STDMETHODIMP DNL_SendToApplication(LPVOID lpv,DWORD dwAppId,DWORD dwMessageId,DWORD dwUserToken,
DWORD dwParam1,DWORD dwParam2,DWORD dwParam3,DWORD dwParam4,
DWORD dwFlags,DWORD dwTagLen,LPVOID lpvTags)
{
LPDIRECTNETLOBBYOBJECT lpdnLobbyObject;
HRESULT hResultCode = DPN_OK;
LPDN_APP_HANDLE_ENTRY lpdnAppHandleEntry;
LPDN_MESSAGE_STRUCT lpdnMessage;
DN_MESSAGE_STRUCT dnMessage;
DWORD dwMsgLen;
DPFX(DPFPREP, 9,"Parameters: lpv [%p], dwAppId [%lx], dwMessageId [%lx], dwUserToken [%lx], dwParams [%lx], [%lx], [%lx], [%lx], dwFlags [%lx], dwTagLen [%lx], lpvTags [%p]",
lpv,dwAppId,dwMessageId,dwUserToken,dwParam1,dwParam2,dwParam3,dwParam4,dwFlags,dwTagLen,lpvTags);
// Parameter validation
TRY
{
if (lpv == NULL || dwAppId == 0)
return(DPNERR_INVALIDPARAM);
if (dwFlags != 0)
return(DPNERR_INVALIDFLAGS);
}
EXCEPT (EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Exception encountered validating parameters");
return(DPNERR_INVALIDPARAM);
}
lpdnLobbyObject = (LPDIRECTNETLOBBYOBJECT) GET_OBJECT_FROM_INTERFACE(lpv);
// Ensure app ID is valid, and then retrieve connection (message queue) information for it
if (!IsHandleValid(lpdnLobbyObject->lphsApplicationHandles,dwAppId))
{
hResultCode = DPNERR_INVALIDPARAM;
goto EXIT_DNL_SendToApplication;
}
if ((hResultCode = RetrieveHandleData(lpdnLobbyObject->lphsApplicationHandles,dwAppId,
(LPVOID *)&lpdnAppHandleEntry)) != DPN_OK)
{
goto EXIT_DNL_SendToApplication;
}
dwMsgLen = sizeof(DN_MESSAGE_STRUCT);
if (dwTagLen > 0) // Create buffer if there are tags
{
dwMsgLen += dwTagLen;
if ((lpdnMessage = (LPDN_MESSAGE_STRUCT)GLOBALALLOC(dwMsgLen)) == NULL)
{
hResultCode = DPNERR_OUTOFMEMORY;
goto EXIT_DNL_SendToApplication;
}
}
else // Use default static buffer (avoid malloc call)
{
lpdnMessage = &dnMessage;
}
lpdnMessage->dwMessageType = dwMessageId;
lpdnMessage->dwUserToken = dwUserToken;
lpdnMessage->dwParam1 = dwParam1;
lpdnMessage->dwParam2 = dwParam2;
lpdnMessage->dwParam3 = dwParam3;
lpdnMessage->dwParam4 = dwParam4;
lpdnMessage->dwTagLen = dwTagLen;
if (dwTagLen > 0)
{
memcpy(&(lpdnMessage->cTags),lpvTags,dwTagLen);
}
else
{
lpdnMessage->cTags = '\0';
}
// Send message
hResultCode = DnSendMsg(lpdnAppHandleEntry->lpmqSendMsgQueue,lpdnMessage,dwMsgLen,FALSE,
(DWORD)NULL);
// Free buffer if it was malloc'd
if (dwTagLen > 0)
GlobalFree(lpdnMessage);
EXIT_DNL_SendToApplication:
return(hResultCode);
}
// HRESULT DNL_ReleaseApplication
// LPVOID lpv Interface pointer
// DWORD dwAppId Application ID to release
//
// Returns
// DPN_OK If the message was sent without incident
// DPNERR_INVALIDPARAM If there was an invalid parameter
// DPNERR_INVALIDHANDLE If the application ID is not valid
// DPNERR_GENERIC If there were any problems
//
// Notes
// This function causes the lobby client to terminate it's association with a lobbied
// application (whether the lobby client launched the application or not). This allows the
// application to either terminate gracefully (if still running) and then be made available
// for re-connection to another (or the same) lobby client later. This should be called
// whenever a lobby client is finished with a lobbied application.
#undef DPF_MODNAME
#define DPF_MODNAME "DNL_ReleaseApplication"
STDMETHODIMP DNL_ReleaseApplication(LPVOID lpv,DWORD dwAppId)
{
LPDIRECTNETLOBBYOBJECT lpdnLobbyObject;
HRESULT hResultCode = DPN_OK;
LPDN_APP_HANDLE_ENTRY lph;
DPFX(DPFPREP, 9,"Parameters: lpv [%lx], dwAppId [%lx]", lpv,dwAppId);
// Parameter validation
TRY
{
if (lpv == NULL || dwAppId == 0)
return(DPNERR_INVALIDPARAM);
}
EXCEPT (EXCEPTION_EXECUTE_HANDLER)
{
DPFERR("Exception encountered validating parameters");
return(DPNERR_INVALIDPARAM);
}
lpdnLobbyObject = (LPDIRECTNETLOBBYOBJECT) GET_OBJECT_FROM_INTERFACE(lpv);
// TODO - wait for messages to be processed
if ((hResultCode = RetrieveHandleData(lpdnLobbyObject->lphsApplicationHandles,dwAppId,&lph)) == DPN_OK)
{
if ((hResultCode = DnCloseMsgQueue(lph->lpmqSendMsgQueue)) == DPN_OK)
{
if ((hResultCode = DestroyHandle(lpdnLobbyObject->lphsApplicationHandles,dwAppId)) == DPN_OK)
{
}
}
GlobalFree(lph);
}
//EXIT_DNL_ReleaseApplication:
return(hResultCode);
}
#endif