ReactOS  0.4.14-dev-114-gc8cbd56
dplobby.c
Go to the documentation of this file.
1 /* Direct Play Lobby 2 & 3 Implementation
2  *
3  * Copyright 1998,1999,2000 - Peter Hunnisett
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18  */
19 #include <stdarg.h>
20 #include <string.h>
21 
22 #define COBJMACROS
23 #define NONAMELESSUNION
24 
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winerror.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "wine/debug.h"
31 
32 #include "dplayx_global.h"
33 #include "dplayx_messages.h"
34 #include "dplayx_queue.h"
35 #include "dplobby.h"
36 
38 
39 /* Forward declarations for this module helper methods */
41  LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface )DECLSPEC_HIDDEN;
42 
43 static HRESULT DPL_CreateAddress( REFGUID guidSP, REFGUID guidDataType, LPCVOID lpData, DWORD dwDataSize,
44  LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface );
45 
46 
47 /*****************************************************************************
48  * IDirectPlayLobby {1,2,3} implementation structure
49  *
50  * The philosophy behind this extra pointer dereference is that I wanted to
51  * have the same structure for all types of objects without having to do
52  * a lot of casting. I also only wanted to implement an interface in the
53  * object it was "released" with IUnknown interface being implemented in the 1 version.
54  * Of course, with these new interfaces comes the data required to keep the state required
55  * by these interfaces. So, basically, the pointers contain the data associated with
56  * a release. If you use the data associated with release 3 in a release 2 object, you'll
57  * get a run time trap, as that won't have any data.
58  *
59  */
60 struct DPLMSG
61 {
62  DPQ_ENTRY( DPLMSG ) msgs; /* Link to next queued message */
63 };
64 typedef struct DPLMSG* LPDPLMSG;
65 
66 typedef struct IDirectPlayLobbyImpl
67 {
68  IDirectPlayLobby IDirectPlayLobby_iface;
70  IDirectPlayLobby2 IDirectPlayLobby2_iface;
72  IDirectPlayLobby3 IDirectPlayLobby3_iface;
74  LONG numIfaces; /* "in use interfaces" refcount */
79  DPQ_HEAD( DPLMSG ) msgs; /* List of messages received */
81 
82 static inline IDirectPlayLobbyImpl *impl_from_IDirectPlayLobby( IDirectPlayLobby *iface )
83 {
84  return CONTAINING_RECORD( iface, IDirectPlayLobbyImpl, IDirectPlayLobby_iface );
85 }
86 
88 {
89  return CONTAINING_RECORD( iface, IDirectPlayLobbyImpl, IDirectPlayLobbyA_iface );
90 }
91 
92 static inline IDirectPlayLobbyImpl *impl_from_IDirectPlayLobby2( IDirectPlayLobby2 *iface )
93 {
94  return CONTAINING_RECORD( iface, IDirectPlayLobbyImpl, IDirectPlayLobby2_iface );
95 }
96 
98 {
99  return CONTAINING_RECORD( iface, IDirectPlayLobbyImpl, IDirectPlayLobby2A_iface );
100 }
101 
102 static inline IDirectPlayLobbyImpl *impl_from_IDirectPlayLobby3( IDirectPlayLobby3 *iface )
103 {
104  return CONTAINING_RECORD( iface, IDirectPlayLobbyImpl, IDirectPlayLobby3_iface );
105 }
106 
108 {
109  return CONTAINING_RECORD( iface, IDirectPlayLobbyImpl, IDirectPlayLobby3A_iface );
110 }
111 
113 {
114  if ( obj->msgtid )
115  FIXME( "Should kill the msg thread\n" );
116 
117  DPQ_DELETEQ( obj->msgs, msgs, LPDPLMSG, cbDeleteElemFromHeap );
118  obj->lock.DebugInfo->Spare[0] = 0;
119  DeleteCriticalSection( &obj->lock );
120  HeapFree( GetProcessHeap(), 0, obj );
121 }
122 
124  void **ppv )
125 {
127  return IDirectPlayLobby_QueryInterface( &This->IDirectPlayLobby3_iface, riid, ppv );
128 }
129 
131  void **ppv )
132 {
134  return IDirectPlayLobby_QueryInterface( &This->IDirectPlayLobby3_iface, riid, ppv );
135 }
136 
138  void **ppv )
139 {
141  return IDirectPlayLobby_QueryInterface( &This->IDirectPlayLobby3_iface, riid, ppv );
142 }
143 
145  void **ppv )
146 {
148  return IDirectPlayLobby_QueryInterface( &This->IDirectPlayLobby3_iface, riid, ppv );
149 }
150 
152  void **ppv )
153 {
155  return IDirectPlayLobby_QueryInterface( &This->IDirectPlayLobby3_iface, riid, ppv );
156 }
157 
159  void **ppv )
160 {
162 
163  if ( IsEqualGUID( &IID_IUnknown, riid ) )
164  {
165  TRACE( "(%p)->(IID_IUnknown %p)\n", This, ppv );
166  *ppv = &This->IDirectPlayLobby_iface;
167  }
168  else if ( IsEqualGUID( &IID_IDirectPlayLobby, riid ) )
169  {
170  TRACE( "(%p)->(IID_IDirectPlayLobby %p)\n", This, ppv );
171  *ppv = &This->IDirectPlayLobby_iface;
172  }
173  else if ( IsEqualGUID( &IID_IDirectPlayLobbyA, riid ) )
174  {
175  TRACE( "(%p)->(IID_IDirectPlayLobbyA %p)\n", This, ppv );
176  *ppv = &This->IDirectPlayLobbyA_iface;
177  }
178  else if ( IsEqualGUID( &IID_IDirectPlayLobby2, riid ) )
179  {
180  TRACE( "(%p)->(IID_IDirectPlayLobby2 %p)\n", This, ppv );
181  *ppv = &This->IDirectPlayLobby2_iface;
182  }
183  else if ( IsEqualGUID( &IID_IDirectPlayLobby2A, riid ) )
184  {
185  TRACE( "(%p)->(IID_IDirectPlayLobby2A %p)\n", This, ppv );
186  *ppv = &This->IDirectPlayLobby2A_iface;
187  }
188  else if ( IsEqualGUID( &IID_IDirectPlayLobby3, riid ) )
189  {
190  TRACE( "(%p)->(IID_IDirectPlay3 %p)\n", This, ppv );
191  *ppv = &This->IDirectPlayLobby3_iface;
192  }
193  else if ( IsEqualGUID( &IID_IDirectPlayLobby3A, riid ) )
194  {
195  TRACE( "(%p)->(IID_IDirectPlayLobby3A %p)\n", This, ppv );
196  *ppv = &This->IDirectPlayLobby3A_iface;
197  }
198  else
199  {
200  WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
201  *ppv = NULL;
202  return E_NOINTERFACE;
203  }
204 
205  IUnknown_AddRef((IUnknown*)*ppv);
206  return S_OK;
207 }
208 
210 {
212  ULONG ref = InterlockedIncrement( &This->refA );
213 
214  TRACE( "(%p) refA=%d\n", This, ref );
215 
216  if ( ref == 1 )
217  InterlockedIncrement( &This->numIfaces );
218 
219  return ref;
220 }
221 
222 static ULONG WINAPI IDirectPlayLobbyImpl_AddRef( IDirectPlayLobby *iface )
223 {
225  ULONG ref = InterlockedIncrement( &This->ref );
226 
227  TRACE( "(%p) ref=%d\n", This, ref );
228 
229  if ( ref == 1 )
230  InterlockedIncrement( &This->numIfaces );
231 
232  return ref;
233 }
234 
236 {
238  ULONG ref = InterlockedIncrement( &This->ref2A );
239 
240  TRACE( "(%p) ref2A=%d\n", This, ref );
241 
242  if ( ref == 1 )
243  InterlockedIncrement( &This->numIfaces );
244 
245  return ref;
246 }
247 
248 static ULONG WINAPI IDirectPlayLobby2Impl_AddRef(IDirectPlayLobby2 *iface)
249 {
251  ULONG ref = InterlockedIncrement( &This->ref2 );
252 
253  TRACE( "(%p) ref2=%d\n", This, ref );
254 
255  if ( ref == 1 )
256  InterlockedIncrement( &This->numIfaces );
257 
258  return ref;
259 }
260 
262 {
264  ULONG ref = InterlockedIncrement( &This->ref3A );
265 
266  TRACE( "(%p) ref3A=%d\n", This, ref );
267 
268  if ( ref == 1 )
269  InterlockedIncrement( &This->numIfaces );
270 
271  return ref;
272 }
273 
274 static ULONG WINAPI IDirectPlayLobby3Impl_AddRef(IDirectPlayLobby3 *iface)
275 {
277  ULONG ref = InterlockedIncrement( &This->ref3 );
278 
279  TRACE( "(%p) ref3=%d\n", This, ref );
280 
281  if ( ref == 1 )
282  InterlockedIncrement( &This->numIfaces );
283 
284  return ref;
285 }
286 
288 {
290  ULONG ref = InterlockedDecrement( &This->refA );
291 
292  TRACE( "(%p) refA=%d\n", This, ref );
293 
294  if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
296 
297  return ref;
298 }
299 
300 static ULONG WINAPI IDirectPlayLobbyImpl_Release( IDirectPlayLobby *iface )
301 {
303  ULONG ref = InterlockedDecrement( &This->ref );
304 
305  TRACE( "(%p) ref=%d\n", This, ref );
306 
307  if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
309 
310  return ref;
311 }
312 
314 {
316  ULONG ref = InterlockedDecrement( &This->ref2A );
317 
318  TRACE( "(%p) ref2A=%d\n", This, ref );
319 
320  if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
322 
323  return ref;
324 }
325 
326 static ULONG WINAPI IDirectPlayLobby2Impl_Release(IDirectPlayLobby2 *iface)
327 {
329  ULONG ref = InterlockedDecrement( &This->ref2 );
330 
331  TRACE( "(%p) ref2=%d\n", This, ref );
332 
333  if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
335 
336  return ref;
337 }
338 
340 {
342  ULONG ref = InterlockedDecrement( &This->ref3A );
343 
344  TRACE( "(%p) ref3A=%d\n", This, ref );
345 
346  if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
348 
349  return ref;
350 }
351 
352 static ULONG WINAPI IDirectPlayLobby3Impl_Release(IDirectPlayLobby3 *iface)
353 {
355  ULONG ref = InterlockedDecrement( &This->ref3 );
356 
357  TRACE( "(%p) ref3=%d\n", This, ref );
358 
359  if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
361 
362  return ref;
363 }
364 
365 
366 /********************************************************************
367  *
368  * Connects an application to the session specified by the DPLCONNECTION
369  * structure currently stored with the DirectPlayLobby object.
370  *
371  * Returns an IDirectPlay interface.
372  *
373  */
375  IUnknown* pUnk)
376 {
377  HRESULT hr;
378  DWORD dwOpenFlags = 0;
379  DWORD dwConnSize = 0;
380  LPDPLCONNECTION lpConn;
381 
382  FIXME("(%p)->(0x%08x,%p,%p): semi stub\n", This, dwFlags, lplpDP, pUnk );
383 
384  if( pUnk )
385  {
386  return DPERR_INVALIDPARAMS;
387  }
388 
389  /* Backwards compatibility */
390  if( dwFlags == 0 )
391  {
393  }
394 
395  if ( ( hr = dplay_create( riid, lplpDP ) ) != DP_OK )
396  {
397  ERR( "error creating interface for %s:%s.\n",
399  return hr;
400  }
401 
402  /* FIXME: Is it safe/correct to use appID of 0? */
403  hr = IDirectPlayLobby_GetConnectionSettings( &This->IDirectPlayLobby3_iface,
404  0, NULL, &dwConnSize );
405  if( hr != DPERR_BUFFERTOOSMALL )
406  {
407  return hr;
408  }
409 
410  lpConn = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwConnSize );
411 
412  if( lpConn == NULL )
413  {
414  return DPERR_NOMEMORY;
415  }
416 
417  /* FIXME: Is it safe/correct to use appID of 0? */
418  hr = IDirectPlayLobby_GetConnectionSettings( &This->IDirectPlayLobby3_iface,
419  0, lpConn, &dwConnSize );
420  if( FAILED( hr ) )
421  {
422  HeapFree( GetProcessHeap(), 0, lpConn );
423  return hr;
424  }
425 
426 #if 0
427  /* - Need to call IDirectPlay::EnumConnections with the service provider to get that good information
428  * - Need to call CreateAddress to create the lpConnection param for IDirectPlay::InitializeConnection
429  * - Call IDirectPlay::InitializeConnection
430  */
431 
432  /* Now initialize the Service Provider */
434 #endif
435 
436 
437  /* Setup flags to pass into DirectPlay::Open */
439  {
440  dwOpenFlags |= DPOPEN_RETURNSTATUS;
441  }
442  dwOpenFlags |= lpConn->dwFlags;
443 
445  dwOpenFlags );
446 
447  HeapFree( GetProcessHeap(), 0, lpConn );
448 
449  return hr;
450 }
451 
453  IDirectPlay2A **dp, IUnknown *unk )
454 {
456  return IDirectPlayLobby_Connect( &This->IDirectPlayLobby3A_iface, flags, dp, unk );
457 }
458 
459 static HRESULT WINAPI IDirectPlayLobbyImpl_Connect( IDirectPlayLobby *iface, DWORD flags,
460  IDirectPlay2A **dp, IUnknown *unk )
461 {
463  return IDirectPlayLobby_Connect( &This->IDirectPlayLobby3_iface, flags, dp, unk );
464 }
465 
467  IDirectPlay2A **dp, IUnknown *unk )
468 {
470  return IDirectPlayLobby_Connect( &This->IDirectPlayLobby3A_iface, flags, dp, unk );
471 }
472 
473 static HRESULT WINAPI IDirectPlayLobby2Impl_Connect( IDirectPlayLobby2 *iface, DWORD flags,
474  IDirectPlay2A **dp, IUnknown *unk )
475 {
477  return IDirectPlayLobby_Connect( &This->IDirectPlayLobby3_iface, flags, dp, unk );
478 }
479 
481  IDirectPlay2A **dp, IUnknown *unk)
482 {
483  return IDirectPlayLobby_ConnectEx( iface, flags, &IID_IDirectPlay2A, (void**)dp, unk );
484 }
485 
486 static HRESULT WINAPI IDirectPlayLobby3Impl_Connect( IDirectPlayLobby3 *iface, DWORD flags,
487  IDirectPlay2 **dp, IUnknown *unk)
488 {
489  return IDirectPlayLobby_ConnectEx( iface, flags, &IID_IDirectPlay2A, (void**)dp, unk );
490 }
491 
492 /********************************************************************
493  *
494  * Creates a DirectPlay Address, given a service provider-specific network
495  * address.
496  * Returns an address contains the globally unique identifier
497  * (GUID) of the service provider and data that the service provider can
498  * interpret as a network address.
499  *
500  * NOTE: It appears that this method is supposed to be really really stupid
501  * with no error checking on the contents.
502  */
504  REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize )
505 {
507  return IDirectPlayLobby_CreateAddress( &This->IDirectPlayLobby3A_iface, sp, datatype, data,
508  datasize, address, addrsize );
509 }
510 
511 static HRESULT WINAPI IDirectPlayLobbyImpl_CreateAddress( IDirectPlayLobby *iface, REFGUID sp,
512  REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize )
513 {
515  return IDirectPlayLobby_CreateAddress( &This->IDirectPlayLobby3_iface, sp, datatype, data,
516  datasize, address, addrsize );
517 }
518 
520  REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize )
521 {
523  return IDirectPlayLobby_CreateAddress( &This->IDirectPlayLobby3A_iface, sp, datatype, data,
524  datasize, address, addrsize );
525 }
526 
527 static HRESULT WINAPI IDirectPlayLobby2Impl_CreateAddress( IDirectPlayLobby2 *iface, REFGUID sp,
528  REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize )
529 {
531  return IDirectPlayLobby_CreateAddress( &This->IDirectPlayLobby3_iface, sp, datatype, data,
532  datasize, address, addrsize );
533 }
534 
536  REFGUID guidSP, REFGUID guidDataType, const void *lpData, DWORD dwDataSize, void *lpAddress,
537  DWORD *lpdwAddressSize )
538 {
539  return DPL_CreateAddress( guidSP, guidDataType, lpData, dwDataSize,
540  lpAddress, lpdwAddressSize, TRUE );
541 }
542 
543 static HRESULT WINAPI IDirectPlayLobby3Impl_CreateAddress( IDirectPlayLobby3 *iface, REFGUID guidSP,
544  REFGUID guidDataType, const void *lpData, DWORD dwDataSize, void *lpAddress,
545  DWORD *lpdwAddressSize )
546 {
547  return DPL_CreateAddress( guidSP, guidDataType, lpData, dwDataSize,
548  lpAddress, lpdwAddressSize, FALSE );
549 }
550 
552  REFGUID guidSP,
553  REFGUID guidDataType,
554  LPCVOID lpData,
555  DWORD dwDataSize,
556  LPVOID lpAddress,
557  LPDWORD lpdwAddressSize,
558  BOOL bAnsiInterface )
559 {
560  const DWORD dwNumAddElements = 2; /* Service Provide & address data type */
561  DPCOMPOUNDADDRESSELEMENT addressElements[ 2 /* dwNumAddElements */ ];
562 
563  TRACE( "(%p)->(%p,%p,0x%08x,%p,%p,%d)\n", guidSP, guidDataType, lpData, dwDataSize,
564  lpAddress, lpdwAddressSize, bAnsiInterface );
565 
566  addressElements[ 0 ].guidDataType = DPAID_ServiceProvider;
567  addressElements[ 0 ].dwDataSize = sizeof( GUID );
568  addressElements[ 0 ].lpData = (LPVOID)guidSP;
569 
570  addressElements[ 1 ].guidDataType = *guidDataType;
571  addressElements[ 1 ].dwDataSize = dwDataSize;
572  addressElements[ 1 ].lpData = (LPVOID)lpData;
573 
574  /* Call CreateCompoundAddress to cut down on code.
575  NOTE: We can do this because we don't support DPL 1 interfaces! */
576  return DPL_CreateCompoundAddress( addressElements, dwNumAddElements,
577  lpAddress, lpdwAddressSize, bAnsiInterface );
578 }
579 
580 
581 
582 /********************************************************************
583  *
584  * Parses out chunks from the DirectPlay Address buffer by calling the
585  * given callback function, with lpContext, for each of the chunks.
586  *
587  */
589  LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context )
590 {
592  return IDirectPlayLobby_EnumAddress( &This->IDirectPlayLobby3A_iface, enumaddrcb, address, size,
593  context );
594 }
595 
596 static HRESULT WINAPI IDirectPlayLobbyImpl_EnumAddress( IDirectPlayLobby *iface,
597  LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context )
598 {
600  return IDirectPlayLobby_EnumAddress( &This->IDirectPlayLobby3_iface, enumaddrcb, address, size,
601  context );
602 }
603 
605  LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context )
606 {
608  return IDirectPlayLobby_EnumAddress( &This->IDirectPlayLobby3A_iface, enumaddrcb, address, size,
609  context );
610 }
611 
612 static HRESULT WINAPI IDirectPlayLobby2Impl_EnumAddress( IDirectPlayLobby2 *iface,
613  LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context )
614 {
616  return IDirectPlayLobby_EnumAddress( &This->IDirectPlayLobby3_iface, enumaddrcb, address, size,
617  context );
618 }
619 
621  LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, const void *lpAddress, DWORD dwAddressSize,
622  void *lpContext )
623 {
625 
626  TRACE("(%p)->(%p,%p,0x%08x,%p)\n", This, lpEnumAddressCallback, lpAddress,
627  dwAddressSize, lpContext );
628 
629  return DPL_EnumAddress( lpEnumAddressCallback, lpAddress, dwAddressSize, lpContext );
630 }
631 
632 static HRESULT WINAPI IDirectPlayLobby3Impl_EnumAddress( IDirectPlayLobby3 *iface,
633  LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, const void *lpAddress, DWORD dwAddressSize,
634  void *lpContext )
635 {
637 
638  TRACE("(%p)->(%p,%p,0x%08x,%p)\n", This, lpEnumAddressCallback, lpAddress,
639  dwAddressSize, lpContext );
640 
641  return DPL_EnumAddress( lpEnumAddressCallback, lpAddress, dwAddressSize, lpContext );
642 }
643 
644 HRESULT DPL_EnumAddress( LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress,
645  DWORD dwAddressSize, LPVOID lpContext )
646 {
647  DWORD dwTotalSizeEnumerated = 0;
648 
649  /* FIXME: First chunk is always the total size chunk - Should we report it? */
650 
651  while ( dwTotalSizeEnumerated < dwAddressSize )
652  {
653  const DPADDRESS* lpElements = lpAddress;
654  DWORD dwSizeThisEnumeration;
655 
656  /* Invoke the enum method. If false is returned, stop enumeration */
657  if ( !lpEnumAddressCallback( &lpElements->guidDataType,
658  lpElements->dwDataSize,
659  (const BYTE *)lpElements + sizeof( DPADDRESS ),
660  lpContext ) )
661  {
662  break;
663  }
664 
665  dwSizeThisEnumeration = sizeof( DPADDRESS ) + lpElements->dwDataSize;
666  lpAddress = (const BYTE*) lpAddress + dwSizeThisEnumeration;
667  dwTotalSizeEnumerated += dwSizeThisEnumeration;
668  }
669 
670  return DP_OK;
671 }
672 
673 /********************************************************************
674  *
675  * Enumerates all the address types that a given service provider needs to
676  * build the DirectPlay Address.
677  *
678  */
680  LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags )
681 {
683  return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3A_iface, enumaddrtypecb, sp,
684  context, flags );
685 }
686 
687 static HRESULT WINAPI IDirectPlayLobbyImpl_EnumAddressTypes( IDirectPlayLobby *iface,
688  LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags )
689 {
691  return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3_iface, enumaddrtypecb, sp,
692  context, flags );
693 }
694 
696  LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags )
697 {
699  return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3A_iface, enumaddrtypecb, sp,
700  context, flags );
701 }
702 
703 static HRESULT WINAPI IDirectPlayLobby2Impl_EnumAddressTypes( IDirectPlayLobby2 *iface,
704  LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags )
705 {
707  return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3_iface, enumaddrtypecb, sp,
708  context, flags );
709 }
710 
712  LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback, REFGUID guidSP, void *lpContext,
713  DWORD dwFlags )
714 {
716 
717  HKEY hkResult;
718  LPCSTR searchSubKey = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
719  DWORD dwIndex, sizeOfSubKeyName=50;
720  char subKeyName[51];
722 
723  TRACE(" (%p)->(%p,%p,%p,0x%08x)\n", This, lpEnumAddressTypeCallback, guidSP, lpContext, dwFlags );
724 
725  if( dwFlags != 0 )
726  {
727  return DPERR_INVALIDPARAMS;
728  }
729 
730  if( !lpEnumAddressTypeCallback )
731  {
732  return DPERR_INVALIDPARAMS;
733  }
734 
735  if( guidSP == NULL )
736  {
737  return DPERR_INVALIDOBJECT;
738  }
739 
740  /* Need to loop over the service providers in the registry */
741  if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
742  0, KEY_READ, &hkResult ) != ERROR_SUCCESS )
743  {
744  /* Hmmm. Does this mean that there are no service providers? */
745  ERR(": no service providers?\n");
746  return DP_OK;
747  }
748 
749  /* Traverse all the service providers we have available */
750  for( dwIndex=0;
751  RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
753  ++dwIndex, sizeOfSubKeyName=50 )
754  {
755 
756  HKEY hkServiceProvider, hkServiceProviderAt;
757  GUID serviceProviderGUID;
758  DWORD returnTypeGUID, sizeOfReturnBuffer = 50;
759  char atSubKey[51];
760  char returnBuffer[51];
761  WCHAR buff[51];
762  DWORD dwAtIndex;
763  LPCSTR atKey = "Address Types";
764  LPCSTR guidDataSubKey = "Guid";
765 
766  TRACE(" this time through: %s\n", subKeyName );
767 
768  /* Get a handle for this particular service provider */
769  if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_READ,
770  &hkServiceProvider ) != ERROR_SUCCESS )
771  {
772  ERR(": what the heck is going on?\n" );
773  continue;
774  }
775 
776  if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
777  NULL, &returnTypeGUID, (LPBYTE)returnBuffer,
778  &sizeOfReturnBuffer ) != ERROR_SUCCESS )
779  {
780  ERR(": missing GUID registry data members\n" );
781  continue;
782  }
783 
784  /* FIXME: Check return types to ensure we're interpreting data right */
785  MultiByteToWideChar( CP_ACP, 0, returnBuffer, -1, buff, ARRAY_SIZE( buff ));
786  CLSIDFromString( buff, &serviceProviderGUID );
787  /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
788 
789  /* Determine if this is the Service Provider that the user asked for */
790  if( !IsEqualGUID( &serviceProviderGUID, guidSP ) )
791  {
792  continue;
793  }
794 
795  /* Get a handle for this particular service provider */
796  if( RegOpenKeyExA( hkServiceProvider, atKey, 0, KEY_READ,
797  &hkServiceProviderAt ) != ERROR_SUCCESS )
798  {
799  TRACE(": No Address Types registry data sub key/members\n" );
800  break;
801  }
802 
803  /* Traverse all the address type we have available */
804  for( dwAtIndex=0;
805  RegEnumKeyExA( hkServiceProviderAt, dwAtIndex, atSubKey, &sizeOfSubKeyName,
807  ++dwAtIndex, sizeOfSubKeyName=50 )
808  {
809  TRACE( "Found Address Type GUID %s\n", atSubKey );
810 
811  /* FIXME: Check return types to ensure we're interpreting data right */
812  MultiByteToWideChar( CP_ACP, 0, atSubKey, -1, buff, ARRAY_SIZE( buff ));
813  CLSIDFromString( buff, &serviceProviderGUID );
814  /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
815 
816  /* The enumeration will return FALSE if we are not to continue */
817  if( !lpEnumAddressTypeCallback( &serviceProviderGUID, lpContext, 0 ) )
818  {
819  WARN("lpEnumCallback returning FALSE\n" );
820  break; /* FIXME: This most likely has to break from the procedure...*/
821  }
822 
823  }
824 
825  /* We only enumerate address types for 1 GUID. We've found it, so quit looking */
826  break;
827  }
828 
829  return DP_OK;
830 }
831 
832 static HRESULT WINAPI IDirectPlayLobby3Impl_EnumAddressTypes( IDirectPlayLobby3 *iface,
833  LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags )
834 {
836  return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3A_iface, enumaddrtypecb, sp,
837  context, flags );
838 }
839 
840 /********************************************************************
841  *
842  * Enumerates what applications are registered with DirectPlay by
843  * invoking the callback function with lpContext.
844  *
845  */
847  LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback, void *lpContext, DWORD dwFlags )
848 {
850 
851  FIXME("(%p)->(%p,%p,0x%08x):stub\n", This, lpEnumLocalAppCallback, lpContext, dwFlags );
852 
853  return DPERR_OUTOFMEMORY;
854 }
855 
857  LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags )
858 {
860  return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3A_iface, enumlocalappcb,
861  context, flags );
862 }
863 
865  LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags )
866 {
868  return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3_iface, enumlocalappcb,
869  context, flags );
870 }
871 
873  LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags )
874 {
876  return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3A_iface, enumlocalappcb,
877  context, flags );
878 }
879 
881  LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags )
882 {
884  return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3_iface, enumlocalappcb,
885  context, flags );
886 }
887 
889  LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback, void *lpContext, DWORD dwFlags )
890 {
892 
893  HKEY hkResult;
894  LPCSTR searchSubKey = "SOFTWARE\\Microsoft\\DirectPlay\\Applications";
895  LPCSTR guidDataSubKey = "Guid";
896  DWORD dwIndex, sizeOfSubKeyName=50;
897  char subKeyName[51];
899 
900  TRACE("(%p)->(%p,%p,0x%08x)\n", This, lpEnumLocalAppCallback, lpContext, dwFlags );
901 
902  if( dwFlags != 0 )
903  {
904  return DPERR_INVALIDPARAMS;
905  }
906 
907  if( !lpEnumLocalAppCallback )
908  {
909  return DPERR_INVALIDPARAMS;
910  }
911 
912  /* Need to loop over the service providers in the registry */
913  if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
914  0, KEY_READ, &hkResult ) != ERROR_SUCCESS )
915  {
916  /* Hmmm. Does this mean that there are no service providers? */
917  ERR(": no service providers?\n");
918  return DP_OK;
919  }
920 
921  /* Traverse all registered applications */
922  for( dwIndex=0;
923  RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName, NULL, NULL, NULL, &filetime ) != ERROR_NO_MORE_ITEMS;
924  ++dwIndex, sizeOfSubKeyName=50 )
925  {
926 
927  HKEY hkServiceProvider;
928  GUID serviceProviderGUID;
929  DWORD returnTypeGUID, sizeOfReturnBuffer = 50;
930  char returnBuffer[51];
931  WCHAR buff[51];
932  DPLAPPINFO dplAppInfo;
933 
934  TRACE(" this time through: %s\n", subKeyName );
935 
936  /* Get a handle for this particular service provider */
937  if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_READ,
938  &hkServiceProvider ) != ERROR_SUCCESS )
939  {
940  ERR(": what the heck is going on?\n" );
941  continue;
942  }
943 
944  if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
945  NULL, &returnTypeGUID, (LPBYTE)returnBuffer,
946  &sizeOfReturnBuffer ) != ERROR_SUCCESS )
947  {
948  ERR(": missing GUID registry data members\n" );
949  continue;
950  }
951 
952  /* FIXME: Check return types to ensure we're interpreting data right */
953  MultiByteToWideChar( CP_ACP, 0, returnBuffer, -1, buff, ARRAY_SIZE( buff ));
954  CLSIDFromString( buff, &serviceProviderGUID );
955  /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
956 
957  dplAppInfo.dwSize = sizeof( dplAppInfo );
958  dplAppInfo.guidApplication = serviceProviderGUID;
959  dplAppInfo.u.lpszAppNameA = subKeyName;
960 
961  EnterCriticalSection( &This->lock );
962 
963  memcpy( &This->cbkeyhack, &hkServiceProvider, sizeof( hkServiceProvider ) );
964 
965  if( !lpEnumLocalAppCallback( &dplAppInfo, lpContext, dwFlags ) )
966  {
967  LeaveCriticalSection( &This->lock );
968  break;
969  }
970 
971  LeaveCriticalSection( &This->lock );
972  }
973 
974  return DP_OK;
975 }
976 
977 /********************************************************************
978  *
979  * Retrieves the DPLCONNECTION structure that contains all the information
980  * needed to start and connect an application. This was generated using
981  * either the RunApplication or SetConnectionSettings methods.
982  *
983  * NOTES: If lpData is NULL then just return lpdwDataSize. This allows
984  * the data structure to be allocated by our caller which can then
985  * call this procedure/method again with a valid data pointer.
986  */
988  DWORD appid, void *data, DWORD *size )
989 {
991  return IDirectPlayLobby_GetConnectionSettings( &This->IDirectPlayLobby3A_iface, appid, data,
992  size );
993 }
994 
996  DWORD appid, void *data, DWORD *size )
997 {
999  return IDirectPlayLobby_GetConnectionSettings( &This->IDirectPlayLobby3_iface, appid, data,
1000  size );
1001 }
1002 
1004  DWORD appid, void *data, DWORD *size )
1005 {
1007  return IDirectPlayLobby_GetConnectionSettings( &This->IDirectPlayLobby3A_iface, appid, data,
1008  size );
1009 }
1010 
1012  DWORD appid, void *data, DWORD *size )
1013 {
1015  return IDirectPlayLobby_GetConnectionSettings( &This->IDirectPlayLobby3_iface, appid, data,
1016  size );
1017 }
1018 
1020  DWORD dwAppID, void *lpData, DWORD *lpdwDataSize )
1021 {
1023  HRESULT hr;
1024 
1025  TRACE("(%p)->(0x%08x,%p,%p)\n", This, dwAppID, lpData, lpdwDataSize );
1026 
1027  EnterCriticalSection( &This->lock );
1028 
1029  hr = DPLAYX_GetConnectionSettingsA( dwAppID,
1030  lpData,
1031  lpdwDataSize
1032  );
1033 
1034  LeaveCriticalSection( &This->lock );
1035 
1036  return hr;
1037 }
1038 
1040  DWORD dwAppID, void *lpData, DWORD *lpdwDataSize )
1041 {
1043  HRESULT hr;
1044 
1045  TRACE("(%p)->(0x%08x,%p,%p)\n", This, dwAppID, lpData, lpdwDataSize );
1046 
1047  EnterCriticalSection( &This->lock );
1048 
1049  hr = DPLAYX_GetConnectionSettingsW( dwAppID,
1050  lpData,
1051  lpdwDataSize
1052  );
1053 
1054  LeaveCriticalSection( &This->lock );
1055 
1056  return hr;
1057 }
1058 
1059 /********************************************************************
1060  *
1061  * Retrieves the message sent between a lobby client and a DirectPlay
1062  * application. All messages are queued until received.
1063  *
1064  */
1066  DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size )
1067 {
1069  return IDirectPlayLobby_ReceiveLobbyMessage( &This->IDirectPlayLobby3A_iface, flags, appid,
1070  msgflags, data, size );
1071 }
1072 
1074  DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size )
1075 {
1077  return IDirectPlayLobby_ReceiveLobbyMessage( &This->IDirectPlayLobby3_iface, flags, appid,
1078  msgflags, data, size );
1079 }
1080 
1082  DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size )
1083 {
1085  return IDirectPlayLobby_ReceiveLobbyMessage( &This->IDirectPlayLobby3A_iface, flags, appid,
1086  msgflags, data, size );
1087 }
1088 
1090  DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size )
1091 {
1093  return IDirectPlayLobby_ReceiveLobbyMessage( &This->IDirectPlayLobby3_iface, flags, appid,
1094  msgflags, data, size );
1095 }
1096 
1098  DWORD dwFlags, DWORD dwAppID, DWORD *lpdwMessageFlags, void *lpData,
1099  DWORD *lpdwDataSize )
1100 {
1102  FIXME(":stub %p %08x %08x %p %p %p\n", This, dwFlags, dwAppID, lpdwMessageFlags, lpData,
1103  lpdwDataSize );
1104  return DPERR_OUTOFMEMORY;
1105 }
1106 
1108  DWORD dwFlags, DWORD dwAppID, DWORD *lpdwMessageFlags, void *lpData,
1109  DWORD *lpdwDataSize )
1110 {
1112  FIXME(":stub %p %08x %08x %p %p %p\n", This, dwFlags, dwAppID, lpdwMessageFlags, lpData,
1113  lpdwDataSize );
1114  return DPERR_OUTOFMEMORY;
1115 }
1116 
1118 {
1120 
1127 
1128 /* To be called by RunApplication to find how to invoke the function */
1130 ( LPCDPLAPPINFO lpAppInfo,
1131  LPVOID lpContext,
1132  DWORD dwFlags )
1133 {
1135 
1136  if( IsEqualGUID( &lpAppInfo->guidApplication, &lpData->appGUID ) )
1137  {
1138  char returnBuffer[200];
1139  DWORD returnType, sizeOfReturnBuffer;
1140  LPCSTR clSubKey = "CommandLine";
1141  LPCSTR cdSubKey = "CurrentDirectory";
1142  LPCSTR fileSubKey = "File";
1143  LPCSTR pathSubKey = "Path";
1144 
1145  /* FIXME: Lazy man hack - dplay struct has the present reg key saved */
1146 
1147  sizeOfReturnBuffer = 200;
1148 
1149  /* Get all the appropriate data from the registry */
1150  if( RegQueryValueExA( lpData->This->cbkeyhack, clSubKey,
1151  NULL, &returnType, (LPBYTE)returnBuffer,
1152  &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1153  {
1154  ERR( ": missing CommandLine registry data member\n" );
1155  }
1156  else
1157  {
1158  if ((lpData->lpszCommandLine = HeapAlloc( GetProcessHeap(), 0, strlen(returnBuffer)+1 )))
1159  strcpy( lpData->lpszCommandLine, returnBuffer );
1160  }
1161 
1162  sizeOfReturnBuffer = 200;
1163 
1164  if( RegQueryValueExA( lpData->This->cbkeyhack, cdSubKey,
1165  NULL, &returnType, (LPBYTE)returnBuffer,
1166  &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1167  {
1168  ERR( ": missing CurrentDirectory registry data member\n" );
1169  }
1170  else
1171  {
1172  if ((lpData->lpszCurrentDirectory = HeapAlloc( GetProcessHeap(), 0, strlen(returnBuffer)+1 )))
1173  strcpy( lpData->lpszCurrentDirectory, returnBuffer );
1174  }
1175 
1176  sizeOfReturnBuffer = 200;
1177 
1178  if( RegQueryValueExA( lpData->This->cbkeyhack, fileSubKey,
1179  NULL, &returnType, (LPBYTE)returnBuffer,
1180  &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1181  {
1182  ERR( ": missing File registry data member\n" );
1183  }
1184  else
1185  {
1186  if ((lpData->lpszFileName = HeapAlloc( GetProcessHeap(), 0, strlen(returnBuffer)+1 )))
1187  strcpy( lpData->lpszFileName, returnBuffer );
1188  }
1189 
1190  sizeOfReturnBuffer = 200;
1191 
1192  if( RegQueryValueExA( lpData->This->cbkeyhack, pathSubKey,
1193  NULL, &returnType, (LPBYTE)returnBuffer,
1194  &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1195  {
1196  ERR( ": missing Path registry data member\n" );
1197  }
1198  else
1199  {
1200  if ((lpData->lpszPath = HeapAlloc( GetProcessHeap(), 0, strlen(returnBuffer)+1 )))
1201  strcpy( lpData->lpszPath, returnBuffer );
1202  }
1203 
1204  return FALSE; /* No need to keep going as we found what we wanted */
1205  }
1206 
1207  return TRUE; /* Keep enumerating, haven't found the application yet */
1208 }
1209 
1210 static BOOL DPL_CreateAndSetLobbyHandles( DWORD dwDestProcessId, HANDLE hDestProcess,
1211  LPHANDLE lphStart, LPHANDLE lphDeath,
1212  LPHANDLE lphRead )
1213 {
1214  /* These are the handles for the created process */
1215  HANDLE hAppStart = 0, hAppDeath = 0, hAppRead = 0;
1216  SECURITY_ATTRIBUTES s_attrib;
1217 
1218  s_attrib.nLength = sizeof( s_attrib );
1219  s_attrib.lpSecurityDescriptor = NULL;
1220  s_attrib.bInheritHandle = TRUE;
1221 
1222  *lphStart = CreateEventW( &s_attrib, TRUE, FALSE, NULL );
1223  *lphDeath = CreateEventW( &s_attrib, TRUE, FALSE, NULL );
1224  *lphRead = CreateEventW( &s_attrib, TRUE, FALSE, NULL );
1225 
1226  if( ( !DuplicateHandle( GetCurrentProcess(), *lphStart,
1227  hDestProcess, &hAppStart,
1228  0, FALSE, DUPLICATE_SAME_ACCESS ) ) ||
1229  ( !DuplicateHandle( GetCurrentProcess(), *lphDeath,
1230  hDestProcess, &hAppDeath,
1231  0, FALSE, DUPLICATE_SAME_ACCESS ) ) ||
1232  ( !DuplicateHandle( GetCurrentProcess(), *lphRead,
1233  hDestProcess, &hAppRead,
1235  )
1236  {
1237  if (*lphStart) { CloseHandle(*lphStart); *lphStart = 0; }
1238  if (*lphDeath) { CloseHandle(*lphDeath); *lphDeath = 0; }
1239  if (*lphRead) { CloseHandle(*lphRead); *lphRead = 0; }
1240  /* FIXME: Handle leak... */
1241  ERR( "Unable to dup handles\n" );
1242  return FALSE;
1243  }
1244 
1245  if( !DPLAYX_SetLobbyHandles( dwDestProcessId,
1246  hAppStart, hAppDeath, hAppRead ) )
1247  {
1248  /* FIXME: Handle leak... */
1249  return FALSE;
1250  }
1251 
1252  return TRUE;
1253 }
1254 
1255 
1256 /********************************************************************
1257  *
1258  * Starts an application and passes to it all the information to
1259  * connect to a session.
1260  *
1261  */
1263  DWORD *appid, DPLCONNECTION *conn, HANDLE event )
1264 {
1266  return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3A_iface, flags, appid, conn,
1267  event );
1268 }
1269 
1271  DWORD *appid, DPLCONNECTION *conn, HANDLE event )
1272 {
1274  return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3_iface, flags, appid, conn,
1275  event );
1276 }
1277 
1279  DWORD *appid, DPLCONNECTION *conn, HANDLE event )
1280 {
1282  return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3A_iface, flags, appid, conn,
1283  event );
1284 }
1285 
1287  DWORD *appid, DPLCONNECTION *conn, HANDLE event )
1288 {
1290  return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3_iface, flags, appid, conn,
1291  event );
1292 }
1293 
1295  DWORD dwFlags, DWORD *lpdwAppID, DPLCONNECTION *lpConn, HANDLE hReceiveEvent )
1296 {
1298  HRESULT hr;
1299  RunApplicationEnumStruct enumData;
1300  char temp[200];
1301  STARTUPINFOA startupInfo;
1302  PROCESS_INFORMATION newProcessInfo;
1303  LPSTR appName;
1304  DWORD dwSuspendCount;
1305  HANDLE hStart, hDeath, hSettingRead;
1306 
1307  TRACE( "(%p)->(0x%08x,%p,%p,%p)\n",
1308  This, dwFlags, lpdwAppID, lpConn, hReceiveEvent );
1309 
1310  if( dwFlags != 0 )
1311  {
1312  return DPERR_INVALIDPARAMS;
1313  }
1314 
1316  {
1317  FIXME( "Waiting lobby not being handled correctly\n" );
1318  }
1319 
1320  EnterCriticalSection( &This->lock );
1321 
1322  ZeroMemory( &enumData, sizeof( enumData ) );
1323  enumData.This = This;
1324  enumData.appGUID = lpConn->lpSessionDesc->guidApplication;
1325 
1326  /* Our callback function will fill up the enumData structure with all the information
1327  required to start a new process */
1329  (&enumData), 0 );
1330 
1331  /* First the application name */
1332  strcpy( temp, enumData.lpszPath );
1333  strcat( temp, "\\" );
1334  strcat( temp, enumData.lpszFileName );
1335  HeapFree( GetProcessHeap(), 0, enumData.lpszPath );
1336  HeapFree( GetProcessHeap(), 0, enumData.lpszFileName );
1337  if ((appName = HeapAlloc( GetProcessHeap(), 0, strlen(temp)+1 ))) strcpy( appName, temp );
1338 
1339  /* Now the command line */
1340  strcat( temp, " " );
1341  strcat( temp, enumData.lpszCommandLine );
1342  HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1343  if ((enumData.lpszCommandLine = HeapAlloc( GetProcessHeap(), 0, strlen(temp)+1 )))
1344  strcpy( enumData.lpszCommandLine, temp );
1345 
1346  ZeroMemory( &startupInfo, sizeof( startupInfo ) );
1347  startupInfo.cb = sizeof( startupInfo );
1348  /* FIXME: Should any fields be filled in? */
1349 
1350  ZeroMemory( &newProcessInfo, sizeof( newProcessInfo ) );
1351 
1352  if( !CreateProcessA( appName,
1353  enumData.lpszCommandLine,
1354  NULL,
1355  NULL,
1356  FALSE,
1358  NULL,
1359  enumData.lpszCurrentDirectory,
1360  &startupInfo,
1361  &newProcessInfo
1362  )
1363  )
1364  {
1365  ERR( "Failed to create process for app %s\n", appName );
1366 
1367  HeapFree( GetProcessHeap(), 0, appName );
1368  HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1369  HeapFree( GetProcessHeap(), 0, enumData.lpszCurrentDirectory );
1370 
1371  LeaveCriticalSection( &This->lock );
1372  return DPERR_CANTCREATEPROCESS;
1373  }
1374 
1375  HeapFree( GetProcessHeap(), 0, appName );
1376  HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1377  HeapFree( GetProcessHeap(), 0, enumData.lpszCurrentDirectory );
1378 
1379  /* Reserve this global application id! */
1380  if( !DPLAYX_CreateLobbyApplication( newProcessInfo.dwProcessId ) )
1381  {
1382  ERR( "Unable to create global application data for 0x%08x\n",
1383  newProcessInfo.dwProcessId );
1384  }
1385 
1386  hr = IDirectPlayLobby_SetConnectionSettings( iface, 0, newProcessInfo.dwProcessId, lpConn );
1387 
1388  if( hr != DP_OK )
1389  {
1390  ERR( "SetConnectionSettings failure %s\n", DPLAYX_HresultToString( hr ) );
1391  LeaveCriticalSection( &This->lock );
1392  return hr;
1393  }
1394 
1395  /* Setup the handles for application notification */
1396  DPL_CreateAndSetLobbyHandles( newProcessInfo.dwProcessId,
1397  newProcessInfo.hProcess,
1398  &hStart, &hDeath, &hSettingRead );
1399 
1400  /* Setup the message thread ID */
1401  This->msgtid = CreateLobbyMessageReceptionThread( hReceiveEvent, hStart, hDeath, hSettingRead );
1402 
1403  DPLAYX_SetLobbyMsgThreadId( newProcessInfo.dwProcessId, This->msgtid );
1404 
1405  LeaveCriticalSection( &This->lock );
1406 
1407  /* Everything seems to have been set correctly, update the dwAppID */
1408  *lpdwAppID = newProcessInfo.dwProcessId;
1409 
1410  /* Unsuspend the process - should return the prev suspension count */
1411  if( ( dwSuspendCount = ResumeThread( newProcessInfo.hThread ) ) != 1 )
1412  {
1413  ERR( "ResumeThread failed with 0x%08x\n", dwSuspendCount );
1414  }
1415 
1416  return DP_OK;
1417 }
1418 
1420  DWORD *lpdwAppID, DPLCONNECTION *lpConn, HANDLE hReceiveEvent )
1421 {
1423  FIXME( "(%p)->(0x%08x,%p,%p,%p):stub\n", This, dwFlags, lpdwAppID, lpConn, hReceiveEvent );
1424  return DPERR_OUTOFMEMORY;
1425 }
1426 
1427 /********************************************************************
1428  *
1429  * Sends a message between the application and the lobby client.
1430  * All messages are queued until received.
1431  *
1432  */
1434  DWORD appid, void *data, DWORD size )
1435 {
1437  return IDirectPlayLobby_SendLobbyMessage( &This->IDirectPlayLobby3A_iface, flags, appid, data,
1438  size );
1439 }
1440 
1442  DWORD appid, void *data, DWORD size )
1443 {
1445  return IDirectPlayLobby_SendLobbyMessage( &This->IDirectPlayLobby3_iface, flags, appid, data,
1446  size );
1447 }
1448 
1450  DWORD flags, DWORD appid, void *data, DWORD size )
1451 {
1453  return IDirectPlayLobby_SendLobbyMessage( &This->IDirectPlayLobby3A_iface, flags, appid, data,
1454  size );
1455 }
1456 
1458  DWORD appid, void *data, DWORD size )
1459 {
1461  return IDirectPlayLobby_SendLobbyMessage( &This->IDirectPlayLobby3_iface, flags, appid, data,
1462  size );
1463 }
1464 
1466  DWORD flags, DWORD appid, void *data, DWORD size )
1467 {
1468  FIXME(":stub\n");
1469  return DPERR_OUTOFMEMORY;
1470 }
1471 
1472 static HRESULT WINAPI IDirectPlayLobby3Impl_SendLobbyMessage( IDirectPlayLobby3 *iface,
1473  DWORD flags, DWORD appid, void *data, DWORD size )
1474 {
1475  FIXME(":stub\n");
1476  return DPERR_OUTOFMEMORY;
1477 }
1478 
1479 /********************************************************************
1480  *
1481  * Modifies the DPLCONNECTION structure to contain all information
1482  * needed to start and connect an application.
1483  *
1484  */
1486  DWORD dwFlags, DWORD dwAppID, DPLCONNECTION *lpConn )
1487 {
1489  HRESULT hr;
1490 
1491  TRACE("(%p)->(0x%08x,0x%08x,%p)\n", This, dwFlags, dwAppID, lpConn );
1492 
1493  EnterCriticalSection( &This->lock );
1494 
1495  hr = DPLAYX_SetConnectionSettingsW( dwFlags, dwAppID, lpConn );
1496 
1497  /* FIXME: Don't think that this is supposed to fail, but the documentation
1498  is somewhat sketchy. I'll try creating a lobby application
1499  for this... */
1500  if( hr == DPERR_NOTLOBBIED )
1501  {
1502  FIXME( "Unlobbied app setting connections. Is this correct behavior?\n" );
1503  if( dwAppID == 0 )
1504  {
1505  dwAppID = GetCurrentProcessId();
1506  }
1507  DPLAYX_CreateLobbyApplication( dwAppID );
1508  hr = DPLAYX_SetConnectionSettingsW( dwFlags, dwAppID, lpConn );
1509  }
1510 
1511  LeaveCriticalSection( &This->lock );
1512 
1513  return hr;
1514 }
1515 
1517  DWORD flags, DWORD appid, DPLCONNECTION *conn )
1518 {
1520  return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3A_iface, flags,
1521  appid, conn );
1522 }
1523 
1525  DWORD flags, DWORD appid, DPLCONNECTION *conn )
1526 {
1528  return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3_iface, flags,
1529  appid, conn );
1530 }
1531 
1533  DWORD flags, DWORD appid, DPLCONNECTION *conn )
1534 {
1536  return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3A_iface, flags,
1537  appid, conn );
1538 }
1539 
1541  DWORD flags, DWORD appid, DPLCONNECTION *conn )
1542 {
1544  return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3_iface, flags,
1545  appid, conn );
1546 }
1547 
1549  DWORD dwFlags, DWORD dwAppID, DPLCONNECTION *lpConn )
1550 {
1552  HRESULT hr;
1553 
1554  TRACE("(%p)->(0x%08x,0x%08x,%p)\n", This, dwFlags, dwAppID, lpConn );
1555 
1556  EnterCriticalSection( &This->lock );
1557 
1558  hr = DPLAYX_SetConnectionSettingsA( dwFlags, dwAppID, lpConn );
1559 
1560  /* FIXME: Don't think that this is supposed to fail, but the documentation
1561  is somewhat sketchy. I'll try creating a lobby application
1562  for this... */
1563  if( hr == DPERR_NOTLOBBIED )
1564  {
1565  FIXME( "Unlobbied app setting connections. Is this correct behavior?\n" );
1566  dwAppID = GetCurrentProcessId();
1567  DPLAYX_CreateLobbyApplication( dwAppID );
1568  hr = DPLAYX_SetConnectionSettingsA( dwFlags, dwAppID, lpConn );
1569  }
1570 
1571  LeaveCriticalSection( &This->lock );
1572 
1573  return hr;
1574 }
1575 
1576 /********************************************************************
1577  *
1578  * Registers an event that will be set when a lobby message is received.
1579  *
1580  */
1583 {
1585  return IDirectPlayLobby_SetLobbyMessageEvent( &This->IDirectPlayLobby3A_iface, flags, appid,
1586  event );
1587 }
1588 
1591 {
1593  return IDirectPlayLobby_SetLobbyMessageEvent( &This->IDirectPlayLobby3_iface, flags, appid,
1594  event );
1595 }
1596 
1599 {
1601  return IDirectPlayLobby_SetLobbyMessageEvent( &This->IDirectPlayLobby3A_iface, flags, appid,
1602  event );
1603 }
1604 
1607 {
1609  return IDirectPlayLobby_SetLobbyMessageEvent( &This->IDirectPlayLobby3_iface, flags, appid,
1610  event );
1611 }
1612 
1615 {
1616  FIXME(":stub\n");
1617  return DPERR_OUTOFMEMORY;
1618 }
1619 
1622 {
1623  FIXME(":stub\n");
1624  return DPERR_OUTOFMEMORY;
1625 }
1626 
1627 
1628 /* DPL 2 methods */
1630  const DPCOMPOUNDADDRESSELEMENT *elements, DWORD count, void *address, DWORD *size )
1631 {
1633  return IDirectPlayLobby_CreateCompoundAddress( &This->IDirectPlayLobby3A_iface, elements,
1634  count, address, size );
1635 }
1636 
1638  const DPCOMPOUNDADDRESSELEMENT *elements, DWORD count, void *address, DWORD *size )
1639 {
1641  return IDirectPlayLobby_CreateCompoundAddress( &This->IDirectPlayLobby3_iface, elements,
1642  count, address, size );
1643 }
1644 
1646  const DPCOMPOUNDADDRESSELEMENT *lpElements, DWORD dwElementCount, void *lpAddress,
1647  DWORD *lpdwAddressSize )
1648 {
1649  return DPL_CreateCompoundAddress( lpElements, dwElementCount, lpAddress, lpdwAddressSize, FALSE );
1650 }
1651 
1653  const DPCOMPOUNDADDRESSELEMENT *lpElements, DWORD dwElementCount, void *lpAddress,
1654  DWORD *lpdwAddressSize )
1655 {
1656  return DPL_CreateCompoundAddress( lpElements, dwElementCount, lpAddress, lpdwAddressSize, TRUE );
1657 }
1658 
1661  DWORD dwElementCount,
1662  LPVOID lpAddress,
1663  LPDWORD lpdwAddressSize,
1664  BOOL bAnsiInterface )
1665 {
1666  DWORD dwSizeRequired = 0;
1667  DWORD dwElements;
1668  LPCDPCOMPOUNDADDRESSELEMENT lpOrigElements = lpElements;
1669 
1670  TRACE("(%p,0x%08x,%p,%p)\n", lpElements, dwElementCount, lpAddress, lpdwAddressSize );
1671 
1672  /* Parameter check */
1673  if( ( lpElements == NULL ) ||
1674  ( dwElementCount == 0 ) /* FIXME: Not sure if this is a failure case */
1675  )
1676  {
1677  return DPERR_INVALIDPARAMS;
1678  }
1679 
1680  /* Add the total size chunk */
1681  dwSizeRequired += sizeof( DPADDRESS ) + sizeof( DWORD );
1682 
1683  /* Calculate the size of the buffer required */
1684  for ( dwElements = dwElementCount; dwElements > 0; --dwElements, ++lpElements )
1685  {
1686  if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ServiceProvider ) ) ||
1687  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_LobbyProvider ) )
1688  )
1689  {
1690  dwSizeRequired += sizeof( DPADDRESS ) + sizeof( GUID );
1691  }
1692  else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Phone ) ) ||
1693  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Modem ) ) ||
1694  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INet ) )
1695  )
1696  {
1697  if( !bAnsiInterface )
1698  {
1699  ERR( "Ansi GUIDs used for unicode interface\n" );
1700  return DPERR_INVALIDFLAGS;
1701  }
1702 
1703  dwSizeRequired += sizeof( DPADDRESS ) + lpElements->dwDataSize;
1704  }
1705  else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_PhoneW ) ) ||
1706  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ModemW ) ) ||
1707  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetW ) )
1708  )
1709  {
1710  if( bAnsiInterface )
1711  {
1712  ERR( "Unicode GUIDs used for ansi interface\n" );
1713  return DPERR_INVALIDFLAGS;
1714  }
1715 
1716  FIXME( "Right size for unicode interface?\n" );
1717  dwSizeRequired += sizeof( DPADDRESS ) + lpElements->dwDataSize * sizeof( WCHAR );
1718  }
1719  else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetPort ) )
1720  {
1721  dwSizeRequired += sizeof( DPADDRESS ) + sizeof( WORD );
1722  }
1723  else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ComPort ) )
1724  {
1725  FIXME( "Right size for unicode interface?\n" );
1726  dwSizeRequired += sizeof( DPADDRESS ) + sizeof( DPCOMPORTADDRESS ); /* FIXME: Right size? */
1727  }
1728  else
1729  {
1730  WARN( "Skipping Unknown GUID %s\n", debugstr_guid(&lpElements->guidDataType) );
1731  }
1732  }
1733 
1734  /* The user wants to know how big a buffer to allocate for us */
1735  if( ( lpAddress == NULL ) ||
1736  ( *lpdwAddressSize < dwSizeRequired )
1737  )
1738  {
1739  *lpdwAddressSize = dwSizeRequired;
1740  return DPERR_BUFFERTOOSMALL;
1741  }
1742 
1743  /* Add the total size chunk */
1744  {
1745  LPDPADDRESS lpdpAddress = lpAddress;
1746 
1747  lpdpAddress->guidDataType = DPAID_TotalSize;
1748  lpdpAddress->dwDataSize = sizeof( DWORD );
1749  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1750 
1751  *(LPDWORD)lpAddress = dwSizeRequired;
1752  lpAddress = (char *) lpAddress + sizeof( DWORD );
1753  }
1754 
1755  /* Calculate the size of the buffer required */
1756  for( dwElements = dwElementCount, lpElements = lpOrigElements;
1757  dwElements > 0;
1758  --dwElements, ++lpElements )
1759  {
1760  if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ServiceProvider ) ) ||
1761  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_LobbyProvider ) )
1762  )
1763  {
1764  LPDPADDRESS lpdpAddress = lpAddress;
1765 
1766  lpdpAddress->guidDataType = lpElements->guidDataType;
1767  lpdpAddress->dwDataSize = sizeof( GUID );
1768  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1769 
1770  CopyMemory( lpAddress, lpElements->lpData, sizeof( GUID ) );
1771  lpAddress = (char *) lpAddress + sizeof( GUID );
1772  }
1773  else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Phone ) ) ||
1774  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_Modem ) ) ||
1775  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INet ) )
1776  )
1777  {
1778  LPDPADDRESS lpdpAddress = lpAddress;
1779 
1780  lpdpAddress->guidDataType = lpElements->guidDataType;
1781  lpdpAddress->dwDataSize = lpElements->dwDataSize;
1782  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1783 
1784  lstrcpynA( lpAddress, lpElements->lpData, lpElements->dwDataSize );
1785  lpAddress = (char *) lpAddress + lpElements->dwDataSize;
1786  }
1787  else if ( ( IsEqualGUID( &lpElements->guidDataType, &DPAID_PhoneW ) ) ||
1788  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ModemW ) ) ||
1789  ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetW ) )
1790  )
1791  {
1792  LPDPADDRESS lpdpAddress = lpAddress;
1793 
1794  lpdpAddress->guidDataType = lpElements->guidDataType;
1795  lpdpAddress->dwDataSize = lpElements->dwDataSize;
1796  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1797 
1798  lstrcpynW( lpAddress, lpElements->lpData, lpElements->dwDataSize );
1799  lpAddress = (char *) lpAddress + lpElements->dwDataSize * sizeof( WCHAR );
1800  }
1801  else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_INetPort ) )
1802  {
1803  LPDPADDRESS lpdpAddress = lpAddress;
1804 
1805  lpdpAddress->guidDataType = lpElements->guidDataType;
1806  lpdpAddress->dwDataSize = lpElements->dwDataSize;
1807  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1808 
1809  *((LPWORD)lpAddress) = *((LPWORD)lpElements->lpData);
1810  lpAddress = (char *) lpAddress + sizeof( WORD );
1811  }
1812  else if ( IsEqualGUID( &lpElements->guidDataType, &DPAID_ComPort ) )
1813  {
1814  LPDPADDRESS lpdpAddress = lpAddress;
1815 
1816  lpdpAddress->guidDataType = lpElements->guidDataType;
1817  lpdpAddress->dwDataSize = lpElements->dwDataSize;
1818  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1819 
1820  CopyMemory( lpAddress, lpElements->lpData, sizeof( DPADDRESS ) );
1821  lpAddress = (char *) lpAddress + sizeof( DPADDRESS );
1822  }
1823  }
1824 
1825  return DP_OK;
1826 }
1827 
1828 /* DPL 3 methods */
1829 
1830 static HRESULT WINAPI IDirectPlayLobby3Impl_ConnectEx( IDirectPlayLobby3 *iface, DWORD dwFlags,
1832 {
1834  return DPL_ConnectEx( This, dwFlags, riid, lplpDP, pUnk );
1835 }
1836 
1838  REFIID riid, void **lplpDP, IUnknown *pUnk )
1839 {
1841  return DPL_ConnectEx( This, dwFlags, riid, lplpDP, pUnk );
1842 }
1843 
1845  DWORD flags, DPAPPLICATIONDESC *appdesc )
1846 {
1847  FIXME(":stub\n");
1848  return DP_OK;
1849 }
1850 
1852  DWORD flags, DPAPPLICATIONDESC *appdesc )
1853 {
1854  FIXME(":stub\n");
1855  return DP_OK;
1856 }
1857 
1859  DWORD flags, REFGUID appdesc )
1860 {
1861  FIXME(":stub\n");
1862  return DP_OK;
1863 }
1864 
1866  DWORD flags, REFGUID appdesc )
1867 {
1868  FIXME(":stub\n");
1869  return DP_OK;
1870 }
1871 
1873  DWORD dwFlags )
1874 {
1875  HRESULT hr = DP_OK;
1876  BOOL bStartWait = !(dwFlags & DPLWAIT_CANCEL);
1877 
1878  TRACE( "(%p)->(0x%08x)\n", iface, dwFlags );
1879 
1880  if( DPLAYX_WaitForConnectionSettings( bStartWait ) )
1881  {
1882  /* FIXME: What is the correct error return code? */
1883  hr = DPERR_NOTLOBBIED;
1884  }
1885 
1886  return hr;
1887 }
1888 
1890  DWORD dwFlags )
1891 {
1892  HRESULT hr = DP_OK;
1893  BOOL bStartWait = !(dwFlags & DPLWAIT_CANCEL);
1894 
1895  TRACE( "(%p)->(0x%08x)\n", iface, dwFlags );
1896 
1897  if( DPLAYX_WaitForConnectionSettings( bStartWait ) )
1898  {
1899  /* FIXME: What is the correct error return code? */
1900  hr = DPERR_NOTLOBBIED;
1901  }
1902 
1903  return hr;
1904 }
1905 
1906 static const IDirectPlayLobbyVtbl dplA_vt =
1907 {
1922 };
1923 
1924 static const IDirectPlayLobbyVtbl dpl_vt =
1925 {
1940 };
1941 
1942 static const IDirectPlayLobby2Vtbl dpl2A_vt =
1943 {
1959 };
1960 
1961 static const IDirectPlayLobby2Vtbl dpl2_vt =
1962 {
1978 };
1979 
1980 static const IDirectPlayLobby3Vtbl dpl3A_vt =
1981 {
2001 };
2002 
2003 static const IDirectPlayLobby3Vtbl dpl3_vt =
2004 {
2024 };
2025 
2027 {
2029  HRESULT hr;
2030 
2031  TRACE( "(%s, %p)\n", debugstr_guid( riid ), ppv );
2032 
2033  *ppv = NULL;
2034  obj = HeapAlloc( GetProcessHeap(), 0, sizeof( *obj ) );
2035  if ( !obj )
2036  return DPERR_OUTOFMEMORY;
2037 
2038  obj->IDirectPlayLobby_iface.lpVtbl = &dpl_vt;
2039  obj->IDirectPlayLobbyA_iface.lpVtbl = &dplA_vt;
2040  obj->IDirectPlayLobby2_iface.lpVtbl = &dpl2_vt;
2041  obj->IDirectPlayLobby2A_iface.lpVtbl = &dpl2A_vt;
2042  obj->IDirectPlayLobby3_iface.lpVtbl = &dpl3_vt;
2043  obj->IDirectPlayLobby3A_iface.lpVtbl = &dpl3A_vt;
2044  obj->numIfaces = 1;
2045  obj->msgtid = 0;
2046  obj->ref = 0;
2047  obj->refA = 0;
2048  obj->ref2 = 0;
2049  obj->ref2A = 0;
2050  obj->ref3 = 1;
2051  obj->ref3A = 0;
2052 
2053  InitializeCriticalSection( &obj->lock );
2054  obj->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IDirectPlayLobbyImpl.lock");
2055  DPQ_INIT( obj->msgs );
2056 
2057  hr = IDirectPlayLobby_QueryInterface( &obj->IDirectPlayLobby3_iface, riid, ppv );
2058  IDirectPlayLobby_Release( &obj->IDirectPlayLobby3_iface );
2059 
2060  return hr;
2061 }
2062 
2063 
2064 
2065 /***************************************************************************
2066  * DirectPlayLobbyCreateA (DPLAYX.4)
2067  *
2068  */
2070  IUnknown *lpUnk, void *lpData, DWORD dwDataSize )
2071 {
2072  TRACE("lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08x\n",
2073  lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
2074 
2075  /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
2076  * equal 0. These fields are mostly for future expansion.
2077  */
2078  if ( lpGUIDDSP || lpData || dwDataSize )
2079  {
2080  *lplpDPL = NULL;
2081  return DPERR_INVALIDPARAMS;
2082  }
2083 
2084  if( lpUnk )
2085  {
2086  *lplpDPL = NULL;
2087  ERR("Bad parameters!\n" );
2088  return CLASS_E_NOAGGREGATION;
2089  }
2090 
2091  return dplobby_create( &IID_IDirectPlayLobbyA, (void**)lplpDPL );
2092 }
2093 
2094 /***************************************************************************
2095  * DirectPlayLobbyCreateW (DPLAYX.5)
2096  *
2097  */
2098 HRESULT WINAPI DirectPlayLobbyCreateW( GUID *lpGUIDDSP, IDirectPlayLobby **lplpDPL,
2099  IUnknown *lpUnk, void *lpData, DWORD dwDataSize )
2100 {
2101  TRACE("lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08x\n",
2102  lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
2103 
2104  /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
2105  * equal 0. These fields are mostly for future expansion.
2106  */
2107  if ( lpGUIDDSP || lpData || dwDataSize )
2108  {
2109  *lplpDPL = NULL;
2110  ERR("Bad parameters!\n" );
2111  return DPERR_INVALIDPARAMS;
2112  }
2113 
2114  if( lpUnk )
2115  {
2116  *lplpDPL = NULL;
2117  ERR("Bad parameters!\n" );
2118  return CLASS_E_NOAGGREGATION;
2119  }
2120 
2121  return dplobby_create( &IID_IDirectPlayLobby, (void**)lplpDPL );
2122 }
struct tagRunApplicationEnumStruct * lpRunApplicationEnumStruct
HRESULT dplay_create(REFIID riid, void **ppv)
Definition: dplay.c:5680
static HRESULT WINAPI IDirectPlayLobby3AImpl_EnumAddressTypes(IDirectPlayLobby3A *iface, LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback, REFGUID guidSP, void *lpContext, DWORD dwFlags)
Definition: dplobby.c:711
BOOL(CALLBACK * LPDPLENUMLOCALAPPLICATIONSCALLBACK)(LPCDPLAPPINFO lpAppInfo, LPVOID lpContext, DWORD dwFlags)
Definition: dplobby.h:363
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4023
static HRESULT WINAPI IDirectPlayLobby3AImpl_SetConnectionSettings(IDirectPlayLobby3A *iface, DWORD dwFlags, DWORD dwAppID, DPLCONNECTION *lpConn)
Definition: dplobby.c:1548
#define DPOPEN_RETURNSTATUS
Definition: dplay.h:265
#define IDirectPlayLobby_ReceiveLobbyMessage(p, a, b, c, d, e)
Definition: dplobby.h:464
BOOL(CALLBACK * LPDPLENUMADDRESSTYPESCALLBACK)(REFGUID guidDataType, LPVOID lpContext, DWORD dwFlags)
Definition: dplobby.h:358
static HRESULT WINAPI IDirectPlayLobbyImpl_SendLobbyMessage(IDirectPlayLobby *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1441
WINE_DEFAULT_DEBUG_CHANNEL(dplay)
BOOL DPLAYX_SetLobbyHandles(DWORD dwAppID, HANDLE hStart, HANDLE hDeath, HANDLE hConnRead)
BOOL DPLAYX_AnyLobbiesWaitingForConnSettings(void)
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
#define CloseHandle
Definition: compat.h:398
HRESULT DPLAYX_SetConnectionSettingsA(DWORD dwFlags, DWORD dwAppID, const DPLCONNECTION *lpConn)
#define E_NOINTERFACE
Definition: winerror.h:2364
#define DPQ_INIT(head)
Definition: dplayx_queue.h:54
static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumLocalApplications(IDirectPlayLobby2A *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:872
static HRESULT WINAPI IDirectPlayLobby3Impl_QueryInterface(IDirectPlayLobby3 *iface, REFIID riid, void **ppv)
Definition: dplobby.c:158
#define IDirectPlayLobby_QueryInterface(p, a, b)
Definition: dplobby.h:454
#define ERROR_SUCCESS
Definition: deptool.c:10
static HRESULT WINAPI IDirectPlayLobby3Impl_WaitForConnectionSettings(IDirectPlayLobby3 *iface, DWORD dwFlags)
Definition: dplobby.c:1872
#define DWORD_PTR
Definition: treelist.c:76
IDirectPlayLobby2A IDirectPlayLobby2A_iface
Definition: dplobby.c:71
HRESULT hr
Definition: shlfolder.c:183
Definition: scsiwmi.h:51
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:95
#define DPQ_DELETEQ(head, field, type, df)
Definition: dplayx_queue.h:199
static HRESULT WINAPI IDirectPlayLobby2Impl_EnumAddressTypes(IDirectPlayLobby2 *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:703
#define DPERR_NOTLOBBIED
Definition: dplay.h:142
Definition: http.c:6587
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
HRESULT DPL_CreateCompoundAddress(LPCDPCOMPOUNDADDRESSELEMENT lpElements, DWORD dwElementCount, LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface) DECLSPEC_HIDDEN
Definition: dplobby.c:1660
static HRESULT WINAPI IDirectPlayLobby2AImpl_RunApplication(IDirectPlayLobby2A *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1278
struct IDirectPlay2 IDirectPlay2A
Definition: dplay.h:47
#define KEY_READ
Definition: nt_native.h:1023
#define IDirectPlayLobby_SetConnectionSettings(p, a, b, c)
Definition: dplobby.h:467
static HRESULT WINAPI IDirectPlayLobbyAImpl_GetConnectionSettings(IDirectPlayLobbyA *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:987
REFIID riid
Definition: precomp.h:44
#define DPERR_BUFFERTOOSMALL
Definition: dplay.h:92
#define CP_ACP
Definition: compat.h:99
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define IDirectPlayLobby_EnumLocalApplications(p, a, b, c)
Definition: dplobby.h:462
#define DPERR_INVALIDPARAMS
Definition: dplay.h:103
static HRESULT WINAPI IDirectPlayLobby3Impl_EnumLocalApplications(IDirectPlayLobby3 *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback, void *lpContext, DWORD dwFlags)
Definition: dplobby.c:846
#define WARN(fmt,...)
Definition: debug.h:111
#define IDirectPlayLobby_Connect(p, a, b, c)
Definition: dplobby.h:458
static HRESULT WINAPI IDirectPlayLobbyAImpl_ReceiveLobbyMessage(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1065
static const IDirectPlayLobbyVtbl dpl_vt
Definition: dplobby.c:1924
#define CALLBACK
Definition: compat.h:27
HRESULT WINAPI DirectPlayLobbyCreateA(GUID *lpGUIDDSP, IDirectPlayLobbyA **lplpDPL, IUnknown *lpUnk, void *lpData, DWORD dwDataSize)
Definition: dplobby.c:2069
#define IDirectPlayLobby_EnumAddress(p, a, b, c, d)
Definition: dplobby.h:460
REFIID LPVOID * ppv
Definition: atlbase.h:39
static HRESULT WINAPI IDirectPlayLobby2AImpl_SetConnectionSettings(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1532
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3331
#define DPERR_OUTOFMEMORY
Definition: dplay.h:109
#define ZeroMemory
Definition: winbase.h:1642
#define IDirectPlayLobby_CreateAddress(p, a, b, c, d, e, f)
Definition: dplobby.h:459
static HRESULT WINAPI IDirectPlayLobby2AImpl_SetLobbyMessageEvent(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1597
#define CREATE_DEFAULT_ERROR_MODE
Definition: winbase.h:194
#define DPERR_CANTCREATEPROCESS
Definition: dplay.h:137
LPCSTR DPLAYX_HresultToString(HRESULT hr)
static HRESULT WINAPI IDirectPlayLobbyAImpl_RunApplication(IDirectPlayLobbyA *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1262
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
static HRESULT WINAPI IDirectPlayLobby2AImpl_QueryInterface(IDirectPlayLobby2A *iface, REFIID riid, void **ppv)
Definition: dplobby.c:137
static ULONG WINAPI IDirectPlayLobby3AImpl_Release(IDirectPlayLobby3A *iface)
Definition: dplobby.c:339
DWORD dwSize
Definition: dplobby.h:283
struct IDirectPlay2 * LPDIRECTPLAY2
Definition: dplay.h:44
char * LPSTR
Definition: xmlstorage.h:182
static ULONG WINAPI IDirectPlayLobby2Impl_Release(IDirectPlayLobby2 *iface)
Definition: dplobby.c:326
#define DPERR_INVALIDFLAGS
Definition: dplay.h:100
static const IDirectPlayLobbyVtbl dplA_vt
Definition: dplobby.c:1906
static ULONG WINAPI IDirectPlayLobbyImpl_AddRef(IDirectPlayLobby *iface)
Definition: dplobby.c:222
#define DWORD
Definition: nt_native.h:44
Definition: send.c:47
GUID guidDataType
Definition: dplobby.h:252
static HRESULT WINAPI IDirectPlayLobby3Impl_GetConnectionSettings(IDirectPlayLobby3 *iface, DWORD dwAppID, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1039
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
#define lstrcpynW
Definition: compat.h:397
#define IDirectPlayX_InitializeConnection(p, a, b)
Definition: dplay.h:904
GLsizei GLsizei GLuint * obj
Definition: glext.h:6042
struct IDirectPlayLobby3 IDirectPlayLobby3A
Definition: dplobby.h:50
#define IDirectPlayX_Open(p, a, b)
Definition: dplay.h:889
static HRESULT WINAPI IDirectPlayLobby2AImpl_Connect(IDirectPlayLobby2A *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:466
GUID guidApplication
Definition: dplay.h:235
static HRESULT WINAPI IDirectPlayLobbyAImpl_QueryInterface(IDirectPlayLobbyA *iface, REFIID riid, void **ppv)
Definition: dplobby.c:123
static HRESULT WINAPI IDirectPlayLobbyAImpl_Connect(IDirectPlayLobbyA *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:452
static HRESULT WINAPI IDirectPlayLobby3AImpl_RegisterApplication(IDirectPlayLobby3A *iface, DWORD flags, DPAPPLICATIONDESC *appdesc)
Definition: dplobby.c:1851
IDirectPlayLobbyImpl * This
Definition: dplobby.c:1119
#define CREATE_SUSPENDED
Definition: winbase.h:178
static HRESULT WINAPI IDirectPlayLobby2Impl_CreateAddress(IDirectPlayLobby2 *iface, REFGUID sp, REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize)
Definition: dplobby.c:527
static HRESULT WINAPI IDirectPlayLobbyImpl_RunApplication(IDirectPlayLobby *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1270
#define DUPLICATE_SAME_ACCESS
HRESULT DPL_EnumAddress(LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress, DWORD dwAddressSize, LPVOID lpContext)
Definition: dplobby.c:644
static HRESULT WINAPI IDirectPlayLobby2Impl_SetLobbyMessageEvent(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1605
unsigned char * LPBYTE
Definition: typedefs.h:52
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby2(IDirectPlayLobby2 *iface)
Definition: dplobby.c:92
#define DP_OK
Definition: dplay.h:88
static HRESULT WINAPI IDirectPlayLobby3AImpl_ConnectEx(IDirectPlayLobby3A *iface, DWORD dwFlags, REFIID riid, void **lplpDP, IUnknown *pUnk)
Definition: dplobby.c:1837
static HRESULT WINAPI IDirectPlayLobby3Impl_UnregisterApplication(IDirectPlayLobby3 *iface, DWORD flags, REFGUID appdesc)
Definition: dplobby.c:1858
static HRESULT WINAPI IDirectPlayLobbyAImpl_SetLobbyMessageEvent(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1581
static HRESULT WINAPI IDirectPlayLobby3AImpl_SendLobbyMessage(IDirectPlayLobby3A *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1465
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
static HRESULT WINAPI IDirectPlayLobby3Impl_Connect(IDirectPlayLobby3 *iface, DWORD flags, IDirectPlay2 **dp, IUnknown *unk)
Definition: dplobby.c:486
static HRESULT WINAPI IDirectPlayLobbyImpl_GetConnectionSettings(IDirectPlayLobby *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:995
#define IDirectPlayLobby_SendLobbyMessage(p, a, b, c, d)
Definition: dplobby.h:466
GLenum GLint ref
Definition: glext.h:6028
#define FIXME(fmt,...)
Definition: debug.h:110
struct tagRunApplicationEnumStruct RunApplicationEnumStruct
static BOOL CALLBACK RunApplicationA_EnumLocalApplications(LPCDPLAPPINFO lpAppInfo, LPVOID lpContext, DWORD dwFlags)
Definition: dplobby.c:1130
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby2A(IDirectPlayLobby2A *iface)
Definition: dplobby.c:97
HRESULT DPLAYX_GetConnectionSettingsA(DWORD dwAppID, LPVOID lpData, LPDWORD lpdwDataSize)
static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateCompoundAddress(IDirectPlayLobby2A *iface, const DPCOMPOUNDADDRESSELEMENT *elements, DWORD count, void *address, DWORD *size)
Definition: dplobby.c:1629
char * appid
Definition: mkisofs.c:161
static const IDirectPlayLobby3Vtbl dpl3A_vt
Definition: dplobby.c:1980
static HRESULT WINAPI IDirectPlayLobby3Impl_ReceiveLobbyMessage(IDirectPlayLobby3 *iface, DWORD dwFlags, DWORD dwAppID, DWORD *lpdwMessageFlags, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1107
static BOOL DPL_CreateAndSetLobbyHandles(DWORD dwDestProcessId, HANDLE hDestProcess, LPHANDLE lphStart, LPHANDLE lphDeath, LPHANDLE lphRead)
Definition: dplobby.c:1210
#define IDirectPlayLobby_EnumAddressTypes(p, a, b, c, d)
Definition: dplobby.h:461
static HRESULT WINAPI IDirectPlayLobby2Impl_QueryInterface(IDirectPlayLobby2 *iface, REFIID riid, void **ppv)
Definition: dplobby.c:144
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
smooth NULL
Definition: ftsmooth.c:416
IDirectPlayLobby2 IDirectPlayLobby2_iface
Definition: dplobby.c:70
static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddressTypes(IDirectPlayLobbyA *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:679
HRESULT dplobby_create(REFIID riid, void **ppv)
Definition: dplobby.c:2026
static ULONG WINAPI IDirectPlayLobbyAImpl_AddRef(IDirectPlayLobbyA *iface)
Definition: dplobby.c:209
static ULONG WINAPI IDirectPlayLobby3Impl_AddRef(IDirectPlayLobby3 *iface)
Definition: dplobby.c:274
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby3(IDirectPlayLobby3 *iface)
Definition: dplobby.c:102
static HRESULT WINAPI IDirectPlayLobby2Impl_GetConnectionSettings(IDirectPlayLobby2 *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:1011
const char * LPCSTR
Definition: xmlstorage.h:183
static HRESULT WINAPI IDirectPlayLobby3AImpl_UnregisterApplication(IDirectPlayLobby3A *iface, DWORD flags, REFGUID appdesc)
Definition: dplobby.c:1865
#define debugstr_guid
Definition: kernel32.h:35
static HRESULT WINAPI IDirectPlayLobbyImpl_EnumAddressTypes(IDirectPlayLobby *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:687
static HRESULT WINAPI IDirectPlayLobby3AImpl_ReceiveLobbyMessage(IDirectPlayLobby3A *iface, DWORD dwFlags, DWORD dwAppID, DWORD *lpdwMessageFlags, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1097
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static void *static void *static LPDIRECTPLAY * lplpDP
Definition: dplayx.c:30
static HRESULT WINAPI IDirectPlayLobby2Impl_SendLobbyMessage(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1457
static HRESULT WINAPI IDirectPlayLobbyImpl_CreateAddress(IDirectPlayLobby *iface, REFGUID sp, REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize)
Definition: dplobby.c:511
static const IDirectPlayLobby2Vtbl dpl2A_vt
Definition: dplobby.c:1942
static const IDirectPlayLobby2Vtbl dpl2_vt
Definition: dplobby.c:1961
#define TRACE(s)
Definition: solgame.cpp:4
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby(IDirectPlayLobby *iface)
Definition: dplobby.c:82
#define IDirectPlayLobby_Release(p)
Definition: dplobby.h:456
GLsizeiptr size
Definition: glext.h:5919
#define CREATE_NEW_CONSOLE
Definition: winbase.h:180
DWORD cb
Definition: winbase.h:803
static HRESULT WINAPI IDirectPlayLobbyImpl_ReceiveLobbyMessage(IDirectPlayLobby *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1073
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateAddress(IDirectPlayLobby2A *iface, REFGUID sp, REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize)
Definition: dplobby.c:519
DWORD CreateLobbyMessageReceptionThread(HANDLE hNotifyEvent, HANDLE hStart, HANDLE hDeath, HANDLE hConnRead)
__wchar_t WCHAR
Definition: xmlstorage.h:180
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
LONG HRESULT
Definition: typedefs.h:77
#define DPERR_INVALIDOBJECT
Definition: dplay.h:101
const GUID IID_IUnknown
BOOL DPLAYX_CreateLobbyApplication(DWORD dwAppID)
HANDLE WINAPI GetCurrentProcess(VOID)
Definition: proc.c:1138
static HRESULT DPL_CreateAddress(REFGUID guidSP, REFGUID guidDataType, LPCVOID lpData, DWORD dwDataSize, LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface)
Definition: dplobby.c:551
BOOL WINAPI DECLSPEC_HOTPATCH CreateProcessA(LPCSTR lpApplicationName, LPSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes, LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles, DWORD dwCreationFlags, LPVOID lpEnvironment, LPCSTR lpCurrentDirectory, LPSTARTUPINFOA lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation)
Definition: proc.c:4742
#define WINAPI
Definition: msvc.h:8
#define CopyMemory
Definition: winbase.h:1640
static HRESULT WINAPI IDirectPlayLobby3AImpl_CreateAddress(IDirectPlayLobby3A *iface, REFGUID guidSP, REFGUID guidDataType, const void *lpData, DWORD dwDataSize, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:535
unsigned short WORD
Definition: ntddk_ex.h:93
static HRESULT WINAPI IDirectPlayLobby2Impl_EnumLocalApplications(IDirectPlayLobby2 *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:880
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint address
Definition: glext.h:9393
BOOL DPLAYX_SetLobbyMsgThreadId(DWORD dwAppId, DWORD dwThreadId)
#define DPQ_ENTRY(type)
Definition: dplayx_queue.h:45
#define LPVOID
Definition: nt_native.h:45
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumAddressTypes(IDirectPlayLobby2A *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:695
GUID guidApplication
Definition: dplobby.h:284
GLbitfield flags
Definition: glext.h:7161
HRESULT DPLAYX_GetConnectionSettingsW(DWORD dwAppID, LPVOID lpData, LPDWORD lpdwDataSize)
IDirectPlayLobby3 IDirectPlayLobby3_iface
Definition: dplobby.c:72
static HRESULT WINAPI IDirectPlayLobby3Impl_SendLobbyMessage(IDirectPlayLobby3 *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1472
#define IDirectPlayLobby_GetConnectionSettings(p, a, b, c)
Definition: dplobby.h:463
#define DPCONNECT_RETURNSTATUS
Definition: dplay.h:1065
static ULONG WINAPI IDirectPlayLobbyImpl_Release(IDirectPlayLobby *iface)
Definition: dplobby.c:300
static HRESULT WINAPI IDirectPlayLobby2AImpl_SendLobbyMessage(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1449
static HRESULT WINAPI IDirectPlayLobby2Impl_EnumAddress(IDirectPlayLobby2 *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:612
static HRESULT WINAPI IDirectPlayLobby3Impl_ConnectEx(IDirectPlayLobby3 *iface, DWORD dwFlags, REFIID riid, LPVOID *lplpDP, IUnknown *pUnk)
Definition: dplobby.c:1830
#define DPLWAIT_CANCEL
Definition: dplobby.h:503
#define LPDWORD
Definition: nt_native.h:46
#define InterlockedDecrement
Definition: armddk.h:52
static HRESULT WINAPI IDirectPlayLobby2AImpl_GetConnectionSettings(IDirectPlayLobby2A *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:1003
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
static HRESULT WINAPI IDirectPlayLobby3Impl_CreateCompoundAddress(IDirectPlayLobby3 *iface, const DPCOMPOUNDADDRESSELEMENT *lpElements, DWORD dwElementCount, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:1645
static const IDirectPlayLobby3Vtbl dpl3_vt
Definition: dplobby.c:2003
struct IDirectPlayLobbyImpl IDirectPlayLobbyImpl
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
IDirectPlayLobbyA IDirectPlayLobbyA_iface
Definition: dplobby.c:69
unsigned char BYTE
Definition: mem.h:68
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby3A(IDirectPlayLobby3A *iface)
Definition: dplobby.c:107
static HRESULT WINAPI IDirectPlayLobby3Impl_RunApplication(IDirectPlayLobby3 *iface, DWORD dwFlags, DWORD *lpdwAppID, DPLCONNECTION *lpConn, HANDLE hReceiveEvent)
Definition: dplobby.c:1419
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:2662
struct _cl_event * event
Definition: glext.h:7739
HRESULT DPLAYX_SetConnectionSettingsW(DWORD dwFlags, DWORD dwAppID, const DPLCONNECTION *lpConn)
static HRESULT DPL_ConnectEx(IDirectPlayLobbyImpl *This, DWORD dwFlags, REFIID riid, void **lplpDP, IUnknown *pUnk)
Definition: dplobby.c:374
static HRESULT WINAPI IDirectPlayLobby3Impl_CreateAddress(IDirectPlayLobby3 *iface, REFGUID guidSP, REFGUID guidDataType, const void *lpData, DWORD dwDataSize, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:543
uint16_t * LPWORD
Definition: typedefs.h:54
static HRESULT WINAPI IDirectPlayLobby3Impl_RegisterApplication(IDirectPlayLobby3 *iface, DWORD flags, DPAPPLICATIONDESC *appdesc)
Definition: dplobby.c:1844
#define ERR(fmt,...)
Definition: debug.h:109
static ULONG WINAPI IDirectPlayLobbyAImpl_Release(IDirectPlayLobbyA *iface)
Definition: dplobby.c:287
static HRESULT WINAPI IDirectPlayLobby2AImpl_ReceiveLobbyMessage(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1081
struct IDirectPlayLobby2 IDirectPlayLobby2A
Definition: dplobby.h:44
struct _GUID GUID
#define IDirectPlayLobby_ConnectEx(p, a, b, c, d)
Definition: dplobby.h:472
#define IDirectPlayLobby_SetLobbyMessageEvent(p, a, b, c)
Definition: dplobby.h:468
#define S_OK
Definition: intsafe.h:59
static ULONG WINAPI IDirectPlayLobby2Impl_AddRef(IDirectPlayLobby2 *iface)
Definition: dplobby.c:248
static HRESULT WINAPI IDirectPlayLobby3AImpl_CreateCompoundAddress(IDirectPlayLobby3A *iface, const DPCOMPOUNDADDRESSELEMENT *lpElements, DWORD dwElementCount, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:1652
#define InterlockedIncrement
Definition: armddk.h:53
#define DECLSPEC_HIDDEN
Definition: precomp.h:8
static HRESULT WINAPI IDirectPlayLobby3AImpl_SetLobbyMessageEvent(IDirectPlayLobby3A *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1613
LPVOID lpSecurityDescriptor
Definition: compat.h:181
struct tagDPADDRESS DPADDRESS
static HRESULT WINAPI IDirectPlayLobbyAImpl_SetConnectionSettings(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1516
static HRESULT WINAPI IDirectPlayLobby3AImpl_WaitForConnectionSettings(IDirectPlayLobby3A *iface, DWORD dwFlags)
Definition: dplobby.c:1889
static calc_node_t temp
Definition: rpn_ieee.c:38
static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddress(IDirectPlayLobbyA *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:588
#define ARRAY_SIZE(a)
Definition: main.h:24
struct DPLMSG * LPDPLMSG
Definition: dplobby.c:64
struct IDirectPlayLobby IDirectPlayLobbyA
Definition: dplobby.h:38
static HRESULT WINAPI IDirectPlayLobby2Impl_RunApplication(IDirectPlayLobby2 *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1286
static ULONG WINAPI IDirectPlayLobby3AImpl_AddRef(IDirectPlayLobby3A *iface)
Definition: dplobby.c:261
static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumAddress(IDirectPlayLobby2A *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:604
#define DPERR_NOMEMORY
Definition: dplay.h:108
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4021
static void dplobby_destroy(IDirectPlayLobbyImpl *obj)
Definition: dplobby.c:112
#define lstrcpynA
Definition: compat.h:408
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
#define MultiByteToWideChar
Definition: compat.h:100
static HRESULT WINAPI IDirectPlayLobbyImpl_SetConnectionSettings(IDirectPlayLobby *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1524
static HRESULT WINAPI IDirectPlayLobby3Impl_SetConnectionSettings(IDirectPlayLobby3 *iface, DWORD dwFlags, DWORD dwAppID, DPLCONNECTION *lpConn)
Definition: dplobby.c:1485
IDirectPlayLobby3A IDirectPlayLobby3A_iface
Definition: dplobby.c:73
static HRESULT WINAPI IDirectPlayLobby2Impl_ReceiveLobbyMessage(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1089
static HRESULT WINAPI IDirectPlayLobbyImpl_QueryInterface(IDirectPlayLobby *iface, REFIID riid, void **ppv)
Definition: dplobby.c:130
LPDPSESSIONDESC2 lpSessionDesc
Definition: dplay.h:286
static HRESULT WINAPI IDirectPlayLobby3AImpl_GetConnectionSettings(IDirectPlayLobby3A *iface, DWORD dwAppID, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1019
static HRESULT WINAPI IDirectPlayLobby3AImpl_RunApplication(IDirectPlayLobby3A *iface, DWORD dwFlags, DWORD *lpdwAppID, DPLCONNECTION *lpConn, HANDLE hReceiveEvent)
Definition: dplobby.c:1294
CONST void * LPCVOID
Definition: windef.h:191
static HRESULT WINAPI IDirectPlayLobbyImpl_EnumAddress(IDirectPlayLobby *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:596
static HRESULT WINAPI IDirectPlayLobbyImpl_SetLobbyMessageEvent(IDirectPlayLobby *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1589
static HRESULT WINAPI IDirectPlayLobby3AImpl_EnumLocalApplications(IDirectPlayLobby3A *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback, void *lpContext, DWORD dwFlags)
Definition: dplobby.c:888
DWORD dwFlags
Definition: dplay.h:285
static HRESULT WINAPI IDirectPlayLobby3AImpl_QueryInterface(IDirectPlayLobby3A *iface, REFIID riid, void **ppv)
Definition: dplobby.c:151
HRESULT WINAPI DirectPlayLobbyCreateW(GUID *lpGUIDDSP, IDirectPlayLobby **lplpDPL, IUnknown *lpUnk, void *lpData, DWORD dwDataSize)
Definition: dplobby.c:2098
static HRESULT WINAPI IDirectPlayLobbyAImpl_CreateAddress(IDirectPlayLobbyA *iface, REFGUID sp, REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize)
Definition: dplobby.c:503
uint32_t * LPDWORD
Definition: typedefs.h:57
DWORD WINAPI ResumeThread(IN HANDLE hThread)
Definition: thread.c:566
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
static HRESULT WINAPI IDirectPlayLobby3AImpl_EnumAddress(IDirectPlayLobby3A *iface, LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, const void *lpAddress, DWORD dwAddressSize, void *lpContext)
Definition: dplobby.c:620
IDirectPlayLobby IDirectPlayLobby_iface
Definition: dplobby.c:68
HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id)
Definition: compobj.c:2247
unsigned int ULONG
Definition: retypes.h:1
static HRESULT WINAPI IDirectPlayLobby3Impl_EnumAddress(IDirectPlayLobby3 *iface, LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, const void *lpAddress, DWORD dwAddressSize, void *lpContext)
Definition: dplobby.c:632
const char * appName(const char *argv0)
Definition: loadlib.c:89
static HRESULT WINAPI IDirectPlayLobby2Impl_SetConnectionSettings(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1540
static const WCHAR sp[]
Definition: suminfo.c:288
BOOL DPLAYX_WaitForConnectionSettings(BOOL bWait)
static HRESULT WINAPI IDirectPlayLobbyImpl_EnumLocalApplications(IDirectPlayLobby *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:864
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
static ULONG WINAPI IDirectPlayLobby2AImpl_AddRef(IDirectPlayLobby2A *iface)
Definition: dplobby.c:235
static HRESULT WINAPI IDirectPlayLobbyAImpl_SendLobbyMessage(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1433
BOOL(CALLBACK * LPDPENUMADDRESSCALLBACK)(REFGUID guidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext)
Definition: dplobby.h:352
#define IDirectPlayLobby_RunApplication(p, a, b, c, d)
Definition: dplobby.h:465
static HRESULT WINAPI IDirectPlayLobby2Impl_Connect(IDirectPlayLobby2 *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:473
static HRESULT WINAPI IDirectPlayLobbyImpl_Connect(IDirectPlayLobby *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:459
CRITICAL_SECTION lock
Definition: dplobby.c:76
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
DWORD dwDataSize
Definition: dplobby.h:253
static unsigned char buff[32768]
Definition: fatten.c:17
#define HeapFree(x, y, z)
Definition: compat.h:394
#define IDirectPlayLobby_CreateCompoundAddress(p, a, b, c, d)
Definition: dplobby.h:470
static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumLocalApplications(IDirectPlayLobbyA *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:856
LONG WINAPI RegEnumKeyExA(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2442
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobbyA(IDirectPlayLobbyA *iface)
Definition: dplobby.c:87
static ULONG WINAPI IDirectPlayLobby3Impl_Release(IDirectPlayLobby3 *iface)
Definition: dplobby.c:352
static HRESULT WINAPI IDirectPlayLobby2Impl_CreateCompoundAddress(IDirectPlayLobby2 *iface, const DPCOMPOUNDADDRESSELEMENT *elements, DWORD count, void *address, DWORD *size)
Definition: dplobby.c:1637
DWORD WINAPI GetCurrentProcessId(VOID)
Definition: proc.c:1158
static HRESULT WINAPI IDirectPlayLobby3Impl_SetLobbyMessageEvent(IDirectPlayLobby3 *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1620
LPSTR lpszAppNameA
Definition: dplobby.h:288
static HRESULT WINAPI IDirectPlayLobby3Impl_EnumAddressTypes(IDirectPlayLobby3 *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:832
#define DPQ_HEAD(type)
Definition: dplayx_queue.h:39
static ULONG WINAPI IDirectPlayLobby2AImpl_Release(IDirectPlayLobby2A *iface)
Definition: dplobby.c:313
static HRESULT WINAPI IDirectPlayLobby3AImpl_Connect(IDirectPlayLobby3A *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:480
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
Definition: dplobby.c:60