zstd_ddict.c File Reference

#include <string.h>
#include "cpu.h"
#include "mem.h"
#include "fse.h"
#include "huf.h"
#include "zstd_decompress_internal.h"
#include "zstd_ddict.h"

Include dependency graph for zstd_ddict.c:

Go to the source code of this file.

Classes
struct	ZSTD_DDict_s

Macros
#define	FSE_STATIC_LINKING_ONLY
#define	HUF_STATIC_LINKING_ONLY

Functions
const void *	ZSTD_DDict_dictContent (const ZSTD_DDict *ddict)
size_t	ZSTD_DDict_dictSize (const ZSTD_DDict *ddict)
void	ZSTD_copyDDictParameters (ZSTD_DCtx *dctx, const ZSTD_DDict *ddict)
static size_t	ZSTD_loadEntropy_intoDDict (ZSTD_DDict *ddict, ZSTD_dictContentType_e dictContentType)
static size_t	ZSTD_initDDict_internal (ZSTD_DDict *ddict, const void *dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
ZSTD_DDict *	ZSTD_createDDict_advanced (const void *dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType, ZSTD_customMem customMem)
ZSTD_DDict *	ZSTD_createDDict (const void *dict, size_t dictSize)
ZSTD_DDict *	ZSTD_createDDict_byReference (const void *dictBuffer, size_t dictSize)
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	ZSTD_freeDDict (ZSTD_DDict *ddict)
size_t	ZSTD_estimateDDictSize (size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
size_t	ZSTD_sizeof_DDict (const ZSTD_DDict *ddict)
unsigned	ZSTD_getDictID_fromDDict (const ZSTD_DDict *ddict)

Macro Definition Documentation

FSE_STATIC_LINKING_ONLY

#define FSE_STATIC_LINKING_ONLY

Definition at line 20 of file zstd_ddict.c.

HUF_STATIC_LINKING_ONLY

#define HUF_STATIC_LINKING_ONLY

Definition at line 22 of file zstd_ddict.c.

Function Documentation

ZSTD_copyDDictParameters()

void ZSTD_copyDDictParameters	(	ZSTD_DCtx *	dctx,
		const ZSTD_DDict *	ddict
	)

Definition at line 58 of file zstd_ddict.c.

{
    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;
    }
}

Referenced by ZSTD_decompressBegin_usingDDict().

ZSTD_createDDict()

ZSTD_DDict * ZSTD_createDDict	(	const void *	dict,
		size_t	dictSize
	)

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

Definition at line 170 of file zstd_ddict.c.

{
    ZSTD_customMem const allocator = { NULL, NULL, NULL };
    return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
}

ZSTD_createDDict_advanced()

ZSTD_DDict * ZSTD_createDDict_advanced	(	const void *	dict,
		size_t	dictSize,
		ZSTD_dictLoadMethod_e	dictLoadMethod,
		ZSTD_dictContentType_e	dictContentType,
		ZSTD_customMem	customMem
	)

Definition at line 145 of file zstd_ddict.c.

{
    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;
 
    {   ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_malloc(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;
    }
}

Referenced by ZSTD_createDDict(), ZSTD_createDDict_byReference(), and ZSTD_DCtx_loadDictionary_advanced().

ZSTD_createDDict_byReference()

ZSTD_DDict * ZSTD_createDDict_byReference	(	const void *	dictBuffer,
		size_t	dictSize
	)

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)

Definition at line 180 of file zstd_ddict.c.

{
    ZSTD_customMem const allocator = { NULL, NULL, NULL };
    return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
}

ZSTD_DDict_dictContent()

const void * ZSTD_DDict_dictContent

(

const ZSTD_DDict *

ddict

)

Definition at line 46 of file zstd_ddict.c.

{
    assert(ddict != NULL);
    return ddict->dictContent;
}

Referenced by ZSTD_decompressBegin_usingDDict(), ZSTD_decompressMultiFrame(), and ZSTD_decompressStream().

ZSTD_DDict_dictSize()

size_t ZSTD_DDict_dictSize

(

const ZSTD_DDict *

ddict

)

Definition at line 52 of file zstd_ddict.c.

{
    assert(ddict != NULL);
    return ddict->dictSize;
}

Referenced by ZSTD_decompressBegin_usingDDict(), ZSTD_decompressMultiFrame(), and ZSTD_decompressStream().

ZSTD_estimateDDictSize()

size_t ZSTD_estimateDDictSize	(	size_t	dictSize,
		ZSTD_dictLoadMethod_e	dictLoadMethod
	)

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

Definition at line 225 of file zstd_ddict.c.

{
    return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
}

ZSTD_freeDDict()

size_t ZSTD_freeDDict

(

ZSTD_DDict *

ddict

)

ZSTD_freeDDict() : Function frees memory allocated with ZSTD_createDDict()

Definition at line 212 of file zstd_ddict.c.

{
    if (ddict==NULL) return 0;   /* support free on NULL */
    {   ZSTD_customMem const cMem = ddict->cMem;
        ZSTD_free(ddict->dictBuffer, cMem);
        ZSTD_free(ddict, cMem);
        return 0;
    }
}

Referenced by ZSTD_clearDict(), and ZSTD_createDDict_advanced().

ZSTD_getDictID_fromDDict()

unsigned ZSTD_getDictID_fromDDict

(

const ZSTD_DDict *

ddict

)

ZSTD_getDictID_fromDDict() : Provides the dictID of the dictionary loaded into ddict. If

Returns

== 0, the dictionary is not conformant to Zstandard specification, or empty. Non-conformant dictionaries can still be loaded, but as content-only dictionaries.

Definition at line 240 of file zstd_ddict.c.

{
    if (ddict==NULL) return 0;
    return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
}

ZSTD_initDDict_internal()

static size_t ZSTD_initDDict_internal ( ZSTD_DDict *  ddict, const void *  dict, size_t  dictSize, ZSTD_dictLoadMethod_e  dictLoadMethod, ZSTD_dictContentType_e  dictContentType  )

static

Definition at line 120 of file zstd_ddict.c.

{
    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
        ddict->dictBuffer = NULL;
        ddict->dictContent = dict;
        if (!dict) dictSize = 0;
    } else {
        void* const internalBuffer = ZSTD_malloc(dictSize, ddict->cMem);
        ddict->dictBuffer = internalBuffer;
        ddict->dictContent = internalBuffer;
        if (!internalBuffer) return ERROR(memory_allocation);
        memcpy(internalBuffer, dict, dictSize);
    }
    ddict->dictSize = dictSize;
    ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001);  /* cover both little and big endian */
 
    /* parse dictionary content */
    FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) , "");
 
    return 0;
}

Referenced by ZSTD_createDDict_advanced(), and ZSTD_initStaticDDict().

ZSTD_initStaticDDict()

const ZSTD_DDict * ZSTD_initStaticDDict	(	void *	sBuffer,
		size_t	sBufferSize,
		const void *	dict,
		size_t	dictSize,
		ZSTD_dictLoadMethod_e	dictLoadMethod,
		ZSTD_dictContentType_e	dictContentType
	)

Definition at line 187 of file zstd_ddict.c.

{
    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) {
        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;
}

ZSTD_loadEntropy_intoDDict()

static size_t ZSTD_loadEntropy_intoDDict ( ZSTD_DDict *  ddict, ZSTD_dictContentType_e  dictContentType  )

static

Definition at line 90 of file zstd_ddict.c.

{
    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;
}

Referenced by ZSTD_initDDict_internal().

ZSTD_sizeof_DDict()

size_t ZSTD_sizeof_DDict

(

const ZSTD_DDict *

ddict

)

Definition at line 230 of file zstd_ddict.c.

{
    if (ddict==NULL) return 0;   /* support sizeof on NULL */
    return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
}

Referenced by ZSTD_sizeof_DCtx().