static void
dns_reissue_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_server_port *port1 = NULL, *port2 = NULL;
struct evdns_base *dns = NULL;
struct generic_dns_callback_result r1;
ev_uint16_t portnum1 = 0, portnum2=0;
char buf1[64], buf2[64];
port1 = regress_get_dnsserver(base, &portnum1, NULL,
regress_dns_server_cb, internal_error_table);
tt_assert(port1);
port2 = regress_get_dnsserver(base, &portnum2, NULL,
regress_dns_server_cb, reissue_table);
tt_assert(port2);
evutil_snprintf(buf1, sizeof(buf1), "127.0.0.1:%d", (int)portnum1);
evutil_snprintf(buf2, sizeof(buf2), "127.0.0.1:%d", (int)portnum2);
dns = evdns_base_new(base, 0);
tt_assert(!evdns_base_nameserver_ip_add(dns, buf1));
tt_assert(! evdns_base_set_option(dns, "timeout:", "0.3"));
tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2"));
tt_assert(! evdns_base_set_option(dns, "attempts:", "5"));
memset(&r1, 0, sizeof(r1));
evdns_base_resolve_ipv4(dns, "foof.example.com", 0,
generic_dns_callback, &r1);
/* Add this after, so that we are sure to get a reissue. */
tt_assert(!evdns_base_nameserver_ip_add(dns, buf2));
n_replies_left = 1;
exit_base = base;
event_base_dispatch(base);
tt_int_op(r1.result, ==, DNS_ERR_NONE);
tt_int_op(r1.type, ==, DNS_IPv4_A);
tt_int_op(r1.count, ==, 1);
tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0xf00ff00f));
/* Make sure we dropped at least once. */
tt_int_op(internal_error_table[0].seen, >, 0);
end:
if (dns)
evdns_base_free(dns, 0);
if (port1)
evdns_close_server_port(port1);
if (port2)
evdns_close_server_port(port2);
}
int
regress_dnsserver(struct event_base *base, ev_uint16_t *port,
struct regress_dns_server_table *search_table)
{
dns_port = regress_get_dnsserver(base, port, &dns_sock,
regress_dns_server_cb, search_table);
return dns_port != NULL;
}
static void
dns_search_cancel_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_base *dns = NULL;
struct evdns_server_port *port = NULL;
ev_uint16_t portnum = 0;
struct generic_dns_callback_result r1;
char buf[64];
port = regress_get_dnsserver(base, &portnum, NULL,
search_cancel_server_cb, NULL);
tt_assert(port);
evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
dns = evdns_base_new(base, 0);
tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
evdns_base_search_add(dns, "a.example.com");
evdns_base_search_add(dns, "b.example.com");
evdns_base_search_add(dns, "c.example.com");
evdns_base_search_add(dns, "d.example.com");
exit_base = base;
request_count = 3;
n_replies_left = 1;
current_req = evdns_base_resolve_ipv4(dns, "host", 0,
generic_dns_callback, &r1);
event_base_dispatch(base);
tt_int_op(r1.result, ==, DNS_ERR_CANCEL);
end:
if (port)
evdns_close_server_port(port);
if (dns)
evdns_base_free(dns, 0);
}
static void
test_bufferevent_connect_hostname(void *arg)
{
struct basic_test_data *data = arg;
struct evconnlistener *listener = NULL;
struct bufferevent *be1=NULL, *be2=NULL, *be3=NULL, *be4=NULL, *be5=NULL;
int be1_outcome=0, be2_outcome=0, be3_outcome=0, be4_outcome=0,
be5_outcome=0;
struct evdns_base *dns=NULL;
struct evdns_server_port *port=NULL;
evutil_socket_t server_fd=-1;
struct sockaddr_in sin;
int listener_port=-1;
ev_uint16_t dns_port=0;
int n_accept=0, n_dns=0;
char buf[128];
be_connect_hostname_base = data->base;
/* Bind an address and figure out what port it's on. */
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
sin.sin_port = 0;
listener = evconnlistener_new_bind(data->base, nil_accept_cb,
&n_accept,
LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_EXEC,
-1, (struct sockaddr *)&sin, sizeof(sin));
listener_port = regress_get_socket_port(
evconnlistener_get_fd(listener));
port = regress_get_dnsserver(data->base, &dns_port, NULL,
be_getaddrinfo_server_cb, &n_dns);
tt_assert(port);
tt_int_op(dns_port, >=, 0);
/* Start an evdns_base that uses the server as its resolver. */
dns = evdns_base_new(data->base, 0);
evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", dns_port);
evdns_base_nameserver_ip_add(dns, buf);
/* Now, finally, at long last, launch the bufferevents. One should do
* a failing lookup IP, one should do a successful lookup by IP,
* and one should do a successful lookup by hostname. */
be1 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
be2 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
be3 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
be4 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
be5 = bufferevent_socket_new(data->base, -1, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(be1, NULL, NULL, be_connect_hostname_event_cb,
&be1_outcome);
bufferevent_setcb(be2, NULL, NULL, be_connect_hostname_event_cb,
&be2_outcome);
bufferevent_setcb(be3, NULL, NULL, be_connect_hostname_event_cb,
&be3_outcome);
bufferevent_setcb(be4, NULL, NULL, be_connect_hostname_event_cb,
&be4_outcome);
bufferevent_setcb(be5, NULL, NULL, be_connect_hostname_event_cb,
&be5_outcome);
/* Launch an async resolve that will fail. */
tt_assert(!bufferevent_socket_connect_hostname(be1, dns, AF_INET,
"nosuchplace.example.com", listener_port));
/* Connect to the IP without resolving. */
tt_assert(!bufferevent_socket_connect_hostname(be2, dns, AF_INET,
"127.0.0.1", listener_port));
/* Launch an async resolve that will succeed. */
tt_assert(!bufferevent_socket_connect_hostname(be3, dns, AF_INET,
"nobodaddy.example.com", listener_port));
/* Use the blocking resolver. This one will fail if your resolver
* can't resolve localhost to 127.0.0.1 */
tt_assert(!bufferevent_socket_connect_hostname(be4, NULL, AF_INET,
"localhost", listener_port));
/* Use the blocking resolver with a nonexistent hostname. */
tt_assert(!bufferevent_socket_connect_hostname(be5, NULL, AF_INET,
"nonesuch.nowhere.example.com", 80));
event_base_dispatch(data->base);
tt_int_op(be1_outcome, ==, BEV_EVENT_ERROR);
tt_int_op(be2_outcome, ==, BEV_EVENT_CONNECTED);
tt_int_op(be3_outcome, ==, BEV_EVENT_CONNECTED);
tt_int_op(be4_outcome, ==, BEV_EVENT_CONNECTED);
tt_int_op(be5_outcome, ==, BEV_EVENT_ERROR);
tt_int_op(n_accept, ==, 3);
tt_int_op(n_dns, ==, 2);
end:
if (listener)
evconnlistener_free(listener);
if (server_fd>=0)
EVUTIL_CLOSESOCKET(server_fd);
if (port)
evdns_close_server_port(port);
if (dns)
evdns_base_free(dns, 0);
if (be1)
bufferevent_free(be1);
if (be2)
bufferevent_free(be2);
if (be3)
bufferevent_free(be3);
if (be4)
bufferevent_free(be4);
if (be5)
bufferevent_free(be5);
}
static void
dns_retry_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_server_port *port = NULL;
struct evdns_base *dns = NULL;
int drop_count = 2;
ev_uint16_t portnum = 53900;/*XXXX let the code pick a port*/
struct generic_dns_callback_result r1;
port = regress_get_dnsserver(base, &portnum, NULL,
fail_server_cb, &drop_count);
tt_assert(port);
dns = evdns_base_new(base, 0);
tt_assert(!evdns_base_nameserver_ip_add(dns, "127.0.0.1:53900"));
tt_assert(! evdns_base_set_option(dns, "timeout", "0.3", DNS_OPTIONS_ALL));
tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "10", DNS_OPTIONS_ALL));
tt_assert(! evdns_base_set_option(dns, "initial-probe-timeout", "0.5", DNS_OPTIONS_ALL));
evdns_base_resolve_ipv4(dns, "host.example.com", 0,
generic_dns_callback, &r1);
n_replies_left = 1;
exit_base = base;
event_base_dispatch(base);
tt_int_op(drop_count, ==, 0);
tt_int_op(r1.type, ==, DNS_IPv4_A);
tt_int_op(r1.count, ==, 1);
tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x10204080));
/* Now try again, but this time have the server get treated as
* failed, so we can send it a test probe. */
drop_count = 4;
tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "3", DNS_OPTIONS_ALL));
tt_assert(! evdns_base_set_option(dns, "attempts:", "4", DNS_OPTIONS_ALL));
memset(&r1, 0, sizeof(r1));
evdns_base_resolve_ipv4(dns, "host.example.com", 0,
generic_dns_callback, &r1);
n_replies_left = 2;
/* This will run until it answers the "google.com" probe request. */
event_base_dispatch(base);
/* We'll treat the server as failed here. */
tt_int_op(r1.result, ==, DNS_ERR_TIMEOUT);
/* It should work this time. */
tt_int_op(drop_count, ==, 0);
evdns_base_resolve_ipv4(dns, "host.example.com", 0,
generic_dns_callback, &r1);
event_base_dispatch(base);
tt_int_op(r1.result, ==, DNS_ERR_NONE);
tt_int_op(r1.type, ==, DNS_IPv4_A);
tt_int_op(r1.count, ==, 1);
tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x10204080));
end:
if (dns)
evdns_base_free(dns, 0);
if (port)
evdns_close_server_port(port);
}
