libdeflate 0.1.0

data/ext/libdeflate/libdeflate/programs/prog_util.h

@@ -0,0 +1,162 @@
+/*
+ * prog_util.h - utility functions for programs
+ *
+ * Copyright 2016 Eric Biggers
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef PROGRAMS_PROG_UTIL_H
+#define PROGRAMS_PROG_UTIL_H
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include "libdeflate.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common_defs.h"
+
+#ifdef __GNUC__
+# define _printf(str_idx, args_idx)	\
+		__attribute__((format(printf, str_idx, args_idx)))
+#else
+# define _printf(str_idx, args_idx)
+#endif
+
+#ifdef _WIN32
+
+/*
+ * Definitions for Windows builds.  Mainly, 'tchar' is defined to be the 2-byte
+ * 'wchar_t' type instead of 'char'.  This is the only "easy" way I know of to
+ * get full Unicode support on Windows...
+ */
+
+#include <wchar.h>
+extern int wmain(int argc, wchar_t **argv);
+#  define	tmain		wmain
+#  define	tchar		wchar_t
+#  define	_T(text)	L##text
+#  define	T(text)		_T(text)
+#  define	TS		"ls"
+#  define	TC		"lc"
+#  define	tmemcpy		wmemcpy
+#  define	topen		_wopen
+#  define	tstrchr		wcschr
+#  define	tstrcmp		wcscmp
+#  define	tstrcpy		wcscpy
+#  define	tstrlen		wcslen
+#  define	tstrrchr	wcsrchr
+#  define	tstrtoul	wcstoul
+#  define	tstrxcmp	wcsicmp
+#  define	tunlink		_wunlink
+#  define	tutimbuf	__utimbuf64
+#  define	tutime		_wutime64
+#  define	tstat		_wstat64
+#  define	tfstat		_fstat64
+#  define	stat_t		struct _stat64
+#  ifdef _MSC_VER
+#    define	STDIN_FILENO	0
+#    define	STDOUT_FILENO	1
+#    define	STDERR_FILENO	2
+#    define	S_ISREG(m)      (((m) & S_IFMT) == S_IFREG)
+#    define	S_ISDIR(m)      (((m) & S_IFMT) == S_IFDIR)
+#  endif
+
+#else /* _WIN32 */
+
+/* Standard definitions for everyone else */
+
+#  define	tmain		main
+#  define	tchar		char
+#  define	T(text)		text
+#  define	TS		"s"
+#  define	TC		"c"
+#  define	tmemcpy		memcpy
+#  define	topen		open
+#  define	tstrchr		strchr
+#  define	tstrcmp		strcmp
+#  define	tstrcpy		strcpy
+#  define	tstrlen		strlen
+#  define	tstrrchr	strrchr
+#  define	tstrtoul	strtoul
+#  define	tstrxcmp	strcmp
+#  define	tunlink		unlink
+#  define	tutimbuf	utimbuf
+#  define	tutime		utime
+#  define	tstat		stat
+#  define	tfstat		fstat
+#  define	stat_t		struct stat
+
+#endif /* !_WIN32 */
+
+extern const tchar *program_invocation_name;
+
+extern void _printf(1, 2) msg(const char *fmt, ...);
+extern void _printf(1, 2) msg_errno(const char *fmt, ...);
+
+extern void *xmalloc(size_t size);
+
+extern u64 timer_ticks(void);
+extern u64 timer_ticks_to_ms(u64 ticks);
+extern u64 timer_MB_per_s(u64 bytes, u64 ticks);
+
+extern const tchar *get_filename(const tchar *path);
+
+struct file_stream {
+	int fd;
+	tchar *name;
+	bool is_standard_stream;
+	void *mmap_token;
+	void *mmap_mem;
+	size_t mmap_size;
+};
+
+extern int xopen_for_read(const tchar *path, bool symlink_ok,
+			  struct file_stream *strm);
+extern int xopen_for_write(const tchar *path, bool force,
+			   struct file_stream *strm);
+extern int map_file_contents(struct file_stream *strm, u64 size);
+
+extern ssize_t xread(struct file_stream *strm, void *buf, size_t count);
+extern int full_write(struct file_stream *strm, const void *buf, size_t count);
+
+extern int xclose(struct file_stream *strm);
+
+extern int parse_compression_level(tchar opt_char, const tchar *arg);
+
+extern struct libdeflate_compressor *alloc_compressor(int level);
+extern struct libdeflate_decompressor *alloc_decompressor(void);
+
+/* tgetopt.c */
+
+extern tchar *toptarg;
+extern int toptind, topterr, toptopt;
+
+extern int tgetopt(int argc, tchar *argv[], const tchar *optstring);
+
+#endif /* PROGRAMS_PROG_UTIL_H */

