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