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