2 * Copyright (c) Meta Platforms, Inc. and affiliates.
5 * This source code is licensed under both the BSD-style license (found in the
6 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7 * in the COPYING file in the root directory of this source tree).
8 * You may select, at your option, one of the above-listed licenses.
16 #define ZSTD_STATIC_LINKING_ONLY
19 #define MIN(x, y) ((x) < (y) ? (x) : (y))
21 static char const* g_zstdcli = NULL;
23 void method_set_zstdcli(char const* zstdcli) {
28 * Macro to get a pointer of type, given ptr, which is a member variable with
29 * the given name, member.
31 * method_state_t* base = ...;
32 * buffer_state_t* state = container_of(base, buffer_state_t, base);
34 #define container_of(ptr, type, member) \
35 ((type*)(ptr == NULL ? NULL : (char*)(ptr)-offsetof(type, member)))
37 /** State to reuse the same buffers between compression calls. */
40 data_buffers_t inputs; /**< The input buffer for each file. */
41 data_buffer_t dictionary; /**< The dictionary. */
42 data_buffer_t compressed; /**< The compressed data buffer. */
43 data_buffer_t decompressed; /**< The decompressed data buffer. */
46 static size_t buffers_max_size(data_buffers_t buffers) {
48 for (size_t i = 0; i < buffers.size; ++i) {
49 if (buffers.buffers[i].size > max)
50 max = buffers.buffers[i].size;
55 static method_state_t* buffer_state_create(data_t const* data) {
56 buffer_state_t* state = (buffer_state_t*)calloc(1, sizeof(buffer_state_t));
59 state->base.data = data;
60 state->inputs = data_buffers_get(data);
61 state->dictionary = data_buffer_get_dict(data);
62 size_t const max_size = buffers_max_size(state->inputs);
63 state->compressed = data_buffer_create(ZSTD_compressBound(max_size));
64 state->decompressed = data_buffer_create(max_size);
68 static void buffer_state_destroy(method_state_t* base) {
71 buffer_state_t* state = container_of(base, buffer_state_t, base);
75 static int buffer_state_bad(
76 buffer_state_t const* state,
77 config_t const* config) {
79 fprintf(stderr, "buffer_state_t is NULL\n");
82 if (state->inputs.size == 0 || state->compressed.data == NULL ||
83 state->decompressed.data == NULL) {
84 fprintf(stderr, "buffer state allocation failure\n");
87 if (config->use_dictionary && state->dictionary.data == NULL) {
88 fprintf(stderr, "dictionary loading failed\n");
94 static result_t simple_compress(method_state_t* base, config_t const* config) {
95 buffer_state_t* state = container_of(base, buffer_state_t, base);
97 if (buffer_state_bad(state, config))
98 return result_error(result_error_system_error);
100 /* Keep the tests short by skipping directories, since behavior shouldn't
103 if (base->data->type != data_type_file)
104 return result_error(result_error_skip);
106 if (config->advanced_api_only)
107 return result_error(result_error_skip);
109 if (config->use_dictionary || config->no_pledged_src_size)
110 return result_error(result_error_skip);
112 /* If the config doesn't specify a level, skip. */
113 int const level = config_get_level(config);
114 if (level == CONFIG_NO_LEVEL)
115 return result_error(result_error_skip);
117 data_buffer_t const input = state->inputs.buffers[0];
119 /* Compress, decompress, and check the result. */
120 state->compressed.size = ZSTD_compress(
121 state->compressed.data,
122 state->compressed.capacity,
126 if (ZSTD_isError(state->compressed.size))
127 return result_error(result_error_compression_error);
129 state->decompressed.size = ZSTD_decompress(
130 state->decompressed.data,
131 state->decompressed.capacity,
132 state->compressed.data,
133 state->compressed.size);
134 if (ZSTD_isError(state->decompressed.size))
135 return result_error(result_error_decompression_error);
136 if (data_buffer_compare(input, state->decompressed))
137 return result_error(result_error_round_trip_error);
140 data.total_size = state->compressed.size;
141 return result_data(data);
144 static result_t compress_cctx_compress(
145 method_state_t* base,
146 config_t const* config) {
147 buffer_state_t* state = container_of(base, buffer_state_t, base);
149 if (buffer_state_bad(state, config))
150 return result_error(result_error_system_error);
152 if (config->no_pledged_src_size)
153 return result_error(result_error_skip);
155 if (base->data->type != data_type_dir)
156 return result_error(result_error_skip);
158 if (config->advanced_api_only)
159 return result_error(result_error_skip);
161 int const level = config_get_level(config);
163 ZSTD_CCtx* cctx = ZSTD_createCCtx();
164 ZSTD_DCtx* dctx = ZSTD_createDCtx();
165 if (cctx == NULL || dctx == NULL) {
166 fprintf(stderr, "context creation failed\n");
167 return result_error(result_error_system_error);
171 result_data_t data = {.total_size = 0};
172 for (size_t i = 0; i < state->inputs.size; ++i) {
173 data_buffer_t const input = state->inputs.buffers[i];
174 ZSTD_parameters const params =
175 config_get_zstd_params(config, input.size, state->dictionary.size);
177 if (level == CONFIG_NO_LEVEL)
178 state->compressed.size = ZSTD_compress_advanced(
180 state->compressed.data,
181 state->compressed.capacity,
184 config->use_dictionary ? state->dictionary.data : NULL,
185 config->use_dictionary ? state->dictionary.size : 0,
187 else if (config->use_dictionary)
188 state->compressed.size = ZSTD_compress_usingDict(
190 state->compressed.data,
191 state->compressed.capacity,
194 state->dictionary.data,
195 state->dictionary.size,
198 state->compressed.size = ZSTD_compressCCtx(
200 state->compressed.data,
201 state->compressed.capacity,
206 if (ZSTD_isError(state->compressed.size)) {
207 result = result_error(result_error_compression_error);
211 if (config->use_dictionary)
212 state->decompressed.size = ZSTD_decompress_usingDict(
214 state->decompressed.data,
215 state->decompressed.capacity,
216 state->compressed.data,
217 state->compressed.size,
218 state->dictionary.data,
219 state->dictionary.size);
221 state->decompressed.size = ZSTD_decompressDCtx(
223 state->decompressed.data,
224 state->decompressed.capacity,
225 state->compressed.data,
226 state->compressed.size);
227 if (ZSTD_isError(state->decompressed.size)) {
228 result = result_error(result_error_decompression_error);
231 if (data_buffer_compare(input, state->decompressed)) {
232 result = result_error(result_error_round_trip_error);
236 data.total_size += state->compressed.size;
239 result = result_data(data);
246 /** Generic state creation function. */
247 static method_state_t* method_state_create(data_t const* data) {
248 method_state_t* state = (method_state_t*)malloc(sizeof(method_state_t));
255 static void method_state_destroy(method_state_t* state) {
259 static result_t cli_compress(method_state_t* state, config_t const* config) {
260 if (config->cli_args == NULL)
261 return result_error(result_error_skip);
263 if (config->advanced_api_only)
264 return result_error(result_error_skip);
266 /* We don't support no pledged source size with directories. Too slow. */
267 if (state->data->type == data_type_dir && config->no_pledged_src_size)
268 return result_error(result_error_skip);
270 if (g_zstdcli == NULL)
271 return result_error(result_error_system_error);
273 /* '<zstd>' -cqr <args> [-D '<dict>'] '<file/dir>' */
275 size_t const cmd_size = snprintf(
278 "'%s' -cqr %s %s%s%s %s '%s'",
281 config->use_dictionary ? "-D '" : "",
282 config->use_dictionary ? state->data->dict.path : "",
283 config->use_dictionary ? "'" : "",
284 config->no_pledged_src_size ? "<" : "",
285 state->data->data.path);
286 if (cmd_size >= sizeof(cmd)) {
287 fprintf(stderr, "command too large: %s\n", cmd);
288 return result_error(result_error_system_error);
290 FILE* zstd = popen(cmd, "r");
292 fprintf(stderr, "failed to popen command: %s\n", cmd);
293 return result_error(result_error_system_error);
297 size_t total_size = 0;
299 size_t const size = fread(out, 1, sizeof(out), zstd);
301 if (size != sizeof(out))
304 if (ferror(zstd) || pclose(zstd) != 0) {
305 fprintf(stderr, "zstd failed with command: %s\n", cmd);
306 return result_error(result_error_compression_error);
309 result_data_t const data = {.total_size = total_size};
310 return result_data(data);
313 static int advanced_config(
315 buffer_state_t* state,
316 config_t const* config) {
317 ZSTD_CCtx_reset(cctx, ZSTD_reset_session_and_parameters);
318 for (size_t p = 0; p < config->param_values.size; ++p) {
319 param_value_t const pv = config->param_values.data[p];
320 if (ZSTD_isError(ZSTD_CCtx_setParameter(cctx, pv.param, pv.value))) {
324 if (config->use_dictionary) {
325 if (ZSTD_isError(ZSTD_CCtx_loadDictionary(
326 cctx, state->dictionary.data, state->dictionary.size))) {
333 static result_t advanced_one_pass_compress_output_adjustment(
334 method_state_t* base,
335 config_t const* config,
336 size_t const subtract) {
337 buffer_state_t* state = container_of(base, buffer_state_t, base);
339 if (buffer_state_bad(state, config))
340 return result_error(result_error_system_error);
342 ZSTD_CCtx* cctx = ZSTD_createCCtx();
345 if (!cctx || advanced_config(cctx, state, config)) {
346 result = result_error(result_error_compression_error);
350 result_data_t data = {.total_size = 0};
351 for (size_t i = 0; i < state->inputs.size; ++i) {
352 data_buffer_t const input = state->inputs.buffers[i];
354 if (!config->no_pledged_src_size) {
355 if (ZSTD_isError(ZSTD_CCtx_setPledgedSrcSize(cctx, input.size))) {
356 result = result_error(result_error_compression_error);
360 size_t const size = ZSTD_compress2(
362 state->compressed.data,
363 ZSTD_compressBound(input.size) - subtract,
366 if (ZSTD_isError(size)) {
367 result = result_error(result_error_compression_error);
370 data.total_size += size;
373 result = result_data(data);
379 static result_t advanced_one_pass_compress(
380 method_state_t* base,
381 config_t const* config) {
382 return advanced_one_pass_compress_output_adjustment(base, config, 0);
385 static result_t advanced_one_pass_compress_small_output(
386 method_state_t* base,
387 config_t const* config) {
388 return advanced_one_pass_compress_output_adjustment(base, config, 1);
391 static result_t advanced_streaming_compress(
392 method_state_t* base,
393 config_t const* config) {
394 buffer_state_t* state = container_of(base, buffer_state_t, base);
396 if (buffer_state_bad(state, config))
397 return result_error(result_error_system_error);
399 ZSTD_CCtx* cctx = ZSTD_createCCtx();
402 if (!cctx || advanced_config(cctx, state, config)) {
403 result = result_error(result_error_compression_error);
407 result_data_t data = {.total_size = 0};
408 for (size_t i = 0; i < state->inputs.size; ++i) {
409 data_buffer_t input = state->inputs.buffers[i];
411 if (!config->no_pledged_src_size) {
412 if (ZSTD_isError(ZSTD_CCtx_setPledgedSrcSize(cctx, input.size))) {
413 result = result_error(result_error_compression_error);
418 while (input.size > 0) {
419 ZSTD_inBuffer in = {input.data, MIN(input.size, 4096)};
420 input.data += in.size;
421 input.size -= in.size;
422 ZSTD_EndDirective const op =
423 input.size > 0 ? ZSTD_e_continue : ZSTD_e_end;
425 while (in.pos < in.size || (op == ZSTD_e_end && ret != 0)) {
426 ZSTD_outBuffer out = {state->compressed.data,
427 MIN(state->compressed.capacity, 1024)};
428 ret = ZSTD_compressStream2(cctx, &out, &in, op);
429 if (ZSTD_isError(ret)) {
430 result = result_error(result_error_compression_error);
433 data.total_size += out.pos;
438 result = result_data(data);
444 static int init_cstream(
445 buffer_state_t* state,
447 config_t const* config,
453 ZSTD_parameters const params = config_get_zstd_params(config, 0, 0);
454 ZSTD_CDict* dict = NULL;
456 if (!config->use_dictionary)
458 *cdict = ZSTD_createCDict_advanced(
459 state->dictionary.data,
460 state->dictionary.size,
468 zret = ZSTD_initCStream_usingCDict_advanced(
469 zcs, *cdict, params.fParams, ZSTD_CONTENTSIZE_UNKNOWN);
471 zret = ZSTD_initCStream_advanced(
473 config->use_dictionary ? state->dictionary.data : NULL,
474 config->use_dictionary ? state->dictionary.size : 0,
476 ZSTD_CONTENTSIZE_UNKNOWN);
479 int const level = config_get_level(config);
480 if (level == CONFIG_NO_LEVEL)
483 if (!config->use_dictionary)
485 *cdict = ZSTD_createCDict(
486 state->dictionary.data,
487 state->dictionary.size,
492 zret = ZSTD_initCStream_usingCDict(zcs, *cdict);
493 } else if (config->use_dictionary) {
494 zret = ZSTD_initCStream_usingDict(
496 state->dictionary.data,
497 state->dictionary.size,
500 zret = ZSTD_initCStream(zcs, level);
503 if (ZSTD_isError(zret)) {
509 static result_t old_streaming_compress_internal(
510 method_state_t* base,
511 config_t const* config,
514 buffer_state_t* state = container_of(base, buffer_state_t, base);
516 if (buffer_state_bad(state, config))
517 return result_error(result_error_system_error);
520 ZSTD_CStream* zcs = ZSTD_createCStream();
521 ZSTD_CDict* cd = NULL;
524 result = result_error(result_error_compression_error);
527 if (!advanced && config_get_level(config) == CONFIG_NO_LEVEL) {
528 result = result_error(result_error_skip);
531 if (cdict && !config->use_dictionary) {
532 result = result_error(result_error_skip);
535 if (config->advanced_api_only) {
536 result = result_error(result_error_skip);
539 if (init_cstream(state, zcs, config, advanced, cdict ? &cd : NULL)) {
540 result = result_error(result_error_compression_error);
544 result_data_t data = {.total_size = 0};
545 for (size_t i = 0; i < state->inputs.size; ++i) {
546 data_buffer_t input = state->inputs.buffers[i];
547 size_t zret = ZSTD_resetCStream(
549 config->no_pledged_src_size ? ZSTD_CONTENTSIZE_UNKNOWN : input.size);
550 if (ZSTD_isError(zret)) {
551 result = result_error(result_error_compression_error);
555 while (input.size > 0) {
556 ZSTD_inBuffer in = {input.data, MIN(input.size, 4096)};
557 input.data += in.size;
558 input.size -= in.size;
559 ZSTD_EndDirective const op =
560 input.size > 0 ? ZSTD_e_continue : ZSTD_e_end;
562 while (in.pos < in.size || (op == ZSTD_e_end && zret != 0)) {
563 ZSTD_outBuffer out = {state->compressed.data,
564 MIN(state->compressed.capacity, 1024)};
565 if (op == ZSTD_e_continue || in.pos < in.size)
566 zret = ZSTD_compressStream(zcs, &out, &in);
568 zret = ZSTD_endStream(zcs, &out);
569 if (ZSTD_isError(zret)) {
570 result = result_error(result_error_compression_error);
573 data.total_size += out.pos;
578 result = result_data(data);
580 ZSTD_freeCStream(zcs);
585 static result_t old_streaming_compress(
586 method_state_t* base,
587 config_t const* config)
589 return old_streaming_compress_internal(
590 base, config, /* advanced */ 0, /* cdict */ 0);
593 static result_t old_streaming_compress_advanced(
594 method_state_t* base,
595 config_t const* config)
597 return old_streaming_compress_internal(
598 base, config, /* advanced */ 1, /* cdict */ 0);
601 static result_t old_streaming_compress_cdict(
602 method_state_t* base,
603 config_t const* config)
605 return old_streaming_compress_internal(
606 base, config, /* advanced */ 0, /* cdict */ 1);
609 static result_t old_streaming_compress_cdict_advanced(
610 method_state_t* base,
611 config_t const* config)
613 return old_streaming_compress_internal(
614 base, config, /* advanced */ 1, /* cdict */ 1);
617 method_t const simple = {
618 .name = "compress simple",
619 .create = buffer_state_create,
620 .compress = simple_compress,
621 .destroy = buffer_state_destroy,
624 method_t const compress_cctx = {
625 .name = "compress cctx",
626 .create = buffer_state_create,
627 .compress = compress_cctx_compress,
628 .destroy = buffer_state_destroy,
631 method_t const advanced_one_pass = {
632 .name = "advanced one pass",
633 .create = buffer_state_create,
634 .compress = advanced_one_pass_compress,
635 .destroy = buffer_state_destroy,
638 method_t const advanced_one_pass_small_out = {
639 .name = "advanced one pass small out",
640 .create = buffer_state_create,
641 .compress = advanced_one_pass_compress,
642 .destroy = buffer_state_destroy,
645 method_t const advanced_streaming = {
646 .name = "advanced streaming",
647 .create = buffer_state_create,
648 .compress = advanced_streaming_compress,
649 .destroy = buffer_state_destroy,
652 method_t const old_streaming = {
653 .name = "old streaming",
654 .create = buffer_state_create,
655 .compress = old_streaming_compress,
656 .destroy = buffer_state_destroy,
659 method_t const old_streaming_advanced = {
660 .name = "old streaming advanced",
661 .create = buffer_state_create,
662 .compress = old_streaming_compress_advanced,
663 .destroy = buffer_state_destroy,
666 method_t const old_streaming_cdict = {
667 .name = "old streaming cdict",
668 .create = buffer_state_create,
669 .compress = old_streaming_compress_cdict,
670 .destroy = buffer_state_destroy,
673 method_t const old_streaming_advanced_cdict = {
674 .name = "old streaming advanced cdict",
675 .create = buffer_state_create,
676 .compress = old_streaming_compress_cdict_advanced,
677 .destroy = buffer_state_destroy,
680 method_t const cli = {
682 .create = method_state_create,
683 .compress = cli_compress,
684 .destroy = method_state_destroy,
687 static method_t const* g_methods[] = {
692 &advanced_one_pass_small_out,
695 &old_streaming_advanced,
696 &old_streaming_cdict,
697 &old_streaming_advanced_cdict,
701 method_t const* const* methods = g_methods;