dplay_global.h File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wine/dplaysp.h"
#include "wine/list.h"
#include "lobbysp.h"
#include "dplayx_queue.h"

Include dependency graph for dplay_global.h:

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

Go to the source code of this file.

Classes
struct	DPCONNECTION
struct	tagEnumSessionAsyncCallbackData
struct	tagDP_MSG_REPLY_STRUCT
struct	tagDP_MSG_REPLY_STRUCT_LIST
struct	PlayerData
struct	PlayerList
struct	GroupData
struct	GroupList
struct	DPMSG
struct	tagDirectPlay2Data
struct	IDirectPlayImpl

Typedefs
typedef struct tagEnumSessionAsyncCallbackData	EnumSessionAsyncCallbackData
typedef struct tagDP_MSG_REPLY_STRUCT	DP_MSG_REPLY_STRUCT
typedef struct tagDP_MSG_REPLY_STRUCT *	LPDP_MSG_REPLY_STRUCT
typedef struct tagDP_MSG_REPLY_STRUCT_LIST	DP_MSG_REPLY_STRUCT_LIST
typedef struct tagDP_MSG_REPLY_STRUCT_LIST *	LPDP_MSG_REPLY_STRUCT_LIST
typedef struct PlayerData *	lpPlayerData
typedef struct PlayerList *	lpPlayerList
typedef struct GroupData	GroupData
typedef struct GroupData *	lpGroupData
typedef struct GroupList *	lpGroupList
typedef DWORD	FN_COPY_MESSAGE(DPMSG_GENERIC *genericDst, DPMSG_GENERIC *genericSrc, DWORD genericSize, BOOL ansi)
typedef struct DPMSG *	LPDPMSG
typedef struct tagDirectPlay2Data	DirectPlay2Data
typedef struct IDirectPlayImpl	IDirectPlayImpl

Enumerations
enum	SPSTATE { NO_PROVIDER = 0 , DP_SERVICE_PROVIDER = 1 , DP_LOBBY_PROVIDER = 2 }

Functions
HRESULT	DPL_EnumAddress (LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress, DWORD dwAddressSize, LPVOID lpContext)
HRESULT	DP_HandleMessage (IDirectPlayImpl *This, void *messageBody, DWORD dwMessageBodySize, void *messageHeader, WORD wCommandId, WORD wVersion, void **lplpReply, DWORD *lpdwMsgSize)
DPSESSIONDESC2 *	DP_DuplicateSessionDesc (const DPSESSIONDESC2 *src, BOOL dstAnsi, BOOL srcAnsi)
HRESULT	DP_HandleGameMessage (IDirectPlayImpl *This, void *messageBody, DWORD messageBodySize, DPID fromId, DPID toId)
HRESULT	DP_CreatePlayer (IDirectPlayImpl *This, void *msgHeader, DPID *lpid, DPNAME *lpName, void *data, DWORD dataSize, void *spData, DWORD spDataSize, DWORD dwFlags, HANDLE hEvent, struct PlayerData **playerData, BOOL bAnsi)
HRESULT	DP_CreateGroup (IDirectPlayImpl *This, void *msgHeader, const DPID *lpid, const DPNAME *lpName, void *data, DWORD dataSize, DWORD dwFlags, DPID idParent, BOOL bAnsi)
HRESULT	DP_AddPlayerToGroup (IDirectPlayImpl *This, DPID group, DPID player)
void	DP_FreeConnections (void)
HRESULT	DP_GetSPPlayerData (IDirectPlayImpl *lpDP, DPID idPlayer, void **lplpData)
HRESULT	DP_SetSPPlayerData (IDirectPlayImpl *lpDP, DPID idPlayer, void *lpData)
LPVOID	DPSP_CreateSPPlayerData (void)
HRESULT	dplay_create (REFIID riid, void **ppv)
HRESULT	dplobby_create (REFIID riid, void **ppv)
HRESULT	dplaysp_create (REFIID riid, void **ppv, IDirectPlayImpl *dp)
HRESULT	dplobbysp_create (REFIID riid, void **ppv, IDirectPlayImpl *dp)

Typedef Documentation

DirectPlay2Data

typedef struct tagDirectPlay2Data DirectPlay2Data

DP_MSG_REPLY_STRUCT

typedef struct tagDP_MSG_REPLY_STRUCT DP_MSG_REPLY_STRUCT

DP_MSG_REPLY_STRUCT_LIST

typedef struct tagDP_MSG_REPLY_STRUCT_LIST DP_MSG_REPLY_STRUCT_LIST

EnumSessionAsyncCallbackData

typedef struct tagEnumSessionAsyncCallbackData EnumSessionAsyncCallbackData

FN_COPY_MESSAGE

typedef DWORD FN_COPY_MESSAGE(DPMSG_GENERIC *genericDst, DPMSG_GENERIC *genericSrc, DWORD genericSize, BOOL ansi)

Definition at line 150 of file dplay_global.h.

GroupData

typedef struct GroupData GroupData

Definition at line 139 of file dplay_global.h.

IDirectPlayImpl

