git.oblomov.eu Git - wine/blob - dlls/dplayx/dplay.c

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