dlls/dplayx/dplobby.c

   1 /* Direct Play Lobby 2 & 3 Implementation
   2  *
   3  * Copyright 1998,1999 - Peter Hunnisett
   4  *
   5  * <presently under construction - contact hunnise@nortelnetworks.com>
   6  *
   7  */
   8 #include <string.h>
   9
  10 #include "winerror.h"
  11 #include "winnt.h"
  12 #include "winreg.h"
  13 #include "heap.h"
  14 #include "debugtools.h"
  15
  16 #include "dplobby.h"
  17 #include "dpinit.h"
  18 #include "dplayx_global.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(dplay)
  21
  22
  23 /* Forward declarations for this module helper methods */
  24 HRESULT DPL_CreateCompoundAddress ( LPCDPCOMPOUNDADDRESSELEMENT lpElements, DWORD dwElementCount,
  25                                     LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface );
  26
  27 HRESULT DPL_CreateAddress( REFGUID guidSP, REFGUID guidDataType, LPCVOID lpData, DWORD dwDataSize,
  28                            LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface );
  29
  30
  31
  32 static HRESULT DPL_EnumAddress( LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress,
  33                                 DWORD dwAddressSize, LPVOID lpContext );
  34
  35
  36 /*****************************************************************************
  37  * Predeclare the interface implementation structures
  38  */
  39 typedef struct IDirectPlayLobbyImpl  IDirectPlayLobbyAImpl;
  40 typedef struct IDirectPlayLobbyImpl  IDirectPlayLobbyWImpl;
  41 typedef struct IDirectPlayLobby2Impl IDirectPlayLobby2AImpl;
  42 typedef struct IDirectPlayLobby2Impl IDirectPlayLobby2WImpl;
  43 typedef struct IDirectPlayLobby3Impl IDirectPlayLobby3AImpl;
  44 typedef struct IDirectPlayLobby3Impl IDirectPlayLobby3WImpl;
  45
  46 /*****************************************************************************
  47  * IDirectPlayLobby {1,2,3} implementation structure
  48  *
  49  * The philosophy behind this extra pointer derefernce is that I wanted to
  50  * have the same structure for all types of objects without having to do
  51  * alot of casting. I also only wanted to implement an interface in the
  52  * object it was "released" with IUnknown interface being implemented in the 1 version.
  53  * Of course, with these new interfaces comes the data required to keep the state required
  54  * by these interfaces. So, basically, the pointers contain the data associated with
  55  * a release. If you use the data associated with release 3 in a release 2 object, you'll
  56  * get a run time trap, as that won't have any data.
  57  *
  58  */
  59
  60 typedef struct tagDirectPlayLobbyIUnknownData
  61 {
  62   DWORD             ref;
  63   CRITICAL_SECTION  DPL_lock;
  64 } DirectPlayLobbyIUnknownData;
  65
  66 typedef struct tagDirectPlayLobbyData
  67 {
  68   HKEY hkCallbackKeyHack;
  69 } DirectPlayLobbyData;
  70
  71 typedef struct tagDirectPlayLobby2Data
  72 {
  73   BOOL dummy;
  74 } DirectPlayLobby2Data;
  75
  76 typedef struct tagDirectPlayLobby3Data
  77 {
  78   BOOL dummy;
  79 } DirectPlayLobby3Data;
  80
  81 #define DPL_IMPL_FIELDS \
  82  DirectPlayLobbyIUnknownData*  unk; \
  83  DirectPlayLobbyData*          dpl; \
  84  DirectPlayLobby2Data*         dpl2; \
  85  DirectPlayLobby3Data*         dpl3;
  86
  87 struct IDirectPlayLobbyImpl
  88 {
  89     ICOM_VFIELD(IDirectPlayLobby);
  90     DPL_IMPL_FIELDS
  91 };
  92
  93 struct IDirectPlayLobby2Impl
  94 {
  95     ICOM_VFIELD(IDirectPlayLobby2);
  96     DPL_IMPL_FIELDS
  97 };
  98
  99 struct IDirectPlayLobby3Impl
 100 {
 101     ICOM_VFIELD(IDirectPlayLobby3);
 102     DPL_IMPL_FIELDS
 103 };
 104
 105
 106 /* Forward declarations of virtual tables */
 107 static ICOM_VTABLE(IDirectPlayLobby)  directPlayLobbyWVT;
 108 static ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2WVT;
 109 static ICOM_VTABLE(IDirectPlayLobby3) directPlayLobby3WVT;
 110
 111 static ICOM_VTABLE(IDirectPlayLobby)  directPlayLobbyAVT;
 112 static ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2AVT;
 113 static ICOM_VTABLE(IDirectPlayLobby3) directPlayLobby3AVT;
 114
 115
 116
 117
 118 /* The COM interface for upversioning an interface
 119  * We've been given a GUID (riid) and we need to replace the present
 120  * interface with that of the requested interface.
 121  *
 122  * Snip from some Microsoft document:
 123  * There are four requirements for implementations of QueryInterface (In these
 124  * cases, "must succeed" means "must succeed barring catastrophic failure."):
 125  *
 126  *  * The set of interfaces accessible on an object through
 127  *    IUnknown::QueryInterface must be static, not dynamic. This means that
 128  *    if a call to QueryInterface for a pointer to a specified interface
 129  *    succeeds the first time, it must succeed again, and if it fails the
 130  *    first time, it must fail on all subsequent queries.
 131  *  * It must be symmetric ~W if a client holds a pointer to an interface on
 132  *    an object, and queries for that interface, the call must succeed.
 133  *  * It must be reflexive ~W if a client holding a pointer to one interface
 134  *    queries successfully for another, a query through the obtained pointer
 135  *    for the first interface must succeed.
 136  *  * It must be transitive ~W if a client holding a pointer to one interface
 137  *    queries successfully for a second, and through that pointer queries
 138  *    successfully for a third interface, a query for the first interface
 139  *    through the pointer for the third interface must succeed.
 140  *
 141  *  As you can see, this interface doesn't qualify but will most likely
 142  *  be good enough for the time being.
 143  */
 144
 145
 146 BOOL DPL_CreateIUnknown( LPVOID lpDPL )
 147 {
 148   ICOM_THIS(IDirectPlayLobbyAImpl,lpDPL);
 149
 150   This->unk = (DirectPlayLobbyIUnknownData*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 151                                                        sizeof( *(This->unk) ) );
 152   if ( This->unk == NULL )
 153   {
 154     return FALSE;
 155   }
 156
 157   InitializeCriticalSection( &This->unk->DPL_lock );
 158
 159   IDirectPlayLobby_AddRef( (LPDIRECTPLAYLOBBYA)lpDPL );
 160
 161   return TRUE;
 162 }
 163
 164 BOOL DPL_DestroyIUnknown( LPVOID lpDPL )
 165 {
 166   ICOM_THIS(IDirectPlayLobbyAImpl,lpDPL);
 167
 168   DeleteCriticalSection( &This->unk->DPL_lock );
 169   HeapFree( GetProcessHeap(), 0, This->unk );
 170
 171   return TRUE;
 172 }
 173
 174 BOOL DPL_CreateLobby1( LPVOID lpDPL )
 175 {
 176   ICOM_THIS(IDirectPlayLobbyAImpl,lpDPL);
 177
 178   This->dpl = (DirectPlayLobbyData*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 179                                                sizeof( *(This->dpl) ) );
 180   if ( This->dpl == NULL )
 181   {
 182     return FALSE;
 183   }
 184
 185   return TRUE;
 186 }
 187
 188 BOOL DPL_DestroyLobby1( LPVOID lpDPL )
 189 {
 190   ICOM_THIS(IDirectPlayLobbyAImpl,lpDPL);
 191
 192   /* Delete the contents */
 193   HeapFree( GetProcessHeap(), 0, This->dpl );
 194
 195   return TRUE;
 196 }
 197
 198 BOOL DPL_CreateLobby2( LPVOID lpDPL )
 199 {
 200   ICOM_THIS(IDirectPlayLobby2AImpl,lpDPL);
 201
 202   This->dpl2 = (DirectPlayLobby2Data*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 203                                                  sizeof( *(This->dpl2) ) );
 204   if ( This->dpl2 == NULL )
 205   {
 206     return FALSE;
 207   }
 208
 209   return TRUE;
 210 }
 211
 212 BOOL DPL_DestroyLobby2( LPVOID lpDPL )
 213 {
 214   ICOM_THIS(IDirectPlayLobby2AImpl,lpDPL);
 215
 216   HeapFree( GetProcessHeap(), 0, This->dpl2 );
 217
 218   return TRUE;
 219 }
 220
 221 BOOL DPL_CreateLobby3( LPVOID lpDPL )
 222 {
 223   ICOM_THIS(IDirectPlayLobby3AImpl,lpDPL);
 224
 225   This->dpl3 = (DirectPlayLobby3Data*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 226                                                  sizeof( *(This->dpl3) ) );
 227   if ( This->dpl3 == NULL )
 228   {
 229     return FALSE;
 230   }
 231
 232   return TRUE;
 233 }
 234
 235 BOOL DPL_DestroyLobby3( LPVOID lpDPL )
 236 {
 237   ICOM_THIS(IDirectPlayLobby3AImpl,lpDPL);
 238
 239   HeapFree( GetProcessHeap(), 0, This->dpl3 );
 240
 241   return TRUE;
 242 }
 243
 244
 245 /* Helper function for DirectPlayLobby  QueryInterface */
 246 extern
 247 HRESULT directPlayLobby_QueryInterface
 248          ( REFIID riid, LPVOID* ppvObj )
 249 {
 250   if( IsEqualGUID( &IID_IDirectPlayLobby, riid ) )
 251   {
 252     *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 253                          sizeof( IDirectPlayLobbyWImpl ) );
 254
 255     if( *ppvObj == NULL )
 256     {
 257       return E_OUTOFMEMORY;
 258     }
 259
 260     /* new scope for variable declaration */
 261     {
 262       ICOM_THIS(IDirectPlayLobbyWImpl,*ppvObj);
 263
 264       ICOM_VTBL(This) = &directPlayLobbyWVT;
 265
 266       if ( DPL_CreateIUnknown( (LPVOID)This ) &&
 267            DPL_CreateLobby1( (LPVOID)This )
 268          )
 269       {
 270         return S_OK;
 271       }
 272
 273     }
 274
 275     goto error;
 276   }
 277   else if( IsEqualGUID( &IID_IDirectPlayLobbyA, riid ) )
 278   {
 279     *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 280                          sizeof( IDirectPlayLobbyAImpl ) );
 281
 282     if( *ppvObj == NULL )
 283     {
 284       return E_OUTOFMEMORY;
 285     }
 286
 287     {
 288       ICOM_THIS(IDirectPlayLobbyAImpl,*ppvObj);
 289
 290       ICOM_VTBL(This) = &directPlayLobbyAVT;
 291
 292       if ( DPL_CreateIUnknown( (LPVOID)This ) &&
 293            DPL_CreateLobby1( (LPVOID)This )
 294          )
 295       {
 296         return S_OK;
 297       }
 298     }
 299
 300     goto error;
 301   }
 302   else if( IsEqualGUID( &IID_IDirectPlayLobby2, riid ) )
 303   {
 304     *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 305                          sizeof( IDirectPlayLobby2WImpl ) );
 306
 307     if( *ppvObj == NULL )
 308     {
 309       return E_OUTOFMEMORY;
 310     }
 311
 312     {
 313       ICOM_THIS(IDirectPlayLobby2WImpl,*ppvObj);
 314
 315       ICOM_VTBL(This) = &directPlayLobby2WVT;
 316
 317       if ( DPL_CreateIUnknown( (LPVOID)This ) &&
 318            DPL_CreateLobby1( (LPVOID)This ) &&
 319            DPL_CreateLobby2( (LPVOID)This )
 320          )
 321       {
 322         return S_OK;
 323       }
 324     }
 325
 326     goto error;
 327   }
 328   else if( IsEqualGUID( &IID_IDirectPlayLobby2A, riid ) )
 329   {
 330     *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 331                          sizeof( IDirectPlayLobby2AImpl ) );
 332
 333     if( *ppvObj == NULL )
 334     {
 335       return E_OUTOFMEMORY;
 336     }
 337
 338     {
 339       ICOM_THIS(IDirectPlayLobby2AImpl,*ppvObj);
 340
 341       ICOM_VTBL(This) = &directPlayLobby2AVT;
 342
 343       if ( DPL_CreateIUnknown( (LPVOID)This ) &&
 344            DPL_CreateLobby1( (LPVOID)This )  &&
 345            DPL_CreateLobby2( (LPVOID)This )
 346          )
 347       {
 348         return S_OK;
 349       }
 350     }
 351
 352     goto error;
 353   }
 354   else if( IsEqualGUID( &IID_IDirectPlayLobby3, riid ) )
 355   {
 356     *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 357                          sizeof( IDirectPlayLobby3WImpl ) );
 358
 359     if( *ppvObj == NULL )
 360     {
 361       return E_OUTOFMEMORY;
 362     }
 363
 364     {
 365       ICOM_THIS(IDirectPlayLobby3WImpl,*ppvObj);
 366
 367       ICOM_VTBL(This) = &directPlayLobby3WVT;
 368
 369       if ( DPL_CreateIUnknown( *ppvObj ) &&
 370            DPL_CreateLobby1( *ppvObj ) &&
 371            DPL_CreateLobby2( *ppvObj ) &&
 372            DPL_CreateLobby3( *ppvObj )
 373          )
 374       {
 375         return S_OK;
 376       }
 377     }
 378
 379     goto error;
 380   }
 381   else if( IsEqualGUID( &IID_IDirectPlayLobby3A, riid ) )
 382   {
 383      *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 384                           sizeof( IDirectPlayLobby3AImpl ) );
 385
 386     if( *ppvObj == NULL )
 387     {
 388       return E_OUTOFMEMORY;
 389     }
 390
 391     {
 392       ICOM_THIS(IDirectPlayLobby3AImpl,*ppvObj);
 393
 394       ICOM_VTBL(This) = &directPlayLobby3AVT;
 395
 396       if ( DPL_CreateIUnknown( *ppvObj ) &&
 397            DPL_CreateLobby1( *ppvObj ) &&
 398            DPL_CreateLobby2( *ppvObj ) &&
 399            DPL_CreateLobby3( *ppvObj )
 400          )
 401       {
 402         return S_OK;
 403       }
 404     }
 405
 406     goto error;
 407   }
 408
 409   /* Unsupported interface */
 410   *ppvObj = NULL;
 411   return E_NOINTERFACE;
 412
 413 error:
 414
 415     DPL_DestroyLobby3( *ppvObj );
 416     DPL_DestroyLobby2( *ppvObj );
 417     DPL_DestroyLobby1( *ppvObj );
 418     DPL_DestroyIUnknown( *ppvObj );
 419     HeapFree( GetProcessHeap(), 0, *ppvObj );
 420
 421     *ppvObj = NULL;
 422     return DPERR_NOMEMORY;
 423 }
 424
 425 static HRESULT WINAPI IDirectPlayLobbyAImpl_QueryInterface
 426 ( LPDIRECTPLAYLOBBYA iface,
 427   REFIID riid,
 428   LPVOID* ppvObj )
 429 {
 430   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
 431   TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
 432
 433   if( IsEqualGUID( &IID_IUnknown, riid )  ||
 434       IsEqualGUID( &IID_IDirectPlayLobbyA, riid )
 435     )
 436   {
 437     IDirectPlayLobby_AddRef( iface );
 438     *ppvObj = This;
 439     return S_OK;
 440   }
 441
 442   return directPlayLobby_QueryInterface( riid, ppvObj );
 443
 444 }
 445
 446 static HRESULT WINAPI IDirectPlayLobbyW_QueryInterface
 447 ( LPDIRECTPLAYLOBBY iface,
 448   REFIID riid,
 449   LPVOID* ppvObj )
 450 {
 451   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
 452   TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
 453
 454   if( IsEqualGUID( &IID_IUnknown, riid )  ||
 455       IsEqualGUID( &IID_IDirectPlayLobby, riid )
 456     )
 457   {
 458     IDirectPlayLobby_AddRef( iface );
 459     *ppvObj = This;
 460     return S_OK;
 461   }
 462
 463   return directPlayLobby_QueryInterface( riid, ppvObj );
 464 }
 465
 466
 467 static HRESULT WINAPI IDirectPlayLobby2AImpl_QueryInterface
 468 ( LPDIRECTPLAYLOBBY2A iface,
 469   REFIID riid,
 470   LPVOID* ppvObj )
 471 {
 472   ICOM_THIS(IDirectPlayLobby2AImpl,iface);
 473   TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
 474
 475   /* Compare riids. We know this object is a direct play lobby 2A object.
 476      If we are asking about the same type of interface we're fine.
 477    */
 478   if( IsEqualGUID( &IID_IUnknown, riid )  ||
 479       IsEqualGUID( &IID_IDirectPlayLobby2A, riid )
 480     )
 481   {
 482     IDirectPlayLobby_AddRef( iface );
 483     *ppvObj = This;
 484     return S_OK;
 485   }
 486   return directPlayLobby_QueryInterface( riid, ppvObj );
 487 }
 488
 489 static HRESULT WINAPI IDirectPlayLobby2WImpl_QueryInterface
 490 ( LPDIRECTPLAYLOBBY2 iface,
 491   REFIID riid,
 492   LPVOID* ppvObj )
 493 {
 494   ICOM_THIS(IDirectPlayLobby2WImpl,iface);
 495
 496   /* Compare riids. We know this object is a direct play lobby 2 object.
 497      If we are asking about the same type of interface we're fine.
 498    */
 499   if( IsEqualGUID( &IID_IUnknown, riid ) ||
 500       IsEqualGUID( &IID_IDirectPlayLobby2, riid )
 501     )
 502   {
 503     IDirectPlayLobby_AddRef( iface );
 504     *ppvObj = This;
 505     return S_OK;
 506   }
 507
 508   return directPlayLobby_QueryInterface( riid, ppvObj );
 509
 510 }
 511
 512 static HRESULT WINAPI IDirectPlayLobby3AImpl_QueryInterface
 513 ( LPDIRECTPLAYLOBBY3A iface,
 514   REFIID riid,
 515   LPVOID* ppvObj )
 516 {
 517   ICOM_THIS(IDirectPlayLobby3AImpl,iface);
 518
 519   /* Compare riids. We know this object is a direct play lobby 3 object.
 520      If we are asking about the same type of interface we're fine.
 521    */
 522   if( IsEqualGUID( &IID_IUnknown, riid ) ||
 523       IsEqualGUID( &IID_IDirectPlayLobby3A, riid )
 524     )
 525   {
 526     IDirectPlayLobby_AddRef( iface );
 527     *ppvObj = This;
 528     return S_OK;
 529   }
 530
 531   return directPlayLobby_QueryInterface( riid, ppvObj );
 532
 533 }
 534
 535 static HRESULT WINAPI IDirectPlayLobby3WImpl_QueryInterface
 536 ( LPDIRECTPLAYLOBBY3 iface,
 537   REFIID riid,
 538   LPVOID* ppvObj )
 539 {
 540   ICOM_THIS(IDirectPlayLobby3WImpl,iface);
 541
 542   /* Compare riids. We know this object is a direct play lobby 3 object.
 543      If we are asking about the same type of interface we're fine.
 544    */
 545   if( IsEqualGUID( &IID_IUnknown, riid ) ||
 546       IsEqualGUID( &IID_IDirectPlayLobby3, riid )
 547     )
 548   {
 549     IDirectPlayLobby_AddRef( iface );
 550     *ppvObj = This;
 551     return S_OK;
 552   }
 553
 554   return directPlayLobby_QueryInterface( riid, ppvObj );
 555
 556 }
 557
 558 /*
 559  * Simple procedure. Just increment the reference count to this
 560  * structure and return the new reference count.
 561  */
 562 static ULONG WINAPI IDirectPlayLobbyImpl_AddRef
 563 ( LPDIRECTPLAYLOBBY iface )
 564 {
 565   ULONG refCount;
 566   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
 567
 568   EnterCriticalSection( &This->unk->DPL_lock );
 569   {
 570     refCount = ++(This->unk->ref);
 571   }
 572   LeaveCriticalSection( &This->unk->DPL_lock );
 573
 574   TRACE("ref count incremented to %lu for %p\n", refCount, This );
 575
 576   return refCount;
 577 }
 578
 579 /*
 580  * Simple COM procedure. Decrease the reference count to this object.
 581  * If the object no longer has any reference counts, free up the associated
 582  * memory.
 583  */
 584 static ULONG WINAPI IDirectPlayLobbyAImpl_Release
 585 ( LPDIRECTPLAYLOBBYA iface )
 586 {
 587   ULONG refCount;
 588
 589   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
 590
 591   EnterCriticalSection( &This->unk->DPL_lock );
 592   {
 593     refCount = --(This->unk->ref);
 594   }
 595   LeaveCriticalSection( &This->unk->DPL_lock );
 596
 597   TRACE("ref count decremeneted to %lu for %p\n", refCount, This );
 598
 599   /* Deallocate if this is the last reference to the object */
 600   if( refCount )
 601   {
 602      DPL_DestroyLobby3( This );
 603      DPL_DestroyLobby2( This );
 604      DPL_DestroyLobby1( This );
 605      DPL_DestroyIUnknown( This );
 606      HeapFree( GetProcessHeap(), 0, This );
 607   }
 608
 609   return refCount;
 610 }
 611
 612
 613 /********************************************************************
 614  *
 615  * Connects an application to the session specified by the DPLCONNECTION
 616  * structure currently stored with the DirectPlayLobby object.
 617  *
 618  * Returns a IDirectPlay interface.
 619  *
 620  */
 621 static HRESULT WINAPI IDirectPlayLobbyAImpl_Connect
 622 ( LPDIRECTPLAYLOBBYA iface,
 623   DWORD dwFlags,
 624   LPDIRECTPLAY2A* lplpDP,
 625   IUnknown* pUnk)
 626 {
 627   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
 628
 629   LPDIRECTPLAY2A      lpDirectPlay2A;
 630   /* LPDIRECTPLAY3A      lpDirectPlay3A; */
 631   /* LPDIRECTPLAYLOBBY2A lpDirectPlayLobby2A; */
 632   HRESULT             rc;
 633
 634   FIXME("(%p)->(0x%08lx,%p,%p): stub\n", This, dwFlags, lplpDP, pUnk );
 635
 636   if( dwFlags || pUnk )
 637   {
 638      return DPERR_INVALIDPARAMS;
 639   }
 640
 641   /* Create the DirectPlay interface */
 642   if( ( rc = directPlay_QueryInterface( &IID_IDirectPlay2A, (LPVOID*)lplpDP ) ) != DP_OK )
 643   {
 644      ERR("error creating Direct Play 2A interface. Return Code = 0x%lx.\n", rc );
 645      return rc;
 646   }
 647
 648   lpDirectPlay2A = *lplpDP;
 649
 650   /* - Need to call IDirectPlay::EnumConnections with the service provider to get that good information
 651    * - Need to call CreateAddress to create the lpConnection param for IDirectPlay::InitializeConnection
 652    * - Call IDirectPlay::InitializeConnection
 653    * - Call IDirectPlay::Open
 654    */
 655 #if 0
 656   IDirectPlayLobby_EnumAddress( iface, RunApplicationA_Callback,
 657                                 lpConn->lpAddress, lpConn->dwAddressSize, NULL );
 658 #endif
 659
 660
 661   return DP_OK;
 662
 663 }
 664
 665 static HRESULT WINAPI IDirectPlayLobbyWImpl_Connect
 666 ( LPDIRECTPLAYLOBBY iface,
 667   DWORD dwFlags,
 668   LPDIRECTPLAY2* lplpDP,
 669   IUnknown* pUnk)
 670 {
 671   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
 672   LPDIRECTPLAY2* directPlay2W;
 673   HRESULT        createRC;
 674
 675   FIXME("(%p)->(0x%08lx,%p,%p): stub\n", This, dwFlags, lplpDP, pUnk );
 676
 677   if( dwFlags || pUnk )
 678   {
 679      return DPERR_INVALIDPARAMS;
 680   }
 681
 682   /* Create the DirectPlay interface */
 683   if( ( createRC = directPlay_QueryInterface( &IID_IDirectPlay2, (LPVOID*)lplpDP ) ) != DP_OK )
 684   {
 685      ERR("error creating Direct Play 2W interface. Return Code = 0x%lx.\n", createRC );
 686      return createRC;
 687   }
 688
 689   /* This should invoke IDirectPlay3::InitializeConnection IDirectPlay3::Open */
 690   directPlay2W = lplpDP;
 691
 692   return DP_OK;
 693
 694 }
 695
 696 /********************************************************************
 697  *
 698  * Creates a DirectPlay Address, given a service provider-specific network
 699  * address.
 700  * Returns an address contains the globally unique identifier
 701  * (GUID) of the service provider and data that the service provider can
 702  * interpret as a network address.
 703  *
 704  * NOTE: It appears that this method is supposed to be really really stupid
 705  *       with no error checking on the contents.
 706  */
 707 static HRESULT WINAPI IDirectPlayLobbyAImpl_CreateAddress
 708 ( LPDIRECTPLAYLOBBYA iface,
 709   REFGUID guidSP,
 710   REFGUID guidDataType,
 711   LPCVOID lpData,
 712   DWORD dwDataSize,
 713   LPVOID lpAddress,
 714   LPDWORD lpdwAddressSize )
 715 {
 716   return DPL_CreateAddress( guidSP, guidDataType, lpData, dwDataSize,
 717                             lpAddress, lpdwAddressSize, TRUE );
 718 }
 719
 720 static HRESULT WINAPI IDirectPlayLobbyWImpl_CreateAddress
 721 ( LPDIRECTPLAYLOBBY iface,
 722   REFGUID guidSP,
 723   REFGUID guidDataType,
 724   LPCVOID lpData,
 725   DWORD dwDataSize,
 726   LPVOID lpAddress,
 727   LPDWORD lpdwAddressSize )
 728 {
 729   return DPL_CreateAddress( guidSP, guidDataType, lpData, dwDataSize,
 730                             lpAddress, lpdwAddressSize, FALSE );
 731 }
 732
 733 HRESULT DPL_CreateAddress(
 734   REFGUID guidSP,
 735   REFGUID guidDataType,
 736   LPCVOID lpData,
 737   DWORD dwDataSize,
 738   LPVOID lpAddress,
 739   LPDWORD lpdwAddressSize,
 740   BOOL bAnsiInterface )
 741 {
 742   const DWORD dwNumAddElements = 2; /* Service Provide & address data type */
 743   DPCOMPOUNDADDRESSELEMENT addressElements[ 2 /* dwNumAddElements */ ];
 744
 745   TRACE( "(%p)->(%p,%p,0x%08lx,%p,%p,%d)\n", guidSP, guidDataType, lpData, dwDataSize,
 746                                              lpAddress, lpdwAddressSize, bAnsiInterface );
 747
 748   addressElements[ 0 ].guidDataType = DPAID_ServiceProvider;
 749   addressElements[ 0 ].dwDataSize = sizeof( GUID );
 750   addressElements[ 0 ].lpData = (LPVOID)guidSP;
 751
 752   addressElements[ 1 ].guidDataType = *guidDataType;
 753   addressElements[ 1 ].dwDataSize = dwDataSize;
 754   addressElements[ 1 ].lpData = (LPVOID)lpData;
 755
 756   /* Call CreateCompoundAddress to cut down on code.
 757      NOTE: We can do this because we don't support DPL 1 interfaces! */
 758   return DPL_CreateCompoundAddress( addressElements, dwNumAddElements,
 759                                     lpAddress, lpdwAddressSize, bAnsiInterface );
 760 }
 761
 762
 763
 764 /********************************************************************
 765  *
 766  * Parses out chunks from the DirectPlay Address buffer by calling the
 767  * given callback function, with lpContext, for each of the chunks.
 768  *
 769  */
 770 static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddress
 771 ( LPDIRECTPLAYLOBBYA iface,
 772   LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
 773   LPCVOID lpAddress,
 774   DWORD dwAddressSize,
 775   LPVOID lpContext )
 776 {
 777   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
 778
 779   TRACE("(%p)->(%p,%p,0x%08lx,%p)\n", This, lpEnumAddressCallback, lpAddress,
 780                                       dwAddressSize, lpContext );
 781
 782   return DPL_EnumAddress( lpEnumAddressCallback, lpAddress, dwAddressSize, lpContext );
 783 }
 784
 785 static HRESULT WINAPI IDirectPlayLobbyWImpl_EnumAddress
 786 ( LPDIRECTPLAYLOBBY iface,
 787   LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
 788   LPCVOID lpAddress,
 789   DWORD dwAddressSize,
 790   LPVOID lpContext )
 791 {
 792   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
 793
 794   TRACE("(%p)->(%p,%p,0x%08lx,%p)\n", This, lpEnumAddressCallback, lpAddress,
 795                                       dwAddressSize, lpContext );
 796
 797   return DPL_EnumAddress( lpEnumAddressCallback, lpAddress, dwAddressSize, lpContext );
 798 }
 799
 800 static HRESULT DPL_EnumAddress( LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress,
 801                                 DWORD dwAddressSize, LPVOID lpContext )
 802 {
 803   DWORD dwTotalSizeEnumerated = 0;
 804
 805   /* FIXME: First chunk is always the total size chunk - Should we report it? */
 806
 807   while ( dwTotalSizeEnumerated < dwAddressSize )
 808   {
 809     LPDPADDRESS lpElements = (LPDPADDRESS)lpAddress;
 810     DWORD dwSizeThisEnumeration;
 811
 812     /* Invoke the enum method. If false is returned, stop enumeration */
 813     if ( !lpEnumAddressCallback( &lpElements->guidDataType, lpElements->dwDataSize,
 814                                  lpElements + sizeof( DPADDRESS ), lpContext ) )
 815     {
 816       break;
 817     }
 818
 819     dwSizeThisEnumeration  = sizeof( DPADDRESS ) + lpElements->dwDataSize;
 820     lpAddress = (char *) lpAddress + dwSizeThisEnumeration;
 821     dwTotalSizeEnumerated += dwSizeThisEnumeration;
 822   }
 823
 824   return DP_OK;
 825 }
 826
 827 /********************************************************************
 828  *
 829  * Enumerates all the address types that a given service provider needs to
 830  * build the DirectPlay Address.
 831  *
 832  */
 833 static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddressTypes
 834 ( LPDIRECTPLAYLOBBYA iface,
 835   LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
 836   REFGUID guidSP,
 837   LPVOID lpContext,
 838   DWORD dwFlags )
 839 {
 840   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
 841
 842   HKEY   hkResult;
 843   LPCSTR searchSubKey    = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
 844   DWORD  dwIndex, sizeOfSubKeyName=50;
 845   char   subKeyName[51];
 846
 847   TRACE(" (%p)->(%p,%p,%p,0x%08lx)\n", This, lpEnumAddressTypeCallback, guidSP, lpContext, dwFlags );
 848
 849   if( dwFlags != 0 )
 850   {
 851     return DPERR_INVALIDPARAMS;
 852   }
 853
 854   if( !lpEnumAddressTypeCallback || !*lpEnumAddressTypeCallback )
 855   {
 856      return DPERR_INVALIDPARAMS;
 857   }
 858
 859   if( guidSP == NULL )
 860   {
 861     return DPERR_INVALIDOBJECT;
 862   }
 863
 864     /* Need to loop over the service providers in the registry */
 865     if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
 866                          0, KEY_ENUMERATE_SUB_KEYS, &hkResult ) != ERROR_SUCCESS )
 867     {
 868       /* Hmmm. Does this mean that there are no service providers? */
 869       ERR(": no service providers?\n");
 870       return DP_OK;
 871     }
 872
 873     /* Traverse all the service providers we have available */
 874     for( dwIndex=0;
 875          RegEnumKeyA( hkResult, dwIndex, subKeyName, sizeOfSubKeyName ) != ERROR_NO_MORE_ITEMS;
 876          ++dwIndex )
 877     {
 878
 879       HKEY     hkServiceProvider, hkServiceProviderAt;
 880       GUID     serviceProviderGUID;
 881       DWORD    returnTypeGUID, sizeOfReturnBuffer = 50;
 882       char     atSubKey[51];
 883       char     returnBuffer[51];
 884       LPWSTR   lpWGUIDString;
 885       DWORD    dwAtIndex;
 886       LPSTR    atKey = "Address Types";
 887       LPSTR    guidDataSubKey   = "Guid";
 888
 889
 890       TRACE(" this time through: %s\n", subKeyName );
 891
 892       /* Get a handle for this particular service provider */
 893       if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_QUERY_VALUE,
 894                          &hkServiceProvider ) != ERROR_SUCCESS )
 895       {
 896          ERR(": what the heck is going on?\n" );
 897          continue;
 898       }
 899
 900       if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
 901                             NULL, &returnTypeGUID, returnBuffer,
 902                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
 903       {
 904         ERR(": missing GUID registry data members\n" );
 905         continue;
 906       }
 907
 908       /* FIXME: Check return types to ensure we're interpreting data right */
 909       lpWGUIDString = HEAP_strdupAtoW( GetProcessHeap(), 0, returnBuffer );
 910       CLSIDFromString( (LPCOLESTR)lpWGUIDString, &serviceProviderGUID );
 911       HeapFree( GetProcessHeap(), 0, lpWGUIDString );
 912       /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
 913
 914       /* Determine if this is the Service Provider that the user asked for */
 915       if( !IsEqualGUID( &serviceProviderGUID, guidSP ) )
 916       {
 917         continue;
 918       }
 919
 920       /* Get a handle for this particular service provider */
 921       if( RegOpenKeyExA( hkServiceProvider, atKey, 0, KEY_QUERY_VALUE,
 922                          &hkServiceProviderAt ) != ERROR_SUCCESS )
 923       {
 924         WARN(": No Address Types registry data sub key/members\n" );
 925         break;
 926       }
 927
 928       /* Traverse all the address type we have available */
 929       for( dwAtIndex=0;
 930            RegEnumKeyA( hkServiceProviderAt, dwAtIndex, atSubKey, sizeOfSubKeyName ) != ERROR_NO_MORE_ITEMS;
 931            ++dwAtIndex )
 932       {
 933         TRACE( "Found Address Type GUID %s\n", atSubKey );
 934
 935         /* FIXME: Check return types to ensure we're interpreting data right */
 936         lpWGUIDString = HEAP_strdupAtoW( GetProcessHeap(), 0, atSubKey );
 937         CLSIDFromString( (LPCOLESTR)lpWGUIDString, &serviceProviderGUID );
 938         HeapFree( GetProcessHeap(), 0, lpWGUIDString );
 939         /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
 940
 941         /* The enumeration will return FALSE if we are not to continue */
 942         if( !lpEnumAddressTypeCallback( &serviceProviderGUID, lpContext, 0 ) )
 943         {
 944            WARN("lpEnumCallback returning FALSE\n" );
 945            break; /* FIXME: This most likely has to break from the procedure...*/
 946         }
 947
 948       }
 949
 950       /* We only enumerate address types for 1 GUID. We've found it, so quit looking */
 951       break;
 952     }
 953
 954   return DP_OK;
 955 }
 956
 957 static HRESULT WINAPI IDirectPlayLobbyWImpl_EnumAddressTypes
 958 ( LPDIRECTPLAYLOBBY iface,
 959   LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
 960   REFGUID guidSP,
 961   LPVOID lpContext,
 962   DWORD dwFlags )
 963 {
 964   FIXME(":stub\n");
 965   return DPERR_OUTOFMEMORY;
 966 }
 967
 968 /********************************************************************
 969  *
 970  * Enumerates what applications are registered with DirectPlay by
 971  * invoking the callback function with lpContext.
 972  *
 973  */
 974 static HRESULT WINAPI IDirectPlayLobbyWImpl_EnumLocalApplications
 975 ( LPDIRECTPLAYLOBBY iface,
 976   LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback,
 977   LPVOID lpContext,
 978   DWORD dwFlags )
 979 {
 980   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
 981
 982   FIXME("(%p)->(%p,%p,0x%08lx):stub\n", This, lpEnumLocalAppCallback, lpContext, dwFlags );
 983
 984   return DPERR_OUTOFMEMORY;
 985 }
 986
 987 static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumLocalApplications
 988 ( LPDIRECTPLAYLOBBYA iface,
 989   LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback,
 990   LPVOID lpContext,
 991   DWORD dwFlags )
 992 {
 993   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
 994
 995   HKEY hkResult;
 996   LPCSTR searchSubKey    = "SOFTWARE\\Microsoft\\DirectPlay\\Applications";
 997   LPSTR guidDataSubKey   = "Guid";
 998   DWORD dwIndex, sizeOfSubKeyName=50;
 999   char subKeyName[51];
1000
1001   TRACE("(%p)->(%p,%p,0x%08lx)\n", This, lpEnumLocalAppCallback, lpContext, dwFlags );
1002
1003   if( dwFlags != 0 )
1004   {
1005     return DPERR_INVALIDPARAMS;
1006   }
1007
1008   if( !lpEnumLocalAppCallback || !*lpEnumLocalAppCallback )
1009   {
1010      return DPERR_INVALIDPARAMS;
1011   }
1012
1013   /* Need to loop over the service providers in the registry */
1014   if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
1015                      0, KEY_ENUMERATE_SUB_KEYS, &hkResult ) != ERROR_SUCCESS )
1016   {
1017     /* Hmmm. Does this mean that there are no service providers? */
1018     ERR(": no service providers?\n");
1019     return DP_OK;
1020   }
1021
1022   /* Traverse all registered applications */
1023   for( dwIndex=0;
1024        RegEnumKeyA( hkResult, dwIndex, subKeyName, sizeOfSubKeyName ) != ERROR_NO_MORE_ITEMS;
1025        ++dwIndex )
1026   {
1027
1028     HKEY       hkServiceProvider;
1029     GUID       serviceProviderGUID;
1030     DWORD      returnTypeGUID, sizeOfReturnBuffer = 50;
1031     char       returnBuffer[51];
1032     LPWSTR     lpWGUIDString;
1033     DPLAPPINFO dplAppInfo;
1034
1035     TRACE(" this time through: %s\n", subKeyName );
1036
1037     /* Get a handle for this particular service provider */
1038     if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_QUERY_VALUE,
1039                        &hkServiceProvider ) != ERROR_SUCCESS )
1040     {
1041        ERR(": what the heck is going on?\n" );
1042        continue;
1043     }
1044
1045     if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
1046                           NULL, &returnTypeGUID, returnBuffer,
1047                           &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1048     {
1049       ERR(": missing GUID registry data members\n" );
1050       continue;
1051     }
1052
1053     /* FIXME: Check return types to ensure we're interpreting data right */
1054     lpWGUIDString = HEAP_strdupAtoW( GetProcessHeap(), 0, returnBuffer );
1055     CLSIDFromString( (LPCOLESTR)lpWGUIDString, &serviceProviderGUID );
1056     HeapFree( GetProcessHeap(), 0, lpWGUIDString );
1057     /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
1058
1059     dplAppInfo.dwSize               = sizeof( dplAppInfo );
1060     dplAppInfo.guidApplication      = serviceProviderGUID;
1061     dplAppInfo.appName.lpszAppNameA = subKeyName;
1062
1063     EnterCriticalSection( &This->unk->DPL_lock );
1064
1065     memcpy( &This->dpl->hkCallbackKeyHack, &hkServiceProvider, sizeof( hkServiceProvider ) );
1066
1067     if( !lpEnumLocalAppCallback( &dplAppInfo, lpContext, dwFlags ) )
1068     {
1069        LeaveCriticalSection( &This->unk->DPL_lock );
1070        break;
1071     }
1072
1073     LeaveCriticalSection( &This->unk->DPL_lock );
1074   }
1075
1076   return DP_OK;
1077 }
1078
1079 /********************************************************************
1080  *
1081  * Retrieves the DPLCONNECTION structure that contains all the information
1082  * needed to start and connect an application. This was generated using
1083  * either the RunApplication or SetConnectionSettings methods.
1084  *
1085  * NOTES: If lpData is NULL then just return lpdwDataSize. This allows
1086  *        the data structure to be allocated by our caller which can then
1087  *        call this procedure/method again with a valid data pointer.
1088  */
1089 static HRESULT WINAPI IDirectPlayLobbyAImpl_GetConnectionSettings
1090 ( LPDIRECTPLAYLOBBYA iface,
1091   DWORD dwAppID,
1092   LPVOID lpData,
1093   LPDWORD lpdwDataSize )
1094 {
1095   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
1096   HRESULT hr;
1097
1098   TRACE("(%p)->(0x%08lx,%p,%p)\n", This, dwAppID, lpData, lpdwDataSize );
1099
1100   EnterCriticalSection( &This->unk->DPL_lock );
1101
1102   hr = DPLAYX_GetConnectionSettingsA( dwAppID, lpData, lpdwDataSize );
1103
1104   LeaveCriticalSection( &This->unk->DPL_lock );
1105
1106   return hr;
1107 }
1108
1109 static HRESULT WINAPI IDirectPlayLobbyWImpl_GetConnectionSettings
1110 ( LPDIRECTPLAYLOBBY iface,
1111   DWORD dwAppID,
1112   LPVOID lpData,
1113   LPDWORD lpdwDataSize )
1114 {
1115   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
1116   HRESULT hr;
1117
1118   TRACE("(%p)->(0x%08lx,%p,%p)\n", This, dwAppID, lpData, lpdwDataSize );
1119
1120   EnterCriticalSection( &This->unk->DPL_lock );
1121
1122   hr = DPLAYX_GetConnectionSettingsW( dwAppID, lpData, lpdwDataSize );
1123
1124   LeaveCriticalSection( &This->unk->DPL_lock );
1125
1126   return hr;
1127 }
1128
1129 /********************************************************************
1130  *
1131  * Retrieves the message sent between a lobby client and a DirectPlay
1132  * application. All messages are queued until received.
1133  *
1134  */
1135 static HRESULT WINAPI IDirectPlayLobbyAImpl_ReceiveLobbyMessage
1136 ( LPDIRECTPLAYLOBBYA iface,
1137   DWORD dwFlags,
1138   DWORD dwAppID,
1139   LPDWORD lpdwMessageFlags,
1140   LPVOID lpData,
1141   LPDWORD lpdwDataSize )
1142 {
1143   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
1144   FIXME(":stub %p %08lx %08lx %p %p %p\n", This, dwFlags, dwAppID, lpdwMessageFlags, lpData,
1145          lpdwDataSize );
1146   return DPERR_OUTOFMEMORY;
1147 }
1148
1149 static HRESULT WINAPI IDirectPlayLobbyWImpl_ReceiveLobbyMessage
1150 ( LPDIRECTPLAYLOBBY iface,
1151   DWORD dwFlags,
1152   DWORD dwAppID,
1153   LPDWORD lpdwMessageFlags,
1154   LPVOID lpData,
1155   LPDWORD lpdwDataSize )
1156 {
1157   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
1158   FIXME(":stub %p %08lx %08lx %p %p %p\n", This, dwFlags, dwAppID, lpdwMessageFlags, lpData,
1159          lpdwDataSize );
1160   return DPERR_OUTOFMEMORY;
1161 }
1162
1163 typedef struct tagRunApplicationEnumStruct
1164 {
1165   IDirectPlayLobbyAImpl* This;
1166
1167   GUID  appGUID;
1168   LPSTR lpszPath;
1169   LPSTR lpszFileName;
1170   LPSTR lpszCommandLine;
1171   LPSTR lpszCurrentDirectory;
1172 } RunApplicationEnumStruct, *lpRunApplicationEnumStruct;
1173
1174 /* To be called by RunApplication to find how to invoke the function */
1175 static BOOL CALLBACK RunApplicationA_EnumLocalApplications
1176 ( LPCDPLAPPINFO   lpAppInfo,
1177   LPVOID          lpContext,
1178   DWORD           dwFlags )
1179 {
1180   lpRunApplicationEnumStruct lpData = (lpRunApplicationEnumStruct)lpContext;
1181
1182   if( IsEqualGUID( &lpAppInfo->guidApplication, &lpData->appGUID ) )
1183   {
1184     char  returnBuffer[200];
1185     DWORD returnType, sizeOfReturnBuffer;
1186     LPSTR clSubKey   = "CommandLine";
1187     LPSTR cdSubKey   = "CurrentDirectory";
1188     LPSTR fileSubKey = "File";
1189     LPSTR pathSubKey = "Path";
1190
1191     /* FIXME: Lazy man hack - dplay struct has the present reg key saved */
1192
1193     sizeOfReturnBuffer = 200;
1194
1195     /* Get all the appropriate data from the registry */
1196     if( RegQueryValueExA( lpData->This->dpl->hkCallbackKeyHack, clSubKey,
1197                           NULL, &returnType, returnBuffer,
1198                           &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1199     {
1200        ERR( ": missing CommandLine registry data member\n" );
1201     }
1202     else
1203     {
1204       lpData->lpszCommandLine = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, returnBuffer );
1205     }
1206
1207     sizeOfReturnBuffer = 200;
1208
1209     if( RegQueryValueExA( lpData->This->dpl->hkCallbackKeyHack, cdSubKey,
1210                           NULL, &returnType, returnBuffer,
1211                           &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1212     {
1213        ERR( ": missing CurrentDirectory registry data member\n" );
1214     }
1215     else
1216     {
1217       lpData->lpszCurrentDirectory = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, returnBuffer );
1218     }
1219
1220     sizeOfReturnBuffer = 200;
1221
1222     if( RegQueryValueExA( lpData->This->dpl->hkCallbackKeyHack, fileSubKey,
1223                           NULL, &returnType, returnBuffer,
1224                           &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1225     {
1226        ERR( ": missing File registry data member\n" );
1227     }
1228     else
1229     {
1230       lpData->lpszFileName = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, returnBuffer );
1231     }
1232
1233     sizeOfReturnBuffer = 200;
1234
1235     if( RegQueryValueExA( lpData->This->dpl->hkCallbackKeyHack, pathSubKey,
1236                           NULL, &returnType, returnBuffer,
1237                           &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1238     {
1239        ERR( ": missing Path registry data member\n" );
1240     }
1241     else
1242     {
1243       lpData->lpszPath = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, returnBuffer );
1244     }
1245
1246     return FALSE; /* No need to keep going as we found what we wanted */
1247   }
1248
1249   return TRUE; /* Keep enumerating, haven't found the application yet */
1250 }
1251
1252 /********************************************************************
1253  *
1254  * Starts an application and passes to it all the information to
1255  * connect to a session.
1256  *
1257  */
1258 static HRESULT WINAPI IDirectPlayLobbyAImpl_RunApplication
1259 ( LPDIRECTPLAYLOBBYA iface,
1260   DWORD dwFlags,
1261   LPDWORD lpdwAppID,
1262   LPDPLCONNECTION lpConn,
1263   HANDLE hReceiveEvent )
1264 {
1265   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
1266   HRESULT hr;
1267   RunApplicationEnumStruct enumData;
1268   char temp[200];
1269   STARTUPINFOA startupInfo;
1270   PROCESS_INFORMATION newProcessInfo;
1271   LPSTR appName;
1272
1273   TRACE( "(%p)->(0x%08lx,%p,%p,%x)\n", This, dwFlags, lpdwAppID, lpConn, hReceiveEvent );
1274
1275   if( dwFlags != 0 )
1276   {
1277     return DPERR_INVALIDPARAMS;
1278   }
1279
1280   EnterCriticalSection( &This->unk->DPL_lock );
1281
1282   ZeroMemory( &enumData, sizeof( enumData ) );
1283   enumData.This    = This;
1284   enumData.appGUID = lpConn->lpSessionDesc->guidApplication;
1285
1286   /* Our callback function will fill up the enumData structure with all the information
1287      required to start a new process */
1288   IDirectPlayLobby_EnumLocalApplications( iface, RunApplicationA_EnumLocalApplications,
1289                                           (LPVOID)(&enumData), 0 );
1290
1291   /* First the application name */
1292   strcpy( temp, enumData.lpszPath );
1293   strcat( temp, "\\" );
1294   strcat( temp, enumData.lpszFileName );
1295   HeapFree( GetProcessHeap(), 0, enumData.lpszPath );
1296   HeapFree( GetProcessHeap(), 0, enumData.lpszFileName );
1297   appName = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, temp );
1298
1299   /* Now the command line */
1300   strcat( temp, " " );
1301   strcat( temp, enumData.lpszCommandLine );
1302   HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1303   enumData.lpszCommandLine = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, temp );
1304
1305   ZeroMemory( &startupInfo, sizeof( startupInfo ) );
1306   startupInfo.cb = sizeof( startupInfo );
1307   /* FIXME: Should any fields be filled in? */
1308
1309   ZeroMemory( &newProcessInfo, sizeof( newProcessInfo ) );
1310
1311   if( !CreateProcessA( appName,
1312                        enumData.lpszCommandLine,
1313                        NULL,
1314                        NULL,
1315                        FALSE,
1316                        CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_CONSOLE | CREATE_SUSPENDED, /* Creation Flags */
1317                        NULL,
1318                        enumData.lpszCurrentDirectory,
1319                        &startupInfo,
1320                        &newProcessInfo
1321                      )
1322     )
1323   {
1324     FIXME( "Failed to create process for app %s\n", appName );
1325
1326     HeapFree( GetProcessHeap(), 0, appName );
1327     HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1328     HeapFree( GetProcessHeap(), 0, enumData.lpszCurrentDirectory );
1329
1330     return DPERR_CANTCREATEPROCESS;
1331   }
1332
1333   HeapFree( GetProcessHeap(), 0, appName );
1334   HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1335   HeapFree( GetProcessHeap(), 0, enumData.lpszCurrentDirectory );
1336
1337   /* Reserve this global application id! */
1338   if( !DPLAYX_CreateLobbyApplication( newProcessInfo.dwProcessId, hReceiveEvent ) )
1339   {
1340     ERR( "Unable to create global application data\n" );
1341   }
1342
1343   hr = IDirectPlayLobby_SetConnectionSettings( iface, 0, newProcessInfo.dwProcessId, lpConn );
1344
1345   if( hr != DP_OK )
1346   {
1347     FIXME( "SetConnectionSettings failure %s\n", DPLAYX_HresultToString( hr ) );
1348     return hr;
1349   }
1350
1351   /* Everything seems to have been set correctly, update the dwAppID */
1352   *lpdwAppID = newProcessInfo.dwProcessId;
1353
1354   /* Unsuspend the process */
1355   ResumeThread( newProcessInfo.dwThreadId );
1356
1357   LeaveCriticalSection( &This->unk->DPL_lock );
1358
1359   return DP_OK;
1360 }
1361
1362 static HRESULT WINAPI IDirectPlayLobbyWImpl_RunApplication
1363 ( LPDIRECTPLAYLOBBY iface,
1364   DWORD dwFlags,
1365   LPDWORD lpdwAppID,
1366   LPDPLCONNECTION lpConn,
1367   HANDLE hReceiveEvent )
1368 {
1369   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
1370   FIXME( "(%p)->(0x%08lx,%p,%p,%p):stub\n", This, dwFlags, lpdwAppID, lpConn, (void *)hReceiveEvent );
1371   return DPERR_OUTOFMEMORY;
1372 }
1373
1374 /********************************************************************
1375  *
1376  * Sends a message between the application and the lobby client.
1377  * All messages are queued until received.
1378  *
1379  */
1380 static HRESULT WINAPI IDirectPlayLobbyAImpl_SendLobbyMessage
1381 ( LPDIRECTPLAYLOBBYA iface,
1382   DWORD dwFlags,
1383   DWORD dwAppID,
1384   LPVOID lpData,
1385   DWORD dwDataSize )
1386 {
1387   FIXME(":stub\n");
1388   return DPERR_OUTOFMEMORY;
1389 }
1390
1391 static HRESULT WINAPI IDirectPlayLobbyWImpl_SendLobbyMessage
1392 ( LPDIRECTPLAYLOBBY iface,
1393   DWORD dwFlags,
1394   DWORD dwAppID,
1395   LPVOID lpData,
1396   DWORD dwDataSize )
1397 {
1398   FIXME(":stub\n");
1399   return DPERR_OUTOFMEMORY;
1400 }
1401
1402 /********************************************************************
1403  *
1404  * Modifies the DPLCONNECTION structure to contain all information
1405  * needed to start and connect an application.
1406  *
1407  */
1408 static HRESULT WINAPI IDirectPlayLobbyWImpl_SetConnectionSettings
1409 ( LPDIRECTPLAYLOBBY iface,
1410   DWORD dwFlags,
1411   DWORD dwAppID,
1412   LPDPLCONNECTION lpConn )
1413 {
1414   ICOM_THIS(IDirectPlayLobbyWImpl,iface);
1415   HRESULT hr;
1416
1417   TRACE("(%p)->(0x%08lx,0x%08lx,%p)\n", This, dwFlags, dwAppID, lpConn );
1418
1419   EnterCriticalSection( &This->unk->DPL_lock );
1420
1421   hr = DPLAYX_SetConnectionSettingsW( dwFlags, dwAppID, lpConn );
1422
1423   LeaveCriticalSection( &This->unk->DPL_lock );
1424
1425   return hr;
1426 }
1427
1428 static HRESULT WINAPI IDirectPlayLobbyAImpl_SetConnectionSettings
1429 ( LPDIRECTPLAYLOBBYA iface,
1430   DWORD dwFlags,
1431   DWORD dwAppID,
1432   LPDPLCONNECTION lpConn )
1433 {
1434   ICOM_THIS(IDirectPlayLobbyAImpl,iface);
1435   HRESULT hr;
1436
1437   TRACE("(%p)->(0x%08lx,0x%08lx,%p)\n", This, dwFlags, dwAppID, lpConn );
1438
1439   EnterCriticalSection( &This->unk->DPL_lock );
1440
1441   hr = DPLAYX_SetConnectionSettingsA( dwFlags, dwAppID, lpConn );
1442
1443   LeaveCriticalSection( &This->unk->DPL_lock );
1444
1445   return hr;
1446 }
1447
1448 /********************************************************************
1449  *
1450  * Registers an event that will be set when a lobby message is received.
1451  *
1452  */
1453 static HRESULT WINAPI IDirectPlayLobbyAImpl_SetLobbyMessageEvent
1454 ( LPDIRECTPLAYLOBBYA iface,
1455   DWORD dwFlags,
1456   DWORD dwAppID,
1457   HANDLE hReceiveEvent )
1458 {
1459   FIXME(":stub\n");
1460   return DPERR_OUTOFMEMORY;
1461 }
1462
1463 static HRESULT WINAPI IDirectPlayLobbyWImpl_SetLobbyMessageEvent
1464 ( LPDIRECTPLAYLOBBY iface,
1465   DWORD dwFlags,
1466   DWORD dwAppID,
1467   HANDLE hReceiveEvent )
1468 {
1469   FIXME(":stub\n");
1470   return DPERR_OUTOFMEMORY;
1471 }
1472
1473
1474 /* DPL 2 methods */
1475
1476 /********************************************************************
1477  *
1478  * Registers an event that will be set when a lobby message is received.
1479  *
1480  */
1481 static HRESULT WINAPI IDirectPlayLobby2WImpl_CreateCompoundAddress
1482 ( LPDIRECTPLAYLOBBY2 iface,
1483   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1484   DWORD dwElementCount,
1485   LPVOID lpAddress,
1486   LPDWORD lpdwAddressSize )
1487 {
1488   return DPL_CreateCompoundAddress( lpElements, dwElementCount, lpAddress, lpdwAddressSize, FALSE );
1489 }
1490
1491 static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateCompoundAddress
1492 ( LPDIRECTPLAYLOBBY2A iface,
1493   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1494   DWORD dwElementCount,
1495   LPVOID lpAddress,
1496   LPDWORD lpdwAddressSize )
1497 {
1498   return DPL_CreateCompoundAddress( lpElements, dwElementCount, lpAddress, lpdwAddressSize, TRUE );
1499 }
1500
1501 HRESULT DPL_CreateCompoundAddress
1502 ( LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1503   DWORD dwElementCount,
1504   LPVOID lpAddress,
1505   LPDWORD lpdwAddressSize,
1506   BOOL bAnsiInterface )
1507 {
1508   DWORD dwSizeRequired = 0;
1509   DWORD dwElements;
1510   LPCDPCOMPOUNDADDRESSELEMENT lpOrigElements = lpElements;
1511
1512   TRACE("(%p,0x%08lx,%p,%p)\n", lpElements, dwElementCount, lpAddress, lpdwAddressSize );
1513
1514   /* Parameter check */
1515   if( ( lpElements == NULL ) ||
1516       ( dwElementCount == 0 )   /* FIXME: Not sure if this is a failure case */
1517     )
1518   {
1519     return DPERR_INVALIDPARAMS;
1520   }
1521
1522   /* Add the total size chunk */
1523   dwSizeRequired += sizeof( DPADDRESS ) + sizeof( DWORD );
1524
1525   /* Calculate the size of the buffer required */
1526   for ( dwElements = dwElementCount; dwElements > 0; --dwElements, ++lpElements )
1527   {
1528     if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ServiceProvider ) ) ||
1529          ( IsEqualGUID( &lpElements->guidDataType, &DPAID_LobbyProvider ) )
1530        )
1531     {
1532       dwSizeRequired += sizeof( DPADDRESS ) + sizeof( GUID );
1533     }
1534     else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Phone ) ) ||
1535               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Modem ) ) ||
1536               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INet ) )
1537             )
1538     {
1539       if( !bAnsiInterface )
1540       {
1541         ERR( "Ansi GUIDs used for unicode interface\n" );
1542         return DPERR_INVALIDFLAGS;
1543       }
1544
1545       dwSizeRequired += sizeof( DPADDRESS ) + lpElements->dwDataSize;
1546     }
1547     else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_PhoneW ) ) ||
1548               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ModemW ) ) ||
1549               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetW ) )
1550             )
1551     {
1552       if( bAnsiInterface )
1553       {
1554         ERR( "Unicode GUIDs used for ansi interface\n" );
1555         return DPERR_INVALIDFLAGS;
1556       }
1557
1558       FIXME( "Right size for unicode interface?\n" );
1559       dwSizeRequired += sizeof( DPADDRESS ) + lpElements->dwDataSize * sizeof( WCHAR );
1560     }
1561     else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetPort ) )
1562     {
1563       dwSizeRequired += sizeof( DPADDRESS ) + sizeof( WORD );
1564     }
1565     else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ComPort ) )
1566     {
1567       FIXME( "Right size for unicode interface?\n" );
1568       dwSizeRequired += sizeof( DPADDRESS ) + sizeof( DPCOMPORTADDRESS ); /* FIXME: Right size? */
1569     }
1570     else
1571     {
1572       ERR( "Unknown GUID %s\n", debugstr_guid(&lpElements->guidDataType) );
1573       return DPERR_INVALIDFLAGS;
1574     }
1575   }
1576
1577   /* The user wants to know how big a buffer to allocate for us */
1578   if( ( lpAddress == NULL ) ||
1579       ( *lpdwAddressSize < dwSizeRequired )
1580     )
1581   {
1582     *lpdwAddressSize = dwSizeRequired;
1583     return DPERR_BUFFERTOOSMALL;
1584   }
1585
1586   /* Add the total size chunk */
1587   {
1588     LPDPADDRESS lpdpAddress = (LPDPADDRESS)lpAddress;
1589
1590     lpdpAddress->guidDataType = DPAID_TotalSize;
1591     lpdpAddress->dwDataSize = sizeof( DWORD );
1592     lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1593
1594     *(LPDWORD)lpAddress = dwSizeRequired;
1595     lpAddress = (char *) lpAddress + sizeof( DWORD );
1596   }
1597
1598   /* Calculate the size of the buffer required */
1599   for( dwElements = dwElementCount, lpElements = lpOrigElements;
1600        dwElements > 0;
1601        --dwElements, ++lpElements )
1602   {
1603     if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ServiceProvider ) ) ||
1604          ( IsEqualGUID( &lpElements->guidDataType, &DPAID_LobbyProvider ) )
1605        )
1606     {
1607       LPDPADDRESS lpdpAddress = (LPDPADDRESS)lpAddress;
1608
1609       lpdpAddress->guidDataType = lpElements->guidDataType;
1610       lpdpAddress->dwDataSize = sizeof( GUID );
1611       lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1612
1613       *((LPGUID)lpAddress) = *((LPGUID)lpElements->lpData);
1614       lpAddress = (char *) lpAddress + sizeof( GUID );
1615     }
1616     else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Phone ) ) ||
1617               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Modem ) ) ||
1618               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INet ) )
1619             )
1620     {
1621       LPDPADDRESS lpdpAddress = (LPDPADDRESS)lpAddress;
1622
1623       lpdpAddress->guidDataType = lpElements->guidDataType;
1624       lpdpAddress->dwDataSize = lpElements->dwDataSize;
1625       lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1626
1627       lstrcpynA( (LPSTR)lpAddress,
1628                  (LPCSTR)lpElements->lpData,
1629                  lpElements->dwDataSize );
1630       lpAddress = (char *) lpAddress + lpElements->dwDataSize;
1631     }
1632     else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_PhoneW ) ) ||
1633               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ModemW ) ) ||
1634               ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetW ) )
1635             )
1636     {
1637       LPDPADDRESS lpdpAddress = (LPDPADDRESS)lpAddress;
1638
1639       lpdpAddress->guidDataType = lpElements->guidDataType;
1640       lpdpAddress->dwDataSize = lpElements->dwDataSize;
1641       lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1642
1643       lstrcpynW( (LPWSTR)lpAddress,
1644                  (LPCWSTR)lpElements->lpData,
1645                  lpElements->dwDataSize );
1646       lpAddress = (char *) lpAddress + lpElements->dwDataSize * sizeof( WCHAR );
1647     }
1648     else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetPort ) )
1649     {
1650       LPDPADDRESS lpdpAddress = (LPDPADDRESS)lpAddress;
1651
1652       lpdpAddress->guidDataType = lpElements->guidDataType;
1653       lpdpAddress->dwDataSize = lpElements->dwDataSize;
1654       lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1655
1656       *((LPWORD)lpAddress) = *((LPWORD)lpElements->lpData);
1657       lpAddress = (char *) lpAddress + sizeof( WORD );
1658     }
1659     else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ComPort ) )
1660     {
1661       LPDPADDRESS lpdpAddress = (LPDPADDRESS)lpAddress;
1662
1663       lpdpAddress->guidDataType = lpElements->guidDataType;
1664       lpdpAddress->dwDataSize = lpElements->dwDataSize;
1665       lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1666
1667       memcpy( lpAddress, lpElements->lpData, sizeof( DPADDRESS ) );
1668       lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1669     }
1670   }
1671
1672   return DP_OK;
1673 }
1674
1675 /* DPL 3 methods */
1676
1677 static HRESULT WINAPI IDirectPlayLobby3WImpl_ConnectEx
1678 ( LPDIRECTPLAYLOBBY3 iface, DWORD dwFlags, REFIID riid, LPVOID* lplpDP, IUnknown* pUnk )
1679 {
1680   FIXME(":stub\n");
1681   return DP_OK;
1682 }
1683
1684 static HRESULT WINAPI IDirectPlayLobby3AImpl_ConnectEx
1685 ( LPDIRECTPLAYLOBBY3A iface, DWORD dwFlags, REFIID riid, LPVOID* lplpDP, IUnknown* pUnk )
1686 {
1687   FIXME(":stub\n");
1688   return DP_OK;
1689 }
1690
1691 static HRESULT WINAPI IDirectPlayLobby3WImpl_RegisterApplication
1692 ( LPDIRECTPLAYLOBBY3 iface, DWORD dwFlags, LPDPAPPLICATIONDESC lpAppDesc )
1693 {
1694   FIXME(":stub\n");
1695   return DP_OK;
1696 }
1697
1698 static HRESULT WINAPI IDirectPlayLobby3AImpl_RegisterApplication
1699 ( LPDIRECTPLAYLOBBY3A iface, DWORD dwFlags, LPDPAPPLICATIONDESC lpAppDesc )
1700 {
1701   FIXME(":stub\n");
1702   return DP_OK;
1703 }
1704
1705 static HRESULT WINAPI IDirectPlayLobby3WImpl_UnregisterApplication
1706 ( LPDIRECTPLAYLOBBY3 iface, DWORD dwFlags, REFGUID lpAppDesc )
1707 {
1708   FIXME(":stub\n");
1709   return DP_OK;
1710 }
1711
1712 static HRESULT WINAPI IDirectPlayLobby3AImpl_UnregisterApplication
1713 ( LPDIRECTPLAYLOBBY3A iface, DWORD dwFlags, REFGUID lpAppDesc )
1714 {
1715   FIXME(":stub\n");
1716   return DP_OK;
1717 }
1718
1719 static HRESULT WINAPI IDirectPlayLobby3WImpl_WaitForConnectionSettings
1720 ( LPDIRECTPLAYLOBBY3 iface, DWORD dwFlags )
1721 {
1722   FIXME(":stub\n");
1723   return DP_OK;
1724 }
1725
1726 static HRESULT WINAPI IDirectPlayLobby3AImpl_WaitForConnectionSettings
1727 ( LPDIRECTPLAYLOBBY3A iface, DWORD dwFlags )
1728 {
1729   FIXME(":stub\n");
1730   return DP_OK;
1731 }
1732
1733
1734 /* Virtual Table definitions for DPL{1,2,3}{A,W} */
1735
1736 /* Note: Hack so we can reuse the old functions without compiler warnings */
1737 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1738 # define XCAST(fun)     (typeof(directPlayLobbyAVT.fn##fun))
1739 #else
1740 # define XCAST(fun)     (void*)
1741 #endif
1742
1743 /* Direct Play Lobby 1 (ascii) Virtual Table for methods */
1744 /* All lobby 1 methods are exactly the same except QueryInterface */
1745 static struct ICOM_VTABLE(IDirectPlayLobby) directPlayLobbyAVT =
1746 {
1747   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1748
1749   IDirectPlayLobbyAImpl_QueryInterface,
1750   XCAST(AddRef)IDirectPlayLobbyImpl_AddRef,
1751   XCAST(Release)IDirectPlayLobbyAImpl_Release,
1752
1753   IDirectPlayLobbyAImpl_Connect,
1754   IDirectPlayLobbyAImpl_CreateAddress,
1755   IDirectPlayLobbyAImpl_EnumAddress,
1756   IDirectPlayLobbyAImpl_EnumAddressTypes,
1757   IDirectPlayLobbyAImpl_EnumLocalApplications,
1758   IDirectPlayLobbyAImpl_GetConnectionSettings,
1759   IDirectPlayLobbyAImpl_ReceiveLobbyMessage,
1760   IDirectPlayLobbyAImpl_RunApplication,
1761   IDirectPlayLobbyAImpl_SendLobbyMessage,
1762   IDirectPlayLobbyAImpl_SetConnectionSettings,
1763   IDirectPlayLobbyAImpl_SetLobbyMessageEvent
1764 };
1765 #undef XCAST
1766
1767
1768 /* Note: Hack so we can reuse the old functions without compiler warnings */
1769 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1770 # define XCAST(fun)     (typeof(directPlayLobbyWVT.fn##fun))
1771 #else
1772 # define XCAST(fun)     (void*)
1773 #endif
1774
1775 /* Direct Play Lobby 1 (unicode) Virtual Table for methods */
1776 static ICOM_VTABLE(IDirectPlayLobby) directPlayLobbyWVT =
1777 {
1778   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1779
1780   IDirectPlayLobbyW_QueryInterface,
1781   XCAST(AddRef)IDirectPlayLobbyImpl_AddRef,
1782   XCAST(Release)IDirectPlayLobbyAImpl_Release,
1783
1784   IDirectPlayLobbyWImpl_Connect,
1785   IDirectPlayLobbyWImpl_CreateAddress,
1786   IDirectPlayLobbyWImpl_EnumAddress,
1787   IDirectPlayLobbyWImpl_EnumAddressTypes,
1788   IDirectPlayLobbyWImpl_EnumLocalApplications,
1789   IDirectPlayLobbyWImpl_GetConnectionSettings,
1790   IDirectPlayLobbyWImpl_ReceiveLobbyMessage,
1791   IDirectPlayLobbyWImpl_RunApplication,
1792   IDirectPlayLobbyWImpl_SendLobbyMessage,
1793   IDirectPlayLobbyWImpl_SetConnectionSettings,
1794   IDirectPlayLobbyWImpl_SetLobbyMessageEvent
1795 };
1796 #undef XCAST
1797
1798 /* Note: Hack so we can reuse the old functions without compiler warnings */
1799 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1800 # define XCAST(fun)     (typeof(directPlayLobby2AVT.fn##fun))
1801 #else
1802 # define XCAST(fun)     (void*)
1803 #endif
1804
1805 /* Direct Play Lobby 2 (ascii) Virtual Table for methods */
1806 static ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2AVT =
1807 {
1808   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1809
1810   IDirectPlayLobby2AImpl_QueryInterface,
1811   XCAST(AddRef)IDirectPlayLobbyImpl_AddRef,
1812   XCAST(Release)IDirectPlayLobbyAImpl_Release,
1813
1814   XCAST(Connect)IDirectPlayLobbyAImpl_Connect,
1815   XCAST(CreateAddress)IDirectPlayLobbyAImpl_CreateAddress,
1816   XCAST(EnumAddress)IDirectPlayLobbyAImpl_EnumAddress,
1817   XCAST(EnumAddressTypes)IDirectPlayLobbyAImpl_EnumAddressTypes,
1818   XCAST(EnumLocalApplications)IDirectPlayLobbyAImpl_EnumLocalApplications,
1819   XCAST(GetConnectionSettings)IDirectPlayLobbyAImpl_GetConnectionSettings,
1820   XCAST(ReceiveLobbyMessage)IDirectPlayLobbyAImpl_ReceiveLobbyMessage,
1821   XCAST(RunApplication)IDirectPlayLobbyAImpl_RunApplication,
1822   XCAST(SendLobbyMessage)IDirectPlayLobbyAImpl_SendLobbyMessage,
1823   XCAST(SetConnectionSettings)IDirectPlayLobbyAImpl_SetConnectionSettings,
1824   XCAST(SetLobbyMessageEvent)IDirectPlayLobbyAImpl_SetLobbyMessageEvent,
1825
1826   IDirectPlayLobby2AImpl_CreateCompoundAddress
1827 };
1828 #undef XCAST
1829
1830 /* Note: Hack so we can reuse the old functions without compiler warnings */
1831 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1832 # define XCAST(fun)     (typeof(directPlayLobby2AVT.fn##fun))
1833 #else
1834 # define XCAST(fun)     (void*)
1835 #endif
1836
1837 /* Direct Play Lobby 2 (unicode) Virtual Table for methods */
1838 static ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2WVT =
1839 {
1840   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1841
1842   IDirectPlayLobby2WImpl_QueryInterface,
1843   XCAST(AddRef)IDirectPlayLobbyImpl_AddRef,
1844   XCAST(Release)IDirectPlayLobbyAImpl_Release,
1845
1846   XCAST(Connect)IDirectPlayLobbyWImpl_Connect,
1847   XCAST(CreateAddress)IDirectPlayLobbyWImpl_CreateAddress,
1848   XCAST(EnumAddress)IDirectPlayLobbyWImpl_EnumAddress,
1849   XCAST(EnumAddressTypes)IDirectPlayLobbyWImpl_EnumAddressTypes,
1850   XCAST(EnumLocalApplications)IDirectPlayLobbyWImpl_EnumLocalApplications,
1851   XCAST(GetConnectionSettings)IDirectPlayLobbyWImpl_GetConnectionSettings,
1852   XCAST(ReceiveLobbyMessage)IDirectPlayLobbyWImpl_ReceiveLobbyMessage,
1853   XCAST(RunApplication)IDirectPlayLobbyWImpl_RunApplication,
1854   XCAST(SendLobbyMessage)IDirectPlayLobbyWImpl_SendLobbyMessage,
1855   XCAST(SetConnectionSettings)IDirectPlayLobbyWImpl_SetConnectionSettings,
1856   XCAST(SetLobbyMessageEvent)IDirectPlayLobbyWImpl_SetLobbyMessageEvent,
1857
1858   IDirectPlayLobby2WImpl_CreateCompoundAddress
1859 };
1860 #undef XCAST
1861
1862 /* Direct Play Lobby 3 (ascii) Virtual Table for methods */
1863
1864 /* Note: Hack so we can reuse the old functions without compiler warnings */
1865 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1866 # define XCAST(fun)     (typeof(directPlayLobby3AVT.fn##fun))
1867 #else
1868 # define XCAST(fun)     (void*)
1869 #endif
1870
1871 static ICOM_VTABLE(IDirectPlayLobby3) directPlayLobby3AVT =
1872 {
1873   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1874   IDirectPlayLobby3AImpl_QueryInterface,
1875   XCAST(AddRef)IDirectPlayLobbyImpl_AddRef,
1876   XCAST(Release)IDirectPlayLobbyAImpl_Release,
1877
1878   XCAST(Connect)IDirectPlayLobbyAImpl_Connect,
1879   XCAST(CreateAddress)IDirectPlayLobbyAImpl_CreateAddress,
1880   XCAST(EnumAddress)IDirectPlayLobbyAImpl_EnumAddress,
1881   XCAST(EnumAddressTypes)IDirectPlayLobbyAImpl_EnumAddressTypes,
1882   XCAST(EnumLocalApplications)IDirectPlayLobbyAImpl_EnumLocalApplications,
1883   XCAST(GetConnectionSettings)IDirectPlayLobbyAImpl_GetConnectionSettings,
1884   XCAST(ReceiveLobbyMessage)IDirectPlayLobbyAImpl_ReceiveLobbyMessage,
1885   XCAST(RunApplication)IDirectPlayLobbyAImpl_RunApplication,
1886   XCAST(SendLobbyMessage)IDirectPlayLobbyAImpl_SendLobbyMessage,
1887   XCAST(SetConnectionSettings)IDirectPlayLobbyAImpl_SetConnectionSettings,
1888   XCAST(SetLobbyMessageEvent)IDirectPlayLobbyAImpl_SetLobbyMessageEvent,
1889
1890   XCAST(CreateCompoundAddress)IDirectPlayLobby2AImpl_CreateCompoundAddress,
1891
1892   IDirectPlayLobby3AImpl_ConnectEx,
1893   IDirectPlayLobby3AImpl_RegisterApplication,
1894   IDirectPlayLobby3AImpl_UnregisterApplication,
1895   IDirectPlayLobby3AImpl_WaitForConnectionSettings
1896 };
1897 #undef XCAST
1898
1899 /* Direct Play Lobby 3 (unicode) Virtual Table for methods */
1900
1901 /* Note: Hack so we can reuse the old functions without compiler warnings */
1902 #if !defined(__STRICT_ANSI__) && defined(__GNUC__)
1903 # define XCAST(fun)     (typeof(directPlayLobby3WVT.fn##fun))
1904 #else
1905 # define XCAST(fun)     (void*)
1906 #endif
1907
1908 static ICOM_VTABLE(IDirectPlayLobby3) directPlayLobby3WVT =
1909 {
1910   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1911   IDirectPlayLobby3WImpl_QueryInterface,
1912   XCAST(AddRef)IDirectPlayLobbyImpl_AddRef,
1913   XCAST(Release)IDirectPlayLobbyAImpl_Release,
1914
1915   XCAST(Connect)IDirectPlayLobbyWImpl_Connect,
1916   XCAST(CreateAddress)IDirectPlayLobbyWImpl_CreateAddress,
1917   XCAST(EnumAddress)IDirectPlayLobbyWImpl_EnumAddress,
1918   XCAST(EnumAddressTypes)IDirectPlayLobbyWImpl_EnumAddressTypes,
1919   XCAST(EnumLocalApplications)IDirectPlayLobbyWImpl_EnumLocalApplications,
1920   XCAST(GetConnectionSettings)IDirectPlayLobbyWImpl_GetConnectionSettings,
1921   XCAST(ReceiveLobbyMessage)IDirectPlayLobbyWImpl_ReceiveLobbyMessage,
1922   XCAST(RunApplication)IDirectPlayLobbyWImpl_RunApplication,
1923   XCAST(SendLobbyMessage)IDirectPlayLobbyWImpl_SendLobbyMessage,
1924   XCAST(SetConnectionSettings)IDirectPlayLobbyWImpl_SetConnectionSettings,
1925   XCAST(SetLobbyMessageEvent)IDirectPlayLobbyWImpl_SetLobbyMessageEvent,
1926
1927   XCAST(CreateCompoundAddress)IDirectPlayLobby2WImpl_CreateCompoundAddress,
1928
1929   IDirectPlayLobby3WImpl_ConnectEx,
1930   IDirectPlayLobby3WImpl_RegisterApplication,
1931   IDirectPlayLobby3WImpl_UnregisterApplication,
1932   IDirectPlayLobby3WImpl_WaitForConnectionSettings
1933 };
1934 #undef XCAST
1935
1936
1937 /*********************************************************
1938  *
1939  * Direct Play and Direct Play Lobby Interface Implementation
1940  *
1941  *********************************************************/
1942
1943 /***************************************************************************
1944  *  DirectPlayLobbyCreateA   (DPLAYX.4)
1945  *
1946  */
1947 HRESULT WINAPI DirectPlayLobbyCreateA( LPGUID lpGUIDDSP,
1948                                        LPDIRECTPLAYLOBBYA *lplpDPL,
1949                                        IUnknown *lpUnk,
1950                                        LPVOID lpData,
1951                                        DWORD dwDataSize )
1952 {
1953   TRACE("lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
1954         lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
1955
1956   /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
1957    * equal 0. These fields are mostly for future expansion.
1958    */
1959   if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
1960   {
1961      *lplpDPL = NULL;
1962      return DPERR_INVALIDPARAMS;
1963   }
1964
1965   return directPlayLobby_QueryInterface( &IID_IDirectPlayLobbyA, (void**)lplpDPL );
1966 }
1967
1968 /***************************************************************************
1969  *  DirectPlayLobbyCreateW   (DPLAYX.5)
1970  *
1971  */
1972 HRESULT WINAPI DirectPlayLobbyCreateW( LPGUID lpGUIDDSP,
1973                                        LPDIRECTPLAYLOBBY *lplpDPL,
1974                                        IUnknown *lpUnk,
1975                                        LPVOID lpData,
1976                                        DWORD dwDataSize )
1977 {
1978   TRACE("lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
1979         lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
1980
1981   /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
1982    * equal 0. These fields are mostly for future expansion.
1983    */
1984   if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
1985   {
1986      *lplpDPL = NULL;
1987      ERR("Bad parameters!\n" );
1988      return DPERR_INVALIDPARAMS;
1989   }
1990
1991   return directPlayLobby_QueryInterface( &IID_IDirectPlayLobby, (void**)lplpDPL );
1992
1993 }