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

   1 /* Direct Play 2,3,4 Implementation
   2  *
   3  * Copyright 1998,1999,2000,2001 - Peter Hunnisett
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 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                              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      * consequence 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         lpData->requestGuid = lpsd->guidApplication;
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 contiguous 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( 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( 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( 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( 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 lpGData;
3400   lpGroupList lpNewGList;
3401
3402   TRACE( "(%p)->(0x%08x,0x%08x)\n", This, idParentGroup, idGroup );
3403
3404   if( DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idParentGroup ) == NULL )
3405   {
3406     return DPERR_INVALIDGROUP;
3407   }
3408
3409   if( ( lpGData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idGroup ) ) == NULL )
3410   {
3411     return DPERR_INVALIDGROUP;
3412   }
3413
3414   /* Create a player list (ie "shortcut" ) */
3415   lpNewGList = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpNewGList ) );
3416   if( lpNewGList == NULL )
3417   {
3418     return DPERR_CANTADDPLAYER;
3419   }
3420
3421   /* Add the shortcut */
3422   lpGData->uRef++;
3423   lpNewGList->lpGData = lpGData;
3424
3425   /* Add the player to the list of players for this group */
3426   DPQ_INSERT( lpGData->groups, lpNewGList, groups );
3427
3428   /* Send a ADDGROUPTOGROUP message */
3429   FIXME( "Not sending message\n" );
3430
3431   return DP_OK;
3432 }
3433
3434 static HRESULT WINAPI DirectPlay3AImpl_AddGroupToGroup
3435           ( LPDIRECTPLAY3A iface, DPID idParentGroup, DPID idGroup )
3436 {
3437   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3438   return DP_IF_AddGroupToGroup( This, idParentGroup, idGroup );
3439 }
3440
3441 static HRESULT WINAPI DirectPlay3WImpl_AddGroupToGroup
3442           ( LPDIRECTPLAY3 iface, DPID idParentGroup, DPID idGroup )
3443 {
3444   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3445   return DP_IF_AddGroupToGroup( This, idParentGroup, idGroup );
3446 }
3447
3448 static HRESULT WINAPI DP_IF_CreateGroupInGroup
3449           ( IDirectPlay3Impl* This, LPVOID lpMsgHdr, DPID idParentGroup,
3450             LPDPID lpidGroup, LPDPNAME lpGroupName, LPVOID lpData,
3451             DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi )
3452 {
3453   lpGroupData lpGParentData;
3454   lpGroupList lpGList;
3455   lpGroupData lpGData;
3456
3457   TRACE( "(%p)->(0x%08x,%p,%p,%p,0x%08x,0x%08x,%u)\n",
3458          This, idParentGroup, lpidGroup, lpGroupName, lpData,
3459          dwDataSize, dwFlags, bAnsi );
3460
3461   /* Verify that the specified parent is valid */
3462   if( ( lpGParentData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This,
3463                                          idParentGroup ) ) == NULL
3464     )
3465   {
3466     return DPERR_INVALIDGROUP;
3467   }
3468
3469   lpGData = DP_CreateGroup( (IDirectPlay2AImpl*)This, lpidGroup, lpGroupName,
3470                             dwFlags, idParentGroup, bAnsi );
3471
3472   if( lpGData == NULL )
3473   {
3474     return DPERR_CANTADDPLAYER; /* yes player not group */
3475   }
3476
3477   /* Something else is referencing this data */
3478   lpGData->uRef++;
3479
3480   DP_SetGroupData( lpGData, DPSET_REMOTE, lpData, dwDataSize );
3481
3482   /* The list has now been inserted into the interface group list. We now
3483      need to put a "shortcut" to this group in the parent group */
3484   lpGList = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpGList ) );
3485   if( lpGList == NULL )
3486   {
3487     FIXME( "Memory leak\n" );
3488     return DPERR_CANTADDPLAYER; /* yes player not group */
3489   }
3490
3491   lpGList->lpGData = lpGData;
3492
3493   DPQ_INSERT( lpGParentData->groups, lpGList, groups );
3494
3495   /* Let the SP know that we've created this group */
3496   if( This->dp2->spData.lpCB->CreateGroup )
3497   {
3498     DPSP_CREATEGROUPDATA data;
3499
3500     TRACE( "Calling SP CreateGroup\n" );
3501
3502     data.idGroup           = *lpidGroup;
3503     data.dwFlags           = dwFlags;
3504     data.lpSPMessageHeader = lpMsgHdr;
3505     data.lpISP             = This->dp2->spData.lpISP;
3506
3507     (*This->dp2->spData.lpCB->CreateGroup)( &data );
3508   }
3509
3510   /* Inform all other peers of the creation of a new group. If there are
3511    * no peers keep this quiet.
3512    */
3513   if( This->dp2->lpSessionDesc &&
3514       ( This->dp2->lpSessionDesc->dwFlags & DPSESSION_MULTICASTSERVER ) )
3515   {
3516     DPMSG_CREATEPLAYERORGROUP msg;
3517
3518     msg.dwType = DPSYS_CREATEPLAYERORGROUP;
3519     msg.dwPlayerType = DPPLAYERTYPE_GROUP;
3520     msg.dpId = *lpidGroup;
3521     msg.dwCurrentPlayers = idParentGroup; /* FIXME: Incorrect? */
3522     msg.lpData = lpData;
3523     msg.dwDataSize = dwDataSize;
3524     msg.dpnName = *lpGroupName;
3525
3526     /* FIXME: Correct to just use send effectively? */
3527     /* FIXME: Should size include data w/ message or just message "header" */
3528     /* FIXME: Check return code */
3529     DP_SendEx( (IDirectPlay2Impl*)This,
3530                DPID_SERVERPLAYER, DPID_ALLPLAYERS, 0, &msg, sizeof( msg ),
3531                0, 0, NULL, NULL, bAnsi );
3532   }
3533
3534   return DP_OK;
3535 }
3536
3537 static HRESULT WINAPI DirectPlay3AImpl_CreateGroupInGroup
3538           ( LPDIRECTPLAY3A iface, DPID idParentGroup, LPDPID lpidGroup,
3539             LPDPNAME lpGroupName, LPVOID lpData, DWORD dwDataSize,
3540             DWORD dwFlags )
3541 {
3542   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3543
3544   *lpidGroup = DPID_UNKNOWN;
3545
3546   return DP_IF_CreateGroupInGroup( This, NULL, idParentGroup, lpidGroup,
3547                                    lpGroupName, lpData, dwDataSize, dwFlags,
3548                                    TRUE );
3549 }
3550
3551 static HRESULT WINAPI DirectPlay3WImpl_CreateGroupInGroup
3552           ( LPDIRECTPLAY3 iface, DPID idParentGroup, LPDPID lpidGroup,
3553             LPDPNAME lpGroupName, LPVOID lpData, DWORD dwDataSize,
3554             DWORD dwFlags )
3555 {
3556   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3557
3558   *lpidGroup = DPID_UNKNOWN;
3559
3560   return DP_IF_CreateGroupInGroup( This, NULL, idParentGroup, lpidGroup,
3561                                    lpGroupName, lpData, dwDataSize,
3562                                    dwFlags, FALSE );
3563 }
3564
3565 static HRESULT WINAPI DP_IF_DeleteGroupFromGroup
3566           ( IDirectPlay3Impl* This, DPID idParentGroup, DPID idGroup )
3567 {
3568   lpGroupList lpGList;
3569   lpGroupData lpGParentData;
3570
3571   TRACE("(%p)->(0x%08x,0x%08x)\n", This, idParentGroup, idGroup );
3572
3573   /* Is the parent group valid? */
3574   if( ( lpGParentData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idParentGroup ) ) == NULL )
3575   {
3576     return DPERR_INVALIDGROUP;
3577   }
3578
3579   /* Remove the group from the parent group queue */
3580   DPQ_REMOVE_ENTRY( lpGParentData->groups, groups, lpGData->dpid, ==, idGroup, lpGList );
3581
3582   if( lpGList == NULL )
3583   {
3584     return DPERR_INVALIDGROUP;
3585   }
3586
3587   /* Decrement the ref count */
3588   lpGList->lpGData->uRef--;
3589
3590   /* Free up the list item */
3591   HeapFree( GetProcessHeap(), 0, lpGList );
3592
3593   /* Should send a DELETEGROUPFROMGROUP message */
3594   FIXME( "message not sent\n" );
3595
3596   return DP_OK;
3597 }
3598
3599 static HRESULT WINAPI DirectPlay3AImpl_DeleteGroupFromGroup
3600           ( LPDIRECTPLAY3 iface, DPID idParentGroup, DPID idGroup )
3601 {
3602   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3603   return DP_IF_DeleteGroupFromGroup( This, idParentGroup, idGroup );
3604 }
3605
3606 static HRESULT WINAPI DirectPlay3WImpl_DeleteGroupFromGroup
3607           ( LPDIRECTPLAY3 iface, DPID idParentGroup, DPID idGroup )
3608 {
3609   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3610   return DP_IF_DeleteGroupFromGroup( This, idParentGroup, idGroup );
3611 }
3612
3613 static
3614 BOOL WINAPI DP_BuildSPCompoundAddr( LPGUID lpcSpGuid, LPVOID* lplpAddrBuf,
3615                                     LPDWORD lpdwBufSize )
3616 {
3617   DPCOMPOUNDADDRESSELEMENT dpCompoundAddress;
3618   HRESULT                  hr;
3619
3620   dpCompoundAddress.dwDataSize = sizeof( GUID );
3621   dpCompoundAddress.guidDataType = DPAID_ServiceProvider;
3622   dpCompoundAddress.lpData = lpcSpGuid;
3623
3624   *lplpAddrBuf = NULL;
3625   *lpdwBufSize = 0;
3626
3627   hr = DPL_CreateCompoundAddress( &dpCompoundAddress, 1, *lplpAddrBuf,
3628                                   lpdwBufSize, TRUE );
3629
3630   if( hr != DPERR_BUFFERTOOSMALL )
3631   {
3632     ERR( "can't get buffer size: %s\n", DPLAYX_HresultToString( hr ) );
3633     return FALSE;
3634   }
3635
3636   /* Now allocate the buffer */
3637   *lplpAddrBuf = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
3638                             *lpdwBufSize );
3639
3640   hr = DPL_CreateCompoundAddress( &dpCompoundAddress, 1, *lplpAddrBuf,
3641                                   lpdwBufSize, TRUE );
3642   if( FAILED(hr) )
3643   {
3644     ERR( "can't create address: %s\n", DPLAYX_HresultToString( hr ) );
3645     return FALSE;
3646   }
3647
3648   return TRUE;
3649 }
3650
3651 static HRESULT WINAPI DirectPlay3AImpl_EnumConnections
3652           ( LPDIRECTPLAY3A iface, LPCGUID lpguidApplication, LPDPENUMCONNECTIONSCALLBACK lpEnumCallback, LPVOID lpContext, DWORD dwFlags )
3653 {
3654   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3655   TRACE("(%p)->(%p,%p,%p,0x%08x)\n", This, lpguidApplication, lpEnumCallback, lpContext, dwFlags );
3656
3657   /* A default dwFlags (0) is backwards compatible -- DPCONNECTION_DIRECTPLAY */
3658   if( dwFlags == 0 )
3659   {
3660     dwFlags = DPCONNECTION_DIRECTPLAY;
3661   }
3662
3663   if( ! ( ( dwFlags & DPCONNECTION_DIRECTPLAY ) ||
3664           ( dwFlags & DPCONNECTION_DIRECTPLAYLOBBY ) )
3665     )
3666   {
3667     return DPERR_INVALIDFLAGS;
3668   }
3669
3670   if( !lpEnumCallback )
3671   {
3672      return DPERR_INVALIDPARAMS;
3673   }
3674
3675   /* Enumerate DirectPlay service providers */
3676   if( dwFlags & DPCONNECTION_DIRECTPLAY )
3677   {
3678     HKEY hkResult;
3679     LPCSTR searchSubKey    = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
3680     LPCSTR guidDataSubKey  = "Guid";
3681     char subKeyName[51];
3682     DWORD dwIndex, sizeOfSubKeyName=50;
3683     FILETIME filetime;
3684
3685     /* Need to loop over the service providers in the registry */
3686     if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
3687                          0, KEY_READ, &hkResult ) != ERROR_SUCCESS )
3688     {
3689       /* Hmmm. Does this mean that there are no service providers? */
3690       ERR(": no service providers?\n");
3691       return DP_OK;
3692     }
3693
3694
3695     /* Traverse all the service providers we have available */
3696     for( dwIndex=0;
3697          RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
3698                         NULL, NULL, NULL, &filetime ) != ERROR_NO_MORE_ITEMS;
3699          ++dwIndex, sizeOfSubKeyName=51 )
3700     {
3701
3702       HKEY     hkServiceProvider;
3703       GUID     serviceProviderGUID;
3704       DWORD    returnTypeGUID, sizeOfReturnBuffer = 50;
3705       char     returnBuffer[51];
3706       WCHAR    buff[51];
3707       DPNAME   dpName;
3708       BOOL     bBuildPass;
3709
3710       LPVOID                   lpAddressBuffer = NULL;
3711       DWORD                    dwAddressBufferSize = 0;
3712
3713       TRACE(" this time through: %s\n", subKeyName );
3714
3715       /* Get a handle for this particular service provider */
3716       if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_READ,
3717                          &hkServiceProvider ) != ERROR_SUCCESS )
3718       {
3719          ERR(": what the heck is going on?\n" );
3720          continue;
3721       }
3722
3723       if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
3724                             NULL, &returnTypeGUID, (LPBYTE)returnBuffer,
3725                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
3726       {
3727         ERR(": missing GUID registry data members\n" );
3728         RegCloseKey(hkServiceProvider);
3729         continue;
3730       }
3731       RegCloseKey(hkServiceProvider);
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         RegCloseKey(hkServiceProvider);
3826         continue;
3827       }
3828       RegCloseKey(hkServiceProvider);
3829
3830       /* FIXME: Check return types to ensure we're interpreting data right */
3831       MultiByteToWideChar( CP_ACP, 0, returnBuffer, -1, buff, sizeof(buff)/sizeof(WCHAR) );
3832       CLSIDFromString( buff, &serviceProviderGUID );
3833       /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
3834
3835       /* Fill in the DPNAME struct for the service provider */
3836       dpName.dwSize             = sizeof( dpName );
3837       dpName.dwFlags            = 0;
3838       dpName.u1.lpszShortNameA = subKeyName;
3839       dpName.u2.lpszLongNameA  = NULL;
3840
3841       /* Create the compound address for the service provider.
3842          NOTE: This is a gruesome architectural scar right now. DP uses DPL and DPL uses DP
3843                nast stuff. This may be why the native dll just gets around this little bit by
3844                allocating an 80 byte buffer which isn't even a filled with a valid compound
3845                address. Oh well. Creating a proper compound address is the way to go anyways
3846                despite this method taking slightly more heap space and realtime :) */
3847
3848       dpCompoundAddress.guidDataType = DPAID_LobbyProvider;
3849       dpCompoundAddress.dwDataSize   = sizeof( GUID );
3850       dpCompoundAddress.lpData       = &serviceProviderGUID;
3851
3852       if( ( hr = DPL_CreateCompoundAddress( &dpCompoundAddress, 1, lpAddressBuffer,
3853                                      &dwAddressBufferSize, TRUE ) ) != DPERR_BUFFERTOOSMALL )
3854       {
3855         ERR( "can't get buffer size: %s\n", DPLAYX_HresultToString( hr ) );
3856         return hr;
3857       }
3858
3859       /* Now allocate the buffer */
3860       lpAddressBuffer = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwAddressBufferSize );
3861
3862       if( ( hr = DPL_CreateCompoundAddress( &dpCompoundAddress, 1, lpAddressBuffer,
3863                                      &dwAddressBufferSize, TRUE ) ) != DP_OK )
3864       {
3865         ERR( "can't create address: %s\n", DPLAYX_HresultToString( hr ) );
3866         HeapFree( GetProcessHeap(), 0, lpAddressBuffer );
3867         return hr;
3868       }
3869
3870       /* The enumeration will return FALSE if we are not to continue */
3871       if( !lpEnumCallback( &serviceProviderGUID, lpAddressBuffer, dwAddressBufferSize,
3872                            &dpName, DPCONNECTION_DIRECTPLAYLOBBY, lpContext ) )
3873       {
3874          HeapFree( GetProcessHeap(), 0, lpAddressBuffer );
3875          return DP_OK;
3876       }
3877       HeapFree( GetProcessHeap(), 0, lpAddressBuffer );
3878     }
3879   }
3880
3881   return DP_OK;
3882 }
3883
3884 static HRESULT WINAPI DirectPlay3WImpl_EnumConnections
3885           ( LPDIRECTPLAY3 iface, LPCGUID lpguidApplication, LPDPENUMCONNECTIONSCALLBACK lpEnumCallback, LPVOID lpContext, DWORD dwFlags )
3886 {
3887   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3888   FIXME("(%p)->(%p,%p,%p,0x%08x): stub\n", This, lpguidApplication, lpEnumCallback, lpContext, dwFlags );
3889   return DP_OK;
3890 }
3891
3892 static HRESULT WINAPI DP_IF_EnumGroupsInGroup
3893           ( IDirectPlay3AImpl* This, DPID idGroup, LPGUID lpguidInstance,
3894             LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2,
3895             LPVOID lpContext, DWORD dwFlags, BOOL bAnsi )
3896 {
3897   lpGroupList lpGList;
3898   lpGroupData lpGData;
3899
3900   FIXME( "(%p)->(0x%08x,%p,%p,%p,0x%08x,%u): semi stub\n",
3901          This, idGroup, lpguidInstance, lpEnumPlayersCallback2,
3902          lpContext, dwFlags, bAnsi );
3903
3904   if( ( lpGData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idGroup ) ) == NULL )
3905   {
3906     return DPERR_INVALIDGROUP;
3907   }
3908
3909   if( DPQ_IS_EMPTY( lpGData->groups ) )
3910   {
3911     return DP_OK;
3912   }
3913
3914   lpGList = DPQ_FIRST( lpGData->groups );
3915
3916   for( ;; )
3917   {
3918     /* FIXME: Should check dwFlags for match here */
3919
3920     if( !(*lpEnumPlayersCallback2)( lpGList->lpGData->dpid, DPPLAYERTYPE_GROUP,
3921                                     &lpGList->lpGData->name, dwFlags,
3922                                     lpContext ) )
3923     {
3924       return DP_OK; /* User requested break */
3925     }
3926
3927     if( DPQ_IS_ENDOFLIST( lpGList->groups ) )
3928     {
3929       break;
3930     }
3931
3932     lpGList = DPQ_NEXT( lpGList->groups );
3933
3934   }
3935
3936   return DP_OK;
3937 }
3938
3939 static HRESULT WINAPI DirectPlay3AImpl_EnumGroupsInGroup
3940           ( LPDIRECTPLAY3A iface, DPID idGroup, LPGUID lpguidInstance,
3941             LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2, LPVOID lpContext,
3942             DWORD dwFlags )
3943 {
3944   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3945   return DP_IF_EnumGroupsInGroup( This, idGroup, lpguidInstance,
3946                                   lpEnumPlayersCallback2, lpContext, dwFlags,
3947                                   TRUE );
3948 }
3949
3950 static HRESULT WINAPI DirectPlay3WImpl_EnumGroupsInGroup
3951           ( LPDIRECTPLAY3A iface, DPID idGroup, LPGUID lpguidInstance,
3952             LPDPENUMPLAYERSCALLBACK2 lpEnumPlayersCallback2, LPVOID lpContext,
3953             DWORD dwFlags )
3954 {
3955   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3956   return DP_IF_EnumGroupsInGroup( This, idGroup, lpguidInstance,
3957                                   lpEnumPlayersCallback2, lpContext, dwFlags,
3958                                   FALSE );
3959 }
3960
3961 static HRESULT WINAPI DirectPlay3AImpl_GetGroupConnectionSettings
3962           ( LPDIRECTPLAY3A iface, DWORD dwFlags, DPID idGroup, LPVOID lpData, LPDWORD lpdwDataSize )
3963 {
3964   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3965   FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, dwFlags, idGroup, lpData, lpdwDataSize );
3966   return DP_OK;
3967 }
3968
3969 static HRESULT WINAPI DirectPlay3WImpl_GetGroupConnectionSettings
3970           ( LPDIRECTPLAY3 iface, DWORD dwFlags, DPID idGroup, LPVOID lpData, LPDWORD lpdwDataSize )
3971 {
3972   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
3973   FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, dwFlags, idGroup, lpData, lpdwDataSize );
3974   return DP_OK;
3975 }
3976
3977 static BOOL CALLBACK DP_GetSpLpGuidFromCompoundAddress(
3978     REFGUID         guidDataType,
3979     DWORD           dwDataSize,
3980     LPCVOID         lpData,
3981     LPVOID          lpContext )
3982 {
3983   /* Looking for the GUID of the provider to load */
3984   if( ( IsEqualGUID( guidDataType, &DPAID_ServiceProvider ) ) ||
3985       ( IsEqualGUID( guidDataType, &DPAID_LobbyProvider ) )
3986     )
3987   {
3988     TRACE( "Found SP/LP (%s) %s (data size = 0x%08x)\n",
3989            debugstr_guid( guidDataType ), debugstr_guid( lpData ), dwDataSize );
3990
3991     if( dwDataSize != sizeof( GUID ) )
3992     {
3993       ERR( "Invalid sp/lp guid size 0x%08x\n", dwDataSize );
3994     }
3995
3996     memcpy( lpContext, lpData, dwDataSize );
3997
3998     /* There shouldn't be more than 1 GUID/compound address */
3999     return FALSE;
4000   }
4001
4002   /* Still waiting for what we want */
4003   return TRUE;
4004 }
4005
4006
4007 /* Find and perform a LoadLibrary on the requested SP or LP GUID */
4008 static HMODULE DP_LoadSP( LPCGUID lpcGuid, LPSPINITDATA lpSpData, LPBOOL lpbIsDpSp )
4009 {
4010   UINT i;
4011   LPCSTR spSubKey         = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
4012   LPCSTR lpSubKey         = "SOFTWARE\\Microsoft\\DirectPlay\\Lobby Providers";
4013   LPCSTR guidDataSubKey   = "Guid";
4014   LPCSTR majVerDataSubKey = "dwReserved1";
4015   LPCSTR minVerDataSubKey = "dwReserved2";
4016   LPCSTR pathSubKey       = "Path";
4017
4018   TRACE( " request to load %s\n", debugstr_guid( lpcGuid ) );
4019
4020   /* FIXME: Cloned code with a quick hack. */
4021   for( i=0; i<2; i++ )
4022   {
4023     HKEY hkResult;
4024     LPCSTR searchSubKey;
4025     char subKeyName[51];
4026     DWORD dwIndex, sizeOfSubKeyName=50;
4027     FILETIME filetime;
4028
4029     (i == 0) ? (searchSubKey = spSubKey ) : (searchSubKey = lpSubKey );
4030     *lpbIsDpSp = (i == 0) ? TRUE : FALSE;
4031
4032
4033     /* Need to loop over the service providers in the registry */
4034     if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
4035                          0, KEY_READ, &hkResult ) != ERROR_SUCCESS )
4036     {
4037       /* Hmmm. Does this mean that there are no service providers? */
4038       ERR(": no service providers?\n");
4039       return 0;
4040     }
4041
4042     /* Traverse all the service providers we have available */
4043     for( dwIndex=0;
4044          RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4045                         NULL, NULL, NULL, &filetime ) != ERROR_NO_MORE_ITEMS;
4046          ++dwIndex, sizeOfSubKeyName=51 )
4047     {
4048
4049       HKEY     hkServiceProvider;
4050       GUID     serviceProviderGUID;
4051       DWORD    returnType, sizeOfReturnBuffer = 255;
4052       char     returnBuffer[256];
4053       WCHAR    buff[51];
4054       DWORD    dwTemp, len;
4055
4056       TRACE(" this time through: %s\n", subKeyName );
4057
4058       /* Get a handle for this particular service provider */
4059       if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_READ,
4060                          &hkServiceProvider ) != ERROR_SUCCESS )
4061       {
4062          ERR(": what the heck is going on?\n" );
4063          continue;
4064       }
4065
4066       if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
4067                             NULL, &returnType, (LPBYTE)returnBuffer,
4068                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4069       {
4070         ERR(": missing GUID registry data members\n" );
4071         continue;
4072       }
4073
4074       /* FIXME: Check return types to ensure we're interpreting data right */
4075       MultiByteToWideChar( CP_ACP, 0, returnBuffer, -1, buff, sizeof(buff)/sizeof(WCHAR) );
4076       CLSIDFromString( buff, &serviceProviderGUID );
4077       /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
4078
4079       /* Determine if this is the Service Provider that the user asked for */
4080       if( !IsEqualGUID( &serviceProviderGUID, lpcGuid ) )
4081       {
4082         continue;
4083       }
4084
4085       if( i == 0 ) /* DP SP */
4086       {
4087         len = MultiByteToWideChar( CP_ACP, 0, subKeyName, -1, NULL, 0 );
4088         lpSpData->lpszName = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
4089         MultiByteToWideChar( CP_ACP, 0, subKeyName, -1, lpSpData->lpszName, len );
4090       }
4091
4092       sizeOfReturnBuffer = 255;
4093
4094       /* Get dwReserved1 */
4095       if( RegQueryValueExA( hkServiceProvider, majVerDataSubKey,
4096                             NULL, &returnType, (LPBYTE)returnBuffer,
4097                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4098       {
4099          ERR(": missing dwReserved1 registry data members\n") ;
4100          continue;
4101       }
4102
4103       if( i == 0 )
4104           memcpy( &lpSpData->dwReserved1, returnBuffer, sizeof(lpSpData->dwReserved1) );
4105
4106       sizeOfReturnBuffer = 255;
4107
4108       /* Get dwReserved2 */
4109       if( RegQueryValueExA( hkServiceProvider, minVerDataSubKey,
4110                             NULL, &returnType, (LPBYTE)returnBuffer,
4111                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4112       {
4113          ERR(": missing dwReserved1 registry data members\n") ;
4114          continue;
4115       }
4116
4117       if( i == 0 )
4118           memcpy( &lpSpData->dwReserved2, returnBuffer, sizeof(lpSpData->dwReserved2) );
4119
4120       sizeOfReturnBuffer = 255;
4121
4122       /* Get the path for this service provider */
4123       if( ( dwTemp = RegQueryValueExA( hkServiceProvider, pathSubKey,
4124                             NULL, NULL, (LPBYTE)returnBuffer,
4125                             &sizeOfReturnBuffer ) ) != ERROR_SUCCESS )
4126       {
4127         ERR(": missing PATH registry data members: 0x%08x\n", dwTemp );
4128         continue;
4129       }
4130
4131       TRACE( "Loading %s\n", returnBuffer );
4132       return LoadLibraryA( returnBuffer );
4133     }
4134   }
4135
4136   return 0;
4137 }
4138
4139 static
4140 HRESULT DP_InitializeDPSP( IDirectPlay3Impl* This, HMODULE hServiceProvider )
4141 {
4142   HRESULT hr;
4143   LPDPSP_SPINIT SPInit;
4144
4145   /* Initialize the service provider by calling SPInit */
4146   SPInit = (LPDPSP_SPINIT)GetProcAddress( hServiceProvider, "SPInit" );
4147
4148   if( SPInit == NULL )
4149   {
4150     ERR( "Service provider doesn't provide SPInit interface?\n" );
4151     FreeLibrary( hServiceProvider );
4152     return DPERR_UNAVAILABLE;
4153   }
4154
4155   TRACE( "Calling SPInit (DP SP entry point)\n" );
4156
4157   hr = (*SPInit)( &This->dp2->spData );
4158
4159   if( FAILED(hr) )
4160   {
4161     ERR( "DP SP Initialization failed: %s\n", DPLAYX_HresultToString(hr) );
4162     FreeLibrary( hServiceProvider );
4163     return hr;
4164   }
4165
4166   /* FIXME: Need to verify the sanity of the returned callback table
4167    *        using IsBadCodePtr */
4168   This->dp2->bSPInitialized = TRUE;
4169
4170   /* This interface is now initialized as a DP object */
4171   This->dp2->connectionInitialized = DP_SERVICE_PROVIDER;
4172
4173   /* Store the handle of the module so that we can unload it later */
4174   This->dp2->hServiceProvider = hServiceProvider;
4175
4176   return hr;
4177 }
4178
4179 static
4180 HRESULT DP_InitializeDPLSP( IDirectPlay3Impl* This, HMODULE hLobbyProvider )
4181 {
4182   HRESULT hr;
4183   LPSP_INIT DPLSPInit;
4184
4185   /* Initialize the service provider by calling SPInit */
4186   DPLSPInit = (LPSP_INIT)GetProcAddress( hLobbyProvider, "DPLSPInit" );
4187
4188   if( DPLSPInit == NULL )
4189   {
4190     ERR( "Service provider doesn't provide DPLSPInit interface?\n" );
4191     FreeLibrary( hLobbyProvider );
4192     return DPERR_UNAVAILABLE;
4193   }
4194
4195   TRACE( "Calling DPLSPInit (DPL SP entry point)\n" );
4196
4197   hr = (*DPLSPInit)( &This->dp2->dplspData );
4198
4199   if( FAILED(hr) )
4200   {
4201     ERR( "DPL SP Initialization failed: %s\n", DPLAYX_HresultToString(hr) );
4202     FreeLibrary( hLobbyProvider );
4203     return hr;
4204   }
4205
4206   /* FIXME: Need to verify the sanity of the returned callback table
4207    *        using IsBadCodePtr */
4208
4209   This->dp2->bDPLSPInitialized = TRUE;
4210
4211   /* This interface is now initialized as a lobby object */
4212   This->dp2->connectionInitialized = DP_LOBBY_PROVIDER;
4213
4214   /* Store the handle of the module so that we can unload it later */
4215   This->dp2->hDPLobbyProvider = hLobbyProvider;
4216
4217   return hr;
4218 }
4219
4220 static HRESULT WINAPI DP_IF_InitializeConnection
4221           ( IDirectPlay3Impl* This, LPVOID lpConnection, DWORD dwFlags, BOOL bAnsi )
4222 {
4223   HMODULE hServiceProvider;
4224   HRESULT hr;
4225   GUID guidSP;
4226   const DWORD dwAddrSize = 80; /* FIXME: Need to calculate it correctly */
4227   BOOL bIsDpSp; /* TRUE if Direct Play SP, FALSE if Direct Play Lobby SP */
4228
4229   TRACE("(%p)->(%p,0x%08x,%u)\n", This, lpConnection, dwFlags, bAnsi );
4230
4231   if( dwFlags != 0 )
4232   {
4233     return DPERR_INVALIDFLAGS;
4234   }
4235
4236   /* Find out what the requested SP is and how large this buffer is */
4237   hr = DPL_EnumAddress( DP_GetSpLpGuidFromCompoundAddress, lpConnection,
4238                         dwAddrSize, &guidSP );
4239
4240   if( FAILED(hr) )
4241   {
4242     ERR( "Invalid compound address?\n" );
4243     return DPERR_UNAVAILABLE;
4244   }
4245
4246   /* Load the service provider */
4247   hServiceProvider = DP_LoadSP( &guidSP, &This->dp2->spData, &bIsDpSp );
4248
4249   if( hServiceProvider == 0 )
4250   {
4251     ERR( "Unable to load service provider %s\n", debugstr_guid(&guidSP) );
4252     return DPERR_UNAVAILABLE;
4253   }
4254
4255   if( bIsDpSp )
4256   {
4257      /* Fill in what we can of the Service Provider required information.
4258       * The rest was be done in DP_LoadSP
4259       */
4260      This->dp2->spData.lpAddress = lpConnection;
4261      This->dp2->spData.dwAddressSize = dwAddrSize;
4262      This->dp2->spData.lpGuid = &guidSP;
4263
4264      hr = DP_InitializeDPSP( This, hServiceProvider );
4265   }
4266   else
4267   {
4268      This->dp2->dplspData.lpAddress = lpConnection;
4269
4270      hr = DP_InitializeDPLSP( This, hServiceProvider );
4271   }
4272
4273   if( FAILED(hr) )
4274   {
4275     return hr;
4276   }
4277
4278   return DP_OK;
4279 }
4280
4281 static HRESULT WINAPI DirectPlay3AImpl_InitializeConnection
4282           ( LPDIRECTPLAY3A iface, LPVOID lpConnection, DWORD dwFlags )
4283 {
4284   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4285
4286   /* This may not be externally invoked once either an SP or LP is initialized */
4287   if( This->dp2->connectionInitialized != NO_PROVIDER )
4288   {
4289     return DPERR_ALREADYINITIALIZED;
4290   }
4291
4292   return DP_IF_InitializeConnection( This, lpConnection, dwFlags, TRUE );
4293 }
4294
4295 static HRESULT WINAPI DirectPlay3WImpl_InitializeConnection
4296           ( LPDIRECTPLAY3 iface, LPVOID lpConnection, DWORD dwFlags )
4297 {
4298   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4299
4300   /* This may not be externally invoked once either an SP or LP is initialized */
4301   if( This->dp2->connectionInitialized != NO_PROVIDER )
4302   {
4303     return DPERR_ALREADYINITIALIZED;
4304   }
4305
4306   return DP_IF_InitializeConnection( This, lpConnection, dwFlags, FALSE );
4307 }
4308
4309 static HRESULT WINAPI DirectPlay3AImpl_SecureOpen
4310           ( LPDIRECTPLAY3A iface, LPCDPSESSIONDESC2 lpsd, DWORD dwFlags,
4311             LPCDPSECURITYDESC lpSecurity, LPCDPCREDENTIALS lpCredentials )
4312 {
4313   IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* Yes a dp 2 interface */
4314   return DP_SecureOpen( This, lpsd, dwFlags, lpSecurity, lpCredentials, TRUE );
4315 }
4316
4317 static HRESULT WINAPI DirectPlay3WImpl_SecureOpen
4318           ( LPDIRECTPLAY3 iface, LPCDPSESSIONDESC2 lpsd, DWORD dwFlags,
4319             LPCDPSECURITYDESC lpSecurity, LPCDPCREDENTIALS lpCredentials )
4320 {
4321   IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* Yes a dp 2 interface */
4322   return DP_SecureOpen( This, lpsd, dwFlags, lpSecurity, lpCredentials, FALSE );
4323 }
4324
4325 static HRESULT WINAPI DirectPlay3AImpl_SendChatMessage
4326           ( LPDIRECTPLAY3A iface, DPID idFrom, DPID idTo, DWORD dwFlags, LPDPCHAT lpChatMessage )
4327 {
4328   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4329   FIXME("(%p)->(0x%08x,0x%08x,0x%08x,%p): stub\n", This, idFrom, idTo, dwFlags, lpChatMessage );
4330   return DP_OK;
4331 }
4332
4333 static HRESULT WINAPI DirectPlay3WImpl_SendChatMessage
4334           ( LPDIRECTPLAY3 iface, DPID idFrom, DPID idTo, DWORD dwFlags, LPDPCHAT lpChatMessage )
4335 {
4336   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4337   FIXME("(%p)->(0x%08x,0x%08x,0x%08x,%p): stub\n", This, idFrom, idTo, dwFlags, lpChatMessage );
4338   return DP_OK;
4339 }
4340
4341 static HRESULT WINAPI DirectPlay3AImpl_SetGroupConnectionSettings
4342           ( LPDIRECTPLAY3A iface, DWORD dwFlags, DPID idGroup, LPDPLCONNECTION lpConnection )
4343 {
4344   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4345   FIXME("(%p)->(0x%08x,0x%08x,%p): stub\n", This, dwFlags, idGroup, lpConnection );
4346   return DP_OK;
4347 }
4348
4349 static HRESULT WINAPI DirectPlay3WImpl_SetGroupConnectionSettings
4350           ( LPDIRECTPLAY3 iface, DWORD dwFlags, DPID idGroup, LPDPLCONNECTION lpConnection )
4351 {
4352   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4353   FIXME("(%p)->(0x%08x,0x%08x,%p): stub\n", This, dwFlags, idGroup, lpConnection );
4354   return DP_OK;
4355 }
4356
4357 static HRESULT WINAPI DirectPlay3AImpl_StartSession
4358           ( LPDIRECTPLAY3A iface, DWORD dwFlags, DPID idGroup )
4359 {
4360   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4361   FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, dwFlags, idGroup );
4362   return DP_OK;
4363 }
4364
4365 static HRESULT WINAPI DirectPlay3WImpl_StartSession
4366           ( LPDIRECTPLAY3 iface, DWORD dwFlags, DPID idGroup )
4367 {
4368   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4369   FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, dwFlags, idGroup );
4370   return DP_OK;
4371 }
4372
4373 static HRESULT WINAPI DirectPlay3AImpl_GetGroupFlags
4374           ( LPDIRECTPLAY3A iface, DPID idGroup, LPDWORD lpdwFlags )
4375 {
4376   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4377   FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpdwFlags );
4378   return DP_OK;
4379 }
4380
4381 static HRESULT WINAPI DirectPlay3WImpl_GetGroupFlags
4382           ( LPDIRECTPLAY3 iface, DPID idGroup, LPDWORD lpdwFlags )
4383 {
4384   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4385   FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpdwFlags );
4386   return DP_OK;
4387 }
4388
4389 static HRESULT WINAPI DP_IF_GetGroupParent
4390           ( IDirectPlay3AImpl* This, DPID idGroup, LPDPID lpidGroup,
4391             BOOL bAnsi )
4392 {
4393   lpGroupData lpGData;
4394
4395   TRACE("(%p)->(0x%08x,%p,%u)\n", This, idGroup, lpidGroup, bAnsi );
4396
4397   if( ( lpGData = DP_FindAnyGroup( (IDirectPlay2AImpl*)This, idGroup ) ) == NULL )
4398   {
4399     return DPERR_INVALIDGROUP;
4400   }
4401
4402   *lpidGroup = lpGData->dpid;
4403
4404   return DP_OK;
4405 }
4406
4407 static HRESULT WINAPI DirectPlay3AImpl_GetGroupParent
4408           ( LPDIRECTPLAY3A iface, DPID idGroup, LPDPID lpidGroup )
4409 {
4410   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4411   return DP_IF_GetGroupParent( This, idGroup, lpidGroup, TRUE );
4412 }
4413 static HRESULT WINAPI DirectPlay3WImpl_GetGroupParent
4414           ( LPDIRECTPLAY3 iface, DPID idGroup, LPDPID lpidGroup )
4415 {
4416   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4417   return DP_IF_GetGroupParent( This, idGroup, lpidGroup, FALSE );
4418 }
4419
4420 static HRESULT WINAPI DirectPlay3AImpl_GetPlayerAccount
4421           ( LPDIRECTPLAY3A iface, DPID idPlayer, DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize )
4422 {
4423   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4424   FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, idPlayer, dwFlags, lpData, lpdwDataSize );
4425   return DP_OK;
4426 }
4427
4428 static HRESULT WINAPI DirectPlay3WImpl_GetPlayerAccount
4429           ( LPDIRECTPLAY3 iface, DPID idPlayer, DWORD dwFlags, LPVOID lpData, LPDWORD lpdwDataSize )
4430 {
4431   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4432   FIXME("(%p)->(0x%08x,0x%08x,%p,%p): stub\n", This, idPlayer, dwFlags, lpData, lpdwDataSize );
4433   return DP_OK;
4434 }
4435
4436 static HRESULT WINAPI DirectPlay3AImpl_GetPlayerFlags
4437           ( LPDIRECTPLAY3A iface, DPID idPlayer, LPDWORD lpdwFlags )
4438 {
4439   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4440   FIXME("(%p)->(0x%08x,%p): stub\n", This, idPlayer, lpdwFlags );
4441   return DP_OK;
4442 }
4443
4444 static HRESULT WINAPI DirectPlay3WImpl_GetPlayerFlags
4445           ( LPDIRECTPLAY3 iface, DPID idPlayer, LPDWORD lpdwFlags )
4446 {
4447   IDirectPlay3Impl *This = (IDirectPlay3Impl *)iface;
4448   FIXME("(%p)->(0x%08x,%p): stub\n", This, idPlayer, lpdwFlags );
4449   return DP_OK;
4450 }
4451
4452 static HRESULT WINAPI DirectPlay4AImpl_GetGroupOwner
4453           ( LPDIRECTPLAY4A iface, DPID idGroup, LPDPID lpidGroupOwner )
4454 {
4455   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4456   FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpidGroupOwner );
4457   return DP_OK;
4458 }
4459
4460 static HRESULT WINAPI DirectPlay4WImpl_GetGroupOwner
4461           ( LPDIRECTPLAY4 iface, DPID idGroup, LPDPID lpidGroupOwner )
4462 {
4463   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4464   FIXME("(%p)->(0x%08x,%p): stub\n", This, idGroup, lpidGroupOwner );
4465   return DP_OK;
4466 }
4467
4468 static HRESULT WINAPI DirectPlay4AImpl_SetGroupOwner
4469           ( LPDIRECTPLAY4A iface, DPID idGroup , DPID idGroupOwner )
4470 {
4471   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4472   FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, idGroup, idGroupOwner );
4473   return DP_OK;
4474 }
4475
4476 static HRESULT WINAPI DirectPlay4WImpl_SetGroupOwner
4477           ( LPDIRECTPLAY4 iface, DPID idGroup , DPID idGroupOwner )
4478 {
4479   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4480   FIXME("(%p)->(0x%08x,0x%08x): stub\n", This, idGroup, idGroupOwner );
4481   return DP_OK;
4482 }
4483
4484 static HRESULT WINAPI DP_SendEx
4485           ( IDirectPlay2Impl* This, DPID idFrom, DPID idTo, DWORD dwFlags,
4486             LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4487             LPVOID lpContext, LPDWORD lpdwMsgID, BOOL bAnsi )
4488 {
4489   BOOL         bValidDestination = FALSE;
4490
4491   FIXME( "(%p)->(0x%08x,0x%08x,0x%08x,%p,0x%08x,0x%08x,0x%08x,%p,%p,%u)"
4492          ": stub\n",
4493          This, idFrom, idTo, dwFlags, lpData, dwDataSize, dwPriority,
4494          dwTimeout, lpContext, lpdwMsgID, bAnsi );
4495
4496   /* FIXME: Add parameter checking */
4497   /* FIXME: First call to this needs to acquire a message id which will be
4498    *        used for multiple sends
4499    */
4500
4501   /* NOTE: Can't send messages to yourself - this will be trapped in receive */
4502
4503   /* Verify that the message is being sent from a valid local player. The
4504    * from player may be anonymous DPID_UNKNOWN
4505    */
4506   if( idFrom != DPID_UNKNOWN )
4507   {
4508     if( DP_FindPlayer( This, idFrom ) == NULL )
4509     {
4510       WARN( "INFO: Invalid from player 0x%08x\n", idFrom );
4511       return DPERR_INVALIDPLAYER;
4512     }
4513   }
4514
4515   /* Verify that the message is being sent to a valid player, group or to
4516    * everyone. If it's valid, send it to those players.
4517    */
4518   if( idTo == DPID_ALLPLAYERS )
4519   {
4520     bValidDestination = TRUE;
4521
4522     /* See if SP has the ability to multicast. If so, use it */
4523     if( This->dp2->spData.lpCB->SendToGroupEx )
4524     {
4525       FIXME( "Use group sendex to group 0\n" );
4526     }
4527     else if( This->dp2->spData.lpCB->SendToGroup ) /* obsolete interface */
4528     {
4529       FIXME( "Use obsolete group send to group 0\n" );
4530     }
4531     else /* No multicast, multiplicate */
4532     {
4533       /* Send to all players we know about */
4534       FIXME( "Send to all players using EnumPlayersInGroup\n" );
4535     }
4536   }
4537
4538   if( ( !bValidDestination ) &&
4539       ( DP_FindPlayer( This, idTo ) != NULL )
4540     )
4541   {
4542     bValidDestination = TRUE;
4543
4544     /* Have the service provider send this message */
4545     /* FIXME: Could optimize for local interface sends */
4546     return DP_SP_SendEx( This, dwFlags, lpData, dwDataSize, dwPriority,
4547                          dwTimeout, lpContext, lpdwMsgID );
4548   }
4549
4550   if( ( !bValidDestination ) &&
4551       ( DP_FindAnyGroup( This, idTo ) != NULL )
4552     )
4553   {
4554     bValidDestination = TRUE;
4555
4556     /* See if SP has the ability to multicast. If so, use it */
4557     if( This->dp2->spData.lpCB->SendToGroupEx )
4558     {
4559       FIXME( "Use group sendex\n" );
4560     }
4561     else if( This->dp2->spData.lpCB->SendToGroup ) /* obsolete interface */
4562     {
4563       FIXME( "Use obsolete group send to group\n" );
4564     }
4565     else /* No multicast, multiplicate */
4566     {
4567       FIXME( "Send to all players using EnumPlayersInGroup\n" );
4568     }
4569
4570 #if 0
4571     if( bExpectReply )
4572     {
4573       DWORD dwWaitReturn;
4574
4575       This->dp2->hReplyEvent = CreateEventW( NULL, FALSE, FALSE, NULL );
4576
4577       dwWaitReturn = WaitForSingleObject( hReplyEvent, dwTimeout );
4578       if( dwWaitReturn != WAIT_OBJECT_0 )
4579       {
4580         ERR( "Wait failed 0x%08lx\n", dwWaitReturn );
4581       }
4582     }
4583 #endif
4584   }
4585
4586   if( !bValidDestination )
4587   {
4588     return DPERR_INVALIDPLAYER;
4589   }
4590   else
4591   {
4592     /* FIXME: Should return what the send returned */
4593     return DP_OK;
4594   }
4595 }
4596
4597
4598 static HRESULT WINAPI DirectPlay4AImpl_SendEx
4599           ( LPDIRECTPLAY4A iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4600             LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4601             LPVOID lpContext, LPDWORD lpdwMsgID )
4602 {
4603   IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* yes downcast to 2 */
4604   return DP_SendEx( This, idFrom, idTo, dwFlags, lpData, dwDataSize,
4605                     dwPriority, dwTimeout, lpContext, lpdwMsgID, TRUE );
4606 }
4607
4608 static HRESULT WINAPI DirectPlay4WImpl_SendEx
4609           ( LPDIRECTPLAY4 iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4610             LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4611             LPVOID lpContext, LPDWORD lpdwMsgID )
4612 {
4613   IDirectPlay2Impl *This = (IDirectPlay2Impl *)iface; /* yes downcast to 2 */
4614   return DP_SendEx( This, idFrom, idTo, dwFlags, lpData, dwDataSize,
4615                     dwPriority, dwTimeout, lpContext, lpdwMsgID, FALSE );
4616 }
4617
4618 static HRESULT WINAPI DP_SP_SendEx
4619           ( IDirectPlay2Impl* This, DWORD dwFlags,
4620             LPVOID lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout,
4621             LPVOID lpContext, LPDWORD lpdwMsgID )
4622 {
4623   LPDPMSG lpMElem;
4624
4625   FIXME( ": stub\n" );
4626
4627   /* FIXME: This queuing should only be for async messages */
4628
4629   lpMElem = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *lpMElem ) );
4630   lpMElem->msg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
4631
4632   CopyMemory( lpMElem->msg, lpData, dwDataSize );
4633
4634   /* FIXME: Need to queue based on priority */
4635   DPQ_INSERT( This->dp2->sendMsgs, lpMElem, msgs );
4636
4637   return DP_OK;
4638 }
4639
4640 static HRESULT WINAPI DP_IF_GetMessageQueue
4641           ( IDirectPlay4Impl* This, DPID idFrom, DPID idTo, DWORD dwFlags,
4642             LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes, BOOL bAnsi )
4643 {
4644   HRESULT hr = DP_OK;
4645
4646   FIXME( "(%p)->(0x%08x,0x%08x,0x%08x,%p,%p,%u): semi stub\n",
4647          This, idFrom, idTo, dwFlags, lpdwNumMsgs, lpdwNumBytes, bAnsi );
4648
4649   /* FIXME: Do we need to do idFrom and idTo sanity checking here? */
4650   /* FIXME: What about sends which are not immediate? */
4651
4652   if( This->dp2->spData.lpCB->GetMessageQueue )
4653   {
4654     DPSP_GETMESSAGEQUEUEDATA data;
4655
4656     FIXME( "Calling SP GetMessageQueue - is it right?\n" );
4657
4658     /* FIXME: None of this is documented :( */
4659
4660     data.lpISP        = This->dp2->spData.lpISP;
4661     data.dwFlags      = dwFlags;
4662     data.idFrom       = idFrom;
4663     data.idTo         = idTo;
4664     data.lpdwNumMsgs  = lpdwNumMsgs;
4665     data.lpdwNumBytes = lpdwNumBytes;
4666
4667     hr = (*This->dp2->spData.lpCB->GetMessageQueue)( &data );
4668   }
4669   else
4670   {
4671     FIXME( "No SP for GetMessageQueue - fake some data\n" );
4672   }
4673
4674   return hr;
4675 }
4676
4677 static HRESULT WINAPI DirectPlay4AImpl_GetMessageQueue
4678           ( LPDIRECTPLAY4A iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4679             LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes )
4680 {
4681   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4682   return DP_IF_GetMessageQueue( This, idFrom, idTo, dwFlags, lpdwNumMsgs,
4683                                 lpdwNumBytes, TRUE );
4684 }
4685
4686 static HRESULT WINAPI DirectPlay4WImpl_GetMessageQueue
4687           ( LPDIRECTPLAY4 iface, DPID idFrom, DPID idTo, DWORD dwFlags,
4688             LPDWORD lpdwNumMsgs, LPDWORD lpdwNumBytes )
4689 {
4690   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4691   return DP_IF_GetMessageQueue( This, idFrom, idTo, dwFlags, lpdwNumMsgs,
4692                                 lpdwNumBytes, FALSE );
4693 }
4694
4695 static HRESULT WINAPI DP_IF_CancelMessage
4696           ( IDirectPlay4Impl* This, DWORD dwMsgID, DWORD dwFlags,
4697             DWORD dwMinPriority, DWORD dwMaxPriority, BOOL bAnsi )
4698 {
4699   HRESULT hr = DP_OK;
4700
4701   FIXME( "(%p)->(0x%08x,0x%08x,%u): semi stub\n",
4702          This, dwMsgID, dwFlags, bAnsi );
4703
4704   if( This->dp2->spData.lpCB->Cancel )
4705   {
4706     DPSP_CANCELDATA data;
4707
4708     TRACE( "Calling SP Cancel\n" );
4709
4710     /* FIXME: Undocumented callback */
4711
4712     data.lpISP          = This->dp2->spData.lpISP;
4713     data.dwFlags        = dwFlags;
4714     data.lprglpvSPMsgID = NULL;
4715     data.cSPMsgID       = dwMsgID;
4716     data.dwMinPriority  = dwMinPriority;
4717     data.dwMaxPriority  = dwMaxPriority;
4718
4719     hr = (*This->dp2->spData.lpCB->Cancel)( &data );
4720   }
4721   else
4722   {
4723     FIXME( "SP doesn't implement Cancel\n" );
4724   }
4725
4726   return hr;
4727 }
4728
4729 static HRESULT WINAPI DirectPlay4AImpl_CancelMessage
4730           ( LPDIRECTPLAY4A iface, DWORD dwMsgID, DWORD dwFlags )
4731 {
4732   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4733
4734   if( dwFlags != 0 )
4735   {
4736     return DPERR_INVALIDFLAGS;
4737   }
4738
4739   if( dwMsgID == 0 )
4740   {
4741     dwFlags |= DPCANCELSEND_ALL;
4742   }
4743
4744   return DP_IF_CancelMessage( This, dwMsgID, dwFlags, 0, 0, TRUE );
4745 }
4746
4747 static HRESULT WINAPI DirectPlay4WImpl_CancelMessage
4748           ( LPDIRECTPLAY4 iface, DWORD dwMsgID, DWORD dwFlags )
4749 {
4750   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4751
4752   if( dwFlags != 0 )
4753   {
4754     return DPERR_INVALIDFLAGS;
4755   }
4756
4757   if( dwMsgID == 0 )
4758   {
4759     dwFlags |= DPCANCELSEND_ALL;
4760   }
4761
4762   return DP_IF_CancelMessage( This, dwMsgID, dwFlags, 0, 0, FALSE );
4763 }
4764
4765 static HRESULT WINAPI DirectPlay4AImpl_CancelPriority
4766           ( LPDIRECTPLAY4A iface, DWORD dwMinPriority, DWORD dwMaxPriority,
4767             DWORD dwFlags )
4768 {
4769   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4770
4771   if( dwFlags != 0 )
4772   {
4773     return DPERR_INVALIDFLAGS;
4774   }
4775
4776   return DP_IF_CancelMessage( This, 0, DPCANCELSEND_PRIORITY, dwMinPriority,
4777                               dwMaxPriority, TRUE );
4778 }
4779
4780 static HRESULT WINAPI DirectPlay4WImpl_CancelPriority
4781           ( LPDIRECTPLAY4 iface, DWORD dwMinPriority, DWORD dwMaxPriority,
4782             DWORD dwFlags )
4783 {
4784   IDirectPlay4Impl *This = (IDirectPlay4Impl *)iface;
4785
4786   if( dwFlags != 0 )
4787   {
4788     return DPERR_INVALIDFLAGS;
4789   }
4790
4791   return DP_IF_CancelMessage( This, 0, DPCANCELSEND_PRIORITY, dwMinPriority,
4792                               dwMaxPriority, FALSE );
4793 }
4794
4795 /* Note: Hack so we can reuse the old functions without compiler warnings */
4796 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4797 # define XCAST(fun)     (typeof(directPlay2WVT.fun))
4798 #else
4799 # define XCAST(fun)     (void*)
4800 #endif
4801
4802 static const IDirectPlay2Vtbl directPlay2WVT =
4803 {
4804   XCAST(QueryInterface)DP_QueryInterface,
4805   XCAST(AddRef)DP_AddRef,
4806   XCAST(Release)DP_Release,
4807
4808   DirectPlay2WImpl_AddPlayerToGroup,
4809   DirectPlay2WImpl_Close,
4810   DirectPlay2WImpl_CreateGroup,
4811   DirectPlay2WImpl_CreatePlayer,
4812   DirectPlay2WImpl_DeletePlayerFromGroup,
4813   DirectPlay2WImpl_DestroyGroup,
4814   DirectPlay2WImpl_DestroyPlayer,
4815   DirectPlay2WImpl_EnumGroupPlayers,
4816   DirectPlay2WImpl_EnumGroups,
4817   DirectPlay2WImpl_EnumPlayers,
4818   DirectPlay2WImpl_EnumSessions,
4819   DirectPlay2WImpl_GetCaps,
4820   DirectPlay2WImpl_GetGroupData,
4821   DirectPlay2WImpl_GetGroupName,
4822   DirectPlay2WImpl_GetMessageCount,
4823   DirectPlay2WImpl_GetPlayerAddress,
4824   DirectPlay2WImpl_GetPlayerCaps,
4825   DirectPlay2WImpl_GetPlayerData,
4826   DirectPlay2WImpl_GetPlayerName,
4827   DirectPlay2WImpl_GetSessionDesc,
4828   DirectPlay2WImpl_Initialize,
4829   DirectPlay2WImpl_Open,
4830   DirectPlay2WImpl_Receive,
4831   DirectPlay2WImpl_Send,
4832   DirectPlay2WImpl_SetGroupData,
4833   DirectPlay2WImpl_SetGroupName,
4834   DirectPlay2WImpl_SetPlayerData,
4835   DirectPlay2WImpl_SetPlayerName,
4836   DirectPlay2WImpl_SetSessionDesc
4837 };
4838 #undef XCAST
4839
4840 /* Note: Hack so we can reuse the old functions without compiler warnings */
4841 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4842 # define XCAST(fun)     (typeof(directPlay2AVT.fun))
4843 #else
4844 # define XCAST(fun)     (void*)
4845 #endif
4846
4847 static const IDirectPlay2Vtbl directPlay2AVT =
4848 {
4849   XCAST(QueryInterface)DP_QueryInterface,
4850   XCAST(AddRef)DP_AddRef,
4851   XCAST(Release)DP_Release,
4852
4853   DirectPlay2AImpl_AddPlayerToGroup,
4854   DirectPlay2AImpl_Close,
4855   DirectPlay2AImpl_CreateGroup,
4856   DirectPlay2AImpl_CreatePlayer,
4857   DirectPlay2AImpl_DeletePlayerFromGroup,
4858   DirectPlay2AImpl_DestroyGroup,
4859   DirectPlay2AImpl_DestroyPlayer,
4860   DirectPlay2AImpl_EnumGroupPlayers,
4861   DirectPlay2AImpl_EnumGroups,
4862   DirectPlay2AImpl_EnumPlayers,
4863   DirectPlay2AImpl_EnumSessions,
4864   DirectPlay2AImpl_GetCaps,
4865   DirectPlay2AImpl_GetGroupData,
4866   DirectPlay2AImpl_GetGroupName,
4867   DirectPlay2AImpl_GetMessageCount,
4868   DirectPlay2AImpl_GetPlayerAddress,
4869   DirectPlay2AImpl_GetPlayerCaps,
4870   DirectPlay2AImpl_GetPlayerData,
4871   DirectPlay2AImpl_GetPlayerName,
4872   DirectPlay2AImpl_GetSessionDesc,
4873   DirectPlay2AImpl_Initialize,
4874   DirectPlay2AImpl_Open,
4875   DirectPlay2AImpl_Receive,
4876   DirectPlay2AImpl_Send,
4877   DirectPlay2AImpl_SetGroupData,
4878   DirectPlay2AImpl_SetGroupName,
4879   DirectPlay2AImpl_SetPlayerData,
4880   DirectPlay2AImpl_SetPlayerName,
4881   DirectPlay2AImpl_SetSessionDesc
4882 };
4883 #undef XCAST
4884
4885
4886 /* Note: Hack so we can reuse the old functions without compiler warnings */
4887 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4888 # define XCAST(fun)     (typeof(directPlay3AVT.fun))
4889 #else
4890 # define XCAST(fun)     (void*)
4891 #endif
4892
4893 static const IDirectPlay3Vtbl directPlay3AVT =
4894 {
4895   XCAST(QueryInterface)DP_QueryInterface,
4896   XCAST(AddRef)DP_AddRef,
4897   XCAST(Release)DP_Release,
4898
4899   XCAST(AddPlayerToGroup)DirectPlay2AImpl_AddPlayerToGroup,
4900   XCAST(Close)DirectPlay2AImpl_Close,
4901   XCAST(CreateGroup)DirectPlay2AImpl_CreateGroup,
4902   XCAST(CreatePlayer)DirectPlay2AImpl_CreatePlayer,
4903   XCAST(DeletePlayerFromGroup)DirectPlay2AImpl_DeletePlayerFromGroup,
4904   XCAST(DestroyGroup)DirectPlay2AImpl_DestroyGroup,
4905   XCAST(DestroyPlayer)DirectPlay2AImpl_DestroyPlayer,
4906   XCAST(EnumGroupPlayers)DirectPlay2AImpl_EnumGroupPlayers,
4907   XCAST(EnumGroups)DirectPlay2AImpl_EnumGroups,
4908   XCAST(EnumPlayers)DirectPlay2AImpl_EnumPlayers,
4909   XCAST(EnumSessions)DirectPlay2AImpl_EnumSessions,
4910   XCAST(GetCaps)DirectPlay2AImpl_GetCaps,
4911   XCAST(GetGroupData)DirectPlay2AImpl_GetGroupData,
4912   XCAST(GetGroupName)DirectPlay2AImpl_GetGroupName,
4913   XCAST(GetMessageCount)DirectPlay2AImpl_GetMessageCount,
4914   XCAST(GetPlayerAddress)DirectPlay2AImpl_GetPlayerAddress,
4915   XCAST(GetPlayerCaps)DirectPlay2AImpl_GetPlayerCaps,
4916   XCAST(GetPlayerData)DirectPlay2AImpl_GetPlayerData,
4917   XCAST(GetPlayerName)DirectPlay2AImpl_GetPlayerName,
4918   XCAST(GetSessionDesc)DirectPlay2AImpl_GetSessionDesc,
4919   XCAST(Initialize)DirectPlay2AImpl_Initialize,
4920   XCAST(Open)DirectPlay2AImpl_Open,
4921   XCAST(Receive)DirectPlay2AImpl_Receive,
4922   XCAST(Send)DirectPlay2AImpl_Send,
4923   XCAST(SetGroupData)DirectPlay2AImpl_SetGroupData,
4924   XCAST(SetGroupName)DirectPlay2AImpl_SetGroupName,
4925   XCAST(SetPlayerData)DirectPlay2AImpl_SetPlayerData,
4926   XCAST(SetPlayerName)DirectPlay2AImpl_SetPlayerName,
4927   XCAST(SetSessionDesc)DirectPlay2AImpl_SetSessionDesc,
4928
4929   DirectPlay3AImpl_AddGroupToGroup,
4930   DirectPlay3AImpl_CreateGroupInGroup,
4931   DirectPlay3AImpl_DeleteGroupFromGroup,
4932   DirectPlay3AImpl_EnumConnections,
4933   DirectPlay3AImpl_EnumGroupsInGroup,
4934   DirectPlay3AImpl_GetGroupConnectionSettings,
4935   DirectPlay3AImpl_InitializeConnection,
4936   DirectPlay3AImpl_SecureOpen,
4937   DirectPlay3AImpl_SendChatMessage,
4938   DirectPlay3AImpl_SetGroupConnectionSettings,
4939   DirectPlay3AImpl_StartSession,
4940   DirectPlay3AImpl_GetGroupFlags,
4941   DirectPlay3AImpl_GetGroupParent,
4942   DirectPlay3AImpl_GetPlayerAccount,
4943   DirectPlay3AImpl_GetPlayerFlags
4944 };
4945 #undef XCAST
4946
4947 /* Note: Hack so we can reuse the old functions without compiler warnings */
4948 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
4949 # define XCAST(fun)     (typeof(directPlay3WVT.fun))
4950 #else
4951 # define XCAST(fun)     (void*)
4952 #endif
4953 static const IDirectPlay3Vtbl directPlay3WVT =
4954 {
4955   XCAST(QueryInterface)DP_QueryInterface,
4956   XCAST(AddRef)DP_AddRef,
4957   XCAST(Release)DP_Release,
4958
4959   XCAST(AddPlayerToGroup)DirectPlay2WImpl_AddPlayerToGroup,
4960   XCAST(Close)DirectPlay2WImpl_Close,
4961   XCAST(CreateGroup)DirectPlay2WImpl_CreateGroup,
4962   XCAST(CreatePlayer)DirectPlay2WImpl_CreatePlayer,
4963   XCAST(DeletePlayerFromGroup)DirectPlay2WImpl_DeletePlayerFromGroup,
4964   XCAST(DestroyGroup)DirectPlay2WImpl_DestroyGroup,
4965   XCAST(DestroyPlayer)DirectPlay2WImpl_DestroyPlayer,
4966   XCAST(EnumGroupPlayers)DirectPlay2WImpl_EnumGroupPlayers,
4967   XCAST(EnumGroups)DirectPlay2WImpl_EnumGroups,
4968   XCAST(EnumPlayers)DirectPlay2WImpl_EnumPlayers,
4969   XCAST(EnumSessions)DirectPlay2WImpl_EnumSessions,
4970   XCAST(GetCaps)DirectPlay2WImpl_GetCaps,
4971   XCAST(GetGroupData)DirectPlay2WImpl_GetGroupData,
4972   XCAST(GetGroupName)DirectPlay2WImpl_GetGroupName,
4973   XCAST(GetMessageCount)DirectPlay2WImpl_GetMessageCount,
4974   XCAST(GetPlayerAddress)DirectPlay2WImpl_GetPlayerAddress,
4975   XCAST(GetPlayerCaps)DirectPlay2WImpl_GetPlayerCaps,
4976   XCAST(GetPlayerData)DirectPlay2WImpl_GetPlayerData,
4977   XCAST(GetPlayerName)DirectPlay2WImpl_GetPlayerName,
4978   XCAST(GetSessionDesc)DirectPlay2WImpl_GetSessionDesc,
4979   XCAST(Initialize)DirectPlay2WImpl_Initialize,
4980   XCAST(Open)DirectPlay2WImpl_Open,
4981   XCAST(Receive)DirectPlay2WImpl_Receive,
4982   XCAST(Send)DirectPlay2WImpl_Send,
4983   XCAST(SetGroupData)DirectPlay2WImpl_SetGroupData,
4984   XCAST(SetGroupName)DirectPlay2WImpl_SetGroupName,
4985   XCAST(SetPlayerData)DirectPlay2WImpl_SetPlayerData,
4986   XCAST(SetPlayerName)DirectPlay2WImpl_SetPlayerName,
4987   XCAST(SetSessionDesc)DirectPlay2WImpl_SetSessionDesc,
4988
4989   DirectPlay3WImpl_AddGroupToGroup,
4990   DirectPlay3WImpl_CreateGroupInGroup,
4991   DirectPlay3WImpl_DeleteGroupFromGroup,
4992   DirectPlay3WImpl_EnumConnections,
4993   DirectPlay3WImpl_EnumGroupsInGroup,
4994   DirectPlay3WImpl_GetGroupConnectionSettings,
4995   DirectPlay3WImpl_InitializeConnection,
4996   DirectPlay3WImpl_SecureOpen,
4997   DirectPlay3WImpl_SendChatMessage,
4998   DirectPlay3WImpl_SetGroupConnectionSettings,
4999   DirectPlay3WImpl_StartSession,
5000   DirectPlay3WImpl_GetGroupFlags,
5001   DirectPlay3WImpl_GetGroupParent,
5002   DirectPlay3WImpl_GetPlayerAccount,
5003   DirectPlay3WImpl_GetPlayerFlags
5004 };
5005 #undef XCAST
5006
5007 /* Note: Hack so we can reuse the old functions without compiler warnings */
5008 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5009 # define XCAST(fun)     (typeof(directPlay4WVT.fun))
5010 #else
5011 # define XCAST(fun)     (void*)
5012 #endif
5013 static const IDirectPlay4Vtbl directPlay4WVT =
5014 {
5015   XCAST(QueryInterface)DP_QueryInterface,
5016   XCAST(AddRef)DP_AddRef,
5017   XCAST(Release)DP_Release,
5018
5019   XCAST(AddPlayerToGroup)DirectPlay2WImpl_AddPlayerToGroup,
5020   XCAST(Close)DirectPlay2WImpl_Close,
5021   XCAST(CreateGroup)DirectPlay2WImpl_CreateGroup,
5022   XCAST(CreatePlayer)DirectPlay2WImpl_CreatePlayer,
5023   XCAST(DeletePlayerFromGroup)DirectPlay2WImpl_DeletePlayerFromGroup,
5024   XCAST(DestroyGroup)DirectPlay2WImpl_DestroyGroup,
5025   XCAST(DestroyPlayer)DirectPlay2WImpl_DestroyPlayer,
5026   XCAST(EnumGroupPlayers)DirectPlay2WImpl_EnumGroupPlayers,
5027   XCAST(EnumGroups)DirectPlay2WImpl_EnumGroups,
5028   XCAST(EnumPlayers)DirectPlay2WImpl_EnumPlayers,
5029   XCAST(EnumSessions)DirectPlay2WImpl_EnumSessions,
5030   XCAST(GetCaps)DirectPlay2WImpl_GetCaps,
5031   XCAST(GetGroupData)DirectPlay2WImpl_GetGroupData,
5032   XCAST(GetGroupName)DirectPlay2WImpl_GetGroupName,
5033   XCAST(GetMessageCount)DirectPlay2WImpl_GetMessageCount,
5034   XCAST(GetPlayerAddress)DirectPlay2WImpl_GetPlayerAddress,
5035   XCAST(GetPlayerCaps)DirectPlay2WImpl_GetPlayerCaps,
5036   XCAST(GetPlayerData)DirectPlay2WImpl_GetPlayerData,
5037   XCAST(GetPlayerName)DirectPlay2WImpl_GetPlayerName,
5038   XCAST(GetSessionDesc)DirectPlay2WImpl_GetSessionDesc,
5039   XCAST(Initialize)DirectPlay2WImpl_Initialize,
5040   XCAST(Open)DirectPlay2WImpl_Open,
5041   XCAST(Receive)DirectPlay2WImpl_Receive,
5042   XCAST(Send)DirectPlay2WImpl_Send,
5043   XCAST(SetGroupData)DirectPlay2WImpl_SetGroupData,
5044   XCAST(SetGroupName)DirectPlay2WImpl_SetGroupName,
5045   XCAST(SetPlayerData)DirectPlay2WImpl_SetPlayerData,
5046   XCAST(SetPlayerName)DirectPlay2WImpl_SetPlayerName,
5047   XCAST(SetSessionDesc)DirectPlay2WImpl_SetSessionDesc,
5048
5049   XCAST(AddGroupToGroup)DirectPlay3WImpl_AddGroupToGroup,
5050   XCAST(CreateGroupInGroup)DirectPlay3WImpl_CreateGroupInGroup,
5051   XCAST(DeleteGroupFromGroup)DirectPlay3WImpl_DeleteGroupFromGroup,
5052   XCAST(EnumConnections)DirectPlay3WImpl_EnumConnections,
5053   XCAST(EnumGroupsInGroup)DirectPlay3WImpl_EnumGroupsInGroup,
5054   XCAST(GetGroupConnectionSettings)DirectPlay3WImpl_GetGroupConnectionSettings,
5055   XCAST(InitializeConnection)DirectPlay3WImpl_InitializeConnection,
5056   XCAST(SecureOpen)DirectPlay3WImpl_SecureOpen,
5057   XCAST(SendChatMessage)DirectPlay3WImpl_SendChatMessage,
5058   XCAST(SetGroupConnectionSettings)DirectPlay3WImpl_SetGroupConnectionSettings,
5059   XCAST(StartSession)DirectPlay3WImpl_StartSession,
5060   XCAST(GetGroupFlags)DirectPlay3WImpl_GetGroupFlags,
5061   XCAST(GetGroupParent)DirectPlay3WImpl_GetGroupParent,
5062   XCAST(GetPlayerAccount)DirectPlay3WImpl_GetPlayerAccount,
5063   XCAST(GetPlayerFlags)DirectPlay3WImpl_GetPlayerFlags,
5064
5065   DirectPlay4WImpl_GetGroupOwner,
5066   DirectPlay4WImpl_SetGroupOwner,
5067   DirectPlay4WImpl_SendEx,
5068   DirectPlay4WImpl_GetMessageQueue,
5069   DirectPlay4WImpl_CancelMessage,
5070   DirectPlay4WImpl_CancelPriority
5071 };
5072 #undef XCAST
5073
5074
5075 /* Note: Hack so we can reuse the old functions without compiler warnings */
5076 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
5077 # define XCAST(fun)     (typeof(directPlay4AVT.fun))
5078 #else
5079 # define XCAST(fun)     (void*)
5080 #endif
5081 static const IDirectPlay4Vtbl directPlay4AVT =
5082 {
5083   XCAST(QueryInterface)DP_QueryInterface,
5084   XCAST(AddRef)DP_AddRef,
5085   XCAST(Release)DP_Release,
5086
5087   XCAST(AddPlayerToGroup)DirectPlay2AImpl_AddPlayerToGroup,
5088   XCAST(Close)DirectPlay2AImpl_Close,
5089   XCAST(CreateGroup)DirectPlay2AImpl_CreateGroup,
5090   XCAST(CreatePlayer)DirectPlay2AImpl_CreatePlayer,
5091   XCAST(DeletePlayerFromGroup)DirectPlay2AImpl_DeletePlayerFromGroup,
5092   XCAST(DestroyGroup)DirectPlay2AImpl_DestroyGroup,
5093   XCAST(DestroyPlayer)DirectPlay2AImpl_DestroyPlayer,
5094   XCAST(EnumGroupPlayers)DirectPlay2AImpl_EnumGroupPlayers,
5095   XCAST(EnumGroups)DirectPlay2AImpl_EnumGroups,
5096   XCAST(EnumPlayers)DirectPlay2AImpl_EnumPlayers,
5097   XCAST(EnumSessions)DirectPlay2AImpl_EnumSessions,
5098   XCAST(GetCaps)DirectPlay2AImpl_GetCaps,
5099   XCAST(GetGroupData)DirectPlay2AImpl_GetGroupData,
5100   XCAST(GetGroupName)DirectPlay2AImpl_GetGroupName,
5101   XCAST(GetMessageCount)DirectPlay2AImpl_GetMessageCount,
5102   XCAST(GetPlayerAddress)DirectPlay2AImpl_GetPlayerAddress,
5103   XCAST(GetPlayerCaps)DirectPlay2AImpl_GetPlayerCaps,
5104   XCAST(GetPlayerData)DirectPlay2AImpl_GetPlayerData,
5105   XCAST(GetPlayerName)DirectPlay2AImpl_GetPlayerName,
5106   XCAST(GetSessionDesc)DirectPlay2AImpl_GetSessionDesc,
5107   XCAST(Initialize)DirectPlay2AImpl_Initialize,
5108   XCAST(Open)DirectPlay2AImpl_Open,
5109   XCAST(Receive)DirectPlay2AImpl_Receive,
5110   XCAST(Send)DirectPlay2AImpl_Send,
5111   XCAST(SetGroupData)DirectPlay2AImpl_SetGroupData,
5112   XCAST(SetGroupName)DirectPlay2AImpl_SetGroupName,
5113   XCAST(SetPlayerData)DirectPlay2AImpl_SetPlayerData,
5114   XCAST(SetPlayerName)DirectPlay2AImpl_SetPlayerName,
5115   XCAST(SetSessionDesc)DirectPlay2AImpl_SetSessionDesc,
5116
5117   XCAST(AddGroupToGroup)DirectPlay3AImpl_AddGroupToGroup,
5118   XCAST(CreateGroupInGroup)DirectPlay3AImpl_CreateGroupInGroup,
5119   XCAST(DeleteGroupFromGroup)DirectPlay3AImpl_DeleteGroupFromGroup,
5120   XCAST(EnumConnections)DirectPlay3AImpl_EnumConnections,
5121   XCAST(EnumGroupsInGroup)DirectPlay3AImpl_EnumGroupsInGroup,
5122   XCAST(GetGroupConnectionSettings)DirectPlay3AImpl_GetGroupConnectionSettings,
5123   XCAST(InitializeConnection)DirectPlay3AImpl_InitializeConnection,
5124   XCAST(SecureOpen)DirectPlay3AImpl_SecureOpen,
5125   XCAST(SendChatMessage)DirectPlay3AImpl_SendChatMessage,
5126   XCAST(SetGroupConnectionSettings)DirectPlay3AImpl_SetGroupConnectionSettings,
5127   XCAST(StartSession)DirectPlay3AImpl_StartSession,
5128   XCAST(GetGroupFlags)DirectPlay3AImpl_GetGroupFlags,
5129   XCAST(GetGroupParent)DirectPlay3AImpl_GetGroupParent,
5130   XCAST(GetPlayerAccount)DirectPlay3AImpl_GetPlayerAccount,
5131   XCAST(GetPlayerFlags)DirectPlay3AImpl_GetPlayerFlags,
5132
5133   DirectPlay4AImpl_GetGroupOwner,
5134   DirectPlay4AImpl_SetGroupOwner,
5135   DirectPlay4AImpl_SendEx,
5136   DirectPlay4AImpl_GetMessageQueue,
5137   DirectPlay4AImpl_CancelMessage,
5138   DirectPlay4AImpl_CancelPriority
5139 };
5140 #undef XCAST
5141
5142 extern
5143 HRESULT DP_GetSPPlayerData( IDirectPlay2Impl* lpDP,
5144                             DPID idPlayer,
5145                             LPVOID* lplpData )
5146 {
5147   lpPlayerList lpPlayer = DP_FindPlayer( lpDP, idPlayer );
5148
5149   if( lpPlayer == NULL )
5150   {
5151     return DPERR_INVALIDPLAYER;
5152   }
5153
5154   *lplpData = lpPlayer->lpPData->lpSPPlayerData;
5155
5156   return DP_OK;
5157 }
5158
5159 extern
5160 HRESULT DP_SetSPPlayerData( IDirectPlay2Impl* lpDP,
5161                             DPID idPlayer,
5162                             LPVOID lpData )
5163 {
5164   lpPlayerList lpPlayer = DP_FindPlayer( lpDP, idPlayer );
5165
5166   if( lpPlayer == NULL )
5167   {
5168     return DPERR_INVALIDPLAYER;
5169   }
5170
5171   lpPlayer->lpPData->lpSPPlayerData = lpData;
5172
5173   return DP_OK;
5174 }
5175
5176 /***************************************************************************
5177  *  DirectPlayEnumerateAW
5178  *
5179  *  The pointer to the structure lpContext will be filled with the
5180  *  appropriate data for each service offered by the OS. These services are
5181  *  not necessarily available on this particular machine but are defined
5182  *  as simple service providers under the "Service Providers" registry key.
5183  *  This structure is then passed to lpEnumCallback for each of the different
5184  *  services.
5185  *
5186  *  This API is useful only for applications written using DirectX3 or
5187  *  worse. It is superseded by IDirectPlay3::EnumConnections which also
5188  *  gives information on the actual connections.
5189  *
5190  * defn of a service provider:
5191  * A dynamic-link library used by DirectPlay to communicate over a network.
5192  * The service provider contains all the network-specific code required
5193  * to send and receive messages. Online services and network operators can
5194  * supply service providers to use specialized hardware, protocols, communications
5195  * media, and network resources.
5196  *
5197  */
5198 static HRESULT DirectPlayEnumerateAW(LPDPENUMDPCALLBACKA lpEnumCallbackA,
5199                                      LPDPENUMDPCALLBACKW lpEnumCallbackW,
5200                                      LPVOID lpContext)
5201 {
5202     HKEY   hkResult;
5203     static const WCHAR searchSubKey[] = {
5204         'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\',
5205         'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\',
5206         'D', 'i', 'r', 'e', 'c', 't', 'P', 'l', 'a', 'y', '\\',
5207         'S', 'e', 'r', 'v', 'i', 'c', 'e', ' ', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 's', 0 };
5208     static const WCHAR guidKey[] = { 'G', 'u', 'i', 'd', 0 };
5209     static const WCHAR descW[] = { 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 'W', 0 };
5210
5211     DWORD  dwIndex;
5212     FILETIME filetime;
5213
5214     char  *descriptionA = NULL;
5215     DWORD max_sizeOfDescriptionA = 0;
5216     WCHAR *descriptionW = NULL;
5217     DWORD max_sizeOfDescriptionW = 0;
5218
5219     if (!lpEnumCallbackA && !lpEnumCallbackW)
5220     {
5221         return DPERR_INVALIDPARAMS;
5222     }
5223
5224     /* Need to loop over the service providers in the registry */
5225     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, searchSubKey,
5226                       0, KEY_READ, &hkResult) != ERROR_SUCCESS)
5227     {
5228         /* Hmmm. Does this mean that there are no service providers? */
5229         ERR(": no service provider key in the registry - check your Wine installation !!!\n");
5230         return DPERR_GENERIC;
5231     }
5232
5233     /* Traverse all the service providers we have available */
5234     dwIndex = 0;
5235     while (1)
5236     {
5237         WCHAR subKeyName[255]; /* 255 is the maximum key size according to MSDN */
5238         DWORD sizeOfSubKeyName = sizeof(subKeyName) / sizeof(WCHAR);
5239         HKEY  hkServiceProvider;
5240         GUID  serviceProviderGUID;
5241         WCHAR guidKeyContent[(2 * 16) + 1 + 6 /* This corresponds to '{....-..-..-..-......}' */ ];
5242         DWORD sizeOfGuidKeyContent = sizeof(guidKeyContent);
5243         LONG  ret_value;
5244
5245         ret_value = RegEnumKeyExW(hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
5246                                   NULL, NULL, NULL, &filetime);
5247         if (ret_value == ERROR_NO_MORE_ITEMS)
5248             break;
5249         else if (ret_value != ERROR_SUCCESS)
5250         {
5251             ERR(": could not enumerate on service provider key.\n");
5252             return DPERR_EXCEPTION;
5253         }
5254         TRACE(" this time through sub-key %s.\n", debugstr_w(subKeyName));
5255
5256         /* Open the key for this service provider */
5257         if (RegOpenKeyExW(hkResult, subKeyName, 0, KEY_READ, &hkServiceProvider) != ERROR_SUCCESS)
5258         {
5259             ERR(": could not open registry key for service provider %s.\n", debugstr_w(subKeyName));
5260             continue;
5261         }
5262
5263         /* Get the GUID from the registry */
5264         if (RegQueryValueExW(hkServiceProvider, guidKey,
5265                              NULL, NULL, (LPBYTE) guidKeyContent, &sizeOfGuidKeyContent) != ERROR_SUCCESS)
5266         {
5267             ERR(": missing GUID registry data member for service provider %s.\n", debugstr_w(subKeyName));
5268             continue;
5269         }
5270         if (sizeOfGuidKeyContent != sizeof(guidKeyContent))
5271         {
5272             ERR(": invalid format for the GUID registry data member for service provider %s (%s).\n", debugstr_w(subKeyName), debugstr_w(guidKeyContent));
5273             continue;
5274         }
5275         CLSIDFromString(guidKeyContent, &serviceProviderGUID );
5276
5277         /* The enumeration will return FALSE if we are not to continue.
5278          *
5279          * Note: on my windows box, major / minor version is 6 / 0 for all service providers
5280          *       and have no relation to any of the two dwReserved1 and dwReserved2 keys.
5281          *       I think that it simply means that they are in-line with DirectX 6.0
5282          */
5283         if (lpEnumCallbackA)
5284         {
5285             DWORD sizeOfDescription = 0;
5286
5287             /* Note that this is the A case of this function, so use the A variant to get the description string */
5288             if (RegQueryValueExA(hkServiceProvider, "DescriptionA",
5289                                  NULL, NULL, NULL, &sizeOfDescription) != ERROR_SUCCESS)
5290             {
5291                 ERR(": missing 'DescriptionA' registry data member for service provider %s.\n", debugstr_w(subKeyName));
5292                 continue;
5293             }
5294             if (sizeOfDescription > max_sizeOfDescriptionA)
5295             {
5296                 HeapFree(GetProcessHeap(), 0, descriptionA);
5297                 max_sizeOfDescriptionA = sizeOfDescription;
5298             }
5299             descriptionA = HeapAlloc(GetProcessHeap(), 0, sizeOfDescription);
5300             RegQueryValueExA(hkServiceProvider, "DescriptionA",
5301                              NULL, NULL, (LPBYTE) descriptionA, &sizeOfDescription);
5302
5303             if (!lpEnumCallbackA(&serviceProviderGUID, descriptionA, 6, 0, lpContext))
5304                 goto end;
5305         }
5306         else
5307         {
5308             DWORD sizeOfDescription = 0;
5309
5310             if (RegQueryValueExW(hkServiceProvider, descW,
5311                                  NULL, NULL, NULL, &sizeOfDescription) != ERROR_SUCCESS)
5312             {
5313                 ERR(": missing 'DescriptionW' registry data member for service provider %s.\n", debugstr_w(subKeyName));
5314                 continue;
5315             }
5316             if (sizeOfDescription > max_sizeOfDescriptionW)
5317             {
5318                 HeapFree(GetProcessHeap(), 0, descriptionW);
5319                 max_sizeOfDescriptionW = sizeOfDescription;
5320             }
5321             descriptionW = HeapAlloc(GetProcessHeap(), 0, sizeOfDescription);
5322             RegQueryValueExW(hkServiceProvider, descW,
5323                              NULL, NULL, (LPBYTE) descriptionW, &sizeOfDescription);
5324
5325             if (!lpEnumCallbackW(&serviceProviderGUID, descriptionW, 6, 0, lpContext))
5326                 goto end;
5327         }
5328
5329       dwIndex++;
5330   }
5331
5332  end:
5333     HeapFree(GetProcessHeap(), 0, descriptionA);
5334     HeapFree(GetProcessHeap(), 0, descriptionW);
5335
5336     return DP_OK;
5337 }
5338
5339 /***************************************************************************
5340  *  DirectPlayEnumerate  [DPLAYX.9]
5341  *  DirectPlayEnumerateA [DPLAYX.2]
5342  */
5343 HRESULT WINAPI DirectPlayEnumerateA(LPDPENUMDPCALLBACKA lpEnumCallback, LPVOID lpContext )
5344 {
5345     TRACE("(%p,%p)\n", lpEnumCallback, lpContext);
5346
5347     return DirectPlayEnumerateAW(lpEnumCallback, NULL, lpContext);
5348 }
5349
5350 /***************************************************************************
5351  *  DirectPlayEnumerateW [DPLAYX.3]
5352  */
5353 HRESULT WINAPI DirectPlayEnumerateW(LPDPENUMDPCALLBACKW lpEnumCallback, LPVOID lpContext )
5354 {
5355     TRACE("(%p,%p)\n", lpEnumCallback, lpContext);
5356
5357     return DirectPlayEnumerateAW(NULL, lpEnumCallback, lpContext);
5358 }
5359
5360 typedef struct tagCreateEnum
5361 {
5362   LPVOID  lpConn;
5363   LPCGUID lpGuid;
5364 } CreateEnumData, *lpCreateEnumData;
5365
5366 /* Find and copy the matching connection for the SP guid */
5367 static BOOL CALLBACK cbDPCreateEnumConnections(
5368     LPCGUID     lpguidSP,
5369     LPVOID      lpConnection,
5370     DWORD       dwConnectionSize,
5371     LPCDPNAME   lpName,
5372     DWORD       dwFlags,
5373     LPVOID      lpContext)
5374 {
5375   lpCreateEnumData lpData = (lpCreateEnumData)lpContext;
5376
5377   if( IsEqualGUID( lpguidSP, lpData->lpGuid ) )
5378   {
5379     TRACE( "Found SP entry with guid %s\n", debugstr_guid(lpData->lpGuid) );
5380
5381     lpData->lpConn = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
5382                                 dwConnectionSize );
5383     CopyMemory( lpData->lpConn, lpConnection, dwConnectionSize );
5384
5385     /* Found the record that we were looking for */
5386     return FALSE;
5387   }
5388
5389   /* Haven't found what were looking for yet */
5390   return TRUE;
5391 }
5392
5393
5394 /***************************************************************************
5395  *  DirectPlayCreate [DPLAYX.1]
5396  *
5397  */
5398 HRESULT WINAPI DirectPlayCreate
5399 ( LPGUID lpGUID, LPDIRECTPLAY2 *lplpDP, IUnknown *pUnk)
5400 {
5401   HRESULT hr;
5402   LPDIRECTPLAY3A lpDP3A;
5403   CreateEnumData cbData;
5404
5405   TRACE( "lpGUID=%s lplpDP=%p pUnk=%p\n", debugstr_guid(lpGUID), lplpDP, pUnk );
5406
5407   if( pUnk != NULL )
5408   {
5409     return CLASS_E_NOAGGREGATION;
5410   }
5411
5412   /* Create an IDirectPlay object. We don't support that so we'll cheat and
5413      give them an IDirectPlay2A object and hope that doesn't cause problems */
5414   if( DP_CreateInterface( &IID_IDirectPlay2A, (LPVOID*)lplpDP ) != DP_OK )
5415   {
5416     return DPERR_UNAVAILABLE;
5417   }
5418
5419   if( IsEqualGUID( &GUID_NULL, lpGUID ) )
5420   {
5421     /* The GUID_NULL means don't bind a service provider. Just return the
5422        interface as is */
5423     return DP_OK;
5424   }
5425
5426   /* Bind the desired service provider since lpGUID is non NULL */
5427   TRACE( "Service Provider binding for %s\n", debugstr_guid(lpGUID) );
5428
5429   /* We're going to use a DP3 interface */
5430   hr = IDirectPlayX_QueryInterface( *lplpDP, &IID_IDirectPlay3A,
5431                                     (LPVOID*)&lpDP3A );
5432   if( FAILED(hr) )
5433   {
5434     ERR( "Failed to get DP3 interface: %s\n", DPLAYX_HresultToString(hr) );
5435     return hr;
5436   }
5437
5438   cbData.lpConn = NULL;
5439   cbData.lpGuid = lpGUID;
5440
5441   /* We were given a service provider, find info about it... */
5442   hr = IDirectPlayX_EnumConnections( lpDP3A, NULL, cbDPCreateEnumConnections,
5443                                      &cbData, DPCONNECTION_DIRECTPLAY );
5444   if( ( FAILED(hr) ) ||
5445       ( cbData.lpConn == NULL )
5446     )
5447   {
5448     ERR( "Failed to get Enum for SP: %s\n", DPLAYX_HresultToString(hr) );
5449     IDirectPlayX_Release( lpDP3A );
5450     return DPERR_UNAVAILABLE;
5451   }
5452
5453   /* Initialize the service provider */
5454   hr = IDirectPlayX_InitializeConnection( lpDP3A, cbData.lpConn, 0 );
5455   if( FAILED(hr) )
5456   {
5457     ERR( "Failed to Initialize SP: %s\n", DPLAYX_HresultToString(hr) );
5458     HeapFree( GetProcessHeap(), 0, cbData.lpConn );
5459     IDirectPlayX_Release( lpDP3A );
5460     return hr;
5461   }
5462
5463   /* Release our version of the interface now that we're done with it */
5464   IDirectPlayX_Release( lpDP3A );
5465   HeapFree( GetProcessHeap(), 0, cbData.lpConn );
5466
5467   return DP_OK;
5468 }