summaryrefslogtreecommitdiffstats
path: root/src/core/hle/service/fs/archive.h
blob: 533be34a4629bb346abc8b2308b0ca288cfa18e5 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
// Copyright 2014 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#pragma once

#include <memory>
#include <string>
#include "common/common_types.h"
#include "core/file_sys/archive_backend.h"
#include "core/hle/kernel/session.h"
#include "core/hle/result.h"

namespace FileSys {
class DirectoryBackend;
class FileBackend;
}

/// The unique system identifier hash, also known as ID0
extern const std::string SYSTEM_ID;
/// The scrambled SD card CID, also known as ID1
extern const std::string SDCARD_ID;

namespace Service {
namespace FS {

/// Supported archive types
enum class ArchiveIdCode : u32 {
    RomFS = 0x00000003,
    SaveData = 0x00000004,
    ExtSaveData = 0x00000006,
    SharedExtSaveData = 0x00000007,
    SystemSaveData = 0x00000008,
    SDMC = 0x00000009,
    SDMCWriteOnly = 0x0000000A,
    SaveDataCheck = 0x2345678A,
};

/// Media types for the archives
enum class MediaType : u32 { NAND = 0, SDMC = 1 };

typedef u64 ArchiveHandle;

class File : public Kernel::Session {
public:
    File(std::unique_ptr<FileSys::FileBackend>&& backend, const FileSys::Path& path);
    ~File();

    std::string GetName() const override {
        return "Path: " + path.DebugStr();
    }
    ResultVal<bool> SyncRequest() override;

    FileSys::Path path; ///< Path of the file
    u32 priority;       ///< Priority of the file. TODO(Subv): Find out what this means
    std::unique_ptr<FileSys::FileBackend> backend; ///< File backend interface
};

class Directory : public Kernel::Session {
public:
    Directory(std::unique_ptr<FileSys::DirectoryBackend>&& backend, const FileSys::Path& path);
    ~Directory();

    std::string GetName() const override {
        return "Directory: " + path.DebugStr();
    }
    ResultVal<bool> SyncRequest() override;

    FileSys::Path path;                                 ///< Path of the directory
    std::unique_ptr<FileSys::DirectoryBackend> backend; ///< File backend interface
};

/**
 * Opens an archive
 * @param id_code IdCode of the archive to open
 * @param archive_path Path to the archive, used with Binary paths
 * @return Handle to the opened archive
 */
ResultVal<ArchiveHandle> OpenArchive(ArchiveIdCode id_code, FileSys::Path& archive_path);

/**
 * Closes an archive
 * @param handle Handle to the archive to close
 */
ResultCode CloseArchive(ArchiveHandle handle);

/**
 * Registers an Archive type, instances of which can later be opened using its IdCode.
 * @param factory File system backend interface to the archive
 * @param id_code Id code used to access this type of archive
 */
ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factory,
                               ArchiveIdCode id_code);

/**
 * Open a File from an Archive
 * @param archive_handle Handle to an open Archive object
 * @param path Path to the File inside of the Archive
 * @param mode Mode under which to open the File
 * @return The opened File object as a Session
 */
ResultVal<Kernel::SharedPtr<File>> OpenFileFromArchive(ArchiveHandle archive_handle,
                                                       const FileSys::Path& path,
                                                       const FileSys::Mode mode);

/**
 * Delete a File from an Archive
 * @param archive_handle Handle to an open Archive object
 * @param path Path to the File inside of the Archive
 * @return Whether deletion succeeded
 */
ResultCode DeleteFileFromArchive(ArchiveHandle archive_handle, const FileSys::Path& path);

/**
 * Rename a File between two Archives
 * @param src_archive_handle Handle to the source Archive object
 * @param src_path Path to the File inside of the source Archive
 * @param dest_archive_handle Handle to the destination Archive object
 * @param dest_path Path to the File inside of the destination Archive
 * @return Whether rename succeeded
 */
ResultCode RenameFileBetweenArchives(ArchiveHandle src_archive_handle,
                                     const FileSys::Path& src_path,
                                     ArchiveHandle dest_archive_handle,
                                     const FileSys::Path& dest_path);

/**
 * Delete a Directory from an Archive
 * @param archive_handle Handle to an open Archive object
 * @param path Path to the Directory inside of the Archive
 * @return Whether deletion succeeded
 */
ResultCode DeleteDirectoryFromArchive(ArchiveHandle archive_handle, const FileSys::Path& path);

/**
 * Create a File in an Archive
 * @param archive_handle Handle to an open Archive object
 * @param path Path to the File inside of the Archive
 * @param file_size The size of the new file, filled with zeroes
 * @return File creation result code
 */
ResultCode CreateFileInArchive(ArchiveHandle archive_handle, const FileSys::Path& path,
                               u64 file_size);

/**
 * Create a Directory from an Archive
 * @param archive_handle Handle to an open Archive object
 * @param path Path to the Directory inside of the Archive
 * @return Whether creation of directory succeeded
 */
ResultCode CreateDirectoryFromArchive(ArchiveHandle archive_handle, const FileSys::Path& path);

/**
 * Rename a Directory between two Archives
 * @param src_archive_handle Handle to the source Archive object
 * @param src_path Path to the Directory inside of the source Archive
 * @param dest_archive_handle Handle to the destination Archive object
 * @param dest_path Path to the Directory inside of the destination Archive
 * @return Whether rename succeeded
 */
ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
                                          const FileSys::Path& src_path,
                                          ArchiveHandle dest_archive_handle,
                                          const FileSys::Path& dest_path);

