Changeset 57741 in vbox for trunk

Timestamp:

Sep 14, 2015 3:24:42 PM (9 years ago)

Author:

vboxsync

Message:

Additions/VBoxTray:

• Refactored internal services to use the RTThread API.
• First take on cleaning up VBoxTray, separating the services more and more. See @todos.
• Updated some code areas where deprecated APIs were used.
• A lot of log formatting fixes and renaming.

Location:

trunk/src/VBox/Additions/WINNT/VBoxTray

Files:

• VBoxClipboard.cpp (modified) (18 diffs)
• VBoxClipboard.h (modified) (2 diffs)
• VBoxDispIf.cpp (modified) (15 diffs)
• VBoxDispIf.h (modified) (4 diffs)
• VBoxDisplay.cpp (modified) (30 diffs)
• VBoxDisplay.h (modified) (2 diffs)
• VBoxDnD.cpp (modified) (32 diffs)
• VBoxDnD.h (modified) (5 diffs)
• VBoxHostVersion.cpp (modified) (3 diffs)
• VBoxIPC.cpp (modified) (13 diffs)
• VBoxIPC.h (modified) (1 diff)
• VBoxLA.cpp (modified) (34 diffs)
• VBoxLA.h (modified) (2 diffs)
• VBoxSeamless.cpp (modified) (13 diffs)
• VBoxSeamless.h (modified) (3 diffs)
• VBoxTray.cpp (modified) (53 diffs)
• VBoxTray.h (modified) (5 diffs)
• VBoxVRDP.cpp (modified) (21 diffs)

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2006-2014 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -21 +21 @@
 #include "VBoxHelpers.h"
 
+#include <iprt/asm.h>
+
 #include <VBox/HostServices/VBoxClipboardSvc.h>
 #include <strsafe.h>
@@ -27 +29 @@
 #ifdef DEBUG
 # define LOG_ENABLED
-# define LOG_GROUP LOG_GROUP_DEFAULT
+# define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
 #endif
 #include <VBox/log.h>
@@ -36 +38 @@
 {
     const VBOXSERVICEENV *pEnv;
-
-    uint32_t u32ClientID;
-
-    ATOM     atomWindowClass;
-
-    HWND     hwnd;
-
-    HWND     hwndNextInChain;
-
-    UINT     timerRefresh;
-
-    bool     fCBChainPingInProcess;
-
-//    bool     fOperational;
-
-//    uint32_t u32LastSentFormat;
-//    uint64_t u64LastSentCRC64;
-
-} VBOXCLIPBOARDCONTEXT;
-
-static char gachWindowClassName[] = "VBoxSharedClipboardClass";
+    uint32_t              u32ClientID;
+    ATOM                  wndClass;
+    HWND                  hwnd;
+    HWND                  hwndNextInChain;
+    UINT                  timerRefresh;
+    bool                  fCBChainPingInProcess;
+} VBOXCLIPBOARDCONTEXT, *PVBOXCLIPBOARDCONTEXT;
+
+/** Static since it is the single instance. Directly used in the windows proc. */
+static VBOXCLIPBOARDCONTEXT g_Ctx = { NULL };
+
+static char s_szClipWndClassName[] = "VBoxSharedClipboardClass";
 
 enum { CBCHAIN_TIMEOUT = 5000 /* ms */ };
 
-static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx)
+static int vboxClipboardChanged(PVBOXCLIPBOARDCONTEXT pCtx)
 {
     AssertPtr(pCtx);
@@ -75 +68 @@
         UINT format = 0;
 
-        while ((format = EnumClipboardFormats (format)) != 0)
+        while ((format = EnumClipboardFormats(format)) != 0)
         {
             LogFlowFunc(("vboxClipboardChanged: format = 0x%08X\n", format));
@@ -91 +84 @@
 
                 default:
+                {
                     if (format >= 0xC000)
                     {
@@ -105 +99 @@
                     }
                     break;
+                }
             }
         }
 
-        CloseClipboard ();
+        CloseClipboard();
         rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, u32Formats);
     }
@@ -115 +110 @@
 
 /* Add ourselves into the chain of cliboard listeners */
-static void addToCBChain (VBOXCLIPBOARDCONTEXT *pCtx)
-{
-    pCtx->hwndNextInChain = SetClipboardViewer (pCtx->hwnd);
+static void vboxClipboardAddToCBChain(PVBOXCLIPBOARDCONTEXT pCtx)
+{
+    AssertPtrReturnVoid(pCtx);
+    pCtx->hwndNextInChain = SetClipboardViewer(pCtx->hwnd);
+    /** @todo r=andy Return code?? */
 }
 
 /* Remove ourselves from the chain of cliboard listeners */
-static void removeFromCBChain (VBOXCLIPBOARDCONTEXT *pCtx)
-{
-    ChangeClipboardChain (pCtx->hwnd, pCtx->hwndNextInChain);
+static void vboxClipboardRemoveFromCBChain(PVBOXCLIPBOARDCONTEXT pCtx)
+{
+    AssertPtrReturnVoid(pCtx);
+
+    ChangeClipboardChain(pCtx->hwnd, pCtx->hwndNextInChain);
     pCtx->hwndNextInChain = NULL;
+    /** @todo r=andy Return code?? */
 }
 
@@ -131 +131 @@
  * There is a race if a ping returns after the next one is initiated, but nothing
  * very bad is likely to happen. */
-VOID CALLBACK CBChainPingProc(HWND hwnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult)
-{
-    (void) hwnd;
-    (void) uMsg;
-    (void) lResult;
-    VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)dwData;
+VOID CALLBACK vboxClipboardChainPingProc(HWND hWnd, UINT uMsg, ULONG_PTR dwData, LRESULT lResult)
+{
+    NOREF(hWnd);
+    NOREF(uMsg);
+    NOREF(lResult);
+
+    /** @todo r=andy Why not using SetWindowLongPtr for keeping the context? */
+    PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)dwData;
+    AssertPtr(pCtx);
+
     pCtx->fCBChainPingInProcess = FALSE;
 }
 
-static LRESULT vboxClipboardProcessMsg(VBOXCLIPBOARDCONTEXT *pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{
+static LRESULT vboxClipboardProcessMsg(PVBOXCLIPBOARDCONTEXT pCtx, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    AssertPtr(pCtx);
+
     LRESULT rc = 0;
 
@@ -197 +203 @@
             if (!hViewer || pCtx->fCBChainPingInProcess)
             {
-                removeFromCBChain(pCtx);
-                addToCBChain(pCtx);
+                vboxClipboardRemoveFromCBChain(pCtx);
+                vboxClipboardAddToCBChain(pCtx);
             }
             /* Start a new ping by passing a dummy WM_CHANGECBCHAIN to be
@@ -205 +211 @@
             hViewer = GetClipboardViewer();
             if (hViewer)
-                SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pCtx->hwndNextInChain, (LPARAM)pCtx->hwndNextInChain, CBChainPingProc, (ULONG_PTR) pCtx);
+                SendMessageCallback(hViewer, WM_CHANGECBCHAIN, (WPARAM)pCtx->hwndNextInChain, (LPARAM)pCtx->hwndNextInChain, vboxClipboardChainPingProc, (ULONG_PTR) pCtx);
         } break;
 
@@ -541 +547 @@
 }
 
-static LRESULT CALLBACK vboxClipboardWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
-
-static int vboxClipboardInit (VBOXCLIPBOARDCONTEXT *pCtx)
-{
+static LRESULT CALLBACK vboxClipboardWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
+
+static int vboxClipboardCreateWindow(PVBOXCLIPBOARDCONTEXT pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
+
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pCtx->pEnv);
+    HINSTANCE hInstance = pCtx->pEnv->hInstance;
+    Assert(hInstance != 0);
+
     /* Register the Window Class. */
-    WNDCLASS wc;
-
-    wc.style         = CS_NOCLOSE;
-    wc.lpfnWndProc   = vboxClipboardWndProc;
-    wc.cbClsExtra    = 0;
-    wc.cbWndExtra    = 0;
-    wc.hInstance     = pCtx->pEnv->hInstance;
-    wc.hIcon         = NULL;
-    wc.hCursor       = NULL;
-    wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
-    wc.lpszMenuName  = NULL;
-    wc.lpszClassName = gachWindowClassName;
-
-    pCtx->atomWindowClass = RegisterClass (&wc);
-
-    int rc = VINF_SUCCESS;
-    if (pCtx->atomWindowClass == 0)
-    {
-        rc = VERR_NOT_SUPPORTED;
-    }
-    else
+    WNDCLASSEX wc = { 0 };
+    wc.cbSize     = sizeof(WNDCLASSEX);
+
+    if (!GetClassInfoEx(hInstance, s_szClipWndClassName, &wc))
+    {
+        wc.style         = CS_NOCLOSE;
+        wc.lpfnWndProc   = vboxClipboardWndProc;
+        wc.hInstance     = pCtx->pEnv->hInstance;
+        wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
+        wc.lpszClassName = s_szClipWndClassName;
+
+        pCtx->wndClass = RegisterClassEx(&wc);
+        if (pCtx->wndClass == 0)
+            rc = RTErrConvertFromWin32(GetLastError());
+    }
+
+    if (RT_SUCCESS(rc))
     {
         /* Create the window. */
-        pCtx->hwnd = CreateWindowEx (WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_TOPMOST,
-                                     gachWindowClassName, gachWindowClassName,
-                                     WS_POPUPWINDOW,
-                                     -200, -200, 100, 100, NULL, NULL, pCtx->pEnv->hInstance, NULL);
-
+        pCtx->hwnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_TOPMOST,
+                                    s_szClipWndClassName, s_szClipWndClassName,
+                                    WS_POPUPWINDOW,
+                                    -200, -200, 100, 100, NULL, NULL, hInstance, NULL);
         if (pCtx->hwnd == NULL)
         {
@@ -583 +592 @@
                          SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE);
 
-            addToCBChain(pCtx);
+            vboxClipboardAddToCBChain(pCtx);
             pCtx->timerRefresh = SetTimer(pCtx->hwnd, 0, 10 * 1000, NULL);
         }
     }
 
-    LogFlowFunc(("vboxClipboardInit returned with rc = %Rrc\n", rc));
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
 
-static void vboxClipboardDestroy(VBOXCLIPBOARDCONTEXT *pCtx)
-{
+static void vboxClipboardDestroy(PVBOXCLIPBOARDCONTEXT pCtx)
+{
+    AssertPtrReturnVoid(pCtx);
+
     if (pCtx->hwnd)
     {
-        removeFromCBChain(pCtx);
+        vboxClipboardRemoveFromCBChain(pCtx);
         if (pCtx->timerRefresh)
             KillTimer(pCtx->hwnd, 0);
 
-        DestroyWindow (pCtx->hwnd);
+        DestroyWindow(pCtx->hwnd);
         pCtx->hwnd = NULL;
     }
 
-    if (pCtx->atomWindowClass != 0)
-    {
-        UnregisterClass(gachWindowClassName, pCtx->pEnv->hInstance);
-        pCtx->atomWindowClass = 0;
-    }
-}
-
-/* Static since it is the single instance. Directly used in the windows proc. */
-static VBOXCLIPBOARDCONTEXT gCtx = { NULL };
-
-static LRESULT CALLBACK vboxClipboardWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
-{
+    if (pCtx->wndClass != 0)
+    {
+        UnregisterClass(s_szClipWndClassName, pCtx->pEnv->hInstance);
+        pCtx->wndClass = 0;
+    }
+}
+
+static LRESULT CALLBACK vboxClipboardWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /** @todo r=andy Make pCtx available through SetWindowLongPtr() / GWL_USERDATA. */
+    AssertPtr(pCtx);
+
     /* Forward with proper context. */
-    return vboxClipboardProcessMsg(&gCtx, hwnd, msg, wParam, lParam);
-}
-
-int VBoxClipboardInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
-{
-    LogFlowFunc(("VBoxClipboardInit\n"));
-    if (gCtx.pEnv)
+    return vboxClipboardProcessMsg(pCtx, hWnd, uMsg, wParam, lParam);
+}
+
+DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
+{
+    LogFlowFuncEnter();
+
+    PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */
+    AssertPtr(pCtx);
+
+    if (pCtx->pEnv)
     {
         /* Clipboard was already initialized. 2 or more instances are not supported. */
@@ -632 +647 @@
     {
         /* Do not use clipboard for remote sessions. */
-        LogRel(("VBoxTray: clipboard has been disabled for a remote session.\n"));
+        LogRel(("Clipboard: Clipboard has been disabled for a remote session\n"));
         return VERR_NOT_SUPPORTED;
     }
 
-    RT_ZERO (gCtx);
-    gCtx.pEnv = pEnv;
-
-    int rc = VbglR3ClipboardConnect(&gCtx.u32ClientID);
-    if (RT_SUCCESS (rc))
-    {
-        rc = vboxClipboardInit(&gCtx);
-        if (RT_SUCCESS (rc))
-        {
-            /* Always start the thread for host messages. */
-            *pfStartThread = true;
+    RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT));
+    pCtx->pEnv = pEnv;
+
+    int rc = VbglR3ClipboardConnect(&pCtx->u32ClientID);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vboxClipboardCreateWindow(pCtx);
+        if (RT_SUCCESS(rc))
+        {
+            *ppInstance = pCtx;
         }
         else
         {
-            VbglR3ClipboardDisconnect(gCtx.u32ClientID);
+            VbglR3ClipboardDisconnect(pCtx->u32ClientID);
         }
     }
 
-    if (RT_SUCCESS(rc))
-        *ppInstance = &gCtx;
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
 
-unsigned __stdcall VBoxClipboardThread(void *pInstance)
-{
-    LogFlowFunc(("VBoxClipboardThread\n"));
-
-    VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)pInstance;
+DECLCALLBACK(int) VBoxClipboardWorker(void *pInstance, bool volatile *pfShutdown)
+{
+    AssertPtr(pInstance);
+    LogFlowFunc(("pInstance=%p\n", pInstance));
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
+
+    PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance;
     AssertPtr(pCtx);
+
+    int rc;
 
     /* The thread waits for incoming messages from the host. */
@@ -671 +693 @@
         uint32_t u32Msg;
         uint32_t u32Formats;
-        int rc = VbglR3ClipboardGetHostMsg(pCtx->u32ClientID, &u32Msg, &u32Formats);
+        rc = VbglR3ClipboardGetHostMsg(pCtx->u32ClientID, &u32Msg, &u32Formats);
         if (RT_FAILURE(rc))
         {
-            LogFlowFunc(("VBoxClipboardThread: Failed to call the driver for host message! rc = %Rrc\n", rc));
             if (rc == VERR_INTERRUPTED)
-            {
-                /* Wait for termination event. */
-                WaitForSingleObject(pCtx->pEnv->hStopEvent, INFINITE);
                 break;
-            }
+
+            LogFlowFunc(("Error getting host message, rc=%Rrc\n", rc));
+
+            if (*pfShutdown)
+                break;
+
             /* Wait a bit before retrying. */
-            AssertPtr(pCtx->pEnv);
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 1000) == WAIT_OBJECT_0)
-            {
-                break;
-            }
+            RTThreadSleep(1000);
             continue;
         }
         else
         {
-            LogFlowFunc(("VBoxClipboardThread: VbglR3ClipboardGetHostMsg u32Msg = %ld, u32Formats = %ld\n", u32Msg, u32Formats));
+            LogFlowFunc(("u32Msg=%RU32, u32Formats=0x%x\n", u32Msg, u32Formats));
             switch (u32Msg)
             {
+                /** @todo r=andy Use a #define for WM_USER (+1). */
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
                 {
@@ -699 +719 @@
                      * Forward the information to the window, so it can later
                      * respond to WM_RENDERFORMAT message. */
-                    ::PostMessage (pCtx->hwnd, WM_USER, 0, u32Formats);
+                    ::PostMessage(pCtx->hwnd, WM_USER, 0, u32Formats);
                 } break;
 
@@ -705 +725 @@
                 {
                     /* The host needs data in the specified format. */
-                    ::PostMessage (pCtx->hwnd, WM_USER + 1, 0, u32Formats);
+                    ::PostMessage(pCtx->hwnd, WM_USER + 1, 0, u32Formats);
                 } break;
 
@@ -711 +731 @@
                 {
                     /* The host is terminating. */
-                    rc = VERR_INTERRUPTED;
+                    LogRel(("Clipboard: Terminating ...\n"));
+                    ASMAtomicXchgBool(pfShutdown, true);
                 } break;
 
                 default:
                 {
-                    LogFlowFunc(("VBoxClipboardThread: Unsupported message from host! Message = %ld\n", u32Msg));
-                }
+                    LogFlowFunc(("Unsupported message from host, message=%RU32\n", u32Msg));
+
+                    /* Wait a bit before retrying. */
+                    RTThreadSleep(1000);
+                } break;
             }
         }
-    }
-    return 0;
-}
-
-void VBoxClipboardDestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)pInstance;
-    if (pCtx != &gCtx)
-    {
-        LogFlowFunc(("VBoxClipboardDestroy: invalid instance %p (our = %p)!\n", pCtx, &gCtx));
-        pCtx = &gCtx;
-    }
-
-    vboxClipboardDestroy (pCtx);
+
+        if (*pfShutdown)
+            break;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+DECLCALLBACK(int) VBoxClipboardStop(void *pInstance)
+{
+    AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
+
+    LogFunc(("Stopping pInstance=%p\n", pInstance));
+
+    PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance;
+    AssertPtr(pCtx);
+
     VbglR3ClipboardDisconnect(pCtx->u32ClientID);
-    memset (pCtx, 0, sizeof (*pCtx));
+    pCtx->u32ClientID = 0;
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
+    return VINF_SUCCESS;
+}
+
+DECLCALLBACK(void) VBoxClipboardDestroy(void *pInstance)
+{
+    AssertPtrReturnVoid(pInstance);
+
+    PVBOXCLIPBOARDCONTEXT pCtx = (PVBOXCLIPBOARDCONTEXT)pInstance;
+    AssertPtr(pCtx);
+
+    /* Make sure that we are disconnected. */
+    Assert(pCtx->u32ClientID == 0);
+
+    vboxClipboardDestroy(pCtx);
+    RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT));
+
     return;
 }
 
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescClipboard =
+{
+    /* pszName. */
+    "clipboard",
+    /* pszDescription. */
+    "Shared Clipboard",
+    /* methods */
+    VBoxClipboardInit,
+    VBoxClipboardWorker,
+    VBoxClipboardStop,
+    VBoxClipboardDestroy
+};
+

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2010 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19 +19 @@
 #define __VBOXSERVICESHAREDCLIPLBOARD__H
 
-/* The shared clipboard service prototypes. */
-int                VBoxClipboardInit    (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-unsigned __stdcall VBoxClipboardThread  (void *pInstance);
-void               VBoxClipboardDestroy (const VBOXSERVICEENV *pEnv, void *pInstance);
+#endif /* __VBOXSERVICESHAREDCLIPLBOARD__H */
 
-
-#endif /* __VBOXSERVICESHAREDCLIPLBOARD__H */

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

@@ -53 +53 @@
 } VBOXDISPIF_OP;
 
-DWORD EnableAndResizeDispDev(DEVMODE *paDeviceModes, DISPLAY_DEVICE *paDisplayDevices, DWORD totalDispNum, UINT Id, DWORD aWidth, DWORD aHeight,
-                                    DWORD aBitsPerPixel, LONG aPosX, LONG aPosY, BOOL fEnabled, BOOL fExtDispSup);
-
 static DWORD vboxDispIfWddmResizeDisplay(PCVBOXDISPIF const pIf, UINT Id, BOOL fEnable, DISPLAY_DEVICE * paDisplayDevices, DEVMODE *paDeviceMode, UINT devModes);
-
 static DWORD vboxDispIfResizePerform(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes);
-
 static DWORD vboxDispIfWddmEnableDisplaysTryingTopology(PCVBOXDISPIF const pIf, UINT cIds, UINT *pIds, BOOL fEnable);
-
 static DWORD vboxDispIfResizeStartedWDDMOp(VBOXDISPIF_OP *pOp);
 
-/* APIs specific to win7 and above WDDM architecture. Not available for Vista WDDM.
- * This is the reason they have not been put in the VBOXDISPIF struct in VBoxDispIf.h
+/*
+ * APIs specific to Win7 and above WDDM architecture. Not available for Vista WDDM.
+ * This is the reason they have not been put in the VBOXDISPIF struct in VBoxDispIf.h.
  */
 typedef struct _VBOXDISPLAYWDDMAPICONTEXT
@@ -961 +956 @@
 {
     HRESULT hr = S_OK;
+
+    /** @todo r=andy Use VBOXSERVICEENV::hInstance. */
     HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
+
     /* Register the Window Class. */
-    WNDCLASS wc;
-    if (!GetClassInfo(hInstance, VBOXRRWND_NAME, &wc))
-    {
-        wc.style = 0;//CS_OWNDC;
-        wc.lpfnWndProc = vboxRrWndProc;
-        wc.cbClsExtra = 0;
-        wc.cbWndExtra = 0;
-        wc.hInstance = hInstance;
-        wc.hIcon = NULL;
-        wc.hCursor = NULL;
-        wc.hbrBackground = NULL;
-        wc.lpszMenuName = NULL;
+    WNDCLASSEX wc = { 0 };
+    wc.cbSize     = sizeof(WNDCLASSEX);
+
+    if (!GetClassInfoEx(hInstance, VBOXRRWND_NAME, &wc))
+    {
+        wc.lpfnWndProc   = vboxRrWndProc;
+        wc.hInstance     = hInstance;
         wc.lpszClassName = VBOXRRWND_NAME;
-        if (!RegisterClass(&wc))
+
+        if (!RegisterClassEx(&wc))
         {
             DWORD winErr = GetLastError();
@@ -1790 +1784 @@
 static DWORD vboxDispIfResizeStartedWDDMOp(VBOXDISPIF_OP *pOp)
 {
-    DWORD NumDevices = VBoxGetDisplayConfigCount();
+    DWORD NumDevices = VBoxDisplayGetCount();
     if (NumDevices == 0)
     {
@@ -1802 +1796 @@
     DWORD DevPrimaryNum = 0;
 
-    DWORD winEr = VBoxGetDisplayConfig(NumDevices, &DevPrimaryNum, &DevNum, paDisplayDevices, paDeviceModes);
+    DWORD winEr = VBoxDisplayGetConfig(NumDevices, &DevPrimaryNum, &DevNum, paDisplayDevices, paDeviceModes);
     if (winEr != NO_ERROR)
     {
@@ -1831 +1825 @@
         WARN(("VBoxTray: vboxDispIfResizeStartedWDDMOp: vboxDispIfWaitDisplayDataInited failed winEr 0x%x\n", winEr));
 
-    DWORD NewNumDevices = VBoxGetDisplayConfigCount();
+    DWORD NewNumDevices = VBoxDisplayGetCount();
     if (NewNumDevices == 0)
     {
@@ -1846 +1840 @@
     DWORD NewDevPrimaryNum = 0;
 
-    winEr = VBoxGetDisplayConfig(NewNumDevices, &NewDevPrimaryNum, &NewDevNum, paNewDisplayDevices, paNewDeviceModes);
+    winEr = VBoxDisplayGetConfig(NewNumDevices, &NewDevPrimaryNum, &NewDevNum, paNewDisplayDevices, paNewDeviceModes);
     if (winEr != NO_ERROR)
     {
@@ -1945 +1939 @@
 {
     DWORD err = NO_ERROR;
-    AssertBreakpoint();
+
     OSVERSIONINFO OSinfo;
-    OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
+    OSinfo.dwOSVersionInfoSize = sizeof(OSinfo);
     GetVersionEx (&OSinfo);
     if (OSinfo.dwMajorVersion >= 5)
@@ -2059 +2053 @@
 }
 
-static DWORD vboxDispIfSeamlesCreateWDDM(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent)
+static DWORD vboxDispIfSeamlessCreateWDDM(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent)
 {
     HRESULT hr = vboxDispKmtOpenAdapter(&pIf->modeData.wddm.KmtCallbacks, &pSeamless->modeData.wddm.Adapter);
@@ -2089 +2083 @@
 }
 
-static DWORD vboxDispIfSeamlesTermWDDM(VBOXDISPIF_SEAMLESS *pSeamless)
+static DWORD vboxDispIfSeamlessTermWDDM(VBOXDISPIF_SEAMLESS *pSeamless)
 {
 #ifdef VBOX_DISPIF_WITH_OPCONTEXT
@@ -2100 +2094 @@
 }
 
-static DWORD vboxDispIfSeamlesSubmitWDDM(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData)
+static DWORD vboxDispIfSeamlessSubmitWDDM(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData)
 {
     D3DKMT_ESCAPE EscapeData = {0};
@@ -2121 +2115 @@
 }
 
-DWORD VBoxDispIfSeamlesCreate(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent)
+DWORD VBoxDispIfSeamlessCreate(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent)
 {
     memset(pSeamless, 0, sizeof (*pSeamless));
@@ -2134 +2128 @@
         case VBOXDISPIF_MODE_WDDM:
         case VBOXDISPIF_MODE_WDDM_W7:
-            return vboxDispIfSeamlesCreateWDDM(pIf, pSeamless, hEvent);
+            return vboxDispIfSeamlessCreateWDDM(pIf, pSeamless, hEvent);
 #endif
         default:
-            WARN(("VBoxTray: VBoxDispIfSeamlesCreate: invalid mode %d\n", pIf->enmMode));
-            return ERROR_INVALID_PARAMETER;
-    }
-}
-
-DWORD VBoxDispIfSeamlesTerm(VBOXDISPIF_SEAMLESS *pSeamless)
+            break;
+    }
+
+    WARN(("VBoxTray: VBoxDispIfSeamlessCreate: invalid mode %d\n", pIf->enmMode));
+    return ERROR_INVALID_PARAMETER;
+}
+
+DWORD VBoxDispIfSeamlessTerm(VBOXDISPIF_SEAMLESS *pSeamless)
 {
     PCVBOXDISPIF const pIf = pSeamless->pIf;
@@ -2155 +2151 @@
         case VBOXDISPIF_MODE_WDDM:
         case VBOXDISPIF_MODE_WDDM_W7:
-            winEr = vboxDispIfSeamlesTermWDDM(pSeamless);
+            winEr = vboxDispIfSeamlessTermWDDM(pSeamless);
             break;
 #endif
         default:
-            WARN(("VBoxTray: VBoxDispIfSeamlesTerm: invalid mode %d\n", pIf->enmMode));
+            WARN(("VBoxTray: VBoxDispIfSeamlessTerm: invalid mode %d\n", pIf->enmMode));
             winEr = ERROR_INVALID_PARAMETER;
             break;
@@ -2170 +2166 @@
 }
 
-DWORD VBoxDispIfSeamlesSubmit(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData)
+DWORD VBoxDispIfSeamlessSubmit(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData)
 {
     PCVBOXDISPIF const pIf = pSeamless->pIf;
@@ -2188 +2184 @@
         case VBOXDISPIF_MODE_WDDM:
         case VBOXDISPIF_MODE_WDDM_W7:
-            return vboxDispIfSeamlesSubmitWDDM(pSeamless, pData, cbData);
+            return vboxDispIfSeamlessSubmitWDDM(pSeamless, pData, cbData);
 #endif
         default:
-            WARN(("VBoxTray: VBoxDispIfSeamlesSubmit: invalid mode %d\n", pIf->enmMode));
+            WARN(("VBoxTray: VBoxDispIfSeamlessSubmit: invalid mode %d\n", pIf->enmMode));
             return ERROR_INVALID_PARAMETER;
     }
 }
+

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

@@ -51 +51 @@
         struct
         {
-            LONG (WINAPI * pfnChangeDisplaySettingsEx)(LPCSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
+            LONG (WINAPI *pfnChangeDisplaySettingsEx)(LPCSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
         } xpdm;
 #ifdef VBOX_WITH_WDDM
@@ -57 +57 @@
         {
             /* ChangeDisplaySettingsEx does not exist in NT. ResizeDisplayDevice uses the function. */
-            LONG (WINAPI * pfnChangeDisplaySettingsEx)(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
-
+            LONG (WINAPI *pfnChangeDisplaySettingsEx)(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
             /* EnumDisplayDevices does not exist in NT. isVBoxDisplayDriverActive et al. are using these functions. */
-            BOOL (WINAPI * pfnEnumDisplayDevices)(IN LPCSTR lpDevice, IN DWORD iDevNum, OUT PDISPLAY_DEVICEA lpDisplayDevice, IN DWORD dwFlags);
+            BOOL (WINAPI *pfnEnumDisplayDevices)(IN LPCSTR lpDevice, IN DWORD iDevNum, OUT PDISPLAY_DEVICEA lpDisplayDevice, IN DWORD dwFlags);
 
             VBOXDISPKMT_CALLBACKS KmtCallbacks;
@@ -80 +79 @@
 DWORD VBoxDispIfResizeModes(PCVBOXDISPIF const pIf, UINT iChangedMode, BOOL fEnable, BOOL fExtDispSup, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes, UINT cDevModes);
 DWORD VBoxDispIfCancelPendingResize(PCVBOXDISPIF const pIf);
-
 DWORD VBoxDispIfResizeStarted(PCVBOXDISPIF const pIf);
-
 
 typedef struct VBOXDISPIF_SEAMLESS
@@ -108 +105 @@
 }
 
-DWORD VBoxDispIfSeamlesCreate(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent);
-DWORD VBoxDispIfSeamlesTerm(VBOXDISPIF_SEAMLESS *pSeamless);
-DWORD VBoxDispIfSeamlesSubmit(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData);
+DWORD VBoxDispIfSeamlessCreate(PCVBOXDISPIF const pIf, VBOXDISPIF_SEAMLESS *pSeamless, HANDLE hEvent);
+DWORD VBoxDispIfSeamlessTerm(VBOXDISPIF_SEAMLESS *pSeamless);
+DWORD VBoxDispIfSeamlessSubmit(VBOXDISPIF_SEAMLESS *pSeamless, VBOXDISPIFESCAPE *pData, int cbData);
+

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2014 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -42 +42 @@
 {
     const VBOXSERVICEENV *pEnv;
-
     BOOL fAnyX;
-
-    /* ChangeDisplaySettingsEx does not exist in NT. ResizeDisplayDevice uses the function. */
+    /** ChangeDisplaySettingsEx does not exist in NT. ResizeDisplayDevice uses the function. */
     LONG (WINAPI * pfnChangeDisplaySettingsEx)(LPCTSTR lpszDeviceName, LPDEVMODE lpDevMode, HWND hwnd, DWORD dwflags, LPVOID lParam);
-
-    /* EnumDisplayDevices does not exist in NT. isVBoxDisplayDriverActive et al. are using these functions. */
+    /** EnumDisplayDevices does not exist in NT. isVBoxDisplayDriverActive et al. are using these functions. */
     BOOL (WINAPI * pfnEnumDisplayDevices)(IN LPCSTR lpDevice, IN DWORD iDevNum, OUT PDISPLAY_DEVICEA lpDisplayDevice, IN DWORD dwFlags);
-} VBOXDISPLAYCONTEXT;
-
-static VBOXDISPLAYCONTEXT gCtx = {0};
+    /** Display driver interface, XPDM - WDDM abstraction see VBOXDISPIF** definitions above */
+    VBOXDISPIF dispIf;
+} VBOXDISPLAYCONTEXT, *PVBOXDISPLAYCONTEXT;
+
+static VBOXDISPLAYCONTEXT g_Ctx = { 0 };
 
 #ifdef VBOX_WITH_WDDM
@@ -65 +64 @@
 #endif
 
-int VBoxDisplayInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
+static DECLCALLBACK(int) VBoxDisplayInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
 {
-    LogFlowFunc(("VBoxDisplayInit ...\n"));
-
-    OSVERSIONINFO OSinfo;
-    OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
+    LogFlowFuncEnter();
+
+    PVBOXDISPLAYCONTEXT pCtx = &g_Ctx; /** @todo r=andy Use instance data via service lookup (add void *pInstance). */
+    AssertPtr(pCtx);
+
+    OSVERSIONINFO OSinfo; /** @todo r=andy Use VBoxTray's g_dwMajorVersion? */
+    OSinfo.dwOSVersionInfoSize = sizeof(OSinfo);
     GetVersionEx (&OSinfo);
 
-    HMODULE hUser = GetModuleHandle("user32.dll");
-
-    gCtx.pEnv = pEnv;
+    int rc;
+    HMODULE hUser = GetModuleHandle("user32.dll"); /** @todo r=andy Use RTLdrXXX and friends. */
+
+    pCtx->pEnv = pEnv;
 
     if (NULL == hUser)
     {
         LogFlowFunc(("Could not get module handle of USER32.DLL!\n"));
-        return VERR_NOT_IMPLEMENTED;
-    }
-    else if (OSinfo.dwMajorVersion >= 5)        /* APIs available only on W2K and up! */
-    {
-        *(uintptr_t *)&gCtx.pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
-        LogFlowFunc(("pfnChangeDisplaySettingsEx = %p\n", gCtx.pfnChangeDisplaySettingsEx));
-
-        *(uintptr_t *)&gCtx.pfnEnumDisplayDevices = (uintptr_t)GetProcAddress(hUser, "EnumDisplayDevicesA");
-        LogFlowFunc(("pfnEnumDisplayDevices = %p\n", gCtx.pfnEnumDisplayDevices));
+        rc = VERR_NOT_IMPLEMENTED;
+    }
+    else if (OSinfo.dwMajorVersion >= 5)        /* APIs available only on W2K and up. */
+    {
+        /** @todo r=andy Use RTLdrXXX and friends. */
+        /** @todo r=andy No unicode version available? */
+        *(uintptr_t *)&pCtx->pfnChangeDisplaySettingsEx = (uintptr_t)GetProcAddress(hUser, "ChangeDisplaySettingsExA");
+        LogFlowFunc(("pfnChangeDisplaySettingsEx = %p\n", pCtx->pfnChangeDisplaySettingsEx));
+
+        *(uintptr_t *)&pCtx->pfnEnumDisplayDevices = (uintptr_t)GetProcAddress(hUser, "EnumDisplayDevicesA");
+        LogFlowFunc(("pfnEnumDisplayDevices = %p\n", pCtx->pfnEnumDisplayDevices));
 
 #ifdef VBOX_WITH_WDDM
         if (OSinfo.dwMajorVersion >= 6)
         {
-            /* this is vista and up, check if we need to switch the display driver if to WDDM mode */
+            /* This is Vista and up, check if we need to switch the display driver if to WDDM mode. */
             LogFlowFunc(("this is Windows Vista and up\n"));
-            VBOXDISPLAY_DRIVER_TYPE enmType = getVBoxDisplayDriverType (&gCtx);
+            VBOXDISPLAY_DRIVER_TYPE enmType = getVBoxDisplayDriverType(pCtx);
             if (enmType == VBOXDISPLAY_DRIVER_TYPE_WDDM)
             {
                 LogFlowFunc(("WDDM driver is installed, switching display driver if to WDDM mode\n"));
-                /* this is hacky, but the most easiest way */
+                /* This is hacky, but the most easiest way. */
                 VBOXDISPIF_MODE enmMode = (OSinfo.dwMajorVersion > 6 || OSinfo.dwMinorVersion > 0) ? VBOXDISPIF_MODE_WDDM_W7 : VBOXDISPIF_MODE_WDDM;
-                DWORD err = VBoxDispIfSwitchMode(const_cast<PVBOXDISPIF>(&pEnv->dispIf), enmMode, NULL /* old mode, we don't care about it */);
-                if (err == NO_ERROR)
-                    LogFlowFunc(("DispIf switched to WDDM mode successfully\n"));
+                DWORD dwErr = VBoxDispIfSwitchMode(const_cast<PVBOXDISPIF>(&pEnv->dispIf), enmMode, NULL /* old mode, we don't care about it */);
+                if (dwErr == NO_ERROR)
+                {
+                    LogFlowFunc(("DispIf successfully switched to WDDM mode\n"));
+                    rc = VINF_SUCCESS;
+                }
                 else
-                    LogFlowFunc(("Failed to switch DispIf to WDDM mode, err (%d)\n", err));
+                {
+                    LogFlowFunc(("Failed to switch DispIf to WDDM mode, error (%d)\n", dwErr));
+                    rc = RTErrConvertFromWin32(dwErr);
+                }
             }
-        }
+            else
+                rc = VINF_SUCCESS;
+        }
+        else
+            rc = VINF_SUCCESS;
 #endif
     }
-    else if (OSinfo.dwMajorVersion <= 4)            /* Windows NT 4.0 */
-    {
-        /* Nothing to do here yet */
-    }
-    else                                /* Unsupported platform */
-    {
-        LogFlowFunc(("Warning, display for platform not handled yet!\n"));
-        return VERR_NOT_IMPLEMENTED;
-    }
-
-    VBOXDISPIFESCAPE_ISANYX IsAnyX = {0};
-    IsAnyX.EscapeHdr.escapeCode = VBOXESC_ISANYX;
-    DWORD err = VBoxDispIfEscapeInOut(&pEnv->dispIf, &IsAnyX.EscapeHdr, sizeof (uint32_t));
-    if (err == NO_ERROR)
-        gCtx.fAnyX = !!IsAnyX.u32IsAnyX;
-    else
-        gCtx.fAnyX = TRUE;
-
-    LogFlowFunc(("Display init successful\n"));
-
-    *pfStartThread = true;
-    *ppInstance = (void *)&gCtx;
-    return VINF_SUCCESS;
+    else if (OSinfo.dwMajorVersion <= 4) /* Windows NT 4.0. */
+    {
+        /* Nothing to do here yet. */
+        /** @todo r=andy Has this been tested? */
+        rc = VINF_SUCCESS;
+    }
+    else                                 /* Unsupported platform. */
+    {
+        LogFlowFunc(("Warning: Display for platform not handled yet!\n"));
+        rc = VERR_NOT_IMPLEMENTED;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        VBOXDISPIFESCAPE_ISANYX IsAnyX = { 0 };
+        IsAnyX.EscapeHdr.escapeCode = VBOXESC_ISANYX;
+        DWORD err = VBoxDispIfEscapeInOut(&pEnv->dispIf, &IsAnyX.EscapeHdr, sizeof(uint32_t));
+        if (err == NO_ERROR)
+            pCtx->fAnyX = !!IsAnyX.u32IsAnyX;
+        else
+            pCtx->fAnyX = TRUE;
+
+        *ppInstance = pCtx;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
-void VBoxDisplayDestroy (const VBOXSERVICEENV *pEnv, void *pInstance)
+static DECLCALLBACK(void) VBoxDisplayDestroy(void *pInstance)
 {
     return;
@@ -141 +160 @@
 
 #ifdef VBOX_WITH_WDDM
-static VBOXDISPLAY_DRIVER_TYPE getVBoxDisplayDriverType(VBOXDISPLAYCONTEXT *pCtx)
+static VBOXDISPLAY_DRIVER_TYPE getVBoxDisplayDriverType(PVBOXDISPLAYCONTEXT pCtx)
 #else
-static bool isVBoxDisplayDriverActive(VBOXDISPLAYCONTEXT *pCtx)
+static bool isVBoxDisplayDriverActive(PVBOXDISPLAYCONTEXT pCtx)
 #endif
 {
@@ -224 +243 @@
 }
 
-DWORD EnableAndResizeDispDev(DEVMODE *paDeviceModes, DISPLAY_DEVICE *paDisplayDevices, DWORD totalDispNum, UINT Id, DWORD aWidth, DWORD aHeight,
-                                    DWORD aBitsPerPixel, LONG aPosX, LONG aPosY, BOOL fEnabled, BOOL fExtDispSup)
+/** @todo r=andy The "display", "seamless" (and VBoxCaps facility in VBoxTray.cpp indirectly) is using this.
+ *               Add a PVBOXDISPLAYCONTEXT here for properly getting the display (XPDM/WDDM) abstraction interfaces. */
+DWORD EnableAndResizeDispDev(DEVMODE *paDeviceModes, DISPLAY_DEVICE *paDisplayDevices,
+                             DWORD totalDispNum, UINT Id, DWORD aWidth, DWORD aHeight,
+                             DWORD aBitsPerPixel, LONG aPosX, LONG aPosY, BOOL fEnabled, BOOL fExtDispSup)
 {
     DISPLAY_DEVICE displayDeviceTmp;
@@ -233 +255 @@
     DWORD iter ;
 
+    PVBOXDISPLAYCONTEXT pCtx = &g_Ctx; /* See todo above. */
+
     deviceMode = paDeviceModes[Id];
     displayDevice = paDisplayDevices[Id];
@@ -240 +264 @@
         if (iter != 0 && iter != Id && !(paDisplayDevices[iter].StateFlags & DISPLAY_DEVICE_ACTIVE))
         {
-            LogRel(("VBoxTray:Initially disabling the monitor with id = %d . Total Monitor=%d\n", iter, totalDispNum));
+            LogRel(("Display: Initially disabling monitor with ID=%ld; total monitor count is %ld\n", iter, totalDispNum));
             DEVMODE deviceModeTmp;
             ZeroMemory(&deviceModeTmp, sizeof(DEVMODE));
@@ -247 +271 @@
                                      | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS ;
             displayDeviceTmp = paDisplayDevices[iter];
-            gCtx.pfnChangeDisplaySettingsEx(displayDeviceTmp.DeviceName, &deviceModeTmp, NULL,
-                                           (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
+            pCtx->pfnChangeDisplaySettingsEx(displayDeviceTmp.DeviceName, &deviceModeTmp, NULL,
+                                             (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
         }
     }
@@ -259 +283 @@
             if(!(displayDevice.StateFlags & DISPLAY_DEVICE_ACTIVE))
             {
-                LogRel(("Secondary Monitor with ID=%d and name=%s Not Enabled. Enabling it.\n", Id, displayDevice.DeviceName));
+                LogRel(("Display [ID=%ld, name='%s']: Is a secondary monitor and disabled -- enabling it\n", Id, displayDevice.DeviceName));
                 deviceMode.dmPosition.x = paDeviceModes[0].dmPelsWidth;
                 deviceMode.dmPosition.y = 0;
@@ -274 +298 @@
                     deviceMode.dmFields =   DM_BITSPERPEL | DM_DISPLAYFLAGS | DM_DISPLAYFREQUENCY  | DM_POSITION;
 
-                dwStatus = gCtx.pfnChangeDisplaySettingsEx((LPSTR)displayDevice.DeviceName,&deviceMode, NULL, (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
+                dwStatus = pCtx->pfnChangeDisplaySettingsEx((LPSTR)displayDevice.DeviceName,&deviceMode, NULL, (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
                 /* A second call to ChangeDisplaySettings updates the monitor.*/
-                gCtx.pfnChangeDisplaySettingsEx(NULL, NULL, NULL,0, NULL);
+                pCtx->pfnChangeDisplaySettingsEx(NULL, NULL, NULL,0, NULL);
             }
             else /* secondary monitor already enabled. Request to change the resolution or position. */
@@ -282 +306 @@
                 if (aWidth !=0 && aHeight != 0)
                 {
-                    LogRel(("Display : %s , Change Height: %d & Width: %d\n", displayDevice.DeviceName, aWidth, aHeight));
+                    LogRel(("Display [ID=%ld, name='%s']: Changing resolution to %ldx%ld\n", Id, displayDevice.DeviceName, aWidth, aHeight));
                     deviceMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL
                                           | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS;
@@ -291 +315 @@
                 if (aPosX != 0 || aPosY != 0)
                 {
-                    LogRel(("Display: %s PosX: %d, PosY: %d\n", displayDevice.DeviceName, aPosX, aPosY));
+                    LogRel(("Display [ID=%ld, name='%s']: Changing position to %ld,%ld\n", Id, displayDevice.DeviceName, aPosX, aPosY));
                     deviceMode.dmFields |=  DM_POSITION;
                     deviceMode.dmPosition.x = aPosX;
                     deviceMode.dmPosition.y = aPosY;
                 }
-                dwStatus = gCtx.pfnChangeDisplaySettingsEx((LPSTR)displayDevice.DeviceName,
-                                                   &deviceMode, NULL, CDS_NORESET|CDS_UPDATEREGISTRY, NULL);
+                dwStatus = pCtx->pfnChangeDisplaySettingsEx((LPSTR)displayDevice.DeviceName,
+                                                            &deviceMode, NULL, CDS_NORESET|CDS_UPDATEREGISTRY, NULL);
                 /* A second call to ChangeDisplaySettings updates the monitor. */
-                gCtx.pfnChangeDisplaySettingsEx(NULL, NULL, NULL,0, NULL);
+                pCtx->pfnChangeDisplaySettingsEx(NULL, NULL, NULL,0, NULL);
             }
         }
         else /* Request is there to disable the monitor with ID = Id*/
         {
-            LogRel(("Disable the Display: %d\n", displayDevice.DeviceName));
+            LogRel(("Display [ID=%ld, name='%s']: Disalbing\n", Id, displayDevice.DeviceName));
 
             DEVMODE deviceModeTmp;
@@ -312 +336 @@
                                      | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS ;
             displayDeviceTmp = paDisplayDevices[Id];
-            dwStatus = gCtx.pfnChangeDisplaySettingsEx(displayDeviceTmp.DeviceName, &deviceModeTmp, NULL,
-                                           (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
-            gCtx.pfnChangeDisplaySettingsEx(NULL, NULL, NULL,0, NULL);
+            dwStatus = pCtx->pfnChangeDisplaySettingsEx(displayDeviceTmp.DeviceName, &deviceModeTmp, NULL,
+                                                        (CDS_UPDATEREGISTRY | CDS_NORESET), NULL);
+            pCtx->pfnChangeDisplaySettingsEx(NULL, NULL, NULL,0, NULL);
         }
     }
@@ -320 +344 @@
 }
 
-DWORD VBoxGetDisplayConfigCount()
+DWORD VBoxDisplayGetCount(void)
 {
     DISPLAY_DEVICE DisplayDevice;
@@ -354 +378 @@
 }
 
-DWORD VBoxGetDisplayConfig(const DWORD NumDevices, DWORD *pDevPrimaryNum, DWORD *pNumDevices, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes)
+DWORD VBoxDisplayGetConfig(const DWORD NumDevices, DWORD *pDevPrimaryNum, DWORD *pNumDevices,
+                           DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes)
 {
     /* Fetch information about current devices and modes. */
@@ -441 +466 @@
 
 /* Returns TRUE to try again. */
-static BOOL ResizeDisplayDevice(UINT Id, DWORD Width, DWORD Height, DWORD BitsPerPixel,
+/** @todo r=andy Why not using the VMMDevDisplayChangeRequestEx structure for all those parameters here? */
+static BOOL ResizeDisplayDevice(PVBOXDISPLAYCONTEXT pCtx,
+                                UINT Id, DWORD Width, DWORD Height, DWORD BitsPerPixel,
                                 BOOL fEnabled, LONG dwNewPosX, LONG dwNewPosY, bool fChangeOrigin,
-                                VBOXDISPLAYCONTEXT *pCtx, BOOL fExtDispSup)
+                                BOOL fExtDispSup)
 {
     BOOL fDispAlreadyEnabled = false; /* check whether the monitor with ID is already enabled. */
@@ -453 +480 @@
           Id, Width, Height, dwNewPosX, dwNewPosY, fChangeOrigin, fEnabled, fExtDispSup));
 
-    if (!gCtx.fAnyX)
+    if (!pCtx->fAnyX)
         Width &= 0xFFF8;
 
     VBoxDispIfCancelPendingResize(&pCtx->pEnv->dispIf);
 
-    DWORD NumDevices = VBoxGetDisplayConfigCount();
+    DWORD NumDevices = VBoxDisplayGetCount();
 
     if (NumDevices == 0 || Id >= NumDevices)
@@ -473 +500 @@
     DWORD DevNum = 0;
     DWORD DevPrimaryNum = 0;
-    DWORD dwStatus = VBoxGetDisplayConfig(NumDevices, &DevPrimaryNum, &DevNum, paDisplayDevices, paDeviceModes);
+    DWORD dwStatus = VBoxDisplayGetConfig(NumDevices, &DevPrimaryNum, &DevNum, paDisplayDevices, paDeviceModes);
     if (dwStatus != NO_ERROR)
     {
@@ -566 +593 @@
      * all rect conditions are true. Thus in this case nothing has to be done.
      */
-    if ( !fModeReset && (!fEnabled == !fDispAlreadyEnabled)
-        && paRects[Id].left == dwNewPosX
-        && paRects[Id].top == dwNewPosY
-        && paRects[Id].right - paRects[Id].left == Width
-        && paRects[Id].bottom - paRects[Id].top == Height
+    if (   !fModeReset && (!fEnabled == !fDispAlreadyEnabled)
+        && paRects[Id].left                      == dwNewPosX
+        && paRects[Id].top                       == dwNewPosY
+        && paRects[Id].right  - paRects[Id].left == Width
+        && paRects[Id].bottom - paRects[Id].top  == Height
         && paDeviceModes[Id].dmBitsPerPel == BitsPerPixel)
     {
@@ -617 +644 @@
 
             LogFlowFunc(("ResizeDisplayDevice: pfnChangeDisplaySettingsEx %x: %dx%dx%d at %d,%d fields 0x%X\n",
-                  gCtx.pfnChangeDisplaySettingsEx,
+                  pCtx->pfnChangeDisplaySettingsEx,
                   paDeviceModes[i].dmPelsWidth,
                   paDeviceModes[i].dmPelsHeight,
@@ -681 +708 @@
               paDeviceModes[i].dmPosition.y));
 
-        LONG status = gCtx.pfnChangeDisplaySettingsEx((LPSTR)paDisplayDevices[i].DeviceName,
-                                        &paDeviceModes[i], NULL, CDS_NORESET | CDS_UPDATEREGISTRY, NULL);
+        LONG status = pCtx->pfnChangeDisplaySettingsEx((LPSTR)paDisplayDevices[i].DeviceName,
+                                                       &paDeviceModes[i], NULL, CDS_NORESET | CDS_UPDATEREGISTRY, NULL);
         LogFlowFunc(("ResizeDisplayDevice: ChangeDisplaySettingsEx position status %d, err %d\n", status, GetLastError ()));
     }
@@ -706 +733 @@
  * requests
  */
-unsigned __stdcall VBoxDisplayThread(void *pInstance)
+DECLCALLBACK(int) VBoxDisplayWorker(void *pInstance, bool volatile *pfShutdown)
 {
-    LogFlowFunc(("Entered\n"));
-
-    VBOXDISPLAYCONTEXT *pCtx = (VBOXDISPLAYCONTEXT *)pInstance;
+    AssertPtr(pInstance);
+    LogFlowFunc(("pInstance=%p\n", pInstance));
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
+
+    PVBOXDISPLAYCONTEXT pCtx = (PVBOXDISPLAYCONTEXT)pInstance;
+
     HANDLE gVBoxDriver = pCtx->pEnv->hDriver;
-    bool fTerminate = false;
     VBoxGuestFilterMaskInfo maskInfo;
     DWORD cbReturned;
@@ -720 +754 @@
     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
     {
-        LogFlowFunc(("DeviceIOControl(CtlMask - or) failed, thread exiting\n"));
-        return 0;
-    }
-
-    PostMessage(ghwndToolWindow, WM_VBOX_GRAPHICS_SUPPORTED, 0, 0);
+        DWORD dwErr = GetLastError();
+        LogFlowFunc(("DeviceIOControl(CtlMask - or) failed with %ld, exiting\n", dwErr));
+        return RTErrConvertFromWin32(dwErr);
+    }
+
+    PostMessage(g_hwndToolWindow, WM_VBOX_GRAPHICS_SUPPORTED, 0, 0);
 
     VBoxDispIfResizeStarted(&pCtx->pEnv->dispIf);
 
-    do
+    int rc = VINF_SUCCESS;
+
+    for (;;)
     {
         BOOL fExtDispSup = TRUE;
         /* Wait for a display change event. */
         VBoxGuestWaitEventInfo waitEvent;
-        waitEvent.u32TimeoutIn = 1000;
+        waitEvent.u32TimeoutIn   = 1000;
         waitEvent.u32EventMaskIn = VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST | VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED;
         if (DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
@@ -750 +787 @@
 
             /* are we supposed to stop? */
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 0) == WAIT_OBJECT_0)
+            if (*pfShutdown)
                 break;
 
@@ -847 +884 @@
                                      displayChangeRequest.cyOrigin,
                                      displayChangeRequest.fChangeOrigin));
-                                if (!ResizeDisplayDevice(displayChangeRequest.display,
+                                if (!ResizeDisplayDevice(pCtx,
+                                                         displayChangeRequest.display,
                                                          displayChangeRequest.xres,
                                                          displayChangeRequest.yres,
@@ -855 +893 @@
                                                          displayChangeRequest.cyOrigin,
                                                          displayChangeRequest.fChangeOrigin,
-                                                         pCtx,
                                                          fExtDispSup
                                                          ))
@@ -922 +959 @@
 
                                     LogFlowFunc(("setting new mode %d x %d, %d BPP\n",
-                                         devMode.dmPelsWidth, devMode.dmPelsHeight, devMode.dmBitsPerPel));
+                                                 devMode.dmPelsWidth, devMode.dmPelsHeight, devMode.dmBitsPerPel));
 
                                     /* set the new mode */
@@ -955 +992 @@
 
                         /* Retry the change a bit later. */
-                        /* are we supposed to stop? */
-                        if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 1000) == WAIT_OBJECT_0)
-                        {
-                            fTerminate = true;
-                            break;
-                        }
+                        RTThreadSleep(1000);
                     }
                 }
                 else
                 {
-                    LogFlowFunc(("error from DeviceIoControl VBOXGUEST_IOCTL_VMMREQUEST\n"));
                     /* sleep a bit to not eat too much CPU while retrying */
-                    /* are we supposed to stop? */
-                    if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 50) == WAIT_OBJECT_0)
-                    {
-                        fTerminate = true;
-                        break;
-                    }
+                    RTThreadSleep(50);
                 }
             }
+
+            /* are we supposed to stop? */
+            if (*pfShutdown)
+                break;
+
             if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_MOUSE_CAPABILITIES_CHANGED)
                 hlpReloadCursor();
@@ -980 +1011 @@
         else
         {
-#ifndef DEBUG_andy /* Too noisy for me. */
-            LogFlowFunc(("error 0 from DeviceIoControl VBOXGUEST_IOCTL_WAITEVENT\n"));
-#endif
             /* sleep a bit to not eat too much CPU in case the above call always fails */
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 10) == WAIT_OBJECT_0)
-            {
-                fTerminate = true;
+            RTThreadSleep(10);
+
+            if (*pfShutdown)
                 break;
-            }
-        }
-    } while (!fTerminate);
+        }
+    }
 
     /*
@@ -999 +1026 @@
     if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
         LogFlowFunc(("DeviceIOControl(CtlMask - not) failed\n"));
-    PostMessage(ghwndToolWindow, WM_VBOX_GRAPHICS_UNSUPPORTED, 0, 0);
-
-    LogFlowFunc(("finished display change request thread\n"));
-    return 0;
+    PostMessage(g_hwndToolWindow, WM_VBOX_GRAPHICS_UNSUPPORTED, 0, 0);
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
+
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescDisplay =
+{
+    /* pszName. */
+    "display",
+    /* pszDescription. */
+    "Display Notifications",
+    /* methods */
+    VBoxDisplayInit,
+    VBoxDisplayWorker,
+    NULL /* pfnStop */,
+    VBoxDisplayDestroy
+};
+

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2010 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19 +19 @@
 #define __VBOXSERVICEDISPLAY__H
 
-/* The display service prototypes. */
-int                VBoxDisplayInit    (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-unsigned __stdcall VBoxDisplayThread  (void *pInstance);
-void               VBoxDisplayDestroy (const VBOXSERVICEENV *pEnv, void *pInstance);
+DWORD VBoxDisplayGetCount();
+DWORD VBoxDisplayGetConfig(const DWORD NumDevices, DWORD *pDevPrimaryNum, DWORD *pNumDevices, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes);
 
-DWORD VBoxGetDisplayConfigCount();
-DWORD VBoxGetDisplayConfig(const DWORD NumDevices, DWORD *pDevPrimaryNum, DWORD *pNumDevices, DISPLAY_DEVICE *paDisplayDevices, DEVMODE *paDeviceModes);
+DWORD EnableAndResizeDispDev(DEVMODE *paDeviceModes, DISPLAY_DEVICE *paDisplayDevices, DWORD totalDispNum, UINT Id, DWORD aWidth, DWORD aHeight,
+                             DWORD aBitsPerPixel, LONG aPosX, LONG aPosY, BOOL fEnabled, BOOL fExtDispSup);
 
 #ifndef VBOX_WITH_WDDM
-static bool isVBoxDisplayDriverActive (void);
+static bool isVBoxDisplayDriverActive(void);
 #else
 /* @misha: getVBoxDisplayDriverType is used instead.

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

@@ -48 +48 @@
 #endif
 
+/** The drag and drop window's window class. */
+#define VBOX_DND_WND_CLASS            "VBoxTrayDnDWnd"
+
 /** @todo Merge this with messages from VBoxTray.h. */
 #define WM_VBOXTRAY_DND_MESSAGE       WM_APP + 401
@@ -62 +65 @@
 static LRESULT CALLBACK vboxDnDWndProcInstance(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 static LRESULT CALLBACK vboxDnDWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+
+static VBOXDNDCONTEXT g_Ctx = { 0 };
 
 VBoxDnDWnd::VBoxDnDWnd(void)
@@ -97 +102 @@
  * @param   pContext                Pointer to context to use.
  */
-int VBoxDnDWnd::Initialize(PVBOXDNDCONTEXT pContext)
-{
-    AssertPtrReturn(pContext, VERR_INVALID_POINTER);
+int VBoxDnDWnd::Initialize(PVBOXDNDCONTEXT pCtx)
+{
+    AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
 
     /* Save the context. */
-    this->pContext = pContext;
+    this->pCtx = pCtx;
 
     int rc = RTSemEventCreate(&mEventSem);
@@ -113 +118 @@
         rc = RTThreadCreate(&hThread, VBoxDnDWnd::Thread, this,
                             0, RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
-                            "VBoxTrayDnDWnd");
+                            "dndwnd"); /** @todo Include ID if there's more than one proxy window. */
         if (RT_SUCCESS(rc))
             rc = RTThreadUserWait(hThread, 30 * 1000 /* Timeout in ms */);
@@ -128 +133 @@
  * Destroys the proxy window and releases all remaining
  * resources again.
- *
  */
 void VBoxDnDWnd::Destroy(void)
@@ -144 +148 @@
     RTCritSectDelete(&mCritSect);
     if (mEventSem != NIL_RTSEMEVENT)
+    {
         RTSemEventDestroy(mEventSem);
+        mEventSem = NIL_RTSEMEVENT;
+    }
+
+    if (pCtx->wndClass != 0)
+    {
+        UnregisterClass(VBOX_DND_WND_CLASS, pCtx->pEnv->hInstance);
+        pCtx->wndClass = 0;
+    }
 
     LogFlowFuncLeave();
@@ -162 +175 @@
     AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
 
+    LogFlowFuncEnter();
+
     VBoxDnDWnd *pThis = (VBoxDnDWnd*)pvUser;
     AssertPtr(pThis);
 
-    PVBOXDNDCONTEXT pContext = pThis->pContext;
-    AssertPtr(pContext);
-    AssertPtr(pContext->pEnv);
-
-    HINSTANCE hInstance = pContext->pEnv->hInstance;
+    PVBOXDNDCONTEXT pCtx = pThis->pCtx;
+    AssertPtr(pCtx);
+    AssertPtr(pCtx->pEnv);
+
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pCtx->pEnv);
+    HINSTANCE hInstance = pCtx->pEnv->hInstance;
     Assert(hInstance != 0);
 
     /* Create our proxy window. */
-    WNDCLASSEX wndClass;
-    RT_ZERO(wndClass);
-
-    wndClass.cbSize        = sizeof(WNDCLASSEX);
-    wndClass.lpfnWndProc   = vboxDnDWndProc;
-    wndClass.lpszClassName = "VBoxTrayDnDWnd";
-    wndClass.hInstance     = hInstance;
-    wndClass.style         = CS_NOCLOSE;
+    WNDCLASSEX wc = { 0 };
+    wc.cbSize     = sizeof(WNDCLASSEX);
+
+    if (!GetClassInfoEx(hInstance, VBOX_DND_WND_CLASS, &wc))
+    {
+        wc.lpfnWndProc   = vboxDnDWndProc;
+        wc.lpszClassName = VBOX_DND_WND_CLASS;
+        wc.hInstance     = hInstance;
+        wc.style         = CS_NOCLOSE;
 #ifdef VBOX_DND_DEBUG_WND
-    wndClass.style        |= CS_HREDRAW | CS_VREDRAW;
-    wndClass.hbrBackground = (HBRUSH)(CreateSolidBrush(RGB(255, 0, 0)));
+        wc.style        |= CS_HREDRAW | CS_VREDRAW;
+        wc.hbrBackground = (HBRUSH)(CreateSolidBrush(RGB(255, 0, 0)));
 #else
-    wndClass.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
-#endif
-
-    bool fSignalled = false; /* Thread signalled? */
-
-    int rc = VINF_SUCCESS;
-    if (!RegisterClassEx(&wndClass))
-    {
-        DWORD dwErr = GetLastError();
-        LogFlowFunc(("Unable to register proxy window class, error=%ld\n", dwErr));
-        rc = RTErrConvertFromWin32(dwErr);
+        wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
+#endif
+        if (!RegisterClassEx(&wc))
+        {
+            DWORD dwErr = GetLastError();
+            LogFlowFunc(("Unable to register proxy window class, error=%ld\n", dwErr));
+            rc = RTErrConvertFromWin32(dwErr);
+        }
     }
 
@@ -208 +224 @@
         pThis->hWnd =
             CreateWindowEx(dwExStyle,
-                           "VBoxTrayDnDWnd", "VBoxTrayDnDWnd",
+                           VBOX_DND_WND_CLASS, VBOX_DND_WND_CLASS,
                            dwStyle,
 #ifdef VBOX_DND_DEBUG_WND
@@ -251 +267 @@
 #ifdef VBOX_WITH_DRAG_AND_DROP_GH
         rc = pThis->RegisterAsDropTarget();
+#else
+        rc = VINF_SUCCESS;
 #endif
     }
@@ -259 +277 @@
     }
 
+    bool fSignalled = false;
+
     if (RT_SUCCESS(rc))
     {
@@ -265 +285 @@
 
         bool fShutdown = false;
-        while (RT_SUCCESS(rc))
+        for (;;)
         {
             MSG uMsg;
@@ -274 +294 @@
             }
 
-            if (ASMAtomicReadBool(&pContext->fShutdown))
+            if (ASMAtomicReadBool(&pCtx->fShutdown))
                 fShutdown = true;
 
             if (fShutdown)
             {
-                LogFlowFunc(("Cancelling ...\n"));
+                LogFlowFunc(("Closing proxy window ...\n"));
                 break;
             }
@@ -356 +376 @@
         }
 
-        case WM_CLOSE:
-        {
-            OnDestroy();
-
-            DestroyWindow(hWnd);
+        case WM_QUIT:
+        {
+            LogFlowThisFunc(("WM_QUIT\n"));
             PostQuitMessage(0);
             return 0;
         }
 
+        case WM_DESTROY:
+        {
+            LogFlowThisFunc(("WM_DESTROY\n"));
+
+            OnDestroy();
+            return 0;
+        }
+
         case WM_LBUTTONDOWN:
+        {
             LogFlowThisFunc(("WM_LBUTTONDOWN\n"));
             mfMouseButtonDown = true;
             return 0;
+        }
 
         case WM_LBUTTONUP:
+        {
             LogFlowThisFunc(("WM_LBUTTONUP\n"));
             mfMouseButtonDown = false;
@@ -381 +410 @@
             reset();
             return 0;
+        }
 
         case WM_MOUSELEAVE:
+        {
             LogFlowThisFunc(("WM_MOUSELEAVE\n"));
             return 0;
+        }
 
         /* Will only be called once; after the first mouse move, this
@@ -642 +674 @@
     {
         pDropTarget = new VBoxDnDDropTarget(this /* pParent */);
-        AssertPtr(pDropTarget);
         HRESULT hr = CoLockObjectExternal(pDropTarget, TRUE /* fLock */,
                                           FALSE /* fLastUnlockReleases */);
@@ -706 +737 @@
 int VBoxDnDWnd::OnCreate(void)
 {
+    LogFlowFuncEnter();
     int rc = VbglR3DnDConnect(&mDnDCtx);
     if (RT_FAILURE(rc))
@@ -722 +754 @@
 void VBoxDnDWnd::OnDestroy(void)
 {
+    DestroyWindow(hWnd);
+
     VbglR3DnDDisconnect(&mDnDCtx);
     LogFlowThisFuncLeave();
@@ -812 +846 @@
                     }
                     else /* Should never happen. */
-                        AssertReleaseFailedBreak(("Format specification for '%s' not implemented\n", pszFormat));
+                        AssertReleaseMsgFailedBreak(("Format specification for '%s' not implemented\n", pszFormat));
                     break;
                 }
@@ -940 +974 @@
     /* Post ESC to our window to officially abort the
      * drag and drop operation. */
-    PostMessage(hWnd, WM_KEYDOWN, VK_ESCAPE, 0 /* lParam */);
+    this->PostMessage(WM_KEYDOWN, VK_ESCAPE /* wParam */, 0 /* lParam */);
 
     LogFlowFuncLeaveRC(rc);
@@ -1196 +1230 @@
             {
                 case VERR_ACCESS_DENIED:
-                    rc = hlpShowBalloonTip(ghInstance, ghwndToolWindow, ID_TRAYICON,
+                    rc = hlpShowBalloonTip(g_hInstance, g_hwndToolWindow, ID_TRAYICON,
                                            szMsg, szTitle,
                                            15 * 1000 /* Time to display in msec */, NIIF_INFO);
@@ -1270 +1304 @@
 #endif /* VBOX_WITH_DRAG_AND_DROP_GH */
 
+void VBoxDnDWnd::PostMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    LogFlowFunc(("Posting message %u\n"));
+    BOOL fRc = ::PostMessage(hWnd, uMsg, wParam, lParam);
+    Assert(fRc);
+}
+
 /**
  * Injects a DnD event in this proxy window's Windows
@@ -1282 +1323 @@
     AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
 
-    BOOL fRc = PostMessage(hWnd, WM_VBOXTRAY_DND_MESSAGE,
-                           0 /* wParm */, (LPARAM)pEvent /* lParm */);
+    BOOL fRc = ::PostMessage(hWnd, WM_VBOXTRAY_DND_MESSAGE,
+                             0 /* wParm */, (LPARAM)pEvent /* lParm */);
     if (!fRc)
     {
+        DWORD dwErr = GetLastError();
+
         static int s_iBitchedAboutFailedDnDMessages = 0;
         if (s_iBitchedAboutFailedDnDMessages++ < 32)
         {
-            DWORD dwErr = GetLastError();
-            LogRel(("DnD: Processing event %p failed with %ld (%Rrc), skpping\n",
+            LogRel(("DnD: Processing event %p failed with %ld (%Rrc), skipping\n",
                     pEvent, dwErr, RTErrConvertFromWin32(dwErr)));
         }
@@ -1297 +1339 @@
         pEvent = NULL;
 
-        return VERR_NO_MEMORY;
+        return RTErrConvertFromWin32(dwErr);
     }
 
@@ -1561 +1603 @@
  * @param   pfStartThread               Pointer to flag whether the DnD service can be started or not.
  */
-int VBoxDnDInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
+DECLCALLBACK(int) VBoxDnDInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
 {
     AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
-    /** ppInstance not used here. */
-    AssertPtrReturn(pfStartThread, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppInstance, VERR_INVALID_POINTER);
 
     LogFlowFuncEnter();
 
-    *pfStartThread = false;
-
-    PVBOXDNDCONTEXT pCtx = &gCtx;
+    PVBOXDNDCONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
+    AssertPtr(pCtx);
 
     int rc;
     bool fSupportedOS = true;
 
-    s_pfnSendInput = (PFNSENDINPUT)
-        RTLdrGetSystemSymbol("User32.dll", "SendInput");
-    fSupportedOS = !RT_BOOL(s_pfnSendInput == NULL);
-    s_pfnEnumDisplayMonitors = (PFNENUMDISPLAYMONITORS)
-        RTLdrGetSystemSymbol("User32.dll", "EnumDisplayMonitors");
-    /* g_pfnEnumDisplayMonitors is optional. */
-
-    if (!fSupportedOS)
-    {
-        LogRel(("DnD: Not supported Windows version, disabling drag and drop support\n"));
+    if (VbglR3AutoLogonIsRemoteSession())
+    {
+        /* Do not do drag and drop for remote sessions. */
+        LogRel(("DnD: Drag and drop has been disabled for a remote session\n"));
         rc = VERR_NOT_SUPPORTED;
     }
     else
         rc = VINF_SUCCESS;
+
+    if (RT_SUCCESS(rc))
+    {
+        s_pfnSendInput = (PFNSENDINPUT)
+            RTLdrGetSystemSymbol("User32.dll", "SendInput");
+        fSupportedOS = !RT_BOOL(s_pfnSendInput == NULL);
+        s_pfnEnumDisplayMonitors = (PFNENUMDISPLAYMONITORS)
+            RTLdrGetSystemSymbol("User32.dll", "EnumDisplayMonitors");
+        /* g_pfnEnumDisplayMonitors is optional. */
+
+        if (!fSupportedOS)
+        {
+            LogRel(("DnD: Not supported Windows version, disabling drag and drop support\n"));
+            rc = VERR_NOT_SUPPORTED;
+        }
+    }
 
     if (RT_SUCCESS(rc))
@@ -1619 +1669 @@
     {
         *ppInstance = pCtx;
-        *pfStartThread = true;
 
         LogRel(("DnD: Drag and drop service successfully started\n"));
-        return VINF_SUCCESS;
-    }
-
-    LogRel(("DnD: Initializing drag and drop service failed with rc=%Rrc\n", rc));
+    }
+    else
+        LogRel(("DnD: Initializing drag and drop service failed with rc=%Rrc\n", rc));
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
 
-void VBoxDnDStop(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    AssertPtrReturnVoid(pEnv);
-    AssertPtrReturnVoid(pInstance);
+DECLCALLBACK(int) VBoxDnDStop(void *pInstance)
+{
+    AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
 
     LogFunc(("Stopping pInstance=%p\n", pInstance));
@@ -1641 +1690 @@
     /* Set shutdown indicator. */
     ASMAtomicWriteBool(&pCtx->fShutdown, true);
-}
-
-void VBoxDnDDestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    AssertPtr(pEnv);
-    AssertPtr(pInstance);
+
+    /* Disconnect. */
+    VbglR3DnDDisconnect(&pCtx->cmdCtx);
+
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
+    return VINF_SUCCESS;
+}
+
+DECLCALLBACK(void) VBoxDnDDestroy(void *pInstance)
+{
+    AssertPtrReturnVoid(pInstance);
 
     LogFunc(("Destroying pInstance=%p\n", pInstance));
@@ -1659 +1713 @@
     VBoxDnDWnd *pWnd = pCtx->lstWnd.first();
     if (pWnd)
+    {
         delete pWnd;
+        pWnd = NULL;
+    }
 
     if (pCtx->hEvtQueueSem != NIL_RTSEMEVENT)
         RTSemEventDestroy(pCtx->hEvtQueueSem);
 
-    LogFunc(("Destroyed pInstance=%p, rc=%Rrc\n",
-             pInstance, rc));
-}
-
-unsigned __stdcall VBoxDnDThread(void *pInstance)
-{
+    LogFunc(("Destroyed pInstance=%p, rc=%Rrc\n", pInstance, rc));
+}
+
+DECLCALLBACK(int) VBoxDnDWorker(void *pInstance, bool volatile *pfShutdown)
+{
+    AssertPtr(pInstance);
     LogFlowFunc(("pInstance=%p\n", pInstance));
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
 
     PVBOXDNDCONTEXT pCtx = (PVBOXDNDCONTEXT)pInstance;
     AssertPtr(pCtx);
 
-    VBGLR3GUESTDNDCMDCTX ctxDnD; /* The thread's own DnD context. */
-
-    int rc = VbglR3DnDConnect(&ctxDnD);
+    int rc = VbglR3DnDConnect(&pCtx->cmdCtx);
     if (RT_FAILURE(rc))
         return rc;
@@ -1688 +1749 @@
     /* Number of invalid messages skipped in a row. */
     int cMsgSkippedInvalid = 0;
-
-    do
-    {
-        PVBOXDNDEVENT pEvent = (PVBOXDNDEVENT)RTMemAlloc(sizeof(VBOXDNDEVENT));
+    PVBOXDNDEVENT pEvent = NULL;
+
+    for (;;)
+    {
+        pEvent = (PVBOXDNDEVENT)RTMemAllocZ(sizeof(VBOXDNDEVENT));
         if (!pEvent)
         {
@@ -1699 +1761 @@
         /* Note: pEvent will be free'd by the consumer later. */
 
-        rc = VbglR3DnDProcessNextMessage(&ctxDnD, &pEvent->Event);
+        rc = VbglR3DnDProcessNextMessage(&pCtx->cmdCtx, &pEvent->Event);
         LogFlowFunc(("VbglR3DnDProcessNextMessage returned uType=%RU32, rc=%Rrc\n",
                      pEvent->Event.uType, rc));
 
-        if (ASMAtomicReadBool(&pCtx->fShutdown))
-            break;
-
         if (   RT_SUCCESS(rc)
-            || rc == VERR_CANCELLED)
+            /* Cancelled from host. */
+            || rc == VERR_CANCELLED
+            )
         {
             cMsgSkippedInvalid = 0; /* Reset skipped messages count. */
 
-            LogFlowFunc(("Received new event, type=%RU32\n", pEvent->Event.uType));
-
-            int rc2 = pWnd->ProcessEvent(pEvent);
-            if (RT_FAILURE(rc2))
-                LogFlowFunc(("Processing event failed with rc=%Rrc\n", rc2));
+            LogFlowFunc(("Received new event, type=%RU32, rc=%Rrc\n", pEvent->Event.uType, rc));
+
+            rc = pWnd->ProcessEvent(pEvent);
+            if (RT_SUCCESS(rc))
+            {
+                /* Event was consumed and the proxy window till take care of the memory -- NULL it. */
+                pEvent = NULL;
+            }
+            else
+                LogFlowFunc(("Processing event failed with rc=%Rrc\n", rc));
+        }
+        else if (rc == VERR_INTERRUPTED) /* Disconnected from service. */
+        {
+            LogFlowFunc(("Posting quit message ...\n"));
+            pWnd->PostMessage(WM_QUIT, 0 /* wParm */, 0 /* lParm */);
+            rc = VINF_SUCCESS;
         }
         else
@@ -1732 +1804 @@
             }
 
-            int rc2 = VbglR3DnDGHSendError(&ctxDnD, rc);
+            int rc2 = VbglR3DnDGHSendError(&pCtx->cmdCtx, rc);
             AssertRC(rc2);
         }
@@ -1741 +1813 @@
         if (RT_FAILURE(rc)) /* Don't hog the CPU on errors. */
             RTThreadSleep(1000 /* ms */);
-
-    } while (true);
+    }
+
+    if (pEvent)
+    {
+        RTMemFree(pEvent);
+        pEvent = NULL;
+    }
 
     LogFlowFunc(("Shutting down ...\n"));
 
-    VbglR3DnDDisconnect(&ctxDnD);
+    VbglR3DnDDisconnect(&pCtx->cmdCtx);
 
     LogFlowFuncLeaveRC(rc);
@@ -1752 +1829 @@
 }
 
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescDnD =
+{
+    /* pszName. */
+    "draganddrop",
+    /* pszDescription. */
+    "Drag and Drop",
+    /* methods */
+    VBoxDnDInit,
+    VBoxDnDWorker,
+    VBoxDnDStop,
+    VBoxDnDDestroy
+};
+

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

@@ -23 +23 @@
 #include <iprt/cpp/mtlist.h>
 #include <iprt/cpp/ministring.h>
-
-int                VBoxDnDInit    (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-unsigned __stdcall VBoxDnDThread  (void *pInstance);
-void               VBoxDnDStop    (const VBOXSERVICEENV *pEnv, void *pInstance);
-void               VBoxDnDDestroy (const VBOXSERVICEENV *pEnv, void *pInstance);
 
 class VBoxDnDWnd;
@@ -225 +220 @@
     /** Shutdown indicator. */
     bool                       fShutdown;
+    /** The registered window class. */
+    ATOM                       wndClass;
     /** The DnD main event queue. */
     RTCMTList<VBOXDNDEVENT>    lstEvtQueue;
@@ -233 +230 @@
      *  Note: At the moment only one window is supported. */
     RTCMTList<VBoxDnDWnd*>     lstWnd;
+    /** The DnD command context. */
+    VBGLR3GUESTDNDCMDCTX       cmdCtx;
 
 } VBOXDNDCONTEXT, *PVBOXDNDCONTEXT;
-static VBOXDNDCONTEXT gCtx = {0};
 
 /**
@@ -335 +333 @@
 #endif
 
+    void PostMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
     int ProcessEvent(PVBOXDNDEVENT pEvent);
 
@@ -352 +351 @@
 
     /** Pointer to DnD context. */
-    PVBOXDNDCONTEXT            pContext;
+    PVBOXDNDCONTEXT            pCtx;
     /** The proxy window's main thread for processing
      *  window messages. */

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

@@ -6 +6 @@
 
 /*
- * Copyright (C) 2010-2014 Oracle Corporation
+ * Copyright (C) 2010-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -33 +33 @@
 /** @todo Move this part in VbglR3 and just provide a callback for the platform-specific
           notification stuff, since this is very similar to the VBoxClient code. */
-int VBoxCheckHostVersion()
+int VBoxCheckHostVersion(void)
 {
     int rc;
@@ -58 +58 @@
                                                 "install option from the Devices menu.", pszGuestVersion, pszHostVersion);
 
-                rc = hlpShowBalloonTip(ghInstance, ghwndToolWindow, ID_TRAYICON,
+                rc = hlpShowBalloonTip(g_hInstance, g_hwndToolWindow, ID_TRAYICON,
                                        szMsg, szTitle,
                                        5000 /* Time to display in msec */, NIIF_INFO);

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

@@ -7 +7 @@
 
 /*
- * Copyright (C) 2010-2014 Oracle Corporation
+ * Copyright (C) 2010-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -58 +58 @@
 
 } VBOXIPCCONTEXT, *PVBOXIPCCONTEXT;
-static VBOXIPCCONTEXT gCtx = {0};
+
+static VBOXIPCCONTEXT g_Ctx = { 0 };
 
 /** Function pointer for GetLastInputInfo(). */
@@ -108 +109 @@
     {
         /* Showing the balloon tooltip is not critical. */
-        int rc2 = hlpShowBalloonTip(ghInstance, ghwndToolWindow, ID_TRAYICON,
+        int rc2 = hlpShowBalloonTip(g_hInstance, g_hwndToolWindow, ID_TRAYICON,
                                     ipcMsg.szMsgContent, ipcMsg.szMsgTitle,
                                     ipcMsg.uShowMS, ipcMsg.uType);
@@ -163 +164 @@
  * @return  IPRT status code.
  * @param   pEnv                        The IPC service's environment.
- * @param   ppInstance                  The instance pointer which refer to this object.
- * @param   pfStartThread               Pointer to flag whether the IPC service can be started or not.
- */
-int VBoxIPCInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
+ * @param   ppInstance                  The instance pointer which refers to this object.
+ */
+DECLCALLBACK(int) VBoxIPCInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
 {
     AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
-    /** ppInstance not used here. */
-    AssertPtrReturn(pfStartThread, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppInstance, VERR_INVALID_POINTER);
 
     LogFlowFuncEnter();
 
-    *pfStartThread = false;
-
-    int rc = RTCritSectInit(&gCtx.CritSect);
+    PVBOXIPCCONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
+    AssertPtr(pCtx);
+
+    int rc = RTCritSectInit(&pCtx->CritSect);
     if (RT_SUCCESS(rc))
     {
@@ -195 +195 @@
                                 VBOXTRAY_IPC_PIPE_PREFIX, pszUserName))
                 {
-                    rc = RTLocalIpcServerCreate(&gCtx.hServer, szPipeName,
+                    rc = RTLocalIpcServerCreate(&pCtx->hServer, szPipeName,
                                                 RTLOCALIPC_FLAGS_MULTI_SESSION);
                     if (RT_SUCCESS(rc))
@@ -201 +201 @@
                         RTStrFree(pszUserName);
 
-                        gCtx.pEnv = pEnv;
-                        RTListInit(&gCtx.SessionList);
-
-                        *ppInstance = &gCtx;
-                        *pfStartThread = true;
-
-                        /* GetLastInputInfo only is available starting at Windows 2000. */
+                        pCtx->pEnv = pEnv;
+                        RTListInit(&pCtx->SessionList);
+
+                        *ppInstance = pCtx;
+
+                        /* GetLastInputInfo only is available starting at Windows 2000 -- might fail. */
                         s_pfnGetLastInputInfo = (PFNGETLASTINPUTINFO)
                             RTLdrGetSystemSymbol("User32.dll", "GetLastInputInfo");
 
-                        LogRelFunc(("Local IPC server now running at \"%s\"\n",
-                                    szPipeName));
+                        LogRelFunc(("Local IPC server now running at \"%s\"\n", szPipeName));
                         return VINF_SUCCESS;
                     }
@@ -224 +222 @@
         }
 
-        RTCritSectDelete(&gCtx.CritSect);
+        RTCritSectDelete(&pCtx->CritSect);
     }
 
@@ -231 +229 @@
 }
 
-void VBoxIPCStop(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    AssertPtrReturnVoid(pEnv);
+DECLCALLBACK(void) VBoxIPCStop(void *pInstance)
+{
     AssertPtrReturnVoid(pInstance);
 
@@ -267 +264 @@
 }
 
-void VBoxIPCDestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    AssertPtrReturnVoid(pEnv);
+DECLCALLBACK(void) VBoxIPCDestroy(void *pInstance)
+{
     AssertPtrReturnVoid(pInstance);
 
@@ -476 +472 @@
         if (pSession)
         {
-            pSession->pCtx = pCtx;
-            pSession->hSession = hSession;
+            pSession->pCtx      = pCtx;
+            pSession->hSession   = hSession;
             pSession->fTerminate = false;
-            pSession->hThread = NIL_RTTHREAD;
+            pSession->hThread    = NIL_RTTHREAD;
 
             /* Start IPC session thread. */
@@ -485 +481 @@
             rc = RTThreadCreate(&pSession->hThread, vboxIPCSessionThread,
                                 pSession /* pvUser */, 0 /* Default stack size */,
-                                RTTHREADTYPE_DEFAULT, 0 /* Flags */, "VBXTRYIPCSESS");
+                                RTTHREADTYPE_DEFAULT, 0 /* Flags */, "IPCSESSION");
             if (RT_SUCCESS(rc))
             {
@@ -529 +525 @@
  * requests
  */
-unsigned __stdcall VBoxIPCThread(void *pInstance)
-{
+DECLCALLBACK(int) VBoxIPCWorker(void *pInstance, bool volatile *pfShutdown)
+{
+    AssertPtr(pInstance);
+    LogFlowFunc(("pInstance=%p\n", pInstance));
+
     LogFlowFuncEnter();
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
 
     PVBOXIPCCONTEXT pCtx = (PVBOXIPCCONTEXT)pInstance;
     AssertPtr(pCtx);
 
+    int rc;
+
     bool fShutdown = false;
     for (;;)
     {
         RTLOCALIPCSESSION hClientSession = NIL_RTLOCALIPCSESSION;
-        int rc = RTLocalIpcServerListen(pCtx->hServer, &hClientSession);
+        rc = RTLocalIpcServerListen(pCtx->hServer, &hClientSession);
         if (RT_FAILURE(rc))
         {
@@ -561 +568 @@
         }
 
-        AssertPtr(pCtx->pEnv);
-        if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 0 /* No waiting */) == WAIT_OBJECT_0)
+        if (*pfShutdown)
             break;
     }
 
-    LogFlowFuncLeave();
-    return 0;
-}
-
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescIPC =
+{
+    /* pszName. */
+    "IPC",
+    /* pszDescription. */
+    "Inter-Process Communication",
+    /* methods */
+    VBoxIPCInit,
+    VBoxIPCWorker,
+    NULL /* pfnStop */,
+    VBoxIPCDestroy
+};
+

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

@@ -22 +22 @@
 
 int                VBoxIPCInit    (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-unsigned __stdcall VBoxIPCThread  (void *pInstance);
+unsigned __stdcall VBoxIPCWorker  (void *pInstance);
 void               VBoxIPCStop    (const VBOXSERVICEENV *pEnv, void *pInstance);
 void               VBoxIPCDestroy (const VBOXSERVICEENV *pEnv, void *pInstance);

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2014 Oracle Corporation
+ * Copyright (C) 2014-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -54 +54 @@
 
 
-struct VBOXLACONTEXT
+typedef struct _VBOXLACONTEXT
 {
     const VBOXSERVICEENV *pEnv;
@@ -92 +92 @@
 
     BOOL (WINAPI * pfnProcessIdToSessionId)(DWORD dwProcessId, DWORD *pSessionId);
-};
-
-typedef struct ACTIONENTRY
+} VBOXLACONTEXT, *PVBOXLACONTEXT;
+
+typedef struct _ACTIONENTRY
 {
     RTLISTNODE nodeActionEntry;
     uint32_t u32Index;
     WCHAR wszCommandLine[1];
-} ACTIONENTRY;
-
-
-static VBOXLACONTEXT gCtx = {0};
+} ACTIONENTRY, *PACTIONENTRY;
+
+
+static VBOXLACONTEXT g_Ctx = { 0 };
 
 static const char *g_pszPropActiveClient = "/VirtualBox/HostInfo/VRDP/ActiveClient";
@@ -407 +407 @@
 }
 
-static BOOL GetVolatileEnvironmentKey(WCHAR *pwszRegKey, DWORD cbRegKey)
+static BOOL GetVolatileEnvironmentKey(PVBOXLACONTEXT pCtx, WCHAR *pwszRegKey, DWORD cbRegKey)
 {
     BOOL fFound = FALSE;
@@ -417 +417 @@
 
     /* Attempt to open HKCU\Volatile Environment\<session ID> first. */
-    if (   gCtx.pfnProcessIdToSessionId != NULL
-        && gCtx.pfnProcessIdToSessionId(GetCurrentProcessId(), &nSessionID))
+    if (   pCtx->pfnProcessIdToSessionId
+        && pCtx->pfnProcessIdToSessionId(GetCurrentProcessId(), &nSessionID))
     {
         RTStrPrintf(szRegKey, sizeof(szRegKey),
@@ -485 +485 @@
 }
 
-static BOOL GetUtcInfoClientName(WCHAR *pwszClientName, DWORD cbClientName)
+static BOOL laGetUtcInfoClientName(PVBOXLACONTEXT pCtx, WCHAR *pwszClientName, DWORD cbClientName)
 {
     LONG lErr;
 
     WCHAR wszRegKey[REG_KEY_LEN];
-    if (!GetVolatileEnvironmentKey(wszRegKey, sizeof(wszRegKey)))
+    if (!GetVolatileEnvironmentKey(pCtx, wszRegKey, sizeof(wszRegKey)))
     {
         return FALSE;
@@ -561 +561 @@
 }
 
-static BOOL SetClientName(const WCHAR *pwszClientName)
+static BOOL laSetClientName(PVBOXLACONTEXT pCtx, const WCHAR *pwszClientName)
 {
     LONG lErr;
 
     WCHAR wszRegKey[REG_KEY_LEN];
-    if (!GetVolatileEnvironmentKey(wszRegKey, sizeof(wszRegKey)))
+    if (!GetVolatileEnvironmentKey(pCtx, wszRegKey, sizeof(wszRegKey)))
     {
         return FALSE;
@@ -613 +613 @@
                             &dwResult) == 0)
     {
-        LogFlowFunc(("SendMessageTimeout failed, error %d\n", GetLastError()));
-    }
-}
-
-static void laUpdateClientName(VBOXLACONTEXT *pCtx)
+        LogFlowFunc(("SendMessageTimeout failed, error %ld\n", GetLastError()));
+    }
+}
+
+static void laUpdateClientName(PVBOXLACONTEXT pCtx)
 {
     WCHAR wszUtcInfoClientName[MAX_CLIENT_NAME_CHARS];
 
-    if (GetUtcInfoClientName(wszUtcInfoClientName, sizeof(wszUtcInfoClientName)))
-    {
-        if (SetClientName(wszUtcInfoClientName))
-        {
+    if (laGetUtcInfoClientName(pCtx, wszUtcInfoClientName, sizeof(wszUtcInfoClientName)))
+    {
+        if (laSetClientName(pCtx, wszUtcInfoClientName))
             laBroadcastSettingChange();
-        }
-    }
-}
-
-static void laOnClientLocationInfo(char *pszClientInfo[][2])
+    }
+}
+
+static void laOnClientLocationInfo(PVBOXLACONTEXT pCtx, char *pszClientInfo[][2])
 {
     /*
@@ -642 +640 @@
     unsigned int idx;
     WCHAR wszRegKey[REG_KEY_LEN];
-    if (!GetVolatileEnvironmentKey(wszRegKey, sizeof(wszRegKey)))
+    if (!GetVolatileEnvironmentKey(pCtx, wszRegKey, sizeof(wszRegKey)))
     {
         LogFlowFunc(("Failed to get 'Volatile Environment' registry key\n"));
@@ -660 +658 @@
     if (lRet != ERROR_SUCCESS)
     {
-        LogFlowFunc(("Failed to open key [%ls], error %lu\n",
-               wszRegKey, lRet));
+        LogFlowFunc(("Failed to open key [%ls], error %lu\n", wszRegKey, lRet));
         return;
     }
@@ -716 +713 @@
 }
 
-static void laDoAttach(VBOXLACONTEXT *pCtx)
+static void laDoAttach(PVBOXLACONTEXT pCtx)
 {
     LogFlowFunc(("laDoAttach\n"));
@@ -727 +724 @@
 }
 
-static void laDoDetach(VBOXLACONTEXT *pCtx)
+static void laDoDetach(PVBOXLACONTEXT pCtx)
 {
     LogFlowFunc(("laDoDetach\n"));
@@ -836 +833 @@
 
         if (rc != VERR_BUFFER_OVERFLOW)
-        {
             break;
-        }
 
         cbBuf += 1024;
@@ -877 +872 @@
 
     if (pszValue)
-    {
         RTMemFree(pszValue);
-    }
-
-    LogFlowFunc(("laGetUint32: rc = %Rrc, [%s]\n",
-           rc, pszName));
-
+
+    LogFlowFunc(("laGetUint32: rc = %Rrc, [%s]\n", rc, pszName));
     return rc;
 }
@@ -894 +885 @@
                            ppszValue);
 
-    LogFlowFunc(("laGetString: rc = %Rrc, [%s]\n",
-           rc, pszName));
-
+    LogFlowFunc(("laGetString: rc = %Rrc, [%s]\n", rc, pszName));
     return rc;
 }
 
-static int laGetActiveClient(VBOXLACONTEXT *pCtx, uint64_t *pu64Timestamp, uint32_t *pu32Value)
+static int laGetActiveClient(PVBOXLACONTEXT pCtx, uint64_t *pu64Timestamp, uint32_t *pu32Value)
 {
     int rc = laGetUint32(pCtx->u32GuestPropHandle,
@@ -907 +896 @@
                          pu32Value);
 
-    LogFlowFunc(("laGetActiveClient: rc %Rrc, %d, %lld\n", rc, *pu32Value, *pu64Timestamp));
-
+    LogFlowFunc(("laGetActiveClient: rc %Rrc, %RU32, %RU64\n", rc, *pu32Value, *pu64Timestamp));
     return rc;
 }
 
-static int laUpdateCurrentState(VBOXLACONTEXT *pCtx, uint32_t u32ActiveClientId, uint64_t u64ActiveClientTS)
+static int laUpdateCurrentState(PVBOXLACONTEXT pCtx, uint32_t u32ActiveClientId, uint64_t u64ActiveClientTS)
 {
     /* Prepare the current state for the active client.
      * If u32ActiveClientId is 0, then there is no connected clients.
      */
-    LogFlowFunc(("laUpdateCurrentState: %u %lld\n",
-            u32ActiveClientId, u64ActiveClientTS));
+    LogFlowFunc(("laUpdateCurrentState: %RU32 %RU64\n", u32ActiveClientId, u64ActiveClientTS));
 
     int rc = VINF_SUCCESS;
@@ -1019 +1006 @@
     }
 
-    LogFlowFunc(("laUpdateCurrentState rc = %Rrc\n",
-           rc));
-
+    LogFlowFunc(("laUpdateCurrentState rc = %Rrc\n", rc));
     return rc;
 }
 
-static int laWait(VBOXLACONTEXT *pCtx, uint64_t *pu64Timestamp, uint32_t u32Timeout)
-{
-    LogFlowFunc(("laWait [%s]\n",
-           pCtx->activeClient.pszPropWaitPattern));
+static int laWait(PVBOXLACONTEXT pCtx, uint64_t *pu64Timestamp, uint32_t u32Timeout)
+{
+    LogFlowFunc(("laWait [%s]\n", pCtx->activeClient.pszPropWaitPattern));
 
     int rc = laWaitProperties(pCtx->u32GuestPropHandle,
@@ -1036 +1020 @@
                               u32Timeout);
 
-    LogFlowFunc(("laWait rc %Rrc\n",
-           rc));
-
+    LogFlowFunc(("laWait rc %Rrc\n", rc));
     return rc;
 }
 
-static void laProcessClientInfo(VBOXLACONTEXT *pCtx)
+static void laProcessClientInfo(PVBOXLACONTEXT pCtx)
 {
     /* Check if the name was changed. */
@@ -1066 +1048 @@
                          &pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE]);
 
-         LogFlowFunc(("laProcessClientInfo: read [%s], at %lld\n",
-                pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE], u64Timestamp));
+         LogFlowFunc(("laProcessClientInfo: read [%s], at %RU64\n",
+                      pClientInfoMap[idx][LA_UTCINFO_PROP_VALUE], u64Timestamp));
 
         if (RT_FAILURE(rc))
@@ -1080 +1062 @@
         if (u64Timestamp != pCtx->activeClient.u64LastNameTimestamp)
         {
-            laOnClientLocationInfo(pClientInfoMap);
+            laOnClientLocationInfo(pCtx, pClientInfoMap);
 
             pCtx->activeClient.u64LastNameTimestamp = u64Timestamp;
@@ -1095 +1077 @@
 }
 
-static void laProcessAttach(VBOXLACONTEXT *pCtx)
+static void laProcessAttach(PVBOXLACONTEXT pCtx)
 {
     /* Check if the attach was changed. */
@@ -1110 +1092 @@
     if (RT_SUCCESS(rc))
     {
-        LogFlowFunc(("laProcessAttach: read %d, at %lld\n",
-               u32Attach, u64Timestamp));
-
+        LogFlowFunc(("laProcessAttach: read %RU32, at %RU64\n", u32Attach, u64Timestamp));
         if (u64Timestamp != pCtx->activeClient.u64LastAttachTimestamp)
         {
@@ -1120 +1100 @@
 
                 /* Just do the last action. */
-                pCtx->u32Action = u32Attach?
-                                       LA_DO_ATTACH:
-                                       LA_DO_DETACH;
+                pCtx->u32Action = u32Attach
+                                ? LA_DO_ATTACH : LA_DO_DETACH;
 
                 pCtx->activeClient.u32LastAttach = u32Attach;
@@ -1133 +1112 @@
                  * which means that it was changed and restored.
                  */
-                pCtx->u32Action = u32Attach?
-                                       LA_DO_DETACH_AND_ATTACH:
-                                       LA_DO_ATTACH_AND_DETACH;
+                pCtx->u32Action = u32Attach
+                                ? LA_DO_DETACH_AND_ATTACH : LA_DO_ATTACH_AND_DETACH;
             }
 
@@ -1143 +1121 @@
     }
 
-    LogFlowFunc(("laProcessAttach: action %d\n",
-           pCtx->u32Action));
-}
-
-static void laDoActions(VBOXLACONTEXT *pCtx)
-{
-    /* Check if the attach was changed.
+    LogFlowFunc(("laProcessAttach: action %RU32\n", pCtx->u32Action));
+}
+
+static void laDoActions(PVBOXLACONTEXT pCtx)
+{
+    /*
+     * Check if the attach was changed.
      *
      * Caller assumes that this function will filter double actions.
      * That is two or more LA_DO_ATTACH will do just one LA_DO_ATTACH.
      */
-    LogFlowFunc(("laDoActions: action %d, prev %d\n",
-           pCtx->u32Action, pCtx->u32PrevAction));
+    LogFlowFunc(("laDoActions: action %RU32, prev %RU32\n", pCtx->u32Action, pCtx->u32PrevAction));
 
     switch(pCtx->u32Action)
@@ -1209 +1186 @@
 }
 
-int VBoxLAInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
-{
-    gCtx.pEnv = pEnv;
+DECLCALLBACK(int) VBoxLAInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
+{
+    AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppInstance, VERR_INVALID_POINTER);
+
+    LogFlowFuncEnter();
+
+    PVBOXLACONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
+    AssertPtr(pCtx);
+
+    pCtx->pEnv = pEnv;
 
     DWORD dwValue = 0;
@@ -1217 +1202 @@
         && (dwValue & 0x10) != 0)
     {
-         gCtx.fLogEnabled = true;
+         pCtx->fLogEnabled = true;
     }
     else
     {
-         gCtx.fLogEnabled = false;
-    }
-
-    LogFlowFunc(("\n"));
+         pCtx->fLogEnabled = false;
+    }
 
     /* DetachOnDisconnect is enabled by default. */
@@ -1231 +1214 @@
         && (dwValue & 0x02) == 0)
     {
-         gCtx.fDetachOnDisconnect = false;
+         pCtx->fDetachOnDisconnect = false;
     }
     else
     {
-         gCtx.fDetachOnDisconnect = true;
-    }
-
-    LogRel(("LA: DetachOnDisconnect=%RTbool\n", gCtx.fDetachOnDisconnect));
-
-    int rc = VbglR3GuestPropConnect(&gCtx.u32GuestPropHandle);
+         pCtx->fDetachOnDisconnect = true;
+    }
+
+    LogRel(("LA: DetachOnDisconnect=%RTbool\n", pCtx->fDetachOnDisconnect));
+
+    int rc = VbglR3GuestPropConnect(&pCtx->u32GuestPropHandle);
     if (RT_FAILURE(rc))
-    {
         return rc;
-    }
-
-    RTListInit(&gCtx.listAttachActions);
-    RTListInit(&gCtx.listDetachActions);
-
-    RT_ZERO(gCtx.activeClient);
-
-    *(void **)&gCtx.pfnProcessIdToSessionId = RTLdrGetSystemSymbol("kernel32.dll", "ProcessIdToSessionId");
-    *pfStartThread = true;
-    *ppInstance = &gCtx;
+
+    RTListInit(&pCtx->listAttachActions);
+    RTListInit(&pCtx->listDetachActions);
+
+    RT_ZERO(pCtx->activeClient);
+
+    *(void **)&pCtx->pfnProcessIdToSessionId = RTLdrGetSystemSymbol("kernel32.dll", "ProcessIdToSessionId");
+
+    *ppInstance = pCtx;
+    LogFlowFuncLeaveRC(VINF_SUCCESS);
     return VINF_SUCCESS;
 }
 
