dplayx_global.h File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "dplay.h"

Include dependency graph for dplayx_global.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BOOL	DPLAYX_ConstructData (void) DECLSPEC_HIDDEN
BOOL	DPLAYX_DestructData (void) DECLSPEC_HIDDEN
HRESULT	DPLAYX_GetConnectionSettingsA (DWORD dwAppID, LPVOID lpData, LPDWORD lpdwDataSize) DECLSPEC_HIDDEN
HRESULT	DPLAYX_GetConnectionSettingsW (DWORD dwAppID, LPVOID lpData, LPDWORD lpdwDataSize) DECLSPEC_HIDDEN
HRESULT	DPLAYX_SetConnectionSettingsA (DWORD dwFlags, DWORD dwAppID, const DPLCONNECTION *lpConn) DECLSPEC_HIDDEN
HRESULT	DPLAYX_SetConnectionSettingsW (DWORD dwFlags, DWORD dwAppID, const DPLCONNECTION *lpConn) DECLSPEC_HIDDEN
BOOL	DPLAYX_CreateLobbyApplication (DWORD dwAppID) DECLSPEC_HIDDEN
BOOL	DPLAYX_WaitForConnectionSettings (BOOL bWait) DECLSPEC_HIDDEN
BOOL	DPLAYX_AnyLobbiesWaitingForConnSettings (void) DECLSPEC_HIDDEN
BOOL	DPLAYX_SetLobbyHandles (DWORD dwAppID, HANDLE hStart, HANDLE hDeath, HANDLE hConnRead) DECLSPEC_HIDDEN
BOOL	DPLAYX_SetLobbyMsgThreadId (DWORD dwAppId, DWORD dwThreadId) DECLSPEC_HIDDEN
LPCSTR	DPLAYX_HresultToString (HRESULT hr) DECLSPEC_HIDDEN

Function Documentation

DPLAYX_AnyLobbiesWaitingForConnSettings()

BOOL DPLAYX_AnyLobbiesWaitingForConnSettings

(

void

)

Definition at line 1017 of file dplayx_global.c.

{
  UINT i;
  BOOL bFound = FALSE;
 
  DPLAYX_AcquireSemaphore();
 
  for( i=0; i < numSupportedLobbies; i++ )
  {
    if( ( lobbyData[ i ].dwAppID != 0 ) &&            /* lobby initialized */
        ( lobbyData[ i ].bWaitForConnectionSettings ) /* Waiting */
      )
    {
      bFound = TRUE;
      break;
    }
  }
 
  DPLAYX_ReleaseSemaphore();
 
  return bFound;
}

Referenced by IDirectPlayLobby3AImpl_RunApplication().

DPLAYX_ConstructData()

BOOL DPLAYX_ConstructData

(

void

)

Definition at line 357 of file dplayx_global.c.

