VBoxTray.cpp@ 75407

Last change on this file since 75407 was 75407, checked in by vboxsync, 6 years ago

VBoxSharedFolders,VBoxService,VBoxTray: New go at auto mounting shared folders, now also at runtime. bugref:3544

Added three new functions to the shared folders service:
1. query mountpoint and everything else about a shared folder.
2. wait for folder (mappings) config changes.
3. cancel such waits.
Relaxed some of the check wrt placeholder folders so that the GUI can succesfully make changes to a folder while it is being used. The old code would end up failing if the guest was using the folder because of a (placeholder) duplicate.
Ran into some weird weird flag passing between service.cpp and vbsfMappingsQuery via pClient->fu32Flags. Didn't make sense to me and clashed with a new flag I added for the wait cancellation, so I changed it to use a parameter (fOnlyAutoMounts) for the purpose.
Pointed out that vbsfMappingsQuery is weird in a the way it doesn't return an overflow indicator, meaning that the guest library wrapper's checks for VINF_BUFFER_OVERFLOW is pointless.
In VBoxService I've reimplemented the automounter subservice. Only tested with a windows 7 guest so far. Highlights:
- Use host specified mount points / drive letters.
- Adjust to changes in mapping configuration.
- Mappings should be global on windows guests, given that VBoxService runs under the System user (only verified on Win7).
One TODO is that I would like to try relocate a mapping that's not on the specified mount point once the mount point is freed up.
VBoxTray no longer maps shared folder on startup.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 63.5 KB