-
-void VBoxLADestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    LogFlowFuncEnter();
-
-    VBOXLACONTEXT *pCtx = (VBOXLACONTEXT *)pInstance;
+DECLCALLBACK(void) VBoxLADestroy(void *pInstance)
+{
+    AssertPtrReturnVoid(pInstance);
+
+    LogFlowFunc(("Destroying pInstance=%p\n", pInstance));
+
+    PVBOXLACONTEXT pCtx = (PVBOXLACONTEXT)pInstance;
+    AssertPtr(pCtx);
 
     if (pCtx->u32GuestPropHandle != 0)
@@ -1278 +1262 @@
  * Thread function to wait for and process property changes
  */
-unsigned __stdcall VBoxLAThread(void *pInstance)
-{
-    VBOXLACONTEXT *pCtx = (VBOXLACONTEXT *)pInstance;
-
-    LogFlowFunc(("Started\n"));
+DECLCALLBACK(int) VBoxLAWorker(void *pInstance, bool volatile *pfShutdown)
+{
+    AssertPtr(pInstance);
+    LogFlowFunc(("pInstance=%p\n", pInstance));
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
+
+    PVBOXLACONTEXT pCtx = (PVBOXLACONTEXT)pInstance;
 
     /*
@@ -1295 +1286 @@
      */
 
-    if (!ActionExecutorEnumerateRegistryKey(g_pwszRegKeyReconnectActions, &gCtx.listAttachActions))
+    if (!ActionExecutorEnumerateRegistryKey(g_pwszRegKeyReconnectActions, &pCtx->listAttachActions))
     {
         LogFlowFunc(("Can't enumerate registry key %ls\n", g_pwszRegKeyReconnectActions));
     }
-    if (!ActionExecutorEnumerateRegistryKey(g_pwszRegKeyDisconnectActions, &gCtx.listDetachActions))
+    if (!ActionExecutorEnumerateRegistryKey(g_pwszRegKeyDisconnectActions, &pCtx->listDetachActions))
     {
         LogFlowFunc(("Can't enumerate registry key %ls\n", g_pwszRegKeyDisconnectActions));
@@ -1308 +1299 @@
     /* Start at Detached state. */
     pCtx->u32PrevAction = LA_DO_DETACH;
+
+    int rc;
 
     for (;;)
@@ -1323 +1316 @@
         uint64_t u64Timestamp = 0;
         uint32_t u32ActiveClientId = 0;
-        int rc = laGetActiveClient(pCtx, &u64Timestamp, &u32ActiveClientId);
+        rc = laGetActiveClient(pCtx, &u64Timestamp, &u32ActiveClientId);
 
         if (RT_SUCCESS(rc))
@@ -1357 +1350 @@
                         && fClientIdChanged)
                     {
-                        LogFlowFunc(("client disconnected\n"));
+                        LogFlowFunc(("Client disconnected\n"));
 
                         /* laDoActions will prevent a repeated detach action. So if there
@@ -1372 +1365 @@
         }
 
-        /* Check if it is time to exit.
+        /*
+         * Check if it is time to exit.
          * If the code above failed, wait a bit until repeating to avoid a loop.
          * Otherwise just check if the stop event was signalled.
          */
-        uint32_t u32Wait;
+        RTMSINTERVAL msWait;
         if (   rc == VERR_NOT_FOUND
             || pCtx->activeClient.u32ClientId == 0)
         {
             /* No connections, wait longer. */
-            u32Wait = 5000;
+            msWait = 5000;
+            rc = VINF_SUCCESS;
         }
         else if (RT_FAILURE(rc))
         {
-            u32Wait = 1000;
+            static int s_iBitchedAboutFailedGetActiveClient = 0;
+            if (s_iBitchedAboutFailedGetActiveClient++ < 32)
+                LogRel(("LA: Retrieving current client(s) failed with %Rrc\n", rc));
+
+            msWait = 10000;
         }
         else
-        {
-            u32Wait = 0;
-        }
-        if (WaitForSingleObject(pCtx->pEnv->hStopEvent, u32Wait) == WAIT_OBJECT_0)
-        {
+            msWait = 0;
+
+        if (*pfShutdown)
             break;
-        }
-    }
-
-    LogFlowFunc(("Finished\n"));
-    return 0;
-}
+
+        if (msWait)
+            RTThreadSleep(msWait);
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescLA =
+{
+    /* pszName. */
+    "LA",
+    /* pszDescription. */
+    "Location Awareness",
+    /* methods */
+    VBoxLAInit,
+    VBoxLAWorker,
+    NULL /* pfnStop */,
+    VBoxLADestroy
+};
+

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2012 Oracle Corporation
+ * Copyright (C) 2012-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19 +19 @@
 #define __VBOXSERVICELA__H
 
-int                VBoxLAInit    (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-unsigned __stdcall VBoxLAThread  (void *pInstance);
-void               VBoxLADestroy (const VBOXSERVICEENV *pEnv, void *pInstance);
+#endif /* __VBOXSERVICELA__H */
 
-#endif /* __VBOXSERVICELA__H */

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2014 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -49 +49 @@
 
     PVBOXDISPIFESCAPE lpEscapeData;
-} VBOXSEAMLESSCONTEXT;
+} VBOXSEAMLESSCONTEXT, *PVBOXSEAMLESSCONTEXT;
 
 typedef struct
@@ -57 +57 @@
 } VBOX_ENUM_PARAM, *PVBOX_ENUM_PARAM;
 
