1793 lines
58 KiB
C++
1793 lines
58 KiB
C++
/*==========================================================================
|
|
*
|
|
* 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
|