From a85c6025903a2b6e97e1938b201b3361a0cbed66 Mon Sep 17 00:00:00 2001 From: David Oberhollenzer Date: Tue, 30 Apr 2019 10:50:13 +0200 Subject: Add compressor library Signed-off-by: David Oberhollenzer --- lib/Makemodule.am | 20 +++++++++- lib/comp/compressor.c | 35 ++++++++++++++++ lib/comp/internal.h | 11 +++++ lib/comp/lzma.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++ lib/comp/zlib.c | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 273 insertions(+), 1 deletion(-) create mode 100644 lib/comp/compressor.c create mode 100644 lib/comp/internal.h create mode 100644 lib/comp/lzma.c create mode 100644 lib/comp/zlib.c (limited to 'lib') diff --git a/lib/Makemodule.am b/lib/Makemodule.am index 18ec8c4..89ec538 100644 --- a/lib/Makemodule.am +++ b/lib/Makemodule.am @@ -2,4 +2,22 @@ libfstree_a_SOURCES = lib/fstree/fstree.c lib/fstree/fstree_from_file.c libfstree_a_SOURCES += lib/fstree/fstree_sort.c libfstree_a_SOURCES += include/fstree.h -noinst_LIBRARIES += libfstree.a +libcompress_a_SOURCES = lib/comp/compressor.c lib/comp/internal.h +libcompress_a_CFLAGS = $(AM_CFLAGS) +libcompress_a_CPPFLAGS = $(AM_CPPFLAGS) + +if WITH_ZLIB +libcompress_a_SOURCES += lib/comp/zlib.c + +libcompress_a_CFLAGS += $(ZLIB_CFLAGS) +libcompress_a_CPPFLAGS += -DWITH_ZLIB +endif + +if WITH_LZMA +libcompress_a_SOURCES += lib/comp/lzma.c + +libcompress_a_CFLAGS += $(XZ_CFLAGS) +libcompress_a_CPPFLAGS += -DWITH_LZMA +endif + +noinst_LIBRARIES += libfstree.a libcompress.a diff --git a/lib/comp/compressor.c b/lib/comp/compressor.c new file mode 100644 index 0000000..3bc2b4d --- /dev/null +++ b/lib/comp/compressor.c @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#include + +#include "internal.h" + +typedef compressor_t *(*compressor_fun_t)(bool compress, size_t block_size); + +static compressor_fun_t compressors[SQFS_COMP_MAX + 1] = { +#ifdef WITH_ZLIB + [SQFS_COMP_GZIP] = create_zlib_compressor, +#endif +#ifdef WITH_LZMA + [SQFS_COMP_XZ] = create_lzma_compressor, +#endif +}; + +bool compressor_exists(E_SQFS_COMPRESSOR id) +{ + if (id < SQFS_COMP_MIN || id > SQFS_COMP_MAX) + return false; + + return (compressors[id] != NULL); +} + +compressor_t *compressor_create(E_SQFS_COMPRESSOR id, bool compress, + size_t block_size) +{ + if (id < SQFS_COMP_MIN || id > SQFS_COMP_MAX) + return NULL; + + if (compressors[id] == NULL) + return NULL; + + return compressors[id](compress, block_size); +} diff --git a/lib/comp/internal.h b/lib/comp/internal.h new file mode 100644 index 0000000..17fffe1 --- /dev/null +++ b/lib/comp/internal.h @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#ifndef INTERNAL_H +#define INTERNAL_H + +#include "compress.h" + +compressor_t *create_lzma_compressor(bool compress, size_t block_size); + +compressor_t *create_zlib_compressor(bool compress, size_t block_size); + +#endif /* INTERNAL_H */ diff --git a/lib/comp/lzma.c b/lib/comp/lzma.c new file mode 100644 index 0000000..fd2a6c7 --- /dev/null +++ b/lib/comp/lzma.c @@ -0,0 +1,100 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#include +#include +#include +#include +#include + +#include "internal.h" + +typedef struct { + compressor_t base; + + size_t block_size; + uint8_t buffer[]; +} lzma_compressor_t; + +static ssize_t lzma_comp_block(compressor_t *base, uint8_t *block, size_t size) +{ + lzma_compressor_t *lzma = (lzma_compressor_t *)base; + lzma_filter filters[5]; + lzma_options_lzma opt; + size_t written = 0; + lzma_ret ret; + + if (lzma_lzma_preset(&opt, LZMA_PRESET_DEFAULT)) { + fputs("error initializing LZMA options\n", stderr); + return -1; + } + + opt.dict_size = lzma->block_size; + + filters[0].id = LZMA_FILTER_LZMA2; + filters[0].options = &opt; + + filters[1].id = LZMA_VLI_UNKNOWN; + filters[1].options = NULL; + + ret = lzma_stream_buffer_encode(filters, LZMA_CHECK_CRC32, NULL, + block, size, lzma->buffer, + &written, lzma->block_size); + + if (ret == LZMA_OK) { + if (written >= size) + return 0; + + memcpy(block, lzma->buffer, size); + return written; + } + + if (ret != LZMA_BUF_ERROR) { + fputs("lzma block compress failed\n", stderr); + return -1; + } + + return 0; +} + +static ssize_t lzma_uncomp_block(compressor_t *base, uint8_t *block, + size_t size) +{ + lzma_compressor_t *lzma = (lzma_compressor_t *)base; + uint64_t memlimit = 32 * 1024 * 1024; + size_t dest_pos = 0; + size_t src_pos = 0; + lzma_ret ret; + + ret = lzma_stream_buffer_decode(&memlimit, 0, NULL, + block, &src_pos, size, + lzma->buffer, &dest_pos, + lzma->block_size); + + if (ret == LZMA_OK && size == src_pos) { + memcpy(block, lzma->buffer, dest_pos); + return (ssize_t)dest_pos; + } + + fputs("lzma block extract failed\n", stderr); + return -1; +} + +static void lzma_destroy(compressor_t *base) +{ + free(base); +} + +compressor_t *create_lzma_compressor(bool compress, size_t block_size) +{ + lzma_compressor_t *lzma = calloc(1, sizeof(*lzma) + block_size); + compressor_t *base = (compressor_t *)lzma; + + if (lzma == NULL) { + perror("creating lzma stream"); + return NULL; + } + + lzma->block_size = block_size; + base->destroy = lzma_destroy; + base->do_block = compress ? lzma_comp_block : lzma_uncomp_block; + return base; +} diff --git a/lib/comp/zlib.c b/lib/comp/zlib.c new file mode 100644 index 0000000..d3bfe70 --- /dev/null +++ b/lib/comp/zlib.c @@ -0,0 +1,108 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later */ +#include +#include +#include +#include +#include + +#include "internal.h" + +typedef struct { + compressor_t base; + + z_stream strm; + bool compress; + + size_t block_size; + uint8_t buffer[]; +} zlib_compressor_t; + +static void zlib_destroy(compressor_t *base) +{ + zlib_compressor_t *zlib = (zlib_compressor_t *)base; + + if (zlib->compress) { + deflateEnd(&zlib->strm); + } else { + inflateEnd(&zlib->strm); + } + + free(zlib); +} + +static ssize_t zlib_do_block(compressor_t *base, uint8_t *block, size_t size) +{ + zlib_compressor_t *zlib = (zlib_compressor_t *)base; + size_t written; + int ret; + + if (zlib->compress) { + ret = deflateReset(&zlib->strm); + } else { + ret = inflateReset(&zlib->strm); + } + + if (ret != Z_OK) { + fputs("resetting zlib stream failed\n", stderr); + return -1; + } + + zlib->strm.next_in = (void *)block; + zlib->strm.avail_in = size; + zlib->strm.next_out = zlib->buffer; + zlib->strm.avail_out = zlib->block_size; + + if (zlib->compress) { + ret = deflate(&zlib->strm, Z_FINISH); + } else { + ret = inflate(&zlib->strm, Z_FINISH); + } + + if (ret == Z_STREAM_END) { + written = zlib->strm.total_out; + + if (zlib->compress && written >= size) + return 0; + + memcpy(block, zlib->buffer, written); + return (ssize_t)written; + } + + if (ret != Z_OK) { + fputs("zlib block processing failed\n", stderr); + return -1; + } + + return 0; +} + +compressor_t *create_zlib_compressor(bool compress, size_t block_size) +{ + zlib_compressor_t *zlib = calloc(1, sizeof(*zlib) + block_size); + compressor_t *base = (compressor_t *)zlib; + int ret; + + if (zlib == NULL) { + perror("creating zlib stream"); + return NULL; + } + + zlib->compress = compress; + zlib->block_size = block_size; + base->do_block = zlib_do_block; + base->destroy = zlib_destroy; + + if (compress) { + ret = deflateInit(&zlib->strm, Z_BEST_COMPRESSION); + } else { + ret = inflateInit(&zlib->strm); + } + + if (ret != Z_OK) { + fputs("internal error creating zlib stream\n", stderr); + free(zlib); + return NULL; + } + + return base; +} -- cgit v1.2.3