elfcpp/elfcpp_file.h

   1 // elfcpp_file.h -- file access for elfcpp   -*- C++ -*-
   2
   3 // This header file defines the class Elf_file which can be used to
   4 // read useful data from an ELF file.  The functions here are all
   5 // templates which take a file interface object as a parameter.  This
   6 // type must have a subtype View.  This type must support two methods:
   7 //     View view(off_t file_offset, off_t data_size)
   8 // returns a View for the specified part of the file.
   9 //     void error(const char* printf_format, ...)
  10 // prints an error message and does not return.  The subtype View must
  11 // support a method
  12 //     const unsigned char* data()
  13 // which returns a pointer to a buffer containing the requested data.
  14 // This general interface is used to read data from the file.  Objects
  15 // of type View will never survive longer than the elfcpp function.
  16
  17 // Some of these functions must return a reference to part of the
  18 // file.  To use these, the file interface must support a subtype
  19 // Location:
  20 //    Location(off_t file_offset, off_t data_size)
  21 // To use this in conjunction with the accessors types Shdr, etc., the
  22 // file interface should support an overload of view:
  23 //    View view(Location)
  24 // This permits writing
  25 //    elfcpp::Shdr shdr(file, ef.section_header(n));
  26
  27 #ifndef ELFPCP_FILE_H
  28 #define ELFCPP_FILE_H
  29
  30 #include <string>
  31 #include <cstring>
  32
  33 namespace elfcpp
  34 {
  35
  36 // This object is used to read an ELF file.
  37 //   SIZE: The size of file, 32 or 64.
  38 //   BIG_ENDIAN: Whether the file is in big-endian format.
  39 //   FILE: A file reading type as described above.
  40
  41 template<int size, bool big_endian, typename File>
  42 class Elf_file
  43 {
  44  private:
  45   typedef Elf_file<size, big_endian, File> This;
  46
  47  public:
  48   static const int ehdr_size = Elf_sizes<size>::ehdr_size;
  49   static const int phdr_size = Elf_sizes<size>::phdr_size;
  50   static const int shdr_size = Elf_sizes<size>::shdr_size;
  51   static const int sym_size = Elf_sizes<size>::sym_size;
  52   static const int rel_size = Elf_sizes<size>::rel_size;
  53   static const int rela_size = Elf_sizes<size>::rela_size;
  54
  55   typedef Ehdr<size, big_endian> Ef_ehdr;
  56   typedef Phdr<size, big_endian> Ef_phdr;
  57   typedef Shdr<size, big_endian> Ef_shdr;
  58   typedef Sym<size, big_endian> Ef_sym;
  59
  60   // Construct an Elf_file given an ELF file header.
  61   Elf_file(File* file, const Ef_ehdr& ehdr)
  62   { this->construct(file, ehdr); }
  63
  64   // Construct an ELF file.
  65   inline
  66   Elf_file(File* file);
  67
  68   // Return the file offset to the section headers.
  69   off_t
  70   shoff() const
  71   { return this->shoff_; }
  72
  73   // Return the number of sections.
  74   unsigned int
  75   shnum()
  76   {
  77     this->initialize_shnum();
  78     return this->shnum_;
  79   }
  80
  81   // Return the section index of the section name string table.
  82   unsigned int
  83   shstrndx()
  84   {
  85     this->initialize_shnum();
  86     return this->shstrndx_;
  87   }
  88
  89   // Return the location of the header of section SHNDX.
  90   typename File::Location
  91   section_header(unsigned int shndx)
  92   {
  93     return typename File::Location(this->section_header_offset(shndx),
  94                                    shdr_size);
  95   }
  96
  97   // Return the name of section SHNDX.
  98   std::string
  99   section_name(unsigned int shndx);
 100
 101   // Return the location of the contents of section SHNDX.
 102   typename File::Location
 103   section_contents(unsigned int shndx);
 104
 105  private:
 106   // Shared constructor code.
 107   void
 108   construct(File* file, const Ef_ehdr& ehdr);
 109
 110   // Initialize shnum_ and shstrndx_.
 111   void
 112   initialize_shnum();
 113
 114   // Return the file offset of the header of section SHNDX.
 115   off_t
 116   section_header_offset(unsigned int shndx);
 117
 118   // The file we are reading.
 119   File* file_;
 120   // The file offset to the section headers.
 121   off_t shoff_;
 122   // The number of sections.
 123   unsigned int shnum_;
 124   // The section index of the section name string table.
 125   unsigned int shstrndx_;
 126 };
 127
 128 // Template function definitions.
 129
 130 // Construct an Elf_file given an ELF file header.
 131
 132 template<int size, bool big_endian, typename File>
 133 void
 134 Elf_file<size, big_endian, File>::construct(File* file, const Ef_ehdr& ehdr)
 135 {
 136   this->file_ = file;
 137   this->shoff_ = ehdr.get_e_shoff();
 138   this->shnum_ = ehdr.get_e_shnum();
 139   this->shstrndx_ = ehdr.get_e_shstrndx();
 140   if (ehdr.get_e_ehsize() != This::ehdr_size)
 141     file->error(_("bad e_ehsize (%d != %d)"),
 142                 ehdr.get_e_ehsize(), This::ehdr_size);
 143   if (ehdr.get_e_shentsize() != This::shdr_size)
 144     file->error(_("bad e_shentsize (%d != %d)"),
 145                 ehdr.get_e_shentsize(), This::shdr_size);
 146 }
 147
 148 // Construct an ELF file.
 149
 150 template<int size, bool big_endian, typename File>
 151 inline
 152 Elf_file<size, big_endian, File>::Elf_file(File* file)
 153 {
 154   typename File::View v(file->view(file_header_offset, This::ehdr_size));
 155   this->construct(file, Ef_ehdr(v.data()));
 156 }
 157
 158 // Initialize the shnum_ and shstrndx_ fields, handling overflow.
 159
 160 template<int size, bool big_endian, typename File>
 161 void
 162 Elf_file<size, big_endian, File>::initialize_shnum()
 163 {
 164   if ((this->shnum_ == 0 || this->shstrndx_ == SHN_XINDEX)
 165       && this->shoff_ != 0)
 166     {
 167       typename File::View v(this->file_->view(this->shoff_, This::shdr_size));
 168       Ef_shdr shdr(v.data());
 169       if (this->shnum_ == 0)
 170         this->shnum_ = shdr.get_sh_size();
 171       if (this->shstrndx_ == SHN_XINDEX)
 172         this->shstrndx_ = shdr.get_sh_link();
 173     }
 174 }
 175
 176 // Return the file offset of the section header of section SHNDX.
 177
 178 template<int size, bool big_endian, typename File>
 179 off_t
 180 Elf_file<size, big_endian, File>::section_header_offset(unsigned int shndx)
 181 {
 182   if (shndx >= this->shnum())
 183     this->file_->error(_("section_header_offset: bad shndx %u >= %u"),
 184                        shndx, this->shnum());
 185   return this->shoff_ + This::shdr_size * shndx;
 186 }
 187
 188 // Return the name of section SHNDX.
 189
 190 template<int size, bool big_endian, typename File>
 191 std::string
 192 Elf_file<size, big_endian, File>::section_name(unsigned int shndx)
 193 {
 194   File* const file = this->file_;
 195
 196   // Get the section name offset.
 197   unsigned int sh_name;
 198   {
 199     typename File::View v(file->view(this->section_header_offset(shndx),
 200                                      This::shdr_size));
 201     Ef_shdr shdr(v.data());
 202     sh_name = shdr.get_sh_name();
 203   }
 204
 205   // Get the file offset for the section name string table data.
 206   off_t shstr_off;
 207   off_t shstr_size;
 208   {
 209     const unsigned int shstrndx = this->shstrndx_;
 210     typename File::View v(file->view(this->section_header_offset(shstrndx),
 211                                      This::shdr_size));
 212     Ef_shdr shstr_shdr(v.data());
 213     shstr_off = shstr_shdr.get_sh_offset();
 214     shstr_size = shstr_shdr.get_sh_size();
 215   }
 216
 217   if (sh_name >= shstr_size)
 218     file->error(_("bad section name offset for section %u: %u"),
 219                 shndx, sh_name);
 220
 221   typename File::View v(file->view(shstr_off, shstr_size));
 222
 223   const unsigned char* datau = v.data();
 224   const char* data = reinterpret_cast<const char*>(datau);
 225   const void* p = ::memchr(data + sh_name, '\0', shstr_size - sh_name);
 226   if (p == NULL)
 227     file->error(_("missing null terminator for name of section %u"),
 228                 shndx);
 229
 230   size_t len = static_cast<const char*>(p) - (data + sh_name);
 231
 232   return std::string(data + sh_name, len);
 233 }
 234
 235 // Return the contents of section SHNDX.
 236
 237 template<int size, bool big_endian, typename File>
 238 typename File::Location
 239 Elf_file<size, big_endian, File>::section_contents(unsigned int shndx)
 240 {
 241   File* const file = this->file_;
 242
 243   if (shndx >= this->shnum())
 244     file->error(_("section_contents: bad shndx %u >= %u"),
 245                 shndx, this->shnum());
 246
 247   typename File::View v(file->view(this->section_header_offset(shndx),
 248                                    This::shdr_size));
 249   Ef_shdr shdr(v.data());
 250   return typename File::Location(shdr.get_sh_offset(), shdr.get_sh_size());
 251 }
 252
 253 } // End namespace elfcpp.
 254
 255 #endif // !defined(ELFCPP_FILE_H)