dplayx_messages.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "dplayx_messages.h"
#include "dplay_global.h"
#include "dplayx_global.h"
#include "name_server.h"
#include "wine/debug.h"

Include dependency graph for dplayx_messages.c:

Go to the source code of this file.

Classes
struct	tagMSGTHREADINFO

Typedefs
typedef struct tagMSGTHREADINFO	MSGTHREADINFO
typedef struct tagMSGTHREADINFO *	LPMSGTHREADINFO

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dplay)
static DWORD CALLBACK	DPL_MSG_ThreadMain (LPVOID lpContext)
static void *	DP_MSG_ExpectReply (IDirectPlayImpl *This, DPSP_SENDDATA *data, DWORD dwWaitTime, WORD wReplyCommandId, void **lplpReplyMsg, DWORD *lpdwMsgBodySize)
DWORD	CreateLobbyMessageReceptionThread (HANDLE hNotifyEvent, HANDLE hStart, HANDLE hDeath, HANDLE hConnRead)
static HANDLE	DP_MSG_BuildAndLinkReplyStruct (IDirectPlayImpl *This, DP_MSG_REPLY_STRUCT_LIST *lpReplyStructList, WORD wReplyCommandId)
static LPVOID	DP_MSG_CleanReplyStruct (LPDP_MSG_REPLY_STRUCT_LIST lpReplyStructList, LPVOID *lplpReplyMsg, LPDWORD lpdwMsgBodySize)
HRESULT	DP_MSG_SendRequestPlayerId (IDirectPlayImpl *This, DWORD dwFlags, DPID *lpdpidAllocatedId)
HRESULT	DP_MSG_ForwardPlayerCreation (IDirectPlayImpl *This, DPID dpidServer)
void	DP_MSG_ReplyReceived (IDirectPlayImpl *This, WORD wCommandId, const void *lpcMsgBody, DWORD dwMsgBodySize)
void	DP_MSG_ToSelf (IDirectPlayImpl *This, DPID dpidSelf)
void	DP_MSG_ErrorReceived (IDirectPlayImpl *This, WORD wCommandId, const void *lpMsgBody, DWORD dwMsgBodySize)

Typedef Documentation

LPMSGTHREADINFO

typedef struct tagMSGTHREADINFO * LPMSGTHREADINFO

MSGTHREADINFO

typedef struct tagMSGTHREADINFO MSGTHREADINFO

Function Documentation

CreateLobbyMessageReceptionThread()

DWORD CreateLobbyMessageReceptionThread	(	HANDLE	hNotifyEvent,
		HANDLE	hStart,
		HANDLE	hDeath,
		HANDLE	hConnRead
	)

Definition at line 55 of file dplayx_messages.c.

{
  DWORD           dwMsgThreadId;
  LPMSGTHREADINFO lpThreadInfo;
  HANDLE          hThread;
 
  lpThreadInfo = HeapAlloc( GetProcessHeap(), 0, sizeof( *lpThreadInfo ) );
  if( lpThreadInfo == NULL )
  {
    return 0;
  }
 
  /* The notify event may or may not exist. Depends if async comm or not */
  if( hNotifyEvent &&
      !DuplicateHandle( GetCurrentProcess(), hNotifyEvent,
                        GetCurrentProcess(), &lpThreadInfo->hNotifyEvent,
                        0, FALSE, DUPLICATE_SAME_ACCESS ) )
  {
    ERR( "Unable to duplicate event handle\n" );
    goto error;
  }
 
  /* These 3 handles don't need to be duplicated because we don't keep a
   * reference to them where they're created. They're created specifically
   * for the message thread
   */
  lpThreadInfo->hStart       = hStart;
  lpThreadInfo->hDeath       = hDeath;
  lpThreadInfo->hSettingRead = hConnRead;
 
  hThread = CreateThread( NULL,                  /* Security attribs */
                          0,                     /* Stack */
                          DPL_MSG_ThreadMain,    /* Msg reception function */
                          lpThreadInfo,          /* Msg reception func parameter */
                          0,                     /* Flags */
                          &dwMsgThreadId         /* Updated with thread id */
                        );
  if ( hThread == NULL )
  {
    ERR( "Unable to create msg thread\n" );
    goto error;
  }
 
  CloseHandle(hThread);
 
  return dwMsgThreadId;
 
error:
 
  HeapFree( GetProcessHeap(), 0, lpThreadInfo );
 
  return 0;
}

Referenced by IDirectPlayLobby3AImpl_RunApplication().