Line
1	/* $Id: VBoxTray.cpp 75407 2018-11-12 20:06:57Z vboxsync $ */
2	/** @file
3	* VBoxTray - Guest Additions Tray Application
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <package-generated.h>
23	#include "product-generated.h"
24
25	#include "VBoxTray.h"
26	#include "VBoxTrayMsg.h"
27	#include "VBoxHelpers.h"
28	#include "VBoxSeamless.h"
29	#include "VBoxClipboard.h"
30	#include "VBoxDisplay.h"
31	#include "VBoxVRDP.h"
32	#include "VBoxHostVersion.h"
33	#ifdef VBOX_WITH_SHARED_FOLDERS
34	# include "VBoxSharedFolders.h"
35	#endif
36	#ifdef VBOX_WITH_DRAG_AND_DROP
37	# include "VBoxDnD.h"
38	#endif
39	#include "VBoxIPC.h"
40	#include "VBoxLA.h"
41	#include <VBoxHook.h>
42	#include "resource.h"
43
44	#include <sddl.h>
45
46	#include <iprt/asm.h>
47	#include <iprt/buildconfig.h>
48	#include <iprt/ldr.h>
49	#include <iprt/path.h>
50	#include <iprt/process.h>
51	#include <iprt/system.h>
52	#include <iprt/time.h>
53
54	#ifdef DEBUG
55	# define LOG_ENABLED
56	# define LOG_GROUP LOG_GROUP_DEFAULT
57	#endif
58	#include <VBox/log.h>
59
60	/* Default desktop state tracking */
61	#include <Wtsapi32.h>
62
63	/*
64	* St (session [state] tracking) functionality API
65	*
66	* !!!NOTE: this API is NOT thread-safe!!!
67	* it is supposed to be called & used from within the window message handler thread
68	* of the window passed to vboxStInit */
69	static int vboxStInit(HWND hWnd);
70	static void vboxStTerm(void);
71	/* @returns true on "IsActiveConsole" state change */
72	static BOOL vboxStHandleEvent(WPARAM EventID);
73	static BOOL vboxStIsActiveConsole();
74	static BOOL vboxStCheckTimer(WPARAM wEvent);
75
76	/*
77	* Dt (desktop [state] tracking) functionality API
78	*
79	* !!!NOTE: this API is NOT thread-safe!!!
80	* */
81	static int vboxDtInit();
82	static void vboxDtTerm();
83	/* @returns true on "IsInputDesktop" state change */
84	static BOOL vboxDtHandleEvent();
85	/* @returns true iff the application (VBoxTray) desktop is input */
86	static BOOL vboxDtIsInputDesktop();
87	static HANDLE vboxDtGetNotifyEvent();
88	static BOOL vboxDtCheckTimer(WPARAM wParam);
89
90	/* caps API */
91	#define VBOXCAPS_ENTRY_IDX_SEAMLESS 0
92	#define VBOXCAPS_ENTRY_IDX_GRAPHICS 1
93	#define VBOXCAPS_ENTRY_IDX_COUNT 2
94
95	typedef enum VBOXCAPS_ENTRY_FUNCSTATE
96	{
97	/* the cap is unsupported */
98	VBOXCAPS_ENTRY_FUNCSTATE_UNSUPPORTED = 0,
99	/* the cap is supported */
100	VBOXCAPS_ENTRY_FUNCSTATE_SUPPORTED,
101	/* the cap functionality is started, it can be disabled however if its AcState is not ACQUIRED */
102	VBOXCAPS_ENTRY_FUNCSTATE_STARTED,
103	} VBOXCAPS_ENTRY_FUNCSTATE;
104
105
106	static void VBoxCapsEntryFuncStateSet(uint32_t iCup, VBOXCAPS_ENTRY_FUNCSTATE enmFuncState);
107	static int VBoxCapsInit();
108	static int VBoxCapsReleaseAll();
109	static void VBoxCapsTerm();
110	static BOOL VBoxCapsEntryIsAcquired(uint32_t iCap);
111	static BOOL VBoxCapsEntryIsEnabled(uint32_t iCap);
112	static BOOL VBoxCapsCheckTimer(WPARAM wParam);
113	static int VBoxCapsEntryRelease(uint32_t iCap);
114	static int VBoxCapsEntryAcquire(uint32_t iCap);
115	static int VBoxCapsAcquireAllSupported();
116
117	/* console-related caps API */
118	static BOOL VBoxConsoleIsAllowed();
119	static void VBoxConsoleEnable(BOOL fEnable);
120	static void VBoxConsoleCapSetSupported(uint32_t iCap, BOOL fSupported);
121
122	static void VBoxGrapicsSetSupported(BOOL fSupported);
123
124
125	/*********************************************************************************************************************************
126	* Internal Functions *
127	*********************************************************************************************************************************/
128	static int vboxTrayCreateTrayIcon(void);
129	static LRESULT CALLBACK vboxToolWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
130
131	/* Global message handler prototypes. */
132	static int vboxTrayGlMsgTaskbarCreated(WPARAM lParam, LPARAM wParam);
133	/static int vboxTrayGlMsgShowBalloonMsg(WPARAM lParam, LPARAM wParam);/
134
135	static int VBoxAcquireGuestCaps(uint32_t fOr, uint32_t fNot, bool fCfg);
136
137
138	/*********************************************************************************************************************************
139	* Global Variables *
140	*********************************************************************************************************************************/
141	HANDLE g_hStopSem;
142	HANDLE g_hSeamlessWtNotifyEvent = 0;
143	HANDLE g_hSeamlessKmNotifyEvent = 0;
144	HINSTANCE g_hInstance;
145	HWND g_hwndToolWindow;
146	NOTIFYICONDATA g_NotifyIconData;
147	DWORD g_dwMajorVersion;
148
149	uint32_t g_fGuestDisplaysChanged = 0;
150
151	static PRTLOGGER g_pLoggerRelease = NULL;
152	static uint32_t g_cHistory = 10; /* Enable log rotation, 10 files. */
153	static uint32_t g_uHistoryFileTime = RT_SEC_1DAY; /* Max 1 day per file. */
154	static uint64_t g_uHistoryFileSize = 100 * _1M; /* Max 100MB per file. */
155
156	/**
157	* The details of the services that has been compiled in.
158	*/
159	static VBOXSERVICEINFO g_aServices[] =
160	{
161	{ &g_SvcDescDisplay, NIL_RTTHREAD, NULL, false, false, false, false, true },
162	{ &g_SvcDescClipboard, NIL_RTTHREAD, NULL, false, false, false, false, true },
163	{ &g_SvcDescSeamless, NIL_RTTHREAD, NULL, false, false, false, false, true },
164	{ &g_SvcDescVRDP, NIL_RTTHREAD, NULL, false, false, false, false, true },
165	{ &g_SvcDescIPC, NIL_RTTHREAD, NULL, false, false, false, false, true },
166	{ &g_SvcDescLA, NIL_RTTHREAD, NULL, false, false, false, false, true },
167	#ifdef VBOX_WITH_DRAG_AND_DROP
168	{ &g_SvcDescDnD, NIL_RTTHREAD, NULL, false, false, false, false, true }
169	#endif
170	};
171
172	/* The global message table. */
173	static VBOXGLOBALMESSAGE g_vboxGlobalMessageTable[] =
174	{
175	/* Windows specific stuff. */
176	{
177	"TaskbarCreated",
178	vboxTrayGlMsgTaskbarCreated
179	},
180
181	/* VBoxTray specific stuff. */
182	/** @todo Add new messages here! */
183
184	{
185	NULL
186	}
187	};
188
189	/**
190	* Gets called whenever the Windows main taskbar
191	* get (re-)created. Nice to install our tray icon.
192	*
193	* @return IPRT status code.
194	* @param wParam
195	* @param lParam
196	*/
197	static int vboxTrayGlMsgTaskbarCreated(WPARAM wParam, LPARAM lParam)
198	{
199	RT_NOREF(wParam, lParam);
200	return vboxTrayCreateTrayIcon();
201	}
202
203	static int vboxTrayCreateTrayIcon(void)
204	{
205	HICON hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_VIRTUALBOX));
206	if (hIcon == NULL)
207	{
208	DWORD dwErr = GetLastError();
209	LogFunc(("Could not load tray icon, error %08X\n", dwErr));
210	return RTErrConvertFromWin32(dwErr);
211	}
212
213	/* Prepare the system tray icon. */
214	RT_ZERO(g_NotifyIconData);
215	g_NotifyIconData.cbSize = NOTIFYICONDATA_V1_SIZE; // sizeof(NOTIFYICONDATA);
216	g_NotifyIconData.hWnd = g_hwndToolWindow;
217	g_NotifyIconData.uID = ID_TRAYICON;
218	g_NotifyIconData.uFlags = NIF_ICON \| NIF_MESSAGE \| NIF_TIP;
219	g_NotifyIconData.uCallbackMessage = WM_VBOXTRAY_TRAY_ICON;
220	g_NotifyIconData.hIcon = hIcon;
221
222	sprintf(g_NotifyIconData.szTip, "%s Guest Additions %d.%d.%dr%d",
223	VBOX_PRODUCT, VBOX_VERSION_MAJOR, VBOX_VERSION_MINOR, VBOX_VERSION_BUILD, VBOX_SVN_REV);
224
225	int rc = VINF_SUCCESS;
226	if (!Shell_NotifyIcon(NIM_ADD, &g_NotifyIconData))
227	{
228	DWORD dwErr = GetLastError();
229	LogFunc(("Could not create tray icon, error=%ld\n", dwErr));
230	rc = RTErrConvertFromWin32(dwErr);
231	RT_ZERO(g_NotifyIconData);
232	}
233
234	if (hIcon)
235	DestroyIcon(hIcon);
236	return rc;
237	}
238
239	static void vboxTrayRemoveTrayIcon(void)
240	{
241	if (g_NotifyIconData.cbSize > 0)
242	{
243	/* Remove the system tray icon and refresh system tray. */
244	Shell_NotifyIcon(NIM_DELETE, &g_NotifyIconData);
245	HWND hTrayWnd = FindWindow("Shell_TrayWnd", NULL); /* We assume we only have one tray atm. */
246	if (hTrayWnd)
247	{
248	HWND hTrayNotifyWnd = FindWindowEx(hTrayWnd, 0, "TrayNotifyWnd", NULL);
249	if (hTrayNotifyWnd)
250	SendMessage(hTrayNotifyWnd, WM_PAINT, 0, NULL);
251	}
252	RT_ZERO(g_NotifyIconData);
253	}
254	}
255
256	/**
257	* The service thread.
258	*
259	* @returns Whatever the worker function returns.
260	* @param ThreadSelf My thread handle.
261	* @param pvUser The service index.
262	*/
263	static DECLCALLBACK(int) vboxTrayServiceThread(RTTHREAD ThreadSelf, void *pvUser)
264	{
265	PVBOXSERVICEINFO pSvc = (PVBOXSERVICEINFO)pvUser;
266	AssertPtr(pSvc);
267
268	#ifndef RT_OS_WINDOWS
269	/*
270	* Block all signals for this thread. Only the main thread will handle signals.
271	*/
272	sigset_t signalMask;
273	sigfillset(&signalMask);
274	pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
275	#endif
276
277	int rc = pSvc->pDesc->pfnWorker(pSvc->pInstance, &pSvc->fShutdown);
278	ASMAtomicXchgBool(&pSvc->fShutdown, true);
279	RTThreadUserSignal(ThreadSelf);
280
281	LogFunc(("Worker for '%s' ended with %Rrc\n", pSvc->pDesc->pszName, rc));
282	return rc;
283	}
284
285	static int vboxTrayServicesStart(PVBOXSERVICEENV pEnv)
286	{
287	AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
288
289	LogRel(("Starting services ...\n"));
290
291	int rc = VINF_SUCCESS;
292
293	for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
294	{
295	PVBOXSERVICEINFO pSvc = &g_aServices[i];
296	LogRel(("Starting service '%s' ...\n", pSvc->pDesc->pszName));
297
298	pSvc->hThread = NIL_RTTHREAD;
299	pSvc->pInstance = NULL;
300	pSvc->fStarted = false;
301	pSvc->fShutdown = false;
302
303	int rc2 = VINF_SUCCESS;
304
305	if (pSvc->pDesc->pfnInit)
306	rc2 = pSvc->pDesc->pfnInit(pEnv, &pSvc->pInstance);
307
308	if (RT_FAILURE(rc2))
309	{
310	LogRel(("Failed to initialize service '%s', rc=%Rrc\n", pSvc->pDesc->pszName, rc2));
311	if (rc2 == VERR_NOT_SUPPORTED)
312	{
313	LogRel(("Service '%s' is not supported on this system\n", pSvc->pDesc->pszName));
314	rc2 = VINF_SUCCESS;
315	}
316	/* Keep going. */
317	}
318	else
319	{
320	if (pSvc->pDesc->pfnWorker)
321	{
322	rc2 = RTThreadCreate(&pSvc->hThread, vboxTrayServiceThread, pSvc /* pvUser */,
323	0 /* Default stack size */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, pSvc->pDesc->pszName);
324	if (RT_SUCCESS(rc2))
325	{
326	pSvc->fStarted = true;
327
328	RTThreadUserWait(pSvc->hThread, 30 * 1000 /* Timeout in ms */);
329	if (pSvc->fShutdown)
330	{
331	LogRel(("Service '%s' failed to start!\n", pSvc->pDesc->pszName));
332	rc = VERR_GENERAL_FAILURE;
333	}
334	else
335	LogRel(("Service '%s' started\n", pSvc->pDesc->pszName));
336	}
337	else
338	{
339	LogRel(("Failed to start thread for service '%s': %Rrc\n", rc2));
340	if (pSvc->pDesc->pfnDestroy)
341	pSvc->pDesc->pfnDestroy(pSvc->pInstance);
342	}
343	}
344	}
345
346	if (RT_SUCCESS(rc))
347	rc = rc2;
348	}
349
350	if (RT_SUCCESS(rc))
351	LogRel(("All services started\n"));
352	else
353	LogRel(("Services started, but some with errors\n"));
354
355	LogFlowFuncLeaveRC(rc);
356	return rc;
357	}
358
359	static int vboxTrayServicesStop(VBOXSERVICEENV *pEnv)
360	{
361	AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
362
363	LogRel2(("Stopping all services ...\n"));
364
365	/*
366	* Signal all the services.
367	*/
368	for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
369	ASMAtomicWriteBool(&g_aServices[i].fShutdown, true);
370
371	/*
372	* Do the pfnStop callback on all running services.
373	*/
374	for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
375	{
376	PVBOXSERVICEINFO pSvc = &g_aServices[i];
377	if ( pSvc->fStarted
378	&& pSvc->pDesc->pfnStop)
379	{
380	LogRel2(("Calling stop function for service '%s' ...\n", pSvc->pDesc->pszName));
381	int rc2 = pSvc->pDesc->pfnStop(pSvc->pInstance);
382	if (RT_FAILURE(rc2))
383	LogRel(("Failed to stop service '%s': %Rrc\n", pSvc->pDesc->pszName, rc2));
384	}
385	}
386
387	LogRel2(("All stop functions for services called\n"));
388
389	int rc = VINF_SUCCESS;
390
391	/*
392	* Wait for all the service threads to complete.
393	*/
394	for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
395	{
396	PVBOXSERVICEINFO pSvc = &g_aServices[i];
397	if (!pSvc->fEnabled) /* Only stop services which were started before. */
398	continue;
399
400	if (pSvc->hThread != NIL_RTTHREAD)
401	{
402	LogRel2(("Waiting for service '%s' to stop ...\n", pSvc->pDesc->pszName));
403	int rc2 = VINF_SUCCESS;
404	for (int j = 0; j < 30; j++) /* Wait 30 seconds in total */
405	{
406	rc2 = RTThreadWait(pSvc->hThread, 1000 /* Wait 1 second */, NULL);
407	if (RT_SUCCESS(rc2))
408	break;
409	}
410	if (RT_FAILURE(rc2))
411	{
412	LogRel(("Service '%s' failed to stop (%Rrc)\n", pSvc->pDesc->pszName, rc2));
413	if (RT_SUCCESS(rc))
414	rc = rc2;
415	}
416	}
417
418	if (pSvc->pDesc->pfnDestroy)
419	{
420	LogRel2(("Terminating service '%s' ...\n", pSvc->pDesc->pszName));
421	pSvc->pDesc->pfnDestroy(pSvc->pInstance);
422	}
423	}
424
425	if (RT_SUCCESS(rc))
426	LogRel(("All services stopped\n"));
427
428	LogFlowFuncLeaveRC(rc);
429	return rc;
430	}
431
432	static int vboxTrayRegisterGlobalMessages(PVBOXGLOBALMESSAGE pTable)
433	{
434	int rc = VINF_SUCCESS;
435	if (pTable == NULL) /* No table to register? Skip. */
436	return rc;
437	while ( pTable->pszName
438	&& RT_SUCCESS(rc))
439	{
440	/* Register global accessible window messages. */
441	pTable->uMsgID = RegisterWindowMessage(TEXT(pTable->pszName));
442	if (!pTable->uMsgID)
443	{
444	DWORD dwErr = GetLastError();
445	Log(("Registering global message \"%s\" failed, error = %08X\n", dwErr));
446	rc = RTErrConvertFromWin32(dwErr);
447	}
448
449	/* Advance to next table element. */
450	pTable++;
451	}
452	return rc;
453	}
454
455	static bool vboxTrayHandleGlobalMessages(PVBOXGLOBALMESSAGE pTable, UINT uMsg,
456	WPARAM wParam, LPARAM lParam)
457	{
458	if (pTable == NULL)
459	return false;
460	while (pTable && pTable->pszName)
461	{
462	if (pTable->uMsgID == uMsg)
463	{
464	if (pTable->pfnHandler)
465	pTable->pfnHandler(wParam, lParam);
466	return true;
467	}
468
469	/* Advance to next table element. */
470	pTable++;
471	}
472	return false;
473	}
474
475	/**
476	* Release logger callback.
477	*
478	* @return IPRT status code.
479	* @param pLoggerRelease
480	* @param enmPhase
481	* @param pfnLog
482	*/
483	static void vboxTrayLogHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
484	{
485	/* Some introductory information. */
486	static RTTIMESPEC s_TimeSpec;
487	char szTmp[256];
488	if (enmPhase == RTLOGPHASE_BEGIN)
489	RTTimeNow(&s_TimeSpec);
490	RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
491
492	switch (enmPhase)
493	{
494	case RTLOGPHASE_BEGIN:
495	{
496	pfnLog(pLoggerRelease,
497	"VBoxTray %s r%s %s (%s %s) release log\n"
498	"Log opened %s\n",
499	RTBldCfgVersion(), RTBldCfgRevisionStr(), VBOX_BUILD_TARGET,
500	__DATE__, __TIME__, szTmp);
501
502	int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
503	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
504	pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
505	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
506	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
507	pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
508	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
509	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
510	pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
511	if (RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW)
512	pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
513
514	/* the package type is interesting for Linux distributions */
515	char szExecName[RTPATH_MAX];
516	char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
517	pfnLog(pLoggerRelease,
518	"Executable: %s\n"
519	"Process ID: %u\n"
520	"Package type: %s"
521	#ifdef VBOX_OSE
522	" (OSE)"
523	#endif
524	"\n",
525	pszExecName ? pszExecName : "unknown",
526	RTProcSelf(),
527	VBOX_PACKAGE_STRING);
528	break;
529	}
530
531	case RTLOGPHASE_PREROTATE:
532	pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
533	break;
534
535	case RTLOGPHASE_POSTROTATE:
536	pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
537	break;
538
539	case RTLOGPHASE_END:
540	pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
541	break;
542
543	default:
544	/* nothing */;
545	}
546	}
547
548	/**
549	* Creates the default release logger outputting to the specified file.
550	* Pass NULL for disabled logging.
551	*
552	* @return IPRT status code.
553	* @param pszLogFile Filename for log output. Optional.
554	*/
555	static int vboxTrayLogCreate(const char *pszLogFile)
556	{
557	/* Create release logger (stdout + file). */
558	static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
559	RTUINT fFlags = RTLOGFLAGS_PREFIX_THREAD \| RTLOGFLAGS_PREFIX_TIME_PROG;
560	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
561	fFlags \|= RTLOGFLAGS_USECRLF;
562	#endif
563	RTERRINFOSTATIC ErrInfo;
564	int rc = RTLogCreateEx(&g_pLoggerRelease, fFlags,
565	#ifdef DEBUG
566	"all.e.l.f",
567	"VBOXTRAY_LOG",
568	#else
569	"all",
570	"VBOXTRAY_RELEASE_LOG",
571	#endif
572	RT_ELEMENTS(s_apszGroups), s_apszGroups, RTLOGDEST_STDOUT,
573	vboxTrayLogHeaderFooter, g_cHistory, g_uHistoryFileSize, g_uHistoryFileTime,
574	RTErrInfoInitStatic(&ErrInfo), pszLogFile);
575	if (RT_SUCCESS(rc))
576	{
577	#ifdef DEBUG
578	RTLogSetDefaultInstance(g_pLoggerRelease);
579	#else
580	/* Register this logger as the release logger. */
581	RTLogRelSetDefaultInstance(g_pLoggerRelease);
582	#endif
583	/* Explicitly flush the log in case of VBOXTRAY_RELEASE_LOG=buffered. */
584	RTLogFlush(g_pLoggerRelease);
585	}
586	else
587	MessageBoxA(GetDesktopWindow(), ErrInfo.szMsg, "VBoxTray - Logging Error", MB_OK \| MB_ICONERROR);
588
589	return rc;
590	}
591
592	static void vboxTrayLogDestroy(void)
593	{
594	RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
595	}
596
597	static void vboxTrayDestroyToolWindow(void)
598	{
599	if (g_hwndToolWindow)
600	{
601	Log(("Destroying tool window ...\n"));
602
603	/* Destroy the tool window. */
604	DestroyWindow(g_hwndToolWindow);
605	g_hwndToolWindow = NULL;
606
607	UnregisterClass("VBoxTrayToolWndClass", g_hInstance);
608	}
609	}
610
611	static int vboxTrayCreateToolWindow(void)
612	{
613	DWORD dwErr = ERROR_SUCCESS;
614
615	/* Create a custom window class. */
616	WNDCLASSEX wc = { 0 };
617	wc.cbSize = sizeof(WNDCLASSEX);
618	wc.style = CS_NOCLOSE;
619	wc.lpfnWndProc = (WNDPROC)vboxToolWndProc;
620	wc.hInstance = g_hInstance;
621	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
622	wc.lpszClassName = "VBoxTrayToolWndClass";
623
624	if (!RegisterClassEx(&wc))
625	{
626	dwErr = GetLastError();
627	Log(("Registering invisible tool window failed, error = %08X\n", dwErr));
628	}
629	else
630	{
631	/*
632	* Create our (invisible) tool window.
633	* Note: The window name ("VBoxTrayToolWnd") and class ("VBoxTrayToolWndClass") is
634	* needed for posting globally registered messages to VBoxTray and must not be
635	* changed! Otherwise things get broken!
636	*
637	*/
638	g_hwndToolWindow = CreateWindowEx(WS_EX_TOOLWINDOW \| WS_EX_TRANSPARENT \| WS_EX_TOPMOST,
639	"VBoxTrayToolWndClass", "VBoxTrayToolWnd",
640	WS_POPUPWINDOW,
641	-200, -200, 100, 100, NULL, NULL, g_hInstance, NULL);
642	if (!g_hwndToolWindow)
643	{
644	dwErr = GetLastError();
645	Log(("Creating invisible tool window failed, error = %08X\n", dwErr));
646	}
647	else
648	{
649	/* Reload the cursor(s). */
650	hlpReloadCursor();
651
652	Log(("Invisible tool window handle = %p\n", g_hwndToolWindow));
653	}
654	}
655
656	if (dwErr != ERROR_SUCCESS)
657	vboxTrayDestroyToolWindow();
658	return RTErrConvertFromWin32(dwErr);
659	}
660
661	static int vboxTraySetupSeamless(void)
662	{
663	OSVERSIONINFO info;
664	g_dwMajorVersion = 5; /* Default to Windows XP. */
665	info.dwOSVersionInfoSize = sizeof(info);
666	if (GetVersionEx(&info))
667	{
668	Log(("Windows version %ld.%ld\n", info.dwMajorVersion, info.dwMinorVersion));
669	g_dwMajorVersion = info.dwMajorVersion;
670	}
671
672	/* We need to setup a security descriptor to allow other processes modify access to the seamless notification event semaphore. */
673	SECURITY_ATTRIBUTES SecAttr;
674	DWORD dwErr = ERROR_SUCCESS;
675	char secDesc[SECURITY_DESCRIPTOR_MIN_LENGTH];
676	BOOL fRC;
677
678	SecAttr.nLength = sizeof(SecAttr);
679	SecAttr.bInheritHandle = FALSE;
680	SecAttr.lpSecurityDescriptor = &secDesc;
681	InitializeSecurityDescriptor(SecAttr.lpSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
682	fRC = SetSecurityDescriptorDacl(SecAttr.lpSecurityDescriptor, TRUE, 0, FALSE);
683	if (!fRC)
684	{
685	dwErr = GetLastError();
686	Log(("SetSecurityDescriptorDacl failed with last error = %08X\n", dwErr));
687	}
688	else
689	{
690	/* For Vista and up we need to change the integrity of the security descriptor, too. */
691	if (g_dwMajorVersion >= 6)
692	{
693	BOOL (WINAPI * pfnConvertStringSecurityDescriptorToSecurityDescriptorA)(LPCSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR *SecurityDescriptor, PULONG SecurityDescriptorSize);
694	(void *)&pfnConvertStringSecurityDescriptorToSecurityDescriptorA =
695	RTLdrGetSystemSymbol("advapi32.dll", "ConvertStringSecurityDescriptorToSecurityDescriptorA");
696	Log(("pfnConvertStringSecurityDescriptorToSecurityDescriptorA = %x\n", pfnConvertStringSecurityDescriptorToSecurityDescriptorA));
697	if (pfnConvertStringSecurityDescriptorToSecurityDescriptorA)
698	{
699	PSECURITY_DESCRIPTOR pSD;
700	PACL pSacl = NULL;
701	BOOL fSaclPresent = FALSE;
702	BOOL fSaclDefaulted = FALSE;
703
704	fRC = pfnConvertStringSecurityDescriptorToSecurityDescriptorA("S:(ML;;NW;;;LW)", /* this means "low integrity" */
705	SDDL_REVISION_1, &pSD, NULL);
706	if (!fRC)
707	{
708	dwErr = GetLastError();
709	Log(("ConvertStringSecurityDescriptorToSecurityDescriptorA failed with last error = %08X\n", dwErr));
710	}
711	else
712	{
713	fRC = GetSecurityDescriptorSacl(pSD, &fSaclPresent, &pSacl, &fSaclDefaulted);
714	if (!fRC)
715	{
716	dwErr = GetLastError();
717	Log(("GetSecurityDescriptorSacl failed with last error = %08X\n", dwErr));
718	}
719	else
720	{
721	fRC = SetSecurityDescriptorSacl(SecAttr.lpSecurityDescriptor, TRUE, pSacl, FALSE);
722	if (!fRC)
723	{
724	dwErr = GetLastError();
725	Log(("SetSecurityDescriptorSacl failed with last error = %08X\n", dwErr));
726	}
727	}
728	}
729	}
730	}
731
732	if ( dwErr == ERROR_SUCCESS
733	&& g_dwMajorVersion >= 5) /* Only for W2K and up ... */
734	{
735	g_hSeamlessWtNotifyEvent = CreateEvent(&SecAttr, FALSE, FALSE, VBOXHOOK_GLOBAL_WT_EVENT_NAME);
736	if (g_hSeamlessWtNotifyEvent == NULL)
737	{
738	dwErr = GetLastError();
739	Log(("CreateEvent for Seamless failed, last error = %08X\n", dwErr));
740	}
741
742	g_hSeamlessKmNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
743	if (g_hSeamlessKmNotifyEvent == NULL)
744	{
745	dwErr = GetLastError();
746	Log(("CreateEvent for Seamless failed, last error = %08X\n", dwErr));
747	}
748	}
749	}
750	return RTErrConvertFromWin32(dwErr);
751	}
752
753	static void vboxTrayShutdownSeamless(void)
754	{
755	if (g_hSeamlessWtNotifyEvent)
756	{
757	CloseHandle(g_hSeamlessWtNotifyEvent);
758	g_hSeamlessWtNotifyEvent = NULL;
759	}
760
761	if (g_hSeamlessKmNotifyEvent)
762	{
763	CloseHandle(g_hSeamlessKmNotifyEvent);
764	g_hSeamlessKmNotifyEvent = NULL;
765	}
766	}
767
768	static void VBoxTrayCheckDt()
769	{
770	BOOL fOldAllowedState = VBoxConsoleIsAllowed();
771	if (vboxDtHandleEvent())
772	{
773	if (!VBoxConsoleIsAllowed() != !fOldAllowedState)
774	VBoxConsoleEnable(!fOldAllowedState);
775	}
776	}
777
778	static int vboxTrayServiceMain(void)
779	{
780	int rc = VINF_SUCCESS;
781	LogFunc(("Entering vboxTrayServiceMain\n"));
782
783	g_hStopSem = CreateEvent(NULL, TRUE, FALSE, NULL);
784	if (g_hStopSem == NULL)
785	{
786	rc = RTErrConvertFromWin32(GetLastError());
787	LogFunc(("CreateEvent for stopping VBoxTray failed, rc=%Rrc\n", rc));
788	}
789	else
790	{
791	/*
792	* Start services listed in the vboxServiceTable.
793	*/
794	VBOXSERVICEENV svcEnv;
795	svcEnv.hInstance = g_hInstance;
796
797	/* Initializes disp-if to default (XPDM) mode. */
798	VBoxDispIfInit(&svcEnv.dispIf); /* Cannot fail atm. */
799	#ifdef VBOX_WITH_WDDM
800	/*
801	* For now the display mode will be adjusted to WDDM mode if needed
802	* on display service initialization when it detects the display driver type.
803	*/
804	#endif
805
806	/* Finally start all the built-in services! */
807	rc = vboxTrayServicesStart(&svcEnv);
808	if (RT_FAILURE(rc))
809	{
810	/* Terminate service if something went wrong. */
811	vboxTrayServicesStop(&svcEnv);
812	}
813	else
814	{
815	rc = vboxTrayCreateTrayIcon();
816	if ( RT_SUCCESS(rc)
817	&& g_dwMajorVersion >= 5) /* Only for W2K and up ... */
818	{
819	/* We're ready to create the tooltip balloon.
820	Check in 10 seconds (@todo make seconds configurable) ... */
821	SetTimer(g_hwndToolWindow,
822	TIMERID_VBOXTRAY_CHECK_HOSTVERSION,
823	10 * 1000, /* 10 seconds */
824	NULL /* No timerproc */);
825	}
826
827	if (RT_SUCCESS(rc))
828	{
829	#ifdef VBOX_WITH_SHARED_FOLDERS
830	/* Do the Shared Folders auto-mounting stuff. */
831	rc = VBoxSharedFoldersAutoMount();
832	#endif
833	if (RT_SUCCESS(rc))
834	{
835	/* Report the host that we're up and running! */
836	hlpReportStatus(VBoxGuestFacilityStatus_Active);
837	}
838	}
839
840	if (RT_SUCCESS(rc))
841	{
842	/* Boost thread priority to make sure we wake up early for seamless window notifications
843	* (not sure if it actually makes any difference though). */
844	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
845
846	/*
847	* Main execution loop
848	* Wait for the stop semaphore to be posted or a window event to arrive
849	*/
850
851	HANDLE hWaitEvent[4] = {0};
852	DWORD dwEventCount = 0;
853
854	hWaitEvent[dwEventCount++] = g_hStopSem;
855
856	/* Check if seamless mode is not active and add seamless event to the list */
857	if (0 != g_hSeamlessWtNotifyEvent)
858	{
859	hWaitEvent[dwEventCount++] = g_hSeamlessWtNotifyEvent;
860	}
861
862	if (0 != g_hSeamlessKmNotifyEvent)
863	{
864	hWaitEvent[dwEventCount++] = g_hSeamlessKmNotifyEvent;
865	}
866
867	if (0 != vboxDtGetNotifyEvent())
868	{
869	hWaitEvent[dwEventCount++] = vboxDtGetNotifyEvent();
870	}
871
872	LogFlowFunc(("Number of events to wait in main loop: %ld\n", dwEventCount));
873	while (true)
874	{
875	DWORD waitResult = MsgWaitForMultipleObjectsEx(dwEventCount, hWaitEvent, 500, QS_ALLINPUT, 0);
876	waitResult = waitResult - WAIT_OBJECT_0;
877
878	/* Only enable for message debugging, lots of traffic! */
879	//Log(("Wait result = %ld\n", waitResult));
880
881	if (waitResult == 0)
882	{
883	LogFunc(("Event 'Exit' triggered\n"));
884	/* exit */
885	break;
886	}
887	else
888	{
889	BOOL fHandled = FALSE;
890	if (waitResult < RT_ELEMENTS(hWaitEvent))
891	{
892	if (hWaitEvent[waitResult])
893	{
894	if (hWaitEvent[waitResult] == g_hSeamlessWtNotifyEvent)
895	{
896	LogFunc(("Event 'Seamless' triggered\n"));
897
898	/* seamless window notification */
899	VBoxSeamlessCheckWindows(false);
900	fHandled = TRUE;
901	}
902	else if (hWaitEvent[waitResult] == g_hSeamlessKmNotifyEvent)
903	{
904	LogFunc(("Event 'Km Seamless' triggered\n"));
905
906	/* seamless window notification */
907	VBoxSeamlessCheckWindows(true);
908	fHandled = TRUE;
909	}
910	else if (hWaitEvent[waitResult] == vboxDtGetNotifyEvent())
911	{
912	LogFunc(("Event 'Dt' triggered\n"));
913	VBoxTrayCheckDt();
914	fHandled = TRUE;
915	}
916	}
917	}
918
919	if (!fHandled)
920	{
921	/* timeout or a window message, handle it */
922	MSG msg;
923	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
924	{
925	#ifdef DEBUG_andy
926	LogFlowFunc(("PeekMessage %u\n", msg.message));
927	#endif
928	if (msg.message == WM_QUIT)
929	{
930	LogFunc(("Terminating ...\n"));
931	SetEvent(g_hStopSem);
932	}
933	TranslateMessage(&msg);
934	DispatchMessage(&msg);
935	}
936	}
937	}
938	}
939	LogFunc(("Returned from main loop, exiting ...\n"));
940	}
941	LogFunc(("Waiting for services to stop ...\n"));
942	vboxTrayServicesStop(&svcEnv);
943	} /* Services started */
944	CloseHandle(g_hStopSem);
945	} /* Stop event created */
946
947	vboxTrayRemoveTrayIcon();
948
949	LogFunc(("Leaving with rc=%Rrc\n", rc));
950	return rc;
951	}
952
953	/**
954	* Main function
955	*/
956	int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
957	{
958	RT_NOREF(hPrevInstance, lpCmdLine, nCmdShow);
959	int rc = RTR3InitExeNoArguments(0);
960	if (RT_FAILURE(rc))
961	return RTEXITCODE_INIT;
962
963	/* Note: Do not use a global namespace ("Global\\") for mutex name here,
964	* will blow up NT4 compatibility! */
965	HANDLE hMutexAppRunning = CreateMutex(NULL, FALSE, "VBoxTray");
966	if ( hMutexAppRunning != NULL
967	&& GetLastError() == ERROR_ALREADY_EXISTS)
968	{
969	/* VBoxTray already running? Bail out. */
970	CloseHandle (hMutexAppRunning);
971	hMutexAppRunning = NULL;
972	return 0;
973	}
974
975	LogRel(("%s r%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr()));
976
977	rc = vboxTrayLogCreate(NULL /* pszLogFile */);
978	if (RT_SUCCESS(rc))
979	{
980	rc = VbglR3Init();
981	if (RT_SUCCESS(rc))
982	{
983	/* Save instance handle. */
984	g_hInstance = hInstance;
985
986	hlpReportStatus(VBoxGuestFacilityStatus_Init);
987	rc = vboxTrayCreateToolWindow();
988	if (RT_SUCCESS(rc))
989	{
990	VBoxCapsInit();
991
992	rc = vboxStInit(g_hwndToolWindow);
993	if (!RT_SUCCESS(rc))
994	{
995	LogFlowFunc(("vboxStInit failed, rc=%Rrc\n", rc));
996	/* ignore the St Init failure. this can happen for < XP win that do not support WTS API
997	* in that case the session is treated as active connected to the physical console
998	* (i.e. fallback to the old behavior that was before introduction of VBoxSt) */
999	Assert(vboxStIsActiveConsole());
1000	}
1001
1002	rc = vboxDtInit();
1003	if (!RT_SUCCESS(rc))
1004	{
1005	LogFlowFunc(("vboxDtInit failed, rc=%Rrc\n", rc));
1006	/* ignore the Dt Init failure. this can happen for < XP win that do not support WTS API
1007	* in that case the session is treated as active connected to the physical console
1008	* (i.e. fallback to the old behavior that was before introduction of VBoxSt) */
1009	Assert(vboxDtIsInputDesktop());
1010	}
1011
1012	rc = VBoxAcquireGuestCaps(VMMDEV_GUEST_SUPPORTS_SEAMLESS \| VMMDEV_GUEST_SUPPORTS_GRAPHICS, 0, true);
1013	if (!RT_SUCCESS(rc))
1014	LogFlowFunc(("VBoxAcquireGuestCaps failed with rc=%Rrc, ignoring ...\n", rc));
1015
1016	rc = vboxTraySetupSeamless(); /** @todo r=andy Do we really want to be this critical for the whole application? */
1017	if (RT_SUCCESS(rc))
1018	{
1019	rc = vboxTrayServiceMain();
1020	if (RT_SUCCESS(rc))
1021	hlpReportStatus(VBoxGuestFacilityStatus_Terminating);
1022	vboxTrayShutdownSeamless();
1023	}
1024
1025	/* it should be safe to call vboxDtTerm even if vboxStInit above failed */
1026	vboxDtTerm();
1027
1028	/* it should be safe to call vboxStTerm even if vboxStInit above failed */
1029	vboxStTerm();
1030
1031	VBoxCapsTerm();
1032
1033	vboxTrayDestroyToolWindow();
1034	}
1035	if (RT_SUCCESS(rc))
1036	hlpReportStatus(VBoxGuestFacilityStatus_Terminated);
1037	else
1038	{
1039	LogRel(("Error while starting, rc=%Rrc\n", rc));
1040	hlpReportStatus(VBoxGuestFacilityStatus_Failed);
1041	}
1042
1043	LogRel(("Ended\n"));
1044	VbglR3Term();
1045	}
1046	else
1047	LogRel(("VbglR3Init failed: %Rrc\n", rc));
1048	}
1049
1050	/* Release instance mutex. */
1051	if (hMutexAppRunning != NULL)
1052	{
1053	CloseHandle(hMutexAppRunning);
1054	hMutexAppRunning = NULL;
1055	}
1056
1057	vboxTrayLogDestroy();
1058
1059	return RT_SUCCESS(rc) ? 0 : 1;
1060	}
1061
1062	/**
1063	* Window procedure for our main tool window.
1064	*/
1065	static LRESULT CALLBACK vboxToolWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1066	{
1067	LogFlowFunc(("hWnd=%p, uMsg=%u\n", hWnd, uMsg));
1068
1069	switch (uMsg)
1070	{
1071	case WM_CREATE:
1072	{
1073	LogFunc(("Tool window created\n"));
1074
1075	int rc = vboxTrayRegisterGlobalMessages(&g_vboxGlobalMessageTable[0]);
1076	if (RT_FAILURE(rc))
1077	LogFunc(("Error registering global window messages, rc=%Rrc\n", rc));
1078	return 0;
1079	}
1080
1081	case WM_CLOSE:
1082	return 0;
1083
1084	case WM_DESTROY:
1085	{
1086	LogFunc(("Tool window destroyed\n"));
1087	KillTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_CHECK_HOSTVERSION);
1088	return 0;
1089	}
1090
1091	case WM_TIMER:
1092	{
1093	if (VBoxCapsCheckTimer(wParam))
1094	return 0;
1095	if (vboxDtCheckTimer(wParam))
1096	return 0;
1097	if (vboxStCheckTimer(wParam))
1098	return 0;
1099
1100	switch (wParam)
1101	{
1102	case TIMERID_VBOXTRAY_CHECK_HOSTVERSION:
1103	if (RT_SUCCESS(VBoxCheckHostVersion()))
1104	{
1105	/* After successful run we don't need to check again. */
1106	KillTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_CHECK_HOSTVERSION);
1107	}
1108	return 0;
1109
1110	default:
1111	break;
1112	}
1113
1114	break; /* Make sure other timers get processed the usual way! */
1115	}
1116
1117	case WM_VBOXTRAY_TRAY_ICON:
1118	{
1119	switch (lParam)
1120	{
1121	case WM_LBUTTONDBLCLK:
1122	break;
1123
1124	case WM_RBUTTONDOWN:
1125	break;
1126	}
1127	return 0;
1128	}
1129
1130	case WM_VBOX_SEAMLESS_ENABLE:
1131	{
1132	VBoxCapsEntryFuncStateSet(VBOXCAPS_ENTRY_IDX_SEAMLESS, VBOXCAPS_ENTRY_FUNCSTATE_STARTED);
1133	if (VBoxCapsEntryIsEnabled(VBOXCAPS_ENTRY_IDX_SEAMLESS))
1134	VBoxSeamlessCheckWindows(true);
1135	return 0;
1136	}
1137
1138	case WM_VBOX_SEAMLESS_DISABLE:
1139	{
1140	VBoxCapsEntryFuncStateSet(VBOXCAPS_ENTRY_IDX_SEAMLESS, VBOXCAPS_ENTRY_FUNCSTATE_SUPPORTED);
1141	return 0;
1142	}
1143
1144	case WM_DISPLAYCHANGE:
1145	ASMAtomicUoWriteU32(&g_fGuestDisplaysChanged, 1);
1146	// No break or return is intentional here.
1147	case WM_VBOX_SEAMLESS_UPDATE:
1148	{
1149	if (VBoxCapsEntryIsEnabled(VBOXCAPS_ENTRY_IDX_SEAMLESS))
1150	VBoxSeamlessCheckWindows(true);
1151	return 0;
1152	}
1153
1154	case WM_VBOX_GRAPHICS_SUPPORTED:
1155	{
1156	VBoxGrapicsSetSupported(TRUE);
1157	return 0;
1158	}
1159
1160	case WM_VBOX_GRAPHICS_UNSUPPORTED:
1161	{
1162	VBoxGrapicsSetSupported(FALSE);
1163	return 0;
1164	}
1165
1166	case WM_WTSSESSION_CHANGE:
1167	{
1168	BOOL fOldAllowedState = VBoxConsoleIsAllowed();
1169	if (vboxStHandleEvent(wParam))
1170	{
1171	if (!VBoxConsoleIsAllowed() != !fOldAllowedState)
1172	VBoxConsoleEnable(!fOldAllowedState);
1173	}
1174	return 0;
1175	}
1176
1177	default:
1178	{
1179	/* Handle all globally registered window messages. */
1180	if (vboxTrayHandleGlobalMessages(&g_vboxGlobalMessageTable[0], uMsg,
1181	wParam, lParam))
1182	{
1183	return 0; /* We handled the message. @todo Add return value!*/
1184	}
1185	break; /* We did not handle the message, dispatch to DefWndProc. */
1186	}
1187	}
1188
1189	/* Only if message was not handled by our switch above, dispatch to DefWindowProc. */
1190	return DefWindowProc(hWnd, uMsg, wParam, lParam);
1191	}
1192
1193	/* St (session [state] tracking) functionality API impl */
1194
1195	typedef struct VBOXST
1196	{
1197	HWND hWTSAPIWnd;
1198	RTLDRMOD hLdrModWTSAPI32;
1199	BOOL fIsConsole;
1200	WTS_CONNECTSTATE_CLASS enmConnectState;
1201	UINT_PTR idDelayedInitTimer;
1202	BOOL (WINAPI * pfnWTSRegisterSessionNotification)(HWND hWnd, DWORD dwFlags);
1203	BOOL (WINAPI * pfnWTSUnRegisterSessionNotification)(HWND hWnd);
1204	BOOL (WINAPI * pfnWTSQuerySessionInformationA)(HANDLE hServer, DWORD SessionId, WTS_INFO_CLASS WTSInfoClass, LPTSTR ppBuffer, DWORD pBytesReturned);
1205	} VBOXST;
1206
1207	static VBOXST gVBoxSt;
1208
1209	static int vboxStCheckState()
1210	{
1211	int rc = VINF_SUCCESS;
1212	WTS_CONNECTSTATE_CLASS *penmConnectState = NULL;
1213	USHORT *pProtocolType = NULL;
1214	DWORD cbBuf = 0;
1215	if (gVBoxSt.pfnWTSQuerySessionInformationA(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTSConnectState,
1216	(LPTSTR *)&penmConnectState, &cbBuf))
1217	{
1218	if (gVBoxSt.pfnWTSQuerySessionInformationA(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTSClientProtocolType,
1219	(LPTSTR *)&pProtocolType, &cbBuf))
1220	{
1221	gVBoxSt.fIsConsole = (*pProtocolType == 0);
1222	gVBoxSt.enmConnectState = *penmConnectState;
1223	return VINF_SUCCESS;
1224	}
1225
1226	DWORD dwErr = GetLastError();
1227	LogFlowFunc(("WTSQuerySessionInformationA WTSClientProtocolType failed, error = %08X\n", dwErr));
1228	rc = RTErrConvertFromWin32(dwErr);
1229	}
1230	else
1231	{
1232	DWORD dwErr = GetLastError();
1233	LogFlowFunc(("WTSQuerySessionInformationA WTSConnectState failed, error = %08X\n", dwErr));
1234	rc = RTErrConvertFromWin32(dwErr);
1235	}
1236
1237	/* failure branch, set to "console-active" state */
1238	gVBoxSt.fIsConsole = TRUE;
1239	gVBoxSt.enmConnectState = WTSActive;
1240
1241	return rc;
1242	}
1243
1244	static int vboxStInit(HWND hWnd)
1245	{
1246	RT_ZERO(gVBoxSt);
1247	int rc = RTLdrLoadSystem("WTSAPI32.DLL", false /fNoUnload/, &gVBoxSt.hLdrModWTSAPI32);
1248	if (RT_SUCCESS(rc))
1249	{
1250	rc = RTLdrGetSymbol(gVBoxSt.hLdrModWTSAPI32, "WTSRegisterSessionNotification",
1251	(void **)&gVBoxSt.pfnWTSRegisterSessionNotification);
1252	if (RT_SUCCESS(rc))
1253	{
1254	rc = RTLdrGetSymbol(gVBoxSt.hLdrModWTSAPI32, "WTSUnRegisterSessionNotification",
1255	(void **)&gVBoxSt.pfnWTSUnRegisterSessionNotification);
1256	if (RT_SUCCESS(rc))
1257	{
1258	rc = RTLdrGetSymbol(gVBoxSt.hLdrModWTSAPI32, "WTSQuerySessionInformationA",
1259	(void **)&gVBoxSt.pfnWTSQuerySessionInformationA);
1260	if (RT_FAILURE(rc))
1261	LogFlowFunc(("WTSQuerySessionInformationA not found\n"));
1262	}
1263	else
1264	LogFlowFunc(("WTSUnRegisterSessionNotification not found\n"));
1265	}
1266	else
1267	LogFlowFunc(("WTSRegisterSessionNotification not found\n"));
1268	if (RT_SUCCESS(rc))
1269	{
1270	gVBoxSt.hWTSAPIWnd = hWnd;
1271	if (gVBoxSt.pfnWTSRegisterSessionNotification(gVBoxSt.hWTSAPIWnd, NOTIFY_FOR_THIS_SESSION))
1272	vboxStCheckState();
1273	else
1274	{
1275	DWORD dwErr = GetLastError();
1276	LogFlowFunc(("WTSRegisterSessionNotification failed, error = %08X\n", dwErr));
1277	if (dwErr == RPC_S_INVALID_BINDING)
1278	{
1279	gVBoxSt.idDelayedInitTimer = SetTimer(gVBoxSt.hWTSAPIWnd, TIMERID_VBOXTRAY_ST_DELAYED_INIT_TIMER,
1280	2000, (TIMERPROC)NULL);
1281	gVBoxSt.fIsConsole = TRUE;
1282	gVBoxSt.enmConnectState = WTSActive;
1283	rc = VINF_SUCCESS;
1284	}
1285	else
1286	rc = RTErrConvertFromWin32(dwErr);
1287	}
1288
1289	if (RT_SUCCESS(rc))
1290	return VINF_SUCCESS;
1291	}
1292
1293	RTLdrClose(gVBoxSt.hLdrModWTSAPI32);
1294	}
1295	else
1296	LogFlowFunc(("WTSAPI32 load failed, rc = %Rrc\n", rc));
1297
1298	RT_ZERO(gVBoxSt);
1299	gVBoxSt.fIsConsole = TRUE;
1300	gVBoxSt.enmConnectState = WTSActive;
1301	return rc;
1302	}
1303
1304	static void vboxStTerm(void)
1305	{
1306	if (!gVBoxSt.hWTSAPIWnd)
1307	{
1308	LogFlowFunc(("vboxStTerm called for non-initialized St\n"));
1309	return;
1310	}
1311
1312	if (gVBoxSt.idDelayedInitTimer)
1313	{
1314	/* notification is not registered, just kill timer */
1315	KillTimer(gVBoxSt.hWTSAPIWnd, gVBoxSt.idDelayedInitTimer);
1316	gVBoxSt.idDelayedInitTimer = 0;
1317	}
1318	else
1319	{
1320	if (!gVBoxSt.pfnWTSUnRegisterSessionNotification(gVBoxSt.hWTSAPIWnd))
1321	{
1322	LogFlowFunc(("WTSAPI32 load failed, error = %08X\n", GetLastError()));
1323	}
1324	}
1325
1326	RTLdrClose(gVBoxSt.hLdrModWTSAPI32);
1327	RT_ZERO(gVBoxSt);
1328	}
1329
1330	#define VBOXST_DBG_MAKECASE(_val) case _val: return #_val;
1331
1332	static const char* vboxStDbgGetString(DWORD val)
1333	{
1334	switch (val)
1335	{
1336	VBOXST_DBG_MAKECASE(WTS_CONSOLE_CONNECT);
1337	VBOXST_DBG_MAKECASE(WTS_CONSOLE_DISCONNECT);
1338	VBOXST_DBG_MAKECASE(WTS_REMOTE_CONNECT);
1339	VBOXST_DBG_MAKECASE(WTS_REMOTE_DISCONNECT);
1340	VBOXST_DBG_MAKECASE(WTS_SESSION_LOGON);
1341	VBOXST_DBG_MAKECASE(WTS_SESSION_LOGOFF);
1342	VBOXST_DBG_MAKECASE(WTS_SESSION_LOCK);
1343	VBOXST_DBG_MAKECASE(WTS_SESSION_UNLOCK);
1344	VBOXST_DBG_MAKECASE(WTS_SESSION_REMOTE_CONTROL);
1345	default:
1346	LogFlowFunc(("invalid WTS state %d\n", val));
1347	return "Unknown";
1348	}
1349	}
1350
1351	static BOOL vboxStCheckTimer(WPARAM wEvent)
1352	{
1353	if (wEvent != gVBoxSt.idDelayedInitTimer)
1354	return FALSE;
1355
1356	if (gVBoxSt.pfnWTSRegisterSessionNotification(gVBoxSt.hWTSAPIWnd, NOTIFY_FOR_THIS_SESSION))
1357	{
1358	KillTimer(gVBoxSt.hWTSAPIWnd, gVBoxSt.idDelayedInitTimer);
1359	gVBoxSt.idDelayedInitTimer = 0;
1360	vboxStCheckState();
1361	}
1362	else
1363	{
1364	LogFlowFunc(("timer WTSRegisterSessionNotification failed, error = %08X\n", GetLastError()));
1365	Assert(gVBoxSt.fIsConsole == TRUE);
1366	Assert(gVBoxSt.enmConnectState == WTSActive);
1367	}
1368
1369	return TRUE;
1370	}
1371
1372
1373	static BOOL vboxStHandleEvent(WPARAM wEvent)
1374	{
1375	RT_NOREF(wEvent);
1376	LogFlowFunc(("WTS Event: %s\n", vboxStDbgGetString(wEvent)));
1377	BOOL fOldIsActiveConsole = vboxStIsActiveConsole();
1378
1379	vboxStCheckState();
1380
1381	return !vboxStIsActiveConsole() != !fOldIsActiveConsole;
1382	}
1383
1384	static BOOL vboxStIsActiveConsole(void)
1385	{
1386	return (gVBoxSt.enmConnectState == WTSActive && gVBoxSt.fIsConsole);
1387	}
1388
1389	/*
1390	* Dt (desktop [state] tracking) functionality API impl
1391	*
1392	* !!!NOTE: this API is NOT thread-safe!!!
1393	* */
1394
1395	typedef struct VBOXDT
1396	{
1397	HANDLE hNotifyEvent;
1398	BOOL fIsInputDesktop;
1399	UINT_PTR idTimer;
1400	RTLDRMOD hLdrModHook;
1401	BOOL (* pfnVBoxHookInstallActiveDesktopTracker)(HMODULE hDll);
1402	BOOL (* pfnVBoxHookRemoveActiveDesktopTracker)();
1403	HDESK (WINAPI * pfnGetThreadDesktop)(DWORD dwThreadId);
1404	HDESK (WINAPI * pfnOpenInputDesktop)(DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
1405	BOOL (WINAPI * pfnCloseDesktop)(HDESK hDesktop);
1406	} VBOXDT;
1407
1408	static VBOXDT gVBoxDt;
1409
1410	static BOOL vboxDtCalculateIsInputDesktop()
1411	{
1412	BOOL fIsInputDt = FALSE;
1413	HDESK hInput = gVBoxDt.pfnOpenInputDesktop(0, FALSE, DESKTOP_CREATEWINDOW);
1414	if (hInput)
1415	{
1416	// DWORD dwThreadId = GetCurrentThreadId();
1417	// HDESK hThreadDt = gVBoxDt.pfnGetThreadDesktop(dwThreadId);
1418	// if (hThreadDt)
1419	// {
1420	fIsInputDt = TRUE;
1421	// }
1422	// else
1423	// {
1424	// DWORD dwErr = GetLastError();
1425	// LogFlowFunc(("pfnGetThreadDesktop for Seamless failed, last error = %08X\n", dwErr));
1426	// }
1427
1428	gVBoxDt.pfnCloseDesktop(hInput);
1429	}
1430	else
1431	{
1432	// DWORD dwErr = GetLastError();
1433	// LogFlowFunc(("pfnOpenInputDesktop for Seamless failed, last error = %08X\n", dwErr));
1434	}
1435	return fIsInputDt;
1436	}
1437
1438	static BOOL vboxDtCheckTimer(WPARAM wParam)
1439	{
1440	if (wParam != gVBoxDt.idTimer)
1441	return FALSE;
1442
1443	VBoxTrayCheckDt();
1444
1445	return TRUE;
1446	}
1447
1448	static int vboxDtInit()
1449	{
1450	int rc = VINF_SUCCESS;
1451	OSVERSIONINFO info;
1452	g_dwMajorVersion = 5; /* Default to Windows XP. */
1453	info.dwOSVersionInfoSize = sizeof(info);
1454	if (GetVersionEx(&info))
1455	{
1456	LogRel(("Windows version %ld.%ld\n", info.dwMajorVersion, info.dwMinorVersion));
1457	g_dwMajorVersion = info.dwMajorVersion;
1458	}
1459
1460	RT_ZERO(gVBoxDt);
1461
1462	gVBoxDt.hNotifyEvent = CreateEvent(NULL, FALSE, FALSE, VBOXHOOK_GLOBAL_DT_EVENT_NAME);
1463	if (gVBoxDt.hNotifyEvent != NULL)
1464	{
1465	/* Load the hook dll and resolve the necessary entry points. */
1466	rc = RTLdrLoadAppPriv(VBOXHOOK_DLL_NAME, &gVBoxDt.hLdrModHook);
1467	if (RT_SUCCESS(rc))
1468	{
1469	rc = RTLdrGetSymbol(gVBoxDt.hLdrModHook, "VBoxHookInstallActiveDesktopTracker",
1470	(void **)&gVBoxDt.pfnVBoxHookInstallActiveDesktopTracker);
1471	if (RT_SUCCESS(rc))
1472	{
1473	rc = RTLdrGetSymbol(gVBoxDt.hLdrModHook, "VBoxHookRemoveActiveDesktopTracker",
1474	(void **)&gVBoxDt.pfnVBoxHookRemoveActiveDesktopTracker);
1475	if (RT_FAILURE(rc))
1476	LogFlowFunc(("VBoxHookRemoveActiveDesktopTracker not found\n"));
1477	}
1478	else
1479	LogFlowFunc(("VBoxHookInstallActiveDesktopTracker not found\n"));
1480	if (RT_SUCCESS(rc))
1481	{
1482	/* Try get the system APIs we need. */
1483	(void *)&gVBoxDt.pfnGetThreadDesktop = RTLdrGetSystemSymbol("user32.dll", "GetThreadDesktop");
1484	if (!gVBoxDt.pfnGetThreadDesktop)
1485	{
1486	LogFlowFunc(("GetThreadDesktop not found\n"));
1487	rc = VERR_NOT_SUPPORTED;
1488	}
1489
1490	(void *)&gVBoxDt.pfnOpenInputDesktop = RTLdrGetSystemSymbol("user32.dll", "OpenInputDesktop");
1491	if (!gVBoxDt.pfnOpenInputDesktop)
1492	{
1493	LogFlowFunc(("OpenInputDesktop not found\n"));
1494	rc = VERR_NOT_SUPPORTED;
1495	}
1496
1497	(void *)&gVBoxDt.pfnCloseDesktop = RTLdrGetSystemSymbol("user32.dll", "CloseDesktop");
1498	if (!gVBoxDt.pfnCloseDesktop)
1499	{
1500	LogFlowFunc(("CloseDesktop not found\n"));
1501	rc = VERR_NOT_SUPPORTED;
1502	}
1503
1504	if (RT_SUCCESS(rc))
1505	{
1506	BOOL fRc = FALSE;
1507	/* For Vista and up we need to change the integrity of the security descriptor, too. */
1508	if (g_dwMajorVersion >= 6)
1509	{
1510	HMODULE hModHook = (HMODULE)RTLdrGetNativeHandle(gVBoxDt.hLdrModHook);
1511	Assert((uintptr_t)hModHook != ~(uintptr_t)0);
1512	fRc = gVBoxDt.pfnVBoxHookInstallActiveDesktopTracker(hModHook);
1513	if (!fRc)
1514	LogFlowFunc(("pfnVBoxHookInstallActiveDesktopTracker failed, last error = %08X\n", GetLastError()));
1515	}
1516
1517	if (!fRc)
1518	{
1519	gVBoxDt.idTimer = SetTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_DT_TIMER, 500, (TIMERPROC)NULL);
1520	if (!gVBoxDt.idTimer)
1521	{
1522	DWORD dwErr = GetLastError();
1523	LogFlowFunc(("SetTimer error %08X\n", dwErr));
1524	rc = RTErrConvertFromWin32(dwErr);
1525	}
1526	}
1527
1528	if (RT_SUCCESS(rc))
1529	{
1530	gVBoxDt.fIsInputDesktop = vboxDtCalculateIsInputDesktop();
1531	return VINF_SUCCESS;
1532	}
1533	}
1534	}
1535
1536	RTLdrClose(gVBoxDt.hLdrModHook);
1537	}
1538	else
1539	{
1540	DWORD dwErr = GetLastError();
1541	LogFlowFunc(("CreateEvent for Seamless failed, last error = %08X\n", dwErr));
1542	rc = RTErrConvertFromWin32(dwErr);
1543	}
1544
1545	CloseHandle(gVBoxDt.hNotifyEvent);
1546	}
1547	else
1548	{
1549	DWORD dwErr = GetLastError();
1550	LogFlowFunc(("CreateEvent for Seamless failed, last error = %08X\n", dwErr));
1551	rc = RTErrConvertFromWin32(dwErr);
1552	}
1553
1554
1555	RT_ZERO(gVBoxDt);
1556	gVBoxDt.fIsInputDesktop = TRUE;
1557
1558	return rc;
1559	}
1560
1561	static void vboxDtTerm()
1562	{
1563	if (!gVBoxDt.hLdrModHook)
1564	return;
1565
1566	gVBoxDt.pfnVBoxHookRemoveActiveDesktopTracker();
1567
1568	RTLdrClose(gVBoxDt.hLdrModHook);
1569	CloseHandle(gVBoxDt.hNotifyEvent);
1570
1571	RT_ZERO(gVBoxDt);
1572	}
1573	/* @returns true on "IsInputDesktop" state change */
1574	static BOOL vboxDtHandleEvent()
1575	{
1576	BOOL fIsInputDesktop = gVBoxDt.fIsInputDesktop;
1577	gVBoxDt.fIsInputDesktop = vboxDtCalculateIsInputDesktop();
1578	return !fIsInputDesktop != !gVBoxDt.fIsInputDesktop;
1579	}
1580
1581	static HANDLE vboxDtGetNotifyEvent()
1582	{
1583	return gVBoxDt.hNotifyEvent;
1584	}
1585
1586	/* @returns true iff the application (VBoxTray) desktop is input */
1587	static BOOL vboxDtIsInputDesktop()
1588	{
1589	return gVBoxDt.fIsInputDesktop;
1590	}
1591
1592	/* we need to perform Acquire/Release using the file handled we use for rewuesting events from VBoxGuest
1593	* otherwise Acquisition mechanism will treat us as different client and will not propagate necessary requests
1594	* */
1595	static int VBoxAcquireGuestCaps(uint32_t fOr, uint32_t fNot, bool fCfg)
1596	{
1597	Log(("VBoxAcquireGuestCaps or(0x%x), not(0x%x), cfx(%d)\n", fOr, fNot, fCfg));
1598	int rc = VbglR3AcquireGuestCaps(fOr, fNot, fCfg);
1599	if (RT_FAILURE(rc))
1600	LogFlowFunc(("VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE failed: %Rrc\n", rc));
1601	return rc;
1602	}
1603
1604	typedef enum VBOXCAPS_ENTRY_ACSTATE
1605	{
1606	/* the given cap is released */
1607	VBOXCAPS_ENTRY_ACSTATE_RELEASED = 0,
1608	/* the given cap acquisition is in progress */
1609	VBOXCAPS_ENTRY_ACSTATE_ACQUIRING,
1610	/* the given cap is acquired */
1611	VBOXCAPS_ENTRY_ACSTATE_ACQUIRED
1612	} VBOXCAPS_ENTRY_ACSTATE;
1613
1614
1615	struct VBOXCAPS_ENTRY;
1616	struct VBOXCAPS;
1617
1618	typedef DECLCALLBACKPTR(void, PFNVBOXCAPS_ENTRY_ON_ENABLE)(struct VBOXCAPS pConsole, struct VBOXCAPS_ENTRY pCap, BOOL fEnabled);
1619
1620	typedef struct VBOXCAPS_ENTRY
1621	{
1622	uint32_t fCap;
1623	uint32_t iCap;
1624	VBOXCAPS_ENTRY_FUNCSTATE enmFuncState;
1625	VBOXCAPS_ENTRY_ACSTATE enmAcState;
1626	PFNVBOXCAPS_ENTRY_ON_ENABLE pfnOnEnable;
1627	} VBOXCAPS_ENTRY;
1628
1629
1630	typedef struct VBOXCAPS
1631	{
1632	UINT_PTR idTimer;
1633	VBOXCAPS_ENTRY aCaps[VBOXCAPS_ENTRY_IDX_COUNT];
1634	} VBOXCAPS;
1635
1636	static VBOXCAPS gVBoxCaps;
1637
1638	static DECLCALLBACK(void) vboxCapsOnEnableSeamless(struct VBOXCAPS pConsole, struct VBOXCAPS_ENTRY pCap, BOOL fEnabled)
1639	{
1640	RT_NOREF(pConsole, pCap);
1641	if (fEnabled)
1642	{
1643	Log(("vboxCapsOnEnableSeamless: ENABLED\n"));
1644	Assert(pCap->enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED);
1645	Assert(pCap->enmFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED);
1646	VBoxSeamlessEnable();
1647	}
1648	else
1649	{
1650	Log(("vboxCapsOnEnableSeamless: DISABLED\n"));
1651	Assert(pCap->enmAcState != VBOXCAPS_ENTRY_ACSTATE_ACQUIRED \|\| pCap->enmFuncState != VBOXCAPS_ENTRY_FUNCSTATE_STARTED);
1652	VBoxSeamlessDisable();
1653	}
1654	}
1655
1656	static void vboxCapsEntryAcStateSet(VBOXCAPS_ENTRY *pCap, VBOXCAPS_ENTRY_ACSTATE enmAcState)
1657	{
1658	VBOXCAPS *pConsole = &gVBoxCaps;
1659
1660	Log(("vboxCapsEntryAcStateSet: new state enmAcState(%d); pCap: fCap(%d), iCap(%d), enmFuncState(%d), enmAcState(%d)\n",
1661	enmAcState, pCap->fCap, pCap->iCap, pCap->enmFuncState, pCap->enmAcState));
1662
1663	if (pCap->enmAcState == enmAcState)
1664	return;
1665
1666	VBOXCAPS_ENTRY_ACSTATE enmOldAcState = pCap->enmAcState;
1667	pCap->enmAcState = enmAcState;
1668
1669	if (enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED)
1670	{
1671	if (pCap->enmFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED)
1672	{
1673	if (pCap->pfnOnEnable)
1674	pCap->pfnOnEnable(pConsole, pCap, TRUE);
1675	}
1676	}
1677	else if (enmOldAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED && pCap->enmFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED)
1678	{
1679	if (pCap->pfnOnEnable)
1680	pCap->pfnOnEnable(pConsole, pCap, FALSE);
1681	}
1682	}
1683
1684	static void vboxCapsEntryFuncStateSet(VBOXCAPS_ENTRY *pCap, VBOXCAPS_ENTRY_FUNCSTATE enmFuncState)
1685	{
1686	VBOXCAPS *pConsole = &gVBoxCaps;
1687
1688	Log(("vboxCapsEntryFuncStateSet: new state enmAcState(%d); pCap: fCap(%d), iCap(%d), enmFuncState(%d), enmAcState(%d)\n",
1689	enmFuncState, pCap->fCap, pCap->iCap, pCap->enmFuncState, pCap->enmAcState));
1690
1691	if (pCap->enmFuncState == enmFuncState)
1692	return;
1693
1694	VBOXCAPS_ENTRY_FUNCSTATE enmOldFuncState = pCap->enmFuncState;
1695
1696	pCap->enmFuncState = enmFuncState;
1697
1698	if (enmFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED)
1699	{
1700	Assert(enmOldFuncState == VBOXCAPS_ENTRY_FUNCSTATE_SUPPORTED);
1701	if (pCap->enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED)
1702	{
1703	if (pCap->pfnOnEnable)
1704	pCap->pfnOnEnable(pConsole, pCap, TRUE);
1705	}
1706	}
1707	else if (pCap->enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED && enmOldFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED)
1708	{
1709	if (pCap->pfnOnEnable)
1710	pCap->pfnOnEnable(pConsole, pCap, FALSE);
1711	}
1712	}
1713
1714	static void VBoxCapsEntryFuncStateSet(uint32_t iCup, VBOXCAPS_ENTRY_FUNCSTATE enmFuncState)
1715	{
1716	VBOXCAPS *pConsole = &gVBoxCaps;
1717	VBOXCAPS_ENTRY *pCap = &pConsole->aCaps[iCup];
1718	vboxCapsEntryFuncStateSet(pCap, enmFuncState);
1719	}
1720
1721	static int VBoxCapsInit()
1722	{
1723	VBOXCAPS *pConsole = &gVBoxCaps;
1724	memset(pConsole, 0, sizeof (*pConsole));
1725	pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].fCap = VMMDEV_GUEST_SUPPORTS_SEAMLESS;
1726	pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].iCap = VBOXCAPS_ENTRY_IDX_SEAMLESS;
1727	pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].pfnOnEnable = vboxCapsOnEnableSeamless;
1728	pConsole->aCaps[VBOXCAPS_ENTRY_IDX_GRAPHICS].fCap = VMMDEV_GUEST_SUPPORTS_GRAPHICS;
1729	pConsole->aCaps[VBOXCAPS_ENTRY_IDX_GRAPHICS].iCap = VBOXCAPS_ENTRY_IDX_GRAPHICS;
1730	return VINF_SUCCESS;
1731	}
1732
1733	static int VBoxCapsReleaseAll()
1734	{
1735	VBOXCAPS *pConsole = &gVBoxCaps;
1736	Log(("VBoxCapsReleaseAll\n"));
1737	int rc = VBoxAcquireGuestCaps(0, VMMDEV_GUEST_SUPPORTS_SEAMLESS \| VMMDEV_GUEST_SUPPORTS_GRAPHICS, false);
1738	if (!RT_SUCCESS(rc))
1739	{
1740	LogFlowFunc(("vboxCapsEntryReleaseAll VBoxAcquireGuestCaps failed rc %d\n", rc));
1741	return rc;
1742	}
1743
1744	if (pConsole->idTimer)
1745	{
1746	Log(("killing console timer\n"));
1747	KillTimer(g_hwndToolWindow, pConsole->idTimer);
1748	pConsole->idTimer = 0;
1749	}
1750
1751	for (int i = 0; i < RT_ELEMENTS(pConsole->aCaps); ++i)
1752	{
1753	vboxCapsEntryAcStateSet(&pConsole->aCaps[i], VBOXCAPS_ENTRY_ACSTATE_RELEASED);
1754	}
1755
1756	return rc;
1757	}
1758
1759	static void VBoxCapsTerm()
1760	{
1761	VBOXCAPS *pConsole = &gVBoxCaps;
1762	VBoxCapsReleaseAll();
1763	memset(pConsole, 0, sizeof (*pConsole));
1764	}
1765
1766	static BOOL VBoxCapsEntryIsAcquired(uint32_t iCap)
1767	{
1768	VBOXCAPS *pConsole = &gVBoxCaps;
1769	return pConsole->aCaps[iCap].enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED;
1770	}
1771
1772	static BOOL VBoxCapsEntryIsEnabled(uint32_t iCap)
1773	{
1774	VBOXCAPS *pConsole = &gVBoxCaps;
1775	return pConsole->aCaps[iCap].enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED
1776	&& pConsole->aCaps[iCap].enmFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED;
1777	}
1778
1779	static BOOL VBoxCapsCheckTimer(WPARAM wParam)
1780	{
1781	VBOXCAPS *pConsole = &gVBoxCaps;
1782	if (wParam != pConsole->idTimer)
1783	return FALSE;
1784
1785	uint32_t u32AcquiredCaps = 0;
1786	BOOL fNeedNewTimer = FALSE;
1787
1788	for (int i = 0; i < RT_ELEMENTS(pConsole->aCaps); ++i)
1789	{
1790	VBOXCAPS_ENTRY *pCap = &pConsole->aCaps[i];
1791	if (pCap->enmAcState != VBOXCAPS_ENTRY_ACSTATE_ACQUIRING)
1792	continue;
1793
1794	int rc = VBoxAcquireGuestCaps(pCap->fCap, 0, false);
1795	if (RT_SUCCESS(rc))
1796	{
1797	vboxCapsEntryAcStateSet(&pConsole->aCaps[i], VBOXCAPS_ENTRY_ACSTATE_ACQUIRED);
1798	u32AcquiredCaps \|= pCap->fCap;
1799	}
1800	else
1801	{
1802	Assert(rc == VERR_RESOURCE_BUSY);
1803	fNeedNewTimer = TRUE;
1804	}
1805	}
1806
1807	if (!fNeedNewTimer)
1808	{
1809	KillTimer(g_hwndToolWindow, pConsole->idTimer);
1810	/* cleanup timer data */
1811	pConsole->idTimer = 0;
1812	}
1813
1814	return TRUE;
1815	}
1816
1817	static int VBoxCapsEntryRelease(uint32_t iCap)
1818	{
1819	VBOXCAPS *pConsole = &gVBoxCaps;
1820	VBOXCAPS_ENTRY *pCap = &pConsole->aCaps[iCap];
1821	if (pCap->enmAcState == VBOXCAPS_ENTRY_ACSTATE_RELEASED)
1822	{
1823	LogFlowFunc(("invalid cap[%d] state[%d] on release\n", iCap, pCap->enmAcState));
1824	return VERR_INVALID_STATE;
1825	}
1826
1827	if (pCap->enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED)
1828	{
1829	int rc = VBoxAcquireGuestCaps(0, pCap->fCap, false);
1830	AssertRC(rc);
1831	}
1832
1833	vboxCapsEntryAcStateSet(pCap, VBOXCAPS_ENTRY_ACSTATE_RELEASED);
1834
1835	return VINF_SUCCESS;
1836	}
1837
1838	static int VBoxCapsEntryAcquire(uint32_t iCap)
1839	{
1840	VBOXCAPS *pConsole = &gVBoxCaps;
1841	Assert(VBoxConsoleIsAllowed());
1842	VBOXCAPS_ENTRY *pCap = &pConsole->aCaps[iCap];
1843	Log(("VBoxCapsEntryAcquire %d\n", iCap));
1844	if (pCap->enmAcState != VBOXCAPS_ENTRY_ACSTATE_RELEASED)
1845	{
1846	LogFlowFunc(("invalid cap[%d] state[%d] on acquire\n", iCap, pCap->enmAcState));
1847	return VERR_INVALID_STATE;
1848	}
1849
1850	vboxCapsEntryAcStateSet(pCap, VBOXCAPS_ENTRY_ACSTATE_ACQUIRING);
1851	int rc = VBoxAcquireGuestCaps(pCap->fCap, 0, false);
1852	if (RT_SUCCESS(rc))
1853	{
1854	vboxCapsEntryAcStateSet(pCap, VBOXCAPS_ENTRY_ACSTATE_ACQUIRED);
1855	return VINF_SUCCESS;
1856	}
1857
1858	if (rc != VERR_RESOURCE_BUSY)
1859	{
1860	LogFlowFunc(("vboxCapsEntryReleaseAll VBoxAcquireGuestCaps failed rc %d\n", rc));
1861	return rc;
1862	}
1863
1864	LogFlowFunc(("iCap %d is busy!\n", iCap));
1865
1866	/* the cap was busy, most likely it is still used by other VBoxTray instance running in another session,
1867	* queue the retry timer */
1868	if (!pConsole->idTimer)
1869	{
1870	pConsole->idTimer = SetTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_CAPS_TIMER, 100, (TIMERPROC)NULL);
1871	if (!pConsole->idTimer)
1872	{
1873	DWORD dwErr = GetLastError();
1874	LogFlowFunc(("SetTimer error %08X\n", dwErr));
1875	return RTErrConvertFromWin32(dwErr);
1876	}
1877	}
1878
1879	return rc;
1880	}
1881
1882	static int VBoxCapsAcquireAllSupported()
1883	{
1884	VBOXCAPS *pConsole = &gVBoxCaps;
1885	Log(("VBoxCapsAcquireAllSupported\n"));
1886	for (int i = 0; i < RT_ELEMENTS(pConsole->aCaps); ++i)
1887	{
1888	if (pConsole->aCaps[i].enmFuncState >= VBOXCAPS_ENTRY_FUNCSTATE_SUPPORTED)
1889	{
1890	Log(("VBoxCapsAcquireAllSupported acquiring cap %d, state %d\n", i, pConsole->aCaps[i].enmFuncState));
1891	VBoxCapsEntryAcquire(i);
1892	}
1893	else
1894	{
1895	LogFlowFunc(("VBoxCapsAcquireAllSupported: WARN: cap %d not supported, state %d\n", i, pConsole->aCaps[i].enmFuncState));
1896	}
1897	}
1898	return VINF_SUCCESS;
1899	}
1900
1901	static BOOL VBoxConsoleIsAllowed()
1902	{
1903	return vboxDtIsInputDesktop() && vboxStIsActiveConsole();
1904	}
1905
1906	static void VBoxConsoleEnable(BOOL fEnable)
1907	{
1908	if (fEnable)
1909	VBoxCapsAcquireAllSupported();
1910	else
1911	VBoxCapsReleaseAll();
1912	}
1913
1914	static void VBoxConsoleCapSetSupported(uint32_t iCap, BOOL fSupported)
1915	{
1916	if (fSupported)
1917	{
1918	VBoxCapsEntryFuncStateSet(iCap, VBOXCAPS_ENTRY_FUNCSTATE_SUPPORTED);
1919
1920	if (VBoxConsoleIsAllowed())
1921	VBoxCapsEntryAcquire(iCap);
1922	}
1923	else
1924	{
1925	VBoxCapsEntryFuncStateSet(iCap, VBOXCAPS_ENTRY_FUNCSTATE_UNSUPPORTED);
1926
1927	VBoxCapsEntryRelease(iCap);
1928	}
1929	}
1930
1931	void VBoxSeamlessSetSupported(BOOL fSupported)
1932	{
1933	VBoxConsoleCapSetSupported(VBOXCAPS_ENTRY_IDX_SEAMLESS, fSupported);
1934	}
1935
1936	static void VBoxGrapicsSetSupported(BOOL fSupported)
1937	{
1938	VBoxConsoleCapSetSupported(VBOXCAPS_ENTRY_IDX_GRAPHICS, fSupported);
1939	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxTray.cpp@ 75407

Download in other formats: