Ryujinx-uplift/Ryujinx.HLE/HOS/Services/Mii/MiiDatabaseManager.cs

514 lines
15 KiB
C#
Raw Normal View History

using LibHac;
using LibHac.Common;
using LibHac.Fs;
using LibHac.Fs.Shim;
using Ryujinx.HLE.HOS.Services.Mii.Types;
using System.Runtime.CompilerServices;
namespace Ryujinx.HLE.HOS.Services.Mii
{
class MiiDatabaseManager
{
private static bool IsTestModeEnabled = false;
private static uint MountCounter = 0;
private const ulong DatabaseTestSaveDataId = 0x8000000000000031;
private const ulong DatabaseSaveDataId = 0x8000000000000030;
private const ulong NsTitleId = 0x010000000000001F;
private const ulong SdbTitleId = 0x0100000000000039;
private static U8String DatabasePath = new U8String("mii:/MiiDatabase.dat");
private static U8String MountName = new U8String("mii");
private NintendoFigurineDatabase _database;
private bool _isDirty;
private FileSystemClient _filesystemClient;
protected ulong UpdateCounter { get; private set; }
public MiiDatabaseManager()
{
_database = new NintendoFigurineDatabase();
_isDirty = false;
UpdateCounter = 0;
}
private void ResetDatabase()
{
_database = new NintendoFigurineDatabase();
_database.Format();
}
private void MarkDirty(DatabaseSessionMetadata metadata)
{
_isDirty = true;
UpdateCounter++;
metadata.UpdateCounter = UpdateCounter;
}
private bool GetAtVirtualIndex(int index, out int realIndex, out StoreData storeData)
{
realIndex = -1;
storeData = new StoreData();
int virtualIndex = 0;
for (int i = 0; i < _database.Length; i++)
{
StoreData tmp = _database.Get(i);
if (!tmp.IsSpecial())
{
if (index == virtualIndex)
{
realIndex = i;
storeData = tmp;
return true;
}
virtualIndex++;
}
}
return false;
}
private int ConvertRealIndexToVirtualIndex(int realIndex)
{
int virtualIndex = 0;
for (int i = 0; i < realIndex; i++)
{
StoreData tmp = _database.Get(i);
if (!tmp.IsSpecial())
{
virtualIndex++;
}
}
return virtualIndex;
}
public void InitializeDatabase(Switch device)
{
_filesystemClient = device.FileSystem.FsClient;
// Ensure we have valid data in the database
_database.Format();
// TODO: Unmount is currently not implemented properly at dispose, implement that and decrement MountCounter.
MountCounter = 0;
MountSave();
}
private Result MountSave()
{
Result result = Result.Success;
Update to LibHac 0.13.1 (#2328) Update the LibHac dependency to version 0.13.1. This brings a ton of improvements and changes such as: - Refactor `FsSrv` to match the official refactoring done in FS. - Change how the `Horizon` and `HorizonClient` classes are handled. Each client created represents a different process with its own process ID and client state. - Add FS access control to handle permissions for FS service method calls. - Add FS program registry to keep track of the program ID, location and permissions of each process. - Add FS program index map info manager to track the program IDs and indexes of multi-application programs. - Add all FS IPC interfaces. - Rewrite `Fs.Fsa` code to be more accurate. - Rewrite a lot of `FsSrv` code to be more accurate. - Extend directory save data to store `SaveDataExtraData` - Extend directory save data to lock the save directory to allow only one accessor at a time. - Improve waiting and retrying when encountering access issues in `LocalFileSystem` and `DirectorySaveDataFileSystem`. - More `IFileSystemProxy` methods should work now. - Probably a bunch more stuff. On the Ryujinx side: - Forward most `IFileSystemProxy` methods to LibHac. - Register programs and program index map info when launching an application. - Remove hacks and workarounds for missing LibHac functionality. - Recreate missing save data extra data found on emulator startup. - Create system save data that wasn't indexed correctly on an older LibHac version. `FsSrv` now enforces access control for each process. When a process tries to open a save data file system, FS reads the save's extra data to determine who the save owner is and if the caller has permission to open the save data. Previously-created save data did not have extra data created when the save was created. With access control checks in place, this means that processes with no permissions (most games) wouldn't be able to access their own save data. The extra data can be partially created from data in the save data indexer, which should be enough for access control purposes.
2021-07-13 10:19:28 +02:00
if (MountCounter == 0)
{
ulong targetSaveDataId;
ulong targetTitleId;
if (IsTestModeEnabled)
{
targetSaveDataId = DatabaseTestSaveDataId;
targetTitleId = SdbTitleId;
}
else
{
targetSaveDataId = DatabaseSaveDataId;
// Nintendo use NS TitleID when creating the production save even on sdb, let's follow that behaviour.
targetTitleId = NsTitleId;
}
U8Span mountName = new U8Span(MountName);
result = _filesystemClient.MountSystemSaveData(mountName, SaveDataSpaceId.System, targetSaveDataId);
if (result.IsFailure())
{
if (ResultFs.TargetNotFound.Includes(result))
{
// TODO: We're currently always specifying the owner ID because FS doesn't have a way of
// knowing which process called it
result = _filesystemClient.CreateSystemSaveData(targetSaveDataId, targetTitleId, 0x10000,
0x10000, SaveDataFlags.KeepAfterResettingSystemSaveDataWithoutUserSaveData);
if (result.IsFailure()) return result;
result = _filesystemClient.MountSystemSaveData(mountName, SaveDataSpaceId.System, targetSaveDataId);
if (result.IsFailure()) return result;
}
}
if (result == Result.Success)
{
MountCounter++;
}
Update to LibHac 0.13.1 (#2328) Update the LibHac dependency to version 0.13.1. This brings a ton of improvements and changes such as: - Refactor `FsSrv` to match the official refactoring done in FS. - Change how the `Horizon` and `HorizonClient` classes are handled. Each client created represents a different process with its own process ID and client state. - Add FS access control to handle permissions for FS service method calls. - Add FS program registry to keep track of the program ID, location and permissions of each process. - Add FS program index map info manager to track the program IDs and indexes of multi-application programs. - Add all FS IPC interfaces. - Rewrite `Fs.Fsa` code to be more accurate. - Rewrite a lot of `FsSrv` code to be more accurate. - Extend directory save data to store `SaveDataExtraData` - Extend directory save data to lock the save directory to allow only one accessor at a time. - Improve waiting and retrying when encountering access issues in `LocalFileSystem` and `DirectorySaveDataFileSystem`. - More `IFileSystemProxy` methods should work now. - Probably a bunch more stuff. On the Ryujinx side: - Forward most `IFileSystemProxy` methods to LibHac. - Register programs and program index map info when launching an application. - Remove hacks and workarounds for missing LibHac functionality. - Recreate missing save data extra data found on emulator startup. - Create system save data that wasn't indexed correctly on an older LibHac version. `FsSrv` now enforces access control for each process. When a process tries to open a save data file system, FS reads the save's extra data to determine who the save owner is and if the caller has permission to open the save data. Previously-created save data did not have extra data created when the save was created. With access control checks in place, this means that processes with no permissions (most games) wouldn't be able to access their own save data. The extra data can be partially created from data in the save data indexer, which should be enough for access control purposes.
2021-07-13 10:19:28 +02:00
}
return result;
}
public ResultCode DeleteFile()
{
ResultCode result = (ResultCode)_filesystemClient.DeleteFile(DatabasePath).Value;
_filesystemClient.Commit(MountName);
return result;
}
public ResultCode LoadFromFile(out bool isBroken)
{
isBroken = false;
if (MountCounter == 0)
{
return ResultCode.InvalidArgument;
}
UpdateCounter++;
ResetDatabase();
Result result = _filesystemClient.OpenFile(out FileHandle handle, DatabasePath, OpenMode.Read);
if (result.IsSuccess())
{
result = _filesystemClient.GetFileSize(out long fileSize, handle);
if (result.IsSuccess())
{
if (fileSize == Unsafe.SizeOf<NintendoFigurineDatabase>())
{
result = _filesystemClient.ReadFile(handle, 0, _database.AsSpan());
if (result.IsSuccess())
{
if (_database.Verify() != ResultCode.Success)
{
ResetDatabase();
isBroken = true;
}
else
{
isBroken = _database.FixDatabase();
}
}
}
else
{
isBroken = true;
}
}
_filesystemClient.CloseFile(handle);
return (ResultCode)result.Value;
}
else if (ResultFs.PathNotFound.Includes(result))
{
return (ResultCode)ForceSaveDatabase().Value;
}
return ResultCode.Success;
}
private Result ForceSaveDatabase()
{
Result result = _filesystemClient.CreateFile(DatabasePath, Unsafe.SizeOf<NintendoFigurineDatabase>());
if (result.IsSuccess() || ResultFs.PathAlreadyExists.Includes(result))
{
result = _filesystemClient.OpenFile(out FileHandle handle, DatabasePath, OpenMode.Write);
if (result.IsSuccess())
{
result = _filesystemClient.GetFileSize(out long fileSize, handle);
if (result.IsSuccess())
{
// If the size doesn't match, recreate the file
if (fileSize != Unsafe.SizeOf<NintendoFigurineDatabase>())
{
_filesystemClient.CloseFile(handle);
result = _filesystemClient.DeleteFile(DatabasePath);
if (result.IsSuccess())
{
result = _filesystemClient.CreateFile(DatabasePath, Unsafe.SizeOf<NintendoFigurineDatabase>());
if (result.IsSuccess())
{
result = _filesystemClient.OpenFile(out handle, DatabasePath, OpenMode.Write);
}
}
if (result.IsFailure())
{
return result;
}
}
result = _filesystemClient.WriteFile(handle, 0, _database.AsReadOnlySpan(), WriteOption.Flush);
}
_filesystemClient.CloseFile(handle);
}
}
if (result.IsSuccess())
{
_isDirty = false;
result = _filesystemClient.Commit(MountName);
}
return result;
}
public DatabaseSessionMetadata CreateSessionMetadata(SpecialMiiKeyCode miiKeyCode)
{
return new DatabaseSessionMetadata(UpdateCounter, miiKeyCode);
}
public void SetInterfaceVersion(DatabaseSessionMetadata metadata, uint interfaceVersion)
{
metadata.InterfaceVersion = interfaceVersion;
}
public bool IsUpdated(DatabaseSessionMetadata metadata)
{
bool result = metadata.UpdateCounter != UpdateCounter;
metadata.UpdateCounter = UpdateCounter;
return result;
}
public int GetCount(DatabaseSessionMetadata metadata)
{
if (!metadata.MiiKeyCode.IsEnabledSpecialMii())
{
int count = 0;
for (int i = 0; i < _database.Length; i++)
{
StoreData tmp = _database.Get(i);
if (!tmp.IsSpecial())
{
count++;
}
}
return count;
}
else
{
return _database.Length;
}
}
public void Get(DatabaseSessionMetadata metadata, int index, out StoreData storeData)
{
if (!metadata.MiiKeyCode.IsEnabledSpecialMii())
{
if (GetAtVirtualIndex(index, out int realIndex, out _))
{
index = realIndex;
}
else
{
index = 0;
}
}
storeData = _database.Get(index);
}
public ResultCode FindIndex(DatabaseSessionMetadata metadata, out int index, CreateId createId)
{
return FindIndex(out index, createId, metadata.MiiKeyCode.IsEnabledSpecialMii());
}
public ResultCode FindIndex(out int index, CreateId createId, bool isSpecial)
{
if (_database.GetIndexByCreatorId(out int realIndex, createId))
{
if (isSpecial)
{
index = realIndex;
return ResultCode.Success;
}
StoreData storeData = _database.Get(realIndex);
if (!storeData.IsSpecial())
{
if (realIndex < 1)
{
index = 0;
}
else
{
index = ConvertRealIndexToVirtualIndex(realIndex);
}
return ResultCode.Success;
}
}
index = -1;
return ResultCode.NotFound;
}
public ResultCode Move(DatabaseSessionMetadata metadata, int newIndex, CreateId createId)
{
if (!metadata.MiiKeyCode.IsEnabledSpecialMii())
{
if (GetAtVirtualIndex(newIndex, out int realIndex, out _))
{
newIndex = realIndex;
}
else
{
newIndex = 0;
}
}
if (_database.GetIndexByCreatorId(out int oldIndex, createId))
{
StoreData realStoreData = _database.Get(oldIndex);
if (!metadata.MiiKeyCode.IsEnabledSpecialMii() && realStoreData.IsSpecial())
{
return ResultCode.InvalidOperationOnSpecialMii;
}
ResultCode result = _database.Move(newIndex, oldIndex);
if (result == ResultCode.Success)
{
MarkDirty(metadata);
}
return result;
}
return ResultCode.NotFound;
}
public ResultCode AddOrReplace(DatabaseSessionMetadata metadata, StoreData storeData)
{
if (!storeData.IsValid())
{
return ResultCode.InvalidStoreData;
}
if (!metadata.MiiKeyCode.IsEnabledSpecialMii() && storeData.IsSpecial())
{
return ResultCode.InvalidOperationOnSpecialMii;
}
if (_database.GetIndexByCreatorId(out int index, storeData.CreateId))
{
StoreData oldStoreData = _database.Get(index);
if (oldStoreData.IsSpecial())
{
return ResultCode.InvalidOperationOnSpecialMii;
}
_database.Replace(index, storeData);
}
else
{
if (_database.IsFull())
{
return ResultCode.DatabaseFull;
}
_database.Add(storeData);
}
MarkDirty(metadata);
return ResultCode.Success;
}
public ResultCode Delete(DatabaseSessionMetadata metadata, CreateId createId)
{
if (!_database.GetIndexByCreatorId(out int index, createId))
{
return ResultCode.NotFound;
}
if (!metadata.MiiKeyCode.IsEnabledSpecialMii())
{
StoreData storeData = _database.Get(index);
if (storeData.IsSpecial())
{
return ResultCode.InvalidOperationOnSpecialMii;
}
}
_database.Delete(index);
MarkDirty(metadata);
return ResultCode.Success;
}
public ResultCode DestroyFile(DatabaseSessionMetadata metadata)
{
_database.CorruptDatabase();
MarkDirty(metadata);
ResultCode result = SaveDatabase();
ResetDatabase();
return result;
}
public ResultCode SaveDatabase()
{
if (_isDirty)
{
return (ResultCode)ForceSaveDatabase().Value;
}
else
{
return ResultCode.NotUpdated;
}
}
public void FormatDatabase(DatabaseSessionMetadata metadata)
{
_database.Format();
MarkDirty(metadata);
}
public bool IsFullDatabase()
{
return _database.IsFull();
}
}
}