mirror of
https://github.com/facebook/zstd.git
synced 2025-10-06 00:04:13 -04:00
d7841d150b
Currently this function actually reads the dict ID from the dictionary's header, via `ZSTD_getDictID_fromDict()`. But during decompression the decomp- ressor actually compares the dict ID in the frame header with the dict ID in the DDict. Now of course the dict ID in the dictionary contents and the dict ID in the DDict struct *should* be the same. But in cases of memory corrupt- ion, where they can drift out of sync, it's misleading for this function to read it again from the dict buffer rather then return the dict ID that will actually be used. Also doing it this way avoids rechecking the magic and so on and so it is a tiny bit more efficient.
245 lines
8.9 KiB
C
245 lines
8.9 KiB
C
/*
|
|
* Copyright (c) Yann Collet, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under both the BSD-style license (found in the
|
|
* LICENSE file in the root directory of this source tree) and the GPLv2 (found
|
|
* in the COPYING file in the root directory of this source tree).
|
|
* You may select, at your option, one of the above-listed licenses.
|
|
*/
|
|
|
|
/* zstd_ddict.c :
|
|
* concentrates all logic that needs to know the internals of ZSTD_DDict object */
|
|
|
|
/*-*******************************************************
|
|
* Dependencies
|
|
*********************************************************/
|
|
#include "../common/zstd_deps.h" /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
|
|
#include "../common/cpu.h" /* bmi2 */
|
|
#include "../common/mem.h" /* low level memory routines */
|
|
#define FSE_STATIC_LINKING_ONLY
|
|
#include "../common/fse.h"
|
|
#define HUF_STATIC_LINKING_ONLY
|
|
#include "../common/huf.h"
|
|
#include "zstd_decompress_internal.h"
|
|
#include "zstd_ddict.h"
|
|
|
|
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
|
|
# include "../legacy/zstd_legacy.h"
|
|
#endif
|
|
|
|
|
|
|
|
/*-*******************************************************
|
|
* Types
|
|
*********************************************************/
|
|
struct ZSTD_DDict_s {
|
|
void* dictBuffer;
|
|
const void* dictContent;
|
|
size_t dictSize;
|
|
ZSTD_entropyDTables_t entropy;
|
|
U32 dictID;
|
|
U32 entropyPresent;
|
|
ZSTD_customMem cMem;
|
|
}; /* typedef'd to ZSTD_DDict within "zstd.h" */
|
|
|
|
const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)
|
|
{
|
|
assert(ddict != NULL);
|
|
return ddict->dictContent;
|
|
}
|
|
|
|
size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)
|
|
{
|
|
assert(ddict != NULL);
|
|
return ddict->dictSize;
|
|
}
|
|
|
|
void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
|
|
{
|
|
DEBUGLOG(4, "ZSTD_copyDDictParameters");
|
|
assert(dctx != NULL);
|
|
assert(ddict != NULL);
|
|
dctx->dictID = ddict->dictID;
|
|
dctx->prefixStart = ddict->dictContent;
|
|
dctx->virtualStart = ddict->dictContent;
|
|
dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
|
|
dctx->previousDstEnd = dctx->dictEnd;
|
|
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
|
|
dctx->dictContentBeginForFuzzing = dctx->prefixStart;
|
|
dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
|
|
#endif
|
|
if (ddict->entropyPresent) {
|
|
dctx->litEntropy = 1;
|
|
dctx->fseEntropy = 1;
|
|
dctx->LLTptr = ddict->entropy.LLTable;
|
|
dctx->MLTptr = ddict->entropy.MLTable;
|
|
dctx->OFTptr = ddict->entropy.OFTable;
|
|
dctx->HUFptr = ddict->entropy.hufTable;
|
|
dctx->entropy.rep[0] = ddict->entropy.rep[0];
|
|
dctx->entropy.rep[1] = ddict->entropy.rep[1];
|
|
dctx->entropy.rep[2] = ddict->entropy.rep[2];
|
|
} else {
|
|
dctx->litEntropy = 0;
|
|
dctx->fseEntropy = 0;
|
|
}
|
|
}
|
|
|
|
|
|
static size_t
|
|
ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
|
|
ZSTD_dictContentType_e dictContentType)
|
|
{
|
|
ddict->dictID = 0;
|
|
ddict->entropyPresent = 0;
|
|
if (dictContentType == ZSTD_dct_rawContent) return 0;
|
|
|
|
if (ddict->dictSize < 8) {
|
|
if (dictContentType == ZSTD_dct_fullDict)
|
|
return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
|
|
return 0; /* pure content mode */
|
|
}
|
|
{ U32 const magic = MEM_readLE32(ddict->dictContent);
|
|
if (magic != ZSTD_MAGIC_DICTIONARY) {
|
|
if (dictContentType == ZSTD_dct_fullDict)
|
|
return ERROR(dictionary_corrupted); /* only accept specified dictionaries */
|
|
return 0; /* pure content mode */
|
|
}
|
|
}
|
|
ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);
|
|
|
|
/* load entropy tables */
|
|
RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy(
|
|
&ddict->entropy, ddict->dictContent, ddict->dictSize)),
|
|
dictionary_corrupted, "");
|
|
ddict->entropyPresent = 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
|
|
const void* dict, size_t dictSize,
|
|
ZSTD_dictLoadMethod_e dictLoadMethod,
|
|
ZSTD_dictContentType_e dictContentType)
|
|
{
|
|
if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
|
|
ddict->dictBuffer = NULL;
|
|
ddict->dictContent = dict;
|
|
if (!dict) dictSize = 0;
|
|
} else {
|
|
void* const internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem);
|
|
ddict->dictBuffer = internalBuffer;
|
|
ddict->dictContent = internalBuffer;
|
|
if (!internalBuffer) return ERROR(memory_allocation);
|
|
ZSTD_memcpy(internalBuffer, dict, dictSize);
|
|
}
|
|
ddict->dictSize = dictSize;
|
|
ddict->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001); /* cover both little and big endian */
|
|
|
|
/* parse dictionary content */
|
|
FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) , "");
|
|
|
|
return 0;
|
|
}
|
|
|
|
ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
|
|
ZSTD_dictLoadMethod_e dictLoadMethod,
|
|
ZSTD_dictContentType_e dictContentType,
|
|
ZSTD_customMem customMem)
|
|
{
|
|
if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
|
|
|
|
{ ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_customMalloc(sizeof(ZSTD_DDict), customMem);
|
|
if (ddict == NULL) return NULL;
|
|
ddict->cMem = customMem;
|
|
{ size_t const initResult = ZSTD_initDDict_internal(ddict,
|
|
dict, dictSize,
|
|
dictLoadMethod, dictContentType);
|
|
if (ZSTD_isError(initResult)) {
|
|
ZSTD_freeDDict(ddict);
|
|
return NULL;
|
|
} }
|
|
return ddict;
|
|
}
|
|
}
|
|
|
|
/*! ZSTD_createDDict() :
|
|
* Create a digested dictionary, to start decompression without startup delay.
|
|
* `dict` content is copied inside DDict.
|
|
* Consequently, `dict` can be released after `ZSTD_DDict` creation */
|
|
ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
|
|
{
|
|
ZSTD_customMem const allocator = { NULL, NULL, NULL };
|
|
return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
|
|
}
|
|
|
|
/*! ZSTD_createDDict_byReference() :
|
|
* Create a digested dictionary, to start decompression without startup delay.
|
|
* Dictionary content is simply referenced, it will be accessed during decompression.
|
|
* Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
|
|
ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
|
|
{
|
|
ZSTD_customMem const allocator = { NULL, NULL, NULL };
|
|
return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
|
|
}
|
|
|
|
|
|
const ZSTD_DDict* ZSTD_initStaticDDict(
|
|
void* sBuffer, size_t sBufferSize,
|
|
const void* dict, size_t dictSize,
|
|
ZSTD_dictLoadMethod_e dictLoadMethod,
|
|
ZSTD_dictContentType_e dictContentType)
|
|
{
|
|
size_t const neededSpace = sizeof(ZSTD_DDict)
|
|
+ (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
|
|
ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
|
|
assert(sBuffer != NULL);
|
|
assert(dict != NULL);
|
|
if ((size_t)sBuffer & 7) return NULL; /* 8-aligned */
|
|
if (sBufferSize < neededSpace) return NULL;
|
|
if (dictLoadMethod == ZSTD_dlm_byCopy) {
|
|
ZSTD_memcpy(ddict+1, dict, dictSize); /* local copy */
|
|
dict = ddict+1;
|
|
}
|
|
if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
|
|
dict, dictSize,
|
|
ZSTD_dlm_byRef, dictContentType) ))
|
|
return NULL;
|
|
return ddict;
|
|
}
|
|
|
|
|
|
size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
|
|
{
|
|
if (ddict==NULL) return 0; /* support free on NULL */
|
|
{ ZSTD_customMem const cMem = ddict->cMem;
|
|
ZSTD_customFree(ddict->dictBuffer, cMem);
|
|
ZSTD_customFree(ddict, cMem);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*! ZSTD_estimateDDictSize() :
|
|
* Estimate amount of memory that will be needed to create a dictionary for decompression.
|
|
* Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
|
|
size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
|
|
{
|
|
return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
|
|
}
|
|
|
|
size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
|
|
{
|
|
if (ddict==NULL) return 0; /* support sizeof on NULL */
|
|
return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
|
|
}
|
|
|
|
/*! ZSTD_getDictID_fromDDict() :
|
|
* Provides the dictID of the dictionary loaded into `ddict`.
|
|
* If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
|
|
* Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
|
|
unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
|
|
{
|
|
if (ddict==NULL) return 0;
|
|
return ddict->dictID;
|
|
}
|