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