Changeset 45703 in vbox for trunk/src/VBox/Additions

Timestamp:

Apr 24, 2013 2:31:56 PM (12 years ago)

Author:

vboxsync

Message:

VBoxTray/Seamless: disable seamless on desktop change (UAC, Lock)

Location:

trunk/src/VBox/Additions/WINNT

Files:

• VBoxHook/VBoxHook.cpp (modified) (4 diffs)
• VBoxHook/VBoxHook.def (modified) (1 diff)
• VBoxHook/testcase/tstHook.cpp (modified) (1 diff)
• VBoxTray/VBoxSeamless.cpp (modified) (8 diffs)
• VBoxTray/VBoxSeamless.h (modified) (1 diff)
• VBoxTray/VBoxTray.cpp (modified) (13 diffs)
• include/VBoxHook.h (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/VBoxHook/VBoxHook.cpp

@@ -19 +19 @@
 
 #pragma data_seg("SHARED")
-static HWINEVENTHOOK    hEventHook[2]    = {0};
+static HWINEVENTHOOK    hWinEventHook[2]    = {0};
+static HWINEVENTHOOK    hDesktopEventHook   = NULL;
 #pragma data_seg()
 #pragma comment(linker, "/section:SHARED,RWS")
 
-static HANDLE   hNotifyEvent = 0;
+static HANDLE   hWinNotifyEvent = 0;
+static HANDLE   hDesktopNotifyEvent = 0;
 
 #ifdef DEBUG
@@ -33 +35 @@
 
 
-void CALLBACK VBoxHandleWinEvent(HWINEVENTHOOK hook, DWORD event, HWND hwnd,
+static void CALLBACK VBoxHandleWinEvent(HWINEVENTHOOK hook, DWORD event, HWND hwnd,
                                  LONG idObject, LONG idChild,
                                  DWORD dwEventThread, DWORD dwmsEventTime)
@@ -76 +78 @@
         }
 #endif
-        if (!hNotifyEvent)
+        if (!hWinNotifyEvent)
         {
-            hNotifyEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, VBOXHOOK_GLOBAL_EVENT_NAME);
-            dprintf(("OpenEvent returned %x (last err=%x)\n", hNotifyEvent, GetLastError()));
+            hWinNotifyEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, VBOXHOOK_GLOBAL_WT_EVENT_NAME);
+            dprintf(("OpenEvent returned %x (last err=%x)\n", hWinNotifyEvent, GetLastError()));
         }
-        BOOL ret = SetEvent(hNotifyEvent);
-        dprintf(("SetEvent %x returned %d (last error %x)\n", hNotifyEvent, ret, GetLastError()));
+        BOOL ret = SetEvent(hWinNotifyEvent);
+        dprintf(("SetEvent %x returned %d (last error %x)\n", hWinNotifyEvent, ret, GetLastError()));
         break;
     }
 }
 
+static void CALLBACK VBoxHandleDesktopEvent(HWINEVENTHOOK hook, DWORD event, HWND hwnd,
+                                 LONG idObject, LONG idChild,
+                                 DWORD dwEventThread, DWORD dwmsEventTime)
+{
+    if (!hDesktopNotifyEvent)
+    {
+        hDesktopNotifyEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, VBOXHOOK_GLOBAL_DT_EVENT_NAME);
+        dprintf(("OpenEvent returned %x (last err=%x)\n", hDesktopNotifyEvent, GetLastError()));
+    }
+    BOOL ret = SetEvent(hDesktopNotifyEvent);
+    dprintf(("SetEvent %x returned %d (last error %x)\n", hDesktopNotifyEvent, ret, GetLastError()));
+}
+
+BOOL VBoxHookInstallActiveDesktopTracker(HMODULE hDll)
+{
+    if (hDesktopEventHook)
+        return TRUE;
+
+    CoInitialize(NULL);
+    hDesktopEventHook = SetWinEventHook(EVENT_SYSTEM_DESKTOPSWITCH, EVENT_SYSTEM_DESKTOPSWITCH,
+                                    hDll,
+                                    VBoxHandleDesktopEvent,
+                                    0, 0,
+                                    0);
+
+    return !!hDesktopEventHook;
+
+}
+
+BOOL VBoxHookRemoveActiveDesktopTracker()
+{
+    if (hDesktopEventHook)
+    {
+        UnhookWinEvent(hDesktopEventHook);
+        CoUninitialize();
+    }
+    hDesktopEventHook = 0;
+    return TRUE;
+}
 
 /* Install the global message hook */
