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