data/ext/libdeflate/libdeflate/programs/test_checksums.c

@@ -0,0 +1,135 @@
+/*
+ * test_checksums.c
+ *
+ * Verify that libdeflate's Adler-32 and CRC-32 functions produce the same
+ * results as their zlib equivalents.
+ */
+
+#include <time.h>
+#include <zlib.h>
+
+#include "prog_util.h"
+
+static unsigned int rng_seed;
+
+static void
+assertion_failed(const char *file, int line)
+{
+	fprintf(stderr, "Assertion failed at %s:%d\n", file, line);
+	fprintf(stderr, "RNG seed was %u\n", rng_seed);
+	abort();
+}
+
+#define ASSERT(expr) if (!(expr)) assertion_failed(__FILE__, __LINE__);
+
+typedef u32 (*cksum_fn_t)(u32, const void *, size_t);
+
+static u32
+zlib_adler32(u32 adler, const void *buf, size_t len)
+{
+	return adler32(adler, buf, len);
+}
+
+static u32
+zlib_crc32(u32 crc, const void *buf, size_t len)
+{
+	return crc32(crc, buf, len);
+}
+
+static u32
+select_initial_crc(void)
+{
+	if (rand() & 1)
+		return 0;
+	return ((u32)rand() << 16) | rand();
+}
+
+static u32
+select_initial_adler(void)
+{
+	if (rand() & 1)
+		return 1;
+	return ((u32)(rand() % 65521) << 16) | (rand() % 65521);
+}
+
+static void
+test_initial_values(cksum_fn_t cksum, u32 expected)
+{
+	ASSERT(cksum(0, NULL, 0) == expected);
+	if (cksum != zlib_adler32) /* broken */
+		ASSERT(cksum(0, NULL, 1) == expected);
+	ASSERT(cksum(0, NULL, 1234) == expected);
+	ASSERT(cksum(1234, NULL, 0) == expected);
+	ASSERT(cksum(1234, NULL, 1234) == expected);
+}
+
+static void
+test_multipart(const u8 *buffer, unsigned size, const char *name,
+	       cksum_fn_t cksum, u32 v, u32 expected)
+{
+	unsigned division = (size != 0) ? rand() % size : 0;
+	v = cksum(v, buffer, division);
+	v = cksum(v, buffer + division, size - division);
+	if (v != expected) {
+		fprintf(stderr, "%s checksum failed multipart test\n", name);
+		ASSERT(0);
+	}
+}
+
+static void
+test_checksums(const void *buffer, unsigned size, const char *name,
+	       cksum_fn_t cksum1, cksum_fn_t cksum2, u32 initial_value)
+{
+	u32 v1 = cksum1(initial_value, buffer, size);
+	u32 v2 = cksum2(initial_value, buffer, size);
+
+	if (v1 != v2) {
+		fprintf(stderr, "%s checksum mismatch\n", name);
+		fprintf(stderr, "initial_value=0x%08"PRIx32", buffer=%p, "
+			"contents ", initial_value, buffer);
+		for (unsigned i = 0; i < size; i++)
+			fprintf(stderr, "%02x", ((const u8 *)buffer)[i]);
+		fprintf(stderr, "\n");
+		ASSERT(0);
+	}
+
+	if ((rand() & 15) == 0) {
+		test_multipart(buffer, size, name, cksum1, initial_value, v1);
+		test_multipart(buffer, size, name, cksum2, initial_value, v1);
+	}
+}
+
+int
+tmain(int argc, tchar *argv[])
+{
+	u8 buffer[256];
+
+	rng_seed = time(NULL);
+	srand(rng_seed);
+
+	test_initial_values(libdeflate_adler32, 1);
+	test_initial_values(zlib_adler32, 1);
+	test_initial_values(libdeflate_crc32, 0);
+	test_initial_values(zlib_crc32, 0);
+
+	for (uint32_t i = 0; i < 50000; i++) {
+		/* test different buffer sizes and alignments */
+		int start = rand() % sizeof(buffer);
+		int len = rand() % (sizeof(buffer) - start);
+
+		for (int i = start; i < start + len; i++)
+			buffer[i] = rand();
+
+		test_checksums(&buffer[start], len, "Adler-32",
+			       libdeflate_adler32, zlib_adler32,
+			       select_initial_adler());
+
+		test_checksums(&buffer[start], len, "CRC-32",
+			       libdeflate_crc32, zlib_crc32,
+			       select_initial_crc());
+	}
+
+	printf("Adler-32 and CRC-32 checksum tests passed!\n");
+
+	return 0;
+}

data/ext/libdeflate/libdeflate/programs/tgetopt.c

