source: trunk/src/DPlayX/dplayx.cpp@ 943

Last change on this file since 943 was 943, checked in by phaller, 26 years ago

.
File size: 76.8 KB
Line 
1/* $Id: dplayx.cpp,v 1.2 1999-09-15 17:27:23 phaller Exp $ */
2
3/* Direct Play 3 and Direct Play Lobby 2 Implementation
4 *
5 * Copyright 1998,1999 - Peter Hunnisett
6 *
7 * <presently under construction - contact hunnise@nortelnetworks.com>
8 *
9 */
10#include <string.h>
11
12#include <odin.h>
13#define ICOM_CINTERFACE 1
14#define CINTERFACE
15
16#include "winerror.h"
17#include "winnt.h"
18#include "winreg.h"
19#include "dplay.h"
20#include "dplobby.h"
21#include "heap.h"
22#include "debugtools.h"
23
24#include <misc.h>
25#include <heapstring.h>
26
27DEFAULT_DEBUG_CHANNEL(dplay)
28
29/*****************************************************************************
30 * Predeclare the interface implementation structures
31 */
32typedef struct IDirectPlayLobbyImpl IDirectPlayLobbyImpl;
33typedef struct IDirectPlayLobbyImpl IDirectPlayLobbyAImpl;
34typedef struct IDirectPlayLobbyImpl IDirectPlayLobbyWImpl;
35typedef struct IDirectPlayLobby2Impl IDirectPlayLobby2Impl;
36typedef struct IDirectPlayLobby2Impl IDirectPlayLobby2AImpl;
37typedef struct IDirectPlay2Impl IDirectPlay2Impl;
38typedef struct IDirectPlay2Impl IDirectPlay2AImpl;
39typedef struct IDirectPlay3Impl IDirectPlay3Impl;
40typedef struct IDirectPlay3Impl IDirectPlay3AImpl;
41
42/*****************************************************************************
43 * IDirectPlayLobby implementation structure
44 */
45struct IDirectPlayLobbyImpl
46{
47 /* IUnknown fields */
48 ICOM_VTABLE(IDirectPlayLobby)* lpvtbl;
49 DWORD ref;
50 /* IDirectPlayLobbyImpl fields */
51 DWORD dwConnFlags;
52 DPSESSIONDESC2 sessionDesc;
53 DPNAME playerName;
54 GUID guidSP;
55 LPVOID lpAddress;
56 DWORD dwAddressSize;
57};
58
59/*****************************************************************************
60 * IDirectPlayLobby2 implementation structure
61 */
62struct IDirectPlayLobby2Impl
63{
64 /* IUnknown fields */
65 ICOM_VTABLE(IDirectPlayLobby2)* lpvtbl;
66 DWORD ref;
67 /* IDirectPlayLobby2Impl fields */
68 DWORD dwConnFlags;
69 DPSESSIONDESC2 lpSessionDesc;
70 DPNAME lpPlayerName;
71 GUID guidSP;
72 LPVOID lpAddress;
73 DWORD dwAddressSize;
74};
75
76/*****************************************************************************
77 * IDirectPlay2 implementation structure
78 */
79struct IDirectPlay2Impl
80{
81 /* IUnknown fields */
82 ICOM_VTABLE(IDirectPlay2)* lpvtbl;
83 DWORD ref;
84 /* IDirectPlay2Impl fields */
85 /* none */
86};
87
88/*****************************************************************************
89 * IDirectPlay3 implementation structure
90 */
91struct IDirectPlay3Impl
92{
93 /* IUnknown fields */
94 ICOM_VTABLE(IDirectPlay3)* lpvtbl;
95 DWORD ref;
96 /* IDirectPlay3Impl fields */
97 /* none */
98};
99
100/* Forward declarations of virtual tables */
101extern ICOM_VTABLE(IDirectPlayLobby) directPlayLobbyAVT;
102extern ICOM_VTABLE(IDirectPlayLobby) directPlayLobbyWVT;
103extern ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2AVT;
104extern ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2WVT;
105extern ICOM_VTABLE(IDirectPlay2) directPlay2WVT;
106extern ICOM_VTABLE(IDirectPlay2) directPlay2AVT;
107extern ICOM_VTABLE(IDirectPlay3) directPlay3WVT;
108extern ICOM_VTABLE(IDirectPlay3) directPlay3AVT;
109
110
111
112
113/* Routine called when starting up the server thread */
114DWORD DPLobby_Spawn_Server( LPVOID startData )
115{
116 DPSESSIONDESC2* lpSession = (DPSESSIONDESC2*) startData;
117 DWORD sessionDwFlags = lpSession->dwFlags;
118
119 TRACE("spawing thread for lpConn=%p dwFlags=%08lx\n", lpSession, sessionDwFlags );
120 FIXME("thread needs something to do\n" );
121
122/*for(;;)*/
123 {
124
125 /* Check out the connection flags to determine what to do. Ensure we have
126 no leftover bits in this structure */
127 if( sessionDwFlags & DPSESSION_CLIENTSERVER )
128 {
129 /* This indicates that the application which is requesting the creation
130 * of this session is going to be the server (application/player)
131 */
132 if( sessionDwFlags & DPSESSION_SECURESERVER )
133 {
134 sessionDwFlags &= ~DPSESSION_SECURESERVER;
135 }
136 sessionDwFlags &= ~DPSESSION_CLIENTSERVER;
137 }
138
139 if( sessionDwFlags & DPSESSION_JOINDISABLED )
140 {
141 sessionDwFlags &= ~DPSESSION_JOINDISABLED;
142 }
143
144 if( sessionDwFlags & DPSESSION_KEEPALIVE )
145 {
146 sessionDwFlags &= ~DPSESSION_KEEPALIVE;
147 }
148
149 if( sessionDwFlags & DPSESSION_MIGRATEHOST )
150 {
151 sessionDwFlags &= ~DPSESSION_MIGRATEHOST;
152 }
153
154 if( sessionDwFlags & DPSESSION_MULTICASTSERVER )
155 {
156 sessionDwFlags &= ~DPSESSION_MULTICASTSERVER;
157 }
158
159 if( sessionDwFlags & DPSESSION_NEWPLAYERSDISABLED )
160 {
161 sessionDwFlags &= ~DPSESSION_NEWPLAYERSDISABLED;
162 }
163
164 if( sessionDwFlags & DPSESSION_NODATAMESSAGES )
165 {
166 sessionDwFlags &= ~DPSESSION_NODATAMESSAGES;
167 }
168
169 if( sessionDwFlags & DPSESSION_NOMESSAGEID )
170 {
171 sessionDwFlags &= ~DPSESSION_NOMESSAGEID;
172 }
173
174 if( sessionDwFlags & DPSESSION_PASSWORDREQUIRED )
175 {
176 sessionDwFlags &= ~DPSESSION_PASSWORDREQUIRED;
177 }
178
179 }
180
181 ExitThread(0);
182 return 0;
183}
184
185
186/*********************************************************
187 *
188 * Direct Play and Direct Play Lobby Interface Implementation
189 *
190 *********************************************************/
191
192/* The COM interface for upversioning an interface
193 * We've been given a GUID (riid) and we need to replace the present
194 * interface with that of the requested interface.
195 *
196 * Snip from some Microsoft document:
197 * There are four requirements for implementations of QueryInterface (In these
198 * cases, "must succeed" means "must succeed barring catastrophic failure."):
199 *
200 * * The set of interfaces accessible on an object through
201 * IUnknown::QueryInterface must be static, not dynamic. This means that
202 * if a call to QueryInterface for a pointer to a specified interface
203 * succeeds the first time, it must succeed again, and if it fails the
204 * first time, it must fail on all subsequent queries.
205 * * It must be symmetric ~W if a client holds a pointer to an interface on
206 * an object, and queries for that interface, the call must succeed.
207 * * It must be reflexive ~W if a client holding a pointer to one interface
208 * queries successfully for another, a query through the obtained pointer
209 * for the first interface must succeed.
210 * * It must be transitive ~W if a client holding a pointer to one interface
211 * queries successfully for a second, and through that pointer queries
212 * successfully for a third interface, a query for the first interface
213 * through the pointer for the third interface must succeed.
214 *
215 * As you can see, this interface doesn't qualify but will most likely
216 * be good enough for the time being.
217 */
218
219/* Helper function for DirectPlayLobby QueryInterface */
220static HRESULT directPlayLobby_QueryInterface
221 ( REFIID riid, LPVOID* ppvObj )
222{
223
224 if( IsEqualGUID( &IID_IDirectPlayLobby, riid ) )
225 {
226 IDirectPlayLobbyImpl* lpDpL = (IDirectPlayLobbyImpl*)(*ppvObj);
227
228 lpDpL = (IDirectPlayLobbyImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
229 sizeof( *lpDpL ) );
230
231 if( !lpDpL )
232 {
233 return E_NOINTERFACE;
234 }
235
236 lpDpL->lpvtbl = &directPlayLobbyWVT;
237 lpDpL->ref = 1;
238
239 return S_OK;
240 }
241 else if( IsEqualGUID( &IID_IDirectPlayLobbyA, riid ) )
242 {
243 IDirectPlayLobbyAImpl* lpDpL = (IDirectPlayLobbyAImpl*)(*ppvObj);
244
245 lpDpL = (IDirectPlayLobbyAImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
246 sizeof( *lpDpL ) );
247
248 if( !lpDpL )
249 {
250 return E_NOINTERFACE;
251 }
252
253 lpDpL->lpvtbl = &directPlayLobbyAVT;
254 lpDpL->ref = 1;
255
256 return S_OK;
257 }
258 else if( IsEqualGUID( &IID_IDirectPlayLobby2, riid ) )
259 {
260 IDirectPlayLobby2Impl* lpDpL = (IDirectPlayLobby2Impl*)(*ppvObj);
261
262 lpDpL = (IDirectPlayLobby2Impl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
263 sizeof( *lpDpL ) );
264
265 if( !lpDpL )
266 {
267 return E_NOINTERFACE;
268 }
269
270 lpDpL->lpvtbl = &directPlayLobby2WVT;
271 lpDpL->ref = 1;
272
273 return S_OK;
274 }
275 else if( IsEqualGUID( &IID_IDirectPlayLobby2A, riid ) )
276 {
277 IDirectPlayLobby2AImpl* lpDpL = (IDirectPlayLobby2AImpl*)(*ppvObj);
278
279 lpDpL = (IDirectPlayLobby2AImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
280 sizeof( *lpDpL ) );
281
282 if( !lpDpL )
283 {
284 return E_NOINTERFACE;
285 }
286
287 lpDpL->lpvtbl = &directPlayLobby2AVT;
288 lpDpL->ref = 1;
289
290 return S_OK;
291 }
292
293 /* Unknown interface */
294 *ppvObj = NULL;
295 return E_NOINTERFACE;
296}
297static HRESULT WINAPI IDirectPlayLobbyAImpl_QueryInterface
298( LPDIRECTPLAYLOBBYA iface,
299 REFIID riid,
300 LPVOID* ppvObj )
301{
302 ICOM_THIS(IDirectPlayLobby2Impl,iface);
303 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
304
305 if( IsEqualGUID( &IID_IUnknown, riid ) ||
306 IsEqualGUID( &IID_IDirectPlayLobbyA, riid )
307 )
308 {
309 IDirectPlayLobby_AddRef( iface );
310 *ppvObj = This;
311 return S_OK;
312 }
313
314 return directPlayLobby_QueryInterface( riid, ppvObj );
315
316}
317
318static HRESULT WINAPI IDirectPlayLobbyW_QueryInterface
319( LPDIRECTPLAYLOBBY iface,
320 REFIID riid,
321 LPVOID* ppvObj )
322{
323 ICOM_THIS(IDirectPlayLobbyImpl,iface);
324 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
325
326 if( IsEqualGUID( &IID_IUnknown, riid ) ||
327 IsEqualGUID( &IID_IDirectPlayLobby, riid )
328 )
329 {
330 IDirectPlayLobby_AddRef( iface );
331 *ppvObj = This;
332 return S_OK;
333 }
334
335 return directPlayLobby_QueryInterface( riid, ppvObj );
336}
337
338
339static HRESULT WINAPI IDirectPlayLobby2AImpl_QueryInterface
340( LPDIRECTPLAYLOBBY2A iface,
341 REFIID riid,
342 LPVOID* ppvObj )
343{
344 ICOM_THIS(IDirectPlayLobby2Impl,iface);
345 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
346
347 /* Compare riids. We know this object is a direct play lobby 2A object.
348 If we are asking about the same type of interface we're fine.
349 */
350 if( IsEqualGUID( &IID_IUnknown, riid ) ||
351 IsEqualGUID( &IID_IDirectPlayLobby2A, riid )
352 )
353 {
354 IDirectPlayLobby2_AddRef( iface );
355 *ppvObj = This;
356 return S_OK;
357 }
358 return directPlayLobby_QueryInterface( riid, ppvObj );
359}
360
361static HRESULT WINAPI IDirectPlayLobby2WImpl_QueryInterface
362( LPDIRECTPLAYLOBBY2 iface,
363 REFIID riid,
364 LPVOID* ppvObj )
365{
366 ICOM_THIS(IDirectPlayLobby2Impl,iface);
367
368 /* Compare riids. We know this object is a direct play lobby 2 object.
369 If we are asking about the same type of interface we're fine.
370 */
371 if( IsEqualGUID( &IID_IUnknown, riid ) ||
372 IsEqualGUID( &IID_IDirectPlayLobby2, riid )
373 )
374 {
375 IDirectPlayLobby2_AddRef( iface );
376 *ppvObj = This;
377 return S_OK;
378 }
379
380 return directPlayLobby_QueryInterface( riid, ppvObj );
381
382}
383
384/*
385 * Simple procedure. Just increment the reference count to this
386 * structure and return the new reference count.
387 */
388static ULONG WINAPI IDirectPlayLobby2AImpl_AddRef
389( LPDIRECTPLAYLOBBY2A iface )
390{
391 ICOM_THIS(IDirectPlayLobby2Impl,iface);
392 ++(This->ref);
393 TRACE("ref count now %lu\n", This->ref );
394 return (This->ref);
395}
396
397static ULONG WINAPI IDirectPlayLobby2WImpl_AddRef
398( LPDIRECTPLAYLOBBY2 iface )
399{
400 ICOM_THIS(IDirectPlayLobby2Impl,iface);
401 return IDirectPlayLobby2AImpl_AddRef( (LPDIRECTPLAYLOBBY2) This );
402}
403
404static ULONG WINAPI IDirectPlayLobbyAImpl_AddRef
405( LPDIRECTPLAYLOBBYA iface )
406{
407 return IDirectPlayLobby2AImpl_AddRef( (LPDIRECTPLAYLOBBY2A)iface );
408}
409
410
411/*
412 * Simple COM procedure. Decrease the reference count to this object.
413 * If the object no longer has any reference counts, free up the associated
414 * memory.
415 */
416static ULONG WINAPI IDirectPlayLobby2AImpl_Release
417( LPDIRECTPLAYLOBBY2A iface )
418{
419 ICOM_THIS(IDirectPlayLobby2Impl,iface);
420 TRACE("ref count decremeneted from %lu\n", This->ref );
421
422 This->ref--;
423
424 /* Deallocate if this is the last reference to the object */
425 if( !(This->ref) )
426 {
427 FIXME("memory leak\n" );
428 /* Implement memory deallocation */
429
430 HeapFree( GetProcessHeap(), 0, This );
431
432 return 0;
433 }
434
435 return This->ref;
436}
437
438static ULONG WINAPI IDirectPlayLobby2WImpl_Release
439( LPDIRECTPLAYLOBBY2 iface )
440{
441 ICOM_THIS(IDirectPlayLobby2Impl,iface);
442 return IDirectPlayLobby2AImpl_Release( (LPDIRECTPLAYLOBBY2A) This );
443}
444
445static ULONG WINAPI IDirectPlayLobbyAImpl_Release
446( LPDIRECTPLAYLOBBYA iface )
447{
448 return IDirectPlayLobby2AImpl_Release( (LPDIRECTPLAYLOBBY2A)iface );
449}
450
451
452/********************************************************************
453 *
454 * Connects an application to the session specified by the DPLCONNECTION
455 * structure currently stored with the DirectPlayLobby object.
456 *
457 * Returns a IDirectPlay interface.
458 *
459 */
460static HRESULT WINAPI IDirectPlayLobby2AImpl_Connect
461( LPDIRECTPLAYLOBBY2A iface,
462 DWORD dwFlags,
463 LPDIRECTPLAY2* lplpDP,
464 IUnknown* pUnk)
465{
466 FIXME(": dwFlags=%08lx %p %p stub\n", dwFlags, lplpDP, pUnk );
467 return DPERR_OUTOFMEMORY;
468}
469
470
471static HRESULT WINAPI IDirectPlayLobby2WImpl_Connect
472( LPDIRECTPLAYLOBBY2 iface,
473 DWORD dwFlags,
474 LPDIRECTPLAY2* lplpDP,
475 IUnknown* pUnk)
476{
477 ICOM_THIS(IDirectPlayLobby2Impl,iface);
478 LPDIRECTPLAY2* directPlay2W;
479 HRESULT createRC;
480
481 FIXME("(%p)->(%08lx,%p,%p): stub\n", This, dwFlags, lplpDP, pUnk );
482
483 if( dwFlags )
484 {
485 return DPERR_INVALIDPARAMS;
486 }
487
488 if( ( createRC = DirectPlayCreate( (LPGUID)&IID_IDirectPlayLobby2, lplpDP, pUnk ) ) != DP_OK )
489 {
490 ERR("error creating Direct Play 2W interface. Return Code = %ld.\n", createRC );
491 return createRC;
492 }
493
494 /* This should invoke IDirectPlay3::InitializeConnection IDirectPlay3::Open */
495 directPlay2W = lplpDP;
496
497
498
499
500#if 0
501 /* All the stuff below this is WRONG! */
502 if( This->lpSession->dwFlags == DPLCONNECTION_CREATESESSION )
503 {
504 DWORD threadIdSink;
505
506 /* Spawn a thread to deal with all of this and to handle the incomming requests */
507 threadIdSink = CreateThread( NULL, 0, &DPLobby_Spawn_Server,
508 (LPVOID)This->lpSession->lpConn->lpSessionDesc, 0, &threadIdSink );
509
510 }
511 else if ( This->lpSession->dwFlags == DPLCONNECTION_JOINSESSION )
512 {
513 /* Let's search for a matching session */
514 FIXME("joining session not yet supported.\n");
515 return DPERR_OUTOFMEMORY;
516 }
517 else /* Unknown type of connection request */
518 {
519 ERR(": Unknown connection request lpConn->dwFlags=%08lx\n",
520 lpConn->dwFlags );
521
522 return DPERR_OUTOFMEMORY;
523 }
524
525 /* This does the work of the following methods...
526 IDirectPlay3::InitializeConnection,
527 IDirectPlay3::EnumSessions,
528 IDirectPlay3::Open
529 */
530
531
532#endif
533
534 return DP_OK;
535
536}
537
538static HRESULT WINAPI IDirectPlayLobbyAImpl_Connect
539( LPDIRECTPLAYLOBBYA iface,
540 DWORD dwFlags,
541 LPDIRECTPLAY2* lplpDP,
542 IUnknown *pUnk)
543{
544 return IDirectPlayLobby2AImpl_Connect( (LPDIRECTPLAYLOBBY2A)iface,
545 dwFlags,
546 (LPDIRECTPLAY2*)lplpDP,
547 pUnk);
548}
549
550
551/********************************************************************
552 *
553 * Creates a DirectPlay Address, given a service provider-specific network
554 * address.
555 * Returns an address contains the globally unique identifier
556 * (GUID) of the service provider and data that the service provider can
557 * interpret as a network address.
558 *
559 */
560static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateAddress
561( LPDIRECTPLAYLOBBY2A iface,
562 REFGUID guidSP,
563 REFGUID guidDataType,
564 LPCVOID lpData,
565 DWORD dwDataSize,
566 LPVOID lpAddress,
567 LPDWORD lpdwAddressSize )
568{
569 FIXME(":stub\n");
570 return DPERR_OUTOFMEMORY;
571}
572
573static HRESULT WINAPI IDirectPlayLobby2WImpl_CreateAddress
574( LPDIRECTPLAYLOBBY2 iface,
575 REFGUID guidSP,
576 REFGUID guidDataType,
577 LPCVOID lpData,
578 DWORD dwDataSize,
579 LPVOID lpAddress,
580 LPDWORD lpdwAddressSize )
581{
582 FIXME(":stub\n");
583 return DPERR_OUTOFMEMORY;
584}
585
586static HRESULT WINAPI IDirectPlayLobbyAImpl_CreateAddress
587( LPDIRECTPLAYLOBBYA iface,
588 REFGUID guidSP,
589 REFGUID guidDataType,
590 LPCVOID lpData,
591 DWORD dwDataSize,
592 LPVOID lpAddress,
593 LPDWORD lpdwAddressSize )
594{
595 return IDirectPlayLobby2AImpl_CreateAddress( (LPDIRECTPLAYLOBBY2A)iface,
596 guidSP,
597 guidDataType,
598 lpData,
599 dwDataSize,
600 lpAddress,
601 lpdwAddressSize);
602}
603
604
605/********************************************************************
606 *
607 * Parses out chunks from the DirectPlay Address buffer by calling the
608 * given callback function, with lpContext, for each of the chunks.
609 *
610 */
611static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumAddress
612( LPDIRECTPLAYLOBBY2A iface,
613 LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
614 LPCVOID lpAddress,
615 DWORD dwAddressSize,
616 LPVOID lpContext )
617{
618 FIXME(":stub\n");
619 return DPERR_OUTOFMEMORY;
620}
621
622static HRESULT WINAPI IDirectPlayLobby2WImpl_EnumAddress
623( LPDIRECTPLAYLOBBY2 iface,
624 LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
625 LPCVOID lpAddress,
626 DWORD dwAddressSize,
627 LPVOID lpContext )
628{
629 FIXME(":stub\n");
630 return DPERR_OUTOFMEMORY;
631}
632
633static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddress
634( LPDIRECTPLAYLOBBYA iface,
635 LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
636 LPCVOID lpAddress,
637 DWORD dwAddressSize,
638 LPVOID lpContext)
639{
640 return IDirectPlayLobby2AImpl_EnumAddress( (LPDIRECTPLAYLOBBY2A)iface,
641 lpEnumAddressCallback,
642 lpAddress,
643 dwAddressSize,
644 lpContext);
645}
646
647
648/********************************************************************
649 *
650 * Enumerates all the address types that a given service provider needs to
651 * build the DirectPlay Address.
652 *
653 */
654static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumAddressTypes
655( LPDIRECTPLAYLOBBYA iface,
656 LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
657 REFGUID guidSP,
658 LPVOID lpContext,
659 DWORD dwFlags )
660{
661 FIXME(":stub\n");
662 return DPERR_OUTOFMEMORY;
663}
664
665static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumAddressTypes
666( LPDIRECTPLAYLOBBY2A iface,
667 LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
668 REFGUID guidSP,
669 LPVOID lpContext,
670 DWORD dwFlags )
671{
672 ICOM_THIS(IDirectPlayLobby2Impl,iface);
673 return IDirectPlayLobbyAImpl_EnumAddressTypes( (LPDIRECTPLAYLOBBYA)This, lpEnumAddressTypeCallback,
674 guidSP, lpContext, dwFlags );
675}
676
677static HRESULT WINAPI IDirectPlayLobby2WImpl_EnumAddressTypes
678( LPDIRECTPLAYLOBBY2 iface,
679 LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
680 REFGUID guidSP,
681 LPVOID lpContext,
682 DWORD dwFlags )
683{
684 FIXME(":stub\n");
685 return DPERR_OUTOFMEMORY;
686}
687
688/********************************************************************
689 *
690 * Enumerates what applications are registered with DirectPlay by
691 * invoking the callback function with lpContext.
692 *
693 */
694static HRESULT WINAPI IDirectPlayLobbyW_EnumLocalApplications
695( LPDIRECTPLAYLOBBY iface,
696 LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
697 LPVOID lpContext,
698 DWORD dwFlags )
699{
700 FIXME(":stub\n");
701 return DPERR_OUTOFMEMORY;
702}
703
704static HRESULT WINAPI IDirectPlayLobby2WImpl_EnumLocalApplications
705( LPDIRECTPLAYLOBBY2 iface,
706 LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
707 LPVOID lpContext,
708 DWORD dwFlags )
709{
710 ICOM_THIS(IDirectPlayLobby2Impl,iface);
711 return IDirectPlayLobbyW_EnumLocalApplications( (LPDIRECTPLAYLOBBY)This, a,
712 lpContext, dwFlags );
713}
714
715static HRESULT WINAPI IDirectPlayLobbyAImpl_EnumLocalApplications
716( LPDIRECTPLAYLOBBYA iface,
717 LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
718 LPVOID lpContext,
719 DWORD dwFlags )
720{
721 FIXME(":stub\n");
722 return DPERR_OUTOFMEMORY;
723}
724
725static HRESULT WINAPI IDirectPlayLobby2AImpl_EnumLocalApplications
726( LPDIRECTPLAYLOBBY2A iface,
727 LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
728 LPVOID lpContext,
729 DWORD dwFlags )
730{
731 ICOM_THIS(IDirectPlayLobby2Impl,iface);
732 return IDirectPlayLobbyAImpl_EnumLocalApplications( (LPDIRECTPLAYLOBBYA)This, a,
733 lpContext, dwFlags );
734}
735
736
737/********************************************************************
738 *
739 * Retrieves the DPLCONNECTION structure that contains all the information
740 * needed to start and connect an application. This was generated using
741 * either the RunApplication or SetConnectionSettings methods.
742 *
743 * NOTES: If lpData is NULL then just return lpdwDataSize. This allows
744 * the data structure to be allocated by our caller which can then
745 * call this procedure/method again with a valid data pointer.
746 */
747static HRESULT WINAPI IDirectPlayLobbyAImpl_GetConnectionSettings
748( LPDIRECTPLAYLOBBYA iface,
749 DWORD dwAppID,
750 LPVOID lpData,
751 LPDWORD lpdwDataSize )
752{
753 ICOM_THIS(IDirectPlayLobbyImpl,iface);
754 LPDPLCONNECTION lpDplConnection;
755
756 FIXME(": semi stub (%p)->(0x%08lx,%p,%p)\n", This, dwAppID, lpData, lpdwDataSize );
757
758 /* Application is requesting us to give the required size */
759 if ( !lpData )
760 {
761 /* Let's check the size of the buffer that the application has allocated */
762 if( *lpdwDataSize >= sizeof( DPLCONNECTION ) )
763 {
764 return DP_OK;
765 }
766 else
767 {
768 *lpdwDataSize = sizeof( DPLCONNECTION );
769 return DPERR_BUFFERTOOSMALL;
770 }
771 }
772
773 /* Fill in the fields - let them just use the ptrs */
774 lpDplConnection = (LPDPLCONNECTION)lpData;
775
776 /* Make sure we were given the right size */
777 if( lpDplConnection->dwSize < sizeof( DPLCONNECTION ) )
778 {
779 ERR("bad passed size 0x%08lx.\n", lpDplConnection->dwSize );
780 return DPERR_INVALIDPARAMS;
781 }
782
783 /* Copy everything we've got into here */
784 /* Need to actually store the stuff here. Check if we've already allocated each field first. */
785 lpDplConnection->dwFlags = This->dwConnFlags;
786
787 /* Copy LPDPSESSIONDESC2 struct */
788 lpDplConnection->lpSessionDesc = (tagDPSESSIONDESC2*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( This->sessionDesc ) );
789 memcpy( lpDplConnection->lpSessionDesc, &(This->sessionDesc), sizeof( This->sessionDesc ) );
790
791 if( This->sessionDesc.sess.lpszSessionName )
792 {
793 lpDplConnection->lpSessionDesc->sess.lpszSessionName =
794 HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, This->sessionDesc.sess.lpszSessionName );
795 }
796
797 if( This->sessionDesc.pass.lpszPassword )
798 {
799 lpDplConnection->lpSessionDesc->pass.lpszPassword =
800 HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, This->sessionDesc.pass.lpszPassword );
801 }
802
803 /* I don't know what to use the reserved for. We'll set it to 0 just for fun */
804 This->sessionDesc.dwReserved1 = This->sessionDesc.dwReserved2 = 0;
805
806 /* Copy DPNAME struct - seems to be optional - check for existance first */
807 lpDplConnection->lpPlayerName = (tagDPNAME*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( This->playerName ) );
808 memcpy( lpDplConnection->lpPlayerName, &(This->playerName), sizeof( This->playerName ) );
809
810 if( This->playerName.psn.lpszShortName )
811 {
812 lpDplConnection->lpPlayerName->psn.lpszShortName =
813 HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, This->playerName.psn.lpszShortName );
814 }
815
816 if( This->playerName.pln.lpszLongName )
817 {
818 lpDplConnection->lpPlayerName->pln.lpszLongName =
819 HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, This->playerName.pln.lpszLongName );
820 }
821
822
823
824 memcpy( &(lpDplConnection->guidSP), &(This->guidSP), sizeof( This->guidSP ) );
825
826 lpDplConnection->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, This->dwAddressSize );
827 memcpy( lpDplConnection->lpAddress, This->lpAddress, This->dwAddressSize );
828
829 lpDplConnection->dwAddressSize = This->dwAddressSize;
830
831 return DP_OK;
832}
833
834static HRESULT WINAPI IDirectPlayLobby2AImpl_GetConnectionSettings
835( LPDIRECTPLAYLOBBY2A iface,
836 DWORD dwAppID,
837 LPVOID lpData,
838 LPDWORD lpdwDataSize )
839{
840 ICOM_THIS(IDirectPlayLobby2Impl,iface);
841 return IDirectPlayLobbyAImpl_GetConnectionSettings( (LPDIRECTPLAYLOBBYA)This,
842 dwAppID, lpData, lpdwDataSize );
843}
844
845static HRESULT WINAPI IDirectPlayLobbyWImpl_GetConnectionSettings
846( LPDIRECTPLAYLOBBY iface,
847 DWORD dwAppID,
848 LPVOID lpData,
849 LPDWORD lpdwDataSize )
850{
851 ICOM_THIS(IDirectPlayLobbyImpl,iface);
852 FIXME(":semi stub %p %08lx %p %p \n", This, dwAppID, lpData, lpdwDataSize );
853
854 /* Application is requesting us to give the required size */
855 if ( !lpData )
856 {
857 /* Let's check the size of the buffer that the application has allocated */
858 if( *lpdwDataSize >= sizeof( DPLCONNECTION ) )
859 {
860 return DP_OK;
861 }
862 else
863 {
864 *lpdwDataSize = sizeof( DPLCONNECTION );
865 return DPERR_BUFFERTOOSMALL;
866 }
867 }
868
869 /* Fill in the fields - let them just use the ptrs */
870 FIXME("stub\n" );
871
872 return DP_OK;
873}
874
875static HRESULT WINAPI IDirectPlayLobby2WImpl_GetConnectionSettings
876( LPDIRECTPLAYLOBBY2 iface,
877 DWORD dwAppID,
878 LPVOID lpData,
879 LPDWORD lpdwDataSize )
880{
881 ICOM_THIS(IDirectPlayLobby2Impl,iface);
882 return IDirectPlayLobbyWImpl_GetConnectionSettings( (LPDIRECTPLAYLOBBY)This,
883 dwAppID, lpData, lpdwDataSize );
884}
885
886/********************************************************************
887 *
888 * Retrieves the message sent between a lobby client and a DirectPlay
889 * application. All messages are queued until received.
890 *
891 */
892static HRESULT WINAPI IDirectPlayLobbyAImpl_ReceiveLobbyMessage
893( LPDIRECTPLAYLOBBYA iface,
894 DWORD dwFlags,
895 DWORD dwAppID,
896 LPDWORD lpdwMessageFlags,
897 LPVOID lpData,
898 LPDWORD lpdwDataSize )
899{
900 ICOM_THIS(IDirectPlayLobbyImpl,iface);
901 FIXME(":stub %p %08lx %08lx %p %p %p\n", This, dwFlags, dwAppID, lpdwMessageFlags, lpData,
902 lpdwDataSize );
903 return DPERR_OUTOFMEMORY;
904}
905
906static HRESULT WINAPI IDirectPlayLobby2AImpl_ReceiveLobbyMessage
907( LPDIRECTPLAYLOBBY2A iface,
908 DWORD dwFlags,
909 DWORD dwAppID,
910 LPDWORD lpdwMessageFlags,
911 LPVOID lpData,
912 LPDWORD lpdwDataSize )
913{
914 ICOM_THIS(IDirectPlayLobby2Impl,iface);
915 return IDirectPlayLobbyAImpl_ReceiveLobbyMessage( (LPDIRECTPLAYLOBBYA)This, dwFlags, dwAppID,
916 lpdwMessageFlags, lpData, lpdwDataSize );
917}
918
919
920static HRESULT WINAPI IDirectPlayLobbyW_ReceiveLobbyMessage
921( LPDIRECTPLAYLOBBY iface,
922 DWORD dwFlags,
923 DWORD dwAppID,
924 LPDWORD lpdwMessageFlags,
925 LPVOID lpData,
926 LPDWORD lpdwDataSize )
927{
928 ICOM_THIS(IDirectPlayLobbyImpl,iface);
929 FIXME(":stub %p %08lx %08lx %p %p %p\n", This, dwFlags, dwAppID, lpdwMessageFlags, lpData,
930 lpdwDataSize );
931 return DPERR_OUTOFMEMORY;
932}
933
934static HRESULT WINAPI IDirectPlayLobby2WImpl_ReceiveLobbyMessage
935( LPDIRECTPLAYLOBBY2 iface,
936 DWORD dwFlags,
937 DWORD dwAppID,
938 LPDWORD lpdwMessageFlags,
939 LPVOID lpData,
940 LPDWORD lpdwDataSize )
941{
942 ICOM_THIS(IDirectPlayLobby2Impl,iface);
943 return IDirectPlayLobbyW_ReceiveLobbyMessage( (LPDIRECTPLAYLOBBY)This, dwFlags, dwAppID,
944 lpdwMessageFlags, lpData, lpdwDataSize );
945}
946
947/********************************************************************
948 *
949 * Starts an application and passes to it all the information to
950 * connect to a session.
951 *
952 */
953static HRESULT WINAPI IDirectPlayLobbyAImpl_RunApplication
954( LPDIRECTPLAYLOBBYA iface,
955 DWORD dwFlags,
956 LPDWORD lpdwAppID,
957 LPDPLCONNECTION lpConn,
958 HANDLE hReceiveEvent )
959{
960 FIXME(":stub\n");
961 return DPERR_OUTOFMEMORY;
962}
963
964static HRESULT WINAPI IDirectPlayLobby2AImpl_RunApplication
965( LPDIRECTPLAYLOBBY2A iface,
966 DWORD dwFlags,
967 LPDWORD lpdwAppID,
968 LPDPLCONNECTION lpConn,
969 HANDLE hReceiveEvent )
970{
971 ICOM_THIS(IDirectPlayLobby2Impl,iface);
972 return IDirectPlayLobbyAImpl_RunApplication( (LPDIRECTPLAYLOBBYA)This, dwFlags,
973 lpdwAppID, lpConn, hReceiveEvent );
974}
975
976static HRESULT WINAPI IDirectPlayLobbyW_RunApplication
977( LPDIRECTPLAYLOBBY iface,
978 DWORD dwFlags,
979 LPDWORD lpdwAppID,
980 LPDPLCONNECTION lpConn,
981 HANDLE hReceiveEvent )
982{
983 FIXME(":stub\n");
984 return DPERR_OUTOFMEMORY;
985}
986
987static HRESULT WINAPI IDirectPlayLobby2WImpl_RunApplication
988( LPDIRECTPLAYLOBBY2 iface,
989 DWORD dwFlags,
990 LPDWORD lpdwAppID,
991 LPDPLCONNECTION lpConn,
992 HANDLE hReceiveEvent )
993{
994 ICOM_THIS(IDirectPlayLobby2Impl,iface);
995 return IDirectPlayLobbyW_RunApplication( (LPDIRECTPLAYLOBBY)This, dwFlags,
996 lpdwAppID, lpConn, hReceiveEvent );
997}
998
999
1000/********************************************************************
1001 *
1002 * Sends a message between the application and the lobby client.
1003 * All messages are queued until received.
1004 *
1005 */
1006static HRESULT WINAPI IDirectPlayLobbyAImpl_SendLobbyMessage
1007( LPDIRECTPLAYLOBBYA iface,
1008 DWORD dwFlags,
1009 DWORD dwAppID,
1010 LPVOID lpData,
1011 DWORD dwDataSize )
1012{
1013 FIXME(":stub\n");
1014 return DPERR_OUTOFMEMORY;
1015}
1016
1017static HRESULT WINAPI IDirectPlayLobby2AImpl_SendLobbyMessage
1018( LPDIRECTPLAYLOBBY2A iface,
1019 DWORD dwFlags,
1020 DWORD dwAppID,
1021 LPVOID lpData,
1022 DWORD dwDataSize )
1023{
1024 ICOM_THIS(IDirectPlayLobby2Impl,iface);
1025 return IDirectPlayLobbyAImpl_SendLobbyMessage( (LPDIRECTPLAYLOBBYA)This, dwFlags,
1026 dwAppID, lpData, dwDataSize );
1027}
1028
1029
1030static HRESULT WINAPI IDirectPlayLobbyW_SendLobbyMessage
1031( LPDIRECTPLAYLOBBY iface,
1032 DWORD dwFlags,
1033 DWORD dwAppID,
1034 LPVOID lpData,
1035 DWORD dwDataSize )
1036{
1037 FIXME(":stub\n");
1038 return DPERR_OUTOFMEMORY;
1039}
1040
1041static HRESULT WINAPI IDirectPlayLobby2WImpl_SendLobbyMessage
1042( LPDIRECTPLAYLOBBY2 iface,
1043 DWORD dwFlags,
1044 DWORD dwAppID,
1045 LPVOID lpData,
1046 DWORD dwDataSize )
1047{
1048 ICOM_THIS(IDirectPlayLobby2Impl,iface);
1049 return IDirectPlayLobbyW_SendLobbyMessage( (LPDIRECTPLAYLOBBY)This, dwFlags,
1050 dwAppID, lpData, dwDataSize );
1051}
1052
1053/********************************************************************
1054 *
1055 * Modifies the DPLCONNECTION structure to contain all information
1056 * needed to start and connect an application.
1057 *
1058 */
1059static HRESULT WINAPI IDirectPlayLobbyW_SetConnectionSettings
1060( LPDIRECTPLAYLOBBY iface,
1061 DWORD dwFlags,
1062 DWORD dwAppID,
1063 LPDPLCONNECTION lpConn )
1064{
1065 ICOM_THIS(IDirectPlayLobbyImpl,iface);
1066 TRACE(": This=%p, dwFlags=%08lx, dwAppId=%08lx, lpConn=%p\n",
1067 This, dwFlags, dwAppID, lpConn );
1068
1069 /* Paramater check */
1070 if( dwFlags || !This || !lpConn )
1071 {
1072 ERR("invalid parameters.\n");
1073 return DPERR_INVALIDPARAMS;
1074 }
1075
1076 /* See if there is a connection associated with this request.
1077 * dwAppID == 0 indicates that this request isn't associated with a connection.
1078 */
1079 if( dwAppID )
1080 {
1081 FIXME(": Connection dwAppID=%08lx given. Not implemented yet.\n",
1082 dwAppID );
1083
1084 /* Need to add a check for this application Id...*/
1085 return DPERR_NOTLOBBIED;
1086 }
1087
1088 if( lpConn->dwSize != sizeof(DPLCONNECTION) )
1089 {
1090 ERR(": old/new DPLCONNECTION type? Size=%08lx vs. expected=%ul bytes\n",
1091 lpConn->dwSize, sizeof( DPLCONNECTION ) );
1092 return DPERR_INVALIDPARAMS;
1093 }
1094
1095 /* Need to investigate the lpConn->lpSessionDesc to figure out
1096 * what type of session we need to join/create.
1097 */
1098 if( (!lpConn->lpSessionDesc ) ||
1099 ( lpConn->lpSessionDesc->dwSize != sizeof( DPSESSIONDESC2 ) )
1100 )
1101 {
1102 ERR("DPSESSIONDESC passed in? Size=%08lx vs. expected=%ul bytes\n",
1103 lpConn->lpSessionDesc->dwSize, sizeof( DPSESSIONDESC2 ) );
1104 return DPERR_INVALIDPARAMS;
1105 }
1106
1107 /* Need to actually store the stuff here. Check if we've already allocated each field first. */
1108 This->dwConnFlags = lpConn->dwFlags;
1109
1110 /* Copy LPDPSESSIONDESC2 struct - this is required */
1111 memcpy( &(This->sessionDesc), lpConn->lpSessionDesc, sizeof( *(lpConn->lpSessionDesc) ) );
1112
1113 if( lpConn->lpSessionDesc->sess.lpszSessionName )
1114 This->sessionDesc.sess.lpszSessionName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->sess.lpszSessionName );
1115 else
1116 This->sessionDesc.sess.lpszSessionName = NULL;
1117
1118 if( lpConn->lpSessionDesc->pass.lpszPassword )
1119 This->sessionDesc.pass.lpszPassword = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->pass.lpszPassword );
1120 else
1121 This->sessionDesc.pass.lpszPassword = NULL;
1122
1123 /* I don't know what to use the reserved for ... */
1124 This->sessionDesc.dwReserved1 = This->sessionDesc.dwReserved2 = 0;
1125
1126 /* Copy DPNAME struct - seems to be optional - check for existance first */
1127 if( lpConn->lpPlayerName )
1128 {
1129 memcpy( &(This->playerName), lpConn->lpPlayerName, sizeof( *lpConn->lpPlayerName ) );
1130
1131 if( lpConn->lpPlayerName->psn.lpszShortName )
1132 This->playerName.psn.lpszShortName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->psn.lpszShortName );
1133
1134 if( lpConn->lpPlayerName->pln.lpszLongName )
1135 This->playerName.pln.lpszLongName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->pln.lpszLongName );
1136
1137 }
1138
1139 memcpy( &(This->guidSP), &(lpConn->guidSP), sizeof( lpConn->guidSP ) );
1140
1141 This->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->dwAddressSize );
1142 memcpy( This->lpAddress, lpConn->lpAddress, lpConn->dwAddressSize );
1143
1144 This->dwAddressSize = lpConn->dwAddressSize;
1145
1146 return DP_OK;
1147}
1148
1149static HRESULT WINAPI IDirectPlayLobby2WImpl_SetConnectionSettings
1150( LPDIRECTPLAYLOBBY2 iface,
1151 DWORD dwFlags,
1152 DWORD dwAppID,
1153 LPDPLCONNECTION lpConn )
1154{
1155 ICOM_THIS(IDirectPlayLobby2Impl,iface);
1156 return IDirectPlayLobbyW_SetConnectionSettings( (LPDIRECTPLAYLOBBY)This,
1157 dwFlags, dwAppID, lpConn );
1158}
1159
1160static HRESULT WINAPI IDirectPlayLobbyAImpl_SetConnectionSettings
1161( LPDIRECTPLAYLOBBYA iface,
1162 DWORD dwFlags,
1163 DWORD dwAppID,
1164 LPDPLCONNECTION lpConn )
1165{
1166 ICOM_THIS(IDirectPlayLobbyImpl,iface);
1167 FIXME(": This=%p, dwFlags=%08lx, dwAppId=%08lx, lpConn=%p: stub\n",
1168 This, dwFlags, dwAppID, lpConn );
1169 return DPERR_OUTOFMEMORY;
1170}
1171
1172static HRESULT WINAPI IDirectPlayLobby2AImpl_SetConnectionSettings
1173( LPDIRECTPLAYLOBBY2A iface,
1174 DWORD dwFlags,
1175 DWORD dwAppID,
1176 LPDPLCONNECTION lpConn )
1177{
1178 ICOM_THIS(IDirectPlayLobby2Impl,iface);
1179 return IDirectPlayLobbyAImpl_SetConnectionSettings( (LPDIRECTPLAYLOBBYA)This,
1180 dwFlags, dwAppID, lpConn );
1181}
1182
1183/********************************************************************
1184 *
1185 * Registers an event that will be set when a lobby message is received.
1186 *
1187 */
1188static HRESULT WINAPI IDirectPlayLobbyAImpl_SetLobbyMessageEvent
1189( LPDIRECTPLAYLOBBYA iface,
1190 DWORD dwFlags,
1191 DWORD dwAppID,
1192 HANDLE hReceiveEvent )
1193{
1194 FIXME(":stub\n");
1195 return DPERR_OUTOFMEMORY;
1196}
1197
1198static HRESULT WINAPI IDirectPlayLobby2AImpl_SetLobbyMessageEvent
1199( LPDIRECTPLAYLOBBY2A iface,
1200 DWORD dwFlags,
1201 DWORD dwAppID,
1202 HANDLE hReceiveEvent )
1203{
1204 ICOM_THIS(IDirectPlayLobby2Impl,iface);
1205 return IDirectPlayLobbyAImpl_SetLobbyMessageEvent( (LPDIRECTPLAYLOBBYA)This, dwFlags,
1206 dwAppID, hReceiveEvent );
1207}
1208
1209static HRESULT WINAPI IDirectPlayLobbyW_SetLobbyMessageEvent
1210( LPDIRECTPLAYLOBBY iface,
1211 DWORD dwFlags,
1212 DWORD dwAppID,
1213 HANDLE hReceiveEvent )
1214{
1215 FIXME(":stub\n");
1216 return DPERR_OUTOFMEMORY;
1217}
1218
1219static HRESULT WINAPI IDirectPlayLobby2WImpl_SetLobbyMessageEvent
1220( LPDIRECTPLAYLOBBY2 iface,
1221 DWORD dwFlags,
1222 DWORD dwAppID,
1223 HANDLE hReceiveEvent )
1224{
1225 ICOM_THIS(IDirectPlayLobby2Impl,iface);
1226 return IDirectPlayLobbyW_SetLobbyMessageEvent( (LPDIRECTPLAYLOBBY)This, dwFlags,
1227 dwAppID, hReceiveEvent );
1228}
1229
1230
1231/********************************************************************
1232 *
1233 * Registers an event that will be set when a lobby message is received.
1234 *
1235 */
1236static HRESULT WINAPI IDirectPlayLobby2WImpl_CreateCompoundAddress
1237( LPDIRECTPLAYLOBBY2 iface,
1238 LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1239 DWORD dwElementCount,
1240 LPVOID lpAddress,
1241 LPDWORD lpdwAddressSize )
1242{
1243 FIXME(":stub\n");
1244 return DPERR_OUTOFMEMORY;
1245}
1246
1247static HRESULT WINAPI IDirectPlayLobby2AImpl_CreateCompoundAddress
1248( LPDIRECTPLAYLOBBY2A iface,
1249 LPCDPCOMPOUNDADDRESSELEMENT lpElements,
1250 DWORD dwElementCount,
1251 LPVOID lpAddress,
1252 LPDWORD lpdwAddressSize )
1253{
1254 FIXME(":stub\n");
1255 return DPERR_OUTOFMEMORY;
1256}
1257
1258
1259/* Direct Play Lobby 1 (ascii) Virtual Table for methods */
1260/* All lobby 1 methods are exactly the same except QueryInterface */
1261
1262
1263struct ICOM_VTABLE(IDirectPlayLobby) directPlayLobbyAVT =
1264{
1265 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1266 IDirectPlayLobbyAImpl_QueryInterface,
1267 IDirectPlayLobbyAImpl_AddRef,
1268 IDirectPlayLobbyAImpl_Release,
1269 IDirectPlayLobbyAImpl_Connect,
1270 IDirectPlayLobbyAImpl_CreateAddress,
1271 IDirectPlayLobbyAImpl_EnumAddress,
1272 IDirectPlayLobbyAImpl_EnumAddressTypes,
1273 IDirectPlayLobbyAImpl_EnumLocalApplications,
1274 IDirectPlayLobbyAImpl_GetConnectionSettings,
1275 IDirectPlayLobbyAImpl_ReceiveLobbyMessage,
1276 IDirectPlayLobbyAImpl_RunApplication,
1277 IDirectPlayLobbyAImpl_SendLobbyMessage,
1278 IDirectPlayLobbyAImpl_SetConnectionSettings,
1279 IDirectPlayLobbyAImpl_SetLobbyMessageEvent
1280};
1281
1282
1283/* Direct Play Lobby 1 (unicode) Virtual Table for methods */
1284ICOM_VTABLE(IDirectPlayLobby) directPlayLobbyWVT =
1285{
1286 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1287 IDirectPlayLobbyW_QueryInterface,
1288 IDirectPlayLobbyAImpl_AddRef,
1289 IDirectPlayLobbyAImpl_Release,
1290 IDirectPlayLobbyAImpl_Connect,
1291 IDirectPlayLobbyAImpl_CreateAddress,
1292 IDirectPlayLobbyAImpl_EnumAddress,
1293 IDirectPlayLobbyAImpl_EnumAddressTypes,
1294 IDirectPlayLobbyAImpl_EnumLocalApplications,
1295 IDirectPlayLobbyWImpl_GetConnectionSettings,
1296 IDirectPlayLobbyAImpl_ReceiveLobbyMessage,
1297 IDirectPlayLobbyAImpl_RunApplication,
1298 IDirectPlayLobbyAImpl_SendLobbyMessage,
1299 IDirectPlayLobbyAImpl_SetConnectionSettings,
1300 IDirectPlayLobbyAImpl_SetLobbyMessageEvent
1301};
1302
1303
1304/* Direct Play Lobby 2 (ascii) Virtual Table for methods */
1305ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2AVT =
1306{
1307 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1308 IDirectPlayLobby2AImpl_QueryInterface,
1309 IDirectPlayLobby2AImpl_AddRef,
1310 IDirectPlayLobby2AImpl_Release,
1311 IDirectPlayLobby2AImpl_Connect,
1312 IDirectPlayLobby2AImpl_CreateAddress,
1313 IDirectPlayLobby2AImpl_EnumAddress,
1314 IDirectPlayLobby2AImpl_EnumAddressTypes,
1315 IDirectPlayLobby2AImpl_EnumLocalApplications,
1316 IDirectPlayLobby2AImpl_GetConnectionSettings,
1317 IDirectPlayLobby2AImpl_ReceiveLobbyMessage,
1318 IDirectPlayLobby2AImpl_RunApplication,
1319 IDirectPlayLobby2AImpl_SendLobbyMessage,
1320 IDirectPlayLobby2AImpl_SetConnectionSettings,
1321 IDirectPlayLobby2AImpl_SetLobbyMessageEvent,
1322 IDirectPlayLobby2AImpl_CreateCompoundAddress
1323};
1324
1325/* Direct Play Lobby 2 (unicode) Virtual Table for methods */
1326ICOM_VTABLE(IDirectPlayLobby2) directPlayLobby2WVT =
1327{
1328 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1329 IDirectPlayLobby2WImpl_QueryInterface,
1330 IDirectPlayLobby2WImpl_AddRef,
1331 IDirectPlayLobby2WImpl_Release,
1332 IDirectPlayLobby2WImpl_Connect,
1333 IDirectPlayLobby2WImpl_CreateAddress,
1334 IDirectPlayLobby2WImpl_EnumAddress,
1335 IDirectPlayLobby2WImpl_EnumAddressTypes,
1336 IDirectPlayLobby2WImpl_EnumLocalApplications,
1337 IDirectPlayLobby2WImpl_GetConnectionSettings,
1338 IDirectPlayLobby2WImpl_ReceiveLobbyMessage,
1339 IDirectPlayLobby2WImpl_RunApplication,
1340 IDirectPlayLobby2WImpl_SendLobbyMessage,
1341 IDirectPlayLobby2WImpl_SetConnectionSettings,
1342 IDirectPlayLobby2WImpl_SetLobbyMessageEvent,
1343 IDirectPlayLobby2WImpl_CreateCompoundAddress
1344};
1345
1346/***************************************************************************
1347 * DirectPlayLobbyCreateA (DPLAYX.4)
1348 *
1349 */
1350HRESULT WINAPI DirectPlayLobbyCreateA( LPGUID lpGUIDDSP,
1351 LPDIRECTPLAYLOBBYA *lplpDPL,
1352 IUnknown *lpUnk,
1353 LPVOID lpData,
1354 DWORD dwDataSize )
1355{
1356 IDirectPlayLobbyAImpl** ilplpDPL=(IDirectPlayLobbyAImpl**)lplpDPL;
1357 TRACE("lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
1358 lpGUIDDSP,ilplpDPL,lpUnk,lpData,dwDataSize);
1359
1360 /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
1361 * equal 0. These fields are mostly for future expansion.
1362 */
1363 if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
1364 {
1365 *ilplpDPL = NULL;
1366 return DPERR_INVALIDPARAMS;
1367 }
1368
1369 /* Yes...really we should be returning a lobby 1 object */
1370 *ilplpDPL = (IDirectPlayLobbyAImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1371 sizeof( IDirectPlayLobbyAImpl ) );
1372
1373 if( ! (*ilplpDPL) )
1374 {
1375 return DPERR_OUTOFMEMORY;
1376 }
1377
1378 (*ilplpDPL)->lpvtbl = &directPlayLobbyAVT;
1379 (*ilplpDPL)->ref = 1;
1380
1381 /* All fields were nulled out by the allocation */
1382
1383 return DP_OK;
1384}
1385
1386/***************************************************************************
1387 * DirectPlayLobbyCreateW (DPLAYX.5)
1388 *
1389 */
1390HRESULT WINAPI DirectPlayLobbyCreateW( LPGUID lpGUIDDSP,
1391 LPDIRECTPLAYLOBBY *lplpDPL,
1392 IUnknown *lpUnk,
1393 LPVOID lpData,
1394 DWORD dwDataSize )
1395{
1396 IDirectPlayLobbyImpl** ilplpDPL=(IDirectPlayLobbyImpl**)lplpDPL;
1397 TRACE("lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
1398 lpGUIDDSP,ilplpDPL,lpUnk,lpData,dwDataSize);
1399
1400 /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
1401 * equal 0. These fields are mostly for future expansion.
1402 */
1403 if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
1404 {
1405 *ilplpDPL = NULL;
1406 ERR("Bad parameters!\n" );
1407 return DPERR_INVALIDPARAMS;
1408 }
1409
1410 /* Yes...really we should bre returning a lobby 1 object */
1411 *ilplpDPL = (IDirectPlayLobbyImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1412 sizeof( IDirectPlayLobbyImpl ) );
1413
1414 if( !*ilplpDPL)
1415 {
1416 return DPERR_OUTOFMEMORY;
1417 }
1418
1419 (*ilplpDPL)->lpvtbl = &directPlayLobbyWVT;
1420 (*ilplpDPL)->ref = 1;
1421
1422 /* All fields were nulled out by the allocation */
1423
1424 return DP_OK;
1425
1426}
1427
1428/***************************************************************************
1429 * DirectPlayEnumerateA (DPLAYX.2)
1430 *
1431 * The pointer to the structure lpContext will be filled with the
1432 * appropriate data for each service offered by the OS. These services are
1433 * not necessarily available on this particular machine but are defined
1434 * as simple service providers under the "Service Providers" registry key.
1435 * This structure is then passed to lpEnumCallback for each of the different
1436 * services.
1437 *
1438 * This API is useful only for applications written using DirectX3 or
1439 * worse. It is superceeded by IDirectPlay3::EnumConnections which also
1440 * gives information on the actual connections.
1441 *
1442 * defn of a service provider:
1443 * A dynamic-link library used by DirectPlay to communicate over a network.
1444 * The service provider contains all the network-specific code required
1445 * to send and receive messages. Online services and network operators can
1446 * supply service providers to use specialized hardware, protocols, communications
1447 * media, and network resources.
1448 *
1449 * TODO: Allocate string buffer space from the heap (length from reg)
1450 * Pass real device driver numbers...
1451 * Get the GUID properly...
1452 */
1453HRESULT WINAPI DirectPlayEnumerateA( LPDPENUMDPCALLBACKA lpEnumCallback,
1454 LPVOID lpContext )
1455{
1456
1457 HKEY hkResult;
1458 LPCSTR searchSubKey = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
1459 LPSTR guidDataSubKey = "Guid";
1460 LPSTR majVerDataSubKey = "dwReserved1";
1461 DWORD dwIndex, sizeOfSubKeyName=50;
1462 char subKeyName[51];
1463
1464 TRACE(": lpEnumCallback=%p lpContext=%p\n", lpEnumCallback, lpContext );
1465
1466 if( !lpEnumCallback )
1467 {
1468 return DPERR_INVALIDPARAMS;
1469 }
1470
1471 /* Need to loop over the service providers in the registry */
1472 if( RegOpenKeyExA( HKEY_LOCAL_MACHINE, searchSubKey,
1473 0, KEY_ENUMERATE_SUB_KEYS, &hkResult ) != ERROR_SUCCESS )
1474 {
1475 /* Hmmm. Does this mean that there are no service providers? */
1476 ERR(": no service providers?\n");
1477 return DP_OK;
1478 }
1479
1480 /* Traverse all the service providers we have available */
1481 for( dwIndex=0;
1482 RegEnumKeyA( hkResult, dwIndex, subKeyName, sizeOfSubKeyName ) !=
1483 ERROR_NO_MORE_ITEMS;
1484 ++dwIndex )
1485 {
1486 HKEY hkServiceProvider;
1487 GUID serviceProviderGUID;
1488 DWORD returnTypeGUID, returnTypeReserved1, sizeOfReturnBuffer=50;
1489 char returnBuffer[51];
1490 DWORD majVersionNum /*, minVersionNum */;
1491 LPWSTR lpWGUIDString;
1492
1493 TRACE(" this time through: %s\n", subKeyName );
1494
1495 /* Get a handle for this particular service provider */
1496 if( RegOpenKeyExA( hkResult, subKeyName, 0, KEY_QUERY_VALUE,
1497 &hkServiceProvider ) != ERROR_SUCCESS )
1498 {
1499 ERR(": what the heck is going on?\n" );
1500 continue;
1501 }
1502
1503 /* Get the GUID, Device major number and device minor number
1504 * from the registry.
1505 */
1506 if( RegQueryValueExA( hkServiceProvider, guidDataSubKey,
1507 NULL, &returnTypeGUID, (LPBYTE)returnBuffer,
1508 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1509 {
1510 ERR(": missing GUID registry data members\n" );
1511 continue;
1512 }
1513
1514 /* FIXME: Check return types to ensure we're interpreting data right */
1515 lpWGUIDString = HEAP_strdupAtoW( GetProcessHeap(), 0, returnBuffer );
1516 CLSIDFromString( (LPCOLESTR)lpWGUIDString, &serviceProviderGUID );
1517 HeapFree( GetProcessHeap(), 0, lpWGUIDString );
1518
1519 sizeOfReturnBuffer = 50;
1520
1521 if( RegQueryValueExA( hkServiceProvider, majVerDataSubKey,
1522 NULL, &returnTypeReserved1, (LPBYTE)returnBuffer,
1523 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
1524 {
1525 ERR(": missing dwReserved1 registry data members\n") ;
1526 continue;
1527 }
1528 /* FIXME: This couldn't possibly be right...*/
1529 majVersionNum = GET_DWORD( returnBuffer );
1530
1531 /* The enumeration will return FALSE if we are not to continue */
1532 if( !lpEnumCallback( &serviceProviderGUID , subKeyName,
1533 majVersionNum, (DWORD)0, lpContext ) )
1534 {
1535 WARN("lpEnumCallback returning FALSE\n" );
1536 break;
1537 }
1538 }
1539
1540 return DP_OK;
1541
1542}
1543
1544/***************************************************************************
1545 * DirectPlayEnumerateW (DPLAYX.3)
1546 *
1547 */
1548HRESULT WINAPI DirectPlayEnumerateW( LPDPENUMDPCALLBACKW lpEnumCallback, LPVOID lpContext )
1549{
1550
1551 FIXME(":stub\n");
1552
1553 return DPERR_OUTOFMEMORY;
1554
1555}
1556
1557/***************************************************************************
1558 * DirectPlayCreate (DPLAYX.1) (DPLAY.1)
1559 *
1560 */
1561HRESULT WINAPI DirectPlayCreate
1562( LPGUID lpGUID, LPDIRECTPLAY2 *lplpDP, IUnknown *pUnk)
1563{
1564
1565 TRACE("lpGUID=%p lplpDP=%p pUnk=%p\n", lpGUID,lplpDP,pUnk);
1566
1567 if( pUnk != NULL )
1568 {
1569 /* Hmmm...wonder what this means! */
1570 ERR("What does a NULL here mean?\n" );
1571 return DPERR_OUTOFMEMORY;
1572 }
1573
1574 if( IsEqualGUID( &IID_IDirectPlay2A, lpGUID ) )
1575 {
1576 IDirectPlay2AImpl** ilplpDP=(IDirectPlay2AImpl**)lplpDP;
1577 *ilplpDP = (IDirectPlay2AImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1578 sizeof( **ilplpDP ) );
1579
1580 if( !*ilplpDP )
1581 {
1582 return DPERR_OUTOFMEMORY;
1583 }
1584
1585 (*ilplpDP)->lpvtbl = &directPlay2AVT;
1586 (*ilplpDP)->ref = 1;
1587
1588 return DP_OK;
1589 }
1590 else if( IsEqualGUID( &IID_IDirectPlay2, lpGUID ) )
1591 {
1592 IDirectPlay2Impl** ilplpDP=(IDirectPlay2Impl**)lplpDP;
1593 *ilplpDP = (IDirectPlay2Impl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1594 sizeof( **ilplpDP ) );
1595
1596 if( !*ilplpDP )
1597 {
1598 return DPERR_OUTOFMEMORY;
1599 }
1600
1601 (*ilplpDP)->lpvtbl = &directPlay2WVT;
1602 (*ilplpDP)->ref = 1;
1603
1604 return DP_OK;
1605 }
1606
1607 /* Unknown interface type */
1608 return DPERR_NOINTERFACE;
1609
1610}
1611
1612/* Direct Play helper methods */
1613
1614/* Get a new interface. To be used by QueryInterface. */
1615static HRESULT directPlay_QueryInterface
1616 ( REFIID riid, LPVOID* ppvObj )
1617{
1618
1619 if( IsEqualGUID( &IID_IDirectPlay2, riid ) )
1620 {
1621 IDirectPlay2Impl* lpDP = (IDirectPlay2Impl*)*ppvObj;
1622
1623 lpDP = (IDirectPlay2Impl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1624 sizeof( *lpDP ) );
1625
1626 if( !lpDP )
1627 {
1628 return DPERR_OUTOFMEMORY;
1629 }
1630
1631 lpDP->lpvtbl = &directPlay2WVT;
1632 lpDP->ref = 1;
1633
1634 return S_OK;
1635 }
1636 else if( IsEqualGUID( &IID_IDirectPlay2A, riid ) )
1637 {
1638 IDirectPlay2AImpl* lpDP = (IDirectPlay2AImpl*)*ppvObj;
1639
1640 lpDP = (IDirectPlay2AImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1641 sizeof( *lpDP ) );
1642
1643 if( !lpDP )
1644 {
1645 return DPERR_OUTOFMEMORY;
1646 }
1647
1648 lpDP->lpvtbl = &directPlay2AVT;
1649 lpDP->ref = 1;
1650
1651 return S_OK;
1652 }
1653 else if( IsEqualGUID( &IID_IDirectPlay3, riid ) )
1654 {
1655 IDirectPlay3Impl* lpDP = (IDirectPlay3Impl*)*ppvObj;
1656
1657 lpDP = (IDirectPlay3Impl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1658 sizeof( *lpDP ) );
1659
1660 if( !lpDP )
1661 {
1662 return DPERR_OUTOFMEMORY;
1663 }
1664
1665 lpDP->lpvtbl = &directPlay3WVT;
1666 lpDP->ref = 1;
1667
1668 return S_OK;
1669 }
1670 else if( IsEqualGUID( &IID_IDirectPlay3A, riid ) )
1671 {
1672 IDirectPlay3AImpl* lpDP = (IDirectPlay3AImpl*)*ppvObj;
1673
1674 lpDP = (IDirectPlay3AImpl*)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1675 sizeof( *lpDP ) );
1676
1677 if( !lpDP )
1678 {
1679 return DPERR_OUTOFMEMORY;
1680 }
1681
1682 lpDP->lpvtbl = &directPlay3AVT;
1683 lpDP->ref = 1;
1684
1685 return S_OK;
1686
1687 }
1688
1689 *ppvObj = NULL;
1690 return E_NOINTERFACE;
1691}
1692
1693
1694/* Direct Play methods */
1695static HRESULT WINAPI DirectPlay2W_QueryInterface
1696 ( LPDIRECTPLAY2 iface, REFIID riid, LPVOID* ppvObj )
1697{
1698 ICOM_THIS(IDirectPlay2Impl,iface);
1699 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
1700
1701 if( IsEqualGUID( &IID_IUnknown, riid ) ||
1702 IsEqualGUID( &IID_IDirectPlay2, riid )
1703 )
1704 {
1705 IDirectPlay2_AddRef( iface );
1706 *ppvObj = This;
1707 return S_OK;
1708 }
1709 return directPlay_QueryInterface( riid, ppvObj );
1710}
1711
1712static HRESULT WINAPI DirectPlay2A_QueryInterface
1713 ( LPDIRECTPLAY2A iface, REFIID riid, LPVOID* ppvObj )
1714{
1715 ICOM_THIS(IDirectPlay2Impl,iface);
1716 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
1717
1718 if( IsEqualGUID( &IID_IUnknown, riid ) ||
1719 IsEqualGUID( &IID_IDirectPlay2A, riid )
1720 )
1721 {
1722 IDirectPlay2_AddRef( iface );
1723 *ppvObj = This;
1724 return S_OK;
1725 }
1726
1727 return directPlay_QueryInterface( riid, ppvObj );
1728}
1729
1730static HRESULT WINAPI DirectPlay3WImpl_QueryInterface
1731 ( LPDIRECTPLAY3 iface, REFIID riid, LPVOID* ppvObj )
1732{
1733 ICOM_THIS(IDirectPlay3Impl,iface);
1734 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
1735
1736 if( IsEqualGUID( &IID_IUnknown, riid ) ||
1737 IsEqualGUID( &IID_IDirectPlay3, riid )
1738 )
1739 {
1740 IDirectPlay3_AddRef( iface );
1741 *ppvObj = This;
1742 return S_OK;
1743 }
1744
1745 return directPlay_QueryInterface( riid, ppvObj );
1746}
1747
1748static HRESULT WINAPI DirectPlay3A_QueryInterface
1749 ( LPDIRECTPLAY3A iface, REFIID riid, LPVOID* ppvObj )
1750{
1751 ICOM_THIS(IDirectPlay3Impl,iface);
1752 TRACE("(%p)->(%p,%p)\n", This, riid, ppvObj );
1753
1754 if( IsEqualGUID( &IID_IUnknown, riid ) ||
1755 IsEqualGUID( &IID_IDirectPlay3A, riid )
1756 )
1757 {
1758 IDirectPlay3_AddRef( iface );
1759 *ppvObj = This;
1760 return S_OK;
1761 }
1762
1763 return directPlay_QueryInterface( riid, ppvObj );
1764}
1765
1766
1767/* Shared between all dplay types */
1768static ULONG WINAPI DirectPlay3WImpl_AddRef
1769 ( LPDIRECTPLAY3 iface )
1770{
1771 ICOM_THIS(IDirectPlay3Impl,iface);
1772 ++(This->ref);
1773 TRACE("ref count now %lu\n", This->ref );
1774 return (This->ref);
1775}
1776
1777static ULONG WINAPI DirectPlay2WImpl_AddRef (LPDIRECTPLAY2 iface)
1778{
1779 return DirectPlay3WImpl_AddRef( (LPDIRECTPLAY3) iface );
1780}
1781
1782static ULONG WINAPI DirectPlay3WImpl_Release
1783( LPDIRECTPLAY3 iface )
1784{
1785 ICOM_THIS(IDirectPlay3Impl,iface);
1786 TRACE("ref count decremeneted from %lu\n", This->ref );
1787
1788 This->ref--;
1789
1790 /* Deallocate if this is the last reference to the object */
1791 if( !(This->ref) )
1792 {
1793 FIXME("memory leak\n" );
1794 /* Implement memory deallocation */
1795
1796 HeapFree( GetProcessHeap(), 0, This );
1797
1798 return 0;
1799 }
1800
1801 return This->ref;
1802}
1803
1804static ULONG WINAPI DirectPlay2WImpl_Release (LPDIRECTPLAY2 iface)
1805{
1806 return DirectPlay3WImpl_Release( (LPDIRECTPLAY3) iface );
1807}
1808
1809static ULONG WINAPI DirectPlay3A_Release
1810( LPDIRECTPLAY3A iface )
1811{
1812 ICOM_THIS(IDirectPlay3Impl,iface);
1813 TRACE("ref count decremeneted from %lu\n", This->ref );
1814
1815 This->ref--;
1816
1817 /* Deallocate if this is the last reference to the object */
1818 if( !(This->ref) )
1819 {
1820 FIXME("memory leak\n" );
1821 /* Implement memory deallocation */
1822
1823 HeapFree( GetProcessHeap(), 0, This );
1824
1825 return 0;
1826 }
1827
1828 return This->ref;
1829}
1830
1831static ULONG WINAPI DirectPlay2AImpl_AddRef (LPDIRECTPLAY2A iface)
1832{
1833 return DirectPlay3AImpl_AddRef( (LPDIRECTPLAY3A) iface );
1834}
1835
1836HRESULT WINAPI DirectPlay3A_AddPlayerToGroup
1837 ( LPDIRECTPLAY3A iface, DPID a, DPID b )
1838{
1839 ICOM_THIS(IDirectPlay3Impl,iface);
1840 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
1841 return DP_OK;
1842}
1843
1844HRESULT WINAPI DirectPlay3WImpl_AddPlayerToGroup
1845 ( LPDIRECTPLAY3 iface, DPID a, DPID b )
1846{
1847 ICOM_THIS(IDirectPlay3Impl,iface);
1848 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
1849 return DP_OK;
1850}
1851
1852
1853HRESULT WINAPI DirectPlay3A_Close
1854 ( LPDIRECTPLAY3A iface )
1855{
1856 ICOM_THIS(IDirectPlay3Impl,iface);
1857 FIXME("(%p)->(): stub", This );
1858 return DP_OK;
1859}
1860
1861HRESULT WINAPI DirectPlay3WImpl_Close
1862 ( LPDIRECTPLAY3 iface )
1863{
1864 ICOM_THIS(IDirectPlay3Impl,iface);
1865 FIXME("(%p)->(): stub", This );
1866 return DP_OK;
1867}
1868
1869HRESULT WINAPI DirectPlay3A_CreateGroup
1870 ( LPDIRECTPLAY3A iface, LPDPID a, LPDPNAME b, LPVOID c, DWORD d, DWORD e )
1871{
1872 ICOM_THIS(IDirectPlay3Impl,iface);
1873 FIXME("(%p)->(%p,%p,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d, e );
1874 return DP_OK;
1875}
1876
1877HRESULT WINAPI DirectPlay3WImpl_CreateGroup
1878 ( LPDIRECTPLAY3 iface, LPDPID a, LPDPNAME b, LPVOID c, DWORD d, DWORD e )
1879{
1880 ICOM_THIS(IDirectPlay3Impl,iface);
1881 FIXME("(%p)->(%p,%p,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d, e );
1882 return DP_OK;
1883}
1884
1885HRESULT WINAPI DirectPlay3A_CreatePlayer
1886 ( LPDIRECTPLAY3A iface, LPDPID a, LPDPNAME b, HANDLE c, LPVOID d, DWORD e, DWORD f )
1887{
1888 ICOM_THIS(IDirectPlay3Impl,iface);
1889 FIXME("(%p)->(%p,%p,%d,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d, e, f );
1890 return DP_OK;
1891}
1892
1893HRESULT WINAPI DirectPlay3WImpl_CreatePlayer
1894 ( LPDIRECTPLAY3 iface, LPDPID a, LPDPNAME b, HANDLE c, LPVOID d, DWORD e, DWORD f )
1895{
1896 ICOM_THIS(IDirectPlay3Impl,iface);
1897 FIXME("(%p)->(%p,%p,%d,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d, e, f );
1898 return DP_OK;
1899}
1900
1901HRESULT WINAPI DirectPlay3A_DeletePlayerFromGroup
1902 ( LPDIRECTPLAY3A iface, DPID a, DPID b )
1903{
1904 ICOM_THIS(IDirectPlay3Impl,iface);
1905 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
1906 return DP_OK;
1907}
1908
1909HRESULT WINAPI DirectPlay3WImpl_DeletePlayerFromGroup
1910 ( LPDIRECTPLAY3 iface, DPID a, DPID b )
1911{
1912 ICOM_THIS(IDirectPlay3Impl,iface);
1913 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
1914 return DP_OK;
1915}
1916
1917HRESULT WINAPI DirectPlay3A_DestroyGroup
1918 ( LPDIRECTPLAY3A iface, DPID a )
1919{
1920 ICOM_THIS(IDirectPlay3Impl,iface);
1921 FIXME("(%p)->(0x%08lx): stub", This, a );
1922 return DP_OK;
1923}
1924
1925HRESULT WINAPI DirectPlay3WImpl_DestroyGroup
1926 ( LPDIRECTPLAY3 iface, DPID a )
1927{
1928 ICOM_THIS(IDirectPlay3Impl,iface);
1929 FIXME("(%p)->(0x%08lx): stub", This, a );
1930 return DP_OK;
1931}
1932
1933HRESULT WINAPI DirectPlay3A_DestroyPlayer
1934 ( LPDIRECTPLAY3A iface, DPID a )
1935{
1936 ICOM_THIS(IDirectPlay3Impl,iface);
1937 FIXME("(%p)->(0x%08lx): stub", This, a );
1938 return DP_OK;
1939}
1940
1941HRESULT WINAPI DirectPlay3WImpl_DestroyPlayer
1942 ( LPDIRECTPLAY3 iface, DPID a )
1943{
1944 ICOM_THIS(IDirectPlay3Impl,iface);
1945 FIXME("(%p)->(0x%08lx): stub", This, a );
1946 return DP_OK;
1947}
1948
1949HRESULT WINAPI DirectPlay3A_EnumGroupPlayers
1950 ( LPDIRECTPLAY3A iface, DPID a, LPGUID b, LPDPENUMPLAYERSCALLBACK2 c,
1951 LPVOID d, DWORD e )
1952{
1953 ICOM_THIS(IDirectPlay3Impl,iface);
1954 FIXME("(%p)->(0x%08lx,%p,%p,%p,0x%08lx): stub", This, a, b, c, d, e );
1955 return DP_OK;
1956}
1957
1958HRESULT WINAPI DirectPlay3WImpl_EnumGroupPlayers
1959 ( LPDIRECTPLAY3 iface, DPID a, LPGUID b, LPDPENUMPLAYERSCALLBACK2 c,
1960 LPVOID d, DWORD e )
1961{
1962 ICOM_THIS(IDirectPlay3Impl,iface);
1963 FIXME("(%p)->(0x%08lx,%p,%p,%p,0x%08lx): stub", This, a, b, c, d, e );
1964 return DP_OK;
1965}
1966
1967HRESULT WINAPI DirectPlay3A_EnumGroups
1968 ( LPDIRECTPLAY3A iface, LPGUID a, LPDPENUMPLAYERSCALLBACK2 b, LPVOID c, DWORD d )
1969{
1970 ICOM_THIS(IDirectPlay3Impl,iface);
1971 FIXME("(%p)->(%p,%p,%p,0x%08lx): stub", This, a, b, c, d );
1972 return DP_OK;
1973}
1974
1975HRESULT WINAPI DirectPlay3WImpl_EnumGroups
1976 ( LPDIRECTPLAY3 iface, LPGUID a, LPDPENUMPLAYERSCALLBACK2 b, LPVOID c, DWORD d )
1977{
1978 ICOM_THIS(IDirectPlay3Impl,iface);
1979 FIXME("(%p)->(%p,%p,%p,0x%08lx): stub", This, a, b, c, d );
1980 return DP_OK;
1981}
1982
1983HRESULT WINAPI DirectPlay3A_EnumPlayers
1984 ( LPDIRECTPLAY3A iface, LPGUID a, LPDPENUMPLAYERSCALLBACK2 b, LPVOID c, DWORD d )
1985{
1986 ICOM_THIS(IDirectPlay3Impl,iface);
1987 FIXME("(%p)->(%p,%p,%p,0x%08lx): stub", This, a, b, c, d );
1988 return DP_OK;
1989}
1990
1991HRESULT WINAPI DirectPlay3WImpl_EnumPlayers
1992 ( LPDIRECTPLAY3 iface, LPGUID a, LPDPENUMPLAYERSCALLBACK2 b, LPVOID c, DWORD d )
1993{
1994 ICOM_THIS(IDirectPlay3Impl,iface);
1995 FIXME("(%p)->(%p,%p,%p,0x%08lx): stub", This, a, b, c, d );
1996 return DP_OK;
1997}
1998
1999HRESULT WINAPI DirectPlay3A_EnumSessions
2000 ( LPDIRECTPLAY3A iface, LPDPSESSIONDESC2 a, DWORD b, LPDPENUMSESSIONSCALLBACK2 c,
2001 LPVOID d, DWORD e )
2002{
2003 ICOM_THIS(IDirectPlay3Impl,iface);
2004 FIXME("(%p)->(%p,0x%08lx,%p,%p,0x%08lx): stub", This, a, b, c, d, e );
2005 return DP_OK;
2006}
2007
2008HRESULT WINAPI DirectPlay3WImpl_EnumSessions
2009 ( LPDIRECTPLAY3 iface, LPDPSESSIONDESC2 a, DWORD b, LPDPENUMSESSIONSCALLBACK2 c,
2010 LPVOID d, DWORD e )
2011{
2012 ICOM_THIS(IDirectPlay3Impl,iface);
2013 FIXME("(%p)->(%p,0x%08lx,%p,%p,0x%08lx): stub", This, a, b, c, d, e );
2014 return DP_OK;
2015}
2016
2017HRESULT WINAPI DirectPlay3A_GetCaps
2018 ( LPDIRECTPLAY3A iface, LPDPCAPS a, DWORD b )
2019{
2020 ICOM_THIS(IDirectPlay3Impl,iface);
2021 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2022 return DP_OK;
2023}
2024
2025HRESULT WINAPI DirectPlay3WImpl_GetCaps
2026 ( LPDIRECTPLAY3 iface, LPDPCAPS a, DWORD b )
2027{
2028 ICOM_THIS(IDirectPlay3Impl,iface);
2029 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2030 return DP_OK;
2031}
2032
2033HRESULT WINAPI DirectPlay3A_GetGroupData
2034 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c, DWORD d )
2035{
2036 ICOM_THIS(IDirectPlay3Impl,iface);
2037 FIXME("(%p)->(0x%08lx,%p,%p,0x%08lx): stub", This, a, b, c, d );
2038 return DP_OK;
2039}
2040
2041HRESULT WINAPI DirectPlay3WImpl_GetGroupData
2042 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c, DWORD d )
2043{
2044 ICOM_THIS(IDirectPlay3Impl,iface);
2045 FIXME("(%p)->(0x%08lx,%p,%p,0x%08lx): stub", This, a, b, c, d );
2046 return DP_OK;
2047}
2048
2049HRESULT WINAPI DirectPlay3A_GetGroupName
2050 ( LPDIRECTPLAY3A iface, DPID a, LPVOID b, LPDWORD c )
2051{
2052 ICOM_THIS(IDirectPlay3Impl,iface);
2053 FIXME("(%p)->(0x%08lx,%p,%p): stub", This, a, b, c );
2054 return DP_OK;
2055}
2056
2057HRESULT WINAPI DirectPlay3WImpl_GetGroupName
2058 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c )
2059{
2060 ICOM_THIS(IDirectPlay3Impl,iface);
2061 FIXME("(%p)->(0x%08lx,%p,%p): stub", This, a, b, c );
2062 return DP_OK;
2063}
2064
2065HRESULT WINAPI DirectPlay3A_GetMessageCount
2066 ( LPDIRECTPLAY3A iface, DPID a, LPDWORD b )
2067{
2068 ICOM_THIS(IDirectPlay3Impl,iface);
2069 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2070 return DP_OK;
2071}
2072
2073HRESULT WINAPI DirectPlay3WImpl_GetMessageCount
2074 ( LPDIRECTPLAY3 iface, DPID a, LPDWORD b )
2075{
2076 ICOM_THIS(IDirectPlay3Impl,iface);
2077 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2078 return DP_OK;
2079}
2080
2081HRESULT WINAPI DirectPlay3A_GetPlayerAddress
2082 ( LPDIRECTPLAY3A iface, DPID a, LPVOID b, LPDWORD c )
2083{
2084 ICOM_THIS(IDirectPlay3Impl,iface);
2085 FIXME("(%p)->(0x%08lx,%p,%p): stub", This, a, b, c );
2086 return DP_OK;
2087}
2088
2089HRESULT WINAPI DirectPlay3WImpl_GetPlayerAddress
2090 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c )
2091{
2092 ICOM_THIS(IDirectPlay3Impl,iface);
2093 FIXME("(%p)->(0x%08lx,%p,%p): stub", This, a, b, c );
2094 return DP_OK;
2095}
2096
2097HRESULT WINAPI DirectPlay3A_GetPlayerCaps
2098 ( LPDIRECTPLAY3A iface, DPID a, LPDPCAPS b, DWORD c )
2099{
2100 ICOM_THIS(IDirectPlay3Impl,iface);
2101 FIXME("(%p)->(0x%08lx,%p,0x%08lx): stub", This, a, b, c );
2102 return DP_OK;
2103}
2104
2105HRESULT WINAPI DirectPlay3WImpl_GetPlayerCaps
2106 ( LPDIRECTPLAY3 iface, DPID a, LPDPCAPS b, DWORD c )
2107{
2108 ICOM_THIS(IDirectPlay3Impl,iface);
2109 FIXME("(%p)->(0x%08lx,%p,0x%08lx): stub", This, a, b, c );
2110 return DP_OK;
2111}
2112
2113HRESULT WINAPI DirectPlay3A_GetPlayerData
2114 ( LPDIRECTPLAY3A iface, DPID a, LPVOID b, LPDWORD c, DWORD d )
2115{
2116 ICOM_THIS(IDirectPlay3Impl,iface);
2117 FIXME("(%p)->(0x%08lx,%p,%p,0x%08lx): stub", This, a, b, c, d );
2118 return DP_OK;
2119}
2120
2121HRESULT WINAPI DirectPlay3WImpl_GetPlayerData
2122 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c, DWORD d )
2123{
2124 ICOM_THIS(IDirectPlay3Impl,iface);
2125 FIXME("(%p)->(0x%08lx,%p,%p,0x%08lx): stub", This, a, b, c, d );
2126 return DP_OK;
2127}
2128
2129HRESULT WINAPI DirectPlay3A_GetPlayerName
2130 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c )
2131{
2132 ICOM_THIS(IDirectPlay3Impl,iface);
2133 FIXME("(%p)->(0x%08lx,%p,%p): stub", This, a, b, c );
2134 return DP_OK;
2135}
2136
2137HRESULT WINAPI DirectPlay3WImpl_GetPlayerName
2138 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, LPDWORD c )
2139{
2140 ICOM_THIS(IDirectPlay3Impl,iface);
2141 FIXME("(%p)->(0x%08lx,%p,%p): stub", This, a, b, c );
2142 return DP_OK;
2143}
2144
2145HRESULT WINAPI DirectPlay3A_GetSessionDesc
2146 ( LPDIRECTPLAY3A iface, LPVOID a, LPDWORD b )
2147{
2148 ICOM_THIS(IDirectPlay3Impl,iface);
2149 FIXME("(%p)->(%p,%p): stub", This, a, b );
2150 return DP_OK;
2151}
2152
2153HRESULT WINAPI DirectPlay3WImpl_GetSessionDesc
2154 ( LPDIRECTPLAY3 iface, LPVOID a, LPDWORD b )
2155{
2156 ICOM_THIS(IDirectPlay3Impl,iface);
2157 FIXME("(%p)->(%p,%p): stub", This, a, b );
2158 return DP_OK;
2159}
2160
2161HRESULT WINAPI DirectPlay3A_Initialize
2162 ( LPDIRECTPLAY3A iface, LPGUID a )
2163{
2164 ICOM_THIS(IDirectPlay3Impl,iface);
2165 FIXME("(%p)->(%p): stub", This, a );
2166 return DP_OK;
2167}
2168
2169HRESULT WINAPI DirectPlay3WImpl_Initialize
2170 ( LPDIRECTPLAY3 iface, LPGUID a )
2171{
2172 ICOM_THIS(IDirectPlay3Impl,iface);
2173 FIXME("(%p)->(%p): stub", This, a );
2174 return DP_OK;
2175}
2176
2177
2178HRESULT WINAPI DirectPlay3A_Open
2179 ( LPDIRECTPLAY3A iface, LPDPSESSIONDESC2 a, DWORD b )
2180{
2181 ICOM_THIS(IDirectPlay3Impl,iface);
2182 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2183 return DP_OK;
2184}
2185
2186HRESULT WINAPI DirectPlay3WImpl_Open
2187 ( LPDIRECTPLAY3 iface, LPDPSESSIONDESC2 a, DWORD b )
2188{
2189 ICOM_THIS(IDirectPlay3Impl,iface);
2190 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2191 return DP_OK;
2192}
2193
2194HRESULT WINAPI DirectPlay3A_Receive
2195 ( LPDIRECTPLAY3A iface, LPDPID a, LPDPID b, DWORD c, LPVOID d, LPDWORD e )
2196{
2197 ICOM_THIS(IDirectPlay3Impl,iface);
2198 FIXME("(%p)->(%p,%p,0x%08lx,%p,%p): stub", This, a, b, c, d, e );
2199 return DP_OK;
2200}
2201
2202HRESULT WINAPI DirectPlay3WImpl_Receive
2203 ( LPDIRECTPLAY3 iface, LPDPID a, LPDPID b, DWORD c, LPVOID d, LPDWORD e )
2204{
2205 ICOM_THIS(IDirectPlay3Impl,iface);
2206 FIXME("(%p)->(%p,%p,0x%08lx,%p,%p): stub", This, a, b, c, d, e );
2207 return DP_OK;
2208}
2209
2210HRESULT WINAPI DirectPlay3A_Send
2211 ( LPDIRECTPLAY3A iface, DPID a, DPID b, DWORD c, LPVOID d, DWORD e )
2212{
2213 ICOM_THIS(IDirectPlay3Impl,iface);
2214 FIXME("(%p)->(0x%08lx,0x%08lx,0x%08lx,%p,0x%08lx): stub", This, a, b, c, d, e );
2215 return DP_OK;
2216}
2217
2218HRESULT WINAPI DirectPlay3WImpl_Send
2219 ( LPDIRECTPLAY3 iface, DPID a, DPID b, DWORD c, LPVOID d, DWORD e )
2220{
2221 ICOM_THIS(IDirectPlay3Impl,iface);
2222 FIXME("(%p)->(0x%08lx,0x%08lx,0x%08lx,%p,0x%08lx): stub", This, a, b, c, d, e );
2223 return DP_OK;
2224}
2225
2226HRESULT WINAPI DirectPlay3A_SetGroupData
2227 ( LPDIRECTPLAY3A iface, DPID a, LPVOID b, DWORD c, DWORD d )
2228{
2229 ICOM_THIS(IDirectPlay3Impl,iface);
2230 FIXME("(%p)->(0x%08lx,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d );
2231 return DP_OK;
2232}
2233
2234HRESULT WINAPI DirectPlay3WImpl_SetGroupData
2235 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, DWORD c, DWORD d )
2236{
2237 ICOM_THIS(IDirectPlay3Impl,iface);
2238 FIXME("(%p)->(0x%08lx,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d );
2239 return DP_OK;
2240}
2241
2242HRESULT WINAPI DirectPlay3A_SetGroupName
2243 ( LPDIRECTPLAY3A iface, DPID a, LPDPNAME b, DWORD c )
2244{
2245 ICOM_THIS(IDirectPlay3Impl,iface);
2246 FIXME("(%p)->(0x%08lx,%p,0x%08lx): stub", This, a, b, c );
2247 return DP_OK;
2248}
2249
2250HRESULT WINAPI DirectPlay3WImpl_SetGroupName
2251 ( LPDIRECTPLAY3 iface, DPID a, LPDPNAME b, DWORD c )
2252{
2253 ICOM_THIS(IDirectPlay3Impl,iface);
2254 FIXME("(%p)->(0x%08lx,%p,0x%08lx): stub", This, a, b, c );
2255 return DP_OK;
2256}
2257
2258HRESULT WINAPI DirectPlay3A_SetPlayerData
2259 ( LPDIRECTPLAY3A iface, DPID a, LPVOID b, DWORD c, DWORD d )
2260{
2261 ICOM_THIS(IDirectPlay3Impl,iface);
2262 FIXME("(%p)->(0x%08lx,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d );
2263 return DP_OK;
2264}
2265
2266HRESULT WINAPI DirectPlay3WImpl_SetPlayerData
2267 ( LPDIRECTPLAY3 iface, DPID a, LPVOID b, DWORD c, DWORD d )
2268{
2269 ICOM_THIS(IDirectPlay3Impl,iface);
2270 FIXME("(%p)->(0x%08lx,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d );
2271 return DP_OK;
2272}
2273
2274HRESULT WINAPI DirectPlay3A_SetPlayerName
2275 ( LPDIRECTPLAY3A iface, DPID a, LPDPNAME b, DWORD c )
2276{
2277 ICOM_THIS(IDirectPlay3Impl,iface);
2278 FIXME("(%p)->(0x%08lx,%p,0x%08lx): stub", This, a, b, c );
2279 return DP_OK;
2280}
2281
2282HRESULT WINAPI DirectPlay3WImpl_SetPlayerName
2283 ( LPDIRECTPLAY3 iface, DPID a, LPDPNAME b, DWORD c )
2284{
2285 ICOM_THIS(IDirectPlay3Impl,iface);
2286 FIXME("(%p)->(0x%08lx,%p,0x%08lx): stub", This, a, b, c );
2287 return DP_OK;
2288}
2289
2290HRESULT WINAPI DirectPlay3A_SetSessionDesc
2291 ( LPDIRECTPLAY3A iface, LPDPSESSIONDESC2 a, DWORD b )
2292{
2293 ICOM_THIS(IDirectPlay3Impl,iface);
2294 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2295 return DP_OK;
2296}
2297
2298HRESULT WINAPI DirectPlay3WImpl_SetSessionDesc
2299 ( LPDIRECTPLAY3 iface, LPDPSESSIONDESC2 a, DWORD b )
2300{
2301 ICOM_THIS(IDirectPlay3Impl,iface);
2302 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2303 return DP_OK;
2304}
2305
2306HRESULT WINAPI DirectPlay3A_AddGroupToGroup
2307 ( LPDIRECTPLAY3A iface, DPID a, DPID b )
2308{
2309 ICOM_THIS(IDirectPlay3Impl,iface);
2310 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
2311 return DP_OK;
2312}
2313
2314HRESULT WINAPI DirectPlay3WImpl_AddGroupToGroup
2315 ( LPDIRECTPLAY3 iface, DPID a, DPID b )
2316{
2317 ICOM_THIS(IDirectPlay3Impl,iface);
2318 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
2319 return DP_OK;
2320}
2321
2322HRESULT WINAPI DirectPlay3A_CreateGroupInGroup
2323 ( LPDIRECTPLAY3A iface, DPID a, LPDPID b, LPDPNAME c, LPVOID d, DWORD e, DWORD f )
2324{
2325 ICOM_THIS(IDirectPlay3Impl,iface);
2326 FIXME("(%p)->(0x%08lx,%p,%p,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d, e, f );
2327 return DP_OK;
2328}
2329
2330HRESULT WINAPI DirectPlay3WImpl_CreateGroupInGroup
2331 ( LPDIRECTPLAY3 iface, DPID a, LPDPID b, LPDPNAME c, LPVOID d, DWORD e, DWORD f )
2332{
2333 ICOM_THIS(IDirectPlay3Impl,iface);
2334 FIXME("(%p)->(0x%08lx,%p,%p,%p,0x%08lx,0x%08lx): stub", This, a, b, c, d, e, f );
2335 return DP_OK;
2336}
2337
2338HRESULT WINAPI DirectPlay3A_DeleteGroupFromGroup
2339 ( LPDIRECTPLAY3A iface, DPID a, DPID b )
2340{
2341 ICOM_THIS(IDirectPlay3Impl,iface);
2342 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
2343 return DP_OK;
2344}
2345
2346HRESULT WINAPI DirectPlay3WImpl_DeleteGroupFromGroup
2347 ( LPDIRECTPLAY3 iface, DPID a, DPID b )
2348{
2349 ICOM_THIS(IDirectPlay3Impl,iface);
2350 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
2351 return DP_OK;
2352}
2353
2354HRESULT WINAPI DirectPlay3A_EnumConnections
2355 ( LPDIRECTPLAY3A iface, LPCGUID a, LPDPENUMCONNECTIONSCALLBACK b, LPVOID c, DWORD d )
2356{
2357 ICOM_THIS(IDirectPlay3Impl,iface);
2358 FIXME("(%p)->(%p,%p,%p,0x%08lx): stub", This, a, b, c, d );
2359 return DP_OK;
2360}
2361
2362HRESULT WINAPI DirectPlay3WImpl_EnumConnections
2363 ( LPDIRECTPLAY3 iface, LPCGUID a, LPDPENUMCONNECTIONSCALLBACK b, LPVOID c, DWORD d )
2364{
2365 ICOM_THIS(IDirectPlay3Impl,iface);
2366 FIXME("(%p)->(%p,%p,%p,0x%08lx): stub", This, a, b, c, d );
2367 return DP_OK;
2368}
2369
2370HRESULT WINAPI DirectPlay3A_EnumGroupsInGroup
2371 ( LPDIRECTPLAY3A iface, DPID a, LPGUID b, LPDPENUMPLAYERSCALLBACK2 c, LPVOID d, DWORD e )
2372{
2373 ICOM_THIS(IDirectPlay3Impl,iface);
2374 FIXME("(%p)->(0x%08lx,%p,%p,%p,0x%08lx): stub", This, a, b, c, d, e );
2375 return DP_OK;
2376}
2377
2378HRESULT WINAPI DirectPlay3WImpl_EnumGroupsInGroup
2379 ( LPDIRECTPLAY3 iface, DPID a, LPGUID b, LPDPENUMPLAYERSCALLBACK2 c, LPVOID d, DWORD e )
2380{
2381 ICOM_THIS(IDirectPlay3Impl,iface);
2382 FIXME("(%p)->(0x%08lx,%p,%p,%p,0x%08lx): stub", This, a, b, c, d, e );
2383 return DP_OK;
2384}
2385
2386HRESULT WINAPI DirectPlay3A_GetGroupConnectionSettings
2387 ( LPDIRECTPLAY3A iface, DWORD a, DPID b, LPVOID c, LPDWORD d )
2388{
2389 ICOM_THIS(IDirectPlay3Impl,iface);
2390 FIXME("(%p)->(0x%08lx,0x%08lx,%p,%p): stub", This, a, b, c, d );
2391 return DP_OK;
2392}
2393
2394HRESULT WINAPI DirectPlay3WImpl_GetGroupConnectionSettings
2395 ( LPDIRECTPLAY3 iface, DWORD a, DPID b, LPVOID c, LPDWORD d )
2396{
2397 ICOM_THIS(IDirectPlay3Impl,iface);
2398 FIXME("(%p)->(0x%08lx,0x%08lx,%p,%p): stub", This, a, b, c, d );
2399 return DP_OK;
2400}
2401
2402HRESULT WINAPI DirectPlay3A_InitializeConnection
2403 ( LPDIRECTPLAY3A iface, LPVOID a, DWORD b )
2404{
2405 ICOM_THIS(IDirectPlay3Impl,iface);
2406 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2407 return DP_OK;
2408}
2409
2410HRESULT WINAPI DirectPlay3WImpl_InitializeConnection
2411 ( LPDIRECTPLAY3 iface, LPVOID a, DWORD b )
2412{
2413 ICOM_THIS(IDirectPlay3Impl,iface);
2414 FIXME("(%p)->(%p,0x%08lx): stub", This, a, b );
2415 return DP_OK;
2416}
2417
2418HRESULT WINAPI DirectPlay3A_SecureOpen
2419 ( LPDIRECTPLAY3A iface, LPCDPSESSIONDESC2 a, DWORD b, LPCDPSECURITYDESC c, LPCDPCREDENTIALS d )
2420{
2421 ICOM_THIS(IDirectPlay3Impl,iface);
2422 FIXME("(%p)->(%p,0x%08lx,%p,%p): stub", This, a, b, c, d );
2423 return DP_OK;
2424}
2425
2426HRESULT WINAPI DirectPlay3WImpl_SecureOpen
2427 ( LPDIRECTPLAY3 iface, LPCDPSESSIONDESC2 a, DWORD b, LPCDPSECURITYDESC c, LPCDPCREDENTIALS d )
2428{
2429 ICOM_THIS(IDirectPlay3Impl,iface);
2430 FIXME("(%p)->(%p,0x%08lx,%p,%p): stub", This, a, b, c, d );
2431 return DP_OK;
2432}
2433
2434HRESULT WINAPI DirectPlay3A_SendChatMessage
2435 ( LPDIRECTPLAY3A iface, DPID a, DPID b, DWORD c, LPDPCHAT d )
2436{
2437 ICOM_THIS(IDirectPlay3Impl,iface);
2438 FIXME("(%p)->(0x%08lx,0x%08lx,0x%08lx,%p): stub", This, a, b, c, d );
2439 return DP_OK;
2440}
2441
2442HRESULT WINAPI DirectPlay3WImpl_SendChatMessage
2443 ( LPDIRECTPLAY3 iface, DPID a, DPID b, DWORD c, LPDPCHAT d )
2444{
2445 ICOM_THIS(IDirectPlay3Impl,iface);
2446 FIXME("(%p)->(0x%08lx,0x%08lx,0x%08lx,%p): stub", This, a, b, c, d );
2447 return DP_OK;
2448}
2449
2450HRESULT WINAPI DirectPlay3A_SetGroupConnectionSettings
2451 ( LPDIRECTPLAY3A iface, DWORD a, DPID b, LPDPLCONNECTION c )
2452{
2453 ICOM_THIS(IDirectPlay3Impl,iface);
2454 FIXME("(%p)->(0x%08lx,0x%08lx,%p): stub", This, a, b, c );
2455 return DP_OK;
2456}
2457
2458HRESULT WINAPI DirectPlay3WImpl_SetGroupConnectionSettings
2459 ( LPDIRECTPLAY3 iface, DWORD a, DPID b, LPDPLCONNECTION c )
2460{
2461 ICOM_THIS(IDirectPlay3Impl,iface);
2462 FIXME("(%p)->(0x%08lx,0x%08lx,%p): stub", This, a, b, c );
2463 return DP_OK;
2464}
2465
2466HRESULT WINAPI DirectPlay3A_StartSession
2467 ( LPDIRECTPLAY3A iface, DWORD a, DPID b )
2468{
2469 ICOM_THIS(IDirectPlay3Impl,iface);
2470 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
2471 return DP_OK;
2472}
2473
2474HRESULT WINAPI DirectPlay3WImpl_StartSession
2475 ( LPDIRECTPLAY3 iface, DWORD a, DPID b )
2476{
2477 ICOM_THIS(IDirectPlay3Impl,iface);
2478 FIXME("(%p)->(0x%08lx,0x%08lx): stub", This, a, b );
2479 return DP_OK;
2480}
2481
2482HRESULT WINAPI DirectPlay3A_GetGroupFlags
2483 ( LPDIRECTPLAY3A iface, DPID a, LPDWORD b )
2484{
2485 ICOM_THIS(IDirectPlay3Impl,iface);
2486 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2487 return DP_OK;
2488}
2489
2490HRESULT WINAPI DirectPlay3WImpl_GetGroupFlags
2491 ( LPDIRECTPLAY3 iface, DPID a, LPDWORD b )
2492{
2493 ICOM_THIS(IDirectPlay3Impl,iface);
2494 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2495 return DP_OK;
2496}
2497
2498HRESULT WINAPI DirectPlay3A_GetGroupParent
2499 ( LPDIRECTPLAY3A iface, DPID a, LPDPID b )
2500{
2501 ICOM_THIS(IDirectPlay3Impl,iface);
2502 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2503 return DP_OK;
2504}
2505
2506HRESULT WINAPI DirectPlay3WImpl_GetGroupParent
2507 ( LPDIRECTPLAY3 iface, DPID a, LPDPID b )
2508{
2509 ICOM_THIS(IDirectPlay3Impl,iface);
2510 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2511 return DP_OK;
2512}
2513
2514HRESULT WINAPI DirectPlay3A_GetPlayerAccount
2515 ( LPDIRECTPLAY3A iface, DPID a, DWORD b, LPVOID c, LPDWORD d )
2516{
2517 ICOM_THIS(IDirectPlay3Impl,iface);
2518 FIXME("(%p)->(0x%08lx,0x%08lx,%p,%p): stub", This, a, b, c, d );
2519 return DP_OK;
2520}
2521
2522HRESULT WINAPI DirectPlay3WImpl_GetPlayerAccount
2523 ( LPDIRECTPLAY3 iface, DPID a, DWORD b, LPVOID c, LPDWORD d )
2524{
2525 ICOM_THIS(IDirectPlay3Impl,iface);
2526 FIXME("(%p)->(0x%08lx,0x%08lx,%p,%p): stub", This, a, b, c, d );
2527 return DP_OK;
2528}
2529
2530HRESULT WINAPI DirectPlay3A_GetPlayerFlags
2531 ( LPDIRECTPLAY3A iface, DPID a, LPDWORD b )
2532{
2533 ICOM_THIS(IDirectPlay3Impl,iface);
2534 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2535 return DP_OK;
2536}
2537
2538HRESULT WINAPI DirectPlay3WImpl_GetPlayerFlags
2539 ( LPDIRECTPLAY3 iface, DPID a, LPDWORD b )
2540{
2541 ICOM_THIS(IDirectPlay3Impl,iface);
2542 FIXME("(%p)->(0x%08lx,%p): stub", This, a, b );
2543 return DP_OK;
2544}
2545
2546
2547ICOM_VTABLE(IDirectPlay2) directPlay2WVT =
2548{
2549 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2550 DirectPlay2W_QueryInterface,
2551 DirectPlay2WImpl_AddRef,
2552 DirectPlay2WImpl_Release,
2553 DirectPlay2WImpl_AddPlayerToGroup,
2554 DirectPlay2WImpl_Close,
2555 DirectPlay2WImpl_CreateGroup,
2556 DirectPlay2WImpl_CreatePlayer,
2557 DirectPlay2WImpl_DeletePlayerFromGroup,
2558 DirectPlay2WImpl_DestroyGroup,
2559 DirectPlay2WImpl_DestroyPlayer,
2560 DirectPlay2WImpl_EnumGroupPlayers,
2561 DirectPlay2WImpl_EnumGroups,
2562 DirectPlay2WImpl_EnumPlayers,
2563 DirectPlay2WImpl_EnumSessions,
2564 DirectPlay2WImpl_GetCaps,
2565 DirectPlay2WImpl_GetGroupData,
2566 DirectPlay2WImpl_GetGroupName,
2567 DirectPlay2WImpl_GetMessageCount,
2568 DirectPlay2WImpl_GetPlayerAddress,
2569 DirectPlay2WImpl_GetPlayerCaps,
2570 DirectPlay2WImpl_GetPlayerData,
2571 DirectPlay2WImpl_GetPlayerName,
2572 DirectPlay2WImpl_GetSessionDesc,
2573 DirectPlay2WImpl_Initialize,
2574 DirectPlay2WImpl_Open,
2575 DirectPlay2WImpl_Receive,
2576 DirectPlay2WImpl_Send,
2577 DirectPlay2WImpl_SetGroupData,
2578 DirectPlay2WImpl_SetGroupName,
2579 DirectPlay2WImpl_SetPlayerData,
2580 DirectPlay2WImpl_SetPlayerName,
2581 DirectPlay2WImpl_SetSessionDesc
2582};
2583
2584
2585ICOM_VTABLE(IDirectPlay2) directPlay2AVT =
2586{
2587 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2588 DirectPlay2A_QueryInterface,
2589 DirectPlay2WImpl_AddRef, //???
2590 DirectPlay2A_Release,
2591 DirectPlay2A_AddPlayerToGroup,
2592 DirectPlay2A_Close,
2593 DirectPlay2A_CreateGroup,
2594 DirectPlay2A_CreatePlayer,
2595 DirectPlay2A_DeletePlayerFromGroup,
2596 DirectPlay2A_DestroyGroup,
2597 DirectPlay2A_DestroyPlayer,
2598 DirectPlay2A_EnumGroupPlayers,
2599 DirectPlay2A_EnumGroups,
2600 DirectPlay2A_EnumPlayers,
2601 DirectPlay2A_EnumSessions,
2602 DirectPlay2A_GetCaps,
2603 DirectPlay2A_GetGroupData,
2604 DirectPlay2A_GetGroupName,
2605 DirectPlay2A_GetMessageCount,
2606 DirectPlay2A_GetPlayerAddress,
2607 DirectPlay2A_GetPlayerCaps,
2608 DirectPlay2A_GetPlayerData,
2609 DirectPlay2A_GetPlayerName,
2610 DirectPlay2A_GetSessionDesc,
2611 DirectPlay2A_Initialize,
2612 DirectPlay2A_Open,
2613 DirectPlay2A_Receive,
2614 DirectPlay2A_Send,
2615 DirectPlay2A_SetGroupData,
2616 DirectPlay2A_SetGroupName,
2617 DirectPlay2A_SetPlayerData,
2618 DirectPlay2A_SetPlayerName,
2619 DirectPlay2A_SetSessionDesc
2620};
2621
2622
2623ICOM_VTABLE(IDirectPlay3) directPlay3AVT =
2624{
2625 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2626 DirectPlay3A_QueryInterface,
2627 DirectPlay3WImpl_AddRef,
2628 DirectPlay3A_Release,
2629 DirectPlay3A_AddPlayerToGroup,
2630 DirectPlay3A_Close,
2631 DirectPlay3A_CreateGroup,
2632 DirectPlay3A_CreatePlayer,
2633 DirectPlay3A_DeletePlayerFromGroup,
2634 DirectPlay3A_DestroyGroup,
2635 DirectPlay3A_DestroyPlayer,
2636 DirectPlay3A_EnumGroupPlayers,
2637 DirectPlay3A_EnumGroups,
2638 DirectPlay3A_EnumPlayers,
2639 DirectPlay3A_EnumSessions,
2640 DirectPlay3A_GetCaps,
2641 DirectPlay3A_GetGroupData,
2642 DirectPlay3A_GetGroupName,
2643 DirectPlay3A_GetMessageCount,
2644 DirectPlay3A_GetPlayerAddress,
2645 DirectPlay3A_GetPlayerCaps,
2646 DirectPlay3A_GetPlayerData,
2647 DirectPlay3A_GetPlayerName,
2648 DirectPlay3A_GetSessionDesc,
2649 DirectPlay3A_Initialize,
2650 DirectPlay3A_Open,
2651 DirectPlay3A_Receive,
2652 DirectPlay3A_Send,
2653 DirectPlay3A_SetGroupData,
2654 DirectPlay3A_SetGroupName,
2655 DirectPlay3A_SetPlayerData,
2656 DirectPlay3A_SetPlayerName,
2657 DirectPlay3A_SetSessionDesc,
2658
2659 DirectPlay3A_AddGroupToGroup,
2660 DirectPlay3A_CreateGroupInGroup,
2661 DirectPlay3A_DeleteGroupFromGroup,
2662 DirectPlay3A_EnumConnections,
2663 DirectPlay3A_EnumGroupsInGroup,
2664 DirectPlay3A_GetGroupConnectionSettings,
2665 DirectPlay3A_InitializeConnection,
2666 DirectPlay3A_SecureOpen,
2667 DirectPlay3A_SendChatMessage,
2668 DirectPlay3A_SetGroupConnectionSettings,
2669 DirectPlay3A_StartSession,
2670 DirectPlay3A_GetGroupFlags,
2671 DirectPlay3A_GetGroupParent,
2672 DirectPlay3A_GetPlayerAccount,
2673 DirectPlay3A_GetPlayerFlags
2674};
2675
2676ICOM_VTABLE(IDirectPlay3) directPlay3WVT =
2677{
2678 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2679 DirectPlay3WImpl_QueryInterface,
2680 DirectPlay3WImpl_AddRef,
2681 DirectPlay3WImpl_Release,
2682 DirectPlay3WImpl_AddPlayerToGroup,
2683 DirectPlay3WImpl_Close,
2684 DirectPlay3WImpl_CreateGroup,
2685 DirectPlay3WImpl_CreatePlayer,
2686 DirectPlay3WImpl_DeletePlayerFromGroup,
2687 DirectPlay3WImpl_DestroyGroup,
2688 DirectPlay3WImpl_DestroyPlayer,
2689 DirectPlay3WImpl_EnumGroupPlayers,
2690 DirectPlay3WImpl_EnumGroups,
2691 DirectPlay3WImpl_EnumPlayers,
2692 DirectPlay3WImpl_EnumSessions,
2693 DirectPlay3WImpl_GetCaps,
2694 DirectPlay3WImpl_GetGroupData,
2695 DirectPlay3WImpl_GetGroupName,
2696 DirectPlay3WImpl_GetMessageCount,
2697 DirectPlay3WImpl_GetPlayerAddress,
2698 DirectPlay3WImpl_GetPlayerCaps,
2699 DirectPlay3WImpl_GetPlayerData,
2700 DirectPlay3WImpl_GetPlayerName,
2701 DirectPlay3WImpl_GetSessionDesc,
2702 DirectPlay3WImpl_Initialize,
2703 DirectPlay3WImpl_Open,
2704 DirectPlay3WImpl_Receive,
2705 DirectPlay3WImpl_Send,
2706 DirectPlay3WImpl_SetGroupData,
2707 DirectPlay3WImpl_SetGroupName,
2708 DirectPlay3WImpl_SetPlayerData,
2709 DirectPlay3WImpl_SetPlayerName,
2710 DirectPlay3WImpl_SetSessionDesc,
2711
2712 DirectPlay3WImpl_AddGroupToGroup,
2713 DirectPlay3WImpl_CreateGroupInGroup,
2714 DirectPlay3WImpl_DeleteGroupFromGroup,
2715 DirectPlay3WImpl_EnumConnections,
2716 DirectPlay3WImpl_EnumGroupsInGroup,
2717 DirectPlay3WImpl_GetGroupConnectionSettings,
2718 DirectPlay3WImpl_InitializeConnection,
2719 DirectPlay3WImpl_SecureOpen,
2720 DirectPlay3WImpl_SendChatMessage,
2721 DirectPlay3WImpl_SetGroupConnectionSettings,
2722 DirectPlay3WImpl_StartSession,
2723 DirectPlay3WImpl_GetGroupFlags,
2724 DirectPlay3WImpl_GetGroupParent,
2725 DirectPlay3WImpl_GetPlayerAccount,
2726 DirectPlay3WImpl_GetPlayerFlags
2727};
Note: See TracBrowser for help on using the repository browser.