-static VBOXSEAMLESSCONTEXT gCtx = {0};
+static VBOXSEAMLESSCONTEXT g_Ctx = { 0 };
 
 void VBoxLogString(HANDLE hDriver, char *pszStr);
 
-int VBoxSeamlessInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
-{
-    Log(("VBoxTray: VBoxSeamlessInit\n"));
-
-    *pfStartThread = false;
-    gCtx.pEnv = pEnv;
-    gCtx.hModHook = NIL_RTLDRMOD;
+DECLCALLBACK(int) VBoxSeamlessInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
+{
+    LogFlowFuncEnter();
+
+    PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
+    AssertPtr(pCtx);
+
+    pCtx->pEnv     = pEnv;
+    pCtx->hModHook = NIL_RTLDRMOD;
 
     OSVERSIONINFO OSinfo;
@@ -73 +75 @@
     GetVersionEx (&OSinfo);
 
-    int rc = VINF_SUCCESS;
+    int rc;
 
     /* We have to jump out here when using NT4, otherwise it complains about
@@ -85 +87 @@
     {
         /* Will fail if SetWinEventHook is not present (version < NT4 SP6 apparently) */
-        rc = RTLdrLoadAppPriv(VBOXHOOK_DLL_NAME, &gCtx.hModHook);
+        rc = RTLdrLoadAppPriv(VBOXHOOK_DLL_NAME, &pCtx->hModHook);
         if (RT_SUCCESS(rc))
         {
-            *(PFNRT *)&gCtx.pfnVBoxHookInstallWindowTracker = RTLdrGetFunction(gCtx.hModHook, "VBoxHookInstallWindowTracker");
-            *(PFNRT *)&gCtx.pfnVBoxHookRemoveWindowTracker  = RTLdrGetFunction(gCtx.hModHook, "VBoxHookRemoveWindowTracker");
+            *(PFNRT *)&pCtx->pfnVBoxHookInstallWindowTracker = RTLdrGetFunction(pCtx->hModHook, "VBoxHookInstallWindowTracker");
+            *(PFNRT *)&pCtx->pfnVBoxHookRemoveWindowTracker  = RTLdrGetFunction(pCtx->hModHook, "VBoxHookRemoveWindowTracker");
 
             /* rc should contain success status */
-            AssertRC(rc);
+            AssertRC(rc); /** @todo r=andy Makes no sense here!? */
 
             VBoxSeamlessSetSupported(TRUE);
 
-//            if (RT_SUCCESS(rc))
-            {
-                *pfStartThread = true;
-                *ppInstance = &gCtx;
-            }
+            *ppInstance = pCtx;
         }
         else
-            Log(("VBoxTray: VBoxSeamlessInit: LoadLibrary of \"%s\" failed with rc=%Rrc\n", VBOXHOOK_DLL_NAME, rc));
-    }
-
+            LogFlowFunc(("Unable to load %s, rc=%Rrc\n", VBOXHOOK_DLL_NAME, rc));
+    }
+
+    LogFlowFuncLeaveRC(rc);
     return rc;
 }
 
