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