?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: Code to send CreatePlayer messages
[wine/gsoc_dplay.git] / dlls / dplayx / dplay.c
blob09fb759e7dd8486bc165c28b66f9187506172036
1 /* Direct Play 2,3,4 Implementation
2 *
3 * Copyright 1998,1999,2000,2001 - Peter Hunnisett
4 *
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.
9 *
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.
14 *
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
18 */
19
20 #include "config.h"
21 #include "wine/port.h"
22
23 #include <stdarg.h>
24 #include <string.h>
25
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
28 #include "windef.h"
29 #include "winerror.h"
30 #include "winbase.h"
31 #include "winnt.h"
32 #include "winreg.h"
33 #include "winnls.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
36
37 #include "dpinit.h"
38 #include "dplayx_global.h"
39 #include "name_server.h"
40 #include "dplayx_queue.h"
41 #include "wine/dplaysp.h"
42 #include "dplay_global.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(dplay);
45
46 /* FIXME: Should this be externed? */
47 extern HRESULT DPL_CreateCompoundAddress
48 ( LPCDPCOMPOUNDADDRESSELEMENT lpElements, DWORD dwElementCount,
49 LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface );
50
51
52 /* Local function prototypes */
53 static BOOL DP_CopyDPNAMEStruct( LPDPNAME lpDst, const DPNAME *lpSrc, BOOL bAnsi );
54 static void DP_SetPlayerData( lpPlayerData lpPData, DWORD dwFlags,
55 LPVOID lpData, DWORD dwDataSize );
56
57 static lpGroupData DP_CreateGroup( IDirectPlay2AImpl* iface, const DPID *lpid,
58 const DPNAME *lpName, DWORD dwFlags,
59 DPID idParent, BOOL bAnsi );
60 static void DP_SetGroupData( lpGroupData lpGData, DWORD dwFlags,
61 LPVOID lpData, DWORD dwDataSize );
62 static void DP_DeleteDPNameStruct( LPDPNAME lpDPName );
63 static void DP_DeletePlayer( IDirectPlay2Impl* This, DPID dpid );
64 static BOOL CALLBACK cbDeletePlayerFromAllGroups( DPID dpId,
65 DWORD dwPlayerType,
66 LPCDPNAME lpName,
67 DWORD dwFlags,
68 LPVOID lpContext );
69 static lpGroupData DP_FindAnyGroup( IDirectPlay2AImpl* This, DPID dpid );
70 static BOOL CALLBACK cbRemoveGroupOrPlayer( DPID dpId, DWORD dwPlayerType,
71 LPCDPNAME lpName, DWORD dwFlags,
72 LPVOID lpContext );
73 static void DP_DeleteGroup( IDirectPlay2Impl* This, DPID dpid );
74
75 /* Forward declarations of virtual tables */
76 static const IDirectPlay2Vtbl directPlay2AVT;
77 static const IDirectPlay3Vtbl directPlay3AVT;
78 static const IDirectPlay4Vtbl directPlay4AVT;
79
80 static const IDirectPlay2Vtbl directPlay2WVT;
81 static const IDirectPlay3Vtbl directPlay3WVT;
82 static const IDirectPlay4Vtbl directPlay4WVT;
83
84 /* Helper methods for player/group interfaces */
85 static HRESULT DP_IF_DeletePlayerFromGroup
86 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idGroup,
87 DPID idPlayer, BOOL bAnsi );
88 static HRESULT DP_IF_CreatePlayer
89 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, LPDPID lpidPlayer,
90 LPDPNAME lpPlayerName, HANDLE hEvent, LPVOID lpData,
91 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi );
92 static HRESULT DP_IF_DestroyGroup
93 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idGroup, BOOL bAnsi );
94 static HRESULT DP_IF_DestroyPlayer
95 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idPlayer, BOOL bAnsi );
96 static HRESULT DP_IF_EnumGroupPlayers
97 ( IDirectPlay2Impl* This, DPID idGroup, LPGUID lpguidInstance,
98 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
99 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi );
100 static HRESULT DP_IF_EnumGroups
101 ( IDirectPlay2Impl* This, LPGUID lpguidInstance,
102 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
103 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi );
104 static HRESULT DP_IF_EnumPlayers
105 ( IDirectPlay2Impl* This, LPGUID lpguidInstance,
106 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
107 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi );
108 static HRESULT DP_IF_GetGroupData
109 ( IDirectPlay2Impl* This, DPID idGroup, LPVOID lpData,
110 LPDWORD lpdwDataSize, DWORD dwFlags, BOOL bAnsi );
111 static HRESULT DP_IF_GetGroupName
112 ( IDirectPlay2Impl* This, DPID idGroup, LPVOID lpData,
113 LPDWORD lpdwDataSize, BOOL bAnsi );
114 static HRESULT DP_IF_GetPlayerData
115 ( IDirectPlay2Impl* This, DPID idPlayer, LPVOID lpData,
116 LPDWORD lpdwDataSize, DWORD dwFlags, BOOL bAnsi );
117 static HRESULT DP_IF_GetPlayerName
118 ( IDirectPlay2Impl* This, DPID idPlayer, LPVOID lpData,
119 LPDWORD lpdwDataSize, BOOL bAnsi );
120 static HRESULT DP_IF_SetGroupName
121 ( IDirectPlay2Impl* This, DPID idGroup, LPDPNAME lpGroupName,
122 DWORD dwFlags, BOOL bAnsi );
123 static HRESULT DP_IF_SetPlayerData
124 ( IDirectPlay2Impl* This, DPID idPlayer, LPVOID lpData,
125 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi );
126 static HRESULT DP_IF_SetPlayerName
127 ( IDirectPlay2Impl* This, DPID idPlayer, LPDPNAME lpPlayerName,
128 DWORD dwFlags, BOOL bAnsi );
129 static HRESULT DP_IF_AddGroupToGroup
130 ( IDirectPlay3Impl* This, DPID idParentGroup, DPID idGroup );
131 static HRESULT DP_IF_CreateGroup
132 ( IDirectPlay2AImpl* This, LPVOID lpMsgHdr, LPDPID lpidGroup,
133 LPDPNAME lpGroupName, LPVOID lpData, DWORD dwDataSize,
134 DWORD dwFlags, BOOL bAnsi );
135 static HRESULT DP_IF_CreateGroupInGroup
136 ( IDirectPlay3Impl* This, LPVOID lpMsgHdr, DPID idParentGroup,
137 LPDPID lpidGroup, LPDPNAME lpGroupName, LPVOID lpData,
138 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi );
139 static HRESULT DP_IF_AddPlayerToGroup
140 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idGroup,
141 DPID idPlayer, BOOL bAnsi );
142 static HRESULT DP_IF_DeleteGroupFromGroup
143 ( IDirectPlay3Impl* This, DPID idParentGroup, DPID idGroup );
144 static HRESULT DP_SecureOpen
145 ( IDirectPlay2Impl* This, LPCDPSESSIONDESC2 lpsd, DWORD dwFlags,
146 LPCDPSECURITYDESC lpSecurity, LPCDPCREDENTIALS lpCredentials,
147 BOOL bAnsi );
148 static HRESULT DP_SendEx
149 ( IDirectPlay2Impl* This, DPID idFrom, DPID idTo, DWORD dwFlags,
150 LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
151 LPVOID lpContext, LPDWORD lpdwMsgID, BOOL bAnsi );
152 static HRESULT DP_IF_Receive
153 ( IDirectPlay2Impl* This, LPDPID lpidFrom, LPDPID lpidTo,
154 DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize, BOOL bAnsi );
155 static HRESULT DP_IF_GetMessageQueue
156 ( IDirectPlay4Impl* This, DPID idFrom, DPID idTo, DWORD dwFlags,
157 LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes, BOOL bAnsi );
158 static HRESULT DP_SP_SendEx
159 ( IDirectPlay2Impl* This, DWORD dwFlags,
160 LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
161 LPVOID lpContext, LPDWORD lpdwMsgID );
162 static HRESULT DP_IF_SetGroupData
163 ( IDirectPlay2Impl* This, DPID idGroup, LPVOID lpData,
164 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi );
165 static HRESULT DP_IF_GetPlayerCaps
166 ( IDirectPlay2Impl* This, DPID idPlayer, LPDPCAPS lpDPCaps,
167 DWORD dwFlags );
168 static HRESULT DP_IF_Close( IDirectPlay2Impl* This, BOOL bAnsi );
169 static HRESULT DP_IF_CancelMessage
170 ( IDirectPlay4Impl* This, DWORD dwMsgID, DWORD dwFlags,
171 DWORD dwMinPriority, DWORD dwMaxPriority, BOOL bAnsi );
172 static HRESULT DP_IF_EnumGroupsInGroup
173 ( IDirectPlay3AImpl* This, DPID idGroup, LPGUID lpguidInstance,
174 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
175 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi );
176 static HRESULT DP_IF_GetGroupParent
177 ( IDirectPlay3AImpl* This, DPID idGroup, LPDPID lpidGroup,
178 BOOL bAnsi );
179 static HRESULT DP_IF_GetCaps
180 ( IDirectPlay2Impl* This, LPDPCAPS lpDPCaps, DWORD dwFlags );
181 static HRESULT DP_IF_EnumSessions
182 ( IDirectPlay2Impl* This, LPDPSESSIONDESC2 lpsd, DWORD dwTimeout,
183 LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2,
184 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi );
185 static HRESULT DP_IF_InitializeConnection
186 ( IDirectPlay3Impl* This, LPVOID lpConnection, DWORD dwFlags, BOOL bAnsi );
187 static BOOL CALLBACK cbDPCreateEnumConnections( LPCGUID lpguidSP,
188 LPVOID lpConnection, DWORD dwConnectionSize, LPCDPNAME lpName,
189 DWORD dwFlags, LPVOID lpContext );
190 static BOOL DP_BuildCompoundAddr( GUID guidDataType, LPGUID lpcSpGuid,
191 LPVOID* lplpAddrBuf, LPDWORD lpdwBufSize );
192
193
194
195 static inline DPID DP_NextObjectId(void);
196 static DPID DP_GetRemoteNextObjectId(void);
197
198 static DWORD DP_CalcSessionDescSize( LPCDPSESSIONDESC2 lpSessDesc, BOOL bAnsi );
199 static void DP_CopySessionDesc( LPDPSESSIONDESC2 destSessionDesc,
200 LPCDPSESSIONDESC2 srcSessDesc, BOOL bAnsi );
201
202
203 static HMODULE DP_LoadSP( LPCGUID lpcGuid, LPSPINITDATA lpSpData, LPBOOL lpbIsDpSp );
204 static HRESULT DP_InitializeDPSP( IDirectPlay3Impl* This, HMODULE hServiceProvider );
205 static HRESULT DP_InitializeDPLSP( IDirectPlay3Impl* This, HMODULE hServiceProvider );
206
207
208
209
210
211
212 #define DPID_NOPARENT_GROUP 0 /* Magic number to indicate no parent of group */
213 #define DPID_SYSTEM_GROUP DPID_NOPARENT_GROUP /* If system group is supported
214 we don't have to change much */
215 #define DPID_NAME_SERVER 0x19a9d65b /* Don't ask me why */
216
217 /* Strip out dwFlag values which cannot be sent in the CREATEGROUP msg */
218 #define DPMSG_CREATEGROUP_DWFLAGS(x) ( (x) & DPGROUP_HIDDEN )
219
220 /* Strip out all dwFlags values for CREATEPLAYER msg */
221 #define DPMSG_CREATEPLAYER_DWFLAGS(x) 0
222
223 static LONG kludgePlayerGroupId = 1000;
224
225 /* ------------------------------------------------------------------ */
226
227
228 static BOOL DP_CreateIUnknown( LPVOID lpDP )
229 {
230 IDirectPlay2AImpl *This = lpDP;
231
232 This->unk = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *(This->unk) ) );
233 if ( This->unk == NULL )
234 {
235 return FALSE;
236 }
237
238 InitializeCriticalSection( &This->unk->DP_lock );
239 This->unk->DP_lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IDirectPlay2AImpl*->DirectPlayIUnknownData*->DP_lock");
240
241 return TRUE;
242 }
243
244 static BOOL DP_DestroyIUnknown( LPVOID lpDP )
245 {
246 IDirectPlay2AImpl *This = lpDP;
247
248 This->unk->DP_lock.DebugInfo->Spare[0] = 0;
249 DeleteCriticalSection( &This->unk->DP_lock );
250 HeapFree( GetProcessHeap(), 0, This->unk );
251
252 return TRUE;
253 }
254
255 static BOOL DP_CreateDirectPlay2( LPVOID lpDP )
256 {
257 IDirectPlay2AImpl *This = lpDP;
258
259 This->dp2 = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *(This->dp2) ) );
260 if ( This->dp2 == NULL )
261 {
262 return FALSE;
263 }
264
265 This->dp2->bConnectionOpen = FALSE;
266
267 This->dp2->hEnumSessionThread = INVALID_HANDLE_VALUE;
268 This->dp2->dwEnumSessionLock = 0;
269
270 This->dp2->bHostInterface = FALSE;
271
272 DPQ_INIT(This->dp2->receiveMsgs);
273 DPQ_INIT(This->dp2->sendMsgs);
274 DPQ_INIT(This->dp2->replysExpected);
275
276 if( !NS_InitializeSessionCache( &This->dp2->lpNameServerData ) )
277 {
278 /* FIXME: Memory leak */
279 return FALSE;
280 }
281
282 /* Provide an initial session desc with nothing in it */
283 This->dp2->lpSessionDesc = HeapAlloc( GetProcessHeap(),
284 HEAP_ZERO_MEMORY,
285 sizeof( *This->dp2->lpSessionDesc ) );
286 if( This->dp2->lpSessionDesc == NULL )
287 {
288 /* FIXME: Memory leak */
289 return FALSE;
290 }
291 This->dp2->lpSessionDesc->dwSize = sizeof( *This->dp2->lpSessionDesc );
292
293 /* We are emulating a dp 6 implementation */
294 This->dp2->spData.dwSPVersion = DPSP_MAJORVERSION;
295
296 This->dp2->spData.lpCB = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
297 sizeof( *This->dp2->spData.lpCB ) );
298 This->dp2->spData.lpCB->dwSize = sizeof( *This->dp2->spData.lpCB );
299 This->dp2->spData.lpCB->dwVersion = DPSP_MAJORVERSION;
300
301 /* This is the pointer to the service provider */
302 if( FAILED( DPSP_CreateInterface( &IID_IDirectPlaySP,
303 (LPVOID*)&This->dp2->spData.lpISP, This ) )
304 )
305 {
306 /* FIXME: Memory leak */
307 return FALSE;
308 }
309
310 /* Setup lobby provider information */
311 This->dp2->dplspData.dwSPVersion = DPSP_MAJORVERSION;
312 This->dp2->dplspData.lpCB = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
313 sizeof( *This->dp2->dplspData.lpCB ) );
314 This->dp2->dplspData.lpCB->dwSize = sizeof( *This->dp2->dplspData.lpCB );
315
316 if( FAILED( DPLSP_CreateInterface( &IID_IDPLobbySP,
317 (LPVOID*)&This->dp2->dplspData.lpISP, This ) )
318 )
319 {
320 /* FIXME: Memory leak */
321 return FALSE;
322 }
323
324 return TRUE;
325 }
326
327 /* Definition of the global function in dplayx_queue.h. #
328 * FIXME: Would it be better to have a dplayx_queue.c for this function? */
329 DPQ_DECL_DELETECB( cbDeleteElemFromHeap, LPVOID )
330 {
331 HeapFree( GetProcessHeap(), 0, elem );
332 }
333
334 static BOOL DP_DestroyDirectPlay2( LPVOID lpDP )
335 {
336 IDirectPlay2AImpl *This = lpDP;
337
338 if( This->dp2->hEnumSessionThread != INVALID_HANDLE_VALUE )
339 {
340 TerminateThread( This->dp2->hEnumSessionThread, 0 );
341 CloseHandle( This->dp2->hEnumSessionThread );
342 }
343
344 /* Finish with the SP - have it shutdown */
345 if( This->dp2->spData.lpCB->ShutdownEx )
346 {
347 DPSP_SHUTDOWNDATA data;
348
349 TRACE( "Calling SP ShutdownEx\n" );
350
351 data.lpISP = This->dp2->spData.lpISP;
352
353 (*This->dp2->spData.lpCB->ShutdownEx)( &data );
354 }
355 else if (This->dp2->spData.lpCB->Shutdown ) /* obsolete interface */
356 {
357 TRACE( "Calling obsolete SP Shutdown\n" );
358 (*This->dp2->spData.lpCB->Shutdown)();
359 }
360
361 /* Unload the SP (if it exists) */
362 if( This->dp2->hServiceProvider != 0 )
363 {
364 FreeLibrary( This->dp2->hServiceProvider );
365 }
366
367 /* Unload the Lobby Provider (if it exists) */
368 if( This->dp2->hDPLobbyProvider != 0 )
369 {
370 FreeLibrary( This->dp2->hDPLobbyProvider );
371 }
372
373 /* FIXME: Need to delete receive and send msgs queue contents */
374
375 NS_DeleteSessionCache( This->dp2->lpNameServerData );
376
377 HeapFree( GetProcessHeap(), 0, This->dp2->lpSessionDesc );
378
379 IDirectPlaySP_Release( This->dp2->spData.lpISP );
380
381 /* Delete the contents */
382 HeapFree( GetProcessHeap(), 0, This->dp2 );
383
384 return TRUE;
385 }
386
387 static BOOL DP_CreateDirectPlay3( LPVOID lpDP )
388 {
389 IDirectPlay3AImpl *This = lpDP;
390
391 This->dp3 = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *(This->dp3) ) );
392 if ( This->dp3 == NULL )
393 {
394 return FALSE;
395 }
396
397 return TRUE;
398 }
399
400 static BOOL DP_DestroyDirectPlay3( LPVOID lpDP )
401 {
402 IDirectPlay3AImpl *This = lpDP;
403
404 /* Delete the contents */
405 HeapFree( GetProcessHeap(), 0, This->dp3 );
406
407 return TRUE;
408 }
409
410 static BOOL DP_CreateDirectPlay4( LPVOID lpDP )
411 {
412 IDirectPlay4AImpl *This = lpDP;
413
414 This->dp4 = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *(This->dp4) ) );
415 if ( This->dp4 == NULL )
416 {
417 return FALSE;
418 }
419
420 return TRUE;
421 }
422
423 static BOOL DP_DestroyDirectPlay4( LPVOID lpDP )
424 {
425 IDirectPlay3AImpl *This = lpDP;
426
427 /* Delete the contents */
428 HeapFree( GetProcessHeap(), 0, This->dp4 );
429
430 return TRUE;
431 }
432
433
434 /* Create a new interface */
435 HRESULT DP_CreateInterface
436 ( REFIID riid, LPVOID* ppvObj )
437 {
438 TRACE( " for %s\n", debugstr_guid( riid ) );
439
440 *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
441 sizeof( IDirectPlay2Impl ) );
442
443 if( *ppvObj == NULL )
444 {
445 return DPERR_OUTOFMEMORY;
446 }
447
448 if( IsEqualGUID( &IID_IDirectPlay2, riid ) )
449 {
450 IDirectPlay2Impl *This = *ppvObj;
451 This->lpVtbl = &directPlay2WVT;
452 }
453 else if( IsEqualGUID( &IID_IDirectPlay2A, riid ) )
454 {
455 IDirectPlay2AImpl *This = *ppvObj;
456 This->lpVtbl = &directPlay2AVT;
457 }
458 else if( IsEqualGUID( &IID_IDirectPlay3, riid ) )
459 {
460 IDirectPlay3Impl *This = *ppvObj;
461 This->lpVtbl = &directPlay3WVT;
462 }
463 else if( IsEqualGUID( &IID_IDirectPlay3A, riid ) )
464 {
465 IDirectPlay3AImpl *This = *ppvObj;
466 This->lpVtbl = &directPlay3AVT;
467 }
468 else if( IsEqualGUID( &IID_IDirectPlay4, riid ) )
469 {
470 IDirectPlay4Impl *This = *ppvObj;
471 This->lpVtbl = &directPlay4WVT;
472 }
473 else if( IsEqualGUID( &IID_IDirectPlay4A, riid ) )
474 {
475 IDirectPlay4AImpl *This = *ppvObj;
476 This->lpVtbl = &directPlay4AVT;
477 }
478 else
479 {
480 /* Unsupported interface */
481 HeapFree( GetProcessHeap(), 0, *ppvObj );
482 *ppvObj = NULL;
483
484 return E_NOINTERFACE;
485 }
486
487 /* Initialize it */
488 if ( DP_CreateIUnknown( *ppvObj ) &&
489 DP_CreateDirectPlay2( *ppvObj ) &&
490 DP_CreateDirectPlay3( *ppvObj ) &&
491 DP_CreateDirectPlay4( *ppvObj )
492 )
493 {
494 IDirectPlayX_AddRef( (LPDIRECTPLAY2A)*ppvObj );
495
496 return S_OK;
497 }
498
499 /* Initialize failed, destroy it */
500 DP_DestroyDirectPlay4( *ppvObj );
501 DP_DestroyDirectPlay3( *ppvObj );
502 DP_DestroyDirectPlay2( *ppvObj );
503 DP_DestroyIUnknown( *ppvObj );
504
505 HeapFree( GetProcessHeap(), 0, *ppvObj );
506
507 *ppvObj = NULL;
508 return DPERR_NOMEMORY;
509 }
510
511
512 /* Direct Play methods */
513
514 /* Shared between all dplay types */
515 static HRESULT WINAPI DP_QueryInterface
516 ( LPDIRECTPLAY2 iface, REFIID riid, LPVOID* ppvObj )
517 {
518 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
519 TRACE("(%p)->(%s,%p)\n", This, debugstr_guid( riid ), ppvObj );
520
521 *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
522 sizeof( *This ) );
523
524 if( *ppvObj == NULL )
525 {
526 return DPERR_OUTOFMEMORY;
527 }
528
529 CopyMemory( *ppvObj, This, sizeof( *This ) );
530 (*(IDirectPlay2Impl**)ppvObj)->ulInterfaceRef = 0;
531
532 if( IsEqualGUID( &IID_IDirectPlay2, riid ) )
533 {
534 IDirectPlay2Impl *This = *ppvObj;
535 This->lpVtbl = &directPlay2WVT;
536 }
537 else if( IsEqualGUID( &IID_IDirectPlay2A, riid ) )
538 {
539 IDirectPlay2AImpl *This = *ppvObj;
540 This->lpVtbl = &directPlay2AVT;
541 }
542 else if( IsEqualGUID( &IID_IDirectPlay3, riid ) )
543 {
544 IDirectPlay3Impl *This = *ppvObj;
545 This->lpVtbl = &directPlay3WVT;
546 }
547 else if( IsEqualGUID( &IID_IDirectPlay3A, riid ) )
548 {
549 IDirectPlay3AImpl *This = *ppvObj;
550 This->lpVtbl = &directPlay3AVT;
551 }
552 else if( IsEqualGUID( &IID_IDirectPlay4, riid ) )
553 {
554 IDirectPlay4Impl *This = *ppvObj;
555 This->lpVtbl = &directPlay4WVT;
556 }
557 else if( IsEqualGUID( &IID_IDirectPlay4A, riid ) )
558 {
559 IDirectPlay4AImpl *This = *ppvObj;
560 This->lpVtbl = &directPlay4AVT;
561 }
562 else
563 {
564 /* Unsupported interface */
565 HeapFree( GetProcessHeap(), 0, *ppvObj );
566 *ppvObj = NULL;
567
568 return E_NOINTERFACE;
569 }
570
571 IDirectPlayX_AddRef( (LPDIRECTPLAY2)*ppvObj );
572
573 return S_OK;
574 }
575
576 /* Shared between all dplay types */
577 static ULONG WINAPI DP_AddRef
578 ( LPDIRECTPLAY3 iface )
579 {
580 ULONG ulInterfaceRefCount, ulObjRefCount;
581 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
582
583 ulObjRefCount = InterlockedIncrement( &This->unk->ulObjRef );
584 ulInterfaceRefCount = InterlockedIncrement( &This->ulInterfaceRef );
585
586 TRACE( "ref count incremented to %u:%u for %p\n",
587 ulInterfaceRefCount, ulObjRefCount, This );
588
589 return ulObjRefCount;
590 }
591
592 static ULONG WINAPI DP_Release
593 ( LPDIRECTPLAY3 iface )
594 {
595 ULONG ulInterfaceRefCount, ulObjRefCount;
596
597 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
598
599 ulObjRefCount = InterlockedDecrement( &This->unk->ulObjRef );
600 ulInterfaceRefCount = InterlockedDecrement( &This->ulInterfaceRef );
601
602 TRACE( "ref count decremented to %u:%u for %p\n",
603 ulInterfaceRefCount, ulObjRefCount, This );
604
605 /* Deallocate if this is the last reference to the object */
606 if( ulObjRefCount == 0 )
607 {
608 /* If we're destroying the object, this must be the last ref
609 of the last interface */
610 DP_DestroyDirectPlay4( This );
611 DP_DestroyDirectPlay3( This );
612 DP_DestroyDirectPlay2( This );
613 DP_DestroyIUnknown( This );
614 }
615
616 /* Deallocate the interface */
617 if( ulInterfaceRefCount == 0 )
618 {
619 HeapFree( GetProcessHeap(), 0, This );
620 }
621
622 return ulObjRefCount;
623 }
624
625 static inline DPID DP_NextObjectId(void)
626 {
627 return (DPID)InterlockedIncrement( &kludgePlayerGroupId );
628 }
629
630 /* *lplpReply will be non NULL iff there is something to reply */
631 HRESULT DP_HandleMessage( IDirectPlay2Impl* This, LPCVOID lpcMessageBody,
632 DWORD dwMessageBodySize, LPCVOID lpcMessageHeader,
633 WORD wCommandId, WORD wVersion,
634 LPVOID* lplpReply, LPDWORD lpdwMsgSize )
635 {
636 TRACE( "(%p)->(%p,0x%08x,%p,0x%x,%u)\n",
637 This, lpcMessageBody, dwMessageBodySize, lpcMessageHeader, wCommandId,
638 wVersion );
639
640 switch( wCommandId )
641 {
642 /* Name server needs to handle this request */
643 case DPMSGCMD_ENUMSESSIONS:
644 {
645 /* Reply expected */
646 NS_ReplyToEnumSessionsRequest( lpcMessageBody, lplpReply, lpdwMsgSize, This );
647
648 break;
649 }
650
651 /* Name server needs to handle this request */
652 case DPMSGCMD_ENUMSESSIONSREPLY:
653 {
654 /* No reply expected */
655 NS_AddRemoteComputerAsNameServer( lpcMessageHeader,
656 This->dp2->spData.dwSPHeaderSize,
657 lpcMessageBody,
658 This->dp2->lpNameServerData );
659 break;
660 }
661
662 case DPMSGCMD_REQUESTPLAYERID:
663 {
664 LPDPSP_MSG_REQUESTPLAYERID lpcMsg = lpcMessageBody;
665 LPDPSP_MSG_REQUESTPLAYERREPLY lpReply;
666
667 *lpdwMsgSize = This->dp2->spData.dwSPHeaderSize + sizeof( *lpReply );
668
669 *lplpReply = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, *lpdwMsgSize );
670
671 lpReply = (LPDPSP_MSG_REQUESTPLAYERREPLY)( (LPBYTE)(*lplpReply) +
672 This->dp2->spData.dwSPHeaderSize );
673
674 lpReply->envelope.dwMagic = DPMSG_SIGNATURE;
675 lpReply->envelope.wCommandId = DPMSGCMD_REQUESTPLAYERREPLY;
676 lpReply->envelope.wVersion = DX61AVERSION;
677
678 if ( lpcMsg->Flags & DPLAYI_PLAYER_SYSPLAYER )
679 {
680 /* Request to join the game */
681
682 if ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_SECURESERVER )
683 {
684 FIXME( "Fill lpReply->SecDesc with Game->SSPIProvider\n" );
685 }
686 FIXME( "Fill lpReply->CAPIProvider with Game->CAPIProvider\n" );
687 FIXME( "Fill lpReply->SecDesc->dwEncryptionAlgorithm with Game->EncryptionAlgorithm\n" );
688
689 /* Player is not local anymore */
690 lpcMsg->Flags ^= DPLAYI_PLAYER_PLAYERLOCAL;
691
692 lpReply->ID = DP_NextObjectId();
693 lpReply->Result = DP_IF_CreatePlayer( This, lpcMessageHeader,
694 &lpReply->ID, NULL, 0, NULL, 0,
695 lpcMsg->Flags, TRUE/*TODO*/ );
696 lpReply->Result = S_OK;
697 }
698 else
699 {
700 /* Request to to add a normal player from an
701 * existing member of the session */
702
703 if ( ( This->dp2->lpSessionDesc->dwCurrentPlayers
704 == This->dp2->lpSessionDesc->dwMaxPlayers ) ||
705 ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_NEWPLAYERSDISABLED ) )
706 {
707 lpReply->Result = DPERR_NONEWPLAYERS;
708 }
709 else
710 {
711 lpReply->ID = DP_NextObjectId();
712 lpReply->Result = S_OK;
713 }
714 }
715
716 break;
717 }
718
719 case DPMSGCMD_PACKET:
720 {
721 LPCDPSP_MSG_PACKET lpcMsg = lpcMessageBody;
722 LPDPSP_MSG_ENVELOPE packetData;
723
724 /* TODO: We have to wait for all the messages in the sequence and
725 * assemble them in a bigger message. */
726 if ( lpcMsg->TotalPackets > 1 )
727 {
728 FIXME( "TODO: Message belongs to a sequence of %d, implement assembly\n",
729 lpcMsg->TotalPackets );
730 return DPERR_GENERIC;
731 }
732
733 /* For now, for simplicity we'll just decapsulate the embedded
734 * message and work with it. */
735 packetData = (LPVOID)(lpcMsg + 1);
736
737 TRACE( "Processing embedded message with envelope (0x%08x, 0x%08x, %d)\n",
738 packetData->dwMagic, packetData->wCommandId, packetData->wVersion );
739
740 return DP_HandleMessage( This,
741 packetData,
742 lpcMsg->DataSize,
743 lpcMessageHeader,
744 packetData->wCommandId,
745 packetData->wVersion,
746 lplpReply, lpdwMsgSize );
747 break;
748 }
749
750 case DPMSGCMD_REQUESTPLAYERREPLY:
751 {
752 DP_MSG_ReplyReceived( This, wCommandId, lpcMessageHeader,
753 lpcMessageBody, dwMessageBodySize );
754 break;
755 }
756
757 case DPMSGCMD_ADDFORWARDREQUEST:
758 {
759 /*LPCDPSP_MSG_ADDFORWARDREQUEST lpcMsg =
760 (LPCDPSP_MSG_ADDFORWARDREQUEST) lpcMessageBody;*/
761
762 /* TODO: Send ADDFORWARD messages to all the players to populate
763 * their name tables.
764 * Start NametablePopulation timer and wait for ADDFORWARDACKs */
765 FIXME( "Spread name table population messages\n" );
766
767 /* TODO remember to set local addr somewhere */
768 /* call NS_SetLocalAddr with a SOCKADDR_IN */
769
770 FIXME( "This should happen after we received all the DPMSGCMD_ADDFORWARDACKs\n" );
771 DP_MSG_ReplyToEnumPlayersRequest( This, lplpReply, lpdwMsgSize );
772
773 break;
774 }
775
776 case DPMSGCMD_ADDFORWARDREPLY:
777 {
778 DP_MSG_ReplyReceived( This, wCommandId, lpcMessageHeader,
779 lpcMessageBody, dwMessageBodySize );
780 break;
781 }
782
783 case DPMSGCMD_ENUMPLAYERSREPLY:
784 case DPMSGCMD_SUPERENUMPLAYERSREPLY:
785 {
786 /* If we're joining a session, when we receive this
787 * command we were waiting for a ADDFORWARDREPLY */
788 if ( !DP_MSG_ReplyReceived( This, DPMSGCMD_ADDFORWARDREPLY,
789 lpcMessageHeader, lpcMessageBody,
790 dwMessageBodySize ) )
791 {
792 /* If we were not joining a session, check if we are
793 * waiting for an enumeration of players or groups */
794 DP_MSG_ReplyReceived( This, wCommandId, lpcMessageHeader,
795 lpcMessageBody, dwMessageBodySize );
796 }
797 break;
798 }
799
800 case DPMSGCMD_ADDFORWARDACK:
801 {
802 /* When we receive an ADDFORWARDACK for each of the ADDFORWARDs
803 * we've sent, send a SUPERENUMPLAYERSREPLY back to the peer
804 * that sent the ADDFORWARDREQUEST */
805 /* TODO: We'll skip this for now and just send the SUPERENUMPLAYERSREPLY
806 * right away when we get a ADDFORWARDREQUEST */
807 break;
808 }
809
810 default:
811 {
812 FIXME( "Unknown wCommandId 0x%08x. Ignoring message\n", wCommandId );
813 return DPERR_GENERIC;
814 }
815 }
816
817 return DP_OK;
818 }
819
820
821 static HRESULT DP_IF_AddPlayerToGroup
822 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idGroup,
823 DPID idPlayer, BOOL bAnsi )
824 {
825 lpGroupData lpGData;
826 lpPlayerList lpPList;
827 lpPlayerList lpNewPList;
828
829 TRACE( "(%p)->(%p,0x%08x,0x%08x,%u)\n",
830 This, lpMsgHdr, idGroup, idPlayer, bAnsi );
831
832 if( This->dp2->connectionInitialized == NO_PROVIDER )
833 {
834 return DPERR_UNINITIALIZED;
835 }
836
837 /* Find the group */
838 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
839 {
840 return DPERR_INVALIDGROUP;
841 }
842
843 /* Find the player */
844 if( ( lpPList = DP_FindPlayer( This, idPlayer ) ) == NULL )
845 {
846 return DPERR_INVALIDPLAYER;
847 }
848
849 /* Create a player list (ie "shortcut" ) */
850 lpNewPList = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpNewPList ) );
851 if( lpNewPList == NULL )
852 {
853 return DPERR_CANTADDPLAYER;
854 }
855
856 /* Add the shortcut */
857 lpPList->lpPData->uRef++;
858 lpNewPList->lpPData = lpPList->lpPData;
859
860 /* Add the player to the list of players for this group */
861 DPQ_INSERT(lpGData->players,lpNewPList,players);
862
863 /* Let the SP know that we've added a player to the group */
864 if( This->dp2->spData.lpCB->AddPlayerToGroup )
865 {
866 DPSP_ADDPLAYERTOGROUPDATA data;
867
868 TRACE( "Calling SP AddPlayerToGroup\n" );
869
870 data.idPlayer = idPlayer;
871 data.idGroup = idGroup;
872 data.lpISP = This->dp2->spData.lpISP;
873
874 (*This->dp2->spData.lpCB->AddPlayerToGroup)( &data );
875 }
876
877 /* Inform all other peers of the addition of player to the group. If there are
878 * no peers keep this event quiet.
879 * Also, if this event was the result of another machine sending it to us,
880 * don't bother rebroadcasting it.
881 */
882 if( ( lpMsgHdr == NULL ) &&
883 This->dp2->lpSessionDesc &&
884 ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_MULTICASTSERVER ) )
885 {
886 DPMSG_ADDPLAYERTOGROUP msg;
887 msg.dwType = DPSYS_ADDPLAYERTOGROUP;
888
889 msg.dpIdGroup = idGroup;
890 msg.dpIdPlayer = idPlayer;
891
892 /* FIXME: Correct to just use send effectively? */
893 /* FIXME: Should size include data w/ message or just message "header" */
894 /* FIXME: Check return code */
895 DP_SendEx( This, DPID_SERVERPLAYER, DPID_ALLPLAYERS, 0, &msg, sizeof( msg ), 0, 0, NULL, NULL, bAnsi );
896 }
897
898 return DP_OK;
899 }
900
901 static HRESULT WINAPI DirectPlay2AImpl_AddPlayerToGroup
902 ( LPDIRECTPLAY2A iface, DPID idGroup, DPID idPlayer )
903 {
904 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
905 return DP_IF_AddPlayerToGroup( This, NULL, idGroup, idPlayer, TRUE );
906 }
907
908 static HRESULT WINAPI DirectPlay2WImpl_AddPlayerToGroup
909 ( LPDIRECTPLAY2 iface, DPID idGroup, DPID idPlayer )
910 {
911 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
912 return DP_IF_AddPlayerToGroup( This, NULL, idGroup, idPlayer, FALSE );
913 }
914
915 static HRESULT DP_IF_Close( IDirectPlay2Impl* This, BOOL bAnsi )
916 {
917 HRESULT hr = DP_OK;
918
919 TRACE("(%p)->(%u)\n", This, bAnsi );
920
921 /* FIXME: Need to find a new host I assume (how?) */
922 /* FIXME: Need to destroy all local groups */
923 /* FIXME: Need to migrate all remotely visible players to the new host */
924
925 /* Invoke the SP callback to inform of session close */
926 if( This->dp2->spData.lpCB->CloseEx )
927 {
928 DPSP_CLOSEDATA data;
929
930 TRACE( "Calling SP CloseEx\n" );
931
932 data.lpISP = This->dp2->spData.lpISP;
933
934 hr = (*This->dp2->spData.lpCB->CloseEx)( &data );
935
936 }
937 else if ( This->dp2->spData.lpCB->Close ) /* Try obsolete version */
938 {
939 TRACE( "Calling SP Close (obsolete interface)\n" );
940
941 hr = (*This->dp2->spData.lpCB->Close)();
942 }
943
944 if ( !FAILED(hr) )
945 {
946 This->dp2->bConnectionOpen = FALSE;
947 }
948
949 return hr;
950 }
951
952 static HRESULT WINAPI DirectPlay2AImpl_Close
953 ( LPDIRECTPLAY2A iface )
954 {
955 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
956 return DP_IF_Close( This, TRUE );
957 }
958
959 static HRESULT WINAPI DirectPlay2WImpl_Close
960 ( LPDIRECTPLAY2 iface )
961 {
962 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
963 return DP_IF_Close( This, FALSE );
964 }
965
966 static
967 lpGroupData DP_CreateGroup( IDirectPlay2AImpl* This, const DPID *lpid,
968 const DPNAME *lpName, DWORD dwFlags,
969 DPID idParent, BOOL bAnsi )
970 {
971 lpGroupData lpGData;
972
973 /* Allocate the new space and add to end of high level group list */
974 lpGData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpGData ) );
975
976 if( lpGData == NULL )
977 {
978 return NULL;
979 }
980
981 DPQ_INIT(lpGData->groups);
982 DPQ_INIT(lpGData->players);
983
984 /* Set the desired player ID - no sanity checking to see if it exists */
985 lpGData->dpid = *lpid;
986
987 DP_CopyDPNAMEStruct( &lpGData->name, lpName, bAnsi );
988
989 /* FIXME: Should we check that the parent exists? */
990 lpGData->parent = idParent;
991
992 /* FIXME: Should we validate the dwFlags? */
993 lpGData->dwFlags = dwFlags;
994
995 TRACE( "Created group id 0x%08x\n", *lpid );
996
997 return lpGData;
998 }
999
1000 /* This method assumes that all links to it are already deleted */
1001 static void
1002 DP_DeleteGroup( IDirectPlay2Impl* This, DPID dpid )
1003 {
1004 lpGroupList lpGList;
1005
1006 TRACE( "(%p)->(0x%08x)\n", This, dpid );
1007
1008 DPQ_REMOVE_ENTRY( This->dp2->lpSysGroup->groups, groups, lpGData->dpid, ==, dpid, lpGList );
1009
1010 if( lpGList == NULL )
1011 {
1012 ERR( "DPID 0x%08x not found\n", dpid );
1013 return;
1014 }
1015
1016 if( --(lpGList->lpGData->uRef) )
1017 {
1018 FIXME( "Why is this not the last reference to group?\n" );
1019 DebugBreak();
1020 }
1021
1022 /* Delete player */
1023 DP_DeleteDPNameStruct( &lpGList->lpGData->name );
1024 HeapFree( GetProcessHeap(), 0, lpGList->lpGData );
1025
1026 /* Remove and Delete Player List object */
1027 HeapFree( GetProcessHeap(), 0, lpGList );
1028
1029 }
1030
1031 static lpGroupData DP_FindAnyGroup( IDirectPlay2AImpl* This, DPID dpid )
1032 {
1033 lpGroupList lpGroups;
1034
1035 TRACE( "(%p)->(0x%08x)\n", This, dpid );
1036
1037 if( dpid == DPID_SYSTEM_GROUP )
1038 {
1039 return This->dp2->lpSysGroup;
1040 }
1041 else
1042 {
1043 DPQ_FIND_ENTRY( This->dp2->lpSysGroup->groups, groups, lpGData->dpid, ==, dpid, lpGroups );
1044 }
1045
1046 if( lpGroups == NULL )
1047 {
1048 return NULL;
1049 }
1050
1051 return lpGroups->lpGData;
1052 }
1053
1054 static HRESULT DP_IF_CreateGroup
1055 ( IDirectPlay2AImpl* This, LPVOID lpMsgHdr, LPDPID lpidGroup,
1056 LPDPNAME lpGroupName, LPVOID lpData, DWORD dwDataSize,
1057 DWORD dwFlags, BOOL bAnsi )
1058 {
1059 lpGroupData lpGData;
1060
1061 TRACE( "(%p)->(%p,%p,%p,%p,0x%08x,0x%08x,%u)\n",
1062 This, lpMsgHdr, lpidGroup, lpGroupName, lpData, dwDataSize,
1063 dwFlags, bAnsi );
1064
1065 /* If the name is not specified, we must provide one */
1066 if( DPID_UNKNOWN == *lpidGroup )
1067 {
1068 /* If we are the name server, we decide on the group ids. If not, we
1069 * must ask for one before attempting a creation.
1070 */
1071 if( This->dp2->bHostInterface )
1072 {
1073 *lpidGroup = DP_NextObjectId();
1074 }
1075 else
1076 {
1077 *lpidGroup = DP_GetRemoteNextObjectId();
1078 }
1079 }
1080
1081 lpGData = DP_CreateGroup( This, lpidGroup, lpGroupName, dwFlags,
1082 DPID_NOPARENT_GROUP, bAnsi );
1083
1084 if( lpGData == NULL )
1085 {
1086 return DPERR_CANTADDPLAYER; /* yes player not group */
1087 }
1088
1089 if( DPID_SYSTEM_GROUP == *lpidGroup )
1090 {
1091 This->dp2->lpSysGroup = lpGData;
1092 TRACE( "Inserting system group\n" );
1093 }
1094 else
1095 {
1096 /* Insert into the system group */
1097 lpGroupList lpGroup = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpGroup ) );
1098 lpGroup->lpGData = lpGData;
1099
1100 DPQ_INSERT( This->dp2->lpSysGroup->groups, lpGroup, groups );
1101 }
1102
1103 /* Something is now referencing this data */
1104 lpGData->uRef++;
1105
1106 /* Set all the important stuff for the group */
1107 DP_SetGroupData( lpGData, DPSET_REMOTE, lpData, dwDataSize );
1108
1109 /* FIXME: We should only create the system group if GetCaps returns
1110 * DPCAPS_GROUPOPTIMIZED.
1111 */
1112
1113 /* Let the SP know that we've created this group */
1114 if( This->dp2->spData.lpCB->CreateGroup )
1115 {
1116 DPSP_CREATEGROUPDATA data;
1117 DWORD dwCreateFlags = 0;
1118
1119 TRACE( "Calling SP CreateGroup\n" );
1120
1121 if( *lpidGroup == DPID_NOPARENT_GROUP )
1122 dwCreateFlags |= DPLAYI_GROUP_SYSGROUP;
1123
1124 if( lpMsgHdr == NULL )
1125 dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
1126
1127 if( dwFlags & DPGROUP_HIDDEN )
1128 dwCreateFlags |= DPLAYI_GROUP_HIDDEN;
1129
1130 data.idGroup = *lpidGroup;
1131 data.dwFlags = dwCreateFlags;
1132 data.lpSPMessageHeader = lpMsgHdr;
1133 data.lpISP = This->dp2->spData.lpISP;
1134
1135 (*This->dp2->spData.lpCB->CreateGroup)( &data );
1136 }
1137
1138 /* Inform all other peers of the creation of a new group. If there are
1139 * no peers keep this event quiet.
1140 * Also if this message was sent to us, don't rebroadcast.
1141 */
1142 if( ( lpMsgHdr == NULL ) &&
1143 This->dp2->lpSessionDesc &&
1144 ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_MULTICASTSERVER ) )
1145 {
1146 DPMSG_CREATEPLAYERORGROUP msg;
1147 msg.dwType = DPSYS_CREATEPLAYERORGROUP;
1148
1149 msg.dwPlayerType = DPPLAYERTYPE_GROUP;
1150 msg.dpId = *lpidGroup;
1151 msg.dwCurrentPlayers = 0; /* FIXME: Incorrect? */
1152 msg.lpData = lpData;
1153 msg.dwDataSize = dwDataSize;
1154 msg.dpnName = *lpGroupName;
1155 msg.dpIdParent = DPID_NOPARENT_GROUP;
1156 msg.dwFlags = DPMSG_CREATEGROUP_DWFLAGS( dwFlags );
1157
1158 /* FIXME: Correct to just use send effectively? */
1159 /* FIXME: Should size include data w/ message or just message "header" */
1160 /* FIXME: Check return code */
1161 DP_SendEx( This, DPID_SERVERPLAYER, DPID_ALLPLAYERS, 0, &msg, sizeof( msg ),
1162 0, 0, NULL, NULL, bAnsi );
1163 }
1164
1165 return DP_OK;
1166 }
1167
1168 static HRESULT WINAPI DirectPlay2AImpl_CreateGroup
1169 ( LPDIRECTPLAY2A iface, LPDPID lpidGroup, LPDPNAME lpGroupName,
1170 LPVOID lpData, DWORD dwDataSize, DWORD dwFlags )
1171 {
1172 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1173
1174 if( This->dp2->connectionInitialized == NO_PROVIDER )
1175 {
1176 return DPERR_UNINITIALIZED;
1177 }
1178
1179 if( lpidGroup == NULL ||
1180 !This->dp2->bConnectionOpen ||
1181 dwDataSize >= MAXDWORD ||
1182 ( lpData == NULL && dwDataSize != 0 ) )
1183 {
1184 return DPERR_INVALIDPARAMS;
1185 }
1186
1187 *lpidGroup = DPID_UNKNOWN;
1188
1189 return DP_IF_CreateGroup( This, NULL, lpidGroup,
1190 lpGroupName, lpData, dwDataSize, dwFlags, TRUE );
1191 }
1192
1193 static HRESULT WINAPI DirectPlay2WImpl_CreateGroup
1194 ( LPDIRECTPLAY2 iface, LPDPID lpidGroup, LPDPNAME lpGroupName,
1195 LPVOID lpData, DWORD dwDataSize, DWORD dwFlags )
1196 {
1197 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1198
1199 if( This->dp2->connectionInitialized == NO_PROVIDER )
1200 {
1201 return DPERR_UNINITIALIZED;
1202 }
1203
1204 if( lpidGroup == NULL ||
1205 !This->dp2->bConnectionOpen ||
1206 dwDataSize >= MAXDWORD ||
1207 ( lpData == NULL && dwDataSize != 0 ) )
1208 {
1209 return DPERR_INVALIDPARAMS;
1210 }
1211
1212 *lpidGroup = DPID_UNKNOWN;
1213
1214 return DP_IF_CreateGroup( This, NULL, lpidGroup,
1215 lpGroupName, lpData, dwDataSize, dwFlags, FALSE );
1216 }
1217
1218
1219 static void
1220 DP_SetGroupData( lpGroupData lpGData, DWORD dwFlags,
1221 LPVOID lpData, DWORD dwDataSize )
1222 {
1223 /* Clear out the data with this player */
1224 if( dwFlags & DPSET_LOCAL )
1225 {
1226 if ( lpGData->dwLocalDataSize != 0 )
1227 {
1228 HeapFree( GetProcessHeap(), 0, lpGData->lpLocalData );
1229 lpGData->lpLocalData = NULL;
1230 lpGData->dwLocalDataSize = 0;
1231 }
1232 }
1233 else
1234 {
1235 if( lpGData->dwRemoteDataSize != 0 )
1236 {
1237 HeapFree( GetProcessHeap(), 0, lpGData->lpRemoteData );
1238 lpGData->lpRemoteData = NULL;
1239 lpGData->dwRemoteDataSize = 0;
1240 }
1241 }
1242
1243 /* Reallocate for new data */
1244 if( lpData != NULL )
1245 {
1246 LPVOID lpNewData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1247 sizeof( dwDataSize ) );
1248 CopyMemory( lpNewData, lpData, dwDataSize );
1249
1250 if( dwFlags & DPSET_LOCAL )
1251 {
1252 lpGData->lpLocalData = lpData;
1253 lpGData->dwLocalDataSize = dwDataSize;
1254 }
1255 else
1256 {
1257 lpGData->lpRemoteData = lpNewData;
1258 lpGData->dwRemoteDataSize = dwDataSize;
1259 }
1260 }
1261
1262 }
1263
1264
1265 HRESULT DP_CreatePlayer( IDirectPlay2Impl* This, DPID idPlayer,
1266 LPDPNAME lpName, DWORD dwFlags,
1267 LPVOID lpData, DWORD dwDataSize,
1268 HANDLE hEvent, BOOL bAnsi,
1269 lpPlayerData* lplpPlayer )
1270 {
1271 /* Create the storage for a new player and insert
1272 * it in the list of players. */
1273
1274 lpPlayerList lpPList = NULL;
1275 lpPlayerData lpPlayer;
1276 HRESULT hr;
1277
1278 TRACE( "(%p)->(0x%08x,%p,0x%08x,%p,%d,%p,%u,%p)\n",
1279 This, idPlayer, lpName, dwFlags, lpData,
1280 dwDataSize, hEvent, bAnsi, lplpPlayer );
1281
1282 /* Verify that we don't already have this player */
1283 DPQ_FIND_ENTRY( This->dp2->lpSysGroup->players, players,
1284 lpPData->dpid, ==, idPlayer, lpPList );
1285 if ( lpPList != NULL )
1286 {
1287 hr = DPERR_CANTCREATEPLAYER;
1288 goto end;
1289 }
1290
1291 /* Allocate the storage for the player and associate it with list element */
1292 lpPlayer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpPlayer ) );
1293 if( lpPlayer == NULL )
1294 {
1295 hr = DPERR_CANTCREATEPLAYER;
1296 goto end;
1297 }
1298
1299 if ( lplpPlayer != NULL )
1300 {
1301 *lplpPlayer = lpPlayer;
1302 }
1303
1304 lpPlayer->dpid = idPlayer;
1305 lpPlayer->dwFlags = dwFlags;
1306
1307 DP_CopyDPNAMEStruct( &lpPlayer->name, lpName, bAnsi );
1308
1309 /* If we were given an event handle, duplicate it */
1310 if( hEvent != 0 )
1311 {
1312 if( !DuplicateHandle( GetCurrentProcess(), hEvent,
1313 GetCurrentProcess(), &lpPlayer->hEvent,
1314 0, FALSE, DUPLICATE_SAME_ACCESS ) )
1315 {
1316 ERR( "Can't duplicate player msg handle %p\n", hEvent );
1317 hr = DPERR_CANTCREATEPLAYER;
1318 goto end;
1319 }
1320 }
1321
1322 /* Set player data */
1323 if ( lpData != NULL )
1324 {
1325 DP_SetPlayerData( lpPlayer, DPSET_REMOTE, lpData, dwDataSize );
1326 }
1327
1328 /* Initialize the SP data section */
1329 lpPlayer->lpSPPlayerData = DPSP_CreateSPPlayerData();
1330
1331 if( ~dwFlags & DPLAYI_PLAYER_SYSPLAYER )
1332 {
1333 This->dp2->lpSessionDesc->dwCurrentPlayers++;
1334 }
1335
1336 /* Create the list object and link it in */
1337 lpPList = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpPList ) );
1338 if( lpPList == NULL )
1339 {
1340 hr = DPERR_CANTADDPLAYER;
1341 goto end;
1342 }
1343
1344 lpPlayer->uRef = 1;
1345 lpPList->lpPData = lpPlayer;
1346
1347 /* Add the player to the system group */
1348 DPQ_INSERT( This->dp2->lpSysGroup->players, lpPList, players );
1349
1350 /* Quick hack */
1351 if ( ~dwFlags & DPLAYI_PLAYER_PLAYERLOCAL ) {
1352 lpPlayerList lpPList;
1353 LPDPMSG lpMsg =
1354 HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct DPMSG) );
1355 LPDPMSG_CREATEPLAYERORGROUP msg =
1356 HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DPMSG_CREATEPLAYERORGROUP) );
1357
1358 msg->dwType = DPSYS_CREATEPLAYERORGROUP;
1359 msg->dwPlayerType = DPPLAYERTYPE_PLAYER;
1360 msg->dpId = idPlayer;
1361 msg->dwCurrentPlayers = This->dp2->lpSessionDesc->dwCurrentPlayers;
1362 msg->lpData = NULL;/*TODO*/
1363 msg->dwDataSize = 0;/*TODO*/
1364 msg->dpIdParent = DPID_NOPARENT_GROUP;
1365 msg->dwFlags = DPMSG_CREATEPLAYER_DWFLAGS( dwFlags );
1366 if ( lpName )
1367 {
1368 msg->dpnName = *lpName;
1369 }
1370
1371 lpMsg->msg = (LPDPMSG_GENERIC) msg;
1372 lpMsg->dwMsgSize = sizeof(LPDPMSG_CREATEPLAYERORGROUP);
1373 DPQ_INSERT( This->dp2->receiveMsgs, lpMsg, msgs );
1374
1375 if ( (lpPList = DPQ_FIRST( This->dp2->lpSysGroup->players )) )
1376 {
1377 do
1378 {
1379 if ( ( lpPList->lpPData->dwFlags & DPLAYI_PLAYER_PLAYERLOCAL ) &&
1380 lpPList->lpPData->hEvent )
1381 {
1382 SetEvent( lpPList->lpPData->hEvent );
1383 }
1384 }
1385 while( (lpPList = DPQ_NEXT( lpPList->players )) );
1386 }
1387 }
1388
1389 end:
1390 if ( FAILED(hr) )
1391 {
1392 DP_DeletePlayer( This, idPlayer );
1393 }
1394 return hr;
1395 }
1396
1397 /* Delete the contents of the DPNAME struct */
1398 static void
1399 DP_DeleteDPNameStruct( LPDPNAME lpDPName )
1400 {
1401 HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->u1.lpszShortNameA );
1402 HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->u2.lpszLongNameA );
1403 }
1404
1405 /* This method assumes that all links to it are already deleted */
1406 static void
1407 DP_DeletePlayer( IDirectPlay2Impl* This, DPID dpid )
1408 {
1409 lpPlayerList lpPList;
1410
1411 TRACE( "(%p)->(0x%08x)\n", This, dpid );
1412
1413 DPQ_REMOVE_ENTRY( This->dp2->lpSysGroup->players, players, lpPData->dpid, ==, dpid, lpPList );
1414
1415 if( lpPList == NULL )
1416 {
1417 ERR( "DPID 0x%08x not found\n", dpid );
1418 return;
1419 }
1420
1421 /* Verify that this is the last reference to the data */
1422 if( --(lpPList->lpPData->uRef) )
1423 {
1424 FIXME( "Why is this not the last reference to player?\n" );
1425 DebugBreak();
1426 }
1427
1428 /* Delete player */
1429 DP_DeleteDPNameStruct( &lpPList->lpPData->name );
1430
1431 CloseHandle( lpPList->lpPData->hEvent );
1432 HeapFree( GetProcessHeap(), 0, lpPList->lpPData );
1433
1434 /* Delete Player List object */
1435 HeapFree( GetProcessHeap(), 0, lpPList );
1436 }
1437
1438 lpPlayerList DP_FindPlayer( IDirectPlay2AImpl* This, DPID dpid )
1439 {
1440 lpPlayerList lpPlayers;
1441
1442 TRACE( "(%p)->(0x%08x)\n", This, dpid );
1443
1444 if(This->dp2->lpSysGroup == NULL)
1445 return NULL;
1446
1447 DPQ_FIND_ENTRY( This->dp2->lpSysGroup->players, players, lpPData->dpid, ==, dpid, lpPlayers );
1448
1449 return lpPlayers;
1450 }
1451
1452 /* Basic area for Dst must already be allocated */
1453 static BOOL DP_CopyDPNAMEStruct( LPDPNAME lpDst, const DPNAME *lpSrc, BOOL bAnsi )
1454 {
1455 if( lpSrc == NULL )
1456 {
1457 ZeroMemory( lpDst, sizeof( *lpDst ) );
1458 lpDst->dwSize = sizeof( *lpDst );
1459 return TRUE;
1460 }
1461
1462 if( lpSrc->dwSize != sizeof( *lpSrc) )
1463 {
1464 return FALSE;
1465 }
1466
1467 /* Delete any existing pointers */
1468 HeapFree( GetProcessHeap(), 0, lpDst->u1.lpszShortNameA );
1469 HeapFree( GetProcessHeap(), 0, lpDst->u2.lpszLongNameA );
1470
1471 /* Copy as required */
1472 CopyMemory( lpDst, lpSrc, lpSrc->dwSize );
1473
1474 if( bAnsi )
1475 {
1476 if( lpSrc->u1.lpszShortNameA )
1477 {
1478 lpDst->u1.lpszShortNameA = HeapAlloc( GetProcessHeap(), 0,
1479 strlen(lpSrc->u1.lpszShortNameA)+1 );
1480 strcpy( lpDst->u1.lpszShortNameA, lpSrc->u1.lpszShortNameA );
1481 }
1482 else
1483 {
1484 lpDst->u1.lpszShortNameA = NULL;
1485 }
1486 if( lpSrc->u2.lpszLongNameA )
1487 {
1488 lpDst->u2.lpszLongNameA = HeapAlloc( GetProcessHeap(), 0,
1489 strlen(lpSrc->u2.lpszLongNameA)+1 );
1490 strcpy( lpDst->u2.lpszLongNameA, lpSrc->u2.lpszLongNameA );
1491 }
1492 else
1493 {
1494 lpDst->u2.lpszLongNameA = NULL;
1495 }
1496 }
1497 else
1498 {
1499 if( lpSrc->u1.lpszShortNameA )
1500 {
1501 lpDst->u1.lpszShortName = HeapAlloc( GetProcessHeap(), 0,
1502 (strlenW(lpSrc->u1.lpszShortName)+1)*sizeof(WCHAR) );
1503 strcpyW( lpDst->u1.lpszShortName, lpSrc->u1.lpszShortName );
1504 }
1505 else
1506 {
1507 lpDst->u1.lpszShortNameA = NULL;
1508 }
1509 if( lpSrc->u2.lpszLongNameA )
1510 {
1511 lpDst->u2.lpszLongName = HeapAlloc( GetProcessHeap(), 0,
1512 (strlenW(lpSrc->u2.lpszLongName)+1)*sizeof(WCHAR) );
1513 strcpyW( lpDst->u2.lpszLongName, lpSrc->u2.lpszLongName );
1514 }
1515 else
1516 {
1517 lpDst->u2.lpszLongNameA = NULL;
1518 }
1519 }
1520
1521 return TRUE;
1522 }
1523
1524 static void
1525 DP_SetPlayerData( lpPlayerData lpPData, DWORD dwFlags,
1526 LPVOID lpData, DWORD dwDataSize )
1527 {
1528 /* Clear out the data with this player */
1529 if( dwFlags & DPSET_LOCAL )
1530 {
1531 if ( lpPData->dwLocalDataSize != 0 )
1532 {
1533 HeapFree( GetProcessHeap(), 0, lpPData->lpLocalData );
1534 lpPData->lpLocalData = NULL;
1535 lpPData->dwLocalDataSize = 0;
1536 }
1537 }
1538 else
1539 {
1540 if( lpPData->dwRemoteDataSize != 0 )
1541 {
1542 HeapFree( GetProcessHeap(), 0, lpPData->lpRemoteData );
1543 lpPData->lpRemoteData = NULL;
1544 lpPData->dwRemoteDataSize = 0;
1545 }
1546 }
1547
1548 /* Reallocate for new data */
1549 if( lpData != NULL )
1550 {
1551 LPVOID lpNewData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1552 sizeof( dwDataSize ) );
1553 CopyMemory( lpNewData, lpData, dwDataSize );
1554
1555 if( dwFlags & DPSET_LOCAL )
1556 {
1557 lpPData->lpLocalData = lpData;
1558 lpPData->dwLocalDataSize = dwDataSize;
1559 }
1560 else
1561 {
1562 lpPData->lpRemoteData = lpNewData;
1563 lpPData->dwRemoteDataSize = dwDataSize;
1564 }
1565 }
1566
1567 }
1568
1569 static HRESULT DP_IF_CreatePlayer
1570 ( IDirectPlay2Impl* This,
1571 LPVOID lpMsgHdr, /* NULL for local creation, non NULL for remote creation */
1572 LPDPID lpidPlayer,
1573 LPDPNAME lpPlayerName,
1574 HANDLE hEvent,
1575 LPVOID lpData,
1576 DWORD dwDataSize,
1577 DWORD dwFlags,
1578 BOOL bAnsi )
1579 {
1580 HRESULT hr = DP_OK;
1581 lpPlayerData lpPData;
1582
1583 TRACE( "(%p)->(%p,%p,%p,%p,0x%08x,0x%08x,%u)\n",
1584 This, lpidPlayer, lpPlayerName, hEvent, lpData,
1585 dwDataSize, dwFlags, bAnsi );
1586
1587 if( dwFlags == 0 )
1588 {
1589 dwFlags = DPPLAYER_SPECTATOR;
1590 }
1591
1592 if( lpidPlayer == NULL )
1593 {
1594 return DPERR_INVALIDPARAMS;
1595 }
1596
1597
1598 /* Determine the creation flags for the player. These will be passed
1599 * to the name server if requesting a player id and to the SP when
1600 * informing it of the player creation
1601 */
1602 {
1603 if( dwFlags & DPPLAYER_SERVERPLAYER )
1604 {
1605 if( *lpidPlayer == DPID_SERVERPLAYER )
1606 {
1607 /* Server player for the host interface */
1608 dwFlags |= DPLAYI_PLAYER_APPSERVER;
1609 }
1610 else if( *lpidPlayer == DPID_NAME_SERVER )
1611 {
1612 /* Name server - master of everything */
1613 dwFlags |= (DPLAYI_PLAYER_NAMESRVR|DPLAYI_PLAYER_SYSPLAYER);
1614 }
1615 else
1616 {
1617 /* Server player for a non host interface */
1618 dwFlags |= DPLAYI_PLAYER_SYSPLAYER;
1619 }
1620 }
1621
1622 if( lpMsgHdr == NULL )
1623 dwFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
1624 }
1625
1626 /* Verify we know how to handle all the flags */
1627 if( !( ( dwFlags & DPPLAYER_SERVERPLAYER ) ||
1628 ( dwFlags & DPPLAYER_SPECTATOR )
1629 )
1630 )
1631 {
1632 /* Assume non fatal failure */
1633 ERR( "unknown dwFlags = 0x%08x\n", dwFlags );
1634 }
1635
1636 /* If the name is not specified, we must provide one */
1637 if( *lpidPlayer == DPID_UNKNOWN )
1638 {
1639 /* If we are the session master, we dish out the group/player ids */
1640 if( This->dp2->bHostInterface )
1641 {
1642 *lpidPlayer = DP_NextObjectId();
1643 }
1644 else
1645 {
1646 hr = DP_MSG_SendRequestPlayerId( This, dwFlags & 0x000000FF, lpidPlayer );
1647
1648 if( FAILED(hr) )
1649 {
1650 ERR( "Request for ID failed: %s\n", DPLAYX_HresultToString( hr ) );
1651 return hr;
1652 }
1653 }
1654 }
1655
1656 hr = DP_CreatePlayer( This, *lpidPlayer, lpPlayerName, dwFlags,
1657 lpData, dwDataSize, hEvent, bAnsi,
1658 &lpPData );
1659 if( FAILED(hr) )
1660 {
1661 return hr;
1662 }
1663
1664 /* Let the SP know that we've created this player */
1665 if( This->dp2->spData.lpCB->CreatePlayer )
1666 {
1667 DPSP_CREATEPLAYERDATA data;
1668
1669 data.idPlayer = *lpidPlayer;
1670 data.dwFlags = dwFlags;
1671 data.lpSPMessageHeader = lpMsgHdr;
1672 data.lpISP = This->dp2->spData.lpISP;
1673
1674 TRACE( "Calling SP CreatePlayer 0x%08x: dwFlags: 0x%08x lpMsgHdr: %p\n",
1675 *lpidPlayer, data.dwFlags, data.lpSPMessageHeader );
1676
1677 hr = (*This->dp2->spData.lpCB->CreatePlayer)( &data );
1678 }
1679
1680 if( FAILED(hr) )
1681 {
1682 ERR( "Failed to create player with sp: %s\n", DPLAYX_HresultToString(hr) );
1683 return hr;
1684 }
1685
1686 /* Now let the SP know that this player is a member of the system group */
1687 if( This->dp2->spData.lpCB->AddPlayerToGroup )
1688 {
1689 DPSP_ADDPLAYERTOGROUPDATA data;
1690
1691 data.idPlayer = *lpidPlayer;
1692 data.idGroup = DPID_SYSTEM_GROUP;
1693 data.lpISP = This->dp2->spData.lpISP;
1694
1695 TRACE( "Calling SP AddPlayerToGroup (sys group)\n" );
1696
1697 hr = (*This->dp2->spData.lpCB->AddPlayerToGroup)( &data );
1698 }
1699
1700 if( FAILED(hr) )
1701 {
1702 ERR( "Failed to add player to sys group with sp: %s\n",
1703 DPLAYX_HresultToString(hr) );
1704 return hr;
1705 }
1706
1707
1708 if ( ( ! This->dp2->bHostInterface ) && ( lpMsgHdr == NULL ) )
1709 {
1710 if ( dwFlags & DPLAYI_PLAYER_SYSPLAYER )
1711 {
1712 /* Let the name server know about the creation of this player,
1713 * and reeceive the name table */
1714 hr = DP_MSG_ForwardPlayerCreation( This, *lpidPlayer);
1715 }
1716 else
1717 {
1718 /* Inform all other peers of the creation of a new player.
1719 * Also, if this was a remote event, no need to rebroadcast it. */
1720 hr = DP_MSG_SendCreatePlayer( This, lpPData );
1721 }
1722 }
1723
1724 return hr;
1725 }
1726
1727 static HRESULT WINAPI DirectPlay2AImpl_CreatePlayer
1728 ( LPDIRECTPLAY2A iface, LPDPID lpidPlayer, LPDPNAME lpPlayerName,
1729 HANDLE hEvent, LPVOID lpData, DWORD dwDataSize, DWORD dwFlags )
1730 {
1731 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1732
1733 if( This->dp2->connectionInitialized == NO_PROVIDER )
1734 {
1735 return DPERR_UNINITIALIZED;
1736 }
1737
1738 if( lpidPlayer == NULL || !This->dp2->bConnectionOpen )
1739 {
1740 return DPERR_INVALIDPARAMS;
1741 }
1742
1743 if ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_NEWPLAYERSDISABLED )
1744 {
1745 return DPERR_CANTCREATEPLAYER;
1746 }
1747
1748 if( dwFlags & DPPLAYER_SERVERPLAYER )
1749 {
1750 *lpidPlayer = DPID_SERVERPLAYER;
1751 }
1752 else
1753 {
1754 *lpidPlayer = DPID_UNKNOWN;
1755 }
1756
1757 return DP_IF_CreatePlayer( This, NULL, lpidPlayer, lpPlayerName, hEvent,
1758 lpData, dwDataSize, dwFlags, TRUE );
1759 }
1760
1761 static HRESULT WINAPI DirectPlay2WImpl_CreatePlayer
1762 ( LPDIRECTPLAY2 iface, LPDPID lpidPlayer, LPDPNAME lpPlayerName,
1763 HANDLE hEvent, LPVOID lpData, DWORD dwDataSize, DWORD dwFlags )
1764 {
1765 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1766
1767 if( This->dp2->connectionInitialized == NO_PROVIDER )
1768 {
1769 return DPERR_UNINITIALIZED;
1770 }
1771
1772 if( lpidPlayer == NULL || !This->dp2->bConnectionOpen )
1773 {
1774 return DPERR_INVALIDPARAMS;
1775 }
1776
1777 if ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_NEWPLAYERSDISABLED )
1778 {
1779 return DPERR_CANTCREATEPLAYER;
1780 }
1781
1782 if( dwFlags & DPPLAYER_SERVERPLAYER )
1783 {
1784 *lpidPlayer = DPID_SERVERPLAYER;
1785 }
1786 else
1787 {
1788 *lpidPlayer = DPID_UNKNOWN;
1789 }
1790
1791 return DP_IF_CreatePlayer( This, NULL, lpidPlayer, lpPlayerName, hEvent,
1792 lpData, dwDataSize, dwFlags, FALSE );
1793 }
1794
1795 static DPID DP_GetRemoteNextObjectId(void)
1796 {
1797 FIXME( ":stub\n" );
1798
1799 /* Hack solution */
1800 return DP_NextObjectId();
1801 }
1802
1803 static HRESULT DP_IF_DeletePlayerFromGroup
1804 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idGroup,
1805 DPID idPlayer, BOOL bAnsi )
1806 {
1807 HRESULT hr = DP_OK;
1808
1809 lpGroupData lpGData;
1810 lpPlayerList lpPList;
1811
1812 TRACE( "(%p)->(%p,0x%08x,0x%08x,%u)\n",
1813 This, lpMsgHdr, idGroup, idPlayer, bAnsi );
1814
1815 /* Find the group */
1816 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
1817 {
1818 return DPERR_INVALIDGROUP;
1819 }
1820
1821 /* Find the player */
1822 if( ( lpPList = DP_FindPlayer( This, idPlayer ) ) == NULL )
1823 {
1824 return DPERR_INVALIDPLAYER;
1825 }
1826
1827 /* Remove the player shortcut from the group */
1828 DPQ_REMOVE_ENTRY( lpGData->players, players, lpPData->dpid, ==, idPlayer, lpPList );
1829
1830 if( lpPList == NULL )
1831 {
1832 return DPERR_INVALIDPLAYER;
1833 }
1834
1835 /* One less reference */
1836 lpPList->lpPData->uRef--;
1837
1838 /* Delete the Player List element */
1839 HeapFree( GetProcessHeap(), 0, lpPList );
1840
1841 /* Inform the SP if they care */
1842 if( This->dp2->spData.lpCB->RemovePlayerFromGroup )
1843 {
1844 DPSP_REMOVEPLAYERFROMGROUPDATA data;
1845
1846 TRACE( "Calling SP RemovePlayerFromGroup\n" );
1847
1848 data.idPlayer = idPlayer;
1849 data.idGroup = idGroup;
1850 data.lpISP = This->dp2->spData.lpISP;
1851
1852 hr = (*This->dp2->spData.lpCB->RemovePlayerFromGroup)( &data );
1853 }
1854
1855 /* Need to send a DELETEPLAYERFROMGROUP message */
1856 FIXME( "Need to send a message\n" );
1857
1858 return hr;
1859 }
1860
1861 static HRESULT WINAPI DirectPlay2AImpl_DeletePlayerFromGroup
1862 ( LPDIRECTPLAY2A iface, DPID idGroup, DPID idPlayer )
1863 {
1864 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1865 return DP_IF_DeletePlayerFromGroup( This, NULL, idGroup, idPlayer, TRUE );
1866 }
1867
1868 static HRESULT WINAPI DirectPlay2WImpl_DeletePlayerFromGroup
1869 ( LPDIRECTPLAY2 iface, DPID idGroup, DPID idPlayer )
1870 {
1871 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1872 return DP_IF_DeletePlayerFromGroup( This, NULL, idGroup, idPlayer, FALSE );
1873 }
1874
1875 typedef struct _DPRGOPContext
1876 {
1877 IDirectPlay3Impl* This;
1878 BOOL bAnsi;
1879 DPID idGroup;
1880 } DPRGOPContext, *lpDPRGOPContext;
1881
1882 static BOOL CALLBACK
1883 cbRemoveGroupOrPlayer(
1884 DPID dpId,
1885 DWORD dwPlayerType,
1886 LPCDPNAME lpName,
1887 DWORD dwFlags,
1888 LPVOID lpContext )
1889 {
1890 lpDPRGOPContext lpCtxt = (lpDPRGOPContext)lpContext;
1891
1892 TRACE( "Removing element:0x%08x (type:0x%08x) from element:0x%08x\n",
1893 dpId, dwPlayerType, lpCtxt->idGroup );
1894
1895 if( dwPlayerType == DPPLAYERTYPE_GROUP )
1896 {
1897 if( FAILED( DP_IF_DeleteGroupFromGroup( lpCtxt->This, lpCtxt->idGroup,
1898 dpId )
1899 )
1900 )
1901 {
1902 ERR( "Unable to delete group 0x%08x from group 0x%08x\n",
1903 dpId, lpCtxt->idGroup );
1904 }
1905 }
1906 else
1907 {
1908 if( FAILED( DP_IF_DeletePlayerFromGroup( (IDirectPlay2Impl*)lpCtxt->This,
1909 NULL, lpCtxt->idGroup,
1910 dpId, lpCtxt->bAnsi )
1911 )
1912 )
1913 {
1914 ERR( "Unable to delete player 0x%08x from grp 0x%08x\n",
1915 dpId, lpCtxt->idGroup );
1916 }
1917 }
1918
1919 return TRUE; /* Continue enumeration */
1920 }
1921
1922 static HRESULT DP_IF_DestroyGroup
1923 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idGroup, BOOL bAnsi )
1924 {
1925 lpGroupData lpGData;
1926 DPRGOPContext context;
1927
1928 FIXME( "(%p)->(%p,0x%08x,%u): semi stub\n",
1929 This, lpMsgHdr, idGroup, bAnsi );
1930
1931 /* Find the group */
1932 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
1933 {
1934 return DPERR_INVALIDPLAYER; /* yes player */
1935 }
1936
1937 context.This = (IDirectPlay3Impl*)This;
1938 context.bAnsi = bAnsi;
1939 context.idGroup = idGroup;
1940
1941 /* Remove all players that this group has */
1942 DP_IF_EnumGroupPlayers( This, idGroup, NULL,
1943 cbRemoveGroupOrPlayer, &context, 0, bAnsi );
1944
1945 /* Remove all links to groups that this group has since this is dp3 */
1946 DP_IF_EnumGroupsInGroup( (IDirectPlay3Impl*)This, idGroup, NULL,
1947 cbRemoveGroupOrPlayer, (LPVOID)&context, 0, bAnsi );
1948
1949 /* Remove this group from the parent group - if it has one */
1950 if( ( idGroup != DPID_SYSTEM_GROUP ) &&
1951 ( lpGData->parent != DPID_SYSTEM_GROUP )
1952 )
1953 {
1954 DP_IF_DeleteGroupFromGroup( (IDirectPlay3Impl*)This, lpGData->parent,
1955 idGroup );
1956 }
1957
1958 /* Now delete this group data and list from the system group */
1959 DP_DeleteGroup( This, idGroup );
1960
1961 /* Let the SP know that we've destroyed this group */
1962 if( This->dp2->spData.lpCB->DeleteGroup )
1963 {
1964 DPSP_DELETEGROUPDATA data;
1965
1966 FIXME( "data.dwFlags is incorrect\n" );
1967
1968 data.idGroup = idGroup;
1969 data.dwFlags = 0;
1970 data.lpISP = This->dp2->spData.lpISP;
1971
1972 (*This->dp2->spData.lpCB->DeleteGroup)( &data );
1973 }
1974
1975 FIXME( "Send out a DESTORYPLAYERORGROUP message\n" );
1976
1977 return DP_OK;
1978 }
1979
1980 static HRESULT WINAPI DirectPlay2AImpl_DestroyGroup
1981 ( LPDIRECTPLAY2A iface, DPID idGroup )
1982 {
1983 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1984 return DP_IF_DestroyGroup( This, NULL, idGroup, TRUE );
1985 }
1986
1987 static HRESULT WINAPI DirectPlay2WImpl_DestroyGroup
1988 ( LPDIRECTPLAY2 iface, DPID idGroup )
1989 {
1990 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
1991 return DP_IF_DestroyGroup( This, NULL, idGroup, FALSE );
1992 }
1993
1994 typedef struct _DPFAGContext
1995 {
1996 IDirectPlay2Impl* This;
1997 DPID idPlayer;
1998 BOOL bAnsi;
1999 } DPFAGContext, *lpDPFAGContext;
2000
2001 static HRESULT DP_IF_DestroyPlayer
2002 ( IDirectPlay2Impl* This, LPVOID lpMsgHdr, DPID idPlayer, BOOL bAnsi )
2003 {
2004 DPFAGContext cbContext;
2005
2006 FIXME( "(%p)->(%p,0x%08x,%u): semi stub\n",
2007 This, lpMsgHdr, idPlayer, bAnsi );
2008
2009 if( This->dp2->connectionInitialized == NO_PROVIDER )
2010 {
2011 return DPERR_UNINITIALIZED;
2012 }
2013
2014 if( DP_FindPlayer( This, idPlayer ) == NULL )
2015 {
2016 return DPERR_INVALIDPLAYER;
2017 }
2018
2019 /* FIXME: If the player is remote, we must be the host to delete this */
2020
2021 cbContext.This = This;
2022 cbContext.idPlayer = idPlayer;
2023 cbContext.bAnsi = bAnsi;
2024
2025 /* Find each group and call DeletePlayerFromGroup if the player is a
2026 member of the group */
2027 DP_IF_EnumGroups( This, NULL, cbDeletePlayerFromAllGroups,
2028 &cbContext, DPENUMGROUPS_ALL, bAnsi );
2029
2030 /* Now delete player and player list from the sys group */
2031 DP_DeletePlayer( This, idPlayer );
2032
2033 /* Let the SP know that we've destroyed this group */
2034 if( This->dp2->spData.lpCB->DeletePlayer )
2035 {
2036 DPSP_DELETEPLAYERDATA data;
2037
2038 FIXME( "data.dwFlags is incorrect\n" );
2039
2040 data.idPlayer = idPlayer;
2041 data.dwFlags = 0;
2042 data.lpISP = This->dp2->spData.lpISP;
2043
2044 (*This->dp2->spData.lpCB->DeletePlayer)( &data );
2045 }
2046
2047 FIXME( "Send a DELETEPLAYERORGROUP msg\n" );
2048
2049 return DP_OK;
2050 }
2051
2052 static BOOL CALLBACK
2053 cbDeletePlayerFromAllGroups(
2054 DPID dpId,
2055 DWORD dwPlayerType,
2056 LPCDPNAME lpName,
2057 DWORD dwFlags,
2058 LPVOID lpContext )
2059 {
2060 lpDPFAGContext lpCtxt = (lpDPFAGContext)lpContext;
2061
2062 if( dwPlayerType == DPPLAYERTYPE_GROUP )
2063 {
2064 DP_IF_DeletePlayerFromGroup( lpCtxt->This, NULL, dpId, lpCtxt->idPlayer,
2065 lpCtxt->bAnsi );
2066
2067 /* Enumerate all groups in this group since this will normally only
2068 * be called for top level groups
2069 */
2070 DP_IF_EnumGroupsInGroup( (IDirectPlay3Impl*)lpCtxt->This,
2071 dpId, NULL,
2072 cbDeletePlayerFromAllGroups,
2073 lpContext, DPENUMGROUPS_ALL,
2074 lpCtxt->bAnsi );
2075
2076 }
2077 else
2078 {
2079 ERR( "Group callback has dwPlayerType = 0x%08x\n", dwPlayerType );
2080 }
2081
2082 return TRUE;
2083 }
2084
2085 static HRESULT WINAPI DirectPlay2AImpl_DestroyPlayer
2086 ( LPDIRECTPLAY2A iface, DPID idPlayer )
2087 {
2088 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2089 return DP_IF_DestroyPlayer( This, NULL, idPlayer, TRUE );
2090 }
2091
2092 static HRESULT WINAPI DirectPlay2WImpl_DestroyPlayer
2093 ( LPDIRECTPLAY2 iface, DPID idPlayer )
2094 {
2095 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2096 return DP_IF_DestroyPlayer( This, NULL, idPlayer, FALSE );
2097 }
2098
2099 static HRESULT DP_IF_EnumGroupPlayers
2100 ( IDirectPlay2Impl* This, DPID idGroup, LPGUID lpguidInstance,
2101 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2102 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi )
2103 {
2104 lpGroupData lpGData;
2105 lpPlayerList lpPList;
2106
2107 FIXME("(%p)->(0x%08x,%p,%p,%p,0x%08x,%u): semi stub\n",
2108 This, idGroup, lpguidInstance, lpEnumPlayersCallback2,
2109 lpContext, dwFlags, bAnsi );
2110
2111 if( This->dp2->connectionInitialized == NO_PROVIDER )
2112 {
2113 return DPERR_UNINITIALIZED;
2114 }
2115
2116 if( !This->dp2->bConnectionOpen )
2117 {
2118 return DPERR_NOSESSIONS;
2119 }
2120
2121 if( ( lpEnumPlayersCallback2 == NULL ) ||
2122 ( ( dwFlags & DPENUMPLAYERS_SESSION ) && ( lpguidInstance == NULL ) ) )
2123 {
2124 return DPERR_INVALIDPARAMS;
2125 }
2126
2127 /* Find the group */
2128 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
2129 {
2130 return DPERR_INVALIDGROUP;
2131 }
2132
2133 if( DPQ_IS_EMPTY( lpGData->players ) )
2134 {
2135 return DP_OK;
2136 }
2137
2138 lpPList = DPQ_FIRST( lpGData->players );
2139
2140 /* Walk the players in this group */
2141 for( ;; )
2142 {
2143 /* We do not enum the name server or app server as they are of no
2144 * consequence to the end user.
2145 */
2146 if( ( lpPList->lpPData->dpid != DPID_NAME_SERVER ) &&
2147 ( lpPList->lpPData->dpid != DPID_SERVERPLAYER )
2148 )
2149 {
2150
2151 /* FIXME: Need to add stuff for dwFlags checking */
2152
2153 if( !lpEnumPlayersCallback2( lpPList->lpPData->dpid, DPPLAYERTYPE_PLAYER,
2154 &lpPList->lpPData->name,
2155 lpPList->lpPData->dwFlags,
2156 lpContext )
2157 )
2158 {
2159 /* User requested break */
2160 return DP_OK;
2161 }
2162 }
2163
2164 if( DPQ_IS_ENDOFLIST( lpPList->players ) )
2165 {
2166 break;
2167 }
2168
2169 lpPList = DPQ_NEXT( lpPList->players );
2170 }
2171
2172 return DP_OK;
2173 }
2174
2175 static HRESULT WINAPI DirectPlay2AImpl_EnumGroupPlayers
2176 ( LPDIRECTPLAY2A iface, DPID idGroup, LPGUID lpguidInstance,
2177 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2178 LPVOID lpContext, DWORD dwFlags )
2179 {
2180 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2181 return DP_IF_EnumGroupPlayers( This, idGroup, lpguidInstance,
2182 lpEnumPlayersCallback2, lpContext,
2183 dwFlags, TRUE );
2184 }
2185
2186 static HRESULT WINAPI DirectPlay2WImpl_EnumGroupPlayers
2187 ( LPDIRECTPLAY2 iface, DPID idGroup, LPGUID lpguidInstance,
2188 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2189 LPVOID lpContext, DWORD dwFlags )
2190 {
2191 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2192 return DP_IF_EnumGroupPlayers( This, idGroup, lpguidInstance,
2193 lpEnumPlayersCallback2, lpContext,
2194 dwFlags, FALSE );
2195 }
2196
2197 /* NOTE: This only enumerates top level groups (created with CreateGroup) */
2198 static HRESULT DP_IF_EnumGroups
2199 ( IDirectPlay2Impl* This, LPGUID lpguidInstance,
2200 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2201 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi )
2202 {
2203 return DP_IF_EnumGroupsInGroup( (IDirectPlay3Impl*)This,
2204 DPID_SYSTEM_GROUP, lpguidInstance,
2205 lpEnumPlayersCallback2, lpContext,
2206 dwFlags, bAnsi );
2207 }
2208
2209 static HRESULT WINAPI DirectPlay2AImpl_EnumGroups
2210 ( LPDIRECTPLAY2A iface, LPGUID lpguidInstance,
2211 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2212 LPVOID lpContext, DWORD dwFlags )
2213 {
2214 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2215 return DP_IF_EnumGroups( This, lpguidInstance, lpEnumPlayersCallback2,
2216 lpContext, dwFlags, TRUE );
2217 }
2218
2219 static HRESULT WINAPI DirectPlay2WImpl_EnumGroups
2220 ( LPDIRECTPLAY2 iface, LPGUID lpguidInstance,
2221 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2222 LPVOID lpContext, DWORD dwFlags )
2223 {
2224 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2225 return DP_IF_EnumGroups( This, lpguidInstance, lpEnumPlayersCallback2,
2226 lpContext, dwFlags, FALSE );
2227 }
2228
2229 static HRESULT DP_IF_EnumPlayers
2230 ( IDirectPlay2Impl* This, LPGUID lpguidInstance,
2231 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2232 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi )
2233 {
2234 return DP_IF_EnumGroupPlayers( This, DPID_SYSTEM_GROUP, lpguidInstance,
2235 lpEnumPlayersCallback2, lpContext,
2236 dwFlags, bAnsi );
2237 }
2238
2239 static HRESULT WINAPI DirectPlay2AImpl_EnumPlayers
2240 ( LPDIRECTPLAY2A iface, LPGUID lpguidInstance,
2241 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2242 LPVOID lpContext, DWORD dwFlags )
2243 {
2244 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2245 return DP_IF_EnumPlayers( This, lpguidInstance, lpEnumPlayersCallback2,
2246 lpContext, dwFlags, TRUE );
2247 }
2248
2249 static HRESULT WINAPI DirectPlay2WImpl_EnumPlayers
2250 ( LPDIRECTPLAY2 iface, LPGUID lpguidInstance,
2251 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
2252 LPVOID lpContext, DWORD dwFlags )
2253 {
2254 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2255 return DP_IF_EnumPlayers( This, lpguidInstance, lpEnumPlayersCallback2,
2256 lpContext, dwFlags, FALSE );
2257 }
2258
2259 /* This function should call the registered callback function that the user
2260 passed into EnumSessions for each entry available.
2261 */
2262 static void DP_InvokeEnumSessionCallbacks
2263 ( LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2,
2264 LPVOID lpNSInfo,
2265 DWORD dwTimeout,
2266 LPVOID lpContext )
2267 {
2268 LPDPSESSIONDESC2 lpSessionDesc;
2269
2270 FIXME( ": not checking for conditions\n" );
2271
2272 /* Not sure if this should be pruning but it's convenient */
2273 NS_PruneSessionCache( lpNSInfo );
2274
2275 NS_ResetSessionEnumeration( lpNSInfo );
2276
2277 /* Enumerate all sessions */
2278 /* FIXME: Need to indicate ANSI */
2279 while( (lpSessionDesc = NS_WalkSessions( lpNSInfo ) ) != NULL )
2280 {
2281 TRACE( "EnumSessionsCallback2 invoked\n" );
2282 if( !lpEnumSessionsCallback2( lpSessionDesc, &dwTimeout, 0, lpContext ) )
2283 {
2284 return;
2285 }
2286 }
2287
2288 /* Invoke one last time to indicate that there is no more to come */
2289 lpEnumSessionsCallback2( NULL, &dwTimeout, DPESC_TIMEDOUT, lpContext );
2290 }
2291
2292 static DWORD CALLBACK DP_EnumSessionsSendAsyncRequestThread( LPVOID lpContext )
2293 {
2294 EnumSessionAsyncCallbackData* data = lpContext;
2295 HANDLE hSuicideRequest = data->hSuicideRequest;
2296 DWORD dwTimeout = data->dwTimeout;
2297
2298 TRACE( "Thread started with timeout = 0x%08x\n", dwTimeout );
2299
2300 for( ;; )
2301 {
2302 HRESULT hr;
2303
2304 /* Sleep up to dwTimeout waiting for request to terminate thread */
2305 if( WaitForSingleObject( hSuicideRequest, dwTimeout ) == WAIT_OBJECT_0 )
2306 {
2307 TRACE( "Thread terminating on terminate request\n" );
2308 break;
2309 }
2310
2311 /* Now resend the enum request */
2312 hr = NS_SendSessionRequestBroadcast( &data->requestGuid,
2313 data->dwEnumSessionFlags,
2314 data->lpSpData );
2315
2316 if( FAILED(hr) )
2317 {
2318 ERR( "Enum broadcase request failed: %s\n", DPLAYX_HresultToString(hr) );
2319 /* FIXME: Should we kill this thread? How to inform the main thread? */
2320 }
2321
2322 }
2323
2324 TRACE( "Thread terminating\n" );
2325
2326 /* Clean up the thread data */
2327 CloseHandle( hSuicideRequest );
2328 HeapFree( GetProcessHeap(), 0, lpContext );
2329
2330 /* FIXME: Need to have some notification to main app thread that this is
2331 * dead. It would serve two purposes. 1) allow sync on termination
2332 * so that we don't actually send something to ourselves when we
2333 * become name server (race condition) and 2) so that if we die
2334 * abnormally something else will be able to tell.
2335 */
2336
2337 return 1;
2338 }
2339
2340 static void DP_KillEnumSessionThread( IDirectPlay2Impl* This )
2341 {
2342 /* Does a thread exist? If so we were doing an async enum session */
2343 if( This->dp2->hEnumSessionThread != INVALID_HANDLE_VALUE )
2344 {
2345 TRACE( "Killing EnumSession thread %p\n",
2346 This->dp2->hEnumSessionThread );
2347
2348 /* Request that the thread kill itself nicely */
2349 SetEvent( This->dp2->hKillEnumSessionThreadEvent );
2350 CloseHandle( This->dp2->hKillEnumSessionThreadEvent );
2351
2352 /* We no longer need to know about the thread */
2353 CloseHandle( This->dp2->hEnumSessionThread );
2354
2355 This->dp2->hEnumSessionThread = INVALID_HANDLE_VALUE;
2356 }
2357 }
2358
2359 static HRESULT DP_IF_EnumSessions
2360 ( IDirectPlay2Impl* This, LPDPSESSIONDESC2 lpsd, DWORD dwTimeout,
2361 LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2,
2362 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi )
2363 {
2364 HRESULT hr = DP_OK;
2365
2366 TRACE( "(%p)->(%p,0x%08x,%p,%p,0x%08x,%u)\n",
2367 This, lpsd, dwTimeout, lpEnumSessionsCallback2, lpContext, dwFlags,
2368 bAnsi );
2369 if( This->dp2->connectionInitialized == NO_PROVIDER )
2370 {
2371 return DPERR_UNINITIALIZED;
2372 }
2373
2374 if( (lpsd == NULL) || (lpsd->dwSize != sizeof(DPSESSIONDESC2)) )
2375 {
2376 return DPERR_INVALIDPARAMS;
2377 }
2378
2379 /* Can't enumerate if the session is already open */
2380 if( This->dp2->bConnectionOpen )
2381 {
2382 return DPERR_GENERIC;
2383 }
2384
2385 #if 1
2386 /* The loading of a lobby provider _seems_ to require a backdoor loading
2387 * of the service provider to also associate with this DP object. This is
2388 * because the app doesn't seem to have to call EnumConnections and
2389 * InitializeConnection for the SP before calling this method. As such
2390 * we'll do their dirty work for them with a quick hack so as to always
2391 * load the TCP/IP service provider.
2392 *
2393 * The correct solution would seem to involve creating a dialog box which
2394 * contains the possible SPs. These dialog boxes most likely follow SDK
2395 * examples.
2396 */
2397 if( This->dp2->bDPLSPInitialized && !This->dp2->bSPInitialized )
2398 {
2399 LPVOID lpConnection;
2400 DWORD dwSize;
2401
2402 WARN( "Hack providing TCP/IP SP for lobby provider activated\n" );
2403
2404 if( !DP_BuildCompoundAddr( DPAID_ServiceProvider, (LPGUID)&DPSPGUID_TCPIP,
2405 &lpConnection, &dwSize ) )
2406 {
2407 ERR( "Can't build compound addr\n" );
2408 return DPERR_GENERIC;
2409 }
2410
2411 hr = DP_IF_InitializeConnection( (IDirectPlay3Impl*)This, lpConnection,
2412 0, bAnsi );
2413 if( FAILED(hr) )
2414 {
2415 return hr;
2416 }
2417
2418 /* Free up the address buffer */
2419 HeapFree( GetProcessHeap(), 0, lpConnection );
2420
2421 /* The SP is now initialized */
2422 This->dp2->bSPInitialized = TRUE;
2423 }
2424 #endif
2425
2426
2427 /* Use the service provider default? */
2428 if( dwTimeout == 0 )
2429 {
2430 DPCAPS spCaps;
2431 spCaps.dwSize = sizeof( spCaps );
2432
2433 DP_IF_GetCaps( This, &spCaps, 0 );
2434 dwTimeout = spCaps.dwTimeout;
2435
2436 /* The service provider doesn't provide one either! */
2437 if( dwTimeout == 0 )
2438 {
2439 /* Provide the TCP/IP default */
2440 dwTimeout = DPMSG_WAIT_5_SECS;
2441 }
2442 }
2443
2444 if( dwFlags & DPENUMSESSIONS_STOPASYNC )
2445 {
2446 DP_KillEnumSessionThread( This );
2447 return hr;
2448 }
2449
2450 if( ( dwFlags & DPENUMSESSIONS_ASYNC ) )
2451 {
2452 /* Enumerate everything presently in the local session cache */
2453 DP_InvokeEnumSessionCallbacks( lpEnumSessionsCallback2,
2454 This->dp2->lpNameServerData, dwTimeout,
2455 lpContext );
2456
2457 if( This->dp2->dwEnumSessionLock != 0 )
2458 return DPERR_CONNECTING;
2459
2460 /* See if we've already created a thread to service this interface */
2461 if( This->dp2->hEnumSessionThread == INVALID_HANDLE_VALUE )
2462 {
2463 DWORD dwThreadId;
2464 This->dp2->dwEnumSessionLock++;
2465
2466 /* Send the first enum request inline since the user may cancel a dialog
2467 * if one is presented. Also, may also have a connecting return code.
2468 */
2469 hr = NS_SendSessionRequestBroadcast( &lpsd->guidApplication,
2470 dwFlags, &This->dp2->spData );
2471
2472 if( SUCCEEDED(hr) )
2473 {
2474 EnumSessionAsyncCallbackData* lpData
2475 = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpData ) );
2476 /* FIXME: need to kill the thread on object deletion */
2477 lpData->lpSpData = &This->dp2->spData;
2478
2479 lpData->requestGuid = lpsd->guidApplication;
2480 lpData->dwEnumSessionFlags = dwFlags;
2481 lpData->dwTimeout = dwTimeout;
2482
2483 This->dp2->hKillEnumSessionThreadEvent =
2484 CreateEventW( NULL, TRUE, FALSE, NULL );
2485
2486 if( !DuplicateHandle( GetCurrentProcess(),
2487 This->dp2->hKillEnumSessionThreadEvent,
2488 GetCurrentProcess(),
2489 &lpData->hSuicideRequest,
2490 0, FALSE, DUPLICATE_SAME_ACCESS )
2491 )
2492 {
2493 ERR( "Can't duplicate thread killing handle\n" );
2494 }
2495
2496 TRACE( ": creating EnumSessionsRequest thread\n" );
2497
2498 This->dp2->hEnumSessionThread = CreateThread( NULL,
2499 0,
2500 DP_EnumSessionsSendAsyncRequestThread,
2501 lpData,
2502 0,
2503 &dwThreadId );
2504 }
2505 This->dp2->dwEnumSessionLock--;
2506 }
2507 }
2508 else
2509 {
2510 /* Invalidate the session cache for the interface */
2511 NS_InvalidateSessionCache( This->dp2->lpNameServerData );
2512
2513 /* Send the broadcast for session enumeration */
2514 hr = NS_SendSessionRequestBroadcast( &lpsd->guidApplication,
2515 dwFlags,
2516 &This->dp2->spData );
2517
2518
2519 SleepEx( dwTimeout, FALSE );
2520
2521 DP_InvokeEnumSessionCallbacks( lpEnumSessionsCallback2,
2522 This->dp2->lpNameServerData, dwTimeout,
2523 lpContext );
2524 }
2525
2526 return hr;
2527 }
2528
2529 static HRESULT WINAPI DirectPlay2AImpl_EnumSessions
2530 ( LPDIRECTPLAY2A iface, LPDPSESSIONDESC2 lpsd, DWORD dwTimeout,
2531 LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2,
2532 LPVOID lpContext, DWORD dwFlags )
2533 {
2534 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2535 return DP_IF_EnumSessions( This, lpsd, dwTimeout, lpEnumSessionsCallback2,
2536 lpContext, dwFlags, TRUE );
2537 }
2538
2539 static HRESULT WINAPI DirectPlay2WImpl_EnumSessions
2540 ( LPDIRECTPLAY2 iface, LPDPSESSIONDESC2 lpsd, DWORD dwTimeout,
2541 LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2,
2542 LPVOID lpContext, DWORD dwFlags )
2543 {
2544 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2545 return DP_IF_EnumSessions( This, lpsd, dwTimeout, lpEnumSessionsCallback2,
2546 lpContext, dwFlags, FALSE );
2547 }
2548
2549 static HRESULT DP_IF_GetPlayerCaps
2550 ( IDirectPlay2Impl* This, DPID idPlayer, LPDPCAPS lpDPCaps,
2551 DWORD dwFlags )
2552 {
2553 DPSP_GETCAPSDATA data;
2554
2555 TRACE("(%p)->(0x%08x,%p,0x%08x)\n", This, idPlayer, lpDPCaps, dwFlags);
2556
2557 if ( This->dp2->connectionInitialized == NO_PROVIDER )
2558 {
2559 return DPERR_UNINITIALIZED;
2560 }
2561
2562 if ( lpDPCaps->dwSize != sizeof(DPCAPS) )
2563 {
2564 return DPERR_INVALIDPARAMS;
2565 }
2566
2567 /* Query the service provider */
2568 data.idPlayer = idPlayer;
2569 data.dwFlags = dwFlags;
2570 data.lpCaps = lpDPCaps;
2571 data.lpISP = This->dp2->spData.lpISP;
2572
2573 return (*This->dp2->spData.lpCB->GetCaps)( &data );
2574 }
2575
2576 static HRESULT DP_IF_GetCaps
2577 ( IDirectPlay2Impl* This, LPDPCAPS lpDPCaps, DWORD dwFlags )
2578 {
2579 return DP_IF_GetPlayerCaps( This, DPID_ALLPLAYERS, lpDPCaps, dwFlags );
2580 }
2581
2582 static HRESULT WINAPI DirectPlay2AImpl_GetCaps
2583 ( LPDIRECTPLAY2A iface, LPDPCAPS lpDPCaps, DWORD dwFlags )
2584 {
2585 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2586 return DP_IF_GetCaps( This, lpDPCaps, dwFlags );
2587 }
2588
2589 static HRESULT WINAPI DirectPlay2WImpl_GetCaps
2590 ( LPDIRECTPLAY2 iface, LPDPCAPS lpDPCaps, DWORD dwFlags )
2591 {
2592 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2593 return DP_IF_GetCaps( This, lpDPCaps, dwFlags );
2594 }
2595
2596 static HRESULT DP_IF_GetGroupData
2597 ( IDirectPlay2Impl* This, DPID idGroup, LPVOID lpData,
2598 LPDWORD lpdwDataSize, DWORD dwFlags, BOOL bAnsi )
2599 {
2600 lpGroupData lpGData;
2601 DWORD dwRequiredBufferSize;
2602 LPVOID lpCopyDataFrom;
2603
2604 TRACE( "(%p)->(0x%08x,%p,%p,0x%08x,%u)\n",
2605 This, idGroup, lpData, lpdwDataSize, dwFlags, bAnsi );
2606
2607 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
2608 {
2609 return DPERR_INVALIDGROUP;
2610 }
2611
2612 /* How much buffer is required? */
2613 if( dwFlags & DPSET_LOCAL )
2614 {
2615 dwRequiredBufferSize = lpGData->dwLocalDataSize;
2616 lpCopyDataFrom = lpGData->lpLocalData;
2617 }
2618 else
2619 {
2620 dwRequiredBufferSize = lpGData->dwRemoteDataSize;
2621 lpCopyDataFrom = lpGData->lpRemoteData;
2622 }
2623
2624 /* Is the user requesting to know how big a buffer is required? */
2625 if( ( lpData == NULL ) ||
2626 ( *lpdwDataSize < dwRequiredBufferSize )
2627 )
2628 {
2629 *lpdwDataSize = dwRequiredBufferSize;
2630 return DPERR_BUFFERTOOSMALL;
2631 }
2632
2633 CopyMemory( lpData, lpCopyDataFrom, dwRequiredBufferSize );
2634
2635 return DP_OK;
2636 }
2637
2638 static HRESULT WINAPI DirectPlay2AImpl_GetGroupData
2639 ( LPDIRECTPLAY2A iface, DPID idGroup, LPVOID lpData,
2640 LPDWORD lpdwDataSize, DWORD dwFlags )
2641 {
2642 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2643 return DP_IF_GetGroupData( This, idGroup, lpData, lpdwDataSize,
2644 dwFlags, TRUE );
2645 }
2646
2647 static HRESULT WINAPI DirectPlay2WImpl_GetGroupData
2648 ( LPDIRECTPLAY2 iface, DPID idGroup, LPVOID lpData,
2649 LPDWORD lpdwDataSize, DWORD dwFlags )
2650 {
2651 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2652 return DP_IF_GetGroupData( This, idGroup, lpData, lpdwDataSize,
2653 dwFlags, FALSE );
2654 }
2655
2656 static HRESULT DP_IF_GetGroupName
2657 ( IDirectPlay2Impl* This, DPID idGroup, LPVOID lpData,
2658 LPDWORD lpdwDataSize, BOOL bAnsi )
2659 {
2660 lpGroupData lpGData;
2661 LPDPNAME lpName = lpData;
2662 DWORD dwRequiredDataSize;
2663
2664 FIXME("(%p)->(0x%08x,%p,%p,%u) ANSI ignored\n",
2665 This, idGroup, lpData, lpdwDataSize, bAnsi );
2666
2667 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
2668 {
2669 return DPERR_INVALIDGROUP;
2670 }
2671
2672 dwRequiredDataSize = lpGData->name.dwSize;
2673
2674 if( lpGData->name.u1.lpszShortNameA )
2675 {
2676 dwRequiredDataSize += strlen( lpGData->name.u1.lpszShortNameA ) + 1;
2677 }
2678
2679 if( lpGData->name.u2.lpszLongNameA )
2680 {
2681 dwRequiredDataSize += strlen( lpGData->name.u2.lpszLongNameA ) + 1;
2682 }
2683
2684 if( ( lpData == NULL ) ||
2685 ( *lpdwDataSize < dwRequiredDataSize )
2686 )
2687 {
2688 *lpdwDataSize = dwRequiredDataSize;
2689 return DPERR_BUFFERTOOSMALL;
2690 }
2691
2692 /* Copy the structure */
2693 CopyMemory( lpName, &lpGData->name, lpGData->name.dwSize );
2694
2695 if( lpGData->name.u1.lpszShortNameA )
2696 {
2697 strcpy( ((char*)lpName)+lpGData->name.dwSize,
2698 lpGData->name.u1.lpszShortNameA );
2699 }
2700 else
2701 {
2702 lpName->u1.lpszShortNameA = NULL;
2703 }
2704
2705 if( lpGData->name.u1.lpszShortNameA )
2706 {
2707 strcpy( ((char*)lpName)+lpGData->name.dwSize,
2708 lpGData->name.u2.lpszLongNameA );
2709 }
2710 else
2711 {
2712 lpName->u2.lpszLongNameA = NULL;
2713 }
2714
2715 return DP_OK;
2716 }
2717
2718 static HRESULT WINAPI DirectPlay2AImpl_GetGroupName
2719 ( LPDIRECTPLAY2A iface, DPID idGroup, LPVOID lpData,
2720 LPDWORD lpdwDataSize )
2721 {
2722 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2723 return DP_IF_GetGroupName( This, idGroup, lpData, lpdwDataSize, TRUE );
2724 }
2725
2726 static HRESULT WINAPI DirectPlay2WImpl_GetGroupName
2727 ( LPDIRECTPLAY2 iface, DPID idGroup, LPVOID lpData,
2728 LPDWORD lpdwDataSize )
2729 {
2730 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2731 return DP_IF_GetGroupName( This, idGroup, lpData, lpdwDataSize, FALSE );
2732 }
2733
2734 static HRESULT DP_IF_GetMessageCount
2735 ( IDirectPlay2Impl* This, DPID idPlayer,
2736 LPDWORD lpdwCount, BOOL bAnsi )
2737 {
2738 FIXME("(%p)->(0x%08x,%p,%u): stub\n", This, idPlayer, lpdwCount, bAnsi );
2739 return DP_IF_GetMessageQueue( (IDirectPlay4Impl*)This, 0, idPlayer,
2740 DPMESSAGEQUEUE_RECEIVE, lpdwCount, NULL,
2741 bAnsi );
2742 }
2743
2744 static HRESULT WINAPI DirectPlay2AImpl_GetMessageCount
2745 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPDWORD lpdwCount )
2746 {
2747 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2748 return DP_IF_GetMessageCount( This, idPlayer, lpdwCount, TRUE );
2749 }
2750
2751 static HRESULT WINAPI DirectPlay2WImpl_GetMessageCount
2752 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPDWORD lpdwCount )
2753 {
2754 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2755 return DP_IF_GetMessageCount( This, idPlayer, lpdwCount, FALSE );
2756 }
2757
2758 static HRESULT WINAPI DirectPlay2AImpl_GetPlayerAddress
2759 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPVOID lpData, LPDWORD lpdwDataSize )
2760 {
2761 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2762 FIXME("(%p)->(0x%08x,%p,%p): stub\n", This, idPlayer, lpData, lpdwDataSize );
2763 return DP_OK;
2764 }
2765
2766 static HRESULT WINAPI DirectPlay2WImpl_GetPlayerAddress
2767 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPVOID lpData, LPDWORD lpdwDataSize )
2768 {
2769 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2770 FIXME("(%p)->(0x%08x,%p,%p): stub\n", This, idPlayer, lpData, lpdwDataSize );
2771 return DP_OK;
2772 }
2773
2774 static HRESULT WINAPI DirectPlay2AImpl_GetPlayerCaps
2775 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPDPCAPS lpPlayerCaps,
2776 DWORD dwFlags )
2777 {
2778 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2779 return DP_IF_GetPlayerCaps( This, idPlayer, lpPlayerCaps, dwFlags );
2780 }
2781
2782 static HRESULT WINAPI DirectPlay2WImpl_GetPlayerCaps
2783 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPDPCAPS lpPlayerCaps,
2784 DWORD dwFlags )
2785 {
2786 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2787 return DP_IF_GetPlayerCaps( This, idPlayer, lpPlayerCaps, dwFlags );
2788 }
2789
2790 static HRESULT DP_IF_GetPlayerData
2791 ( IDirectPlay2Impl* This, DPID idPlayer, LPVOID lpData,
2792 LPDWORD lpdwDataSize, DWORD dwFlags, BOOL bAnsi )
2793 {
2794 lpPlayerList lpPList;
2795 DWORD dwRequiredBufferSize;
2796 LPVOID lpCopyDataFrom;
2797
2798 TRACE( "(%p)->(0x%08x,%p,%p,0x%08x,%u)\n",
2799 This, idPlayer, lpData, lpdwDataSize, dwFlags, bAnsi );
2800
2801 if( This->dp2->connectionInitialized == NO_PROVIDER )
2802 {
2803 return DPERR_UNINITIALIZED;
2804 }
2805
2806 if( ( lpPList = DP_FindPlayer( This, idPlayer ) ) == NULL )
2807 {
2808 return DPERR_INVALIDPLAYER;
2809 }
2810
2811 if( lpdwDataSize == NULL )
2812 {
2813 return DPERR_INVALIDPARAMS;
2814 }
2815
2816 /* How much buffer is required? */
2817 if( dwFlags & DPSET_LOCAL )
2818 {
2819 dwRequiredBufferSize = lpPList->lpPData->dwLocalDataSize;
2820 lpCopyDataFrom = lpPList->lpPData->lpLocalData;
2821 }
2822 else
2823 {
2824 dwRequiredBufferSize = lpPList->lpPData->dwRemoteDataSize;
2825 lpCopyDataFrom = lpPList->lpPData->lpRemoteData;
2826 }
2827
2828 /* Is the user requesting to know how big a buffer is required? */
2829 if( ( lpData == NULL ) ||
2830 ( *lpdwDataSize < dwRequiredBufferSize )
2831 )
2832 {
2833 *lpdwDataSize = dwRequiredBufferSize;
2834 return DPERR_BUFFERTOOSMALL;
2835 }
2836
2837 CopyMemory( lpData, lpCopyDataFrom, dwRequiredBufferSize );
2838
2839 return DP_OK;
2840 }
2841
2842 static HRESULT WINAPI DirectPlay2AImpl_GetPlayerData
2843 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPVOID lpData,
2844 LPDWORD lpdwDataSize, DWORD dwFlags )
2845 {
2846 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2847 return DP_IF_GetPlayerData( This, idPlayer, lpData, lpdwDataSize,
2848 dwFlags, TRUE );
2849 }
2850
2851 static HRESULT WINAPI DirectPlay2WImpl_GetPlayerData
2852 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPVOID lpData,
2853 LPDWORD lpdwDataSize, DWORD dwFlags )
2854 {
2855 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2856 return DP_IF_GetPlayerData( This, idPlayer, lpData, lpdwDataSize,
2857 dwFlags, FALSE );
2858 }
2859
2860 static HRESULT DP_IF_GetPlayerName
2861 ( IDirectPlay2Impl* This, DPID idPlayer, LPVOID lpData,
2862 LPDWORD lpdwDataSize, BOOL bAnsi )
2863 {
2864 lpPlayerList lpPList;
2865 LPDPNAME lpName = lpData;
2866 DWORD dwRequiredDataSize;
2867
2868 FIXME( "(%p)->(0x%08x,%p,%p,%u): ANSI\n",
2869 This, idPlayer, lpData, lpdwDataSize, bAnsi );
2870
2871 if( This->dp2->connectionInitialized == NO_PROVIDER )
2872 {
2873 return DPERR_UNINITIALIZED;
2874 }
2875
2876 if( ( lpPList = DP_FindPlayer( This, idPlayer ) ) == NULL )
2877 {
2878 return DPERR_INVALIDPLAYER;
2879 }
2880
2881 dwRequiredDataSize = lpPList->lpPData->name.dwSize;
2882
2883 if( lpPList->lpPData->name.u1.lpszShortNameA )
2884 {
2885 dwRequiredDataSize += strlen( lpPList->lpPData->name.u1.lpszShortNameA ) + 1;
2886 }
2887
2888 if( lpPList->lpPData->name.u2.lpszLongNameA )
2889 {
2890 dwRequiredDataSize += strlen( lpPList->lpPData->name.u2.lpszLongNameA ) + 1;
2891 }
2892
2893 if( ( lpData == NULL ) ||
2894 ( *lpdwDataSize < dwRequiredDataSize )
2895 )
2896 {
2897 *lpdwDataSize = dwRequiredDataSize;
2898 return DPERR_BUFFERTOOSMALL;
2899 }
2900
2901 /* Copy the structure */
2902 CopyMemory( lpName, &lpPList->lpPData->name, lpPList->lpPData->name.dwSize );
2903
2904 if( lpPList->lpPData->name.u1.lpszShortNameA )
2905 {
2906 strcpy( ((char*)lpName)+lpPList->lpPData->name.dwSize,
2907 lpPList->lpPData->name.u1.lpszShortNameA );
2908 }
2909 else
2910 {
2911 lpName->u1.lpszShortNameA = NULL;
2912 }
2913
2914 if( lpPList->lpPData->name.u2.lpszLongNameA )
2915 {
2916 strcpy( ((char*)lpName)+lpPList->lpPData->name.dwSize,
2917 lpPList->lpPData->name.u2.lpszLongNameA );
2918 }
2919 else
2920 {
2921 lpName->u2.lpszLongNameA = NULL;
2922 }
2923
2924 return DP_OK;
2925 }
2926
2927 static HRESULT WINAPI DirectPlay2AImpl_GetPlayerName
2928 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPVOID lpData,
2929 LPDWORD lpdwDataSize )
2930 {
2931 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2932 return DP_IF_GetPlayerName( This, idPlayer, lpData, lpdwDataSize, TRUE );
2933 }
2934
2935 static HRESULT WINAPI DirectPlay2WImpl_GetPlayerName
2936 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPVOID lpData,
2937 LPDWORD lpdwDataSize )
2938 {
2939 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2940 return DP_IF_GetPlayerName( This, idPlayer, lpData, lpdwDataSize, FALSE );
2941 }
2942
2943 static HRESULT DP_GetSessionDesc
2944 ( IDirectPlay2Impl* This, LPVOID lpData, LPDWORD lpdwDataSize,
2945 BOOL bAnsi )
2946 {
2947 DWORD dwRequiredSize;
2948
2949 TRACE( "(%p)->(%p,%p,%u)\n", This, lpData, lpdwDataSize, bAnsi );
2950
2951 if( This->dp2->connectionInitialized == NO_PROVIDER )
2952 {
2953 return DPERR_UNINITIALIZED;
2954 }
2955
2956 if( !This->dp2->bConnectionOpen )
2957 {
2958 return DPERR_NOSESSIONS;
2959 }
2960
2961 if( ( lpdwDataSize == NULL ) || ( *lpdwDataSize >= MAXDWORD ) )
2962 {
2963 return DPERR_INVALIDPARAMS;
2964 }
2965
2966 /* FIXME: Get from This->dp2->lpSessionDesc */
2967 dwRequiredSize = DP_CalcSessionDescSize( This->dp2->lpSessionDesc, bAnsi );
2968
2969 if ( ( lpData == NULL ) ||
2970 ( *lpdwDataSize < dwRequiredSize )
2971 )
2972 {
2973 *lpdwDataSize = dwRequiredSize;
2974 return DPERR_BUFFERTOOSMALL;
2975 }
2976
2977 DP_CopySessionDesc( lpData, This->dp2->lpSessionDesc, bAnsi );
2978
2979 return DP_OK;
2980 }
2981
2982 static HRESULT WINAPI DirectPlay2AImpl_GetSessionDesc
2983 ( LPDIRECTPLAY2A iface, LPVOID lpData, LPDWORD lpdwDataSize )
2984 {
2985 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2986 return DP_GetSessionDesc( This, lpData, lpdwDataSize, TRUE );
2987 }
2988
2989 static HRESULT WINAPI DirectPlay2WImpl_GetSessionDesc
2990 ( LPDIRECTPLAY2 iface, LPVOID lpData, LPDWORD lpdwDataSize )
2991 {
2992 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
2993 return DP_GetSessionDesc( This, lpData, lpdwDataSize, TRUE );
2994 }
2995
2996 /* Intended only for COM compatibility. Always returns an error. */
2997 static HRESULT WINAPI DirectPlay2AImpl_Initialize
2998 ( LPDIRECTPLAY2A iface, LPGUID lpGUID )
2999 {
3000 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3001 TRACE("(%p)->(%p): stub\n", This, lpGUID );
3002 return DPERR_ALREADYINITIALIZED;
3003 }
3004
3005 /* Intended only for COM compatibility. Always returns an error. */
3006 static HRESULT WINAPI DirectPlay2WImpl_Initialize
3007 ( LPDIRECTPLAY2 iface, LPGUID lpGUID )
3008 {
3009 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3010 TRACE("(%p)->(%p): stub\n", This, lpGUID );
3011 return DPERR_ALREADYINITIALIZED;
3012 }
3013
3014
3015 static HRESULT DP_SecureOpen
3016 ( IDirectPlay2Impl* This, LPCDPSESSIONDESC2 lpsd, DWORD dwFlags,
3017 LPCDPSECURITYDESC lpSecurity, LPCDPCREDENTIALS lpCredentials,
3018 BOOL bAnsi )
3019 {
3020 HRESULT hr = DP_OK;
3021
3022 FIXME( "(%p)->(%p,0x%08x,%p,%p): partial stub\n",
3023 This, lpsd, dwFlags, lpSecurity, lpCredentials );
3024
3025 if( ( lpsd == NULL ) ||
3026 ( lpsd->dwSize != sizeof(DPSESSIONDESC2) ) )
3027 {
3028 return DPERR_INVALIDPARAMS;
3029 }
3030
3031 if( This->dp2->bConnectionOpen )
3032 {
3033 TRACE( ": rejecting already open connection.\n" );
3034 return DPERR_ALREADYINITIALIZED;
3035 }
3036
3037 /* If we're enumerating, kill the thread */
3038 DP_KillEnumSessionThread( This );
3039
3040 if( dwFlags & DPOPEN_JOIN )
3041 {
3042 LPDPSESSIONDESC2 current = NULL;
3043 NS_ResetSessionEnumeration( This->dp2->lpNameServerData );
3044 while( ( current = NS_WalkSessions( This->dp2->lpNameServerData ) ) )
3045 {
3046 if ( IsEqualGUID( &lpsd->guidInstance, &current->guidInstance ) )
3047 break;
3048 }
3049 if ( current == NULL )
3050 return DPERR_NOSESSIONS;
3051 }
3052 else if( dwFlags & DPOPEN_CREATE )
3053 {
3054 /* Rightoo - this computer is the host and the local computer needs to be
3055 the name server so that others can join this session */
3056 NS_SetLocalComputerAsNameServer( lpsd, This->dp2->lpNameServerData );
3057
3058 This->dp2->bHostInterface = TRUE;
3059
3060 hr = DP_SetSessionDesc( This, lpsd, 0, TRUE, bAnsi );
3061 if( FAILED( hr ) )
3062 {
3063 ERR( "Unable to set session desc: %s\n", DPLAYX_HresultToString( hr ) );
3064 return hr;
3065 }
3066 }
3067
3068 /* Invoke the conditional callback for the service provider */
3069 if( This->dp2->spData.lpCB->Open )
3070 {
3071 DPSP_OPENDATA data;
3072
3073 FIXME( "Not all data fields are correct. Need new parameter\n" );
3074
3075 data.bCreate = (dwFlags & DPOPEN_CREATE ) ? TRUE : FALSE;
3076 data.lpSPMessageHeader = (dwFlags & DPOPEN_CREATE ) ? NULL
3077 : NS_GetNSAddr( This->dp2->lpNameServerData );
3078 data.lpISP = This->dp2->spData.lpISP;
3079 data.bReturnStatus = (dwFlags & DPOPEN_RETURNSTATUS) ? TRUE : FALSE;
3080 data.dwOpenFlags = dwFlags;
3081 data.dwSessionFlags = This->dp2->lpSessionDesc->dwFlags;
3082
3083 hr = (*This->dp2->spData.lpCB->Open)(&data);
3084 if( FAILED( hr ) )
3085 {
3086 ERR( "Unable to open session: %s\n", DPLAYX_HresultToString( hr ) );
3087 return hr;
3088 }
3089 }
3090
3091 {
3092 /* Create the system group of which everything is a part of */
3093 DPID systemGroup = DPID_SYSTEM_GROUP;
3094
3095 hr = DP_IF_CreateGroup( This, NULL, &systemGroup, NULL,
3096 NULL, 0, 0, TRUE );
3097
3098 }
3099
3100 if( dwFlags & DPOPEN_JOIN )
3101 {
3102 DPID dpidServerId = DPID_UNKNOWN;
3103
3104 /* Create the server player for this interface. This way we can receive
3105 * messages for this session.
3106 */
3107 /* FIXME: I suppose that we should be setting an event for a receive
3108 * type of thing. That way the messaging thread could know to wake
3109 * up. DPlay would then trigger the hEvent for the player the
3110 * message is directed to.
3111 */
3112 hr = DP_IF_CreatePlayer( This, NULL, &dpidServerId, NULL, 0, NULL,
3113 0,
3114 DPPLAYER_SERVERPLAYER | DPPLAYER_LOCAL , bAnsi );
3115
3116 }
3117 else if( dwFlags & DPOPEN_CREATE )
3118 {
3119 DPID dpidNameServerId = DPID_NAME_SERVER;
3120
3121 hr = DP_IF_CreatePlayer( This, NULL, &dpidNameServerId, NULL, 0, NULL,
3122 0, DPPLAYER_SERVERPLAYER, bAnsi );
3123 }
3124
3125 if( FAILED(hr) )
3126 {
3127 ERR( "Couldn't create name server/system player: %s\n",
3128 DPLAYX_HresultToString(hr) );
3129 }
3130 else
3131 {
3132 This->dp2->bConnectionOpen = TRUE;
3133 }
3134
3135 return hr;
3136 }
3137
3138 static HRESULT WINAPI DirectPlay2AImpl_Open
3139 ( LPDIRECTPLAY2A iface, LPDPSESSIONDESC2 lpsd, DWORD dwFlags )
3140 {
3141 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3142 TRACE("(%p)->(%p,0x%08x)\n", This, lpsd, dwFlags );
3143 return DP_SecureOpen( This, lpsd, dwFlags, NULL, NULL, TRUE );
3144 }
3145
3146 static HRESULT WINAPI DirectPlay2WImpl_Open
3147 ( LPDIRECTPLAY2 iface, LPDPSESSIONDESC2 lpsd, DWORD dwFlags )
3148 {
3149 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3150 TRACE("(%p)->(%p,0x%08x)\n", This, lpsd, dwFlags );
3151 return DP_SecureOpen( This, lpsd, dwFlags, NULL, NULL, FALSE );
3152 }
3153
3154 static HRESULT DP_IF_Receive
3155 ( IDirectPlay2Impl* This, LPDPID lpidFrom, LPDPID lpidTo,
3156 DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize, BOOL bAnsi )
3157 {
3158 LPDPMSG lpMsg = NULL;
3159
3160 FIXME( "(%p)->(%p,%p,0x%08x,%p,%p,%u): stub\n",
3161 This, lpidFrom, lpidTo, dwFlags, lpData, lpdwDataSize, bAnsi );
3162
3163 if( This->dp2->connectionInitialized == NO_PROVIDER )
3164 {
3165 return DPERR_UNINITIALIZED;
3166 }
3167
3168 if ( ( lpdwDataSize == NULL ) ||
3169 ( ( dwFlags & DPRECEIVE_FROMPLAYER ) && ( lpidFrom == NULL ) ) ||
3170 ( ( dwFlags & DPRECEIVE_TOPLAYER ) && ( lpidTo == NULL ) ) )
3171 {
3172 return DPERR_INVALIDPARAMS;
3173 }
3174
3175 if( dwFlags == 0 )
3176 {
3177 dwFlags = DPRECEIVE_ALL;
3178 }
3179
3180 if( dwFlags & DPRECEIVE_ALL )
3181 {
3182 lpMsg = DPQ_FIRST( This->dp2->receiveMsgs );
3183 }
3184 else
3185 {
3186 if ( (lpMsg = DPQ_FIRST( This->dp2->receiveMsgs )) )
3187 {
3188 do
3189 {
3190 if ( ( ( dwFlags & DPRECEIVE_FROMPLAYER ) &&
3191 ( dwFlags & DPRECEIVE_TOPLAYER ) &&
3192 ( lpMsg->idFrom == *lpidFrom ) &&
3193 ( lpMsg->idTo == *lpidTo ) ) || /* From & To */
3194 ( ( dwFlags & DPRECEIVE_FROMPLAYER ) &&
3195 ( lpMsg->idFrom == *lpidFrom ) ) || /* From */
3196 ( ( dwFlags & DPRECEIVE_TOPLAYER ) &&
3197 ( lpMsg->idTo == *lpidTo ) ) ) /* To */
3198 {
3199 break;
3200 }
3201 }
3202 while( (lpMsg = DPQ_NEXT( lpMsg->msgs )) );
3203 }
3204 }
3205
3206 if( lpMsg == NULL )
3207 {
3208 return DPERR_NOMESSAGES;
3209 }
3210
3211 /* Buffer size check */
3212 if ( ( lpData == NULL ) ||
3213 ( *lpdwDataSize < lpMsg->dwMsgSize ) )
3214 {
3215 *lpdwDataSize = lpMsg->dwMsgSize;
3216 return DPERR_BUFFERTOOSMALL;
3217 }
3218
3219 /* Copy into the provided buffer */
3220 if (lpData) CopyMemory( lpData, lpMsg->msg, *lpdwDataSize );
3221
3222 /* Set players */
3223 if ( lpidFrom )
3224 {
3225 *lpidFrom = lpMsg->idFrom;
3226 }
3227 if ( lpidTo )
3228 {
3229 *lpidTo = lpMsg->idTo;
3230 }
3231
3232 /* Remove message from queue */
3233 if( !( dwFlags & DPRECEIVE_PEEK ) )
3234 {
3235 HeapFree( GetProcessHeap(), 0, lpMsg->msg );
3236 DPQ_REMOVE( This->dp2->receiveMsgs, lpMsg, msgs );
3237 HeapFree( GetProcessHeap(), 0, lpMsg );
3238 }
3239
3240 return DP_OK;
3241 }
3242
3243 static HRESULT WINAPI DirectPlay2AImpl_Receive
3244 ( LPDIRECTPLAY2A iface, LPDPID lpidFrom, LPDPID lpidTo,
3245 DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize )
3246 {
3247 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3248 return DP_IF_Receive( This, lpidFrom, lpidTo, dwFlags,
3249 lpData, lpdwDataSize, TRUE );
3250 }
3251
3252 static HRESULT WINAPI DirectPlay2WImpl_Receive
3253 ( LPDIRECTPLAY2 iface, LPDPID lpidFrom, LPDPID lpidTo,
3254 DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize )
3255 {
3256 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3257 return DP_IF_Receive( This, lpidFrom, lpidTo, dwFlags,
3258 lpData, lpdwDataSize, FALSE );
3259 }
3260
3261 static HRESULT WINAPI DirectPlay2AImpl_Send
3262 ( LPDIRECTPLAY2A iface, DPID idFrom, DPID idTo, DWORD dwFlags, LPVOID lpData, DWORD dwDataSize )
3263 {
3264 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3265 return DP_SendEx( This, idFrom, idTo, dwFlags, lpData, dwDataSize,
3266 0, 0, NULL, NULL, TRUE );
3267 }
3268
3269 static HRESULT WINAPI DirectPlay2WImpl_Send
3270 ( LPDIRECTPLAY2 iface, DPID idFrom, DPID idTo, DWORD dwFlags, LPVOID lpData, DWORD dwDataSize )
3271 {
3272 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3273 return DP_SendEx( This, idFrom, idTo, dwFlags, lpData, dwDataSize,
3274 0, 0, NULL, NULL, FALSE );
3275 }
3276
3277 static HRESULT DP_IF_SetGroupData
3278 ( IDirectPlay2Impl* This, DPID idGroup, LPVOID lpData,
3279 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi )
3280 {
3281 lpGroupData lpGData;
3282
3283 TRACE( "(%p)->(0x%08x,%p,0x%08x,0x%08x,%u)\n",
3284 This, idGroup, lpData, dwDataSize, dwFlags, bAnsi );
3285
3286 /* Parameter check */
3287 if( ( lpData == NULL ) &&
3288 ( dwDataSize != 0 )
3289 )
3290 {
3291 return DPERR_INVALIDPARAMS;
3292 }
3293
3294 /* Find the pointer to the data for this player */
3295 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
3296 {
3297 return DPERR_INVALIDOBJECT;
3298 }
3299
3300 if( !(dwFlags & DPSET_LOCAL) )
3301 {
3302 FIXME( "Was this group created by this interface?\n" );
3303 /* FIXME: If this is a remote update need to allow it but not
3304 * send a message.
3305 */
3306 }
3307
3308 DP_SetGroupData( lpGData, dwFlags, lpData, dwDataSize );
3309
3310 /* FIXME: Only send a message if this group is local to the session otherwise
3311 * it will have been rejected above
3312 */
3313 if( !(dwFlags & DPSET_LOCAL) )
3314 {
3315 FIXME( "Send msg?\n" );
3316 }
3317
3318 return DP_OK;
3319 }
3320
3321 static HRESULT WINAPI DirectPlay2AImpl_SetGroupData
3322 ( LPDIRECTPLAY2A iface, DPID idGroup, LPVOID lpData,
3323 DWORD dwDataSize, DWORD dwFlags )
3324 {
3325 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3326 return DP_IF_SetGroupData( This, idGroup, lpData, dwDataSize, dwFlags, TRUE );
3327 }
3328
3329 static HRESULT WINAPI DirectPlay2WImpl_SetGroupData
3330 ( LPDIRECTPLAY2 iface, DPID idGroup, LPVOID lpData,
3331 DWORD dwDataSize, DWORD dwFlags )
3332 {
3333 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3334 return DP_IF_SetGroupData( This, idGroup, lpData, dwDataSize, dwFlags, FALSE );
3335 }
3336
3337 static HRESULT DP_IF_SetGroupName
3338 ( IDirectPlay2Impl* This, DPID idGroup, LPDPNAME lpGroupName,
3339 DWORD dwFlags, BOOL bAnsi )
3340 {
3341 lpGroupData lpGData;
3342
3343 TRACE( "(%p)->(0x%08x,%p,0x%08x,%u)\n", This, idGroup,
3344 lpGroupName, dwFlags, bAnsi );
3345
3346 if( ( lpGData = DP_FindAnyGroup( This, idGroup ) ) == NULL )
3347 {
3348 return DPERR_INVALIDGROUP;
3349 }
3350
3351 DP_CopyDPNAMEStruct( &lpGData->name, lpGroupName, bAnsi );
3352
3353 /* Should send a DPMSG_SETPLAYERORGROUPNAME message */
3354 FIXME( "Message not sent and dwFlags ignored\n" );
3355
3356 return DP_OK;
3357 }
3358
3359 static HRESULT WINAPI DirectPlay2AImpl_SetGroupName
3360 ( LPDIRECTPLAY2A iface, DPID idGroup, LPDPNAME lpGroupName,
3361 DWORD dwFlags )
3362 {
3363 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3364 return DP_IF_SetGroupName( This, idGroup, lpGroupName, dwFlags, TRUE );
3365 }
3366
3367 static HRESULT WINAPI DirectPlay2WImpl_SetGroupName
3368 ( LPDIRECTPLAY2 iface, DPID idGroup, LPDPNAME lpGroupName,
3369 DWORD dwFlags )
3370 {
3371 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3372 return DP_IF_SetGroupName( This, idGroup, lpGroupName, dwFlags, FALSE );
3373 }
3374
3375 static HRESULT DP_IF_SetPlayerData
3376 ( IDirectPlay2Impl* This, DPID idPlayer, LPVOID lpData,
3377 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi )
3378 {
3379 lpPlayerList lpPList;
3380
3381 TRACE( "(%p)->(0x%08x,%p,0x%08x,0x%08x,%u)\n",
3382 This, idPlayer, lpData, dwDataSize, dwFlags, bAnsi );
3383
3384 if( This->dp2->connectionInitialized == NO_PROVIDER )
3385 {
3386 return DPERR_UNINITIALIZED;
3387 }
3388
3389 /* Parameter check */
3390 if( ( ( lpData == NULL ) && ( dwDataSize != 0 ) ) ||
3391 ( dwDataSize >= MAXDWORD ) )
3392 {
3393 return DPERR_INVALIDPARAMS;
3394 }
3395
3396 /* Find the pointer to the data for this player */
3397 if( ( lpPList = DP_FindPlayer( This, idPlayer ) ) == NULL )
3398 {
3399 return DPERR_INVALIDPLAYER;
3400 }
3401
3402 if( !(dwFlags & DPSET_LOCAL) )
3403 {
3404 FIXME( "Was this group created by this interface?\n" );
3405 /* FIXME: If this is a remote update need to allow it but not
3406 * send a message.
3407 */
3408 }
3409
3410 DP_SetPlayerData( lpPList->lpPData, dwFlags, lpData, dwDataSize );
3411
3412 if( !(dwFlags & DPSET_LOCAL) )
3413 {
3414 FIXME( "Send msg?\n" );
3415 }
3416
3417 return DP_OK;
3418 }
3419
3420 static HRESULT WINAPI DirectPlay2AImpl_SetPlayerData
3421 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPVOID lpData,
3422 DWORD dwDataSize, DWORD dwFlags )
3423 {
3424 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3425 return DP_IF_SetPlayerData( This, idPlayer, lpData, dwDataSize,
3426 dwFlags, TRUE );
3427 }
3428
3429 static HRESULT WINAPI DirectPlay2WImpl_SetPlayerData
3430 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPVOID lpData,
3431 DWORD dwDataSize, DWORD dwFlags )
3432 {
3433 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3434 return DP_IF_SetPlayerData( This, idPlayer, lpData, dwDataSize,
3435 dwFlags, FALSE );
3436 }
3437
3438 static HRESULT DP_IF_SetPlayerName
3439 ( IDirectPlay2Impl* This, DPID idPlayer, LPDPNAME lpPlayerName,
3440 DWORD dwFlags, BOOL bAnsi )
3441 {
3442 lpPlayerList lpPList;
3443
3444 TRACE( "(%p)->(0x%08x,%p,0x%08x,%u)\n",
3445 This, idPlayer, lpPlayerName, dwFlags, bAnsi );
3446
3447 if( This->dp2->connectionInitialized == NO_PROVIDER )
3448 {
3449 return DPERR_UNINITIALIZED;
3450 }
3451
3452 if( ( lpPList = DP_FindPlayer( This, idPlayer ) ) == NULL )
3453 {
3454 return DPERR_INVALIDGROUP;
3455 }
3456
3457 DP_CopyDPNAMEStruct( &lpPList->lpPData->name, lpPlayerName, bAnsi );
3458
3459 /* Should send a DPMSG_SETPLAYERORGROUPNAME message */
3460 FIXME( "Message not sent and dwFlags ignored\n" );
3461
3462 return DP_OK;
3463 }
3464
3465 static HRESULT WINAPI DirectPlay2AImpl_SetPlayerName
3466 ( LPDIRECTPLAY2A iface, DPID idPlayer, LPDPNAME lpPlayerName,
3467 DWORD dwFlags )
3468 {
3469 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3470 return DP_IF_SetPlayerName( This, idPlayer, lpPlayerName, dwFlags, TRUE );
3471 }
3472
3473 static HRESULT WINAPI DirectPlay2WImpl_SetPlayerName
3474 ( LPDIRECTPLAY2 iface, DPID idPlayer, LPDPNAME lpPlayerName,
3475 DWORD dwFlags )
3476 {
3477 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3478 return DP_IF_SetPlayerName( This, idPlayer, lpPlayerName, dwFlags, FALSE );
3479 }
3480
3481 HRESULT DP_SetSessionDesc
3482 ( IDirectPlay2Impl* This, LPCDPSESSIONDESC2 lpSessDesc,
3483 DWORD dwFlags, BOOL bInitial, BOOL bAnsi )
3484 {
3485 DWORD dwRequiredSize;
3486 LPDPSESSIONDESC2 lpTempSessDesc;
3487
3488 TRACE( "(%p)->(%p,0x%08x,%u,%u)\n",
3489 This, lpSessDesc, dwFlags, bInitial, bAnsi );
3490
3491 /* FIXME: Copy into This->dp2->lpSessionDesc */
3492 dwRequiredSize = DP_CalcSessionDescSize( lpSessDesc, bAnsi );
3493 lpTempSessDesc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize );
3494
3495 if( lpTempSessDesc == NULL )
3496 {
3497 return DPERR_OUTOFMEMORY;
3498 }
3499
3500 /* Free the old */
3501 HeapFree( GetProcessHeap(), 0, This->dp2->lpSessionDesc );
3502
3503 This->dp2->lpSessionDesc = lpTempSessDesc;
3504 /* Set the new */
3505 DP_CopySessionDesc( This->dp2->lpSessionDesc, lpSessDesc, bAnsi );
3506 if( bInitial )
3507 {
3508 /*Initializing session GUID*/
3509 CoCreateGuid( &(This->dp2->lpSessionDesc->guidInstance) );
3510 }
3511 /* If this is an external invocation of the interface, we should be
3512 * letting everyone know that things have changed. Otherwise this is
3513 * just an initialization and it doesn't need to be propagated.
3514 */
3515 if( !bInitial )
3516 {
3517 FIXME( "Need to send a DPMSG_SETSESSIONDESC msg to everyone\n" );
3518 }
3519
3520 return DP_OK;
3521 }
3522
3523 static HRESULT WINAPI DirectPlay2AImpl_SetSessionDesc
3524 ( LPDIRECTPLAY2A iface, LPDPSESSIONDESC2 lpSessDesc, DWORD dwFlags )
3525 {
3526 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3527
3528 if( This->dp2->connectionInitialized == NO_PROVIDER )
3529 {
3530 return DPERR_UNINITIALIZED;
3531 }
3532
3533 if( !This->dp2->bConnectionOpen )
3534 {
3535 return DPERR_NOSESSIONS;
3536 }
3537
3538 if( dwFlags || (lpSessDesc == NULL) )
3539 {
3540 return DPERR_INVALIDPARAMS;
3541 }
3542
3543 /* Illegal combinations of flags */
3544 if ( ( lpSessDesc->dwFlags & DPSESSION_MIGRATEHOST ) &&
3545 ( lpSessDesc->dwFlags & ( DPSESSION_CLIENTSERVER |
3546 DPSESSION_MULTICASTSERVER |
3547 DPSESSION_SECURESERVER ) ) )
3548 {
3549 return DPERR_INVALIDFLAGS;
3550 }
3551
3552 /* Only the host is allowed to update the session desc */
3553 if( !This->dp2->bHostInterface )
3554 {
3555 return DPERR_ACCESSDENIED;
3556 }
3557
3558 return DP_SetSessionDesc( This, lpSessDesc, dwFlags, FALSE, TRUE );
3559 }
3560
3561 static HRESULT WINAPI DirectPlay2WImpl_SetSessionDesc
3562 ( LPDIRECTPLAY2 iface, LPDPSESSIONDESC2 lpSessDesc, DWORD dwFlags )
3563 {
3564 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface;
3565
3566 if( This->dp2->connectionInitialized == NO_PROVIDER )
3567 {
3568 return DPERR_UNINITIALIZED;
3569 }
3570
3571 if( !This->dp2->bConnectionOpen )
3572 {
3573 return DPERR_NOSESSIONS;
3574 }
3575
3576 if( dwFlags || (lpSessDesc == NULL) )
3577 {
3578 return DPERR_INVALIDPARAMS;
3579 }
3580
3581 /* Illegal combinations of flags */
3582 if ( ( lpSessDesc->dwFlags & DPSESSION_MIGRATEHOST ) &&
3583 ( lpSessDesc->dwFlags & ( DPSESSION_CLIENTSERVER |
3584 DPSESSION_MULTICASTSERVER |
3585 DPSESSION_SECURESERVER ) ) )
3586 {
3587 return DPERR_INVALIDFLAGS;
3588 }
3589
3590 /* Only the host is allowed to update the session desc */
3591 if( !This->dp2->bHostInterface )
3592 {
3593 return DPERR_ACCESSDENIED;
3594 }
3595
3596 return DP_SetSessionDesc( This, lpSessDesc, dwFlags, FALSE, TRUE );
3597 }
3598
3599 /* FIXME: See about merging some of this stuff with dplayx_global.c stuff */
3600 static DWORD DP_CalcSessionDescSize( LPCDPSESSIONDESC2 lpSessDesc, BOOL bAnsi )
3601 {
3602 DWORD dwSize = 0;
3603
3604 if( lpSessDesc == NULL )
3605 {
3606 /* Hmmm..don't need any size? */
3607 ERR( "NULL lpSessDesc\n" );
3608 return dwSize;
3609 }
3610
3611 dwSize += sizeof( *lpSessDesc );
3612
3613 if( bAnsi )
3614 {
3615 if( lpSessDesc->u1.lpszSessionNameA )
3616 {
3617 dwSize += lstrlenA( lpSessDesc->u1.lpszSessionNameA ) + 1;
3618 }
3619
3620 if( lpSessDesc->u2.lpszPasswordA )
3621 {
3622 dwSize += lstrlenA( lpSessDesc->u2.lpszPasswordA ) + 1;
3623 }
3624 }
3625 else /* UNICODE */
3626 {
3627 if( lpSessDesc->u1.lpszSessionName )
3628 {
3629 dwSize += sizeof( WCHAR ) *
3630 ( lstrlenW( lpSessDesc->u1.lpszSessionName ) + 1 );
3631 }
3632
3633 if( lpSessDesc->u2.lpszPassword )
3634 {
3635 dwSize += sizeof( WCHAR ) *
3636 ( lstrlenW( lpSessDesc->u2.lpszPassword ) + 1 );
3637 }
3638 }
3639
3640 return dwSize;
3641 }
3642
3643 /* Assumes that contiguous buffers are already allocated. */
3644 static void DP_CopySessionDesc( LPDPSESSIONDESC2 lpSessionDest,
3645 LPCDPSESSIONDESC2 lpSessionSrc, BOOL bAnsi )
3646 {
3647 BYTE* lpStartOfFreeSpace;
3648
3649 if( lpSessionDest == NULL )
3650 {
3651 ERR( "NULL lpSessionDest\n" );
3652 return;
3653 }
3654
3655 CopyMemory( lpSessionDest, lpSessionSrc, sizeof( *lpSessionSrc ) );
3656
3657 lpStartOfFreeSpace = ((BYTE*)lpSessionDest) + sizeof( *lpSessionSrc );
3658
3659 if( bAnsi )
3660 {
3661 if( lpSessionSrc->u1.lpszSessionNameA )
3662 {
3663 lstrcpyA( (LPSTR)lpStartOfFreeSpace,
3664 lpSessionDest->u1.lpszSessionNameA );
3665 lpSessionDest->u1.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
3666 lpStartOfFreeSpace +=
3667 lstrlenA( lpSessionDest->u1.lpszSessionNameA ) + 1;
3668 }
3669
3670 if( lpSessionSrc->u2.lpszPasswordA )
3671 {
3672 lstrcpyA( (LPSTR)lpStartOfFreeSpace,
3673 lpSessionDest->u2.lpszPasswordA );
3674 lpSessionDest->u2.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
3675 lpStartOfFreeSpace +=
3676 lstrlenA( lpSessionDest->u2.lpszPasswordA ) + 1;
3677 }
3678 }
3679 else /* UNICODE */
3680 {
3681 if( lpSessionSrc->u1.lpszSessionName )
3682 {
3683 lstrcpyW( (LPWSTR)lpStartOfFreeSpace,
3684 lpSessionDest->u1.lpszSessionName );
3685 lpSessionDest->u1.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
3686 lpStartOfFreeSpace += sizeof(WCHAR) *
3687 ( lstrlenW( lpSessionDest->u1.lpszSessionName ) + 1 );
3688 }
3689
3690 if( lpSessionSrc->u2.lpszPassword )
3691 {
3692 lstrcpyW( (LPWSTR)lpStartOfFreeSpace,
3693 lpSessionDest->u2.lpszPassword );
3694 lpSessionDest->u2.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
3695 lpStartOfFreeSpace += sizeof(WCHAR) *
3696 ( lstrlenW( lpSessionDest->u2.lpszPassword ) + 1 );
3697 }
3698 }
3699 }
3700
3701
3702 static HRESULT DP_IF_AddGroupToGroup
3703 ( IDirectPlay3Impl* This, DPID idParentGroup, DPID idGroup )
3704 {
3705 lpGroupData lpGData;
3706 lpGroupList lpNewGList;
3707
3708 TRACE( "(%p)->(0x%08x,0x%08x)\n", This, idParentGroup, idGroup );
3709
3710 if( This->dp2->connectionInitialized == NO_PROVIDER )
3711 {
3712 return DPERR_UNINITIALIZED;
3713 }
3714
3715 if( DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idParentGroup ) == NULL )
3716 {
3717 return DPERR_INVALIDGROUP;
3718 }
3719
3720 if( ( lpGData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idGroup ) ) == NULL )
3721 {
3722 return DPERR_INVALIDGROUP;
3723 }
3724
3725 /* Create a player list (ie "shortcut" ) */
3726 lpNewGList = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpNewGList ) );
3727 if( lpNewGList == NULL )
3728 {
3729 return DPERR_CANTADDPLAYER;
3730 }
3731
3732 /* Add the shortcut */
3733 lpGData->uRef++;
3734 lpNewGList->lpGData = lpGData;
3735
3736 /* Add the player to the list of players for this group */
3737 DPQ_INSERT( lpGData->groups, lpNewGList, groups );
3738
3739 /* Send a ADDGROUPTOGROUP message */
3740 FIXME( "Not sending message\n" );
3741
3742 return DP_OK;
3743 }
3744
3745 static HRESULT WINAPI DirectPlay3AImpl_AddGroupToGroup
3746 ( LPDIRECTPLAY3A iface, DPID idParentGroup, DPID idGroup )
3747 {
3748 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3749 return DP_IF_AddGroupToGroup( This, idParentGroup, idGroup );
3750 }
3751
3752 static HRESULT WINAPI DirectPlay3WImpl_AddGroupToGroup
3753 ( LPDIRECTPLAY3 iface, DPID idParentGroup, DPID idGroup )
3754 {
3755 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3756 return DP_IF_AddGroupToGroup( This, idParentGroup, idGroup );
3757 }
3758
3759 static HRESULT DP_IF_CreateGroupInGroup
3760 ( IDirectPlay3Impl* This, LPVOID lpMsgHdr, DPID idParentGroup,
3761 LPDPID lpidGroup, LPDPNAME lpGroupName, LPVOID lpData,
3762 DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi )
3763 {
3764 lpGroupData lpGParentData;
3765 lpGroupList lpGList;
3766 lpGroupData lpGData;
3767
3768 TRACE( "(%p)->(0x%08x,%p,%p,%p,0x%08x,0x%08x,%u)\n",
3769 This, idParentGroup, lpidGroup, lpGroupName, lpData,
3770 dwDataSize, dwFlags, bAnsi );
3771
3772 /* Verify that the specified parent is valid */
3773 if( ( lpGParentData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This,
3774 idParentGroup ) ) == NULL
3775 )
3776 {
3777 return DPERR_INVALIDGROUP;
3778 }
3779
3780 lpGData = DP_CreateGroup( (IDirectPlay2AImpl*)This, lpidGroup, lpGroupName,
3781 dwFlags, idParentGroup, bAnsi );
3782
3783 if( lpGData == NULL )
3784 {
3785 return DPERR_CANTADDPLAYER; /* yes player not group */
3786 }
3787
3788 /* Something else is referencing this data */
3789 lpGData->uRef++;
3790
3791 DP_SetGroupData( lpGData, DPSET_REMOTE, lpData, dwDataSize );
3792
3793 /* The list has now been inserted into the interface group list. We now
3794 need to put a "shortcut" to this group in the parent group */
3795 lpGList = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpGList ) );
3796 if( lpGList == NULL )
3797 {
3798 FIXME( "Memory leak\n" );
3799 return DPERR_CANTADDPLAYER; /* yes player not group */
3800 }
3801
3802 lpGList->lpGData = lpGData;
3803
3804 DPQ_INSERT( lpGParentData->groups, lpGList, groups );
3805
3806 /* Let the SP know that we've created this group */
3807 if( This->dp2->spData.lpCB->CreateGroup )
3808 {
3809 DPSP_CREATEGROUPDATA data;
3810
3811 TRACE( "Calling SP CreateGroup\n" );
3812
3813 data.idGroup = *lpidGroup;
3814 data.dwFlags = dwFlags;
3815 data.lpSPMessageHeader = lpMsgHdr;
3816 data.lpISP = This->dp2->spData.lpISP;
3817
3818 (*This->dp2->spData.lpCB->CreateGroup)( &data );
3819 }
3820
3821 /* Inform all other peers of the creation of a new group. If there are
3822 * no peers keep this quiet.
3823 */
3824 if( This->dp2->lpSessionDesc &&
3825 ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_MULTICASTSERVER ) )
3826 {
3827 DPMSG_CREATEPLAYERORGROUP msg;
3828
3829 msg.dwType = DPSYS_CREATEPLAYERORGROUP;
3830 msg.dwPlayerType = DPPLAYERTYPE_GROUP;
3831 msg.dpId = *lpidGroup;
3832 msg.dwCurrentPlayers = idParentGroup; /* FIXME: Incorrect? */
3833 msg.lpData = lpData;
3834 msg.dwDataSize = dwDataSize;
3835 msg.dpnName = *lpGroupName;
3836
3837 /* FIXME: Correct to just use send effectively? */
3838 /* FIXME: Should size include data w/ message or just message "header" */
3839 /* FIXME: Check return code */
3840 DP_SendEx( (IDirectPlay2Impl*)This,
3841 DPID_SERVERPLAYER, DPID_ALLPLAYERS, 0, &msg, sizeof( msg ),
3842 0, 0, NULL, NULL, bAnsi );
3843 }
3844
3845 return DP_OK;
3846 }
3847
3848 static HRESULT WINAPI DirectPlay3AImpl_CreateGroupInGroup
3849 ( LPDIRECTPLAY3A iface, DPID idParentGroup, LPDPID lpidGroup,
3850 LPDPNAME lpGroupName, LPVOID lpData, DWORD dwDataSize,
3851 DWORD dwFlags )
3852 {
3853 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3854
3855 if( This->dp2->connectionInitialized == NO_PROVIDER )
3856 {
3857 return DPERR_UNINITIALIZED;
3858 }
3859
3860 if( lpidGroup == NULL ||
3861 !This->dp2->bConnectionOpen ||
3862 dwDataSize >= MAXDWORD ||
3863 ( lpData == NULL && dwDataSize != 0 ) )
3864 {
3865 return DPERR_INVALIDPARAMS;
3866 }
3867
3868 *lpidGroup = DPID_UNKNOWN;
3869
3870 return DP_IF_CreateGroupInGroup( This, NULL, idParentGroup, lpidGroup,
3871 lpGroupName, lpData, dwDataSize, dwFlags,
3872 TRUE );
3873 }
3874
3875 static HRESULT WINAPI DirectPlay3WImpl_CreateGroupInGroup
3876 ( LPDIRECTPLAY3 iface, DPID idParentGroup, LPDPID lpidGroup,
3877 LPDPNAME lpGroupName, LPVOID lpData, DWORD dwDataSize,
3878 DWORD dwFlags )
3879 {
3880 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3881
3882 if( This->dp2->connectionInitialized == NO_PROVIDER )
3883 {
3884 return DPERR_UNINITIALIZED;
3885 }
3886
3887 if( lpidGroup == NULL ||
3888 !This->dp2->bConnectionOpen ||
3889 dwDataSize >= MAXDWORD ||
3890 ( lpData == NULL && dwDataSize != 0 ) )
3891 {
3892 return DPERR_INVALIDPARAMS;
3893 }
3894
3895 *lpidGroup = DPID_UNKNOWN;
3896
3897 return DP_IF_CreateGroupInGroup( This, NULL, idParentGroup, lpidGroup,
3898 lpGroupName, lpData, dwDataSize,
3899 dwFlags, FALSE );
3900 }
3901
3902 static HRESULT DP_IF_DeleteGroupFromGroup
3903 ( IDirectPlay3Impl* This, DPID idParentGroup, DPID idGroup )
3904 {
3905 lpGroupList lpGList;
3906 lpGroupData lpGParentData;
3907
3908 TRACE("(%p)->(0x%08x,0x%08x)\n", This, idParentGroup, idGroup );
3909
3910 /* Is the parent group valid? */
3911 if( ( lpGParentData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idParentGroup ) ) == NULL )
3912 {
3913 return DPERR_INVALIDGROUP;
3914 }
3915
3916 /* Remove the group from the parent group queue */
3917 DPQ_REMOVE_ENTRY( lpGParentData->groups, groups, lpGData->dpid, ==, idGroup, lpGList );
3918
3919 if( lpGList == NULL )
3920 {
3921 return DPERR_INVALIDGROUP;
3922 }
3923
3924 /* Decrement the ref count */
3925 lpGList->lpGData->uRef--;
3926
3927 /* Free up the list item */
3928 HeapFree( GetProcessHeap(), 0, lpGList );
3929
3930 /* Should send a DELETEGROUPFROMGROUP message */
3931 FIXME( "message not sent\n" );
3932
3933 return DP_OK;
3934 }
3935
3936 static HRESULT WINAPI DirectPlay3AImpl_DeleteGroupFromGroup
3937 ( LPDIRECTPLAY3 iface, DPID idParentGroup, DPID idGroup )
3938 {
3939 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3940 return DP_IF_DeleteGroupFromGroup( This, idParentGroup, idGroup );
3941 }
3942
3943 static HRESULT WINAPI DirectPlay3WImpl_DeleteGroupFromGroup
3944 ( LPDIRECTPLAY3 iface, DPID idParentGroup, DPID idGroup )
3945 {
3946 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3947 return DP_IF_DeleteGroupFromGroup( This, idParentGroup, idGroup );
3948 }
3949 static BOOL DP_BuildCompoundAddr( GUID guidDataType,
3950 LPGUID lpcSpGuid,
3951 LPVOID* lplpAddrBuf,
3952 LPDWORD lpdwBufSize )
3953 {
3954 DPCOMPOUNDADDRESSELEMENT dpCompoundAddress;
3955 HRESULT hr;
3956
3957 dpCompoundAddress.dwDataSize = sizeof( GUID );
3958 dpCompoundAddress.guidDataType = guidDataType;
3959 dpCompoundAddress.lpData = lpcSpGuid;
3960
3961 *lplpAddrBuf = NULL;
3962 *lpdwBufSize = 0;
3963
3964 hr = DPL_CreateCompoundAddress( &dpCompoundAddress, 1, *lplpAddrBuf,
3965 lpdwBufSize, TRUE );
3966
3967 if( hr != DPERR_BUFFERTOOSMALL )
3968 {
3969 ERR( "can't get buffer size: %s\n", DPLAYX_HresultToString( hr ) );
3970 return FALSE;
3971 }
3972
3973 /* Now allocate the buffer */
3974 *lplpAddrBuf = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
3975 *lpdwBufSize );
3976
3977 hr = DPL_CreateCompoundAddress( &dpCompoundAddress, 1, *lplpAddrBuf,
3978 lpdwBufSize, TRUE );
3979 if( FAILED(hr) )
3980 {
3981 ERR( "can't create address: %s\n", DPLAYX_HresultToString( hr ) );
3982 return FALSE;
3983 }
3984
3985 return TRUE;
3986 }
3987
3988 static HRESULT WINAPI DP_IF_EnumConnections
3989 ( LPDIRECTPLAY3A iface, LPCGUID lpguidApplication,
3990 LPDPENUMCONNECTIONSCALLBACK lpEnumCallback, LPVOID lpContext,
3991 DWORD dwFlags, BOOL bAnsi )
3992 {
3993 HKEY hkResult;
3994 WCHAR searchSubKeySP[] = {
3995 'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\',
3996 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\',
3997 'D', 'i', 'r', 'e', 'c', 't', 'P', 'l', 'a', 'y', '\\',
3998 'S', 'e', 'r', 'v', 'i', 'c', 'e', ' ', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 's', 0 };
3999 WCHAR searchSubKeyLP[] = {
4000 'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\',
4001 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\',
4002 'D', 'i', 'r', 'e', 'c', 't', 'P', 'l', 'a', 'y', '\\',
4003 'L', 'o', 'b', 'b', 'y', ' ', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 's', 0 };
4004 WCHAR guidDataSubKey[] = { 'G', 'u', 'i', 'd', 0 };
4005 WCHAR subKeyName[255]; /* 255 is the maximum key size according to MSDN */
4006 DWORD dwIndex, sizeOfSubKeyName = sizeof(subKeyName) / sizeof(WCHAR);
4007 FILETIME filetime;
4008
4009 /* A default dwFlags (0) is backwards compatible -- DPCONNECTION_DIRECTPLAY */
4010 if( dwFlags == 0 )
4011 {
4012 dwFlags = DPCONNECTION_DIRECTPLAY;
4013 }
4014
4015 if( ! ( ( dwFlags & DPCONNECTION_DIRECTPLAY ) ||
4016 ( dwFlags & DPCONNECTION_DIRECTPLAYLOBBY ) ) )
4017 {
4018 return DPERR_INVALIDFLAGS;
4019 }
4020
4021 if( !lpEnumCallback )
4022 {
4023 return DPERR_INVALIDPARAMS;
4024 }
4025
4026
4027 /* Need to loop over the service providers in the registry */
4028 if( RegOpenKeyExW( HKEY_LOCAL_MACHINE,
4029 ( dwFlags & DPCONNECTION_DIRECTPLAY ) ? searchSubKeySP
4030 : searchSubKeyLP,
4031 0, KEY_READ, &hkResult ) != ERROR_SUCCESS )
4032 {
4033 /* Hmmm. Does this mean that there are no service providers? */
4034 ERR(": no service providers?\n");
4035 return DP_OK;
4036 }
4037
4038
4039 /* Traverse all the service providers we have available */
4040 for( dwIndex=0;
4041 RegEnumKeyExW( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4042 NULL, NULL, NULL, &filetime ) != ERROR_NO_MORE_ITEMS;
4043 ++dwIndex, sizeOfSubKeyName = sizeof(subKeyName) / sizeof(WCHAR) )
4044 {
4045 HKEY hkServiceProvider;
4046 GUID serviceProviderGUID;
4047 WCHAR guidKeyContent[39];
4048 DWORD sizeOfReturnBuffer = sizeof(guidKeyContent);
4049 DPNAME dpName;
4050 BOOL continueEnumeration = TRUE;
4051
4052 LPVOID lpAddressBuffer = NULL;
4053 DWORD dwAddressBufferSize = 0;
4054
4055
4056 TRACE(" this time through: %s\n", debugstr_w(subKeyName) );
4057
4058 /* Get a handle for this particular service provider */
4059 if( RegOpenKeyExW( hkResult, subKeyName, 0, KEY_READ,
4060 &hkServiceProvider ) != ERROR_SUCCESS )
4061 {
4062 ERR(": what the heck is going on?\n" );
4063 continue;
4064 }
4065
4066 if( RegQueryValueExW( hkServiceProvider, guidDataSubKey,
4067 NULL, NULL, (LPBYTE)guidKeyContent,
4068 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4069 {
4070 ERR(": missing GUID registry data members\n" );
4071 RegCloseKey(hkServiceProvider);
4072 continue;
4073 }
4074 RegCloseKey(hkServiceProvider);
4075
4076 CLSIDFromString( guidKeyContent, &serviceProviderGUID );
4077
4078 /* Fill in the DPNAME struct for the service provider */
4079 dpName.dwSize = sizeof( dpName );
4080 dpName.dwFlags = 0;
4081 if ( bAnsi )
4082 {
4083 dpName.u1.lpszShortNameA = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
4084 sizeOfSubKeyName+1 );
4085 WideCharToMultiByte( CP_ACP, 0, subKeyName,
4086 -1, dpName.u1.lpszShortNameA, -1, 0, 0);
4087 dpName.u2.lpszLongNameA = NULL;
4088 }
4089 else
4090 {
4091 dpName.u1.lpszShortName = subKeyName;
4092 dpName.u2.lpszLongName = NULL;
4093 }
4094
4095 /* Create the compound address for the service provider.
4096 * NOTE: This is a gruesome architectural scar right now. DP
4097 * uses DPL and DPL uses DP. Nasty stuff. This may be why the
4098 * native dll just gets around this little bit by allocating an
4099 * 80 byte buffer which isn't even filled with a valid compound
4100 * address. Oh well. Creating a proper compound address is the
4101 * way to go anyways despite this method taking slightly more
4102 * heap space and realtime :) */
4103
4104 if ( DP_BuildCompoundAddr( ( ( dwFlags & DPCONNECTION_DIRECTPLAY )
4105 ? DPAID_ServiceProvider
4106 : DPAID_LobbyProvider ),
4107 &serviceProviderGUID,
4108 &lpAddressBuffer,
4109 &dwAddressBufferSize ) )
4110 {
4111 /* The enumeration will return FALSE if we are not to continue */
4112 continueEnumeration = lpEnumCallback( &serviceProviderGUID, lpAddressBuffer,
4113 dwAddressBufferSize, &dpName,
4114 dwFlags, lpContext );
4115 }
4116 else
4117 {
4118 ERR( "Couldn't build compound address\n" );
4119 }
4120
4121 HeapFree( GetProcessHeap(), 0, lpAddressBuffer );
4122 if ( bAnsi )
4123 HeapFree( GetProcessHeap(), 0, dpName.u1.lpszShortNameA );
4124
4125 if (!continueEnumeration)
4126 return DP_OK;
4127 }
4128
4129 return DP_OK;
4130 }
4131
4132 static HRESULT WINAPI DirectPlay3AImpl_EnumConnections
4133 ( LPDIRECTPLAY3A iface, LPCGUID lpguidApplication, LPDPENUMCONNECTIONSCALLBACK lpEnumCallback, LPVOID lpContext, DWORD dwFlags )
4134 {
4135 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4136 TRACE("(%p)->(%p,%p,%p,0x%08x)\n", This, lpguidApplication, lpEnumCallback, lpContext, dwFlags );
4137 return DP_IF_EnumConnections( iface, lpguidApplication, lpEnumCallback, lpContext, dwFlags, TRUE );
4138 }
4139
4140 static HRESULT WINAPI DirectPlay3WImpl_EnumConnections
4141 ( LPDIRECTPLAY3 iface, LPCGUID lpguidApplication, LPDPENUMCONNECTIONSCALLBACK lpEnumCallback, LPVOID lpContext, DWORD dwFlags )
4142 {
4143 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4144 TRACE("(%p)->(%p,%p,%p,0x%08x)\n", This, lpguidApplication, lpEnumCallback, lpContext, dwFlags );
4145 return DP_IF_EnumConnections( iface, lpguidApplication, lpEnumCallback, lpContext, dwFlags, FALSE );
4146 }
4147
4148 static HRESULT DP_IF_EnumGroupsInGroup
4149 ( IDirectPlay3AImpl* This, DPID idGroup, LPGUID lpguidInstance,
4150 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
4151 LPVOID lpContext, DWORD dwFlags, BOOL bAnsi )
4152 {
4153 lpGroupList lpGList;
4154 lpGroupData lpGData;
4155
4156 FIXME( "(%p)->(0x%08x,%p,%p,%p,0x%08x,%u): semi stub\n",
4157 This, idGroup, lpguidInstance, lpEnumPlayersCallback2,
4158 lpContext, dwFlags, bAnsi );
4159
4160 if( This->dp2->connectionInitialized == NO_PROVIDER )
4161 {
4162 return DPERR_UNINITIALIZED;
4163 }
4164
4165 if( !This->dp2->bConnectionOpen )
4166 {
4167 return DPERR_NOSESSIONS;
4168 }
4169
4170 if( ( lpEnumPlayersCallback2 == NULL ) ||
4171 ( ( dwFlags & DPENUMGROUPS_SESSION ) && ( lpguidInstance == NULL ) ) )
4172 {
4173 return DPERR_INVALIDPARAMS;
4174 }
4175
4176 if( ( lpGData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idGroup ) ) == NULL )
4177 {
4178 return DPERR_INVALIDGROUP;
4179 }
4180
4181 if( DPQ_IS_EMPTY( lpGData->groups ) )
4182 {
4183 return DP_OK;
4184 }
4185
4186 lpGList = DPQ_FIRST( lpGData->groups );
4187
4188 for( ;; )
4189 {
4190 /* FIXME: Should check dwFlags for match here */
4191
4192 if( !(*lpEnumPlayersCallback2)( lpGList->lpGData->dpid, DPPLAYERTYPE_GROUP,
4193 &lpGList->lpGData->name, dwFlags,
4194 lpContext ) )
4195 {
4196 return DP_OK; /* User requested break */
4197 }
4198
4199 if( DPQ_IS_ENDOFLIST( lpGList->groups ) )
4200 {
4201 break;
4202 }
4203
4204 lpGList = DPQ_NEXT( lpGList->groups );
4205
4206 }
4207
4208 return DP_OK;
4209 }
4210
4211 static HRESULT WINAPI DirectPlay3AImpl_EnumGroupsInGroup
4212 ( LPDIRECTPLAY3A iface, DPID idGroup, LPGUID lpguidInstance,
4213 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2, LPVOID lpContext,
4214 DWORD dwFlags )
4215 {
4216 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4217 return DP_IF_EnumGroupsInGroup( This, idGroup, lpguidInstance,
4218 lpEnumPlayersCallback2, lpContext, dwFlags,
4219 TRUE );
4220 }
4221
4222 static HRESULT WINAPI DirectPlay3WImpl_EnumGroupsInGroup
4223 ( LPDIRECTPLAY3A iface, DPID idGroup, LPGUID lpguidInstance,
4224 LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2, LPVOID lpContext,
4225 DWORD dwFlags )
4226 {
4227 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4228 return DP_IF_EnumGroupsInGroup( This, idGroup, lpguidInstance,
4229 lpEnumPlayersCallback2, lpContext, dwFlags,
4230 FALSE );
4231 }
4232
4233 static HRESULT WINAPI DirectPlay3AImpl_GetGroupConnectionSettings
4234 ( LPDIRECTPLAY3A iface, DWORD dwFlags, DPID idGroup, LPVOID lpData, LPDWORD lpdwDataSize )
4235 {
4236 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4237 FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, dwFlags, idGroup, lpData, lpdwDataSize );
4238 return DP_OK;
4239 }
4240
4241 static HRESULT WINAPI DirectPlay3WImpl_GetGroupConnectionSettings
4242 ( LPDIRECTPLAY3 iface, DWORD dwFlags, DPID idGroup, LPVOID lpData, LPDWORD lpdwDataSize )
4243 {
4244 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4245 FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, dwFlags, idGroup, lpData, lpdwDataSize );
4246 return DP_OK;
4247 }
4248
4249 static BOOL CALLBACK DP_GetSpLpGuidFromCompoundAddress(
4250 REFGUID guidDataType,
4251 DWORD dwDataSize,
4252 LPCVOID lpData,
4253 LPVOID lpContext )
4254 {
4255 /* Looking for the GUID of the provider to load */
4256 if( ( IsEqualGUID( guidDataType, &DPAID_ServiceProvider ) ) ||
4257 ( IsEqualGUID( guidDataType, &DPAID_LobbyProvider ) )
4258 )
4259 {
4260 TRACE( "Found SP/LP (%s) %s (data size = 0x%08x)\n",
4261 debugstr_guid( guidDataType ), debugstr_guid( lpData ), dwDataSize );
4262
4263 if( dwDataSize != sizeof( GUID ) )
4264 {
4265 ERR( "Invalid sp/lp guid size 0x%08x\n", dwDataSize );
4266 }
4267
4268 memcpy( lpContext, lpData, dwDataSize );
4269
4270 /* There shouldn't be more than 1 GUID/compound address */
4271 return FALSE;
4272 }
4273
4274 /* Still waiting for what we want */
4275 return TRUE;
4276 }
4277
4278
4279 /* Find and perform a LoadLibrary on the requested SP or LP GUID */
4280 static HMODULE DP_LoadSP( LPCGUID lpcGuid, LPSPINITDATA lpSpData, LPBOOL lpbIsDpSp )
4281 {
4282 UINT i;
4283 LPCSTR spSubKey = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
4284 LPCSTR lpSubKey = "SOFTWARE\\Microsoft\\DirectPlay\\Lobby Providers";
4285 LPCSTR guidDataSubKey = "Guid";
4286 LPCSTR majVerDataSubKey = "dwReserved1";
4287 LPCSTR minVerDataSubKey = "dwReserved2";
4288 LPCSTR pathSubKey = "Path";
4289
4290 TRACE( " request to load %s\n", debugstr_guid( lpcGuid ) );
4291
4292 /* FIXME: Cloned code with a quick hack. */
4293 for( i=0; i<2; i++ )
4294 {
4295 HKEY hkResult;
4296 LPCSTR searchSubKey;
4297 char subKeyName[51];
4298 DWORD dwIndex, sizeOfSubKeyName=50;
4299 FILETIME filetime;
4300
4301 (i == 0) ? (searchSubKey = spSubKey ) : (searchSubKey = lpSubKey );
4302 *lpbIsDpSp = (i == 0) ? TRUE : FALSE;
4303
4304
4305 /* Need to loop over the service providers in the registry */
4306 if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
4307 0, KEY_READ, &hkResult ) != ERROR_SUCCESS )
4308 {
4309 /* Hmmm. Does this mean that there are no service providers? */
4310 ERR(": no service providers?\n");
4311 return 0;
4312 }
4313
4314 /* Traverse all the service providers we have available */
4315 for( dwIndex=0;
4316 RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4317 NULL, NULL, NULL, &filetime ) != ERROR_NO_MORE_ITEMS;
4318 ++dwIndex, sizeOfSubKeyName=51 )
4319 {
4320
4321 HKEY hkServiceProvider;
4322 GUID serviceProviderGUID;
4323 DWORD returnType, sizeOfReturnBuffer = 255;
4324 char returnBuffer[256];
4325 WCHAR buff[51];
4326 DWORD dwTemp, len;
4327
4328 TRACE(" this time through: %s\n", subKeyName );
4329
4330 /* Get a handle for this particular service provider */
4331 if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_READ,
4332 &hkServiceProvider ) != ERROR_SUCCESS )
4333 {
4334 ERR(": what the heck is going on?\n" );
4335 continue;
4336 }
4337
4338 if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
4339 NULL, &returnType, (LPBYTE)returnBuffer,
4340 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4341 {
4342 ERR(": missing GUID registry data members\n" );
4343 continue;
4344 }
4345
4346 /* FIXME: Check return types to ensure we're interpreting data right */
4347 MultiByteToWideChar( CP_ACP, 0, returnBuffer, -1, buff, sizeof(buff)/sizeof(WCHAR) );
4348 CLSIDFromString( buff, &serviceProviderGUID );
4349 /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
4350
4351 /* Determine if this is the Service Provider that the user asked for */
4352 if( !IsEqualGUID( &serviceProviderGUID, lpcGuid ) )
4353 {
4354 continue;
4355 }
4356
4357 if( i == 0 ) /* DP SP */
4358 {
4359 len = MultiByteToWideChar( CP_ACP, 0, subKeyName, -1, NULL, 0 );
4360 lpSpData->lpszName = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
4361 MultiByteToWideChar( CP_ACP, 0, subKeyName, -1, lpSpData->lpszName, len );
4362 }
4363
4364 sizeOfReturnBuffer = 255;
4365
4366 /* Get dwReserved1 */
4367 if( RegQueryValueExA( hkServiceProvider, majVerDataSubKey,
4368 NULL, &returnType, (LPBYTE)returnBuffer,
4369 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4370 {
4371 ERR(": missing dwReserved1 registry data members\n") ;
4372 continue;
4373 }
4374
4375 if( i == 0 )
4376 memcpy( &lpSpData->dwReserved1, returnBuffer, sizeof(lpSpData->dwReserved1) );
4377
4378 sizeOfReturnBuffer = 255;
4379
4380 /* Get dwReserved2 */
4381 if( RegQueryValueExA( hkServiceProvider, minVerDataSubKey,
4382 NULL, &returnType, (LPBYTE)returnBuffer,
4383 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4384 {
4385 ERR(": missing dwReserved1 registry data members\n") ;
4386 continue;
4387 }
4388
4389 if( i == 0 )
4390 memcpy( &lpSpData->dwReserved2, returnBuffer, sizeof(lpSpData->dwReserved2) );
4391
4392 sizeOfReturnBuffer = 255;
4393
4394 /* Get the path for this service provider */
4395 if( ( dwTemp = RegQueryValueExA( hkServiceProvider, pathSubKey,
4396 NULL, NULL, (LPBYTE)returnBuffer,
4397 &sizeOfReturnBuffer ) ) != ERROR_SUCCESS )
4398 {
4399 ERR(": missing PATH registry data members: 0x%08x\n", dwTemp );
4400 continue;
4401 }
4402
4403 TRACE( "Loading %s\n", returnBuffer );
4404 return LoadLibraryA( returnBuffer );
4405 }
4406 }
4407
4408 return 0;
4409 }
4410
4411 static
4412 HRESULT DP_InitializeDPSP( IDirectPlay3Impl* This, HMODULE hServiceProvider )
4413 {
4414 HRESULT hr;
4415 LPDPSP_SPINIT SPInit;
4416
4417 /* Initialize the service provider by calling SPInit */
4418 SPInit = (LPDPSP_SPINIT)GetProcAddress( hServiceProvider, "SPInit" );
4419
4420 if( SPInit == NULL )
4421 {
4422 ERR( "Service provider doesn't provide SPInit interface?\n" );
4423 FreeLibrary( hServiceProvider );
4424 return DPERR_UNAVAILABLE;
4425 }
4426
4427 TRACE( "Calling SPInit (DP SP entry point)\n" );
4428
4429 hr = (*SPInit)( &This->dp2->spData );
4430
4431 if( FAILED(hr) )
4432 {
4433 ERR( "DP SP Initialization failed: %s\n", DPLAYX_HresultToString(hr) );
4434 FreeLibrary( hServiceProvider );
4435 return hr;
4436 }
4437
4438 /* FIXME: Need to verify the sanity of the returned callback table
4439 * using IsBadCodePtr */
4440 This->dp2->bSPInitialized = TRUE;
4441
4442 /* This interface is now initialized as a DP object */
4443 This->dp2->connectionInitialized = DP_SERVICE_PROVIDER;
4444
4445 /* Store the handle of the module so that we can unload it later */
4446 This->dp2->hServiceProvider = hServiceProvider;
4447
4448 return hr;
4449 }
4450
4451 static
4452 HRESULT DP_InitializeDPLSP( IDirectPlay3Impl* This, HMODULE hLobbyProvider )
4453 {
4454 HRESULT hr;
4455 LPSP_INIT DPLSPInit;
4456
4457 /* Initialize the service provider by calling SPInit */
4458 DPLSPInit = (LPSP_INIT)GetProcAddress( hLobbyProvider, "DPLSPInit" );
4459
4460 if( DPLSPInit == NULL )
4461 {
4462 ERR( "Service provider doesn't provide DPLSPInit interface?\n" );
4463 FreeLibrary( hLobbyProvider );
4464 return DPERR_UNAVAILABLE;
4465 }
4466
4467 TRACE( "Calling DPLSPInit (DPL SP entry point)\n" );
4468
4469 hr = (*DPLSPInit)( &This->dp2->dplspData );
4470
4471 if( FAILED(hr) )
4472 {
4473 ERR( "DPL SP Initialization failed: %s\n", DPLAYX_HresultToString(hr) );
4474 FreeLibrary( hLobbyProvider );
4475 return hr;
4476 }
4477
4478 /* FIXME: Need to verify the sanity of the returned callback table
4479 * using IsBadCodePtr */
4480
4481 This->dp2->bDPLSPInitialized = TRUE;
4482
4483 /* This interface is now initialized as a lobby object */
4484 This->dp2->connectionInitialized = DP_LOBBY_PROVIDER;
4485
4486 /* Store the handle of the module so that we can unload it later */
4487 This->dp2->hDPLobbyProvider = hLobbyProvider;
4488
4489 return hr;
4490 }
4491
4492 static HRESULT DP_IF_InitializeConnection
4493 ( IDirectPlay3Impl* This, LPVOID lpConnection, DWORD dwFlags, BOOL bAnsi )
4494 {
4495 HMODULE hServiceProvider;
4496 HRESULT hr;
4497 GUID guidSP;
4498 const DWORD dwAddrSize = 80; /* FIXME: Need to calculate it correctly */
4499 BOOL bIsDpSp; /* TRUE if Direct Play SP, FALSE if Direct Play Lobby SP */
4500
4501 TRACE("(%p)->(%p,0x%08x,%u)\n", This, lpConnection, dwFlags, bAnsi );
4502
4503 if ( lpConnection == NULL )
4504 {
4505 return DPERR_INVALIDPARAMS;
4506 }
4507
4508 if( dwFlags != 0 )
4509 {
4510 return DPERR_INVALIDFLAGS;
4511 }
4512
4513 if( This->dp2->connectionInitialized != NO_PROVIDER )
4514 {
4515 return DPERR_ALREADYINITIALIZED;
4516 }
4517
4518 /* Find out what the requested SP is and how large this buffer is */
4519 hr = DPL_EnumAddress( DP_GetSpLpGuidFromCompoundAddress, lpConnection,
4520 dwAddrSize, &guidSP );
4521
4522 if( FAILED(hr) )
4523 {
4524 ERR( "Invalid compound address?\n" );
4525 return DPERR_UNAVAILABLE;
4526 }
4527
4528 /* Load the service provider */
4529 hServiceProvider = DP_LoadSP( &guidSP, &This->dp2->spData, &bIsDpSp );
4530
4531 if( hServiceProvider == 0 )
4532 {
4533 ERR( "Unable to load service provider %s\n", debugstr_guid(&guidSP) );
4534 return DPERR_UNAVAILABLE;
4535 }
4536
4537 if( bIsDpSp )
4538 {
4539 /* Fill in what we can of the Service Provider required information.
4540 * The rest was be done in DP_LoadSP
4541 */
4542 This->dp2->spData.lpAddress = lpConnection;
4543 This->dp2->spData.dwAddressSize = dwAddrSize;
4544 This->dp2->spData.lpGuid = &guidSP;
4545
4546 hr = DP_InitializeDPSP( This, hServiceProvider );
4547 }
4548 else
4549 {
4550 This->dp2->dplspData.lpAddress = lpConnection;
4551
4552 hr = DP_InitializeDPLSP( This, hServiceProvider );
4553 }
4554
4555 if( FAILED(hr) )
4556 {
4557 return hr;
4558 }
4559
4560 return DP_OK;
4561 }
4562
4563 static HRESULT WINAPI DirectPlay3AImpl_InitializeConnection
4564 ( LPDIRECTPLAY3A iface, LPVOID lpConnection, DWORD dwFlags )
4565 {
4566 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4567 return DP_IF_InitializeConnection( This, lpConnection, dwFlags, TRUE );
4568 }
4569
4570 static HRESULT WINAPI DirectPlay3WImpl_InitializeConnection
4571 ( LPDIRECTPLAY3 iface, LPVOID lpConnection, DWORD dwFlags )
4572 {
4573 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4574 return DP_IF_InitializeConnection( This, lpConnection, dwFlags, FALSE );
4575 }
4576
4577 static HRESULT WINAPI DirectPlay3AImpl_SecureOpen
4578 ( LPDIRECTPLAY3A iface, LPCDPSESSIONDESC2 lpsd, DWORD dwFlags,
4579 LPCDPSECURITYDESC lpSecurity, LPCDPCREDENTIALS lpCredentials )
4580 {
4581 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* Yes a dp 2 interface */
4582 return DP_SecureOpen( This, lpsd, dwFlags, lpSecurity, lpCredentials, TRUE );
4583 }
4584
4585 static HRESULT WINAPI DirectPlay3WImpl_SecureOpen
4586 ( LPDIRECTPLAY3 iface, LPCDPSESSIONDESC2 lpsd, DWORD dwFlags,
4587 LPCDPSECURITYDESC lpSecurity, LPCDPCREDENTIALS lpCredentials )
4588 {
4589 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* Yes a dp 2 interface */
4590 return DP_SecureOpen( This, lpsd, dwFlags, lpSecurity, lpCredentials, FALSE );
4591 }
4592
4593 static HRESULT WINAPI DirectPlay3AImpl_SendChatMessage
4594 ( LPDIRECTPLAY3A iface, DPID idFrom, DPID idTo, DWORD dwFlags, LPDPCHAT lpChatMessage )
4595 {
4596 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4597 FIXME("(%p)->(0x%08x,0x%08x,0x%08x,%p): stub\n", This, idFrom, idTo, dwFlags, lpChatMessage );
4598 return DP_OK;
4599 }
4600
4601 static HRESULT WINAPI DirectPlay3WImpl_SendChatMessage
4602 ( LPDIRECTPLAY3 iface, DPID idFrom, DPID idTo, DWORD dwFlags, LPDPCHAT lpChatMessage )
4603 {
4604 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4605 FIXME("(%p)->(0x%08x,0x%08x,0x%08x,%p): stub\n", This, idFrom, idTo, dwFlags, lpChatMessage );
4606 return DP_OK;
4607 }
4608
4609 static HRESULT WINAPI DirectPlay3AImpl_SetGroupConnectionSettings
4610 ( LPDIRECTPLAY3A iface, DWORD dwFlags, DPID idGroup, LPDPLCONNECTION lpConnection )
4611 {
4612 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4613 FIXME("(%p)->(0x%08x,0x%08x,%p): stub\n", This, dwFlags, idGroup, lpConnection );
4614 return DP_OK;
4615 }
4616
4617 static HRESULT WINAPI DirectPlay3WImpl_SetGroupConnectionSettings
4618 ( LPDIRECTPLAY3 iface, DWORD dwFlags, DPID idGroup, LPDPLCONNECTION lpConnection )
4619 {
4620 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4621 FIXME("(%p)->(0x%08x,0x%08x,%p): stub\n", This, dwFlags, idGroup, lpConnection );
4622 return DP_OK;
4623 }
4624
4625 static HRESULT WINAPI DirectPlay3AImpl_StartSession
4626 ( LPDIRECTPLAY3A iface, DWORD dwFlags, DPID idGroup )
4627 {
4628 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4629 FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, dwFlags, idGroup );
4630 return DP_OK;
4631 }
4632
4633 static HRESULT WINAPI DirectPlay3WImpl_StartSession
4634 ( LPDIRECTPLAY3 iface, DWORD dwFlags, DPID idGroup )
4635 {
4636 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4637 FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, dwFlags, idGroup );
4638 return DP_OK;
4639 }
4640
4641 static HRESULT WINAPI DirectPlay3AImpl_GetGroupFlags
4642 ( LPDIRECTPLAY3A iface, DPID idGroup, LPDWORD lpdwFlags )
4643 {
4644 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4645 FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpdwFlags );
4646 return DP_OK;
4647 }
4648
4649 static HRESULT WINAPI DirectPlay3WImpl_GetGroupFlags
4650 ( LPDIRECTPLAY3 iface, DPID idGroup, LPDWORD lpdwFlags )
4651 {
4652 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4653 FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpdwFlags );
4654 return DP_OK;
4655 }
4656
4657 static HRESULT DP_IF_GetGroupParent
4658 ( IDirectPlay3AImpl* This, DPID idGroup, LPDPID lpidGroup,
4659 BOOL bAnsi )
4660 {
4661 lpGroupData lpGData;
4662
4663 TRACE("(%p)->(0x%08x,%p,%u)\n", This, idGroup, lpidGroup, bAnsi );
4664
4665 if( ( lpGData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idGroup ) ) == NULL )
4666 {
4667 return DPERR_INVALIDGROUP;
4668 }
4669
4670 *lpidGroup = lpGData->dpid;
4671
4672 return DP_OK;
4673 }
4674
4675 static HRESULT WINAPI DirectPlay3AImpl_GetGroupParent
4676 ( LPDIRECTPLAY3A iface, DPID idGroup, LPDPID lpidGroup )
4677 {
4678 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4679 return DP_IF_GetGroupParent( This, idGroup, lpidGroup, TRUE );
4680 }
4681 static HRESULT WINAPI DirectPlay3WImpl_GetGroupParent
4682 ( LPDIRECTPLAY3 iface, DPID idGroup, LPDPID lpidGroup )
4683 {
4684 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4685 return DP_IF_GetGroupParent( This, idGroup, lpidGroup, FALSE );
4686 }
4687
4688 static HRESULT WINAPI DirectPlay3AImpl_GetPlayerAccount
4689 ( LPDIRECTPLAY3A iface, DPID idPlayer, DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize )
4690 {
4691 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4692 FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, idPlayer, dwFlags, lpData, lpdwDataSize );
4693 return DP_OK;
4694 }
4695
4696 static HRESULT WINAPI DirectPlay3WImpl_GetPlayerAccount
4697 ( LPDIRECTPLAY3 iface, DPID idPlayer, DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize )
4698 {
4699 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4700 FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, idPlayer, dwFlags, lpData, lpdwDataSize );
4701 return DP_OK;
4702 }
4703
4704 static HRESULT WINAPI DirectPlay3AImpl_GetPlayerFlags
4705 ( LPDIRECTPLAY3A iface, DPID idPlayer, LPDWORD lpdwFlags )
4706 {
4707 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4708 FIXME("(%p)->(0x%08x,%p): stub\n", This, idPlayer, lpdwFlags );
4709 return DP_OK;
4710 }
4711
4712 static HRESULT WINAPI DirectPlay3WImpl_GetPlayerFlags
4713 ( LPDIRECTPLAY3 iface, DPID idPlayer, LPDWORD lpdwFlags )
4714 {
4715 IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4716 FIXME("(%p)->(0x%08x,%p): stub\n", This, idPlayer, lpdwFlags );
4717 return DP_OK;
4718 }
4719
4720 static HRESULT WINAPI DirectPlay4AImpl_GetGroupOwner
4721 ( LPDIRECTPLAY4A iface, DPID idGroup, LPDPID lpidGroupOwner )
4722 {
4723 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4724 FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpidGroupOwner );
4725 return DP_OK;
4726 }
4727
4728 static HRESULT WINAPI DirectPlay4WImpl_GetGroupOwner
4729 ( LPDIRECTPLAY4 iface, DPID idGroup, LPDPID lpidGroupOwner )
4730 {
4731 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4732 FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpidGroupOwner );
4733 return DP_OK;
4734 }
4735
4736 static HRESULT WINAPI DirectPlay4AImpl_SetGroupOwner
4737 ( LPDIRECTPLAY4A iface, DPID idGroup , DPID idGroupOwner )
4738 {
4739 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4740 FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, idGroup, idGroupOwner );
4741 return DP_OK;
4742 }
4743
4744 static HRESULT WINAPI DirectPlay4WImpl_SetGroupOwner
4745 ( LPDIRECTPLAY4 iface, DPID idGroup , DPID idGroupOwner )
4746 {
4747 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4748 FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, idGroup, idGroupOwner );
4749 return DP_OK;
4750 }
4751
4752 static HRESULT DP_SendEx
4753 ( IDirectPlay2Impl* This, DPID idFrom, DPID idTo, DWORD dwFlags,
4754 LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4755 LPVOID lpContext, LPDWORD lpdwMsgID, BOOL bAnsi )
4756 {
4757 BOOL bValidDestination = FALSE;
4758
4759 FIXME( "(%p)->(0x%08x,0x%08x,0x%08x,%p,0x%08x,0x%08x,0x%08x,%p,%p,%u)"
4760 ": stub\n",
4761 This, idFrom, idTo, dwFlags, lpData, dwDataSize, dwPriority,
4762 dwTimeout, lpContext, lpdwMsgID, bAnsi );
4763
4764 if( This->dp2->connectionInitialized == NO_PROVIDER )
4765 {
4766 return DPERR_UNINITIALIZED;
4767 }
4768
4769 /* FIXME: Add parameter checking */
4770 /* FIXME: First call to this needs to acquire a message id which will be
4771 * used for multiple sends
4772 */
4773
4774 /* NOTE: Can't send messages to yourself - this will be trapped in receive */
4775
4776 /* Verify that the message is being sent from a valid local player. The
4777 * from player may be anonymous DPID_UNKNOWN
4778 */
4779 if( idFrom != DPID_UNKNOWN )
4780 {
4781 if( DP_FindPlayer( This, idFrom ) == NULL )
4782 {
4783 WARN( "INFO: Invalid from player 0x%08x\n", idFrom );
4784 return DPERR_INVALIDPLAYER;
4785 }
4786 }
4787
4788 /* Verify that the message is being sent to a valid player, group or to
4789 * everyone. If it's valid, send it to those players.
4790 */
4791 if( idTo == DPID_ALLPLAYERS )
4792 {
4793 bValidDestination = TRUE;
4794
4795 /* See if SP has the ability to multicast. If so, use it */
4796 if( This->dp2->spData.lpCB->SendToGroupEx )
4797 {
4798 FIXME( "Use group sendex to group 0\n" );
4799 }
4800 else if( This->dp2->spData.lpCB->SendToGroup ) /* obsolete interface */
4801 {
4802 FIXME( "Use obsolete group send to group 0\n" );
4803 }
4804 else /* No multicast, multiplicate */
4805 {
4806 /* Send to all players we know about */
4807 FIXME( "Send to all players using EnumPlayersInGroup\n" );
4808 }
4809 }
4810
4811 if( ( !bValidDestination ) &&
4812 ( DP_FindPlayer( This, idTo ) != NULL )
4813 )
4814 {
4815 bValidDestination = TRUE;
4816
4817 /* Have the service provider send this message */
4818 /* FIXME: Could optimize for local interface sends */
4819 return DP_SP_SendEx( This, dwFlags, lpData, dwDataSize, dwPriority,
4820 dwTimeout, lpContext, lpdwMsgID );
4821 }
4822
4823 if( ( !bValidDestination ) &&
4824 ( DP_FindAnyGroup( This, idTo ) != NULL )
4825 )
4826 {
4827 bValidDestination = TRUE;
4828
4829 /* See if SP has the ability to multicast. If so, use it */
4830 if( This->dp2->spData.lpCB->SendToGroupEx )
4831 {
4832 FIXME( "Use group sendex\n" );
4833 }
4834 else if( This->dp2->spData.lpCB->SendToGroup ) /* obsolete interface */
4835 {
4836 FIXME( "Use obsolete group send to group\n" );
4837 }
4838 else /* No multicast, multiplicate */
4839 {
4840 FIXME( "Send to all players using EnumPlayersInGroup\n" );
4841 }
4842
4843 #if 0
4844 if( bExpectReply )
4845 {
4846 DWORD dwWaitReturn;
4847
4848 This->dp2->hReplyEvent = CreateEventW( NULL, FALSE, FALSE, NULL );
4849
4850 dwWaitReturn = WaitForSingleObject( hReplyEvent, dwTimeout );
4851 if( dwWaitReturn != WAIT_OBJECT_0 )
4852 {
4853 ERR( "Wait failed 0x%08lx\n", dwWaitReturn );
4854 }
4855 }
4856 #endif
4857 }
4858
4859 if( !bValidDestination )
4860 {
4861 return DPERR_INVALIDPLAYER;
4862 }
4863 else
4864 {
4865 /* FIXME: Should return what the send returned */
4866 return DP_OK;
4867 }
4868 }
4869
4870
4871 static HRESULT WINAPI DirectPlay4AImpl_SendEx
4872 ( LPDIRECTPLAY4A iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4873 LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4874 LPVOID lpContext, LPDWORD lpdwMsgID )
4875 {
4876 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* yes downcast to 2 */
4877 return DP_SendEx( This, idFrom, idTo, dwFlags, lpData, dwDataSize,
4878 dwPriority, dwTimeout, lpContext, lpdwMsgID, TRUE );
4879 }
4880
4881 static HRESULT WINAPI DirectPlay4WImpl_SendEx
4882 ( LPDIRECTPLAY4 iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4883 LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4884 LPVOID lpContext, LPDWORD lpdwMsgID )
4885 {
4886 IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* yes downcast to 2 */
4887 return DP_SendEx( This, idFrom, idTo, dwFlags, lpData, dwDataSize,
4888 dwPriority, dwTimeout, lpContext, lpdwMsgID, FALSE );
4889 }
4890
4891 static HRESULT DP_SP_SendEx
4892 ( IDirectPlay2Impl* This, DWORD dwFlags,
4893 LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4894 LPVOID lpContext, LPDWORD lpdwMsgID )
4895 {
4896 LPDPMSG lpMElem;
4897
4898 FIXME( ": stub\n" );
4899
4900 /* FIXME: This queuing should only be for async messages */
4901
4902 lpMElem = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpMElem ) );
4903 lpMElem->msg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
4904
4905 CopyMemory( lpMElem->msg, lpData, dwDataSize );
4906
4907 /* FIXME: Need to queue based on priority */
4908 DPQ_INSERT( This->dp2->sendMsgs, lpMElem, msgs );
4909
4910 return DP_OK;
4911 }
4912
4913 static HRESULT DP_IF_GetMessageQueue
4914 ( IDirectPlay4Impl* This, DPID idFrom, DPID idTo, DWORD dwFlags,
4915 LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes, BOOL bAnsi )
4916 {
4917 HRESULT hr = DP_OK;
4918
4919 FIXME( "(%p)->(0x%08x,0x%08x,0x%08x,%p,%p,%u): semi stub\n",
4920 This, idFrom, idTo, dwFlags, lpdwNumMsgs, lpdwNumBytes, bAnsi );
4921
4922 /* FIXME: Do we need to do idFrom and idTo sanity checking here? */
4923 /* FIXME: What about sends which are not immediate? */
4924
4925 if( This->dp2->spData.lpCB->GetMessageQueue )
4926 {
4927 DPSP_GETMESSAGEQUEUEDATA data;
4928
4929 FIXME( "Calling SP GetMessageQueue - is it right?\n" );
4930
4931 /* FIXME: None of this is documented :( */
4932
4933 data.lpISP = This->dp2->spData.lpISP;
4934 data.dwFlags = dwFlags;
4935 data.idFrom = idFrom;
4936 data.idTo = idTo;
4937 data.lpdwNumMsgs = lpdwNumMsgs;
4938 data.lpdwNumBytes = lpdwNumBytes;
4939
4940 hr = (*This->dp2->spData.lpCB->GetMessageQueue)( &data );
4941 }
4942 else
4943 {
4944 FIXME( "No SP for GetMessageQueue - fake some data\n" );
4945 }
4946
4947 return hr;
4948 }
4949
4950 static HRESULT WINAPI DirectPlay4AImpl_GetMessageQueue
4951 ( LPDIRECTPLAY4A iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4952 LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes )
4953 {
4954 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4955 return DP_IF_GetMessageQueue( This, idFrom, idTo, dwFlags, lpdwNumMsgs,
4956 lpdwNumBytes, TRUE );
4957 }
4958
4959 static HRESULT WINAPI DirectPlay4WImpl_GetMessageQueue
4960 ( LPDIRECTPLAY4 iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4961 LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes )
4962 {
4963 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4964 return DP_IF_GetMessageQueue( This, idFrom, idTo, dwFlags, lpdwNumMsgs,
4965 lpdwNumBytes, FALSE );
4966 }
4967
4968 static HRESULT DP_IF_CancelMessage
4969 ( IDirectPlay4Impl* This, DWORD dwMsgID, DWORD dwFlags,
4970 DWORD dwMinPriority, DWORD dwMaxPriority, BOOL bAnsi )
4971 {
4972 HRESULT hr = DP_OK;
4973
4974 FIXME( "(%p)->(0x%08x,0x%08x,%u): semi stub\n",
4975 This, dwMsgID, dwFlags, bAnsi );
4976
4977 if( This->dp2->spData.lpCB->Cancel )
4978 {
4979 DPSP_CANCELDATA data;
4980
4981 TRACE( "Calling SP Cancel\n" );
4982
4983 /* FIXME: Undocumented callback */
4984
4985 data.lpISP = This->dp2->spData.lpISP;
4986 data.dwFlags = dwFlags;
4987 data.lprglpvSPMsgID = NULL;
4988 data.cSPMsgID = dwMsgID;
4989 data.dwMinPriority = dwMinPriority;
4990 data.dwMaxPriority = dwMaxPriority;
4991
4992 hr = (*This->dp2->spData.lpCB->Cancel)( &data );
4993 }
4994 else
4995 {
4996 FIXME( "SP doesn't implement Cancel\n" );
4997 }
4998
4999 return hr;
5000 }
5001
5002 static HRESULT WINAPI DirectPlay4AImpl_CancelMessage
5003 ( LPDIRECTPLAY4A iface, DWORD dwMsgID, DWORD dwFlags )
5004 {
5005 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
5006
5007 if( dwFlags != 0 )
5008 {
5009 return DPERR_INVALIDFLAGS;
5010 }
5011
5012 if( dwMsgID == 0 )
5013 {
5014 dwFlags |= DPCANCELSEND_ALL;
5015 }
5016
5017 return DP_IF_CancelMessage( This, dwMsgID, dwFlags, 0, 0, TRUE );
5018 }
5019
5020 static HRESULT WINAPI DirectPlay4WImpl_CancelMessage
5021 ( LPDIRECTPLAY4 iface, DWORD dwMsgID, DWORD dwFlags )
5022 {
5023 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
5024
5025 if( dwFlags != 0 )
5026 {
5027 return DPERR_INVALIDFLAGS;
5028 }
5029
5030 if( dwMsgID == 0 )
5031 {
5032 dwFlags |= DPCANCELSEND_ALL;
5033 }
5034
5035 return DP_IF_CancelMessage( This, dwMsgID, dwFlags, 0, 0, FALSE );
5036 }
5037
5038 static HRESULT WINAPI DirectPlay4AImpl_CancelPriority
5039 ( LPDIRECTPLAY4A iface, DWORD dwMinPriority, DWORD dwMaxPriority,
5040 DWORD dwFlags )
5041 {
5042 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
5043
5044 if( dwFlags != 0 )
5045 {
5046 return DPERR_INVALIDFLAGS;
5047 }
5048
5049 return DP_IF_CancelMessage( This, 0, DPCANCELSEND_PRIORITY, dwMinPriority,
5050 dwMaxPriority, TRUE );
5051 }
5052
5053 static HRESULT WINAPI DirectPlay4WImpl_CancelPriority
5054 ( LPDIRECTPLAY4 iface, DWORD dwMinPriority, DWORD dwMaxPriority,
5055 DWORD dwFlags )
5056 {
5057 IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
5058
5059 if( dwFlags != 0 )
5060 {
5061 return DPERR_INVALIDFLAGS;
5062 }
5063
5064 return DP_IF_CancelMessage( This, 0, DPCANCELSEND_PRIORITY, dwMinPriority,
5065 dwMaxPriority, FALSE );
5066 }
5067
5068 /* Note: Hack so we can reuse the old functions without compiler warnings */
5069 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5070 # define XCAST(fun) (typeof(directPlay2WVT.fun))
5071 #else
5072 # define XCAST(fun) (void*)
5073 #endif
5074
5075 static const IDirectPlay2Vtbl directPlay2WVT =
5076 {
5077 XCAST(QueryInterface)DP_QueryInterface,
5078 XCAST(AddRef)DP_AddRef,
5079 XCAST(Release)DP_Release,
5080
5081 DirectPlay2WImpl_AddPlayerToGroup,
5082 DirectPlay2WImpl_Close,
5083 DirectPlay2WImpl_CreateGroup,
5084 DirectPlay2WImpl_CreatePlayer,
5085 DirectPlay2WImpl_DeletePlayerFromGroup,
5086 DirectPlay2WImpl_DestroyGroup,
5087 DirectPlay2WImpl_DestroyPlayer,
5088 DirectPlay2WImpl_EnumGroupPlayers,
5089 DirectPlay2WImpl_EnumGroups,
5090 DirectPlay2WImpl_EnumPlayers,
5091 DirectPlay2WImpl_EnumSessions,
5092 DirectPlay2WImpl_GetCaps,
5093 DirectPlay2WImpl_GetGroupData,
5094 DirectPlay2WImpl_GetGroupName,
5095 DirectPlay2WImpl_GetMessageCount,
5096 DirectPlay2WImpl_GetPlayerAddress,
5097 DirectPlay2WImpl_GetPlayerCaps,
5098 DirectPlay2WImpl_GetPlayerData,
5099 DirectPlay2WImpl_GetPlayerName,
5100 DirectPlay2WImpl_GetSessionDesc,
5101 DirectPlay2WImpl_Initialize,
5102 DirectPlay2WImpl_Open,
5103 DirectPlay2WImpl_Receive,
5104 DirectPlay2WImpl_Send,
5105 DirectPlay2WImpl_SetGroupData,
5106 DirectPlay2WImpl_SetGroupName,
5107 DirectPlay2WImpl_SetPlayerData,
5108 DirectPlay2WImpl_SetPlayerName,
5109 DirectPlay2WImpl_SetSessionDesc
5110 };
5111 #undef XCAST
5112
5113 /* Note: Hack so we can reuse the old functions without compiler warnings */
5114 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5115 # define XCAST(fun) (typeof(directPlay2AVT.fun))
5116 #else
5117 # define XCAST(fun) (void*)
5118 #endif
5119
5120 static const IDirectPlay2Vtbl directPlay2AVT =
5121 {
5122 XCAST(QueryInterface)DP_QueryInterface,
5123 XCAST(AddRef)DP_AddRef,
5124 XCAST(Release)DP_Release,
5125
5126 DirectPlay2AImpl_AddPlayerToGroup,
5127 DirectPlay2AImpl_Close,
5128 DirectPlay2AImpl_CreateGroup,
5129 DirectPlay2AImpl_CreatePlayer,
5130 DirectPlay2AImpl_DeletePlayerFromGroup,
5131 DirectPlay2AImpl_DestroyGroup,
5132 DirectPlay2AImpl_DestroyPlayer,
5133 DirectPlay2AImpl_EnumGroupPlayers,
5134 DirectPlay2AImpl_EnumGroups,
5135 DirectPlay2AImpl_EnumPlayers,
5136 DirectPlay2AImpl_EnumSessions,
5137 DirectPlay2AImpl_GetCaps,
5138 DirectPlay2AImpl_GetGroupData,
5139 DirectPlay2AImpl_GetGroupName,
5140 DirectPlay2AImpl_GetMessageCount,
5141 DirectPlay2AImpl_GetPlayerAddress,
5142 DirectPlay2AImpl_GetPlayerCaps,
5143 DirectPlay2AImpl_GetPlayerData,
5144 DirectPlay2AImpl_GetPlayerName,
5145 DirectPlay2AImpl_GetSessionDesc,
5146 DirectPlay2AImpl_Initialize,
5147 DirectPlay2AImpl_Open,
5148 DirectPlay2AImpl_Receive,
5149 DirectPlay2AImpl_Send,
5150 DirectPlay2AImpl_SetGroupData,
5151 DirectPlay2AImpl_SetGroupName,
5152 DirectPlay2AImpl_SetPlayerData,
5153 DirectPlay2AImpl_SetPlayerName,
5154 DirectPlay2AImpl_SetSessionDesc
5155 };
5156 #undef XCAST
5157
5158
5159 /* Note: Hack so we can reuse the old functions without compiler warnings */
5160 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5161 # define XCAST(fun) (typeof(directPlay3AVT.fun))
5162 #else
5163 # define XCAST(fun) (void*)
5164 #endif
5165
5166 static const IDirectPlay3Vtbl directPlay3AVT =
5167 {
5168 XCAST(QueryInterface)DP_QueryInterface,
5169 XCAST(AddRef)DP_AddRef,
5170 XCAST(Release)DP_Release,
5171
5172 XCAST(AddPlayerToGroup)DirectPlay2AImpl_AddPlayerToGroup,
5173 XCAST(Close)DirectPlay2AImpl_Close,
5174 XCAST(CreateGroup)DirectPlay2AImpl_CreateGroup,
5175 XCAST(CreatePlayer)DirectPlay2AImpl_CreatePlayer,
5176 XCAST(DeletePlayerFromGroup)DirectPlay2AImpl_DeletePlayerFromGroup,
5177 XCAST(DestroyGroup)DirectPlay2AImpl_DestroyGroup,
5178 XCAST(DestroyPlayer)DirectPlay2AImpl_DestroyPlayer,
5179 XCAST(EnumGroupPlayers)DirectPlay2AImpl_EnumGroupPlayers,
5180 XCAST(EnumGroups)DirectPlay2AImpl_EnumGroups,
5181 XCAST(EnumPlayers)DirectPlay2AImpl_EnumPlayers,
5182 XCAST(EnumSessions)DirectPlay2AImpl_EnumSessions,
5183 XCAST(GetCaps)DirectPlay2AImpl_GetCaps,
5184 XCAST(GetGroupData)DirectPlay2AImpl_GetGroupData,
5185 XCAST(GetGroupName)DirectPlay2AImpl_GetGroupName,
5186 XCAST(GetMessageCount)DirectPlay2AImpl_GetMessageCount,
5187 XCAST(GetPlayerAddress)DirectPlay2AImpl_GetPlayerAddress,
5188 XCAST(GetPlayerCaps)DirectPlay2AImpl_GetPlayerCaps,
5189 XCAST(GetPlayerData)DirectPlay2AImpl_GetPlayerData,
5190 XCAST(GetPlayerName)DirectPlay2AImpl_GetPlayerName,
5191 XCAST(GetSessionDesc)DirectPlay2AImpl_GetSessionDesc,
5192 XCAST(Initialize)DirectPlay2AImpl_Initialize,
5193 XCAST(Open)DirectPlay2AImpl_Open,
5194 XCAST(Receive)DirectPlay2AImpl_Receive,
5195 XCAST(Send)DirectPlay2AImpl_Send,
5196 XCAST(SetGroupData)DirectPlay2AImpl_SetGroupData,
5197 XCAST(SetGroupName)DirectPlay2AImpl_SetGroupName,
5198 XCAST(SetPlayerData)DirectPlay2AImpl_SetPlayerData,
5199 XCAST(SetPlayerName)DirectPlay2AImpl_SetPlayerName,
5200 XCAST(SetSessionDesc)DirectPlay2AImpl_SetSessionDesc,
5201
5202 DirectPlay3AImpl_AddGroupToGroup,
5203 DirectPlay3AImpl_CreateGroupInGroup,
5204 DirectPlay3AImpl_DeleteGroupFromGroup,
5205 DirectPlay3AImpl_EnumConnections,
5206 DirectPlay3AImpl_EnumGroupsInGroup,
5207 DirectPlay3AImpl_GetGroupConnectionSettings,
5208 DirectPlay3AImpl_InitializeConnection,
5209 DirectPlay3AImpl_SecureOpen,
5210 DirectPlay3AImpl_SendChatMessage,
5211 DirectPlay3AImpl_SetGroupConnectionSettings,
5212 DirectPlay3AImpl_StartSession,
5213 DirectPlay3AImpl_GetGroupFlags,
5214 DirectPlay3AImpl_GetGroupParent,
5215 DirectPlay3AImpl_GetPlayerAccount,
5216 DirectPlay3AImpl_GetPlayerFlags
5217 };
5218 #undef XCAST
5219
5220 /* Note: Hack so we can reuse the old functions without compiler warnings */
5221 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5222 # define XCAST(fun) (typeof(directPlay3WVT.fun))
5223 #else
5224 # define XCAST(fun) (void*)
5225 #endif
5226 static const IDirectPlay3Vtbl directPlay3WVT =
5227 {
5228 XCAST(QueryInterface)DP_QueryInterface,
5229 XCAST(AddRef)DP_AddRef,
5230 XCAST(Release)DP_Release,
5231
5232 XCAST(AddPlayerToGroup)DirectPlay2WImpl_AddPlayerToGroup,
5233 XCAST(Close)DirectPlay2WImpl_Close,
5234 XCAST(CreateGroup)DirectPlay2WImpl_CreateGroup,
5235 XCAST(CreatePlayer)DirectPlay2WImpl_CreatePlayer,
5236 XCAST(DeletePlayerFromGroup)DirectPlay2WImpl_DeletePlayerFromGroup,
5237 XCAST(DestroyGroup)DirectPlay2WImpl_DestroyGroup,
5238 XCAST(DestroyPlayer)DirectPlay2WImpl_DestroyPlayer,
5239 XCAST(EnumGroupPlayers)DirectPlay2WImpl_EnumGroupPlayers,
5240 XCAST(EnumGroups)DirectPlay2WImpl_EnumGroups,
5241 XCAST(EnumPlayers)DirectPlay2WImpl_EnumPlayers,
5242 XCAST(EnumSessions)DirectPlay2WImpl_EnumSessions,
5243 XCAST(GetCaps)DirectPlay2WImpl_GetCaps,
5244 XCAST(GetGroupData)DirectPlay2WImpl_GetGroupData,
5245 XCAST(GetGroupName)DirectPlay2WImpl_GetGroupName,
5246 XCAST(GetMessageCount)DirectPlay2WImpl_GetMessageCount,
5247 XCAST(GetPlayerAddress)DirectPlay2WImpl_GetPlayerAddress,
5248 XCAST(GetPlayerCaps)DirectPlay2WImpl_GetPlayerCaps,
5249 XCAST(GetPlayerData)DirectPlay2WImpl_GetPlayerData,
5250 XCAST(GetPlayerName)DirectPlay2WImpl_GetPlayerName,
5251 XCAST(GetSessionDesc)DirectPlay2WImpl_GetSessionDesc,
5252 XCAST(Initialize)DirectPlay2WImpl_Initialize,
5253 XCAST(Open)DirectPlay2WImpl_Open,
5254 XCAST(Receive)DirectPlay2WImpl_Receive,
5255 XCAST(Send)DirectPlay2WImpl_Send,
5256 XCAST(SetGroupData)DirectPlay2WImpl_SetGroupData,
5257 XCAST(SetGroupName)DirectPlay2WImpl_SetGroupName,
5258 XCAST(SetPlayerData)DirectPlay2WImpl_SetPlayerData,
5259 XCAST(SetPlayerName)DirectPlay2WImpl_SetPlayerName,
5260 XCAST(SetSessionDesc)DirectPlay2WImpl_SetSessionDesc,
5261
5262 DirectPlay3WImpl_AddGroupToGroup,
5263 DirectPlay3WImpl_CreateGroupInGroup,
5264 DirectPlay3WImpl_DeleteGroupFromGroup,
5265 DirectPlay3WImpl_EnumConnections,
5266 DirectPlay3WImpl_EnumGroupsInGroup,
5267 DirectPlay3WImpl_GetGroupConnectionSettings,
5268 DirectPlay3WImpl_InitializeConnection,
5269 DirectPlay3WImpl_SecureOpen,
5270 DirectPlay3WImpl_SendChatMessage,
5271 DirectPlay3WImpl_SetGroupConnectionSettings,
5272 DirectPlay3WImpl_StartSession,
5273 DirectPlay3WImpl_GetGroupFlags,
5274 DirectPlay3WImpl_GetGroupParent,
5275 DirectPlay3WImpl_GetPlayerAccount,
5276 DirectPlay3WImpl_GetPlayerFlags
5277 };
5278 #undef XCAST
5279
5280 /* Note: Hack so we can reuse the old functions without compiler warnings */
5281 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5282 # define XCAST(fun) (typeof(directPlay4WVT.fun))
5283 #else
5284 # define XCAST(fun) (void*)
5285 #endif
5286 static const IDirectPlay4Vtbl directPlay4WVT =
5287 {
5288 XCAST(QueryInterface)DP_QueryInterface,
5289 XCAST(AddRef)DP_AddRef,
5290 XCAST(Release)DP_Release,
5291
5292 XCAST(AddPlayerToGroup)DirectPlay2WImpl_AddPlayerToGroup,
5293 XCAST(Close)DirectPlay2WImpl_Close,
5294 XCAST(CreateGroup)DirectPlay2WImpl_CreateGroup,
5295 XCAST(CreatePlayer)DirectPlay2WImpl_CreatePlayer,
5296 XCAST(DeletePlayerFromGroup)DirectPlay2WImpl_DeletePlayerFromGroup,
5297 XCAST(DestroyGroup)DirectPlay2WImpl_DestroyGroup,
5298 XCAST(DestroyPlayer)DirectPlay2WImpl_DestroyPlayer,
5299 XCAST(EnumGroupPlayers)DirectPlay2WImpl_EnumGroupPlayers,
5300 XCAST(EnumGroups)DirectPlay2WImpl_EnumGroups,
5301 XCAST(EnumPlayers)DirectPlay2WImpl_EnumPlayers,
5302 XCAST(EnumSessions)DirectPlay2WImpl_EnumSessions,
5303 XCAST(GetCaps)DirectPlay2WImpl_GetCaps,
5304 XCAST(GetGroupData)DirectPlay2WImpl_GetGroupData,
5305 XCAST(GetGroupName)DirectPlay2WImpl_GetGroupName,
5306 XCAST(GetMessageCount)DirectPlay2WImpl_GetMessageCount,
5307 XCAST(GetPlayerAddress)DirectPlay2WImpl_GetPlayerAddress,
5308 XCAST(GetPlayerCaps)DirectPlay2WImpl_GetPlayerCaps,
5309 XCAST(GetPlayerData)DirectPlay2WImpl_GetPlayerData,
5310 XCAST(GetPlayerName)DirectPlay2WImpl_GetPlayerName,
5311 XCAST(GetSessionDesc)DirectPlay2WImpl_GetSessionDesc,
5312 XCAST(Initialize)DirectPlay2WImpl_Initialize,
5313 XCAST(Open)DirectPlay2WImpl_Open,
5314 XCAST(Receive)DirectPlay2WImpl_Receive,
5315 XCAST(Send)DirectPlay2WImpl_Send,
5316 XCAST(SetGroupData)DirectPlay2WImpl_SetGroupData,
5317 XCAST(SetGroupName)DirectPlay2WImpl_SetGroupName,
5318 XCAST(SetPlayerData)DirectPlay2WImpl_SetPlayerData,
5319 XCAST(SetPlayerName)DirectPlay2WImpl_SetPlayerName,
5320 XCAST(SetSessionDesc)DirectPlay2WImpl_SetSessionDesc,
5321
5322 XCAST(AddGroupToGroup)DirectPlay3WImpl_AddGroupToGroup,
5323 XCAST(CreateGroupInGroup)DirectPlay3WImpl_CreateGroupInGroup,
5324 XCAST(DeleteGroupFromGroup)DirectPlay3WImpl_DeleteGroupFromGroup,
5325 XCAST(EnumConnections)DirectPlay3WImpl_EnumConnections,
5326 XCAST(EnumGroupsInGroup)DirectPlay3WImpl_EnumGroupsInGroup,
5327 XCAST(GetGroupConnectionSettings)DirectPlay3WImpl_GetGroupConnectionSettings,
5328 XCAST(InitializeConnection)DirectPlay3WImpl_InitializeConnection,
5329 XCAST(SecureOpen)DirectPlay3WImpl_SecureOpen,
5330 XCAST(SendChatMessage)DirectPlay3WImpl_SendChatMessage,
5331 XCAST(SetGroupConnectionSettings)DirectPlay3WImpl_SetGroupConnectionSettings,
5332 XCAST(StartSession)DirectPlay3WImpl_StartSession,
5333 XCAST(GetGroupFlags)DirectPlay3WImpl_GetGroupFlags,
5334 XCAST(GetGroupParent)DirectPlay3WImpl_GetGroupParent,
5335 XCAST(GetPlayerAccount)DirectPlay3WImpl_GetPlayerAccount,
5336 XCAST(GetPlayerFlags)DirectPlay3WImpl_GetPlayerFlags,
5337
5338 DirectPlay4WImpl_GetGroupOwner,
5339 DirectPlay4WImpl_SetGroupOwner,
5340 DirectPlay4WImpl_SendEx,
5341 DirectPlay4WImpl_GetMessageQueue,
5342 DirectPlay4WImpl_CancelMessage,
5343 DirectPlay4WImpl_CancelPriority
5344 };
5345 #undef XCAST
5346
5347
5348 /* Note: Hack so we can reuse the old functions without compiler warnings */
5349 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5350 # define XCAST(fun) (typeof(directPlay4AVT.fun))
5351 #else
5352 # define XCAST(fun) (void*)
5353 #endif
5354 static const IDirectPlay4Vtbl directPlay4AVT =
5355 {
5356 XCAST(QueryInterface)DP_QueryInterface,
5357 XCAST(AddRef)DP_AddRef,
5358 XCAST(Release)DP_Release,
5359
5360 XCAST(AddPlayerToGroup)DirectPlay2AImpl_AddPlayerToGroup,
5361 XCAST(Close)DirectPlay2AImpl_Close,
5362 XCAST(CreateGroup)DirectPlay2AImpl_CreateGroup,
5363 XCAST(CreatePlayer)DirectPlay2AImpl_CreatePlayer,
5364 XCAST(DeletePlayerFromGroup)DirectPlay2AImpl_DeletePlayerFromGroup,
5365 XCAST(DestroyGroup)DirectPlay2AImpl_DestroyGroup,
5366 XCAST(DestroyPlayer)DirectPlay2AImpl_DestroyPlayer,
5367 XCAST(EnumGroupPlayers)DirectPlay2AImpl_EnumGroupPlayers,
5368 XCAST(EnumGroups)DirectPlay2AImpl_EnumGroups,
5369 XCAST(EnumPlayers)DirectPlay2AImpl_EnumPlayers,
5370 XCAST(EnumSessions)DirectPlay2AImpl_EnumSessions,
5371 XCAST(GetCaps)DirectPlay2AImpl_GetCaps,
5372 XCAST(GetGroupData)DirectPlay2AImpl_GetGroupData,
5373 XCAST(GetGroupName)DirectPlay2AImpl_GetGroupName,
5374 XCAST(GetMessageCount)DirectPlay2AImpl_GetMessageCount,
5375 XCAST(GetPlayerAddress)DirectPlay2AImpl_GetPlayerAddress,
5376 XCAST(GetPlayerCaps)DirectPlay2AImpl_GetPlayerCaps,
5377 XCAST(GetPlayerData)DirectPlay2AImpl_GetPlayerData,
5378 XCAST(GetPlayerName)DirectPlay2AImpl_GetPlayerName,
5379 XCAST(GetSessionDesc)DirectPlay2AImpl_GetSessionDesc,
5380 XCAST(Initialize)DirectPlay2AImpl_Initialize,
5381 XCAST(Open)DirectPlay2AImpl_Open,
5382 XCAST(Receive)DirectPlay2AImpl_Receive,
5383 XCAST(Send)DirectPlay2AImpl_Send,
5384 XCAST(SetGroupData)DirectPlay2AImpl_SetGroupData,
5385 XCAST(SetGroupName)DirectPlay2AImpl_SetGroupName,
5386 XCAST(SetPlayerData)DirectPlay2AImpl_SetPlayerData,
5387 XCAST(SetPlayerName)DirectPlay2AImpl_SetPlayerName,
5388 XCAST(SetSessionDesc)DirectPlay2AImpl_SetSessionDesc,
5389
5390 XCAST(AddGroupToGroup)DirectPlay3AImpl_AddGroupToGroup,
5391 XCAST(CreateGroupInGroup)DirectPlay3AImpl_CreateGroupInGroup,
5392 XCAST(DeleteGroupFromGroup)DirectPlay3AImpl_DeleteGroupFromGroup,
5393 XCAST(EnumConnections)DirectPlay3AImpl_EnumConnections,
5394 XCAST(EnumGroupsInGroup)DirectPlay3AImpl_EnumGroupsInGroup,
5395 XCAST(GetGroupConnectionSettings)DirectPlay3AImpl_GetGroupConnectionSettings,
5396 XCAST(InitializeConnection)DirectPlay3AImpl_InitializeConnection,
5397 XCAST(SecureOpen)DirectPlay3AImpl_SecureOpen,
5398 XCAST(SendChatMessage)DirectPlay3AImpl_SendChatMessage,
5399 XCAST(SetGroupConnectionSettings)DirectPlay3AImpl_SetGroupConnectionSettings,
5400 XCAST(StartSession)DirectPlay3AImpl_StartSession,
5401 XCAST(GetGroupFlags)DirectPlay3AImpl_GetGroupFlags,
5402 XCAST(GetGroupParent)DirectPlay3AImpl_GetGroupParent,
5403 XCAST(GetPlayerAccount)DirectPlay3AImpl_GetPlayerAccount,
5404 XCAST(GetPlayerFlags)DirectPlay3AImpl_GetPlayerFlags,
5405
5406 DirectPlay4AImpl_GetGroupOwner,
5407 DirectPlay4AImpl_SetGroupOwner,
5408 DirectPlay4AImpl_SendEx,
5409 DirectPlay4AImpl_GetMessageQueue,
5410 DirectPlay4AImpl_CancelMessage,
5411 DirectPlay4AImpl_CancelPriority
5412 };
5413 #undef XCAST
5414
5415 HRESULT DP_GetSPPlayerData( IDirectPlay2Impl* lpDP,
5416 DPID idPlayer,
5417 LPVOID* lplpData )
5418 {
5419 lpPlayerList lpPlayer = DP_FindPlayer( lpDP, idPlayer );
5420
5421 if( lpPlayer == NULL )
5422 {
5423 return DPERR_INVALIDPLAYER;
5424 }
5425
5426 *lplpData = lpPlayer->lpPData->lpSPPlayerData;
5427
5428 return DP_OK;
5429 }
5430
5431 HRESULT DP_SetSPPlayerData( IDirectPlay2Impl* lpDP,
5432 DPID idPlayer,
5433 LPVOID lpData )
5434 {
5435 lpPlayerList lpPlayer = DP_FindPlayer( lpDP, idPlayer );
5436
5437 if( lpPlayer == NULL )
5438 {
5439 return DPERR_INVALIDPLAYER;
5440 }
5441
5442 lpPlayer->lpPData->lpSPPlayerData = lpData;
5443
5444 return DP_OK;
5445 }
5446
5447 /***************************************************************************
5448 * DirectPlayEnumerateAW
5449 *
5450 * The pointer to the structure lpContext will be filled with the
5451 * appropriate data for each service offered by the OS. These services are
5452 * not necessarily available on this particular machine but are defined
5453 * as simple service providers under the "Service Providers" registry key.
5454 * This structure is then passed to lpEnumCallback for each of the different
5455 * services.
5456 *
5457 * This API is useful only for applications written using DirectX3 or
5458 * worse. It is superseded by IDirectPlay3::EnumConnections which also
5459 * gives information on the actual connections.
5460 *
5461 * defn of a service provider:
5462 * A dynamic-link library used by DirectPlay to communicate over a network.
5463 * The service provider contains all the network-specific code required
5464 * to send and receive messages. Online services and network operators can
5465 * supply service providers to use specialized hardware, protocols, communications
5466 * media, and network resources.
5467 *
5468 */
5469 static HRESULT DirectPlayEnumerateAW(LPDPENUMDPCALLBACKA lpEnumCallbackA,
5470 LPDPENUMDPCALLBACKW lpEnumCallbackW,
5471 LPVOID lpContext)
5472 {
5473 HKEY hkResult;
5474 static const WCHAR searchSubKey[] = {
5475 'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\',
5476 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\',
5477 'D', 'i', 'r', 'e', 'c', 't', 'P', 'l', 'a', 'y', '\\',
5478 'S', 'e', 'r', 'v', 'i', 'c', 'e', ' ', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 's', 0 };
5479 static const WCHAR guidKey[] = { 'G', 'u', 'i', 'd', 0 };
5480 static const WCHAR descW[] = { 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 'W', 0 };
5481
5482 DWORD dwIndex;
5483 FILETIME filetime;
5484
5485 char *descriptionA = NULL;
5486 DWORD max_sizeOfDescriptionA = 0;
5487 WCHAR *descriptionW = NULL;
5488 DWORD max_sizeOfDescriptionW = 0;
5489
5490 if (!lpEnumCallbackA && !lpEnumCallbackW)
5491 {
5492 return DPERR_INVALIDPARAMS;
5493 }
5494
5495 /* Need to loop over the service providers in the registry */
5496 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, searchSubKey,
5497 0, KEY_READ, &hkResult) != ERROR_SUCCESS)
5498 {
5499 /* Hmmm. Does this mean that there are no service providers? */
5500 ERR(": no service provider key in the registry - check your Wine installation !!!\n");
5501 return DPERR_GENERIC;
5502 }
5503
5504 /* Traverse all the service providers we have available */
5505 dwIndex = 0;
5506 while (1)
5507 {
5508 WCHAR subKeyName[255]; /* 255 is the maximum key size according to MSDN */
5509 DWORD sizeOfSubKeyName = sizeof(subKeyName) / sizeof(WCHAR);
5510 HKEY hkServiceProvider;
5511 GUID serviceProviderGUID;
5512 WCHAR guidKeyContent[(2 * 16) + 1 + 6 /* This corresponds to '{....-..-..-..-......}' */ ];
5513 DWORD sizeOfGuidKeyContent = sizeof(guidKeyContent);
5514 LONG ret_value;
5515
5516 ret_value = RegEnumKeyExW(hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
5517 NULL, NULL, NULL, &filetime);
5518 if (ret_value == ERROR_NO_MORE_ITEMS)
5519 break;
5520 else if (ret_value != ERROR_SUCCESS)
5521 {
5522 ERR(": could not enumerate on service provider key.\n");
5523 return DPERR_EXCEPTION;
5524 }
5525 TRACE(" this time through sub-key %s.\n", debugstr_w(subKeyName));
5526
5527 /* Open the key for this service provider */
5528 if (RegOpenKeyExW(hkResult, subKeyName, 0, KEY_READ, &hkServiceProvider) != ERROR_SUCCESS)
5529 {
5530 ERR(": could not open registry key for service provider %s.\n", debugstr_w(subKeyName));
5531 continue;
5532 }
5533
5534 /* Get the GUID from the registry */
5535 if (RegQueryValueExW(hkServiceProvider, guidKey,
5536 NULL, NULL, (LPBYTE) guidKeyContent, &sizeOfGuidKeyContent) != ERROR_SUCCESS)
5537 {
5538 ERR(": missing GUID registry data member for service provider %s.\n", debugstr_w(subKeyName));
5539 continue;
5540 }
5541 if (sizeOfGuidKeyContent != sizeof(guidKeyContent))
5542 {
5543 ERR(": invalid format for the GUID registry data member for service provider %s (%s).\n", debugstr_w(subKeyName), debugstr_w(guidKeyContent));
5544 continue;
5545 }
5546 CLSIDFromString(guidKeyContent, &serviceProviderGUID );
5547
5548 /* The enumeration will return FALSE if we are not to continue.
5549 *
5550 * Note: on my windows box, major / minor version is 6 / 0 for all service providers
5551 * and have no relation to any of the two dwReserved1 and dwReserved2 keys.
5552 * I think that it simply means that they are in-line with DirectX 6.0
5553 */
5554 if (lpEnumCallbackA)
5555 {
5556 DWORD sizeOfDescription = 0;
5557
5558 /* Note that this is the A case of this function, so use the A variant to get the description string */
5559 if (RegQueryValueExA(hkServiceProvider, "DescriptionA",
5560 NULL, NULL, NULL, &sizeOfDescription) != ERROR_SUCCESS)
5561 {
5562 ERR(": missing 'DescriptionA' registry data member for service provider %s.\n", debugstr_w(subKeyName));
5563 continue;
5564 }
5565 if (sizeOfDescription > max_sizeOfDescriptionA)
5566 {
5567 HeapFree(GetProcessHeap(), 0, descriptionA);
5568 max_sizeOfDescriptionA = sizeOfDescription;
5569 }
5570 descriptionA = HeapAlloc(GetProcessHeap(), 0, sizeOfDescription);
5571 RegQueryValueExA(hkServiceProvider, "DescriptionA",
5572 NULL, NULL, (LPBYTE) descriptionA, &sizeOfDescription);
5573
5574 if (!lpEnumCallbackA(&serviceProviderGUID, descriptionA, 6, 0, lpContext))
5575 goto end;
5576 }
5577 else
5578 {
5579 DWORD sizeOfDescription = 0;
5580
5581 if (RegQueryValueExW(hkServiceProvider, descW,
5582 NULL, NULL, NULL, &sizeOfDescription) != ERROR_SUCCESS)
5583 {
5584 ERR(": missing 'DescriptionW' registry data member for service provider %s.\n", debugstr_w(subKeyName));
5585 continue;
5586 }
5587 if (sizeOfDescription > max_sizeOfDescriptionW)
5588 {
5589 HeapFree(GetProcessHeap(), 0, descriptionW);
5590 max_sizeOfDescriptionW = sizeOfDescription;
5591 }
5592 descriptionW = HeapAlloc(GetProcessHeap(), 0, sizeOfDescription);
5593 RegQueryValueExW(hkServiceProvider, descW,
5594 NULL, NULL, (LPBYTE) descriptionW, &sizeOfDescription);
5595
5596 if (!lpEnumCallbackW(&serviceProviderGUID, descriptionW, 6, 0, lpContext))
5597 goto end;
5598 }
5599
5600 dwIndex++;
5601 }
5602
5603 end:
5604 HeapFree(GetProcessHeap(), 0, descriptionA);
5605 HeapFree(GetProcessHeap(), 0, descriptionW);
5606
5607 return DP_OK;
5608 }
5609
5610 /***************************************************************************
5611 * DirectPlayEnumerate [DPLAYX.9]
5612 * DirectPlayEnumerateA [DPLAYX.2]
5613 */
5614 HRESULT WINAPI DirectPlayEnumerateA(LPDPENUMDPCALLBACKA lpEnumCallback, LPVOID lpContext )
5615 {
5616 TRACE("(%p,%p)\n", lpEnumCallback, lpContext);
5617
5618 return DirectPlayEnumerateAW(lpEnumCallback, NULL, lpContext);
5619 }
5620
5621 /***************************************************************************
5622 * DirectPlayEnumerateW [DPLAYX.3]
5623 */
5624 HRESULT WINAPI DirectPlayEnumerateW(LPDPENUMDPCALLBACKW lpEnumCallback, LPVOID lpContext )
5625 {
5626 TRACE("(%p,%p)\n", lpEnumCallback, lpContext);
5627
5628 return DirectPlayEnumerateAW(NULL, lpEnumCallback, lpContext);
5629 }
5630
5631 typedef struct tagCreateEnum
5632 {
5633 LPVOID lpConn;
5634 LPCGUID lpGuid;
5635 } CreateEnumData, *lpCreateEnumData;
5636
5637 /* Find and copy the matching connection for the SP guid */
5638 static BOOL CALLBACK cbDPCreateEnumConnections(
5639 LPCGUID lpguidSP,
5640 LPVOID lpConnection,
5641 DWORD dwConnectionSize,
5642 LPCDPNAME lpName,
5643 DWORD dwFlags,
5644 LPVOID lpContext)
5645 {
5646 lpCreateEnumData lpData = (lpCreateEnumData)lpContext;
5647
5648 if( IsEqualGUID( lpguidSP, lpData->lpGuid ) )
5649 {
5650 TRACE( "Found SP entry with guid %s\n", debugstr_guid(lpData->lpGuid) );
5651
5652 lpData->lpConn = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
5653 dwConnectionSize );
5654 CopyMemory( lpData->lpConn, lpConnection, dwConnectionSize );
5655
5656 /* Found the record that we were looking for */
5657 return FALSE;
5658 }
5659
5660 /* Haven't found what were looking for yet */
5661 return TRUE;
5662 }
5663
5664
5665 /***************************************************************************
5666 * DirectPlayCreate [DPLAYX.1]
5667 *
5668 */
5669 HRESULT WINAPI DirectPlayCreate
5670 ( LPGUID lpGUID, LPDIRECTPLAY *lplpDP, IUnknown *pUnk )
5671 {
5672 HRESULT hr;
5673 LPDIRECTPLAY3A lpDP3A;
5674 CreateEnumData cbData;
5675
5676 TRACE( "lpGUID=%s lplpDP=%p pUnk=%p\n", debugstr_guid(lpGUID), lplpDP, pUnk );
5677
5678 if( pUnk != NULL )
5679 {
5680 return CLASS_E_NOAGGREGATION;
5681 }
5682
5683 if( (lplpDP == NULL) || (lpGUID == NULL) )
5684 {
5685 return DPERR_INVALIDPARAMS;
5686 }
5687
5688
5689 /* Create an IDirectPlay object. We don't support that so we'll cheat and
5690 give them an IDirectPlay2A object and hope that doesn't cause problems */
5691 if( DP_CreateInterface( &IID_IDirectPlay2A, (LPVOID*)lplpDP ) != DP_OK )
5692 {
5693 return DPERR_UNAVAILABLE;
5694 }
5695
5696 if( IsEqualGUID( &GUID_NULL, lpGUID ) )
5697 {
5698 /* The GUID_NULL means don't bind a service provider. Just return the
5699 interface as is */
5700 return DP_OK;
5701 }
5702
5703 /* Bind the desired service provider since lpGUID is non NULL */
5704 TRACE( "Service Provider binding for %s\n", debugstr_guid(lpGUID) );
5705
5706 /* We're going to use a DP3 interface */
5707 hr = IDirectPlayX_QueryInterface( *lplpDP, &IID_IDirectPlay3A,
5708 (LPVOID*)&lpDP3A );
5709 if( FAILED(hr) )
5710 {
5711 ERR( "Failed to get DP3 interface: %s\n", DPLAYX_HresultToString(hr) );
5712 return hr;
5713 }
5714
5715 cbData.lpConn = NULL;
5716 cbData.lpGuid = lpGUID;
5717
5718 /* We were given a service provider, find info about it... */
5719 hr = IDirectPlayX_EnumConnections( lpDP3A, NULL, cbDPCreateEnumConnections,
5720 &cbData, DPCONNECTION_DIRECTPLAY );
5721 if( ( FAILED(hr) ) ||
5722 ( cbData.lpConn == NULL )
5723 )
5724 {
5725 ERR( "Failed to get Enum for SP: %s\n", DPLAYX_HresultToString(hr) );
5726 IDirectPlayX_Release( lpDP3A );
5727 return DPERR_UNAVAILABLE;
5728 }
5729
5730 /* Initialize the service provider */
5731 hr = IDirectPlayX_InitializeConnection( lpDP3A, cbData.lpConn, 0 );
5732 if( FAILED(hr) )
5733 {
5734 ERR( "Failed to Initialize SP: %s\n", DPLAYX_HresultToString(hr) );
5735 HeapFree( GetProcessHeap(), 0, cbData.lpConn );
5736 IDirectPlayX_Release( lpDP3A );
5737 return hr;
5738 }
5739
5740 /* Release our version of the interface now that we're done with it */
5741 IDirectPlayX_Release( lpDP3A );
5742 HeapFree( GetProcessHeap(), 0, cbData.lpConn );
5743
5744 return DP_OK;
5745 }
DirectPlay implementation for GSoC