michael@0: /*
michael@0:  * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu>
michael@0:  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
michael@0:  *
michael@0:  * Redistribution and use in source and binary forms, with or without
michael@0:  * modification, are permitted provided that the following conditions
michael@0:  * are met:
michael@0:  * 1. Redistributions of source code must retain the above copyright
michael@0:  *    notice, this list of conditions and the following disclaimer.
michael@0:  * 2. Redistributions in binary form must reproduce the above copyright
michael@0:  *    notice, this list of conditions and the following disclaimer in the
michael@0:  *    documentation and/or other materials provided with the distribution.
michael@0:  * 3. The name of the author may not be used to endorse or promote products
michael@0:  *    derived from this software without specific prior written permission.
michael@0:  *
michael@0:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
michael@0:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
michael@0:  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
michael@0:  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
michael@0:  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
michael@0:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
michael@0:  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
michael@0:  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
michael@0:  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
michael@0:  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
michael@0:  */
michael@0: 
michael@0: #ifdef WIN32
michael@0: #include <winsock2.h>
michael@0: #include <windows.h>
michael@0: #endif
michael@0: 
michael@0: #include "event2/event-config.h"
michael@0: 
michael@0: #include <sys/types.h>
michael@0: #include <sys/stat.h>
michael@0: #ifdef _EVENT_HAVE_SYS_TIME_H
michael@0: #include <sys/time.h>
michael@0: #endif
michael@0: #include <sys/queue.h>
michael@0: #ifndef WIN32
michael@0: #include <sys/socket.h>
michael@0: #include <sys/wait.h>
michael@0: #include <signal.h>
michael@0: #include <unistd.h>
michael@0: #include <netdb.h>
michael@0: #endif
michael@0: #include <stdlib.h>
michael@0: #include <stdio.h>
michael@0: #include <string.h>
michael@0: #include <errno.h>
michael@0: #include <assert.h>
michael@0: 
michael@0: #include "event2/event.h"
michael@0: #include "event2/buffer.h"
michael@0: #include "event2/buffer_compat.h"
michael@0: #include "event2/util.h"
michael@0: 
michael@0: #include "evbuffer-internal.h"
michael@0: #include "log-internal.h"
michael@0: 
michael@0: #include "regress.h"
michael@0: 
michael@0: /* Validates that an evbuffer is good. Returns false if it isn't, true if it
michael@0:  * is*/
michael@0: static int
michael@0: _evbuffer_validate(struct evbuffer *buf)
michael@0: {
michael@0: 	struct evbuffer_chain *chain;
michael@0: 	size_t sum = 0;
michael@0: 	int found_last_with_datap = 0;
michael@0: 
michael@0: 	if (buf->first == NULL) {
michael@0: 		tt_assert(buf->last == NULL);
michael@0: 		tt_assert(buf->total_len == 0);
michael@0: 	}
michael@0: 
michael@0: 	chain = buf->first;
michael@0: 
michael@0: 	tt_assert(buf->last_with_datap);
michael@0: 	if (buf->last_with_datap == &buf->first)
michael@0: 		found_last_with_datap = 1;
michael@0: 
michael@0: 	while (chain != NULL) {
michael@0: 		if (&chain->next == buf->last_with_datap)
michael@0: 			found_last_with_datap = 1;
michael@0: 		sum += chain->off;
michael@0: 		if (chain->next == NULL) {
michael@0: 			tt_assert(buf->last == chain);
michael@0: 		}
michael@0: 		tt_assert(chain->buffer_len >= chain->misalign + chain->off);
michael@0: 		chain = chain->next;
michael@0: 	}
michael@0: 
michael@0: 	if (buf->first)
michael@0: 		tt_assert(*buf->last_with_datap);
michael@0: 
michael@0: 	if (*buf->last_with_datap) {
michael@0: 		chain = *buf->last_with_datap;
michael@0: 		if (chain->off == 0 || buf->total_len == 0) {
michael@0: 			tt_assert(chain->off == 0)
michael@0: 			tt_assert(chain == buf->first);
michael@0: 			tt_assert(buf->total_len == 0);
michael@0: 		}
michael@0: 		chain = chain->next;
michael@0: 		while (chain != NULL) {
michael@0: 			tt_assert(chain->off == 0);
michael@0: 			chain = chain->next;
michael@0: 		}
michael@0: 	} else {
michael@0: 		tt_assert(buf->last_with_datap == &buf->first);
michael@0: 	}
michael@0: 	tt_assert(found_last_with_datap);
michael@0: 
michael@0: 	tt_assert(sum == buf->total_len);
michael@0: 	return 1;
michael@0:  end:
michael@0: 	return 0;
michael@0: }
michael@0: 
michael@0: static void
michael@0: evbuffer_get_waste(struct evbuffer *buf, size_t *allocatedp, size_t *wastedp, size_t *usedp)
michael@0: {
michael@0: 	struct evbuffer_chain *chain;
michael@0: 	size_t a, w, u;
michael@0: 	int n = 0;
michael@0: 	u = a = w = 0;
michael@0: 
michael@0: 	chain = buf->first;
michael@0: 	/* skip empty at start */
michael@0: 	while (chain && chain->off==0) {
michael@0: 		++n;
michael@0: 		a += chain->buffer_len;
michael@0: 		chain = chain->next;
michael@0: 	}
michael@0: 	/* first nonempty chain: stuff at the end only is wasted. */
michael@0: 	if (chain) {
michael@0: 		++n;
michael@0: 		a += chain->buffer_len;
michael@0: 		u += chain->off;
michael@0: 		if (chain->next && chain->next->off)
michael@0: 			w += (size_t)(chain->buffer_len - (chain->misalign + chain->off));
michael@0: 		chain = chain->next;
michael@0: 	}
michael@0: 	/* subsequent nonempty chains */
michael@0: 	while (chain && chain->off) {
michael@0: 		++n;
michael@0: 		a += chain->buffer_len;
michael@0: 		w += (size_t)chain->misalign;
michael@0: 		u += chain->off;
michael@0: 		if (chain->next && chain->next->off)
michael@0: 			w += (size_t) (chain->buffer_len - (chain->misalign + chain->off));
michael@0: 		chain = chain->next;
michael@0: 	}
michael@0: 	/* subsequent empty chains */
michael@0: 	while (chain) {
michael@0: 		++n;
michael@0: 		a += chain->buffer_len;
michael@0: 	}
michael@0: 	*allocatedp = a;
michael@0: 	*wastedp = w;
michael@0: 	*usedp = u;
michael@0: }
michael@0: 
michael@0: #define evbuffer_validate(buf)			\
michael@0: 	TT_STMT_BEGIN if (!_evbuffer_validate(buf)) TT_DIE(("Buffer format invalid")); TT_STMT_END
michael@0: 
michael@0: static void
michael@0: test_evbuffer(void *ptr)
michael@0: {
michael@0: 	static char buffer[512], *tmp;
michael@0: 	struct evbuffer *evb = evbuffer_new();
michael@0: 	struct evbuffer *evb_two = evbuffer_new();
michael@0: 	size_t sz_tmp;
michael@0: 	int i;
michael@0: 
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add_printf(evb, "%s/%d", "hello", 1);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	tt_assert(evbuffer_get_length(evb) == 7);
michael@0: 	tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "hello/1", 1));
michael@0: 
michael@0: 	evbuffer_add_buffer(evb, evb_two);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	evbuffer_drain(evb, strlen("hello/"));
michael@0: 	evbuffer_validate(evb);
michael@0: 	tt_assert(evbuffer_get_length(evb) == 1);
michael@0: 	tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "1", 1));
michael@0: 
michael@0: 	evbuffer_add_printf(evb_two, "%s", "/hello");
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add_buffer(evb, evb_two);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	tt_assert(evbuffer_get_length(evb_two) == 0);
michael@0: 	tt_assert(evbuffer_get_length(evb) == 7);
michael@0: 	tt_assert(!memcmp((char*)EVBUFFER_DATA(evb), "1/hello", 7) != 0);
michael@0: 
michael@0: 	memset(buffer, 0, sizeof(buffer));
michael@0: 	evbuffer_add(evb, buffer, sizeof(buffer));
michael@0: 	evbuffer_validate(evb);
michael@0: 	tt_assert(evbuffer_get_length(evb) == 7 + 512);
michael@0: 
michael@0: 	tmp = (char *)evbuffer_pullup(evb, 7 + 512);
michael@0: 	tt_assert(tmp);
michael@0: 	tt_assert(!strncmp(tmp, "1/hello", 7));
michael@0: 	tt_assert(!memcmp(tmp + 7, buffer, sizeof(buffer)));
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	evbuffer_prepend(evb, "something", 9);
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_prepend(evb, "else", 4);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	tmp = (char *)evbuffer_pullup(evb, 4 + 9 + 7);
michael@0: 	tt_assert(!strncmp(tmp, "elsesomething1/hello", 4 + 9 + 7));
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	evbuffer_drain(evb, -1);
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_drain(evb_two, -1);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	for (i = 0; i < 3; ++i) {
michael@0: 		evbuffer_add(evb_two, buffer, sizeof(buffer));
michael@0: 		evbuffer_validate(evb_two);
michael@0: 		evbuffer_add_buffer(evb, evb_two);
michael@0: 		evbuffer_validate(evb);
michael@0: 		evbuffer_validate(evb_two);
michael@0: 	}
michael@0: 
michael@0: 	tt_assert(evbuffer_get_length(evb_two) == 0);
michael@0: 	tt_assert(evbuffer_get_length(evb) == i * sizeof(buffer));
michael@0: 
michael@0: 	/* test remove buffer */
michael@0: 	sz_tmp = (size_t)(sizeof(buffer)*2.5);
michael@0: 	evbuffer_remove_buffer(evb, evb_two, sz_tmp);
michael@0: 	tt_assert(evbuffer_get_length(evb_two) == sz_tmp);
michael@0: 	tt_assert(evbuffer_get_length(evb) == sizeof(buffer) / 2);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	if (memcmp(evbuffer_pullup(
michael@0: 			   evb, -1), buffer, sizeof(buffer) / 2) != 0 ||
michael@0: 	    memcmp(evbuffer_pullup(
michael@0: 			   evb_two, -1), buffer, sizeof(buffer) != 0))
michael@0: 		tt_abort_msg("Pullup did not preserve content");
michael@0: 
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 
michael@0: 	/* testing one-vector reserve and commit */
michael@0: 	{
michael@0: 		struct evbuffer_iovec v[1];
michael@0: 		char *buf;
michael@0: 		int i, j, r;
michael@0: 
michael@0: 		for (i = 0; i < 3; ++i) {
michael@0: 			r = evbuffer_reserve_space(evb, 10000, v, 1);
michael@0: 			tt_int_op(r, ==, 1);
michael@0: 			tt_assert(v[0].iov_len >= 10000);
michael@0: 			tt_assert(v[0].iov_base != NULL);
michael@0: 
michael@0: 			evbuffer_validate(evb);
michael@0: 			buf = v[0].iov_base;
michael@0: 			for (j = 0; j < 10000; ++j) {
michael@0: 				buf[j] = j;
michael@0: 			}
michael@0: 			evbuffer_validate(evb);
michael@0: 
michael@0: 			tt_int_op(evbuffer_commit_space(evb, v, 1), ==, 0);
michael@0: 			evbuffer_validate(evb);
michael@0: 
michael@0: 			tt_assert(evbuffer_get_length(evb) >= 10000);
michael@0: 
michael@0: 			evbuffer_drain(evb, j * 5000);
michael@0: 			evbuffer_validate(evb);
michael@0: 		}
michael@0: 	}
michael@0: 
michael@0:  end:
michael@0: 	evbuffer_free(evb);
michael@0: 	evbuffer_free(evb_two);
michael@0: }
michael@0: 
michael@0: static void
michael@0: no_cleanup(const void *data, size_t datalen, void *extra)
michael@0: {
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_remove_buffer_with_empty(void *ptr)
michael@0: {
michael@0:     struct evbuffer *src = evbuffer_new();
michael@0:     struct evbuffer *dst = evbuffer_new();
michael@0:     char buf[2];
michael@0: 
michael@0:     evbuffer_validate(src);
michael@0:     evbuffer_validate(dst);
michael@0: 
michael@0:     /* setup the buffers */
michael@0:     /* we need more data in src than we will move later */
michael@0:     evbuffer_add_reference(src, buf, sizeof(buf), no_cleanup, NULL);
michael@0:     evbuffer_add_reference(src, buf, sizeof(buf), no_cleanup, NULL);
michael@0:     /* we need one buffer in dst and one empty buffer at the end */
michael@0:     evbuffer_add(dst, buf, sizeof(buf));
michael@0:     evbuffer_add_reference(dst, buf, 0, no_cleanup, NULL);
michael@0: 
michael@0:     evbuffer_validate(src);
michael@0:     evbuffer_validate(dst);
michael@0: 
michael@0:     /* move three bytes over */
michael@0:     evbuffer_remove_buffer(src, dst, 3);
michael@0: 
michael@0:     evbuffer_validate(src);
michael@0:     evbuffer_validate(dst);
michael@0: 
michael@0: end:
michael@0:     evbuffer_free(src);
michael@0:     evbuffer_free(dst);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_reserve2(void *ptr)
michael@0: {
michael@0: 	/* Test the two-vector cases of reserve/commit. */
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	int n, i;
michael@0: 	struct evbuffer_iovec v[2];
michael@0: 	size_t remaining;
michael@0: 	char *cp, *cp2;
michael@0: 
michael@0: 	/* First chunk will necessarily be one chunk. Use 512 bytes of it.*/
michael@0: 	n = evbuffer_reserve_space(buf, 1024, v, 2);
michael@0: 	tt_int_op(n, ==, 1);
michael@0: 	tt_int_op(evbuffer_get_length(buf), ==, 0);
michael@0: 	tt_assert(v[0].iov_base != NULL);
michael@0: 	tt_int_op(v[0].iov_len, >=, 1024);
michael@0: 	memset(v[0].iov_base, 'X', 512);
michael@0: 	cp = v[0].iov_base;
michael@0: 	remaining = v[0].iov_len - 512;
michael@0: 	v[0].iov_len = 512;
michael@0: 	evbuffer_validate(buf);
michael@0: 	tt_int_op(0, ==, evbuffer_commit_space(buf, v, 1));
michael@0: 	tt_int_op(evbuffer_get_length(buf), ==, 512);
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	/* Ask for another same-chunk request, in an existing chunk. Use 8
michael@0: 	 * bytes of it. */
michael@0: 	n = evbuffer_reserve_space(buf, 32, v, 2);
michael@0: 	tt_int_op(n, ==, 1);
michael@0: 	tt_assert(cp + 512 == v[0].iov_base);
michael@0: 	tt_int_op(remaining, ==, v[0].iov_len);
michael@0: 	memset(v[0].iov_base, 'Y', 8);
michael@0: 	v[0].iov_len = 8;
michael@0: 	tt_int_op(0, ==, evbuffer_commit_space(buf, v, 1));
michael@0: 	tt_int_op(evbuffer_get_length(buf), ==, 520);
michael@0: 	remaining -= 8;
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	/* Now ask for a request that will be split. Use only one byte of it,
michael@0: 	   though. */
michael@0: 	n = evbuffer_reserve_space(buf, remaining+64, v, 2);
michael@0: 	tt_int_op(n, ==, 2);
michael@0: 	tt_assert(cp + 520 == v[0].iov_base);
michael@0: 	tt_int_op(remaining, ==, v[0].iov_len);
michael@0: 	tt_assert(v[1].iov_base);
michael@0: 	tt_assert(v[1].iov_len >= 64);
michael@0: 	cp2 = v[1].iov_base;
michael@0: 	memset(v[0].iov_base, 'Z', 1);
michael@0: 	v[0].iov_len = 1;
michael@0: 	tt_int_op(0, ==, evbuffer_commit_space(buf, v, 1));
michael@0: 	tt_int_op(evbuffer_get_length(buf), ==, 521);
michael@0: 	remaining -= 1;
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	/* Now ask for a request that will be split. Use some of the first
michael@0: 	 * part and some of the second. */
michael@0: 	n = evbuffer_reserve_space(buf, remaining+64, v, 2);
michael@0: 	evbuffer_validate(buf);
michael@0: 	tt_int_op(n, ==, 2);
michael@0: 	tt_assert(cp + 521 == v[0].iov_base);
michael@0: 	tt_int_op(remaining, ==, v[0].iov_len);
michael@0: 	tt_assert(v[1].iov_base == cp2);
michael@0: 	tt_assert(v[1].iov_len >= 64);
michael@0: 	memset(v[0].iov_base, 'W', 400);
michael@0: 	v[0].iov_len = 400;
michael@0: 	memset(v[1].iov_base, 'x', 60);
michael@0: 	v[1].iov_len = 60;
michael@0: 	tt_int_op(0, ==, evbuffer_commit_space(buf, v, 2));
michael@0: 	tt_int_op(evbuffer_get_length(buf), ==, 981);
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	/* Now peek to make sure stuff got made how we like. */
michael@0: 	memset(v,0,sizeof(v));
michael@0: 	n = evbuffer_peek(buf, -1, NULL, v, 2);
michael@0: 	tt_int_op(n, ==, 2);
michael@0: 	tt_int_op(v[0].iov_len, ==, 921);
michael@0: 	tt_int_op(v[1].iov_len, ==, 60);
michael@0: 
michael@0: 	cp = v[0].iov_base;
michael@0: 	for (i=0; i<512; ++i)
michael@0: 		tt_int_op(cp[i], ==, 'X');
michael@0: 	for (i=512; i<520; ++i)
michael@0: 		tt_int_op(cp[i], ==, 'Y');
michael@0: 	for (i=520; i<521; ++i)
michael@0: 		tt_int_op(cp[i], ==, 'Z');
michael@0: 	for (i=521; i<921; ++i)
michael@0: 		tt_int_op(cp[i], ==, 'W');
michael@0: 
michael@0: 	cp = v[1].iov_base;
michael@0: 	for (i=0; i<60; ++i)
michael@0: 		tt_int_op(cp[i], ==, 'x');
michael@0: 
michael@0: end:
michael@0: 	evbuffer_free(buf);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_reserve_many(void *ptr)
michael@0: {
michael@0: 	/* This is a glass-box test to handle expanding a buffer with more
michael@0: 	 * chunks and reallocating chunks as needed */
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	struct evbuffer_iovec v[8];
michael@0: 	int n;
michael@0: 	size_t sz;
michael@0: 	int add_data = ptr && !strcmp(ptr, "add");
michael@0: 	int fill_first = ptr && !strcmp(ptr, "fill");
michael@0: 	char *cp1, *cp2;
michael@0: 
michael@0: 	/* When reserving the the first chunk, we just allocate it */
michael@0: 	n = evbuffer_reserve_space(buf, 128, v, 2);
michael@0: 	evbuffer_validate(buf);
michael@0: 	tt_int_op(n, ==, 1);
michael@0: 	tt_assert(v[0].iov_len >= 128);
michael@0: 	sz = v[0].iov_len;
michael@0: 	cp1 = v[0].iov_base;
michael@0: 	if (add_data) {
michael@0: 		*(char*)v[0].iov_base = 'X';
michael@0: 		v[0].iov_len = 1;
michael@0: 		n = evbuffer_commit_space(buf, v, 1);
michael@0: 		tt_int_op(n, ==, 0);
michael@0: 	} else if (fill_first) {
michael@0: 		memset(v[0].iov_base, 'X', v[0].iov_len);
michael@0: 		n = evbuffer_commit_space(buf, v, 1);
michael@0: 		tt_int_op(n, ==, 0);
michael@0: 		n = evbuffer_reserve_space(buf, 128, v, 2);
michael@0: 		tt_int_op(n, ==, 1);
michael@0: 		sz = v[0].iov_len;
michael@0: 		tt_assert(v[0].iov_base != cp1);
michael@0: 		cp1 = v[0].iov_base;
michael@0: 	}
michael@0: 
michael@0: 	/* Make another chunk get added. */
michael@0: 	n = evbuffer_reserve_space(buf, sz+128, v, 2);
michael@0: 	evbuffer_validate(buf);
michael@0: 	tt_int_op(n, ==, 2);
michael@0: 	sz = v[0].iov_len + v[1].iov_len;
michael@0: 	tt_int_op(sz, >=, v[0].iov_len+128);
michael@0: 	if (add_data) {
michael@0: 		tt_assert(v[0].iov_base == cp1 + 1);
michael@0: 	} else {
michael@0: 		tt_assert(v[0].iov_base == cp1);
michael@0: 	}
michael@0: 	cp1 = v[0].iov_base;
michael@0: 	cp2 = v[1].iov_base;
michael@0: 
michael@0: 	/* And a third chunk. */
michael@0: 	n = evbuffer_reserve_space(buf, sz+128, v, 3);
michael@0: 	evbuffer_validate(buf);
michael@0: 	tt_int_op(n, ==, 3);
michael@0: 	tt_assert(cp1 == v[0].iov_base);
michael@0: 	tt_assert(cp2 == v[1].iov_base);
michael@0: 	sz = v[0].iov_len + v[1].iov_len + v[2].iov_len;
michael@0: 
michael@0: 	/* Now force a reallocation by asking for more space in only 2
michael@0: 	 * buffers. */
michael@0: 	n = evbuffer_reserve_space(buf, sz+128, v, 2);
michael@0: 	evbuffer_validate(buf);
michael@0: 	if (add_data) {
michael@0: 		tt_int_op(n, ==, 2);
michael@0: 		tt_assert(cp1 == v[0].iov_base);
michael@0: 	} else {
michael@0: 		tt_int_op(n, ==, 1);
michael@0: 	}
michael@0: 
michael@0: end:
michael@0: 	evbuffer_free(buf);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_expand(void *ptr)
michael@0: {
michael@0: 	char data[4096];
michael@0: 	struct evbuffer *buf;
michael@0: 	size_t a,w,u;
michael@0: 	void *buffer;
michael@0: 
michael@0: 	memset(data, 'X', sizeof(data));
michael@0: 
michael@0: 	/* Make sure that expand() works on an empty buffer */
michael@0: 	buf = evbuffer_new();
michael@0: 	tt_int_op(evbuffer_expand(buf, 20000), ==, 0);
michael@0: 	evbuffer_validate(buf);
michael@0: 	a=w=u=0;
michael@0: 	evbuffer_get_waste(buf, &a,&w,&u);
michael@0: 	tt_assert(w == 0);
michael@0: 	tt_assert(u == 0);
michael@0: 	tt_assert(a >= 20000);
michael@0: 	tt_assert(buf->first);
michael@0: 	tt_assert(buf->first == buf->last);
michael@0: 	tt_assert(buf->first->off == 0);
michael@0: 	tt_assert(buf->first->buffer_len >= 20000);
michael@0: 
michael@0: 	/* Make sure that expand() works as a no-op when there's enough
michael@0: 	 * contiguous space already. */
michael@0: 	buffer = buf->first->buffer;
michael@0: 	evbuffer_add(buf, data, 1024);
michael@0: 	tt_int_op(evbuffer_expand(buf, 1024), ==, 0);
michael@0: 	tt_assert(buf->first->buffer == buffer);
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_free(buf);
michael@0: 
michael@0: 	/* Make sure that expand() can work by moving misaligned data
michael@0: 	 * when it makes sense to do so. */
michael@0: 	buf = evbuffer_new();
michael@0: 	evbuffer_add(buf, data, 400);
michael@0: 	{
michael@0: 		int n = (int)(buf->first->buffer_len - buf->first->off - 1);
michael@0: 		tt_assert(n < (int)sizeof(data));
michael@0: 		evbuffer_add(buf, data, n);
michael@0: 	}
michael@0: 	tt_assert(buf->first == buf->last);
michael@0: 	tt_assert(buf->first->off == buf->first->buffer_len - 1);
michael@0: 	evbuffer_drain(buf, buf->first->off - 1);
michael@0: 	tt_assert(1 == evbuffer_get_length(buf));
michael@0: 	tt_assert(buf->first->misalign > 0);
michael@0: 	tt_assert(buf->first->off == 1);
michael@0: 	buffer = buf->first->buffer;
michael@0: 	tt_assert(evbuffer_expand(buf, 40) == 0);
michael@0: 	tt_assert(buf->first == buf->last);
michael@0: 	tt_assert(buf->first->off == 1);
michael@0: 	tt_assert(buf->first->buffer == buffer);
michael@0: 	tt_assert(buf->first->misalign == 0);
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_free(buf);
michael@0: 
michael@0: 	/* add, expand, pull-up: This used to crash libevent. */
michael@0: 	buf = evbuffer_new();
michael@0: 
michael@0: 	evbuffer_add(buf, data, sizeof(data));
michael@0: 	evbuffer_add(buf, data, sizeof(data));
michael@0: 	evbuffer_add(buf, data, sizeof(data));
michael@0: 
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_expand(buf, 1024);
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_pullup(buf, -1);
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: end:
michael@0: 	evbuffer_free(buf);
michael@0: }
michael@0: 
michael@0: 
michael@0: static int reference_cb_called;
michael@0: static void
michael@0: reference_cb(const void *data, size_t len, void *extra)
michael@0: {
michael@0: 	tt_str_op(data, ==, "this is what we add as read-only memory.");
michael@0: 	tt_int_op(len, ==, strlen(data));
michael@0: 	tt_want(extra == (void *)0xdeadaffe);
michael@0: 	++reference_cb_called;
michael@0: end:
michael@0: 	;
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_reference(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *src = evbuffer_new();
michael@0: 	struct evbuffer *dst = evbuffer_new();
michael@0: 	struct evbuffer_iovec v[1];
michael@0: 	const char *data = "this is what we add as read-only memory.";
michael@0: 	reference_cb_called = 0;
michael@0: 
michael@0: 	tt_assert(evbuffer_add_reference(src, data, strlen(data),
michael@0: 		 reference_cb, (void *)0xdeadaffe) != -1);
michael@0: 
michael@0: 	evbuffer_reserve_space(dst, strlen(data), v, 1);
michael@0: 	tt_assert(evbuffer_remove(src, v[0].iov_base, 10) != -1);
michael@0: 
michael@0: 	evbuffer_validate(src);
michael@0: 	evbuffer_validate(dst);
michael@0: 
michael@0: 	/* make sure that we don't write data at the beginning */
michael@0: 	evbuffer_prepend(src, "aaaaa", 5);
michael@0: 	evbuffer_validate(src);
michael@0: 	evbuffer_drain(src, 5);
michael@0: 
michael@0: 	tt_assert(evbuffer_remove(src, ((char*)(v[0].iov_base)) + 10,
michael@0: 		strlen(data) - 10) != -1);
michael@0: 
michael@0: 	v[0].iov_len = strlen(data);
michael@0: 
michael@0: 	evbuffer_commit_space(dst, v, 1);
michael@0: 	evbuffer_validate(src);
michael@0: 	evbuffer_validate(dst);
michael@0: 
michael@0: 	tt_int_op(reference_cb_called, ==, 1);
michael@0: 
michael@0: 	tt_assert(!memcmp(evbuffer_pullup(dst, strlen(data)),
michael@0: 			  data, strlen(data)));
michael@0: 	evbuffer_validate(dst);
michael@0: 
michael@0:  end:
michael@0: 	evbuffer_free(dst);
michael@0: 	evbuffer_free(src);
michael@0: }
michael@0: 
michael@0: int _evbuffer_testing_use_sendfile(void);
michael@0: int _evbuffer_testing_use_mmap(void);
michael@0: int _evbuffer_testing_use_linear_file_access(void);
michael@0: 
michael@0: static void
michael@0: test_evbuffer_add_file(void *ptr)
michael@0: {
michael@0: 	const char *impl = ptr;
michael@0: 	struct evbuffer *src = evbuffer_new();
michael@0: 	const char *data = "this is what we add as file system data.";
michael@0: 	size_t datalen;
michael@0: 	const char *compare;
michael@0: 	int fd = -1;
michael@0: 	evutil_socket_t pair[2] = {-1, -1};
michael@0: 	int r=0, n_written=0;
michael@0: 
michael@0: 	/* Add a test for a big file. XXXX */
michael@0: 
michael@0: 	tt_assert(impl);
michael@0: 	if (!strcmp(impl, "sendfile")) {
michael@0: 		if (!_evbuffer_testing_use_sendfile())
michael@0: 			tt_skip();
michael@0: 		TT_BLATHER(("Using sendfile-based implementaion"));
michael@0: 	} else if (!strcmp(impl, "mmap")) {
michael@0: 		if (!_evbuffer_testing_use_mmap())
michael@0: 			tt_skip();
michael@0: 		TT_BLATHER(("Using mmap-based implementaion"));
michael@0: 	} else if (!strcmp(impl, "linear")) {
michael@0: 		if (!_evbuffer_testing_use_linear_file_access())
michael@0: 			tt_skip();
michael@0: 		TT_BLATHER(("Using read-based implementaion"));
michael@0: 	} else {
michael@0: 		TT_DIE(("Didn't recognize the implementation"));
michael@0: 	}
michael@0: 
michael@0: 	/* Say that it drains to a fd so that we can use sendfile. */
michael@0: 	evbuffer_set_flags(src, EVBUFFER_FLAG_DRAINS_TO_FD);
michael@0: 
michael@0: #if defined(_EVENT_HAVE_SENDFILE) && defined(__sun__) && defined(__svr4__)
michael@0: 	/* We need to use a pair of AF_INET sockets, since Solaris
michael@0: 	   doesn't support sendfile() over AF_UNIX. */
michael@0: 	if (evutil_ersatz_socketpair(AF_INET, SOCK_STREAM, 0, pair) == -1)
michael@0: 		tt_abort_msg("ersatz_socketpair failed");
michael@0: #else
michael@0: 	if (evutil_socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1)
michael@0: 		tt_abort_msg("socketpair failed");
michael@0: #endif
michael@0: 
michael@0: 	datalen = strlen(data);
michael@0: 	fd = regress_make_tmpfile(data, datalen);
michael@0: 
michael@0: 	tt_assert(fd != -1);
michael@0: 
michael@0: 	tt_assert(evbuffer_add_file(src, fd, 0, datalen) != -1);
michael@0: 
michael@0: 	evbuffer_validate(src);
michael@0: 
michael@0: 	while (evbuffer_get_length(src) &&
michael@0: 	    (r = evbuffer_write(src, pair[0])) > 0) {
michael@0: 		evbuffer_validate(src);
michael@0: 		n_written += r;
michael@0: 	}
michael@0: 	tt_int_op(r, !=, -1);
michael@0: 	tt_int_op(n_written, ==, datalen);
michael@0: 
michael@0: 	evbuffer_validate(src);
michael@0: 	tt_int_op(evbuffer_read(src, pair[1], (int)strlen(data)), ==, datalen);
michael@0: 	evbuffer_validate(src);
michael@0: 	compare = (char *)evbuffer_pullup(src, datalen);
michael@0: 	tt_assert(compare != NULL);
michael@0: 	if (memcmp(compare, data, datalen))
michael@0: 		tt_abort_msg("Data from add_file differs.");
michael@0: 
michael@0: 	evbuffer_validate(src);
michael@0:  end:
michael@0: 	if (pair[0] >= 0)
michael@0: 		evutil_closesocket(pair[0]);
michael@0: 	if (pair[1] >= 0)
michael@0: 		evutil_closesocket(pair[1]);
michael@0: 	evbuffer_free(src);
michael@0: }
michael@0: 
michael@0: #ifndef _EVENT_DISABLE_MM_REPLACEMENT
michael@0: static void *
michael@0: failing_malloc(size_t how_much)
michael@0: {
michael@0: 	errno = ENOMEM;
michael@0: 	return NULL;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: static void
michael@0: test_evbuffer_readln(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *evb = evbuffer_new();
michael@0: 	struct evbuffer *evb_tmp = evbuffer_new();
michael@0: 	const char *s;
michael@0: 	char *cp = NULL;
michael@0: 	size_t sz;
michael@0: 
michael@0: #define tt_line_eq(content)						\
michael@0: 	TT_STMT_BEGIN							\
michael@0: 	if (!cp || sz != strlen(content) || strcmp(cp, content)) {	\
michael@0: 		TT_DIE(("Wanted %s; got %s [%d]", content, cp, (int)sz)); \
michael@0: 	}								\
michael@0: 	TT_STMT_END
michael@0: 
michael@0: 	/* Test EOL_ANY. */
michael@0: 	s = "complex silly newline\r\n\n\r\n\n\rmore\0\n";
michael@0: 	evbuffer_add(evb, s, strlen(s)+2);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
michael@0: 	tt_line_eq("complex silly newline");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
michael@0: 	if (!cp || sz != 5 || memcmp(cp, "more\0\0", 6))
michael@0: 		tt_abort_msg("Not as expected");
michael@0: 	tt_uint_op(evbuffer_get_length(evb), ==, 0);
michael@0: 	evbuffer_validate(evb);
michael@0: 	s = "\nno newline";
michael@0: 	evbuffer_add(evb, s, strlen(s));
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
michael@0: 	tt_line_eq("");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_ANY);
michael@0: 	tt_assert(!cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_drain(evb, evbuffer_get_length(evb));
michael@0: 	tt_assert(evbuffer_get_length(evb) == 0);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	/* Test EOL_CRLF */
michael@0: 	s = "Line with\rin the middle\nLine with good crlf\r\n\nfinal\n";
michael@0: 	evbuffer_add(evb, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
michael@0: 	tt_line_eq("Line with\rin the middle");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
michael@0: 	tt_line_eq("Line with good crlf");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
michael@0: 	tt_line_eq("");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
michael@0: 	tt_line_eq("final");
michael@0: 	s = "x";
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add(evb, s, 1);
michael@0: 	evbuffer_validate(evb);
michael@0: 	free(cp);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF);
michael@0: 	tt_assert(!cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	/* Test CRLF_STRICT */
michael@0: 	s = " and a bad crlf\nand a good one\r\n\r\nMore\r";
michael@0: 	evbuffer_add(evb, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("x and a bad crlf\nand a good one");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_assert(!cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add(evb, "\n", 1);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("More");
michael@0: 	free(cp);
michael@0: 	tt_assert(evbuffer_get_length(evb) == 0);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	s = "An internal CR\r is not an eol\r\nNor is a lack of one";
michael@0: 	evbuffer_add(evb, s, strlen(s));
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("An internal CR\r is not an eol");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_assert(!cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	evbuffer_add(evb, "\r\n", 2);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("Nor is a lack of one");
michael@0: 	free(cp);
michael@0: 	tt_assert(evbuffer_get_length(evb) == 0);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	/* Test LF */
michael@0: 	s = "An\rand a nl\n\nText";
michael@0: 	evbuffer_add(evb, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_line_eq("An\rand a nl");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_line_eq("");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_assert(!cp);
michael@0: 	free(cp);
michael@0: 	evbuffer_add(evb, "\n", 1);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_line_eq("Text");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	/* Test CRLF_STRICT - across boundaries*/
michael@0: 	s = " and a bad crlf\nand a good one\r";
michael@0: 	evbuffer_add(evb_tmp, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add_buffer(evb, evb_tmp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	s = "\n\r";
michael@0: 	evbuffer_add(evb_tmp, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add_buffer(evb, evb_tmp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	s = "\nMore\r";
michael@0: 	evbuffer_add(evb_tmp, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add_buffer(evb, evb_tmp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq(" and a bad crlf\nand a good one");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("");
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_assert(!cp);
michael@0: 	free(cp);
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add(evb, "\n", 1);
michael@0: 	evbuffer_validate(evb);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_line_eq("More");
michael@0: 	free(cp); cp = NULL;
michael@0: 	evbuffer_validate(evb);
michael@0: 	tt_assert(evbuffer_get_length(evb) == 0);
michael@0: 
michael@0: 	/* Test memory problem*/
michael@0: 	s = "one line\ntwo line\nblue line";
michael@0: 	evbuffer_add(evb_tmp, s, strlen(s));
michael@0: 	evbuffer_validate(evb);
michael@0: 	evbuffer_add_buffer(evb, evb_tmp);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_line_eq("one line");
michael@0: 	free(cp); cp = NULL;
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	/* the next call to readline should fail */
michael@0: #ifndef _EVENT_DISABLE_MM_REPLACEMENT
michael@0: 	event_set_mem_functions(failing_malloc, realloc, free);
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_assert(cp == NULL);
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0: 	/* now we should get the next line back */
michael@0: 	event_set_mem_functions(malloc, realloc, free);
michael@0: #endif
michael@0: 	cp = evbuffer_readln(evb, &sz, EVBUFFER_EOL_LF);
michael@0: 	tt_line_eq("two line");
michael@0: 	free(cp); cp = NULL;
michael@0: 	evbuffer_validate(evb);
michael@0: 
michael@0:  end:
michael@0: 	evbuffer_free(evb);
michael@0: 	evbuffer_free(evb_tmp);
michael@0: 	if (cp) free(cp);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_search_eol(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	struct evbuffer_ptr ptr1, ptr2;
michael@0: 	const char *s;
michael@0: 	size_t eol_len;
michael@0: 
michael@0: 	s = "string! \r\n\r\nx\n";
michael@0: 	evbuffer_add(buf, s, strlen(s));
michael@0: 	eol_len = -1;
michael@0: 	ptr1 = evbuffer_search_eol(buf, NULL, &eol_len, EVBUFFER_EOL_CRLF);
michael@0: 	tt_int_op(ptr1.pos, ==, 8);
michael@0: 	tt_int_op(eol_len, ==, 2);
michael@0: 
michael@0: 	eol_len = -1;
michael@0: 	ptr2 = evbuffer_search_eol(buf, &ptr1, &eol_len, EVBUFFER_EOL_CRLF);
michael@0: 	tt_int_op(ptr2.pos, ==, 8);
michael@0: 	tt_int_op(eol_len, ==, 2);
michael@0: 
michael@0: 	evbuffer_ptr_set(buf, &ptr1, 1, EVBUFFER_PTR_ADD);
michael@0: 	eol_len = -1;
michael@0: 	ptr2 = evbuffer_search_eol(buf, &ptr1, &eol_len, EVBUFFER_EOL_CRLF);
michael@0: 	tt_int_op(ptr2.pos, ==, 9);
michael@0: 	tt_int_op(eol_len, ==, 1);
michael@0: 
michael@0: 	eol_len = -1;
michael@0: 	ptr2 = evbuffer_search_eol(buf, &ptr1, &eol_len, EVBUFFER_EOL_CRLF_STRICT);
michael@0: 	tt_int_op(ptr2.pos, ==, 10);
michael@0: 	tt_int_op(eol_len, ==, 2);
michael@0: 
michael@0: 	eol_len = -1;
michael@0: 	ptr1 = evbuffer_search_eol(buf, NULL, &eol_len, EVBUFFER_EOL_LF);
michael@0: 	tt_int_op(ptr1.pos, ==, 9);
michael@0: 	tt_int_op(eol_len, ==, 1);
michael@0: 
michael@0: 	eol_len = -1;
michael@0: 	ptr2 = evbuffer_search_eol(buf, &ptr1, &eol_len, EVBUFFER_EOL_LF);
michael@0: 	tt_int_op(ptr2.pos, ==, 9);
michael@0: 	tt_int_op(eol_len, ==, 1);
michael@0: 
michael@0: 	evbuffer_ptr_set(buf, &ptr1, 1, EVBUFFER_PTR_ADD);
michael@0: 	eol_len = -1;
michael@0: 	ptr2 = evbuffer_search_eol(buf, &ptr1, &eol_len, EVBUFFER_EOL_LF);
michael@0: 	tt_int_op(ptr2.pos, ==, 11);
michael@0: 	tt_int_op(eol_len, ==, 1);
michael@0: 
michael@0: end:
michael@0: 	evbuffer_free(buf);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_iterative(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	const char *abc = "abcdefghijklmnopqrstvuwxyzabcdefghijklmnopqrstvuwxyzabcdefghijklmnopqrstvuwxyzabcdefghijklmnopqrstvuwxyz";
michael@0: 	unsigned i, j, sum, n;
michael@0: 
michael@0: 	sum = 0;
michael@0: 	n = 0;
michael@0: 	for (i = 0; i < 1000; ++i) {
michael@0: 		for (j = 1; j < strlen(abc); ++j) {
michael@0: 			char format[32];
michael@0: 			evutil_snprintf(format, sizeof(format), "%%%u.%us", j, j);
michael@0: 			evbuffer_add_printf(buf, format, abc);
michael@0: 
michael@0: 			/* Only check for rep violations every so often.
michael@0: 			   Walking over the whole list of chains can get
michael@0: 			   pretty expensive as it gets long.
michael@0: 			 */
michael@0: 			if ((n % 337) == 0)
michael@0: 				evbuffer_validate(buf);
michael@0: 
michael@0: 			sum += j;
michael@0: 			n++;
michael@0: 		}
michael@0: 	}
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	tt_uint_op(sum, ==, evbuffer_get_length(buf));
michael@0: 
michael@0: 	{
michael@0: 		size_t a,w,u;
michael@0: 		a=w=u=0;
michael@0: 		evbuffer_get_waste(buf, &a, &w, &u);
michael@0: 		if (0)
michael@0: 			printf("Allocated: %u.\nWasted: %u.\nUsed: %u.",
michael@0: 			    (unsigned)a, (unsigned)w, (unsigned)u);
michael@0: 		tt_assert( ((double)w)/a < .125);
michael@0: 	}
michael@0:  end:
michael@0: 	evbuffer_free(buf);
michael@0: 
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_find(void *ptr)
michael@0: {
michael@0: 	u_char* p;
michael@0: 	const char* test1 = "1234567890\r\n";
michael@0: 	const char* test2 = "1234567890\r";
michael@0: #define EVBUFFER_INITIAL_LENGTH 256
michael@0: 	char test3[EVBUFFER_INITIAL_LENGTH];
michael@0: 	unsigned int i;
michael@0: 	struct evbuffer * buf = evbuffer_new();
michael@0: 
michael@0: 	tt_assert(buf);
michael@0: 
michael@0: 	/* make sure evbuffer_find doesn't match past the end of the buffer */
michael@0: 	evbuffer_add(buf, (u_char*)test1, strlen(test1));
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_drain(buf, strlen(test1));
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_add(buf, (u_char*)test2, strlen(test2));
michael@0: 	evbuffer_validate(buf);
michael@0: 	p = evbuffer_find(buf, (u_char*)"\r\n", 2);
michael@0: 	tt_want(p == NULL);
michael@0: 
michael@0: 	/*
michael@0: 	 * drain the buffer and do another find; in r309 this would
michael@0: 	 * read past the allocated buffer causing a valgrind error.
michael@0: 	 */
michael@0: 	evbuffer_drain(buf, strlen(test2));
michael@0: 	evbuffer_validate(buf);
michael@0: 	for (i = 0; i < EVBUFFER_INITIAL_LENGTH; ++i)
michael@0: 		test3[i] = 'a';
michael@0: 	test3[EVBUFFER_INITIAL_LENGTH - 1] = 'x';
michael@0: 	evbuffer_add(buf, (u_char *)test3, EVBUFFER_INITIAL_LENGTH);
michael@0: 	evbuffer_validate(buf);
michael@0: 	p = evbuffer_find(buf, (u_char *)"xy", 2);
michael@0: 	tt_want(p == NULL);
michael@0: 
michael@0: 	/* simple test for match at end of allocated buffer */
michael@0: 	p = evbuffer_find(buf, (u_char *)"ax", 2);
michael@0: 	tt_assert(p != NULL);
michael@0: 	tt_want(strncmp((char*)p, "ax", 2) == 0);
michael@0: 
michael@0: end:
michael@0: 	if (buf)
michael@0: 		evbuffer_free(buf);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_ptr_set(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	struct evbuffer_ptr pos;
michael@0: 	struct evbuffer_iovec v[1];
michael@0: 
michael@0: 	tt_assert(buf);
michael@0: 
michael@0: 	/* create some chains */
michael@0: 	evbuffer_reserve_space(buf, 5000, v, 1);
michael@0: 	v[0].iov_len = 5000;
michael@0: 	memset(v[0].iov_base, 1, v[0].iov_len);
michael@0: 	evbuffer_commit_space(buf, v, 1);
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	evbuffer_reserve_space(buf, 4000, v, 1);
michael@0: 	v[0].iov_len = 4000;
michael@0: 	memset(v[0].iov_base, 2, v[0].iov_len);
michael@0: 	evbuffer_commit_space(buf, v, 1);
michael@0: 
michael@0: 	evbuffer_reserve_space(buf, 3000, v, 1);
michael@0: 	v[0].iov_len = 3000;
michael@0: 	memset(v[0].iov_base, 3, v[0].iov_len);
michael@0: 	evbuffer_commit_space(buf, v, 1);
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	tt_int_op(evbuffer_get_length(buf), ==, 12000);
michael@0: 
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 13000, EVBUFFER_PTR_SET) == -1);
michael@0: 	tt_assert(pos.pos == -1);
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 0, EVBUFFER_PTR_SET) == 0);
michael@0: 	tt_assert(pos.pos == 0);
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 13000, EVBUFFER_PTR_ADD) == -1);
michael@0: 
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 0, EVBUFFER_PTR_SET) == 0);
michael@0: 	tt_assert(pos.pos == 0);
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 10000, EVBUFFER_PTR_ADD) == 0);
michael@0: 	tt_assert(pos.pos == 10000);
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 1000, EVBUFFER_PTR_ADD) == 0);
michael@0: 	tt_assert(pos.pos == 11000);
michael@0: 	tt_assert(evbuffer_ptr_set(buf, &pos, 1000, EVBUFFER_PTR_ADD) == -1);
michael@0: 	tt_assert(pos.pos == -1);
michael@0: 
michael@0: end:
michael@0: 	if (buf)
michael@0: 		evbuffer_free(buf);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_search(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	struct evbuffer *tmp = evbuffer_new();
michael@0: 	struct evbuffer_ptr pos, end;
michael@0: 
michael@0: 	tt_assert(buf);
michael@0: 	tt_assert(tmp);
michael@0: 
michael@0: 	/* set up our chains */
michael@0: 	evbuffer_add_printf(tmp, "hello");  /* 5 chars */
michael@0: 	evbuffer_add_buffer(buf, tmp);
michael@0: 	evbuffer_add_printf(tmp, "foo");    /* 3 chars */
michael@0: 	evbuffer_add_buffer(buf, tmp);
michael@0: 	evbuffer_add_printf(tmp, "cat");    /* 3 chars */
michael@0: 	evbuffer_add_buffer(buf, tmp);
michael@0: 	evbuffer_add_printf(tmp, "attack");
michael@0: 	evbuffer_add_buffer(buf, tmp);
michael@0: 
michael@0: 	pos = evbuffer_search(buf, "attack", 6, NULL);
michael@0: 	tt_int_op(pos.pos, ==, 11);
michael@0: 	pos = evbuffer_search(buf, "attacker", 8, NULL);
michael@0: 	tt_int_op(pos.pos, ==, -1);
michael@0: 
michael@0: 	/* test continuing search */
michael@0: 	pos = evbuffer_search(buf, "oc", 2, NULL);
michael@0: 	tt_int_op(pos.pos, ==, 7);
michael@0: 	pos = evbuffer_search(buf, "cat", 3, &pos);
michael@0: 	tt_int_op(pos.pos, ==, 8);
michael@0: 	pos = evbuffer_search(buf, "tacking", 7, &pos);
michael@0: 	tt_int_op(pos.pos, ==, -1);
michael@0: 
michael@0: 	evbuffer_ptr_set(buf, &pos, 5, EVBUFFER_PTR_SET);
michael@0: 	pos = evbuffer_search(buf, "foo", 3, &pos);
michael@0: 	tt_int_op(pos.pos, ==, 5);
michael@0: 
michael@0: 	evbuffer_ptr_set(buf, &pos, 2, EVBUFFER_PTR_ADD);
michael@0: 	pos = evbuffer_search(buf, "tat", 3, &pos);
michael@0: 	tt_int_op(pos.pos, ==, 10);
michael@0: 
michael@0: 	/* test bounded search. */
michael@0: 	/* Set "end" to the first t in "attack". */
michael@0: 	evbuffer_ptr_set(buf, &end, 12, EVBUFFER_PTR_SET);
michael@0: 	pos = evbuffer_search_range(buf, "foo", 3, NULL, &end);
michael@0: 	tt_int_op(pos.pos, ==, 5);
michael@0: 	pos = evbuffer_search_range(buf, "foocata", 7, NULL, &end);
michael@0: 	tt_int_op(pos.pos, ==, 5);
michael@0: 	pos = evbuffer_search_range(buf, "foocatat", 8, NULL, &end);
michael@0: 	tt_int_op(pos.pos, ==, -1);
michael@0: 	pos = evbuffer_search_range(buf, "ack", 3, NULL, &end);
michael@0: 	tt_int_op(pos.pos, ==, -1);
michael@0: 
michael@0: 
michael@0: end:
michael@0: 	if (buf)
michael@0: 		evbuffer_free(buf);
michael@0: 	if (tmp)
michael@0: 		evbuffer_free(tmp);
michael@0: }
michael@0: 
michael@0: static void
michael@0: log_change_callback(struct evbuffer *buffer,
michael@0:     const struct evbuffer_cb_info *cbinfo,
michael@0:     void *arg)
michael@0: {
michael@0: 
michael@0: 	size_t old_len = cbinfo->orig_size;
michael@0: 	size_t new_len = old_len + cbinfo->n_added - cbinfo->n_deleted;
michael@0: 	struct evbuffer *out = arg;
michael@0: 	evbuffer_add_printf(out, "%lu->%lu; ", (unsigned long)old_len,
michael@0: 			    (unsigned long)new_len);
michael@0: }
michael@0: static void
michael@0: self_draining_callback(struct evbuffer *evbuffer, size_t old_len,
michael@0: 		size_t new_len, void *arg)
michael@0: {
michael@0: 	if (new_len > old_len)
michael@0: 		evbuffer_drain(evbuffer, new_len);
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_callbacks(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf = evbuffer_new();
michael@0: 	struct evbuffer *buf_out1 = evbuffer_new();
michael@0: 	struct evbuffer *buf_out2 = evbuffer_new();
michael@0: 	struct evbuffer_cb_entry *cb1, *cb2;
michael@0: 
michael@0: 	tt_assert(buf);
michael@0: 	tt_assert(buf_out1);
michael@0: 	tt_assert(buf_out2);
michael@0: 
michael@0: 	cb1 = evbuffer_add_cb(buf, log_change_callback, buf_out1);
michael@0: 	cb2 = evbuffer_add_cb(buf, log_change_callback, buf_out2);
michael@0: 
michael@0: 	/* Let's run through adding and deleting some stuff from the buffer
michael@0: 	 * and turning the callbacks on and off and removing them.  The callback
michael@0: 	 * adds a summary of length changes to buf_out1/buf_out2 when called. */
michael@0: 	/* size: 0-> 36. */
michael@0: 	evbuffer_add_printf(buf, "The %d magic words are spotty pudding", 2);
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_cb_clear_flags(buf, cb2, EVBUFFER_CB_ENABLED);
michael@0: 	evbuffer_drain(buf, 10); /*36->26*/
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_prepend(buf, "Hello", 5);/*26->31*/
michael@0: 	evbuffer_cb_set_flags(buf, cb2, EVBUFFER_CB_ENABLED);
michael@0: 	evbuffer_add_reference(buf, "Goodbye", 7, NULL, NULL); /*31->38*/
michael@0: 	evbuffer_remove_cb_entry(buf, cb1);
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_drain(buf, evbuffer_get_length(buf)); /*38->0*/;
michael@0: 	tt_assert(-1 == evbuffer_remove_cb(buf, log_change_callback, NULL));
michael@0: 	evbuffer_add(buf, "X", 1); /* 0->1 */
michael@0: 	tt_assert(!evbuffer_remove_cb(buf, log_change_callback, buf_out2));
michael@0: 	evbuffer_validate(buf);
michael@0: 
michael@0: 	tt_str_op(evbuffer_pullup(buf_out1, -1), ==,
michael@0: 		  "0->36; 36->26; 26->31; 31->38; ");
michael@0: 	tt_str_op(evbuffer_pullup(buf_out2, -1), ==,
michael@0: 		  "0->36; 31->38; 38->0; 0->1; ");
michael@0: 	evbuffer_drain(buf_out1, evbuffer_get_length(buf_out1));
michael@0: 	evbuffer_drain(buf_out2, evbuffer_get_length(buf_out2));
michael@0: 	/* Let's test the obsolete buffer_setcb function too. */
michael@0: 	cb1 = evbuffer_add_cb(buf, log_change_callback, buf_out1);
michael@0: 	tt_assert(cb1 != NULL);
michael@0: 	cb2 = evbuffer_add_cb(buf, log_change_callback, buf_out2);
michael@0: 	tt_assert(cb2 != NULL);
michael@0: 	evbuffer_setcb(buf, self_draining_callback, NULL);
michael@0: 	evbuffer_add_printf(buf, "This should get drained right away.");
michael@0: 	tt_uint_op(evbuffer_get_length(buf), ==, 0);
michael@0: 	tt_uint_op(evbuffer_get_length(buf_out1), ==, 0);
michael@0: 	tt_uint_op(evbuffer_get_length(buf_out2), ==, 0);
michael@0: 	evbuffer_setcb(buf, NULL, NULL);
michael@0: 	evbuffer_add_printf(buf, "This will not.");
michael@0: 	tt_str_op(evbuffer_pullup(buf, -1), ==, "This will not.");
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_drain(buf, evbuffer_get_length(buf));
michael@0: 	evbuffer_validate(buf);
michael@0: #if 0
michael@0: 	/* Now let's try a suspended callback. */
michael@0: 	cb1 = evbuffer_add_cb(buf, log_change_callback, buf_out1);
michael@0: 	cb2 = evbuffer_add_cb(buf, log_change_callback, buf_out2);
michael@0: 	evbuffer_cb_suspend(buf,cb2);
michael@0: 	evbuffer_prepend(buf,"Hello world",11); /*0->11*/
michael@0: 	evbuffer_validate(buf);
michael@0: 	evbuffer_cb_suspend(buf,cb1);
michael@0: 	evbuffer_add(buf,"more",4); /* 11->15 */
michael@0: 	evbuffer_cb_unsuspend(buf,cb2);
michael@0: 	evbuffer_drain(buf, 4); /* 15->11 */
michael@0: 	evbuffer_cb_unsuspend(buf,cb1);
michael@0: 	evbuffer_drain(buf, evbuffer_get_length(buf)); /* 11->0 */
michael@0: 
michael@0: 	tt_str_op(evbuffer_pullup(buf_out1, -1), ==,
michael@0: 		  "0->11; 11->11; 11->0; ");
michael@0: 	tt_str_op(evbuffer_pullup(buf_out2, -1), ==,
michael@0: 		  "0->15; 15->11; 11->0; ");
michael@0: #endif
michael@0: 
michael@0:  end:
michael@0: 	if (buf)
michael@0: 		evbuffer_free(buf);
michael@0: 	if (buf_out1)
michael@0: 		evbuffer_free(buf_out1);
michael@0: 	if (buf_out2)
michael@0: 		evbuffer_free(buf_out2);
michael@0: }
michael@0: 
michael@0: static int ref_done_cb_called_count = 0;
michael@0: static void *ref_done_cb_called_with = NULL;
michael@0: static const void *ref_done_cb_called_with_data = NULL;
michael@0: static size_t ref_done_cb_called_with_len = 0;
michael@0: static void ref_done_cb(const void *data, size_t len, void *info)
michael@0: {
michael@0: 	++ref_done_cb_called_count;
michael@0: 	ref_done_cb_called_with = info;
michael@0: 	ref_done_cb_called_with_data = data;
michael@0: 	ref_done_cb_called_with_len = len;
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_add_reference(void *ptr)
michael@0: {
michael@0: 	const char chunk1[] = "If you have found the answer to such a problem";
michael@0: 	const char chunk2[] = "you ought to write it up for publication";
michael@0: 			  /* -- Knuth's "Notes on the Exercises" from TAOCP */
michael@0: 	char tmp[16];
michael@0: 	size_t len1 = strlen(chunk1), len2=strlen(chunk2);
michael@0: 
michael@0: 	struct evbuffer *buf1 = NULL, *buf2 = NULL;
michael@0: 
michael@0: 	buf1 = evbuffer_new();
michael@0: 	tt_assert(buf1);
michael@0: 
michael@0: 	evbuffer_add_reference(buf1, chunk1, len1, ref_done_cb, (void*)111);
michael@0: 	evbuffer_add(buf1, ", ", 2);
michael@0: 	evbuffer_add_reference(buf1, chunk2, len2, ref_done_cb, (void*)222);
michael@0: 	tt_int_op(evbuffer_get_length(buf1), ==, len1+len2+2);
michael@0: 
michael@0: 	/* Make sure we can drain a little from a reference. */
michael@0: 	tt_int_op(evbuffer_remove(buf1, tmp, 6), ==, 6);
michael@0: 	tt_int_op(memcmp(tmp, "If you", 6), ==, 0);
michael@0: 	tt_int_op(evbuffer_remove(buf1, tmp, 5), ==, 5);
michael@0: 	tt_int_op(memcmp(tmp, " have", 5), ==, 0);
michael@0: 
michael@0: 	/* Make sure that prepending does not meddle with immutable data */
michael@0: 	tt_int_op(evbuffer_prepend(buf1, "I have ", 7), ==, 0);
michael@0: 	tt_int_op(memcmp(chunk1, "If you", 6), ==, 0);
michael@0: 	evbuffer_validate(buf1);
michael@0: 
michael@0: 	/* Make sure that when the chunk is over, the callback is invoked. */
michael@0: 	evbuffer_drain(buf1, 7); /* Remove prepended stuff. */
michael@0: 	evbuffer_drain(buf1, len1-11-1); /* remove all but one byte of chunk1 */
michael@0: 	tt_int_op(ref_done_cb_called_count, ==, 0);
michael@0: 	evbuffer_remove(buf1, tmp, 1);
michael@0: 	tt_int_op(tmp[0], ==, 'm');
michael@0: 	tt_assert(ref_done_cb_called_with == (void*)111);
michael@0: 	tt_assert(ref_done_cb_called_with_data == chunk1);
michael@0: 	tt_assert(ref_done_cb_called_with_len == len1);
michael@0: 	tt_int_op(ref_done_cb_called_count, ==, 1);
michael@0: 	evbuffer_validate(buf1);
michael@0: 
michael@0: 	/* Drain some of the remaining chunk, then add it to another buffer */
michael@0: 	evbuffer_drain(buf1, 6); /* Remove the ", you ". */
michael@0: 	buf2 = evbuffer_new();
michael@0: 	tt_assert(buf2);
michael@0: 	tt_int_op(ref_done_cb_called_count, ==, 1);
michael@0: 	evbuffer_add(buf2, "I ", 2);
michael@0: 
michael@0: 	evbuffer_add_buffer(buf2, buf1);
michael@0: 	tt_int_op(ref_done_cb_called_count, ==, 1);
michael@0: 	evbuffer_remove(buf2, tmp, 16);
michael@0: 	tt_int_op(memcmp("I ought to write", tmp, 16), ==, 0);
michael@0: 	evbuffer_drain(buf2, evbuffer_get_length(buf2));
michael@0: 	tt_int_op(ref_done_cb_called_count, ==, 2);
michael@0: 	tt_assert(ref_done_cb_called_with == (void*)222);
michael@0: 	evbuffer_validate(buf2);
michael@0: 
michael@0: 	/* Now add more stuff to buf1 and make sure that it gets removed on
michael@0: 	 * free. */
michael@0: 	evbuffer_add(buf1, "You shake and shake the ", 24);
michael@0: 	evbuffer_add_reference(buf1, "ketchup bottle", 14, ref_done_cb,
michael@0: 	    (void*)3333);
michael@0: 	evbuffer_add(buf1, ". Nothing comes and then a lot'll.", 42);
michael@0: 	evbuffer_free(buf1);
michael@0: 	buf1 = NULL;
michael@0: 	tt_int_op(ref_done_cb_called_count, ==, 3);
michael@0: 	tt_assert(ref_done_cb_called_with == (void*)3333);
michael@0: 
michael@0: end:
michael@0: 	if (buf1)
michael@0: 		evbuffer_free(buf1);
michael@0: 	if (buf2)
michael@0: 		evbuffer_free(buf2);
michael@0: }
michael@0: 
michael@0: /* Some cases that we didn't get in test_evbuffer() above, for more coverage. */
michael@0: static void
michael@0: test_evbuffer_prepend(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf1 = NULL, *buf2 = NULL;
michael@0: 	char tmp[128];
michael@0: 	int n;
michael@0: 
michael@0: 	buf1 = evbuffer_new();
michael@0: 	tt_assert(buf1);
michael@0: 
michael@0: 	/* Case 0: The evbuffer is entirely empty. */
michael@0: 	evbuffer_prepend(buf1, "This string has 29 characters", 29);
michael@0: 	evbuffer_validate(buf1);
michael@0: 
michael@0: 	/* Case 1: Prepend goes entirely in new chunk. */
michael@0: 	evbuffer_prepend(buf1, "Short.", 6);
michael@0: 	evbuffer_validate(buf1);
michael@0: 
michael@0: 	/* Case 2: prepend goes entirely in first chunk. */
michael@0: 	evbuffer_drain(buf1, 6+11);
michael@0: 	evbuffer_prepend(buf1, "it", 2);
michael@0: 	evbuffer_validate(buf1);
michael@0: 	tt_assert(!memcmp(buf1->first->buffer+buf1->first->misalign,
michael@0: 		"it has", 6));
michael@0: 
michael@0: 	/* Case 3: prepend is split over multiple chunks. */
michael@0: 	evbuffer_prepend(buf1, "It is no longer true to say ", 28);
michael@0: 	evbuffer_validate(buf1);
michael@0: 	n = evbuffer_remove(buf1, tmp, sizeof(tmp)-1);
michael@0: 	tmp[n]='\0';
michael@0: 	tt_str_op(tmp,==,"It is no longer true to say it has 29 characters");
michael@0: 
michael@0: 	buf2 = evbuffer_new();
michael@0: 	tt_assert(buf2);
michael@0: 
michael@0: 	/* Case 4: prepend a buffer to an empty buffer. */
michael@0: 	n = 999;
michael@0: 	evbuffer_add_printf(buf1, "Here is string %d. ", n++);
michael@0: 	evbuffer_prepend_buffer(buf2, buf1);
michael@0: 	evbuffer_validate(buf2);
michael@0: 
michael@0: 	/* Case 5: prepend a buffer to a nonempty buffer. */
michael@0: 	evbuffer_add_printf(buf1, "Here is string %d. ", n++);
michael@0: 	evbuffer_prepend_buffer(buf2, buf1);
michael@0: 	evbuffer_validate(buf2);
michael@0: 	evbuffer_validate(buf1);
michael@0: 	n = evbuffer_remove(buf2, tmp, sizeof(tmp)-1);
michael@0: 	tmp[n]='\0';
michael@0: 	tt_str_op(tmp,==,"Here is string 1000. Here is string 999. ");
michael@0: 
michael@0: end:
michael@0: 	if (buf1)
michael@0: 		evbuffer_free(buf1);
michael@0: 	if (buf2)
michael@0: 		evbuffer_free(buf2);
michael@0: 
michael@0: }
michael@0: 
michael@0: static void
michael@0: test_evbuffer_peek(void *info)
michael@0: {
michael@0: 	struct evbuffer *buf = NULL, *tmp_buf = NULL;
michael@0: 	int i;
michael@0: 	struct evbuffer_iovec v[20];
michael@0: 	struct evbuffer_ptr ptr;
michael@0: 
michael@0: #define tt_iov_eq(v, s)						\
michael@0: 	tt_int_op((v)->iov_len, ==, strlen(s));			\
michael@0: 	tt_assert(!memcmp((v)->iov_base, (s), strlen(s)))
michael@0: 
michael@0: 	/* Let's make a very fragmented buffer. */
michael@0: 	buf = evbuffer_new();
michael@0: 	tmp_buf = evbuffer_new();
michael@0: 	for (i = 0; i < 16; ++i) {
michael@0: 		evbuffer_add_printf(tmp_buf, "Contents of chunk [%d]\n", i);
michael@0: 		evbuffer_add_buffer(buf, tmp_buf);
michael@0: 	}
michael@0: 
michael@0: 	/* How many chunks do we need for everything? */
michael@0: 	i = evbuffer_peek(buf, -1, NULL, NULL, 0);
michael@0: 	tt_int_op(i, ==, 16);
michael@0: 
michael@0: 	/* Simple peek: get everything. */
michael@0: 	i = evbuffer_peek(buf, -1, NULL, v, 20);
michael@0: 	tt_int_op(i, ==, 16); /* we used only 16 chunks. */
michael@0: 	tt_iov_eq(&v[0], "Contents of chunk [0]\n");
michael@0: 	tt_iov_eq(&v[3], "Contents of chunk [3]\n");
michael@0: 	tt_iov_eq(&v[12], "Contents of chunk [12]\n");
michael@0: 	tt_iov_eq(&v[15], "Contents of chunk [15]\n");
michael@0: 
michael@0: 	/* Just get one chunk worth. */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(buf, -1, NULL, v, 1);
michael@0: 	tt_int_op(i, ==, 1);
michael@0: 	tt_iov_eq(&v[0], "Contents of chunk [0]\n");
michael@0: 	tt_assert(v[1].iov_base == NULL);
michael@0: 
michael@0: 	/* Suppose we want at least the first 40 bytes. */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(buf, 40, NULL, v, 16);
michael@0: 	tt_int_op(i, ==, 2);
michael@0: 	tt_iov_eq(&v[0], "Contents of chunk [0]\n");
michael@0: 	tt_iov_eq(&v[1], "Contents of chunk [1]\n");
michael@0: 	tt_assert(v[2].iov_base == NULL);
michael@0: 
michael@0: 	/* How many chunks do we need for 100 bytes? */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(buf, 100, NULL, NULL, 0);
michael@0: 	tt_int_op(i, ==, 5);
michael@0: 	tt_assert(v[0].iov_base == NULL);
michael@0: 
michael@0: 	/* Now we ask for more bytes than we provide chunks for */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(buf, 60, NULL, v, 1);
michael@0: 	tt_int_op(i, ==, 3);
michael@0: 	tt_iov_eq(&v[0], "Contents of chunk [0]\n");
michael@0: 	tt_assert(v[1].iov_base == NULL);
michael@0: 
michael@0: 	/* Now we ask for more bytes than the buffer has. */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(buf, 65536, NULL, v, 20);
michael@0: 	tt_int_op(i, ==, 16); /* we used only 16 chunks. */
michael@0: 	tt_iov_eq(&v[0], "Contents of chunk [0]\n");
michael@0: 	tt_iov_eq(&v[3], "Contents of chunk [3]\n");
michael@0: 	tt_iov_eq(&v[12], "Contents of chunk [12]\n");
michael@0: 	tt_iov_eq(&v[15], "Contents of chunk [15]\n");
michael@0: 	tt_assert(v[16].iov_base == NULL);
michael@0: 
michael@0: 	/* What happens if we try an empty buffer? */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(tmp_buf, -1, NULL, v, 20);
michael@0: 	tt_int_op(i, ==, 0);
michael@0: 	tt_assert(v[0].iov_base == NULL);
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	i = evbuffer_peek(tmp_buf, 50, NULL, v, 20);
michael@0: 	tt_int_op(i, ==, 0);
michael@0: 	tt_assert(v[0].iov_base == NULL);
michael@0: 
michael@0: 	/* Okay, now time to have fun with pointers. */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	evbuffer_ptr_set(buf, &ptr, 30, EVBUFFER_PTR_SET);
michael@0: 	i = evbuffer_peek(buf, 50, &ptr, v, 20);
michael@0: 	tt_int_op(i, ==, 3);
michael@0: 	tt_iov_eq(&v[0], " of chunk [1]\n");
michael@0: 	tt_iov_eq(&v[1], "Contents of chunk [2]\n");
michael@0: 	tt_iov_eq(&v[2], "Contents of chunk [3]\n"); /*more than we asked for*/
michael@0: 
michael@0: 	/* advance to the start of another chain. */
michael@0: 	memset(v, 0, sizeof(v));
michael@0: 	evbuffer_ptr_set(buf, &ptr, 14, EVBUFFER_PTR_ADD);
michael@0: 	i = evbuffer_peek(buf, 44, &ptr, v, 20);
michael@0: 	tt_int_op(i, ==, 2);
michael@0: 	tt_iov_eq(&v[0], "Contents of chunk [2]\n");
michael@0: 	tt_iov_eq(&v[1], "Contents of chunk [3]\n"); /*more than we asked for*/
michael@0: 
michael@0: end:
michael@0: 	if (buf)
michael@0: 		evbuffer_free(buf);
michael@0: 	if (tmp_buf)
michael@0: 		evbuffer_free(tmp_buf);
michael@0: }
michael@0: 
michael@0: /* Check whether evbuffer freezing works right.  This is called twice,
michael@0:    once with the argument "start" and once with the argument "end".
michael@0:    When we test "start", we freeze the start of an evbuffer and make sure
michael@0:    that modifying the start of the buffer doesn't work.  When we test
michael@0:    "end", we freeze the end of an evbuffer and make sure that modifying
michael@0:    the end of the buffer doesn't work.
michael@0:  */
michael@0: static void
michael@0: test_evbuffer_freeze(void *ptr)
michael@0: {
michael@0: 	struct evbuffer *buf = NULL, *tmp_buf=NULL;
michael@0: 	const char string[] = /* Year's End, Richard Wilbur */
michael@0: 	    "I've known the wind by water banks to shake\n"
michael@0: 	    "The late leaves down, which frozen where they fell\n"
michael@0: 	    "And held in ice as dancers in a spell\n"
michael@0: 	    "Fluttered all winter long into a lake...";
michael@0: 	const int start = !strcmp(ptr, "start");
michael@0: 	char *cp;
michael@0: 	char charbuf[128];
michael@0: 	int r;
michael@0: 	size_t orig_length;
michael@0: 	struct evbuffer_iovec v[1];
michael@0: 
michael@0: 	if (!start)
michael@0: 		tt_str_op(ptr, ==, "end");
michael@0: 
michael@0: 	buf = evbuffer_new();
michael@0: 	tmp_buf = evbuffer_new();
michael@0: 	tt_assert(tmp_buf);
michael@0: 
michael@0: 	evbuffer_add(buf, string, strlen(string));
michael@0: 	evbuffer_freeze(buf, start); /* Freeze the start or the end.*/
michael@0: 
michael@0: #define FREEZE_EQ(a, startcase, endcase)		\
michael@0: 	do {						\
michael@0: 	    if (start) {				\
michael@0: 		    tt_int_op((a), ==, (startcase));	\
michael@0: 	    } else {					\
michael@0: 		    tt_int_op((a), ==, (endcase));	\
michael@0: 	    }						\
michael@0: 	} while (0)
michael@0: 
michael@0: 
michael@0: 	orig_length = evbuffer_get_length(buf);
michael@0: 
michael@0: 	/* These functions all manipulate the end of buf. */
michael@0: 	r = evbuffer_add(buf, "abc", 0);
michael@0: 	FREEZE_EQ(r, 0, -1);
michael@0: 	r = evbuffer_reserve_space(buf, 10, v, 1);
michael@0: 	FREEZE_EQ(r, 1, -1);
michael@0: 	if (r == 0) {
michael@0: 		memset(v[0].iov_base, 'X', 10);
michael@0: 		v[0].iov_len = 10;
michael@0: 	}
michael@0: 	r = evbuffer_commit_space(buf, v, 1);
michael@0: 	FREEZE_EQ(r, 0, -1);
michael@0: 	r = evbuffer_add_reference(buf, string, 5, NULL, NULL);
michael@0: 	FREEZE_EQ(r, 0, -1);
michael@0: 	r = evbuffer_add_printf(buf, "Hello %s", "world");
michael@0: 	FREEZE_EQ(r, 11, -1);
michael@0: 	/* TODO: test add_buffer, add_file, read */
michael@0: 
michael@0: 	if (!start)
michael@0: 		tt_int_op(orig_length, ==, evbuffer_get_length(buf));
michael@0: 
michael@0: 	orig_length = evbuffer_get_length(buf);
michael@0: 
michael@0: 	/* These functions all manipulate the start of buf. */
michael@0: 	r = evbuffer_remove(buf, charbuf, 1);
michael@0: 	FREEZE_EQ(r, -1, 1);
michael@0: 	r = evbuffer_drain(buf, 3);
michael@0: 	FREEZE_EQ(r, -1, 0);
michael@0: 	r = evbuffer_prepend(buf, "dummy", 5);
michael@0: 	FREEZE_EQ(r, -1, 0);
michael@0: 	cp = evbuffer_readln(buf, NULL, EVBUFFER_EOL_LF);
michael@0: 	FREEZE_EQ(cp==NULL, 1, 0);
michael@0: 	if (cp)
michael@0: 		free(cp);
michael@0: 	/* TODO: Test remove_buffer, add_buffer, write, prepend_buffer */
michael@0: 
michael@0: 	if (start)
michael@0: 		tt_int_op(orig_length, ==, evbuffer_get_length(buf));
michael@0: 
michael@0: end:
michael@0: 	if (buf)
michael@0: 		evbuffer_free(buf);
michael@0: 
michael@0: 	if (tmp_buf)
michael@0: 		evbuffer_free(tmp_buf);
michael@0: }
michael@0: 
michael@0: static void *
michael@0: setup_passthrough(const struct testcase_t *testcase)
michael@0: {
michael@0: 	return testcase->setup_data;
michael@0: }
michael@0: static int
michael@0: cleanup_passthrough(const struct testcase_t *testcase, void *ptr)
michael@0: {
michael@0: 	(void) ptr;
michael@0: 	return 1;
michael@0: }
michael@0: 
michael@0: static const struct testcase_setup_t nil_setup = {
michael@0: 	setup_passthrough,
michael@0: 	cleanup_passthrough
michael@0: };
michael@0: 
michael@0: struct testcase_t evbuffer_testcases[] = {
michael@0: 	{ "evbuffer", test_evbuffer, 0, NULL, NULL },
michael@0: 	{ "remove_buffer_with_empty", test_evbuffer_remove_buffer_with_empty, 0, NULL, NULL },
michael@0: 	{ "reserve2", test_evbuffer_reserve2, 0, NULL, NULL },
michael@0: 	{ "reserve_many", test_evbuffer_reserve_many, 0, NULL, NULL },
michael@0: 	{ "reserve_many2", test_evbuffer_reserve_many, 0, &nil_setup, (void*)"add" },
michael@0: 	{ "reserve_many3", test_evbuffer_reserve_many, 0, &nil_setup, (void*)"fill" },
michael@0: 	{ "expand", test_evbuffer_expand, 0, NULL, NULL },
michael@0: 	{ "reference", test_evbuffer_reference, 0, NULL, NULL },
michael@0: 	{ "iterative", test_evbuffer_iterative, 0, NULL, NULL },
michael@0: 	{ "readln", test_evbuffer_readln, TT_NO_LOGS, &basic_setup, NULL },
michael@0: 	{ "search_eol", test_evbuffer_search_eol, 0, NULL, NULL },
michael@0: 	{ "find", test_evbuffer_find, 0, NULL, NULL },
michael@0: 	{ "ptr_set", test_evbuffer_ptr_set, 0, NULL, NULL },
michael@0: 	{ "search", test_evbuffer_search, 0, NULL, NULL },
michael@0: 	{ "callbacks", test_evbuffer_callbacks, 0, NULL, NULL },
michael@0: 	{ "add_reference", test_evbuffer_add_reference, 0, NULL, NULL },
michael@0: 	{ "prepend", test_evbuffer_prepend, TT_FORK, NULL, NULL },
michael@0: 	{ "peek", test_evbuffer_peek, 0, NULL, NULL },
michael@0: 	{ "freeze_start", test_evbuffer_freeze, 0, &nil_setup, (void*)"start" },
michael@0: 	{ "freeze_end", test_evbuffer_freeze, 0, &nil_setup, (void*)"end" },
michael@0: 	/* TODO: need a temp file implementation for Windows */
michael@0: 	{ "add_file_sendfile", test_evbuffer_add_file, TT_FORK, &nil_setup,
michael@0: 	  (void*)"sendfile" },
michael@0: 	{ "add_file_mmap", test_evbuffer_add_file, TT_FORK, &nil_setup,
michael@0: 	  (void*)"mmap" },
michael@0: 	{ "add_file_linear", test_evbuffer_add_file, TT_FORK, &nil_setup,
michael@0: 	  (void*)"linear" },
michael@0: 
michael@0: 	END_OF_TESTCASES
michael@0: };