dlls/dpnet/client.c

   1 /*
   2  * DirectPlay8 Client
   3  *
   4  * Copyright 2004 Raphael Junqueira
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22
  23 #include <stdarg.h>
  24
  25 #define COBJMACROS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "objbase.h"
  31 #include "wine/debug.h"
  32
  33 #include "dpnet_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(dpnet);
  36
  37 typedef struct IDirectPlay8LobbyClientImpl
  38 {
  39     IDirectPlay8LobbyClient IDirectPlay8LobbyClient_iface;
  40     LONG ref;
  41
  42     PFNDPNMESSAGEHANDLER msghandler;
  43     DWORD flags;
  44     void *usercontext;
  45 } IDirectPlay8LobbyClientImpl;
  46
  47 static inline IDirectPlay8LobbyClientImpl *impl_from_IDirectPlay8LobbyClient(IDirectPlay8LobbyClient *iface)
  48 {
  49     return CONTAINING_RECORD(iface, IDirectPlay8LobbyClientImpl, IDirectPlay8LobbyClient_iface);
  50 }
  51
  52 static inline IDirectPlay8ClientImpl *impl_from_IDirectPlay8Client(IDirectPlay8Client *iface)
  53 {
  54     return CONTAINING_RECORD(iface, IDirectPlay8ClientImpl, IDirectPlay8Client_iface);
  55 }
  56
  57 /* IDirectPlay8Client IUnknown parts follow: */
  58 static HRESULT WINAPI IDirectPlay8ClientImpl_QueryInterface(IDirectPlay8Client *iface, REFIID riid,
  59         void **ppobj)
  60 {
  61     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
  62
  63     if (IsEqualGUID(riid, &IID_IUnknown)
  64         || IsEqualGUID(riid, &IID_IDirectPlay8Client)) {
  65         IUnknown_AddRef(iface);
  66         *ppobj = This;
  67         return DPN_OK;
  68     }
  69
  70     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
  71     return E_NOINTERFACE;
  72 }
  73
  74 static ULONG WINAPI IDirectPlay8ClientImpl_AddRef(IDirectPlay8Client *iface)
  75 {
  76     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
  77     ULONG ref = InterlockedIncrement(&This->ref);
  78
  79     TRACE("(%p) ref=%u\n", This, ref);
  80
  81     return ref;
  82 }
  83
  84 static ULONG WINAPI IDirectPlay8ClientImpl_Release(IDirectPlay8Client *iface)
  85 {
  86     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
  87     ULONG ref = InterlockedDecrement(&This->ref);
  88
  89     TRACE("(%p) ref=%u\n", This, ref);
  90
  91     if (!ref)
  92     {
  93         heap_free(This->username);
  94         heap_free(This->data);
  95         heap_free(This);
  96     }
  97     return ref;
  98 }
  99
 100 /* IDirectPlay8Client Interface follow: */
 101
 102 static HRESULT WINAPI IDirectPlay8ClientImpl_Initialize(IDirectPlay8Client *iface,
 103         void * const pvUserContext, const PFNDPNMESSAGEHANDLER pfn, const DWORD dwFlags)
 104 {
 105     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 106
 107     TRACE("(%p):(%p,%p,%x)\n", This, pvUserContext, pfn, dwFlags);
 108
 109     if(!pfn)
 110         return DPNERR_INVALIDPARAM;
 111
 112     This->usercontext = pvUserContext;
 113     This->msghandler = pfn;
 114     This->flags = dwFlags;
 115
 116     init_winsock();
 117
 118     return DPN_OK;
 119 }
 120
 121 static HRESULT WINAPI IDirectPlay8ClientImpl_EnumServiceProviders(IDirectPlay8Client *iface,
 122         const GUID * const pguidServiceProvider, const GUID * const pguidApplication,
 123         DPN_SERVICE_PROVIDER_INFO * const pSPInfoBuffer, PDWORD const pcbEnumData,
 124         PDWORD const pcReturned, const DWORD dwFlags)
 125 {
 126     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 127     TRACE("(%p)->(%s,%s,%p,%p,%p,%x)\n", This, debugstr_guid(pguidServiceProvider), debugstr_guid(pguidApplication),
 128                                              pSPInfoBuffer, pcbEnumData, pcReturned, dwFlags);
 129
 130     if(dwFlags)
 131         FIXME("Unhandled flags %x\n", dwFlags);
 132
 133     if(pguidApplication)
 134         FIXME("Application guid %s is currently being ignored\n", debugstr_guid(pguidApplication));
 135
 136     return enum_services_providers(pguidServiceProvider, pSPInfoBuffer, pcbEnumData, pcReturned);
 137 }
 138
 139 static HRESULT WINAPI IDirectPlay8ClientImpl_EnumHosts(IDirectPlay8Client *iface,
 140         PDPN_APPLICATION_DESC const pApplicationDesc, IDirectPlay8Address * const pAddrHost,
 141         IDirectPlay8Address * const pDeviceInfo, void * const pUserEnumData,
 142         const DWORD dwUserEnumDataSize, const DWORD dwEnumCount, const DWORD dwRetryInterval,
 143         const DWORD dwTimeOut, void * const pvUserContext, DPNHANDLE * const pAsyncHandle,
 144         const DWORD dwFlags)
 145 {
 146     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 147
 148     FIXME("(%p):(%p,%p,%p,%p,%u,%u,%u,%u,%p,%p,%x)\n", This, pApplicationDesc, pAddrHost, pDeviceInfo, pUserEnumData,
 149         dwUserEnumDataSize, dwEnumCount, dwRetryInterval, dwTimeOut, pvUserContext, pAsyncHandle, dwFlags);
 150
 151     if(!This->msghandler)
 152         return DPNERR_UNINITIALIZED;
 153
 154     if((dwFlags & DPNENUMHOSTS_SYNC) && pAsyncHandle)
 155         return DPNERR_INVALIDPARAM;
 156
 157     if(dwUserEnumDataSize > This->spcaps.dwMaxEnumPayloadSize)
 158         return DPNERR_ENUMQUERYTOOLARGE;
 159
 160     return (dwFlags & DPNENUMHOSTS_SYNC) ? DPN_OK : DPNSUCCESS_PENDING;
 161 }
 162
 163 static HRESULT WINAPI IDirectPlay8ClientImpl_CancelAsyncOperation(IDirectPlay8Client *iface,
 164         const DPNHANDLE hAsyncHandle, const DWORD dwFlags)
 165 {
 166   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 167   FIXME("(%p):(%u,%x): Stub\n", This, hAsyncHandle, dwFlags);
 168   return DPN_OK;
 169 }
 170
 171 static HRESULT WINAPI IDirectPlay8ClientImpl_Connect(IDirectPlay8Client *iface,
 172         const DPN_APPLICATION_DESC * const pdnAppDesc, IDirectPlay8Address * const pHostAddr,
 173         IDirectPlay8Address * const pDeviceInfo, const DPN_SECURITY_DESC * const pdnSecurity,
 174         const DPN_SECURITY_CREDENTIALS * const pdnCredentials, const void * const pvUserConnectData,
 175         const DWORD dwUserConnectDataSize, void * const pvAsyncContext,
 176         DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
 177 {
 178   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 179   FIXME("(%p):(%p,%p,%x): Stub\n", This, pvAsyncContext, phAsyncHandle, dwFlags);
 180   return DPN_OK;
 181 }
 182
 183 static HRESULT WINAPI IDirectPlay8ClientImpl_Send(IDirectPlay8Client *iface,
 184         const DPN_BUFFER_DESC * const prgBufferDesc, const DWORD cBufferDesc, const DWORD dwTimeOut,
 185         void * const pvAsyncContext, DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
 186 {
 187   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 188   FIXME("(%p):(%p,%p,%x): Stub\n", This, pvAsyncContext, phAsyncHandle, dwFlags);
 189   return DPN_OK;
 190 }
 191
 192 static HRESULT WINAPI IDirectPlay8ClientImpl_GetSendQueueInfo(IDirectPlay8Client *iface,
 193         DWORD * const pdwNumMsgs, DWORD * const pdwNumBytes, const DWORD dwFlags)
 194 {
 195   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 196   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 197   return DPN_OK;
 198 }
 199
 200 static HRESULT WINAPI IDirectPlay8ClientImpl_GetApplicationDesc(IDirectPlay8Client *iface,
 201         DPN_APPLICATION_DESC * const pAppDescBuffer, DWORD * const pcbDataSize, const DWORD dwFlags)
 202 {
 203   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 204   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 205   return DPN_OK;
 206 }
 207
 208 static HRESULT WINAPI IDirectPlay8ClientImpl_SetClientInfo(IDirectPlay8Client *iface,
 209         const DPN_PLAYER_INFO * const pdpnPlayerInfo, void * const pvAsyncContext,
 210         DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
 211 {
 212     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 213     FIXME("(%p):(%p,%p,%x): Semi-stub.\n", This, pvAsyncContext, phAsyncHandle, dwFlags);
 214
 215     if(!pdpnPlayerInfo)
 216        return E_POINTER;
 217
 218     if(phAsyncHandle)
 219         FIXME("Async handle currently not supported.\n");
 220
 221     if (pdpnPlayerInfo->dwInfoFlags & DPNINFO_NAME)
 222     {
 223         heap_free(This->username);
 224         This->username = NULL;
 225
 226         if(pdpnPlayerInfo->pwszName)
 227         {
 228             This->username = heap_strdupW(pdpnPlayerInfo->pwszName);
 229             if (!This->username)
 230                 return E_OUTOFMEMORY;
 231         }
 232     }
 233
 234     if (pdpnPlayerInfo->dwInfoFlags & DPNINFO_DATA)
 235     {
 236         heap_free(This->data);
 237         This->data = NULL;
 238         This->datasize = 0;
 239
 240         if(!pdpnPlayerInfo->pvData && pdpnPlayerInfo->dwDataSize)
 241             return E_POINTER;
 242
 243         if(pdpnPlayerInfo->dwDataSize && pdpnPlayerInfo->pvData)
 244         {
 245             This->data = heap_alloc(pdpnPlayerInfo->dwDataSize);
 246             if (!This->data)
 247                 return E_OUTOFMEMORY;
 248
 249             This->datasize = pdpnPlayerInfo->dwDataSize;
 250
 251             memcpy(This->data, pdpnPlayerInfo->pvData, pdpnPlayerInfo->dwDataSize);
 252         }
 253     }
 254
 255     return DPN_OK;
 256 }
 257
 258 static HRESULT WINAPI IDirectPlay8ClientImpl_GetServerInfo(IDirectPlay8Client *iface,
 259         DPN_PLAYER_INFO * const pdpnPlayerInfo, DWORD * const pdwSize, const DWORD dwFlags)
 260 {
 261   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 262   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 263   return DPN_OK;
 264 }
 265
 266 static HRESULT WINAPI IDirectPlay8ClientImpl_GetServerAddress(IDirectPlay8Client *iface,
 267         IDirectPlay8Address ** const pAddress, const DWORD dwFlags)
 268 {
 269   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 270   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 271   return DPN_OK;
 272 }
 273
 274 static HRESULT WINAPI IDirectPlay8ClientImpl_Close(IDirectPlay8Client *iface, const DWORD dwFlags)
 275 {
 276     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 277     FIXME("(%p):(%x): Stub\n", This, dwFlags);
 278
 279     This->msghandler = NULL;
 280
 281     return DPN_OK;
 282 }
 283
 284 static HRESULT WINAPI IDirectPlay8ClientImpl_ReturnBuffer(IDirectPlay8Client *iface,
 285         const DPNHANDLE hBufferHandle, const DWORD dwFlags)
 286 {
 287   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 288   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 289   return DPN_OK;
 290 }
 291
 292 static HRESULT WINAPI IDirectPlay8ClientImpl_GetCaps(IDirectPlay8Client *iface,
 293         DPN_CAPS * const pdpCaps, const DWORD dwFlags)
 294 {
 295   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 296   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 297   return DPN_OK;
 298 }
 299
 300 static HRESULT WINAPI IDirectPlay8ClientImpl_SetCaps(IDirectPlay8Client *iface,
 301         const DPN_CAPS * const pdpCaps, const DWORD dwFlags)
 302 {
 303   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 304   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 305   return DPN_OK;
 306 }
 307
 308 static HRESULT WINAPI IDirectPlay8ClientImpl_SetSPCaps(IDirectPlay8Client *iface,
 309         const GUID * const pguidSP, const DPN_SP_CAPS * const pdpspCaps, const DWORD dwFlags)
 310 {
 311     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 312
 313     TRACE("(%p)->(%p,%p,%x): stub\n", iface, pguidSP, pdpspCaps, dwFlags);
 314
 315     if(!This->msghandler || pdpspCaps->dwSize != sizeof(DPN_SP_CAPS))
 316         return DPNERR_INVALIDPARAM;
 317
 318     /* Only dwSystemBufferSize is set by this call. */
 319     This->spcaps.dwSystemBufferSize = pdpspCaps->dwSystemBufferSize;
 320
 321     return DPN_OK;
 322 }
 323
 324 static HRESULT WINAPI IDirectPlay8ClientImpl_GetSPCaps(IDirectPlay8Client *iface,
 325         const GUID * const pguidSP, DPN_SP_CAPS * const pdpspCaps, const DWORD dwFlags)
 326 {
 327     IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 328
 329     TRACE("(%p)->(%p,%p,%x)\n", This, pguidSP, pdpspCaps, dwFlags);
 330
 331     if(!This->msghandler)
 332         return DPNERR_UNINITIALIZED;
 333
 334     if(pdpspCaps->dwSize != sizeof(DPN_SP_CAPS))
 335     {
 336         return DPNERR_INVALIDPARAM;
 337     }
 338
 339     *pdpspCaps = This->spcaps;
 340
 341     return DPN_OK;
 342 }
 343
 344 static HRESULT WINAPI IDirectPlay8ClientImpl_GetConnectionInfo(IDirectPlay8Client *iface,
 345         DPN_CONNECTION_INFO * const pdpConnectionInfo, const DWORD dwFlags)
 346 {
 347   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 348   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 349   return DPN_OK;
 350 }
 351
 352 static HRESULT WINAPI IDirectPlay8ClientImpl_RegisterLobby(IDirectPlay8Client *iface,
 353         const DPNHANDLE dpnHandle,
 354         struct IDirectPlay8LobbiedApplication * const pIDP8LobbiedApplication, const DWORD dwFlags)
 355 {
 356   IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
 357   FIXME("(%p):(%x): Stub\n", This, dwFlags);
 358   return DPN_OK;
 359 }
 360
 361 static const IDirectPlay8ClientVtbl DirectPlay8Client_Vtbl =
 362 {
 363     IDirectPlay8ClientImpl_QueryInterface,
 364     IDirectPlay8ClientImpl_AddRef,
 365     IDirectPlay8ClientImpl_Release,
 366     IDirectPlay8ClientImpl_Initialize,
 367     IDirectPlay8ClientImpl_EnumServiceProviders,
 368     IDirectPlay8ClientImpl_EnumHosts,
 369     IDirectPlay8ClientImpl_CancelAsyncOperation,
 370     IDirectPlay8ClientImpl_Connect,
 371     IDirectPlay8ClientImpl_Send,
 372     IDirectPlay8ClientImpl_GetSendQueueInfo,
 373     IDirectPlay8ClientImpl_GetApplicationDesc,
 374     IDirectPlay8ClientImpl_SetClientInfo,
 375     IDirectPlay8ClientImpl_GetServerInfo,
 376     IDirectPlay8ClientImpl_GetServerAddress,
 377     IDirectPlay8ClientImpl_Close,
 378     IDirectPlay8ClientImpl_ReturnBuffer,
 379     IDirectPlay8ClientImpl_GetCaps,
 380     IDirectPlay8ClientImpl_SetCaps,
 381     IDirectPlay8ClientImpl_SetSPCaps,
 382     IDirectPlay8ClientImpl_GetSPCaps,
 383     IDirectPlay8ClientImpl_GetConnectionInfo,
 384     IDirectPlay8ClientImpl_RegisterLobby
 385 };
 386
 387 HRESULT DPNET_CreateDirectPlay8Client(IClassFactory *iface, IUnknown *pUnkOuter, REFIID riid, void **ppv)
 388 {
 389     IDirectPlay8ClientImpl* client;
 390     HRESULT hr;
 391
 392     TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
 393
 394     *ppv = NULL;
 395
 396     if(pUnkOuter)
 397         return CLASS_E_NOAGGREGATION;
 398
 399     client = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectPlay8ClientImpl));
 400     if (!client)
 401         return E_OUTOFMEMORY;
 402
 403     client->IDirectPlay8Client_iface.lpVtbl = &DirectPlay8Client_Vtbl;
 404     client->ref = 1;
 405
 406     init_dpn_sp_caps(&client->spcaps);
 407
 408     hr = IDirectPlay8ClientImpl_QueryInterface(&client->IDirectPlay8Client_iface, riid, ppv);
 409     IDirectPlay8ClientImpl_Release(&client->IDirectPlay8Client_iface);
 410
 411     return hr;
 412 }
 413
 414 static HRESULT WINAPI lobbyclient_QueryInterface(IDirectPlay8LobbyClient *iface, REFIID riid, void **obj)
 415 {
 416     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 417
 418     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 419
 420     *obj = NULL;
 421
 422     if (IsEqualGUID(riid, &IID_IUnknown) ||
 423         IsEqualGUID(riid, &IID_IDirectPlay8LobbyClient))
 424     {
 425         *obj = &This->IDirectPlay8LobbyClient_iface;
 426         IUnknown_AddRef( (IUnknown*)*obj);
 427
 428         return DPN_OK;
 429     }
 430
 431     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),obj);
 432     return E_NOINTERFACE;
 433 }
 434
 435 static ULONG WINAPI lobbyclient_AddRef(IDirectPlay8LobbyClient *iface)
 436 {
 437     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 438     ULONG ref = InterlockedIncrement(&This->ref);
 439
 440     TRACE("(%p) ref=%u\n", This, ref);
 441
 442     return ref;
 443 }
 444
 445 static ULONG WINAPI lobbyclient_Release(IDirectPlay8LobbyClient *iface)
 446 {
 447     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 448     ULONG ref = InterlockedDecrement(&This->ref);
 449
 450     TRACE("(%p) ref=%u\n", This, ref);
 451
 452     if (!ref)
 453     {
 454         HeapFree(GetProcessHeap(), 0, This);
 455     }
 456
 457     return ref;
 458 }
 459
 460 static HRESULT WINAPI lobbyclient_Initialize(IDirectPlay8LobbyClient *iface, void *context,
 461                                              PFNDPNMESSAGEHANDLER msghandler, DWORD flags)
 462 {
 463     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 464
 465     TRACE("(%p):(%p,%p,%x)\n", This, context, msghandler, flags);
 466
 467     if(!msghandler)
 468         return E_POINTER;
 469
 470     This->usercontext = context;
 471     This->msghandler = msghandler;
 472     This->flags = flags;
 473
 474     init_winsock();
 475
 476     return DPN_OK;
 477 }
 478
 479 static HRESULT WINAPI lobbyclient_EnumLocalPrograms(IDirectPlay8LobbyClient *iface, GUID* guidapplication,
 480                                                     BYTE *enumdata, DWORD *enumDataSize, DWORD *items, DWORD flags)
 481 {
 482     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 483
 484     FIXME("(%p)->(%p %p %p %p 0x%08x)\n", This, guidapplication, enumdata, enumDataSize, items, flags);
 485
 486     if(enumDataSize)
 487         *enumDataSize = 0;
 488
 489     return S_OK;
 490 }
 491
 492 static HRESULT WINAPI lobbyclient_ConnectApplication(IDirectPlay8LobbyClient *iface, DPL_CONNECT_INFO *connectioninfo,
 493                                                      void *connectioncontext, DPNHANDLE *application, DWORD timeout,
 494                                                      DWORD flags)
 495 {
 496     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 497
 498     FIXME("(%p)->(%p %p %p %u 0x%08x)\n", This, connectioninfo, connectioncontext, application, timeout, flags);
 499
 500     return E_NOTIMPL;
 501 }
 502
 503 static HRESULT WINAPI lobbyclient_Send(IDirectPlay8LobbyClient *iface, DPNHANDLE connection, BYTE *buffer, DWORD buffersize, DWORD flags)
 504 {
 505     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 506
 507     FIXME("(%p)->(%u %p %u 0x%08x)\n", This, connection, buffer, buffersize, flags);
 508
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI lobbyclient_ReleaseApplication(IDirectPlay8LobbyClient *iface, DPNHANDLE connection, DWORD flags)
 513 {
 514     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 515
 516     FIXME("(%p)->(%u 0x%08x)\n", This, connection, flags);
 517
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI lobbyclient_Close(IDirectPlay8LobbyClient *iface, DWORD flags)
 522 {
 523     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 524
 525     FIXME("(%p)->(0x%08x)\n", This, flags);
 526
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI lobbyclient_GetConnectionSettings(IDirectPlay8LobbyClient *iface, DPNHANDLE connection, DPL_CONNECTION_SETTINGS *sessioninfo, DWORD *infosize, DWORD flags)
 531 {
 532     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 533
 534     FIXME("(%p)->(%u %p %p 0x%08x)\n", This, connection, sessioninfo, infosize, flags);
 535
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI lobbyclient_SetConnectionSettings(IDirectPlay8LobbyClient *iface, DPNHANDLE connection, const DPL_CONNECTION_SETTINGS *sessioninfo, DWORD flags)
 540 {
 541     IDirectPlay8LobbyClientImpl *This = impl_from_IDirectPlay8LobbyClient(iface);
 542
 543     FIXME("(%p)->(%u %p 0x%08x)\n", This, connection, sessioninfo, flags);
 544
 545     return E_NOTIMPL;
 546 }
 547
 548 static const IDirectPlay8LobbyClientVtbl DirectPlay8LobbiedClient_Vtbl =
 549 {
 550     lobbyclient_QueryInterface,
 551     lobbyclient_AddRef,
 552     lobbyclient_Release,
 553     lobbyclient_Initialize,
 554     lobbyclient_EnumLocalPrograms,
 555     lobbyclient_ConnectApplication,
 556     lobbyclient_Send,
 557     lobbyclient_ReleaseApplication,
 558     lobbyclient_Close,
 559     lobbyclient_GetConnectionSettings,
 560     lobbyclient_SetConnectionSettings
 561 };
 562
 563 HRESULT DPNET_CreateDirectPlay8LobbyClient(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
 564 {
 565     IDirectPlay8LobbyClientImpl *client;
 566     HRESULT ret;
 567
 568     TRACE("%p (%p, %s, %p)\n", iface, outer, debugstr_guid(riid), obj);
 569
 570     client = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*client));
 571     if (!client)
 572     {
 573         *obj = NULL;
 574         return E_OUTOFMEMORY;
 575     }
 576
 577     client->IDirectPlay8LobbyClient_iface.lpVtbl = &DirectPlay8LobbiedClient_Vtbl;
 578     client->ref = 1;
 579
 580     ret = lobbyclient_QueryInterface(&client->IDirectPlay8LobbyClient_iface, riid, obj);
 581     lobbyclient_Release(&client->IDirectPlay8LobbyClient_iface);
 582
 583     return ret;
 584 }