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
83 static int infilter_calls;
84 static int outfilter_calls;
85 static int readcb_finished;
86 static int writecb_finished;
87 static int errorcb_invoked;
88
89 /*
90 * Zlib filters
91 */
92
93 static void
zlib_deflate_free(void * ctx)94 zlib_deflate_free(void *ctx)
95 {
96 z_streamp p = ctx;
97
98 assert(deflateEnd(p) == Z_OK);
99 mm_free(p);
100 }
101
102 static void
zlib_inflate_free(void * ctx)103 zlib_inflate_free(void *ctx)
104 {
105 z_streamp p = ctx;
106
107 assert(inflateEnd(p) == Z_OK);
108 mm_free(p);
109 }
110
111 static int
getstate(enum bufferevent_flush_mode state)112 getstate(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 */
130 static enum bufferevent_filter_result
zlib_input_filter(struct evbuffer * src,struct evbuffer * dst,ev_ssize_t lim,enum bufferevent_flush_mode state,void * ctx)131 zlib_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 = (unsigned char *)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 = (unsigned char *)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
184 static enum bufferevent_filter_result
zlib_output_filter(struct evbuffer * src,struct evbuffer * dst,ev_ssize_t lim,enum bufferevent_flush_mode state,void * ctx)185 zlib_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 = (unsigned char *)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 = (unsigned char *)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
242 static void
readcb(struct bufferevent * bev,void * arg)243 readcb(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
262 static void
writecb(struct bufferevent * bev,void * arg)263 writecb(struct bufferevent *bev, void *arg)
264 {
265 if (evbuffer_get_length(bufferevent_get_output(bev)) == 0) {
266 ++writecb_finished;
267 }
268 }
269
270 static void
errorcb(struct bufferevent * bev,short what,void * arg)271 errorcb(struct bufferevent *bev, short what, void *arg)
272 {
273 errorcb_invoked = 1;
274 }
275
276 void
test_bufferevent_zlib(void * arg)277 test_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;
338 end:
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