dlls/dplayx/dplaysp.c

   1 /* This contains the implementation of the interface Service
   2  * Providers require to communicate with Direct Play
   3  *
   4  * Copyright 2000 Peter Hunnisett
   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 #include <string.h>
  22 #include "winerror.h"
  23 #include "wine/debug.h"
  24
  25 #include "dpinit.h"
  26 #include "wine/dplaysp.h"
  27 #include "dplay_global.h"
  28 #include "name_server.h"
  29 #include "dplayx_messages.h"
  30
  31 #include "dplayx_global.h" /* FIXME: For global hack */
  32
  33 /* FIXME: Need to add interface locking inside procedures */
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(dplay);
  36
  37 /* Prototypes */
  38 static BOOL DPSP_CreateIUnknown( LPVOID lpSP );
  39 static BOOL DPSP_DestroyIUnknown( LPVOID lpSP );
  40 static BOOL DPSP_CreateDirectPlaySP( LPVOID lpSP, IDirectPlay2Impl* dp );
  41 static BOOL DPSP_DestroyDirectPlaySP( LPVOID lpSP );
  42
  43 /* Predefine the interface */
  44 typedef struct IDirectPlaySPImpl IDirectPlaySPImpl;
  45
  46 typedef struct tagDirectPlaySPIUnknownData
  47 {
  48   LONG              ulObjRef;
  49   CRITICAL_SECTION  DPSP_lock;
  50 } DirectPlaySPIUnknownData;
  51
  52 typedef struct tagDirectPlaySPData
  53 {
  54   LPVOID lpSpRemoteData;
  55   DWORD  dwSpRemoteDataSize; /* Size of data pointed to by lpSpRemoteData */
  56
  57   LPVOID lpSpLocalData;
  58   DWORD  dwSpLocalDataSize; /* Size of data pointed to by lpSpLocalData */
  59
  60   IDirectPlay2Impl* dplay; /* FIXME: This should perhaps be iface not impl */
  61
  62 } DirectPlaySPData;
  63
  64 #define DPSP_IMPL_FIELDS \
  65    LONG ulInterfaceRef; \
  66    DirectPlaySPIUnknownData* unk; \
  67    DirectPlaySPData* sp;
  68
  69 struct IDirectPlaySPImpl
  70 {
  71   const IDirectPlaySPVtbl *lpVtbl;
  72   DPSP_IMPL_FIELDS
  73 };
  74
  75 /* Forward declaration of virtual tables */
  76 static const IDirectPlaySPVtbl directPlaySPVT;
  77
  78 /* This structure is passed to the DP object for safe keeping */
  79 typedef struct tagDP_SPPLAYERDATA
  80 {
  81   LPVOID lpPlayerLocalData;
  82   DWORD  dwPlayerLocalDataSize;
  83
  84   LPVOID lpPlayerRemoteData;
  85   DWORD  dwPlayerRemoteDataSize;
  86 } DP_SPPLAYERDATA, *LPDP_SPPLAYERDATA;
  87
  88 /* Create the SP interface */
  89 HRESULT DPSP_CreateInterface( REFIID riid, LPVOID* ppvObj, IDirectPlay2Impl* dp )
  90 {
  91   TRACE( " for %s\n", debugstr_guid( riid ) );
  92
  93   *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
  94                        sizeof( IDirectPlaySPImpl ) );
  95
  96   if( *ppvObj == NULL )
  97   {
  98     return DPERR_OUTOFMEMORY;
  99   }
 100
 101   if( IsEqualGUID( &IID_IDirectPlaySP, riid ) )
 102   {
 103     IDirectPlaySPImpl *This = *ppvObj;
 104     This->lpVtbl = &directPlaySPVT;
 105   }
 106   else
 107   {
 108     /* Unsupported interface */
 109     HeapFree( GetProcessHeap(), 0, *ppvObj );
 110     *ppvObj = NULL;
 111
 112     return E_NOINTERFACE;
 113   }
 114
 115   /* Initialize it */
 116   if( DPSP_CreateIUnknown( *ppvObj ) &&
 117       DPSP_CreateDirectPlaySP( *ppvObj, dp )
 118     )
 119   {
 120     IDirectPlaySP_AddRef( (LPDIRECTPLAYSP)*ppvObj );
 121     return S_OK;
 122   }
 123
 124   /* Initialize failed, destroy it */
 125   DPSP_DestroyDirectPlaySP( *ppvObj );
 126   DPSP_DestroyIUnknown( *ppvObj );
 127
 128   HeapFree( GetProcessHeap(), 0, *ppvObj );
 129   *ppvObj = NULL;
 130
 131   return DPERR_NOMEMORY;
 132 }
 133
 134 static BOOL DPSP_CreateIUnknown( LPVOID lpSP )
 135 {
 136   IDirectPlaySPImpl *This = lpSP;
 137
 138   This->unk = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *(This->unk) ) );
 139
 140   if ( This->unk == NULL )
 141   {
 142     return FALSE;
 143   }
 144
 145   InitializeCriticalSection( &This->unk->DPSP_lock );
 146   This->unk->DPSP_lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": IDirectPlaySPImpl*->DirectPlaySPIUnknownData*->DPSP_lock");
 147
 148   return TRUE;
 149 }
 150
 151 static BOOL DPSP_DestroyIUnknown( LPVOID lpSP )
 152 {
 153   IDirectPlaySPImpl *This = lpSP;
 154
 155   This->unk->DPSP_lock.DebugInfo->Spare[0] = 0;
 156   DeleteCriticalSection( &This->unk->DPSP_lock );
 157   HeapFree( GetProcessHeap(), 0, This->unk );
 158
 159   return TRUE;
 160 }
 161
 162
 163 static BOOL DPSP_CreateDirectPlaySP( LPVOID lpSP, IDirectPlay2Impl* dp )
 164 {
 165   IDirectPlaySPImpl *This = lpSP;
 166
 167   This->sp = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *(This->sp) ) );
 168
 169   if ( This->sp == NULL )
 170   {
 171     return FALSE;
 172   }
 173
 174   This->sp->dplay = dp;
 175
 176   /* Normally we should be keeping a reference, but since only the dplay
 177    * interface that created us can destroy us, we do not keep a reference
 178    * to it (ie we'd be stuck with always having one reference to the dplay
 179    * object, and hence us, around).
 180    * NOTE: The dp object does reference count us.
 181    *
 182    * FIXME: This is a kludge to get around a problem where a queryinterface
 183    *        is used to get a new interface and then is closed. We will then
 184    *        reference garbage. However, with this we will never deallocate
 185    *        the interface we store. The correct fix is to require all
 186    *        DP internal interfaces to use the This->dp2 interface which
 187    *        should be changed to This->dp
 188    */
 189   IDirectPlayX_AddRef( (LPDIRECTPLAY2)dp );
 190
 191   return TRUE;
 192 }
 193
 194 static BOOL DPSP_DestroyDirectPlaySP( LPVOID lpSP )
 195 {
 196   IDirectPlaySPImpl *This = lpSP;
 197
 198   /* Normally we should be keeping a reference, but since only the dplay
 199    * interface that created us can destroy us, we do not keep a reference
 200    * to it (ie we'd be stuck with always having one reference to the dplay
 201    * object, and hence us, around).
 202    * NOTE: The dp object does reference count us.
 203    */
 204   /*IDirectPlayX_Release( (LPDIRECTPLAY2)This->sp->dplay ); */
 205
 206   HeapFree( GetProcessHeap(), 0, This->sp->lpSpRemoteData );
 207   HeapFree( GetProcessHeap(), 0, This->sp->lpSpLocalData );
 208
 209   /* FIXME: Need to delete player queue */
 210
 211   HeapFree( GetProcessHeap(), 0, This->sp );
 212   return TRUE;
 213 }
 214
 215 /* Interface implementation */
 216
 217 static HRESULT WINAPI DPSP_QueryInterface
 218 ( LPDIRECTPLAYSP iface,
 219   REFIID riid,
 220   LPVOID* ppvObj )
 221 {
 222   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 223   TRACE("(%p)->(%s,%p)\n", This, debugstr_guid( riid ), ppvObj );
 224
 225   *ppvObj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 226                        sizeof( *This ) );
 227
 228   if( *ppvObj == NULL )
 229   {
 230     return DPERR_OUTOFMEMORY;
 231   }
 232
 233   CopyMemory( *ppvObj, This, sizeof( *This )  );
 234   (*(IDirectPlaySPImpl**)ppvObj)->ulInterfaceRef = 0;
 235
 236   if( IsEqualGUID( &IID_IDirectPlaySP, riid ) )
 237   {
 238     IDirectPlaySPImpl *This = *ppvObj;
 239     This->lpVtbl = &directPlaySPVT;
 240   }
 241   else
 242   {
 243     /* Unsupported interface */
 244     HeapFree( GetProcessHeap(), 0, *ppvObj );
 245     *ppvObj = NULL;
 246
 247     return E_NOINTERFACE;
 248   }
 249
 250   IDirectPlaySP_AddRef( (LPDIRECTPLAYSP)*ppvObj );
 251
 252   return S_OK;
 253 }
 254
 255 static ULONG WINAPI DPSP_AddRef
 256 ( LPDIRECTPLAYSP iface )
 257 {
 258   ULONG ulInterfaceRefCount, ulObjRefCount;
 259   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 260
 261   ulObjRefCount       = InterlockedIncrement( &This->unk->ulObjRef );
 262   ulInterfaceRefCount = InterlockedIncrement( &This->ulInterfaceRef );
 263
 264   TRACE( "ref count incremented to %u:%u for %p\n",
 265          ulInterfaceRefCount, ulObjRefCount, This );
 266
 267   return ulObjRefCount;
 268 }
 269
 270 static ULONG WINAPI DPSP_Release
 271 ( LPDIRECTPLAYSP iface )
 272 {
 273   ULONG ulInterfaceRefCount, ulObjRefCount;
 274   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 275
 276   ulObjRefCount       = InterlockedDecrement( &This->unk->ulObjRef );
 277   ulInterfaceRefCount = InterlockedDecrement( &This->ulInterfaceRef );
 278
 279   TRACE( "ref count decremented to %u:%u for %p\n",
 280          ulInterfaceRefCount, ulObjRefCount, This );
 281
 282   /* Deallocate if this is the last reference to the object */
 283   if( ulObjRefCount == 0 )
 284   {
 285      DPSP_DestroyDirectPlaySP( This );
 286      DPSP_DestroyIUnknown( This );
 287   }
 288
 289   if( ulInterfaceRefCount == 0 )
 290   {
 291     HeapFree( GetProcessHeap(), 0, This );
 292   }
 293
 294   return ulInterfaceRefCount;
 295 }
 296
 297 static HRESULT WINAPI IDirectPlaySPImpl_AddMRUEntry
 298 ( LPDIRECTPLAYSP iface,
 299   LPCWSTR lpSection,
 300   LPCWSTR lpKey,
 301   LPCVOID lpData,
 302   DWORD   dwDataSize,
 303   DWORD   dwMaxEntries
 304 )
 305 {
 306   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 307
 308   /* Should be able to call the comctl32 undocumented MRU routines.
 309      I suspect that the interface works appropriately */
 310   FIXME( "(%p)->(%p,%p%p,0x%08x,0x%08x): stub\n",
 311          This, lpSection, lpKey, lpData, dwDataSize, dwMaxEntries );
 312
 313   return DP_OK;
 314 }
 315
 316 static HRESULT WINAPI IDirectPlaySPImpl_CreateAddress
 317 ( LPDIRECTPLAYSP iface,
 318   REFGUID guidSP,
 319   REFGUID guidDataType,
 320   LPCVOID lpData,
 321   DWORD   dwDataSize,
 322   LPVOID  lpAddress,
 323   LPDWORD lpdwAddressSize
 324 )
 325 {
 326   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 327
 328   FIXME( "(%p)->(%s,%s,%p,0x%08x,%p,%p): stub\n",
 329          This, debugstr_guid(guidSP), debugstr_guid(guidDataType),
 330          lpData, dwDataSize, lpAddress, lpdwAddressSize );
 331
 332   return DP_OK;
 333 }
 334
 335 static HRESULT WINAPI IDirectPlaySPImpl_EnumAddress
 336 ( LPDIRECTPLAYSP iface,
 337   LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
 338   LPCVOID lpAddress,
 339   DWORD dwAddressSize,
 340   LPVOID lpContext
 341 )
 342 {
 343   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 344
 345   TRACE( "(%p)->(%p,%p,0x%08x,%p)\n",
 346          This, lpEnumAddressCallback, lpAddress, dwAddressSize, lpContext );
 347
 348   DPL_EnumAddress( lpEnumAddressCallback, lpAddress, dwAddressSize, lpContext );
 349
 350   return DP_OK;
 351 }
 352
 353 static HRESULT WINAPI IDirectPlaySPImpl_EnumMRUEntries
 354 ( LPDIRECTPLAYSP iface,
 355   LPCWSTR lpSection,
 356   LPCWSTR lpKey,
 357   LPENUMMRUCALLBACK lpEnumMRUCallback,
 358   LPVOID lpContext
 359 )
 360 {
 361   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 362
 363   /* Should be able to call the comctl32 undocumented MRU routines.
 364      I suspect that the interface works appropriately */
 365   FIXME( "(%p)->(%p,%p,%p,%p,): stub\n",
 366          This, lpSection, lpKey, lpEnumMRUCallback, lpContext );
 367
 368   return DP_OK;
 369 }
 370
 371 static HRESULT WINAPI IDirectPlaySPImpl_GetPlayerFlags
 372 ( LPDIRECTPLAYSP iface,
 373   DPID idPlayer,
 374   LPDWORD lpdwPlayerFlags
 375 )
 376 {
 377   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 378
 379   FIXME( "(%p)->(0x%08x,%p): stub\n",
 380          This, idPlayer, lpdwPlayerFlags );
 381
 382   return DP_OK;
 383 }
 384
 385 static HRESULT WINAPI IDirectPlaySPImpl_GetSPPlayerData
 386 ( LPDIRECTPLAYSP iface,
 387   DPID idPlayer,
 388   LPVOID* lplpData,
 389   LPDWORD lpdwDataSize,
 390   DWORD dwFlags
 391 )
 392 {
 393   HRESULT hr;
 394   LPDP_SPPLAYERDATA lpPlayerData;
 395   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 396
 397   TRACE( "(%p)->(0x%08x,%p,%p,0x%08x)\n",
 398          This, idPlayer, lplpData, lpdwDataSize, dwFlags );
 399
 400   hr = DP_GetSPPlayerData( This->sp->dplay, idPlayer, (LPVOID*)&lpPlayerData );
 401
 402   if( FAILED(hr) )
 403   {
 404     ERR( "Couldn't get player data: %s\n", DPLAYX_HresultToString(hr) );
 405     return hr;
 406   }
 407
 408   if( dwFlags == DPSET_LOCAL )
 409   {
 410     *lplpData     = lpPlayerData->lpPlayerLocalData;
 411     *lpdwDataSize = lpPlayerData->dwPlayerLocalDataSize;
 412   }
 413   else if( dwFlags == DPSET_REMOTE )
 414   {
 415     *lplpData     = lpPlayerData->lpPlayerRemoteData;
 416     *lpdwDataSize = lpPlayerData->dwPlayerRemoteDataSize;
 417   }
 418
 419   return DP_OK;
 420 }
 421
 422 static HRESULT WINAPI IDirectPlaySPImpl_HandleMessage
 423 ( LPDIRECTPLAYSP iface,
 424   LPVOID lpMessageBody,
 425   DWORD  dwMessageBodySize,
 426   LPVOID lpMessageHeader
 427 )
 428 {
 429   LPDPSP_MSG_ENVELOPE lpMsg = lpMessageBody;
 430   DPSP_REPLYDATA data;
 431   HRESULT hr;
 432
 433   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 434
 435   TRACE( "(%p)->(%p,0x%08x,%p)\n",
 436          This, lpMessageBody, dwMessageBodySize, lpMessageHeader );
 437
 438   TRACE( "Incoming message has envelope of 0x%08x, 0x%x, %u\n",
 439          lpMsg->dwMagic, lpMsg->wCommandId, lpMsg->wVersion );
 440
 441   if( lpMsg->dwMagic != DPMSG_SIGNATURE )
 442   {
 443     ERR( "Unknown magic 0x%08x!\n", lpMsg->dwMagic );
 444     return DPERR_GENERIC;
 445   }
 446
 447   /* Pass everything else to Direct Play */
 448   data.lpMessage     = NULL;
 449   data.dwMessageSize = 0;
 450
 451   /* Pass this message to the dplay interface to handle */
 452   hr = DP_HandleMessage( This->sp->dplay, lpMessageBody, dwMessageBodySize,
 453                          lpMessageHeader, lpMsg->wCommandId, lpMsg->wVersion,
 454                          &data.lpMessage, &data.dwMessageSize );
 455   if( FAILED(hr) )
 456   {
 457     ERR( "Command processing failed %s\n", DPLAYX_HresultToString(hr) );
 458   }
 459
 460   /* Do we want a reply? */
 461   if( data.lpMessage != NULL )
 462   {
 463     data.lpSPMessageHeader = lpMessageHeader;
 464     data.idNameServer      = 0;
 465     data.lpISP             = iface;
 466
 467     hr = (This->sp->dplay->dp2->spData.lpCB->Reply)( &data );
 468
 469     if( FAILED(hr) )
 470     {
 471       ERR( "Reply failed %s\n", DPLAYX_HresultToString(hr) );
 472     }
 473   }
 474
 475   return hr;
 476 }
 477
 478 static HRESULT WINAPI IDirectPlaySPImpl_SetSPPlayerData
 479 ( LPDIRECTPLAYSP iface,
 480   DPID idPlayer,
 481   LPVOID lpData,
 482   DWORD dwDataSize,
 483   DWORD dwFlags
 484 )
 485 {
 486   HRESULT           hr;
 487   LPDP_SPPLAYERDATA lpPlayerEntry;
 488   LPVOID            lpPlayerData;
 489
 490   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 491
 492   TRACE( "(%p)->(0x%08x,%p,0x%08x,0x%08x)\n",
 493          This, idPlayer, lpData, dwDataSize, dwFlags );
 494
 495   hr = DP_GetSPPlayerData( This->sp->dplay, idPlayer, (LPVOID*)&lpPlayerEntry );
 496   if( FAILED(hr) )
 497   {
 498     /* Player must not exist */
 499     return DPERR_INVALIDPLAYER;
 500   }
 501
 502   lpPlayerData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
 503   CopyMemory( lpPlayerData, lpData, dwDataSize );
 504
 505   /* If we have data already allocated, free it and replace it */
 506   if( dwFlags == DPSET_LOCAL )
 507   {
 508     HeapFree( GetProcessHeap(), 0, lpPlayerEntry->lpPlayerLocalData );
 509     lpPlayerEntry->lpPlayerLocalData = lpPlayerData;
 510     lpPlayerEntry->dwPlayerLocalDataSize = dwDataSize;
 511   }
 512   else if( dwFlags == DPSET_REMOTE )
 513   {
 514     HeapFree( GetProcessHeap(), 0, lpPlayerEntry->lpPlayerRemoteData );
 515     lpPlayerEntry->lpPlayerRemoteData = lpPlayerData;
 516     lpPlayerEntry->dwPlayerRemoteDataSize = dwDataSize;
 517   }
 518
 519   hr = DP_SetSPPlayerData( This->sp->dplay, idPlayer, lpPlayerEntry );
 520
 521   return hr;
 522 }
 523
 524 static HRESULT WINAPI IDirectPlaySPImpl_CreateCompoundAddress
 525 ( LPDIRECTPLAYSP iface,
 526   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
 527   DWORD dwElementCount,
 528   LPVOID lpAddress,
 529   LPDWORD lpdwAddressSize
 530 )
 531 {
 532   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 533
 534   FIXME( "(%p)->(%p,0x%08x,%p,%p): stub\n",
 535          This, lpElements, dwElementCount, lpAddress, lpdwAddressSize );
 536
 537   return DP_OK;
 538 }
 539
 540 static HRESULT WINAPI IDirectPlaySPImpl_GetSPData
 541 ( LPDIRECTPLAYSP iface,
 542   LPVOID* lplpData,
 543   LPDWORD lpdwDataSize,
 544   DWORD dwFlags
 545 )
 546 {
 547   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 548
 549   TRACE( "(%p)->(%p,%p,0x%08x)\n",
 550          This, lplpData, lpdwDataSize, dwFlags );
 551
 552   if( dwFlags == DPSET_REMOTE )
 553   {
 554     *lpdwDataSize = This->sp->dwSpRemoteDataSize;
 555     *lplpData     = This->sp->lpSpRemoteData;
 556   }
 557   else if( dwFlags == DPSET_LOCAL )
 558   {
 559     *lpdwDataSize = This->sp->dwSpLocalDataSize;
 560     *lplpData     = This->sp->lpSpLocalData;
 561   }
 562
 563   return DP_OK;
 564 }
 565
 566 static HRESULT WINAPI IDirectPlaySPImpl_SetSPData
 567 ( LPDIRECTPLAYSP iface,
 568   LPVOID lpData,
 569   DWORD dwDataSize,
 570   DWORD dwFlags
 571 )
 572 {
 573   LPVOID lpSpData;
 574
 575   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 576
 577   TRACE( "(%p)->(%p,%d,0x%08x)\n",
 578          This, lpData, dwDataSize, dwFlags );
 579
 580   lpSpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
 581   CopyMemory( lpSpData, lpData, dwDataSize );
 582
 583   /* If we have data already allocated, free it and replace it */
 584   if( dwFlags == DPSET_REMOTE )
 585   {
 586     HeapFree( GetProcessHeap(), 0, This->sp->lpSpRemoteData );
 587     This->sp->dwSpRemoteDataSize = dwDataSize;
 588     This->sp->lpSpRemoteData = lpSpData;
 589   }
 590   else if ( dwFlags == DPSET_LOCAL )
 591   {
 592     HeapFree( GetProcessHeap(), 0, This->sp->lpSpLocalData );
 593     This->sp->lpSpLocalData     = lpSpData;
 594     This->sp->dwSpLocalDataSize = dwDataSize;
 595   }
 596
 597   return DP_OK;
 598 }
 599
 600 static VOID WINAPI IDirectPlaySPImpl_SendComplete
 601 ( LPDIRECTPLAYSP iface,
 602   LPVOID unknownA,
 603   DWORD unknownB
 604 )
 605 {
 606   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 607
 608   FIXME( "(%p)->(%p,0x%08x): stub\n",
 609          This, unknownA, unknownB );
 610 }
 611
 612 static const IDirectPlaySPVtbl directPlaySPVT =
 613 {
 614
 615   DPSP_QueryInterface,
 616   DPSP_AddRef,
 617   DPSP_Release,
 618
 619   IDirectPlaySPImpl_AddMRUEntry,
 620   IDirectPlaySPImpl_CreateAddress,
 621   IDirectPlaySPImpl_EnumAddress,
 622   IDirectPlaySPImpl_EnumMRUEntries,
 623   IDirectPlaySPImpl_GetPlayerFlags,
 624   IDirectPlaySPImpl_GetSPPlayerData,
 625   IDirectPlaySPImpl_HandleMessage,
 626   IDirectPlaySPImpl_SetSPPlayerData,
 627   IDirectPlaySPImpl_CreateCompoundAddress,
 628   IDirectPlaySPImpl_GetSPData,
 629   IDirectPlaySPImpl_SetSPData,
 630   IDirectPlaySPImpl_SendComplete
 631 };
 632
 633
 634 /* DP external interfaces to call into DPSP interface */
 635
 636 /* Allocate the structure */
 637 LPVOID DPSP_CreateSPPlayerData(void)
 638 {
 639   TRACE( "Creating SPPlayer data struct\n" );
 640   return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 641                     sizeof( DP_SPPLAYERDATA ) );
 642 }