diff --git a/source/hactool_options.cpp b/source/hactool_options.cpp index 03bac7c..629e6cb 100644 --- a/source/hactool_options.cpp +++ b/source/hactool_options.cpp @@ -115,7 +115,7 @@ namespace ams::hactool { } const OptionHandler OptionHandlers[] = { - MakeOptionHandler("intype", "Specify input file type [nca, xci, pfs or pfs0 or nsp, appfs, npdm]", 't', [] (Options &options, const char *arg) { + MakeOptionHandler("intype", "Specify input file type [nca, xci, pfs or pfs0 or nsp, appfs, romfs, npdm]", 't', [] (Options &options, const char *arg) { if (std::strcmp(arg, "npdm") == 0) { options.file_type = FileType::Npdm; } else if (std::strcmp(arg, "nca") == 0) { @@ -124,6 +124,8 @@ namespace ams::hactool { options.file_type = FileType::Xci; } else if (std::strcmp(arg, "appfs") == 0) { options.file_type = FileType::AppFs; + } else if (std::strcmp(arg, "romfs") == 0) { + options.file_type = FileType::Romfs; } else if (std::strcmp(arg, "pfs") == 0 || std::strcmp(arg, "pfs0") == 0 || std::strcmp(arg, "nsp") == 0) { options.file_type = FileType::Pfs; } else { @@ -165,7 +167,6 @@ namespace ams::hactool { MakeOptionHandler("section1dir", "[nca] Specify Section 1 directory path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.section_out_dir_paths[1]), arg); }), MakeOptionHandler("section2dir", "[nca] Specify Section 2 directory path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.section_out_dir_paths[2]), arg); }), MakeOptionHandler("section3dir", "[nca] Specify Section 3 directory path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.section_out_dir_paths[3]), arg); }), - MakeOptionHandler("listupdate", "[nca] List update details.", [] (Options &options) { options.list_update = true; }), MakeOptionHandler("onlyupdated", "[nca] Ignore non-updated files in update partitions.", [] (Options &options) { options.only_updated = true; }), MakeOptionHandler("updatedsince", "[nca] Ignore files updated prior to a specific update generation.", [] (Options &options, const char *arg) { return ParseIntegerArgument(std::addressof(options.updated_generation), arg); }), MakeOptionHandler("json", "[nca/exefs/npdm/kip] Specify file path for saving JSON representation of program permissions.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.json_out_file_path), arg); }), @@ -174,6 +175,7 @@ namespace ams::hactool { MakeOptionHandler("normaldir", "[xci] Specify xci normal hfs0 directory path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.normal_partition_out_dir), arg); }), MakeOptionHandler("updatedir", "[xci] Specify xci update hfs0 directory path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.update_partition_out_dir), arg); }), MakeOptionHandler("logodir", "[xci] Specify xci logo hfs0 directory path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.logo_partition_out_dir), arg); }), + MakeOptionHandler("listupdate", "[xci] List update details.", [] (Options &options) { options.list_update = true; }), MakeOptionHandler("ciphertext", "[unused] Specify ciphertext output path.", [] (Options &options, const char *arg) { return CreateFilePath(std::addressof(options.ciphertext_out_path), arg); }), }; diff --git a/source/hactool_processor.hpp b/source/hactool_processor.hpp index 13b70b0..bc64306 100644 --- a/source/hactool_processor.hpp +++ b/source/hactool_processor.hpp @@ -135,6 +135,11 @@ namespace ams::hactool { ProcessAsNpdmContext npdm_ctx; ProcessAsApplicationFileSystemContext app_ctx; }; + + struct ProcessAsRomfsContext { + std::shared_ptr storage; + std::shared_ptr fs; + }; private: Options m_options; fssrv::impl::ExternalKeyManager m_external_nca_key_manager; @@ -235,6 +240,7 @@ namespace ams::hactool { Result ProcessAsNpdm(std::shared_ptr storage, ProcessAsNpdmContext *ctx = nullptr); Result ProcessAsXci(std::shared_ptr storage, ProcessAsXciContext *ctx = nullptr); Result ProcessAsPfs(std::shared_ptr storage, ProcessAsPfsContext *ctx = nullptr); + Result ProcessAsRomfs(std::shared_ptr storage, ProcessAsRomfsContext *ctx = nullptr); Result ProcessAsApplicationFileSystem(std::shared_ptr fs, ProcessAsApplicationFileSystemContext *ctx = nullptr); /* Printing. */ @@ -242,6 +248,7 @@ namespace ams::hactool { void PrintAsNpdm(ProcessAsNpdmContext &ctx); void PrintAsXci(ProcessAsXciContext &ctx); void PrintAsPfs(ProcessAsPfsContext &ctx); + void PrintAsRomfs(ProcessAsRomfsContext &ctx); void PrintAsApplicationFileSystem(ProcessAsApplicationFileSystemContext &ctx); /* Saving. */ @@ -249,6 +256,7 @@ namespace ams::hactool { void SaveAsNpdm(ProcessAsNpdmContext &ctx); void SaveAsXci(ProcessAsXciContext &ctx); void SaveAsPfs(ProcessAsPfsContext &ctx); + void SaveAsRomfs(ProcessAsRomfsContext &ctx); void SaveAsApplicationFileSystem(ProcessAsApplicationFileSystemContext &ctx); }; diff --git a/source/hactool_processor.main.cpp b/source/hactool_processor.main.cpp index 4392b1a..a96d102 100644 --- a/source/hactool_processor.main.cpp +++ b/source/hactool_processor.main.cpp @@ -123,6 +123,9 @@ namespace ams::hactool { case FileType::Pfs: R_TRY(this->ProcessAsPfs(std::move(input))); break; + case FileType::Romfs: + R_TRY(this->ProcessAsRomfs(std::move(input))); + break; AMS_UNREACHABLE_DEFAULT_CASE(); } } diff --git a/source/hactool_processor.romfs.cpp b/source/hactool_processor.romfs.cpp new file mode 100644 index 0000000..691914d --- /dev/null +++ b/source/hactool_processor.romfs.cpp @@ -0,0 +1,121 @@ +/* + * Copyright (c) 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 . + */ +#include +#include "hactool_processor.hpp" +#include "hactool_fs_utils.hpp" + +namespace ams::hactool { + + namespace { + + /* Taken from fssrv::RomFileSystemCreator. */ + class RomFileSystemWithBuffer : public ::ams::fssystem::RomFsFileSystem { + private: + void *m_meta_cache_buffer; + size_t m_meta_cache_buffer_size; + MemoryResource *m_allocator; + public: + explicit RomFileSystemWithBuffer(MemoryResource *mr) : m_meta_cache_buffer(nullptr), m_allocator(mr) { /* ... */ } + + ~RomFileSystemWithBuffer() { + if (m_meta_cache_buffer != nullptr) { + m_allocator->Deallocate(m_meta_cache_buffer, m_meta_cache_buffer_size); + } + } + + Result Initialize(std::shared_ptr storage) { + /* Check if the buffer is eligible for cache. */ + size_t buffer_size = 0; + if (R_FAILED(RomFsFileSystem::GetRequiredWorkingMemorySize(std::addressof(buffer_size), storage.get())) || buffer_size == 0 || buffer_size >= 128_KB) { + R_RETURN(RomFsFileSystem::Initialize(std::move(storage), nullptr, 0, false)); + } + + /* Allocate a buffer. */ + m_meta_cache_buffer = m_allocator->Allocate(buffer_size); + if (m_meta_cache_buffer == nullptr) { + R_RETURN(RomFsFileSystem::Initialize(std::move(storage), nullptr, 0, false)); + } + + /* Initialize with cache buffer. */ + m_meta_cache_buffer_size = buffer_size; + R_RETURN(RomFsFileSystem::Initialize(std::move(storage), m_meta_cache_buffer, m_meta_cache_buffer_size, true)); + } + }; + + } + + Result Processor::ProcessAsRomfs(std::shared_ptr storage, ProcessAsRomfsContext *ctx) { + /* Ensure we have a context. */ + ProcessAsRomfsContext local_ctx{}; + if (ctx == nullptr) { + ctx = std::addressof(local_ctx); + } + + /* Set the fs. */ + ctx->storage = std::move(storage); + + /* Mount the rom filesystem. */ + { + /* Allocate the fs. */ + auto fs = fssystem::AllocateShared(sf::GetNewDeleteMemoryResource()); + R_UNLESS(fs != nullptr, fs::ResultAllocationMemoryFailedInRomFileSystemCreatorA()); + + /* Initialize the filesystem. */ + R_TRY(fs->Initialize(std::shared_ptr(ctx->storage))); + + /* Set the context fs. */ + ctx->fs = std::move(fs); + } + + /* Print. */ + if (ctx == std::addressof(local_ctx)) { + this->PrintAsRomfs(*ctx); + } + + /* Save. */ + if (ctx == std::addressof(local_ctx)) { + this->SaveAsRomfs(*ctx); + } + + R_SUCCEED(); + } + + void Processor::PrintAsRomfs(ProcessAsRomfsContext &ctx) { + /* There's nothing meaningful to print about romfs. */ + AMS_UNUSED(ctx); + } + + void Processor::SaveAsRomfs(ProcessAsRomfsContext &ctx) { + if (m_options.list_romfs) { + PrintDirectory(ctx.fs, "rom:", "/"); + } else { + /* Determine path to extract to. */ + const char *dir_path = nullptr; + if (dir_path == nullptr && m_options.romfs_out_dir_path != nullptr) { + dir_path = m_options.romfs_out_dir_path; + } + if (dir_path == nullptr && m_options.default_out_dir_path != nullptr) { + dir_path = m_options.default_out_dir_path; + } + + /* If we have a path, extract to it. */ + if (dir_path != nullptr) { + ExtractDirectory(m_local_fs, ctx.fs, "rom:", dir_path, "/"); + } + } + } + +} \ No newline at end of file