From 7bb708e394e8d079d4aee8a03772401cc13720dd Mon Sep 17 00:00:00 2001 From: Pablo Curiel Date: Mon, 12 Sep 2022 20:19:10 +0200 Subject: [PATCH] Many small changes (sorry, I need to push these). * Use forward declarations for type definitions wherever suitable (e.g. NcaContext, BucketTreeContext). * Replace references to "DumpDestination" with "OutputStorage". * Replace references to "append key area" with "prepend key area". * Update LZ4 to v1.9.4. * Update Material Icons font to 2022-08-01. * RootView: change USB-related icons, reflect how many UMS devices are currently connected to the console, provide a way for child views to retrieve the populated UMS devices vector. * Tasks: implement GetUmsDevices(). * Update borealis. * Update libusbhsfs. * Begin implementation of a DumpOptionsFrame class to display configurable options before starting a new dump process. * bktr: rename bktrIsValidSubstorage() to bktrIsValidSubStorage(), use bktrIsValidSubStorage() in bktrInitializeCompressedStorageContext(), fixed a bug in bktrReadCompressedStorage() where Sparse substorages wouldn't be allowed. * GamecardTab: push a DumpOptionsFrame object onto the view stack if the XCI option is clicked. --- include/core/bktr.h | 13 +- include/core/config.h | 8 +- include/core/lz4.h | 160 ++++-- include/core/nca.h | 11 +- include/core/pfs.h | 2 +- include/core/romfs.h | 2 +- include/defines.h | 3 +- include/dump_options_frame.hpp | 340 +++++++++++++ include/root_view.hpp | 9 +- include/tasks.hpp | 5 +- libs/borealis | 2 +- libs/libusbhsfs | 2 +- romfs/default_config.json | 4 +- romfs/i18n/en-US/dump_options.json | 42 ++ romfs/i18n/en-US/generic.json | 5 +- romfs/i18n/en-US/options_tab.json | 4 +- romfs/i18n/en-US/root_view.json | 9 +- romfs/material/MaterialIcons-Regular.ttf | Bin 128180 -> 356220 bytes source/core/bktr.c | 45 +- source/core/config.c | 12 +- source/core/lz4.c | 615 ++++++++++++++++------- source/core/nca.c | 34 +- source/core/nca_storage.c | 2 +- source/core/npdm.c | 2 +- source/core/nso.c | 5 +- source/core/pfs.c | 5 +- source/core/romfs.c | 4 +- source/gamecard_tab.cpp | 14 +- source/options_tab.cpp | 4 +- source/root_view.cpp | 58 ++- source/tasks.cpp | 5 + source/titles_tab.cpp | 2 +- 32 files changed, 1085 insertions(+), 343 deletions(-) create mode 100644 include/dump_options_frame.hpp create mode 100644 romfs/i18n/en-US/dump_options.json diff --git a/include/core/bktr.h b/include/core/bktr.h index 5c94479..621c588 100644 --- a/include/core/bktr.h +++ b/include/core/bktr.h @@ -161,14 +161,17 @@ typedef enum { BucketTreeSubStorageType_Count = 5 ///< Total values supported by this enum. } BucketTreeSubStorageType; +// Forward declaration for BucketTreeSubStorage. +typedef struct _BucketTreeContext BucketTreeContext; + typedef struct { u8 index; ///< Substorage index. NcaFsSectionContext *nca_fs_ctx; ///< NCA FS section context. Used to perform operations on the target NCA. u8 type; ///< BucketTreeSubStorageType. - void *bktr_ctx; ///< BucketTreeContext related to this storage. Only used if type > BucketTreeSubStorageType_Regular. + BucketTreeContext *bktr_ctx; ///< BucketTreeContext related to this storage. Only used if type > BucketTreeSubStorageType_Regular. } BucketTreeSubStorage; -typedef struct { +struct _BucketTreeContext { NcaFsSectionContext *nca_fs_ctx; ///< NCA FS section context. Used to perform operations on the target NCA. u8 storage_type; ///< BucketTreeStorageType. BucketTreeTable *storage_table; ///< Pointer to the dynamically allocated Bucket Tree Table for this storage. @@ -181,7 +184,7 @@ typedef struct { u64 start_offset; ///< Virtual storage start offset. u64 end_offset; ///< Virtual storage end offset. BucketTreeSubStorage substorages[BKTR_MAX_SUBSTORAGE_COUNT]; ///< Substorages required for this BucketTree storage. May be set after initializing this context. -} BucketTreeContext; +}; /// Initializes a Bucket Tree context using the provided NCA FS section context and a storage type. /// 'storage_type' may only be BucketTreeStorageType_Indirect, BucketTreeStorageType_AesCtrEx or BucketTreeStorageType_Sparse. @@ -231,11 +234,11 @@ NX_INLINE bool bktrIsBlockWithinStorageRange(BucketTreeContext *ctx, u64 size, u return (bktrIsValidContext(ctx) && size > 0 && ctx->start_offset <= offset && size <= (ctx->end_offset - offset)); } -NX_INLINE bool bktrIsValidSubstorage(BucketTreeSubStorage *substorage) +NX_INLINE bool bktrIsValidSubStorage(BucketTreeSubStorage *substorage) { return (substorage && substorage->index < BKTR_MAX_SUBSTORAGE_COUNT && substorage->nca_fs_ctx && substorage->type < BucketTreeSubStorageType_Count && \ ((substorage->type == BucketTreeSubStorageType_Regular && substorage->index == 0 && !substorage->bktr_ctx) || \ - (substorage->type > BucketTreeSubStorageType_Regular && substorage->bktr_ctx))); + (substorage->type > BucketTreeSubStorageType_Regular && substorage->bktr_ctx && substorage->bktr_ctx->nca_fs_ctx == substorage->nca_fs_ctx))); } #ifdef __cplusplus diff --git a/include/core/config.h b/include/core/config.h index cc90107..80e11b4 100644 --- a/include/core/config.h +++ b/include/core/config.h @@ -31,10 +31,10 @@ extern "C" { #endif typedef enum { - ConfigDumpDestination_SdCard = 0, - ConfigDumpDestination_UsbHost = 1, - ConfigDumpDestination_Count = 2 -} ConfigDumpDestination; + ConfigOutputStorage_SdCard = 0, + ConfigOutputStorage_UsbHost = 1, + ConfigOutputStorage_Count = 2 +} ConfigOutputStorage; typedef enum { ConfigChecksumLookupMethod_None = 0, diff --git a/include/core/lz4.h b/include/core/lz4.h index 7ab1e48..491c608 100644 --- a/include/core/lz4.h +++ b/include/core/lz4.h @@ -1,7 +1,7 @@ /* * LZ4 - Fast LZ compression algorithm * Header File - * Copyright (C) 2011-present, Yann Collet. + * Copyright (C) 2011-2020, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) @@ -97,36 +97,77 @@ extern "C" { # define LZ4LIB_API LZ4LIB_VISIBILITY #endif +/*! LZ4_FREESTANDING : + * When this macro is set to 1, it enables "freestanding mode" that is + * suitable for typical freestanding environment which doesn't support + * standard C library. + * + * - LZ4_FREESTANDING is a compile-time switch. + * - It requires the following macros to be defined: + * LZ4_memcpy, LZ4_memmove, LZ4_memset. + * - It only enables LZ4/HC functions which don't use heap. + * All LZ4F_* functions are not supported. + * - See tests/freestanding.c to check its basic setup. + */ +#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1) +# define LZ4_HEAPMODE 0 +# define LZ4HC_HEAPMODE 0 +# define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1 +# if !defined(LZ4_memcpy) +# error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'." +# endif +# if !defined(LZ4_memset) +# error "LZ4_FREESTANDING requires macro 'LZ4_memset'." +# endif +# if !defined(LZ4_memmove) +# error "LZ4_FREESTANDING requires macro 'LZ4_memmove'." +# endif +#elif ! defined(LZ4_FREESTANDING) +# define LZ4_FREESTANDING 0 +#endif + + /*------ Version ------*/ #define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */ #define LZ4_VERSION_MINOR 9 /* for new (non-breaking) interface capabilities */ -#define LZ4_VERSION_RELEASE 3 /* for tweaks, bug-fixes, or development */ +#define LZ4_VERSION_RELEASE 4 /* for tweaks, bug-fixes, or development */ #define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE) #define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE #define LZ4_QUOTE(str) #str #define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str) -#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION) +#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION) /* requires v1.7.3+ */ -LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; useful to check dll version */ -LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; useful to check dll version */ +LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; useful to check dll version; requires v1.3.0+ */ +LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; useful to check dll version; requires v1.7.5+ */ /*-************************************ * Tuning parameter **************************************/ +#define LZ4_MEMORY_USAGE_MIN 10 +#define LZ4_MEMORY_USAGE_DEFAULT 14 +#define LZ4_MEMORY_USAGE_MAX 20 + /*! * LZ4_MEMORY_USAGE : - * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) - * Increasing memory usage improves compression ratio. - * Reduced memory usage may improve speed, thanks to better cache locality. + * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; ) + * Increasing memory usage improves compression ratio, at the cost of speed. + * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality. * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */ #ifndef LZ4_MEMORY_USAGE -# define LZ4_MEMORY_USAGE 14 +# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT #endif +#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN) +# error "LZ4_MEMORY_USAGE is too small !" +#endif + +#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX) +# error "LZ4_MEMORY_USAGE is too large !" +#endif /*-************************************ * Simple Functions @@ -270,8 +311,25 @@ LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcS ***********************************************/ typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */ +/** + Note about RC_INVOKED + + - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio). + https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros + + - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars) + and reports warning "RC4011: identifier truncated". + + - To eliminate the warning, we surround long preprocessor symbol with + "#if !defined(RC_INVOKED) ... #endif" block that means + "skip this block when rc.exe is trying to read it". +*/ +#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4LIB_API LZ4_stream_t* LZ4_createStream(void); LZ4LIB_API int LZ4_freeStream (LZ4_stream_t* streamPtr); +#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ +#endif /*! LZ4_resetStream_fast() : v1.9.0+ * Use this to prepare an LZ4_stream_t for a new chain of dependent blocks @@ -355,8 +413,12 @@ typedef union LZ4_streamDecode_u LZ4_streamDecode_t; /* tracking context */ * creation / destruction of streaming decompression tracking context. * A tracking context can be re-used multiple times. */ +#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void); LZ4LIB_API int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream); +#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */ +#endif /*! LZ4_setStreamDecode() : * An LZ4_streamDecode_t context can be allocated once and re-used multiple times. @@ -406,7 +468,10 @@ LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize); * save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression, * then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block. */ -LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity); +LZ4LIB_API int +LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, + const char* src, char* dst, + int srcSize, int dstCapacity); /*! LZ4_decompress_*_usingDict() : @@ -417,7 +482,16 @@ LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecod * Performance tip : Decompression speed can be substantially increased * when dst == dictStart + dictSize. */ -LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* src, char* dst, int srcSize, int dstCapcity, const char* dictStart, int dictSize); +LZ4LIB_API int +LZ4_decompress_safe_usingDict(const char* src, char* dst, + int srcSize, int dstCapacity, + const char* dictStart, int dictSize); + +LZ4LIB_API int +LZ4_decompress_safe_partial_usingDict(const char* src, char* dst, + int compressedSize, + int targetOutputSize, int maxOutputSize, + const char* dictStart, int dictSize); #endif /* LZ4_H_2983827168210 */ @@ -496,13 +570,15 @@ LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const c * stream (and source buffer) must remain in-place / accessible / unchanged * through the completion of the first compression call on the stream. */ -LZ4LIB_STATIC_API void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream); +LZ4LIB_STATIC_API void +LZ4_attach_dictionary(LZ4_stream_t* workingStream, + const LZ4_stream_t* dictionaryStream); /*! In-place compression and decompression * * It's possible to have input and output sharing the same buffer, - * for highly contrained memory environments. + * for highly constrained memory environments. * In both cases, it requires input to lay at the end of the buffer, * and decompression to start at beginning of the buffer. * Buffer size must feature some margin, hence be larger than final size. @@ -592,38 +668,26 @@ LZ4LIB_STATIC_API void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const typedef unsigned int LZ4_u32; #endif +/*! LZ4_stream_t : + * Never ever use below internal definitions directly ! + * These definitions are not API/ABI safe, and may change in future versions. + * If you need static allocation, declare or allocate an LZ4_stream_t object. +**/ + typedef struct LZ4_stream_t_internal LZ4_stream_t_internal; struct LZ4_stream_t_internal { LZ4_u32 hashTable[LZ4_HASH_SIZE_U32]; - LZ4_u32 currentOffset; - LZ4_u32 tableType; const LZ4_byte* dictionary; const LZ4_stream_t_internal* dictCtx; + LZ4_u32 currentOffset; + LZ4_u32 tableType; LZ4_u32 dictSize; + /* Implicit padding to ensure structure is aligned */ }; -typedef struct { - const LZ4_byte* externalDict; - size_t extDictSize; - const LZ4_byte* prefixEnd; - size_t prefixSize; -} LZ4_streamDecode_t_internal; - - -/*! LZ4_stream_t : - * Do not use below internal definitions directly ! - * Declare or allocate an LZ4_stream_t instead. - * LZ4_stream_t can also be created using LZ4_createStream(), which is recommended. - * The structure definition can be convenient for static allocation - * (on stack, or as part of larger structure). - * Init this structure with LZ4_initStream() before first use. - * note : only use this definition in association with static linking ! - * this definition is not API/ABI safe, and may change in future versions. - */ -#define LZ4_STREAMSIZE 16416 /* static size, for inter-version compatibility */ -#define LZ4_STREAMSIZE_VOIDP (LZ4_STREAMSIZE / sizeof(void*)) +#define LZ4_STREAM_MINSIZE ((1UL << LZ4_MEMORY_USAGE) + 32) /* static size, for inter-version compatibility */ union LZ4_stream_u { - void* table[LZ4_STREAMSIZE_VOIDP]; + char minStateSize[LZ4_STREAM_MINSIZE]; LZ4_stream_t_internal internal_donotuse; }; /* previously typedef'd to LZ4_stream_t */ @@ -641,21 +705,25 @@ union LZ4_stream_u { * In which case, the function will @return NULL. * Note2: An LZ4_stream_t structure guarantees correct alignment and size. * Note3: Before v1.9.0, use LZ4_resetStream() instead - */ +**/ LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* buffer, size_t size); /*! LZ4_streamDecode_t : - * information structure to track an LZ4 stream during decompression. - * init this structure using LZ4_setStreamDecode() before first use. - * note : only use in association with static linking ! - * this definition is not API/ABI safe, - * and may change in a future version ! - */ -#define LZ4_STREAMDECODESIZE_U64 (4 + ((sizeof(void*)==16) ? 2 : 0) /*AS-400*/ ) -#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long)) + * Never ever use below internal definitions directly ! + * These definitions are not API/ABI safe, and may change in future versions. + * If you need static allocation, declare or allocate an LZ4_streamDecode_t object. +**/ +typedef struct { + const LZ4_byte* externalDict; + const LZ4_byte* prefixEnd; + size_t extDictSize; + size_t prefixSize; +} LZ4_streamDecode_t_internal; + +#define LZ4_STREAMDECODE_MINSIZE 32 union LZ4_streamDecode_u { - unsigned long long table[LZ4_STREAMDECODESIZE_U64]; + char minStateSize[LZ4_STREAMDECODE_MINSIZE]; LZ4_streamDecode_t_internal internal_donotuse; } ; /* previously typedef'd to LZ4_streamDecode_t */ diff --git a/include/core/nca.h b/include/core/nca.h index b7502b2..93688a4 100644 --- a/include/core/nca.h +++ b/include/core/nca.h @@ -358,11 +358,14 @@ typedef enum { NcaFsSectionType_Invalid = 4 } NcaFsSectionType; +// Forward declaration for NcaFsSectionContext. +typedef struct _NcaContext NcaContext; + /// Unlike NCA contexts, we don't need to keep a hash for the NCA FS section header in NCA FS section contexts. /// This is because the functions that modify the NCA FS section header also update the NCA FS section header hash stored in the NCA header. typedef struct { bool enabled; ///< Set to true if this NCA FS section has passed all validation checks and can be safely used. - void *nca_ctx; ///< NcaContext. Used to perform NCA reads. + NcaContext *nca_ctx; ///< NcaContext. Used to perform NCA reads. NcaFsHeader header; ///< Plaintext NCA FS section header. NcaFsHeader encrypted_header; ///< Encrypted NCA FS section header. If the plaintext NCA FS section header is modified, this will hold an encrypted copy of it. ///< Otherwise, this holds the unmodified, encrypted NCA FS section header. @@ -418,7 +421,7 @@ typedef struct { NXDT_ASSERT(NcaDecryptedKeyArea, NCA_KEY_AREA_USED_SIZE); -typedef struct { +struct _NcaContext { u8 storage_id; ///< NcmStorageId. NcmContentStorage *ncm_storage; ///< Pointer to a NcmContentStorage instance. Used to read NCA data from eMMC/SD. u64 gamecard_offset; ///< Used to read NCA data from a gamecard using a FsStorage instance when storage_id == NcmStorageId_GameCard. @@ -448,7 +451,7 @@ typedef struct { void *content_type_ctx; ///< Pointer to a content type context (e.g. ContentMetaContext, ProgramInfoContext, NacpContext, LegalInfoContext). Set to NULL if unused. bool content_type_ctx_patch; ///< Set to true if a NCA patch generated by the content type context is needed and hasn't been completely written yet. u32 content_type_ctx_data_idx; ///< Start index for the data generated by the content type context. Used while creating NSPs. -} NcaContext; +}; typedef struct { bool written; ///< Set to true if this patch has already been written. @@ -478,7 +481,7 @@ void ncaFreeCryptoBuffer(void); /// Initializes a NCA context. /// If 'storage_id' == NcmStorageId_GameCard, the 'hfs_partition_type' argument must be a valid GameCardHashFileSystemPartitionType value. /// If the NCA holds a populated Rights ID field, ticket data will need to be retrieved. -/// If the 'tik' argument points to a valid Ticket element, it will either be updated (if it's empty) or be used to read ticket data that has already been retrieved. +/// If the 'tik' argument points to a valid Ticket element, it will either be updated (if it's empty) or used to read ticket data that has already been retrieved. /// If the 'tik' argument is NULL, the function will just retrieve the necessary ticket data on its own. /// If ticket data can't be retrieved, the context will still be initialized, but anything that involves working with encrypted NCA FS section blocks won't be possible (e.g. ncaReadFsSection()). bool ncaInitializeContext(NcaContext *out, u8 storage_id, u8 hfs_partition_type, const NcmContentInfo *content_info, u32 title_version, Ticket *tik); diff --git a/include/core/pfs.h b/include/core/pfs.h index b515e1b..35e5dd5 100644 --- a/include/core/pfs.h +++ b/include/core/pfs.h @@ -157,7 +157,7 @@ NX_INLINE void pfsWriteEntryPatchToMemoryBuffer(PartitionFileSystemContext *ctx, { if (!ctx || !ncaStorageIsValidContext(&(ctx->storage_ctx)) || ctx->nca_fs_ctx != ctx->storage_ctx.nca_fs_ctx || \ ctx->storage_ctx.base_storage_type != NcaStorageBaseStorageType_Regular) return; - ncaWriteHierarchicalSha256PatchToMemoryBuffer((NcaContext*)ctx->nca_fs_ctx->nca_ctx, patch, buf, buf_size, buf_offset); + ncaWriteHierarchicalSha256PatchToMemoryBuffer(ctx->nca_fs_ctx->nca_ctx, patch, buf, buf_size, buf_offset); } NX_INLINE void pfsFreeEntryPatch(NcaHierarchicalSha256Patch *patch) diff --git a/include/core/romfs.h b/include/core/romfs.h index e1c6769..41bc198 100644 --- a/include/core/romfs.h +++ b/include/core/romfs.h @@ -281,7 +281,7 @@ NX_INLINE void romfsWriteFileEntryPatchToMemoryBuffer(RomFileSystemContext *ctx, (!patch->use_old_format_patch && ctx->default_storage_ctx->nca_fs_ctx->section_type != NcaFsSectionType_RomFs) || \ (patch->use_old_format_patch && ctx->default_storage_ctx->nca_fs_ctx->section_type != NcaFsSectionType_Nca0RomFs)) return; - NcaContext *nca_ctx = (NcaContext*)ctx->default_storage_ctx->nca_fs_ctx->nca_ctx; + NcaContext *nca_ctx = ctx->default_storage_ctx->nca_fs_ctx->nca_ctx; if (patch->use_old_format_patch) { diff --git a/include/defines.h b/include/defines.h index 3c8c35e..effd7b7 100644 --- a/include/defines.h +++ b/include/defines.h @@ -121,7 +121,8 @@ #define GITHUB_API_RELEASE_URL GITHUB_API_URL "/repos/" GITHUB_REPOSITORY "/releases/latest" #define NSWDB_XML_URL "http://nswdb.com/xml.php" -#define NSWDB_XML_PATH APP_BASE_PATH "NSWreleases.xml" +#define NSWDB_XML_NAME "NSWreleases.xml" +#define NSWDB_XML_PATH APP_BASE_PATH NSWDB_XML_NAME #define BOREALIS_URL "https://github.com/natinusala/borealis" #define LIBUSBHSFS_URL "https://github.com/DarkMatterCore/libusbhsfs" diff --git a/include/dump_options_frame.hpp b/include/dump_options_frame.hpp new file mode 100644 index 0000000..c436fc2 --- /dev/null +++ b/include/dump_options_frame.hpp @@ -0,0 +1,340 @@ +/* + * dump_options_frame.hpp + * + * Copyright (c) 2020-2022, DarkMatterCore . + * + * This file is part of nxdumptool (https://github.com/DarkMatterCore/nxdumptool). + * + * nxdumptool is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * nxdumptool is distributed in the hope that 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 . + */ + +#pragma once + +#ifndef __DUMP_OPTIONS_FRAME_HPP__ +#define __DUMP_OPTIONS_FRAME_HPP__ + +#include + + + + +using namespace brls::i18n::literals; + + + + + +namespace nxdt::views +{ + class DumpOptionsFrame: public brls::ThumbnailFrame + { + private: + RootView *root_view = nullptr; + nxdt::tasks::UmsEvent::Subscription ums_task_sub; + + char *raw_filename = NULL; + const char *extension = NULL; + + brls::List *list = nullptr; + brls::InputListItem *filename_input = nullptr; + brls::SelectListItem *output_storage = nullptr; + brls::ToggleListItem *prepend_key_area = nullptr; + brls::ToggleListItem *keep_certificate = nullptr; + brls::ToggleListItem *trim_dump = nullptr; + brls::ToggleListItem *calculate_checksum = nullptr; + brls::SelectListItem *checksum_lookup_method = nullptr; + + std::string RegenerateFileName(void) + { + if (!this->raw_filename) return "dummy"; + + char *raw_filename_dup = strdup(this->raw_filename); + if (!raw_filename_dup) return "dummy"; + + u8 selected = static_cast(this->output_storage ? this->output_storage->getSelectedValue() : configGetInteger("output_storage")); + utilsReplaceIllegalCharacters(raw_filename_dup, selected == ConfigOutputStorage_SdCard); + + std::string output = std::string(raw_filename_dup); + free(raw_filename_dup); + + return output; + } + + void UpdateRawFileName(void) + { + if (raw_filename) free(this->raw_filename); + this->raw_filename = strdup(this->filename_input->getValue().c_str()); + } + + void UpdateStorages(const nxdt::tasks::UmsDeviceVector* ums_devices) + { + if (!this->output_storage) return; + + std::vector *storages = this->output_storage->getValues(); + storages->clear(); + + storages->push_back("dump_options/output_storage/value_00"_i18n); + storages->push_back("dump_options/output_storage/value_01"_i18n); + + for(const UsbHsFsDevice& cur_ums_device : *ums_devices) + { + std::string device_str = (std::string(cur_ums_device.name) + ", "); + if (cur_ums_device.product_name[0]) device_str += (std::string(cur_ums_device.product_name) + ", "); + device_str += fmt::format("LUN {}, FS #{}, {}", cur_ums_device.lun, cur_ums_device.fs_idx, LIBUSBHSFS_FS_TYPE_STR(cur_ums_device.fs_type)); + storages->push_back(brls::i18n::getStr("dump_options/output_storage/value_02"_i18n, device_str)); + } + + if (this->output_storage->getSelectedValue() > ConfigOutputStorage_UsbHost) + { + /* Set the SD card as the current output storage. */ + this->output_storage->setSelectedValue(ConfigOutputStorage_SdCard); + + /* Regenerate filename. */ + this->output_storage->getValueSelectedEvent()->fire(ConfigOutputStorage_SdCard); + } + } + + protected: + bool onCancel(void) override + { + /* Pop view. */ + brls::Application::popView(brls::ViewAnimation::SLIDE_RIGHT); + + return true; + } + + public: + DumpOptionsFrame(RootView *root_view, std::string title, brls::Image *icon, char *raw_filename, const char *extension) : brls::ThumbnailFrame(), root_view(root_view), raw_filename(raw_filename), extension(extension) + { + /* Set UI properties. */ + this->setTitle(title); + this->setIcon(icon); + + this->list = new brls::List(); + this->list->setSpacing(this->list->getSpacing() / 2); + this->list->setMarginBottom(20); + + + + + + + + + this->filename_input = new brls::InputListItem("dump_options/filename/label"_i18n, this->RegenerateFileName(), "", "dump_options/filename/description"_i18n, 255); + + this->filename_input->getClickEvent()->subscribe([this](brls::View *view) { + this->UpdateRawFileName(); + this->filename_input->setValue(this->RegenerateFileName()); + }); + + this->list->addView(this->filename_input); + + + + + + + + + this->output_storage = new brls::SelectListItem("dump_options/output_storage/label"_i18n, { + "dump_options/output_storage/value_00"_i18n, + "dump_options/output_storage/value_01"_i18n + }, configGetInteger("output_storage"), + brls::i18n::getStr("dump_options/output_storage/description"_i18n, GITHUB_REPOSITORY_URL)); + + /* Subscribe to SelectListItem's value selected event. */ + this->output_storage->getValueSelectedEvent()->subscribe([this](int selected) { + /* Make sure the current value isn't out of bounds. */ + if (selected < ConfigOutputStorage_SdCard || selected >= static_cast(this->root_view->GetUmsDevices()->size() + ConfigOutputStorage_Count)) return; + + /* Update configuration. */ + if (selected == ConfigOutputStorage_SdCard || selected == ConfigOutputStorage_UsbHost) configSetInteger("output_storage", selected); + + /* Update output filename. */ + this->filename_input->setValue(this->RegenerateFileName()); + }); + + /* Update output storages vector. */ + this->UpdateStorages(this->root_view->GetUmsDevices()); + + this->list->addView(this->output_storage); + + + + + + + /* Subscribe to the UMS device event. */ + this->ums_task_sub = this->root_view->RegisterUmsTaskListener([this](const nxdt::tasks::UmsDeviceVector* ums_devices) { + /* Update output storages vector. */ + this->UpdateStorages(ums_devices); + }); + + + + + + + + + + this->prepend_key_area = new brls::ToggleListItem("dump_options/prepend_key_area/label"_i18n, configGetBoolean("gamecard/prepend_key_area"), \ + "dump_options/prepend_key_area/description"_i18n, "generic/value_enabled"_i18n, \ + "generic/value_disabled"_i18n); + + this->prepend_key_area->getClickEvent()->subscribe([](brls::View* view) { + /* Get current value. */ + brls::ToggleListItem *item = static_cast(view); + bool value = item->getToggleState(); + + /* Update configuration. */ + configSetBoolean("gamecard/prepend_key_area", value); + + LOG_MSG_DEBUG("Prepend Key Area setting changed by user."); + }); + + this->list->addView(this->prepend_key_area); + + + + + + + + this->keep_certificate = new brls::ToggleListItem("dump_options/keep_certificate/label"_i18n, configGetBoolean("gamecard/keep_certificate"), \ + "dump_options/keep_certificate/description"_i18n, "generic/value_enabled"_i18n, \ + "generic/value_disabled"_i18n); + + this->keep_certificate->getClickEvent()->subscribe([](brls::View* view) { + /* Get current value. */ + brls::ToggleListItem *item = static_cast(view); + bool value = item->getToggleState(); + + /* Update configuration. */ + configSetBoolean("gamecard/keep_certificate", value); + + LOG_MSG_DEBUG("Keep certificate setting changed by user."); + }); + + this->list->addView(this->keep_certificate); + + + + + + + + + + this->trim_dump = new brls::ToggleListItem("dump_options/trim_dump/label"_i18n, configGetBoolean("gamecard/trim_dump"), \ + "dump_options/trim_dump/description"_i18n, "generic/value_enabled"_i18n, \ + "generic/value_disabled"_i18n); + + this->trim_dump->getClickEvent()->subscribe([](brls::View* view) { + /* Get current value. */ + brls::ToggleListItem *item = static_cast(view); + bool value = item->getToggleState(); + + /* Update configuration. */ + configSetBoolean("gamecard/trim_dump", value); + + LOG_MSG_DEBUG("Trim dump setting changed by user."); + }); + + this->list->addView(this->trim_dump); + + + + + + + + + + this->calculate_checksum = new brls::ToggleListItem("dump_options/calculate_checksum/label"_i18n, configGetBoolean("gamecard/calculate_checksum"), \ + "dump_options/calculate_checksum/description"_i18n, "generic/value_enabled"_i18n, \ + "generic/value_disabled"_i18n); + + this->calculate_checksum->getClickEvent()->subscribe([](brls::View* view) { + /* Get current value. */ + brls::ToggleListItem *item = static_cast(view); + bool value = item->getToggleState(); + + /* Update configuration. */ + configSetBoolean("gamecard/calculate_checksum", value); + + LOG_MSG_DEBUG("Calculate checksum setting changed by user."); + }); + + this->list->addView(this->calculate_checksum); + + + + + + + + + this->checksum_lookup_method = new brls::SelectListItem("dump_options/checksum_lookup_method/label"_i18n, { + "dump_options/checksum_lookup_method/value_00"_i18n, + "NSWDB", + "No-Intro" + }, configGetInteger("gamecard/checksum_lookup_method"), + brls::i18n::getStr("dump_options/checksum_lookup_method/description"_i18n, + "dump_options/calculate_checksum/label"_i18n, "NSWDB", NSWDB_XML_NAME, "No-Intro")); + + /* Subscribe to SelectListItem's value selected event. */ + this->checksum_lookup_method->getValueSelectedEvent()->subscribe([this](int selected) { + /* Make sure the current value isn't out of bounds. */ + if (selected < ConfigChecksumLookupMethod_None || selected >= ConfigChecksumLookupMethod_Count) return; + + /* Update configuration. */ + configSetInteger("gamecard/checksum_lookup_method", selected); + }); + + this->list->addView(this->checksum_lookup_method); + + + + + + + + brls::Button *button = this->getSidebar()->getButton(); + button->setLabel("dump_options/start_dump"_i18n); + button->getClickEvent()->subscribe([](brls::View *view) { + brls::Application::notify("test"); + }); + + + + + + + + this->setContentView(this->list); + } + + ~DumpOptionsFrame(void) + { + /* Unregister task listener. */ + this->root_view->UnregisterUmsTaskListener(this->ums_task_sub); + + if (this->raw_filename) free(this->raw_filename); + } + }; +} + +#endif /* __DUMP_OPTIONS_FRAME_HPP__ */ diff --git a/include/root_view.hpp b/include/root_view.hpp index be762c2..3129525 100644 --- a/include/root_view.hpp +++ b/include/root_view.hpp @@ -41,7 +41,8 @@ namespace nxdt::views brls::Label *time_lbl = nullptr; brls::Label *battery_icon = nullptr, *battery_percentage = nullptr; brls::Label *connection_icon = nullptr, *connection_status_lbl = nullptr; - brls::Label *usb_icon = nullptr, *usb_host_speed_lbl = nullptr; + brls::Label *usb_icon = nullptr, *ums_counter_lbl = nullptr; + brls::Label *cable_icon = nullptr, *usb_host_speed_lbl = nullptr; nxdt::tasks::StatusInfoTask *status_info_task = nullptr; nxdt::tasks::GameCardTask *gc_status_task = nullptr; @@ -50,6 +51,7 @@ namespace nxdt::views nxdt::tasks::UsbHostTask *usb_host_task = nullptr; nxdt::tasks::StatusInfoEvent::Subscription status_info_task_sub; + nxdt::tasks::UmsEvent::Subscription ums_task_sub; nxdt::tasks::UsbHostEvent::Subscription usb_host_task_sub; protected: @@ -75,6 +77,11 @@ namespace nxdt::views return this->title_task->GetApplicationMetadata(is_system); } + ALWAYS_INLINE const nxdt::tasks::UmsDeviceVector* GetUmsDevices(void) + { + return this->ums_task->GetUmsDevices(); + } + EVENT_SUBSCRIPTION(StatusInfoTask, StatusInfoEvent, status_info_task); EVENT_SUBSCRIPTION(GameCardTask, GameCardStatusEvent, gc_status_task); EVENT_SUBSCRIPTION(TitleTask, TitleEvent, title_task); diff --git a/include/tasks.hpp b/include/tasks.hpp index e05b842..5fe2c4e 100644 --- a/include/tasks.hpp +++ b/include/tasks.hpp @@ -120,7 +120,7 @@ namespace nxdt::tasks TitleTask(void); ~TitleTask(void); - /* Intentionally left here to let system titles views retrieve metadata. */ + /* Intentionally left here to let views retrieve title metadata. */ const TitleApplicationMetadataVector* GetApplicationMetadata(bool is_system); EVENT_SUBSCRIPTION(TitleEvent, title_event); @@ -143,6 +143,9 @@ namespace nxdt::tasks UmsTask(void); ~UmsTask(void); + /* Intentionally left here to let views retrieve UMS device info. */ + const UmsDeviceVector* GetUmsDevices(void); + EVENT_SUBSCRIPTION(UmsEvent, ums_event); }; diff --git a/libs/borealis b/libs/borealis index 642c599..f9f4aa9 160000 --- a/libs/borealis +++ b/libs/borealis @@ -1 +1 @@ -Subproject commit 642c599c33f8632c42b0931aaa7676293576a191 +Subproject commit f9f4aa9637f84aa89025d68a8ec15e5ff34d1537 diff --git a/libs/libusbhsfs b/libs/libusbhsfs index 315c98e..c1f63a9 160000 --- a/libs/libusbhsfs +++ b/libs/libusbhsfs @@ -1 +1 @@ -Subproject commit 315c98ecd631656b0e5839ca5e6fc293908d06f8 +Subproject commit c1f63a931df0c6d07f8f2c91ef6352657acbdb2d diff --git a/romfs/default_config.json b/romfs/default_config.json index a93628d..7d1582b 100644 --- a/romfs/default_config.json +++ b/romfs/default_config.json @@ -1,9 +1,9 @@ { "overclock": true, "naming_convention": 0, - "dump_destination": 0, + "output_storage": 0, "gamecard": { - "append_key_area": false, + "prepend_key_area": false, "keep_certificate": false, "trim_dump": false, "calculate_checksum": true, diff --git a/romfs/i18n/en-US/dump_options.json b/romfs/i18n/en-US/dump_options.json new file mode 100644 index 0000000..f7ed0b8 --- /dev/null +++ b/romfs/i18n/en-US/dump_options.json @@ -0,0 +1,42 @@ +{ + "filename": { + "label": "Filename", + "description": "Filename used for the output dump.\nIllegal filesystem characters will be automatically replaced with underscores (\"_\"). If the inserted SD card is used as the output storage, only ASCII characters will be kept — this is a limitation on Nintendo's FS driver.\nThe file extension cannot be modified, and it is excluded on purpose." + }, + + "output_storage": { + "label": "Output storage", + "description": "Storage where the dumped data will be written to. Changing it will automatically update the output filename to better suit the output filesystem limitations.\nUsing a connected USB host requires a libusb-based driver, as well as the Python host script. For more information, please visit \"{}\".", + "value_00": "SD card", + "value_01": "USB host", + "value_02": "USB Mass Storage ({})" + }, + + "prepend_key_area": { + "label": "Prepend KeyArea data", + "description": "Prepends the full, 4 KiB long KeyArea block to the output XCI dump, which includes the InitialData area. XCI dumps with KeyArea data are also known as \"Full XCIs\". Disabled by default." + }, + + "keep_certificate": { + "label": "Keep certificate", + "description": "Preserves the gamecard certificate in the output XCI dump, which is used to unequivocally identify each individual gamecard. Disabled by default." + }, + + "trim_dump": { + "label": "Trim dump", + "description": "Trims the output XCI dump by removing padding data beyond the end of the last HFS partition. Disabled by default." + }, + + "calculate_checksum": { + "label": "Calculate checksum", + "description": "Calculates one or more CRC32 checksums over the dumped data, depending on the selected configuration. Checksums are useful to verify data integrity. Enabled by default." + }, + + "checksum_lookup_method": { + "label": "Checksum lookup method", + "description": "If \"{0}\" is enabled, this option determines which lookup method is used to validate the calculated CRC32 checksum at the end of the dump process.\nIf \"{1}\" is selected, the calculated checksum will be looked up in \"{2}\", which must have been previously downloaded.\nIf \"{3}\" is selected, the calculated checksum will be looked up using an Internet connection and a public HTTP endpoint.", + "value_00": "None" + }, + + "start_dump": "Start dump" +} diff --git a/romfs/i18n/en-US/generic.json b/romfs/i18n/en-US/generic.json index d75f546..dc4317d 100644 --- a/romfs/i18n/en-US/generic.json +++ b/romfs/i18n/en-US/generic.json @@ -15,5 +15,8 @@ "unknown_exception": "unknown", "libnx_abort": "Fatal error triggered in libnx!\nError code: 0x{:08X}.", - "exception_triggered": "Fatal exception triggered!\nReason: {} (0x{:X})." + "exception_triggered": "Fatal exception triggered!\nReason: {} (0x{:X}).", + + "value_enabled": "Yes", + "value_disabled": "No" } diff --git a/romfs/i18n/en-US/options_tab.json b/romfs/i18n/en-US/options_tab.json index 65d97ba..38b3988 100644 --- a/romfs/i18n/en-US/options_tab.json +++ b/romfs/i18n/en-US/options_tab.json @@ -3,9 +3,7 @@ "overclock": { "label": "Overclock", - "description": "Overclocks both CPU and MEM to 1785 MHz and 1600 MHz, respectively, in order to speed up dump operations. This is considered a relatively safe action.\n\nIf the application is running under title override mode, and sys-clk is active, and a clock profile has been created for the overridden title, this setting has no effect at all.", - "value_enabled": "Yes", - "value_disabled": "No" + "description": "Overclocks both CPU and MEM to 1785 MHz and 1600 MHz, respectively, in order to speed up dump operations. This is considered a relatively safe action.\n\nIf the application is running under title override mode, and sys-clk is active, and a clock profile has been created for the overridden title, this setting has no effect at all." }, "naming_convention": { diff --git a/romfs/i18n/en-US/root_view.json b/romfs/i18n/en-US/root_view.json index ed32133..68ef69f 100644 --- a/romfs/i18n/en-US/root_view.json +++ b/romfs/i18n/en-US/root_view.json @@ -1,8 +1,13 @@ { "applet_mode": "\uE8B2 Applet Mode \uE8B2", - + "not_connected": "Not connected", - + + "ums_counter": "{} UMS device(s)", + + "usb_host_speed": "USB {}.0 host", + "usb_host_not_connected": "No USB host connected", + "tabs": { "gamecard": "Gamecard", "user_titles": "User titles", diff --git a/romfs/material/MaterialIcons-Regular.ttf b/romfs/material/MaterialIcons-Regular.ttf index 7015564ad166a3e9d88c82f17829f0cc01ebe29a..82cf19ed34b686660000f9afd8c72dee1e963a73 100644 GIT binary patch literal 356220 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 E3#mUf2><{9 delta 37254 zcmce;2Ygi3);E0iK2uXBnaPyQOfn^tnMr0QbuyWdkTCQPp`?KH4xu-ZmWW8N#;_G> zB3KAg6pf-{EZ1v6MX$lDqJ|=(vE6&U-lB%@zt1FqKKJ>3@B4kv`x4IV-qv1g?X}ik z=lt@S;nY{kT7d|HkRa3vqA&H!jkJPJUb@&JXh|;&uoC66=@S>t zzkVGfkIY{bo#^I7RXC=4mMW1yA7&WXK3bIVnIoea4){ z%Vu4j*$3%A3xe{%?0J(XmSpa_8w1oKy=TtEW%FfT;UdbbQQt9l;+&}|385W_~mfC^&eI#2;$qq2_ad^<`s!lD(#R5#9zNw z=B__38<|ih81Uzpszro~`V9Gq`g-|{dbwhCeZ693eUh?L9uXpfzkaUr4ic%qrVJ5x zy-k&+=4~oa;;tW~GNZ?(s>$`=s|xG0)DhyVpR4xQKdA0g-=>bM|GPSw_@C6om`Rc! zO*)?n#PL^O9GgeV>SxEAoxDT8(1;0PD$=jN6Ajc!(;n)%b2w_tZ z6J)>eJ(u#uj(i#U0qJGvQ7#k-U4-$%@>a3c-0EyiZw<8OwRUM8(Ym1Z`PLU(Uv2&3 z;+%^O7x!Fz<>KoX&t3fF;-yPdF1>o`jZ0@Qt1c&BF1p-$`MWDgwO6vQbp4|6i-li& zdew2Y_tigK{q*YRS1*3~)irWWbIowA_}Z{*i>^I=?VYcLuM}S;eC2N&1XL7+Tns(2 zRlv~JR#$6AYj$g}wWPJ8^?2)<)>m3zyV(2U4h;PehJO3vpD(sv@?3iU(rXx6c{%2? ztFLwr{pEMpVy|hh6MLzq$@S~k|8)J>^~W6=2+@s2o0tRu$$w*9RA4g2f%nfAW+?)DOU*dDY8 z>>0K%Y};&GZJTYwY~{A0scorWr(R3_GWBZ8Pboj997_ zf3*C;@`$Cua<8S{a*t)FWrtyz!qNw1z$WDCD4mt8y7!89MpWV70)Ha!Rs!0@JtZ^o>)XMvrCu+ z8GsOzxbz0%SjDBY(T7wC!eu2MG~|5dGEn_8h@6Z@Xu(s2_)LU*@n8_L0U-vu{2k)x z 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 || nca_fs_ctx->section_type >= NcaFsSectionType_Invalid || !(nca_ctx = (NcaContext*)nca_fs_ctx->nca_ctx) || \ - (nca_ctx->rights_id_available && !nca_ctx->titlekey_retrieved) || storage_type == BucketTreeStorageType_Compressed || storage_type >= BucketTreeStorageType_Count) + if (!out || !nca_fs_ctx || !nca_fs_ctx->enabled || nca_fs_ctx->section_type >= NcaFsSectionType_Invalid || !nca_fs_ctx->nca_ctx || \ + (nca_fs_ctx->nca_ctx->rights_id_available && !nca_fs_ctx->nca_ctx->titlekey_retrieved) || storage_type == BucketTreeStorageType_Compressed || \ + storage_type >= BucketTreeStorageType_Count) { LOG_MSG_ERROR("Invalid parameters!"); return false; @@ -166,20 +165,17 @@ bool bktrInitializeContext(BucketTreeContext *out, NcaFsSectionContext *nca_fs_c } if (!success) LOG_MSG_ERROR("Failed to initialize Bucket Tree %s storage for FS section #%u in \"%s\".", bktrGetStorageTypeName(storage_type), nca_fs_ctx->section_idx, \ - nca_ctx->content_id_str); + nca_fs_ctx->nca_ctx->content_id_str); return success; } bool bktrInitializeCompressedStorageContext(BucketTreeContext *out, BucketTreeSubStorage *substorage) { - NcaFsSectionContext *nca_fs_ctx = NULL; - NcaContext *nca_ctx = NULL; - - if (!out || !substorage || substorage->index != 0 || !(nca_fs_ctx = substorage->nca_fs_ctx) || !nca_fs_ctx->enabled || !nca_fs_ctx->has_compression_layer || \ - nca_fs_ctx->section_type >= NcaFsSectionType_Invalid || !(nca_ctx = (NcaContext*)nca_fs_ctx->nca_ctx) || (nca_ctx->rights_id_available && !nca_ctx->titlekey_retrieved) || \ - substorage->type == BucketTreeSubStorageType_AesCtrEx || substorage->type == BucketTreeSubStorageType_Compressed || substorage->type >= BucketTreeSubStorageType_Count || \ - (substorage->type == BucketTreeSubStorageType_Regular && substorage->bktr_ctx) || (substorage->type != BucketTreeSubStorageType_Regular && !substorage->bktr_ctx)) + if (!out || !bktrIsValidSubStorage(substorage) || substorage->index != 0 || !substorage->nca_fs_ctx->enabled || !substorage->nca_fs_ctx->has_compression_layer || \ + substorage->nca_fs_ctx->section_type >= NcaFsSectionType_Invalid || !substorage->nca_fs_ctx->nca_ctx || \ + (substorage->nca_fs_ctx->nca_ctx->rights_id_available && !substorage->nca_fs_ctx->nca_ctx->titlekey_retrieved) || \ + substorage->type == BucketTreeSubStorageType_AesCtrEx || substorage->type == BucketTreeSubStorageType_Compressed || substorage->type >= BucketTreeSubStorageType_Count) { LOG_MSG_ERROR("Invalid parameters!"); return false; @@ -188,6 +184,7 @@ bool bktrInitializeCompressedStorageContext(BucketTreeContext *out, BucketTreeSu /* Free output context beforehand. */ bktrFreeContext(out); + NcaFsSectionContext *nca_fs_ctx = substorage->nca_fs_ctx; NcaBucketInfo *compressed_bucket = &(nca_fs_ctx->header.compression_info.bucket); BucketTreeTable *compressed_table = NULL; u64 node_storage_size = 0, entry_storage_size = 0; @@ -253,10 +250,8 @@ end: bool bktrSetRegularSubStorage(BucketTreeContext *ctx, NcaFsSectionContext *nca_fs_ctx) { - NcaContext *nca_ctx = NULL; - if (!bktrIsValidContext(ctx) || !nca_fs_ctx || !nca_fs_ctx->enabled || nca_fs_ctx->section_type >= NcaFsSectionType_Invalid || \ - !(nca_ctx = (NcaContext*)nca_fs_ctx->nca_ctx) || (nca_ctx->rights_id_available && !nca_ctx->titlekey_retrieved) || \ + !nca_fs_ctx->nca_ctx || (nca_fs_ctx->nca_ctx->rights_id_available && !nca_fs_ctx->nca_ctx->titlekey_retrieved) || \ ctx->storage_type == BucketTreeStorageType_Compressed || ctx->storage_type >= BucketTreeStorageType_Count || \ (ctx->storage_type == BucketTreeStorageType_Indirect && ctx->nca_fs_ctx == nca_fs_ctx) || \ ((ctx->storage_type == BucketTreeStorageType_AesCtrEx || ctx->storage_type == BucketTreeStorageType_Sparse) && ctx->nca_fs_ctx != nca_fs_ctx)) @@ -364,7 +359,7 @@ bool bktrIsBlockWithinIndirectStorageRange(BucketTreeContext *ctx, u64 offset, u /* Check if we're dealing with a Compressed storage. */ if (ctx->storage_type == BucketTreeStorageType_Compressed) { - BucketTreeContext *indirect_storage = (BucketTreeContext*)ctx->substorages[0].bktr_ctx; + BucketTreeContext *indirect_storage = ctx->substorages[0].bktr_ctx; const u64 compressed_storage_base_offset = ctx->nca_fs_ctx->hash_region.size; BucketTreeCompressedStorageEntry *start_entry = NULL, *end_entry = NULL; @@ -509,7 +504,7 @@ static bool bktrInitializeIndirectStorageContext(BucketTreeContext *out, NcaFsSe return false; } - NcaContext *nca_ctx = (NcaContext*)nca_fs_ctx->nca_ctx; + NcaContext *nca_ctx = nca_fs_ctx->nca_ctx; NcaBucketInfo *indirect_bucket = (is_sparse ? &(nca_fs_ctx->header.sparse_info.bucket) : &(nca_fs_ctx->header.patch_info.indirect_bucket)); BucketTreeTable *indirect_table = NULL; u64 node_storage_size = 0, entry_storage_size = 0; @@ -532,7 +527,7 @@ static bool bktrInitializeIndirectStorageContext(BucketTreeContext *out, NcaFsSe /* Read indirect storage table data. */ if ((!is_sparse && !ncaReadFsSection(nca_fs_ctx, indirect_table, indirect_bucket->size, indirect_bucket->offset)) || \ - (is_sparse && !ncaReadContentFile((NcaContext*)nca_fs_ctx->nca_ctx, indirect_table, indirect_bucket->size, nca_fs_ctx->sparse_table_offset))) + (is_sparse && !ncaReadContentFile(nca_ctx, indirect_table, indirect_bucket->size, nca_fs_ctx->sparse_table_offset))) { LOG_MSG_ERROR("Failed to read Indirect Storage Table data! (%s).", is_sparse ? "sparse" : "patch"); goto end; @@ -595,10 +590,10 @@ static bool bktrReadIndirectStorage(BucketTreeVisitor *visitor, void *out, u64 r { BucketTreeContext *ctx = visitor->bktr_ctx; bool is_sparse = (ctx->storage_type == BucketTreeStorageType_Sparse); - bool missing_original_storage = !bktrIsValidSubstorage(&(ctx->substorages[0])); + bool missing_original_storage = !bktrIsValidSubStorage(&(ctx->substorages[0])); if (!out || (is_sparse && (missing_original_storage || ctx->substorages[0].type != BucketTreeSubStorageType_Regular)) || \ - (!is_sparse && (!bktrIsValidSubstorage(&(ctx->substorages[1])) || ctx->substorages[1].type != BucketTreeSubStorageType_AesCtrEx || \ + (!is_sparse && (!bktrIsValidSubStorage(&(ctx->substorages[1])) || ctx->substorages[1].type != BucketTreeSubStorageType_AesCtrEx || \ (!missing_original_storage && (ctx->substorages[0].type == BucketTreeSubStorageType_Indirect || ctx->substorages[0].type == BucketTreeSubStorageType_AesCtrEx || \ ctx->substorages[0].type >= BucketTreeSubStorageType_Count)))) || (offset + read_size) > ctx->end_offset) { @@ -771,7 +766,7 @@ static bool bktrReadAesCtrExStorage(BucketTreeVisitor *visitor, void *out, u64 r { BucketTreeContext *ctx = visitor->bktr_ctx; - if (!out || !bktrIsValidSubstorage(&(ctx->substorages[0])) || ctx->substorages[0].type != BucketTreeSubStorageType_Regular || (offset + read_size) > ctx->end_offset) + if (!out || !bktrIsValidSubStorage(&(ctx->substorages[0])) || ctx->substorages[0].type != BucketTreeSubStorageType_Regular || (offset + read_size) > ctx->end_offset) { LOG_MSG_ERROR("Invalid parameters!"); return false; @@ -856,7 +851,8 @@ static bool bktrReadCompressedStorage(BucketTreeVisitor *visitor, void *out, u64 NcaFsSectionContext *nca_fs_ctx = ctx->nca_fs_ctx; u64 compressed_storage_base_offset = nca_fs_ctx->hash_region.size; - if (!out || !bktrIsValidSubstorage(&(ctx->substorages[0])) || ctx->substorages[0].type >= BucketTreeSubStorageType_AesCtrEx || (offset + read_size) > ctx->end_offset) + if (!out || !bktrIsValidSubStorage(&(ctx->substorages[0])) || ctx->substorages[0].type == BucketTreeSubStorageType_AesCtrEx || \ + ctx->substorages[0].type == BucketTreeSubStorageType_Compressed || ctx->substorages[0].type >= BucketTreeSubStorageType_Count || (offset + read_size) > ctx->end_offset) { LOG_MSG_ERROR("Invalid parameters!"); return false; @@ -1016,7 +1012,7 @@ end: static bool bktrReadSubStorage(BucketTreeSubStorage *substorage, BucketTreeSubStorageReadParams *params) { - if (!bktrIsValidSubstorage(substorage) || !params || !params->buffer || !params->size) + if (!bktrIsValidSubStorage(substorage) || !params || !params->buffer || !params->size) { LOG_MSG_ERROR("Invalid parameters!"); return false; @@ -1041,8 +1037,7 @@ static bool bktrReadSubStorage(BucketTreeSubStorage *substorage, BucketTreeSubSt } } else { /* Perform a read on the target BucketTree storage. */ - BucketTreeContext *ctx = (BucketTreeContext*)substorage->bktr_ctx; - success = bktrReadStorage(ctx, params->buffer, params->size, params->offset); + success = bktrReadStorage(substorage->bktr_ctx, params->buffer, params->size, params->offset); } if (!success) LOG_MSG_ERROR("Failed to read 0x%lX-byte long chunk from offset 0x%lX!", params->size, params->offset); diff --git a/source/core/config.c b/source/core/config.c index c5cad5a..ad1cd3d 100644 --- a/source/core/config.c +++ b/source/core/config.c @@ -169,7 +169,7 @@ static void configFreeConfigJson(void) static bool configValidateJsonRootObject(const struct json_object *obj) { - bool ret = false, overclock_found = false, naming_convention_found = false, dump_destination_found = false, gamecard_found = false; + bool ret = false, overclock_found = false, naming_convention_found = false, output_storage_found = false, gamecard_found = false; bool nsp_found = false, ticket_found = false, nca_fs_found = false; if (!jsonValidateObject(obj)) goto end; @@ -178,7 +178,7 @@ static bool configValidateJsonRootObject(const struct json_object *obj) { CONFIG_VALIDATE_FIELD(Boolean, overclock); CONFIG_VALIDATE_FIELD(Integer, naming_convention, TitleNamingConvention_Full, TitleNamingConvention_Count - 1); - CONFIG_VALIDATE_FIELD(Integer, dump_destination, ConfigDumpDestination_SdCard, ConfigDumpDestination_Count - 1); + CONFIG_VALIDATE_FIELD(Integer, output_storage, ConfigOutputStorage_SdCard, ConfigOutputStorage_Count - 1); CONFIG_VALIDATE_OBJECT(GameCard, gamecard); CONFIG_VALIDATE_OBJECT(Nsp, nsp); CONFIG_VALIDATE_OBJECT(Ticket, ticket); @@ -186,7 +186,7 @@ static bool configValidateJsonRootObject(const struct json_object *obj) goto end; } - ret = (overclock_found && naming_convention_found && dump_destination_found && gamecard_found && nsp_found && ticket_found && nca_fs_found); + ret = (overclock_found && naming_convention_found && output_storage_found && gamecard_found && nsp_found && ticket_found && nca_fs_found); end: return ret; @@ -194,13 +194,13 @@ end: static bool configValidateJsonGameCardObject(const struct json_object *obj) { - bool ret = false, append_key_area_found = false, keep_certificate_found = false, trim_dump_found = false, calculate_checksum_found = false, checksum_lookup_method_found = false; + bool ret = false, prepend_key_area_found = false, keep_certificate_found = false, trim_dump_found = false, calculate_checksum_found = false, checksum_lookup_method_found = false; if (!jsonValidateObject(obj)) goto end; json_object_object_foreach(obj, key, val) { - CONFIG_VALIDATE_FIELD(Boolean, append_key_area); + CONFIG_VALIDATE_FIELD(Boolean, prepend_key_area); CONFIG_VALIDATE_FIELD(Boolean, keep_certificate); CONFIG_VALIDATE_FIELD(Boolean, trim_dump); CONFIG_VALIDATE_FIELD(Boolean, calculate_checksum); @@ -208,7 +208,7 @@ static bool configValidateJsonGameCardObject(const struct json_object *obj) goto end; } - ret = (append_key_area_found && keep_certificate_found && trim_dump_found && calculate_checksum_found && checksum_lookup_method_found); + ret = (prepend_key_area_found && keep_certificate_found && trim_dump_found && calculate_checksum_found && checksum_lookup_method_found); end: return ret; diff --git a/source/core/lz4.c b/source/core/lz4.c index 9f5e9bf..654bfdf 100644 --- a/source/core/lz4.c +++ b/source/core/lz4.c @@ -1,6 +1,6 @@ /* LZ4 - Fast LZ compression algorithm - Copyright (C) 2011-present, Yann Collet. + Copyright (C) 2011-2020, Yann Collet. BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) @@ -124,6 +124,7 @@ #if defined(_MSC_VER) && (_MSC_VER >= 1400) /* Visual Studio 2005+ */ # include /* only present in VS2005+ */ # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */ +# pragma warning(disable : 6237) /* disable: C6237: conditional expression is always 0 */ #endif /* _MSC_VER */ #ifndef LZ4_FORCE_INLINE @@ -187,7 +188,27 @@ /*-************************************ * Memory routines **************************************/ -#ifdef LZ4_USER_MEMORY_FUNCTIONS + +/*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION : + * Disable relatively high-level LZ4/HC functions that use dynamic memory + * allocation functions (malloc(), calloc(), free()). + * + * Note that this is a compile-time switch. And since it disables + * public/stable LZ4 v1 API functions, we don't recommend using this + * symbol to generate a library for distribution. + * + * The following public functions are removed when this symbol is defined. + * - lz4 : LZ4_createStream, LZ4_freeStream, + * LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated) + * - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC, + * LZ4_createHC (deprecated), LZ4_freeHC (deprecated) + * - lz4frame, lz4file : All LZ4F_* functions + */ +#if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) +# define ALLOC(s) lz4_error_memory_allocation_is_disabled +# define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled +# define FREEMEM(p) lz4_error_memory_allocation_is_disabled +#elif defined(LZ4_USER_MEMORY_FUNCTIONS) /* memory management functions can be customized by user project. * Below functions must exist somewhere in the Project * and be available at link time */ @@ -204,8 +225,13 @@ void LZ4_free(void* p); # define FREEMEM(p) free(p) #endif -#include /* memset, memcpy */ -#define MEM_INIT(p,v,s) memset((p),(v),(s)) +#if ! LZ4_FREESTANDING +# include /* memset, memcpy */ +#endif +#if !defined(LZ4_memset) +# define LZ4_memset(p,v,s) memset((p),(v),(s)) +#endif +#define MEM_INIT(p,v,s) LZ4_memset((p),(v),(s)) /*-************************************ @@ -316,10 +342,20 @@ typedef enum { * memcpy() as if it were standard compliant, so it can inline it in freestanding * environments. This is needed when decompressing the Linux Kernel, for example. */ -#if defined(__GNUC__) && (__GNUC__ >= 4) -#define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) -#else -#define LZ4_memcpy(dst, src, size) memcpy(dst, src, size) +#if !defined(LZ4_memcpy) +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size) +# else +# define LZ4_memcpy(dst, src, size) memcpy(dst, src, size) +# endif +#endif + +#if !defined(LZ4_memmove) +# if defined(__GNUC__) && (__GNUC__ >= 4) +# define LZ4_memmove __builtin_memmove +# else +# define LZ4_memmove memmove +# endif #endif static unsigned LZ4_isLittleEndian(void) @@ -343,14 +379,14 @@ static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } /* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ /* currently only defined for gcc and icc */ -typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) unalign; +typedef union { U16 u16; U32 u32; reg_t uArch; } __attribute__((packed)) LZ4_unalign; -static U16 LZ4_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } -static U32 LZ4_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } -static reg_t LZ4_read_ARCH(const void* ptr) { return ((const unalign*)ptr)->uArch; } +static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign*)ptr)->u16; } +static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign*)ptr)->u32; } +static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalign*)ptr)->uArch; } -static void LZ4_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } -static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } +static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign*)memPtr)->u16 = value; } +static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign*)memPtr)->u32 = value; } #else /* safe and portable access using memcpy() */ @@ -421,10 +457,12 @@ static const int dec64table[8] = {0, 0, 0, -1, -4, 1, 2, 3}; #ifndef LZ4_FAST_DEC_LOOP # if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64 # define LZ4_FAST_DEC_LOOP 1 +# elif defined(__aarch64__) && defined(__APPLE__) +# define LZ4_FAST_DEC_LOOP 1 # elif defined(__aarch64__) && !defined(__clang__) - /* On aarch64, we disable this optimization for clang because on certain - * mobile chipsets, performance is reduced with clang. For information - * refer to https://github.com/lz4/lz4/pull/707 */ + /* On non-Apple aarch64, we disable this optimization for clang because + * on certain mobile chipsets, performance is reduced with clang. For + * more information refer to https://github.com/lz4/lz4/pull/707 */ # define LZ4_FAST_DEC_LOOP 1 # else # define LZ4_FAST_DEC_LOOP 0 @@ -486,7 +524,14 @@ LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const si case 2: LZ4_memcpy(v, srcPtr, 2); LZ4_memcpy(&v[2], srcPtr, 2); +#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */ +# pragma warning(push) +# pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */ +#endif LZ4_memcpy(&v[4], v, 4); +#if defined(_MSC_VER) && (_MSC_VER <= 1933) /* MSVC 2022 ver 17.3 or earlier */ +# pragma warning(pop) +#endif break; case 4: LZ4_memcpy(v, srcPtr, 4); @@ -515,9 +560,20 @@ static unsigned LZ4_NbCommonBytes (reg_t val) assert(val != 0); if (LZ4_isLittleEndian()) { if (sizeof(val) == 8) { -# if defined(_MSC_VER) && (_MSC_VER >= 1800) && defined(_M_AMD64) && !defined(LZ4_FORCE_SW_BITCOUNT) +# if defined(_MSC_VER) && (_MSC_VER >= 1800) && (defined(_M_AMD64) && !defined(_M_ARM64EC)) && !defined(LZ4_FORCE_SW_BITCOUNT) +/*-************************************************************************************************* +* ARM64EC is a Microsoft-designed ARM64 ABI compatible with AMD64 applications on ARM64 Windows 11. +* The ARM64EC ABI does not support AVX/AVX2/AVX512 instructions, nor their relevant intrinsics +* including _tzcnt_u64. Therefore, we need to neuter the _tzcnt_u64 code path for ARM64EC. +****************************************************************************************************/ +# if defined(__clang__) && (__clang_major__ < 10) + /* Avoid undefined clang-cl intrinsics issue. + * See https://github.com/lz4/lz4/pull/1017 for details. */ + return (unsigned)__builtin_ia32_tzcnt_u64(val) >> 3; +# else /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */ return (unsigned)_tzcnt_u64(val) >> 3; +# endif # elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) unsigned long r = 0; _BitScanForward64(&r, (U64)val); @@ -652,10 +708,10 @@ typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t; * - usingExtDict : Like withPrefix64k, but the preceding content is somewhere * else in memory, starting at ctx->dictionary with length * ctx->dictSize. - * - usingDictCtx : Like usingExtDict, but everything concerning the preceding - * content is in a separate context, pointed to by - * ctx->dictCtx. ctx->dictionary, ctx->dictSize, and table - * entries in the current context that refer to positions + * - usingDictCtx : Everything concerning the preceding content is + * in a separate context, pointed to by ctx->dictCtx. + * ctx->dictionary, ctx->dictSize, and table entries + * in the current context that refer to positions * preceding the beginning of the current compression are * ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx * ->dictSize describe the location and size of the preceding @@ -672,12 +728,12 @@ typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive; int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; } const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; } int LZ4_compressBound(int isize) { return LZ4_COMPRESSBOUND(isize); } -int LZ4_sizeofState(void) { return LZ4_STREAMSIZE; } +int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); } -/*-************************************ -* Internal Definitions used in Tests -**************************************/ +/*-**************************************** +* Internal Definitions, used only in Tests +*******************************************/ #if defined (__cplusplus) extern "C" { #endif @@ -687,7 +743,9 @@ int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const void* dictStart, size_t dictSize); - +int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest, + int compressedSize, int targetOutputSize, int dstCapacity, + const void* dictStart, size_t dictSize); #if defined (__cplusplus) } #endif @@ -827,9 +885,10 @@ LZ4_prepareTable(LZ4_stream_t_internal* const cctx, } } - /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, is faster - * than compressing without a gap. However, compressing with - * currentOffset == 0 is faster still, so we preserve that case. + /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back, + * is faster than compressing without a gap. + * However, compressing with currentOffset == 0 is faster still, + * so we preserve that case. */ if (cctx->currentOffset != 0 && tableType == byU32) { DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset"); @@ -853,7 +912,7 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated( const char* const source, char* const dest, const int inputSize, - int *inputConsumed, /* only written when outputDirective == fillOutput */ + int* inputConsumed, /* only written when outputDirective == fillOutput */ const int maxOutputSize, const limitedOutput_directive outputDirective, const tableType_t tableType, @@ -885,7 +944,8 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated( /* the dictCtx currentOffset is indexed on the start of the dictionary, * while a dictionary in the current context precedes the currentOffset */ - const BYTE* dictBase = !dictionary ? NULL : (dictDirective == usingDictCtx) ? + const BYTE* dictBase = (dictionary == NULL) ? NULL : + (dictDirective == usingDictCtx) ? dictionary + dictSize - dictCtx->currentOffset : dictionary + dictSize - startIndex; @@ -981,10 +1041,11 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated( match = base + matchIndex; lowLimit = (const BYTE*)source; } - } else if (dictDirective==usingExtDict) { + } else if (dictDirective == usingExtDict) { if (matchIndex < startIndex) { DEBUGLOG(7, "extDict candidate: matchIndex=%5u < startIndex=%5u", matchIndex, startIndex); assert(startIndex - matchIndex >= MINMATCH); + assert(dictBase); match = dictBase + matchIndex; lowLimit = dictionary; } else { @@ -1048,7 +1109,7 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated( _next_match: /* at this stage, the following variables must be correctly set : * - ip : at start of LZ operation - * - match : at start of previous pattern occurence; can be within current prefix, or within extDict + * - match : at start of previous pattern occurrence; can be within current prefix, or within extDict * - offset : if maybe_ext_memSegment==1 (constant) * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written @@ -1173,6 +1234,7 @@ _next_match: } } else if (dictDirective==usingExtDict) { if (matchIndex < startIndex) { + assert(dictBase); match = dictBase + matchIndex; lowLimit = dictionary; /* required for match length counter */ } else { @@ -1355,7 +1417,7 @@ int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutp { int result; #if (LZ4_HEAPMODE) - LZ4_stream_t* ctxPtr = ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */ + LZ4_stream_t* ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */ if (ctxPtr == NULL) return 0; #else LZ4_stream_t ctx; @@ -1420,15 +1482,17 @@ int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targe * Streaming functions ********************************/ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4_stream_t* LZ4_createStream(void) { LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t)); - LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal)); /* A compilation error here means LZ4_STREAMSIZE is not large enough */ + LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal)); DEBUGLOG(4, "LZ4_createStream %p", lz4s); if (lz4s == NULL) return NULL; LZ4_initStream(lz4s, sizeof(*lz4s)); return lz4s; } +#endif static size_t LZ4_stream_t_alignment(void) { @@ -1462,6 +1526,7 @@ void LZ4_resetStream_fast(LZ4_stream_t* ctx) { LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32); } +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) int LZ4_freeStream (LZ4_stream_t* LZ4_stream) { if (!LZ4_stream) return 0; /* support free on NULL */ @@ -1469,6 +1534,7 @@ int LZ4_freeStream (LZ4_stream_t* LZ4_stream) FREEMEM(LZ4_stream); return (0); } +#endif #define HASH_UNIT sizeof(reg_t) @@ -1514,8 +1580,9 @@ int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize) return (int)dict->dictSize; } -void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) { - const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL : +void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) +{ + const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL : &(dictionaryStream->internal_donotuse); DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)", @@ -1568,36 +1635,40 @@ int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, int acceleration) { const tableType_t tableType = byU32; - LZ4_stream_t_internal* streamPtr = &LZ4_stream->internal_donotuse; - const BYTE* dictEnd = streamPtr->dictionary + streamPtr->dictSize; + LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse; + const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL; - DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i)", inputSize); + DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize); - LZ4_renormDictT(streamPtr, inputSize); /* avoid index overflow */ + LZ4_renormDictT(streamPtr, inputSize); /* fix index overflow */ if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT; if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX; /* invalidate tiny dictionaries */ - if ( (streamPtr->dictSize-1 < 4-1) /* intentional underflow */ - && (dictEnd != (const BYTE*)source) ) { + if ( (streamPtr->dictSize < 4) /* tiny dictionary : not enough for a hash */ + && (dictEnd != source) /* prefix mode */ + && (inputSize > 0) /* tolerance : don't lose history, in case next invocation would use prefix mode */ + && (streamPtr->dictCtx == NULL) /* usingDictCtx */ + ) { DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary); + /* remove dictionary existence from history, to employ faster prefix mode */ streamPtr->dictSize = 0; streamPtr->dictionary = (const BYTE*)source; - dictEnd = (const BYTE*)source; + dictEnd = source; } /* Check overlapping input/dictionary space */ - { const BYTE* sourceEnd = (const BYTE*) source + inputSize; - if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) { + { const char* const sourceEnd = source + inputSize; + if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) { streamPtr->dictSize = (U32)(dictEnd - sourceEnd); if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB; if (streamPtr->dictSize < 4) streamPtr->dictSize = 0; - streamPtr->dictionary = dictEnd - streamPtr->dictSize; + streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize; } } /* prefix mode : source data follows dictionary */ - if (dictEnd == (const BYTE*)source) { + if (dictEnd == source) { if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration); else @@ -1623,7 +1694,7 @@ int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream, } else { result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration); } - } else { + } else { /* small data <= 4 KB */ if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) { result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration); } else { @@ -1661,21 +1732,25 @@ int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* /*! LZ4_saveDict() : * If previously compressed data block is not guaranteed to remain available at its memory location, * save it into a safer place (char* safeBuffer). - * Note : you don't need to call LZ4_loadDict() afterwards, - * dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue(). - * Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error. + * Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable, + * one can therefore call LZ4_compress_fast_continue() right after. + * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error. */ int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize) { LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse; - const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize; + + DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer); if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */ if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; } if (safeBuffer == NULL) assert(dictSize == 0); - if (dictSize > 0) - memmove(safeBuffer, previousDictEnd - dictSize, dictSize); + if (dictSize > 0) { + const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize; + assert(dict->dictionary); + LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize); + } dict->dictionary = (const BYTE*)safeBuffer; dict->dictSize = (U32)dictSize; @@ -1689,39 +1764,163 @@ int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize) * Decompression functions ********************************/ -typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive; typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive; #undef MIN #define MIN(a,b) ( (a) < (b) ? (a) : (b) ) + +/* variant for decompress_unsafe() + * does not know end of input + * presumes input is well formed + * note : will consume at least one byte */ +size_t read_long_length_no_check(const BYTE** pp) +{ + size_t b, l = 0; + do { b = **pp; (*pp)++; l += b; } while (b==255); + DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1) + return l; +} + +/* core decoder variant for LZ4_decompress_fast*() + * for legacy support only : these entry points are deprecated. + * - Presumes input is correctly formed (no defense vs malformed inputs) + * - Does not know input size (presume input buffer is "large enough") + * - Decompress a full block (only) + * @return : nb of bytes read from input. + * Note : this variant is not optimized for speed, just for maintenance. + * the goal is to remove support of decompress_fast*() variants by v2.0 +**/ +LZ4_FORCE_INLINE int +LZ4_decompress_unsafe_generic( + const BYTE* const istart, + BYTE* const ostart, + int decompressedSize, + + size_t prefixSize, + const BYTE* const dictStart, /* only if dict==usingExtDict */ + const size_t dictSize /* note: =0 if dictStart==NULL */ + ) +{ + const BYTE* ip = istart; + BYTE* op = (BYTE*)ostart; + BYTE* const oend = ostart + decompressedSize; + const BYTE* const prefixStart = ostart - prefixSize; + + DEBUGLOG(5, "LZ4_decompress_unsafe_generic"); + if (dictStart == NULL) assert(dictSize == 0); + + while (1) { + /* start new sequence */ + unsigned token = *ip++; + + /* literals */ + { size_t ll = token >> ML_BITS; + if (ll==15) { + /* long literal length */ + ll += read_long_length_no_check(&ip); + } + if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */ + LZ4_memmove(op, ip, ll); /* support in-place decompression */ + op += ll; + ip += ll; + if ((size_t)(oend-op) < MFLIMIT) { + if (op==oend) break; /* end of block */ + DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op); + /* incorrect end of block : + * last match must start at least MFLIMIT==12 bytes before end of output block */ + return -1; + } } + + /* match */ + { size_t ml = token & 15; + size_t const offset = LZ4_readLE16(ip); + ip+=2; + + if (ml==15) { + /* long literal length */ + ml += read_long_length_no_check(&ip); + } + ml += MINMATCH; + + if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */ + + { const BYTE* match = op - offset; + + /* out of range */ + if (offset > (size_t)(op - prefixStart) + dictSize) { + DEBUGLOG(6, "offset out of range"); + return -1; + } + + /* check special case : extDict */ + if (offset > (size_t)(op - prefixStart)) { + /* extDict scenario */ + const BYTE* const dictEnd = dictStart + dictSize; + const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart)); + size_t const extml = (size_t)(dictEnd - extMatch); + if (extml > ml) { + /* match entirely within extDict */ + LZ4_memmove(op, extMatch, ml); + op += ml; + ml = 0; + } else { + /* match split between extDict & prefix */ + LZ4_memmove(op, extMatch, extml); + op += extml; + ml -= extml; + } + match = prefixStart; + } + + /* match copy - slow variant, supporting overlap copy */ + { size_t u; + for (u=0; u= lencheck. - * loop_check - check ip >= lencheck in body of loop. Returns loop_error if so. - * initial_check - check ip >= lencheck before start of loop. Returns initial_error if so. - * error (output) - error code. Should be set to 0 before call. - */ -typedef enum { loop_error = -2, initial_error = -1, ok = 0 } variable_length_error; -LZ4_FORCE_INLINE unsigned -read_variable_length(const BYTE**ip, const BYTE* lencheck, - int loop_check, int initial_check, - variable_length_error* error) + * @ip : input pointer + * @ilimit : position after which if length is not decoded, the input is necessarily corrupted. + * @initial_check - check ip >= ipmax before start of loop. Returns initial_error if so. + * @error (output) - error code. Must be set to 0 before call. +**/ +typedef size_t Rvl_t; +static const Rvl_t rvl_error = (Rvl_t)(-1); +LZ4_FORCE_INLINE Rvl_t +read_variable_length(const BYTE** ip, const BYTE* ilimit, + int initial_check) { - U32 length = 0; - U32 s; - if (initial_check && unlikely((*ip) >= lencheck)) { /* overflow detection */ - *error = initial_error; - return length; + Rvl_t s, length = 0; + assert(ip != NULL); + assert(*ip != NULL); + assert(ilimit != NULL); + if (initial_check && unlikely((*ip) >= ilimit)) { /* read limit reached */ + return rvl_error; } do { s = **ip; (*ip)++; length += s; - if (loop_check && unlikely((*ip) >= lencheck)) { /* overflow detection */ - *error = loop_error; - return length; + if (unlikely((*ip) > ilimit)) { /* read limit reached */ + return rvl_error; + } + /* accumulator overflow detection (32-bit mode only) */ + if ((sizeof(length)<8) && unlikely(length > ((Rvl_t)(-1)/2)) ) { + return rvl_error; } } while (s==255); @@ -1741,7 +1940,6 @@ LZ4_decompress_generic( int srcSize, int outputSize, /* If endOnInput==endOnInputSize, this value is `dstCapacity` */ - endCondition_directive endOnInput, /* endOnOutputSize, endOnInputSize */ earlyEnd_directive partialDecoding, /* full, partial */ dict_directive dict, /* noDict, withPrefix64k, usingExtDict */ const BYTE* const lowPrefix, /* always <= dst, == dst when no prefix */ @@ -1749,7 +1947,7 @@ LZ4_decompress_generic( const size_t dictSize /* note : = 0 if noDict */ ) { - if (src == NULL) { return -1; } + if ((src == NULL) || (outputSize < 0)) { return -1; } { const BYTE* ip = (const BYTE*) src; const BYTE* const iend = ip + srcSize; @@ -1760,13 +1958,12 @@ LZ4_decompress_generic( const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize; - const int safeDecode = (endOnInput==endOnInputSize); - const int checkOffset = ((safeDecode) && (dictSize < (int)(64 KB))); + const int checkOffset = (dictSize < (int)(64 KB)); /* Set up the "end" pointers for the shortcut. */ - const BYTE* const shortiend = iend - (endOnInput ? 14 : 8) /*maxLL*/ - 2 /*offset*/; - const BYTE* const shortoend = oend - (endOnInput ? 14 : 8) /*maxLL*/ - 18 /*maxML*/; + const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/; + const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/; const BYTE* match; size_t offset; @@ -1778,83 +1975,70 @@ LZ4_decompress_generic( /* Special cases */ assert(lowPrefix <= op); - if ((endOnInput) && (unlikely(outputSize==0))) { + if (unlikely(outputSize==0)) { /* Empty output buffer */ if (partialDecoding) return 0; return ((srcSize==1) && (*ip==0)) ? 0 : -1; } - if ((!endOnInput) && (unlikely(outputSize==0))) { return (*ip==0 ? 1 : -1); } - if ((endOnInput) && unlikely(srcSize==0)) { return -1; } + if (unlikely(srcSize==0)) { return -1; } - /* Currently the fast loop shows a regression on qualcomm arm chips. */ + /* LZ4_FAST_DEC_LOOP: + * designed for modern OoO performance cpus, + * where copying reliably 32-bytes is preferable to an unpredictable branch. + * note : fast loop may show a regression for some client arm chips. */ #if LZ4_FAST_DEC_LOOP if ((oend - op) < FASTLOOP_SAFE_DISTANCE) { DEBUGLOG(6, "skip fast decode loop"); goto safe_decode; } - /* Fast loop : decode sequences as long as output < iend-FASTLOOP_SAFE_DISTANCE */ + /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */ while (1) { /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */ assert(oend - op >= FASTLOOP_SAFE_DISTANCE); - if (endOnInput) { assert(ip < iend); } + assert(ip < iend); token = *ip++; length = token >> ML_BITS; /* literal length */ - assert(!endOnInput || ip <= iend); /* ip < iend before the increment */ - /* decode literal length */ if (length == RUN_MASK) { - variable_length_error error = ok; - length += read_variable_length(&ip, iend-RUN_MASK, (int)endOnInput, (int)endOnInput, &error); - if (error == initial_error) { goto _output_error; } - if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ - if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ + size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1); + if (addl == rvl_error) { goto _output_error; } + length += addl; + if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ + if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ /* copy literals */ cpy = op+length; LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); - if (endOnInput) { /* LZ4_decompress_safe() */ - if ((cpy>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; } - LZ4_wildCopy32(op, ip, cpy); - } else { /* LZ4_decompress_fast() */ - if (cpy>oend-8) { goto safe_literal_copy; } - LZ4_wildCopy8(op, ip, cpy); /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time : - * it doesn't know input length, and only relies on end-of-block properties */ - } + if ((cpy>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; } + LZ4_wildCopy32(op, ip, cpy); ip += length; op = cpy; } else { cpy = op+length; - if (endOnInput) { /* LZ4_decompress_safe() */ - DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length); - /* We don't need to check oend, since we check it once for each loop below */ - if (ip > iend-(16 + 1/*max lit + offset + nextToken*/)) { goto safe_literal_copy; } - /* Literals can only be 14, but hope compilers optimize if we copy by a register size */ - LZ4_memcpy(op, ip, 16); - } else { /* LZ4_decompress_fast() */ - /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time : - * it doesn't know input length, and relies on end-of-block properties */ - LZ4_memcpy(op, ip, 8); - if (length > 8) { LZ4_memcpy(op+8, ip+8, 8); } - } + DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length); + /* We don't need to check oend, since we check it once for each loop below */ + if (ip > iend-(16 + 1/*max lit + offset + nextToken*/)) { goto safe_literal_copy; } + /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */ + LZ4_memcpy(op, ip, 16); ip += length; op = cpy; } /* get offset */ offset = LZ4_readLE16(ip); ip+=2; match = op - offset; - assert(match <= op); + assert(match <= op); /* overflow check */ /* get matchlength */ length = token & ML_MASK; if (length == ML_MASK) { - variable_length_error error = ok; - if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */ - length += read_variable_length(&ip, iend - LASTLITERALS + 1, (int)endOnInput, 0, &error); - if (error != ok) { goto _output_error; } - if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */ + size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0); + if (addl == rvl_error) { goto _output_error; } + length += addl; length += MINMATCH; + if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */ + if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */ if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) { goto safe_match_copy; } @@ -1864,7 +2048,7 @@ LZ4_decompress_generic( goto safe_match_copy; } - /* Fastpath check: Avoids a branch in LZ4_wildCopy32 if true */ + /* Fastpath check: skip LZ4_wildCopy32 when true */ if ((dict == withPrefix64k) || (match >= lowPrefix)) { if (offset >= 8) { assert(match >= lowPrefix); @@ -1881,6 +2065,7 @@ LZ4_decompress_generic( if (checkOffset && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */ /* match starting within external dictionary */ if ((dict==usingExtDict) && (match < lowPrefix)) { + assert(dictEnd != NULL); if (unlikely(op+length > oend-LASTLITERALS)) { if (partialDecoding) { DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd"); @@ -1891,7 +2076,7 @@ LZ4_decompress_generic( if (length <= (size_t)(lowPrefix-match)) { /* match fits entirely within external dictionary : just copy */ - memmove(op, dictEnd - (lowPrefix-match), length); + LZ4_memmove(op, dictEnd - (lowPrefix-match), length); op += length; } else { /* match stretches into both external dictionary and current block */ @@ -1927,11 +2112,10 @@ LZ4_decompress_generic( /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */ while (1) { + assert(ip < iend); token = *ip++; length = token >> ML_BITS; /* literal length */ - assert(!endOnInput || ip <= iend); /* ip < iend before the increment */ - /* A two-stage shortcut for the most common case: * 1) If the literal length is 0..14, and there is enough space, * enter the shortcut and copy 16 bytes on behalf of the literals @@ -1941,11 +2125,11 @@ LZ4_decompress_generic( * those 18 bytes earlier, upon entering the shortcut (in other words, * there is a combined check for both stages). */ - if ( (endOnInput ? length != RUN_MASK : length <= 8) + if ( (length != RUN_MASK) /* strictly "less than" on input, to re-enter the loop with at least one byte */ - && likely((endOnInput ? ip < shortiend : 1) & (op <= shortoend)) ) { + && likely((ip < shortiend) & (op <= shortoend)) ) { /* Copy the literals */ - LZ4_memcpy(op, ip, endOnInput ? 16 : 8); + LZ4_memcpy(op, ip, 16); op += length; ip += length; /* The second stage: prepare for match copying, decode full info. @@ -1975,11 +2159,11 @@ LZ4_decompress_generic( /* decode literal length */ if (length == RUN_MASK) { - variable_length_error error = ok; - length += read_variable_length(&ip, iend-RUN_MASK, (int)endOnInput, (int)endOnInput, &error); - if (error == initial_error) { goto _output_error; } - if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ - if ((safeDecode) && unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ + size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1); + if (addl == rvl_error) { goto _output_error; } + length += addl; + if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */ + if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */ } /* copy literals */ @@ -1988,9 +2172,7 @@ LZ4_decompress_generic( safe_literal_copy: #endif LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH); - if ( ((endOnInput) && ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) ) - || ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) ) - { + if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) { /* We've either hit the input parsing restriction or the output parsing restriction. * In the normal scenario, decoding a full block, it must be the last sequence, * otherwise it's an error (invalid input or dimensions). @@ -2000,7 +2182,6 @@ LZ4_decompress_generic( /* Since we are partial decoding we may be in this block because of the output parsing * restriction, which is not valid since the output buffer is allowed to be undersized. */ - assert(endOnInput); DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end") DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length); DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op)); @@ -2021,21 +2202,17 @@ LZ4_decompress_generic( length = (size_t)(oend-op); } } else { - /* We must be on the last sequence because of the parsing limitations so check - * that we exactly regenerate the original size (must be exact when !endOnInput). - */ - if ((!endOnInput) && (cpy != oend)) { goto _output_error; } /* We must be on the last sequence (or invalid) because of the parsing limitations * so check that we exactly consume the input and don't overrun the output buffer. */ - if ((endOnInput) && ((ip+length != iend) || (cpy > oend))) { + if ((ip+length != iend) || (cpy > oend)) { DEBUGLOG(6, "should have been last run of literals") DEBUGLOG(6, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend); DEBUGLOG(6, "or cpy(%p) > oend(%p)", cpy, oend); goto _output_error; } } - memmove(op, ip, length); /* supports overlapping memory regions; only matters for in-place decompression scenarios */ + LZ4_memmove(op, ip, length); /* supports overlapping memory regions, for in-place decompression scenarios */ ip += length; op += length; /* Necessarily EOF when !partialDecoding. @@ -2047,7 +2224,7 @@ LZ4_decompress_generic( break; } } else { - LZ4_wildCopy8(op, ip, cpy); /* may overwrite up to WILDCOPYLENGTH beyond cpy */ + LZ4_wildCopy8(op, ip, cpy); /* can overwrite up to 8 bytes beyond cpy */ ip += length; op = cpy; } @@ -2060,10 +2237,10 @@ LZ4_decompress_generic( _copy_match: if (length == ML_MASK) { - variable_length_error error = ok; - length += read_variable_length(&ip, iend - LASTLITERALS + 1, (int)endOnInput, 0, &error); - if (error != ok) goto _output_error; - if ((safeDecode) && unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error; /* overflow detection */ + size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0); + if (addl == rvl_error) { goto _output_error; } + length += addl; + if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error; /* overflow detection */ } length += MINMATCH; @@ -2073,6 +2250,7 @@ LZ4_decompress_generic( if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error; /* Error : offset outside buffers */ /* match starting within external dictionary */ if ((dict==usingExtDict) && (match < lowPrefix)) { + assert(dictEnd != NULL); if (unlikely(op+length > oend-LASTLITERALS)) { if (partialDecoding) length = MIN(length, (size_t)(oend-op)); else goto _output_error; /* doesn't respect parsing restriction */ @@ -2080,7 +2258,7 @@ LZ4_decompress_generic( if (length <= (size_t)(lowPrefix-match)) { /* match fits entirely within external dictionary : just copy */ - memmove(op, dictEnd - (lowPrefix-match), length); + LZ4_memmove(op, dictEnd - (lowPrefix-match), length); op += length; } else { /* match stretches into both external dictionary and current block */ @@ -2151,12 +2329,8 @@ LZ4_decompress_generic( } /* end of decoding */ - if (endOnInput) { - DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst)); - return (int) (((char*)op)-dst); /* Nb of output bytes decoded */ - } else { - return (int) (((const char*)ip)-src); /* Nb of input bytes read */ - } + DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst)); + return (int) (((char*)op)-dst); /* Nb of output bytes decoded */ /* Overflow error detected */ _output_error: @@ -2171,7 +2345,7 @@ LZ4_FORCE_O2 int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize, - endOnInputSize, decode_full_block, noDict, + decode_full_block, noDict, (BYTE*)dest, NULL, 0); } @@ -2180,16 +2354,17 @@ int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, { dstCapacity = MIN(targetOutputSize, dstCapacity); return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity, - endOnInputSize, partial_decode, + partial_decode, noDict, (BYTE*)dst, NULL, 0); } LZ4_FORCE_O2 int LZ4_decompress_fast(const char* source, char* dest, int originalSize) { - return LZ4_decompress_generic(source, dest, 0, originalSize, - endOnOutputSize, decode_full_block, withPrefix64k, - (BYTE*)dest - 64 KB, NULL, 0); + DEBUGLOG(5, "LZ4_decompress_fast"); + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + 0, NULL, 0); } /*===== Instantiate a few more decoding cases, used more than once. =====*/ @@ -2198,16 +2373,25 @@ LZ4_FORCE_O2 /* Exported, an obsolete API function. */ int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, - endOnInputSize, decode_full_block, withPrefix64k, + decode_full_block, withPrefix64k, + (BYTE*)dest - 64 KB, NULL, 0); +} + +LZ4_FORCE_O2 +static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, + partial_decode, withPrefix64k, (BYTE*)dest - 64 KB, NULL, 0); } /* Another obsolete API function, paired with the previous one. */ int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize) { - /* LZ4_decompress_fast doesn't validate match offsets, - * and thus serves well with any prefixed dictionary. */ - return LZ4_decompress_fast(source, dest, originalSize); + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + 64 KB, NULL, 0); } LZ4_FORCE_O2 @@ -2215,7 +2399,17 @@ static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, i size_t prefixSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, - endOnInputSize, decode_full_block, noDict, + decode_full_block, noDict, + (BYTE*)dest-prefixSize, NULL, 0); +} + +LZ4_FORCE_O2 +static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, + size_t prefixSize) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, + partial_decode, noDict, (BYTE*)dest-prefixSize, NULL, 0); } @@ -2225,7 +2419,18 @@ int LZ4_decompress_safe_forceExtDict(const char* source, char* dest, const void* dictStart, size_t dictSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, - endOnInputSize, decode_full_block, usingExtDict, + decode_full_block, usingExtDict, + (BYTE*)dest, (const BYTE*)dictStart, dictSize); +} + +LZ4_FORCE_O2 +int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest, + int compressedSize, int targetOutputSize, int dstCapacity, + const void* dictStart, size_t dictSize) +{ + dstCapacity = MIN(targetOutputSize, dstCapacity); + return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity, + partial_decode, usingExtDict, (BYTE*)dest, (const BYTE*)dictStart, dictSize); } @@ -2233,9 +2438,9 @@ LZ4_FORCE_O2 static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize, const void* dictStart, size_t dictSize) { - return LZ4_decompress_generic(source, dest, 0, originalSize, - endOnOutputSize, decode_full_block, usingExtDict, - (BYTE*)dest, (const BYTE*)dictStart, dictSize); + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + 0, (const BYTE*)dictStart, dictSize); } /* The "double dictionary" mode, for use with e.g. ring buffers: the first part @@ -2247,26 +2452,17 @@ int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compresse size_t prefixSize, const void* dictStart, size_t dictSize) { return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize, - endOnInputSize, decode_full_block, usingExtDict, - (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize); -} - -LZ4_FORCE_INLINE -int LZ4_decompress_fast_doubleDict(const char* source, char* dest, int originalSize, - size_t prefixSize, const void* dictStart, size_t dictSize) -{ - return LZ4_decompress_generic(source, dest, 0, originalSize, - endOnOutputSize, decode_full_block, usingExtDict, + decode_full_block, usingExtDict, (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize); } /*===== streaming decompression functions =====*/ +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) LZ4_streamDecode_t* LZ4_createStreamDecode(void) { - LZ4_streamDecode_t* lz4s = (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t)); - LZ4_STATIC_ASSERT(LZ4_STREAMDECODESIZE >= sizeof(LZ4_streamDecode_t_internal)); /* A compilation error here means LZ4_STREAMDECODESIZE is not large enough */ - return lz4s; + LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal)); + return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t)); } int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream) @@ -2275,6 +2471,7 @@ int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream) FREEMEM(LZ4_stream); return 0; } +#endif /*! LZ4_setStreamDecode() : * Use this function to instruct where to find the dictionary. @@ -2285,8 +2482,13 @@ int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream) int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize) { LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse; - lz4sd->prefixSize = (size_t) dictSize; - lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize; + lz4sd->prefixSize = (size_t)dictSize; + if (dictSize) { + assert(dictionary != NULL); + lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize; + } else { + lz4sd->prefixEnd = (const BYTE*) dictionary; + } lz4sd->externalDict = NULL; lz4sd->extDictSize = 0; return 1; @@ -2358,29 +2560,35 @@ int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const ch return result; } -LZ4_FORCE_O2 -int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize) +LZ4_FORCE_O2 int +LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, + const char* source, char* dest, int originalSize) { - LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse; + LZ4_streamDecode_t_internal* const lz4sd = + (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse); int result; + + DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize); assert(originalSize >= 0); if (lz4sd->prefixSize == 0) { + DEBUGLOG(5, "first invocation : no prefix nor extDict"); assert(lz4sd->extDictSize == 0); result = LZ4_decompress_fast(source, dest, originalSize); if (result <= 0) return result; lz4sd->prefixSize = (size_t)originalSize; lz4sd->prefixEnd = (BYTE*)dest + originalSize; } else if (lz4sd->prefixEnd == (BYTE*)dest) { - if (lz4sd->prefixSize >= 64 KB - 1 || lz4sd->extDictSize == 0) - result = LZ4_decompress_fast(source, dest, originalSize); - else - result = LZ4_decompress_fast_doubleDict(source, dest, originalSize, - lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize); + DEBUGLOG(5, "continue using existing prefix"); + result = LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + lz4sd->prefixSize, + lz4sd->externalDict, lz4sd->extDictSize); if (result <= 0) return result; lz4sd->prefixSize += (size_t)originalSize; lz4sd->prefixEnd += originalSize; } else { + DEBUGLOG(5, "prefix becomes extDict"); lz4sd->extDictSize = lz4sd->prefixSize; lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize; result = LZ4_decompress_fast_extDict(source, dest, originalSize, @@ -2416,10 +2624,27 @@ int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressed return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize); } +int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize) +{ + if (dictSize==0) + return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity); + if (dictStart+dictSize == dest) { + if (dictSize >= 64 KB - 1) { + return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity); + } + assert(dictSize >= 0); + return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize); + } + assert(dictSize >= 0); + return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize); +} + int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize) { if (dictSize==0 || dictStart+dictSize == dest) - return LZ4_decompress_fast(source, dest, originalSize); + return LZ4_decompress_unsafe_generic( + (const BYTE*)source, (BYTE*)dest, originalSize, + (size_t)dictSize, NULL, 0); assert(dictSize >= 0); return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize); } @@ -2471,7 +2696,7 @@ int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, /* Obsolete Streaming functions */ -int LZ4_sizeofStreamState(void) { return LZ4_STREAMSIZE; } +int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); } int LZ4_resetStreamState(void* state, char* inputBuffer) { @@ -2480,11 +2705,13 @@ int LZ4_resetStreamState(void* state, char* inputBuffer) return 0; } +#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) void* LZ4_create (char* inputBuffer) { (void)inputBuffer; return LZ4_createStream(); } +#endif char* LZ4_slideInputBuffer (void* state) { diff --git a/source/core/nca.c b/source/core/nca.c index 87af7e9..dce04a1 100644 --- a/source/core/nca.c +++ b/source/core/nca.c @@ -273,8 +273,9 @@ bool ncaGenerateHierarchicalSha256Patch(NcaFsSectionContext *ctx, const void *da void ncaWriteHierarchicalSha256PatchToMemoryBuffer(NcaContext *ctx, NcaHierarchicalSha256Patch *patch, void *buf, u64 buf_size, u64 buf_offset) { - if (!ctx || !*(ctx->content_id_str) || ctx->content_size < NCA_FULL_HEADER_LENGTH || !patch || patch->written || memcmp(patch->content_id.c, ctx->content_id.c, 0x10) != 0 || \ - !patch->hash_region_count || patch->hash_region_count > NCA_HIERARCHICAL_SHA256_MAX_REGION_COUNT || !buf || !buf_size || (buf_offset + buf_size) > ctx->content_size) return; + if (!ctx || !*(ctx->content_id_str) || ctx->content_size < NCA_FULL_HEADER_LENGTH || !patch || patch->written || \ + memcmp(patch->content_id.c, ctx->content_id.c, sizeof(NcmContentId)) != 0 || !patch->hash_region_count || \ + patch->hash_region_count > NCA_HIERARCHICAL_SHA256_MAX_REGION_COUNT || !buf || !buf_size || (buf_offset + buf_size) > ctx->content_size) return; patch->written = true; @@ -297,8 +298,8 @@ bool ncaGenerateHierarchicalIntegrityPatch(NcaFsSectionContext *ctx, const void void ncaWriteHierarchicalIntegrityPatchToMemoryBuffer(NcaContext *ctx, NcaHierarchicalIntegrityPatch *patch, void *buf, u64 buf_size, u64 buf_offset) { - if (!ctx || !*(ctx->content_id_str) || ctx->content_size < NCA_FULL_HEADER_LENGTH || !patch || patch->written || memcmp(patch->content_id.c, ctx->content_id.c, 0x10) != 0 || \ - !buf || !buf_size || (buf_offset + buf_size) > ctx->content_size) return; + if (!ctx || !*(ctx->content_id_str) || ctx->content_size < NCA_FULL_HEADER_LENGTH || !patch || patch->written || \ + memcmp(patch->content_id.c, ctx->content_id.c, sizeof(NcmContentId)) != 0 || !buf || !buf_size || (buf_offset + buf_size) > ctx->content_size) return; patch->written = true; @@ -458,13 +459,12 @@ void ncaUpdateContentIdAndHash(NcaContext *ctx, u8 hash[SHA256_HASH_SIZE]) const char *ncaGetFsSectionTypeName(NcaFsSectionContext *ctx) { - NcaContext *nca_ctx = NULL; const char *str = "Invalid"; bool is_exefs = false; - if (!ctx || !(nca_ctx = (NcaContext*)ctx->nca_ctx)) return str; + if (!ctx || !ctx->nca_ctx) return str; - is_exefs = (nca_ctx->content_type == NcmContentType_Program && ctx->section_idx == 0); + is_exefs = (ctx->nca_ctx->content_type == NcmContentType_Program && ctx->section_idx == 0); switch(ctx->section_type) { @@ -1019,7 +1019,7 @@ end: static bool ncaFsSectionValidateHashDataBoundaries(NcaFsSectionContext *ctx) { #if LOG_LEVEL <= LOG_LEVEL_WARNING - NcaContext *nca_ctx = (NcaContext*)ctx->nca_ctx; + const char *content_id_str = ctx->nca_ctx->content_id_str; #endif bool success = false, valid = true; @@ -1038,7 +1038,7 @@ static bool ncaFsSectionValidateHashDataBoundaries(NcaFsSectionContext *ctx) if (!hash_data->hash_block_size || !hash_data->hash_region_count || hash_data->hash_region_count > NCA_HIERARCHICAL_SHA256_MAX_REGION_COUNT) { LOG_DATA_WARNING(hash_data, sizeof(NcaHierarchicalSha256Data), "Invalid HierarchicalSha256 data for FS section #%u in \"%s\". Skipping FS section. Hash data dump:", \ - ctx->section_idx, nca_ctx->content_id_str); + ctx->section_idx, content_id_str); break; } @@ -1050,7 +1050,7 @@ static bool ncaFsSectionValidateHashDataBoundaries(NcaFsSectionContext *ctx) ((i < (hash_data->hash_region_count - 1) || !ctx->has_sparse_layer) && (hash_region->offset + hash_region->size) > ctx->section_size)) { LOG_MSG_WARNING("HierarchicalSha256 region #%u for FS section #%u in \"%s\" is out of NCA boundaries. Skipping FS section.", \ - i, ctx->section_idx, nca_ctx->content_id_str); + i, ctx->section_idx, content_id_str); valid = false; break; } @@ -1070,7 +1070,7 @@ static bool ncaFsSectionValidateHashDataBoundaries(NcaFsSectionContext *ctx) hash_data->info_level_hash.max_level_count != NCA_IVFC_MAX_LEVEL_COUNT) { LOG_DATA_WARNING(hash_data, sizeof(NcaIntegrityMetaInfo), "Invalid HierarchicalIntegrity data for FS section #%u in \"%s\". Skipping FS section. Hash data dump:", \ - ctx->section_idx, nca_ctx->content_id_str); + ctx->section_idx, content_id_str); break; } @@ -1082,7 +1082,7 @@ static bool ncaFsSectionValidateHashDataBoundaries(NcaFsSectionContext *ctx) (!ctx->has_sparse_layer && ctx->section_type != NcaFsSectionType_PatchRomFs)) && (lvl_info->offset + lvl_info->size) > ctx->section_size)) { LOG_MSG_WARNING("HierarchicalIntegrity level #%u for FS section #%u in \"%s\" is out of NCA boundaries. Skipping FS section.", \ - i, ctx->section_idx, nca_ctx->content_id_str); + i, ctx->section_idx, content_id_str); valid = false; break; } @@ -1095,7 +1095,7 @@ static bool ncaFsSectionValidateHashDataBoundaries(NcaFsSectionContext *ctx) break; default: - LOG_MSG_WARNING("Invalid hash type for FS section #%u in \"%s\" (0x%02X). Skipping FS section.", ctx->section_idx, nca_ctx->content_id_str, ctx->hash_type); + LOG_MSG_WARNING("Invalid hash type for FS section #%u in \"%s\" (0x%02X). Skipping FS section.", ctx->section_idx, content_id_str, ctx->hash_type); break; } @@ -1115,7 +1115,7 @@ static bool _ncaReadFsSection(NcaFsSectionContext *ctx, void *out, u64 read_size size_t crypt_res = 0; u64 sector_num = 0; - NcaContext *nca_ctx = (NcaContext*)ctx->nca_ctx; + NcaContext *nca_ctx = ctx->nca_ctx; u64 content_offset = (ctx->section_offset + offset); u64 sparse_virtual_offset = ((ctx->has_sparse_layer && ctx->cur_sparse_virtual_offset) ? (ctx->section_offset + ctx->cur_sparse_virtual_offset) : 0); @@ -1299,7 +1299,7 @@ static bool _ncaReadAesCtrExStorage(NcaFsSectionContext *ctx, void *out, u64 rea return false; } - NcaContext *nca_ctx = (NcaContext*)ctx->nca_ctx; + NcaContext *nca_ctx = ctx->nca_ctx; u64 content_offset = (ctx->section_offset + offset); u64 block_start_offset = 0, block_end_offset = 0, block_size = 0; @@ -1394,7 +1394,7 @@ static bool ncaGenerateHashDataPatch(NcaFsSectionContext *ctx, const void *data, bool use_sha3 = false, success = false; - if (!ctx || !ctx->enabled || ctx->has_sparse_layer || ctx->has_compression_layer || !(nca_ctx = (NcaContext*)ctx->nca_ctx) || \ + if (!ctx || !ctx->enabled || ctx->has_sparse_layer || ctx->has_compression_layer || !(nca_ctx = ctx->nca_ctx) || \ (!is_integrity_patch && ((ctx->hash_type != NcaHashType_HierarchicalSha256 && ctx->hash_type != NcaHashType_HierarchicalSha3256) || \ !ctx->header.hash_data.hierarchical_sha256_data.hash_block_size || !(layer_count = ctx->header.hash_data.hierarchical_sha256_data.hash_region_count) || \ layer_count > NCA_HIERARCHICAL_SHA256_MAX_REGION_COUNT || !(last_layer_size = ctx->header.hash_data.hierarchical_sha256_data.hash_region[layer_count - 1].size))) || \ @@ -1656,7 +1656,7 @@ static void *ncaGenerateEncryptedFsSectionBlock(NcaFsSectionContext *ctx, const size_t crypt_res = 0; u64 sector_num = 0; - NcaContext *nca_ctx = (NcaContext*)ctx->nca_ctx; + NcaContext *nca_ctx = ctx->nca_ctx; u64 content_offset = (ctx->section_offset + data_offset); u64 block_start_offset = 0, block_end_offset = 0, block_size = 0; diff --git a/source/core/nca_storage.c b/source/core/nca_storage.c index 4fe94eb..438bc1d 100644 --- a/source/core/nca_storage.c +++ b/source/core/nca_storage.c @@ -95,7 +95,7 @@ bool ncaStorageSetPatchOriginalSubStorage(NcaStorageContext *patch_ctx, NcaStora NcaContext *patch_nca_ctx = NULL, *base_nca_ctx = NULL; if (!ncaStorageIsValidContext(patch_ctx) || !ncaStorageIsValidContext(base_ctx) || patch_ctx->nca_fs_ctx == base_ctx->nca_fs_ctx || \ - !(patch_nca_ctx = (NcaContext*)patch_ctx->nca_fs_ctx->nca_ctx) || !(base_nca_ctx = (NcaContext*)base_ctx->nca_fs_ctx->nca_ctx) || \ + !(patch_nca_ctx = patch_ctx->nca_fs_ctx->nca_ctx) || !(base_nca_ctx = base_ctx->nca_fs_ctx->nca_ctx) || \ patch_ctx->nca_fs_ctx->section_type != NcaFsSectionType_PatchRomFs || base_ctx->nca_fs_ctx->section_type != NcaFsSectionType_RomFs || \ patch_nca_ctx->header.program_id != base_nca_ctx->header.program_id || patch_nca_ctx->header.content_type != base_nca_ctx->header.content_type || \ patch_nca_ctx->id_offset != base_nca_ctx->id_offset || patch_nca_ctx->title_version < base_nca_ctx->title_version || \ diff --git a/source/core/npdm.c b/source/core/npdm.c index 2bf45b9..89adf0d 100644 --- a/source/core/npdm.c +++ b/source/core/npdm.c @@ -30,7 +30,7 @@ bool npdmInitializeContext(NpdmContext *out, PartitionFileSystemContext *pfs_ctx bool success = false, dump_meta_header = false, dump_acid_header = false, dump_aci_header = false; PartitionFileSystemEntry *pfs_entry = NULL; - if (!out || !pfs_ctx || !ncaStorageIsValidContext(&(pfs_ctx->storage_ctx)) || !(nca_ctx = (NcaContext*)pfs_ctx->nca_fs_ctx->nca_ctx) || \ + if (!out || !pfs_ctx || !ncaStorageIsValidContext(&(pfs_ctx->storage_ctx)) || !(nca_ctx = pfs_ctx->nca_fs_ctx->nca_ctx) || \ nca_ctx->content_type != NcmContentType_Program || !pfs_ctx->offset || !pfs_ctx->size || !pfs_ctx->is_exefs || \ pfs_ctx->header_size <= sizeof(PartitionFileSystemHeader) || !pfs_ctx->header) { diff --git a/source/core/nso.c b/source/core/nso.c index 71e7a3a..42342d4 100644 --- a/source/core/nso.c +++ b/source/core/nso.c @@ -31,12 +31,11 @@ static bool nsoGetSectionFromRodataSegment(NsoContext *nso_ctx, u8 *rodata_buf, bool nsoInitializeContext(NsoContext *out, PartitionFileSystemContext *pfs_ctx, PartitionFileSystemEntry *pfs_entry) { - NcaContext *nca_ctx = NULL; u8 *rodata_buf = NULL; bool success = false, dump_nso_header = false; - if (!out || !pfs_ctx || !ncaStorageIsValidContext(&(pfs_ctx->storage_ctx)) || !(nca_ctx = (NcaContext*)pfs_ctx->nca_fs_ctx->nca_ctx) || \ - nca_ctx->content_type != NcmContentType_Program || !pfs_ctx->offset || !pfs_ctx->size || !pfs_ctx->is_exefs || \ + if (!out || !pfs_ctx || !ncaStorageIsValidContext(&(pfs_ctx->storage_ctx)) || !pfs_ctx->nca_fs_ctx->nca_ctx || \ + pfs_ctx->nca_fs_ctx->nca_ctx->content_type != NcmContentType_Program || !pfs_ctx->offset || !pfs_ctx->size || !pfs_ctx->is_exefs || \ pfs_ctx->header_size <= sizeof(PartitionFileSystemHeader) || !pfs_ctx->header || !pfs_entry) { LOG_MSG_ERROR("Invalid parameters!"); diff --git a/source/core/pfs.c b/source/core/pfs.c index b7b7633..930a39d 100644 --- a/source/core/pfs.c +++ b/source/core/pfs.c @@ -27,7 +27,6 @@ bool pfsInitializeContext(PartitionFileSystemContext *out, NcaFsSectionContext *nca_fs_ctx) { - NcaContext *nca_ctx = NULL; u32 magic = 0; PartitionFileSystemHeader pfs_header = {0}; @@ -36,8 +35,8 @@ bool pfsInitializeContext(PartitionFileSystemContext *out, NcaFsSectionContext * bool success = false, dump_fs_header = false; if (!out || !nca_fs_ctx || !nca_fs_ctx->enabled || nca_fs_ctx->has_sparse_layer || nca_fs_ctx->section_type != NcaFsSectionType_PartitionFs || \ - (nca_fs_ctx->hash_type != NcaHashType_HierarchicalSha256 && nca_fs_ctx->hash_type != NcaHashType_HierarchicalSha3256) || !(nca_ctx = (NcaContext*)nca_fs_ctx->nca_ctx) || \ - (nca_ctx->rights_id_available && !nca_ctx->titlekey_retrieved)) + (nca_fs_ctx->hash_type != NcaHashType_HierarchicalSha256 && nca_fs_ctx->hash_type != NcaHashType_HierarchicalSha3256) || !nca_fs_ctx->nca_ctx || \ + (nca_fs_ctx->nca_ctx->rights_id_available && !nca_fs_ctx->nca_ctx->titlekey_retrieved)) { LOG_MSG_ERROR("Invalid parameters!"); return false; diff --git a/source/core/romfs.c b/source/core/romfs.c index 0c8cd06..2ce85aa 100644 --- a/source/core/romfs.c +++ b/source/core/romfs.c @@ -38,12 +38,12 @@ bool romfsInitializeContext(RomFileSystemContext *out, NcaFsSectionContext *base base_nca_fs_ctx->section_type != NcaFsSectionType_Nca0RomFs))); if (!out || !base_nca_fs_ctx || (!patch_nca_fs_ctx && (missing_base_romfs || base_nca_fs_ctx->has_sparse_layer)) || \ - (!missing_base_romfs && (!(base_nca_ctx = (NcaContext*)base_nca_fs_ctx->nca_ctx) || (base_nca_ctx->format_version == NcaVersion_Nca0 && \ + (!missing_base_romfs && (!(base_nca_ctx = base_nca_fs_ctx->nca_ctx) || (base_nca_ctx->format_version == NcaVersion_Nca0 && \ (base_nca_fs_ctx->section_type != NcaFsSectionType_Nca0RomFs || base_nca_fs_ctx->hash_type != NcaHashType_HierarchicalSha256)) || \ (base_nca_ctx->format_version != NcaVersion_Nca0 && (base_nca_fs_ctx->section_type != NcaFsSectionType_RomFs || \ (base_nca_fs_ctx->hash_type != NcaHashType_HierarchicalIntegrity && base_nca_fs_ctx->hash_type != NcaHashType_HierarchicalIntegritySha3))) || \ (base_nca_ctx->rights_id_available && !base_nca_ctx->titlekey_retrieved))) || (patch_nca_fs_ctx && (!patch_nca_fs_ctx->enabled || \ - !(patch_nca_ctx = (NcaContext*)patch_nca_fs_ctx->nca_ctx) || (!missing_base_romfs && patch_nca_ctx->format_version != base_nca_ctx->format_version) || \ + !(patch_nca_ctx = patch_nca_fs_ctx->nca_ctx) || (!missing_base_romfs && patch_nca_ctx->format_version != base_nca_ctx->format_version) || \ patch_nca_fs_ctx->section_type != NcaFsSectionType_PatchRomFs || (patch_nca_ctx->rights_id_available && !patch_nca_ctx->titlekey_retrieved)))) { LOG_MSG_ERROR("Invalid parameters!"); diff --git a/source/gamecard_tab.cpp b/source/gamecard_tab.cpp index 8a31724..4680689 100644 --- a/source/gamecard_tab.cpp +++ b/source/gamecard_tab.cpp @@ -22,6 +22,7 @@ #include #include #include +#include namespace i18n = brls::i18n; /* For getStr(). */ using namespace i18n::literals; /* For _i18n. */ @@ -34,7 +35,7 @@ namespace nxdt::views this->list->setSpacing(this->list->getSpacing() / 2); this->list->setMarginBottom(20); - /* Subscribe to gamecard status event. */ + /* Subscribe to the gamecard status event. */ this->gc_status_task_sub = this->root_view->RegisterGameCardTaskListener([this](GameCardStatus gc_status) { /* Process gamecard status. */ this->ProcessGameCardStatus(gc_status); @@ -179,9 +180,16 @@ namespace nxdt::views brls::ListItem *dump_card_image = new brls::ListItem("gamecard_tab/list/dump_card_image/label"_i18n, "gamecard_tab/list/dump_card_image/description"_i18n); - /*dump_card_image->getClickEvent()->subscribe([](brls::View *view) { + dump_card_image->getClickEvent()->subscribe([this](brls::View *view) { + char *raw_filename = titleGenerateGameCardFileName(configGetInteger("naming_convention"), TitleFileNameIllegalCharReplaceType_None); + if (!raw_filename) return; - });*/ + brls::Image *icon = new brls::Image(); + icon->setImage(BOREALIS_ASSET("icon/" APP_TITLE ".jpg")); + icon->setScaleType(brls::ImageScaleType::SCALE); + + brls::Application::pushView(new DumpOptionsFrame(this->root_view, "gamecard_tab/list/dump_card_image/label"_i18n, icon, raw_filename, ".xci"), brls::ViewAnimation::SLIDE_LEFT); + }); this->list->addView(dump_card_image); diff --git a/source/options_tab.cpp b/source/options_tab.cpp index c2c0be6..aeaa0dc 100644 --- a/source/options_tab.cpp +++ b/source/options_tab.cpp @@ -395,8 +395,8 @@ namespace nxdt::views /* Overclock. */ brls::ToggleListItem *overclock = new brls::ToggleListItem("options_tab/overclock/label"_i18n, configGetBoolean("overclock"), \ - "options_tab/overclock/description"_i18n, "options_tab/overclock/value_enabled"_i18n, \ - "options_tab/overclock/value_disabled"_i18n); + "options_tab/overclock/description"_i18n, "generic/value_enabled"_i18n, \ + "generic/value_disabled"_i18n); overclock->getClickEvent()->subscribe([](brls::View* view) { /* Get current value. */ diff --git a/source/root_view.cpp b/source/root_view.cpp index e0891dc..7135249 100644 --- a/source/root_view.cpp +++ b/source/root_view.cpp @@ -81,7 +81,18 @@ namespace nxdt::views this->usb_icon->setVerticalAlign(NVG_ALIGN_TOP); this->usb_icon->setParent(this); - this->usb_host_speed_lbl = new brls::Label(brls::LabelStyle::SMALL, "root_view/not_connected"_i18n); + this->ums_counter_lbl = new brls::Label(brls::LabelStyle::SMALL, i18n::getStr("root_view/ums_counter"_i18n, usbHsFsGetPhysicalDeviceCount())); + this->ums_counter_lbl->setHorizontalAlign(NVG_ALIGN_RIGHT); + this->ums_counter_lbl->setVerticalAlign(NVG_ALIGN_TOP); + this->ums_counter_lbl->setParent(this); + + this->cable_icon = new brls::Label(brls::LabelStyle::SMALL, "\uEFE6"); + this->cable_icon->setFont(material); + this->cable_icon->setHorizontalAlign(NVG_ALIGN_RIGHT); + this->cable_icon->setVerticalAlign(NVG_ALIGN_TOP); + this->cable_icon->setParent(this); + + this->usb_host_speed_lbl = new brls::Label(brls::LabelStyle::SMALL, "root_view/usb_host_not_connected"_i18n); this->usb_host_speed_lbl->setHorizontalAlign(NVG_ALIGN_RIGHT); this->usb_host_speed_lbl->setVerticalAlign(NVG_ALIGN_TOP); this->usb_host_speed_lbl->setParent(this); @@ -128,8 +139,13 @@ namespace nxdt::views this->time_lbl->setText(this->GetFormattedDateString(status_info_data->timeinfo)); /* Update battery labels. */ - this->battery_icon->setText(charger_type != PsmChargerType_Unconnected ? "\uE1A3" : (charge_percentage <= 15 ? "\uE19C" : "\uE1A4")); - this->battery_icon->setColor(charger_type != PsmChargerType_Unconnected ? nvgRGB(0, 255, 0) : (charge_percentage <= 15 ? nvgRGB(255, 0, 0) : brls::Application::getTheme()->textColor)); + this->battery_icon->setText(charger_type != PsmChargerType_Unconnected ? "\uE1A3" : (charge_percentage >= 100 ? "\uE1A4" : (charge_percentage >= 83 ? "\uEBD2" : \ + (charge_percentage >= 67 ? "\uEBD4" : (charge_percentage >= 50 ? "\uEBE2" : \ + (charge_percentage >= 33 ? "\uEBDD" : (charge_percentage >= 17 ? "\uEBE0" : \ + (charge_percentage > 0 ? "\uEBD9" : "\uEBDC")))))))); + + this->battery_icon->setColor(charger_type != PsmChargerType_Unconnected ? nvgRGB(0, 255, 0) : (charge_percentage <= 15 ? nvgRGB(255, 0, 0) : \ + brls::Application::getTheme()->textColor)); this->battery_percentage->setText(fmt::format("{}%", charge_percentage)); @@ -138,19 +154,24 @@ namespace nxdt::views this->connection_status_lbl->setText(ip_addr ? std::string(ip_addr) : "root_view/not_connected"_i18n); }); + /* Subscribe to UMS event. */ + this->ums_task_sub = this->ums_task->RegisterListener([this](const nxdt::tasks::UmsDeviceVector* ums_devices) { + /* Update UMS counter label. */ + this->ums_counter_lbl->setText(i18n::getStr("root_view/ums_counter"_i18n, usbHsFsGetPhysicalDeviceCount())); + }); + /* Subscribe to USB host event. */ this->usb_host_task_sub = this->usb_host_task->RegisterListener([this](UsbHostSpeed usb_host_speed) { /* Update USB host speed label. */ - this->usb_host_speed_lbl->setText(usb_host_speed ? fmt::format("USB {}.0", usb_host_speed) : "root_view/not_connected"_i18n); + this->usb_host_speed_lbl->setText(usb_host_speed ? i18n::getStr("root_view/usb_host_speed"_i18n, usb_host_speed) : "root_view/usb_host_not_connected"_i18n); }); } RootView::~RootView(void) { - /* Unregister USB host task listener. */ + /* Unregister task listeners. */ this->usb_host_task->UnregisterListener(this->usb_host_task_sub); - - /* Unregister status info task listener. */ + this->ums_task->UnregisterListener(this->ums_task_sub); this->status_info_task->UnregisterListener(this->status_info_task_sub); /* Stop background tasks. */ @@ -168,6 +189,8 @@ namespace nxdt::views delete this->connection_icon; delete this->connection_status_lbl; delete this->usb_icon; + delete this->ums_counter_lbl; + delete this->cable_icon; delete this->usb_host_speed_lbl; } @@ -212,12 +235,15 @@ namespace nxdt::views this->connection_status_lbl->frame(ctx); this->usb_icon->frame(ctx); + this->ums_counter_lbl->frame(ctx); + + this->cable_icon->frame(ctx); this->usb_host_speed_lbl->frame(ctx); } void RootView::layout(NVGcontext* vg, brls::Style* style, brls::FontStash* stash) { - int x_pos = 0, y_pos = 0; + int x_orig = 0, x_pos = 0, y_pos = 0; brls::AppletFrame::layout(vg, style, stash); @@ -232,7 +258,7 @@ namespace nxdt::views } /* Time label. */ - x_pos = (this->x + this->width - style->AppletFrame.separatorSpacing - style->AppletFrame.footerTextSpacing); + x_orig = x_pos = (this->x + this->width - style->AppletFrame.separatorSpacing - style->AppletFrame.footerTextSpacing); y_pos = this->y + style->AppletFrame.imageTopPadding; this->time_lbl->setBoundaries(x_pos, y_pos, 0, 0); @@ -259,8 +285,8 @@ namespace nxdt::views this->battery_icon->setBoundaries(x_pos, y_pos, 0, 0); this->battery_icon->invalidate(); - /* USB host speed labels. */ - x_pos = (this->x + this->width - style->AppletFrame.separatorSpacing - style->AppletFrame.footerTextSpacing); + /* UMS device counter and USB host speed labels. */ + x_pos = x_orig; y_pos += (this->connection_status_lbl->getTextHeight() + 5); this->usb_host_speed_lbl->setBoundaries(x_pos, y_pos, 0, 0); @@ -268,6 +294,16 @@ namespace nxdt::views x_pos -= (5 + this->usb_host_speed_lbl->getTextWidth()); + this->cable_icon->setBoundaries(x_pos, y_pos, 0, 0); + this->cable_icon->invalidate(); + + x_pos -= (10 + this->cable_icon->getTextWidth()); + + this->ums_counter_lbl->setBoundaries(x_pos, y_pos, 0, 0); + this->ums_counter_lbl->invalidate(); + + x_pos -= (5 + this->ums_counter_lbl->getTextWidth()); + this->usb_icon->setBoundaries(x_pos, y_pos, 0, 0); this->usb_icon->invalidate(); } diff --git a/source/tasks.cpp b/source/tasks.cpp index d07d89f..778e356 100644 --- a/source/tasks.cpp +++ b/source/tasks.cpp @@ -236,6 +236,11 @@ namespace nxdt::tasks } } + const UmsDeviceVector* UmsTask::GetUmsDevices(void) + { + return &(this->ums_devices); + } + void UmsTask::PopulateUmsDeviceVector(void) { UsbHsFsDevice *ums_devices = NULL; diff --git a/source/titles_tab.cpp b/source/titles_tab.cpp index 8b9dda7..9ed9a63 100644 --- a/source/titles_tab.cpp +++ b/source/titles_tab.cpp @@ -120,7 +120,7 @@ namespace nxdt::views if (!app_metadata_count) return; /* Populate list. */ - for(TitleApplicationMetadata *cur_app_metadata : *app_metadata) + for(const TitleApplicationMetadata *cur_app_metadata : *app_metadata) { /* Create list item. */ TitlesTabItem *title = new TitlesTabItem(cur_app_metadata, this->is_system);