brintos / linux-shallow public Read only

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