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 60/* zlib 1.2.4 and 1.2.5 do some "clever" things with macros. Instead of 61 saying "(defined(FOO) ? FOO : 0)" they like to say "FOO-0", on the theory 62 that nobody will care if the compile outputs a no-such-identifier warning. 63 64 Sorry, but we like -Werror over here, so I guess we need to define these. 65 I hope that zlib 1.2.6 doesn't break these too. 66*/ 67#ifndef _LARGEFILE64_SOURCE 68#define _LARGEFILE64_SOURCE 0 69#endif 70#ifndef _LFS64_LARGEFILE 71#define _LFS64_LARGEFILE 0 72#endif 73#ifndef _FILE_OFFSET_BITS 74#define _FILE_OFFSET_BITS 0 75#endif 76#ifndef off64_t 77#define off64_t ev_int64_t 78#endif 79 80#include <zlib.h> 81 82static int infilter_calls; 83static int outfilter_calls; 84static int readcb_finished; 85static int writecb_finished; 86static int errorcb_invoked; 87 88/* 89 * Zlib filters 90 */ 91 92static void 93zlib_deflate_free(void *ctx) 94{ 95 z_streamp p = ctx; 96 97 assert(deflateEnd(p) == Z_OK); 98} 99 100static void 101zlib_inflate_free(void *ctx) 102{ 103 z_streamp p = ctx; 104 105 assert(inflateEnd(p) == Z_OK); 106} 107 108static int 109getstate(enum bufferevent_flush_mode state) 110{ 111 switch (state) { 112 case BEV_FINISHED: 113 return Z_FINISH; 114 case BEV_FLUSH: 115 return Z_SYNC_FLUSH; 116 case BEV_NORMAL: 117 default: 118 return Z_NO_FLUSH; 119 } 120} 121 122/* 123 * The input filter is triggered only on new input read from the network. 124 * That means all input data needs to be consumed or the filter needs to 125 * initiate its own triggering via a timeout. 126 */ 127static enum bufferevent_filter_result 128zlib_input_filter(struct evbuffer *src, struct evbuffer *dst, 129 ev_ssize_t lim, enum bufferevent_flush_mode state, void *ctx) 130{ 131 struct evbuffer_iovec v_in[1]; 132 struct evbuffer_iovec v_out[1]; 133 int nread, nwrite; 134 int res, n; 135 136 z_streamp p = ctx; 137 138 do { 139 /* let's do some decompression */ 140 n = evbuffer_peek(src, -1, NULL, v_in, 1); 141 if (n) { 142 p->avail_in = v_in[0].iov_len; 143 p->next_in = v_in[0].iov_base; 144 } else { 145 p->avail_in = 0; 146 p->next_in = 0; 147 } 148 149 evbuffer_reserve_space(dst, 4096, v_out, 1); 150 p->next_out = v_out[0].iov_base; 151 p->avail_out = v_out[0].iov_len; 152 153 /* we need to flush zlib if we got a flush */ 154 res = inflate(p, getstate(state)); 155 156 /* let's figure out how much was compressed */ 157 nread = v_in[0].iov_len - p->avail_in; 158 nwrite = v_out[0].iov_len - p->avail_out; 159 160 evbuffer_drain(src, nread); 161 v_out[0].iov_len = nwrite; 162 evbuffer_commit_space(dst, v_out, 1); 163 164 if (res==Z_BUF_ERROR) { 165 /* We're out of space, or out of decodeable input. 166 Only if nwrite == 0 assume the latter. 167 */ 168 if (nwrite == 0) 169 return BEV_NEED_MORE; 170 } else { 171 assert(res == Z_OK || res == Z_STREAM_END); 172 } 173 174 } while (evbuffer_get_length(src) > 0); 175 176 ++infilter_calls; 177 178 return (BEV_OK); 179} 180 181static enum bufferevent_filter_result 182zlib_output_filter(struct evbuffer *src, struct evbuffer *dst, 183 ev_ssize_t lim, enum bufferevent_flush_mode state, void *ctx) 184{ 185 struct evbuffer_iovec v_in[1]; 186 struct evbuffer_iovec v_out[1]; 187 int nread, nwrite; 188 int res, n; 189 190 z_streamp p = ctx; 191 192 do { 193 /* let's do some compression */ 194 n = evbuffer_peek(src, -1, NULL, v_in, 1); 195 if (n) { 196 p->avail_in = v_in[0].iov_len; 197 p->next_in = v_in[0].iov_base; 198 } else { 199 p->avail_in = 0; 200 p->next_in = 0; 201 } 202 203 evbuffer_reserve_space(dst, 4096, v_out, 1); 204 p->next_out = v_out[0].iov_base; 205 p->avail_out = v_out[0].iov_len; 206 207 /* we need to flush zlib if we got a flush */ 208 res = deflate(p, getstate(state)); 209 210 /* let's figure out how much was decompressed */ 211 nread = v_in[0].iov_len - p->avail_in; 212 nwrite = v_out[0].iov_len - p->avail_out; 213 214 evbuffer_drain(src, nread); 215 v_out[0].iov_len = nwrite; 216 evbuffer_commit_space(dst, v_out, 1); 217 218 if (res==Z_BUF_ERROR) { 219 /* We're out of space, or out of decodeable input. 220 Only if nwrite == 0 assume the latter. 221 */ 222 if (nwrite == 0) 223 return BEV_NEED_MORE; 224 } else { 225 assert(res == Z_OK || res == Z_STREAM_END); 226 } 227 228 } while (evbuffer_get_length(src) > 0); 229 230 ++outfilter_calls; 231 232 return (BEV_OK); 233} 234 235/* 236 * simple bufferevent test (over transparent zlib treatment) 237 */ 238 239static void 240readcb(struct bufferevent *bev, void *arg) 241{ 242 if (evbuffer_get_length(bufferevent_get_input(bev)) == 8333) { 243 struct evbuffer *evbuf = evbuffer_new(); 244 assert(evbuf != NULL); 245 246 /* gratuitous test of bufferevent_read_buffer */ 247 bufferevent_read_buffer(bev, evbuf); 248 249 bufferevent_disable(bev, EV_READ); 250 251 if (evbuffer_get_length(evbuf) == 8333) { 252 ++readcb_finished; 253 } 254 255 evbuffer_free(evbuf); 256 } 257} 258 259static void 260writecb(struct bufferevent *bev, void *arg) 261{ 262 if (evbuffer_get_length(bufferevent_get_output(bev)) == 0) { 263 ++writecb_finished; 264 } 265} 266 267static void 268errorcb(struct bufferevent *bev, short what, void *arg) 269{ 270 errorcb_invoked = 1; 271} 272 273void 274test_bufferevent_zlib(void *arg) 275{ 276 struct bufferevent *bev1=NULL, *bev2=NULL; 277 char buffer[8333]; 278 z_stream z_input, z_output; 279 int i, pair[2]={-1,-1}, r; 280 (void)arg; 281 282 infilter_calls = outfilter_calls = readcb_finished = writecb_finished 283 = errorcb_invoked = 0; 284 285 if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) { 286 tt_abort_perror("socketpair"); 287 } 288 289 evutil_make_socket_nonblocking(pair[0]); 290 evutil_make_socket_nonblocking(pair[1]); 291 292 bev1 = bufferevent_socket_new(NULL, pair[0], 0); 293 bev2 = bufferevent_socket_new(NULL, pair[1], 0); 294 295 memset(&z_output, 0, sizeof(z_output)); 296 r = deflateInit(&z_output, Z_DEFAULT_COMPRESSION); 297 tt_int_op(r, ==, Z_OK); 298 memset(&z_input, 0, sizeof(z_input)); 299 r = inflateInit(&z_input); 300 tt_int_op(r, ==, Z_OK); 301 302 /* initialize filters */ 303 bev1 = bufferevent_filter_new(bev1, NULL, zlib_output_filter, 304 BEV_OPT_CLOSE_ON_FREE, zlib_deflate_free, &z_output); 305 bev2 = bufferevent_filter_new(bev2, zlib_input_filter, 306 NULL, BEV_OPT_CLOSE_ON_FREE, zlib_inflate_free, &z_input); 307 bufferevent_setcb(bev1, readcb, writecb, errorcb, NULL); 308 bufferevent_setcb(bev2, readcb, writecb, errorcb, NULL); 309 310 bufferevent_disable(bev1, EV_READ); 311 bufferevent_enable(bev1, EV_WRITE); 312 313 bufferevent_enable(bev2, EV_READ); 314 315 for (i = 0; i < (int)sizeof(buffer); i++) 316 buffer[i] = i; 317 318 /* break it up into multiple buffer chains */ 319 bufferevent_write(bev1, buffer, 1800); 320 bufferevent_write(bev1, buffer + 1800, sizeof(buffer) - 1800); 321 322 /* we are done writing - we need to flush everything */ 323 bufferevent_flush(bev1, EV_WRITE, BEV_FINISHED); 324 325 event_dispatch(); 326 327 tt_want(infilter_calls); 328 tt_want(outfilter_calls); 329 tt_want(readcb_finished); 330 tt_want(writecb_finished); 331 tt_want(!errorcb_invoked); 332 333 test_ok = 1; 334end: 335 if (bev1) 336 bufferevent_free(bev1); 337 if (bev2) 338 bufferevent_free(bev2); 339 340 if (pair[0] >= 0) 341 evutil_closesocket(pair[0]); 342 if (pair[1] >= 0) 343 evutil_closesocket(pair[1]); 344} 345