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