Changeset 57843 in vbox for trunk

Timestamp:

Sep 21, 2015 4:14:20 PM (9 years ago)

Author:

vboxsync

Message:

RTProcCreateEx/win: Implemented RTPROC_FLAGS_PROFILE and RTPROC_FLAGS_ENV_CHANGE_RECORD when pszUser is NULL, fixed the RTPROC_FLAGS_SEARCH_PATH behavior for those flags.

Location:

trunk

Files:

• include/iprt/process.h (modified) (1 diff)
• src/VBox/Runtime/r3/win/process-win.cpp (modified) (15 diffs)
• src/VBox/Runtime/testcase/tstRTProcCreateEx.cpp (modified) (6 diffs)

trunk/include/iprt/process.h

@@ -200 +200 @@
 /** Load user profile data when executing a process.
  * This redefines the meaning of RTENV_DEFAULT to the profile environment.
- * This bit is at the moment only supported on Windows using the RTProcCreateEx
- * with a user specified. */
+ * This bit is at the moment only supported on Windows. */
 #define RTPROC_FLAGS_PROFILE                RT_BIT(4)
 /** Create process without a console window.

trunk/src/VBox/Runtime/r3/win/process-win.cpp

@@ -132 +132 @@
 
 
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static int rtProcWinFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec, PRTUTF16 *ppwszExec);
 
 
@@ -640 +644 @@
  * Logs on a specified user and returns its primary token.
  *
- * @return  int
+ * @returns IPRT status code.
  * @param   pwszUser            User name.
  * @param   pwszPassword        Password.
@@ -750 +754 @@
 
 
-
 /**
  * Method \#2.
  */
