Never use the resolver to "resolve" something that is already an IP address.

The resolver in boost::asio is by default a single-threaded pseudo-async thing, so while it is blocked by a lengthy lookup, no further lookups can proceed. If we use the resolver even if we have a perfectly good IP address to start with, we can get blocked by DNS resolution even if we don't need resolving at all...

Author: Medo42

faucet/IpLookup.cpp

@@ -7,17 +7,15 @@
 using namespace boost::asio::ip;
 std::shared_ptr<IpLookup> IpLookup::lookup(const char *lookup) {
 	std::shared_ptr<IpLookup> ipLookup (new IpLookup());
-	tcp::resolver::query query(lookup, "", tcp::resolver::query::address_configured);
-	ipLookup->resolver_.async_resolve(query, boost::bind(&IpLookup::handleResolve,
+	fct_async_resolve<tcp>(lookup, 0, ipLookup->resolver_, boost::bind(&IpLookup::handleResolve,
 			ipLookup, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
 	return ipLookup;
 }
 
-std::shared_ptr<IpLookup> IpLookup::lookup(const char *lookup, const tcp::resolver::protocol_type &protocol) {
+std::shared_ptr<IpLookup> IpLookup::lookup(const char *lookup, fct_lookup_protocol protocol) {
 	std::shared_ptr<IpLookup> ipLookup (new IpLookup());
-	tcp::resolver::query query(protocol, lookup, "", tcp::resolver::query::address_configured);
-	ipLookup->resolver_.async_resolve(query, boost::bind(&IpLookup::handleResolve,
-			ipLookup, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
+    fct_async_resolve<tcp>(lookup, 0, ipLookup->resolver_, boost::bind(&IpLookup::handleResolve,
+        ipLookup, boost::asio::placeholders::error, boost::asio::placeholders::iterator), protocol);
 	return ipLookup;
 }
 

faucet/IpLookup.hpp

@@ -8,11 +8,13 @@
 #include <string>
 #include <memory>
 
+#include <faucet/resolve.hpp>
+
 class IpLookup: public Handled,
 		boost::noncopyable {
 public:
 	static std::shared_ptr<IpLookup> lookup(const char *lookup);
-	static std::shared_ptr<IpLookup> lookup(const char *lookup, const boost::asio::ip::tcp::resolver::protocol_type &protocol);
+	static std::shared_ptr<IpLookup> lookup(const char *lookup, fct_lookup_protocol protocol);
 
 	bool ready();
 	bool hasNext();

faucet/resolve.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <faucet/Asio.hpp>
+#include <string>
+#include <functional>
+#include <boost/lexical_cast.hpp>
+
+enum class fct_lookup_protocol {V4, V6, ANY};
+
+template <typename InternetProtocol>
+void fct_async_resolve(std::string host, uint16_t port, typename InternetProtocol::resolver &resolver, std::function<void(const boost::system::error_code&, typename InternetProtocol::resolver::iterator)> handleResolve) {
+    fct_async_resolve<InternetProtocol>(host, port, resolver, handleResolve, fct_lookup_protocol::ANY);
+}
+
+/**
+ * Wrapper around resolver::async_resolve which will first attempt to interpret the hostname as a literal IP address.
+ * If it can be parsed this way, the handler function will be called synchronously.
+ */
+template <typename InternetProtocol>
+void fct_async_resolve(std::string host, uint16_t port, typename InternetProtocol::resolver &resolver, std::function<void(const boost::system::error_code&, typename InternetProtocol::resolver::iterator)> handleResolve, fct_lookup_protocol protocol) {
+	boost::system::error_code ec;
+	typename InternetProtocol::endpoint endpoint(boost::asio::ip::address::from_string(host, ec), port);
+
+	if(!ec) {
+        if((protocol == fct_lookup_protocol::V4 && endpoint.address().is_v4()) || (protocol == fct_lookup_protocol::V6 && endpoint.address().is_v6()) || protocol == fct_lookup_protocol::ANY) {
+            handleResolve(ec, InternetProtocol::resolver::iterator::create(endpoint, "", ""));
+        } else {
+            handleResolve(ec, typename InternetProtocol::resolver::iterator());
+        }
+	} else {
+	    std::string portStr(boost::lexical_cast<std::string>(port));
+	    typename InternetProtocol::resolver::query::flags flags(InternetProtocol::resolver::query::numeric_service | InternetProtocol::resolver::query::address_configured);
+	    typename InternetProtocol::resolver::query query([&](){
+	        if(protocol == fct_lookup_protocol::ANY) {
+                return typename InternetProtocol::resolver::query(host, portStr, flags);
+	        } else {
+	            return typename InternetProtocol::resolver::query((protocol == fct_lookup_protocol::V4) ? InternetProtocol::v4() : InternetProtocol::v6(), host, portStr, flags);
+	        }
+	    }());
+
+        resolver.async_resolve(query, handleResolve);
+	}
+}

faucet/socketApi.cpp

@@ -799,12 +799,12 @@ DLLEXPORT double ip_lookup_create(const char *host) {
 
 DLLEXPORT double ipv4_lookup_create(const char *host) {
 	MutexLock lock(*apiMutex);
-	return handles.allocate(IpLookup::lookup(host, boost::asio::ip::tcp::v4()));
+	return handles.allocate(IpLookup::lookup(host, fct_lookup_protocol::V4));
 }
 
 DLLEXPORT double ipv6_lookup_create(const char *host) {
 	MutexLock lock(*apiMutex);
-	return handles.allocate(IpLookup::lookup(host, boost::asio::ip::tcp::v6()));
+	return handles.allocate(IpLookup::lookup(host, fct_lookup_protocol::V6));
 }
 
 DLLEXPORT double ip_lookup_ready(double lookupHandle) {

faucet/tcp/connectionStates/TcpConnecting.cpp

@@ -6,6 +6,8 @@
 #include <boost/bind.hpp>
 #include <boost/thread/locks.hpp>
 
+#include <faucet/resolve.hpp>
+
 using namespace boost::asio::ip;
 
 TcpConnecting::TcpConnecting(TcpSocket &socket) :
@@ -16,9 +18,7 @@ TcpConnecting::TcpConnecting(TcpSocket &socket) :
 }
 
 void TcpConnecting::enter(const char *host, uint16_t port) {
-	tcp::resolver::query query(host, boost::lexical_cast<std::string>(port),
-			tcp::resolver::query::numeric_service | tcp::resolver::query::address_configured);
-	resolver.async_resolve(query, boost::bind(&TcpConnecting::handleResolve,
+    fct_async_resolve<tcp>(host, port, resolver, boost::bind(&TcpConnecting::handleResolve,
 			this, socket->shared_from_this(), boost::asio::placeholders::error,
 			boost::asio::placeholders::iterator));
 }

faucet/udp/UdpSocket.cpp

@@ -1,6 +1,7 @@
 #include "UdpSocket.hpp"
 
 #include "broadcastAddrs.hpp"
+#include <faucet/resolve.hpp>
 
 #include <boost/lexical_cast.hpp>
 #include <boost/make_shared.hpp>
@@ -242,15 +243,8 @@ void UdpSocket::asyncSend() {
 	sendqueue_.pop();
 	asyncSendInProgress_ = true;
 
-	boost::system::error_code ec;
-	udp::endpoint endpoint(address::from_string(item.remoteHost, ec), item.remotePort);
-	if(!ec) {
-		handleResolve(ec, udp::resolver::iterator::create(endpoint, "", ""), item.buffer);
-	} else {
-		udp::resolver::query query(item.remoteHost, boost::lexical_cast<std::string>(item.remotePort), udp::resolver::query::numeric_service | udp::resolver::query::address_configured);
-		resolver_.async_resolve(query, boost::bind(&UdpSocket::handleResolve, shared_from_this(),
+    fct_async_resolve<udp>(item.remoteHost, item.remotePort, resolver_, boost::bind(&UdpSocket::handleResolve, shared_from_this(),
 				boost::asio::placeholders::error, boost::asio::placeholders::iterator, item.buffer));
-	}
 }
 
 udp::socket *UdpSocket::getAppropriateSocket(const udp::endpoint &endpoint) {