ryujinx/Ryujinx.HLE/FileSystem/Content/ContentManager.cs
Thog f0055482fd Fix race condition in ContentManager (#884)
* Fix race condition in ContentManager

This fix a race condition happening since #791 when trying to load a
game via command line.

* Address gdk's comments

* Ensure to dispose the FileStream and not the IStorage
2020-01-13 01:17:44 +01:00

889 lines
35 KiB
C#

using LibHac;
using LibHac.Fs;
using LibHac.FsSystem;
using LibHac.FsSystem.NcaUtils;
using LibHac.Ncm;
using Ryujinx.HLE.Exceptions;
using Ryujinx.HLE.HOS.Services.Time;
using Ryujinx.HLE.Utilities;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
namespace Ryujinx.HLE.FileSystem.Content
{
internal class ContentManager
{
private const ulong SystemVersionTitleId = 0x0100000000000809;
private const ulong SystemUpdateTitleId = 0x0100000000000816;
private Dictionary<StorageId, LinkedList<LocationEntry>> _locationEntries;
private Dictionary<string, long> _sharedFontTitleDictionary;
private Dictionary<string, string> _sharedFontFilenameDictionary;
private SortedDictionary<(ulong titleId, NcaContentType type), string> _contentDictionary;
private Switch _device;
private readonly object _lock = new object();
public ContentManager(Switch device)
{
_contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>();
_locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>();
_sharedFontTitleDictionary = new Dictionary<string, long>
{
{ "FontStandard", 0x0100000000000811 },
{ "FontChineseSimplified", 0x0100000000000814 },
{ "FontExtendedChineseSimplified", 0x0100000000000814 },
{ "FontKorean", 0x0100000000000812 },
{ "FontChineseTraditional", 0x0100000000000813 },
{ "FontNintendoExtended", 0x0100000000000810 }
};
_sharedFontFilenameDictionary = new Dictionary<string, string>
{
{ "FontStandard", "nintendo_udsg-r_std_003.bfttf" },
{ "FontChineseSimplified", "nintendo_udsg-r_org_zh-cn_003.bfttf" },
{ "FontExtendedChineseSimplified", "nintendo_udsg-r_ext_zh-cn_003.bfttf" },
{ "FontKorean", "nintendo_udsg-r_ko_003.bfttf" },
{ "FontChineseTraditional", "nintendo_udjxh-db_zh-tw_003.bfttf" },
{ "FontNintendoExtended", "nintendo_ext_003.bfttf" }
};
_device = device;
}
public void LoadEntries(bool ignoreMissingFonts = false)
{
lock (_lock)
{
_contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>();
_locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>();
foreach (StorageId storageId in Enum.GetValues(typeof(StorageId)))
{
string contentDirectory = null;
string contentPathString = null;
string registeredDirectory = null;
try
{
contentPathString = LocationHelper.GetContentRoot(storageId);
contentDirectory = LocationHelper.GetRealPath(_device.FileSystem, contentPathString);
registeredDirectory = Path.Combine(contentDirectory, "registered");
}
catch (NotSupportedException)
{
continue;
}
Directory.CreateDirectory(registeredDirectory);
LinkedList<LocationEntry> locationList = new LinkedList<LocationEntry>();
void AddEntry(LocationEntry entry)
{
locationList.AddLast(entry);
}
foreach (string directoryPath in Directory.EnumerateDirectories(registeredDirectory))
{
if (Directory.GetFiles(directoryPath).Length > 0)
{
string ncaName = new DirectoryInfo(directoryPath).Name.Replace(".nca", string.Empty);
using (FileStream ncaFile = File.OpenRead(Directory.GetFiles(directoryPath)[0]))
{
Nca nca = new Nca(_device.System.KeySet, ncaFile.AsStorage());
string switchPath = contentPathString + ":/" + ncaFile.Name.Replace(contentDirectory, string.Empty).TrimStart(Path.DirectorySeparatorChar);
// Change path format to switch's
switchPath = switchPath.Replace('\\', '/');
LocationEntry entry = new LocationEntry(switchPath,
0,
(long)nca.Header.TitleId,
nca.Header.ContentType);
AddEntry(entry);
_contentDictionary.Add((nca.Header.TitleId, nca.Header.ContentType), ncaName);
}
}
}
foreach (string filePath in Directory.EnumerateFiles(contentDirectory))
{
if (Path.GetExtension(filePath) == ".nca")
{
string ncaName = Path.GetFileNameWithoutExtension(filePath);
using (FileStream ncaFile = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
Nca nca = new Nca(_device.System.KeySet, ncaFile.AsStorage());
string switchPath = contentPathString + ":/" + filePath.Replace(contentDirectory, string.Empty).TrimStart(Path.DirectorySeparatorChar);
// Change path format to switch's
switchPath = switchPath.Replace('\\', '/');
LocationEntry entry = new LocationEntry(switchPath,
0,
(long)nca.Header.TitleId,
nca.Header.ContentType);
AddEntry(entry);
_contentDictionary.Add((nca.Header.TitleId, nca.Header.ContentType), ncaName);
}
}
}
if (_locationEntries.ContainsKey(storageId) && _locationEntries[storageId]?.Count == 0)
{
_locationEntries.Remove(storageId);
}
if (!_locationEntries.ContainsKey(storageId))
{
_locationEntries.Add(storageId, locationList);
}
}
TimeManager.Instance.InitializeTimeZone(_device);
_device.System.Font.Initialize(this, ignoreMissingFonts);
}
}
public void ClearEntry(long titleId, NcaContentType contentType, StorageId storageId)
{
lock (_lock)
{
RemoveLocationEntry(titleId, contentType, storageId);
}
}
public void RefreshEntries(StorageId storageId, int flag)
{
lock (_lock)
{
LinkedList<LocationEntry> locationList = _locationEntries[storageId];
LinkedListNode<LocationEntry> locationEntry = locationList.First;
while (locationEntry != null)
{
LinkedListNode<LocationEntry> nextLocationEntry = locationEntry.Next;
if (locationEntry.Value.Flag == flag)
{
locationList.Remove(locationEntry.Value);
}
locationEntry = nextLocationEntry;
}
}
}
public bool HasNca(string ncaId, StorageId storageId)
{
lock (_lock)
{
if (_contentDictionary.ContainsValue(ncaId))
{
var content = _contentDictionary.FirstOrDefault(x => x.Value == ncaId);
long titleId = (long)content.Key.Item1;
NcaContentType contentType = content.Key.type;
StorageId storage = GetInstalledStorage(titleId, contentType, storageId);
return storage == storageId;
}
}
return false;
}
public UInt128 GetInstalledNcaId(long titleId, NcaContentType contentType)
{
lock (_lock)
{
if (_contentDictionary.ContainsKey(((ulong)titleId, contentType)))
{
return new UInt128(_contentDictionary[((ulong)titleId, contentType)]);
}
}
return new UInt128();
}
public StorageId GetInstalledStorage(long titleId, NcaContentType contentType, StorageId storageId)
{
lock (_lock)
{
LocationEntry locationEntry = GetLocation(titleId, contentType, storageId);
return locationEntry.ContentPath != null ?
LocationHelper.GetStorageId(locationEntry.ContentPath) : StorageId.None;
}
}
public string GetInstalledContentPath(long titleId, StorageId storageId, NcaContentType contentType)
{
lock (_lock)
{
LocationEntry locationEntry = GetLocation(titleId, contentType, storageId);
if (VerifyContentType(locationEntry, contentType))
{
return locationEntry.ContentPath;
}
}
return string.Empty;
}
public void RedirectLocation(LocationEntry newEntry, StorageId storageId)
{
lock (_lock)
{
LocationEntry locationEntry = GetLocation(newEntry.TitleId, newEntry.ContentType, storageId);
if (locationEntry.ContentPath != null)
{
RemoveLocationEntry(newEntry.TitleId, newEntry.ContentType, storageId);
}
AddLocationEntry(newEntry, storageId);
}
}
private bool VerifyContentType(LocationEntry locationEntry, NcaContentType contentType)
{
if (locationEntry.ContentPath == null)
{
return false;
}
string installedPath = _device.FileSystem.SwitchPathToSystemPath(locationEntry.ContentPath);
if (!string.IsNullOrWhiteSpace(installedPath))
{
if (File.Exists(installedPath))
{
using (FileStream file = new FileStream(installedPath, FileMode.Open, FileAccess.Read))
{
Nca nca = new Nca(_device.System.KeySet, file.AsStorage());
bool contentCheck = nca.Header.ContentType == contentType;
return contentCheck;
}
}
}
return false;
}
private void AddLocationEntry(LocationEntry entry, StorageId storageId)
{
LinkedList<LocationEntry> locationList = null;
if (_locationEntries.ContainsKey(storageId))
{
locationList = _locationEntries[storageId];
}
if (locationList != null)
{
if (locationList.Contains(entry))
{
locationList.Remove(entry);
}
locationList.AddLast(entry);
}
}
private void RemoveLocationEntry(long titleId, NcaContentType contentType, StorageId storageId)
{
LinkedList<LocationEntry> locationList = null;
if (_locationEntries.ContainsKey(storageId))
{
locationList = _locationEntries[storageId];
}
if (locationList != null)
{
LocationEntry entry =
locationList.ToList().Find(x => x.TitleId == titleId && x.ContentType == contentType);
if (entry.ContentPath != null)
{
locationList.Remove(entry);
}
}
}
public bool TryGetFontTitle(string fontName, out long titleId)
{
return _sharedFontTitleDictionary.TryGetValue(fontName, out titleId);
}
public bool TryGetFontFilename(string fontName, out string filename)
{
return _sharedFontFilenameDictionary.TryGetValue(fontName, out filename);
}
private LocationEntry GetLocation(long titleId, NcaContentType contentType, StorageId storageId)
{
LinkedList<LocationEntry> locationList = _locationEntries[storageId];
return locationList.ToList().Find(x => x.TitleId == titleId && x.ContentType == contentType);
}
public void InstallFirmware(string firmwareSource)
{
string contentPathString = LocationHelper.GetContentRoot(StorageId.NandSystem);
string contentDirectory = LocationHelper.GetRealPath(_device.FileSystem, contentPathString);
string registeredDirectory = Path.Combine(contentDirectory, "registered");
string temporaryDirectory = Path.Combine(contentDirectory, "temp");
if (Directory.Exists(temporaryDirectory))
{
Directory.Delete(temporaryDirectory, true);
}
if (Directory.Exists(firmwareSource))
{
InstallFromDirectory(firmwareSource, temporaryDirectory);
FinishInstallation(temporaryDirectory, registeredDirectory);
return;
}
if (!File.Exists(firmwareSource))
{
throw new FileNotFoundException("Firmware file does not exist.");
}
FileInfo info = new FileInfo(firmwareSource);
using (FileStream file = File.OpenRead(firmwareSource))
{
switch (info.Extension)
{
case ".zip":
using (ZipArchive archive = ZipFile.OpenRead(firmwareSource))
{
InstallFromZip(archive, temporaryDirectory);
}
break;
case ".xci":
Xci xci = new Xci(_device.System.KeySet, file.AsStorage());
InstallFromCart(xci, temporaryDirectory);
break;
default:
throw new InvalidFirmwarePackageException("Input file is not a valid firmware package");
}
FinishInstallation(temporaryDirectory, registeredDirectory);
}
}
private void FinishInstallation(string temporaryDirectory, string registeredDirectory)
{
if (Directory.Exists(registeredDirectory))
{
new DirectoryInfo(registeredDirectory).Delete(true);
}
Directory.Move(temporaryDirectory, registeredDirectory);
LoadEntries();
}
private void InstallFromDirectory(string firmwareDirectory, string temporaryDirectory)
{
InstallFromPartition(new LocalFileSystem(firmwareDirectory), temporaryDirectory);
}
private void InstallFromPartition(IFileSystem filesystem, string temporaryDirectory)
{
foreach (var entry in filesystem.EnumerateEntries("/", "*.nca"))
{
Nca nca = new Nca(_device.System.KeySet, OpenPossibleFragmentedFile(filesystem, entry.FullPath, OpenMode.Read).AsStorage());
SaveNca(nca, entry.Name.Remove(entry.Name.IndexOf('.')), temporaryDirectory);
}
}
private void InstallFromCart(Xci gameCard, string temporaryDirectory)
{
if (gameCard.HasPartition(XciPartitionType.Update))
{
XciPartition partition = gameCard.OpenPartition(XciPartitionType.Update);
InstallFromPartition(partition, temporaryDirectory);
}
else
{
throw new Exception("Update not found in xci file.");
}
}
private void InstallFromZip(ZipArchive archive, string temporaryDirectory)
{
using (archive)
{
foreach (var entry in archive.Entries)
{
if (entry.FullName.EndsWith(".nca") || entry.FullName.EndsWith(".nca/00"))
{
// Clean up the name and get the NcaId
string[] pathComponents = entry.FullName.Replace(".cnmt", "").Split('/');
string ncaId = pathComponents[pathComponents.Length - 1];
// If this is a fragmented nca, we need to get the previous element.GetZip
if (ncaId.Equals("00"))
{
ncaId = pathComponents[pathComponents.Length - 2];
}
if (ncaId.Contains(".nca"))
{
string newPath = Path.Combine(temporaryDirectory, ncaId);
Directory.CreateDirectory(newPath);
entry.ExtractToFile(Path.Combine(newPath, "00"));
}
}
}
}
}
public void SaveNca(Nca nca, string ncaId, string temporaryDirectory)
{
string newPath = Path.Combine(temporaryDirectory, ncaId + ".nca");
Directory.CreateDirectory(newPath);
using (FileStream file = File.Create(Path.Combine(newPath, "00")))
{
nca.BaseStorage.AsStream().CopyTo(file);
}
}
private IFile OpenPossibleFragmentedFile(IFileSystem filesystem, string path, OpenMode mode)
{
IFile file;
if (filesystem.FileExists($"{path}/00"))
{
filesystem.OpenFile(out file, $"{path}/00", mode);
}
else
{
filesystem.OpenFile(out file, path, mode);
}
return file;
}
private Stream GetZipStream(ZipArchiveEntry entry)
{
MemoryStream dest = new MemoryStream();
Stream src = entry.Open();
src.CopyTo(dest);
src.Dispose();
return dest;
}
public SystemVersion VerifyFirmwarePackage(string firmwarePackage)
{
Dictionary<ulong, List<(NcaContentType type, string path)>> updateNcas = new Dictionary<ulong, List<(NcaContentType, string)>>();
if (Directory.Exists(firmwarePackage))
{
return VerifyAndGetVersionDirectory(firmwarePackage);
}
if (!File.Exists(firmwarePackage))
{
throw new FileNotFoundException("Firmware file does not exist.");
}
FileInfo info = new FileInfo(firmwarePackage);
using (FileStream file = File.OpenRead(firmwarePackage))
{
switch (info.Extension)
{
case ".zip":
using (ZipArchive archive = ZipFile.OpenRead(firmwarePackage))
{
return VerifyAndGetVersionZip(archive);
}
case ".xci":
Xci xci = new Xci(_device.System.KeySet, file.AsStorage());
if (xci.HasPartition(XciPartitionType.Update))
{
XciPartition partition = xci.OpenPartition(XciPartitionType.Update);
return VerifyAndGetVersion(partition);
}
else
{
throw new InvalidFirmwarePackageException("Update not found in xci file.");
}
default:
break;
}
}
SystemVersion VerifyAndGetVersionDirectory(string firmwareDirectory)
{
return VerifyAndGetVersion(new LocalFileSystem(firmwareDirectory));
}
SystemVersion VerifyAndGetVersionZip(ZipArchive archive)
{
SystemVersion systemVersion = null;
foreach (var entry in archive.Entries)
{
if (entry.FullName.EndsWith(".nca") || entry.FullName.EndsWith(".nca/00"))
{
using (Stream ncaStream = GetZipStream(entry))
{
IStorage storage = ncaStream.AsStorage();
Nca nca = new Nca(_device.System.KeySet, storage);
if (updateNcas.ContainsKey(nca.Header.TitleId))
{
updateNcas[nca.Header.TitleId].Add((nca.Header.ContentType, entry.FullName));
}
else
{
updateNcas.Add(nca.Header.TitleId, new List<(NcaContentType, string)>());
updateNcas[nca.Header.TitleId].Add((nca.Header.ContentType, entry.FullName));
}
}
}
}
if (updateNcas.ContainsKey(SystemUpdateTitleId))
{
var ncaEntry = updateNcas[SystemUpdateTitleId];
string metaPath = ncaEntry.Find(x => x.type == NcaContentType.Meta).path;
CnmtContentMetaEntry[] metaEntries = null;
var fileEntry = archive.GetEntry(metaPath);
using (Stream ncaStream = GetZipStream(fileEntry))
{
Nca metaNca = new Nca(_device.System.KeySet, ncaStream.AsStorage());
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
string cnmtPath = fs.EnumerateEntries("/", "*.cnmt").Single().FullPath;
if (fs.OpenFile(out IFile metaFile, cnmtPath, OpenMode.Read).IsSuccess())
{
var meta = new Cnmt(metaFile.AsStream());
if (meta.Type == ContentMetaType.SystemUpdate)
{
metaEntries = meta.MetaEntries;
updateNcas.Remove(SystemUpdateTitleId);
};
}
}
if (metaEntries == null)
{
throw new FileNotFoundException("System update title was not found in the firmware package.");
}
if (updateNcas.ContainsKey(SystemVersionTitleId))
{
string versionEntry = updateNcas[SystemVersionTitleId].Find(x => x.type != NcaContentType.Meta).path;
using (Stream ncaStream = GetZipStream(archive.GetEntry(versionEntry)))
{
Nca nca = new Nca(_device.System.KeySet, ncaStream.AsStorage());
var romfs = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
if (romfs.OpenFile(out IFile systemVersionFile, "/file", OpenMode.Read).IsSuccess())
{
systemVersion = new SystemVersion(systemVersionFile.AsStream());
}
}
}
foreach (CnmtContentMetaEntry metaEntry in metaEntries)
{
if (updateNcas.TryGetValue(metaEntry.TitleId, out ncaEntry))
{
metaPath = ncaEntry.Find(x => x.type == NcaContentType.Meta).path;
string contentPath = ncaEntry.Find(x => x.type != NcaContentType.Meta).path;
// Nintendo in 9.0.0, removed PPC and only kept the meta nca of it.
// This is a perfect valid case, so we should just ignore the missing content nca and continue.
if (contentPath == null)
{
updateNcas.Remove(metaEntry.TitleId);
continue;
}
ZipArchiveEntry metaZipEntry = archive.GetEntry(metaPath);
ZipArchiveEntry contentZipEntry = archive.GetEntry(contentPath);
using (Stream metaNcaStream = GetZipStream(metaZipEntry))
{
using (Stream contentNcaStream = GetZipStream(contentZipEntry))
{
Nca metaNca = new Nca(_device.System.KeySet, metaNcaStream.AsStorage());
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
string cnmtPath = fs.EnumerateEntries("/", "*.cnmt").Single().FullPath;
if (fs.OpenFile(out IFile metaFile, cnmtPath, OpenMode.Read).IsSuccess())
{
var meta = new Cnmt(metaFile.AsStream());
IStorage contentStorage = contentNcaStream.AsStorage();
if (contentStorage.GetSize(out long size).IsSuccess())
{
byte[] contentData = new byte[size];
Span<byte> content = new Span<byte>(contentData);
contentStorage.Read(0, content);
Span<byte> hash = new Span<byte>(new byte[32]);
LibHac.Crypto.Sha256.GenerateSha256Hash(content, hash);
if (LibHac.Util.ArraysEqual(hash.ToArray(), meta.ContentEntries[0].Hash))
{
updateNcas.Remove(metaEntry.TitleId);
}
}
}
}
}
}
}
if (updateNcas.Count > 0)
{
string extraNcas = string.Empty;
foreach (var entry in updateNcas)
{
foreach (var nca in entry.Value)
{
extraNcas += nca.path + Environment.NewLine;
}
}
throw new InvalidFirmwarePackageException($"Firmware package contains unrelated archives. Please remove these paths: {Environment.NewLine}{extraNcas}");
}
}
else
{
throw new FileNotFoundException("System update title was not found in the firmware package.");
}
return systemVersion;
}
SystemVersion VerifyAndGetVersion(IFileSystem filesystem)
{
SystemVersion systemVersion = null;
CnmtContentMetaEntry[] metaEntries = null;
foreach (var entry in filesystem.EnumerateEntries("/", "*.nca"))
{
IStorage ncaStorage = OpenPossibleFragmentedFile(filesystem, entry.FullPath, OpenMode.Read).AsStorage();
Nca nca = new Nca(_device.System.KeySet, ncaStorage);
if (nca.Header.TitleId == SystemUpdateTitleId && nca.Header.ContentType == NcaContentType.Meta)
{
IFileSystem fs = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
string cnmtPath = fs.EnumerateEntries("/", "*.cnmt").Single().FullPath;
if (fs.OpenFile(out IFile metaFile, cnmtPath, OpenMode.Read).IsSuccess())
{
var meta = new Cnmt(metaFile.AsStream());
if (meta.Type == ContentMetaType.SystemUpdate)
{
metaEntries = meta.MetaEntries;
}
};
continue;
}
else if (nca.Header.TitleId == SystemVersionTitleId && nca.Header.ContentType == NcaContentType.Data)
{
var romfs = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
if (romfs.OpenFile(out IFile systemVersionFile, "/file", OpenMode.Read).IsSuccess())
{
systemVersion = new SystemVersion(systemVersionFile.AsStream());
}
}
if (updateNcas.ContainsKey(nca.Header.TitleId))
{
updateNcas[nca.Header.TitleId].Add((nca.Header.ContentType, entry.FullPath));
}
else
{
updateNcas.Add(nca.Header.TitleId, new List<(NcaContentType, string)>());
updateNcas[nca.Header.TitleId].Add((nca.Header.ContentType, entry.FullPath));
}
ncaStorage.Dispose();
}
if (metaEntries == null)
{
throw new FileNotFoundException("System update title was not found in the firmware package.");
}
foreach (CnmtContentMetaEntry metaEntry in metaEntries)
{
if (updateNcas.TryGetValue(metaEntry.TitleId, out var ncaEntry))
{
var metaNcaEntry = ncaEntry.Find(x => x.type == NcaContentType.Meta);
string contentPath = ncaEntry.Find(x => x.type != NcaContentType.Meta).path;
// Nintendo in 9.0.0, removed PPC and only kept the meta nca of it.
// This is a perfect valid case, so we should just ignore the missing content nca and continue.
if (contentPath == null)
{
updateNcas.Remove(metaEntry.TitleId);
continue;
}
IStorage metaStorage = OpenPossibleFragmentedFile(filesystem, metaNcaEntry.path, OpenMode.Read).AsStorage();
IStorage contentStorage = OpenPossibleFragmentedFile(filesystem, contentPath, OpenMode.Read).AsStorage();
Nca metaNca = new Nca(_device.System.KeySet, metaStorage);
IFileSystem fs = metaNca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
string cnmtPath = fs.EnumerateEntries("/", "*.cnmt").Single().FullPath;
if (fs.OpenFile(out IFile metaFile, cnmtPath, OpenMode.Read).IsSuccess())
{
var meta = new Cnmt(metaFile.AsStream());
if (contentStorage.GetSize(out long size).IsSuccess())
{
byte[] contentData = new byte[size];
Span<byte> content = new Span<byte>(contentData);
contentStorage.Read(0, content);
Span<byte> hash = new Span<byte>(new byte[32]);
LibHac.Crypto.Sha256.GenerateSha256Hash(content, hash);
if (LibHac.Util.ArraysEqual(hash.ToArray(), meta.ContentEntries[0].Hash))
{
updateNcas.Remove(metaEntry.TitleId);
}
}
}
}
}
if (updateNcas.Count > 0)
{
string extraNcas = string.Empty;
foreach (var entry in updateNcas)
{
foreach (var nca in entry.Value)
{
extraNcas += nca.path + Environment.NewLine;
}
}
throw new InvalidFirmwarePackageException($"Firmware package contains unrelated archives. Please remove these paths: {Environment.NewLine}{extraNcas}");
}
return systemVersion;
}
return null;
}
public SystemVersion GetCurrentFirmwareVersion()
{
LoadEntries(true);
lock (_lock)
{
var locationEnties = _locationEntries[StorageId.NandSystem];
foreach (var entry in locationEnties)
{
if (entry.ContentType == NcaContentType.Data)
{
var path = _device.FileSystem.SwitchPathToSystemPath(entry.ContentPath);
using (FileStream fileStream = File.OpenRead(path))
{
Nca nca = new Nca(_device.System.KeySet, fileStream.AsStorage());
if (nca.Header.TitleId == SystemVersionTitleId && nca.Header.ContentType == NcaContentType.Data)
{
var romfs = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
if (romfs.OpenFile(out IFile systemVersionFile, "/file", OpenMode.Read).IsSuccess())
{
return new SystemVersion(systemVersionFile.AsStream());
}
}
}
}
}
}
return null;
}
}
}