typedef struct IDirectPlayImpl IDirectPlayImpl

LPDP_MSG_REPLY_STRUCT

typedef struct tagDP_MSG_REPLY_STRUCT * LPDP_MSG_REPLY_STRUCT

LPDP_MSG_REPLY_STRUCT_LIST

typedef struct tagDP_MSG_REPLY_STRUCT_LIST * LPDP_MSG_REPLY_STRUCT_LIST

LPDPMSG

typedef struct DPMSG* LPDPMSG

Definition at line 162 of file dplay_global.h.

lpGroupData

typedef struct GroupData* lpGroupData

Definition at line 140 of file dplay_global.h.

lpGroupList

typedef struct GroupList* lpGroupList

Definition at line 148 of file dplay_global.h.

lpPlayerData

typedef struct PlayerData* lpPlayerData

Definition at line 100 of file dplay_global.h.

lpPlayerList

typedef struct PlayerList* lpPlayerList

Definition at line 108 of file dplay_global.h.

Enumeration Type Documentation

SPSTATE

enum SPSTATE

Enumerator
NO_PROVIDER
DP_SERVICE_PROVIDER
DP_LOBBY_PROVIDER

Definition at line 164 of file dplay_global.h.

{
  NO_PROVIDER = 0,
  DP_SERVICE_PROVIDER = 1,
  DP_LOBBY_PROVIDER = 2
};

Function Documentation

DP_AddPlayerToGroup()

HRESULT DP_AddPlayerToGroup	(	IDirectPlayImpl *	This,
		DPID	group,
		DPID	player
	)

Definition at line 1210 of file dplay.c.

