public static async Task <RomFs> Load(IBinaryDataAccessor data)
{
var header = new RomFsHeader(await data.ReadArrayAsync(0, 0x6B));
var romfs = new RomFs(data, header);
await romfs.Initialize();
return(romfs);
}
public NcchPartition(RomFs romfs = null, ExeFs exefs = null, NcchHeader header = null, NcchExtendedHeader exheader = null, string plainRegion = null, byte[] logo = null)
{
RomFs = romfs;
ExeFs = exefs;
Header = header;
ExHeader = exheader;
PlainRegion = plainRegion;
Logo = logo;
}
public async Task Initialize(IReadOnlyBinaryDataAccessor data)
{
if (Header != null && Header.RomFsSize > 0)
{
if (Header.ExeFsOffset > 0 && Header.ExeFsSize > 0)
{
ExeFs = await ExeFs.Load(data.GetReadOnlyDataReference((long)Header.ExeFsOffset *MediaUnitSize, (long)Header.ExeFsSize *MediaUnitSize));
}
if (Header.RomFsOffset > 0 && Header.RomFsOffset > 0)
{
RomFs = await RomFs.Load(data.GetReadOnlyDataReference((long)Header.RomFsOffset *MediaUnitSize, (long)Header.RomFsSize *MediaUnitSize));
}
if (Header.ExHeaderSize > 0)
{
ExHeader = data.GetReadOnlyDataReference(0x200, Header.ExHeaderSize);
}
}
}
public async Task Initialize(IReadOnlyBinaryDataAccessor data)
{
this.RawData = data;
if (Header != null && Header.RomFsSize > 0)
{
if (Header.ExeFsOffset > 0 && Header.ExeFsSize > 0)
{
ExeFs = await ExeFs.Load(data.Slice((long)Header.ExeFsOffset *MediaUnitSize, (long)Header.ExeFsSize *MediaUnitSize));
}
if (Header.RomFsOffset > 0 && Header.RomFsOffset > 0)
{
RomFs = await RomFs.Load(data.Slice((long)Header.RomFsOffset *MediaUnitSize, (long)Header.RomFsSize *MediaUnitSize));
}
if (Header.ExHeaderSize > 0)
{
ExHeader = await NcchExtendedHeader.Load(data.Slice(0x200, Header.ExHeaderSize));
}
PlainRegion = await data.ReadStringAsync(Header.PlainRegionOffset *MediaUnitSize, Header.PlainRegionSize *MediaUnitSize, Encoding.ASCII);
Logo = await data.ReadArrayAsync(Header.LogoRegionOffset *MediaUnitSize, Header.LogoRegionSize *MediaUnitSize);
}
}
/// <summary>
/// Builds a new NCCH partition from the given directory
/// </summary>
/// <param name="fileSystem">File system from which to load the files</param>
/// <returns>A newly built NCCH partition</returns>
public static async Task <NcchPartition> Build(string headerFilename, string exHeaderFilename, string?exeFsDirectory, string?romFsDiretory, string?plainRegionFilename, string?logoFilename, IFileSystem fileSystem, ProcessingProgressedToken?progressToken = null)
{
ProcessingProgressedToken?exefsToken = null;
ProcessingProgressedToken?romfsToken = null;
void ReportProgress()
{
if (progressToken != null)
{
progressToken.TotalFileCount = (exefsToken?.TotalFileCount + romfsToken?.TotalFileCount).GetValueOrDefault();
progressToken.ProcessedFileCount = (exefsToken?.ProcessedFileCount + romfsToken?.ProcessedFileCount).GetValueOrDefault();
}
};
Task <ExeFs?> exeFsTask;
if (!string.IsNullOrEmpty(exeFsDirectory))
{
if (progressToken != null)
{
exefsToken = new ProcessingProgressedToken();
exefsToken.FileCountChanged += (sender, e) => ReportProgress();
}
exeFsTask = Task.Run <ExeFs?>(async() => await ExeFs.Build(exeFsDirectory, fileSystem, exefsToken).ConfigureAwait(false));
}
else
{
exeFsTask = Task.FromResult <ExeFs?>(null);
}
Task <RomFs?> romFsTask;
if (!string.IsNullOrEmpty(romFsDiretory))
{
if (progressToken != null)
{
romfsToken = new ProcessingProgressedToken();
romfsToken.FileCountChanged += (sender, e) => ReportProgress();
}
romFsTask = Task.Run <RomFs?>(async() => await RomFs.Build(romFsDiretory, fileSystem, romfsToken).ConfigureAwait(false));
}
else
{
romFsTask = Task.FromResult <RomFs?>(null);
}
var header = new NcchHeader(fileSystem.ReadAllBytes(headerFilename));
NcchExtendedHeader?exHeader = null;
if (!string.IsNullOrEmpty(exHeaderFilename))
{
using var exHeaderData = new BinaryFile(fileSystem.ReadAllBytes(exHeaderFilename));
exHeader = await NcchExtendedHeader.Load(exHeaderData);
}
string?plainRegion = null;
if (!string.IsNullOrEmpty(plainRegionFilename))
{
plainRegion = fileSystem.ReadAllText(plainRegionFilename);
}
byte[]? logo = null;
if (!string.IsNullOrEmpty(logoFilename))
{
logo = fileSystem.ReadAllBytes(logoFilename);
}
return(new NcchPartition(await romFsTask, await exeFsTask, header, exHeader, plainRegion, logo));
}
public void Dispose()
{
RomFs?.Dispose();
}
/// <summary>
/// Writes the current state of the NCCH partition to the given binary data accessor
/// </summary>
/// <param name="data">Data accessor to receive the binary data</param>
/// <returns>A long representing the total length of data written</returns>
public async Task <long> WriteBinary(IWriteOnlyBinaryDataAccessor data)
{
// Get the data
var exheader = ExHeader?.ToByteArray();
var plainRegion = !string.IsNullOrEmpty(PlainRegion) ? Encoding.ASCII.GetBytes(PlainRegion) : null;
var plainRegionOffset = 0;
var logoRegionOffset = 0;
var exeFs = ExeFs?.ToByteArray();
var exeFsOffset = 0;
var romFs = RomFs?.Data;
var romFsOffset = 0;
// Write the data
var offset = 0x200; // Skip the header, write it last
if (exheader != null)
{
await data.WriteAsync(offset, exheader);
offset += exheader.Length;
}
if (plainRegion != null)
{
plainRegionOffset = offset;
await data.WriteAsync(offset, plainRegion);
offset += plainRegion.Length;
var padding = new byte[0x200 - plainRegion.Length % 0x200];
await data.WriteAsync(offset, padding);
offset += padding.Length;
}
if (Logo != null)
{
logoRegionOffset = offset;
await data.WriteAsync(offset, Logo);
offset += Logo.Length;
var padding = new byte[0x200 - Logo.Length % 0x200];
await data.WriteAsync(offset, padding);
offset += padding.Length;
}
if (exeFs != null)
{
exeFsOffset = offset;
await data.WriteAsync(offset, exeFs);
offset += exeFs.Length;
var padding = new byte[0x200 - exeFs.Length % 0x200];
await data.WriteAsync(offset, padding);
offset += padding.Length;
}
if (romFs != null)
{
romFsOffset = offset;
const int bufferSize = 1024 * 1024;
for (int i = 0; i < romFs.Length; i += bufferSize)
{
int length = (int)Math.Min(bufferSize, romFs.Length - i);
var block = await romFs.ReadArrayAsync(i, length);
await data.WriteAsync(offset, block);
offset += length;
}
var padding = new byte[0x200 - romFs.Length % 0x200];
await data.WriteAsync(offset, padding);
offset += padding.Length;
}
// Create a new header
using var sha = SHA256.Create();
var header = NcchHeader.Copy(this.Header);
header.Signature = new byte[0x100]; // We lack the 3DS's private key, so leave out the signature
header.ContentSize = (offset + MediaUnitSize - 1) / MediaUnitSize; // offset/MediaUnitSize, but rounding up
header.ContentLockSeedHash = 0; // Unknown, left blank by SciresM's 3DS Builder
if (Logo != null)
{
header.LogoRegionHash = sha.ComputeHash(Logo);
}
else
{
header.LogoRegionHash = new byte[0x20];
}
if (exheader != null)
{
header.ExHeaderHash = NcchExtendedHeader.GetSuperblockHash(sha, exheader);
header.ExHeaderSize = NcchExtendedHeader.ExHeaderDataSize;
}
else
{
header.ExHeaderHash = new byte[0x20];
header.ExHeaderSize = 0;
}
header.PlainRegionOffset = (plainRegionOffset + MediaUnitSize - 1) / MediaUnitSize;
header.PlainRegionSize = ((plainRegion?.Length ?? 0) + MediaUnitSize - 1) / MediaUnitSize;
header.LogoRegionOffset = (logoRegionOffset + MediaUnitSize - 1) / MediaUnitSize;
header.LogoRegionSize = ((Logo?.Length ?? 0) + MediaUnitSize - 1) / MediaUnitSize;
header.ExeFsOffset = (exeFsOffset + MediaUnitSize - 1) / MediaUnitSize;
header.ExeFsSize = ((exeFs?.Length ?? 0) + MediaUnitSize - 1) / MediaUnitSize;
header.ExeFsHashRegionSize = 1; // Static 0x200 for exefs superblock
header.RomFsOffset = (romFsOffset + MediaUnitSize - 1) / MediaUnitSize;
header.RomFsSize = ((int)(romFs?.Length ?? 0) + MediaUnitSize - 1) / MediaUnitSize;
header.RomFsHashRegionSize = ((RomFs?.Header?.MasterHashSize ?? 0) + MediaUnitSize - 1) / MediaUnitSize;
header.ExeFsSuperblockHash = ExeFs?.GetSuperblockHash() ?? new byte[0x20];
header.RomFsSuperblockHash = RomFs != null ? await RomFs.GetSuperblockHash(sha, romFs, RomFs.Header) : new byte[0x20];
var headerData = await header.ToBinary().ReadArrayAsync();
await data.WriteAsync(0, headerData);
return(offset);
}
/// <summary>
/// Builds a new ROM file system from the given directory
/// </summary>
/// <param name="directory">Directory from which to load the files</param>
/// <param name="fileSystem">File system from which to load the files</param>
/// <returns>A newly built ROM file system</returns>
public static async Task <RomFs> Build(string directory, IFileSystem fileSystem, ProcessingProgressedToken?progressToken = null)
{
Stream?stream = null;
string?tempFilename = null;
try
{
// A memory stream is faster, but an internal limitation means it's unsuitable for files larger than 2GB
// We'll fall back to a file stream if our raw data won't fit within 2GB minus 400 MB (for safety, since there's still metadata, hashes, and other partitions)
if (fileSystem.GetDirectoryLength(directory) < (int.MaxValue - (400 * Math.Pow(1024, 2))))
{
stream = new MemoryStream();
}
else
{
// Do not use IFileSystem; this is for temporary storage since RAM isn't an option
tempFilename = Path.GetTempFileName();
stream = File.Open(tempFilename, FileMode.OpenOrCreate, FileAccess.ReadWrite);
}
RomFsBuilder.RomFsBuilder.BuildRomFS(directory, fileSystem, stream, progressToken);
BinaryFile data;
if (stream is FileStream)
{
// We want the BinaryFile class to own the file so it will dispose of it properly
// So let's dispose our copy and let it re-open it however it sees fit
// And instead of a BinaryFile, use a FileDeletingBinaryFile to delete the file on dispose
stream.Dispose();
stream = null;
if (string.IsNullOrEmpty(tempFilename))
{
// The developer (probably me) made a mistake
throw new Exception("Temporary file not found");
}
data = new FileDeletingBinaryFile(tempFilename);
}
else if (stream is MemoryStream memoryStream)
{
try
{
// Faster but maybe more memory-intensive
var memoryStreamArray = memoryStream.ToArray();
data = new BinaryFile(memoryStreamArray);
}
catch (OutOfMemoryException)
{
// Slower but more reliable
data = new BinaryFile(memoryStream);
}
}
else
{
// The developer (probably me) made a mistake
throw new Exception("Unexpected type of stream in RomFs.Build");
}
var header = new RomFsHeader(await data.ReadArrayAsync(0, 0x6B));
var romFs = new RomFs(data, header);
await romFs.Initialize();
return(romFs);
}
finally
{
stream?.Dispose();
}
}
public NcchPartition(RomFs romfs = null, ExeFs exefs = null, IReadOnlyBinaryDataAccessor exheader = null)
{
RomFs = romfs;
ExeFs = exefs;
ExHeader = exheader;
}
