multimedia/dplay.c

   1 /* Direct Play 3 and Direct Play Lobby 2 Implementation
   2  *
   3  * Copyright 1998 - Peter Hunnisett
   4  *
   5  * <presently under construction - contact hunnise@nortelnetworks.com>
   6  *
   7  */
   8 #include "heap.h"
   9 #include "winerror.h"
  10 #include "debug.h"
  11 #include "winnt.h"
  12 #include "winreg.h"
  13 #include "dplay.h"
  14
  15 #include "thread.h"
  16
  17 #define IsEqualGUID(rguid1, rguid2) (!memcmp(rguid1, rguid2, sizeof(GUID)))
  18 #define IsEqualIID(riid1, riid2) IsEqualGUID(riid1, riid2)
  19 #define IsEqualCLSID(rclsid1, rclsid2) IsEqualGUID(rclsid1, rclsid2)
  20
  21 struct IDirectPlayLobby {
  22     LPDIRECTPLAYLOBBY_VTABLE lpVtbl;
  23     ULONG                    ref;
  24     DWORD                    dwConnFlags;
  25     DPSESSIONDESC2           sessionDesc;
  26     DPNAME                   playerName;
  27     GUID                     guidSP;
  28     LPVOID                   lpAddress;
  29     DWORD                    dwAddressSize;
  30 };
  31
  32 struct IDirectPlayLobby2 {
  33     LPDIRECTPLAYLOBBY2_VTABLE lpVtbl;
  34     ULONG                     ref;
  35     DWORD                     dwConnFlags;
  36     DPSESSIONDESC2            lpSessionDesc;
  37     DPNAME                    lpPlayerName;
  38     GUID                      guidSP;
  39     LPVOID                    lpAddress;
  40     DWORD                     dwAddressSize;
  41 };
  42
  43
  44 /* Forward declarations of virtual tables */
  45 static DIRECTPLAYLOBBY_VTABLE  directPlayLobbyAVT;
  46 static DIRECTPLAYLOBBY_VTABLE  directPlayLobbyWVT;
  47 static DIRECTPLAYLOBBY2_VTABLE directPlayLobby2AVT;
  48 static DIRECTPLAYLOBBY2_VTABLE directPlayLobby2WVT;
  49
  50
  51 static DIRECTPLAY2_VTABLE directPlay2AVT;
  52 static DIRECTPLAY3_VTABLE directPlay3VT;
  53
  54
  55
  56
  57 struct IDirectPlay2 {
  58   LPDIRECTPLAY2_VTABLE lpVtbl;
  59   ULONG                ref;
  60 };
  61
  62 struct IDirectPlay3 {
  63   LPDIRECTPLAY3_VTABLE lpVtbl;
  64   ULONG                ref;
  65 };
  66
  67 /* Routine called when starting up the server thread */
  68 DWORD DPLobby_Spawn_Server( LPVOID startData )
  69 {
  70   DPSESSIONDESC2* lpSession = (DPSESSIONDESC2*) startData;
  71   DWORD sessionDwFlags = lpSession->dwFlags;
  72
  73   TRACE( dplay, "spawing thread for lpConn=%p dwFlags=%08lx\n", lpSession, sessionDwFlags );
  74   FIXME( dplay, "thread needs something to do\n" );
  75
  76 /*for(;;)*/
  77   {
  78
  79     /* Check out the connection flags to determine what to do. Ensure we have
  80        no leftover bits in this structure */
  81     if( sessionDwFlags & DPSESSION_CLIENTSERVER )
  82     {
  83        /* This indicates that the application which is requesting the creation
  84         * of this session is going to be the server (application/player)
  85         */
  86        if( sessionDwFlags & DPSESSION_SECURESERVER )
  87        {
  88          sessionDwFlags &= ~DPSESSION_SECURESERVER;
  89        }
  90        sessionDwFlags &= ~DPSESSION_CLIENTSERVER;
  91     }
  92
  93     if( sessionDwFlags & DPSESSION_JOINDISABLED )
  94     {
  95        sessionDwFlags &= ~DPSESSION_JOINDISABLED;
  96     }
  97
  98     if( sessionDwFlags & DPSESSION_KEEPALIVE )
  99     {
 100        sessionDwFlags &= ~DPSESSION_KEEPALIVE;
 101     }
 102
 103     if( sessionDwFlags & DPSESSION_MIGRATEHOST )
 104     {
 105        sessionDwFlags &= ~DPSESSION_MIGRATEHOST;
 106     }
 107
 108     if( sessionDwFlags & DPSESSION_MULTICASTSERVER )
 109     {
 110        sessionDwFlags &= ~DPSESSION_MULTICASTSERVER;
 111     }
 112
 113     if( sessionDwFlags & DPSESSION_NEWPLAYERSDISABLED )
 114     {
 115        sessionDwFlags &= ~DPSESSION_NEWPLAYERSDISABLED;
 116     }
 117
 118     if( sessionDwFlags & DPSESSION_NODATAMESSAGES )
 119     {
 120        sessionDwFlags &= ~DPSESSION_NODATAMESSAGES;
 121     }
 122
 123     if( sessionDwFlags & DPSESSION_NOMESSAGEID )
 124     {
 125        sessionDwFlags &= ~DPSESSION_NOMESSAGEID;
 126     }
 127
 128     if( sessionDwFlags & DPSESSION_PASSWORDREQUIRED )
 129     {
 130        sessionDwFlags &= ~DPSESSION_PASSWORDREQUIRED;
 131     }
 132
 133   }
 134
 135   ExitThread(0);
 136   return 0;
 137 }
 138
 139
 140 /*********************************************************
 141  *
 142  * Direct Play and Direct Play Lobby Interface Implementation
 143  *
 144  *********************************************************/
 145
 146 /* The COM interface for upversioning an interface
 147  * We've been given a GUID (riid) and we need to replace the present
 148  * interface with that of the requested interface.
 149  *
 150  * Snip from some Microsoft document:
 151  * There are four requirements for implementations of QueryInterface (In these
 152  * cases, "must succeed" means "must succeed barring catastrophic failure."):
 153  *
 154  *  * The set of interfaces accessible on an object through
 155  *    IUnknown::QueryInterface must be static, not dynamic. This means that
 156  *    if a call to QueryInterface for a pointer to a specified interface
 157  *    succeeds the first time, it must succeed again, and if it fails the
 158  *    first time, it must fail on all subsequent queries.
 159  *  * It must be symmetric ~W if a client holds a pointer to an interface on
 160  *    an object, and queries for that interface, the call must succeed.
 161  *  * It must be reflexive ~W if a client holding a pointer to one interface
 162  *    queries successfully for another, a query through the obtained pointer
 163  *    for the first interface must succeed.
 164  *  * It must be transitive ~W if a client holding a pointer to one interface
 165  *    queries successfully for a second, and through that pointer queries
 166  *    successfully for a third interface, a query for the first interface
 167  *    through the pointer for the third interface must succeed.
 168  *
 169  *  As you can see, this interface doesn't qualify but will most likely
 170  *  be good enough for the time being.
 171  */
 172 static HRESULT WINAPI IDirectPlayLobbyA_QueryInterface
 173 ( LPDIRECTPLAYLOBBYA this,
 174   REFIID riid,
 175   LPVOID* ppvObj )
 176 {
 177   FIXME( dplay, "(%p)->(%p,%p): stub\n", this, riid, ppvObj );
 178   return E_NOINTERFACE;
 179 }
 180
 181 static HRESULT WINAPI IDirectPlayLobbyW_QueryInterface
 182 ( LPDIRECTPLAYLOBBY this,
 183   REFIID riid,
 184   LPVOID* ppvObj )
 185 {
 186   FIXME( dplay, "(%p)->(%p,%p): stub\n", this, riid, ppvObj );
 187   return E_NOINTERFACE;
 188 }
 189
 190
 191 static HRESULT WINAPI IDirectPlayLobby2A_QueryInterface
 192 ( LPDIRECTPLAYLOBBY2A this,
 193   REFIID riid,
 194   LPVOID* ppvObj )
 195 {
 196   TRACE( dplay, "(%p)->(%p,%p)\n", this, riid, ppvObj );
 197
 198   /* Compare riids. We know this object is a direct play lobby 2A object.
 199      If we are asking about the same type of interface we're fine.
 200    */
 201   if( IsEqualGUID( &IID_IUnknown, riid )  ||
 202       IsEqualGUID( &IID_IDirectPlayLobby2A, riid )
 203     )
 204   {
 205     this->lpVtbl->fnAddRef( this );
 206     *ppvObj = this;
 207     return S_OK;
 208   }
 209   /* They're requesting a unicode version of the interface */
 210   else if( IsEqualGUID( &IID_IDirectPlayLobby2, riid ) )
 211   {
 212      LPDIRECTPLAYLOBBY2 lpDpL = (LPDIRECTPLAYLOBBY2)(*ppvObj);
 213
 214      lpDpL = (LPDIRECTPLAYLOBBY2)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 215                                              sizeof( IDirectPlayLobby2 ) );
 216
 217     if( !lpDpL )
 218     {
 219       return E_NOINTERFACE;
 220     }
 221
 222     lpDpL->lpVtbl = &directPlayLobby2WVT;
 223     lpDpL->ref    = 1;
 224
 225     return S_OK;
 226   }
 227
 228   /* Unexpected interface request! */
 229   *ppvObj = NULL;
 230   return E_NOINTERFACE;
 231 };
 232
 233 static HRESULT WINAPI IDirectPlayLobby2W_QueryInterface
 234 ( LPDIRECTPLAYLOBBY2 this,
 235   REFIID riid,
 236   LPVOID* ppvObj )
 237 {
 238
 239   /* Compare riids. We know this object is a direct play lobby 2 object.
 240      If we are asking about the same type of interface we're fine.
 241    */
 242   if( IsEqualGUID( &IID_IUnknown, riid ) ||
 243       IsEqualGUID( &IID_IDirectPlayLobby2, riid )
 244     )
 245   {
 246     this->lpVtbl->fnAddRef( this );
 247     *ppvObj = this;
 248     return S_OK;
 249   }
 250   else if( IsEqualGUID( &IID_IDirectPlayLobby2A, riid ) )
 251   {
 252      LPDIRECTPLAYLOBBY2A lpDpL = (LPDIRECTPLAYLOBBY2A)(*ppvObj);
 253
 254      lpDpL = (LPDIRECTPLAYLOBBY2A)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 255                                              sizeof( IDirectPlayLobby2A ) );
 256
 257     if( !lpDpL )
 258     {
 259       return E_NOINTERFACE;
 260     }
 261
 262     lpDpL->lpVtbl = &directPlayLobby2AVT;
 263     lpDpL->ref    = 1;
 264
 265     return S_OK;
 266   }
 267
 268   /* Unexpected interface request! */
 269   *ppvObj = NULL;
 270   return E_NOINTERFACE;
 271
 272 };
 273
 274 /*
 275  * Simple procedure. Just increment the reference count to this
 276  * structure and return the new reference count.
 277  */
 278 static ULONG WINAPI IDirectPlayLobby2A_AddRef
 279 ( LPDIRECTPLAYLOBBY2A this )
 280 {
 281   ++(this->ref);
 282   TRACE( dplay,"ref count now %lu\n", this->ref );
 283   return (this->ref);
 284 };
 285
 286 static ULONG WINAPI IDirectPlayLobby2W_AddRef
 287 ( LPDIRECTPLAYLOBBY2 this )
 288 {
 289   return IDirectPlayLobby2A_AddRef( (LPDIRECTPLAYLOBBY2) this );
 290 };
 291
 292
 293 /*
 294  * Simple COM procedure. Decrease the reference count to this object.
 295  * If the object no longer has any reference counts, free up the associated
 296  * memory.
 297  */
 298 static ULONG WINAPI IDirectPlayLobby2A_Release
 299 ( LPDIRECTPLAYLOBBY2A this )
 300 {
 301   TRACE( dplay, "ref count decremeneted from %lu\n", this->ref );
 302
 303   this->ref--;
 304
 305   /* Deallocate if this is the last reference to the object */
 306   if( !(this->ref) )
 307   {
 308     FIXME( dplay, "memory leak\n" );
 309     /* Implement memory deallocation */
 310
 311     HeapFree( GetProcessHeap(), 0, this );
 312
 313     return 0;
 314   }
 315
 316   return this->ref;
 317 };
 318
 319 static ULONG WINAPI IDirectPlayLobby2W_Release
 320 ( LPDIRECTPLAYLOBBY2 this )
 321 {
 322   return IDirectPlayLobby2A_Release( (LPDIRECTPLAYLOBBY2A) this );
 323 };
 324
 325
 326 /********************************************************************
 327  *
 328  * Connects an application to the session specified by the DPLCONNECTION
 329  * structure currently stored with the DirectPlayLobby object.
 330  *
 331  * Returns a IDirectPlay interface.
 332  *
 333  */
 334 static HRESULT WINAPI IDirectPlayLobby2A_Connect
 335 ( LPDIRECTPLAYLOBBY2A this,
 336   DWORD dwFlags,
 337   LPDIRECTPLAY2* lplpDP,
 338   IUnknown* pUnk)
 339 {
 340   FIXME( dplay, ": dwFlags=%08lx %p %p stub\n", dwFlags, lplpDP, pUnk );
 341   return DPERR_OUTOFMEMORY;
 342 };
 343
 344 static HRESULT WINAPI IDirectPlayLobby2W_Connect
 345 ( LPDIRECTPLAYLOBBY2 this,
 346   DWORD dwFlags,
 347   LPDIRECTPLAY2* lplpDP,
 348   IUnknown* pUnk)
 349 {
 350   LPDIRECTPLAY2* directPlay2W;
 351   HRESULT        createRC;
 352
 353   FIXME( dplay, ": dwFlags=%08lx %p %p stub\n", dwFlags, lplpDP, pUnk );
 354
 355   if( dwFlags )
 356   {
 357      return DPERR_INVALIDPARAMS;
 358   }
 359
 360   if( ( createRC = DirectPlayCreate( &IID_IDirectPlayLobby2, lplpDP, pUnk ) ) != DP_OK )
 361   {
 362      ERR( dplay, "error creating Direct Play 2 (W) interface. Return Code = %ld.\n", createRC );
 363      return createRC;
 364   }
 365
 366   /* This should invoke IDirectPlay3::InitializeConnection IDirectPlay3::Open */
 367   directPlay2W = lplpDP;
 368
 369
 370
 371 #if 0
 372   /* All the stuff below this is WRONG! */
 373   if( this->lpSession->dwFlags == DPLCONNECTION_CREATESESSION )
 374   {
 375     DWORD threadIdSink;
 376
 377     /* Spawn a thread to deal with all of this and to handle the incomming requests */
 378     threadIdSink = CreateThread( NULL, 0, &DPLobby_Spawn_Server,
 379                                 (LPVOID)this->lpSession->lpConn->lpSessionDesc, 0, &threadIdSink );
 380
 381   }
 382   else if ( this->lpSession->dwFlags == DPLCONNECTION_JOINSESSION )
 383   {
 384     /* Let's search for a matching session */
 385     FIXME( dplay, "joining session not yet supported.\n");
 386     return DPERR_OUTOFMEMORY;
 387   }
 388   else /* Unknown type of connection request */
 389   {
 390      ERR( dplay, ": Unknown connection request lpConn->dwFlags=%08lx\n",
 391           lpConn->dwFlags );
 392
 393      return DPERR_OUTOFMEMORY;
 394   }
 395
 396   /* This does the work of the following methods...
 397      IDirectPlay3::InitializeConnection,
 398      IDirectPlay3::EnumSessions,
 399      IDirectPlay3::Open
 400    */
 401
 402
 403 #endif
 404
 405   return DP_OK;
 406
 407 };
 408
 409 /********************************************************************
 410  *
 411  * Creates a DirectPlay Address, given a service provider-specific network
 412  * address.
 413  * Returns an address contains the globally unique identifier
 414  * (GUID) of the service provider and data that the service provider can
 415  * interpret as a network address.
 416  *
 417  */
 418 static HRESULT WINAPI IDirectPlayLobby2A_CreateAddress
 419 ( LPDIRECTPLAYLOBBY2A this,
 420   REFGUID guidSP,
 421   REFGUID guidDataType,
 422   LPCVOID lpData,
 423   DWORD dwDataSize,
 424   LPVOID lpAddress,
 425   LPDWORD lpdwAddressSize )
 426 {
 427   FIXME( dplay, ":stub\n");
 428   return DPERR_OUTOFMEMORY;
 429 };
 430
 431 static HRESULT WINAPI IDirectPlayLobby2W_CreateAddress
 432 ( LPDIRECTPLAYLOBBY2 this,
 433   REFGUID guidSP,
 434   REFGUID guidDataType,
 435   LPCVOID lpData,
 436   DWORD dwDataSize,
 437   LPVOID lpAddress,
 438   LPDWORD lpdwAddressSize )
 439 {
 440   FIXME( dplay, ":stub\n");
 441   return DPERR_OUTOFMEMORY;
 442 };
 443
 444
 445 /********************************************************************
 446  *
 447  * Parses out chunks from the DirectPlay Address buffer by calling the
 448  * given callback function, with lpContext, for each of the chunks.
 449  *
 450  */
 451 static HRESULT WINAPI IDirectPlayLobby2A_EnumAddress
 452 ( LPDIRECTPLAYLOBBY2A this,
 453   LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
 454   LPCVOID lpAddress,
 455   DWORD dwAddressSize,
 456   LPVOID lpContext )
 457 {
 458   FIXME( dplay, ":stub\n");
 459   return DPERR_OUTOFMEMORY;
 460 };
 461
 462 static HRESULT WINAPI IDirectPlayLobby2W_EnumAddress
 463 ( LPDIRECTPLAYLOBBY2 this,
 464   LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
 465   LPCVOID lpAddress,
 466   DWORD dwAddressSize,
 467   LPVOID lpContext )
 468 {
 469   FIXME( dplay, ":stub\n");
 470   return DPERR_OUTOFMEMORY;
 471 };
 472
 473 /********************************************************************
 474  *
 475  * Enumerates all the address types that a given service provider needs to
 476  * build the DirectPlay Address.
 477  *
 478  */
 479 static HRESULT WINAPI IDirectPlayLobbyA_EnumAddressTypes
 480 ( LPDIRECTPLAYLOBBYA this,
 481   LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
 482   REFGUID guidSP,
 483   LPVOID lpContext,
 484   DWORD dwFlags )
 485 {
 486   FIXME( dplay, ":stub\n");
 487   return DPERR_OUTOFMEMORY;
 488 };
 489
 490 static HRESULT WINAPI IDirectPlayLobby2A_EnumAddressTypes
 491 ( LPDIRECTPLAYLOBBY2A this,
 492   LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
 493   REFGUID guidSP,
 494   LPVOID lpContext,
 495   DWORD dwFlags )
 496 {
 497   return IDirectPlayLobbyA_EnumAddressTypes( (LPDIRECTPLAYLOBBYA)this, lpEnumAddressTypeCallback,
 498                                              guidSP, lpContext, dwFlags );
 499 };
 500
 501 static HRESULT WINAPI IDirectPlayLobby2W_EnumAddressTypes
 502 ( LPDIRECTPLAYLOBBY2 this,
 503   LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
 504   REFGUID guidSP,
 505   LPVOID lpContext,
 506   DWORD dwFlags )
 507 {
 508   FIXME( dplay, ":stub\n");
 509   return DPERR_OUTOFMEMORY;
 510 };
 511
 512 /********************************************************************
 513  *
 514  * Enumerates what applications are registered with DirectPlay by
 515  * invoking the callback function with lpContext.
 516  *
 517  */
 518 static HRESULT WINAPI IDirectPlayLobbyW_EnumLocalApplications
 519 ( LPDIRECTPLAYLOBBY this,
 520   LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
 521   LPVOID lpContext,
 522   DWORD dwFlags )
 523 {
 524   FIXME( dplay, ":stub\n");
 525   return DPERR_OUTOFMEMORY;
 526 };
 527
 528 static HRESULT WINAPI IDirectPlayLobby2W_EnumLocalApplications
 529 ( LPDIRECTPLAYLOBBY2 this,
 530   LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
 531   LPVOID lpContext,
 532   DWORD dwFlags )
 533 {
 534   return IDirectPlayLobbyW_EnumLocalApplications( (LPDIRECTPLAYLOBBY)this, a,
 535                                                   lpContext, dwFlags );
 536 };
 537
 538 static HRESULT WINAPI IDirectPlayLobbyA_EnumLocalApplications
 539 ( LPDIRECTPLAYLOBBYA this,
 540   LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
 541   LPVOID lpContext,
 542   DWORD dwFlags )
 543 {
 544   FIXME( dplay, ":stub\n");
 545   return DPERR_OUTOFMEMORY;
 546 };
 547
 548 static HRESULT WINAPI IDirectPlayLobby2A_EnumLocalApplications
 549 ( LPDIRECTPLAYLOBBY2A this,
 550   LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
 551   LPVOID lpContext,
 552   DWORD dwFlags )
 553 {
 554   return IDirectPlayLobbyA_EnumLocalApplications( (LPDIRECTPLAYLOBBYA)this, a,
 555                                                   lpContext, dwFlags );
 556 };
 557
 558
 559 /********************************************************************
 560  *
 561  * Retrieves the DPLCONNECTION structure that contains all the information
 562  * needed to start and connect an application. This was generated using
 563  * either the RunApplication or SetConnectionSettings methods.
 564  *
 565  * NOTES: If lpData is NULL then just return lpdwDataSize. This allows
 566  *        the data structure to be allocated by our caller which can then
 567  *        call this procedure/method again with a valid data pointer.
 568  */
 569 static HRESULT WINAPI IDirectPlayLobbyA_GetConnectionSettings
 570 ( LPDIRECTPLAYLOBBYA this,
 571   DWORD dwAppID,
 572   LPVOID lpData,
 573   LPDWORD lpdwDataSize )
 574 {
 575   LPDPLCONNECTION lpDplConnection;
 576
 577   FIXME( dplay, ": semi stub (%p)->(0x%08lx,%p,%p)\n", this, dwAppID, lpData, lpdwDataSize );
 578
 579   /* Application is requesting us to give the required size */
 580   if ( !lpData )
 581   {
 582     /* Let's check the size of the buffer that the application has allocated */
 583     if( *lpdwDataSize >= sizeof( DPLCONNECTION ) )
 584     {
 585       return DP_OK;
 586     }
 587     else
 588     {
 589       *lpdwDataSize = sizeof( DPLCONNECTION );
 590       return DPERR_BUFFERTOOSMALL;
 591     }
 592   }
 593
 594   /* Fill in the fields - let them just use the ptrs */
 595   lpDplConnection = (LPDPLCONNECTION)lpData;
 596
 597   /* Make sure we were given the right size */
 598   if( lpDplConnection->dwSize < sizeof( DPLCONNECTION ) )
 599   {
 600      ERR( dplay, "bad passed size 0x%08lx.\n", lpDplConnection->dwSize );
 601      return DPERR_INVALIDPARAMS;
 602   }
 603
 604   /* Copy everything we've got into here */
 605   /* Need to actually store the stuff here. Check if we've already allocated each field first. */
 606   lpDplConnection->dwFlags = this->dwConnFlags;
 607
 608   /* Copy LPDPSESSIONDESC2 struct */
 609   lpDplConnection->lpSessionDesc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( this->sessionDesc ) );
 610   memcpy( lpDplConnection, &(this->sessionDesc), sizeof( this->sessionDesc ) );
 611
 612   if( this->sessionDesc.sess.lpszSessionName )
 613   {
 614     lpDplConnection->lpSessionDesc->sess.lpszSessionName =
 615       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, this->sessionDesc.sess.lpszSessionName );
 616   }
 617
 618   if( this->sessionDesc.pass.lpszPassword )
 619   {
 620     lpDplConnection->lpSessionDesc->pass.lpszPassword =
 621       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, this->sessionDesc.pass.lpszPassword );
 622   }
 623
 624   /* I don't know what to use the reserved for. We'll set it to 0 just for fun */
 625   this->sessionDesc.dwReserved1 = this->sessionDesc.dwReserved2 = 0;
 626
 627   /* Copy DPNAME struct - seems to be optional - check for existance first */
 628   lpDplConnection->lpPlayerName = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( this->playerName ) );
 629   memcpy( lpDplConnection->lpPlayerName, &(this->playerName), sizeof( this->playerName ) );
 630
 631   if( this->playerName.psn.lpszShortName )
 632   {
 633     lpDplConnection->lpPlayerName->psn.lpszShortName =
 634       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, this->playerName.psn.lpszShortName );
 635   }
 636
 637   if( this->playerName.pln.lpszLongName )
 638   {
 639     lpDplConnection->lpPlayerName->pln.lpszLongName =
 640       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, this->playerName.pln.lpszLongName );
 641   }
 642
 643
 644
 645   memcpy( &(lpDplConnection->guidSP), &(this->guidSP), sizeof( this->guidSP ) );
 646
 647   lpDplConnection->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, this->dwAddressSize );
 648   memcpy( lpDplConnection->lpAddress, this->lpAddress, this->dwAddressSize );
 649
 650   lpDplConnection->dwAddressSize = this->dwAddressSize;
 651
 652   return DP_OK;
 653 }
 654
 655 static HRESULT WINAPI IDirectPlayLobby2A_GetConnectionSettings
 656 ( LPDIRECTPLAYLOBBY2A this,
 657   DWORD dwAppID,
 658   LPVOID lpData,
 659   LPDWORD lpdwDataSize )
 660 {
 661   return IDirectPlayLobbyA_GetConnectionSettings( (LPDIRECTPLAYLOBBYA)this,
 662                                                   dwAppID, lpData, lpdwDataSize );
 663 }
 664
 665 static HRESULT WINAPI IDirectPlayLobbyW_GetConnectionSettings
 666 ( LPDIRECTPLAYLOBBY this,
 667   DWORD dwAppID,
 668   LPVOID lpData,
 669   LPDWORD lpdwDataSize )
 670 {
 671   FIXME( dplay, ":semi stub %p %08lx %p %p \n", this, dwAppID, lpData, lpdwDataSize );
 672
 673   /* Application is requesting us to give the required size */
 674   if ( !lpData )
 675   {
 676     /* Let's check the size of the buffer that the application has allocated */
 677     if( *lpdwDataSize >= sizeof( DPLCONNECTION ) )
 678     {
 679       return DP_OK;
 680     }
 681     else
 682     {
 683       *lpdwDataSize = sizeof( DPLCONNECTION );
 684       return DPERR_BUFFERTOOSMALL;
 685     }
 686   }
 687
 688   /* Fill in the fields - let them just use the ptrs */
 689   FIXME( dplay, "stub\n" );
 690
 691   return DP_OK;
 692 };
 693
 694 static HRESULT WINAPI IDirectPlayLobby2W_GetConnectionSettings
 695 ( LPDIRECTPLAYLOBBY2 this,
 696   DWORD dwAppID,
 697   LPVOID lpData,
 698   LPDWORD lpdwDataSize )
 699 {
 700   return IDirectPlayLobbyW_GetConnectionSettings( (LPDIRECTPLAYLOBBY)this,
 701                                                   dwAppID, lpData, lpdwDataSize );
 702 }
 703
 704 /********************************************************************
 705  *
 706  * Retrieves the message sent between a lobby client and a DirectPlay
 707  * application. All messages are queued until received.
 708  *
 709  */
 710 static HRESULT WINAPI IDirectPlayLobbyA_ReceiveLobbyMessage
 711 ( LPDIRECTPLAYLOBBYA this,
 712   DWORD dwFlags,
 713   DWORD dwAppID,
 714   LPDWORD lpdwMessageFlags,
 715   LPVOID lpData,
 716   LPDWORD lpdwDataSize )
 717 {
 718   FIXME( dplay, ":stub %p %08lx %08lx %p %p %p\n", this, dwFlags, dwAppID, lpdwMessageFlags, lpData,
 719          lpdwDataSize );
 720   return DPERR_OUTOFMEMORY;
 721 };
 722
 723 static HRESULT WINAPI IDirectPlayLobby2A_ReceiveLobbyMessage
 724 ( LPDIRECTPLAYLOBBY2A this,
 725   DWORD dwFlags,
 726   DWORD dwAppID,
 727   LPDWORD lpdwMessageFlags,
 728   LPVOID lpData,
 729   LPDWORD lpdwDataSize )
 730 {
 731   return IDirectPlayLobbyA_ReceiveLobbyMessage( (LPDIRECTPLAYLOBBYA)this, dwFlags, dwAppID,
 732                                                  lpdwMessageFlags, lpData, lpdwDataSize );
 733 };
 734
 735
 736 static HRESULT WINAPI IDirectPlayLobbyW_ReceiveLobbyMessage
 737 ( LPDIRECTPLAYLOBBY this,
 738   DWORD dwFlags,
 739   DWORD dwAppID,
 740   LPDWORD lpdwMessageFlags,
 741   LPVOID lpData,
 742   LPDWORD lpdwDataSize )
 743 {
 744   FIXME( dplay, ":stub %p %08lx %08lx %p %p %p\n", this, dwFlags, dwAppID, lpdwMessageFlags, lpData,
 745          lpdwDataSize );
 746   return DPERR_OUTOFMEMORY;
 747 };
 748
 749 static HRESULT WINAPI IDirectPlayLobby2W_ReceiveLobbyMessage
 750 ( LPDIRECTPLAYLOBBY2 this,
 751   DWORD dwFlags,
 752   DWORD dwAppID,
 753   LPDWORD lpdwMessageFlags,
 754   LPVOID lpData,
 755   LPDWORD lpdwDataSize )
 756 {
 757   return IDirectPlayLobbyW_ReceiveLobbyMessage( (LPDIRECTPLAYLOBBY)this, dwFlags, dwAppID,
 758                                                  lpdwMessageFlags, lpData, lpdwDataSize );
 759 };
 760
 761 /********************************************************************
 762  *
 763  * Starts an application and passes to it all the information to
 764  * connect to a session.
 765  *
 766  */
 767 static HRESULT WINAPI IDirectPlayLobbyA_RunApplication
 768 ( LPDIRECTPLAYLOBBYA this,
 769   DWORD dwFlags,
 770   LPDWORD lpdwAppID,
 771   LPDPLCONNECTION lpConn,
 772   HANDLE32 hReceiveEvent )
 773 {
 774   FIXME( dplay, ":stub\n");
 775   return DPERR_OUTOFMEMORY;
 776 };
 777
 778 static HRESULT WINAPI IDirectPlayLobby2A_RunApplication
 779 ( LPDIRECTPLAYLOBBY2A this,
 780   DWORD dwFlags,
 781   LPDWORD lpdwAppID,
 782   LPDPLCONNECTION lpConn,
 783   HANDLE32 hReceiveEvent )
 784 {
 785   return IDirectPlayLobbyA_RunApplication( (LPDIRECTPLAYLOBBYA)this, dwFlags,
 786                                            lpdwAppID, lpConn, hReceiveEvent );
 787 };
 788
 789 static HRESULT WINAPI IDirectPlayLobbyW_RunApplication
 790 ( LPDIRECTPLAYLOBBY this,
 791   DWORD dwFlags,
 792   LPDWORD lpdwAppID,
 793   LPDPLCONNECTION lpConn,
 794   HANDLE32 hReceiveEvent )
 795 {
 796   FIXME( dplay, ":stub\n");
 797   return DPERR_OUTOFMEMORY;
 798 };
 799
 800 static HRESULT WINAPI IDirectPlayLobby2W_RunApplication
 801 ( LPDIRECTPLAYLOBBY2 this,
 802   DWORD dwFlags,
 803   LPDWORD lpdwAppID,
 804   LPDPLCONNECTION lpConn,
 805   HANDLE32 hReceiveEvent )
 806 {
 807   return IDirectPlayLobbyW_RunApplication( (LPDIRECTPLAYLOBBY)this, dwFlags,
 808                                            lpdwAppID, lpConn, hReceiveEvent );
 809 };
 810
 811
 812 /********************************************************************
 813  *
 814  * Sends a message between the application and the lobby client.
 815  * All messages are queued until received.
 816  *
 817  */
 818 static HRESULT WINAPI IDirectPlayLobbyA_SendLobbyMessage
 819 ( LPDIRECTPLAYLOBBYA this,
 820   DWORD dwFlags,
 821   DWORD dwAppID,
 822   LPVOID lpData,
 823   DWORD dwDataSize )
 824 {
 825   FIXME( dplay, ":stub\n");
 826   return DPERR_OUTOFMEMORY;
 827 };
 828
 829 static HRESULT WINAPI IDirectPlayLobby2A_SendLobbyMessage
 830 ( LPDIRECTPLAYLOBBY2A this,
 831   DWORD dwFlags,
 832   DWORD dwAppID,
 833   LPVOID lpData,
 834   DWORD dwDataSize )
 835 {
 836   return IDirectPlayLobbyA_SendLobbyMessage( (LPDIRECTPLAYLOBBYA)this, dwFlags,
 837                                              dwAppID, lpData, dwDataSize );
 838 };
 839
 840
 841 static HRESULT WINAPI IDirectPlayLobbyW_SendLobbyMessage
 842 ( LPDIRECTPLAYLOBBY this,
 843   DWORD dwFlags,
 844   DWORD dwAppID,
 845   LPVOID lpData,
 846   DWORD dwDataSize )
 847 {
 848   FIXME( dplay, ":stub\n");
 849   return DPERR_OUTOFMEMORY;
 850 };
 851
 852 static HRESULT WINAPI IDirectPlayLobby2W_SendLobbyMessage
 853 ( LPDIRECTPLAYLOBBY2 this,
 854   DWORD dwFlags,
 855   DWORD dwAppID,
 856   LPVOID lpData,
 857   DWORD dwDataSize )
 858 {
 859   return IDirectPlayLobbyW_SendLobbyMessage( (LPDIRECTPLAYLOBBY)this, dwFlags,
 860                                               dwAppID, lpData, dwDataSize );
 861 };
 862
 863 /********************************************************************
 864  *
 865  * Modifies the DPLCONNECTION structure to contain all information
 866  * needed to start and connect an application.
 867  *
 868  */
 869 static HRESULT WINAPI IDirectPlayLobbyW_SetConnectionSettings
 870 ( LPDIRECTPLAYLOBBY this,
 871   DWORD dwFlags,
 872   DWORD dwAppID,
 873   LPDPLCONNECTION lpConn )
 874 {
 875   TRACE( dplay, ": this=%p, dwFlags=%08lx, dwAppId=%08lx, lpConn=%p\n",
 876          this, dwFlags, dwAppID, lpConn );
 877
 878   /* Paramater check */
 879   if( dwFlags || !this || !lpConn )
 880   {
 881     ERR( dplay, "invalid parameters.\n");
 882     return DPERR_INVALIDPARAMS;
 883   }
 884
 885   /* See if there is a connection associated with this request.
 886    * dwAppID == 0 indicates that this request isn't associated with a connection.
 887    */
 888   if( dwAppID )
 889   {
 890      FIXME( dplay, ": Connection dwAppID=%08lx given. Not implemented yet.\n",
 891             dwAppID );
 892
 893      /* Need to add a check for this application Id...*/
 894      return DPERR_NOTLOBBIED;
 895   }
 896
 897   if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
 898   {
 899     ERR( dplay, ": old/new DPLCONNECTION type? Size=%08lx vs. expected=%ul bytes\n",
 900          lpConn->dwSize, sizeof( DPLCONNECTION ) );
 901     return DPERR_INVALIDPARAMS;
 902   }
 903
 904   /* Need to investigate the lpConn->lpSessionDesc to figure out
 905    * what type of session we need to join/create.
 906    */
 907   if(  (!lpConn->lpSessionDesc ) ||
 908        ( lpConn->lpSessionDesc->dwSize != sizeof( DPSESSIONDESC2 ) )
 909     )
 910   {
 911     ERR( dplay, "DPSESSIONDESC passed in? Size=%08lx vs. expected=%ul bytes\n",
 912          lpConn->lpSessionDesc->dwSize, sizeof( DPSESSIONDESC2 ) );
 913     return DPERR_INVALIDPARAMS;
 914   }
 915
 916   /* Need to actually store the stuff here. Check if we've already allocated each field first. */
 917   this->dwConnFlags = lpConn->dwFlags;
 918
 919   /* Copy LPDPSESSIONDESC2 struct - this is required */
 920   memcpy( &(this->sessionDesc), lpConn->lpSessionDesc, sizeof( *(lpConn->lpSessionDesc) ) );
 921
 922   if( lpConn->lpSessionDesc->sess.lpszSessionName )
 923     this->sessionDesc.sess.lpszSessionName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->sess.lpszSessionName );
 924   else
 925     this->sessionDesc.sess.lpszSessionName = NULL;
 926
 927   if( lpConn->lpSessionDesc->pass.lpszPassword )
 928     this->sessionDesc.pass.lpszPassword = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->pass.lpszPassword );
 929   else
 930     this->sessionDesc.pass.lpszPassword = NULL;
 931
 932   /* I don't know what to use the reserved for ... */
 933   this->sessionDesc.dwReserved1 = this->sessionDesc.dwReserved2 = 0;
 934
 935   /* Copy DPNAME struct - seems to be optional - check for existance first */
 936   if( lpConn->lpPlayerName )
 937   {
 938      memcpy( &(this->playerName), lpConn->lpPlayerName, sizeof( *lpConn->lpPlayerName ) );
 939
 940      if( lpConn->lpPlayerName->psn.lpszShortName )
 941        this->playerName.psn.lpszShortName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->psn.lpszShortName );
 942
 943      if( lpConn->lpPlayerName->pln.lpszLongName )
 944        this->playerName.pln.lpszLongName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->pln.lpszLongName );
 945
 946   }
 947
 948   memcpy( &(this->guidSP), &(lpConn->guidSP), sizeof( lpConn->guidSP ) );
 949
 950   this->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->dwAddressSize );
 951   memcpy( this->lpAddress, lpConn->lpAddress, lpConn->dwAddressSize );
 952
 953   this->dwAddressSize = lpConn->dwAddressSize;
 954
 955   return DP_OK;
 956 };
 957
 958 static HRESULT WINAPI IDirectPlayLobby2W_SetConnectionSettings
 959 ( LPDIRECTPLAYLOBBY2 this,
 960   DWORD dwFlags,
 961   DWORD dwAppID,
 962   LPDPLCONNECTION lpConn )
 963 {
 964   return IDirectPlayLobbyW_SetConnectionSettings( (LPDIRECTPLAYLOBBY)this,
 965                                                   dwFlags, dwAppID, lpConn );
 966 }
 967
 968 static HRESULT WINAPI IDirectPlayLobbyA_SetConnectionSettings
 969 ( LPDIRECTPLAYLOBBYA this,
 970   DWORD dwFlags,
 971   DWORD dwAppID,
 972   LPDPLCONNECTION lpConn )
 973 {
 974   FIXME( dplay, ": this=%p, dwFlags=%08lx, dwAppId=%08lx, lpConn=%p: stub\n",
 975          this, dwFlags, dwAppID, lpConn );
 976   return DPERR_OUTOFMEMORY;
 977 }
 978
 979 static HRESULT WINAPI IDirectPlayLobby2A_SetConnectionSettings
 980 ( LPDIRECTPLAYLOBBY2A this,
 981   DWORD dwFlags,
 982   DWORD dwAppID,
 983   LPDPLCONNECTION lpConn )
 984 {
 985   return IDirectPlayLobbyA_SetConnectionSettings( (LPDIRECTPLAYLOBBYA)this,
 986                                                   dwFlags, dwAppID, lpConn );
 987 };
 988
 989 /********************************************************************
 990  *
 991  * Registers an event that will be set when a lobby message is received.
 992  *
 993  */
 994 static HRESULT WINAPI IDirectPlayLobbyA_SetLobbyMessageEvent
 995 ( LPDIRECTPLAYLOBBYA this,
 996   DWORD dwFlags,
 997   DWORD dwAppID,
 998   HANDLE32 hReceiveEvent )
 999 {
1000   FIXME( dplay, ":stub\n");
1001   return DPERR_OUTOFMEMORY;
1002 };
1003
1004 static HRESULT WINAPI IDirectPlayLobby2A_SetLobbyMessageEvent
1005 ( LPDIRECTPLAYLOBBY2A this,
1006   DWORD dwFlags,
1007   DWORD dwAppID,
1008   HANDLE32 hReceiveEvent )
1009 {
1010   return IDirectPlayLobbyA_SetLobbyMessageEvent( (LPDIRECTPLAYLOBBYA)this, dwFlags,
1011                                                  dwAppID, hReceiveEvent );
1012 };
1013
1014 static HRESULT WINAPI IDirectPlayLobbyW_SetLobbyMessageEvent
1015 ( LPDIRECTPLAYLOBBY this,
1016   DWORD dwFlags,
1017   DWORD dwAppID,
1018   HANDLE32 hReceiveEvent )
1019 {
1020   FIXME( dplay, ":stub\n");
1021   return DPERR_OUTOFMEMORY;
1022 };
1023
1024 static HRESULT WINAPI IDirectPlayLobby2W_SetLobbyMessageEvent
1025 ( LPDIRECTPLAYLOBBY2 this,
1026   DWORD dwFlags,
1027   DWORD dwAppID,
1028   HANDLE32 hReceiveEvent )
1029 {
1030   return IDirectPlayLobbyW_SetLobbyMessageEvent( (LPDIRECTPLAYLOBBY)this, dwFlags,
1031                                                  dwAppID, hReceiveEvent );
1032 };
1033
1034
1035 /********************************************************************
1036  *
1037  * Registers an event that will be set when a lobby message is received.
1038  *
1039  */
1040 static HRESULT WINAPI IDirectPlayLobby2W_CreateCompoundAddress
1041 ( LPDIRECTPLAYLOBBY2 this,
1042   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1043   DWORD dwElementCount,
1044   LPVOID lpAddress,
1045   LPDWORD lpdwAddressSize )
1046 {
1047   FIXME( dplay, ":stub\n");
1048   return DPERR_OUTOFMEMORY;
1049 };
1050
1051 static HRESULT WINAPI IDirectPlayLobby2A_CreateCompoundAddress
1052 ( LPDIRECTPLAYLOBBY2A this,
1053   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1054   DWORD dwElementCount,
1055   LPVOID lpAddress,
1056   LPDWORD lpdwAddressSize )
1057 {
1058   FIXME( dplay, ":stub\n");
1059   return DPERR_OUTOFMEMORY;
1060 };
1061
1062
1063 /* Direct Play Lobby 1 (ascii) Virtual Table for methods */
1064 /* All lobby 1 methods are exactly the same except QueryInterface */
1065 static struct tagLPDIRECTPLAYLOBBY_VTABLE directPlayLobbyAVT = {
1066   IDirectPlayLobbyA_QueryInterface,
1067   (void*)IDirectPlayLobby2A_AddRef,
1068   (void*)IDirectPlayLobby2A_Release,
1069   (void*)IDirectPlayLobby2A_Connect,
1070   (void*)IDirectPlayLobby2A_CreateAddress,
1071   (void*)IDirectPlayLobby2A_EnumAddress,
1072   (void*)IDirectPlayLobby2A_EnumAddressTypes,
1073   (void*)IDirectPlayLobby2A_EnumLocalApplications,
1074   (void*)IDirectPlayLobby2A_GetConnectionSettings,
1075   (void*)IDirectPlayLobby2A_ReceiveLobbyMessage,
1076   (void*)IDirectPlayLobby2A_RunApplication,
1077   (void*)IDirectPlayLobby2A_SendLobbyMessage,
1078   (void*)IDirectPlayLobby2A_SetConnectionSettings,
1079   (void*)IDirectPlayLobby2A_SetLobbyMessageEvent
1080 };
1081
1082 /* Direct Play Lobby 1 (unicode) Virtual Table for methods */
1083 static struct tagLPDIRECTPLAYLOBBY_VTABLE directPlayLobbyWVT = {
1084   IDirectPlayLobbyW_QueryInterface,
1085   (void*)IDirectPlayLobby2W_AddRef,
1086   (void*)IDirectPlayLobby2W_Release,
1087   (void*)IDirectPlayLobby2W_Connect,
1088   (void*)IDirectPlayLobby2W_CreateAddress,
1089   (void*)IDirectPlayLobby2W_EnumAddress,
1090   (void*)IDirectPlayLobby2W_EnumAddressTypes,
1091   (void*)IDirectPlayLobby2W_EnumLocalApplications,
1092   (void*)IDirectPlayLobby2W_GetConnectionSettings,
1093   (void*)IDirectPlayLobby2W_ReceiveLobbyMessage,
1094   (void*)IDirectPlayLobby2W_RunApplication,
1095   (void*)IDirectPlayLobby2W_SendLobbyMessage,
1096   (void*)IDirectPlayLobby2W_SetConnectionSettings,
1097   (void*)IDirectPlayLobby2W_SetLobbyMessageEvent
1098 };
1099
1100
1101 /* Direct Play Lobby 2 (ascii) Virtual Table for methods */
1102 static struct tagLPDIRECTPLAYLOBBY2_VTABLE directPlayLobby2AVT = {
1103   IDirectPlayLobby2A_QueryInterface,
1104   IDirectPlayLobby2A_AddRef,
1105   IDirectPlayLobby2A_Release,
1106   IDirectPlayLobby2A_Connect,
1107   IDirectPlayLobby2A_CreateAddress,
1108   IDirectPlayLobby2A_EnumAddress,
1109   IDirectPlayLobby2A_EnumAddressTypes,
1110   IDirectPlayLobby2A_EnumLocalApplications,
1111   IDirectPlayLobby2A_GetConnectionSettings,
1112   IDirectPlayLobby2A_ReceiveLobbyMessage,
1113   IDirectPlayLobby2A_RunApplication,
1114   IDirectPlayLobby2A_SendLobbyMessage,
1115   IDirectPlayLobby2A_SetConnectionSettings,
1116   IDirectPlayLobby2A_SetLobbyMessageEvent,
1117   IDirectPlayLobby2A_CreateCompoundAddress
1118 };
1119
1120 /* Direct Play Lobby 2 (unicode) Virtual Table for methods */
1121 static struct tagLPDIRECTPLAYLOBBY2_VTABLE directPlayLobby2WVT = {
1122   IDirectPlayLobby2W_QueryInterface,
1123   IDirectPlayLobby2W_AddRef,
1124   IDirectPlayLobby2W_Release,
1125   IDirectPlayLobby2W_Connect,
1126   IDirectPlayLobby2W_CreateAddress,
1127   IDirectPlayLobby2W_EnumAddress,
1128   IDirectPlayLobby2W_EnumAddressTypes,
1129   IDirectPlayLobby2W_EnumLocalApplications,
1130   IDirectPlayLobby2W_GetConnectionSettings,
1131   IDirectPlayLobby2W_ReceiveLobbyMessage,
1132   IDirectPlayLobby2W_RunApplication,
1133   IDirectPlayLobby2W_SendLobbyMessage,
1134   IDirectPlayLobby2W_SetConnectionSettings,
1135   IDirectPlayLobby2W_SetLobbyMessageEvent,
1136   IDirectPlayLobby2W_CreateCompoundAddress
1137 };
1138
1139 /***************************************************************************
1140  *  DirectPlayLobbyCreateA   (DPLAYX.4)
1141  *
1142  */
1143 HRESULT WINAPI DirectPlayLobbyCreateA( LPGUID lpGUIDDSP,
1144                                        LPDIRECTPLAYLOBBYA *lplpDPL,
1145                                        IUnknown *lpUnk,
1146                                        LPVOID lpData,
1147                                        DWORD dwDataSize )
1148 {
1149   TRACE(dplay,"lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
1150         lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
1151
1152   /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
1153    * equal 0. These fields are mostly for future expansion.
1154    */
1155   if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
1156   {
1157      *lplpDPL = NULL;
1158      return DPERR_INVALIDPARAMS;
1159   }
1160
1161   /* Yes...really we should be returning a lobby 1 object */
1162   *lplpDPL = (LPDIRECTPLAYLOBBYA)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1163                                             sizeof( IDirectPlayLobbyA ) );
1164
1165   if( ! (*lplpDPL) )
1166   {
1167      return DPERR_OUTOFMEMORY;
1168   }
1169
1170   (*lplpDPL)->lpVtbl = &directPlayLobbyAVT;
1171   (*lplpDPL)->ref    = 1;
1172
1173   /* All fields were nulled out by the allocation */
1174
1175   return DP_OK;
1176 }
1177
1178 /***************************************************************************
1179  *  DirectPlayLobbyCreateW   (DPLAYX.5)
1180  *
1181  */
1182 HRESULT WINAPI DirectPlayLobbyCreateW( LPGUID lpGUIDDSP,
1183                                        LPDIRECTPLAYLOBBY *lplpDPL,
1184                                        IUnknown *lpUnk,
1185                                        LPVOID lpData,
1186                                        DWORD dwDataSize )
1187 {
1188   TRACE(dplay,"lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
1189         lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
1190
1191   /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
1192    * equal 0. These fields are mostly for future expansion.
1193    */
1194   if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
1195   {
1196      *lplpDPL = NULL;
1197      ERR( dplay, "Bad parameters!\n" );
1198      return DPERR_INVALIDPARAMS;
1199   }
1200
1201   /* Yes...really we should bre returning a lobby 1 object */
1202   *lplpDPL = (LPDIRECTPLAYLOBBY)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1203                                            sizeof( IDirectPlayLobby ) );
1204
1205   if( !*lplpDPL)
1206   {
1207      return DPERR_OUTOFMEMORY;
1208   }
1209
1210   (*lplpDPL)->lpVtbl = &directPlayLobbyWVT;
1211   (*lplpDPL)->ref    = 1;
1212
1213   /* All fields were nulled out by the allocation */
1214
1215   return DP_OK;
1216
1217 }
1218
1219 /***************************************************************************
1220  *  DirectPlayEnumerateA (DPLAYX.2)
1221  *
1222  *  The pointer to the structure lpContext will be filled with the
1223  *  appropriate data for each service offered by the OS. These services are
1224  *  not necessarily available on this particular machine but are defined
1225  *  as simple service providers under the "Service Providers" registry key.
1226  *  This structure is then passed to lpEnumCallback for each of the different
1227  *  services.
1228  *
1229  *  This API is useful only for applications written using DirectX3 or
1230  *  worse. It is superceeded by IDirectPlay3::EnumConnections which also
1231  *  gives information on the actual connections.
1232  *
1233  * defn of a service provider:
1234  * A dynamic-link library used by DirectPlay to communicate over a network.
1235  * The service provider contains all the network-specific code required
1236  * to send and receive messages. Online services and network operators can
1237  * supply service providers to use specialized hardware, protocols, communications
1238  * media, and network resources.
1239  *
1240  * TODO: Allocate string buffer space from the heap (length from reg)
1241  *       Pass real device driver numbers...
1242  *       Get the GUID properly...
1243  */
1244 HRESULT WINAPI DirectPlayEnumerateA( LPDPENUMDPCALLBACKA lpEnumCallback,
1245                                      LPVOID lpContext )
1246 {
1247
1248   HKEY hkResult;
1249   LPCSTR searchSubKey    = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
1250   LPSTR guidDataSubKey   = "Guid";
1251   LPSTR majVerDataSubKey = "dwReserved1";
1252   DWORD dwIndex, sizeOfSubKeyName=50;
1253   char subKeyName[51];
1254
1255   TRACE( dplay, ": lpEnumCallback=%p lpContext=%p\n", lpEnumCallback, lpContext );
1256
1257   if( !lpEnumCallback || !*lpEnumCallback )
1258   {
1259      return DPERR_INVALIDPARAMS;
1260   }
1261
1262   /* Need to loop over the service providers in the registry */
1263   if( RegOpenKeyEx32A( HKEY_LOCAL_MACHINE, searchSubKey,
1264                        0, KEY_ENUMERATE_SUB_KEYS, &hkResult ) != ERROR_SUCCESS )
1265   {
1266     /* Hmmm. Does this mean that there are no service providers? */
1267     ERR(dplay, ": no service providers?\n");
1268     return DP_OK;
1269   }
1270
1271   /* Traverse all the service providers we have available */
1272   for( dwIndex=0;
1273        RegEnumKey32A( hkResult, dwIndex, subKeyName, sizeOfSubKeyName ) !=
1274          ERROR_NO_MORE_ITEMS;
1275        ++dwIndex )
1276   {
1277     HKEY     hkServiceProvider;
1278     GUID     serviceProviderGUID;
1279     DWORD    returnTypeGUID, returnTypeReserved1, sizeOfReturnBuffer=50;
1280     char     returnBuffer[51];
1281     DWORD    majVersionNum /*, minVersionNum */;
1282     LPWSTR   lpWGUIDString;
1283
1284     TRACE( dplay, " this time through: %s\n", subKeyName );
1285
1286     /* Get a handle for this particular service provider */
1287     if( RegOpenKeyEx32A( hkResult, subKeyName, 0, KEY_QUERY_VALUE,
1288                          &hkServiceProvider ) != ERROR_SUCCESS )
1289     {
1290       ERR( dplay, ": what the heck is going on?\n" );
1291       continue;
1292     }
1293
1294     /* Get the GUID, Device major number and device minor number
1295      * from the registry.
1296      */
1297     if( RegQueryValueEx32A( hkServiceProvider, guidDataSubKey,
1298                             NULL, &returnTypeGUID, returnBuffer,
1299                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1300     {
1301       ERR( dplay, ": missing GUID registry data members\n" );
1302       continue;
1303     }
1304
1305     /* FIXME: Check return types to ensure we're interpreting data right */
1306     lpWGUIDString = HEAP_strdupAtoW( GetProcessHeap(), 0, returnBuffer );
1307     CLSIDFromString32( (LPCOLESTR32)lpWGUIDString, &serviceProviderGUID );
1308     HeapFree( GetProcessHeap(), 0, lpWGUIDString );
1309
1310     sizeOfReturnBuffer = 50;
1311
1312     if( RegQueryValueEx32A( hkServiceProvider, majVerDataSubKey,
1313                             NULL, &returnTypeReserved1, returnBuffer,
1314                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1315     {
1316       ERR( dplay, ": missing dwReserved1 registry data members\n") ;
1317       continue;
1318     }
1319     /* FIXME: This couldn't possibly be right...*/
1320     majVersionNum = GET_DWORD( returnBuffer );
1321
1322     /* The enumeration will return FALSE if we are not to continue */
1323     if( !lpEnumCallback( &serviceProviderGUID , subKeyName,
1324                          majVersionNum, (DWORD)0, lpContext ) )
1325     {
1326       WARN( dplay, "lpEnumCallback returning FALSE\n" );
1327       break;
1328     }
1329   }
1330
1331   return DP_OK;
1332
1333 };
1334
1335 /***************************************************************************
1336  *  DirectPlayEnumerateW (DPLAYX.3)
1337  *
1338  */
1339 HRESULT WINAPI DirectPlayEnumerateW( LPDPENUMDPCALLBACKW lpEnumCallback, LPVOID lpContext )
1340 {
1341
1342   FIXME( dplay, ":stub\n");
1343
1344   return DPERR_OUTOFMEMORY;
1345
1346 };
1347
1348 /***************************************************************************
1349  *  DirectPlayCreate (DPLAYX.1) (DPLAY.1)
1350  *
1351  */
1352 HRESULT WINAPI DirectPlayCreate
1353 ( LPGUID lpGUID, LPDIRECTPLAY2 *lplpDP, IUnknown *pUnk)
1354 {
1355
1356   TRACE(dplay,"\n" );
1357
1358   if( pUnk != NULL )
1359   {
1360     /* Hmmm...wonder what this means! */
1361     ERR(dplay, "What does a NULL here mean?\n" );
1362     return DPERR_OUTOFMEMORY;
1363   }
1364
1365   *lplpDP = (LPDIRECTPLAY2)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1366                                       sizeof( **lplpDP ) );
1367
1368   if( !*lplpDP )
1369   {
1370      return DPERR_OUTOFMEMORY;
1371   }
1372
1373   (*lplpDP)->lpVtbl = &directPlay2AVT;
1374   (*lplpDP)->ref    = 1;
1375
1376   return DP_OK;
1377
1378 };
1379
1380
1381 /* Direct Play methods */
1382 static HRESULT WINAPI DirectPlay2W_QueryInterface
1383          ( LPDIRECTPLAY2 this, REFIID riid, LPVOID* ppvObj )
1384 {
1385   FIXME( dplay, "(%p)->(%p,%p): stub\n", this, riid, ppvObj );
1386   return E_NOINTERFACE;
1387 }
1388
1389 static HRESULT WINAPI DirectPlay2A_QueryInterface
1390          ( LPDIRECTPLAY2A this, REFIID riid, LPVOID* ppvObj )
1391 {
1392   FIXME( dplay, "(%p)->(%p,%p): stub\n", this, riid, ppvObj );
1393   return E_NOINTERFACE;
1394 }
1395
1396 static HRESULT WINAPI DirectPlay3W_QueryInterface
1397          ( LPDIRECTPLAY3 this, REFIID riid, LPVOID* ppvObj )
1398 {
1399   FIXME( dplay, "(%p)->(%p,%p): stub\n", this, riid, ppvObj );
1400   return E_NOINTERFACE;
1401 }
1402
1403 static HRESULT WINAPI DirectPlay3A_QueryInterface
1404          ( LPDIRECTPLAY3A this, REFIID riid, LPVOID* ppvObj )
1405 {
1406   FIXME( dplay, "(%p)->(%p,%p): stub\n", this, riid, ppvObj );
1407   return E_NOINTERFACE;
1408 }
1409
1410
1411 static ULONG WINAPI DirectPlay3W_AddRef
1412          ( LPDIRECTPLAY3 this )
1413 {
1414   ++(this->ref);
1415   TRACE( dplay,"ref count now %lu\n", this->ref );
1416   return (this->ref);
1417 }
1418
1419 static ULONG WINAPI DirectPlay3W_Release
1420 ( LPDIRECTPLAY3 this )
1421 {
1422   TRACE( dplay, "ref count decremeneted from %lu\n", this->ref );
1423
1424   this->ref--;
1425
1426   /* Deallocate if this is the last reference to the object */
1427   if( !(this->ref) )
1428   {
1429     FIXME( dplay, "memory leak\n" );
1430     /* Implement memory deallocation */
1431
1432     HeapFree( GetProcessHeap(), 0, this );
1433
1434     return 0;
1435   }
1436
1437   return this->ref;
1438 };
1439
1440
1441
1442
1443 HRESULT WINAPI DirectPlay3W_AddPlayerToGroup
1444           ( LPDIRECTPLAY3 this, DPID a, DPID b )
1445 {
1446   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx): stub", this, a, b );
1447   return DP_OK;
1448 }
1449
1450 HRESULT WINAPI DirectPlay3W_Close
1451           ( LPDIRECTPLAY3 this )
1452 {
1453   FIXME( dplay,"(%p)->(): stub", this );
1454   return DP_OK;
1455 }
1456
1457 HRESULT WINAPI DirectPlay3W_CreateGroup
1458           ( LPDIRECTPLAY3 this, LPDPID a, LPDPNAME b, LPVOID c, DWORD d, DWORD e )
1459 {
1460   FIXME( dplay,"(%p)->(%p,%p,%p,0x%08lx,0x%08lx): stub", this, a, b, c, d, e );
1461   return DP_OK;
1462 }
1463
1464 HRESULT WINAPI DirectPlay3W_CreatePlayer
1465           ( LPDIRECTPLAY3 this, LPDPID a, LPDPNAME b, HANDLE32 c, LPVOID d, DWORD e, DWORD f )
1466 {
1467   FIXME( dplay,"(%p)->(%p,%p,%d,%p,0x%08lx,0x%08lx): stub", this, a, b, c, d, e, f );
1468   return DP_OK;
1469 }
1470
1471 HRESULT WINAPI DirectPlay3W_DeletePlayerFromGroup
1472           ( LPDIRECTPLAY3 this, DPID a, DPID b )
1473 {
1474   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx): stub", this, a, b );
1475   return DP_OK;
1476 }
1477
1478 HRESULT WINAPI DirectPlay3W_DestroyGroup
1479           ( LPDIRECTPLAY3 this, DPID a )
1480 {
1481   FIXME( dplay,"(%p)->(0x%08lx): stub", this, a );
1482   return DP_OK;
1483 }
1484
1485 HRESULT WINAPI DirectPlay3W_DestroyPlayer
1486           ( LPDIRECTPLAY3 this, DPID a )
1487 {
1488   FIXME( dplay,"(%p)->(0x%08lx): stub", this, a );
1489   return DP_OK;
1490 }
1491
1492 HRESULT WINAPI DirectPlay3W_EnumGroupPlayers
1493           ( LPDIRECTPLAY3 this, DPID a, LPGUID b, LPDPENUMPLAYERSCALLBACK2 c,
1494             LPVOID d, DWORD e )
1495 {
1496   FIXME( dplay,"(%p)->(0x%08lx,%p,%p,%p,0x%08lx): stub", this, a, b, c, d, e );
1497   return DP_OK;
1498 }
1499
1500 HRESULT WINAPI DirectPlay3W_EnumGroups
1501           ( LPDIRECTPLAY3 this, LPGUID a, LPDPENUMPLAYERSCALLBACK2 b, LPVOID c, DWORD d )
1502 {
1503   FIXME( dplay,"(%p)->(%p,%p,%p,0x%08lx): stub", this, a, b, c, d );
1504   return DP_OK;
1505 }
1506
1507 HRESULT WINAPI DirectPlay3W_EnumPlayers
1508           ( LPDIRECTPLAY3 this, LPGUID a, LPDPENUMPLAYERSCALLBACK2 b, LPVOID c, DWORD d )
1509 {
1510   FIXME( dplay,"(%p)->(%p,%p,%p,0x%08lx): stub", this, a, b, c, d );
1511   return DP_OK;
1512 }
1513
1514 HRESULT WINAPI DirectPlay3W_EnumSessions
1515           ( LPDIRECTPLAY3 this, LPDPSESSIONDESC2 a, DWORD b, LPDPENUMSESSIONSCALLBACK2 c,
1516             LPVOID d, DWORD e )
1517 {
1518   FIXME( dplay,"(%p)->(%p,0x%08lx,%p,%p,0x%08lx): stub", this, a, b, c, d, e );
1519   return DP_OK;
1520 }
1521
1522 HRESULT WINAPI DirectPlay3W_GetCaps
1523           ( LPDIRECTPLAY3 this, LPDPCAPS a, DWORD b )
1524 {
1525   FIXME( dplay,"(%p)->(%p,0x%08lx): stub", this, a, b );
1526   return DP_OK;
1527 }
1528
1529 HRESULT WINAPI DirectPlay3W_GetGroupData
1530           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, LPDWORD c, DWORD d )
1531 {
1532   FIXME( dplay,"(%p)->(0x%08lx,%p,%p,0x%08lx): stub", this, a, b, c, d );
1533   return DP_OK;
1534 }
1535
1536 HRESULT WINAPI DirectPlay3W_GetGroupName
1537           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, LPDWORD c )
1538 {
1539   FIXME( dplay,"(%p)->(0x%08lx,%p,%p): stub", this, a, b, c );
1540   return DP_OK;
1541 }
1542
1543 HRESULT WINAPI DirectPlay3W_GetMessageCount
1544           ( LPDIRECTPLAY3 this, DPID a, LPDWORD b )
1545 {
1546   FIXME( dplay,"(%p)->(0x%08lx,%p): stub", this, a, b );
1547   return DP_OK;
1548 }
1549
1550 HRESULT WINAPI DirectPlay3W_GetPlayerAddress
1551           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, LPDWORD c )
1552 {
1553   FIXME( dplay,"(%p)->(0x%08lx,%p,%p): stub", this, a, b, c );
1554   return DP_OK;
1555 }
1556
1557 HRESULT WINAPI DirectPlay3W_GetPlayerCaps
1558           ( LPDIRECTPLAY3 this, DPID a, LPDPCAPS b, DWORD c )
1559 {
1560   FIXME( dplay,"(%p)->(0x%08lx,%p,0x%08lx): stub", this, a, b, c );
1561   return DP_OK;
1562 }
1563
1564 HRESULT WINAPI DirectPlay3W_GetPlayerData
1565           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, LPDWORD c, DWORD d )
1566 {
1567   FIXME( dplay,"(%p)->(0x%08lx,%p,%p,0x%08lx): stub", this, a, b, c, d );
1568   return DP_OK;
1569 }
1570
1571 HRESULT WINAPI DirectPlay3W_GetPlayerName
1572           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, LPDWORD c )
1573 {
1574   FIXME( dplay,"(%p)->(0x%08lx,%p,%p): stub", this, a, b, c );
1575   return DP_OK;
1576 }
1577
1578 HRESULT WINAPI DirectPlay3W_GetSessionDesc
1579           ( LPDIRECTPLAY3 this, LPVOID a, LPDWORD b )
1580 {
1581   FIXME( dplay,"(%p)->(%p,%p): stub", this, a, b );
1582   return DP_OK;
1583 }
1584
1585 HRESULT WINAPI DirectPlay3W_Initialize
1586           ( LPDIRECTPLAY3 this, LPGUID a )
1587 {
1588   FIXME( dplay,"(%p)->(%p): stub", this, a );
1589   return DP_OK;
1590 }
1591
1592 HRESULT WINAPI DirectPlay3W_Open
1593           ( LPDIRECTPLAY3 this, LPDPSESSIONDESC2 a, DWORD b )
1594 {
1595   FIXME( dplay,"(%p)->(%p,0x%08lx): stub", this, a, b );
1596   return DP_OK;
1597 }
1598
1599 HRESULT WINAPI DirectPlay3W_Receive
1600           ( LPDIRECTPLAY3 this, LPDPID a, LPDPID b, DWORD c, LPVOID d, LPDWORD e )
1601 {
1602   FIXME( dplay,"(%p)->(%p,%p,0x%08lx,%p,%p): stub", this, a, b, c, d, e );
1603   return DP_OK;
1604 }
1605
1606 HRESULT WINAPI DirectPlay3W_Send
1607           ( LPDIRECTPLAY3 this, DPID a, DPID b, DWORD c, LPVOID d, DWORD e )
1608 {
1609   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx,0x%08lx,%p,0x%08lx): stub", this, a, b, c, d, e );
1610   return DP_OK;
1611 }
1612
1613 HRESULT WINAPI DirectPlay3W_SetGroupData
1614           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, DWORD c, DWORD d )
1615 {
1616   FIXME( dplay,"(%p)->(0x%08lx,%p,0x%08lx,0x%08lx): stub", this, a, b, c, d );
1617   return DP_OK;
1618 }
1619
1620 HRESULT WINAPI DirectPlay3W_SetGroupName
1621           ( LPDIRECTPLAY3 this, DPID a, LPDPNAME b, DWORD c )
1622 {
1623   FIXME( dplay,"(%p)->(0x%08lx,%p,0x%08lx): stub", this, a, b, c );
1624   return DP_OK;
1625 }
1626
1627 HRESULT WINAPI DirectPlay3W_SetPlayerData
1628           ( LPDIRECTPLAY3 this, DPID a, LPVOID b, DWORD c, DWORD d )
1629 {
1630   FIXME( dplay,"(%p)->(0x%08lx,%p,0x%08lx,0x%08lx): stub", this, a, b, c, d );
1631   return DP_OK;
1632 }
1633
1634 HRESULT WINAPI DirectPlay3W_SetPlayerName
1635           ( LPDIRECTPLAY3 this, DPID a, LPDPNAME b, DWORD c )
1636 {
1637   FIXME( dplay,"(%p)->(0x%08lx,%p,0x%08lx): stub", this, a, b, c );
1638   return DP_OK;
1639 }
1640
1641 HRESULT WINAPI DirectPlay3W_SetSessionDesc
1642           ( LPDIRECTPLAY3 this, LPDPSESSIONDESC2 a, DWORD b )
1643 {
1644   FIXME( dplay,"(%p)->(%p,0x%08lx): stub", this, a, b );
1645   return DP_OK;
1646 }
1647
1648 HRESULT WINAPI DirectPlay3W_AddGroupToGroup
1649           ( LPDIRECTPLAY3 this, DPID a, DPID b )
1650 {
1651   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx): stub", this, a, b );
1652   return DP_OK;
1653 }
1654
1655 HRESULT WINAPI DirectPlay3W_CreateGroupInGroup
1656           ( LPDIRECTPLAY3 this, DPID a, LPDPID b, LPDPNAME c, LPVOID d, DWORD e, DWORD f )
1657 {
1658   FIXME( dplay,"(%p)->(0x%08lx,%p,%p,%p,0x%08lx,0x%08lx): stub", this, a, b, c, d, e, f );
1659   return DP_OK;
1660 }
1661
1662 HRESULT WINAPI DirectPlay3W_DeleteGroupFromGroup
1663           ( LPDIRECTPLAY3 this, DPID a, DPID b )
1664 {
1665   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx): stub", this, a, b );
1666   return DP_OK;
1667 }
1668
1669 HRESULT WINAPI DirectPlay3W_EnumConnections
1670           ( LPDIRECTPLAY3 this, LPCGUID a, LPDPENUMCONNECTIONSCALLBACK b, LPVOID c, DWORD d )
1671 {
1672   FIXME( dplay,"(%p)->(%p,%p,%p,0x%08lx): stub", this, a, b, c, d );
1673   return DP_OK;
1674 }
1675
1676 HRESULT WINAPI DirectPlay3W_EnumGroupsInGroup
1677           ( LPDIRECTPLAY3 this, DPID a, LPGUID b, LPDPENUMPLAYERSCALLBACK2 c, LPVOID d, DWORD e )
1678 {
1679   FIXME( dplay,"(%p)->(0x%08lx,%p,%p,%p,0x%08lx): stub", this, a, b, c, d, e );
1680   return DP_OK;
1681 }
1682
1683 HRESULT WINAPI DirectPlay3W_GetGroupConnectionSettings
1684           ( LPDIRECTPLAY3 this, DWORD a, DPID b, LPVOID c, LPDWORD d )
1685 {
1686   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx,%p,%p): stub", this, a, b, c, d );
1687   return DP_OK;
1688 }
1689
1690 HRESULT WINAPI DirectPlay3W_InitializeConnection
1691           ( LPDIRECTPLAY3 this, LPVOID a, DWORD b )
1692 {
1693   FIXME( dplay,"(%p)->(%p,0x%08lx): stub", this, a, b );
1694   return DP_OK;
1695 }
1696
1697 HRESULT WINAPI DirectPlay3W_SecureOpen
1698           ( LPDIRECTPLAY3 this, LPCDPSESSIONDESC2 a, DWORD b, LPCDPSECURITYDESC c, LPCDPCREDENTIALS d )
1699 {
1700   FIXME( dplay,"(%p)->(%p,0x%08lx,%p,%p): stub", this, a, b, c, d );
1701   return DP_OK;
1702 }
1703
1704 HRESULT WINAPI DirectPlay3W_SendChatMessage
1705           ( LPDIRECTPLAY3 this, DPID a, DPID b, DWORD c, LPDPCHAT d )
1706 {
1707   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx,0x%08lx,%p): stub", this, a, b, c, d );
1708   return DP_OK;
1709 }
1710
1711 HRESULT WINAPI DirectPlay3W_SetGroupConnectionSettings
1712           ( LPDIRECTPLAY3 this, DWORD a, DPID b, LPDPLCONNECTION c )
1713 {
1714   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx,%p): stub", this, a, b, c );
1715   return DP_OK;
1716 }
1717
1718 HRESULT WINAPI DirectPlay3W_StartSession
1719           ( LPDIRECTPLAY3 this, DWORD a, DPID b )
1720 {
1721   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx): stub", this, a, b );
1722   return DP_OK;
1723 }
1724
1725 HRESULT WINAPI DirectPlay3W_GetGroupFlags
1726           ( LPDIRECTPLAY3 this, DPID a, LPDWORD b )
1727 {
1728   FIXME( dplay,"(%p)->(0x%08lx,%p): stub", this, a, b );
1729   return DP_OK;
1730 }
1731
1732 HRESULT WINAPI DirectPlay3W_GetGroupParent
1733           ( LPDIRECTPLAY3 this, DPID a, LPDPID b )
1734 {
1735   FIXME( dplay,"(%p)->(0x%08lx,%p): stub", this, a, b );
1736   return DP_OK;
1737 }
1738
1739 HRESULT WINAPI DirectPlay3W_GetPlayerAccount
1740           ( LPDIRECTPLAY3 this, DPID a, DWORD b, LPVOID c, LPDWORD d )
1741 {
1742   FIXME( dplay,"(%p)->(0x%08lx,0x%08lx,%p,%p): stub", this, a, b, c, d );
1743   return DP_OK;
1744 }
1745
1746 HRESULT WINAPI DirectPlay3W_GetPlayerFlags
1747           ( LPDIRECTPLAY3 this, DPID a, LPDWORD b )
1748 {
1749   FIXME( dplay,"(%p)->(0x%08lx,%p): stub", this, a, b );
1750   return DP_OK;
1751 }
1752
1753 static struct tagLPDIRECTPLAY2_VTABLE directPlay2WVT = {
1754   DirectPlay2W_QueryInterface,
1755   (void*)DirectPlay3W_AddRef,
1756   (void*)DirectPlay3W_Release,
1757   (void*)DirectPlay3W_AddPlayerToGroup,
1758   (void*)DirectPlay3W_Close,
1759   (void*)DirectPlay3W_CreateGroup,
1760   (void*)DirectPlay3W_CreatePlayer,
1761   (void*)DirectPlay3W_DeletePlayerFromGroup,
1762   (void*)DirectPlay3W_DestroyGroup,
1763   (void*)DirectPlay3W_DestroyPlayer,
1764   (void*)DirectPlay3W_EnumGroupPlayers,
1765   (void*)DirectPlay3W_EnumGroups,
1766   (void*)DirectPlay3W_EnumPlayers,
1767   (void*)DirectPlay3W_EnumSessions,
1768   (void*)DirectPlay3W_GetCaps,
1769   (void*)DirectPlay3W_GetGroupData,
1770   (void*)DirectPlay3W_GetGroupName,
1771   (void*)DirectPlay3W_GetMessageCount,
1772   (void*)DirectPlay3W_GetPlayerAddress,
1773   (void*)DirectPlay3W_GetPlayerCaps,
1774   (void*)DirectPlay3W_GetPlayerData,
1775   (void*)DirectPlay3W_GetPlayerName,
1776   (void*)DirectPlay3W_GetSessionDesc,
1777   (void*)DirectPlay3W_Initialize,
1778   (void*)DirectPlay3W_Open,
1779   (void*)DirectPlay3W_Receive,
1780   (void*)DirectPlay3W_Send,
1781   (void*)DirectPlay3W_SetGroupData,
1782   (void*)DirectPlay3W_SetGroupName,
1783   (void*)DirectPlay3W_SetPlayerData,
1784   (void*)DirectPlay3W_SetPlayerName,
1785   (void*)DirectPlay3W_SetSessionDesc
1786 };
1787
1788 static struct tagLPDIRECTPLAY2_VTABLE directPlay2AVT = {
1789   DirectPlay2A_QueryInterface,
1790   (void*)DirectPlay3W_AddRef,
1791   (void*)DirectPlay3W_Release,
1792   (void*)DirectPlay3W_AddPlayerToGroup,
1793   (void*)DirectPlay3W_Close,
1794   (void*)DirectPlay3W_CreateGroup,
1795   (void*)DirectPlay3W_CreatePlayer,
1796   (void*)DirectPlay3W_DeletePlayerFromGroup,
1797   (void*)DirectPlay3W_DestroyGroup,
1798   (void*)DirectPlay3W_DestroyPlayer,
1799   (void*)DirectPlay3W_EnumGroupPlayers,
1800   (void*)DirectPlay3W_EnumGroups,
1801   (void*)DirectPlay3W_EnumPlayers,
1802   (void*)DirectPlay3W_EnumSessions,
1803   (void*)DirectPlay3W_GetCaps,
1804   (void*)DirectPlay3W_GetGroupData,
1805   (void*)DirectPlay3W_GetGroupName,
1806   (void*)DirectPlay3W_GetMessageCount,
1807   (void*)DirectPlay3W_GetPlayerAddress,
1808   (void*)DirectPlay3W_GetPlayerCaps,
1809   (void*)DirectPlay3W_GetPlayerData,
1810   (void*)DirectPlay3W_GetPlayerName,
1811   (void*)DirectPlay3W_GetSessionDesc,
1812   (void*)DirectPlay3W_Initialize,
1813   (void*)DirectPlay3W_Open,
1814   (void*)DirectPlay3W_Receive,
1815   (void*)DirectPlay3W_Send,
1816   (void*)DirectPlay3W_SetGroupData,
1817   (void*)DirectPlay3W_SetGroupName,
1818   (void*)DirectPlay3W_SetPlayerData,
1819   (void*)DirectPlay3W_SetPlayerName,
1820   (void*)DirectPlay3W_SetSessionDesc
1821 };
1822
1823 static struct tagLPDIRECTPLAY3_VTABLE directPlay3AVT = {
1824   DirectPlay3A_QueryInterface,
1825   (void*)DirectPlay3W_AddRef,
1826   (void*)DirectPlay3W_Release,
1827   (void*)DirectPlay3W_AddPlayerToGroup,
1828   (void*)DirectPlay3W_Close,
1829   (void*)DirectPlay3W_CreateGroup,
1830   (void*)DirectPlay3W_CreatePlayer,
1831   (void*)DirectPlay3W_DeletePlayerFromGroup,
1832   (void*)DirectPlay3W_DestroyGroup,
1833   (void*)DirectPlay3W_DestroyPlayer,
1834   (void*)DirectPlay3W_EnumGroupPlayers,
1835   (void*)DirectPlay3W_EnumGroups,
1836   (void*)DirectPlay3W_EnumPlayers,
1837   (void*)DirectPlay3W_EnumSessions,
1838   (void*)DirectPlay3W_GetCaps,
1839   (void*)DirectPlay3W_GetGroupData,
1840   (void*)DirectPlay3W_GetGroupName,
1841   (void*)DirectPlay3W_GetMessageCount,
1842   (void*)DirectPlay3W_GetPlayerAddress,
1843   (void*)DirectPlay3W_GetPlayerCaps,
1844   (void*)DirectPlay3W_GetPlayerData,
1845   (void*)DirectPlay3W_GetPlayerName,
1846   (void*)DirectPlay3W_GetSessionDesc,
1847   (void*)DirectPlay3W_Initialize,
1848   (void*)DirectPlay3W_Open,
1849   (void*)DirectPlay3W_Receive,
1850   (void*)DirectPlay3W_Send,
1851   (void*)DirectPlay3W_SetGroupData,
1852   (void*)DirectPlay3W_SetGroupName,
1853   (void*)DirectPlay3W_SetPlayerData,
1854   (void*)DirectPlay3W_SetPlayerName,
1855   (void*)DirectPlay3W_SetSessionDesc,
1856
1857   (void*)DirectPlay3W_AddGroupToGroup,
1858   (void*)DirectPlay3W_CreateGroupInGroup,
1859   (void*)DirectPlay3W_DeleteGroupFromGroup,
1860   (void*)DirectPlay3W_EnumConnections,
1861   (void*)DirectPlay3W_EnumGroupsInGroup,
1862   (void*)DirectPlay3W_GetGroupConnectionSettings,
1863   (void*)DirectPlay3W_InitializeConnection,
1864   (void*)DirectPlay3W_SecureOpen,
1865   (void*)DirectPlay3W_SendChatMessage,
1866   (void*)DirectPlay3W_SetGroupConnectionSettings,
1867   (void*)DirectPlay3W_StartSession,
1868   (void*)DirectPlay3W_GetGroupFlags,
1869   (void*)DirectPlay3W_GetGroupParent,
1870   (void*)DirectPlay3W_GetPlayerAccount,
1871   (void*)DirectPlay3W_GetPlayerFlags
1872 };
1873
1874 static struct tagLPDIRECTPLAY3_VTABLE directPlay3WVT = {
1875   DirectPlay3W_QueryInterface,
1876   DirectPlay3W_AddRef,
1877   DirectPlay3W_Release,
1878   DirectPlay3W_AddPlayerToGroup,
1879   DirectPlay3W_Close,
1880   DirectPlay3W_CreateGroup,
1881   DirectPlay3W_CreatePlayer,
1882   DirectPlay3W_DeletePlayerFromGroup,
1883   DirectPlay3W_DestroyGroup,
1884   DirectPlay3W_DestroyPlayer,
1885   DirectPlay3W_EnumGroupPlayers,
1886   DirectPlay3W_EnumGroups,
1887   DirectPlay3W_EnumPlayers,
1888   DirectPlay3W_EnumSessions,
1889   DirectPlay3W_GetCaps,
1890   DirectPlay3W_GetGroupData,
1891   DirectPlay3W_GetGroupName,
1892   DirectPlay3W_GetMessageCount,
1893   DirectPlay3W_GetPlayerAddress,
1894   DirectPlay3W_GetPlayerCaps,
1895   DirectPlay3W_GetPlayerData,
1896   DirectPlay3W_GetPlayerName,
1897   DirectPlay3W_GetSessionDesc,
1898   DirectPlay3W_Initialize,
1899   DirectPlay3W_Open,
1900   DirectPlay3W_Receive,
1901   DirectPlay3W_Send,
1902   DirectPlay3W_SetGroupData,
1903   DirectPlay3W_SetGroupName,
1904   DirectPlay3W_SetPlayerData,
1905   DirectPlay3W_SetPlayerName,
1906   DirectPlay3W_SetSessionDesc,
1907
1908   DirectPlay3W_AddGroupToGroup,
1909   DirectPlay3W_CreateGroupInGroup,
1910   DirectPlay3W_DeleteGroupFromGroup,
1911   DirectPlay3W_EnumConnections,
1912   DirectPlay3W_EnumGroupsInGroup,
1913   DirectPlay3W_GetGroupConnectionSettings,
1914   DirectPlay3W_InitializeConnection,
1915   DirectPlay3W_SecureOpen,
1916   DirectPlay3W_SendChatMessage,
1917   DirectPlay3W_SetGroupConnectionSettings,
1918   DirectPlay3W_StartSession,
1919   DirectPlay3W_GetGroupFlags,
1920   DirectPlay3W_GetGroupParent,
1921   DirectPlay3W_GetPlayerAccount,
1922   DirectPlay3W_GetPlayerFlags
1923 };
1924