diff --git a/src/Client/Connection.hpp b/src/Client/Connection.hpp
index d9626f0ba..b2c6b8fe2 100644
--- a/src/Client/Connection.hpp
+++ b/src/Client/Connection.hpp
@@ -79,8 +79,24 @@ struct ConnectionImpl
 	void ref();
 	void unref();
 
+	typename NetProvider::Stream_t &get_strm() { return strm; }
+	const typename NetProvider::Stream_t &get_strm() const { return strm; }
+
+	void setError(const std::string &msg, int errno_ = 0);
+	bool hasError() const;
+
+	size_t getFutureCount() const;
+
+	BUFFER &getInBuf();
+	BUFFER &getOutBuf();
+
+	void prepare_auth(std::string_view user, std::string_view passwd);
+	void commit_auth(std::string_view user, std::string_view passwd);
+
 	Connector<BUFFER, NetProvider> &connector;
 	BUFFER inBuf;
+	static constexpr size_t GC_STEP_CNT = 100;
+	size_t gc_step = 0;
 	BUFFER outBuf;
 	RequestEncoder<BUFFER> enc;
 	ResponseDecoder<BUFFER> dec;
@@ -111,8 +127,8 @@ template<class BUFFER, class NetProvider>
 ConnectionImpl<BUFFER, NetProvider>::~ConnectionImpl()
 {
 	assert(refs == 0);
-	if (!strm.has_status(SS_DEAD)) {
-		connector.close(*this);
+	if (strm.is_open()) {
+		connector.close(this);
 	}
 }
 
@@ -133,6 +149,56 @@ ConnectionImpl<BUFFER, NetProvider>::unref()
 		delete this;
 }
 
+template <class BUFFER, class NetProvider>
+void
+ConnectionImpl<BUFFER, NetProvider>::setError(const std::string &msg, int errno_)
+{
+	error.emplace(msg, errno_);
+}
+
+template <class BUFFER, class NetProvider>
+bool
+ConnectionImpl<BUFFER, NetProvider>::hasError() const
+{
+	return error.has_value();
+}
+
+template <class BUFFER, class NetProvider>
+size_t
+ConnectionImpl<BUFFER, NetProvider>::getFutureCount() const
+{
+	return futures.size();
+}
+
+template <class BUFFER, class NetProvider>
+BUFFER &
+ConnectionImpl<BUFFER, NetProvider>::getInBuf()
+{
+	return inBuf;
+}
+
+template <class BUFFER, class NetProvider>
+BUFFER &
+ConnectionImpl<BUFFER, NetProvider>::getOutBuf()
+{
+	return outBuf;
+}
+
+template <class BUFFER, class NetProvider>
+void
+ConnectionImpl<BUFFER, NetProvider>::prepare_auth(std::string_view user, std::string_view passwd)
+{
+	enc.encodeAuth(user, passwd, greeting);
+}
+
+template <class BUFFER, class NetProvider>
+void
+ConnectionImpl<BUFFER, NetProvider>::commit_auth(std::string_view user, std::string_view passwd)
+{
+	enc.reencodeAuth(user, passwd, greeting);
+	connector.readyToSend(this);
+}
+
 /** Each connection is supposed to be bound to a single socket. */
 template<class BUFFER, class NetProvider>
 class Connection
@@ -212,44 +278,11 @@ class Connection
 	BUFFER& getInBuf();
 	BUFFER& getOutBuf();
 
-	template<class B, class N>
-	friend
-	void hasSentBytes(Connection<B, N> &conn, size_t bytes);
-
-	template<class B, class N>
-	friend
-	void hasNotRecvBytes(Connection<B, N> &conn, size_t bytes);
-
-	template<class B, class N>
-	friend
-	bool hasDataToSend(Connection<B, N> &conn);
-
-	template<class B, class N>
-	friend
-	bool hasDataToDecode(Connection<B, N> &conn);
-
-	template<class B, class N>
-	friend
-	enum DecodeStatus processResponse(Connection<B, N> &conn, int req_sync, Response<B> *result);
-
-	template<class B, class N>
-	friend
-	void inputBufGC(Connection<B, N> &conn);
-
-	template<class B, class N>
-	friend
-	int decodeGreeting(Connection<B, N> &conn);
-
-	rid_t prepare_auth(std::string_view user,
-			   std::string_view passwd);
-
-	rid_t commit_auth(std::string_view user,
-			  std::string_view passwd);
+	void prepare_auth(std::string_view user, std::string_view passwd);
+	void commit_auth(std::string_view user, std::string_view passwd);
 
 private:
 	ConnectionImpl<BUFFER, NetProvider> *impl;
-	static constexpr size_t GC_STEP_CNT = 100;
-	size_t gc_step = 0;
 
 	template <class T>
 	rid_t insert(const T &tuple, uint32_t space_id);
@@ -435,21 +468,21 @@ template<class BUFFER, class NetProvider>
 size_t
 Connection<BUFFER, NetProvider>::getFutureCount() const
 {
-	return impl->futures.size();
+	return impl->getFutureCount();
 }
 
 template<class BUFFER, class NetProvider>
 void
 Connection<BUFFER, NetProvider>::setError(const std::string &msg, int errno_)
 {
-	impl->error.emplace(msg, errno_);
+	impl->setError(msg, errno_);
 }
 
 template<class BUFFER, class NetProvider>
 bool
 Connection<BUFFER, NetProvider>::hasError() const
 {
-	return impl->error.has_value();
+	return impl->hasError();
 }
 
 template<class BUFFER, class NetProvider>
