degesch: asynchronous connecting etc.

I'm sorry, couldn't keep the diff small.

All the ZyklonB heritage code is shit anyway.

2 files changed, 733 insertions, 465 deletions

diff --git a/common.c b/common.c
index 820863d..32ccc01 100644
--- a/common.c
+++ b/common.c
@@ -90,6 +90,239 @@ log_message_syslog (void *user_data, const char *quote, const char *fmt,
 		syslog (prio, "%s%s", quote, buf);
 }
 
+// --- Connector ---------------------------------------------------------------
+
+// This is a helper that tries to establish a connection with any address on
+// a given list.  Sadly it also introduces a bit of a callback hell.
+
+struct connector_target
+{
+	LIST_HEADER (struct connector_target)
+
+	char *hostname;                     ///< Target hostname or address
+	char *service;                      ///< Target service name or port
+
+	struct addrinfo *results;           ///< Resolved target
+	struct addrinfo *iter;              ///< Current endpoint
+};
+
+static struct connector_target *
+connector_target_new (void)
+{
+	struct connector_target *self = xmalloc (sizeof *self);
+	return self;
+}
+
+static void
+connector_target_destroy (struct connector_target *self)
+{
+	free (self->hostname);
+	free (self->service);
+	freeaddrinfo (self->results);
+	free (self);
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+struct connector
+{
+	int socket;                         ///< Socket FD for the connection
+	struct poller_fd connected_event;   ///< We've connected or failed
+	struct connector_target *targets;   ///< Targets
+	struct connector_target *targets_t; ///< Tail of targets
+
+	void *user_data;                    ///< User data for callbacks
+
+	// You may destroy the connector object in these two main callbacks:
+
+	/// Connection has been successfully established
+	void (*on_connected) (void *user_data, int socket);
+	/// Failed to establish a connection to either target
+	void (*on_failure) (void *user_data);
+
+	// Optional:
+
+	/// Connecting to a new address
+	void (*on_connecting) (void *user_data, const char *address);
+	/// Connecting to the last address has failed
+	void (*on_error) (void *user_data, const char *error);
+};
+
+static void
+connector_notify_connecting (struct connector *self,
+	struct connector_target *target, struct addrinfo *gai_iter)
+{
+	if (!self->on_connecting)
+		return;
+
+	const char *real_host = target->hostname;
+
+	// We don't really need this, so we can let it quietly fail
+	char buf[NI_MAXHOST];
+	int err = getnameinfo (gai_iter->ai_addr, gai_iter->ai_addrlen,
+		buf, sizeof buf, NULL, 0, NI_NUMERICHOST);
+	if (err)
+		LOG_FUNC_FAILURE ("getnameinfo", gai_strerror (err));
+	else
+		real_host = buf;
+
+	char *address = format_host_port_pair (real_host, target->service);
+	self->on_connecting (self->user_data, address);
+	free (address);
+}
+
+static void
+connector_notify_error (struct connector *self, const char *error)
+{
+	if (self->on_error)
+		self->on_error (self->user_data, error);
+}
+
+static void
+connector_prepare_next (struct connector *self)
+{
+	struct connector_target *target = self->targets;
+	if (!(target->iter = target->iter->ai_next))
+	{
+		LIST_UNLINK_WITH_TAIL (self->targets, self->targets_t, target);
+		connector_target_destroy (target);
+	}
+}
+
+static void
+connector_step (struct connector *self)
+{
+	struct connector_target *target = self->targets;
+	if (!target)
+	{
+		// Total failure, none of the targets has succeeded
+		self->on_failure (self->user_data);
+		return;
+	}
+
+	struct addrinfo *gai_iter = target->iter;
+	hard_assert (gai_iter != NULL);
+
+	connector_notify_connecting (self, target, gai_iter);
+
+	int fd = self->socket = socket (gai_iter->ai_family,
+		gai_iter->ai_socktype, gai_iter->ai_protocol);
+	if (fd == -1)
+	{
+		connector_notify_error (self, strerror (errno));
+
+		connector_prepare_next (self);
+		connector_step (self);
+		return;
+	}
+
+	set_cloexec (fd);
+	set_blocking (fd, false);
+
+	int yes = 1;
+	soft_assert (setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE,
+		&yes, sizeof yes) != -1);
+
+	if (!connect (fd, gai_iter->ai_addr, gai_iter->ai_addrlen))
+	{
+		set_blocking (fd, true);
+		self->on_connected (self->user_data, fd);
+		return;
+	}
+	else if (errno != EINPROGRESS)
+	{
+		connector_notify_error (self, strerror (errno));
+		xclose (fd);
+
+		connector_prepare_next (self);
+		connector_step (self);
+		return;
+	}
+
+	self->connected_event.fd = self->socket = fd;
+	poller_fd_set (&self->connected_event, POLLOUT);
+
+	connector_prepare_next (self);
+}
+
+static void
+connector_on_ready (const struct pollfd *pfd, struct connector *self)
+{
+	// See http://cr.yp.to/docs/connect.html if this doesn't work.
+	// The second connect() method doesn't work with DragonflyBSD.
+
+	int error = 0;
+	socklen_t error_len = sizeof error;
+	hard_assert (!getsockopt (pfd->fd,
+		SOL_SOCKET, SO_ERROR, &error, &error_len));
+
+	if (error)
+	{
+		connector_notify_error (self, strerror (errno));
+
+		xclose (self->socket);
+		self->socket = -1;
+
+		connector_step (self);
+	}
+	else
+	{
+		poller_fd_reset (&self->connected_event);
+		self->socket = -1;
+
+		set_blocking (pfd->fd, true);
+		self->on_connected (self->user_data, pfd->fd);
+	}
+}
+
+static void
+connector_init (struct connector *self, struct poller *poller)
+{
+	memset (self, 0, sizeof *self);
+	self->socket = -1;
+	poller_fd_init (&self->connected_event, poller, self->socket);
+	self->connected_event.user_data = self;
+	self->connected_event.dispatcher = (poller_fd_fn) connector_on_ready;
+}
+
+static void
+connector_free (struct connector *self)
+{
+	poller_fd_reset (&self->connected_event);
+	if (self->socket != -1)
+		xclose (self->socket);
+
+	LIST_FOR_EACH (struct connector_target, iter, self->targets)
+		connector_target_destroy (iter);
+}
+
+static bool
+connector_add_target (struct connector *self,
+	const char *hostname, const char *service, struct error **e)
+{
+	struct addrinfo hints, *results;
+	memset (&hints, 0, sizeof hints);
+	hints.ai_socktype = SOCK_STREAM;
+
+	// TODO: even this should be done asynchronously, most likely in
+	//   a thread pool, similarly to how libuv does it
+	int err = getaddrinfo (hostname, service, &hints, &results);
+	if (err)
+	{
+		error_set (e, "%s: %s", "getaddrinfo", gai_strerror (err));
+		return false;
+	}
+
+	struct connector_target *target = connector_target_new ();
+	target->hostname = xstrdup (hostname);
+	target->service = xstrdup (service);
+	target->results = results;
+	target->iter = target->results;
+
+	LIST_APPEND_WITH_TAIL (self->targets, self->targets_t, target);
+	return true;
+}
+
 // --- SOCKS 5/4a (blocking implementation) ------------------------------------
 
 // These are awkward protocols.  Note that the `username' is used differently