{
  SECURITY_ATTRIBUTES s_attrib;
  BOOL                bInitializeSharedMemory = FALSE;
  LPVOID              lpDesiredMemoryMapStart = (LPVOID)0x50000000;
  HANDLE              hInformOnStart;
 
  TRACE( "DPLAYX dll loaded - construct called\n" );
 
  /* Create a semaphore to block access to DPLAYX global data structs */
 
  s_attrib.bInheritHandle       = TRUE;
  s_attrib.lpSecurityDescriptor = NULL;
  s_attrib.nLength              = sizeof(s_attrib);
 
  hDplayxSema = CreateSemaphoreA( &s_attrib, 0, 1, lpszDplayxSemaName );
 
  /* First instance creates the semaphore. Others just use it */
  if( GetLastError() == ERROR_SUCCESS )
  {
    TRACE( "Semaphore %p created\n", hDplayxSema );
 
    /* The semaphore creator will also build the shared memory */
    bInitializeSharedMemory = TRUE;
  }
  else if ( GetLastError() == ERROR_ALREADY_EXISTS )
  {
    TRACE( "Found semaphore handle %p\n", hDplayxSema );
    DPLAYX_AcquireSemaphore();
  }
  else
  {
    ERR( ": semaphore error %d\n", GetLastError() );
    return FALSE;
  }
 
  SetLastError( ERROR_SUCCESS );
 
  hDplayxSharedMem = CreateFileMappingA( INVALID_HANDLE_VALUE,
                                         &s_attrib,
                                         PAGE_READWRITE | SEC_COMMIT,
                                         0,
                                         dwTotalSharedSize,
                                         lpszDplayxFileMapping );
 
  if( GetLastError() == ERROR_SUCCESS )
  {
    TRACE( "File mapped %p created\n", hDplayxSharedMem );
  }
  else if ( GetLastError() == ERROR_ALREADY_EXISTS )
  {
    TRACE( "Found FileMapping handle %p\n", hDplayxSharedMem );
  }
  else
  {
    ERR( ": unable to create shared memory (%d)\n", GetLastError() );
    DPLAYX_ReleaseSemaphore();
    return FALSE;
  }
 
  lpSharedStaticData = MapViewOfFileEx( hDplayxSharedMem,
                                        FILE_MAP_WRITE,
                                        0, 0, 0, lpDesiredMemoryMapStart );
 
  if( lpSharedStaticData == NULL )
  {
    ERR( ": unable to map static data into process memory space (%d)\n",
         GetLastError() );
    DPLAYX_ReleaseSemaphore();
    return FALSE;
  }
  else
  {
    if( lpDesiredMemoryMapStart == lpSharedStaticData )
    {
      TRACE( "File mapped to %p\n", lpSharedStaticData );
    }
    else
    {
      /* Presently the shared data structures use pointers. If the
       * files are not mapped into the same area, the pointers will no
       * longer make any sense :(
       * FIXME: In the future make the shared data structures have some
       *        sort of fixup to make them independent between data spaces.
       *        This will also require a rework of the session data stuff.
       */
      ERR( "File mapped to %p (not %p). Expect failure\n",
            lpSharedStaticData, lpDesiredMemoryMapStart );
    }
  }
 
  /* Dynamic area starts just after the static area */
  lpMemArea = (LPVOID)((BYTE*)lpSharedStaticData + dwStaticSharedSize);
 
  /* FIXME: Crude hack */
  lobbyData   = lpSharedStaticData;
  sessionData = (DPSESSIONDESC2*)((BYTE*)lpSharedStaticData + (dwStaticSharedSize/2));
 
  /* Initialize shared data segments. */
  if( bInitializeSharedMemory )
  {
    UINT i;
 
    TRACE( "Initializing shared memory\n" );
 
    /* Set all lobbies to be "empty" */
    for( i=0; i < numSupportedLobbies; i++ )
    {
      DPLAYX_InitializeLobbyDataEntry( &lobbyData[ i ] );
    }
 
    /* Set all sessions to be "empty" */
    for( i=0; i < numSupportedSessions; i++ )
    {
      sessionData[i].dwSize = 0;
    }
 
    /* Zero out the dynamic area */
    ZeroMemory( lpMemArea, dwDynamicSharedSize );
 
    /* Just for fun sync the whole data area */
    FlushViewOfFile( lpSharedStaticData, dwTotalSharedSize );
  }
 
  DPLAYX_ReleaseSemaphore();
 
  /* Everything was created correctly. Signal the lobby client that
   * we started up correctly
   */
  if( DPLAYX_GetThisLobbyHandles( &hInformOnStart, NULL, NULL, FALSE ) &&
      hInformOnStart
    )
  {
    BOOL bSuccess;
    bSuccess = SetEvent( hInformOnStart );
    TRACE( "Signalling lobby app start event %p %s\n",
             hInformOnStart, bSuccess ? "succeed" : "failed" );
 
    /* Close out handle */
    DPLAYX_GetThisLobbyHandles( &hInformOnStart, NULL, NULL, TRUE );
  }
 
  return TRUE;
}

