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