dlls/dplayx/dplayx_global.c

   1 /* dplayx.dll global data implementation.
   2  *
   3  * Copyright 1999 - Peter Hunnisett
   4  *
   5  * <presently under construction - contact hunnise@nortelnetworks.com>
   6  *
   7  */
   8
   9 /* NOTE: Methods that begin with DPLAYX_ are used for dealing with
  10  *       dplayx.dll data which is accessible from all processes.
  11  */
  12
  13 #include "debugtools.h"
  14 #include "winbase.h"
  15 #include "winerror.h"
  16 #include "heap.h"  /* Really shouldn't be using those HEAP_strdupA interfaces should I? */
  17
  18 #include "dplayx_global.h"
  19
  20 DEFAULT_DEBUG_CHANNEL(dplay)
  21
  22 /* FIXME: Need to do all that fun other dll referencing type of stuff */
  23 /* FIXME: Need to allocate a giant static area - or a global data type thing for Get/Set */
  24
  25 /* Static data for all processes */
  26 static LPSTR lpszDplayxSemaName = "DPLAYX_SM";
  27 static HANDLE hDplayxSema;
  28
  29
  30
  31 #define DPLAYX_AquireSemaphore()  0L /* WaitForSingleObject( hDplayxSema, INFINITE? ) */
  32 #define DPLAYX_ReleaseSemaphore() 0L /* ReleaseSemaphore( hDplayxSema, ..., ...  ) */
  33
  34
  35 /* HACK for simple global data right now */
  36 enum { numSupportedLobbies = 32 };
  37 typedef struct tagDirectPlayLobbyData
  38 {
  39   DWORD           dwConnFlags;
  40   DPSESSIONDESC2  sessionDesc;
  41   DPNAME          playerName;
  42   GUID            guidSP;
  43   LPVOID          lpAddress;
  44   DWORD           dwAddressSize;
  45   DWORD           dwAppID;
  46   HANDLE          hReceiveEvent;
  47 } DirectPlayLobbyData, *lpDirectPlayLobbyData;
  48
  49 static DirectPlayLobbyData lobbyData[ numSupportedLobbies ];
  50
  51 /* Function prototypes */
  52 BOOL DPLAYX_AppIdLobbied( DWORD dwAppId, lpDirectPlayLobbyData* dplData );
  53
  54
  55
  56
  57 /***************************************************************************
  58  * Called to initialize the global data. This will only be used on the
  59  * loading of the dll
  60  ***************************************************************************/
  61 void DPLAYX_ConstructData(void)
  62 {
  63   UINT i;
  64
  65   TRACE( "DPLAYX dll loaded - construct called\n" );
  66
  67   /* FIXME: This needs to be allocated shared */
  68   hDplayxSema = CreateSemaphoreA( NULL, 0, 1, lpszDplayxSemaName );
  69
  70   if( !hDplayxSema )
  71   {
  72     /* Really don't have any choice but to continue... */
  73     ERR( "Semaphore creation error 0x%08lx\n", GetLastError() );
  74   }
  75
  76   /* Set all lobbies to be "empty" */
  77   for( i=0; i < numSupportedLobbies; i++ )
  78   {
  79     lobbyData[ i ].dwAppID = 0;
  80   }
  81
  82 }
  83
  84 /***************************************************************************
  85  * Called to destroy all global data. This will only be used on the
  86  * unloading of the dll
  87  ***************************************************************************/
  88 void DPLAYX_DestructData(void)
  89 {
  90   /* Hmmm...what to call to delete the semaphore? Auto delete? */
  91   TRACE( "DPLAYX dll unloaded - destruct called\n" );
  92 }
  93
  94
  95 /* NOTE: This must be called with the semaphore aquired.
  96  * TRUE/FALSE with a pointer to it's data returned
  97  */
  98 BOOL DPLAYX_AppIdLobbied( DWORD dwAppID, lpDirectPlayLobbyData* lplpDplData )
  99 {
 100   INT i;
 101
 102   if( dwAppID == 0 )
 103   {
 104     dwAppID = GetCurrentProcessId();
 105   }
 106
 107   for( i=0; i < numSupportedLobbies; i++ )
 108   {
 109     if( lobbyData[ i ].dwAppID == dwAppID )
 110     {
 111       /* This process is lobbied */
 112       *lplpDplData = &lobbyData[ i ];
 113       return TRUE;
 114     }
 115   }
 116
 117   return FALSE;
 118 }
 119
 120 #if !defined( WORKING_PROCESS_SUSPEND )
 121 /* These two functions should not exist. We would normally create a process initially
 122    suspended when we RunApplication. This gives us time to actually store some data
 123    before the new process might try to read it. However, process suspension doesn't
 124    work yet and I'm too stupid to get it going. So, we'll just hack in fine fashion */
 125 DWORD DPLAYX_AquireSemaphoreHack( void )
 126 {
 127   return DPLAYX_AquireSemaphore();
 128 }
 129
 130 DWORD DPLAYX_ReleaseSemaphoreHack( void )
 131 {
 132   return DPLAYX_ReleaseSemaphore();
 133 }
 134
 135 #endif
 136
 137
 138
 139
 140 /* Reserve a spot for the new appliction. TRUE means success and FALSE failure.  */
 141 BOOL DPLAYX_CreateLobbyApplication( DWORD dwAppID, HANDLE hReceiveEvent )
 142 {
 143   INT  i;
 144
 145   DPLAYX_AquireSemaphore();
 146
 147   for( i=0; i < numSupportedLobbies; i++ )
 148   {
 149     if( lobbyData[ i ].dwAppID == 0 )
 150     {
 151       /* This process is now lobbied */
 152       lobbyData[ i ].dwAppID       = dwAppID;
 153       lobbyData[ i ].hReceiveEvent = hReceiveEvent;
 154
 155       DPLAYX_ReleaseSemaphore();
 156       return TRUE;
 157     }
 158   }
 159
 160   DPLAYX_ReleaseSemaphore();
 161   return FALSE;
 162 }
 163
 164 HRESULT DPLAYX_GetConnectionSettingsA
 165 ( DWORD dwAppID,
 166   LPVOID lpData,
 167   LPDWORD lpdwDataSize )
 168 {
 169   lpDirectPlayLobbyData lpDplData;
 170   LPDPLCONNECTION lpDplConnection;
 171
 172   DPLAYX_AquireSemaphore();
 173
 174   if ( !DPLAYX_AppIdLobbied( dwAppID, &lpDplData ) )
 175   {
 176     DPLAYX_ReleaseSemaphore();
 177     return DPERR_NOTLOBBIED;
 178   }
 179
 180   /* Verify buffer size */
 181   if ( ( lpData == NULL ) ||
 182        ( *lpdwDataSize < sizeof( DPLCONNECTION ) )
 183      )
 184   {
 185     DPLAYX_ReleaseSemaphore();
 186
 187     *lpdwDataSize = sizeof( DPLCONNECTION );
 188
 189     return DPERR_BUFFERTOOSMALL;
 190   }
 191
 192   /* Copy the information */
 193   lpDplConnection = (LPDPLCONNECTION)lpData;
 194
 195   /* Copy everything we've got into here */
 196   /* Need to actually store the stuff here. Check if we've already allocated each field first. */
 197   lpDplConnection->dwSize = sizeof( DPLCONNECTION );
 198   lpDplConnection->dwFlags = lpDplData->dwConnFlags;
 199
 200   /* Copy LPDPSESSIONDESC2 struct */
 201   lpDplConnection->lpSessionDesc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( lpDplData->sessionDesc ) );
 202   memcpy( lpDplConnection->lpSessionDesc, &lpDplData->sessionDesc, sizeof( lpDplData->sessionDesc ) );
 203
 204   if( lpDplData->sessionDesc.sess.lpszSessionNameA )
 205   {
 206     lpDplConnection->lpSessionDesc->sess.lpszSessionNameA =
 207       HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->sessionDesc.sess.lpszSessionNameA );
 208   }
 209
 210   if( lpDplData->sessionDesc.pass.lpszPasswordA )
 211   {
 212     lpDplConnection->lpSessionDesc->pass.lpszPasswordA =
 213       HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->sessionDesc.pass.lpszPasswordA );
 214   }
 215
 216   lpDplConnection->lpSessionDesc->dwReserved1 = lpDplData->sessionDesc.dwReserved1;
 217   lpDplConnection->lpSessionDesc->dwReserved2 = lpDplData->sessionDesc.dwReserved2;
 218
 219   /* Copy DPNAME struct - seems to be optional - check for existance first */
 220   lpDplConnection->lpPlayerName = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( lpDplData->playerName ) );
 221   memcpy( lpDplConnection->lpPlayerName, &(lpDplData->playerName), sizeof( lpDplData->playerName ) );
 222
 223   if( lpDplData->playerName.psn.lpszShortNameA )
 224   {
 225     lpDplConnection->lpPlayerName->psn.lpszShortNameA =
 226       HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->playerName.psn.lpszShortNameA );
 227   }
 228
 229   if( lpDplData->playerName.pln.lpszLongNameA )
 230   {
 231     lpDplConnection->lpPlayerName->pln.lpszLongNameA =
 232       HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->playerName.pln.lpszLongNameA );
 233   }
 234
 235   memcpy( &lpDplConnection->guidSP, &lpDplData->guidSP, sizeof( lpDplData->guidSP ) );
 236
 237   lpDplConnection->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->dwAddressSize );
 238   memcpy( lpDplConnection->lpAddress, lpDplData->lpAddress, lpDplData->dwAddressSize );
 239
 240   lpDplConnection->dwAddressSize = lpDplData->dwAddressSize;
 241
 242   /* Send a message - or only the first time? */
 243
 244   DPLAYX_ReleaseSemaphore();
 245
 246   return DP_OK;
 247 }
 248
 249 HRESULT DPLAYX_GetConnectionSettingsW
 250 ( DWORD dwAppID,
 251   LPVOID lpData,
 252   LPDWORD lpdwDataSize )
 253 {
 254   lpDirectPlayLobbyData lpDplData;
 255   LPDPLCONNECTION lpDplConnection;
 256
 257   DPLAYX_AquireSemaphore();
 258
 259   if ( !DPLAYX_AppIdLobbied( dwAppID, &lpDplData ) )
 260   {
 261     DPLAYX_ReleaseSemaphore();
 262     return DPERR_NOTLOBBIED;
 263   }
 264
 265   /* Verify buffer size */
 266   if ( ( lpData == NULL ) ||
 267        ( *lpdwDataSize < sizeof( DPLCONNECTION ) )
 268      )
 269   {
 270     DPLAYX_ReleaseSemaphore();
 271
 272     *lpdwDataSize = sizeof( DPLCONNECTION );
 273
 274     return DPERR_BUFFERTOOSMALL;
 275   }
 276
 277   /* Copy the information */
 278   lpDplConnection = (LPDPLCONNECTION)lpData;
 279
 280   /* Copy everything we've got into here */
 281   /* Need to actually store the stuff here. Check if we've already allocated each field first. */
 282   lpDplConnection->dwSize = sizeof( DPLCONNECTION );
 283   lpDplConnection->dwFlags = lpDplData->dwConnFlags;
 284
 285   /* Copy LPDPSESSIONDESC2 struct */
 286   lpDplConnection->lpSessionDesc = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( lpDplData->sessionDesc ) );
 287   memcpy( lpDplConnection->lpSessionDesc, &lpDplData->sessionDesc, sizeof( lpDplData->sessionDesc ) );
 288
 289   if( lpDplData->sessionDesc.sess.lpszSessionName )
 290   {
 291     lpDplConnection->lpSessionDesc->sess.lpszSessionName =
 292       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->sessionDesc.sess.lpszSessionName );
 293   }
 294
 295   if( lpDplData->sessionDesc.pass.lpszPassword )
 296   {
 297     lpDplConnection->lpSessionDesc->pass.lpszPassword =
 298       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->sessionDesc.pass.lpszPassword );
 299   }
 300
 301   lpDplConnection->lpSessionDesc->dwReserved1 = lpDplData->sessionDesc.dwReserved1;
 302   lpDplConnection->lpSessionDesc->dwReserved2 = lpDplData->sessionDesc.dwReserved2;
 303
 304   /* Copy DPNAME struct - seems to be optional - check for existance first */
 305   lpDplConnection->lpPlayerName = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( lpDplData->playerName ) );
 306   memcpy( lpDplConnection->lpPlayerName, &(lpDplData->playerName), sizeof( lpDplData->playerName ) );
 307
 308   if( lpDplData->playerName.psn.lpszShortName )
 309   {
 310     lpDplConnection->lpPlayerName->psn.lpszShortName =
 311       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->playerName.psn.lpszShortName );
 312   }
 313
 314   if( lpDplData->playerName.pln.lpszLongName )
 315   {
 316     lpDplConnection->lpPlayerName->pln.lpszLongName =
 317       HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->playerName.pln.lpszLongName );
 318   }
 319
 320   memcpy( &lpDplConnection->guidSP, &lpDplData->guidSP, sizeof( lpDplData->guidSP ) );
 321
 322   lpDplConnection->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDplData->dwAddressSize );
 323   memcpy( lpDplConnection->lpAddress, lpDplData->lpAddress, lpDplData->dwAddressSize );
 324
 325   lpDplConnection->dwAddressSize = lpDplData->dwAddressSize;
 326
 327   /* Send a message - or only the first time? */
 328
 329   DPLAYX_ReleaseSemaphore();
 330
 331   return DP_OK;
 332 }
 333
 334
 335 HRESULT DPLAYX_SetConnectionSettingsA
 336 ( DWORD dwFlags,
 337   DWORD dwAppID,
 338   LPDPLCONNECTION lpConn )
 339 {
 340   lpDirectPlayLobbyData lpDplData;
 341
 342   DPLAYX_AquireSemaphore();
 343
 344   if ( !DPLAYX_AppIdLobbied( dwAppID, &lpDplData ) )
 345   {
 346     /* FIXME: Create a new entry for this dwAppID? */
 347     DPLAYX_ReleaseSemaphore();
 348
 349     return DPERR_GENERIC;
 350   }
 351
 352   /* Paramater check */
 353   if( dwFlags || !lpConn )
 354   {
 355     DPLAYX_ReleaseSemaphore();
 356
 357     ERR("invalid parameters.\n");
 358     return DPERR_INVALIDPARAMS;
 359   }
 360
 361   /* Store information */
 362   if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
 363   {
 364     DPLAYX_ReleaseSemaphore();
 365
 366     ERR(": old/new DPLCONNECTION type? Size=%08lx vs. expected=%ul bytes\n",
 367          lpConn->dwSize, sizeof( DPLCONNECTION ) );
 368
 369     return DPERR_INVALIDPARAMS;
 370   }
 371
 372   /* Need to investigate the lpConn->lpSessionDesc to figure out
 373    * what type of session we need to join/create.
 374    */
 375   if(  (!lpConn->lpSessionDesc ) ||
 376        ( lpConn->lpSessionDesc->dwSize != sizeof( DPSESSIONDESC2 ) )
 377     )
 378   {
 379     DPLAYX_ReleaseSemaphore();
 380
 381     ERR("DPSESSIONDESC passed in? Size=%08lx vs. expected=%ul bytes\n",
 382          lpConn->lpSessionDesc->dwSize, sizeof( DPSESSIONDESC2 ) );
 383
 384     return DPERR_INVALIDPARAMS;
 385   }
 386
 387   /* FIXME: How do I store this stuff so that it can be read by all processes? Static area? What about strings? Ewww...large global shared */
 388
 389   /* Need to actually store the stuff here. Check if we've already allocated each field first. */
 390   lpDplData->dwConnFlags = lpConn->dwFlags;
 391
 392   /* Copy LPDPSESSIONDESC2 struct - this is required */
 393   memcpy( &lpDplData->sessionDesc, lpConn->lpSessionDesc, sizeof( *(lpConn->lpSessionDesc) ) );
 394
 395   /* FIXME: Can this just be shorted? Does it handle the NULL case correctly? */
 396   if( lpConn->lpSessionDesc->sess.lpszSessionNameA )
 397     lpDplData->sessionDesc.sess.lpszSessionNameA = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->sess.lpszSessionNameA );
 398   else
 399     lpDplData->sessionDesc.sess.lpszSessionNameA = NULL;
 400
 401   if( lpConn->lpSessionDesc->pass.lpszPasswordA )
 402     lpDplData->sessionDesc.pass.lpszPasswordA = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->pass.lpszPasswordA );
 403   else
 404     lpDplData->sessionDesc.pass.lpszPasswordA = NULL;
 405
 406   lpDplData->sessionDesc.dwReserved1 = lpConn->lpSessionDesc->dwReserved1;
 407   lpDplData->sessionDesc.dwReserved2 = lpConn->lpSessionDesc->dwReserved2;
 408
 409   /* Copy DPNAME struct - seems to be optional - check for existance first */
 410   if( lpConn->lpPlayerName )
 411   {
 412      memcpy( &lpDplData->playerName, lpConn->lpPlayerName, sizeof( *lpConn->lpPlayerName ) );
 413
 414      if( lpConn->lpPlayerName->psn.lpszShortNameA )
 415        lpDplData->playerName.psn.lpszShortNameA = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->psn.lpszShortNameA );
 416
 417      if( lpConn->lpPlayerName->pln.lpszLongNameA )
 418        lpDplData->playerName.pln.lpszLongNameA = HEAP_strdupA( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->pln.lpszLongNameA );
 419
 420   }
 421
 422   memcpy( &lpDplData->guidSP, &lpConn->guidSP, sizeof( lpConn->guidSP ) );
 423
 424   lpDplData->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->dwAddressSize );
 425   memcpy( lpDplData->lpAddress, lpConn->lpAddress, lpConn->dwAddressSize );
 426
 427   lpDplData->dwAddressSize = lpConn->dwAddressSize;
 428
 429   /* Send a message - I think */
 430
 431   DPLAYX_ReleaseSemaphore();
 432
 433   return DP_OK;
 434 }
 435
 436 HRESULT DPLAYX_SetConnectionSettingsW
 437 ( DWORD dwFlags,
 438   DWORD dwAppID,
 439   LPDPLCONNECTION lpConn )
 440 {
 441   lpDirectPlayLobbyData lpDplData;
 442
 443   DPLAYX_AquireSemaphore();
 444
 445   if ( !DPLAYX_AppIdLobbied( dwAppID, &lpDplData ) )
 446   {
 447     DPLAYX_ReleaseSemaphore();
 448     return DPERR_NOTLOBBIED;
 449   }
 450
 451   /* Paramater check */
 452   if( dwFlags || !lpConn )
 453   {
 454     DPLAYX_ReleaseSemaphore();
 455     ERR("invalid parameters.\n");
 456     return DPERR_INVALIDPARAMS;
 457   }
 458
 459   /* Store information */
 460   if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
 461   {
 462     DPLAYX_ReleaseSemaphore();
 463
 464     ERR(": old/new DPLCONNECTION type? Size=%08lx vs. expected=%ul bytes\n",
 465          lpConn->dwSize, sizeof( DPLCONNECTION ) );
 466
 467     return DPERR_INVALIDPARAMS;
 468   }
 469
 470   /* Need to investigate the lpConn->lpSessionDesc to figure out
 471    * what type of session we need to join/create.
 472    */
 473   if(  (!lpConn->lpSessionDesc ) ||
 474        ( lpConn->lpSessionDesc->dwSize != sizeof( DPSESSIONDESC2 ) )
 475     )
 476   {
 477     DPLAYX_ReleaseSemaphore();
 478
 479     ERR("DPSESSIONDESC passed in? Size=%08lx vs. expected=%ul bytes\n",
 480          lpConn->lpSessionDesc->dwSize, sizeof( DPSESSIONDESC2 ) );
 481
 482     return DPERR_INVALIDPARAMS;
 483   }
 484
 485   /* FIXME: How do I store this stuff so that it can be read by all processes? Static area? What about strings? Ewww...large global shared */
 486
 487   /* Need to actually store the stuff here. Check if we've already allocated each field first. */
 488   lpDplData->dwConnFlags = lpConn->dwFlags;
 489
 490   /* Copy LPDPSESSIONDESC2 struct - this is required */
 491   memcpy( &lpDplData->sessionDesc, lpConn->lpSessionDesc, sizeof( *(lpConn->lpSessionDesc) ) );
 492
 493   /* FIXME: Can this just be shorted? Does it handle the NULL case correctly? */
 494   if( lpConn->lpSessionDesc->sess.lpszSessionName )
 495     lpDplData->sessionDesc.sess.lpszSessionName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->sess.lpszSessionName );
 496   else
 497     lpDplData->sessionDesc.sess.lpszSessionName = NULL;
 498
 499   if( lpConn->lpSessionDesc->pass.lpszPassword )
 500     lpDplData->sessionDesc.pass.lpszPassword = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpSessionDesc->pass.lpszPassword );
 501   else
 502     lpDplData->sessionDesc.pass.lpszPassword = NULL;
 503
 504   lpDplData->sessionDesc.dwReserved1 = lpConn->lpSessionDesc->dwReserved1;
 505   lpDplData->sessionDesc.dwReserved2 = lpConn->lpSessionDesc->dwReserved2;
 506
 507   /* Copy DPNAME struct - seems to be optional - check for existance first */
 508   if( lpConn->lpPlayerName )
 509   {
 510      memcpy( &lpDplData->playerName, lpConn->lpPlayerName, sizeof( *lpConn->lpPlayerName ) );
 511
 512      if( lpConn->lpPlayerName->psn.lpszShortName )
 513        lpDplData->playerName.psn.lpszShortName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->psn.lpszShortName );
 514
 515      if( lpConn->lpPlayerName->pln.lpszLongName )
 516        lpDplData->playerName.pln.lpszLongName = HEAP_strdupW( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->lpPlayerName->pln.lpszLongName );
 517
 518   }
 519
 520   memcpy( &lpDplData->guidSP, &lpConn->guidSP, sizeof( lpConn->guidSP ) );
 521
 522   lpDplData->lpAddress = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, lpConn->dwAddressSize );
 523   memcpy( lpDplData->lpAddress, lpConn->lpAddress, lpConn->dwAddressSize );
 524
 525   lpDplData->dwAddressSize = lpConn->dwAddressSize;
 526
 527   /* Send a message - I think */
 528
 529   DPLAYX_ReleaseSemaphore();
 530
 531   return DP_OK;
 532 }