|
|
@@ -0,0 +1,827 @@
|
|
|
+/*
|
|
|
+ * Copyright 1998-2021 The OpenSSL Project Authors. All Rights Reserved.
|
|
|
+ *
|
|
|
+ * Licensed under the Apache License 2.0 (the "License"). You may not use
|
|
|
+ * this file except in compliance with the License. You can obtain a copy
|
|
|
+ * in the file LICENSE in the source distribution or at
|
|
|
+ * https://www.openssl.org/source/license.html
|
|
|
+ *
|
|
|
+ * Uses zstd compression library from https://github.com/facebook/zstd
|
|
|
+ * Requires version 1.4.x (latest as of this writing is 1.4.5)
|
|
|
+ * Using custom free functions require static linking, so that is disabled when
|
|
|
+ * using the shared library.
|
|
|
+ */
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <string.h>
|
|
|
+#include <openssl/objects.h>
|
|
|
+#include "internal/comp.h"
|
|
|
+#include <openssl/err.h>
|
|
|
+#include "crypto/cryptlib.h"
|
|
|
+#include "internal/bio.h"
|
|
|
+#include "internal/thread_once.h"
|
|
|
+#include "comp_local.h"
|
|
|
+
|
|
|
+COMP_METHOD *COMP_zstd(void);
|
|
|
+
|
|
|
+static COMP_METHOD zstd_method_nozstd = {
|
|
|
+ NID_undef,
|
|
|
+ "(undef)",
|
|
|
+ NULL,
|
|
|
+ NULL,
|
|
|
+ NULL,
|
|
|
+ NULL,
|
|
|
+};
|
|
|
+
|
|
|
+#ifdef OPENSSL_NO_ZSTD
|
|
|
+# undef ZSTD_SHARED
|
|
|
+#else
|
|
|
+
|
|
|
+# ifndef ZSTD_SHARED
|
|
|
+# define ZSTD_STATIC_LINKING_ONLY
|
|
|
+# endif
|
|
|
+# include <zstd.h>
|
|
|
+
|
|
|
+/* Note: There is also a linux zstd.h file in the kernel source */
|
|
|
+# ifndef ZSTD_H_235446
|
|
|
+# error Wrong (i.e. linux) zstd.h included.
|
|
|
+# endif
|
|
|
+
|
|
|
+# if ZSTD_VERSION_MAJOR != 1 && ZSTD_VERSION_MINOR < 4
|
|
|
+# error Expecting version 1.4 or greater of ZSTD
|
|
|
+# endif
|
|
|
+
|
|
|
+# ifndef ZSTD_SHARED
|
|
|
+/* memory allocations functions for zstd initialisation */
|
|
|
+static void *zstd_alloc(void *opaque, size_t size)
|
|
|
+{
|
|
|
+ return OPENSSL_zalloc(size);
|
|
|
+}
|
|
|
+
|
|
|
+static void zstd_free(void *opaque, void *address)
|
|
|
+{
|
|
|
+ OPENSSL_free(address);
|
|
|
+}
|
|
|
+
|
|
|
+static ZSTD_customMem zstd_mem_funcs = {
|
|
|
+ zstd_alloc,
|
|
|
+ zstd_free,
|
|
|
+ NULL
|
|
|
+};
|
|
|
+# endif
|
|
|
+
|
|
|
+/*
|
|
|
+ * When OpenSSL is built on Windows, we do not want to require that
|
|
|
+ * the LIBZSTD.DLL be available in order for the OpenSSL DLLs to
|
|
|
+ * work. Therefore, all ZSTD routines are loaded at run time
|
|
|
+ * and we do not link to a .LIB file when ZSTD_SHARED is set.
|
|
|
+ */
|
|
|
+# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
|
|
|
+# include <windows.h>
|
|
|
+# endif
|
|
|
+
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+# include "internal/dso.h"
|
|
|
+
|
|
|
+/* Function pointers */
|
|
|
+typedef ZSTD_CStream* (*createCStream_ft)(void);
|
|
|
+typedef size_t (*initCStream_ft)(ZSTD_CStream*, int);
|
|
|
+typedef size_t (*freeCStream_ft)(ZSTD_CStream*);
|
|
|
+typedef size_t (*compressStream2_ft)(ZSTD_CCtx*, ZSTD_outBuffer*, ZSTD_inBuffer*, ZSTD_EndDirective);
|
|
|
+typedef size_t (*flushStream_ft)(ZSTD_CStream*, ZSTD_outBuffer*);
|
|
|
+typedef size_t (*endStream_ft)(ZSTD_CStream*, ZSTD_outBuffer*);
|
|
|
+typedef size_t (*compress_ft)(void*, size_t, const void*, size_t, int);
|
|
|
+typedef ZSTD_DStream* (*createDStream_ft)(void);
|
|
|
+typedef size_t (*initDStream_ft)(ZSTD_DStream*);
|
|
|
+typedef size_t (*freeDStream_ft)(ZSTD_DStream*);
|
|
|
+typedef size_t (*decompressStream_ft)(ZSTD_DStream*, ZSTD_outBuffer*, ZSTD_inBuffer*);
|
|
|
+typedef size_t (*decompress_ft)(void*, size_t, const void*, size_t);
|
|
|
+typedef unsigned (*isError_ft)(size_t);
|
|
|
+typedef const char* (*getErrorName_ft)(size_t);
|
|
|
+typedef size_t (*DStreamInSize_ft)(void);
|
|
|
+typedef size_t (*CStreamInSize_ft)(void);
|
|
|
+
|
|
|
+static createCStream_ft p_createCStream = NULL;
|
|
|
+static initCStream_ft p_initCStream = NULL;
|
|
|
+static freeCStream_ft p_freeCStream = NULL;
|
|
|
+static compressStream2_ft p_compressStream2 = NULL;
|
|
|
+static flushStream_ft p_flushStream = NULL;
|
|
|
+static endStream_ft p_endStream = NULL;
|
|
|
+static compress_ft p_compress = NULL;
|
|
|
+static createDStream_ft p_createDStream = NULL;
|
|
|
+static initDStream_ft p_initDStream = NULL;
|
|
|
+static freeDStream_ft p_freeDStream = NULL;
|
|
|
+static decompressStream_ft p_decompressStream = NULL;
|
|
|
+static decompress_ft p_decompress = NULL;
|
|
|
+static isError_ft p_isError = NULL;
|
|
|
+static getErrorName_ft p_getErrorName = NULL;
|
|
|
+static DStreamInSize_ft p_DStreamInSize = NULL;
|
|
|
+static CStreamInSize_ft p_CStreamInSize = NULL;
|
|
|
+
|
|
|
+static DSO *zstd_dso = NULL;
|
|
|
+
|
|
|
+# define ZSTD_createCStream p_createCStream
|
|
|
+# define ZSTD_initCStream p_initCStream
|
|
|
+# define ZSTD_freeCStream p_freeCStream
|
|
|
+# define ZSTD_compressStream2 p_compressStream2
|
|
|
+# define ZSTD_flushStream p_flushStream
|
|
|
+# define ZSTD_endStream p_endStream
|
|
|
+# define ZSTD_compress p_compress
|
|
|
+# define ZSTD_createDStream p_createDStream
|
|
|
+# define ZSTD_initDStream p_initDStream
|
|
|
+# define ZSTD_freeDStream p_freeDStream
|
|
|
+# define ZSTD_decompressStream p_decompressStream
|
|
|
+# define ZSTD_decompress p_decompress
|
|
|
+# define ZSTD_isError p_isError
|
|
|
+# define ZSTD_getErrorName p_getErrorName
|
|
|
+# define ZSTD_DStreamInSize p_DStreamInSize
|
|
|
+# define ZSTD_CStreamInSize p_CStreamInSize
|
|
|
+
|
|
|
+# endif /* ifdef ZSTD_SHARED */
|
|
|
+
|
|
|
+struct zstd_state {
|
|
|
+ ZSTD_CStream *compressor;
|
|
|
+ ZSTD_DStream *decompressor;
|
|
|
+};
|
|
|
+
|
|
|
+static int zstd_stateful_init(COMP_CTX *ctx)
|
|
|
+{
|
|
|
+ struct zstd_state *state = OPENSSL_zalloc(sizeof(*state));
|
|
|
+
|
|
|
+ if (state == NULL)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+ state->compressor = ZSTD_createCStream();
|
|
|
+# else
|
|
|
+ state->compressor = ZSTD_createCStream_advanced(zstd_mem_funcs);
|
|
|
+# endif
|
|
|
+ if (state->compressor == NULL)
|
|
|
+ goto err;
|
|
|
+ ZSTD_initCStream(state->compressor, ZSTD_CLEVEL_DEFAULT);
|
|
|
+
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+ state->decompressor = ZSTD_createDStream();
|
|
|
+# else
|
|
|
+ state->decompressor = ZSTD_createDStream_advanced(zstd_mem_funcs);
|
|
|
+# endif
|
|
|
+ if (state->decompressor == NULL)
|
|
|
+ goto err;
|
|
|
+ ZSTD_initDStream(state->decompressor);
|
|
|
+
|
|
|
+ ctx->data = state;
|
|
|
+ return 1;
|
|
|
+ err:
|
|
|
+ ZSTD_freeCStream(state->compressor);
|
|
|
+ ZSTD_freeDStream(state->decompressor);
|
|
|
+ OPENSSL_free(state);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static void zstd_stateful_finish(COMP_CTX *ctx)
|
|
|
+{
|
|
|
+ struct zstd_state *state = ctx->data;
|
|
|
+
|
|
|
+ if (state != NULL) {
|
|
|
+ ZSTD_freeCStream(state->compressor);
|
|
|
+ ZSTD_freeDStream(state->decompressor);
|
|
|
+ OPENSSL_free(state);
|
|
|
+ ctx->data = NULL;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int zstd_stateful_compress_block(COMP_CTX *ctx, unsigned char *out,
|
|
|
+ unsigned int olen, unsigned char *in,
|
|
|
+ unsigned int ilen)
|
|
|
+{
|
|
|
+ ZSTD_inBuffer inbuf;
|
|
|
+ ZSTD_outBuffer outbuf;
|
|
|
+ size_t ret;
|
|
|
+ struct zstd_state *state = ctx->data;
|
|
|
+
|
|
|
+ inbuf.src = in;
|
|
|
+ inbuf.size = ilen;
|
|
|
+ inbuf.pos = 0;
|
|
|
+ outbuf.dst = out;
|
|
|
+ outbuf.size = olen;
|
|
|
+ outbuf.pos = 0;
|
|
|
+
|
|
|
+ if (state == NULL)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ /* If input length is zero, end the stream/frame ? */
|
|
|
+ if (ilen == 0) {
|
|
|
+ ret = ZSTD_endStream(state->compressor, &outbuf);
|
|
|
+ if (ZSTD_isError(ret))
|
|
|
+ return -1;
|
|
|
+ return outbuf.pos;
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * The finish API does not provide a final output buffer,
|
|
|
+ * so each compress operation has to be ended, if all
|
|
|
+ * the input data can't be accepted, or there is more output,
|
|
|
+ * this has to be considered an error, since there is no more
|
|
|
+ * output buffer space.
|
|
|
+ */
|
|
|
+ do {
|
|
|
+ ret = ZSTD_compressStream2(state->compressor, &outbuf, &inbuf, ZSTD_e_continue);
|
|
|
+ if (ZSTD_isError(ret))
|
|
|
+ return -1;
|
|
|
+ /* do I need to check for ret == 0 ? */
|
|
|
+ } while (inbuf.pos < inbuf.size);
|
|
|
+
|
|
|
+ /* Did not consume all the data */
|
|
|
+ if (inbuf.pos < inbuf.size)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ ret = ZSTD_flushStream(state->compressor, &outbuf);
|
|
|
+ if (ZSTD_isError(ret))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return outbuf.pos;
|
|
|
+}
|
|
|
+
|
|
|
+static int zstd_stateful_expand_block(COMP_CTX *ctx, unsigned char *out,
|
|
|
+ unsigned int olen, unsigned char *in,
|
|
|
+ unsigned int ilen)
|
|
|
+{
|
|
|
+ ZSTD_inBuffer inbuf;
|
|
|
+ ZSTD_outBuffer outbuf;
|
|
|
+ size_t ret;
|
|
|
+ struct zstd_state *state = ctx->data;
|
|
|
+
|
|
|
+ inbuf.src = in;
|
|
|
+ inbuf.size = ilen;
|
|
|
+ inbuf.pos = 0;
|
|
|
+ outbuf.dst = out;
|
|
|
+ outbuf.size = olen;
|
|
|
+ outbuf.pos = 0;
|
|
|
+
|
|
|
+ if (state == NULL)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (ilen == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ ret = ZSTD_decompressStream(state->decompressor, &outbuf, &inbuf);
|
|
|
+ if (ZSTD_isError(ret))
|
|
|
+ return -1;
|
|
|
+ /* If we completed a frame, and there's more data, try again */
|
|
|
+ } while (ret == 0 && inbuf.pos < inbuf.size);
|
|
|
+
|
|
|
+ /* Did not consume all the data */
|
|
|
+ if (inbuf.pos < inbuf.size)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return outbuf.pos;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+static COMP_METHOD zstd_stateful_method = {
|
|
|
+ NID_zstd,
|
|
|
+ LN_zstd,
|
|
|
+ zstd_stateful_init,
|
|
|
+ zstd_stateful_finish,
|
|
|
+ zstd_stateful_compress_block,
|
|
|
+ zstd_stateful_expand_block
|
|
|
+};
|
|
|
+
|
|
|
+static int zstd_oneshot_init(COMP_CTX *ctx)
|
|
|
+{
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static void zstd_oneshot_finish(COMP_CTX *ctx)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+static int zstd_oneshot_compress_block(COMP_CTX *ctx, unsigned char *out,
|
|
|
+ unsigned int olen, unsigned char *in,
|
|
|
+ unsigned int ilen)
|
|
|
+{
|
|
|
+ size_t out_size;
|
|
|
+
|
|
|
+ if (ilen == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* Note: uses STDLIB memory allocators */
|
|
|
+ out_size = ZSTD_compress(out, olen, in, ilen, ZSTD_CLEVEL_DEFAULT);
|
|
|
+ if (ZSTD_isError(out_size))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return out_size;
|
|
|
+}
|
|
|
+
|
|
|
+static int zstd_oneshot_expand_block(COMP_CTX *ctx, unsigned char *out,
|
|
|
+ unsigned int olen, unsigned char *in,
|
|
|
+ unsigned int ilen)
|
|
|
+{
|
|
|
+ size_t out_size;
|
|
|
+
|
|
|
+ if (ilen == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ /* Note: uses STDLIB memory allocators */
|
|
|
+ out_size = ZSTD_decompress(out, olen, in, ilen);
|
|
|
+ if (ZSTD_isError(out_size))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return out_size;
|
|
|
+}
|
|
|
+
|
|
|
+static COMP_METHOD zstd_oneshot_method = {
|
|
|
+ NID_zstd,
|
|
|
+ LN_zstd,
|
|
|
+ zstd_oneshot_init,
|
|
|
+ zstd_oneshot_finish,
|
|
|
+ zstd_oneshot_compress_block,
|
|
|
+ zstd_oneshot_expand_block
|
|
|
+};
|
|
|
+
|
|
|
+static CRYPTO_ONCE zstd_once = CRYPTO_ONCE_STATIC_INIT;
|
|
|
+DEFINE_RUN_ONCE_STATIC(ossl_comp_zstd_init)
|
|
|
+{
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
|
|
|
+# define LIBZSTD "LIBZSTD"
|
|
|
+# else
|
|
|
+# define LIBZSTD "zstd"
|
|
|
+# endif
|
|
|
+
|
|
|
+ zstd_dso = DSO_load(NULL, LIBZSTD, NULL, 0);
|
|
|
+ if (zstd_dso != NULL) {
|
|
|
+ p_createCStream = (createCStream_ft)DSO_bind_func(zstd_dso, "ZSTD_createCStream");
|
|
|
+ p_initCStream = (initCStream_ft)DSO_bind_func(zstd_dso, "ZSTD_initCStream");
|
|
|
+ p_freeCStream = (freeCStream_ft)DSO_bind_func(zstd_dso, "ZSTD_freeCStream");
|
|
|
+ p_compressStream2 = (compressStream2_ft)DSO_bind_func(zstd_dso, "ZSTD_compressStream2");
|
|
|
+ p_flushStream = (flushStream_ft)DSO_bind_func(zstd_dso, "ZSTD_flushStream");
|
|
|
+ p_endStream = (endStream_ft)DSO_bind_func(zstd_dso, "ZSTD_endStream");
|
|
|
+ p_compress = (compress_ft)DSO_bind_func(zstd_dso, "ZSTD_compress");
|
|
|
+ p_createDStream = (createDStream_ft)DSO_bind_func(zstd_dso, "ZSTD_createDStream");
|
|
|
+ p_initDStream = (initDStream_ft)DSO_bind_func(zstd_dso, "ZSTD_initDStream");
|
|
|
+ p_freeDStream = (freeDStream_ft)DSO_bind_func(zstd_dso, "ZSTD_freeDStream");
|
|
|
+ p_decompressStream = (decompressStream_ft)DSO_bind_func(zstd_dso, "ZSTD_decompressStream");
|
|
|
+ p_decompress = (decompress_ft)DSO_bind_func(zstd_dso, "ZSTD_decompress");
|
|
|
+ p_isError = (isError_ft)DSO_bind_func(zstd_dso, "ZSTD_isError");
|
|
|
+ p_getErrorName = (getErrorName_ft)DSO_bind_func(zstd_dso, "ZSTD_getErrorName");
|
|
|
+ p_DStreamInSize = (DStreamInSize_ft)DSO_bind_func(zstd_dso, "ZSTD_DStreamInSize");
|
|
|
+ p_CStreamInSize = (CStreamInSize_ft)DSO_bind_func(zstd_dso, "ZSTD_CStreamInSize");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (p_createCStream == NULL || p_initCStream == NULL || p_freeCStream == NULL
|
|
|
+ || p_compressStream2 == NULL || p_flushStream == NULL || p_endStream == NULL
|
|
|
+ || p_compress == NULL || p_createDStream == NULL || p_initDStream == NULL
|
|
|
+ || p_freeDStream == NULL || p_decompressStream == NULL || p_decompress == NULL
|
|
|
+ || p_isError == NULL || p_getErrorName == NULL || p_DStreamInSize == NULL
|
|
|
+ || p_CStreamInSize == NULL) {
|
|
|
+ ossl_comp_zstd_cleanup();
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+# endif
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+#endif /* ifndef ZSTD / else */
|
|
|
+
|
|
|
+COMP_METHOD *COMP_zstd(void)
|
|
|
+{
|
|
|
+ COMP_METHOD *meth = &zstd_method_nozstd;
|
|
|
+
|
|
|
+#ifndef OPENSSL_NO_ZSTD
|
|
|
+ if (RUN_ONCE(&zstd_once, ossl_comp_zstd_init))
|
|
|
+ meth = &zstd_stateful_method;
|
|
|
+#endif
|
|
|
+ return meth;
|
|
|
+}
|
|
|
+
|
|
|
+COMP_METHOD *COMP_zstd_oneshot(void)
|
|
|
+{
|
|
|
+ COMP_METHOD *meth = &zstd_method_nozstd;
|
|
|
+
|
|
|
+#ifndef OPENSSL_NO_ZSTD
|
|
|
+ if (RUN_ONCE(&zstd_once, ossl_comp_zstd_init))
|
|
|
+ meth = &zstd_oneshot_method;
|
|
|
+#endif
|
|
|
+ return meth;
|
|
|
+}
|
|
|
+
|
|
|
+/* Also called from OPENSSL_cleanup() */
|
|
|
+void ossl_comp_zstd_cleanup(void)
|
|
|
+{
|
|
|
+#ifdef ZSTD_SHARED
|
|
|
+ DSO_free(zstd_dso);
|
|
|
+ zstd_dso = NULL;
|
|
|
+ p_createCStream = NULL;
|
|
|
+ p_initCStream = NULL;
|
|
|
+ p_freeCStream = NULL;
|
|
|
+ p_compressStream2 = NULL;
|
|
|
+ p_flushStream = NULL;
|
|
|
+ p_endStream = NULL;
|
|
|
+ p_compress = NULL;
|
|
|
+ p_createDStream = NULL;
|
|
|
+ p_initDStream = NULL;
|
|
|
+ p_freeDStream = NULL;
|
|
|
+ p_decompressStream = NULL;
|
|
|
+ p_decompress = NULL;
|
|
|
+ p_isError = NULL;
|
|
|
+ p_getErrorName = NULL;
|
|
|
+ p_DStreamInSize = NULL;
|
|
|
+ p_CStreamInSize = NULL;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+#ifndef OPENSSL_NO_ZSTD
|
|
|
+
|
|
|
+/* Zstd-based compression/decompression filter BIO */
|
|
|
+
|
|
|
+typedef struct {
|
|
|
+ struct { /* input structure */
|
|
|
+ ZSTD_DStream *state;
|
|
|
+ ZSTD_inBuffer inbuf; /* has const src */
|
|
|
+ size_t bufsize;
|
|
|
+ void* buffer;
|
|
|
+ } decompress;
|
|
|
+ struct { /* output structure */
|
|
|
+ ZSTD_CStream *state;
|
|
|
+ ZSTD_outBuffer outbuf;
|
|
|
+ size_t bufsize;
|
|
|
+ size_t write_pos;
|
|
|
+ } compress;
|
|
|
+} BIO_ZSTD_CTX;
|
|
|
+
|
|
|
+# define ZSTD_DEFAULT_BUFSIZE 1024
|
|
|
+
|
|
|
+static int bio_zstd_new(BIO *bi);
|
|
|
+static int bio_zstd_free(BIO *bi);
|
|
|
+static int bio_zstd_read(BIO *b, char *out, int outl);
|
|
|
+static int bio_zstd_write(BIO *b, const char *in, int inl);
|
|
|
+static long bio_zstd_ctrl(BIO *b, int cmd, long num, void *ptr);
|
|
|
+static long bio_zstd_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
|
|
|
+
|
|
|
+static const BIO_METHOD bio_meth_zstd = {
|
|
|
+ BIO_TYPE_COMP,
|
|
|
+ "zstd",
|
|
|
+ /* TODO: Convert to new style write function */
|
|
|
+ bwrite_conv,
|
|
|
+ bio_zstd_write,
|
|
|
+ /* TODO: Convert to new style read function */
|
|
|
+ bread_conv,
|
|
|
+ bio_zstd_read,
|
|
|
+ NULL, /* bio_zstd_puts, */
|
|
|
+ NULL, /* bio_zstd_gets, */
|
|
|
+ bio_zstd_ctrl,
|
|
|
+ bio_zstd_new,
|
|
|
+ bio_zstd_free,
|
|
|
+ bio_zstd_callback_ctrl
|
|
|
+};
|
|
|
+#endif
|
|
|
+
|
|
|
+const BIO_METHOD *BIO_f_zstd(void)
|
|
|
+{
|
|
|
+#ifndef OPENSSL_NO_ZSTD
|
|
|
+ return &bio_meth_zstd;
|
|
|
+#else
|
|
|
+ return NULL;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+#ifndef OPENSSL_NO_ZSTD
|
|
|
+static int bio_zstd_new(BIO *bi)
|
|
|
+{
|
|
|
+ BIO_ZSTD_CTX *ctx;
|
|
|
+
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+ (void)COMP_zstd();
|
|
|
+ if (zstd_dso == NULL) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, COMP_R_ZSTD_NOT_SUPPORTED);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+# endif
|
|
|
+ ctx = OPENSSL_zalloc(sizeof(*ctx));
|
|
|
+ if (ctx == NULL) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+ ctx->decompress.state = ZSTD_createDStream();
|
|
|
+# else
|
|
|
+ ctx->decompress.state = ZSTD_createDStream_advanced(zstd_mem_funcs);
|
|
|
+# endif
|
|
|
+ if (ctx->decompress.state == NULL)
|
|
|
+ goto err;
|
|
|
+ ZSTD_initDStream(ctx->decompress.state);
|
|
|
+ ctx->decompress.bufsize = ZSTD_DStreamInSize();
|
|
|
+
|
|
|
+# ifdef ZSTD_SHARED
|
|
|
+ ctx->compress.state = ZSTD_createCStream();
|
|
|
+# else
|
|
|
+ ctx->compress.state = ZSTD_createCStream_advanced(zstd_mem_funcs);
|
|
|
+# endif
|
|
|
+ if (ctx->compress.state == NULL)
|
|
|
+ goto err;
|
|
|
+ ZSTD_initCStream(ctx->compress.state, ZSTD_CLEVEL_DEFAULT);
|
|
|
+ ctx->compress.bufsize = ZSTD_CStreamInSize();
|
|
|
+
|
|
|
+ BIO_set_init(bi, 1);
|
|
|
+ BIO_set_data(bi, ctx);
|
|
|
+
|
|
|
+ return 1;
|
|
|
+ err:
|
|
|
+ ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
|
|
|
+ ZSTD_freeDStream(ctx->decompress.state);
|
|
|
+ ZSTD_freeCStream(ctx->compress.state);
|
|
|
+ OPENSSL_free(ctx);
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+static int bio_zstd_free(BIO *bi)
|
|
|
+{
|
|
|
+ BIO_ZSTD_CTX *ctx;
|
|
|
+
|
|
|
+ if (bi == NULL)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ ctx = BIO_get_data(bi);
|
|
|
+ if (ctx != NULL) {
|
|
|
+ ZSTD_freeDStream(ctx->decompress.state);
|
|
|
+ OPENSSL_free(ctx->decompress.buffer);
|
|
|
+ ZSTD_freeCStream(ctx->compress.state);
|
|
|
+ OPENSSL_free(ctx->compress.outbuf.dst);
|
|
|
+ OPENSSL_free(ctx);
|
|
|
+ }
|
|
|
+ BIO_set_data(bi, NULL);
|
|
|
+ BIO_set_init(bi, 0);
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+static int bio_zstd_read(BIO *b, char *out, int outl)
|
|
|
+{
|
|
|
+ BIO_ZSTD_CTX *ctx;
|
|
|
+ size_t zret;
|
|
|
+ int ret;
|
|
|
+ ZSTD_outBuffer outBuf;
|
|
|
+ BIO *next = BIO_next(b);
|
|
|
+
|
|
|
+ if (out == NULL || outl <= 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ ctx = BIO_get_data(b);
|
|
|
+ BIO_clear_retry_flags(b);
|
|
|
+ if (ctx->decompress.buffer == NULL) {
|
|
|
+ ctx->decompress.buffer = OPENSSL_malloc(ctx->decompress.bufsize);
|
|
|
+ if (ctx->decompress.buffer == NULL) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ ctx->decompress.inbuf.src = ctx->decompress.buffer;
|
|
|
+ ctx->decompress.inbuf.size = 0;
|
|
|
+ ctx->decompress.inbuf.pos = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Copy output data directly to supplied buffer */
|
|
|
+ outBuf.dst = out;
|
|
|
+ outBuf.size = (size_t)outl;
|
|
|
+ outBuf.pos = 0;
|
|
|
+ for (;;) {
|
|
|
+ /* Decompress while data available */
|
|
|
+ do {
|
|
|
+ zret = ZSTD_decompressStream(ctx->decompress.state, &outBuf, &ctx->decompress.inbuf);
|
|
|
+ if (ZSTD_isError(zret)) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, COMP_R_ZSTD_DECOMPRESS_ERROR);
|
|
|
+ ERR_add_error_data(1, ZSTD_getErrorName(zret));
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ /* No more output space */
|
|
|
+ if (outBuf.pos == outBuf.size)
|
|
|
+ return outBuf.pos;
|
|
|
+ } while (ctx->decompress.inbuf.pos < ctx->decompress.inbuf.size);
|
|
|
+
|
|
|
+ /*
|
|
|
+ * No data in input buffer try to read some in, if an error then
|
|
|
+ * return the total data read.
|
|
|
+ */
|
|
|
+ ret = BIO_read(next, ctx->decompress.buffer, ctx->decompress.bufsize);
|
|
|
+ if (ret <= 0) {
|
|
|
+ BIO_copy_next_retry(b);
|
|
|
+ if (ret < 0 && outBuf.pos == 0)
|
|
|
+ return ret;
|
|
|
+ return outBuf.pos;
|
|
|
+ }
|
|
|
+ ctx->decompress.inbuf.size = ret;
|
|
|
+ ctx->decompress.inbuf.pos = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int bio_zstd_write(BIO *b, const char *in, int inl)
|
|
|
+{
|
|
|
+ BIO_ZSTD_CTX *ctx;
|
|
|
+ size_t zret;
|
|
|
+ ZSTD_inBuffer inBuf;
|
|
|
+ int ret;
|
|
|
+ int done = 0;
|
|
|
+ BIO *next = BIO_next(b);
|
|
|
+
|
|
|
+ if (in == NULL || inl <= 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ ctx = BIO_get_data(b);
|
|
|
+
|
|
|
+ BIO_clear_retry_flags(b);
|
|
|
+ if (ctx->compress.outbuf.dst == NULL) {
|
|
|
+ ctx->compress.outbuf.dst = OPENSSL_malloc(ctx->compress.bufsize);
|
|
|
+ if (ctx->compress.outbuf.dst == NULL) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ ctx->compress.outbuf.size = ctx->compress.bufsize;
|
|
|
+ ctx->compress.outbuf.pos = 0;
|
|
|
+ ctx->compress.write_pos = 0;
|
|
|
+ }
|
|
|
+ /* Obtain input data directly from supplied buffer */
|
|
|
+ inBuf.src = in;
|
|
|
+ inBuf.size = inl;
|
|
|
+ inBuf.pos = 0;
|
|
|
+ for (;;) {
|
|
|
+ /* If data in output buffer write it first */
|
|
|
+ while (ctx->compress.write_pos < ctx->compress.outbuf.pos) {
|
|
|
+ ret = BIO_write(next, (unsigned char*)ctx->compress.outbuf.dst + ctx->compress.write_pos,
|
|
|
+ ctx->compress.outbuf.pos - ctx->compress.write_pos);
|
|
|
+ if (ret <= 0) {
|
|
|
+ BIO_copy_next_retry(b);
|
|
|
+ if (ret < 0 && inBuf.pos == 0)
|
|
|
+ return ret;
|
|
|
+ return inBuf.pos;
|
|
|
+ }
|
|
|
+ ctx->compress.write_pos += ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Have we consumed all supplied data? */
|
|
|
+ if (done)
|
|
|
+ return inBuf.pos;
|
|
|
+
|
|
|
+ /* Reset buffer */
|
|
|
+ ctx->compress.outbuf.pos = 0;
|
|
|
+ ctx->compress.outbuf.size = ctx->compress.bufsize;
|
|
|
+ ctx->compress.write_pos = 0;
|
|
|
+ /* Compress some more */
|
|
|
+ zret = ZSTD_compressStream2(ctx->compress.state, &ctx->compress.outbuf, &inBuf, ZSTD_e_end);
|
|
|
+ if (ZSTD_isError(zret)) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, COMP_R_ZSTD_COMPRESS_ERROR);
|
|
|
+ ERR_add_error_data(1, ZSTD_getErrorName(zret));
|
|
|
+ return 0;
|
|
|
+ } else if (zret == 0) {
|
|
|
+ done = 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static int bio_zstd_flush(BIO *b)
|
|
|
+{
|
|
|
+ BIO_ZSTD_CTX *ctx;
|
|
|
+ size_t zret;
|
|
|
+ int ret;
|
|
|
+ BIO *next = BIO_next(b);
|
|
|
+
|
|
|
+ ctx = BIO_get_data(b);
|
|
|
+
|
|
|
+ /* If no data written or already flush show success */
|
|
|
+ if (ctx->compress.outbuf.dst == NULL)
|
|
|
+ return 1;
|
|
|
+
|
|
|
+ BIO_clear_retry_flags(b);
|
|
|
+ /* No more input data */
|
|
|
+ ctx->compress.outbuf.pos = 0;
|
|
|
+ ctx->compress.outbuf.size = ctx->compress.bufsize;
|
|
|
+ ctx->compress.write_pos = 0;
|
|
|
+ for (;;) {
|
|
|
+ /* If data in output buffer write it first */
|
|
|
+ while (ctx->compress.write_pos < ctx->compress.outbuf.pos) {
|
|
|
+ ret = BIO_write(next, (unsigned char*)ctx->compress.outbuf.dst + ctx->compress.write_pos,
|
|
|
+ ctx->compress.outbuf.pos - ctx->compress.write_pos);
|
|
|
+ if (ret <= 0) {
|
|
|
+ BIO_copy_next_retry(b);
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+ ctx->compress.write_pos += ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Reset buffer */
|
|
|
+ ctx->compress.outbuf.pos = 0;
|
|
|
+ ctx->compress.outbuf.size = ctx->compress.bufsize;
|
|
|
+ ctx->compress.write_pos = 0;
|
|
|
+ /* Compress some more */
|
|
|
+ zret = ZSTD_flushStream(ctx->compress.state, &ctx->compress.outbuf);
|
|
|
+ if (ZSTD_isError(zret)) {
|
|
|
+ ERR_raise(ERR_LIB_COMP, COMP_R_ZSTD_DECODE_ERROR);
|
|
|
+ ERR_add_error_data(1, ZSTD_getErrorName(zret));
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (zret == 0)
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static long bio_zstd_ctrl(BIO *b, int cmd, long num, void *ptr)
|
|
|
+{
|
|
|
+ BIO_ZSTD_CTX *ctx;
|
|
|
+ int ret = 0, *ip;
|
|
|
+ size_t ibs, obs;
|
|
|
+ unsigned char *tmp;
|
|
|
+ BIO *next = BIO_next(b);
|
|
|
+
|
|
|
+ if (next == NULL)
|
|
|
+ return 0;
|
|
|
+ ctx = BIO_get_data(b);
|
|
|
+ switch (cmd) {
|
|
|
+
|
|
|
+ case BIO_CTRL_RESET:
|
|
|
+ ctx->compress.write_pos = 0;
|
|
|
+ ctx->compress.bufsize = 0;
|
|
|
+ ret = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case BIO_CTRL_FLUSH:
|
|
|
+ ret = bio_zstd_flush(b);
|
|
|
+ if (ret > 0)
|
|
|
+ ret = BIO_flush(next);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case BIO_C_SET_BUFF_SIZE:
|
|
|
+ ibs = ctx->decompress.bufsize;
|
|
|
+ obs = ctx->compress.bufsize;
|
|
|
+ if (ptr != NULL) {
|
|
|
+ ip = ptr;
|
|
|
+ if (*ip == 0)
|
|
|
+ ibs = (size_t)num;
|
|
|
+ else
|
|
|
+ obs = (size_t)num;
|
|
|
+ } else {
|
|
|
+ obs = ibs = (size_t)num;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ibs > 0 && ibs != ctx->decompress.bufsize) {
|
|
|
+ if (ctx->decompress.buffer != NULL) {
|
|
|
+ tmp = OPENSSL_realloc(ctx->decompress.buffer, ibs);
|
|
|
+ if (tmp == NULL)
|
|
|
+ return 0;
|
|
|
+ if (ctx->decompress.inbuf.src == ctx->decompress.buffer)
|
|
|
+ ctx->decompress.inbuf.src = tmp;
|
|
|
+ ctx->decompress.buffer = tmp;
|
|
|
+ }
|
|
|
+ ctx->decompress.bufsize = ibs;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (obs > 0 && obs != ctx->compress.bufsize) {
|
|
|
+ if (ctx->compress.outbuf.dst != NULL) {
|
|
|
+ tmp = OPENSSL_realloc(ctx->compress.outbuf.dst, obs);
|
|
|
+ if (tmp == NULL)
|
|
|
+ return 0;
|
|
|
+ ctx->compress.outbuf.dst = tmp;
|
|
|
+ }
|
|
|
+ ctx->compress.bufsize = obs;
|
|
|
+ }
|
|
|
+ ret = 1;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case BIO_C_DO_STATE_MACHINE:
|
|
|
+ BIO_clear_retry_flags(b);
|
|
|
+ ret = BIO_ctrl(next, cmd, num, ptr);
|
|
|
+ BIO_copy_next_retry(b);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case BIO_CTRL_WPENDING:
|
|
|
+ if (ctx->compress.outbuf.pos < ctx->compress.outbuf.size)
|
|
|
+ ret = 1;
|
|
|
+ else
|
|
|
+ ret = BIO_ctrl(next, cmd, num, ptr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case BIO_CTRL_PENDING:
|
|
|
+ if (ctx->decompress.inbuf.pos < ctx->decompress.inbuf.size)
|
|
|
+ ret = 1;
|
|
|
+ else
|
|
|
+ ret = BIO_ctrl(next, cmd, num, ptr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ ret = BIO_ctrl(next, cmd, num, ptr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+static long bio_zstd_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
|
|
|
+{
|
|
|
+ BIO *next = BIO_next(b);
|
|
|
+ if (next == NULL)
|
|
|
+ return 0;
|
|
|
+ return BIO_callback_ctrl(next, cmd, fp);
|
|
|
+}
|
|
|
+
|
|
|
+#endif
|
Todd Short