1 /*
2 * Copyright (c) 2016-present, Facebook, Inc.
3 * All rights reserved.
4 *
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 */
9
10 #define ZSTD_STATIC_LINKING_ONLY
11 #define ZDICT_STATIC_LINKING_ONLY
12
13 #include <string.h>
14
15 #include "zstd_helpers.h"
16 #include "fuzz_helpers.h"
17 #include "zstd.h"
18 #include "zdict.h"
19
set(ZSTD_CCtx * cctx,ZSTD_cParameter param,int value)20 static void set(ZSTD_CCtx *cctx, ZSTD_cParameter param, int value)
21 {
22 FUZZ_ZASSERT(ZSTD_CCtx_setParameter(cctx, param, value));
23 }
24
setRand(ZSTD_CCtx * cctx,ZSTD_cParameter param,unsigned min,unsigned max,uint32_t * state)25 static void setRand(ZSTD_CCtx *cctx, ZSTD_cParameter param, unsigned min,
26 unsigned max, uint32_t *state) {
27 unsigned const value = FUZZ_rand32(state, min, max);
28 set(cctx, param, value);
29 }
30
FUZZ_randomCParams(size_t srcSize,uint32_t * state)31 ZSTD_compressionParameters FUZZ_randomCParams(size_t srcSize, uint32_t *state)
32 {
33 /* Select compression parameters */
34 ZSTD_compressionParameters cParams;
35 cParams.windowLog = FUZZ_rand32(state, ZSTD_WINDOWLOG_MIN, 15);
36 cParams.hashLog = FUZZ_rand32(state, ZSTD_HASHLOG_MIN, 15);
37 cParams.chainLog = FUZZ_rand32(state, ZSTD_CHAINLOG_MIN, 16);
38 cParams.searchLog = FUZZ_rand32(state, ZSTD_SEARCHLOG_MIN, 9);
39 cParams.minMatch = FUZZ_rand32(state, ZSTD_MINMATCH_MIN,
40 ZSTD_MINMATCH_MAX);
41 cParams.targetLength = FUZZ_rand32(state, 0, 512);
42 cParams.strategy = FUZZ_rand32(state, ZSTD_STRATEGY_MIN, ZSTD_STRATEGY_MAX);
43 return ZSTD_adjustCParams(cParams, srcSize, 0);
44 }
45
FUZZ_randomFParams(uint32_t * state)46 ZSTD_frameParameters FUZZ_randomFParams(uint32_t *state)
47 {
48 /* Select frame parameters */
49 ZSTD_frameParameters fParams;
50 fParams.contentSizeFlag = FUZZ_rand32(state, 0, 1);
51 fParams.checksumFlag = FUZZ_rand32(state, 0, 1);
52 fParams.noDictIDFlag = FUZZ_rand32(state, 0, 1);
53 return fParams;
54 }
55
FUZZ_randomParams(size_t srcSize,uint32_t * state)56 ZSTD_parameters FUZZ_randomParams(size_t srcSize, uint32_t *state)
57 {
58 ZSTD_parameters params;
59 params.cParams = FUZZ_randomCParams(srcSize, state);
60 params.fParams = FUZZ_randomFParams(state);
61 return params;
62 }
63
FUZZ_setRandomParameters(ZSTD_CCtx * cctx,size_t srcSize,uint32_t * state)64 void FUZZ_setRandomParameters(ZSTD_CCtx *cctx, size_t srcSize, uint32_t *state)
65 {
66 ZSTD_compressionParameters cParams = FUZZ_randomCParams(srcSize, state);
67 set(cctx, ZSTD_c_windowLog, cParams.windowLog);
68 set(cctx, ZSTD_c_hashLog, cParams.hashLog);
69 set(cctx, ZSTD_c_chainLog, cParams.chainLog);
70 set(cctx, ZSTD_c_searchLog, cParams.searchLog);
71 set(cctx, ZSTD_c_minMatch, cParams.minMatch);
72 set(cctx, ZSTD_c_targetLength, cParams.targetLength);
73 set(cctx, ZSTD_c_strategy, cParams.strategy);
74 /* Select frame parameters */
75 setRand(cctx, ZSTD_c_contentSizeFlag, 0, 1, state);
76 setRand(cctx, ZSTD_c_checksumFlag, 0, 1, state);
77 setRand(cctx, ZSTD_c_dictIDFlag, 0, 1, state);
78 /* Select long distance matching parameters */
79 setRand(cctx, ZSTD_c_enableLongDistanceMatching, 0, 1, state);
80 setRand(cctx, ZSTD_c_ldmHashLog, ZSTD_HASHLOG_MIN, 16, state);
81 setRand(cctx, ZSTD_c_ldmMinMatch, ZSTD_LDM_MINMATCH_MIN,
82 ZSTD_LDM_MINMATCH_MAX, state);
83 setRand(cctx, ZSTD_c_ldmBucketSizeLog, 0, ZSTD_LDM_BUCKETSIZELOG_MAX,
84 state);
85 setRand(cctx, ZSTD_c_ldmHashRateLog, ZSTD_LDM_HASHRATELOG_MIN,
86 ZSTD_LDM_HASHRATELOG_MAX, state);
87 /* Set misc parameters */
88 setRand(cctx, ZSTD_c_nbWorkers, 0, 2, state);
89 setRand(cctx, ZSTD_c_rsyncable, 0, 1, state);
90 setRand(cctx, ZSTD_c_forceMaxWindow, 0, 1, state);
91 setRand(cctx, ZSTD_c_literalCompressionMode, 0, 2, state);
92 setRand(cctx, ZSTD_c_forceAttachDict, 0, 2, state);
93 }
94
FUZZ_train(void const * src,size_t srcSize,uint32_t * state)95 FUZZ_dict_t FUZZ_train(void const* src, size_t srcSize, uint32_t *state)
96 {
97 size_t const dictSize = MAX(srcSize / 8, 1024);
98 size_t const totalSampleSize = dictSize * 11;
99 FUZZ_dict_t dict = { malloc(dictSize), dictSize };
100 char* const samples = (char*)malloc(totalSampleSize);
101 unsigned nbSamples = 100;
102 size_t* const samplesSizes = (size_t*)malloc(sizeof(size_t) * nbSamples);
103 size_t pos = 0;
104 size_t sample = 0;
105 ZDICT_fastCover_params_t params;
106 FUZZ_ASSERT(dict.buff && samples && samplesSizes);
107
108 for (sample = 0; sample < nbSamples; ++sample) {
109 size_t const remaining = totalSampleSize - pos;
110 size_t const offset = FUZZ_rand32(state, 0, MAX(srcSize, 1) - 1);
111 size_t const limit = MIN(srcSize - offset, remaining);
112 size_t const toCopy = MIN(limit, remaining / (nbSamples - sample));
113 memcpy(samples + pos, src + offset, toCopy);
114 pos += toCopy;
115 samplesSizes[sample] = toCopy;
116
117 }
118 memset(samples + pos, 0, totalSampleSize - pos);
119
120 memset(¶ms, 0, sizeof(params));
121 params.accel = 5;
122 params.k = 40;
123 params.d = 8;
124 params.f = 14;
125 params.zParams.compressionLevel = 1;
126 dict.size = ZDICT_trainFromBuffer_fastCover(dict.buff, dictSize,
127 samples, samplesSizes, nbSamples, params);
128 if (ZSTD_isError(dict.size)) {
129 free(dict.buff);
130 memset(&dict, 0, sizeof(dict));
131 }
132
133 free(samplesSizes);
134 free(samples);
135
136 return dict;
137 }
138