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