ceph/src/boost/boost/dll/detail/pe_info.hpp

   1 // Copyright 2014 Renato Tegon Forti, Antony Polukhin.
   2 // Copyright 2015 Antony Polukhin.
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt
   6 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   7
   8 #ifndef BOOST_DLL_DETAIL_WINDOWS_PE_INFO_HPP
   9 #define BOOST_DLL_DETAIL_WINDOWS_PE_INFO_HPP
  10
  11 #include <boost/config.hpp>
  12
  13 #ifdef BOOST_HAS_PRAGMA_ONCE
  14 # pragma once
  15 #endif
  16
  17 #include <boost/cstdint.hpp>
  18 #include <boost/filesystem/fstream.hpp>
  19 #include <boost/dll/detail/x_info_interface.hpp>
  20
  21 namespace boost { namespace dll { namespace detail {
  22
  23 // reference:
  24 // http://www.joachim-bauch.de/tutorials/loading-a-dll-from-memory/
  25 // http://msdn.microsoft.com/en-us/magazine/ms809762.aspx
  26 // http://msdn.microsoft.com/en-us/magazine/cc301808.aspx
  27 //
  28
  29 // Basic Windows typedefs. We can not use <boost/winapi/basic_types.hpp> header
  30 // because that header must be included only on Windows platform
  31 typedef unsigned char BYTE_;
  32 typedef unsigned short WORD_;
  33 typedef boost::uint32_t DWORD_;
  34 typedef boost::int32_t LONG_;
  35 typedef boost::uint32_t ULONG_;
  36 typedef boost::int64_t LONGLONG_;
  37 typedef boost::uint64_t ULONGLONG_;
  38
  39 struct IMAGE_DOS_HEADER_ { // 32/64 independent header
  40     boost::dll::detail::WORD_   e_magic;        // Magic number
  41     boost::dll::detail::WORD_   e_cblp;         // Bytes on last page of file
  42     boost::dll::detail::WORD_   e_cp;           // Pages in file
  43     boost::dll::detail::WORD_   e_crlc;         // Relocations
  44     boost::dll::detail::WORD_   e_cparhdr;      // Size of header in paragraphs
  45     boost::dll::detail::WORD_   e_minalloc;     // Minimum extra paragraphs needed
  46     boost::dll::detail::WORD_   e_maxalloc;     // Maximum extra paragraphs needed
  47     boost::dll::detail::WORD_   e_ss;           // Initial (relative) SS value
  48     boost::dll::detail::WORD_   e_sp;           // Initial SP value
  49     boost::dll::detail::WORD_   e_csum;         // Checksum
  50     boost::dll::detail::WORD_   e_ip;           // Initial IP value
  51     boost::dll::detail::WORD_   e_cs;           // Initial (relative) CS value
  52     boost::dll::detail::WORD_   e_lfarlc;       // File address of relocation table
  53     boost::dll::detail::WORD_   e_ovno;         // Overlay number
  54     boost::dll::detail::WORD_   e_res[4];       // Reserved words
  55     boost::dll::detail::WORD_   e_oemid;        // OEM identifier (for e_oeminfo)
  56     boost::dll::detail::WORD_   e_oeminfo;      // OEM information; e_oemid specific
  57     boost::dll::detail::WORD_   e_res2[10];     // Reserved words
  58     boost::dll::detail::LONG_   e_lfanew;       // File address of new exe header
  59 };
  60
  61 struct IMAGE_FILE_HEADER_ { // 32/64 independent header
  62     boost::dll::detail::WORD_   Machine;
  63     boost::dll::detail::WORD_   NumberOfSections;
  64     boost::dll::detail::DWORD_  TimeDateStamp;
  65     boost::dll::detail::DWORD_  PointerToSymbolTable;
  66     boost::dll::detail::DWORD_  NumberOfSymbols;
  67     boost::dll::detail::WORD_   SizeOfOptionalHeader;
  68     boost::dll::detail::WORD_   Characteristics;
  69 };
  70
  71 struct IMAGE_DATA_DIRECTORY_ { // 32/64 independent header
  72     boost::dll::detail::DWORD_  VirtualAddress;
  73     boost::dll::detail::DWORD_  Size;
  74 };
  75
  76 struct IMAGE_EXPORT_DIRECTORY_ { // 32/64 independent header
  77     boost::dll::detail::DWORD_  Characteristics;
  78     boost::dll::detail::DWORD_  TimeDateStamp;
  79     boost::dll::detail::WORD_   MajorVersion;
  80     boost::dll::detail::WORD_   MinorVersion;
  81     boost::dll::detail::DWORD_  Name;
  82     boost::dll::detail::DWORD_  Base;
  83     boost::dll::detail::DWORD_  NumberOfFunctions;
  84     boost::dll::detail::DWORD_  NumberOfNames;
  85     boost::dll::detail::DWORD_  AddressOfFunctions;
  86     boost::dll::detail::DWORD_  AddressOfNames;
  87     boost::dll::detail::DWORD_  AddressOfNameOrdinals;
  88 };
  89
  90 struct IMAGE_SECTION_HEADER_ { // 32/64 independent header
  91     static const std::size_t    IMAGE_SIZEOF_SHORT_NAME_ = 8;
  92
  93     boost::dll::detail::BYTE_   Name[IMAGE_SIZEOF_SHORT_NAME_];
  94     union {
  95         boost::dll::detail::DWORD_   PhysicalAddress;
  96         boost::dll::detail::DWORD_   VirtualSize;
  97     } Misc;
  98     boost::dll::detail::DWORD_  VirtualAddress;
  99     boost::dll::detail::DWORD_  SizeOfRawData;
 100     boost::dll::detail::DWORD_  PointerToRawData;
 101     boost::dll::detail::DWORD_  PointerToRelocations;
 102     boost::dll::detail::DWORD_  PointerToLinenumbers;
 103     boost::dll::detail::WORD_   NumberOfRelocations;
 104     boost::dll::detail::WORD_   NumberOfLinenumbers;
 105     boost::dll::detail::DWORD_  Characteristics;
 106 };
 107
 108
 109 template <class AddressOffsetT>
 110 struct IMAGE_OPTIONAL_HEADER_template {
 111     static const std::size_t IMAGE_NUMBEROF_DIRECTORY_ENTRIES_ = 16;
 112
 113     boost::dll::detail::WORD_   Magic;
 114     boost::dll::detail::BYTE_   MajorLinkerVersion;
 115     boost::dll::detail::BYTE_   MinorLinkerVersion;
 116     boost::dll::detail::DWORD_  SizeOfCode;
 117     boost::dll::detail::DWORD_  SizeOfInitializedData;
 118     boost::dll::detail::DWORD_  SizeOfUninitializedData;
 119     boost::dll::detail::DWORD_  AddressOfEntryPoint;
 120     union {
 121         boost::dll::detail::DWORD_   BaseOfCode;
 122         unsigned char padding_[sizeof(AddressOffsetT) == 8 ? 4 : 8]; // in x64 version BaseOfData does not exist
 123     } BaseOfCode_and_BaseOfData;
 124
 125     AddressOffsetT              ImageBase;
 126     boost::dll::detail::DWORD_  SectionAlignment;
 127     boost::dll::detail::DWORD_  FileAlignment;
 128     boost::dll::detail::WORD_   MajorOperatingSystemVersion;
 129     boost::dll::detail::WORD_   MinorOperatingSystemVersion;
 130     boost::dll::detail::WORD_   MajorImageVersion;
 131     boost::dll::detail::WORD_   MinorImageVersion;
 132     boost::dll::detail::WORD_   MajorSubsystemVersion;
 133     boost::dll::detail::WORD_   MinorSubsystemVersion;
 134     boost::dll::detail::DWORD_  Win32VersionValue;
 135     boost::dll::detail::DWORD_  SizeOfImage;
 136     boost::dll::detail::DWORD_  SizeOfHeaders;
 137     boost::dll::detail::DWORD_  CheckSum;
 138     boost::dll::detail::WORD_   Subsystem;
 139     boost::dll::detail::WORD_   DllCharacteristics;
 140     AddressOffsetT              SizeOfStackReserve;
 141     AddressOffsetT              SizeOfStackCommit;
 142     AddressOffsetT              SizeOfHeapReserve;
 143     AddressOffsetT              SizeOfHeapCommit;
 144     boost::dll::detail::DWORD_  LoaderFlags;
 145     boost::dll::detail::DWORD_  NumberOfRvaAndSizes;
 146     IMAGE_DATA_DIRECTORY_       DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES_];
 147 };
 148
 149 typedef IMAGE_OPTIONAL_HEADER_template<boost::dll::detail::DWORD_>      IMAGE_OPTIONAL_HEADER32_;
 150 typedef IMAGE_OPTIONAL_HEADER_template<boost::dll::detail::ULONGLONG_>  IMAGE_OPTIONAL_HEADER64_;
 151
 152 template <class AddressOffsetT>
 153 struct IMAGE_NT_HEADERS_template {
 154     boost::dll::detail::DWORD_                      Signature;
 155     IMAGE_FILE_HEADER_                              FileHeader;
 156     IMAGE_OPTIONAL_HEADER_template<AddressOffsetT>  OptionalHeader;
 157 };
 158
 159 typedef IMAGE_NT_HEADERS_template<boost::dll::detail::DWORD_>      IMAGE_NT_HEADERS32_;
 160 typedef IMAGE_NT_HEADERS_template<boost::dll::detail::ULONGLONG_>  IMAGE_NT_HEADERS64_;
 161
 162
 163 template <class AddressOffsetT>
 164 class pe_info: public x_info_interface {
 165     boost::filesystem::ifstream&    f_;
 166
 167     typedef IMAGE_NT_HEADERS_template<AddressOffsetT>   header_t;
 168     typedef IMAGE_EXPORT_DIRECTORY_                     exports_t;
 169     typedef IMAGE_SECTION_HEADER_                       section_t;
 170     typedef IMAGE_DOS_HEADER_                           dos_t;
 171
 172     template <class T>
 173     inline void read_raw(T& value, std::size_t size = sizeof(T)) const {
 174         f_.read(reinterpret_cast<char*>(&value), size);
 175     }
 176
 177 public:
 178     static bool parsing_supported(boost::filesystem::ifstream& f) {
 179         dos_t dos;
 180         f.seekg(0);
 181         f.read(reinterpret_cast<char*>(&dos), sizeof(dos));
 182
 183         // 'MZ' and 'ZM' according to Wikipedia
 184         if (dos.e_magic != 0x4D5A && dos.e_magic != 0x5A4D) {
 185             return false;
 186         }
 187
 188         header_t h;
 189         f.seekg(dos.e_lfanew);
 190         f.read(reinterpret_cast<char*>(&h), sizeof(h));
 191
 192         return h.Signature == 0x00004550 // 'PE00'
 193                 && h.OptionalHeader.Magic == (sizeof(boost::uint32_t) == sizeof(AddressOffsetT) ? 0x10B : 0x20B);
 194     }
 195
 196
 197     explicit pe_info(boost::filesystem::ifstream& f) BOOST_NOEXCEPT
 198         : f_(f)
 199     {}
 200
 201 private:
 202     inline header_t header() {
 203         header_t h;
 204
 205         dos_t dos;
 206         f_.seekg(0);
 207         read_raw(dos);
 208
 209         f_.seekg(dos.e_lfanew);
 210         read_raw(h);
 211
 212         return h;
 213     }
 214
 215     inline exports_t exports(const header_t& h) {
 216         exports_t exports;
 217
 218         static const unsigned int IMAGE_DIRECTORY_ENTRY_EXPORT_ = 0;
 219         const std::size_t exp_virtual_address = h.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT_].VirtualAddress;
 220
 221         const std::size_t real_offset = get_file_offset(exp_virtual_address, h);
 222         BOOST_ASSERT(real_offset);
 223
 224         f_.seekg(real_offset);
 225         read_raw(exports);
 226
 227         return exports;
 228     }
 229
 230     std::size_t get_file_offset(std::size_t virtual_address, const header_t& h) {
 231         section_t image_section_header;
 232
 233         {   // f_.seekg to the beginning on section headers
 234             dos_t dos;
 235             f_.seekg(0);
 236             read_raw(dos);
 237             f_.seekg(dos.e_lfanew + sizeof(header_t));
 238         }
 239
 240         for (std::size_t i = 0;i < h.FileHeader.NumberOfSections;++i) {
 241             read_raw(image_section_header);
 242             if (virtual_address >= image_section_header.VirtualAddress
 243                 && virtual_address < image_section_header.VirtualAddress + image_section_header.SizeOfRawData)
 244             {
 245                 return image_section_header.PointerToRawData + virtual_address - image_section_header.VirtualAddress;
 246             }
 247         }
 248
 249         return 0;
 250     }
 251
 252 public:
 253     std::vector<std::string> sections() {
 254         std::vector<std::string> ret;
 255
 256         const header_t h = header();
 257         ret.reserve(h.FileHeader.NumberOfSections);
 258
 259         // get names, e.g: .text .rdata .data .rsrc .reloc
 260         section_t image_section_header;
 261         char name_helper[section_t::IMAGE_SIZEOF_SHORT_NAME_ + 1];
 262         std::memset(name_helper, 0, sizeof(name_helper));
 263         for (std::size_t i = 0;i < h.FileHeader.NumberOfSections;++i) {
 264             // There is no terminating null character if the string is exactly eight characters long
 265             read_raw(image_section_header);
 266             std::memcpy(name_helper, image_section_header.Name, section_t::IMAGE_SIZEOF_SHORT_NAME_);
 267
 268             if (name_helper[0] != '/') {
 269                 ret.push_back(name_helper);
 270             } else {
 271                 // For longer names, image_section_header.Name contains a slash (/) followed by ASCII representation of a decimal number.
 272                 // this number is an offset into the string table.
 273                 // TODO: fixme
 274                 ret.push_back(name_helper);
 275             }
 276         }
 277
 278         return ret;
 279     }
 280
 281     std::vector<std::string> symbols() {
 282         std::vector<std::string> ret;
 283
 284         const header_t h = header();
 285         const exports_t exprt = exports(h);
 286         const std::size_t exported_symbols = exprt.NumberOfNames;
 287         const std::size_t fixed_names_addr = get_file_offset(exprt.AddressOfNames, h);
 288
 289         ret.reserve(exported_symbols);
 290         boost::dll::detail::DWORD_ name_offset;
 291         std::string symbol_name;
 292         for (std::size_t i = 0;i < exported_symbols;++i) {
 293             f_.seekg(fixed_names_addr + i * sizeof(name_offset));
 294             read_raw(name_offset);
 295             f_.seekg(get_file_offset(name_offset, h));
 296             getline(f_, symbol_name, '\0');
 297             ret.push_back(symbol_name);
 298         }
 299
 300         return ret;
 301     }
 302
 303     std::vector<std::string> symbols(const char* section_name) {
 304         std::vector<std::string> ret;
 305
 306         const header_t h = header();
 307
 308         std::size_t section_begin_addr = 0;
 309         std::size_t section_end_addr = 0;
 310
 311         {   // getting address range for the section
 312             section_t image_section_header;
 313             char name_helper[section_t::IMAGE_SIZEOF_SHORT_NAME_ + 1];
 314             std::memset(name_helper, 0, sizeof(name_helper));
 315             for (std::size_t i = 0;i < h.FileHeader.NumberOfSections;++i) {
 316                 // There is no terminating null character if the string is exactly eight characters long
 317                 read_raw(image_section_header);
 318                 std::memcpy(name_helper, image_section_header.Name, section_t::IMAGE_SIZEOF_SHORT_NAME_);
 319                 if (!std::strcmp(section_name, name_helper)) {
 320                     section_begin_addr = image_section_header.PointerToRawData;
 321                     section_end_addr = section_begin_addr + image_section_header.SizeOfRawData;
 322                 }
 323             }
 324
 325             // returning empty result if section was not found
 326             if(section_begin_addr == 0 || section_end_addr == 0)
 327                 return ret;
 328         }
 329
 330         const exports_t exprt = exports(h);
 331         const std::size_t exported_symbols = exprt.NumberOfFunctions;
 332         const std::size_t fixed_names_addr = get_file_offset(exprt.AddressOfNames, h);
 333         const std::size_t fixed_ordinals_addr = get_file_offset(exprt.AddressOfNameOrdinals, h);
 334         const std::size_t fixed_functions_addr = get_file_offset(exprt.AddressOfFunctions, h);
 335
 336         ret.reserve(exported_symbols);
 337         boost::dll::detail::DWORD_ ptr;
 338         boost::dll::detail::WORD_ ordinal;
 339         std::string symbol_name;
 340         for (std::size_t i = 0;i < exported_symbols;++i) {
 341             // getting ordinal
 342             f_.seekg(fixed_ordinals_addr + i * sizeof(ordinal));
 343             read_raw(ordinal);
 344
 345             // getting function addr
 346             f_.seekg(fixed_functions_addr + ordinal * sizeof(ptr));
 347             read_raw(ptr);
 348             ptr = static_cast<boost::dll::detail::DWORD_>( get_file_offset(ptr, h) );
 349
 350             if (ptr >= section_end_addr || ptr < section_begin_addr) {
 351                 continue;
 352             }
 353
 354             f_.seekg(fixed_names_addr + i * sizeof(ptr));
 355             read_raw(ptr);
 356             f_.seekg(get_file_offset(ptr, h));
 357             getline(f_, symbol_name, '\0');
 358             ret.push_back(symbol_name);
 359         }
 360
 361         return ret;
 362     }
 363
 364     // a test method to get dependents modules,
 365     // who my plugin imports (1st level only)
 366     /*
 367     e.g. for myself I get:
 368       KERNEL32.dll
 369       MSVCP110D.dll
 370       boost_system-vc-mt-gd-1_56.dll
 371       MSVCR110D.dll
 372     */
 373     /*
 374     std::vector<std::string> depend_of(boost::system::error_code &ec) BOOST_NOEXCEPT {
 375         std::vector<std::string> ret;
 376
 377         IMAGE_DOS_HEADER* image_dos_header = (IMAGE_DOS_HEADER*)native();
 378         if(!image_dos_header) {
 379             // ERROR_BAD_EXE_FORMAT
 380             ec = boost::system::error_code(
 381                  boost::system::errc::executable_format_error,
 382                  boost::system::generic_category()
 383                  );
 384
 385             return ret;
 386         }
 387
 388         IMAGE_OPTIONAL_HEADER* image_optional_header = (IMAGE_OPTIONAL_HEADER*)((boost::dll::detail::BYTE_*)native() + image_dos_header->e_lfanew + 24);
 389         if(!image_optional_header) {
 390             // ERROR_BAD_EXE_FORMAT
 391             ec = boost::system::error_code(
 392                  boost::system::errc::executable_format_error,
 393                  boost::system::generic_category()
 394                  );
 395
 396             return ret;
 397         }
 398
 399         IMAGE_IMPORT_DESCRIPTOR* image_import_descriptor =  (IMAGE_IMPORT_DESCRIPTOR*)((boost::dll::detail::BYTE_*)native() + image_optional_header->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
 400         if(!image_import_descriptor) {
 401             // ERROR_BAD_EXE_FORMAT
 402             ec = boost::system::error_code(
 403                  boost::system::errc::executable_format_error,
 404                  boost::system::generic_category()
 405                  );
 406
 407             return ret;
 408         }
 409
 410         while(image_import_descriptor->FirstThunk) {
 411            std::string module_name = reinterpret_cast<char*>((boost::dll::detail::BYTE_*)native() + image_import_descriptor->Name);
 412
 413            if(module_name.size()) {
 414               ret.push_back(module_name);
 415            }
 416
 417            image_import_descriptor++;
 418         }
 419
 420         return ret;
 421     }
 422 */
 423 };
 424
 425 typedef pe_info<boost::dll::detail::DWORD_>      pe_info32;
 426 typedef pe_info<boost::dll::detail::ULONGLONG_>  pe_info64;
 427
 428 }}} // namespace boost::dll::detail
 429
 430 #endif // BOOST_DLL_DETAIL_WINDOWS_PE_INFO_HPP