aboutsummaryrefslogtreecommitdiff
path: root/demo-json-rpc-server.c
diff options
context:
space:
mode:
Diffstat (limited to 'demo-json-rpc-server.c')
-rw-r--r--demo-json-rpc-server.c473
1 files changed, 242 insertions, 231 deletions
diff --git a/demo-json-rpc-server.c b/demo-json-rpc-server.c
index 483f701..00fdb4b 100644
--- a/demo-json-rpc-server.c
+++ b/demo-json-rpc-server.c
@@ -1,7 +1,7 @@
/*
* demo-json-rpc-server.c: JSON-RPC 2.0 demo server
*
- * Copyright (c) 2015, Přemysl Janouch <p.janouch@gmail.com>
+ * Copyright (c) 2015 - 2016, Přemysl Janouch <p.janouch@gmail.com>
* All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
@@ -756,7 +756,9 @@ static void
ws_handler_on_close_timeout (EV_P_ ev_timer *watcher, int revents)
{
struct ws_handler *self = watcher->data;
- // TODO: call "close_cb"
+ // TODO: anything else to do here? Invalidate our state?
+ if (self->close_cb)
+ self->close_cb (self->user_data);
}
static void
@@ -1002,7 +1004,7 @@ ws_handler_finish_handshake (struct ws_handler *self)
if (!can_upgrade)
FAIL_HANDSHAKE (HTTP_400_BAD_REQUEST, NULL);
- // Okay, we've finally got past basic HTTP/1.1 stuff
+ // 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);
@@ -1733,6 +1735,7 @@ static void
request_handler_static_destroy (struct request *request)
{
(void) request;
+ // Nothing to dispose of this far
}
struct request_handler g_request_handler_static =
@@ -1748,6 +1751,7 @@ struct client
{
LIST_HEADER (struct client)
+ // XXX: do we really need this here?
struct server_context *ctx; ///< Server context
int socket_fd; ///< The TCP socket
@@ -1756,19 +1760,16 @@ struct client
ev_io read_watcher; ///< The socket can be read from
ev_io write_watcher; ///< The socket can be written to
- struct client_impl *impl; ///< Client behaviour
- void *impl_data; ///< Client behaviour data
+ struct client_vtable *vtable; ///< Client behaviour
};
-struct client_impl
+struct client_vtable
{
- /// Initialize the client as needed
- void (*init) (struct client *client);
-
/// Attempt a graceful shutdown
void (*shutdown) (struct client *client);
/// Do any additional cleanup
+ // TODO: rename to "finalize" or "cleanup"?
void (*destroy) (struct client *client);
/// Process incoming data; "len == 0" means EOF
@@ -1776,53 +1777,122 @@ struct client_impl
};
static void
-client_init (struct client *self)
-{
- memset (self, 0, sizeof *self);
- write_queue_init (&self->write_queue);
-}
-
-static void
client_free (struct client *self)
{
write_queue_free (&self->write_queue);
}
static void
-client_write (struct client *client, const void *data, size_t len)
+client_write (struct client *self, const void *data, size_t len)
{
write_req_t *req = xcalloc (1, sizeof *req);
req->data.iov_base = memcpy (xmalloc (len), data, len);
req->data.iov_len = len;
- write_queue_add (&client->write_queue, req);
- ev_io_start (EV_DEFAULT_ &client->write_watcher);
+ write_queue_add (&self->write_queue, req);
+ ev_io_start (EV_DEFAULT_ &self->write_watcher);
}
static void
-client_remove (struct client *client)
+client_destroy (struct client *self)
{
- struct server_context *ctx = client->ctx;
+ struct server_context *ctx = self->ctx;
- LIST_UNLINK (ctx->clients, client);
+ LIST_UNLINK (ctx->clients, self);
ctx->n_clients--;
// First uninitialize the higher-level implementation
- client->impl->destroy (client);
+ self->vtable->destroy (self);
- ev_io_stop (EV_DEFAULT_ &client->read_watcher);
- ev_io_stop (EV_DEFAULT_ &client->write_watcher);
- xclose (client->socket_fd);
- client_free (client);
- free (client);
+ ev_io_stop (EV_DEFAULT_ &self->read_watcher);
+ ev_io_stop (EV_DEFAULT_ &self->write_watcher);
+ xclose (self->socket_fd);
+ client_free (self);
+ free (self);
try_finish_quit (ctx);
}
-// - - FastCGI - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static bool
+client_read_loop (EV_P_ struct client *client, ev_io *watcher)
+{
+ char buf[8192];
+ while (true)
+ {
+ ssize_t n_read = recv (watcher->fd, buf, sizeof buf, 0);
+ if (n_read >= 0)
+ {
+ if (!client->vtable->push (client, buf, n_read))
+ return false;
+ if (!n_read)
+ break;
+ }
+ else if (errno == EAGAIN)
+ return true;
+ else if (errno != EINTR)
+ return false;
+ }
+
+ // Don't receive the EOF condition repeatedly
+ ev_io_stop (EV_A_ watcher);
+
+ // We can probably still write, so let's just return
+ // XXX: if there's nothing to be written, shouldn't we close the connection?
+ return true;
+}
+
+static void
+on_client_ready (EV_P_ ev_io *watcher, int revents)
+{
+ struct client *client = watcher->data;
+
+ if (revents & EV_READ)
+ if (!client_read_loop (EV_A_ client, watcher))
+ goto close;
+ if (revents & EV_WRITE)
+ // TODO: add "closing link" functionality -> automatic shutdown
+ // (half-close) once we manage to flush the write buffer,
+ // which is logically followed by waiting for an EOF from the client
+ // TODO: some sort of "on_buffers_flushed" callback for streaming huge
+ // chunks of external (or generated) data.
+ if (!flush_queue (&client->write_queue, watcher))
+ goto close;
+ return;
+
+close:
+ client_destroy (client);
+}
+
+static void
+client_init (EV_P_ struct client *self, int sock_fd)
+{
+ struct server_context *ctx = ev_userdata (loop);
+
+ memset (self, 0, sizeof *self);
+ write_queue_init (&self->write_queue);
+
+ set_blocking (sock_fd, false);
+ self->socket_fd = sock_fd;
+
+ ev_io_init (&self->read_watcher, on_client_ready, sock_fd, EV_READ);
+ ev_io_init (&self->write_watcher, on_client_ready, 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++;
+}
+
+// --- FastCGI client handler --------------------------------------------------
struct client_fcgi
{
+ struct client client; ///< Parent class
struct fcgi_muxer muxer; ///< FastCGI de/multiplexer
};
@@ -1832,33 +1902,39 @@ struct client_fcgi_request
struct request request; ///< Request
};
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
static void
-client_fcgi_request_write (void *user_data, const void *data, size_t len)
+client_fcgi_request_write_cb (void *user_data, const void *data, size_t len)
{
struct client_fcgi_request *request = user_data;
fcgi_request_write (request->fcgi_request, data, len);
}
static void
-client_fcgi_request_close (void *user_data)
+client_fcgi_request_close_cb (void *user_data)
{
struct client_fcgi_request *request = user_data;
- // TODO: fcgi_request_finish()? That will most probably end up with us
- // receiving client_fcgi_request_destroy()
+ // No more data to send, terminate the substream/request
+ // XXX: this will most probably end up with client_fcgi_request_destroy(),
+ // we might or might not need to defer this action
+ fcgi_request_finish (request->fcgi_request);
}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
static void *
client_fcgi_request_start (void *user_data, struct fcgi_request *fcgi_request)
{
- struct client *client = user_data;
+ struct client_fcgi *self = user_data;
// TODO: what if the request is aborted by ;
- struct client_fcgi_request *request = xmalloc (sizeof *request);
+ struct client_fcgi_request *request = xcalloc (1, sizeof *request);
request->fcgi_request = fcgi_request;
request_init (&request->request);
- request->request.ctx = client->ctx;
- request->request.write_cb = client_fcgi_request_write;
- request->request.close_cb = client_fcgi_request_close;
+ request->request.ctx = self->client.ctx;
+ request->request.write_cb = client_fcgi_request_write_cb;
+ request->request.close_cb = client_fcgi_request_close_cb;
request->request.user_data = request;
return request;
}
@@ -1875,42 +1951,33 @@ client_fcgi_request_destroy (void *handler_data)
{
struct client_fcgi_request *request = handler_data;
request_free (&request->request);
- free (handler_data);
+ free (request);
}
-static void
-client_fcgi_write (void *user_data, const void *data, size_t len)
-{
- struct client *client = user_data;
- client_write (client, data, len);
-}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
static void
-client_fcgi_close (void *user_data)
+client_fcgi_write_cb (void *user_data, const void *data, size_t len)
{
- struct client *client = user_data;
- client_remove (client);
+ struct client_fcgi *self = user_data;
+ client_write (&self->client, data, len);
}
static void
-client_fcgi_init (struct client *client)
+client_fcgi_close_cb (void *user_data)
{
- struct client_fcgi *self = xcalloc (1, sizeof *self);
- client->impl_data = self;
-
- fcgi_muxer_init (&self->muxer);
- self->muxer.write_cb = client_fcgi_write;
- self->muxer.close_cb = client_fcgi_close;
- self->muxer.request_start_cb = client_fcgi_request_start;
- self->muxer.request_push_cb = client_fcgi_request_push;
- self->muxer.request_destroy_cb = client_fcgi_request_destroy;
- self->muxer.user_data = client;
+ struct client_fcgi *self = user_data;
+ // FIXME: we should probably call something like client_shutdown(),
+ // which may have an argument whether we should really use close()
+ client_destroy (&self->client);
}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
static void
client_fcgi_shutdown (struct client *client)
{
- struct client_fcgi *self = client->impl_data;
+ struct client_fcgi *self = (struct client_fcgi *) client;
// TODO: respond with FCGI_END_REQUEST: FCGI_REQUEST_COMPLETE to everything,
// and start sending out FCGI_OVERLOADED to all incoming requests. The
@@ -1920,65 +1987,79 @@ client_fcgi_shutdown (struct client *client)
static void
client_fcgi_destroy (struct client *client)
{
- struct client_fcgi *self = client->impl_data;
- client->impl_data = NULL;
-
+ struct client_fcgi *self = (struct client_fcgi *) client;
fcgi_muxer_free (&self->muxer);
- free (self);
}
static bool
client_fcgi_push (struct client *client, const void *data, size_t len)
{
- struct client_fcgi *self = client->impl_data;
+ struct client_fcgi *self = (struct client_fcgi *) client;
fcgi_muxer_push (&self->muxer, data, len);
return true;
}
-static struct client_impl g_client_fcgi =
+static struct client_vtable client_fcgi_vtable =
{
- .init = client_fcgi_init,
.shutdown = client_fcgi_shutdown,
.destroy = client_fcgi_destroy,
.push = client_fcgi_push,
};
-// - - SCGI - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+static struct client *
+client_fcgi_create (EV_P_ int sock_fd)
+{
+ struct client_fcgi *self = xcalloc (1, sizeof *self);
+ client_init (EV_A_ &self->client, 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_destroy_cb = client_fcgi_request_destroy;
+ self->muxer.user_data = self;
+ 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)
};
static void
-client_scgi_write (void *user_data, const void *data, size_t len)
+client_scgi_write_cb (void *user_data, const void *data, size_t len)
{
- struct client *client = user_data;
- client_write (client, data, len);
+ struct client_scgi *self = user_data;
+ client_write (&self->client, data, len);
}
static void
-client_scgi_close (void *user_data)
+client_scgi_close_cb (void *user_data)
{
// NOTE: this rather really means "close me [the request]"
- struct client *client = user_data;
- client_remove (client);
+ struct client_scgi *self = user_data;
+ // FIXME: we should probably call something like client_shutdown(),
+ // which may have an argument whether we should really use close()
+ client_destroy (&self->client);
}
static bool
client_scgi_on_headers_read (void *user_data)
{
- struct client *client = user_data;
- struct client_scgi *self = client->impl_data;
+ struct client_scgi *self = user_data;
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 *client = user_data;
- struct client_scgi *self = client->impl_data;
+ struct client_scgi *self = user_data;
// XXX: do we have to count CONTENT_LENGTH and supply our own EOF?
// If we do produce our own EOF, we should probably make sure we don't
@@ -1986,39 +2067,20 @@ client_scgi_on_content (void *user_data, const void *data, size_t len)
return request_push (&self->request, data, len);
}
-static void
-client_scgi_init (struct client *client)
-{
- struct client_scgi *self = xcalloc (1, sizeof *self);
- client->impl_data = self;
-
- request_init (&self->request);
- self->request.ctx = client->ctx;
- self->request.write_cb = client_scgi_write;
- self->request.close_cb = client_scgi_close;
- self->request.user_data = client;
-
- scgi_parser_init (&self->parser);
- self->parser.on_headers_read = client_scgi_on_headers_read;
- self->parser.on_content = client_scgi_on_content;
- self->parser.user_data = client;
-}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
static void
client_scgi_destroy (struct client *client)
{
- struct client_scgi *self = client->impl_data;
- client->impl_data = NULL;
-
+ struct client_scgi *self = (struct client_scgi *) client;
request_free (&self->request);
scgi_parser_free (&self->parser);
- free (self);
}
static bool
client_scgi_push (struct client *client, const void *data, size_t len)
{
- struct client_scgi *self = client->impl_data;
+ struct client_scgi *self = (struct client_scgi *) client;
struct error *e = NULL;
if (scgi_parser_push (&self->parser, data, len, &e))
return true;
@@ -2031,17 +2093,37 @@ client_scgi_push (struct client *client, const void *data, size_t len)
return false;
}
-static struct client_impl g_client_scgi =
+static struct client_vtable client_scgi_vtable =
{
- .init = client_scgi_init,
.destroy = client_scgi_destroy,
.push = client_scgi_push,
};
-// - - WebSockets - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+static struct client *
+client_scgi_create (EV_P_ int sock_fd)
+{
+ struct client_scgi *self = xcalloc (1, sizeof *self);
+ client_init (EV_A_ &self->client, sock_fd);
+ self->client.vtable = &client_scgi_vtable;
+
+ request_init (&self->request);
+ self->request.ctx = self->client.ctx;
+ self->request.write_cb = client_scgi_write_cb;
+ self->request.close_cb = client_scgi_close_cb;
+ self->request.user_data = self;
+
+ scgi_parser_init (&self->parser);
+ 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
};
@@ -2049,9 +2131,7 @@ static bool
client_ws_on_message (void *user_data,
enum ws_opcode type, const void *data, size_t len)
{
- struct client *client = user_data;
- struct client_ws *self = client->impl_data;
-
+ struct client_ws *self = user_data;
if (type != WS_OPCODE_TEXT)
{
ws_handler_fail (&self->handler, WS_STATUS_UNSUPPORTED_DATA);
@@ -2060,7 +2140,7 @@ client_ws_on_message (void *user_data,
struct str response;
str_init (&response);
- process_json_rpc (client->ctx, data, len, &response);
+ process_json_rpc (self->client.ctx, data, len, &response);
ws_handler_send (&self->handler,
WS_OPCODE_TEXT, response.str, response.len);
str_free (&response);
@@ -2068,74 +2148,78 @@ client_ws_on_message (void *user_data,
}
static void
-client_ws_write (void *user_data, const void *data, size_t len)
+client_ws_write_cb (void *user_data, const void *data, size_t len)
{
struct client *client = user_data;
client_write (client, data, len);
}
static void
-client_ws_close (void *user_data)
+client_ws_close_cb (void *user_data)
{
- struct client *client = user_data;
- client_remove (client);
+ struct client_ws *self = user_data;
+ // FIXME: we should probably call something like client_shutdown(),
+ // which may have an argument whether we should really use close()
+ client_destroy (&self->client);
}
-static void
-client_ws_init (struct client *client)
-{
- struct client_ws *self = xmalloc (sizeof *self);
- client->impl_data = self;
-
- ws_handler_init (&self->handler);
- self->handler.on_message = client_ws_on_message;
- self->handler.write_cb = client_ws_write;
- self->handler.close_cb = client_ws_close;
- self->handler.user_data = client;
-
- // One mebibyte seems to be a reasonable value
- self->handler.max_payload_len = 1 << 10;
-}
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
static void
client_ws_shutdown (struct client *client)
{
- struct client_ws *self = client->impl_data;
+ struct client_ws *self = (struct client_ws *) client;
ws_handler_close (&self->handler, WS_STATUS_GOING_AWAY, NULL, 0);
}
static void
client_ws_destroy (struct client *client)
{
- struct client_ws *self = client->impl_data;
- client->impl_data = NULL;
-
+ struct client_ws *self = (struct client_ws *) client;
ws_handler_free (&self->handler);
- free (self);
}
static bool
client_ws_push (struct client *client, const void *data, size_t len)
{
- struct client_ws *self = client->impl_data;
+ struct client_ws *self = (struct client_ws *) client;
return ws_handler_push (&self->handler, data, len);
}
-static struct client_impl g_client_ws =
+static struct client_vtable client_ws_vtable =
{
- .init = client_ws_init,
.shutdown = client_ws_shutdown,
.destroy = client_ws_destroy,
.push = client_ws_push,
};
+static struct client *
+client_ws_create (EV_P_ int sock_fd)
+{
+ struct client_ws *self = xcalloc (1, sizeof *self);
+ client_init (EV_A_ &self->client, 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;
+ self->handler.user_data = self;
+
+ // One mebibyte seems to be a reasonable value
+ self->handler.max_payload_len = 1 << 10;
+ 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
- struct client_impl *impl; ///< Client behaviour
+ client_create_fn create; ///< Client constructor
};
static void
@@ -2171,7 +2255,7 @@ on_quit_timeout (EV_P_ ev_timer *watcher, int revents)
(void) revents;
LIST_FOR_EACH (struct client, iter, self->clients)
- client_remove (iter);
+ client_destroy (iter);
}
static void
@@ -2179,91 +2263,13 @@ initiate_quit (struct server_context *self)
{
close_listeners (self);
LIST_FOR_EACH (struct client, iter, self->clients)
- if (iter->impl->shutdown)
- iter->impl->shutdown (iter->impl_data);
+ if (iter->vtable->shutdown)
+ iter->vtable->shutdown (iter);
ev_timer_set (&self->quit_timeout_watcher, 3., 0.);
self->quitting = true;
}
-static bool
-client_read_loop (EV_P_ struct client *client, ev_io *watcher)
-{
- char buf[8192];
- while (true)
- {
- ssize_t n_read = recv (watcher->fd, buf, sizeof buf, 0);
- if (n_read >= 0)
- {
- if (!client->impl->push (client, buf, n_read))
- return false;
- if (!n_read)
- break;
- }
- else if (errno == EAGAIN)
- return true;
- else if (errno != EINTR)
- return false;
- }
-
- // Don't receive the EOF condition repeatedly
- ev_io_stop (EV_A_ watcher);
-
- // We can probably still write, so let's just return
- return true;
-}
-
-static void
-on_client_ready (EV_P_ ev_io *watcher, int revents)
-{
- struct client *client = watcher->data;
-
- if (revents & EV_READ)
- if (!client_read_loop (EV_A_ client, watcher))
- goto close;
- if (revents & EV_WRITE)
- // TODO: shouldn't we at least provide an option (to be used by a client
- // implementation if it so desires) to close the connection once we've
- // finished flushing the write queue? This should probably even be
- // the default behaviour, as it's fairly uncommon for clients to
- // shutdown the socket for writes while leaving it open for reading.
- // Actually, we should wait until the client closes the connection.
- // TODO: some sort of "on_buffers_flushed" callback for streaming huge
- // chunks of external (or generated) data.
- if (!flush_queue (&client->write_queue, watcher))
- goto close;
- return;
-
-close:
- client_remove (client);
-}
-
-static void
-make_client (EV_P_ struct client_impl *impl, int sock_fd)
-{
- struct server_context *ctx = ev_userdata (loop);
- set_blocking (sock_fd, false);
-
- struct client *client = xmalloc (sizeof *client);
- client_init (client);
- client->socket_fd = sock_fd;
- client->impl = impl;
-
- ev_io_init (&client->read_watcher, on_client_ready, sock_fd, EV_READ);
- ev_io_init (&client->write_watcher, on_client_ready, sock_fd, EV_WRITE);
- client->read_watcher.data = client;
- client->write_watcher.data = client;
-
- // We're only interested in reading as the write queue is empty now
- ev_io_start (EV_A_ &client->read_watcher);
-
- // Initialize the higher-level implementation
- client->impl->init (client);
-
- LIST_PREPEND (ctx->clients, client);
- ctx->n_clients++;
-}
-
static void
on_client_available (EV_P_ ev_io *watcher, int revents)
{
@@ -2275,7 +2281,7 @@ on_client_available (EV_P_ ev_io *watcher, int revents)
{
int sock_fd = accept (watcher->fd, NULL, NULL);
if (sock_fd != -1)
- make_client (EV_A_ listener->impl, sock_fd);
+ listener->create (EV_A_ sock_fd);
else if (errno == EAGAIN)
return;
else if (errno != EINTR && errno != ECONNABORTED)
@@ -2345,7 +2351,7 @@ listener_bind (struct addrinfo *gai_iter)
static void
listener_add (struct server_context *ctx, const char *host, const char *port,
- const struct addrinfo *gai_hints, struct client_impl *impl)
+ const struct addrinfo *gai_hints, client_create_fn create)
{
struct addrinfo *gai_result, *gai_iter;
int err = getaddrinfo (host, port, gai_hints, &gai_result);
@@ -2369,7 +2375,7 @@ listener_add (struct server_context *ctx, const char *host, const char *port,
ev_io_init (&listener->watcher, on_client_available, fd, EV_READ);
ev_io_start (EV_DEFAULT_ &listener->watcher);
listener->watcher.data = listener;
- listener->impl = impl;
+ listener->create = create;
break;
}
freeaddrinfo (gai_result);
@@ -2407,13 +2413,13 @@ setup_listen_fds (struct server_context *ctx, struct error **e)
for (size_t i = 0; i < ports_fcgi.len; i++)
listener_add (ctx, bind_host, ports_fcgi.vector[i],
- &gai_hints, &g_client_fcgi);
+ &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, &g_client_scgi);
+ &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, &g_client_ws);
+ &gai_hints, client_ws_create);
str_vector_free (&ports_fcgi);
str_vector_free (&ports_scgi);
@@ -2526,7 +2532,19 @@ on_termination_signal (EV_P_ ev_signal *handle, int revents)
(void) handle;
(void) revents;
- // TODO: initiate_quit (ctx);
+ 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
@@ -2668,14 +2686,7 @@ main (int argc, char *argv[])
exit_fatal ("libev initialization failed");
ev_set_userdata (loop, &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);
+ setup_signal_handlers (&ctx);
LIST_PREPEND (ctx.handlers, &g_request_handler_static);
LIST_PREPEND (ctx.handlers, &g_request_handler_json_rpc);