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

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