dlls/dplayx/dplay.c

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