Add a utility function to run a process as an arbitrary user...

base/process_util_win.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process_util.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <windows.h>
+#include <userenv.h>
 #include <psapi.h>
 
 #include <ios>
 
 #include "base/debug_util.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/scoped_handle_win.h"
 #include "base/scoped_ptr.h"
 
+// userenv.dll is required for CreateEnvironmentBlock().
+#pragma comment(lib, "userenv.lib")
+
 namespace base {
 
 namespace {
 
 // System pagesize. This value remains constant on x86/64 architectures.
 const int PAGESIZE_KB = 4;
 
 // HeapSetInformation function pointer.
 typedef BOOL (WINAPI* HeapSetFn)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
 
@@ skipping 125 matching lines @@
 
   // If the caller wants the process handle, we won't close it.
   if (process_handle) {
     *process_handle = process_info.hProcess;
   } else {
     CloseHandle(process_info.hProcess);
   }
   return true;
 }
 
+
+bool LaunchAppAsUser(UserTokenHandle token, const std::wstring& cmdline,
+                     bool start_hidden, ProcessHandle* process_handle) {

[ananta, 2010/02/01 00:52:29]

Would it make sense to take in the desired STARTUPINFO as a parameter instead?

+  STARTUPINFO startup_info = {0};
+  startup_info.cb = sizeof(startup_info);
+  PROCESS_INFORMATION process_info;
+  if (start_hidden) {
+    startup_info.dwFlags = STARTF_USESHOWWINDOW;
+    startup_info.wShowWindow = SW_HIDE;
+  }
+  DWORD flags = CREATE_UNICODE_ENVIRONMENT;
+  void* enviroment_block = NULL;
+
+  if(!CreateEnvironmentBlock(&enviroment_block, token, FALSE))
+    return false;
+
+  BOOL launched =
+      CreateProcessAsUser(token, NULL, const_cast<wchar_t*>(cmdline.c_str()),
+                          NULL, NULL, FALSE, flags, enviroment_block,
+                          NULL, &startup_info, &process_info);
+
+  DestroyEnvironmentBlock(enviroment_block);
+
+  if (!launched)
+    return false;
+
+  CloseHandle(process_info.hThread);
+
+  if (process_handle) {
+    *process_handle = process_info.hProcess;
+  } else {
+    CloseHandle(process_info.hProcess);
+  }
+  return true;
+}
+
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
   return LaunchApp(cl.command_line_string(), wait,
                    start_hidden, process_handle);
 }
 
 // Attempts to kill the process identified by the given process
 // entry structure, giving it the specified exit code.
 // Returns true if this is successful, false otherwise.
 bool KillProcessById(ProcessId process_id, int exit_code, bool wait) {
@@ skipping 591 matching lines @@
 
   PERFORMANCE_INFORMATION info;
   if (!InternalGetPerformanceInfo(&info, sizeof(info))) {
     LOG(ERROR) << "Failed to fetch internal performance info.";
     return 0;
   }
   return (info.CommitTotal * system_info.dwPageSize) / 1024;
 }
 
 }  // namespace base