diff --git a/libstratosphere/include/stratosphere/fs.hpp b/libstratosphere/include/stratosphere/fs.hpp index 60e62d90..76c844a9 100644 --- a/libstratosphere/include/stratosphere/fs.hpp +++ b/libstratosphere/include/stratosphere/fs.hpp @@ -15,14 +15,15 @@ */ #pragma once -#include "fs/fs_common.hpp" -#include "fs/fsa/fs_ifile.hpp" -#include "fs/fsa/fs_idirectory.hpp" -#include "fs/fsa/fs_ifilesystem.hpp" -#include "fs/fs_remote_filesystem.hpp" -#include "fs/fs_istorage.hpp" -#include "fs/fs_remote_storage.hpp" -#include "fs/fs_file_storage.hpp" -#include "fs/fs_query_range.hpp" -#include "fs/fs_path_tool.hpp" -#include "fs/fs_path_utils.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/libstratosphere/include/stratosphere/fs/fs_readonly_filesystem_adapter.hpp b/libstratosphere/include/stratosphere/fs/fs_readonly_filesystem_adapter.hpp new file mode 100644 index 00000000..9c3c031d --- /dev/null +++ b/libstratosphere/include/stratosphere/fs/fs_readonly_filesystem_adapter.hpp @@ -0,0 +1,152 @@ +/* + * 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 . + */ +#pragma once +#include +#include +#include +#include + +namespace ams::fs { + + class ReadOnlyFileAdapter : public fsa::IFile { + NON_COPYABLE(ReadOnlyFileAdapter); + private: + std::unique_ptr base_file; + public: + ReadOnlyFileAdapter(fsa::IFile *f) : base_file(f) { /* ... */ } + ReadOnlyFileAdapter(std::unique_ptr f) : base_file(std::move(f)) { /* ... */ } + virtual ~ReadOnlyFileAdapter() { /* ... */ } + public: + virtual Result ReadImpl(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) override final { + /* Ensure that we can read these extents. */ + size_t read_size = 0; + R_TRY(this->DryRead(std::addressof(read_size), offset, size, option, fs::OpenMode_Read)); + + /* Validate preconditions. */ + AMS_ASSERT(offset >= 0); + AMS_ASSERT(buffer != nullptr || size == 0); + + return this->base_file->Read(out, offset, buffer, size, option); + } + + virtual Result GetSizeImpl(s64 *out) override final { + return this->base_file->GetSize(out); + } + + virtual Result FlushImpl() override final { + return ResultSuccess(); + } + + virtual Result WriteImpl(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result SetSizeImpl(s64 size) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result OperateRangeImpl(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override final { + /* TODO: How should this be handled? */ + return fs::ResultNotImplemented(); + } + public: + virtual sf::cmif::DomainObjectId GetDomainObjectId() const override { + return this->base_file->GetDomainObjectId(); + } + }; + + class ReadOnlyFileSystemAdapter : public fsa::IFileSystem { + NON_COPYABLE(ReadOnlyFileSystemAdapter); + private: + std::shared_ptr shared_fs; + std::unique_ptr unique_fs; + protected: + fsa::IFileSystem * const base_fs; + public: + template + explicit ReadOnlyFileSystemAdapter(std::shared_ptr fs) : shared_fs(std::move(fs)), base_fs(shared_fs.get()) { static_assert(std::is_base_of::value); } + + template + explicit ReadOnlyFileSystemAdapter(std::unique_ptr fs) : unique_fs(std::move(fs)), base_fs(unique_fs.get()) { static_assert(std::is_base_of::value); } + + virtual ~ReadOnlyFileSystemAdapter() { /* ... */ } + public: + virtual Result CreateFileImpl(const char *path, s64 size, int flags) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result DeleteFileImpl(const char *path) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result CreateDirectoryImpl(const char *path) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result DeleteDirectoryImpl(const char *path) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result DeleteDirectoryRecursivelyImpl(const char *path) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result RenameFileImpl(const char *old_path, const char *new_path) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result RenameDirectoryImpl(const char *old_path, const char *new_path) override final { + return fs::ResultUnsupportedOperation(); + } + + virtual Result GetEntryTypeImpl(DirectoryEntryType *out, const char *path) override final { + return this->base_fs->GetEntryType(out, path); + } + + virtual Result OpenFileImpl(std::unique_ptr *out_file, const char *path, OpenMode mode) override final { + std::unique_ptr f; + R_TRY(this->base_fs->OpenFile(std::addressof(f), path, mode)); + + *out_file = std::make_unique(std::move(f)); + return ResultSuccess(); + } + + virtual Result OpenDirectoryImpl(std::unique_ptr *out_dir, const char *path, OpenDirectoryMode mode) override final { + return this->base_fs->OpenDirectory(out_dir, path, mode); + } + + virtual Result CommitImpl() override final { + return ResultSuccess(); + } + + virtual Result GetFreeSpaceSizeImpl(s64 *out, const char *path) { + return fs::ResultUnsupportedOperation(); + } + + virtual Result GetTotalSpaceSizeImpl(s64 *out, const char *path) { + return fs::ResultUnsupportedOperation(); + } + + virtual Result CleanDirectoryRecursivelyImpl(const char *path) { + return fs::ResultUnsupportedOperation(); + } + + virtual Result GetFileTimeStampRawImpl(FileTimeStampRaw *out, const char *path) { + return this->base_fs->GetFileTimeStampRaw(out, path); + } + }; + +} diff --git a/libstratosphere/include/stratosphere/fs/fsa/fs_ifile.hpp b/libstratosphere/include/stratosphere/fs/fsa/fs_ifile.hpp index 77e59d6f..0d474604 100644 --- a/libstratosphere/include/stratosphere/fs/fsa/fs_ifile.hpp +++ b/libstratosphere/include/stratosphere/fs/fsa/fs_ifile.hpp @@ -16,6 +16,7 @@ #pragma once #include "../fs_common.hpp" #include "../fs_file.hpp" +#include "../fs_filesystem.hpp" #include "../fs_operate_range.hpp" namespace ams::fs::fsa { @@ -82,7 +83,25 @@ namespace ams::fs::fsa { /* TODO: This is a hack to allow the mitm API to work. Find a better way? */ virtual sf::cmif::DomainObjectId GetDomainObjectId() const = 0; protected: - /* ...? */ + Result DryRead(size_t *out, s64 offset, size_t size, const fs::ReadOption &option, OpenMode open_mode) { + /* Check that we can read. */ + R_UNLESS((open_mode & OpenMode_Read) != 0, fs::ResultInvalidOperationForOpenMode()); + + /* Get the file size, and validate our offset. */ + s64 file_size = 0; + R_TRY(this->GetSize(&file_size)); + R_UNLESS(offset <= file_size, fs::ResultOutOfRange()); + + *out = static_cast(std::min(file_size - offset, static_cast(size))); + return ResultSuccess(); + } + + Result DrySetSize(s64 size, OpenMode open_mode) { + /* Check that we can write. */ + R_UNLESS((open_mode & OpenMode_Write) != 0, fs::ResultInvalidOperationForOpenMode()); + + return ResultSuccess(); + } private: virtual Result ReadImpl(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) = 0; virtual Result GetSizeImpl(s64 *out) = 0;