The Tor Browser: ipc/chromium/src/base/process_util

ipc/chromium/src/base/process_util_win.cc@6474c204b198 (annotated)

ipc/chromium/src/base/process_util_win.cc

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 // We need extended process and thread attribute support
 #undef _WIN32_WINNT
 #define _WIN32_WINNT 0x0600
 #include "base/process_util.h"
 #include <windows.h>
 #include <winternl.h>
 #include <psapi.h>
 #include "base/debug_util.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/scoped_handle_win.h"
 #include "base/scoped_ptr.h"
 #include "base/win_util.h"
 #include <algorithm>
 namespace {
 // System pagesize. This value remains constant on x86/64 architectures.
 const int PAGESIZE_KB = 4;
 // HeapSetInformation function pointer.
 typedef BOOL (WINAPI* HeapSetFn)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);
 typedef BOOL (WINAPI * InitializeProcThreadAttributeListFn)(
   LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
   DWORD dwAttributeCount,
   DWORD dwFlags,
   PSIZE_T lpSize
 );
 typedef BOOL (WINAPI * DeleteProcThreadAttributeListFn)(
   LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList
 );
 typedef BOOL (WINAPI * UpdateProcThreadAttributeFn)(
   LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
   DWORD dwFlags,
   DWORD_PTR Attribute,
   PVOID lpValue,
   SIZE_T cbSize,
   PVOID lpPreviousValue,
   PSIZE_T lpReturnSize
 );
 static InitializeProcThreadAttributeListFn InitializeProcThreadAttributeListPtr;
 static DeleteProcThreadAttributeListFn DeleteProcThreadAttributeListPtr;
 static UpdateProcThreadAttributeFn UpdateProcThreadAttributePtr;
 static mozilla::EnvironmentLog gProcessLog("MOZ_PROCESS_LOG");
 }  // namespace
 namespace base {
 ProcessId GetCurrentProcId() {
   return ::GetCurrentProcessId();
 }
 ProcessHandle GetCurrentProcessHandle() {
   return ::GetCurrentProcess();
 }
 bool OpenProcessHandle(ProcessId pid, ProcessHandle* handle) {
   // TODO(phajdan.jr): Take even more permissions out of this list.
   ProcessHandle result = OpenProcess(PROCESS_DUP_HANDLE |
                                          PROCESS_TERMINATE |
                                          PROCESS_QUERY_INFORMATION |
                                          SYNCHRONIZE,
                                      FALSE, pid);
   if (result == INVALID_HANDLE_VALUE)
     return false;
   *handle = result;
   return true;
 }
 bool OpenPrivilegedProcessHandle(ProcessId pid, ProcessHandle* handle) {
   ProcessHandle result = OpenProcess(PROCESS_DUP_HANDLE |
                                          PROCESS_TERMINATE |
                                          PROCESS_QUERY_INFORMATION |
                                          PROCESS_VM_READ |
                                          SYNCHRONIZE,
                                      FALSE, pid);
   if (result == INVALID_HANDLE_VALUE)
     return false;
   *handle = result;
   return true;
 }
 void CloseProcessHandle(ProcessHandle process) {
   // closing a handle twice on Windows can be catastrophic - after the first
   // close the handle value may be reused, so the second close will kill that
   // other new handle.
   BOOL ok = CloseHandle(process);
   DCHECK(ok);
 }
 // Helper for GetProcId()
 bool GetProcIdViaGetProcessId(ProcessHandle process, DWORD* id) {
   // Dynamically get a pointer to GetProcessId().
   typedef DWORD (WINAPI *GetProcessIdFunction)(HANDLE);
   static GetProcessIdFunction GetProcessIdPtr = NULL;
   static bool initialize_get_process_id = true;
   if (initialize_get_process_id) {
     initialize_get_process_id = false;
     HMODULE kernel32_handle = GetModuleHandle(L"kernel32.dll");
     if (!kernel32_handle) {
       NOTREACHED();
       return false;
     }
     GetProcessIdPtr = reinterpret_cast<GetProcessIdFunction>(GetProcAddress(
         kernel32_handle, "GetProcessId"));
   }
   if (!GetProcessIdPtr)
     return false;
   // Ask for the process ID.
   *id = (*GetProcessIdPtr)(process);
   return true;
 }
 // Helper for GetProcId()
 bool GetProcIdViaNtQueryInformationProcess(ProcessHandle process, DWORD* id) {
   // Dynamically get a pointer to NtQueryInformationProcess().
   typedef NTSTATUS (WINAPI *NtQueryInformationProcessFunction)(
       HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG);
   static NtQueryInformationProcessFunction NtQueryInformationProcessPtr = NULL;
   static bool initialize_query_information_process = true;
   if (initialize_query_information_process) {
     initialize_query_information_process = false;
     // According to nsylvain, ntdll.dll is guaranteed to be loaded, even though
     // the Windows docs seem to imply that you should LoadLibrary() it.
     HMODULE ntdll_handle = GetModuleHandle(L"ntdll.dll");
     if (!ntdll_handle) {
       NOTREACHED();
       return false;
     }
     NtQueryInformationProcessPtr =
         reinterpret_cast<NtQueryInformationProcessFunction>(GetProcAddress(
             ntdll_handle, "NtQueryInformationProcess"));
   }
   if (!NtQueryInformationProcessPtr)
     return false;
   // Ask for the process ID.
   PROCESS_BASIC_INFORMATION info;
   ULONG bytes_returned;
   NTSTATUS status = (*NtQueryInformationProcessPtr)(process,
                                                     ProcessBasicInformation,
                                                     &info, sizeof info,
                                                     &bytes_returned);
   if (!SUCCEEDED(status) || (bytes_returned != (sizeof info)))
     return false;
   *id = static_cast<DWORD>(info.UniqueProcessId);
   return true;
 }
 ProcessId GetProcId(ProcessHandle process) {
   // Get a handle to |process| that has PROCESS_QUERY_INFORMATION rights.
   HANDLE current_process = GetCurrentProcess();
   HANDLE process_with_query_rights;
   if (DuplicateHandle(current_process, process, current_process,
                       &process_with_query_rights, PROCESS_QUERY_INFORMATION,
                       false, 0)) {
     // Try to use GetProcessId(), if it exists.  Fall back on
     // NtQueryInformationProcess() otherwise (< Win XP SP1).
     DWORD id;
     bool success =
         GetProcIdViaGetProcessId(process_with_query_rights, &id) ||
         GetProcIdViaNtQueryInformationProcess(process_with_query_rights, &id);
     CloseHandle(process_with_query_rights);
     if (success)
       return id;
   }
   // We're screwed.
   NOTREACHED();
   return 0;
 }
 // from sandbox_policy_base.cc in a later version of the chromium ipc code...
 bool IsInheritableHandle(HANDLE handle) {
   if (!handle)
     return false;
   if (handle == INVALID_HANDLE_VALUE)
     return false;
   // File handles (FILE_TYPE_DISK) and pipe handles are known to be
   // inheritable.  Console handles (FILE_TYPE_CHAR) are not
   // inheritable via PROC_THREAD_ATTRIBUTE_HANDLE_LIST.
   DWORD handle_type = GetFileType(handle);
   return handle_type == FILE_TYPE_DISK || handle_type == FILE_TYPE_PIPE;
 }
 void LoadThreadAttributeFunctions() {
   HMODULE kernel32 = GetModuleHandle(L"kernel32.dll");
   InitializeProcThreadAttributeListPtr =
     reinterpret_cast<InitializeProcThreadAttributeListFn>
     (GetProcAddress(kernel32, "InitializeProcThreadAttributeList"));
   DeleteProcThreadAttributeListPtr =
     reinterpret_cast<DeleteProcThreadAttributeListFn>
     (GetProcAddress(kernel32, "DeleteProcThreadAttributeList"));
   UpdateProcThreadAttributePtr =
     reinterpret_cast<UpdateProcThreadAttributeFn>
     (GetProcAddress(kernel32, "UpdateProcThreadAttribute"));
 }
 // Creates and returns a "thread attribute list" to pass to the child process.
 // On return, is a pointer to a THREAD_ATTRIBUTE_LIST or NULL if either the
 // functions we need aren't available (eg, XP or earlier) or the functions we
 // need failed.
 // The result of this function must be passed to FreeThreadAttributeList.
 // Note that the pointer to the HANDLE array ends up embedded in the result of
 // this function and must stay alive until FreeThreadAttributeList is called,
 // hence it is passed in so the owner is the caller of this function.
 LPPROC_THREAD_ATTRIBUTE_LIST CreateThreadAttributeList(HANDLE *handlesToInherit,
                                                        int handleCount) {
   if (!InitializeProcThreadAttributeListPtr ||
       !DeleteProcThreadAttributeListPtr ||
       !UpdateProcThreadAttributePtr)
     LoadThreadAttributeFunctions();
   // shouldn't happen as we are only called for Vista+, but better safe than sorry...
   if (!InitializeProcThreadAttributeListPtr ||
       !DeleteProcThreadAttributeListPtr ||
       !UpdateProcThreadAttributePtr)
     return NULL;
   SIZE_T threadAttrSize;
   LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
   if (!(*InitializeProcThreadAttributeListPtr)(NULL, 1, 0, &threadAttrSize) &&
       GetLastError() != ERROR_INSUFFICIENT_BUFFER)
     goto fail;
   lpAttributeList = reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>
                               (malloc(threadAttrSize));
   if (!lpAttributeList ||
       !(*InitializeProcThreadAttributeListPtr)(lpAttributeList, 1, 0, &threadAttrSize))
     goto fail;
   if (!(*UpdateProcThreadAttributePtr)(lpAttributeList,
 , PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
                   handlesToInherit,
                   sizeof(handlesToInherit[0]) * handleCount,
                   NULL, NULL)) {
     (*DeleteProcThreadAttributeListPtr)(lpAttributeList);
     goto fail;
   }
   return lpAttributeList;
 fail:
   if (lpAttributeList)
     free(lpAttributeList);
   return NULL;
 }
 // Frees the data returned by CreateThreadAttributeList.
 void FreeThreadAttributeList(LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList) {
   // must be impossible to get a NULL DeleteProcThreadAttributeListPtr, as
   // we already checked it existed when creating the data we are now freeing.
   (*DeleteProcThreadAttributeListPtr)(lpAttributeList);
   free(lpAttributeList);
 }
 bool LaunchApp(const std::wstring& cmdline,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
   // We want to inherit the std handles so dump() statements and assertion
   // messages in the child process can be seen - but we *do not* want to
   // blindly have all handles inherited.  Vista and later has a technique
   // where only specified handles are inherited - so we use this technique if
   // we can.  If that technique isn't available (or it fails), we just don't
   // inherit anything.  This means that dump() etc isn't going to be seen on
   // XP release builds, but that's OK (developers who really care can run a
   // debug build on XP, where the processes are marked as "console" apps, so
   // things work without these hoops)
   DWORD dwCreationFlags = 0;
   BOOL bInheritHandles = FALSE;
   // We use a STARTUPINFOEX, but if we can't do the thread attribute thing, we
   // just pass the size of a STARTUPINFO.
   STARTUPINFOEX startup_info_ex;
   ZeroMemory(&startup_info_ex, sizeof(startup_info_ex));
   STARTUPINFO &startup_info = startup_info_ex.StartupInfo;
   startup_info.cb = sizeof(startup_info);
   startup_info.dwFlags = STARTF_USESHOWWINDOW;
   startup_info.wShowWindow = start_hidden ? SW_HIDE : SW_SHOW;
   LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList = NULL;
   // Don't even bother trying pre-Vista...
   if (win_util::GetWinVersion() >= win_util::WINVERSION_VISTA) {
     // setup our handle array first - if we end up with no handles that can
     // be inherited we can avoid trying to do the ThreadAttributeList dance...
     HANDLE handlesToInherit[2];
     int handleCount = 0;
     HANDLE stdOut = ::GetStdHandle(STD_OUTPUT_HANDLE);
     HANDLE stdErr = ::GetStdHandle(STD_ERROR_HANDLE);
     if (IsInheritableHandle(stdOut))
       handlesToInherit[handleCount++] = stdOut;
     if (stdErr != stdOut && IsInheritableHandle(stdErr))
       handlesToInherit[handleCount++] = stdErr;
     if (handleCount)
       lpAttributeList = CreateThreadAttributeList(handlesToInherit, handleCount);
   }
   if (lpAttributeList) {
     // it's safe to inherit handles, so arrange for that...
     startup_info.cb = sizeof(startup_info_ex);
     startup_info.dwFlags |= STARTF_USESTDHANDLES;
     startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
     startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
     startup_info.hStdInput = INVALID_HANDLE_VALUE;
     startup_info_ex.lpAttributeList = lpAttributeList;
     dwCreationFlags |= EXTENDED_STARTUPINFO_PRESENT;
     bInheritHandles = TRUE;
   }
   PROCESS_INFORMATION process_info;
   BOOL createdOK = CreateProcess(NULL,
                      const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
                      bInheritHandles, dwCreationFlags, NULL, NULL,
                      &startup_info, &process_info);
   if (lpAttributeList)
     FreeThreadAttributeList(lpAttributeList);
   if (!createdOK)
     return false;
   gProcessLog.print("==> process %d launched child process %d (%S)\n",
                     GetCurrentProcId(),
                     process_info.dwProcessId,
                     cmdline.c_str());
   // Handles must be closed or they will leak
   CloseHandle(process_info.hThread);
   if (wait)
     WaitForSingleObject(process_info.hProcess, INFINITE);
   // If the caller wants the process handle, we won't close it.
   if (process_handle) {
     *process_handle = process_info.hProcess;
   } else {
     CloseHandle(process_info.hProcess);
   }
   return true;
 }
 bool LaunchApp(const CommandLine& cl,
                bool wait, bool start_hidden, ProcessHandle* process_handle) {
   return LaunchApp(cl.command_line_string(), wait,
                    start_hidden, process_handle);
 }
 bool KillProcess(ProcessHandle process, int exit_code, bool wait) {
   bool result = (TerminateProcess(process, exit_code) != FALSE);
   if (result && wait) {
     // The process may not end immediately due to pending I/O
     if (WAIT_OBJECT_0 != WaitForSingleObject(process, 60 * 1000))
       DLOG(ERROR) << "Error waiting for process exit: " << GetLastError();
   } else if (!result) {
     DLOG(ERROR) << "Unable to terminate process: " << GetLastError();
   }
   return result;
 }
 bool DidProcessCrash(bool* child_exited, ProcessHandle handle) {
   DWORD exitcode = 0;
   if (child_exited)
     *child_exited = true;  // On Windows it an error to call this function if
                            // the child hasn't already exited.
   if (!::GetExitCodeProcess(handle, &exitcode)) {
     NOTREACHED();
     return false;
   }
   if (exitcode == STILL_ACTIVE) {
     // The process is likely not dead or it used 0x103 as exit code.
     NOTREACHED();
     return false;
   }
   // Warning, this is not generic code; it heavily depends on the way
   // the rest of the code kills a process.
   if (exitcode == PROCESS_END_NORMAL_TERMINATON ||
       exitcode == PROCESS_END_KILLED_BY_USER ||
       exitcode == PROCESS_END_PROCESS_WAS_HUNG ||
       exitcode == 0xC0000354 ||     // STATUS_DEBUGGER_INACTIVE.
       exitcode == 0xC000013A ||     // Control-C/end session.
       exitcode == 0x40010004) {     // Debugger terminated process/end session.
     return false;
   }
   return true;
 }
 void SetCurrentProcessPrivileges(ChildPrivileges privs) {
 }
 NamedProcessIterator::NamedProcessIterator(const std::wstring& executable_name,
                                            const ProcessFilter* filter)
     : started_iteration_(false),
       executable_name_(executable_name),
       filter_(filter) {
   snapshot_ = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 }
 NamedProcessIterator::~NamedProcessIterator() {
   CloseHandle(snapshot_);
 }
 const ProcessEntry* NamedProcessIterator::NextProcessEntry() {
   bool result = false;
   do {
     result = CheckForNextProcess();
   } while (result && !IncludeEntry());
   if (result) {
     return &entry_;
   }
   return NULL;
 }
 bool NamedProcessIterator::CheckForNextProcess() {
   InitProcessEntry(&entry_);
   if (!started_iteration_) {
     started_iteration_ = true;
     return !!Process32First(snapshot_, &entry_);
   }
   return !!Process32Next(snapshot_, &entry_);
 }
 bool NamedProcessIterator::IncludeEntry() {
   return _wcsicmp(executable_name_.c_str(), entry_.szExeFile) == 0 &&
                   (!filter_ || filter_->Includes(entry_.th32ProcessID,
                                                  entry_.th32ParentProcessID));
 }
 void NamedProcessIterator::InitProcessEntry(ProcessEntry* entry) {
   memset(entry, 0, sizeof(*entry));
   entry->dwSize = sizeof(*entry);
 }
 ///////////////////////////////////////////////////////////////////////////////
 // ProcesMetrics
 ProcessMetrics::ProcessMetrics(ProcessHandle process) : process_(process),
                                                         last_time_(0),
                                                         last_system_time_(0) {
   SYSTEM_INFO system_info;
   GetSystemInfo(&system_info);
   processor_count_ = system_info.dwNumberOfProcessors;
 }
 // static
 ProcessMetrics* ProcessMetrics::CreateProcessMetrics(ProcessHandle process) {
   return new ProcessMetrics(process);
 }
 ProcessMetrics::~ProcessMetrics() { }
 static uint64_t FileTimeToUTC(const FILETIME& ftime) {
   LARGE_INTEGER li;
   li.LowPart = ftime.dwLowDateTime;
   li.HighPart = ftime.dwHighDateTime;
   return li.QuadPart;
 }
 int ProcessMetrics::GetCPUUsage() {
   FILETIME now;
   FILETIME creation_time;
   FILETIME exit_time;
   FILETIME kernel_time;
   FILETIME user_time;
   GetSystemTimeAsFileTime(&now);
   if (!GetProcessTimes(process_, &creation_time, &exit_time,
                        &kernel_time, &user_time)) {
     // We don't assert here because in some cases (such as in the Task Manager)
     // we may call this function on a process that has just exited but we have
     // not yet received the notification.
     return 0;
   }
   int64_t system_time = (FileTimeToUTC(kernel_time) + FileTimeToUTC(user_time)) /
                         processor_count_;
   int64_t time = FileTimeToUTC(now);
   if ((last_system_time_ == 0) || (last_time_ == 0)) {
     // First call, just set the last values.
     last_system_time_ = system_time;
     last_time_ = time;
     return 0;
   }
   int64_t system_time_delta = system_time - last_system_time_;
   int64_t time_delta = time - last_time_;
   DCHECK(time_delta != 0);
   if (time_delta == 0)
     return 0;
   // We add time_delta / 2 so the result is rounded.
   int cpu = static_cast<int>((system_time_delta * 100 + time_delta / 2) /
                              time_delta);
   last_system_time_ = system_time;
   last_time_ = time;
   return cpu;
 }
 }  // namespace base

The Tor Browser / annotate

ipc/chromium/src/base/process_util_win.cc@6474c204b198 (annotated)

ipc/chromium/src/base/process_util_win.cc