Add options for lzo compressor

Signed-off-by: David Oberhollenzer <david.oberhollenzer@sigma-star.at>

1 files changed, 216 insertions, 12 deletions

diff --git a/lib/comp/lzo.c b/lib/comp/lzo.c
index a7b6876..09d05ea 100644
--- a/lib/comp/lzo.c
+++ b/lib/comp/lzo.c
@@ -3,29 +3,125 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <ctype.h>
 
 #include <lzo/lzo1x.h>
 
 #include "internal.h"
 
+
+typedef enum {
+	LZO_ALGORITHM_LZO1X_1 = 0,
+	LZO_ALGORITHM_LZO1X_1_11 = 1,
+	LZO_ALGORITHM_LZO1X_1_12 = 2,
+	LZO_ALGORITHM_LZO1X_1_15 = 3,
+	LZO_ALGORITHM_LZO1X_999	= 4,
+} LZO_ALGORITHM;
+
+#define LZO_DEFAULT_ALG LZO_ALGORITHM_LZO1X_999
+#define LZO_DEFAULT_LEVEL 8
+#define LZO_NUM_ALGS (sizeof(lzo_algs) / sizeof(lzo_algs[0]))
+
+typedef int (*lzo_cb_t)(const lzo_bytep src, lzo_uint src_len, lzo_bytep dst,
+			lzo_uintp dst_len, lzo_voidp wrkmem);
+
+static const struct {
+	const char *name;
+	lzo_cb_t compress;
+	size_t bufsize;
+} lzo_algs[] = {
+	[LZO_ALGORITHM_LZO1X_1] = {
+		.name = "lzo1x_1",
+		.compress = lzo1x_1_compress,
+		.bufsize = LZO1X_1_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_1_11] = {
+		.name = "lzo1x_1_11",
+		.compress = lzo1x_1_11_compress,
+		.bufsize = LZO1X_1_11_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_1_12] = {
+		.name = "lzo1x_1_12",
+		.compress = lzo1x_1_12_compress,
+		.bufsize = LZO1X_1_12_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_1_15] = {
+		.name = "lzo1x_1_15",
+		.compress = lzo1x_1_15_compress,
+		.bufsize = LZO1X_1_15_MEM_COMPRESS,
+	},
+	[LZO_ALGORITHM_LZO1X_999] = {
+		.name = "lzo1x_999",
+		.compress = lzo1x_999_compress,
+		.bufsize = LZO1X_999_MEM_COMPRESS,
+	},
+};
+
 typedef struct {
 	compressor_t base;
+	int algorithm;
+	int level;
 
-	uint8_t buffer[LZO1X_999_MEM_COMPRESS];
+	uint8_t buffer[];
 } lzo_compressor_t;
 
+typedef struct {
+	uint32_t algorithm;
+	uint32_t level;
+} lzo_options_t;
+
 static int lzo_write_options(compressor_t *base, int fd)
 {
-	(void)base;
-	(void)fd;
-	return 0;
+	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
+	lzo_options_t opt;
+
+	if (lzo->algorithm == LZO_DEFAULT_ALG &&
+	    lzo->level == LZO_DEFAULT_LEVEL) {
+		return 0;
+	}
+
+	opt.algorithm = htole32(lzo->algorithm);
+
+	if (lzo->algorithm == LZO_ALGORITHM_LZO1X_999) {
+		opt.level = htole32(lzo->level);
+	} else {
+		opt.level = 0;
+	}
+
+	return generic_write_options(fd, &opt, sizeof(opt));
 }
 
 static int lzo_read_options(compressor_t *base, int fd)
 {
-	(void)base;
-	(void)fd;
-	fputs("lzo extra options are not yet implemented\n", stderr);
+	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
+	lzo_options_t opt;
+
+	if (generic_read_options(fd, &opt, sizeof(opt)))
+		return -1;
+
+	lzo->algorithm = le32toh(opt.algorithm);
+	lzo->level = le32toh(opt.level);
+
+	switch(lzo->algorithm) {
+	case LZO_ALGORITHM_LZO1X_1:
+	case LZO_ALGORITHM_LZO1X_1_11:
+	case LZO_ALGORITHM_LZO1X_1_12:
+	case LZO_ALGORITHM_LZO1X_1_15:
+		if (lzo->level != 0)
+			goto fail_level;
+		break;
+	case LZO_ALGORITHM_LZO1X_999:
+		if (lzo->level < 1 || lzo->level > 9)
+			goto fail_level;
+		break;
+	default:
+		fputs("Unsupported LZO variant specified.\n", stderr);
+		return -1;
+	}
+
+	return 0;
+fail_level:
+	fputs("Unsupported LZO compression level specified.\n", stderr);
 	return -1;
 }
 
