ReactOS 0.4.15-dev-8127-g6338913
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
43static 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 */
60struct DPLMSG
61{
62 DPQ_ENTRY( DPLMSG ) msgs; /* Link to next queued message */
63};
64typedef struct DPLMSG* LPDPLMSG;
65
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
82static 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
92static 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
102static 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{
213
214 TRACE( "(%p) refA=%d\n", This, ref );
215
216 if ( ref == 1 )
217 InterlockedIncrement( &This->numIfaces );
218
219 return ref;
220}
221
222static ULONG WINAPI IDirectPlayLobbyImpl_AddRef( IDirectPlayLobby *iface )
223{
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
248static ULONG WINAPI IDirectPlayLobby2Impl_AddRef(IDirectPlayLobby2 *iface)
249{
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
274static ULONG WINAPI IDirectPlayLobby3Impl_AddRef(IDirectPlayLobby3 *iface)
275{
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{
291
292 TRACE( "(%p) refA=%d\n", This, ref );
293
294 if ( !ref && !InterlockedDecrement( &This->numIfaces ) )
296
297 return ref;
298}
299
300static ULONG WINAPI IDirectPlayLobbyImpl_Release( IDirectPlayLobby *iface )
301{
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
326static ULONG WINAPI IDirectPlayLobby2Impl_Release(IDirectPlayLobby2 *iface)
327{
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
352static ULONG WINAPI IDirectPlayLobby3Impl_Release(IDirectPlayLobby3 *iface)
353{
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
459static 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
473static 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
486static 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
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
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
543static 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
596static 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
612static 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
632static 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
644HRESULT 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 */
681{
683 return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3A_iface, enumaddrtypecb, sp,
684 context, flags );
685}
686
689{
691 return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3_iface, enumaddrtypecb, sp,
692 context, flags );
693}
694
697{
699 return IDirectPlayLobby_EnumAddressTypes( &This->IDirectPlayLobby3A_iface, enumaddrtypecb, sp,
700 context, flags );
701}
702
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
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
858{
860 return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3A_iface, enumlocalappcb,
861 context, flags );
862}
863
866{
868 return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3_iface, enumlocalappcb,
869 context, flags );
870}
871
874{
876 return IDirectPlayLobby_EnumLocalApplications( &This->IDirectPlayLobby3A_iface, enumlocalappcb,
877 context, flags );
878}
879
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
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
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
1210static 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 */
1264{
1266 return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3A_iface, flags, appid, conn,
1267 event );
1268}
1269
1272{
1274 return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3_iface, flags, appid, conn,
1275 event );
1276}
1277
1280{
1282 return IDirectPlayLobby_RunApplication( &This->IDirectPlayLobby3A_iface, flags, appid, conn,
1283 event );
1284}
1285
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
1368 HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
1370
1371 LeaveCriticalSection( &This->lock );
1373 }
1374
1376 HeapFree( GetProcessHeap(), 0, enumData.lpszCommandLine );
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 */
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
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 }
1508 hr = DPLAYX_SetConnectionSettingsW( dwFlags, dwAppID, lpConn );
1509 }
1510
1511 LeaveCriticalSection( &This->lock );
1512
1513 return hr;
1514}
1515
1518{
1520 return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3A_iface, flags,
1521 appid, conn );
1522}
1523
1526{
1528 return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3_iface, flags,
1529 appid, conn );
1530}
1531
1534{
1536 return IDirectPlayLobby_SetConnectionSettings( &This->IDirectPlayLobby3A_iface, flags,
1537 appid, conn );
1538}
1539
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();
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
1660( LPCDPCOMPOUNDADDRESSELEMENT lpElements,
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
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? */
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? */
1901 }
1902
1903 return hr;
1904}
1905
1906static const IDirectPlayLobbyVtbl dplA_vt =
1907{
1922};
1923
1924static const IDirectPlayLobbyVtbl dpl_vt =
1925{
1940};
1941
1942static const IDirectPlayLobby2Vtbl dpl2A_vt =
1943{
1959};
1960
1961static const IDirectPlayLobby2Vtbl dpl2_vt =
1962{
1978};
1979
1980static const IDirectPlayLobby3Vtbl dpl3A_vt =
1981{
2001};
2002
2003static 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
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 */
2098HRESULT 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}
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define ARRAY_SIZE(A)
Definition: main.h:33
const GUID IID_IUnknown
#define FIXME(fmt,...)
Definition: debug.h:114
#define WARN(fmt,...)
Definition: debug.h:115
#define ERR(fmt,...)
Definition: debug.h:113
static SIZE_T datasize
Definition: asm.c:30
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define DECLSPEC_HIDDEN
Definition: precomp.h:8
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3298
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:4009
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:2419
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define CP_ACP
Definition: compat.h:109
#define lstrcpynA
Definition: compat.h:751
#define HeapAlloc
Definition: compat.h:733
#define GetCurrentProcess()
Definition: compat.h:759
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CALLBACK
Definition: compat.h:35
#define MultiByteToWideChar
Definition: compat.h:110
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrcpynW
Definition: compat.h:738
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
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:4741
DWORD WINAPI ResumeThread(IN HANDLE hThread)
Definition: thread.c:567
HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id)
Definition: compobj.c:2338
HRESULT dplay_create(REFIID riid, void **ppv)
Definition: dplay.c:5676
#define DPERR_INVALIDOBJECT
Definition: dplay.h:101
#define IDirectPlayX_Open(p, a, b)
Definition: dplay.h:889
#define DPERR_NOMEMORY
Definition: dplay.h:108
#define DPERR_BUFFERTOOSMALL
Definition: dplay.h:92
#define DPOPEN_RETURNSTATUS
Definition: dplay.h:265
#define DPERR_INVALIDFLAGS
Definition: dplay.h:100
struct IDirectPlay2 * LPDIRECTPLAY2
Definition: dplay.h:44
#define DPCONNECT_RETURNSTATUS
Definition: dplay.h:1065
#define DP_OK
Definition: dplay.h:88
#define IDirectPlayX_InitializeConnection(p, a, b)
Definition: dplay.h:904
#define DPERR_NOTLOBBIED
Definition: dplay.h:142
#define DPERR_INVALIDPARAMS
Definition: dplay.h:103
#define DPERR_OUTOFMEMORY
Definition: dplay.h:109
struct IDirectPlay2 IDirectPlay2A
Definition: dplay.h:47
#define DPERR_CANTCREATEPROCESS
Definition: dplay.h:137
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
static void *static void *static LPDIRECTPLAY * lplpDP
Definition: dplayx.c:30
HRESULT DPLAYX_GetConnectionSettingsA(DWORD dwAppID, LPVOID lpData, LPDWORD lpdwDataSize)
BOOL DPLAYX_SetLobbyHandles(DWORD dwAppID, HANDLE hStart, HANDLE hDeath, HANDLE hConnRead)
BOOL DPLAYX_AnyLobbiesWaitingForConnSettings(void)
HRESULT DPLAYX_SetConnectionSettingsA(DWORD dwFlags, DWORD dwAppID, const DPLCONNECTION *lpConn)
BOOL DPLAYX_SetLobbyMsgThreadId(DWORD dwAppId, DWORD dwThreadId)
BOOL DPLAYX_CreateLobbyApplication(DWORD dwAppID)
BOOL DPLAYX_WaitForConnectionSettings(BOOL bWait)
HRESULT DPLAYX_SetConnectionSettingsW(DWORD dwFlags, DWORD dwAppID, const DPLCONNECTION *lpConn)
LPCSTR DPLAYX_HresultToString(HRESULT hr)
HRESULT DPLAYX_GetConnectionSettingsW(DWORD dwAppID, LPVOID lpData, LPDWORD lpdwDataSize)
DWORD CreateLobbyMessageReceptionThread(HANDLE hNotifyEvent, HANDLE hStart, HANDLE hDeath, HANDLE hConnRead)
#define DPQ_INIT(head)
Definition: dplayx_queue.h:54
#define DPQ_ENTRY(type)
Definition: dplayx_queue.h:45
#define DPQ_HEAD(type)
Definition: dplayx_queue.h:39
#define DPQ_DELETEQ(head, field, type, df)
Definition: dplayx_queue.h:199
static HRESULT DPL_ConnectEx(IDirectPlayLobbyImpl *This, DWORD dwFlags, REFIID riid, void **lplpDP, IUnknown *pUnk)
Definition: dplobby.c:374
static HRESULT WINAPI IDirectPlayLobby3Impl_QueryInterface(IDirectPlayLobby3 *iface, REFIID riid, void **ppv)
Definition: dplobby.c:158
static HRESULT WINAPI IDirectPlayLobbyAImpl_CreateAddress(IDirectPlayLobbyA *iface, REFGUID sp, REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize)
Definition: dplobby.c:503
static HRESULT WINAPI IDirectPlayLobbyImpl_QueryInterface(IDirectPlayLobby *iface, REFIID riid, void **ppv)
Definition: dplobby.c:130
static ULONG WINAPI IDirectPlayLobby3AImpl_Release(IDirectPlayLobby3A *iface)
Definition: dplobby.c:339
static const IDirectPlayLobby3Vtbl dpl3_vt
Definition: dplobby.c:2003
static HRESULT WINAPI IDirectPlayLobby3AImpl_EnumAddressTypes(IDirectPlayLobby3A *iface, LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback, REFGUID guidSP, void *lpContext, DWORD dwFlags)
Definition: dplobby.c:711
HRESULT WINAPI DirectPlayLobbyCreateW(GUID *lpGUIDDSP, IDirectPlayLobby **lplpDPL, IUnknown *lpUnk, void *lpData, DWORD dwDataSize)
Definition: dplobby.c:2098
static HRESULT WINAPI IDirectPlayLobbyAImpl_SetLobbyMessageEvent(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1581
static HRESULT WINAPI IDirectPlayLobbyAImpl_Connect(IDirectPlayLobbyA *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:452
static HRESULT WINAPI IDirectPlayLobbyImpl_GetConnectionSettings(IDirectPlayLobby *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:995
static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumAddressTypes(IDirectPlayLobby2A *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:695
static HRESULT WINAPI IDirectPlayLobby3AImpl_QueryInterface(IDirectPlayLobby3A *iface, REFIID riid, void **ppv)
Definition: dplobby.c:151
static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddressTypes(IDirectPlayLobbyA *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:679
static HRESULT WINAPI IDirectPlayLobby3Impl_EnumAddress(IDirectPlayLobby3 *iface, LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, const void *lpAddress, DWORD dwAddressSize, void *lpContext)
Definition: dplobby.c:632
static ULONG WINAPI IDirectPlayLobbyImpl_AddRef(IDirectPlayLobby *iface)
Definition: dplobby.c:222
static const IDirectPlayLobby2Vtbl dpl2A_vt
Definition: dplobby.c:1942
static HRESULT WINAPI IDirectPlayLobbyAImpl_GetConnectionSettings(IDirectPlayLobbyA *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:987
struct tagRunApplicationEnumStruct RunApplicationEnumStruct
static HRESULT WINAPI IDirectPlayLobby3AImpl_CreateAddress(IDirectPlayLobby3A *iface, REFGUID guidSP, REFGUID guidDataType, const void *lpData, DWORD dwDataSize, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:535
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby2A(IDirectPlayLobby2A *iface)
Definition: dplobby.c:97
static ULONG WINAPI IDirectPlayLobby2Impl_AddRef(IDirectPlayLobby2 *iface)
Definition: dplobby.c:248
static HRESULT WINAPI IDirectPlayLobby3AImpl_RegisterApplication(IDirectPlayLobby3A *iface, DWORD flags, DPAPPLICATIONDESC *appdesc)
Definition: dplobby.c:1851
static HRESULT WINAPI IDirectPlayLobby3Impl_SetConnectionSettings(IDirectPlayLobby3 *iface, DWORD dwFlags, DWORD dwAppID, DPLCONNECTION *lpConn)
Definition: dplobby.c:1485
static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateAddress(IDirectPlayLobby2A *iface, REFGUID sp, REFGUID datatype, const void *data, DWORD datasize, void *address, DWORD *addrsize)
Definition: dplobby.c:519
static ULONG WINAPI IDirectPlayLobbyImpl_Release(IDirectPlayLobby *iface)
Definition: dplobby.c:300
static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumLocalApplications(IDirectPlayLobbyA *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:856
static HRESULT WINAPI IDirectPlayLobby3Impl_Connect(IDirectPlayLobby3 *iface, DWORD flags, IDirectPlay2 **dp, IUnknown *unk)
Definition: dplobby.c:486
static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddress(IDirectPlayLobbyA *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:588
static HRESULT WINAPI IDirectPlayLobby3Impl_GetConnectionSettings(IDirectPlayLobby3 *iface, DWORD dwAppID, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1039
static HRESULT WINAPI IDirectPlayLobby2Impl_GetConnectionSettings(IDirectPlayLobby2 *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:1011
static HRESULT WINAPI IDirectPlayLobbyImpl_EnumAddressTypes(IDirectPlayLobby *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:687
static HRESULT WINAPI IDirectPlayLobbyImpl_RunApplication(IDirectPlayLobby *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1270
static const IDirectPlayLobbyVtbl dplA_vt
Definition: dplobby.c:1906
static HRESULT WINAPI IDirectPlayLobby2Impl_SetConnectionSettings(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1540
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_SetLobbyMessageEvent(IDirectPlayLobby *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1589
static HRESULT WINAPI IDirectPlayLobby3AImpl_ConnectEx(IDirectPlayLobby3A *iface, DWORD dwFlags, REFIID riid, void **lplpDP, IUnknown *pUnk)
Definition: dplobby.c:1837
static const IDirectPlayLobbyVtbl dpl_vt
Definition: dplobby.c:1924
static HRESULT WINAPI IDirectPlayLobby3Impl_EnumAddressTypes(IDirectPlayLobby3 *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:832
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby2(IDirectPlayLobby2 *iface)
Definition: dplobby.c:92
static HRESULT WINAPI IDirectPlayLobby3AImpl_UnregisterApplication(IDirectPlayLobby3A *iface, DWORD flags, REFGUID appdesc)
Definition: dplobby.c:1865
static HRESULT WINAPI IDirectPlayLobby3Impl_ConnectEx(IDirectPlayLobby3 *iface, DWORD dwFlags, REFIID riid, LPVOID *lplpDP, IUnknown *pUnk)
Definition: dplobby.c:1830
static HRESULT WINAPI IDirectPlayLobby3Impl_CreateAddress(IDirectPlayLobby3 *iface, REFGUID guidSP, REFGUID guidDataType, const void *lpData, DWORD dwDataSize, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:543
static ULONG WINAPI IDirectPlayLobby3Impl_AddRef(IDirectPlayLobby3 *iface)
Definition: dplobby.c:274
static HRESULT WINAPI IDirectPlayLobby2AImpl_SendLobbyMessage(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1449
static HRESULT WINAPI IDirectPlayLobby3AImpl_ReceiveLobbyMessage(IDirectPlayLobby3A *iface, DWORD dwFlags, DWORD dwAppID, DWORD *lpdwMessageFlags, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1097
static HRESULT WINAPI IDirectPlayLobby3AImpl_SetLobbyMessageEvent(IDirectPlayLobby3A *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1613
static HRESULT WINAPI IDirectPlayLobby2Impl_Connect(IDirectPlayLobby2 *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:473
static ULONG WINAPI IDirectPlayLobby3AImpl_AddRef(IDirectPlayLobby3A *iface)
Definition: dplobby.c:261
static HRESULT WINAPI IDirectPlayLobby2Impl_EnumLocalApplications(IDirectPlayLobby2 *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:880
static BOOL CALLBACK RunApplicationA_EnumLocalApplications(LPCDPLAPPINFO lpAppInfo, LPVOID lpContext, DWORD dwFlags)
Definition: dplobby.c:1130
static HRESULT WINAPI IDirectPlayLobby2AImpl_QueryInterface(IDirectPlayLobby2A *iface, REFIID riid, void **ppv)
Definition: dplobby.c:137
static HRESULT WINAPI IDirectPlayLobby3Impl_WaitForConnectionSettings(IDirectPlayLobby3 *iface, DWORD dwFlags)
Definition: dplobby.c:1872
static HRESULT WINAPI IDirectPlayLobby3AImpl_SetConnectionSettings(IDirectPlayLobby3A *iface, DWORD dwFlags, DWORD dwAppID, DPLCONNECTION *lpConn)
Definition: dplobby.c:1548
static ULONG WINAPI IDirectPlayLobbyAImpl_Release(IDirectPlayLobbyA *iface)
Definition: dplobby.c:287
static HRESULT WINAPI IDirectPlayLobby3AImpl_CreateCompoundAddress(IDirectPlayLobby3A *iface, const DPCOMPOUNDADDRESSELEMENT *lpElements, DWORD dwElementCount, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:1652
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby3A(IDirectPlayLobby3A *iface)
Definition: dplobby.c:107
static HRESULT WINAPI IDirectPlayLobbyAImpl_RunApplication(IDirectPlayLobbyA *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1262
static HRESULT WINAPI IDirectPlayLobby3Impl_EnumLocalApplications(IDirectPlayLobby3 *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback, void *lpContext, DWORD dwFlags)
Definition: dplobby.c:846
static const IDirectPlayLobby2Vtbl dpl2_vt
Definition: dplobby.c:1961
HRESULT DPL_EnumAddress(LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress, DWORD dwAddressSize, LPVOID lpContext)
Definition: dplobby.c:644
static HRESULT WINAPI IDirectPlayLobby2AImpl_GetConnectionSettings(IDirectPlayLobby2A *iface, DWORD appid, void *data, DWORD *size)
Definition: dplobby.c:1003
static HRESULT WINAPI IDirectPlayLobby3Impl_ReceiveLobbyMessage(IDirectPlayLobby3 *iface, DWORD dwFlags, DWORD dwAppID, DWORD *lpdwMessageFlags, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1107
static HRESULT WINAPI IDirectPlayLobby2Impl_CreateCompoundAddress(IDirectPlayLobby2 *iface, const DPCOMPOUNDADDRESSELEMENT *elements, DWORD count, void *address, DWORD *size)
Definition: dplobby.c:1637
static HRESULT WINAPI IDirectPlayLobby3AImpl_GetConnectionSettings(IDirectPlayLobby3A *iface, DWORD dwAppID, void *lpData, DWORD *lpdwDataSize)
Definition: dplobby.c:1019
static HRESULT WINAPI IDirectPlayLobby2AImpl_ReceiveLobbyMessage(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1081
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby(IDirectPlayLobby *iface)
Definition: dplobby.c:82
static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumLocalApplications(IDirectPlayLobby2A *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:872
static HRESULT WINAPI IDirectPlayLobbyImpl_SendLobbyMessage(IDirectPlayLobby *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1441
HRESULT DPL_CreateCompoundAddress(LPCDPCOMPOUNDADDRESSELEMENT lpElements, DWORD dwElementCount, LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface) DECLSPEC_HIDDEN
Definition: dplobby.c:1660
static HRESULT WINAPI IDirectPlayLobby2Impl_EnumAddressTypes(IDirectPlayLobby2 *iface, LPDPLENUMADDRESSTYPESCALLBACK enumaddrtypecb, REFGUID sp, void *context, DWORD flags)
Definition: dplobby.c:703
static HRESULT DPL_CreateAddress(REFGUID guidSP, REFGUID guidDataType, LPCVOID lpData, DWORD dwDataSize, LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface)
Definition: dplobby.c:551
static IDirectPlayLobbyImpl * impl_from_IDirectPlayLobbyA(IDirectPlayLobbyA *iface)
Definition: dplobby.c:87
static HRESULT WINAPI IDirectPlayLobby3Impl_UnregisterApplication(IDirectPlayLobby3 *iface, DWORD flags, REFGUID appdesc)
Definition: dplobby.c:1858
static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumAddress(IDirectPlayLobby2A *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:604
static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateCompoundAddress(IDirectPlayLobby2A *iface, const DPCOMPOUNDADDRESSELEMENT *elements, DWORD count, void *address, DWORD *size)
Definition: dplobby.c:1629
static HRESULT WINAPI IDirectPlayLobbyAImpl_ReceiveLobbyMessage(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1065
static HRESULT WINAPI IDirectPlayLobby3Impl_CreateCompoundAddress(IDirectPlayLobby3 *iface, const DPCOMPOUNDADDRESSELEMENT *lpElements, DWORD dwElementCount, void *lpAddress, DWORD *lpdwAddressSize)
Definition: dplobby.c:1645
static HRESULT WINAPI IDirectPlayLobbyImpl_SetConnectionSettings(IDirectPlayLobby *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1524
static HRESULT WINAPI IDirectPlayLobbyImpl_ReceiveLobbyMessage(IDirectPlayLobby *iface, DWORD flags, DWORD appid, DWORD *msgflags, void *data, DWORD *size)
Definition: dplobby.c:1073
static HRESULT WINAPI IDirectPlayLobby2AImpl_RunApplication(IDirectPlayLobby2A *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1278
static HRESULT WINAPI IDirectPlayLobby3AImpl_RunApplication(IDirectPlayLobby3A *iface, DWORD dwFlags, DWORD *lpdwAppID, DPLCONNECTION *lpConn, HANDLE hReceiveEvent)
Definition: dplobby.c:1294
static ULONG WINAPI IDirectPlayLobby2AImpl_AddRef(IDirectPlayLobby2A *iface)
Definition: dplobby.c:235
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 IDirectPlayLobbyImpl * impl_from_IDirectPlayLobby3(IDirectPlayLobby3 *iface)
Definition: dplobby.c:102
static HRESULT WINAPI IDirectPlayLobby2Impl_EnumAddress(IDirectPlayLobby2 *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:612
static HRESULT WINAPI IDirectPlayLobbyImpl_EnumAddress(IDirectPlayLobby *iface, LPDPENUMADDRESSCALLBACK enumaddrcb, const void *address, DWORD size, void *context)
Definition: dplobby.c:596
static ULONG WINAPI IDirectPlayLobbyAImpl_AddRef(IDirectPlayLobbyA *iface)
Definition: dplobby.c:209
static HRESULT WINAPI IDirectPlayLobbyAImpl_SetConnectionSettings(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1516
static HRESULT WINAPI IDirectPlayLobbyAImpl_QueryInterface(IDirectPlayLobbyA *iface, REFIID riid, void **ppv)
Definition: dplobby.c:123
static HRESULT WINAPI IDirectPlayLobby2Impl_QueryInterface(IDirectPlayLobby2 *iface, REFIID riid, void **ppv)
Definition: dplobby.c:144
static HRESULT WINAPI IDirectPlayLobby3AImpl_Connect(IDirectPlayLobby3A *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:480
static HRESULT WINAPI IDirectPlayLobbyImpl_EnumLocalApplications(IDirectPlayLobby *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK enumlocalappcb, void *context, DWORD flags)
Definition: dplobby.c:864
static HRESULT WINAPI IDirectPlayLobby2Impl_SendLobbyMessage(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1457
static HRESULT WINAPI IDirectPlayLobby2Impl_SetLobbyMessageEvent(IDirectPlayLobby2 *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1605
static HRESULT WINAPI IDirectPlayLobby3AImpl_EnumAddress(IDirectPlayLobby3A *iface, LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, const void *lpAddress, DWORD dwAddressSize, void *lpContext)
Definition: dplobby.c:620
static HRESULT WINAPI IDirectPlayLobby3Impl_SendLobbyMessage(IDirectPlayLobby3 *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1472
HRESULT WINAPI DirectPlayLobbyCreateA(GUID *lpGUIDDSP, IDirectPlayLobbyA **lplpDPL, IUnknown *lpUnk, void *lpData, DWORD dwDataSize)
Definition: dplobby.c:2069
struct DPLMSG * LPDPLMSG
Definition: dplobby.c:64
static HRESULT WINAPI IDirectPlayLobby3AImpl_EnumLocalApplications(IDirectPlayLobby3A *iface, LPDPLENUMLOCALAPPLICATIONSCALLBACK lpEnumLocalAppCallback, void *lpContext, DWORD dwFlags)
Definition: dplobby.c:888
static HRESULT WINAPI IDirectPlayLobby2AImpl_SetLobbyMessageEvent(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1597
static HRESULT WINAPI IDirectPlayLobby2AImpl_Connect(IDirectPlayLobby2A *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:466
static const IDirectPlayLobby3Vtbl dpl3A_vt
Definition: dplobby.c:1980
static HRESULT WINAPI IDirectPlayLobby3Impl_RegisterApplication(IDirectPlayLobby3 *iface, DWORD flags, DPAPPLICATIONDESC *appdesc)
Definition: dplobby.c:1844
static ULONG WINAPI IDirectPlayLobby2AImpl_Release(IDirectPlayLobby2A *iface)
Definition: dplobby.c:313
static HRESULT WINAPI IDirectPlayLobby3AImpl_WaitForConnectionSettings(IDirectPlayLobby3A *iface, DWORD dwFlags)
Definition: dplobby.c:1889
static void dplobby_destroy(IDirectPlayLobbyImpl *obj)
Definition: dplobby.c:112
static BOOL DPL_CreateAndSetLobbyHandles(DWORD dwDestProcessId, HANDLE hDestProcess, LPHANDLE lphStart, LPHANDLE lphDeath, LPHANDLE lphRead)
Definition: dplobby.c:1210
static HRESULT WINAPI IDirectPlayLobby3Impl_SetLobbyMessageEvent(IDirectPlayLobby3 *iface, DWORD flags, DWORD appid, HANDLE event)
Definition: dplobby.c:1620
struct tagRunApplicationEnumStruct * lpRunApplicationEnumStruct
static HRESULT WINAPI IDirectPlayLobby2Impl_RunApplication(IDirectPlayLobby2 *iface, DWORD flags, DWORD *appid, DPLCONNECTION *conn, HANDLE event)
Definition: dplobby.c:1286
static HRESULT WINAPI IDirectPlayLobby3Impl_RunApplication(IDirectPlayLobby3 *iface, DWORD dwFlags, DWORD *lpdwAppID, DPLCONNECTION *lpConn, HANDLE hReceiveEvent)
Definition: dplobby.c:1419
static ULONG WINAPI IDirectPlayLobby2Impl_Release(IDirectPlayLobby2 *iface)
Definition: dplobby.c:326
static ULONG WINAPI IDirectPlayLobby3Impl_Release(IDirectPlayLobby3 *iface)
Definition: dplobby.c:352
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 HRESULT WINAPI IDirectPlayLobby3AImpl_SendLobbyMessage(IDirectPlayLobby3A *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1465
static HRESULT WINAPI IDirectPlayLobbyAImpl_SendLobbyMessage(IDirectPlayLobbyA *iface, DWORD flags, DWORD appid, void *data, DWORD size)
Definition: dplobby.c:1433
static HRESULT WINAPI IDirectPlayLobby2AImpl_SetConnectionSettings(IDirectPlayLobby2A *iface, DWORD flags, DWORD appid, DPLCONNECTION *conn)
Definition: dplobby.c:1532
HRESULT dplobby_create(REFIID riid, void **ppv)
Definition: dplobby.c:2026
static HRESULT WINAPI IDirectPlayLobbyImpl_Connect(IDirectPlayLobby *iface, DWORD flags, IDirectPlay2A **dp, IUnknown *unk)
Definition: dplobby.c:459
struct tagDPADDRESS DPADDRESS
#define IDirectPlayLobby_Release(p)
Definition: dplobby.h:456
#define IDirectPlayLobby_SetLobbyMessageEvent(p, a, b, c)
Definition: dplobby.h:468
#define IDirectPlayLobby_Connect(p, a, b, c)
Definition: dplobby.h:458
BOOL(CALLBACK * LPDPLENUMADDRESSTYPESCALLBACK)(REFGUID guidDataType, LPVOID lpContext, DWORD dwFlags)
Definition: dplobby.h:358
#define IDirectPlayLobby_QueryInterface(p, a, b)
Definition: dplobby.h:454
#define IDirectPlayLobby_ReceiveLobbyMessage(p, a, b, c, d, e)
Definition: dplobby.h:464
#define IDirectPlayLobby_GetConnectionSettings(p, a, b, c)
Definition: dplobby.h:463
#define IDirectPlayLobby_CreateCompoundAddress(p, a, b, c, d)
Definition: dplobby.h:470
BOOL(CALLBACK * LPDPLENUMLOCALAPPLICATIONSCALLBACK)(LPCDPLAPPINFO lpAppInfo, LPVOID lpContext, DWORD dwFlags)
Definition: dplobby.h:363
struct IDirectPlayLobby2 IDirectPlayLobby2A
Definition: dplobby.h:44
BOOL(CALLBACK * LPDPENUMADDRESSCALLBACK)(REFGUID guidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext)
Definition: dplobby.h:352
#define IDirectPlayLobby_EnumLocalApplications(p, a, b, c)
Definition: dplobby.h:462
#define IDirectPlayLobby_SendLobbyMessage(p, a, b, c, d)
Definition: dplobby.h:466
struct IDirectPlayLobby3 IDirectPlayLobby3A
Definition: dplobby.h:50
#define IDirectPlayLobby_CreateAddress(p, a, b, c, d, e, f)
Definition: dplobby.h:459
#define IDirectPlayLobby_RunApplication(p, a, b, c, d)
Definition: dplobby.h:465
#define IDirectPlayLobby_SetConnectionSettings(p, a, b, c)
Definition: dplobby.h:467
#define IDirectPlayLobby_EnumAddressTypes(p, a, b, c, d)
Definition: dplobby.h:461
#define IDirectPlayLobby_ConnectEx(p, a, b, c, d)
Definition: dplobby.h:472
#define IDirectPlayLobby_EnumAddress(p, a, b, c, d)
Definition: dplobby.h:460
struct IDirectPlayLobby IDirectPlayLobbyA
Definition: dplobby.h:38
#define DPLWAIT_CANCEL
Definition: dplobby.h:503
static unsigned char buff[32768]
Definition: fatten.c:17
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
struct _cl_event * event
Definition: glext.h:7739
GLuint address
Definition: glext.h:9393
GLbitfield flags
Definition: glext.h:7161
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define S_OK
Definition: intsafe.h:52
#define FAILED(hr)
Definition: intsafe.h:51
#define debugstr_guid
Definition: kernel32.h:35
const char * appName(const char *argv0)
Definition: loadlib.c:89
char * appid
Definition: mkisofs.c:161
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static const WCHAR sp[]
Definition: suminfo.c:287
#define KEY_READ
Definition: nt_native.h:1023
#define LPDWORD
Definition: nt_native.h:46
#define DWORD
Definition: nt_native.h:44
#define LPVOID
Definition: nt_native.h:45
long LONG
Definition: pedump.c:60
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define REFIID
Definition: guiddef.h:118
static calc_node_t temp
Definition: rpn_ieee.c:38
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
Definition: dplobby.c:61
IDirectPlayLobby2 IDirectPlayLobby2_iface
Definition: dplobby.c:70
IDirectPlayLobby IDirectPlayLobby_iface
Definition: dplobby.c:68
IDirectPlayLobby2A IDirectPlayLobby2A_iface
Definition: dplobby.c:71
CRITICAL_SECTION lock
Definition: dplobby.c:76
IDirectPlayLobby3 IDirectPlayLobby3_iface
Definition: dplobby.c:72
IDirectPlayLobbyA IDirectPlayLobbyA_iface
Definition: dplobby.c:69
IDirectPlayLobby3A IDirectPlayLobby3A_iface
Definition: dplobby.c:73
Definition: scsiwmi.h:51
LPVOID lpSecurityDescriptor
Definition: compat.h:193
DWORD cb
Definition: winbase.h:831
Definition: http.c:7252
Definition: send.c:48
GUID guidDataType
Definition: dplobby.h:252
DWORD dwDataSize
Definition: dplobby.h:253
GUID guidApplication
Definition: dplobby.h:284
LPSTR lpszAppNameA
Definition: dplobby.h:288
DWORD dwSize
Definition: dplobby.h:283
LPDPSESSIONDESC2 lpSessionDesc
Definition: dplay.h:286
DWORD dwFlags
Definition: dplay.h:285
GUID guidApplication
Definition: dplay.h:235
IDirectPlayLobbyImpl * This
Definition: dplobby.c:1119
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
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 DWORD_PTR
Definition: treelist.c:76
unsigned char * LPBYTE
Definition: typedefs.h:53
uint16_t * LPWORD
Definition: typedefs.h:56
uint32_t * LPDWORD
Definition: typedefs.h:59
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define ZeroMemory
Definition: winbase.h:1712
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
DWORD WINAPI GetCurrentProcessId(void)
Definition: proc.c:1158
#define CopyMemory
Definition: winbase.h:1710
#define CREATE_DEFAULT_ERROR_MODE
Definition: winbase.h:194
#define CREATE_SUSPENDED
Definition: winbase.h:178
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define CREATE_NEW_CONSOLE
Definition: winbase.h:180
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
CONST void * LPCVOID
Definition: windef.h:191
#define WINAPI
Definition: msvc.h:6
#define E_NOINTERFACE
Definition: winerror.h:2364
#define CLASS_E_NOAGGREGATION
Definition: winerror.h:2662
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define DUPLICATE_SAME_ACCESS
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193