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