src/base/process/launch_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/process/launch.h"
   6
   7 #include <fcntl.h>
   8 #include <io.h>
   9 #include <shellapi.h>
  10 #include <windows.h>
  11 #include <userenv.h>
  12 #include <psapi.h>
  13
  14 #include <ios>
  15 #include <limits>
  16
  17 #include "base/bind.h"
  18 #include "base/bind_helpers.h"
  19 #include "base/command_line.h"
  20 #include "base/debug/stack_trace.h"
  21 #include "base/logging.h"
  22 #include "base/memory/scoped_ptr.h"
  23 #include "base/message_loop/message_loop.h"
  24 #include "base/metrics/histogram.h"
  25 #include "base/process/kill.h"
  26 #include "base/strings/utf_string_conversions.h"
  27 #include "base/sys_info.h"
  28 #include "base/win/object_watcher.h"
  29 #include "base/win/scoped_handle.h"
  30 #include "base/win/scoped_process_information.h"
  31 #include "base/win/startup_information.h"
  32 #include "base/win/windows_version.h"
  33
  34 // userenv.dll is required for CreateEnvironmentBlock().
  35 #pragma comment(lib, "userenv.lib")
  36
  37 namespace base {
  38
  39 namespace {
  40
  41 // This exit code is used by the Windows task manager when it kills a
  42 // process.  It's value is obviously not that unique, and it's
  43 // surprising to me that the task manager uses this value, but it
  44 // seems to be common practice on Windows to test for it as an
  45 // indication that the task manager has killed something if the
  46 // process goes away.
  47 const DWORD kProcessKilledExitCode = 1;
  48
  49 }  // namespace
  50
  51 void RouteStdioToConsole() {
  52   // Don't change anything if stdout or stderr already point to a
  53   // valid stream.
  54   //
  55   // If we are running under Buildbot or under Cygwin's default
  56   // terminal (mintty), stderr and stderr will be pipe handles.  In
  57   // that case, we don't want to open CONOUT$, because its output
  58   // likely does not go anywhere.
  59   //
  60   // We don't use GetStdHandle() to check stdout/stderr here because
  61   // it can return dangling IDs of handles that were never inherited
  62   // by this process.  These IDs could have been reused by the time
  63   // this function is called.  The CRT checks the validity of
  64   // stdout/stderr on startup (before the handle IDs can be reused).
  65   // _fileno(stdout) will return -2 (_NO_CONSOLE_FILENO) if stdout was
  66   // invalid.
  67   if (_fileno(stdout) >= 0 || _fileno(stderr) >= 0)
  68     return;
  69
  70   if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
  71     unsigned int result = GetLastError();
  72     // Was probably already attached.
  73     if (result == ERROR_ACCESS_DENIED)
  74       return;
  75     // Don't bother creating a new console for each child process if the
  76     // parent process is invalid (eg: crashed).
  77     if (result == ERROR_GEN_FAILURE)
  78       return;
  79     // Make a new console if attaching to parent fails with any other error.
  80     // It should be ERROR_INVALID_HANDLE at this point, which means the browser
  81     // was likely not started from a console.
  82     AllocConsole();
  83   }
  84
  85   // Arbitrary byte count to use when buffering output lines.  More
  86   // means potential waste, less means more risk of interleaved
  87   // log-lines in output.
  88   enum { kOutputBufferSize = 64 * 1024 };
  89
  90   if (freopen("CONOUT$", "w", stdout)) {
  91     setvbuf(stdout, NULL, _IOLBF, kOutputBufferSize);
  92     // Overwrite FD 1 for the benefit of any code that uses this FD
  93     // directly.  This is safe because the CRT allocates FDs 0, 1 and
  94     // 2 at startup even if they don't have valid underlying Windows
  95     // handles.  This means we won't be overwriting an FD created by
  96     // _open() after startup.
  97     _dup2(_fileno(stdout), 1);
  98   }
  99   if (freopen("CONOUT$", "w", stderr)) {
 100     setvbuf(stderr, NULL, _IOLBF, kOutputBufferSize);
 101     _dup2(_fileno(stderr), 2);
 102   }
 103
 104   // Fix all cout, wcout, cin, wcin, cerr, wcerr, clog and wclog.
 105   std::ios::sync_with_stdio();
 106 }
 107
 108 bool LaunchProcess(const string16& cmdline,
 109                    const LaunchOptions& options,
 110                    win::ScopedHandle* process_handle) {
 111   win::StartupInformation startup_info_wrapper;
 112   STARTUPINFO* startup_info = startup_info_wrapper.startup_info();
 113
 114   bool inherit_handles = options.inherit_handles;
 115   DWORD flags = 0;
 116   if (options.handles_to_inherit) {
 117     if (options.handles_to_inherit->empty()) {
 118       inherit_handles = false;
 119     } else {
 120       if (base::win::GetVersion() < base::win::VERSION_VISTA) {
 121         DLOG(ERROR) << "Specifying handles to inherit requires Vista or later.";
 122         return false;
 123       }
 124
 125       if (options.handles_to_inherit->size() >
 126               std::numeric_limits<DWORD>::max() / sizeof(HANDLE)) {
 127         DLOG(ERROR) << "Too many handles to inherit.";
 128         return false;
 129       }
 130
 131       if (!startup_info_wrapper.InitializeProcThreadAttributeList(1)) {
 132         DPLOG(ERROR);
 133         return false;
 134       }
 135
 136       if (!startup_info_wrapper.UpdateProcThreadAttribute(
 137               PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
 138               const_cast<HANDLE*>(&options.handles_to_inherit->at(0)),
 139               static_cast<DWORD>(options.handles_to_inherit->size() *
 140                   sizeof(HANDLE)))) {
 141         DPLOG(ERROR);
 142         return false;
 143       }
 144
 145       inherit_handles = true;
 146       flags |= EXTENDED_STARTUPINFO_PRESENT;
 147     }
 148   }
 149
 150   if (options.empty_desktop_name)
 151     startup_info->lpDesktop = const_cast<wchar_t*>(L"");
 152   startup_info->dwFlags = STARTF_USESHOWWINDOW;
 153   startup_info->wShowWindow = options.start_hidden ? SW_HIDE : SW_SHOW;
 154
 155   if (options.stdin_handle || options.stdout_handle || options.stderr_handle) {
 156     DCHECK(inherit_handles);
 157     DCHECK(options.stdin_handle);
 158     DCHECK(options.stdout_handle);
 159     DCHECK(options.stderr_handle);
 160     startup_info->dwFlags |= STARTF_USESTDHANDLES;
 161     startup_info->hStdInput = options.stdin_handle;
 162     startup_info->hStdOutput = options.stdout_handle;
 163     startup_info->hStdError = options.stderr_handle;
 164   }
 165
 166   if (options.job_handle) {
 167     flags |= CREATE_SUSPENDED;
 168
 169     // If this code is run under a debugger, the launched process is
 170     // automatically associated with a job object created by the debugger.
 171     // The CREATE_BREAKAWAY_FROM_JOB flag is used to prevent this.
 172     flags |= CREATE_BREAKAWAY_FROM_JOB;
 173   }
 174
 175   if (options.force_breakaway_from_job_)
 176     flags |= CREATE_BREAKAWAY_FROM_JOB;
 177
 178   PROCESS_INFORMATION temp_process_info = {};
 179
 180   if (options.as_user) {
 181     flags |= CREATE_UNICODE_ENVIRONMENT;
 182     void* enviroment_block = NULL;
 183
 184     if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
 185       DPLOG(ERROR);
 186       return false;
 187     }
 188
 189     BOOL launched =
 190         CreateProcessAsUser(options.as_user, NULL,
 191                             const_cast<wchar_t*>(cmdline.c_str()),
 192                             NULL, NULL, inherit_handles, flags,
 193                             enviroment_block, NULL, startup_info,
 194                             &temp_process_info);
 195     DestroyEnvironmentBlock(enviroment_block);
 196     if (!launched) {
 197       DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
 198                    << std::endl;;
 199       return false;
 200     }
 201   } else {
 202     if (!CreateProcess(NULL,
 203                        const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
 204                        inherit_handles, flags, NULL, NULL,
 205                        startup_info, &temp_process_info)) {
 206       DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
 207                    << std::endl;;
 208       return false;
 209     }
 210   }
 211   base::win::ScopedProcessInformation process_info(temp_process_info);
 212
 213   if (options.job_handle) {
 214     if (0 == AssignProcessToJobObject(options.job_handle,
 215                                       process_info.process_handle())) {
 216       DLOG(ERROR) << "Could not AssignProcessToObject.";
 217       KillProcess(process_info.process_handle(), kProcessKilledExitCode, true);
 218       return false;
 219     }
 220
 221     ResumeThread(process_info.thread_handle());
 222   }
 223
 224   if (options.wait)
 225     WaitForSingleObject(process_info.process_handle(), INFINITE);
 226
 227   // If the caller wants the process handle, we won't close it.
 228   if (process_handle)
 229     process_handle->Set(process_info.TakeProcessHandle());
 230
 231   return true;
 232 }
 233
 234 bool LaunchProcess(const CommandLine& cmdline,
 235                    const LaunchOptions& options,
 236                    ProcessHandle* process_handle) {
 237   if (!process_handle)
 238     return LaunchProcess(cmdline.GetCommandLineString(), options, NULL);
 239
 240   win::ScopedHandle process;
 241   bool rv = LaunchProcess(cmdline.GetCommandLineString(), options, &process);
 242   *process_handle = process.Take();
 243   return rv;
 244 }
 245
 246 bool LaunchElevatedProcess(const CommandLine& cmdline,
 247                            const LaunchOptions& options,
 248                            ProcessHandle* process_handle) {
 249   const string16 file = cmdline.GetProgram().value();
 250   const string16 arguments = cmdline.GetArgumentsString();
 251
 252   SHELLEXECUTEINFO shex_info = {0};
 253   shex_info.cbSize = sizeof(shex_info);
 254   shex_info.fMask = SEE_MASK_NOCLOSEPROCESS;
 255   shex_info.hwnd = GetActiveWindow();
 256   shex_info.lpVerb = L"runas";
 257   shex_info.lpFile = file.c_str();
 258   shex_info.lpParameters = arguments.c_str();
 259   shex_info.lpDirectory = NULL;
 260   shex_info.nShow = options.start_hidden ? SW_HIDE : SW_SHOW;
 261   shex_info.hInstApp = NULL;
 262
 263   if (!ShellExecuteEx(&shex_info)) {
 264     DPLOG(ERROR);
 265     return false;
 266   }
 267
 268   if (options.wait)
 269     WaitForSingleObject(shex_info.hProcess, INFINITE);
 270
 271   // If the caller wants the process handle give it to them, otherwise just
 272   // close it.  Closing it does not terminate the process.
 273   if (process_handle)
 274     *process_handle = shex_info.hProcess;
 275   else
 276     CloseHandle(shex_info.hProcess);
 277
 278   return true;
 279 }
 280
 281 bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags) {
 282   JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info = {0};
 283   limit_info.BasicLimitInformation.LimitFlags = limit_flags;
 284   return 0 != SetInformationJobObject(
 285       job_object,
 286       JobObjectExtendedLimitInformation,
 287       &limit_info,
 288       sizeof(limit_info));
 289 }
 290
 291 bool GetAppOutput(const CommandLine& cl, std::string* output) {
 292   return GetAppOutput(cl.GetCommandLineString(), output);
 293 }
 294
 295 bool GetAppOutput(const StringPiece16& cl, std::string* output) {
 296   HANDLE out_read = NULL;
 297   HANDLE out_write = NULL;
 298
 299   SECURITY_ATTRIBUTES sa_attr;
 300   // Set the bInheritHandle flag so pipe handles are inherited.
 301   sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
 302   sa_attr.bInheritHandle = TRUE;
 303   sa_attr.lpSecurityDescriptor = NULL;
 304
 305   // Create the pipe for the child process's STDOUT.
 306   if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
 307     NOTREACHED() << "Failed to create pipe";
 308     return false;
 309   }
 310
 311   // Ensure we don't leak the handles.
 312   win::ScopedHandle scoped_out_read(out_read);
 313   win::ScopedHandle scoped_out_write(out_write);
 314
 315   // Ensure the read handle to the pipe for STDOUT is not inherited.
 316   if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
 317     NOTREACHED() << "Failed to disabled pipe inheritance";
 318     return false;
 319   }
 320
 321   FilePath::StringType writable_command_line_string;
 322   writable_command_line_string.assign(cl.data(), cl.size());
 323
 324   STARTUPINFO start_info = {};
 325
 326   start_info.cb = sizeof(STARTUPINFO);
 327   start_info.hStdOutput = out_write;
 328   // Keep the normal stdin and stderr.
 329   start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
 330   start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
 331   start_info.dwFlags |= STARTF_USESTDHANDLES;
 332
 333   // Create the child process.
 334   PROCESS_INFORMATION temp_process_info = {};
 335   if (!CreateProcess(NULL,
 336                      &writable_command_line_string[0],
 337                      NULL, NULL,
 338                      TRUE,  // Handles are inherited.
 339                      0, NULL, NULL, &start_info, &temp_process_info)) {
 340     NOTREACHED() << "Failed to start process";
 341     return false;
 342   }
 343   base::win::ScopedProcessInformation proc_info(temp_process_info);
 344
 345   // Close our writing end of pipe now. Otherwise later read would not be able
 346   // to detect end of child's output.
 347   scoped_out_write.Close();
 348
 349   // Read output from the child process's pipe for STDOUT
 350   const int kBufferSize = 1024;
 351   char buffer[kBufferSize];
 352
 353   for (;;) {
 354     DWORD bytes_read = 0;
 355     BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
 356     if (!success || bytes_read == 0)
 357       break;
 358     output->append(buffer, bytes_read);
 359   }
 360
 361   // Let's wait for the process to finish.
 362   WaitForSingleObject(proc_info.process_handle(), INFINITE);
 363
 364   return true;
 365 }
 366
 367 void RaiseProcessToHighPriority() {
 368   SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
 369 }
 370
 371 }  // namespace base