# HG changeset patch
# User David Demelier <markand@malikania.fr>
# Date 1456153791 -3600
# Node ID 627284574e426b1d5e520750a287a1ceb64fa194
# Parent  ebe16d7afbe6533cd38d23a2dcd0804164a26b5e
Sockets: massive update

  - Separate Ip in Ipv4 and Ipv6,
  - Socket have no state, condition, action anymore (use Condition instead),
  - Get rid of Stream(Client|Connection|Server).

diff -r ebe16d7afbe6 -r 627284574e42 modules/sockets/CMakeLists.txt
--- a/modules/sockets/CMakeLists.txt	Wed Feb 03 14:06:18 2016 +0100
+++ b/modules/sockets/CMakeLists.txt	Mon Feb 22 16:09:51 2016 +0100
@@ -26,6 +26,7 @@
 	code_define_module(
 		NAME sockets
 		INCLUDES ${OPENSSL_INCLUDE_DIR}
+		FLAGS -DSOCKET_NO_SSL
 		LIBRARIES
 			${LIBRARIES}
 			${OPENSSL_LIBRARIES}
diff -r ebe16d7afbe6 -r 627284574e42 modules/sockets/sockets.cpp
--- a/modules/sockets/sockets.cpp	Wed Feb 03 14:06:18 2016 +0100
+++ b/modules/sockets/sockets.cpp	Mon Feb 22 16:09:51 2016 +0100
@@ -185,30 +185,30 @@
 /* {{{ Error */
 
 Error::Error(Code code, std::string function)
-	: m_code{code}
-	, m_function{std::move(function)}
-	, m_error{error()}
+	: m_code(code)
+	, m_function(std::move(function))
+	, m_error(error())
 {
 }
 
 Error::Error(Code code, std::string function, int n)
-	: m_code{code}
-	, m_function{std::move(function)}
-	, m_error{error(n)}
+	: m_code(code)
+	, m_function(std::move(function))
+	, m_error(error(n))
 {
 }
 
 Error::Error(Code code, std::string function, std::string error)
-	: m_code{code}
-	, m_function{std::move(function)}
-	, m_error{std::move(error)}
+	: m_code(code)
+	, m_function(std::move(function))
+	, m_error(std::move(error))
 {
 }
 
 /* }}} */
 
 /*
- * Predefine addressed to be used
+ * Predefined addressed to be used
  * ------------------------------------------------------------------
  */
 
@@ -216,76 +216,84 @@
 
 namespace address {
 
-/* Default domain */
-int Ip::m_default{AF_INET};
+namespace {
 
-Ip::Ip(Type domain) noexcept
-	: m_domain(static_cast<int>(domain))
+void resolv(sockaddr *destination, const std::string host, std::uint16_t port, int domain)
 {
-	assert(m_domain == AF_INET6 || m_domain == AF_INET);
+	assert(domain == AF_INET || domain == AF_INET6);
+
+	addrinfo hints, *res;
+
+	std::memset(&hints, 0, sizeof (addrinfo));
+	hints.ai_family = domain;
+
+	auto error = getaddrinfo(host.c_str(), std::to_string(port).c_str(), &hints, &res);
+	if (error != 0)
+		throw Error(Error::System, "getaddrinfo", gai_strerror(error));
+
+	if (domain == AF_INET6)
+		std::memcpy(destination, res->ai_addr, res->ai_addrlen);
+	else
+		std::memcpy(destination, res->ai_addr, res->ai_addrlen);
+
+	freeaddrinfo(res);
+}
 
-	if (m_domain == AF_INET6) {
-		std::memset(&m_sin6, 0, sizeof (sockaddr_in6));
+} // !namespace
+
+/* {{{ Ipv4 */
+
+Ipv4::Ipv4() noexcept
+{
+	std::memset(&m_sin, 0, sizeof (sockaddr_in));
+}
+
+Ipv4::Ipv4(const std::string &host, std::uint16_t port)
+	: Ipv4()
+{
+	if (host == "*") {
+		m_sin.sin_addr.s_addr = INADDR_ANY;
+		m_sin.sin_family = AF_INET;
+		m_sin.sin_port = htons(port);
 	} else {
-		std::memset(&m_sin, 0, sizeof (sockaddr_in));
+		resolv(reinterpret_cast<sockaddr *>(&m_sin), host, port, AF_INET);
 	}
 }
 
-Ip::Ip(const std::string &host, int port, Type domain)
-	: m_domain(static_cast<int>(domain))
+Ipv4::Ipv4(const sockaddr_storage *ss, socklen_t length) noexcept
 {
-	assert(m_domain == AF_INET6 || m_domain == AF_INET);
+	std::memcpy(&m_sin, ss, length);
+}
 
-	if (host == "*") {
-		if (m_domain == AF_INET6) {
-			std::memset(&m_sin6, 0, sizeof (sockaddr_in6));
+/* }}} */
 
-			m_length = sizeof (sockaddr_in6);
-			m_sin6.sin6_addr = in6addr_any;
-			m_sin6.sin6_family = AF_INET6;
-			m_sin6.sin6_port = htons(port);
-		} else {
-			std::memset(&m_sin, 0, sizeof (sockaddr_in));
+/* {{{ Ipv6 */
 
-			m_length = sizeof (sockaddr_in);
-			m_sin.sin_addr.s_addr = INADDR_ANY;
-			m_sin.sin_family = AF_INET;
-			m_sin.sin_port = htons(port);
-		}
-	} else {
-		addrinfo hints, *res;
-
-		std::memset(&hints, 0, sizeof (addrinfo));
-		hints.ai_family = domain;
+Ipv6::Ipv6() noexcept
+{
+	std::memset(&m_sin6, 0, sizeof (sockaddr_in6));
+}
 
-		auto error = getaddrinfo(host.c_str(), std::to_string(port).c_str(), &hints, &res);
-		if (error != 0) {
-			throw Error{Error::System, "getaddrinfo", gai_strerror(error)};
-		}
-
-		if (m_domain == AF_INET6) {
-			std::memcpy(&m_sin6, res->ai_addr, res->ai_addrlen);
-		} else {
-			std::memcpy(&m_sin, res->ai_addr, res->ai_addrlen);
-		}
-
-		m_length = res->ai_addrlen;
-		freeaddrinfo(res);
+Ipv6::Ipv6(const std::string &host, std::uint16_t port)
+	: Ipv6()
+{
+	if (host == "*") {
+		m_sin6.sin6_addr = in6addr_any;
+		m_sin6.sin6_family = AF_INET6;
+		m_sin6.sin6_port = htons(port);
+	} else {
+		resolv(reinterpret_cast<sockaddr *>(&m_sin6), host, port, AF_INET6);
 	}
 }
 
-Ip::Ip(const sockaddr_storage *ss, socklen_t length) noexcept
-	: m_length{length}
-	, m_domain{ss->ss_family}
+Ipv6::Ipv6(const sockaddr_storage *ss, socklen_t length) noexcept
 {
-	assert(ss->ss_family == AF_INET6 || ss->ss_family == AF_INET);
+	std::memcpy(&m_sin6, ss, length);
+}
 
-	if (ss->ss_family == AF_INET6) {
-		std::memcpy(&m_sin6, ss, length);
-	} else if (ss->ss_family == AF_INET) {
-		std::memcpy(&m_sin, ss, length);
-	}
-}
+/* }}} */
+
+/* {{{ Local */
 
 #if !defined(_WIN32)
 
@@ -295,12 +303,11 @@
 }
 
 Local::Local(std::string path, bool rm) noexcept
-	: m_path{std::move(path)}
+	: m_path(std::move(path))
 {
 	/* Silently remove the file even if it fails */
-	if (rm) {
+	if (rm)
 		::remove(m_path.c_str());
-	}
 
 	/* Copy the path */
 	std::memset(m_sun.sun_path, 0, sizeof (m_sun.sun_path));
@@ -322,11 +329,19 @@
 
 #endif // !_WIN32
 
+/* }}} */
+
 } // !address
 
 /* }}} */
 
 /*
+ * Listener backends
+ * ------------------------------------------------------------------
+ */
+
+/* {{{ Backends */
+/*
  * Select
  * ------------------------------------------------------------------
  */
@@ -506,26 +521,22 @@
 {
 	uint32_t events = 0;
 
-	if ((condition & Condition::Readable) == Condition::Readable) {
+	if ((condition & Condition::Readable) == Condition::Readable)
 		events |= EPOLLIN;
-	}
-	if ((condition & Condition::Writable) == Condition::Writable) {
+	if ((condition & Condition::Writable) == Condition::Writable)
 		events |= EPOLLOUT;
-	}
 
 	return events;
 }
 
 Condition Epoll::toCondition(uint32_t events) const noexcept
 {
-	Condition condition{Condition::None};
+	Condition condition = Condition::None;
 
-	if ((events & EPOLLIN) || (events & EPOLLHUP)) {
+	if ((events & EPOLLIN) || (events & EPOLLHUP))
 		condition |= Condition::Readable;
-	}
-	if (events & EPOLLOUT) {
+	if (events & EPOLLOUT)
 		condition |= Condition::Writable;
-	}
 
 	return condition;
 }
@@ -539,22 +550,21 @@
 	ev.events = eflags;
 	ev.data.fd = h;
 
-	if (epoll_ctl(m_handle, op, h, &ev) < 0) {
-		throw Error{Error::System, "epoll_ctl"};
-	}
+	if (epoll_ctl(m_handle, op, h, &ev) < 0)
+		throw Error(Error::System, "epoll_ctl");
 }
 
 Epoll::Epoll()
-	: m_handle{epoll_create1(0)}
+	: m_handle(epoll_create1(0))
 {
-	if (m_handle < 0) {
+	if (m_handle < 0)
 		throw Error{Error::System, "epoll_create"};
-	}
 }
 
 Epoll::~Epoll()
 {
-	close(m_handle);
+	if (m_handle != -1)
+		close(m_handle);
 }
 
 /*
@@ -595,16 +605,13 @@
 	int ret = epoll_wait(m_handle, m_events.data(), m_events.size(), ms);
 	std::vector<ListenerStatus> result;
 
-	if (ret == 0) {
-		throw Error{Error::Timeout, "epoll_wait", TIMEOUT_MSG};
-	}
-	if (ret < 0) {
-		throw Error{Error::System, "epoll_wait"};
-	}
+	if (ret == 0)
+		throw Error(Error::Timeout, "epoll_wait", TIMEOUT_MSG);
+	if (ret < 0)
+		throw Error(Error::System, "epoll_wait");
 
-	for (int i = 0; i < ret; ++i) {
+	for (int i = 0; i < ret; ++i)
 		result.push_back(ListenerStatus{m_events[i].data.fd, toCondition(m_events[i].events)});
-	}
 
 	return result;
 }
@@ -625,14 +632,14 @@
 Kqueue::Kqueue()
 	: m_handle(kqueue())
 {
-	if (m_handle < 0) {
-		throw Error{Error::System, "kqueue"};
-	}
+	if (m_handle < 0)
+		throw Error(Error::System, "kqueue");
 }
 
 Kqueue::~Kqueue()
 {
-	close(m_handle);
+	if (m_handle != -1)
+		close(m_handle);
 }
 
 void Kqueue::update(Handle h, int filter, int kflags)
@@ -706,4 +713,6 @@
 
 /* }}} */
 
+/* }}} */
+
 } // !net
diff -r ebe16d7afbe6 -r 627284574e42 modules/sockets/sockets.h
--- a/modules/sockets/sockets.h	Wed Feb 03 14:06:18 2016 +0100
+++ b/modules/sockets/sockets.h	Mon Feb 22 16:09:51 2016 +0100
@@ -161,6 +161,7 @@
 
 #include <cassert>
 #include <chrono>
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <exception>
@@ -449,7 +450,6 @@
 	Connecting,		//!< The connection is in progress
 	Connected,		//!< Connection is complete
 	Accepted,		//!< Socket has been accepted (client)
-	Accepting,		//!< The client acceptation is in progress
 	Closed,			//!< The socket has been closed
 	Disconnected,		//!< The connection was lost
 };
