dlls/dplayx/dplay.c

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