284 lines
9.3 KiB
C++
284 lines
9.3 KiB
C++
|
// 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 <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"
|
||
|
|
#include "base/metrics/histogram.h"
|
||
|
|
#include "base/process/kill.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/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)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
|
||
|
|
unsigned int result = GetLastError();
|
||
|
|
// Was probably already attached.
|
||
|
|
if (result == ERROR_ACCESS_DENIED)
|
||
|
|
return;
|
||
|
|
// Don't bother creating a new console for each child process if the
|
||
|
|
// parent process is invalid (eg: crashed).
|
||
|
|
if (result == ERROR_GEN_FAILURE)
|
||
|
|
return;
|
||
|
|
// 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.
|
||
|
|
AllocConsole();
|
||
|
|
}
|
||
|
|
|
||
|
|
// 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.
|
||
|
|
std::ios::sync_with_stdio();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool LaunchProcess(const string16& cmdline,
|
||
|
|
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) {
|
||
|
|
DCHECK(options.inherit_handles);
|
||
|
|
DCHECK(options.stdin_handle);
|
||
|
|
DCHECK(options.stdout_handle);
|
||
|
|
DCHECK(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;
|
||
|
|
}
|
||
|
|
|
||
|
|
DWORD flags = 0;
|
||
|
|
|
||
|
|
if (options.job_handle) {
|
||
|
|
flags |= CREATE_SUSPENDED;
|
||
|
|
|
||
|
|
// 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.
|
||
|
|
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 (!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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
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();
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool LaunchProcess(const CommandLine& cmdline,
|
||
|
|
const LaunchOptions& options,
|
||
|
|
ProcessHandle* process_handle) {
|
||
|
|
return LaunchProcess(cmdline.GetCommandLineString(), options, process_handle);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool SetJobObjectAsKillOnJobClose(HANDLE job_object) {
|
||
|
|
JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info = {0};
|
||
|
|
limit_info.BasicLimitInformation.LimitFlags =
|
||
|
|
JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
|
||
|
|
return 0 != SetInformationJobObject(
|
||
|
|
job_object,
|
||
|
|
JobObjectExtendedLimitInformation,
|
||
|
|
&limit_info,
|
||
|
|
sizeof(limit_info));
|
||
|
|
}
|
||
|
|
|
||
|
|
bool GetAppOutput(const CommandLine& cl, std::string* output) {
|
||
|
|
HANDLE out_read = NULL;
|
||
|
|
HANDLE out_write = NULL;
|
||
|
|
|
||
|
|
SECURITY_ATTRIBUTES sa_attr;
|
||
|
|
// 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(cl.GetCommandLineString());
|
||
|
|
|
||
|
|
base::win::ScopedProcessInformation proc_info;
|
||
|
|
STARTUPINFO start_info = { 0 };
|
||
|
|
|
||
|
|
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.
|
||
|
|
if (!CreateProcess(NULL,
|
||
|
|
&writable_command_line_string[0],
|
||
|
|
NULL, NULL,
|
||
|
|
TRUE, // Handles are inherited.
|
||
|
|
0, NULL, NULL, &start_info, proc_info.Receive())) {
|
||
|
|
NOTREACHED() << "Failed to start process";
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Close our writing end of pipe now. Otherwise later read would not be able
|
||
|
|
// to detect end of child's output.
|
||
|
|
scoped_out_write.Close();
|
||
|
|
|
||
|
|
// 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)
|
||
|
|
break;
|
||
|
|
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
|