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