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