/**
 * Open a Directory from an Archive
 * @param archive_handle Handle to an open Archive object
 * @param path Path to the Directory inside of the Archive
 * @return The opened Directory object as a Session
 */
ResultVal<Kernel::SharedPtr<Directory>> OpenDirectoryFromArchive(ArchiveHandle archive_handle,
                                                                 const FileSys::Path& path);

/**
 * Get the free space in an Archive
 * @param archive_handle Handle to an open Archive object
 * @return The number of free bytes in the archive
 */
ResultVal<u64> GetFreeBytesInArchive(ArchiveHandle archive_handle);

/**
 * Erases the contents of the physical folder that contains the archive
 * identified by the specified id code and path
 * @param id_code The id of the archive to format
 * @param format_info Format information about the new archive
 * @param path The path to the archive, if relevant.
 * @return ResultCode 0 on success or the corresponding code on error
 */
ResultCode FormatArchive(ArchiveIdCode id_code, const FileSys::ArchiveFormatInfo& format_info,
                         const FileSys::Path& path = FileSys::Path());

/**
 * Retrieves the format info about the archive of the specified type and path.
 * The format info is supplied by the client code when creating archives.
 * @param id_code The id of the archive
 * @param archive_path The path of the archive, if relevant
 * @return The format info of the archive, or the corresponding error code if failed.
 */
ResultVal<FileSys::ArchiveFormatInfo> GetArchiveFormatInfo(ArchiveIdCode id_code,
                                                           FileSys::Path& archive_path);

/**
 * Creates a blank SharedExtSaveData archive for the specified extdata ID
 * @param media_type The media type of the archive to create (NAND / SDMC)
 * @param high The high word of the extdata id to create
 * @param low The low word of the extdata id to create
 * @param icon_buffer VAddr of the SMDH icon for this ExtSaveData
 * @param icon_size Size of the SMDH icon
 * @param format_info Format information about the new archive
 * @return ResultCode 0 on success or the corresponding code on error
 */
ResultCode CreateExtSaveData(MediaType media_type, u32 high, u32 low, VAddr icon_buffer,
                             u32 icon_size, const FileSys::ArchiveFormatInfo& format_info);

/**
 * Deletes the SharedExtSaveData archive for the specified extdata ID
 * @param media_type The media type of the archive to delete (NAND / SDMC)
 * @param high The high word of the extdata id to delete
 * @param low The low word of the extdata id to delete
 * @return ResultCode 0 on success or the corresponding code on error
 */
ResultCode DeleteExtSaveData(MediaType media_type, u32 high, u32 low);

/**
 * Deletes the SystemSaveData archive folder for the specified save data id
 * @param high The high word of the SystemSaveData archive to delete
 * @param low The low word of the SystemSaveData archive to delete
 * @return ResultCode 0 on success or the corresponding code on error
 */
ResultCode DeleteSystemSaveData(u32 high, u32 low);

/**
 * Creates the SystemSaveData archive folder for the specified save data id
 * @param high The high word of the SystemSaveData archive to create
 * @param low The low word of the SystemSaveData archive to create
 * @return ResultCode 0 on success or the corresponding code on error
 */
ResultCode CreateSystemSaveData(u32 high, u32 low);

/// Initialize archives
void ArchiveInit();

/// Shutdown archives
void ArchiveShutdown();

/// Register all archive types
void RegisterArchiveTypes();

/// Unregister all archive types
void UnregisterArchiveTypes();

} // namespace FS
} // namespace Service