win: make CrashpadInfo retrievable

util/win/process_info.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 62 matching lines @@
     PLOG(ERROR) << "ReadProcessMemory UNICODE_STRING";
     return false;
   }
   if (bytes_read != us.Length) {
     LOG(ERROR) << "ReadProcessMemory UNICODE_STRING incorrect size";
     return false;
   }
   return true;
 }
 
-template <class T> bool ReadStruct(HANDLE process, uintptr_t at, T* into) {
+template <class T> bool ReadStruct(HANDLE process, WinVMAddress at, T* into) {
   SIZE_T bytes_read;
   if (!ReadProcessMemory(process,
                          reinterpret_cast<const void*>(at),
                          into,
                          sizeof(T),
                          &bytes_read)) {
     // We don't have a name for the type we're reading, so include the signature
     // to get the type of T.
     PLOG(ERROR) << "ReadProcessMemory " << __FUNCSIG__;
     return false;
   }
   if (bytes_read != sizeof(T)) {
     LOG(ERROR) << "ReadProcessMemory " << __FUNCSIG__ << " incorrect size";
     return false;
   }
   return true;
 }
 
 }  // namespace
 
 template <class Traits>
 bool ReadProcessData(HANDLE process,
-                     uintptr_t peb_address_uintptr,
+                     WinVMAddress peb_address_vmaddr,
                      ProcessInfo* process_info) {
   Traits::Pointer peb_address;
-  if (!AssignIfInRange(&peb_address, peb_address_uintptr)) {
-    LOG(ERROR) << "peb_address_uintptr " << peb_address_uintptr
+  if (!AssignIfInRange(&peb_address, peb_address_vmaddr)) {
+    LOG(ERROR) << "peb_address_vmaddr " << peb_address_vmaddr
                << " out of range";
     return false;
   }
 
   // Try to read the process environment block.
   process_types::PEB<Traits> peb;
   if (!ReadStruct(process, peb_address, &peb))
     return false;
 
   process_types::RTL_USER_PROCESS_PARAMETERS<Traits> process_parameters;
   if (!ReadStruct(process, peb.ProcessParameters, &process_parameters))
     return false;
 
   if (!ReadUnicodeString(process,
                          process_parameters.CommandLine,
                          &process_info->command_line_)) {
     return false;
   }
 
   process_types::PEB_LDR_DATA<Traits> peb_ldr_data;
   if (!ReadStruct(process, peb.Ldr, &peb_ldr_data))
     return false;
 
-  std::wstring module;
   process_types::LDR_DATA_TABLE_ENTRY<Traits> ldr_data_table_entry;
 
   // Include the first module in the memory order list to get our the main
   // executable's name, as it's not included in initialization order below.
   if (!ReadStruct(process,
-                  reinterpret_cast<uintptr_t>(
+                  reinterpret_cast<WinVMAddress>(
                       reinterpret_cast<const char*>(
                           peb_ldr_data.InMemoryOrderModuleList.Flink) -
                       offsetof(process_types::LDR_DATA_TABLE_ENTRY<Traits>,
                                InMemoryOrderLinks)),
                   &ldr_data_table_entry)) {
     return false;
   }
-  if (!ReadUnicodeString(process, ldr_data_table_entry.FullDllName, &module))
+  ProcessInfo::Module module;
+  if (!ReadUnicodeString(
+          process, ldr_data_table_entry.FullDllName, &module.name)) {
     return false;
+  }
+  module.dll_base = ldr_data_table_entry.DllBase;
+  module.size = ldr_data_table_entry.SizeOfImage;
+  module.timestamp = ldr_data_table_entry.TimeDateStamp;
   process_info->modules_.push_back(module);
 
   // Walk the PEB LDR structure (doubly-linked list) to get the list of loaded
   // modules. We use this method rather than EnumProcessModules to get the
   // modules in initialization order rather than memory order.
   Traits::Pointer last = peb_ldr_data.InInitializationOrderModuleList.Blink;
   for (Traits::Pointer cur = peb_ldr_data.InInitializationOrderModuleList.Flink;
        ;
        cur = ldr_data_table_entry.InInitializationOrderLinks.Flink) {
     // |cur| is the pointer to the LIST_ENTRY embedded in the
     // LDR_DATA_TABLE_ENTRY, in the target process's address space. So we need
     // to read from the target, and also offset back to the beginning of the
     // structure.
     if (!ReadStruct(process,
-                    reinterpret_cast<uintptr_t>(
+                    reinterpret_cast<WinVMAddress>(
                         reinterpret_cast<const char*>(cur) -
                         offsetof(process_types::LDR_DATA_TABLE_ENTRY<Traits>,
                                  InInitializationOrderLinks)),
                     &ldr_data_table_entry)) {
       break;
     }
-    // TODO(scottmg): Capture TimeDateStamp, Checksum, etc. too?
-    if (!ReadUnicodeString(process, ldr_data_table_entry.FullDllName, &module))
+    // TODO(scottmg): Capture Checksum, etc. too?
+    if (!ReadUnicodeString(
+            process, ldr_data_table_entry.FullDllName, &module.name)) {
       break;
+    }
+    module.dll_base = ldr_data_table_entry.DllBase;
+    module.size = ldr_data_table_entry.SizeOfImage;
+    module.timestamp = ldr_data_table_entry.TimeDateStamp;
     process_info->modules_.push_back(module);
     if (cur == last)
       break;
   }
 
   return true;
 }
 
+ProcessInfo::Module::Module() : name(), dll_base(0), size(0), timestamp() {
+}
+
+ProcessInfo::Module::~Module() {
+}
+
 ProcessInfo::ProcessInfo()
     : process_id_(),
       inherited_from_process_id_(),
       command_line_(),
       modules_(),
       is_64_bit_(false),
       is_wow64_(false),
       initialized_() {
 }
 
@@ skipping 52 matching lines @@
     return false;
   }
   process_id_ = process_basic_information.UniqueProcessId;
   inherited_from_process_id_ =
       process_basic_information.InheritedFromUniqueProcessId;
 
   // We now want to read the PEB to gather the rest of our information. The
   // PebBaseAddress as returned above is what we want for 64-on-64 and 32-on-32,
   // but for Wow64, we want to read the 32 bit PEB (a Wow64 process has both).
   // The address of this is found by a second call to NtQueryInformationProcess.
-  uintptr_t peb_address = process_basic_information.PebBaseAddress;
+  WinVMAddress peb_address = process_basic_information.PebBaseAddress;
   if (is_wow64_) {
     ULONG_PTR wow64_peb_address;
     status =
         crashpad::NtQueryInformationProcess(process,
                                             ProcessWow64Information,
                                             &wow64_peb_address,
                                             sizeof(wow64_peb_address),
                                             &bytes_returned);
     if (status < 0) {
       LOG(ERROR) << "NtQueryInformationProcess: status=" << status;
@@ skipping 37 matching lines @@
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return inherited_from_process_id_;
 }
 
 bool ProcessInfo::CommandLine(std::wstring* command_line) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   *command_line = command_line_;
   return true;
 }
 
-bool ProcessInfo::Modules(std::vector<std::wstring>* modules) const {
+bool ProcessInfo::Modules(std::vector<Module>* modules) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   *modules = modules_;
   return true;
 }
 
 }  // namespace crashpad