Referenced by DllMain().

DPLAYX_CreateLobbyApplication()

BOOL DPLAYX_CreateLobbyApplication

(

DWORD

dwAppID

)

Definition at line 214 of file dplayx_global.c.

{
  UINT i;
 
  /* 0 is the marker for unused application data slots */
  if( dwAppID == 0 )
  {
    return FALSE;
  }
 
  DPLAYX_AcquireSemaphore();
 
  /* Find an empty space in the list and insert the data */
  for( i=0; i < numSupportedLobbies; i++ )
  {
    if( lobbyData[ i ].dwAppID == 0 )
    {
      /* This process is now lobbied */
      TRACE( "Setting lobbyData[%u] for (0x%08x,0x%08x)\n",
              i, dwAppID, GetCurrentProcessId() );
 
      lobbyData[ i ].dwAppID              = dwAppID;
      lobbyData[ i ].dwAppLaunchedFromID  = GetCurrentProcessId();
 
      /* FIXME: Where is the best place for this? In interface or here? */
      lobbyData[ i ].hInformOnAppStart = 0;
      lobbyData[ i ].hInformOnAppDeath = 0;
      lobbyData[ i ].hInformOnSettingRead = 0;
 
      DPLAYX_ReleaseSemaphore();
      return TRUE;
    }
  }
 
  ERR( "No empty lobbies\n" );
 
  DPLAYX_ReleaseSemaphore();
  return FALSE;
}

Referenced by IDirectPlayLobby3AImpl_RunApplication(), IDirectPlayLobby3AImpl_SetConnectionSettings(), and IDirectPlayLobby3Impl_SetConnectionSettings().

DPLAYX_DestructData()

BOOL DPLAYX_DestructData

(

void

)

Definition at line 506 of file dplayx_global.c.

{
  HANDLE hInformOnDeath;
 
  TRACE( "DPLAYX dll unloaded - destruct called\n" );
 
  /* If required, inform that this app is dying */
  if( DPLAYX_GetThisLobbyHandles( NULL, &hInformOnDeath, NULL, FALSE ) &&
      hInformOnDeath
    )
  {
    BOOL bSuccess;
    bSuccess = SetEvent( hInformOnDeath );
    TRACE( "Signalling lobby app death event %p %s\n",
             hInformOnDeath, bSuccess ? "succeed" : "failed" );
 
    /* Close out handle */
    DPLAYX_GetThisLobbyHandles( NULL, &hInformOnDeath, NULL, TRUE );
  }
 
  /* DO CLEAN UP (LAST) */
 
  /* Delete the semaphore */
  CloseHandle( hDplayxSema );
 
  /* Delete shared memory file mapping */
  UnmapViewOfFile( lpSharedStaticData );
  CloseHandle( hDplayxSharedMem );
 
  return FALSE;
}

Referenced by DllMain().

DPLAYX_GetConnectionSettingsA()

HRESULT DPLAYX_GetConnectionSettingsA	(	DWORD	dwAppID,
		LPVOID	lpData,
		LPDWORD	lpdwDataSize
	)

Definition at line 774 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpDplData;
  DWORD              dwRequiredDataSize = 0;
  HANDLE             hInformOnSettingRead;
 
  DPLAYX_AcquireSemaphore();
 
  if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
  {
    DPLAYX_ReleaseSemaphore();
 
    TRACE( "Application 0x%08x is not lobbied\n", dwAppID );
    return DPERR_NOTLOBBIED;
  }
 
  dwRequiredDataSize = DPLAYX_SizeOfLobbyDataA( lpDplData->lpConn );
 
  /* Do they want to know the required buffer size or is the provided buffer
   * big enough?
   */
  if ( ( lpData == NULL ) ||
       ( *lpdwDataSize < dwRequiredDataSize )
     )
  {
    DPLAYX_ReleaseSemaphore();
 
    *lpdwDataSize = DPLAYX_SizeOfLobbyDataA( lpDplData->lpConn );
 
    return DPERR_BUFFERTOOSMALL;
  }
 
  DPLAYX_CopyConnStructA( lpData, lpDplData->lpConn );
 
  DPLAYX_ReleaseSemaphore();
 
  /* They have gotten the information - signal the event if required */
  if( DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, FALSE ) &&
      hInformOnSettingRead
    )
  {
    BOOL bSuccess;
    bSuccess = SetEvent( hInformOnSettingRead );
    TRACE( "Signalling setting read event %p %s\n",
             hInformOnSettingRead, bSuccess ? "succeed" : "failed" );
 
    /* Close out handle */
    DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, TRUE );
  }
 
  return DP_OK;
}

