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