From a7bcede17b4c10e172c7877fc2ce89862dc454af Mon Sep 17 00:00:00 2001 From: Dennis Brentjes Date: Thu, 23 Jun 2016 18:07:42 +0200 Subject: adds alot more binary parsing. --- le/CMakeLists.txt | 6 ++++ le/le_entry_table.cpp | 27 ++++++++++++++++++ le/le_entry_table.hpp | 19 +++++++++++++ le/le_entry_table_entry.cpp | 55 +++++++++++++++++++++++++++++++++++++ le/le_entry_table_entry.hpp | 33 ++++++++++++++++++++++ le/le_file.cpp | 12 ++++++++ le/le_file.hpp | 6 ++++ le/le_object_page_table.cpp | 27 ++++++++++++++++++ le/le_object_page_table.hpp | 23 ++++++++++++++++ le/le_object_page_table_entry.cpp | 27 ++++++++++++++++++ le/le_object_page_table_entry.hpp | 28 +++++++++++++++++++ le/le_object_table_entry.cpp | 2 +- le/le_object_table_entry.hpp | 2 +- le/le_resident_name_table.cpp | 26 ++++++++++++++++++ le/le_resident_name_table.hpp | 19 +++++++++++++ le/le_resident_name_table_entry.cpp | 26 ++++++++++++++++++ le/le_resident_name_table_entry.hpp | 21 ++++++++++++++ 17 files changed, 357 insertions(+), 2 deletions(-) create mode 100644 le/le_entry_table.cpp create mode 100644 le/le_entry_table.hpp create mode 100644 le/le_entry_table_entry.cpp create mode 100644 le/le_entry_table_entry.hpp create mode 100644 le/le_object_page_table.cpp create mode 100644 le/le_object_page_table.hpp create mode 100644 le/le_object_page_table_entry.cpp create mode 100644 le/le_object_page_table_entry.hpp create mode 100644 le/le_resident_name_table.cpp create mode 100644 le/le_resident_name_table.hpp create mode 100644 le/le_resident_name_table_entry.cpp create mode 100644 le/le_resident_name_table_entry.hpp (limited to 'le') diff --git a/le/CMakeLists.txt b/le/CMakeLists.txt index c41d730..a135f8b 100644 --- a/le/CMakeLists.txt +++ b/le/CMakeLists.txt @@ -4,6 +4,12 @@ add_library(le STATIC le_file.hpp le_file.cpp le_object_table.hpp le_object_table.cpp le_object_table_entry.hpp le_object_table_entry.cpp + le_object_page_table.hpp le_object_page_table.cpp + le_object_page_table_entry.hpp le_object_page_table_entry.cpp + le_resident_name_table.hpp le_resident_name_table.cpp + le_resident_name_table_entry.hpp le_resident_name_table_entry.cpp + le_entry_table.hpp le_entry_table.cpp + le_entry_table_entry.hpp le_entry_table_entry.cpp ) target_include_directories(le diff --git a/le/le_entry_table.cpp b/le/le_entry_table.cpp new file mode 100644 index 0000000..28f901d --- /dev/null +++ b/le/le_entry_table.cpp @@ -0,0 +1,27 @@ +#include "le_entry_table.hpp" + +#include "output.hpp" + +namespace le { + +EntryTable parse_entry_table(std::istream& is, binparse::Offset32 offset) +{ + is.seekg(0, std::ios::beg); + is.ignore(offset); + + EntryTable table; + + uint32_t i = 1; + while(is.peek()) { + table.entries.emplace(i++, parse_entry_table_entry(is)); + } + + return table; +} + +std::ostream&operator<<(std::ostream& os, const EntryTable& table) +{ + return binparse::operator<<(os, table.entries); +} + +} \ No newline at end of file diff --git a/le/le_entry_table.hpp b/le/le_entry_table.hpp new file mode 100644 index 0000000..f31f542 --- /dev/null +++ b/le/le_entry_table.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include "le_entry_table_entry.hpp" + +#include +#include + +namespace le { + +struct EntryTable +{ + std::map entries; +}; + +EntryTable parse_entry_table(std::istream& is, binparse::Offset32 offset); + +std::ostream& operator<<(std::ostream& os, EntryTable const& table); + +} \ No newline at end of file diff --git a/le/le_entry_table_entry.cpp b/le/le_entry_table_entry.cpp new file mode 100644 index 0000000..4894ec0 --- /dev/null +++ b/le/le_entry_table_entry.cpp @@ -0,0 +1,55 @@ +#include "le_entry_table_entry.hpp" + +#include "parse.hpp" +#include "output.hpp" + +#include + +typedef boost::variant EntryT; + +BOOST_FUSION_ADAPT_STRUCT( + le::EntryPoint, + (binparse::Value8, flags) + (EntryT, entry) +) + +BOOST_FUSION_ADAPT_STRUCT( + le::EntryTableEntry, + (binparse::Value8, nr_entries) + (binparse::Value8, flags) + (binparse::Value16, object_index) + (std::vector, entries) +) + +namespace le { + +EntryTableEntry parse_entry_table_entry(std::istream& is) { + EntryTableEntry entry; + + entry.nr_entries = binparse::parse(is, "nr_entries"); + entry.flags = binparse::parse(is, "flags"); + entry.object_index = binparse::parse(is, "object_index"); + + for(Value8 i = Value8(0); i < entry.nr_entries; i++) { + if(entry.flags & 2) { + entry.entries.push_back({ + binparse::parse(is, "flags"), + binparse::parse(is, "entry") + }); + } else { + entry.entries.push_back({ + binparse::parse(is, "flags"), + binparse::parse(is, "entry") + }); + } + } + + return entry; +} + +std::ostream&operator<<(std::ostream& os, const EntryTableEntry& entry) +{ + return binparse::operator<<(os, entry); +} + +} \ No newline at end of file diff --git a/le/le_entry_table_entry.hpp b/le/le_entry_table_entry.hpp new file mode 100644 index 0000000..209c1bb --- /dev/null +++ b/le/le_entry_table_entry.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include "types.hpp" + +#include + +#include + +namespace le { + +using binparse::Value8; +using binparse::Value16; +using binparse::Offset16; +using binparse::Offset32; + +struct EntryPoint { + binparse::Value8 flags; + boost::variant entry; +}; + +struct EntryTableEntry { + + Value8 nr_entries; + Value8 flags; + Value16 object_index; + std::vector entries; +}; + +EntryTableEntry parse_entry_table_entry(std::istream& is); + +std::ostream& operator<<(std::ostream& os, EntryTableEntry const& entry); + +} diff --git a/le/le_file.cpp b/le/le_file.cpp index 4a9f57e..b6aa54f 100644 --- a/le/le_file.cpp +++ b/le/le_file.cpp @@ -18,6 +18,9 @@ BOOST_FUSION_ADAPT_STRUCT( (std::vector, dos_exe) (le::Header, le_header) (le::ObjectTable, object_table) + (le::ObjectPageTable, object_page_table) + (le::ResidentNameTable, resident_name_table) + (le::EntryTable, entry_table) ) namespace le { @@ -39,6 +42,12 @@ File parse_file(std::istream& is) { auto object_table = parse_object_table(is, le_offset + le_h.object_table_offset, le_h.nr_objects_in_module); + auto object_page_table = parse_object_page_table(is, le_offset + le_h.object_page_table_offset, le_h.module_nr_of_pages); + + auto resident_name_table = parse_resident_name_table(is, le_offset + le_h.resident_name_table_offset); + + auto entry_table = parse_entry_table(is, le_offset + le_h.entry_table_offset); + return { mz_h, unused, @@ -48,6 +57,9 @@ File parse_file(std::istream& is) { dos_exe, le_h, object_table, + object_page_table, + resident_name_table, + entry_table }; } diff --git a/le/le_file.hpp b/le/le_file.hpp index 56857c5..f66bd36 100644 --- a/le/le_file.hpp +++ b/le/le_file.hpp @@ -5,6 +5,9 @@ #include "mz_header.hpp" #include "le_header.hpp" #include "le_object_table.hpp" +#include "le_object_page_table.hpp" +#include "le_resident_name_table.hpp" +#include "le_entry_table.hpp" #include #include @@ -27,6 +30,9 @@ struct File std::vector dos_exe; Header le_header; ObjectTable object_table; + ObjectPageTable object_page_table; + ResidentNameTable resident_name_table; + EntryTable entry_table; }; File parse_file(std::istream& is); diff --git a/le/le_object_page_table.cpp b/le/le_object_page_table.cpp new file mode 100644 index 0000000..d8fd290 --- /dev/null +++ b/le/le_object_page_table.cpp @@ -0,0 +1,27 @@ +#include "le_object_page_table.hpp" + +#include "parse.hpp" +#include "output.hpp" + +namespace le { + +ObjectPageTable parse_object_page_table(std::istream& is, binparse::Offset32 offset, binparse::Value32 nr_pages) +{ + is.seekg(0, std::ios::beg); + is.ignore(offset); + + ObjectPageTable table; + + for(binparse::Value32 i = binparse::Value32(0); i < nr_pages; i++) { + table.entries.emplace(i+1, parse_object_page_table_entry(is)); + } + + return table; +} + +std::ostream&operator<<(std::ostream& os, const ObjectPageTable& table) +{ + return binparse::operator<<(os, table.entries); +} + +} \ No newline at end of file diff --git a/le/le_object_page_table.hpp b/le/le_object_page_table.hpp new file mode 100644 index 0000000..08a67e6 --- /dev/null +++ b/le/le_object_page_table.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "types.hpp" + +#include "le_object_page_table_entry.hpp" + +#include + +namespace le { + +using binparse::Value32; +using binparse::Offset32; + +struct ObjectPageTable +{ + std::map entries; +}; + +ObjectPageTable parse_object_page_table(std::istream& is, Offset32 offset, Value32 nr_pages); + +std::ostream& operator<<(std::ostream& os, ObjectPageTable const& table); + +} \ No newline at end of file diff --git a/le/le_object_page_table_entry.cpp b/le/le_object_page_table_entry.cpp new file mode 100644 index 0000000..73bdb61 --- /dev/null +++ b/le/le_object_page_table_entry.cpp @@ -0,0 +1,27 @@ +#include "le_object_page_table_entry.hpp" + +#include "parse.hpp" +#include "output.hpp" + +#include + +BOOST_FUSION_ADAPT_STRUCT( + le::ObjectPageTableEntry, + (binparse::Offset16, high_page_number) + (binparse::Value8, low_page_number) + (binparse::Value8, flags) +) + +namespace le { + +ObjectPageTableEntry parse_object_page_table_entry(std::istream& is) +{ + return binparse::parse(is); +} + +std::ostream& operator<<(std::ostream& os, const ObjectPageTableEntry& entry) +{ + return binparse::operator<<(os, entry); +} + +} \ No newline at end of file diff --git a/le/le_object_page_table_entry.hpp b/le/le_object_page_table_entry.hpp new file mode 100644 index 0000000..3254365 --- /dev/null +++ b/le/le_object_page_table_entry.hpp @@ -0,0 +1,28 @@ +#pragma once + +#include "types.hpp" + +namespace le { + +using binparse::Offset16; +using binparse::Value8; + +enum class object_page_flags { + legal_physical = 0, + iteration_data = 1, + invalid = 2, + zero_filled = 3, + range_of = 4 +}; + +struct ObjectPageTableEntry { + Offset16 high_page_number; + Value8 low_page_number; + Value8 flags; +}; + +ObjectPageTableEntry parse_object_page_table_entry(std::istream& is); + +std::ostream& operator<<(std::ostream& os, ObjectPageTableEntry const& entry); + +} diff --git a/le/le_object_table_entry.cpp b/le/le_object_table_entry.cpp index 92810aa..68e77ba 100644 --- a/le/le_object_table_entry.cpp +++ b/le/le_object_table_entry.cpp @@ -9,7 +9,7 @@ BOOST_FUSION_ADAPT_STRUCT( le::ObjectTableEntry, (binparse::Value32, virtual_size) (binparse::Offset32, reloc_base_address) - (binparse::Value32, ojbect_flags) + (binparse::Value32, object_flags) (binparse::Value32, page_table_index) (binparse::Value32, nr_page_table_entries) (binparse::Value32, reserved) diff --git a/le/le_object_table_entry.hpp b/le/le_object_table_entry.hpp index 7b97873..c456a15 100644 --- a/le/le_object_table_entry.hpp +++ b/le/le_object_table_entry.hpp @@ -29,7 +29,7 @@ enum class ObjectFlags { struct ObjectTableEntry { Value32 virtual_size; Offset32 reloc_base_address; - Value32 ojbect_flags; + Value32 object_flags; Value32 page_table_index; Value32 nr_page_table_entries; Value32 reserved; diff --git a/le/le_resident_name_table.cpp b/le/le_resident_name_table.cpp new file mode 100644 index 0000000..bc34999 --- /dev/null +++ b/le/le_resident_name_table.cpp @@ -0,0 +1,26 @@ +#include "le_resident_name_table.hpp" + +#include "output.hpp" + +namespace le { + +ResidentNameTable parse_resident_name_table(std::istream& is, binparse::Offset32 offset) +{ + is.seekg(0, std::ios::beg); + is.ignore(offset); + + ResidentNameTable table; + + while(is.peek()) { + table.entries.push_back(parse_resident_name_table_entry(is)); + } + + return table; +} + +std::ostream&operator<<(std::ostream& os, const ResidentNameTable& table) +{ + return binparse::operator<<(os, table.entries); +} + +} diff --git a/le/le_resident_name_table.hpp b/le/le_resident_name_table.hpp new file mode 100644 index 0000000..aa81577 --- /dev/null +++ b/le/le_resident_name_table.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include "le_resident_name_table_entry.hpp" + +#include +#include + +namespace le { + +struct ResidentNameTable { + std::vector entries; +}; + +ResidentNameTable parse_resident_name_table(std::istream& is, binparse::Offset32 offset); + +std::ostream& operator<<(std::ostream& os, ResidentNameTable const& table); + +} + diff --git a/le/le_resident_name_table_entry.cpp b/le/le_resident_name_table_entry.cpp new file mode 100644 index 0000000..a82cbeb --- /dev/null +++ b/le/le_resident_name_table_entry.cpp @@ -0,0 +1,26 @@ +#include "le_resident_name_table_entry.hpp" + +#include "parse.hpp" +#include "output.hpp" + +#include + +BOOST_FUSION_ADAPT_STRUCT( + le::ResidentNameTableEntry, + (binparse::PString8, string) + (binparse::Value16, index) +) + +namespace le { + +ResidentNameTableEntry parse_resident_name_table_entry(std::istream& is) +{ + return binparse::parse(is); +} + +std::ostream&operator<<(std::ostream& os, ResidentNameTableEntry const& entry) +{ + return binparse::operator<<(os, entry); +} + +} \ No newline at end of file diff --git a/le/le_resident_name_table_entry.hpp b/le/le_resident_name_table_entry.hpp new file mode 100644 index 0000000..95c83bc --- /dev/null +++ b/le/le_resident_name_table_entry.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include "types.hpp" + +#include + +namespace le { + +using binparse::PString8; +using binparse::Value16; + +struct ResidentNameTableEntry { + PString8 string; + Value16 index; +}; + +ResidentNameTableEntry parse_resident_name_table_entry(std::istream& is); + +std::ostream& operator<<(std::ostream& os, ResidentNameTableEntry const& entry); + +} \ No newline at end of file -- cgit v1.2.3-70-g09d2