DP_MSG_BuildAndLinkReplyStruct()

static HANDLE DP_MSG_BuildAndLinkReplyStruct ( IDirectPlayImpl *  This, DP_MSG_REPLY_STRUCT_LIST *  lpReplyStructList, WORD  wReplyCommandId  )

static

Definition at line 156 of file dplayx_messages.c.

{
  lpReplyStructList->replyExpected.hReceipt       = CreateEventW( NULL, FALSE, FALSE, NULL );
  lpReplyStructList->replyExpected.wExpectedReply = wReplyCommandId;
  lpReplyStructList->replyExpected.lpReplyMsg     = NULL;
  lpReplyStructList->replyExpected.dwMsgBodySize  = 0;
 
  /* Insert into the message queue while locked */
  EnterCriticalSection( &This->lock );
    DPQ_INSERT( This->dp2->repliesExpected, lpReplyStructList, repliesExpected );
  LeaveCriticalSection( &This->lock );
 
  return lpReplyStructList->replyExpected.hReceipt;
}

Referenced by DP_MSG_ExpectReply().

DP_MSG_CleanReplyStruct()

static LPVOID DP_MSG_CleanReplyStruct ( LPDP_MSG_REPLY_STRUCT_LIST  lpReplyStructList, LPVOID *  lplpReplyMsg, LPDWORD  lpdwMsgBodySize  )

static

Definition at line 173 of file dplayx_messages.c.

{
  CloseHandle( lpReplyStructList->replyExpected.hReceipt );
 
  *lplpReplyMsg    = lpReplyStructList->replyExpected.lpReplyMsg;
  *lpdwMsgBodySize = lpReplyStructList->replyExpected.dwMsgBodySize;
 
  return lpReplyStructList->replyExpected.lpReplyMsg;
}

Referenced by DP_MSG_ExpectReply().

DP_MSG_ErrorReceived()

void DP_MSG_ErrorReceived	(	IDirectPlayImpl *	This,
		WORD	wCommandId,
		const void *	lpMsgBody,
		DWORD	dwMsgBodySize
	)

Definition at line 484 of file dplayx_messages.c.

{
  LPCDPMSG_FORWARDADDPLAYERNACK lpcErrorMsg;
 
  lpcErrorMsg = lpMsgBody;
 
  ERR( "Received error message %u. Error is %s\n",
       wCommandId, DPLAYX_HresultToString( lpcErrorMsg->errorCode) );
  DebugBreak();
}

Referenced by DP_HandleMessage().

DP_MSG_ExpectReply()

static void * DP_MSG_ExpectReply ( IDirectPlayImpl *  This, DPSP_SENDDATA *  data, DWORD  dwWaitTime, WORD  wReplyCommandId, void **  lplpReplyMsg, DWORD *  lpdwMsgBodySize  )

static

Definition at line 368 of file dplayx_messages.c.

{
  HRESULT                  hr;
  HANDLE                   hMsgReceipt;
  DP_MSG_REPLY_STRUCT_LIST replyStructList;
  DWORD                    dwWaitReturn;
 
  /* Setup for receipt */
  hMsgReceipt = DP_MSG_BuildAndLinkReplyStruct( This, &replyStructList,
                                                wReplyCommandId );
 
  TRACE( "Sending msg and expecting cmd %u in reply within %u ticks\n",
         wReplyCommandId, dwWaitTime );
  hr = (*This->dp2->spData.lpCB->Send)( lpData );
 
  if( FAILED(hr) )
  {
    ERR( "Send failed: %s\n", DPLAYX_HresultToString( hr ) );
    return NULL;
  }
 
  /* The reply message will trigger the hMsgReceipt event effectively switching
   * control back to this thread. See DP_MSG_ReplyReceived.
   */
  dwWaitReturn = WaitForSingleObject( hMsgReceipt, dwWaitTime );
  if( dwWaitReturn != WAIT_OBJECT_0 )
  {
    ERR( "Wait failed 0x%08x\n", dwWaitReturn );
    return NULL;
  }
 
  /* Clean Up */
  return DP_MSG_CleanReplyStruct( &replyStructList, lplpReplyMsg, lpdwMsgBodySize );
}

Referenced by DP_MSG_ForwardPlayerCreation(), DP_MSG_SendRequestPlayerId(), and DP_MSG_ToSelf().

DP_MSG_ForwardPlayerCreation()

HRESULT DP_MSG_ForwardPlayerCreation	(	IDirectPlayImpl *	This,
		DPID	dpidServer
	)

