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