dll/directx/wine/dplayx/dplayx_global.c

   1 /* dplayx.dll global data implementation.
   2  *
   3  * Copyright 1999,2000 - Peter Hunnisett
   4  *
   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  * NOTES:
  22  *  o Implementation of all things which are associated with dplay on
  23  *    the computer - i.e. shared resources and such. Methods in this
  24  *    compilation unit should not call anything outside of this unit
  25  *    except base windows services and an interface to start the
  26  *    messaging thread.
  27  *  o Methods that begin with DPLAYX_ are used for dealing with
  28  *    dplayx.dll data which is accessible from all processes.
  29  *
  30  */
  31
  32 #include "dplayx_global.h"
  33
  34 /* FIXME: Need to do all that fun other dll referencing type of stuff */
  35
  36 /* Static data for all processes */
  37 static const char lpszDplayxSemaName[] = "WINE_DPLAYX_SM";
  38 static HANDLE hDplayxSema;
  39
  40 static const char lpszDplayxFileMapping[] = "WINE_DPLAYX_FM";
  41 static HANDLE hDplayxSharedMem;
  42
  43 static LPVOID lpSharedStaticData = NULL;
  44
  45
  46 #define DPLAYX_AcquireSemaphore() TRACE( "Waiting for DPLAYX semaphore\n" ); \
  47                                   WaitForSingleObject( hDplayxSema, INFINITE );\
  48                                   TRACE( "Through wait\n" )
  49
  50 #define DPLAYX_ReleaseSemaphore() ReleaseSemaphore( hDplayxSema, 1, NULL ); \
  51                                   TRACE( "DPLAYX Semaphore released\n" ) /* FIXME: Is this correct? */
  52
  53
  54 /* HACK for simple global data right now */
  55 #define dwStaticSharedSize (128 * 1024) /* 128 KBytes */
  56 #define dwDynamicSharedSize (512 * 1024) /* 512 KBytes */
  57 #define dwTotalSharedSize  ( dwStaticSharedSize + dwDynamicSharedSize )
  58
  59
  60 /* FIXME: Is there no easier way? */
  61
  62 /* Pretend the entire dynamic area is carved up into 512 byte blocks.
  63  * Each block has 4 bytes which are 0 unless used */
  64 #define dwBlockSize 512
  65 #define dwMaxBlock  (dwDynamicSharedSize/dwBlockSize)
  66
  67 typedef struct
  68 {
  69   BOOL used;
  70   BYTE data[dwBlockSize - sizeof(BOOL)];
  71 } DPLAYX_MEM_SLICE;
  72 C_ASSERT(sizeof(DPLAYX_MEM_SLICE) == dwBlockSize);
  73
  74 static DPLAYX_MEM_SLICE* lpMemArea;
  75
  76 static void DPLAYX_PrivHeapFree( LPVOID addr )
  77 {
  78   LPVOID lpAddrStart;
  79   DWORD dwBlockUsed;
  80
  81   /* Handle getting passed a NULL */
  82   if( addr == NULL )
  83   {
  84     return;
  85   }
  86
  87   lpAddrStart = CONTAINING_RECORD(addr, DPLAYX_MEM_SLICE, data); /* Find block header */
  88   dwBlockUsed =  ((BYTE*)lpAddrStart - (BYTE*)lpMemArea)/dwBlockSize;
  89
  90   lpMemArea[ dwBlockUsed ].used = FALSE;
  91 }
  92
  93 static LPVOID DPLAYX_PrivHeapAlloc( DWORD flags, DWORD size )
  94 {
  95   LPVOID lpvArea = NULL;
  96   UINT   uBlockUsed;
  97
  98   if( size > (dwBlockSize - sizeof(BOOL)) )
  99   {
 100     FIXME( "Size exceeded. Request of 0x%08x\n", size );
 101     size = dwBlockSize - sizeof(BOOL);
 102   }
 103
 104   /* Find blank area */
 105   uBlockUsed = 0;
 106   while( lpMemArea[ uBlockUsed ].used && uBlockUsed <= dwMaxBlock ) { uBlockUsed++; }
 107
 108   if( uBlockUsed <= dwMaxBlock )
 109   {
 110     /* Set the area used */
 111     lpMemArea[ uBlockUsed ].used = TRUE;
 112     lpvArea = lpMemArea[ uBlockUsed ].data;
 113   }
 114   else
 115   {
 116     ERR( "No free block found\n" );
 117     return NULL;
 118   }
 119
 120   if( flags & HEAP_ZERO_MEMORY )
 121   {
 122     ZeroMemory( lpvArea, size );
 123   }
 124
 125   return lpvArea;
 126 }
 127
 128
 129 enum { numSupportedLobbies = 32, numSupportedSessions = 32 };
 130 typedef struct tagDPLAYX_LOBBYDATA
 131 {
 132   /* Points to lpConn + block of contiguous extra memory for dynamic parts
 133    * of the struct directly following
 134    */
 135   LPDPLCONNECTION lpConn;
 136
 137   /* Information for dplobby interfaces */
 138   DWORD           dwAppID;
 139   DWORD           dwAppLaunchedFromID;
 140
 141   /* Should this lobby app send messages to creator at important life
 142    * stages
 143    */
 144   HANDLE hInformOnAppStart;
 145   HANDLE hInformOnAppDeath;
 146   HANDLE hInformOnSettingRead;
 147
 148   /* Sundries */
 149   BOOL bWaitForConnectionSettings;
 150   DWORD dwLobbyMsgThreadId;
 151
 152
 153 } DPLAYX_LOBBYDATA, *LPDPLAYX_LOBBYDATA;
 154
 155 static DPLAYX_LOBBYDATA* lobbyData = NULL;
 156 /* static DPLAYX_LOBBYDATA lobbyData[ numSupportedLobbies ]; */
 157
 158 static DPSESSIONDESC2* sessionData = NULL;
 159 /* static DPSESSIONDESC2* sessionData[ numSupportedSessions ]; */
 160
 161
 162 static void DPLAYX_InitializeLobbyDataEntry( LPDPLAYX_LOBBYDATA lpData )
 163 {
 164   ZeroMemory( lpData, sizeof( *lpData ) );
 165 }
 166
 167 /* NOTE: This must be called with the semaphore acquired.
 168  * TRUE/FALSE with a pointer to it's data returned. Pointer data is
 169  * is only valid if TRUE is returned.
 170  */
 171 static BOOL DPLAYX_IsAppIdLobbied( DWORD dwAppID, LPDPLAYX_LOBBYDATA* lplpDplData )
 172 {
 173   UINT i;
 174
 175   *lplpDplData = NULL;
 176
 177   if( dwAppID == 0 )
 178   {
 179     dwAppID = GetCurrentProcessId();
 180     TRACE( "Translated dwAppID == 0 into 0x%08x\n", dwAppID );
 181   }
 182
 183   for( i=0; i < numSupportedLobbies; i++ )
 184   {
 185     if( lobbyData[ i ].dwAppID == dwAppID )
 186     {
 187       /* This process is lobbied */
 188       TRACE( "Found 0x%08x @ %u\n", dwAppID, i );
 189       *lplpDplData = &lobbyData[ i ];
 190       return TRUE;
 191     }
 192   }
 193
 194   return FALSE;
 195 }
 196
 197 /* Reserve a spot for the new application. TRUE means success and FALSE failure.  */
 198 BOOL DPLAYX_CreateLobbyApplication( DWORD dwAppID )
 199 {
 200   UINT i;
 201
 202   /* 0 is the marker for unused application data slots */
 203   if( dwAppID == 0 )
 204   {
 205     return FALSE;
 206   }
 207
 208   DPLAYX_AcquireSemaphore();
 209
 210   /* Find an empty space in the list and insert the data */
 211   for( i=0; i < numSupportedLobbies; i++ )
 212   {
 213     if( lobbyData[ i ].dwAppID == 0 )
 214     {
 215       /* This process is now lobbied */
 216       TRACE( "Setting lobbyData[%u] for (0x%08x,0x%08x)\n",
 217               i, dwAppID, GetCurrentProcessId() );
 218
 219       lobbyData[ i ].dwAppID              = dwAppID;
 220       lobbyData[ i ].dwAppLaunchedFromID  = GetCurrentProcessId();
 221
 222       /* FIXME: Where is the best place for this? In interface or here? */
 223       lobbyData[ i ].hInformOnAppStart = 0;
 224       lobbyData[ i ].hInformOnAppDeath = 0;
 225       lobbyData[ i ].hInformOnSettingRead = 0;
 226
 227       DPLAYX_ReleaseSemaphore();
 228       return TRUE;
 229     }
 230   }
 231
 232   ERR( "No empty lobbies\n" );
 233
 234   DPLAYX_ReleaseSemaphore();
 235   return FALSE;
 236 }
 237
 238 BOOL DPLAYX_SetLobbyHandles( DWORD dwAppID,
 239                              HANDLE hStart, HANDLE hDeath, HANDLE hConnRead )
 240 {
 241   LPDPLAYX_LOBBYDATA lpLData;
 242
 243   /* Need to explicitly give lobby application. Can't set for yourself */
 244   if( dwAppID == 0 )
 245   {
 246     return FALSE;
 247   }
 248
 249   DPLAYX_AcquireSemaphore();
 250
 251   if( !DPLAYX_IsAppIdLobbied( dwAppID, &lpLData ) )
 252   {
 253     DPLAYX_ReleaseSemaphore();
 254     return FALSE;
 255   }
 256
 257   lpLData->hInformOnAppStart    = hStart;
 258   lpLData->hInformOnAppDeath    = hDeath;
 259   lpLData->hInformOnSettingRead = hConnRead;
 260
 261   DPLAYX_ReleaseSemaphore();
 262
 263   return TRUE;
 264 }
 265
 266 static BOOL DPLAYX_GetThisLobbyHandles( LPHANDLE lphStart,
 267                                         LPHANDLE lphDeath,
 268                                         LPHANDLE lphConnRead,
 269                                         BOOL     bClearSetHandles )
 270 {
 271   LPDPLAYX_LOBBYDATA lpLData;
 272
 273   DPLAYX_AcquireSemaphore();
 274
 275   if( !DPLAYX_IsAppIdLobbied( 0, &lpLData ) )
 276   {
 277     DPLAYX_ReleaseSemaphore();
 278     return FALSE;
 279   }
 280
 281   if( lphStart != NULL )
 282   {
 283     if( lpLData->hInformOnAppStart == 0 )
 284     {
 285       DPLAYX_ReleaseSemaphore();
 286       return FALSE;
 287     }
 288
 289     *lphStart = lpLData->hInformOnAppStart;
 290
 291     if( bClearSetHandles )
 292     {
 293       CloseHandle( lpLData->hInformOnAppStart );
 294       lpLData->hInformOnAppStart = 0;
 295     }
 296   }
 297
 298   if( lphDeath != NULL )
 299   {
 300     if( lpLData->hInformOnAppDeath == 0 )
 301     {
 302       DPLAYX_ReleaseSemaphore();
 303       return FALSE;
 304     }
 305
 306     *lphDeath = lpLData->hInformOnAppDeath;
 307
 308     if( bClearSetHandles )
 309     {
 310       CloseHandle( lpLData->hInformOnAppDeath );
 311       lpLData->hInformOnAppDeath = 0;
 312     }
 313   }
 314
 315   if( lphConnRead != NULL )
 316   {
 317     if( lpLData->hInformOnSettingRead == 0 )
 318     {
 319       DPLAYX_ReleaseSemaphore();
 320       return FALSE;
 321     }
 322
 323     *lphConnRead = lpLData->hInformOnSettingRead;
 324
 325     if( bClearSetHandles )
 326     {
 327       CloseHandle( lpLData->hInformOnSettingRead );
 328       lpLData->hInformOnSettingRead = 0;
 329     }
 330   }
 331
 332   DPLAYX_ReleaseSemaphore();
 333
 334   return TRUE;
 335 }
 336
 337 /***************************************************************************
 338  * Called to initialize the global data. This will only be used on the
 339  * loading of the dll
 340  ***************************************************************************/
 341 BOOL DPLAYX_ConstructData(void)
 342 {
 343   SECURITY_ATTRIBUTES s_attrib;
 344   BOOL                bInitializeSharedMemory = FALSE;
 345   LPVOID              lpDesiredMemoryMapStart = (LPVOID)0x50000000;
 346   HANDLE              hInformOnStart;
 347
 348   TRACE( "DPLAYX dll loaded - construct called\n" );
 349
 350   /* Create a semaphore to block access to DPLAYX global data structs */
 351
 352   s_attrib.bInheritHandle       = TRUE;
 353   s_attrib.lpSecurityDescriptor = NULL;
 354   s_attrib.nLength              = sizeof(s_attrib);
 355
 356   hDplayxSema = CreateSemaphoreA( &s_attrib, 0, 1, lpszDplayxSemaName );
 357
 358   /* First instance creates the semaphore. Others just use it */
 359   if( GetLastError() == ERROR_SUCCESS )
 360   {
 361     TRACE( "Semaphore %p created\n", hDplayxSema );
 362
 363     /* The semaphore creator will also build the shared memory */
 364     bInitializeSharedMemory = TRUE;
 365   }
 366   else if ( GetLastError() == ERROR_ALREADY_EXISTS )
 367   {
 368     TRACE( "Found semaphore handle %p\n", hDplayxSema );
 369     DPLAYX_AcquireSemaphore();
 370   }
 371   else
 372   {
 373     ERR( ": semaphore error %d\n", GetLastError() );
 374     return FALSE;
 375   }
 376
 377   SetLastError( ERROR_SUCCESS );
 378
 379   hDplayxSharedMem = CreateFileMappingA( INVALID_HANDLE_VALUE,
 380                                          &s_attrib,
 381                                          PAGE_READWRITE | SEC_COMMIT,
 382                                          0,
 383                                          dwTotalSharedSize,
 384                                          lpszDplayxFileMapping );
 385
 386   if( GetLastError() == ERROR_SUCCESS )
 387   {
 388     TRACE( "File mapped %p created\n", hDplayxSharedMem );
 389   }
 390   else if ( GetLastError() == ERROR_ALREADY_EXISTS )
 391   {
 392     TRACE( "Found FileMapping handle %p\n", hDplayxSharedMem );
 393   }
 394   else
 395   {
 396     ERR( ": unable to create shared memory (%d)\n", GetLastError() );
 397     DPLAYX_ReleaseSemaphore();
 398     return FALSE;
 399   }
 400
 401   lpSharedStaticData = MapViewOfFileEx( hDplayxSharedMem,
 402                                         FILE_MAP_WRITE,
 403                                         0, 0, 0, lpDesiredMemoryMapStart );
 404
 405   if( lpSharedStaticData == NULL )
 406   {
 407     ERR( ": unable to map static data into process memory space (%d)\n",
 408          GetLastError() );
 409     DPLAYX_ReleaseSemaphore();
 410     return FALSE;
 411   }
 412   else
 413   {
 414     if( lpDesiredMemoryMapStart == lpSharedStaticData )
 415     {
 416       TRACE( "File mapped to %p\n", lpSharedStaticData );
 417     }
 418     else
 419     {
 420       /* Presently the shared data structures use pointers. If the
 421        * files are not mapped into the same area, the pointers will no
 422        * longer make any sense :(
 423        * FIXME: In the future make the shared data structures have some
 424        *        sort of fixup to make them independent between data spaces.
 425        *        This will also require a rework of the session data stuff.
 426        */
 427       ERR( "File mapped to %p (not %p). Expect failure\n",
 428             lpSharedStaticData, lpDesiredMemoryMapStart );
 429     }
 430   }
 431
 432   /* Dynamic area starts just after the static area */
 433   lpMemArea = (LPVOID)((BYTE*)lpSharedStaticData + dwStaticSharedSize);
 434
 435   /* FIXME: Crude hack */
 436   lobbyData   = lpSharedStaticData;
 437   sessionData = (DPSESSIONDESC2*)((BYTE*)lpSharedStaticData + (dwStaticSharedSize/2));
 438
 439   /* Initialize shared data segments. */
 440   if( bInitializeSharedMemory )
 441   {
 442     UINT i;
 443
 444     TRACE( "Initializing shared memory\n" );
 445
 446     /* Set all lobbies to be "empty" */
 447     for( i=0; i < numSupportedLobbies; i++ )
 448     {
 449       DPLAYX_InitializeLobbyDataEntry( &lobbyData[ i ] );
 450     }
 451
 452     /* Set all sessions to be "empty" */
 453     for( i=0; i < numSupportedSessions; i++ )
 454     {
 455       sessionData[i].dwSize = 0;
 456     }
 457
 458     /* Zero out the dynamic area */
 459     ZeroMemory( lpMemArea, dwDynamicSharedSize );
 460
 461     /* Just for fun sync the whole data area */
 462     FlushViewOfFile( lpSharedStaticData, dwTotalSharedSize );
 463   }
 464
 465   DPLAYX_ReleaseSemaphore();
 466
 467   /* Everything was created correctly. Signal the lobby client that
 468    * we started up correctly
 469    */
 470   if( DPLAYX_GetThisLobbyHandles( &hInformOnStart, NULL, NULL, FALSE ) &&
 471       hInformOnStart
 472     )
 473   {
 474     BOOL bSuccess;
 475     bSuccess = SetEvent( hInformOnStart );
 476     TRACE( "Signalling lobby app start event %p %s\n",
 477              hInformOnStart, bSuccess ? "succeed" : "failed" );
 478
 479     /* Close out handle */
 480     DPLAYX_GetThisLobbyHandles( &hInformOnStart, NULL, NULL, TRUE );
 481   }
 482
 483   return TRUE;
 484 }
 485
 486 /***************************************************************************
 487  * Called to destroy all global data. This will only be used on the
 488  * unloading of the dll
 489  ***************************************************************************/
 490 BOOL DPLAYX_DestructData(void)
 491 {
 492   HANDLE hInformOnDeath;
 493
 494   TRACE( "DPLAYX dll unloaded - destruct called\n" );
 495
 496   /* If required, inform that this app is dying */
 497   if( DPLAYX_GetThisLobbyHandles( NULL, &hInformOnDeath, NULL, FALSE ) &&
 498       hInformOnDeath
 499     )
 500   {
 501     BOOL bSuccess;
 502     bSuccess = SetEvent( hInformOnDeath );
 503     TRACE( "Signalling lobby app death event %p %s\n",
 504              hInformOnDeath, bSuccess ? "succeed" : "failed" );
 505
 506     /* Close out handle */
 507     DPLAYX_GetThisLobbyHandles( NULL, &hInformOnDeath, NULL, TRUE );
 508   }
 509
 510   /* DO CLEAN UP (LAST) */
 511
 512   /* Delete the semaphore */
 513   CloseHandle( hDplayxSema );
 514
 515   /* Delete shared memory file mapping */
 516   UnmapViewOfFile( lpSharedStaticData );
 517   CloseHandle( hDplayxSharedMem );
 518
 519   return FALSE;
 520 }
 521
 522
 523 /* Assumption: Enough contiguous space was allocated at dest */
 524 static void DPLAYX_CopyConnStructA( LPDPLCONNECTION dest, const DPLCONNECTION *src )
 525 {
 526   BYTE* lpStartOfFreeSpace;
 527
 528   *dest = *src;
 529
 530   lpStartOfFreeSpace = ((BYTE*)dest) + sizeof( DPLCONNECTION );
 531
 532   /* Copy the LPDPSESSIONDESC2 structure if it exists */
 533   if( src->lpSessionDesc )
 534   {
 535     dest->lpSessionDesc = (LPDPSESSIONDESC2)lpStartOfFreeSpace;
 536     lpStartOfFreeSpace += sizeof( DPSESSIONDESC2 );
 537     *dest->lpSessionDesc = *src->lpSessionDesc;
 538
 539     /* Session names may or may not exist */
 540     if( src->lpSessionDesc->u1.lpszSessionNameA )
 541     {
 542       strcpy( (LPSTR)lpStartOfFreeSpace, src->lpSessionDesc->u1.lpszSessionNameA );
 543       dest->lpSessionDesc->u1.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
 544       lpStartOfFreeSpace +=
 545         strlen( dest->lpSessionDesc->u1.lpszSessionNameA ) + 1;
 546     }
 547
 548     if( src->lpSessionDesc->u2.lpszPasswordA )
 549     {
 550       strcpy( (LPSTR)lpStartOfFreeSpace, src->lpSessionDesc->u2.lpszPasswordA );
 551       dest->lpSessionDesc->u2.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
 552       lpStartOfFreeSpace +=
 553         strlen( dest->lpSessionDesc->u2.lpszPasswordA ) + 1;
 554     }
 555   }
 556
 557   /* DPNAME structure is optional */
 558   if( src->lpPlayerName )
 559   {
 560     dest->lpPlayerName = (LPDPNAME)lpStartOfFreeSpace;
 561     lpStartOfFreeSpace += sizeof( DPNAME );
 562     *dest->lpPlayerName = *src->lpPlayerName;
 563
 564     if( src->lpPlayerName->u1.lpszShortNameA )
 565     {
 566       strcpy( (LPSTR)lpStartOfFreeSpace, src->lpPlayerName->u1.lpszShortNameA );
 567       dest->lpPlayerName->u1.lpszShortNameA = (LPSTR)lpStartOfFreeSpace;
 568       lpStartOfFreeSpace +=
 569         strlen( dest->lpPlayerName->u1.lpszShortNameA ) + 1;
 570     }
 571
 572     if( src->lpPlayerName->u2.lpszLongNameA )
 573     {
 574       strcpy( (LPSTR)lpStartOfFreeSpace, src->lpPlayerName->u2.lpszLongNameA );
 575       dest->lpPlayerName->u2.lpszLongNameA = (LPSTR)lpStartOfFreeSpace;
 576       lpStartOfFreeSpace +=
 577         strlen( (LPSTR)dest->lpPlayerName->u2.lpszLongName ) + 1 ;
 578     }
 579
 580   }
 581
 582   /* Copy address if it exists */
 583   if( src->lpAddress )
 584   {
 585     dest->lpAddress = lpStartOfFreeSpace;
 586     CopyMemory( lpStartOfFreeSpace, src->lpAddress, src->dwAddressSize );
 587     /* No need to advance lpStartOfFreeSpace as there is no more "dynamic" data */
 588   }
 589 }
 590
 591 /* Assumption: Enough contiguous space was allocated at dest */
 592 static void DPLAYX_CopyConnStructW( LPDPLCONNECTION dest, const DPLCONNECTION *src )
 593 {
 594   BYTE*              lpStartOfFreeSpace;
 595
 596   *dest = *src;
 597
 598   lpStartOfFreeSpace = ( (BYTE*)dest) + sizeof( DPLCONNECTION );
 599
 600   /* Copy the LPDPSESSIONDESC2 structure if it exists */
 601   if( src->lpSessionDesc )
 602   {
 603     dest->lpSessionDesc = (LPDPSESSIONDESC2)lpStartOfFreeSpace;
 604     lpStartOfFreeSpace += sizeof( DPSESSIONDESC2 );
 605     *dest->lpSessionDesc = *src->lpSessionDesc;
 606
 607     /* Session names may or may not exist */
 608     if( src->lpSessionDesc->u1.lpszSessionName )
 609     {
 610       strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpSessionDesc->u1.lpszSessionName );
 611       dest->lpSessionDesc->u1.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
 612       lpStartOfFreeSpace +=  sizeof(WCHAR) *
 613         ( strlenW( dest->lpSessionDesc->u1.lpszSessionName ) + 1 );
 614     }
 615
 616     if( src->lpSessionDesc->u2.lpszPassword )
 617     {
 618       strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpSessionDesc->u2.lpszPassword );
 619       dest->lpSessionDesc->u2.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
 620       lpStartOfFreeSpace +=  sizeof(WCHAR) *
 621         ( strlenW( dest->lpSessionDesc->u2.lpszPassword ) + 1 );
 622     }
 623   }
 624
 625   /* DPNAME structure is optional */
 626   if( src->lpPlayerName )
 627   {
 628     dest->lpPlayerName = (LPDPNAME)lpStartOfFreeSpace;
 629     lpStartOfFreeSpace += sizeof( DPNAME );
 630     *dest->lpPlayerName = *src->lpPlayerName;
 631
 632     if( src->lpPlayerName->u1.lpszShortName )
 633     {
 634       strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpPlayerName->u1.lpszShortName );
 635       dest->lpPlayerName->u1.lpszShortName = (LPWSTR)lpStartOfFreeSpace;
 636       lpStartOfFreeSpace +=  sizeof(WCHAR) *
 637         ( strlenW( dest->lpPlayerName->u1.lpszShortName ) + 1 );
 638     }
 639
 640     if( src->lpPlayerName->u2.lpszLongName )
 641     {
 642       strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpPlayerName->u2.lpszLongName );
 643       dest->lpPlayerName->u2.lpszLongName = (LPWSTR)lpStartOfFreeSpace;
 644       lpStartOfFreeSpace +=  sizeof(WCHAR) *
 645         ( strlenW( dest->lpPlayerName->u2.lpszLongName ) + 1 );
 646     }
 647
 648   }
 649
 650   /* Copy address if it exists */
 651   if( src->lpAddress )
 652   {
 653     dest->lpAddress = lpStartOfFreeSpace;
 654     CopyMemory( lpStartOfFreeSpace, src->lpAddress, src->dwAddressSize );
 655     /* No need to advance lpStartOfFreeSpace as there is no more "dynamic" data */
 656   }
 657
 658 }
 659
 660 static DWORD DPLAYX_SizeOfLobbyDataA( const DPLCONNECTION *lpConn )
 661 {
 662   DWORD dwTotalSize = sizeof( DPLCONNECTION );
 663
 664   /* Just a safety check */
 665   if( lpConn == NULL )
 666   {
 667     ERR( "lpConn is NULL\n" );
 668     return 0;
 669   }
 670
 671   if( lpConn->lpSessionDesc != NULL )
 672   {
 673     dwTotalSize += sizeof( DPSESSIONDESC2 );
 674
 675     if( lpConn->lpSessionDesc->u1.lpszSessionNameA )
 676     {
 677       dwTotalSize += strlen( lpConn->lpSessionDesc->u1.lpszSessionNameA ) + 1;
 678     }
 679
 680     if( lpConn->lpSessionDesc->u2.lpszPasswordA )
 681     {
 682       dwTotalSize += strlen( lpConn->lpSessionDesc->u2.lpszPasswordA ) + 1;
 683     }
 684   }
 685
 686   if( lpConn->lpPlayerName != NULL )
 687   {
 688     dwTotalSize += sizeof( DPNAME );
 689
 690     if( lpConn->lpPlayerName->u1.lpszShortNameA )
 691     {
 692       dwTotalSize += strlen( lpConn->lpPlayerName->u1.lpszShortNameA ) + 1;
 693     }
 694
 695     if( lpConn->lpPlayerName->u2.lpszLongNameA )
 696     {
 697       dwTotalSize += strlen( lpConn->lpPlayerName->u2.lpszLongNameA ) + 1;
 698     }
 699
 700   }
 701
 702   dwTotalSize += lpConn->dwAddressSize;
 703
 704   return dwTotalSize;
 705 }
 706
 707 static DWORD DPLAYX_SizeOfLobbyDataW( const DPLCONNECTION *lpConn )
 708 {
 709   DWORD dwTotalSize = sizeof( DPLCONNECTION );
 710
 711   /* Just a safety check */
 712   if( lpConn == NULL )
 713   {
 714     ERR( "lpConn is NULL\n" );
 715     return 0;
 716   }
 717
 718   if( lpConn->lpSessionDesc != NULL )
 719   {
 720     dwTotalSize += sizeof( DPSESSIONDESC2 );
 721
 722     if( lpConn->lpSessionDesc->u1.lpszSessionName )
 723     {
 724       dwTotalSize += sizeof( WCHAR ) *
 725         ( strlenW( lpConn->lpSessionDesc->u1.lpszSessionName ) + 1 );
 726     }
 727
 728     if( lpConn->lpSessionDesc->u2.lpszPassword )
 729     {
 730       dwTotalSize += sizeof( WCHAR ) *
 731         ( strlenW( lpConn->lpSessionDesc->u2.lpszPassword ) + 1 );
 732     }
 733   }
 734
 735   if( lpConn->lpPlayerName != NULL )
 736   {
 737     dwTotalSize += sizeof( DPNAME );
 738
 739     if( lpConn->lpPlayerName->u1.lpszShortName )
 740     {
 741       dwTotalSize += sizeof( WCHAR ) *
 742         ( strlenW( lpConn->lpPlayerName->u1.lpszShortName ) + 1 );
 743     }
 744
 745     if( lpConn->lpPlayerName->u2.lpszLongName )
 746     {
 747       dwTotalSize += sizeof( WCHAR ) *
 748         ( strlenW( lpConn->lpPlayerName->u2.lpszLongName ) + 1 );
 749     }
 750
 751   }
 752
 753   dwTotalSize += lpConn->dwAddressSize;
 754
 755   return dwTotalSize;
 756 }
 757
 758 HRESULT DPLAYX_GetConnectionSettingsA
 759 ( DWORD dwAppID,
 760   LPVOID lpData,
 761   LPDWORD lpdwDataSize )
 762 {
 763   LPDPLAYX_LOBBYDATA lpDplData;
 764   DWORD              dwRequiredDataSize = 0;
 765   HANDLE             hInformOnSettingRead;
 766
 767   DPLAYX_AcquireSemaphore();
 768
 769   if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
 770   {
 771     DPLAYX_ReleaseSemaphore();
 772
 773     TRACE( "Application 0x%08x is not lobbied\n", dwAppID );
 774     return DPERR_NOTLOBBIED;
 775   }
 776
 777   dwRequiredDataSize = DPLAYX_SizeOfLobbyDataA( lpDplData->lpConn );
 778
 779   /* Do they want to know the required buffer size or is the provided buffer
 780    * big enough?
 781    */
 782   if ( ( lpData == NULL ) ||
 783        ( *lpdwDataSize < dwRequiredDataSize )
 784      )
 785   {
 786     DPLAYX_ReleaseSemaphore();
 787
 788     *lpdwDataSize = DPLAYX_SizeOfLobbyDataA( lpDplData->lpConn );
 789
 790     return DPERR_BUFFERTOOSMALL;
 791   }
 792
 793   DPLAYX_CopyConnStructA( lpData, lpDplData->lpConn );
 794
 795   DPLAYX_ReleaseSemaphore();
 796
 797   /* They have gotten the information - signal the event if required */
 798   if( DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, FALSE ) &&
 799       hInformOnSettingRead
 800     )
 801   {
 802     BOOL bSuccess;
 803     bSuccess = SetEvent( hInformOnSettingRead );
 804     TRACE( "Signalling setting read event %p %s\n",
 805              hInformOnSettingRead, bSuccess ? "succeed" : "failed" );
 806
 807     /* Close out handle */
 808     DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, TRUE );
 809   }
 810
 811   return DP_OK;
 812 }
 813
 814 HRESULT DPLAYX_GetConnectionSettingsW
 815 ( DWORD dwAppID,
 816   LPVOID lpData,
 817   LPDWORD lpdwDataSize )
 818 {
 819   LPDPLAYX_LOBBYDATA lpDplData;
 820   DWORD              dwRequiredDataSize = 0;
 821   HANDLE             hInformOnSettingRead;
 822
 823   DPLAYX_AcquireSemaphore();
 824
 825   if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
 826   {
 827     DPLAYX_ReleaseSemaphore();
 828     return DPERR_NOTLOBBIED;
 829   }
 830
 831   dwRequiredDataSize = DPLAYX_SizeOfLobbyDataW( lpDplData->lpConn );
 832
 833   /* Do they want to know the required buffer size or is the provided buffer
 834    * big enough?
 835    */
 836   if ( ( lpData == NULL ) ||
 837        ( *lpdwDataSize < dwRequiredDataSize )
 838      )
 839   {
 840     DPLAYX_ReleaseSemaphore();
 841
 842     *lpdwDataSize = DPLAYX_SizeOfLobbyDataW( lpDplData->lpConn );
 843
 844     return DPERR_BUFFERTOOSMALL;
 845   }
 846
 847   DPLAYX_CopyConnStructW( lpData, lpDplData->lpConn );
 848
 849   DPLAYX_ReleaseSemaphore();
 850
 851   /* They have gotten the information - signal the event if required */
 852   if( DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, FALSE ) &&
 853       hInformOnSettingRead
 854     )
 855   {
 856     BOOL bSuccess;
 857     bSuccess = SetEvent( hInformOnSettingRead );
 858     TRACE( "Signalling setting read event %p %s\n",
 859              hInformOnSettingRead, bSuccess ? "succeed" : "failed" );
 860
 861     /* Close out handle */
 862     DPLAYX_GetThisLobbyHandles( NULL, NULL, &hInformOnSettingRead, TRUE );
 863   }
 864
 865   return DP_OK;
 866 }
 867
 868 /* Store the structure into the shared data structure. Ensure that allocs for
 869  * variable length strings come from the shared data structure.
 870  * FIXME: We need to free information as well.
 871  */
 872 HRESULT DPLAYX_SetConnectionSettingsA
 873 ( DWORD dwFlags,
 874   DWORD dwAppID,
 875   const DPLCONNECTION *lpConn )
 876 {
 877   LPDPLAYX_LOBBYDATA lpDplData;
 878
 879   /* Parameter check */
 880   if( dwFlags || !lpConn )
 881   {
 882     ERR("invalid parameters.\n");
 883     return DPERR_INVALIDPARAMS;
 884   }
 885
 886   /* Store information */
 887   if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
 888   {
 889     ERR(": old/new DPLCONNECTION type? Size=%08x\n", lpConn->dwSize );
 890
 891     return DPERR_INVALIDPARAMS;
 892   }
 893
 894   DPLAYX_AcquireSemaphore();
 895
 896   if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
 897   {
 898     DPLAYX_ReleaseSemaphore();
 899
 900     return DPERR_NOTLOBBIED;
 901   }
 902
 903   if(  (!lpConn->lpSessionDesc ) ||
 904        ( lpConn->lpSessionDesc->dwSize != sizeof( DPSESSIONDESC2 ) )
 905     )
 906   {
 907     DPLAYX_ReleaseSemaphore();
 908
 909     ERR("DPSESSIONDESC passed in? Size=%u\n",
 910         lpConn->lpSessionDesc?lpConn->lpSessionDesc->dwSize:0 );
 911
 912     return DPERR_INVALIDPARAMS;
 913   }
 914
 915   /* Free the existing memory */
 916   DPLAYX_PrivHeapFree( lpDplData->lpConn );
 917
 918   lpDplData->lpConn = DPLAYX_PrivHeapAlloc( HEAP_ZERO_MEMORY,
 919                                             DPLAYX_SizeOfLobbyDataA( lpConn ) );
 920
 921   DPLAYX_CopyConnStructA( lpDplData->lpConn, lpConn );
 922
 923
 924   DPLAYX_ReleaseSemaphore();
 925
 926   /* FIXME: Send a message - I think */
 927
 928   return DP_OK;
 929 }
 930
 931 /* Store the structure into the shared data structure. Ensure that allocs for
 932  * variable length strings come from the shared data structure.
 933  * FIXME: We need to free information as well
 934  */
 935 HRESULT DPLAYX_SetConnectionSettingsW
 936 ( DWORD dwFlags,
 937   DWORD dwAppID,
 938   const DPLCONNECTION *lpConn )
 939 {
 940   LPDPLAYX_LOBBYDATA lpDplData;
 941
 942   /* Parameter check */
 943   if( dwFlags || !lpConn )
 944   {
 945     ERR("invalid parameters.\n");
 946     return DPERR_INVALIDPARAMS;
 947   }
 948
 949   /* Store information */
 950   if(  lpConn->dwSize != sizeof(DPLCONNECTION) )
 951   {
 952     ERR(": old/new DPLCONNECTION type? Size=%u\n", lpConn->dwSize );
 953
 954     return DPERR_INVALIDPARAMS;
 955   }
 956
 957   DPLAYX_AcquireSemaphore();
 958
 959   if ( ! DPLAYX_IsAppIdLobbied( dwAppID, &lpDplData ) )
 960   {
 961     DPLAYX_ReleaseSemaphore();
 962
 963     return DPERR_NOTLOBBIED;
 964   }
 965
 966   /* Free the existing memory */
 967   DPLAYX_PrivHeapFree( lpDplData->lpConn );
 968
 969   lpDplData->lpConn = DPLAYX_PrivHeapAlloc( HEAP_ZERO_MEMORY,
 970                                             DPLAYX_SizeOfLobbyDataW( lpConn ) );
 971
 972   DPLAYX_CopyConnStructW( lpDplData->lpConn, lpConn );
 973
 974
 975   DPLAYX_ReleaseSemaphore();
 976
 977   /* FIXME: Send a message - I think */
 978
 979   return DP_OK;
 980 }
 981
 982 BOOL DPLAYX_WaitForConnectionSettings( BOOL bWait )
 983 {
 984   LPDPLAYX_LOBBYDATA lpLobbyData;
 985
 986   DPLAYX_AcquireSemaphore();
 987
 988   if( !DPLAYX_IsAppIdLobbied( 0, &lpLobbyData ) )
 989   {
 990     DPLAYX_ReleaseSemaphore();
 991     return FALSE;
 992   }
 993
 994   lpLobbyData->bWaitForConnectionSettings = bWait;
 995
 996   DPLAYX_ReleaseSemaphore();
 997
 998   return TRUE;
 999 }