@@ -0,0 +1,118 @@
+/*
+ * tgetopt.c - portable replacement for GNU getopt()
+ *
+ * Copyright 2016 Eric Biggers
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "prog_util.h"
+
+tchar *toptarg;
+int toptind = 1, topterr = 1, toptopt;
+
+/*
+ * This is a simple implementation of getopt().  It can be compiled with either
+ * 'char' or 'wchar_t' as the character type.
+ *
+ * Do *not* use this implementation if you need any of the following features,
+ * as they are not supported:
+ *	- Long options
+ *	- Option-related arguments retained in argv, not nulled out
+ *	- '+' and '-' characters in optstring
+ */
+int
+tgetopt(int argc, tchar *argv[], const tchar *optstring)
+{
+	static tchar empty[1];
+	static tchar *nextchar;
+	static bool done;
+
+	if (toptind == 1) {
+		/* Starting to scan a new argument vector */
+		nextchar = NULL;
+		done = false;
+	}
+
+	while (!done && (nextchar != NULL || toptind < argc)) {
+		if (nextchar == NULL) {
+			/* Scanning a new argument */
+			tchar *arg = argv[toptind++];
+			if (arg[0] == '-' && arg[1] != '\0') {
+				if (arg[1] == '-' && arg[2] == '\0') {
+					/* All args after "--" are nonoptions */
+					argv[toptind - 1] = NULL;
+					done = true;
+				} else {
+					/* Start of short option characters */
+					nextchar = &arg[1];
+				}
+			}
+		} else {
+			/* More short options in previous arg */
+			tchar opt = *nextchar;
+			tchar *p = tstrchr(optstring, opt);
+			if (p == NULL) {
+				if (topterr)
+					msg("invalid option -- '%"TC"'", opt);
+				toptopt = opt;
+				return '?';
+			}
+			/* 'opt' is a valid short option character */
+			nextchar++;
+			toptarg = NULL;
+			if (*(p + 1) == ':') {
+				/* 'opt' can take an argument */
+				if (*nextchar != '\0') {
+					/* Optarg is in same argv argument */
+					toptarg = nextchar;
+					nextchar = empty;
+				} else if (toptind < argc && *(p + 2) != ':') {
+					/* Optarg is next argv argument */
+					argv[toptind - 1] = NULL;
+					toptarg = argv[toptind++];
+				} else if (*(p + 2) != ':') {
+					if (topterr && *optstring != ':') {
+						msg("option requires an "
+						    "argument -- '%"TC"'", opt);
+					}
+					toptopt = opt;
+					opt = (*optstring == ':') ? ':' : '?';
+				}
+			}
+			if (*nextchar == '\0') {
+				argv[toptind - 1] = NULL;
+				nextchar = NULL;
+			}
+			return opt;
+		}
+	}
+
+	/* Done scanning.  Move all nonoptions to the end, set optind to the
+	 * index of the first nonoption, and return -1. */
+	toptind = argc;
+	while (--argc > 0)
+		if (argv[argc] != NULL)
+			argv[--toptind] = argv[argc];
+	done = true;
+	return -1;
+}

data/ext/libdeflate/libdeflate/tools/afl-fuzz/Makefile

@@ -0,0 +1,12 @@
+SRC := $(wildcard */*.c)
+EXE := $(SRC:.c=)
+
+CFLAGS := -O2 -s
+LDLIBS := -ldeflate
+LDFLAGS := -L../..
+CPPFLAGS := -I../..
+
+all:$(EXE)
+
+clean:
+	rm -f $(EXE)

data/ext/libdeflate/libdeflate/tools/afl-fuzz/deflate_compress/fuzz.c

@@ -0,0 +1,40 @@
+#include <assert.h>
+#include <libdeflate.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+int main(int argc, char **argv)
+{
+	struct libdeflate_decompressor *d;
+	struct libdeflate_compressor *c;
+	int ret;
+	int fd = open(argv[1], O_RDONLY);
+	struct stat stbuf;
+	assert(fd >= 0);
+	ret = fstat(fd, &stbuf);
+	assert(!ret);
+
+	char in[stbuf.st_size];
+	ret = read(fd, in, sizeof in);
+	assert(ret == sizeof in);
+
+	c = libdeflate_alloc_compressor(6);
+	d = libdeflate_alloc_decompressor();
+
+	char out[sizeof(in)];
+	char checkarray[sizeof(in)];
+
+	size_t csize = libdeflate_deflate_compress(c, in,sizeof in, out, sizeof out);
+	if (csize) {
+		enum libdeflate_result res;
+		res = libdeflate_deflate_decompress(d, out, csize, checkarray, sizeof in, NULL);
+		assert(!res);
+		assert(!memcmp(in, checkarray, sizeof in));
+	}
+
+	libdeflate_free_compressor(c);
+	libdeflate_free_decompressor(d);
+	return 0;
+}