/// <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);
}
}
