demo-json-rpc-server -> json-rpc-test-serveracid/master

1 files changed, 0 insertions, 2925 deletions

diff --git a/demo-json-rpc-server.c b/demo-json-rpc-server.c
deleted file mode 100644
index 34cd378..0000000
--- a/demo-json-rpc-server.c
+++ /dev/null
@@ -1,2925 +0,0 @@
-/*
- * demo-json-rpc-server.c: JSON-RPC 2.0 demo server
- *
- * Copyright (c) 2015 - 2018, Přemysl Janouch <p@janouch.name>
- *
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
- * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
- * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
- * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- */
-
-#define print_fatal_data    ((void *) LOG_ERR)
-#define print_error_data    ((void *) LOG_ERR)
-#define print_warning_data  ((void *) LOG_WARNING)
-#define print_status_data   ((void *) LOG_INFO)
-#define print_debug_data    ((void *) LOG_DEBUG)
-
-#define LIBERTY_WANT_SSL
-#define LIBERTY_WANT_PROTO_HTTP
-#define LIBERTY_WANT_PROTO_WS
-#define LIBERTY_WANT_PROTO_SCGI
-#define LIBERTY_WANT_PROTO_FASTCGI
-
-#include "config.h"
-#include "liberty/liberty.c"
-
-#include <langinfo.h>
-#include <locale.h>
-#include <signal.h>
-#include <strings.h>
-
-#include <ev.h>
-#include <jansson.h>
-#include <magic.h>
-
-#include "http-parser/http_parser.h"
-
-enum { PIPE_READ, PIPE_WRITE };
-
-#define FIND_CONTAINER(name, pointer, type, member) \
-	type *name = CONTAINER_OF (pointer, type, member)
-
-// --- Utilities ---------------------------------------------------------------
-
-static bool
-flush_queue (struct write_queue *queue, int fd)
-{
-	struct iovec vec[queue->len], *vec_iter = vec;
-	LIST_FOR_EACH (struct write_req, iter, queue->head)
-		*vec_iter++ = iter->data;
-
-	ssize_t written;
-again:
-	if ((written = writev (fd, vec, N_ELEMENTS (vec))) >= 0)
-	{
-		write_queue_processed (queue, written);
-		return true;
-	}
-	if (errno == EINTR)
-		goto again;
-	if (errno == EAGAIN)
-		return true;
-
-	return false;
-}
-
-// --- Logging -----------------------------------------------------------------
-
-static void
-log_message_syslog (void *user_data, const char *quote, const char *fmt,
-	va_list ap)
-{
-	int prio = (int) (intptr_t) user_data;
-
-	va_list va;
-	va_copy (va, ap);
-	int size = vsnprintf (NULL, 0, fmt, va);
-	va_end (va);
-	if (size < 0)
-		return;
-
-	char buf[size + 1];
-	if (vsnprintf (buf, sizeof buf, fmt, ap) >= 0)
-		syslog (prio, "%s%s", quote, buf);
-}
-
-// --- FastCGI -----------------------------------------------------------------
-/// @defgroup FastCGI
-/// @{
-
-enum fcgi_request_state
-{
-	FCGI_REQUEST_PARAMS,                ///< Reading headers
-	FCGI_REQUEST_STDIN                  ///< Reading input
-};
-
-struct fcgi_request
-{
-	struct fcgi_muxer *muxer;           ///< The parent muxer
-	uint16_t request_id;                ///< The ID of this request
-	uint8_t flags;                      ///< Request flags
-
-	enum fcgi_request_state state;      ///< Parsing state
-	struct str_map headers;             ///< Headers
-	struct fcgi_nv_parser hdr_parser;   ///< Header parser
-
-	struct str output_buffer;           ///< Output buffer
-
-	void *handler_data;                 ///< Handler data
-};
-
-/// Handles a single FastCGI connection, de/multiplexing requests and responses
-struct fcgi_muxer
-{
-	struct fcgi_parser parser;          ///< FastCGI message parser
-	uint32_t active_requests;           ///< The number of active requests
-	bool in_shutdown;                   ///< Rejecting new requests
-
-	// Virtual method callbacks:
-
-	/// Write data to the underlying transport
-	void (*write_cb) (struct fcgi_muxer *, const void *data, size_t len);
-
-	/// Close the underlying transport.  You are allowed to destroy the muxer
-	/// directly from within the callback.
-	void (*close_cb) (struct fcgi_muxer *);
-
-	/// Start processing a request.  Return false if no further action is
-	/// to be done and the request should be finished.
-	bool (*request_start_cb) (struct fcgi_request *);
-
-	/// Handle incoming data.  "len == 0" means EOF.  Returns false if
-	/// the underlying transport should be closed, this being the last request.
-	bool (*request_push_cb)
-		(struct fcgi_request *, const void *data, size_t len);
-
-	/// Destroy the handler's data stored in the request object
-	void (*request_finalize_cb) (struct fcgi_request *);
-
-	/// Requests assigned to request IDs (may not be FCGI_NULL_REQUEST_ID)
-	struct fcgi_request *requests[1 << 8];
-};
-
-static void
-fcgi_muxer_send (struct fcgi_muxer *self,
-	enum fcgi_type type, uint16_t request_id, const void *data, size_t len)
-{
-	hard_assert (len <= UINT16_MAX);
-
-	struct str message = str_make ();
-	static char zeroes[8];
-	size_t padding = -len & 7;
-
-	str_pack_u8  (&message, FCGI_VERSION_1);
-	str_pack_u8  (&message, type);
-	str_pack_u16 (&message, request_id);
-	str_pack_u16 (&message, len);     // content length
-	str_pack_u8  (&message, padding); // padding length
-	str_pack_u8  (&message, 0);       // reserved
-
-	str_append_data (&message, data, len);
-	str_append_data (&message, zeroes, padding);
-
-	// XXX: we should probably have another write_cb that assumes ownership
-	self->write_cb (self, message.str, message.len);
-	str_free (&message);
-}
-
-static void
-fcgi_muxer_send_end_request (struct fcgi_muxer *self, uint16_t request_id,
-	uint32_t app_status, enum fcgi_protocol_status protocol_status)
-{
-	uint8_t content[8] = { app_status >> 24, app_status >> 16,
-		app_status << 8, app_status, protocol_status };
-	fcgi_muxer_send (self, FCGI_END_REQUEST, request_id,
-		content, sizeof content);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static struct fcgi_request *
-fcgi_request_new (void)
-{
-	struct fcgi_request *self = xcalloc (1, sizeof *self);
-
-	self->headers = str_map_make (free);
-
-	self->hdr_parser = fcgi_nv_parser_make ();
-	self->hdr_parser.output = &self->headers;
-
-	self->output_buffer = str_make ();
-	return self;
-}
-
-static void
-fcgi_request_destroy (struct fcgi_request *self)
-{
-	// TODO: consider the case where it hasn't been started yet
-	self->muxer->request_finalize_cb (self);
-
-	str_map_free (&self->headers);
-	fcgi_nv_parser_free (&self->hdr_parser);
-	free (self);
-}
-
-static void
-fcgi_request_flush (struct fcgi_request *self)
-{
-	if (!self->output_buffer.len)
-		return;
-
-	fcgi_muxer_send (self->muxer, FCGI_STDOUT, self->request_id,
-		self->output_buffer.str, self->output_buffer.len);
-	str_reset (&self->output_buffer);
-}
-
-static void
-fcgi_request_write (struct fcgi_request *self, const void *data, size_t len)
-{
-	// We're buffering the output and splitting it into messages
-	bool need_flush = true;
-	while (len)
-	{
-		size_t to_write = UINT16_MAX - self->output_buffer.len;
-		if (to_write > len)
-		{
-			to_write = len;
-			need_flush = false;
-		}
-
-		str_append_data (&self->output_buffer, data, to_write);
-		data = (uint8_t *) data + to_write;
-		len -= to_write;
-
-		if (need_flush)
-			fcgi_request_flush (self);
-	}
-}
-
-/// Mark the request as done.  Returns false if the underlying transport
-/// should be closed, this being the last request.
-static bool
-fcgi_request_finish (struct fcgi_request *self)
-{
-	fcgi_request_flush (self);
-	fcgi_muxer_send (self->muxer, FCGI_STDOUT, self->request_id, NULL, 0);
-
-	fcgi_muxer_send_end_request (self->muxer, self->request_id,
-		0 /* TODO app_status, although ignored */,
-		FCGI_REQUEST_COMPLETE /* TODO protocol_status, may be different */);
-
-	bool should_close = !(self->flags & FCGI_KEEP_CONN);
-
-	self->muxer->active_requests--;
-	self->muxer->requests[self->request_id] = NULL;
-	fcgi_request_destroy (self);
-
-	return !should_close;
-}
-
-static bool
-fcgi_request_push_params
-	(struct fcgi_request *self, const void *data, size_t len)
-{
-	if (self->state != FCGI_REQUEST_PARAMS)
-	{
-		print_debug ("FastCGI: expected %s, got %s",
-			STRINGIFY (FCGI_STDIN), STRINGIFY (FCGI_PARAMS));
-		return false;
-	}
-
-	if (len)
-		fcgi_nv_parser_push (&self->hdr_parser, data, len);
-	else
-	{
-		if (self->hdr_parser.state != FCGI_NV_PARSER_NAME_LEN)
-			print_debug ("FastCGI: request headers seem to be cut off");
-
-		self->state = FCGI_REQUEST_STDIN;
-		if (!self->muxer->request_start_cb (self))
-			return fcgi_request_finish (self);
-	}
-	return true;
-}
-
-static bool
-fcgi_request_push_stdin
-	(struct fcgi_request *self, const void *data, size_t len)
-{
-	if (self->state != FCGI_REQUEST_STDIN)
-	{
-		print_debug ("FastCGI: expected %s, got %s",
-			STRINGIFY (FCGI_PARAMS), STRINGIFY (FCGI_STDIN));
-		return false;
-	}
-
-	return self->muxer->request_push_cb (self, data, len);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-typedef bool (*fcgi_muxer_handler_fn)
-	(struct fcgi_muxer *, const struct fcgi_parser *);
-
-static bool
-fcgi_muxer_on_get_values
-	(struct fcgi_muxer *self, const struct fcgi_parser *parser)
-{
-	if (parser->request_id != FCGI_NULL_REQUEST_ID)
-	{
-		print_debug ("FastCGI: invalid %s message",
-			STRINGIFY (FCGI_GET_VALUES));
-		return false;
-	}
-
-	struct str_map values   = str_map_make (free);
-	struct str_map response = str_map_make (free);
-
-	struct fcgi_nv_parser nv_parser = fcgi_nv_parser_make ();
-	nv_parser.output = &values;
-
-	fcgi_nv_parser_push (&nv_parser, parser->content.str, parser->content.len);
-	const char *key = NULL;
-
-	// No real-world servers seem to actually use multiplexing
-	// or even issue this request, but we will implement it anyway
-	if (str_map_find (&values, (key = FCGI_MPXS_CONNS)))
-		str_map_set (&response, key, xstrdup ("1"));
-
-	// It's not clear whether FCGI_MAX_REQS means concurrently over all
-	// connections or over just a single connection (multiplexed), though
-	// supposedly it's actually per /web server/.  Supply the strictest limit.
-	if (str_map_find (&values, (key = FCGI_MAX_REQS)))
-		str_map_set (&response, key,
-			xstrdup_printf ("%zu", N_ELEMENTS (self->requests) - 1));
-
-	// FCGI_MAX_CONNS would be basically infinity.  We don't limit connections.
-
-	struct str content = str_make ();
-	fcgi_nv_convert (&response, &content);
-	fcgi_muxer_send (self, FCGI_GET_VALUES_RESULT, parser->request_id,
-		content.str, content.len);
-	str_free (&content);
-
-	str_map_free (&values);
-	str_map_free (&response);
-	return true;
-}
-
-static bool
-fcgi_muxer_on_begin_request
-	(struct fcgi_muxer *self, const struct fcgi_parser *parser)
-{
-	struct msg_unpacker unpacker =
-		msg_unpacker_make (parser->content.str, parser->content.len);
-
-	uint16_t role;
-	uint8_t flags;
-	bool success = true;
-	success &= msg_unpacker_u16 (&unpacker, &role);
-	success &= msg_unpacker_u8 (&unpacker, &flags);
-	// Ignoring 5 reserved bytes
-
-	if (!success)
-	{
-		print_debug ("FastCGI: invalid %s message",
-			STRINGIFY (FCGI_BEGIN_REQUEST));
-		return false;
-	}
-
-	struct fcgi_request *request = self->requests[parser->request_id];
-	if (parser->request_id == FCGI_NULL_REQUEST_ID || request)
-	{
-		print_debug ("FastCGI: unusable request ID in %s message",
-			STRINGIFY (FCGI_BEGIN_REQUEST));
-		return false;
-	}
-
-	// We can only act as a responder, reject everything else up front
-	if (role != FCGI_RESPONDER)
-	{
-		fcgi_muxer_send_end_request (self,
-			parser->request_id, 0, FCGI_UNKNOWN_ROLE);
-		return true;
-	}
-
-	if (parser->request_id >= N_ELEMENTS (self->requests)
-	 || self->in_shutdown)
-	{
-		fcgi_muxer_send_end_request (self,
-			parser->request_id, 0, FCGI_OVERLOADED);
-		return true;
-	}
-
-	request = fcgi_request_new ();
-	request->muxer = self;
-	request->request_id = parser->request_id;
-	request->flags = flags;
-
-	self->requests[parser->request_id] = request;
-	self->active_requests++;
-	return true;
-}
-
-static bool
-fcgi_muxer_on_abort_request
-	(struct fcgi_muxer *self, const struct fcgi_parser *parser)
-{
-	struct fcgi_request *request = self->requests[parser->request_id];
-	if (parser->request_id == FCGI_NULL_REQUEST_ID || !request)
-	{
-		print_debug ("FastCGI: received %s for an unknown request",
-			STRINGIFY (FCGI_ABORT_REQUEST));
-		return true;  // We might have just rejected it
-	}
-
-	return fcgi_request_finish (request);
-}
-
-static bool
-fcgi_muxer_on_params (struct fcgi_muxer *self, const struct fcgi_parser *parser)
-{
-	struct fcgi_request *request = self->requests[parser->request_id];
-	if (parser->request_id == FCGI_NULL_REQUEST_ID || !request)
-	{
-		print_debug ("FastCGI: received %s for an unknown request",
-			STRINGIFY (FCGI_PARAMS));
-		return true;  // We might have just rejected it
-	}
-
-	// This may immediately finish and delete the request, but that's fine
-	return fcgi_request_push_params (request,
-		parser->content.str, parser->content.len);
-}
-
-static bool
-fcgi_muxer_on_stdin (struct fcgi_muxer *self, const struct fcgi_parser *parser)
-{
-	struct fcgi_request *request = self->requests[parser->request_id];
-	if (parser->request_id == FCGI_NULL_REQUEST_ID || !request)
-	{
-		print_debug ("FastCGI: received %s for an unknown request",
-			STRINGIFY (FCGI_STDIN));
-		return true;  // We might have just rejected it
-	}
-
-	// At the end of the stream, a zero-length record is received
-	return fcgi_request_push_stdin (request,
-		parser->content.str, parser->content.len);
-}
-
-static bool
-fcgi_muxer_on_message (const struct fcgi_parser *parser, void *user_data)
-{
-	struct fcgi_muxer *self = user_data;
-
-	if (parser->version != FCGI_VERSION_1)
-	{
-		print_debug ("FastCGI: unsupported version %d", parser->version);
-		return false;
-	}
-
-	static const fcgi_muxer_handler_fn handlers[] =
-	{
-		[FCGI_GET_VALUES]    = fcgi_muxer_on_get_values,
-		[FCGI_BEGIN_REQUEST] = fcgi_muxer_on_begin_request,
-		[FCGI_ABORT_REQUEST] = fcgi_muxer_on_abort_request,
-		[FCGI_PARAMS]        = fcgi_muxer_on_params,
-		[FCGI_STDIN]         = fcgi_muxer_on_stdin,
-	};
-
-	fcgi_muxer_handler_fn handler;
-	if (parser->type >= N_ELEMENTS (handlers)
-	 || !(handler = handlers[parser->type]))
-	{
-		// Responding in this way even to application records, unspecified
-		uint8_t content[8] = { parser->type };
-		fcgi_muxer_send (self, FCGI_UNKNOWN_TYPE, parser->request_id,
-			content, sizeof content);
-		return true;
-	}
-
-	return handler (self, parser);
-}
-
-static void
-fcgi_muxer_init (struct fcgi_muxer *self)
-{
-	self->parser = fcgi_parser_make ();
-	self->parser.on_message = fcgi_muxer_on_message;
-	self->parser.user_data = self;
-}
-
-static void
-fcgi_muxer_free (struct fcgi_muxer *self)
-{
-	for (size_t i = 0; i < N_ELEMENTS (self->requests); i++)
-	{
-		if (!self->active_requests)
-			break;
-		if (self->requests[i])
-		{
-			fcgi_request_destroy (self->requests[i]);
-			self->active_requests--;
-		}
-	}
-
-	fcgi_parser_free (&self->parser);
-}
-
-static bool
-fcgi_muxer_push (struct fcgi_muxer *self, const void *data, size_t len)
-{
-	return fcgi_parser_push (&self->parser, data, len);
-}
-
-/// @}
-// --- WebSockets --------------------------------------------------------------
-/// @defgroup WebSockets
-/// @{
-
-// WebSockets aren't CGI-compatible, therefore we must handle the initial HTTP
-// handshake ourselves.  Luckily it's not too much of a bother with http-parser.
-// Typically there will be a normal HTTP server in front of us, proxying the
-// requests based on the URI.
-
-enum ws_handler_state
-{
-	WS_HANDLER_CONNECTING,              ///< Parsing HTTP
-	WS_HANDLER_OPEN,                    ///< Parsing WebSockets frames
-	WS_HANDLER_CLOSING,                 ///< Partial closure by us
-	WS_HANDLER_FLUSHING,                ///< Just waiting for client EOF
-	WS_HANDLER_CLOSED                   ///< Dead, both sides closed
-};
-
-struct ws_handler
-{
-	enum ws_handler_state state;        ///< State
-
-	// HTTP handshake:
-
-	http_parser hp;                     ///< HTTP parser
-	bool have_header_value;             ///< Parsing header value or field?
-	struct str field;                   ///< Field part buffer
-	struct str value;                   ///< Value part buffer
-	struct str_map headers;             ///< HTTP Headers
-	struct str url;                     ///< Request URL
-	ev_timer handshake_timeout_watcher; ///< Handshake timeout watcher
-
-	// WebSocket frame protocol:
-
-	struct ws_parser parser;            ///< Protocol frame parser
-	bool expecting_continuation;        ///< For non-control traffic
-
-	enum ws_opcode message_opcode;      ///< Opcode for the current message
-	struct str message_data;            ///< Concatenated message data
-
-	ev_timer ping_timer;                ///< Ping timer
-	bool received_pong;                 ///< Received PONG since the last PING
-
-	ev_timer close_timeout_watcher;     ///< Close timeout watcher
-
-	// Configuration:
-
-	unsigned handshake_timeout;         ///< How long to wait for the handshake
-	unsigned close_timeout;             ///< How long to wait for TCP close
-	unsigned ping_interval;             ///< Ping interval in seconds
-	uint64_t max_payload_len;           ///< Maximum length of any message
-
-	// Event callbacks:
-
-	// TODO: void (*on_handshake) (protocols) that will allow the user
-	//   to choose any sub-protocol, if the client has provided any.
-	//   This may render "on_connected" unnecessary.
-	//   Should also enable failing the handshake.
-
-	/// Called after successfuly connecting (handshake complete)
-	bool (*on_connected) (struct ws_handler *);
-
-	/// Called upon reception of a single full message
-	bool (*on_message) (struct ws_handler *,
-		enum ws_opcode type, const void *data, size_t len);
-
-	/// The connection is about to close.  @a close_code may, or may not, be one
-	/// of enum ws_status.  The @a reason is never NULL.
-	void (*on_close) (struct ws_handler *, int close_code, const char *reason);
-
-	// Virtual method callbacks:
-
-	/// Write a chunk of data to the stream
-	void (*write_cb) (struct ws_handler *, const void *data, size_t len);
-
-	/// Close the connection.  If @a half_close is false, you are allowed to
-	/// destroy the handler directly from within the callback.
-	void (*close_cb) (struct ws_handler *, bool half_close);
-};
-
-static void
-ws_handler_send_control (struct ws_handler *self,
-	enum ws_opcode opcode, const void *data, size_t len)
-{
-	if (len > WS_MAX_CONTROL_PAYLOAD_LEN)
-	{
-		print_debug ("truncating output control frame payload"
-			" from %zu to %zu bytes", len, (size_t) WS_MAX_CONTROL_PAYLOAD_LEN);
-		len = WS_MAX_CONTROL_PAYLOAD_LEN;
-	}
-
-	uint8_t header[2] = { 0x80 | (opcode & 0x0F), len };
-	self->write_cb (self, header, sizeof header);
-	self->write_cb (self, data, len);
-}
-
-static void
-ws_handler_close (struct ws_handler *self,
-	enum ws_status close_code, const char *reason, size_t len)
-{
-	hard_assert (self->state == WS_HANDLER_OPEN);
-
-	struct str payload = str_make ();
-	str_pack_u16 (&payload, close_code);
-	// XXX: maybe accept a null-terminated string on input? Has to be UTF-8 a/w
-	str_append_data (&payload, reason, len);
-	ws_handler_send_control (self, WS_OPCODE_CLOSE, payload.str, payload.len);
-	self->close_cb (self, true /* half_close */);
-
-	self->state = WS_HANDLER_CLOSING;
-	str_free (&payload);
-}
-
-static bool
-ws_handler_fail_connection (struct ws_handler *self, enum ws_status close_code)
-{
-	hard_assert (self->state == WS_HANDLER_OPEN
-		|| self->state == WS_HANDLER_CLOSING);
-
-	if (self->state == WS_HANDLER_OPEN)
-		ws_handler_close (self, close_code, NULL, 0);
-
-	self->state = WS_HANDLER_FLUSHING;
-	if (self->on_close)
-		self->on_close (self, WS_STATUS_ABNORMAL_CLOSURE, "");
-
-	ev_timer_stop (EV_DEFAULT_ &self->ping_timer);
-	ev_timer_set (&self->close_timeout_watcher, self->close_timeout, 0.);
-	ev_timer_start (EV_DEFAULT_ &self->close_timeout_watcher);
-	return false;
-}
-
-// TODO: add support for fragmented responses
-static void
-ws_handler_send_frame (struct ws_handler *self,
-	enum ws_opcode opcode, const void *data, size_t len)
-{
-	if (!soft_assert (self->state == WS_HANDLER_OPEN))
-		return;
-
-	struct str header = str_make ();
-	str_pack_u8 (&header, 0x80 | (opcode & 0x0F));
-
-	if (len > UINT16_MAX)
-	{
-		str_pack_u8 (&header, 127);
-		str_pack_u64 (&header, len);
-	}
-	else if (len > 125)
-	{
-		str_pack_u8 (&header, 126);
-		str_pack_u16 (&header, len);
-	}
-	else
-		str_pack_u8 (&header, len);
-
-	self->write_cb (self, header.str, header.len);
-	self->write_cb (self, data, len);
-	str_free (&header);
-}
-
-static bool
-ws_handler_on_frame_header (void *user_data, const struct ws_parser *parser)
-{
-	struct ws_handler *self = user_data;
-
-	// Note that we aren't expected to send any close frame before closing the
-	// connection when the frame is unmasked
-
-	if (parser->reserved_1 || parser->reserved_2 || parser->reserved_3
-	 || !parser->is_masked  // client -> server payload must be masked
-	 || (ws_is_control_frame (parser->opcode) &&
-		(!parser->is_fin || parser->payload_len > WS_MAX_CONTROL_PAYLOAD_LEN))
-	 || (!ws_is_control_frame (parser->opcode) &&
-		(self->expecting_continuation && parser->opcode != WS_OPCODE_CONT))
-	 || parser->payload_len >= 0x8000000000000000ULL)
-		return ws_handler_fail_connection (self, WS_STATUS_PROTOCOL_ERROR);
-
-	if (parser->payload_len > self->max_payload_len
-	 || (self->expecting_continuation &&
-		self->message_data.len + parser->payload_len > self->max_payload_len))
-		return ws_handler_fail_connection (self, WS_STATUS_MESSAGE_TOO_BIG);
-	return true;
-}
-
-static bool
-ws_handler_on_control_close
-	(struct ws_handler *self, const struct ws_parser *parser)
-{
-	hard_assert (self->state == WS_HANDLER_OPEN
-		|| self->state == WS_HANDLER_CLOSING);
-	struct msg_unpacker unpacker =
-		msg_unpacker_make (parser->input.str, parser->payload_len);
-
-	char *reason = NULL;
-	uint16_t close_code = WS_STATUS_NO_STATUS_RECEIVED;
-	if (parser->payload_len >= 2)
-	{
-		(void) msg_unpacker_u16 (&unpacker, &close_code);
-		reason = xstrndup (parser->input.str + 2, parser->payload_len - 2);
-	}
-	else
-		reason = xstrdup ("");
-
-	if (close_code < 1000 || close_code > 4999)
-		// XXX: invalid close code: maybe we should fail the connection instead
-		close_code = WS_STATUS_PROTOCOL_ERROR;
-
-	if (self->state == WS_HANDLER_OPEN)
-	{
-		// Close initiated by the client
-		// FIXME: not sending the potentially different close_code
-		ws_handler_send_control (self, WS_OPCODE_CLOSE,
-			parser->input.str, parser->payload_len);
-
-		self->state = WS_HANDLER_FLUSHING;
-		if (self->on_close)
-			self->on_close (self, close_code, reason);
-	}
-	else
-		self->state = WS_HANDLER_FLUSHING;
-
-	free (reason);
-
-	ev_timer_stop (EV_DEFAULT_ &self->ping_timer);
-	ev_timer_set (&self->close_timeout_watcher, self->close_timeout, 0.);
-	ev_timer_start (EV_DEFAULT_ &self->close_timeout_watcher);
-	return true;
-}
-
-static bool
-ws_handler_on_control_frame
-	(struct ws_handler *self, const struct ws_parser *parser)
-{
-	switch (parser->opcode)
-	{
-	case WS_OPCODE_CLOSE:
-		return ws_handler_on_control_close (self, parser);
-	case WS_OPCODE_PING:
-		ws_handler_send_control (self, WS_OPCODE_PONG,
-			parser->input.str, parser->payload_len);
-		break;
-	case WS_OPCODE_PONG:
-		// TODO: check the payload
-		self->received_pong = true;
-		break;
-	default:
-		// Unknown control frame
-		return ws_handler_fail_connection (self, WS_STATUS_PROTOCOL_ERROR);
-	}
-	return true;
-}
-
-static bool
-ws_handler_on_frame (void *user_data, const struct ws_parser *parser)
-{
-	struct ws_handler *self = user_data;
-	if (ws_is_control_frame (parser->opcode))
-		return ws_handler_on_control_frame (self, parser);
-	if (!self->expecting_continuation)
-		self->message_opcode = parser->opcode;
-
-	str_append_data (&self->message_data,
-		parser->input.str, parser->payload_len);
-	if ((self->expecting_continuation = !parser->is_fin))
-		return true;
-
-	if (self->message_opcode == WS_OPCODE_TEXT
-	 && !utf8_validate (self->message_data.str, self->message_data.len))
-	{
-		return ws_handler_fail_connection
-			(self, WS_STATUS_INVALID_PAYLOAD_DATA);
-	}
-
-	bool result = true;
-	if (self->on_message)
-		result = self->on_message (self, self->message_opcode,
-			self->message_data.str, self->message_data.len);
-	str_reset (&self->message_data);
-	// TODO: if (!result), either replace this with a state check,
-	//   or make sure to change the state
-	return result;
-}
-
-static void
-ws_handler_on_ping_timer (EV_P_ ev_timer *watcher, int revents)
-{
-	(void) loop;
-	(void) revents;
-
-	struct ws_handler *self = watcher->data;
-	if (!self->received_pong)
-		ws_handler_fail_connection (self, 4000);
-	else
-	{
-		// TODO: be an annoying server and send a nonce in the data
-		ws_handler_send_control (self, WS_OPCODE_PING, NULL, 0);
-		ev_timer_again (EV_A_ watcher);
-	}
-}
-
-static void
-ws_handler_on_close_timeout (EV_P_ ev_timer *watcher, int revents)
-{
-	(void) loop;
-	(void) revents;
-	struct ws_handler *self = watcher->data;
-
-	hard_assert (self->state == WS_HANDLER_OPEN
-		|| self->state == WS_HANDLER_CLOSING);
-
-	if (self->state == WS_HANDLER_CLOSING
-	 && self->on_close)
-		self->on_close (self, WS_STATUS_ABNORMAL_CLOSURE, "close timeout");
-
-	self->state = WS_HANDLER_CLOSED;
-	self->close_cb (self, false /* half_close */);
-}
-
-static void
-ws_handler_on_handshake_timeout (EV_P_ ev_timer *watcher, int revents)
-{
-	(void) loop;
-	(void) revents;
-	struct ws_handler *self = watcher->data;
-
-	// XXX: this is a no-op, since this currently doesn't even call shutdown
-	//   immediately but postpones it until later
-	self->close_cb (self, true /* half_close */);
-	self->state = WS_HANDLER_FLUSHING;
-
-	if (self->on_close)
-		self->on_close (self, WS_STATUS_ABNORMAL_CLOSURE, "handshake timeout");
-
-	self->state = WS_HANDLER_CLOSED;
-	self->close_cb (self, false /* half_close */);
-}
-
-static void
-ws_handler_init (struct ws_handler *self)
-{
-	memset (self, 0, sizeof *self);
-
-	self->state = WS_HANDLER_CONNECTING;
-
-	http_parser_init (&self->hp, HTTP_REQUEST);
-	self->hp.data = self;
-	self->field = str_make ();
-	self->value = str_make ();
-	self->headers = str_map_make (free);
-	self->headers.key_xfrm = tolower_ascii_strxfrm;
-	self->url = str_make ();
-	ev_timer_init (&self->handshake_timeout_watcher,
-		ws_handler_on_handshake_timeout, 0., 0.);
-	self->handshake_timeout_watcher.data = self;
-
-	self->parser = ws_parser_make ();
-	self->parser.on_frame_header = ws_handler_on_frame_header;
-	self->parser.on_frame = ws_handler_on_frame;
-	self->parser.user_data = self;
-	self->message_data = str_make ();
-
-	ev_timer_init (&self->ping_timer,
-		ws_handler_on_ping_timer, 0., 0.);
-	self->ping_timer.data = self;
-	ev_timer_init (&self->close_timeout_watcher,
-		ws_handler_on_close_timeout, 0., 0.);
-	self->ping_timer.data = self;
-	// So that the first ping timer doesn't timeout the connection
-	self->received_pong = true;
-
-	self->handshake_timeout = self->close_timeout = self->ping_interval = 60;
-	// This is still ridiculously high.  Note that the most significant bit
-	// must always be zero, i.e. the protocol maximum is 0x7FFF FFFF FFFF FFFF.
-	self->max_payload_len = UINT32_MAX;
-}
-
-/// Stop all timers, not going to use the handler anymore
-static void
-ws_handler_stop (struct ws_handler *self)
-{
-	ev_timer_stop (EV_DEFAULT_ &self->handshake_timeout_watcher);
-	ev_timer_stop (EV_DEFAULT_ &self->ping_timer);
-	ev_timer_stop (EV_DEFAULT_ &self->close_timeout_watcher);
-}
-
-static void
-ws_handler_free (struct ws_handler *self)
-{
-	ws_handler_stop (self);
-
-	str_free (&self->field);
-	str_free (&self->value);
-	str_map_free (&self->headers);
-	str_free (&self->url);
-
-	ws_parser_free (&self->parser);
-	str_free (&self->message_data);
-}
-
-static bool
-ws_handler_header_field_is_a_list (const char *name)
-{
-	// This must contain all header fields we use for anything
-	static const char *concatenable[] =
-		{ SEC_WS_PROTOCOL, SEC_WS_EXTENSIONS, "Connection", "Upgrade" };
-
-	for (size_t i = 0; i < N_ELEMENTS (concatenable); i++)
-		if (!strcasecmp_ascii (name, concatenable[i]))
-			return true;
-	return false;
-}
-
-static void
-ws_handler_on_header_read (struct ws_handler *self)
-{
-	// The HTTP parser unfolds values and removes preceding whitespace, but
-	// otherwise doesn't touch the values or the following whitespace.
-
-	// RFC 7230 states that trailing whitespace is not part of a field value
-	char *value = self->field.str;
-	size_t len = self->field.len;
-	while (len--)
-		if (value[len] == '\t' || value[len] == ' ')
-			value[len] = '\0';
-		else
-			break;
-	self->field.len = len;
-
-	const char *field = self->field.str;
-	const char *current = str_map_find (&self->headers, field);
-	if (ws_handler_header_field_is_a_list (field) && current)
-		str_map_set (&self->headers, field,
-			xstrdup_printf ("%s, %s", current, self->value.str));
-	else
-		// If the field cannot be concatenated, just overwrite the last value.
-		// Maybe we should issue a warning or something.
-		str_map_set (&self->headers, field, xstrdup (self->value.str));
-}
-
-static int
-ws_handler_on_header_field (http_parser *parser, const char *at, size_t len)
-{
-	struct ws_handler *self = parser->data;
-	if (self->have_header_value)
-	{
-		ws_handler_on_header_read (self);
-		str_reset (&self->field);
-		str_reset (&self->value);
-	}
-	str_append_data (&self->field, at, len);
-	self->have_header_value = false;
-	return 0;
-}
-
-static int
-ws_handler_on_header_value (http_parser *parser, const char *at, size_t len)
-{
-	struct ws_handler *self = parser->data;
-	str_append_data (&self->value, at, len);
-	self->have_header_value = true;
-	return 0;
-}
-
-static int
-ws_handler_on_headers_complete (http_parser *parser)
-{
-	struct ws_handler *self = parser->data;
-	if (self->have_header_value)
-		ws_handler_on_header_read (self);
-
-	// We strictly require a protocol upgrade
-	if (!parser->upgrade)
-		return 2;
-
-	return 0;
-}
-
-static int
-ws_handler_on_url (http_parser *parser, const char *at, size_t len)
-{
-	struct ws_handler *self = parser->data;
-	str_append_data (&self->value, at, len);
-	return 0;
-}
-
-#define HTTP_101_SWITCHING_PROTOCOLS    "101 Switching Protocols"
-#define HTTP_400_BAD_REQUEST            "400 Bad Request"
-#define HTTP_405_METHOD_NOT_ALLOWED     "405 Method Not Allowed"
-#define HTTP_417_EXPECTATION_FAILED     "407 Expectation Failed"
-#define HTTP_426_UPGRADE_REQUIRED       "426 Upgrade Required"
-#define HTTP_505_VERSION_NOT_SUPPORTED  "505 HTTP Version Not Supported"
-
-static void
-ws_handler_http_responsev (struct ws_handler *self,
-	const char *status, char *const *fields)
-{
-	hard_assert (status != NULL);
-
-	struct str response = str_make ();
-	str_append_printf (&response, "HTTP/1.1 %s\r\n", status);
-
-	while (*fields)
-		str_append_printf (&response, "%s\r\n", *fields++);
-
-	time_t now = time (NULL);
-	struct tm ts;
-	gmtime_r (&now, &ts);
-
-	// See RFC 7231, 7.1.1.2. Date
-	const char *dow[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-	const char *moy[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-	str_append_printf (&response,
-		"Date: %s, %02d %s %04d %02d:%02d:%02d GMT\r\n",
-		dow[ts.tm_wday], ts.tm_mday, moy[ts.tm_mon], ts.tm_year + 1900,
-		ts.tm_hour, ts.tm_min, ts.tm_sec);
-
-	str_append (&response, "Server: "
-		PROGRAM_NAME "/" PROGRAM_VERSION "\r\n\r\n");
-	self->write_cb (self, response.str, response.len);
-	str_free (&response);
-}
-
-static bool
-ws_handler_fail_handshake (struct ws_handler *self, const char *status, ...)
-{
-	va_list ap;
-	va_start (ap, status);
-
-	const char *s;
-	struct strv v = strv_make ();
-	while ((s = va_arg (ap, const char *)))
-		strv_append (&v, s);
-
-	va_end (ap);
-	ws_handler_http_responsev (self, status, v.vector);
-	strv_free (&v);
-
-	self->close_cb (self, true /* half_close */);
-	self->state = WS_HANDLER_FLUSHING;
-
-	if (self->on_close)
-		self->on_close (self, WS_STATUS_ABNORMAL_CLOSURE, status);
-	return false;
-}
-
-#define FAIL_HANDSHAKE(...) \
-	return ws_handler_fail_handshake (self, __VA_ARGS__, NULL)
-
-static bool
-ws_handler_finish_handshake (struct ws_handler *self)
-{
-	if (self->hp.method != HTTP_GET)
-		FAIL_HANDSHAKE (HTTP_405_METHOD_NOT_ALLOWED, "Allow: GET");
-
-	// Technically, it must be /at least/ 1.1 but no other 1.x version of HTTP
-	// is going to happen and 2.x is entirely incompatible
-	// XXX: we probably shouldn't use 505 to reject the minor version but w/e
-	if (self->hp.http_major != 1 || self->hp.http_minor != 1)
-		FAIL_HANDSHAKE (HTTP_505_VERSION_NOT_SUPPORTED);
-
-	// Your expectations are way too high
-	if (str_map_find (&self->headers, "Expect"))
-		FAIL_HANDSHAKE (HTTP_417_EXPECTATION_FAILED);
-
-	// Reject URLs specifying the schema and host; we're not parsing that
-	// TODO: actually do parse this and let our user decide if it matches
-	struct http_parser_url url;
-	if (http_parser_parse_url (self->url.str, self->url.len, false, &url)
-	 || (url.field_set & (1 << UF_SCHEMA | 1 << UF_HOST | 1 << UF_PORT))
-	 || !str_map_find (&self->headers, "Host"))
-		FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST);
-
-	const char *connection = str_map_find (&self->headers, "Connection");
-	if (!connection || strcasecmp_ascii (connection, "Upgrade"))
-		FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST);
-
-	// Check if we can actually upgrade the protocol to WebSockets
-	const char *upgrade = str_map_find (&self->headers, "Upgrade");
-	struct http_protocol *offered_upgrades = NULL;
-	bool can_upgrade = false;
-	if (upgrade && http_parse_upgrade (upgrade, &offered_upgrades))
-		// Case-insensitive according to RFC 6455; neither RFC 2616 nor 7230
-		// say anything at all about case-sensitivity for this field
-		LIST_FOR_EACH (struct http_protocol, iter, offered_upgrades)
-		{
-			if (!iter->version && !strcasecmp_ascii (iter->name, "websocket"))
-				can_upgrade = true;
-			http_protocol_destroy (iter);
-		}
-	if (!can_upgrade)
-		FAIL_HANDSHAKE (HTTP_426_UPGRADE_REQUIRED,
-			"Upgrade: websocket", SEC_WS_VERSION ": 13");
-
-	// Okay, we're finally past the basic HTTP/1.1 stuff
-	const char *key        = str_map_find (&self->headers, SEC_WS_KEY);
-	const char *version    = str_map_find (&self->headers, SEC_WS_VERSION);
-/*
-	const char *protocol   = str_map_find (&self->headers, SEC_WS_PROTOCOL);
-	const char *extensions = str_map_find (&self->headers, SEC_WS_EXTENSIONS);
-*/
-
-	if (!version)
-		FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST);
-	if (strcmp (version, "13"))
-		FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST, SEC_WS_VERSION ": 13");
-
-	struct str tmp = str_make ();
-	bool key_is_valid = key
-		&& base64_decode (key, false, &tmp) && tmp.len == 16;
-	str_free (&tmp);
-	if (!key_is_valid)
-		FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST);
-
-	struct strv fields = strv_make ();
-	strv_append_args (&fields,
-		"Upgrade: websocket",
-		"Connection: Upgrade",
-		NULL);
-
-	char *response_key = ws_encode_response_key (key);
-	strv_append_owned (&fields,
-		xstrdup_printf (SEC_WS_ACCEPT ": %s", response_key));
-	free (response_key);
-
-	// TODO: make it possible to choose Sec-Websocket-{Extensions,Protocol}
-
-	ws_handler_http_responsev (self,
-		HTTP_101_SWITCHING_PROTOCOLS, fields.vector);
-
-	strv_free (&fields);
-
-	self->state = WS_HANDLER_OPEN;
-	ev_timer_init (&self->ping_timer, ws_handler_on_ping_timer,
-		self->ping_interval, 0);
-	ev_timer_start (EV_DEFAULT_ &self->ping_timer);
-	return true;
-}
-
-/// Tells the handler that the TCP connection has been established so it can
-/// timeout when the client handshake doesn't arrive soon enough
-static void
-ws_handler_start (struct ws_handler *self)
-{
-	hard_assert (self->state == WS_HANDLER_CONNECTING);
-
-	ev_timer_set (&self->handshake_timeout_watcher,
-		self->handshake_timeout, 0.);
-	ev_timer_start (EV_DEFAULT_ &self->handshake_timeout_watcher);
-}
-
-// The client should normally never close the connection, assume that it's
-// either received an EOF from our side, or that it doesn't care about our data
-// anymore, having called close() already
-static bool
-ws_handler_push_eof (struct ws_handler *self)
-{
-	switch (self->state)
-	{
-	case WS_HANDLER_CONNECTING:
-		ev_timer_stop (EV_DEFAULT_ &self->handshake_timeout_watcher);
-
-		self->state = WS_HANDLER_FLUSHING;
-		if (self->on_close)
-			self->on_close (self, WS_STATUS_ABNORMAL_CLOSURE, "unexpected EOF");
-		break;
-	case WS_HANDLER_OPEN:
-		ev_timer_stop (EV_DEFAULT_ &self->ping_timer);
-		// Fall-through
-	case WS_HANDLER_CLOSING:
-		self->state = WS_HANDLER_CLOSED;
-		if (self->on_close)
-			self->on_close (self, WS_STATUS_ABNORMAL_CLOSURE, "");
-		// Fall-through
-	case WS_HANDLER_FLUSHING:
-		ev_timer_stop (EV_DEFAULT_ &self->close_timeout_watcher);
-		break;
-	default:
-		soft_assert(self->state != WS_HANDLER_CLOSED);
-	}
-	self->state = WS_HANDLER_CLOSED;
-	return false;
-}
-
-/// Push data to the WebSocket handler.  "len == 0" means EOF.
-/// You are expected to close the connection and dispose of the handler
-/// when the function returns false.
-static bool
-ws_handler_push (struct ws_handler *self, const void *data, size_t len)
-{
-	if (!len)
-		return ws_handler_push_eof (self);
-
-	if (self->state == WS_HANDLER_FLUSHING)
-		// We're waiting for an EOF from the client, must not process data
-		return true;
-
-	if (self->state != WS_HANDLER_CONNECTING)
-		return soft_assert (self->state != WS_HANDLER_CLOSED)
-			&& ws_parser_push (&self->parser, data, len);
-
-	// The handshake hasn't been done yet, process HTTP headers
-	static const http_parser_settings http_settings =
-	{
-		.on_header_field     = ws_handler_on_header_field,
-		.on_header_value     = ws_handler_on_header_value,
-		.on_headers_complete = ws_handler_on_headers_complete,
-		.on_url              = ws_handler_on_url,
-	};
-
-	size_t n_parsed =
-		http_parser_execute (&self->hp, &http_settings, data, len);
-
-	if (self->hp.upgrade)
-	{
-		ev_timer_stop (EV_DEFAULT_ &self->handshake_timeout_watcher);
-
-		// The handshake hasn't been finished, yet there is more data
-		//   to be processed after the headers already
-		if (len - n_parsed)
-			FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST);
-
-		if (!ws_handler_finish_handshake (self))
-			return false;
-		if (self->on_connected)
-			return self->on_connected (self);
-		return true;
-	}
-
-	enum http_errno err = HTTP_PARSER_ERRNO (&self->hp);
-	if (n_parsed != len || err != HPE_OK)
-	{
-		ev_timer_stop (EV_DEFAULT_ &self->handshake_timeout_watcher);
-
-		if (err == HPE_CB_headers_complete)
-			print_debug ("WS handshake failed: %s", "missing `Upgrade' field");
-		else
-			print_debug ("WS handshake failed: %s",
-				http_errno_description (err));
-
-		FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST);
-	}
-	return true;
-}
-
-/// @}
-// --- Server ------------------------------------------------------------------
-
-static struct simple_config_item g_config_table[] =
-{
-	{ "bind_host",       NULL,              "Address of the server"          },
-	{ "port_fastcgi",    "9000",            "Port to bind for FastCGI"       },
-	{ "port_scgi",       NULL,              "Port to bind for SCGI"          },
-	{ "port_ws",         NULL,              "Port to bind for WebSockets"    },
-	{ "pid_file",        NULL,              "Full path for the PID file"     },
-	// XXX: here belongs something like a web SPA that interfaces with us
-	{ "static_root",     NULL,              "The root for static content"    },
-	{ NULL,              NULL,              NULL                             }
-};
-
-struct server_context
-{
-	ev_signal sigterm_watcher;          ///< Got SIGTERM
-	ev_signal sigint_watcher;           ///< Got SIGINT
-	ev_timer quit_timeout_watcher;      ///< Quit timeout watcher
-	bool quitting;                      ///< User requested quitting
-
-	struct listener *listeners;         ///< Listeners
-	size_t n_listeners;                 ///< Number of listening sockets
-
-	struct client *clients;             ///< Clients
-	unsigned n_clients;                 ///< Current number of connections
-
-	struct request_handler *handlers;   ///< Request handlers
-	struct str_map config;              ///< Server configuration
-};
-
-static void initiate_quit (struct server_context *self);
-static void try_finish_quit (struct server_context *self);
-static void on_quit_timeout (EV_P_ ev_timer *watcher, int revents);
-static void close_listeners (struct server_context *self);
-
-static void
-server_context_init (struct server_context *self)
-{
-	memset (self, 0, sizeof *self);
-
-	self->config = str_map_make (NULL);
-	simple_config_load_defaults (&self->config, g_config_table);
-	ev_timer_init (&self->quit_timeout_watcher, on_quit_timeout, 3., 0.);
-	self->quit_timeout_watcher.data = self;
-}
-
-static void
-server_context_free (struct server_context *self)
-{
-	// We really shouldn't attempt a quit without closing the clients first
-	soft_assert (!self->clients);
-
-	close_listeners (self);
-	free (self->listeners);
-
-	str_map_free (&self->config);
-}
-
-// --- JSON-RPC ----------------------------------------------------------------
-/// @defgroup JSON-RPC
-/// @{
-
-#define JSON_RPC_ERROR_TABLE(XX)                                               \
-	XX (-32700, PARSE_ERROR,      "Parse error")                               \
-	XX (-32600, INVALID_REQUEST,  "Invalid Request")                           \
-	XX (-32601, METHOD_NOT_FOUND, "Method not found")                          \
-	XX (-32602, INVALID_PARAMS,   "Invalid params")                            \
-	XX (-32603, INTERNAL_ERROR,   "Internal error")
-
-enum json_rpc_error
-{
-#define XX(code, name, message) JSON_RPC_ERROR_ ## name,
-	JSON_RPC_ERROR_TABLE (XX)
-#undef XX
-	JSON_RPC_ERROR_COUNT
-};
-
-static json_t *
-json_rpc_error (enum json_rpc_error id, json_t *data)
-{
-#define XX(code, name, message) { code, message },
-	static const struct json_rpc_error
-	{
-		int code;
-		const char *message;
-	}
-	errors[JSON_RPC_ERROR_COUNT] =
-	{
-		JSON_RPC_ERROR_TABLE (XX)
-	};
-#undef XX
-
-	json_t *error = json_object ();
-	json_object_set_new (error, "code",    json_integer (errors[id].code));
-	json_object_set_new (error, "message", json_string  (errors[id].message));
-
-	if (data)
-		json_object_set_new (error, "data", data);
-
-	return error;
-}
-
-static json_t *
-json_rpc_response (json_t *id, json_t *result, json_t *error)
-{
-	json_t *x = json_object ();
-	json_object_set_new (x, "jsonrpc", json_string ("2.0"));
-	json_object_set_new (x, "id", id ? id : json_null ());
-	if (result)  json_object_set_new (x, "result", result);
-	if (error)   json_object_set_new (x, "error",  error);
-	return x;
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static bool
-validate_json_rpc_content_type (const char *content_type)
-{
-	char *type = NULL;
-	char *subtype = NULL;
-
-	struct str_map parameters = str_map_make (free);
-	parameters.key_xfrm = tolower_ascii_strxfrm;
-
-	bool result = http_parse_media_type
-		(content_type, &type, &subtype, &parameters);
-	if (!result)
-		goto end;
-
-	if (strcasecmp_ascii (type, "application")
-	 || (strcasecmp_ascii (subtype, "json") &&
-		 strcasecmp_ascii (subtype, "json-rpc" /* obsolete */)))
-		result = false;
-
-	const char *charset = str_map_find (&parameters, "charset");
-	if (charset && strcasecmp_ascii (charset, "UTF-8"))
-		result = false;
-
-	// Currently ignoring all unknown parametrs
-
-end:
-	free (type);
-	free (subtype);
-	str_map_free (&parameters);
-	return result;
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-typedef json_t *(*json_rpc_handler_fn) (struct server_context *, json_t *);
-
-struct json_rpc_handler_info
-{
-	const char *method_name;            ///< JSON-RPC method name
-	json_rpc_handler_fn handler;        ///< Method handler
-};
-
-static int
-json_rpc_handler_info_cmp (const void *first, const void *second)
-{
-	return strcmp (((struct json_rpc_handler_info *) first)->method_name,
-		((struct json_rpc_handler_info *) second)->method_name);
-}
-
-// TODO: a method that sends a response after a certain number of seconds.
-//   This has to be owned by the server context as a background job that
-//   removes itself upon completion.
-
-static json_t *
-json_rpc_ping (struct server_context *ctx, json_t *params)
-{
-	(void) ctx;
-	(void) params;
-
-	return json_rpc_response (NULL, json_string ("pong"), NULL);
-}
-
-static json_t *
-process_json_rpc_request (struct server_context *ctx, json_t *request)
-{
-	// A list of all available methods; this list has to be ordered.
-	// Eventually it might be better to move this into a map in the context.
-	static struct json_rpc_handler_info handlers[] =
-	{
-		{ "ping", json_rpc_ping },
-	};
-
-	if (!json_is_object (request))
-		return json_rpc_response (NULL, NULL,
-			json_rpc_error (JSON_RPC_ERROR_INVALID_REQUEST, NULL));
-
-	json_t *v      = json_object_get (request, "jsonrpc");
-	json_t *m      = json_object_get (request, "method");
-	json_t *params = json_object_get (request, "params");
-	json_t *id     = json_object_get (request, "id");
-
-	const char *version;
-	const char *method;
-
-	bool ok = true;
-	ok &= v && (version = json_string_value (v)) && !strcmp (version, "2.0");
-	ok &= m && (method  = json_string_value (m));
-	ok &= !params || json_is_array (params) || json_is_object (params);
-	ok &= !id || json_is_null (id) ||
-		json_is_string (id) || json_is_number (id);
-	if (!ok)
-		return json_rpc_response (id, NULL,
-			json_rpc_error (JSON_RPC_ERROR_INVALID_REQUEST, NULL));
-
-	struct json_rpc_handler_info key = { .method_name = method };
-	struct json_rpc_handler_info *handler = bsearch (&key, handlers,
-		N_ELEMENTS (handlers), sizeof key, json_rpc_handler_info_cmp);
-	if (!handler)
-		return json_rpc_response (id, NULL,
-			json_rpc_error (JSON_RPC_ERROR_METHOD_NOT_FOUND, NULL));
-
-	json_t *response = handler->handler (ctx, params);
-	if (id)
-		return response;
-
-	// Notifications don't get responses
-	json_decref (response);
-	return NULL;
-}
-
-static void
-flush_json (json_t *json, struct str *output)
-{
-	char *utf8 = json_dumps (json, JSON_ENCODE_ANY);
-	str_append (output, utf8);
-	free (utf8);
-	json_decref (json);
-}
-
-static void
-process_json_rpc (struct server_context *ctx,
-	const void *data, size_t len, struct str *output)
-{
-
-	json_error_t e;
-	json_t *request;
-	if (!(request = json_loadb (data, len, JSON_DECODE_ANY, &e)))
-	{
-		flush_json (json_rpc_response (NULL, NULL,
-			json_rpc_error (JSON_RPC_ERROR_PARSE_ERROR, NULL)),
-			output);
-		return;
-	}
-
-	if (json_is_array (request))
-	{
-		if (!json_array_size (request))
-		{
-			flush_json (json_rpc_response (NULL, NULL,
-				json_rpc_error (JSON_RPC_ERROR_INVALID_REQUEST, NULL)),
-				output);
-			return;
-		}
-
-		json_t *response = json_array ();
-		json_t *iter;
-		size_t i;
-
-		json_array_foreach (request, i, iter)
-		{
-			json_t *result = process_json_rpc_request (ctx, iter);
-			if (result)
-				json_array_append_new (response, result);
-		}
-
-		if (json_array_size (response))
-			flush_json (response, output);
-		else
-			json_decref (response);
-	}
-	else
-	{
-		json_t *result = process_json_rpc_request (ctx, request);
-		if (result)
-			flush_json (result, output);
-	}
-}
-
-/// @}
-// --- Requests ----------------------------------------------------------------
-/// @defgroup Requests
-/// @{
-
-/// A generic CGI request abstraction, writing data indirectly through callbacks
-struct request
-{
-	struct server_context *ctx;         ///< Server context
-
-	struct request_handler *handler;    ///< Assigned request handler
-	void *handler_data;                 ///< User data for the handler
-
-	/// Callback to write some CGI response data to the output
-	void (*write_cb) (struct request *, const void *data, size_t len);
-
-	/// Callback to close the CGI response, simulates end of program execution.
-	/// CALLING THIS MAY CAUSE THE REQUEST TO BE DESTROYED.
-	void (*close_cb) (struct request *);
-};
-
-/// An interface to detect and handle specific kinds of CGI requests.
-/// The server walks through a list of them until it finds one that can serve
-/// a particular request.  If unsuccessful, the remote client gets a 404
-/// (the default handling).
-struct request_handler
-{
-	LIST_HEADER (struct request_handler)
-
-	/// Install ourselves as the handler for the request, if applicable.
-	/// Sets @a continue_ to false if further processing should be stopped,
-	/// meaning the request has already been handled.
-	bool (*try_handle) (struct request *request,
-		struct str_map *headers, bool *continue_);
-
-	/// Handle incoming data.  "len == 0" means EOF.
-	/// Returns false if there is no more processing to be done.
-	// FIXME: the EOF may or may not be delivered when request is cut short,
-	//   we should fix FastCGI not to deliver it on CONTENT_LENGTH mismatch
-	bool (*push_cb) (struct request *request, const void *data, size_t len);
-
-	/// Destroy the handler's data stored in the request object
-	void (*finalize_cb) (struct request *request);
-};
-
-static void
-request_init (struct request *self)
-{
-	memset (self, 0, sizeof *self);
-}
-
-static void
-request_free (struct request *self)
-{
-	if (self->handler)
-		self->handler->finalize_cb (self);
-}
-
-/// Write request CGI response data, intended for use by request handlers
-static void
-request_write (struct request *self, const void *data, size_t len)
-{
-	self->write_cb (self, data, len);
-}
-
-/// This function is only intended to be run from asynchronous event handlers
-/// such as timers, not as a direct result of starting the request or receiving
-/// request data.  CALLING THIS MAY CAUSE THE REQUEST TO BE DESTROYED.
-static void
-request_finish (struct request *self)
-{
-	self->close_cb (self);
-}
-
-/// Starts processing a request.  Returns false if no further action is to be
-/// done and the request should be finished.
-static bool
-request_start (struct request *self, struct str_map *headers)
-{
-	// XXX: it feels like this should rather be two steps:
-	//   bool (*can_handle) (request *, headers)
-	//   ... install the handler ...
-	//   bool (*handle) (request *)
-	//
-	//   However that might cause some stuff to be done twice.
-	//
-	//   Another way we could get rid of the continue_ argument is via adding
-	//   some way of marking the request as finished from within the handler.
-
-	if (g_debug_mode)
-	{
-		struct str_map_iter iter = str_map_iter_make (headers);
-		const char *value;
-		while ((value = str_map_iter_next (&iter)))
-			print_debug ("%s: %s", iter.link->key, value);
-		print_debug ("--");
-	}
-
-	bool continue_ = true;
-	LIST_FOR_EACH (struct request_handler, handler, self->ctx->handlers)
-		if (handler->try_handle (self, headers, &continue_))
-		{
-			self->handler = handler;
-			return continue_;
-		}
-
-	// Unable to serve the request
-	struct str response = str_make ();
-	str_append (&response, "Status: 404 Not Found\n");
-	str_append (&response, "Content-Type: text/plain\n\n");
-	request_write (self, response.str, response.len);
-	str_free (&response);
-	return false;
-}
-
-static bool
-request_push (struct request *self, const void *data, size_t len)
-{
-	if (!soft_assert (self->handler))
-		// No handler, nothing to do with any data
-		return false;
-
-	return self->handler->push_cb (self, data, len);
-}
-
-/// @}
-// --- Requests handlers -------------------------------------------------------
-
-static bool
-request_handler_json_rpc_try_handle
-	(struct request *request, struct str_map *headers, bool *continue_)
-{
-	const char *content_type = str_map_find (headers, "CONTENT_TYPE");
-	const char *method = str_map_find (headers, "REQUEST_METHOD");
-
-	if (!method || strcmp (method, "POST")
-	 || !content_type || !validate_json_rpc_content_type (content_type))
-		return false;
-
-	struct str *buf = xcalloc (1, sizeof *buf);
-	*buf = str_make ();
-
-	request->handler_data = buf;
-	*continue_ = true;
-	return true;
-}
-
-static bool
-request_handler_json_rpc_push
-	(struct request *request, const void *data, size_t len)
-{
-	struct str *buf = request->handler_data;
-	if (len)
-	{
-		str_append_data (buf, data, len);
-		return true;
-	}
-
-	// TODO: check buf.len against CONTENT_LENGTH; if it's less, then the
-	//   client hasn't been successful in transferring all of its data.
-	//   See also comment on request_handler::push_cb.
-
-	struct str response = str_make ();
-	str_append (&response, "Status: 200 OK\n");
-	str_append_printf (&response, "Content-Type: %s\n\n", "application/json");
-	process_json_rpc (request->ctx, buf->str, buf->len, &response);
-	request_write (request, response.str, response.len);
-	str_free (&response);
-	return false;
-}
-
-static void
-request_handler_json_rpc_finalize (struct request *request)
-{
-	struct str *buf = request->handler_data;
-	str_free (buf);
-	free (buf);
-
-	request->handler_data = NULL;
-}
-
-struct request_handler g_request_handler_json_rpc =
-{
-	.try_handle  = request_handler_json_rpc_try_handle,
-	.push_cb     = request_handler_json_rpc_push,
-	.finalize_cb = request_handler_json_rpc_finalize,
-};
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static char *
-canonicalize_url_path (const char *path)
-{
-	// XXX: this strips any slashes at the end
-	struct strv v = strv_make ();
-	cstr_split (path, "/", true, &v);
-
-	struct strv canonical = strv_make ();
-
-	// So that the joined path always begins with a slash
-	strv_append (&canonical, "");
-
-	for (size_t i = 0; i < v.len; i++)
-	{
-		const char *dir = v.vector[i];
-		if (!strcmp (dir, "."))
-			continue;
-
-		if (strcmp (dir, ".."))
-			strv_append (&canonical, dir);
-		else if (canonical.len > 1)
-			// ".." never goes above the root
-			strv_remove (&canonical, canonical.len - 1);
-	}
-	strv_free (&v);
-
-	char *joined = strv_join (&canonical, "/");
-	strv_free (&canonical);
-	return joined;
-}
-
-static char *
-detect_magic (const void *data, size_t len)
-{
-	magic_t cookie;
-	char *mime_type = NULL;
-
-	if (!(cookie = magic_open (MAGIC_MIME)))
-		return NULL;
-
-	const char *magic = NULL;
-	if (!magic_load (cookie, NULL)
-	 && (magic = magic_buffer (cookie, data, len)))
-		mime_type = xstrdup (magic);
-	else
-		print_debug ("MIME type detection failed: %s", magic_error (cookie));
-
-	magic_close (cookie);
-	return mime_type;
-}
-
-static bool
-request_handler_static_try_handle
-	(struct request *request, struct str_map *headers, bool *continue_)
-{
-	// Serving static files is actually quite complicated as it turns out;
-	// but this is only meant to serve a few tiny text files
-
-	struct server_context *ctx = request->ctx;
-	const char *root = str_map_find (&ctx->config, "static_root");
-	if (!root)
-	{
-		print_debug ("static document root not configured");
-		return false;
-	}
-
-	// TODO: implement HEAD, we don't get that for free;
-	//   probably implies adding Content-Length
-	const char *method = str_map_find (headers, "REQUEST_METHOD");
-	if (!method || strcmp (method, "GET"))
-		return false;
-
-	// TODO: look at <SCRIPT_NAME, PATH_INFO>, REQUEST_URI in the headers
-	const char *path_info = str_map_find (headers, "PATH_INFO");
-	if (!path_info)
-		path_info = str_map_find (headers, "REQUEST_URI");
-	if (!path_info)
-	{
-		print_debug ("neither PATH_INFO nor REQUEST_URI was defined");
-		return false;
-	}
-
-	// We need to filter the path to stay in our root
-	// Being able to read /etc/passwd would be rather embarrasing
-	char *suffix = canonicalize_url_path (path_info);
-	char *path = xstrdup_printf ("%s%s", root, suffix);
-	print_debug ("trying to statically serve %s", path);
-
-	// TODO: check that this is a regular file
-	FILE *fp = fopen (path, "rb");
-	if (!fp)
-	{
-		struct str response = str_make ();
-		str_append (&response, "Status: 404 Not Found\n");
-		str_append (&response, "Content-Type: text/plain\n\n");
-		str_append_printf (&response,
-			"File %s was not found on this server\n", suffix);
-		request_write (request, response.str, response.len);
-		str_free (&response);
-
-		free (suffix);
-		free (path);
-		return false;
-	}
-
-	free (suffix);
-	free (path);
-
-	uint8_t buf[8192];
-	size_t len;
-
-	// Try to detect the Content-Type from the actual contents
-	char *mime_type = NULL;
-	if ((len = fread (buf, 1, sizeof buf, fp)))
-		mime_type = detect_magic (buf, len);
-	if (!mime_type)
-		mime_type = xstrdup ("application/octet_stream");
-
-	struct str response = str_make ();
-	str_append (&response, "Status: 200 OK\n");
-	str_append_printf (&response, "Content-Type: %s\n\n", mime_type);
-	request_write (request, response.str, response.len);
-	str_free (&response);
-	free (mime_type);
-
-	// Write the chunk we've used to help us with magic detection;
-	// obviously we have to do it after we've written the headers
-	if (len)
-		request_write (request, buf, len);
-
-	while ((len = fread (buf, 1, sizeof buf, fp)))
-		request_write (request, buf, len);
-	fclose (fp);
-
-	// TODO: this should rather not be returned all at once but in chunks;
-	//   file read requests never return EAGAIN
-	// TODO: actual file data should really be returned by a callback when
-	//   the socket is writable with nothing to be sent (pumping the entire
-	//   file all at once won't really work if it's huge).
-	*continue_ = false;
-	return true;
-}
-
-static bool
-request_handler_static_push
-	(struct request *request, const void *data, size_t len)
-{
-	(void) request;
-	(void) data;
-
-	// Aborting on content; we shouldn't receive any (GET)
-	// FIXME: there should at least be some indication of this happening
-	return len == 0;
-}
-
-static void
-request_handler_static_finalize (struct request *request)
-{
-	(void) request;
-	// Nothing to dispose of this far
-}
-
-struct request_handler g_request_handler_static =
-{
-	.try_handle  = request_handler_static_try_handle,
-	.push_cb     = request_handler_static_push,
-	.finalize_cb = request_handler_static_finalize,
-};
-
-// --- Client communication handlers -------------------------------------------
-
-/// A virtual class for client connections coming either from the web server
-/// or directly from the end-client, depending on the protocol in use
-struct client
-{
-	LIST_HEADER (struct client)
-
-	struct client_vtable *vtable;       ///< Client behaviour
-
-	int socket_fd;                      ///< The network socket
-	bool received_eof;                  ///< Whether EOF has been received yet
-	bool flushing;                      ///< No more data to write, send FIN
-	bool closing;                       ///< No more data to read or write
-	bool half_closed;                   ///< Conn. half-closed while flushing
-	struct write_queue write_queue;     ///< Write queue
-	ev_timer close_timeout_watcher;     ///< Write queue flush timer
-
-	ev_io read_watcher;                 ///< The socket can be read from
-	ev_io write_watcher;                ///< The socket can be written to
-};
-
-/// The concrete behaviour to serve a particular client's requests
-struct client_vtable
-{
-	/// Process incoming data; "len == 0" means EOF.
-	/// If the method returns false, client_close() is called by the caller.
-	bool (*push) (struct client *client, const void *data, size_t len);
-
-	// TODO: optional push_error() to inform about network I/O errors
-
-	/// Attempt a graceful shutdown: make any appropriate steps before
-	/// the client connection times out and gets torn down by force.
-	/// The client is allowed to destroy itself immediately.
-	void (*shutdown) (struct client *client);
-
-	/// Do any additional cleanup for the concrete class before destruction
-	void (*finalize) (struct client *client);
-};
-
-static void
-client_destroy (struct client *self)
-{
-	// XXX: this codebase halfway pretends there could be other contexts
-	struct server_context *ctx = ev_userdata (EV_DEFAULT);
-	LIST_UNLINK (ctx->clients, self);
-	ctx->n_clients--;
-
-	// First uninitialize the higher-level implementation
-	self->vtable->finalize (self);
-
-	ev_io_stop (EV_DEFAULT_ &self->read_watcher);
-	ev_io_stop (EV_DEFAULT_ &self->write_watcher);
-	xclose (self->socket_fd);
-	write_queue_free (&self->write_queue);
-	ev_timer_stop (EV_DEFAULT_ &self->close_timeout_watcher);
-	free (self);
-
-	try_finish_quit (ctx);
-}
-
-static void
-client_write (struct client *self, const void *data, size_t len)
-{
-	if (!soft_assert (!self->flushing) || len == 0)
-		return;
-
-	struct write_req *req = xcalloc (1, sizeof *req);
-	req->data.iov_base = memcpy (xmalloc (len), data, len);
-	req->data.iov_len = len;
-
-	write_queue_add (&self->write_queue, req);
-	ev_io_start (EV_DEFAULT_ &self->write_watcher);
-}
-
-/// Half-close the connection from our side once the write_queue is flushed.
-/// It is the caller's responsibility to destroy the connection upon EOF.
-// XXX: or we might change on_client_readable to do it anyway, seems safe
-static void
-client_shutdown (struct client *self)
-{
-	self->flushing = true;
-	ev_feed_event (EV_DEFAULT_ &self->write_watcher, EV_WRITE);
-}
-
-/// Try to cleanly close the connection, waiting for the remote client to close
-/// its own side of the connection as a sign that it has processed all the data
-/// it wanted to.  The client implementation will not receive any further data.
-/// May directly call client_destroy().
-static void
-client_close (struct client *self)
-{
-	if (self->closing)
-		return;
-
-	self->closing = true;
-	ev_timer_start (EV_DEFAULT_ &self->close_timeout_watcher);
-	client_shutdown (self);
-
-	// We assume the remote client doesn't want our data if it half-closes
-	if (self->received_eof)
-		client_destroy (self);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static bool
-client_read_loop (EV_P_ struct client *client, ev_io *watcher)
-{
-	char buf[8192];
-	ssize_t n_read;
-again:
-	while ((n_read = recv (watcher->fd, buf, sizeof buf, 0)) >= 0)
-	{
-		if (!n_read)
-		{
-			// Don't deliver the EOF condition repeatedly
-			ev_io_stop (EV_A_ watcher);
-			client->received_eof = true;
-		}
-		if (!client->closing
-		 && !client->vtable->push (client, buf, n_read))
-		{
-			client_close (client);
-			return false;
-		}
-		if (!n_read)
-			return true;
-	}
-	if (errno == EINTR)
-		goto again;
-	if (errno == EAGAIN)
-		return true;
-
-	client_destroy (client);
-	return false;
-}
-
-static void
-on_client_readable (EV_P_ ev_io *watcher, int revents)
-{
-	struct client *client = watcher->data;
-	(void) revents;
-
-	if (client_read_loop (EV_A_ client, watcher)
-	 && client->closing && client->received_eof)
-		client_destroy (client);
-}
-
-static void
-on_client_writable (EV_P_ ev_io *watcher, int revents)
-{
-	struct client *client = watcher->data;
-	(void) loop;
-	(void) revents;
-
-	// TODO: some sort of "on_buffers_flushed" callback for streaming huge
-	//   chunks of external (or generated) data.  That will need to be
-	//   forwarded to "struct request_handler".
-	if (!flush_queue (&client->write_queue, watcher->fd))
-	{
-		client_destroy (client);
-		return;
-	}
-	if (!write_queue_is_empty (&client->write_queue))
-		return;
-
-	ev_io_stop (EV_A_ watcher);
-	if (client->flushing && !client->half_closed)
-	{
-		if (!shutdown (client->socket_fd, SHUT_WR))
-			client->half_closed = true;
-		else
-			client_destroy (client);
-	}
-}
-
-static void
-on_client_timeout (EV_P_ ev_timer *watcher, int revents)
-{
-	(void) loop;
-	(void) revents;
-
-	client_destroy (watcher->data);
-}
-
-/// Create a new instance of a subclass with the given size.
-/// The superclass is assumed to be the first member of the structure.
-static void *
-client_new (EV_P_ size_t size, int sock_fd)
-{
-	struct server_context *ctx = ev_userdata (loop);
-	struct client *self = xcalloc (1, size);
-
-	self->write_queue = write_queue_make ();
-	ev_timer_init (&self->close_timeout_watcher, on_client_timeout, 5., 0.);
-	self->close_timeout_watcher.data = self;
-
-	set_blocking (sock_fd, false);
-	self->socket_fd = sock_fd;
-
-	ev_io_init (&self->read_watcher,  on_client_readable, sock_fd, EV_READ);
-	ev_io_init (&self->write_watcher, on_client_writable, sock_fd, EV_WRITE);
-	self->read_watcher.data = self;
-	self->write_watcher.data = self;
-
-	// We're only interested in reading as the write queue is empty now
-	ev_io_start (EV_A_ &self->read_watcher);
-
-	LIST_PREPEND (ctx->clients, self);
-	ctx->n_clients++;
-	return self;
-}
-
-// --- FastCGI client handler --------------------------------------------------
-
-struct client_fcgi
-{
-	struct client client;               ///< Parent class
-	struct fcgi_muxer muxer;            ///< FastCGI de/multiplexer
-};
-
-struct client_fcgi_request
-{
-	struct fcgi_request *fcgi_request;  ///< FastCGI request
-	struct request request;             ///< Request
-};
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static void
-client_fcgi_request_write_cb (struct request *req, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, req, struct client_fcgi_request, request);
-	fcgi_request_write (self->fcgi_request, data, len);
-}
-
-static void
-client_fcgi_request_close_cb (struct request *req)
-{
-	FIND_CONTAINER (self, req, struct client_fcgi_request, request);
-	struct fcgi_muxer *muxer = self->fcgi_request->muxer;
-	// No more data to send, terminate the substream/request,
-	// and also the transport if the client didn't specifically ask to keep it
-	if (!fcgi_request_finish (self->fcgi_request))
-		muxer->close_cb (muxer);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static bool
-client_fcgi_request_start (struct fcgi_request *fcgi_request)
-{
-	struct client_fcgi_request *request =
-		fcgi_request->handler_data = xcalloc (1, sizeof *request);
-	request->fcgi_request = fcgi_request;
-	request_init (&request->request);
-	request->request.ctx = ev_userdata (EV_DEFAULT);
-	request->request.write_cb = client_fcgi_request_write_cb;
-	request->request.close_cb = client_fcgi_request_close_cb;
-
-	return request_start (&request->request, &fcgi_request->headers);
-}
-
-static bool
-client_fcgi_request_push
-	(struct fcgi_request *req, const void *data, size_t len)
-{
-	struct client_fcgi_request *request = req->handler_data;
-	return request_push (&request->request, data, len)
-		|| fcgi_request_finish (req);
-}
-
-static void
-client_fcgi_request_finalize (struct fcgi_request *req)
-{
-	struct client_fcgi_request *request = req->handler_data;
-	request_free (&request->request);
-	free (request);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static void
-client_fcgi_write_cb (struct fcgi_muxer *mux, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, mux, struct client_fcgi, muxer);
-	client_write (&self->client, data, len);
-}
-
-static void
-client_fcgi_close_cb (struct fcgi_muxer *mux)
-{
-	FIND_CONTAINER (self, mux, struct client_fcgi, muxer);
-	client_close (&self->client);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static bool
-client_fcgi_push (struct client *client, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, client, struct client_fcgi, client);
-	return fcgi_muxer_push (&self->muxer, data, len);
-}
-
-static void
-client_fcgi_shutdown (struct client *client)
-{
-	FIND_CONTAINER (self, client, struct client_fcgi, client);
-	self->muxer.in_shutdown = true;
-
-	// TODO: respond with FCGI_END_REQUEST: FCGI_REQUEST_COMPLETE to everything?
-	//   The FastCGI specification isn't very clear about what we should do.
-}
-
-static void
-client_fcgi_finalize (struct client *client)
-{
-	FIND_CONTAINER (self, client, struct client_fcgi, client);
-	fcgi_muxer_free (&self->muxer);
-}
-
-static struct client_vtable client_fcgi_vtable =
-{
-	.push     = client_fcgi_push,
-	.shutdown = client_fcgi_shutdown,
-	.finalize = client_fcgi_finalize,
-};
-
-static struct client *
-client_fcgi_create (EV_P_ int sock_fd)
-{
-	struct client_fcgi *self = client_new (EV_A_ sizeof *self, sock_fd);
-	self->client.vtable = &client_fcgi_vtable;
-
-	fcgi_muxer_init (&self->muxer);
-	self->muxer.write_cb            = client_fcgi_write_cb;
-	self->muxer.close_cb            = client_fcgi_close_cb;
-	self->muxer.request_start_cb    = client_fcgi_request_start;
-	self->muxer.request_push_cb     = client_fcgi_request_push;
-	self->muxer.request_finalize_cb = client_fcgi_request_finalize;
-	return &self->client;
-}
-
-// --- SCGI client handler -----------------------------------------------------
-
-struct client_scgi
-{
-	struct client client;               ///< Parent class
-	struct scgi_parser parser;          ///< SCGI stream parser
-	struct request request;             ///< Request (only one per connection)
-	unsigned long remaining_content;    ///< Length of input data to be seen
-};
-
-static void
-client_scgi_write_cb (struct request *req, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, req, struct client_scgi, request);
-	client_write (&self->client, data, len);
-}
-
-static void
-client_scgi_close_cb (struct request *req)
-{
-	FIND_CONTAINER (self, req, struct client_scgi, request);
-	// NOTE: this rather really means "close me [the request]"
-	client_close (&self->client);
-}
-
-static bool
-client_scgi_on_headers_read (void *user_data)
-{
-	struct client_scgi *self = user_data;
-	const char *cl = str_map_find (&self->parser.headers, "CONTENT_LENGTH");
-	if (!cl || !xstrtoul (&self->remaining_content, cl, 10))
-	{
-		print_debug ("SCGI request with invalid or missing CONTENT_LENGTH");
-		return false;
-	}
-	return request_start (&self->request, &self->parser.headers);
-}
-
-static bool
-client_scgi_on_content (void *user_data, const void *data, size_t len)
-{
-	struct client_scgi *self = user_data;
-	if (len > self->remaining_content)
-	{
-		print_debug ("SCGI request got more data than CONTENT_LENGTH");
-		return false;
-	}
-	// We're in a slight disagreement with the specification since
-	// this tries to write output before it has read all the input
-	if (!request_push (&self->request, data, len))
-		return false;
-
-	// Signalise end of input to the request handler
-	return (self->remaining_content -= len) != 0
-		|| request_push (&self->request, NULL, 0);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static bool
-client_scgi_push (struct client *client, const void *data, size_t len)
-{
-	struct client_scgi *self = (struct client_scgi *) client;
-	struct error *e = NULL;
-	if (scgi_parser_push (&self->parser, data, len, &e))
-		return true;
-
-	if (e != NULL)
-	{
-		print_debug ("SCGI parser failed: %s", e->message);
-		error_free (e);
-	}
-	return false;
-}
-
-static void
-client_scgi_finalize (struct client *client)
-{
-	struct client_scgi *self = (struct client_scgi *) client;
-	request_free (&self->request);
-	scgi_parser_free (&self->parser);
-}
-
-static struct client_vtable client_scgi_vtable =
-{
-	.push     = client_scgi_push,
-	.finalize = client_scgi_finalize,
-};
-
-static struct client *
-client_scgi_create (EV_P_ int sock_fd)
-{
-	struct client_scgi *self = client_new (EV_A_ sizeof *self, sock_fd);
-	self->client.vtable = &client_scgi_vtable;
-
-	request_init (&self->request);
-	self->request.ctx            = ev_userdata (EV_DEFAULT);
-	self->request.write_cb       = client_scgi_write_cb;
-	self->request.close_cb       = client_scgi_close_cb;
-
-	self->parser = scgi_parser_make ();
-	self->parser.on_headers_read = client_scgi_on_headers_read;
-	self->parser.on_content      = client_scgi_on_content;
-	self->parser.user_data       = self;
-	return &self->client;
-}
-
-// --- WebSockets client handler -----------------------------------------------
-
-struct client_ws
-{
-	struct client client;               ///< Parent class
-	struct ws_handler handler;          ///< WebSockets connection handler
-};
-
-static bool
-client_ws_on_message (struct ws_handler *handler,
-	enum ws_opcode type, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, handler, struct client_ws, handler);
-	if (type != WS_OPCODE_TEXT)
-	{
-		return ws_handler_fail_connection
-			(&self->handler, WS_STATUS_UNSUPPORTED_DATA);
-	}
-
-	struct server_context *ctx = ev_userdata (EV_DEFAULT);
-	struct str response = str_make ();
-	process_json_rpc (ctx, data, len, &response);
-	if (response.len)
-		ws_handler_send_frame (&self->handler,
-			WS_OPCODE_TEXT, response.str, response.len);
-	str_free (&response);
-	return true;
-}
-
-static void
-client_ws_write_cb (struct ws_handler *handler, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, handler, struct client_ws, handler);
-	client_write (&self->client, data, len);
-}
-
-static void
-client_ws_close_cb (struct ws_handler *handler, bool half_close)
-{
-	FIND_CONTAINER (self, handler, struct client_ws, handler);
-	(half_close ? client_shutdown : client_destroy) (&self->client);
-}
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-static bool
-client_ws_push (struct client *client, const void *data, size_t len)
-{
-	FIND_CONTAINER (self, client, struct client_ws, client);
-	// client_close() will correctly destroy the client on EOF
-	return ws_handler_push (&self->handler, data, len);
-}
-
-static void
-client_ws_shutdown (struct client *client)
-{
-	FIND_CONTAINER (self, client, struct client_ws, client);
-	if (self->handler.state == WS_HANDLER_CONNECTING)
-		// No on_close, no problem
-		client_destroy (&self->client);
-	else if (self->handler.state == WS_HANDLER_OPEN)
-		ws_handler_close (&self->handler, WS_STATUS_GOING_AWAY, NULL, 0);
-}
-
-static void
-client_ws_finalize (struct client *client)
-{
-	FIND_CONTAINER (self, client, struct client_ws, client);
-	ws_handler_free (&self->handler);
-}
-
-static struct client_vtable client_ws_vtable =
-{
-	.push     = client_ws_push,
-	.shutdown = client_ws_shutdown,
-	.finalize = client_ws_finalize,
-};
-
-static struct client *
-client_ws_create (EV_P_ int sock_fd)
-{
-	struct client_ws *self = client_new (EV_A_ sizeof *self, sock_fd);
-	self->client.vtable = &client_ws_vtable;
-
-	ws_handler_init (&self->handler);
-	self->handler.on_message = client_ws_on_message;
-	self->handler.write_cb   = client_ws_write_cb;
-	self->handler.close_cb   = client_ws_close_cb;
-
-	// One mebibyte seems to be a reasonable value
-	self->handler.max_payload_len = 1 << 10;
-
-	ws_handler_start (&self->handler);
-	return &self->client;
-}
-
-// --- Basic server stuff ------------------------------------------------------
-
-typedef struct client *(*client_create_fn) (EV_P_ int sock_fd);
-
-struct listener
-{
-	int fd;                             ///< Listening socket FD
-	ev_io watcher;                      ///< New connection available
-	client_create_fn create;            ///< Client constructor
-};
-
-static void
-close_listeners (struct server_context *self)
-{
-	for (size_t i = 0; i < self->n_listeners; i++)
-	{
-		struct listener *listener = &self->listeners[i];
-		if (listener->fd == -1)
-			continue;
-
-		ev_io_stop (EV_DEFAULT_ &listener->watcher);
-		xclose (listener->fd);
-		listener->fd = -1;
-	}
-}
-
-static void
-try_finish_quit (struct server_context *self)
-{
-	if (!self->quitting || self->clients)
-		return;
-
-	ev_timer_stop (EV_DEFAULT_ &self->quit_timeout_watcher);
-	ev_break (EV_DEFAULT_ EVBREAK_ALL);
-}
-
-static void
-on_quit_timeout (EV_P_ ev_timer *watcher, int revents)
-{
-	struct server_context *self = watcher->data;
-	(void) loop;
-	(void) revents;
-
-	LIST_FOR_EACH (struct client, iter, self->clients)
-		client_destroy (iter);
-}
-
-static void
-initiate_quit (struct server_context *self)
-{
-	self->quitting = true;
-	close_listeners (self);
-
-	// Wait a little while for all clients to clean up, if necessary
-	LIST_FOR_EACH (struct client, iter, self->clients)
-		if (iter->vtable->shutdown)
-			iter->vtable->shutdown (iter);
-	ev_timer_start (EV_DEFAULT_ &self->quit_timeout_watcher);
-	try_finish_quit (self);
-}
-
-static void
-on_client_available (EV_P_ ev_io *watcher, int revents)
-{
-	struct server_context *ctx = ev_userdata (loop);
-	struct listener *listener = watcher->data;
-	(void) revents;
-
-	while (true)
-	{
-		int sock_fd = accept (watcher->fd, NULL, NULL);
-		if (sock_fd != -1)
-			listener->create (EV_A_ sock_fd);
-		else if (errno == EAGAIN)
-			return;
-		else if (errno != EINTR && errno != EMFILE
-		 && errno != ECONNRESET && errno != ECONNABORTED)
-			break;
-	}
-
-	// Stop accepting connections to prevent busy looping
-	ev_io_stop (EV_A_ watcher);
-
-	print_fatal ("%s: %s", "accept", strerror (errno));
-	initiate_quit (ctx);
-}
-
-// --- Application setup -------------------------------------------------------
-
-/// This function handles values that require validation before their first use,
-/// or some kind of a transformation (such as conversion to an integer) needs
-/// to be done before they can be used directly.
-static bool
-parse_config (struct server_context *ctx, struct error **e)
-{
-	(void) ctx;
-	(void) e;
-
-	return true;
-}
-
-static int
-listener_bind (struct addrinfo *gai_iter)
-{
-	int fd = socket (gai_iter->ai_family,
-		gai_iter->ai_socktype, gai_iter->ai_protocol);
-	if (fd == -1)
-		return -1;
-	set_cloexec (fd);
-
-	int yes = 1;
-	soft_assert (setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE,
-		&yes, sizeof yes) != -1);
-	soft_assert (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
-		&yes, sizeof yes) != -1);
-
-	char host[NI_MAXHOST], port[NI_MAXSERV];
-	host[0] = port[0] = '\0';
-	int err = getnameinfo (gai_iter->ai_addr, gai_iter->ai_addrlen,
-		host, sizeof host, port, sizeof port,
-		NI_NUMERICHOST | NI_NUMERICSERV);
-	if (err)
-		print_debug ("%s: %s", "getnameinfo", gai_strerror (err));
-
-	char *address = format_host_port_pair (host, port);
-	if (bind (fd, gai_iter->ai_addr, gai_iter->ai_addrlen))
-		print_error ("bind to %s failed: %s", address, strerror (errno));
-	else if (listen (fd, 16 /* arbitrary number */))
-		print_error ("listen on %s failed: %s", address, strerror (errno));
-	else
-	{
-		print_status ("listening on %s", address);
-		free (address);
-		return fd;
-	}
-
-	free (address);
-	xclose (fd);
-	return -1;
-}
-
-static void
-listener_add (struct server_context *ctx, const char *host, const char *port,
-	const struct addrinfo *gai_hints, client_create_fn create)
-{
-	struct addrinfo *gai_result, *gai_iter;
-	int err = getaddrinfo (host, port, gai_hints, &gai_result);
-	if (err)
-	{
-		char *address = format_host_port_pair (host, port);
-		print_error ("bind to %s failed: %s: %s",
-			address, "getaddrinfo", gai_strerror (err));
-		free (address);
-		return;
-	}
-
-	int fd;
-	for (gai_iter = gai_result; gai_iter; gai_iter = gai_iter->ai_next)
-	{
-		if ((fd = listener_bind (gai_iter)) == -1)
-			continue;
-		set_blocking (fd, false);
-
-		struct listener *listener = &ctx->listeners[ctx->n_listeners++];
-		ev_io_init (&listener->watcher, on_client_available, fd, EV_READ);
-		ev_io_start (EV_DEFAULT_ &listener->watcher);
-		listener->watcher.data = listener;
-		listener->create = create;
-		listener->fd = fd;
-		break;
-	}
-	freeaddrinfo (gai_result);
-}
-
-static void
-get_ports_from_config (struct server_context *ctx,
-	const char *key, struct strv *out)
-{
-	const char *ports;
-	if ((ports = str_map_find (&ctx->config, key)))
-		cstr_split (ports, ",", true, out);
-}
-
-static bool
-setup_listen_fds (struct server_context *ctx, struct error **e)
-{
-	static const struct addrinfo gai_hints =
-	{
-		.ai_socktype = SOCK_STREAM,
-		.ai_flags = AI_PASSIVE,
-	};
-
-	struct strv ports_fcgi = strv_make ();
-	struct strv ports_scgi = strv_make ();
-	struct strv ports_ws   = strv_make ();
-
-	get_ports_from_config (ctx, "port_fastcgi", &ports_fcgi);
-	get_ports_from_config (ctx, "port_scgi",    &ports_scgi);
-	get_ports_from_config (ctx, "port_ws",      &ports_ws);
-
-	const char *bind_host = str_map_find (&ctx->config, "bind_host");
-	size_t n_ports = ports_fcgi.len + ports_scgi.len + ports_ws.len;
-	ctx->listeners = xcalloc (n_ports, sizeof *ctx->listeners);
-
-	for (size_t i = 0; i < ports_fcgi.len; i++)
-		listener_add (ctx, bind_host, ports_fcgi.vector[i],
-			&gai_hints, client_fcgi_create);
-	for (size_t i = 0; i < ports_scgi.len; i++)
-		listener_add (ctx, bind_host, ports_scgi.vector[i],
-			&gai_hints, client_scgi_create);
-	for (size_t i = 0; i < ports_ws.len; i++)
-		listener_add (ctx, bind_host, ports_ws.vector[i],
-			&gai_hints, client_ws_create);
-
-	strv_free (&ports_fcgi);
-	strv_free (&ports_scgi);
-	strv_free (&ports_ws);
-
-	if (!ctx->n_listeners)
-	{
-		error_set (e, "%s: %s",
-			"network setup failed", "no ports to listen on");
-		return false;
-	}
-	return true;
-}
-
-static bool
-app_lock_pid_file (struct server_context *ctx, struct error **e)
-{
-	const char *path = str_map_find (&ctx->config, "pid_file");
-	if (!path)
-		return true;
-
-	char *resolved = resolve_filename (path, resolve_relative_runtime_filename);
-	bool result = lock_pid_file (resolved, e) != -1;
-	free (resolved);
-	return result;
-}
-
-// --- Tests -------------------------------------------------------------------
-
-static void
-test_misc (void)
-{
-	soft_assert ( validate_json_rpc_content_type
-		("application/JSON; charset=\"utf-8\""));
-	soft_assert (!validate_json_rpc_content_type
-		("text/html; charset=\"utf-8\""));
-
-	char *canon = canonicalize_url_path ("///../../../etc/./passwd");
-	soft_assert (!strcmp (canon, "/etc/passwd"));
-	free (canon);
-}
-
-int
-test_main (int argc, char *argv[])
-{
-	struct test test;
-	test_init (&test, argc, argv);
-
-	test_add_simple (&test, "/misc",        NULL, test_misc);
-
-	// TODO: write more tests
-	// TODO: test the server handler (happy path)
-
-	return test_run (&test);
-}
-
-// --- Main program ------------------------------------------------------------
-
-static void
-on_termination_signal (EV_P_ ev_signal *handle, int revents)
-{
-	struct server_context *ctx = ev_userdata (loop);
-	(void) handle;
-	(void) revents;
-
-	if (ctx->quitting)
-	{
-		// Double C-c from the terminal accelerates the process
-		LIST_FOR_EACH (struct client, iter, ctx->clients)
-			client_destroy (iter);
-	}
-	else
-		initiate_quit (ctx);
-}
-
-static void
-setup_signal_handlers (struct server_context *ctx)
-{
-	ev_signal_init (&ctx->sigterm_watcher, on_termination_signal, SIGTERM);
-	ev_signal_start (EV_DEFAULT_ &ctx->sigterm_watcher);
-
-	ev_signal_init (&ctx->sigint_watcher, on_termination_signal, SIGINT);
-	ev_signal_start (EV_DEFAULT_ &ctx->sigint_watcher);
-
-	(void) signal (SIGPIPE, SIG_IGN);
-}
-
-static void
-daemonize (struct server_context *ctx)
-{
-	print_status ("daemonizing...");
-
-	if (chdir ("/"))
-		exit_fatal ("%s: %s", "chdir", strerror (errno));
-
-	// Because of systemd, we need to exit the parent process _after_ writing
-	// a PID file, otherwise our grandchild would receive a SIGTERM
-	int sync_pipe[2];
-	if (pipe (sync_pipe))
-		exit_fatal ("%s: %s", "pipe", strerror (errno));
-
-	pid_t pid;
-	if ((pid = fork ()) < 0)
-		exit_fatal ("%s: %s", "fork", strerror (errno));
-	else if (pid)
-	{
-		// Wait until all write ends of the pipe are closed, which can mean
-		// either success or failure, we don't need to care
-		xclose (sync_pipe[PIPE_WRITE]);
-
-		char dummy;
-		if (read (sync_pipe[PIPE_READ], &dummy, 1) < 0)
-			exit_fatal ("%s: %s", "read", strerror (errno));
-
-		exit (EXIT_SUCCESS);
-	}
-
-	setsid ();
-	signal (SIGHUP, SIG_IGN);
-
-	if ((pid = fork ()) < 0)
-		exit_fatal ("%s: %s", "fork", strerror (errno));
-	else if (pid)
-		exit (EXIT_SUCCESS);
-
-	openlog (PROGRAM_NAME, LOG_NDELAY | LOG_NOWAIT | LOG_PID, 0);
-	g_log_message_real = log_message_syslog;
-
-	// Write the PID file (if so configured) and get rid of the pipe, so that
-	// the read() in our grandparent finally returns zero (no write ends)
-	struct error *e = NULL;
-	if (!app_lock_pid_file (ctx, &e))
-		exit_fatal ("%s", e->message);
-
-	xclose (sync_pipe[PIPE_READ]);
-	xclose (sync_pipe[PIPE_WRITE]);
-
-	// XXX: we may close our own descriptors this way, crippling ourselves;
-	//   there is no real guarantee that we will start with all three
-	//   descriptors open.  In theory we could try to enumerate the descriptors
-	//   at the start of main().
-	for (int i = 0; i < 3; i++)
-		xclose (i);
-
-	int tty = open ("/dev/null", O_RDWR);
-	if (tty != 0 || dup (0) != 1 || dup (0) != 2)
-		exit_fatal ("failed to reopen FD's: %s", strerror (errno));
-}
-
-static void
-parse_program_arguments (int argc, char **argv)
-{
-	static const struct opt opts[] =
-	{
-		{ 't', "test", NULL, 0, "self-test" },
-		{ 'd', "debug", NULL, 0, "run in debug mode" },
-		{ 'h', "help", NULL, 0, "display this help and exit" },
-		{ 'V', "version", NULL, 0, "output version information and exit" },
-		{ 'w', "write-default-cfg", "FILENAME",
-		  OPT_OPTIONAL_ARG | OPT_LONG_ONLY,
-		  "write a default configuration file and exit" },
-		{ 0, NULL, NULL, 0, NULL }
-	};
-
-	struct opt_handler oh =
-		opt_handler_make (argc, argv, opts, NULL, "JSON-RPC 2.0 demo server.");
-
-	int c;
-	while ((c = opt_handler_get (&oh)) != -1)
-	switch (c)
-	{
-	case 't':
-		test_main (argc, argv);
-		exit (EXIT_SUCCESS);
-	case 'd':
-		g_debug_mode = true;
-		break;
-	case 'h':
-		opt_handler_usage (&oh, stdout);
-		exit (EXIT_SUCCESS);
-	case 'V':
-		printf (PROGRAM_NAME " " PROGRAM_VERSION "\n");
-		exit (EXIT_SUCCESS);
-	case 'w':
-		call_simple_config_write_default (optarg, g_config_table);
-		exit (EXIT_SUCCESS);
-	default:
-		print_error ("wrong options");
-		opt_handler_usage (&oh, stderr);
-		exit (EXIT_FAILURE);
-	}
-
-	argc -= optind;
-	argv += optind;
-
-	if (argc)
-	{
-		opt_handler_usage (&oh, stderr);
-		exit (EXIT_FAILURE);
-	}
-	opt_handler_free (&oh);
-}
-
-int
-main (int argc, char *argv[])
-{
-	parse_program_arguments (argc, argv);
-
-	print_status (PROGRAM_NAME " " PROGRAM_VERSION " starting");
-
-	struct server_context ctx;
-	server_context_init (&ctx);
-
-	struct error *e = NULL;
-	if (!simple_config_update_from_file (&ctx.config, &e))
-	{
-		print_error ("error loading configuration: %s", e->message);
-		error_free (e);
-		exit (EXIT_FAILURE);
-	}
-
-	struct ev_loop *loop;
-	if (!(loop = EV_DEFAULT))
-		exit_fatal ("libev initialization failed");
-
-	ev_set_userdata (loop, &ctx);
-	setup_signal_handlers (&ctx);
-
-	LIST_PREPEND (ctx.handlers, &g_request_handler_static);
-	LIST_PREPEND (ctx.handlers, &g_request_handler_json_rpc);
-
-	if (!parse_config (&ctx, &e)
-	 || !setup_listen_fds (&ctx, &e))
-	{
-		print_error ("%s", e->message);
-		error_free (e);
-		exit (EXIT_FAILURE);
-	}
-
-	if (!g_debug_mode)
-		daemonize (&ctx);
-	else if (!app_lock_pid_file (&ctx, &e))
-		exit_fatal ("%s", e->message);
-
-	ev_run (loop, 0);
-	ev_loop_destroy (loop);
-
-	server_context_free (&ctx);
-	return EXIT_SUCCESS;
-}