1000
1001 BOOL DPLAYX_AnyLobbiesWaitingForConnSettings(void)
1002 {
1003   UINT i;
1004   BOOL bFound = FALSE;
1005
1006   DPLAYX_AcquireSemaphore();
1007
1008   for( i=0; i < numSupportedLobbies; i++ )
1009   {
1010     if( ( lobbyData[ i ].dwAppID != 0 ) &&            /* lobby initialized */
1011         ( lobbyData[ i ].bWaitForConnectionSettings ) /* Waiting */
1012       )
1013     {
1014       bFound = TRUE;
1015       break;
1016     }
1017   }
1018
1019   DPLAYX_ReleaseSemaphore();
1020
1021   return bFound;
1022 }
1023
1024 BOOL DPLAYX_SetLobbyMsgThreadId( DWORD dwAppId, DWORD dwThreadId )
1025 {
1026   LPDPLAYX_LOBBYDATA lpLobbyData;
1027
1028   DPLAYX_AcquireSemaphore();
1029
1030   if( !DPLAYX_IsAppIdLobbied( dwAppId, &lpLobbyData ) )
1031   {
1032     DPLAYX_ReleaseSemaphore();
1033     return FALSE;
1034   }
1035
1036   lpLobbyData->dwLobbyMsgThreadId = dwThreadId;
1037
1038   DPLAYX_ReleaseSemaphore();
1039
1040   return TRUE;
1041 }
1042
1043 /* NOTE: This is potentially not thread safe. You are not guaranteed to end up
1044          with the correct string printed in the case where the HRESULT is not
1045          known. You will just get the last hr passed in. This can change
1046          over time if this method is used a lot :) */
1047 LPCSTR DPLAYX_HresultToString(HRESULT hr)
1048 {
1049   static char szTempStr[12];
1050
1051   switch (hr)
1052   {
1053     case DP_OK:
1054       return "DP_OK";
1055     case DPERR_ALREADYINITIALIZED:
1056       return "DPERR_ALREADYINITIALIZED";
1057     case DPERR_ACCESSDENIED:
1058       return "DPERR_ACCESSDENIED";
1059     case DPERR_ACTIVEPLAYERS:
1060       return "DPERR_ACTIVEPLAYERS";
1061     case DPERR_BUFFERTOOSMALL:
1062       return "DPERR_BUFFERTOOSMALL";
1063     case DPERR_CANTADDPLAYER:
1064       return "DPERR_CANTADDPLAYER";
1065     case DPERR_CANTCREATEGROUP:
1066       return "DPERR_CANTCREATEGROUP";
1067     case DPERR_CANTCREATEPLAYER:
1068       return "DPERR_CANTCREATEPLAYER";
1069     case DPERR_CANTCREATESESSION:
1070       return "DPERR_CANTCREATESESSION";
1071     case DPERR_CAPSNOTAVAILABLEYET:
1072       return "DPERR_CAPSNOTAVAILABLEYET";
1073     case DPERR_EXCEPTION:
1074       return "DPERR_EXCEPTION";
1075     case DPERR_GENERIC:
1076       return "DPERR_GENERIC";
1077     case DPERR_INVALIDFLAGS:
1078       return "DPERR_INVALIDFLAGS";
1079     case DPERR_INVALIDOBJECT:
1080       return "DPERR_INVALIDOBJECT";
1081     case DPERR_INVALIDPARAMS:
1082       return "DPERR_INVALIDPARAMS";
1083     case DPERR_INVALIDPLAYER:
1084       return "DPERR_INVALIDPLAYER";
1085     case DPERR_INVALIDGROUP:
1086       return "DPERR_INVALIDGROUP";
1087     case DPERR_NOCAPS:
1088       return "DPERR_NOCAPS";
1089     case DPERR_NOCONNECTION:
1090       return "DPERR_NOCONNECTION";
1091     case DPERR_OUTOFMEMORY:
1092       return "DPERR_OUTOFMEMORY";
1093     case DPERR_NOMESSAGES:
1094       return "DPERR_NOMESSAGES";
1095     case DPERR_NONAMESERVERFOUND:
1096       return "DPERR_NONAMESERVERFOUND";
1097     case DPERR_NOPLAYERS:
1098       return "DPERR_NOPLAYERS";
1099     case DPERR_NOSESSIONS:
1100       return "DPERR_NOSESSIONS";
1101     case DPERR_PENDING:
1102       return "DPERR_PENDING";
1103     case DPERR_SENDTOOBIG:
1104       return "DPERR_SENDTOOBIG";
1105     case DPERR_TIMEOUT:
1106       return "DPERR_TIMEOUT";
1107     case DPERR_UNAVAILABLE:
1108       return "DPERR_UNAVAILABLE";
1109     case DPERR_UNSUPPORTED:
1110       return "DPERR_UNSUPPORTED";
1111     case DPERR_BUSY:
1112       return "DPERR_BUSY";
1113     case DPERR_USERCANCEL:
1114       return "DPERR_USERCANCEL";
1115     case DPERR_NOINTERFACE:
1116       return "DPERR_NOINTERFACE";
1117     case DPERR_CANNOTCREATESERVER:
1118       return "DPERR_CANNOTCREATESERVER";
1119     case DPERR_PLAYERLOST:
1120       return "DPERR_PLAYERLOST";
1121     case DPERR_SESSIONLOST:
1122       return "DPERR_SESSIONLOST";
1123     case DPERR_UNINITIALIZED:
1124       return "DPERR_UNINITIALIZED";
1125     case DPERR_NONEWPLAYERS:
1126       return "DPERR_NONEWPLAYERS";
1127     case DPERR_INVALIDPASSWORD:
1128       return "DPERR_INVALIDPASSWORD";
1129     case DPERR_CONNECTING:
1130       return "DPERR_CONNECTING";
1131     case DPERR_CONNECTIONLOST:
1132       return "DPERR_CONNECTIONLOST";
1133     case DPERR_UNKNOWNMESSAGE:
1134       return "DPERR_UNKNOWNMESSAGE";
1135     case DPERR_CANCELFAILED:
1136       return "DPERR_CANCELFAILED";
1137     case DPERR_INVALIDPRIORITY:
1138       return "DPERR_INVALIDPRIORITY";
1139     case DPERR_NOTHANDLED:
1140       return "DPERR_NOTHANDLED";
1141     case DPERR_CANCELLED:
1142       return "DPERR_CANCELLED";
1143     case DPERR_ABORTED:
1144       return "DPERR_ABORTED";
1145     case DPERR_BUFFERTOOLARGE:
1146       return "DPERR_BUFFERTOOLARGE";
1147     case DPERR_CANTCREATEPROCESS:
1148       return "DPERR_CANTCREATEPROCESS";
1149     case DPERR_APPNOTSTARTED:
1150       return "DPERR_APPNOTSTARTED";
1151     case DPERR_INVALIDINTERFACE:
1152       return "DPERR_INVALIDINTERFACE";
1153     case DPERR_NOSERVICEPROVIDER:
1154       return "DPERR_NOSERVICEPROVIDER";
1155     case DPERR_UNKNOWNAPPLICATION:
1156       return "DPERR_UNKNOWNAPPLICATION";
1157     case DPERR_NOTLOBBIED:
1158       return "DPERR_NOTLOBBIED";
1159     case DPERR_SERVICEPROVIDERLOADED:
1160       return "DPERR_SERVICEPROVIDERLOADED";
1161     case DPERR_ALREADYREGISTERED:
1162       return "DPERR_ALREADYREGISTERED";
1163     case DPERR_NOTREGISTERED:
1164       return "DPERR_NOTREGISTERED";
1165     case DPERR_AUTHENTICATIONFAILED:
1166       return "DPERR_AUTHENTICATIONFAILED";
1167     case DPERR_CANTLOADSSPI:
1168       return "DPERR_CANTLOADSSPI";
1169     case DPERR_ENCRYPTIONFAILED:
1170       return "DPERR_ENCRYPTIONFAILED";
1171     case DPERR_SIGNFAILED:
1172       return "DPERR_SIGNFAILED";
1173     case DPERR_CANTLOADSECURITYPACKAGE:
1174       return "DPERR_CANTLOADSECURITYPACKAGE";
1175     case DPERR_ENCRYPTIONNOTSUPPORTED:
1176       return "DPERR_ENCRYPTIONNOTSUPPORTED";
1177     case DPERR_CANTLOADCAPI:
1178       return "DPERR_CANTLOADCAPI";
1179     case DPERR_NOTLOGGEDIN:
1180       return "DPERR_NOTLOGGEDIN";
1181     case DPERR_LOGONDENIED:
1182       return "DPERR_LOGONDENIED";
1183     default:
1184       /* For errors not in the list, return HRESULT as a string
1185          This part is not thread safe */
1186       WARN( "Unknown error 0x%08x\n", hr );
1187       wsprintfA( szTempStr, "0x%08x", hr );
1188       return szTempStr;
1189   }
1190 }