libropkg: implement compressed file streams and tar-writer functionality

libropkg/zstd.c

@@ -0,0 +1,203 @@
+#include "compress.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <zstd.h>
+
+struct zstd_stream {
+	struct ropkg_compression_stream s_base;
+	union {
+		ZSTD_CCtx *c;
+		ZSTD_DCtx *d;
+	} s_ctx;
+};
+
+static enum ropkg_status zstd_buffer_size(
+	enum ropkg_compression_stream_mode mode,
+	size_t *in_buffer_size,
+	size_t *out_buffer_size)
+{
+	switch (mode) {
+	case ROPKG_COMPRESSION_MODE_COMPRESS:
+		if (in_buffer_size) {
+			*in_buffer_size = ZSTD_CStreamInSize();
+		}
+
+		if (out_buffer_size) {
+			*out_buffer_size = ZSTD_CStreamOutSize();
+		}
+		return ROPKG_SUCCESS;
+	case ROPKG_COMPRESSION_MODE_DECOMPRESS:
+		if (in_buffer_size) {
+			*in_buffer_size = ZSTD_DStreamInSize();
+		}
+
+		if (out_buffer_size) {
+			*out_buffer_size = ZSTD_DStreamOutSize();
+		}
+		return ROPKG_SUCCESS;
+	default:
+		return ROPKG_ERR_INVALID_ARGUMENT;
+	}
+}
+
+static enum ropkg_status zstd_open(
+	const struct ropkg_compression_function *func,
+	enum ropkg_compression_stream_mode mode,
+	void *in_buffer,
+	size_t in_max,
+	void *out_buffer,
+	size_t out_max,
+	struct ropkg_compression_stream **out)
+{
+	struct zstd_stream *stream = malloc(sizeof *stream);
+	if (!stream) {
+		return ROPKG_ERR_NO_MEMORY;
+	}
+
+	memset(stream, 0x0, sizeof *stream);
+
+	stream->s_base.s_in = in_buffer;
+	stream->s_base.s_in_max = in_max;
+	stream->s_base.s_out = out_buffer;
+	stream->s_base.s_out_max = out_max;
+	stream->s_base.s_func = func;
+	stream->s_base.s_mode = mode;
+
+	switch (mode) {
+	case ROPKG_COMPRESSION_MODE_COMPRESS:
+		stream->s_ctx.c = ZSTD_createCCtx();
+
+		if (!stream->s_ctx.c) {
+			free(stream);
+			return ROPKG_ERR_NO_MEMORY;
+		}
+
+		ZSTD_CCtx_setParameter(
+			stream->s_ctx.c,
+			ZSTD_c_compressionLevel,
+			10);
+		ZSTD_CCtx_setParameter(stream->s_ctx.c, ZSTD_c_checksumFlag, 1);
+		break;
+	case ROPKG_COMPRESSION_MODE_DECOMPRESS:
+		stream->s_ctx.d = ZSTD_createDCtx();
+
+		if (!stream->s_ctx.d) {
+			free(stream);
+			return ROPKG_ERR_NO_MEMORY;
+		}
+
+		break;
+	default:
+		free(stream);
+		return ROPKG_ERR_INVALID_ARGUMENT;
+	}
+
+	*out = &stream->s_base;
+	return ROPKG_SUCCESS;
+}
+
+static enum ropkg_status zstd_close(struct ropkg_compression_stream *stream)
+{
+	struct zstd_stream *zstream = (struct zstd_stream *)stream;
+	switch (stream->s_mode) {
+	case ROPKG_COMPRESSION_MODE_COMPRESS:
+		ZSTD_freeCCtx(zstream->s_ctx.c);
+		break;
+	case ROPKG_COMPRESSION_MODE_DECOMPRESS:
+		ZSTD_freeDCtx(zstream->s_ctx.d);
+		break;
+	default:
+		return ROPKG_ERR_BAD_STATE;
+	}
+
+	free(stream);
+	return ROPKG_SUCCESS;
+}
+
+static enum ropkg_status zstd_compress(
+	struct zstd_stream *zstream,
+	enum ropkg_compression_stream_op op,
+	ZSTD_inBuffer *in,
+	ZSTD_outBuffer *out)
+{
+	ZSTD_EndDirective zop;
+
+	switch (op) {
+	case ROPKG_COMPRESSION_OP_CONTINUE:
+		zop = ZSTD_e_continue;
+		break;
+	case ROPKG_COMPRESSION_OP_END:
+		zop = ZSTD_e_end;
+		break;
+	default:
+		return ROPKG_ERR_INVALID_ARGUMENT;
+	}
+
+	do {
+		size_t ret
+			= ZSTD_compressStream2(zstream->s_ctx.c, out, in, zop);
+
+		if (ret == 0) {
+			break;
+		}
+	} while (in->pos < in->size);
+
+	return ROPKG_SUCCESS;
+}
+
+static enum ropkg_status zstd_decompress(
+	struct zstd_stream *zstream,
+	ZSTD_inBuffer *in,
+	ZSTD_outBuffer *out)
+{
+	size_t ret = 0;
+
+	while (in->pos < in->size) {
+		ret = ZSTD_decompressStream(zstream->s_ctx.d, out, in);
+	}
+
+	if (ret != 0) {
+		return ROPKG_ERR_INTERNAL_FAILURE;
+	}
+
+	return ROPKG_SUCCESS;
+}
+
+static enum ropkg_status zstd_process(
+	struct ropkg_compression_stream *stream,
+	size_t in_size,
+	enum ropkg_compression_stream_op op,
+	size_t *out_size)
+{
+	struct zstd_stream *zstream = (struct zstd_stream *)stream;
+	ZSTD_inBuffer in = {.src = stream->s_in, .size = in_size};
+	ZSTD_outBuffer out = {.dst = stream->s_out, .size = stream->s_out_max};
+
+	enum ropkg_status status;
+	switch (stream->s_mode) {
+	case ROPKG_COMPRESSION_MODE_COMPRESS:
+		status = zstd_compress(zstream, op, &in, &out);
+		break;
+	case ROPKG_COMPRESSION_MODE_DECOMPRESS:
+		status = zstd_decompress(zstream, &in, &out);
+		break;
+	default:
+		return ROPKG_ERR_BAD_STATE;
+	}
+
+	if (out_size) {
+		*out_size = out.pos;
+	}
+
+	return ROPKG_SUCCESS;
+}
+
+const struct ropkg_compression_function ropkg_zstd = {
+	.f_name = "zstd",
+	.f_extension = ".zst",
+	.f_buffer_size = zstd_buffer_size,
+	.f_open = zstd_open,
+	.f_close = zstd_close,
+	.f_process = zstd_process,
+};