1 /* DirectPlay & DirectPlayLobby messaging implementation
3 * Copyright 2000,2001 - Peter Hunnisett
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 * o Messaging interface required for both DirectPlay and DirectPlayLobby.
31 #include "dplayx_messages.h"
32 #include "dplay_global.h"
33 #include "dplayx_global.h"
34 #include "name_server.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(dplay
);
39 typedef struct tagMSGTHREADINFO
45 } MSGTHREADINFO
, *LPMSGTHREADINFO
;
47 static DWORD CALLBACK
DPL_MSG_ThreadMain( LPVOID lpContext
);
48 static LPVOID
DP_MSG_ExpectReply( IDirectPlay2AImpl
* This
, LPDPSP_SENDDATA data
,
49 DWORD dwWaitTime
, WORD wReplyCommandId
,
50 LPVOID
* lplpReplyMsg
, LPDWORD lpdwMsgBodySize
);
53 /* Create the message reception thread to allow the application to receive
54 * asynchronous message reception
56 DWORD
CreateLobbyMessageReceptionThread( HANDLE hNotifyEvent
, HANDLE hStart
,
57 HANDLE hDeath
, HANDLE hConnRead
)
60 LPMSGTHREADINFO lpThreadInfo
;
62 lpThreadInfo
= HeapAlloc( GetProcessHeap(), 0, sizeof( *lpThreadInfo
) );
63 if( lpThreadInfo
== NULL
)
68 /* The notify event may or may not exist. Depends if async comm or not */
70 !DuplicateHandle( GetCurrentProcess(), hNotifyEvent
,
71 GetCurrentProcess(), &lpThreadInfo
->hNotifyEvent
,
72 0, FALSE
, DUPLICATE_SAME_ACCESS
) )
74 ERR( "Unable to duplicate event handle\n" );
78 /* These 3 handles don't need to be duplicated because we don't keep a
79 * reference to them where they're created. They're created specifically
80 * for the message thread
82 lpThreadInfo
->hStart
= hStart
;
83 lpThreadInfo
->hDeath
= hDeath
;
84 lpThreadInfo
->hSettingRead
= hConnRead
;
86 if( !CreateThread( NULL
, /* Security attribs */
88 DPL_MSG_ThreadMain
, /* Msg reception function */
89 lpThreadInfo
, /* Msg reception func parameter */
91 &dwMsgThreadId
/* Updated with thread id */
95 ERR( "Unable to create msg thread\n" );
99 /* FIXME: Should I be closing the handle to the thread or does that
100 terminate the thread? */
102 return dwMsgThreadId
;
106 HeapFree( GetProcessHeap(), 0, lpThreadInfo
);
111 static DWORD CALLBACK
DPL_MSG_ThreadMain( LPVOID lpContext
)
113 LPMSGTHREADINFO lpThreadInfo
= (LPMSGTHREADINFO
)lpContext
;
116 TRACE( "Msg thread created. Waiting on app startup\n" );
118 /* Wait to ensure that the lobby application is started w/ 1 min timeout */
119 dwWaitResult
= WaitForSingleObject( lpThreadInfo
->hStart
, 10000 /* 10 sec */ );
120 if( dwWaitResult
== WAIT_TIMEOUT
)
122 FIXME( "Should signal app/wait creation failure (0x%08x)\n", dwWaitResult
);
126 /* Close this handle as it's not needed anymore */
127 CloseHandle( lpThreadInfo
->hStart
);
128 lpThreadInfo
->hStart
= 0;
130 /* Wait until the lobby knows what it is */
131 dwWaitResult
= WaitForSingleObject( lpThreadInfo
->hSettingRead
, INFINITE
);
132 if( dwWaitResult
== WAIT_TIMEOUT
)
134 ERR( "App Read connection setting timeout fail (0x%08x)\n", dwWaitResult
);
137 /* Close this handle as it's not needed anymore */
138 CloseHandle( lpThreadInfo
->hSettingRead
);
139 lpThreadInfo
->hSettingRead
= 0;
141 TRACE( "App created && intialized starting main message reception loop\n" );
146 GetMessageW( &lobbyMsg
, 0, 0, 0 );
150 TRACE( "Msg thread exiting!\n" );
151 HeapFree( GetProcessHeap(), 0, lpThreadInfo
);
156 /* DP messageing stuff */
157 static HANDLE
DP_MSG_BuildAndLinkReplyStruct( IDirectPlay2Impl
* This
,
158 LPDP_MSG_REPLY_STRUCT_LIST lpReplyStructList
,
159 WORD wReplyCommandId
);
160 static LPVOID
DP_MSG_CleanReplyStruct( LPDP_MSG_REPLY_STRUCT_LIST lpReplyStructList
,
161 LPVOID
* lplpReplyMsg
, LPDWORD lpdwMsgBodySize
);
165 HANDLE
DP_MSG_BuildAndLinkReplyStruct( IDirectPlay2Impl
* This
,
166 LPDP_MSG_REPLY_STRUCT_LIST lpReplyStructList
, WORD wReplyCommandId
)
168 lpReplyStructList
->replyExpected
.hReceipt
= CreateEventW( NULL
, FALSE
, FALSE
, NULL
);
169 lpReplyStructList
->replyExpected
.wExpectedReply
= wReplyCommandId
;
170 lpReplyStructList
->replyExpected
.lpReplyMsg
= NULL
;
171 lpReplyStructList
->replyExpected
.dwMsgBodySize
= 0;
173 /* Insert into the message queue while locked */
174 EnterCriticalSection( &This
->unk
->DP_lock
);
175 DPQ_INSERT( This
->dp2
->replysExpected
, lpReplyStructList
, replysExpected
);
176 LeaveCriticalSection( &This
->unk
->DP_lock
);
178 return lpReplyStructList
->replyExpected
.hReceipt
;
182 LPVOID
DP_MSG_CleanReplyStruct( LPDP_MSG_REPLY_STRUCT_LIST lpReplyStructList
,
183 LPVOID
* lplpReplyMsg
, LPDWORD lpdwMsgBodySize
)
185 CloseHandle( lpReplyStructList
->replyExpected
.hReceipt
);
187 *lplpReplyMsg
= lpReplyStructList
->replyExpected
.lpReplyMsg
;
188 *lpdwMsgBodySize
= lpReplyStructList
->replyExpected
.dwMsgBodySize
;
190 return lpReplyStructList
->replyExpected
.lpReplyMsg
;
193 HRESULT
DP_MSG_SendRequestPlayerId( IDirectPlay2AImpl
* This
, DWORD dwFlags
,
194 LPDPID lpdpidAllocatedId
)
197 LPDPMSG_REQUESTNEWPLAYERID lpMsgBody
;
201 dwMsgSize
= This
->dp2
->spData
.dwSPHeaderSize
+ sizeof( *lpMsgBody
);
203 lpMsg
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwMsgSize
);
205 lpMsgBody
= (LPDPMSG_REQUESTNEWPLAYERID
)( (BYTE
*)lpMsg
+
206 This
->dp2
->spData
.dwSPHeaderSize
);
208 /* Compose dplay message envelope */
209 lpMsgBody
->envelope
.dwMagic
= DPMSGMAGIC_DPLAYMSG
;
210 lpMsgBody
->envelope
.wCommandId
= DPMSGCMD_REQUESTNEWPLAYERID
;
211 lpMsgBody
->envelope
.wVersion
= DPMSGVER_DP6
;
213 /* Compose the body of the message */
214 lpMsgBody
->dwFlags
= dwFlags
;
216 /* Send the message */
220 data
.dwFlags
= DPSEND_GUARANTEED
;
221 data
.idPlayerTo
= 0; /* Name server */
222 data
.idPlayerFrom
= 0; /* Sending from DP */
223 data
.lpMessage
= lpMsg
;
224 data
.dwMessageSize
= dwMsgSize
;
225 data
.bSystemMessage
= TRUE
; /* Allow reply to be sent */
226 data
.lpISP
= This
->dp2
->spData
.lpISP
;
228 TRACE( "Asking for player id w/ dwFlags 0x%08x\n",
229 lpMsgBody
->dwFlags
);
231 DP_MSG_ExpectReply( This
, &data
, DPMSG_DEFAULT_WAIT_TIME
, DPMSGCMD_NEWPLAYERIDREPLY
,
232 &lpMsg
, &dwMsgSize
);
235 /* Need to examine the data and extract the new player id */
238 LPCDPMSG_NEWPLAYERIDREPLY lpcReply
;
240 lpcReply
= (LPCDPMSG_NEWPLAYERIDREPLY
)lpMsg
;
242 *lpdpidAllocatedId
= lpcReply
->dpidNewPlayerId
;
244 TRACE( "Received reply for id = 0x%08x\n", lpcReply
->dpidNewPlayerId
);
246 /* FIXME: I think that the rest of the message has something to do
247 * with remote data for the player that perhaps I need to setup.
248 * However, with the information that is passed, all that it could
249 * be used for is a standardized intialization value, which I'm
250 * guessing we can do without. Unless the message content is the same
251 * for several different messages?
254 HeapFree( GetProcessHeap(), 0, lpMsg
);
260 HRESULT
DP_MSG_ForwardPlayerCreation( IDirectPlay2AImpl
* This
, DPID dpidServer
)
263 LPDPMSG_FORWARDADDPLAYER lpMsgBody
;
267 dwMsgSize
= This
->dp2
->spData
.dwSPHeaderSize
+ sizeof( *lpMsgBody
);
269 lpMsg
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwMsgSize
);
271 lpMsgBody
= (LPDPMSG_FORWARDADDPLAYER
)( (BYTE
*)lpMsg
+
272 This
->dp2
->spData
.dwSPHeaderSize
);
274 /* Compose dplay message envelope */
275 lpMsgBody
->envelope
.dwMagic
= DPMSGMAGIC_DPLAYMSG
;
276 lpMsgBody
->envelope
.wCommandId
= DPMSGCMD_FORWARDADDPLAYER
;
277 lpMsgBody
->envelope
.wVersion
= DPMSGVER_DP6
;
284 /* SP Player remote data needs to be propagated at some point - is this the point? */
285 IDirectPlaySP_GetSPPlayerData( This
->dp2
->spData
.lpISP
, 0, (LPVOID
*)&lpPData
, &dwDataSize
, DPSET_REMOTE
);
287 ERR( "Player Data size is 0x%08lx\n"
288 "[%02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x]\n"
289 "[%02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x %02x%02x]\n",
292 lpPData
[0], lpPData
[1], lpPData
[2], lpPData
[3], lpPData
[4],
293 lpPData
[5], lpPData
[6], lpPData
[7], lpPData
[8], lpPData
[9],
294 lpPData
[10], lpPData
[11], lpPData
[12], lpPData
[13], lpPData
[14],
295 lpPData
[15], lpPData
[16], lpPData
[17], lpPData
[18], lpPData
[19],
296 lpPData
[20], lpPData
[21], lpPData
[22], lpPData
[23], lpPData
[24],
297 lpPData
[25], lpPData
[26], lpPData
[27], lpPData
[28], lpPData
[29],
298 lpPData
[30], lpPData
[31]
304 /* Compose body of message */
305 lpMsgBody
->dpidAppServer
= dpidServer
;
306 lpMsgBody
->unknown2
[0] = 0x0;
307 lpMsgBody
->unknown2
[1] = 0x1c;
308 lpMsgBody
->unknown2
[2] = 0x6c;
309 lpMsgBody
->unknown2
[3] = 0x50;
310 lpMsgBody
->unknown2
[4] = 0x9;
312 lpMsgBody
->dpidAppServer2
= dpidServer
;
313 lpMsgBody
->unknown3
[0] = 0x0;
314 lpMsgBody
->unknown3
[0] = 0x0;
315 lpMsgBody
->unknown3
[0] = 0x20;
316 lpMsgBody
->unknown3
[0] = 0x0;
317 lpMsgBody
->unknown3
[0] = 0x0;
319 lpMsgBody
->dpidAppServer3
= dpidServer
;
320 lpMsgBody
->unknown4
[0] = 0x30;
321 lpMsgBody
->unknown4
[1] = 0xb;
322 lpMsgBody
->unknown4
[2] = 0x0;
324 lpMsgBody
->unknown4
[3] = NS_GetNsMagic( This
->dp2
->lpNameServerData
) -
326 TRACE( "Setting first magic to 0x%08x\n", lpMsgBody
->unknown4
[3] );
328 lpMsgBody
->unknown4
[4] = 0x0;
329 lpMsgBody
->unknown4
[5] = 0x0;
330 lpMsgBody
->unknown4
[6] = 0x0;
333 lpMsgBody
->unknown4
[7] = NS_GetOtherMagic( This
->dp2
->lpNameServerData
)
335 lpMsgBody
->unknown4
[7] = NS_GetNsMagic( This
->dp2
->lpNameServerData
);
337 TRACE( "Setting second magic to 0x%08x\n", lpMsgBody
->unknown4
[7] );
339 lpMsgBody
->unknown4
[8] = 0x0;
340 lpMsgBody
->unknown4
[9] = 0x0;
341 lpMsgBody
->unknown4
[10] = 0x0;
342 lpMsgBody
->unknown4
[11] = 0x0;
344 lpMsgBody
->unknown5
[0] = 0x0;
345 lpMsgBody
->unknown5
[1] = 0x0;
347 /* Send the message */
351 data
.dwFlags
= DPSEND_GUARANTEED
;
352 data
.idPlayerTo
= 0; /* Name server */
353 data
.idPlayerFrom
= dpidServer
; /* Sending from session server */
354 data
.lpMessage
= lpMsg
;
355 data
.dwMessageSize
= dwMsgSize
;
356 data
.bSystemMessage
= TRUE
; /* Allow reply to be sent */
357 data
.lpISP
= This
->dp2
->spData
.lpISP
;
359 TRACE( "Sending forward player request with 0x%08x\n", dpidServer
);
361 lpMsg
= DP_MSG_ExpectReply( This
, &data
,
363 DPMSGCMD_GETNAMETABLEREPLY
,
364 &lpMsg
, &dwMsgSize
);
367 /* Need to examine the data and extract the new player id */
370 FIXME( "Name Table reply received: stub\n" );
376 /* Queue up a structure indicating that we want a reply of type wReplyCommandId. DPlay does
377 * not seem to offer any way of uniquely differentiating between replies of the same type
378 * relative to the request sent. There is an implicit assumption that there will be no
379 * ordering issues on sends and receives from the opposite machine. No wonder MS is not
380 * a networking company.
383 LPVOID
DP_MSG_ExpectReply( IDirectPlay2AImpl
* This
, LPDPSP_SENDDATA lpData
,
384 DWORD dwWaitTime
, WORD wReplyCommandId
,
385 LPVOID
* lplpReplyMsg
, LPDWORD lpdwMsgBodySize
)
389 DP_MSG_REPLY_STRUCT_LIST replyStructList
;
392 /* Setup for receipt */
393 hMsgReceipt
= DP_MSG_BuildAndLinkReplyStruct( This
, &replyStructList
,
396 TRACE( "Sending msg and expecting cmd %u in reply within %u ticks\n",
397 wReplyCommandId
, dwWaitTime
);
398 hr
= (*This
->dp2
->spData
.lpCB
->Send
)( lpData
);
402 ERR( "Send failed: %s\n", DPLAYX_HresultToString( hr
) );
406 /* The reply message will trigger the hMsgReceipt event effectively switching
407 * control back to this thread. See DP_MSG_ReplyReceived.
409 dwWaitReturn
= WaitForSingleObject( hMsgReceipt
, dwWaitTime
);
410 if( dwWaitReturn
!= WAIT_OBJECT_0
)
412 ERR( "Wait failed 0x%08x\n", dwWaitReturn
);
417 return DP_MSG_CleanReplyStruct( &replyStructList
, lplpReplyMsg
, lpdwMsgBodySize
);
420 /* Determine if there is a matching request for this incoming message and then copy
421 * all important data. It is quite silly to have to copy the message, but the documents
422 * indicate that a copy is taken. Silly really.
424 void DP_MSG_ReplyReceived( IDirectPlay2AImpl
* This
, WORD wCommandId
,
425 LPCVOID lpcMsgBody
, DWORD dwMsgBodySize
)
427 LPDP_MSG_REPLY_STRUCT_LIST lpReplyList
;
430 if( wCommandId
== DPMSGCMD_FORWARDADDPLAYER
)
436 /* Find, and immediately remove (to avoid double triggering), the appropriate entry. Call locked to
439 EnterCriticalSection( &This
->unk
->DP_lock
);
440 DPQ_REMOVE_ENTRY( This
->dp2
->replysExpected
, replysExpected
, replyExpected
.wExpectedReply
,\
441 ==, wCommandId
, lpReplyList
);
442 LeaveCriticalSection( &This
->unk
->DP_lock
);
444 if( lpReplyList
!= NULL
)
446 lpReplyList
->replyExpected
.dwMsgBodySize
= dwMsgBodySize
;
447 lpReplyList
->replyExpected
.lpReplyMsg
= HeapAlloc( GetProcessHeap(),
450 CopyMemory( lpReplyList
->replyExpected
.lpReplyMsg
,
451 lpcMsgBody
, dwMsgBodySize
);
453 /* Signal the thread which sent the message that it has a reply */
454 SetEvent( lpReplyList
->replyExpected
.hReceipt
);
458 ERR( "No receipt event set - only expecting in reply mode\n" );
463 void DP_MSG_ToSelf( IDirectPlay2AImpl
* This
, DPID dpidSelf
)
466 LPDPMSG_SENDENVELOPE lpMsgBody
;
469 dwMsgSize
= This
->dp2
->spData
.dwSPHeaderSize
+ sizeof( *lpMsgBody
);
471 lpMsg
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, dwMsgSize
);
473 lpMsgBody
= (LPDPMSG_SENDENVELOPE
)( (BYTE
*)lpMsg
+
474 This
->dp2
->spData
.dwSPHeaderSize
);
476 /* Compose dplay message envelope */
477 lpMsgBody
->dwMagic
= DPMSGMAGIC_DPLAYMSG
;
478 lpMsgBody
->wCommandId
= DPMSGCMD_JUSTENVELOPE
;
479 lpMsgBody
->wVersion
= DPMSGVER_DP6
;
481 /* Send the message to ourselves */
486 data
.idPlayerTo
= dpidSelf
; /* Sending to session server */
487 data
.idPlayerFrom
= 0; /* Sending from session server */
488 data
.lpMessage
= lpMsg
;
489 data
.dwMessageSize
= dwMsgSize
;
490 data
.bSystemMessage
= TRUE
; /* Allow reply to be sent */
491 data
.lpISP
= This
->dp2
->spData
.lpISP
;
493 lpMsg
= DP_MSG_ExpectReply( This
, &data
,
495 DPMSGCMD_JUSTENVELOPE
,
496 &lpMsg
, &dwMsgSize
);
500 void DP_MSG_ErrorReceived( IDirectPlay2AImpl
* This
, WORD wCommandId
,
501 LPCVOID lpMsgBody
, DWORD dwMsgBodySize
)
503 LPCDPMSG_FORWARDADDPLAYERNACK lpcErrorMsg
;
505 lpcErrorMsg
= (LPCDPMSG_FORWARDADDPLAYERNACK
)lpMsgBody
;
507 ERR( "Received error message %u. Error is %s\n",
508 wCommandId
, DPLAYX_HresultToString( lpcErrorMsg
->errorCode
) );