Changeset 107985 in vbox for trunk/src/VBox/GuestHost/installation/VBoxWinDrvInst.cpp

Timestamp:

Jan 30, 2025 10:01:07 AM (3 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

167248

Message:

Windows driver installation: Implemented APIs for controlling (driver SCM) services. bugref:10762

File:

• trunk/src/VBox/GuestHost/installation/VBoxWinDrvInst.cpp (modified) (2 diffs)

trunk/src/VBox/GuestHost/installation/VBoxWinDrvInst.cpp

@@ -51 +51 @@
 #include <iprt/string.h>
 #include <iprt/system.h>
+#include <iprt/thread.h> /* For RTThreadSleep(). */
 #include <iprt/utf16.h>
 
@@ -2284 +2285 @@
 }
 
+/**
+ * Controls a Windows service, internal version.
+ *
+ * @returns VBox status code.
+ * @param   hDrvInst            Windows driver installer handle to use.
+ * @param   pszService          Name of service to control.
+ * @param   enmFn               Service control function to use.
+ *                              VBOXWINDRVSVCFN_RESTART is not implemented and must be composed of
+ *                              VBOXWINDRVSVCFN_START + VBOXWINDRVSVCFN_STOP by the caller.
+ * @param   fFlags              Service control flags (of type VBOXWINDRVSVCFN_F_XXX) to use.
+ * @param   msTimeout           Timeout (in ms) to use. Only being used if VBOXWINDRVSVCFN_F_WAIT is specified in \a fFlags.
+ */
+static int vbooxWinDrvInstControlServiceEx(PVBOXWINDRVINSTINTERNAL pCtx,
+                                           const char *pszService, VBOXWINDRVSVCFN enmFn, uint32_t fFlags, RTMSINTERVAL msTimeout)
+{
+    AssertPtrReturn(pszService, VERR_INVALID_POINTER);
+    AssertReturn(!(fFlags & ~VBOXWINDRVSVCFN_F_VALID_MASK), VERR_INVALID_PARAMETER);
+    AssertReturn(enmFn > VBOXWINDRVSVCFN_INVALID && enmFn < VBOXWINDRVSVCFN_END, VERR_INVALID_PARAMETER);
+    AssertReturn(msTimeout == RT_INDEFINITE_WAIT || msTimeout, VERR_INVALID_PARAMETER);
+
+    PRTUTF16 pwszService;
+    int rc = RTStrToUtf16(pszService, &pwszService);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    SC_HANDLE hSvc = NULL;
+    SC_HANDLE hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
+    if (hSCM != NULL)
+    {
+        hSvc = OpenServiceW(hSCM, pwszService, SERVICE_ALL_ACCESS | SERVICE_QUERY_STATUS);
+        if (hSvc == NULL)
+        {
+            rc = RTErrConvertFromWin32(GetLastError());
+            if (rc == VERR_NOT_FOUND)
+                vboxWinDrvInstLogError(pCtx, "Service '%s' not found", pszService);
+            else
+                rc = vboxWinDrvInstLogLastError(pCtx, "Opening service '%s' failed", pszService);
+        }
+    }
+    else
+        rc = vboxWinDrvInstLogLastError(pCtx, "Opening Service Control Manager (SCM) failed");
+
+    if (RT_FAILURE(rc))
+    {
+        RTUtf16Free(pwszService);
+        if (hSvc)
+            CloseServiceHandle(hSvc);
+        if (hSCM)
+            CloseServiceHandle(hSCM);
+        return rc;
+    }
+
+    SERVICE_STATUS_PROCESS enmSvcSts;
+
+    switch (enmFn)
+    {
+        case VBOXWINDRVSVCFN_START:
+        {
+            if (!StartService(hSvc, 0, NULL))
+            {
+                if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
+                    break;
+
+                /** @todo Also handle disabled services here? */
+
+                rc = vboxWinDrvInstLogLastError(pCtx, "Starting service '%s' failed", pszService);
+            }
+            else
+                vboxWinDrvInstLogInfo(pCtx, "Starting service '%s' ...", pszService);
+            break;
+        }
+
+        case VBOXWINDRVSVCFN_STOP:
+        {
+            if (!ControlService(hSvc, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS)&enmSvcSts))
+            {
+                DWORD const dwErr = GetLastError();
+
+                /* A not active or disabled service is not an error, so just skip. */
+                if (   dwErr == ERROR_SERVICE_DISABLED
+                    || dwErr == ERROR_SERVICE_NOT_ACTIVE)
+                    break;
+
+                rc = vboxWinDrvInstLogLastError(pCtx, "Stopping service '%s' failed", pszService);
+            }
+            else
+                vboxWinDrvInstLogInfo(pCtx, "Stopping service '%s' ...", pszService);
+            break;
+        }
+
+        default:
+            AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
+            break;
+    }
+
+    if (   RT_SUCCESS(rc)
+        && (fFlags & VBOXWINDRVSVCFN_F_WAIT))
+    {
+        uint64_t const msStartTS = RTTimeMilliTS();
+
+        rc = VERR_NO_CHANGE; /* No change yet. */
+
+        vboxWinDrvInstLogInfo(pCtx, "Waiting for status change of service '%s' ...", pszService);
+        for (;;)
+        {
+            DWORD dwBytes;
+            if (!QueryServiceStatusEx(hSvc,
+                                      SC_STATUS_PROCESS_INFO,
+                                      (LPBYTE)&enmSvcSts,
+                                      sizeof(SERVICE_STATUS_PROCESS),
+                                      &dwBytes))
+            {
+                rc = vboxWinDrvInstLogLastError(pCtx, "Failed to query service status");
+                break;
+            }
+
+            if ((RTTimeMilliTS() - msStartTS) % RT_MS_1SEC == 0) /* Don't spam. */
+                vboxWinDrvInstLogVerbose(pCtx, 3, "Service '%s' status is %#x: %u",
+                                         pszService, enmSvcSts.dwCurrentState, (RTTimeMilliTS() - msStartTS) % 100 == 0);
+
+            switch (enmSvcSts.dwCurrentState)
+            {
+                case SERVICE_STOP_PENDING:
+                case SERVICE_START_PENDING:
+                    RTThreadSleep(100); /* Wait a bit before retrying. */
+                    break;
+
+                case SERVICE_RUNNING:
+                {
+                    if (enmFn == VBOXWINDRVSVCFN_START)
+                        rc = VINF_SUCCESS;
+                    break;
+                }
+
+                case SERVICE_STOPPED:
+                {
+                    if (enmFn == VBOXWINDRVSVCFN_START)
+                    {
+                        vboxWinDrvInstLogError(pCtx, "Service '%s' stopped unexpectedly", pszService);
+                        rc = VERR_INVALID_STATE;
+                    }
+                    else
+                        rc = VINF_SUCCESS;
+                    break;
+                }
+
+                default:
+                {
+                    vboxWinDrvInstLogError(pCtx, "Service '%s' reported an unexpected state (%#x)",
+                                           pszService, enmSvcSts.dwCurrentState);
+                    rc = VERR_INVALID_STATE;
+                }
+            }
+
+            if (   RT_FAILURE(rc)
+                && rc != VERR_NO_CHANGE)
+                break;
+
+            if (RT_SUCCESS(rc))
+                break;
+
+            if (RTTimeMilliTS() - msStartTS >= msTimeout)
+            {
+                vboxWinDrvInstLogError(pCtx, "Waiting for service '%s' timed out (%ums)", pszService, msTimeout);
+                rc = VERR_TIMEOUT;
+                break;
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+            vboxWinDrvInstLogInfo(pCtx, "Service '%s' successfully %s",
+                                  pszService, enmFn == VBOXWINDRVSVCFN_START ? "started" : "stopped");
+    }
+    else
+        vboxWinDrvInstLogVerbose(pCtx, 1, "Service '%s' was %s asynchronously",
+                                 pszService, enmFn == VBOXWINDRVSVCFN_START ? "started" : "stopped");
+
+    RTUtf16Free(pwszService);
+    CloseServiceHandle(hSvc);
+    CloseServiceHandle(hSCM);
+    return rc;
+}
+
+/**
+ * Controls a Windows service, extended version.
+ *
+ * @returns VBox status code.
+ * @param   hDrvInst            Windows driver installer handle to use.
+ * @param   pszService          Name of service to control.
+ * @param   enmFn               Service control function to use.
+ * @param   fFlags              Service control flags (of type VBOXWINDRVSVCFN_F_XXX) to use.
+ * @param   msTimeout           Timeout (in ms) to use. Only being used if VBOXWINDRVSVCFN_F_WAIT is specified in \a fFlags.
+ */
+int VBooxWinDrvInstControlServiceEx(VBOXWINDRVINST hDrvInst,
+                                    const char *pszService, VBOXWINDRVSVCFN enmFn, uint32_t fFlags, RTMSINTERVAL msTimeout)
+{
+    PVBOXWINDRVINSTINTERNAL pCtx = hDrvInst;
+    VBOXWINDRVINST_VALID_RETURN(pCtx);
+
+#define CONTROL_SERVICE(a_Fn) \
+    vbooxWinDrvInstControlServiceEx(pCtx, pszService, a_Fn, fFlags, msTimeout);
+
+    int rc;
+    if (enmFn == VBOXWINDRVSVCFN_RESTART)
+    {
+        rc = CONTROL_SERVICE(VBOXWINDRVSVCFN_STOP);
+        if (RT_SUCCESS(rc))
+            rc = CONTROL_SERVICE(VBOXWINDRVSVCFN_START);
+    }
+    else
+        rc = CONTROL_SERVICE(enmFn);
+
+#undef CONTROL_SERVICE
+    return rc;
+}
+
+/**
+ * Controls a Windows service.
+ *
+ * @returns VBox status code.
+ * @param   hDrvInst            Windows driver installer handle to use.
+ * @param   pszService          Name of service to control.
+ * @param   enmFn               Service control function to use.
+ *
+ * @note    Function waits 30s for the service to reach the desired control function.
+ *          Use VBooxWinDrvInstControlServiceEx() for more flexibility.
+ */
+int VBoxWinDrvInstControlService(VBOXWINDRVINST hDrvInst, const char *pszService, VBOXWINDRVSVCFN enmFn)
+{
+    PVBOXWINDRVINSTINTERNAL pCtx = hDrvInst;
+    VBOXWINDRVINST_VALID_RETURN(pCtx);
+
+    return VBooxWinDrvInstControlServiceEx(pCtx, pszService, enmFn, VBOXWINDRVSVCFN_F_WAIT, RT_MS_30SEC);
+}
+
 #ifdef TESTCASE
 /**