@@ -457,39 +457,6 @@
 /* }}} */
 
 /*
- * Action enum
- * ------------------------------------------------------------------
- *
- * Defines the pending operation.
- */
-
-/* {{{ Action */
-
-/**
- * @enum Action
- * @brief Define the current operation that must complete.
- *
- * Some operations like accept, connect, recv or send must sometimes do several round-trips to complete and the socket
- * action is set with that enumeration. The user is responsible of calling accept, connect send or recv until the
- * operation is complete.
- *
- * Note: the user must wait for the appropriate condition in Socket::condition to check if the required condition is
- * met.
- *
- * It is important to complete the operation in the correct order because protocols like Tls may require to continue
- * re-negociating when calling Socket::send or Socket::Recv.
- */
-enum class Action {
-	None,		//!< No action is required, socket is ready
-	Accept,		//!< The socket is not yet accepted, caller must call accept() again
-	Connect,	//!< The socket is not yet connected, caller must call connect() again
-	Receive,	//!< The received operation has not succeeded yet, caller must call recv() or recvfrom() again
-	Send		//!< The send operation has not succeded yet, caller must call send() or sendto() again
-};
-
-/* }}} */
-
-/*
  * Condition enum
  * ------------------------------------------------------------------
  *
@@ -627,9 +594,6 @@
 class Socket {
 private:
 	Protocol m_proto;
-	State m_state{State::Closed};
-	Action m_action{Action::None};
-	Condition m_condition{Condition::None};
 
 protected:
 	/**
@@ -649,8 +613,6 @@
 	 * @param protocol the protocol
 	 * @param iface the implementation
 	 * @throw net::Error on errors
-	 * @post state is set to Open
-	 * @post handle is not set to Invalid
 	 */
 	Socket(int domain, int type, int protocol, Protocol iface = {})
 		: m_proto(std::move(iface))
@@ -660,14 +622,10 @@
 #endif
 		m_handle = ::socket(domain, type, protocol);
 
-		if (m_handle == Invalid) {
-			throw Error{Error::System, "socket"};
-		}
+		if (m_handle == Invalid)
+			throw Error(Error::System, "socket");
 
 		m_proto.create(*this);
-		m_state = State::Open;
-
-		assert(m_handle != Invalid);
 	}
 
 	/**
@@ -680,7 +638,7 @@
 	 * @throw net::Error on errors
 	 */
 	explicit inline Socket(Protocol protocol = {}, const Address &address = {})
-		: Socket{address.domain(), protocol.type(), 0, std::move(protocol)}
+		: Socket(address.domain(), protocol.type(), 0, std::move(protocol))
 	{
 	}
 
@@ -690,23 +648,18 @@
 	 * @param handle the native descriptor
 	 * @param state specify the socket state
 	 * @param protocol the type of socket implementation
-	 * @post action is set to None
-	 * @post condition is set to None
 	 */
 	explicit inline Socket(Handle handle, State state = State::Closed, Protocol protocol = {}) noexcept
 		: m_proto(std::move(protocol))
-		, m_state{state}
-		, m_handle{handle}
+		, m_handle(handle)
 	{
-		assert(m_action == Action::None);
-		assert(m_condition == Condition::None);
 	}
 
 	/**
 	 * Create an invalid socket. Can be used when you cannot instanciate the socket immediately.
 	 */
 	explicit inline Socket(std::nullptr_t) noexcept
-		: m_handle{Invalid}
+		: m_handle(Invalid)
 	{
 	}
 
@@ -722,16 +675,10 @@
 	 */
 	inline Socket(Socket &&other) noexcept
 		: m_proto(std::move(other.m_proto))
-		, m_state{other.m_state}
-		, m_action{other.m_action}
-		, m_condition{other.m_condition}
-		, m_handle{other.m_handle}
+		, m_handle(other.m_handle)
 	{
 		/* Invalidate other */
 		other.m_handle = Invalid;
-		other.m_state = State::Closed;
-		other.m_action = Action::None;
-		other.m_condition = Condition::None;
 	}
 
 	/**
@@ -764,83 +711,31 @@
 	}
 
 	/**
-	 * Get the current socket state.
-	 *
-	 * @return the state
-	 */
-	inline State state() const noexcept
-	{
-		return m_state;
-	}
-
-	/**
-	 * Change the current socket state.
+	 * Tells if the socket is not invalid.
 	 *
-	 * @param state the new state
-	 * @warning only implementations should call this function
+	 * @return true if not invalid
 	 */
-	inline void setState(State state) noexcept
-	{
-		m_state = state;
-	}
-
-	/**
-	 * Get the pending operation.
-	 *
-	 * @return the action to complete before continuing
-	 * @note usually only needed in non-blocking sockets
-	 */
-	inline Action action() const noexcept
+	inline bool isOpen() const noexcept
 	{
-		return m_action;
-	}
-
-	/**
-	 * Change the pending operation.
-	 *
-	 * @param action the action
-	 * @warning you should not call this function yourself
-	 */
-	inline void setAction(Action action) noexcept
-	{
-		m_action = action;
-	}
-
-	/**
-	 * Get the condition to wait for.
-	 *
-	 * @return the condition
-	 */
-	inline Condition condition() const noexcept
-	{
-		return m_condition;
-	}
-
-	/**
-	 * Change the condition required.
-	 *
-	 * @param condition the condition
-	 * @warning you should not call this function yourself
-	 */
-	inline void setCondition(Condition condition) noexcept
-	{
-		m_condition = condition;
+		return m_handle != Invalid;
 	}
 
 	/**
 	 * Set an option for the socket. Wrapper of setsockopt(2).
 	 *
+	 * @pre isOpen()
 	 * @param level the setting level
 	 * @param name the name
 	 * @param arg the value
 	 * @throw net::Error on errors
 	 */
 	template <typename Argument>
-	void set(int level, int name, const Argument &arg)
+	inline void set(int level, int name, const Argument &arg)
 	{
-		if (setsockopt(m_handle, level, name, (ConstArg)&arg, sizeof (arg)) == Failure) {
-			throw Error{Error::System, "set"};
-		}
+		assert(m_handle != Invalid);
+
+		if (setsockopt(m_handle, level, name, (ConstArg)&arg, sizeof (arg)) == Failure)
+			throw Error(Error::System, "set");
 	}
 
 	/**
@@ -848,18 +743,22 @@
 	 *
 	 * The object must have `set(Socket<Address, Protocol> &) const`.
 	 *
+	 * @pre isOpen()
 	 * @param option the option
 	 * @throw net::Error on errors
 	 */
 	template <typename Option>
 	inline void set(const Option &option)
 	{
+		assert(m_handle != Invalid);
+
 		option.set(*this);
 	}
 
 	/**
 	 * Get an option for the socket. Wrapper of getsockopt(2).
 	 *
+	 * @pre isOpen()
 	 * @param level the setting level
 	 * @param name the name
 	 * @throw net::Error on errors
@@ -867,12 +766,13 @@
 	template <typename Argument>
 	Argument get(int level, int name)
 	{
+		assert(m_handle != Invalid);
+
 		Argument desired, result{};
 		socklen_t size = sizeof (result);
 
-		if (getsockopt(m_handle, level, name, (Arg)&desired, &size) == Failure) {
-			throw Error{Error::System, "get"};
-		}
+		if (getsockopt(m_handle, level, name, (Arg)&desired, &size) == Failure)
+			throw Error(Error::System, "get");
 
 		std::memcpy(&result, &desired, size);
 
@@ -885,13 +785,16 @@
 	 * The object must have `T get(Socket<Address, Protocol> &) const`, T can be any type and it is the value
 	 * returned from this function.
 	 *
+	 * @pre isOpen()
 	 * @return the same value as get() in the option
 	 * @throw net::Error on errors
 	 */
 	template <typename Option>
 	inline auto get() -> decltype(std::declval<Option>().get(*this))
 	{
-		return Option{}.get(*this);
+		assert(m_handle != Invalid);
+
+		return Option().get(*this);
 	}
 
 	/**
@@ -908,374 +811,244 @@
 	/**
 	 * Bind using a native address.
 	 *
+	 * @pre isOpen()
 	 * @param address the address
 	 * @param length the size
-	 * @pre state must not be Bound
 	 * @throw net::Error on errors
 	 */
-	void bind(const sockaddr *address, socklen_t length)
+	inline void bind(const sockaddr *address, socklen_t length)
 	{
-		assert(m_state != State::Bound);
-
-		if (::bind(m_handle, address, length) == Failure) {
-			throw Error{Error::System, "bind"};
-		}
-
-		m_state = State::Bound;
+		assert(m_handle != Invalid);
+
+		if (::bind(m_handle, address, length) == Failure)
+			throw Error(Error::System, "bind");
 	}
 
 	/**
 	 * Overload that takes an address.
 	 *
+	 * @pre isOpen()
 	 * @param address the address
 	 * @throw net::Error on errors
 	 */
 	inline void bind(const Address &address)
 	{
-		bind(address.address(), address.length());
+		assert(m_handle != Invalid);
+
+		if (::bind(m_handle, address.address(), address.length()) == Failure)
+			throw Error(Error::System, "bind");
+	}
+
+	/**
+	 * Overload that creates an address on the fly.
+	 *
+	 * @pre isOpen()
+	 * @param args the arguments to Address constructor
+	 * @throw net::Error on errors
+	 */
+	template <typename... Args>
+	inline void bind(Args&&... args)
+	{
+		assert(m_handle != Invalid);
+
+		Address address{std::forward<Args>(args)...};
+
+		if (::bind(m_handle, address.address(), address.length()) == Failure)
+			throw Error(Error::System, "bind");
 	}
 
 	/**
 	 * Listen for pending connection.
 	 *
+	 * @pre isOpen()
 	 * @param max the maximum number
-	 * @pre state must be Bound
 	 * @throw net::Error on errors
 	 */
 	inline void listen(int max = 128)
 	{
-		assert(m_state == State::Bound);
-
-		if (::listen(this->m_handle, max) == Failure) {
-			throw Error{Error::System, "listen"};
-		}
+		assert(m_handle != Invalid);
+
+		if (::listen(this->m_handle, max) == Failure)
+			throw Error(Error::System, "listen");
 	}
 
 	/**
-	 * Connect to the address.
 	 *
-	 * If connection cannot be established immediately, connect with no argument must be called again. See
-	 * the underlying protocol for more information.
-	 *
-	 * @pre state must be State::Open
+	 * @pre isOpen()
 	 * @param address the address
 	 * @param length the the address length
+	 * @param condition the condition to wait (Optional)
 	 * @throw net::Error on errors
-	 * @post state is set to State::Connecting or State::Connected
-	 * @note For non-blocking sockets, see the underlying protocol function for more details
 	 */
-	void connect(const sockaddr *address, socklen_t length)
+	inline void connect(const sockaddr *address, socklen_t length, Condition *condition = nullptr)
 	{
-		assert(m_state == State::Open);
-
-		m_action = Action::None;
-		m_condition = Condition::None;
-
-		m_proto.connect(*this, address, length);
-
-		assert((m_state == State::Connected  && m_action == Action::None    && m_condition == Condition::None) ||
-		       (m_state == State::Connecting && m_action == Action::Connect && m_condition != Condition::None));
+		assert(m_handle != Invalid);
+
+		m_proto.connect(*this, address, length, condition);
+
 	}
 
 	/**
 	 * Overloaded function.
 	 *
-	 * Effectively call connect(address.address(), address.length());
+	 * Effectively call connect(address.address(), address.length(), condition);
 	 *
+	 * @pre isOpen()
 	 * @param address the address
+	 * @param condition the condition to wait (Optional)
 	 */
-	inline void connect(const Address &address)
-	{
-		connect(address.address(), address.length());
-	}
-
-	/**
-	 * Continue the connection, only required with non-blocking sockets.
-	 *
-	 * @pre state must be State::Connecting
-	 * @throw net::Error on errors
-	 */
-	void connect()
+	inline void connect(const Address &address, Condition *condition = nullptr)
 	{
-		assert(m_state == State::Connecting);
-
-		m_action = Action::None;
-		m_condition = Condition::None;
-
-		m_proto.connect(*this);
-
-		assert((m_state == State::Connected  && m_action == Action::None    && m_condition == Condition::None) ||
-		       (m_state == State::Connecting && m_action == Action::Connect && m_condition != Condition::None));
+		assert(m_handle != Invalid);
+
+		connect(address.address(), address.length(), condition);
 	}
 
