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