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