Referenced by IDirectPlayLobby3AImpl_GetConnectionSettings().

DPLAYX_GetConnectionSettingsW()

HRESULT DPLAYX_GetConnectionSettingsW	(	DWORD	dwAppID,
		LPVOID	lpData,
		LPDWORD	lpdwDataSize
	)

Definition at line 830 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpDplData;
  DWORD              dwRequiredDataSize = 0;
  HANDLE             hInformOnSettingRead;
 
  DPLAYX_AcquireSemaphore();
 
  if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
  {
    DPLAYX_ReleaseSemaphore();
    return DPERR_NOTLOBBIED;
  }
 
  dwRequiredDataSize = DPLAYX_SizeOfLobbyDataW( lpDplData->lpConn );
 
  /* Do they want to know the required buffer size or is the provided buffer
   * big enough?
   */
  if ( ( lpData == NULL ) ||
       ( *lpdwDataSize < dwRequiredDataSize )
     )
  {
    DPLAYX_ReleaseSemaphore();
 
    *lpdwDataSize = DPLAYX_SizeOfLobbyDataW( lpDplData->lpConn );
 
    return DPERR_BUFFERTOOSMALL;
  }
 
  DPLAYX_CopyConnStructW( lpData, lpDplData->lpConn );
 
  DPLAYX_ReleaseSemaphore();
 
  /* They have gotten the information - signal the event if required */
  if( DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, FALSE ) &&
      hInformOnSettingRead
    )
  {
    BOOL bSuccess;
    bSuccess = SetEvent( hInformOnSettingRead );
    TRACE( "Signalling setting read event %p %s\n",
             hInformOnSettingRead, bSuccess ? "succeed" : "failed" );
 
    /* Close out handle */
    DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, TRUE );
  }
 
  return DP_OK;
}

Referenced by IDirectPlayLobby3Impl_GetConnectionSettings().

DPLAYX_HresultToString()

LPCSTR DPLAYX_HresultToString

(

HRESULT

hr

)

Definition at line 1063 of file dplayx_global.c.

