| 1 | /* |
| 2 | * Copyright (c) Meta Platforms, Inc. and affiliates. |
| 3 | * All rights reserved. |
| 4 | * |
| 5 | * This source code is licensed under both the BSD-style license (found in the |
| 6 | * LICENSE file in the root directory of this source tree) and the GPLv2 (found |
| 7 | * in the COPYING file in the root directory of this source tree). |
| 8 | * You may select, at your option, one of the above-listed licenses. |
| 9 | */ |
| 10 | |
| 11 | |
| 12 | /* *************************************************************** |
| 13 | * Tuning parameters |
| 14 | *****************************************************************/ |
| 15 | /*! |
| 16 | * HEAPMODE : |
| 17 | * Select how default decompression function ZSTD_decompress() allocates its context, |
| 18 | * on stack (0), or into heap (1, default; requires malloc()). |
| 19 | * Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected. |
| 20 | */ |
| 21 | #ifndef ZSTD_HEAPMODE |
| 22 | # define ZSTD_HEAPMODE 1 |
| 23 | #endif |
| 24 | |
| 25 | /*! |
| 26 | * LEGACY_SUPPORT : |
| 27 | * if set to 1+, ZSTD_decompress() can decode older formats (v0.1+) |
| 28 | */ |
| 29 | #ifndef ZSTD_LEGACY_SUPPORT |
| 30 | # define ZSTD_LEGACY_SUPPORT 0 |
| 31 | #endif |
| 32 | |
| 33 | /*! |
| 34 | * MAXWINDOWSIZE_DEFAULT : |
| 35 | * maximum window size accepted by DStream __by default__. |
| 36 | * Frames requiring more memory will be rejected. |
| 37 | * It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize(). |
| 38 | */ |
| 39 | #ifndef ZSTD_MAXWINDOWSIZE_DEFAULT |
| 40 | # define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1) |
| 41 | #endif |
| 42 | |
| 43 | /*! |
| 44 | * NO_FORWARD_PROGRESS_MAX : |
| 45 | * maximum allowed nb of calls to ZSTD_decompressStream() |
| 46 | * without any forward progress |
| 47 | * (defined as: no byte read from input, and no byte flushed to output) |
| 48 | * before triggering an error. |
| 49 | */ |
| 50 | #ifndef ZSTD_NO_FORWARD_PROGRESS_MAX |
| 51 | # define ZSTD_NO_FORWARD_PROGRESS_MAX 16 |
| 52 | #endif |
| 53 | |
| 54 | |
| 55 | /*-******************************************************* |
| 56 | * Dependencies |
| 57 | *********************************************************/ |
| 58 | #include "../common/allocations.h" /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */ |
| 59 | #include "../common/zstd_deps.h" /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */ |
| 60 | #include "../common/mem.h" /* low level memory routines */ |
| 61 | #define FSE_STATIC_LINKING_ONLY |
| 62 | #include "../common/fse.h" |
| 63 | #include "../common/huf.h" |
| 64 | #include "../common/xxhash.h" /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */ |
| 65 | #include "../common/zstd_internal.h" /* blockProperties_t */ |
| 66 | #include "zstd_decompress_internal.h" /* ZSTD_DCtx */ |
| 67 | #include "zstd_ddict.h" /* ZSTD_DDictDictContent */ |
| 68 | #include "zstd_decompress_block.h" /* ZSTD_decompressBlock_internal */ |
| 69 | #include "../common/bits.h" /* ZSTD_highbit32 */ |
| 70 | |
| 71 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) |
| 72 | # include "../legacy/zstd_legacy.h" |
| 73 | #endif |
| 74 | |
| 75 | |
| 76 | |
| 77 | /************************************* |
| 78 | * Multiple DDicts Hashset internals * |
| 79 | *************************************/ |
| 80 | |
| 81 | #define DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT 4 |
| 82 | #define DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT 3 /* These two constants represent SIZE_MULT/COUNT_MULT load factor without using a float. |
| 83 | * Currently, that means a 0.75 load factor. |
| 84 | * So, if count * COUNT_MULT / size * SIZE_MULT != 0, then we've exceeded |
| 85 | * the load factor of the ddict hash set. |
| 86 | */ |
| 87 | |
| 88 | #define DDICT_HASHSET_TABLE_BASE_SIZE 64 |
| 89 | #define DDICT_HASHSET_RESIZE_FACTOR 2 |
| 90 | |
| 91 | /* Hash function to determine starting position of dict insertion within the table |
| 92 | * Returns an index between [0, hashSet->ddictPtrTableSize] |
| 93 | */ |
| 94 | static size_t ZSTD_DDictHashSet_getIndex(const ZSTD_DDictHashSet* hashSet, U32 dictID) { |
| 95 | const U64 hash = XXH64(&dictID, sizeof(U32), 0); |
| 96 | /* DDict ptr table size is a multiple of 2, use size - 1 as mask to get index within [0, hashSet->ddictPtrTableSize) */ |
| 97 | return hash & (hashSet->ddictPtrTableSize - 1); |
| 98 | } |
| 99 | |
| 100 | /* Adds DDict to a hashset without resizing it. |
| 101 | * If inserting a DDict with a dictID that already exists in the set, replaces the one in the set. |
| 102 | * Returns 0 if successful, or a zstd error code if something went wrong. |
| 103 | */ |
| 104 | static size_t ZSTD_DDictHashSet_emplaceDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict) { |
| 105 | const U32 dictID = ZSTD_getDictID_fromDDict(ddict); |
| 106 | size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID); |
| 107 | const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1; |
| 108 | RETURN_ERROR_IF(hashSet->ddictPtrCount == hashSet->ddictPtrTableSize, GENERIC, "Hash set is full!"); |
| 109 | DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx); |
| 110 | while (hashSet->ddictPtrTable[idx] != NULL) { |
| 111 | /* Replace existing ddict if inserting ddict with same dictID */ |
| 112 | if (ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]) == dictID) { |
| 113 | DEBUGLOG(4, "DictID already exists, replacing rather than adding"); |
| 114 | hashSet->ddictPtrTable[idx] = ddict; |
| 115 | return 0; |
| 116 | } |
| 117 | idx &= idxRangeMask; |
| 118 | idx++; |
| 119 | } |
| 120 | DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx); |
| 121 | hashSet->ddictPtrTable[idx] = ddict; |
| 122 | hashSet->ddictPtrCount++; |
| 123 | return 0; |
| 124 | } |
| 125 | |
| 126 | /* Expands hash table by factor of DDICT_HASHSET_RESIZE_FACTOR and |
| 127 | * rehashes all values, allocates new table, frees old table. |
| 128 | * Returns 0 on success, otherwise a zstd error code. |
| 129 | */ |
| 130 | static size_t ZSTD_DDictHashSet_expand(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) { |
| 131 | size_t newTableSize = hashSet->ddictPtrTableSize * DDICT_HASHSET_RESIZE_FACTOR; |
| 132 | const ZSTD_DDict** newTable = (const ZSTD_DDict**)ZSTD_customCalloc(sizeof(ZSTD_DDict*) * newTableSize, customMem); |
| 133 | const ZSTD_DDict** oldTable = hashSet->ddictPtrTable; |
| 134 | size_t oldTableSize = hashSet->ddictPtrTableSize; |
| 135 | size_t i; |
| 136 | |
| 137 | DEBUGLOG(4, "Expanding DDict hash table! Old size: %zu new size: %zu", oldTableSize, newTableSize); |
| 138 | RETURN_ERROR_IF(!newTable, memory_allocation, "Expanded hashset allocation failed!"); |
| 139 | hashSet->ddictPtrTable = newTable; |
| 140 | hashSet->ddictPtrTableSize = newTableSize; |
| 141 | hashSet->ddictPtrCount = 0; |
| 142 | for (i = 0; i < oldTableSize; ++i) { |
| 143 | if (oldTable[i] != NULL) { |
| 144 | FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, oldTable[i]), ""); |
| 145 | } |
| 146 | } |
| 147 | ZSTD_customFree((void*)oldTable, customMem); |
| 148 | DEBUGLOG(4, "Finished re-hash"); |
| 149 | return 0; |
| 150 | } |
| 151 | |
| 152 | /* Fetches a DDict with the given dictID |
| 153 | * Returns the ZSTD_DDict* with the requested dictID. If it doesn't exist, then returns NULL. |
| 154 | */ |
| 155 | static const ZSTD_DDict* ZSTD_DDictHashSet_getDDict(ZSTD_DDictHashSet* hashSet, U32 dictID) { |
| 156 | size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID); |
| 157 | const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1; |
| 158 | DEBUGLOG(4, "Hashed index: for dictID: %u is %zu", dictID, idx); |
| 159 | for (;;) { |
| 160 | size_t currDictID = ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]); |
| 161 | if (currDictID == dictID || currDictID == 0) { |
| 162 | /* currDictID == 0 implies a NULL ddict entry */ |
| 163 | break; |
| 164 | } else { |
| 165 | idx &= idxRangeMask; /* Goes to start of table when we reach the end */ |
| 166 | idx++; |
| 167 | } |
| 168 | } |
| 169 | DEBUGLOG(4, "Final idx after probing for dictID %u is: %zu", dictID, idx); |
| 170 | return hashSet->ddictPtrTable[idx]; |
| 171 | } |
| 172 | |
| 173 | /* Allocates space for and returns a ddict hash set |
| 174 | * The hash set's ZSTD_DDict* table has all values automatically set to NULL to begin with. |
| 175 | * Returns NULL if allocation failed. |
| 176 | */ |
| 177 | static ZSTD_DDictHashSet* ZSTD_createDDictHashSet(ZSTD_customMem customMem) { |
| 178 | ZSTD_DDictHashSet* ret = (ZSTD_DDictHashSet*)ZSTD_customMalloc(sizeof(ZSTD_DDictHashSet), customMem); |
| 179 | DEBUGLOG(4, "Allocating new hash set"); |
| 180 | if (!ret) |
| 181 | return NULL; |
| 182 | ret->ddictPtrTable = (const ZSTD_DDict**)ZSTD_customCalloc(DDICT_HASHSET_TABLE_BASE_SIZE * sizeof(ZSTD_DDict*), customMem); |
| 183 | if (!ret->ddictPtrTable) { |
| 184 | ZSTD_customFree(ret, customMem); |
| 185 | return NULL; |
| 186 | } |
| 187 | ret->ddictPtrTableSize = DDICT_HASHSET_TABLE_BASE_SIZE; |
| 188 | ret->ddictPtrCount = 0; |
| 189 | return ret; |
| 190 | } |
| 191 | |
| 192 | /* Frees the table of ZSTD_DDict* within a hashset, then frees the hashset itself. |
| 193 | * Note: The ZSTD_DDict* within the table are NOT freed. |
| 194 | */ |
| 195 | static void ZSTD_freeDDictHashSet(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) { |
| 196 | DEBUGLOG(4, "Freeing ddict hash set"); |
| 197 | if (hashSet && hashSet->ddictPtrTable) { |
| 198 | ZSTD_customFree((void*)hashSet->ddictPtrTable, customMem); |
| 199 | } |
| 200 | if (hashSet) { |
| 201 | ZSTD_customFree(hashSet, customMem); |
| 202 | } |
| 203 | } |
| 204 | |
| 205 | /* Public function: Adds a DDict into the ZSTD_DDictHashSet, possibly triggering a resize of the hash set. |
| 206 | * Returns 0 on success, or a ZSTD error. |
| 207 | */ |
| 208 | static size_t ZSTD_DDictHashSet_addDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict, ZSTD_customMem customMem) { |
| 209 | DEBUGLOG(4, "Adding dict ID: %u to hashset with - Count: %zu Tablesize: %zu", ZSTD_getDictID_fromDDict(ddict), hashSet->ddictPtrCount, hashSet->ddictPtrTableSize); |
| 210 | if (hashSet->ddictPtrCount * DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT / hashSet->ddictPtrTableSize * DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT != 0) { |
| 211 | FORWARD_IF_ERROR(ZSTD_DDictHashSet_expand(hashSet, customMem), ""); |
| 212 | } |
| 213 | FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, ddict), ""); |
| 214 | return 0; |
| 215 | } |
| 216 | |
| 217 | /*-************************************************************* |
| 218 | * Context management |
| 219 | ***************************************************************/ |
| 220 | size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx) |
| 221 | { |
| 222 | if (dctx==NULL) return 0; /* support sizeof NULL */ |
| 223 | return sizeof(*dctx) |
| 224 | + ZSTD_sizeof_DDict(dctx->ddictLocal) |
| 225 | + dctx->inBuffSize + dctx->outBuffSize; |
| 226 | } |
| 227 | |
| 228 | size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); } |
| 229 | |
| 230 | |
| 231 | static size_t ZSTD_startingInputLength(ZSTD_format_e format) |
| 232 | { |
| 233 | size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format); |
| 234 | /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */ |
| 235 | assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) ); |
| 236 | return startingInputLength; |
| 237 | } |
| 238 | |
| 239 | static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx) |
| 240 | { |
| 241 | assert(dctx->streamStage == zdss_init); |
| 242 | dctx->format = ZSTD_f_zstd1; |
| 243 | dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT; |
| 244 | dctx->outBufferMode = ZSTD_bm_buffered; |
| 245 | dctx->forceIgnoreChecksum = ZSTD_d_validateChecksum; |
| 246 | dctx->refMultipleDDicts = ZSTD_rmd_refSingleDDict; |
| 247 | dctx->disableHufAsm = 0; |
| 248 | } |
| 249 | |
| 250 | static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx) |
| 251 | { |
| 252 | dctx->staticSize = 0; |
| 253 | dctx->ddict = NULL; |
| 254 | dctx->ddictLocal = NULL; |
| 255 | dctx->dictEnd = NULL; |
| 256 | dctx->ddictIsCold = 0; |
| 257 | dctx->dictUses = ZSTD_dont_use; |
| 258 | dctx->inBuff = NULL; |
| 259 | dctx->inBuffSize = 0; |
| 260 | dctx->outBuffSize = 0; |
| 261 | dctx->streamStage = zdss_init; |
| 262 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) |
| 263 | dctx->legacyContext = NULL; |
| 264 | dctx->previousLegacyVersion = 0; |
| 265 | #endif |
| 266 | dctx->noForwardProgress = 0; |
| 267 | dctx->oversizedDuration = 0; |
| 268 | #if DYNAMIC_BMI2 |
| 269 | dctx->bmi2 = ZSTD_cpuSupportsBmi2(); |
| 270 | #endif |
| 271 | dctx->ddictSet = NULL; |
| 272 | ZSTD_DCtx_resetParameters(dctx); |
| 273 | #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION |
| 274 | dctx->dictContentEndForFuzzing = NULL; |
| 275 | #endif |
| 276 | } |
| 277 | |
| 278 | ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize) |
| 279 | { |
| 280 | ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace; |
| 281 | |
| 282 | if ((size_t)workspace & 7) return NULL; /* 8-aligned */ |
| 283 | if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL; /* minimum size */ |
| 284 | |
| 285 | ZSTD_initDCtx_internal(dctx); |
| 286 | dctx->staticSize = workspaceSize; |
| 287 | dctx->inBuff = (char*)(dctx+1); |
| 288 | return dctx; |
| 289 | } |
| 290 | |
| 291 | static ZSTD_DCtx* ZSTD_createDCtx_internal(ZSTD_customMem customMem) { |
| 292 | if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL; |
| 293 | |
| 294 | { ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem); |
| 295 | if (!dctx) return NULL; |
| 296 | dctx->customMem = customMem; |
| 297 | ZSTD_initDCtx_internal(dctx); |
| 298 | return dctx; |
| 299 | } |
| 300 | } |
| 301 | |
| 302 | ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem) |
| 303 | { |
| 304 | return ZSTD_createDCtx_internal(customMem); |
| 305 | } |
| 306 | |
| 307 | ZSTD_DCtx* ZSTD_createDCtx(void) |
| 308 | { |
| 309 | DEBUGLOG(3, "ZSTD_createDCtx"); |
| 310 | return ZSTD_createDCtx_internal(ZSTD_defaultCMem); |
| 311 | } |
| 312 | |
| 313 | static void ZSTD_clearDict(ZSTD_DCtx* dctx) |
| 314 | { |
| 315 | ZSTD_freeDDict(dctx->ddictLocal); |
| 316 | dctx->ddictLocal = NULL; |
| 317 | dctx->ddict = NULL; |
| 318 | dctx->dictUses = ZSTD_dont_use; |
| 319 | } |
| 320 | |
| 321 | size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) |
| 322 | { |
| 323 | if (dctx==NULL) return 0; /* support free on NULL */ |
| 324 | RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx"); |
| 325 | { ZSTD_customMem const cMem = dctx->customMem; |
| 326 | ZSTD_clearDict(dctx); |
| 327 | ZSTD_customFree(dctx->inBuff, cMem); |
| 328 | dctx->inBuff = NULL; |
| 329 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) |
| 330 | if (dctx->legacyContext) |
| 331 | ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion); |
| 332 | #endif |
| 333 | if (dctx->ddictSet) { |
| 334 | ZSTD_freeDDictHashSet(dctx->ddictSet, cMem); |
| 335 | dctx->ddictSet = NULL; |
| 336 | } |
| 337 | ZSTD_customFree(dctx, cMem); |
| 338 | return 0; |
| 339 | } |
| 340 | } |
| 341 | |
| 342 | /* no longer useful */ |
| 343 | void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx) |
| 344 | { |
| 345 | size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx); |
| 346 | ZSTD_memcpy(dstDCtx, srcDCtx, toCopy); /* no need to copy workspace */ |
| 347 | } |
| 348 | |
| 349 | /* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on |
| 350 | * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then |
| 351 | * accordingly sets the ddict to be used to decompress the frame. |
| 352 | * |
| 353 | * If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is. |
| 354 | * |
| 355 | * ZSTD_d_refMultipleDDicts must be enabled for this function to be called. |
| 356 | */ |
| 357 | static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) { |
| 358 | assert(dctx->refMultipleDDicts && dctx->ddictSet); |
| 359 | DEBUGLOG(4, "Adjusting DDict based on requested dict ID from frame"); |
| 360 | if (dctx->ddict) { |
| 361 | const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(dctx->ddictSet, dctx->fParams.dictID); |
| 362 | if (frameDDict) { |
| 363 | DEBUGLOG(4, "DDict found!"); |
| 364 | ZSTD_clearDict(dctx); |
| 365 | dctx->dictID = dctx->fParams.dictID; |
| 366 | dctx->ddict = frameDDict; |
| 367 | dctx->dictUses = ZSTD_use_indefinitely; |
| 368 | } |
| 369 | } |
| 370 | } |
| 371 | |
| 372 | |
| 373 | /*-************************************************************* |
| 374 | * Frame header decoding |
| 375 | ***************************************************************/ |
| 376 | |
| 377 | /*! ZSTD_isFrame() : |
| 378 | * Tells if the content of `buffer` starts with a valid Frame Identifier. |
| 379 | * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. |
| 380 | * Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled. |
| 381 | * Note 3 : Skippable Frame Identifiers are considered valid. */ |
| 382 | unsigned ZSTD_isFrame(const void* buffer, size_t size) |
| 383 | { |
| 384 | if (size < ZSTD_FRAMEIDSIZE) return 0; |
| 385 | { U32 const magic = MEM_readLE32(buffer); |
| 386 | if (magic == ZSTD_MAGICNUMBER) return 1; |
| 387 | if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1; |
| 388 | } |
| 389 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) |
| 390 | if (ZSTD_isLegacy(buffer, size)) return 1; |
| 391 | #endif |
| 392 | return 0; |
| 393 | } |
| 394 | |
| 395 | /*! ZSTD_isSkippableFrame() : |
| 396 | * Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame. |
| 397 | * Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0. |
| 398 | */ |
| 399 | unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size) |
| 400 | { |
| 401 | if (size < ZSTD_FRAMEIDSIZE) return 0; |
| 402 | { U32 const magic = MEM_readLE32(buffer); |
| 403 | if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1; |
| 404 | } |
| 405 | return 0; |
| 406 | } |
| 407 | |
| 408 | /** ZSTD_frameHeaderSize_internal() : |
| 409 | * srcSize must be large enough to reach header size fields. |
| 410 | * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless. |
| 411 | * @return : size of the Frame Header |
| 412 | * or an error code, which can be tested with ZSTD_isError() */ |
| 413 | static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format) |
| 414 | { |
| 415 | size_t const minInputSize = ZSTD_startingInputLength(format); |
| 416 | RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, ""); |
| 417 | |
| 418 | { BYTE const fhd = ((const BYTE*)src)[minInputSize-1]; |
| 419 | U32 const dictID= fhd & 3; |
| 420 | U32 const singleSegment = (fhd >> 5) & 1; |
| 421 | U32 const fcsId = fhd >> 6; |
| 422 | return minInputSize + !singleSegment |
| 423 | + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId] |
| 424 | + (singleSegment && !fcsId); |
| 425 | } |
| 426 | } |
| 427 | |
| 428 | /** ZSTD_frameHeaderSize() : |
| 429 | * srcSize must be >= ZSTD_frameHeaderSize_prefix. |
| 430 | * @return : size of the Frame Header, |
| 431 | * or an error code (if srcSize is too small) */ |
| 432 | size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize) |
| 433 | { |
| 434 | return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1); |
| 435 | } |
| 436 | |
| 437 | |
| 438 | /** ZSTD_getFrameHeader_advanced() : |
| 439 | * decode Frame Header, or require larger `srcSize`. |
| 440 | * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless |
| 441 | * @return : 0, `zfhPtr` is correctly filled, |
| 442 | * >0, `srcSize` is too small, value is wanted `srcSize` amount, |
| 443 | ** or an error code, which can be tested using ZSTD_isError() */ |
| 444 | size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format) |
| 445 | { |
| 446 | const BYTE* ip = (const BYTE*)src; |
| 447 | size_t const minInputSize = ZSTD_startingInputLength(format); |
| 448 | |
| 449 | DEBUGLOG(5, "ZSTD_getFrameHeader_advanced: minInputSize = %zu, srcSize = %zu", minInputSize, srcSize); |
| 450 | |
| 451 | if (srcSize > 0) { |
| 452 | /* note : technically could be considered an assert(), since it's an invalid entry */ |
| 453 | RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter : src==NULL, but srcSize>0"); |
| 454 | } |
| 455 | if (srcSize < minInputSize) { |
| 456 | if (srcSize > 0 && format != ZSTD_f_zstd1_magicless) { |
| 457 | /* when receiving less than @minInputSize bytes, |
| 458 | * control these bytes at least correspond to a supported magic number |
| 459 | * in order to error out early if they don't. |
| 460 | **/ |
| 461 | size_t const toCopy = MIN(4, srcSize); |
| 462 | unsigned char hbuf[4]; MEM_writeLE32(hbuf, ZSTD_MAGICNUMBER); |
| 463 | assert(src != NULL); |
| 464 | ZSTD_memcpy(hbuf, src, toCopy); |
| 465 | if ( MEM_readLE32(hbuf) != ZSTD_MAGICNUMBER ) { |
| 466 | /* not a zstd frame : let's check if it's a skippable frame */ |
| 467 | MEM_writeLE32(hbuf, ZSTD_MAGIC_SKIPPABLE_START); |
| 468 | ZSTD_memcpy(hbuf, src, toCopy); |
| 469 | if ((MEM_readLE32(hbuf) & ZSTD_MAGIC_SKIPPABLE_MASK) != ZSTD_MAGIC_SKIPPABLE_START) { |
| 470 | RETURN_ERROR(prefix_unknown, |
| 471 | "first bytes don't correspond to any supported magic number"); |
| 472 | } } } |
| 473 | return minInputSize; |
| 474 | } |
| 475 | |
| 476 | ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr)); /* not strictly necessary, but static analyzers may not understand that zfhPtr will be read only if return value is zero, since they are 2 different signals */ |
| 477 | if ( (format != ZSTD_f_zstd1_magicless) |
| 478 | && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) { |
| 479 | if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { |
| 480 | /* skippable frame */ |
| 481 | if (srcSize < ZSTD_SKIPPABLEHEADERSIZE) |
| 482 | return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */ |
| 483 | ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr)); |
| 484 | zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE); |
| 485 | zfhPtr->frameType = ZSTD_skippableFrame; |
| 486 | return 0; |
| 487 | } |
| 488 | RETURN_ERROR(prefix_unknown, ""); |
| 489 | } |
| 490 | |
| 491 | /* ensure there is enough `srcSize` to fully read/decode frame header */ |
| 492 | { size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format); |
| 493 | if (srcSize < fhsize) return fhsize; |
| 494 | zfhPtr->headerSize = (U32)fhsize; |
| 495 | } |
| 496 | |
| 497 | { BYTE const fhdByte = ip[minInputSize-1]; |
| 498 | size_t pos = minInputSize; |
| 499 | U32 const dictIDSizeCode = fhdByte&3; |
| 500 | U32 const checksumFlag = (fhdByte>>2)&1; |
| 501 | U32 const singleSegment = (fhdByte>>5)&1; |
| 502 | U32 const fcsID = fhdByte>>6; |
| 503 | U64 windowSize = 0; |
| 504 | U32 dictID = 0; |
| 505 | U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN; |
| 506 | RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported, |
| 507 | "reserved bits, must be zero"); |
| 508 | |
| 509 | if (!singleSegment) { |
| 510 | BYTE const wlByte = ip[pos++]; |
| 511 | U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN; |
| 512 | RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, ""); |
| 513 | windowSize = (1ULL << windowLog); |
| 514 | windowSize += (windowSize >> 3) * (wlByte&7); |
| 515 | } |
| 516 | switch(dictIDSizeCode) |
| 517 | { |
| 518 | default: |
| 519 | assert(0); /* impossible */ |
| 520 | ZSTD_FALLTHROUGH; |
| 521 | case 0 : break; |
| 522 | case 1 : dictID = ip[pos]; pos++; break; |
| 523 | case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break; |
| 524 | case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break; |
| 525 | } |
| 526 | switch(fcsID) |
| 527 | { |
| 528 | default: |
| 529 | assert(0); /* impossible */ |
| 530 | ZSTD_FALLTHROUGH; |
| 531 | case 0 : if (singleSegment) frameContentSize = ip[pos]; break; |
| 532 | case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break; |
| 533 | case 2 : frameContentSize = MEM_readLE32(ip+pos); break; |
| 534 | case 3 : frameContentSize = MEM_readLE64(ip+pos); break; |
| 535 | } |
| 536 | if (singleSegment) windowSize = frameContentSize; |
| 537 | |
| 538 | zfhPtr->frameType = ZSTD_frame; |
| 539 | zfhPtr->frameContentSize = frameContentSize; |
| 540 | zfhPtr->windowSize = windowSize; |
| 541 | zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX); |
| 542 | zfhPtr->dictID = dictID; |
| 543 | zfhPtr->checksumFlag = checksumFlag; |
| 544 | } |
| 545 | return 0; |
| 546 | } |
| 547 | |
| 548 | /** ZSTD_getFrameHeader() : |
| 549 | * decode Frame Header, or require larger `srcSize`. |
| 550 | * note : this function does not consume input, it only reads it. |
| 551 | * @return : 0, `zfhPtr` is correctly filled, |
| 552 | * >0, `srcSize` is too small, value is wanted `srcSize` amount, |
| 553 | * or an error code, which can be tested using ZSTD_isError() */ |
| 554 | size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize) |
| 555 | { |
| 556 | return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1); |
| 557 | } |
| 558 | |
| 559 | /** ZSTD_getFrameContentSize() : |
| 560 | * compatible with legacy mode |
| 561 | * @return : decompressed size of the single frame pointed to be `src` if known, otherwise |
| 562 | * - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined |
| 563 | * - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */ |
| 564 | unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize) |
| 565 | { |
| 566 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) |
| 567 | if (ZSTD_isLegacy(src, srcSize)) { |
| 568 | unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize); |
| 569 | return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret; |
| 570 | } |
| 571 | #endif |
| 572 | { ZSTD_frameHeader zfh; |
| 573 | if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0) |
| 574 | return ZSTD_CONTENTSIZE_ERROR; |
| 575 | if (zfh.frameType == ZSTD_skippableFrame) { |
| 576 | return 0; |
| 577 | } else { |
| 578 | return zfh.frameContentSize; |
| 579 | } } |
| 580 | } |
| 581 | |
| 582 | static size_t readSkippableFrameSize(void const* src, size_t srcSize) |
| 583 | { |
| 584 | size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE; |
| 585 | U32 sizeU32; |
| 586 | |
| 587 | RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, ""); |
| 588 | |
| 589 | sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE); |
| 590 | RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32, |
| 591 | frameParameter_unsupported, ""); |
| 592 | { size_t const skippableSize = skippableHeaderSize + sizeU32; |
| 593 | RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, ""); |
| 594 | return skippableSize; |
| 595 | } |
| 596 | } |
| 597 | |
| 598 | /*! ZSTD_readSkippableFrame() : |
| 599 | * Retrieves content of a skippable frame, and writes it to dst buffer. |
| 600 | * |
| 601 | * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written, |
| 602 | * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START. This can be NULL if the caller is not interested |
| 603 | * in the magicVariant. |
| 604 | * |
| 605 | * Returns an error if destination buffer is not large enough, or if this is not a valid skippable frame. |
| 606 | * |
| 607 | * @return : number of bytes written or a ZSTD error. |
| 608 | */ |
| 609 | size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity, |
| 610 | unsigned* magicVariant, /* optional, can be NULL */ |
| 611 | const void* src, size_t srcSize) |
| 612 | { |
| 613 | RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, ""); |
| 614 | |
| 615 | { U32 const magicNumber = MEM_readLE32(src); |
| 616 | size_t skippableFrameSize = readSkippableFrameSize(src, srcSize); |
| 617 | size_t skippableContentSize = skippableFrameSize - ZSTD_SKIPPABLEHEADERSIZE; |
| 618 | |
| 619 | /* check input validity */ |
| 620 | RETURN_ERROR_IF(!ZSTD_isSkippableFrame(src, srcSize), frameParameter_unsupported, ""); |
| 621 | RETURN_ERROR_IF(skippableFrameSize < ZSTD_SKIPPABLEHEADERSIZE || skippableFrameSize > srcSize, srcSize_wrong, ""); |
| 622 | RETURN_ERROR_IF(skippableContentSize > dstCapacity, dstSize_tooSmall, ""); |
| 623 | |
| 624 | /* deliver payload */ |
| 625 | if (skippableContentSize > 0 && dst != NULL) |
| 626 | ZSTD_memcpy(dst, (const BYTE *)src + ZSTD_SKIPPABLEHEADERSIZE, skippableContentSize); |
| 627 | if (magicVariant != NULL) |
| 628 | *magicVariant = magicNumber - ZSTD_MAGIC_SKIPPABLE_START; |
| 629 | return skippableContentSize; |
| 630 | } |
| 631 | } |
| 632 | |
| 633 | /** ZSTD_findDecompressedSize() : |
| 634 | * `srcSize` must be the exact length of some number of ZSTD compressed and/or |
| 635 | * skippable frames |
| 636 | * note: compatible with legacy mode |
| 637 | * @return : decompressed size of the frames contained */ |
| 638 | unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize) |
| 639 | { |
| 640 | unsigned long long totalDstSize = 0; |
| 641 | |
| 642 | while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) { |
| 643 | U32 const magicNumber = MEM_readLE32(src); |
| 644 | |
| 645 | if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { |
| 646 | size_t const skippableSize = readSkippableFrameSize(src, srcSize); |
| 647 | if (ZSTD_isError(skippableSize)) return ZSTD_CONTENTSIZE_ERROR; |
| 648 | assert(skippableSize <= srcSize); |
| 649 | |
| 650 | src = (const BYTE *)src + skippableSize; |
| 651 | srcSize -= skippableSize; |
| 652 | continue; |
| 653 | } |
| 654 | |
| 655 | { unsigned long long const fcs = ZSTD_getFrameContentSize(src, srcSize); |
| 656 | if (fcs >= ZSTD_CONTENTSIZE_ERROR) return fcs; |
| 657 | |
| 658 | if (totalDstSize + fcs < totalDstSize) |
| 659 | return ZSTD_CONTENTSIZE_ERROR; /* check for overflow */ |
| 660 | totalDstSize += fcs; |
| 661 | } |
| 662 | /* skip to next frame */ |
| 663 | { size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize); |
| 664 | if (ZSTD_isError(frameSrcSize)) return ZSTD_CONTENTSIZE_ERROR; |
| 665 | assert(frameSrcSize <= srcSize); |
| 666 | |
| 667 | src = (const BYTE *)src + frameSrcSize; |
| 668 | srcSize -= frameSrcSize; |
| 669 | } |
| 670 | } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */ |
| 671 | |
| 672 | if (srcSize) return ZSTD_CONTENTSIZE_ERROR; |
| 673 | |
| 674 | return totalDstSize; |
| 675 | } |
| 676 | |
| 677 | /** ZSTD_getDecompressedSize() : |
| 678 | * compatible with legacy mode |
| 679 | * @return : decompressed size if known, 0 otherwise |
| 680 | note : 0 can mean any of the following : |
| 681 | - frame content is empty |
| 682 | - decompressed size field is not present in frame header |
| 683 | - frame header unknown / not supported |
| 684 | - frame header not complete (`srcSize` too small) */ |
| 685 | unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize) |
| 686 | { |
| 687 | unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize); |
| 688 | ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN); |
| 689 | return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret; |
| 690 | } |
| 691 | |
| 692 | |
| 693 | /** ZSTD_decodeFrameHeader() : |
| 694 | * `headerSize` must be the size provided by ZSTD_frameHeaderSize(). |
| 695 | * If multiple DDict references are enabled, also will choose the correct DDict to use. |
| 696 | * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */ |
| 697 | static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize) |
| 698 | { |
| 699 | size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format); |
| 700 | if (ZSTD_isError(result)) return result; /* invalid header */ |
| 701 | RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small"); |
| 702 | |
| 703 | /* Reference DDict requested by frame if dctx references multiple ddicts */ |
| 704 | if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) { |
| 705 | ZSTD_DCtx_selectFrameDDict(dctx); |
| 706 | } |
| 707 | |
| 708 | #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION |
| 709 | /* Skip the dictID check in fuzzing mode, because it makes the search |
| 710 | * harder. |
| 711 | */ |
| 712 | RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID), |
| 713 | dictionary_wrong, ""); |
| 714 | #endif |
| 715 | dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0; |
| 716 | if (dctx->validateChecksum) XXH64_reset(&dctx->xxhState, 0); |
| 717 | dctx->processedCSize += headerSize; |
| 718 | return 0; |
| 719 | } |
| 720 | |
| 721 | static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret) |
| 722 | { |
| 723 | ZSTD_frameSizeInfo frameSizeInfo; |
| 724 | frameSizeInfo.compressedSize = ret; |
| 725 | frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR; |
| 726 | return frameSizeInfo; |
| 727 | } |
| 728 | |
| 729 | static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize) |
| 730 | { |
| 731 | ZSTD_frameSizeInfo frameSizeInfo; |
| 732 | ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo)); |
| 733 | |
| 734 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) |
| 735 | if (ZSTD_isLegacy(src, srcSize)) |
| 736 | return ZSTD_findFrameSizeInfoLegacy(src, srcSize); |
| 737 | #endif |
| 738 | |
| 739 | if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE) |
| 740 | && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { |
| 741 | frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize); |
| 742 | assert(ZSTD_isError(frameSizeInfo.compressedSize) || |
| 743 | frameSizeInfo.compressedSize <= srcSize); |
| 744 | return frameSizeInfo; |
| 745 | } else { |
| 746 | const BYTE* ip = (const BYTE*)src; |
| 747 | const BYTE* const ipstart = ip; |
| 748 | size_t remainingSize = srcSize; |
| 749 | size_t nbBlocks = 0; |
| 750 | ZSTD_frameHeader zfh; |
| 751 | |
| 752 | /* Extract Frame Header */ |
| 753 | { size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize); |
| 754 | if (ZSTD_isError(ret)) |
| 755 | return ZSTD_errorFrameSizeInfo(ret); |
| 756 | if (ret > 0) |
| 757 | return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong)); |
| 758 | } |
| 759 | |
| 760 | ip += zfh.headerSize; |
| 761 | remainingSize -= zfh.headerSize; |
| 762 | |
| 763 | /* Iterate over each block */ |
| 764 | while (1) { |
| 765 | blockProperties_t blockProperties; |
| 766 | size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties); |
| 767 | if (ZSTD_isError(cBlockSize)) |
| 768 | return ZSTD_errorFrameSizeInfo(cBlockSize); |
| 769 | |
| 770 | if (ZSTD_blockHeaderSize + cBlockSize > remainingSize) |
| 771 | return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong)); |
| 772 | |
| 773 | ip += ZSTD_blockHeaderSize + cBlockSize; |
| 774 | remainingSize -= ZSTD_blockHeaderSize + cBlockSize; |
| 775 | nbBlocks++; |
| 776 | |
| 777 | if (blockProperties.lastBlock) break; |
| 778 | } |
| 779 | |
| 780 | /* Final frame content checksum */ |
| 781 | if (zfh.checksumFlag) { |
| 782 | if (remainingSize < 4) |
| 783 | return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong)); |
| 784 | ip += 4; |
| 785 | } |
| 786 | |
| 787 | frameSizeInfo.nbBlocks = nbBlocks; |
| 788 | frameSizeInfo.compressedSize = (size_t)(ip - ipstart); |
| 789 | frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) |
| 790 | ? zfh.frameContentSize |
| 791 | : (unsigned long long)nbBlocks * zfh.blockSizeMax; |
| 792 | return frameSizeInfo; |
| 793 | } |
| 794 | } |
| 795 | |
| 796 | /** ZSTD_findFrameCompressedSize() : |
| 797 | * compatible with legacy mode |
| 798 | * `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame |
| 799 | * `srcSize` must be at least as large as the frame contained |
| 800 | * @return : the compressed size of the frame starting at `src` */ |
| 801 | size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize) |
| 802 | { |
| 803 | ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize); |
| 804 | return frameSizeInfo.compressedSize; |
| 805 | } |
| 806 | |
| 807 | /** ZSTD_decompressBound() : |
| 808 | * compatible with legacy mode |
| 809 | * `src` must point to the start of a ZSTD frame or a skippeable frame |
| 810 | * `srcSize` must be at least as large as the frame contained |
| 811 | * @return : the maximum decompressed size of the compressed source |
| 812 | */ |
| 813 | unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize) |
| 814 | { |
| 815 | unsigned long long bound = 0; |
| 816 | /* Iterate over each frame */ |
| 817 | while (srcSize > 0) { |
| 818 | ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize); |
| 819 | size_t const compressedSize = frameSizeInfo.compressedSize; |
| 820 | unsigned long long const decompressedBound = frameSizeInfo.decompressedBound; |
| 821 | if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR) |
| 822 | return ZSTD_CONTENTSIZE_ERROR; |
| 823 | assert(srcSize >= compressedSize); |
| 824 | src = (const BYTE*)src + compressedSize; |
| 825 | srcSize -= compressedSize; |
| 826 | bound += decompressedBound; |
| 827 | } |
| 828 | return bound; |
| 829 | } |
| 830 | |
| 831 | size_t ZSTD_decompressionMargin(void const* src, size_t srcSize) |
| 832 | { |
| 833 | size_t margin = 0; |
| 834 | unsigned maxBlockSize = 0; |
| 835 | |
| 836 | /* Iterate over each frame */ |
| 837 | while (srcSize > 0) { |
| 838 | ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize); |
| 839 | size_t const compressedSize = frameSizeInfo.compressedSize; |
| 840 | unsigned long long const decompressedBound = frameSizeInfo.decompressedBound; |
| 841 | ZSTD_frameHeader zfh; |
| 842 | |
| 843 | FORWARD_IF_ERROR(ZSTD_getFrameHeader(&zfh, src, srcSize), ""); |
| 844 | if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR) |
| 845 | return ERROR(corruption_detected); |
| 846 | |
| 847 | if (zfh.frameType == ZSTD_frame) { |
| 848 | /* Add the frame header to our margin */ |
| 849 | margin += zfh.headerSize; |
| 850 | /* Add the checksum to our margin */ |
| 851 | margin += zfh.checksumFlag ? 4 : 0; |
| 852 | /* Add 3 bytes per block */ |
| 853 | margin += 3 * frameSizeInfo.nbBlocks; |
| 854 | |
| 855 | /* Compute the max block size */ |
| 856 | maxBlockSize = MAX(maxBlockSize, zfh.blockSizeMax); |
| 857 | } else { |
| 858 | assert(zfh.frameType == ZSTD_skippableFrame); |
| 859 | /* Add the entire skippable frame size to our margin. */ |
| 860 | margin += compressedSize; |
| 861 | } |
| 862 | |
| 863 | assert(srcSize >= compressedSize); |
| 864 | src = (const BYTE*)src + compressedSize; |
| 865 | srcSize -= compressedSize; |
| 866 | } |
| 867 | |
| 868 | /* Add the max block size back to the margin. */ |
| 869 | margin += maxBlockSize; |
| 870 | |
| 871 | return margin; |
| 872 | } |
| 873 | |
| 874 | /*-************************************************************* |
| 875 | * Frame decoding |
| 876 | ***************************************************************/ |
| 877 | |
| 878 | /** ZSTD_insertBlock() : |
| 879 | * insert `src` block into `dctx` history. Useful to track uncompressed blocks. */ |
| 880 | size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize) |
| 881 | { |
| 882 | DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize); |
| 883 | ZSTD_checkContinuity(dctx, blockStart, blockSize); |
| 884 | dctx->previousDstEnd = (const char*)blockStart + blockSize; |
| 885 | return blockSize; |
| 886 | } |
| 887 | |
| 888 | |
| 889 | static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity, |
| 890 | const void* src, size_t srcSize) |
| 891 | { |
| 892 | DEBUGLOG(5, "ZSTD_copyRawBlock"); |
| 893 | RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, ""); |
| 894 | if (dst == NULL) { |
| 895 | if (srcSize == 0) return 0; |
| 896 | RETURN_ERROR(dstBuffer_null, ""); |
| 897 | } |
| 898 | ZSTD_memmove(dst, src, srcSize); |
| 899 | return srcSize; |
| 900 | } |
| 901 | |
| 902 | static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity, |
| 903 | BYTE b, |
| 904 | size_t regenSize) |
| 905 | { |
| 906 | RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, ""); |
| 907 | if (dst == NULL) { |
| 908 | if (regenSize == 0) return 0; |
| 909 | RETURN_ERROR(dstBuffer_null, ""); |
| 910 | } |
| 911 | ZSTD_memset(dst, b, regenSize); |
| 912 | return regenSize; |
| 913 | } |
| 914 | |
| 915 | static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming) |
| 916 | { |
| 917 | #if ZSTD_TRACE |
| 918 | if (dctx->traceCtx && ZSTD_trace_decompress_end != NULL) { |
| 919 | ZSTD_Trace trace; |
| 920 | ZSTD_memset(&trace, 0, sizeof(trace)); |
| 921 | trace.version = ZSTD_VERSION_NUMBER; |
| 922 | trace.streaming = streaming; |
| 923 | if (dctx->ddict) { |
| 924 | trace.dictionaryID = ZSTD_getDictID_fromDDict(dctx->ddict); |
| 925 | trace.dictionarySize = ZSTD_DDict_dictSize(dctx->ddict); |
| 926 | trace.dictionaryIsCold = dctx->ddictIsCold; |
| 927 | } |
| 928 | trace.uncompressedSize = (size_t)uncompressedSize; |
| 929 | trace.compressedSize = (size_t)compressedSize; |
| 930 | trace.dctx = dctx; |
| 931 | ZSTD_trace_decompress_end(dctx->traceCtx, &trace); |
| 932 | } |
| 933 | #else |
| 934 | (void)dctx; |
| 935 | (void)uncompressedSize; |
| 936 | (void)compressedSize; |
| 937 | (void)streaming; |
| 938 | #endif |
| 939 | } |
| 940 | |
| 941 | |
| 942 | /*! ZSTD_decompressFrame() : |
| 943 | * @dctx must be properly initialized |
| 944 | * will update *srcPtr and *srcSizePtr, |
| 945 | * to make *srcPtr progress by one frame. */ |
| 946 | static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx, |
| 947 | void* dst, size_t dstCapacity, |
| 948 | const void** srcPtr, size_t *srcSizePtr) |
| 949 | { |
| 950 | const BYTE* const istart = (const BYTE*)(*srcPtr); |
| 951 | const BYTE* ip = istart; |
| 952 | BYTE* const ostart = (BYTE*)dst; |
| 953 | BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart; |
| 954 | BYTE* op = ostart; |
| 955 | size_t remainingSrcSize = *srcSizePtr; |
| 956 | |
| 957 | DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr); |
| 958 | |
| 959 | /* check */ |
| 960 | RETURN_ERROR_IF( |
| 961 | remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize, |
| 962 | srcSize_wrong, ""); |
| 963 | |
| 964 | /* Frame Header */ |
| 965 | { size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal( |
| 966 | ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format); |
| 967 | if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; |
| 968 | RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize, |
| 969 | srcSize_wrong, ""); |
| 970 | FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , ""); |
| 971 | ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize; |
| 972 | } |
| 973 | |
| 974 | /* Loop on each block */ |
| 975 | while (1) { |
| 976 | BYTE* oBlockEnd = oend; |
| 977 | size_t decodedSize; |
| 978 | blockProperties_t blockProperties; |
| 979 | size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties); |
| 980 | if (ZSTD_isError(cBlockSize)) return cBlockSize; |
| 981 | |
| 982 | ip += ZSTD_blockHeaderSize; |
| 983 | remainingSrcSize -= ZSTD_blockHeaderSize; |
| 984 | RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, ""); |
| 985 | |
| 986 | if (ip >= op && ip < oBlockEnd) { |
| 987 | /* We are decompressing in-place. Limit the output pointer so that we |
| 988 | * don't overwrite the block that we are currently reading. This will |
| 989 | * fail decompression if the input & output pointers aren't spaced |
| 990 | * far enough apart. |
| 991 | * |
| 992 | * This is important to set, even when the pointers are far enough |
| 993 | * apart, because ZSTD_decompressBlock_internal() can decide to store |
| 994 | * literals in the output buffer, after the block it is decompressing. |
| 995 | * Since we don't want anything to overwrite our input, we have to tell |
| 996 | * ZSTD_decompressBlock_internal to never write past ip. |
| 997 | * |
| 998 | * See ZSTD_allocateLiteralsBuffer() for reference. |
| 999 | */ |
| 1000 | oBlockEnd = op + (ip - op); |
| 1001 | } |
| 1002 | |
| 1003 | switch(blockProperties.blockType) |
| 1004 | { |
| 1005 | case bt_compressed: |
| 1006 | decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oBlockEnd-op), ip, cBlockSize, /* frame */ 1, not_streaming); |
| 1007 | break; |
| 1008 | case bt_raw : |
| 1009 | /* Use oend instead of oBlockEnd because this function is safe to overlap. It uses memmove. */ |
| 1010 | decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize); |
| 1011 | break; |
| 1012 | case bt_rle : |
| 1013 | decodedSize = ZSTD_setRleBlock(op, (size_t)(oBlockEnd-op), *ip, blockProperties.origSize); |
| 1014 | break; |
| 1015 | case bt_reserved : |
| 1016 | default: |
| 1017 | RETURN_ERROR(corruption_detected, "invalid block type"); |
| 1018 | } |
| 1019 | |
| 1020 | if (ZSTD_isError(decodedSize)) return decodedSize; |
| 1021 | if (dctx->validateChecksum) |
| 1022 | XXH64_update(&dctx->xxhState, op, decodedSize); |
| 1023 | if (decodedSize != 0) |
| 1024 | op += decodedSize; |
| 1025 | assert(ip != NULL); |
| 1026 | ip += cBlockSize; |
| 1027 | remainingSrcSize -= cBlockSize; |
| 1028 | if (blockProperties.lastBlock) break; |
| 1029 | } |
| 1030 | |
| 1031 | if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) { |
| 1032 | RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize, |
| 1033 | corruption_detected, ""); |
| 1034 | } |
| 1035 | if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */ |
| 1036 | RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, ""); |
| 1037 | if (!dctx->forceIgnoreChecksum) { |
| 1038 | U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState); |
| 1039 | U32 checkRead; |
| 1040 | checkRead = MEM_readLE32(ip); |
| 1041 | RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, ""); |
| 1042 | } |
| 1043 | ip += 4; |
| 1044 | remainingSrcSize -= 4; |
| 1045 | } |
| 1046 | ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0); |
| 1047 | /* Allow caller to get size read */ |
| 1048 | DEBUGLOG(4, "ZSTD_decompressFrame: decompressed frame of size %zi, consuming %zi bytes of input", op-ostart, ip - (const BYTE*)*srcPtr); |
| 1049 | *srcPtr = ip; |
| 1050 | *srcSizePtr = remainingSrcSize; |
| 1051 | return (size_t)(op-ostart); |
| 1052 | } |
| 1053 | |
| 1054 | static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx, |
| 1055 | void* dst, size_t dstCapacity, |
| 1056 | const void* src, size_t srcSize, |
| 1057 | const void* dict, size_t dictSize, |
| 1058 | const ZSTD_DDict* ddict) |
| 1059 | { |
| 1060 | void* const dststart = dst; |
| 1061 | int moreThan1Frame = 0; |
| 1062 | |
| 1063 | DEBUGLOG(5, "ZSTD_decompressMultiFrame"); |
| 1064 | assert(dict==NULL || ddict==NULL); /* either dict or ddict set, not both */ |
| 1065 | |
| 1066 | if (ddict) { |
| 1067 | dict = ZSTD_DDict_dictContent(ddict); |
| 1068 | dictSize = ZSTD_DDict_dictSize(ddict); |
| 1069 | } |
| 1070 | |
| 1071 | while (srcSize >= ZSTD_startingInputLength(dctx->format)) { |
| 1072 | |
| 1073 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) |
| 1074 | if (ZSTD_isLegacy(src, srcSize)) { |
| 1075 | size_t decodedSize; |
| 1076 | size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize); |
| 1077 | if (ZSTD_isError(frameSize)) return frameSize; |
| 1078 | RETURN_ERROR_IF(dctx->staticSize, memory_allocation, |
| 1079 | "legacy support is not compatible with static dctx"); |
| 1080 | |
| 1081 | decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize); |
| 1082 | if (ZSTD_isError(decodedSize)) return decodedSize; |
| 1083 | |
| 1084 | assert(decodedSize <= dstCapacity); |
| 1085 | dst = (BYTE*)dst + decodedSize; |
| 1086 | dstCapacity -= decodedSize; |
| 1087 | |
| 1088 | src = (const BYTE*)src + frameSize; |
| 1089 | srcSize -= frameSize; |
| 1090 | |
| 1091 | continue; |
| 1092 | } |
| 1093 | #endif |
| 1094 | |
| 1095 | if (srcSize >= 4) { |
| 1096 | U32 const magicNumber = MEM_readLE32(src); |
| 1097 | DEBUGLOG(5, "reading magic number %08X", (unsigned)magicNumber); |
| 1098 | if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { |
| 1099 | /* skippable frame detected : skip it */ |
| 1100 | size_t const skippableSize = readSkippableFrameSize(src, srcSize); |
| 1101 | FORWARD_IF_ERROR(skippableSize, "invalid skippable frame"); |
| 1102 | assert(skippableSize <= srcSize); |
| 1103 | |
| 1104 | src = (const BYTE *)src + skippableSize; |
| 1105 | srcSize -= skippableSize; |
| 1106 | continue; /* check next frame */ |
| 1107 | } } |
| 1108 | |
| 1109 | if (ddict) { |
| 1110 | /* we were called from ZSTD_decompress_usingDDict */ |
| 1111 | FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), ""); |
| 1112 | } else { |
| 1113 | /* this will initialize correctly with no dict if dict == NULL, so |
| 1114 | * use this in all cases but ddict */ |
| 1115 | FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), ""); |
| 1116 | } |
| 1117 | ZSTD_checkContinuity(dctx, dst, dstCapacity); |
| 1118 | |
| 1119 | { const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity, |
| 1120 | &src, &srcSize); |
| 1121 | RETURN_ERROR_IF( |
| 1122 | (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown) |
| 1123 | && (moreThan1Frame==1), |
| 1124 | srcSize_wrong, |
| 1125 | "At least one frame successfully completed, " |
| 1126 | "but following bytes are garbage: " |
| 1127 | "it's more likely to be a srcSize error, " |
| 1128 | "specifying more input bytes than size of frame(s). " |
| 1129 | "Note: one could be unlucky, it might be a corruption error instead, " |
| 1130 | "happening right at the place where we expect zstd magic bytes. " |
| 1131 | "But this is _much_ less likely than a srcSize field error."); |
| 1132 | if (ZSTD_isError(res)) return res; |
| 1133 | assert(res <= dstCapacity); |
| 1134 | if (res != 0) |
| 1135 | dst = (BYTE*)dst + res; |
| 1136 | dstCapacity -= res; |
| 1137 | } |
| 1138 | moreThan1Frame = 1; |
| 1139 | } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */ |
| 1140 | |
| 1141 | RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed"); |
| 1142 | |
| 1143 | return (size_t)((BYTE*)dst - (BYTE*)dststart); |
| 1144 | } |
| 1145 | |
| 1146 | size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx, |
| 1147 | void* dst, size_t dstCapacity, |
| 1148 | const void* src, size_t srcSize, |
| 1149 | const void* dict, size_t dictSize) |
| 1150 | { |
| 1151 | return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL); |
| 1152 | } |
| 1153 | |
| 1154 | |
| 1155 | static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx) |
| 1156 | { |
| 1157 | switch (dctx->dictUses) { |
| 1158 | default: |
| 1159 | assert(0 /* Impossible */); |
| 1160 | ZSTD_FALLTHROUGH; |
| 1161 | case ZSTD_dont_use: |
| 1162 | ZSTD_clearDict(dctx); |
| 1163 | return NULL; |
| 1164 | case ZSTD_use_indefinitely: |
| 1165 | return dctx->ddict; |
| 1166 | case ZSTD_use_once: |
| 1167 | dctx->dictUses = ZSTD_dont_use; |
| 1168 | return dctx->ddict; |
| 1169 | } |
| 1170 | } |
| 1171 | |
| 1172 | size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) |
| 1173 | { |
| 1174 | return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx)); |
| 1175 | } |
| 1176 | |
| 1177 | |
| 1178 | size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) |
| 1179 | { |
| 1180 | #if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1) |
| 1181 | size_t regenSize; |
| 1182 | ZSTD_DCtx* const dctx = ZSTD_createDCtx_internal(ZSTD_defaultCMem); |
| 1183 | RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!"); |
| 1184 | regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); |
| 1185 | ZSTD_freeDCtx(dctx); |
| 1186 | return regenSize; |
| 1187 | #else /* stack mode */ |
| 1188 | ZSTD_DCtx dctx; |
| 1189 | ZSTD_initDCtx_internal(&dctx); |
| 1190 | return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); |
| 1191 | #endif |
| 1192 | } |
| 1193 | |
| 1194 | |
| 1195 | /*-************************************** |
| 1196 | * Advanced Streaming Decompression API |
| 1197 | * Bufferless and synchronous |
| 1198 | ****************************************/ |
| 1199 | size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; } |
| 1200 | |
| 1201 | /** |
| 1202 | * Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed, we |
| 1203 | * allow taking a partial block as the input. Currently only raw uncompressed blocks can |
| 1204 | * be streamed. |
| 1205 | * |
| 1206 | * For blocks that can be streamed, this allows us to reduce the latency until we produce |
| 1207 | * output, and avoid copying the input. |
| 1208 | * |
| 1209 | * @param inputSize - The total amount of input that the caller currently has. |
| 1210 | */ |
| 1211 | static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) { |
| 1212 | if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock)) |
| 1213 | return dctx->expected; |
| 1214 | if (dctx->bType != bt_raw) |
| 1215 | return dctx->expected; |
| 1216 | return BOUNDED(1, inputSize, dctx->expected); |
| 1217 | } |
| 1218 | |
| 1219 | ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) { |
| 1220 | switch(dctx->stage) |
| 1221 | { |
| 1222 | default: /* should not happen */ |
| 1223 | assert(0); |
| 1224 | ZSTD_FALLTHROUGH; |
| 1225 | case ZSTDds_getFrameHeaderSize: |
| 1226 | ZSTD_FALLTHROUGH; |
| 1227 | case ZSTDds_decodeFrameHeader: |
| 1228 | return ZSTDnit_frameHeader; |
| 1229 | case ZSTDds_decodeBlockHeader: |
| 1230 | return ZSTDnit_blockHeader; |
| 1231 | case ZSTDds_decompressBlock: |
| 1232 | return ZSTDnit_block; |
| 1233 | case ZSTDds_decompressLastBlock: |
| 1234 | return ZSTDnit_lastBlock; |
| 1235 | case ZSTDds_checkChecksum: |
| 1236 | return ZSTDnit_checksum; |
| 1237 | case ZSTDds_decodeSkippableHeader: |
| 1238 | ZSTD_FALLTHROUGH; |
| 1239 | case ZSTDds_skipFrame: |
| 1240 | return ZSTDnit_skippableFrame; |
| 1241 | } |
| 1242 | } |
| 1243 | |
| 1244 | static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; } |
| 1245 | |
| 1246 | /** ZSTD_decompressContinue() : |
| 1247 | * srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress()) |
| 1248 | * @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity) |
| 1249 | * or an error code, which can be tested using ZSTD_isError() */ |
| 1250 | size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) |
| 1251 | { |
| 1252 | DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize); |
| 1253 | /* Sanity check */ |
| 1254 | RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed"); |
| 1255 | ZSTD_checkContinuity(dctx, dst, dstCapacity); |
| 1256 | |
| 1257 | dctx->processedCSize += srcSize; |
| 1258 | |
| 1259 | switch (dctx->stage) |
| 1260 | { |
| 1261 | case ZSTDds_getFrameHeaderSize : |
| 1262 | assert(src != NULL); |
| 1263 | if (dctx->format == ZSTD_f_zstd1) { /* allows header */ |
| 1264 | assert(srcSize >= ZSTD_FRAMEIDSIZE); /* to read skippable magic number */ |
| 1265 | if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ |
| 1266 | ZSTD_memcpy(dctx->headerBuffer, src, srcSize); |
| 1267 | dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize; /* remaining to load to get full skippable frame header */ |
| 1268 | dctx->stage = ZSTDds_decodeSkippableHeader; |
| 1269 | return 0; |
| 1270 | } } |
| 1271 | dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format); |
| 1272 | if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize; |
| 1273 | ZSTD_memcpy(dctx->headerBuffer, src, srcSize); |
| 1274 | dctx->expected = dctx->headerSize - srcSize; |
| 1275 | dctx->stage = ZSTDds_decodeFrameHeader; |
| 1276 | return 0; |
| 1277 | |
| 1278 | case ZSTDds_decodeFrameHeader: |
| 1279 | assert(src != NULL); |
| 1280 | ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize); |
| 1281 | FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), ""); |
| 1282 | dctx->expected = ZSTD_blockHeaderSize; |
| 1283 | dctx->stage = ZSTDds_decodeBlockHeader; |
| 1284 | return 0; |
| 1285 | |
| 1286 | case ZSTDds_decodeBlockHeader: |
| 1287 | { blockProperties_t bp; |
| 1288 | size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); |
| 1289 | if (ZSTD_isError(cBlockSize)) return cBlockSize; |
| 1290 | RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum"); |
| 1291 | dctx->expected = cBlockSize; |
| 1292 | dctx->bType = bp.blockType; |
| 1293 | dctx->rleSize = bp.origSize; |
| 1294 | if (cBlockSize) { |
| 1295 | dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock; |
| 1296 | return 0; |
| 1297 | } |
| 1298 | /* empty block */ |
| 1299 | if (bp.lastBlock) { |
| 1300 | if (dctx->fParams.checksumFlag) { |
| 1301 | dctx->expected = 4; |
| 1302 | dctx->stage = ZSTDds_checkChecksum; |
| 1303 | } else { |
| 1304 | dctx->expected = 0; /* end of frame */ |
| 1305 | dctx->stage = ZSTDds_getFrameHeaderSize; |
| 1306 | } |
| 1307 | } else { |
| 1308 | dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */ |
| 1309 | dctx->stage = ZSTDds_decodeBlockHeader; |
| 1310 | } |
| 1311 | return 0; |
| 1312 | } |
| 1313 | |
| 1314 | case ZSTDds_decompressLastBlock: |
| 1315 | case ZSTDds_decompressBlock: |
| 1316 | DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock"); |
| 1317 | { size_t rSize; |
| 1318 | switch(dctx->bType) |
| 1319 | { |
| 1320 | case bt_compressed: |
| 1321 | DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed"); |
| 1322 | rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1, is_streaming); |
| 1323 | dctx->expected = 0; /* Streaming not supported */ |
| 1324 | break; |
| 1325 | case bt_raw : |
| 1326 | assert(srcSize <= dctx->expected); |
| 1327 | rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize); |
| 1328 | FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed"); |
| 1329 | assert(rSize == srcSize); |
| 1330 | dctx->expected -= rSize; |
| 1331 | break; |
| 1332 | case bt_rle : |
| 1333 | rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize); |
| 1334 | dctx->expected = 0; /* Streaming not supported */ |
| 1335 | break; |
| 1336 | case bt_reserved : /* should never happen */ |
| 1337 | default: |
| 1338 | RETURN_ERROR(corruption_detected, "invalid block type"); |
| 1339 | } |
| 1340 | FORWARD_IF_ERROR(rSize, ""); |
| 1341 | RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum"); |
| 1342 | DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize); |
| 1343 | dctx->decodedSize += rSize; |
| 1344 | if (dctx->validateChecksum) XXH64_update(&dctx->xxhState, dst, rSize); |
| 1345 | dctx->previousDstEnd = (char*)dst + rSize; |
| 1346 | |
| 1347 | /* Stay on the same stage until we are finished streaming the block. */ |
| 1348 | if (dctx->expected > 0) { |
| 1349 | return rSize; |
| 1350 | } |
| 1351 | |
| 1352 | if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */ |
| 1353 | DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize); |
| 1354 | RETURN_ERROR_IF( |
| 1355 | dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN |
| 1356 | && dctx->decodedSize != dctx->fParams.frameContentSize, |
| 1357 | corruption_detected, ""); |
| 1358 | if (dctx->fParams.checksumFlag) { /* another round for frame checksum */ |
| 1359 | dctx->expected = 4; |
| 1360 | dctx->stage = ZSTDds_checkChecksum; |
| 1361 | } else { |
| 1362 | ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1); |
| 1363 | dctx->expected = 0; /* ends here */ |
| 1364 | dctx->stage = ZSTDds_getFrameHeaderSize; |
| 1365 | } |
| 1366 | } else { |
| 1367 | dctx->stage = ZSTDds_decodeBlockHeader; |
| 1368 | dctx->expected = ZSTD_blockHeaderSize; |
| 1369 | } |
| 1370 | return rSize; |
| 1371 | } |
| 1372 | |
| 1373 | case ZSTDds_checkChecksum: |
| 1374 | assert(srcSize == 4); /* guaranteed by dctx->expected */ |
| 1375 | { |
| 1376 | if (dctx->validateChecksum) { |
| 1377 | U32 const h32 = (U32)XXH64_digest(&dctx->xxhState); |
| 1378 | U32 const check32 = MEM_readLE32(src); |
| 1379 | DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32); |
| 1380 | RETURN_ERROR_IF(check32 != h32, checksum_wrong, ""); |
| 1381 | } |
| 1382 | ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1); |
| 1383 | dctx->expected = 0; |
| 1384 | dctx->stage = ZSTDds_getFrameHeaderSize; |
| 1385 | return 0; |
| 1386 | } |
| 1387 | |
| 1388 | case ZSTDds_decodeSkippableHeader: |
| 1389 | assert(src != NULL); |
| 1390 | assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE); |
| 1391 | ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complete skippable header */ |
| 1392 | dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */ |
| 1393 | dctx->stage = ZSTDds_skipFrame; |
| 1394 | return 0; |
| 1395 | |
| 1396 | case ZSTDds_skipFrame: |
| 1397 | dctx->expected = 0; |
| 1398 | dctx->stage = ZSTDds_getFrameHeaderSize; |
| 1399 | return 0; |
| 1400 | |
| 1401 | default: |
| 1402 | assert(0); /* impossible */ |
| 1403 | RETURN_ERROR(GENERIC, "impossible to reach"); /* some compilers require default to do something */ |
| 1404 | } |
| 1405 | } |
| 1406 | |
| 1407 | |
| 1408 | static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) |
| 1409 | { |
| 1410 | dctx->dictEnd = dctx->previousDstEnd; |
| 1411 | dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); |
| 1412 | dctx->prefixStart = dict; |
| 1413 | dctx->previousDstEnd = (const char*)dict + dictSize; |
| 1414 | #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION |
| 1415 | dctx->dictContentBeginForFuzzing = dctx->prefixStart; |
| 1416 | dctx->dictContentEndForFuzzing = dctx->previousDstEnd; |
| 1417 | #endif |
| 1418 | return 0; |
| 1419 | } |
| 1420 | |
| 1421 | /*! ZSTD_loadDEntropy() : |
| 1422 | * dict : must point at beginning of a valid zstd dictionary. |
| 1423 | * @return : size of entropy tables read */ |
| 1424 | size_t |
| 1425 | ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy, |
| 1426 | const void* const dict, size_t const dictSize) |
| 1427 | { |
| 1428 | const BYTE* dictPtr = (const BYTE*)dict; |
| 1429 | const BYTE* const dictEnd = dictPtr + dictSize; |
| 1430 | |
| 1431 | RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small"); |
| 1432 | assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY); /* dict must be valid */ |
| 1433 | dictPtr += 8; /* skip header = magic + dictID */ |
| 1434 | |
| 1435 | ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable)); |
| 1436 | ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable)); |
| 1437 | ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE); |
| 1438 | { void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies fse tables are grouped together */ |
| 1439 | size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable); |
| 1440 | #ifdef HUF_FORCE_DECOMPRESS_X1 |
| 1441 | /* in minimal huffman, we always use X1 variants */ |
| 1442 | size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable, |
| 1443 | dictPtr, dictEnd - dictPtr, |
| 1444 | workspace, workspaceSize, /* flags */ 0); |
| 1445 | #else |
| 1446 | size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable, |
| 1447 | dictPtr, (size_t)(dictEnd - dictPtr), |
| 1448 | workspace, workspaceSize, /* flags */ 0); |
| 1449 | #endif |
| 1450 | RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, ""); |
| 1451 | dictPtr += hSize; |
| 1452 | } |
| 1453 | |
| 1454 | { short offcodeNCount[MaxOff+1]; |
| 1455 | unsigned offcodeMaxValue = MaxOff, offcodeLog; |
| 1456 | size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr)); |
| 1457 | RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, ""); |
| 1458 | RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, ""); |
| 1459 | RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, ""); |
| 1460 | ZSTD_buildFSETable( entropy->OFTable, |
| 1461 | offcodeNCount, offcodeMaxValue, |
| 1462 | OF_base, OF_bits, |
| 1463 | offcodeLog, |
| 1464 | entropy->workspace, sizeof(entropy->workspace), |
| 1465 | /* bmi2 */0); |
| 1466 | dictPtr += offcodeHeaderSize; |
| 1467 | } |
| 1468 | |
| 1469 | { short matchlengthNCount[MaxML+1]; |
| 1470 | unsigned matchlengthMaxValue = MaxML, matchlengthLog; |
| 1471 | size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr)); |
| 1472 | RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, ""); |
| 1473 | RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, ""); |
| 1474 | RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, ""); |
| 1475 | ZSTD_buildFSETable( entropy->MLTable, |
| 1476 | matchlengthNCount, matchlengthMaxValue, |
| 1477 | ML_base, ML_bits, |
| 1478 | matchlengthLog, |
| 1479 | entropy->workspace, sizeof(entropy->workspace), |
| 1480 | /* bmi2 */ 0); |
| 1481 | dictPtr += matchlengthHeaderSize; |
| 1482 | } |
| 1483 | |
| 1484 | { short litlengthNCount[MaxLL+1]; |
| 1485 | unsigned litlengthMaxValue = MaxLL, litlengthLog; |
| 1486 | size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr)); |
| 1487 | RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, ""); |
| 1488 | RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, ""); |
| 1489 | RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, ""); |
| 1490 | ZSTD_buildFSETable( entropy->LLTable, |
| 1491 | litlengthNCount, litlengthMaxValue, |
| 1492 | LL_base, LL_bits, |
| 1493 | litlengthLog, |
| 1494 | entropy->workspace, sizeof(entropy->workspace), |
| 1495 | /* bmi2 */ 0); |
| 1496 | dictPtr += litlengthHeaderSize; |
| 1497 | } |
| 1498 | |
| 1499 | RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, ""); |
| 1500 | { int i; |
| 1501 | size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12)); |
| 1502 | for (i=0; i<3; i++) { |
| 1503 | U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4; |
| 1504 | RETURN_ERROR_IF(rep==0 || rep > dictContentSize, |
| 1505 | dictionary_corrupted, ""); |
| 1506 | entropy->rep[i] = rep; |
| 1507 | } } |
| 1508 | |
| 1509 | return (size_t)(dictPtr - (const BYTE*)dict); |
| 1510 | } |
| 1511 | |
| 1512 | static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) |
| 1513 | { |
| 1514 | if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize); |
| 1515 | { U32 const magic = MEM_readLE32(dict); |
| 1516 | if (magic != ZSTD_MAGIC_DICTIONARY) { |
| 1517 | return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */ |
| 1518 | } } |
| 1519 | dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); |
| 1520 | |
| 1521 | /* load entropy tables */ |
| 1522 | { size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize); |
| 1523 | RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, ""); |
| 1524 | dict = (const char*)dict + eSize; |
| 1525 | dictSize -= eSize; |
| 1526 | } |
| 1527 | dctx->litEntropy = dctx->fseEntropy = 1; |
| 1528 | |
| 1529 | /* reference dictionary content */ |
| 1530 | return ZSTD_refDictContent(dctx, dict, dictSize); |
| 1531 | } |
| 1532 | |
| 1533 | size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx) |
| 1534 | { |
| 1535 | assert(dctx != NULL); |
| 1536 | #if ZSTD_TRACE |
| 1537 | dctx->traceCtx = (ZSTD_trace_decompress_begin != NULL) ? ZSTD_trace_decompress_begin(dctx) : 0; |
| 1538 | #endif |
| 1539 | dctx->expected = ZSTD_startingInputLength(dctx->format); /* dctx->format must be properly set */ |
| 1540 | dctx->stage = ZSTDds_getFrameHeaderSize; |
| 1541 | dctx->processedCSize = 0; |
| 1542 | dctx->decodedSize = 0; |
| 1543 | dctx->previousDstEnd = NULL; |
| 1544 | dctx->prefixStart = NULL; |
| 1545 | dctx->virtualStart = NULL; |
| 1546 | dctx->dictEnd = NULL; |
| 1547 | dctx->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001); /* cover both little and big endian */ |
| 1548 | dctx->litEntropy = dctx->fseEntropy = 0; |
| 1549 | dctx->dictID = 0; |
| 1550 | dctx->bType = bt_reserved; |
| 1551 | ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue)); |
| 1552 | ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */ |
| 1553 | dctx->LLTptr = dctx->entropy.LLTable; |
| 1554 | dctx->MLTptr = dctx->entropy.MLTable; |
| 1555 | dctx->OFTptr = dctx->entropy.OFTable; |
| 1556 | dctx->HUFptr = dctx->entropy.hufTable; |
| 1557 | return 0; |
| 1558 | } |
| 1559 | |
| 1560 | size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) |
| 1561 | { |
| 1562 | FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , ""); |
| 1563 | if (dict && dictSize) |
| 1564 | RETURN_ERROR_IF( |
| 1565 | ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)), |
| 1566 | dictionary_corrupted, ""); |
| 1567 | return 0; |
| 1568 | } |
| 1569 | |
| 1570 | |
| 1571 | /* ====== ZSTD_DDict ====== */ |
| 1572 | |
| 1573 | size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) |
| 1574 | { |
| 1575 | DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict"); |
| 1576 | assert(dctx != NULL); |
| 1577 | if (ddict) { |
| 1578 | const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict); |
| 1579 | size_t const dictSize = ZSTD_DDict_dictSize(ddict); |
| 1580 | const void* const dictEnd = dictStart + dictSize; |
| 1581 | dctx->ddictIsCold = (dctx->dictEnd != dictEnd); |
| 1582 | DEBUGLOG(4, "DDict is %s", |
| 1583 | dctx->ddictIsCold ? "~cold~" : "hot!"); |
| 1584 | } |
| 1585 | FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , ""); |
| 1586 | if (ddict) { /* NULL ddict is equivalent to no dictionary */ |
| 1587 | ZSTD_copyDDictParameters(dctx, ddict); |
| 1588 | } |
| 1589 | return 0; |
| 1590 | } |
| 1591 | |
| 1592 | /*! ZSTD_getDictID_fromDict() : |
| 1593 | * Provides the dictID stored within dictionary. |
| 1594 | * if @return == 0, the dictionary is not conformant with Zstandard specification. |
| 1595 | * It can still be loaded, but as a content-only dictionary. */ |
| 1596 | unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize) |
| 1597 | { |
| 1598 | if (dictSize < 8) return 0; |
| 1599 | if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0; |
| 1600 | return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); |
| 1601 | } |
| 1602 | |
| 1603 | /*! ZSTD_getDictID_fromFrame() : |
| 1604 | * Provides the dictID required to decompress frame stored within `src`. |
| 1605 | * If @return == 0, the dictID could not be decoded. |
| 1606 | * This could for one of the following reasons : |
| 1607 | * - The frame does not require a dictionary (most common case). |
| 1608 | * - The frame was built with dictID intentionally removed. |
| 1609 | * Needed dictionary is a hidden piece of information. |
| 1610 | * Note : this use case also happens when using a non-conformant dictionary. |
| 1611 | * - `srcSize` is too small, and as a result, frame header could not be decoded. |
| 1612 | * Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`. |
| 1613 | * - This is not a Zstandard frame. |
| 1614 | * When identifying the exact failure cause, it's possible to use |
| 1615 | * ZSTD_getFrameHeader(), which will provide a more precise error code. */ |
| 1616 | unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize) |
| 1617 | { |
| 1618 | ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0, 0, 0 }; |
| 1619 | size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize); |
| 1620 | if (ZSTD_isError(hError)) return 0; |
| 1621 | return zfp.dictID; |
| 1622 | } |
| 1623 | |
| 1624 | |
| 1625 | /*! ZSTD_decompress_usingDDict() : |
| 1626 | * Decompression using a pre-digested Dictionary |
| 1627 | * Use dictionary without significant overhead. */ |
| 1628 | size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx, |
| 1629 | void* dst, size_t dstCapacity, |
| 1630 | const void* src, size_t srcSize, |
| 1631 | const ZSTD_DDict* ddict) |
| 1632 | { |
| 1633 | /* pass content and size in case legacy frames are encountered */ |
| 1634 | return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, |
| 1635 | NULL, 0, |
| 1636 | ddict); |
| 1637 | } |
| 1638 | |
| 1639 | |
| 1640 | /*===================================== |
| 1641 | * Streaming decompression |
| 1642 | *====================================*/ |
| 1643 | |
| 1644 | ZSTD_DStream* ZSTD_createDStream(void) |
| 1645 | { |
| 1646 | DEBUGLOG(3, "ZSTD_createDStream"); |
| 1647 | return ZSTD_createDCtx_internal(ZSTD_defaultCMem); |
| 1648 | } |
| 1649 | |
| 1650 | ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize) |
| 1651 | { |
| 1652 | return ZSTD_initStaticDCtx(workspace, workspaceSize); |
| 1653 | } |
| 1654 | |
| 1655 | ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem) |
| 1656 | { |
| 1657 | return ZSTD_createDCtx_internal(customMem); |
| 1658 | } |
| 1659 | |
| 1660 | size_t ZSTD_freeDStream(ZSTD_DStream* zds) |
| 1661 | { |
| 1662 | return ZSTD_freeDCtx(zds); |
| 1663 | } |
| 1664 | |
| 1665 | |
| 1666 | /* *** Initialization *** */ |
| 1667 | |
| 1668 | size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; } |
| 1669 | size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; } |
| 1670 | |
| 1671 | size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, |
| 1672 | const void* dict, size_t dictSize, |
| 1673 | ZSTD_dictLoadMethod_e dictLoadMethod, |
| 1674 | ZSTD_dictContentType_e dictContentType) |
| 1675 | { |
| 1676 | RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); |
| 1677 | ZSTD_clearDict(dctx); |
| 1678 | if (dict && dictSize != 0) { |
| 1679 | dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem); |
| 1680 | RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!"); |
| 1681 | dctx->ddict = dctx->ddictLocal; |
| 1682 | dctx->dictUses = ZSTD_use_indefinitely; |
| 1683 | } |
| 1684 | return 0; |
| 1685 | } |
| 1686 | |
| 1687 | size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) |
| 1688 | { |
| 1689 | return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto); |
| 1690 | } |
| 1691 | |
| 1692 | size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) |
| 1693 | { |
| 1694 | return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto); |
| 1695 | } |
| 1696 | |
| 1697 | size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType) |
| 1698 | { |
| 1699 | FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), ""); |
| 1700 | dctx->dictUses = ZSTD_use_once; |
| 1701 | return 0; |
| 1702 | } |
| 1703 | |
| 1704 | size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize) |
| 1705 | { |
| 1706 | return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent); |
| 1707 | } |
| 1708 | |
| 1709 | |
| 1710 | /* ZSTD_initDStream_usingDict() : |
| 1711 | * return : expected size, aka ZSTD_startingInputLength(). |
| 1712 | * this function cannot fail */ |
| 1713 | size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize) |
| 1714 | { |
| 1715 | DEBUGLOG(4, "ZSTD_initDStream_usingDict"); |
| 1716 | FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , ""); |
| 1717 | FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , ""); |
| 1718 | return ZSTD_startingInputLength(zds->format); |
| 1719 | } |
| 1720 | |
| 1721 | /* note : this variant can't fail */ |
| 1722 | size_t ZSTD_initDStream(ZSTD_DStream* zds) |
| 1723 | { |
| 1724 | DEBUGLOG(4, "ZSTD_initDStream"); |
| 1725 | FORWARD_IF_ERROR(ZSTD_DCtx_reset(zds, ZSTD_reset_session_only), ""); |
| 1726 | FORWARD_IF_ERROR(ZSTD_DCtx_refDDict(zds, NULL), ""); |
| 1727 | return ZSTD_startingInputLength(zds->format); |
| 1728 | } |
| 1729 | |
| 1730 | /* ZSTD_initDStream_usingDDict() : |
| 1731 | * ddict will just be referenced, and must outlive decompression session |
| 1732 | * this function cannot fail */ |
| 1733 | size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict) |
| 1734 | { |
| 1735 | DEBUGLOG(4, "ZSTD_initDStream_usingDDict"); |
| 1736 | FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , ""); |
| 1737 | FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , ""); |
| 1738 | return ZSTD_startingInputLength(dctx->format); |
| 1739 | } |
| 1740 | |
| 1741 | /* ZSTD_resetDStream() : |
| 1742 | * return : expected size, aka ZSTD_startingInputLength(). |
| 1743 | * this function cannot fail */ |
| 1744 | size_t ZSTD_resetDStream(ZSTD_DStream* dctx) |
| 1745 | { |
| 1746 | DEBUGLOG(4, "ZSTD_resetDStream"); |
| 1747 | FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), ""); |
| 1748 | return ZSTD_startingInputLength(dctx->format); |
| 1749 | } |
| 1750 | |
| 1751 | |
| 1752 | size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) |
| 1753 | { |
| 1754 | RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); |
| 1755 | ZSTD_clearDict(dctx); |
| 1756 | if (ddict) { |
| 1757 | dctx->ddict = ddict; |
| 1758 | dctx->dictUses = ZSTD_use_indefinitely; |
| 1759 | if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) { |
| 1760 | if (dctx->ddictSet == NULL) { |
| 1761 | dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem); |
| 1762 | if (!dctx->ddictSet) { |
| 1763 | RETURN_ERROR(memory_allocation, "Failed to allocate memory for hash set!"); |
| 1764 | } |
| 1765 | } |
| 1766 | assert(!dctx->staticSize); /* Impossible: ddictSet cannot have been allocated if static dctx */ |
| 1767 | FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), ""); |
| 1768 | } |
| 1769 | } |
| 1770 | return 0; |
| 1771 | } |
| 1772 | |
| 1773 | /* ZSTD_DCtx_setMaxWindowSize() : |
| 1774 | * note : no direct equivalence in ZSTD_DCtx_setParameter, |
| 1775 | * since this version sets windowSize, and the other sets windowLog */ |
| 1776 | size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize) |
| 1777 | { |
| 1778 | ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax); |
| 1779 | size_t const min = (size_t)1 << bounds.lowerBound; |
| 1780 | size_t const max = (size_t)1 << bounds.upperBound; |
| 1781 | RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); |
| 1782 | RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, ""); |
| 1783 | RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, ""); |
| 1784 | dctx->maxWindowSize = maxWindowSize; |
| 1785 | return 0; |
| 1786 | } |
| 1787 | |
| 1788 | size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format) |
| 1789 | { |
| 1790 | return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format); |
| 1791 | } |
| 1792 | |
| 1793 | ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam) |
| 1794 | { |
| 1795 | ZSTD_bounds bounds = { 0, 0, 0 }; |
| 1796 | switch(dParam) { |
| 1797 | case ZSTD_d_windowLogMax: |
| 1798 | bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN; |
| 1799 | bounds.upperBound = ZSTD_WINDOWLOG_MAX; |
| 1800 | return bounds; |
| 1801 | case ZSTD_d_format: |
| 1802 | bounds.lowerBound = (int)ZSTD_f_zstd1; |
| 1803 | bounds.upperBound = (int)ZSTD_f_zstd1_magicless; |
| 1804 | ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless); |
| 1805 | return bounds; |
| 1806 | case ZSTD_d_stableOutBuffer: |
| 1807 | bounds.lowerBound = (int)ZSTD_bm_buffered; |
| 1808 | bounds.upperBound = (int)ZSTD_bm_stable; |
| 1809 | return bounds; |
| 1810 | case ZSTD_d_forceIgnoreChecksum: |
| 1811 | bounds.lowerBound = (int)ZSTD_d_validateChecksum; |
| 1812 | bounds.upperBound = (int)ZSTD_d_ignoreChecksum; |
| 1813 | return bounds; |
| 1814 | case ZSTD_d_refMultipleDDicts: |
| 1815 | bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict; |
| 1816 | bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts; |
| 1817 | return bounds; |
| 1818 | case ZSTD_d_disableHuffmanAssembly: |
| 1819 | bounds.lowerBound = 0; |
| 1820 | bounds.upperBound = 1; |
| 1821 | return bounds; |
| 1822 | |
| 1823 | default:; |
| 1824 | } |
| 1825 | bounds.error = ERROR(parameter_unsupported); |
| 1826 | return bounds; |
| 1827 | } |
| 1828 | |
| 1829 | /* ZSTD_dParam_withinBounds: |
| 1830 | * @return 1 if value is within dParam bounds, |
| 1831 | * 0 otherwise */ |
| 1832 | static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value) |
| 1833 | { |
| 1834 | ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam); |
| 1835 | if (ZSTD_isError(bounds.error)) return 0; |
| 1836 | if (value < bounds.lowerBound) return 0; |
| 1837 | if (value > bounds.upperBound) return 0; |
| 1838 | return 1; |
| 1839 | } |
| 1840 | |
| 1841 | #define CHECK_DBOUNDS(p,v) { \ |
| 1842 | RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \ |
| 1843 | } |
| 1844 | |
| 1845 | size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value) |
| 1846 | { |
| 1847 | switch (param) { |
| 1848 | case ZSTD_d_windowLogMax: |
| 1849 | *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize); |
| 1850 | return 0; |
| 1851 | case ZSTD_d_format: |
| 1852 | *value = (int)dctx->format; |
| 1853 | return 0; |
| 1854 | case ZSTD_d_stableOutBuffer: |
| 1855 | *value = (int)dctx->outBufferMode; |
| 1856 | return 0; |
| 1857 | case ZSTD_d_forceIgnoreChecksum: |
| 1858 | *value = (int)dctx->forceIgnoreChecksum; |
| 1859 | return 0; |
| 1860 | case ZSTD_d_refMultipleDDicts: |
| 1861 | *value = (int)dctx->refMultipleDDicts; |
| 1862 | return 0; |
| 1863 | case ZSTD_d_disableHuffmanAssembly: |
| 1864 | *value = (int)dctx->disableHufAsm; |
| 1865 | return 0; |
| 1866 | default:; |
| 1867 | } |
| 1868 | RETURN_ERROR(parameter_unsupported, ""); |
| 1869 | } |
| 1870 | |
| 1871 | size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value) |
| 1872 | { |
| 1873 | RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); |
| 1874 | switch(dParam) { |
| 1875 | case ZSTD_d_windowLogMax: |
| 1876 | if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT; |
| 1877 | CHECK_DBOUNDS(ZSTD_d_windowLogMax, value); |
| 1878 | dctx->maxWindowSize = ((size_t)1) << value; |
| 1879 | return 0; |
| 1880 | case ZSTD_d_format: |
| 1881 | CHECK_DBOUNDS(ZSTD_d_format, value); |
| 1882 | dctx->format = (ZSTD_format_e)value; |
| 1883 | return 0; |
| 1884 | case ZSTD_d_stableOutBuffer: |
| 1885 | CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value); |
| 1886 | dctx->outBufferMode = (ZSTD_bufferMode_e)value; |
| 1887 | return 0; |
| 1888 | case ZSTD_d_forceIgnoreChecksum: |
| 1889 | CHECK_DBOUNDS(ZSTD_d_forceIgnoreChecksum, value); |
| 1890 | dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value; |
| 1891 | return 0; |
| 1892 | case ZSTD_d_refMultipleDDicts: |
| 1893 | CHECK_DBOUNDS(ZSTD_d_refMultipleDDicts, value); |
| 1894 | if (dctx->staticSize != 0) { |
| 1895 | RETURN_ERROR(parameter_unsupported, "Static dctx does not support multiple DDicts!"); |
| 1896 | } |
| 1897 | dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value; |
| 1898 | return 0; |
| 1899 | case ZSTD_d_disableHuffmanAssembly: |
| 1900 | CHECK_DBOUNDS(ZSTD_d_disableHuffmanAssembly, value); |
| 1901 | dctx->disableHufAsm = value != 0; |
| 1902 | return 0; |
| 1903 | default:; |
| 1904 | } |
| 1905 | RETURN_ERROR(parameter_unsupported, ""); |
| 1906 | } |
| 1907 | |
| 1908 | size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset) |
| 1909 | { |
| 1910 | if ( (reset == ZSTD_reset_session_only) |
| 1911 | || (reset == ZSTD_reset_session_and_parameters) ) { |
| 1912 | dctx->streamStage = zdss_init; |
| 1913 | dctx->noForwardProgress = 0; |
| 1914 | } |
| 1915 | if ( (reset == ZSTD_reset_parameters) |
| 1916 | || (reset == ZSTD_reset_session_and_parameters) ) { |
| 1917 | RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); |
| 1918 | ZSTD_clearDict(dctx); |
| 1919 | ZSTD_DCtx_resetParameters(dctx); |
| 1920 | } |
| 1921 | return 0; |
| 1922 | } |
| 1923 | |
| 1924 | |
| 1925 | size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx) |
| 1926 | { |
| 1927 | return ZSTD_sizeof_DCtx(dctx); |
| 1928 | } |
| 1929 | |
| 1930 | size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize) |
| 1931 | { |
| 1932 | size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX); |
| 1933 | /* space is needed to store the litbuffer after the output of a given block without stomping the extDict of a previous run, as well as to cover both windows against wildcopy*/ |
| 1934 | unsigned long long const neededRBSize = windowSize + blockSize + ZSTD_BLOCKSIZE_MAX + (WILDCOPY_OVERLENGTH * 2); |
| 1935 | unsigned long long const neededSize = MIN(frameContentSize, neededRBSize); |
| 1936 | size_t const minRBSize = (size_t) neededSize; |
| 1937 | RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize, |
| 1938 | frameParameter_windowTooLarge, ""); |
| 1939 | return minRBSize; |
| 1940 | } |
| 1941 | |
| 1942 | size_t ZSTD_estimateDStreamSize(size_t windowSize) |
| 1943 | { |
| 1944 | size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX); |
| 1945 | size_t const inBuffSize = blockSize; /* no block can be larger */ |
| 1946 | size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN); |
| 1947 | return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize; |
| 1948 | } |
| 1949 | |
| 1950 | size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize) |
| 1951 | { |
| 1952 | U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */ |
| 1953 | ZSTD_frameHeader zfh; |
| 1954 | size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize); |
| 1955 | if (ZSTD_isError(err)) return err; |
| 1956 | RETURN_ERROR_IF(err>0, srcSize_wrong, ""); |
| 1957 | RETURN_ERROR_IF(zfh.windowSize > windowSizeMax, |
| 1958 | frameParameter_windowTooLarge, ""); |
| 1959 | return ZSTD_estimateDStreamSize((size_t)zfh.windowSize); |
| 1960 | } |
| 1961 | |
| 1962 | |
| 1963 | /* ***** Decompression ***** */ |
| 1964 | |
| 1965 | static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize) |
| 1966 | { |
| 1967 | return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR; |
| 1968 | } |
| 1969 | |
| 1970 | static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize) |
| 1971 | { |
| 1972 | if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize)) |
| 1973 | zds->oversizedDuration++; |
| 1974 | else |
| 1975 | zds->oversizedDuration = 0; |
| 1976 | } |
| 1977 | |
| 1978 | static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds) |
| 1979 | { |
| 1980 | return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION; |
| 1981 | } |
| 1982 | |
| 1983 | /* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */ |
| 1984 | static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output) |
| 1985 | { |
| 1986 | ZSTD_outBuffer const expect = zds->expectedOutBuffer; |
| 1987 | /* No requirement when ZSTD_obm_stable is not enabled. */ |
| 1988 | if (zds->outBufferMode != ZSTD_bm_stable) |
| 1989 | return 0; |
| 1990 | /* Any buffer is allowed in zdss_init, this must be the same for every other call until |
| 1991 | * the context is reset. |
| 1992 | */ |
| 1993 | if (zds->streamStage == zdss_init) |
| 1994 | return 0; |
| 1995 | /* The buffer must match our expectation exactly. */ |
| 1996 | if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size) |
| 1997 | return 0; |
| 1998 | RETURN_ERROR(dstBuffer_wrong, "ZSTD_d_stableOutBuffer enabled but output differs!"); |
| 1999 | } |
| 2000 | |
| 2001 | /* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream() |
| 2002 | * and updates the stage and the output buffer state. This call is extracted so it can be |
| 2003 | * used both when reading directly from the ZSTD_inBuffer, and in buffered input mode. |
| 2004 | * NOTE: You must break after calling this function since the streamStage is modified. |
| 2005 | */ |
| 2006 | static size_t ZSTD_decompressContinueStream( |
| 2007 | ZSTD_DStream* zds, char** op, char* oend, |
| 2008 | void const* src, size_t srcSize) { |
| 2009 | int const isSkipFrame = ZSTD_isSkipFrame(zds); |
| 2010 | if (zds->outBufferMode == ZSTD_bm_buffered) { |
| 2011 | size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart; |
| 2012 | size_t const decodedSize = ZSTD_decompressContinue(zds, |
| 2013 | zds->outBuff + zds->outStart, dstSize, src, srcSize); |
| 2014 | FORWARD_IF_ERROR(decodedSize, ""); |
| 2015 | if (!decodedSize && !isSkipFrame) { |
| 2016 | zds->streamStage = zdss_read; |
| 2017 | } else { |
| 2018 | zds->outEnd = zds->outStart + decodedSize; |
| 2019 | zds->streamStage = zdss_flush; |
| 2020 | } |
| 2021 | } else { |
| 2022 | /* Write directly into the output buffer */ |
| 2023 | size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op); |
| 2024 | size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize); |
| 2025 | FORWARD_IF_ERROR(decodedSize, ""); |
| 2026 | *op += decodedSize; |
| 2027 | /* Flushing is not needed. */ |
| 2028 | zds->streamStage = zdss_read; |
| 2029 | assert(*op <= oend); |
| 2030 | assert(zds->outBufferMode == ZSTD_bm_stable); |
| 2031 | } |
| 2032 | return 0; |
| 2033 | } |
| 2034 | |
| 2035 | size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input) |
| 2036 | { |
| 2037 | const char* const src = (const char*)input->src; |
| 2038 | const char* const istart = input->pos != 0 ? src + input->pos : src; |
| 2039 | const char* const iend = input->size != 0 ? src + input->size : src; |
| 2040 | const char* ip = istart; |
| 2041 | char* const dst = (char*)output->dst; |
| 2042 | char* const ostart = output->pos != 0 ? dst + output->pos : dst; |
| 2043 | char* const oend = output->size != 0 ? dst + output->size : dst; |
| 2044 | char* op = ostart; |
| 2045 | U32 someMoreWork = 1; |
| 2046 | |
| 2047 | DEBUGLOG(5, "ZSTD_decompressStream"); |
| 2048 | RETURN_ERROR_IF( |
| 2049 | input->pos > input->size, |
| 2050 | srcSize_wrong, |
| 2051 | "forbidden. in: pos: %u vs size: %u", |
| 2052 | (U32)input->pos, (U32)input->size); |
| 2053 | RETURN_ERROR_IF( |
| 2054 | output->pos > output->size, |
| 2055 | dstSize_tooSmall, |
| 2056 | "forbidden. out: pos: %u vs size: %u", |
| 2057 | (U32)output->pos, (U32)output->size); |
| 2058 | DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos)); |
| 2059 | FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), ""); |
| 2060 | |
| 2061 | while (someMoreWork) { |
| 2062 | switch(zds->streamStage) |
| 2063 | { |
| 2064 | case zdss_init : |
| 2065 | DEBUGLOG(5, "stage zdss_init => transparent reset "); |
| 2066 | zds->streamStage = zdss_loadHeader; |
| 2067 | zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0; |
| 2068 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) |
| 2069 | zds->legacyVersion = 0; |
| 2070 | #endif |
| 2071 | zds->hostageByte = 0; |
| 2072 | zds->expectedOutBuffer = *output; |
| 2073 | ZSTD_FALLTHROUGH; |
| 2074 | |
| 2075 | case zdss_loadHeader : |
| 2076 | DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip)); |
| 2077 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) |
| 2078 | if (zds->legacyVersion) { |
| 2079 | RETURN_ERROR_IF(zds->staticSize, memory_allocation, |
| 2080 | "legacy support is incompatible with static dctx"); |
| 2081 | { size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input); |
| 2082 | if (hint==0) zds->streamStage = zdss_init; |
| 2083 | return hint; |
| 2084 | } } |
| 2085 | #endif |
| 2086 | { size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format); |
| 2087 | if (zds->refMultipleDDicts && zds->ddictSet) { |
| 2088 | ZSTD_DCtx_selectFrameDDict(zds); |
| 2089 | } |
| 2090 | if (ZSTD_isError(hSize)) { |
| 2091 | #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) |
| 2092 | U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart); |
| 2093 | if (legacyVersion) { |
| 2094 | ZSTD_DDict const* const ddict = ZSTD_getDDict(zds); |
| 2095 | const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL; |
| 2096 | size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0; |
| 2097 | DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion); |
| 2098 | RETURN_ERROR_IF(zds->staticSize, memory_allocation, |
| 2099 | "legacy support is incompatible with static dctx"); |
| 2100 | FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext, |
| 2101 | zds->previousLegacyVersion, legacyVersion, |
| 2102 | dict, dictSize), ""); |
| 2103 | zds->legacyVersion = zds->previousLegacyVersion = legacyVersion; |
| 2104 | { size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input); |
| 2105 | if (hint==0) zds->streamStage = zdss_init; /* or stay in stage zdss_loadHeader */ |
| 2106 | return hint; |
| 2107 | } } |
| 2108 | #endif |
| 2109 | return hSize; /* error */ |
| 2110 | } |
| 2111 | if (hSize != 0) { /* need more input */ |
| 2112 | size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */ |
| 2113 | size_t const remainingInput = (size_t)(iend-ip); |
| 2114 | assert(iend >= ip); |
| 2115 | if (toLoad > remainingInput) { /* not enough input to load full header */ |
| 2116 | if (remainingInput > 0) { |
| 2117 | ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput); |
| 2118 | zds->lhSize += remainingInput; |
| 2119 | } |
| 2120 | input->pos = input->size; |
| 2121 | /* check first few bytes */ |
| 2122 | FORWARD_IF_ERROR( |
| 2123 | ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format), |
| 2124 | "First few bytes detected incorrect" ); |
| 2125 | /* return hint input size */ |
| 2126 | return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */ |
| 2127 | } |
| 2128 | assert(ip != NULL); |
| 2129 | ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad; |
| 2130 | break; |
| 2131 | } } |
| 2132 | |
| 2133 | /* check for single-pass mode opportunity */ |
| 2134 | if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN |
| 2135 | && zds->fParams.frameType != ZSTD_skippableFrame |
| 2136 | && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) { |
| 2137 | size_t const cSize = ZSTD_findFrameCompressedSize(istart, (size_t)(iend-istart)); |
| 2138 | if (cSize <= (size_t)(iend-istart)) { |
| 2139 | /* shortcut : using single-pass mode */ |
| 2140 | size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, ZSTD_getDDict(zds)); |
| 2141 | if (ZSTD_isError(decompressedSize)) return decompressedSize; |
| 2142 | DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()") |
| 2143 | assert(istart != NULL); |
| 2144 | ip = istart + cSize; |
| 2145 | op = op ? op + decompressedSize : op; /* can occur if frameContentSize = 0 (empty frame) */ |
| 2146 | zds->expected = 0; |
| 2147 | zds->streamStage = zdss_init; |
| 2148 | someMoreWork = 0; |
| 2149 | break; |
| 2150 | } } |
| 2151 | |
| 2152 | /* Check output buffer is large enough for ZSTD_odm_stable. */ |
| 2153 | if (zds->outBufferMode == ZSTD_bm_stable |
| 2154 | && zds->fParams.frameType != ZSTD_skippableFrame |
| 2155 | && zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN |
| 2156 | && (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) { |
| 2157 | RETURN_ERROR(dstSize_tooSmall, "ZSTD_obm_stable passed but ZSTD_outBuffer is too small"); |
| 2158 | } |
| 2159 | |
| 2160 | /* Consume header (see ZSTDds_decodeFrameHeader) */ |
| 2161 | DEBUGLOG(4, "Consume header"); |
| 2162 | FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), ""); |
| 2163 | |
| 2164 | if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */ |
| 2165 | zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE); |
| 2166 | zds->stage = ZSTDds_skipFrame; |
| 2167 | } else { |
| 2168 | FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), ""); |
| 2169 | zds->expected = ZSTD_blockHeaderSize; |
| 2170 | zds->stage = ZSTDds_decodeBlockHeader; |
| 2171 | } |
| 2172 | |
| 2173 | /* control buffer memory usage */ |
| 2174 | DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)", |
| 2175 | (U32)(zds->fParams.windowSize >>10), |
| 2176 | (U32)(zds->maxWindowSize >> 10) ); |
| 2177 | zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN); |
| 2178 | RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize, |
| 2179 | frameParameter_windowTooLarge, ""); |
| 2180 | |
| 2181 | /* Adapt buffer sizes to frame header instructions */ |
| 2182 | { size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */); |
| 2183 | size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered |
| 2184 | ? ZSTD_decodingBufferSize_min(zds->fParams.windowSize, zds->fParams.frameContentSize) |
| 2185 | : 0; |
| 2186 | |
| 2187 | ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize); |
| 2188 | |
| 2189 | { int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize); |
| 2190 | int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds); |
| 2191 | |
| 2192 | if (tooSmall || tooLarge) { |
| 2193 | size_t const bufferSize = neededInBuffSize + neededOutBuffSize; |
| 2194 | DEBUGLOG(4, "inBuff : from %u to %u", |
| 2195 | (U32)zds->inBuffSize, (U32)neededInBuffSize); |
| 2196 | DEBUGLOG(4, "outBuff : from %u to %u", |
| 2197 | (U32)zds->outBuffSize, (U32)neededOutBuffSize); |
| 2198 | if (zds->staticSize) { /* static DCtx */ |
| 2199 | DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize); |
| 2200 | assert(zds->staticSize >= sizeof(ZSTD_DCtx)); /* controlled at init */ |
| 2201 | RETURN_ERROR_IF( |
| 2202 | bufferSize > zds->staticSize - sizeof(ZSTD_DCtx), |
| 2203 | memory_allocation, ""); |
| 2204 | } else { |
| 2205 | ZSTD_customFree(zds->inBuff, zds->customMem); |
| 2206 | zds->inBuffSize = 0; |
| 2207 | zds->outBuffSize = 0; |
| 2208 | zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem); |
| 2209 | RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, ""); |
| 2210 | } |
| 2211 | zds->inBuffSize = neededInBuffSize; |
| 2212 | zds->outBuff = zds->inBuff + zds->inBuffSize; |
| 2213 | zds->outBuffSize = neededOutBuffSize; |
| 2214 | } } } |
| 2215 | zds->streamStage = zdss_read; |
| 2216 | ZSTD_FALLTHROUGH; |
| 2217 | |
| 2218 | case zdss_read: |
| 2219 | DEBUGLOG(5, "stage zdss_read"); |
| 2220 | { size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip)); |
| 2221 | DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize); |
| 2222 | if (neededInSize==0) { /* end of frame */ |
| 2223 | zds->streamStage = zdss_init; |
| 2224 | someMoreWork = 0; |
| 2225 | break; |
| 2226 | } |
| 2227 | if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */ |
| 2228 | FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), ""); |
| 2229 | assert(ip != NULL); |
| 2230 | ip += neededInSize; |
| 2231 | /* Function modifies the stage so we must break */ |
| 2232 | break; |
| 2233 | } } |
| 2234 | if (ip==iend) { someMoreWork = 0; break; } /* no more input */ |
| 2235 | zds->streamStage = zdss_load; |
| 2236 | ZSTD_FALLTHROUGH; |
| 2237 | |
| 2238 | case zdss_load: |
| 2239 | { size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds); |
| 2240 | size_t const toLoad = neededInSize - zds->inPos; |
| 2241 | int const isSkipFrame = ZSTD_isSkipFrame(zds); |
| 2242 | size_t loadedSize; |
| 2243 | /* At this point we shouldn't be decompressing a block that we can stream. */ |
| 2244 | assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip))); |
| 2245 | if (isSkipFrame) { |
| 2246 | loadedSize = MIN(toLoad, (size_t)(iend-ip)); |
| 2247 | } else { |
| 2248 | RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos, |
| 2249 | corruption_detected, |
| 2250 | "should never happen"); |
| 2251 | loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip)); |
| 2252 | } |
| 2253 | if (loadedSize != 0) { |
| 2254 | /* ip may be NULL */ |
| 2255 | ip += loadedSize; |
| 2256 | zds->inPos += loadedSize; |
| 2257 | } |
| 2258 | if (loadedSize < toLoad) { someMoreWork = 0; break; } /* not enough input, wait for more */ |
| 2259 | |
| 2260 | /* decode loaded input */ |
| 2261 | zds->inPos = 0; /* input is consumed */ |
| 2262 | FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), ""); |
| 2263 | /* Function modifies the stage so we must break */ |
| 2264 | break; |
| 2265 | } |
| 2266 | case zdss_flush: |
| 2267 | { |
| 2268 | size_t const toFlushSize = zds->outEnd - zds->outStart; |
| 2269 | size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toFlushSize); |
| 2270 | |
| 2271 | op = op ? op + flushedSize : op; |
| 2272 | |
| 2273 | zds->outStart += flushedSize; |
| 2274 | if (flushedSize == toFlushSize) { /* flush completed */ |
| 2275 | zds->streamStage = zdss_read; |
| 2276 | if ( (zds->outBuffSize < zds->fParams.frameContentSize) |
| 2277 | && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) { |
| 2278 | DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)", |
| 2279 | (int)(zds->outBuffSize - zds->outStart), |
| 2280 | (U32)zds->fParams.blockSizeMax); |
| 2281 | zds->outStart = zds->outEnd = 0; |
| 2282 | } |
| 2283 | break; |
| 2284 | } } |
| 2285 | /* cannot complete flush */ |
| 2286 | someMoreWork = 0; |
| 2287 | break; |
| 2288 | |
| 2289 | default: |
| 2290 | assert(0); /* impossible */ |
| 2291 | RETURN_ERROR(GENERIC, "impossible to reach"); /* some compilers require default to do something */ |
| 2292 | } } |
| 2293 | |
| 2294 | /* result */ |
| 2295 | input->pos = (size_t)(ip - (const char*)(input->src)); |
| 2296 | output->pos = (size_t)(op - (char*)(output->dst)); |
| 2297 | |
| 2298 | /* Update the expected output buffer for ZSTD_obm_stable. */ |
| 2299 | zds->expectedOutBuffer = *output; |
| 2300 | |
| 2301 | if ((ip==istart) && (op==ostart)) { /* no forward progress */ |
| 2302 | zds->noForwardProgress ++; |
| 2303 | if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) { |
| 2304 | RETURN_ERROR_IF(op==oend, noForwardProgress_destFull, ""); |
| 2305 | RETURN_ERROR_IF(ip==iend, noForwardProgress_inputEmpty, ""); |
| 2306 | assert(0); |
| 2307 | } |
| 2308 | } else { |
| 2309 | zds->noForwardProgress = 0; |
| 2310 | } |
| 2311 | { size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds); |
| 2312 | if (!nextSrcSizeHint) { /* frame fully decoded */ |
| 2313 | if (zds->outEnd == zds->outStart) { /* output fully flushed */ |
| 2314 | if (zds->hostageByte) { |
| 2315 | if (input->pos >= input->size) { |
| 2316 | /* can't release hostage (not present) */ |
| 2317 | zds->streamStage = zdss_read; |
| 2318 | return 1; |
| 2319 | } |
| 2320 | input->pos++; /* release hostage */ |
| 2321 | } /* zds->hostageByte */ |
| 2322 | return 0; |
| 2323 | } /* zds->outEnd == zds->outStart */ |
| 2324 | if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */ |
| 2325 | input->pos--; /* note : pos > 0, otherwise, impossible to finish reading last block */ |
| 2326 | zds->hostageByte=1; |
| 2327 | } |
| 2328 | return 1; |
| 2329 | } /* nextSrcSizeHint==0 */ |
| 2330 | nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */ |
| 2331 | assert(zds->inPos <= nextSrcSizeHint); |
| 2332 | nextSrcSizeHint -= zds->inPos; /* part already loaded*/ |
| 2333 | return nextSrcSizeHint; |
| 2334 | } |
| 2335 | } |
| 2336 | |
| 2337 | size_t ZSTD_decompressStream_simpleArgs ( |
| 2338 | ZSTD_DCtx* dctx, |
| 2339 | void* dst, size_t dstCapacity, size_t* dstPos, |
| 2340 | const void* src, size_t srcSize, size_t* srcPos) |
| 2341 | { |
| 2342 | ZSTD_outBuffer output; |
| 2343 | ZSTD_inBuffer input; |
| 2344 | output.dst = dst; |
| 2345 | output.size = dstCapacity; |
| 2346 | output.pos = *dstPos; |
| 2347 | input.src = src; |
| 2348 | input.size = srcSize; |
| 2349 | input.pos = *srcPos; |
| 2350 | { size_t const cErr = ZSTD_decompressStream(dctx, &output, &input); |
| 2351 | *dstPos = output.pos; |
| 2352 | *srcPos = input.pos; |
| 2353 | return cErr; |
| 2354 | } |
| 2355 | } |