Definition at line 250 of file dplayx_messages.c.

{
  LPVOID                   lpMsg;
  LPDPMSG_FORWARDADDPLAYER lpMsgBody;
  DWORD                    dwMsgSize;
  HRESULT                  hr = DP_OK;
 
  dwMsgSize = This->dp2->spData.dwSPHeaderSize + sizeof( *lpMsgBody );
 
  lpMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwMsgSize );
 
  lpMsgBody = (LPDPMSG_FORWARDADDPLAYER)( (BYTE*)lpMsg +
                                          This->dp2->spData.dwSPHeaderSize );
 
  /* Compose dplay message envelope */
  lpMsgBody->envelope.dwMagic    = DPMSGMAGIC_DPLAYMSG;
  lpMsgBody->envelope.wCommandId = DPMSGCMD_FORWARDADDPLAYER;
  lpMsgBody->envelope.wVersion   = DPMSGVER_DP6;
 
#if 0
  {
    LPBYTE lpPData;
    DWORD  dwDataSize;
 
    /* SP Player remote data needs to be propagated at some point - is this the point? */
    IDirectPlaySP_GetSPPlayerData( This->dp2->spData.lpISP, 0, &lpPData, &dwDataSize, DPSET_REMOTE );
 
    ERR( "Player Data size is 0x%08lx\n"
         "[%02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x]\n"
         "[%02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x]\n",
 
     dwDataSize,
         lpPData[0], lpPData[1], lpPData[2], lpPData[3], lpPData[4],
     lpPData[5], lpPData[6], lpPData[7], lpPData[8], lpPData[9],
         lpPData[10], lpPData[11], lpPData[12], lpPData[13], lpPData[14],
     lpPData[15], lpPData[16], lpPData[17], lpPData[18], lpPData[19],
         lpPData[20], lpPData[21], lpPData[22], lpPData[23], lpPData[24],
     lpPData[25], lpPData[26], lpPData[27], lpPData[28], lpPData[29],
         lpPData[30], lpPData[31]
        );
    DebugBreak();
  }
#endif
 
  /* Compose body of message */
  lpMsgBody->dpidAppServer = dpidServer;
  lpMsgBody->unknown2[0] = 0x0;
  lpMsgBody->unknown2[1] = 0x1c;
  lpMsgBody->unknown2[2] = 0x6c;
  lpMsgBody->unknown2[3] = 0x50;
  lpMsgBody->unknown2[4] = 0x9;
 
  lpMsgBody->dpidAppServer2 = dpidServer;
  lpMsgBody->unknown3[0] = 0x0;
  lpMsgBody->unknown3[1] = 0x0;
  lpMsgBody->unknown3[2] = 0x20;
  lpMsgBody->unknown3[3] = 0x0;
  lpMsgBody->unknown3[4] = 0x0;
 
  lpMsgBody->dpidAppServer3 = dpidServer;
  lpMsgBody->unknown4[0] =  0x30;
  lpMsgBody->unknown4[1] =  0xb;
  lpMsgBody->unknown4[2] =  0x0;
 
  lpMsgBody->unknown4[3] =  NS_GetNsMagic( This->dp2->lpNameServerData ) -
                            0x02000000;
  TRACE( "Setting first magic to 0x%08x\n", lpMsgBody->unknown4[3] );
 
  lpMsgBody->unknown4[4] =  0x0;
  lpMsgBody->unknown4[5] =  0x0;
  lpMsgBody->unknown4[6] =  0x0;
 
  lpMsgBody->unknown4[7] =  NS_GetNsMagic( This->dp2->lpNameServerData );
  TRACE( "Setting second magic to 0x%08x\n", lpMsgBody->unknown4[7] );
 
  lpMsgBody->unknown4[8] =  0x0;
  lpMsgBody->unknown4[9] =  0x0;
  lpMsgBody->unknown4[10] = 0x0;
  lpMsgBody->unknown4[11] = 0x0;
 
  lpMsgBody->unknown5[0] = 0x0;
  lpMsgBody->unknown5[1] = 0x0;
 
  /* Send the message */
  {
    DPSP_SENDDATA data;
 
    data.dwFlags        = DPSEND_GUARANTEED;
    data.idPlayerTo     = 0; /* Name server */
    data.idPlayerFrom   = dpidServer; /* Sending from session server */
    data.lpMessage      = lpMsg;
    data.dwMessageSize  = dwMsgSize;
    data.bSystemMessage = TRUE; /* Allow reply to be sent */
    data.lpISP          = This->dp2->spData.lpISP;
 
    TRACE( "Sending forward player request with 0x%08x\n", dpidServer );
 
    lpMsg = DP_MSG_ExpectReply( This, &data,
                                DPMSG_WAIT_60_SECS,
                                DPMSGCMD_GETNAMETABLEREPLY,
                                &lpMsg, &dwMsgSize );
  }
 
  /* Need to examine the data and extract the new player id */
  if( lpMsg != NULL )
  {
    FIXME( "Name Table reply received: stub\n" );
  }
 
  return hr;
}

