fs.mitm: implement layered html redirection (closes #814)

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 <stratosphere/fs/fs_common.hpp>
+#include <stratosphere/fs/fsa/fs_ifile.hpp>
+#include <stratosphere/fs/fsa/fs_idirectory.hpp>
+#include <stratosphere/fs/fsa/fs_ifilesystem.hpp>
+#include <stratosphere/fs/fs_remote_filesystem.hpp>
+#include <stratosphere/fs/fs_readonly_filesystem_adapter.hpp>
+#include <stratosphere/fs/fs_istorage.hpp>
+#include <stratosphere/fs/fs_remote_storage.hpp>
+#include <stratosphere/fs/fs_file_storage.hpp>
+#include <stratosphere/fs/fs_query_range.hpp>
+#include <stratosphere/fs/fs_path_tool.hpp>
+#include <stratosphere/fs/fs_path_utils.hpp>

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 <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere/fs/fs_common.hpp>
+#include <stratosphere/fs/fsa/fs_ifile.hpp>
+#include <stratosphere/fs/fsa/fs_idirectory.hpp>
+#include <stratosphere/fs/fsa/fs_ifilesystem.hpp>
+
+namespace ams::fs {
+
+    class ReadOnlyFileAdapter : public fsa::IFile {
+        NON_COPYABLE(ReadOnlyFileAdapter);
+        private:
+            std::unique_ptr<fsa::IFile> base_file;
+        public:
+            ReadOnlyFileAdapter(fsa::IFile *f) : base_file(f) { /* ... */ }
+            ReadOnlyFileAdapter(std::unique_ptr<fsa::IFile> 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<fsa::IFileSystem> shared_fs;
+            std::unique_ptr<fsa::IFileSystem> unique_fs;
+        protected:
+            fsa::IFileSystem * const base_fs;
+        public:
+            template<typename T>
+            explicit ReadOnlyFileSystemAdapter(std::shared_ptr<T> fs) : shared_fs(std::move(fs)), base_fs(shared_fs.get())  { static_assert(std::is_base_of<fsa::IFileSystem, T>::value); }
+
+            template<typename T>
+            explicit ReadOnlyFileSystemAdapter(std::unique_ptr<T> fs) : unique_fs(std::move(fs)), base_fs(unique_fs.get())  { static_assert(std::is_base_of<fsa::IFileSystem, T>::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<fsa::IFile> *out_file, const char *path, OpenMode mode) override final {
+                std::unique_ptr<fsa::IFile> f;
+                R_TRY(this->base_fs->OpenFile(std::addressof(f), path, mode));
+
+                *out_file = std::make_unique<ReadOnlyFileAdapter>(std::move(f));
+                return ResultSuccess();
+            }
+
+            virtual Result OpenDirectoryImpl(std::unique_ptr<fsa::IDirectory> *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);
+            }
+    };
+
+}

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<size_t>(std::min(file_size - offset, static_cast<s64>(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;