1 /*
2 * Copyright (c) 2003-2007 Niels Provos <provos@citi.umich.edu>
3 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27 #include "../util-internal.h"
28
29 #ifdef _WIN32
30 #include <winsock2.h>
31 #include <windows.h>
32 #include <ws2tcpip.h>
33 #endif
34
35 #include "event2/event-config.h"
36
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #ifdef EVENT__HAVE_SYS_TIME_H
40 #include <sys/time.h>
41 #endif
42 #include <sys/queue.h>
43 #ifndef _WIN32
44 #include <sys/socket.h>
45 #include <signal.h>
46 #include <netinet/in.h>
47 #include <arpa/inet.h>
48 #include <unistd.h>
49 #endif
50 #ifdef EVENT__HAVE_NETINET_IN6_H
51 #include <netinet/in6.h>
52 #endif
53 #ifdef HAVE_NETDB_H
54 #include <netdb.h>
55 #endif
56 #include <fcntl.h>
57 #include <stdlib.h>
58 #include <stdio.h>
59 #include <string.h>
60 #include <errno.h>
61
62 #include "event2/dns.h"
63 #include "event2/dns_compat.h"
64 #include "event2/dns_struct.h"
65 #include "event2/event.h"
66 #include "event2/event_compat.h"
67 #include "event2/event_struct.h"
68 #include "event2/util.h"
69 #include "event2/listener.h"
70 #include "event2/bufferevent.h"
71 #include "log-internal.h"
72 #include "regress.h"
73 #include "regress_testutils.h"
74
75 static int dns_ok = 0;
76 static int dns_got_cancel = 0;
77 static int dns_err = 0;
78
79
80 static void
dns_gethostbyname_cb(int result,char type,int count,int ttl,void * addresses,void * arg)81 dns_gethostbyname_cb(int result, char type, int count, int ttl,
82 void *addresses, void *arg)
83 {
84 dns_ok = dns_err = 0;
85
86 if (result == DNS_ERR_TIMEOUT) {
87 printf("[Timed out] ");
88 dns_err = result;
89 goto out;
90 }
91
92 if (result != DNS_ERR_NONE) {
93 printf("[Error code %d] ", result);
94 goto out;
95 }
96
97 TT_BLATHER(("type: %d, count: %d, ttl: %d: ", type, count, ttl));
98
99 switch (type) {
100 case DNS_IPv6_AAAA: {
101 #if defined(EVENT__HAVE_STRUCT_IN6_ADDR) && defined(EVENT__HAVE_INET_NTOP) && defined(INET6_ADDRSTRLEN)
102 struct in6_addr *in6_addrs = addresses;
103 char buf[INET6_ADDRSTRLEN+1];
104 int i;
105 /* a resolution that's not valid does not help */
106 if (ttl < 0)
107 goto out;
108 for (i = 0; i < count; ++i) {
109 const char *b = evutil_inet_ntop(AF_INET6, &in6_addrs[i], buf,sizeof(buf));
110 if (b)
111 TT_BLATHER(("%s ", b));
112 else
113 TT_BLATHER(("%s ", strerror(errno)));
114 }
115 #endif
116 break;
117 }
118 case DNS_IPv4_A: {
119 struct in_addr *in_addrs = addresses;
120 int i;
121 /* a resolution that's not valid does not help */
122 if (ttl < 0)
123 goto out;
124 for (i = 0; i < count; ++i)
125 TT_BLATHER(("%s ", inet_ntoa(in_addrs[i])));
126 break;
127 }
128 case DNS_PTR:
129 /* may get at most one PTR */
130 if (count != 1)
131 goto out;
132
133 TT_BLATHER(("%s ", *(char **)addresses));
134 break;
135 default:
136 goto out;
137 }
138
139 dns_ok = type;
140
141 out:
142 if (arg == NULL)
143 event_loopexit(NULL);
144 else
145 event_base_loopexit((struct event_base *)arg, NULL);
146 }
147
148 static void
dns_gethostbyname(void)149 dns_gethostbyname(void)
150 {
151 dns_ok = 0;
152 evdns_resolve_ipv4("www.monkey.org", 0, dns_gethostbyname_cb, NULL);
153 event_dispatch();
154
155 tt_int_op(dns_ok, ==, DNS_IPv4_A);
156 test_ok = dns_ok;
157 end:
158 ;
159 }
160
161 static void
dns_gethostbyname6(void)162 dns_gethostbyname6(void)
163 {
164 dns_ok = 0;
165 evdns_resolve_ipv6("www.ietf.org", 0, dns_gethostbyname_cb, NULL);
166 event_dispatch();
167
168 if (!dns_ok && dns_err == DNS_ERR_TIMEOUT) {
169 tt_skip();
170 }
171
172 tt_int_op(dns_ok, ==, DNS_IPv6_AAAA);
173 test_ok = 1;
174 end:
175 ;
176 }
177
178 static void
dns_gethostbyaddr(void)179 dns_gethostbyaddr(void)
180 {
181 struct in_addr in;
182 in.s_addr = htonl(0x7f000001ul); /* 127.0.0.1 */
183 dns_ok = 0;
184 evdns_resolve_reverse(&in, 0, dns_gethostbyname_cb, NULL);
185 event_dispatch();
186
187 tt_int_op(dns_ok, ==, DNS_PTR);
188 test_ok = dns_ok;
189 end:
190 ;
191 }
192
193 static void
dns_resolve_reverse(void * ptr)194 dns_resolve_reverse(void *ptr)
195 {
196 struct in_addr in;
197 struct event_base *base = event_base_new();
198 struct evdns_base *dns = evdns_base_new(base, 1/* init name servers */);
199 struct evdns_request *req = NULL;
200
201 tt_assert(base);
202 tt_assert(dns);
203 in.s_addr = htonl(0x7f000001ul); /* 127.0.0.1 */
204 dns_ok = 0;
205
206 req = evdns_base_resolve_reverse(
207 dns, &in, 0, dns_gethostbyname_cb, base);
208 tt_assert(req);
209
210 event_base_dispatch(base);
211
212 tt_int_op(dns_ok, ==, DNS_PTR);
213
214 end:
215 if (dns)
216 evdns_base_free(dns, 0);
217 if (base)
218 event_base_free(base);
219 }
220
221 static int n_server_responses = 0;
222
223 static void
dns_server_request_cb(struct evdns_server_request * req,void * data)224 dns_server_request_cb(struct evdns_server_request *req, void *data)
225 {
226 int i, r;
227 const char TEST_ARPA[] = "11.11.168.192.in-addr.arpa";
228 const char TEST_IN6[] =
229 "f.e.f.e." "0.0.0.0." "0.0.0.0." "1.1.1.1."
230 "a.a.a.a." "0.0.0.0." "0.0.0.0." "0.f.f.f.ip6.arpa";
231
232 for (i = 0; i < req->nquestions; ++i) {
233 const int qtype = req->questions[i]->type;
234 const int qclass = req->questions[i]->dns_question_class;
235 const char *qname = req->questions[i]->name;
236
237 struct in_addr ans;
238 ans.s_addr = htonl(0xc0a80b0bUL); /* 192.168.11.11 */
239 if (qtype == EVDNS_TYPE_A &&
240 qclass == EVDNS_CLASS_INET &&
241 !evutil_ascii_strcasecmp(qname, "zz.example.com")) {
242 r = evdns_server_request_add_a_reply(req, qname,
243 1, &ans.s_addr, 12345);
244 if (r<0)
245 dns_ok = 0;
246 } else if (qtype == EVDNS_TYPE_AAAA &&
247 qclass == EVDNS_CLASS_INET &&
248 !evutil_ascii_strcasecmp(qname, "zz.example.com")) {
249 char addr6[17] = "abcdefghijklmnop";
250 r = evdns_server_request_add_aaaa_reply(req,
251 qname, 1, addr6, 123);
252 if (r<0)
253 dns_ok = 0;
254 } else if (qtype == EVDNS_TYPE_PTR &&
255 qclass == EVDNS_CLASS_INET &&
256 !evutil_ascii_strcasecmp(qname, TEST_ARPA)) {
257 r = evdns_server_request_add_ptr_reply(req, NULL,
258 qname, "ZZ.EXAMPLE.COM", 54321);
259 if (r<0)
260 dns_ok = 0;
261 } else if (qtype == EVDNS_TYPE_PTR &&
262 qclass == EVDNS_CLASS_INET &&
263 !evutil_ascii_strcasecmp(qname, TEST_IN6)){
264 r = evdns_server_request_add_ptr_reply(req, NULL,
265 qname,
266 "ZZ-INET6.EXAMPLE.COM", 54322);
267 if (r<0)
268 dns_ok = 0;
269 } else if (qtype == EVDNS_TYPE_A &&
270 qclass == EVDNS_CLASS_INET &&
271 !evutil_ascii_strcasecmp(qname, "drop.example.com")) {
272 if (evdns_server_request_drop(req)<0)
273 dns_ok = 0;
274 return;
275 } else {
276 printf("Unexpected question %d %d \"%s\" ",
277 qtype, qclass, qname);
278 dns_ok = 0;
279 }
280 }
281 r = evdns_server_request_respond(req, 0);
282 if (r<0) {
283 printf("Couldn't send reply. ");
284 dns_ok = 0;
285 }
286 }
287
288 static void
dns_server_gethostbyname_cb(int result,char type,int count,int ttl,void * addresses,void * arg)289 dns_server_gethostbyname_cb(int result, char type, int count, int ttl,
290 void *addresses, void *arg)
291 {
292 if (result == DNS_ERR_CANCEL) {
293 if (arg != (void*)(char*)90909) {
294 printf("Unexpected cancelation");
295 dns_ok = 0;
296 }
297 dns_got_cancel = 1;
298 goto out;
299 }
300 if (result != DNS_ERR_NONE) {
301 printf("Unexpected result %d. ", result);
302 dns_ok = 0;
303 goto out;
304 }
305 if (count != 1) {
306 printf("Unexpected answer count %d. ", count);
307 dns_ok = 0;
308 goto out;
309 }
310 switch (type) {
311 case DNS_IPv4_A: {
312 struct in_addr *in_addrs = addresses;
313 if (in_addrs[0].s_addr != htonl(0xc0a80b0bUL) || ttl != 12345) {
314 printf("Bad IPv4 response \"%s\" %d. ",
315 inet_ntoa(in_addrs[0]), ttl);
316 dns_ok = 0;
317 goto out;
318 }
319 break;
320 }
321 case DNS_IPv6_AAAA: {
322 #if defined (EVENT__HAVE_STRUCT_IN6_ADDR) && defined(EVENT__HAVE_INET_NTOP) && defined(INET6_ADDRSTRLEN)
323 struct in6_addr *in6_addrs = addresses;
324 char buf[INET6_ADDRSTRLEN+1];
325 if (memcmp(&in6_addrs[0].s6_addr, "abcdefghijklmnop", 16)
326 || ttl != 123) {
327 const char *b = evutil_inet_ntop(AF_INET6, &in6_addrs[0],buf,sizeof(buf));
328 printf("Bad IPv6 response \"%s\" %d. ", b, ttl);
329 dns_ok = 0;
330 goto out;
331 }
332 #endif
333 break;
334 }
335 case DNS_PTR: {
336 char **addrs = addresses;
337 if (arg != (void*)6) {
338 if (strcmp(addrs[0], "ZZ.EXAMPLE.COM") ||
339 ttl != 54321) {
340 printf("Bad PTR response \"%s\" %d. ",
341 addrs[0], ttl);
342 dns_ok = 0;
343 goto out;
344 }
345 } else {
346 if (strcmp(addrs[0], "ZZ-INET6.EXAMPLE.COM") ||
347 ttl != 54322) {
348 printf("Bad ipv6 PTR response \"%s\" %d. ",
349 addrs[0], ttl);
350 dns_ok = 0;
351 goto out;
352 }
353 }
354 break;
355 }
356 default:
357 printf("Bad response type %d. ", type);
358 dns_ok = 0;
359 }
360 out:
361 if (++n_server_responses == 3) {
362 event_loopexit(NULL);
363 }
364 }
365
366 static void
dns_server(void)367 dns_server(void)
368 {
369 evutil_socket_t sock=-1;
370 struct sockaddr_in my_addr;
371 struct sockaddr_storage ss;
372 ev_socklen_t slen;
373 struct evdns_server_port *port=NULL;
374 struct in_addr resolve_addr;
375 struct in6_addr resolve_addr6;
376 struct evdns_base *base=NULL;
377 struct evdns_request *req=NULL;
378
379 dns_ok = 1;
380
381 base = evdns_base_new(NULL, 0);
382
383 /* Now configure a nameserver port. */
384 sock = socket(AF_INET, SOCK_DGRAM, 0);
385 if (sock<0) {
386 tt_abort_perror("socket");
387 }
388
389 evutil_make_socket_nonblocking(sock);
390
391 memset(&my_addr, 0, sizeof(my_addr));
392 my_addr.sin_family = AF_INET;
393 my_addr.sin_port = 0; /* kernel picks */
394 my_addr.sin_addr.s_addr = htonl(0x7f000001UL);
395 if (bind(sock, (struct sockaddr*)&my_addr, sizeof(my_addr)) < 0) {
396 tt_abort_perror("bind");
397 }
398 slen = sizeof(ss);
399 if (getsockname(sock, (struct sockaddr*)&ss, &slen) < 0) {
400 tt_abort_perror("getsockname");
401 }
402
403 port = evdns_add_server_port(sock, 0, dns_server_request_cb, NULL);
404
405 /* Add ourself as the only nameserver, and make sure we really are
406 * the only nameserver. */
407 evdns_base_nameserver_sockaddr_add(base, (struct sockaddr*)&ss, slen, 0);
408 tt_int_op(evdns_base_count_nameservers(base), ==, 1);
409 {
410 struct sockaddr_storage ss2;
411 int slen2;
412
413 memset(&ss2, 0, sizeof(ss2));
414
415 slen2 = evdns_base_get_nameserver_addr(base, 0, (struct sockaddr *)&ss2, 3);
416 tt_int_op(slen2, ==, slen);
417 tt_int_op(ss2.ss_family, ==, 0);
418 slen2 = evdns_base_get_nameserver_addr(base, 0, (struct sockaddr *)&ss2, sizeof(ss2));
419 tt_int_op(slen2, ==, slen);
420 tt_mem_op(&ss2, ==, &ss, slen);
421
422 slen2 = evdns_base_get_nameserver_addr(base, 1, (struct sockaddr *)&ss2, sizeof(ss2));
423 tt_int_op(-1, ==, slen2);
424 }
425
426 /* Send some queries. */
427 evdns_base_resolve_ipv4(base, "zz.example.com", DNS_QUERY_NO_SEARCH,
428 dns_server_gethostbyname_cb, NULL);
429 evdns_base_resolve_ipv6(base, "zz.example.com", DNS_QUERY_NO_SEARCH,
430 dns_server_gethostbyname_cb, NULL);
431 resolve_addr.s_addr = htonl(0xc0a80b0bUL); /* 192.168.11.11 */
432 evdns_base_resolve_reverse(base, &resolve_addr, 0,
433 dns_server_gethostbyname_cb, NULL);
434 memcpy(resolve_addr6.s6_addr,
435 "\xff\xf0\x00\x00\x00\x00\xaa\xaa"
436 "\x11\x11\x00\x00\x00\x00\xef\xef", 16);
437 evdns_base_resolve_reverse_ipv6(base, &resolve_addr6, 0,
438 dns_server_gethostbyname_cb, (void*)6);
439
440 req = evdns_base_resolve_ipv4(base,
441 "drop.example.com", DNS_QUERY_NO_SEARCH,
442 dns_server_gethostbyname_cb, (void*)(char*)90909);
443
444 evdns_cancel_request(base, req);
445
446 event_dispatch();
447
448 tt_assert(dns_got_cancel);
449 test_ok = dns_ok;
450
451 end:
452 if (port)
453 evdns_close_server_port(port);
454 if (sock >= 0)
455 evutil_closesocket(sock);
456 if (base)
457 evdns_base_free(base, 0);
458 }
459
460 static int n_replies_left;
461 static struct event_base *exit_base;
462 static struct evdns_server_port *exit_port;
463
464 struct generic_dns_callback_result {
465 int result;
466 char type;
467 int count;
468 int ttl;
469 size_t addrs_len;
470 void *addrs;
471 char addrs_buf[256];
472 };
473
474 static void
generic_dns_callback(int result,char type,int count,int ttl,void * addresses,void * arg)475 generic_dns_callback(int result, char type, int count, int ttl, void *addresses,
476 void *arg)
477 {
478 size_t len;
479 struct generic_dns_callback_result *res = arg;
480 res->result = result;
481 res->type = type;
482 res->count = count;
483 res->ttl = ttl;
484
485 if (type == DNS_IPv4_A)
486 len = count * 4;
487 else if (type == DNS_IPv6_AAAA)
488 len = count * 16;
489 else if (type == DNS_PTR)
490 len = strlen(addresses)+1;
491 else {
492 res->addrs_len = len = 0;
493 res->addrs = NULL;
494 }
495 if (len) {
496 res->addrs_len = len;
497 if (len > 256)
498 len = 256;
499 memcpy(res->addrs_buf, addresses, len);
500 res->addrs = res->addrs_buf;
501 }
502
503 --n_replies_left;
504 if (n_replies_left == 0) {
505 if (exit_port) {
506 evdns_close_server_port(exit_port);
507 exit_port = NULL;
508 } else
509 event_base_loopexit(exit_base, NULL);
510 }
511 }
512
513 static struct regress_dns_server_table search_table[] = {
514 { "host.a.example.com", "err", "3", 0 },
515 { "host.b.example.com", "err", "3", 0 },
516 { "host.c.example.com", "A", "11.22.33.44", 0 },
517 { "host2.a.example.com", "err", "3", 0 },
518 { "host2.b.example.com", "A", "200.100.0.100", 0 },
519 { "host2.c.example.com", "err", "3", 0 },
520 { "hostn.a.example.com", "errsoa", "0", 0 },
521 { "hostn.b.example.com", "errsoa", "3", 0 },
522 { "hostn.c.example.com", "err", "0", 0 },
523
524 { "host", "err", "3", 0 },
525 { "host2", "err", "3", 0 },
526 { "*", "err", "3", 0 },
527 { NULL, NULL, NULL, 0 }
528 };
529
530 static void
dns_search_test(void * arg)531 dns_search_test(void *arg)
532 {
533 struct basic_test_data *data = arg;
534 struct event_base *base = data->base;
535 struct evdns_base *dns = NULL;
536 ev_uint16_t portnum = 0;
537 char buf[64];
538
539 struct generic_dns_callback_result r[8];
540
541 tt_assert(regress_dnsserver(base, &portnum, search_table));
542 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
543
544 dns = evdns_base_new(base, 0);
545 tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
546
547 evdns_base_search_add(dns, "a.example.com");
548 evdns_base_search_add(dns, "b.example.com");
549 evdns_base_search_add(dns, "c.example.com");
550
551 n_replies_left = sizeof(r)/sizeof(r[0]);
552 exit_base = base;
553
554 evdns_base_resolve_ipv4(dns, "host", 0, generic_dns_callback, &r[0]);
555 evdns_base_resolve_ipv4(dns, "host2", 0, generic_dns_callback, &r[1]);
556 evdns_base_resolve_ipv4(dns, "host", DNS_NO_SEARCH, generic_dns_callback, &r[2]);
557 evdns_base_resolve_ipv4(dns, "host2", DNS_NO_SEARCH, generic_dns_callback, &r[3]);
558 evdns_base_resolve_ipv4(dns, "host3", 0, generic_dns_callback, &r[4]);
559 evdns_base_resolve_ipv4(dns, "hostn.a.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[5]);
560 evdns_base_resolve_ipv4(dns, "hostn.b.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[6]);
561 evdns_base_resolve_ipv4(dns, "hostn.c.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[7]);
562
563 event_base_dispatch(base);
564
565 tt_int_op(r[0].type, ==, DNS_IPv4_A);
566 tt_int_op(r[0].count, ==, 1);
567 tt_int_op(((ev_uint32_t*)r[0].addrs)[0], ==, htonl(0x0b16212c));
568 tt_int_op(r[1].type, ==, DNS_IPv4_A);
569 tt_int_op(r[1].count, ==, 1);
570 tt_int_op(((ev_uint32_t*)r[1].addrs)[0], ==, htonl(0xc8640064));
571 tt_int_op(r[2].result, ==, DNS_ERR_NOTEXIST);
572 tt_int_op(r[3].result, ==, DNS_ERR_NOTEXIST);
573 tt_int_op(r[4].result, ==, DNS_ERR_NOTEXIST);
574 tt_int_op(r[5].result, ==, DNS_ERR_NODATA);
575 tt_int_op(r[5].ttl, ==, 42);
576 tt_int_op(r[6].result, ==, DNS_ERR_NOTEXIST);
577 tt_int_op(r[6].ttl, ==, 42);
578 tt_int_op(r[7].result, ==, DNS_ERR_NODATA);
579 tt_int_op(r[7].ttl, ==, 0);
580
581 end:
582 if (dns)
583 evdns_base_free(dns, 0);
584
585 regress_clean_dnsserver();
586 }
587
588 static int request_count = 0;
589 static struct evdns_request *current_req = NULL;
590
591 static void
search_cancel_server_cb(struct evdns_server_request * req,void * data)592 search_cancel_server_cb(struct evdns_server_request *req, void *data)
593 {
594 const char *question;
595
596 if (req->nquestions != 1)
597 TT_DIE(("Only handling one question at a time; got %d",
598 req->nquestions));
599
600 question = req->questions[0]->name;
601
602 TT_BLATHER(("got question, %s", question));
603
604 tt_assert(request_count > 0);
605 tt_assert(!evdns_server_request_respond(req, 3));
606
607 if (!--request_count)
608 evdns_cancel_request(NULL, current_req);
609
610 end:
611 ;
612 }
613
614 static void
dns_search_cancel_test(void * arg)615 dns_search_cancel_test(void *arg)
616 {
617 struct basic_test_data *data = arg;
618 struct event_base *base = data->base;
619 struct evdns_base *dns = NULL;
620 struct evdns_server_port *port = NULL;
621 ev_uint16_t portnum = 0;
622 struct generic_dns_callback_result r1;
623 char buf[64];
624
625 port = regress_get_dnsserver(base, &portnum, NULL,
626 search_cancel_server_cb, NULL);
627 tt_assert(port);
628 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
629
630 dns = evdns_base_new(base, 0);
631 tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
632
633 evdns_base_search_add(dns, "a.example.com");
634 evdns_base_search_add(dns, "b.example.com");
635 evdns_base_search_add(dns, "c.example.com");
636 evdns_base_search_add(dns, "d.example.com");
637
638 exit_base = base;
639 request_count = 3;
640 n_replies_left = 1;
641
642 current_req = evdns_base_resolve_ipv4(dns, "host", 0,
643 generic_dns_callback, &r1);
644 event_base_dispatch(base);
645
646 tt_int_op(r1.result, ==, DNS_ERR_CANCEL);
647
648 end:
649 if (port)
650 evdns_close_server_port(port);
651 if (dns)
652 evdns_base_free(dns, 0);
653 }
654
655 static void
fail_server_cb(struct evdns_server_request * req,void * data)656 fail_server_cb(struct evdns_server_request *req, void *data)
657 {
658 const char *question;
659 int *count = data;
660 struct in_addr in;
661
662 /* Drop the first N requests that we get. */
663 if (*count > 0) {
664 --*count;
665 tt_want(! evdns_server_request_drop(req));
666 return;
667 }
668
669 if (req->nquestions != 1)
670 TT_DIE(("Only handling one question at a time; got %d",
671 req->nquestions));
672
673 question = req->questions[0]->name;
674
675 if (!evutil_ascii_strcasecmp(question, "google.com")) {
676 /* Detect a probe, and get out of the loop. */
677 event_base_loopexit(exit_base, NULL);
678 }
679
680 tt_assert(evutil_inet_pton(AF_INET, "16.32.64.128", &in));
681 evdns_server_request_add_a_reply(req, question, 1, &in.s_addr,
682 100);
683 tt_assert(! evdns_server_request_respond(req, 0))
684 return;
685 end:
686 tt_want(! evdns_server_request_drop(req));
687 }
688
689 static void
dns_retry_test_impl(void * arg,int flags)690 dns_retry_test_impl(void *arg, int flags)
691 {
692 struct basic_test_data *data = arg;
693 struct event_base *base = data->base;
694 struct evdns_server_port *port = NULL;
695 struct evdns_base *dns = NULL;
696 int drop_count = 2;
697 ev_uint16_t portnum = 0;
698 char buf[64];
699
700 struct generic_dns_callback_result r1;
701
702 port = regress_get_dnsserver(base, &portnum, NULL,
703 fail_server_cb, &drop_count);
704 tt_assert(port);
705 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
706
707 dns = evdns_base_new(base, flags);
708 tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
709 tt_assert(! evdns_base_set_option(dns, "timeout", "0.2"));
710 tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "10"));
711 tt_assert(! evdns_base_set_option(dns, "initial-probe-timeout", "0.1"));
712
713 evdns_base_resolve_ipv4(dns, "host.example.com", 0,
714 generic_dns_callback, &r1);
715
716 n_replies_left = 1;
717 exit_base = base;
718
719 event_base_dispatch(base);
720
721 tt_int_op(drop_count, ==, 0);
722
723 tt_int_op(r1.type, ==, DNS_IPv4_A);
724 tt_int_op(r1.count, ==, 1);
725 tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x10204080));
726
727 /* Now try again, but this time have the server get treated as
728 * failed, so we can send it a test probe. */
729 drop_count = 4;
730 tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2"));
731 tt_assert(! evdns_base_set_option(dns, "attempts:", "3"));
732 memset(&r1, 0, sizeof(r1));
733
734 evdns_base_resolve_ipv4(dns, "host.example.com", 0,
735 generic_dns_callback, &r1);
736
737 n_replies_left = 2;
738
739 /* This will run until it answers the "google.com" probe request. */
740 event_base_dispatch(base);
741
742 /* We'll treat the server as failed here. */
743 tt_int_op(r1.result, ==, DNS_ERR_TIMEOUT);
744
745 /* It should work this time. */
746 tt_int_op(drop_count, ==, 0);
747 evdns_base_resolve_ipv4(dns, "host.example.com", 0,
748 generic_dns_callback, &r1);
749
750 event_base_dispatch(base);
751 tt_int_op(r1.result, ==, DNS_ERR_NONE);
752 tt_int_op(r1.type, ==, DNS_IPv4_A);
753 tt_int_op(r1.count, ==, 1);
754 tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x10204080));
755
756 end:
757 if (dns)
758 evdns_base_free(dns, 0);
759 if (port)
760 evdns_close_server_port(port);
761 }
762 static void
dns_retry_test(void * arg)763 dns_retry_test(void *arg)
764 {
765 dns_retry_test_impl(arg, 0);
766 }
767 static void
dns_retry_disable_when_inactive_test(void * arg)768 dns_retry_disable_when_inactive_test(void *arg)
769 {
770 dns_retry_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
771 }
772
773 static struct regress_dns_server_table internal_error_table[] = {
774 /* Error 4 (NOTIMPL) makes us reissue the request to another server
775 if we can.
776
777 XXXX we should reissue under a much wider set of circumstances!
778 */
779 { "foof.example.com", "err", "4", 0 },
780 { NULL, NULL, NULL, 0 }
781 };
782
783 static struct regress_dns_server_table reissue_table[] = {
784 { "foof.example.com", "A", "240.15.240.15", 0 },
785 { NULL, NULL, NULL, 0 }
786 };
787
788 static void
dns_reissue_test_impl(void * arg,int flags)789 dns_reissue_test_impl(void *arg, int flags)
790 {
791 struct basic_test_data *data = arg;
792 struct event_base *base = data->base;
793 struct evdns_server_port *port1 = NULL, *port2 = NULL;
794 struct evdns_base *dns = NULL;
795 struct generic_dns_callback_result r1;
796 ev_uint16_t portnum1 = 0, portnum2=0;
797 char buf1[64], buf2[64];
798
799 port1 = regress_get_dnsserver(base, &portnum1, NULL,
800 regress_dns_server_cb, internal_error_table);
801 tt_assert(port1);
802 port2 = regress_get_dnsserver(base, &portnum2, NULL,
803 regress_dns_server_cb, reissue_table);
804 tt_assert(port2);
805 evutil_snprintf(buf1, sizeof(buf1), "127.0.0.1:%d", (int)portnum1);
806 evutil_snprintf(buf2, sizeof(buf2), "127.0.0.1:%d", (int)portnum2);
807
808 dns = evdns_base_new(base, flags);
809 tt_assert(!evdns_base_nameserver_ip_add(dns, buf1));
810 tt_assert(! evdns_base_set_option(dns, "timeout:", "0.3"));
811 tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2"));
812 tt_assert(! evdns_base_set_option(dns, "attempts:", "5"));
813
814 memset(&r1, 0, sizeof(r1));
815 evdns_base_resolve_ipv4(dns, "foof.example.com", 0,
816 generic_dns_callback, &r1);
817
818 /* Add this after, so that we are sure to get a reissue. */
819 tt_assert(!evdns_base_nameserver_ip_add(dns, buf2));
820
821 n_replies_left = 1;
822 exit_base = base;
823
824 event_base_dispatch(base);
825 tt_int_op(r1.result, ==, DNS_ERR_NONE);
826 tt_int_op(r1.type, ==, DNS_IPv4_A);
827 tt_int_op(r1.count, ==, 1);
828 tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0xf00ff00f));
829
830 /* Make sure we dropped at least once. */
831 tt_int_op(internal_error_table[0].seen, >, 0);
832
833 end:
834 if (dns)
835 evdns_base_free(dns, 0);
836 if (port1)
837 evdns_close_server_port(port1);
838 if (port2)
839 evdns_close_server_port(port2);
840 }
841 static void
dns_reissue_test(void * arg)842 dns_reissue_test(void *arg)
843 {
844 dns_reissue_test_impl(arg, 0);
845 }
846 static void
dns_reissue_disable_when_inactive_test(void * arg)847 dns_reissue_disable_when_inactive_test(void *arg)
848 {
849 dns_reissue_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
850 }
851
852 #if 0
853 static void
854 dumb_bytes_fn(char *p, size_t n)
855 {
856 unsigned i;
857 /* This gets us 6 bits of entropy per transaction ID, which means we
858 * will have probably have collisions and need to pick again. */
859 for (i=0;i<n;++i)
860 p[i] = (char)(rand() & 7);
861 }
862 #endif
863
864 static void
dns_inflight_test_impl(void * arg,int flags)865 dns_inflight_test_impl(void *arg, int flags)
866 {
867 struct basic_test_data *data = arg;
868 struct event_base *base = data->base;
869 struct evdns_base *dns = NULL;
870 struct evdns_server_port *dns_port = NULL;
871 ev_uint16_t portnum = 0;
872 char buf[64];
873 int disable_when_inactive = flags & EVDNS_BASE_DISABLE_WHEN_INACTIVE;
874
875 struct generic_dns_callback_result r[20];
876 int i;
877
878 dns_port = regress_get_dnsserver(base, &portnum, NULL,
879 regress_dns_server_cb, reissue_table);
880 tt_assert(dns_port);
881 if (disable_when_inactive) {
882 exit_port = dns_port;
883 }
884
885 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
886
887 dns = evdns_base_new(base, flags);
888 tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
889 tt_assert(! evdns_base_set_option(dns, "max-inflight:", "3"));
890 tt_assert(! evdns_base_set_option(dns, "randomize-case:", "0"));
891
892 for (i=0;i<20;++i)
893 evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r[i]);
894
895 n_replies_left = 20;
896 exit_base = base;
897
898 event_base_dispatch(base);
899
900 for (i=0;i<20;++i) {
901 tt_int_op(r[i].type, ==, DNS_IPv4_A);
902 tt_int_op(r[i].count, ==, 1);
903 tt_int_op(((ev_uint32_t*)r[i].addrs)[0], ==, htonl(0xf00ff00f));
904 }
905
906 end:
907 if (dns)
908 evdns_base_free(dns, 0);
909 if (exit_port) {
910 evdns_close_server_port(exit_port);
911 exit_port = NULL;
912 } else if (! disable_when_inactive) {
913 evdns_close_server_port(dns_port);
914 }
915 }
916
917 static void
dns_inflight_test(void * arg)918 dns_inflight_test(void *arg)
919 {
920 dns_inflight_test_impl(arg, 0);
921 }
922
923 static void
dns_disable_when_inactive_test(void * arg)924 dns_disable_when_inactive_test(void *arg)
925 {
926 dns_inflight_test_impl(arg, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
927 }
928
929 static void
dns_disable_when_inactive_no_ns_test(void * arg)930 dns_disable_when_inactive_no_ns_test(void *arg)
931 {
932 struct basic_test_data *data = arg;
933 struct event_base *base = data->base, *inactive_base;
934 struct evdns_base *dns = NULL;
935 ev_uint16_t portnum = 0;
936 char buf[64];
937 struct generic_dns_callback_result r;
938
939 inactive_base = event_base_new();
940 tt_assert(inactive_base);
941
942 /** Create dns server with inactive base, to avoid replying to clients */
943 tt_assert(regress_dnsserver(inactive_base, &portnum, search_table));
944 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
945
946 dns = evdns_base_new(base, EVDNS_BASE_DISABLE_WHEN_INACTIVE);
947 tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
948 tt_assert(! evdns_base_set_option(dns, "timeout:", "0.1"));
949
950 evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r);
951 n_replies_left = 1;
952 exit_base = base;
953
954 event_base_dispatch(base);
955
956 tt_int_op(n_replies_left, ==, 0);
957
958 tt_int_op(r.result, ==, DNS_ERR_TIMEOUT);
959 tt_int_op(r.count, ==, 0);
960 tt_ptr_op(r.addrs, ==, NULL);
961
962 end:
963 if (dns)
964 evdns_base_free(dns, 0);
965 regress_clean_dnsserver();
966 if (inactive_base)
967 event_base_free(inactive_base);
968 }
969
970 /* === Test for bufferevent_socket_connect_hostname */
971
972 static int total_connected_or_failed = 0;
973 static int total_n_accepted = 0;
974 static struct event_base *be_connect_hostname_base = NULL;
975
976 /* Implements a DNS server for the connect_hostname test and the
977 * getaddrinfo_async test */
978 static void
be_getaddrinfo_server_cb(struct evdns_server_request * req,void * data)979 be_getaddrinfo_server_cb(struct evdns_server_request *req, void *data)
980 {
981 int i;
982 int *n_got_p=data;
983 int added_any=0;
984 ++*n_got_p;
985
986 for (i=0;i<req->nquestions;++i) {
987 const int qtype = req->questions[i]->type;
988 const int qclass = req->questions[i]->dns_question_class;
989 const char *qname = req->questions[i]->name;
990 struct in_addr ans;
991 struct in6_addr ans6;
992 memset(&ans6, 0, sizeof(ans6));
993
994 TT_BLATHER(("Got question about %s, type=%d", qname, qtype));
995
996 if (qtype == EVDNS_TYPE_A &&
997 qclass == EVDNS_CLASS_INET &&
998 !evutil_ascii_strcasecmp(qname, "nobodaddy.example.com")) {
999 ans.s_addr = htonl(0x7f000001);
1000 evdns_server_request_add_a_reply(req, qname,
1001 1, &ans.s_addr, 2000);
1002 added_any = 1;
1003 } else if (!evutil_ascii_strcasecmp(qname,
1004 "nosuchplace.example.com")) {
1005 /* ok, just say notfound. */
1006 } else if (!evutil_ascii_strcasecmp(qname,
1007 "both.example.com")) {
1008 if (qtype == EVDNS_TYPE_A) {
1009 ans.s_addr = htonl(0x50502020);
1010 evdns_server_request_add_a_reply(req, qname,
1011 1, &ans.s_addr, 2000);
1012 added_any = 1;
1013 } else if (qtype == EVDNS_TYPE_AAAA) {
1014 ans6.s6_addr[0] = 0x80;
1015 ans6.s6_addr[1] = 0xff;
1016 ans6.s6_addr[14] = 0xbb;
1017 ans6.s6_addr[15] = 0xbb;
1018 evdns_server_request_add_aaaa_reply(req, qname,
1019 1, &ans6.s6_addr, 2000);
1020 added_any = 1;
1021 }
1022 evdns_server_request_add_cname_reply(req, qname,
1023 "both-canonical.example.com", 1000);
1024 } else if (!evutil_ascii_strcasecmp(qname,
1025 "v4only.example.com") ||
1026 !evutil_ascii_strcasecmp(qname, "v4assert.example.com")) {
1027 if (qtype == EVDNS_TYPE_A) {
1028 ans.s_addr = htonl(0x12345678);
1029 evdns_server_request_add_a_reply(req, qname,
1030 1, &ans.s_addr, 2000);
1031 added_any = 1;
1032 } else if (!evutil_ascii_strcasecmp(qname,
1033 "v4assert.example.com")) {
1034 TT_FAIL(("Got an AAAA request for v4assert"));
1035 }
1036 } else if (!evutil_ascii_strcasecmp(qname,
1037 "v6only.example.com") ||
1038 !evutil_ascii_strcasecmp(qname, "v6assert.example.com")) {
1039 if (qtype == EVDNS_TYPE_AAAA) {
1040 ans6.s6_addr[0] = 0x0b;
1041 ans6.s6_addr[1] = 0x0b;
1042 ans6.s6_addr[14] = 0xf0;
1043 ans6.s6_addr[15] = 0x0d;
1044 evdns_server_request_add_aaaa_reply(req, qname,
1045 1, &ans6.s6_addr, 2000);
1046 added_any = 1;
1047 } else if (!evutil_ascii_strcasecmp(qname,
1048 "v6assert.example.com")) {
1049 TT_FAIL(("Got a A request for v6assert"));
1050 }
1051 } else if (!evutil_ascii_strcasecmp(qname,
1052 "v6timeout.example.com")) {
1053 if (qtype == EVDNS_TYPE_A) {
1054 ans.s_addr = htonl(0xabcdef01);
1055 evdns_server_request_add_a_reply(req, qname,
1056 1, &ans.s_addr, 2000);
1057 added_any = 1;
1058 } else if (qtype == EVDNS_TYPE_AAAA) {
1059 /* Let the v6 request time out.*/
1060 evdns_server_request_drop(req);
1061 return;
1062 }
1063 } else if (!evutil_ascii_strcasecmp(qname,
1064 "v4timeout.example.com")) {
1065 if (qtype == EVDNS_TYPE_AAAA) {
1066 ans6.s6_addr[0] = 0x0a;
1067 ans6.s6_addr[1] = 0x0a;
1068 ans6.s6_addr[14] = 0xff;
1069 ans6.s6_addr[15] = 0x01;
1070 evdns_server_request_add_aaaa_reply(req, qname,
1071 1, &ans6.s6_addr, 2000);
1072 added_any = 1;
1073 } else if (qtype == EVDNS_TYPE_A) {
1074 /* Let the v4 request time out.*/
1075 evdns_server_request_drop(req);
1076 return;
1077 }
1078 } else if (!evutil_ascii_strcasecmp(qname,
1079 "v6timeout-nonexist.example.com")) {
1080 if (qtype == EVDNS_TYPE_A) {
1081 /* Fall through, give an nexist. */
1082 } else if (qtype == EVDNS_TYPE_AAAA) {
1083 /* Let the v6 request time out.*/
1084 evdns_server_request_drop(req);
1085 return;
1086 }
1087 } else if (!evutil_ascii_strcasecmp(qname,
1088 "all-timeout.example.com")) {
1089 /* drop all requests */
1090 evdns_server_request_drop(req);
1091 return;
1092 } else {
1093 TT_GRIPE(("Got weird request for %s",qname));
1094 }
1095 }
1096 if (added_any) {
1097 TT_BLATHER(("answering"));
1098 evdns_server_request_respond(req, 0);
1099 } else {
1100 TT_BLATHER(("saying nexist."));
1101 evdns_server_request_respond(req, 3);
1102 }
1103 }
1104
1105 /* Implements a listener for connect_hostname test. */
1106 static void
nil_accept_cb(struct evconnlistener * l,evutil_socket_t fd,struct sockaddr * s,int socklen,void * arg)1107 nil_accept_cb(struct evconnlistener *l, evutil_socket_t fd, struct sockaddr *s,
1108 int socklen, void *arg)
1109 {
1110 int *p = arg;
1111 (*p)++;
1112 ++total_n_accepted;
1113 /* don't do anything with the socket; let it close when we exit() */
1114 if (total_n_accepted >= 3 && total_connected_or_failed >= 5)
1115 event_base_loopexit(be_connect_hostname_base,
1116 NULL);
1117 }
1118
1119 struct be_conn_hostname_result {
1120 int dnserr;
1121 int what;
1122 };
1123
1124 /* Bufferevent event callback for the connect_hostname test: remembers what
1125 * event we got. */
1126 static void
be_connect_hostname_event_cb(struct bufferevent * bev,short what,void * ctx)1127 be_connect_hostname_event_cb(struct bufferevent *bev, short what, void *ctx)
1128 {
1129 struct be_conn_hostname_result *got = ctx;
1130 if (!got->what) {
1131 TT_BLATHER(("Got a bufferevent event %d", what));
1132 got->what = what;
1133
1134 if ((what & BEV_EVENT_CONNECTED) || (what & BEV_EVENT_ERROR)) {
1135 int r;
1136 if ((r = bufferevent_socket_get_dns_error(bev))) {
1137 got->dnserr = r;
1138 TT_BLATHER(("DNS error %d: %s", r,
1139 evutil_gai_strerror(r)));
1140 } ++total_connected_or_failed;
1141 TT_BLATHER(("Got %d connections or errors.", total_connected_or_failed));
1142
1143 if (total_n_accepted >= 3 && total_connected_or_failed >= 5)
1144 event_base_loopexit(be_connect_hostname_base,
1145 NULL);
1146 }
1147 } else {
1148 TT_FAIL(("Two events on one bufferevent. %d,%d",
1149 got->what, (int)what));
1150 }
1151 }
1152
1153 static void
test_bufferevent_connect_hostname(void * arg)1154 test_bufferevent_connect_hostname(void *arg)
1155 {
1156 struct basic_test_data *data = arg;
1157 struct evconnlistener *listener = NULL;
1158 struct bufferevent *be1=NULL, *be2=NULL, *be3=NULL, *be4=NULL, *be5=NULL;
1159 struct be_conn_hostname_result be1_outcome={0,0}, be2_outcome={0,0},
1160 be3_outcome={0,0}, be4_outcome={0,0}, be5_outcome={0,0};
1161 int expect_err5;
1162 struct evdns_base *dns=NULL;
1163 struct evdns_server_port *port=NULL;
1164 struct sockaddr_in sin;
1165 int listener_port=-1;
1166 ev_uint16_t dns_port=0;
1167 int n_accept=0, n_dns=0;
1168 char buf[128];
1169
1170 be_connect_hostname_base = data->base;
1171
1172 /* Bind an address and figure out what port it's on. */
1173 memset(&sin, 0, sizeof(sin));
1174 sin.sin_family = AF_INET;
1175 sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
1176 sin.sin_port = 0;
1177 listener = evconnlistener_new_bind(data->base, nil_accept_cb,
1178 &n_accept,
1179 LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_EXEC,
1180 -1, (struct sockaddr *)&sin, sizeof(sin));
1181 tt_assert(listener);
1182 listener_port = regress_get_socket_port(
1183 evconnlistener_get_fd(listener));
1184
1185 port = regress_get_dnsserver(data->base, &dns_port, NULL,
1186 be_getaddrinfo_server_cb, &n_dns);
1187 tt_assert(port);
1188 tt_int_op(dns_port, >=, 0);
1189
1190 /* Start an evdns_base that uses the server as its resolver. */
1191 dns = evdns_base_new(data->base, 0);
1192 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)dns_port);
1193 evdns_base_nameserver_ip_add(dns, buf);
1194
1195 /* Now, finally, at long last, launch the bufferevents. One should do
1196 * a failing lookup IP, one should do a successful lookup by IP,
1197 * and one should do a successful lookup by hostname. */
1198 be1 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
1199 be2 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
1200 be3 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
1201 be4 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
1202 be5 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
1203
1204 bufferevent_setcb(be1, NULL, NULL, be_connect_hostname_event_cb,
1205 &be1_outcome);
1206 bufferevent_setcb(be2, NULL, NULL, be_connect_hostname_event_cb,
1207 &be2_outcome);
1208 bufferevent_setcb(be3, NULL, NULL, be_connect_hostname_event_cb,
1209 &be3_outcome);
1210 bufferevent_setcb(be4, NULL, NULL, be_connect_hostname_event_cb,
1211 &be4_outcome);
1212 bufferevent_setcb(be5, NULL, NULL, be_connect_hostname_event_cb,
1213 &be5_outcome);
1214
1215 /* Launch an async resolve that will fail. */
1216 tt_assert(!bufferevent_socket_connect_hostname(be1, dns, AF_INET,
1217 "nosuchplace.example.com", listener_port));
1218 /* Connect to the IP without resolving. */
1219 tt_assert(!bufferevent_socket_connect_hostname(be2, dns, AF_INET,
1220 "127.0.0.1", listener_port));
1221 /* Launch an async resolve that will succeed. */
1222 tt_assert(!bufferevent_socket_connect_hostname(be3, dns, AF_INET,
1223 "nobodaddy.example.com", listener_port));
1224 /* Use the blocking resolver. This one will fail if your resolver
1225 * can't resolve localhost to 127.0.0.1 */
1226 tt_assert(!bufferevent_socket_connect_hostname(be4, NULL, AF_INET,
1227 "localhost", listener_port));
1228 /* Use the blocking resolver with a nonexistent hostname. */
1229 tt_assert(!bufferevent_socket_connect_hostname(be5, NULL, AF_INET,
1230 "nonesuch.nowhere.example.com", 80));
1231 {
1232 /* The blocking resolver will use the system nameserver, which
1233 * might tell us anything. (Yes, some twits even pretend that
1234 * example.com is real.) Let's see what answer to expect. */
1235 struct evutil_addrinfo hints, *ai = NULL;
1236 memset(&hints, 0, sizeof(hints));
1237 hints.ai_family = AF_INET;
1238 hints.ai_socktype = SOCK_STREAM;
1239 hints.ai_protocol = IPPROTO_TCP;
1240 expect_err5 = evutil_getaddrinfo(
1241 "nonesuch.nowhere.example.com", "80", &hints, &ai);
1242 }
1243
1244 event_base_dispatch(data->base);
1245
1246 tt_int_op(be1_outcome.what, ==, BEV_EVENT_ERROR);
1247 tt_int_op(be1_outcome.dnserr, ==, EVUTIL_EAI_NONAME);
1248 tt_int_op(be2_outcome.what, ==, BEV_EVENT_CONNECTED);
1249 tt_int_op(be2_outcome.dnserr, ==, 0);
1250 tt_int_op(be3_outcome.what, ==, BEV_EVENT_CONNECTED);
1251 tt_int_op(be3_outcome.dnserr, ==, 0);
1252 tt_int_op(be4_outcome.what, ==, BEV_EVENT_CONNECTED);
1253 tt_int_op(be4_outcome.dnserr, ==, 0);
1254 if (expect_err5) {
1255 tt_int_op(be5_outcome.what, ==, BEV_EVENT_ERROR);
1256 tt_int_op(be5_outcome.dnserr, ==, expect_err5);
1257 }
1258
1259 tt_int_op(n_accept, ==, 3);
1260 tt_int_op(n_dns, ==, 2);
1261
1262 end:
1263 if (listener)
1264 evconnlistener_free(listener);
1265 if (port)
1266 evdns_close_server_port(port);
1267 if (dns)
1268 evdns_base_free(dns, 0);
1269 if (be1)
1270 bufferevent_free(be1);
1271 if (be2)
1272 bufferevent_free(be2);
1273 if (be3)
1274 bufferevent_free(be3);
1275 if (be4)
1276 bufferevent_free(be4);
1277 if (be5)
1278 bufferevent_free(be5);
1279 }
1280
1281
1282 struct gai_outcome {
1283 int err;
1284 struct evutil_addrinfo *ai;
1285 };
1286
1287 static int n_gai_results_pending = 0;
1288 static struct event_base *exit_base_on_no_pending_results = NULL;
1289
1290 static void
gai_cb(int err,struct evutil_addrinfo * res,void * ptr)1291 gai_cb(int err, struct evutil_addrinfo *res, void *ptr)
1292 {
1293 struct gai_outcome *go = ptr;
1294 go->err = err;
1295 go->ai = res;
1296 if (--n_gai_results_pending <= 0 && exit_base_on_no_pending_results)
1297 event_base_loopexit(exit_base_on_no_pending_results, NULL);
1298 if (n_gai_results_pending < 900)
1299 TT_BLATHER(("Got an answer; expecting %d more.",
1300 n_gai_results_pending));
1301 }
1302
1303 static void
cancel_gai_cb(evutil_socket_t fd,short what,void * ptr)1304 cancel_gai_cb(evutil_socket_t fd, short what, void *ptr)
1305 {
1306 struct evdns_getaddrinfo_request *r = ptr;
1307 evdns_getaddrinfo_cancel(r);
1308 }
1309
1310 static void
test_getaddrinfo_async(void * arg)1311 test_getaddrinfo_async(void *arg)
1312 {
1313 struct basic_test_data *data = arg;
1314 struct evutil_addrinfo hints, *a;
1315 struct gai_outcome local_outcome;
1316 struct gai_outcome a_out[12];
1317 int i;
1318 struct evdns_getaddrinfo_request *r;
1319 char buf[128];
1320 struct evdns_server_port *port = NULL;
1321 ev_uint16_t dns_port = 0;
1322 int n_dns_questions = 0;
1323 struct evdns_base *dns_base;
1324
1325 memset(&a_out, 0, sizeof(a_out));
1326 memset(&local_outcome, 0, sizeof(local_outcome));
1327
1328 dns_base = evdns_base_new(data->base, 0);
1329 tt_assert(dns_base);
1330
1331 /* for localhost */
1332 evdns_base_load_hosts(dns_base, NULL);
1333
1334 tt_assert(! evdns_base_set_option(dns_base, "timeout", "0.3"));
1335 tt_assert(! evdns_base_set_option(dns_base, "getaddrinfo-allow-skew", "0.2"));
1336
1337 n_gai_results_pending = 10000; /* don't think about exiting yet. */
1338
1339 /* 1. Try some cases that will never hit the asynchronous resolver. */
1340 /* 1a. Simple case with a symbolic service name */
1341 memset(&hints, 0, sizeof(hints));
1342 hints.ai_family = PF_UNSPEC;
1343 hints.ai_socktype = SOCK_STREAM;
1344 memset(&local_outcome, 0, sizeof(local_outcome));
1345 r = evdns_getaddrinfo(dns_base, "1.2.3.4", "http",
1346 &hints, gai_cb, &local_outcome);
1347 tt_assert(! r);
1348 if (!local_outcome.err) {
1349 tt_ptr_op(local_outcome.ai,!=,NULL);
1350 test_ai_eq(local_outcome.ai, "1.2.3.4:80", SOCK_STREAM, IPPROTO_TCP);
1351 evutil_freeaddrinfo(local_outcome.ai);
1352 local_outcome.ai = NULL;
1353 } else {
1354 TT_BLATHER(("Apparently we have no getservbyname."));
1355 }
1356
1357 /* 1b. EVUTIL_AI_NUMERICHOST is set */
1358 memset(&hints, 0, sizeof(hints));
1359 hints.ai_family = PF_UNSPEC;
1360 hints.ai_flags = EVUTIL_AI_NUMERICHOST;
1361 memset(&local_outcome, 0, sizeof(local_outcome));
1362 r = evdns_getaddrinfo(dns_base, "www.google.com", "80",
1363 &hints, gai_cb, &local_outcome);
1364 tt_ptr_op(r,==,NULL);
1365 tt_int_op(local_outcome.err,==,EVUTIL_EAI_NONAME);
1366 tt_ptr_op(local_outcome.ai,==,NULL);
1367
1368 /* 1c. We give a numeric address (ipv6) */
1369 memset(&hints, 0, sizeof(hints));
1370 memset(&local_outcome, 0, sizeof(local_outcome));
1371 hints.ai_family = PF_UNSPEC;
1372 hints.ai_protocol = IPPROTO_TCP;
1373 r = evdns_getaddrinfo(dns_base, "f::f", "8008",
1374 &hints, gai_cb, &local_outcome);
1375 tt_assert(!r);
1376 tt_int_op(local_outcome.err,==,0);
1377 tt_assert(local_outcome.ai);
1378 tt_ptr_op(local_outcome.ai->ai_next,==,NULL);
1379 test_ai_eq(local_outcome.ai, "[f::f]:8008", SOCK_STREAM, IPPROTO_TCP);
1380 evutil_freeaddrinfo(local_outcome.ai);
1381 local_outcome.ai = NULL;
1382
1383 /* 1d. We give a numeric address (ipv4) */
1384 memset(&hints, 0, sizeof(hints));
1385 memset(&local_outcome, 0, sizeof(local_outcome));
1386 hints.ai_family = PF_UNSPEC;
1387 r = evdns_getaddrinfo(dns_base, "5.6.7.8", NULL,
1388 &hints, gai_cb, &local_outcome);
1389 tt_assert(!r);
1390 tt_int_op(local_outcome.err,==,0);
1391 tt_assert(local_outcome.ai);
1392 a = ai_find_by_protocol(local_outcome.ai, IPPROTO_TCP);
1393 tt_assert(a);
1394 test_ai_eq(a, "5.6.7.8", SOCK_STREAM, IPPROTO_TCP);
1395 a = ai_find_by_protocol(local_outcome.ai, IPPROTO_UDP);
1396 tt_assert(a);
1397 test_ai_eq(a, "5.6.7.8", SOCK_DGRAM, IPPROTO_UDP);
1398 evutil_freeaddrinfo(local_outcome.ai);
1399 local_outcome.ai = NULL;
1400
1401 /* 1e. nodename is NULL (bind) */
1402 memset(&hints, 0, sizeof(hints));
1403 memset(&local_outcome, 0, sizeof(local_outcome));
1404 hints.ai_family = PF_UNSPEC;
1405 hints.ai_socktype = SOCK_DGRAM;
1406 hints.ai_flags = EVUTIL_AI_PASSIVE;
1407 r = evdns_getaddrinfo(dns_base, NULL, "9090",
1408 &hints, gai_cb, &local_outcome);
1409 tt_assert(!r);
1410 tt_int_op(local_outcome.err,==,0);
1411 tt_assert(local_outcome.ai);
1412 /* we should get a v4 address of 0.0.0.0... */
1413 a = ai_find_by_family(local_outcome.ai, PF_INET);
1414 tt_assert(a);
1415 test_ai_eq(a, "0.0.0.0:9090", SOCK_DGRAM, IPPROTO_UDP);
1416 /* ... and a v6 address of ::0 */
1417 a = ai_find_by_family(local_outcome.ai, PF_INET6);
1418 tt_assert(a);
1419 test_ai_eq(a, "[::]:9090", SOCK_DGRAM, IPPROTO_UDP);
1420 evutil_freeaddrinfo(local_outcome.ai);
1421 local_outcome.ai = NULL;
1422
1423 /* 1f. nodename is NULL (connect) */
1424 memset(&hints, 0, sizeof(hints));
1425 memset(&local_outcome, 0, sizeof(local_outcome));
1426 hints.ai_family = PF_UNSPEC;
1427 hints.ai_socktype = SOCK_STREAM;
1428 r = evdns_getaddrinfo(dns_base, NULL, "2",
1429 &hints, gai_cb, &local_outcome);
1430 tt_assert(!r);
1431 tt_int_op(local_outcome.err,==,0);
1432 tt_assert(local_outcome.ai);
1433 /* we should get a v4 address of 127.0.0.1 .... */
1434 a = ai_find_by_family(local_outcome.ai, PF_INET);
1435 tt_assert(a);
1436 test_ai_eq(a, "127.0.0.1:2", SOCK_STREAM, IPPROTO_TCP);
1437 /* ... and a v6 address of ::1 */
1438 a = ai_find_by_family(local_outcome.ai, PF_INET6);
1439 tt_assert(a);
1440 test_ai_eq(a, "[::1]:2", SOCK_STREAM, IPPROTO_TCP);
1441 evutil_freeaddrinfo(local_outcome.ai);
1442 local_outcome.ai = NULL;
1443
1444 /* 1g. We find localhost immediately. (pf_unspec) */
1445 memset(&hints, 0, sizeof(hints));
1446 memset(&local_outcome, 0, sizeof(local_outcome));
1447 hints.ai_family = PF_UNSPEC;
1448 hints.ai_socktype = SOCK_STREAM;
1449 r = evdns_getaddrinfo(dns_base, "LOCALHOST", "80",
1450 &hints, gai_cb, &local_outcome);
1451 tt_assert(!r);
1452 tt_int_op(local_outcome.err,==,0);
1453 tt_assert(local_outcome.ai);
1454 /* we should get a v4 address of 127.0.0.1 .... */
1455 a = ai_find_by_family(local_outcome.ai, PF_INET);
1456 tt_assert(a);
1457 test_ai_eq(a, "127.0.0.1:80", SOCK_STREAM, IPPROTO_TCP);
1458 /* ... and a v6 address of ::1 */
1459 a = ai_find_by_family(local_outcome.ai, PF_INET6);
1460 tt_assert(a);
1461 test_ai_eq(a, "[::1]:80", SOCK_STREAM, IPPROTO_TCP);
1462 evutil_freeaddrinfo(local_outcome.ai);
1463 local_outcome.ai = NULL;
1464
1465 /* 1g. We find localhost immediately. (pf_inet6) */
1466 memset(&hints, 0, sizeof(hints));
1467 memset(&local_outcome, 0, sizeof(local_outcome));
1468 hints.ai_family = PF_INET6;
1469 hints.ai_socktype = SOCK_STREAM;
1470 r = evdns_getaddrinfo(dns_base, "LOCALHOST", "9999",
1471 &hints, gai_cb, &local_outcome);
1472 tt_assert(! r);
1473 tt_int_op(local_outcome.err,==,0);
1474 tt_assert(local_outcome.ai);
1475 a = local_outcome.ai;
1476 test_ai_eq(a, "[::1]:9999", SOCK_STREAM, IPPROTO_TCP);
1477 tt_ptr_op(a->ai_next, ==, NULL);
1478 evutil_freeaddrinfo(local_outcome.ai);
1479 local_outcome.ai = NULL;
1480
1481 /* 2. Okay, now we can actually test the asynchronous resolver. */
1482 /* Start a dummy local dns server... */
1483 port = regress_get_dnsserver(data->base, &dns_port, NULL,
1484 be_getaddrinfo_server_cb, &n_dns_questions);
1485 tt_assert(port);
1486 tt_int_op(dns_port, >=, 0);
1487 /* ... and tell the evdns_base about it. */
1488 evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", dns_port);
1489 evdns_base_nameserver_ip_add(dns_base, buf);
1490
1491 memset(&hints, 0, sizeof(hints));
1492 hints.ai_family = PF_UNSPEC;
1493 hints.ai_socktype = SOCK_STREAM;
1494 hints.ai_flags = EVUTIL_AI_CANONNAME;
1495 /* 0: Request for both.example.com should return both addresses. */
1496 r = evdns_getaddrinfo(dns_base, "both.example.com", "8000",
1497 &hints, gai_cb, &a_out[0]);
1498 tt_assert(r);
1499
1500 /* 1: Request for v4only.example.com should return one address. */
1501 r = evdns_getaddrinfo(dns_base, "v4only.example.com", "8001",
1502 &hints, gai_cb, &a_out[1]);
1503 tt_assert(r);
1504
1505 /* 2: Request for v6only.example.com should return one address. */
1506 hints.ai_flags = 0;
1507 r = evdns_getaddrinfo(dns_base, "v6only.example.com", "8002",
1508 &hints, gai_cb, &a_out[2]);
1509 tt_assert(r);
1510
1511 /* 3: PF_INET request for v4assert.example.com should not generate a
1512 * v6 request. The server will fail the test if it does. */
1513 hints.ai_family = PF_INET;
1514 r = evdns_getaddrinfo(dns_base, "v4assert.example.com", "8003",
1515 &hints, gai_cb, &a_out[3]);
1516 tt_assert(r);
1517
1518 /* 4: PF_INET6 request for v6assert.example.com should not generate a
1519 * v4 request. The server will fail the test if it does. */
1520 hints.ai_family = PF_INET6;
1521 r = evdns_getaddrinfo(dns_base, "v6assert.example.com", "8004",
1522 &hints, gai_cb, &a_out[4]);
1523 tt_assert(r);
1524
1525 /* 5: PF_INET request for nosuchplace.example.com should give NEXIST. */
1526 hints.ai_family = PF_INET;
1527 r = evdns_getaddrinfo(dns_base, "nosuchplace.example.com", "8005",
1528 &hints, gai_cb, &a_out[5]);
1529 tt_assert(r);
1530
1531 /* 6: PF_UNSPEC request for nosuchplace.example.com should give NEXIST.
1532 */
1533 hints.ai_family = PF_UNSPEC;
1534 r = evdns_getaddrinfo(dns_base, "nosuchplace.example.com", "8006",
1535 &hints, gai_cb, &a_out[6]);
1536 tt_assert(r);
1537
1538 /* 7: PF_UNSPEC request for v6timeout.example.com should give an ipv4
1539 * address only. */
1540 hints.ai_family = PF_UNSPEC;
1541 r = evdns_getaddrinfo(dns_base, "v6timeout.example.com", "8007",
1542 &hints, gai_cb, &a_out[7]);
1543 tt_assert(r);
1544
1545 /* 8: PF_UNSPEC request for v6timeout-nonexist.example.com should give
1546 * a NEXIST */
1547 hints.ai_family = PF_UNSPEC;
1548 r = evdns_getaddrinfo(dns_base, "v6timeout-nonexist.example.com",
1549 "8008", &hints, gai_cb, &a_out[8]);
1550 tt_assert(r);
1551
1552 /* 9: AI_ADDRCONFIG should at least not crash. Can't test it more
1553 * without knowing what kind of internet we have. */
1554 hints.ai_flags |= EVUTIL_AI_ADDRCONFIG;
1555 r = evdns_getaddrinfo(dns_base, "both.example.com",
1556 "8009", &hints, gai_cb, &a_out[9]);
1557 tt_assert(r);
1558
1559 /* 10: PF_UNSPEC for v4timeout.example.com should give an ipv6 address
1560 * only. */
1561 hints.ai_family = PF_UNSPEC;
1562 hints.ai_flags = 0;
1563 r = evdns_getaddrinfo(dns_base, "v4timeout.example.com", "8010",
1564 &hints, gai_cb, &a_out[10]);
1565 tt_assert(r);
1566
1567 /* 11: timeout.example.com: cancel it after 100 msec. */
1568 r = evdns_getaddrinfo(dns_base, "all-timeout.example.com", "8011",
1569 &hints, gai_cb, &a_out[11]);
1570 tt_assert(r);
1571 {
1572 struct timeval tv;
1573 tv.tv_sec = 0;
1574 tv.tv_usec = 100*1000; /* 100 msec */
1575 event_base_once(data->base, -1, EV_TIMEOUT, cancel_gai_cb,
1576 r, &tv);
1577 }
1578
1579 /* XXXXX There are more tests we could do, including:
1580
1581 - A test to elicit NODATA.
1582
1583 */
1584
1585 n_gai_results_pending = 12;
1586 exit_base_on_no_pending_results = data->base;
1587
1588 event_base_dispatch(data->base);
1589
1590 /* 0: both.example.com */
1591 tt_int_op(a_out[0].err, ==, 0);
1592 tt_assert(a_out[0].ai);
1593 tt_assert(a_out[0].ai->ai_next);
1594 tt_assert(!a_out[0].ai->ai_next->ai_next);
1595 a = ai_find_by_family(a_out[0].ai, PF_INET);
1596 tt_assert(a);
1597 test_ai_eq(a, "80.80.32.32:8000", SOCK_STREAM, IPPROTO_TCP);
1598 a = ai_find_by_family(a_out[0].ai, PF_INET6);
1599 tt_assert(a);
1600 test_ai_eq(a, "[80ff::bbbb]:8000", SOCK_STREAM, IPPROTO_TCP);
1601 tt_assert(a_out[0].ai->ai_canonname);
1602 tt_str_op(a_out[0].ai->ai_canonname, ==, "both-canonical.example.com");
1603
1604 /* 1: v4only.example.com */
1605 tt_int_op(a_out[1].err, ==, 0);
1606 tt_assert(a_out[1].ai);
1607 tt_assert(! a_out[1].ai->ai_next);
1608 test_ai_eq(a_out[1].ai, "18.52.86.120:8001", SOCK_STREAM, IPPROTO_TCP);
1609 tt_assert(a_out[1].ai->ai_canonname == NULL);
1610
1611
1612 /* 2: v6only.example.com */
1613 tt_int_op(a_out[2].err, ==, 0);
1614 tt_assert(a_out[2].ai);
1615 tt_assert(! a_out[2].ai->ai_next);
1616 test_ai_eq(a_out[2].ai, "[b0b::f00d]:8002", SOCK_STREAM, IPPROTO_TCP);
1617
1618 /* 3: v4assert.example.com */
1619 tt_int_op(a_out[3].err, ==, 0);
1620 tt_assert(a_out[3].ai);
1621 tt_assert(! a_out[3].ai->ai_next);
1622 test_ai_eq(a_out[3].ai, "18.52.86.120:8003", SOCK_STREAM, IPPROTO_TCP);
1623
1624 /* 4: v6assert.example.com */
1625 tt_int_op(a_out[4].err, ==, 0);
1626 tt_assert(a_out[4].ai);
1627 tt_assert(! a_out[4].ai->ai_next);
1628 test_ai_eq(a_out[4].ai, "[b0b::f00d]:8004", SOCK_STREAM, IPPROTO_TCP);
1629
1630 /* 5: nosuchplace.example.com (inet) */
1631 tt_int_op(a_out[5].err, ==, EVUTIL_EAI_NONAME);
1632 tt_assert(! a_out[5].ai);
1633
1634 /* 6: nosuchplace.example.com (unspec) */
1635 tt_int_op(a_out[6].err, ==, EVUTIL_EAI_NONAME);
1636 tt_assert(! a_out[6].ai);
1637
1638 /* 7: v6timeout.example.com */
1639 tt_int_op(a_out[7].err, ==, 0);
1640 tt_assert(a_out[7].ai);
1641 tt_assert(! a_out[7].ai->ai_next);
1642 test_ai_eq(a_out[7].ai, "171.205.239.1:8007", SOCK_STREAM, IPPROTO_TCP);
1643
1644 /* 8: v6timeout-nonexist.example.com */
1645 tt_int_op(a_out[8].err, ==, EVUTIL_EAI_NONAME);
1646 tt_assert(! a_out[8].ai);
1647
1648 /* 9: both (ADDRCONFIG) */
1649 tt_int_op(a_out[9].err, ==, 0);
1650 tt_assert(a_out[9].ai);
1651 a = ai_find_by_family(a_out[9].ai, PF_INET);
1652 if (a)
1653 test_ai_eq(a, "80.80.32.32:8009", SOCK_STREAM, IPPROTO_TCP);
1654 else
1655 tt_assert(ai_find_by_family(a_out[9].ai, PF_INET6));
1656 a = ai_find_by_family(a_out[9].ai, PF_INET6);
1657 if (a)
1658 test_ai_eq(a, "[80ff::bbbb]:8009", SOCK_STREAM, IPPROTO_TCP);
1659 else
1660 tt_assert(ai_find_by_family(a_out[9].ai, PF_INET));
1661
1662 /* 10: v4timeout.example.com */
1663 tt_int_op(a_out[10].err, ==, 0);
1664 tt_assert(a_out[10].ai);
1665 tt_assert(! a_out[10].ai->ai_next);
1666 test_ai_eq(a_out[10].ai, "[a0a::ff01]:8010", SOCK_STREAM, IPPROTO_TCP);
1667
1668 /* 11: cancelled request. */
1669 tt_int_op(a_out[11].err, ==, EVUTIL_EAI_CANCEL);
1670 tt_assert(a_out[11].ai == NULL);
1671
1672 end:
1673 if (local_outcome.ai)
1674 evutil_freeaddrinfo(local_outcome.ai);
1675 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
1676 for (i=0;i<(int)ARRAY_SIZE(a_out);++i) {
1677 if (a_out[i].ai)
1678 evutil_freeaddrinfo(a_out[i].ai);
1679 }
1680 if (port)
1681 evdns_close_server_port(port);
1682 if (dns_base)
1683 evdns_base_free(dns_base, 0);
1684 }
1685
1686 struct gaic_request_status {
1687 int magic;
1688 struct event_base *base;
1689 struct evdns_base *dns_base;
1690 struct evdns_getaddrinfo_request *request;
1691 struct event cancel_event;
1692 int canceled;
1693 };
1694
1695 #define GAIC_MAGIC 0x1234abcd
1696
1697 static int pending = 0;
1698
1699 static void
gaic_cancel_request_cb(evutil_socket_t fd,short what,void * arg)1700 gaic_cancel_request_cb(evutil_socket_t fd, short what, void *arg)
1701 {
1702 struct gaic_request_status *status = arg;
1703
1704 tt_assert(status->magic == GAIC_MAGIC);
1705 status->canceled = 1;
1706 evdns_getaddrinfo_cancel(status->request);
1707 return;
1708 end:
1709 event_base_loopexit(status->base, NULL);
1710 }
1711
1712 static void
gaic_server_cb(struct evdns_server_request * req,void * arg)1713 gaic_server_cb(struct evdns_server_request *req, void *arg)
1714 {
1715 ev_uint32_t answer = 0x7f000001;
1716 tt_assert(req->nquestions);
1717 evdns_server_request_add_a_reply(req, req->questions[0]->name, 1,
1718 &answer, 100);
1719 evdns_server_request_respond(req, 0);
1720 return;
1721 end:
1722 evdns_server_request_respond(req, DNS_ERR_REFUSED);
1723 }
1724
1725
1726 static void
gaic_getaddrinfo_cb(int result,struct evutil_addrinfo * res,void * arg)1727 gaic_getaddrinfo_cb(int result, struct evutil_addrinfo *res, void *arg)
1728 {
1729 struct gaic_request_status *status = arg;
1730 struct event_base *base = status->base;
1731 tt_assert(status->magic == GAIC_MAGIC);
1732
1733 if (result == EVUTIL_EAI_CANCEL) {
1734 tt_assert(status->canceled);
1735 }
1736 event_del(&status->cancel_event);
1737
1738 memset(status, 0xf0, sizeof(*status));
1739 free(status);
1740
1741 end:
1742 if (--pending <= 0)
1743 event_base_loopexit(base, NULL);
1744 }
1745
1746 static void
gaic_launch(struct event_base * base,struct evdns_base * dns_base)1747 gaic_launch(struct event_base *base, struct evdns_base *dns_base)
1748 {
1749 struct gaic_request_status *status = calloc(1, sizeof(*status));
1750 tt_assert(status);
1751 struct timeval tv = { 0, 10000 };
1752 status->magic = GAIC_MAGIC;
1753 status->base = base;
1754 status->dns_base = dns_base;
1755 event_assign(&status->cancel_event, base, -1, 0, gaic_cancel_request_cb,
1756 status);
1757 status->request = evdns_getaddrinfo(dns_base,
1758 "foobar.bazquux.example.com", "80", NULL, gaic_getaddrinfo_cb,
1759 status);
1760 event_add(&status->cancel_event, &tv);
1761 ++pending;
1762 }
1763
1764 #ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
1765 /* FIXME: We should move this to regress_main.c if anything else needs it.*/
1766
1767 /* Trivial replacements for malloc/free/realloc to check for memory leaks.
1768 * Not threadsafe. */
1769 static int allocated_chunks = 0;
1770
1771 static void *
cnt_malloc(size_t sz)1772 cnt_malloc(size_t sz)
1773 {
1774 allocated_chunks += 1;
1775 return malloc(sz);
1776 }
1777
1778 static void *
cnt_realloc(void * old,size_t sz)1779 cnt_realloc(void *old, size_t sz)
1780 {
1781 if (!old)
1782 allocated_chunks += 1;
1783 if (!sz)
1784 allocated_chunks -= 1;
1785 return realloc(old, sz);
1786 }
1787
1788 static void
cnt_free(void * ptr)1789 cnt_free(void *ptr)
1790 {
1791 allocated_chunks -= 1;
1792 free(ptr);
1793 }
1794
1795 struct testleak_env_t {
1796 struct event_base *base;
1797 struct evdns_base *dns_base;
1798 struct evdns_request *req;
1799 struct generic_dns_callback_result r;
1800 };
1801
1802 static void *
testleak_setup(const struct testcase_t * testcase)1803 testleak_setup(const struct testcase_t *testcase)
1804 {
1805 struct testleak_env_t *env;
1806
1807 allocated_chunks = 0;
1808
1809 /* Reset allocation counter, to start allocations from the very beginning.
1810 * (this will avoid false-positive negative numbers for allocated_chunks)
1811 */
1812 libevent_global_shutdown();
1813
1814 event_set_mem_functions(cnt_malloc, cnt_realloc, cnt_free);
1815
1816 event_enable_debug_mode();
1817
1818 /* not mm_calloc: we don't want to mess with the count. */
1819 env = calloc(1, sizeof(struct testleak_env_t));
1820 env->base = event_base_new();
1821 env->dns_base = evdns_base_new(env->base, 0);
1822 env->req = evdns_base_resolve_ipv4(
1823 env->dns_base, "example.com", DNS_QUERY_NO_SEARCH,
1824 generic_dns_callback, &env->r);
1825 return env;
1826 }
1827
1828 static int
testleak_cleanup(const struct testcase_t * testcase,void * env_)1829 testleak_cleanup(const struct testcase_t *testcase, void *env_)
1830 {
1831 int ok = 0;
1832 struct testleak_env_t *env = env_;
1833 tt_assert(env);
1834 #ifdef EVENT__DISABLE_DEBUG_MODE
1835 tt_int_op(allocated_chunks, ==, 0);
1836 #else
1837 libevent_global_shutdown();
1838 tt_int_op(allocated_chunks, ==, 0);
1839 #endif
1840 ok = 1;
1841 end:
1842 if (env) {
1843 if (env->dns_base)
1844 evdns_base_free(env->dns_base, 0);
1845 if (env->base)
1846 event_base_free(env->base);
1847 free(env);
1848 }
1849 return ok;
1850 }
1851
1852 static struct testcase_setup_t testleak_funcs = {
1853 testleak_setup, testleak_cleanup
1854 };
1855
1856 static void
test_dbg_leak_cancel(void * env_)1857 test_dbg_leak_cancel(void *env_)
1858 {
1859 /* cancel, loop, free/dns, free/base */
1860 struct testleak_env_t *env = env_;
1861 int send_err_shutdown = 1;
1862 evdns_cancel_request(env->dns_base, env->req);
1863 env->req = 0;
1864
1865 /* `req` is freed in callback, that's why one loop is required. */
1866 event_base_loop(env->base, EVLOOP_NONBLOCK);
1867
1868 /* send_err_shutdown means nothing as soon as our request is
1869 * already canceled */
1870 evdns_base_free(env->dns_base, send_err_shutdown);
1871 env->dns_base = 0;
1872 event_base_free(env->base);
1873 env->base = 0;
1874 }
1875
1876 static void
dbg_leak_resume(void * env_,int cancel,int send_err_shutdown)1877 dbg_leak_resume(void *env_, int cancel, int send_err_shutdown)
1878 {
1879 /* cancel, loop, free/dns, free/base */
1880 struct testleak_env_t *env = env_;
1881 if (cancel) {
1882 evdns_cancel_request(env->dns_base, env->req);
1883 tt_assert(!evdns_base_resume(env->dns_base));
1884 } else {
1885 /* TODO: No nameservers, request can't be processed, must be errored */
1886 tt_assert(!evdns_base_resume(env->dns_base));
1887 }
1888
1889 /**
1890 * Because we don't cancel request,
1891 * and want our callback to recieve DNS_ERR_SHUTDOWN,
1892 * we use deferred callback, and there was
1893 * - one extra malloc(),
1894 * @see reply_schedule_callback()
1895 * - and one missing free
1896 * @see request_finished() (req->handle->pending_cb = 1)
1897 * than we don't need to count in testleak_cleanup()
1898 *
1899 * So just decrement allocated_chunks to 2,
1900 * like we already take care about it.
1901 */
1902 if (!cancel && send_err_shutdown) {
1903 allocated_chunks -= 2;
1904 }
1905
1906 event_base_loop(env->base, EVLOOP_NONBLOCK);
1907
1908 end:
1909 evdns_base_free(env->dns_base, send_err_shutdown);
1910 env->dns_base = 0;
1911
1912 event_base_free(env->base);
1913 env->base = 0;
1914 }
1915
1916 #define IMPL_DBG_LEAK_RESUME(name, cancel, send_err_shutdown) \
1917 static void \
1918 test_dbg_leak_##name##_(void *env_) \
1919 { \
1920 dbg_leak_resume(env_, cancel, send_err_shutdown); \
1921 }
1922 IMPL_DBG_LEAK_RESUME(resume, 0, 0)
1923 IMPL_DBG_LEAK_RESUME(cancel_and_resume, 1, 0)
1924 IMPL_DBG_LEAK_RESUME(resume_send_err, 0, 1)
1925 IMPL_DBG_LEAK_RESUME(cancel_and_resume_send_err, 1, 1)
1926
1927 static void
test_dbg_leak_shutdown(void * env_)1928 test_dbg_leak_shutdown(void *env_)
1929 {
1930 /* free/dns, loop, free/base */
1931 struct testleak_env_t *env = env_;
1932 int send_err_shutdown = 1;
1933
1934 /* `req` is freed both with `send_err_shutdown` and without it,
1935 * the only difference is `evdns_callback` call */
1936 env->req = 0;
1937
1938 evdns_base_free(env->dns_base, send_err_shutdown);
1939 env->dns_base = 0;
1940
1941 /* `req` is freed in callback, that's why one loop is required */
1942 event_base_loop(env->base, EVLOOP_NONBLOCK);
1943 event_base_free(env->base);
1944 env->base = 0;
1945 }
1946 #endif
1947
1948 static void
test_getaddrinfo_async_cancel_stress(void * ptr)1949 test_getaddrinfo_async_cancel_stress(void *ptr)
1950 {
1951 struct event_base *base;
1952 struct evdns_base *dns_base = NULL;
1953 struct evdns_server_port *server = NULL;
1954 evutil_socket_t fd = -1;
1955 struct sockaddr_in sin;
1956 struct sockaddr_storage ss;
1957 ev_socklen_t slen;
1958 int i;
1959
1960 base = event_base_new();
1961 dns_base = evdns_base_new(base, 0);
1962
1963 memset(&sin, 0, sizeof(sin));
1964 sin.sin_family = AF_INET;
1965 sin.sin_port = 0;
1966 sin.sin_addr.s_addr = htonl(0x7f000001);
1967 if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
1968 tt_abort_perror("socket");
1969 }
1970 evutil_make_socket_nonblocking(fd);
1971 if (bind(fd, (struct sockaddr*)&sin, sizeof(sin))<0) {
1972 tt_abort_perror("bind");
1973 }
1974 server = evdns_add_server_port_with_base(base, fd, 0, gaic_server_cb,
1975 base);
1976
1977 memset(&ss, 0, sizeof(ss));
1978 slen = sizeof(ss);
1979 if (getsockname(fd, (struct sockaddr*)&ss, &slen)<0) {
1980 tt_abort_perror("getsockname");
1981 }
1982 evdns_base_nameserver_sockaddr_add(dns_base,
1983 (struct sockaddr*)&ss, slen, 0);
1984
1985 for (i = 0; i < 1000; ++i) {
1986 gaic_launch(base, dns_base);
1987 }
1988
1989 event_base_dispatch(base);
1990
1991 end:
1992 if (dns_base)
1993 evdns_base_free(dns_base, 1);
1994 if (server)
1995 evdns_close_server_port(server);
1996 if (base)
1997 event_base_free(base);
1998 if (fd >= 0)
1999 evutil_closesocket(fd);
2000 }
2001
2002
2003 #define DNS_LEGACY(name, flags) \
2004 { #name, run_legacy_test_fn, flags|TT_LEGACY, &legacy_setup, \
2005 dns_##name }
2006
2007 struct testcase_t dns_testcases[] = {
2008 DNS_LEGACY(server, TT_FORK|TT_NEED_BASE),
2009 DNS_LEGACY(gethostbyname, TT_FORK|TT_NEED_BASE|TT_NEED_DNS|TT_OFF_BY_DEFAULT),
2010 DNS_LEGACY(gethostbyname6, TT_FORK|TT_NEED_BASE|TT_NEED_DNS|TT_OFF_BY_DEFAULT),
2011 DNS_LEGACY(gethostbyaddr, TT_FORK|TT_NEED_BASE|TT_NEED_DNS|TT_OFF_BY_DEFAULT),
2012 { "resolve_reverse", dns_resolve_reverse, TT_FORK|TT_OFF_BY_DEFAULT, NULL, NULL },
2013 { "search", dns_search_test, TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2014 { "search_cancel", dns_search_cancel_test,
2015 TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2016 { "retry", dns_retry_test, TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
2017 { "retry_disable_when_inactive", dns_retry_disable_when_inactive_test,
2018 TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
2019 { "reissue", dns_reissue_test, TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
2020 { "reissue_disable_when_inactive", dns_reissue_disable_when_inactive_test,
2021 TT_FORK|TT_NEED_BASE|TT_NO_LOGS, &basic_setup, NULL },
2022 { "inflight", dns_inflight_test, TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2023 { "bufferevent_connect_hostname", test_bufferevent_connect_hostname,
2024 TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2025 { "disable_when_inactive", dns_disable_when_inactive_test,
2026 TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2027 { "disable_when_inactive_no_ns", dns_disable_when_inactive_no_ns_test,
2028 TT_FORK|TT_NEED_BASE, &basic_setup, NULL },
2029
2030 { "getaddrinfo_async", test_getaddrinfo_async,
2031 TT_FORK|TT_NEED_BASE, &basic_setup, (char*)"" },
2032 { "getaddrinfo_cancel_stress", test_getaddrinfo_async_cancel_stress,
2033 TT_FORK, NULL, NULL },
2034
2035 #ifdef EVENT_SET_MEM_FUNCTIONS_IMPLEMENTED
2036 { "leak_shutdown", test_dbg_leak_shutdown, TT_FORK, &testleak_funcs, NULL },
2037 { "leak_cancel", test_dbg_leak_cancel, TT_FORK, &testleak_funcs, NULL },
2038
2039 { "leak_resume", test_dbg_leak_resume_, TT_FORK, &testleak_funcs, NULL },
2040 { "leak_cancel_and_resume", test_dbg_leak_cancel_and_resume_,
2041 TT_FORK, &testleak_funcs, NULL },
2042 { "leak_resume_send_err", test_dbg_leak_resume_send_err_,
2043 TT_FORK, &testleak_funcs, NULL },
2044 { "leak_cancel_and_resume_send_err", test_dbg_leak_cancel_and_resume_send_err_,
2045 TT_FORK, &testleak_funcs, NULL },
2046 #endif
2047
2048 END_OF_TESTCASES
2049 };
2050
2051