root
/
openssl
mirror of https://github.com/openssl/openssl.git
1
0
Fork 0
Code Issues Actions 7 Packages Projects Releases Wiki Activity
openssl/crypto/comp/c_brotli.c

801 lines
25 KiB
C
Raw Blame History

/*
* Copyright 1998-2025 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 brotli compression library from https://github.com/google/brotli
*/
#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_brotli(void);
#ifdef OPENSSL_NO_BROTLI
# undef BROTLI_SHARED
#else
# include <brotli/decode.h>
# include <brotli/encode.h>
/* memory allocations functions for brotli initialisation */
static void *brotli_alloc(void *opaque, size_t size)
{
return OPENSSL_zalloc(size);
}
static void brotli_free(void *opaque, void *address)
{
OPENSSL_free(address);
}
/*
* When OpenSSL is built on Windows, we do not want to require that
* the BROTLI.DLL be available in order for the OpenSSL DLLs to
* work. Therefore, all BROTLI routines are loaded at run time
* and we do not link to a .LIB file when BROTLI_SHARED is set.
*/
# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
# include <windows.h>
# endif
# ifdef BROTLI_SHARED
# include "internal/dso.h"
/* Function pointers */
typedef BrotliEncoderState *(*encode_init_ft)(brotli_alloc_func, brotli_free_func, void *);
typedef BROTLI_BOOL (*encode_stream_ft)(BrotliEncoderState *, BrotliEncoderOperation, size_t *, const uint8_t **, size_t *, uint8_t **, size_t *);
typedef BROTLI_BOOL (*encode_has_more_ft)(BrotliEncoderState *);
typedef void (*encode_end_ft)(BrotliEncoderState *);
typedef BROTLI_BOOL (*encode_oneshot_ft)(int, int, BrotliEncoderMode, size_t, const uint8_t in[], size_t *, uint8_t out[]);
typedef BrotliDecoderState *(*decode_init_ft)(brotli_alloc_func, brotli_free_func, void *);
typedef BROTLI_BOOL (*decode_stream_ft)(BrotliDecoderState *, size_t *, const uint8_t **, size_t *, uint8_t **, size_t *);
typedef BROTLI_BOOL (*decode_has_more_ft)(BrotliDecoderState *);
typedef void (*decode_end_ft)(BrotliDecoderState *);
typedef BrotliDecoderErrorCode (*decode_error_ft)(BrotliDecoderState *);
typedef const char *(*decode_error_string_ft)(BrotliDecoderErrorCode);
typedef BROTLI_BOOL (*decode_is_finished_ft)(BrotliDecoderState *);
typedef BrotliDecoderResult (*decode_oneshot_ft)(size_t, const uint8_t in[], size_t *, uint8_t out[]);
static encode_init_ft p_encode_init = NULL;
static encode_stream_ft p_encode_stream = NULL;
static encode_has_more_ft p_encode_has_more = NULL;
static encode_end_ft p_encode_end = NULL;
static encode_oneshot_ft p_encode_oneshot = NULL;
static decode_init_ft p_decode_init = NULL;
static decode_stream_ft p_decode_stream = NULL;
static decode_has_more_ft p_decode_has_more = NULL;
static decode_end_ft p_decode_end = NULL;
static decode_error_ft p_decode_error = NULL;
static decode_error_string_ft p_decode_error_string = NULL;
static decode_is_finished_ft p_decode_is_finished = NULL;
static decode_oneshot_ft p_decode_oneshot = NULL;
static DSO *brotli_encode_dso = NULL;
static DSO *brotli_decode_dso = NULL;
# define BrotliEncoderCreateInstance p_encode_init
# define BrotliEncoderCompressStream p_encode_stream
# define BrotliEncoderHasMoreOutput p_encode_has_more
# define BrotliEncoderDestroyInstance p_encode_end
# define BrotliEncoderCompress p_encode_oneshot
# define BrotliDecoderCreateInstance p_decode_init
# define BrotliDecoderDecompressStream p_decode_stream
# define BrotliDecoderHasMoreOutput p_decode_has_more
# define BrotliDecoderDestroyInstance p_decode_end
# define BrotliDecoderGetErrorCode p_decode_error
# define BrotliDecoderErrorString p_decode_error_string
# define BrotliDecoderIsFinished p_decode_is_finished
# define BrotliDecoderDecompress p_decode_oneshot
# endif /* ifdef BROTLI_SHARED */
struct brotli_state {
BrotliEncoderState *encoder;
BrotliDecoderState *decoder;
};
static int brotli_stateful_init(COMP_CTX *ctx)
{
struct brotli_state *state = OPENSSL_zalloc(sizeof(*state));
if (state == NULL)
return 0;
state->encoder = BrotliEncoderCreateInstance(brotli_alloc, brotli_free, NULL);
if (state->encoder == NULL)
goto err;
state->decoder = BrotliDecoderCreateInstance(brotli_alloc, brotli_free, NULL);
if (state->decoder == NULL)
goto err;
ctx->data = state;
return 1;
err:
BrotliDecoderDestroyInstance(state->decoder);
BrotliEncoderDestroyInstance(state->encoder);
OPENSSL_free(state);
return 0;
}
static void brotli_stateful_finish(COMP_CTX *ctx)
{
struct brotli_state *state = ctx->data;
if (state != NULL) {
BrotliDecoderDestroyInstance(state->decoder);
BrotliEncoderDestroyInstance(state->encoder);
OPENSSL_free(state);
ctx->data = NULL;
}
}
static ossl_ssize_t brotli_stateful_compress_block(COMP_CTX *ctx, unsigned char *out,
size_t olen, unsigned char *in,
size_t ilen)
{
BROTLI_BOOL done;
struct brotli_state *state = ctx->data;
size_t in_avail = ilen;
size_t out_avail = olen;
if (state == NULL || olen > OSSL_SSIZE_MAX)
return -1;
if (ilen == 0)
return 0;
/*
* The finish API does not provide a final output buffer,
* so each compress operation has to be flushed, 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
*/
done = BrotliEncoderCompressStream(state->encoder, BROTLI_OPERATION_FLUSH,
&in_avail, (const uint8_t**)&in,
&out_avail, &out, NULL);
if (done == BROTLI_FALSE
|| in_avail != 0
|| BrotliEncoderHasMoreOutput(state->encoder))
return -1;
if (out_avail > olen)
return -1;
return (ossl_ssize_t)(olen - out_avail);
}
static ossl_ssize_t brotli_stateful_expand_block(COMP_CTX *ctx, unsigned char *out,
size_t olen, unsigned char *in,
size_t ilen)
{
BrotliDecoderResult result;
struct brotli_state *state = ctx->data;
size_t in_avail = ilen;
size_t out_avail = olen;
if (state == NULL || olen > OSSL_SSIZE_MAX)
return -1;
if (ilen == 0)
return 0;
result = BrotliDecoderDecompressStream(state->decoder, &in_avail,
(const uint8_t**)&in, &out_avail,
&out, NULL);
if (result == BROTLI_DECODER_RESULT_ERROR
|| in_avail != 0
|| BrotliDecoderHasMoreOutput(state->decoder))
return -1;
if (out_avail > olen)
return -1;
return (ossl_ssize_t)(olen - out_avail);
}
static COMP_METHOD brotli_stateful_method = {
NID_brotli,
LN_brotli,
brotli_stateful_init,
brotli_stateful_finish,
brotli_stateful_compress_block,
brotli_stateful_expand_block
};
static int brotli_oneshot_init(COMP_CTX *ctx)
{
return 1;
}
static void brotli_oneshot_finish(COMP_CTX *ctx)
{
}
static ossl_ssize_t brotli_oneshot_compress_block(COMP_CTX *ctx, unsigned char *out,
size_t olen, unsigned char *in,
size_t ilen)
{
size_t out_size = olen;
ossl_ssize_t ret;
if (ilen == 0)
return 0;
if (BrotliEncoderCompress(BROTLI_DEFAULT_QUALITY, BROTLI_DEFAULT_WINDOW,
BROTLI_DEFAULT_MODE, ilen, in,
&out_size, out) == BROTLI_FALSE)
return -1;
if (out_size > OSSL_SSIZE_MAX)
return -1;
ret = (ossl_ssize_t)out_size;
if (ret < 0)
return -1;
return ret;
}
static ossl_ssize_t brotli_oneshot_expand_block(COMP_CTX *ctx, unsigned char *out,
size_t olen, unsigned char *in,
size_t ilen)
{
size_t out_size = olen;
ossl_ssize_t ret;
if (ilen == 0)
return 0;
if (BrotliDecoderDecompress(ilen, in, &out_size, out) != BROTLI_DECODER_RESULT_SUCCESS)
return -1;
if (out_size > OSSL_SSIZE_MAX)
return -1;
ret = (ossl_ssize_t)out_size;
if (ret < 0)
return -1;
return ret;
}
static COMP_METHOD brotli_oneshot_method = {
NID_brotli,
LN_brotli,
brotli_oneshot_init,
brotli_oneshot_finish,
brotli_oneshot_compress_block,
brotli_oneshot_expand_block
};
static CRYPTO_ONCE brotli_once = CRYPTO_ONCE_STATIC_INIT;
DEFINE_RUN_ONCE_STATIC(ossl_comp_brotli_init)
{
# ifdef BROTLI_SHARED
# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_WIN32)
# define LIBBROTLIENC "BROTLIENC"
# define LIBBROTLIDEC "BROTLIDEC"
# else
# define LIBBROTLIENC "brotlienc"
# define LIBBROTLIDEC "brotlidec"
# endif
brotli_encode_dso = DSO_load(NULL, LIBBROTLIENC, NULL, 0);
if (brotli_encode_dso != NULL) {
p_encode_init = (encode_init_ft)DSO_bind_func(brotli_encode_dso, "BrotliEncoderCreateInstance");
p_encode_stream = (encode_stream_ft)DSO_bind_func(brotli_encode_dso, "BrotliEncoderCompressStream");
p_encode_has_more = (encode_has_more_ft)DSO_bind_func(brotli_encode_dso, "BrotliEncoderHasMoreOutput");
p_encode_end = (encode_end_ft)DSO_bind_func(brotli_encode_dso, "BrotliEncoderDestroyInstance");
p_encode_oneshot = (encode_oneshot_ft)DSO_bind_func(brotli_encode_dso, "BrotliEncoderCompress");
}
brotli_decode_dso = DSO_load(NULL, LIBBROTLIDEC, NULL, 0);
if (brotli_decode_dso != NULL) {
p_decode_init = (decode_init_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderCreateInstance");
p_decode_stream = (decode_stream_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderDecompressStream");
p_decode_has_more = (decode_has_more_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderHasMoreOutput");
p_decode_end = (decode_end_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderDestroyInstance");
p_decode_error = (decode_error_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderGetErrorCode");
p_decode_error_string = (decode_error_string_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderErrorString");
p_decode_is_finished = (decode_is_finished_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderIsFinished");
p_decode_oneshot = (decode_oneshot_ft)DSO_bind_func(brotli_decode_dso, "BrotliDecoderDecompress");
}
if (p_encode_init == NULL || p_encode_stream == NULL || p_encode_has_more == NULL
|| p_encode_end == NULL || p_encode_oneshot == NULL || p_decode_init == NULL
|| p_decode_stream == NULL || p_decode_has_more == NULL || p_decode_end == NULL
|| p_decode_error == NULL || p_decode_error_string == NULL || p_decode_is_finished == NULL
|| p_decode_oneshot == NULL) {
ossl_comp_brotli_cleanup();
return 0;
}
# endif
return 1;
}
#endif /* ifndef BROTLI / else */
COMP_METHOD *COMP_brotli(void)
{
COMP_METHOD *meth = NULL;
#ifndef OPENSSL_NO_BROTLI
if (RUN_ONCE(&brotli_once, ossl_comp_brotli_init))
meth = &brotli_stateful_method;
#endif
return meth;
}
COMP_METHOD *COMP_brotli_oneshot(void)
{
COMP_METHOD *meth = NULL;
#ifndef OPENSSL_NO_BROTLI
if (RUN_ONCE(&brotli_once, ossl_comp_brotli_init))
meth = &brotli_oneshot_method;
#endif
return meth;
}
/* Also called from OPENSSL_cleanup() */
void ossl_comp_brotli_cleanup(void)
{
#ifdef BROTLI_SHARED
DSO_free(brotli_encode_dso);
brotli_encode_dso = NULL;
DSO_free(brotli_decode_dso);
brotli_decode_dso = NULL;
p_encode_init = NULL;
p_encode_stream = NULL;
p_encode_has_more = NULL;
p_encode_end = NULL;
p_encode_oneshot = NULL;
p_decode_init = NULL;
p_decode_stream = NULL;
p_decode_has_more = NULL;
p_decode_end = NULL;
p_decode_error = NULL;
p_decode_error_string = NULL;
p_decode_is_finished = NULL;
p_decode_oneshot = NULL;
#endif
}
#ifndef OPENSSL_NO_BROTLI
/* Brotli-based compression/decompression filter BIO */
typedef struct {
struct { /* input structure */
size_t avail_in;
unsigned char *next_in;
size_t avail_out;
unsigned char *next_out;
unsigned char *buf;
size_t bufsize;
BrotliDecoderState *state;
} decode;
struct { /* output structure */
size_t avail_in;
unsigned char *next_in;
size_t avail_out;
unsigned char *next_out;
unsigned char *buf;
size_t bufsize;
BrotliEncoderState *state;
int mode; /* Encoder mode to use */
int done;
unsigned char *ptr;
size_t count;
} encode;
} BIO_BROTLI_CTX;
# define BROTLI_DEFAULT_BUFSIZE 1024
static int bio_brotli_new(BIO *bi);
static int bio_brotli_free(BIO *bi);
static int bio_brotli_read(BIO *b, char *out, int outl);
static int bio_brotli_write(BIO *b, const char *in, int inl);
static long bio_brotli_ctrl(BIO *b, int cmd, long num, void *ptr);
static long bio_brotli_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
static const BIO_METHOD bio_meth_brotli = {
BIO_TYPE_COMP,
"brotli",
/* TODO: Convert to new style write function */
bwrite_conv,
bio_brotli_write,
/* TODO: Convert to new style read function */
bread_conv,
bio_brotli_read,
NULL, /* bio_brotli_puts, */
NULL, /* bio_brotli_gets, */
bio_brotli_ctrl,
bio_brotli_new,
bio_brotli_free,
bio_brotli_callback_ctrl
};
#endif
const BIO_METHOD *BIO_f_brotli(void)
{
#ifndef OPENSSL_NO_BROTLI
if (RUN_ONCE(&brotli_once, ossl_comp_brotli_init))
return &bio_meth_brotli;
#endif
return NULL;
}
#ifndef OPENSSL_NO_BROTLI
static int bio_brotli_new(BIO *bi)
{
BIO_BROTLI_CTX *ctx;
# ifdef BROTLI_SHARED
if (!RUN_ONCE(&brotli_once, ossl_comp_brotli_init)) {
ERR_raise(ERR_LIB_COMP, COMP_R_BROTLI_NOT_SUPPORTED);
return 0;
}
# endif
ctx = OPENSSL_zalloc(sizeof(*ctx));
if (ctx == NULL) {
ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
return 0;
}
ctx->decode.bufsize = BROTLI_DEFAULT_BUFSIZE;
ctx->decode.state = BrotliDecoderCreateInstance(brotli_alloc, brotli_free, NULL);
if (ctx->decode.state == NULL)
goto err;
ctx->encode.bufsize = BROTLI_DEFAULT_BUFSIZE;
ctx->encode.state = BrotliEncoderCreateInstance(brotli_alloc, brotli_free, NULL);
if (ctx->encode.state == NULL)
goto err;
ctx->encode.mode = BROTLI_DEFAULT_MODE;
BIO_set_init(bi, 1);
BIO_set_data(bi, ctx);
return 1;
err:
ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
BrotliDecoderDestroyInstance(ctx->decode.state);
BrotliEncoderDestroyInstance(ctx->encode.state);
OPENSSL_free(ctx);
return 0;
}
static int bio_brotli_free(BIO *bi)
{
BIO_BROTLI_CTX *ctx;
if (bi == NULL)
return 0;
ctx = BIO_get_data(bi);
if (ctx != NULL) {
BrotliDecoderDestroyInstance(ctx->decode.state);
OPENSSL_free(ctx->decode.buf);
BrotliEncoderDestroyInstance(ctx->encode.state);
OPENSSL_free(ctx->encode.buf);
OPENSSL_free(ctx);
}
BIO_set_data(bi, NULL);
BIO_set_init(bi, 0);
return 1;
}
static int bio_brotli_read(BIO *b, char *out, int outl)
{
BIO_BROTLI_CTX *ctx;
BrotliDecoderResult bret;
int ret;
BIO *next = BIO_next(b);
if (out == NULL || outl <= 0) {
ERR_raise(ERR_LIB_COMP, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
#if INT_MAX > SIZE_MAX
if ((unsigned int)outl > SIZE_MAX) {
ERR_raise(ERR_LIB_COMP, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
#endif
ctx = BIO_get_data(b);
BIO_clear_retry_flags(b);
if (ctx->decode.buf == NULL) {
ctx->decode.buf = OPENSSL_malloc(ctx->decode.bufsize);
if (ctx->decode.buf == NULL) {
ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
return 0;
}
ctx->decode.next_in = ctx->decode.buf;
ctx->decode.avail_in = 0;
}
/* Copy output data directly to supplied buffer */
ctx->decode.next_out = (unsigned char *)out;
ctx->decode.avail_out = (size_t)outl;
for (;;) {
/* Decompress while data available */
while (ctx->decode.avail_in > 0 || BrotliDecoderHasMoreOutput(ctx->decode.state)) {
bret = BrotliDecoderDecompressStream(ctx->decode.state, &ctx->decode.avail_in, (const uint8_t**)&ctx->decode.next_in,
&ctx->decode.avail_out, &ctx->decode.next_out, NULL);
if (bret == BROTLI_DECODER_RESULT_ERROR) {
ERR_raise(ERR_LIB_COMP, COMP_R_BROTLI_DECODE_ERROR);
ERR_add_error_data(1, BrotliDecoderErrorString(BrotliDecoderGetErrorCode(ctx->decode.state)));
return 0;
}
/* If EOF or we've read everything then return */
if (BrotliDecoderIsFinished(ctx->decode.state) || ctx->decode.avail_out == 0)
return (int)(outl - ctx->decode.avail_out);
}
/* If EOF */
if (BrotliDecoderIsFinished(ctx->decode.state))
return 0;
/*
* No data in input buffer try to read some in, if an error then
* return the total data read.
*/
ret = BIO_read(next, ctx->decode.buf, (int)ctx->decode.bufsize);
if (ret <= 0) {
/* Total data read */
int tot = outl - (int)ctx->decode.avail_out;
BIO_copy_next_retry(b);
if (ret < 0)
return (tot > 0) ? tot : ret;
return tot;
}
ctx->decode.avail_in = ret;
ctx->decode.next_in = ctx->decode.buf;
}
}
static int bio_brotli_write(BIO *b, const char *in, int inl)
{
BIO_BROTLI_CTX *ctx;
BROTLI_BOOL brret;
int ret;
BIO *next = BIO_next(b);
if (in == NULL || inl <= 0) {
ERR_raise(ERR_LIB_COMP, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
#if INT_MAX > SIZE_MAX
if ((unsigned int)inl > SIZE_MAX) {
ERR_raise(ERR_LIB_COMP, ERR_R_PASSED_INVALID_ARGUMENT);
return 0;
}
#endif
ctx = BIO_get_data(b);
if (ctx->encode.done)
return 0;
BIO_clear_retry_flags(b);
if (ctx->encode.buf == NULL) {
ctx->encode.buf = OPENSSL_malloc(ctx->encode.bufsize);
if (ctx->encode.buf == NULL) {
ERR_raise(ERR_LIB_COMP, ERR_R_MALLOC_FAILURE);
return 0;
}
ctx->encode.ptr = ctx->encode.buf;
ctx->encode.count = 0;
ctx->encode.next_out = ctx->encode.buf;
ctx->encode.avail_out = ctx->encode.bufsize;
}
/* Obtain input data directly from supplied buffer */
ctx->encode.next_in = (unsigned char *)in;
ctx->encode.avail_in = (size_t)inl;
for (;;) {
/* If data in output buffer write it first */
while (ctx->encode.count > 0) {
ret = BIO_write(next, ctx->encode.ptr, (int)ctx->encode.count);
if (ret <= 0) {
/* Total data written */
int tot = inl - (int)ctx->encode.avail_in;
BIO_copy_next_retry(b);
if (ret < 0)
return (tot > 0) ? tot : ret;
return tot;
}
ctx->encode.ptr += ret;
ctx->encode.count -= ret;
}
/* Have we consumed all supplied data? */
if (ctx->encode.avail_in == 0 && !BrotliEncoderHasMoreOutput(ctx->encode.state))
return inl;
/* Compress some more */
/* Reset buffer */
ctx->encode.ptr = ctx->encode.buf;
ctx->encode.next_out = ctx->encode.buf;
ctx->encode.avail_out = ctx->encode.bufsize;
/* Compress some more */
brret = BrotliEncoderCompressStream(ctx->encode.state, BROTLI_OPERATION_FLUSH, &ctx->encode.avail_in, (const uint8_t**)&ctx->encode.next_in,
&ctx->encode.avail_out, &ctx->encode.next_out, NULL);
if (brret != BROTLI_TRUE) {
ERR_raise(ERR_LIB_COMP, COMP_R_BROTLI_ENCODE_ERROR);
ERR_add_error_data(1, "brotli encoder error");
return 0;
}
ctx->encode.count = ctx->encode.bufsize - ctx->encode.avail_out;
}
}
static int bio_brotli_flush(BIO *b)
{
BIO_BROTLI_CTX *ctx;
BROTLI_BOOL brret;
int ret;
BIO *next = BIO_next(b);
ctx = BIO_get_data(b);
/* If no data written or already flush show success */
if (ctx->encode.buf == NULL || (ctx->encode.done && ctx->encode.count == 0))
return 1;
BIO_clear_retry_flags(b);
/* No more input data */
ctx->encode.next_in = NULL;
ctx->encode.avail_in = 0;
for (;;) {
/* If data in output buffer write it first */
while (ctx->encode.count > 0) {
ret = BIO_write(next, ctx->encode.ptr, (int)ctx->encode.count);
if (ret <= 0) {
BIO_copy_next_retry(b);
return ret;
}
ctx->encode.ptr += ret;
ctx->encode.count -= ret;
}
if (ctx->encode.done)
return 1;
/* Compress some more */
/* Reset buffer */
ctx->encode.ptr = ctx->encode.buf;
ctx->encode.next_out = ctx->encode.buf;
ctx->encode.avail_out = ctx->encode.bufsize;
/* Compress some more */
brret = BrotliEncoderCompressStream(ctx->encode.state, BROTLI_OPERATION_FINISH, &ctx->encode.avail_in,
(const uint8_t**)&ctx->encode.next_in, &ctx->encode.avail_out, &ctx->encode.next_out, NULL);
if (brret != BROTLI_TRUE) {
ERR_raise(ERR_LIB_COMP, COMP_R_BROTLI_DECODE_ERROR);
ERR_add_error_data(1, "brotli encoder error");
return 0;
}
if (!BrotliEncoderHasMoreOutput(ctx->encode.state) && ctx->encode.avail_in == 0)
ctx->encode.done = 1;
ctx->encode.count = ctx->encode.bufsize - ctx->encode.avail_out;
}
}
static long bio_brotli_ctrl(BIO *b, int cmd, long num, void *ptr)
{
BIO_BROTLI_CTX *ctx;
unsigned char *tmp;
int ret = 0, *ip;
size_t ibs, obs;
BIO *next = BIO_next(b);
if (next == NULL)
return 0;
ctx = BIO_get_data(b);
switch (cmd) {
case BIO_CTRL_RESET:
ctx->encode.count = 0;
ctx->encode.done = 0;
ret = 1;
break;
case BIO_CTRL_FLUSH:
ret = bio_brotli_flush(b);
if (ret > 0) {
ret = BIO_flush(next);
BIO_copy_next_retry(b);
}
break;
case BIO_C_SET_BUFF_SIZE:
ibs = ctx->decode.bufsize;
obs = ctx->encode.bufsize;
if (ptr != NULL) {
ip = ptr;
if (*ip == 0)
ibs = (size_t)num;
else
obs = (size_t)num;
} else {
ibs = (size_t)num;
obs = ibs;
}
if (ibs > 0 && ibs != ctx->decode.bufsize) {
/* Do not free/alloc, only reallocate */
if (ctx->decode.buf != NULL) {
tmp = OPENSSL_realloc(ctx->decode.buf, ibs);
if (tmp == NULL)
return 0;
ctx->decode.buf = tmp;
}
ctx->decode.bufsize = ibs;
}
if (obs > 0 && obs != ctx->encode.bufsize) {
/* Do not free/alloc, only reallocate */
if (ctx->encode.buf != NULL) {
tmp = OPENSSL_realloc(ctx->encode.buf, obs);
if (tmp == NULL)
return 0;
ctx->encode.buf = tmp;
}
ctx->encode.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 (BrotliEncoderHasMoreOutput(ctx->encode.state))
ret = 1;
else
ret = BIO_ctrl(next, cmd, num, ptr);
break;
case BIO_CTRL_PENDING:
if (!BrotliDecoderIsFinished(ctx->decode.state))
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_brotli_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
Reference in New Issue View Git Blame Copy Permalink