The Tor Browser / file revision

 // -*- mode: C++ -*-

 // Copyright (c) 2010, Google Inc.

 // All rights reserved.

 //

 // Redistribution and use in source and binary forms, with or without

 // modification, are permitted provided that the following conditions are

 // met:

 //

 //     * Redistributions of source code must retain the above copyright

 // notice, this list of conditions and the following disclaimer.

 //     * Redistributions in binary form must reproduce the above

 // copyright notice, this list of conditions and the following disclaimer

 // in the documentation and/or other materials provided with the

 // distribution.

 //     * Neither the name of Google Inc. nor the names of its

 // contributors may be used to endorse or promote products derived from

 // this software without specific prior written permission.

 //

 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>

 // macho_reader.h: A class for parsing Mach-O files.

 #ifndef BREAKPAD_COMMON_MAC_MACHO_READER_H_

 #define BREAKPAD_COMMON_MAC_MACHO_READER_H_

 #include <mach-o/loader.h>

 #include <mach-o/fat.h>

 #include <stdint.h>

 #include <stdlib.h>

 #include <unistd.h>

 #include <map>

 #include <string>

 #include <vector>

 #include "common/byte_cursor.h"

 namespace google_breakpad {

 namespace mach_o {

 using std::map;

 using std::string;

 using std::vector;

 // The Mac headers don't specify particular types for these groups of

 // constants, but defining them here provides some documentation

 // value.  We also give them the same width as the fields in which

 // they appear, which makes them a bit easier to use with ByteCursors.

 typedef uint32_t Magic;

 typedef uint32_t FileType;

 typedef uint32_t FileFlags;

 typedef uint32_t LoadCommandType;

 typedef uint32_t SegmentFlags;

 typedef uint32_t SectionFlags;

 // A parser for fat binary files, used to store universal binaries.

 // When applied to a (non-fat) Mach-O file, this behaves as if the

 // file were a fat file containing a single object file.

 class FatReader {

  public:

   // A class for reporting errors found while parsing fat binary files. The

   // default definitions of these methods print messages to stderr.

   class Reporter {

    public:

     // Create a reporter that attributes problems to |filename|.

     explicit Reporter(const string &filename) : filename_(filename) { }

     virtual ~Reporter() { }

     // The data does not begin with a fat binary or Mach-O magic number.

     // This is a fatal error.

     virtual void BadHeader();

     // The Mach-O fat binary file ends abruptly, without enough space

     // to contain an object file it claims is present.

     virtual void MisplacedObjectFile();

     // The file ends abruptly: either it is not large enough to hold a

     // complete header, or the header implies that contents are present

     // beyond the actual end of the file.

     virtual void TooShort();

    private:

     // The filename to which the reader should attribute problems.

     string filename_;

   };

   // Create a fat binary file reader that uses |reporter| to report problems.

   explicit FatReader(Reporter *reporter) : reporter_(reporter) { }

   // Read the |size| bytes at |buffer| as a fat binary file. On success,

   // return true; on failure, report the problem to reporter_ and return

   // false.

   //

   // If the data is a plain Mach-O file, rather than a fat binary file,

   // then the reader behaves as if it had found a fat binary file whose

   // single object file is the Mach-O file.

   bool Read(const uint8_t *buffer, size_t size);

   // Return an array of 'struct fat_arch' structures describing the

   // object files present in this fat binary file. Set |size| to the

   // number of elements in the array.

   //

   // Assuming Read returned true, the entries are validated: it is

   // safe to assume that the offsets and sizes in each 'struct

   // fat_arch' refer to subranges of the bytes passed to Read.

   //

   // If there are no object files in this fat binary, then this

   // function can return NULL.

   //

   // The array is owned by this FatReader instance; it will be freed when

   // this FatReader is destroyed.

   //

   // This function returns a C-style array instead of a vector to make it

   // possible to use the result with OS X functions like NXFindBestFatArch,

   // so that the symbol dumper will behave consistently with other OS X

   // utilities that work with fat binaries.

   const struct fat_arch *object_files(size_t *count) const { 

     *count = object_files_.size();

     if (object_files_.size() > 0)

       return &object_files_[0];

     return NULL;

   }

  private:

   // We use this to report problems parsing the file's contents. (WEAK)

   Reporter *reporter_;

   // The contents of the fat binary or Mach-O file we're parsing. We do not

   // own the storage it refers to.

   ByteBuffer buffer_;

   // The magic number of this binary, in host byte order.

   Magic magic_;

   // The list of object files in this binary.

   // object_files_.size() == fat_header.nfat_arch

   vector<struct fat_arch> object_files_;

 };

 // A segment in a Mach-O file. All these fields have been byte-swapped as

 // appropriate for use by the executing architecture.

 struct Segment {

   // The ByteBuffers below point into the bytes passed to the Reader that

   // created this Segment.

   ByteBuffer section_list;    // This segment's section list.

   ByteBuffer contents;        // This segment's contents.

   // This segment's name.

   string name;

   // The address at which this segment should be loaded in memory. If

   // bits_64 is false, only the bottom 32 bits of this value are valid.

   uint64_t vmaddr;

   // The size of this segment when loaded into memory. This may be larger

   // than contents.Size(), in which case the extra area will be

   // initialized with zeros. If bits_64 is false, only the bottom 32 bits

   // of this value are valid.

   uint64_t vmsize;

   // The maximum and initial VM protection of this segment's contents.

   uint32_t maxprot;

   uint32_t initprot;

   // The number of sections in section_list.

   uint32_t nsects;

   // Flags describing this segment, from SegmentFlags.

   uint32_t flags;

   // True if this is a 64-bit section; false if it is a 32-bit section.

   bool bits_64;

 };

 // A section in a Mach-O file. All these fields have been byte-swapped as

 // appropriate for use by the executing architecture.

 struct Section {

   // This section's contents. This points into the bytes passed to the

   // Reader that created this Section.

   ByteBuffer contents;

   // This section's name.

   string section_name;  // section[_64].sectname

   // The name of the segment this section belongs to.

   string segment_name;  // section[_64].segname

   // The address at which this section's contents should be loaded in

   // memory. If bits_64 is false, only the bottom 32 bits of this value

   // are valid.

   uint64_t address;

   // The contents of this section should be loaded into memory at an

   // address which is a multiple of (two raised to this power).

   uint32_t align;

   // Flags from SectionFlags describing the section's contents.

   uint32_t flags;

   // We don't support reading relocations yet.

   // True if this is a 64-bit section; false if it is a 32-bit section.

   bool bits_64;

 };

 // A map from section names to Sections.

 typedef map<string, Section> SectionMap;

 // A reader for a Mach-O file.

 //

 // This does not handle fat binaries; see FatReader above. FatReader

 // provides a friendly interface for parsing data that could be either a

 // fat binary or a Mach-O file.

 class Reader {

  public:

   // A class for reporting errors found while parsing Mach-O files. The

   // default definitions of these member functions print messages to

   // stderr.

   class Reporter {

    public:

     // Create a reporter that attributes problems to |filename|.

     explicit Reporter(const string &filename) : filename_(filename) { }

     virtual ~Reporter() { }

     // Reporter functions for fatal errors return void; the reader will

     // definitely return an error to its caller after calling them

     // The data does not begin with a Mach-O magic number, or the magic

     // number does not match the expected value for the cpu architecture.

     // This is a fatal error.

     virtual void BadHeader();

     // The data contained in a Mach-O fat binary (|cpu_type|, |cpu_subtype|)

     // does not match the expected CPU architecture

     // (|expected_cpu_type|, |expected_cpu_subtype|).

     virtual void CPUTypeMismatch(cpu_type_t cpu_type,

                                  cpu_subtype_t cpu_subtype,

                                  cpu_type_t expected_cpu_type,

                                  cpu_subtype_t expected_cpu_subtype);

     // The file ends abruptly: either it is not large enough to hold a

     // complete header, or the header implies that contents are present

     // beyond the actual end of the file.

     virtual void HeaderTruncated();

     // The file's load command region, as given in the Mach-O header, is

     // too large for the file.

     virtual void LoadCommandRegionTruncated();

     // The file's Mach-O header claims the file contains |claimed| load

     // commands, but the I'th load command, of type |type|, extends beyond

     // the end of the load command region, as given by the Mach-O header.

     // If |type| is zero, the command's type was unreadable.

     virtual void LoadCommandsOverrun(size_t claimed, size_t i,

                                      LoadCommandType type);

     // The contents of the |i|'th load command, of type |type|, extend beyond

     // the size given in the load command's header.

     virtual void LoadCommandTooShort(size_t i, LoadCommandType type);

     // The LC_SEGMENT or LC_SEGMENT_64 load command for the segment named

     // |name| is too short to hold the sections that its header says it does.

     // (This more specific than LoadCommandTooShort.)

     virtual void SectionsMissing(const string &name);

     // The segment named |name| claims that its contents lie beyond the end

     // of the file.

     virtual void MisplacedSegmentData(const string &name);

     // The section named |section| in the segment named |segment| claims that

     // its contents do not lie entirely within the segment.

     virtual void MisplacedSectionData(const string &section,

                                       const string &segment);

     // The LC_SYMTAB command claims that symbol table contents are located

     // beyond the end of the file.

     virtual void MisplacedSymbolTable();

     // An attempt was made to read a Mach-O file of the unsupported

     // CPU architecture |cpu_type|.

     virtual void UnsupportedCPUType(cpu_type_t cpu_type);

    private:

     string filename_;

   };

   // A handler for sections parsed from a segment. The WalkSegmentSections

   // member function accepts an instance of this class, and applies it to

   // each section defined in a given segment.

   class SectionHandler {

    public:

     virtual ~SectionHandler() { }

     // Called to report that the segment's section list contains |section|.

     // This should return true if the iteration should continue, or false

     // if it should stop.

     virtual bool HandleSection(const Section &section) = 0;

   };

   // A handler for the load commands in a Mach-O file.

   class LoadCommandHandler {

    public:

     LoadCommandHandler() { }

     virtual ~LoadCommandHandler() { }

     // When called from WalkLoadCommands, the following handler functions

     // should return true if they wish to continue iterating over the load

     // command list, or false if they wish to stop iterating.

     //

     // When called from LoadCommandIterator::Handle or Reader::Handle,

     // these functions' return values are simply passed through to Handle's

     // caller.

     //

     // The definitions provided by this base class simply return true; the

     // default is to silently ignore sections whose member functions the

     // subclass doesn't override.

     // COMMAND is load command we don't recognize. We provide only the

     // command type and a ByteBuffer enclosing the command's data (If we

     // cannot parse the command type or its size, we call

     // reporter_->IncompleteLoadCommand instead.)

     virtual bool UnknownCommand(LoadCommandType type,

                                 const ByteBuffer &contents) {

       return true;

     }

     // The load command is LC_SEGMENT or LC_SEGMENT_64, defining a segment

     // with the properties given in |segment|.

     virtual bool SegmentCommand(const Segment &segment) {

       return true;

     }

     // The load command is LC_SYMTAB. |entries| holds the array of nlist

     // entries, and |names| holds the strings the entries refer to.

     virtual bool SymtabCommand(const ByteBuffer &entries,

                                const ByteBuffer &names) {

       return true;

     }

     // Add handler functions for more load commands here as needed.

   };

   // Create a Mach-O file reader that reports problems to |reporter|.

   explicit Reader(Reporter *reporter)

       : reporter_(reporter) { }

   // Read the given data as a Mach-O file. The reader retains pointers

   // into the data passed, so the data should live as long as the reader

   // does. On success, return true; on failure, return false.

   //

   // At most one of these functions should be invoked once on each Reader

   // instance.

   bool Read(const uint8_t *buffer,

             size_t size,

             cpu_type_t expected_cpu_type,

             cpu_subtype_t expected_cpu_subtype);

   bool Read(const ByteBuffer &buffer,

             cpu_type_t expected_cpu_type,

             cpu_subtype_t expected_cpu_subtype) {

     return Read(buffer.start,

                 buffer.Size(),

                 expected_cpu_type,

                 expected_cpu_subtype); 

   }

   // Return this file's characteristics, as found in the Mach-O header.

   cpu_type_t    cpu_type()    const { return cpu_type_; }

   cpu_subtype_t cpu_subtype() const { return cpu_subtype_; }

   FileType      file_type()   const { return file_type_; }

   FileFlags     flags()       const { return flags_; }

   // Return true if this is a 64-bit Mach-O file, false if it is a 32-bit

   // Mach-O file.

   bool bits_64() const { return bits_64_; }

   // Return true if this is a big-endian Mach-O file, false if it is

   // little-endian.

   bool big_endian() const { return big_endian_; }

   // Apply |handler| to each load command in this Mach-O file, stopping when

   // a handler function returns false. If we encounter a malformed load

   // command, report it via reporter_ and return false. Return true if all

   // load commands were parseable and all handlers returned true.

   bool WalkLoadCommands(LoadCommandHandler *handler) const;

   // Set |segment| to describe the segment named |name|, if present. If

   // found, |segment|'s byte buffers refer to a subregion of the bytes

   // passed to Read. If we find the section, return true; otherwise,

   // return false.

   bool FindSegment(const string &name, Segment *segment) const;

   // Apply |handler| to each section defined in |segment|. If |handler| returns

   // false, stop iterating and return false. If all calls to |handler| return

   // true and we reach the end of the section list, return true.

   bool WalkSegmentSections(const Segment &segment, SectionHandler *handler)

     const;

   // Clear |section_map| and then populate it with a map of the sections

   // in |segment|, from section names to Section structures.

   // Each Section's contents refer to bytes in |segment|'s contents.

   // On success, return true; if a problem occurs, report it and return false.

   bool MapSegmentSections(const Segment &segment, SectionMap *section_map)

     const;

  private:

   // Used internally.

   class SegmentFinder;

   class SectionMapper;

   // We use this to report problems parsing the file's contents. (WEAK)

   Reporter *reporter_;

   // The contents of the Mach-O file we're parsing. We do not own the

   // storage it refers to.

   ByteBuffer buffer_;

   // True if this file is big-endian.

   bool big_endian_;

   // True if this file is a 64-bit Mach-O file.

   bool bits_64_;

   // This file's cpu type and subtype.

   cpu_type_t cpu_type_;        // mach_header[_64].cputype

   cpu_subtype_t cpu_subtype_;  // mach_header[_64].cpusubtype

   // This file's type.

   FileType file_type_;         // mach_header[_64].filetype

   // The region of buffer_ occupied by load commands.

   ByteBuffer load_commands_;

   // The number of load commands in load_commands_.

   uint32_t load_command_count_;  // mach_header[_64].ncmds

   // This file's header flags.

   FileFlags flags_;

 };

 }  // namespace mach_o

 }  // namespace google_breakpad

 #endif  // BREAKPAD_COMMON_MAC_MACHO_READER_H_