/* * Copyright (c) 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 #include namespace ams::fs { namespace { class ReadOnlyFile : public fsa::IFile, public impl::Newable { NON_COPYABLE(ReadOnlyFile); NON_MOVEABLE(ReadOnlyFile); private: std::unique_ptr m_base_file; public: explicit ReadOnlyFile(std::unique_ptr &&f) : m_base_file(std::move(f)) { AMS_ASSERT(m_base_file != nullptr); } virtual ~ReadOnlyFile() { /* ... */ } private: virtual Result DoRead(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) override final { return m_base_file->Read(out, offset, buffer, size, option); } virtual Result DoGetSize(s64 *out) override final { return m_base_file->GetSize(out); } virtual Result DoFlush() override final { return ResultSuccess(); } virtual Result DoWrite(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override final { bool need_append; R_TRY(this->DryWrite(std::addressof(need_append), offset, size, option, fs::OpenMode_Read)); AMS_ASSERT(!need_append); AMS_UNUSED(buffer); return fs::ResultUnsupportedWriteForReadOnlyFile(); } virtual Result DoSetSize(s64 size) override final { R_TRY(this->DrySetSize(size, fs::OpenMode_Read)); return fs::ResultUnsupportedWriteForReadOnlyFile(); } virtual Result DoOperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override final { switch (op_id) { case OperationId::Invalidate: case OperationId::QueryRange: return m_base_file->OperateRange(dst, dst_size, op_id, offset, size, src, src_size); default: return fs::ResultUnsupportedOperateRangeForReadOnlyFile(); } } public: virtual sf::cmif::DomainObjectId GetDomainObjectId() const override { return m_base_file->GetDomainObjectId(); } }; } template class ReadOnlyFileSystemTemplate : public fsa::IFileSystem, public impl::Newable { NON_COPYABLE(ReadOnlyFileSystemTemplate); NON_MOVEABLE(ReadOnlyFileSystemTemplate); private: T m_base_fs; public: explicit ReadOnlyFileSystemTemplate(T &&fs) : m_base_fs(std::move(fs)) { /* ... */ } virtual ~ReadOnlyFileSystemTemplate() { /* ... */ } private: virtual Result DoOpenFile(std::unique_ptr *out_file, const fs::Path &path, OpenMode mode) override final { /* Only allow opening files with mode = read. */ R_UNLESS((mode & fs::OpenMode_All) == fs::OpenMode_Read, fs::ResultInvalidOpenMode()); std::unique_ptr base_file; R_TRY(m_base_fs->OpenFile(std::addressof(base_file), path, mode)); auto read_only_file = std::make_unique(std::move(base_file)); R_UNLESS(read_only_file != nullptr, fs::ResultAllocationFailureInReadOnlyFileSystemA()); *out_file = std::move(read_only_file); return ResultSuccess(); } virtual Result DoOpenDirectory(std::unique_ptr *out_dir, const fs::Path &path, OpenDirectoryMode mode) override final { return m_base_fs->OpenDirectory(out_dir, path, mode); } virtual Result DoGetEntryType(DirectoryEntryType *out, const fs::Path &path) override final { return m_base_fs->GetEntryType(out, path); } virtual Result DoCommit() override final { return ResultSuccess(); } virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) override final { AMS_UNUSED(path, size, flags); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoDeleteFile(const fs::Path &path) override final { AMS_UNUSED(path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoCreateDirectory(const fs::Path &path) override final { AMS_UNUSED(path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoDeleteDirectory(const fs::Path &path) override final { AMS_UNUSED(path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) override final { AMS_UNUSED(path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) override final { AMS_UNUSED(old_path, new_path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) override final { AMS_UNUSED(old_path, new_path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoCleanDirectoryRecursively(const fs::Path &path) override final { AMS_UNUSED(path); return fs::ResultUnsupportedWriteForReadOnlyFileSystem(); } virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) override final { AMS_UNUSED(out, path); return fs::ResultUnsupportedCommitProvisionallyForReadOnlyFileSystem(); } virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) override final { AMS_UNUSED(out, path); return fs::ResultUnsupportedCommitProvisionallyForReadOnlyFileSystem(); } virtual Result DoCommitProvisionally(s64 counter) override final { AMS_UNUSED(counter); return fs::ResultUnsupportedGetTotalSpaceSizeForReadOnlyFileSystem(); } }; using ReadOnlyFileSystem = ReadOnlyFileSystemTemplate>; using ReadOnlyFileSystemShared = ReadOnlyFileSystemTemplate>; }