diff --git a/degesch.c b/degesch.c
index f4e1a81..7cffb3b 100644
--- a/degesch.c
+++ b/degesch.c
@@ -977,6 +977,7 @@ buffer_destroy (struct buffer *self)
 enum server_state
 {
 	IRC_DISCONNECTED,                   ///< Not connected
+	IRC_CONNECTING,                     ///< Connecting to the server
 	IRC_CONNECTED,                      ///< Trying to register
 	IRC_REGISTERED                      ///< We can chat now
 };
@@ -984,8 +985,11 @@ enum server_state
 struct server
 {
 	struct app_context *ctx;            ///< Application context
+	bool reconnect;                     ///< Whether to reconnect on conn. fail.
+	unsigned long reconnect_delay;      ///< Reconnect delay in seconds
 
 	enum server_state state;            ///< Connection state
+	struct connector *connector;        ///< Connection establisher
 
 	int socket;                         ///< Socket FD of the server
 	struct str read_buffer;             ///< Input yet to be processed
@@ -1021,9 +1025,9 @@ struct server
 	struct poller_timer reconnect_tmr;  ///< We should reconnect now
 };
 
-static void on_irc_ping_timeout (void *user_data);
 static void on_irc_timeout (void *user_data);
-static void on_irc_reconnect_timeout (void *user_data);
+static void on_irc_ping_timeout (void *user_data);
+static void irc_initiate_connect (struct server *s);
 
 static void
 server_init (struct server *self, struct poller *poller)
@@ -1048,13 +1052,18 @@ server_init (struct server *self, struct poller *poller)
 	self->ping_tmr.user_data = self;
 
 	poller_timer_init (&self->reconnect_tmr, poller);
-	self->reconnect_tmr.dispatcher = on_irc_reconnect_timeout;
+	self->reconnect_tmr.dispatcher = (poller_timer_fn) irc_initiate_connect;
 	self->reconnect_tmr.user_data = self;
 }
 
 static void
 server_free (struct server *self)
 {
+	if (self->connector)
+	{
+		connector_free (self->connector);
+		free (self->connector);
+	}
 	if (self->socket != -1)
 	{
 		xclose (self->socket);
@@ -1086,8 +1095,6 @@ struct app_context
 	struct config config;               ///< Program configuration
 	char *attrs[ATTR_COUNT];            ///< Terminal attributes
 	bool no_colors;                     ///< Colour output mode
-	bool reconnect;                     ///< Whether to reconnect on conn. fail.
-	unsigned long reconnect_delay;      ///< Reconnect delay in seconds
 	bool isolate_buffers;               ///< Isolate global/server buffers
 
 	struct server server;               ///< Our only server so far
@@ -2453,11 +2460,11 @@ irc_remove_user_from_channel (struct user *user, struct channel *channel)
 			irc_channel_unlink_user (channel, iter);
 }
 
-// --- Supporting code ---------------------------------------------------------
+// --- Core functionality ------------------------------------------------------
 
-static bool irc_connect (struct server *s, bool *should_retry, struct error **);
-static void irc_cancel_timers (struct server *s);
-static void on_irc_reconnect_timeout (void *user_data);
+// Most of the core IRC code comes from ZyklonB which is mostly blocking.
+// While it's fairly easy to follow, it also stinks.  It needs to be rewritten
+// to be as asynchronous as possible.  See kike.c for reference.
 
 static bool
 irc_is_connected (struct server *s)
@@ -2466,117 +2473,36 @@ irc_is_connected (struct server *s)
 }
 
 static void
-irc_shutdown (struct server *s)
+irc_cancel_timers (struct server *s)
 {
-	// TODO: set a timer after which we cut the connection?
-	// Generally non-critical
-	if (s->ssl)
-		soft_assert (SSL_shutdown (s->ssl) != -1);
-	else
-		soft_assert (shutdown (s->socket, SHUT_WR) == 0);
+	poller_timer_reset (&s->timeout_tmr);
+	poller_timer_reset (&s->ping_tmr);
+	poller_timer_reset (&s->reconnect_tmr);
 }
 
 static void
