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);
}
static void
dns_inflight_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_base *dns = NULL;
ev_uint16_t portnum = 53900;/*XXXX let the code pick a port*/
struct generic_dns_callback_result r[20];
int i;
tt_assert(regress_dnsserver(base, &portnum, reissue_table));
/* Make sure that having another (very bad!) RNG doesn't mess us
* up. */
evdns_set_random_bytes_fn(dumb_bytes_fn);
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, "max-inflight:", "3", DNS_OPTIONS_ALL));
tt_assert(! evdns_base_set_option(dns, "randomize-case:", "0", DNS_OPTIONS_ALL));
for(i=0;i<20;++i)
evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r[i]);
n_replies_left = 20;
exit_base = base;
event_base_dispatch(base);
for (i=0;i<20;++i) {
tt_int_op(r[i].type, ==, DNS_IPv4_A);
tt_int_op(r[i].count, ==, 1);
tt_int_op(((ev_uint32_t*)r[i].addrs)[0], ==, htonl(0xf00ff00f));
}
end:
if (dns)
evdns_base_free(dns, 0);
regress_clean_dnsserver();
}
int main(int argc, char *argv[])
{
struct evdns_base *evdns_base;
if (options_parse(&app_context, argc, argv) != 0) {
return 1;
}
#ifdef _WIN32
WSADATA wsa_data;
WSAStartup(MAKEWORD(2, 2), &wsa_data);
#endif
if ((app_context.event_loop = event_base_new()) == NULL) {
perror("event_base_new");
return 1;
}
if ((evdns_base = evdns_base_new(app_context.event_loop, 0)) == NULL) {
perror("evdns_base");
return 1;
}
evdns_base_set_option(evdns_base, "use-tcp", "on-tc");
evdns_base_set_option(evdns_base, "randomize-case", "0");
if (evdns_base_nameserver_ip_add(evdns_base,
app_context.resolver_ip) != 0) {
fprintf(stderr, "Unable to use [%s] as a resolver\n",
app_context.resolver_ip);
return 1;
}
if (app_context.want_ipv6 != 0) {
evdns_base_resolve_ipv6(evdns_base, app_context.host_name,
DNS_QUERY_NO_SEARCH,
ipv6_query_cb, &app_context);
} else {
evdns_base_resolve_ipv4(evdns_base, app_context.host_name,
DNS_QUERY_NO_SEARCH,
ipv4_query_cb, &app_context);
}
event_base_dispatch(app_context.event_loop);
event_base_free(app_context.event_loop);
return 0;
}
static void
dns_inflight_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_base *dns = NULL;
ev_uint16_t portnum = 0;
char buf[64];
struct generic_dns_callback_result r[20];
int i;
tt_assert(regress_dnsserver(base, &portnum, reissue_table));
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));
tt_assert(! evdns_base_set_option(dns, "max-inflight:", "3"));
tt_assert(! evdns_base_set_option(dns, "randomize-case:", "0"));
for (i=0;i<20;++i)
evdns_base_resolve_ipv4(dns, "foof.example.com", 0, generic_dns_callback, &r[i]);
n_replies_left = 20;
exit_base = base;
event_base_dispatch(base);
for (i=0;i<20;++i) {
tt_int_op(r[i].type, ==, DNS_IPv4_A);
tt_int_op(r[i].count, ==, 1);
tt_int_op(((ev_uint32_t*)r[i].addrs)[0], ==, htonl(0xf00ff00f));
}
end:
if (dns)
evdns_base_free(dns, 0);
regress_clean_dnsserver();
}
void
async_network_task_push(struct async_network_task_s *task)
{
static int thread_started = 0;
if (!thread_started) {
pthread_t t;
evthread_use_pthreads();
event_b = event_base_new();
evdns_b = evdns_base_new(event_b, 0);
evdns_base_resolv_conf_parse(evdns_b, DNS_OPTIONS_ALL, "/etc/resolv.conf");
if (config.randomize_dns_case == 0)
evdns_base_set_option(evdns_b, "randomize-case:", "0");
pthread_create(&t, NULL, network_worker_thread, NULL);
pthread_detach(t);
thread_started = 1;
}
switch (task->type) {
case ASYNC_NETWORK_TCP_CONNECT:
handle_tcp_connect_stage1(task);
break;
case ASYNC_NETWORK_TCP_CONNECT_WITH_NETADDRESS:
handle_tcp_connect_with_net_address(task);
break;
case ASYNC_NETWORK_DISCONNECT:
handle_disconnect_stage1(task);
break;
case ASYNC_NETWORK_TCP_READ:
handle_tcp_read_stage1(task);
break;
case ASYNC_NETWORK_TCP_WRITE:
handle_tcp_write_stage1(task);
break;
case ASYNC_NETWORK_UDP_RECV:
handle_udp_recv_stage1(task);
break;
case ASYNC_NETWORK_UDP_SEND:
handle_udp_send_stage1(task);
break;
case ASYNC_NETWORK_HOST_RESOLVE:
handle_host_resolve_stage1(task);
break;
}
}
void setup_events(global_resources_struct *global_resources) {
struct event_base *base = event_base_new();
if (base == NULL) everror_and_exit("event_base_new");
global_resources->bases.base = base;
struct evdns_base *dns_base = evdns_base_new(base, EVDNS_BASE_INITIALIZE_NAMESERVERS);
if (dns_base == NULL) everror_and_exit("evdns_base_new");
if (evdns_base_set_option(dns_base, "randomize-case", "0")) everror_and_exit("evdns_base_set_option");
global_resources->bases.dns_base = dns_base;
struct event *int_signal_event = evsignal_new(base, INTERRUPT_SIGNAL, signal_cb, global_resources->bases.base);
if (int_signal_event == NULL) everror_and_exit("evsignal_new");
global_resources->int_signal_event = int_signal_event;
if (event_add(int_signal_event, NULL)) everror_and_exit("event_add");
struct event *server_event = event_new(base, global_resources->server_sockfd, EV_READ|EV_PERSIST,
server_accept_cb, &global_resources->bases);
if (server_event == NULL) everror_and_exit("event_new");
global_resources->server_event = server_event;
if (event_add(server_event, NULL)) everror_and_exit("event_add");
}
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);
}
