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); }