-BOOL VBoxInstallHook(HMODULE hDll)
-{
-    if (hEventHook[0] || hEventHook[1])
+BOOL VBoxHookInstallWindowTracker(HMODULE hDll)
+{
+    if (hWinEventHook[0] || hWinEventHook[1])
         return TRUE;
 
     CoInitialize(NULL);
-    hEventHook[0] = SetWinEventHook(EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_LOCATIONCHANGE,
+    hWinEventHook[0] = SetWinEventHook(EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_LOCATIONCHANGE,
                                     hDll,
                                     VBoxHandleWinEvent,
@@ -101 +142 @@
                                     WINEVENT_INCONTEXT | WINEVENT_SKIPOWNPROCESS);
 
-    hEventHook[1] = SetWinEventHook(EVENT_OBJECT_CREATE, EVENT_OBJECT_HIDE,
+    hWinEventHook[1] = SetWinEventHook(EVENT_OBJECT_CREATE, EVENT_OBJECT_HIDE,
                                     hDll,
                                     VBoxHandleWinEvent,
                                     0, 0,
                                     WINEVENT_INCONTEXT | WINEVENT_SKIPOWNPROCESS);
-    return !!hEventHook[0];
+    return !!hWinEventHook[0];
 }
 
 /* Remove the global message hook */
-BOOL VBoxRemoveHook()
-{
-    if (hEventHook[0] && hEventHook[1])
-    {
-        UnhookWinEvent(hEventHook[0]);
-        UnhookWinEvent(hEventHook[1]);
+BOOL VBoxHookRemoveWindowTracker()
+{
+    if (hWinEventHook[0] && hWinEventHook[1])
+    {
+        UnhookWinEvent(hWinEventHook[0]);
+        UnhookWinEvent(hWinEventHook[1]);
         CoUninitialize();
     }
-    hEventHook[0]  = hEventHook[1] = 0;
-    return true;
+    hWinEventHook[0]  = hWinEventHook[1] = 0;
+    return TRUE;
 }
 

trunk/src/VBox/Additions/WINNT/VBoxHook/VBoxHook.def

@@ -19 +19 @@
 
 EXPORTS
-   VBoxInstallHook
-   VBoxRemoveHook
+    VBoxHookInstallActiveDesktopTracker
+    VBoxHookRemoveActiveDesktopTracker
+    VBoxHookInstallWindowTracker
+    VBoxHookRemoveWindowTracker

trunk/src/VBox/Additions/WINNT/VBoxHook/testcase/tstHook.cpp

@@ -22 +22 @@
     printf("Enabling global hook\n");
 
-    HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, VBOXHOOK_GLOBAL_EVENT_NAME);
+    HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, VBOXHOOK_GLOBAL_WT_EVENT_NAME);
 
-    VBoxInstallHook(GetModuleHandle("VBoxHook.dll"));
+    VBoxHookInstallWindowTracker(GetModuleHandle("VBoxHook.dll"));
     getchar();
 
     printf("Disabling global hook\n");
-    VBoxRemoveHook();
+    VBoxHookRemoveWindowTracker();
     return 0;
 }

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxSeamless.cpp

@@ -33 +33 @@
     HMODULE    hModule;
 
-    BOOL    (* pfnVBoxInstallHook)(HMODULE hDll);
-    BOOL    (* pfnVBoxRemoveHook)();
+    BOOL    (* pfnVBoxHookInstallWindowTracker)(HMODULE hDll);
+    BOOL    (* pfnVBoxHookRemoveWindowTracker)();
 
     PVBOXDISPIFESCAPE lpEscapeData;
@@ -75 +75 @@
         if (gCtx.hModule)
         {
-            *(uintptr_t *)&gCtx.pfnVBoxInstallHook = (uintptr_t)GetProcAddress(gCtx.hModule, "VBoxInstallHook");
-            *(uintptr_t *)&gCtx.pfnVBoxRemoveHook  = (uintptr_t)GetProcAddress(gCtx.hModule, "VBoxRemoveHook");
-
-            /* Inform the host that we support the seamless window mode. */
-            rc = VbglR3SetGuestCaps(VMMDEV_GUEST_SUPPORTS_SEAMLESS, 0);
+            *(uintptr_t *)&gCtx.pfnVBoxHookInstallWindowTracker = (uintptr_t)GetProcAddress(gCtx.hModule, "VBoxHookInstallWindowTracker");
+            *(uintptr_t *)&gCtx.pfnVBoxHookRemoveWindowTracker  = (uintptr_t)GetProcAddress(gCtx.hModule, "VBoxHookRemoveWindowTracker");
+
+            /* rc should contain success status */
+            AssertRC(rc);
+
+            if (VBoxSeamlessIsAllowed())
+            {
+                rc = VBoxSeamlessOnAllowChange(TRUE);
+                if (!RT_SUCCESS(rc))
+                    Log(("VBoxTray: VBoxSeamlessInit: Failed to set seamless capability\n"));
+            }
+
             if (RT_SUCCESS(rc))
             {
@@ -85 +93 @@
                 *ppInstance = &gCtx;
             }
-            else
-                Log(("VBoxTray: VBoxSeamlessInit: Failed to set seamless capability\n"));
         }
         else
@@ -108 +114 @@
         Log(("VBoxTray: VBoxSeamlessDestroy: Failed to unset seamless capability, rc=%Rrc\n", rc));
 
-    if (gCtx.pfnVBoxRemoveHook)
-        gCtx.pfnVBoxRemoveHook();
+    if (gCtx.pfnVBoxHookRemoveWindowTracker)
+        gCtx.pfnVBoxHookRemoveWindowTracker();
     if (gCtx.hModule)
         FreeLibrary(gCtx.hModule);
@@ -118 +124 @@
 void VBoxSeamlessInstallHook()
 {
-    if (gCtx.pfnVBoxInstallHook)
+    if (gCtx.pfnVBoxHookInstallWindowTracker)
     {
         /* Check current visible region state */
         VBoxSeamlessCheckWindows();
 
-        gCtx.pfnVBoxInstallHook(gCtx.hModule);
+        gCtx.pfnVBoxHookInstallWindowTracker(gCtx.hModule);
     }
 }
@@ -129 +135 @@
 void VBoxSeamlessRemoveHook()
 {
-    if (gCtx.pfnVBoxRemoveHook)
-        gCtx.pfnVBoxRemoveHook();
+    if (gCtx.pfnVBoxHookRemoveWindowTracker)
+        gCtx.pfnVBoxHookRemoveWindowTracker();
 
     if (gCtx.lpEscapeData)
@@ -376 +382 @@
                                     Log(("VBoxTray: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %d\n", GetLastError()));
                             }
-                            PostMessage(ghwndToolWindow, WM_VBOX_REMOVE_SEAMLESS_HOOK, 0, 0);
+                            PostMessage(ghwndToolWindow, WM_VBOX_SEAMLESS_DISABLE, 0, 0);
                             break;
 
@@ -390 +396 @@
                             if (!ret)
                                 Log(("VBoxTray: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %d\n", GetLastError()));
-                            PostMessage(ghwndToolWindow, WM_VBOX_INSTALL_SEAMLESS_HOOK, 0, 0);
+                            PostMessage(ghwndToolWindow, WM_VBOX_SEAMLESS_ENABLE, 0, 0);
                             break;
 

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxSeamless.h

@@ -28 +28 @@
 void VBoxSeamlessCheckWindows();
 
+/* NOTE: both can only be called from Main thread only! */
+BOOL VBoxSeamlessIsAllowed();
+int VBoxSeamlessOnAllowChange(BOOL fEnable);
+
 #endif /* __VBOXSERVICESEAMLESS__H */

trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxTray.cpp

@@ -42 +42 @@
 #include <iprt/buildconfig.h>
 
+/* Default desktop state tracking */
+#include <Wtsapi32.h>
+
+#ifdef DEBUG_misha
+#define WARN(_m) do { \
+            Assert(0); \
+            Log(_m); \
+        } while (0)
+#else
+#define WARN(_m) do { \
+            Log(_m); \
+        } while (0)
+#endif
+
+/*
+ * St (session [state] tracking) functionality API
+ *
+ * !!!NOTE: this API is NOT thread-safe!!!
+ * it is supposed to be called & used from within the window message handler thread
+ * of the window passed to vboxStInit */
+static int vboxStInit(HWND hWnd);
+static void vboxStTerm();
+/* @returns true on "IsActiveConsole" state change */
+static BOOL vboxStHandleEvent(WPARAM EventID, LPARAM SessionID);
+static BOOL vboxStIsActiveConsole();
+
+/*
+ * Dt (desktop [state] tracking) functionality API
+ *
+ * !!!NOTE: this API is NOT thread-safe!!!
+ * */
+static int vboxDtInit();
+static void vboxDtTerm();
+/* @returns true on "IsInputDesktop" state change */
+static BOOL vboxDtHandleEvent();
+/* @returns true iff the application (VBoxTray) desktop is input */
+static BOOL vboxDtIsInputDesktop();
+static HANDLE vboxDtGetNotifyEvent();
+
 
 /*******************************************************************************
@@ -59 +98 @@
 HANDLE                ghVBoxDriver;
 HANDLE                ghStopSem;
-HANDLE                ghSeamlessNotifyEvent = 0;
+HANDLE                ghSeamlessWtNotifyEvent = 0;
 SERVICE_STATUS        gVBoxServiceStatus;
 SERVICE_STATUS_HANDLE gVBoxServiceStatusHandle;
@@ -66 +105 @@
 NOTIFYICONDATA        gNotifyIconData;
 DWORD                 gMajorVersion;
+BOOL                  gfIsSeamlessOn = FALSE;
 
 
@@ -525 +565 @@
             && gMajorVersion >= 5) /* Only for W2K and up ... */
         {
-            ghSeamlessNotifyEvent = CreateEvent(&SecAttr, FALSE, FALSE, VBOXHOOK_GLOBAL_EVENT_NAME);
-            if (ghSeamlessNotifyEvent == NULL)
+            ghSeamlessWtNotifyEvent = CreateEvent(&SecAttr, FALSE, FALSE, VBOXHOOK_GLOBAL_WT_EVENT_NAME);
+            if (ghSeamlessWtNotifyEvent == NULL)
             {
                 dwErr = GetLastError();
@@ -538 +578 @@
 static void vboxTrayShutdownSeamless(void)
 {
-    if (ghSeamlessNotifyEvent)
-    {
-        CloseHandle(ghSeamlessNotifyEvent);
-        ghSeamlessNotifyEvent = NULL;
+    if (ghSeamlessWtNotifyEvent)
+    {
+        CloseHandle(ghSeamlessWtNotifyEvent);
+        ghSeamlessWtNotifyEvent = NULL;
     }
 }
@@ -617 +657 @@
                  */
 
-                DWORD dwEventCount = 2;
-                HANDLE hWaitEvent[2] = { ghStopSem, ghSeamlessNotifyEvent };
-
-                if (0 == ghSeamlessNotifyEvent) /* If seamless mode is not active / supported, reduce event array count. */
+                HANDLE hWaitEvent[3] = { ghStopSem, ghSeamlessWtNotifyEvent, vboxDtGetNotifyEvent() };
+                DWORD dwEventCount = RT_ELEMENTS(hWaitEvent);
+
+                if (0 == ghSeamlessWtNotifyEvent) /* If seamless mode is not active / supported, reduce event array count. */
                     dwEventCount = 1;
 
@@ -639 +679 @@
                     }
                     else if (   waitResult == 1
-                             && ghSeamlessNotifyEvent != 0) /* Only jump in, if seamless is active! */
+                             && ghSeamlessWtNotifyEvent != 0) /* Only jump in, if seamless is active! */
                     {
                         Log(("VBoxTray: Event 'Seamless' triggered\n"));
@@ -645 +685 @@
                         /* seamless window notification */
                         VBoxSeamlessCheckWindows();
+                    }
+                    else if (   waitResult == 2
+                             && vboxDtGetNotifyEvent() != 0) /* Only jump in, if Dt is active! */
+                    {
+                        BOOL fOldSeamlessAllowedState = VBoxSeamlessIsAllowed();
+                        if (vboxDtHandleEvent())
+                        {
+                            if (!VBoxSeamlessIsAllowed() != !fOldSeamlessAllowedState)
+                            {
+                                rc = VBoxSeamlessOnAllowChange(!fOldSeamlessAllowedState);
+                                if (!RT_SUCCESS(rc))
+                                    Log(("VBoxTray: WndProc: Failed to set seamless capability\n"));
+                            }
+                        }
                     }
                     else
@@ -713 +767 @@
         if (RT_SUCCESS(rc))
         {
+            rc = vboxStInit(ghwndToolWindow);
+            if (!RT_SUCCESS(rc))
+            {
+                WARN(("VBoxTray: vboxStInit failed, rc %d"));
+                /* ignore the St Init failure. this can happen for < XP win that do not support WTS API
+                 * in that case the session is treated as active connected to the physical console
+                 * (i.e. fallback to the old behavior that was before introduction of VBoxSt) */
+                Assert(vboxStIsActiveConsole());
+            }
+
+            rc = vboxDtInit();
+            if (!RT_SUCCESS(rc))
+            {
+                WARN(("VBoxTray: vboxDtInit failed, rc %d"));
+                /* ignore the Dt Init failure. this can happen for < XP win that do not support WTS API
+                 * in that case the session is treated as active connected to the physical console
+                 * (i.e. fallback to the old behavior that was before introduction of VBoxSt) */
+                Assert(vboxDtIsInputDesktop());
+            }
+
             rc = vboxTraySetupSeamless();
             if (RT_SUCCESS(rc))
@@ -722 +796 @@
                 vboxTrayShutdownSeamless();
             }
+
+            /* it should be safe to call vboxDtTerm even if vboxStInit above failed */
+            vboxDtTerm();
+
+            /* it should be safe to call vboxStTerm even if vboxStInit above failed */
+            vboxStTerm();
+
             vboxTrayDestroyToolWindow();
         }
