Launches a privileged utility process.

base/process/launch_win.cc

 // Copyright (c) 2012 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/launch.h"
 
 #include <fcntl.h>
 #include <io.h>
 #include <windows.h>
 #include <userenv.h>
 #include <psapi.h>
+#include <Shellapi.h>
 
 #include <ios>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 73 matching lines @@
   if (freopen("CONOUT$", "w", stderr)) {
     setvbuf(stderr, NULL, _IOLBF, kOutputBufferSize);
     _dup2(_fileno(stderr), 2);
   }
 
   // Fix all cout, wcout, cin, wcin, cerr, wcerr, clog and wclog.
   std::ios::sync_with_stdio();
 }
 
 bool LaunchProcess(const string16& cmdline,
+                   const string16& file,
+                   const string16& arguments,
                    const LaunchOptions& options,
                    ProcessHandle* process_handle) {
   STARTUPINFO startup_info = {};
   startup_info.cb = sizeof(startup_info);
   if (options.empty_desktop_name)
     startup_info.lpDesktop = L"";
   startup_info.dwFlags = STARTF_USESHOWWINDOW;
   startup_info.wShowWindow = options.start_hidden ? SW_HIDE : SW_SHOW;
 
   if (options.stdin_handle || options.stdout_handle || options.stderr_handle) {
@@ skipping 16 matching lines @@
     // automatically associated with a job object created by the debugger.
     // The CREATE_BREAKAWAY_FROM_JOB flag is used to prevent this.
     flags |= CREATE_BREAKAWAY_FROM_JOB;
   }
 
   if (options.force_breakaway_from_job_)
     flags |= CREATE_BREAKAWAY_FROM_JOB;
 
   base::win::ScopedProcessInformation process_info;
 
-  if (options.as_user) {
-    flags |= CREATE_UNICODE_ENVIRONMENT;
-    void* enviroment_block = NULL;
+  if (options.run_elevated) {
+    SHELLEXECUTEINFO shex_info = {0};
+    shex_info.cbSize = sizeof(shex_info);
+    shex_info.fMask = SEE_MASK_NOCLOSEPROCESS;
+    shex_info.hwnd = NULL;

[mef, 2013/12/10 15:25:18]

We may have to set hwnd to something meaningful, otherwise UAC prompt may get
stuck behind active window (just quietly blinking on taskbar).

+    shex_info.lpVerb = L"runas";
+    shex_info.lpFile = file.c_str();
+    shex_info.lpParameters = arguments.c_str();
+    shex_info.lpDirectory = NULL;
+    shex_info.nShow = SW_HIDE;
+    shex_info.hInstApp = NULL;
 
-    if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
+    if (!ShellExecuteEx(&shex_info)) {
       DPLOG(ERROR);
       return false;
     }
 
-    BOOL launched =
-        CreateProcessAsUser(options.as_user, NULL,
-                            const_cast<wchar_t*>(cmdline.c_str()),
-                            NULL, NULL, options.inherit_handles, flags,
-                            enviroment_block, NULL, &startup_info,
-                            process_info.Receive());
-    DestroyEnvironmentBlock(enviroment_block);
-    if (!launched) {
-      DPLOG(ERROR);
-      return false;
-    }
+    HANDLE p_handle = shex_info.hProcess;
+
+    if (options.wait)
+      WaitForSingleObject(shex_info.hProcess, INFINITE);
+
+    // If the caller wants the process handle, we won't close it.
+    if (process_handle)
+      *process_handle = p_handle;
+
   } else {
-    if (!CreateProcess(NULL,
-                       const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
-                       options.inherit_handles, flags, NULL, NULL,
-                       &startup_info, process_info.Receive())) {
-      DPLOG(ERROR);
-      return false;
-    }
-  }
+    if (options.as_user) {
+      flags |= CREATE_UNICODE_ENVIRONMENT;
+      void* enviroment_block = NULL;
 
-  if (options.job_handle) {
-    if (0 == AssignProcessToJobObject(options.job_handle,
-                                      process_info.process_handle())) {
-      DLOG(ERROR) << "Could not AssignProcessToObject.";
-      KillProcess(process_info.process_handle(), kProcessKilledExitCode, true);
-      return false;
+      if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
+        DPLOG(ERROR);
+        return false;
+      }
+
+      BOOL launched =
+          CreateProcessAsUser(options.as_user, NULL,
+                              const_cast<wchar_t*>(cmdline.c_str()),
+                              NULL, NULL, options.inherit_handles, flags,
+                              enviroment_block, NULL, &startup_info,
+                              process_info.Receive());
+      DestroyEnvironmentBlock(enviroment_block);
+      if (!launched) {
+        DPLOG(ERROR);
+        return false;
+      }
+    } else {
+      if (!CreateProcess(NULL,
+                         const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
+                         options.inherit_handles, flags, NULL, NULL,
+                         &startup_info, process_info.Receive())) {
+        DPLOG(ERROR);
+        return false;
+      }
     }
 
-    ResumeThread(process_info.thread_handle());
+    if (options.job_handle) {
+      if (0 == AssignProcessToJobObject(options.job_handle,
+                                        process_info.process_handle())) {
+        DLOG(ERROR) << "Could not AssignProcessToObject.";
+        KillProcess(process_info.process_handle(),
+                    kProcessKilledExitCode,
+                    true);
+        return false;
+      }
+
+      ResumeThread(process_info.thread_handle());
+    }
+
+    if (options.wait)
+      WaitForSingleObject(process_info.process_handle(), INFINITE);
+
+    // If the caller wants the process handle, we won't close it.
+    if (process_handle)
+      *process_handle = process_info.TakeProcessHandle();
   }
 
-  if (options.wait)
-    WaitForSingleObject(process_info.process_handle(), INFINITE);
-
-  // If the caller wants the process handle, we won't close it.
-  if (process_handle)
-    *process_handle = process_info.TakeProcessHandle();
-
   return true;
 }
 
 bool LaunchProcess(const CommandLine& cmdline,
                    const LaunchOptions& options,
                    ProcessHandle* process_handle) {
-  return LaunchProcess(cmdline.GetCommandLineString(), options, process_handle);
+  return LaunchProcess(cmdline.GetCommandLineString(),
+                       cmdline.GetProgram().value(),
+                       cmdline.GetArgumentsString(),
+                       options, process_handle);
 }
 
 bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags) {
   JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info = {0};
   limit_info.BasicLimitInformation.LimitFlags = limit_flags;
   return 0 != SetInformationJobObject(
       job_object,
       JobObjectExtendedLimitInformation,
       &limit_info,
       sizeof(limit_info));
@@ skipping 67 matching lines @@
   WaitForSingleObject(proc_info.process_handle(), INFINITE);
 
   return true;
 }
 
 void RaiseProcessToHighPriority() {
   SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 }
 
 }  // namespace base