private void Load(StructureValueCollection values, FileSegmenter segmenter) { _eofSegment = segmenter.WrapEOF((int) values.GetInteger("file size")); var metaOffset = (int) values.GetInteger("meta offset"); var metaSize = (int) values.GetInteger("meta size"); uint metaOffsetMask = values.GetInteger("meta offset mask"); var metaSegment = new FileSegment( segmenter.DefineSegment(metaOffset, metaSize, 0x200, SegmentResizeOrigin.Beginning), segmenter); MetaArea = new FileSegmentGroup(new MetaOffsetConverter(metaSegment, metaOffsetMask)); IndexHeaderLocation = MetaArea.AddSegment(metaSegment); Type = (CacheFileType) values.GetInteger("type"); var headerGroup = new FileSegmentGroup(); headerGroup.AddSegment(segmenter.WrapSegment(0, HeaderSize, 1, SegmentResizeOrigin.None)); StringIDCount = (int) values.GetInteger("string table count"); var sidDataSize = (int) values.GetInteger("string table size"); StringIDData = segmenter.WrapSegment((int) values.GetInteger("string table offset"), sidDataSize, 1, SegmentResizeOrigin.End); StringIDIndexTable = segmenter.WrapSegment((int) values.GetInteger("string index table offset"), StringIDCount*4, 4, SegmentResizeOrigin.End); FileNameCount = (int) values.GetInteger("file table count"); var fileDataSize = (int) values.GetInteger("file table size"); FileNameData = segmenter.WrapSegment((int) values.GetInteger("file table offset"), fileDataSize, 1, SegmentResizeOrigin.End); FileNameIndexTable = segmenter.WrapSegment((int) values.GetInteger("file index table offset"), FileNameCount*4, 4, SegmentResizeOrigin.End); InternalName = values.GetString("internal name"); ScenarioName = values.GetString("scenario name"); StringArea = new FileSegmentGroup(); StringArea.AddSegment(segmenter.WrapSegment((int) values.GetInteger("string block offset"), StringIDCount*0x80, 0x80, SegmentResizeOrigin.End)); StringArea.AddSegment(StringIDIndexTable); StringArea.AddSegment(StringIDData); StringArea.AddSegment(FileNameIndexTable); StringArea.AddSegment(FileNameData); StringIDIndexTableLocation = SegmentPointer.FromOffset(StringIDIndexTable.Offset, StringArea); StringIDDataLocation = SegmentPointer.FromOffset(StringIDData.Offset, StringArea); FileNameIndexTableLocation = SegmentPointer.FromOffset(FileNameIndexTable.Offset, StringArea); FileNameDataLocation = SegmentPointer.FromOffset(FileNameData.Offset, StringArea); LocaleArea = new FileSegmentGroup(); var rawTableOffset = (int) values.GetInteger("raw table offset"); var rawTableSize = (int) values.GetInteger("raw table size"); RawTable = segmenter.WrapSegment(rawTableOffset, rawTableSize, 1, SegmentResizeOrigin.End); Checksum = values.GetInteger("checksum"); // Set up a bogus partition table Partitions = new Partition[1]; Partitions[0] = new Partition(SegmentPointer.FromOffset(MetaArea.Offset, MetaArea), (uint) MetaArea.Size); }
private SegmentPointer(FileSegment baseSegment, FileSegmentGroup baseGroup, int baseSegmentDelta) { _baseSegment = baseSegment; _baseGroup = baseGroup; _baseSegmentDelta = baseSegmentDelta; _originalBaseSize = baseSegment.Size; _baseBottomResizes = (baseSegment.ResizeOrigin == SegmentResizeOrigin.Beginning); }
/// <summary> /// Adds a segment to the group. /// </summary> /// <param name="segment">The segment to add.</param> /// <returns>A SegmentPointer pointing to the beginning of the segment.</returns> public SegmentPointer AddSegment(FileSegment segment) { int offset = segment.Offset; if (_segmentsByOffset.ContainsKey(offset)) { throw new ArgumentException("A segment has already been added at the given offset."); } _segmentsByOffset[segment.Offset] = segment; segment.Resized += SegmentResized; return(SegmentPointer.FromOffset(segment.Offset, this)); }
/// <summary> /// Resizes the last segment in the group, changing the total size of the group to be at least a specified size. /// </summary> /// <param name="newSize">The total amount of space that the resized group should at least occupy.</param> /// <param name="stream">The stream to write changes to.</param> public void Resize(int newSize, IStream stream) { if (Segments.Count == 0) { return; } FileSegment lastSegment = Segments[Segments.Count - 1]; int newLastSegmentSize = newSize - (lastSegment.Offset - Offset); if (newLastSegmentSize <= 0) { throw new ArgumentException("Cannot shrink the group enough without deleting the last segment"); } lastSegment.Resize(newLastSegmentSize, stream); }
/// <summary> /// Given a pointer, creates a SegmentPointer which points to a segment in a certain group. /// </summary> /// <param name="pointer">The pointer to create a SegmentPointer to.</param> /// <param name="baseGroup">The segment group containing the pointer.</param> /// <returns>The SegmentPointer corresponding to the file pointer.</returns> public static SegmentPointer FromPointer(uint pointer, FileSegmentGroup baseGroup) { if (baseGroup.Segments.Count == 0) { throw new ArgumentException("Cannot create a SegmentPointer from an empty group"); } FileSegment baseSegment = baseGroup.FindSegmentWithPointer(pointer); if (baseSegment == null) { throw new ArgumentException("Cannot create a SegmentPointer from an invalid pointer"); } int baseSegmentDelta = baseGroup.PointerToOffset(pointer) - baseSegment.Offset; return(new SegmentPointer(baseSegment, baseGroup, baseSegmentDelta)); }
/// <summary> /// Given a file offset, creates a SegmentPointer which points to a segment in a certain group. /// </summary> /// <param name="fileOffset">The file offset to create a SegmentPointer to.</param> /// <param name="baseGroup">The segment group containing the file offset.</param> /// <returns>The SegmentPointer corresponding to the file offset.</returns> public static SegmentPointer FromOffset(int fileOffset, FileSegmentGroup baseGroup) { if (baseGroup.Segments.Count == 0) { throw new ArgumentException("Cannot create a SegmentPointer from an empty group"); } FileSegment baseSegment = baseGroup.FindSegmentWithOffset(fileOffset); if (baseSegment == null) { throw new ArgumentException("Cannot create a SegmentPointer from an invalid offset"); } int baseSegmentDelta = fileOffset - baseSegment.Offset; return(new SegmentPointer(baseSegment, baseGroup, baseSegmentDelta)); }
private void Load(StructureValueCollection values, FileSegmenter segmenter) { segmenter.DefineSegment(0, HeaderSize, 1, SegmentResizeOrigin.Beginning); // Define a segment for the header _eofSegment = segmenter.WrapEOF((int) values.GetInteger("file size")); LoadInteropData(values); RawTable = CalculateRawTableSegment(segmenter); Type = (CacheFileType) values.GetInteger("type"); InternalName = values.GetString("internal name"); ScenarioName = values.GetString("scenario name"); XDKVersion = (int) values.GetInteger("xdk version"); FileSegment metaSegment = CalculateTagDataSegment(values, segmenter); if (metaSegment != null) { uint virtualBase = values.GetInteger("virtual base address"); MetaArea = new FileSegmentGroup(new MetaAddressConverter(metaSegment, virtualBase)); MetaArea.AddSegment(metaSegment); IndexHeaderLocation = SegmentPointer.FromPointer(values.GetInteger("index header address"), MetaArea); Partitions = LoadPartitions(values.GetArray("partitions")); } else { Partitions = new Partition[0]; } CalculateStringGroup(values, segmenter); }
public MetaOffsetConverter(FileSegment metaSegment, uint mask) { _metaSegment = metaSegment; _mask = mask; }
/// <summary> /// Adds a segment to the group. /// </summary> /// <param name="segment">The segment to add.</param> /// <returns>A SegmentPointer pointing to the beginning of the segment.</returns> public SegmentPointer AddSegment(FileSegment segment) { int offset = segment.Offset; if (_segmentsByOffset.ContainsKey(offset)) throw new ArgumentException("A segment has already been added at the given offset."); _segmentsByOffset[segment.Offset] = segment; segment.Resized += SegmentResized; return SegmentPointer.FromOffset(segment.Offset, this); }
/// <summary> /// Constructs a new MetaAddressConverter. /// </summary> /// <param name="metaSegment">The FileSegment where meta is stored.</param> /// <param name="virtualBase">The virtual base address of the meta.</param> public MetaAddressConverter(FileSegment metaSegment, uint virtualBase) { _metaSegment = metaSegment; _virtualBase = virtualBase; metaSegment.Resized += MetaResized; }
/// <summary> /// Creates a new ResourcePageExtractor which can extract resource pages from a cache file. /// </summary> /// <param name="cacheFile">The cache file to extract resource pages from.</param> public ResourcePageExtractor(ICacheFile cacheFile) { _rawTable = cacheFile.RawTable; }
/// <summary> /// Adds a tag to the table and allocates space for its base data. /// </summary> /// <param name="classMagic">The magic number (ID) of the tag's class.</param> /// <param name="baseSize">The size of the data to initially allocate for the tag.</param> /// <param name="stream">The stream to write to.</param> /// <returns> /// The tag that was allocated. /// </returns> public override ITag AddTag(int classMagic, int baseSize, IStream stream) { /* //if (_indexHeaderLocation == null) // throw new InvalidOperationException("Tags cannot be added to a shared map"); ITagClass tagClass = Classes.FirstOrDefault(c => (c.Magic == classMagic)); if (tagClass == null) throw new InvalidOperationException("Invalid tag class"); uint address = _allocator.Allocate(baseSize, stream); var index = new DatumIndex(0x4153, (ushort) _tags.Count); // 0x4153 = 'AS' because the salt doesn't matter var result = new FourthGenTag(index, tagClass, (uint)stream.Position); _tags.Add(result); return result; * */ ITagClass tagClass = Classes.FirstOrDefault(c => (c.Magic == classMagic)); if (tagClass == null) throw new InvalidOperationException("Invalid tag class"); var offset = stream.BaseStream.Position; uint address = _allocator.Allocate(baseSize, stream); var index = new DatumIndex(0x4153, (ushort)_tags.Count); // 0x4153 = 'AS' because the salt doesn't matter // File Segment FileSegmenter segmenter = new FileSegmenter(); segmenter.DefineSegment(0, (int)stream.Length, 0x4, SegmentResizeOrigin.Beginning); // Define a segment for the header //_eofSegment = segmenter.WrapEOF((int)map_values.GetInteger("file size")); FileSegment segment = new FileSegment(0, segmenter); FileSegmentGroup segmentgroup = new FileSegmentGroup(); SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, (int)offset); FourthGenTag result = new FourthGenTag(index, tagClass, pointer, pointer); _tags.Add(result); return result; }
private List<ITag> LoadTags(IReader reader, StructureValueCollection headerValues, IList<ITagClass> classes) { /* StructureLayout layout = _buildInfo.Layouts.GetLayout("tag entry"); StructureValueCollection[] entries = ReflexiveReader.ReadReflexive(reader, count, address, layout, _metaArea); return entries.Select<StructureValueCollection, ITag>((e, i) => new FourthGenTag(e, (ushort) i, _metaArea, classes)) .ToList(); */ List<ITag> tags = new List<ITag>(); // New list of tags reader.SeekTo(0); var count = (int) headerValues.GetInteger("number of tags"); uint address = headerValues.GetInteger("tag table address"); StructureLayout layout = _buildInfo.Layouts.GetLayout("tag entry"); // File Segment FileSegmenter segmenter = new FileSegmenter(); segmenter.DefineSegment(0, (int)reader.Length, 0x4, SegmentResizeOrigin.Beginning); // Define a segment for the header //_eofSegment = segmenter.WrapEOF((int)map_values.GetInteger("file size")); FileSegment segment = new FileSegment(0, segmenter); FileSegmentGroup segmentgroup = new FileSegmentGroup(); // Find all of the tag offsets reader.BaseStream.Position = address; // Start at the beginning og the offsets List<uint> tagOffsets = new List<uint>(); for (int i = 0; i < count; i++) tagOffsets.Add(reader.ReadUInt32()); reader.BaseStream.Position = tagOffsets[0]; for (int i = 0; i < count; i++) // Loop through each offset { //if (tagOffsets[i] == 0) tags.Add(null); //else if (tagOffsets[i] != 0) { //var headerOffset = (uint)reader.BaseStream.Position; /* var checksum = reader.ReadUInt32(); // 0x00 uint32 checksum? var totalSize = reader.ReadUInt32(); // 0x04 uint32 total size var numDependencies = reader.ReadInt16(); // 0x08 int16 dependencies count var numDataFixups = reader.ReadInt16(); // 0x0A int16 data fixup count var numResourceFixups = reader.ReadInt16(); // 0x0C int16 resource fixup count reader.BaseStream.Position += 2; // 0x0E int16 (padding) var mainStructOffset = reader.ReadUInt32(); // 0x10 uint32 main struct offset var tagClass = reader.ReadInt32(); // 0x14 int32 class var parentClass = reader.ReadInt32(); // 0x18 int32 parent class var grandparentClass = reader.ReadInt32(); // 0x1C int32 grandparent class var classId = reader.ReadUInt32(); // 0x20 uint32 class stringid */ /* reader.BaseStream.Position = tagOffsets[i]; StructureValueCollection tag_entry_values = StructureReader.ReadStructure(reader, layout); uint id = tag_entry_values.GetInteger("magic"); if(id == 0x3c66783e ) { uint x = id; } //ITagClass tagclass = TryAddClass(tag_entry_values); //FourthGenTag tag = new FourthGenTag(new DatumIndex(headerOffset), tagclass, headerOffset); uint tag_offset = tagOffsets[i]; //SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, (int)tag_offset); uint dep_size = (tag_entry_values.GetInteger("dependencies count") * 4 + tag_entry_values.GetInteger("data fixups count") * 4 + tag_entry_values.GetInteger("resource fixups count") * 4); tag_offset += tag_entry_values.GetInteger("total size") - (tag_entry_values.GetInteger("main struct offset") + dep_size); ITagClass tagclass = TryAddClass(tag_entry_values); //FourthGenTag tag = new FourthGenTag(new DatumIndex(headerOffset), tagclass, headerOffset); SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, (int)(tag_offset)); FourthGenTag tag = new FourthGenTag(new DatumIndex(tag_offset), tagclass, pointer); tags.Add(tag); * */ var headerOffset = tagOffsets[i]; reader.BaseStream.Position = headerOffset; StructureValueCollection tag_entry_values = StructureReader.ReadStructure(reader, layout); reader.BaseStream.Position = tagOffsets[i] + 0x24; int structOffset = (int)tag_entry_values.GetInteger("main struct offset"); int metaOffset = (int)tagOffsets[i] + structOffset; ITagClass tagclass = TryAddClass(tag_entry_values); //SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, metaOffset); //FourthGenTag tag = new FourthGenTag(new DatumIndex((uint)i), tagclass, pointer); SegmentPointer hdrPointer = new SegmentPointer(segment, segmentgroup, (int)headerOffset); SegmentPointer pointer = new SegmentPointer(segment, segmentgroup, metaOffset); FourthGenTag tag = new FourthGenTag(new DatumIndex((uint)i), tagclass, hdrPointer, pointer); tags.Add(tag); } else // Null Tag { FourthGenTag tag = new FourthGenTag(new DatumIndex((uint)i), null, null, null); tags.Add(tag); } } return tags.Where(t => t != null).ToList(); // Remove NULL Entries }
/* private void AdjustPartitions() { if (MetaArea == null) return; // Find the first partition with a non-null address and change it to the meta area's base address Partition partition = Partitions.First(p => p.BasePointer != null); if (partition != null) partition.BasePointer = SegmentPointer.FromPointer(MetaArea.BasePointer, MetaArea); // Recalculate the size of each partition int partitionEnd = MetaArea.Offset + MetaArea.Size; for (int i = Partitions.Length - 1; i >= 0; i--) { if (Partitions[i].BasePointer == null) continue; int offset = Partitions[i].BasePointer.AsOffset(); Partitions[i].Size = (uint) (partitionEnd - offset); partitionEnd = offset; } } */ /* private StructureValueCollection[] SerializePartitions() { if (Partitions == null) return new StructureValueCollection[0]; var results = new StructureValueCollection[Partitions.Length]; for (int i = 0; i < Partitions.Length; i++) { var values = new StructureValueCollection(); values.SetInteger("load address", Partitions[i].BasePointer != null ? Partitions[i].BasePointer.AsPointer() : 0); values.SetInteger("size", Partitions[i].Size); results[i] = values; } return results; } */ /// <summary> /// Rebuilds the interop data table in a cache file. /// </summary> /// <param name="localeArea">The localization area of the file.</param> /* private void RebuildInteropData(FileSegmentGroup localeArea) { FourthGenInteropSection debugSection = Sections[(int) FourthGenInteropSectionType.Debug]; FourthGenInteropSection rsrcSection = Sections[(int) FourthGenInteropSectionType.Resource]; FourthGenInteropSection tagSection = Sections[(int) FourthGenInteropSectionType.Tag]; FourthGenInteropSection localeSection = Sections[(int) FourthGenInteropSectionType.Localization]; // Recompute base addresses // Section addresses are usually in the following order: resource, locale, tag, debug. // Each address can immediately follow after the previous non-null section, // even though this isn't the case in some of the official files (because of removed debug data). // // TODO: This could possibly be made into a for loop and cleaned up if the pointer converters are stored in an array. // I just want to get this working for now. rsrcSection.VirtualAddress = 0; // This is always zero rsrcSection.Size = (ResourcePointerConverter != null) ? (uint) RawTable.Size : 0; localeSection.VirtualAddress = (LocalePointerConverter != null) ? rsrcSection.VirtualAddress + rsrcSection.Size : 0; localeSection.Size = (LocalePointerConverter != null) ? (uint) localeArea.Size : 0; tagSection.VirtualAddress = (TagBufferPointerConverter != null) ? rsrcSection.VirtualAddress + rsrcSection.Size + localeSection.Size : 0; tagSection.Size = (TagBufferPointerConverter != null) ? (uint) MetaArea.Size : 0; debugSection.VirtualAddress = (DebugPointerConverter != null) ? rsrcSection.VirtualAddress + rsrcSection.Size + localeSection.Size + tagSection.Size : 0; debugSection.Size = (DebugPointerConverter != null) ? (uint) StringArea.Size : 0; // If the offset mask for the debug section wasn't originally zero, then we have to subtract the first partition size from the debug base address // Not entirely sure why this is the case, but that's what the official files do if (debugSection.VirtualAddress != 0 && SectionOffsetMasks[(int) FourthGenInteropSectionType.Debug] != 0) debugSection.VirtualAddress -= Partitions[0].Size; // Recompute offset masks SectionOffsetMasks[(int) FourthGenInteropSectionType.Debug] = (debugSection.Size > 0) ? (uint) (StringArea.Offset - debugSection.VirtualAddress) : 0; SectionOffsetMasks[(int) FourthGenInteropSectionType.Resource] = (rsrcSection.Size > 0) ? (uint) (RawTable.Offset - rsrcSection.VirtualAddress) : 0; SectionOffsetMasks[(int) FourthGenInteropSectionType.Tag] = (tagSection.Size > 0) ? (uint) (MetaArea.Offset - tagSection.VirtualAddress) : 0; SectionOffsetMasks[(int) FourthGenInteropSectionType.Localization] = (localeSection.Size > 0) ? (uint) (localeArea.Offset - localeSection.VirtualAddress) : 0; // Update pointer converters if (DebugPointerConverter != null) DebugPointerConverter.BasePointer = debugSection.VirtualAddress; if (ResourcePointerConverter != null) ResourcePointerConverter.BasePointer = rsrcSection.VirtualAddress; if (TagBufferPointerConverter != null) TagBufferPointerConverter.BasePointer = tagSection.VirtualAddress; if (LocalePointerConverter != null) LocalePointerConverter.BasePointer = localeSection.VirtualAddress; } */ private void Load(StructureValueCollection map_values, StructureValueCollection tag_values, StructureValueCollection string_values, FileSegmenter map_segmenter) { map_segmenter.DefineSegment(0, HeaderSize, 1, SegmentResizeOrigin.Beginning); // Define a segment for the header _eofSegment = map_segmenter.WrapEOF((int)map_values.GetInteger("file size")); //LoadInteropData(map_values, tag_values); //RawTable = CalculateRawTableSegment(segmenter); Type = (CacheFileType)map_values.GetInteger("type"); InternalName = map_values.GetString("internal name"); ScenarioPath = map_values.GetString("scenario path"); uint index_header_address = map_values.GetInteger("index header address"); // File Segment FileSegmenter tags_segmenter = new FileSegmenter(); tags_segmenter.DefineSegment(0, (int)EngineInfo.TagsDataSize, 0x1, SegmentResizeOrigin.Beginning); // Define a segment for the header FileSegment metaSegment = new FileSegment(0, tags_segmenter); //FileSegment metaSegment = CalculateTagDataSegment(tag_values, segmenter); MetaArea = new FileSegmentGroup(new MetaAddressConverter(metaSegment, index_header_address)); MetaArea.AddSegment(metaSegment); IndexHeaderLocation = SegmentPointer.FromPointer(index_header_address, MetaArea); //XDKVersion = (int) values.GetInteger("xdk version"); /* FileSegment metaSegment = CalculateTagDataSegment(values, segmenter); if (metaSegment != null) { uint virtualBase = values.GetInteger("virtual base address"); MetaArea = new FileSegmentGroup(new MetaAddressConverter(metaSegment, virtualBase)); MetaArea.AddSegment(metaSegment); IndexHeaderLocation = SegmentPointer.FromPointer(values.GetInteger("index header address"), MetaArea); Partitions = LoadPartitions(values.GetArray("partitions")); } else { Partitions = new Partition[0]; } */ CalculateStringGroup(string_values, map_segmenter); }