@@ -799 +880 @@
             return 0;
 
-        case WM_VBOX_INSTALL_SEAMLESS_HOOK:
-            VBoxSeamlessInstallHook();
+        case WM_VBOX_SEAMLESS_ENABLE:
+            gfIsSeamlessOn = TRUE;
+            if (VBoxSeamlessIsAllowed())
+                VBoxSeamlessInstallHook();
             return 0;
 
-        case WM_VBOX_REMOVE_SEAMLESS_HOOK:
-            VBoxSeamlessRemoveHook();
+        case WM_VBOX_SEAMLESS_DISABLE:
+            gfIsSeamlessOn = FALSE;
+            if (VBoxSeamlessIsAllowed())
+                VBoxSeamlessRemoveHook();
             return 0;
 
         case WM_VBOX_SEAMLESS_UPDATE:
-            VBoxSeamlessCheckWindows();
+            if (gfIsSeamlessOn && VBoxSeamlessIsAllowed())
+                VBoxSeamlessCheckWindows();
             return 0;
 
@@ -819 +905 @@
             return 0;
 
+        case WM_WTSSESSION_CHANGE:
+        {
+            BOOL fOldSeamlessAllowedState = VBoxSeamlessIsAllowed();
+            if (vboxStHandleEvent(wParam, lParam))
+            {
+                if (!VBoxSeamlessIsAllowed() != !fOldSeamlessAllowedState)
+                {
+                    int rc = VBoxSeamlessOnAllowChange(!fOldSeamlessAllowedState);
+                    if (!RT_SUCCESS(rc))
+                        Log(("VBoxTray: WndProc: Failed to set seamless capability\n"));
+                }
+            }
+            return 0;
+        }
         default:
 
