mirror of
https://github.com/rkd77/elinks.git
synced 2024-12-04 14:46:47 -05:00
189 lines
3.6 KiB
C
189 lines
3.6 KiB
C
/* zstd encoding (ENCODING_ZSTD) backend */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#include <zstd.h>
|
|
#include <errno.h>
|
|
|
|
#include "elinks.h"
|
|
|
|
#include "encoding/zstd.h"
|
|
#include "encoding/encoding.h"
|
|
#include "util/memory.h"
|
|
|
|
/* How many bytes of compressed data to read before decompressing.
|
|
*/
|
|
#define ELINKS_ZSTD_BUFFER_LENGTH 16384
|
|
|
|
struct zstd_enc_data {
|
|
ZSTD_DCtx *zstd_stream;
|
|
ZSTD_inBuffer input;
|
|
ZSTD_outBuffer output;
|
|
size_t sent_pos;
|
|
/* The file descriptor from which we read. */
|
|
int fdread;
|
|
int decoded:1;
|
|
};
|
|
|
|
static int
|
|
zstd_open(struct stream_encoded *stream, int fd)
|
|
{
|
|
struct zstd_enc_data *data = (struct zstd_enc_data *)mem_calloc(1, sizeof(*data));
|
|
|
|
stream->data = NULL;
|
|
if (!data) {
|
|
return -1;
|
|
}
|
|
|
|
data->fdread = fd;
|
|
data->zstd_stream = ZSTD_createDCtx();
|
|
|
|
if (!data->zstd_stream) {
|
|
mem_free(data);
|
|
return -1;
|
|
}
|
|
|
|
stream->data = data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static char *
|
|
zstd_decode_buffer(struct stream_encoded *st, char *data, int len, int *new_len)
|
|
{
|
|
struct zstd_enc_data *enc_data = (struct zstd_enc_data *)st->data;
|
|
int error;
|
|
|
|
*new_len = 0; /* default, left there if an error occurs */
|
|
|
|
enc_data->input.src = data;
|
|
enc_data->input.pos = 0;
|
|
enc_data->input.size = len;
|
|
enc_data->output.pos = 0;
|
|
enc_data->output.size = 0;
|
|
enc_data->output.dst = NULL;
|
|
|
|
do {
|
|
char *new_buffer;
|
|
size_t size = enc_data->output.size + ELINKS_ZSTD_BUFFER_LENGTH;
|
|
|
|
new_buffer = (char *)mem_realloc(enc_data->output.dst, size);
|
|
if (!new_buffer) {
|
|
error = 1;
|
|
break;
|
|
}
|
|
|
|
enc_data->output.dst = new_buffer;
|
|
enc_data->output.size += ELINKS_ZSTD_BUFFER_LENGTH;
|
|
|
|
error = ZSTD_decompressStream(enc_data->zstd_stream, &enc_data->output , &enc_data->input);
|
|
|
|
if (ZSTD_isError(error)) {
|
|
mem_free_if(enc_data->output.dst);
|
|
enc_data->output.dst = NULL;
|
|
return NULL;
|
|
}
|
|
} while (enc_data->input.pos < enc_data->input.size);
|
|
|
|
*new_len = enc_data->output.pos;
|
|
return (char *)enc_data->output.dst;
|
|
}
|
|
|
|
static int
|
|
zstd_read(struct stream_encoded *stream, char *buf, int len)
|
|
{
|
|
struct zstd_enc_data *data = (struct zstd_enc_data *) stream->data;
|
|
|
|
if (!data) return -1;
|
|
|
|
assert(len > 0);
|
|
|
|
if (!data->decoded) {
|
|
size_t read_pos = 0;
|
|
char *tmp_buf = (char *)mem_alloc(len);
|
|
int new_len;
|
|
|
|
if (!tmp_buf) {
|
|
return 0;
|
|
}
|
|
do {
|
|
int l = safe_read(data->fdread, tmp_buf + read_pos, len - read_pos);
|
|
|
|
if (!l) break;
|
|
|
|
if (l == -1 && errno == EAGAIN) {
|
|
continue;
|
|
}
|
|
if (l == -1) {
|
|
return -1;
|
|
}
|
|
read_pos += l;
|
|
} while (1);
|
|
|
|
if (zstd_decode_buffer(stream, tmp_buf, len, &new_len)) {
|
|
data->decoded = 1;
|
|
}
|
|
mem_free(tmp_buf);
|
|
}
|
|
if (data->decoded) {
|
|
int length = len < (data->output.pos - data->sent_pos) ? len : (data->output.pos - data->sent_pos);
|
|
|
|
if (length <= 0) {
|
|
mem_free(data->output.dst);
|
|
data->output.dst = NULL;
|
|
} else {
|
|
memcpy(buf, (void *)((char *)(data->output.dst) + data->sent_pos), length);
|
|
data->sent_pos += length;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
static void
|
|
zstd_close(struct stream_encoded *stream)
|
|
{
|
|
struct zstd_enc_data *data = (struct zstd_enc_data *) stream->data;
|
|
|
|
if (data) {
|
|
if (data->zstd_stream) {
|
|
ZSTD_freeDCtx(data->zstd_stream);
|
|
data->zstd_stream = NULL;
|
|
}
|
|
if (data->fdread != -1) {
|
|
close(data->fdread);
|
|
}
|
|
mem_free(data);
|
|
stream->data = 0;
|
|
}
|
|
}
|
|
|
|
const char *
|
|
get_zstd_version(void)
|
|
{
|
|
return ZSTD_versionString();
|
|
}
|
|
|
|
static const char *const zstd_extensions[] = { ".zst", NULL };
|
|
|
|
const struct decoding_backend zstd_decoding_backend = {
|
|
"zstd",
|
|
zstd_extensions,
|
|
zstd_open,
|
|
zstd_read,
|
|
zstd_decode_buffer,
|
|
zstd_close,
|
|
};
|