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