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
RouteStdioToConsole()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
LaunchProcess(const string16 & cmdline,const LaunchOptions & options,win::ScopedHandle * process_handle)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 string16 writable_cmdline(cmdline);
181 if (options.as_user) {
182 flags |= CREATE_UNICODE_ENVIRONMENT;
183 void* enviroment_block = NULL;
184
185 if (!CreateEnvironmentBlock(&enviroment_block, options.as_user, FALSE)) {
186 DPLOG(ERROR);
187 return false;
188 }
189
190 BOOL launched =
191 CreateProcessAsUser(options.as_user, NULL,
192 &writable_cmdline[0],
193 NULL, NULL, inherit_handles, flags,
194 enviroment_block, NULL, startup_info,
195 &temp_process_info);
196 DestroyEnvironmentBlock(enviroment_block);
197 if (!launched) {
198 DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
199 << std::endl;;
200 return false;
201 }
202 } else {
203 if (!CreateProcess(NULL,
204 &writable_cmdline[0], NULL, NULL,
205 inherit_handles, flags, NULL, NULL,
206 startup_info, &temp_process_info)) {
207 DPLOG(ERROR) << "Command line:" << std::endl << UTF16ToUTF8(cmdline)
208 << std::endl;;
209 return false;
210 }
211 }
212 base::win::ScopedProcessInformation process_info(temp_process_info);
213
214 if (options.job_handle) {
215 if (0 == AssignProcessToJobObject(options.job_handle,
216 process_info.process_handle())) {
217 DLOG(ERROR) << "Could not AssignProcessToObject.";
218 KillProcess(process_info.process_handle(), kProcessKilledExitCode, true);
219 return false;
220 }
221
222 ResumeThread(process_info.thread_handle());
223 }
224
225 if (options.wait)
226 WaitForSingleObject(process_info.process_handle(), INFINITE);
227
228 // If the caller wants the process handle, we won't close it.
229 if (process_handle)
230 process_handle->Set(process_info.TakeProcessHandle());
231
232 return true;
233 }
234
LaunchProcess(const CommandLine & cmdline,const LaunchOptions & options,ProcessHandle * process_handle)235 bool LaunchProcess(const CommandLine& cmdline,
236 const LaunchOptions& options,
237 ProcessHandle* process_handle) {
238 if (!process_handle)
239 return LaunchProcess(cmdline.GetCommandLineString(), options, NULL);
240
241 win::ScopedHandle process;
242 bool rv = LaunchProcess(cmdline.GetCommandLineString(), options, &process);
243 *process_handle = process.Take();
244 return rv;
245 }
246
LaunchElevatedProcess(const CommandLine & cmdline,const LaunchOptions & options,ProcessHandle * process_handle)247 bool LaunchElevatedProcess(const CommandLine& cmdline,
248 const LaunchOptions& options,
249 ProcessHandle* process_handle) {
250 const string16 file = cmdline.GetProgram().value();
251 const string16 arguments = cmdline.GetArgumentsString();
252
253 SHELLEXECUTEINFO shex_info = {0};
254 shex_info.cbSize = sizeof(shex_info);
255 shex_info.fMask = SEE_MASK_NOCLOSEPROCESS;
256 shex_info.hwnd = GetActiveWindow();
257 shex_info.lpVerb = L"runas";
258 shex_info.lpFile = file.c_str();
259 shex_info.lpParameters = arguments.c_str();
260 shex_info.lpDirectory = NULL;
261 shex_info.nShow = options.start_hidden ? SW_HIDE : SW_SHOW;
262 shex_info.hInstApp = NULL;
263
264 if (!ShellExecuteEx(&shex_info)) {
265 DPLOG(ERROR);
266 return false;
267 }
268
269 if (options.wait)
270 WaitForSingleObject(shex_info.hProcess, INFINITE);
271
272 // If the caller wants the process handle give it to them, otherwise just
273 // close it. Closing it does not terminate the process.
274 if (process_handle)
275 *process_handle = shex_info.hProcess;
276 else
277 CloseHandle(shex_info.hProcess);
278
279 return true;
280 }
281
SetJobObjectLimitFlags(HANDLE job_object,DWORD limit_flags)282 bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags) {
283 JOBOBJECT_EXTENDED_LIMIT_INFORMATION limit_info = {0};
284 limit_info.BasicLimitInformation.LimitFlags = limit_flags;
285 return 0 != SetInformationJobObject(
286 job_object,
287 JobObjectExtendedLimitInformation,
288 &limit_info,
289 sizeof(limit_info));
290 }
291
GetAppOutput(const CommandLine & cl,std::string * output)292 bool GetAppOutput(const CommandLine& cl, std::string* output) {
293 return GetAppOutput(cl.GetCommandLineString(), output);
294 }
295
GetAppOutput(const StringPiece16 & cl,std::string * output)296 bool GetAppOutput(const StringPiece16& cl, std::string* output) {
297 HANDLE out_read = NULL;
298 HANDLE out_write = NULL;
299
300 SECURITY_ATTRIBUTES sa_attr;
301 // Set the bInheritHandle flag so pipe handles are inherited.
302 sa_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
303 sa_attr.bInheritHandle = TRUE;
304 sa_attr.lpSecurityDescriptor = NULL;
305
306 // Create the pipe for the child process's STDOUT.
307 if (!CreatePipe(&out_read, &out_write, &sa_attr, 0)) {
308 NOTREACHED() << "Failed to create pipe";
309 return false;
310 }
311
312 // Ensure we don't leak the handles.
313 win::ScopedHandle scoped_out_read(out_read);
314 win::ScopedHandle scoped_out_write(out_write);
315
316 // Ensure the read handle to the pipe for STDOUT is not inherited.
317 if (!SetHandleInformation(out_read, HANDLE_FLAG_INHERIT, 0)) {
318 NOTREACHED() << "Failed to disabled pipe inheritance";
319 return false;
320 }
321
322 FilePath::StringType writable_command_line_string;
323 writable_command_line_string.assign(cl.data(), cl.size());
324
325 STARTUPINFO start_info = {};
326
327 start_info.cb = sizeof(STARTUPINFO);
328 start_info.hStdOutput = out_write;
329 // Keep the normal stdin and stderr.
330 start_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
331 start_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
332 start_info.dwFlags |= STARTF_USESTDHANDLES;
333
334 // Create the child process.
335 PROCESS_INFORMATION temp_process_info = {};
336 if (!CreateProcess(NULL,
337 &writable_command_line_string[0],
338 NULL, NULL,
339 TRUE, // Handles are inherited.
340 0, NULL, NULL, &start_info, &temp_process_info)) {
341 NOTREACHED() << "Failed to start process";
342 return false;
343 }
344 base::win::ScopedProcessInformation proc_info(temp_process_info);
345
346 // Close our writing end of pipe now. Otherwise later read would not be able
347 // to detect end of child's output.
348 scoped_out_write.Close();
349
350 // Read output from the child process's pipe for STDOUT
351 const int kBufferSize = 1024;
352 char buffer[kBufferSize];
353
354 for (;;) {
355 DWORD bytes_read = 0;
356 BOOL success = ReadFile(out_read, buffer, kBufferSize, &bytes_read, NULL);
357 if (!success || bytes_read == 0)
358 break;
359 output->append(buffer, bytes_read);
360 }
361
362 // Let's wait for the process to finish.
363 WaitForSingleObject(proc_info.process_handle(), INFINITE);
364
365 return true;
366 }
367
RaiseProcessToHighPriority()368 void RaiseProcessToHighPriority() {
369 SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
370 }
371
372 } // namespace base
373