-	/**
-	 * Accept a new client. If there are no pending connection, throws an error.
-	 *
-	 * If the client cannot be accepted immediately, the client is returned and accept with no arguments
-	 * must be called on it. See the underlying protocol for more information.
-	 *
-	 * @pre state must be State::Bound
-	 * @param info the address where to store client's information (optional)
-	 * @return the new socket
-	 * @throw Error on errors
-	 * @post returned client's state is set to State::Accepting or State::Accepted
-	 * @note For non-blocking sockets, see the underlying protocol function for more details
-	 */
-	Socket<Address, Protocol> accept(Address *info)
+	inline void connect(Condition &condition)
 	{
-		assert(m_state == State::Bound);
-
-		m_action = Action::None;
-		m_condition = Condition::None;
+		m_proto.connect(*this, &condition);
+	}
+
+	Socket<Address, Protocol> accept(Address *info, Condition *condition = nullptr)
+	{
+		assert(m_handle != Invalid);
 
 		sockaddr_storage storage;
 		socklen_t length = sizeof (storage);
 
-		Socket<Address, Protocol> sc = m_proto.accept(*this, reinterpret_cast<sockaddr *>(&storage), &length);
-
-		if (info) {
+		Socket<Address, Protocol> sc = m_proto.accept(*this, reinterpret_cast<sockaddr *>(&storage), &length, condition);
+
+		if (info)
 			*info = Address{&storage, length};
-		}
-
-		/* Master do not change */
-		assert(m_state == State::Bound);
-		assert(m_action == Action::None);
-		assert(m_condition == Condition::None);
-
-		/* Client */
-		assert(
-			(sc.state() == State::Accepting && sc.action() == Action::Accept && sc.condition() != Condition::None) ||
-			(sc.state() == State::Accepted  && sc.action() == Action::None   && sc.condition() == Condition::None)
-		);
 
 		return sc;
 	}
 
-	/**
-	 * Continue the accept process on this client. This function must be called only when the socket is
-	 * ready to be readable or writable! (see condition).
-	 *
-	 * @pre state must be State::Accepting
-	 * @throw Error on errors
-	 * @post if connection is complete, state is changed to State::Accepted, action and condition are unset
-	 * @post if connection is still in progress, condition is set
-	 */
-	void accept()
+	inline void accept(Condition &condition)
 	{
-		assert(m_state == State::Accepting);
-
-		m_action = Action::None;
-		m_condition = Condition::None;
-
-		m_proto.accept(*this);
-
-		assert(
-			(m_state == State::Accepting && m_action == Action::Accept && m_condition != Condition::None) ||
-			(m_state == State::Accepted  && m_action == Action::None   && m_condition == Condition::None)
-		);
+		assert(m_handle != Invalid);
+
+		m_proto.accept(*this, &condition);
 	}
 
 	/**
 	 * Get the local name. This is a wrapper of getsockname().
 	 *
+	 * @pre isOpen()
 	 * @return the address
 	 * @throw Error on failures
 	 * @pre state() must not be State::Closed
 	 */
 	Address address() const
 	{
-		assert(m_state != State::Closed);
+		assert(m_handle != Invalid);
 
 		sockaddr_storage ss;
 		socklen_t length = sizeof (sockaddr_storage);
 
-		if (::getsockname(m_handle, (sockaddr *)&ss, &length) == Failure) {
-			throw Error{Error::System, "getsockname"};
-		}
+		if (::getsockname(m_handle, reinterpret_cast<sockaddr *>(&ss), &length) == Failure)
+			throw Error(Error::System, "getsockname");
 
 		return Address(&ss, length);
 	}
 
 	/**
-	 * Receive some data.
+	 *
 	 *
-	 * If the operation cannot be complete immediately, 0 is returned and user must call the function
-	 * again when ready. See the underlying protocol for more information.
-	 *
-	 * If action is set to Action::None and result is set to 0, disconnection occured.
-	 *
+	 * @pre isOpen()
 	 * @param data the destination buffer
 	 * @param length the buffer length
-	 * @pre action must not be Action::Send
 	 * @return the number of bytes received or 0
 	 * @throw Error on error
-	 * @note For non-blocking sockets, see the underlying protocol function for more details
 	 */
-	unsigned recv(void *data, unsigned length)
+	inline unsigned recv(void *data, unsigned length, Condition *condition = nullptr)
 	{
-		assert(m_action != Action::Send);
-
-		m_action = Action::None;
-		m_condition = Condition::None;
-
-		return m_proto.recv(*this, data, length);
+		assert(m_handle != Invalid);
+
+		return m_proto.recv(*this, data, length, condition);
 	}
 
 	/**
 	 * Overloaded function.
 	 *
+	 * @pre isOpen()
 	 * @param count the number of bytes to receive
 	 * @return the string
 	 * @throw Error on error
 	 */
-	inline std::string recv(unsigned count)
+	std::string recv(unsigned count, Condition *condition = nullptr)
 	{
+		assert(m_handle != Invalid);
+
 		std::string result;
 
 		result.resize(count);
-		auto n = recv(const_cast<char *>(result.data()), count);
+		auto n = recv(const_cast<char *>(result.data()), count, condition);
 		result.resize(n);
 
 		return result;
 	}
 
 	/**
-	 * Send some data.
+	 *
 	 *
-	 * If the operation cannot be complete immediately, 0 is returned and user must call the function
-	 * again when ready. See the underlying protocol for more information.
-	 *
+	 * @pre isOpen()
 	 * @param data the data buffer
 	 * @param length the buffer length
 	 * @return the number of bytes sent or 0
-	 * @pre action() must not be Flag::Receive
-	 * @throw Error on error
-	 * @note For non-blocking sockets, see the underlying protocol function for more details
-	 */
-	unsigned send(const void *data, unsigned length)
-	{
-		assert(m_action != Action::Receive);
-
-		m_action = Action::None;
-		m_condition = Condition::None;
-
-		return m_proto.send(*this, data, length);
-	}
-
-	/**
-	 * Overloaded function.
-	 *
-	 * @param data the string to send
-	 * @return the number of bytes sent
 	 * @throw Error on error
 	 */
-	inline unsigned send(const std::string &data)
+	unsigned send(const void *data, unsigned length, Condition *condition = nullptr)
 	{
-		return send(data.c_str(), data.size());
+		assert(m_handle != Invalid);
+
+		return m_proto.send(*this, data, length, condition);
 	}
 
-	/**
-	 * Send data to an end point.
-	 *
-	 * If the operation cannot be complete immediately, 0 is returned and user must call the function
-	 * again when ready. See the underlying protocol for more information.
-	 *
-	 * @param data the buffer
-	 * @param length the buffer length
-	 * @param address the client address
-	 * @param addrlen the address length
-	 * @return the number of bytes sent
-	 * @throw net::Error on errors
-	 * @note For non-blocking sockets, see the underlying protocol function for more details
-	 */
-	inline unsigned sendto(const void *data, unsigned length, const sockaddr *address, socklen_t addrlen)
+	inline unsigned send(const std::string &data, Condition *condition = nullptr)
+	{
+		return m_proto.send(*this, data.c_str(), data.size(), condition);
+	}
+
+	inline unsigned sendto(const void *data, unsigned length, const sockaddr *address, socklen_t addrlen, Condition *condition = nullptr)
 	{
 		return m_proto.sendto(*this, data, length, address, addrlen);
 	}
 
-	/**
-	 * Overloaded function.
-	 *
-	 * @param data the buffer
-	 * @param length the buffer length
-	 * @param address the destination
-	 * @return the number of bytes sent
-	 * @throw net::Error on errors
-	 */
-	inline unsigned sendto(const void *data, unsigned length, const Address &address)
+	inline unsigned sendto(const void *data, unsigned length, const Address &address, Condition *condition = nullptr)
 	{
-		return sendto(data, length, address.address(), address.length());
+		return m_proto.sendto(data, length, address.address(), address.length(), condition);
 	}
 
-	/**
-	 * Overloaded function.
-	 *
-	 * @param data the data
-	 * @param address the address
-	 * @return the number of bytes sent
-	 * @throw net:;Error on errors
-	 */
-	inline unsigned sendto(const std::string &data, const Address &address)
+	inline unsigned sendto(const std::string &data, const Address &address, Condition *condition = nullptr)
 	{
-		return sendto(data.c_str(), data.length(), address);
+		return m_proto.sendto(*this, data.c_str(), data.length(), address.address(), address.length(), condition);
 	}
 
-	/**
-	 * Receive data from an end point.
-	 *
-	 * If the operation cannot be complete immediately, 0 is returned and user must call the function
-	 * again when ready. See the underlying protocol for more information.
-	 *
-	 * @param data the destination buffer
-	 * @param length the buffer length
-	 * @param address the address destination
-	 * @param addrlen the address length (in/out)
-	 * @return the number of bytes received
-	 * @throw net::Error on errors
-	 * @note For non-blocking sockets, see the underlying protocol function for more details
-	 */
-	inline unsigned recvfrom(void *data, unsigned length, sockaddr *address, socklen_t *addrlen)
+	inline unsigned recvfrom(void *data, unsigned length, sockaddr *address, socklen_t *addrlen, Condition *condition = nullptr)
 	{
 		return m_proto.recvfrom(*this, data, length, address, addrlen);
 	}
 
-	/**
-	 * Overloaded function.
-	 *
-	 * @param data the destination buffer
-	 * @param length the buffer length
-	 * @param info the address destination
-	 * @return the number of bytes received
-	 * @throw net::Error on errors
-	 */
-	inline unsigned recvfrom(void *data, unsigned length, Address *info = nullptr)
+	inline unsigned recvfrom(void *data, unsigned length, Address *info = nullptr, Condition *condition = nullptr)
 	{
 		sockaddr_storage storage;
 		socklen_t addrlen = sizeof (sockaddr_storage);
 
-		auto n = recvfrom(data, length, reinterpret_cast<sockaddr *>(&storage), &addrlen);
-
-		if (info && n != 0) {
+		auto n = m_proto.recvfrom(*this, data, length, reinterpret_cast<sockaddr *>(&storage), &addrlen, condition);
+
+		if (info && n != 0)
 			*info = Address{&storage, addrlen};
-		}
 
 		return n;
 	}
 
-	/**
-	 * Overloaded function.
-	 *
-	 * @param count the maximum number of bytes to receive
-	 * @param info the client information
-	 * @return the string
-	 * @throw net::Error on errors
-	 */
-	std::string recvfrom(unsigned count, Address *info = nullptr)
+	std::string recvfrom(unsigned count, Address *info = nullptr, Condition *condition = nullptr)
 	{
 		std::string result;
 
 		result.resize(count);
-		auto n = recvfrom(const_cast<char *>(result.data()), count, info);
+		auto n = recvfrom(const_cast<char *>(result.data()), count, info, condition);
 		result.resize(n);
 
 		return result;
@@ -1296,10 +1069,6 @@
 #endif
 			m_handle = Invalid;
 		}
-
-		m_state = State::Closed;
-		m_action = Action::None;
-		m_condition = Condition::None;
 	}
 
 	/**
@@ -1320,15 +1089,9 @@
 	{
 		m_handle = other.m_handle;
 		m_proto = std::move(other.m_proto);
-		m_state = other.m_state;
-		m_action = other.m_action;
-		m_condition = other.m_condition;
 
 		/* Invalidate other */
 		other.m_handle = Invalid;
-		other.m_state = State::Closed;
-		other.m_action = Action::None;
-		other.m_condition = Condition::None;
 
 		return *this;
 	}
