mirror of
https://github.com/Atmosphere-NX/Atmosphere-libs.git
synced 2025-10-09 19:07:08 +02:00
578 lines
23 KiB
C++
578 lines
23 KiB
C++
/*
|
|
* Copyright (c) 2018-2020 Atmosphère-NX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <stratosphere.hpp>
|
|
|
|
namespace ams::fs {
|
|
|
|
s64 HierarchicalRomFileTable::QueryDirectoryEntryStorageSize(u32 count) {
|
|
const size_t real_count = count + ReservedDirectoryCount;
|
|
return DirectoryEntryMapTable::QueryKeyValueStorageSize(real_count) + real_count * (RomPathTool::MaxPathLength + 1) * sizeof(RomPathChar);
|
|
}
|
|
|
|
s64 HierarchicalRomFileTable::QueryDirectoryEntryBucketStorageSize(s64 count) {
|
|
return DirectoryEntryMapTable::QueryBucketStorageSize(count);
|
|
}
|
|
|
|
s64 HierarchicalRomFileTable::QueryFileEntryStorageSize(u32 count) {
|
|
return FileEntryMapTable::QueryKeyValueStorageSize(count) + count * (RomPathTool::MaxPathLength + 1) * sizeof(RomPathChar);
|
|
}
|
|
|
|
s64 HierarchicalRomFileTable::QueryFileEntryBucketStorageSize(s64 count) {
|
|
return FileEntryMapTable::QueryBucketStorageSize(count);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::Format(SubStorage dir_bucket, SubStorage file_bucket) {
|
|
s64 dir_bucket_size;
|
|
R_TRY(dir_bucket.GetSize(std::addressof(dir_bucket_size)));
|
|
R_TRY(DirectoryEntryMapTable::Format(dir_bucket, DirectoryEntryMapTable::QueryBucketCount(dir_bucket_size)));
|
|
|
|
s64 file_bucket_size;
|
|
R_TRY(file_bucket.GetSize(std::addressof(file_bucket_size)));
|
|
R_TRY(FileEntryMapTable::Format(file_bucket, FileEntryMapTable::QueryBucketCount(file_bucket_size)));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
HierarchicalRomFileTable::HierarchicalRomFileTable() { /* ... */ }
|
|
|
|
Result HierarchicalRomFileTable::Initialize(SubStorage dir_bucket, SubStorage dir_entry, SubStorage file_bucket, SubStorage file_entry) {
|
|
s64 dir_bucket_size;
|
|
R_TRY(dir_bucket.GetSize(std::addressof(dir_bucket_size)));
|
|
R_TRY(this->dir_table.Initialize(dir_bucket, DirectoryEntryMapTable::QueryBucketCount(dir_bucket_size), dir_entry));
|
|
|
|
s64 file_bucket_size;
|
|
R_TRY(file_bucket.GetSize(std::addressof(file_bucket_size)));
|
|
R_TRY(this->file_table.Initialize(file_bucket, FileEntryMapTable::QueryBucketCount(file_bucket_size), file_entry));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
void HierarchicalRomFileTable::Finalize() {
|
|
this->dir_table.Finalize();
|
|
this->file_table.Finalize();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::CreateRootDirectory() {
|
|
Position root_pos = RootPosition;
|
|
EntryKey root_key = {};
|
|
root_key.key.parent = root_pos;
|
|
RomPathTool::InitializeRomEntryName(std::addressof(root_key.name));
|
|
RomDirectoryEntry root_entry = {
|
|
.next = InvalidPosition,
|
|
.dir = InvalidPosition,
|
|
.file = InvalidPosition,
|
|
};
|
|
return this->dir_table.Add(std::addressof(root_pos), root_key, root_entry);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::CreateDirectory(RomDirectoryId *out, const RomPathChar *path, const DirectoryInfo &info) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey new_key = {};
|
|
R_TRY(this->FindDirectoryRecursive(std::addressof(new_key), std::addressof(parent_entry), path));
|
|
|
|
R_TRY(this->CheckSameEntryExists(new_key, fs::ResultDbmAlreadyExists()));
|
|
|
|
RomDirectoryEntry new_entry = {
|
|
.next = InvalidPosition,
|
|
.dir = InvalidPosition,
|
|
.file = InvalidPosition,
|
|
};
|
|
|
|
Position new_pos = 0;
|
|
R_TRY_CATCH(this->dir_table.Add(std::addressof(new_pos), new_key, new_entry)) {
|
|
R_CONVERT(fs::ResultDbmKeyFull, fs::ResultDbmDirectoryEntryFull())
|
|
} R_END_TRY_CATCH;
|
|
|
|
*out = ConvertToDirectoryId(new_pos);
|
|
|
|
if (parent_entry.dir == InvalidPosition) {
|
|
parent_entry.dir = new_pos;
|
|
|
|
R_TRY(this->dir_table.SetByPosition(new_key.key.parent, parent_entry));
|
|
} else {
|
|
Position cur_pos = parent_entry.dir;
|
|
while (true) {
|
|
RomEntryKey cur_key = {};
|
|
RomDirectoryEntry cur_entry = {};
|
|
R_TRY(this->dir_table.GetByPosition(std::addressof(cur_key), std::addressof(cur_entry), cur_pos));
|
|
|
|
if (cur_entry.next == InvalidPosition) {
|
|
cur_entry.next = new_pos;
|
|
|
|
R_TRY(this->dir_table.SetByPosition(cur_pos, cur_entry));
|
|
break;
|
|
}
|
|
|
|
cur_pos = cur_entry.next;
|
|
}
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::CreateFile(RomFileId *out, const RomPathChar *path, const FileInfo &info) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey new_key = {};
|
|
R_TRY(this->FindFileRecursive(std::addressof(new_key), std::addressof(parent_entry), path));
|
|
|
|
R_TRY(this->CheckSameEntryExists(new_key, fs::ResultDbmAlreadyExists()));
|
|
|
|
RomFileEntry new_entry = {
|
|
.next = InvalidPosition,
|
|
.info = info,
|
|
};
|
|
|
|
Position new_pos = 0;
|
|
R_TRY_CATCH(this->file_table.Add(std::addressof(new_pos), new_key, new_entry)) {
|
|
R_CONVERT(fs::ResultDbmKeyFull, fs::ResultDbmFileEntryFull())
|
|
} R_END_TRY_CATCH;
|
|
|
|
*out = ConvertToFileId(new_pos);
|
|
|
|
if (parent_entry.file == InvalidPosition) {
|
|
parent_entry.file = new_pos;
|
|
|
|
R_TRY(this->dir_table.SetByPosition(new_key.key.parent, parent_entry));
|
|
} else {
|
|
Position cur_pos = parent_entry.file;
|
|
while (true) {
|
|
RomEntryKey cur_key = {};
|
|
RomFileEntry cur_entry = {};
|
|
R_TRY(this->file_table.GetByPosition(std::addressof(cur_key), std::addressof(cur_entry), cur_pos));
|
|
|
|
if (cur_entry.next == InvalidPosition) {
|
|
cur_entry.next = new_pos;
|
|
|
|
R_TRY(this->file_table.SetByPosition(cur_pos, cur_entry));
|
|
break;
|
|
}
|
|
|
|
cur_pos = cur_entry.next;
|
|
}
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::ConvertPathToDirectoryId(RomDirectoryId *out, const RomPathChar *path) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey key = {};
|
|
R_TRY(this->FindDirectoryRecursive(std::addressof(key), std::addressof(parent_entry), path));
|
|
|
|
Position pos = 0;
|
|
RomDirectoryEntry entry = {};
|
|
R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key));
|
|
|
|
*out = ConvertToDirectoryId(pos);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::ConvertPathToFileId(RomFileId *out, const RomPathChar *path) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey key = {};
|
|
R_TRY(this->FindDirectoryRecursive(std::addressof(key), std::addressof(parent_entry), path));
|
|
|
|
Position pos = 0;
|
|
RomFileEntry entry = {};
|
|
R_TRY(this->GetFileEntry(std::addressof(pos), std::addressof(entry), key));
|
|
|
|
*out = ConvertToFileId(pos);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetDirectoryInformation(DirectoryInfo *out, const RomPathChar *path) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey key = {};
|
|
R_TRY(this->FindDirectoryRecursive(std::addressof(key), std::addressof(parent_entry), path));
|
|
|
|
return this->GetDirectoryInformation(out, key);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetDirectoryInformation(DirectoryInfo *out, RomDirectoryId id) {
|
|
AMS_ASSERT(out != nullptr);
|
|
|
|
RomDirectoryEntry entry = {};
|
|
R_TRY(this->GetDirectoryEntry(std::addressof(entry), id));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::OpenFile(FileInfo *out, const RomPathChar *path) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey key = {};
|
|
R_TRY(this->FindFileRecursive(std::addressof(key), std::addressof(parent_entry), path));
|
|
|
|
return this->OpenFile(out, key);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::OpenFile(FileInfo *out, RomFileId id) {
|
|
AMS_ASSERT(out != nullptr);
|
|
|
|
RomFileEntry entry = {};
|
|
R_TRY(this->GetFileEntry(std::addressof(entry), id));
|
|
|
|
*out = entry.info;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindOpen(FindPosition *out, const RomPathChar *path) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomDirectoryEntry parent_entry = {};
|
|
EntryKey key = {};
|
|
R_TRY(this->FindDirectoryRecursive(std::addressof(key), std::addressof(parent_entry), path));
|
|
|
|
return this->FindOpen(out, key);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindOpen(FindPosition *out, RomDirectoryId id) {
|
|
AMS_ASSERT(out != nullptr);
|
|
|
|
out->next_dir = InvalidPosition;
|
|
out->next_file = InvalidPosition;
|
|
|
|
RomDirectoryEntry entry = {};
|
|
R_TRY(this->GetDirectoryEntry(std::addressof(entry), id));
|
|
|
|
out->next_dir = entry.dir;
|
|
out->next_file = entry.file;
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindNextDirectory(RomPathChar *out, FindPosition *find, size_t length) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(find != nullptr);
|
|
AMS_ASSERT(length > RomPathTool::MaxPathLength);
|
|
|
|
R_UNLESS(find->next_dir != InvalidPosition, fs::ResultDbmFindFinished());
|
|
|
|
RomEntryKey key = {};
|
|
RomDirectoryEntry entry = {};
|
|
size_t aux_size = 0;
|
|
R_TRY(this->dir_table.GetByPosition(std::addressof(key), std::addressof(entry), out, std::addressof(aux_size), find->next_dir));
|
|
AMS_ASSERT(aux_size / sizeof(RomPathChar) <= RomPathTool::MaxPathLength);
|
|
|
|
out[aux_size / sizeof(RomPathChar)] = RomStringTraits::NullTerminator;
|
|
|
|
find->next_dir = entry.next;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindNextFile(RomPathChar *out, FindPosition *find, size_t length) {
|
|
AMS_ASSERT(out != nullptr);
|
|
AMS_ASSERT(find != nullptr);
|
|
AMS_ASSERT(length > RomPathTool::MaxPathLength);
|
|
|
|
R_UNLESS(find->next_file != InvalidPosition, fs::ResultDbmFindFinished());
|
|
|
|
RomEntryKey key = {};
|
|
RomFileEntry entry = {};
|
|
size_t aux_size = 0;
|
|
R_TRY(this->file_table.GetByPosition(std::addressof(key), std::addressof(entry), out, std::addressof(aux_size), find->next_file));
|
|
AMS_ASSERT(aux_size / sizeof(RomPathChar) <= RomPathTool::MaxPathLength);
|
|
|
|
out[aux_size / sizeof(RomPathChar)] = RomStringTraits::NullTerminator;
|
|
|
|
find->next_file = entry.next;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::QueryRomFileSystemSize(s64 *out_dir_entry_size, s64 *out_file_entry_size) {
|
|
AMS_ASSERT(out_dir_entry_size != nullptr);
|
|
AMS_ASSERT(out_file_entry_size != nullptr);
|
|
|
|
*out_dir_entry_size = this->dir_table.GetTotalEntrySize();
|
|
*out_file_entry_size = this->file_table.GetTotalEntrySize();
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetGrandParent(Position *out_pos, EntryKey *out_dir_key, RomDirectoryEntry *out_dir_entry, Position pos, RomPathTool::RomEntryName name, const RomPathChar *path) {
|
|
AMS_ASSERT(out_pos != nullptr);
|
|
AMS_ASSERT(out_dir_key != nullptr);
|
|
AMS_ASSERT(out_dir_entry != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomEntryKey gp_key = {};
|
|
RomDirectoryEntry gp_entry = {};
|
|
R_TRY(this->dir_table.GetByPosition(std::addressof(gp_key), std::addressof(gp_entry), pos));
|
|
out_dir_key->key.parent = gp_key.parent;
|
|
|
|
R_TRY(RomPathTool::GetParentDirectoryName(std::addressof(out_dir_key->name), name, path));
|
|
|
|
R_TRY(this->GetDirectoryEntry(out_pos, out_dir_entry, *out_dir_key));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindParentDirectoryRecursive(Position *out_pos, EntryKey *out_dir_key, RomDirectoryEntry *out_dir_entry, RomPathTool::PathParser *parser, const RomPathChar *path) {
|
|
AMS_ASSERT(out_pos != nullptr);
|
|
AMS_ASSERT(out_dir_key != nullptr);
|
|
AMS_ASSERT(out_dir_entry != nullptr);
|
|
AMS_ASSERT(parser != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
Position dir_pos = RootPosition;
|
|
EntryKey dir_key = {};
|
|
RomDirectoryEntry dir_entry = {};
|
|
dir_key.key.parent = RootPosition;
|
|
|
|
R_TRY(parser->GetNextDirectoryName(std::addressof(dir_key.name)));
|
|
R_TRY(this->GetDirectoryEntry(std::addressof(dir_pos), std::addressof(dir_entry), dir_key));
|
|
|
|
Position parent_pos = dir_pos;
|
|
while (!parser->IsFinished()) {
|
|
EntryKey old_key = dir_key;
|
|
|
|
R_TRY(parser->GetNextDirectoryName(std::addressof(dir_key.name)));
|
|
|
|
if (RomPathTool::IsCurrentDirectory(dir_key.name)) {
|
|
dir_key = old_key;
|
|
continue;
|
|
} else if (RomPathTool::IsParentDirectory(dir_key.name)) {
|
|
R_UNLESS(parent_pos != RootPosition, fs::ResultDirectoryUnobtainable());
|
|
|
|
R_TRY(this->GetGrandParent(std::addressof(parent_pos), std::addressof(dir_key), std::addressof(dir_entry), dir_key.key.parent, dir_key.name, path));
|
|
} else {
|
|
dir_key.key.parent = parent_pos;
|
|
R_TRY_CATCH(this->GetDirectoryEntry(std::addressof(dir_pos), std::addressof(dir_entry), dir_key)) {
|
|
R_CONVERT(fs::ResultDbmInvalidOperation, fs::ResultDbmNotFound())
|
|
} R_END_TRY_CATCH;
|
|
|
|
parent_pos = dir_pos;
|
|
}
|
|
}
|
|
|
|
*out_pos = parent_pos;
|
|
*out_dir_key = dir_key;
|
|
*out_dir_entry = dir_entry;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindPathRecursive(EntryKey *out_key, RomDirectoryEntry *out_dir_entry, bool is_dir, const RomPathChar *path) {
|
|
AMS_ASSERT(out_key != nullptr);
|
|
AMS_ASSERT(out_dir_entry != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
RomPathTool::PathParser parser;
|
|
R_TRY(parser.Initialize(path));
|
|
|
|
EntryKey parent_key = {};
|
|
Position parent_pos = 0;
|
|
R_TRY(this->FindParentDirectoryRecursive(std::addressof(parent_pos), std::addressof(parent_key), out_dir_entry, std::addressof(parser), path));
|
|
|
|
if (is_dir) {
|
|
RomPathTool::RomEntryName name = {};
|
|
R_TRY(parser.GetAsDirectoryName(std::addressof(name)));
|
|
|
|
if (RomPathTool::IsCurrentDirectory(name)) {
|
|
*out_key = parent_key;
|
|
if (out_key->key.parent != RootPosition) {
|
|
Position pos = 0;
|
|
R_TRY(this->GetGrandParent(std::addressof(pos), std::addressof(parent_key), out_dir_entry, out_key->key.parent, out_key->name, path));
|
|
}
|
|
} else if (RomPathTool::IsParentDirectory(name)) {
|
|
R_UNLESS(parent_pos != RootPosition, fs::ResultDirectoryUnobtainable());
|
|
|
|
Position pos = 0;
|
|
RomDirectoryEntry cur_entry = {};
|
|
R_TRY(this->GetGrandParent(std::addressof(pos), out_key, std::addressof(cur_entry), parent_key.key.parent, parent_key.name, path));
|
|
|
|
if (out_key->key.parent != RootPosition) {
|
|
R_TRY(this->GetGrandParent(std::addressof(pos), std::addressof(parent_key), out_dir_entry, out_key->key.parent, out_key->name, path));
|
|
}
|
|
} else {
|
|
out_key->name = name;
|
|
out_key->key.parent = (out_key->name.length > 0) ? parent_pos : RootPosition;
|
|
}
|
|
} else {
|
|
{
|
|
RomPathTool::RomEntryName name = {};
|
|
R_TRY(parser.GetAsDirectoryName(std::addressof(name)));
|
|
R_UNLESS(!RomPathTool::IsParentDirectory(name) || parent_pos != RootPosition, fs::ResultDirectoryUnobtainable());
|
|
}
|
|
|
|
R_UNLESS(!parser.IsDirectoryPath(), fs::ResultDbmInvalidOperation());
|
|
|
|
out_key->key.parent = parent_pos;
|
|
R_TRY(parser.GetAsFileName(std::addressof(out_key->name)));
|
|
}
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindDirectoryRecursive(EntryKey *out_key, RomDirectoryEntry *out_dir_entry, const RomPathChar *path) {
|
|
AMS_ASSERT(out_key != nullptr);
|
|
AMS_ASSERT(out_dir_entry != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
return this->FindPathRecursive(out_key, out_dir_entry, true, path);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindFileRecursive(EntryKey *out_key, RomDirectoryEntry *out_dir_entry, const RomPathChar *path) {
|
|
AMS_ASSERT(out_key != nullptr);
|
|
AMS_ASSERT(out_dir_entry != nullptr);
|
|
AMS_ASSERT(path != nullptr);
|
|
|
|
return this->FindPathRecursive(out_key, out_dir_entry, false, path);
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::CheckSameEntryExists(const EntryKey &key, Result if_exists) {
|
|
/* Check dir */
|
|
{
|
|
Position pos = InvalidPosition;
|
|
RomDirectoryEntry entry = {};
|
|
const Result get_res = this->dir_table.Get(std::addressof(pos), std::addressof(entry), key);
|
|
if (!fs::ResultDbmKeyNotFound::Includes(get_res)) {
|
|
R_TRY(get_res);
|
|
return if_exists;
|
|
}
|
|
}
|
|
|
|
/* Check file */
|
|
{
|
|
Position pos = InvalidPosition;
|
|
RomFileEntry entry = {};
|
|
const Result get_res = this->file_table.Get(std::addressof(pos), std::addressof(entry), key);
|
|
if (!fs::ResultDbmKeyNotFound::Includes(get_res)) {
|
|
R_TRY(get_res);
|
|
return if_exists;
|
|
}
|
|
}
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetDirectoryEntry(Position *out_pos, RomDirectoryEntry *out_entry, const EntryKey &key) {
|
|
AMS_ASSERT(out_pos != nullptr);
|
|
AMS_ASSERT(out_entry != nullptr);
|
|
|
|
const Result dir_res = this->dir_table.Get(out_pos, out_entry, key);
|
|
R_UNLESS(R_FAILED(dir_res), dir_res);
|
|
R_UNLESS(fs::ResultDbmKeyNotFound::Includes(dir_res), dir_res);
|
|
|
|
Position pos = 0;
|
|
RomFileEntry entry = {};
|
|
const Result file_res = this->file_table.Get(std::addressof(pos), std::addressof(entry), key);
|
|
R_UNLESS(R_FAILED(file_res), fs::ResultDbmInvalidOperation());
|
|
R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(file_res), fs::ResultDbmDirectoryNotFound());
|
|
return file_res;
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetDirectoryEntry(RomDirectoryEntry *out_entry, RomDirectoryId id) {
|
|
AMS_ASSERT(out_entry != nullptr);
|
|
Position pos = ConvertToPosition(id);
|
|
|
|
RomEntryKey key = {};
|
|
const Result dir_res = this->dir_table.GetByPosition(std::addressof(key), out_entry, pos);
|
|
R_UNLESS(R_FAILED(dir_res), dir_res);
|
|
R_UNLESS(fs::ResultDbmKeyNotFound::Includes(dir_res), dir_res);
|
|
|
|
RomFileEntry entry = {};
|
|
const Result file_res = this->file_table.GetByPosition(std::addressof(key), std::addressof(entry), pos);
|
|
R_UNLESS(R_FAILED(file_res), fs::ResultDbmInvalidOperation());
|
|
R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(file_res), fs::ResultDbmDirectoryNotFound());
|
|
return file_res;
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetFileEntry(Position *out_pos, RomFileEntry *out_entry, const EntryKey &key) {
|
|
AMS_ASSERT(out_pos != nullptr);
|
|
AMS_ASSERT(out_entry != nullptr);
|
|
|
|
const Result file_res = this->file_table.Get(out_pos, out_entry, key);
|
|
R_UNLESS(R_FAILED(file_res), file_res);
|
|
R_UNLESS(fs::ResultDbmKeyNotFound::Includes(file_res), file_res);
|
|
|
|
Position pos = 0;
|
|
RomDirectoryEntry entry = {};
|
|
const Result dir_res = this->dir_table.Get(std::addressof(pos), std::addressof(entry), key);
|
|
R_UNLESS(R_FAILED(dir_res), fs::ResultDbmInvalidOperation());
|
|
R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(dir_res), fs::ResultDbmFileNotFound());
|
|
return dir_res;
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetFileEntry(RomFileEntry *out_entry, RomFileId id) {
|
|
AMS_ASSERT(out_entry != nullptr);
|
|
Position pos = ConvertToPosition(id);
|
|
|
|
RomEntryKey key = {};
|
|
const Result file_res = this->file_table.GetByPosition(std::addressof(key), out_entry, pos);
|
|
R_UNLESS(R_FAILED(file_res), file_res);
|
|
R_UNLESS(fs::ResultDbmKeyNotFound::Includes(file_res), file_res);
|
|
|
|
RomDirectoryEntry entry = {};
|
|
const Result dir_res = this->dir_table.GetByPosition(std::addressof(key), std::addressof(entry), pos);
|
|
R_UNLESS(R_FAILED(dir_res), fs::ResultDbmInvalidOperation());
|
|
R_UNLESS(!fs::ResultDbmKeyNotFound::Includes(dir_res), fs::ResultDbmFileNotFound());
|
|
return dir_res;
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::GetDirectoryInformation(DirectoryInfo *out, const EntryKey &key) {
|
|
AMS_ASSERT(out != nullptr);
|
|
|
|
Position pos = 0;
|
|
RomDirectoryEntry entry = {};
|
|
R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key));
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::OpenFile(FileInfo *out, const EntryKey &key) {
|
|
AMS_ASSERT(out != nullptr);
|
|
|
|
Position pos = 0;
|
|
RomFileEntry entry = {};
|
|
R_TRY(this->GetFileEntry(std::addressof(pos), std::addressof(entry), key));
|
|
|
|
*out = entry.info;
|
|
return ResultSuccess();
|
|
}
|
|
|
|
Result HierarchicalRomFileTable::FindOpen(FindPosition *out, const EntryKey &key) {
|
|
AMS_ASSERT(out != nullptr);
|
|
|
|
out->next_dir = InvalidPosition;
|
|
out->next_file = InvalidPosition;
|
|
|
|
Position pos = 0;
|
|
RomDirectoryEntry entry = {};
|
|
R_TRY(this->GetDirectoryEntry(std::addressof(pos), std::addressof(entry), key));
|
|
|
|
out->next_dir = entry.dir;
|
|
out->next_file = entry.file;
|
|
|
|
return ResultSuccess();
|
|
}
|
|
|
|
} |