1 /* Copyright 2006-2007 Niels Provos
2 * Copyright 2007-2012 Nick Mathewson and Niels Provos
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 /* Based on software by Adam Langly. Adam's original message:
30 * Adam Langley <agl@imperialviolet.org>
33 * This software is Public Domain. To view a copy of the public domain dedication,
34 * visit http://creativecommons.org/licenses/publicdomain/ or send a letter to
35 * Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
37 * I ask and expect, but do not require, that all derivative works contain an
38 * attribution similar to:
39 * Parts developed by Adam Langley <agl@imperialviolet.org>
41 * You may wish to replace the word "Parts" with something else depending on
42 * the amount of original code.
44 * (Derivative works does not include programs which link against, run or include
45 * the source verbatim in their source distributions)
50 #include "event2/event-config.h"
51 #include "evconfig-private.h"
53 #include <sys/types.h>
55 #ifndef _FORTIFY_SOURCE
56 #define _FORTIFY_SOURCE 3
61 #ifdef EVENT__HAVE_SYS_TIME_H
64 #ifdef EVENT__HAVE_STDINT_H
70 #ifdef EVENT__HAVE_UNISTD_H
82 #define _WIN32_IE 0x400
87 #include "event2/buffer.h"
88 #include "event2/bufferevent.h"
89 #include "event2/dns.h"
90 #include "event2/dns_struct.h"
91 #include "event2/dns_compat.h"
92 #include "event2/util.h"
93 #include "event2/event.h"
94 #include "event2/event_struct.h"
95 #include "event2/listener.h"
96 #include "event2/thread.h"
98 #include "defer-internal.h"
99 #include "log-internal.h"
100 #include "mm-internal.h"
101 #include "strlcpy-internal.h"
102 #include "ipv6-internal.h"
103 #include "util-internal.h"
104 #include "evthread-internal.h"
107 #include <winsock2.h>
109 #include <iphlpapi.h>
112 #include <sys/socket.h>
113 #include <netinet/in.h>
114 #include <arpa/inet.h>
117 #ifdef EVENT__HAVE_NETINET_IN6_H
118 #include <netinet/in6.h>
121 #define EVDNS_LOG_DEBUG EVENT_LOG_DEBUG
122 #define EVDNS_LOG_WARN EVENT_LOG_WARN
123 #define EVDNS_LOG_MSG EVENT_LOG_MSG
125 #ifndef EVDNS_NAME_MAX
126 #define EVDNS_NAME_MAX 255
133 #define MIN(a,b) ((a)<(b)?(a):(b))
134 #define MAX(a,b) ((a)>(b)?(a):(b))
136 #define ASSERT_VALID_REQUEST(req) \
137 EVUTIL_ASSERT((req)->handle && (req)->handle->current_req == (req))
139 #define u64 ev_uint64_t
140 #define u32 ev_uint32_t
141 #define u16 ev_uint16_t
142 #define u8 ev_uint8_t
144 /* maximum number of addresses from a single packet */
145 /* that we bother recording */
146 #define MAX_V4_ADDRS 32
147 #define MAX_V6_ADDRS 32
149 /* Maximum allowable size of a DNS message over UDP without EDNS.*/
150 #define DNS_MAX_UDP_SIZE 512
151 /* Maximum allowable size of a DNS message over UDP with EDNS.*/
152 #define EDNS_MAX_UDP_SIZE 65535
154 #define EDNS_ENABLED(base) \
155 (((base)->global_max_udp_size) > DNS_MAX_UDP_SIZE)
157 #define TYPE_A EVDNS_TYPE_A
159 #define TYPE_PTR EVDNS_TYPE_PTR
160 #define TYPE_SOA EVDNS_TYPE_SOA
161 #define TYPE_AAAA EVDNS_TYPE_AAAA
164 #define CLASS_INET EVDNS_CLASS_INET
166 /* Timeout in seconds for idle TCP connections that server keeps alive. */
167 #define SERVER_IDLE_CONN_TIMEOUT 10
168 /* Timeout in seconds for idle TCP connections that client keeps alive. */
169 #define CLIENT_IDLE_CONN_TIMEOUT 5
170 /* Default maximum number of simultaneous TCP client connections that DNS server can hold. */
171 #define MAX_CLIENT_CONNECTIONS 10
173 /* Persistent handle. We keep this separate from 'struct request' since we
174 * need some object to last for as long as an evdns_request is outstanding so
175 * that it can be canceled, whereas a search request can lead to multiple
176 * 'struct request' instances being created over its lifetime. */
177 struct evdns_request {
178 struct request *current_req;
179 struct evdns_base *base;
181 int pending_cb; /* Waiting for its callback to be invoked; not
182 * owned by event base any more. */
184 /* elements used by the searching code */
186 struct search_state *search_state;
187 char *search_origname; /* needs to be free()ed */
193 u8 *request; /* the dns packet data */
194 u16 request_size; /* size of memory block stored in request field */
195 u8 request_type; /* TYPE_PTR or TYPE_A or TYPE_AAAA */
196 unsigned int request_len;
198 int tx_count; /* the number of times that this packet has been sent */
199 void *user_pointer; /* the pointer given to us for this request */
200 evdns_callback_type user_callback;
201 struct nameserver *ns; /* the server which we last sent it */
203 /* these objects are kept in a circular list */
204 /* XXX We could turn this into a CIRCLEQ. */
205 struct request *next, *prev;
207 struct event timeout_event;
209 u16 trans_id; /* the transaction id */
210 unsigned request_appended :1; /* true if the request pointer is data which follows this struct */
211 unsigned transmit_me :1; /* needs to be transmitted */
212 unsigned need_cname :1; /* make a separate callback for CNAME */
214 /* XXXX This is a horrible hack. */
215 char **put_cname_in_ptr; /* store the cname here if we get one. */
217 struct evdns_base *base;
219 struct evdns_request *handle;
224 unsigned int have_answer : 1;
228 struct in6_addr *aaaa;
241 struct tcp_connection {
242 struct bufferevent *bev;
243 enum tcp_state state;
244 u16 awaiting_packet_size;
247 struct evdns_server_port;
249 struct client_tcp_connection {
250 LIST_ENTRY(client_tcp_connection) next;
251 struct tcp_connection connection;
252 struct evdns_server_port *port;
256 evutil_socket_t socket; /* a connected UDP socket */
257 struct tcp_connection *connection; /* intended for TCP support */
258 struct sockaddr_storage address;
259 ev_socklen_t addrlen;
260 int failed_times; /* number of times which we have given this server a chance */
261 int timedout; /* number of times in a row a request has timed out */
263 /* these objects are kept in a circular list */
264 struct nameserver *next, *prev;
265 struct event timeout_event; /* used to keep the timeout for */
266 /* when we next probe this server. */
267 /* Valid if state == 0 */
268 /* Outstanding probe request for this nameserver, if any */
269 struct evdns_request *probe_request;
270 char state; /* zero if we think that this server is down */
271 char choked; /* true if we have an EAGAIN from this server's socket */
272 char write_waiting; /* true if we are waiting for EV_WRITE events */
273 struct evdns_base *base;
275 /* Number of currently inflight requests: used
276 * to track when we should add/del the event. */
277 int requests_inflight;
281 /* Represents a local port where we're listening for DNS requests. */
282 struct evdns_server_port {
283 evutil_socket_t socket; /* socket we use to read queries and write replies. */
284 int refcnt; /* reference count. */
285 char choked; /* Are we currently blocked from writing? */
286 char closing; /* Are we trying to close this port, pending writes? */
287 evdns_request_callback_fn_type user_callback; /* Fn to handle requests */
288 void *user_data; /* Opaque pointer passed to user_callback */
289 struct event event; /* Read/write event */
290 /* circular list of replies that we want to write. */
291 struct server_request *pending_replies;
292 struct event_base *event_base;
294 /* Structures for tcp support */
295 struct evconnlistener *listener;
296 LIST_HEAD(client_list, client_tcp_connection) client_connections;
297 unsigned client_connections_count;
298 unsigned max_client_connections;
299 struct timeval tcp_idle_timeout;
301 #ifndef EVENT__DISABLE_THREAD_SUPPORT
306 /* Represents part of a reply being built. (That is, a single RR.) */
307 struct server_reply_item {
308 struct server_reply_item *next; /* next item in sequence. */
309 char *name; /* name part of the RR */
310 u16 type; /* The RR type */
311 u16 class; /* The RR class (usually CLASS_INET) */
312 u32 ttl; /* The RR TTL */
313 char is_name; /* True iff data is a label */
314 u16 datalen; /* Length of data; -1 if data is a label */
315 void *data; /* The contents of the RR */
318 /* Represents a request that we've received as a DNS server, and holds */
319 /* the components of the reply as we're constructing it. */
320 struct server_request {
321 /* Pointers to the next and previous entries on the list of replies */
322 /* that we're waiting to write. Only set if we have tried to respond */
323 /* and gotten EAGAIN. */
324 struct server_request *next_pending;
325 struct server_request *prev_pending;
327 u16 trans_id; /* Transaction id. */
328 struct evdns_server_port *port; /* Which port received this request on? */
329 struct client_tcp_connection *client; /* Equal to NULL in case of UDP connection. */
330 struct sockaddr_storage addr; /* Where to send the response in case of UDP. Equal to NULL in case of TCP connection.*/
331 ev_socklen_t addrlen; /* length of addr */
332 u16 max_udp_reply_size; /* Maximum size of udp reply that client can handle. */
334 int n_answer; /* how many answer RRs have been set? */
335 int n_authority; /* how many authority RRs have been set? */
336 int n_additional; /* how many additional RRs have been set? */
338 struct server_reply_item *answer; /* linked list of answer RRs */
339 struct server_reply_item *authority; /* linked list of authority RRs */
340 struct server_reply_item *additional; /* linked list of additional RRs */
342 /* Constructed response. Only set once we're ready to send a reply. */
343 /* Once this is set, the RR fields are cleared, and no more should be set. */
347 /* Caller-visible fields: flags, questions. */
348 struct evdns_server_request base;
352 /* An array of n_req_heads circular lists for inflight requests.
353 * Each inflight request req is in req_heads[req->trans_id % n_req_heads].
355 struct request **req_heads;
356 /* A circular list of requests that we're waiting to send, but haven't
357 * sent yet because there are too many requests inflight */
358 struct request *req_waiting_head;
359 /* A circular list of nameservers. */
360 struct nameserver *server_head;
363 struct event_base *event_base;
365 /* The number of good nameservers that we have */
366 int global_good_nameservers;
368 /* inflight requests are contained in the req_head list */
369 /* and are actually going out across the network */
370 int global_requests_inflight;
371 /* requests which aren't inflight are in the waiting list */
372 /* and are counted here */
373 int global_requests_waiting;
375 int global_max_requests_inflight;
377 struct timeval global_timeout; /* 5 seconds by default */
378 int global_max_reissues; /* a reissue occurs when we get some errors from the server */
379 int global_max_retransmits; /* number of times we'll retransmit a request which timed out */
380 /* number of timeouts in a row before we consider this server to be down */
381 int global_max_nameserver_timeout;
382 /* true iff we will use the 0x20 hack to prevent poisoning attacks. */
383 int global_randomize_case;
384 /* Maximum size of a UDP DNS packet. */
385 u16 global_max_udp_size;
387 /* The first time that a nameserver fails, how long do we wait before
388 * probing to see if it has returned? */
389 struct timeval global_nameserver_probe_initial_timeout;
391 /* Combination of DNS_QUERY_USEVC, DNS_QUERY_IGNTC flags
392 * to control requests via TCP. */
393 u16 global_tcp_flags;
394 /* Idle timeout for outgoing TCP connections. */
395 struct timeval global_tcp_idle_timeout;
397 /** Port to bind to for outgoing DNS packets. */
398 struct sockaddr_storage global_outgoing_address;
399 /** ev_socklen_t for global_outgoing_address. 0 if it isn't set. */
400 ev_socklen_t global_outgoing_addrlen;
402 struct timeval global_getaddrinfo_allow_skew;
407 int getaddrinfo_ipv4_timeouts;
408 int getaddrinfo_ipv6_timeouts;
409 int getaddrinfo_ipv4_answered;
410 int getaddrinfo_ipv6_answered;
412 struct search_state *global_search_state;
414 TAILQ_HEAD(hosts_list, hosts_entry) hostsdb;
416 #ifndef EVENT__DISABLE_THREAD_SUPPORT
420 int disable_when_inactive;
422 /* Maximum timeout between two probe packets
423 * will change `global_nameserver_probe_initial_timeout`
424 * when this value is smaller */
425 int ns_max_probe_timeout;
426 /* Backoff factor of probe timeout */
427 int ns_timeout_backoff_factor;
431 TAILQ_ENTRY(hosts_entry) next;
434 struct sockaddr_in sin;
435 struct sockaddr_in6 sin6;
441 static struct evdns_base *current_base = NULL;
444 evdns_get_global_base(void)
449 /* Given a pointer to an evdns_server_request, get the corresponding */
450 /* server_request. */
451 #define TO_SERVER_REQUEST(base_ptr) \
452 ((struct server_request*) \
453 (((char*)(base_ptr) - evutil_offsetof(struct server_request, base))))
455 #define REQ_HEAD(base, id) ((base)->req_heads[id % (base)->n_req_heads])
457 static struct nameserver *nameserver_pick(struct evdns_base *base);
458 static void evdns_request_insert(struct request *req, struct request **head);
459 static void evdns_request_remove(struct request *req, struct request **head);
460 static void nameserver_ready_callback(evutil_socket_t fd, short events, void *arg);
461 static int evdns_transmit(struct evdns_base *base);
462 static int evdns_request_transmit(struct request *req);
463 static void nameserver_send_probe(struct nameserver *const ns);
464 static void search_request_finished(struct evdns_request *const);
465 static int search_try_next(struct evdns_request *const req);
466 static struct request *search_request_new(struct evdns_base *base, struct evdns_request *handle, int type, const char *const name, int flags, evdns_callback_type user_callback, void *user_arg);
467 static void evdns_requests_pump_waiting_queue(struct evdns_base *base);
468 static u16 transaction_id_pick(struct evdns_base *base);
469 static struct request *request_new(struct evdns_base *base, struct evdns_request *handle, int type, const char *name, int flags, evdns_callback_type callback, void *ptr);
470 static struct request *request_clone(struct evdns_base *base, struct request* current);
471 static void request_submit(struct request *const req);
473 static int server_request_free(struct server_request *req);
474 static void server_request_free_answers(struct server_request *req);
475 static void server_port_free(struct evdns_server_port *port);
476 static void server_port_ready_callback(evutil_socket_t fd, short events, void *arg);
477 static int evdns_base_resolv_conf_parse_impl(struct evdns_base *base, int flags, const char *const filename);
478 static int evdns_base_set_option_impl(struct evdns_base *base,
479 const char *option, const char *val, int flags);
480 static void evdns_base_free_and_unlock(struct evdns_base *base, int fail_requests);
481 static void evdns_request_timeout_callback(evutil_socket_t fd, short events, void *arg);
482 static int evdns_server_request_format_response(struct server_request *req, int err);
483 static void incoming_conn_cb(struct evconnlistener *listener, evutil_socket_t fd,
484 struct sockaddr *address, int socklen, void *arg);
486 static int strtoint(const char *const str);
488 #ifdef EVENT__DISABLE_THREAD_SUPPORT
489 #define EVDNS_LOCK(base) EVUTIL_NIL_STMT_
490 #define EVDNS_UNLOCK(base) EVUTIL_NIL_STMT_
491 #define ASSERT_LOCKED(base) EVUTIL_NIL_STMT_
493 #define EVDNS_LOCK(base) \
494 EVLOCK_LOCK((base)->lock, 0)
495 #define EVDNS_UNLOCK(base) \
496 EVLOCK_UNLOCK((base)->lock, 0)
497 #define ASSERT_LOCKED(base) \
498 EVLOCK_ASSERT_LOCKED((base)->lock)
501 static evdns_debug_log_fn_type evdns_log_fn = NULL;
504 evdns_set_log_fn(evdns_debug_log_fn_type fn)
510 #define EVDNS_LOG_CHECK __attribute__ ((format(printf, 2, 3)))
512 #define EVDNS_LOG_CHECK
515 static void evdns_log_(int severity, const char *fmt, ...) EVDNS_LOG_CHECK;
517 evdns_log_(int severity, const char *fmt, ...)
523 int is_warn = (severity == EVDNS_LOG_WARN);
524 evutil_vsnprintf(buf, sizeof(buf), fmt, args);
525 evdns_log_fn(is_warn, buf);
527 event_logv_(severity, NULL, fmt, args);
532 #define log evdns_log_
534 /* Initialize tcp_connection structure. */
536 init_tcp_connection(struct tcp_connection *conn, struct bufferevent *bev)
538 memset(conn, 0, sizeof(*conn));
539 conn->state = TS_DISCONNECTED;
541 conn->awaiting_packet_size = 0;
544 /* Disconnect tcp connection. */
546 evdns_tcp_disconnect(struct tcp_connection *conn)
550 conn->state = TS_DISCONNECTED;
551 conn->awaiting_packet_size = 0;
553 bufferevent_free(conn->bev);
558 /* Add new tcp client to the list of TCP clients in the TCP DNS server. */
559 static struct client_tcp_connection*
560 evdns_add_tcp_client(struct evdns_server_port *port, struct bufferevent *bev)
562 struct client_tcp_connection *client;
563 EVUTIL_ASSERT(port && bev);
564 if (port->max_client_connections == port->client_connections_count)
567 client = mm_calloc(1, sizeof(*client));
570 init_tcp_connection(&client->connection, bev);
572 LIST_INSERT_HEAD(&port->client_connections, client, next);
574 ++port->client_connections_count;
575 /* we need to hold evdns_server_port as long as one connection at least stays alive */
582 /* Remove tcp client and free all associated data from the TCP DNS server. */
584 evdns_remove_tcp_client(struct evdns_server_port *port, struct client_tcp_connection *client)
586 if (!port || !client)
589 evdns_tcp_disconnect(&client->connection);
590 LIST_REMOVE(client, next);
592 --port->client_connections_count;
599 /* Remove all tcp clients and free all associated data from the TCP DNS server. */
601 evdns_remove_all_tcp_clients(struct evdns_server_port *port)
603 struct client_tcp_connection *client;
604 while ((client = LIST_FIRST(&port->client_connections))) {
605 evdns_remove_tcp_client(port, client);
609 /* Create new tcp connection structure for DNS client. */
610 static struct tcp_connection *
611 new_tcp_connecton(struct bufferevent *bev)
613 struct tcp_connection *conn;
617 conn = mm_calloc(1, sizeof(*conn));
620 init_tcp_connection(conn, bev);
624 /* Disconnect and free all associated data for the tcp connection in DNS client. */
626 disconnect_and_free_connection(struct tcp_connection *conn)
630 evdns_tcp_disconnect(conn);
634 /* This walks the list of inflight requests to find the */
635 /* one with a matching transaction id. Returns NULL on */
637 static struct request *
638 request_find_from_trans_id(struct evdns_base *base, u16 trans_id) {
639 struct request *req = REQ_HEAD(base, trans_id);
640 struct request *const started_at = req;
646 if (req->trans_id == trans_id) return req;
648 } while (req != started_at);
654 /* a libevent callback function which is called when a nameserver */
655 /* has gone down and we want to test if it has came back to life yet */
657 nameserver_prod_callback(evutil_socket_t fd, short events, void *arg) {
658 struct nameserver *const ns = (struct nameserver *) arg;
662 EVDNS_LOCK(ns->base);
663 nameserver_send_probe(ns);
664 EVDNS_UNLOCK(ns->base);
667 /* a libevent callback which is called when a nameserver probe (to see if */
668 /* it has come back to life) times out. We increment the count of failed_times */
669 /* and wait longer to send the next probe packet. */
671 nameserver_probe_failed(struct nameserver *const ns) {
672 struct timeval timeout;
675 ASSERT_LOCKED(ns->base);
676 (void) evtimer_del(&ns->timeout_event);
677 if (ns->state == 1) {
678 /* This can happen if the nameserver acts in a way which makes us mark */
679 /* it as bad and then starts sending good replies. */
683 memcpy(&timeout, &ns->base->global_nameserver_probe_initial_timeout,
684 sizeof(struct timeval));
685 for (i = ns->failed_times; i > 0 && timeout.tv_sec < ns->base->ns_max_probe_timeout; --i) {
686 timeout.tv_sec *= ns->base->ns_timeout_backoff_factor;
687 timeout.tv_usec *= ns->base->ns_timeout_backoff_factor;
688 if (timeout.tv_usec > 1000000) {
689 timeout.tv_sec += timeout.tv_usec / 1000000;
690 timeout.tv_usec %= 1000000;
693 if (timeout.tv_sec > ns->base->ns_max_probe_timeout) {
694 timeout.tv_sec = ns->base->ns_max_probe_timeout;
700 if (evtimer_add(&ns->timeout_event, &timeout) < 0) {
703 "Error from libevent when adding timer event for %s",
704 evutil_format_sockaddr_port_(
705 (struct sockaddr *)&ns->address,
706 addrbuf, sizeof(addrbuf)));
711 request_swap_ns(struct request *req, struct nameserver *ns) {
712 if (ns && req->ns != ns) {
713 EVUTIL_ASSERT(req->ns->requests_inflight > 0);
714 req->ns->requests_inflight--;
715 ns->requests_inflight++;
721 /* called when a nameserver has been deemed to have failed. For example, too */
722 /* many packets have timed out etc */
724 nameserver_failed(struct nameserver *const ns, const char *msg, int err) {
725 struct request *req, *started_at;
726 struct evdns_base *base = ns->base;
731 /* if this nameserver has already been marked as failed */
732 /* then don't do anything */
733 if (!ns->state) return;
735 log(EVDNS_LOG_MSG, "Nameserver %s has failed: %s",
736 evutil_format_sockaddr_port_(
737 (struct sockaddr *)&ns->address,
738 addrbuf, sizeof(addrbuf)),
741 base->global_good_nameservers--;
742 EVUTIL_ASSERT(base->global_good_nameservers >= 0);
743 if (base->global_good_nameservers == 0) {
744 log(EVDNS_LOG_MSG, "All nameservers have failed");
748 ns->failed_times = 1;
750 if (ns->connection) {
751 disconnect_and_free_connection(ns->connection);
752 ns->connection = NULL;
753 } else if (err == ENOTCONN) {
754 /* XXX: If recvfrom results in ENOTCONN, the socket remains readable
755 * which triggers another recvfrom. The observed behavior is 100% CPU use.
756 * This occurs on iOS (kqueue) after the process has been backgrounded
757 * for a long time (~300 seconds) and then resumed.
758 * All sockets, TCP and UDP, seem to get ENOTCONN and must be closed.
759 * https://github.com/libevent/libevent/issues/265 */
760 const struct sockaddr *address = (const struct sockaddr *)&ns->address;
761 evutil_closesocket(ns->socket);
762 ns->socket = evutil_socket_(address->sa_family,
763 SOCK_DGRAM | EVUTIL_SOCK_NONBLOCK | EVUTIL_SOCK_CLOEXEC, 0);
765 if (base->global_outgoing_addrlen &&
766 !evutil_sockaddr_is_loopback_(address)) {
768 (struct sockaddr *)&base->global_outgoing_address,
769 base->global_outgoing_addrlen) < 0) {
770 log(EVDNS_LOG_WARN, "Couldn't bind to outgoing address");
774 event_del(&ns->event);
775 event_assign(&ns->event, ns->base->event_base, ns->socket,
776 EV_READ | (ns->write_waiting ? EV_WRITE : 0) | EV_PERSIST,
777 nameserver_ready_callback, ns);
778 if (!base->disable_when_inactive && event_add(&ns->event, NULL) < 0) {
779 log(EVDNS_LOG_WARN, "Couldn't add %s event",
780 ns->write_waiting ? "rw": "read");
783 if (evtimer_add(&ns->timeout_event,
784 &base->global_nameserver_probe_initial_timeout) < 0) {
786 "Error from libevent when adding timer event for %s",
787 evutil_format_sockaddr_port_(
788 (struct sockaddr *)&ns->address,
789 addrbuf, sizeof(addrbuf)));
793 /* walk the list of inflight requests to see if any can be reassigned to */
794 /* a different server. Requests in the waiting queue don't have a */
795 /* nameserver assigned yet */
797 /* if we don't have *any* good nameservers then there's no point */
798 /* trying to reassign requests to one */
799 if (!base->global_good_nameservers) return;
801 for (i = 0; i < base->n_req_heads; ++i) {
802 req = started_at = base->req_heads[i];
805 if (req->tx_count == 0 && req->ns == ns) {
806 /* still waiting to go out, can be moved */
807 /* to another server */
808 request_swap_ns(req, nameserver_pick(base));
811 } while (req != started_at);
817 nameserver_up(struct nameserver *const ns)
820 ASSERT_LOCKED(ns->base);
821 if (ns->state) return;
822 log(EVDNS_LOG_MSG, "Nameserver %s is back up",
823 evutil_format_sockaddr_port_(
824 (struct sockaddr *)&ns->address,
825 addrbuf, sizeof(addrbuf)));
826 evtimer_del(&ns->timeout_event);
827 if (ns->probe_request) {
828 evdns_cancel_request(ns->base, ns->probe_request);
829 ns->probe_request = NULL;
832 ns->failed_times = 0;
834 ns->base->global_good_nameservers++;
838 request_trans_id_set(struct request *const req, const u16 trans_id) {
839 req->trans_id = trans_id;
840 *((u16 *) req->request) = htons(trans_id);
843 /* Called to remove a request from a list and dealloc it. */
844 /* head is a pointer to the head of the list it should be */
845 /* removed from or NULL if the request isn't in a list. */
846 /* when free_handle is one, free the handle as well. */
848 request_finished(struct request *const req, struct request **head, int free_handle) {
849 struct evdns_base *base = req->base;
850 int was_inflight = (head != &base->req_waiting_head);
852 ASSERT_VALID_REQUEST(req);
855 evdns_request_remove(req, head);
857 log(EVDNS_LOG_DEBUG, "Removing timeout for request %p", (void *)req);
859 evtimer_del(&req->timeout_event);
860 base->global_requests_inflight--;
861 req->ns->requests_inflight--;
863 base->global_requests_waiting--;
865 /* it was initialized during request_new / evtimer_assign */
866 event_debug_unassign(&req->timeout_event);
869 req->ns->requests_inflight == 0 &&
870 req->base->disable_when_inactive) {
871 event_del(&req->ns->event);
872 evtimer_del(&req->ns->timeout_event);
875 if (!req->request_appended) {
876 /* need to free the request data on it's own */
877 mm_free(req->request);
879 /* the request data is appended onto the header */
880 /* so everything gets free()ed when we: */
884 EVUTIL_ASSERT(req->handle->current_req == req);
887 search_request_finished(req->handle);
888 req->handle->current_req = NULL;
889 if (! req->handle->pending_cb) {
890 /* If we're planning to run the callback,
891 * don't free the handle until later. */
892 mm_free(req->handle);
894 req->handle = NULL; /* If we have a bug, let's crash
897 req->handle->current_req = NULL;
903 evdns_requests_pump_waiting_queue(base);
907 /* This is called when a server returns a funny error code. */
908 /* We try the request again with another server. */
912 /* 1 failed/reissue is pointless */
914 request_reissue(struct request *req) {
915 const struct nameserver *const last_ns = req->ns;
916 ASSERT_LOCKED(req->base);
917 ASSERT_VALID_REQUEST(req);
918 /* the last nameserver should have been marked as failing */
919 /* by the caller of this function, therefore pick will try */
920 /* not to return it */
921 request_swap_ns(req, nameserver_pick(req->base));
922 if (req->ns == last_ns) {
923 /* ... but pick did return it */
924 /* not a lot of point in trying again with the */
929 req->reissue_count++;
931 req->transmit_me = 1;
936 /* this function looks for space on the inflight queue and promotes */
937 /* requests from the waiting queue if it can. */
940 /* add return code, see at nameserver_pick() and other functions. */
942 evdns_requests_pump_waiting_queue(struct evdns_base *base) {
944 while (base->global_requests_inflight < base->global_max_requests_inflight &&
945 base->global_requests_waiting) {
948 EVUTIL_ASSERT(base->req_waiting_head);
949 req = base->req_waiting_head;
951 req->ns = nameserver_pick(base);
955 /* move a request from the waiting queue to the inflight queue */
956 req->ns->requests_inflight++;
958 evdns_request_remove(req, &base->req_waiting_head);
960 base->global_requests_waiting--;
961 base->global_requests_inflight++;
963 request_trans_id_set(req, transaction_id_pick(base));
965 evdns_request_insert(req, &REQ_HEAD(base, req->trans_id));
966 evdns_request_transmit(req);
967 evdns_transmit(base);
971 /* TODO(nickm) document */
972 struct deferred_reply_callback {
973 struct event_callback deferred;
974 struct evdns_request *handle;
979 evdns_callback_type user_callback;
984 reply_run_callback(struct event_callback *d, void *user_pointer)
986 struct deferred_reply_callback *cb =
987 EVUTIL_UPCAST(d, struct deferred_reply_callback, deferred);
989 switch (cb->request_type) {
991 if (cb->have_reply) {
992 cb->user_callback(DNS_ERR_NONE, DNS_IPv4_A,
993 cb->reply.rr_count, cb->ttl,
997 cb->user_callback(DNS_ERR_NONE, DNS_CNAME, 1,
998 cb->ttl, cb->reply.cname, user_pointer);
1000 cb->user_callback(cb->err, 0, 0, cb->ttl, NULL, user_pointer);
1003 if (cb->have_reply) {
1004 char *name = cb->reply.data.ptr_name;
1005 cb->user_callback(DNS_ERR_NONE, DNS_PTR, 1, cb->ttl,
1006 &name, user_pointer);
1008 cb->user_callback(cb->err, 0, 0, cb->ttl, NULL, user_pointer);
1012 if (cb->have_reply) {
1013 cb->user_callback(DNS_ERR_NONE, DNS_IPv6_AAAA,
1014 cb->reply.rr_count, cb->ttl,
1015 cb->reply.data.aaaa,
1017 if (cb->reply.cname)
1018 cb->user_callback(DNS_ERR_NONE, DNS_CNAME, 1,
1019 cb->ttl, cb->reply.cname, user_pointer);
1021 cb->user_callback(cb->err, 0, 0, cb->ttl, NULL, user_pointer);
1027 if (cb->handle && cb->handle->pending_cb) {
1028 mm_free(cb->handle);
1031 if (cb->reply.data.raw) {
1032 mm_free(cb->reply.data.raw);
1035 if (cb->reply.cname) {
1036 mm_free(cb->reply.cname);
1043 reply_schedule_callback(struct request *const req, u32 ttl, u32 err, struct reply *reply)
1045 struct deferred_reply_callback *d = mm_calloc(1, sizeof(*d));
1048 event_warn("%s: Couldn't allocate space for deferred callback.",
1053 ASSERT_LOCKED(req->base);
1055 d->request_type = req->request_type;
1056 d->user_callback = req->user_callback;
1061 memcpy(&d->reply, reply, sizeof(struct reply));
1062 /* We've taken ownership of the data. */
1063 reply->data.raw = NULL;
1067 req->handle->pending_cb = 1;
1068 d->handle = req->handle;
1071 event_deferred_cb_init_(
1073 event_get_priority(&req->timeout_event),
1076 event_deferred_cb_schedule_(
1077 req->base->event_base,
1082 client_retransmit_through_tcp(struct evdns_request *handle)
1084 struct request *req = handle->current_req;
1085 struct evdns_base *base = req->base;
1086 struct request *newreq = request_clone(base, req);
1087 ASSERT_LOCKED(base);
1090 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 0);
1091 handle->current_req = newreq;
1092 newreq->handle = handle;
1093 request_submit(newreq);
1097 #define _QR_MASK 0x8000U
1098 #define _OP_MASK 0x7800U
1099 #define _AA_MASK 0x0400U
1100 #define _TC_MASK 0x0200U
1101 #define _RD_MASK 0x0100U
1102 #define _RA_MASK 0x0080U
1103 #define _Z_MASK 0x0040U
1104 #define _AD_MASK 0x0020U
1105 #define _CD_MASK 0x0010U
1106 #define _RCODE_MASK 0x000fU
1107 #define _Z_MASK_DEPRECATED 0x0070U
1109 /* this processes a parsed reply packet */
1111 reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
1114 int retransmit_via_tcp = 0;
1115 static const int error_codes[] = {
1116 DNS_ERR_FORMAT, DNS_ERR_SERVERFAILED, DNS_ERR_NOTEXIST,
1117 DNS_ERR_NOTIMPL, DNS_ERR_REFUSED
1120 ASSERT_LOCKED(req->base);
1121 ASSERT_VALID_REQUEST(req);
1123 if (flags & (_RCODE_MASK | _TC_MASK) || !reply || !reply->have_answer) {
1124 /* there was an error */
1125 if (flags & _TC_MASK) {
1126 error = DNS_ERR_TRUNCATED;
1127 retransmit_via_tcp = (req->handle->tcp_flags & (DNS_QUERY_IGNTC | DNS_QUERY_USEVC)) == 0;
1128 } else if (flags & _RCODE_MASK) {
1129 u16 error_code = (flags & _RCODE_MASK) - 1;
1130 if (error_code > 4) {
1131 error = DNS_ERR_UNKNOWN;
1133 error = error_codes[error_code];
1135 } else if (reply && !reply->have_answer) {
1136 error = DNS_ERR_NODATA;
1138 error = DNS_ERR_UNKNOWN;
1142 case DNS_ERR_NOTIMPL:
1143 case DNS_ERR_REFUSED:
1144 /* we regard these errors as marking a bad nameserver */
1145 if (req->reissue_count < req->base->global_max_reissues) {
1147 evutil_snprintf(msg, sizeof(msg), "Bad response %d (%s)",
1148 error, evdns_err_to_string(error));
1149 nameserver_failed(req->ns, msg, 0);
1150 if (!request_reissue(req)) return;
1153 case DNS_ERR_SERVERFAILED:
1154 /* rcode 2 (servfailed) sometimes means "we
1155 * are broken" and sometimes (with some binds)
1156 * means "that request was very confusing."
1157 * Treat this as a timeout, not a failure.
1159 log(EVDNS_LOG_DEBUG, "Got a SERVERFAILED from nameserver"
1160 "at %s; will allow the request to time out.",
1161 evutil_format_sockaddr_port_(
1162 (struct sockaddr *)&req->ns->address,
1163 addrbuf, sizeof(addrbuf)));
1164 /* Call the timeout function */
1165 evdns_request_timeout_callback(0, 0, req);
1168 /* we got a good reply from the nameserver: it is up. */
1169 if (req->handle == req->ns->probe_request) {
1170 /* Avoid double-free */
1171 req->ns->probe_request = NULL;
1174 nameserver_up(req->ns);
1177 if (retransmit_via_tcp) {
1178 log(EVDNS_LOG_DEBUG, "Recieved truncated reply(flags 0x%x, transanc ID: %d). Retransmiting via TCP.",
1179 req->handle->tcp_flags, req->trans_id);
1180 req->handle->tcp_flags |= DNS_QUERY_USEVC;
1181 client_retransmit_through_tcp(req->handle);
1185 if (req->handle->search_state &&
1186 req->request_type != TYPE_PTR) {
1187 /* if we have a list of domains to search in,
1188 * try the next one */
1189 if (!search_try_next(req->handle)) {
1190 /* a new request was issued so this
1191 * request is finished and */
1192 /* the user callback will be made when
1193 * that request (or a */
1194 /* child of it) finishes. */
1199 /* all else failed. Pass the failure up */
1200 reply_schedule_callback(req, ttl, error, NULL);
1201 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1);
1203 /* all ok, tell the user */
1204 reply_schedule_callback(req, ttl, 0, reply);
1205 if (req->handle == req->ns->probe_request)
1206 req->ns->probe_request = NULL; /* Avoid double-free */
1207 nameserver_up(req->ns);
1208 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1);
1213 name_parse(u8 *packet, int length, int *idx, char *name_out, int name_out_len) {
1217 #define GET32(x) do { if (j + 4 > length) goto err; memcpy(&t32_, packet + j, 4); j += 4; x = ntohl(t32_); } while (0)
1218 #define GET16(x) do { if (j + 2 > length) goto err; memcpy(&t_, packet + j, 2); j += 2; x = ntohs(t_); } while (0)
1219 #define GET8(x) do { if (j >= length) goto err; x = packet[j++]; } while (0)
1221 char *cp = name_out;
1222 const char *const end = name_out + name_out_len;
1224 /* Normally, names are a series of length prefixed strings terminated */
1225 /* with a length of 0 (the lengths are u8's < 63). */
1226 /* However, the length can start with a pair of 1 bits and that */
1227 /* means that the next 14 bits are a pointer within the current */
1233 if (!label_len) break;
1234 if (label_len & 0xc0) {
1237 if (name_end < 0) name_end = j;
1238 j = (((int)label_len & 0x3f) << 8) + ptr_low;
1239 /* Make sure that the target offset is in-bounds. */
1240 if (j < 0 || j >= length) return -1;
1241 /* If we've jumped more times than there are characters in the
1242 * message, we must have a loop. */
1243 if (++ptr_count > length) return -1;
1246 if (label_len > 63) return -1;
1247 if (cp != name_out) {
1248 if (cp + 1 >= end) return -1;
1251 if (cp + label_len >= end) return -1;
1252 if (j + label_len > length) return -1;
1253 memcpy(cp, packet + j, label_len);
1257 if (cp >= end) return -1;
1268 /* parses a raw request from a nameserver */
1270 reply_parse(struct evdns_base *base, u8 *packet, int length)
1272 int j = 0, k = 0; /* index into packet */
1273 u16 t_; /* used by the macros */
1274 u32 t32_; /* used by the macros */
1275 char tmp_name[256], cmp_name[256]; /* used by the macros */
1276 int name_matches = 0;
1278 u16 trans_id, questions, answers, authority, additional, datalength;
1280 u32 ttl, ttl_r = 0xffffffff;
1282 struct request *req = NULL;
1283 unsigned int i, buf_size;
1285 ASSERT_LOCKED(base);
1293 (void) authority; /* suppress "unused variable" warnings. */
1294 (void) additional; /* suppress "unused variable" warnings. */
1296 req = request_find_from_trans_id(base, trans_id);
1297 if (!req) return -1;
1298 EVUTIL_ASSERT(req->base == base);
1300 memset(&reply, 0, sizeof(reply));
1302 /* If it's not an answer, it doesn't correspond to any request. */
1303 if (!(flags & _QR_MASK)) return -1; /* must be an answer */
1304 if ((flags & (_RCODE_MASK|_TC_MASK)) && (flags & (_RCODE_MASK|_TC_MASK)) != DNS_ERR_NOTEXIST) {
1305 /* there was an error and it's not NXDOMAIN */
1308 /* if (!answers) return; */ /* must have an answer of some form */
1310 /* This macro skips a name in the DNS reply. */
1312 do { tmp_name[0] = '\0'; \
1313 if (name_parse(packet, length, &j, tmp_name, \
1314 sizeof(tmp_name))<0) \
1318 reply.type = req->request_type;
1320 /* skip over each question in the reply */
1321 for (i = 0; i < questions; ++i) {
1322 /* the question looks like
1323 * <label:name><u16:type><u16:class>
1328 if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name)) < 0)
1330 if (name_parse(req->request, req->request_len, &k,
1331 cmp_name, sizeof(cmp_name))<0)
1333 if (!base->global_randomize_case) {
1334 if (strcmp(tmp_name, cmp_name) == 0)
1337 if (evutil_ascii_strcasecmp(tmp_name, cmp_name) == 0)
1349 /* We can allocate less for the reply data, but to do it we'll have
1350 * to parse the response. To simplify things let's just allocate
1351 * a little bit more to avoid complex evaluations.
1353 buf_size = MAX(length - j, EVDNS_NAME_MAX);
1354 reply.data.raw = mm_malloc(buf_size);
1356 /* now we have the answer section which looks like
1357 * <label:name><u16:type><u16:class><u32:ttl><u16:len><data...>
1360 for (i = 0; i < answers; ++i) {
1369 if (type == TYPE_A && class == CLASS_INET) {
1371 if (req->request_type != TYPE_A) {
1372 j += datalength; continue;
1374 if ((datalength & 3) != 0) /* not an even number of As. */
1376 addrcount = datalength >> 2;
1378 ttl_r = MIN(ttl_r, ttl);
1379 /* we only bother with the first four addresses. */
1380 if (j + 4*addrcount > length) goto err;
1381 memcpy(&reply.data.a[reply.rr_count],
1382 packet + j, 4*addrcount);
1384 reply.rr_count += addrcount;
1385 reply.have_answer = 1;
1386 } else if (type == TYPE_PTR && class == CLASS_INET) {
1387 if (req->request_type != TYPE_PTR) {
1388 j += datalength; continue;
1390 if (name_parse(packet, length, &j, reply.data.ptr_name,
1393 ttl_r = MIN(ttl_r, ttl);
1394 reply.have_answer = 1;
1396 } else if (type == TYPE_CNAME) {
1397 char cname[EVDNS_NAME_MAX];
1398 if (name_parse(packet, length, &j, cname,
1401 if (req->need_cname)
1402 reply.cname = mm_strdup(cname);
1403 if (req->put_cname_in_ptr && !*req->put_cname_in_ptr)
1404 *req->put_cname_in_ptr = mm_strdup(cname);
1405 } else if (type == TYPE_AAAA && class == CLASS_INET) {
1407 if (req->request_type != TYPE_AAAA) {
1408 j += datalength; continue;
1410 if ((datalength & 15) != 0) /* not an even number of AAAAs. */
1412 addrcount = datalength >> 4; /* each address is 16 bytes long */
1413 ttl_r = MIN(ttl_r, ttl);
1415 /* we only bother with the first four addresses. */
1416 if (j + 16*addrcount > length) goto err;
1417 memcpy(&reply.data.aaaa[reply.rr_count],
1418 packet + j, 16*addrcount);
1419 reply.rr_count += addrcount;
1421 reply.have_answer = 1;
1423 /* skip over any other type of resource */
1428 if (!reply.have_answer) {
1429 for (i = 0; i < authority; ++i) {
1436 if (type == TYPE_SOA && class == CLASS_INET) {
1437 u32 serial, refresh, retry, expire, minimum;
1449 ttl_r = MIN(ttl_r, ttl);
1450 ttl_r = MIN(ttl_r, minimum);
1452 /* skip over any other type of resource */
1458 if (ttl_r == 0xffffffff)
1461 reply_handle(req, flags, ttl_r, &reply);
1463 mm_free(reply.data.raw);
1467 reply_handle(req, flags, 0, NULL);
1469 mm_free(reply.data.raw);
1473 /* Parse a raw request (packet,length) sent to a nameserver port (port) from */
1474 /* a DNS client (addr,addrlen), and if it's well-formed, call the corresponding */
1477 request_parse(u8 *packet, int length, struct evdns_server_port *port,
1478 struct sockaddr *addr, ev_socklen_t addrlen, struct client_tcp_connection *client)
1480 int j = 0; /* index into packet */
1481 u16 t_; /* used by the macros */
1482 u32 t32_; /* used by the macros */
1483 char tmp_name[256]; /* used by the macros */
1486 u16 trans_id, flags, questions, answers, authority, additional;
1487 struct server_request *server_req = NULL;
1489 u16 type, class, rdlen;
1491 ASSERT_LOCKED(port);
1493 /* Get the header fields */
1501 if (flags & _QR_MASK) return -1; /* Must not be an answer. */
1502 flags &= (_RD_MASK|_CD_MASK); /* Only RD and CD get preserved. */
1504 server_req = mm_malloc(sizeof(struct server_request));
1505 if (server_req == NULL) return -1;
1506 memset(server_req, 0, sizeof(struct server_request));
1508 server_req->trans_id = trans_id;
1510 memcpy(&server_req->addr, addr, addrlen);
1511 server_req->addrlen = addrlen;
1514 server_req->port = port;
1515 server_req->client = client;
1516 server_req->base.flags = flags;
1517 server_req->base.nquestions = 0;
1518 server_req->base.questions = mm_calloc(sizeof(struct evdns_server_question *), questions);
1519 if (server_req->base.questions == NULL)
1522 for (i = 0; i < questions; ++i) {
1524 struct evdns_server_question *q;
1526 if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0)
1530 namelen = (int)strlen(tmp_name);
1531 q = mm_malloc(sizeof(struct evdns_server_question) + namelen);
1535 q->dns_question_class = class;
1536 memcpy(q->name, tmp_name, namelen+1);
1537 server_req->base.questions[server_req->base.nquestions++] = q;
1543 j += 2 /* type */ + 2 /* class */ + 4 /* ttl */; \
1548 for (i = 0; i < answers; ++i) {
1552 for (i = 0; i < authority; ++i) {
1556 server_req->max_udp_reply_size = DNS_MAX_UDP_SIZE;
1557 for (i = 0; i < additional; ++i) {
1565 if (type == TYPE_OPT) {
1566 /* In case of OPT pseudo-RR `class` field is treated
1567 * as a requestor's UDP payload size. */
1568 server_req->max_udp_reply_size = MAX(class, DNS_MAX_UDP_SIZE);
1569 evdns_server_request_add_reply(&(server_req->base),
1570 EVDNS_ADDITIONAL_SECTION,
1572 TYPE_OPT, /* type */
1573 DNS_MAX_UDP_SIZE, /* class */
1585 /* Only standard queries are supported. */
1586 if (flags & _OP_MASK) {
1587 evdns_server_request_respond(&(server_req->base), DNS_ERR_NOTIMPL);
1591 port->user_callback(&(server_req->base), port->user_data);
1596 if (server_req->base.questions) {
1597 for (i = 0; i < server_req->base.nquestions; ++i)
1598 mm_free(server_req->base.questions[i]);
1599 mm_free(server_req->base.questions);
1601 mm_free(server_req);
1612 /* Try to choose a strong transaction id which isn't already in flight */
1614 transaction_id_pick(struct evdns_base *base) {
1615 ASSERT_LOCKED(base);
1618 evutil_secure_rng_get_bytes(&trans_id, sizeof(trans_id));
1620 if (trans_id == 0xffff) continue;
1621 /* now check to see if that id is already inflight */
1622 if (request_find_from_trans_id(base, trans_id) == NULL)
1627 /* choose a namesever to use. This function will try to ignore */
1628 /* nameservers which we think are down and load balance across the rest */
1629 /* by updating the server_head global each time. */
1630 static struct nameserver *
1631 nameserver_pick(struct evdns_base *base) {
1632 struct nameserver *started_at = base->server_head, *picked;
1633 ASSERT_LOCKED(base);
1634 if (!base->server_head) return NULL;
1636 /* if we don't have any good nameservers then there's no */
1637 /* point in trying to find one. */
1638 if (!base->global_good_nameservers) {
1639 base->server_head = base->server_head->next;
1640 return base->server_head;
1643 /* remember that nameservers are in a circular list */
1645 if (base->server_head->state) {
1646 /* we think this server is currently good */
1647 picked = base->server_head;
1648 base->server_head = base->server_head->next;
1652 base->server_head = base->server_head->next;
1653 if (base->server_head == started_at) {
1654 /* all the nameservers seem to be down */
1655 /* so we just return this one and hope for the */
1657 EVUTIL_ASSERT(base->global_good_nameservers == 0);
1658 picked = base->server_head;
1659 base->server_head = base->server_head->next;
1665 /* this is called when a namesever socket is ready for reading */
1667 nameserver_read(struct nameserver *ns) {
1668 struct sockaddr_storage ss;
1669 ev_socklen_t addrlen = sizeof(ss);
1671 const size_t max_packet_size = ns->base->global_max_udp_size;
1672 u8 *packet = mm_malloc(max_packet_size);
1673 ASSERT_LOCKED(ns->base);
1676 nameserver_failed(ns, "not enough memory", 0);
1681 const int r = recvfrom(ns->socket, (void*)packet,
1683 (struct sockaddr*)&ss, &addrlen);
1685 int err = evutil_socket_geterror(ns->socket);
1686 if (EVUTIL_ERR_RW_RETRIABLE(err))
1688 nameserver_failed(ns,
1689 evutil_socket_error_to_string(err), err);
1692 if (evutil_sockaddr_cmp((struct sockaddr*)&ss,
1693 (struct sockaddr*)&ns->address, 0)) {
1694 log(EVDNS_LOG_WARN, "Address mismatch on received "
1695 "DNS packet. Apparent source was %s",
1696 evutil_format_sockaddr_port_(
1697 (struct sockaddr *)&ss,
1698 addrbuf, sizeof(addrbuf)));
1703 reply_parse(ns->base, packet, r);
1709 /* Read a packet from a DNS client on a server port s, parse it, and */
1710 /* act accordingly. */
1712 server_udp_port_read(struct evdns_server_port *s) {
1714 struct sockaddr_storage addr;
1715 ev_socklen_t addrlen;
1720 addrlen = sizeof(struct sockaddr_storage);
1721 r = recvfrom(s->socket, (void*)packet, sizeof(packet), 0,
1722 (struct sockaddr*) &addr, &addrlen);
1724 int err = evutil_socket_geterror(s->socket);
1725 if (EVUTIL_ERR_RW_RETRIABLE(err))
1728 "Error %s (%d) while reading request.",
1729 evutil_socket_error_to_string(err), err);
1732 request_parse(packet, r, s, (struct sockaddr*) &addr, addrlen, NULL);
1737 server_send_response(struct evdns_server_port *port, struct server_request *req)
1739 u16 packet_size = 0;
1740 struct bufferevent *bev = NULL;
1742 bev = req->client->connection.bev;
1744 EVUTIL_ASSERT(req->response_len <= 65535);
1745 packet_size = htons((u16)req->response_len);
1746 if (bufferevent_write(bev, &packet_size, sizeof(packet_size)))
1747 goto beferevent_error;
1748 if (bufferevent_write(bev, (void*)req->response, req->response_len))
1749 goto beferevent_error;
1750 return (int)req->response_len;
1752 int r = sendto(port->socket, req->response, (int)req->response_len, 0,
1753 (struct sockaddr*) &req->addr, (ev_socklen_t)req->addrlen);
1758 log(EVDNS_LOG_WARN, "Failed to send reply to request %p for client %p", (void *)req, (void *)req->client);
1759 /* disconnect if we got bufferevent error */
1760 evdns_remove_tcp_client(port, req->client);
1764 /* Try to write all pending replies on a given DNS server port. */
1766 server_port_flush(struct evdns_server_port *port)
1768 struct server_request *req = port->pending_replies;
1769 ASSERT_LOCKED(port);
1771 int r = server_send_response(port, req);
1773 int err = evutil_socket_geterror(port->socket);
1774 if (EVUTIL_ERR_RW_RETRIABLE(err))
1776 log(EVDNS_LOG_WARN, "Error %s (%d) while writing response to port; dropping", evutil_socket_error_to_string(err), err);
1778 if (server_request_free(req)) {
1779 /* we released the last reference to req->port. */
1782 EVUTIL_ASSERT(req != port->pending_replies);
1783 req = port->pending_replies;
1787 /* We have no more pending requests; stop listening for 'writeable' events. */
1788 (void) event_del(&port->event);
1789 event_assign(&port->event, port->event_base,
1790 port->socket, EV_READ | EV_PERSIST,
1791 server_port_ready_callback, port);
1793 if (event_add(&port->event, NULL) < 0) {
1794 log(EVDNS_LOG_WARN, "Error from libevent when adding event for DNS server.");
1799 /* set if we are waiting for the ability to write to this server. */
1800 /* if waiting is true then we ask libevent for EV_WRITE events, otherwise */
1801 /* we stop these events. */
1803 nameserver_write_waiting(struct nameserver *ns, char waiting) {
1804 ASSERT_LOCKED(ns->base);
1805 if (ns->write_waiting == waiting) return;
1807 ns->write_waiting = waiting;
1808 (void) event_del(&ns->event);
1809 event_assign(&ns->event, ns->base->event_base,
1810 ns->socket, EV_READ | (waiting ? EV_WRITE : 0) | EV_PERSIST,
1811 nameserver_ready_callback, ns);
1812 if (event_add(&ns->event, NULL) < 0) {
1814 log(EVDNS_LOG_WARN, "Error from libevent when adding event for %s",
1815 evutil_format_sockaddr_port_(
1816 (struct sockaddr *)&ns->address,
1817 addrbuf, sizeof(addrbuf)));
1822 /* a callback function. Called by libevent when the kernel says that */
1823 /* a nameserver socket is ready for writing or reading */
1825 nameserver_ready_callback(evutil_socket_t fd, short events, void *arg) {
1826 struct nameserver *ns = (struct nameserver *) arg;
1829 EVDNS_LOCK(ns->base);
1830 if (events & EV_WRITE) {
1832 if (!evdns_transmit(ns->base)) {
1833 nameserver_write_waiting(ns, 0);
1836 if (events & EV_READ) {
1837 nameserver_read(ns);
1839 EVDNS_UNLOCK(ns->base);
1842 /* a callback function. Called by libevent when the kernel says that */
1843 /* a server socket is ready for writing or reading. */
1845 server_port_ready_callback(evutil_socket_t fd, short events, void *arg) {
1846 struct evdns_server_port *port = (struct evdns_server_port *) arg;
1850 if (events & EV_WRITE) {
1852 server_port_flush(port);
1854 if (events & EV_READ) {
1855 server_udp_port_read(port);
1860 /* This is an inefficient representation; only use it via the dnslabel_table_*
1861 * functions, so that is can be safely replaced with something smarter later. */
1862 #define MAX_LABELS 128
1863 /* Structures used to implement name compression */
1864 struct dnslabel_entry { char *v; off_t pos; };
1865 struct dnslabel_table {
1866 int n_labels; /* number of current entries */
1867 /* map from name to position in message */
1868 struct dnslabel_entry labels[MAX_LABELS];
1871 /* Initialize dnslabel_table. */
1873 dnslabel_table_init(struct dnslabel_table *table)
1875 table->n_labels = 0;
1878 /* Free all storage held by table, but not the table itself. */
1880 dnslabel_clear(struct dnslabel_table *table)
1883 for (i = 0; i < table->n_labels; ++i)
1884 mm_free(table->labels[i].v);
1885 table->n_labels = 0;
1888 /* return the position of the label in the current message, or -1 if the label */
1889 /* hasn't been used yet. */
1891 dnslabel_table_get_pos(const struct dnslabel_table *table, const char *label)
1894 for (i = 0; i < table->n_labels; ++i) {
1895 if (!strcmp(label, table->labels[i].v))
1896 return table->labels[i].pos;
1901 /* remember that we've used the label at position pos */
1903 dnslabel_table_add(struct dnslabel_table *table, const char *label, off_t pos)
1907 if (table->n_labels == MAX_LABELS)
1909 v = mm_strdup(label);
1912 p = table->n_labels++;
1913 table->labels[p].v = v;
1914 table->labels[p].pos = pos;
1919 /* Converts a string to a length-prefixed set of DNS labels, starting */
1920 /* at buf[j]. name and buf must not overlap. name_len should be the length */
1921 /* of name. table is optional, and is used for compression. */
1923 /* Input: abc.def */
1924 /* Output: <3>abc<3>def<0> */
1926 /* Returns the first index after the encoded name, or negative on error. */
1927 /* -1 label was > 63 bytes */
1928 /* -2 name too long to fit in buffer. */
1931 dnsname_to_labels(u8 *const buf, size_t buf_len, off_t j,
1932 const char *name, const size_t name_len,
1933 struct dnslabel_table *table) {
1934 const char *end = name + name_len;
1938 #define APPEND16(x) do { \
1939 if (j + 2 > (off_t)buf_len) \
1942 memcpy(buf + j, &t_, 2); \
1945 #define APPEND32(x) do { \
1946 if (j + 4 > (off_t)buf_len) \
1949 memcpy(buf + j, &t32_, 4); \
1953 if (name_len > 255) return -2;
1956 const char *const start = name;
1957 if (table && (ref = dnslabel_table_get_pos(table, name)) >= 0) {
1958 APPEND16(ref | 0xc000);
1961 name = strchr(name, '.');
1963 const size_t label_len = end - start;
1964 if (label_len > 63) return -1;
1965 if ((size_t)(j+label_len+1) > buf_len) return -2;
1966 if (table) dnslabel_table_add(table, start, j);
1967 buf[j++] = (ev_uint8_t)label_len;
1969 memcpy(buf + j, start, label_len);
1970 j += (int) label_len;
1973 /* append length of the label. */
1974 const size_t label_len = name - start;
1975 if (label_len > 63) return -1;
1976 if ((size_t)(j+label_len+1) > buf_len) return -2;
1977 if (table) dnslabel_table_add(table, start, j);
1978 buf[j++] = (ev_uint8_t)label_len;
1980 memcpy(buf + j, start, label_len);
1981 j += (int) label_len;
1982 /* hop over the '.' */
1987 /* the labels must be terminated by a 0. */
1988 /* It's possible that the name ended in a . */
1989 /* in which case the zero is already there */
1990 if (!j || buf[j-1]) buf[j++] = 0;
1996 /* Finds the length of a dns request for a DNS name of the given */
1997 /* length. The actual request may be smaller than the value returned */
2000 evdns_request_len(const struct evdns_base *base, const size_t name_len)
2002 int addional_section_len = 0;
2003 if (EDNS_ENABLED(base)) {
2004 addional_section_len = 1 + /* length of domain name string, always 0 */
2005 2 + /* space for resource type */
2006 2 + /* space for UDP payload size */
2007 4 + /* space for extended RCODE flags */
2008 2; /* space for length of RDATA, always 0 */
2010 return 96 + /* length of the DNS standard header */
2012 4 /* space for the resource type */ +
2013 addional_section_len;
2016 /* build a dns request packet into buf. buf should be at least as long */
2017 /* as evdns_request_len told you it should be. */
2019 /* Returns the amount of space used. Negative on error. */
2021 evdns_request_data_build(const struct evdns_base *base,
2022 const char *const name, const size_t name_len,
2023 const u16 trans_id, const u16 type, const u16 class, u8 *const buf,
2026 off_t j = 0; /* current offset into buf */
2027 u16 t_; /* used by the macros */
2028 u32 t32_; /* used by the macros */
2031 APPEND16(0x0100); /* standard query, recusion needed */
2032 APPEND16(1); /* one question */
2033 APPEND16(0); /* no answers */
2034 APPEND16(0); /* no authority */
2035 APPEND16(EDNS_ENABLED(base) ? 1 : 0); /* additional */
2037 j = dnsname_to_labels(buf, buf_len, j, name, name_len, NULL);
2045 if (EDNS_ENABLED(base)) {
2046 /* The OPT pseudo-RR format
2047 * (https://tools.ietf.org/html/rfc6891#section-6.1.2)
2048 * +------------+--------------+------------------------------+
2049 * | Field Name | Field Type | Description |
2050 * +------------+--------------+------------------------------+
2051 * | NAME | domain name | MUST be 0 (root domain) |
2052 * | TYPE | u_int16_t | OPT (41) |
2053 * | CLASS | u_int16_t | requestor's UDP payload size |
2054 * | TTL | u_int32_t | extended RCODE and flags |
2055 * | RDLEN | u_int16_t | length of all RDATA |
2056 * | RDATA | octet stream | {attribute,value} pairs |
2057 * +------------+--------------+------------------------------+ */
2058 buf[j++] = 0; /* NAME, always 0 */
2059 APPEND16(TYPE_OPT); /* OPT type */
2060 APPEND16(base->global_max_udp_size); /* max UDP payload size */
2061 APPEND32(0); /* No extended RCODE flags set */
2062 APPEND16(0); /* length of RDATA is 0 */
2070 /* exported function */
2071 struct evdns_server_port *
2072 evdns_add_server_port_with_base(struct event_base *base, evutil_socket_t socket, int flags, evdns_request_callback_fn_type cb, void *user_data)
2074 struct evdns_server_port *port;
2076 return NULL; /* flags not yet implemented */
2077 if (!(port = mm_malloc(sizeof(struct evdns_server_port))))
2079 memset(port, 0, sizeof(struct evdns_server_port));
2082 port->socket = socket;
2086 port->user_callback = cb;
2087 port->user_data = user_data;
2088 port->pending_replies = NULL;
2089 port->event_base = base;
2090 port->max_client_connections = MAX_CLIENT_CONNECTIONS;
2091 port->tcp_idle_timeout.tv_sec = SERVER_IDLE_CONN_TIMEOUT;
2092 port->tcp_idle_timeout.tv_usec = 0;
2093 port->client_connections_count = 0;
2094 LIST_INIT(&port->client_connections);
2095 event_assign(&port->event, port->event_base,
2096 port->socket, EV_READ | EV_PERSIST,
2097 server_port_ready_callback, port);
2098 if (event_add(&port->event, NULL) < 0) {
2102 EVTHREAD_ALLOC_LOCK(port->lock, EVTHREAD_LOCKTYPE_RECURSIVE);
2106 /* exported function */
2107 struct evdns_server_port *
2108 evdns_add_server_port_with_listener(struct event_base *base, struct evconnlistener *listener, int flags, evdns_request_callback_fn_type cb, void *user_data)
2110 struct evdns_server_port *port;
2114 return NULL; /* flags not yet implemented */
2116 if (!(port = mm_calloc(1, sizeof(struct evdns_server_port))))
2122 port->user_callback = cb;
2123 port->user_data = user_data;
2124 port->pending_replies = NULL;
2125 port->event_base = base;
2126 port->max_client_connections = MAX_CLIENT_CONNECTIONS;
2127 port->client_connections_count = 0;
2128 LIST_INIT(&port->client_connections);
2129 port->listener = listener;
2130 evconnlistener_set_cb(port->listener, incoming_conn_cb, port);
2132 EVTHREAD_ALLOC_LOCK(port->lock, EVTHREAD_LOCKTYPE_RECURSIVE);
2137 server_tcp_event_cb(struct bufferevent *bev, short events, void *ctx);
2140 tcp_read_message(struct tcp_connection *conn, u8 **msg, int *msg_len)
2142 struct bufferevent *bev = conn->bev;
2143 struct evbuffer *input = bufferevent_get_input(bev);
2147 EVUTIL_ASSERT(conn);
2148 EVUTIL_ASSERT(conn->state == TS_CONNECTED);
2150 /* reading new packet size */
2151 if (!conn->awaiting_packet_size) {
2152 if (evbuffer_get_length(input) < sizeof(ev_uint16_t))
2155 bufferevent_read(bev, (void*)&conn->awaiting_packet_size,
2156 sizeof(conn->awaiting_packet_size));
2157 conn->awaiting_packet_size = ntohs(conn->awaiting_packet_size);
2158 if (conn->awaiting_packet_size <= 0)
2162 /* reading new packet content */
2163 if (evbuffer_get_length(input) < conn->awaiting_packet_size)
2166 packet = mm_malloc(conn->awaiting_packet_size);
2170 r = (int)bufferevent_read(bev, (void*)packet, conn->awaiting_packet_size);
2171 if (r != conn->awaiting_packet_size) {
2186 server_tcp_read_packet_cb(struct bufferevent *bev, void *ctx)
2191 struct client_tcp_connection *client = (struct client_tcp_connection *)ctx;
2192 struct evdns_server_port *port = client->port;
2193 struct tcp_connection *conn = &client->connection;
2194 EVUTIL_ASSERT(port && bev);
2198 if (tcp_read_message(conn, &msg, &msg_len)) {
2199 log(EVDNS_LOG_MSG, "Closing client connection %p due to error", (void *)bev);
2200 evdns_remove_tcp_client(port, client);
2204 server_port_free(port);
2208 /* Only part of the message was recieved. */
2212 request_parse(msg, msg_len, port, NULL, 0, client);
2215 conn->awaiting_packet_size = 0;
2218 bufferevent_setwatermark(bev, EV_READ,
2219 conn->awaiting_packet_size ? conn->awaiting_packet_size : sizeof(ev_uint16_t), 0);
2220 bufferevent_setcb(bev, server_tcp_read_packet_cb, NULL, server_tcp_event_cb, ctx);
2225 server_tcp_event_cb(struct bufferevent *bev, short events, void *ctx)
2227 struct client_tcp_connection *client = (struct client_tcp_connection *)ctx;
2228 struct evdns_server_port *port = client->port;
2230 EVUTIL_ASSERT(port && bev);
2232 if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR | BEV_EVENT_TIMEOUT)) {
2233 log(EVDNS_LOG_DEBUG, "Closing connection %p", (void *)bev);
2234 evdns_remove_tcp_client(port, client);
2239 server_port_free(port);
2243 incoming_conn_cb(struct evconnlistener *listener, evutil_socket_t fd,
2244 struct sockaddr *address, int socklen, void *arg)
2246 struct evdns_server_port *port = (struct evdns_server_port*)arg;
2247 struct bufferevent *bev = bufferevent_socket_new(port->event_base, fd, BEV_OPT_CLOSE_ON_FREE);
2248 struct client_tcp_connection *client = NULL;
2249 struct tcp_connection *cd = NULL;
2253 log(EVDNS_LOG_DEBUG, "New incoming client connection %p", (void *)bev);
2255 bufferevent_set_timeouts(bev, &port->tcp_idle_timeout, &port->tcp_idle_timeout);
2257 client = evdns_add_tcp_client(port, bev);
2260 cd = &client->connection;
2262 cd->state = TS_CONNECTED;
2263 bufferevent_setwatermark(bev, EV_READ, sizeof(ev_uint16_t), 0);
2264 bufferevent_setcb(bev, server_tcp_read_packet_cb, NULL, server_tcp_event_cb, (void *)client);
2265 bufferevent_enable(bev, EV_READ);
2270 bufferevent_free(bev);
2274 struct evdns_server_port *
2275 evdns_add_server_port(evutil_socket_t socket, int flags, evdns_request_callback_fn_type cb, void *user_data)
2277 return evdns_add_server_port_with_base(NULL, socket, flags, cb, user_data);
2280 /* exported function */
2282 evdns_close_server_port(struct evdns_server_port *port)
2285 evdns_remove_all_tcp_clients(port);
2286 if (--port->refcnt == 0) {
2288 server_port_free(port);
2295 /* exported function */
2297 evdns_server_request_add_reply(struct evdns_server_request *req_, int section, const char *name, int type, int class, int ttl, int datalen, int is_name, const char *data)
2299 struct server_request *req = TO_SERVER_REQUEST(req_);
2300 struct server_reply_item **itemp, *item;
2304 EVDNS_LOCK(req->port);
2305 if (req->response) /* have we already answered? */
2309 case EVDNS_ANSWER_SECTION:
2310 itemp = &req->answer;
2311 countp = &req->n_answer;
2313 case EVDNS_AUTHORITY_SECTION:
2314 itemp = &req->authority;
2315 countp = &req->n_authority;
2317 case EVDNS_ADDITIONAL_SECTION:
2318 itemp = &req->additional;
2319 countp = &req->n_additional;
2325 itemp = &((*itemp)->next);
2327 item = mm_malloc(sizeof(struct server_reply_item));
2331 if (!(item->name = mm_strdup(name))) {
2336 item->dns_question_class = class;
2338 item->is_name = is_name != 0;
2342 if (item->is_name) {
2343 if (!(item->data = mm_strdup(data))) {
2344 mm_free(item->name);
2348 item->datalen = (u16)-1;
2350 if (!(item->data = mm_malloc(datalen))) {
2351 mm_free(item->name);
2355 item->datalen = datalen;
2356 memcpy(item->data, data, datalen);
2364 EVDNS_UNLOCK(req->port);
2368 /* exported function */
2370 evdns_server_request_add_a_reply(struct evdns_server_request *req, const char *name, int n, const void *addrs, int ttl)
2372 return evdns_server_request_add_reply(
2373 req, EVDNS_ANSWER_SECTION, name, TYPE_A, CLASS_INET,
2374 ttl, n*4, 0, addrs);
2377 /* exported function */
2379 evdns_server_request_add_aaaa_reply(struct evdns_server_request *req, const char *name, int n, const void *addrs, int ttl)
2381 return evdns_server_request_add_reply(
2382 req, EVDNS_ANSWER_SECTION, name, TYPE_AAAA, CLASS_INET,
2383 ttl, n*16, 0, addrs);
2386 /* exported function */
2388 evdns_server_request_add_ptr_reply(struct evdns_server_request *req, struct in_addr *in, const char *inaddr_name, const char *hostname, int ttl)
2392 if (in && inaddr_name)
2394 else if (!in && !inaddr_name)
2397 a = ntohl(in->s_addr);
2398 evutil_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa",
2399 (int)(u8)((a )&0xff),
2400 (int)(u8)((a>>8 )&0xff),
2401 (int)(u8)((a>>16)&0xff),
2402 (int)(u8)((a>>24)&0xff));
2405 return evdns_server_request_add_reply(
2406 req, EVDNS_ANSWER_SECTION, inaddr_name, TYPE_PTR, CLASS_INET,
2407 ttl, -1, 1, hostname);
2410 /* exported function */
2412 evdns_server_request_add_cname_reply(struct evdns_server_request *req, const char *name, const char *cname, int ttl)
2414 return evdns_server_request_add_reply(
2415 req, EVDNS_ANSWER_SECTION, name, TYPE_CNAME, CLASS_INET,
2419 /* exported function */
2421 evdns_server_request_set_flags(struct evdns_server_request *exreq, int flags)
2423 struct server_request *req = TO_SERVER_REQUEST(exreq);
2424 req->base.flags &= ~(EVDNS_FLAGS_AA|EVDNS_FLAGS_RD);
2425 req->base.flags |= flags;
2429 evdns_server_request_format_response(struct server_request *req, int err)
2431 unsigned char buf[1024 * 64];
2432 size_t buf_len = sizeof(buf);
2438 struct dnslabel_table table;
2440 if (err < 0 || err > 15) return -1;
2442 /* Set response bit and error code; copy OPCODE and RD fields from
2443 * question; copy RA and AA if set by caller. */
2444 flags = req->base.flags;
2445 flags |= (_QR_MASK | err);
2447 dnslabel_table_init(&table);
2448 APPEND16(req->trans_id);
2450 APPEND16(req->base.nquestions);
2451 APPEND16(req->n_answer);
2452 APPEND16(req->n_authority);
2453 APPEND16(req->n_additional);
2455 /* Add questions. */
2456 for (i=0; i < req->base.nquestions; ++i) {
2457 const char *s = req->base.questions[i]->name;
2458 j = dnsname_to_labels(buf, buf_len, j, s, strlen(s), &table);
2460 dnslabel_clear(&table);
2463 APPEND16(req->base.questions[i]->type);
2464 APPEND16(req->base.questions[i]->dns_question_class);
2467 /* Add answer, authority, and additional sections. */
2468 for (i=0; i<3; ++i) {
2469 struct server_reply_item *item;
2473 item = req->authority;
2475 item = req->additional;
2477 r = dnsname_to_labels(buf, buf_len, j, item->name, strlen(item->name), &table);
2482 APPEND16(item->type);
2483 APPEND16(item->dns_question_class);
2484 APPEND32(item->ttl);
2485 if (item->is_name) {
2486 off_t len_idx = j, name_start;
2489 r = dnsname_to_labels(buf, buf_len, j, item->data, strlen(item->data), &table);
2493 t_ = htons( (short) (j-name_start) );
2494 memcpy(buf+len_idx, &t_, 2);
2496 APPEND16(item->datalen);
2497 if (j+item->datalen > (off_t)buf_len)
2500 memcpy(buf+j, item->data, item->datalen);
2503 EVUTIL_ASSERT(item->datalen == 0);
2510 if (j > req->max_udp_reply_size && !req->client) {
2512 j = req->max_udp_reply_size;
2513 buf[2] |= 0x02; /* set the truncated bit. */
2516 req->response_len = j;
2518 if (!(req->response = mm_malloc(req->response_len))) {
2519 server_request_free_answers(req);
2520 dnslabel_clear(&table);
2523 memcpy(req->response, buf, req->response_len);
2524 server_request_free_answers(req);
2525 dnslabel_clear(&table);
2529 /* exported function */
2531 evdns_server_request_respond(struct evdns_server_request *req_, int err)
2533 struct server_request *req = TO_SERVER_REQUEST(req_);
2534 struct evdns_server_port *port = req->port;
2538 if (!req->response) {
2539 if ((r = evdns_server_request_format_response(req, err))<0)
2543 r = server_send_response(port, req);
2544 if (r < 0 && req->client) {
2545 int sock_err = evutil_socket_geterror(port->socket);
2546 if (EVUTIL_ERR_RW_RETRIABLE(sock_err))
2549 if (port->pending_replies) {
2550 req->prev_pending = port->pending_replies->prev_pending;
2551 req->next_pending = port->pending_replies;
2552 req->prev_pending->next_pending =
2553 req->next_pending->prev_pending = req;
2555 req->prev_pending = req->next_pending = req;
2556 port->pending_replies = req;
2559 (void) event_del(&port->event);
2560 event_assign(&port->event, port->event_base, port->socket, (port->closing?0:EV_READ) | EV_WRITE | EV_PERSIST, server_port_ready_callback, port);
2562 if (event_add(&port->event, NULL) < 0) {
2563 log(EVDNS_LOG_WARN, "Error from libevent when adding event for DNS server");
2571 if (server_request_free(req)) {
2576 if (port->pending_replies)
2577 server_port_flush(port);
2585 /* Free all storage held by RRs in req. */
2587 server_request_free_answers(struct server_request *req)
2589 struct server_reply_item *victim, *next, **list;
2591 for (i = 0; i < 3; ++i) {
2593 list = &req->answer;
2595 list = &req->authority;
2597 list = &req->additional;
2601 next = victim->next;
2602 mm_free(victim->name);
2603 victim->name = NULL;
2605 mm_free(victim->data);
2606 victim->data = NULL;
2615 /* Free all storage held by req, and remove links to it. */
2616 /* return true iff we just wound up freeing the server_port. */
2618 server_request_free(struct server_request *req)
2620 int i, rc=1, lock=0;
2621 if (req->base.questions) {
2622 for (i = 0; i < req->base.nquestions; ++i) {
2623 mm_free(req->base.questions[i]);
2624 req->base.questions[i] = NULL;
2626 mm_free(req->base.questions);
2627 req->base.questions = NULL;
2631 EVDNS_LOCK(req->port);
2633 if (req->port->pending_replies == req) {
2634 if (req->next_pending && req->next_pending != req)
2635 req->port->pending_replies = req->next_pending;
2637 req->port->pending_replies = NULL;
2639 rc = --req->port->refcnt;
2642 if (req->response) {
2643 mm_free(req->response);
2644 req->response = NULL;
2647 server_request_free_answers(req);
2649 if (req->next_pending && req->next_pending != req) {
2650 req->next_pending->prev_pending = req->prev_pending;
2651 req->prev_pending->next_pending = req->next_pending;
2655 EVDNS_UNLOCK(req->port); /* ????? nickm */
2656 server_port_free(req->port);
2661 EVDNS_UNLOCK(req->port);
2666 /* Free all storage held by an evdns_server_port. Only called when */
2668 server_port_free(struct evdns_server_port *port)
2670 EVUTIL_ASSERT(port);
2671 EVUTIL_ASSERT(!port->refcnt);
2672 EVUTIL_ASSERT(!port->pending_replies);
2673 if (port->socket > 0) {
2674 evutil_closesocket(port->socket);
2679 if (port->listener) {
2680 evconnlistener_free(port->listener);
2682 (void) event_del(&port->event);
2683 event_debug_unassign(&port->event);
2686 EVTHREAD_FREE_LOCK(port->lock, EVTHREAD_LOCKTYPE_RECURSIVE);
2690 /* exported function */
2692 evdns_server_request_drop(struct evdns_server_request *req_)
2694 struct server_request *req = TO_SERVER_REQUEST(req_);
2695 server_request_free(req);
2699 /* exported function */
2701 evdns_server_request_get_requesting_addr(struct evdns_server_request *req_, struct sockaddr *sa, int addr_len)
2703 struct server_request *req = TO_SERVER_REQUEST(req_);
2704 if (addr_len < (int)req->addrlen)
2706 memcpy(sa, &(req->addr), req->addrlen);
2707 return req->addrlen;
2711 retransmit_all_tcp_requests_for(struct nameserver *server)
2714 for (i = 0; i < server->base->n_req_heads; ++i) {
2715 struct request *started_at = server->base->req_heads[i];
2716 struct request *req = started_at;
2721 if (req->ns == server && (req->handle->tcp_flags & DNS_QUERY_USEVC)) {
2722 if (req->tx_count >= req->base->global_max_retransmits) {
2723 log(EVDNS_LOG_DEBUG, "Giving up on request %p; tx_count==%d",
2724 (void *)req, req->tx_count);
2725 reply_schedule_callback(req, 0, DNS_ERR_TIMEOUT, NULL);
2726 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1);
2728 (void) evtimer_del(&req->timeout_event);
2729 evdns_request_transmit(req);
2733 } while (req != started_at);
2737 /* this is a libevent callback function which is called when a request */
2738 /* has timed out. */
2740 evdns_request_timeout_callback(evutil_socket_t fd, short events, void *arg) {
2741 struct request *const req = (struct request *) arg;
2742 struct evdns_base *base = req->base;
2747 log(EVDNS_LOG_DEBUG, "Request %p timed out", arg);
2750 if (req->tx_count >= req->base->global_max_retransmits) {
2751 struct nameserver *ns = req->ns;
2752 /* this request has failed */
2753 log(EVDNS_LOG_DEBUG, "Giving up on request %p; tx_count==%d",
2754 arg, req->tx_count);
2755 reply_schedule_callback(req, 0, DNS_ERR_TIMEOUT, NULL);
2757 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1);
2758 nameserver_failed(ns, "request timed out.", 0);
2760 /* if request is using tcp connection, so tear connection */
2761 if (req->handle->tcp_flags & DNS_QUERY_USEVC) {
2762 disconnect_and_free_connection(req->ns->connection);
2763 req->ns->connection = NULL;
2765 /* client can have the only connection to DNS server */
2766 retransmit_all_tcp_requests_for(req->ns);
2769 log(EVDNS_LOG_DEBUG, "Retransmitting request %p; tx_count==%d by udp", arg, req->tx_count);
2770 (void) evtimer_del(&req->timeout_event);
2771 request_swap_ns(req, nameserver_pick(base));
2772 evdns_request_transmit(req);
2774 req->ns->timedout++;
2775 if (req->ns->timedout > req->base->global_max_nameserver_timeout) {
2776 req->ns->timedout = 0;
2777 nameserver_failed(req->ns, "request timed out.", 0);
2785 /* try to send a request to a given server. */
2789 /* 1 temporary failure */
2790 /* 2 other failure */
2792 evdns_request_transmit_to(struct request *req, struct nameserver *server) {
2794 ASSERT_LOCKED(req->base);
2795 ASSERT_VALID_REQUEST(req);
2797 if (server->requests_inflight == 1 &&
2798 req->base->disable_when_inactive &&
2799 event_add(&server->event, NULL) < 0) {
2803 r = sendto(server->socket, (void*)req->request, req->request_len, 0,
2804 (struct sockaddr *)&server->address, server->addrlen);
2806 int err = evutil_socket_geterror(server->socket);
2807 if (EVUTIL_ERR_RW_RETRIABLE(err))
2809 nameserver_failed(req->ns, evutil_socket_error_to_string(err), err);
2811 } else if (r != (int)req->request_len) {
2812 return 1; /* short write */
2818 /* try to connect to a given server. */
2822 /* 1 temporary failure */
2823 /* 2 other failure */
2825 evdns_tcp_connect_if_disconnected(struct nameserver *server)
2827 struct tcp_connection *conn = server->connection;
2828 struct timeval *timeout = &server->base->global_tcp_idle_timeout;
2829 if (conn && conn->state != TS_DISCONNECTED && conn->bev != NULL)
2832 disconnect_and_free_connection(conn);
2833 conn = new_tcp_connecton(bufferevent_socket_new(server->base->event_base, -1, BEV_OPT_CLOSE_ON_FREE));
2836 server->connection = conn;
2838 if (bufferevent_set_timeouts(conn->bev, timeout, timeout))
2841 EVUTIL_ASSERT(conn->state == TS_DISCONNECTED);
2842 if (bufferevent_socket_connect(conn->bev, (struct sockaddr *)&server->address, server->addrlen))
2845 conn->state = TS_CONNECTING;
2846 log(EVDNS_LOG_DEBUG, "New tcp connection %p created", (void *)conn);
2851 client_tcp_event_cb(struct bufferevent *bev, short events, void *ctx);
2855 client_tcp_read_packet_cb(struct bufferevent *bev, void *ctx)
2859 struct nameserver *server = (struct nameserver*)ctx;
2860 struct tcp_connection *conn = server->connection;
2861 EVUTIL_ASSERT(server && bev);
2862 EVDNS_LOCK(server->base);
2865 if (tcp_read_message(conn, &msg, &msg_len)) {
2866 disconnect_and_free_connection(server->connection);
2867 server->connection = NULL;
2868 EVDNS_UNLOCK(server->base);
2872 /* Only part of the message was recieved. */
2876 reply_parse(server->base, msg, msg_len);
2879 conn->awaiting_packet_size = 0;
2882 bufferevent_setwatermark(bev, EV_READ,
2883 conn->awaiting_packet_size ? conn->awaiting_packet_size : sizeof(ev_uint16_t), 0);
2884 bufferevent_setcb(bev, client_tcp_read_packet_cb, NULL, client_tcp_event_cb, ctx);
2885 EVDNS_UNLOCK(server->base);
2889 client_tcp_event_cb(struct bufferevent *bev, short events, void *ctx) {
2890 struct nameserver *server = (struct nameserver*)ctx;
2891 struct tcp_connection *conn = server->connection;
2892 EVUTIL_ASSERT(server);
2893 EVDNS_LOCK(server->base);
2894 EVUTIL_ASSERT(conn && conn->bev == bev && bev);
2896 log(EVDNS_LOG_DEBUG, "Event %d on connection %p", events, (void *)conn);
2898 if (events & (BEV_EVENT_TIMEOUT)) {
2899 disconnect_and_free_connection(server->connection);
2900 server->connection = NULL;
2901 } else if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
2902 disconnect_and_free_connection(server->connection);
2903 server->connection = NULL;
2904 } else if (events & BEV_EVENT_CONNECTED) {
2905 EVUTIL_ASSERT (conn->state == TS_CONNECTING);
2906 conn->state = TS_CONNECTED;
2907 evutil_make_socket_nonblocking(bufferevent_getfd(bev));
2908 bufferevent_setcb(bev, client_tcp_read_packet_cb, NULL, client_tcp_event_cb, server);
2909 bufferevent_setwatermark(bev, EV_READ, sizeof(ev_uint16_t), 0);
2911 EVDNS_UNLOCK(server->base);
2914 /* try to send a request to a given server. */
2918 /* 1 temporary failure */
2919 /* 2 other failure */
2921 evdns_request_transmit_through_tcp(struct request *req, struct nameserver *server) {
2922 uint16_t packet_size;
2923 struct tcp_connection *conn = NULL;
2925 ASSERT_LOCKED(req->base);
2926 ASSERT_VALID_REQUEST(req);
2928 if ((r = evdns_tcp_connect_if_disconnected(server)))
2931 conn = server->connection;
2932 bufferevent_setcb(conn->bev, client_tcp_read_packet_cb, NULL, client_tcp_event_cb, server);
2934 log(EVDNS_LOG_DEBUG, "Sending request %p via tcp connection %p", (void *)req, (void *)conn);
2935 packet_size = htons(req->request_len);
2936 if (bufferevent_write(conn->bev, &packet_size, sizeof(packet_size)) )
2938 if (bufferevent_write(conn->bev, (void*)req->request, req->request_len) )
2940 if (bufferevent_enable(conn->bev, EV_READ))
2942 if (evtimer_add(&req->timeout_event, &req->base->global_timeout) < 0)
2947 log(EVDNS_LOG_WARN, "Failed to send request %p via tcp connection %p", (void *)req, (void *)conn);
2948 disconnect_and_free_connection(server->connection);
2949 server->connection = NULL;
2953 /* try to send a request, updating the fields of the request */
2960 evdns_request_transmit(struct request *req) {
2963 ASSERT_LOCKED(req->base);
2964 ASSERT_VALID_REQUEST(req);
2965 /* if we fail to send this packet then this flag marks it */
2966 /* for evdns_transmit */
2967 req->transmit_me = 1;
2968 EVUTIL_ASSERT(req->trans_id != 0xffff);
2972 /* unable to transmit request if no nameservers */
2976 if (req->ns->choked) {
2977 /* don't bother trying to write to a socket */
2978 /* which we have had EAGAIN from */
2982 if (req->handle->tcp_flags & DNS_QUERY_USEVC) {
2983 r = evdns_request_transmit_through_tcp(req, req->ns);
2985 If connection didn't initiated now, so report about temporary problems.
2986 We don't mark name server as chocked so udp packets possibly have no
2987 problems during transmit. Simply we will retry attempt later */
2992 r = evdns_request_transmit_to(req, req->ns);
2997 req->ns->choked = 1;
2998 nameserver_write_waiting(req->ns, 1);
3001 /* failed to transmit the request entirely. we can fallthrough since
3002 * we'll set a timeout, which will time out, and make us retransmit the
3003 * request anyway. */
3008 log(EVDNS_LOG_DEBUG,
3009 "Setting timeout for request %p, sent to nameserver %p", (void *)req, (void *)req->ns);
3010 if (evtimer_add(&req->timeout_event, &req->base->global_timeout) < 0) {
3012 "Error from libevent when adding timer for request %p",
3017 req->transmit_me = 0;
3023 nameserver_probe_callback(int result, char type, int count, int ttl, void *addresses, void *arg) {
3024 struct nameserver *const ns = (struct nameserver *) arg;
3030 if (result == DNS_ERR_CANCEL) {
3031 /* We canceled this request because the nameserver came up
3032 * for some other reason. Do not change our opinion about
3033 * the nameserver. */
3037 EVDNS_LOCK(ns->base);
3038 ns->probe_request = NULL;
3039 if (result == DNS_ERR_NONE || result == DNS_ERR_NOTEXIST) {
3040 /* this is a good reply */
3043 nameserver_probe_failed(ns);
3045 EVDNS_UNLOCK(ns->base);
3049 nameserver_send_probe(struct nameserver *const ns) {
3050 struct evdns_request *handle;
3051 struct request *req;
3053 /* here we need to send a probe to a given nameserver */
3054 /* in the hope that it is up now. */
3056 ASSERT_LOCKED(ns->base);
3057 log(EVDNS_LOG_DEBUG, "Sending probe to %s",
3058 evutil_format_sockaddr_port_(
3059 (struct sockaddr *)&ns->address,
3060 addrbuf, sizeof(addrbuf)));
3061 handle = mm_calloc(1, sizeof(*handle));
3062 if (!handle) return;
3063 req = request_new(ns->base, handle, TYPE_A, "google.com", DNS_QUERY_NO_SEARCH, nameserver_probe_callback, ns);
3068 ns->probe_request = handle;
3069 /* we force this into the inflight queue no matter what */
3070 request_trans_id_set(req, transaction_id_pick(ns->base));
3072 request_submit(req);
3076 /* 0 didn't try to transmit anything */
3077 /* 1 tried to transmit something */
3079 evdns_transmit(struct evdns_base *base) {
3080 char did_try_to_transmit = 0;
3083 ASSERT_LOCKED(base);
3084 for (i = 0; i < base->n_req_heads; ++i) {
3085 if (base->req_heads[i]) {
3086 struct request *const started_at = base->req_heads[i], *req = started_at;
3087 /* first transmit all the requests which are currently waiting */
3089 if (req->transmit_me) {
3090 did_try_to_transmit = 1;
3091 evdns_request_transmit(req);
3095 } while (req != started_at);
3099 return did_try_to_transmit;
3102 /* exported function */
3104 evdns_base_count_nameservers(struct evdns_base *base)
3106 const struct nameserver *server;
3110 server = base->server_head;
3115 server = server->next;
3116 } while (server != base->server_head);
3123 evdns_count_nameservers(void)
3125 return evdns_base_count_nameservers(current_base);
3128 /* exported function */
3130 evdns_base_clear_nameservers_and_suspend(struct evdns_base *base)
3132 struct nameserver *server, *started_at;
3136 server = base->server_head;
3137 started_at = base->server_head;
3143 struct nameserver *next = server->next;
3144 disconnect_and_free_connection(server->connection);
3145 server->connection = NULL;
3146 (void) event_del(&server->event);
3147 if (evtimer_initialized(&server->timeout_event))
3148 (void) evtimer_del(&server->timeout_event);
3149 if (server->probe_request) {
3150 evdns_cancel_request(server->base, server->probe_request);
3151 server->probe_request = NULL;
3153 if (server->socket >= 0)
3154 evutil_closesocket(server->socket);
3156 if (next == started_at)
3160 base->server_head = NULL;
3161 base->global_good_nameservers = 0;
3163 for (i = 0; i < base->n_req_heads; ++i) {
3164 struct request *req, *req_started_at;
3165 req = req_started_at = base->req_heads[i];
3167 struct request *next = req->next;
3168 req->tx_count = req->reissue_count = 0;
3170 /* ???? What to do about searches? */
3171 (void) evtimer_del(&req->timeout_event);
3173 req->transmit_me = 0;
3175 base->global_requests_waiting++;
3176 evdns_request_insert(req, &base->req_waiting_head);
3177 /* We want to insert these suspended elements at the front of
3178 * the waiting queue, since they were pending before any of
3179 * the waiting entries were added. This is a circular list,
3180 * so we can just shift the start back by one.*/
3181 base->req_waiting_head = base->req_waiting_head->prev;
3183 if (next == req_started_at)
3187 base->req_heads[i] = NULL;
3190 base->global_requests_inflight = 0;
3197 evdns_clear_nameservers_and_suspend(void)
3199 return evdns_base_clear_nameservers_and_suspend(current_base);
3203 /* exported function */
3205 evdns_base_resume(struct evdns_base *base)
3208 evdns_requests_pump_waiting_queue(base);
3217 return evdns_base_resume(current_base);
3221 evdns_nameserver_add_impl_(struct evdns_base *base, const struct sockaddr *address, int addrlen) {
3222 /* first check to see if we already have this nameserver */
3224 const struct nameserver *server = base->server_head, *const started_at = base->server_head;
3225 struct nameserver *ns;
3229 ASSERT_LOCKED(base);
3232 if (!evutil_sockaddr_cmp((struct sockaddr*)&server->address, address, 1)) return 3;
3233 server = server->next;
3234 } while (server != started_at);
3236 if (addrlen > (int)sizeof(ns->address)) {
3237 log(EVDNS_LOG_DEBUG, "Addrlen %d too long.", (int)addrlen);
3241 ns = (struct nameserver *) mm_malloc(sizeof(struct nameserver));
3244 memset(ns, 0, sizeof(struct nameserver));
3247 evtimer_assign(&ns->timeout_event, ns->base->event_base, nameserver_prod_callback, ns);
3249 ns->socket = evutil_socket_(address->sa_family,
3250 SOCK_DGRAM|EVUTIL_SOCK_NONBLOCK|EVUTIL_SOCK_CLOEXEC, 0);
3251 if (ns->socket < 0) { err = 1; goto out1; }
3253 if (base->global_outgoing_addrlen &&
3254 !evutil_sockaddr_is_loopback_(address)) {
3255 if (bind(ns->socket,
3256 (struct sockaddr*)&base->global_outgoing_address,
3257 base->global_outgoing_addrlen) < 0) {
3258 log(EVDNS_LOG_WARN,"Couldn't bind to outgoing address");
3264 if (base->so_rcvbuf) {
3265 if (setsockopt(ns->socket, SOL_SOCKET, SO_RCVBUF,
3266 (void *)&base->so_rcvbuf, sizeof(base->so_rcvbuf))) {
3267 log(EVDNS_LOG_WARN, "Couldn't set SO_RCVBUF to %i", base->so_rcvbuf);
3272 if (base->so_sndbuf) {
3273 if (setsockopt(ns->socket, SOL_SOCKET, SO_SNDBUF,
3274 (void *)&base->so_sndbuf, sizeof(base->so_sndbuf))) {
3275 log(EVDNS_LOG_WARN, "Couldn't set SO_SNDBUF to %i", base->so_sndbuf);
3281 memcpy(&ns->address, address, addrlen);
3282 ns->addrlen = addrlen;
3284 ns->connection = NULL;
3285 event_assign(&ns->event, ns->base->event_base, ns->socket,
3286 EV_READ | EV_PERSIST, nameserver_ready_callback, ns);
3287 if (!base->disable_when_inactive && event_add(&ns->event, NULL) < 0) {
3292 log(EVDNS_LOG_DEBUG, "Added nameserver %s as %p",
3293 evutil_format_sockaddr_port_(address, addrbuf, sizeof(addrbuf)), (void *)ns);
3295 /* insert this nameserver into the list of them */
3296 if (!base->server_head) {
3297 ns->next = ns->prev = ns;
3298 base->server_head = ns;
3300 ns->next = base->server_head->next;
3301 ns->prev = base->server_head;
3302 base->server_head->next = ns;
3303 ns->next->prev = ns;
3306 base->global_good_nameservers++;
3311 evutil_closesocket(ns->socket);
3313 event_debug_unassign(&ns->event);
3315 log(EVDNS_LOG_WARN, "Unable to add nameserver %s: error %d",
3316 evutil_format_sockaddr_port_(address, addrbuf, sizeof(addrbuf)), err);
3320 /* exported function */
3322 evdns_base_nameserver_add(struct evdns_base *base, unsigned long int address)
3324 struct sockaddr_in sin;
3326 memset(&sin, 0, sizeof(sin));
3327 sin.sin_addr.s_addr = address;
3328 sin.sin_port = htons(53);
3329 sin.sin_family = AF_INET;
3330 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
3331 sin.sin_len = sizeof(sin);
3334 res = evdns_nameserver_add_impl_(base, (struct sockaddr*)&sin, sizeof(sin));
3340 evdns_nameserver_add(unsigned long int address) {
3342 current_base = evdns_base_new(NULL, 0);
3343 return evdns_base_nameserver_add(current_base, address);
3347 sockaddr_setport(struct sockaddr *sa, ev_uint16_t port)
3349 if (sa->sa_family == AF_INET) {
3350 ((struct sockaddr_in *)sa)->sin_port = htons(port);
3351 } else if (sa->sa_family == AF_INET6) {
3352 ((struct sockaddr_in6 *)sa)->sin6_port = htons(port);
3357 sockaddr_getport(struct sockaddr *sa)
3359 if (sa->sa_family == AF_INET) {
3360 return ntohs(((struct sockaddr_in *)sa)->sin_port);
3361 } else if (sa->sa_family == AF_INET6) {
3362 return ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
3368 /* exported function */
3370 evdns_base_nameserver_ip_add(struct evdns_base *base, const char *ip_as_string) {
3371 struct sockaddr_storage ss;
3372 struct sockaddr *sa;
3373 int len = sizeof(ss);
3375 if (evutil_parse_sockaddr_port(ip_as_string, (struct sockaddr *)&ss,
3377 log(EVDNS_LOG_WARN, "Unable to parse nameserver address %s",
3381 sa = (struct sockaddr *) &ss;
3382 if (sockaddr_getport(sa) == 0)
3383 sockaddr_setport(sa, 53);
3386 res = evdns_nameserver_add_impl_(base, sa, len);
3392 evdns_nameserver_ip_add(const char *ip_as_string) {
3394 current_base = evdns_base_new(NULL, 0);
3395 return evdns_base_nameserver_ip_add(current_base, ip_as_string);
3399 evdns_base_nameserver_sockaddr_add(struct evdns_base *base,
3400 const struct sockaddr *sa, ev_socklen_t len, unsigned flags)
3403 EVUTIL_ASSERT(base);
3405 res = evdns_nameserver_add_impl_(base, sa, len);
3411 evdns_base_get_nameserver_addr(struct evdns_base *base, int idx,
3412 struct sockaddr *sa, ev_socklen_t len)
3416 struct nameserver *server;
3418 server = base->server_head;
3419 for (i = 0; i < idx && server; ++i, server = server->next) {
3420 if (server->next == base->server_head)
3426 if (server->addrlen > len) {
3427 result = (int) server->addrlen;
3431 memcpy(sa, &server->address, server->addrlen);
3432 result = (int) server->addrlen;
3439 evdns_base_get_nameserver_fd(struct evdns_base *base, int idx)
3443 struct nameserver *server;
3445 server = base->server_head;
3446 for (i = 0; i < idx && server; ++i, server = server->next) {
3447 if (server->next == base->server_head)
3452 result = server->socket;
3459 /* remove from the queue */
3461 evdns_request_remove(struct request *req, struct request **head)
3463 ASSERT_LOCKED(req->base);
3464 ASSERT_VALID_REQUEST(req);
3468 struct request *ptr;
3470 EVUTIL_ASSERT(*head != NULL);
3479 } while (ptr != *head);
3480 EVUTIL_ASSERT(found);
3482 EVUTIL_ASSERT(req->next);
3486 if (req->next == req) {
3487 /* only item in the list */
3490 req->next->prev = req->prev;
3491 req->prev->next = req->next;
3492 if (*head == req) *head = req->next;
3494 req->next = req->prev = NULL;
3497 /* insert into the tail of the queue */
3499 evdns_request_insert(struct request *req, struct request **head) {
3500 ASSERT_LOCKED(req->base);
3501 ASSERT_VALID_REQUEST(req);
3504 req->next = req->prev = req;
3508 req->prev = (*head)->prev;
3509 req->prev->next = req;
3511 (*head)->prev = req;
3515 string_num_dots(const char *s) {
3517 while ((s = strchr(s, '.'))) {
3524 static struct request *
3525 request_new(struct evdns_base *base, struct evdns_request *handle, int type,
3526 const char *name, int flags, evdns_callback_type callback,
3529 const char issuing_now =
3530 (base->global_requests_inflight < base->global_max_requests_inflight) ? 1 : 0;
3532 const size_t name_len = strlen(name);
3533 const size_t request_max_len = evdns_request_len(base, name_len);
3534 const u16 trans_id = issuing_now ? transaction_id_pick(base) : 0xffff;
3535 /* the request data is alloced in a single block with the header */
3536 struct request *const req =
3537 mm_malloc(sizeof(struct request) + request_max_len);
3542 ASSERT_LOCKED(base);
3544 if (!req) return NULL;
3546 if (name_len >= sizeof(namebuf)) {
3551 memset(req, 0, sizeof(struct request));
3552 req->request_size = (u16)(sizeof(struct request) + request_max_len);
3555 evtimer_assign(&req->timeout_event, req->base->event_base, evdns_request_timeout_callback, req);
3557 if (base->global_randomize_case) {
3559 char randbits[(sizeof(namebuf)+7)/8];
3560 strlcpy(namebuf, name, sizeof(namebuf));
3561 evutil_secure_rng_get_bytes(randbits, (name_len+7)/8);
3562 for (i = 0; i < name_len; ++i) {
3563 if (EVUTIL_ISALPHA_(namebuf[i])) {
3564 if ((randbits[i >> 3] & (1<<(i & 7))))
3567 namebuf[i] &= ~0x20;
3573 /* request data lives just after the header */
3574 req->request = ((u8 *) req) + sizeof(struct request);
3575 /* denotes that the request data shouldn't be free()ed */
3576 req->request_appended = 1;
3577 rlen = evdns_request_data_build(base, name, name_len, trans_id,
3578 type, CLASS_INET, req->request, request_max_len);
3582 req->request_len = rlen;
3583 req->trans_id = trans_id;
3585 req->request_type = type;
3586 req->user_pointer = user_ptr;
3587 req->user_callback = callback;
3588 req->ns = issuing_now ? nameserver_pick(base) : NULL;
3589 req->next = req->prev = NULL;
3590 req->handle = handle;
3592 handle->current_req = req;
3593 handle->base = base;
3596 if (flags & DNS_CNAME_CALLBACK)
3597 req->need_cname = 1;
3605 static struct request *
3606 request_clone(struct evdns_base *base, struct request* current)
3608 const char issuing_now =
3609 (base->global_requests_inflight < base->global_max_requests_inflight) ? 1 : 0;
3610 const u16 trans_id = issuing_now ? transaction_id_pick(base) : 0xffff;
3611 /* the request data is alloced in a single block with the header */
3612 struct request *const req = mm_malloc(current->request_size);
3613 EVUTIL_ASSERT(current && base);
3614 ASSERT_LOCKED(base);
3618 memcpy(req, current, current->request_size);
3620 evtimer_assign(&req->timeout_event, req->base->event_base, evdns_request_timeout_callback, req);
3622 /* request data lives just after the header */
3623 req->request = ((u8 *) req) + sizeof(struct request);
3624 /* We need to replace transact id */
3625 request_trans_id_set(req, trans_id);
3628 req->ns = issuing_now ? nameserver_pick(base) : NULL;
3629 req->next = req->prev = NULL;
3631 log(EVDNS_LOG_DEBUG, "Clone new request TID %d from TID %d", req->trans_id, current->trans_id);
3637 request_submit(struct request *const req) {
3638 struct evdns_base *base = req->base;
3639 ASSERT_LOCKED(base);
3640 ASSERT_VALID_REQUEST(req);
3642 /* if it has a nameserver assigned then this is going */
3643 /* straight into the inflight queue */
3644 evdns_request_insert(req, &REQ_HEAD(base, req->trans_id));
3646 base->global_requests_inflight++;
3647 req->ns->requests_inflight++;
3649 evdns_request_transmit(req);
3651 evdns_request_insert(req, &base->req_waiting_head);
3652 base->global_requests_waiting++;
3656 /* exported function */
3658 evdns_cancel_request(struct evdns_base *base, struct evdns_request *handle)
3660 struct request *req;
3662 if (!handle->current_req)
3666 /* This redundancy is silly; can we fix it? (Not for 2.0) XXXX */
3667 base = handle->base;
3669 base = handle->current_req->base;
3673 if (handle->pending_cb) {
3678 req = handle->current_req;
3679 ASSERT_VALID_REQUEST(req);
3681 reply_schedule_callback(req, 0, DNS_ERR_CANCEL, NULL);
3683 /* remove from inflight queue */
3684 request_finished(req, &REQ_HEAD(base, req->trans_id), 1);
3686 /* remove from global_waiting head */
3687 request_finished(req, &base->req_waiting_head, 1);
3692 /* exported function */
3693 struct evdns_request *
3694 evdns_base_resolve_ipv4(struct evdns_base *base, const char *name, int flags,
3695 evdns_callback_type callback, void *ptr) {
3696 struct evdns_request *handle;
3697 struct request *req;
3698 log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
3699 handle = mm_calloc(1, sizeof(*handle));
3703 handle->tcp_flags = base->global_tcp_flags;
3704 handle->tcp_flags |= flags & (DNS_QUERY_USEVC | DNS_QUERY_IGNTC);
3705 if (flags & DNS_QUERY_NO_SEARCH) {
3707 request_new(base, handle, TYPE_A, name, flags,
3710 request_submit(req);
3712 search_request_new(base, handle, TYPE_A, name, flags,
3715 if (handle->current_req == NULL) {
3723 int evdns_resolve_ipv4(const char *name, int flags,
3724 evdns_callback_type callback, void *ptr)
3726 return evdns_base_resolve_ipv4(current_base, name, flags, callback, ptr)
3731 /* exported function */
3732 struct evdns_request *
3733 evdns_base_resolve_ipv6(struct evdns_base *base,
3734 const char *name, int flags,
3735 evdns_callback_type callback, void *ptr)
3737 struct evdns_request *handle;
3738 struct request *req;
3739 log(EVDNS_LOG_DEBUG, "Resolve requested for %s", name);
3740 handle = mm_calloc(1, sizeof(*handle));
3744 handle->tcp_flags = base->global_tcp_flags;
3745 handle->tcp_flags |= flags & (DNS_QUERY_USEVC | DNS_QUERY_IGNTC);
3746 if (flags & DNS_QUERY_NO_SEARCH) {
3747 req = request_new(base, handle, TYPE_AAAA, name, flags,
3750 request_submit(req);
3752 search_request_new(base, handle, TYPE_AAAA, name, flags,
3755 if (handle->current_req == NULL) {
3763 int evdns_resolve_ipv6(const char *name, int flags,
3764 evdns_callback_type callback, void *ptr) {
3765 return evdns_base_resolve_ipv6(current_base, name, flags, callback, ptr)
3769 struct evdns_request *
3770 evdns_base_resolve_reverse(struct evdns_base *base, const struct in_addr *in, int flags, evdns_callback_type callback, void *ptr) {
3772 struct evdns_request *handle;
3773 struct request *req;
3776 a = ntohl(in->s_addr);
3777 evutil_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa",
3778 (int)(u8)((a )&0xff),
3779 (int)(u8)((a>>8 )&0xff),
3780 (int)(u8)((a>>16)&0xff),
3781 (int)(u8)((a>>24)&0xff));
3782 handle = mm_calloc(1, sizeof(*handle));
3785 log(EVDNS_LOG_DEBUG, "Resolve requested for %s (reverse)", buf);
3787 handle->tcp_flags = base->global_tcp_flags;
3788 handle->tcp_flags |= flags & (DNS_QUERY_USEVC | DNS_QUERY_IGNTC);
3789 req = request_new(base, handle, TYPE_PTR, buf, flags, callback, ptr);
3791 request_submit(req);
3792 if (handle->current_req == NULL) {
3800 int evdns_resolve_reverse(const struct in_addr *in, int flags, evdns_callback_type callback, void *ptr) {
3801 return evdns_base_resolve_reverse(current_base, in, flags, callback, ptr)
3805 struct evdns_request *
3806 evdns_base_resolve_reverse_ipv6(struct evdns_base *base, const struct in6_addr *in, int flags, evdns_callback_type callback, void *ptr) {
3807 /* 32 nybbles, 32 periods, "ip6.arpa", NUL. */
3810 struct evdns_request *handle;
3811 struct request *req;
3815 for (i=15; i >= 0; --i) {
3816 u8 byte = in->s6_addr[i];
3817 *cp++ = "0123456789abcdef"[byte & 0x0f];
3819 *cp++ = "0123456789abcdef"[byte >> 4];
3822 EVUTIL_ASSERT(cp + strlen("ip6.arpa") < buf+sizeof(buf));
3823 memcpy(cp, "ip6.arpa", strlen("ip6.arpa")+1);
3824 handle = mm_calloc(1, sizeof(*handle));
3827 log(EVDNS_LOG_DEBUG, "Resolve requested for %s (reverse)", buf);
3829 handle->tcp_flags = base->global_tcp_flags;
3830 handle->tcp_flags |= flags & (DNS_QUERY_USEVC | DNS_QUERY_IGNTC);
3831 req = request_new(base, handle, TYPE_PTR, buf, flags, callback, ptr);
3833 request_submit(req);
3834 if (handle->current_req == NULL) {
3842 int evdns_resolve_reverse_ipv6(const struct in6_addr *in, int flags, evdns_callback_type callback, void *ptr) {
3843 return evdns_base_resolve_reverse_ipv6(current_base, in, flags, callback, ptr)
3847 /* ================================================================= */
3848 /* Search support */
3850 /* the libc resolver has support for searching a number of domains */
3851 /* to find a name. If nothing else then it takes the single domain */
3852 /* from the gethostname() call. */
3854 /* It can also be configured via the domain and search options in a */
3857 /* The ndots option controls how many dots it takes for the resolver */
3858 /* to decide that a name is non-local and so try a raw lookup first. */
3860 struct search_domain {
3862 struct search_domain *next;
3863 /* the text string is appended to this structure */
3866 struct search_state {
3870 struct search_domain *head;
3874 search_state_decref(struct search_state *const state) {
3877 if (!state->refcount) {
3878 struct search_domain *next, *dom;
3879 for (dom = state->head; dom; dom = next) {
3887 static struct search_state *
3888 search_state_new(void) {
3889 struct search_state *state = (struct search_state *) mm_malloc(sizeof(struct search_state));
3890 if (!state) return NULL;
3891 memset(state, 0, sizeof(struct search_state));
3892 state->refcount = 1;
3899 search_postfix_clear(struct evdns_base *base) {
3900 search_state_decref(base->global_search_state);
3902 base->global_search_state = search_state_new();
3905 /* exported function */
3907 evdns_base_search_clear(struct evdns_base *base)
3910 search_postfix_clear(base);
3915 evdns_search_clear(void) {
3916 evdns_base_search_clear(current_base);
3920 search_postfix_add(struct evdns_base *base, const char *domain) {
3922 struct search_domain *sdomain;
3923 while (domain[0] == '.') domain++;
3924 domain_len = strlen(domain);
3926 ASSERT_LOCKED(base);
3927 if (!base->global_search_state) base->global_search_state = search_state_new();
3928 if (!base->global_search_state) return;
3929 base->global_search_state->num_domains++;
3931 sdomain = (struct search_domain *) mm_malloc(sizeof(struct search_domain) + domain_len);
3932 if (!sdomain) return;
3933 memcpy( ((u8 *) sdomain) + sizeof(struct search_domain), domain, domain_len);
3934 sdomain->next = base->global_search_state->head;
3935 sdomain->len = (int) domain_len;
3937 base->global_search_state->head = sdomain;
3940 /* reverse the order of members in the postfix list. This is needed because, */
3941 /* when parsing resolv.conf we push elements in the wrong order */
3943 search_reverse(struct evdns_base *base) {
3944 struct search_domain *cur, *prev = NULL, *next;
3945 ASSERT_LOCKED(base);
3946 cur = base->global_search_state->head;
3954 base->global_search_state->head = prev;
3957 /* exported function */
3959 evdns_base_search_add(struct evdns_base *base, const char *domain) {
3961 search_postfix_add(base, domain);
3965 evdns_search_add(const char *domain) {
3966 evdns_base_search_add(current_base, domain);
3969 /* exported function */
3971 evdns_base_search_ndots_set(struct evdns_base *base, const int ndots) {
3973 if (!base->global_search_state) base->global_search_state = search_state_new();
3974 if (base->global_search_state)
3975 base->global_search_state->ndots = ndots;
3979 evdns_search_ndots_set(const int ndots) {
3980 evdns_base_search_ndots_set(current_base, ndots);
3984 search_set_from_hostname(struct evdns_base *base) {
3985 char hostname[EVDNS_NAME_MAX + 1], *domainname;
3987 ASSERT_LOCKED(base);
3988 search_postfix_clear(base);
3989 if (gethostname(hostname, sizeof(hostname))) return;
3990 domainname = strchr(hostname, '.');
3991 if (!domainname) return;
3992 search_postfix_add(base, domainname);
3995 /* warning: returns malloced string */
3997 search_make_new(const struct search_state *const state, int n, const char *const base_name) {
3998 const size_t base_len = strlen(base_name);
3999 char need_to_append_dot;
4000 struct search_domain *dom;
4002 if (!base_len) return NULL;
4003 need_to_append_dot = base_name[base_len - 1] == '.' ? 0 : 1;
4005 for (dom = state->head; dom; dom = dom->next) {
4007 /* this is the postfix we want */
4008 /* the actual postfix string is kept at the end of the structure */
4009 const u8 *const postfix = ((u8 *) dom) + sizeof(struct search_domain);
4010 const int postfix_len = dom->len;
4011 char *const newname = (char *) mm_malloc(base_len + need_to_append_dot + postfix_len + 1);
4012 if (!newname) return NULL;
4013 memcpy(newname, base_name, base_len);
4014 if (need_to_append_dot) newname[base_len] = '.';
4015 memcpy(newname + base_len + need_to_append_dot, postfix, postfix_len);
4016 newname[base_len + need_to_append_dot + postfix_len] = 0;
4021 /* we ran off the end of the list and still didn't find the requested string */
4023 return NULL; /* unreachable; stops warnings in some compilers. */
4026 static struct request *
4027 search_request_new(struct evdns_base *base, struct evdns_request *handle,
4028 int type, const char *const name, int flags,
4029 evdns_callback_type user_callback, void *user_arg) {
4030 ASSERT_LOCKED(base);
4031 EVUTIL_ASSERT(type == TYPE_A || type == TYPE_AAAA);
4032 EVUTIL_ASSERT(handle->current_req == NULL);
4033 if ( ((flags & DNS_QUERY_NO_SEARCH) == 0) &&
4034 base->global_search_state &&
4035 base->global_search_state->num_domains) {
4036 /* we have some domains to search */
4037 struct request *req;
4038 if (string_num_dots(name) >= base->global_search_state->ndots) {
4039 req = request_new(base, handle, type, name, flags, user_callback, user_arg);
4040 if (!req) return NULL;
4041 handle->search_index = -1;
4043 char *const new_name = search_make_new(base->global_search_state, 0, name);
4044 if (!new_name) return NULL;
4045 req = request_new(base, handle, type, new_name, flags, user_callback, user_arg);
4047 if (!req) return NULL;
4048 handle->search_index = 0;
4050 EVUTIL_ASSERT(handle->search_origname == NULL);
4051 handle->search_origname = mm_strdup(name);
4052 if (handle->search_origname == NULL) {
4053 /* XXX Should we dealloc req? If yes, how? */
4058 handle->search_state = base->global_search_state;
4059 handle->search_flags = flags;
4060 base->global_search_state->refcount++;
4061 request_submit(req);
4064 struct request *const req = request_new(base, handle, type, name, flags, user_callback, user_arg);
4065 if (!req) return NULL;
4066 request_submit(req);
4071 /* this is called when a request has failed to find a name. We need to check */
4072 /* if it is part of a search and, if so, try the next name in the list */
4074 /* 0 another request has been submitted */
4075 /* 1 no more requests needed */
4077 search_try_next(struct evdns_request *const handle) {
4078 struct request *req = handle->current_req;
4079 struct evdns_base *base = req->base;
4080 struct request *newreq;
4081 ASSERT_LOCKED(base);
4082 if (handle->search_state) {
4083 /* it is part of a search */
4085 handle->search_index++;
4086 if (handle->search_index >= handle->search_state->num_domains) {
4087 /* no more postfixes to try, however we may need to try */
4088 /* this name without a postfix */
4089 if (string_num_dots(handle->search_origname) < handle->search_state->ndots) {
4090 /* yep, we need to try it raw */
4091 newreq = request_new(base, NULL, req->request_type, handle->search_origname, handle->search_flags, req->user_callback, req->user_pointer);
4092 log(EVDNS_LOG_DEBUG, "Search: trying raw query %s", handle->search_origname);
4094 search_request_finished(handle);
4101 new_name = search_make_new(handle->search_state, handle->search_index, handle->search_origname);
4102 if (!new_name) return 1;
4103 log(EVDNS_LOG_DEBUG, "Search: now trying %s (%d)", new_name, handle->search_index);
4104 newreq = request_new(base, NULL, req->request_type, new_name, handle->search_flags, req->user_callback, req->user_pointer);
4106 if (!newreq) return 1;
4112 request_finished(req, &REQ_HEAD(req->base, req->trans_id), 0);
4113 handle->current_req = newreq;
4114 newreq->handle = handle;
4115 request_submit(newreq);
4120 search_request_finished(struct evdns_request *const handle) {
4121 ASSERT_LOCKED(handle->current_req->base);
4122 if (handle->search_state) {
4123 search_state_decref(handle->search_state);
4124 handle->search_state = NULL;
4126 if (handle->search_origname) {
4127 mm_free(handle->search_origname);
4128 handle->search_origname = NULL;
4132 /* ================================================================= */
4133 /* Parsing resolv.conf files */
4136 evdns_resolv_set_defaults(struct evdns_base *base, int flags) {
4137 int add_default = flags & DNS_OPTION_NAMESERVERS;
4138 if (flags & DNS_OPTION_NAMESERVERS_NO_DEFAULT)
4141 /* if the file isn't found then we assume a local resolver */
4142 ASSERT_LOCKED(base);
4143 if (flags & DNS_OPTION_SEARCH)
4144 search_set_from_hostname(base);
4146 evdns_base_nameserver_ip_add(base, "127.0.0.1");
4149 #ifndef EVENT__HAVE_STRTOK_R
4151 strtok_r(char *s, const char *delim, char **state) {
4153 start = cp = s ? s : *state;
4156 while (*cp && !strchr(delim, *cp))
4171 /* helper version of atoi which returns -1 on error */
4173 strtoint(const char *const str)
4176 const int r = strtol(str, &endptr, 10);
4177 if (*endptr) return -1;
4181 /* Parse a number of seconds into a timeval; return -1 on error. */
4183 evdns_strtotimeval(const char *const str, struct timeval *out)
4187 d = strtod(str, &endptr);
4188 if (*endptr) return -1;
4189 if (d < 0) return -1;
4190 out->tv_sec = (int) d;
4191 out->tv_usec = (int) ((d - (int) d)*1000000);
4192 if (out->tv_sec == 0 && out->tv_usec < 1000) /* less than 1 msec */
4197 /* helper version of atoi that returns -1 on error and clips to bounds. */
4199 strtoint_clipped(const char *const str, int min, int max)
4201 int r = strtoint(str);
4213 evdns_base_set_max_requests_inflight(struct evdns_base *base, int maxinflight)
4215 int old_n_heads = base->n_req_heads, n_heads;
4216 struct request **old_heads = base->req_heads, **new_heads, *req;
4219 ASSERT_LOCKED(base);
4220 if (maxinflight < 1)
4222 n_heads = (maxinflight+4) / 5;
4223 EVUTIL_ASSERT(n_heads > 0);
4224 new_heads = mm_calloc(n_heads, sizeof(struct request*));
4228 for (i = 0; i < old_n_heads; ++i) {
4229 while (old_heads[i]) {
4231 evdns_request_remove(req, &old_heads[i]);
4232 evdns_request_insert(req, &new_heads[req->trans_id % n_heads]);
4237 base->req_heads = new_heads;
4238 base->n_req_heads = n_heads;
4239 base->global_max_requests_inflight = maxinflight;
4243 /* exported function */
4245 evdns_base_set_option(struct evdns_base *base,
4246 const char *option, const char *val)
4250 res = evdns_base_set_option_impl(base, option, val, DNS_OPTIONS_ALL);
4256 str_matches_option(const char *s1, const char *optionname)
4258 /* Option names are given as "option:" We accept either 'option' in
4259 * s1, or 'option:randomjunk'. The latter form is to implement the
4260 * resolv.conf parser. */
4261 size_t optlen = strlen(optionname);
4262 size_t slen = strlen(s1);
4263 if (slen == optlen || slen == optlen - 1)
4264 return !strncmp(s1, optionname, slen);
4265 else if (slen > optlen)
4266 return !strncmp(s1, optionname, optlen);
4271 /* exported function */
4273 evdns_server_port_set_option(struct evdns_server_port *port,
4274 enum evdns_server_option option, size_t value)
4279 case EVDNS_SOPT_TCP_MAX_CLIENTS:
4280 if (!port->listener) {
4281 log(EVDNS_LOG_WARN, "EVDNS_SOPT_TCP_MAX_CLIENTS option can be set only on TCP server");
4285 port->max_client_connections = value;
4286 log(EVDNS_LOG_DEBUG, "Setting EVDNS_SOPT_TCP_MAX_CLIENTS to %u", port->max_client_connections);
4288 case EVDNS_SOPT_TCP_IDLE_TIMEOUT:
4289 if (!port->listener) {
4290 log(EVDNS_LOG_WARN, "EVDNS_SOPT_TCP_IDLE_TIMEOUT option can be set only on TCP server");
4294 port->tcp_idle_timeout.tv_sec = value;
4295 port->tcp_idle_timeout.tv_usec = 0;
4296 log(EVDNS_LOG_DEBUG, "Setting EVDNS_SOPT_TCP_IDLE_TIMEOUT to %u seconds",
4297 (unsigned)port->tcp_idle_timeout.tv_sec);
4300 log(EVDNS_LOG_WARN, "Invalid DNS server option %d", (int)option);
4310 evdns_base_set_option_impl(struct evdns_base *base,
4311 const char *option, const char *val, int flags)
4313 ASSERT_LOCKED(base);
4314 if (str_matches_option(option, "ndots:")) {
4315 const int ndots = strtoint(val);
4316 if (ndots == -1) return -1;
4317 if (!(flags & DNS_OPTION_SEARCH)) return 0;
4318 log(EVDNS_LOG_DEBUG, "Setting ndots to %d", ndots);
4319 if (!base->global_search_state) base->global_search_state = search_state_new();
4320 if (!base->global_search_state) return -1;
4321 base->global_search_state->ndots = ndots;
4322 } else if (str_matches_option(option, "timeout:")) {
4324 if (evdns_strtotimeval(val, &tv) == -1) return -1;
4325 if (!(flags & DNS_OPTION_MISC)) return 0;
4326 log(EVDNS_LOG_DEBUG, "Setting timeout to %s", val);
4327 memcpy(&base->global_timeout, &tv, sizeof(struct timeval));
4328 } else if (str_matches_option(option, "getaddrinfo-allow-skew:")) {
4330 if (evdns_strtotimeval(val, &tv) == -1) return -1;
4331 if (!(flags & DNS_OPTION_MISC)) return 0;
4332 log(EVDNS_LOG_DEBUG, "Setting getaddrinfo-allow-skew to %s",
4334 memcpy(&base->global_getaddrinfo_allow_skew, &tv,
4335 sizeof(struct timeval));
4336 } else if (str_matches_option(option, "max-timeouts:")) {
4337 const int maxtimeout = strtoint_clipped(val, 1, 255);
4338 if (maxtimeout == -1) return -1;
4339 if (!(flags & DNS_OPTION_MISC)) return 0;
4340 log(EVDNS_LOG_DEBUG, "Setting maximum allowed timeouts to %d",
4342 base->global_max_nameserver_timeout = maxtimeout;
4343 } else if (str_matches_option(option, "max-inflight:")) {
4344 const int maxinflight = strtoint_clipped(val, 1, 65000);
4345 if (maxinflight == -1) return -1;
4346 if (!(flags & DNS_OPTION_MISC)) return 0;
4347 log(EVDNS_LOG_DEBUG, "Setting maximum inflight requests to %d",
4349 evdns_base_set_max_requests_inflight(base, maxinflight);
4350 } else if (str_matches_option(option, "attempts:")) {
4351 int retries = strtoint(val);
4352 if (retries == -1) return -1;
4353 if (retries > 255) retries = 255;
4354 if (!(flags & DNS_OPTION_MISC)) return 0;
4355 log(EVDNS_LOG_DEBUG, "Setting retries to %d", retries);
4356 base->global_max_retransmits = retries;
4357 } else if (str_matches_option(option, "randomize-case:")) {
4358 int randcase = strtoint(val);
4359 if (randcase == -1) return -1;
4360 if (!(flags & DNS_OPTION_MISC)) return 0;
4361 base->global_randomize_case = randcase;
4362 } else if (str_matches_option(option, "bind-to:")) {
4363 /* XXX This only applies to successive nameservers, not
4364 * to already-configured ones. We might want to fix that. */
4365 int len = sizeof(base->global_outgoing_address);
4366 if (!(flags & DNS_OPTION_NAMESERVERS)) return 0;
4367 if (evutil_parse_sockaddr_port(val,
4368 (struct sockaddr*)&base->global_outgoing_address, &len))
4370 base->global_outgoing_addrlen = len;
4371 } else if (str_matches_option(option, "initial-probe-timeout:")) {
4373 if (evdns_strtotimeval(val, &tv) == -1) return -1;
4374 if (tv.tv_sec > 3600)
4376 if (!(flags & DNS_OPTION_MISC)) return 0;
4377 log(EVDNS_LOG_DEBUG, "Setting initial probe timeout to %s",
4379 memcpy(&base->global_nameserver_probe_initial_timeout, &tv,
4381 } else if (str_matches_option(option, "max-probe-timeout:")) {
4382 const int max_probe_timeout = strtoint_clipped(val, 1, 3600);
4383 if (max_probe_timeout == -1) return -1;
4384 if (!(flags & DNS_OPTION_MISC)) return 0;
4385 log(EVDNS_LOG_DEBUG, "Setting maximum probe timeout to %d",
4387 base->ns_max_probe_timeout = max_probe_timeout;
4388 if (base->global_nameserver_probe_initial_timeout.tv_sec > max_probe_timeout) {
4389 base->global_nameserver_probe_initial_timeout.tv_sec = max_probe_timeout;
4390 base->global_nameserver_probe_initial_timeout.tv_usec = 0;
4391 log(EVDNS_LOG_DEBUG, "Setting initial probe timeout to %s",
4394 } else if (str_matches_option(option, "probe-backoff-factor:")) {
4395 const int backoff_backtor = strtoint_clipped(val, 1, 10);
4396 if (backoff_backtor == -1) return -1;
4397 if (!(flags & DNS_OPTION_MISC)) return 0;
4398 log(EVDNS_LOG_DEBUG, "Setting probe timeout backoff factor to %d",
4400 base->ns_timeout_backoff_factor = backoff_backtor;
4401 } else if (str_matches_option(option, "so-rcvbuf:")) {
4402 int buf = strtoint(val);
4403 if (buf == -1) return -1;
4404 if (!(flags & DNS_OPTION_MISC)) return 0;
4405 log(EVDNS_LOG_DEBUG, "Setting SO_RCVBUF to %s", val);
4406 base->so_rcvbuf = buf;
4407 } else if (str_matches_option(option, "so-sndbuf:")) {
4408 int buf = strtoint(val);
4409 if (buf == -1) return -1;
4410 if (!(flags & DNS_OPTION_MISC)) return 0;
4411 log(EVDNS_LOG_DEBUG, "Setting SO_SNDBUF to %s", val);
4412 base->so_sndbuf = buf;
4413 } else if (str_matches_option(option, "tcp-idle-timeout:")) {
4415 if (evdns_strtotimeval(val, &tv) == -1) return -1;
4416 if (!(flags & DNS_OPTION_MISC)) return 0;
4417 log(EVDNS_LOG_DEBUG, "Setting tcp idle timeout to %s", val);
4418 memcpy(&base->global_tcp_idle_timeout, &tv, sizeof(tv));
4419 } else if (str_matches_option(option, "use-vc:")) {
4420 if (!(flags & DNS_OPTION_MISC)) return 0;
4421 if (val && strlen(val)) return -1;
4422 log(EVDNS_LOG_DEBUG, "Setting use-vc option");
4423 base->global_tcp_flags |= DNS_QUERY_USEVC;
4424 } else if (str_matches_option(option, "ignore-tc:")) {
4425 if (!(flags & DNS_OPTION_MISC)) return 0;
4426 if (val && strlen(val)) return -1;
4427 log(EVDNS_LOG_DEBUG, "Setting ignore-tc option");
4428 base->global_tcp_flags |= DNS_QUERY_IGNTC;
4429 } else if (str_matches_option(option, "edns-udp-size:")) {
4430 const int sz = strtoint_clipped(val, DNS_MAX_UDP_SIZE, EDNS_MAX_UDP_SIZE);
4431 if (sz == -1) return -1;
4432 if (!(flags & DNS_OPTION_MISC)) return 0;
4433 log(EVDNS_LOG_DEBUG, "Setting edns-udp-size to %d", sz);
4434 base->global_max_udp_size = sz;
4440 evdns_set_option(const char *option, const char *val, int flags)
4443 current_base = evdns_base_new(NULL, 0);
4444 return evdns_base_set_option(current_base, option, val);
4448 resolv_conf_parse_line(struct evdns_base *base, char *const start, int flags) {
4450 static const char *const delims = " \t";
4451 #define NEXT_TOKEN strtok_r(NULL, delims, &strtok_state)
4454 char *const first_token = strtok_r(start, delims, &strtok_state);
4455 ASSERT_LOCKED(base);
4456 if (!first_token) return;
4458 if (!strcmp(first_token, "nameserver") && (flags & DNS_OPTION_NAMESERVERS)) {
4459 const char *const nameserver = NEXT_TOKEN;
4462 evdns_base_nameserver_ip_add(base, nameserver);
4463 } else if (!strcmp(first_token, "domain") && (flags & DNS_OPTION_SEARCH)) {
4464 const char *const domain = NEXT_TOKEN;
4466 search_postfix_clear(base);
4467 search_postfix_add(base, domain);
4469 } else if (!strcmp(first_token, "search") && (flags & DNS_OPTION_SEARCH)) {
4471 search_postfix_clear(base);
4473 while ((domain = NEXT_TOKEN)) {
4474 search_postfix_add(base, domain);
4476 search_reverse(base);
4477 } else if (!strcmp(first_token, "options")) {
4479 while ((option = NEXT_TOKEN)) {
4480 const char *val = strchr(option, ':');
4481 evdns_base_set_option_impl(base, option, val ? val+1 : "", flags);
4487 /* exported function */
4490 /* 1 failed to open file */
4491 /* 2 failed to stat file */
4492 /* 3 file too large */
4493 /* 4 out of memory */
4494 /* 5 short read from file */
4496 evdns_base_resolv_conf_parse(struct evdns_base *base, int flags, const char *const filename) {
4499 res = evdns_base_resolv_conf_parse_impl(base, flags, filename);
4505 evdns_get_default_hosts_filename(void)
4508 /* Windows is a little coy about where it puts its configuration
4509 * files. Sure, they're _usually_ in C:\windows\system32, but
4510 * there's no reason in principle they couldn't be in
4511 * W:\hoboken chicken emergency\
4513 char path[MAX_PATH+1];
4514 static const char hostfile[] = "\\drivers\\etc\\hosts";
4518 if (! SHGetSpecialFolderPathA(NULL, path, CSIDL_SYSTEM, 0))
4520 len_out = strlen(path)+strlen(hostfile)+1;
4521 path_out = mm_malloc(len_out);
4522 evutil_snprintf(path_out, len_out, "%s%s", path, hostfile);
4525 return mm_strdup("/etc/hosts");
4530 evdns_base_resolv_conf_parse_impl(struct evdns_base *base, int flags, const char *const filename) {
4537 log(EVDNS_LOG_DEBUG, "Parsing resolv.conf file %s", filename);
4539 add_default = flags & DNS_OPTION_NAMESERVERS;
4540 if (flags & DNS_OPTION_NAMESERVERS_NO_DEFAULT)
4543 if (flags & DNS_OPTION_HOSTSFILE) {
4544 char *fname = evdns_get_default_hosts_filename();
4545 evdns_base_load_hosts(base, fname);
4551 evdns_resolv_set_defaults(base, flags);
4555 if ((err = evutil_read_file_(filename, &resolv, &n, 0)) < 0) {
4558 evdns_resolv_set_defaults(base, flags);
4567 char *const newline = strchr(start, '\n');
4569 resolv_conf_parse_line(base, start, flags);
4573 resolv_conf_parse_line(base, start, flags);
4574 start = newline + 1;
4578 if (!base->server_head && add_default) {
4579 /* no nameservers were configured. */
4580 evdns_base_nameserver_ip_add(base, "127.0.0.1");
4583 if (flags & DNS_OPTION_SEARCH && (!base->global_search_state || base->global_search_state->num_domains == 0)) {
4584 search_set_from_hostname(base);
4592 evdns_resolv_conf_parse(int flags, const char *const filename) {
4594 current_base = evdns_base_new(NULL, 0);
4595 return evdns_base_resolv_conf_parse(current_base, flags, filename);
4600 /* Add multiple nameservers from a space-or-comma-separated list. */
4602 evdns_nameserver_ip_add_line(struct evdns_base *base, const char *ips) {
4606 ASSERT_LOCKED(base);
4608 while (isspace(*ips) || *ips == ',' || *ips == '\t')
4611 while (isdigit(*ips) || *ips == '.' || *ips == ':' ||
4612 *ips=='[' || *ips==']')
4614 buf = mm_malloc(ips-addr+1);
4616 memcpy(buf, addr, ips-addr);
4617 buf[ips-addr] = '\0';
4618 r = evdns_base_nameserver_ip_add(base, buf);
4625 typedef DWORD(WINAPI *GetNetworkParams_fn_t)(FIXED_INFO *, DWORD*);
4627 /* Use the windows GetNetworkParams interface in iphlpapi.dll to */
4628 /* figure out what our nameservers are. */
4630 load_nameservers_with_getnetworkparams(struct evdns_base *base)
4632 /* Based on MSDN examples and inspection of c-ares code. */
4635 ULONG size = sizeof(FIXED_INFO);
4637 int status = 0, r, added_any;
4639 GetNetworkParams_fn_t fn;
4641 ASSERT_LOCKED(base);
4642 if (!(handle = evutil_load_windows_system_library_(
4643 TEXT("iphlpapi.dll")))) {
4644 log(EVDNS_LOG_WARN, "Could not open iphlpapi.dll");
4648 if (!(fn = (GetNetworkParams_fn_t) GetProcAddress(handle, "GetNetworkParams"))) {
4649 log(EVDNS_LOG_WARN, "Could not get address of function.");
4654 buf = mm_malloc(size);
4655 if (!buf) { status = 4; goto done; }
4657 r = fn(fixed, &size);
4658 if (r != ERROR_SUCCESS && r != ERROR_BUFFER_OVERFLOW) {
4662 if (r != ERROR_SUCCESS) {
4664 buf = mm_malloc(size);
4665 if (!buf) { status = 4; goto done; }
4667 r = fn(fixed, &size);
4668 if (r != ERROR_SUCCESS) {
4669 log(EVDNS_LOG_DEBUG, "fn() failed.");
4675 EVUTIL_ASSERT(fixed);
4677 ns = &(fixed->DnsServerList);
4679 r = evdns_nameserver_ip_add_line(base, ns->IpAddress.String);
4681 log(EVDNS_LOG_DEBUG,"Could not add nameserver %s to list,error: %d",
4682 (ns->IpAddress.String),(int)GetLastError());
4686 log(EVDNS_LOG_DEBUG,"Successfully added %s as nameserver",ns->IpAddress.String);
4693 log(EVDNS_LOG_DEBUG, "No nameservers added.");
4704 FreeLibrary(handle);
4709 config_nameserver_from_reg_key(struct evdns_base *base, HKEY key, const TCHAR *subkey)
4712 DWORD bufsz = 0, type = 0;
4715 ASSERT_LOCKED(base);
4716 if (RegQueryValueEx(key, subkey, 0, &type, NULL, &bufsz)
4719 if (!(buf = mm_malloc(bufsz)))
4722 if (RegQueryValueEx(key, subkey, 0, &type, (LPBYTE)buf, &bufsz)
4723 == ERROR_SUCCESS && bufsz > 1) {
4724 status = evdns_nameserver_ip_add_line(base,buf);
4731 #define SERVICES_KEY TEXT("System\\CurrentControlSet\\Services\\")
4732 #define WIN_NS_9X_KEY SERVICES_KEY TEXT("VxD\\MSTCP")
4733 #define WIN_NS_NT_KEY SERVICES_KEY TEXT("Tcpip\\Parameters")
4736 load_nameservers_from_registry(struct evdns_base *base)
4740 #define TRY(k, name) \
4741 if (!found && config_nameserver_from_reg_key(base,k,TEXT(name)) == 0) { \
4742 log(EVDNS_LOG_DEBUG,"Found nameservers in %s/%s",#k,name); \
4744 } else if (!found) { \
4745 log(EVDNS_LOG_DEBUG,"Didn't find nameservers in %s/%s", \
4749 ASSERT_LOCKED(base);
4751 if (((int)GetVersion()) > 0) { /* NT */
4752 HKEY nt_key = 0, interfaces_key = 0;
4754 if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WIN_NS_NT_KEY, 0,
4755 KEY_READ, &nt_key) != ERROR_SUCCESS) {
4756 log(EVDNS_LOG_DEBUG,"Couldn't open nt key, %d",(int)GetLastError());
4759 r = RegOpenKeyEx(nt_key, TEXT("Interfaces"), 0,
4760 KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS,
4762 if (r != ERROR_SUCCESS) {
4763 log(EVDNS_LOG_DEBUG,"Couldn't open interfaces key, %d",(int)GetLastError());
4766 TRY(nt_key, "NameServer");
4767 TRY(nt_key, "DhcpNameServer");
4768 TRY(interfaces_key, "NameServer");
4769 TRY(interfaces_key, "DhcpNameServer");
4770 RegCloseKey(interfaces_key);
4771 RegCloseKey(nt_key);
4774 if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, WIN_NS_9X_KEY, 0,
4775 KEY_READ, &win_key) != ERROR_SUCCESS) {
4776 log(EVDNS_LOG_DEBUG, "Couldn't open registry key, %d", (int)GetLastError());
4779 TRY(win_key, "NameServer");
4780 RegCloseKey(win_key);
4784 log(EVDNS_LOG_WARN,"Didn't find any nameservers.");
4787 return found ? 0 : -1;
4792 evdns_base_config_windows_nameservers(struct evdns_base *base)
4797 base = current_base;
4801 fname = evdns_get_default_hosts_filename();
4802 log(EVDNS_LOG_DEBUG, "Loading hosts entries from %s", fname);
4803 evdns_base_load_hosts(base, fname);
4807 if (load_nameservers_with_getnetworkparams(base) == 0) {
4811 r = load_nameservers_from_registry(base);
4818 evdns_config_windows_nameservers(void)
4820 if (!current_base) {
4821 current_base = evdns_base_new(NULL, 1);
4822 return current_base == NULL ? -1 : 0;
4824 return evdns_base_config_windows_nameservers(current_base);
4830 evdns_base_new(struct event_base *event_base, int flags)
4832 struct evdns_base *base;
4834 if (evutil_secure_rng_init() < 0) {
4835 log(EVDNS_LOG_WARN, "Unable to seed random number generator; "
4840 /* Give the evutil library a hook into its evdns-enabled
4841 * functionality. We can't just call evdns_getaddrinfo directly or
4842 * else libevent-core will depend on libevent-extras. */
4843 evutil_set_evdns_getaddrinfo_fn_(evdns_getaddrinfo);
4844 evutil_set_evdns_getaddrinfo_cancel_fn_(evdns_getaddrinfo_cancel);
4846 base = mm_malloc(sizeof(struct evdns_base));
4849 memset(base, 0, sizeof(struct evdns_base));
4850 base->req_waiting_head = NULL;
4852 EVTHREAD_ALLOC_LOCK(base->lock, EVTHREAD_LOCKTYPE_RECURSIVE);
4855 /* Set max requests inflight and allocate req_heads. */
4856 base->req_heads = NULL;
4858 evdns_base_set_max_requests_inflight(base, 64);
4860 base->server_head = NULL;
4861 base->event_base = event_base;
4862 base->global_good_nameservers = base->global_requests_inflight =
4863 base->global_requests_waiting = 0;
4865 base->global_timeout.tv_sec = 5;
4866 base->global_timeout.tv_usec = 0;
4867 base->global_max_reissues = 1;
4868 base->global_max_retransmits = 3;
4869 base->global_max_nameserver_timeout = 3;
4870 base->global_search_state = NULL;
4871 base->global_randomize_case = 1;
4872 base->global_max_udp_size = DNS_MAX_UDP_SIZE;
4873 base->global_getaddrinfo_allow_skew.tv_sec = 3;
4874 base->global_getaddrinfo_allow_skew.tv_usec = 0;
4875 base->global_nameserver_probe_initial_timeout.tv_sec = 10;
4876 base->global_nameserver_probe_initial_timeout.tv_usec = 0;
4877 base->ns_max_probe_timeout = 3600;
4878 base->ns_timeout_backoff_factor = 3;
4879 base->global_tcp_idle_timeout.tv_sec = CLIENT_IDLE_CONN_TIMEOUT;
4881 TAILQ_INIT(&base->hostsdb);
4883 #define EVDNS_BASE_ALL_FLAGS ( \
4884 EVDNS_BASE_INITIALIZE_NAMESERVERS | \
4885 EVDNS_BASE_DISABLE_WHEN_INACTIVE | \
4886 EVDNS_BASE_NAMESERVERS_NO_DEFAULT | \
4889 if (flags & ~EVDNS_BASE_ALL_FLAGS) {
4890 flags = EVDNS_BASE_INITIALIZE_NAMESERVERS;
4892 "Unrecognized flag passed to evdns_base_new(). Assuming "
4893 "you meant EVDNS_BASE_INITIALIZE_NAMESERVERS.");
4895 #undef EVDNS_BASE_ALL_FLAGS
4897 if (flags & EVDNS_BASE_INITIALIZE_NAMESERVERS) {
4899 int opts = DNS_OPTIONS_ALL;
4900 if (flags & EVDNS_BASE_NAMESERVERS_NO_DEFAULT) {
4901 opts |= DNS_OPTION_NAMESERVERS_NO_DEFAULT;
4905 r = evdns_base_config_windows_nameservers(base);
4907 r = evdns_base_resolv_conf_parse(base, opts, "/etc/resolv.conf");
4910 evdns_base_free_and_unlock(base, 0);
4914 if (flags & EVDNS_BASE_DISABLE_WHEN_INACTIVE) {
4915 base->disable_when_inactive = 1;
4925 struct evdns_base *base = evdns_base_new(NULL, 1);
4927 current_base = base;
4935 evdns_err_to_string(int err)
4938 case DNS_ERR_NONE: return "no error";
4939 case DNS_ERR_FORMAT: return "misformatted query";
4940 case DNS_ERR_SERVERFAILED: return "server failed";
4941 case DNS_ERR_NOTEXIST: return "name does not exist";
4942 case DNS_ERR_NOTIMPL: return "query not implemented";
4943 case DNS_ERR_REFUSED: return "refused";
4945 case DNS_ERR_TRUNCATED: return "reply truncated or ill-formed";
4946 case DNS_ERR_UNKNOWN: return "unknown";
4947 case DNS_ERR_TIMEOUT: return "request timed out";
4948 case DNS_ERR_SHUTDOWN: return "dns subsystem shut down";
4949 case DNS_ERR_CANCEL: return "dns request canceled";
4950 case DNS_ERR_NODATA: return "no records in the reply";
4951 default: return "[Unknown error code]";
4956 evdns_nameserver_free(struct nameserver *server)
4958 if (server->socket >= 0)
4959 evutil_closesocket(server->socket);
4960 (void) event_del(&server->event);
4961 event_debug_unassign(&server->event);
4962 if (server->state == 0)
4963 (void) event_del(&server->timeout_event);
4964 if (server->probe_request) {
4965 evdns_cancel_request(server->base, server->probe_request);
4966 server->probe_request = NULL;
4968 event_debug_unassign(&server->timeout_event);
4969 disconnect_and_free_connection(server->connection);
4974 evdns_base_free_and_unlock(struct evdns_base *base, int fail_requests)
4976 struct nameserver *server, *server_next;
4977 struct search_domain *dom, *dom_next;
4980 /* Requires that we hold the lock. */
4982 /* TODO(nickm) we might need to refcount here. */
4984 while (base->req_waiting_head) {
4986 reply_schedule_callback(base->req_waiting_head, 0, DNS_ERR_SHUTDOWN, NULL);
4987 request_finished(base->req_waiting_head, &base->req_waiting_head, 1);
4989 for (i = 0; i < base->n_req_heads; ++i) {
4990 while (base->req_heads[i]) {
4992 reply_schedule_callback(base->req_heads[i], 0, DNS_ERR_SHUTDOWN, NULL);
4993 request_finished(base->req_heads[i], &REQ_HEAD(base, base->req_heads[i]->trans_id), 1);
4996 base->global_requests_inflight = base->global_requests_waiting = 0;
4998 for (server = base->server_head; server; server = server_next) {
4999 server_next = server->next;
5000 /** already done something before */
5001 server->probe_request = NULL;
5002 evdns_nameserver_free(server);
5003 if (server_next == base->server_head)
5006 base->server_head = NULL;
5007 base->global_good_nameservers = 0;
5009 if (base->global_search_state) {
5010 for (dom = base->global_search_state->head; dom; dom = dom_next) {
5011 dom_next = dom->next;
5014 mm_free(base->global_search_state);
5015 base->global_search_state = NULL;
5019 struct hosts_entry *victim;
5020 while ((victim = TAILQ_FIRST(&base->hostsdb))) {
5021 TAILQ_REMOVE(&base->hostsdb, victim, next);
5026 mm_free(base->req_heads);
5029 EVTHREAD_FREE_LOCK(base->lock, EVTHREAD_LOCKTYPE_RECURSIVE);
5035 evdns_base_free(struct evdns_base *base, int fail_requests)
5038 evdns_base_free_and_unlock(base, fail_requests);
5042 evdns_base_clear_host_addresses(struct evdns_base *base)
5044 struct hosts_entry *victim;
5046 while ((victim = TAILQ_FIRST(&base->hostsdb))) {
5047 TAILQ_REMOVE(&base->hostsdb, victim, next);
5054 evdns_shutdown(int fail_requests)
5057 struct evdns_base *b = current_base;
5058 current_base = NULL;
5059 evdns_base_free(b, fail_requests);
5061 evdns_log_fn = NULL;
5065 evdns_base_parse_hosts_line(struct evdns_base *base, char *line)
5068 static const char *const delims = " \t";
5069 char *const addr = strtok_r(line, delims, &strtok_state);
5070 char *hostname, *hash;
5071 struct sockaddr_storage ss;
5072 int socklen = sizeof(ss);
5073 ASSERT_LOCKED(base);
5075 #define NEXT_TOKEN strtok_r(NULL, delims, &strtok_state)
5077 if (!addr || *addr == '#')
5080 memset(&ss, 0, sizeof(ss));
5081 if (evutil_parse_sockaddr_port(addr, (struct sockaddr*)&ss, &socklen)<0)
5083 if (socklen > (int)sizeof(struct sockaddr_in6))
5086 if (sockaddr_getport((struct sockaddr*)&ss))
5089 while ((hostname = NEXT_TOKEN)) {
5090 struct hosts_entry *he;
5092 if ((hash = strchr(hostname, '#'))) {
5093 if (hash == hostname)
5098 namelen = strlen(hostname);
5100 he = mm_calloc(1, sizeof(struct hosts_entry)+namelen);
5103 EVUTIL_ASSERT(socklen <= (int)sizeof(he->addr));
5104 memcpy(&he->addr, &ss, socklen);
5105 memcpy(he->hostname, hostname, namelen+1);
5106 he->addrlen = socklen;
5108 TAILQ_INSERT_TAIL(&base->hostsdb, he, next);
5119 evdns_base_load_hosts_impl(struct evdns_base *base, const char *hosts_fname)
5121 char *str=NULL, *cp, *eol;
5125 ASSERT_LOCKED(base);
5127 if (hosts_fname == NULL ||
5128 (err = evutil_read_file_(hosts_fname, &str, &len, 0)) < 0) {
5130 strlcpy(tmp, "127.0.0.1 localhost", sizeof(tmp));
5131 evdns_base_parse_hosts_line(base, tmp);
5132 strlcpy(tmp, "::1 localhost", sizeof(tmp));
5133 evdns_base_parse_hosts_line(base, tmp);
5134 return err ? -1 : 0;
5137 /* This will break early if there is a NUL in the hosts file.
5138 * Probably not a problem.*/
5141 eol = strchr(cp, '\n');
5145 evdns_base_parse_hosts_line(base, cp);
5148 evdns_base_parse_hosts_line(base, cp);
5158 evdns_base_load_hosts(struct evdns_base *base, const char *hosts_fname)
5162 base = current_base;
5164 res = evdns_base_load_hosts_impl(base, hosts_fname);
5169 /* A single request for a getaddrinfo, either v4 or v6. */
5170 struct getaddrinfo_subrequest {
5171 struct evdns_request *r;
5175 /* State data used to implement an in-progress getaddrinfo. */
5176 struct evdns_getaddrinfo_request {
5177 struct evdns_base *evdns_base;
5178 /* Copy of the modified 'hints' data that we'll use to build
5180 struct evutil_addrinfo hints;
5181 /* The callback to invoke when we're done */
5182 evdns_getaddrinfo_cb user_cb;
5183 /* User-supplied data to give to the callback. */
5185 /* The port to use when building sockaddrs. */
5187 /* The sub_request for an A record (if any) */
5188 struct getaddrinfo_subrequest ipv4_request;
5189 /* The sub_request for an AAAA record (if any) */
5190 struct getaddrinfo_subrequest ipv6_request;
5192 /* The cname result that we were told (if any) */
5195 /* If we have one request answered and one request still inflight,
5196 * then this field holds the answer from the first request... */
5197 struct evutil_addrinfo *pending_result;
5198 /* And this event is a timeout that will tell us to cancel the second
5199 * request if it's taking a long time. */
5200 struct event timeout;
5202 /* And this field holds the error code from the first request... */
5204 /* If this is set, the user canceled this request. */
5205 unsigned user_canceled : 1;
5206 /* If this is set, the user can no longer cancel this request; we're
5207 * just waiting for the free. */
5208 unsigned request_done : 1;
5211 /* Convert an evdns errors to the equivalent getaddrinfo error. */
5213 evdns_err_to_getaddrinfo_err(int e1)
5215 /* XXX Do this better! */
5216 if (e1 == DNS_ERR_NONE)
5218 else if (e1 == DNS_ERR_NOTEXIST)
5219 return EVUTIL_EAI_NONAME;
5221 return EVUTIL_EAI_FAIL;
5224 /* Return the more informative of two getaddrinfo errors. */
5226 getaddrinfo_merge_err(int e1, int e2)
5228 /* XXXX be cleverer here. */
5236 free_getaddrinfo_request(struct evdns_getaddrinfo_request *data)
5238 /* DO NOT CALL this if either of the requests is pending. Only once
5239 * both callbacks have been invoked is it safe to free the request */
5240 if (data->pending_result)
5241 evutil_freeaddrinfo(data->pending_result);
5242 if (data->cname_result)
5243 mm_free(data->cname_result);
5244 event_del(&data->timeout);
5250 add_cname_to_reply(struct evdns_getaddrinfo_request *data,
5251 struct evutil_addrinfo *ai)
5253 if (data->cname_result && ai) {
5254 ai->ai_canonname = data->cname_result;
5255 data->cname_result = NULL;
5259 /* Callback: invoked when one request in a mixed-format A/AAAA getaddrinfo
5260 * request has finished, but the other one took too long to answer. Pass
5261 * along the answer we got, and cancel the other request.
5264 evdns_getaddrinfo_timeout_cb(evutil_socket_t fd, short what, void *ptr)
5266 int v4_timedout = 0, v6_timedout = 0;
5267 struct evdns_getaddrinfo_request *data = ptr;
5269 /* Cancel any pending requests, and note which one */
5270 if (data->ipv4_request.r) {
5271 /* XXXX This does nothing if the request's callback is already
5272 * running (pending_cb is set). */
5273 evdns_cancel_request(NULL, data->ipv4_request.r);
5275 EVDNS_LOCK(data->evdns_base);
5276 ++data->evdns_base->getaddrinfo_ipv4_timeouts;
5277 EVDNS_UNLOCK(data->evdns_base);
5279 if (data->ipv6_request.r) {
5280 /* XXXX This does nothing if the request's callback is already
5281 * running (pending_cb is set). */
5282 evdns_cancel_request(NULL, data->ipv6_request.r);
5284 EVDNS_LOCK(data->evdns_base);
5285 ++data->evdns_base->getaddrinfo_ipv6_timeouts;
5286 EVDNS_UNLOCK(data->evdns_base);
5289 /* We only use this timeout callback when we have an answer for
5291 EVUTIL_ASSERT(!v4_timedout || !v6_timedout);
5293 /* Report the outcome of the other request that didn't time out. */
5294 if (data->pending_result) {
5295 add_cname_to_reply(data, data->pending_result);
5296 data->user_cb(0, data->pending_result, data->user_data);
5297 data->pending_result = NULL;
5299 int e = data->pending_error;
5301 e = EVUTIL_EAI_AGAIN;
5302 data->user_cb(e, NULL, data->user_data);
5305 data->user_cb = NULL; /* prevent double-call if evdns callbacks are
5306 * in-progress. XXXX It would be better if this
5307 * weren't necessary. */
5309 if (!v4_timedout && !v6_timedout) {
5310 /* should be impossible? XXXX */
5311 free_getaddrinfo_request(data);
5316 evdns_getaddrinfo_set_timeout(struct evdns_base *evdns_base,
5317 struct evdns_getaddrinfo_request *data)
5319 return event_add(&data->timeout, &evdns_base->global_getaddrinfo_allow_skew);
5323 evdns_result_is_answer(int result)
5325 return (result != DNS_ERR_NOTIMPL && result != DNS_ERR_REFUSED &&
5326 result != DNS_ERR_SERVERFAILED && result != DNS_ERR_CANCEL);
5330 evdns_getaddrinfo_gotresolve(int result, char type, int count,
5331 int ttl, void *addresses, void *arg)
5334 struct getaddrinfo_subrequest *req = arg;
5335 struct getaddrinfo_subrequest *other_req;
5336 struct evdns_getaddrinfo_request *data;
5338 struct evutil_addrinfo *res;
5340 struct sockaddr_in sin;
5341 struct sockaddr_in6 sin6;
5342 struct sockaddr *sa;
5343 int socklen, addrlen;
5348 EVUTIL_ASSERT(req->type == DNS_IPv4_A || req->type == DNS_IPv6_AAAA);
5349 if (req->type == DNS_IPv4_A) {
5350 data = EVUTIL_UPCAST(req, struct evdns_getaddrinfo_request, ipv4_request);
5351 other_req = &data->ipv6_request;
5353 data = EVUTIL_UPCAST(req, struct evdns_getaddrinfo_request, ipv6_request);
5354 other_req = &data->ipv4_request;
5357 /** Called from evdns_base_free() with @fail_requests == 1 */
5358 if (result != DNS_ERR_SHUTDOWN) {
5359 EVDNS_LOCK(data->evdns_base);
5360 if (evdns_result_is_answer(result)) {
5361 if (req->type == DNS_IPv4_A)
5362 ++data->evdns_base->getaddrinfo_ipv4_answered;
5364 ++data->evdns_base->getaddrinfo_ipv6_answered;
5366 user_canceled = data->user_canceled;
5367 if (other_req->r == NULL)
5368 data->request_done = 1;
5369 EVDNS_UNLOCK(data->evdns_base);
5371 data->evdns_base = NULL;
5372 user_canceled = data->user_canceled;
5377 if (result == DNS_ERR_CANCEL && ! user_canceled) {
5378 /* Internal cancel request from timeout or internal error.
5379 * we already answered the user. */
5380 if (other_req->r == NULL)
5381 free_getaddrinfo_request(data);
5385 if (data->user_cb == NULL) {
5386 /* We already answered. XXXX This shouldn't be needed; see
5387 * comments in evdns_getaddrinfo_timeout_cb */
5388 free_getaddrinfo_request(data);
5392 if (result == DNS_ERR_NONE) {
5394 err = EVUTIL_EAI_NODATA;
5398 err = evdns_err_to_getaddrinfo_err(result);
5402 /* Looks like we got an error. */
5404 /* The other request is still working; maybe it will
5406 /* XXXX handle failure from set_timeout */
5407 if (result != DNS_ERR_SHUTDOWN) {
5408 evdns_getaddrinfo_set_timeout(data->evdns_base, data);
5410 data->pending_error = err;
5414 if (user_canceled) {
5415 data->user_cb(EVUTIL_EAI_CANCEL, NULL, data->user_data);
5416 } else if (data->pending_result) {
5417 /* If we have an answer waiting, and we weren't
5418 * canceled, ignore this error. */
5419 add_cname_to_reply(data, data->pending_result);
5420 data->user_cb(0, data->pending_result, data->user_data);
5421 data->pending_result = NULL;
5423 if (data->pending_error)
5424 err = getaddrinfo_merge_err(err,
5425 data->pending_error);
5426 data->user_cb(err, NULL, data->user_data);
5428 free_getaddrinfo_request(data);
5430 } else if (user_canceled) {
5432 /* The other request is still working; let it hit this
5433 * callback with EVUTIL_EAI_CANCEL callback and report
5437 data->user_cb(EVUTIL_EAI_CANCEL, NULL, data->user_data);
5438 free_getaddrinfo_request(data);
5442 /* Looks like we got some answers. We should turn them into addrinfos
5443 * and then either queue those or return them all. */
5444 EVUTIL_ASSERT(type == DNS_IPv4_A || type == DNS_IPv6_AAAA);
5446 if (type == DNS_IPv4_A) {
5447 memset(&sin, 0, sizeof(sin));
5448 sin.sin_family = AF_INET;
5449 sin.sin_port = htons(data->port);
5450 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
5451 sin.sin_len = sizeof(sin);
5454 sa = (struct sockaddr *)&sin;
5455 socklen = sizeof(sin);
5457 addrp = &sin.sin_addr.s_addr;
5459 memset(&sin6, 0, sizeof(sin6));
5460 sin6.sin6_family = AF_INET6;
5461 sin6.sin6_port = htons(data->port);
5462 #ifdef EVENT__HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
5463 sin6.sin6_len = sizeof(sin6);
5466 sa = (struct sockaddr *)&sin6;
5467 socklen = sizeof(sin6);
5469 addrp = &sin6.sin6_addr.s6_addr;
5473 for (i=0; i < count; ++i) {
5474 struct evutil_addrinfo *ai;
5475 memcpy(addrp, ((char*)addresses)+i*addrlen, addrlen);
5476 ai = evutil_new_addrinfo_(sa, socklen, &data->hints);
5479 evdns_cancel_request(NULL, other_req->r);
5481 data->user_cb(EVUTIL_EAI_MEMORY, NULL, data->user_data);
5483 evutil_freeaddrinfo(res);
5485 if (other_req->r == NULL)
5486 free_getaddrinfo_request(data);
5489 res = evutil_addrinfo_append_(res, ai);
5493 /* The other request is still in progress; wait for it */
5494 /* XXXX handle failure from set_timeout */
5495 evdns_getaddrinfo_set_timeout(data->evdns_base, data);
5496 data->pending_result = res;
5499 /* The other request is done or never started; append its
5500 * results (if any) and return them. */
5501 if (data->pending_result) {
5502 if (req->type == DNS_IPv4_A)
5503 res = evutil_addrinfo_append_(res,
5504 data->pending_result);
5506 res = evutil_addrinfo_append_(
5507 data->pending_result, res);
5508 data->pending_result = NULL;
5511 /* Call the user callback. */
5512 add_cname_to_reply(data, res);
5513 data->user_cb(0, res, data->user_data);
5516 free_getaddrinfo_request(data);
5520 static struct hosts_entry *
5521 find_hosts_entry(struct evdns_base *base, const char *hostname,
5522 struct hosts_entry *find_after)
5524 struct hosts_entry *e;
5527 e = TAILQ_NEXT(find_after, next);
5529 e = TAILQ_FIRST(&base->hostsdb);
5531 for (; e; e = TAILQ_NEXT(e, next)) {
5532 if (!evutil_ascii_strcasecmp(e->hostname, hostname))
5539 evdns_getaddrinfo_fromhosts(struct evdns_base *base,
5540 const char *nodename, struct evutil_addrinfo *hints, ev_uint16_t port,
5541 struct evutil_addrinfo **res)
5544 struct hosts_entry *e;
5545 struct evutil_addrinfo *ai=NULL;
5546 int f = hints->ai_family;
5549 for (e = find_hosts_entry(base, nodename, NULL); e;
5550 e = find_hosts_entry(base, nodename, e)) {
5551 struct evutil_addrinfo *ai_new;
5553 if ((e->addr.sa.sa_family == AF_INET && f == PF_INET6) ||
5554 (e->addr.sa.sa_family == AF_INET6 && f == PF_INET))
5556 ai_new = evutil_new_addrinfo_(&e->addr.sa, e->addrlen, hints);
5561 sockaddr_setport(ai_new->ai_addr, port);
5562 ai = evutil_addrinfo_append_(ai, ai_new);
5567 /* Note that we return an empty answer if we found entries for
5568 * this hostname but none were of the right address type. */
5573 evutil_freeaddrinfo(ai);
5578 struct evdns_getaddrinfo_request *
5579 evdns_getaddrinfo(struct evdns_base *dns_base,
5580 const char *nodename, const char *servname,
5581 const struct evutil_addrinfo *hints_in,
5582 evdns_getaddrinfo_cb cb, void *arg)
5584 struct evdns_getaddrinfo_request *data;
5585 struct evutil_addrinfo hints;
5586 struct evutil_addrinfo *res = NULL;
5593 dns_base = current_base;
5596 "Call to getaddrinfo_async with no "
5597 "evdns_base configured.");
5598 cb(EVUTIL_EAI_FAIL, NULL, arg); /* ??? better error? */
5603 /* If we _must_ answer this immediately, do so. */
5604 if ((hints_in && (hints_in->ai_flags & EVUTIL_AI_NUMERICHOST))) {
5606 err = evutil_getaddrinfo(nodename, servname, hints_in, &res);
5612 memcpy(&hints, hints_in, sizeof(hints));
5614 memset(&hints, 0, sizeof(hints));
5615 hints.ai_family = PF_UNSPEC;
5618 evutil_adjust_hints_for_addrconfig_(&hints);
5620 /* Now try to see if we _can_ answer immediately. */
5621 /* (It would be nice to do this by calling getaddrinfo directly, with
5622 * AI_NUMERICHOST, on plaforms that have it, but we can't: there isn't
5623 * a reliable way to distinguish the "that wasn't a numeric host!" case
5624 * from any other EAI_NONAME cases.) */
5625 err = evutil_getaddrinfo_common_(nodename, servname, &hints, &res, &port);
5626 if (err != EVUTIL_EAI_NEED_RESOLVE) {
5631 /* If there is an entry in the hosts file, we should give it now. */
5632 if (!evdns_getaddrinfo_fromhosts(dns_base, nodename, &hints, port, &res)) {
5637 /* Okay, things are serious now. We're going to need to actually
5640 data = mm_calloc(1,sizeof(struct evdns_getaddrinfo_request));
5642 cb(EVUTIL_EAI_MEMORY, NULL, arg);
5646 memcpy(&data->hints, &hints, sizeof(data->hints));
5647 data->port = (ev_uint16_t)port;
5648 data->ipv4_request.type = DNS_IPv4_A;
5649 data->ipv6_request.type = DNS_IPv6_AAAA;
5651 data->user_data = arg;
5652 data->evdns_base = dns_base;
5654 want_cname = (hints.ai_flags & EVUTIL_AI_CANONNAME);
5656 /* If we are asked for a PF_UNSPEC address, we launch two requests in
5657 * parallel: one for an A address and one for an AAAA address. We
5658 * can't send just one request, since many servers only answer one
5659 * question per DNS request.
5661 * Once we have the answer to one request, we allow for a short
5662 * timeout before we report it, to see if the other one arrives. If
5663 * they both show up in time, then we report both the answers.
5665 * If too many addresses of one type time out or fail, we should stop
5666 * launching those requests. (XXX we don't do that yet.)
5669 EVDNS_LOCK(dns_base);
5671 if (hints.ai_family != PF_INET6) {
5672 log(EVDNS_LOG_DEBUG, "Sending request for %s on ipv4 as %p",
5673 nodename, (void *)&data->ipv4_request);
5675 data->ipv4_request.r = evdns_base_resolve_ipv4(dns_base,
5676 nodename, 0, evdns_getaddrinfo_gotresolve,
5677 &data->ipv4_request);
5678 if (want_cname && data->ipv4_request.r)
5679 data->ipv4_request.r->current_req->put_cname_in_ptr =
5680 &data->cname_result;
5682 if (hints.ai_family != PF_INET) {
5683 log(EVDNS_LOG_DEBUG, "Sending request for %s on ipv6 as %p",
5684 nodename, (void *)&data->ipv6_request);
5686 data->ipv6_request.r = evdns_base_resolve_ipv6(dns_base,
5687 nodename, 0, evdns_getaddrinfo_gotresolve,
5688 &data->ipv6_request);
5689 if (want_cname && data->ipv6_request.r)
5690 data->ipv6_request.r->current_req->put_cname_in_ptr =
5691 &data->cname_result;
5694 evtimer_assign(&data->timeout, dns_base->event_base,
5695 evdns_getaddrinfo_timeout_cb, data);
5697 started = (data->ipv4_request.r || data->ipv6_request.r);
5699 EVDNS_UNLOCK(dns_base);
5705 cb(EVUTIL_EAI_FAIL, NULL, arg);
5711 evdns_getaddrinfo_cancel(struct evdns_getaddrinfo_request *data)
5713 EVDNS_LOCK(data->evdns_base);
5714 if (data->request_done) {
5715 EVDNS_UNLOCK(data->evdns_base);
5718 event_del(&data->timeout);
5719 data->user_canceled = 1;
5720 if (data->ipv4_request.r)
5721 evdns_cancel_request(data->evdns_base, data->ipv4_request.r);
5722 if (data->ipv6_request.r)
5723 evdns_cancel_request(data->evdns_base, data->ipv6_request.r);
5724 EVDNS_UNLOCK(data->evdns_base);