@@ -835 +935 @@
 }
 
+/* St (session [state] tracking) functionality API impl */
+
+typedef struct VBOXST
+{
+    HWND hWTSAPIWnd;
+    HMODULE hWTSAPI32;
+    BOOL fIsConsole;
+    WTS_CONNECTSTATE_CLASS enmConnectState;
+    BOOL (WINAPI * pfnWTSRegisterSessionNotification)(HWND hWnd, DWORD dwFlags);
+    BOOL (WINAPI * pfnWTSUnRegisterSessionNotification)(HWND hWnd);
+    BOOL (WINAPI * pfnWTSQuerySessionInformationA)(HANDLE hServer, DWORD SessionId, WTS_INFO_CLASS WTSInfoClass, LPTSTR *ppBuffer, DWORD *pBytesReturned);
+} VBOXST;
+
+static VBOXST gVBoxSt;
+
+static int vboxStInit(HWND hWnd)
+{
+    int rc = VINF_SUCCESS;
+    memset(&gVBoxSt, 0, sizeof (gVBoxSt));
+    gVBoxSt.hWTSAPI32 = LoadLibrary("WTSAPI32.DLL");
+    if (gVBoxSt.hWTSAPI32)
+    {
+        *(uintptr_t *)&gVBoxSt.pfnWTSRegisterSessionNotification = (uintptr_t)GetProcAddress(gVBoxSt.hWTSAPI32, "WTSRegisterSessionNotification");
+        if (!gVBoxSt.pfnWTSRegisterSessionNotification)
+        {
+            WARN(("VBoxTray: WTSRegisterSessionNotification not found\n"));
+            rc = VERR_NOT_SUPPORTED;
+        }
+
+        *(uintptr_t *)&gVBoxSt.pfnWTSUnRegisterSessionNotification = (uintptr_t)GetProcAddress(gVBoxSt.hWTSAPI32, "WTSUnRegisterSessionNotification");
+        if (!gVBoxSt.pfnWTSUnRegisterSessionNotification)
+        {
+            WARN(("VBoxTray: WTSUnRegisterSessionNotification not found\n"));
+            rc = VERR_NOT_SUPPORTED;
+        }
+
+        *(uintptr_t *)&gVBoxSt.pfnWTSQuerySessionInformationA = (uintptr_t)GetProcAddress(gVBoxSt.hWTSAPI32, "WTSQuerySessionInformationA");
+        if (!gVBoxSt.pfnWTSQuerySessionInformationA)
+        {
+            WARN(("VBoxTray: WTSQuerySessionInformationA not found\n"));
+            rc = VERR_NOT_SUPPORTED;
+        }
+
+        if (rc == VINF_SUCCESS)
+        {
+            gVBoxSt.hWTSAPIWnd = hWnd;
+            if (gVBoxSt.pfnWTSRegisterSessionNotification(gVBoxSt.hWTSAPIWnd, NOTIFY_FOR_THIS_SESSION))
+            {
+                WTS_CONNECTSTATE_CLASS *penmConnectState = NULL;
+                USHORT *pProtocolType = NULL;
+                DWORD cbBuf = 0;
+                if (gVBoxSt.pfnWTSQuerySessionInformationA(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTSConnectState, (LPTSTR *)&penmConnectState, &cbBuf))
+                {
+                    if (gVBoxSt.pfnWTSQuerySessionInformationA(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTSClientProtocolType, (LPTSTR *)&pProtocolType, &cbBuf))
+                    {
+                        gVBoxSt.fIsConsole = (*pProtocolType == 0);
+                        gVBoxSt.enmConnectState = *penmConnectState;
+                    }
+                    else
+                    {
+                        DWORD dwErr = GetLastError();
+                        WARN(("VBoxTray: WTSQuerySessionInformationA WTSClientProtocolType failed, error = %08X\n", dwErr));
+                        rc = RTErrConvertFromWin32(dwErr);
+                    }
+                }
+                else
+                {
+                    DWORD dwErr = GetLastError();
+                    WARN(("VBoxTray: WTSQuerySessionInformationA WTSConnectState failed, error = %08X\n", dwErr));
+                    rc = RTErrConvertFromWin32(dwErr);
+                }
+                return VINF_SUCCESS;
+            }
+            else
+            {
+                DWORD dwErr = GetLastError();
+                WARN(("VBoxTray: WTSRegisterSessionNotification failed, error = %08X\n", dwErr));
+                rc = RTErrConvertFromWin32(dwErr);
+            }
+        }
+
+        FreeLibrary(gVBoxSt.hWTSAPI32);
+    }
+    else
+    {
+        DWORD dwErr = GetLastError();
+        WARN(("VBoxTray: WTSAPI32 load failed, error = %08X\n", dwErr));
+        rc = RTErrConvertFromWin32(dwErr);
+    }
+
+    memset(&gVBoxSt, 0, sizeof (gVBoxSt));
+    gVBoxSt.fIsConsole = TRUE;
+    gVBoxSt.enmConnectState = WTSActive;
+    return rc;
+}
+
+static void vboxStTerm()
+{
+    if (gVBoxSt.hWTSAPIWnd)
+    {
+        WARN(("VBoxTray: vboxStTerm called for non-initialized St\n"));
+        return;
+    }
+
+    if (!gVBoxSt.pfnWTSUnRegisterSessionNotification(gVBoxSt.hWTSAPIWnd))
+    {
+        DWORD dwErr = GetLastError();
+        WARN(("VBoxTray: WTSAPI32 load failed, error = %08X\n", dwErr));
+    }
+
+    FreeLibrary(gVBoxSt.hWTSAPI32);
+    memset(&gVBoxSt, 0, sizeof (gVBoxSt));
+}
+
+#define VBOXST_DBG_MAKECASE(_val) case _val: return #_val;
+
+static const char* vboxStDbgGetString(DWORD val)
+{
+    switch (val)
+    {
+        VBOXST_DBG_MAKECASE(WTS_CONSOLE_CONNECT);
+        VBOXST_DBG_MAKECASE(WTS_CONSOLE_DISCONNECT);
+        VBOXST_DBG_MAKECASE(WTS_REMOTE_CONNECT);
+        VBOXST_DBG_MAKECASE(WTS_REMOTE_DISCONNECT);
+        VBOXST_DBG_MAKECASE(WTS_SESSION_LOGON);
+        VBOXST_DBG_MAKECASE(WTS_SESSION_LOGOFF);
+        VBOXST_DBG_MAKECASE(WTS_SESSION_LOCK);
+        VBOXST_DBG_MAKECASE(WTS_SESSION_UNLOCK);
+        VBOXST_DBG_MAKECASE(WTS_SESSION_REMOTE_CONTROL);
+        default:
+            WARN(("VBoxTray: invalid WTS state %d", val));
+            return "Unknown";
+    }
+}
+
+static BOOL vboxStHandleEvent(WPARAM wEvent, LPARAM SessionID)
+{
+    WARN(("VBoxTray: WTS Event: %s\n", vboxStDbgGetString(wEvent)));
+    BOOL fOldIsActiveConsole = vboxStIsActiveConsole();
+    switch (wEvent)
+    {
+        case WTS_CONSOLE_CONNECT:
+            gVBoxSt.enmConnectState = WTSConnected;
+            gVBoxSt.fIsConsole = TRUE;
+            break;
+        case WTS_CONSOLE_DISCONNECT:
+            gVBoxSt.enmConnectState = WTSDisconnected;
+            break;
+        case WTS_REMOTE_CONNECT:
+            gVBoxSt.enmConnectState = WTSConnected;
+            gVBoxSt.fIsConsole = FALSE;
+            break;
+        case WTS_REMOTE_DISCONNECT:
+            gVBoxSt.enmConnectState = WTSDisconnected;
+            break;
+        case WTS_SESSION_LOGON:
+            Assert(gVBoxSt.enmConnectState == WTSConnected);
+            gVBoxSt.enmConnectState = WTSActive;
+            break;
+        case WTS_SESSION_LOGOFF:
+            Assert(gVBoxSt.enmConnectState == WTSActive);
+            gVBoxSt.enmConnectState = WTSConnected;
+            break;
+        case WTS_SESSION_LOCK:
+            Assert(gVBoxSt.enmConnectState == WTSActive);
+            gVBoxSt.enmConnectState = WTSConnected;
+            break;
+        case WTS_SESSION_UNLOCK:
+            Assert(gVBoxSt.enmConnectState == WTSConnected);
+            gVBoxSt.enmConnectState = WTSActive;
+            break;
+        case WTS_SESSION_REMOTE_CONTROL:
+            /* todo */
+            WARN(("WTS_SESSION_REMOTE_CONTROL handling not implemented!"));
+            break;
+        default:
+            WARN(("unexpected session change notification %d", (DWORD)wEvent));
+            break;
+    }
+
+    return !vboxStIsActiveConsole() != !fOldIsActiveConsole;
+}
+
+static BOOL vboxStIsActiveConsole()
+{
+    return (gVBoxSt.enmConnectState == WTSActive && gVBoxSt.fIsConsole);
+}
+
+/*
+ * Dt (desktop [state] tracking) functionality API impl
+ *
+ * !!!NOTE: this API is NOT thread-safe!!!
+ * */
+
+typedef struct VBOXDT
+{
+    HANDLE hNotifyEvent;
+    BOOL fIsInputDesktop;
+    HMODULE hHookModule;
+    BOOL (* pfnVBoxHookInstallActiveDesktopTracker)(HMODULE hDll);
+    BOOL (* pfnVBoxHookRemoveActiveDesktopTracker)();
+    HMODULE hUSER32;
+    HDESK (WINAPI * pfnGetThreadDesktop)(DWORD dwThreadId);
+    HDESK (WINAPI * pfnOpenInputDesktop)(DWORD dwFlags, BOOL fInherit, ACCESS_MASK dwDesiredAccess);
+    BOOL (WINAPI * pfnCloseDesktop)(HDESK hDesktop);
+} VBOXDT;
+
+static VBOXDT gVBoxDt;
+
+static BOOL vboxDtCalculateIsInputDesktop()
+{
+    BOOL fIsInputDt = FALSE;
+    HDESK hInput = gVBoxDt.pfnOpenInputDesktop(0, FALSE, DESKTOP_CREATEWINDOW);
+    if (hInput)
+    {
+//        DWORD dwThreadId = GetCurrentThreadId();
+//        HDESK hThreadDt = gVBoxDt.pfnGetThreadDesktop(dwThreadId);
+//        if (hThreadDt)
+//        {
+            fIsInputDt = TRUE;
+//        }
+//        else
+//        {
+//            DWORD dwErr = GetLastError();
+//            WARN(("VBoxTray: pfnGetThreadDesktop for Seamless failed, last error = %08X\n", dwErr));
+//        }
+
+        gVBoxDt.pfnCloseDesktop(hInput);
+    }
+    else
+    {
+        DWORD dwErr = GetLastError();
+        WARN(("VBoxTray: pfnOpenInputDesktop for Seamless failed, last error = %08X\n", dwErr));
+    }
+    return fIsInputDt;
+}
+static int vboxDtInit()
+{
+    int rc = VINF_SUCCESS;
+    OSVERSIONINFO info;
+    gMajorVersion = 5; /* Default to Windows XP. */
+    info.dwOSVersionInfoSize = sizeof(info);
+    if (GetVersionEx(&info))
+    {
+        WARN(("VBoxTray: Windows version %ld.%ld\n", info.dwMajorVersion, info.dwMinorVersion));
+        gMajorVersion = info.dwMajorVersion;
+    }
+
+    memset(&gVBoxDt, 0, sizeof (gVBoxDt));
+
+    /* For Vista and up we need to change the integrity of the security descriptor, too. */
+    if (gMajorVersion >= 6)
+    {
+        gVBoxDt.hNotifyEvent = CreateEvent(NULL, FALSE, FALSE, VBOXHOOK_GLOBAL_DT_EVENT_NAME);
+        if (gVBoxDt.hNotifyEvent != NULL)
+        {
+            gVBoxDt.hHookModule = LoadLibrary(VBOXHOOK_DLL_NAME);
+            if (gVBoxDt.hHookModule)
+            {
+                *(uintptr_t *)&gVBoxDt.pfnVBoxHookInstallActiveDesktopTracker = (uintptr_t)GetProcAddress(gVBoxDt.hHookModule, "VBoxHookInstallActiveDesktopTracker");
+                if (!gVBoxDt.pfnVBoxHookInstallActiveDesktopTracker)
+                {
+                    WARN(("VBoxTray: VBoxHookInstallActiveDesktopTracker not found\n"));
+                    rc = VERR_NOT_SUPPORTED;
+                }
+
+                *(uintptr_t *)&gVBoxDt.pfnVBoxHookRemoveActiveDesktopTracker  = (uintptr_t)GetProcAddress(gVBoxDt.hHookModule, "VBoxHookInstallActiveDesktopTracker");
+                if (!gVBoxDt.pfnVBoxHookRemoveActiveDesktopTracker)
+                {
+                    WARN(("VBoxTray: VBoxHookRemoveActiveDesktopTracker not found\n"));
+                    rc = VERR_NOT_SUPPORTED;
+                }
+
+                if (VINF_SUCCESS == rc)
+                {
+                    gVBoxDt.hUSER32 = LoadLibrary("User32.dll");
+                    if (gVBoxDt.hUSER32)
+                    {
+                        *(uintptr_t *)&gVBoxDt.pfnGetThreadDesktop = (uintptr_t)GetProcAddress(gVBoxDt.hUSER32, "GetThreadDesktop");
+                        if (!gVBoxDt.pfnGetThreadDesktop)
+                        {
+                            WARN(("VBoxTray: GetThreadDesktop not found\n"));
+                            rc = VERR_NOT_SUPPORTED;
+                        }
+
+                        *(uintptr_t *)&gVBoxDt.pfnOpenInputDesktop = (uintptr_t)GetProcAddress(gVBoxDt.hUSER32, "OpenInputDesktop");
+                        if (!gVBoxDt.pfnOpenInputDesktop)
+                        {
+                            WARN(("VBoxTray: OpenInputDesktop not found\n"));
+                            rc = VERR_NOT_SUPPORTED;
+                        }
+
+                        *(uintptr_t *)&gVBoxDt.pfnCloseDesktop = (uintptr_t)GetProcAddress(gVBoxDt.hUSER32, "CloseDesktop");
+                        if (!gVBoxDt.pfnCloseDesktop)
+                        {
+                            WARN(("VBoxTray: CloseDesktop not found\n"));
+                            rc = VERR_NOT_SUPPORTED;
+                        }
+
+                        if (VINF_SUCCESS == rc)
+                        {
+                            gVBoxDt.pfnVBoxHookInstallActiveDesktopTracker(gVBoxDt.hHookModule);
+                            gVBoxDt.fIsInputDesktop = vboxDtCalculateIsInputDesktop();
+                            return VINF_SUCCESS;
+                        }
+                        FreeLibrary(gVBoxDt.hUSER32);
+                    }
+                }
+
+                FreeLibrary(gVBoxDt.hHookModule);
+            }
+            else
+            {
+                DWORD dwErr = GetLastError();
+                WARN(("VBoxTray: CreateEvent for Seamless failed, last error = %08X\n", dwErr));
+                rc = RTErrConvertFromWin32(dwErr);
+            }
+
+            CloseHandle(gVBoxDt.hNotifyEvent);
+        }
+        else
+        {
+            DWORD dwErr = GetLastError();
+            WARN(("VBoxTray: CreateEvent for Seamless failed, last error = %08X\n", dwErr));
+            rc = RTErrConvertFromWin32(dwErr);
+        }
+    }
+
+    memset(&gVBoxDt, 0, sizeof (gVBoxDt));
+    gVBoxDt.fIsInputDesktop = TRUE;
+
+    return rc;
+}
+
+static void vboxDtTerm()
+{
+    if (!gVBoxDt.hHookModule)
+        return;
+
+    gVBoxDt.pfnVBoxHookRemoveActiveDesktopTracker();
+
+    FreeLibrary(gVBoxDt.hUSER32);
+    FreeLibrary(gVBoxDt.hHookModule);
+    CloseHandle(gVBoxDt.hNotifyEvent);
+
+    memset(&gVBoxDt, 0, sizeof (gVBoxDt));
+}
+/* @returns true on "IsInputDesktop" state change */
+static BOOL vboxDtHandleEvent()
+{
+    BOOL fIsInputDesktop = gVBoxDt.fIsInputDesktop;
+    gVBoxDt.fIsInputDesktop = vboxDtCalculateIsInputDesktop();
+    return !fIsInputDesktop != !gVBoxDt.fIsInputDesktop;
+}
+
+static HANDLE vboxDtGetNotifyEvent()
+{
+    return gVBoxDt.hNotifyEvent;
+}
+
+/* @returns true iff the application (VBoxTray) desktop is input */
+static BOOL vboxDtIsInputDesktop()
+{
+    return gVBoxDt.fIsInputDesktop;
+}
+
+
+/* helper state tracking API */
+BOOL VBoxSeamlessIsAllowed()
+{
+    return vboxDtIsInputDesktop() && vboxStIsActiveConsole();
+}
+
+int VBoxSeamlessOnAllowChange(BOOL fAllowed)
+{
+    int rc;
+    if (fAllowed)
+    {
+        rc = VbglR3SetGuestCaps(VMMDEV_GUEST_SUPPORTS_SEAMLESS, 0);
+        if (gfIsSeamlessOn)
+            VBoxSeamlessInstallHook();
+    }
+    else
+    {
+        if (gfIsSeamlessOn)
+            VBoxSeamlessRemoveHook();
+        rc = VbglR3SetGuestCaps(0, VMMDEV_GUEST_SUPPORTS_SEAMLESS);
+    }
+    if (!RT_SUCCESS(rc))
+        WARN(("VBoxTray: VMMDEV_GUEST_SUPPORTS_SEAMLESS: Failed to %s seamless capability\n", fAllowed ? "set" : "clear" ));
+
+    return rc;
+}

