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