1eac58b9emaste/*
2eac58b9emaste * Copyright (c) 2009-2012 Nick Mathewson and Niels Provos
3eac58b9emaste *
4eac58b9emaste * Redistribution and use in source and binary forms, with or without
5eac58b9emaste * modification, are permitted provided that the following conditions
6eac58b9emaste * are met:
7eac58b9emaste * 1. Redistributions of source code must retain the above copyright
8eac58b9emaste *    notice, this list of conditions and the following disclaimer.
9eac58b9emaste * 2. Redistributions in binary form must reproduce the above copyright
10eac58b9emaste *    notice, this list of conditions and the following disclaimer in the
11eac58b9emaste *    documentation and/or other materials provided with the distribution.
12eac58b9emaste * 3. The name of the author may not be used to endorse or promote products
13eac58b9emaste *    derived from this software without specific prior written permission.
14eac58b9emaste *
15eac58b9emaste * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16eac58b9emaste * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17eac58b9emaste * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18eac58b9emaste * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19eac58b9emaste * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20eac58b9emaste * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21eac58b9emaste * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22eac58b9emaste * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23eac58b9emaste * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24eac58b9emaste * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25eac58b9emaste */
26eac58b9emaste#include "../util-internal.h"
27eac58b9emaste
28eac58b9emaste#ifdef _WIN32
29eac58b9emaste#include <winsock2.h>
30eac58b9emaste#include <windows.h>
31eac58b9emaste#include <ws2tcpip.h>
32eac58b9emaste#endif
33eac58b9emaste
34eac58b9emaste#include "event2/event-config.h"
35eac58b9emaste
36eac58b9emaste#include <sys/types.h>
37eac58b9emaste
38eac58b9emaste#ifndef _WIN32
39eac58b9emaste#include <sys/socket.h>
40eac58b9emaste#include <netinet/in.h>
41eac58b9emaste#include <arpa/inet.h>
42eac58b9emaste#include <unistd.h>
43eac58b9emaste#endif
44eac58b9emaste#ifdef EVENT__HAVE_NETINET_IN6_H
45eac58b9emaste#include <netinet/in6.h>
46eac58b9emaste#endif
47eac58b9emaste#ifdef EVENT__HAVE_SYS_WAIT_H
48eac58b9emaste#include <sys/wait.h>
49eac58b9emaste#endif
50eac58b9emaste#include <signal.h>
51eac58b9emaste#include <stdio.h>
52eac58b9emaste#include <stdlib.h>
53eac58b9emaste#include <string.h>
54eac58b9emaste
55eac58b9emaste#include "event2/event.h"
56eac58b9emaste#include "event2/util.h"
57eac58b9emaste#include "../ipv6-internal.h"
58eac58b9emaste#include "../log-internal.h"
59eac58b9emaste#include "../strlcpy-internal.h"
60eac58b9emaste#include "../mm-internal.h"
61eac58b9emaste#include "../time-internal.h"
62eac58b9emaste
63eac58b9emaste#include "regress.h"
64eac58b9emaste
65eac58b9emasteenum entry_status { NORMAL, CANONICAL, BAD };
66eac58b9emaste
67eac58b9emaste/* This is a big table of results we expect from generating and parsing */
68eac58b9emastestatic struct ipv4_entry {
69eac58b9emaste	const char *addr;
70eac58b9emaste	ev_uint32_t res;
71eac58b9emaste	enum entry_status status;
72eac58b9emaste} ipv4_entries[] = {
73eac58b9emaste	{ "1.2.3.4", 0x01020304u, CANONICAL },
74eac58b9emaste	{ "255.255.255.255", 0xffffffffu, CANONICAL },
75eac58b9emaste	{ "256.0.0.0", 0, BAD },
76eac58b9emaste	{ "ABC", 0, BAD },
77eac58b9emaste	{ "1.2.3.4.5", 0, BAD },
78eac58b9emaste	{ "176.192.208.244", 0xb0c0d0f4, CANONICAL },
79eac58b9emaste	{ NULL, 0, BAD },
80eac58b9emaste};
81eac58b9emaste
82eac58b9emastestatic struct ipv6_entry {
83eac58b9emaste	const char *addr;
84eac58b9emaste	ev_uint32_t res[4];
85eac58b9emaste	enum entry_status status;
86eac58b9emaste} ipv6_entries[] = {
87eac58b9emaste	{ "::", { 0, 0, 0, 0, }, CANONICAL },
88eac58b9emaste	{ "0:0:0:0:0:0:0:0", { 0, 0, 0, 0, }, NORMAL },
89eac58b9emaste	{ "::1", { 0, 0, 0, 1, }, CANONICAL },
90eac58b9emaste	{ "::1.2.3.4", { 0, 0, 0, 0x01020304, }, CANONICAL },
91eac58b9emaste	{ "ffff:1::", { 0xffff0001u, 0, 0, 0, }, CANONICAL },
92eac58b9emaste	{ "ffff:0000::", { 0xffff0000u, 0, 0, 0, }, NORMAL },
93eac58b9emaste	{ "ffff::1234", { 0xffff0000u, 0, 0, 0x1234, }, CANONICAL },
94eac58b9emaste	{ "0102::1.2.3.4", {0x01020000u, 0, 0, 0x01020304u }, NORMAL },
95eac58b9emaste	{ "::9:c0a8:1:1", { 0, 0, 0x0009c0a8u, 0x00010001u }, CANONICAL },
96eac58b9emaste	{ "::ffff:1.2.3.4", { 0, 0, 0x000ffffu, 0x01020304u }, CANONICAL },
97eac58b9emaste	{ "FFFF::", { 0xffff0000u, 0, 0, 0 }, NORMAL },
98eac58b9emaste	{ "foobar.", { 0, 0, 0, 0 }, BAD },
99eac58b9emaste	{ "foobar", { 0, 0, 0, 0 }, BAD },
100eac58b9emaste	{ "fo:obar", { 0, 0, 0, 0 }, BAD },
101eac58b9emaste	{ "ffff", { 0, 0, 0, 0 }, BAD },
102eac58b9emaste	{ "fffff::", { 0, 0, 0, 0 }, BAD },
103eac58b9emaste	{ "fffff::", { 0, 0, 0, 0 }, BAD },
104eac58b9emaste	{ "::1.0.1.1000", { 0, 0, 0, 0 }, BAD },
105eac58b9emaste	{ "1:2:33333:4::", { 0, 0, 0, 0 }, BAD },
106eac58b9emaste	{ "1:2:3:4:5:6:7:8:9", { 0, 0, 0, 0 }, BAD },
107eac58b9emaste	{ "1::2::3", { 0, 0, 0, 0 }, BAD },
108eac58b9emaste	{ ":::1", { 0, 0, 0, 0 }, BAD },
109eac58b9emaste	{ NULL, { 0, 0, 0, 0,  }, BAD },
110eac58b9emaste};
111eac58b9emaste
112eac58b9emastestatic void
113eac58b9emasteregress_ipv4_parse(void *ptr)
114eac58b9emaste{
115eac58b9emaste	int i;
116eac58b9emaste	for (i = 0; ipv4_entries[i].addr; ++i) {
117eac58b9emaste		char written[128];
118eac58b9emaste		struct ipv4_entry *ent = &ipv4_entries[i];
119eac58b9emaste		struct in_addr in;
120eac58b9emaste		int r;
121eac58b9emaste		r = evutil_inet_pton(AF_INET, ent->addr, &in);
122eac58b9emaste		if (r == 0) {
123eac58b9emaste			if (ent->status != BAD) {
124eac58b9emaste				TT_FAIL(("%s did not parse, but it's a good address!",
125eac58b9emaste					ent->addr));
126eac58b9emaste			}
127eac58b9emaste			continue;
128eac58b9emaste		}
129eac58b9emaste		if (ent->status == BAD) {
130eac58b9emaste			TT_FAIL(("%s parsed, but we expected an error", ent->addr));
131eac58b9emaste			continue;
132eac58b9emaste		}
133eac58b9emaste		if (ntohl(in.s_addr) != ent->res) {
134eac58b9emaste			TT_FAIL(("%s parsed to %lx, but we expected %lx", ent->addr,
135eac58b9emaste				(unsigned long)ntohl(in.s_addr),
136eac58b9emaste				(unsigned long)ent->res));
137eac58b9emaste			continue;
138eac58b9emaste		}
139eac58b9emaste		if (ent->status == CANONICAL) {
140eac58b9emaste			const char *w = evutil_inet_ntop(AF_INET, &in, written,
141eac58b9emaste											 sizeof(written));
142eac58b9emaste			if (!w) {
143eac58b9emaste				TT_FAIL(("Tried to write out %s; got NULL.", ent->addr));
144eac58b9emaste				continue;
145eac58b9emaste			}
146eac58b9emaste			if (strcmp(written, ent->addr)) {
147eac58b9emaste				TT_FAIL(("Tried to write out %s; got %s",
148eac58b9emaste					ent->addr, written));
149eac58b9emaste				continue;
150eac58b9emaste			}
151eac58b9emaste		}
152eac58b9emaste
153eac58b9emaste	}
154eac58b9emaste
155eac58b9emaste}
156eac58b9emaste
157eac58b9emastestatic void
158eac58b9emasteregress_ipv6_parse(void *ptr)
159eac58b9emaste{
160eac58b9emaste#ifdef AF_INET6
161eac58b9emaste	int i, j;
162eac58b9emaste
163eac58b9emaste	for (i = 0; ipv6_entries[i].addr; ++i) {
164eac58b9emaste		char written[128];
165eac58b9emaste		struct ipv6_entry *ent = &ipv6_entries[i];
166eac58b9emaste		struct in6_addr in6;
167eac58b9emaste		int r;
168eac58b9emaste		r = evutil_inet_pton(AF_INET6, ent->addr, &in6);
169eac58b9emaste		if (r == 0) {
170eac58b9emaste			if (ent->status != BAD)
171eac58b9emaste				TT_FAIL(("%s did not parse, but it's a good address!",
172eac58b9emaste					ent->addr));
173eac58b9emaste			continue;
174eac58b9emaste		}
175eac58b9emaste		if (ent->status == BAD) {
176eac58b9emaste			TT_FAIL(("%s parsed, but we expected an error", ent->addr));
177eac58b9emaste			continue;
178eac58b9emaste		}
179eac58b9emaste		for (j = 0; j < 4; ++j) {
180eac58b9emaste			/* Can't use s6_addr32 here; some don't have it. */
181eac58b9emaste			ev_uint32_t u =
182eac58b9emaste			    ((ev_uint32_t)in6.s6_addr[j*4  ] << 24) |
183eac58b9emaste			    ((ev_uint32_t)in6.s6_addr[j*4+1] << 16) |
184eac58b9emaste			    ((ev_uint32_t)in6.s6_addr[j*4+2] << 8) |
185eac58b9emaste			    ((ev_uint32_t)in6.s6_addr[j*4+3]);
186eac58b9emaste			if (u != ent->res[j]) {
187eac58b9emaste				TT_FAIL(("%s did not parse as expected.", ent->addr));
188eac58b9emaste				continue;
189eac58b9emaste			}
190eac58b9emaste		}
191eac58b9emaste		if (ent->status == CANONICAL) {
192eac58b9emaste			const char *w = evutil_inet_ntop(AF_INET6, &in6, written,
193eac58b9emaste											 sizeof(written));
194eac58b9emaste			if (!w) {
195eac58b9emaste				TT_FAIL(("Tried to write out %s; got NULL.", ent->addr));
196eac58b9emaste				continue;
197eac58b9emaste			}
198eac58b9emaste			if (strcmp(written, ent->addr)) {
199eac58b9emaste				TT_FAIL(("Tried to write out %s; got %s", ent->addr, written));
200eac58b9emaste				continue;
201eac58b9emaste			}
202eac58b9emaste		}
203eac58b9emaste
204eac58b9emaste	}
205eac58b9emaste#else
206eac58b9emaste	TT_BLATHER(("Skipping IPv6 address parsing."));
207eac58b9emaste#endif
208eac58b9emaste}
209eac58b9emaste
210eac58b9emastestatic struct sa_port_ent {
211eac58b9emaste	const char *parse;
212eac58b9emaste	int safamily;
213eac58b9emaste	const char *addr;
214eac58b9emaste	int port;
215eac58b9emaste} sa_port_ents[] = {
216eac58b9emaste	{ "[ffff::1]:1000", AF_INET6, "ffff::1", 1000 },
217eac58b9emaste	{ "[ffff::1]", AF_INET6, "ffff::1", 0 },
218eac58b9emaste	{ "[ffff::1", 0, NULL, 0 },
219eac58b9emaste	{ "[ffff::1]:65599", 0, NULL, 0 },
220eac58b9emaste	{ "[ffff::1]:0", 0, NULL, 0 },
221eac58b9emaste	{ "[ffff::1]:-1", 0, NULL, 0 },
222eac58b9emaste	{ "::1", AF_INET6, "::1", 0 },
223eac58b9emaste	{ "1:2::1", AF_INET6, "1:2::1", 0 },
224eac58b9emaste	{ "192.168.0.1:50", AF_INET, "192.168.0.1", 50 },
225eac58b9emaste	{ "1.2.3.4", AF_INET, "1.2.3.4", 0 },
226eac58b9emaste	{ NULL, 0, NULL, 0 },
227eac58b9emaste};
228eac58b9emaste
229eac58b9emastestatic void
230eac58b9emasteregress_sockaddr_port_parse(void *ptr)
231eac58b9emaste{
232eac58b9emaste	struct sockaddr_storage ss;
233eac58b9emaste	int i, r;
234eac58b9emaste
235eac58b9emaste	for (i = 0; sa_port_ents[i].parse; ++i) {
236eac58b9emaste		struct sa_port_ent *ent = &sa_port_ents[i];
237eac58b9emaste		int len = sizeof(ss);
238eac58b9emaste		memset(&ss, 0, sizeof(ss));
239eac58b9emaste		r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len);
240eac58b9emaste		if (r < 0) {
241eac58b9emaste			if (ent->safamily)
242eac58b9emaste				TT_FAIL(("Couldn't parse %s!", ent->parse));
243eac58b9emaste			continue;
244eac58b9emaste		} else if (! ent->safamily) {
245eac58b9emaste			TT_FAIL(("Shouldn't have been able to parse %s!", ent->parse));
246eac58b9emaste			continue;
247eac58b9emaste		}
248eac58b9emaste		if (ent->safamily == AF_INET) {
249eac58b9emaste			struct sockaddr_in sin;
250eac58b9emaste			memset(&sin, 0, sizeof(sin));
251eac58b9emaste#ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
252eac58b9emaste			sin.sin_len = sizeof(sin);
253eac58b9emaste#endif
254eac58b9emaste			sin.sin_family = AF_INET;
255eac58b9emaste			sin.sin_port = htons(ent->port);
256eac58b9emaste			r = evutil_inet_pton(AF_INET, ent->addr, &sin.sin_addr);
257eac58b9emaste			if (1 != r) {
258eac58b9emaste				TT_FAIL(("Couldn't parse ipv4 target %s.", ent->addr));
259eac58b9emaste			} else if (memcmp(&sin, &ss, sizeof(sin))) {
260eac58b9emaste				TT_FAIL(("Parse for %s was not as expected.", ent->parse));
261eac58b9emaste			} else if (len != sizeof(sin)) {
262eac58b9emaste				TT_FAIL(("Length for %s not as expected.",ent->parse));
263eac58b9emaste			}
264eac58b9emaste		} else {
265eac58b9emaste			struct sockaddr_in6 sin6;
266eac58b9emaste			memset(&sin6, 0, sizeof(sin6));
267eac58b9emaste#ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
268eac58b9emaste			sin6.sin6_len = sizeof(sin6);
269eac58b9emaste#endif
270eac58b9emaste			sin6.sin6_family = AF_INET6;
271eac58b9emaste			sin6.sin6_port = htons(ent->port);
272eac58b9emaste			r = evutil_inet_pton(AF_INET6, ent->addr, &sin6.sin6_addr);
273eac58b9emaste			if (1 != r) {
274eac58b9emaste				TT_FAIL(("Couldn't parse ipv6 target %s.", ent->addr));
275eac58b9emaste			} else if (memcmp(&sin6, &ss, sizeof(sin6))) {
276eac58b9emaste				TT_FAIL(("Parse for %s was not as expected.", ent->parse));
277eac58b9emaste			} else if (len != sizeof(sin6)) {
278eac58b9emaste				TT_FAIL(("Length for %s not as expected.",ent->parse));
279eac58b9emaste			}
280eac58b9emaste		}
281eac58b9emaste	}
282eac58b9emaste}
283eac58b9emaste
284eac58b9emaste
285eac58b9emastestatic void
286eac58b9emasteregress_sockaddr_port_format(void *ptr)
287eac58b9emaste{
288eac58b9emaste	struct sockaddr_storage ss;
289eac58b9emaste	int len;
290eac58b9emaste	const char *cp;
291eac58b9emaste	char cbuf[128];
292eac58b9emaste	int r;
293eac58b9emaste
294eac58b9emaste	len = sizeof(ss);
295eac58b9emaste	r = evutil_parse_sockaddr_port("192.168.1.1:80",
296eac58b9emaste	    (struct sockaddr*)&ss, &len);
297eac58b9emaste	tt_int_op(r,==,0);
298eac58b9emaste	cp = evutil_format_sockaddr_port_(
299eac58b9emaste		(struct sockaddr*)&ss, cbuf, sizeof(cbuf));
300eac58b9emaste	tt_ptr_op(cp,==,cbuf);
301eac58b9emaste	tt_str_op(cp,==,"192.168.1.1:80");
302eac58b9emaste
303eac58b9emaste	len = sizeof(ss);
304eac58b9emaste	r = evutil_parse_sockaddr_port("[ff00::8010]:999",
305eac58b9emaste	    (struct sockaddr*)&ss, &len);
306eac58b9emaste	tt_int_op(r,==,0);
307eac58b9emaste	cp = evutil_format_sockaddr_port_(
308eac58b9emaste		(struct sockaddr*)&ss, cbuf, sizeof(cbuf));
309eac58b9emaste	tt_ptr_op(cp,==,cbuf);
310eac58b9emaste	tt_str_op(cp,==,"[ff00::8010]:999");
311eac58b9emaste
312eac58b9emaste	ss.ss_family=99;
313eac58b9emaste	cp = evutil_format_sockaddr_port_(
314eac58b9emaste		(struct sockaddr*)&ss, cbuf, sizeof(cbuf));
315eac58b9emaste	tt_ptr_op(cp,==,cbuf);
316eac58b9emaste	tt_str_op(cp,==,"<addr with socktype 99>");
317eac58b9emasteend:
318eac58b9emaste	;
319eac58b9emaste}
320eac58b9emaste
321eac58b9emastestatic struct sa_pred_ent {
322eac58b9emaste	const char *parse;
323eac58b9emaste
324eac58b9emaste	int is_loopback;
325eac58b9emaste} sa_pred_entries[] = {
326eac58b9emaste	{ "127.0.0.1",	 1 },
327eac58b9emaste	{ "127.0.3.2",	 1 },
328eac58b9emaste	{ "128.1.2.3",	 0 },
329eac58b9emaste	{ "18.0.0.1",	 0 },
330eac58b9emaste	{ "129.168.1.1", 0 },
331eac58b9emaste
332eac58b9emaste	{ "::1",	 1 },
333eac58b9emaste	{ "::0",	 0 },
334eac58b9emaste	{ "f::1",	 0 },
335eac58b9emaste	{ "::501",	 0 },
336eac58b9emaste	{ NULL,		 0 },
337eac58b9emaste
338eac58b9emaste};
339eac58b9emaste
340eac58b9emastestatic void
341eac58b9emastetest_evutil_sockaddr_predicates(void *ptr)
342eac58b9emaste{
343eac58b9emaste	struct sockaddr_storage ss;
344eac58b9emaste	int r, i;
345eac58b9emaste
346eac58b9emaste	for (i=0; sa_pred_entries[i].parse; ++i) {
347eac58b9emaste		struct sa_pred_ent *ent = &sa_pred_entries[i];
348eac58b9emaste		int len = sizeof(ss);
349eac58b9emaste
350eac58b9emaste		r = evutil_parse_sockaddr_port(ent->parse, (struct sockaddr*)&ss, &len);
351eac58b9emaste
352eac58b9emaste		if (r<0) {
353eac58b9emaste			TT_FAIL(("Couldn't parse %s!", ent->parse));
354eac58b9emaste			continue;
355eac58b9emaste		}
356eac58b9emaste
357eac58b9emaste		/* sockaddr_is_loopback */
358eac58b9emaste		if (ent->is_loopback != evutil_sockaddr_is_loopback_((struct sockaddr*)&ss)) {
359eac58b9emaste			TT_FAIL(("evutil_sockaddr_loopback(%s) not as expected",
360eac58b9emaste				ent->parse));
361eac58b9emaste		}
362eac58b9emaste	}
363eac58b9emaste}
364eac58b9emaste
365eac58b9emastestatic void
366eac58b9emastetest_evutil_strtoll(void *ptr)
367eac58b9emaste{
368eac58b9emaste	const char *s;
369eac58b9emaste	char *endptr;
370eac58b9emaste
371eac58b9emaste	tt_want(evutil_strtoll("5000000000", NULL, 10) ==
372eac58b9emaste		((ev_int64_t)5000000)*1000);
373eac58b9emaste	tt_want(evutil_strtoll("-5000000000", NULL, 10) ==
374eac58b9emaste		((ev_int64_t)5000000)*-1000);
375eac58b9emaste	s = " 99999stuff";
376eac58b9emaste	tt_want(evutil_strtoll(s, &endptr, 10) == (ev_int64_t)99999);
377eac58b9emaste	tt_want(endptr == s+6);
378eac58b9emaste	tt_want(evutil_strtoll("foo", NULL, 10) == 0);
379eac58b9emaste }
380eac58b9emaste
381eac58b9emastestatic void
382eac58b9emastetest_evutil_snprintf(void *ptr)
383eac58b9emaste{
384eac58b9emaste	char buf[16];
385eac58b9emaste	int r;
386eac58b9emaste	ev_uint64_t u64 = ((ev_uint64_t)1000000000)*200;
387eac58b9emaste	ev_int64_t i64 = -1 * (ev_int64_t) u64;
388eac58b9emaste	size_t size = 8000;
389eac58b9emaste	ev_ssize_t ssize = -9000;
390eac58b9emaste
391eac58b9emaste	r = evutil_snprintf(buf, sizeof(buf), "%d %d", 50, 100);
392eac58b9emaste	tt_str_op(buf, ==, "50 100");
393eac58b9emaste	tt_int_op(r, ==, 6);
394eac58b9emaste
395eac58b9emaste	r = evutil_snprintf(buf, sizeof(buf), "longish %d", 1234567890);
396eac58b9emaste	tt_str_op(buf, ==, "longish 1234567");
397eac58b9emaste	tt_int_op(r, ==, 18);
398eac58b9emaste
399eac58b9emaste	r = evutil_snprintf(buf, sizeof(buf), EV_U64_FMT, EV_U64_ARG(u64));
400eac58b9emaste	tt_str_op(buf, ==, "200000000000");
401eac58b9emaste	tt_int_op(r, ==, 12);
402eac58b9emaste
403eac58b9emaste	r = evutil_snprintf(buf, sizeof(buf), EV_I64_FMT, EV_I64_ARG(i64));
404eac58b9emaste	tt_str_op(buf, ==, "-200000000000");
405eac58b9emaste	tt_int_op(r, ==, 13);
406eac58b9emaste
407eac58b9emaste	r = evutil_snprintf(buf, sizeof(buf), EV_SIZE_FMT" "EV_SSIZE_FMT,
408eac58b9emaste	    EV_SIZE_ARG(size), EV_SSIZE_ARG(ssize));
409eac58b9emaste	tt_str_op(buf, ==, "8000 -9000");
410eac58b9emaste	tt_int_op(r, ==, 10);
411eac58b9emaste
412eac58b9emaste      end:
413eac58b9emaste	;
414eac58b9emaste}
415eac58b9emaste
416eac58b9emastestatic void
417eac58b9emastetest_evutil_casecmp(void *ptr)
418eac58b9emaste{
419eac58b9emaste	tt_int_op(evutil_ascii_strcasecmp("ABC", "ABC"), ==, 0);
420eac58b9emaste	tt_int_op(evutil_ascii_strcasecmp("ABC", "abc"), ==, 0);
421eac58b9emaste	tt_int_op(evutil_ascii_strcasecmp("ABC", "abcd"), <, 0);
422eac58b9emaste	tt_int_op(evutil_ascii_strcasecmp("ABC", "abb"), >, 0);
423eac58b9emaste	tt_int_op(evutil_ascii_strcasecmp("ABCd", "abc"), >, 0);
424eac58b9emaste
425eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibEvEnT", 100), ==, 0);
426eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibEvEnT", 4), ==, 0);
427eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibEXXXX", 4), ==, 0);
428eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Libevent", "LibE", 4), ==, 0);
429eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Libe", "LibEvEnT", 4), ==, 0);
430eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Lib", "LibEvEnT", 4), <, 0);
431eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("abc", "def", 99), <, 0);
432eac58b9emaste	tt_int_op(evutil_ascii_strncasecmp("Z", "qrst", 1), >, 0);
433eac58b9emasteend:
434eac58b9emaste	;
435eac58b9emaste}
436eac58b9emaste
437eac58b9emastestatic void
438eac58b9emastetest_evutil_rtrim(void *ptr)
439eac58b9emaste{
440eac58b9emaste#define TEST_TRIM(s, result) \
441eac58b9emaste	do {						\
442eac58b9emaste	    if (cp) mm_free(cp);			\
443eac58b9emaste	    cp = mm_strdup(s);				\
444eac58b9emaste	    tt_assert(cp);				\
445eac58b9emaste	    evutil_rtrim_lws_(cp);			\
446eac58b9emaste	    tt_str_op(cp, ==, result);			\
447eac58b9emaste	} while(0)
448eac58b9emaste
449eac58b9emaste	char *cp = NULL;
450eac58b9emaste	(void) ptr;
451eac58b9emaste
452eac58b9emaste	TEST_TRIM("", "");
453eac58b9emaste	TEST_TRIM("a", "a");
454eac58b9emaste	TEST_TRIM("abcdef ghi", "abcdef ghi");
455eac58b9emaste
456eac58b9emaste	TEST_TRIM(" ", "");
457eac58b9emaste	TEST_TRIM("  ", "");
458eac58b9emaste	TEST_TRIM("a ", "a");
459eac58b9emaste	TEST_TRIM("abcdef  gH       ", "abcdef  gH");
460eac58b9emaste
461eac58b9emaste	TEST_TRIM("\t\t", "");
462eac58b9emaste	TEST_TRIM(" \t", "");
463eac58b9emaste	TEST_TRIM("\t", "");
464eac58b9emaste	TEST_TRIM("a \t", "a");
465eac58b9emaste	TEST_TRIM("a\t ", "a");
466eac58b9emaste	TEST_TRIM("a\t", "a");
467eac58b9emaste	TEST_TRIM("abcdef  gH    \t  ", "abcdef  gH");
468eac58b9emaste
469eac58b9emasteend:
470eac58b9emaste	if (cp)
471eac58b9emaste		mm_free(cp);
472eac58b9emaste}
473eac58b9emaste
474eac58b9emastestatic int logsev = 0;
475eac58b9emastestatic char *logmsg = NULL;
476eac58b9emaste
477eac58b9emastestatic void
478eac58b9emastelogfn(int severity, const char *msg)
479eac58b9emaste{
480eac58b9emaste	logsev = severity;
481eac58b9emaste	tt_want(msg);
482eac58b9emaste	if (msg) {
483eac58b9emaste		if (logmsg)
484eac58b9emaste			free(logmsg);
485eac58b9emaste		logmsg = strdup(msg);
486eac58b9emaste	}
487eac58b9emaste}
488eac58b9emaste
489eac58b9emastestatic int fatal_want_severity = 0;
490eac58b9emastestatic const char *fatal_want_message = NULL;
491eac58b9emastestatic void
492eac58b9emastefatalfn(int exitcode)
493eac58b9emaste{
494eac58b9emaste	if (logsev != fatal_want_severity ||
495eac58b9emaste	    !logmsg ||
496eac58b9emaste	    strcmp(logmsg, fatal_want_message))
497eac58b9emaste		exit(0);
498eac58b9emaste	else
499eac58b9emaste		exit(exitcode);
500eac58b9emaste}
501eac58b9emaste
502eac58b9emaste#ifndef _WIN32
503eac58b9emaste#define CAN_CHECK_ERR
504eac58b9emastestatic void
505eac58b9emastecheck_error_logging(void (*fn)(void), int wantexitcode,
506eac58b9emaste    int wantseverity, const char *wantmsg)
507eac58b9emaste{
508eac58b9emaste	pid_t pid;
509eac58b9emaste	int status = 0, exitcode;
510eac58b9emaste	fatal_want_severity = wantseverity;
511eac58b9emaste	fatal_want_message = wantmsg;
512eac58b9emaste	if ((pid = regress_fork()) == 0) {
513eac58b9emaste		/* child process */
514eac58b9emaste		fn();
515eac58b9emaste		exit(0); /* should be unreachable. */
516eac58b9emaste	} else {
517eac58b9emaste		wait(&status);
518eac58b9emaste		exitcode = WEXITSTATUS(status);
519eac58b9emaste		tt_int_op(wantexitcode, ==, exitcode);
520eac58b9emaste	}
521eac58b9emasteend:
522eac58b9emaste	;
523eac58b9emaste}
524eac58b9emaste
525eac58b9emastestatic void
526eac58b9emasteerrx_fn(void)
527eac58b9emaste{
528eac58b9emaste	event_errx(2, "Fatal error; too many kumquats (%d)", 5);
529eac58b9emaste}
530eac58b9emaste
531eac58b9emastestatic void
532eac58b9emasteerr_fn(void)
533eac58b9emaste{
534eac58b9emaste	errno = ENOENT;
535eac58b9emaste	event_err(5,"Couldn't open %s", "/very/bad/file");
536eac58b9emaste}
537eac58b9emaste
538eac58b9emastestatic void
539eac58b9emastesock_err_fn(void)
540eac58b9emaste{
541eac58b9emaste	evutil_socket_t fd = socket(AF_INET, SOCK_STREAM, 0);
542eac58b9emaste#ifdef _WIN32
543eac58b9emaste	EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK);
544eac58b9emaste#else
545eac58b9emaste	errno = EAGAIN;
546eac58b9emaste#endif
547eac58b9emaste	event_sock_err(20, fd, "Unhappy socket");
548eac58b9emaste}
549eac58b9emaste#endif
550eac58b9emaste
551eac58b9emastestatic void
552eac58b9emastetest_evutil_log(void *ptr)
553eac58b9emaste{
554eac58b9emaste	evutil_socket_t fd = -1;
555eac58b9emaste	char buf[128];
556eac58b9emaste
557eac58b9emaste	event_set_log_callback(logfn);
558eac58b9emaste	event_set_fatal_callback(fatalfn);
559eac58b9emaste#define RESET() do {				\
560eac58b9emaste		logsev = 0;	\
561eac58b9emaste		if (logmsg) free(logmsg);	\
562eac58b9emaste		logmsg = NULL;			\
563eac58b9emaste	} while (0)
564eac58b9emaste#define LOGEQ(sev,msg) do {			\
565eac58b9emaste		tt_int_op(logsev,==,sev);	\
566eac58b9emaste		tt_assert(logmsg != NULL);	\
567eac58b9emaste		tt_str_op(logmsg,==,msg);	\
568eac58b9emaste	} while (0)
569eac58b9emaste
570eac58b9emaste#ifdef CAN_CHECK_ERR
571eac58b9emaste	/* We need to disable these tests for now.  Previously, the logging
572eac58b9emaste	 * module didn't enforce the requirement that a fatal callback
573eac58b9emaste	 * actually exit.  Now, it exits no matter what, so if we wan to
574eac58b9emaste	 * reinstate these tests, we'll need to fork for each one. */
575eac58b9emaste	check_error_logging(errx_fn, 2, EVENT_LOG_ERR,
576eac58b9emaste	    "Fatal error; too many kumquats (5)");
577eac58b9emaste	RESET();
578eac58b9emaste#endif
579eac58b9emaste
580eac58b9emaste	event_warnx("Far too many %s (%d)", "wombats", 99);
581eac58b9emaste	LOGEQ(EVENT_LOG_WARN, "Far too many wombats (99)");
582eac58b9emaste	RESET();
583eac58b9emaste
584eac58b9emaste	event_msgx("Connecting lime to coconut");
585eac58b9emaste	LOGEQ(EVENT_LOG_MSG, "Connecting lime to coconut");
586eac58b9emaste	RESET();
587eac58b9emaste
588eac58b9emaste	event_debug(("A millisecond passed! We should log that!"));
589eac58b9emaste#ifdef USE_DEBUG
590eac58b9emaste	LOGEQ(EVENT_LOG_DEBUG, "A millisecond passed! We should log that!");
591eac58b9emaste#else
592eac58b9emaste	tt_int_op(logsev,==,0);
593eac58b9emaste	tt_ptr_op(logmsg,==,NULL);
594eac58b9emaste#endif
595eac58b9emaste	RESET();
596eac58b9emaste
597eac58b9emaste	/* Try with an errno. */
598eac58b9emaste	errno = ENOENT;
599eac58b9emaste	event_warn("Couldn't open %s", "/bad/file");
600eac58b9emaste	evutil_snprintf(buf, sizeof(buf),
601eac58b9emaste	    "Couldn't open /bad/file: %s",strerror(ENOENT));
602eac58b9emaste	LOGEQ(EVENT_LOG_WARN,buf);
603eac58b9emaste	RESET();
604eac58b9emaste
605eac58b9emaste#ifdef CAN_CHECK_ERR
606eac58b9emaste	evutil_snprintf(buf, sizeof(buf),
607eac58b9emaste	    "Couldn't open /very/bad/file: %s",strerror(ENOENT));
608eac58b9emaste	check_error_logging(err_fn, 5, EVENT_LOG_ERR, buf);
609eac58b9emaste	RESET();
610eac58b9emaste#endif
611eac58b9emaste
612eac58b9emaste	/* Try with a socket errno. */
613eac58b9emaste	fd = socket(AF_INET, SOCK_STREAM, 0);
614eac58b9emaste#ifdef _WIN32
615eac58b9emaste	evutil_snprintf(buf, sizeof(buf),
616eac58b9emaste	    "Unhappy socket: %s",
617eac58b9emaste	    evutil_socket_error_to_string(WSAEWOULDBLOCK));
618eac58b9emaste	EVUTIL_SET_SOCKET_ERROR(WSAEWOULDBLOCK);
619eac58b9emaste#else
620eac58b9emaste	evutil_snprintf(buf, sizeof(buf),
621eac58b9emaste	    "Unhappy socket: %s", strerror(EAGAIN));
622eac58b9emaste	errno = EAGAIN;
623eac58b9emaste#endif
624eac58b9emaste	event_sock_warn(fd, "Unhappy socket");
625eac58b9emaste	LOGEQ(EVENT_LOG_WARN, buf);
626eac58b9emaste	RESET();
627eac58b9emaste
628eac58b9emaste#ifdef CAN_CHECK_ERR
629eac58b9emaste	check_error_logging(sock_err_fn, 20, EVENT_LOG_ERR, buf);
630eac58b9emaste	RESET();
631eac58b9emaste#endif
632eac58b9emaste
633eac58b9emaste#undef RESET
634eac58b9emaste#undef LOGEQ
635eac58b9emasteend:
636eac58b9emaste	if (logmsg)
637eac58b9emaste		free(logmsg);
638eac58b9emaste	if (fd >= 0)
639eac58b9emaste		evutil_closesocket(fd);
640eac58b9emaste}
641eac58b9emaste
642eac58b9emastestatic void
643eac58b9emastetest_evutil_strlcpy(void *arg)
644eac58b9emaste{
645eac58b9emaste	char buf[8];
646eac58b9emaste
647eac58b9emaste	/* Successful case. */
648eac58b9emaste	tt_int_op(5, ==, strlcpy(buf, "Hello", sizeof(buf)));
649eac58b9emaste	tt_str_op(buf, ==, "Hello");
650eac58b9emaste
651eac58b9emaste	/* Overflow by a lot. */
652eac58b9emaste	tt_int_op(13, ==, strlcpy(buf, "pentasyllabic", sizeof(buf)));
653eac58b9emaste	tt_str_op(buf, ==, "pentasy");
654eac58b9emaste
655eac58b9emaste	/* Overflow by exactly one. */
656eac58b9emaste	tt_int_op(8, ==, strlcpy(buf, "overlong", sizeof(buf)));
657eac58b9emaste	tt_str_op(buf, ==, "overlon");
658eac58b9emasteend:
659eac58b9emaste	;
660eac58b9emaste}
661eac58b9emaste
662eac58b9emastestruct example_struct {
663eac58b9emaste	const char *a;
664eac58b9emaste	const char *b;
665eac58b9emaste	long c;
666eac58b9emaste};
667eac58b9emaste
668eac58b9emastestatic void
669eac58b9emastetest_evutil_upcast(void *arg)
670eac58b9emaste{
671eac58b9emaste	struct example_struct es1;
672eac58b9emaste	const char **cp;
673eac58b9emaste	es1.a = "World";
674eac58b9emaste	es1.b = "Hello";
675eac58b9emaste	es1.c = -99;
676eac58b9emaste
677eac58b9emaste	tt_int_op(evutil_offsetof(struct example_struct, b), ==, sizeof(char*));
678eac58b9emaste
679eac58b9emaste	cp = &es1.b;
680eac58b9emaste	tt_ptr_op(EVUTIL_UPCAST(cp, struct example_struct, b), ==, &es1);
681eac58b9emaste
682eac58b9emasteend:
683eac58b9emaste	;
684eac58b9emaste}
685eac58b9emaste
686eac58b9emastestatic void
687eac58b9emastetest_evutil_integers(void *arg)
688eac58b9emaste{
689eac58b9emaste	ev_int64_t i64;
690eac58b9emaste	ev_uint64_t u64;
691eac58b9emaste	ev_int32_t i32;
692eac58b9emaste	ev_uint32_t u32;
693eac58b9emaste	ev_int16_t i16;
694eac58b9emaste	ev_uint16_t u16;
695eac58b9emaste	ev_int8_t  i8;
696eac58b9emaste	ev_uint8_t  u8;
697eac58b9emaste
698eac58b9emaste	void *ptr;
699eac58b9emaste	ev_intptr_t iptr;
700eac58b9emaste	ev_uintptr_t uptr;
701eac58b9emaste
702eac58b9emaste	ev_ssize_t ssize;
703eac58b9emaste
704eac58b9emaste	tt_int_op(sizeof(u64), ==, 8);
705eac58b9emaste	tt_int_op(sizeof(i64), ==, 8);
706eac58b9emaste	tt_int_op(sizeof(u32), ==, 4);
707eac58b9emaste	tt_int_op(sizeof(i32), ==, 4);
708eac58b9emaste	tt_int_op(sizeof(u16), ==, 2);
709eac58b9emaste	tt_int_op(sizeof(i16), ==, 2);
710eac58b9emaste	tt_int_op(sizeof(u8), ==,  1);
711eac58b9emaste	tt_int_op(sizeof(i8), ==,  1);
712eac58b9emaste
713eac58b9emaste	tt_int_op(sizeof(ev_ssize_t), ==, sizeof(size_t));
714eac58b9emaste	tt_int_op(sizeof(ev_intptr_t), >=, sizeof(void *));
715eac58b9emaste	tt_int_op(sizeof(ev_uintptr_t), ==, sizeof(intptr_t));
716eac58b9emaste
717eac58b9emaste	u64 = 1000000000;
718eac58b9emaste	u64 *= 1000000000;
719eac58b9emaste	tt_assert(u64 / 1000000000 == 1000000000);
720eac58b9emaste	i64 = -1000000000;
721eac58b9emaste	i64 *= 1000000000;
722eac58b9emaste	tt_assert(i64 / 1000000000 == -1000000000);
723eac58b9emaste
724eac58b9emaste	u64 = EV_UINT64_MAX;
725eac58b9emaste	i64 = EV_INT64_MAX;
726eac58b9emaste	tt_assert(u64 > 0);
727eac58b9emaste	tt_assert(i64 > 0);
728eac58b9emaste	u64++;
729eac58b9emaste/*	i64++; */
730eac58b9emaste	tt_assert(u64 == 0);
731eac58b9emaste/*	tt_assert(i64 == EV_INT64_MIN); */
732eac58b9emaste/*	tt_assert(i64 < 0); */
733eac58b9emaste
734eac58b9emaste	u32 = EV_UINT32_MAX;
735eac58b9emaste	i32 = EV_INT32_MAX;
736eac58b9emaste	tt_assert(u32 > 0);
737eac58b9emaste	tt_assert(i32 > 0);
738eac58b9emaste	u32++;
739eac58b9emaste/*	i32++; */
740eac58b9emaste	tt_assert(u32 == 0);
741eac58b9emaste/*	tt_assert(i32 == EV_INT32_MIN); */
742eac58b9emaste/*	tt_assert(i32 < 0); */
743eac58b9emaste
744eac58b9emaste	u16 = EV_UINT16_MAX;
745eac58b9emaste	i16 = EV_INT16_MAX;
746eac58b9emaste	tt_assert(u16 > 0);
747eac58b9emaste	tt_assert(i16 > 0);
748eac58b9emaste	u16++;
749eac58b9emaste/*	i16++; */
750eac58b9emaste	tt_assert(u16 == 0);
751eac58b9emaste/*	tt_assert(i16 == EV_INT16_MIN); */
752eac58b9emaste/* 	tt_assert(i16 < 0); */
753eac58b9emaste
754eac58b9emaste	u8 = EV_UINT8_MAX;
755eac58b9emaste	i8 = EV_INT8_MAX;
756eac58b9emaste	tt_assert(u8 > 0);
757eac58b9emaste	tt_assert(i8 > 0);
758eac58b9emaste	u8++;
759eac58b9emaste/*	i8++;*/
760eac58b9emaste	tt_assert(u8 == 0);
761eac58b9emaste/*	tt_assert(i8 == EV_INT8_MIN); */
762eac58b9emaste/*	tt_assert(i8 < 0); */
763eac58b9emaste
764eac58b9emaste/*
765eac58b9emaste	ssize = EV_SSIZE_MAX;
766eac58b9emaste	tt_assert(ssize > 0);
767eac58b9emaste	ssize++;
768eac58b9emaste	tt_assert(ssize < 0);
769eac58b9emaste	tt_assert(ssize == EV_SSIZE_MIN);
770eac58b9emaste*/
771eac58b9emaste
772eac58b9emaste	ptr = &ssize;
773eac58b9emaste	iptr = (ev_intptr_t)ptr;
774eac58b9emaste	uptr = (ev_uintptr_t)ptr;
775eac58b9emaste	ptr = (void *)iptr;
776eac58b9emaste	tt_assert(ptr == &ssize);
777eac58b9emaste	ptr = (void *)uptr;
778eac58b9emaste	tt_assert(ptr == &ssize);
779eac58b9emaste
780eac58b9emaste	iptr = -1;
781eac58b9emaste	tt_assert(iptr < 0);
782eac58b9emasteend:
783eac58b9emaste	;
784eac58b9emaste}
785eac58b9emaste
786eac58b9emastestruct evutil_addrinfo *
787eac58b9emasteai_find_by_family(struct evutil_addrinfo *ai, int family)
788eac58b9emaste{
789eac58b9emaste	while (ai) {
790eac58b9emaste		if (ai->ai_family == family)
791eac58b9emaste			return ai;
792eac58b9emaste		ai = ai->ai_next;
793eac58b9emaste	}
794eac58b9emaste	return NULL;
795eac58b9emaste}
796eac58b9emaste
797eac58b9emastestruct evutil_addrinfo *
798eac58b9emasteai_find_by_protocol(struct evutil_addrinfo *ai, int protocol)
799eac58b9emaste{
800eac58b9emaste	while (ai) {
801eac58b9emaste		if (ai->ai_protocol == protocol)
802eac58b9emaste			return ai;
803eac58b9emaste		ai = ai->ai_next;
804eac58b9emaste	}
805eac58b9emaste	return NULL;
806eac58b9emaste}
807eac58b9emaste
808eac58b9emaste
809eac58b9emasteint
810eac58b9emastetest_ai_eq_(const struct evutil_addrinfo *ai, const char *sockaddr_port,
811eac58b9emaste    int socktype, int protocol, int line)
812eac58b9emaste{
813eac58b9emaste	struct sockaddr_storage ss;
814eac58b9emaste	int slen = sizeof(ss);
815eac58b9emaste	int gotport;
816eac58b9emaste	char buf[128];
817eac58b9emaste	memset(&ss, 0, sizeof(ss));
818eac58b9emaste	if (socktype > 0)
819eac58b9emaste		tt_int_op(ai->ai_socktype, ==, socktype);
820eac58b9emaste	if (protocol > 0)
821eac58b9emaste		tt_int_op(ai->ai_protocol, ==, protocol);
822eac58b9emaste
823eac58b9emaste	if (evutil_parse_sockaddr_port(
824eac58b9emaste		    sockaddr_port, (struct sockaddr*)&ss, &slen)<0) {
825eac58b9emaste		TT_FAIL(("Couldn't parse expected address %s on line %d",
826eac58b9emaste			sockaddr_port, line));
827eac58b9emaste		return -1;
828eac58b9emaste	}
829eac58b9emaste	if (ai->ai_family != ss.ss_family) {
830eac58b9emaste		TT_FAIL(("Address family %d did not match %d on line %d",
831eac58b9emaste			ai->ai_family, ss.ss_family, line));
832eac58b9emaste		return -1;
833eac58b9emaste	}
834eac58b9emaste	if (ai->ai_addr->sa_family == AF_INET) {
835eac58b9emaste		struct sockaddr_in *sin = (struct sockaddr_in*)ai->ai_addr;
836eac58b9emaste		evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf));
837eac58b9emaste		gotport = ntohs(sin->sin_port);
838eac58b9emaste		if (ai->ai_addrlen != sizeof(struct sockaddr_in)) {
839eac58b9emaste			TT_FAIL(("Addr size mismatch on line %d", line));
840eac58b9emaste			return -1;
841eac58b9emaste		}
842eac58b9emaste	} else {
843eac58b9emaste		struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)ai->ai_addr;
844eac58b9emaste		evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf));
845eac58b9emaste		gotport = ntohs(sin6->sin6_port);
846eac58b9emaste		if (ai->ai_addrlen != sizeof(struct sockaddr_in6)) {
847eac58b9emaste			TT_FAIL(("Addr size mismatch on line %d", line));
848eac58b9emaste			return -1;
849eac58b9emaste		}
850eac58b9emaste	}
851eac58b9emaste	if (evutil_sockaddr_cmp(ai->ai_addr, (struct sockaddr*)&ss, 1)) {
852eac58b9emaste		TT_FAIL(("Wanted %s, got %s:%d on line %d", sockaddr_port,
853eac58b9emaste			buf, gotport, line));
854eac58b9emaste		return -1;
855eac58b9emaste	} else {
856eac58b9emaste		TT_BLATHER(("Wanted %s, got %s:%d on line %d", sockaddr_port,
857eac58b9emaste			buf, gotport, line));
858eac58b9emaste	}
859eac58b9emaste	return 0;
860eac58b9emasteend:
861eac58b9emaste	TT_FAIL(("Test failed on line %d", line));
862eac58b9emaste	return -1;
863eac58b9emaste}
864eac58b9emaste
865eac58b9emastestatic void
866eac58b9emastetest_evutil_rand(void *arg)
867eac58b9emaste{
868eac58b9emaste	char buf1[32];
869eac58b9emaste	char buf2[32];
870eac58b9emaste	int counts[256];
871eac58b9emaste	int i, j, k, n=0;
872eac58b9emaste	struct evutil_weakrand_state seed = { 12346789U };
873eac58b9emaste
874eac58b9emaste	memset(buf2, 0, sizeof(buf2));
875eac58b9emaste	memset(counts, 0, sizeof(counts));
876eac58b9emaste
877eac58b9emaste	for (k=0;k<32;++k) {
878eac58b9emaste		/* Try a few different start and end points; try to catch
879eac58b9emaste		 * the various misaligned cases of arc4random_buf */
880eac58b9emaste		int startpoint = evutil_weakrand_(&seed) % 4;
881eac58b9emaste		int endpoint = 32 - (evutil_weakrand_(&seed) % 4);
882eac58b9emaste
883eac58b9emaste		memset(buf2, 0, sizeof(buf2));
884eac58b9emaste
885eac58b9emaste		/* Do 6 runs over buf1, or-ing the result into buf2 each
886eac58b9emaste		 * time, to make sure we're setting each byte that we mean
887eac58b9emaste		 * to set. */
888eac58b9emaste		for (i=0;i<8;++i) {
889eac58b9emaste			memset(buf1, 0, sizeof(buf1));
890eac58b9emaste			evutil_secure_rng_get_bytes(buf1 + startpoint,
891eac58b9emaste			    endpoint-startpoint);
892eac58b9emaste			n += endpoint - startpoint;
893eac58b9emaste			for (j=0; j<32; ++j) {
894eac58b9emaste				if (j >= startpoint && j < endpoint) {
895eac58b9emaste					buf2[j] |= buf1[j];
896eac58b9emaste					++counts[(unsigned char)buf1[j]];
897eac58b9emaste				} else {
898eac58b9emaste					tt_assert(buf1[j] == 0);
899eac58b9emaste					tt_int_op(buf1[j], ==, 0);
900eac58b9emaste
901eac58b9emaste				}
902eac58b9emaste			}
903eac58b9emaste		}
904eac58b9emaste
905eac58b9emaste		/* This will give a false positive with P=(256**8)==(2**64)
906eac58b9emaste		 * for each character. */
907eac58b9emaste		for (j=startpoint;j<endpoint;++j) {
908eac58b9emaste			tt_int_op(buf2[j], !=, 0);
909eac58b9emaste		}
910eac58b9emaste	}
911eac58b9emaste
912eac58b9emaste	evutil_weakrand_seed_(&seed, 0);
913eac58b9emaste	for (i = 0; i < 10000; ++i) {
914eac58b9emaste		ev_int32_t r = evutil_weakrand_range_(&seed, 9999);
915eac58b9emaste		tt_int_op(0, <=, r);
916eac58b9emaste		tt_int_op(r, <, 9999);
917eac58b9emaste	}
918eac58b9emaste
919eac58b9emaste	/* for (i=0;i<256;++i) { printf("%3d %2d\n", i, counts[i]); } */
920eac58b9emasteend:
921eac58b9emaste	;
922eac58b9emaste}
923eac58b9emaste
924eac58b9emastestatic void
925eac58b9emastetest_evutil_getaddrinfo(void *arg)
926eac58b9emaste{
927eac58b9emaste	struct evutil_addrinfo *ai = NULL, *a;
928eac58b9emaste	struct evutil_addrinfo hints;
929eac58b9emaste	int r;
930eac58b9emaste
931eac58b9emaste	/* Try using it as a pton. */
932eac58b9emaste	memset(&hints, 0, sizeof(hints));
933eac58b9emaste	hints.ai_family = PF_UNSPEC;
934eac58b9emaste	hints.ai_socktype = SOCK_STREAM;
935eac58b9emaste	r = evutil_getaddrinfo("1.2.3.4", "8080", &hints, &ai);
936eac58b9emaste	tt_int_op(r, ==, 0);
937eac58b9emaste	tt_assert(ai);
938eac58b9emaste	tt_ptr_op(ai->ai_next, ==, NULL); /* no ambiguity */
939eac58b9emaste	test_ai_eq(ai, "1.2.3.4:8080", SOCK_STREAM, IPPROTO_TCP);
940eac58b9emaste	evutil_freeaddrinfo(ai);
941eac58b9emaste	ai = NULL;
942eac58b9emaste
943eac58b9emaste	memset(&hints, 0, sizeof(hints));
944eac58b9emaste	hints.ai_family = PF_UNSPEC;
945eac58b9emaste	hints.ai_protocol = IPPROTO_UDP;
946eac58b9emaste	r = evutil_getaddrinfo("1001:b0b::f00f", "4321", &hints, &ai);
947eac58b9emaste	tt_int_op(r, ==, 0);
948eac58b9emaste	tt_assert(ai);
949eac58b9emaste	tt_ptr_op(ai->ai_next, ==, NULL); /* no ambiguity */
950eac58b9emaste	test_ai_eq(ai, "[1001:b0b::f00f]:4321", SOCK_DGRAM, IPPROTO_UDP);
951eac58b9emaste	evutil_freeaddrinfo(ai);
952eac58b9emaste	ai = NULL;
953eac58b9emaste
954eac58b9emaste	/* Try out the behavior of nodename=NULL */
955eac58b9emaste	memset(&hints, 0, sizeof(hints));
956eac58b9emaste	hints.ai_family = PF_INET;
957eac58b9emaste	hints.ai_protocol = IPPROTO_TCP;
958eac58b9emaste	hints.ai_flags = EVUTIL_AI_PASSIVE; /* as if for bind */
959eac58b9emaste	r = evutil_getaddrinfo(NULL, "9999", &hints, &ai);
960eac58b9emaste	tt_int_op(r,==,0);
961eac58b9emaste	tt_assert(ai);
962eac58b9emaste	tt_ptr_op(ai->ai_next, ==, NULL);
963eac58b9emaste	test_ai_eq(ai, "0.0.0.0:9999", SOCK_STREAM, IPPROTO_TCP);
964eac58b9emaste	evutil_freeaddrinfo(ai);
965eac58b9emaste	ai = NULL;
966eac58b9emaste	hints.ai_flags = 0; /* as if for connect */
967eac58b9emaste	r = evutil_getaddrinfo(NULL, "9998", &hints, &ai);
968eac58b9emaste	tt_assert(ai);
969eac58b9emaste	tt_int_op(r,==,0);
970eac58b9emaste	test_ai_eq(ai, "127.0.0.1:9998", SOCK_STREAM, IPPROTO_TCP);
971eac58b9emaste	tt_ptr_op(ai->ai_next, ==, NULL);
972eac58b9emaste	evutil_freeaddrinfo(ai);
973eac58b9emaste	ai = NULL;
974eac58b9emaste
975eac58b9emaste	hints.ai_flags = 0; /* as if for connect */
976eac58b9emaste	hints.ai_family = PF_INET6;
977eac58b9emaste	r = evutil_getaddrinfo(NULL, "9997", &hints, &ai);
978eac58b9emaste	tt_assert(ai);
979eac58b9emaste	tt_int_op(r,==,0);
980eac58b9emaste	tt_ptr_op(ai->ai_next, ==, NULL);
981eac58b9emaste	test_ai_eq(ai, "[::1]:9997", SOCK_STREAM, IPPROTO_TCP);
982eac58b9emaste	evutil_freeaddrinfo(ai);
983eac58b9emaste	ai = NULL;
984eac58b9emaste
985eac58b9emaste	hints.ai_flags = EVUTIL_AI_PASSIVE; /* as if for bind. */
986eac58b9emaste	hints.ai_family = PF_INET6;
987eac58b9emaste	r = evutil_getaddrinfo(NULL, "9996", &hints, &ai);
988eac58b9emaste	tt_assert(ai);
989eac58b9emaste	tt_int_op(r,==,0);
990eac58b9emaste	tt_ptr_op(ai->ai_next, ==, NULL);
991eac58b9emaste	test_ai_eq(ai, "[::]:9996", SOCK_STREAM, IPPROTO_TCP);
992eac58b9emaste	evutil_freeaddrinfo(ai);
993eac58b9emaste	ai = NULL;
994eac58b9emaste
995eac58b9emaste	/* Now try an unspec one. We should get a v6 and a v4. */
996eac58b9emaste	hints.ai_family = PF_UNSPEC;
997eac58b9emaste	r = evutil_getaddrinfo(NULL, "9996", &hints, &ai);
998eac58b9emaste	tt_assert(ai);
999eac58b9emaste	tt_int_op(r,==,0);
1000eac58b9emaste	a = ai_find_by_family(ai, PF_INET6);
1001eac58b9emaste	tt_assert(a);
1002eac58b9emaste	test_ai_eq(a, "[::]:9996", SOCK_STREAM, IPPROTO_TCP);
1003eac58b9emaste	a = ai_find_by_family(ai, PF_INET);
1004eac58b9emaste	tt_assert(a);
1005eac58b9emaste	test_ai_eq(a, "0.0.0.0:9996", SOCK_STREAM, IPPROTO_TCP);
1006eac58b9emaste	evutil_freeaddrinfo(ai);
1007eac58b9emaste	ai = NULL;
1008eac58b9emaste
1009eac58b9emaste	/* Try out AI_NUMERICHOST: successful case.  Also try
1010eac58b9emaste	 * multiprotocol. */
1011eac58b9emaste	memset(&hints, 0, sizeof(hints));
1012eac58b9emaste	hints.ai_family = PF_UNSPEC;
1013eac58b9emaste	hints.ai_flags = EVUTIL_AI_NUMERICHOST;
1014eac58b9emaste	r = evutil_getaddrinfo("1.2.3.4", NULL, &hints, &ai);
1015eac58b9emaste	tt_int_op(r, ==, 0);
1016eac58b9emaste	a = ai_find_by_protocol(ai, IPPROTO_TCP);
1017eac58b9emaste	tt_assert(a);
1018eac58b9emaste	test_ai_eq(a, "1.2.3.4", SOCK_STREAM, IPPROTO_TCP);
1019eac58b9emaste	a = ai_find_by_protocol(ai, IPPROTO_UDP);
1020eac58b9emaste	tt_assert(a);
1021eac58b9emaste	test_ai_eq(a, "1.2.3.4", SOCK_DGRAM, IPPROTO_UDP);
1022eac58b9emaste	evutil_freeaddrinfo(ai);
1023eac58b9emaste	ai = NULL;
1024eac58b9emaste
1025eac58b9emaste	/* Try the failing case of AI_NUMERICHOST */
1026eac58b9emaste	memset(&hints, 0, sizeof(hints));
1027eac58b9emaste	hints.ai_family = PF_UNSPEC;
1028eac58b9emaste	hints.ai_flags = EVUTIL_AI_NUMERICHOST;
1029eac58b9emaste	r = evutil_getaddrinfo("www.google.com", "80", &hints, &ai);
1030eac58b9emaste	tt_int_op(r, ==, EVUTIL_EAI_NONAME);
1031eac58b9emaste	tt_ptr_op(ai, ==, NULL);
1032eac58b9emaste
1033eac58b9emaste	/* Try symbolic service names wit AI_NUMERICSERV */
1034eac58b9emaste	memset(&hints, 0, sizeof(hints));
1035eac58b9emaste	hints.ai_family = PF_UNSPEC;
1036eac58b9emaste	hints.ai_socktype = SOCK_STREAM;
1037eac58b9emaste	hints.ai_flags = EVUTIL_AI_NUMERICSERV;
1038eac58b9emaste	r = evutil_getaddrinfo("1.2.3.4", "http", &hints, &ai);
1039eac58b9emaste	tt_int_op(r,==,EVUTIL_EAI_NONAME);
1040eac58b9emaste
1041eac58b9emaste	/* Try symbolic service names */
1042eac58b9emaste	memset(&hints, 0, sizeof(hints));
1043eac58b9emaste	hints.ai_family = PF_UNSPEC;
1044eac58b9emaste	hints.ai_socktype = SOCK_STREAM;
1045eac58b9emaste	r = evutil_getaddrinfo("1.2.3.4", "http", &hints, &ai);
1046eac58b9emaste	if (r!=0) {
1047eac58b9emaste		TT_DECLARE("SKIP", ("Symbolic service names seem broken."));
1048eac58b9emaste	} else {
1049eac58b9emaste		tt_assert(ai);
1050eac58b9emaste		test_ai_eq(ai, "1.2.3.4:80", SOCK_STREAM, IPPROTO_TCP);
1051eac58b9emaste		evutil_freeaddrinfo(ai);
1052eac58b9emaste		ai = NULL;
1053eac58b9emaste	}
1054eac58b9emaste
1055eac58b9emasteend:
1056eac58b9emaste	if (ai)
1057eac58b9emaste		evutil_freeaddrinfo(ai);
1058eac58b9emaste}
1059eac58b9emaste
1060eac58b9emastestatic void
1061eac58b9emastetest_evutil_getaddrinfo_live(void *arg)
1062eac58b9emaste{
1063eac58b9emaste	struct evutil_addrinfo *ai = NULL;
1064eac58b9emaste	struct evutil_addrinfo hints;
1065eac58b9emaste
1066eac58b9emaste	struct sockaddr_in6 *sin6;
1067eac58b9emaste	struct sockaddr_in *sin;
1068eac58b9emaste	char buf[128];
1069eac58b9emaste	const char *cp;
1070eac58b9emaste	int r;
1071eac58b9emaste
1072eac58b9emaste	/* Now do some actual lookups. */
1073eac58b9emaste	memset(&hints, 0, sizeof(hints));
1074eac58b9emaste	hints.ai_family = PF_INET;
1075eac58b9emaste	hints.ai_protocol = IPPROTO_TCP;
1076eac58b9emaste	hints.ai_socktype = SOCK_STREAM;
1077eac58b9emaste	r = evutil_getaddrinfo("www.google.com", "80", &hints, &ai);
1078eac58b9emaste	if (r != 0) {
1079eac58b9emaste		TT_DECLARE("SKIP", ("Couldn't resolve www.google.com"));
1080eac58b9emaste	} else {
1081eac58b9emaste		tt_assert(ai);
1082eac58b9emaste		tt_int_op(ai->ai_family, ==, PF_INET);
1083eac58b9emaste		tt_int_op(ai->ai_protocol, ==, IPPROTO_TCP);
1084eac58b9emaste		tt_int_op(ai->ai_socktype, ==, SOCK_STREAM);
1085eac58b9emaste		tt_int_op(ai->ai_addrlen, ==, sizeof(struct sockaddr_in));
1086eac58b9emaste		sin = (struct sockaddr_in*)ai->ai_addr;
1087eac58b9emaste		tt_int_op(sin->sin_family, ==, AF_INET);
1088eac58b9emaste		tt_int_op(sin->sin_port, ==, htons(80));
1089eac58b9emaste		tt_int_op(sin->sin_addr.s_addr, !=, 0xffffffff);
1090eac58b9emaste
1091eac58b9emaste		cp = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf));
1092eac58b9emaste		TT_BLATHER(("www.google.com resolved to %s",
1093eac58b9emaste			cp?cp:"<unwriteable>"));
1094eac58b9emaste		evutil_freeaddrinfo(ai);
1095eac58b9emaste		ai = NULL;
1096eac58b9emaste	}
1097eac58b9emaste
1098eac58b9emaste	hints.ai_family = PF_INET6;
1099eac58b9emaste	r = evutil_getaddrinfo("ipv6.google.com", "80", &hints, &ai);
1100eac58b9emaste	if (r != 0) {
1101eac58b9emaste		TT_BLATHER(("Couldn't do an ipv6 lookup for ipv6.google.com"));
1102eac58b9emaste	} else {
1103eac58b9emaste		tt_assert(ai);
1104eac58b9emaste		tt_int_op(ai->ai_family, ==, PF_INET6);
1105eac58b9emaste		tt_int_op(ai->ai_addrlen, ==, sizeof(struct sockaddr_in6));
1106eac58b9emaste		sin6 = (struct sockaddr_in6*)ai->ai_addr;
1107eac58b9emaste		tt_int_op(sin6->sin6_port, ==, htons(80));
1108eac58b9emaste
1109eac58b9emaste		cp = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf,
1110eac58b9emaste		    sizeof(buf));
1111eac58b9emaste		TT_BLATHER(("ipv6.google.com resolved to %s",
1112eac58b9emaste			cp?cp:"<unwriteable>"));
1113eac58b9emaste	}
1114eac58b9emaste
1115eac58b9emasteend:
1116eac58b9emaste	if (ai)
1117eac58b9emaste		evutil_freeaddrinfo(ai);
1118eac58b9emaste}
1119eac58b9emaste
1120eac58b9emaste#ifdef _WIN32
1121eac58b9emastestatic void
1122eac58b9emastetest_evutil_loadsyslib(void *arg)
1123eac58b9emaste{
1124eac58b9emaste	HMODULE h=NULL;
1125eac58b9emaste
1126eac58b9emaste	h = evutil_load_windows_system_library_(TEXT("kernel32.dll"));
1127eac58b9emaste	tt_assert(h);
1128eac58b9emaste
1129eac58b9emasteend:
1130eac58b9emaste	if (h)
1131eac58b9emaste		CloseHandle(h);
1132eac58b9emaste
1133eac58b9emaste}
1134eac58b9emaste#endif
1135eac58b9emaste
1136eac58b9emaste/** Test mm_malloc(). */
1137eac58b9emastestatic void
1138eac58b9emastetest_event_malloc(void *arg)
1139eac58b9emaste{
1140eac58b9emaste	void *p = NULL;
1141eac58b9emaste	(void)arg;
1142eac58b9emaste
1143eac58b9emaste	/* mm_malloc(0) should simply return NULL. */
1144eac58b9emaste#ifndef EVENT__DISABLE_MM_REPLACEMENT
1145eac58b9emaste	errno = 0;
1146eac58b9emaste	p = mm_malloc(0);
1147eac58b9emaste	tt_assert(p == NULL);
1148eac58b9emaste	tt_int_op(errno, ==, 0);
1149eac58b9emaste#endif
1150eac58b9emaste
1151eac58b9emaste	/* Trivial case. */
1152eac58b9emaste	errno = 0;
1153eac58b9emaste	p = mm_malloc(8);
1154eac58b9emaste	tt_assert(p != NULL);
1155eac58b9emaste	tt_int_op(errno, ==, 0);
1156eac58b9emaste	mm_free(p);
1157eac58b9emaste
1158eac58b9emaste end:
1159eac58b9emaste	errno = 0;
1160eac58b9emaste	return;
1161eac58b9emaste}
1162eac58b9emaste
1163eac58b9emastestatic void
1164eac58b9emastetest_event_calloc(void *arg)
1165eac58b9emaste{
1166eac58b9emaste	void *p = NULL;
1167eac58b9emaste	(void)arg;
1168eac58b9emaste
1169eac58b9emaste#ifndef EVENT__DISABLE_MM_REPLACEMENT
1170eac58b9emaste	/* mm_calloc() should simply return NULL
1171eac58b9emaste	 * if either argument is zero. */
1172eac58b9emaste	errno = 0;
1173eac58b9emaste	p = mm_calloc(0, 0);
1174eac58b9emaste	tt_assert(p == NULL);
1175eac58b9emaste	tt_int_op(errno, ==, 0);
1176eac58b9emaste	errno = 0;
1177eac58b9emaste	p = mm_calloc(0, 1);
1178eac58b9emaste	tt_assert(p == NULL);
1179eac58b9emaste	tt_int_op(errno, ==, 0);
1180eac58b9emaste	errno = 0;
1181eac58b9emaste	p = mm_calloc(1, 0);
1182eac58b9emaste	tt_assert(p == NULL);
1183eac58b9emaste	tt_int_op(errno, ==, 0);
1184eac58b9emaste#endif
1185eac58b9emaste
1186eac58b9emaste	/* Trivial case. */
1187eac58b9emaste	errno = 0;
1188eac58b9emaste	p = mm_calloc(8, 8);
1189eac58b9emaste	tt_assert(p != NULL);
1190eac58b9emaste	tt_int_op(errno, ==, 0);
1191eac58b9emaste	mm_free(p);
1192eac58b9emaste	p = NULL;
1193eac58b9emaste
1194eac58b9emaste	/* mm_calloc() should set errno = ENOMEM and return NULL
1195eac58b9emaste	 * in case of potential overflow. */
1196eac58b9emaste	errno = 0;
1197eac58b9emaste	p = mm_calloc(EV_SIZE_MAX/2, EV_SIZE_MAX/2 + 8);
1198eac58b9emaste	tt_assert(p == NULL);
1199eac58b9emaste	tt_int_op(errno, ==, ENOMEM);
1200eac58b9emaste
1201eac58b9emaste end:
1202eac58b9emaste	errno = 0;
1203eac58b9emaste	if (p)
1204eac58b9emaste		mm_free(p);
1205eac58b9emaste
1206eac58b9emaste	return;
1207eac58b9emaste}
1208eac58b9emaste
1209eac58b9emastestatic void
1210eac58b9emastetest_event_strdup(void *arg)
1211eac58b9emaste{
1212eac58b9emaste	void *p = NULL;
1213eac58b9emaste	(void)arg;
1214eac58b9emaste
1215eac58b9emaste#ifndef EVENT__DISABLE_MM_REPLACEMENT
1216eac58b9emaste	/* mm_strdup(NULL) should set errno = EINVAL and return NULL. */
1217eac58b9emaste	errno = 0;
1218eac58b9emaste	p = mm_strdup(NULL);
1219eac58b9emaste	tt_assert(p == NULL);
1220eac58b9emaste	tt_int_op(errno, ==, EINVAL);
1221eac58b9emaste#endif
1222eac58b9emaste
1223eac58b9emaste	/* Trivial cases. */
1224eac58b9emaste
1225eac58b9emaste	errno = 0;
1226eac58b9emaste	p = mm_strdup("");
1227eac58b9emaste	tt_assert(p != NULL);
1228eac58b9emaste	tt_int_op(errno, ==, 0);
1229eac58b9emaste	tt_str_op(p, ==, "");
1230eac58b9emaste	mm_free(p);
1231eac58b9emaste
1232eac58b9emaste	errno = 0;
1233eac58b9emaste	p = mm_strdup("foo");
1234eac58b9emaste	tt_assert(p != NULL);
1235eac58b9emaste	tt_int_op(errno, ==, 0);
1236eac58b9emaste	tt_str_op(p, ==, "foo");
1237eac58b9emaste	mm_free(p);
1238eac58b9emaste
1239eac58b9emaste	/* XXX
1240eac58b9emaste	 * mm_strdup(str) where str is a string of length EV_SIZE_MAX
1241eac58b9emaste	 * should set errno = ENOMEM and return NULL. */
1242eac58b9emaste
1243eac58b9emaste end:
1244eac58b9emaste	errno = 0;
1245eac58b9emaste	return;
1246eac58b9emaste}
1247eac58b9emaste
1248eac58b9emastestatic void
1249eac58b9emastetest_evutil_usleep(void *arg)
1250eac58b9emaste{
1251eac58b9emaste	struct timeval tv1, tv2, tv3, diff1, diff2;
1252eac58b9emaste	const struct timeval quarter_sec = {0, 250*1000};
1253eac58b9emaste	const struct timeval tenth_sec = {0, 100*1000};
1254eac58b9emaste	long usec1, usec2;
1255eac58b9emaste
1256eac58b9emaste	evutil_gettimeofday(&tv1, NULL);
1257eac58b9emaste	evutil_usleep_(&quarter_sec);
1258eac58b9emaste	evutil_gettimeofday(&tv2, NULL);
1259eac58b9emaste	evutil_usleep_(&tenth_sec);
1260eac58b9emaste	evutil_gettimeofday(&tv3, NULL);
1261eac58b9emaste
1262eac58b9emaste	evutil_timersub(&tv2, &tv1, &diff1);
1263eac58b9emaste	evutil_timersub(&tv3, &tv2, &diff2);
1264eac58b9emaste	usec1 = diff1.tv_sec * 1000000 + diff1.tv_usec;
1265eac58b9emaste	usec2 = diff2.tv_sec * 1000000 + diff2.tv_usec;
1266eac58b9emaste
1267eac58b9emaste	tt_int_op(usec1, >, 200000);
1268eac58b9emaste	tt_int_op(usec1, <, 300000);
1269eac58b9emaste	tt_int_op(usec2, >,  80000);
1270eac58b9emaste	tt_int_op(usec2, <, 120000);
1271eac58b9emaste
1272eac58b9emasteend:
1273eac58b9emaste	;
1274eac58b9emaste}
1275eac58b9emaste
1276eac58b9emastestatic void
1277eac58b9emastetest_evutil_monotonic_res(void *data_)
1278eac58b9emaste{
1279eac58b9emaste	/* Basic santity-test for monotonic timers.  What we'd really like
1280eac58b9emaste	 * to do is make sure that they can't go backwards even when the
1281eac58b9emaste	 * system clock goes backwards. But we haven't got a good way to
1282eac58b9emaste	 * move the system clock backwards.
1283eac58b9emaste	 */
1284eac58b9emaste	struct basic_test_data *data = data_;
1285eac58b9emaste	struct evutil_monotonic_timer timer;
1286eac58b9emaste	const int precise = strstr(data->setup_data, "precise") != NULL;
1287eac58b9emaste	const int fallback = strstr(data->setup_data, "fallback") != NULL;
1288eac58b9emaste	struct timeval tv[10], delay;
1289eac58b9emaste	int total_diff = 0;
1290eac58b9emaste
1291eac58b9emaste	int flags = 0, wantres, acceptdiff, i;
1292eac58b9emaste	if (precise)
1293eac58b9emaste		flags |= EV_MONOT_PRECISE;
1294eac58b9emaste	if (fallback)
1295eac58b9emaste		flags |= EV_MONOT_FALLBACK;
1296eac58b9emaste	if (precise || fallback) {
1297eac58b9emaste#ifdef _WIN32
1298eac58b9emaste		wantres = 10*1000;
1299eac58b9emaste		acceptdiff = 1000;
1300eac58b9emaste#else
1301eac58b9emaste		wantres = 1000;
1302eac58b9emaste		acceptdiff = 300;
1303eac58b9emaste#endif
1304eac58b9emaste	} else {
1305eac58b9emaste		wantres = 40*1000;
1306eac58b9emaste		acceptdiff = 20*1000;
1307eac58b9emaste	}
1308eac58b9emaste
1309eac58b9emaste	TT_BLATHER(("Precise = %d", precise));
1310eac58b9emaste	TT_BLATHER(("Fallback = %d", fallback));
1311eac58b9emaste
1312eac58b9emaste	/* First, make sure we match up with usleep. */
1313eac58b9emaste
1314eac58b9emaste	delay.tv_sec = 0;
1315eac58b9emaste	delay.tv_usec = wantres;
1316eac58b9emaste
1317eac58b9emaste	tt_int_op(evutil_configure_monotonic_time_(&timer, flags), ==, 0);
1318eac58b9emaste
1319eac58b9emaste	for (i = 0; i < 10; ++i) {
1320eac58b9emaste		evutil_gettime_monotonic_(&timer, &tv[i]);
1321eac58b9emaste		evutil_usleep_(&delay);
1322eac58b9emaste	}
1323eac58b9emaste
1324eac58b9emaste	for (i = 0; i < 9; ++i) {
1325eac58b9emaste		struct timeval diff;
1326eac58b9emaste		tt_assert(evutil_timercmp(&tv[i], &tv[i+1], <));
1327eac58b9emaste		evutil_timersub(&tv[i+1], &tv[i], &diff);
1328eac58b9emaste		tt_int_op(diff.tv_sec, ==, 0);
1329eac58b9emaste		total_diff += diff.tv_usec;
1330eac58b9emaste		TT_BLATHER(("Difference = %d", (int)diff.tv_usec));
1331eac58b9emaste	}
1332eac58b9emaste	tt_int_op(abs(total_diff/9 - wantres), <, acceptdiff);
1333eac58b9emaste
1334eac58b9emasteend:
1335eac58b9emaste	;
1336eac58b9emaste}
1337eac58b9emaste
1338eac58b9emastestatic void
1339eac58b9emastetest_evutil_monotonic_prc(void *data_)
1340eac58b9emaste{
1341eac58b9emaste	struct basic_test_data *data = data_;
1342eac58b9emaste	struct evutil_monotonic_timer timer;
1343eac58b9emaste	const int precise = strstr(data->setup_data, "precise") != NULL;
1344eac58b9emaste	const int fallback = strstr(data->setup_data, "fallback") != NULL;
1345eac58b9emaste	struct timeval tv[10];
1346eac58b9emaste	int total_diff = 0;
1347eac58b9emaste	int i, maxstep = 25*1000,flags=0;
1348eac58b9emaste	if (precise)
1349eac58b9emaste		maxstep = 500;
1350eac58b9emaste	if (precise)
1351eac58b9emaste		flags |= EV_MONOT_PRECISE;
1352eac58b9emaste	if (fallback)
1353eac58b9emaste		flags |= EV_MONOT_FALLBACK;
1354eac58b9emaste	tt_int_op(evutil_configure_monotonic_time_(&timer, flags), ==, 0);
1355eac58b9emaste
1356eac58b9emaste	/* find out what precision we actually see. */
1357eac58b9emaste
1358eac58b9emaste	evutil_gettime_monotonic_(&timer, &tv[0]);
1359eac58b9emaste	for (i = 1; i < 10; ++i) {
1360eac58b9emaste		do {
1361eac58b9emaste			evutil_gettime_monotonic_(&timer, &tv[i]);
1362eac58b9emaste		} while (evutil_timercmp(&tv[i-1], &tv[i], ==));
1363eac58b9emaste	}
1364eac58b9emaste
1365eac58b9emaste	total_diff = 0;
1366eac58b9emaste	for (i = 0; i < 9; ++i) {
1367eac58b9emaste		struct timeval diff;
1368eac58b9emaste		tt_assert(evutil_timercmp(&tv[i], &tv[i+1], <));
1369eac58b9emaste		evutil_timersub(&tv[i+1], &tv[i], &diff);
1370eac58b9emaste		tt_int_op(diff.tv_sec, ==, 0);
1371eac58b9emaste		total_diff += diff.tv_usec;
1372eac58b9emaste		TT_BLATHER(("Step difference = %d", (int)diff.tv_usec));
1373eac58b9emaste	}
1374eac58b9emaste	TT_BLATHER(("Average step difference = %d", total_diff / 9));
1375eac58b9emaste	tt_int_op(total_diff/9, <, maxstep);
1376eac58b9emaste
1377eac58b9emasteend:
1378eac58b9emaste	;
1379eac58b9emaste}
1380eac58b9emaste
1381eac58b9emastestatic void
1382eac58b9emastecreate_tm_from_unix_epoch(struct tm *cur_p, const time_t t)
1383eac58b9emaste{
1384eac58b9emaste#ifdef _WIN32
1385eac58b9emaste	struct tm *tmp = gmtime(&t);
1386eac58b9emaste	if (!tmp) {
1387eac58b9emaste		fprintf(stderr, "gmtime: %s (%i)", strerror(errno), (int)t);
1388eac58b9emaste		exit(1);
1389eac58b9emaste	}
1390eac58b9emaste	*cur_p = *tmp;
1391eac58b9emaste#else
1392eac58b9emaste	gmtime_r(&t, cur_p);
1393eac58b9emaste#endif
1394eac58b9emaste}
1395eac58b9emaste
1396eac58b9emastestatic struct date_rfc1123_case {
1397eac58b9emaste	time_t t;
1398eac58b9emaste	char date[30];
1399eac58b9emaste} date_rfc1123_cases[] = {
1400eac58b9emaste	{           0, "Thu, 01 Jan 1970 00:00:00 GMT"} /* UNIX time of zero */,
1401eac58b9emaste	{   946684799, "Fri, 31 Dec 1999 23:59:59 GMT"} /* the last moment of the 20th century */,
1402eac58b9emaste	{   946684800, "Sat, 01 Jan 2000 00:00:00 GMT"} /* the first moment of the 21st century */,
1403eac58b9emaste	{   981072000, "Fri, 02 Feb 2001 00:00:00 GMT"},
1404eac58b9emaste	{  1015113600, "Sun, 03 Mar 2002 00:00:00 GMT"},
1405eac58b9emaste	{  1049414400, "Fri, 04 Apr 2003 00:00:00 GMT"},
1406eac58b9emaste	{  1083715200, "Wed, 05 May 2004 00:00:00 GMT"},
1407eac58b9emaste	{  1118016000, "Mon, 06 Jun 2005 00:00:00 GMT"},
1408eac58b9emaste	{  1152230400, "Fri, 07 Jul 2006 00:00:00 GMT"},
1409eac58b9emaste	{  1186531200, "Wed, 08 Aug 2007 00:00:00 GMT"},
1410eac58b9emaste	{  1220918400, "Tue, 09 Sep 2008 00:00:00 GMT"},
1411eac58b9emaste	{  1255132800, "Sat, 10 Oct 2009 00:00:00 GMT"},
1412eac58b9emaste	{  1289433600, "Thu, 11 Nov 2010 00:00:00 GMT"},
1413eac58b9emaste	{  1323648000, "Mon, 12 Dec 2011 00:00:00 GMT"},
1414eac58b9emaste#ifndef _WIN32
1415eac58b9emaste	/** In win32 case we have max   "23:59:59 January 18, 2038, UTC" for time32 */
1416eac58b9emaste	{  4294967296, "Sun, 07 Feb 2106 06:28:16 GMT"} /* 2^32 */,
1417eac58b9emaste	/** In win32 case we have max "23:59:59, December 31, 3000, UTC" for time64 */
1418eac58b9emaste	{253402300799, "Fri, 31 Dec 9999 23:59:59 GMT"} /* long long future no one can imagine */,
1419eac58b9emaste	{  1456704000, "Mon, 29 Feb 2016 00:00:00 GMT"} /* leap year */,
1420eac58b9emaste#endif
1421eac58b9emaste	{  1435708800, "Wed, 01 Jul 2015 00:00:00 GMT"} /* leap second */,
1422eac58b9emaste	{  1481866376, "Fri, 16 Dec 2016 05:32:56 GMT"} /* the time this test case is generated */,
1423eac58b9emaste	{0, ""} /* end of test cases. */
1424eac58b9emaste};
1425eac58b9emaste
1426eac58b9emastestatic void
1427eac58b9emastetest_evutil_date_rfc1123(void *arg)
1428eac58b9emaste{
1429eac58b9emaste	struct tm query;
1430eac58b9emaste	char result[30];
1431eac58b9emaste	size_t i = 0;
1432eac58b9emaste
1433eac58b9emaste	/* Checks if too small buffers are safely accepted. */
1434eac58b9emaste	{
1435eac58b9emaste		create_tm_from_unix_epoch(&query, 0);
1436eac58b9emaste		evutil_date_rfc1123(result, 8, &query);
1437eac58b9emaste		tt_str_op(result, ==, "Thu, 01");
1438eac58b9emaste	}
1439eac58b9emaste
1440eac58b9emaste	/* Checks for testcases. */
1441eac58b9emaste	for (i = 0; ; i++) {
1442eac58b9emaste		struct date_rfc1123_case c = date_rfc1123_cases[i];
1443eac58b9emaste
1444eac58b9emaste		if (strlen(c.date) == 0)
1445eac58b9emaste			break;
1446eac58b9emaste
1447eac58b9emaste		create_tm_from_unix_epoch(&query, c.t);
1448eac58b9emaste		evutil_date_rfc1123(result, sizeof(result), &query);
1449eac58b9emaste		tt_str_op(result, ==, c.date);
1450eac58b9emaste	}
1451eac58b9emaste
1452eac58b9emasteend:
1453eac58b9emaste	;
1454eac58b9emaste}
1455eac58b9emaste
1456eac58b9emastestruct testcase_t util_testcases[] = {
1457eac58b9emaste	{ "ipv4_parse", regress_ipv4_parse, 0, NULL, NULL },
1458eac58b9emaste	{ "ipv6_parse", regress_ipv6_parse, 0, NULL, NULL },
1459eac58b9emaste	{ "sockaddr_port_parse", regress_sockaddr_port_parse, 0, NULL, NULL },
1460eac58b9emaste	{ "sockaddr_port_format", regress_sockaddr_port_format, 0, NULL, NULL },
1461eac58b9emaste	{ "sockaddr_predicates", test_evutil_sockaddr_predicates, 0,NULL,NULL },
1462eac58b9emaste	{ "evutil_snprintf", test_evutil_snprintf, 0, NULL, NULL },
1463eac58b9emaste	{ "evutil_strtoll", test_evutil_strtoll, 0, NULL, NULL },
1464eac58b9emaste	{ "evutil_casecmp", test_evutil_casecmp, 0, NULL, NULL },
1465eac58b9emaste	{ "evutil_rtrim", test_evutil_rtrim, 0, NULL, NULL },
1466eac58b9emaste	{ "strlcpy", test_evutil_strlcpy, 0, NULL, NULL },
1467eac58b9emaste	{ "log", test_evutil_log, TT_FORK, NULL, NULL },
1468eac58b9emaste	{ "upcast", test_evutil_upcast, 0, NULL, NULL },
1469eac58b9emaste	{ "integers", test_evutil_integers, 0, NULL, NULL },
1470eac58b9emaste	{ "rand", test_evutil_rand, TT_FORK, NULL, NULL },
1471eac58b9emaste	{ "getaddrinfo", test_evutil_getaddrinfo, TT_FORK, NULL, NULL },
1472eac58b9emaste	{ "getaddrinfo_live", test_evutil_getaddrinfo_live, TT_FORK|TT_OFF_BY_DEFAULT, NULL, NULL },
1473eac58b9emaste#ifdef _WIN32
1474eac58b9emaste	{ "loadsyslib", test_evutil_loadsyslib, TT_FORK, NULL, NULL },
1475eac58b9emaste#endif
1476eac58b9emaste	{ "mm_malloc", test_event_malloc, 0, NULL, NULL },
1477eac58b9emaste	{ "mm_calloc", test_event_calloc, 0, NULL, NULL },
1478eac58b9emaste	{ "mm_strdup", test_event_strdup, 0, NULL, NULL },
1479eac58b9emaste	{ "usleep", test_evutil_usleep, 0, NULL, NULL },
1480eac58b9emaste	{ "monotonic_res", test_evutil_monotonic_res, 0, &basic_setup, (void*)"" },
1481eac58b9emaste	{ "monotonic_res_precise", test_evutil_monotonic_res, TT_OFF_BY_DEFAULT, &basic_setup, (void*)"precise" },
1482eac58b9emaste	{ "monotonic_res_fallback", test_evutil_monotonic_res, TT_OFF_BY_DEFAULT, &basic_setup, (void*)"fallback" },
1483eac58b9emaste	{ "monotonic_prc", test_evutil_monotonic_prc, 0, &basic_setup, (void*)"" },
1484eac58b9emaste	{ "monotonic_prc_precise", test_evutil_monotonic_prc, 0, &basic_setup, (void*)"precise" },
1485eac58b9emaste	{ "monotonic_prc_fallback", test_evutil_monotonic_prc, 0, &basic_setup, (void*)"fallback" },
1486eac58b9emaste	{ "date_rfc1123", test_evutil_date_rfc1123, 0, NULL, NULL },
1487eac58b9emaste	END_OF_TESTCASES,
1488eac58b9emaste};
1489eac58b9emaste
1490