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 */
94static 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 */
104static 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 */
130static 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 */
155static 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 */
177static 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 */
195static 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 */
208static 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***************************************************************/
220size_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
228size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
229
230
231static 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
239static 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
250static 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
278ZSTD_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
291static 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
302ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
303{
304 return ZSTD_createDCtx_internal(customMem);
305}
306
307ZSTD_DCtx* ZSTD_createDCtx(void)
308{
309 DEBUGLOG(3, "ZSTD_createDCtx");
310 return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
311}
312
313static 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
321size_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 */
343void 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 */
357static 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. */
382unsigned 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 */
399unsigned 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() */
413static 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) */
432size_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() */
444size_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() */
554size_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) */
564unsigned 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
582static 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 */
609size_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 */
638unsigned 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) */
685unsigned 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() */
697static 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
721static 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
729static 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` */
801size_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 */
813unsigned 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
831size_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. */
880size_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
889static 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
902static 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
915static 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. */
946static 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
1054static 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
1146size_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
1155static 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
1172size_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
1178size_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****************************************/
1199size_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 */
1211static 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
1219ZSTD_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
1244static 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() */
1250size_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
1408static 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 */
1424size_t
1425ZSTD_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
1512static 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
1533size_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
1560size_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
1573size_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. */
1596unsigned 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. */
1616unsigned 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. */
1628size_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
1644ZSTD_DStream* ZSTD_createDStream(void)
1645{
1646 DEBUGLOG(3, "ZSTD_createDStream");
1647 return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
1648}
1649
1650ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
1651{
1652 return ZSTD_initStaticDCtx(workspace, workspaceSize);
1653}
1654
1655ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
1656{
1657 return ZSTD_createDCtx_internal(customMem);
1658}
1659
1660size_t ZSTD_freeDStream(ZSTD_DStream* zds)
1661{
1662 return ZSTD_freeDCtx(zds);
1663}
1664
1665
1666/* *** Initialization *** */
1667
1668size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
1669size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
1670
1671size_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
1687size_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
1692size_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
1697size_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
1704size_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 */
1713size_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 */
1722size_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 */
1733size_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 */
1744size_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
1752size_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 */
1776size_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
1788size_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
1793ZSTD_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 */
1832static 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
1845size_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
1871size_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
1908size_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
1925size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
1926{
1927 return ZSTD_sizeof_DCtx(dctx);
1928}
1929
1930size_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
1942size_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
1950size_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
1965static 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
1970static 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
1978static 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. */
1984static 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 */
2006static 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
2035size_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
2337size_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}
2356