-try_finish_quit (struct app_context *ctx)
+irc_reset_connection_timeouts (struct server *s)
 {
-	// TODO: multiserver
-	if (ctx->quitting && !irc_is_connected (&ctx->server))
-		ctx->polling = false;
+	irc_cancel_timers (s);
+	poller_timer_set (&s->timeout_tmr, 3 * 60 * 1000);
+	poller_timer_set (&s->ping_tmr, (3 * 60 + 30) * 1000);
 }
 
 static void
-initiate_quit (struct app_context *ctx)
-{
-	// Destroy the user interface
-	input_stop (&ctx->input);
-
-	buffer_send_status (ctx, ctx->global_buffer, "Shutting down");
-
-	// Initiate a connection close
-	// TODO: multiserver
-	struct server *s = &ctx->server;
-	if (irc_is_connected (s))
-		// XXX: when we go async, we'll have to flush output buffers first
-		irc_shutdown (s);
-
-	ctx->quitting = true;
-	try_finish_quit (ctx);
-}
-
-// As of 2015, everything should be in UTF-8.  And if it's not, we'll decode it
-// as ISO Latin 1.  This function should not be called on the whole message.
-static char *
-irc_to_utf8 (struct app_context *ctx, const char *text)
+irc_queue_reconnect (struct server *s)
 {
-	size_t len = strlen (text) + 1;
-	if (utf8_validate (text, len))
-		return xstrdup (text);
-	return iconv_xstrdup (ctx->latin1_to_utf8, (char *) text, len, NULL);
-}
+	// As long as the user wants us to, that is
+	if (!s->reconnect)
+		return;
 
-// This function is used to output debugging IRC traffic to the terminal.
-// It's far from ideal, as any non-UTF-8 text degrades the entire line to
-// ISO Latin 1.  But it should work good enough most of the time.
-static char *
-irc_to_term (struct app_context *ctx, const char *text)
-{
-	char *utf8 = irc_to_utf8 (ctx, text);
-	char *term = iconv_xstrdup (ctx->term_from_utf8, utf8, -1, NULL);
-	free (utf8);
-	return term;
+	// TODO: exponentional backoff
+	hard_assert (s->socket == -1);
+	buffer_send_status (s->ctx, s->buffer,
+		"Trying to reconnect in %ld seconds...", s->reconnect_delay);
+	poller_timer_set (&s->reconnect_tmr, s->reconnect_delay * 1000);
 }
 
-static bool irc_send (struct server *s,
-	const char *format, ...) ATTRIBUTE_PRINTF (2, 3);
-
-static bool
-irc_send (struct server *s, const char *format, ...)
-{
-	if (!soft_assert (irc_is_connected (s)))
-	{
-		print_debug ("tried sending a message to a dead server connection");
-		return false;
-	}
-
-	va_list ap;
-	va_start (ap, format);
-	struct str str;
-	str_init (&str);
-	str_append_vprintf (&str, format, ap);
-	va_end (ap);
-
-	if (g_debug_mode)
-	{
-		input_hide (&s->ctx->input);
-
-		char *term = irc_to_term (s->ctx, str.str);
-		fprintf (stderr, "[IRC] <== \"%s\"\n", term);
-		free (term);
-
-		input_show (&s->ctx->input);
-	}
-	str_append (&str, "\r\n");
-
-	bool result = true;
-	if (s->ssl)
-	{
-		// TODO: call SSL_get_error() to detect if a clean shutdown has occured
-		if (SSL_write (s->ssl, str.str, str.len) != (int) str.len)
-		{
-			LOG_FUNC_FAILURE ("SSL_write",
-				ERR_error_string (ERR_get_error (), NULL));
-			result = false;
-		}
-	}
-	else if (write (s->socket, str.str, str.len) != (ssize_t) str.len)
-	{
-		LOG_LIBC_FAILURE ("write");
-		result = false;
-	}
-
-	str_free (&str);
-	return result;
-}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 static bool
 irc_initialize_ssl_ctx (struct server *s, struct error **e)
@@ -2685,70 +2611,491 @@ error_ssl_1:
 	return false;
 }
 
-static bool
-irc_establish_connection (struct server *s,
-	const char *host, const char *port, struct error **e)
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// As of 2015, everything should be in UTF-8.  And if it's not, we'll decode it
+// as ISO Latin 1.  This function should not be called on the whole message.
+static char *
+irc_to_utf8 (struct app_context *ctx, const char *text)
 {
-	struct addrinfo gai_hints, *gai_result, *gai_iter;
-	memset (&gai_hints, 0, sizeof gai_hints);
-	gai_hints.ai_socktype = SOCK_STREAM;
+	size_t len = strlen (text) + 1;
+	if (utf8_validate (text, len))
+		return xstrdup (text);
+	return iconv_xstrdup (ctx->latin1_to_utf8, (char *) text, len, NULL);
+}
 
