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     TRACE( "Couldn't get player data: %s\n", DPLAYX_HresultToString(hr) );
 405     return DPERR_INVALIDPLAYER;
 406   }
 407
 408   /* What to do in the case where there is nothing set yet? */
 409   if( dwFlags == DPSET_LOCAL )
 410   {
 411     HeapFree( GetProcessHeap(), 0, lpPlayerData->lpPlayerLocalData );
 412     *lplpData     = lpPlayerData->lpPlayerLocalData;
 413     *lpdwDataSize = lpPlayerData->dwPlayerLocalDataSize;
 414   }
 415   else if( dwFlags == DPSET_REMOTE )
 416   {
 417     HeapFree( GetProcessHeap(), 0, lpPlayerData->lpPlayerRemoteData );
 418     *lplpData     = lpPlayerData->lpPlayerRemoteData;
 419     *lpdwDataSize = lpPlayerData->dwPlayerRemoteDataSize;
 420   }
 421
 422   if( *lplpData == NULL )
 423   {
 424     hr = DPERR_GENERIC;
 425   }
 426
 427   return hr;
 428 }
 429
 430 static HRESULT WINAPI IDirectPlaySPImpl_HandleMessage
 431 ( LPDIRECTPLAYSP iface,
 432   LPVOID lpMessageBody,
 433   DWORD  dwMessageBodySize,
 434   LPVOID lpMessageHeader
 435 )
 436 {
 437   LPDPMSG_SENDENVELOPE lpMsg = lpMessageBody;
 438   HRESULT hr = DPERR_GENERIC;
 439   WORD wCommandId;
 440   WORD wVersion;
 441   DPSP_REPLYDATA data;
 442
 443   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 444
 445   FIXME( "(%p)->(%p,0x%08x,%p): mostly stub\n",
 446          This, lpMessageBody, dwMessageBodySize, lpMessageHeader );
 447
 448   wCommandId = lpMsg->wCommandId;
 449   wVersion   = lpMsg->wVersion;
 450
 451   TRACE( "Incoming message has envelope of 0x%08x, %u, %u\n",
 452          lpMsg->dwMagic, wCommandId, wVersion );
 453
 454   if( lpMsg->dwMagic != DPMSGMAGIC_DPLAYMSG )
 455   {
 456     ERR( "Unknown magic 0x%08x!\n", lpMsg->dwMagic );
 457     return DPERR_GENERIC;
 458   }
 459
 460 #if 0
 461   {
 462     const LPDWORD lpcHeader = lpMessageHeader;
 463
 464     TRACE( "lpMessageHeader = [0x%08lx] [0x%08lx] [0x%08lx] [0x%08lx] [0x%08lx]\n",
 465            lpcHeader[0], lpcHeader[1], lpcHeader[2], lpcHeader[3], lpcHeader[4] );
 466    }
 467 #endif
 468
 469   /* Pass everything else to Direct Play */
 470   data.lpMessage     = NULL;
 471   data.dwMessageSize = 0;
 472
 473   /* Pass this message to the dplay interface to handle */
 474   hr = DP_HandleMessage( This->sp->dplay, lpMessageBody, dwMessageBodySize,
 475                          lpMessageHeader, wCommandId, wVersion,
 476                          &data.lpMessage, &data.dwMessageSize );
 477
 478   if( FAILED(hr) )
 479   {
 480     ERR( "Command processing failed %s\n", DPLAYX_HresultToString(hr) );
 481   }
 482
 483   /* Do we want a reply? */
 484   if( data.lpMessage != NULL )
 485   {
 486     data.lpSPMessageHeader = lpMessageHeader;
 487     data.idNameServer      = 0;
 488     data.lpISP             = iface;
 489
 490     hr = (This->sp->dplay->dp2->spData.lpCB->Reply)( &data );
 491
 492     if( FAILED(hr) )
 493     {
 494       ERR( "Reply failed %s\n", DPLAYX_HresultToString(hr) );
 495     }
 496   }
 497
 498   return hr;
 499
 500 #if 0
 501   HRESULT hr = DP_OK;
 502   HANDLE  hReceiveEvent = 0;
 503   /* FIXME: Acquire some sort of interface lock */
 504   /* FIXME: Need some sort of context for this callback. Need to determine
 505    *        how this is actually done with the SP
 506    */
 507   /* FIXME: Who needs to delete the message when done? */
 508   switch( lpMsg->dwType )
 509   {
 510     case DPSYS_CREATEPLAYERORGROUP:
 511     {
 512       LPDPMSG_CREATEPLAYERORGROUP msg = lpMsg;
 513
 514       if( msg->dwPlayerType == DPPLAYERTYPE_PLAYER )
 515       {
 516         hr = DP_IF_CreatePlayer( This, lpMessageHeader, msg->dpId,
 517                                  &msg->dpnName, 0, msg->lpData,
 518                                  msg->dwDataSize, msg->dwFlags, ... );
 519       }
 520       else if( msg->dwPlayerType == DPPLAYERTYPE_GROUP )
 521       {
 522         /* Group in group situation? */
 523         if( msg->dpIdParent == DPID_NOPARENT_GROUP )
 524         {
 525           hr = DP_IF_CreateGroup( This, lpMessageHeader, msg->dpId,
 526                                   &msg->dpnName, 0, msg->lpData,
 527                                   msg->dwDataSize, msg->dwFlags, ... );
 528         }
 529         else /* Group in Group */
 530         {
 531           hr = DP_IF_CreateGroupInGroup( This, lpMessageHeader, msg->dpIdParent,
 532                                          &msg->dpnName, 0, msg->lpData,
 533                                          msg->dwDataSize, msg->dwFlags, ... );
 534         }
 535       }
 536       else /* Hmmm? */
 537       {
 538         ERR( "Corrupt msg->dwPlayerType for DPSYS_CREATEPLAYERORGROUP\n" );
 539         return;
 540       }
 541
 542       break;
 543     }
 544
 545     case DPSYS_DESTROYPLAYERORGROUP:
 546     {
 547       LPDPMSG_DESTROYPLAYERORGROUP msg = lpMsg;
 548
 549       if( msg->dwPlayerType == DPPLAYERTYPE_PLAYER )
 550       {
 551         hr = DP_IF_DestroyPlayer( This, msg->dpId, ... );
 552       }
 553       else if( msg->dwPlayerType == DPPLAYERTYPE_GROUP )
 554       {
 555         hr = DP_IF_DestroyGroup( This, msg->dpId, ... );
 556       }
 557       else /* Hmmm? */
 558       {
 559         ERR( "Corrupt msg->dwPlayerType for DPSYS_DESTROYPLAYERORGROUP\n" );
 560         return;
 561       }
 562
 563       break;
 564     }
 565
 566     case DPSYS_ADDPLAYERTOGROUP:
 567     {
 568       LPDPMSG_ADDPLAYERTOGROUP msg = lpMsg;
 569
 570       hr = DP_IF_AddPlayerToGroup( This, msg->dpIdGroup, msg->dpIdPlayer, ... );
 571       break;
 572     }
 573
 574     case DPSYS_DELETEPLAYERFROMGROUP:
 575     {
 576       LPDPMSG_DELETEPLAYERFROMGROUP msg = lpMsg;
 577
 578       hr = DP_IF_DeletePlayerFromGroup( This, msg->dpIdGroup, msg->dpIdPlayer,
 579                                         ... );
 580
 581       break;
 582     }
 583
 584     case DPSYS_SESSIONLOST:
 585     {
 586       LPDPMSG_SESSIONLOST msg = lpMsg;
 587
 588       FIXME( "DPSYS_SESSIONLOST not handled\n" );
 589
 590       break;
 591     }
 592
 593     case DPSYS_HOST:
 594     {
 595       LPDPMSG_HOST msg = lpMsg;
 596
 597       FIXME( "DPSYS_HOST not handled\n" );
 598
 599       break;
 600     }
 601
 602     case DPSYS_SETPLAYERORGROUPDATA:
 603     {
 604       LPDPMSG_SETPLAYERORGROUPDATA msg = lpMsg;
 605
 606       if( msg->dwPlayerType == DPPLAYERTYPE_PLAYER )
 607       {
 608         hr = DP_IF_SetPlayerData( This, msg->dpId, msg->lpData, msg->dwDataSize,                                  DPSET_REMOTE, ... );
 609       }
 610       else if( msg->dwPlayerType == DPPLAYERTYPE_GROUP )
 611       {
 612         hr = DP_IF_SetGroupData( This, msg->dpId, msg->lpData, msg->dwDataSize,
 613                                  DPSET_REMOTE, ... );
 614       }
 615       else /* Hmmm? */
 616       {
 617         ERR( "Corrupt msg->dwPlayerType for LPDPMSG_SETPLAYERORGROUPDATA\n" );
 618         return;
 619       }
 620
 621       break;
 622     }
 623
 624     case DPSYS_SETPLAYERORGROUPNAME:
 625     {
 626       LPDPMSG_SETPLAYERORGROUPNAME msg = lpMsg;
 627
 628       if( msg->dwPlayerType == DPPLAYERTYPE_PLAYER )
 629       {
 630         hr = DP_IF_SetPlayerName( This, msg->dpId, msg->dpnName, ... );
 631       }
 632       else if( msg->dwPlayerType == DPPLAYERTYPE_GROUP )
 633       {
 634         hr = DP_IF_SetGroupName( This, msg->dpId, msg->dpnName, ... );
 635       }
 636       else /* Hmmm? */
 637       {
 638         ERR( "Corrupt msg->dwPlayerType for LPDPMSG_SETPLAYERORGROUPDATA\n" );
 639         return;
 640       }
 641
 642       break;
 643     }
 644
 645     case DPSYS_SETSESSIONDESC;
 646     {
 647       LPDPMSG_SETSESSIONDESC msg = lpMsg;
 648
 649       hr = DP_IF_SetSessionDesc( This, &msg->dpDesc );
 650
 651       break;
 652     }
 653
 654     case DPSYS_ADDGROUPTOGROUP:
 655     {
 656       LPDPMSG_ADDGROUPTOGROUP msg = lpMsg;
 657
 658       hr = DP_IF_AddGroupToGroup( This, msg->dpIdParentGroup, msg->dpIdGroup,
 659                                   ... );
 660
 661       break;
 662     }
 663
 664     case DPSYS_DELETEGROUPFROMGROUP:
 665     {
 666       LPDPMSG_DELETEGROUPFROMGROUP msg = lpMsg;
 667
 668       hr = DP_IF_DeleteGroupFromGroup( This, msg->dpIdParentGroup,
 669                                        msg->dpIdGroup, ... );
 670
 671       break;
 672     }
 673
 674     case DPSYS_SECUREMESSAGE:
 675     {
 676       LPDPMSG_SECUREMESSAGE msg = lpMsg;
 677
 678       FIXME( "DPSYS_SECUREMESSAGE not implemented\n" );
 679
 680       break;
 681     }
 682
 683     case DPSYS_STARTSESSION:
 684     {
 685       LPDPMSG_STARTSESSION msg = lpMsg;
 686
 687       FIXME( "DPSYS_STARTSESSION not implemented\n" );
 688
 689       break;
 690     }
 691
 692     case DPSYS_CHAT:
 693     {
 694       LPDPMSG_CHAT msg = lpMsg;
 695
 696       FIXME( "DPSYS_CHAT not implemeneted\n" );
 697
 698       break;
 699     }
 700
 701     case DPSYS_SETGROUPOWNER:
 702     {
 703       LPDPMSG_SETGROUPOWNER msg = lpMsg;
 704
 705       FIXME( "DPSYS_SETGROUPOWNER not implemented\n" );
 706
 707       break;
 708     }
 709
 710     case DPSYS_SENDCOMPLETE:
 711     {
 712       LPDPMSG_SENDCOMPLETE msg = lpMsg;
 713
 714       FIXME( "DPSYS_SENDCOMPLETE not implemented\n" );
 715
 716       break;
 717     }
 718
 719     default:
 720     {
 721       /* NOTE: This should be a user defined type. There is nothing that we
 722        *       need to do with it except queue it.
 723        */
 724       TRACE( "Received user message type(?) 0x%08lx through SP.\n",
 725               lpMsg->dwType );
 726       break;
 727     }
 728   }
 729
 730   FIXME( "Queue message in the receive queue. Need some context data!\n" );
 731
 732   if( FAILED(hr) )
 733   {
 734     ERR( "Unable to perform action for msg type 0x%08lx\n", lpMsg->dwType );
 735   }
 736   /* If a receive event was registered for this player, invoke it */
 737   if( hReceiveEvent )
 738   {
 739     SetEvent( hReceiveEvent );
 740   }
 741 #endif
 742 }
 743
 744 static HRESULT WINAPI IDirectPlaySPImpl_SetSPPlayerData
 745 ( LPDIRECTPLAYSP iface,
 746   DPID idPlayer,
 747   LPVOID lpData,
 748   DWORD dwDataSize,
 749   DWORD dwFlags
 750 )
 751 {
 752   HRESULT           hr;
 753   LPDP_SPPLAYERDATA lpPlayerEntry;
 754   LPVOID            lpPlayerData;
 755
 756   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 757
 758 /*  TRACE( "Called on process 0x%08lx\n", GetCurrentProcessId() ); */
 759   TRACE( "(%p)->(0x%08x,%p,0x%08x,0x%08x)\n",
 760          This, idPlayer, lpData, dwDataSize, dwFlags );
 761
 762   hr = DP_GetSPPlayerData( This->sp->dplay, idPlayer, (LPVOID*)&lpPlayerEntry );
 763   if( FAILED(hr) )
 764   {
 765     /* Player must not exist */
 766     return DPERR_INVALIDPLAYER;
 767   }
 768
 769   lpPlayerData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
 770   CopyMemory( lpPlayerData, lpData, dwDataSize );
 771
 772   if( dwFlags == DPSET_LOCAL )
 773   {
 774     lpPlayerEntry->lpPlayerLocalData = lpPlayerData;
 775     lpPlayerEntry->dwPlayerLocalDataSize = dwDataSize;
 776   }
 777   else if( dwFlags == DPSET_REMOTE )
 778   {
 779     lpPlayerEntry->lpPlayerRemoteData = lpPlayerData;
 780     lpPlayerEntry->dwPlayerRemoteDataSize = dwDataSize;
 781   }
 782
 783   hr = DP_SetSPPlayerData( This->sp->dplay, idPlayer, lpPlayerEntry );
 784
 785   return hr;
 786 }
 787
 788 static HRESULT WINAPI IDirectPlaySPImpl_CreateCompoundAddress
 789 ( LPDIRECTPLAYSP iface,
 790   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
 791   DWORD dwElementCount,
 792   LPVOID lpAddress,
 793   LPDWORD lpdwAddressSize
 794 )
 795 {
 796   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 797
 798   FIXME( "(%p)->(%p,0x%08x,%p,%p): stub\n",
 799          This, lpElements, dwElementCount, lpAddress, lpdwAddressSize );
 800
 801   return DP_OK;
 802 }
 803
 804 static HRESULT WINAPI IDirectPlaySPImpl_GetSPData
 805 ( LPDIRECTPLAYSP iface,
 806   LPVOID* lplpData,
 807   LPDWORD lpdwDataSize,
 808   DWORD dwFlags
 809 )
 810 {
 811   HRESULT hr = DP_OK;
 812   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 813
 814 /*  TRACE( "Called on process 0x%08lx\n", GetCurrentProcessId() ); */
 815   TRACE( "(%p)->(%p,%p,0x%08x)\n",
 816          This, lplpData, lpdwDataSize, dwFlags );
 817
 818 #if 0
 819   /* This is what the documentation says... */
 820   if( dwFlags != DPSET_REMOTE )
 821   {
 822     return DPERR_INVALIDPARAMS;
 823   }
 824 #else
 825   /* ... but most service providers call this with 1 */
 826   /* Guess that this is using a DPSET_LOCAL or DPSET_REMOTE type of
 827    * thing?
 828    */
 829   if( dwFlags != DPSET_REMOTE )
 830   {
 831     TRACE( "Undocumented dwFlags 0x%08x used\n", dwFlags );
 832   }
 833 #endif
 834
 835   /* FIXME: What to do in the case where this isn't initialized yet? */
 836
 837   /* Yes, we're supposed to return a pointer to the memory we have stored! */
 838   if( dwFlags == DPSET_REMOTE )
 839   {
 840     *lpdwDataSize = This->sp->dwSpRemoteDataSize;
 841     *lplpData     = This->sp->lpSpRemoteData;
 842
 843     if( This->sp->lpSpRemoteData == NULL )
 844     {
 845       hr = DPERR_GENERIC;
 846     }
 847   }
 848   else if( dwFlags == DPSET_LOCAL )
 849   {
 850     *lpdwDataSize = This->sp->dwSpLocalDataSize;
 851     *lplpData     = This->sp->lpSpLocalData;
 852
 853     if( This->sp->lpSpLocalData == NULL )
 854     {
 855       hr = DPERR_GENERIC;
 856     }
 857   }
 858
 859   return hr;
 860 }
 861
 862 static HRESULT WINAPI IDirectPlaySPImpl_SetSPData
 863 ( LPDIRECTPLAYSP iface,
 864   LPVOID lpData,
 865   DWORD dwDataSize,
 866   DWORD dwFlags
 867 )
 868 {
 869   LPVOID lpSpData;
 870
 871   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 872
 873 /*  TRACE( "Called on process 0x%08lx\n", GetCurrentProcessId() ); */
 874   TRACE( "(%p)->(%p,0x%08x,0x%08x)\n",
 875          This, lpData, dwDataSize, dwFlags );
 876
 877 #if 0
 878   /* This is what the documentation says... */
 879   if( dwFlags != DPSET_REMOTE )
 880   {
 881     return DPERR_INVALIDPARAMS;
 882   }
 883 #else
 884   /* ... but most service providers call this with 1 */
 885   /* Guess that this is using a DPSET_LOCAL or DPSET_REMOTE type of
 886    * thing?
 887    */
 888   if( dwFlags != DPSET_REMOTE )
 889   {
 890     TRACE( "Undocumented dwFlags 0x%08x used\n", dwFlags );
 891   }
 892 #endif
 893
 894   lpSpData = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, dwDataSize );
 895   CopyMemory( lpSpData, lpData, dwDataSize );
 896
 897   /* If we have data already allocated, free it and replace it */
 898   if( dwFlags == DPSET_REMOTE )
 899   {
 900     HeapFree( GetProcessHeap(), 0, This->sp->lpSpRemoteData );
 901     This->sp->dwSpRemoteDataSize = dwDataSize;
 902     This->sp->lpSpRemoteData = lpSpData;
 903   }
 904   else if ( dwFlags == DPSET_LOCAL )
 905   {
 906     HeapFree( GetProcessHeap(), 0, This->sp->lpSpLocalData );
 907     This->sp->lpSpLocalData     = lpSpData;
 908     This->sp->dwSpLocalDataSize = dwDataSize;
 909   }
 910
 911   return DP_OK;
 912 }
 913
 914 static VOID WINAPI IDirectPlaySPImpl_SendComplete
 915 ( LPDIRECTPLAYSP iface,
 916   LPVOID unknownA,
 917   DWORD unknownB
 918 )
 919 {
 920   IDirectPlaySPImpl *This = (IDirectPlaySPImpl *)iface;
 921
 922   FIXME( "(%p)->(%p,0x%08x): stub\n",
 923          This, unknownA, unknownB );
 924 }
 925
 926 static const IDirectPlaySPVtbl directPlaySPVT =
 927 {
 928
 929   DPSP_QueryInterface,
 930   DPSP_AddRef,
 931   DPSP_Release,
 932
 933   IDirectPlaySPImpl_AddMRUEntry,
 934   IDirectPlaySPImpl_CreateAddress,
 935   IDirectPlaySPImpl_EnumAddress,
 936   IDirectPlaySPImpl_EnumMRUEntries,
 937   IDirectPlaySPImpl_GetPlayerFlags,
 938   IDirectPlaySPImpl_GetSPPlayerData,
 939   IDirectPlaySPImpl_HandleMessage,
 940   IDirectPlaySPImpl_SetSPPlayerData,
 941   IDirectPlaySPImpl_CreateCompoundAddress,
 942   IDirectPlaySPImpl_GetSPData,
 943   IDirectPlaySPImpl_SetSPData,
 944   IDirectPlaySPImpl_SendComplete
 945 };
 946
 947
 948 /* DP external interfaces to call into DPSP interface */
 949
 950 /* Allocate the structure */
 951 LPVOID DPSP_CreateSPPlayerData(void)
 952 {
 953   TRACE( "Creating SPPlayer data struct\n" );
 954   return HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 955                     sizeof( DP_SPPLAYERDATA ) );
 956 }