254 lines
8.6 KiB
C++
254 lines
8.6 KiB
C++
/*
|
|
**********************************************************************************************
|
|
* File: http_content_decompress.c
|
|
* Description:
|
|
* Authors: LuWenPeng <luwenpeng@geedgenetworks.com>
|
|
* Date: 2022-10-31
|
|
* Copyright: (c) Since 2022 Geedge Networks, Ltd. All rights reserved.
|
|
***********************************************************************************************
|
|
*/
|
|
#include <zlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <brotli/decode.h>
|
|
#include "http_decoder_inc.h"
|
|
|
|
#define HTTP_DECOMPRESS_BUFFER_SIZE (4096)
|
|
|
|
struct http_content_decompress {
|
|
enum http_content_encoding encoding;
|
|
z_stream *z_stream_ptr;
|
|
BrotliDecoderState *br_state;
|
|
char *buffer;
|
|
size_t buffer_size;
|
|
};
|
|
|
|
enum http_content_encoding
|
|
http_content_encoding_str2int(const char *content_encoding)
|
|
{
|
|
if (strcasestr(content_encoding, "gzip") != NULL) {
|
|
return HTTP_CONTENT_ENCODING_GZIP;
|
|
}
|
|
if (strcasestr(content_encoding, "deflate") != NULL) {
|
|
return HTTP_CONTENT_ENCODING_DEFLATE;
|
|
}
|
|
if (strcasestr(content_encoding, "br") != NULL) {
|
|
return HTTP_CONTENT_ENCODING_BR;
|
|
}
|
|
return HTTP_CONTENT_ENCODING_NONE;
|
|
}
|
|
|
|
const char *
|
|
http_content_encoding_int2str(enum http_content_encoding content_encoding)
|
|
{
|
|
if (content_encoding == HTTP_CONTENT_ENCODING_GZIP) {
|
|
return "gzip";
|
|
}
|
|
if (content_encoding == HTTP_CONTENT_ENCODING_DEFLATE) {
|
|
return "deflate";
|
|
}
|
|
if (content_encoding == HTTP_CONTENT_ENCODING_BR) {
|
|
return "br";
|
|
}
|
|
return "unknown";
|
|
}
|
|
|
|
struct http_content_decompress *
|
|
http_content_decompress_create(enum http_content_encoding encoding)
|
|
{
|
|
struct http_content_decompress *decompress =
|
|
CALLOC(struct http_content_decompress, 1);
|
|
assert(decompress);
|
|
|
|
decompress->encoding = encoding;
|
|
decompress->z_stream_ptr = NULL;
|
|
decompress->br_state = NULL;
|
|
|
|
if (encoding == HTTP_CONTENT_ENCODING_GZIP
|
|
|| encoding == HTTP_CONTENT_ENCODING_DEFLATE) {
|
|
decompress->z_stream_ptr = CALLOC(z_stream, 1);
|
|
assert(decompress->z_stream_ptr);
|
|
|
|
decompress->z_stream_ptr->zalloc = NULL;
|
|
decompress->z_stream_ptr->zfree = NULL;
|
|
decompress->z_stream_ptr->opaque = NULL;
|
|
decompress->z_stream_ptr->avail_in = 0;
|
|
decompress->z_stream_ptr->next_in = Z_NULL;
|
|
|
|
if (encoding == HTTP_CONTENT_ENCODING_GZIP) {
|
|
if (inflateInit2(decompress->z_stream_ptr, MAX_WBITS + 16)
|
|
!= Z_OK) {
|
|
goto error;
|
|
}
|
|
}
|
|
if (encoding == HTTP_CONTENT_ENCODING_DEFLATE) {
|
|
if (inflateInit2(decompress->z_stream_ptr, -MAX_WBITS) != Z_OK) {
|
|
goto error;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (encoding == HTTP_CONTENT_ENCODING_BR) {
|
|
decompress->br_state = BrotliDecoderCreateInstance(NULL, NULL, NULL);
|
|
if (decompress->br_state == NULL) {
|
|
goto error;
|
|
}
|
|
}
|
|
return decompress;
|
|
|
|
error:
|
|
http_content_decompress_destroy(decompress);
|
|
return NULL;
|
|
}
|
|
|
|
void http_content_decompress_destroy(struct http_content_decompress *decompress)
|
|
{
|
|
if (NULL == decompress) {
|
|
return;
|
|
}
|
|
if (decompress->z_stream_ptr != NULL) {
|
|
inflateEnd(decompress->z_stream_ptr);
|
|
FREE(decompress->z_stream_ptr);
|
|
}
|
|
if (decompress->br_state) {
|
|
BrotliDecoderDestroyInstance(decompress->br_state);
|
|
decompress->br_state = NULL;
|
|
}
|
|
FREE(decompress->buffer);
|
|
FREE(decompress);
|
|
}
|
|
|
|
static int
|
|
http_content_decompress_write_zlib(struct http_content_decompress *decompress,
|
|
const char *indata, size_t indata_len,
|
|
char **outdata, size_t *outdata_len)
|
|
{
|
|
z_stream *z_stream_ptr = decompress->z_stream_ptr;
|
|
z_stream_ptr->avail_in = (unsigned int)indata_len;
|
|
z_stream_ptr->next_in = (unsigned char *)indata;
|
|
z_stream_ptr->avail_out = (unsigned int)decompress->buffer_size;
|
|
z_stream_ptr->next_out = (unsigned char *)decompress->buffer;
|
|
|
|
*outdata = NULL;
|
|
*outdata_len = 0;
|
|
|
|
do {
|
|
int ret = inflate(z_stream_ptr, Z_NO_FLUSH);
|
|
if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT
|
|
|| ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
|
|
(void)inflateEnd(z_stream_ptr);
|
|
return -1;
|
|
}
|
|
|
|
size_t have = decompress->buffer_size - z_stream_ptr->avail_out;
|
|
if (have > 0) {
|
|
if (0 == z_stream_ptr->avail_out) {
|
|
fprintf(stderr, "realloc outbuffer,before: %zu bytes, after :%zu B\n", decompress->buffer_size , decompress->buffer_size + have); ;
|
|
decompress->buffer_size += have;
|
|
decompress->buffer = REALLOC(char, decompress->buffer,
|
|
decompress->buffer_size);
|
|
*outdata = decompress->buffer;
|
|
*outdata_len = *outdata_len + have;
|
|
// http_decoder_log(DEBUG, "%s realloc outbuffer %zu bytes",
|
|
// http_content_encoding_int2str(decompress->encoding),
|
|
// decompress->buffer_size);
|
|
z_stream_ptr->avail_out = have;
|
|
z_stream_ptr->next_out = (unsigned char *)decompress->buffer +
|
|
(decompress->buffer_size - have);
|
|
} else {
|
|
*outdata = decompress->buffer;
|
|
*outdata_len = have;
|
|
}
|
|
}
|
|
if(Z_STREAM_END == ret){
|
|
break;
|
|
}
|
|
} while (z_stream_ptr->avail_in != 0);
|
|
decompress->buffer = NULL;
|
|
decompress->buffer_size = 0;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
http_content_decompress_write_br(struct http_content_decompress *decompress,
|
|
const char *indata, size_t indata_len,
|
|
char **outdata, size_t *outdata_len)
|
|
{
|
|
size_t available_in = indata_len;
|
|
const unsigned char *next_in = (const unsigned char *)indata;
|
|
size_t available_out = decompress->buffer_size;
|
|
unsigned char *next_out = (unsigned char *)decompress->buffer;
|
|
|
|
*outdata = NULL;
|
|
*outdata_len = 0;
|
|
|
|
for (;;) {
|
|
int ret = BrotliDecoderDecompressStream(decompress->br_state, &available_in,
|
|
&next_in, &available_out, &next_out, 0);
|
|
size_t have = decompress->buffer_size - available_out;
|
|
if (have > 0) {
|
|
if (0 == available_out) {
|
|
decompress->buffer_size += have;
|
|
decompress->buffer = REALLOC(char, decompress->buffer,
|
|
decompress->buffer_size);
|
|
*outdata = decompress->buffer;
|
|
*outdata_len = *outdata_len + have;
|
|
available_out = have;
|
|
next_out = (unsigned char *)decompress->buffer +
|
|
(decompress->buffer_size - have);
|
|
} else {
|
|
*outdata = decompress->buffer;
|
|
*outdata_len = have;
|
|
}
|
|
}
|
|
|
|
if (ret == BROTLI_DECODER_RESULT_SUCCESS ||
|
|
ret == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
|
|
decompress->buffer =NULL;
|
|
decompress->buffer_size = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (ret == BROTLI_DECODER_RESULT_ERROR) {
|
|
//BrotliDecoderErrorCode errcode =
|
|
BrotliDecoderGetErrorCode(decompress->br_state);
|
|
*outdata = NULL;
|
|
*outdata_len = 0;
|
|
return -1;
|
|
}
|
|
|
|
assert(ret == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT);
|
|
}
|
|
}
|
|
|
|
int http_content_decompress_write(struct http_content_decompress *decompress,
|
|
const char *indata, size_t indata_len,
|
|
char **outdata, size_t *outdata_len)
|
|
{
|
|
assert(decompress);
|
|
assert(indata);
|
|
assert(indata_len > 0);
|
|
assert(outdata);
|
|
assert(outdata_len);
|
|
|
|
*outdata = NULL;
|
|
*outdata_len = 0;
|
|
|
|
if(NULL == decompress->buffer ){
|
|
decompress->buffer = CALLOC(char, HTTP_DECOMPRESS_BUFFER_SIZE);
|
|
assert(decompress->buffer);
|
|
decompress->buffer_size = HTTP_DECOMPRESS_BUFFER_SIZE;
|
|
}
|
|
|
|
if (decompress->encoding == HTTP_CONTENT_ENCODING_GZIP ||
|
|
decompress->encoding == HTTP_CONTENT_ENCODING_DEFLATE) {
|
|
return http_content_decompress_write_zlib(decompress, indata, indata_len,
|
|
outdata, outdata_len);
|
|
}
|
|
if (decompress->encoding == HTTP_CONTENT_ENCODING_BR) {
|
|
return http_content_decompress_write_br(decompress, indata, indata_len,
|
|
outdata, outdata_len);
|
|
}
|
|
assert(0);
|
|
return -1;
|
|
} |