win: make CrashpadInfo retrievable

snapshot/win/pe_image_reader.h

Index: snapshot/win/pe_image_reader.h
diff --git a/snapshot/win/pe_image_reader.h b/snapshot/win/pe_image_reader.h
new file mode 100644
index 0000000000000000000000000000000000000000..a9317eb9acb0a8987a803bb728a43d6174f26211
--- /dev/null
+++ b/snapshot/win/pe_image_reader.h
@@ -0,0 +1,109 @@
+// 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,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CRASHPAD_SNAPSHOT_WIN_PE_IMAGE_READER_H_
+#define CRASHPAD_SNAPSHOT_WIN_PE_IMAGE_READER_H_
+
+#include <windows.h>
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "util/misc/initialization_state_dcheck.h"
+#include "util/numeric/checked_address_range.h"
+
+namespace crashpad {
+
+class ProcessReaderWin;
+
+namespace process_types {
+
+// TODO(scottmg): Genericize and/or? move process_types out of mac/.
+struct CrashpadInfo {
+  uint32_t signature;
+  uint32_t size;
+  uint32_t version;
+  uint8_t crashpad_handler_behavior;  // TriState.
+  uint8_t system_crash_reporter_forwarding;  // TriState.
+  uint16_t padding_0;
+  uint64_t simple_annotations;  // TODO(scottmg): x86/64.
+};
+
+struct Section {
+};
+
+}  // namespace process_types
+
+//! \brief A reader for PE images mapped into another process.
+//!
+//! This class is capable of reading both 32-bit and 64-bit images based on the
+//! bitness of the remote process.
+//!
+//! \sa PEImageAnnotationsReader
+class PEImageReader {
+ public:
+  PEImageReader();
+  ~PEImageReader();
+
+  //! \brief Initializes the reader.
+  //!
+  //! This method must be called only once on an object. This method must be
+  //! called successfully before any other method in this class may be called.
+  //!
+  //! \param[in] process_reader The reader for the remote process.
+  //! \param[in] address The address, in the remote process' address space,
+  //!     where the `IMAGE_DOS_HEADER` is located.
+  //! \param[in] size The size of the image.
+  //! \param[in] name The module's name, a string to be used in logged messages.
+  //!     This string is for diagnostic purposes.
+  //!
+  //! \return `true` if the image was read successfully, `false` otherwise, with
+  //!     an appropriate message logged.
+  bool Initialize(ProcessReaderWin* process_reader,
+                  uintptr_t address,
+                  uintptr_t size,

[Mark Mentovai, 2015/04/30 20:58:35]

I don’t love uintptr_t for sizes. size_t is better.

Not that we’re sure we’ll need 32-reads-64 (you actually mentioned that you’re
more sure we won’t), but if you want to preserve the ability to do 32-reads-64,
these shouldn’t be uintptr_t or size_t. They should be uint64_t or new typedefs
equivalent to uint64_t. On the other hand, while most of this class does seem to
accept 32-reads-64 (once the TODOs are resolved), if you’re still very against
it, this isn’t necessary. The typedefs still might be nice for documentary
value, though. On Mac, we’re able to use the system-supplied mach_vm_address_t
and mach_vm_size_t.

I think that these two things bubble through this file and even to other files
(checked_address_range) a little bit, but I’m only mentioning them here.

[scottmg, 2015/04/30 22:09:44]

I started making an address_types.h, but then recalled that e.g.
ReadProcessMemory
https://msdn.microsoft.com/en-ca/library/windows/desktop/ms680553%28v=vs.85%2...
takes a base address of "void*". So it would mean a separate code path for
escaping WoW64 for only the 32-to-64 case that I suspect won't be worth the
effort in writing or testing.

So, I've switched to uintptr_t/size_t for now. Hopefully it won't be a major
effort to amend that in the future anyway.

[scottmg, 2015/04/30 22:12:23]

Although now that I say that... e.g. ModuleSnapshot is uint64_t directly. So...
I'll make a couple types I think. It's useful for documentation value as you say
and there's not much cost.

[scottmg, 2015/04/30 22:28:23]

Lacking a better name, I used win_vm_address_t and win_vm_size_t. WinVmAddress
and WinVmSize would I guess be more standard, but makes them feel like maybe
they're more than they actually are.

+                  const std::string& module_name);
+
+  //! \brief Obtains the module's CrashpadInfo structure.
+  //!
+  //! \return `true` on success, `false` on failure. If the module does not have
+  //!     a `CPADinfo` section, this will return `false` without logging any
+  //!     messages. Other failures will result in messages being logged.
+  bool GetCrashpadInfo(process_types::CrashpadInfo* crashpad_info) const;
+
+ private:
+  //! \brief Finds a given section by name in the image.
+  bool GetSectionByName(const std::string& name,
+                        IMAGE_SECTION_HEADER* section) const;
+
+  //! \brief Reads memory from target process, first checking whether the range
+  //!     requested falls inside module_range_.
+  //!
+  //! \return `true` on success, with \a into filled out, otherwise `false` and
+  //!     a message will be logged.
+  bool CheckedReadMemory(uintptr_t address, uintptr_t size, void* into) const;
+
+  ProcessReaderWin* process_reader_;  // weak
+  uintptr_t address_;
+  uintptr_t size_;
+  CheckedAddressRange module_range_;
+  std::string module_name_;
+  InitializationStateDcheck initialized_;
+
+  DISALLOW_COPY_AND_ASSIGN(PEImageReader);
+};
+
+}  // namespace crashpad
+
+#endif  // CRASHPAD_SNAPSHOT_WIN_PE_IMAGE_READER_H_