diff options
Diffstat (limited to 'src')
28 files changed, 1298 insertions, 59 deletions
diff --git a/src/common/chunk_file.h b/src/common/chunk_file.h index 2b0f120e6..7a3b537c7 100644 --- a/src/common/chunk_file.h +++ b/src/common/chunk_file.h @@ -671,7 +671,7 @@ public: _failureReason->clear(); _failureReason->append("LoadStateWrongVersion"); - if (!File::Exists(_rFilename)) { + if (!FileUtil::Exists(_rFilename)) { _failureReason->clear(); _failureReason->append("LoadStateDoesntExist"); ERROR_LOG(COMMON, "ChunkReader: File doesn't exist"); @@ -679,7 +679,7 @@ public: } // Check file size - const u64 fileSize = File::GetSize(_rFilename); + const u64 fileSize = FileUtil::GetSize(_rFilename); static const u64 headerSize = sizeof(SChunkHeader); if (fileSize < headerSize) { @@ -687,7 +687,7 @@ public: return ERROR_BAD_FILE; } - File::IOFile pFile(_rFilename, "rb"); + FileUtil::IOFile pFile(_rFilename, "rb"); if (!pFile) { ERROR_LOG(COMMON,"ChunkReader: Can't open file for reading"); @@ -765,7 +765,7 @@ public: { INFO_LOG(COMMON, "ChunkReader: Writing %s" , _rFilename.c_str()); - File::IOFile pFile(_rFilename, "wb"); + FileUtil::IOFile pFile(_rFilename, "wb"); if (!pFile) { ERROR_LOG(COMMON,"ChunkReader: Error opening file for write"); diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp index 970041007..ecfccbd66 100644 --- a/src/common/file_util.cpp +++ b/src/common/file_util.cpp @@ -39,7 +39,7 @@ // This namespace has various generic functions related to files and paths. // The code still needs a ton of cleanup. // REMEMBER: strdup considered harmful! -namespace File +namespace FileUtil { // Remove any ending forward slashes from directory paths @@ -172,7 +172,7 @@ bool CreateFullPath(const std::string &fullPath) int panicCounter = 100; INFO_LOG(COMMON, "CreateFullPath: path %s", fullPath.c_str()); - if (File::Exists(fullPath)) + if (FileUtil::Exists(fullPath)) { INFO_LOG(COMMON, "CreateFullPath: path exists %s", fullPath.c_str()); return true; @@ -190,8 +190,8 @@ bool CreateFullPath(const std::string &fullPath) // Include the '/' so the first call is CreateDir("/") rather than CreateDir("") std::string const subPath(fullPath.substr(0, position + 1)); - if (!File::IsDirectory(subPath)) - File::CreateDir(subPath); + if (!FileUtil::IsDirectory(subPath)) + FileUtil::CreateDir(subPath); // A safety check panicCounter--; @@ -211,7 +211,7 @@ bool DeleteDir(const std::string &filename) INFO_LOG(COMMON, "DeleteDir: directory %s", filename.c_str()); // check if a directory - if (!File::IsDirectory(filename)) + if (!FileUtil::IsDirectory(filename)) { ERROR_LOG(COMMON, "DeleteDir: Not a directory %s", filename.c_str()); return false; @@ -386,7 +386,7 @@ bool CreateEmptyFile(const std::string &filename) { INFO_LOG(COMMON, "CreateEmptyFile: %s", filename.c_str()); - if (!File::IOFile(filename, "wb")) + if (!FileUtil::IOFile(filename, "wb")) { ERROR_LOG(COMMON, "CreateEmptyFile: failed %s: %s", filename.c_str(), GetLastErrorMsg()); @@ -519,7 +519,7 @@ bool DeleteDirRecursively(const std::string &directory) } else { - if (!File::Delete(newPath)) + if (!FileUtil::Delete(newPath)) { #ifndef _WIN32 closedir(dirp); @@ -536,7 +536,7 @@ bool DeleteDirRecursively(const std::string &directory) } closedir(dirp); #endif - File::DeleteDir(directory); + FileUtil::DeleteDir(directory); return true; } @@ -546,8 +546,8 @@ void CopyDir(const std::string &source_path, const std::string &dest_path) { #ifndef _WIN32 if (source_path == dest_path) return; - if (!File::Exists(source_path)) return; - if (!File::Exists(dest_path)) File::CreateFullPath(dest_path); + if (!FileUtil::Exists(source_path)) return; + if (!FileUtil::Exists(dest_path)) FileUtil::CreateFullPath(dest_path); struct dirent dirent, *result = NULL; DIR *dirp = opendir(source_path.c_str()); @@ -569,10 +569,10 @@ void CopyDir(const std::string &source_path, const std::string &dest_path) { source += '/'; dest += '/'; - if (!File::Exists(dest)) File::CreateFullPath(dest); + if (!FileUtil::Exists(dest)) FileUtil::CreateFullPath(dest); CopyDir(source, dest); } - else if (!File::Exists(dest)) File::Copy(source, dest); + else if (!FileUtil::Exists(dest)) FileUtil::Copy(source, dest); } closedir(dirp); #endif @@ -660,7 +660,7 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string &new #ifdef _WIN32 paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP; #else - if (File::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) + if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP; else paths[D_USER_IDX] = std::string(getenv("HOME") ? @@ -688,7 +688,7 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string &new if (!newPath.empty()) { - if (!File::IsDirectory(newPath)) + if (!FileUtil::IsDirectory(newPath)) { WARN_LOG(COMMON, "Invalid path specified %s", newPath.c_str()); return paths[DirIDX]; @@ -750,11 +750,11 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string &new //std::string GetThemeDir(const std::string& theme_name) //{ -// std::string dir = File::GetUserPath(D_THEMES_IDX) + theme_name + "/"; +// std::string dir = FileUtil::GetUserPath(D_THEMES_IDX) + theme_name + "/"; // //#if !defined(_WIN32) // // If theme does not exist in user's dir load from shared directory -// if (!File::Exists(dir)) +// if (!FileUtil::Exists(dir)) // dir = SHARED_USER_DIR THEMES_DIR "/" + theme_name + "/"; //#endif // @@ -763,12 +763,12 @@ const std::string& GetUserPath(const unsigned int DirIDX, const std::string &new bool WriteStringToFile(bool text_file, const std::string &str, const char *filename) { - return File::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size()); + return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size()); } bool ReadFileToString(bool text_file, const char *filename, std::string &str) { - File::IOFile file(filename, text_file ? "r" : "rb"); + FileUtil::IOFile file(filename, text_file ? "r" : "rb"); auto const f = file.GetHandle(); if (!f) @@ -854,7 +854,7 @@ void IOFile::SetHandle(std::FILE* file) u64 IOFile::GetSize() { if (IsOpen()) - return File::GetSize(m_file); + return FileUtil::GetSize(m_file); else return 0; } diff --git a/src/common/file_util.h b/src/common/file_util.h index fdae5c9c8..897cbd77e 100644 --- a/src/common/file_util.h +++ b/src/common/file_util.h @@ -43,7 +43,7 @@ enum { NUM_PATH_INDICES }; -namespace File +namespace FileUtil { // FileSystem tree node/ @@ -151,29 +151,41 @@ public: bool Close(); template <typename T> - bool ReadArray(T* data, size_t length) + size_t ReadArray(T* data, size_t length) { - if (!IsOpen() || length != std::fread(data, sizeof(T), length, m_file)) + if (!IsOpen()) { m_good = false; + return -1; + } - return m_good; + size_t items_read = std::fread(data, sizeof(T), length, m_file); + if (items_read != length) + m_good = false; + + return items_read; } template <typename T> - bool WriteArray(const T* data, size_t length) + size_t WriteArray(const T* data, size_t length) { - if (!IsOpen() || length != std::fwrite(data, sizeof(T), length, m_file)) + if (!IsOpen()) { + m_good = false; + return -1; + } + + size_t items_written = std::fwrite(data, sizeof(T), length, m_file); + if (items_written != length) m_good = false; - return m_good; + return items_written; } - bool ReadBytes(void* data, size_t length) + size_t ReadBytes(void* data, size_t length) { return ReadArray(reinterpret_cast<char*>(data), length); } - bool WriteBytes(const void* data, size_t length) + size_t WriteBytes(const void* data, size_t length) { return WriteArray(reinterpret_cast<const char*>(data), length); } diff --git a/src/common/log_manager.cpp b/src/common/log_manager.cpp index 43346f279..28b72fa20 100644 --- a/src/common/log_manager.cpp +++ b/src/common/log_manager.cpp @@ -75,7 +75,7 @@ LogManager::LogManager() m_Log[LogTypes::MEMCARD_MANAGER] = new LogContainer("MemCard Manager", "MemCard Manager"); m_Log[LogTypes::NETPLAY] = new LogContainer("NETPLAY", "Netplay"); - m_fileLog = new FileLogListener(File::GetUserPath(F_MAINLOG_IDX).c_str()); + m_fileLog = new FileLogListener(FileUtil::GetUserPath(F_MAINLOG_IDX).c_str()); m_consoleLog = new ConsoleListener(); m_debuggerLog = new DebuggerLogListener(); diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 1f358ec8d..2b26292fd 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -23,6 +23,11 @@ set(SRCS arm/interpreter/armvirt.cpp arm/interpreter/thumbemu.cpp file_sys/archive_romfs.cpp + file_sys/archive_sdmc.cpp + file_sys/file_romfs.cpp + file_sys/file_sdmc.cpp + file_sys/directory_romfs.cpp + file_sys/directory_sdmc.cpp hle/kernel/address_arbiter.cpp hle/kernel/archive.cpp hle/kernel/event.cpp @@ -77,6 +82,13 @@ set(HEADERS arm/arm_interface.h file_sys/archive.h file_sys/archive_romfs.h + file_sys/archive_sdmc.h + file_sys/file.h + file_sys/file_romfs.h + file_sys/file_sdmc.h + file_sys/directory.h + file_sys/directory_romfs.h + file_sys/directory_sdmc.h hle/kernel/address_arbiter.h hle/kernel/archive.h hle/kernel/event.h diff --git a/src/core/file_sys/archive.h b/src/core/file_sys/archive.h index ac5630bea..560db6dea 100644 --- a/src/core/file_sys/archive.h +++ b/src/core/file_sys/archive.h @@ -4,7 +4,13 @@ #pragma once +#include <memory> + #include "common/common_types.h" +#include "common/bit_field.h" + +#include "core/file_sys/file.h" +#include "core/file_sys/directory.h" #include "core/hle/kernel/kernel.h" @@ -13,6 +19,13 @@ namespace FileSys { +union Mode { + u32 hex; + BitField<0, 1, u32> read_flag; + BitField<1, 1, u32> write_flag; + BitField<2, 1, u32> create_flag; +}; + class Archive : NonCopyable { public: /// Supported archive types @@ -36,6 +49,21 @@ public: virtual IdCode GetIdCode() const = 0; /** + * 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 + * @return Opened file, or nullptr + */ + virtual std::unique_ptr<File> OpenFile(const std::string& path, const Mode mode) const = 0; + + /** + * Open a directory specified by its path + * @param path Path relative to the archive + * @return Opened directory, or nullptr + */ + virtual std::unique_ptr<Directory> OpenDirectory(const std::string& path) const = 0; + + /** * Read data from the archive * @param offset Offset in bytes to start reading data from * @param length Length in bytes of data to read from archive diff --git a/src/core/file_sys/archive_romfs.cpp b/src/core/file_sys/archive_romfs.cpp index dc3fb1807..9bab3471f 100644 --- a/src/core/file_sys/archive_romfs.cpp +++ b/src/core/file_sys/archive_romfs.cpp @@ -5,6 +5,8 @@ #include "common/common_types.h" #include "core/file_sys/archive_romfs.h" +#include "core/file_sys/directory_romfs.h" +#include "core/file_sys/file_romfs.h" //////////////////////////////////////////////////////////////////////////////////////////////////// // FileSys namespace @@ -22,6 +24,25 @@ Archive_RomFS::~Archive_RomFS() { } /** + * 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 + * @return Opened file, or nullptr + */ +std::unique_ptr<File> Archive_RomFS::OpenFile(const std::string& path, const Mode mode) const { + return std::unique_ptr<File>(new File_RomFS); +} + +/** + * Open a directory specified by its path + * @param path Path relative to the archive + * @return Opened directory, or nullptr + */ +std::unique_ptr<Directory> Archive_RomFS::OpenDirectory(const std::string& path) const { + return std::unique_ptr<Directory>(new Directory_RomFS); +} + +/** * Read data from the archive * @param offset Offset in bytes to start reading data from * @param length Length in bytes of data to read from archive diff --git a/src/core/file_sys/archive_romfs.h b/src/core/file_sys/archive_romfs.h index e9ed6f77a..fcdefa95f 100644 --- a/src/core/file_sys/archive_romfs.h +++ b/src/core/file_sys/archive_romfs.h @@ -29,6 +29,21 @@ public: IdCode GetIdCode() const override { return IdCode::RomFS; }; /** + * 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 + * @return Opened file, or nullptr + */ + std::unique_ptr<File> OpenFile(const std::string& path, const Mode mode) const override; + + /** + * Open a directory specified by its path + * @param path Path relative to the archive + * @return Opened directory, or nullptr + */ + std::unique_ptr<Directory> OpenDirectory(const std::string& path) const override; + + /** * Read data from the archive * @param offset Offset in bytes to start reading data from * @param length Length in bytes of data to read from archive diff --git a/src/core/file_sys/archive_sdmc.cpp b/src/core/file_sys/archive_sdmc.cpp new file mode 100644 index 000000000..30d33be5f --- /dev/null +++ b/src/core/file_sys/archive_sdmc.cpp @@ -0,0 +1,108 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include <sys/stat.h> + +#include "common/common_types.h" +#include "common/file_util.h" + +#include "core/file_sys/archive_sdmc.h" +#include "core/file_sys/directory_sdmc.h" +#include "core/file_sys/file_sdmc.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +Archive_SDMC::Archive_SDMC(const std::string& mount_point) { + this->mount_point = mount_point; + DEBUG_LOG(FILESYS, "Directory %s set as SDMC.", mount_point.c_str()); +} + +Archive_SDMC::~Archive_SDMC() { +} + +bool Archive_SDMC::Initialize() { + if (!FileUtil::IsDirectory(mount_point)) { + WARN_LOG(FILESYS, "Directory %s not found, disabling SDMC.", mount_point.c_str()); + return false; + } + + return true; +} + +/** + * 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 + * @return Opened file, or nullptr + */ +std::unique_ptr<File> Archive_SDMC::OpenFile(const std::string& path, const Mode mode) const { + DEBUG_LOG(FILESYS, "called path=%s mode=%d", path.c_str(), mode); + File_SDMC* file = new File_SDMC(this, path, mode); + return std::unique_ptr<File>(file); +} + +/** + * Open a directory specified by its path + * @param path Path relative to the archive + * @return Opened directory, or nullptr + */ +std::unique_ptr<Directory> Archive_SDMC::OpenDirectory(const std::string& path) const { + DEBUG_LOG(FILESYS, "called path=%s", path.c_str()); + Directory_SDMC* directory = new Directory_SDMC(this, path); + return std::unique_ptr<Directory>(directory); +} + +/** + * Read data from the archive + * @param offset Offset in bytes to start reading archive from + * @param length Length in bytes to read data from archive + * @param buffer Buffer to read data into + * @return Number of bytes read + */ +size_t Archive_SDMC::Read(const u64 offset, const u32 length, u8* buffer) const { + ERROR_LOG(FILESYS, "(UNIMPLEMENTED)"); + return -1; +} + +/** + * Write data to the archive + * @param offset Offset in bytes to start writing data to + * @param length Length in bytes of data to write to archive + * @param buffer Buffer to write data from + * @param flush The flush parameters (0 == do not flush) + * @return Number of bytes written + */ +size_t Archive_SDMC::Write(const u64 offset, const u32 length, const u32 flush, u8* buffer) { + ERROR_LOG(FILESYS, "(UNIMPLEMENTED)"); + return -1; +} + +/** + * Get the size of the archive in bytes + * @return Size of the archive in bytes + */ +size_t Archive_SDMC::GetSize() const { + ERROR_LOG(FILESYS, "(UNIMPLEMENTED)"); + return 0; +} + +/** + * Set the size of the archive in bytes + */ +void Archive_SDMC::SetSize(const u64 size) { + ERROR_LOG(FILESYS, "(UNIMPLEMENTED)"); +} + +/** + * Getter for the path used for this Archive + * @return Mount point of that passthrough archive + */ +std::string Archive_SDMC::GetMountPoint() const { + return mount_point; +} + +} // namespace FileSys diff --git a/src/core/file_sys/archive_sdmc.h b/src/core/file_sys/archive_sdmc.h new file mode 100644 index 000000000..946f8b957 --- /dev/null +++ b/src/core/file_sys/archive_sdmc.h @@ -0,0 +1,86 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +#include "core/file_sys/archive.h" +#include "core/loader/loader.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +/// File system interface to the SDMC archive +class Archive_SDMC final : public Archive { +public: + Archive_SDMC(const std::string& mount_point); + ~Archive_SDMC() override; + + bool Initialize(); + + /** + * Get the IdCode of the archive (e.g. RomFS, SaveData, etc.) + * @return IdCode of the archive + */ + IdCode GetIdCode() const override { return IdCode::SDMC; }; + + /** + * 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 + * @return Opened file, or nullptr + */ + std::unique_ptr<File> OpenFile(const std::string& path, const Mode mode) const override; + + /** + * Open a directory specified by its path + * @param path Path relative to the archive + * @return Opened directory, or nullptr + */ + std::unique_ptr<Directory> OpenDirectory(const std::string& path) const override; + + /** + * Read data from the archive + * @param offset Offset in bytes to start reading archive from + * @param length Length in bytes to read data from archive + * @param buffer Buffer to read data into + * @return Number of bytes read + */ + size_t Read(const u64 offset, const u32 length, u8* buffer) const override; + + /** + * Write data to the archive + * @param offset Offset in bytes to start writing data to + * @param length Length in bytes of data to write to archive + * @param buffer Buffer to write data from + * @param flush The flush parameters (0 == do not flush) + * @return Number of bytes written + */ + size_t Write(const u64 offset, const u32 length, const u32 flush, u8* buffer) override; + + /** + * Get the size of the archive in bytes + * @return Size of the archive in bytes + */ + size_t GetSize() const override; + + /** + * Set the size of the archive in bytes + */ + void SetSize(const u64 size) override; + + /** + * Getter for the path used for this Archive + * @return Mount point of that passthrough archive + */ + std::string GetMountPoint() const; + +private: + std::string mount_point; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/directory.h b/src/core/file_sys/directory.h new file mode 100644 index 000000000..cf9a2010b --- /dev/null +++ b/src/core/file_sys/directory.h @@ -0,0 +1,53 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +#include "core/hle/kernel/kernel.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +// Structure of a directory entry, from http://3dbrew.org/wiki/FSDir:Read#Entry_format +const size_t FILENAME_LENGTH = 0x20C / 2; +struct Entry { + char16_t filename[FILENAME_LENGTH]; // Entry name (UTF-16, null-terminated) + char short_name[8]; // 8.3 file name ('longfilename' -> 'LONGFI~1') + char unknown1; // unknown (observed values: 0x0A, 0x70, 0xFD) + char extension[3]; // 8.3 file extension (set to spaces for directories) + char unknown2; // unknown (always 0x01) + char unknown3; // unknown (0x00 or 0x08) + char is_directory; // directory flag + char is_hidden; // hidden flag + char is_archive; // archive flag + char is_read_only; // read-only flag + u64 file_size; // file size (for files only) +}; +static_assert(sizeof(Entry) == 0x228, "Directory Entry struct isn't exactly 0x228 bytes long!"); + +class Directory : NonCopyable { +public: + Directory() { } + virtual ~Directory() { } + + /** + * List files contained in the directory + * @param count Number of entries to return at once in entries + * @param entries Buffer to read data into + * @return Number of entries listed + */ + virtual u32 Read(const u32 count, Entry* entries) = 0; + + /** + * Close the directory + * @return true if the directory closed correctly + */ + virtual bool Close() const = 0; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/directory_romfs.cpp b/src/core/file_sys/directory_romfs.cpp new file mode 100644 index 000000000..4e8f4c04d --- /dev/null +++ b/src/core/file_sys/directory_romfs.cpp @@ -0,0 +1,38 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include "common/common_types.h" + +#include "core/file_sys/directory_romfs.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +Directory_RomFS::Directory_RomFS() { +} + +Directory_RomFS::~Directory_RomFS() { +} + +/** + * List files contained in the directory + * @param count Number of entries to return at once in entries + * @param entries Buffer to read data into + * @return Number of entries listed + */ +u32 Directory_RomFS::Read(const u32 count, Entry* entries) { + return 0; +} + +/** + * Close the directory + * @return true if the directory closed correctly + */ +bool Directory_RomFS::Close() const { + return false; +} + +} // namespace FileSys diff --git a/src/core/file_sys/directory_romfs.h b/src/core/file_sys/directory_romfs.h new file mode 100644 index 000000000..4b71c4b13 --- /dev/null +++ b/src/core/file_sys/directory_romfs.h @@ -0,0 +1,37 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +#include "core/file_sys/directory.h" +#include "core/loader/loader.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +class Directory_RomFS final : public Directory { +public: + Directory_RomFS(); + ~Directory_RomFS() override; + + /** + * List files contained in the directory + * @param count Number of entries to return at once in entries + * @param entries Buffer to read data into + * @return Number of entries listed + */ + u32 Read(const u32 count, Entry* entries) override; + + /** + * Close the directory + * @return true if the directory closed correctly + */ + bool Close() const override; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/directory_sdmc.cpp b/src/core/file_sys/directory_sdmc.cpp new file mode 100644 index 000000000..11e867857 --- /dev/null +++ b/src/core/file_sys/directory_sdmc.cpp @@ -0,0 +1,86 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include <sys/stat.h> + +#include "common/common_types.h" +#include "common/file_util.h" + +#include "core/file_sys/directory_sdmc.h" +#include "core/file_sys/archive_sdmc.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +Directory_SDMC::Directory_SDMC(const Archive_SDMC* archive, const std::string& path) { + // TODO(Link Mauve): normalize path into an absolute path without "..", it can currently bypass + // the root directory we set while opening the archive. + // For example, opening /../../usr/bin can give the emulated program your installed programs. + std::string absolute_path = archive->GetMountPoint() + path; + entry_count = FileUtil::ScanDirectoryTree(absolute_path, entry); + current_entry = 0; +} + +Directory_SDMC::~Directory_SDMC() { + Close(); +} + +/** + * List files contained in the directory + * @param count Number of entries to return at once in entries + * @param entries Buffer to read data into + * @return Number of entries listed + */ +u32 Directory_SDMC::Read(const u32 count, Entry* entries) { + u32 i; + for (i = 0; i < count && current_entry < entry_count; ++i) { + FileUtil::FSTEntry file = entry.children[current_entry]; + std::string filename = file.virtualName; + WARN_LOG(FILESYS, "File %s: size=%d dir=%d", filename.c_str(), file.size, file.isDirectory); + + Entry* entry = &entries[i]; + + // TODO(Link Mauve): use a proper conversion to UTF-16. + for (int j = 0; j < FILENAME_LENGTH; ++j) { + entry->filename[j] = filename[j]; + if (!filename[j]) + break; + } + + // Split the filename into 8.3 format. + // TODO(Link Mauve): move that to common, I guess, and make it more robust to long filenames. + std::string::size_type n = filename.rfind('.'); + if (n == std::string::npos) { + strncpy(entry->short_name, filename.c_str(), 8); + memset(entry->extension, '\0', 3); + } else { + strncpy(entry->short_name, filename.substr(0, n).c_str(), 8); + strncpy(entry->extension, filename.substr(n + 1).c_str(), 8); + } + + entry->is_directory = file.isDirectory; + entry->file_size = file.size; + + // We emulate a SD card where the archive bit has never been cleared, as it would be on + // most user SD cards. + // Some homebrews (blargSNES for instance) are known to mistakenly use the archive bit as a + // file bit. + entry->is_archive = !file.isDirectory; + + ++current_entry; + } + return i; +} + +/** + * Close the directory + * @return true if the directory closed correctly + */ +bool Directory_SDMC::Close() const { + return true; +} + +} // namespace FileSys diff --git a/src/core/file_sys/directory_sdmc.h b/src/core/file_sys/directory_sdmc.h new file mode 100644 index 000000000..0bc6c9eff --- /dev/null +++ b/src/core/file_sys/directory_sdmc.h @@ -0,0 +1,45 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" +#include "common/file_util.h" + +#include "core/file_sys/directory.h" +#include "core/file_sys/archive_sdmc.h" +#include "core/loader/loader.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +class Directory_SDMC final : public Directory { +public: + Directory_SDMC(); + Directory_SDMC(const Archive_SDMC* archive, const std::string& path); + ~Directory_SDMC() override; + + /** + * List files contained in the directory + * @param count Number of entries to return at once in entries + * @param entries Buffer to read data into + * @return Number of entries listed + */ + u32 Read(const u32 count, Entry* entries) override; + + /** + * Close the directory + * @return true if the directory closed correctly + */ + bool Close() const override; + +private: + u32 entry_count; + u32 current_entry; + FileUtil::FSTEntry entry; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/file.h b/src/core/file_sys/file.h new file mode 100644 index 000000000..f7b009f5a --- /dev/null +++ b/src/core/file_sys/file.h @@ -0,0 +1,53 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +#include "core/hle/kernel/kernel.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +class File : NonCopyable { +public: + File() { } + virtual ~File() { } + + /** + * Read data from the file + * @param offset Offset in bytes to start reading data from + * @param length Length in bytes of data to read from file + * @param buffer Buffer to read data into + * @return Number of bytes read + */ + virtual size_t Read(const u64 offset, const u32 length, u8* buffer) const = 0; + + /** + * Write data to the file + * @param offset Offset in bytes to start writing data to + * @param length Length in bytes of data to write to file + * @param buffer Buffer to write data from + * @param flush The flush parameters (0 == do not flush) + * @return Number of bytes written + */ + virtual size_t Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const = 0; + + /** + * Get the size of the file in bytes + * @return Size of the file in bytes + */ + virtual size_t GetSize() const = 0; + + /** + * Close the file + * @return true if the file closed correctly + */ + virtual bool Close() const = 0; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/file_romfs.cpp b/src/core/file_sys/file_romfs.cpp new file mode 100644 index 000000000..00f3c2ea8 --- /dev/null +++ b/src/core/file_sys/file_romfs.cpp @@ -0,0 +1,59 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include "common/common_types.h" + +#include "core/file_sys/file_romfs.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +File_RomFS::File_RomFS() { +} + +File_RomFS::~File_RomFS() { +} + +/** + * Read data from the file + * @param offset Offset in bytes to start reading data from + * @param length Length in bytes of data to read from file + * @param buffer Buffer to read data into + * @return Number of bytes read + */ +size_t File_RomFS::Read(const u64 offset, const u32 length, u8* buffer) const { + return -1; +} + +/** + * Write data to the file + * @param offset Offset in bytes to start writing data to + * @param length Length in bytes of data to write to file + * @param buffer Buffer to write data from + * @param flush The flush parameters (0 == do not flush) + * @return Number of bytes written + */ +size_t File_RomFS::Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const { + return -1; +} + +/** + * Get the size of the file in bytes + * @return Size of the file in bytes + */ +size_t File_RomFS::GetSize() const { + return -1; +} + +/** + * Close the file + * @return true if the file closed correctly + */ +bool File_RomFS::Close() const { + return false; +} + +} // namespace FileSys diff --git a/src/core/file_sys/file_romfs.h b/src/core/file_sys/file_romfs.h new file mode 100644 index 000000000..5db43d4a0 --- /dev/null +++ b/src/core/file_sys/file_romfs.h @@ -0,0 +1,54 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +#include "core/file_sys/file.h" +#include "core/loader/loader.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +class File_RomFS final : public File { +public: + File_RomFS(); + ~File_RomFS() override; + + /** + * Read data from the file + * @param offset Offset in bytes to start reading data from + * @param length Length in bytes of data to read from file + * @param buffer Buffer to read data into + * @return Number of bytes read + */ + size_t Read(const u64 offset, const u32 length, u8* buffer) const override; + + /** + * Write data to the file + * @param offset Offset in bytes to start writing data to + * @param length Length in bytes of data to write to file + * @param buffer Buffer to write data from + * @param flush The flush parameters (0 == do not flush) + * @return Number of bytes written + */ + size_t Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const override; + + /** + * Get the size of the file in bytes + * @return Size of the file in bytes + */ + size_t GetSize() const override; + + /** + * Close the file + * @return true if the file closed correctly + */ + bool Close() const override; +}; + +} // namespace FileSys diff --git a/src/core/file_sys/file_sdmc.cpp b/src/core/file_sys/file_sdmc.cpp new file mode 100644 index 000000000..76adc6403 --- /dev/null +++ b/src/core/file_sys/file_sdmc.cpp @@ -0,0 +1,63 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include <sys/stat.h> + +#include "common/common_types.h" +#include "common/file_util.h" + +#include "core/file_sys/file_sdmc.h" +#include "core/file_sys/archive_sdmc.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +File_SDMC::File_SDMC(const Archive_SDMC* archive, const std::string& path, const Mode mode) { + // TODO(Link Mauve): normalize path into an absolute path without "..", it can currently bypass + // the root directory we set while opening the archive. + // For example, opening /../../etc/passwd can give the emulated program your users list. + std::string real_path = archive->GetMountPoint() + path; + + if (!mode.create_flag && !FileUtil::Exists(real_path)) { + file = nullptr; + return; + } + + std::string mode_string; + if (mode.read_flag) + mode_string += "r"; + if (mode.write_flag) + mode_string += "w"; + + file = new FileUtil::IOFile(real_path, mode_string.c_str()); +} + +File_SDMC::~File_SDMC() { + Close(); +} + +size_t File_SDMC::Read(const u64 offset, const u32 length, u8* buffer) const { + file->Seek(offset, SEEK_SET); + return file->ReadBytes(buffer, length); +} + +size_t File_SDMC::Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const { + file->Seek(offset, SEEK_SET); + size_t written = file->WriteBytes(buffer, length); + if (flush) + file->Flush(); + return written; +} + +size_t File_SDMC::GetSize() const { + return file->GetSize(); +} + +bool File_SDMC::Close() const { + return file->Close(); +} + +} // namespace FileSys diff --git a/src/core/file_sys/file_sdmc.h b/src/core/file_sys/file_sdmc.h new file mode 100644 index 000000000..b2e46f449 --- /dev/null +++ b/src/core/file_sys/file_sdmc.h @@ -0,0 +1,60 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" +#include "common/file_util.h" + +#include "core/file_sys/file.h" +#include "core/file_sys/archive_sdmc.h" +#include "core/loader/loader.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// FileSys namespace + +namespace FileSys { + +class File_SDMC final : public File { +public: + File_SDMC(); + File_SDMC(const Archive_SDMC* archive, const std::string& path, const Mode mode); + ~File_SDMC() override; + + /** + * Read data from the file + * @param offset Offset in bytes to start reading data from + * @param length Length in bytes of data to read from file + * @param buffer Buffer to read data into + * @return Number of bytes read + */ + size_t Read(const u64 offset, const u32 length, u8* buffer) const override; + + /** + * Write data to the file + * @param offset Offset in bytes to start writing data to + * @param length Length in bytes of data to write to file + * @param buffer Buffer to write data from + * @param flush The flush parameters (0 == do not flush) + * @return Number of bytes written + */ + size_t Write(const u64 offset, const u32 length, const u32 flush, const u8* buffer) const override; + + /** + * Get the size of the file in bytes + * @return Size of the file in bytes + */ + size_t GetSize() const override; + + /** + * Close the file + * @return true if the file closed correctly + */ + bool Close() const override; + +private: + FileUtil::IOFile* file; +}; + +} // namespace FileSys diff --git a/src/core/hle/kernel/archive.cpp b/src/core/hle/kernel/archive.cpp index 20536f40f..a7fa661d6 100644 --- a/src/core/hle/kernel/archive.cpp +++ b/src/core/hle/kernel/archive.cpp @@ -3,9 +3,12 @@ // Refer to the license.txt file included. #include "common/common_types.h" +#include "common/file_util.h" #include "common/math_util.h" #include "core/file_sys/archive.h" +#include "core/file_sys/archive_sdmc.h" +#include "core/file_sys/directory.h" #include "core/hle/service/service.h" #include "core/hle/kernel/archive.h" @@ -29,6 +32,14 @@ enum class FileCommand : u32 { Flush = 0x08090000, }; +// Command to access directory +enum class DirectoryCommand : u32 { + Dummy1 = 0x000100C6, + Control = 0x040100C4, + Read = 0x08010042, + Close = 0x08020000, +}; + class Archive : public Object { public: std::string GetTypeName() const { return "Archive"; } @@ -85,6 +96,13 @@ public: backend->SetSize(cmd_buff[1] | ((u64)cmd_buff[2] << 32)); break; } + case FileCommand::Close: + { + DEBUG_LOG(KERNEL, "Close %s %s", GetTypeName().c_str(), GetName().c_str()); + Kernel::g_object_pool.Destroy<Archive>(GetHandle()); + CloseArchive(backend->GetIdCode()); + break; + } // Unknown command... default: { @@ -108,6 +126,153 @@ public: } }; +class File : public Object { +public: + std::string GetTypeName() const { return "File"; } + std::string GetName() const { return path; } + + static Kernel::HandleType GetStaticHandleType() { return HandleType::File; } + Kernel::HandleType GetHandleType() const { return HandleType::File; } + + std::string path; ///< Path of the file + std::unique_ptr<FileSys::File> backend; ///< File backend interface + + /** + * Synchronize kernel object + * @param wait Boolean wait set if current thread should wait as a result of sync operation + * @return Result of operation, 0 on success, otherwise error code + */ + Result SyncRequest(bool* wait) { + u32* cmd_buff = Service::GetCommandBuffer(); + FileCommand cmd = static_cast<FileCommand>(cmd_buff[0]); + switch (cmd) { + + // Read from file... + case FileCommand::Read: + { + u64 offset = cmd_buff[1] | ((u64) cmd_buff[2]) << 32; + u32 length = cmd_buff[3]; + u32 address = cmd_buff[5]; + DEBUG_LOG(KERNEL, "Read %s %s: offset=0x%x length=%d address=0x%x", + GetTypeName().c_str(), GetName().c_str(), offset, length, address); + cmd_buff[2] = backend->Read(offset, length, Memory::GetPointer(address)); + break; + } + + // Write to file... + case FileCommand::Write: + { + u64 offset = cmd_buff[1] | ((u64) cmd_buff[2]) << 32; + u32 length = cmd_buff[3]; + u32 flush = cmd_buff[4]; + u32 address = cmd_buff[6]; + DEBUG_LOG(KERNEL, "Write %s %s: offset=0x%x length=%d address=0x%x, flush=0x%x", + GetTypeName().c_str(), GetName().c_str(), offset, length, address, flush); + cmd_buff[2] = backend->Write(offset, length, flush, Memory::GetPointer(address)); + break; + } + + case FileCommand::GetSize: + { + DEBUG_LOG(KERNEL, "GetSize %s %s", GetTypeName().c_str(), GetName().c_str()); + u64 size = backend->GetSize(); + cmd_buff[2] = (u32)size; + cmd_buff[3] = size >> 32; + break; + } + + case FileCommand::Close: + { + DEBUG_LOG(KERNEL, "Close %s %s", GetTypeName().c_str(), GetName().c_str()); + Kernel::g_object_pool.Destroy<File>(GetHandle()); + break; + } + + // Unknown command... + default: + ERROR_LOG(KERNEL, "Unknown command=0x%08X!", cmd); + cmd_buff[1] = -1; // TODO(Link Mauve): use the correct error code for that. + return -1; + } + cmd_buff[1] = 0; // No error + return 0; + } + + /** + * Wait for kernel object to synchronize + * @param wait Boolean wait set if current thread should wait as a result of sync operation + * @return Result of operation, 0 on success, otherwise error code + */ + Result WaitSynchronization(bool* wait) { + // TODO(bunnei): ImplementMe + ERROR_LOG(OSHLE, "(UNIMPLEMENTED)"); + return 0; + } +}; + +class Directory : public Object { +public: + std::string GetTypeName() const { return "Directory"; } + std::string GetName() const { return path; } + + static Kernel::HandleType GetStaticHandleType() { return HandleType::Directory; } + Kernel::HandleType GetHandleType() const { return HandleType::Directory; } + + std::string path; ///< Path of the directory + std::unique_ptr<FileSys::Directory> backend; ///< File backend interface + + /** + * Synchronize kernel object + * @param wait Boolean wait set if current thread should wait as a result of sync operation + * @return Result of operation, 0 on success, otherwise error code + */ + Result SyncRequest(bool* wait) { + u32* cmd_buff = Service::GetCommandBuffer(); + DirectoryCommand cmd = static_cast<DirectoryCommand>(cmd_buff[0]); + switch (cmd) { + + // Read from directory... + case DirectoryCommand::Read: + { + u32 count = cmd_buff[1]; + u32 address = cmd_buff[3]; + FileSys::Entry* entries = reinterpret_cast<FileSys::Entry*>(Memory::GetPointer(address)); + DEBUG_LOG(KERNEL, "Read %s %s: count=%d", GetTypeName().c_str(), GetName().c_str(), count); + + // Number of entries actually read + cmd_buff[2] = backend->Read(count, entries); + break; + } + + case DirectoryCommand::Close: + { + DEBUG_LOG(KERNEL, "Close %s %s", GetTypeName().c_str(), GetName().c_str()); + Kernel::g_object_pool.Destroy<Directory>(GetHandle()); + break; + } + + // Unknown command... + default: + ERROR_LOG(KERNEL, "Unknown command=0x%08X!", cmd); + cmd_buff[1] = -1; // TODO(Link Mauve): use the correct error code for that. + return -1; + } + cmd_buff[1] = 0; // No error + return 0; + } + + /** + * Wait for kernel object to synchronize + * @param wait Boolean wait set if current thread should wait as a result of sync operation + * @return Result of operation, 0 on success, otherwise error code + */ + Result WaitSynchronization(bool* wait) { + // TODO(bunnei): ImplementMe + ERROR_LOG(OSHLE, "(UNIMPLEMENTED)"); + return 0; + } +}; + //////////////////////////////////////////////////////////////////////////////////////////////////// std::map<FileSys::Archive::IdCode, Handle> g_archive_map; ///< Map of file archives by IdCode @@ -126,6 +291,21 @@ Handle OpenArchive(FileSys::Archive::IdCode id_code) { } /** + * Closes an archive + * @param id_code IdCode of the archive to open + * @return Result of operation, 0 on success, otherwise error code + */ +Result CloseArchive(FileSys::Archive::IdCode id_code) { + if (1 != g_archive_map.erase(id_code)) { + ERROR_LOG(KERNEL, "Cannot close archive %d", (int) id_code); + return -1; + } + + INFO_LOG(KERNEL, "Closed archive %d", (int) id_code); + return 0; +} + +/** * Mounts an archive * @param archive Pointer to the archive to mount * @return Result of operation, 0 on success, otherwise error code @@ -171,9 +351,56 @@ Handle CreateArchive(FileSys::Archive* backend, const std::string& name) { return handle; } +/** + * 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 Opened File object + */ +Handle OpenFileFromArchive(Handle archive_handle, const std::string& path, const FileSys::Mode mode) { + File* file = new File; + Handle handle = Kernel::g_object_pool.Create(file); + + Archive* archive = Kernel::g_object_pool.GetFast<Archive>(archive_handle); + file->path = path; + file->backend = archive->backend->OpenFile(path, mode); + + return handle; +} + +/** + * 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 Opened Directory object + */ +Handle OpenDirectoryFromArchive(Handle archive_handle, const std::string& path) { + Directory* directory = new Directory; + Handle handle = Kernel::g_object_pool.Create(directory); + + Archive* archive = Kernel::g_object_pool.GetFast<Archive>(archive_handle); + directory->path = path; + directory->backend = archive->backend->OpenDirectory(path); + + return handle; +} + /// Initialize archives void ArchiveInit() { g_archive_map.clear(); + + // TODO(Link Mauve): Add the other archive types (see here for the known types: + // http://3dbrew.org/wiki/FS:OpenArchive#Archive_idcodes). Currently the only half-finished + // archive type is SDMC, so it is the only one getting exposed. + + // TODO(Link Mauve): don't assume the path separator is '/'. + std::string sdmc_directory = FileUtil::GetCurrentDir() + "/userdata/sdmc"; + auto archive = new FileSys::Archive_SDMC(sdmc_directory); + if (archive->Initialize()) + CreateArchive(archive, "SDMC"); + else + ERROR_LOG(KERNEL, "Can't instantiate SDMC archive with path %s", sdmc_directory.c_str()); } /// Shutdown archives diff --git a/src/core/hle/kernel/archive.h b/src/core/hle/kernel/archive.h index 3758e7061..593861f8e 100644 --- a/src/core/hle/kernel/archive.h +++ b/src/core/hle/kernel/archive.h @@ -22,6 +22,13 @@ namespace Kernel { Handle OpenArchive(FileSys::Archive::IdCode id_code); /** + * Closes an archive + * @param id_code IdCode of the archive to open + * @return true if it worked fine + */ +Result CloseArchive(FileSys::Archive::IdCode id_code); + +/** * Creates an Archive * @param backend File system backend interface to the archive * @param name Optional name of Archive @@ -29,6 +36,23 @@ Handle OpenArchive(FileSys::Archive::IdCode id_code); */ Handle CreateArchive(FileSys::Archive* backend, const std::string& name); +/** + * 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 Opened File object + */ +Handle OpenFileFromArchive(Handle handle, const std::string& name, const FileSys::Mode mode); + +/** + * 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 Opened Directory object + */ +Handle OpenDirectoryFromArchive(Handle handle, const std::string& name); + /// Initialize archives void ArchiveInit(); diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index 0e7e5ff68..867d1b89c 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -32,6 +32,7 @@ enum class HandleType : u32 { File = 10, Semaphore = 11, Archive = 12, + Directory = 13, }; enum { diff --git a/src/core/hle/service/fs.cpp b/src/core/hle/service/fs.cpp index 9e1998b0f..8469d9840 100644 --- a/src/core/hle/service/fs.cpp +++ b/src/core/hle/service/fs.cpp @@ -12,35 +12,192 @@ namespace FS_User { +// Command to access archive file +enum class LowPathType : u32 { + Invalid = 0, + Empty = 1, + Binary = 2, + Char = 3, + Wchar = 4 +}; + +std::string GetStringFromCmdBuff(const u32 pointer, const u32 size) { + auto data = reinterpret_cast<const char*>(Memory::GetPointer(pointer)); + return std::string(data, size - 1); +} + +// We currently return 0 for success and -1 for failure in cmd_buff[1]. -1 was chosen because it +// puts all the sections of the http://3dbrew.org/wiki/Error_codes to something non-zero, to make +// sure we don't mislead the application into thinking something worked. + void Initialize(Service::Interface* self) { u32* cmd_buff = Service::GetCommandBuffer(); - cmd_buff[1] = 0; // No error + + // TODO(Link Mauve): check the behavior when cmd_buff[1] isn't 32, as per + // http://3dbrew.org/wiki/FS:Initialize#Request + cmd_buff[1] = 0; + + DEBUG_LOG(KERNEL, "called"); +} + +void OpenFile(Service::Interface* self) { + u32* cmd_buff = Service::GetCommandBuffer(); + + u32 transaction = cmd_buff[1]; + // TODO(Link Mauve): cmd_buff[2], aka archive handle lower word, isn't used according to + // 3dmoo's or ctrulib's implementations. Triple check if it's really the case. + Handle archive_handle = static_cast<Handle>(cmd_buff[3]); + LowPathType type = static_cast<LowPathType>(cmd_buff[4]); + u32 size = cmd_buff[5]; + FileSys::Mode mode; mode.hex = cmd_buff[6]; + u32 attributes = cmd_buff[7]; // TODO(Link Mauve): do something with those attributes. + u32 pointer = cmd_buff[9]; + + if (type != LowPathType::Char) { + ERROR_LOG(KERNEL, "file LowPath type other than char is currently unsupported"); + cmd_buff[1] = -1; + return; + } + + std::string file_name = GetStringFromCmdBuff(pointer, size); + + DEBUG_LOG(KERNEL, "type=%d size=%d mode=%d attrs=%d data=%s", type, size, mode, attributes, file_name.c_str()); + + Handle handle = Kernel::OpenFileFromArchive(archive_handle, file_name, mode); + if (handle) { + cmd_buff[1] = 0; + cmd_buff[3] = handle; + } else { + ERROR_LOG(KERNEL, "failed to get a handle for file %s", file_name.c_str()); + // TODO(Link Mauve): check for the actual error values, this one was just chosen arbitrarily. + cmd_buff[1] = -1; + } + DEBUG_LOG(KERNEL, "called"); } void OpenFileDirectly(Service::Interface* self) { u32* cmd_buff = Service::GetCommandBuffer(); - FileSys::Archive::IdCode arch_id = static_cast<FileSys::Archive::IdCode>(cmd_buff[2]); - - // TODO(bunnei): Properly implement use of these... - //u32 transaction = cmd_buff[1]; - //u32 arch_lowpath_type = cmd_buff[3]; - //u32 arch_lowpath_sz = cmd_buff[4]; - //u32 file_lowpath_type = cmd_buff[5]; - //u32 file_lowpath_sz = cmd_buff[6]; - //u32 flags = cmd_buff[7]; - //u32 attr = cmd_buff[8]; - //u32 arch_lowpath_desc = cmd_buff[9]; - //u32 arch_lowpath_ptr = cmd_buff[10]; - //u32 file_lowpath_desc = cmd_buff[11]; - //u32 file_lowpath_ptr = cmd_buff[12]; + u32 transaction = cmd_buff[1]; + auto archive_id = static_cast<FileSys::Archive::IdCode>(cmd_buff[2]); + LowPathType archive_type = static_cast<LowPathType>(cmd_buff[3]); + u32 archive_size = cmd_buff[4]; + LowPathType type = static_cast<LowPathType>(cmd_buff[5]); + u32 size = cmd_buff[6]; + FileSys::Mode mode; mode.hex = cmd_buff[7]; + u32 attributes = cmd_buff[8]; // TODO(Link Mauve): do something with those attributes. + u32 archive_pointer = cmd_buff[10]; + u32 pointer = cmd_buff[12]; + + if (archive_type != LowPathType::Empty) { + ERROR_LOG(KERNEL, "archive LowPath type other than empty is currently unsupported"); + cmd_buff[1] = -1; + return; + } + + if (type != LowPathType::Char) { + ERROR_LOG(KERNEL, "file LowPath type other than char is currently unsupported"); + cmd_buff[1] = -1; + return; + } + + std::string archive_name = GetStringFromCmdBuff(archive_pointer, archive_size); + std::string file_name = GetStringFromCmdBuff(pointer, size); + + DEBUG_LOG(KERNEL, "archive_type=%d archive_size=%d archive_data=%s" + "file_type=%d file_size=%d file_mode=%d file_attrs=%d file_data=%s", + archive_type, archive_size, archive_name.c_str(), + type, size, mode, attributes, file_name.c_str()); + + // TODO(Link Mauve): check if we should even get a handle for the archive, and don't leak it. + Handle archive_handle = Kernel::OpenArchive(archive_id); + if (archive_handle) { + cmd_buff[1] = 0; + // cmd_buff[2] isn't used according to 3dmoo's implementation. + cmd_buff[3] = archive_handle; + } else { + ERROR_LOG(KERNEL, "failed to get a handle for archive %s", archive_name.c_str()); + // TODO(Link Mauve): check for the actual error values, this one was just chosen arbitrarily. + cmd_buff[1] = -1; + return; + } + + Handle handle = Kernel::OpenFileFromArchive(archive_handle, file_name, mode); + if (handle) { + cmd_buff[1] = 0; + cmd_buff[3] = handle; + } else { + ERROR_LOG(KERNEL, "failed to get a handle for file %s", file_name.c_str()); + // TODO(Link Mauve): check for the actual error values, this one was just chosen arbitrarily. + cmd_buff[1] = -1; + } + + DEBUG_LOG(KERNEL, "called"); +} + +void OpenDirectory(Service::Interface* self) { + u32* cmd_buff = Service::GetCommandBuffer(); + + // TODO(Link Mauve): cmd_buff[2], aka archive handle lower word, isn't used according to + // 3dmoo's or ctrulib's implementations. Triple check if it's really the case. + Handle archive_handle = static_cast<Handle>(cmd_buff[2]); + LowPathType type = static_cast<LowPathType>(cmd_buff[3]); + u32 size = cmd_buff[4]; + u32 pointer = cmd_buff[6]; + + if (type != LowPathType::Char) { + ERROR_LOG(KERNEL, "directory LowPath type other than char is currently unsupported"); + cmd_buff[1] = -1; + return; + } + + std::string dir_name = GetStringFromCmdBuff(pointer, size); + + DEBUG_LOG(KERNEL, "type=%d size=%d data=%s", type, size, dir_name.c_str()); + + Handle handle = Kernel::OpenDirectoryFromArchive(archive_handle, dir_name); + if (handle) { + cmd_buff[1] = 0; + cmd_buff[3] = handle; + } else { + ERROR_LOG(KERNEL, "failed to get a handle for directory %s", dir_name.c_str()); + // TODO(Link Mauve): check for the actual error values, this one was just chosen arbitrarily. + cmd_buff[1] = -1; + } + + DEBUG_LOG(KERNEL, "called"); +} + +void OpenArchive(Service::Interface* self) { + u32* cmd_buff = Service::GetCommandBuffer(); + + auto arch_id = static_cast<FileSys::Archive::IdCode>(cmd_buff[1]); + LowPathType type = static_cast<LowPathType>(cmd_buff[2]); + u32 size = cmd_buff[3]; + u32 pointer = cmd_buff[5]; + + if (type != LowPathType::Empty) { + ERROR_LOG(KERNEL, "archive LowPath type other than empty is currently unsupported"); + cmd_buff[1] = -1; + return; + } + + std::string archive_name = GetStringFromCmdBuff(pointer, size); + + DEBUG_LOG(KERNEL, "type=%d size=%d data=%s", type, size, archive_name.c_str()); Handle handle = Kernel::OpenArchive(arch_id); - if (0 != handle) { - cmd_buff[1] = 0; // No error + if (handle) { + cmd_buff[1] = 0; + // cmd_buff[2] isn't used according to 3dmoo's implementation. cmd_buff[3] = handle; + } else { + ERROR_LOG(KERNEL, "failed to get a handle for archive %s", archive_name.c_str()); + // TODO(Link Mauve): check for the actual error values, this one was just chosen arbitrarily. + cmd_buff[1] = -1; } + DEBUG_LOG(KERNEL, "called"); } @@ -48,7 +205,7 @@ const Interface::FunctionInfo FunctionTable[] = { {0x000100C6, nullptr, "Dummy1"}, {0x040100C4, nullptr, "Control"}, {0x08010002, Initialize, "Initialize"}, - {0x080201C2, nullptr, "OpenFile"}, + {0x080201C2, OpenFile, "OpenFile"}, {0x08030204, OpenFileDirectly, "OpenFileDirectly"}, {0x08040142, nullptr, "DeleteFile"}, {0x08050244, nullptr, "RenameFile"}, @@ -57,8 +214,8 @@ const Interface::FunctionInfo FunctionTable[] = { {0x08080202, nullptr, "CreateFile"}, {0x08090182, nullptr, "CreateDirectory"}, {0x080A0244, nullptr, "RenameDirectory"}, - {0x080B0102, nullptr, "OpenDirectory"}, - {0x080C00C2, nullptr, "OpenArchive"}, + {0x080B0102, OpenDirectory, "OpenDirectory"}, + {0x080C00C2, OpenArchive, "OpenArchive"}, {0x080D0144, nullptr, "ControlArchive"}, {0x080E0080, nullptr, "CloseArchive"}, {0x080F0180, nullptr, "FormatThisUserSaveData"}, diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp index 76c9d6d54..389d5a8c9 100644 --- a/src/core/loader/elf.cpp +++ b/src/core/loader/elf.cpp @@ -351,7 +351,7 @@ ResultStatus AppLoader_ELF::Load() { if (is_loaded) return ResultStatus::ErrorAlreadyLoaded; - File::IOFile file(filename, "rb"); + FileUtil::IOFile file(filename, "rb"); if (file.IsOpen()) { u32 size = (u32)file.GetSize(); diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp index 577a2297a..a268e021a 100644 --- a/src/core/loader/loader.cpp +++ b/src/core/loader/loader.cpp @@ -78,7 +78,7 @@ ResultStatus LoadFile(const std::string& filename) { { INFO_LOG(LOADER, "Loading BIN file %s...", filename.c_str()); - File::IOFile file(filename, "rb"); + FileUtil::IOFile file(filename, "rb"); if (file.IsOpen()) { file.ReadBytes(Memory::GetPointer(Memory::EXEFS_CODE_VADDR), (size_t)file.GetSize()); diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp index 9af59e419..1e5501e6d 100644 --- a/src/core/loader/ncch.cpp +++ b/src/core/loader/ncch.cpp @@ -138,7 +138,7 @@ ResultStatus AppLoader_NCCH::LoadExec() const { */ ResultStatus AppLoader_NCCH::LoadSectionExeFS(const char* name, std::vector<u8>& buffer) const { // Iterate through the ExeFs archive until we find the .code file... - File::IOFile file(filename, "rb"); + FileUtil::IOFile file(filename, "rb"); if (file.IsOpen()) { for (int i = 0; i < kMaxSections; i++) { // Load the specified section... @@ -199,7 +199,7 @@ ResultStatus AppLoader_NCCH::Load() { if (is_loaded) return ResultStatus::ErrorAlreadyLoaded; - File::IOFile file(filename, "rb"); + FileUtil::IOFile file(filename, "rb"); if (file.IsOpen()) { file.ReadBytes(&ncch_header, sizeof(NCCH_Header)); @@ -290,7 +290,7 @@ ResultStatus AppLoader_NCCH::ReadLogo(std::vector<u8>& buffer) const { * @return ResultStatus result of function */ ResultStatus AppLoader_NCCH::ReadRomFS(std::vector<u8>& buffer) const { - File::IOFile file(filename, "rb"); + FileUtil::IOFile file(filename, "rb"); if (file.IsOpen()) { // Check if the NCCH has a RomFS... if (ncch_header.romfs_offset != 0 && ncch_header.romfs_size != 0) { diff --git a/src/video_core/debug_utils/debug_utils.cpp b/src/video_core/debug_utils/debug_utils.cpp index 48e6dd182..8f4aa0ad0 100644 --- a/src/video_core/debug_utils/debug_utils.cpp +++ b/src/video_core/debug_utils/debug_utils.cpp @@ -336,7 +336,7 @@ void DumpTexture(const Pica::Regs::TextureConfig& texture_config, u8* data) { png_infop info_ptr = nullptr; // Open file for writing (binary mode) - File::IOFile fp(filename, "wb"); + FileUtil::IOFile fp(filename, "wb"); // Initialize write structure png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); |