trunk/src/VBox/Additions/WINNT/include/VBoxHook.h

@@ -17 +17 @@
 
 /* custom messages as we must install the hook from the main thread */
-#define WM_VBOX_INSTALL_SEAMLESS_HOOK               0x2001
-#define WM_VBOX_REMOVE_SEAMLESS_HOOK                0x2002
+#define WM_VBOX_SEAMLESS_ENABLE                     0x2001
+#define WM_VBOX_SEAMLESS_DISABLE                    0x2002
 #define WM_VBOX_SEAMLESS_UPDATE                     0x2003
 
 
 #define VBOXHOOK_DLL_NAME           "VBoxHook.dll"
-#define VBOXHOOK_GLOBAL_EVENT_NAME  "Local\\VBoxHookNotifyEvent"
+#define VBOXHOOK_GLOBAL_DT_EVENT_NAME  "Local\\VBoxHookDtNotifyEvent"
+#define VBOXHOOK_GLOBAL_WT_EVENT_NAME  "Local\\VBoxHookWtNotifyEvent"
 
-/* Install the global message hook */
-BOOL VBoxInstallHook(HMODULE hDll);
+BOOL VBoxHookInstallActiveDesktopTracker(HMODULE hDll);
+BOOL VBoxHookRemoveActiveDesktopTracker();
 
-/* Remove the global message hook */
-BOOL VBoxRemoveHook();
+BOOL VBoxHookInstallWindowTracker(HMODULE hDll);
+BOOL VBoxHookRemoveWindowTracker();
 
 #endif /* __VBoxHook_h__ */