| #include "binary_annotator.h" |
| |
| #include <limits> |
| #include <string> |
| #include <vector> |
| |
| #include "flatbuffers/reflection.h" |
| #include "flatbuffers/verifier.h" |
| |
| namespace flatbuffers { |
| namespace { |
| |
| static bool BinaryRegionSort(const BinaryRegion &a, const BinaryRegion &b) { |
| return a.offset < b.offset; |
| } |
| |
| static void SetError(BinaryRegionComment &comment, BinaryRegionStatus status, |
| std::string message = "") { |
| comment.status = status; |
| comment.status_message = message; |
| } |
| |
| static BinaryRegion MakeBinaryRegion( |
| const uint64_t offset = 0, const uint64_t length = 0, |
| const BinaryRegionType type = BinaryRegionType::Unknown, |
| const uint64_t array_length = 0, const uint64_t points_to_offset = 0, |
| const BinaryRegionComment comment = {}) { |
| BinaryRegion region; |
| region.offset = offset; |
| region.length = length; |
| region.type = type; |
| region.array_length = array_length; |
| region.points_to_offset = points_to_offset; |
| region.comment = std::move(comment); |
| return region; |
| } |
| |
| static BinarySection MakeBinarySection( |
| const std::string &name, const BinarySectionType type, |
| const std::vector<BinaryRegion> regions) { |
| BinarySection section; |
| section.name = name; |
| section.type = type; |
| section.regions = std::move(regions); |
| return section; |
| } |
| |
| static BinarySection MakeSingleRegionBinarySection(const std::string &name, |
| const BinarySectionType type, |
| const BinaryRegion ®ion) { |
| std::vector<BinaryRegion> regions; |
| regions.push_back(region); |
| return MakeBinarySection(name, type, std::move(regions)); |
| } |
| |
| static bool IsNonZeroRegion(const uint64_t offset, const uint64_t length, |
| const uint8_t *const binary) { |
| for (uint64_t i = offset; i < offset + length; ++i) { |
| if (binary[i] != 0) { return true; } |
| } |
| return false; |
| } |
| |
| static bool IsPrintableRegion(const uint64_t offset, const uint64_t length, |
| const uint8_t *const binary) { |
| for (uint64_t i = offset; i < offset + length; ++i) { |
| if (!isprint(binary[i])) { return false; } |
| } |
| return true; |
| } |
| |
| static BinarySection GenerateMissingSection(const uint64_t offset, |
| const uint64_t length, |
| const uint8_t *const binary) { |
| std::vector<BinaryRegion> regions; |
| |
| // Check if the region is all zeros or not, as that can tell us if it is |
| // padding or not. |
| if (IsNonZeroRegion(offset, length, binary)) { |
| // Some of the padding bytes are non-zero, so this might be an unknown |
| // section of the binary. |
| // TODO(dbaileychess): We could be a bit smarter with different sized |
| // alignments. For now, the 8 byte check encompasses all the smaller |
| // alignments. |
| BinaryRegionComment comment; |
| comment.type = BinaryRegionCommentType::Unknown; |
| if (length >= 8) { |
| SetError(comment, BinaryRegionStatus::WARN_NO_REFERENCES); |
| } else { |
| SetError(comment, BinaryRegionStatus::WARN_CORRUPTED_PADDING); |
| } |
| |
| regions.push_back(MakeBinaryRegion(offset, length * sizeof(uint8_t), |
| BinaryRegionType::Unknown, length, 0, |
| comment)); |
| |
| return MakeBinarySection("no known references", BinarySectionType::Unknown, |
| std::move(regions)); |
| } |
| |
| BinaryRegionComment comment; |
| comment.type = BinaryRegionCommentType::Padding; |
| if (length >= 8) { |
| SetError(comment, BinaryRegionStatus::WARN_PADDING_LENGTH); |
| } |
| |
| // This region is most likely padding. |
| regions.push_back(MakeBinaryRegion(offset, length * sizeof(uint8_t), |
| BinaryRegionType::Uint8, length, 0, |
| comment)); |
| |
| return MakeBinarySection("", BinarySectionType::Padding, std::move(regions)); |
| } |
| |
| } // namespace |
| |
| std::map<uint64_t, BinarySection> BinaryAnnotator::Annotate() { |
| flatbuffers::Verifier verifier(bfbs_, static_cast<size_t>(bfbs_length_)); |
| if (!reflection::VerifySchemaBuffer(verifier)) { return {}; } |
| |
| // The binary is too short to read as a flatbuffers. |
| // TODO(dbaileychess): We could spit out the annotated buffer sections, but |
| // I'm not sure if it is worth it. |
| if (binary_length_ < 4) { return {}; } |
| |
| // Make sure we start with a clean slate. |
| vtables_.clear(); |
| sections_.clear(); |
| |
| // First parse the header region which always start at offset 0. |
| // The returned offset will point to the root_table location. |
| const uint64_t root_table_offset = BuildHeader(0); |
| |
| if (IsValidOffset(root_table_offset)) { |
| // Build the root table, and all else will be referenced from it. |
| BuildTable(root_table_offset, BinarySectionType::RootTable, |
| schema_->root_table()); |
| } |
| |
| // Now that all the sections are built, make sure the binary sections are |
| // contiguous. |
| FixMissingRegions(); |
| |
| // Then scan the area between BinarySections insert padding sections that are |
| // implied. |
| FixMissingSections(); |
| |
| return sections_; |
| } |
| |
| uint64_t BinaryAnnotator::BuildHeader(const uint64_t header_offset) { |
| const auto root_table_offset = ReadScalar<uint32_t>(header_offset); |
| |
| if (!root_table_offset.has_value()) { |
| // This shouldn't occur, since we validate the min size of the buffer |
| // before. But for completion sake, we shouldn't read passed the binary end. |
| return std::numeric_limits<uint64_t>::max(); |
| } |
| |
| std::vector<BinaryRegion> regions; |
| uint64_t offset = header_offset; |
| // TODO(dbaileychess): sized prefixed value |
| |
| BinaryRegionComment root_offset_comment; |
| root_offset_comment.type = BinaryRegionCommentType::RootTableOffset; |
| root_offset_comment.name = schema_->root_table()->name()->str(); |
| |
| if (!IsValidOffset(root_table_offset.value())) { |
| SetError(root_offset_comment, |
| BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| } |
| |
| regions.push_back( |
| MakeBinaryRegion(offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| root_table_offset.value(), root_offset_comment)); |
| offset += sizeof(uint32_t); |
| |
| if (IsValidRead(offset, flatbuffers::kFileIdentifierLength) && |
| IsPrintableRegion(offset, flatbuffers::kFileIdentifierLength, binary_)) { |
| BinaryRegionComment comment; |
| comment.type = BinaryRegionCommentType::FileIdentifier; |
| // Check if the file identifier region has non-zero data, and assume its |
| // the file identifier. Otherwise, it will get filled in with padding |
| // later. |
| regions.push_back(MakeBinaryRegion( |
| offset, flatbuffers::kFileIdentifierLength * sizeof(uint8_t), |
| BinaryRegionType::Char, flatbuffers::kFileIdentifierLength, 0, |
| comment)); |
| } |
| |
| AddSection(header_offset, MakeBinarySection("", BinarySectionType::Header, |
| std::move(regions))); |
| |
| return root_table_offset.value(); |
| } |
| |
| void BinaryAnnotator::BuildVTable(const uint64_t vtable_offset, |
| const reflection::Object *const table, |
| const uint64_t offset_of_referring_table) { |
| // First see if we have used this vtable before, if so skip building it again. |
| auto it = vtables_.find(vtable_offset); |
| if (it != vtables_.end()) { return; } |
| |
| if (ContainsSection(vtable_offset)) { return; } |
| |
| BinaryRegionComment vtable_size_comment; |
| vtable_size_comment.type = BinaryRegionCommentType::VTableSize; |
| |
| const auto vtable_length = ReadScalar<uint16_t>(vtable_offset); |
| if (!vtable_length.has_value()) { |
| const uint64_t remaining = RemainingBytes(vtable_offset); |
| |
| SetError(vtable_size_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| "2"); |
| |
| AddSection(vtable_offset, |
| MakeSingleRegionBinarySection( |
| table->name()->str(), BinarySectionType::VTable, |
| MakeBinaryRegion(vtable_offset, remaining, |
| BinaryRegionType::Unknown, remaining, 0, |
| vtable_size_comment))); |
| return; |
| } |
| |
| // Vtables start with the size of the vtable |
| const uint16_t vtable_size = vtable_length.value(); |
| |
| if (!IsValidOffset(vtable_offset + vtable_size - 1)) { |
| SetError(vtable_size_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_LONG); |
| // The vtable_size points to off the end of the binary. |
| AddSection(vtable_offset, |
| MakeSingleRegionBinarySection( |
| table->name()->str(), BinarySectionType::VTable, |
| MakeBinaryRegion(vtable_offset, sizeof(uint16_t), |
| BinaryRegionType::Uint16, 0, 0, |
| vtable_size_comment))); |
| |
| return; |
| } else if (vtable_size < 2 * sizeof(uint16_t)) { |
| SetError(vtable_size_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_SHORT, |
| "4"); |
| // The size includes itself and the table size which are both uint16_t. |
| AddSection(vtable_offset, |
| MakeSingleRegionBinarySection( |
| table->name()->str(), BinarySectionType::VTable, |
| MakeBinaryRegion(vtable_offset, sizeof(uint16_t), |
| BinaryRegionType::Uint16, 0, 0, |
| vtable_size_comment))); |
| return; |
| } |
| |
| std::vector<BinaryRegion> regions; |
| |
| regions.push_back(MakeBinaryRegion(vtable_offset, sizeof(uint16_t), |
| BinaryRegionType::Uint16, 0, 0, |
| vtable_size_comment)); |
| uint64_t offset = vtable_offset + sizeof(uint16_t); |
| |
| BinaryRegionComment ref_table_len_comment; |
| ref_table_len_comment.type = |
| BinaryRegionCommentType::VTableRefferingTableLength; |
| |
| // Ensure we can read the next uint16_t field, which is the size of the |
| // referring table. |
| const auto table_length = ReadScalar<uint16_t>(offset); |
| |
| if (!table_length.has_value()) { |
| const uint64_t remaining = RemainingBytes(offset); |
| SetError(ref_table_len_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| "2"); |
| |
| AddSection(offset, MakeSingleRegionBinarySection( |
| table->name()->str(), BinarySectionType::VTable, |
| MakeBinaryRegion( |
| offset, remaining, BinaryRegionType::Unknown, |
| remaining, 0, ref_table_len_comment))); |
| return; |
| } |
| |
| // Then they have the size of the table they reference. |
| const uint16_t table_size = table_length.value(); |
| |
| if (!IsValidOffset(offset_of_referring_table + table_size - 1)) { |
| SetError(ref_table_len_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_LONG); |
| } else if (table_size < 4) { |
| SetError(ref_table_len_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_SHORT, |
| "4"); |
| } |
| |
| regions.push_back(MakeBinaryRegion(offset, sizeof(uint16_t), |
| BinaryRegionType::Uint16, 0, 0, |
| ref_table_len_comment)); |
| offset += sizeof(uint16_t); |
| |
| const uint64_t offset_start = offset; |
| |
| // A mapping between field (and its id) to the relative offset (uin16_t) from |
| // the start of the table. |
| std::map<uint16_t, VTable::Entry> fields; |
| |
| // Counter for determining if the binary has more vtable entries than the |
| // schema provided. This can occur if the binary was created at a newer schema |
| // version and is being processed with an older one. |
| uint16_t fields_processed = 0; |
| |
| // Loop over all the fields. |
| ForAllFields(table, /*reverse=*/false, [&](const reflection::Field *field) { |
| const uint64_t field_offset = offset_start + field->id() * sizeof(uint16_t); |
| |
| if (field_offset >= vtable_offset + vtable_size) { |
| // This field_offset is too large for this vtable, so it must come from a |
| // newer schema than the binary was create with or the binary writer did |
| // not write it. For either case, it is safe to ignore. |
| |
| // TODO(dbaileychess): We could show which fields are not set an their |
| // default values if we want. We just need a way to make it obvious that |
| // it isn't part of the buffer. |
| return; |
| } |
| |
| BinaryRegionComment field_comment; |
| field_comment.type = BinaryRegionCommentType::VTableFieldOffset; |
| field_comment.name = std::string(field->name()->c_str()) + |
| "` (id: " + std::to_string(field->id()) + ")"; |
| |
| const auto offset_from_table = ReadScalar<uint16_t>(field_offset); |
| |
| if (!offset_from_table.has_value()) { |
| const uint64_t remaining = RemainingBytes(field_offset); |
| |
| SetError(field_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2"); |
| regions.push_back(MakeBinaryRegion(field_offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, field_comment)); |
| |
| return; |
| } |
| |
| if (!IsValidOffset(offset_of_referring_table + offset_from_table.value() - |
| 1)) { |
| SetError(field_comment, BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t), |
| BinaryRegionType::VOffset, 0, 0, |
| field_comment)); |
| return; |
| } |
| |
| VTable::Entry entry; |
| entry.field = field; |
| entry.offset_from_table = offset_from_table.value(); |
| fields.insert(std::make_pair(field->id(), entry)); |
| |
| std::string default_label; |
| if (offset_from_table.value() == 0) { |
| // Not present, so could be default or be optional. |
| if (field->required()) { |
| SetError(field_comment, |
| BinaryRegionStatus::ERROR_REQUIRED_FIELD_NOT_PRESENT); |
| // If this is a required field, make it known this is an error. |
| regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t), |
| BinaryRegionType::VOffset, 0, 0, |
| field_comment)); |
| return; |
| } else { |
| // Its an optional field, so get the default value and interpret and |
| // provided an annotation for it. |
| if (IsScalar(field->type()->base_type())) { |
| default_label += "<defaults to "; |
| default_label += IsFloat(field->type()->base_type()) |
| ? std::to_string(field->default_real()) |
| : std::to_string(field->default_integer()); |
| default_label += "> ("; |
| } else { |
| default_label += "<null> ("; |
| } |
| default_label += |
| reflection::EnumNameBaseType(field->type()->base_type()); |
| default_label += ")"; |
| } |
| } |
| field_comment.default_value = default_label; |
| |
| regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t), |
| BinaryRegionType::VOffset, 0, 0, |
| field_comment)); |
| |
| fields_processed++; |
| }); |
| |
| // Check if we covered all the expectant fields. If not, we need to add them |
| // as unknown fields. |
| uint16_t expectant_vtable_fields = |
| (vtable_size - sizeof(uint16_t) - sizeof(uint16_t)) / sizeof(uint16_t); |
| |
| // Prevent a bad binary from declaring a really large vtable_size, that we can |
| // not indpendently verify. |
| expectant_vtable_fields = std::min( |
| static_cast<uint16_t>(fields_processed * 3), expectant_vtable_fields); |
| |
| for (uint16_t id = fields_processed; id < expectant_vtable_fields; ++id) { |
| const uint64_t field_offset = offset_start + id * sizeof(uint16_t); |
| |
| const auto offset_from_table = ReadScalar<uint16_t>(field_offset); |
| |
| BinaryRegionComment field_comment; |
| field_comment.type = BinaryRegionCommentType::VTableUnknownFieldOffset; |
| field_comment.index = id; |
| |
| if (!offset_from_table.has_value()) { |
| const uint64_t remaining = RemainingBytes(field_offset); |
| SetError(field_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2"); |
| regions.push_back(MakeBinaryRegion(field_offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, field_comment)); |
| continue; |
| } |
| |
| VTable::Entry entry; |
| entry.field = nullptr; // No field to reference. |
| entry.offset_from_table = offset_from_table.value(); |
| fields.insert(std::make_pair(id, entry)); |
| |
| regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint16_t), |
| BinaryRegionType::VOffset, 0, 0, |
| field_comment)); |
| } |
| |
| sections_[vtable_offset] = MakeBinarySection( |
| table->name()->str(), BinarySectionType::VTable, std::move(regions)); |
| |
| VTable vtable; |
| vtable.fields = std::move(fields); |
| vtable.table_size = table_size; |
| vtable.vtable_size = vtable_size; |
| |
| vtables_[vtable_offset] = vtable; |
| } |
| |
| void BinaryAnnotator::BuildTable(const uint64_t table_offset, |
| const BinarySectionType type, |
| const reflection::Object *const table) { |
| if (ContainsSection(table_offset)) { return; } |
| |
| BinaryRegionComment vtable_offset_comment; |
| vtable_offset_comment.type = BinaryRegionCommentType::TableVTableOffset; |
| |
| const auto vtable_soffset = ReadScalar<int32_t>(table_offset); |
| |
| if (!vtable_soffset.has_value()) { |
| const uint64_t remaining = RemainingBytes(table_offset); |
| SetError(vtable_offset_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| "4"); |
| |
| AddSection( |
| table_offset, |
| MakeSingleRegionBinarySection( |
| table->name()->str(), type, |
| MakeBinaryRegion(table_offset, remaining, BinaryRegionType::Unknown, |
| remaining, 0, vtable_offset_comment))); |
| |
| // If there aren't enough bytes left to read the vtable offset, there is |
| // nothing we can do. |
| return; |
| } |
| |
| // Tables start with the vtable |
| const uint64_t vtable_offset = table_offset - vtable_soffset.value(); |
| |
| if (!IsValidOffset(vtable_offset)) { |
| SetError(vtable_offset_comment, |
| BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| |
| AddSection(table_offset, |
| MakeSingleRegionBinarySection( |
| table->name()->str(), type, |
| MakeBinaryRegion(table_offset, sizeof(int32_t), |
| BinaryRegionType::SOffset, 0, vtable_offset, |
| vtable_offset_comment))); |
| |
| // There isn't much to do with an invalid vtable offset, as we won't be able |
| // to intepret the rest of the table fields. |
| return; |
| } |
| |
| std::vector<BinaryRegion> regions; |
| regions.push_back(MakeBinaryRegion(table_offset, sizeof(int32_t), |
| BinaryRegionType::SOffset, 0, |
| vtable_offset, vtable_offset_comment)); |
| |
| // Parse the vtable first so we know what the rest of the fields in the table |
| // are. |
| BuildVTable(vtable_offset, table, table_offset); |
| |
| auto vtable_entry = vtables_.find(vtable_offset); |
| if (vtable_entry == vtables_.end()) { |
| // There is no valid vtable for this table, so we cannot process the rest of |
| // the table entries. |
| return; |
| } |
| |
| const VTable &vtable = vtable_entry->second; |
| |
| // This is the size and length of this table. |
| const uint16_t table_size = vtable.table_size; |
| uint64_t table_end_offset = table_offset + table_size; |
| |
| if (!IsValidOffset(table_end_offset - 1)) { |
| // We already validated the table size in BuildVTable, but we have to make |
| // sure we don't use a bad value here. |
| table_end_offset = binary_length_; |
| } |
| |
| // We need to iterate over the vtable fields by their offset in the binary, |
| // not by their IDs. So copy them over to another vector that we can sort on |
| // the offset_from_table property. |
| std::vector<VTable::Entry> fields; |
| for (const auto &vtable_field : vtable.fields) { |
| fields.push_back(vtable_field.second); |
| } |
| |
| std::stable_sort(fields.begin(), fields.end(), |
| [](const VTable::Entry &a, const VTable::Entry &b) { |
| return a.offset_from_table < b.offset_from_table; |
| }); |
| |
| // Iterate over all the fields by order of their offset. |
| for (size_t i = 0; i < fields.size(); ++i) { |
| const reflection::Field *field = fields[i].field; |
| const uint16_t offset_from_table = fields[i].offset_from_table; |
| |
| if (offset_from_table == 0) { |
| // Skip non-present fields. |
| continue; |
| } |
| |
| // The field offsets are relative to the start of the table. |
| const uint64_t field_offset = table_offset + offset_from_table; |
| |
| if (!IsValidOffset(field_offset)) { |
| // The field offset is larger than the binary, nothing we can do. |
| continue; |
| } |
| |
| // We have a vtable entry for a non-existant field, that means its a binary |
| // generated by a newer schema than we are currently processing. |
| if (field == nullptr) { |
| // Calculate the length of this unknown field. |
| const uint64_t unknown_field_length = |
| // Check if there is another unknown field after this one. |
| ((i + 1 < fields.size()) |
| ? table_offset + fields[i + 1].offset_from_table |
| // Otherwise use the known end of the table. |
| : table_end_offset) - |
| field_offset; |
| |
| if (unknown_field_length == 0) { continue; } |
| |
| std::string hint; |
| |
| if (unknown_field_length == 4) { |
| const auto relative_offset = ReadScalar<uint32_t>(field_offset); |
| if (relative_offset.has_value()) { |
| // The field is 4 in length, so it could be an offset? Provide a hint. |
| hint += "<possibly an offset? Check Loc: +0x"; |
| hint += ToHex(field_offset + relative_offset.value()); |
| hint += ">"; |
| } |
| } |
| |
| BinaryRegionComment unknown_field_comment; |
| unknown_field_comment.type = BinaryRegionCommentType::TableUnknownField; |
| |
| if (!IsValidRead(field_offset, unknown_field_length)) { |
| const uint64_t remaining = RemainingBytes(field_offset); |
| |
| SetError(unknown_field_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| std::to_string(unknown_field_length)); |
| |
| regions.push_back(MakeBinaryRegion(field_offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, unknown_field_comment)); |
| continue; |
| } |
| |
| unknown_field_comment.default_value = hint; |
| |
| regions.push_back(MakeBinaryRegion( |
| field_offset, unknown_field_length, BinaryRegionType::Unknown, |
| unknown_field_length, 0, unknown_field_comment)); |
| continue; |
| } |
| |
| if (IsScalar(field->type()->base_type())) { |
| // These are the raw values store in the table. |
| const uint64_t type_size = GetTypeSize(field->type()->base_type()); |
| const BinaryRegionType region_type = |
| GetRegionType(field->type()->base_type()); |
| |
| BinaryRegionComment scalar_field_comment; |
| scalar_field_comment.type = BinaryRegionCommentType::TableField; |
| scalar_field_comment.name = |
| std::string(field->name()->c_str()) + "` (" + |
| reflection::EnumNameBaseType(field->type()->base_type()) + ")"; |
| |
| if (!IsValidRead(field_offset, type_size)) { |
| const uint64_t remaining = RemainingBytes(field_offset); |
| SetError(scalar_field_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| std::to_string(type_size)); |
| |
| regions.push_back(MakeBinaryRegion(field_offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, scalar_field_comment)); |
| continue; |
| } |
| |
| if (IsUnionType(field)) { |
| // This is a type for a union. Validate the value |
| const auto enum_value = ReadScalar<uint8_t>(field_offset); |
| |
| // This should always have a value, due to the IsValidRead check above. |
| if (!IsValidUnionValue(field, enum_value.value())) { |
| SetError(scalar_field_comment, |
| BinaryRegionStatus::ERROR_INVALID_UNION_TYPE); |
| |
| regions.push_back(MakeBinaryRegion(field_offset, type_size, |
| region_type, 0, 0, |
| scalar_field_comment)); |
| continue; |
| } |
| } |
| |
| regions.push_back(MakeBinaryRegion(field_offset, type_size, region_type, |
| 0, 0, scalar_field_comment)); |
| continue; |
| } |
| |
| // Read the offset |
| const auto offset_from_field = ReadScalar<uint32_t>(field_offset); |
| uint64_t offset_of_next_item = 0; |
| BinaryRegionComment offset_field_comment; |
| offset_field_comment.type = BinaryRegionCommentType::TableOffsetField; |
| offset_field_comment.name = field->name()->c_str(); |
| const std::string offset_prefix = |
| "offset to field `" + std::string(field->name()->c_str()) + "`"; |
| |
| // Validate any field that isn't inline (i.e., non-structs). |
| if (!IsInlineField(field)) { |
| if (!offset_from_field.has_value()) { |
| const uint64_t remaining = RemainingBytes(field_offset); |
| |
| SetError(offset_field_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4"); |
| |
| regions.push_back(MakeBinaryRegion(field_offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, offset_field_comment)); |
| continue; |
| } |
| |
| offset_of_next_item = field_offset + offset_from_field.value(); |
| |
| if (!IsValidOffset(offset_of_next_item)) { |
| SetError(offset_field_comment, |
| BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| regions.push_back(MakeBinaryRegion( |
| field_offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| offset_of_next_item, offset_field_comment)); |
| continue; |
| } |
| } |
| |
| switch (field->type()->base_type()) { |
| case reflection::BaseType::Obj: { |
| const reflection::Object *next_object = |
| schema_->objects()->Get(field->type()->index()); |
| |
| if (next_object->is_struct()) { |
| // Structs are stored inline. |
| BuildStruct(field_offset, regions, next_object); |
| } else { |
| offset_field_comment.default_value = "(table)"; |
| |
| regions.push_back(MakeBinaryRegion( |
| field_offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| offset_of_next_item, offset_field_comment)); |
| |
| BuildTable(offset_of_next_item, BinarySectionType::Table, |
| next_object); |
| } |
| } break; |
| |
| case reflection::BaseType::String: { |
| offset_field_comment.default_value = "(string)"; |
| regions.push_back(MakeBinaryRegion( |
| field_offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| offset_of_next_item, offset_field_comment)); |
| BuildString(offset_of_next_item, table, field); |
| } break; |
| |
| case reflection::BaseType::Vector: { |
| offset_field_comment.default_value = "(vector)"; |
| regions.push_back(MakeBinaryRegion( |
| field_offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| offset_of_next_item, offset_field_comment)); |
| BuildVector(offset_of_next_item, table, field, table_offset, vtable); |
| } break; |
| |
| case reflection::BaseType::Union: { |
| const uint64_t union_offset = offset_of_next_item; |
| |
| // The union type field is always one less than the union itself. |
| const uint16_t union_type_id = field->id() - 1; |
| |
| auto vtable_field = vtable.fields.find(union_type_id); |
| if (vtable_field == vtable.fields.end()) { |
| // TODO(dbaileychess): need to capture this error condition. |
| break; |
| } |
| offset_field_comment.default_value = "(union)"; |
| |
| const uint64_t type_offset = |
| table_offset + vtable_field->second.offset_from_table; |
| |
| const auto realized_type = ReadScalar<uint8_t>(type_offset); |
| if (!realized_type.has_value()) { |
| const uint64_t remaining = RemainingBytes(type_offset); |
| SetError(offset_field_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "1"); |
| regions.push_back(MakeBinaryRegion( |
| type_offset, remaining, BinaryRegionType::Unknown, remaining, 0, |
| offset_field_comment)); |
| continue; |
| } |
| |
| if (!IsValidUnionValue(field, realized_type.value())) { |
| // We already export an error in the union type field, so just skip |
| // building the union itself and it will default to an unreference |
| // Binary section. |
| continue; |
| } |
| |
| const std::string enum_type = |
| BuildUnion(union_offset, realized_type.value(), field); |
| |
| offset_field_comment.default_value = |
| "(union of type `" + enum_type + "`)"; |
| |
| regions.push_back(MakeBinaryRegion(field_offset, sizeof(uint32_t), |
| BinaryRegionType::UOffset, 0, |
| union_offset, offset_field_comment)); |
| |
| } break; |
| |
| default: break; |
| } |
| } |
| |
| // Handle the case where there is padding after the last known binary |
| // region. Calculate where we left off towards the expected end of the |
| // table. |
| const uint64_t i = regions.back().offset + regions.back().length + 1; |
| |
| if (i < table_end_offset) { |
| const uint64_t pad_bytes = table_end_offset - i + 1; |
| |
| BinaryRegionComment padding_comment; |
| padding_comment.type = BinaryRegionCommentType::Padding; |
| |
| regions.push_back(MakeBinaryRegion(i - 1, pad_bytes * sizeof(uint8_t), |
| BinaryRegionType::Uint8, pad_bytes, 0, |
| padding_comment)); |
| } |
| |
| AddSection(table_offset, |
| MakeBinarySection(table->name()->str(), type, std::move(regions))); |
| } |
| |
| uint64_t BinaryAnnotator::BuildStruct(const uint64_t struct_offset, |
| std::vector<BinaryRegion> ®ions, |
| const reflection::Object *const object) { |
| if (!object->is_struct()) { return struct_offset; } |
| uint64_t offset = struct_offset; |
| |
| // Loop over all the fields in increasing order |
| ForAllFields(object, /*reverse=*/false, [&](const reflection::Field *field) { |
| if (IsScalar(field->type()->base_type())) { |
| // Structure Field value |
| const uint64_t type_size = GetTypeSize(field->type()->base_type()); |
| const BinaryRegionType region_type = |
| GetRegionType(field->type()->base_type()); |
| |
| BinaryRegionComment comment; |
| comment.type = BinaryRegionCommentType::StructField; |
| comment.name = |
| std::string(object->name()->c_str()) + "." + field->name()->c_str(); |
| comment.default_value = "(" + |
| std::string(reflection::EnumNameBaseType( |
| field->type()->base_type())) + |
| ")"; |
| |
| if (!IsValidRead(offset, type_size)) { |
| const uint64_t remaining = RemainingBytes(offset); |
| SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| std::to_string(type_size)); |
| regions.push_back(MakeBinaryRegion(offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, comment)); |
| |
| // TODO(dbaileychess): Should I bail out here? This sets offset to the |
| // end of the binary. So all other reads in the loop should fail. |
| offset += remaining; |
| return; |
| } |
| |
| regions.push_back( |
| MakeBinaryRegion(offset, type_size, region_type, 0, 0, comment)); |
| offset += type_size; |
| } else if (field->type()->base_type() == reflection::BaseType::Obj) { |
| // Structs are stored inline, even when nested. |
| offset = BuildStruct(offset, regions, |
| schema_->objects()->Get(field->type()->index())); |
| } else if (field->type()->base_type() == reflection::BaseType::Array) { |
| const bool is_scalar = IsScalar(field->type()->element()); |
| const uint64_t type_size = GetTypeSize(field->type()->element()); |
| const BinaryRegionType region_type = |
| GetRegionType(field->type()->element()); |
| |
| // Arrays are just repeated structures. |
| for (uint16_t i = 0; i < field->type()->fixed_length(); ++i) { |
| if (is_scalar) { |
| BinaryRegionComment array_comment; |
| array_comment.type = BinaryRegionCommentType::ArrayField; |
| array_comment.name = std::string(object->name()->c_str()) + "." + |
| field->name()->c_str(); |
| array_comment.index = i; |
| array_comment.default_value = |
| "(" + |
| std::string( |
| reflection::EnumNameBaseType(field->type()->element())) + |
| ")"; |
| |
| if (!IsValidRead(offset, type_size)) { |
| const uint64_t remaining = RemainingBytes(offset); |
| |
| SetError(array_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| std::to_string(type_size)); |
| |
| regions.push_back(MakeBinaryRegion(offset, remaining, |
| BinaryRegionType::Unknown, |
| remaining, 0, array_comment)); |
| |
| // TODO(dbaileychess): Should I bail out here? This sets offset to |
| // the end of the binary. So all other reads in the loop should |
| // fail. |
| offset += remaining; |
| break; |
| } |
| |
| regions.push_back(MakeBinaryRegion(offset, type_size, region_type, 0, |
| 0, array_comment)); |
| |
| offset += type_size; |
| } else { |
| // Array of Structs. |
| // |
| // TODO(dbaileychess): This works, but the comments on the fields lose |
| // some context. Need to figure a way how to plumb the nested arrays |
| // comments together that isn't too confusing. |
| offset = BuildStruct(offset, regions, |
| schema_->objects()->Get(field->type()->index())); |
| } |
| } |
| } |
| |
| // Insert any padding after this field. |
| const uint16_t padding = field->padding(); |
| if (padding > 0 && IsValidOffset(offset + padding)) { |
| BinaryRegionComment padding_comment; |
| padding_comment.type = BinaryRegionCommentType::Padding; |
| |
| regions.push_back(MakeBinaryRegion(offset, padding, |
| BinaryRegionType::Uint8, padding, 0, |
| padding_comment)); |
| offset += padding; |
| } |
| }); |
| |
| return offset; |
| } |
| |
| void BinaryAnnotator::BuildString(const uint64_t string_offset, |
| const reflection::Object *const table, |
| const reflection::Field *const field) { |
| // Check if we have already generated this string section, and this is a |
| // shared string instance. |
| if (ContainsSection(string_offset)) { return; } |
| |
| std::vector<BinaryRegion> regions; |
| const auto string_length = ReadScalar<uint32_t>(string_offset); |
| |
| BinaryRegionComment string_length_comment; |
| string_length_comment.type = BinaryRegionCommentType::StringLength; |
| |
| if (!string_length.has_value()) { |
| const uint64_t remaining = RemainingBytes(string_offset); |
| |
| SetError(string_length_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| "4"); |
| |
| regions.push_back(MakeBinaryRegion(string_offset, remaining, |
| BinaryRegionType::Unknown, remaining, 0, |
| string_length_comment)); |
| |
| } else { |
| const uint32_t string_size = string_length.value(); |
| const uint64_t string_end = |
| string_offset + sizeof(uint32_t) + string_size + sizeof(char); |
| |
| if (!IsValidOffset(string_end - 1)) { |
| SetError(string_length_comment, |
| BinaryRegionStatus::ERROR_LENGTH_TOO_LONG); |
| |
| regions.push_back(MakeBinaryRegion(string_offset, sizeof(uint32_t), |
| BinaryRegionType::Uint32, 0, 0, |
| string_length_comment)); |
| } else { |
| regions.push_back(MakeBinaryRegion(string_offset, sizeof(uint32_t), |
| BinaryRegionType::Uint32, 0, 0, |
| string_length_comment)); |
| |
| BinaryRegionComment string_comment; |
| string_comment.type = BinaryRegionCommentType::StringValue; |
| |
| regions.push_back(MakeBinaryRegion(string_offset + sizeof(uint32_t), |
| string_size, BinaryRegionType::Char, |
| string_size, 0, string_comment)); |
| |
| BinaryRegionComment string_terminator_comment; |
| string_terminator_comment.type = |
| BinaryRegionCommentType::StringTerminator; |
| |
| regions.push_back(MakeBinaryRegion( |
| string_offset + sizeof(uint32_t) + string_size, sizeof(char), |
| BinaryRegionType::Char, 0, 0, string_terminator_comment)); |
| } |
| } |
| |
| AddSection(string_offset, |
| MakeBinarySection(std::string(table->name()->c_str()) + "." + |
| field->name()->c_str(), |
| BinarySectionType::String, std::move(regions))); |
| } |
| |
| void BinaryAnnotator::BuildVector(const uint64_t vector_offset, |
| const reflection::Object *const table, |
| const reflection::Field *const field, |
| const uint64_t parent_table_offset, |
| const VTable &vtable) { |
| if (ContainsSection(vector_offset)) { return; } |
| |
| BinaryRegionComment vector_length_comment; |
| vector_length_comment.type = BinaryRegionCommentType::VectorLength; |
| |
| const auto vector_length = ReadScalar<uint32_t>(vector_offset); |
| if (!vector_length.has_value()) { |
| const uint64_t remaining = RemainingBytes(vector_offset); |
| SetError(vector_length_comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| "4"); |
| |
| AddSection( |
| vector_offset, |
| MakeSingleRegionBinarySection( |
| std::string(table->name()->c_str()) + "." + field->name()->c_str(), |
| BinarySectionType::Vector, |
| MakeBinaryRegion(vector_offset, remaining, |
| BinaryRegionType::Unknown, remaining, 0, |
| vector_length_comment))); |
| return; |
| } |
| |
| // Validate there are enough bytes left in the binary to process all the |
| // items. |
| const uint64_t last_item_offset = |
| vector_offset + sizeof(uint32_t) + |
| vector_length.value() * GetElementSize(field); |
| |
| if (!IsValidOffset(last_item_offset - 1)) { |
| SetError(vector_length_comment, BinaryRegionStatus::ERROR_LENGTH_TOO_LONG); |
| AddSection( |
| vector_offset, |
| MakeSingleRegionBinarySection( |
| std::string(table->name()->c_str()) + "." + field->name()->c_str(), |
| BinarySectionType::Vector, |
| MakeBinaryRegion(vector_offset, sizeof(uint32_t), |
| BinaryRegionType::Uint32, 0, 0, |
| vector_length_comment))); |
| |
| return; |
| } |
| |
| std::vector<BinaryRegion> regions; |
| |
| regions.push_back(MakeBinaryRegion(vector_offset, sizeof(uint32_t), |
| BinaryRegionType::Uint32, 0, 0, |
| vector_length_comment)); |
| |
| uint64_t offset = vector_offset + sizeof(uint32_t); |
| |
| switch (field->type()->element()) { |
| case reflection::BaseType::Obj: { |
| const reflection::Object *object = |
| schema_->objects()->Get(field->type()->index()); |
| |
| if (object->is_struct()) { |
| // Vector of structs |
| for (size_t i = 0; i < vector_length.value(); ++i) { |
| // Structs are inline to the vector. |
| const uint64_t next_offset = BuildStruct(offset, regions, object); |
| if (next_offset == offset) { break; } |
| offset = next_offset; |
| } |
| } else { |
| // Vector of objects |
| for (size_t i = 0; i < vector_length.value(); ++i) { |
| BinaryRegionComment vector_object_comment; |
| vector_object_comment.type = |
| BinaryRegionCommentType::VectorTableValue; |
| vector_object_comment.index = i; |
| |
| const auto table_relative_offset = ReadScalar<uint32_t>(offset); |
| if (!table_relative_offset.has_value()) { |
| const uint64_t remaining = RemainingBytes(offset); |
| SetError(vector_object_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4"); |
| |
| regions.push_back( |
| MakeBinaryRegion(offset, remaining, BinaryRegionType::Unknown, |
| remaining, 0, vector_object_comment)); |
| break; |
| } |
| |
| // The table offset is relative from the offset location itself. |
| const uint64_t table_offset = offset + table_relative_offset.value(); |
| |
| if (!IsValidOffset(table_offset)) { |
| SetError(vector_object_comment, |
| BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| regions.push_back(MakeBinaryRegion( |
| offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| table_offset, vector_object_comment)); |
| |
| offset += sizeof(uint32_t); |
| continue; |
| } |
| |
| if (table_offset == parent_table_offset) { |
| SetError(vector_object_comment, |
| BinaryRegionStatus::ERROR_CYCLE_DETECTED); |
| // A cycle detected where a table vector field is pointing to |
| // itself. This should only happen in corrupted files. |
| regions.push_back(MakeBinaryRegion( |
| offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| table_offset, vector_object_comment)); |
| |
| offset += sizeof(uint32_t); |
| continue; |
| } |
| |
| regions.push_back(MakeBinaryRegion( |
| offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| table_offset, vector_object_comment)); |
| |
| offset += sizeof(uint32_t); |
| |
| BuildTable(table_offset, BinarySectionType::Table, object); |
| } |
| } |
| } break; |
| case reflection::BaseType::String: { |
| // Vector of strings |
| for (size_t i = 0; i < vector_length.value(); ++i) { |
| BinaryRegionComment vector_object_comment; |
| vector_object_comment.type = BinaryRegionCommentType::VectorStringValue; |
| vector_object_comment.index = i; |
| |
| const auto string_relative_offset = ReadScalar<uint32_t>(offset); |
| if (!string_relative_offset.has_value()) { |
| const uint64_t remaining = RemainingBytes(offset); |
| |
| SetError(vector_object_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4"); |
| |
| regions.push_back( |
| MakeBinaryRegion(offset, remaining, BinaryRegionType::Unknown, |
| remaining, 0, vector_object_comment)); |
| break; |
| } |
| |
| // The string offset is relative from the offset location itself. |
| const uint64_t string_offset = offset + string_relative_offset.value(); |
| |
| if (!IsValidOffset(string_offset)) { |
| SetError(vector_object_comment, |
| BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| regions.push_back(MakeBinaryRegion( |
| offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| string_offset, vector_object_comment)); |
| |
| offset += sizeof(uint32_t); |
| continue; |
| } |
| |
| regions.push_back(MakeBinaryRegion( |
| offset, sizeof(uint32_t), BinaryRegionType::UOffset, 0, |
| string_offset, vector_object_comment)); |
| |
| BuildString(string_offset, table, field); |
| |
| offset += sizeof(uint32_t); |
| } |
| } break; |
| case reflection::BaseType::Union: { |
| // Vector of unions |
| // Unions have both their realized type (uint8_t for now) that are |
| // stored separately. These are stored in the field->index() - 1 |
| // location. |
| const uint16_t union_type_vector_id = field->id() - 1; |
| |
| auto vtable_entry = vtable.fields.find(union_type_vector_id); |
| if (vtable_entry == vtable.fields.end()) { |
| // TODO(dbaileychess): need to capture this error condition. |
| break; |
| } |
| |
| const uint64_t union_type_vector_field_offset = |
| parent_table_offset + vtable_entry->second.offset_from_table; |
| |
| const auto union_type_vector_field_relative_offset = |
| ReadScalar<uint16_t>(union_type_vector_field_offset); |
| |
| if (!union_type_vector_field_relative_offset.has_value()) { |
| const uint64_t remaining = RemainingBytes(offset); |
| BinaryRegionComment vector_union_comment; |
| vector_union_comment.type = BinaryRegionCommentType::VectorUnionValue; |
| SetError(vector_union_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "2"); |
| |
| regions.push_back(MakeBinaryRegion(offset, remaining, |
| BinaryRegionType::Unknown, remaining, |
| 0, vector_union_comment)); |
| |
| break; |
| } |
| |
| // Get the offset to the first type (the + sizeof(uint32_t) is to skip |
| // over the vector length which we already know). Validation happens |
| // within the loop below. |
| const uint64_t union_type_vector_data_offset = |
| union_type_vector_field_offset + |
| union_type_vector_field_relative_offset.value() + sizeof(uint32_t); |
| |
| for (size_t i = 0; i < vector_length.value(); ++i) { |
| BinaryRegionComment comment; |
| comment.type = BinaryRegionCommentType::VectorUnionValue; |
| comment.index = i; |
| |
| const auto union_relative_offset = ReadScalar<uint32_t>(offset); |
| if (!union_relative_offset.has_value()) { |
| const uint64_t remaining = RemainingBytes(offset); |
| |
| SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "4"); |
| |
| regions.push_back(MakeBinaryRegion(offset, remaining, |
| BinaryRegionType::Unknown, |
| remaining, 0, comment)); |
| |
| break; |
| } |
| |
| // The union offset is relative from the offset location itself. |
| const uint64_t union_offset = offset + union_relative_offset.value(); |
| |
| if (!IsValidOffset(union_offset)) { |
| SetError(comment, BinaryRegionStatus::ERROR_OFFSET_OUT_OF_BINARY); |
| |
| regions.push_back(MakeBinaryRegion(offset, sizeof(uint32_t), |
| BinaryRegionType::UOffset, 0, |
| union_offset, comment)); |
| continue; |
| } |
| |
| const auto realized_type = |
| ReadScalar<uint8_t>(union_type_vector_data_offset + i); |
| |
| if (!realized_type.has_value()) { |
| SetError(comment, BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, "1"); |
| regions.push_back(MakeBinaryRegion( |
| offset, 0, BinaryRegionType::Unknown, 0, 0, comment)); |
| continue; |
| } |
| |
| if (!IsValidUnionValue(vtable_entry->second.field->type()->index(), |
| realized_type.value())) { |
| // We already export an error in the union type field, so just skip |
| // building the union itself and it will default to an unreference |
| // Binary section. |
| offset += sizeof(uint32_t); |
| continue; |
| } |
| |
| const std::string enum_type = |
| BuildUnion(union_offset, realized_type.value(), field); |
| |
| comment.default_value = "(`" + enum_type + "`)"; |
| regions.push_back(MakeBinaryRegion(offset, sizeof(uint32_t), |
| BinaryRegionType::UOffset, 0, |
| union_offset, comment)); |
| |
| offset += sizeof(uint32_t); |
| } |
| } break; |
| default: { |
| if (IsScalar(field->type()->element())) { |
| const BinaryRegionType binary_region_type = |
| GetRegionType(field->type()->element()); |
| |
| const uint64_t type_size = GetTypeSize(field->type()->element()); |
| |
| // TODO(dbaileychess): It might be nicer to user the |
| // BinaryRegion.array_length field to indicate this. |
| for (size_t i = 0; i < vector_length.value(); ++i) { |
| BinaryRegionComment vector_scalar_comment; |
| vector_scalar_comment.type = BinaryRegionCommentType::VectorValue; |
| vector_scalar_comment.index = i; |
| |
| if (!IsValidRead(offset, type_size)) { |
| const uint64_t remaining = RemainingBytes(offset); |
| |
| SetError(vector_scalar_comment, |
| BinaryRegionStatus::ERROR_INCOMPLETE_BINARY, |
| std::to_string(type_size)); |
| |
| regions.push_back( |
| MakeBinaryRegion(offset, remaining, BinaryRegionType::Unknown, |
| remaining, 0, vector_scalar_comment)); |
| break; |
| } |
| |
| if (IsUnionType(field->type()->element())) { |
| // This is a type for a union. Validate the value |
| const auto enum_value = ReadScalar<uint8_t>(offset); |
| |
| // This should always have a value, due to the IsValidRead check |
| // above. |
| if (!IsValidUnionValue(field->type()->index(), |
| enum_value.value())) { |
| SetError(vector_scalar_comment, |
| BinaryRegionStatus::ERROR_INVALID_UNION_TYPE); |
| regions.push_back(MakeBinaryRegion(offset, type_size, |
| binary_region_type, 0, 0, |
| vector_scalar_comment)); |
| offset += type_size; |
| continue; |
| } |
| } |
| |
| regions.push_back(MakeBinaryRegion(offset, type_size, |
| binary_region_type, 0, 0, |
| vector_scalar_comment)); |
| offset += type_size; |
| } |
| } |
| } break; |
| } |
| AddSection(vector_offset, |
| MakeBinarySection(std::string(table->name()->c_str()) + "." + |
| field->name()->c_str(), |
| BinarySectionType::Vector, std::move(regions))); |
| } |
| |
| std::string BinaryAnnotator::BuildUnion(const uint64_t union_offset, |
| const uint8_t realized_type, |
| const reflection::Field *const field) { |
| const reflection::Enum *next_enum = |
| schema_->enums()->Get(field->type()->index()); |
| |
| const reflection::EnumVal *enum_val = next_enum->values()->Get(realized_type); |
| |
| if (ContainsSection(union_offset)) { return enum_val->name()->c_str(); } |
| |
| const reflection::Type *union_type = enum_val->union_type(); |
| |
| if (union_type->base_type() == reflection::BaseType::Obj) { |
| const reflection::Object *object = |
| schema_->objects()->Get(union_type->index()); |
| |
| if (object->is_struct()) { |
| // Union of vectors point to a new Binary section |
| std::vector<BinaryRegion> regions; |
| |
| BuildStruct(union_offset, regions, object); |
| |
| AddSection( |
| union_offset, |
| MakeBinarySection(std::string(object->name()->c_str()) + "." + |
| field->name()->c_str(), |
| BinarySectionType::Union, std::move(regions))); |
| } else { |
| BuildTable(union_offset, BinarySectionType::Table, object); |
| } |
| } |
| // TODO(dbaileychess): handle the other union types. |
| |
| return enum_val->name()->c_str(); |
| } |
| |
| void BinaryAnnotator::FixMissingRegions() { |
| std::vector<BinaryRegion> regions_to_insert; |
| for (auto ¤t_section : sections_) { |
| BinarySection §ion = current_section.second; |
| if (section.regions.empty()) { |
| // TODO(dbaileychess): is this possible? |
| continue; |
| } |
| |
| uint64_t offset = section.regions[0].offset + section.regions[0].length; |
| for (size_t i = 1; i < section.regions.size(); ++i) { |
| BinaryRegion ®ion = section.regions[i]; |
| |
| const uint64_t next_offset = region.offset; |
| if (!IsValidOffset(next_offset)) { |
| // TODO(dbaileychess): figure out how we get into this situation. |
| continue; |
| } |
| |
| if (offset < next_offset) { |
| const uint64_t padding_bytes = next_offset - offset; |
| |
| BinaryRegionComment comment; |
| comment.type = BinaryRegionCommentType::Padding; |
| |
| if (IsNonZeroRegion(offset, padding_bytes, binary_)) { |
| SetError(comment, BinaryRegionStatus::WARN_NO_REFERENCES); |
| regions_to_insert.push_back( |
| MakeBinaryRegion(offset, padding_bytes, BinaryRegionType::Unknown, |
| padding_bytes, 0, comment)); |
| } else { |
| regions_to_insert.push_back( |
| MakeBinaryRegion(offset, padding_bytes, BinaryRegionType::Uint8, |
| padding_bytes, 0, comment)); |
| } |
| } |
| offset = next_offset + region.length; |
| } |
| |
| if (!regions_to_insert.empty()) { |
| section.regions.insert(section.regions.end(), regions_to_insert.begin(), |
| regions_to_insert.end()); |
| std::stable_sort(section.regions.begin(), section.regions.end(), |
| BinaryRegionSort); |
| regions_to_insert.clear(); |
| } |
| } |
| } |
| |
| void BinaryAnnotator::FixMissingSections() { |
| uint64_t offset = 0; |
| |
| std::vector<BinarySection> sections_to_insert; |
| |
| for (auto ¤t_section : sections_) { |
| BinarySection §ion = current_section.second; |
| const uint64_t section_start_offset = current_section.first; |
| const uint64_t section_end_offset = |
| section.regions.back().offset + section.regions.back().length; |
| |
| if (offset < section_start_offset) { |
| // We are at an offset that is less then the current section. |
| const uint64_t pad_bytes = section_start_offset - offset + 1; |
| |
| sections_to_insert.push_back( |
| GenerateMissingSection(offset - 1, pad_bytes, binary_)); |
| } |
| offset = section_end_offset + 1; |
| } |
| |
| // Handle the case where there are still bytes left in the binary that are |
| // unaccounted for. |
| if (offset < binary_length_) { |
| const uint64_t pad_bytes = binary_length_ - offset + 1; |
| sections_to_insert.push_back( |
| GenerateMissingSection(offset - 1, pad_bytes, binary_)); |
| } |
| |
| for (const BinarySection §ion_to_insert : sections_to_insert) { |
| AddSection(section_to_insert.regions[0].offset, section_to_insert); |
| } |
| } |
| |
| bool BinaryAnnotator::ContainsSection(const uint64_t offset) { |
| auto it = sections_.lower_bound(offset); |
| // If the section is found, check that it is exactly equal its offset. |
| if (it != sections_.end() && it->first == offset) { return true; } |
| |
| // If this was the first section, there are no other previous sections to |
| // check. |
| if (it == sections_.begin()) { return false; } |
| |
| // Go back one section. |
| --it; |
| |
| // And check that if the offset is covered by the section. |
| return offset >= it->first && offset < it->second.regions.back().offset + |
| it->second.regions.back().length; |
| } |
| |
| } // namespace flatbuffers |
