Restoring authorship annotation for <kikht@yandex-team.ru>. Commit 2 of 2.

1 files changed, 378 insertions, 378 deletions

diff --git a/contrib/libs/libevent/evdns.c b/contrib/libs/libevent/evdns.c
index 3db28df0e0..3468721a6d 100644
--- a/contrib/libs/libevent/evdns.c
+++ b/contrib/libs/libevent/evdns.c
@@ -49,35 +49,35 @@
  */
 
 #include "event2/event-config.h"
-#include "evconfig-private.h" 
+#include "evconfig-private.h"
+
+#include <sys/types.h>
 
-#include <sys/types.h> 
- 
 #ifndef _FORTIFY_SOURCE
 #define _FORTIFY_SOURCE 3
 #endif
 
 #include <string.h>
 #include <fcntl.h>
-#ifdef EVENT__HAVE_SYS_TIME_H 
+#ifdef EVENT__HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
-#ifdef EVENT__HAVE_STDINT_H 
+#ifdef EVENT__HAVE_STDINT_H
 #include <stdint.h>
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
-#ifdef EVENT__HAVE_UNISTD_H 
+#ifdef EVENT__HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <limits.h>
 #include <sys/stat.h>
 #include <stdio.h>
 #include <stdarg.h>
-#ifdef _WIN32 
+#ifdef _WIN32
 #include <winsock2.h>
-#include <winerror.h> 
+#include <winerror.h>
 #include <ws2tcpip.h>
 #ifndef _WIN32_IE
 #define _WIN32_IE 0x400
@@ -100,7 +100,7 @@
 #include "ipv6-internal.h"
 #include "util-internal.h"
 #include "evthread-internal.h"
-#ifdef _WIN32 
+#ifdef _WIN32
 #include <ctype.h>
 #include <winsock2.h>
 #include <windows.h>
@@ -112,13 +112,13 @@
 #include <arpa/inet.h>
 #endif
 
-#ifdef EVENT__HAVE_NETINET_IN6_H 
-#error #include <netinet/in6.h> 
-#endif 
- 
-#define EVDNS_LOG_DEBUG EVENT_LOG_DEBUG 
-#define EVDNS_LOG_WARN EVENT_LOG_WARN 
-#define EVDNS_LOG_MSG EVENT_LOG_MSG 
+#ifdef EVENT__HAVE_NETINET_IN6_H
+#error #include <netinet/in6.h>
+#endif
+
+#define EVDNS_LOG_DEBUG EVENT_LOG_DEBUG
+#define EVDNS_LOG_WARN EVENT_LOG_WARN
+#define EVDNS_LOG_MSG EVENT_LOG_MSG
 
 #ifndef HOST_NAME_MAX
 #define HOST_NAME_MAX 255
@@ -233,10 +233,10 @@ struct nameserver {
 	char choked;  /* true if we have an EAGAIN from this server's socket */
 	char write_waiting;  /* true if we are waiting for EV_WRITE events */
 	struct evdns_base *base;
- 
-	/* Number of currently inflight requests: used 
-	 * to track when we should add/del the event. */ 
-	int requests_inflight; 
+
+	/* Number of currently inflight requests: used
+	 * to track when we should add/del the event. */
+	int requests_inflight;
 };
 
 
@@ -254,7 +254,7 @@ struct evdns_server_port {
 	struct server_request *pending_replies;
 	struct event_base *event_base;
 
-#ifndef EVENT__DISABLE_THREAD_SUPPORT 
+#ifndef EVENT__DISABLE_THREAD_SUPPORT
 	void *lock;
 #endif
 };