{
  static char szTempStr[12];
 
  switch (hr)
  {
    case DP_OK:
      return "DP_OK";
    case DPERR_ALREADYINITIALIZED:
      return "DPERR_ALREADYINITIALIZED";
    case DPERR_ACCESSDENIED:
      return "DPERR_ACCESSDENIED";
    case DPERR_ACTIVEPLAYERS:
      return "DPERR_ACTIVEPLAYERS";
    case DPERR_BUFFERTOOSMALL:
      return "DPERR_BUFFERTOOSMALL";
    case DPERR_CANTADDPLAYER:
      return "DPERR_CANTADDPLAYER";
    case DPERR_CANTCREATEGROUP:
      return "DPERR_CANTCREATEGROUP";
    case DPERR_CANTCREATEPLAYER:
      return "DPERR_CANTCREATEPLAYER";
    case DPERR_CANTCREATESESSION:
      return "DPERR_CANTCREATESESSION";
    case DPERR_CAPSNOTAVAILABLEYET:
      return "DPERR_CAPSNOTAVAILABLEYET";
    case DPERR_EXCEPTION:
      return "DPERR_EXCEPTION";
    case DPERR_GENERIC:
      return "DPERR_GENERIC";
    case DPERR_INVALIDFLAGS:
      return "DPERR_INVALIDFLAGS";
    case DPERR_INVALIDOBJECT:
      return "DPERR_INVALIDOBJECT";
    case DPERR_INVALIDPARAMS:
      return "DPERR_INVALIDPARAMS";
    case DPERR_INVALIDPLAYER:
      return "DPERR_INVALIDPLAYER";
    case DPERR_INVALIDGROUP:
      return "DPERR_INVALIDGROUP";
    case DPERR_NOCAPS:
      return "DPERR_NOCAPS";
    case DPERR_NOCONNECTION:
      return "DPERR_NOCONNECTION";
    case DPERR_OUTOFMEMORY:
      return "DPERR_OUTOFMEMORY";
    case DPERR_NOMESSAGES:
      return "DPERR_NOMESSAGES";
    case DPERR_NONAMESERVERFOUND:
      return "DPERR_NONAMESERVERFOUND";
    case DPERR_NOPLAYERS:
      return "DPERR_NOPLAYERS";
    case DPERR_NOSESSIONS:
      return "DPERR_NOSESSIONS";
    case DPERR_PENDING:
      return "DPERR_PENDING";
    case DPERR_SENDTOOBIG:
      return "DPERR_SENDTOOBIG";
    case DPERR_TIMEOUT:
      return "DPERR_TIMEOUT";
    case DPERR_UNAVAILABLE:
      return "DPERR_UNAVAILABLE";
    case DPERR_UNSUPPORTED:
      return "DPERR_UNSUPPORTED";
    case DPERR_BUSY:
      return "DPERR_BUSY";
    case DPERR_USERCANCEL:
      return "DPERR_USERCANCEL";
    case DPERR_NOINTERFACE:
      return "DPERR_NOINTERFACE";
    case DPERR_CANNOTCREATESERVER:
      return "DPERR_CANNOTCREATESERVER";
    case DPERR_PLAYERLOST:
      return "DPERR_PLAYERLOST";
    case DPERR_SESSIONLOST:
      return "DPERR_SESSIONLOST";
    case DPERR_UNINITIALIZED:
      return "DPERR_UNINITIALIZED";
    case DPERR_NONEWPLAYERS:
      return "DPERR_NONEWPLAYERS";
    case DPERR_INVALIDPASSWORD:
      return "DPERR_INVALIDPASSWORD";
    case DPERR_CONNECTING:
      return "DPERR_CONNECTING";
    case DPERR_CONNECTIONLOST:
      return "DPERR_CONNECTIONLOST";
    case DPERR_UNKNOWNMESSAGE:
      return "DPERR_UNKNOWNMESSAGE";
    case DPERR_CANCELFAILED:
      return "DPERR_CANCELFAILED";
    case DPERR_INVALIDPRIORITY:
      return "DPERR_INVALIDPRIORITY";
    case DPERR_NOTHANDLED:
      return "DPERR_NOTHANDLED";
    case DPERR_CANCELLED:
      return "DPERR_CANCELLED";
    case DPERR_ABORTED:
      return "DPERR_ABORTED";
    case DPERR_BUFFERTOOLARGE:
      return "DPERR_BUFFERTOOLARGE";
    case DPERR_CANTCREATEPROCESS:
      return "DPERR_CANTCREATEPROCESS";
    case DPERR_APPNOTSTARTED:
      return "DPERR_APPNOTSTARTED";
    case DPERR_INVALIDINTERFACE:
      return "DPERR_INVALIDINTERFACE";
    case DPERR_NOSERVICEPROVIDER:
      return "DPERR_NOSERVICEPROVIDER";
    case DPERR_UNKNOWNAPPLICATION:
      return "DPERR_UNKNOWNAPPLICATION";
    case DPERR_NOTLOBBIED:
      return "DPERR_NOTLOBBIED";
    case DPERR_SERVICEPROVIDERLOADED:
      return "DPERR_SERVICEPROVIDERLOADED";
    case DPERR_ALREADYREGISTERED:
      return "DPERR_ALREADYREGISTERED";
    case DPERR_NOTREGISTERED:
      return "DPERR_NOTREGISTERED";
    case DPERR_AUTHENTICATIONFAILED:
      return "DPERR_AUTHENTICATIONFAILED";
    case DPERR_CANTLOADSSPI:
      return "DPERR_CANTLOADSSPI";
    case DPERR_ENCRYPTIONFAILED:
      return "DPERR_ENCRYPTIONFAILED";
    case DPERR_SIGNFAILED:
      return "DPERR_SIGNFAILED";
    case DPERR_CANTLOADSECURITYPACKAGE:
      return "DPERR_CANTLOADSECURITYPACKAGE";
    case DPERR_ENCRYPTIONNOTSUPPORTED:
      return "DPERR_ENCRYPTIONNOTSUPPORTED";
    case DPERR_CANTLOADCAPI:
      return "DPERR_CANTLOADCAPI";
    case DPERR_NOTLOGGEDIN:
      return "DPERR_NOTLOGGEDIN";
    case DPERR_LOGONDENIED:
      return "DPERR_LOGONDENIED";
    default:
      /* For errors not in the list, return HRESULT as a string
         This part is not thread safe */
      WARN( "Unknown error 0x%08x\n", hr );
      wsprintfA( szTempStr, "0x%08x", hr );
      return szTempStr;
  }
}