{
    DPMSG_ADDPLAYERTOGROUP addPlayerToGroupMsg;
    lpGroupData  gdata;
    lpPlayerList plist;
    lpPlayerList newplist;
    HRESULT hr;
 
    /* Find the group */
    if ( ( gdata = DP_FindAnyGroup( This, group ) ) == NULL )
        return DPERR_INVALIDGROUP;
 
    /* Find the player */
    if ( ( plist = DP_FindPlayer( This, player ) ) == NULL )
        return DPERR_INVALIDPLAYER;
 
    /* Create a player list (ie "shortcut" ) */
    newplist = calloc( 1, sizeof( *newplist ) );
    if ( !newplist )
        return DPERR_CANTADDPLAYER;
 
    /* Add the shortcut */
    plist->lpPData->uRef++;
    newplist->lpPData = plist->lpPData;
 
    /* Add the player to the list of players for this group */
    DPQ_INSERT(gdata->players, newplist, players);
 
    /* Let the SP know that we've added a player to the group */
    if ( This->dp2->spData.lpCB->AddPlayerToGroup )
    {
        DPSP_ADDPLAYERTOGROUPDATA data;
 
        TRACE( "Calling SP AddPlayerToGroup\n" );
 
        data.idPlayer = player;
        data.idGroup  = group;
        data.lpISP    = This->dp2->spData.lpISP;
 
        hr = (*This->dp2->spData.lpCB->AddPlayerToGroup)( &data );
        if ( FAILED( hr ) )
        {
            DPQ_REMOVE( gdata->players, newplist, players );
            --plist->lpPData->uRef;
            free( newplist );
            return hr;
        }
    }
 
    addPlayerToGroupMsg.dwType = DPSYS_ADDPLAYERTOGROUP;
    addPlayerToGroupMsg.dpIdGroup = group;
    addPlayerToGroupMsg.dpIdPlayer = player;
 
    hr = DP_QueueMessage( This, DPID_SYSMSG, DPID_ALLPLAYERS, 0, &addPlayerToGroupMsg,
                          DP_CopyGeneric, sizeof( DPMSG_ADDPLAYERTOGROUP ) );
    if ( FAILED( hr ) )
    {
        if ( This->dp2->spData.lpCB->RemovePlayerFromGroup )
        {
            DPSP_REMOVEPLAYERFROMGROUPDATA data;
            data.idPlayer = player;
            data.idGroup = group;
            data.lpISP = This->dp2->spData.lpISP;
            This->dp2->spData.lpCB->RemovePlayerFromGroup( &data );
        }
        DPQ_REMOVE( gdata->players, newplist, players );
        --plist->lpPData->uRef;
        free( newplist );
        return hr;
    }
 
    return DP_OK;

Referenced by DP_MSG_ForwardPlayerCreation(), and IDirectPlay4Impl_AddPlayerToGroup().

DP_CreateGroup()

HRESULT DP_CreateGroup	(	IDirectPlayImpl *	This,
		void *	msgHeader,
		const DPID *	lpid,
		const DPNAME *	lpName,
		void *	data,
		DWORD	dataSize,
		DWORD	dwFlags,
		DPID	idParent,
		BOOL	bAnsi
	)

Definition at line 1386 of file dplay.c.

{
  struct GroupList *groupList = NULL;
  struct GroupData *parent = NULL;
  lpGroupData lpGData;
  HRESULT hr;
 
  if( DPID_SYSTEM_GROUP != *lpid )
  {
    parent = DP_FindAnyGroup( This, idParent );
    if( !parent )
      return DPERR_INVALIDGROUP;
  }
 
  /* Allocate the new space and add to end of high level group list */
  lpGData = calloc( 1, sizeof( *lpGData ) );
 
  if( lpGData == NULL )
  {
    return DPERR_OUTOFMEMORY;
  }
 
  DPQ_INIT(lpGData->groups);
  DPQ_INIT(lpGData->players);
 
  /* Set the desired player ID - no sanity checking to see if it exists */
  lpGData->dpid = *lpid;
 
  lpGData->name = DP_DuplicateName( lpName, FALSE, bAnsi );
  if ( !lpGData->name )
  {
    free( lpGData );
    return DPERR_OUTOFMEMORY;
  }
 
  lpGData->nameA = DP_DuplicateName( lpName, TRUE, bAnsi );
  if ( !lpGData->nameA )
  {
    free( lpGData->name );
    free( lpGData );
    return DPERR_OUTOFMEMORY;
  }
 
  lpGData->parent = idParent;
 
  /* FIXME: Should we validate the dwFlags? */
  lpGData->dwFlags = dwFlags;
 
  /* Initialize the SP data section */
  lpGData->lpSPPlayerData = DPSP_CreateSPPlayerData();
  if ( !lpGData->lpSPPlayerData )
  {
    free( lpGData->nameA );
    free( lpGData->name );
    free( lpGData );
    return DPERR_OUTOFMEMORY;
  }
 
  if( DPID_SYSTEM_GROUP == *lpid )
  {
    This->dp2->lpSysGroup = lpGData;
    TRACE( "Inserting system group\n" );
  }
  else
  {
    /* Insert into the parent group */
    groupList = calloc( 1, sizeof( *groupList ) );
    if( !groupList )
    {
      free( lpGData->nameA );
      free( lpGData->name );
      free( lpGData );
      return DPERR_OUTOFMEMORY;
    }
    groupList->lpGData = lpGData;
 
    DPQ_INSERT( parent->groups, groupList, groups );
  }
 
  /* Something is now referencing this data */
  lpGData->uRef++;
 
  DP_SetGroupData( lpGData, DPSET_REMOTE, data, dataSize );
 
  /* FIXME: We should only create the system group if GetCaps returns
   *        DPCAPS_GROUPOPTIMIZED.
   */
 
  /* Let the SP know that we've created this group */
  if( This->dp2->spData.lpCB->CreateGroup )
  {
    DPSP_CREATEGROUPDATA data;
    DWORD dwCreateFlags = 0;
 
    TRACE( "Calling SP CreateGroup\n" );
 
    if( !parent )
      dwCreateFlags |= DPLAYI_GROUP_SYSGROUP;
 
    if( !msgHeader )
      dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
 
    if( dwFlags & DPGROUP_HIDDEN )
      dwCreateFlags |= DPLAYI_GROUP_HIDDEN;
 
    data.idGroup           = *lpid;
    data.dwFlags           = dwCreateFlags;
    data.lpSPMessageHeader = msgHeader;
    data.lpISP             = This->dp2->spData.lpISP;
 
    hr = (*This->dp2->spData.lpCB->CreateGroup)( &data );
    if( FAILED( hr ) )
    {
      if( groupList )
      {
        DPQ_REMOVE( parent->groups, groupList, groups );
        free( groupList );
      }
      else
      {
        This->dp2->lpSysGroup = NULL;
      }
      free( lpGData->nameA );
      free( lpGData->name );
      free( lpGData );
      return hr;
    }
  }
 
  TRACE( "Created group id 0x%08lx\n", *lpid );
 
  return DP_OK;

Referenced by DP_IF_CreateGroup(), DP_IF_CreateGroupInGroup(), and DP_MSG_ForwardPlayerCreation().

DP_CreatePlayer()

HRESULT DP_CreatePlayer	(	IDirectPlayImpl *	This,
		void *	msgHeader,
		DPID *	lpid,
		DPNAME *	lpName,
		void *	data,
		DWORD	dataSize,
		void *	spData,
		DWORD	spDataSize,
		DWORD	dwFlags,
		HANDLE	hEvent,
		struct PlayerData **	playerData,
		BOOL	bAnsi
	)

Definition at line 1823 of file dplay.c.

{
  lpPlayerData lpPData;
  lpPlayerList lpPList;
  HRESULT hr;
 
  TRACE( "(%p)->(%p,%p,%u)\n", This, lpid, lpName, bAnsi );
 
  /* Allocate the storage for the player and associate it with list element */
  lpPData = calloc( 1, sizeof( *lpPData ) );
  if( lpPData == NULL )
    return DPERR_OUTOFMEMORY;
 
  /* Set the desired player ID */
  lpPData->dpid = *lpid;
 
  lpPData->name = DP_DuplicateName( lpName, FALSE, bAnsi );
  if ( !lpPData->name )
  {
    free( lpPData );
    return DPERR_OUTOFMEMORY;
  }
 
  lpPData->nameA = DP_DuplicateName( lpName, TRUE, bAnsi );
  if ( !lpPData->nameA )
  {
    free( lpPData->name );
    free( lpPData );
    return DPERR_OUTOFMEMORY;
  }
 
  lpPData->dwFlags = dwFlags;
 
  /* If we were given an event handle, duplicate it */
  if( hEvent != 0 )
  {
    if( !DuplicateHandle( GetCurrentProcess(), hEvent,
                          GetCurrentProcess(), &lpPData->hEvent,
                          0, FALSE, DUPLICATE_SAME_ACCESS )
      )
    {
      /* FIXME: Memory leak */
      ERR( "Can't duplicate player msg handle %p\n", hEvent );
    }
  }
 
  /* Initialize the SP data section */
  lpPData->lpSPPlayerData = DPSP_CreateSPPlayerData();
 
  /* Create the list object and link it in */
  lpPList = calloc( 1, sizeof( *lpPList ) );
  if( !lpPList )
  {
    free( lpPData->lpSPPlayerData );
    CloseHandle( lpPData->hEvent );
    free( lpPData->nameA );
    free( lpPData->name );
    free( lpPData );
    return DPERR_OUTOFMEMORY;
  }
 
  lpPData->uRef = 1;
  lpPList->lpPData = lpPData;
 
  /* Add the player to the system group */
  DPQ_INSERT( This->dp2->lpSysGroup->players, lpPList, players );
 
  DP_SetPlayerData( lpPData, DPSET_REMOTE, data, dataSize );
 
  hr = IDirectPlaySP_SetSPPlayerData( This->dp2->spData.lpISP, *lpid, spData, spDataSize,
                                      DPSET_REMOTE );
  if ( FAILED( hr ) )
  {
    free( lpPData->lpRemoteData );
    DPQ_REMOVE( This->dp2->lpSysGroup->players, lpPList, players );
    free( lpPList );
    free( lpPData->lpSPPlayerData );
    CloseHandle( lpPData->hEvent );
    free( lpPData->nameA );
    free( lpPData->name );
    free( lpPData );
    return hr;
  }
 
  hr = DP_CreateSPPlayer( This, *lpid, dwFlags, msgHeader );
  if ( FAILED( hr ) )
  {
    free( lpPData->lpRemoteData );
    DPQ_REMOVE( This->dp2->lpSysGroup->players, lpPList, players );
    free( lpPList );
    free( lpPData->lpSPPlayerData );
    CloseHandle( lpPData->hEvent );
    free( lpPData->nameA );
    free( lpPData->name );
    free( lpPData );
    return hr;
  }
 
  if( ~dwFlags & DPLAYI_PLAYER_SYSPLAYER )
  {
    DPMSG_CREATEPLAYERORGROUP msg;
    DWORD currentPlayers;
 
    currentPlayers = This->dp2->lpSessionDesc->dwCurrentPlayers;
    if ( ~dwFlags & DPLAYI_PLAYER_PLAYERLOCAL )
        ++currentPlayers;
 
    msg.dwType = DPSYS_CREATEPLAYERORGROUP;
    msg.dwPlayerType = DPPLAYERTYPE_PLAYER;
    msg.dpId = *lpid;
    msg.dwCurrentPlayers = currentPlayers;
    msg.lpData = data;
    msg.dwDataSize = dataSize;
    msg.dpnName = *lpPData->name;
    msg.dpIdParent = 0;
    msg.dwFlags = dwFlags;
 
    hr = DP_QueueMessage( This, DPID_SYSMSG, DPID_ALLPLAYERS, *lpid, &msg,
                          DP_CopyCreatePlayerOrGroup, 0 );
    if ( FAILED( hr ) )
    {
        DP_DeleteSPPlayer( This, *lpid );
        free( lpPData->lpLocalData );
        free( lpPData->lpRemoteData );
        DPQ_REMOVE( This->dp2->lpSysGroup->players, lpPList, players );
        free( lpPList );
        CloseHandle( lpPData->hEvent );
        free( lpPData->nameA );
        free( lpPData->name );
        free( lpPData );
        return hr;
    }
 
    This->dp2->lpSessionDesc->dwCurrentPlayers++;
  }
 
  TRACE( "Created player id 0x%08lx\n", *lpid );
 
  if( playerData )
    *playerData = lpPData;
 
  return DP_OK;

Referenced by DP_HandleMessage(), DP_IF_CreatePlayer(), DP_MSG_ForwardPlayerCreation(), and DP_SecureOpen().

DP_DuplicateSessionDesc()

DPSESSIONDESC2 * DP_DuplicateSessionDesc	(	const DPSESSIONDESC2 *	src,
		BOOL	dstAnsi,
		BOOL	srcAnsi
	)

Definition at line 4579 of file dplay.c.

{
    DPSESSIONDESC2 *dst;
    DWORD size;
 
    size = DP_CopySessionDesc( NULL, src, dstAnsi, srcAnsi );
 
    dst = malloc( size );
    if ( !dst )
        return NULL;
 
    DP_CopySessionDesc( dst, src, dstAnsi, srcAnsi );
 
    return dst;

Referenced by DP_SecureOpen(), DP_SetSessionDesc(), and NS_AddRemoteComputerAsNameServer().

DP_FreeConnections()

void DP_FreeConnections

(

void

)

Definition at line 5133 of file dplay.c.

{
    struct list *connections;
 
    if ( !connectionsInitialized )
        return;
 
    connections = DP_GetConnections();
 
    while ( !list_empty( connections ) )
    {
        DPCONNECTION *connection = LIST_ENTRY( list_tail( connections ), DPCONNECTION, entry );
 
        list_remove( &connection->entry );
        free( connection->nameA.lpszShortNameA );
        free( connection->name.lpszShortName );
        free( connection->path );
        free( connection->address );
        free( connection );
    }

Referenced by DllMain().

DP_GetSPPlayerData()

HRESULT DP_GetSPPlayerData	(	IDirectPlayImpl *	lpDP,
		DPID	idPlayer,
		void **	lplpData
	)

Definition at line 6462 of file dplay.c.

{
  struct GroupData *group;
  lpPlayerList lpPlayer;
 
  EnterCriticalSection( &lpDP->lock );
 
  lpPlayer = DP_FindPlayer( lpDP, idPlayer );
  if( lpPlayer )
  {
    *lplpData = lpPlayer->lpPData->lpSPPlayerData;
    LeaveCriticalSection( &lpDP->lock );
    return DP_OK;
  }
 
  group = DP_FindAnyGroup( lpDP, idPlayer );
  if( group )
  {
    *lplpData = group->lpSPPlayerData;
    LeaveCriticalSection( &lpDP->lock );
    return DP_OK;
  }
 
  LeaveCriticalSection( &lpDP->lock );
 
  return DPERR_INVALIDPLAYER;

Referenced by IDirectPlaySPImpl_GetSPPlayerData(), and IDirectPlaySPImpl_SetSPPlayerData().

DP_HandleGameMessage()

HRESULT DP_HandleGameMessage	(	IDirectPlayImpl *	This,
		void *	messageBody,
		DWORD	messageBodySize,
		DPID	fromId,
		DPID	toId
	)

Definition at line 695 of file dplay.c.

{
  DPMSG_GENERIC *msg;
  DWORD msgSize;
  HRESULT hr;
 
  TRACE( "(%p)->(%p,0x%08lx,0x%08lx,0x%08lx)\n", This, messageBody, messageBodySize, fromId, toId );
 
  msg = (DPMSG_GENERIC *) ((char *) messageBody + sizeof( DPMSG_SYSMSGENVELOPE ));
  msgSize = messageBodySize - sizeof( DPMSG_SYSMSGENVELOPE );
 
  EnterCriticalSection( &This->lock );
 
  hr = DP_QueueMessage( This, fromId, toId, 0, msg, DP_CopyGeneric, msgSize );
 
  LeaveCriticalSection( &This->lock );
 
  return hr;

Referenced by IDirectPlaySPImpl_HandleMessage().

DP_HandleMessage()

HRESULT DP_HandleMessage	(	IDirectPlayImpl *	This,
		void *	messageBody,
		DWORD	dwMessageBodySize,
		void *	messageHeader,
		WORD	wCommandId,
		WORD	wVersion,
		void **	lplpReply,
		DWORD *	lpdwMsgSize
	)

Definition at line 453 of file dplay.c.

{
  TRACE( "(%p)->(%p,0x%08lx,%p,%u,%u)\n",
         This, messageBody, dwMessageBodySize, messageHeader, wCommandId,
         wVersion );
 
  switch( wCommandId )
  {
    /* Name server needs to handle this request */
    case DPMSGCMD_ENUMSESSIONSREQUEST:
      /* Reply expected */
      NS_ReplyToEnumSessionsRequest( messageBody, lplpReply, lpdwMsgSize, This );
      break;
 
    /* Name server needs to handle this request */
    case DPMSGCMD_ENUMSESSIONSREPLY:
      EnterCriticalSection( &This->lock );
 
      /* No reply expected */
      NS_AddRemoteComputerAsNameServer( messageHeader,
                                        This->dp2->spData.dwSPHeaderSize,
                                        messageBody,
                                        dwMessageBodySize,
                                        This->dp2->lpNameServerData );
 
      LeaveCriticalSection( &This->lock );
      break;
 
    case DPMSGCMD_REQUESTNEWPLAYERID:
    {
      LPCDPMSG_REQUESTNEWPLAYERID lpcMsg = messageBody;
 
      LPDPMSG_NEWPLAYERIDREPLY lpReply;
 
      *lpdwMsgSize = This->dp2->spData.dwSPHeaderSize + sizeof( *lpReply );
 
      *lplpReply = calloc( 1, *lpdwMsgSize );
 
      FIXME( "Ignoring dwFlags 0x%08lx in request msg\n",
             lpcMsg->dwFlags );
 
      /* Setup the reply */
      lpReply = (LPDPMSG_NEWPLAYERIDREPLY)( (BYTE*)(*lplpReply) +
                                            This->dp2->spData.dwSPHeaderSize );
 
      lpReply->envelope.dwMagic    = DPMSGMAGIC_DPLAYMSG;
      lpReply->envelope.wCommandId = DPMSGCMD_NEWPLAYERIDREPLY;
      lpReply->envelope.wVersion   = DPMSGVER_DP6;
 
      lpReply->dpidNewPlayerId = DP_NextObjectId();
 
      TRACE( "Allocating new playerid 0x%08lx from remote request\n",
             lpReply->dpidNewPlayerId );
      break;
    }
 
    case DPMSGCMD_CREATESESSION: {
      DPMSG_CREATESESSION *msg;
      DPPLAYERINFO playerInfo;
      DWORD offset = 0;
      HRESULT hr;
 
      if( dwMessageBodySize < sizeof( DPMSG_CREATESESSION ) )
        return DPERR_GENERIC;
      msg = (DPMSG_CREATESESSION *)messageBody;
      offset += sizeof( DPMSG_CREATESESSION );
 
      hr = DP_MSG_ReadPackedPlayer( (char *)messageBody, &offset, dwMessageBodySize, &playerInfo );
      if ( FAILED( hr ) )
        return hr;
 
      if ( dwMessageBodySize - offset < 6 )
        return DPERR_GENERIC;
 
      EnterCriticalSection( &This->lock );
 
      if ( !This->dp2->bConnectionOpen )
      {
        LeaveCriticalSection( &This->lock );
        return DP_OK;
      }
 
      hr = DP_CreatePlayer( This, messageHeader, &msg->playerId, &playerInfo.name,
                            playerInfo.playerData, playerInfo.playerDataLength, playerInfo.spData,
                            playerInfo.spDataLength, playerInfo.flags & ~DPLAYI_PLAYER_PLAYERLOCAL,
                            NULL, NULL, FALSE );
 
      if ( FAILED( hr ) )
      {
        LeaveCriticalSection( &This->lock );
        return hr;
      }
 
      LeaveCriticalSection( &This->lock );
 
      break;
    }
 
    case DPMSGCMD_GETNAMETABLEREPLY:
    case DPMSGCMD_NEWPLAYERIDREPLY:
    case DPMSGCMD_FORWARDADDPLAYERNACK:
    case DPMSGCMD_SUPERENUMPLAYERSREPLY:
      DP_MSG_ReplyReceived( This, wCommandId, messageBody, dwMessageBodySize, messageHeader );
      break;
 
    case DPMSGCMD_GROUPDATACHANGED: {
      DPMSG_SETPLAYERORGROUPDATA setPlayerOrGroupDataMsg;
      DPSP_MSG_GROUPDATACHANGED *msg;
      struct GroupData *group;
      HRESULT hr;
      void *data;
 
      if( dwMessageBodySize < sizeof( DPSP_MSG_GROUPDATACHANGED ) )
        return DPERR_GENERIC;
      msg = (DPSP_MSG_GROUPDATACHANGED *)messageBody;
 
      if( dwMessageBodySize < msg->dataOffset )
        return DPERR_GENERIC;
      if( dwMessageBodySize - msg->dataOffset < msg->dataSize )
        return DPERR_GENERIC;
      data = (char *)messageBody + msg->dataOffset;
 
      EnterCriticalSection( &This->lock );
 
      if( !This->dp2->bConnectionOpen )
      {
        LeaveCriticalSection( &This->lock );
        return DP_OK;
      }
 
      group = DP_FindAnyGroup( This, msg->groupId );
      if( !group )
      {
        LeaveCriticalSection( &This->lock );
        return DPERR_GENERIC;
      }
 
      DP_SetGroupData( group, DPSET_REMOTE, data, msg->dataSize );
 
      setPlayerOrGroupDataMsg.dwType = DPSYS_SETPLAYERORGROUPDATA;
      setPlayerOrGroupDataMsg.dwPlayerType = DPPLAYERTYPE_GROUP;
      setPlayerOrGroupDataMsg.dpId = msg->groupId;
      setPlayerOrGroupDataMsg.lpData = data;
      setPlayerOrGroupDataMsg.dwDataSize = msg->dataSize;
 
      hr = DP_QueueMessage( This, DPID_SYSMSG, DPID_ALLPLAYERS, 0, &setPlayerOrGroupDataMsg,
                            DP_CopySetPlayerOrGroupData, 0 );
      if ( FAILED( hr ) )
      {
        LeaveCriticalSection( &This->lock );
        return hr;
      }
 
      LeaveCriticalSection( &This->lock );
 
      break;
    }
 
    case DPMSGCMD_JUSTENVELOPE:
      TRACE( "GOT THE SELF MESSAGE: %p -> 0x%08lx\n", messageHeader, ((const DWORD *)messageHeader)[1] );
      NS_SetLocalAddr( This->dp2->lpNameServerData, messageHeader, 20 );
      DP_MSG_ReplyReceived( This, wCommandId, messageBody, dwMessageBodySize, messageHeader );
 
    case DPMSGCMD_FORWARDADDPLAYER:
      TRACE( "Sending message to self to get my addr\n" );
      DP_MSG_ToSelf( This, 1 ); /* This is a hack right now */
      break;
 
    case DPMSGCMD_PING: {
      const DPSP_MSG_PING *msg;
 
      if( dwMessageBodySize < sizeof( DPSP_MSG_PING ) )
        return DPERR_GENERIC;
      msg = (const DPSP_MSG_PING *)messageBody;
 
      EnterCriticalSection( &This->lock );
 
      if ( !This->dp2->bConnectionOpen )
      {
        LeaveCriticalSection( &This->lock );
        return DP_OK;
      }
 
      LeaveCriticalSection( &This->lock );
 
      DP_MSG_SendPingReply( This, msg->fromId, This->dp2->systemPlayerId, msg->tickCount );
 
      break;
    }
 
    case DPMSGCMD_ADDFORWARD: {
      DPSP_MSG_ADDFORWARD *msg;
      DPPLAYERINFO playerInfo;
      DWORD offset = 0;
      HRESULT hr;
 
      if( dwMessageBodySize < sizeof( DPSP_MSG_ADDFORWARD ) )
        return DPERR_GENERIC;
      msg = (DPSP_MSG_ADDFORWARD *) messageBody;
      offset += sizeof( DPSP_MSG_ADDFORWARD );
 
      hr = DP_MSG_ReadPackedPlayer( (char *) messageBody, &offset, dwMessageBodySize, &playerInfo );
      if ( FAILED( hr ) )
        return hr;
 
      EnterCriticalSection( &This->lock );
 
      if ( !This->dp2->bConnectionOpen )
      {
        LeaveCriticalSection( &This->lock );
        return DP_OK;
      }
 
      hr = DP_CreatePlayer( This, messageHeader, &msg->playerId, &playerInfo.name,
                            playerInfo.playerData, playerInfo.playerDataLength, playerInfo.spData,
                            playerInfo.spDataLength, playerInfo.flags & ~DPLAYI_PLAYER_PLAYERLOCAL,
                            NULL, NULL, FALSE );
      if ( FAILED( hr ) )
      {
        LeaveCriticalSection( &This->lock );
        return hr;
      }
 
      LeaveCriticalSection( &This->lock );
 
      DP_MSG_SendAddForwardAck( This, msg->playerId );
 
      break;
    }
 
    default:
      FIXME( "Unknown wCommandId %u. Ignoring message\n", wCommandId );
      break;
  }
 
  /* FIXME: There is code in dplaysp.c to handle dplay commands. Move to here. */
 
  return DP_OK;

Referenced by IDirectPlaySPImpl_HandleMessage().

DP_SetSPPlayerData()

HRESULT DP_SetSPPlayerData	(	IDirectPlayImpl *	lpDP,
		DPID	idPlayer,
		void *	lpData
	)

Definition at line 6490 of file dplay.c.

{
  struct GroupData *group;
  lpPlayerList lpPlayer;
 
  EnterCriticalSection( &lpDP->lock );
 
  lpPlayer = DP_FindPlayer( lpDP, idPlayer );
  if( lpPlayer )
  {
    lpPlayer->lpPData->lpSPPlayerData = lpData;
    LeaveCriticalSection( &lpDP->lock );
    return DP_OK;
  }
 
  group = DP_FindAnyGroup( lpDP, idPlayer );
  if( group )
  {
    group->lpSPPlayerData = lpData;
    LeaveCriticalSection( &lpDP->lock );
    return DP_OK;
  }
 
  LeaveCriticalSection( &lpDP->lock );
 
  return DPERR_INVALIDPLAYER;

Referenced by IDirectPlaySPImpl_SetSPPlayerData().

DPL_EnumAddress()

HRESULT DPL_EnumAddress	(	LPDPENUMADDRESSCALLBACK	lpEnumAddressCallback,
		LPCVOID	lpAddress,
		DWORD	dwAddressSize,
		LPVOID	lpContext
	)

Definition at line 368 of file dplobby.c.

{
  DWORD dwTotalSizeEnumerated = 0;
 
  /* FIXME: First chunk is always the total size chunk - Should we report it? */
 
  while ( dwTotalSizeEnumerated < dwAddressSize )
  {
    const DPADDRESS* lpElements = lpAddress;
    DWORD dwSizeThisEnumeration;
 
    /* Invoke the enum method. If false is returned, stop enumeration */
    if ( !lpEnumAddressCallback( &lpElements->guidDataType,
                                 lpElements->dwDataSize,
                                 (const BYTE *)lpElements + sizeof( DPADDRESS ),
                                 lpContext ) )
    {
      break;
    }
 
    dwSizeThisEnumeration  = sizeof( DPADDRESS ) + lpElements->dwDataSize;
    lpAddress = (const BYTE*) lpAddress + dwSizeThisEnumeration;
    dwTotalSizeEnumerated += dwSizeThisEnumeration;
  }
 
  return DP_OK;
}

Referenced by IDirectPlay4Impl_InitializeConnection(), IDirectPlayLobby3AImpl_EnumAddress(), IDirectPlayLobby3Impl_EnumAddress(), and IDirectPlaySPImpl_EnumAddress().

dplay_create()

HRESULT dplay_create	(	REFIID	riid,
		void **	ppv
	)

Definition at line 6428 of file dplay.c.

{
    IDirectPlayImpl *obj;
    HRESULT hr;
 
    TRACE( "(%s, %p)\n", debugstr_guid( riid ), ppv );
 
    *ppv = NULL;
    obj = malloc( sizeof( *obj ) );
    if ( !obj )
        return DPERR_OUTOFMEMORY;
 
    obj->IDirectPlay_iface.lpVtbl = &dp_vt;
    obj->IDirectPlay2A_iface.lpVtbl = &dp2A_vt;
    obj->IDirectPlay2_iface.lpVtbl = &dp2_vt;
    obj->IDirectPlay3A_iface.lpVtbl = &dp3A_vt;
    obj->IDirectPlay3_iface.lpVtbl = &dp3_vt;
    obj->IDirectPlay4A_iface.lpVtbl = &dp4A_vt;
    obj->IDirectPlay4_iface.lpVtbl = &dp4_vt;
    obj->ref = 1;
 
    InitializeCriticalSectionEx( &obj->lock, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
    obj->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IDirectPlayImpl.lock");
 
    if ( DP_CreateDirectPlay2( obj ) )
        hr = IDirectPlayX_QueryInterface( &obj->IDirectPlay4_iface, riid, ppv );
    else
        hr = DPERR_NOMEMORY;
    IDirectPlayX_Release( &obj->IDirectPlay4_iface );
 
    return hr;

Referenced by DirectPlayCreate(), and DPL_ConnectEx().

dplaysp_create()

HRESULT dplaysp_create	(	REFIID	riid,
		void **	ppv,
		IDirectPlayImpl *	dp
	)

Definition at line 696 of file dplaysp.c.

{
  IDirectPlaySPImpl *obj;
  HRESULT hr;
 
  TRACE( "(%s, %p)\n", debugstr_guid( riid ), ppv );
 
  *ppv = NULL;
  obj = calloc( 1, sizeof( *obj ) );
  if ( !obj )
    return DPERR_OUTOFMEMORY;
 
  obj->IDirectPlaySP_iface.lpVtbl = &directPlaySPVT;
  obj->ref = 1;
  obj->dplay = dp;
 
  hr = IDirectPlaySP_QueryInterface( &obj->IDirectPlaySP_iface, riid, ppv );
  IDirectPlaySP_Release( &obj->IDirectPlaySP_iface );
 
  return hr;
}

Referenced by DP_CreateDirectPlay2().

dplobby_create()

HRESULT dplobby_create	(	REFIID	riid,
		void **	ppv
	)

Definition at line 1401 of file dplobby.c.

{
    IDirectPlayLobbyImpl *obj;
    HRESULT hr;
 
    TRACE( "(%s, %p)\n", debugstr_guid( riid ), ppv );
 
    *ppv = NULL;
    obj = malloc( sizeof( *obj ) );
    if ( !obj )
        return DPERR_OUTOFMEMORY;
 
    obj->IDirectPlayLobby3_iface.lpVtbl = &dpl3_vt;
    obj->IDirectPlayLobby3A_iface.lpVtbl = &dpl3A_vt;
    obj->msgtid = 0;
    obj->ref = 1;
 
    InitializeCriticalSectionEx( &obj->lock, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
    obj->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IDirectPlayLobbyImpl.lock");
    DPQ_INIT( obj->msgs );
 
    hr = IDirectPlayLobby_QueryInterface( &obj->IDirectPlayLobby3_iface, riid, ppv );
    IDirectPlayLobby_Release( &obj->IDirectPlayLobby3_iface );
 
    return hr;
}

Referenced by DirectPlayLobbyCreateA(), and DirectPlayLobbyCreateW().

dplobbysp_create()

HRESULT dplobbysp_create	(	REFIID	riid,
		void **	ppv,
		IDirectPlayImpl *	dp
	)

Definition at line 230 of file lobbysp.c.

{
  IDPLobbySPImpl *obj;
  HRESULT hr;
 
  TRACE( "(%s, %p)\n", debugstr_guid( riid ), ppv );
 
  *ppv = NULL;
  obj = malloc( sizeof( *obj ) );
  if ( !obj )
    return DPERR_OUTOFMEMORY;
 
  obj->IDPLobbySP_iface.lpVtbl = &dpLobbySPVT;
  obj->ref = 1;
  obj->dplay = dp;
 
  hr = IDPLobbySP_QueryInterface( &obj->IDPLobbySP_iface, riid, ppv );
  IDPLobbySP_Release( &obj->IDPLobbySP_iface );
 
  return hr;
}

Referenced by DP_CreateDirectPlay2().

DPSP_CreateSPPlayerData()

LPVOID DPSP_CreateSPPlayerData

(

void

)

Definition at line 721 of file dplaysp.c.

{
  TRACE( "Creating SPPlayer data struct\n" );
  return calloc( 1, sizeof( DP_SPPLAYERDATA ) );
}

Referenced by DP_CreateGroup(), and DP_CreatePlayer().