-	int err = getaddrinfo (host, port, &gai_hints, &gai_result);
-	if (err)
+// This function is used to output debugging IRC traffic to the terminal.
+// It's far from ideal, as any non-UTF-8 text degrades the entire line to
+// ISO Latin 1.  But it should work good enough most of the time.
+static char *
+irc_to_term (struct app_context *ctx, const char *text)
+{
+	char *utf8 = irc_to_utf8 (ctx, text);
+	char *term = iconv_xstrdup (ctx->term_from_utf8, utf8, -1, NULL);
+	free (utf8);
+	return term;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static void irc_send (struct server *s,
+	const char *format, ...) ATTRIBUTE_PRINTF (2, 3);
+
+static void
+irc_send (struct server *s, const char *format, ...)
+{
+	if (!soft_assert (irc_is_connected (s)))
 	{
-		error_set (e, "%s: %s: %s",
-			"connection failed", "getaddrinfo", gai_strerror (err));
-		return false;
+		print_debug ("tried sending a message to a dead server connection");
+		return;
 	}
 
-	int sockfd;
-	for (gai_iter = gai_result; gai_iter; gai_iter = gai_iter->ai_next)
+	va_list ap;
+	va_start (ap, format);
+	struct str str;
+	str_init (&str);
+	str_append_vprintf (&str, format, ap);
+	va_end (ap);
+
+	if (g_debug_mode)
 	{
-		sockfd = socket (gai_iter->ai_family,
-			gai_iter->ai_socktype, gai_iter->ai_protocol);
-		if (sockfd == -1)
-			continue;
-		set_cloexec (sockfd);
+		input_hide (&s->ctx->input);
 
-		int yes = 1;
-		soft_assert (setsockopt (sockfd, SOL_SOCKET, SO_KEEPALIVE,
-			&yes, sizeof yes) != -1);
+		char *term = irc_to_term (s->ctx, str.str);
+		fprintf (stderr, "[IRC] <== \"%s\"\n", term);
+		free (term);
 
-		const char *real_host = host;
+		input_show (&s->ctx->input);
+	}
+	str_append (&str, "\r\n");
 
-		// Let's try to resolve the address back into a real hostname;
-		// we don't really need this, so we can let it quietly fail
-		char buf[NI_MAXHOST];
-		err = getnameinfo (gai_iter->ai_addr, gai_iter->ai_addrlen,
-			buf, sizeof buf, NULL, 0, NI_NUMERICHOST);
-		if (err)
-			LOG_FUNC_FAILURE ("getnameinfo", gai_strerror (err));
-		else
-			real_host = buf;
+	if (s->ssl)
+	{
+		// TODO: call SSL_get_error() to detect if a clean shutdown has occured
+		if (SSL_write (s->ssl, str.str, str.len) != (int) str.len)
+			LOG_FUNC_FAILURE ("SSL_write",
+				ERR_error_string (ERR_get_error (), NULL));
+	}
+	else if (write (s->socket, str.str, str.len) != (ssize_t) str.len)
+		LOG_LIBC_FAILURE ("write");
 
-		char *address = format_host_port_pair (real_host, port);
-		buffer_send_status (s->ctx, s->buffer, "Connecting to %s...", address);
-		free (address);
+	str_free (&str);
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static void
+irc_shutdown (struct server *s)
+{
+	// TODO: set a timer after which we cut the connection?
+	// Generally non-critical
+	if (s->ssl)
+		soft_assert (SSL_shutdown (s->ssl) != -1);
+	else
+		soft_assert (shutdown (s->socket, SHUT_WR) == 0);
+}
+
+static void
+irc_destroy_connector (struct server *s)
+{
+	connector_free (s->connector);
+	free (s->connector);
+	s->connector = NULL;
+
+	// Not connecting anymore
+	s->state = IRC_DISCONNECTED;
+}
+
+static void
+try_finish_quit (struct app_context *ctx)
+{
+	// TODO: multiserver
+	if (ctx->quitting && !irc_is_connected (&ctx->server))
+		ctx->polling = false;
+}
+
+static void
+initiate_quit (struct app_context *ctx)
+{
+	// Destroy the user interface
+	input_stop (&ctx->input);
+
+	buffer_send_status (ctx, ctx->global_buffer, "Shutting down");
+
+	// Initiate a connection close
+	// TODO: multiserver
+	struct server *s = &ctx->server;
+	if (irc_is_connected (s))
+		// XXX: when we go async, we'll have to flush output buffers first
+		irc_shutdown (s);
+	else if (s->state == IRC_CONNECTING)
+		irc_destroy_connector (s);
+
+	ctx->quitting = true;
+	try_finish_quit (ctx);
+}
+
+static void
+on_irc_disconnected (struct server *s)
+{
+	hard_assert (irc_is_connected (s));
+
+	// Get rid of the dead socket and related things
+	if (s->ssl)
+	{
+		SSL_free (s->ssl);
+		s->ssl = NULL;
+		SSL_CTX_free (s->ssl_ctx);
+		s->ssl_ctx = NULL;
+	}
+
+	xclose (s->socket);
+	s->socket = -1;
+	s->state = IRC_DISCONNECTED;
+
+	user_unref (s->irc_user);
+	s->irc_user = NULL;
+
+	free (s->irc_user_mode);
+	s->irc_user_mode = NULL;
+	free (s->irc_user_host);
+	s->irc_user_host = NULL;
+
+	s->read_event.closed = true;
+	poller_fd_reset (&s->read_event);
+
+	// All of our timers have lost their meaning now
+	irc_cancel_timers (s);
+
+	if (s->ctx->quitting)
+		try_finish_quit (s->ctx);
+	else
+		irc_queue_reconnect (s);
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static void
+on_irc_ping_timeout (void *user_data)
+{
+	struct server *s = user_data;
+	buffer_send_error (s->ctx, s->buffer, "Connection timeout");
+	on_irc_disconnected (s);
+}
+
+static void
+on_irc_timeout (void *user_data)
+{
+	// Provoke a response from the server
+	struct server *s = user_data;
+	irc_send (s, "PING :%s", get_config_string (s->ctx, s->irc_user->nickname));
+}
+
+// --- Processing server output ------------------------------------------------
+
+static void irc_process_message
+	(const struct irc_message *msg, const char *raw, void *user_data);
+
+enum irc_read_result
+{
+	IRC_READ_OK,                        ///< Some data were read successfully
+	IRC_READ_EOF,                       ///< The server has closed connection
+	IRC_READ_AGAIN,                     ///< No more data at the moment
+	IRC_READ_ERROR                      ///< General connection failure
+};
+
+static enum irc_read_result
+irc_fill_read_buffer_ssl (struct server *s, struct str *buf)
+{
+	int n_read;
+start:
+	n_read = SSL_read (s->ssl, buf->str + buf->len,
+		buf->alloc - buf->len - 1 /* null byte */);
+
+	const char *error_info = NULL;
+	switch (xssl_get_error (s->ssl, n_read, &error_info))
+	{
+	case SSL_ERROR_NONE:
+		buf->str[buf->len += n_read] = '\0';
+		return IRC_READ_OK;
+	case SSL_ERROR_ZERO_RETURN:
+		return IRC_READ_EOF;
+	case SSL_ERROR_WANT_READ:
+		return IRC_READ_AGAIN;
+	case SSL_ERROR_WANT_WRITE:
+	{
+		// Let it finish the handshake as we don't poll for writability;
+		// any errors are to be collected by SSL_read() in the next iteration
+		struct pollfd pfd = { .fd = s->socket, .events = POLLOUT };
+		soft_assert (poll (&pfd, 1, 0) > 0);
+		goto start;
+	}
+	case XSSL_ERROR_TRY_AGAIN:
+		goto start;
+	default:
+		LOG_FUNC_FAILURE ("SSL_read", error_info);
+		return IRC_READ_ERROR;
+	}
+}
+
+static enum irc_read_result
+irc_fill_read_buffer (struct server *s, struct str *buf)
+{
+	ssize_t n_read;
+start:
+	n_read = recv (s->socket, buf->str + buf->len,
+		buf->alloc - buf->len - 1 /* null byte */, 0);
+
+	if (n_read > 0)
+	{
+		buf->str[buf->len += n_read] = '\0';
+		return IRC_READ_OK;
+	}
+	if (n_read == 0)
+		return IRC_READ_EOF;
+
+	if (errno == EAGAIN)
+		return IRC_READ_AGAIN;
+	if (errno == EINTR)
+		goto start;
+
+	LOG_LIBC_FAILURE ("recv");
+	return IRC_READ_ERROR;
+}
+
+static void
+on_irc_readable (const struct pollfd *fd, struct server *s)
+{
+	if (fd->revents & ~(POLLIN | POLLHUP | POLLERR))
+		print_debug ("fd %d: unexpected revents: %d", fd->fd, fd->revents);
+
+	(void) set_blocking (s->socket, false);
 
-		if (!connect (sockfd, gai_iter->ai_addr, gai_iter->ai_addrlen))
+	struct str *buf = &s->read_buffer;
+	enum irc_read_result (*fill_buffer)(struct server *, struct str *)
+		= s->ssl
+		? irc_fill_read_buffer_ssl
+		: irc_fill_read_buffer;
+	bool disconnected = false;
+	while (true)
+	{
+		str_ensure_space (buf, 512);
+		switch (fill_buffer (s, buf))
+		{
+		case IRC_READ_AGAIN:
+			goto end;
+		case IRC_READ_ERROR:
+			buffer_send_error (s->ctx, s->buffer,
+				"Reading from the IRC server failed");
+			disconnected = true;
+			goto end;
+		case IRC_READ_EOF:
+			buffer_send_error (s->ctx, s->buffer,
+				"The IRC server closed the connection");
+			disconnected = true;
+			goto end;
+		case IRC_READ_OK:
 			break;
+		}
+
+		if (buf->len >= (1 << 20))
+		{
+			buffer_send_error (s->ctx, s->buffer,
+				"The IRC server seems to spew out data frantically");
+			irc_shutdown (s);
+			goto end;
+		}
+	}
+end:
+	(void) set_blocking (s->socket, true);
+	irc_process_buffer (buf, irc_process_message, s);
+
+	if (disconnected)
+		on_irc_disconnected (s);
+	else
+		irc_reset_connection_timeouts (s);
+}
+
+// --- Connection establishment ------------------------------------------------
+
+static void
+irc_register (struct server *s)
+{
+	const char *nickname = get_config_string (s->ctx, "server.nickname");
+	const char *username = get_config_string (s->ctx, "server.username");
+	const char *realname = get_config_string (s->ctx, "server.realname");
+
+	// These are filled automatically if needed
+	hard_assert (nickname && username && realname);
+
+	irc_send (s, "NICK %s", nickname);
+	// IRC servers may ignore the last argument if it's empty
+	irc_send (s, "USER %s 8 * :%s", username, *realname ? realname : " ");
+
+	// XXX: maybe we should wait for the first message from the server
+	// FIXME: the user may exist already after we've reconnected. Either
+	//   make sure that there's no reference of this nick upon disconnection,
+	//   or search in "irc_users" first... or something.
+	s->irc_user = irc_make_user (s, xstrdup (nickname));
+	s->irc_user_mode = xstrdup ("");
+	s->irc_user_host = NULL;
+}
+
+static void
+irc_finish_connection (struct server *s, int socket)
+{
+	struct app_context *ctx = s->ctx;
+
+	s->socket = socket;
 
-		xclose (sockfd);
+	struct error *e = NULL;
+	bool use_ssl = get_config_boolean (ctx, "server.ssl");
+	if (use_ssl && !irc_initialize_ssl (s, &e))
+	{
+		buffer_send_error (ctx, s->buffer, "Connection failed: %s", e->message);
+		error_free (e);
+
+		xclose (s->socket);
+		s->socket = -1;
+
+		irc_queue_reconnect (s);
+		return;
 	}
 
-	freeaddrinfo (gai_result);
+	buffer_send_status (ctx, s->buffer, "Connection established");
+	s->state = IRC_CONNECTED;
+
+	poller_fd_init (&s->read_event, &ctx->poller, s->socket);
+	s->read_event.dispatcher = (poller_fd_fn) on_irc_readable;
+	s->read_event.user_data = s;
+
+	poller_fd_set (&s->read_event, POLLIN);
+	irc_reset_connection_timeouts (s);
+
+	irc_register (s);
+}
+
+static void
+irc_on_connector_connecting (void *user_data, const char *address)
+{
+	struct server *s = user_data;
+	buffer_send_status (s->ctx, s->buffer, "Connecting to %s...", address);
+}
+
+static void
+irc_on_connector_error (void *user_data, const char *error)
+{
+	struct server *s = user_data;
+	buffer_send_error (s->ctx, s->buffer, "Connection failed: %s", error);
+}
+
+static void
+irc_on_connector_failure (void *user_data)
+{
+	struct server *s = user_data;
+	irc_destroy_connector (s);
+	irc_queue_reconnect (s);
+}
+
+static void
+irc_on_connector_connected (void *user_data, int socket)
+{
+	struct server *s = user_data;
+	irc_destroy_connector (s);
+	irc_finish_connection (s, socket);
+}
+
+static bool
+irc_setup_connector (struct server *s,
+	const char *host, const char *port, struct error **e)
+{
+	struct connector *connector = xmalloc (sizeof *connector);
+	connector_init (connector, &s->ctx->poller);
+
+	connector->user_data     = s;
+	connector->on_connecting = irc_on_connector_connecting;
+	connector->on_error      = irc_on_connector_error;
+	connector->on_connected  = irc_on_connector_connected;
+	connector->on_failure    = irc_on_connector_failure;
 
-	if (!gai_iter)
+	s->state = IRC_CONNECTING;
+	s->connector = connector;
+
+	if (!connector_add_target (connector, host, port, e))
 	{
-		error_set (e, "connection failed");
+		irc_destroy_connector (s);
 		return false;
 	}
 
-	s->socket = sockfd;
+	connector_step (connector);
 	return true;
 }
 
-// --- More readline funky stuff -----------------------------------------------
+static void
+irc_initiate_connect (struct server *s)
+{
+	hard_assert (s->state == IRC_DISCONNECTED);
+	struct app_context *ctx = s->ctx;
+
+	const char *irc_host = get_config_string (ctx, "server.irc_host");
+	int64_t irc_port_int = get_config_integer (ctx, "server.irc_port");
+
+	if (!get_config_string (ctx, "server.irc_host"))
+	{
+		// No sense in trying to reconnect
+		buffer_send_error (ctx, s->buffer,
+			"No hostname specified in configuration");
+		return;
+	}
+
+	const char *socks_host = get_config_string (ctx, "server.socks_host");
+	int64_t socks_port_int = get_config_integer (ctx, "server.socks_port");
+
+	const char *socks_username =
+		get_config_string (ctx, "server.socks_username");
+	const char *socks_password =
+		get_config_string (ctx, "server.socks_password");
+
+	char *irc_port   = xstrdup_printf ("%" PRIi64, irc_port_int);
+	char *socks_port = xstrdup_printf ("%" PRIi64, socks_port_int);
+
+	// TODO: the SOCKS code needs a rewrite so that we don't block on it either
+	struct error *e = NULL;
+	if (socks_host)
+	{
+		char *address = format_host_port_pair (irc_host, irc_port);
+		char *socks_address = format_host_port_pair (socks_host, socks_port);
+		buffer_send_status (ctx, s->buffer,
+			"Connecting to %s via %s...", address, socks_address);
+		free (socks_address);
+		free (address);
+
+		struct error *error = NULL;
+		int fd = socks_connect (socks_host, socks_port, irc_host, irc_port,
+			socks_username, socks_password, &error);
+		if (fd != -1)
+			irc_finish_connection (s, fd);
+		else
+		{
+			error_set (&e, "%s: %s", "SOCKS connection failed", error->message);
+			error_free (error);
+		}
+	}
+	else
+		irc_setup_connector (s, irc_host, irc_port, &e);
+
+	free (irc_port);
+	free (socks_port);
+
+	if (e)
+	{
+		buffer_send_error (s->ctx, s->buffer, "%s", e->message);
+		error_free (e);
+		irc_queue_reconnect (s);
+	}
+}
+
+// --- Input prompt ------------------------------------------------------------
 
 static char *
 make_unseen_prefix (struct app_context *ctx)
@@ -4428,7 +4775,7 @@ handle_command_connect (struct app_context *ctx, char *arguments)
 	}
 
 	irc_cancel_timers (s);
-	on_irc_reconnect_timeout (s);
+	irc_initiate_connect (s);
 	return true;
 }
 
@@ -4725,318 +5072,6 @@ process_input (struct app_context *ctx, char *user_input)
 	free (input);
 }
 
