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