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.
5 #include "base/process/launch.h"
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/sys_info.h"
27 #include "base/win/object_watcher.h"
28 #include "base/win/scoped_handle.h"
29 #include "base/win/scoped_process_information.h"
30 #include "base/win/startup_information.h"
31 #include "base/win/windows_version.h"
33 // userenv.dll is required for CreateEnvironmentBlock().
34 #pragma comment(lib, "userenv.lib")
40 // This exit code is used by the Windows task manager when it kills a
41 // process. It's value is obviously not that unique, and it's
42 // surprising to me that the task manager uses this value, but it
43 // seems to be common practice on Windows to test for it as an
44 // indication that the task manager has killed something if the
46 const DWORD kProcessKilledExitCode
= 1;
50 void RouteStdioToConsole() {
51 // Don't change anything if stdout or stderr already point to a
54 // If we are running under Buildbot or under Cygwin's default
55 // terminal (mintty), stderr and stderr will be pipe handles. In
56 // that case, we don't want to open CONOUT$, because its output
57 // likely does not go anywhere.
59 // We don't use GetStdHandle() to check stdout/stderr here because
60 // it can return dangling IDs of handles that were never inherited
61 // by this process. These IDs could have been reused by the time
62 // this function is called. The CRT checks the validity of
63 // stdout/stderr on startup (before the handle IDs can be reused).
64 // _fileno(stdout) will return -2 (_NO_CONSOLE_FILENO) if stdout was
66 if (_fileno(stdout
) >= 0 || _fileno(stderr
) >= 0)
69 if (!AttachConsole(ATTACH_PARENT_PROCESS
)) {
70 unsigned int result
= GetLastError();
71 // Was probably already attached.
72 if (result
== ERROR_ACCESS_DENIED
)
74 // Don't bother creating a new console for each child process if the
75 // parent process is invalid (eg: crashed).
76 if (result
== ERROR_GEN_FAILURE
)
78 // Make a new console if attaching to parent fails with any other error.
79 // It should be ERROR_INVALID_HANDLE at this point, which means the browser
80 // was likely not started from a console.
84 // Arbitrary byte count to use when buffering output lines. More
85 // means potential waste, less means more risk of interleaved
86 // log-lines in output.
87 enum { kOutputBufferSize
= 64 * 1024 };
89 if (freopen("CONOUT$", "w", stdout
)) {
90 setvbuf(stdout
, NULL
, _IOLBF
, kOutputBufferSize
);
91 // Overwrite FD 1 for the benefit of any code that uses this FD
92 // directly. This is safe because the CRT allocates FDs 0, 1 and
93 // 2 at startup even if they don't have valid underlying Windows
94 // handles. This means we won't be overwriting an FD created by
95 // _open() after startup.
96 _dup2(_fileno(stdout
), 1);
98 if (freopen("CONOUT$", "w", stderr
)) {
99 setvbuf(stderr
, NULL
, _IOLBF
, kOutputBufferSize
);
100 _dup2(_fileno(stderr
), 2);
103 // Fix all cout, wcout, cin, wcin, cerr, wcerr, clog and wclog.
104 std::ios::sync_with_stdio();
107 bool LaunchProcess(const string16
& cmdline
,
108 const LaunchOptions
& options
,
109 win::ScopedHandle
* process_handle
) {
110 win::StartupInformation startup_info_wrapper
;
111 STARTUPINFO
* startup_info
= startup_info_wrapper
.startup_info();
113 bool inherit_handles
= options
.inherit_handles
;
115 if (options
.handles_to_inherit
) {
116 if (options
.handles_to_inherit
->empty()) {
117 inherit_handles
= false;
119 if (base::win::GetVersion() < base::win::VERSION_VISTA
) {
120 DLOG(ERROR
) << "Specifying handles to inherit requires Vista or later.";
124 if (options
.handles_to_inherit
->size() >
125 std::numeric_limits
<DWORD
>::max() / sizeof(HANDLE
)) {
126 DLOG(ERROR
) << "Too many handles to inherit.";
130 if (!startup_info_wrapper
.InitializeProcThreadAttributeList(1)) {
135 if (!startup_info_wrapper
.UpdateProcThreadAttribute(
136 PROC_THREAD_ATTRIBUTE_HANDLE_LIST
,
137 const_cast<HANDLE
*>(&options
.handles_to_inherit
->at(0)),
138 static_cast<DWORD
>(options
.handles_to_inherit
->size() *
144 inherit_handles
= true;
145 flags
|= EXTENDED_STARTUPINFO_PRESENT
;
149 if (options
.empty_desktop_name
)
150 startup_info
->lpDesktop
= L
"";
151 startup_info
->dwFlags
= STARTF_USESHOWWINDOW
;
152 startup_info
->wShowWindow
= options
.start_hidden
? SW_HIDE
: SW_SHOW
;
154 if (options
.stdin_handle
|| options
.stdout_handle
|| options
.stderr_handle
) {
155 DCHECK(inherit_handles
);
156 DCHECK(options
.stdin_handle
);
157 DCHECK(options
.stdout_handle
);
158 DCHECK(options
.stderr_handle
);
159 startup_info
->dwFlags
|= STARTF_USESTDHANDLES
;
160 startup_info
->hStdInput
= options
.stdin_handle
;
161 startup_info
->hStdOutput
= options
.stdout_handle
;
162 startup_info
->hStdError
= options
.stderr_handle
;
165 if (options
.job_handle
) {
166 flags
|= CREATE_SUSPENDED
;
168 // If this code is run under a debugger, the launched process is
169 // automatically associated with a job object created by the debugger.
170 // The CREATE_BREAKAWAY_FROM_JOB flag is used to prevent this.
171 flags
|= CREATE_BREAKAWAY_FROM_JOB
;
174 if (options
.force_breakaway_from_job_
)
175 flags
|= CREATE_BREAKAWAY_FROM_JOB
;
177 PROCESS_INFORMATION temp_process_info
= {};
179 if (options
.as_user
) {
180 flags
|= CREATE_UNICODE_ENVIRONMENT
;
181 void* enviroment_block
= NULL
;
183 if (!CreateEnvironmentBlock(&enviroment_block
, options
.as_user
, FALSE
)) {
189 CreateProcessAsUser(options
.as_user
, NULL
,
190 const_cast<wchar_t*>(cmdline
.c_str()),
191 NULL
, NULL
, inherit_handles
, flags
,
192 enviroment_block
, NULL
, startup_info
,
194 DestroyEnvironmentBlock(enviroment_block
);
200 if (!CreateProcess(NULL
,
201 const_cast<wchar_t*>(cmdline
.c_str()), NULL
, NULL
,
202 inherit_handles
, flags
, NULL
, NULL
,
203 startup_info
, &temp_process_info
)) {
208 base::win::ScopedProcessInformation
process_info(temp_process_info
);
210 if (options
.job_handle
) {
211 if (0 == AssignProcessToJobObject(options
.job_handle
,
212 process_info
.process_handle())) {
213 DLOG(ERROR
) << "Could not AssignProcessToObject.";
214 KillProcess(process_info
.process_handle(), kProcessKilledExitCode
, true);
218 ResumeThread(process_info
.thread_handle());
222 WaitForSingleObject(process_info
.process_handle(), INFINITE
);
224 // If the caller wants the process handle, we won't close it.
226 process_handle
->Set(process_info
.TakeProcessHandle());
231 bool LaunchProcess(const CommandLine
& cmdline
,
232 const LaunchOptions
& options
,
233 ProcessHandle
* process_handle
) {
235 return LaunchProcess(cmdline
.GetCommandLineString(), options
, NULL
);
237 win::ScopedHandle process
;
238 bool rv
= LaunchProcess(cmdline
.GetCommandLineString(), options
, &process
);
239 *process_handle
= process
.Take();
243 bool LaunchElevatedProcess(const CommandLine
& cmdline
,
244 const LaunchOptions
& options
,
245 ProcessHandle
* process_handle
) {
246 const string16 file
= cmdline
.GetProgram().value();
247 const string16 arguments
= cmdline
.GetArgumentsString();
249 SHELLEXECUTEINFO shex_info
= {0};
250 shex_info
.cbSize
= sizeof(shex_info
);
251 shex_info
.fMask
= SEE_MASK_NOCLOSEPROCESS
;
252 shex_info
.hwnd
= GetActiveWindow();
253 shex_info
.lpVerb
= L
"runas";
254 shex_info
.lpFile
= file
.c_str();
255 shex_info
.lpParameters
= arguments
.c_str();
256 shex_info
.lpDirectory
= NULL
;
257 shex_info
.nShow
= options
.start_hidden
? SW_HIDE
: SW_SHOW
;
258 shex_info
.hInstApp
= NULL
;
260 if (!ShellExecuteEx(&shex_info
)) {
266 WaitForSingleObject(shex_info
.hProcess
, INFINITE
);
268 // If the caller wants the process handle give it to them, otherwise just
269 // close it. Closing it does not terminate the process.
271 *process_handle
= shex_info
.hProcess
;
273 CloseHandle(shex_info
.hProcess
);
278 bool SetJobObjectLimitFlags(HANDLE job_object
, DWORD limit_flags
) {
279 JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info
= {0};
280 limit_info
.BasicLimitInformation
.LimitFlags
= limit_flags
;
281 return 0 != SetInformationJobObject(
283 JobObjectExtendedLimitInformation
,
288 bool GetAppOutput(const CommandLine
& cl
, std::string
* output
) {
289 return GetAppOutput(cl
.GetCommandLineString(), output
);
292 bool GetAppOutput(const StringPiece16
& cl
, std::string
* output
) {
293 HANDLE out_read
= NULL
;
294 HANDLE out_write
= NULL
;
296 SECURITY_ATTRIBUTES sa_attr
;
297 // Set the bInheritHandle flag so pipe handles are inherited.
298 sa_attr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
299 sa_attr
.bInheritHandle
= TRUE
;
300 sa_attr
.lpSecurityDescriptor
= NULL
;
302 // Create the pipe for the child process's STDOUT.
303 if (!CreatePipe(&out_read
, &out_write
, &sa_attr
, 0)) {
304 NOTREACHED() << "Failed to create pipe";
308 // Ensure we don't leak the handles.
309 win::ScopedHandle
scoped_out_read(out_read
);
310 win::ScopedHandle
scoped_out_write(out_write
);
312 // Ensure the read handle to the pipe for STDOUT is not inherited.
313 if (!SetHandleInformation(out_read
, HANDLE_FLAG_INHERIT
, 0)) {
314 NOTREACHED() << "Failed to disabled pipe inheritance";
318 FilePath::StringType writable_command_line_string
;
319 writable_command_line_string
.assign(cl
.data(), cl
.size());
321 STARTUPINFO start_info
= {};
323 start_info
.cb
= sizeof(STARTUPINFO
);
324 start_info
.hStdOutput
= out_write
;
325 // Keep the normal stdin and stderr.
326 start_info
.hStdInput
= GetStdHandle(STD_INPUT_HANDLE
);
327 start_info
.hStdError
= GetStdHandle(STD_ERROR_HANDLE
);
328 start_info
.dwFlags
|= STARTF_USESTDHANDLES
;
330 // Create the child process.
331 PROCESS_INFORMATION temp_process_info
= {};
332 if (!CreateProcess(NULL
,
333 &writable_command_line_string
[0],
335 TRUE
, // Handles are inherited.
336 0, NULL
, NULL
, &start_info
, &temp_process_info
)) {
337 NOTREACHED() << "Failed to start process";
340 base::win::ScopedProcessInformation
proc_info(temp_process_info
);
342 // Close our writing end of pipe now. Otherwise later read would not be able
343 // to detect end of child's output.
344 scoped_out_write
.Close();
346 // Read output from the child process's pipe for STDOUT
347 const int kBufferSize
= 1024;
348 char buffer
[kBufferSize
];
351 DWORD bytes_read
= 0;
352 BOOL success
= ReadFile(out_read
, buffer
, kBufferSize
, &bytes_read
, NULL
);
353 if (!success
|| bytes_read
== 0)
355 output
->append(buffer
, bytes_read
);
358 // Let's wait for the process to finish.
359 WaitForSingleObject(proc_info
.process_handle(), INFINITE
);
364 void RaiseProcessToHighPriority() {
365 SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS
);