/// <summary> /// Updates the data in this header entry for the specified item. /// </summary> /// <param name="item">The item this entry belongs to.</param> internal void Update(NefsItem item) { off_0x00_offset_to_data.Value = item.DataOffset; off_0x08_offset_in_hdr_pt2.Value = item.OffsetIntoPt2Raw; off_0x0c_offset_in_hdr_pt4.Value = item.OffsetIntoPt4Raw; off_0x10_index.Value = item.Id; }
public void CreateHeaderFromFile_ItemIsNotCompressed_ItemCreated() { var nefs = TestArchiveNotModified.Create(@"C:\archive.nefs"); var itemId = new NefsItemId(TestArchiveNotModified.File3ItemId); var item = NefsItem.CreateFromHeader(itemId, nefs.Header, nefs.Items); // File3 is not compressed var expected = nefs.Items.GetItem(itemId); Assert.Equal(expected.CompressedSize, item.CompressedSize); Assert.Equal(expected.DirectoryId, item.DirectoryId); Assert.Equal(expected.ExtractedSize, item.ExtractedSize); Assert.Equal(expected.FileName, item.FileName); Assert.Equal(expected.Id, item.Id); Assert.Equal(expected.State, item.State); Assert.Equal(NefsItemType.File, item.Type); Assert.Equal(@"C:\archive.nefs", item.DataSource.FilePath); Assert.Equal(expected.DataSource.Offset, item.DataSource.Offset); Assert.False(item.DataSource.ShouldCompress); Assert.Single(item.DataSource.Size.ChunkSizes); Assert.Equal(expected.ExtractedSize, item.DataSource.Size.ChunkSizes[0]); Assert.Equal(expected.ExtractedSize, item.DataSource.Size.ExtractedSize); Assert.False(item.DataSource.Size.IsCompressed); Assert.Equal(expected.CompressedSize, item.DataSource.Size.Size); }
/// <inheritdoc/> public bool ReplaceItemByDialog(NefsItem item) { if (item == null) { Log.LogError($"Cannot replace item. Item is null."); return(false); } // Have user pick file (var result, var fileName) = this.UiService.ShowOpenFileDialog(); if (result != DialogResult.OK) { return(false); } // Check file exists if (!this.FileSystem.File.Exists(fileName)) { Log.LogError($"Cannot replace item. Replacement file does not exist: {fileName}."); return(false); } var fileSize = this.FileSystem.FileInfo.FromFileName(fileName).Length; var itemSize = new NefsItemSize((uint)fileSize); var newDataSource = new NefsFileDataSource(fileName, 0, itemSize, false); var cmd = new ReplaceFileCommand(item, item.DataSource, item.State, newDataSource); this.UndoBuffer.Execute(cmd); return(true); }
private async Task <bool> ExtractFileAsync(NefsItem item, string outputFilePath, NefsProgress p) { try { // Create target directory if needed var dir = Path.GetDirectoryName(outputFilePath); if (!this.FileSystem.Directory.Exists(dir)) { this.FileSystem.Directory.CreateDirectory(dir); } // Extract the file await this.NefsTransformer.DetransformFileAsync( item.DataSource.FilePath, (Int64)item.DataSource.Offset, outputFilePath, 0, item.ExtractedSize, item.DataSource.Size.Chunks, p); return(true); } catch (Exception ex) { Log.LogError(ex, $"Failed to extract item {item.FileName}."); return(false); } }
void extractNEFS() { NefsProgressInfo _progressInfo = new NefsProgressInfo(); _progressInfo.Progress = new Progress <NefsProgress>(); DirectoryInfo di = new DirectoryInfo(PathToCars); foreach (FileInfo fi in di.GetFiles("*.nefs")) { try { NefsArchive archive = new NefsArchive(fi.FullName, _progressInfo); NefsItem item = archive.GetItem(13); string car3 = fi.Name.Replace(fi.Extension, ""); FileInfo fi2 = new FileInfo(PathToCars + "\\" + car3 + "\\" + item.Filename + ".bin.xml"); item.Extract(fi2.FullName, _progressInfo); string filename = PathToCars + "\\" + car3 + "\\" + item.Filename; ConvertBinXMLToPlainXML(fi2.FullName, filename); } catch (Exception) { } } }
/// <summary> /// Opens a directory in the archive for viewing. /// </summary> /// <param name="dir">The directory to view. Use null for root directory.</param> private void OpenDirectory(NefsItem dir) { IEnumerable <NefsItem> itemsInDir; var items = this.Workspace.Archive.Items; // Clear the directory contents list view this.filesListView.Items.Clear(); this.filesListItems.Clear(); this.Directory = dir; if (dir == null) { // Display contents of root itemsInDir = items.EnumerateRootItems(); // This is the root of the archive this.pathLabel.Text = @"\"; } else { if (dir.Type != NefsItemType.Directory) { // TODO : FIX MessageBox.Show("TODO: Log this --- can't browse a file."); } // Display contents of specified directory itemsInDir = items.EnumerateItemChildren(dir.Id); this.pathLabel.Text = @"\" + items.GetItemFilePath(dir.Id); } // Load all items in the NeFS archive into the listview foreach (var item in itemsInDir) { var listItem = new ListViewItem(); // The list item is actually the first column listItem.Text = item.Id.Value.ToString("X"); // Save a reference to the item object listItem.Tag = item; this.AddSubItem(listItem, "filename", item.FileName); if (item.Type == NefsItemType.File) { this.AddSubItem(listItem, "compressedSize", item.CompressedSize.ToString("X")); this.AddSubItem(listItem, "extractedSize", item.ExtractedSize.ToString("X")); } if (item.Type == NefsItemType.Directory) { listItem.BackColor = Color.LightBlue; } this.filesListItems.Add(item, listItem); this.filesListView.Items.Add(listItem); } }
public void NefsHeaderPart1_MultipleItems_EntriesPopulated() { var items = new NefsItemList(@"C:\archive.nefs"); var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> { 11, 12, 13 })); var file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData()); items.Add(file1); var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> { 14, 15, 16 })); var file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData()); items.Add(file2); var dir1DataSource = new NefsEmptyDataSource(); var dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData()); items.Add(dir1); var p4 = new NefsHeaderPart4(items); var p1 = new NefsHeaderPart1(items, p4); Assert.Equal(3, p1.EntriesById.Count); /* * dir1 */ // Offset to data and index to p4 are both 0 since this is a directory Assert.Equal(2, (int)p1.EntriesById[dir1.Id].Id.Value); Assert.Equal(0, (int)p1.EntriesById[dir1.Id].OffsetToData); Assert.Equal(0, (int)p1.EntriesById[dir1.Id].MetadataIndex); Assert.Equal(0, (int)p1.EntriesById[dir1.Id].IndexIntoPart4); /* * file1 */ Assert.Equal(0, (int)p1.EntriesById[file1.Id].Id.Value); Assert.Equal(123, (int)p1.EntriesById[file1.Id].OffsetToData); Assert.Equal(1, (int)p1.EntriesById[file1.Id].MetadataIndex); Assert.Equal(0, (int)p1.EntriesById[file1.Id].IndexIntoPart4); /* * file2 */ Assert.Equal(1, (int)p1.EntriesById[file2.Id].Id.Value); Assert.Equal(456, (int)p1.EntriesById[file2.Id].OffsetToData); Assert.Equal(2, (int)p1.EntriesById[file2.Id].MetadataIndex); // There are 3 chunks for file1, so file2's chunks start right after that (hence p4 // index == 3) Assert.Equal(3, (int)p1.EntriesById[file2.Id].IndexIntoPart4); }
/// <summary> /// Initializes a new instance of the <see cref="ReplaceFileCommand"/> class. /// </summary> /// <param name="item">The item to replace.</param> /// <param name="newDataSource">The new data source.</param> public ReplaceFileCommand(NefsItem item, INefsDataSource newDataSource) { this.Item = item; this.OldDataSource = item.DataSource; this.OldState = item.State; this.NewDataSource = newDataSource; this.NewState = NefsItemState.Replaced; }
/// <summary> /// Initializes a new instance of the <see cref="RemoveFileCommand"/> class. /// </summary> /// <param name="item">The item to remove.</param> /// <param name="oldState">The old item state.</param> public RemoveFileCommand( NefsItem item, NefsItemState oldState) { this.Item = item ?? throw new ArgumentNullException(nameof(item)); this.OldState = oldState; this.NewState = NefsItemState.Removed; }
private string GetDebugInfoVersion16(NefsItem item, Nefs16Header h, NefsItemList items) { var p1 = h.Part1.EntriesByGuid[item.Guid]; var p2 = h.Part2.EntriesByIndex[(int)p1.IndexPart2]; var p6 = h.Part6.EntriesByGuid[item.Guid]; var p7 = h.Part7.EntriesByIndex[(int)p1.IndexPart2]; var numChunks = h.TableOfContents.ComputeNumChunks(p2.ExtractedSize); var chunkSize = h.TableOfContents.BlockSize; var attributes = p6.CreateAttributes(); return($@"Item Info ----------------------------------------------------------- Item name: {item.FileName} Item path: {items.GetItemFilePath(item.Id)} Part 1 ----------------------------------------------------------- Offset to data: {p1.OffsetToData.ToString("X")} Index in part 2: {p1.IndexPart2.ToString("X")} Index in part 4: {p1.IndexPart4.ToString("X")} Id: {p1.Id.Value.ToString("X")} Part 2 ----------------------------------------------------------- Directory id: {p2.DirectoryId.Value.ToString("X")} First child id: {p2.FirstChildId.Value.ToString("X")} Offset in part 3: {p2.OffsetIntoPart3.ToString("X")} Extracted size: {p2.ExtractedSize.ToString("X")} Id: {p2.Id.Value.ToString("X")} Part 4 ----------------------------------------------------------- Chunks {this.PrintChunkSizesToString(h.Part4.CreateChunksList(p1.IndexPart4, numChunks, chunkSize, h.Intro.GetAesKey()))} Part 6 ----------------------------------------------------------- 0x00: {p6.Volume.ToString("X")} 0x02: {((byte)p6.Flags).ToString("X")} 0x03: {p6.Unknown0x3.ToString("X")} IsTransformed: {attributes.V16IsTransformed} IsDirectory: {attributes.IsDirectory} IsDuplicated: {attributes.IsDuplicated} IsCacheable: {attributes.IsCacheable} Unknown 0x10: {attributes.V16Unknown0x10} IsPatched: {attributes.IsPatched} Unknown 0x40: {attributes.V16Unknown0x40} Unknown 0x80: {attributes.V16Unknown0x80} Part 7 ----------------------------------------------------------- Sibling id: {p7.SiblingId.Value.ToString("X")} Item id: {p7.Id.Value.ToString("X")} "); }
/// <summary> /// Initializes a new instance of the <see cref="ReplaceFileCommand"/> class. /// </summary> /// <param name="item">The item to perform the command on.</param> /// <param name="oldDataSource">The old data source.</param> /// <param name="oldState">The old state.</param> /// <param name="newDataSource">The new data source.</param> public ReplaceFileCommand( NefsItem item, INefsDataSource oldDataSource, NefsItemState oldState, INefsDataSource newDataSource) { this.Item = item ?? throw new ArgumentNullException(nameof(item)); this.OldDataSource = oldDataSource ?? throw new ArgumentNullException(nameof(oldDataSource)); this.OldState = oldState; this.NewDataSource = newDataSource ?? throw new ArgumentNullException(nameof(newDataSource)); this.NewState = NefsItemState.Replaced; }
private void PrintDebugInfo(NefsItem item, NefsArchive archive) { this.richTextBox.Text = ""; if (item == null || archive == null) { return; } var p1 = archive.Header.Part1.EntriesById.GetValueOrDefault(item.Id); var p2 = archive.Header.Part2.EntriesById.GetValueOrDefault(item.Id); var p6 = archive.Header.Part6.EntriesById.GetValueOrDefault(item.Id); var p7 = archive.Header.Part7.EntriesById.GetValueOrDefault(item.Id); this.richTextBox.Text = $@"Item Info ----------------------------------------------------------- Item name: {item.FileName} Item path: {archive.Items.GetItemFilePath(item.Id)} Part 1 ----------------------------------------------------------- Offset to data: {p1?.OffsetToData.ToString("X")} Index in part 2: {p1?.MetadataIndex.ToString("X")} Index in part 4: {p1?.IndexIntoPart4.ToString("X")} Id: {p1?.Id.Value.ToString("X")} Part 2 ----------------------------------------------------------- Directory id: {p2?.DirectoryId.Value.ToString("X")} First child id: {p2?.FirstChildId.Value.ToString("X")} Offset in part 3: {p2?.OffsetIntoPart3.ToString("X")} Extracted size: {p2?.ExtractedSize.ToString("X")} Id: {p2?.Id.Value.ToString("X")} Part 4 ----------------------------------------------------------- Chunks {this.PrintChunkSizesToString(archive.Header.Part4.GetChunkSizesForItem(item))} Part 6 ----------------------------------------------------------- 0x00: {p6?.Byte0.ToString("X")} 0x01: {p6?.Byte1.ToString("X")} 0x02: {p6?.Byte2.ToString("X")} 0x03: {p6?.Byte3.ToString("X")} Part 7 ----------------------------------------------------------- Sibling id: {p7?.SiblingId.Value.ToString("X")} Item id: {p7?.Id.Value.ToString("X")} "; }
/// <summary> /// Prepares an item's data to be written to the archive. /// </summary> /// <param name="item">The item to prepare.</param> /// <param name="workDir">The temporary working directory.</param> /// <param name="items">The source items list.</param> /// <param name="p">Progress info.</param> private async Task PrepareItemAsync(NefsItem item, string workDir, NefsItemList items, NefsProgress p) { // Deleted items should not be prepared if (item.State == NefsItemState.Removed) { throw new ArgumentException("Trying to prepare a removed item.", nameof(item)); } // Nothing to do for directories if (item.Type == NefsItemType.Directory) { return; } // Only added or replaced files need prepared if (item.State != NefsItemState.Added && item.State != NefsItemState.Replaced) { return; } // Item should have a data source if (item.DataSource == null) { throw new ArgumentException("Item does not have a data source.", nameof(item)); } // Make sure the new file still exists if (!this.FileSystem.File.Exists(item.DataSource.FilePath)) { throw new IOException($"Cannot find source file {item.DataSource.FilePath}."); } // Compress to temp location if needed if (!item.DataSource.IsTransformed) { // Prepare the working directory var filePathInArchive = items.GetItemFilePath(item.Id); var filePathInArchiveHash = HashHelper.HashStringMD5(filePathInArchive); var fileWorkDir = Path.Combine(workDir, filePathInArchiveHash); this.FileSystem.ResetOrCreateDirectory(fileWorkDir); // Transform the file var destFilePath = Path.Combine(workDir, "inject.dat"); var newSize = await this.Transformer.TransformFileAsync(item.DataSource, destFilePath, item.Transform, p); // Update data source to point to the transformed temp file var dataSource = new NefsFileDataSource(destFilePath, 0, newSize, isTransformed: true); item.UpdateDataSource(dataSource, NefsItemState.Replaced); } }
public void NefsHeaderPart3_MultipleItems_EntriesPopulated() { var items = new NefsItemList(@"C:\archive.nefs"); var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> { 11, 12, 13 })); var file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData()); items.Add(file1); var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> { 14, 15, 16 })); var file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData()); items.Add(file2); var dir1DataSource = new NefsEmptyDataSource(); var dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData()); items.Add(dir1); var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, new List <UInt32> { 22, 23, 24 })); var file3 = new NefsItem(new NefsItemId(3), "file3", dir1.Id, NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData()); items.Add(file3); var p3 = new NefsHeaderPart3(items); Assert.Equal(5, p3.OffsetsByFileName.Count); Assert.Equal(5, p3.FileNamesByOffset.Count); // Four file names plus a null terminal for each. Assert.Equal(36, (int)p3.Size); // Strings table is sorted alphabetically - and also contains data file name Assert.Equal("archive.nefs", p3.FileNamesByOffset[0]); Assert.Equal("dir1", p3.FileNamesByOffset[13]); Assert.Equal("file1", p3.FileNamesByOffset[18]); Assert.Equal("file2", p3.FileNamesByOffset[24]); Assert.Equal("file3", p3.FileNamesByOffset[30]); Assert.Equal(18, (int)p3.OffsetsByFileName[file1.FileName]); Assert.Equal(24, (int)p3.OffsetsByFileName[file2.FileName]); Assert.Equal(13, (int)p3.OffsetsByFileName[dir1.FileName]); Assert.Equal(30, (int)p3.OffsetsByFileName[file3.FileName]); }
/// <inheritdoc/> public UInt32 GetIndexForItem(NefsItem item) { // Get index to part 4 if (item.Type == NefsItemType.Directory) { // Item is a directory; the index 0 return(0); } else { // Get index into part 4 return(this.indexLookup[item.Guid]); } }
/// <summary> /// Replaces the selected item with a new item. /// </summary> /// <param name="item">The item to replace.</param> public async void ReplaceItem(NefsItem item) { if (item == null) { MessageBox.Show("No item selected to replace."); return; } /* * Open an open file dialog and get file to inject */ var ofd = new OpenFileDialog(); ofd.Multiselect = false; var result = ofd.ShowDialog(); if (result == DialogResult.OK) { /* Create a progress dialog form */ var progressDialog = new ProgressDialogForm(); /* Show the progress dialog asnyc */ var progressDialogTask = progressDialog.ShowDialogAsync(); /* Replace the item */ await Task.Run(() => { try { log.Info("----------------------------"); log.Info(String.Format("Replacing {0} with {1}...", item.Filename, ofd.FileName)); item.Inject(ofd.FileName, progressDialog.ProgressInfo); log.Info("Item successfully replaced with: " + ofd.FileName); } catch (Exception ex) { log.Error("Error replacing file.", ex); } }); /* Post-replace activites */ updateTitle(); /* Close the progress dialog */ progressDialog.Close(); } }
/// <summary> /// Creates a test archive. Does not write an archive to disk. Just creates a <see /// cref="NefsArchive"/> object. /// </summary> /// <param name="filePath">The file path to use for the archive.</param> /// <returns>A <see cref="NefsArchive"/>.</returns> public static NefsArchive Create(string filePath) { var items = new NefsItemList(filePath); var aesString = "44927647059D3D73CDCC8D4C6E808538CAD7622D076A507E16C43A8DD8E3B5AB"; var file1Attributes = new NefsItemAttributes(v20IsZlib: true); var file1Chunks = NefsDataChunk.CreateChunkList(File1ChunkSizes, TestHelpers.TestTransform); var file1DataSource = new NefsItemListDataSource(items, File1Offset, new NefsItemSize(File1ExtractedSize, file1Chunks)); var file1 = new NefsItem(File1Guid, new NefsItemId(File1ItemId), File1Name, new NefsItemId(File1DirectoryId), file1DataSource, TestHelpers.TestTransform, file1Attributes); items.Add(file1); var dir1Attributes = new NefsItemAttributes(isDirectory: true); var dir1DataSource = new NefsEmptyDataSource(); var dir1 = new NefsItem(Dir1Guid, new NefsItemId(Dir1ItemId), Dir1Name, new NefsItemId(Dir1DirectoryId), dir1DataSource, null, dir1Attributes); items.Add(dir1); var file2Attributes = new NefsItemAttributes(v20IsZlib: true); var file2Chunks = NefsDataChunk.CreateChunkList(File2ChunkSizes, TestHelpers.TestTransform); var file2DataSource = new NefsItemListDataSource(items, File2Offset, new NefsItemSize(File2ExtractedSize, file2Chunks)); var file2 = new NefsItem(File2Guid, new NefsItemId(File2ItemId), File2Name, new NefsItemId(File2DirectoryId), file2DataSource, TestHelpers.TestTransform, file2Attributes); items.Add(file2); var file3Attributes = new NefsItemAttributes(v20IsZlib: true); var file3Transform = new NefsDataTransform(File3ExtractedSize); var file3Chunks = NefsDataChunk.CreateChunkList(File3ChunkSizes, file3Transform); var file3DataSource = new NefsItemListDataSource(items, File3Offset, new NefsItemSize(File3ExtractedSize, file3Chunks)); var file3 = new NefsItem(File3Guid, new NefsItemId(File3ItemId), File3Name, new NefsItemId(File3DirectoryId), file3DataSource, file3Transform, file3Attributes); items.Add(file3); Assert.Equal((int)NumItems, items.Count); var intro = new NefsHeaderIntro(); intro.Data0x6c_NumberOfItems.Value = (uint)items.Count; intro.Data0x24_AesKeyHexString.Value = Encoding.ASCII.GetBytes(aesString); var toc = new Nefs20HeaderIntroToc(); var header = new Nefs20Header(intro, toc, items); return(new NefsArchive(header, items)); }
/// <summary> /// Gets the index into part 4 for the specified item. The index into part 4 is potentially /// different from the item's id. /// </summary> /// <param name="item">The item to get the index for.</param> /// <returns>The index into part 4.</returns> public UInt32 GetIndexForItem(NefsItem item) { // Get index to part 4 if (item.Type == NefsItemType.Directory) { // Item is a directory; the index 0 return(0); } else if (item.ExtractedSize == item.CompressedSize) { // Item is uncompressed; the index is -1 (0xFFFFFFFF) return(0xFFFFFFFF); } else { // Item is compressed; get index into part 4 return(this.indexById[item.Id]); } }
/// <summary> /// Creates a test archive. Does not write an archive to disk. Just creates a <see /// cref="NefsArchive"/> object. /// </summary> /// <param name="filePath">The file path to use for the archive.</param> /// <returns>A <see cref="NefsArchive"/>.</returns> public static NefsArchive Create(string filePath) { var items = new NefsItemList(filePath); var file1Attributes = new NefsItemAttributes(v20IsZlib: true); var file1Chunks = NefsDataChunk.CreateChunkList(File1ChunkSizes, TestHelpers.TestTransform); var file1DataSource = new NefsItemListDataSource(items, File1Offset, new NefsItemSize(File1ExtractedSize, file1Chunks)); var file1 = new NefsItem(File1Guid, new NefsItemId(File1ItemId), File1Name, new NefsItemId(File1DirectoryId), file1DataSource, TestHelpers.TestTransform, file1Attributes); items.Add(file1); var dir1Attributes = new NefsItemAttributes(isDirectory: true); var dir1DataSource = new NefsEmptyDataSource(); var dir1 = new NefsItem(Dir1Guid, new NefsItemId(Dir1ItemId), Dir1Name, new NefsItemId(Dir1DirectoryId), dir1DataSource, null, dir1Attributes); items.Add(dir1); var file2Attributes = new NefsItemAttributes(v20IsZlib: true); var file2Chunks = NefsDataChunk.CreateChunkList(File2ChunkSizes, TestHelpers.TestTransform); var file2DataSource = new NefsItemListDataSource(items, File2Offset, new NefsItemSize(File2ExtractedSize, file2Chunks)); var file2 = new NefsItem(File2Guid, new NefsItemId(File2ItemId), File2Name, new NefsItemId(File2DirectoryId), file2DataSource, TestHelpers.TestTransform, file2Attributes); items.Add(file2); var file3Attributes = new NefsItemAttributes(v20IsZlib: true); var file3Chunks = NefsDataChunk.CreateChunkList(File3ChunkSizes, TestHelpers.TestTransform); var file3DataSource = new NefsItemListDataSource(items, File3Offset, new NefsItemSize(File3ExtractedSize, file3Chunks)); var file3 = new NefsItem(File3Guid, new NefsItemId(File3ItemId), File3Name, new NefsItemId(File3DirectoryId), file3DataSource, TestHelpers.TestTransform, file3Attributes); items.Add(file3); Assert.Equal((int)NumItems, items.Count); var intro = new NefsHeaderIntro(); intro.Data0x6c_NumberOfItems.Value = (uint)items.Count; var toc = new Nefs20HeaderIntroToc(); var header = new Nefs20Header(intro, toc, items); return(new NefsArchive(header, items)); }
/// <summary> /// Gets a copy of the chunk sizes list for an item. /// </summary> /// <param name="item">The item to get chunk sizes for.</param> /// <returns>The list of chunk sizes.</returns> public List <UInt32> GetChunkSizesForItem(NefsItem item) { if (item.Type == NefsItemType.Directory) { // Item is a directory; no chunk sizes return(new List <UInt32>()); } else if (item.ExtractedSize == item.CompressedSize) { // Item is uncompressed; no chunk sizes return(new List <UInt32>()); } else { // Item is compressed; get chunk sizes var idx = this.indexById[item.Id]; // Use ToList() to create a copy of the list return(this.entriesByIndex[idx].ChunkSizes.ToList()); } }
private void PrintDebugInfo(NefsItem item, NefsArchive archive) { this.richTextBox.Text = ""; if (item == null || archive == null) { return; } if (archive.Header is Nefs20Header h20) { this.richTextBox.Text = this.GetDebugInfoVersion20(item, h20, archive.Items); } else if (archive.Header is Nefs16Header h16) { this.richTextBox.Text = this.GetDebugInfoVersion16(item, h16, archive.Items); } else { this.richTextBox.Text = "Unknown header version."; } }
public void Nefs20HeaderFlags_FlagsSet() { var items = new NefsItemList(@"C:\archive.nefs"); var item1Attributes = new NefsItemAttributes( v20IsZlib: true, v20IsAes: true, isDirectory: true, isDuplicated: true, v20Unknown0x10: true, v20Unknown0x20: true, v20Unknown0x40: true, v20Unknown0x80: true); var item1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456)); var item1 = new NefsItem(Guid.NewGuid(), new NefsItemId(0), "file1", new NefsItemId(0), item1DataSource, TestHelpers.TestTransform, item1Attributes); items.Add(item1); var p6 = new Nefs20HeaderPart6(items); Assert.Equal(0xFF, (byte)p6.EntriesByIndex[0].Flags); }
public NefsHeaderPart4Tests() { var items = new NefsItemList(@"C:\archive.nefs"); var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> { 1, 11, 21 }, TestHelpers.TestTransform); var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, file1Chunks)); this.file1 = TestHelpers.CreateFile(0, 0, "file1", file1DataSource); items.Add(this.file1); var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> { 2, 22, 52 }, TestHelpers.TestTransform); var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, file2Chunks)); this.file2 = TestHelpers.CreateFile(1, 1, "file2", file2DataSource); items.Add(this.file2); this.dir1 = TestHelpers.CreateDirectory(2, 2, "dir1"); items.Add(this.dir1); var file3Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> { 3, 13, 23 }, TestHelpers.TestTransform); var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, file3Chunks)); this.file3 = TestHelpers.CreateFile(3, this.dir1.Id.Value, "file3", file3DataSource); items.Add(this.file3); var file4DataSource = new NefsItemListDataSource(items, 777, new NefsItemSize(444)); this.file4NotCompressed = TestHelpers.CreateFile(4, this.dir1.Id.Value, "file4", file4DataSource); items.Add(this.file4NotCompressed); this.testItems = items; }
public void Clone_ItemCloned() { var nefs = TestArchiveNotModified.Create(@"C:\archive.nefs"); var itemId = new NefsItemId(TestArchiveNotModified.File3ItemId); var item = NefsItem.CreateFromHeader(itemId, nefs.Header, nefs.Items); item.UpdateState(NefsItemState.Replaced); var clone = item.Clone() as NefsItem; Assert.Equal(item.CompressedSize, clone.CompressedSize); Assert.Same(item.DataSource, clone.DataSource); Assert.Equal(item.DirectoryId, clone.DirectoryId); Assert.Equal(item.ExtractedSize, clone.ExtractedSize); Assert.Equal(item.FileName, clone.FileName); Assert.Equal(item.Id, clone.Id); Assert.Equal(item.Part6Unknown0x00, clone.Part6Unknown0x00); Assert.Equal(item.Part6Unknown0x01, clone.Part6Unknown0x01); Assert.Equal(item.Part6Unknown0x02, clone.Part6Unknown0x02); Assert.Equal(item.Part6Unknown0x03, clone.Part6Unknown0x03); Assert.Equal(item.State, clone.State); Assert.Equal(item.Type, clone.Type); }
private NefsItemList CreateItems(string dataFilePath, NefsHeader h) { var items = new NefsItemList(dataFilePath); var numItems = h.TableOfContents.Part1Size / NefsHeaderPart1Entry.Size; for (var i = 0; i < numItems; ++i) { // Create the item var id = new NefsItemId((uint)i); try { var item = NefsItem.CreateFromHeader(id, h, items); items.Add(item); } catch (Exception) { Log.LogError($"Failed to create item {id}, skipping."); } } return(items); }
public NefsHeaderPart4Tests() { var items = new NefsItemList(@"C:\archive.nefs"); var file1DataSource = new NefsItemListDataSource(items, 123, new NefsItemSize(456, new List <UInt32> { 1, 11, 21 })); this.file1 = new NefsItem(new NefsItemId(0), "file1", new NefsItemId(0), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData()); items.Add(this.file1); var file2DataSource = new NefsItemListDataSource(items, 456, new NefsItemSize(789, new List <UInt32> { 2, 22, 52 })); this.file2 = new NefsItem(new NefsItemId(1), "file2", new NefsItemId(1), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData()); items.Add(this.file2); var dir1DataSource = new NefsEmptyDataSource(); this.dir1 = new NefsItem(new NefsItemId(2), "dir1", new NefsItemId(2), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData()); items.Add(this.dir1); var file3DataSource = new NefsItemListDataSource(items, 222, new NefsItemSize(333, new List <UInt32> { 3, 13, 23 })); this.file3 = new NefsItem(new NefsItemId(3), "file3", this.dir1.Id, NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData()); items.Add(this.file3); var file4DataSource = new NefsItemListDataSource(items, 777, new NefsItemSize(444)); this.file4NotCompressed = new NefsItem(new NefsItemId(4), "file4", this.dir1.Id, NefsItemType.File, file4DataSource, TestHelpers.CreateUnknownData()); items.Add(this.file4NotCompressed); this.testItems = items; }
/// <summary> /// Creates a <see cref="NefsArchive"/> to be used for testing. /// </summary> /// <param name="filePath">The file path to associate with the archive.</param> /// <returns>An archive object.</returns> /// <remarks><![CDATA[ Test archive items: /file1 /dir1 /dir1/file2 ]]></remarks> internal static NefsArchive CreateTestArchive(string filePath) { var items = new NefsItemList(filePath); var transform = new NefsDataTransform(50, true); var file1Attributes = new NefsItemAttributes(v20IsZlib: true); var file1Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> { 2, 3, 4 }, transform); var file1DataSource = new NefsItemListDataSource(items, 100, new NefsItemSize(20, file1Chunks)); var file1 = new NefsItem(Guid.NewGuid(), new NefsItemId(0), "file1", new NefsItemId(0), file1DataSource, transform, file1Attributes); items.Add(file1); var dir1Attributes = new NefsItemAttributes(isDirectory: true); var dir1DataSource = new NefsEmptyDataSource(); var dir1 = new NefsItem(Guid.NewGuid(), new NefsItemId(1), "dir1", new NefsItemId(1), dir1DataSource, null, dir1Attributes); items.Add(dir1); var file2Attributes = new NefsItemAttributes(v20IsZlib: true); var file2Chunks = NefsDataChunk.CreateChunkList(new List <UInt32> { 5, 6, 7 }, transform); var file2DataSource = new NefsItemListDataSource(items, 104, new NefsItemSize(15, file2Chunks)); var file2 = new NefsItem(Guid.NewGuid(), new NefsItemId(2), "file2", dir1.Id, file2DataSource, transform, file2Attributes); items.Add(file2); var intro = new NefsHeaderIntro(); var toc = new Nefs20HeaderIntroToc(); var header = new Nefs20Header(intro, toc, items); return(new NefsArchive(header, items)); }
/// <summary> /// Creates a test archive. Does not write an archive to disk. Just creates a <see /// cref="NefsArchive"/> object. /// </summary> /// <param name="filePath">The file path to use for the archive.</param> /// <returns>A <see cref="NefsArchive"/>.</returns> public static NefsArchive Create(string filePath) { var items = new NefsItemList(filePath); var file1DataSource = new NefsItemListDataSource(items, File1Offset, new NefsItemSize(File1ExtractedSize, File1ChunkSizes)); var file1 = new NefsItem(new NefsItemId(File1ItemId), File1Name, new NefsItemId(File1DirectoryId), NefsItemType.File, file1DataSource, TestHelpers.CreateUnknownData()); items.Add(file1); var dir1DataSource = new NefsEmptyDataSource(); var dir1 = new NefsItem(new NefsItemId(Dir1ItemId), Dir1Name, new NefsItemId(Dir1DirectoryId), NefsItemType.Directory, dir1DataSource, TestHelpers.CreateUnknownData()); items.Add(dir1); var file2DataSource = new NefsItemListDataSource(items, File2Offset, new NefsItemSize(File2ExtractedSize, File2ChunkSizes)); var file2 = new NefsItem(new NefsItemId(File2ItemId), File2Name, new NefsItemId(File2DirectoryId), NefsItemType.File, file2DataSource, TestHelpers.CreateUnknownData()); items.Add(file2); var file3DataSource = new NefsItemListDataSource(items, File3Offset, new NefsItemSize(File3ExtractedSize, File3ChunkSizes)); var file3 = new NefsItem(new NefsItemId(File3ItemId), File3Name, new NefsItemId(File3DirectoryId), NefsItemType.File, file3DataSource, TestHelpers.CreateUnknownData()); items.Add(file3); Assert.Equal((int)NumItems, items.Count); var intro = new NefsHeaderIntro(); intro.Data0x6c_NumberOfItems.Value = (uint)items.Count; var toc = new NefsHeaderIntroToc(); var header = new NefsHeader(intro, toc, items); return(new NefsArchive(header, items)); }
/// <summary> /// Updates the data in this header entry for the specified item. /// </summary> /// <param name="item">The item this entry belongs to.</param> public void Update(NefsItem item) { off_0x00_directory_id.Value = item.DirectoryId; off_0x0c_extracted_size.Value = item.ExtractedSize; off_0x10_index.Value = item.Id; }
// Use null for root directory public void OpenDirectory(NefsItem dir) { List <NefsItem> itemsInDir; _dir = dir; if (dir == null) { /* Display contents of root */ itemsInDir = (from item in _archive.Items where item.Id == item.DirectoryId select item).ToList(); /* Clear the directory contents list view */ filesListView.Items.Clear(); /* This is the root of the archive */ pathLabel.Text = @"\"; } else { if (dir.Type != NefsItem.NefsItemType.Directory) { // TODO : FIX MessageBox.Show("TODO: Log this --- can't browse a file."); } /* Display contents of specified directory */ itemsInDir = (from item in _archive.Items where item.DirectoryId == dir.Id && item.DirectoryId != item.Id select item).ToList(); pathLabel.Text = @"\" + dir.FilePathInArchive; } /* Clear the directory contents list view */ filesListView.Items.Clear(); // Load all items in the NeFS archive into the listview foreach (var item in itemsInDir) { var listItem = new ListViewItem(); // The list item is actually the first column listItem.Text = item.Id.ToString("X"); // Save a reference to the item object listItem.Tag = item; addSubItem(listItem, "filename", item.Filename); if (item.Type == NefsItem.NefsItemType.File) { addSubItem(listItem, "compressedSize", item.CompressedSize.ToString("X")); addSubItem(listItem, "extractedSize", item.ExtractedSize.ToString("X")); } if (item.Type == NefsItem.NefsItemType.Directory) { listItem.BackColor = Color.LightBlue; } filesListView.Items.Add(listItem); } }