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
37namespace base {
38
39namespace {
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.
47const DWORD kProcessKilledExitCode = 1;
48
49}  // namespace
50
51void 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
108bool 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
235bool 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
247bool 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
282bool 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
292bool GetAppOutput(const CommandLine& cl, std::string* output) {
293  return GetAppOutput(cl.GetCommandLineString(), output);
294}
295
296bool 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
368void RaiseProcessToHighPriority() {
369  SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
370}
371
372}  // namespace base
373