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