-
-void VBoxSeamlessDestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    Log(("VBoxTray: VBoxSeamlessDestroy\n"));
+void VBoxSeamlessDestroy(void *pInstance)
+{
+    LogFlowFuncEnter();
+
+    PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance;
+    AssertPtr(pCtx);
 
     VBoxSeamlessSetSupported(FALSE);
 
     /* Inform the host that we no longer support the seamless window mode. */
-    if (gCtx.pfnVBoxHookRemoveWindowTracker)
-        gCtx.pfnVBoxHookRemoveWindowTracker();
-    if (gCtx.hModHook != NIL_RTLDRMOD)
-    {
-        RTLdrClose(gCtx.hModHook);
-        gCtx.hModHook = NIL_RTLDRMOD;
+    if (pCtx->pfnVBoxHookRemoveWindowTracker)
+        pCtx->pfnVBoxHookRemoveWindowTracker();
+    if (pCtx->hModHook != NIL_RTLDRMOD)
+    {
+        RTLdrClose(pCtx->hModHook);
+        pCtx->hModHook = NIL_RTLDRMOD;
     }
     return;
 }
 
-static void VBoxSeamlessInstallHook()
-{
-    if (gCtx.pfnVBoxHookInstallWindowTracker)
+static void VBoxSeamlessInstallHook(void)
+{
+    PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /** @todo r=andy Use instance data via service lookup (add void *pInstance). */
+    AssertPtr(pCtx);
+
+    if (pCtx->pfnVBoxHookInstallWindowTracker)
     {
         /* Check current visible region state */
         VBoxSeamlessCheckWindows(true);
 
-        HMODULE hMod = (HMODULE)RTLdrGetNativeHandle(gCtx.hModHook);
+        HMODULE hMod = (HMODULE)RTLdrGetNativeHandle(pCtx->hModHook);
         Assert(hMod != (HMODULE)~(uintptr_t)0);
-        gCtx.pfnVBoxHookInstallWindowTracker(hMod);
-    }
-}
-
-static void VBoxSeamlessRemoveHook()
-{
-    if (gCtx.pfnVBoxHookRemoveWindowTracker)
-        gCtx.pfnVBoxHookRemoveWindowTracker();
-
-    if (gCtx.lpEscapeData)
-    {
-        free(gCtx.lpEscapeData);
-        gCtx.lpEscapeData = NULL;
-    }
-}
-
-extern HANDLE ghSeamlessKmNotifyEvent;
-
-static VBOXDISPIF_SEAMLESS gVBoxDispIfSeamless;
-
-
-void VBoxSeamlessEnable()
-{
-    Assert(ghSeamlessKmNotifyEvent);
-
-    VBoxDispIfSeamlesCreate(&gCtx.pEnv->dispIf, &gVBoxDispIfSeamless, ghSeamlessKmNotifyEvent);
+        pCtx->pfnVBoxHookInstallWindowTracker(hMod);
+    }
+}
+
+static void VBoxSeamlessRemoveHook(void)
+{
+    PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /** @todo r=andy Use instance data via service lookup (add void *pInstance). */
+    AssertPtr(pCtx);
+
+    if (pCtx->pfnVBoxHookRemoveWindowTracker)
+        pCtx->pfnVBoxHookRemoveWindowTracker();
+
+    if (pCtx->lpEscapeData)
+    {
+        free(pCtx->lpEscapeData);
+        pCtx->lpEscapeData = NULL;
+    }
+}
+
+extern HANDLE g_hSeamlessKmNotifyEvent;
+
+static VBOXDISPIF_SEAMLESS gVBoxDispIfSeamless; /** @todo r=andy Move this into VBOXSEAMLESSCONTEXT? */
+
+
+void VBoxSeamlessEnable(void)
+{
+    PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /** @todo r=andy Use instance data via service lookup (add void *pInstance). */
+    AssertPtr(pCtx);
+
+    Assert(g_hSeamlessKmNotifyEvent);
+
+    VBoxDispIfSeamlessCreate(&pCtx->pEnv->dispIf, &gVBoxDispIfSeamless, g_hSeamlessKmNotifyEvent);
 
     VBoxSeamlessInstallHook();
 }
 
-void VBoxSeamlessDisable()
-{
+void VBoxSeamlessDisable(void)
+{
+    PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /** @todo r=andy Use instance data via service lookup (add void *pInstance). */
+    AssertPtr(pCtx);
+    NOREF(pCtx);
+
     VBoxSeamlessRemoveHook();
 
-    VBoxDispIfSeamlesTerm(&gVBoxDispIfSeamless);
+    VBoxDispIfSeamlessTerm(&gVBoxDispIfSeamless);
 }
 
@@ -279 +293 @@
 void VBoxSeamlessCheckWindows(bool fForce)
 {
+    PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /** @todo r=andy Use instance data via service lookup (add void *pInstance). */
+    AssertPtr(pCtx);
+
     if (!VBoxDispIfSeamlesIsValid(&gVBoxDispIfSeamless))
         return;
@@ -314 +331 @@
                     }
 #endif
-                    LPRGNDATA lpCtxRgnData = VBOXDISPIFESCAPE_DATA(gCtx.lpEscapeData, RGNDATA);
+                    LPRGNDATA lpCtxRgnData = VBOXDISPIFESCAPE_DATA(pCtx->lpEscapeData, RGNDATA);
                     if (fForce
-                        ||  !gCtx.lpEscapeData
+                        ||  !pCtx->lpEscapeData
                         ||  (lpCtxRgnData->rdh.dwSize + lpCtxRgnData->rdh.nRgnSize != cbSize)
                         ||  memcmp(lpCtxRgnData, lpRgnData, cbSize))
                     {
                         /* send to display driver */
-                        VBoxDispIfSeamlesSubmit(&gVBoxDispIfSeamless, lpEscapeData, cbSize);
-
-                        if (gCtx.lpEscapeData)
-                            free(gCtx.lpEscapeData);
-                        gCtx.lpEscapeData = lpEscapeData;
+                        VBoxDispIfSeamlessSubmit(&gVBoxDispIfSeamless, lpEscapeData, cbSize);
+
+                        if (pCtx->lpEscapeData)
+                            free(pCtx->lpEscapeData);
+                        pCtx->lpEscapeData = lpEscapeData;
                     }
                     else
                         Log(("VBoxTray: Visible rectangles haven't changed; ignore\n"));
                 }
-                if (lpEscapeData != gCtx.lpEscapeData)
+                if (lpEscapeData != pCtx->lpEscapeData)
                     free(lpEscapeData);
             }
@@ -345 +362 @@
  * requests
  */
