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