-static int rtProcWinCreateAsUser2(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszExec, PRTUTF16 pwszCmdLine,
+static int rtProcWinCreateAsUser2(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 *ppwszExec, PRTUTF16 pwszCmdLine,
                                   RTENV hEnv, DWORD dwCreationFlags,
-                                  STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, uint32_t fFlags)
+                                  STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo,
+                                  uint32_t fFlags, const char *pszExec)
 {
     /*
@@ -784 +788 @@
      * We may fail here with ERROR_PRIVILEGE_NOT_HELD.
      */
+/** @todo r=bird: Both methods starts with rtProcWinUserLogon, so we could probably do that once in the parent function, right... */
     DWORD   dwErr       = NO_ERROR;
     HANDLE  hTokenLogon = INVALID_HANDLE_VALUE;
@@ -858 +863 @@
                 if (fFlags & RTPROC_FLAGS_PROFILE)
                 {
-/* @todo r=bird: I'm not convinced that the unload function restores our original environment... */
                     ProfileInfo.dwSize     = sizeof(ProfileInfo);
                     ProfileInfo.lpUserName = pwszUser;
@@ -879 +883 @@
                         if (RT_SUCCESS(rc))
                         {
-                            /*
-                             * Useful KB articles:
-                             *      http://support.microsoft.com/kb/165194/
-                             *      http://support.microsoft.com/kb/184802/
-                             *      http://support.microsoft.com/kb/327618/
-                             */
-                            fRc = CreateProcessAsUserW(hTokenToUse,
-                                                       pwszExec,
-                                                       pwszCmdLine,
-                                                       NULL,         /* pProcessAttributes */
-                                                       NULL,         /* pThreadAttributes */
-                                                       TRUE,         /* fInheritHandles */
-                                                       dwCreationFlags,
-                                                       /** @todo Warn about exceeding 8192 bytes
-                                                        *        on XP and up. */
-                                                       pwszzBlock,   /* lpEnvironment */
-                                                       NULL,         /* pCurrentDirectory */
-                                                       pStartupInfo,
-                                                       pProcInfo);
-                            if (fRc)
-                                dwErr = NO_ERROR;
-                            else
-                                dwErr = GetLastError(); /* CreateProcessAsUserW() failed. */
+                            rc = rtProcWinFindExe(fFlags, hEnv, pszExec, ppwszExec);
+                            if (RT_SUCCESS(rc))
+                            {
+                                /*
+                                 * Useful KB articles:
+                                 *      http://support.microsoft.com/kb/165194/
+                                 *      http://support.microsoft.com/kb/184802/
+                                 *      http://support.microsoft.com/kb/327618/
+                                 */
+                                fRc = CreateProcessAsUserW(hTokenToUse,
+                                                           *ppwszExec,
+                                                           pwszCmdLine,
+                                                           NULL,         /* pProcessAttributes */
+                                                           NULL,         /* pThreadAttributes */
+                                                           TRUE,         /* fInheritHandles */
+                                                           dwCreationFlags,
+                                                           /** @todo Warn about exceeding 8192 bytes
+                                                            *        on XP and up. */
+                                                           pwszzBlock,   /* lpEnvironment */
+                                                           NULL,         /* pCurrentDirectory */
+                                                           pStartupInfo,
+                                                           pProcInfo);
+                                if (fRc)
+                                    dwErr = NO_ERROR;
+                                else
+                                    dwErr = GetLastError(); /* CreateProcessAsUserW() failed. */
+                            }
                             RTEnvFreeUtf16Block(pwszzBlock);
                         }
@@ -953 +961 @@
  * platforms (however, this works on W2K!).
  */
-static int rtProcWinCreateAsUser1(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszExec, PRTUTF16 pwszCmdLine,
+static int rtProcWinCreateAsUser1(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 *ppwszExec, PRTUTF16 pwszCmdLine,
                                   RTENV hEnv, DWORD dwCreationFlags,
-                                  STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, uint32_t fFlags)
+                                  STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo,
+                                  uint32_t fFlags, const char *pszExec)
 {
     if (!g_pfnCreateProcessWithLogonW)
         return VERR_SYMBOL_NOT_FOUND;
 
-    RTENV  hEnvToUse;
+    RTENV  hEnvToUse = NIL_RTENV;
     HANDLE hToken;
     int rc = rtProcWinUserLogon(pwszUser, pwszPassword, NULL /* Domain */, &hToken);
     if (RT_SUCCESS(rc))
     {
-        rc = rtProcWinCreateEnvFromToken(hToken, hEnv, fFlags, &hEnvToUse);
+/** @todo r=bird: Why didn't we load the environment here?  The
+ *       CreateEnvironmentBlock docs indicate that USERPROFILE isn't set
+ *       unless we call LoadUserProfile first.  However, experiments here on W10
+ *       shows it isn't really needed though. Weird. */
+#if 0
+        if (fFlags & RTPROC_FLAGS_PROFILE)
+        {
+            PROFILEINFOW ProfileInfo;
+            RT_ZERO(ProfileInfo);
+            ProfileInfo.dwSize     = sizeof(ProfileInfo);
+            ProfileInfo.lpUserName = pwszUser;
+            ProfileInfo.dwFlags    = PI_NOUI; /* Prevents the display of profile error messages. */
+
+            if (g_pfnLoadUserProfileW(hToken, &ProfileInfo))
+            {
+                rc = rtProcWinCreateEnvFromToken(hToken, hEnv, fFlags, &hEnvToUse);
+
+                if (!g_pfnUnloadUserProfile(hToken, ProfileInfo.hProfile))
+                    AssertFailed();
+            }
+            else
+                rc = RTErrConvertFromWin32(GetLastError());
+        }
+        else
+#endif
+            rc = rtProcWinCreateEnvFromToken(hToken, hEnv, fFlags, &hEnvToUse);
         CloseHandle(hToken);
     }
@@ -974 +1008 @@
         if (RT_SUCCESS(rc))
         {
-            BOOL fRc = g_pfnCreateProcessWithLogonW(pwszUser,
-                                                    NULL,                       /* lpDomain*/
-                                                    pwszPassword,
-                                                    1 /*LOGON_WITH_PROFILE*/,   /* dwLogonFlags */
-                                                    pwszExec,
-                                                    pwszCmdLine,
-                                                    dwCreationFlags,
-                                                    pwszzBlock,
-                                                    NULL,                       /* pCurrentDirectory */
-                                                    pStartupInfo,
-                                                    pProcInfo);
-            if (fRc)
-                rc = VINF_SUCCESS;
-            else
+            rc = rtProcWinFindExe(fFlags, hEnv, pszExec, ppwszExec);
+            if (RT_SUCCESS(rc))
             {
-                DWORD dwErr = GetLastError();
-                rc = rtProcWinMapErrorCodes(dwErr);
-                if (rc == VERR_UNRESOLVED_ERROR)
-                    LogRelFunc(("g_pfnCreateProcessWithLogonW (%p) failed: dwErr=%u (%#x), rc=%Rrc\n",
-                                g_pfnCreateProcessWithLogonW, dwErr, dwErr, rc));
+                BOOL fRc = g_pfnCreateProcessWithLogonW(pwszUser,
+                                                        NULL,                       /* lpDomain*/
+                                                        pwszPassword,
+/** @todo r=bird: Not respecting the RTPROF_FLAGS_PROFILE flag here.  */
+                                                        1 /*LOGON_WITH_PROFILE*/,   /* dwLogonFlags */
+                                                        *ppwszExec,
+                                                        pwszCmdLine,
+                                                        dwCreationFlags,
+                                                        pwszzBlock,
+                                                        NULL,                       /* pCurrentDirectory */
+                                                        pStartupInfo,
+                                                        pProcInfo);
+                if (fRc)
+                    rc = VINF_SUCCESS;
+                else
+                {
+                    DWORD dwErr = GetLastError();
+                    rc = rtProcWinMapErrorCodes(dwErr);
+                    if (rc == VERR_UNRESOLVED_ERROR)
+                        LogRelFunc(("g_pfnCreateProcessWithLogonW (%p) failed: dwErr=%u (%#x), rc=%Rrc\n",
+                                    g_pfnCreateProcessWithLogonW, dwErr, dwErr, rc));
+                }
             }
             RTEnvFreeUtf16Block(pwszzBlock);
@@ -1004 +1043 @@
 
 
-static int rtProcWinCreateAsUser(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszExec, PRTUTF16 pwszCmdLine,
+static int rtProcWinCreateAsUser(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 *ppwszExec, PRTUTF16 pwszCmdLine,
                                  RTENV hEnv, DWORD dwCreationFlags,
-                                 STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, uint32_t fFlags)
+                                 STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo,
+                                 uint32_t fFlags, const char *pszExec)
 {
     /*
@@ -1015 +1055 @@
     if (!(fFlags & RTPROC_FLAGS_SERVICE))
     {
-        int rc = rtProcWinCreateAsUser1(pwszUser, pwszPassword, pwszExec, pwszCmdLine,
-                                        hEnv, dwCreationFlags, pStartupInfo, pProcInfo, fFlags);
+        int rc = rtProcWinCreateAsUser1(pwszUser, pwszPassword, ppwszExec, pwszCmdLine,
+                                        hEnv, dwCreationFlags, pStartupInfo, pProcInfo, fFlags, pszExec);
         if (RT_SUCCESS(rc))
             return rc;
     }
-    return rtProcWinCreateAsUser2(pwszUser, pwszPassword, pwszExec, pwszCmdLine,
-                                  hEnv, dwCreationFlags, pStartupInfo, pProcInfo, fFlags);
+    return rtProcWinCreateAsUser2(pwszUser, pwszPassword, ppwszExec, pwszCmdLine,
+                                  hEnv, dwCreationFlags, pStartupInfo, pProcInfo, fFlags, pszExec);
 }
 
 
 /**
- * RTPathTraverseList callback used by RTProcCreateEx to locate the executable.
+ * RTPathTraverseList callback used by rtProcWinFindExe to locate the
+ * executable.
  */
 static DECLCALLBACK(int) rtPathFindExec(char const *pchPath, size_t cchPath, void *pvUser1, void *pvUser2)
@@ -1041 +1082 @@
 
 
+/**
+ * Locate the executable file if necessary.
+ *
+ * @returns IPRT status code.
+ * @param   pszExec         The UTF-8 executable string passed in by the user.
+ * @param   fFlags          The process creation flags pass in by the user.
+ * @param   hEnv            The environment to get the path variabel from.
+ * @param   ppwszExec       Pointer to the variable pointing to the UTF-16
+ *                          converted string.  If we find something, the current
+ *                          pointer will be free (RTUtf16Free) and
+ *                          replaced by a new one.
+ */
+static int rtProcWinFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec, PRTUTF16 *ppwszExec)
+{
+    /*
+     * Return immediately if we're not asked to search, or if the file has a
+     * path already or if it actually exists in the current directory.
+     */
+    if (   !(fFlags & RTPROC_FLAGS_SEARCH_PATH)
+        || RTPathHavePath(pszExec)
+        || RTPathExists(pszExec) )
+        return VINF_SUCCESS;
+
+    /*
+     * Search the Path or PATH variable for the file.
+     */
+    char *pszPath;
+    if (RTEnvExistEx(hEnv, "PATH"))
+        pszPath = RTEnvDupEx(hEnv, "PATH");
+    else if (RTEnvExistEx(hEnv, "Path"))
+        pszPath = RTEnvDupEx(hEnv, "Path");
+    else
+        return VERR_FILE_NOT_FOUND;
+
+    char szRealExec[RTPATH_MAX];
+    int rc = RTPathTraverseList(pszPath, ';', rtPathFindExec, (void *)pszExec, &szRealExec[0]);
+    RTStrFree(pszPath);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Replace the executable string.
+         */
+        RTUtf16Free(*ppwszExec);
+        *ppwszExec = NULL;
+        rc = RTStrToUtf16(szRealExec, ppwszExec);
+    }
+    else if (rc == VERR_END_OF_STRING)
+        rc = VERR_FILE_NOT_FOUND;
+    return rc;
+}
+
+
+/**
+ * Creates the UTF-16 environment block and, if necessary, find the executable.
+ *
+ * @returns IPRT status code.
+ * @param   fFlags          The process creation flags pass in by the user.
+ * @param   hEnv            The environment handle passed by the user.
+ * @param   pszExec         See rtProcWinFindExe.
+ * @param   ppwszzBlock     Where RTEnvQueryUtf16Block returns the block.
+ * @param   ppwszExec       See rtProcWinFindExe.
+ */
+static int rtProcWinCreateEnvBlockAndFindExe(uint32_t fFlags, RTENV hEnv, const char *pszExec,
+                                             PRTUTF16 *ppwszzBlock, PRTUTF16 *ppwszExec)
+{
+    int rc;
+
+    /*
+     * In most cases, we just need to convert the incoming enviornment to a
+     * UTF-16 environment block.
+     */
+    RTENV hEnvToUse;
+    if (   !(fFlags & (RTPROC_FLAGS_PROFILE | RTPROC_FLAGS_ENV_CHANGE_RECORD))
+        || (hEnv == RTENV_DEFAULT && !(fFlags & RTPROC_FLAGS_PROFILE))
+        || (hEnv != RTENV_DEFAULT && !(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD)) )
+        hEnvToUse = hEnv;
+    else if (fFlags & RTPROC_FLAGS_PROFILE)
+    {
+        /*
+         * We need to get the profile environment for the current user.
+         */
+        Assert((fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD) || hEnv == RTENV_DEFAULT);
+        AssertReturn(g_pfnCreateEnvironmentBlock && g_pfnDestroyEnvironmentBlock, VERR_SYMBOL_NOT_FOUND);
+        AssertReturn(g_pfnLoadUserProfileW && g_pfnUnloadUserProfile, VERR_SYMBOL_NOT_FOUND);
+        HANDLE hToken;
+        if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE, &hToken))
+        {
+            rc = rtProcWinCreateEnvFromToken(hToken, hEnv, fFlags, &hEnvToUse);
+            CloseHandle(hToken);
+        }
+        else
+            rc = RTErrConvertFromWin32(GetLastError());
+    }
+    else
+    {
+        /*
+         * Apply hEnv as a change record on top of the default environment.
+         */
+        Assert(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD);
+        rc = RTEnvClone(&hEnvToUse, RTENV_DEFAULT);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTEnvApplyChanges(hEnvToUse, hEnv);
+            if (RT_FAILURE(rc))
+                RTEnvDestroy(hEnvToUse);
+        }
+    }
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Query the UTF-16 environment block and locate the executable (if needed).
+         */
+        rc = RTEnvQueryUtf16Block(hEnvToUse, ppwszzBlock);
+        if (RT_SUCCESS(rc))
+            rc = rtProcWinFindExe(fFlags, hEnvToUse, pszExec, ppwszExec);
+
+        if (hEnvToUse != hEnv)
+            RTEnvDestroy(hEnvToUse);
+    }
+
+    return rc;
+}
+
+
 RTR3DECL(int)   RTProcCreateEx(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,
                                PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser,
@@ -1053 +1218 @@
     AssertReturn(!(fFlags & RTPROC_FLAGS_DETACHED) || !phProcess, VERR_INVALID_PARAMETER);
     AssertReturn(hEnv != NIL_RTENV, VERR_INVALID_PARAMETER);
-    AssertReturn(   !(fFlags & RTPROC_FLAGS_PROFILE) /* Profile flag isn't fully implemented in all cases: */
-                 || pszAsUser
-                 || (hEnv != RTENV_DEFAULT && !(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD)), VERR_NOT_SUPPORTED);
     AssertPtrReturn(papszArgs, VERR_INVALID_PARAMETER);
     AssertPtrNullReturn(pszAsUser, VERR_INVALID_POINTER);
@@ -1071 +1233 @@
         rc = RTOnce(&g_rtProcWinResolveOnce, rtProcWinResolveOnce, NULL);
         AssertRCReturn(rc, rc);
-    }
-
-    /*
-     * Resolve the executable name via the PATH if requested.
-     */
-    char szRealExec[RTPATH_MAX];
-    if (   (fFlags & RTPROC_FLAGS_SEARCH_PATH)
-        && !RTPathHavePath(pszExec)
-        && !RTPathExists(pszExec) )
-    {
-        /* search */
-/** @todo RTPROC_FLAGS_PROFILE/win: Could be searching the wrong PATH/Path env var for executable. */
-        char *pszPath;
-        if (RTEnvExistEx(hEnv, "PATH"))
-            pszPath = RTEnvDupEx(hEnv, "PATH");
-        else if (RTEnvExistEx(hEnv, "Path"))
-            pszPath = RTEnvDupEx(hEnv, "Path");
-        else if (   !(fFlags & RTPROC_FLAGS_ENV_CHANGE_RECORD)
-                 || hEnv == RTENV_DEFAULT)
-            return VERR_FILE_NOT_FOUND;
-        else if (RTEnvExistEx(RTENV_DEFAULT, "PATH"))
-            pszPath = RTEnvDupEx(RTENV_DEFAULT, "PATH");
-        else if (RTEnvExistEx(RTENV_DEFAULT, "Path"))
-            pszPath = RTEnvDupEx(RTENV_DEFAULT, "Path");
-        else
-            return VERR_FILE_NOT_FOUND;
-        rc = RTPathTraverseList(pszPath, ';', rtPathFindExec, (void *)pszExec, &szRealExec[0]);
-        RTStrFree(pszPath);
-        if (RT_FAILURE(rc))
-            return rc == VERR_END_OF_STRING ? VERR_FILE_NOT_FOUND : rc;
-        pszExec = szRealExec;
     }
 
