regress_zlib.c revision 285612 
1/*
2 * Copyright (c) 2008-2012 Niels Provos and Nick Mathewson
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 *    derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27/* The old tests here need assertions to work. */
28#undef NDEBUG
29
30#ifdef _WIN32
31#include <winsock2.h>
32#include <windows.h>
33#endif
34
35#include "event2/event-config.h"
36
37#include <sys/types.h>
38#ifndef _WIN32
39#include <sys/socket.h>
40#include <sys/wait.h>
41#include <unistd.h>
42#include <netdb.h>
43#endif
44#include <signal.h>
45#include <stdio.h>
46#include <stdlib.h>
47#include <string.h>
48
49#include <assert.h>
50#include <errno.h>
51
52#include "event2/util.h"
53#include "event2/event.h"
54#include "event2/event_compat.h"
55#include "event2/buffer.h"
56#include "event2/bufferevent.h"
57
58#include "regress.h"
59#include "mm-internal.h"
60
61/* zlib 1.2.4 and 1.2.5 do some "clever" things with macros.  Instead of
62   saying "(defined(FOO) ? FOO : 0)" they like to say "FOO-0", on the theory
63   that nobody will care if the compile outputs a no-such-identifier warning.
64
65   Sorry, but we like -Werror over here, so I guess we need to define these.
66   I hope that zlib 1.2.6 doesn't break these too.
67*/
68#ifndef _LARGEFILE64_SOURCE
69#define _LARGEFILE64_SOURCE 0
70#endif
71#ifndef _LFS64_LARGEFILE
72#define _LFS64_LARGEFILE 0
73#endif
74#ifndef _FILE_OFFSET_BITS
75#define _FILE_OFFSET_BITS 0
76#endif
77#ifndef off64_t
78#define off64_t ev_int64_t
79#endif
80
81#include <zlib.h>
82
83static int infilter_calls;
84static int outfilter_calls;
85static int readcb_finished;
86static int writecb_finished;
87static int errorcb_invoked;
88
89/*
90 * Zlib filters
91 */
92
93static void
94zlib_deflate_free(void *ctx)
95{
96	z_streamp p = ctx;
97
98	assert(deflateEnd(p) == Z_OK);
99	mm_free(p);
100}
101
102static void
103zlib_inflate_free(void *ctx)
104{
105	z_streamp p = ctx;
106
107	assert(inflateEnd(p) == Z_OK);
108	mm_free(p);
109}
110
111static int
112getstate(enum bufferevent_flush_mode state)
113{
114	switch (state) {
115	case BEV_FINISHED:
116		return Z_FINISH;
117	case BEV_FLUSH:
118		return Z_SYNC_FLUSH;
119	case BEV_NORMAL:
120	default:
121		return Z_NO_FLUSH;
122	}
123}
124
125/*
126 * The input filter is triggered only on new input read from the network.
127 * That means all input data needs to be consumed or the filter needs to
128 * initiate its own triggering via a timeout.
129 */
130static enum bufferevent_filter_result
131zlib_input_filter(struct evbuffer *src, struct evbuffer *dst,
132    ev_ssize_t lim, enum bufferevent_flush_mode state, void *ctx)
133{
134	struct evbuffer_iovec v_in[1];
135	struct evbuffer_iovec v_out[1];
136	int nread, nwrite;
137	int res, n;
138
139	z_streamp p = ctx;
140
141	do {
142		/* let's do some decompression */
143		n = evbuffer_peek(src, -1, NULL, v_in, 1);
144		if (n) {
145			p->avail_in = v_in[0].iov_len;
146			p->next_in = v_in[0].iov_base;
147		} else {
148			p->avail_in = 0;
149			p->next_in = 0;
150		}
151
152		evbuffer_reserve_space(dst, 4096, v_out, 1);
153		p->next_out = v_out[0].iov_base;
154		p->avail_out = v_out[0].iov_len;
155
156		/* we need to flush zlib if we got a flush */
157		res = inflate(p, getstate(state));
158
159		/* let's figure out how much was compressed */
160		nread = v_in[0].iov_len - p->avail_in;
161		nwrite = v_out[0].iov_len - p->avail_out;
162
163		evbuffer_drain(src, nread);
164		v_out[0].iov_len = nwrite;
165		evbuffer_commit_space(dst, v_out, 1);
166
167		if (res==Z_BUF_ERROR) {
168			/* We're out of space, or out of decodeable input.
169			   Only if nwrite == 0 assume the latter.
170			 */
171			if (nwrite == 0)
172				return BEV_NEED_MORE;
173		} else {
174			assert(res == Z_OK || res == Z_STREAM_END);
175		}
176
177	} while (evbuffer_get_length(src) > 0);
178
179	++infilter_calls;
180
181	return (BEV_OK);
182}
183
184static enum bufferevent_filter_result
185zlib_output_filter(struct evbuffer *src, struct evbuffer *dst,
186    ev_ssize_t lim, enum bufferevent_flush_mode state, void *ctx)
187{
188	struct evbuffer_iovec v_in[1];
189	struct evbuffer_iovec v_out[1];
190	int nread, nwrite;
191	int res, n;
192
193	z_streamp p = ctx;
194
195	do {
196		/* let's do some compression */
197		n = evbuffer_peek(src, -1, NULL, v_in, 1);
198		if (n) {
199			p->avail_in = v_in[0].iov_len;
200			p->next_in = v_in[0].iov_base;
201		} else {
202			p->avail_in = 0;
203			p->next_in = 0;
204		}
205
206		evbuffer_reserve_space(dst, 4096, v_out, 1);
207		p->next_out = v_out[0].iov_base;
208		p->avail_out = v_out[0].iov_len;
209
210		/* we need to flush zlib if we got a flush */
211		res = deflate(p, getstate(state));
212
213		/* let's figure out how much was decompressed */
214		nread = v_in[0].iov_len - p->avail_in;
215		nwrite = v_out[0].iov_len - p->avail_out;
216
217		evbuffer_drain(src, nread);
218		v_out[0].iov_len = nwrite;
219		evbuffer_commit_space(dst, v_out, 1);
220
221		if (res==Z_BUF_ERROR) {
222			/* We're out of space, or out of decodeable input.
223			   Only if nwrite == 0 assume the latter.
224			 */
225			if (nwrite == 0)
226				return BEV_NEED_MORE;
227		} else {
228			assert(res == Z_OK || res == Z_STREAM_END);
229		}
230
231	} while (evbuffer_get_length(src) > 0);
232
233	++outfilter_calls;
234
235	return (BEV_OK);
236}
237
238/*
239 * simple bufferevent test (over transparent zlib treatment)
240 */
241
242static void
243readcb(struct bufferevent *bev, void *arg)
244{
245	if (evbuffer_get_length(bufferevent_get_input(bev)) == 8333) {
246		struct evbuffer *evbuf = evbuffer_new();
247		assert(evbuf != NULL);
248
249		/* gratuitous test of bufferevent_read_buffer */
250		bufferevent_read_buffer(bev, evbuf);
251
252		bufferevent_disable(bev, EV_READ);
253
254		if (evbuffer_get_length(evbuf) == 8333) {
255			++readcb_finished;
256		}
257
258		evbuffer_free(evbuf);
259	}
260}
261
262static void
263writecb(struct bufferevent *bev, void *arg)
264{
265	if (evbuffer_get_length(bufferevent_get_output(bev)) == 0) {
266		++writecb_finished;
267	}
268}
269
270static void
271errorcb(struct bufferevent *bev, short what, void *arg)
272{
273	errorcb_invoked = 1;
274}
275
276void
277test_bufferevent_zlib(void *arg)
278{
279	struct bufferevent *bev1=NULL, *bev2=NULL;
280	char buffer[8333];
281	z_stream *z_input, *z_output;
282	int i, r;
283	evutil_socket_t pair[2] = {-1, -1};
284	(void)arg;
285
286	infilter_calls = outfilter_calls = readcb_finished = writecb_finished
287	    = errorcb_invoked = 0;
288
289	if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
290		tt_abort_perror("socketpair");
291	}
292
293	evutil_make_socket_nonblocking(pair[0]);
294	evutil_make_socket_nonblocking(pair[1]);
295
296	bev1 = bufferevent_socket_new(NULL, pair[0], 0);
297	bev2 = bufferevent_socket_new(NULL, pair[1], 0);
298
299	z_output = mm_calloc(sizeof(*z_output), 1);
300	r = deflateInit(z_output, Z_DEFAULT_COMPRESSION);
301	tt_int_op(r, ==, Z_OK);
302	z_input = mm_calloc(sizeof(*z_input), 1);
303	r = inflateInit(z_input);
304	tt_int_op(r, ==, Z_OK);
305
306	/* initialize filters */
307	bev1 = bufferevent_filter_new(bev1, NULL, zlib_output_filter,
308	    BEV_OPT_CLOSE_ON_FREE, zlib_deflate_free, z_output);
309	bev2 = bufferevent_filter_new(bev2, zlib_input_filter,
310	    NULL, BEV_OPT_CLOSE_ON_FREE, zlib_inflate_free, z_input);
311	bufferevent_setcb(bev1, readcb, writecb, errorcb, NULL);
312	bufferevent_setcb(bev2, readcb, writecb, errorcb, NULL);
313
314	bufferevent_disable(bev1, EV_READ);
315	bufferevent_enable(bev1, EV_WRITE);
316
317	bufferevent_enable(bev2, EV_READ);
318
319	for (i = 0; i < (int)sizeof(buffer); i++)
320		buffer[i] = i;
321
322	/* break it up into multiple buffer chains */
323	bufferevent_write(bev1, buffer, 1800);
324	bufferevent_write(bev1, buffer + 1800, sizeof(buffer) - 1800);
325
326	/* we are done writing - we need to flush everything */
327	bufferevent_flush(bev1, EV_WRITE, BEV_FINISHED);
328
329	event_dispatch();
330
331	tt_want(infilter_calls);
332	tt_want(outfilter_calls);
333	tt_want(readcb_finished);
334	tt_want(writecb_finished);
335	tt_want(!errorcb_invoked);
336
337	test_ok = 1;
338end:
339	if (bev1)
340		bufferevent_free(bev1);
341	if (bev2)
342		bufferevent_free(bev2);
343
344	if (pair[0] >= 0)
345		evutil_closesocket(pair[0]);
346	if (pair[1] >= 0)
347		evutil_closesocket(pair[1]);
348}
349