2014-06-27 20:18:56 +00:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
2014-12-17 05:38:14 +00:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-06-27 20:18:56 +00:00
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2014-09-11 22:42:59 +00:00
|
|
|
#include <memory>
|
2015-05-06 05:15:46 +00:00
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
|
|
|
#include <vector>
|
2020-01-10 23:47:39 +00:00
|
|
|
#include <boost/serialization/string.hpp>
|
|
|
|
#include <boost/serialization/vector.hpp>
|
2015-05-06 05:15:46 +00:00
|
|
|
#include "common/bit_field.h"
|
2014-06-27 20:18:56 +00:00
|
|
|
#include "common/common_types.h"
|
2016-03-03 18:05:50 +00:00
|
|
|
#include "common/swap.h"
|
2018-11-02 22:08:34 +00:00
|
|
|
#include "core/file_sys/delay_generator.h"
|
2015-05-06 05:15:46 +00:00
|
|
|
#include "core/hle/result.h"
|
2014-06-27 20:18:56 +00:00
|
|
|
|
|
|
|
namespace FileSys {
|
|
|
|
|
2015-05-06 05:15:46 +00:00
|
|
|
class FileBackend;
|
|
|
|
class DirectoryBackend;
|
|
|
|
|
2014-11-10 22:36:32 +00:00
|
|
|
// Path string type
|
2017-12-12 22:41:36 +00:00
|
|
|
enum class LowPathType : u32 {
|
2016-09-19 01:01:46 +00:00
|
|
|
Invalid = 0,
|
|
|
|
Empty = 1,
|
|
|
|
Binary = 2,
|
|
|
|
Char = 3,
|
|
|
|
Wchar = 4,
|
|
|
|
};
|
2014-11-10 22:36:32 +00:00
|
|
|
|
2014-09-11 22:42:59 +00:00
|
|
|
union Mode {
|
|
|
|
u32 hex;
|
|
|
|
BitField<0, 1, u32> read_flag;
|
|
|
|
BitField<1, 1, u32> write_flag;
|
|
|
|
BitField<2, 1, u32> create_flag;
|
|
|
|
};
|
|
|
|
|
2014-11-10 22:36:32 +00:00
|
|
|
class Path {
|
|
|
|
public:
|
2017-12-12 22:41:36 +00:00
|
|
|
Path() : type(LowPathType::Invalid) {}
|
|
|
|
Path(const char* path) : type(LowPathType::Char), string(path) {}
|
|
|
|
Path(std::vector<u8> binary_data) : type(LowPathType::Binary), binary(std::move(binary_data)) {}
|
2019-02-15 18:20:06 +00:00
|
|
|
template <std::size_t size>
|
2019-04-07 13:58:42 +00:00
|
|
|
Path(const std::array<u8, size>& binary_data)
|
2019-02-15 18:20:06 +00:00
|
|
|
: type(LowPathType::Binary), binary(binary_data.begin(), binary_data.end()) {}
|
2018-02-15 09:19:01 +00:00
|
|
|
Path(LowPathType type, const std::vector<u8>& data);
|
2014-11-10 22:36:32 +00:00
|
|
|
|
2016-09-18 00:38:01 +00:00
|
|
|
LowPathType GetType() const {
|
|
|
|
return type;
|
|
|
|
}
|
2014-11-10 22:36:32 +00:00
|
|
|
|
2014-11-14 00:26:33 +00:00
|
|
|
/**
|
|
|
|
* Gets the string representation of the path for debugging
|
|
|
|
* @return String representation of the path for debugging
|
|
|
|
*/
|
2016-01-25 05:10:05 +00:00
|
|
|
std::string DebugStr() const;
|
2014-11-10 22:36:32 +00:00
|
|
|
|
2016-01-25 05:10:05 +00:00
|
|
|
std::string AsString() const;
|
|
|
|
std::u16string AsU16Str() const;
|
|
|
|
std::vector<u8> AsBinary() const;
|
2014-11-10 22:36:32 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
LowPathType type;
|
|
|
|
std::vector<u8> binary;
|
|
|
|
std::string string;
|
2020-01-10 23:47:39 +00:00
|
|
|
std::u16string u16str{};
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
void serialize(Archive& ar, const unsigned int) {
|
|
|
|
ar& type;
|
|
|
|
switch (type) {
|
|
|
|
case LowPathType::Binary:
|
|
|
|
ar& binary;
|
|
|
|
break;
|
|
|
|
case LowPathType::Char:
|
|
|
|
ar& string;
|
|
|
|
break;
|
2020-03-28 19:29:29 +00:00
|
|
|
#ifdef _WIN32
|
2020-01-10 23:47:39 +00:00
|
|
|
case LowPathType::Wchar:
|
|
|
|
static_assert(sizeof(wchar_t) == sizeof(char16_t));
|
|
|
|
{
|
|
|
|
std::wstring wstring(reinterpret_cast<wchar_t*>(u16str.data()));
|
|
|
|
ar& wstring;
|
|
|
|
if (!Archive::is_saving::value) {
|
|
|
|
u16str = std::u16string(reinterpret_cast<char16_t*>(wstring.data()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2020-03-28 19:29:29 +00:00
|
|
|
#endif
|
2020-01-10 23:47:39 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
friend class boost::serialization::access;
|
2014-11-10 22:36:32 +00:00
|
|
|
};
|
|
|
|
|
2016-09-19 01:01:46 +00:00
|
|
|
/// Parameters of the archive, as specified in the Create or Format call.
|
2015-12-28 18:51:44 +00:00
|
|
|
struct ArchiveFormatInfo {
|
2016-09-19 01:01:46 +00:00
|
|
|
u32_le total_size; ///< The pre-defined size of the archive.
|
|
|
|
u32_le number_directories; ///< The pre-defined number of directories in the archive.
|
|
|
|
u32_le number_files; ///< The pre-defined number of files in the archive.
|
|
|
|
u8 duplicate_data; ///< Whether the archive should duplicate the data.
|
2015-12-28 18:51:44 +00:00
|
|
|
};
|
|
|
|
static_assert(std::is_pod<ArchiveFormatInfo>::value, "ArchiveFormatInfo is not POD");
|
|
|
|
|
2014-12-15 04:51:38 +00:00
|
|
|
class ArchiveBackend : NonCopyable {
|
2014-06-27 20:18:56 +00:00
|
|
|
public:
|
2016-09-19 01:01:46 +00:00
|
|
|
virtual ~ArchiveBackend() {}
|
2014-06-27 20:18:56 +00:00
|
|
|
|
|
|
|
/**
|
2014-12-15 04:44:04 +00:00
|
|
|
* Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
|
2014-06-27 20:18:56 +00:00
|
|
|
*/
|
2014-12-15 04:44:04 +00:00
|
|
|
virtual std::string GetName() const = 0;
|
2014-06-27 20:18:56 +00:00
|
|
|
|
2014-09-11 22:42:59 +00:00
|
|
|
/**
|
|
|
|
* Open a file specified by its path, using the specified mode
|
|
|
|
* @param path Path relative to the archive
|
|
|
|
* @param mode Mode to open the file with
|
2015-12-28 15:17:06 +00:00
|
|
|
* @return Opened file, or error code
|
2014-09-11 22:42:59 +00:00
|
|
|
*/
|
2016-09-18 00:38:01 +00:00
|
|
|
virtual ResultVal<std::unique_ptr<FileBackend>> OpenFile(const Path& path,
|
2016-10-14 07:29:09 +00:00
|
|
|
const Mode& mode) const = 0;
|
2014-09-11 22:42:59 +00:00
|
|
|
|
2014-11-11 18:37:26 +00:00
|
|
|
/**
|
|
|
|
* Delete a file specified by its path
|
|
|
|
* @param path Path relative to the archive
|
2015-12-28 14:59:27 +00:00
|
|
|
* @return Result of the operation
|
2014-11-11 18:37:26 +00:00
|
|
|
*/
|
2015-12-28 14:59:27 +00:00
|
|
|
virtual ResultCode DeleteFile(const Path& path) const = 0;
|
2014-11-11 18:37:26 +00:00
|
|
|
|
2014-11-24 07:20:04 +00:00
|
|
|
/**
|
|
|
|
* Rename a File specified by its path
|
|
|
|
* @param src_path Source path relative to the archive
|
|
|
|
* @param dest_path Destination path relative to the archive
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Result of the operation
|
2014-11-24 07:20:04 +00:00
|
|
|
*/
|
2016-10-14 07:29:09 +00:00
|
|
|
virtual ResultCode RenameFile(const Path& src_path, const Path& dest_path) const = 0;
|
2014-11-24 07:20:04 +00:00
|
|
|
|
2014-11-11 18:37:26 +00:00
|
|
|
/**
|
|
|
|
* Delete a directory specified by its path
|
|
|
|
* @param path Path relative to the archive
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Result of the operation
|
2014-11-11 18:37:26 +00:00
|
|
|
*/
|
2016-10-14 07:29:09 +00:00
|
|
|
virtual ResultCode DeleteDirectory(const Path& path) const = 0;
|
2014-11-11 18:37:26 +00:00
|
|
|
|
2016-10-02 03:29:04 +00:00
|
|
|
/**
|
|
|
|
* Delete a directory specified by its path and anything under it
|
|
|
|
* @param path Path relative to the archive
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Result of the operation
|
2016-10-02 03:29:04 +00:00
|
|
|
*/
|
2016-10-14 07:29:09 +00:00
|
|
|
virtual ResultCode DeleteDirectoryRecursively(const Path& path) const = 0;
|
2016-10-02 03:29:04 +00:00
|
|
|
|
2014-12-20 15:43:50 +00:00
|
|
|
/**
|
|
|
|
* Create a file specified by its path
|
|
|
|
* @param path Path relative to the Archive
|
|
|
|
* @param size The size of the new file, filled with zeroes
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Result of the operation
|
2014-12-20 15:43:50 +00:00
|
|
|
*/
|
2015-12-28 14:38:10 +00:00
|
|
|
virtual ResultCode CreateFile(const Path& path, u64 size) const = 0;
|
2014-12-20 15:43:50 +00:00
|
|
|
|
2014-10-29 05:52:56 +00:00
|
|
|
/**
|
|
|
|
* Create a directory specified by its path
|
|
|
|
* @param path Path relative to the archive
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Result of the operation
|
2014-10-29 05:52:56 +00:00
|
|
|
*/
|
2016-10-14 07:29:09 +00:00
|
|
|
virtual ResultCode CreateDirectory(const Path& path) const = 0;
|
2014-10-29 05:52:56 +00:00
|
|
|
|
2014-11-24 09:12:58 +00:00
|
|
|
/**
|
|
|
|
* Rename a Directory specified by its path
|
|
|
|
* @param src_path Source path relative to the archive
|
|
|
|
* @param dest_path Destination path relative to the archive
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Result of the operation
|
2014-11-24 09:12:58 +00:00
|
|
|
*/
|
2016-10-14 07:29:09 +00:00
|
|
|
virtual ResultCode RenameDirectory(const Path& src_path, const Path& dest_path) const = 0;
|
2014-11-24 09:12:58 +00:00
|
|
|
|
2014-09-11 22:47:05 +00:00
|
|
|
/**
|
|
|
|
* Open a directory specified by its path
|
|
|
|
* @param path Path relative to the archive
|
2016-10-14 07:29:09 +00:00
|
|
|
* @return Opened directory, or error code
|
2014-09-11 22:47:05 +00:00
|
|
|
*/
|
2016-10-14 07:29:09 +00:00
|
|
|
virtual ResultVal<std::unique_ptr<DirectoryBackend>> OpenDirectory(const Path& path) const = 0;
|
2015-10-18 22:52:37 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the free space
|
|
|
|
* @return The number of free bytes in the archive
|
|
|
|
*/
|
|
|
|
virtual u64 GetFreeBytes() const = 0;
|
2018-11-02 17:11:22 +00:00
|
|
|
|
|
|
|
u64 GetOpenDelayNs() {
|
|
|
|
if (delay_generator != nullptr) {
|
|
|
|
return delay_generator->GetOpenDelayNs();
|
|
|
|
}
|
|
|
|
LOG_ERROR(Service_FS, "Delay generator was not initalized. Using default");
|
|
|
|
delay_generator = std::make_unique<DefaultDelayGenerator>();
|
|
|
|
return delay_generator->GetOpenDelayNs();
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
2020-03-28 15:47:36 +00:00
|
|
|
std::unique_ptr<DelayGenerator> delay_generator;
|
2020-01-02 00:45:58 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
template <class Archive>
|
2020-01-03 14:00:10 +00:00
|
|
|
void serialize(Archive& ar, const unsigned int) {
|
|
|
|
ar& delay_generator;
|
|
|
|
}
|
2020-01-02 00:45:58 +00:00
|
|
|
friend class boost::serialization::access;
|
2014-06-27 20:18:56 +00:00
|
|
|
};
|
|
|
|
|
2015-02-06 13:53:14 +00:00
|
|
|
class ArchiveFactory : NonCopyable {
|
|
|
|
public:
|
2016-09-19 01:01:46 +00:00
|
|
|
virtual ~ArchiveFactory() {}
|
2015-02-06 13:53:14 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
|
|
|
|
*/
|
|
|
|
virtual std::string GetName() const = 0;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Tries to open the archive of this type with the specified path
|
|
|
|
* @param path Path to the archive
|
2019-02-03 01:14:01 +00:00
|
|
|
* @param program_id the program ID of the client that requests the operation
|
2015-02-06 13:53:14 +00:00
|
|
|
* @return An ArchiveBackend corresponding operating specified archive path.
|
|
|
|
*/
|
2019-02-03 01:14:01 +00:00
|
|
|
virtual ResultVal<std::unique_ptr<ArchiveBackend>> Open(const Path& path, u64 program_id) = 0;
|
2015-02-06 13:53:14 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Deletes the archive contents and then re-creates the base folder
|
|
|
|
* @param path Path to the archive
|
2015-12-28 18:51:44 +00:00
|
|
|
* @param format_info Format information for the new archive
|
2019-02-03 01:14:01 +00:00
|
|
|
* @param program_id the program ID of the client that requests the operation
|
2015-02-06 13:53:14 +00:00
|
|
|
* @return ResultCode of the operation, 0 on success
|
|
|
|
*/
|
2019-02-03 01:14:01 +00:00
|
|
|
virtual ResultCode Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info,
|
|
|
|
u64 program_id) = 0;
|
2015-12-28 18:51:44 +00:00
|
|
|
|
2016-01-16 22:01:01 +00:00
|
|
|
/**
|
2015-12-28 18:51:44 +00:00
|
|
|
* Retrieves the format info about the archive with the specified path
|
|
|
|
* @param path Path to the archive
|
2019-02-03 01:14:01 +00:00
|
|
|
* @param program_id the program ID of the client that requests the operation
|
2015-12-28 18:51:44 +00:00
|
|
|
* @return Format information about the archive or error code
|
|
|
|
*/
|
2019-02-03 01:14:01 +00:00
|
|
|
virtual ResultVal<ArchiveFormatInfo> GetFormatInfo(const Path& path, u64 program_id) const = 0;
|
2020-01-02 00:45:58 +00:00
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
void serialize(Archive& ar, const unsigned int) {}
|
|
|
|
friend class boost::serialization::access;
|
2015-02-06 13:53:14 +00:00
|
|
|
};
|
|
|
|
|
2014-06-27 20:18:56 +00:00
|
|
|
} // namespace FileSys
|