-// --- Supporting code (continued) ---------------------------------------------
-
-enum irc_read_result
-{
-	IRC_READ_OK,                        ///< Some data were read successfully
-	IRC_READ_EOF,                       ///< The server has closed connection
-	IRC_READ_AGAIN,                     ///< No more data at the moment
-	IRC_READ_ERROR                      ///< General connection failure
-};
-
-static enum irc_read_result
-irc_fill_read_buffer_ssl (struct server *s, struct str *buf)
-{
-	int n_read;
-start:
-	n_read = SSL_read (s->ssl, buf->str + buf->len,
-		buf->alloc - buf->len - 1 /* null byte */);
-
-	const char *error_info = NULL;
-	switch (xssl_get_error (s->ssl, n_read, &error_info))
-	{
-	case SSL_ERROR_NONE:
-		buf->str[buf->len += n_read] = '\0';
-		return IRC_READ_OK;
-	case SSL_ERROR_ZERO_RETURN:
-		return IRC_READ_EOF;
-	case SSL_ERROR_WANT_READ:
-		return IRC_READ_AGAIN;
-	case SSL_ERROR_WANT_WRITE:
-	{
-		// Let it finish the handshake as we don't poll for writability;
-		// any errors are to be collected by SSL_read() in the next iteration
-		struct pollfd pfd = { .fd = s->socket, .events = POLLOUT };
-		soft_assert (poll (&pfd, 1, 0) > 0);
-		goto start;
-	}
-	case XSSL_ERROR_TRY_AGAIN:
-		goto start;
-	default:
-		LOG_FUNC_FAILURE ("SSL_read", error_info);
-		return IRC_READ_ERROR;
-	}
-}
-
-static enum irc_read_result
-irc_fill_read_buffer (struct server *s, struct str *buf)
-{
-	ssize_t n_read;
-start:
-	n_read = recv (s->socket, buf->str + buf->len,
-		buf->alloc - buf->len - 1 /* null byte */, 0);
-
-	if (n_read > 0)
-	{
-		buf->str[buf->len += n_read] = '\0';
-		return IRC_READ_OK;
-	}
-	if (n_read == 0)
-		return IRC_READ_EOF;
-
-	if (errno == EAGAIN)
-		return IRC_READ_AGAIN;
-	if (errno == EINTR)
-		goto start;
-
-	LOG_LIBC_FAILURE ("recv");
-	return IRC_READ_ERROR;
-}
-
-static void
-irc_cancel_timers (struct server *s)
-{
-	poller_timer_reset (&s->timeout_tmr);
-	poller_timer_reset (&s->ping_tmr);
-	poller_timer_reset (&s->reconnect_tmr);
-}
-
-static void
-irc_queue_reconnect (struct server *s)
-{
-	// TODO: exponentional backoff
-	hard_assert (s->socket == -1);
-	buffer_send_status (s->ctx, s->buffer,
-		"Trying to reconnect in %ld seconds...", s->ctx->reconnect_delay);
-	poller_timer_set (&s->reconnect_tmr, s->ctx->reconnect_delay * 1000);
-}
-
-static void
-on_irc_reconnect_timeout (void *user_data)
-{
-	struct server *s = user_data;
-
-	struct error *e = NULL;
-	bool should_retry = false;
-	if (irc_connect (s, &should_retry, &e))
-		return;
-
-	buffer_send_error (s->ctx, s->buffer, "%s", e->message);
-	error_free (e);
-
-	if (should_retry)
-		irc_queue_reconnect (s);
-}
-
-static void
-on_irc_disconnected (struct server *s)
-{
-	// Get rid of the dead socket and related things
-	if (s->ssl)
-	{
-		SSL_free (s->ssl);
-		s->ssl = NULL;
-		SSL_CTX_free (s->ssl_ctx);
-		s->ssl_ctx = NULL;
-	}
-
-	xclose (s->socket);
-	s->socket = -1;
-	s->state = IRC_DISCONNECTED;
-
-	user_unref (s->irc_user);
-	s->irc_user = NULL;
-
-	free (s->irc_user_mode);
-	s->irc_user_mode = NULL;
-	free (s->irc_user_host);
-	s->irc_user_host = NULL;
-
-	s->read_event.closed = true;
-	poller_fd_reset (&s->read_event);
-
-	// All of our timers have lost their meaning now
-	irc_cancel_timers (s);
-
-	if (s->ctx->quitting)
-		try_finish_quit (s->ctx);
-	else if (!s->ctx->reconnect)
-		// XXX: not sure if we want this in a client
-		// FIXME: no, we don't, would need to be changed for multiserver anyway
-		initiate_quit (s->ctx);
-	else
-		irc_queue_reconnect (s);
-}
-
-static void
-on_irc_ping_timeout (void *user_data)
-{
-	struct server *s = user_data;
-	buffer_send_error (s->ctx, s->buffer, "Connection timeout");
-	on_irc_disconnected (s);
-}
-
-static void
-on_irc_timeout (void *user_data)
-{
-	// Provoke a response from the server
-	struct server *s = user_data;
-	irc_send (s, "PING :%s", get_config_string (s->ctx, "server.nickname"));
-}
-
-static void
-irc_reset_connection_timeouts (struct server *s)
-{
-	irc_cancel_timers (s);
-	poller_timer_set (&s->timeout_tmr, 3 * 60 * 1000);
-	poller_timer_set (&s->ping_tmr, (3 * 60 + 30) * 1000);
-}
-
-static void
-on_irc_readable (const struct pollfd *fd, struct server *s)
-{
-	if (fd->revents & ~(POLLIN | POLLHUP | POLLERR))
-		print_debug ("fd %d: unexpected revents: %d", fd->fd, fd->revents);
-
-	(void) set_blocking (s->socket, false);
-
-	struct str *buf = &s->read_buffer;
-	enum irc_read_result (*fill_buffer)(struct server *, struct str *)
-		= s->ssl
-		? irc_fill_read_buffer_ssl
-		: irc_fill_read_buffer;
-	bool disconnected = false;
-	while (true)
-	{
-		str_ensure_space (buf, 512);
-		switch (fill_buffer (s, buf))
-		{
-		case IRC_READ_AGAIN:
-			goto end;
-		case IRC_READ_ERROR:
-			buffer_send_error (s->ctx, s->buffer,
-				"Reading from the IRC server failed");
-			disconnected = true;
-			goto end;
-		case IRC_READ_EOF:
-			buffer_send_error (s->ctx, s->buffer,
-				"The IRC server closed the connection");
-			disconnected = true;
-			goto end;
-		case IRC_READ_OK:
-			break;
-		}
-
-		if (buf->len >= (1 << 20))
-		{
-			buffer_send_error (s->ctx, s->buffer,
-				"The IRC server seems to spew out data frantically");
-			irc_shutdown (s);
-			goto end;
-		}
-	}
-end:
-	(void) set_blocking (s->socket, true);
-	irc_process_buffer (buf, irc_process_message, s);
-
-	if (disconnected)
-		on_irc_disconnected (s);
-	else
-		irc_reset_connection_timeouts (s);
-}
-
-static bool
-irc_connect (struct server *s, bool *should_retry, struct error **e)
-{
-	// TODO: connect asynchronously so that we don't freeze
-	struct app_context *ctx = s->ctx;
-	*should_retry = true;
-
-	const char *irc_host = get_config_string (ctx, "server.irc_host");
-	int64_t irc_port_int = get_config_integer (ctx, "server.irc_port");
-
-	if (!get_config_string (ctx, "server.irc_host"))
-	{
-		error_set (e, "No hostname specified in configuration");
-		*should_retry = false;
-		return false;
-	}
-
-	const char *socks_host = get_config_string (ctx, "server.socks_host");
-	int64_t socks_port_int = get_config_integer (ctx, "server.socks_port");
-	const char *socks_username =
-		get_config_string (ctx, "server.socks_username");
-	const char *socks_password =
-		get_config_string (ctx, "server.socks_password");
-
-	// FIXME: use it as a number everywhere, there's no need for named services
-	// FIXME: memory leak
-	char *irc_port   = xstrdup_printf ("%" PRIi64, irc_port_int);
-	char *socks_port = xstrdup_printf ("%" PRIi64, socks_port_int);
-
-	const char *nickname = get_config_string (ctx, "server.nickname");
-	const char *username = get_config_string (ctx, "server.username");
-	const char *realname = get_config_string (ctx, "server.realname");
-
-	// These are filled automatically if needed
-	hard_assert (nickname && username && realname);
-
-	bool use_ssl = get_config_boolean (ctx, "server.ssl");
-	if (socks_host)
-	{
-		char *address = format_host_port_pair (irc_host, irc_port);
-		char *socks_address = format_host_port_pair (socks_host, socks_port);
-		buffer_send_status (ctx, s->buffer,
-			"Connecting to %s via %s...", address, socks_address);
-		free (socks_address);
-		free (address);
-
-		struct error *error = NULL;
-		int fd = socks_connect (socks_host, socks_port, irc_host, irc_port,
-			socks_username, socks_password, &error);
-		if (fd == -1)
-		{
-			error_set (e, "%s: %s", "SOCKS connection failed", error->message);
-			error_free (error);
-			return false;
-		}
-		s->socket = fd;
-	}
-	else if (!irc_establish_connection (s, irc_host, irc_port, e))
-		return false;
-
-	if (use_ssl && !irc_initialize_ssl (s, e))
-	{
-		xclose (s->socket);
-		s->socket = -1;
-		return false;
-	}
-
-	s->state = IRC_CONNECTED;
-	buffer_send_status (ctx, s->buffer, "Connection established");
-
-	poller_fd_init (&s->read_event, &ctx->poller, s->socket);
-	s->read_event.dispatcher = (poller_fd_fn) on_irc_readable;
-	s->read_event.user_data = s;
-
-	poller_fd_set (&s->read_event, POLLIN);
-	irc_reset_connection_timeouts (s);
-
-	irc_send (s, "NICK %s", nickname);
-	// IRC servers may ignore the last argument if it's empty
-	irc_send (s, "USER %s 8 * :%s", username, *realname ? realname : " ");
-
-	// XXX: maybe we should wait for the first message from the server
-	// FIXME: the user may exist already after we've reconnected. Either
-	//   make sure that there's no reference of this nick upon disconnection,
-	//   or search in "irc_users" first... or something.
-	s->irc_user = irc_make_user (s, xstrdup (nickname));
-	s->irc_user_mode = xstrdup ("");
-	s->irc_user_host = NULL;
-	return true;
-}
-
 // --- Word completion ---------------------------------------------------------
 
 // The amount of crap that goes into this is truly insane.
@@ -5854,11 +5889,11 @@ load_configuration (struct app_context *ctx)
 		error_free (e);
 	}
 
-	ctx->reconnect =
-		get_config_boolean (ctx, "server.reconnect");
 	ctx->isolate_buffers =
 		get_config_boolean (ctx, "behaviour.isolate_buffers");
-	ctx->reconnect_delay =
+	ctx->server.reconnect =
+		get_config_boolean (ctx, "server.reconnect");
+	ctx->server.reconnect_delay =
 		get_config_integer (ctx, "server.reconnect_delay");
 }