-unsigned __stdcall VBoxSeamlessThread(void *pInstance)
-{
-    VBOXSEAMLESSCONTEXT *pCtx = (VBOXSEAMLESSCONTEXT *)pInstance;
+static DECLCALLBACK(int) VBoxSeamlessWorker(void *pInstance, bool volatile *pfShutdown)
+{
+    AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
+    LogFlowFunc(("pInstance=%p\n", pInstance));
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
+
+    PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance;
+
     HANDLE gVBoxDriver = pCtx->pEnv->hDriver;
-    bool fTerminate = false;
     VBoxGuestFilterMaskInfo maskInfo;
     DWORD cbReturned;
-    BOOL fWasScreenSaverActive = FALSE, ret;
+    BOOL fWasScreenSaverActive = FALSE, fRet;
 
     maskInfo.u32OrMask = VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
     maskInfo.u32NotMask = 0;
-    if (DeviceIoControl (gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
-    {
-        Log(("VBoxTray: VBoxSeamlessThread: DeviceIOControl(CtlMask - or) succeeded\n"));
-    }
-    else
-    {
-        Log(("VBoxTray: VBoxSeamlessThread: DeviceIOControl(CtlMask) failed, SeamlessChangeThread exited\n"));
-        return 0;
-    }
-
-    do
+    if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
+    {
+        DWORD dwErr = GetLastError();
+        LogRel(("Seamless: DeviceIOControl(CtlMask) failed with %ld, exiting ...\n", dwErr));
+        return RTErrConvertFromWin32(dwErr);
+    }
+
+    int rc = VINF_SUCCESS;
+
+    for (;;)
     {
         /* wait for a seamless change event */
@@ -374 +399 @@
         if (DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
         {
-            Log(("VBoxTray: VBoxSeamlessThread: DeviceIOControl succeeded\n"));
-
             /* are we supposed to stop? */
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 0) == WAIT_OBJECT_0)
+            if (*pfShutdown)
                 break;
-
-            Log(("VBoxTray: VBoxSeamlessThread: checking event\n"));
 
             /* did we get the right event? */
             if (waitEvent.u32EventFlagsOut & VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST)
             {
-                Log(("VBoxTray: VBoxTray: going to get seamless change information\n"));
-
                 /* We got at least one event. Read the requested resolution
                  * and try to set it until success. New events will not be seen
@@ -402 +421 @@
                     if (fSeamlessChangeQueried)
                     {
-                        Log(("VBoxTray: VBoxSeamlessThread: mode change to %d\n", seamlessChangeRequest.mode));
+                        LogFlowFunc(("Mode changed to %d\n", seamlessChangeRequest.mode));
 
                         switch(seamlessChangeRequest.mode)
@@ -409 +428 @@
                             if (fWasScreenSaverActive)
                             {
-                                Log(("VBoxTray: Re-enabling the screensaver\n"));
-                                ret = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, NULL, 0);
-                                if (!ret)
-                                    Log(("VBoxTray: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %d\n", GetLastError()));
+                                LogRel(("Seamless: Re-enabling the screensaver\n"));
+                                fRet = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, TRUE, NULL, 0);
+                                if (!fRet)
+                                    LogRel(("Seamless: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
                             }
-                            PostMessage(ghwndToolWindow, WM_VBOX_SEAMLESS_DISABLE, 0, 0);
+                            PostMessage(g_hwndToolWindow, WM_VBOX_SEAMLESS_DISABLE, 0, 0);
                             break;
 
                         case VMMDev_Seamless_Visible_Region:
-                            ret = SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &fWasScreenSaverActive, 0);
-                            if (!ret)
-                                Log(("VBoxTray: SystemParametersInfo SPI_GETSCREENSAVEACTIVE failed with %d\n", GetLastError()));
+                            fRet = SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, &fWasScreenSaverActive, 0);
+                            if (!fRet)
+                                LogRel(("Seamless: SystemParametersInfo SPI_GETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
 
                             if (fWasScreenSaverActive)
-                                Log(("VBoxTray: Disabling the screensaver\n"));
-
-                            ret = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);
-                            if (!ret)
-                                Log(("VBoxTray: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %d\n", GetLastError()));
-                            PostMessage(ghwndToolWindow, WM_VBOX_SEAMLESS_ENABLE, 0, 0);
+                                LogRel(("Seamless: Disabling the screensaver\n"));
+
+                            fRet = SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE, NULL, 0);
+                            if (!fRet)
+                                LogRel(("Seamless: SystemParametersInfo SPI_SETSCREENSAVEACTIVE failed with %ld\n", GetLastError()));
+                            PostMessage(g_hwndToolWindow, WM_VBOX_SEAMLESS_ENABLE, 0, 0);
                             break;
 
@@ -441 +460 @@
                     }
                     else
-                    {
-                        Log(("VBoxTray: VBoxSeamlessThread: error from DeviceIoControl VBOXGUEST_IOCTL_VMMREQUEST\n"));
-                    }
+                        LogRel(("Seamless: DeviceIoControl(ChangeReq) failed with %ld\n", GetLastError()));
+
+                    if (*pfShutdown)
+                        break;
+
                     /* sleep a bit to not eat too much CPU while retrying */
-                    /* are we supposed to stop? */
-                    if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 50) == WAIT_OBJECT_0)
-                    {
-                        fTerminate = true;
-                        break;
-                    }
+                    RTThreadSleep(10);
                 }
             }
@@ -456 +472 @@
         else
         {
-            Log(("VBoxTray: VBoxTray: error 0 from DeviceIoControl VBOXGUEST_IOCTL_WAITEVENT\n"));
             /* sleep a bit to not eat too much CPU in case the above call always fails */
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 10) == WAIT_OBJECT_0)
-            {
-                fTerminate = true;
-                break;
-            }
-        }
-    }
-    while (!fTerminate);
+            RTThreadSleep(10);
+        }
+
+        if (*pfShutdown)
+            break;
+    }
 
     maskInfo.u32OrMask = 0;
     maskInfo.u32NotMask = VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