Referenced by DP_IF_CreatePlayer().

DP_MSG_ReplyReceived()

void DP_MSG_ReplyReceived	(	IDirectPlayImpl *	This,
		WORD	wCommandId,
		const void *	lpcMsgBody,
		DWORD	dwMsgBodySize
	)

Definition at line 408 of file dplayx_messages.c.

{
  LPDP_MSG_REPLY_STRUCT_LIST lpReplyList;
 
#if 0
  if( wCommandId == DPMSGCMD_FORWARDADDPLAYER )
  {
    DebugBreak();
  }
#endif
 
  /* Find, and immediately remove (to avoid double triggering), the appropriate entry. Call locked to
   * avoid problems.
   */
  EnterCriticalSection( &This->lock );
    DPQ_REMOVE_ENTRY( This->dp2->repliesExpected, repliesExpected, replyExpected.wExpectedReply,
                     ==, wCommandId, lpReplyList );
  LeaveCriticalSection( &This->lock );
 
  if( lpReplyList != NULL )
  {
    lpReplyList->replyExpected.dwMsgBodySize = dwMsgBodySize;
    lpReplyList->replyExpected.lpReplyMsg = HeapAlloc( GetProcessHeap(),
                                                       HEAP_ZERO_MEMORY,
                                                       dwMsgBodySize );
    CopyMemory( lpReplyList->replyExpected.lpReplyMsg,
                lpcMsgBody, dwMsgBodySize );
 
    /* Signal the thread which sent the message that it has a reply */
    SetEvent( lpReplyList->replyExpected.hReceipt );
  }
  else
  {
    ERR( "No receipt event set - only expecting in reply mode\n" );
    DebugBreak();
  }
}

Referenced by DP_HandleMessage().

DP_MSG_SendRequestPlayerId()

HRESULT DP_MSG_SendRequestPlayerId	(	IDirectPlayImpl *	This,
		DWORD	dwFlags,
		DPID *	lpdpidAllocatedId
	)

Definition at line 184 of file dplayx_messages.c.

{
  LPVOID                     lpMsg;
  LPDPMSG_REQUESTNEWPLAYERID lpMsgBody;
  DWORD                      dwMsgSize;
  HRESULT                    hr = DP_OK;
 
  dwMsgSize = This->dp2->spData.dwSPHeaderSize + sizeof( *lpMsgBody );
 
  lpMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwMsgSize );
 
  lpMsgBody = (LPDPMSG_REQUESTNEWPLAYERID)( (BYTE*)lpMsg +
                                             This->dp2->spData.dwSPHeaderSize );
 
  /* Compose dplay message envelope */
  lpMsgBody->envelope.dwMagic    = DPMSGMAGIC_DPLAYMSG;
  lpMsgBody->envelope.wCommandId = DPMSGCMD_REQUESTNEWPLAYERID;
  lpMsgBody->envelope.wVersion   = DPMSGVER_DP6;
 
  /* Compose the body of the message */
  lpMsgBody->dwFlags = dwFlags;
 
  /* Send the message */
  {
    DPSP_SENDDATA data;
 
    data.dwFlags        = DPSEND_GUARANTEED;
    data.idPlayerTo     = 0; /* Name server */
    data.idPlayerFrom   = 0; /* Sending from DP */
    data.lpMessage      = lpMsg;
    data.dwMessageSize  = dwMsgSize;
    data.bSystemMessage = TRUE; /* Allow reply to be sent */
    data.lpISP          = This->dp2->spData.lpISP;
 
    TRACE( "Asking for player id w/ dwFlags 0x%08x\n",
           lpMsgBody->dwFlags );
 
    DP_MSG_ExpectReply( This, &data, DPMSG_DEFAULT_WAIT_TIME, DPMSGCMD_NEWPLAYERIDREPLY,
                        &lpMsg, &dwMsgSize );
  }
 
  /* Need to examine the data and extract the new player id */
  if( SUCCEEDED(hr) )
  {
    LPCDPMSG_NEWPLAYERIDREPLY lpcReply;
 
    lpcReply = lpMsg;
 
    *lpdpidAllocatedId = lpcReply->dpidNewPlayerId;
 
    TRACE( "Received reply for id = 0x%08x\n", lpcReply->dpidNewPlayerId );
 
    /* FIXME: I think that the rest of the message has something to do
     *        with remote data for the player that perhaps I need to setup.
     *        However, with the information that is passed, all that it could
     *        be used for is a standardized initialization value, which I'm
     *        guessing we can do without. Unless the message content is the same
     *        for several different messages?
     */
 
    HeapFree( GetProcessHeap(), 0, lpMsg );
  }
 
  return hr;
}