@@ -471,73 +504,79 @@ template<class BUFFER, class NetProvider>
 BUFFER&
 Connection<BUFFER, NetProvider>::getInBuf()
 {
-	return impl->inBuf;
+	return impl->getInBuf();
 }
 
 template<class BUFFER, class NetProvider>
 BUFFER&
 Connection<BUFFER, NetProvider>::getOutBuf()
 {
-	return impl->outBuf;
+	return impl->getOutBuf();
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 void
-hasSentBytes(Connection<BUFFER, NetProvider> &conn, size_t bytes)
+hasSentBytes(ConnectionImpl<BUFFER, NetProvider> *conn, size_t bytes)
 {
 	//dropBack()/dropFront() interfaces require number of bytes be greater
 	//than zero so let's check it first.
 	if (bytes > 0)
-		conn.impl->outBuf.dropFront(bytes);
+		conn->getOutBuf().dropFront(bytes);
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 void
-hasNotRecvBytes(Connection<BUFFER, NetProvider> &conn, size_t bytes)
+hasNotRecvBytes(ConnectionImpl<BUFFER, NetProvider> *conn, size_t bytes)
 {
 	if (bytes > 0)
-		conn.impl->inBuf.dropBack(bytes);
+		conn->getInBuf().dropBack(bytes);
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 bool
-hasDataToSend(Connection<BUFFER, NetProvider> &conn)
+hasDataToSend(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
 	//We drop content of input buffer once it has been sent. So to detect
 	//if there's any data to send it's enough to check buffer's emptiness.
-	return !conn.impl->outBuf.empty();
+	return !conn->getOutBuf().empty();
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 bool
 hasDataToDecode(Connection<BUFFER, NetProvider> &conn)
 {
-	assert(conn.impl->endDecoded < conn.impl->inBuf.end() ||
-	       conn.impl->endDecoded == conn.impl->inBuf.end());
-	return conn.impl->endDecoded != conn.impl->inBuf.end();
+	return hasDataToDecode(conn.getImpl());
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
+bool
+hasDataToDecode(ConnectionImpl<BUFFER, NetProvider> *conn)
+{
+	assert(conn->endDecoded < conn->getInBuf().end() || conn->endDecoded == conn->getInBuf().end());
+	return conn->endDecoded != conn->getInBuf().end();
+}
+
+template <class BUFFER, class NetProvider>
 static void
-inputBufGC(Connection<BUFFER, NetProvider> &conn)
+inputBufGC(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
-	if ((conn.gc_step++ % Connection<BUFFER, NetProvider>::GC_STEP_CNT) == 0) {
-		LOG_DEBUG("Flushed input buffer of the connection %p", &conn);
-		conn.impl->inBuf.flush();
+	if (conn->gc_step++ % ConnectionImpl<BUFFER, NetProvider>::GC_STEP_CNT == 0) {
+		LOG_DEBUG("Flushed input buffer of the connection %p", conn);
+		conn->getInBuf().flush();
 	}
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 DecodeStatus
-processResponse(Connection<BUFFER, NetProvider> &conn, int req_sync, Response<BUFFER> *result)
+processResponse(ConnectionImpl<BUFFER, NetProvider> *conn, int req_sync, Response<BUFFER> *result)
 {
 	//Decode response. In case of success - fill in feature map
 	//and adjust end-of-decoded data pointer. Call GC if needed.
-	if (! conn.impl->inBuf.has(conn.impl->endDecoded, MP_RESPONSE_SIZE))
+	if (!conn->getInBuf().has(conn->endDecoded, MP_RESPONSE_SIZE))
 		return DECODE_NEEDMORE;
 
 	Response<BUFFER> response;
-	response.size = conn.impl->dec.decodeResponseSize();
+	response.size = conn->dec.decodeResponseSize();
 	if (response.size < 0) {
 		LOG_ERROR("Failed to decode response size");
 		//In case of corrupted response size all other data in the buffer
@@ -548,15 +587,15 @@ processResponse(Connection<BUFFER, NetProvider> &conn, int req_sync, Response<BU
 
 	}
 	response.size += MP_RESPONSE_SIZE;
-	if (! conn.impl->inBuf.has(conn.impl->endDecoded, response.size)) {
+	if (!conn->getInBuf().has(conn->endDecoded, response.size)) {
 		//Response was received only partially. Reset decoder position
 		//to the start of response to make this function re-entered.
-		conn.impl->dec.reset(conn.impl->endDecoded);
+		conn->dec.reset(conn->endDecoded);
 		return DECODE_NEEDMORE;
 	}
-	if (conn.impl->dec.decodeResponse(response) != 0) {
-		conn.setError("Failed to decode response, skipping bytes..");
-		conn.impl->endDecoded += response.size;
+	if (conn->dec.decodeResponse(response) != 0) {
+		conn->setError("Failed to decode response, skipping bytes..");
+		conn->endDecoded += response.size;
 		return DECODE_ERR;
 	}
 	LOG_DEBUG("Header: sync=", response.header.sync, ", code=",
@@ -564,39 +603,37 @@ processResponse(Connection<BUFFER, NetProvider> &conn, int req_sync, Response<BU
 	if (result != nullptr && response.header.sync == req_sync) {
 		*result = std::move(response);
 	} else {
-		conn.impl->futures.insert({response.header.sync,
-					   std::move(response)});
+		conn->futures.insert({response.header.sync, std::move(response)});
 	}
-	conn.impl->endDecoded += response.size;
+	conn->endDecoded += response.size;
 	inputBufGC(conn);
 	return DECODE_SUCC;
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 int
-decodeGreeting(Connection<BUFFER, NetProvider> &conn)
+decodeGreeting(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
 	//TODO: that's not zero-copy, should be rewritten in that pattern.
-	assert(conn.getInBuf().has(conn.impl->endDecoded, Iproto::GREETING_SIZE));
+	assert(conn->getInBuf().has(conn->endDecoded, Iproto::GREETING_SIZE));
 	char greeting_buf[Iproto::GREETING_SIZE];
-	conn.impl->endDecoded.read({greeting_buf, sizeof(greeting_buf)});
-	conn.impl->dec.reset(conn.impl->endDecoded);
-	if (parseGreeting(std::string_view{greeting_buf, Iproto::GREETING_SIZE},
-			  conn.impl->greeting) != 0)
+	conn->endDecoded.read({greeting_buf, sizeof(greeting_buf)});
+	conn->dec.reset(conn->endDecoded);
+	if (parseGreeting(std::string_view {greeting_buf, Iproto::GREETING_SIZE}, conn->greeting) != 0)
 		return -1;
-	conn.impl->is_greeting_received = true;
-	LOG_DEBUG("Version: ", conn.impl->greeting.version_id);
+	conn->is_greeting_received = true;
+	LOG_DEBUG("Version: ", conn->greeting.version_id);
 
 #ifndef NDEBUG
 	//print salt in hex format.
 	char hex_salt[Iproto::MAX_SALT_SIZE * 2 + 1];
 	const char *hex = "0123456789abcdef";
-	for (size_t i = 0; i < conn.impl->greeting.salt_size; i++) {
-		uint8_t u = conn.impl->greeting.salt[i];
+	for (size_t i = 0; i < conn->greeting.salt_size; i++) {
+		uint8_t u = conn->greeting.salt[i];
 		hex_salt[i * 2] = hex[u / 16];
 		hex_salt[i * 2 + 1] = hex[u % 16];
 	}
-	hex_salt[conn.impl->greeting.salt_size * 2] = 0;
+	hex_salt[conn->greeting.salt_size * 2] = 0;
 	LOG_DEBUG("Salt: ", hex_salt);
 #endif
 	return 0;
@@ -717,21 +754,16 @@ Connection<BUFFER, NetProvider>::select(const T &key, uint32_t space_id,
 	return impl->enc.getSync();
 }
 
-template<class BUFFER, class NetProvider>
-rid_t
-Connection<BUFFER, NetProvider>::prepare_auth(std::string_view user,
-					      std::string_view passwd)
+template <class BUFFER, class NetProvider>
+void
+Connection<BUFFER, NetProvider>::prepare_auth(std::string_view user, std::string_view passwd)
 {
-	impl->enc.encodeAuth(user, passwd, impl->greeting);
-	return 0;
+	impl->prepare_auth(user, passwd);
 }
 
-template<class BUFFER, class NetProvider>
-rid_t
-Connection<BUFFER, NetProvider>::commit_auth(std::string_view user,
-					      std::string_view passwd)
+template <class BUFFER, class NetProvider>
+void
+Connection<BUFFER, NetProvider>::commit_auth(std::string_view user, std::string_view passwd)
 {
-	impl->enc.reencodeAuth(user, passwd, impl->greeting);;
-	impl->connector.readyToSend(*this);
-	return 0;
+	impl->commit_auth(user, passwd);
 }
diff --git a/src/Client/Connector.hpp b/src/Client/Connector.hpp
index f0d52ded1..f2b9b6033 100644
--- a/src/Client/Connector.hpp
+++ b/src/Client/Connector.hpp
@@ -82,13 +82,14 @@ class Connector
 		      size_t feature_count, int timeout = -1);
 	std::optional<Connection<BUFFER, NetProvider>> waitAny(int timeout = -1);
 	////////////////////////////Service interfaces//////////////////////////
-	void readyToDecode(const Connection<BUFFER, NetProvider> &conn);
-	void readyToSend(const Connection<BUFFER, NetProvider> &conn);
-	void finishSend(const Connection<BUFFER, NetProvider> &conn);
+	void readyToDecode(ConnectionImpl<BUFFER, NetProvider> *conn);
+	void readyToSend(ConnectionImpl<BUFFER, NetProvider> *conn);
+	void readyToSend(Connection<BUFFER, NetProvider> &conn);
+	void finishSend(ConnectionImpl<BUFFER, NetProvider> *conn);
 
-	std::set<Connection<BUFFER, NetProvider>> m_ReadyToSend;
+	std::set<ConnectionImpl<BUFFER, NetProvider> *> m_ReadyToSend;
 	void close(Connection<BUFFER, NetProvider> &conn);
-	void close(ConnectionImpl<BUFFER, NetProvider> &conn);
+	void close(ConnectionImpl<BUFFER, NetProvider> *conn);
 
 private:
 	/**
@@ -98,6 +99,8 @@ class Connector
 	 * `req_sync` sync. If `result` is `nullptr` - `req_sync` is ignored.
 	 * Returns -1 in the case of any error, 0 on success.
 	 */
+	int connectionDecodeResponses(ConnectionImpl<BUFFER, NetProvider> *conn, int req_sync = -1,
+				      Response<BUFFER> *result = nullptr);
 	int connectionDecodeResponses(Connection<BUFFER, NetProvider> &conn, int req_sync = -1,
 				      Response<BUFFER> *result = nullptr);
 	/**
@@ -125,7 +128,11 @@ class Connector
 	 * Shouldn't be modified directly - is managed by methods `readyToDecode`
 	 * and `connectionDecodeResponses`.
 	 */
-	std::set<Connection<BUFFER, NetProvider>> m_ReadyToDecode;
+	std::set<ConnectionImpl<BUFFER, NetProvider> *> m_ReadyToDecode;
+	/**
+	 * Set of active connections owned by connector.
+	 */
+	std::set<ConnectionImpl<BUFFER, NetProvider> *> m_Connections;
 };
 
 template<class BUFFER, class NetProvider>
@@ -145,7 +152,7 @@ Connector<BUFFER, NetProvider>::connect(Connection<BUFFER, NetProvider> &conn,
 {
 	//Make sure that connection is not yet established.
 	assert(conn.get_strm().has_status(SS_DEAD));
-	if (m_NetProvider.connect(conn, opts) != 0) {
+	if (m_NetProvider.connect(conn.getImpl(), opts) != 0) {
 		LOG_ERROR("Failed to connect to ",
 			  opts.address, ':', opts.service);
 		return -1;
@@ -154,10 +161,11 @@ Connector<BUFFER, NetProvider>::connect(Connection<BUFFER, NetProvider> &conn,
 	conn.getImpl()->is_auth_required = !opts.user.empty();
 	if (conn.getImpl()->is_auth_required) {
 		// Encode auth request to reserve space in buffer.
-		conn.prepare_auth(opts.user, opts.passwd);
+		conn.getImpl()->prepare_auth(opts.user, opts.passwd);
 	}
 	LOG_DEBUG("Connection to ", opts.address, ':', opts.service,
 		  " has been established");
+	m_Connections.insert(conn.getImpl());
 	return 0;
 }
 
@@ -178,20 +186,24 @@ template<class BUFFER, class NetProvider>
 void
 Connector<BUFFER, NetProvider>::close(Connection<BUFFER, NetProvider> &conn)
 {
-	return close(*conn.getImpl());
+	return close(conn.getImpl());
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 void
-Connector<BUFFER, NetProvider>::close(ConnectionImpl<BUFFER, NetProvider> &conn)
+Connector<BUFFER, NetProvider>::close(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
-	assert(!conn.strm.has_status(SS_DEAD));
-	m_NetProvider.close(conn.strm);
+	if (conn->get_strm().is_open()) {
+		m_NetProvider.close(conn->get_strm());
+		m_ReadyToSend.erase(conn);
+		m_ReadyToDecode.erase(conn);
+		m_Connections.erase(conn);
+	}
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 int
-Connector<BUFFER, NetProvider>::connectionDecodeResponses(Connection<BUFFER, NetProvider> &conn, int req_sync,
+Connector<BUFFER, NetProvider>::connectionDecodeResponses(ConnectionImpl<BUFFER, NetProvider> *conn, int req_sync,
 							  Response<BUFFER> *result)
 {
 	if (!hasDataToDecode(conn))
@@ -222,6 +234,14 @@ Connector<BUFFER, NetProvider>::connectionDecodeResponses(Connection<BUFFER, Net
 	return rc;
 }
 
+template <class BUFFER, class NetProvider>
+int
+Connector<BUFFER, NetProvider>::connectionDecodeResponses(Connection<BUFFER, NetProvider> &conn, int req_sync,
+							  Response<BUFFER> *result)
+{
+	return connectionDecodeResponses(conn.getImpl(), req_sync, result);
+}
+
 template <class BUFFER, class NetProvider>
 int
 Connector<BUFFER, NetProvider>::connectionCheckResponsesReadiness(Connection<BUFFER, NetProvider> &conn,
@@ -342,9 +362,28 @@ template<class BUFFER, class NetProvider>
 std::optional<Connection<BUFFER, NetProvider>>
 Connector<BUFFER, NetProvider>::waitAny(int timeout)
 {
+	if (m_Connections.empty()) {
+		LOG_DEBUG("waitAny() called on connector without connections");
+		return std::nullopt;
+	}
+	for (auto *conn : m_Connections) {
+		if (conn->getFutureCount() != 0)
+			return conn;
+	}
 	Timer timer{timeout};
 	timer.start();
 	while (m_ReadyToDecode.empty()) {
+		bool has_alive_conn = false;
+		for (auto *conn : m_Connections) {
+			if (!conn->hasError()) {
+				has_alive_conn = true;
+				break;
+			}
+		}
+		if (!has_alive_conn) {
+			LOG_ERROR("All connections have an error");
+			return std::nullopt;
+		}
 		if (m_NetProvider.wait(timer.timeLeft()) != 0) {
 			LOG_ERROR("Failed to poll connections: ", strerror(errno));
 			return std::nullopt;
@@ -356,7 +395,7 @@ Connector<BUFFER, NetProvider>::waitAny(int timeout)
 		LOG_DEBUG("wait() has been timed out! No responses are received");
 		return std::nullopt;
 	}
-	Connection<BUFFER, NetProvider> conn = *m_ReadyToDecode.begin();
+	auto *conn = *m_ReadyToDecode.begin();
 	assert(hasDataToDecode(conn));
 	if (connectionDecodeResponses(conn) != 0)
 		return std::nullopt;
@@ -399,28 +438,34 @@ Connector<BUFFER, NetProvider>::waitCount(Connection<BUFFER, NetProvider> &conn,
 	return -1;
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 void
-Connector<BUFFER, NetProvider>::readyToSend(const Connection<BUFFER, NetProvider> &conn)
+Connector<BUFFER, NetProvider>::readyToSend(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
-	if (conn.getImpl()->is_auth_required &&
-	    !conn.getImpl()->is_greeting_received) {
+	if (conn->is_auth_required && !conn->is_greeting_received) {
 		// Need to receive greeting first.
 		return;
 	}
 	m_ReadyToSend.insert(conn);
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
+void
+Connector<BUFFER, NetProvider>::readyToSend(Connection<BUFFER, NetProvider> &conn)
+{
+	readyToSend(conn.getImpl());
+}
+
+template <class BUFFER, class NetProvider>
 void
-Connector<BUFFER, NetProvider>::readyToDecode(const Connection<BUFFER, NetProvider> &conn)
+Connector<BUFFER, NetProvider>::readyToDecode(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
 	m_ReadyToDecode.insert(conn);
 }
 
-template<class BUFFER, class NetProvider>
+template <class BUFFER, class NetProvider>
 void
-Connector<BUFFER, NetProvider>::finishSend(const Connection<BUFFER, NetProvider> &conn)
+Connector<BUFFER, NetProvider>::finishSend(ConnectionImpl<BUFFER, NetProvider> *conn)
 {
 	m_ReadyToSend.erase(conn);
 }
diff --git a/src/Client/EpollNetProvider.hpp b/src/Client/EpollNetProvider.hpp
index ccd6aa826..2999678cc 100644
--- a/src/Client/EpollNetProvider.hpp
+++ b/src/Client/EpollNetProvider.hpp
@@ -53,11 +53,11 @@ class EpollNetProvider {
 	using Buffer_t = BUFFER;
 	using Stream_t = Stream;
 	using NetProvider_t = EpollNetProvider<BUFFER, Stream>;
-	using Conn_t = Connection<BUFFER, NetProvider_t >;
+	using ConnImpl_t = ConnectionImpl<BUFFER, NetProvider_t>;
 	using Connector_t = Connector<BUFFER, NetProvider_t >;
 	EpollNetProvider(Connector_t &connector);
 	~EpollNetProvider();
-	int connect(Conn_t &conn, const ConnectOptions &opts);
+	int connect(ConnImpl_t *conn, const ConnectOptions &opts);
 	void close(Stream_t &strm);
 	/** Read and write to sockets; polling using epoll. */
 	int wait(int timeout);
@@ -69,11 +69,11 @@ class EpollNetProvider {
 	//return 0 if all data from buffer was processed (sent or read);
 	//return -1 in case of errors;
 	//return 1 in case socket is blocked.
-	int send(Conn_t &conn);
-	int recv(Conn_t &conn);
+	int send(ConnImpl_t *conn);
+	int recv(ConnImpl_t *conn);
 
-	void setPollSetting(Conn_t &conn, int setting);
-	void registerEpoll(Conn_t &conn);
+	void setPollSetting(ConnImpl_t *conn, int setting);
+	void registerEpoll(ConnImpl_t *conn);
 
 	/** <socket : connection> map. Contains both ready to read/send connections */
 	Connector_t &m_Connector;
@@ -98,17 +98,16 @@ EpollNetProvider<BUFFER, Stream>::~EpollNetProvider()
 	m_EpollFd = -1;
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 void
-EpollNetProvider<BUFFER, Stream>::registerEpoll(Conn_t &conn)
+EpollNetProvider<BUFFER, Stream>::registerEpoll(ConnImpl_t *conn)
 {
 	/* Configure epoll with new socket. */
 	assert(m_EpollFd >= 0);
 	struct epoll_event event;
 	event.events = EPOLLIN;
-	event.data.ptr = conn.getImpl();
-	if (epoll_ctl(m_EpollFd, EPOLL_CTL_ADD, conn.get_strm().get_fd(),
-		      &event) != 0) {
+	event.data.ptr = conn;
+	if (epoll_ctl(m_EpollFd, EPOLL_CTL_ADD, conn->get_strm().get_fd(), &event) != 0) {
 		LOG_ERROR("Failed to add socket to epoll: "
 			  "epoll_ctl() returned with errno: ",
 			  strerror(errno));
@@ -116,14 +115,14 @@ EpollNetProvider<BUFFER, Stream>::registerEpoll(Conn_t &conn)
 	}
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 void
-EpollNetProvider<BUFFER, Stream>::setPollSetting(Conn_t &conn, int setting) {
+EpollNetProvider<BUFFER, Stream>::setPollSetting(ConnImpl_t *conn, int setting)
+{
 	struct epoll_event event;
 	event.events = setting;
-	event.data.ptr = conn.getImpl();
-	if (epoll_ctl(m_EpollFd, EPOLL_CTL_MOD, conn.get_strm().get_fd(),
-		      &event) != 0) {
+	event.data.ptr = conn;
+	if (epoll_ctl(m_EpollFd, EPOLL_CTL_MOD, conn->get_strm().get_fd(), &event) != 0) {
 		LOG_ERROR("Failed to change epoll mode: "
 			  "epoll_ctl() returned with errno: ",
 			  strerror(errno));
@@ -131,15 +130,13 @@ EpollNetProvider<BUFFER, Stream>::setPollSetting(Conn_t &conn, int setting) {
 	}
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 int
-EpollNetProvider<BUFFER, Stream>::connect(Conn_t &conn,
-					  const ConnectOptions &opts)
+EpollNetProvider<BUFFER, Stream>::connect(ConnImpl_t *conn, const ConnectOptions &opts)
 {
-	auto &strm = conn.get_strm();
+	auto &strm = conn->get_strm();
 	if (strm.connect(opts) < 0) {
-		conn.setError("Failed to establish connection to " +
-			      opts.address);
+		conn->setError("Failed to establish connection to " + opts.address);
 		return -1;
 	}
 	LOG_DEBUG("Connected to ", opts.address, ", socket is ", strm.get_fd());
@@ -181,69 +178,66 @@ EpollNetProvider<BUFFER, Stream>::close(Stream_t& strm)
 	epoll_ctl(m_EpollFd, EPOLL_CTL_DEL, was_fd, nullptr);
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 int
-EpollNetProvider<BUFFER, Stream>::recv(Conn_t &conn)
+EpollNetProvider<BUFFER, Stream>::recv(ConnImpl_t *conn)
 {
-	auto &buf = conn.getInBuf();
+	auto &buf = conn->getInBuf();
 	auto itr = buf.template end<true>();
 	buf.write({CONN_READAHEAD});
 	struct iovec iov[IOVEC_MAX_SIZE];
 	size_t iov_cnt = buf.getIOV(itr, iov, IOVEC_MAX_SIZE);
 
-	ssize_t rcvd = conn.get_strm().recv(iov, iov_cnt);
+	ssize_t rcvd = conn->get_strm().recv(iov, iov_cnt);
 	hasNotRecvBytes(conn, CONN_READAHEAD - (rcvd < 0 ? 0 : rcvd));
 	if (rcvd < 0) {
-		conn.setError(std::string("Failed to receive response: ") +
-					  strerror(errno), errno);
+		conn->setError(std::string("Failed to receive response: ") + strerror(errno), errno);
 		return -1;
 	}
 
 	if (rcvd == 0) {
-		assert(conn.get_strm().has_status(SS_NEED_EVENT_FOR_READ));
-		if (conn.get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ))
+		assert(conn->get_strm().has_status(SS_NEED_EVENT_FOR_READ));
+		if (conn->get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ))
 			setPollSetting(conn, EPOLLIN | EPOLLOUT);
 	}
 
-	if (!conn.getImpl()->is_greeting_received) {
+	if (!conn->is_greeting_received) {
 		if ((size_t) rcvd < Iproto::GREETING_SIZE)
 			return 0;
 		/* Receive and decode greetings. */
 		LOG_DEBUG("Greetings are received, read bytes ", rcvd);
 		if (decodeGreeting(conn) != 0) {
-			conn.setError("Failed to decode greetings");
+			conn->setError("Failed to decode greetings");
 			return -1;
 		}
 		LOG_DEBUG("Greetings are decoded");
 		rcvd -= Iproto::GREETING_SIZE;
-		if (conn.getImpl()->is_auth_required) {
+		if (conn->is_auth_required) {
 			// Finalize auth request in buffer.
-			conn.commit_auth(conn.get_strm().get_opts().user,
-					 conn.get_strm().get_opts().passwd);
+			conn->commit_auth(conn->get_strm().get_opts().user, conn->get_strm().get_opts().passwd);
 		}
 	}
 
 	return 0;
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 int
-EpollNetProvider<BUFFER, Stream>::send(Conn_t &conn)
+EpollNetProvider<BUFFER, Stream>::send(ConnImpl_t *conn)
 {
 	while (hasDataToSend(conn)) {
 		struct iovec iov[IOVEC_MAX_SIZE];
-		auto &buf = conn.getOutBuf();
+		auto &buf = conn->getOutBuf();
 		size_t iov_cnt = buf.getIOV(buf.template begin<true>(),
 					    iov, IOVEC_MAX_SIZE);
 
-		ssize_t sent = conn.get_strm().send(iov, iov_cnt);
+		ssize_t sent = conn->get_strm().send(iov, iov_cnt);
 		if (sent < 0) {
-			conn.setError(std::string("Failed to send request: ") +
-				      strerror(errno), errno);
+			conn->setError(std::string("Failed to send request: ") + strerror(errno), errno);
 			return -1;
 		} else if (sent == 0) {
-			assert(conn.get_strm().has_status(SS_NEED_EVENT_FOR_WRITE));
-			if (conn.get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_WRITE))
+			assert(conn->get_strm().has_status(SS_NEED_EVENT_FOR_WRITE));
+			if (conn->get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_WRITE))
 				setPollSetting(conn, EPOLLIN | EPOLLOUT);
 			return 1;
 		} else {
@@ -265,8 +259,7 @@ EpollNetProvider<BUFFER, Stream>::wait(int timeout)
 	/* Send pending requests. */
 	for (auto conn = m_Connector.m_ReadyToSend.begin();
 	     conn != m_Connector.m_ReadyToSend.end();) {
-		Conn_t to_be_send(*conn);
-		(void) send(to_be_send);
+		(void)send(*conn);
 		conn = m_Connector.m_ReadyToSend.erase(conn);
 	}
 
@@ -280,12 +273,11 @@ EpollNetProvider<BUFFER, Stream>::wait(int timeout)
 		return -1;
 	}
 	for (int i = 0; i < event_cnt; ++i) {
-		Conn_t conn((typename Conn_t::Impl_t *)events[i].data.ptr);
+		auto *conn = reinterpret_cast<ConnImpl_t *>(events[i].data.ptr);
 		if ((events[i].events & EPOLLIN) != 0) {
-			LOG_DEBUG("Registered poll event ", i, ": ",
-				  conn.get_strm().get_fd(),
+			LOG_DEBUG("Registered poll event ", i, ": ", conn->get_strm().get_fd(),
 				  " socket is ready to read");
-			if (conn.get_strm().has_status(SS_NEED_READ_EVENT_FOR_WRITE)) {
+			if (conn->get_strm().has_status(SS_NEED_READ_EVENT_FOR_WRITE)) {
 				int rc = send(conn);
 				if (rc < 0)
 					return -1;
@@ -302,10 +294,9 @@ EpollNetProvider<BUFFER, Stream>::wait(int timeout)
 		}
 
 		if ((events[i].events & EPOLLOUT) != 0) {
-			LOG_DEBUG("Registered poll event ", i, ": ",
-				  conn.get_strm().get_fd(),
+			LOG_DEBUG("Registered poll event ", i, ": ", conn->get_strm().get_fd(),
 				  " socket is ready to write");
-			if (conn.get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ)) {
+			if (conn->get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ)) {
 				int rc = recv(conn);
 				if (rc < 0)
 					return -1;
diff --git a/src/Client/LibevNetProvider.hpp b/src/Client/LibevNetProvider.hpp
index 431d1c126..cbd039051 100644
--- a/src/Client/LibevNetProvider.hpp
+++ b/src/Client/LibevNetProvider.hpp
@@ -53,21 +53,22 @@ class LibevNetProvider;
 template<class BUFFER, class Stream>
 struct WaitWatcher {
 	WaitWatcher(Connector<BUFFER, LibevNetProvider<BUFFER, Stream>> *client,
-		    Connection<BUFFER, LibevNetProvider<BUFFER, Stream>> conn,
-		    struct ev_timer *t);
+		    ConnectionImpl<BUFFER, LibevNetProvider<BUFFER, Stream>> *conn, struct ev_timer *t);
 
 	struct ev_io in;
 	struct ev_io out;
 	Connector<BUFFER, LibevNetProvider<BUFFER, Stream>> *connector;
-	Connection<BUFFER, LibevNetProvider<BUFFER, Stream>> connection;
+	ConnectionImpl<BUFFER, LibevNetProvider<BUFFER, Stream>> *connection;
 	struct ev_timer *timer;
 };
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 WaitWatcher<BUFFER, Stream>::WaitWatcher(Connector<BUFFER, LibevNetProvider<BUFFER, Stream>> *client,
-					  Connection<BUFFER, LibevNetProvider<BUFFER, Stream>> conn,
-					  struct ev_timer *t) : connector(client), connection(conn),
-							        timer(t)
+					 ConnectionImpl<BUFFER, LibevNetProvider<BUFFER, Stream>> *conn,
+					 struct ev_timer *t)
+    : connector(client)
+    , connection(conn)
+    , timer(t)
 {
 	in.data = this;
 	out.data = this;
@@ -86,11 +87,11 @@ class LibevNetProvider {
 	using Buffer_t = BUFFER;
 	using Stream_t = Stream;
 	using NetProvider_t = LibevNetProvider<BUFFER, Stream>;
-	using Conn_t = Connection<BUFFER, NetProvider_t >;
+	using ConnImpl_t = ConnectionImpl<BUFFER, NetProvider_t>;
 	using Connector_t = Connector<BUFFER, NetProvider_t >;
 
 	LibevNetProvider(Connector_t &connector, struct ev_loop *loop = nullptr);
-	int connect(Conn_t &conn, const ConnectOptions &opts);
+	int connect(ConnImpl_t *conn, const ConnectOptions &opts);
 	void close(Stream_t &strm);
 	int wait(int timeout);
 
@@ -99,7 +100,7 @@ class LibevNetProvider {
 private:
 	static constexpr float MILLISECONDS = 1000.f;
 
-	void registerWatchers(Conn_t &conn, int fd);
+	void registerWatchers(ConnImpl_t *conn, int fd);
 	void stopWatchers(WaitWatcher<BUFFER, Stream> *watcher);
 	/** Callback for libev timeout. */
 	static void timeout_cb(EV_P_ ev_timer *w, int revents);
@@ -120,39 +121,37 @@ LibevNetProvider<BUFFER, Stream>::stopWatchers(struct WaitWatcher<BUFFER, Stream
 	ev_io_stop(m_Loop, &watcher->out);
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 static inline int
-connectionReceive(Connection<BUFFER,  LibevNetProvider<BUFFER, Stream>> &conn)
+connectionReceive(ConnectionImpl<BUFFER, LibevNetProvider<BUFFER, Stream>> *conn)
 {
-	auto &buf = conn.getInBuf();
+	auto &buf = conn->inBuf;
 	auto itr = buf.template end<true>();
 	buf.write({CONN_READAHEAD});
 	struct iovec iov[IOVEC_MAX_SIZE];
 	size_t iov_cnt = buf.getIOV(itr, iov, IOVEC_MAX_SIZE);
 
-	ssize_t rcvd = conn.get_strm().recv(iov, iov_cnt);
+	ssize_t rcvd = conn->get_strm().recv(iov, iov_cnt);
 	hasNotRecvBytes(conn, CONN_READAHEAD - (rcvd < 0 ? 0 : rcvd));
 	if (rcvd < 0) {
-		conn.setError(std::string("Failed to receive response: ") +
-			       strerror(errno), errno);
+		conn->setError(std::string("Failed to receive response: ") + strerror(errno), errno);
 		return -1;
 	}
 
-	if (!conn.getImpl()->is_greeting_received) {
+	if (!conn->is_greeting_received) {
 		if ((size_t) rcvd < Iproto::GREETING_SIZE)
 			return 0;
 		/* Receive and decode greetings. */
 		LOG_DEBUG("Greetings are received, read bytes ", rcvd);
 		if (decodeGreeting(conn) != 0) {
-			conn.setError("Failed to decode greetings");
+			conn->setError("Failed to decode greetings");
 			return -1;
 		}
 		LOG_DEBUG("Greetings are decoded");
 		rcvd -= Iproto::GREETING_SIZE;
-		if (conn.getImpl()->is_auth_required) {
+		if (conn->is_auth_required) {
 			// Finalize auth request in buffer.
-			conn.commit_auth(conn.get_strm().get_opts().user,
-					 conn.get_strm().get_opts().passwd);
+			conn->commit_auth(conn->get_strm().get_opts().user, conn->get_strm().get_opts().passwd);
 		}
 	}
 
@@ -163,17 +162,16 @@ template<class BUFFER, class Stream>
 static void
 recv_cb(struct ev_loop *loop, struct ev_io *watcher, int /* revents */)
 {
-	using NetProvider_t = LibevNetProvider<BUFFER, Stream>;
 	using Connector_t = Connector<BUFFER, LibevNetProvider<BUFFER, Stream>>;
 
 	struct WaitWatcher<BUFFER, Stream> *waitWatcher =
 		reinterpret_cast<WaitWatcher<BUFFER, Stream> *>(watcher->data);
 	assert(&waitWatcher->in == watcher);
-	Connection<BUFFER, NetProvider_t> conn = waitWatcher->connection;
-	assert(waitWatcher->in.fd == conn.get_strm().get_fd());
+	auto *conn = waitWatcher->connection;
+	assert(waitWatcher->in.fd == conn->get_strm().get_fd());
 
-	if (conn.get_strm().has_status(SS_NEED_READ_EVENT_FOR_WRITE))
-		ev_feed_fd_event(loop, conn.get_strm().get_fd(), EV_WRITE);
+	if (conn->get_strm().has_status(SS_NEED_READ_EVENT_FOR_WRITE))
+		ev_feed_fd_event(loop, conn->get_strm().get_fd(), EV_WRITE);
 
 	timerDisable(loop, waitWatcher->timer);
 	int rc = connectionReceive(conn);
@@ -182,7 +180,7 @@ recv_cb(struct ev_loop *loop, struct ev_io *watcher, int /* revents */)
 		return;
 	if (rc > 0) {
 		/* Recv is not complete, setting the write watcher if needed. */
-		if (conn.get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ))
+		if (conn->get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ))
 			if (!ev_is_active(&waitWatcher->out))
 				ev_io_start(loop, &waitWatcher->out);
 		return;
@@ -191,28 +189,26 @@ recv_cb(struct ev_loop *loop, struct ev_io *watcher, int /* revents */)
 		connector->readyToDecode(conn);
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 static inline int
-connectionSend(Connection<BUFFER,  LibevNetProvider<BUFFER, Stream>> &conn)
+connectionSend(ConnectionImpl<BUFFER, LibevNetProvider<BUFFER, Stream>> *conn)
 {
-	if (conn.getImpl()->is_auth_required &&
-	    !conn.getImpl()->is_greeting_received) {
+	if (conn->is_auth_required && !conn->is_greeting_received) {
 		// Need to receive greeting first.
 		return 0;
 	}
 	while (hasDataToSend(conn)) {
 		struct iovec iov[IOVEC_MAX_SIZE];
-		auto &buf = conn.getOutBuf();
+		auto &buf = conn->getOutBuf();
 		size_t iov_cnt = buf.getIOV(buf.template begin<true>(),
 					    iov, IOVEC_MAX_SIZE);
 
-		ssize_t sent = conn.get_strm().send(iov, iov_cnt);
+		ssize_t sent = conn->get_strm().send(iov, iov_cnt);
 		if (sent < 0) {
-			conn.setError(std::string("Failed to send request: ") +
-				      strerror(errno), errno);
+			conn->setError(std::string("Failed to send request: ") + strerror(errno), errno);
 			return -1;
 		} else if (sent == 0) {
-			assert(conn.get_strm().has_status(SS_NEED_EVENT_FOR_WRITE));
+			assert(conn->get_strm().has_status(SS_NEED_EVENT_FOR_WRITE));
 			return 1;
 		} else {
 			hasSentBytes(conn, sent);
@@ -226,18 +222,17 @@ template<class BUFFER, class Stream>
 static void
 send_cb(struct ev_loop *loop, struct ev_io *watcher, int /* revents */)
 {
-	using NetProvider_t = LibevNetProvider<BUFFER, Stream>;
 	using Connector_t = Connector<BUFFER, LibevNetProvider<BUFFER, Stream>>;
 
 	struct WaitWatcher<BUFFER, Stream> *waitWatcher =
 		reinterpret_cast<struct WaitWatcher<BUFFER, Stream> *>(watcher->data);
 	assert(&waitWatcher->out == watcher);
 	Connector_t *connector = waitWatcher->connector;
-	Connection<BUFFER, NetProvider_t> &conn = waitWatcher->connection;
-	assert(watcher->fd == conn.get_strm().get_fd());
+	auto *conn = waitWatcher->connection;
+	assert(watcher->fd == conn->get_strm().get_fd());
 
-	if (conn.get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ))
-		ev_feed_fd_event(loop, conn.get_strm().get_fd(), EV_READ);
+	if (conn->get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_READ))
+		ev_feed_fd_event(loop, conn->get_strm().get_fd(), EV_READ);
 
 	timerDisable(loop, waitWatcher->timer);
 	int rc = connectionSend(conn);
@@ -248,7 +243,7 @@ send_cb(struct ev_loop *loop, struct ev_io *watcher, int /* revents */)
 	if (rc > 0) {
 		/* Send is not complete, setting the write watcher. */
 		LOG_DEBUG("Send is not complete, setting the write watcher");
-		if (conn.get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_WRITE))
+		if (conn->get_strm().has_status(SS_NEED_WRITE_EVENT_FOR_WRITE))
 			if (!ev_is_active(&waitWatcher->out))
 				ev_io_start(loop, &waitWatcher->out);
 		return;
@@ -283,7 +278,7 @@ LibevNetProvider<BUFFER, Stream>::~LibevNetProvider()
 	for (auto w = m_Watchers.begin(); w != m_Watchers.end();) {
 		WaitWatcher<BUFFER, Stream> *to_delete = w->second;
 		stopWatchers(to_delete);
-		assert(to_delete->connection.get_strm().get_fd() == w->first);
+		assert(to_delete->connection->get_strm().get_fd() == w->first);
 		w = m_Watchers.erase(w);
 		delete to_delete;
 	}
@@ -294,9 +289,9 @@ LibevNetProvider<BUFFER, Stream>::~LibevNetProvider()
 	m_Loop = nullptr;
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 void
-LibevNetProvider<BUFFER, Stream>::registerWatchers(Conn_t &conn, int fd)
+LibevNetProvider<BUFFER, Stream>::registerWatchers(ConnImpl_t *conn, int fd)
 {
 	WaitWatcher<BUFFER, Stream> *watcher =
 		new (std::nothrow) WaitWatcher<BUFFER, Stream>(&m_Connector,
@@ -314,15 +309,13 @@ LibevNetProvider<BUFFER, Stream>::registerWatchers(Conn_t &conn, int fd)
 	ev_io_start(m_Loop ,&watcher->out);
 }
 
-template<class BUFFER, class Stream>
+template <class BUFFER, class Stream>
 int
-LibevNetProvider<BUFFER, Stream>::connect(Conn_t &conn,
-					  const ConnectOptions &opts)
+LibevNetProvider<BUFFER, Stream>::connect(ConnImpl_t *conn, const ConnectOptions &opts)
 {
-	auto &strm = conn.get_strm();
+	auto &strm = conn->get_strm();
 	if (strm.connect(opts) < 0) {
-		conn.setError("Failed to establish connection to " +
-			      opts.address);
+		conn->setError("Failed to establish connection to " + opts.address);
 		return -1;
 	}
 	LOG_DEBUG("Connected to ", opts.address, ", socket is ", strm.get_fd());
@@ -371,7 +364,7 @@ LibevNetProvider<BUFFER, Stream>::wait(int timeout)
 	/* Queue pending connections to be send. */
 	for (auto conn = m_Connector.m_ReadyToSend.begin();
 	     conn != m_Connector.m_ReadyToSend.end();) {
-		auto w = m_Watchers.find(conn->get_strm().get_fd());
+		auto w = m_Watchers.find((*conn)->get_strm().get_fd());
 		if (w != m_Watchers.end()) {
 			if (!ev_is_active(&w->second->out))
 				ev_feed_event(m_Loop, &w->second->out, EV_WRITE);
diff --git a/src/Client/UnixStream.hpp b/src/Client/UnixStream.hpp
index 5e8bc589b..289689c0b 100644
--- a/src/Client/UnixStream.hpp
+++ b/src/Client/UnixStream.hpp
@@ -66,6 +66,9 @@ class UnixStream : public Stream {
 	/** Get internal file descriptor of the socket. */
 	int get_fd() const { return fd; }
 
+	/** Check whether the socket is open. */
+	bool is_open() const { return fd != -1; }
+
 protected:
 	/** Log helpers. */
 	template <class ...MSG>
@@ -168,6 +171,7 @@ UnixStream::connect(const ConnectOptions &opts_arg)
 			      addr_info.last_error());
 	int socket_errno = 0, connect_errno = 0;
 	for (auto &inf: addr_info) {
+		socket_errno = connect_errno = 0;
 		fd = ::socket(inf.ai_family, inf.ai_socktype, inf.ai_protocol);
 		if (fd < 0) {
 			socket_errno = errno;
@@ -189,10 +193,7 @@ UnixStream::connect(const ConnectOptions &opts_arg)
 				return US_TELL(SS_ESTABLISHED,
 					       "Connected", opts);
 			} else if (errno == EINPROGRESS || errno == EAGAIN) {
-				// TODO remove timeout and #include <poll.h>
-				//return US_TELL(SS_CONNECT_PENDING,
-				//	       "Connect pending", opts);
-
+				errno = 0;
 				set_status(SS_CONNECT_PENDING);
 				struct pollfd fds;
 				fds.fd = fd;
@@ -206,7 +207,10 @@ UnixStream::connect(const ConnectOptions &opts_arg)
 			}
 		} while (errno == EINTR);
 		close();
-		connect_errno = errno;
+		if (connect_errno == 0)
+			connect_errno = errno;
+		else
+			assert(connect_errno == ETIMEDOUT && errno == 0);
 	}
 	if (connect_errno != 0)
 		return US_DIE("Failed to connect", strerror(connect_errno));
diff --git a/test/ClientMultithreadTest.cpp b/test/ClientMultithreadTest.cpp
index 5c4c068d3..ade6be056 100644
--- a/test/ClientMultithreadTest.cpp
+++ b/test/ClientMultithreadTest.cpp
@@ -47,6 +47,7 @@ test_connect(Connector &client, Connection &conn, const std::string &addr, unsig
 				      .address = addr,
 				      .service = service,
 				      .transport = transport,
+				      .connect_timeout = 10,
 				      .user = user,
 				      .passwd = passwd,
 			      });
diff --git a/test/ClientTest.cpp b/test/ClientTest.cpp
index 41e1424fd..6a8ae828f 100644
--- a/test/ClientTest.cpp
+++ b/test/ClientTest.cpp
@@ -182,6 +182,8 @@ trivial(Connector<BUFFER, NetProvider> &client)
 	TEST_CASE("Connect timeout");
 	rc = test_connect(client, conn, "8.8.8.8", port);
 	fail_unless(rc != 0);
+	TEST_CASE("Close of non-established connection (gh-142)");
+	client.close(conn);
 }
 
 /** Single connection, separate/sequence pings, no errors */
@@ -235,6 +237,9 @@ single_conn_ping(Connector<BUFFER, NetProvider> &client)
 		fail_unless(response->body.error_stack == std::nullopt);
 	}
 	client.close(conn);
+
+	TEST_CASE("Double close of connection (gh-142)");
+	client.close(conn);
 }
 
 template <class BUFFER, class NetProvider>
@@ -261,6 +266,23 @@ auto_close(Connector<BUFFER, NetProvider> &client)
 		std::optional<Response<Buf_t>> response = conn.getResponse(f);
 		fail_unless(response != std::nullopt);
 	}
+
+	TEST_CASE("Waiting after connection is automatically closed (gh-140)");
+	{
+		Connection<Buf_t, NetProvider> conn(client);
+		fail_unless(test_connect(client, conn, localhost, port) == 0);
+		rid_t f = conn.ping();
+		fail_unless(!conn.futureIsReady(f));
+	}
+	fail_unless(client.waitAny() == std::nullopt);
+	{
+		Connection<Buf_t, NetProvider> conn(client);
+		fail_unless(test_connect(client, conn, localhost, port) == 0);
+		rid_t f = conn.ping();
+		fail_unless(!conn.futureIsReady(f));
+		client.wait(conn, f, 0);
+	}
+	fail_unless(client.waitAny() == std::nullopt);
 }
 
 /** Several connection, separate/sequence pings, no errors */
@@ -1065,6 +1087,10 @@ test_sigpipe(void)
 	fail_unless(saved_errno == EPIPE);
 #endif
 	fail_if(conn.futureIsReady(f));
+
+	TEST_CASE("Close of connection with error (gh-142)");
+	fail_unless(conn.hasError());
+	client.close(conn);
 }
 
 /** Single connection, wait response from closed connection. */
@@ -1092,11 +1118,9 @@ test_dead_connection_wait(void)
 	fail_if(client.waitCount(conn, 1) == 0);
 	fail_if(conn.futureIsReady(f));
 
-	/* FIXME(gh-51) */
-#if 0
+	TEST_CASE("waitAny() correctly handles case when all connections have an error (gh-51");
 	fail_if(client.waitAny() != std::nullopt);
 	fail_if(conn.futureIsReady(f));
-#endif
 }
 
 /**
@@ -1381,13 +1405,10 @@ test_wait(Connector<BUFFER, NetProvider> &client)
 	/* FIXME(gh-143): test solely that we check future readiness before waiting. */
 	fail_unless(client.waitCount(conn, 0) == 0);
 	conn.getResponse(f);
-	/* FIXME(gh-132): waitAny does not check connections for ready futures. */
-#if 0
 	f = conn.ping();
 	fail_unless(client.wait(conn, f, WAIT_TIMEOUT) == 0);
-	fail_unless(client.waitAny(conn).has_value());
+	fail_unless(client.waitAny().has_value());
 	conn.getResponse(f);
-#endif
 
 #ifdef __linux__
 	TEST_CASE("wait methods internal wait failure (gh-121)");
@@ -1425,6 +1446,9 @@ test_wait(Connector<BUFFER, NetProvider> &client)
 #endif /* __linux__ */
 
 	client.close(conn);
+
+	TEST_CASE("waitAny() correctly handles case when there are no connections (gh-51");
+	fail_if(client.waitAny() != std::nullopt);
 }
 
 int main()