Referenced by DirectPlayCreate(), DP_BuildSPCompoundAddr(), DP_EnumSessionsSendAsyncRequestThread(), DP_IF_CreatePlayer(), DP_InitializeDPLSP(), DP_InitializeDPSP(), DP_MSG_ErrorReceived(), DP_MSG_ExpectReply(), DP_SecureOpen(), DPL_ConnectEx(), IDirectPlay4AImpl_EnumConnections(), IDirectPlayLobby3AImpl_RunApplication(), IDirectPlaySPImpl_GetSPPlayerData(), and IDirectPlaySPImpl_HandleMessage().

DPLAYX_SetConnectionSettingsA()

HRESULT DPLAYX_SetConnectionSettingsA	(	DWORD	dwFlags,
		DWORD	dwAppID,
		const DPLCONNECTION *	lpConn
	)

Definition at line 888 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpDplData;
 
  /* Parameter check */
  if( dwFlags || !lpConn )
  {
    ERR("invalid parameters.\n");
    return DPERR_INVALIDPARAMS;
  }
 
  /* Store information */
  if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
  {
    ERR(": old/new DPLCONNECTION type? Size=%08x\n", lpConn->dwSize );
 
    return DPERR_INVALIDPARAMS;
  }
 
  DPLAYX_AcquireSemaphore();
 
  if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
  {
    DPLAYX_ReleaseSemaphore();
 
    return DPERR_NOTLOBBIED;
  }
 
  if(  (!lpConn->lpSessionDesc ) ||
       ( lpConn->lpSessionDesc->dwSize != sizeof( DPSESSIONDESC2 ) )
    )
  {
    DPLAYX_ReleaseSemaphore();
 
    ERR("DPSESSIONDESC passed in? Size=%u\n",
        lpConn->lpSessionDesc?lpConn->lpSessionDesc->dwSize:0 );
 
    return DPERR_INVALIDPARAMS;
  }
 
  /* Free the existing memory */
  DPLAYX_PrivHeapFree( lpDplData->lpConn );
 
  lpDplData->lpConn = DPLAYX_PrivHeapAlloc( HEAP_ZERO_MEMORY,
                                            DPLAYX_SizeOfLobbyDataA( lpConn ) );
 
  DPLAYX_CopyConnStructA( lpDplData->lpConn, lpConn );
 
 
  DPLAYX_ReleaseSemaphore();
 
  /* FIXME: Send a message - I think */
 
  return DP_OK;
}

Referenced by IDirectPlayLobby3AImpl_SetConnectionSettings().

