multimedia/dplay.c

   1 /* Direct Play 3 and Direct Play Lobby 1 Implementation
   2  * Presently only the Lobby skeleton is implemented.
   3  *
   4  * Copyright 1998 - Peter Hunnisett
   5  *
   6  */
   7 #include "windows.h"
   8 #include "heap.h"
   9 #include "wintypes.h"
  10 #include "winerror.h"
  11 #include "interfaces.h"
  12 #include "mmsystem.h"
  13 #include "dplay.h"
  14 #include "debug.h"
  15 #include "winnt.h"
  16 #include "winreg.h"
  17
  18
  19 static HRESULT WINAPI IDirectPlayLobby_QueryInterface
  20 ( LPDIRECTPLAYLOBBY2 this,
  21   REFIID riid,
  22   LPVOID* ppvObj )
  23 {
  24   FIXME( dplay, ":stub\n");
  25   return DPERR_OUTOFMEMORY;
  26 }
  27
  28 static ULONG WINAPI IDirectPlayLobby_AddRef
  29 ( LPDIRECTPLAYLOBBY2 this )
  30 {
  31   ++(this->ref);
  32   TRACE( dplay," ref count now %ld\n", this->ref );
  33   return (this->ref);
  34 }
  35
  36 static ULONG WINAPI IDirectPlayLobby_Release
  37 ( LPDIRECTPLAYLOBBY2 this )
  38 {
  39   this->ref--;
  40
  41   TRACE( dplay, " ref count now %ld\n", this->ref );
  42
  43   /* Deallocate if this is the last reference to the object */
  44   if( !(this->ref) )
  45   {
  46     HeapFree( GetProcessHeap(), 0, this );
  47     return 0;
  48   }
  49
  50   return this->ref;
  51 }
  52
  53 /********************************************************************
  54  *
  55  * Connects an application to the session specified by the DPLCONNECTION
  56  * structure currently stored with the DirectPlayLobby object.
  57  *
  58  * Returns a IDirectPlay2 or IDirectPlay2A interface.
  59  *
  60  */
  61 static HRESULT WINAPI IDirectPlayLobby_Connect
  62 ( LPDIRECTPLAYLOBBY2 this,
  63   DWORD dwFlags,
  64   LPDIRECTPLAY2* lplpDP,
  65   IUnknown* pUnk)
  66 {
  67   FIXME( dplay, ":stub\n");
  68   return DPERR_OUTOFMEMORY;
  69 }
  70
  71 /********************************************************************
  72  *
  73  * Creates a DirectPlay Address, given a service provider-specific network
  74  * address.
  75  * Returns an address contains the globally unique identifier
  76  * (GUID) of the service provider and data that the service provider can
  77  * interpret as a network address.
  78  *
  79  */
  80 static HRESULT WINAPI IDirectPlayLobby_CreateAddress
  81 ( LPDIRECTPLAYLOBBY2 this,
  82   REFGUID guidSP,
  83   REFGUID guidDataType,
  84   LPCVOID lpData,
  85   DWORD dwDataSize,
  86   LPVOID lpAddress,
  87   LPDWORD lpdwAddressSize )
  88 {
  89   FIXME( dplay, ":stub\n");
  90   return DPERR_OUTOFMEMORY;
  91 }
  92
  93 /********************************************************************
  94  *
  95  * Parses out chunks from the DirectPlay Address buffer by calling the
  96  * given callback function, with lpContext, for each of the chunks.
  97  *
  98  */
  99 static HRESULT WINAPI IDirectPlayLobby_EnumAddress
 100 ( LPDIRECTPLAYLOBBY2 this,
 101   LPDPENUMADDRESSCALLBACK lpEnumAddressCallback,
 102   LPCVOID lpAddress,
 103   DWORD dwAddressSize,
 104   LPVOID lpContext )
 105 {
 106   FIXME( dplay, ":stub\n");
 107   return DPERR_OUTOFMEMORY;
 108 }
 109
 110 /********************************************************************
 111  *
 112  * Enumerates all the address types that a given service provider needs to
 113  * build the DirectPlay Address.
 114  *
 115  */
 116 static HRESULT WINAPI IDirectPlayLobby_EnumAddressTypes
 117 ( LPDIRECTPLAYLOBBY2 this,
 118   LPDPLENUMADDRESSTYPESCALLBACK lpEnumAddressTypeCallback,
 119   REFGUID guidSP,
 120   LPVOID lpContext,
 121   DWORD dwFlags )
 122 {
 123   FIXME( dplay, ":stub\n");
 124   return DPERR_OUTOFMEMORY;
 125 }
 126
 127 /********************************************************************
 128  *
 129  * Enumerates what applications are registered with DirectPlay by
 130  * invoking the callback function with lpContext.
 131  *
 132  */
 133 static HRESULT WINAPI IDirectPlayLobby_EnumLocalApplications
 134 ( LPDIRECTPLAYLOBBY2 this,
 135   LPDPLENUMLOCALAPPLICATIONSCALLBACK a,
 136   LPVOID lpContext,
 137   DWORD dwFlags )
 138 {
 139   FIXME( dplay, ":stub\n");
 140   return DPERR_OUTOFMEMORY;
 141 }
 142
 143 /********************************************************************
 144  *
 145  * Retrieves the DPLCONNECTION structure that contains all the information
 146  * needed to start and connect an application. This was generated using
 147  * either the RunApplication or SetConnectionSettings methods.
 148  *
 149  * NOTES: If lpData is NULL then just return lpdwDataSize. This allows
 150  *        the data structure to be allocated by our caller which can then
 151  *        call this procedure/method again with a valid data pointer.
 152  */
 153 static HRESULT WINAPI IDirectPlayLobby_GetConnectionSettings
 154 ( LPDIRECTPLAYLOBBY2 this,
 155   DWORD dwAppID,
 156   LPVOID lpData,
 157   LPDWORD lpdwDataSize )
 158 {
 159   LPDPLCONNECTION lpConnectionSettings;
 160
 161   FIXME( dplay, ":semi stub %p %08lx %p %p \n", this, dwAppID, lpData, lpdwDataSize );
 162
 163   if ( !lpData )
 164   {
 165     /* Let's check the size of the buffer that the application has allocated */
 166     if( *lpdwDataSize >= sizeof( DPLCONNECTION ) )
 167     {
 168       return DP_OK;
 169     }
 170     else
 171     {
 172       *lpdwDataSize = sizeof( DPLCONNECTION );
 173       return DPERR_BUFFERTOOSMALL;
 174     }
 175   }
 176
 177   /* Ok we assume that we've been given a buffer that is large enough for our needs */
 178   lpConnectionSettings = ( LPDPLCONNECTION ) lpData;
 179
 180   /* Fill in the fields */
 181
 182   return DPERR_NOTLOBBIED;
 183 }
 184
 185 /********************************************************************
 186  *
 187  * Retrieves the message sent between a lobby client and a DirectPlay
 188  * application. All messages are queued until received.
 189  *
 190  */
 191 static HRESULT WINAPI IDirectPlayLobby_ReceiveLobbyMessage
 192 ( LPDIRECTPLAYLOBBY2 this,
 193   DWORD dwFlags,
 194   DWORD dwAppID,
 195   LPDWORD lpdwMessageFlags,
 196   LPVOID lpData,
 197   LPDWORD lpdwDataSize )
 198 {
 199   FIXME( dplay, ":stub %p %08lx %08lx %p %p %p\n", this, dwFlags, dwAppID, lpdwMessageFlags, lpData,
 200          lpdwDataSize );
 201   return DPERR_OUTOFMEMORY;
 202 }
 203
 204 /********************************************************************
 205  *
 206  * Starts an application and passes to it all the information to
 207  * connect to a session.
 208  *
 209  */
 210 static HRESULT WINAPI IDirectPlayLobby_RunApplication
 211 ( LPDIRECTPLAYLOBBY2 this,
 212   DWORD dwFlags,
 213   LPDWORD lpdwAppID,
 214   LPDPLCONNECTION lpConn,
 215   HANDLE32 hReceiveEvent )
 216 {
 217   FIXME( dplay, ":stub\n");
 218   return DPERR_OUTOFMEMORY;
 219 }
 220
 221 /********************************************************************
 222  *
 223  * Sends a message between the application and the lobby client.
 224  * All messages are queued until received.
 225  *
 226  */
 227 static HRESULT WINAPI IDirectPlayLobby_SendLobbyMessage
 228 ( LPDIRECTPLAYLOBBY2 this,
 229   DWORD dwFlags,
 230   DWORD dwAppID,
 231   LPVOID lpData,
 232   DWORD dwDataSize )
 233 {
 234   FIXME( dplay, ":stub\n");
 235   return DPERR_OUTOFMEMORY;
 236 }
 237
 238 /********************************************************************
 239  *
 240  * Modifies the DPLCONNECTION structure to contain all information
 241  * needed to start and connect an application.
 242  *
 243  */
 244 static HRESULT WINAPI IDirectPlayLobby_SetConnectionSettings
 245 ( LPDIRECTPLAYLOBBY2 this,
 246   DWORD dwFlags,
 247   DWORD dwAppID,
 248   LPDPLCONNECTION lpConn )
 249 {
 250   FIXME( dplay, ": this=%p, dwFlags=%08lx, dwAppId=%08lx, lpConn=%p: stub\n",
 251          this, dwFlags, dwAppID, lpConn );
 252
 253   /* Paramater check */
 254   if( dwFlags || !this || !lpConn )
 255   {
 256     return DPERR_INVALIDPARAMS;
 257   }
 258
 259   if( !( lpConn->dwSize == sizeof(DPLCONNECTION) ) )
 260   {
 261     /* Is this the right return code? */
 262     return DPERR_INVALIDPARAMS;
 263   }
 264
 265   return DPERR_OUTOFMEMORY;
 266 }
 267
 268 /********************************************************************
 269  *
 270  * Registers an event that will be set when a lobby message is received.
 271  *
 272  */
 273 static HRESULT WINAPI IDirectPlayLobby_SetLobbyMessageEvent
 274 ( LPDIRECTPLAYLOBBY2 this,
 275   DWORD dwFlags,
 276   DWORD dwAppID,
 277   HANDLE32 hReceiveEvent )
 278 {
 279   FIXME( dplay, ":stub\n");
 280   return DPERR_OUTOFMEMORY;
 281 }
 282
 283 static HRESULT WINAPI IDirectPlayLobby_CreateCompoundAddress
 284 ( LPDIRECTPLAYLOBBY2 this,
 285   LPCDPCOMPOUNDADDRESSELEMENT lpElements,
 286   DWORD dwElementCount,
 287   LPVOID lpAddress,
 288   LPDWORD lpdwAddressSize )
 289 {
 290   FIXME( dplay, ":stub\n");
 291   return DPERR_OUTOFMEMORY;
 292 }
 293
 294 /* Direct Play Lobby 2 Virtual Table for methods */
 295 static struct tagLPDIRECTPLAYLOBBY2_VTABLE lobby2VT = {
 296   IDirectPlayLobby_QueryInterface,
 297   IDirectPlayLobby_AddRef,
 298   IDirectPlayLobby_Release,
 299   IDirectPlayLobby_Connect,
 300   IDirectPlayLobby_CreateAddress,
 301   IDirectPlayLobby_EnumAddress,
 302   IDirectPlayLobby_EnumAddressTypes,
 303   IDirectPlayLobby_EnumLocalApplications,
 304   IDirectPlayLobby_GetConnectionSettings,
 305   IDirectPlayLobby_ReceiveLobbyMessage,
 306   IDirectPlayLobby_RunApplication,
 307   IDirectPlayLobby_SendLobbyMessage,
 308   IDirectPlayLobby_SetConnectionSettings,
 309   IDirectPlayLobby_SetLobbyMessageEvent,
 310   IDirectPlayLobby_CreateCompoundAddress
 311 };
 312
 313 /***************************************************************************
 314  *  DirectPlayLobbyCreateA   (DPLAYX.4)
 315  *
 316  */
 317 HRESULT WINAPI DirectPlayLobbyCreateA( LPGUID lpGUIDDSP,
 318                                        LPDIRECTPLAYLOBBY2A *lplpDPL,
 319                                        IUnknown *lpUnk,
 320                                        LPVOID lpData,
 321                                        DWORD dwDataSize )
 322 {
 323   TRACE(dplay,"lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
 324         lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
 325
 326   /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
 327    * equal 0. These fields are mostly for future expansion.
 328    */
 329   if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
 330   {
 331      *lplpDPL = NULL;
 332      return DPERR_INVALIDPARAMS;
 333   }
 334
 335   *lplpDPL = (LPDIRECTPLAYLOBBY2A)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 336                                             sizeof( IDirectPlayLobby2A ) );
 337
 338   if( ! (*lplpDPL) )
 339   {
 340      return DPERR_OUTOFMEMORY;
 341   }
 342
 343   (*lplpDPL)->lpvtbl = &lobby2VT;
 344   (*lplpDPL)->ref    = 1;
 345
 346   /* Still some stuff to do here */
 347
 348   return DP_OK;
 349 }
 350
 351 /***************************************************************************
 352  *  DirectPlayLobbyCreateW   (DPLAYX.5)
 353  *
 354  */
 355 HRESULT WINAPI DirectPlayLobbyCreateW( LPGUID lpGUIDDSP,
 356                                        LPDIRECTPLAYLOBBY2 *lplpDPL,
 357                                        IUnknown *lpUnk,
 358                                        LPVOID lpData,
 359                                        DWORD dwDataSize )
 360 {
 361   TRACE(dplay,"lpGUIDDSP=%p lplpDPL=%p lpUnk=%p lpData=%p dwDataSize=%08lx\n",
 362         lpGUIDDSP,lplpDPL,lpUnk,lpData,dwDataSize);
 363
 364   /* Parameter Check: lpGUIDSP, lpUnk & lpData must be NULL. dwDataSize must
 365    * equal 0. These fields are mostly for future expansion.
 366    */
 367   if ( lpGUIDDSP || lpUnk || lpData || dwDataSize )
 368   {
 369      *lplpDPL = NULL;
 370      return DPERR_INVALIDPARAMS;
 371   }
 372
 373   *lplpDPL = (LPDIRECTPLAYLOBBY2)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
 374                                            sizeof( IDirectPlayLobby2 ) );
 375
 376   if( !*lplpDPL)
 377   {
 378      return DPERR_OUTOFMEMORY;
 379   }
 380
 381   (*lplpDPL)->lpvtbl = &lobby2VT;
 382   (*lplpDPL)->ref    = 1;
 383
 384   return DP_OK;
 385
 386 }
 387
 388 /***************************************************************************
 389  *  DirectPlayEnumerateA (DPLAYX.2)
 390  *
 391  *  The pointer to the structure lpContext will be filled with the
 392  *  appropriate data for each service offered by the OS. These services are
 393  *  not necessarily available on this particular machine but are defined
 394  *  as simple service providers under the "Service Providers" registry key.
 395  *  This structure is then passed to lpEnumCallback for each of the different
 396  *  services.
 397  *
 398  *  This API is useful only for applications written using DirectX3 or
 399  *  worse. It is superceeded by IDirectPlay3::EnumConnections which also
 400  *  gives information on the actual connections.
 401  *
 402  * defn of a service provider:
 403  * A dynamic-link library used by DirectPlay to communicate over a network.
 404  * The service provider contains all the network-specific code required
 405  * to send and receive messages. Online services and network operators can
 406  * supply service providers to use specialized hardware, protocols, communications
 407  * media, and network resources.
 408  *
 409  * TODO: Allocate string buffer space from the heap (length from reg)
 410  *       Pass real device driver numbers...
 411  *       Get the GUID properly...
 412  */
 413 HRESULT WINAPI DirectPlayEnumerateA( LPDPENUMDPCALLBACKA lpEnumCallback,
 414                                      LPVOID lpContext )
 415 {
 416
 417   HKEY hkResult;
 418   LPCSTR searchSubKey    = "SOFTWARE\\Microsoft\\DirectPlay\\Service Providers";
 419   LPSTR guidDataSubKey   = "Guid";
 420   LPSTR majVerDataSubKey = "dwReserved1";
 421   DWORD dwIndex, sizeOfSubKeyName=50;
 422   char subKeyName[51];
 423
 424   TRACE( dplay, ": lpEnumCallback=%p lpContext=%p\n", lpEnumCallback, lpContext );
 425
 426   if( !lpEnumCallback || !*lpEnumCallback )
 427   {
 428      return DPERR_INVALIDPARAMS;
 429   }
 430
 431   /* Need to loop over the service providers in the registry */
 432   if( RegOpenKeyEx32A( HKEY_LOCAL_MACHINE, searchSubKey,
 433                        0, KEY_ENUMERATE_SUB_KEYS, &hkResult ) != ERROR_SUCCESS )
 434   {
 435     /* Hmmm. Does this mean that there are no service providers? */
 436     ERR(dplay, ": no service providers?\n");
 437     return DP_OK;
 438   }
 439
 440   /* Traverse all the service providers we have available */
 441   for( dwIndex=0;
 442        RegEnumKey32A( hkResult, dwIndex, subKeyName, sizeOfSubKeyName ) !=
 443          ERROR_NO_MORE_ITEMS;
 444        ++dwIndex )
 445   {
 446     HKEY     hkServiceProvider;
 447     GUID     serviceProviderGUID;
 448     DWORD    returnTypeGUID, returnTypeReserved1, sizeOfReturnBuffer=50;
 449     char     returnBuffer[51];
 450     DWORD    majVersionNum, minVersionNum;
 451     LPWSTR   lpWGUIDString;
 452
 453     TRACE( dplay, " this time through: %s\n", subKeyName );
 454
 455     /* Get a handle for this particular service provider */
 456     if( RegOpenKeyEx32A( hkResult, subKeyName, 0, KEY_QUERY_VALUE,
 457                          &hkServiceProvider ) != ERROR_SUCCESS )
 458     {
 459       ERR( dplay, ": what the heck is going on?\n" );
 460       continue;
 461     }
 462
 463     /* Get the GUID, Device major number and device minor number
 464      * from the registry.
 465      */
 466     if( RegQueryValueEx32A( hkServiceProvider, guidDataSubKey,
 467                             NULL, &returnTypeGUID, returnBuffer,
 468                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
 469     {
 470       ERR( dplay, ": missing GUID registry data members\n" );
 471       continue;
 472     }
 473
 474     /* FIXME: Check return types to ensure we're interpreting data right */
 475     lpWGUIDString = HEAP_strdupAtoW( GetProcessHeap(), 0, returnBuffer );
 476     CLSIDFromString32( (LPCOLESTR32)lpWGUIDString, &serviceProviderGUID );
 477     HeapFree( GetProcessHeap(), 0, lpWGUIDString );
 478
 479     sizeOfReturnBuffer = 50;
 480
 481     if( RegQueryValueEx32A( hkServiceProvider, majVerDataSubKey,
 482                             NULL, &returnTypeReserved1, returnBuffer,
 483                             &sizeOfReturnBuffer ) != ERROR_SUCCESS )
 484     {
 485       ERR( dplay, ": missing dwReserved1 registry data members\n") ;
 486       continue;
 487     }
 488     /* FIXME: This couldn't possibly be right...*/
 489     majVersionNum = GET_DWORD( returnBuffer );
 490
 491     /* The enumeration will return FALSE if we are not to continue */
 492     if( !lpEnumCallback( &serviceProviderGUID , subKeyName,
 493                          majVersionNum, (DWORD)0, lpContext ) )
 494     {
 495       WARN( dplay, "lpEnumCallback returning FALSE\n" );
 496       break;
 497     }
 498   }
 499
 500   return DP_OK;
 501
 502 }
 503
 504 /***************************************************************************
 505  *  DirectPlayEnumerateW (DPLAYX.3)
 506  *
 507  */
 508 HRESULT WINAPI DirectPlayEnumerateW( LPDPENUMDPCALLBACKW lpEnumCallback, LPVOID lpContext )
 509 {
 510
 511   FIXME( dplay, ":stub\n");
 512
 513   return DPERR_OUTOFMEMORY;
 514
 515 }
 516
 517 /***************************************************************************
 518  *  DirectPlayCreate (DPLAYX.1) (DPLAY.1)
 519  *
 520  */
 521 HRESULT WINAPI DirectPlayCreate
 522 ( LPGUID lpGUID, LPDIRECTPLAY *lplpDP, IUnknown *pUnk)
 523 {
 524
 525   FIXME( dplay, ":stub\n");
 526   return DPERR_OUTOFMEMORY;
 527
 528 }