@@ -347,9 +347,9 @@ struct evdns_base {
 
 	struct timeval global_getaddrinfo_allow_skew;
 
-	int so_rcvbuf; 
-	int so_sndbuf; 
- 
+	int so_rcvbuf;
+	int so_sndbuf;
+
 	int getaddrinfo_ipv4_timeouts;
 	int getaddrinfo_ipv6_timeouts;
 	int getaddrinfo_ipv4_answered;
@@ -359,11 +359,11 @@ struct evdns_base {
 
 	TAILQ_HEAD(hosts_list, hosts_entry) hostsdb;
 
-#ifndef EVENT__DISABLE_THREAD_SUPPORT 
+#ifndef EVENT__DISABLE_THREAD_SUPPORT
 	void *lock;
 #endif
- 
-	int disable_when_inactive; 
+
+	int disable_when_inactive;
 };
 
 struct hosts_entry {
@@ -416,14 +416,14 @@ static int evdns_base_resolv_conf_parse_impl(struct evdns_base *base, int flags,
 static int evdns_base_set_option_impl(struct evdns_base *base,
     const char *option, const char *val, int flags);
 static void evdns_base_free_and_unlock(struct evdns_base *base, int fail_requests);
-static void evdns_request_timeout_callback(evutil_socket_t fd, short events, void *arg); 
+static void evdns_request_timeout_callback(evutil_socket_t fd, short events, void *arg);
 
 static int strtoint(const char *const str);
 
-#ifdef EVENT__DISABLE_THREAD_SUPPORT 
-#define EVDNS_LOCK(base)  EVUTIL_NIL_STMT_ 
-#define EVDNS_UNLOCK(base) EVUTIL_NIL_STMT_ 
-#define ASSERT_LOCKED(base) EVUTIL_NIL_STMT_ 
+#ifdef EVENT__DISABLE_THREAD_SUPPORT
+#define EVDNS_LOCK(base)  EVUTIL_NIL_STMT_
+#define EVDNS_UNLOCK(base) EVUTIL_NIL_STMT_
+#define ASSERT_LOCKED(base) EVUTIL_NIL_STMT_
 #else
 #define EVDNS_LOCK(base)			\
 	EVLOCK_LOCK((base)->lock, 0)
@@ -447,24 +447,24 @@ evdns_set_log_fn(evdns_debug_log_fn_type fn)
 #define EVDNS_LOG_CHECK
 #endif
 
-static void evdns_log_(int severity, const char *fmt, ...) EVDNS_LOG_CHECK; 
+static void evdns_log_(int severity, const char *fmt, ...) EVDNS_LOG_CHECK;
 static void
-evdns_log_(int severity, const char *fmt, ...) 
+evdns_log_(int severity, const char *fmt, ...)
 {
 	va_list args;
 	va_start(args,fmt);
 	if (evdns_log_fn) {
-		char buf[512]; 
-		int is_warn = (severity == EVDNS_LOG_WARN); 
-		evutil_vsnprintf(buf, sizeof(buf), fmt, args); 
-		evdns_log_fn(is_warn, buf); 
+		char buf[512];
+		int is_warn = (severity == EVDNS_LOG_WARN);
+		evutil_vsnprintf(buf, sizeof(buf), fmt, args);
+		evdns_log_fn(is_warn, buf);
 	} else {
-		event_logv_(severity, NULL, fmt, args); 
+		event_logv_(severity, NULL, fmt, args);
 	}
-	va_end(args); 
+	va_end(args);
 }
 
-#define log evdns_log_ 
+#define log evdns_log_
 
 /* This walks the list of inflight requests to find the */
 /* one with a matching transaction id. Returns NULL on */
@@ -539,23 +539,23 @@ nameserver_probe_failed(struct nameserver *const ns) {
 		char addrbuf[128];
 		log(EVDNS_LOG_WARN,
 		    "Error from libevent when adding timer event for %s",
-		    evutil_format_sockaddr_port_( 
+		    evutil_format_sockaddr_port_(
 			    (struct sockaddr *)&ns->address,
 			    addrbuf, sizeof(addrbuf)));
 	}
 }
 
-static void 
-request_swap_ns(struct request *req, struct nameserver *ns) { 
-	if (ns && req->ns != ns) { 
-		EVUTIL_ASSERT(req->ns->requests_inflight > 0); 
-		req->ns->requests_inflight--; 
-		ns->requests_inflight++; 
- 
-		req->ns = ns; 
-	} 
-} 
- 
+static void
+request_swap_ns(struct request *req, struct nameserver *ns) {
+	if (ns && req->ns != ns) {
+		EVUTIL_ASSERT(req->ns->requests_inflight > 0);
+		req->ns->requests_inflight--;
+		ns->requests_inflight++;
+
+		req->ns = ns;
+	}
+}
+
 /* called when a nameserver has been deemed to have failed. For example, too */
 /* many packets have timed out etc */
 static void
@@ -571,7 +571,7 @@ nameserver_failed(struct nameserver *const ns, const char *msg) {
 	if (!ns->state) return;
 
 	log(EVDNS_LOG_MSG, "Nameserver %s has failed: %s",
-	    evutil_format_sockaddr_port_( 
+	    evutil_format_sockaddr_port_(
 		    (struct sockaddr *)&ns->address,
 		    addrbuf, sizeof(addrbuf)),
 	    msg);
@@ -589,7 +589,7 @@ nameserver_failed(struct nameserver *const ns, const char *msg) {
 		&base->global_nameserver_probe_initial_timeout) < 0) {
 		log(EVDNS_LOG_WARN,
 		    "Error from libevent when adding timer event for %s",
-		    evutil_format_sockaddr_port_( 
+		    evutil_format_sockaddr_port_(
 			    (struct sockaddr *)&ns->address,
 			    addrbuf, sizeof(addrbuf)));
 		/* ???? Do more? */
@@ -610,7 +610,7 @@ nameserver_failed(struct nameserver *const ns, const char *msg) {
 				if (req->tx_count == 0 && req->ns == ns) {
 					/* still waiting to go out, can be moved */
 					/* to another server */
-					request_swap_ns(req, nameserver_pick(base)); 
+					request_swap_ns(req, nameserver_pick(base));
 				}
 				req = req->next;
 			} while (req != started_at);
@@ -625,7 +625,7 @@ nameserver_up(struct nameserver *const ns)
 	ASSERT_LOCKED(ns->base);
 	if (ns->state) return;
 	log(EVDNS_LOG_MSG, "Nameserver %s is back up",
-	    evutil_format_sockaddr_port_( 
+	    evutil_format_sockaddr_port_(
 		    (struct sockaddr *)&ns->address,
 		    addrbuf, sizeof(addrbuf)));
 	evtimer_del(&ns->timeout_event);
@@ -663,20 +663,20 @@ request_finished(struct request *const req, struct request **head, int free_hand
 	if (was_inflight) {
 		evtimer_del(&req->timeout_event);
 		base->global_requests_inflight--;
-		req->ns->requests_inflight--; 
+		req->ns->requests_inflight--;
 	} else {
 		base->global_requests_waiting--;
 	}
 	/* it was initialized during request_new / evtimer_assign */
 	event_debug_unassign(&req->timeout_event);
 
-	if (req->ns && 
-	    req->ns->requests_inflight == 0 && 
-	    req->base->disable_when_inactive) { 
-		event_del(&req->ns->event); 
-		evtimer_del(&req->ns->timeout_event); 
-	} 
- 
+	if (req->ns &&
+	    req->ns->requests_inflight == 0 &&
+	    req->base->disable_when_inactive) {
+		event_del(&req->ns->event);
+		evtimer_del(&req->ns->timeout_event);
+	}
+
 	if (!req->request_appended) {
 		/* need to free the request data on it's own */
 		mm_free(req->request);
@@ -723,7 +723,7 @@ request_reissue(struct request *req) {
 	/* the last nameserver should have been marked as failing */
 	/* by the caller of this function, therefore pick will try */
 	/* not to return it */
-	request_swap_ns(req, nameserver_pick(req->base)); 
+	request_swap_ns(req, nameserver_pick(req->base));
 	if (req->ns == last_ns) {
 		/* ... but pick did return it */
 		/* not a lot of point in trying again with the */
@@ -758,8 +758,8 @@ evdns_requests_pump_waiting_queue(struct evdns_base *base) {
 			return;
 
 		/* move a request from the waiting queue to the inflight queue */
-		req->ns->requests_inflight++; 
- 
+		req->ns->requests_inflight++;
+
 		evdns_request_remove(req, &base->req_waiting_head);
 
 		base->global_requests_waiting--;
@@ -775,7 +775,7 @@ evdns_requests_pump_waiting_queue(struct evdns_base *base) {
 
 /* TODO(nickm) document */
 struct deferred_reply_callback {
-	struct event_callback deferred; 
+	struct event_callback deferred;
 	struct evdns_request *handle;
 	u8 request_type;
 	u8 have_reply;
@@ -786,7 +786,7 @@ struct deferred_reply_callback {
 };
 
 static void
-reply_run_callback(struct event_callback *d, void *user_pointer) 
+reply_run_callback(struct event_callback *d, void *user_pointer)
 {
 	struct deferred_reply_callback *cb =
 	    EVUTIL_UPCAST(d, struct deferred_reply_callback, deferred);
@@ -857,29 +857,29 @@ reply_schedule_callback(struct request *const req, u32 ttl, u32 err, struct repl
 		d->handle = req->handle;
 	}
 
-	event_deferred_cb_init_( 
-	    &d->deferred, 
-	    event_get_priority(&req->timeout_event), 
-	    reply_run_callback, 
+	event_deferred_cb_init_(
+	    &d->deferred,
+	    event_get_priority(&req->timeout_event),
+	    reply_run_callback,
 	    req->user_pointer);
-	event_deferred_cb_schedule_( 
-		req->base->event_base, 
+	event_deferred_cb_schedule_(
+		req->base->event_base,
 		&d->deferred);
 }
 
- 
-#define _QR_MASK    0x8000U 
-#define _OP_MASK    0x7800U 
-#define _AA_MASK    0x0400U 
-#define _TC_MASK    0x0200U 
-#define _RD_MASK    0x0100U 
-#define _RA_MASK    0x0080U 
-#define _Z_MASK     0x0040U 
-#define _AD_MASK    0x0020U 
-#define _CD_MASK    0x0010U 
-#define _RCODE_MASK 0x000fU 
-#define _Z_MASK_DEPRECATED 0x0070U 
- 
+
+#define _QR_MASK    0x8000U
+#define _OP_MASK    0x7800U
+#define _AA_MASK    0x0400U
+#define _TC_MASK    0x0200U
+#define _RD_MASK    0x0100U
+#define _RA_MASK    0x0080U
+#define _Z_MASK     0x0040U
+#define _AD_MASK    0x0020U
+#define _CD_MASK    0x0010U
+#define _RCODE_MASK 0x000fU
+#define _Z_MASK_DEPRECATED 0x0070U
+
 /* this processes a parsed reply packet */
 static void
 reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
@@ -893,12 +893,12 @@ reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply)
 	ASSERT_LOCKED(req->base);
 	ASSERT_VALID_REQUEST(req);
 
-	if (flags & (_RCODE_MASK | _TC_MASK) || !reply || !reply->have_answer) { 
+	if (flags & (_RCODE_MASK | _TC_MASK) || !reply || !reply->have_answer) {
 		/* there was an error */
-		if (flags & _TC_MASK) { 
+		if (flags & _TC_MASK) {
 			error = DNS_ERR_TRUNCATED;
-		} else if (flags & _RCODE_MASK) { 
-			u16 error_code = (flags & _RCODE_MASK) - 1; 
+		} else if (flags & _RCODE_MASK) {
+			u16 error_code = (flags & _RCODE_MASK) - 1;
 			if (error_code > 4) {
 				error = DNS_ERR_UNKNOWN;
 			} else {
@@ -930,12 +930,12 @@ reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply)
 			 */
 			log(EVDNS_LOG_DEBUG, "Got a SERVERFAILED from nameserver"
 				"at %s; will allow the request to time out.",
-			    evutil_format_sockaddr_port_( 
+			    evutil_format_sockaddr_port_(
 				    (struct sockaddr *)&req->ns->address,
 				    addrbuf, sizeof(addrbuf)));
-			/* Call the timeout function */ 
-			evdns_request_timeout_callback(0, 0, req); 
-			return; 
+			/* Call the timeout function */
+			evdns_request_timeout_callback(0, 0, req);
+			return;
 		default:
 			/* we got a good reply from the nameserver: it is up. */
 			if (req->handle == req->ns->probe_request) {
@@ -978,8 +978,8 @@ name_parse(u8 *packet, int length, int *idx, char *name_out, int name_out_len) {
 	int name_end = -1;
 	int j = *idx;
 	int ptr_count = 0;
-#define GET32(x) do { if (j + 4 > length) goto err; memcpy(&t32_, packet + j, 4); j += 4; x = ntohl(t32_); } while (0) 
-#define GET16(x) do { if (j + 2 > length) goto err; memcpy(&t_, packet + j, 2); j += 2; x = ntohs(t_); } while (0) 
+#define GET32(x) do { if (j + 4 > length) goto err; memcpy(&t32_, packet + j, 4); j += 4; x = ntohl(t32_); } while (0)
+#define GET16(x) do { if (j + 2 > length) goto err; memcpy(&t_, packet + j, 2); j += 2; x = ntohs(t_); } while (0)
 #define GET8(x) do { if (j >= length) goto err; x = packet[j++]; } while (0)
 
 	char *cp = name_out;
@@ -1013,7 +1013,7 @@ name_parse(u8 *packet, int length, int *idx, char *name_out, int name_out_len) {
 			*cp++ = '.';
 		}
 		if (cp + label_len >= end) return -1;
-		if (j + label_len > length) return -1; 
+		if (j + label_len > length) return -1;
 		memcpy(cp, packet + j, label_len);
 		cp += label_len;
 		j += label_len;
@@ -1033,8 +1033,8 @@ name_parse(u8 *packet, int length, int *idx, char *name_out, int name_out_len) {
 static int
 reply_parse(struct evdns_base *base, u8 *packet, int length) {
 	int j = 0, k = 0;  /* index into packet */
-	u16 t_;	 /* used by the macros */ 
-	u32 t32_;  /* used by the macros */ 
+	u16 t_;	 /* used by the macros */
+	u32 t32_;  /* used by the macros */
 	char tmp_name[256], cmp_name[256]; /* used by the macros */
 	int name_matches = 0;
 
@@ -1063,8 +1063,8 @@ reply_parse(struct evdns_base *base, u8 *packet, int length) {
 	memset(&reply, 0, sizeof(reply));
 
 	/* If it's not an answer, it doesn't correspond to any request. */
-	if (!(flags & _QR_MASK)) return -1;  /* must be an answer */ 
-	if ((flags & (_RCODE_MASK|_TC_MASK)) && (flags & (_RCODE_MASK|_TC_MASK)) != DNS_ERR_NOTEXIST) { 
+	if (!(flags & _QR_MASK)) return -1;  /* must be an answer */
+	if ((flags & (_RCODE_MASK|_TC_MASK)) && (flags & (_RCODE_MASK|_TC_MASK)) != DNS_ERR_NOTEXIST) {
 		/* there was an error and it's not NXDOMAIN */
 		goto err;
 	}
@@ -1085,25 +1085,25 @@ reply_parse(struct evdns_base *base, u8 *packet, int length) {
 		/* the question looks like
 		 *   <label:name><u16:type><u16:class>
 		 */
-		tmp_name[0] = '\0'; 
-		cmp_name[0] = '\0'; 
-		k = j; 
-		if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name)) < 0) 
-			goto err; 
-		if (name_parse(req->request, req->request_len, &k, 
-			cmp_name, sizeof(cmp_name))<0) 
-			goto err; 
-		if (!base->global_randomize_case) { 
-			if (strcmp(tmp_name, cmp_name) == 0) 
-				name_matches = 1; 
-		} else { 
-			if (evutil_ascii_strcasecmp(tmp_name, cmp_name) == 0) 
-				name_matches = 1; 
-		} 
- 
+		tmp_name[0] = '\0';
+		cmp_name[0] = '\0';
+		k = j;
+		if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name)) < 0)
+			goto err;
+		if (name_parse(req->request, req->request_len, &k,
+			cmp_name, sizeof(cmp_name))<0)
+			goto err;
+		if (!base->global_randomize_case) {
+			if (strcmp(tmp_name, cmp_name) == 0)
+				name_matches = 1;
+		} else {
+			if (evutil_ascii_strcasecmp(tmp_name, cmp_name) == 0)
+				name_matches = 1;
+		}
+
 		j += 4;
-		if (j > length) 
-			goto err; 
+		if (j > length)
+			goto err;
 	}
 
 	if (!name_matches)
@@ -1233,7 +1233,7 @@ static int
 request_parse(u8 *packet, int length, struct evdns_server_port *port, struct sockaddr *addr, ev_socklen_t addrlen)
 {
 	int j = 0;	/* index into packet */
-	u16 t_;	 /* used by the macros */ 
+	u16 t_;	 /* used by the macros */
 	char tmp_name[256]; /* used by the macros */
 
 	int i;
@@ -1253,8 +1253,8 @@ request_parse(u8 *packet, int length, struct evdns_server_port *port, struct soc
 	(void)additional;
 	(void)authority;
 
-	if (flags & _QR_MASK) return -1; /* Must not be an answer. */ 
-	flags &= (_RD_MASK|_CD_MASK); /* Only RD and CD get preserved. */ 
+	if (flags & _QR_MASK) return -1; /* Must not be an answer. */
+	flags &= (_RD_MASK|_CD_MASK); /* Only RD and CD get preserved. */
 
 	server_req = mm_malloc(sizeof(struct server_request));
 	if (server_req == NULL) return -1;
@@ -1294,7 +1294,7 @@ request_parse(u8 *packet, int length, struct evdns_server_port *port, struct soc
 	port->refcnt++;
 
 	/* Only standard queries are supported. */
-	if (flags & _OP_MASK) { 
+	if (flags & _OP_MASK) {
 		evdns_server_request_respond(&(server_req->base), DNS_ERR_NOTIMPL);
 		return -1;
 	}
@@ -1303,12 +1303,12 @@ request_parse(u8 *packet, int length, struct evdns_server_port *port, struct soc
 
 	return 0;
 err:
-	if (server_req->base.questions) { 
-		for (i = 0; i < server_req->base.nquestions; ++i) 
-			mm_free(server_req->base.questions[i]); 
-		mm_free(server_req->base.questions); 
+	if (server_req->base.questions) {
+		for (i = 0; i < server_req->base.nquestions; ++i)
+			mm_free(server_req->base.questions[i]);
+		mm_free(server_req->base.questions);
 	}
-	mm_free(server_req); 
+	mm_free(server_req);
 	return -1;
 
 #undef SKIP_NAME
@@ -1406,7 +1406,7 @@ nameserver_read(struct nameserver *ns) {
 			(struct sockaddr*)&ns->address, 0)) {
 			log(EVDNS_LOG_WARN, "Address mismatch on received "
 			    "DNS packet.  Apparent source was %s",
-			    evutil_format_sockaddr_port_( 
+			    evutil_format_sockaddr_port_(
 				    (struct sockaddr *)&ss,
 				    addrbuf, sizeof(addrbuf)));
 			return;
@@ -1496,7 +1496,7 @@ nameserver_write_waiting(struct nameserver *ns, char waiting) {
 	if (event_add(&ns->event, NULL) < 0) {
 		char addrbuf[128];
 		log(EVDNS_LOG_WARN, "Error from libevent when adding event for %s",
-		    evutil_format_sockaddr_port_( 
+		    evutil_format_sockaddr_port_(
 			    (struct sockaddr *)&ns->address,
 			    addrbuf, sizeof(addrbuf)));
 		/* ???? Do more? */
@@ -1617,20 +1617,20 @@ dnsname_to_labels(u8 *const buf, size_t buf_len, off_t j,
 				  struct dnslabel_table *table) {
 	const char *end = name + name_len;
 	int ref = 0;
-	u16 t_; 
+	u16 t_;
 
 #define APPEND16(x) do {						\
 		if (j + 2 > (off_t)buf_len)				\
 			goto overflow;					\
-		t_ = htons(x);						\ 
-		memcpy(buf + j, &t_, 2);				\ 
+		t_ = htons(x);						\
+		memcpy(buf + j, &t_, 2);				\
 		j += 2;							\
 	} while (0)
 #define APPEND32(x) do {						\
 		if (j + 4 > (off_t)buf_len)				\
 			goto overflow;					\
-		t32_ = htonl(x);					\ 
-		memcpy(buf + j, &t32_, 4);				\ 
+		t32_ = htonl(x);					\
+		memcpy(buf + j, &t32_, 4);				\
 		j += 4;							\
 	} while (0)
 
@@ -1696,7 +1696,7 @@ evdns_request_data_build(const char *const name, const size_t name_len,
     const u16 trans_id, const u16 type, const u16 class,
     u8 *const buf, size_t buf_len) {
 	off_t j = 0;  /* current offset into buf */
-	u16 t_;	 /* used by the macros */ 
+	u16 t_;	 /* used by the macros */
 
 	APPEND16(trans_id);
 	APPEND16(0x0100);  /* standard query, recusion needed */
@@ -1766,15 +1766,15 @@ evdns_close_server_port(struct evdns_server_port *port)
 		server_port_free(port);
 	} else {
 		port->closing = 1;
-		EVDNS_UNLOCK(port); 
+		EVDNS_UNLOCK(port);
 	}
 }
 
 /* exported function */
 int
-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) 
+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)
 {
-	struct server_request *req = TO_SERVER_REQUEST(req_); 
+	struct server_request *req = TO_SERVER_REQUEST(req_);
 	struct server_reply_item **itemp, *item;
 	int *countp;
 	int result = -1;
@@ -1909,8 +1909,8 @@ evdns_server_request_format_response(struct server_request *req, int err)
 	unsigned char buf[1500];
 	size_t buf_len = sizeof(buf);
 	off_t j = 0, r;
-	u16 t_; 
-	u32 t32_; 
+	u16 t_;
+	u32 t32_;
 	int i;
 	u16 flags;
 	struct dnslabel_table table;
@@ -1920,7 +1920,7 @@ evdns_server_request_format_response(struct server_request *req, int err)
 	/* Set response bit and error code; copy OPCODE and RD fields from
 	 * question; copy RA and AA if set by caller. */
 	flags = req->base.flags;
-	flags |= (_QR_MASK | err); 
+	flags |= (_QR_MASK | err);
 
 	dnslabel_table_init(&table);
 	APPEND16(req->trans_id);
@@ -1968,8 +1968,8 @@ evdns_server_request_format_response(struct server_request *req, int err)
 				if (r < 0)
 					goto overflow;
 				j = r;
-				t_ = htons( (short) (j-name_start) ); 
-				memcpy(buf+len_idx, &t_, 2); 
+				t_ = htons( (short) (j-name_start) );
+				memcpy(buf+len_idx, &t_, 2);
 			} else {
 				APPEND16(item->datalen);
 				if (j+item->datalen > (off_t)buf_len)
@@ -2002,9 +2002,9 @@ overflow:
 
 /* exported function */
 int
-evdns_server_request_respond(struct evdns_server_request *req_, int err) 
+evdns_server_request_respond(struct evdns_server_request *req_, int err)
 {
-	struct server_request *req = TO_SERVER_REQUEST(req_); 
+	struct server_request *req = TO_SERVER_REQUEST(req_);
 	struct evdns_server_port *port = req->port;
 	int r = -1;
 
@@ -2150,18 +2150,18 @@ server_port_free(struct evdns_server_port *port)
 
 /* exported function */
 int
-evdns_server_request_drop(struct evdns_server_request *req_) 
+evdns_server_request_drop(struct evdns_server_request *req_)
 {
-	struct server_request *req = TO_SERVER_REQUEST(req_); 
+	struct server_request *req = TO_SERVER_REQUEST(req_);
 	server_request_free(req);
 	return 0;
 }
 
 /* exported function */
 int
-evdns_server_request_get_requesting_addr(struct evdns_server_request *req_, struct sockaddr *sa, int addr_len) 
+evdns_server_request_get_requesting_addr(struct evdns_server_request *req_, struct sockaddr *sa, int addr_len)
 {
-	struct server_request *req = TO_SERVER_REQUEST(req_); 
+	struct server_request *req = TO_SERVER_REQUEST(req_);
 	if (addr_len < (int)req->addrlen)
 		return -1;
 	memcpy(sa, &(req->addr), req->addrlen);
@@ -2185,29 +2185,29 @@ evdns_request_timeout_callback(evutil_socket_t fd, short events, void *arg) {
 	EVDNS_LOCK(base);
 
 	if (req->tx_count >= req->base->global_max_retransmits) {
-		struct nameserver *ns = req->ns; 
+		struct nameserver *ns = req->ns;
 		/* this request has failed */
 		log(EVDNS_LOG_DEBUG, "Giving up on request %p; tx_count==%d",
 		    arg, req->tx_count);
 		reply_schedule_callback(req, 0, DNS_ERR_TIMEOUT, NULL);
- 
+
 		request_finished(req, &REQ_HEAD(req->base, req->trans_id), 1);
-		nameserver_failed(ns, "request timed out."); 
+		nameserver_failed(ns, "request timed out.");
 	} else {
 		/* retransmit it */
 		log(EVDNS_LOG_DEBUG, "Retransmitting request %p; tx_count==%d",
 		    arg, req->tx_count);
 		(void) evtimer_del(&req->timeout_event);
-		request_swap_ns(req, nameserver_pick(base)); 
+		request_swap_ns(req, nameserver_pick(base));
 		evdns_request_transmit(req);
- 
-		req->ns->timedout++; 
-		if (req->ns->timedout > req->base->global_max_nameserver_timeout) { 
-			req->ns->timedout = 0; 
-			nameserver_failed(req->ns, "request timed out."); 
-		} 
-	}
- 
+
+		req->ns->timedout++;
+		if (req->ns->timedout > req->base->global_max_nameserver_timeout) {
+			req->ns->timedout = 0;
+			nameserver_failed(req->ns, "request timed out.");
+		}
+	}
+
 	EVDNS_UNLOCK(base);
 }
 
@@ -2222,13 +2222,13 @@ evdns_request_transmit_to(struct request *req, struct nameserver *server) {
 	int r;
 	ASSERT_LOCKED(req->base);
 	ASSERT_VALID_REQUEST(req);
- 
-	if (server->requests_inflight == 1 && 
-		req->base->disable_when_inactive && 
-		event_add(&server->event, NULL) < 0) { 
-		return 1; 
-	} 
- 
+
+	if (server->requests_inflight == 1 &&
+		req->base->disable_when_inactive &&
+		event_add(&server->event, NULL) < 0) {
+		return 1;
+	}
+
 	r = sendto(server->socket, (void*)req->request, req->request_len, 0,
 	    (struct sockaddr *)&server->address, server->addrlen);
 	if (r < 0) {
@@ -2281,11 +2281,11 @@ evdns_request_transmit(struct request *req) {
 		nameserver_write_waiting(req->ns, 1);
 		return 1;
 	case 2:
-		/* failed to transmit the request entirely. we can fallthrough since 
-		 * we'll set a timeout, which will time out, and make us retransmit the 
-		 * request anyway. */ 
+		/* failed to transmit the request entirely. we can fallthrough since
+		 * we'll set a timeout, which will time out, and make us retransmit the
+		 * request anyway. */
 		retcode = 1;
-		EVUTIL_FALLTHROUGH; 
+		EVUTIL_FALLTHROUGH;
 	default:
 		/* all ok */
 		log(EVDNS_LOG_DEBUG,
@@ -2338,7 +2338,7 @@ nameserver_send_probe(struct nameserver *const ns) {
 
 	ASSERT_LOCKED(ns->base);
 	log(EVDNS_LOG_DEBUG, "Sending probe to %s",
-	    evutil_format_sockaddr_port_( 
+	    evutil_format_sockaddr_port_(
 		    (struct sockaddr *)&ns->address,
 		    addrbuf, sizeof(addrbuf)));
 	handle = mm_calloc(1, sizeof(*handle));
@@ -2499,7 +2499,7 @@ evdns_resume(void)
 }
 
 static int
-evdns_nameserver_add_impl_(struct evdns_base *base, const struct sockaddr *address, int addrlen) { 
+evdns_nameserver_add_impl_(struct evdns_base *base, const struct sockaddr *address, int addrlen) {
 	/* first check to see if we already have this nameserver */
 
 	const struct nameserver *server = base->server_head, *const started_at = base->server_head;
@@ -2527,12 +2527,12 @@ evdns_nameserver_add_impl_(struct evdns_base *base, const struct sockaddr *addre
 
 	evtimer_assign(&ns->timeout_event, ns->base->event_base, nameserver_prod_callback, ns);
 
-	ns->socket = evutil_socket_(address->sa_family, 
-	    SOCK_DGRAM|EVUTIL_SOCK_NONBLOCK|EVUTIL_SOCK_CLOEXEC, 0); 
+	ns->socket = evutil_socket_(address->sa_family,
+	    SOCK_DGRAM|EVUTIL_SOCK_NONBLOCK|EVUTIL_SOCK_CLOEXEC, 0);
 	if (ns->socket < 0) { err = 1; goto out1; }
 
 	if (base->global_outgoing_addrlen &&
-	    !evutil_sockaddr_is_loopback_(address)) { 
+	    !evutil_sockaddr_is_loopback_(address)) {
 		if (bind(ns->socket,
 			(struct sockaddr*)&base->global_outgoing_address,
 			base->global_outgoing_addrlen) < 0) {
@@ -2542,35 +2542,35 @@ evdns_nameserver_add_impl_(struct evdns_base *base, const struct sockaddr *addre
 		}
 	}
 
-	if (base->so_rcvbuf) { 
-		if (setsockopt(ns->socket, SOL_SOCKET, SO_RCVBUF, 
-		    (void *)&base->so_rcvbuf, sizeof(base->so_rcvbuf))) { 
-			log(EVDNS_LOG_WARN, "Couldn't set SO_RCVBUF to %i", base->so_rcvbuf); 
-			err = -SO_RCVBUF; 
-			goto out2; 
-		} 
-	} 
-	if (base->so_sndbuf) { 
-		if (setsockopt(ns->socket, SOL_SOCKET, SO_SNDBUF, 
-		    (void *)&base->so_sndbuf, sizeof(base->so_sndbuf))) { 
-			log(EVDNS_LOG_WARN, "Couldn't set SO_SNDBUF to %i", base->so_sndbuf); 
-			err = -SO_SNDBUF; 
-			goto out2; 
-		} 
-	} 
- 
+	if (base->so_rcvbuf) {
+		if (setsockopt(ns->socket, SOL_SOCKET, SO_RCVBUF,
+		    (void *)&base->so_rcvbuf, sizeof(base->so_rcvbuf))) {
+			log(EVDNS_LOG_WARN, "Couldn't set SO_RCVBUF to %i", base->so_rcvbuf);
+			err = -SO_RCVBUF;
+			goto out2;
+		}
+	}
+	if (base->so_sndbuf) {
+		if (setsockopt(ns->socket, SOL_SOCKET, SO_SNDBUF,
+		    (void *)&base->so_sndbuf, sizeof(base->so_sndbuf))) {
+			log(EVDNS_LOG_WARN, "Couldn't set SO_SNDBUF to %i", base->so_sndbuf);
+			err = -SO_SNDBUF;
+			goto out2;
+		}
+	}
+
 	memcpy(&ns->address, address, addrlen);
 	ns->addrlen = addrlen;
 	ns->state = 1;
-	event_assign(&ns->event, ns->base->event_base, ns->socket, 
-				 EV_READ | EV_PERSIST, nameserver_ready_callback, ns); 
-	if (!base->disable_when_inactive && event_add(&ns->event, NULL) < 0) { 
+	event_assign(&ns->event, ns->base->event_base, ns->socket,
+				 EV_READ | EV_PERSIST, nameserver_ready_callback, ns);
+	if (!base->disable_when_inactive && event_add(&ns->event, NULL) < 0) {
 		err = 2;
 		goto out2;
 	}
 
 	log(EVDNS_LOG_DEBUG, "Added nameserver %s as %p",
-	    evutil_format_sockaddr_port_(address, addrbuf, sizeof(addrbuf)), ns); 
+	    evutil_format_sockaddr_port_(address, addrbuf, sizeof(addrbuf)), ns);
 
 	/* insert this nameserver into the list of them */
 	if (!base->server_head) {
@@ -2593,7 +2593,7 @@ out1:
 	event_debug_unassign(&ns->event);
 	mm_free(ns);
 	log(EVDNS_LOG_WARN, "Unable to add nameserver %s: error %d",
-	    evutil_format_sockaddr_port_(address, addrbuf, sizeof(addrbuf)), err); 
+	    evutil_format_sockaddr_port_(address, addrbuf, sizeof(addrbuf)), err);
 	return err;
 }
 
@@ -2608,7 +2608,7 @@ evdns_base_nameserver_add(struct evdns_base *base, unsigned long int address)
 	sin.sin_port = htons(53);
 	sin.sin_family = AF_INET;
 	EVDNS_LOCK(base);
-	res = evdns_nameserver_add_impl_(base, (struct sockaddr*)&sin, sizeof(sin)); 
+	res = evdns_nameserver_add_impl_(base, (struct sockaddr*)&sin, sizeof(sin));
 	EVDNS_UNLOCK(base);
 	return res;
 }
@@ -2660,7 +2660,7 @@ evdns_base_nameserver_ip_add(struct evdns_base *base, const char *ip_as_string)
 		sockaddr_setport(sa, 53);
 
 	EVDNS_LOCK(base);
-	res = evdns_nameserver_add_impl_(base, sa, len); 
+	res = evdns_nameserver_add_impl_(base, sa, len);
 	EVDNS_UNLOCK(base);
 	return res;
 }
@@ -2679,39 +2679,39 @@ evdns_base_nameserver_sockaddr_add(struct evdns_base *base,
 	int res;
 	EVUTIL_ASSERT(base);
 	EVDNS_LOCK(base);
-	res = evdns_nameserver_add_impl_(base, sa, len); 
+	res = evdns_nameserver_add_impl_(base, sa, len);
 	EVDNS_UNLOCK(base);
 	return res;
 }
 
-int 
-evdns_base_get_nameserver_addr(struct evdns_base *base, int idx, 
-    struct sockaddr *sa, ev_socklen_t len) 
-{ 
-	int result = -1; 
-	int i; 
-	struct nameserver *server; 
-	EVDNS_LOCK(base); 
-	server = base->server_head; 
-	for (i = 0; i < idx && server; ++i, server = server->next) { 
-		if (server->next == base->server_head) 
-			goto done; 
-	} 
-	if (! server) 
-		goto done; 
- 
-	if (server->addrlen > len) { 
-		result = (int) server->addrlen; 
-		goto done; 
-	} 
- 
-	memcpy(sa, &server->address, server->addrlen); 
-	result = (int) server->addrlen; 
-done: 
-	EVDNS_UNLOCK(base); 
-	return result; 
-} 
- 
+int
+evdns_base_get_nameserver_addr(struct evdns_base *base, int idx,
+    struct sockaddr *sa, ev_socklen_t len)
+{
+	int result = -1;
+	int i;
+	struct nameserver *server;
+	EVDNS_LOCK(base);
+	server = base->server_head;
+	for (i = 0; i < idx && server; ++i, server = server->next) {
+		if (server->next == base->server_head)
+			goto done;
+	}
+	if (! server)
+		goto done;
+
+	if (server->addrlen > len) {
+		result = (int) server->addrlen;
+		goto done;
+	}
+
+	memcpy(sa, &server->address, server->addrlen);
+	result = (int) server->addrlen;
+done:
+	EVDNS_UNLOCK(base);
+	return result;
+}
+
 /* remove from the queue */
 static void
 evdns_request_remove(struct request *req, struct request **head)
@@ -2815,7 +2815,7 @@ request_new(struct evdns_base *base, struct evdns_request *handle, int type,
 		strlcpy(namebuf, name, sizeof(namebuf));
 		evutil_secure_rng_get_bytes(randbits, (name_len+7)/8);
 		for (i = 0; i < name_len; ++i) {
-			if (EVUTIL_ISALPHA_(namebuf[i])) { 
+			if (EVUTIL_ISALPHA_(namebuf[i])) {
 				if ((randbits[i >> 3] & (1<<(i & 7))))
 					namebuf[i] |= 0x20;
 				else
@@ -2863,10 +2863,10 @@ request_submit(struct request *const req) {
 		/* if it has a nameserver assigned then this is going */
 		/* straight into the inflight queue */
 		evdns_request_insert(req, &REQ_HEAD(base, req->trans_id));
- 
+
 		base->global_requests_inflight++;
-		req->ns->requests_inflight++; 
- 
+		req->ns->requests_inflight++;
+
 		evdns_request_transmit(req);
 	} else {
 		evdns_request_insert(req, &base->req_waiting_head);
@@ -3209,12 +3209,12 @@ search_set_from_hostname(struct evdns_base *base) {
 static char *
 search_make_new(const struct search_state *const state, int n, const char *const base_name) {
 	const size_t base_len = strlen(base_name);
-	char need_to_append_dot; 
+	char need_to_append_dot;
 	struct search_domain *dom;
 
-	if (!base_len) return NULL; 
-	need_to_append_dot = base_name[base_len - 1] == '.' ? 0 : 1; 
- 
+	if (!base_len) return NULL;
+	need_to_append_dot = base_name[base_len - 1] == '.' ? 0 : 1;
+
 	for (dom = state->head; dom; dom = dom->next) {
 		if (!n--) {
 			/* this is the postfix we want */
@@ -3347,19 +3347,19 @@ search_request_finished(struct evdns_request *const handle) {
 
 static void
 evdns_resolv_set_defaults(struct evdns_base *base, int flags) {
-	int add_default = flags & DNS_OPTION_NAMESERVERS; 
-	if (flags & DNS_OPTION_NAMESERVERS_NO_DEFAULT) 
-		add_default = 0; 
- 
+	int add_default = flags & DNS_OPTION_NAMESERVERS;
+	if (flags & DNS_OPTION_NAMESERVERS_NO_DEFAULT)
+		add_default = 0;
+
 	/* if the file isn't found then we assume a local resolver */
 	ASSERT_LOCKED(base);
-	if (flags & DNS_OPTION_SEARCH) 
-		search_set_from_hostname(base); 
-	if (add_default) 
-		evdns_base_nameserver_ip_add(base, "127.0.0.1"); 
+	if (flags & DNS_OPTION_SEARCH)
+		search_set_from_hostname(base);
+	if (add_default)
+		evdns_base_nameserver_ip_add(base, "127.0.0.1");
 }
 
-#ifndef EVENT__HAVE_STRTOK_R 
+#ifndef EVENT__HAVE_STRTOK_R
 static char *
 strtok_r(char *s, const char *delim, char **state) {
 	char *cp, *start;
@@ -3393,7 +3393,7 @@ strtoint(const char *const str)
 
 /* Parse a number of seconds into a timeval; return -1 on error. */
 static int
-evdns_strtotimeval(const char *const str, struct timeval *out) 
+evdns_strtotimeval(const char *const str, struct timeval *out)
 {
 	double d;
 	char *endptr;
@@ -3496,13 +3496,13 @@ evdns_base_set_option_impl(struct evdns_base *base,
 		base->global_search_state->ndots = ndots;
 	} else if (str_matches_option(option, "timeout:")) {
 		struct timeval tv;
-		if (evdns_strtotimeval(val, &tv) == -1) return -1; 
+		if (evdns_strtotimeval(val, &tv) == -1) return -1;
 		if (!(flags & DNS_OPTION_MISC)) return 0;
 		log(EVDNS_LOG_DEBUG, "Setting timeout to %s", val);
 		memcpy(&base->global_timeout, &tv, sizeof(struct timeval));
 	} else if (str_matches_option(option, "getaddrinfo-allow-skew:")) {
 		struct timeval tv;
-		if (evdns_strtotimeval(val, &tv) == -1) return -1; 
+		if (evdns_strtotimeval(val, &tv) == -1) return -1;
 		if (!(flags & DNS_OPTION_MISC)) return 0;
 		log(EVDNS_LOG_DEBUG, "Setting getaddrinfo-allow-skew to %s",
 		    val);
@@ -3545,7 +3545,7 @@ evdns_base_set_option_impl(struct evdns_base *base,
 		base->global_outgoing_addrlen = len;
 	} else if (str_matches_option(option, "initial-probe-timeout:")) {
 		struct timeval tv;
-		if (evdns_strtotimeval(val, &tv) == -1) return -1; 
+		if (evdns_strtotimeval(val, &tv) == -1) return -1;
 		if (tv.tv_sec > 3600)
 			tv.tv_sec = 3600;
 		if (!(flags & DNS_OPTION_MISC)) return 0;
@@ -3553,18 +3553,18 @@ evdns_base_set_option_impl(struct evdns_base *base,
 		    val);
 		memcpy(&base->global_nameserver_probe_initial_timeout, &tv,
 		    sizeof(tv));
-	} else if (str_matches_option(option, "so-rcvbuf:")) { 
-		int buf = strtoint(val); 
+	} else if (str_matches_option(option, "so-rcvbuf:")) {
+		int buf = strtoint(val);
 		if (buf == -1) return -1;
-		if (!(flags & DNS_OPTION_MISC)) return 0; 
-		log(EVDNS_LOG_DEBUG, "Setting SO_RCVBUF to %s", val); 
-		base->so_rcvbuf = buf; 
-	} else if (str_matches_option(option, "so-sndbuf:")) { 
-		int buf = strtoint(val); 
+		if (!(flags & DNS_OPTION_MISC)) return 0;
+		log(EVDNS_LOG_DEBUG, "Setting SO_RCVBUF to %s", val);
+		base->so_rcvbuf = buf;
+	} else if (str_matches_option(option, "so-sndbuf:")) {
+		int buf = strtoint(val);
 		if (buf == -1) return -1;
-		if (!(flags & DNS_OPTION_MISC)) return 0; 
-		log(EVDNS_LOG_DEBUG, "Setting SO_SNDBUF to %s", val); 
-		base->so_sndbuf = buf; 
+		if (!(flags & DNS_OPTION_MISC)) return 0;
+		log(EVDNS_LOG_DEBUG, "Setting SO_SNDBUF to %s", val);
+		base->so_sndbuf = buf;
 	}
 	return 0;
 }
@@ -3637,7 +3637,7 @@ evdns_base_resolv_conf_parse(struct evdns_base *base, int flags, const char *con
 static char *
 evdns_get_default_hosts_filename(void)
 {
-#ifdef _WIN32 
+#ifdef _WIN32
 	/* Windows is a little coy about where it puts its configuration
 	 * files.  Sure, they're _usually_ in C:\windows\system32, but
 	 * there's no reason in principle they couldn't be in
@@ -3650,8 +3650,8 @@ evdns_get_default_hosts_filename(void)
 
 	if (! SHGetSpecialFolderPathA(NULL, path, CSIDL_SYSTEM, 0))
 		return NULL;
-	len_out = strlen(path)+strlen(hostfile)+1; 
-	path_out = mm_malloc(len_out); 
+	len_out = strlen(path)+strlen(hostfile)+1;
+	path_out = mm_malloc(len_out);
 	evutil_snprintf(path_out, len_out, "%s%s", path, hostfile);
 	return path_out;
 #else
@@ -3665,14 +3665,14 @@ evdns_base_resolv_conf_parse_impl(struct evdns_base *base, int flags, const char
 	char *resolv;
 	char *start;
 	int err = 0;
-	int add_default; 
+	int add_default;
 
 	log(EVDNS_LOG_DEBUG, "Parsing resolv.conf file %s", filename);
 
-	add_default = flags & DNS_OPTION_NAMESERVERS; 
-	if (flags & DNS_OPTION_NAMESERVERS_NO_DEFAULT) 
-		add_default = 0; 
- 
+	add_default = flags & DNS_OPTION_NAMESERVERS;
+	if (flags & DNS_OPTION_NAMESERVERS_NO_DEFAULT)
+		add_default = 0;
+
 	if (flags & DNS_OPTION_HOSTSFILE) {
 		char *fname = evdns_get_default_hosts_filename();
 		evdns_base_load_hosts(base, fname);
@@ -3680,12 +3680,12 @@ evdns_base_resolv_conf_parse_impl(struct evdns_base *base, int flags, const char
 			mm_free(fname);
 	}
 
-	if (!filename) { 
-		evdns_resolv_set_defaults(base, flags); 
-		return 1; 
-	} 
- 
-	if ((err = evutil_read_file_(filename, &resolv, &n, 0)) < 0) { 
+	if (!filename) {
+		evdns_resolv_set_defaults(base, flags);
+		return 1;
+	}
+
+	if ((err = evutil_read_file_(filename, &resolv, &n, 0)) < 0) {
 		if (err == -1) {
 			/* No file. */
 			evdns_resolv_set_defaults(base, flags);
@@ -3708,7 +3708,7 @@ evdns_base_resolv_conf_parse_impl(struct evdns_base *base, int flags, const char
 		}
 	}
 
-	if (!base->server_head && add_default) { 
+	if (!base->server_head && add_default) {
 		/* no nameservers were configured. */
 		evdns_base_nameserver_ip_add(base, "127.0.0.1");
 		err = 6;
@@ -3729,7 +3729,7 @@ evdns_resolv_conf_parse(int flags, const char *const filename) {
 }
 
 
-#ifdef _WIN32 
+#ifdef _WIN32
 /* Add multiple nameservers from a space-or-comma-separated list. */
 static int
 evdns_nameserver_ip_add_line(struct evdns_base *base, const char *ips) {
@@ -3772,7 +3772,7 @@ load_nameservers_with_getnetworkparams(struct evdns_base *base)
 	GetNetworkParams_fn_t fn;
 
 	ASSERT_LOCKED(base);
-	if (!(handle = evutil_load_windows_system_library_( 
+	if (!(handle = evutil_load_windows_system_library_(
 			TEXT("iphlpapi.dll")))) {
 		log(EVDNS_LOG_WARN, "Could not open iphlpapi.dll");
 		status = -1;
@@ -3931,12 +3931,12 @@ evdns_base_config_windows_nameservers(struct evdns_base *base)
 	if (base == NULL)
 		return -1;
 	EVDNS_LOCK(base);
-	fname = evdns_get_default_hosts_filename(); 
-	log(EVDNS_LOG_DEBUG, "Loading hosts entries from %s", fname); 
-	evdns_base_load_hosts(base, fname); 
-	if (fname) 
-		mm_free(fname); 
- 
+	fname = evdns_get_default_hosts_filename();
+	log(EVDNS_LOG_DEBUG, "Loading hosts entries from %s", fname);
+	evdns_base_load_hosts(base, fname);
+	if (fname)
+		mm_free(fname);
+
 	if (load_nameservers_with_getnetworkparams(base) == 0) {
 		EVDNS_UNLOCK(base);
 		return 0;
@@ -3960,7 +3960,7 @@ evdns_config_windows_nameservers(void)
 #endif
 
 struct evdns_base *
-evdns_base_new(struct event_base *event_base, int flags) 
+evdns_base_new(struct event_base *event_base, int flags)
 {
 	struct evdns_base *base;
 
@@ -3973,8 +3973,8 @@ evdns_base_new(struct event_base *event_base, int flags)
 	/* Give the evutil library a hook into its evdns-enabled
 	 * functionality.  We can't just call evdns_getaddrinfo directly or
 	 * else libevent-core will depend on libevent-extras. */
-	evutil_set_evdns_getaddrinfo_fn_(evdns_getaddrinfo); 
-	evutil_set_evdns_getaddrinfo_cancel_fn_(evdns_getaddrinfo_cancel); 
+	evutil_set_evdns_getaddrinfo_fn_(evdns_getaddrinfo);
+	evutil_set_evdns_getaddrinfo_cancel_fn_(evdns_getaddrinfo_cancel);
 
 	base = mm_malloc(sizeof(struct evdns_base));
 	if (base == NULL)
@@ -4009,41 +4009,41 @@ evdns_base_new(struct event_base *event_base, int flags)
 
 	TAILQ_INIT(&base->hostsdb);
 
-#define EVDNS_BASE_ALL_FLAGS ( \ 
-	EVDNS_BASE_INITIALIZE_NAMESERVERS | \ 
-	EVDNS_BASE_DISABLE_WHEN_INACTIVE  | \ 
-	EVDNS_BASE_NAMESERVERS_NO_DEFAULT | \ 
-	0) 
- 
-	if (flags & ~EVDNS_BASE_ALL_FLAGS) { 
-		flags = EVDNS_BASE_INITIALIZE_NAMESERVERS; 
-		log(EVDNS_LOG_WARN, 
-		    "Unrecognized flag passed to evdns_base_new(). Assuming " 
-		    "you meant EVDNS_BASE_INITIALIZE_NAMESERVERS."); 
-	} 
-#undef EVDNS_BASE_ALL_FLAGS 
- 
-	if (flags & EVDNS_BASE_INITIALIZE_NAMESERVERS) { 
+#define EVDNS_BASE_ALL_FLAGS ( \
+	EVDNS_BASE_INITIALIZE_NAMESERVERS | \
+	EVDNS_BASE_DISABLE_WHEN_INACTIVE  | \
+	EVDNS_BASE_NAMESERVERS_NO_DEFAULT | \
+	0)
+
+	if (flags & ~EVDNS_BASE_ALL_FLAGS) {
+		flags = EVDNS_BASE_INITIALIZE_NAMESERVERS;
+		log(EVDNS_LOG_WARN,
+		    "Unrecognized flag passed to evdns_base_new(). Assuming "
+		    "you meant EVDNS_BASE_INITIALIZE_NAMESERVERS.");
+	}
+#undef EVDNS_BASE_ALL_FLAGS
+
+	if (flags & EVDNS_BASE_INITIALIZE_NAMESERVERS) {
 		int r;
-		int opts = DNS_OPTIONS_ALL; 
-		if (flags & EVDNS_BASE_NAMESERVERS_NO_DEFAULT) { 
-			opts |= DNS_OPTION_NAMESERVERS_NO_DEFAULT; 
-		} 
- 
-#ifdef _WIN32 
+		int opts = DNS_OPTIONS_ALL;
+		if (flags & EVDNS_BASE_NAMESERVERS_NO_DEFAULT) {
+			opts |= DNS_OPTION_NAMESERVERS_NO_DEFAULT;
+		}
+
+#ifdef _WIN32
 		r = evdns_base_config_windows_nameservers(base);
 #else
-		r = evdns_base_resolv_conf_parse(base, opts, "/etc/resolv.conf"); 
+		r = evdns_base_resolv_conf_parse(base, opts, "/etc/resolv.conf");
 #endif
 		if (r) {
 			evdns_base_free_and_unlock(base, 0);
 			return NULL;
 		}
 	}
-	if (flags & EVDNS_BASE_DISABLE_WHEN_INACTIVE) { 
-		base->disable_when_inactive = 1; 
-	} 
- 
+	if (flags & EVDNS_BASE_DISABLE_WHEN_INACTIVE) {
+		base->disable_when_inactive = 1;
+	}
+
 	EVDNS_UNLOCK(base);
 	return base;
 }
@@ -4085,7 +4085,7 @@ static void
 evdns_nameserver_free(struct nameserver *server)
 {
 	if (server->socket >= 0)
-		evutil_closesocket(server->socket); 
+		evutil_closesocket(server->socket);
 	(void) event_del(&server->event);
 	event_debug_unassign(&server->event);
 	if (server->state == 0)
@@ -4123,16 +4123,16 @@ evdns_base_free_and_unlock(struct evdns_base *base, int fail_requests)
 	}
 	base->global_requests_inflight = base->global_requests_waiting = 0;
 
-	for (server = base->server_head; server; server = server_next) { 
-		server_next = server->next; 
-		/** already done something before */ 
-		server->probe_request = NULL; 
-		evdns_nameserver_free(server); 
-		if (server_next == base->server_head) 
-			break; 
-	} 
-	base->server_head = NULL; 
-	base->global_good_nameservers = 0; 
+	for (server = base->server_head; server; server = server_next) {
+		server_next = server->next;
+		/** already done something before */
+		server->probe_request = NULL;
+		evdns_nameserver_free(server);
+		if (server_next == base->server_head)
+			break;
+	}
+	base->server_head = NULL;
+	base->global_good_nameservers = 0;
 
 	if (base->global_search_state) {
 		for (dom = base->global_search_state->head; dom; dom = dom_next) {
@@ -4167,18 +4167,18 @@ evdns_base_free(struct evdns_base *base, int fail_requests)
 }
 
 void
-evdns_base_clear_host_addresses(struct evdns_base *base) 
-{ 
-	struct hosts_entry *victim; 
-	EVDNS_LOCK(base); 
-	while ((victim = TAILQ_FIRST(&base->hostsdb))) { 
-		TAILQ_REMOVE(&base->hostsdb, victim, next); 
-		mm_free(victim); 
-	} 
-	EVDNS_UNLOCK(base); 
-} 
- 
-void 
+evdns_base_clear_host_addresses(struct evdns_base *base)
+{
+	struct hosts_entry *victim;
+	EVDNS_LOCK(base);
+	while ((victim = TAILQ_FIRST(&base->hostsdb))) {
+		TAILQ_REMOVE(&base->hostsdb, victim, next);
+		mm_free(victim);
+	}
+	EVDNS_UNLOCK(base);
+}
+
+void
 evdns_shutdown(int fail_requests)
 {
 	if (current_base) {
@@ -4253,7 +4253,7 @@ evdns_base_load_hosts_impl(struct evdns_base *base, const char *hosts_fname)
 	ASSERT_LOCKED(base);
 
 	if (hosts_fname == NULL ||
-	    (err = evutil_read_file_(hosts_fname, &str, &len, 0)) < 0) { 
+	    (err = evutil_read_file_(hosts_fname, &str, &len, 0)) < 0) {
 		char tmp[64];
 		strlcpy(tmp, "127.0.0.1   localhost", sizeof(tmp));
 		evdns_base_parse_hosts_line(base, tmp);
@@ -4482,22 +4482,22 @@ evdns_getaddrinfo_gotresolve(int result, char type, int count,
 		other_req = &data->ipv4_request;
 	}
 
-	/** Called from evdns_base_free() with @fail_requests == 1 */ 
-	if (result != DNS_ERR_SHUTDOWN) { 
-		EVDNS_LOCK(data->evdns_base); 
-		if (evdns_result_is_answer(result)) { 
-			if (req->type == DNS_IPv4_A) 
-				++data->evdns_base->getaddrinfo_ipv4_answered; 
-			else 
-				++data->evdns_base->getaddrinfo_ipv6_answered; 
-		} 
-		user_canceled = data->user_canceled; 
-		if (other_req->r == NULL) 
-			data->request_done = 1; 
-		EVDNS_UNLOCK(data->evdns_base); 
-	} else { 
-		data->evdns_base = NULL; 
-		user_canceled = data->user_canceled; 
+	/** Called from evdns_base_free() with @fail_requests == 1 */
+	if (result != DNS_ERR_SHUTDOWN) {
+		EVDNS_LOCK(data->evdns_base);
+		if (evdns_result_is_answer(result)) {
+			if (req->type == DNS_IPv4_A)
+				++data->evdns_base->getaddrinfo_ipv4_answered;
+			else
+				++data->evdns_base->getaddrinfo_ipv6_answered;
+		}
+		user_canceled = data->user_canceled;
+		if (other_req->r == NULL)
+			data->request_done = 1;
+		EVDNS_UNLOCK(data->evdns_base);
+	} else {
+		data->evdns_base = NULL;
+		user_canceled = data->user_canceled;
 	}
 
 	req->r = NULL;
@@ -4532,9 +4532,9 @@ evdns_getaddrinfo_gotresolve(int result, char type, int count,
 			/* The other request is still working; maybe it will
 			 * succeed. */
 			/* XXXX handle failure from set_timeout */
-			if (result != DNS_ERR_SHUTDOWN) { 
-				evdns_getaddrinfo_set_timeout(data->evdns_base, data); 
-			} 
+			if (result != DNS_ERR_SHUTDOWN) {
+				evdns_getaddrinfo_set_timeout(data->evdns_base, data);
+			}
 			data->pending_error = err;
 			return;
 		}
@@ -4595,7 +4595,7 @@ evdns_getaddrinfo_gotresolve(int result, char type, int count,
 	for (i=0; i < count; ++i) {
 		struct evutil_addrinfo *ai;
 		memcpy(addrp, ((char*)addresses)+i*addrlen, addrlen);
-		ai = evutil_new_addrinfo_(sa, socklen, &data->hints); 
+		ai = evutil_new_addrinfo_(sa, socklen, &data->hints);
 		if (!ai) {
 			if (other_req->r) {
 				evdns_cancel_request(NULL, other_req->r);
@@ -4608,7 +4608,7 @@ evdns_getaddrinfo_gotresolve(int result, char type, int count,
 				free_getaddrinfo_request(data);
 			return;
 		}
-		res = evutil_addrinfo_append_(res, ai); 
+		res = evutil_addrinfo_append_(res, ai);
 	}
 
 	if (other_req->r) {
@@ -4622,10 +4622,10 @@ evdns_getaddrinfo_gotresolve(int result, char type, int count,
 		 * results (if any) and return them. */
 		if (data->pending_result) {
 			if (req->type == DNS_IPv4_A)
-				res = evutil_addrinfo_append_(res, 
+				res = evutil_addrinfo_append_(res,
 				    data->pending_result);
 			else
-				res = evutil_addrinfo_append_( 
+				res = evutil_addrinfo_append_(
 				    data->pending_result, res);
 			data->pending_result = NULL;
 		}
@@ -4675,13 +4675,13 @@ evdns_getaddrinfo_fromhosts(struct evdns_base *base,
 		if ((e->addr.sa.sa_family == AF_INET && f == PF_INET6) ||
 		    (e->addr.sa.sa_family == AF_INET6 && f == PF_INET))
 			continue;
-		ai_new = evutil_new_addrinfo_(&e->addr.sa, e->addrlen, hints); 
+		ai_new = evutil_new_addrinfo_(&e->addr.sa, e->addrlen, hints);
 		if (!ai_new) {
 			n_found = 0;
 			goto out;
 		}
 		sockaddr_setport(ai_new->ai_addr, port);
-		ai = evutil_addrinfo_append_(ai, ai_new); 
+		ai = evutil_addrinfo_append_(ai, ai_new);
 	}
 	EVDNS_UNLOCK(base);
 out:
@@ -4709,7 +4709,7 @@ evdns_getaddrinfo(struct evdns_base *dns_base,
 	int err;
 	int port = 0;
 	int want_cname = 0;
-	int started = 0; 
+	int started = 0;
 
 	if (!dns_base) {
 		dns_base = current_base;
@@ -4737,14 +4737,14 @@ evdns_getaddrinfo(struct evdns_base *dns_base,
 		hints.ai_family = PF_UNSPEC;
 	}
 
-	evutil_adjust_hints_for_addrconfig_(&hints); 
+	evutil_adjust_hints_for_addrconfig_(&hints);
 
 	/* Now try to see if we _can_ answer immediately. */
 	/* (It would be nice to do this by calling getaddrinfo directly, with
 	 * AI_NUMERICHOST, on plaforms that have it, but we can't: there isn't
 	 * a reliable way to distinguish the "that wasn't a numeric host!" case
 	 * from any other EAI_NONAME cases.) */
-	err = evutil_getaddrinfo_common_(nodename, servname, &hints, &res, &port); 
+	err = evutil_getaddrinfo_common_(nodename, servname, &hints, &res, &port);
 	if (err != EVUTIL_EAI_NEED_RESOLVE) {
 		cb(err, res, arg);
 		return NULL;
@@ -4788,8 +4788,8 @@ evdns_getaddrinfo(struct evdns_base *dns_base,
 	 * launching those requests. (XXX we don't do that yet.)
 	 */
 
-	EVDNS_LOCK(dns_base); 
- 
+	EVDNS_LOCK(dns_base);
+
 	if (hints.ai_family != PF_INET6) {
 		log(EVDNS_LOG_DEBUG, "Sending request for %s on ipv4 as %p",
 		    nodename, &data->ipv4_request);
@@ -4797,7 +4797,7 @@ evdns_getaddrinfo(struct evdns_base *dns_base,
 		data->ipv4_request.r = evdns_base_resolve_ipv4(dns_base,
 		    nodename, 0, evdns_getaddrinfo_gotresolve,
 		    &data->ipv4_request);
-		if (want_cname && data->ipv4_request.r) 
+		if (want_cname && data->ipv4_request.r)
 			data->ipv4_request.r->current_req->put_cname_in_ptr =
 			    &data->cname_result;
 	}
@@ -4808,7 +4808,7 @@ evdns_getaddrinfo(struct evdns_base *dns_base,
 		data->ipv6_request.r = evdns_base_resolve_ipv6(dns_base,
 		    nodename, 0, evdns_getaddrinfo_gotresolve,
 		    &data->ipv6_request);
-		if (want_cname && data->ipv6_request.r) 
+		if (want_cname && data->ipv6_request.r)
 			data->ipv6_request.r->current_req->put_cname_in_ptr =
 			    &data->cname_result;
 	}
@@ -4816,11 +4816,11 @@ evdns_getaddrinfo(struct evdns_base *dns_base,
 	evtimer_assign(&data->timeout, dns_base->event_base,
 	    evdns_getaddrinfo_timeout_cb, data);
 
-	started = (data->ipv4_request.r || data->ipv6_request.r); 
- 
-	EVDNS_UNLOCK(dns_base); 
- 
-	if (started) { 
+	started = (data->ipv4_request.r || data->ipv6_request.r);
+
+	EVDNS_UNLOCK(dns_base);
+
+	if (started) {
 		return data;
 	} else {
 		mm_free(data);