-    if (DeviceIoControl (gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
-    {
-        Log(("VBoxTray: VBoxSeamlessThread: DeviceIOControl(CtlMask - not) succeeded\n"));
-    }
-    else
-    {
-        Log(("VBoxTray: VBoxSeamlessThread: DeviceIOControl(CtlMask) failed\n"));
-    }
-
-    Log(("VBoxTray: VBoxSeamlessThread: finished seamless change request thread\n"));
-    return 0;
-}
-
+    if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
+        LogRel(("Seamless: DeviceIOControl(CtlMask) failed with %ld\n", GetLastError()));
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescSeamless =
+{
+    /* pszName. */
+    "seamless",
+    /* pszDescription. */
+    "Seamless Windows",
+    /* methods */
+    VBoxSeamlessInit,
+    VBoxSeamlessWorker,
+    NULL /* pfnStop */,
+    VBoxSeamlessDestroy
+};
+

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2010 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19 +19 @@
 #define __VBOXSERVICESEAMLESS__H
 
-/* The seamless windows service prototypes */
-int                VBoxSeamlessInit     (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-unsigned __stdcall VBoxSeamlessThread   (void *pInstance);
-void               VBoxSeamlessDestroy  (const VBOXSERVICEENV *pEnv, void *pInstance);
-
-
 void VBoxSeamlessEnable();
 void VBoxSeamlessDisable();
@@ -32 +26 @@
 
 #endif /* __VBOXSERVICESEAMLESS__H */
+

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2014 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -44 +44 @@
 #include <sddl.h>
 
+#include <iprt/asm.h>
 #include <iprt/buildconfig.h>
 #include <iprt/ldr.h>
@@ -137 +138 @@
 *   Global Variables                                                                                                             *
 *********************************************************************************************************************************/
-HANDLE                ghVBoxDriver;
-HANDLE                ghStopSem;
-HANDLE                ghSeamlessWtNotifyEvent = 0;
-HANDLE                ghSeamlessKmNotifyEvent = 0;
-SERVICE_STATUS        gVBoxServiceStatus;
-SERVICE_STATUS_HANDLE gVBoxServiceStatusHandle;
-HINSTANCE             ghInstance;
-HWND                  ghwndToolWindow;
-NOTIFYICONDATA        gNotifyIconData;
-DWORD                 gMajorVersion;
+HANDLE                g_hVBoxDriver;
+HANDLE                g_hStopSem;
+HANDLE                g_hSeamlessWtNotifyEvent = 0;
+HANDLE                g_hSeamlessKmNotifyEvent = 0;
+HINSTANCE             g_hInstance;
+HWND                  g_hwndToolWindow;
+NOTIFYICONDATA        g_NotifyIconData;
+DWORD                 g_dwMajorVersion;
 
 static PRTLOGGER      g_pLoggerRelease = NULL;
@@ -153 +152 @@
 static uint64_t       g_uHistoryFileSize = 100 * _1M;    /* Max 100MB per file. */
 
-/* The service table. */
-static VBOXSERVICEINFO vboxServiceTable[] =
-{
-    {
-        "Display",
-        VBoxDisplayInit,
-        VBoxDisplayThread,
-        NULL /* pfnStop */,
-        VBoxDisplayDestroy
-    },
-    {
-        "Shared Clipboard",
-        VBoxClipboardInit,
-        VBoxClipboardThread,
-        NULL /* pfnStop */,
-        VBoxClipboardDestroy
-    },
-    {
-        "Seamless Windows",
-        VBoxSeamlessInit,
-        VBoxSeamlessThread,
-        NULL /* pfnStop */,
-        VBoxSeamlessDestroy
-    },
-    {
-        "VRDP",
-        VBoxVRDPInit,
-        VBoxVRDPThread,
-        NULL /* pfnStop */,
-        VBoxVRDPDestroy
-    },
-    {
-        "IPC",
-        VBoxIPCInit,
-        VBoxIPCThread,
-        VBoxIPCStop,
-        VBoxIPCDestroy
-    },
-    {
-        "Location Awareness",
-        VBoxLAInit,
-        VBoxLAThread,
-        NULL /* pfnStop */,
-        VBoxLADestroy
-    },
+/**
+ * The details of the services that has been compiled in.
+ */
+static VBOXSERVICEINFO g_aServices[] =
+{
+    { &g_SvcDescDisplay,        NIL_RTTHREAD, NULL, false, false, false, false, true },
+    { &g_SvcDescClipboard,      NIL_RTTHREAD, NULL, false, false, false, false, true },
+    { &g_SvcDescSeamless,       NIL_RTTHREAD, NULL, false, false, false, false, true },
+    { &g_SvcDescVRDP,           NIL_RTTHREAD, NULL, false, false, false, false, true },
+    { &g_SvcDescIPC,            NIL_RTTHREAD, NULL, false, false, false, false, true },
+    { &g_SvcDescLA,             NIL_RTTHREAD, NULL, false, false, false, false, true },
 #ifdef VBOX_WITH_DRAG_AND_DROP
-    {
-        "Drag and Drop",
-        VBoxDnDInit,
-        VBoxDnDThread,
-        VBoxDnDStop,
-        VBoxDnDDestroy
-    },
+    { &g_SvcDescDnD,            NIL_RTTHREAD, NULL, false, false, false, false, true }
 #endif
-    {
-        NULL
-    }
 };
 
@@ -244 +200 @@
 static int vboxTrayCreateTrayIcon(void)
 {
-    HICON hIcon = LoadIcon(ghInstance, MAKEINTRESOURCE(IDI_VIRTUALBOX));
+    HICON hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_VIRTUALBOX));
     if (hIcon == NULL)
     {
         DWORD dwErr = GetLastError();
-        Log(("Could not load tray icon, error %08X\n", dwErr));
+        LogFunc(("Could not load tray icon, error %08X\n", dwErr));
         return RTErrConvertFromWin32(dwErr);
     }
 
     /* Prepare the system tray icon. */
-    RT_ZERO(gNotifyIconData);
-    gNotifyIconData.cbSize           = NOTIFYICONDATA_V1_SIZE; // sizeof(NOTIFYICONDATA);
-    gNotifyIconData.hWnd             = ghwndToolWindow;
-    gNotifyIconData.uID              = ID_TRAYICON;
-    gNotifyIconData.uFlags           = NIF_ICON | NIF_MESSAGE | NIF_TIP;
-    gNotifyIconData.uCallbackMessage = WM_VBOXTRAY_TRAY_ICON;
-    gNotifyIconData.hIcon            = hIcon;
-
-    sprintf(gNotifyIconData.szTip, "%s Guest Additions %d.%d.%dr%d",
+    RT_ZERO(g_NotifyIconData);
+    g_NotifyIconData.cbSize           = NOTIFYICONDATA_V1_SIZE; // sizeof(NOTIFYICONDATA);
+    g_NotifyIconData.hWnd             = g_hwndToolWindow;
+    g_NotifyIconData.uID              = ID_TRAYICON;
+    g_NotifyIconData.uFlags           = NIF_ICON | NIF_MESSAGE | NIF_TIP;
+    g_NotifyIconData.uCallbackMessage = WM_VBOXTRAY_TRAY_ICON;
+    g_NotifyIconData.hIcon            = hIcon;
+
+    sprintf(g_NotifyIconData.szTip, "%s Guest Additions %d.%d.%dr%d",
             VBOX_PRODUCT, VBOX_VERSION_MAJOR, VBOX_VERSION_MINOR, VBOX_VERSION_BUILD, VBOX_SVN_REV);
 
     int rc = VINF_SUCCESS;
-    if (!Shell_NotifyIcon(NIM_ADD, &gNotifyIconData))
+    if (!Shell_NotifyIcon(NIM_ADD, &g_NotifyIconData))
     {
         DWORD dwErr = GetLastError();
-        Log(("Could not create tray icon, error = %08X\n", dwErr));
+        LogFunc(("Could not create tray icon, error=%ld\n", dwErr));
         rc = RTErrConvertFromWin32(dwErr);
-        RT_ZERO(gNotifyIconData);
+        RT_ZERO(g_NotifyIconData);
     }
 
@@ -278 +234 @@
 }
 
-static void vboxTrayRemoveTrayIcon()
-{
-    if (gNotifyIconData.cbSize > 0)
+static void vboxTrayRemoveTrayIcon(void)
+{
+    if (g_NotifyIconData.cbSize > 0)
     {
         /* Remove the system tray icon and refresh system tray. */
-        Shell_NotifyIcon(NIM_DELETE, &gNotifyIconData);
+        Shell_NotifyIcon(NIM_DELETE, &g_NotifyIconData);
         HWND hTrayWnd = FindWindow("Shell_TrayWnd", NULL); /* We assume we only have one tray atm. */
         if (hTrayWnd)
@@ -291 +247 @@
                 SendMessage(hTrayNotifyWnd, WM_PAINT, 0, NULL);
         }
-        RT_ZERO(gNotifyIconData);
-    }
-}
-
-static int vboxTrayStartServices(VBOXSERVICEENV *pEnv, VBOXSERVICEINFO *pTable)
+        RT_ZERO(g_NotifyIconData);
+    }
+}
+
+/**
+ * The service thread.
+ *
+ * @returns Whatever the worker function returns.
+ * @param   ThreadSelf      My thread handle.
+ * @param   pvUser          The service index.
+ */
+static DECLCALLBACK(int) vboxTrayServiceThread(RTTHREAD ThreadSelf, void *pvUser)
+{
+    PVBOXSERVICEINFO pSvc = (PVBOXSERVICEINFO)pvUser;
+    AssertPtr(pSvc);
+
+#ifndef RT_OS_WINDOWS
+    /*
+     * Block all signals for this thread. Only the main thread will handle signals.
+     */
+    sigset_t signalMask;
+    sigfillset(&signalMask);
+    pthread_sigmask(SIG_BLOCK, &signalMask, NULL);
+#endif
+
+    int rc = pSvc->pDesc->pfnWorker(pSvc->pInstance, &pSvc->fShutdown);
+    ASMAtomicXchgBool(&pSvc->fShutdown, true);
+    RTThreadUserSignal(ThreadSelf);
+
+    LogFunc(("Worker for '%s' ended with %Rrc\n", pSvc->pDesc->pszName, rc));
+    return rc;
+}
+
+static int vboxTrayServicesStart(PVBOXSERVICEENV pEnv)
 {
     AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
-    AssertPtrReturn(pTable, VERR_INVALID_POINTER);
-
-    Log(("Starting services ...\n"));
-
-    /** @todo Use IPRT events here. */
-    pEnv->hStopEvent = CreateEvent(NULL, TRUE /* bManualReset */,
-                                   FALSE /* bInitialState */, NULL);
-
-    if (!pEnv->hStopEvent)
-    {
-        /* Could not create event. */
-        return VERR_NOT_SUPPORTED;
-    }
-
-    while (   pTable
-           && pTable->pszName)
-    {
-        Log(("Starting %s ...\n", pTable->pszName));
-
-        int rc = VINF_SUCCESS;
-
-        bool fStartThread = false;
-
-        pTable->hThread = (HANDLE)0;
-        pTable->pInstance = NULL;
-        pTable->fStarted = false;
-
-        if (pTable->pfnInit)
-            rc = pTable->pfnInit(pEnv, &pTable->pInstance, &fStartThread);
-
-        if (RT_FAILURE(rc))
-        {
-            LogRel(("Failed to initialize service \"%s\", rc=%Rrc\n",
-                    pTable->pszName, rc));
+
+    LogRel(("Starting services ...\n"));
+
+    int rc = VINF_SUCCESS;
+
+    for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
+    {
+        PVBOXSERVICEINFO pSvc = &g_aServices[i];
+        LogRel(("Starting service '%s' ...\n", pSvc->pDesc->pszName));
+
+        pSvc->hThread   = NIL_RTTHREAD;
+        pSvc->pInstance = NULL;
+        pSvc->fStarted  = false;
+        pSvc->fShutdown = false;
+
+        int rc2 = VINF_SUCCESS;
+
+        if (pSvc->pDesc->pfnInit)
+            rc2 = pSvc->pDesc->pfnInit(pEnv, &pSvc->pInstance);
+
+        if (RT_FAILURE(rc2))
+        {
+            LogRel(("Failed to initialize service '%s', rc=%Rrc\n", pSvc->pDesc->pszName, rc));
+            if (rc2 == VERR_NOT_SUPPORTED)
+            {
+                LogRel(("Service '%s' is not supported on this system\n", pSvc->pDesc->pszName));
+                rc2 = VINF_SUCCESS;
+            }
+            /* Keep going. */
         }
         else
         {
-            if (   pTable->pfnThread
-                && fStartThread)
-            {
-                unsigned threadid;
-                /** @todo Use RTThread* here. */
-                pTable->hThread = (HANDLE)_beginthreadex(NULL,  /* security */
-                                                         0,     /* stacksize */
-                                                         pTable->pfnThread,
-                                                         pTable->pInstance,
-                                                         0,     /* initflag */
-                                                         &threadid);
-                if (pTable->hThread == (HANDLE)(0))
-                    rc = VERR_NOT_SUPPORTED;
-            }
-
-            if (RT_SUCCESS(rc))
-                pTable->fStarted = true;
-            else
-            {
-                Log(("Failed to start the thread\n"));
-                if (pTable->pfnDestroy)
-                    pTable->pfnDestroy(pEnv, pTable->pInstance);
-            }
-        }
-
-        /* Advance to next table element. */
-        pTable++;
-    }
-
-    return VINF_SUCCESS;
-}
-
-static void vboxTrayStopServices(VBOXSERVICEENV *pEnv, VBOXSERVICEINFO *pTable)
-{
-    if (!pEnv->hStopEvent)
-        return;
-
-    /* Signal to all threads. */
-    SetEvent(pEnv->hStopEvent);
-
-    VBOXSERVICEINFO *pCurTable = pTable;
-    while (   pCurTable
-           && pCurTable->pszName)
-    {
-        if (pCurTable->pfnStop)
-            pCurTable->pfnStop(pEnv, pCurTable->pInstance);
-
-        /* Advance to next table element. */
-        pCurTable++;
-    }
-
-    pCurTable = pTable; /* Reset to first element. */
-    while (   pCurTable
-           && pCurTable->pszName)
-    {
-        if (pCurTable->fStarted)
-        {
-            if (pCurTable->pfnThread)
-            {
-                /* There is a thread, wait for termination. */
-                /** @todo Use RTThread* here. */
-                /** @todo Don't wait forever here. Use a sensible default. */
-                WaitForSingleObject(pCurTable->hThread, INFINITE);
-
-                /** @todo Dito. */
-                CloseHandle(pCurTable->hThread);
-                pCurTable->hThread = NULL;
-            }
-
-            if (pCurTable->pfnDestroy)
-                pCurTable->pfnDestroy(pEnv, pCurTable->pInstance);
-            pCurTable->fStarted = false;
-        }
-
-        /* Advance to next table element. */
-        pCurTable++;
-    }
-
-    CloseHandle(pEnv->hStopEvent);
+            if (pSvc->pDesc->pfnWorker)
+            {
+                rc2 = RTThreadCreate(&pSvc->hThread, vboxTrayServiceThread, pSvc /* pvUser */,
+                                     0 /* Default stack size */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, pSvc->pDesc->pszName);
+                if (RT_SUCCESS(rc2))
+                {
+                    pSvc->fStarted = true;
+
+                    RTThreadUserWait(pSvc->hThread, 30 * 1000 /* Timeout in ms */);
+                    if (pSvc->fShutdown)
+                    {
+                        LogRel(("Service '%s' failed to start!\n", pSvc->pDesc->pszName));
+                        rc = VERR_GENERAL_FAILURE;
+                    }
+                    else
+                        LogRel(("Service '%s' started\n", pSvc->pDesc->pszName));
+                }
+                else
+                {
+                    LogRel(("Failed to start thread for service '%s': %Rrc\n", rc2));
+                    if (pSvc->pDesc->pfnDestroy)
+                        pSvc->pDesc->pfnDestroy(pSvc->pInstance);
+                }
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+
+    if (RT_SUCCESS(rc))
+        LogRel(("All services started\n"));
+    else
+        LogRel(("Services started, but some with errors\n"));
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
+}
+
+static int vboxTrayServicesStop(VBOXSERVICEENV *pEnv)
+{
+    AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
+
+    LogRel2(("Stopping all services ...\n"));
+
+    /*
+     * Signal all the services.
+     */
+    for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
+        ASMAtomicWriteBool(&g_aServices[i].fShutdown, true);
+
+    /*
+     * Do the pfnStop callback on all running services.
+     */
+    for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
+    {
+        PVBOXSERVICEINFO pSvc = &g_aServices[i];
+        if (   pSvc->fStarted
+            && pSvc->pDesc->pfnStop)
+        {
+            LogRel2(("Calling stop function for service '%s' ...\n", pSvc->pDesc->pszName));
+            int rc2 = pSvc->pDesc->pfnStop(pSvc->pInstance);
+            if (RT_FAILURE(rc2))
+                LogRel(("Failed to stop service '%s': %Rrc\n", pSvc->pDesc->pszName, rc2));
+        }
+    }
+
+    LogRel2(("All stop functions for services called\n"));
+
+    int rc = VINF_SUCCESS;
+
+    /*
+     * Wait for all the service threads to complete.
+     */
+    for (unsigned i = 0; i < RT_ELEMENTS(g_aServices); i++)
+    {
+        PVBOXSERVICEINFO pSvc = &g_aServices[i];
+        if (!pSvc->fEnabled) /* Only stop services which were started before. */
+            continue;
+
+        if (pSvc->hThread != NIL_RTTHREAD)
+        {
+            LogRel2(("Waiting for service '%s' to stop ...\n", pSvc->pDesc->pszName));
+            int rc2 = VINF_SUCCESS;
+            for (int j = 0; j < 30; j++) /* Wait 30 seconds in total */
+            {
+                rc2 = RTThreadWait(pSvc->hThread, 1000 /* Wait 1 second */, NULL);
+                if (RT_SUCCESS(rc2))
+                    break;
+            }
+            if (RT_FAILURE(rc2))
+            {
+                LogRel(("Service '%s' failed to stop (%Rrc)\n", pSvc->pDesc->pszName, rc2));
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+            }
+        }
+
+        if (pSvc->pDesc->pfnDestroy)
+        {
+            LogRel2(("Terminating service '%s' ...\n", pSvc->pDesc->pszName));
+            pSvc->pDesc->pfnDestroy(pSvc->pInstance);
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+        LogRel(("All services stopped\n"));
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
@@ -463 +474 @@
     /* Open VBox guest driver. */
     DWORD dwErr = ERROR_SUCCESS;
-    ghVBoxDriver = CreateFile(VBOXGUEST_DEVICE_NAME,
+    g_hVBoxDriver = CreateFile(VBOXGUEST_DEVICE_NAME,
                              GENERIC_READ | GENERIC_WRITE,
                              FILE_SHARE_READ | FILE_SHARE_WRITE,
@@ -470 +481 @@
                              FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
                              NULL);
-    if (ghVBoxDriver == INVALID_HANDLE_VALUE)
+    if (g_hVBoxDriver == INVALID_HANDLE_VALUE)
     {
         dwErr = GetLastError();
@@ -480 +491 @@
 static void vboxTrayCloseBaseDriver(void)
 {
-    if (ghVBoxDriver)
-    {
-        CloseHandle(ghVBoxDriver);
-        ghVBoxDriver = NULL;
+    if (g_hVBoxDriver)
+    {
+        CloseHandle(g_hVBoxDriver);
+        g_hVBoxDriver = NULL;
     }
 }
@@ -612 +623 @@
 static void vboxTrayDestroyToolWindow(void)
 {
-    if (ghwndToolWindow)
+    if (g_hwndToolWindow)
     {
         Log(("Destroying tool window ...\n"));
 
         /* Destroy the tool window. */
-        DestroyWindow(ghwndToolWindow);
-        ghwndToolWindow = NULL;
-
-        UnregisterClass("VBoxTrayToolWndClass", ghInstance);
+        DestroyWindow(g_hwndToolWindow);
+        g_hwndToolWindow = NULL;
+
+        UnregisterClass("VBoxTrayToolWndClass", g_hInstance);
     }
 }
@@ -629 +640 @@
 
     /* Create a custom window class. */
-    WNDCLASS windowClass = {0};
-    windowClass.style         = CS_NOCLOSE;
-    windowClass.lpfnWndProc   = (WNDPROC)vboxToolWndProc;
-    windowClass.hInstance     = ghInstance;
-    windowClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
-    windowClass.lpszClassName = "VBoxTrayToolWndClass";
-    if (!RegisterClass(&windowClass))
+    WNDCLASSEX wc = { 0 };
+    wc.cbSize        = sizeof(WNDCLASSEX);
+    wc.style         = CS_NOCLOSE;
+    wc.lpfnWndProc   = (WNDPROC)vboxToolWndProc;
+    wc.hInstance     = g_hInstance;
+    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
+    wc.lpszClassName = "VBoxTrayToolWndClass";
+
+    if (!RegisterClassEx(&wc))
     {
         dwErr = GetLastError();
@@ -649 +662 @@
          *
          */
-        ghwndToolWindow = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_TOPMOST,
+        g_hwndToolWindow = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_TOPMOST,
                                          "VBoxTrayToolWndClass", "VBoxTrayToolWnd",
                                          WS_POPUPWINDOW,
-                                         -200, -200, 100, 100, NULL, NULL, ghInstance, NULL);
-        if (!ghwndToolWindow)
+                                         -200, -200, 100, 100, NULL, NULL, g_hInstance, NULL);
+        if (!g_hwndToolWindow)
         {
             dwErr = GetLastError();
@@ -663 +676 @@
             hlpReloadCursor();
 
-            Log(("Invisible tool window handle = %p\n", ghwndToolWindow));
+            Log(("Invisible tool window handle = %p\n", g_hwndToolWindow));
         }
     }
@@ -675 +688 @@
 {
     OSVERSIONINFO info;
-    gMajorVersion = 5; /* Default to Windows XP. */
+    g_dwMajorVersion = 5; /* Default to Windows XP. */
     info.dwOSVersionInfoSize = sizeof(info);
     if (GetVersionEx(&info))
     {
         Log(("Windows version %ld.%ld\n", info.dwMajorVersion, info.dwMinorVersion));
-        gMajorVersion = info.dwMajorVersion;
+        g_dwMajorVersion = info.dwMajorVersion;
     }
 
@@ -702 +715 @@
     {
         /* For Vista and up we need to change the integrity of the security descriptor, too. */
-        if (gMajorVersion >= 6)
+        if (g_dwMajorVersion >= 6)
         {
             BOOL (WINAPI * pfnConvertStringSecurityDescriptorToSecurityDescriptorA)(LPCSTR StringSecurityDescriptor, DWORD StringSDRevision, PSECURITY_DESCRIPTOR  *SecurityDescriptor, PULONG  SecurityDescriptorSize);
@@ -744 +757 @@
 
         if (   dwErr == ERROR_SUCCESS
-            && gMajorVersion >= 5) /* Only for W2K and up ... */
-        {
-            ghSeamlessWtNotifyEvent = CreateEvent(&SecAttr, FALSE, FALSE, VBOXHOOK_GLOBAL_WT_EVENT_NAME);
-            if (ghSeamlessWtNotifyEvent == NULL)
+            && g_dwMajorVersion >= 5) /* Only for W2K and up ... */
+        {
+            g_hSeamlessWtNotifyEvent = CreateEvent(&SecAttr, FALSE, FALSE, VBOXHOOK_GLOBAL_WT_EVENT_NAME);
+            if (g_hSeamlessWtNotifyEvent == NULL)
             {
                 dwErr = GetLastError();
@@ -753 +766 @@
             }
 
-            ghSeamlessKmNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-            if (ghSeamlessKmNotifyEvent == NULL)
+            g_hSeamlessKmNotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+            if (g_hSeamlessKmNotifyEvent == NULL)
             {
                 dwErr = GetLastError();
@@ -766 +779 @@
 static void vboxTrayShutdownSeamless(void)
 {
-    if (ghSeamlessWtNotifyEvent)
-    {
-        CloseHandle(ghSeamlessWtNotifyEvent);
-        ghSeamlessWtNotifyEvent = NULL;
-    }
-
-    if (ghSeamlessKmNotifyEvent)
-    {
-        CloseHandle(ghSeamlessKmNotifyEvent);
-        ghSeamlessKmNotifyEvent = NULL;
+    if (g_hSeamlessWtNotifyEvent)
+    {
+        CloseHandle(g_hSeamlessWtNotifyEvent);
+        g_hSeamlessWtNotifyEvent = NULL;
+    }
+
+    if (g_hSeamlessKmNotifyEvent)
+    {
+        CloseHandle(g_hSeamlessKmNotifyEvent);
+        g_hSeamlessKmNotifyEvent = NULL;
     }
 }
@@ -792 +805 @@
 {
     int rc = VINF_SUCCESS;
-    Log(("Entering vboxTrayServiceMain\n"));
-
-    ghStopSem = CreateEvent(NULL, TRUE, FALSE, NULL);
-    if (ghStopSem == NULL)
+    LogFunc(("Entering vboxTrayServiceMain\n"));
+
+    g_hStopSem = CreateEvent(NULL, TRUE, FALSE, NULL);
+    if (g_hStopSem == NULL)
     {
         rc = RTErrConvertFromWin32(GetLastError());
-        Log(("CreateEvent for stopping VBoxTray failed, rc=%Rrc\n", rc));
+        LogFunc(("CreateEvent for stopping VBoxTray failed, rc=%Rrc\n", rc));
     }
     else
@@ -806 +819 @@
          */
         VBOXSERVICEENV svcEnv;
-        svcEnv.hInstance = ghInstance;
-        svcEnv.hDriver   = ghVBoxDriver;
+        svcEnv.hInstance = g_hInstance;
+        svcEnv.hDriver   = g_hVBoxDriver;
 
         /* Initializes disp-if to default (XPDM) mode. */
@@ -819 +832 @@
 
         /* Finally start all the built-in services! */
-        rc = vboxTrayStartServices(&svcEnv, vboxServiceTable);
+        rc = vboxTrayServicesStart(&svcEnv);
         if (RT_FAILURE(rc))
         {
             /* Terminate service if something went wrong. */
-            vboxTrayStopServices(&svcEnv, vboxServiceTable);
+            vboxTrayServicesStop(&svcEnv);
         }
         else
@@ -829 +842 @@
             rc = vboxTrayCreateTrayIcon();
             if (   RT_SUCCESS(rc)
-                && gMajorVersion >= 5) /* Only for W2K and up ... */
+                && g_dwMajorVersion >= 5) /* Only for W2K and up ... */
             {
                 /* We're ready to create the tooltip balloon.
                    Check in 10 seconds (@todo make seconds configurable) ... */
-                SetTimer(ghwndToolWindow,
+                SetTimer(g_hwndToolWindow,
                          TIMERID_VBOXTRAY_CHECK_HOSTVERSION,
                          10 * 1000, /* 10 seconds */
@@ -864 +877 @@
                 DWORD dwEventCount = 0;
 
-                hWaitEvent[dwEventCount++] = ghStopSem;
+                hWaitEvent[dwEventCount++] = g_hStopSem;
 
                 /* Check if seamless mode is not active and add seamless event to the list */
-                if (0 != ghSeamlessWtNotifyEvent)
+                if (0 != g_hSeamlessWtNotifyEvent)
                 {
-                    hWaitEvent[dwEventCount++] = ghSeamlessWtNotifyEvent;
+                    hWaitEvent[dwEventCount++] = g_hSeamlessWtNotifyEvent;
                 }
 
-                if (0 != ghSeamlessKmNotifyEvent)
+                if (0 != g_hSeamlessKmNotifyEvent)
                 {
-                    hWaitEvent[dwEventCount++] = ghSeamlessKmNotifyEvent;
+                    hWaitEvent[dwEventCount++] = g_hSeamlessKmNotifyEvent;
                 }
 
@@ -882 +895 @@
                 }
 
-                Log(("Number of events to wait in main loop: %ld\n", dwEventCount));
+                LogFlowFunc(("Number of events to wait in main loop: %ld\n", dwEventCount));
                 while (true)
                 {
@@ -893 +906 @@
                     if (waitResult == 0)
                     {
-                        Log(("Event 'Exit' triggered\n"));
+                        LogFunc(("Event 'Exit' triggered\n"));
                         /* exit */
                         break;
@@ -904 +917 @@
                             if (hWaitEvent[waitResult])
                             {
-                                if (hWaitEvent[waitResult] == ghSeamlessWtNotifyEvent)
+                                if (hWaitEvent[waitResult] == g_hSeamlessWtNotifyEvent)
                                 {
-                                    Log(("Event 'Seamless' triggered\n"));
+                                    LogFunc(("Event 'Seamless' triggered\n"));
 
                                     /* seamless window notification */
@@ -912 +925 @@
                                     fHandled = TRUE;
                                 }
-                                else if (hWaitEvent[waitResult] == ghSeamlessKmNotifyEvent)
+                                else if (hWaitEvent[waitResult] == g_hSeamlessKmNotifyEvent)
                                 {
-                                    Log(("Event 'Km Seamless' triggered\n"));
+                                    LogFunc(("Event 'Km Seamless' triggered\n"));
 
                                     /* seamless window notification */
@@ -922 +935 @@
                                 else if (hWaitEvent[waitResult] == vboxDtGetNotifyEvent())
                                 {
-                                    Log(("Event 'Dt' triggered\n"));
+                                    LogFunc(("Event 'Dt' triggered\n"));
                                     VBoxTrayCheckDt();
                                     fHandled = TRUE;
@@ -935 +948 @@
                             while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
                             {
-#ifndef DEBUG_andy
-                                Log(("msg %p\n", msg.message));
+#ifdef DEBUG_andy
+                                LogFlowFunc(("PeekMessage %u\n", msg.message));
 #endif
                                 if (msg.message == WM_QUIT)
                                 {
-                                    Log(("WM_QUIT!\n"));
-                                    SetEvent(ghStopSem);
+                                    LogFunc(("Terminating ...\n"));
+                                    SetEvent(g_hStopSem);
                                 }
                                 TranslateMessage(&msg);
@@ -949 +962 @@
                     }
                 }
-                Log(("Returned from main loop, exiting ...\n"));
-            }
-            Log(("Waiting for services to stop ...\n"));
-            vboxTrayStopServices(&svcEnv, vboxServiceTable);
+                LogFunc(("Returned from main loop, exiting ...\n"));
+            }
+            LogFunc(("Waiting for services to stop ...\n"));
+            vboxTrayServicesStop(&svcEnv);
         } /* Services started */
-        CloseHandle(ghStopSem);
+        CloseHandle(g_hStopSem);
     } /* Stop event created */
 
     vboxTrayRemoveTrayIcon();
 
-    Log(("Leaving vboxTrayServiceMain with rc=%Rrc\n", rc));
+    LogFunc(("Leaving with rc=%Rrc\n", rc));
     return rc;
 }
@@ -996 +1009 @@
     {
         /* Save instance handle. */
-        ghInstance = hInstance;
+        g_hInstance = hInstance;
 
         hlpReportStatus(VBoxGuestFacilityStatus_Init);
@@ -1004 +1017 @@
             VBoxCapsInit();
 
-            rc = vboxStInit(ghwndToolWindow);
+            rc = vboxStInit(g_hwndToolWindow);
             if (!RT_SUCCESS(rc))
             {
-                LogFlowFunc(("vboxStInit failed, rc %d\n"));
+                LogFlowFunc(("vboxStInit failed, rc=%Rrc\n", rc));
                 /* 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
@@ -1017 +1030 @@
             if (!RT_SUCCESS(rc))
             {
-                LogFlowFunc(("vboxDtInit failed, rc %d\n"));
+                LogFlowFunc(("vboxDtInit failed, rc=%Rrc\n", rc));
                 /* 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
@@ -1026 +1039 @@
             rc = VBoxAcquireGuestCaps(VMMDEV_GUEST_SUPPORTS_SEAMLESS | VMMDEV_GUEST_SUPPORTS_GRAPHICS, 0, true);
             if (!RT_SUCCESS(rc))
-            {
-                LogFlowFunc(("VBoxAcquireGuestCaps cfg failed rc %d, ignoring..\n", rc));
-            }
-
-            rc = vboxTraySetupSeamless();
+                LogFlowFunc(("VBoxAcquireGuestCaps failed with rc=%Rrc, ignoring ...\n", rc));
+
+            rc = vboxTraySetupSeamless(); /** @todo r=andy Do we really want to be this critical for the whole application? */
             if (RT_SUCCESS(rc))
             {
-                Log(("Init successful\n"));
                 rc = vboxTrayServiceMain();
                 if (RT_SUCCESS(rc))
@@ -1077 +1087 @@
 
 /**
- * Window procedure for our tool window
+ * Window procedure for our main tool window.
  */
 static LRESULT CALLBACK vboxToolWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
+    LogFlowFunc(("hWnd=%p, uMsg=%u\n", hWnd, uMsg));
+
     switch (uMsg)
     {
         case WM_CREATE:
         {
-            Log(("Tool window created\n"));
+            LogFunc(("Tool window created\n"));
 
             int rc = vboxTrayRegisterGlobalMessages(&s_vboxGlobalMessageTable[0]);
             if (RT_FAILURE(rc))
-                Log(("Error registering global window messages, rc=%Rrc\n", rc));
+                LogFunc(("Error registering global window messages, rc=%Rrc\n", rc));
             return 0;
         }
@@ -1097 +1109 @@
 
         case WM_DESTROY:
-            Log(("Tool window destroyed\n"));
-            KillTimer(ghwndToolWindow, TIMERID_VBOXTRAY_CHECK_HOSTVERSION);
+        {
+            LogFunc(("Tool window destroyed\n"));
+            KillTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_CHECK_HOSTVERSION);
             return 0;
+        }
 
         case WM_TIMER:
+        {
             if (VBoxCapsCheckTimer(wParam))
                 return 0;
@@ -1115 +1130 @@
                     {
                         /* After successful run we don't need to check again. */
-                        KillTimer(ghwndToolWindow, TIMERID_VBOXTRAY_CHECK_HOSTVERSION);
+                        KillTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_CHECK_HOSTVERSION);
                     }
                     return 0;
@@ -1122 +1137 @@
                     break;
             }
+
             break; /* Make sure other timers get processed the usual way! */
+        }
 
         case WM_VBOXTRAY_TRAY_ICON:
+        {
             switch (lParam)
             {
@@ -1134 +1152 @@
             }
             return 0;
+        }
 
         case WM_VBOX_SEAMLESS_ENABLE:
+        {
             VBoxCapsEntryFuncStateSet(VBOXCAPS_ENTRY_IDX_SEAMLESS, VBOXCAPS_ENTRY_FUNCSTATE_STARTED);
             return 0;
+        }
 
         case WM_VBOX_SEAMLESS_DISABLE:
+        {
             VBoxCapsEntryFuncStateSet(VBOXCAPS_ENTRY_IDX_SEAMLESS, VBOXCAPS_ENTRY_FUNCSTATE_SUPPORTED);
             return 0;
+        }
 
         case WM_DISPLAYCHANGE:
         case WM_VBOX_SEAMLESS_UPDATE:
+        {
             if (VBoxCapsEntryIsEnabled(VBOXCAPS_ENTRY_IDX_SEAMLESS))
                 VBoxSeamlessCheckWindows(true);
             return 0;
+        }
 
         case WM_VBOX_GRAPHICS_SUPPORTED:
+        {
             VBoxGrapicsSetSupported(TRUE);
             return 0;
+        }
 
         case WM_VBOX_GRAPHICS_UNSUPPORTED:
+        {
             VBoxGrapicsSetSupported(FALSE);
             return 0;
+        }
 
         case WM_WTSSESSION_CHANGE:
@@ -1167 +1196 @@
             return 0;
         }
+
         default:
-
+        {
             /* Handle all globally registered window messages. */
             if (vboxTrayHandleGlobalMessages(&s_vboxGlobalMessageTable[0], uMsg,
@@ -1176 +1206 @@
             }
             break; /* We did not handle the message, dispatch to DefWndProc. */
-    }
-
-    /* Only if message was *not* handled by our switch above, dispatch
-     * to DefWindowProc. */
+        }
+    }
+
+    /* Only if message was *not* handled by our switch above, dispatch to DefWindowProc. */
     return DefWindowProc(hWnd, uMsg, wParam, lParam);
 }
@@ -1443 +1473 @@
     int rc = VINF_SUCCESS;
     OSVERSIONINFO info;
-    gMajorVersion = 5; /* Default to Windows XP. */
+    g_dwMajorVersion = 5; /* Default to Windows XP. */
     info.dwOSVersionInfoSize = sizeof(info);
     if (GetVersionEx(&info))
     {
         LogRel(("Windows version %ld.%ld\n", info.dwMajorVersion, info.dwMinorVersion));
-        gMajorVersion = info.dwMajorVersion;
+        g_dwMajorVersion = info.dwMajorVersion;
     }
 
@@ -1499 +1529 @@
                     BOOL fRc = FALSE;
                     /* For Vista and up we need to change the integrity of the security descriptor, too. */
-                    if (gMajorVersion >= 6)
+                    if (g_dwMajorVersion >= 6)
                     {
                         HMODULE hModHook = (HMODULE)RTLdrGetNativeHandle(gVBoxDt.hLdrModHook);
@@ -1513 +1543 @@
                     if (!fRc)
                     {
-                        gVBoxDt.idTimer = SetTimer(ghwndToolWindow, TIMERID_VBOXTRAY_DT_TIMER, 500, (TIMERPROC)NULL);
+                        gVBoxDt.idTimer = SetTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_DT_TIMER, 500, (TIMERPROC)NULL);
                         if (!gVBoxDt.idTimer)
                         {
@@ -1586 +1616 @@
 }
 
-
 /* we need to perform Acquire/Release using the file handled we use for rewuesting events from VBoxGuest
  * otherwise Acquisition mechanism will treat us as different client and will not propagate necessary requests
@@ -1599 +1628 @@
     Info.u32OrMask = fOr;
     Info.u32NotMask = fNot;
-    if (!DeviceIoControl(ghVBoxDriver, VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE, &Info, sizeof(Info), &Info, sizeof(Info), &cbReturned, NULL))
+    if (!DeviceIoControl(g_hVBoxDriver, VBOXGUEST_IOCTL_GUEST_CAPS_ACQUIRE, &Info, sizeof(Info), &Info, sizeof(Info), &cbReturned, NULL))
     {
         DWORD LastErr = GetLastError();
@@ -1650 +1679 @@
 static VBOXCAPS gVBoxCaps;
 
-static DECLCALLBACK(void) vboxCapsOnEnableSeamles(struct VBOXCAPS *pConsole, struct VBOXCAPS_ENTRY *pCap, BOOL fEnabled)
+static DECLCALLBACK(void) vboxCapsOnEnableSeamless(struct VBOXCAPS *pConsole, struct VBOXCAPS_ENTRY *pCap, BOOL fEnabled)
 {
     if (fEnabled)
     {
-        Log(("vboxCapsOnEnableSeamles: ENABLED\n"));
+        Log(("vboxCapsOnEnableSeamless: ENABLED\n"));
         Assert(pCap->enmAcState == VBOXCAPS_ENTRY_ACSTATE_ACQUIRED);
         Assert(pCap->enmFuncState == VBOXCAPS_ENTRY_FUNCSTATE_STARTED);
@@ -1661 +1690 @@
     else
     {
-        Log(("vboxCapsOnEnableSeamles: DISABLED\n"));
+        Log(("vboxCapsOnEnableSeamless: DISABLED\n"));
         Assert(pCap->enmAcState != VBOXCAPS_ENTRY_ACSTATE_ACQUIRED || pCap->enmFuncState != VBOXCAPS_ENTRY_FUNCSTATE_STARTED);
         VBoxSeamlessDisable();
@@ -1738 +1767 @@
     pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].fCap = VMMDEV_GUEST_SUPPORTS_SEAMLESS;
     pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].iCap = VBOXCAPS_ENTRY_IDX_SEAMLESS;
-    pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].pfnOnEnable = vboxCapsOnEnableSeamles;
+    pConsole->aCaps[VBOXCAPS_ENTRY_IDX_SEAMLESS].pfnOnEnable = vboxCapsOnEnableSeamless;
     pConsole->aCaps[VBOXCAPS_ENTRY_IDX_GRAPHICS].fCap = VMMDEV_GUEST_SUPPORTS_GRAPHICS;
     pConsole->aCaps[VBOXCAPS_ENTRY_IDX_GRAPHICS].iCap = VBOXCAPS_ENTRY_IDX_GRAPHICS;
@@ -1758 +1787 @@
     {
         Log(("killing console timer\n"));
-        KillTimer(ghwndToolWindow, pConsole->idTimer);
+        KillTimer(g_hwndToolWindow, pConsole->idTimer);
         pConsole->idTimer = 0;
     }
@@ -1820 +1849 @@
     if (!fNeedNewTimer)
     {
-        KillTimer(ghwndToolWindow, pConsole->idTimer);
+        KillTimer(g_hwndToolWindow, pConsole->idTimer);
         /* cleanup timer data */
         pConsole->idTimer = 0;
@@ -1881 +1910 @@
     if (!pConsole->idTimer)
     {
-        pConsole->idTimer = SetTimer(ghwndToolWindow, TIMERID_VBOXTRAY_CAPS_TIMER, 100, (TIMERPROC)NULL);
+        pConsole->idTimer = SetTimer(g_hwndToolWindow, TIMERID_VBOXTRAY_CAPS_TIMER, 100, (TIMERPROC)NULL);
         if (!pConsole->idTimer)
         {

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2014 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -46 +46 @@
 #include <iprt/initterm.h>
 #include <iprt/string.h>
+#include <iprt/thread.h>
 
 #include <VBox/version.h>
@@ -63 +64 @@
 #define WM_VBOXTRAY_TRAY_ICON                   WM_APP + 40
 
-
 /* The tray icon's ID. */
 #define ID_TRAYICON                             2000
-
 
 /*
@@ -76 +75 @@
 #define TIMERID_VBOXTRAY_ST_DELAYED_INIT_TIMER  1003
 
-/* The environment information for services. */
+/**
+ * The environment information for services.
+ */
 typedef struct _VBOXSERVICEENV
 {
+    /** hInstance of VBoxTray. */
     HINSTANCE hInstance;
+    /** Handle of guest driver. */
     HANDLE    hDriver;
-    HANDLE    hStopEvent;
-    /* display driver interface, XPDM - WDDM abstraction see VBOXDISPIF** definitions above */
+    /* Display driver interface, XPDM - WDDM abstraction see VBOXDISPIF** definitions above */
+    /** @todo r=andy Argh. Needed by the "display" + "seamless" services (which in turn get called
+     *               by the VBoxCaps facility. See #8037. */
     VBOXDISPIF dispIf;
-} VBOXSERVICEENV;
+} VBOXSERVICEENV, *PVBOXSERVICEENV;
 
-/* The service initialization info and runtime variables. */
+/**
+ * A service descriptor.
+ */
+typedef struct _VBOXSERVICEDESC
+{
+    /** The service's name. RTTHREAD_NAME_LEN maximum characters. */
+    char           *pszName;
+    /** The service description. */
+    char           *pszDesc;
+
+    /** Callbacks. */
+
+    /**
+     * Initializes a service.
+     * @returns VBox status code.
+     * @param   pEnv
+     * @param   ppInstance      Where to return the thread-specific instance data.
+     */
+    DECLCALLBACKMEMBER(int,  pfnInit)   (const PVBOXSERVICEENV pEnv, void **ppInstance);
+
+    /** Called from the worker thread.
+     *
+     * @returns VBox status code.
+     * @retval  VINF_SUCCESS if exitting because *pfShutdown was set.
+     * @param   pInstance       Pointer to thread-specific instance data.
+     * @param   pfShutdown      Pointer to a per service termination flag to check
+     *                          before and after blocking.
+     */
+    DECLCALLBACKMEMBER(int,  pfnWorker) (void *pInstance, bool volatile *pfShutdown);
+
+    /**
+     * Stops a service.
+     */
+    DECLCALLBACKMEMBER(int,  pfnStop)   (void *pInstance);
+
+    /**
+     * Does termination cleanups.
+     *
+     * @remarks This may be called even if pfnInit hasn't been called!
+     */
+    DECLCALLBACKMEMBER(void, pfnDestroy)(void *pInstance);
+} VBOXSERVICEDESC, *PVBOXSERVICEDESC;
+
+extern VBOXSERVICEDESC g_SvcDescDisplay;
+extern VBOXSERVICEDESC g_SvcDescClipboard;
+extern VBOXSERVICEDESC g_SvcDescSeamless;
+extern VBOXSERVICEDESC g_SvcDescVRDP;
+extern VBOXSERVICEDESC g_SvcDescIPC;
+extern VBOXSERVICEDESC g_SvcDescLA;
+#ifdef VBOX_WITH_DRAG_AND_DROP
+extern VBOXSERVICEDESC g_SvcDescDnD;
+#endif
+
+/**
+ * The service initialization info and runtime variables.
+ */
 typedef struct _VBOXSERVICEINFO
 {
-    char     *pszName;
-    int      (* pfnInit)             (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread);
-    unsigned (__stdcall * pfnThread) (void *pInstance);
-    void     (* pfnStop)             (const VBOXSERVICEENV *pEnv, void *pInstance);
-    void     (* pfnDestroy)          (const VBOXSERVICEENV *pEnv, void *pInstance);
-
-    /* Variables. */
-    HANDLE   hThread;
-    void    *pInstance;
-    bool     fStarted;
-} VBOXSERVICEINFO;
+    /** Pointer to the service descriptor. */
+    PVBOXSERVICEDESC pDesc;
+    /** Thread handle. */
+    RTTHREAD         hThread;
+    /** Pointer to service-specific instance data.
+     *  Must be free'd by the service itself. */
+    void            *pInstance;
+    /** Whether Pre-init was called. */
+    bool             fPreInited;
+    /** Shutdown indicator. */
+    bool volatile    fShutdown;
+    /** Indicator set by the service thread exiting. */
+    bool volatile    fStopped;
+    /** Whether the service was started or not. */
+    bool             fStarted;
+    /** Whether the service is enabled or not. */
+    bool             fEnabled;
+} VBOXSERVICEINFO, *PVBOXSERVICEINFO;
 
 /* Globally unique (system wide) message registration. */
@@ -116 +182 @@
 } VBOXGLOBALMESSAGE, *PVBOXGLOBALMESSAGE;
 
-extern HWND         ghwndToolWindow;
-extern HINSTANCE    ghInstance;
+extern HWND         g_hwndToolWindow;
+extern HINSTANCE    g_hInstance;
 
 #endif /* !___VBOXTRAY_H */

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2014 Oracle Corporation
+ * Copyright (C) 2006-2015 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -59 +59 @@
 };
 
-typedef struct _VBoxExperienceParameter
+typedef struct _VBOXVRDPEXPPARAM
 {
     const char *name;
@@ -69 +69 @@
     UINT  cbSavedValue;
     char  achSavedValue[2 * MAX_PATH]; /* Large enough to save the bitmap path. */
-} VBoxExperienceParameter;
+} VBOXVRDPEXPPARAM, *PVBOXVRDPEXPPARAM;
+
+typedef struct _VBOXVRDPCONTEXT
+{
+    const VBOXSERVICEENV *pEnv;
+
+    uint32_t level;
+    BOOL fSavedThemeEnabled;
+
+    RTLDRMOD hModUxTheme;
+
+    HRESULT (* pfnEnableTheming)(BOOL fEnable);
+    BOOL (* pfnIsThemeActive)(VOID);
+} VBOXVRDPCONTEXT, *PVBOXVRDPCONTEXT;
+
+static VBOXVRDPCONTEXT g_Ctx = { 0 };
 
 #define SPI_(l, a) #a, SPI_SET##a, SPI_GET##a, VRDP_EXPERIENCE_LEVEL_##l
 
-static VBoxExperienceParameter parameters[] =
+static VBOXVRDPEXPPARAM s_aSPIParams[] =
 {
     { SPI_(MEDIUM, DESKWALLPAPER),           VBOX_SPI_STRING,   "" },
@@ -92 +107 @@
 #undef SPI_
 
-static void vboxExperienceSet (uint32_t level)
-{
-    int i;
-    for (i = 0; i < RT_ELEMENTS(parameters); i++)
-    {
-        if (parameters[i].level > level)
+static void vboxExperienceSet(uint32_t uLevel)
+{
+    for (size_t i = 0; i < RT_ELEMENTS(s_aSPIParams); i++)
+    {
+        PVBOXVRDPEXPPARAM pParam = &s_aSPIParams[i];
+        if (pParam->level > uLevel)
         {
             /*
              * The parameter has to be disabled.
              */
-            LogFlowFunc(("Saving %s\n", parameters[i].name));
+            LogFlowFunc(("Saving %s\n", pParam->name));
 
             /* Save the current value. */
-            switch (parameters[i].type)
+            switch (pParam->type)
             {
                 case VBOX_SPI_STRING:
@@ -112 +127 @@
                      * The 3rd parameter points to the buffer.
                      */
-                    SystemParametersInfo (parameters[i].uActionGet,
+                    SystemParametersInfo (pParam->uActionGet,
                                           MAX_PATH,
-                                          parameters[i].achSavedValue,
+                                          pParam->achSavedValue,
                                           0);
                 } break;
@@ -122 +137 @@
                 {
                     /* The 3rd parameter points to BOOL. */
-                    SystemParametersInfo (parameters[i].uActionGet,
-                                          0,
-                                          parameters[i].achSavedValue,
+                    SystemParametersInfo (pParam->uActionGet,
+                                          0,
+                                          pParam->achSavedValue,
                                           0);
                 } break;
@@ -134 +149 @@
                      * The uiParam parameter must alos be set.
                      */
-                    if (parameters[i].cbSavedValue > sizeof (parameters[i].achSavedValue))
+                    if (pParam->cbSavedValue > sizeof (pParam->achSavedValue))
                     {
-                        LogFlowFunc(("Not enough space %d > %d\n", parameters[i].cbSavedValue, sizeof (parameters[i].achSavedValue)));
+                        LogFlowFunc(("Not enough space %d > %d\n", pParam->cbSavedValue, sizeof (pParam->achSavedValue)));
                         break;
                     }
 
-                    *(UINT *)&parameters[i].achSavedValue[0] = parameters[i].cbSavedValue;
-
-                    SystemParametersInfo (parameters[i].uActionGet,
-                                          parameters[i].cbSavedValue,
-                                          parameters[i].achSavedValue,
+                    *(UINT *)&pParam->achSavedValue[0] = pParam->cbSavedValue;
+
+                    SystemParametersInfo (s_aSPIParams[i].uActionGet,
+                                          s_aSPIParams[i].cbSavedValue,
+                                          s_aSPIParams[i].achSavedValue,
                                           0);
                 } break;
@@ -152 +167 @@
             }
 
-            LogFlowFunc(("Disabling %s\n", parameters[i].name));
+            LogFlowFunc(("Disabling %s\n", pParam->name));
 
             /* Disable the feature. */
-            switch (parameters[i].type)
+            switch (pParam->type)
             {
                 case VBOX_SPI_STRING:
                 {
                     /* The 3rd parameter points to the string. */
-                    SystemParametersInfo (parameters[i].uActionSet,
-                                          0,
-                                          parameters[i].pvDisable,
+                    SystemParametersInfo (pParam->uActionSet,
+                                          0,
+                                          pParam->pvDisable,
                                           SPIF_SENDCHANGE);
                 } break;
@@ -169 +184 @@
                 {
                     /* The 2nd parameter is BOOL. */
-                    SystemParametersInfo (parameters[i].uActionSet,
+                    SystemParametersInfo (pParam->uActionSet,
                                           FALSE,
                                           NULL,
@@ -178 +193 @@
                 {
                     /* The 3rd parameter is NULL to disable. */
-                    SystemParametersInfo (parameters[i].uActionSet,
+                    SystemParametersInfo (pParam->uActionSet,
                                           0,
                                           NULL,
@@ -187 +202 @@
                 {
                     /* The 3rd parameter points to the structure. */
-                    SystemParametersInfo (parameters[i].uActionSet,
-                                          0,
-                                          parameters[i].pvDisable,
+                    SystemParametersInfo (pParam->uActionSet,
+                                          0,
+                                          pParam->pvDisable,
                                           SPIF_SENDCHANGE);
                 } break;
@@ -200 +215 @@
 }
 
-static void vboxExperienceRestore (uint32_t level)
+static void vboxExperienceRestore(uint32_t uLevel)
 {
     int i;
-    for (i = 0; i < RT_ELEMENTS(parameters); i++)
-    {
-        if (parameters[i].level > level)
+    for (i = 0; i < RT_ELEMENTS(s_aSPIParams); i++)
+    {
+        PVBOXVRDPEXPPARAM pParam = &s_aSPIParams[i];
+        if (pParam->level > uLevel)
         {
-            LogFlowFunc(("Restoring %s\n", parameters[i].name));
+            LogFlowFunc(("Restoring %s\n", pParam->name));
 
             /* Restore the feature. */
-            switch (parameters[i].type)
+            switch (pParam->type)
             {
                 case VBOX_SPI_STRING:
                 {
                     /* The 3rd parameter points to the string. */
-                    SystemParametersInfo (parameters[i].uActionSet,
-                                          0,
-                                          parameters[i].achSavedValue,
+                    SystemParametersInfo (pParam->uActionSet,
+                                          0,
+                                          pParam->achSavedValue,
                                           SPIF_SENDCHANGE);
                 } break;
@@ -224 +240 @@
                 {
                     /* The 2nd parameter is BOOL. */
-                    SystemParametersInfo (parameters[i].uActionSet,
-                                          *(BOOL *)&parameters[i].achSavedValue[0],
+                    SystemParametersInfo (pParam->uActionSet,
+                                          *(BOOL *)&pParam->achSavedValue[0],
                                           NULL,
                                           SPIF_SENDCHANGE);
@@ -233 +249 @@
                 {
                     /* The 3rd parameter is NULL to disable. */
-                    BOOL fSaved = *(BOOL *)&parameters[i].achSavedValue[0];
-
-                    SystemParametersInfo (parameters[i].uActionSet,
+                    BOOL fSaved = *(BOOL *)&pParam->achSavedValue[0];
+
+                    SystemParametersInfo (pParam->uActionSet,
                                           0,
                                           fSaved? &fSaved: NULL,
@@ -244 +260 @@
                 {
                     /* The 3rd parameter points to the structure. */
-                    SystemParametersInfo (parameters[i].uActionSet,
-                                          0,
-                                          parameters[i].achSavedValue,
+                    SystemParametersInfo (pParam->uActionSet,
+                                          0,
+                                          pParam->achSavedValue,
                                           SPIF_SENDCHANGE);
                 } break;
@@ -257 +273 @@
 }
 
-
-typedef struct _VBOXVRDPCONTEXT
-{
-    const VBOXSERVICEENV *pEnv;
-
-    uint32_t level;
-    BOOL fSavedThemeEnabled;
-
-    RTLDRMOD hModUxTheme;
-
-    HRESULT (* pfnEnableTheming)(BOOL fEnable);
-    BOOL (* pfnIsThemeActive)(VOID);
-} VBOXVRDPCONTEXT;
-
-
-static VBOXVRDPCONTEXT gCtx = {0};
-
-
-int VBoxVRDPInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
-{
-    LogFlowFunc(("VBoxVRDPInit\n"));
-
-    gCtx.pEnv      = pEnv;
-    gCtx.level     = VRDP_EXPERIENCE_LEVEL_FULL;
-    gCtx.fSavedThemeEnabled = FALSE;
-
-    int rc = RTLdrLoadSystem("UxTheme.dll", false /*fNoUnload*/, &gCtx.hModUxTheme);
+static DECLCALLBACK(int) VBoxVRDPInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
+{
+    AssertPtrReturn(pEnv, VERR_INVALID_POINTER);
+    AssertPtrReturn(ppInstance, VERR_INVALID_POINTER);
+
+    LogFlowFuncEnter();
+
+    PVBOXVRDPCONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
+    AssertPtr(pCtx);
+
+    pCtx->pEnv               = pEnv;
+    pCtx->level              = VRDP_EXPERIENCE_LEVEL_FULL;
+    pCtx->fSavedThemeEnabled = FALSE;
+
+    int rc = RTLdrLoadSystem("UxTheme.dll", false /*fNoUnload*/, &g_Ctx.hModUxTheme);
     if (RT_SUCCESS(rc))
     {
-        *(PFNRT *)&gCtx.pfnEnableTheming = RTLdrGetFunction(gCtx.hModUxTheme, "EnableTheming");
-        *(PFNRT *)&gCtx.pfnIsThemeActive = RTLdrGetFunction(gCtx.hModUxTheme, "IsThemeActive");
+        *(PFNRT *)&pCtx->pfnEnableTheming = RTLdrGetFunction(g_Ctx.hModUxTheme, "EnableTheming");
+        *(PFNRT *)&pCtx->pfnIsThemeActive = RTLdrGetFunction(g_Ctx.hModUxTheme, "IsThemeActive");
+
+        *ppInstance = &g_Ctx;
     }
     else
     {
-        gCtx.hModUxTheme = NIL_RTLDRMOD;
-        gCtx.pfnEnableTheming = NULL;
-        gCtx.pfnIsThemeActive = NULL;
-    }
-
-    *pfStartThread = true;
-    *ppInstance = &gCtx;
-    return VINF_SUCCESS;
+        g_Ctx.hModUxTheme = NIL_RTLDRMOD;
+        g_Ctx.pfnEnableTheming = NULL;
+        g_Ctx.pfnIsThemeActive = NULL;
+    }
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
-
-void VBoxVRDPDestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
-{
-    LogFlowFunc(("VBoxVRDPDestroy\n"));
-    VBOXVRDPCONTEXT *pCtx = (VBOXVRDPCONTEXT *)pInstance;
+static DECLCALLBACK(void) VBoxVRDPDestroy(void *pInstance)
+{
+    AssertPtrReturnVoid(pInstance);
+
+    LogFlowFuncEnter();
+
+    PVBOXVRDPCONTEXT pCtx = (PVBOXVRDPCONTEXT)pInstance;
+
     vboxExperienceRestore (pCtx->level);
-    if (gCtx.hModUxTheme != NIL_RTLDRMOD)
-    {
-        RTLdrClose(gCtx.hModUxTheme);
-        gCtx.hModUxTheme = NIL_RTLDRMOD;
-    }
+    if (pCtx->hModUxTheme != NIL_RTLDRMOD)
+    {
+        RTLdrClose(g_Ctx.hModUxTheme);
+        pCtx->hModUxTheme = NIL_RTLDRMOD;
+    }
+
     return;
 }
@@ -318 +327 @@
  * Thread function to wait for and process mode change requests
  */
-unsigned __stdcall VBoxVRDPThread(void *pInstance)
-{
-    VBOXVRDPCONTEXT *pCtx = (VBOXVRDPCONTEXT *)pInstance;
+static DECLCALLBACK(int) VBoxVRDPWorker(void *pInstance, bool volatile *pfShutdown)
+{
+    AssertPtrReturn(pInstance, VERR_INVALID_POINTER);
+
+    LogFlowFuncEnter();
+
+    /*
+     * Tell the control thread that it can continue
+     * spawning services.
+     */
+    RTThreadUserSignal(RTThreadSelf());
+
+    PVBOXVRDPCONTEXT pCtx = (PVBOXVRDPCONTEXT)pInstance;
+    AssertPtr(pCtx);
+
     HANDLE gVBoxDriver = pCtx->pEnv->hDriver;
     bool fTerminate = false;
@@ -328 +349 @@
     maskInfo.u32OrMask = VMMDEV_EVENT_VRDP;
     maskInfo.u32NotMask = 0;
-    if (DeviceIoControl (gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
-    {
-        LogFlowFunc(("DeviceIOControl(CtlMask - or) succeeded\n"));
-    }
-    else
-    {
-        LogFlowFunc(("DeviceIOControl(CtlMask) failed\n"));
-        return 0;
-    }
-
-    do
+    if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
+    {
+        DWORD dwErr = GetLastError();
+        LogFlowFunc(("DeviceIOControl(CtlMask) failed with %ld, exiting\n", dwErr));
+        return RTErrConvertFromWin32(dwErr);
+    }
+
+    int rc = VINF_SUCCESS;
+
+    for (;;)
     {
         /* wait for the event */
@@ -346 +366 @@
         if (DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_WAITEVENT, &waitEvent, sizeof(waitEvent), &waitEvent, sizeof(waitEvent), &cbReturned, NULL))
         {
-            LogFlowFunc(("DeviceIOControl succeeded\n"));
-
             /* are we supposed to stop? */
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 0) == WAIT_OBJECT_0)
+            if (*pfShutdown)
                 break;
-
-            LogFlowFunc(("checking event\n"));
 
             /* did we get the right event? */
@@ -417 +433 @@
                 else
                 {
-#ifndef DEBUG_andy /* Too noisy for me. */
-                    LogFlowFunc(("Error from DeviceIoControl VBOXGUEST_IOCTL_VMMREQUEST\n"));
-#endif
                     /* sleep a bit to not eat too much CPU in case the above call always fails */
-                    if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 10) == WAIT_OBJECT_0)
-                    {
-                        fTerminate = true;
+                    RTThreadSleep(10);
+
+                    if (*pfShutdown)
                         break;
-                    }
                 }
             }
@@ -431 +443 @@
         else
         {
-#ifndef DEBUG_andy
-            LogFlowFunc(("Error from DeviceIoControl VBOXGUEST_IOCTL_WAITEVENT\n"));
-#endif
             /* sleep a bit to not eat too much CPU in case the above call always fails */
-            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 10) == WAIT_OBJECT_0)
-            {
-                fTerminate = true;
+            RTThreadSleep(50);
+
+            if (*pfShutdown)
                 break;
-            }
         }
-    } while (!fTerminate);
-
-    maskInfo.u32OrMask = 0;
+    }
+
+    maskInfo.u32OrMask  = 0;
     maskInfo.u32NotMask = VMMDEV_EVENT_VRDP;
-    if (DeviceIoControl (gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
-    {
-        LogFlowFunc(("DeviceIOControl(CtlMask - not) succeeded\n"));
-    }
-    else
-    {
+    if (!DeviceIoControl(gVBoxDriver, VBOXGUEST_IOCTL_CTL_FILTER_MASK, &maskInfo, sizeof (maskInfo), NULL, 0, &cbReturned, NULL))
         LogFlowFunc(("DeviceIOControl(CtlMask) failed\n"));
-    }
-
-    LogFlowFunc(("Finished VRDP change request thread\n"));
-    return 0;
+
+    LogFlowFuncLeaveRC(rc);
+    return rc;
 }
 
+/**
+ * The service description.
+ */
+VBOXSERVICEDESC g_SvcDescVRDP =
+{
+    /* pszName. */
+    "VRDP",
+    /* pszDescription. */
+    "VRDP Connection Notification",
+    /* methods */
+    VBoxVRDPInit,
+    VBoxVRDPWorker,
+    NULL /* pfnStop */,
+    VBoxVRDPDestroy
+};
+