@@ -1191 +1322 @@
 
     /*
-     * Create the environment block, command line and convert the executable
-     * name.
-     */
-/** @todo this environment creation isn't needed for the rtProcWinCreateAsUser case...  Also, we need to take the _PROFILE and _CHANGE_RECORD flags into account here */
-    PRTUTF16 pwszzBlock;
+     * Create the command line and convert the executable name.
+     */
+    PRTUTF16 pwszCmdLine;
     if (RT_SUCCESS(rc))
-        rc = RTEnvQueryUtf16Block(hEnv, &pwszzBlock);
-    if (RT_SUCCESS(rc))
-    {
-        PRTUTF16 pwszCmdLine;
         rc = RTGetOptArgvToUtf16String(&pwszCmdLine, papszArgs,
                                        !(fFlags & RTPROC_FLAGS_UNQUOTED_ARGS)
                                        ? RTGETOPTARGV_CNV_QUOTE_MS_CRT : RTGETOPTARGV_CNV_UNQUOTED);
+    if (RT_SUCCESS(rc))
+    {
+        PRTUTF16 pwszExec;
+        rc = RTStrToUtf16(pszExec, &pwszExec);
         if (RT_SUCCESS(rc))
         {
-            PRTUTF16 pwszExec;
-            rc = RTStrToUtf16(pszExec, &pwszExec);
-            if (RT_SUCCESS(rc))
+            /*
+             * Get going...
+             */
+            PROCESS_INFORMATION ProcInfo;
+            RT_ZERO(ProcInfo);
+            DWORD dwCreationFlags = CREATE_UNICODE_ENVIRONMENT;
+            if (fFlags & RTPROC_FLAGS_DETACHED)
+                dwCreationFlags |= DETACHED_PROCESS;
+            if (fFlags & RTPROC_FLAGS_NO_WINDOW)
+                dwCreationFlags |= CREATE_NO_WINDOW;
+
+            /*
+             * Only use the normal CreateProcess stuff if we have no user name
+             * and we are not running from a (Windows) service. Otherwise use
+             * the more advanced version in rtProcWinCreateAsUser().
+             */
+            if (   pszAsUser == NULL
+                && !(fFlags & RTPROC_FLAGS_SERVICE))
             {
-                /*
-                 * Get going...
-                 */
-                PROCESS_INFORMATION ProcInfo;
-                RT_ZERO(ProcInfo);
-                DWORD dwCreationFlags = CREATE_UNICODE_ENVIRONMENT;
-                if (fFlags & RTPROC_FLAGS_DETACHED)
-                    dwCreationFlags |= DETACHED_PROCESS;
-                if (fFlags & RTPROC_FLAGS_NO_WINDOW)
-                    dwCreationFlags |= CREATE_NO_WINDOW;
-
-                /*
-                 * Only use the normal CreateProcess stuff if we have no user name
-                 * and we are not running from a (Windows) service. Otherwise use
-                 * the more advanced version in rtProcWinCreateAsUser().
-                 */
-                if (   pszAsUser == NULL
-                    && !(fFlags & RTPROC_FLAGS_SERVICE))
+                /* Create the environment block first. */
+                PRTUTF16 pwszzBlock;
+                rc = rtProcWinCreateEnvBlockAndFindExe(fFlags, hEnv, pszExec, &pwszzBlock, &pwszExec);
+                if (RT_SUCCESS(rc))
                 {
                     if (CreateProcessW(pwszExec,
@@ -1242 +1372 @@
                     else
                         rc = RTErrConvertFromWin32(GetLastError());
+                    RTEnvFreeUtf16Block(pwszzBlock);
+                }
+            }
+            else
+            {
+                /*
+                 * Convert the additional parameters and use a helper
+                 * function to do the actual work.
+                 */
+                PRTUTF16 pwszUser;
+                rc = RTStrToUtf16(pszAsUser, &pwszUser);
+                if (RT_SUCCESS(rc))
+                {
+                    PRTUTF16 pwszPassword;
+                    rc = RTStrToUtf16(pszPassword ? pszPassword : "", &pwszPassword);
+                    if (RT_SUCCESS(rc))
+                    {
+                        rc = rtProcWinCreateAsUser(pwszUser, pwszPassword,
+                                                   &pwszExec, pwszCmdLine, hEnv, dwCreationFlags,
+                                                   &StartupInfo, &ProcInfo, fFlags, pszExec);
+
+                        if (pwszPassword && *pwszPassword)
+                            RTMemWipeThoroughly(pwszPassword, RTUtf16Len(pwszPassword), 5);
+                        RTUtf16Free(pwszPassword);
+                    }
+                    RTUtf16Free(pwszUser);
+                }
+            }
+            if (RT_SUCCESS(rc))
+            {
+                CloseHandle(ProcInfo.hThread);
+                if (phProcess)
+                {
+                    /*
+                     * Add the process to the child process list so
+                     * RTProcWait can reuse and close the process handle.
+                     */
+                    rtProcWinAddPid(ProcInfo.dwProcessId, ProcInfo.hProcess);
+                    *phProcess = ProcInfo.dwProcessId;
                 }
                 else
-                {
-                    /*
-                     * Convert the additional parameters and use a helper
-                     * function to do the actual work.
-                     */
-                    PRTUTF16 pwszUser;
-                    rc = RTStrToUtf16(pszAsUser, &pwszUser);
-                    if (RT_SUCCESS(rc))
-                    {
-                        PRTUTF16 pwszPassword;
-                        rc = RTStrToUtf16(pszPassword ? pszPassword : "", &pwszPassword);
-                        if (RT_SUCCESS(rc))
-                        {
-                            rc = rtProcWinCreateAsUser(pwszUser, pwszPassword,
-                                                       pwszExec, pwszCmdLine, hEnv, dwCreationFlags,
-                                                       &StartupInfo, &ProcInfo, fFlags);
-
-                            if (pwszPassword && *pwszPassword)
-                                RTMemWipeThoroughly(pwszPassword, RTUtf16Len(pwszPassword), 5);
-                            RTUtf16Free(pwszPassword);
-                        }
-                        RTUtf16Free(pwszUser);
-                    }
-                }
-                if (RT_SUCCESS(rc))
-                {
-                    CloseHandle(ProcInfo.hThread);
-                    if (phProcess)
-                    {
-                        /*
-                         * Add the process to the child process list so
-                         * RTProcWait can reuse and close the process handle.
-                         */
-                        rtProcWinAddPid(ProcInfo.dwProcessId, ProcInfo.hProcess);
-                        *phProcess = ProcInfo.dwProcessId;
-                    }
-                    else
-                        CloseHandle(ProcInfo.hProcess);
-                    rc = VINF_SUCCESS;
-                }
-                RTUtf16Free(pwszExec);
+                    CloseHandle(ProcInfo.hProcess);
+                rc = VINF_SUCCESS;
             }
-            RTUtf16Free(pwszCmdLine);
-        }
-        RTEnvFreeUtf16Block(pwszzBlock);
+            RTUtf16Free(pwszExec);
+        }
+        RTUtf16Free(pwszCmdLine);
     }
 

trunk/src/VBox/Runtime/testcase/tstRTProcCreateEx.cpp

@@ -54 +54 @@
 *   Global Variables                                                                                                             *
 *********************************************************************************************************************************/
-static char g_szExecName[RTPATH_MAX];
+static RTENV g_hEnvInitial = NIL_RTENV;
+static char  g_szExecName[RTPATH_MAX];
 
 
@@ -82 +83 @@
 
 
+static int tstRTCreateProcEx6Child(int argc, char **argv)
+{
+    int rc = RTR3InitExeNoArguments(0);
+    if (RT_FAILURE(rc))
+        return RTMsgInitFailure(rc);
+
+    int cErrors = 0;
+    char szValue[_1K];
+
+    /*
+     * Check for the environment variable we've set in the parent process.
+     */
+    if (argc >= 3 && strcmp(argv[2], "inherit") == 0)
+    {
+        if (!RTEnvExistEx(RTENV_DEFAULT, "testcase-child-6"))
+        {
+            RTStrmPrintf(g_pStdErr, "child6: Env.var. 'testcase-child-6' was not inherited from parent\n");
+            cErrors++;
+        }
+    }
+    else if (argc >= 3 && strstr(argv[2], "change-record") != NULL)
+    {
+        rc = RTEnvGetEx(RTENV_DEFAULT, "testcase-child-6", szValue, sizeof(szValue), NULL);
+        if (RT_SUCCESS(rc) && strcmp(szValue, "changed"))
+        {
+            RTStrmPrintf(g_pStdErr, "child6: Env.var. 'testcase-child-6'='%s', expected 'changed'.\n", szValue);
+            cErrors++;
+        }
+        else if (RT_FAILURE(rc))
+        {
+            RTStrmPrintf(g_pStdErr, "child6: RTEnvGetEx(,'testcase-child-6',,) -> %Rrc\n", rc);
+            cErrors++;
+        }
+    }
+    else
+    {
+        if (RTEnvExistEx(RTENV_DEFAULT, "testcase-child-6"))
+        {
+            RTStrmPrintf(g_pStdErr, "child6: Env.var. 'testcase-child-6' was inherited from parent\n");
+            cErrors++;
+        }
+    }
+
+    /*
+     * Check the user name if present we didn't inherit from parent.
+     */
+    if (   argc >= 4
+        && argv[3][0] != '\0'
+        && strstr(argv[2], "noinherit") != NULL)
+    {
+        static struct
+        {
+            const char *pszVarNm;
+            bool fReq;
+        } const s_aVars[] =
+        {
+#ifdef RT_OS_WINDOWS
+            { "USERNAME", true },
+#else
+            { "LOGNAME",  true },
+            { "USER",    false },
+#endif
+        };
+        for (unsigned i = 0; i < RT_ELEMENTS(s_aVars); i++)
+        {
+            rc = RTEnvGetEx(RTENV_DEFAULT, s_aVars[i].pszVarNm, szValue, sizeof(szValue), NULL);
+            if (RT_SUCCESS(rc))
+            {
+                if (strcmp(szValue, argv[3]))
+                {
+                    RTStrmPrintf(g_pStdErr, "child6: env.var. '%s'='%s', expected '%s'\n",
+                                 s_aVars[i].pszVarNm, szValue, argv[3]);
+                    cErrors++;
+                }
+            }
+            else if (rc != VERR_ENV_VAR_NOT_FOUND || s_aVars[i].fReq)
+            {
+                RTStrmPrintf(g_pStdErr, "child6: RTGetEnv('%s') -> %Rrc\n", s_aVars[i].pszVarNm, rc);
+                cErrors++;
+            }
+        }
+    }
+
+#if 0
+    /* For manual testing. */
+    if (strcmp(argv[2],"noinherit-change-record") == 0)
+    {
+        RTENV hEnv;
+        rc = RTEnvClone(&hEnv, RTENV_DEFAULT);
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t cVars = RTEnvCountEx(hEnv);
+            for (uint32_t i = 0; i < cVars; i++)
+            {
+                char szVarNm[_1K];
+                char szValue[_16K];
+                rc = RTEnvGetByIndexEx(hEnv, i, szVarNm, sizeof(szVarNm), szValue, sizeof(szValue));
+                if (RT_SUCCESS(rc))
+                    RTStrmPrintf(g_pStdErr, "child6: #%u: %s=%s\n", i, szVarNm, szValue);
+                else
+                {
+                    RTStrmPrintf(g_pStdErr, "child6: #%u: %Rrc\n", rc);
+                    cErrors++;
+                }
+            }
+            RTEnvDestroy(hEnv);
+        }
+        else
+        {
+            RTStrmPrintf(g_pStdErr, "child6: RTEnvClone failed: %Rrc\n", rc);
+            cErrors++;
+        }
+    }
+#endif
+
+    return cErrors == 0 ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
+}
+
+static void tstRTCreateProcEx6(const char *pszAsUser, const char *pszPassword)
+{
+    RTTestISub("Profile environment");
+
+    const char *apszArgs[5] =
+    {
+        g_szExecName,
+        "--testcase-child-6",
+        "inherit",
+        pszAsUser,
+        NULL
+    };
+
+    RTTESTI_CHECK_RC_RETV(RTEnvSetEx(RTENV_DEFAULT, "testcase-child-6", "true"), VINF_SUCCESS);
+
+    /* Use the process environment first. */
+    RTPROCESS hProc;
+    RTTESTI_CHECK_RC_RETV(RTProcCreateEx(g_szExecName, apszArgs, RTENV_DEFAULT, 0 /*fFlags*/,
+                                         NULL, NULL, NULL, pszAsUser, pszPassword, &hProc), VINF_SUCCESS);
+    RTPROCSTATUS ProcStatus = { -1, RTPROCEXITREASON_ABEND };
+    RTTESTI_CHECK_RC(RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus), VINF_SUCCESS);
+
+    if (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0)
+        RTTestIFailed("enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+
+    /* Use the process environment first with a little change. */
+    apszArgs[2] = "change-record";
+    RTENV hEnvChange;
+    RTTESTI_CHECK_RC_RETV(RTEnvCreateChangeRecord(&hEnvChange), VINF_SUCCESS);
+    RTTESTI_CHECK_RC_RETV(RTEnvSetEx(hEnvChange, "testcase-child-6", "changed"), VINF_SUCCESS);
+    RTTESTI_CHECK_RC_RETV(RTProcCreateEx(g_szExecName, apszArgs, hEnvChange, RTPROC_FLAGS_ENV_CHANGE_RECORD,
+                                         NULL, NULL, NULL, pszAsUser, pszPassword, &hProc), VINF_SUCCESS);
+    ProcStatus.enmReason = RTPROCEXITREASON_ABEND;
+    ProcStatus.iStatus   = -1;
+    RTTESTI_CHECK_RC(RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus), VINF_SUCCESS);
+
+    if (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0)
+        RTTestIFailed("enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+
+
+    /* Use profile environment this time. */
+    apszArgs[2] = "noinherit";
+    RTTESTI_CHECK_RC_RETV(RTProcCreateEx(g_szExecName, apszArgs, RTENV_DEFAULT, RTPROC_FLAGS_PROFILE,
+                                         NULL, NULL, NULL, pszAsUser, pszPassword, &hProc), VINF_SUCCESS);
+    ProcStatus.enmReason = RTPROCEXITREASON_ABEND;
+    ProcStatus.iStatus   = -1;
+    RTTESTI_CHECK_RC(RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus), VINF_SUCCESS);
+
+    if (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0)
+        RTTestIFailed("enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+
+    /* Use profile environment this time. */
+    apszArgs[2] = "noinherit-change-record";
+    RTTESTI_CHECK_RC_RETV(RTProcCreateEx(g_szExecName, apszArgs, hEnvChange,
+                                         RTPROC_FLAGS_PROFILE | RTPROC_FLAGS_ENV_CHANGE_RECORD,
+                                         NULL, NULL, NULL, pszAsUser, pszPassword, &hProc), VINF_SUCCESS);
+    ProcStatus.enmReason = RTPROCEXITREASON_ABEND;
+    ProcStatus.iStatus   = -1;
+    RTTESTI_CHECK_RC(RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &ProcStatus), VINF_SUCCESS);
+
+    if (ProcStatus.enmReason != RTPROCEXITREASON_NORMAL || ProcStatus.iStatus != 0)
+        RTTestIFailed("enmReason=%d iStatus=%d", ProcStatus.enmReason, ProcStatus.iStatus);
+
+
+    RTTESTI_CHECK_RC(RTEnvDestroy(hEnvChange), VINF_SUCCESS);
+
+    /*
+     * Restore the environment and check that the PROFILE flag didn't mess with
+     * the process environment.  (Note! The bug may be elsewhere as well.)
+     */
+    RTTESTI_CHECK_RC(RTEnvUnsetEx(RTENV_DEFAULT, "testcase-child-6"), VINF_SUCCESS);
+
+    RTENV hEnvCur;
+    RTTESTI_CHECK_RC_RETV(RTEnvClone(&hEnvCur, RTENV_DEFAULT), VINF_SUCCESS);
+    uint32_t cCurrent = RTEnvCountEx(hEnvCur);
+    uint32_t cInitial = RTEnvCountEx(g_hEnvInitial);
+    RTTESTI_CHECK_MSG(cInitial == cInitial, ("cCurrent=%u cInitial=%u\n", cCurrent, cInitial));
+    uint32_t    cVars1;
+    RTENV       hEnv1,    hEnv2;
+    const char *pszEnv1, *pszEnv2;
+    if (cCurrent >= cInitial)
+    {
+        hEnv1   = hEnvCur;
+        pszEnv1 = "current";
+        cVars1  = cCurrent;
+        hEnv2   = g_hEnvInitial;
+        pszEnv2 = "initial";
+    }
+    else
+    {
+        hEnv2   = hEnvCur;
+        pszEnv2 = "current";
+        hEnv1   = g_hEnvInitial;
+        pszEnv1 = "initial";
+        cVars1  = cInitial;
+    }
+    for (uint32_t i = 0; i < cVars1; i++)
+    {
+        char szValue1[_16K];
+        char szVarNm[_1K];
+        int rc = RTEnvGetByIndexEx(hEnv1, i, szVarNm, sizeof(szVarNm), szValue1, sizeof(szValue1));
+        if (RT_SUCCESS(rc))
+        {
+            char szValue2[_16K];
+            rc = RTEnvGetEx(hEnv2, szVarNm, szValue2, sizeof(szValue2), NULL);
+            if (RT_SUCCESS(rc))
+            {
+                if (strcmp(szValue1, szValue2) != 0)
+                {
+                    RTTestIFailed("Variable '%s' differs", szVarNm);
+                    RTTestIFailureDetails("%s: '%s'\n"
+                                          "%s: '%s'\n",
+                                          pszEnv1, szValue1,
+                                          pszEnv2, szValue2);
+                }
+            }
+            else
+                RTTestIFailed("RTEnvGetEx(%s,%s,,) failed: %Rrc", pszEnv2, szVarNm, rc);
+
+        }
+        else
+            RTTestIFailed("RTEnvGetByIndexEx(%s,%u,,,,) failed: %Rrc", pszEnv1, i, rc);
+    }
+}
+
+
 static int tstRTCreateProcEx5Child(int argc, char **argv)
 {
@@ -410 +655 @@
 int main(int argc, char **argv)
 {
+    /*
+     * Deal with child processes first.
+     */
     if (argc == 2 && !strcmp(argv[1], "--testcase-child-1"))
         return tstRTCreateProcEx1Child();
@@ -420 +668 @@
     if (argc == 2 && !strcmp(argv[1], "--testcase-child-5"))
         return tstRTCreateProcEx5Child(argc, argv);
+    if (argc >= 2 && !strcmp(argv[1], "--testcase-child-6"))
+        return tstRTCreateProcEx6Child(argc, argv);
+
+
+    /*
+     * Main process.
+     */
     const char *pszAsUser   = NULL;
     const char *pszPassword = NULL;
@@ -436 +691 @@
     RTTestBanner(hTest);
 
+    /*
+     * Init globals.
+     */
     if (!RTProcGetExecutablePath(g_szExecName, sizeof(g_szExecName)))
         RTStrCopy(g_szExecName, sizeof(g_szExecName), argv[0]);
+    RTTESTI_CHECK_RC(RTEnvClone(&g_hEnvInitial, RTENV_DEFAULT), VINF_SUCCESS);
 
     /*
@@ -448 +707 @@
     if (pszAsUser)
         tstRTCreateProcEx5(pszAsUser, pszPassword);
+#ifdef RT_OS_WINDOWS
+    tstRTCreateProcEx6(pszAsUser, pszPassword);
+#endif
+
     /** @todo Cover files, ++ */
+
+    RTEnvDestroy(g_hEnvInitial);
 
     /*