DPLAYX_SetConnectionSettingsW()

HRESULT DPLAYX_SetConnectionSettingsW	(	DWORD	dwFlags,
		DWORD	dwAppID,
		const DPLCONNECTION *	lpConn
	)

Definition at line 951 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpDplData;
 
  /* Parameter check */
  if( dwFlags || !lpConn )
  {
    ERR("invalid parameters.\n");
    return DPERR_INVALIDPARAMS;
  }
 
  /* Store information */
  if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
  {
    ERR(": old/new DPLCONNECTION type? Size=%u\n", lpConn->dwSize );
 
    return DPERR_INVALIDPARAMS;
  }
 
  DPLAYX_AcquireSemaphore();
 
  if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
  {
    DPLAYX_ReleaseSemaphore();
 
    return DPERR_NOTLOBBIED;
  }
 
  /* Free the existing memory */
  DPLAYX_PrivHeapFree( lpDplData->lpConn );
 
  lpDplData->lpConn = DPLAYX_PrivHeapAlloc( HEAP_ZERO_MEMORY,
                                            DPLAYX_SizeOfLobbyDataW( lpConn ) );
 
  DPLAYX_CopyConnStructW( lpDplData->lpConn, lpConn );
 
 
  DPLAYX_ReleaseSemaphore();
 
  /* FIXME: Send a message - I think */
 
  return DP_OK;
}

Referenced by IDirectPlayLobby3Impl_SetConnectionSettings().

DPLAYX_SetLobbyHandles()

BOOL DPLAYX_SetLobbyHandles	(	DWORD	dwAppID,
		HANDLE	hStart,
		HANDLE	hDeath,
		HANDLE	hConnRead
	)

Definition at line 254 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpLData;
 
  /* Need to explicitly give lobby application. Can't set for yourself */
  if( dwAppID == 0 )
  {
    return FALSE;
  }
 
  DPLAYX_AcquireSemaphore();
 
  if( !DPLAYX_IsAppIdLobbied( dwAppID, &lpLData ) )
  {
    DPLAYX_ReleaseSemaphore();
    return FALSE;
  }
 
  lpLData->hInformOnAppStart    = hStart;
  lpLData->hInformOnAppDeath    = hDeath;
  lpLData->hInformOnSettingRead = hConnRead;
 
  DPLAYX_ReleaseSemaphore();
 
  return TRUE;
}

Referenced by DPL_CreateAndSetLobbyHandles().

DPLAYX_SetLobbyMsgThreadId()

BOOL DPLAYX_SetLobbyMsgThreadId	(	DWORD	dwAppId,
		DWORD	dwThreadId
	)

Definition at line 1040 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpLobbyData;
 
  DPLAYX_AcquireSemaphore();
 
  if( !DPLAYX_IsAppIdLobbied( dwAppId, &lpLobbyData ) )
  {
    DPLAYX_ReleaseSemaphore();
    return FALSE;
  }
 
  lpLobbyData->dwLobbyMsgThreadId = dwThreadId;
 
  DPLAYX_ReleaseSemaphore();
 
  return TRUE;
}

Referenced by IDirectPlayLobby3AImpl_RunApplication().

DPLAYX_WaitForConnectionSettings()

BOOL DPLAYX_WaitForConnectionSettings

(

BOOL

bWait

)

Definition at line 998 of file dplayx_global.c.

{
  LPDPLAYX_LOBBYDATA lpLobbyData;
 
  DPLAYX_AcquireSemaphore();
 
  if( !DPLAYX_IsAppIdLobbied( 0, &lpLobbyData ) )
  {
    DPLAYX_ReleaseSemaphore();
    return FALSE;
  }
 
  lpLobbyData->bWaitForConnectionSettings = bWait;
 
  DPLAYX_ReleaseSemaphore();
 
  return TRUE;
}

Referenced by IDirectPlayLobby3AImpl_WaitForConnectionSettings(), and IDirectPlayLobby3Impl_WaitForConnectionSettings().