libdeflate-sys 1.26.1

Bindings to libdeflate for DEFLATE (de)compression exposed as non-streaming buffer operations. Contains bindings for raw deflate, zlib, and gzip data.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

/*
 * test_custom_malloc.c
 *
 * Test the support for custom memory allocators.
 * Also test injecting allocation failures.
 */

#include "test_util.h"

static int malloc_count = 0;
static int free_count = 0;

static void *do_malloc(size_t size)
{
	malloc_count++;
	return malloc(size);
}

static void *do_fail_malloc(size_t size)
{
	malloc_count++;
	return NULL;
}

static void do_free(void *ptr)
{
	free_count++;
	free(ptr);
}

static void reset_state(void)
{
	libdeflate_set_memory_allocator(malloc, free);
	malloc_count = 0;
	free_count = 0;
}

/* Test that the custom allocator is actually used when requested. */
static void do_custom_memalloc_test(bool global)
{
	static const struct libdeflate_options options = {
		.sizeof_options = sizeof(options),
		.malloc_func = do_malloc,
		.free_func = do_free,
	};
	int level;
	struct libdeflate_compressor *c;
	struct libdeflate_decompressor *d;

	if (global)
		libdeflate_set_memory_allocator(do_malloc, do_free);

	for (level = 0; level <= 12; level++) {
		malloc_count = free_count = 0;
		if (global)
			c = libdeflate_alloc_compressor(level);
		else
			c = libdeflate_alloc_compressor_ex(level, &options);
		ASSERT(c != NULL);
		ASSERT(malloc_count == 1);
		ASSERT(free_count == 0);
		libdeflate_free_compressor(c);
		ASSERT(malloc_count == 1);
		ASSERT(free_count == 1);
	}

	malloc_count = free_count = 0;
	if (global)
		d = libdeflate_alloc_decompressor();
	else
		d = libdeflate_alloc_decompressor_ex(&options);
	ASSERT(d != NULL);
	ASSERT(malloc_count == 1);
	ASSERT(free_count == 0);
	libdeflate_free_decompressor(d);
	ASSERT(malloc_count == 1);
	ASSERT(free_count == 1);

	reset_state();
}

#define offsetofend(type, field) \
	(offsetof(type, field) + sizeof(((type *)NULL)->field))

/* Test some edge cases involving libdeflate_options. */
static void do_options_test(void)
{
	struct libdeflate_options options = { 0 };
	struct libdeflate_compressor *c;
	struct libdeflate_decompressor *d;
	/* Size in libdeflate v1.19 */
	size_t min_size = offsetofend(struct libdeflate_options, free_func);

	/* sizeof_options must be at least the minimum size. */
	for (; options.sizeof_options < min_size;
	     options.sizeof_options++) {
		c = libdeflate_alloc_compressor_ex(6, &options);
		ASSERT(c == NULL);
		d = libdeflate_alloc_decompressor_ex(&options);
		ASSERT(d == NULL);
	}

	/* NULL malloc_func and free_func means "use the global allocator". */
	options.sizeof_options = min_size;
	malloc_count = free_count = 0;
	libdeflate_set_memory_allocator(do_malloc, do_free);
	c = libdeflate_alloc_compressor_ex(6, &options);
	libdeflate_free_compressor(c);
	ASSERT(malloc_count == 1);
	ASSERT(free_count == 1);
	d = libdeflate_alloc_decompressor_ex(&options);
	libdeflate_free_decompressor(d);
	ASSERT(malloc_count == 2);
	ASSERT(free_count == 2);

	reset_state();
}

/* Test injecting memory allocation failures. */
static void do_fault_injection_test(void)
{
	int level;
	struct libdeflate_compressor *c;
	struct libdeflate_decompressor *d;

	libdeflate_set_memory_allocator(do_fail_malloc, do_free);

	for (level = 0; level <= 12; level++) {
		malloc_count = free_count = 0;
		c = libdeflate_alloc_compressor(level);
		ASSERT(c == NULL);
		ASSERT(malloc_count == 1);
		ASSERT(free_count == 0);
	}

	malloc_count = free_count = 0;
	d = libdeflate_alloc_decompressor();
	ASSERT(d == NULL);
	ASSERT(malloc_count == 1);
	ASSERT(free_count == 0);

	reset_state();
}

int
tmain(int argc, tchar *argv[])
{
	begin_program(argv);

	do_custom_memalloc_test(true);
	do_custom_memalloc_test(false);
	do_options_test();
	do_fault_injection_test();
	return 0;
}