blob: 9e4db384ebb401a967a68fb30157826906549845 [file] [log] [blame]
// 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 <shellapi.h>
#include <windows.h>
#include <userenv.h>
#include <psapi.h>
#include <ios>
#include <limits>
#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"
#include "base/metrics/histogram.h"
#include "base/process/kill.h"
#include "base/strings/utf_string_conversions.h"
#include "base/sys_info.h"
#include "base/win/object_watcher.h"
#include "base/win/scoped_handle.h"
#include "base/win/scoped_process_information.h"
#include "base/win/startup_information.h"
#include "base/win/windows_version.h"
// userenv.dll is required for CreateEnvironmentBlock().
#pragma comment(lib, "userenv.lib")
namespace base {
namespace {
// This exit code is used by the Windows task manager when it kills a
// process. It's value is obviously not that unique, and it's
// surprising to me that the task manager uses this value, but it
// seems to be common practice on Windows to test for it as an
// indication that the task manager has killed something if the
// process goes away.
const DWORD kProcessKilledExitCode = 1;
} // namespace
void RouteStdioToConsole() {
// Don't change anything if stdout or stderr already point to a
// valid stream.
// If we are running under Buildbot or under Cygwin's default
// terminal (mintty), stderr and stderr will be pipe handles. In
// that case, we don't want to open CONOUT$, because its output
// likely does not go anywhere.
// We don't use GetStdHandle() to check stdout/stderr here because
// it can return dangling IDs of handles that were never inherited
// by this process. These IDs could have been reused by the time
// this function is called. The CRT checks the validity of
// stdout/stderr on startup (before the handle IDs can be reused).
// _fileno(stdout) will return -2 (_NO_CONSOLE_FILENO) if stdout was
// invalid.
if (_fileno(stdout) >= 0 || _fileno(stderr) >= 0)
if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
unsigned int result = GetLastError();
// Was probably already attached.
if (result == ERROR_ACCESS_DENIED)
// Don't bother creating a new console for each child process if the
// parent process is invalid (eg: crashed).
if (result == ERROR_GEN_FAILURE)
// Make a new console if attaching to parent fails with any other error.
// It should be ERROR_INVALID_HANDLE at this point, which means the browser
// was likely not started from a console.
// Arbitrary byte count to use when buffering output lines. More
// means potential waste, less means more risk of interleaved
// log-lines in output.
enum { kOutputBufferSize = 64 * 1024 };
if (freopen("CONOUT$", "w", stdout)) {
setvbuf(stdout, NULL, _IOLBF, kOutputBufferSize);
// Overwrite FD 1 for the benefit of any code that uses this FD
// directly. This is safe because the CRT allocates FDs 0, 1 and
// 2 at startup even if they don't have valid underlying Windows
// handles. This means we won't be overwriting an FD created by
// _open() after startup.
_dup2(_fileno(stdout), 1);
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.
bool LaunchProcess(const string16& cmdline,
const LaunchOptions& options,
win::ScopedHandle* process_handle) {
win::StartupInformation startup_info_wrapper;
STARTUPINFO* startup_info = startup_info_wrapper.startup_info();
bool inherit_handles = options.inherit_handles;
DWORD flags = 0;
if (options.handles_to_inherit) {
if (options.handles_to_inherit->empty()) {
inherit_handles = false;
} else {
if (base::win::GetVersion() < base::win::VERSION_VISTA) {
DLOG(ERROR) << "Specifying handles to inherit requires Vista or later.";
return false;
if (options.handles_to_inherit->size() >
std::numeric_limits<DWORD>::max() / sizeof(HANDLE)) {
DLOG(ERROR) << "Too many handles to inherit.";
return false;
if (!startup_info_wrapper.InitializeProcThreadAttributeList(1)) {
return false;
if (!startup_info_wrapper.UpdateProcThreadAttribute(
static_cast<DWORD>(options.handles_to_inherit->size() *
sizeof(HANDLE)))) {
return false;
inherit_handles = true;
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) {
startup_info->dwFlags |= STARTF_USESTDHANDLES;
startup_info->hStdInput = options.stdin_handle;
startup_info->hStdOutput = options.stdout_handle;
startup_info->hStdError = options.stderr_handle;
if (options.job_handle) {
// If this code is run under a debugger, the launched process is
// automatically associated with a job object created by the debugger.
// The CREATE_BREAKAWAY_FROM_JOB flag is used to prevent this.
if (options.force_breakaway_from_job_)
PROCESS_INFORMATION temp_process_info = {};
if (options.as_user) {
void* enviroment_block = NULL;
if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
return false;
BOOL launched =
CreateProcessAsUser(options.as_user, NULL,
NULL, NULL, inherit_handles, flags,
enviroment_block, NULL, startup_info,
if (!launched) {
DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
<< std::endl;;
return false;
} else {
if (!CreateProcess(NULL,
const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
inherit_handles, flags, NULL, NULL,
startup_info, &temp_process_info)) {
DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
<< std::endl;;
return false;
base::win::ScopedProcessInformation process_info(temp_process_info);
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 (options.wait)
WaitForSingleObject(process_info.process_handle(), INFINITE);
// If the caller wants the process handle, we won't close it.
if (process_handle)
return true;
bool LaunchProcess(const CommandLine& cmdline,
const LaunchOptions& options,
ProcessHandle* process_handle) {
if (!process_handle)
return LaunchProcess(cmdline.GetCommandLineString(), options, NULL);
win::ScopedHandle process;
bool rv = LaunchProcess(cmdline.GetCommandLineString(), options, &process);
*process_handle = process.Take();
return rv;
bool LaunchElevatedProcess(const CommandLine& cmdline,
const LaunchOptions& options,
ProcessHandle* process_handle) {
const string16 file = cmdline.GetProgram().value();
const string16 arguments = cmdline.GetArgumentsString();
SHELLEXECUTEINFO shex_info = {0};
shex_info.cbSize = sizeof(shex_info);
shex_info.hwnd = GetActiveWindow();
shex_info.lpVerb = L"runas";
shex_info.lpFile = file.c_str();
shex_info.lpParameters = arguments.c_str();
shex_info.lpDirectory = NULL;
shex_info.nShow = options.start_hidden ? SW_HIDE : SW_SHOW;
shex_info.hInstApp = NULL;
if (!ShellExecuteEx(&shex_info)) {
return false;
if (options.wait)
WaitForSingleObject(shex_info.hProcess, INFINITE);
// If the caller wants the process handle give it to them, otherwise just
// close it. Closing it does not terminate the process.
if (process_handle)
*process_handle = shex_info.hProcess;
return true;
bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags) {
limit_info.BasicLimitInformation.LimitFlags = limit_flags;
return 0 != SetInformationJobObject(
bool GetAppOutput(const CommandLine& cl, std::string* output) {
return GetAppOutput(cl.GetCommandLineString(), output);
bool GetAppOutput(const StringPiece16& cl, std::string* output) {
HANDLE out_read = NULL;
HANDLE out_write = NULL;
// Set the bInheritHandle flag so pipe handles are inherited.
sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
sa_attr.bInheritHandle = TRUE;
sa_attr.lpSecurityDescriptor = NULL;
// Create the pipe for the child process's STDOUT.
if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
NOTREACHED() << "Failed to create pipe";
return false;
// Ensure we don't leak the handles.
win::ScopedHandle scoped_out_read(out_read);
win::ScopedHandle scoped_out_write(out_write);
// Ensure the read handle to the pipe for STDOUT is not inherited.
if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
NOTREACHED() << "Failed to disabled pipe inheritance";
return false;
FilePath::StringType writable_command_line_string;
writable_command_line_string.assign(, cl.size());
STARTUPINFO start_info = {};
start_info.cb = sizeof(STARTUPINFO);
start_info.hStdOutput = out_write;
// Keep the normal stdin and stderr.
start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
start_info.dwFlags |= STARTF_USESTDHANDLES;
// Create the child process.
PROCESS_INFORMATION temp_process_info = {};
if (!CreateProcess(NULL,
TRUE, // Handles are inherited.
0, NULL, NULL, &start_info, &temp_process_info)) {
NOTREACHED() << "Failed to start process";
return false;
base::win::ScopedProcessInformation proc_info(temp_process_info);
// Close our writing end of pipe now. Otherwise later read would not be able
// to detect end of child's output.
// Read output from the child process's pipe for STDOUT
const int kBufferSize = 1024;
char buffer[kBufferSize];
for (;;) {
DWORD bytes_read = 0;
BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
if (!success || bytes_read == 0)
output->append(buffer, bytes_read);
// Let's wait for the process to finish.
WaitForSingleObject(proc_info.process_handle(), INFINITE);
return true;
void RaiseProcessToHighPriority() {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
} // namespace base