@@ -34,10 +130,20 @@ static ssize_t lzo_comp_block(compressor_t *base, const uint8_t *in,
 {
 	lzo_compressor_t *lzo = (lzo_compressor_t *)base;
 	lzo_uint len = outsize;
+	int ret;
+
+	if (lzo->algorithm == LZO_ALGORITHM_LZO1X_999 &&
+	    lzo->level != LZO_DEFAULT_LEVEL) {
+		ret = lzo1x_999_compress_level(in, size, out, &len,
+					       lzo->buffer, NULL, 0, 0,
+					       lzo->level);
+	} else {
+		ret = lzo_algs[lzo->algorithm].compress(in, size, out,
+							&len, lzo->buffer);
+	}
 
-	if (lzo1x_999_compress(in, size, out, &len, lzo->buffer) != LZO_E_OK) {
-		fputs("lzo1x_999 failed. According to its "
-		      "manual, this shouldn't happen!\n", stderr);
+	if (ret != LZO_E_OK) {
+		fputs("LZO compression failed.\n", stderr);
 		return -1;
 	}
 
@@ -69,18 +175,101 @@ static void lzo_destroy(compressor_t *base)
 	free(base);
 }
 
+static int process_options(char *options, int *algorithm, int *level)
+{
+	enum {
+		OPT_ALG = 0,
+		OPT_LEVEL,
+	};
+	char *const token[] = {
+		[OPT_ALG] = (char *)"algorithm",
+		[OPT_LEVEL] = (char *)"level",
+		NULL
+	};
+	char *subopts, *value;
+	size_t i;
+	int opt;
+
+	subopts = options;
+
+	while (*subopts != '\0') {
+		opt = getsubopt(&subopts, token, &value);
+
+		switch (opt) {
+		case OPT_ALG:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; i < LZO_NUM_ALGS; ++i) {
+				if (strcmp(lzo_algs[i].name, value) == 0) {
+					*algorithm = i;
+					break;
+				}
+			}
+
+			if (i == LZO_NUM_ALGS) {
+				fprintf(stderr, "Unknown lzo variant '%s'.\n",
+					value);
+				return -1;
+			}
+			break;
+		case OPT_LEVEL:
+			if (value == NULL)
+				goto fail_value;
+
+			for (i = 0; isdigit(value[i]); ++i)
+				;
+
+			if (i < 1 || i > 3 || value[i] != '\0')
+				goto fail_level;
+
+			*level = atoi(value);
+
+			if (*level < 1 || *level > 9)
+				goto fail_level;
+			break;
+		default:
+			goto fail_opt;
+		}
+	}
+
+	return 0;
+fail_level:
+	fputs("Compression level must be a number between 1 and 9.\n", stderr);
+	return -1;
+fail_opt:
+	fprintf(stderr, "Unknown option '%s'.\n", value);
+	return -1;
+fail_value:
+	fprintf(stderr, "Missing value for '%s'.\n", token[opt]);
+	return -1;
+}
+
 compressor_t *create_lzo_compressor(bool compress, size_t block_size,
 				    char *options)
 {
-	lzo_compressor_t *lzo = calloc(1, sizeof(*lzo));
-	compressor_t *base = (compressor_t *)lzo;
+	lzo_compressor_t *lzo;
+	compressor_t *base;
+	int level, alg;
 	(void)block_size;
 
+	alg = LZO_DEFAULT_ALG;
+	level = LZO_DEFAULT_LEVEL;
+
+	if (options != NULL && process_options(options, &alg, &level) != 0)
+		return NULL;
+
+	lzo = calloc(1, sizeof(*lzo) + lzo_algs[alg].bufsize);
+	base = (compressor_t *)lzo;
+
 	if (lzo == NULL) {
 		perror("creating lzo compressor");
 		return NULL;
 	}
 
+	lzo->algorithm = alg;
+	lzo->level = level;
+
 	base->destroy = lzo_destroy;
 	base->do_block = compress ? lzo_comp_block : lzo_uncomp_block;
 	base->write_options = lzo_write_options;
@@ -90,4 +279,19 @@ compressor_t *create_lzo_compressor(bool compress, size_t block_size,
 
 void compressor_lzo_print_help(void)
 {
+	size_t i;
+
+	fputs("Available options for lzo compressor:\n"
+	      "\n"
+	      "    algorithm=<name>  Specify the variant of lzo to use.\n"
+	      "                      Defaults to 'lzo1x_999'.\n"
+	      "    level=<value>     For lzo1x_999, the compression level.\n"
+	      "                      Value from 1 to 9. Defaults to 8.\n"
+	      "                      Ignored if algorithm is not lzo1x_999.\n"
+	      "\n"
+	      "Available algorithms:\n",
+	      stdout);
+
+	for (i = 0; i < LZO_NUM_ALGS; ++i)
+		printf("\t%s\n", lzo_algs[i].name);
 }