Loading...
Note: File does not exist in v3.1.
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 */
87static 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 */
97static 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 */
123static 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 */
148static 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 */
170static 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 */
188static 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 */
201static 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***************************************************************/
213size_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
221size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
222
223
224static 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
232static 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
242static 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
266ZSTD_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
279static 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
290ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
291{
292 return ZSTD_createDCtx_internal(customMem);
293}
294
295ZSTD_DCtx* ZSTD_createDCtx(void)
296{
297 DEBUGLOG(3, "ZSTD_createDCtx");
298 return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
299}
300
301static 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
309size_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 */
327void 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 */
341static 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. */
366unsigned 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 */
380unsigned 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() */
394static 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) */
413size_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() */
425size_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() */
511size_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) */
521unsigned 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
533static 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 */
561ZSTDLIB_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 */
586unsigned 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) */
635unsigned 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() */
647static 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
671static 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
679static 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` */
746size_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 */
758unsigned 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. */
783size_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
792static 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_memcpy(dst, src, srcSize);
802 return srcSize;
803}
804
805static 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
818static 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. */
831static 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 size_t decodedSize;
862 blockProperties_t blockProperties;
863 size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
864 if (ZSTD_isError(cBlockSize)) return cBlockSize;
865
866 ip += ZSTD_blockHeaderSize;
867 remainingSrcSize -= ZSTD_blockHeaderSize;
868 RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");
869
870 switch(blockProperties.blockType)
871 {
872 case bt_compressed:
873 decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oend-op), ip, cBlockSize, /* frame */ 1, not_streaming);
874 break;
875 case bt_raw :
876 decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize);
877 break;
878 case bt_rle :
879 decodedSize = ZSTD_setRleBlock(op, (size_t)(oend-op), *ip, blockProperties.origSize);
880 break;
881 case bt_reserved :
882 default:
883 RETURN_ERROR(corruption_detected, "invalid block type");
884 }
885
886 if (ZSTD_isError(decodedSize)) return decodedSize;
887 if (dctx->validateChecksum)
888 xxh64_update(&dctx->xxhState, op, decodedSize);
889 if (decodedSize != 0)
890 op += decodedSize;
891 assert(ip != NULL);
892 ip += cBlockSize;
893 remainingSrcSize -= cBlockSize;
894 if (blockProperties.lastBlock) break;
895 }
896
897 if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
898 RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
899 corruption_detected, "");
900 }
901 if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
902 RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, "");
903 if (!dctx->forceIgnoreChecksum) {
904 U32 const checkCalc = (U32)xxh64_digest(&dctx->xxhState);
905 U32 checkRead;
906 checkRead = MEM_readLE32(ip);
907 RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, "");
908 }
909 ip += 4;
910 remainingSrcSize -= 4;
911 }
912 ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);
913 /* Allow caller to get size read */
914 *srcPtr = ip;
915 *srcSizePtr = remainingSrcSize;
916 return (size_t)(op-ostart);
917}
918
919static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
920 void* dst, size_t dstCapacity,
921 const void* src, size_t srcSize,
922 const void* dict, size_t dictSize,
923 const ZSTD_DDict* ddict)
924{
925 void* const dststart = dst;
926 int moreThan1Frame = 0;
927
928 DEBUGLOG(5, "ZSTD_decompressMultiFrame");
929 assert(dict==NULL || ddict==NULL); /* either dict or ddict set, not both */
930
931 if (ddict) {
932 dict = ZSTD_DDict_dictContent(ddict);
933 dictSize = ZSTD_DDict_dictSize(ddict);
934 }
935
936 while (srcSize >= ZSTD_startingInputLength(dctx->format)) {
937
938
939 { U32 const magicNumber = MEM_readLE32(src);
940 DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
941 (unsigned)magicNumber, ZSTD_MAGICNUMBER);
942 if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
943 size_t const skippableSize = readSkippableFrameSize(src, srcSize);
944 FORWARD_IF_ERROR(skippableSize, "readSkippableFrameSize failed");
945 assert(skippableSize <= srcSize);
946
947 src = (const BYTE *)src + skippableSize;
948 srcSize -= skippableSize;
949 continue;
950 } }
951
952 if (ddict) {
953 /* we were called from ZSTD_decompress_usingDDict */
954 FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), "");
955 } else {
956 /* this will initialize correctly with no dict if dict == NULL, so
957 * use this in all cases but ddict */
958 FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), "");
959 }
960 ZSTD_checkContinuity(dctx, dst, dstCapacity);
961
962 { const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
963 &src, &srcSize);
964 RETURN_ERROR_IF(
965 (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
966 && (moreThan1Frame==1),
967 srcSize_wrong,
968 "At least one frame successfully completed, "
969 "but following bytes are garbage: "
970 "it's more likely to be a srcSize error, "
971 "specifying more input bytes than size of frame(s). "
972 "Note: one could be unlucky, it might be a corruption error instead, "
973 "happening right at the place where we expect zstd magic bytes. "
974 "But this is _much_ less likely than a srcSize field error.");
975 if (ZSTD_isError(res)) return res;
976 assert(res <= dstCapacity);
977 if (res != 0)
978 dst = (BYTE*)dst + res;
979 dstCapacity -= res;
980 }
981 moreThan1Frame = 1;
982 } /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
983
984 RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");
985
986 return (size_t)((BYTE*)dst - (BYTE*)dststart);
987}
988
989size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
990 void* dst, size_t dstCapacity,
991 const void* src, size_t srcSize,
992 const void* dict, size_t dictSize)
993{
994 return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
995}
996
997
998static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
999{
1000 switch (dctx->dictUses) {
1001 default:
1002 assert(0 /* Impossible */);
1003 ZSTD_FALLTHROUGH;
1004 case ZSTD_dont_use:
1005 ZSTD_clearDict(dctx);
1006 return NULL;
1007 case ZSTD_use_indefinitely:
1008 return dctx->ddict;
1009 case ZSTD_use_once:
1010 dctx->dictUses = ZSTD_dont_use;
1011 return dctx->ddict;
1012 }
1013}
1014
1015size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1016{
1017 return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
1018}
1019
1020
1021size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1022{
1023#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
1024 size_t regenSize;
1025 ZSTD_DCtx* const dctx = ZSTD_createDCtx_internal(ZSTD_defaultCMem);
1026 RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
1027 regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
1028 ZSTD_freeDCtx(dctx);
1029 return regenSize;
1030#else /* stack mode */
1031 ZSTD_DCtx dctx;
1032 ZSTD_initDCtx_internal(&dctx);
1033 return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
1034#endif
1035}
1036
1037
1038/*-**************************************
1039* Advanced Streaming Decompression API
1040* Bufferless and synchronous
1041****************************************/
1042size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
1043
1044/*
1045 * Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed,
1046 * we allow taking a partial block as the input. Currently only raw uncompressed blocks can
1047 * be streamed.
1048 *
1049 * For blocks that can be streamed, this allows us to reduce the latency until we produce
1050 * output, and avoid copying the input.
1051 *
1052 * @param inputSize - The total amount of input that the caller currently has.
1053 */
1054static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {
1055 if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock))
1056 return dctx->expected;
1057 if (dctx->bType != bt_raw)
1058 return dctx->expected;
1059 return BOUNDED(1, inputSize, dctx->expected);
1060}
1061
1062ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
1063 switch(dctx->stage)
1064 {
1065 default: /* should not happen */
1066 assert(0);
1067 ZSTD_FALLTHROUGH;
1068 case ZSTDds_getFrameHeaderSize:
1069 ZSTD_FALLTHROUGH;
1070 case ZSTDds_decodeFrameHeader:
1071 return ZSTDnit_frameHeader;
1072 case ZSTDds_decodeBlockHeader:
1073 return ZSTDnit_blockHeader;
1074 case ZSTDds_decompressBlock:
1075 return ZSTDnit_block;
1076 case ZSTDds_decompressLastBlock:
1077 return ZSTDnit_lastBlock;
1078 case ZSTDds_checkChecksum:
1079 return ZSTDnit_checksum;
1080 case ZSTDds_decodeSkippableHeader:
1081 ZSTD_FALLTHROUGH;
1082 case ZSTDds_skipFrame:
1083 return ZSTDnit_skippableFrame;
1084 }
1085}
1086
1087static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
1088
1089/* ZSTD_decompressContinue() :
1090 * srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
1091 * @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
1092 * or an error code, which can be tested using ZSTD_isError() */
1093size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
1094{
1095 DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
1096 /* Sanity check */
1097 RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
1098 ZSTD_checkContinuity(dctx, dst, dstCapacity);
1099
1100 dctx->processedCSize += srcSize;
1101
1102 switch (dctx->stage)
1103 {
1104 case ZSTDds_getFrameHeaderSize :
1105 assert(src != NULL);
1106 if (dctx->format == ZSTD_f_zstd1) { /* allows header */
1107 assert(srcSize >= ZSTD_FRAMEIDSIZE); /* to read skippable magic number */
1108 if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
1109 ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1110 dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize; /* remaining to load to get full skippable frame header */
1111 dctx->stage = ZSTDds_decodeSkippableHeader;
1112 return 0;
1113 } }
1114 dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
1115 if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
1116 ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
1117 dctx->expected = dctx->headerSize - srcSize;
1118 dctx->stage = ZSTDds_decodeFrameHeader;
1119 return 0;
1120
1121 case ZSTDds_decodeFrameHeader:
1122 assert(src != NULL);
1123 ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
1124 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), "");
1125 dctx->expected = ZSTD_blockHeaderSize;
1126 dctx->stage = ZSTDds_decodeBlockHeader;
1127 return 0;
1128
1129 case ZSTDds_decodeBlockHeader:
1130 { blockProperties_t bp;
1131 size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
1132 if (ZSTD_isError(cBlockSize)) return cBlockSize;
1133 RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
1134 dctx->expected = cBlockSize;
1135 dctx->bType = bp.blockType;
1136 dctx->rleSize = bp.origSize;
1137 if (cBlockSize) {
1138 dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
1139 return 0;
1140 }
1141 /* empty block */
1142 if (bp.lastBlock) {
1143 if (dctx->fParams.checksumFlag) {
1144 dctx->expected = 4;
1145 dctx->stage = ZSTDds_checkChecksum;
1146 } else {
1147 dctx->expected = 0; /* end of frame */
1148 dctx->stage = ZSTDds_getFrameHeaderSize;
1149 }
1150 } else {
1151 dctx->expected = ZSTD_blockHeaderSize; /* jump to next header */
1152 dctx->stage = ZSTDds_decodeBlockHeader;
1153 }
1154 return 0;
1155 }
1156
1157 case ZSTDds_decompressLastBlock:
1158 case ZSTDds_decompressBlock:
1159 DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
1160 { size_t rSize;
1161 switch(dctx->bType)
1162 {
1163 case bt_compressed:
1164 DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
1165 rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1, is_streaming);
1166 dctx->expected = 0; /* Streaming not supported */
1167 break;
1168 case bt_raw :
1169 assert(srcSize <= dctx->expected);
1170 rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
1171 FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed");
1172 assert(rSize == srcSize);
1173 dctx->expected -= rSize;
1174 break;
1175 case bt_rle :
1176 rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
1177 dctx->expected = 0; /* Streaming not supported */
1178 break;
1179 case bt_reserved : /* should never happen */
1180 default:
1181 RETURN_ERROR(corruption_detected, "invalid block type");
1182 }
1183 FORWARD_IF_ERROR(rSize, "");
1184 RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
1185 DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
1186 dctx->decodedSize += rSize;
1187 if (dctx->validateChecksum) xxh64_update(&dctx->xxhState, dst, rSize);
1188 dctx->previousDstEnd = (char*)dst + rSize;
1189
1190 /* Stay on the same stage until we are finished streaming the block. */
1191 if (dctx->expected > 0) {
1192 return rSize;
1193 }
1194
1195 if (dctx->stage == ZSTDds_decompressLastBlock) { /* end of frame */
1196 DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
1197 RETURN_ERROR_IF(
1198 dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1199 && dctx->decodedSize != dctx->fParams.frameContentSize,
1200 corruption_detected, "");
1201 if (dctx->fParams.checksumFlag) { /* another round for frame checksum */
1202 dctx->expected = 4;
1203 dctx->stage = ZSTDds_checkChecksum;
1204 } else {
1205 ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
1206 dctx->expected = 0; /* ends here */
1207 dctx->stage = ZSTDds_getFrameHeaderSize;
1208 }
1209 } else {
1210 dctx->stage = ZSTDds_decodeBlockHeader;
1211 dctx->expected = ZSTD_blockHeaderSize;
1212 }
1213 return rSize;
1214 }
1215
1216 case ZSTDds_checkChecksum:
1217 assert(srcSize == 4); /* guaranteed by dctx->expected */
1218 {
1219 if (dctx->validateChecksum) {
1220 U32 const h32 = (U32)xxh64_digest(&dctx->xxhState);
1221 U32 const check32 = MEM_readLE32(src);
1222 DEBUGLOG(4, "ZSTD_decompressContinue: checksum : calculated %08X :: %08X read", (unsigned)h32, (unsigned)check32);
1223 RETURN_ERROR_IF(check32 != h32, checksum_wrong, "");
1224 }
1225 ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
1226 dctx->expected = 0;
1227 dctx->stage = ZSTDds_getFrameHeaderSize;
1228 return 0;
1229 }
1230
1231 case ZSTDds_decodeSkippableHeader:
1232 assert(src != NULL);
1233 assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
1234 ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize); /* complete skippable header */
1235 dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE); /* note : dctx->expected can grow seriously large, beyond local buffer size */
1236 dctx->stage = ZSTDds_skipFrame;
1237 return 0;
1238
1239 case ZSTDds_skipFrame:
1240 dctx->expected = 0;
1241 dctx->stage = ZSTDds_getFrameHeaderSize;
1242 return 0;
1243
1244 default:
1245 assert(0); /* impossible */
1246 RETURN_ERROR(GENERIC, "impossible to reach"); /* some compiler require default to do something */
1247 }
1248}
1249
1250
1251static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1252{
1253 dctx->dictEnd = dctx->previousDstEnd;
1254 dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
1255 dctx->prefixStart = dict;
1256 dctx->previousDstEnd = (const char*)dict + dictSize;
1257#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
1258 dctx->dictContentBeginForFuzzing = dctx->prefixStart;
1259 dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
1260#endif
1261 return 0;
1262}
1263
1264/*! ZSTD_loadDEntropy() :
1265 * dict : must point at beginning of a valid zstd dictionary.
1266 * @return : size of entropy tables read */
1267size_t
1268ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
1269 const void* const dict, size_t const dictSize)
1270{
1271 const BYTE* dictPtr = (const BYTE*)dict;
1272 const BYTE* const dictEnd = dictPtr + dictSize;
1273
1274 RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
1275 assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY); /* dict must be valid */
1276 dictPtr += 8; /* skip header = magic + dictID */
1277
1278 ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
1279 ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
1280 ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
1281 { void* const workspace = &entropy->LLTable; /* use fse tables as temporary workspace; implies fse tables are grouped together */
1282 size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
1283#ifdef HUF_FORCE_DECOMPRESS_X1
1284 /* in minimal huffman, we always use X1 variants */
1285 size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
1286 dictPtr, dictEnd - dictPtr,
1287 workspace, workspaceSize);
1288#else
1289 size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
1290 dictPtr, (size_t)(dictEnd - dictPtr),
1291 workspace, workspaceSize);
1292#endif
1293 RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
1294 dictPtr += hSize;
1295 }
1296
1297 { short offcodeNCount[MaxOff+1];
1298 unsigned offcodeMaxValue = MaxOff, offcodeLog;
1299 size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));
1300 RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
1301 RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, "");
1302 RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
1303 ZSTD_buildFSETable( entropy->OFTable,
1304 offcodeNCount, offcodeMaxValue,
1305 OF_base, OF_bits,
1306 offcodeLog,
1307 entropy->workspace, sizeof(entropy->workspace),
1308 /* bmi2 */0);
1309 dictPtr += offcodeHeaderSize;
1310 }
1311
1312 { short matchlengthNCount[MaxML+1];
1313 unsigned matchlengthMaxValue = MaxML, matchlengthLog;
1314 size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
1315 RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
1316 RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, "");
1317 RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
1318 ZSTD_buildFSETable( entropy->MLTable,
1319 matchlengthNCount, matchlengthMaxValue,
1320 ML_base, ML_bits,
1321 matchlengthLog,
1322 entropy->workspace, sizeof(entropy->workspace),
1323 /* bmi2 */ 0);
1324 dictPtr += matchlengthHeaderSize;
1325 }
1326
1327 { short litlengthNCount[MaxLL+1];
1328 unsigned litlengthMaxValue = MaxLL, litlengthLog;
1329 size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
1330 RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
1331 RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, "");
1332 RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
1333 ZSTD_buildFSETable( entropy->LLTable,
1334 litlengthNCount, litlengthMaxValue,
1335 LL_base, LL_bits,
1336 litlengthLog,
1337 entropy->workspace, sizeof(entropy->workspace),
1338 /* bmi2 */ 0);
1339 dictPtr += litlengthHeaderSize;
1340 }
1341
1342 RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
1343 { int i;
1344 size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
1345 for (i=0; i<3; i++) {
1346 U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;
1347 RETURN_ERROR_IF(rep==0 || rep > dictContentSize,
1348 dictionary_corrupted, "");
1349 entropy->rep[i] = rep;
1350 } }
1351
1352 return (size_t)(dictPtr - (const BYTE*)dict);
1353}
1354
1355static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1356{
1357 if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
1358 { U32 const magic = MEM_readLE32(dict);
1359 if (magic != ZSTD_MAGIC_DICTIONARY) {
1360 return ZSTD_refDictContent(dctx, dict, dictSize); /* pure content mode */
1361 } }
1362 dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
1363
1364 /* load entropy tables */
1365 { size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
1366 RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
1367 dict = (const char*)dict + eSize;
1368 dictSize -= eSize;
1369 }
1370 dctx->litEntropy = dctx->fseEntropy = 1;
1371
1372 /* reference dictionary content */
1373 return ZSTD_refDictContent(dctx, dict, dictSize);
1374}
1375
1376size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
1377{
1378 assert(dctx != NULL);
1379 dctx->expected = ZSTD_startingInputLength(dctx->format); /* dctx->format must be properly set */
1380 dctx->stage = ZSTDds_getFrameHeaderSize;
1381 dctx->processedCSize = 0;
1382 dctx->decodedSize = 0;
1383 dctx->previousDstEnd = NULL;
1384 dctx->prefixStart = NULL;
1385 dctx->virtualStart = NULL;
1386 dctx->dictEnd = NULL;
1387 dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001); /* cover both little and big endian */
1388 dctx->litEntropy = dctx->fseEntropy = 0;
1389 dctx->dictID = 0;
1390 dctx->bType = bt_reserved;
1391 ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));
1392 ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue)); /* initial repcodes */
1393 dctx->LLTptr = dctx->entropy.LLTable;
1394 dctx->MLTptr = dctx->entropy.MLTable;
1395 dctx->OFTptr = dctx->entropy.OFTable;
1396 dctx->HUFptr = dctx->entropy.hufTable;
1397 return 0;
1398}
1399
1400size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1401{
1402 FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1403 if (dict && dictSize)
1404 RETURN_ERROR_IF(
1405 ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
1406 dictionary_corrupted, "");
1407 return 0;
1408}
1409
1410
1411/* ====== ZSTD_DDict ====== */
1412
1413size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1414{
1415 DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
1416 assert(dctx != NULL);
1417 if (ddict) {
1418 const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
1419 size_t const dictSize = ZSTD_DDict_dictSize(ddict);
1420 const void* const dictEnd = dictStart + dictSize;
1421 dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
1422 DEBUGLOG(4, "DDict is %s",
1423 dctx->ddictIsCold ? "~cold~" : "hot!");
1424 }
1425 FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
1426 if (ddict) { /* NULL ddict is equivalent to no dictionary */
1427 ZSTD_copyDDictParameters(dctx, ddict);
1428 }
1429 return 0;
1430}
1431
1432/*! ZSTD_getDictID_fromDict() :
1433 * Provides the dictID stored within dictionary.
1434 * if @return == 0, the dictionary is not conformant with Zstandard specification.
1435 * It can still be loaded, but as a content-only dictionary. */
1436unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
1437{
1438 if (dictSize < 8) return 0;
1439 if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
1440 return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
1441}
1442
1443/*! ZSTD_getDictID_fromFrame() :
1444 * Provides the dictID required to decompress frame stored within `src`.
1445 * If @return == 0, the dictID could not be decoded.
1446 * This could for one of the following reasons :
1447 * - The frame does not require a dictionary (most common case).
1448 * - The frame was built with dictID intentionally removed.
1449 * Needed dictionary is a hidden information.
1450 * Note : this use case also happens when using a non-conformant dictionary.
1451 * - `srcSize` is too small, and as a result, frame header could not be decoded.
1452 * Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.
1453 * - This is not a Zstandard frame.
1454 * When identifying the exact failure cause, it's possible to use
1455 * ZSTD_getFrameHeader(), which will provide a more precise error code. */
1456unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
1457{
1458 ZSTD_frameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0 };
1459 size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);
1460 if (ZSTD_isError(hError)) return 0;
1461 return zfp.dictID;
1462}
1463
1464
1465/*! ZSTD_decompress_usingDDict() :
1466* Decompression using a pre-digested Dictionary
1467* Use dictionary without significant overhead. */
1468size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
1469 void* dst, size_t dstCapacity,
1470 const void* src, size_t srcSize,
1471 const ZSTD_DDict* ddict)
1472{
1473 /* pass content and size in case legacy frames are encountered */
1474 return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
1475 NULL, 0,
1476 ddict);
1477}
1478
1479
1480/*=====================================
1481* Streaming decompression
1482*====================================*/
1483
1484ZSTD_DStream* ZSTD_createDStream(void)
1485{
1486 DEBUGLOG(3, "ZSTD_createDStream");
1487 return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
1488}
1489
1490ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
1491{
1492 return ZSTD_initStaticDCtx(workspace, workspaceSize);
1493}
1494
1495ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
1496{
1497 return ZSTD_createDCtx_internal(customMem);
1498}
1499
1500size_t ZSTD_freeDStream(ZSTD_DStream* zds)
1501{
1502 return ZSTD_freeDCtx(zds);
1503}
1504
1505
1506/* *** Initialization *** */
1507
1508size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
1509size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
1510
1511size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
1512 const void* dict, size_t dictSize,
1513 ZSTD_dictLoadMethod_e dictLoadMethod,
1514 ZSTD_dictContentType_e dictContentType)
1515{
1516 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1517 ZSTD_clearDict(dctx);
1518 if (dict && dictSize != 0) {
1519 dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
1520 RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
1521 dctx->ddict = dctx->ddictLocal;
1522 dctx->dictUses = ZSTD_use_indefinitely;
1523 }
1524 return 0;
1525}
1526
1527size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1528{
1529 return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);
1530}
1531
1532size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
1533{
1534 return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);
1535}
1536
1537size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
1538{
1539 FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
1540 dctx->dictUses = ZSTD_use_once;
1541 return 0;
1542}
1543
1544size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
1545{
1546 return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
1547}
1548
1549
1550/* ZSTD_initDStream_usingDict() :
1551 * return : expected size, aka ZSTD_startingInputLength().
1552 * this function cannot fail */
1553size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
1554{
1555 DEBUGLOG(4, "ZSTD_initDStream_usingDict");
1556 FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , "");
1557 FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , "");
1558 return ZSTD_startingInputLength(zds->format);
1559}
1560
1561/* note : this variant can't fail */
1562size_t ZSTD_initDStream(ZSTD_DStream* zds)
1563{
1564 DEBUGLOG(4, "ZSTD_initDStream");
1565 return ZSTD_initDStream_usingDDict(zds, NULL);
1566}
1567
1568/* ZSTD_initDStream_usingDDict() :
1569 * ddict will just be referenced, and must outlive decompression session
1570 * this function cannot fail */
1571size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
1572{
1573 FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , "");
1574 FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , "");
1575 return ZSTD_startingInputLength(dctx->format);
1576}
1577
1578/* ZSTD_resetDStream() :
1579 * return : expected size, aka ZSTD_startingInputLength().
1580 * this function cannot fail */
1581size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
1582{
1583 FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), "");
1584 return ZSTD_startingInputLength(dctx->format);
1585}
1586
1587
1588size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
1589{
1590 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1591 ZSTD_clearDict(dctx);
1592 if (ddict) {
1593 dctx->ddict = ddict;
1594 dctx->dictUses = ZSTD_use_indefinitely;
1595 if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) {
1596 if (dctx->ddictSet == NULL) {
1597 dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem);
1598 if (!dctx->ddictSet) {
1599 RETURN_ERROR(memory_allocation, "Failed to allocate memory for hash set!");
1600 }
1601 }
1602 assert(!dctx->staticSize); /* Impossible: ddictSet cannot have been allocated if static dctx */
1603 FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), "");
1604 }
1605 }
1606 return 0;
1607}
1608
1609/* ZSTD_DCtx_setMaxWindowSize() :
1610 * note : no direct equivalence in ZSTD_DCtx_setParameter,
1611 * since this version sets windowSize, and the other sets windowLog */
1612size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
1613{
1614 ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
1615 size_t const min = (size_t)1 << bounds.lowerBound;
1616 size_t const max = (size_t)1 << bounds.upperBound;
1617 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1618 RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, "");
1619 RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, "");
1620 dctx->maxWindowSize = maxWindowSize;
1621 return 0;
1622}
1623
1624size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
1625{
1626 return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);
1627}
1628
1629ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
1630{
1631 ZSTD_bounds bounds = { 0, 0, 0 };
1632 switch(dParam) {
1633 case ZSTD_d_windowLogMax:
1634 bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
1635 bounds.upperBound = ZSTD_WINDOWLOG_MAX;
1636 return bounds;
1637 case ZSTD_d_format:
1638 bounds.lowerBound = (int)ZSTD_f_zstd1;
1639 bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
1640 ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
1641 return bounds;
1642 case ZSTD_d_stableOutBuffer:
1643 bounds.lowerBound = (int)ZSTD_bm_buffered;
1644 bounds.upperBound = (int)ZSTD_bm_stable;
1645 return bounds;
1646 case ZSTD_d_forceIgnoreChecksum:
1647 bounds.lowerBound = (int)ZSTD_d_validateChecksum;
1648 bounds.upperBound = (int)ZSTD_d_ignoreChecksum;
1649 return bounds;
1650 case ZSTD_d_refMultipleDDicts:
1651 bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict;
1652 bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts;
1653 return bounds;
1654 default:;
1655 }
1656 bounds.error = ERROR(parameter_unsupported);
1657 return bounds;
1658}
1659
1660/* ZSTD_dParam_withinBounds:
1661 * @return 1 if value is within dParam bounds,
1662 * 0 otherwise */
1663static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
1664{
1665 ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
1666 if (ZSTD_isError(bounds.error)) return 0;
1667 if (value < bounds.lowerBound) return 0;
1668 if (value > bounds.upperBound) return 0;
1669 return 1;
1670}
1671
1672#define CHECK_DBOUNDS(p,v) { \
1673 RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \
1674}
1675
1676size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
1677{
1678 switch (param) {
1679 case ZSTD_d_windowLogMax:
1680 *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize);
1681 return 0;
1682 case ZSTD_d_format:
1683 *value = (int)dctx->format;
1684 return 0;
1685 case ZSTD_d_stableOutBuffer:
1686 *value = (int)dctx->outBufferMode;
1687 return 0;
1688 case ZSTD_d_forceIgnoreChecksum:
1689 *value = (int)dctx->forceIgnoreChecksum;
1690 return 0;
1691 case ZSTD_d_refMultipleDDicts:
1692 *value = (int)dctx->refMultipleDDicts;
1693 return 0;
1694 default:;
1695 }
1696 RETURN_ERROR(parameter_unsupported, "");
1697}
1698
1699size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
1700{
1701 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1702 switch(dParam) {
1703 case ZSTD_d_windowLogMax:
1704 if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
1705 CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
1706 dctx->maxWindowSize = ((size_t)1) << value;
1707 return 0;
1708 case ZSTD_d_format:
1709 CHECK_DBOUNDS(ZSTD_d_format, value);
1710 dctx->format = (ZSTD_format_e)value;
1711 return 0;
1712 case ZSTD_d_stableOutBuffer:
1713 CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);
1714 dctx->outBufferMode = (ZSTD_bufferMode_e)value;
1715 return 0;
1716 case ZSTD_d_forceIgnoreChecksum:
1717 CHECK_DBOUNDS(ZSTD_d_forceIgnoreChecksum, value);
1718 dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value;
1719 return 0;
1720 case ZSTD_d_refMultipleDDicts:
1721 CHECK_DBOUNDS(ZSTD_d_refMultipleDDicts, value);
1722 if (dctx->staticSize != 0) {
1723 RETURN_ERROR(parameter_unsupported, "Static dctx does not support multiple DDicts!");
1724 }
1725 dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;
1726 return 0;
1727 default:;
1728 }
1729 RETURN_ERROR(parameter_unsupported, "");
1730}
1731
1732size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
1733{
1734 if ( (reset == ZSTD_reset_session_only)
1735 || (reset == ZSTD_reset_session_and_parameters) ) {
1736 dctx->streamStage = zdss_init;
1737 dctx->noForwardProgress = 0;
1738 }
1739 if ( (reset == ZSTD_reset_parameters)
1740 || (reset == ZSTD_reset_session_and_parameters) ) {
1741 RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
1742 ZSTD_clearDict(dctx);
1743 ZSTD_DCtx_resetParameters(dctx);
1744 }
1745 return 0;
1746}
1747
1748
1749size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
1750{
1751 return ZSTD_sizeof_DCtx(dctx);
1752}
1753
1754size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)
1755{
1756 size_t const blockSize = (size_t) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
1757 /* 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*/
1758 unsigned long long const neededRBSize = windowSize + blockSize + ZSTD_BLOCKSIZE_MAX + (WILDCOPY_OVERLENGTH * 2);
1759 unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
1760 size_t const minRBSize = (size_t) neededSize;
1761 RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
1762 frameParameter_windowTooLarge, "");
1763 return minRBSize;
1764}
1765
1766size_t ZSTD_estimateDStreamSize(size_t windowSize)
1767{
1768 size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
1769 size_t const inBuffSize = blockSize; /* no block can be larger */
1770 size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);
1771 return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
1772}
1773
1774size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
1775{
1776 U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX; /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
1777 ZSTD_frameHeader zfh;
1778 size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
1779 if (ZSTD_isError(err)) return err;
1780 RETURN_ERROR_IF(err>0, srcSize_wrong, "");
1781 RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
1782 frameParameter_windowTooLarge, "");
1783 return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
1784}
1785
1786
1787/* ***** Decompression ***** */
1788
1789static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1790{
1791 return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;
1792}
1793
1794static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1795{
1796 if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))
1797 zds->oversizedDuration++;
1798 else
1799 zds->oversizedDuration = 0;
1800}
1801
1802static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
1803{
1804 return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;
1805}
1806
1807/* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */
1808static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
1809{
1810 ZSTD_outBuffer const expect = zds->expectedOutBuffer;
1811 /* No requirement when ZSTD_obm_stable is not enabled. */
1812 if (zds->outBufferMode != ZSTD_bm_stable)
1813 return 0;
1814 /* Any buffer is allowed in zdss_init, this must be the same for every other call until
1815 * the context is reset.
1816 */
1817 if (zds->streamStage == zdss_init)
1818 return 0;
1819 /* The buffer must match our expectation exactly. */
1820 if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)
1821 return 0;
1822 RETURN_ERROR(dstBuffer_wrong, "ZSTD_d_stableOutBuffer enabled but output differs!");
1823}
1824
1825/* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()
1826 * and updates the stage and the output buffer state. This call is extracted so it can be
1827 * used both when reading directly from the ZSTD_inBuffer, and in buffered input mode.
1828 * NOTE: You must break after calling this function since the streamStage is modified.
1829 */
1830static size_t ZSTD_decompressContinueStream(
1831 ZSTD_DStream* zds, char** op, char* oend,
1832 void const* src, size_t srcSize) {
1833 int const isSkipFrame = ZSTD_isSkipFrame(zds);
1834 if (zds->outBufferMode == ZSTD_bm_buffered) {
1835 size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart;
1836 size_t const decodedSize = ZSTD_decompressContinue(zds,
1837 zds->outBuff + zds->outStart, dstSize, src, srcSize);
1838 FORWARD_IF_ERROR(decodedSize, "");
1839 if (!decodedSize && !isSkipFrame) {
1840 zds->streamStage = zdss_read;
1841 } else {
1842 zds->outEnd = zds->outStart + decodedSize;
1843 zds->streamStage = zdss_flush;
1844 }
1845 } else {
1846 /* Write directly into the output buffer */
1847 size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op);
1848 size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize);
1849 FORWARD_IF_ERROR(decodedSize, "");
1850 *op += decodedSize;
1851 /* Flushing is not needed. */
1852 zds->streamStage = zdss_read;
1853 assert(*op <= oend);
1854 assert(zds->outBufferMode == ZSTD_bm_stable);
1855 }
1856 return 0;
1857}
1858
1859size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
1860{
1861 const char* const src = (const char*)input->src;
1862 const char* const istart = input->pos != 0 ? src + input->pos : src;
1863 const char* const iend = input->size != 0 ? src + input->size : src;
1864 const char* ip = istart;
1865 char* const dst = (char*)output->dst;
1866 char* const ostart = output->pos != 0 ? dst + output->pos : dst;
1867 char* const oend = output->size != 0 ? dst + output->size : dst;
1868 char* op = ostart;
1869 U32 someMoreWork = 1;
1870
1871 DEBUGLOG(5, "ZSTD_decompressStream");
1872 RETURN_ERROR_IF(
1873 input->pos > input->size,
1874 srcSize_wrong,
1875 "forbidden. in: pos: %u vs size: %u",
1876 (U32)input->pos, (U32)input->size);
1877 RETURN_ERROR_IF(
1878 output->pos > output->size,
1879 dstSize_tooSmall,
1880 "forbidden. out: pos: %u vs size: %u",
1881 (U32)output->pos, (U32)output->size);
1882 DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
1883 FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");
1884
1885 while (someMoreWork) {
1886 switch(zds->streamStage)
1887 {
1888 case zdss_init :
1889 DEBUGLOG(5, "stage zdss_init => transparent reset ");
1890 zds->streamStage = zdss_loadHeader;
1891 zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
1892 zds->hostageByte = 0;
1893 zds->expectedOutBuffer = *output;
1894 ZSTD_FALLTHROUGH;
1895
1896 case zdss_loadHeader :
1897 DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
1898 { size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
1899 if (zds->refMultipleDDicts && zds->ddictSet) {
1900 ZSTD_DCtx_selectFrameDDict(zds);
1901 }
1902 DEBUGLOG(5, "header size : %u", (U32)hSize);
1903 if (ZSTD_isError(hSize)) {
1904 return hSize; /* error */
1905 }
1906 if (hSize != 0) { /* need more input */
1907 size_t const toLoad = hSize - zds->lhSize; /* if hSize!=0, hSize > zds->lhSize */
1908 size_t const remainingInput = (size_t)(iend-ip);
1909 assert(iend >= ip);
1910 if (toLoad > remainingInput) { /* not enough input to load full header */
1911 if (remainingInput > 0) {
1912 ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);
1913 zds->lhSize += remainingInput;
1914 }
1915 input->pos = input->size;
1916 return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize; /* remaining header bytes + next block header */
1917 }
1918 assert(ip != NULL);
1919 ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;
1920 break;
1921 } }
1922
1923 /* check for single-pass mode opportunity */
1924 if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1925 && zds->fParams.frameType != ZSTD_skippableFrame
1926 && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {
1927 size_t const cSize = ZSTD_findFrameCompressedSize(istart, (size_t)(iend-istart));
1928 if (cSize <= (size_t)(iend-istart)) {
1929 /* shortcut : using single-pass mode */
1930 size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, ZSTD_getDDict(zds));
1931 if (ZSTD_isError(decompressedSize)) return decompressedSize;
1932 DEBUGLOG(4, "shortcut to single-pass ZSTD_decompress_usingDDict()")
1933 ip = istart + cSize;
1934 op += decompressedSize;
1935 zds->expected = 0;
1936 zds->streamStage = zdss_init;
1937 someMoreWork = 0;
1938 break;
1939 } }
1940
1941 /* Check output buffer is large enough for ZSTD_odm_stable. */
1942 if (zds->outBufferMode == ZSTD_bm_stable
1943 && zds->fParams.frameType != ZSTD_skippableFrame
1944 && zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
1945 && (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) {
1946 RETURN_ERROR(dstSize_tooSmall, "ZSTD_obm_stable passed but ZSTD_outBuffer is too small");
1947 }
1948
1949 /* Consume header (see ZSTDds_decodeFrameHeader) */
1950 DEBUGLOG(4, "Consume header");
1951 FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");
1952
1953 if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { /* skippable frame */
1954 zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
1955 zds->stage = ZSTDds_skipFrame;
1956 } else {
1957 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
1958 zds->expected = ZSTD_blockHeaderSize;
1959 zds->stage = ZSTDds_decodeBlockHeader;
1960 }
1961
1962 /* control buffer memory usage */
1963 DEBUGLOG(4, "Control max memory usage (%u KB <= max %u KB)",
1964 (U32)(zds->fParams.windowSize >>10),
1965 (U32)(zds->maxWindowSize >> 10) );
1966 zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
1967 RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
1968 frameParameter_windowTooLarge, "");
1969
1970 /* Adapt buffer sizes to frame header instructions */
1971 { size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);
1972 size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered
1973 ? ZSTD_decodingBufferSize_min(zds->fParams.windowSize, zds->fParams.frameContentSize)
1974 : 0;
1975
1976 ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);
1977
1978 { int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize);
1979 int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);
1980
1981 if (tooSmall || tooLarge) {
1982 size_t const bufferSize = neededInBuffSize + neededOutBuffSize;
1983 DEBUGLOG(4, "inBuff : from %u to %u",
1984 (U32)zds->inBuffSize, (U32)neededInBuffSize);
1985 DEBUGLOG(4, "outBuff : from %u to %u",
1986 (U32)zds->outBuffSize, (U32)neededOutBuffSize);
1987 if (zds->staticSize) { /* static DCtx */
1988 DEBUGLOG(4, "staticSize : %u", (U32)zds->staticSize);
1989 assert(zds->staticSize >= sizeof(ZSTD_DCtx)); /* controlled at init */
1990 RETURN_ERROR_IF(
1991 bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),
1992 memory_allocation, "");
1993 } else {
1994 ZSTD_customFree(zds->inBuff, zds->customMem);
1995 zds->inBuffSize = 0;
1996 zds->outBuffSize = 0;
1997 zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem);
1998 RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, "");
1999 }
2000 zds->inBuffSize = neededInBuffSize;
2001 zds->outBuff = zds->inBuff + zds->inBuffSize;
2002 zds->outBuffSize = neededOutBuffSize;
2003 } } }
2004 zds->streamStage = zdss_read;
2005 ZSTD_FALLTHROUGH;
2006
2007 case zdss_read:
2008 DEBUGLOG(5, "stage zdss_read");
2009 { size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip));
2010 DEBUGLOG(5, "neededInSize = %u", (U32)neededInSize);
2011 if (neededInSize==0) { /* end of frame */
2012 zds->streamStage = zdss_init;
2013 someMoreWork = 0;
2014 break;
2015 }
2016 if ((size_t)(iend-ip) >= neededInSize) { /* decode directly from src */
2017 FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
2018 ip += neededInSize;
2019 /* Function modifies the stage so we must break */
2020 break;
2021 } }
2022 if (ip==iend) { someMoreWork = 0; break; } /* no more input */
2023 zds->streamStage = zdss_load;
2024 ZSTD_FALLTHROUGH;
2025
2026 case zdss_load:
2027 { size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
2028 size_t const toLoad = neededInSize - zds->inPos;
2029 int const isSkipFrame = ZSTD_isSkipFrame(zds);
2030 size_t loadedSize;
2031 /* At this point we shouldn't be decompressing a block that we can stream. */
2032 assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, iend - ip));
2033 if (isSkipFrame) {
2034 loadedSize = MIN(toLoad, (size_t)(iend-ip));
2035 } else {
2036 RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
2037 corruption_detected,
2038 "should never happen");
2039 loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip));
2040 }
2041 ip += loadedSize;
2042 zds->inPos += loadedSize;
2043 if (loadedSize < toLoad) { someMoreWork = 0; break; } /* not enough input, wait for more */
2044
2045 /* decode loaded input */
2046 zds->inPos = 0; /* input is consumed */
2047 FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
2048 /* Function modifies the stage so we must break */
2049 break;
2050 }
2051 case zdss_flush:
2052 { size_t const toFlushSize = zds->outEnd - zds->outStart;
2053 size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toFlushSize);
2054 op += flushedSize;
2055 zds->outStart += flushedSize;
2056 if (flushedSize == toFlushSize) { /* flush completed */
2057 zds->streamStage = zdss_read;
2058 if ( (zds->outBuffSize < zds->fParams.frameContentSize)
2059 && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {
2060 DEBUGLOG(5, "restart filling outBuff from beginning (left:%i, needed:%u)",
2061 (int)(zds->outBuffSize - zds->outStart),
2062 (U32)zds->fParams.blockSizeMax);
2063 zds->outStart = zds->outEnd = 0;
2064 }
2065 break;
2066 } }
2067 /* cannot complete flush */
2068 someMoreWork = 0;
2069 break;
2070
2071 default:
2072 assert(0); /* impossible */
2073 RETURN_ERROR(GENERIC, "impossible to reach"); /* some compiler require default to do something */
2074 } }
2075
2076 /* result */
2077 input->pos = (size_t)(ip - (const char*)(input->src));
2078 output->pos = (size_t)(op - (char*)(output->dst));
2079
2080 /* Update the expected output buffer for ZSTD_obm_stable. */
2081 zds->expectedOutBuffer = *output;
2082
2083 if ((ip==istart) && (op==ostart)) { /* no forward progress */
2084 zds->noForwardProgress ++;
2085 if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
2086 RETURN_ERROR_IF(op==oend, dstSize_tooSmall, "");
2087 RETURN_ERROR_IF(ip==iend, srcSize_wrong, "");
2088 assert(0);
2089 }
2090 } else {
2091 zds->noForwardProgress = 0;
2092 }
2093 { size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
2094 if (!nextSrcSizeHint) { /* frame fully decoded */
2095 if (zds->outEnd == zds->outStart) { /* output fully flushed */
2096 if (zds->hostageByte) {
2097 if (input->pos >= input->size) {
2098 /* can't release hostage (not present) */
2099 zds->streamStage = zdss_read;
2100 return 1;
2101 }
2102 input->pos++; /* release hostage */
2103 } /* zds->hostageByte */
2104 return 0;
2105 } /* zds->outEnd == zds->outStart */
2106 if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */
2107 input->pos--; /* note : pos > 0, otherwise, impossible to finish reading last block */
2108 zds->hostageByte=1;
2109 }
2110 return 1;
2111 } /* nextSrcSizeHint==0 */
2112 nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block); /* preload header of next block */
2113 assert(zds->inPos <= nextSrcSizeHint);
2114 nextSrcSizeHint -= zds->inPos; /* part already loaded*/
2115 return nextSrcSizeHint;
2116 }
2117}
2118
2119size_t ZSTD_decompressStream_simpleArgs (
2120 ZSTD_DCtx* dctx,
2121 void* dst, size_t dstCapacity, size_t* dstPos,
2122 const void* src, size_t srcSize, size_t* srcPos)
2123{
2124 ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
2125 ZSTD_inBuffer input = { src, srcSize, *srcPos };
2126 /* ZSTD_compress_generic() will check validity of dstPos and srcPos */
2127 size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
2128 *dstPos = output.pos;
2129 *srcPos = input.pos;
2130 return cErr;
2131}