mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2024-12-05 04:28:04 +01:00
180 lines
7.7 KiB
C++
180 lines
7.7 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/>.
|
|
*/
|
|
#pragma once
|
|
#include "fs_common.hpp"
|
|
#include "fsa/fs_ifile.hpp"
|
|
#include "fsa/fs_idirectory.hpp"
|
|
#include "fsa/fs_ifilesystem.hpp"
|
|
|
|
namespace ams::fs {
|
|
|
|
class RemoteFile : public fsa::IFile {
|
|
private:
|
|
std::unique_ptr<::FsFile> base_file;
|
|
public:
|
|
RemoteFile(::FsFile *f) : base_file(f) { /* ... */ }
|
|
RemoteFile(std::unique_ptr<::FsFile> f) : base_file(std::move(f)) { /* ... */ }
|
|
RemoteFile(::FsFile f) {
|
|
this->base_file = std::make_unique<::FsFile>(f);
|
|
}
|
|
|
|
virtual ~RemoteFile() { fsFileClose(this->base_file.get()); }
|
|
public:
|
|
virtual Result ReadImpl(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) override final {
|
|
return fsFileRead(this->base_file.get(), offset, buffer, size, option.value, out);
|
|
}
|
|
|
|
virtual Result GetSizeImpl(s64 *out) override final {
|
|
return fsFileGetSize(this->base_file.get(), out);
|
|
}
|
|
|
|
virtual Result FlushImpl() override final {
|
|
return fsFileFlush(this->base_file.get());
|
|
}
|
|
|
|
virtual Result WriteImpl(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override final {
|
|
return fsFileWrite(this->base_file.get(), offset, buffer, size, option.value);
|
|
}
|
|
|
|
virtual Result SetSizeImpl(s64 size) override final {
|
|
return fsFileSetSize(this->base_file.get(), size);
|
|
}
|
|
|
|
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 sf::cmif::DomainObjectId{serviceGetObjectId(&this->base_file->s)};
|
|
}
|
|
};
|
|
|
|
class RemoteDirectory : public fsa::IDirectory {
|
|
private:
|
|
std::unique_ptr<::FsDir> base_dir;
|
|
public:
|
|
RemoteDirectory(::FsDir *d) : base_dir(d) { /* ... */ }
|
|
RemoteDirectory(std::unique_ptr<::FsDir> d) : base_dir(std::move(d)) { /* ... */ }
|
|
RemoteDirectory(::FsDir d) {
|
|
this->base_dir = std::make_unique<::FsDir>(d);
|
|
}
|
|
|
|
virtual ~RemoteDirectory() { fsDirClose(this->base_dir.get()); }
|
|
public:
|
|
virtual Result ReadImpl(s64 *out_count, DirectoryEntry *out_entries, s64 max_entries) override final {
|
|
return fsDirRead(this->base_dir.get(), out_count, max_entries, out_entries);
|
|
}
|
|
|
|
virtual Result GetEntryCountImpl(s64 *out) override final {
|
|
return fsDirGetEntryCount(this->base_dir.get(), out);
|
|
}
|
|
public:
|
|
virtual sf::cmif::DomainObjectId GetDomainObjectId() const override {
|
|
return sf::cmif::DomainObjectId{serviceGetObjectId(&this->base_dir->s)};
|
|
}
|
|
};
|
|
|
|
class RemoteFileSystem : public fsa::IFileSystem {
|
|
private:
|
|
std::unique_ptr<::FsFileSystem> base_fs;
|
|
public:
|
|
RemoteFileSystem(::FsFileSystem *fs) : base_fs(fs) { /* ... */ }
|
|
RemoteFileSystem(std::unique_ptr<::FsFileSystem> fs) : base_fs(std::move(fs)) { /* ... */ }
|
|
RemoteFileSystem(::FsFileSystem fs) {
|
|
this->base_fs = std::make_unique<::FsFileSystem>(fs);
|
|
}
|
|
|
|
virtual ~RemoteFileSystem() { fsFsClose(this->base_fs.get()); }
|
|
public:
|
|
virtual Result CreateFileImpl(const char *path, s64 size, int flags) override final {
|
|
return fsFsCreateFile(this->base_fs.get(), path, size, flags);
|
|
}
|
|
|
|
virtual Result DeleteFileImpl(const char *path) override final {
|
|
return fsFsDeleteFile(this->base_fs.get(), path);
|
|
}
|
|
|
|
virtual Result CreateDirectoryImpl(const char *path) override final {
|
|
return fsFsCreateDirectory(this->base_fs.get(), path);
|
|
}
|
|
|
|
virtual Result DeleteDirectoryImpl(const char *path) override final {
|
|
return fsFsDeleteDirectory(this->base_fs.get(), path);
|
|
}
|
|
|
|
virtual Result DeleteDirectoryRecursivelyImpl(const char *path) override final {
|
|
return fsFsDeleteDirectoryRecursively(this->base_fs.get(), path);
|
|
}
|
|
|
|
virtual Result RenameFileImpl(const char *old_path, const char *new_path) override final {
|
|
return fsFsRenameFile(this->base_fs.get(), old_path, new_path);
|
|
}
|
|
|
|
virtual Result RenameDirectoryImpl(const char *old_path, const char *new_path) override final {
|
|
return fsFsRenameDirectory(this->base_fs.get(), old_path, new_path);
|
|
}
|
|
|
|
virtual Result GetEntryTypeImpl(DirectoryEntryType *out, const char *path) override final {
|
|
static_assert(sizeof(::FsDirEntryType) == sizeof(DirectoryEntryType));
|
|
return fsFsGetEntryType(this->base_fs.get(), path, reinterpret_cast<::FsDirEntryType *>(out));
|
|
}
|
|
|
|
virtual Result OpenFileImpl(std::unique_ptr<fsa::IFile> *out_file, const char *path, OpenMode mode) override final {
|
|
FsFile f;
|
|
R_TRY(fsFsOpenFile(this->base_fs.get(), path, mode, &f));
|
|
|
|
*out_file = std::make_unique<RemoteFile>(f);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
virtual Result OpenDirectoryImpl(std::unique_ptr<fsa::IDirectory> *out_dir, const char *path, OpenDirectoryMode mode) override final {
|
|
FsDir d;
|
|
R_TRY(fsFsOpenDirectory(this->base_fs.get(), path, mode, &d));
|
|
|
|
*out_dir = std::make_unique<RemoteDirectory>(d);
|
|
return ResultSuccess();
|
|
}
|
|
|
|
virtual Result CommitImpl() override final {
|
|
return fsFsCommit(this->base_fs.get());
|
|
}
|
|
|
|
|
|
virtual Result GetFreeSpaceSizeImpl(s64 *out, const char *path) {
|
|
return fsFsGetFreeSpace(this->base_fs.get(), path, out);
|
|
}
|
|
|
|
virtual Result GetTotalSpaceSizeImpl(s64 *out, const char *path) {
|
|
return fsFsGetTotalSpace(this->base_fs.get(), path, out);
|
|
}
|
|
|
|
virtual Result CleanDirectoryRecursivelyImpl(const char *path) {
|
|
return fsFsCleanDirectoryRecursively(this->base_fs.get(), path);
|
|
}
|
|
|
|
virtual Result GetFileTimeStampRawImpl(FileTimeStampRaw *out, const char *path) {
|
|
static_assert(sizeof(FileTimeStampRaw) == sizeof(::FsTimeStampRaw));
|
|
return fsFsGetFileTimeStampRaw(this->base_fs.get(), path, reinterpret_cast<::FsTimeStampRaw *>(out));
|
|
}
|
|
|
|
virtual Result QueryEntryImpl(char *dst, size_t dst_size, const char *src, size_t src_size, fsa::QueryId query, const char *path) {
|
|
return fsFsQueryEntry(this->base_fs.get(), dst, dst_size, src, src_size, path, static_cast<FsFileSystemQueryId>(query));
|
|
}
|
|
};
|
|
|
|
}
|