Referenced by DP_IF_CreatePlayer().

DP_MSG_ToSelf()

void DP_MSG_ToSelf	(	IDirectPlayImpl *	This,
		DPID	dpidSelf
	)

Definition at line 447 of file dplayx_messages.c.

{
  LPVOID                   lpMsg;
  LPDPMSG_SENDENVELOPE     lpMsgBody;
  DWORD                    dwMsgSize;
 
  dwMsgSize = This->dp2->spData.dwSPHeaderSize + sizeof( *lpMsgBody );
 
  lpMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwMsgSize );
 
  lpMsgBody = (LPDPMSG_SENDENVELOPE)( (BYTE*)lpMsg +
                                      This->dp2->spData.dwSPHeaderSize );
 
  /* Compose dplay message envelope */
  lpMsgBody->dwMagic    = DPMSGMAGIC_DPLAYMSG;
  lpMsgBody->wCommandId = DPMSGCMD_JUSTENVELOPE;
  lpMsgBody->wVersion   = DPMSGVER_DP6;
 
  /* Send the message to ourselves */
  {
    DPSP_SENDDATA data;
 
    data.dwFlags        = 0;
    data.idPlayerTo     = dpidSelf; /* Sending to session server */
    data.idPlayerFrom   = 0; /* Sending from session server */
    data.lpMessage      = lpMsg;
    data.dwMessageSize  = dwMsgSize;
    data.bSystemMessage = TRUE; /* Allow reply to be sent */
    data.lpISP          = This->dp2->spData.lpISP;
 
    lpMsg = DP_MSG_ExpectReply( This, &data,
                                DPMSG_WAIT_5_SECS,
                                DPMSGCMD_JUSTENVELOPE,
                                &lpMsg, &dwMsgSize );
  }
}

Referenced by DP_HandleMessage(), and DP_IF_CreatePlayer().

DPL_MSG_ThreadMain()

static DWORD CALLBACK DPL_MSG_ThreadMain ( LPVOID  lpContext )

static

Definition at line 110 of file dplayx_messages.c.

{
  LPMSGTHREADINFO lpThreadInfo = lpContext;
  DWORD dwWaitResult;
 
  TRACE( "Msg thread created. Waiting on app startup\n" );
 
  /* Wait to ensure that the lobby application is started w/ 1 min timeout */
  dwWaitResult = WaitForSingleObject( lpThreadInfo->hStart, 10000 /* 10 sec */ );
  if( dwWaitResult == WAIT_TIMEOUT )
  {
    FIXME( "Should signal app/wait creation failure (0x%08x)\n", dwWaitResult );
    goto end_of_thread;
  }
 
  /* Close this handle as it's not needed anymore */
  CloseHandle( lpThreadInfo->hStart );
  lpThreadInfo->hStart = 0;
 
  /* Wait until the lobby knows what it is */
  dwWaitResult = WaitForSingleObject( lpThreadInfo->hSettingRead, INFINITE );
  if( dwWaitResult == WAIT_TIMEOUT )
  {
    ERR( "App Read connection setting timeout fail (0x%08x)\n", dwWaitResult );
  }
 
  /* Close this handle as it's not needed anymore */
  CloseHandle( lpThreadInfo->hSettingRead );
  lpThreadInfo->hSettingRead = 0;
 
  TRACE( "App created && initialized starting main message reception loop\n" );
 
  for ( ;; )
  {
    MSG lobbyMsg;
    GetMessageW( &lobbyMsg, 0, 0, 0 );
  }
 
end_of_thread:
  TRACE( "Msg thread exiting!\n" );
  HeapFree( GetProcessHeap(), 0, lpThreadInfo );
 
  return 0;
}

Referenced by CreateLobbyMessageReceptionThread().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dplay

)