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