@@ -1439,11 +1202,14 @@
  * @warning On Windows, it's not possible to check if the socket is blocking or not.
  */
 class SockBlockMode {
+private:
+	bool m_value;
+
 public:
-	/**
-	 * Set to false if you want non-blocking socket.
-	 */
-	bool value{false};
+	inline SockBlockMode(bool value = true) noexcept
+		: m_value(value)
+	{
+	}
 
 	/**
 	 * Set the option.
@@ -1457,25 +1223,21 @@
 #if defined(O_NONBLOCK) && !defined(_WIN32)
 		int flags;
 
-		if ((flags = fcntl(sc.handle(), F_GETFL, 0)) < 0) {
+		if ((flags = fcntl(sc.handle(), F_GETFL, 0)) < 0)
 			flags = 0;
-		}
-
-		if (value) {
+
+		if (m_value)
 			flags &= ~(O_NONBLOCK);
-		} else {
+		else
 			flags |= O_NONBLOCK;
-		}
-
-		if (fcntl(sc.handle(), F_SETFL, flags) < 0) {
-			throw Error{Error::System, "fcntl"};
-		}
+
+		if (fcntl(sc.handle(), F_SETFL, flags) < 0)
+			throw Error(Error::System, "fcntl");
 #else
-		unsigned long flags = (value) ? 0 : 1;
-
-		if (ioctlsocket(sc.handle(), FIONBIO, &flags) == Failure) {
-			throw Error{Error::System, "fcntl"};
-		}
+		unsigned long flags = (m_value) ? 0 : 1;
+
+		if (ioctlsocket(sc.handle(), FIONBIO, &flags) == Failure)
+			throw Error(Error::System, "fcntl");
 #endif
 	}
 
@@ -1491,13 +1253,12 @@
 #if defined(O_NONBLOCK) && !defined(_WIN32)
 		int flags = fcntl(sc.handle(), F_GETFL, 0);
 
-		if (flags < 0) {
-			throw Error{Error::System, "fcntl"};
-		}
+		if (flags < 0)
+			throw Error(Error::System, "fcntl");
 
 		return !(flags & O_NONBLOCK);
 #else
-		throw Error{Error::Other, "get", "Windows API cannot let you get the blocking status of a socket"};
+		throw Error(Error::Other, "get", std::strerror(ENOSYS));
 #endif
 	}
 };
@@ -1507,11 +1268,14 @@
  * @brief Reuse address, must be used before calling Socket::bind
  */
 class SockReuseAddress {
+private:
+	bool m_value;
+
 public:
-	/**
-	 * Set to true if you want to set the SOL_SOCKET/SO_REUSEADDR option.
-	 */
-	bool value{true};
+	inline SockReuseAddress(bool value = true) noexcept
+		: m_value(value)
+	{
+	}
 
 	/**
 	 * Set the option.
@@ -1522,7 +1286,7 @@
 	template <typename Address, typename Protocol>
 	inline void set(Socket<Address, Protocol> &sc) const
 	{
-		sc.set(SOL_SOCKET, SO_REUSEADDR, value ? 1 : 0);
+		sc.set(SOL_SOCKET, SO_REUSEADDR, m_value ? 1 : 0);
 	}
 
 	/**
@@ -1612,16 +1376,21 @@
 
 /* }}} */
 
+/* {{{ Options for TCP */
+
 /**
  * @class TcpNoDelay
  * @brief Set this option if you want to disable nagle's algorithm.
  */
 class TcpNoDelay {
+private:
+	bool m_value;
+
 public:
-	/**
-	 * Set to true to set TCP_NODELAY option.
-	 */
-	bool value{true};
+	inline TcpNoDelay(bool value = true) noexcept
+		: m_value(value)
+	{
+	}
 
 	/**
 	 * Set the option.
@@ -1632,7 +1401,7 @@
 	template <typename Address, typename Protocol>
 	inline void set(Socket<Address, Protocol> &sc) const
 	{
-		sc.set(IPPROTO_TCP, TCP_NODELAY, value ? 1 : 0);
+		sc.set(IPPROTO_TCP, TCP_NODELAY, m_value ? 1 : 0);
 	}
 
 	/**
@@ -1648,6 +1417,10 @@
 	}
 };
 
+/* }}} */
+
+/* {{{ Options for IPv6 */
+
 /**
  * @class Ipv6Only
  * @brief Control IPPROTO_IPV6/IPV6_V6ONLY
@@ -1656,11 +1429,14 @@
  * false or true if portability is a concern.
  */
 class Ipv6Only {
+private:
+	bool m_value;
+
 public:
-	/**
-	 * Set this to use only IPv6.
-	 */
-	bool value{true};
+	inline Ipv6Only(bool value = true) noexcept
+		: m_value(value)
+	{
+	}
 
 	/**
 	 * Set the option.
@@ -1671,7 +1447,7 @@
 	template <typename Address, typename Protocol>
 	inline void set(Socket<Address, Protocol> &sc) const
 	{
-		sc.set(IPPROTO_IPV6, IPV6_V6ONLY, value ? 1 : 0);
+		sc.set(IPPROTO_IPV6, IPV6_V6ONLY, m_value ? 1 : 0);
 	}
 
 	/**
@@ -1687,6 +1463,8 @@
 	}
 };
 
+/* }}} */
+
 } // !option
 
 /* }}} */
@@ -1695,7 +1473,8 @@
  * Predefined addressed to be used
  * ------------------------------------------------------------------
  *
- * - Ip,
+ * - Ipv4,
+ * - Ipv6,
  * - Local.
  */
 
@@ -1706,107 +1485,23 @@
  */
 namespace address {
 
-/**
- * @class Ip
- * @brief Base class for IPv6 and IPv4, you can use it if you don't know in advance if you'll use IPv6 or IPv4.
- */
-class Ip {
+class Ipv4 {
 public:
-	/**
-	 * @enum Type
-	 * @brief Type of ip address.
-	 */
-	enum Type {
-		v4 = AF_INET,		//!< AF_INET
-		v6 = AF_INET6		//!< AF_INET6
-	};
-
 private:
-	/*
-	 * Default domain when using default constructors.
-	 *
-	 * Note: AF_INET or AF_INET6, not
-	 */
-	static int m_default;
-
-	union {
-		mutable sockaddr_in m_sin;
-		mutable sockaddr_in6 m_sin6;
-	};
-
-	socklen_t m_length{0};
-	int m_domain{AF_INET};
+	sockaddr_in m_sin;
 
 public:
-	/**
-	 * Set the default domain to use when using default Ip constructor. By default, AF_INET is used.
-	 *
-	 * @pre domain must be Type::v4 or Type::v6
-	 */
-	static inline void setDefault(Type domain) noexcept
-	{
-		assert(domain == Type::v4 || domain == Type::v6);
-
-		m_default = static_cast<int>(domain);
-	}
-
-	/**
-	 * Construct using the default domain.
-	 */
-	inline Ip() noexcept
-		: Ip(static_cast<Type>(m_default))
-	{
-	}
-
-	/**
-	 * Default initialize the Ip domain.
-	 *
-	 * @pre domain must be AF_INET or AF_INET6 only
-	 * @param domain the domain (AF_INET or AF_INET6)
-	 */
-	Ip(Type domain) noexcept;
-
-	/**
-	 * Construct an address suitable for bind() or connect().
-	 *
-	 * @pre domain must be Type::v4 or Type::v6
-	 * @param domain the domain (AF_INET or AF_INET6)
-	 * @param host the host (* for any)
-	 * @param port the port number
-	 * @throw Error on errors
-	 */
-	Ip(const std::string &host, int port, Type domain = v4);
-
-	/**
-	 * Construct an address from a storage.
-	 *
-	 * @pre storage's domain must be AF_INET or AF_INET6 only
-	 * @param ss the storage
-	 * @param length the length
-	 */
-	Ip(const sockaddr_storage *ss, socklen_t length) noexcept;
-
-	/**
-	 * Get the domain (AF_INET or AF_INET6).
-	 *
-	 * @return the domain
-	 */
+	Ipv4() noexcept;
+	Ipv4(const std::string &host, std::uint16_t port);
+	Ipv4(const sockaddr_storage *ss, socklen_t length) noexcept;
+
 	inline int domain() const noexcept
 	{
-		return m_domain;
+		return AF_INET;
 	}
 
-	/**
-	 * Return the underlying address, either sockaddr_in6 or sockaddr_in.
-	 *
-	 * @return the address
-	 */
 	inline const sockaddr *address() const noexcept
 	{
-		if (m_domain == AF_INET6) {
-			return reinterpret_cast<const sockaddr *>(&m_sin6);
-		}
-
 		return reinterpret_cast<const sockaddr *>(&m_sin);
 	}
 
@@ -1817,7 +1512,7 @@
 	 */
 	inline socklen_t length() const noexcept
 	{
-		return m_length;
+		return sizeof (sockaddr_in);
 	}
 
 	/**
@@ -1825,12 +1520,8 @@
 	 *
 	 * @return the port
 	 */
-	inline int port() const noexcept
+	inline std::uint16_t port() const noexcept
 	{
-		if (m_domain == AF_INET6) {
-			return ntohs(m_sin6.sin6_port);
-		}
-
 		return ntohs(m_sin.sin_port);
 	}
 
@@ -1846,15 +1537,66 @@
 
 		std::memset(result, 0, sizeof (result));
 
-		if (m_domain == AF_INET6) {
-			if (!inet_ntop(AF_INET6, &m_sin6.sin6_addr, result, sizeof (result))) {
-				throw Error{Error::System, "inet_ntop"};
-			}
-		} else {
-			if (!inet_ntop(AF_INET, &m_sin.sin_addr, result, sizeof (result))) {
-				throw Error{Error::System, "inet_ntop"};
-			}
-		}
+		if (!inet_ntop(AF_INET, &m_sin.sin_addr, result, sizeof (result)))
+			throw Error(Error::System, "inet_ntop");
+
+		return result;
+	}
+};
+
+class Ipv6 {
+private:
+	sockaddr_in6 m_sin6;
+
+public:
+	Ipv6() noexcept;
+	Ipv6(const std::string &host, std::uint16_t port);
+	Ipv6(const sockaddr_storage *ss, socklen_t length) noexcept;
+
+	inline int domain() const noexcept
+	{
+		return AF_INET6;
+	}
+
+	inline const sockaddr *address() const noexcept
+	{
+		return reinterpret_cast<const sockaddr *>(&m_sin6);
+	}
+
+	/**
+	 * Return the underlying address length.
+	 *
+	 * @return the length
+	 */
+	inline socklen_t length() const noexcept
+	{
+		return sizeof (sockaddr_in6);
+	}
+
+	/**
+	 * Get the port.
+	 *
+	 * @return the port
+	 */
+	inline std::uint16_t port() const noexcept
+	{
+		return ntohs(m_sin6.sin6_port);
+	}
+
+	/**
+	 * Get the IP address in textual form.
+	 *
+	 * @return the address
+	 * @throw Error on errors
+	 */
+	std::string ip() const
+	{
+		char result[128];
+
+		std::memset(result, 0, sizeof (result));
+
+		if (!inet_ntop(AF_INET6, &m_sin6.sin6_addr, result, sizeof (result)))
+			throw Error(Error::System, "inet_ntop");
 
 		return result;
 	}
@@ -1985,31 +1727,12 @@
 		/* No-op */
 	}
 
-	/**
-	 * Standard connect.
-	 *
-	 * If the socket is marked non-blocking and the connection cannot be established immediately, then the
-	 * following is true:
-	 *
-	 * - state is set to State::Connecting,
-	 * - action is set to Action::Connect,
-	 * - condition is set to Condition::Writable.
-	 *
-	 * Then the user must wait until the socket is writable and call connect() with 0 arguments.
-	 *
-	 * If the socket is blocking, this function blocks until the connection is complete or an error occurs, in
-	 * that case state is either set to State::Connected or State::Disconnected but action and condition are
-	 * not set.
-	 *
-	 * @param sc the socket
-	 * @param address the address
-	 * @param length the length
-	 * @throw net::Error on errors
-	 * @note Wrapper of connect(2)
-	 */
 	template <typename Address, typename Protocol>
-	void connect(Socket<Address, Protocol> &sc, const sockaddr *address, socklen_t length)
+	void connect(Socket<Address, Protocol> &sc, const sockaddr *address, socklen_t length, Condition *condition)
 	{
+		if (condition)
+			*condition = Condition::None;
+
 		if (::connect(sc.handle(), address, length) == Failure) {
 			/*
 			 * Determine if the error comes from a non-blocking connect that cannot be
@@ -2019,118 +1742,61 @@
 			int error = WSAGetLastError();
 
 			if (error == WSAEWOULDBLOCK) {
-				sc.setState(State::Connecting);
-				sc.setAction(Action::Connect);
-				sc.setCondition(Condition::Writable);
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				sc.setState(State::Disconnected);
-				throw Error{Error::System, "connect", error};
+				throw Error(Error::System, "connect", error);
 			}
 #else
 			if (errno == EINPROGRESS) {
-				sc.setState(State::Connecting);
-				sc.setAction(Action::Connect);
-				sc.setCondition(Condition::Writable);
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				sc.setState(State::Disconnected);
-				throw Error{Error::System, "connect"};
+				throw Error(Error::System, "connect");
 			}
 #endif
-		} else {
-			sc.setState(State::Connected);
 		}
 	}
 
-	/**
-	 * Continue the connection. This function must only be called when the socket is ready for writing,
-	 * the user is responsible of waiting for that condition.
-	 *
-	 * This function check for SOL_SOCKET/SO_ERROR status.
-	 *
-	 * If the connection is complete, status is set to State::Connected, otherwise it is set to
-	 * State::Disconnected. In both cases, action and condition are not set.
-	 *
-	 * @param sc the socket
-	 * @throw net::Error on errors
-	 */
 	template <typename Address, typename Protocol>
-	void connect(Socket<Address, Protocol> &sc)
+	void connect(Socket<Address, Protocol> &sc, Condition *condition = nullptr)
 	{
+		if (condition)
+			*condition = Condition::None;
+
 		int error = sc.template get<int>(SOL_SOCKET, SO_ERROR);
 
-		if (error != 0) {
-			sc.setState(State::Disconnected);
-			throw Error{Error::System, "connect", error};
-		}
-
-		sc.setState(State::Connected);
+		if (error != 0)
+			throw Error(Error::System, "connect", error);
 	}
 
-	/**
-	 * Accept a clear client.
-	 *
-	 * If the socket is marked non-blocking and there are no pending connection, this function throws an
-	 * error. The user must wait that the socket is readable before calling this function.
-	 *
-	 * If the socket is blocking, this function blocks until a new client is connected or throws an error on
-	 * errors.
-	 *
-	 * If the socket is correctly returned, its state is set to State::Accepted and its action and condition
-	 * are not set.
-	 *
-	 * In any case, action and condition of this socket are not set.
-	 *
-	 * @param sc the socket
-	 * @param address the address destination
-	 * @param length the address length
-	 * @return the socket
-	 * @throw net::Error on errors
-	 * @note Wrapper of accept(2)
-	 */
 	template <typename Address, typename Protocol>
-	Socket<Address, Protocol> accept(Socket<Address, Protocol> &sc, sockaddr *address, socklen_t *length)
+	Socket<Address, Protocol> accept(Socket<Address, Protocol> &sc, sockaddr *address, socklen_t *length, Condition *condition = nullptr)
 	{
+		if (condition)
+			*condition = Condition::None;
+
 		Handle handle = ::accept(sc.handle(), address, length);
 
-		if (handle == Invalid) {
-			throw Error{Error::System, "accept"};
-		}
-
-		return Socket<Address, Protocol>{handle, State::Accepted};
+		if (handle == Invalid)
+			return Socket<Address, Protocol>();
+
+		return Socket<Address, Protocol>(handle);
 	}
 
-	/**
-	 * Continue accept.
-	 *
-	 * This function is just present for compatibility, it should never be called.
-	 */
 	template <typename Address, typename Protocol>
-	inline void accept(Socket<Address, Protocol> &) const noexcept
+	inline void accept(Socket<Address, Protocol> &, Condition *condition) const noexcept
 	{
-		/* no-op */
+		if (condition)
+			*condition = Condition::None;
 	}
 
-	/**
-	 * Receive data.
-	 *
-	 * If the socket is marked non-blocking and no data is available, 0 is returned and condition is set to
-	 * Condition::Readable. If 0 is returned and condition is not set, then the state is set to
-	 * State::Disconnected.
-	 *
-	 * If the socket is blocking, this function blocks until some data is available or if an error occurs.
-	 *
-	 * In any case, action is never set.
-	 *
-	 * @param sc the socket
-	 * @param data the destination
-	 * @param length the destination length
-	 * @return the number of bytes read
-	 * @throw Error on errors
-	 * @note Wrapper of recv(2)
-	 */
 	template <typename Address>
-	unsigned recv(Socket<Address, Tcp> &sc, void *data, unsigned length)
+	unsigned recv(Socket<Address, Tcp> &sc, void *data, unsigned length, Condition *condition)
 	{
+		if (condition)
+			*condition = Condition::None;
+
 		int nbread = ::recv(sc.handle(), (Arg)data, length, 0);
 
 		if (nbread == Failure) {
@@ -2139,46 +1805,33 @@
 
 			if (error == WSAEWOULDBLOCK) {
 				nbread = 0;
-				sc.setCondition(Condition::Readable);
+
+				if (condition)
+					condition = Condition::Readable;
 			} else {
-				sc.setState(State::Disconnected);
-				throw Error{Error::System, "recv", error};
+				throw Error(Error::System, "recv", error);
 			}
 #else
 			if (errno == EAGAIN || errno == EWOULDBLOCK) {
-				sc.setCondition(Condition::Readable);
+				nbread = 0;
+
+				if (condition)
+					*condition = Condition::Readable;
 			} else {
-				sc.setState(State::Disconnected);
-				throw Error{Error::System, "recv"};
+				throw Error(Error::System, "recv");
 			}
 #endif
-		} else if (nbread == 0) {
-			sc.setState(State::Disconnected);
 		}
 
 		return static_cast<unsigned>(nbread);
 	}
 
-	/**
-	 * Send some data.
-	 *
-	 * If the socket is marked non-blocking and the operation would block, then 0 is returned and condition is set to
-	 * Condition::Writable.
-	 *
-	 * If the socket is blocking, this function blocks until the data has been sent.
-	 *
-	 * On any other errors, this function throw net::Error.
-	 *
-	 * @param sc the socket
-	 * @param data the buffer to send
-	 * @param length the buffer length
-	 * @return the number of bytes sent
-	 * @throw net::Error on errors
-	 * @note Wrapper of send(2)
-	 */
 	template <typename Address>
-	unsigned send(Socket<Address, Tcp> &sc, const void *data, unsigned length)
+	unsigned send(Socket<Address, Tcp> &sc, const void *data, unsigned length, Condition *condition)
 	{
+		if (condition)
+			*condition = Condition::None;
+
 		int nbsent = ::send(sc.handle(), (ConstArg)data, length, 0);
 
 		if (nbsent == Failure) {
@@ -2187,18 +1840,20 @@
 
 			if (error == WSAEWOULDBLOCK) {
 				nbsent = 0;
-				sc.setCondition(Condition::Writable);
+
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				sc.setState(State::Disconnected);
-				throw Error{Error::System, "send", error};
+				throw Error(Error::System, "send", error);
 			}
 #else
 			if (errno == EAGAIN || errno == EWOULDBLOCK) {
 				nbsent = 0;
-				sc.setCondition(Condition::Writable);
+
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				sc.setState(State::Disconnected);
-				throw Error{Error::System, "send"};
+				throw Error(Error::System, "send");
 			}
 #endif
 		}
@@ -2238,25 +1893,12 @@
 		/* No-op */
 	}
 
-	/**
-	 * Receive data from an end point.
-	 *
-	 * If the socket is marked non-blocking and no data is available, 0 is returned and condition is set to
-	 * Condition::Readable.
-	 *
-	 * If the socket is blocking, this functions blocks until some data is available or if an error occurs.
-	 *
-	 * @param sc the socket
-	 * @param data the destination buffer
-	 * @param length the buffer length
-	 * @param address the address
-	 * @param addrlen the initial address length
-	 * @return the number of bytes received
-	 * @throw Error on error
-	 */
 	template <typename Address>
-	unsigned recvfrom(Socket<Address, Udp> &sc, void *data, unsigned length, sockaddr *address, socklen_t *addrlen)
+	unsigned recvfrom(Socket<Address, Udp> &sc, void *data, unsigned length, sockaddr *address, socklen_t *addrlen, Condition *condition)
 	{
+		if (condition)
+			*condition = Condition::Readable;
+
 		int nbread;
 
 		nbread = ::recvfrom(sc.handle(), (Arg)data, length, 0, address, addrlen);
@@ -2267,16 +1909,20 @@
 
 			if (error == WSAEWOULDBLOCK) {
 				nbread = 0;
-				sc.setCondition(Condition::Readable);
+
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				throw Error{Error::System, "recvfrom"};
+				throw Error(Error::System, "recvfrom");
 			}
 #else
 			if (errno == EAGAIN || errno == EWOULDBLOCK) {
 				nbread = 0;
-				sc.setCondition(Condition::Readable);
+
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				throw Error{Error::System, "recvfrom"};
+				throw Error(Error::System, "recvfrom");
 			}
 #endif
 		}
@@ -2284,25 +1930,12 @@
 		return static_cast<unsigned>(nbread);
 	}
 
-	/**
-	 * Send data to an end point.
-	 *
-	 * If the socket is marked non-blocking and the operation would block, then 0 is returned and condition is set to
-	 * Condition::Writable.
-	 *
-	 * If the socket is blocking, this functions blocks until the data has been sent.
-	 *
-	 * @param sc the socket
-	 * @param data the buffer
-	 * @param length the buffer length
-	 * @param address the client address
-	 * @param addrlen the adderss length
-	 * @return the number of bytes sent
-	 * @throw Error on error
-	 */
 	template <typename Address>
-	unsigned sendto(Socket<Address, Udp> &sc, const void *data, unsigned length, const sockaddr *address, socklen_t addrlen)
+	unsigned sendto(Socket<Address, Udp> &sc, const void *data, unsigned length, const sockaddr *address, socklen_t addrlen, Condition *condition)
 	{
+		if (condition)
+			*condition = Condition::None;
+
 		int nbsent;
 
 		nbsent = ::sendto(sc.handle(), (ConstArg)data, length, 0, address, addrlen);
@@ -2312,16 +1945,20 @@
 
 			if (error == WSAEWOULDBLOCK) {
 				nbsent = 0;
-				sc.setCondition(Condition::Writable);
+
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				throw Error{Error::System, "sendto", error};
+				throw Error(Error::System, "sendto", error);
 			}
 #else
 			if (errno == EAGAIN || errno == EWOULDBLOCK) {
 				nbsent = 0;
-				sc.setCondition(Condition::Writable);
+
+				if (condition)
+					*condition = Condition::Writable;
 			} else {
-				throw Error{Error::System, "sendto"};
+				throw Error(Error::System, "sendto");
 			}
 #endif
 		}
@@ -2373,8 +2010,8 @@
 	 * Construct with a context and ssl, for Tls::accept.
 	 */
 	Tls(Context context, Ssl ssl)
-		: m_context{std::move(context)}
-		, m_ssl{std::move(ssl)}
+		: m_context(std::move(context))
+		, m_ssl(std::move(ssl))
 	{
 	}
 
@@ -2737,9 +2374,14 @@
 using SocketTcp = Socket<Address, protocol::Tcp>;
 
 /**
- * Helper to create TCP/IP sockets.
+ * Helper to create TCP/IPv4 sockets.
  */
-using SocketTcpIp = Socket<address::Ip, protocol::Tcp>;
+using SocketTcpIp = Socket<address::Ipv4, protocol::Tcp>;
+
+/**
+ * Helper to create TCP/IPv6 sockets.
+ */
+using SocketTcpIpv6 = Socket<address::Ipv6, protocol::Tcp>;
 
 #if !defined(_WIN32)
 
@@ -2757,9 +2399,14 @@
 using SocketUdp = Socket<Address, protocol::Udp>;
 
 /**
- * Helper to create UDP/IP sockets.
+ * Helper to create UDP/IPv4 sockets.
  */
-using SocketUdpIp = Socket<address::Ip, protocol::Udp>;
+using SocketUdpIp = Socket<address::Ipv4, protocol::Udp>;
+
+/**
+ * Helper to create UDP/IPv6 sockets.
+ */
+using SocketUdpIpv6 = Socket<address::Ipv6, protocol::Udp>;
 
 #if !defined(SOCKET_NO_SSL)
 
@@ -2779,13 +2426,13 @@
 /* }}} */
 
 /*
- * Select wrapper
+ * Listener
  * ------------------------------------------------------------------
  *
  * Wrapper for select(2) and other various implementations.
  */
 
-/* {{{ Listener */
+/* {{{ Listener stuff */
 
 /**
  * @class ListenerStatus
@@ -2806,6 +2453,10 @@
  */
 using ListenerTable = std::map<Handle, Condition>;
 
+/* {{{ Backends */
+
+/* {{{ Select */
+
 /**
  * @class Select
  * @brief Implements select(2)
@@ -2838,6 +2489,10 @@
 	}
 };
 
+/* }}} */
+
+/* {{{ Poll */
+
 #if defined(SOCKET_HAVE_POLL)
 
 /**
@@ -2881,6 +2536,10 @@
 
 #endif
 
+/* }}} */
+
+/* {{{ Epoll */
+
 #if defined(SOCKET_HAVE_EPOLL)
 
 /**
@@ -2889,13 +2548,11 @@
  */
 class Epoll {
 private:
-	int m_handle;
+	int m_handle{-1};
 	std::vector<epoll_event> m_events;
 
 	Epoll(const Epoll &) = delete;
 	Epoll &operator=(const Epoll &) = delete;
-	Epoll(const Epoll &&) = delete;
-	Epoll &operator=(const Epoll &&) = delete;
 
 	uint32_t toEpoll(Condition flags) const noexcept;
 	Condition toCondition(uint32_t events) const noexcept;
@@ -2907,6 +2564,20 @@
 	 */
 	Epoll();
 
+	inline Epoll(const Epoll &&other) noexcept
+		: m_handle(other.m_handle)
+	{
+		other.m_handle = -1;
+	}
+	
+	Epoll &operator=(const Epoll &&other)
+	{
+		m_handle = other.m_handle;
+		other.m_handle = -1;
+
+		return *this;
+	}
+
 	/**
 	 * Close the epoll instance.
 	 */
@@ -2938,6 +2609,10 @@
 
 #endif
 
+/* }}} */
+
+/* {{{ Kqueue */
+
 #if defined(SOCKET_HAVE_KQUEUE)
 
 /**
@@ -2954,8 +2629,6 @@
 
 	Kqueue(const Kqueue &) = delete;
 	Kqueue &operator=(const Kqueue &) = delete;
-	Kqueue(Kqueue &&) = delete;
-	Kqueue &operator=(Kqueue &&) = delete;
 
 	void update(Handle sc, int filter, int kflags);
 
@@ -2965,6 +2638,20 @@
 	 */
 	Kqueue();
 
+	inline Kqueue(Kqueue &&other) noexcept
+		: m_handle(other.m_handle)
+	{
+		other.m_handle = -1;
+	}
+
+	inline Kqueue &operator=(Kqueue &&other) noexcept
+	{
+		m_handle = other.m_handle;
+		other.m_handle = -1;
+
+		return *this;
+	}
+
 	/**
 	 * Destroy the kqueue instance.
 	 */
@@ -2996,6 +2683,12 @@
 
 #endif
 
+/* }}} */
+
+/* }}} */
+
+/* {{{ Listener */
+
 /**
  * @class Listener
  * @brief Synchronous multiplexing
@@ -3158,13 +2851,11 @@
 		} else {
 			/* Remove flag if already present */
 			if ((condition & Condition::Readable) == Condition::Readable &&
-			    (it->second & Condition::Readable) == Condition::Readable) {
+			    (it->second & Condition::Readable) == Condition::Readable)
 				condition &= ~(Condition::Readable);
-			}
 			if ((condition & Condition::Writable) == Condition::Writable &&
-			    (it->second & Condition::Writable) == Condition::Writable) {
+			    (it->second & Condition::Writable) == Condition::Writable)
 				condition &= ~(Condition::Writable);
-			}
 
 			/* Still need a call? */
 			if (condition != Condition::None) {
@@ -3198,13 +2889,11 @@
 		 * state.
 		 */
 		if ((condition & Condition::Readable) == Condition::Readable &&
-		    (it->second & Condition::Readable) != Condition::Readable) {
+		    (it->second & Condition::Readable) != Condition::Readable)
 			condition &= ~(Condition::Readable);
-		}
 		if ((condition & Condition::Writable) == Condition::Writable &&
-		    (it->second & Condition::Writable) != Condition::Writable) {
+		    (it->second & Condition::Writable) != Condition::Writable)
 			condition &= ~(Condition::Writable);
-		}
 
 		if (condition != Condition::None) {
 			/* Determine if it's a complete removal */
@@ -3212,11 +2901,10 @@
 
 			m_backend.unset(m_table, sc, condition, removal);
 
-			if (removal) {
+			if (removal)
 				m_table.erase(it);
-			} else {
+			else
 				it->second &= ~(condition);
-			}
 		}
 	}
 
@@ -3237,9 +2925,8 @@
 	 */
 	inline void clear()
 	{
-		while (!m_table.empty()) {
+		while (!m_table.empty())
 			remove(m_table.begin()->first);
-		}
 	}
 
 	/**
@@ -3302,785 +2989,6 @@
 
 /* }}} */
 
-/*
- * Callback
- * ------------------------------------------------------------------
- *
- * Function owner with tests.
- */
-
-/* {{{ Callback */
-
-/**
- * @class Callback
- * @brief Convenient signal owner that checks if the target is valid.
- *
- * This class also catch all errors thrown from signals to avoid interfering with our process.
- */
-template <typename... Args>
-class Callback : public std::function<void (Args...)> {
-public:
-	/**
-	 * Inherited constructors.
-	 */
-	using std::function<void (Args...)>::function;
-
-	/**
-	 * Execute the callback only if a target is set.
-	 */
-	void operator()(Args... args) const
-	{
-		if (*this) {
-			try {
-				std::function<void (Args...)>::operator()(args...);
-			} catch (...) {
-			}
-		}
-	}
-};
-
-/* }}} */
-
-/*
- * StreamConnection
- * ------------------------------------------------------------------
- *
- * Client connected on the server side.
- */
-
-/* {{{ StreamConnection */
-
-/**
- * @class StreamConnection
- * @brief Connected client on the server side.
- *
- * This object is created from StreamServer when a new client is connected, it is the higher
- * level object of sockets and completely asynchronous.
- */
-template <typename Address, typename Protocol>
-class StreamConnection {
-public:
-	/**
-	 * Called when the output has changed.
-	 */
-	using WriteHandler = Callback<>;
-
-private:
-	/* Signals */
-	WriteHandler m_onWrite;
-
-	/* Sockets and output buffer */
-	Socket<Address, Protocol> m_socket;
-	std::string m_output;
-
-public:
-	/**
-	 * Create the connection.
-	 *
-	 * @param s the socket
-	 */
-	StreamConnection(Socket<Address, Protocol> s)
-		: m_socket{std::move(s)}
-	{
-		m_socket.set(net::option::SockBlockMode{false});
-	}
-
-	/**
-	 * Access the underlying socket.
-	 *
-	 * @return the socket
-	 * @warning use with care
-	 */
-	inline Socket<Address, Protocol> &socket() noexcept
-	{
-		return m_socket;
-	}
-
-	/**
-	 * Access the current output.
-	 *
-	 * @return the output
-	 */
-	inline const std::string &output() const noexcept
-	{
-		return m_output;
-	}
-
-	/**
-	 * Overloaded function
-	 *
-	 * @return the output
-	 * @warning use with care, avoid modifying the output if you don't know what you're doing
-	 */
-	inline std::string &output() noexcept
-	{
-		return m_output;
-	}
-
-	/**
-	 * Post some data to be sent asynchronously.
-	 *
-	 * @param str the data to append
-	 */
-	inline void send(std::string str)
-	{
-		m_output += str;
-		m_onWrite();
-	}
-
-	/**
-	 * Kill the client.
-	 */
-	inline void close()
-	{
-		m_socket.close();
-	}
-
-	/**
-	 * Set the write handler, the signal is emitted when the output has changed so that the StreamServer owner
-	 * knows that there are some data to send.
-	 *
-	 * @param handler the handler
-	 * @warning you usually never need to set this yourself
-	 */
-	inline void setWriteHandler(WriteHandler handler)
-	{
-		m_onWrite = std::move(handler);
-	}
-};
-
-/* }}} */
-
-/*
- * StreamServer
- * ------------------------------------------------------------------
- *
- * Convenient stream oriented server.
- */
-
-/* {{{ StreamServer */
-
-/**
- * @class StreamServer
- * @brief Convenient stream server for TCP and TLS.
- *
- * This class does all the things for you as accepting new clients, listening for it and sending data. It works
- * asynchronously without blocking to let you control your process workflow.
- *
- * This class is not thread safe and you must not call any of the functions from different threads.
- */
-template <typename Address, typename Protocol>
-class StreamServer {
-public:
-	/**
-	 * Handler when a new client is connected.
-	 */
-	using ConnectionHandler = Callback<const std::shared_ptr<StreamConnection<Address, Protocol>> &>;
-
-	/**
-	 * Handler when a client is disconnected.
-	 */
-	using DisconnectionHandler = Callback<const std::shared_ptr<StreamConnection<Address, Protocol>> &>;
-
-	/**
-	 * Handler when data has been received from a client.
-	 */
-	using ReadHandler = Callback<const std::shared_ptr<StreamConnection<Address, Protocol>> &, const std::string &>;
-
-	/**
-	 * Handler when data has been correctly sent to a client.
-	 */
-	using WriteHandler = Callback<const std::shared_ptr<StreamConnection<Address, Protocol>> &, const std::string &>;
-
-	/**
-	 * Handler when an error occured.
-	 */
-	using ErrorHandler = Callback<const Error &>;
-
-	/**
-	 * Handler when there was a timeout.
-	 */
-	using TimeoutHandler = Callback<>;
-
-private:
-	using ClientMap = std::map<Handle, std::shared_ptr<StreamConnection<Address, Protocol>>>;
-
-	/* Signals */
-	ConnectionHandler m_onConnection;
-	DisconnectionHandler m_onDisconnection;
-	ReadHandler m_onRead;
-	WriteHandler m_onWrite;
-	ErrorHandler m_onError;
-	TimeoutHandler m_onTimeout;
-
-	/* Sockets */
-	Socket<Address, Protocol> m_master;
-	Listener<> m_listener;
-	ClientMap m_clients;
-
-	/*
-	 * Update flags depending on the required condition.
-	 */
-	void updateFlags(std::shared_ptr<StreamConnection<Address, Protocol>> &client)
-	{
-		assert(client->socket().action() != Action::None);
-
-		m_listener.remove(client->socket().handle());
-		m_listener.set(client->socket().handle(), client->socket().condition());
-	}
-
-	/*
-	 * Continue accept process.
-	 */
-	template <typename AcceptCall>
-	void processAccept(std::shared_ptr<StreamConnection<Address, Protocol>> &client, const AcceptCall &acceptFunc)
-	{
-		try {
-			/* Do the accept */
-			acceptFunc();
-
-			/* 1. First remove completely the client */
-			m_listener.remove(client->socket().handle());
-
-			/* 2. If accept is not finished, wait for the appropriate condition */
-			if (client->socket().state() == State::Accepted) {
-				/* 3. Client is accepted, notify the user */
-				m_listener.set(client->socket().handle(), Condition::Readable);
-				m_onConnection(client);
-			} else {
-				/* Operation still in progress */
-				updateFlags(client);
-			}
-		} catch (const Error &error) {
-			m_clients.erase(client->socket().handle());
-			m_listener.remove(client->socket().handle());
-			m_onError(error);
-		}
-	}
-
-	/*
-	 * Process initial accept of master socket, this is the initial accepting process. Except on errors, the
-	 * socket is stored but the user will be notified only once the socket is completely accepted.
-	 */
-	void processInitialAccept()
-	{
-		// TODO: store address too.
-		std::shared_ptr<StreamConnection<Address, Protocol>> client = std::make_shared<StreamConnection<Address, Protocol>>(m_master.accept(nullptr));
-		std::weak_ptr<StreamConnection<Address, Protocol>> ptr{client};
-
-		/* 1. Register output changed to update listener */
-		client->setWriteHandler([this, ptr] () {
-			auto client = ptr.lock();
-
-			/* Do not update the listener immediately if an action is pending */
-			if (client && client->socket().action() == Action::None && !client->output().empty()) {
-				m_listener.set(client->socket().handle(), Condition::Writable);
-			}
-		});
-
-		/* 2. Add the client */
-		m_clients.insert(std::make_pair(client->socket().handle(), client));
-
-		/*
-		 * 2. Do an initial check to set the listener flags, at this moment the socket may or not be
-		 *    completely accepted.
-		 */
-		processAccept(client, [&] () {});
-	}
-
-	/*
-	 * Read or complete the read operation.
-	 */
-	void processRead(std::shared_ptr<StreamConnection<Address, Protocol>> &client)
-	{
-		/*
-		 * Read because there is something to read or because the pending operation is
-		 * read and must complete.
-		 */
-		auto buffer = client->socket().recv(512);
-
-		/*
-		 * Now the receive operation may be completed, in that case, two possibilities:
-		 *
-		 * 1. The action is set to None (completed)
-		 * 2. The action is still not complete, update the flags
-		 */
-		if (client->socket().action() == Action::None) {
-			/* Empty mean normal disconnection */
-			if (buffer.empty()) {
-				m_listener.remove(client->socket().handle());
-				m_clients.erase(client->socket().handle());
-				m_onDisconnection(client);
-			} else {
-				/*
-				 * At this step, it is possible that we were completing a receive operation, in this
-				 * case the write flag may be removed, add it if required.
-				 */
-				if (!client->output().empty()) {
-					m_listener.set(client->socket().handle(), Condition::Writable);
-				}
-
-				m_onRead(client, buffer);
-			}
-		} else {
-			/* Operation in progress */
-			updateFlags(client);
-		}
-	}
-
-	/*
-	 * Flush the output buffer.
-	 */
-	void processWrite(std::shared_ptr<StreamConnection<Address, Protocol>> &client)
-	{
-		auto &output = client->output();
-		auto nsent = client->socket().send(output);
-
-		if (client->socket().action() == Action::None) {
-			/* 1. Create a copy of content that has been sent */
-			auto sent = output.substr(0, nsent);
-
-			/* 2. Erase the content sent */
-			output.erase(0, nsent);
-
-			/* 3. Update listener */
-			if (output.empty()) {
-				m_listener.unset(client->socket().handle(), Condition::Writable);
-			}
-
-			/* 4. Notify user */
-			m_onWrite(client, sent);
-		} else {
-			updateFlags(client);
-		}
-	}
-
-	void processSync(std::shared_ptr<StreamConnection<Address, Protocol>> &client, Condition flags)
-	{
-		try {
-			auto action = client->socket().action();
-
-			if (action == Action::Receive ||
-			    (action == Action::None && (flags & Condition::Readable) == Condition::Readable)) {
-				processRead(client);
-			} else if ((flags & Condition::Writable) == Condition::Writable) {
-				processWrite(client);
-			}
-		} catch (const Error &error) {
-			m_onDisconnection(client);
-			m_listener.remove(client->socket().handle());
-			m_clients.erase(client->socket().handle());
-		}
-	}
-
-public:
-	/**
-	 * Create a stream server with the specified address to bind.
-	 *
-	 * @param protocol the protocol (Tcp or Tls)
-	 * @param address the address to bind
-	 * @param max the max number to listen
-	 * @throw Error on errors
-	 */
-	StreamServer(Protocol protocol, const Address &address, int max = 128)
-		: m_master{std::move(protocol), address}
-	{
-		// TODO: m_onError
-		m_master.set(SOL_SOCKET, SO_REUSEADDR, 1);
-		m_master.bind(address);
-		m_master.listen(max);
-		m_listener.set(m_master.handle(), Condition::Readable);
-	}
-
-	/**
-	 * Set the connection handler, called when a new client is connected.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setConnectionHandler(ConnectionHandler handler)
-	{
-		m_onConnection = std::move(handler);
-	}
-
-	/**
-	 * Set the disconnection handler, called when a client died.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setDisconnectionHandler(DisconnectionHandler handler)
-	{
-		m_onDisconnection = std::move(handler);
-	}
-
-	/**
-	 * Set the receive handler, called when a client has sent something.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setReadHandler(ReadHandler handler)
-	{
-		m_onRead = std::move(handler);
-	}
-
-	/**
-	 * Set the writing handler, called when some data has been sent to a client.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setWriteHandler(WriteHandler handler)
-	{
-		m_onWrite = std::move(handler);
-	}
-
-	/**
-	 * Set the error handler, called when unrecoverable error has occured.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setErrorHandler(ErrorHandler handler)
-	{
-		m_onError = std::move(handler);
-	}
-
-	/**
-	 * Set the timeout handler, called when the selection has timeout.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setTimeoutHandler(TimeoutHandler handler)
-	{
-		m_onTimeout = std::move(handler);
-	}
-
-	/**
-	 * Poll for the next event.
-	 *
-	 * @param timeout the timeout (-1 for indefinitely)
-	 * @throw Error on errors
-	 */
-	void poll(int timeout = -1)
-	{
-		try {
-			auto st = m_listener.wait(timeout);
-
-			if (st.socket == m_master.handle()) {
-				/* New client */
-				processInitialAccept();
-			} else {
-				/* Recv / Send / Accept on a client */
-				auto client = m_clients[st.socket];
-
-				if (client->socket().state() == State::Accepted) {
-					processSync(client, st.flags);
-				} else {
-					processAccept(client, [&] () { client->socket().accept(); });
-				}
-			}
-		} catch (const Error &error) {
-			if (error.code() == Error::Timeout) {
-				m_onTimeout();
-			} else {
-				m_onError(error);
-			}
-		}
-	}
-};
-
-/* }}} */
-
-/*
- * StreamClient
- * ------------------------------------------------------------------
- */
-
-/* {{{ StreamClient */
-
-/**
- * @class StreamClient
- * @brief Client side connection to a server.
- *
- * This class is not thread safe and you must not call any of the functions from different threads.
- */
-template <typename Address, typename Protocol>
-class StreamClient {
-public:
-	/**
-	 * Handler when connection is complete.
-	 */
-	using ConnectionHandler = Callback<>;
-
-	/**
-	 * Handler when data has been received.
-	 */
-	using ReadHandler = Callback<const std::string &>;
-
-	/**
-	 * Handler when data has been sent correctly.
-	 */
-	using WriteHandler = Callback<const std::string &>;
-
-	/**
-	 * Handler when disconnected.
-	 */
-	using DisconnectionHandler = Callback<>;
-
-	/**
-	 * Handler on unrecoverable error.
-	 */
-	using ErrorHandler = Callback<const Error &>;
-
-	/**
-	 * Handler when timeout occured.
-	 */
-	using TimeoutHandler = Callback<>;
-
-private:
-	/* Signals */
-	ConnectionHandler m_onConnection;
-	ReadHandler m_onRead;
-	WriteHandler m_onWrite;
-	DisconnectionHandler m_onDisconnection;
-	ErrorHandler m_onError;
-	TimeoutHandler m_onTimeout;
-
-	/* Socket */
-	Socket<Address, Protocol> m_socket;
-	Listener<> m_listener;
-
-	/* Output buffer */
-	std::string m_output;
-
-	/*
-	 * Update the flags after an uncompleted operation. This function must only be called when the operation
-	 * has not complete (e.g. connect, recv, send).
-	 */
-	void updateFlags()
-	{
-		assert(m_socket.action() != Action::None);
-
-		m_listener.remove(m_socket.handle());
-		m_listener.set(m_socket.handle(), m_socket.condition());
-	}
-
-	/*
-	 * This is the generic connect helper, it will be used to both initiate the connection or to continue the
-	 * connection process if needed.
-	 *
-	 * Thus the template parameter is the appropriate function to call either, m_socket.connect(address) or
-	 * m_socket.connect().
-	 *
-	 * See poll() and connect() to understand.
-	 */
-	template <typename ConnectCall>
-	void processConnect(const ConnectCall &connectFunc)
-	{
-		/* Call m_socket.connect() or m_socket.connect(address) */
-		connectFunc();
-
-		/* Remove entirely */
-		m_listener.remove(m_socket.handle());
-
-		if (m_socket.state() == State::Connected) {
-			m_onConnection();
-			m_listener.set(m_socket.handle(), Condition::Readable);
-		} else {
-			/* Connection still in progress */
-			updateFlags();
-		}
-	}
-
-	/*
-	 * Receive or complete the receive command, if the command is not complete, the listener is updated
-	 * accordingly.
-	 */
-	void processRead()
-	{
-		auto received = m_socket.recv(512);
-
-		if (m_socket.action() == Action::None) {
-			/* 0 means disconnection */
-			if (received.empty()) {
-				m_onDisconnection();
-			} else {
-				/*
-				 * At this step, it is possible that we were completing a receive operation, in this
-				 * case the write flag may be removed, add it if required.
-				 */
-				if (m_output.empty()) {
-					m_listener.unset(m_socket.handle(), Condition::Writable);
-				}
-
-				m_onRead(received);
-			}
-		} else {
-			/* Receive operation in progress */
-			updateFlags();
-		}
-	}
-
-	/*
-	 * Send or complete the send command, if the command is not complete, the listener is updated
-	 * accordingly.
-	 */
-	void processWrite()
-	{
-		auto nsent = m_socket.send(m_output);
-
-		if (m_socket.action() == Action::None) {
-			/* 1. Make a copy of what has been sent */
-			auto sent = m_output.substr(0, nsent);
-
-			/* 2. Erase sent content */
-			m_output.erase(0, nsent);
-
-			/* 3. Update flags if needed */
-			if (m_output.empty()) {
-				m_listener.unset(m_socket.handle(), Condition::Writable);
-			}
-
-			/* 4. Notify user */
-			m_onWrite(sent);
-		} else {
-			/* Send operation in progress */
-			updateFlags();
-		}
-	}
-
-	/*
-	 * Receive or send.
-	 */
-	void processSync(Condition condition)
-	{
-		if ((m_socket.action() == Action::Receive) ||
-		    (m_socket.action() == Action::None && (condition & Condition::Readable) == Condition::Readable)) {
-			processRead();
-		} else {
-			processWrite();
-		}
-	}
-
-public:
-	/**
-	 * Create a client. The client is automatically marked as non-blocking.
-	 *
-	 * @param protocol the protocol (Tcp or Tls)
-	 * @param address the optional address
-	 * @throw net::Error on failures
-	 */
-	StreamClient(Protocol protocol = {}, const Address &address = {})
-		: m_socket{std::move(protocol), address}
-	{
-		m_socket.set(net::option::SockBlockMode{false});
-		m_listener.set(m_socket.handle(), Condition::Readable);
-	}
-
-	/**
-	 * Set the connection handler, called when the connection succeed.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setConnectionHandler(ConnectionHandler handler)
-	{
-		m_onConnection = std::move(handler);
-	}
-
-	/**
-	 * Set the disconnection handler, called when the server closed the connection.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setDisconnectionHandler(DisconnectionHandler handler)
-	{
-		m_onDisconnection = std::move(handler);
-	}
-
-	/**
-	 * Set the read handler, called when we received something.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setReadHandler(ReadHandler handler)
-	{
-		m_onRead = std::move(handler);
-	}
-
-	/**
-	 * Set the write handler, called when we successfully sent data.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setWriteHandler(WriteHandler handler)
-	{
-		m_onWrite = std::move(handler);
-	}
-
-	/**
-	 * Set the error handler, called when unexpected error occurs.
-	 *
-	 * @param handler the handler
-	 */
-	inline void setErrorHandler(ErrorHandler handler)
-	{
-		m_onError = std::move(handler);
-	}
-
-	/**
-	 * Connect to a server, this function may connect immediately or not in any case the connection handler
-	 * will be called when the connection completed.
-	 *
-	 * @param address the address to connect to
-	 */
-	void connect(const Address &address) noexcept
-	{
-		assert(m_socket.state() == State::Open);
-
-		processConnect([&] () { m_socket.connect(address); });
-	}
-
-	/**
-	 * Asynchronously send data to the server.
-	 *
-	 * @param str the data to append
-	 */
-	void send(std::string str)
-	{
-		m_output += str;
-
-		/* Don't update the listener if there is a pending operation */
-		if (m_socket.state() == State::Connected && m_socket.action() == Action::None && !m_output.empty()) {
-			m_listener.set(m_socket.handle(), Condition::Writable);
-		}
-	}
-
-	/**
-	 * Wait for the next event.
-	 *
-	 * @param timeout the time to wait in milliseconds
-	 * @throw Error on errors
-	 */
-	void poll(int timeout = -1) noexcept
-	{
-		try {
-			auto st = m_listener.wait(timeout);
-
-			if (m_socket.state() != State::Connected) {
-				/* Continue the connection */
-				processConnect([&] () { m_socket.connect(); });
-			} else {
-				/* Read / Write */
-				processSync(st.flags);
-			}
-		} catch (const Error &error) {
-			if (error.code() == Error::Timeout) {
-				m_onTimeout();
-			} else {
-				m_listener.remove(m_socket.handle());
-				m_onError(error);
-			}
-		}
-	}
-};
-
 /* }}} */
 
 } // !net
diff -r ebe16d7afbe6 -r 627284574e42 modules/sockets/test/main.cpp
--- a/modules/sockets/test/main.cpp	Wed Feb 03 14:06:18 2016 +0100
+++ b/modules/sockets/test/main.cpp	Mon Feb 22 16:09:51 2016 +0100
@@ -43,10 +43,10 @@
 	SocketTcpIp s;
 
 	try {
-		s.set(option::SockReuseAddress{true});
+		s.set(option::SockReuseAddress(true));
 		ASSERT_TRUE(s.get<option::SockReuseAddress>());
 
-		s.set(option::SockReuseAddress{false});
+		s.set(option::SockReuseAddress(false));
 		ASSERT_FALSE(s.get<option::SockReuseAddress>());
 	} catch (const std::exception &ex) {
 		FAIL() << ex.what();
@@ -58,10 +58,10 @@
 	SocketTcpIp s;
 
 	try {
-		s.set(option::TcpNoDelay{true});
+		s.set(option::TcpNoDelay(true));
 		ASSERT_TRUE(s.get<option::TcpNoDelay>());
 
-		s.set(option::TcpNoDelay{false});
+		s.set(option::TcpNoDelay(false));
 		ASSERT_FALSE(s.get<option::TcpNoDelay>());
 	} catch (const std::exception &ex) {
 		FAIL() << ex.what();
@@ -70,13 +70,13 @@
 
 TEST(Options, v6only)
 {
-	SocketTcpIp s{Tcp{}, Ip{Ip::v6}};
+	SocketTcpIpv6 s;
 
 	try {
-		s.set(option::Ipv6Only{true});
+		s.set(option::Ipv6Only(true));
 		ASSERT_TRUE(s.get<option::Ipv6Only>());
 
-		s.set(option::Ipv6Only{false});
+		s.set(option::Ipv6Only(false));
 		ASSERT_FALSE(s.get<option::Ipv6Only>());
 	} catch (const std::exception &ex) {
 		FAIL() << ex.what();
@@ -89,8 +89,8 @@
 
 class TcpServerTest : public testing::Test {
 protected:
-	SocketTcp<Ip> m_server;
-	SocketTcp<Ip> m_client;
+	SocketTcp<Ipv4> m_server;
+	SocketTcp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -98,7 +98,7 @@
 public:
 	TcpServerTest()
 	{
-		m_server.set(SOL_SOCKET, SO_REUSEADDR, 1);
+		m_server.set(SockReuseAddress());
 	}
 
 	~TcpServerTest()
@@ -113,7 +113,7 @@
 TEST_F(TcpServerTest, connect)
 {
 	m_tserver = std::thread([this] () {
-		m_server.bind(Ip{"*", 16000});
+		m_server.bind(Ipv4("*", 16000));
 		m_server.listen();
 		m_server.accept(nullptr);
 		m_server.close();
@@ -122,7 +122,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_client.connect(Ip{"127.0.0.1", 16000});
+		m_client.connect(Ipv4("127.0.0.1", 16000));
 		m_client.close();
 	});
 }
@@ -130,7 +130,7 @@
 TEST_F(TcpServerTest, io)
 {
 	m_tserver = std::thread([this] () {
-		m_server.bind(Ip{"*", 16000});
+		m_server.bind(Ipv4("*", 16000));
 		m_server.listen();
 
 		auto client = m_server.accept(nullptr);
@@ -144,7 +144,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_client.connect(Ip{"127.0.0.1", 16000});
+		m_client.connect(Ipv4("127.0.0.1", 16000));
 		m_client.send("hello world");
 
 		ASSERT_EQ("hello world", m_client.recv(512));
@@ -157,8 +157,8 @@
 
 class UdpServerTest : public testing::Test {
 protected:
-	SocketUdp<Ip> m_server;
-	SocketUdp<Ip> m_client;
+	SocketUdp<Ipv4> m_server;
+	SocketUdp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -166,7 +166,7 @@
 public:
 	UdpServerTest()
 	{
-		m_server.set(SOL_SOCKET, SO_REUSEADDR, 1);
+		m_server.set(SockBlockMode());
 	}
 
 	~UdpServerTest()
@@ -181,8 +181,8 @@
 TEST_F(UdpServerTest, io)
 {
 	m_tserver = std::thread([this] () {
-		Ip client;
-		Ip info{"*", 16000};
+		Ipv4 client;
+		Ipv4 info("*", 16000);
 
 		m_server.bind(info);
 		auto msg = m_server.recvfrom(512, &client);
@@ -196,7 +196,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		Ip info{"127.0.0.1", 16000};
+		Ipv4 info("127.0.0.1", 16000);
 
 		m_client.sendto("hello world", info);
 
@@ -253,7 +253,7 @@
 TEST(ListenerSet, initialAdd)
 {
 	Listener<TestBackendSet> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable);
 
@@ -266,7 +266,7 @@
 TEST(ListenerSet, readThenWrite)
 {
 	Listener<TestBackendSet> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable);
 	listener.set(s, Condition::Writable);
@@ -280,7 +280,7 @@
 TEST(ListenerSet, allOneShot)
 {
 	Listener<TestBackendSet> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable | Condition::Writable);
 
@@ -293,7 +293,7 @@
 TEST(ListenerSet, readTwice)
 {
 	Listener<TestBackendSet> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable);
 	listener.set(s, Condition::Readable);
@@ -307,7 +307,7 @@
 TEST(ListenerSet, failure)
 {
 	Listener<TestBackendSetFail> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	try {
 		listener.set(s, Condition::Readable);
@@ -368,7 +368,7 @@
 TEST(ListenerUnsetRemove, unset)
 {
 	Listener<TestBackendUnset> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable);
 	listener.unset(s, Condition::Readable);
@@ -383,7 +383,7 @@
 TEST(ListenerUnsetRemove, unsetOne)
 {
 	Listener<TestBackendUnset> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable | Condition::Writable);
 	listener.unset(s, Condition::Readable);
@@ -398,7 +398,7 @@
 TEST(ListenerUnsetRemove, unsetAll)
 {
 	Listener<TestBackendUnset> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable | Condition::Writable);
 	listener.unset(s, Condition::Readable);
@@ -414,7 +414,7 @@
 TEST(ListenerUnsetRemove, remove)
 {
 	Listener<TestBackendUnset> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable | Condition::Writable);
 	listener.remove(s);
@@ -429,7 +429,7 @@
 TEST(ListenerUnsetRemove, failure)
 {
 	Listener<TestBackendUnsetFail> listener;
-	Handle s{0};
+	Handle s = 0;
 
 	listener.set(s, Condition::Readable | Condition::Writable);
 
@@ -450,8 +450,8 @@
 class ListenerTest : public testing::Test {
 protected:
 	Listener<Select> m_listener;
-	SocketTcp<Ip> m_masterTcp;
-	SocketTcp<Ip> m_clientTcp;
+	SocketTcp<Ipv4> m_masterTcp;
+	SocketTcp<Ipv4> m_clientTcp;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -459,19 +459,17 @@
 public:
 	ListenerTest()
 	{
-		m_masterTcp.set(SOL_SOCKET, SO_REUSEADDR, 1);
-		m_masterTcp.bind(Ip{"*", 16000});
+		m_masterTcp.set(SockReuseAddress());
+		m_masterTcp.bind(Ipv4("*", 16000));
 		m_masterTcp.listen();
 	}
 
 	~ListenerTest()
 	{
-		if (m_tserver.joinable()) {
+		if (m_tserver.joinable())
 			m_tserver.join();
-		}
-		if (m_tclient.joinable()) {
+		if (m_tclient.joinable())
 			m_tclient.join();
-		}
 	}
 };
 
@@ -491,7 +489,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_clientTcp.connect(Ip{"127.0.0.1", 16000});
+		m_clientTcp.connect(Ipv4("127.0.0.1", 16000));
 	});
 }
 
@@ -513,7 +511,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_clientTcp.connect(Ip{"127.0.0.1", 16000});
+		m_clientTcp.connect(Ipv4("127.0.0.1", 16000));
 		m_clientTcp.send("hello");
 	});
 }
@@ -524,8 +522,8 @@
 
 class NonBlockingConnectTest : public testing::Test {
 protected:
-	SocketTcp<Ip> m_server;
-	SocketTcp<Ip> m_client;
+	SocketTcp<Ipv4> m_server;
+	SocketTcp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -533,7 +531,7 @@
 public:
 	NonBlockingConnectTest()
 	{
-		m_client.set(SockBlockMode{false});
+		m_client.set(SockBlockMode(false));
 	}
 
 	~NonBlockingConnectTest()
@@ -551,8 +549,8 @@
 
 class TcpAcceptTest : public testing::Test {
 protected:
-	SocketTcp<Ip> m_server;
-	SocketTcp<Ip> m_client;
+	SocketTcp<Ipv4> m_server;
+	SocketTcp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -560,8 +558,8 @@
 public:
 	TcpAcceptTest()
 	{
-		m_server.set(SOL_SOCKET, SO_REUSEADDR, 1);
-		m_server.bind(Ip{"*", 16000});
+		m_server.set(SockReuseAddress());
+		m_server.bind(Ipv4("*", 16000));
 		m_server.listen();
 	}
 
@@ -580,8 +578,8 @@
 
 class TcpRecvTest : public testing::Test {
 protected:
-	SocketTcp<Ip> m_server;
-	SocketTcp<Ip> m_client;
+	SocketTcp<Ipv4> m_server;
+	SocketTcp<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -589,8 +587,8 @@
 public:
 	TcpRecvTest()
 	{
-		m_server.set(SOL_SOCKET, SO_REUSEADDR, 1);
-		m_server.bind(Ip{"*", 16000});
+		m_server.set(SockReuseAddress());
+		m_server.bind(Ipv4("*", 16000));
 		m_server.listen();
 	}
 
@@ -614,7 +612,7 @@
 	std::this_thread::sleep_for(100ms);
 
 	m_tclient = std::thread([this] () {
-		m_client.connect(Ip{"127.0.0.1", 16000});
+		m_client.connect(Ipv4("127.0.0.1", 16000));
 		m_client.send("hello");
 		m_client.close();
 	});
@@ -624,10 +622,12 @@
  * Socket SSL
  * -------------------------------------------------------- */
 
+#if !defined(SOCKET_NO_SSL)
+
 class TlsRecvTest : public testing::Test {
 protected:
-	SocketTls<Ip> m_server{nullptr};
-	SocketTls<Ip> m_client;
+	SocketTls<Ipv4> m_server{nullptr};
+	SocketTls<Ipv4> m_client;
 
 	std::thread m_tserver;
 	std::thread m_tclient;
@@ -641,9 +641,9 @@
 		protocol.setPrivateKey("sockets/test.key");
 		protocol.setVerify(false);
 
-		m_server = SocketTls<Ip>{std::move(protocol)};
-		m_server.set(SOL_SOCKET, SO_REUSEADDR, 1);
-		m_server.bind(Ip{"*", 16000});
+		m_server = SocketTls<Ipv4>(std::move(protocol));
+		m_server.set(SockReuseAddress());
+		m_server.bind(Ipv4("*", 16000));
 		m_server.listen();
 	}
 
@@ -672,7 +672,7 @@
 
 	m_tclient = std::thread([this] () {
 		try {
-			m_client.connect(Ip{"127.0.0.1", 16000});
+			m_client.connect(Ipv4("127.0.0.1", 16000));
 			m_client.send("hello");
 		} catch (const net::Error &ex) {
 			FAIL() << ex.function() << ": " << ex.what();
@@ -680,6 +680,8 @@
 	});
 }
 
+#endif
+
 int main(int argc, char **argv)
 {
 	testing::InitGoogleTest(&argc, argv);