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