aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--demo-json-rpc-server.c216
1 files changed, 206 insertions, 10 deletions
diff --git a/demo-json-rpc-server.c b/demo-json-rpc-server.c
index 8645ae3..de8a542 100644
--- a/demo-json-rpc-server.c
+++ b/demo-json-rpc-server.c
@@ -427,14 +427,25 @@ fcgi_nv_parser_push (struct fcgi_nv_parser *self, void *data, size_t len)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// TODO
+
+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
+ enum fcgi_request_state state; ///< Parsing state
+ struct str_map headers; ///< Headers
+ struct fcgi_nv_parser hdr_parser; ///< Header parser
};
// TODO
+
struct fcgi_muxer
{
struct fcgi_parser parser; ///< FastCGI message parser
@@ -492,6 +503,14 @@ struct scgi_parser
size_t headers_len; ///< Length of the netstring contents
struct str name; ///< Header name so far
struct str value; ///< Header value so far
+
+ /// Finished parsing request headers
+ void (*on_headers_read) (void *user_data);
+
+ /// Content available; len == 0 means end of file
+ void (*on_content) (void *user_data, const void *data, size_t len);
+
+ void *user_data; ///< User data passed to callbacks
};
static void
@@ -525,7 +544,8 @@ scgi_parser_push (struct scgi_parser *self,
return false;
}
- // TODO: a "on_eof" callback?
+ // Indicate end of file
+ self->on_content (self->user_data, NULL, 0);
return true;
}
@@ -621,10 +641,9 @@ scgi_parser_push (struct scgi_parser *self,
break;
}
case SCGI_READING_CONTENT:
- // TODO: a "on_content" callback?
+ self->on_content (self->user_data, self->input.str, self->input.len);
+ str_remove_slice (&self->input, 0, self->input.len);
return true;
-
- break;
}
}
@@ -684,29 +703,158 @@ server_context_free (struct server_context *self)
// returns back a JSON reply. This function may get called multiple times if
// the user sends a batch request.
+static bool
+try_advance (const char **p, const char *text)
+{
+ size_t len = strlen (text);
+ if (strncmp (*p, text, len))
+ return false;
+
+ *p += len;
+ return true;
+}
+
+static bool
+validate_json_rpc_content_type (const char *type)
+{
+ const char *content_types[] =
+ {
+ "application/json-rpc", // obsolete
+ "application/json"
+ };
+ const char *tails[] =
+ {
+ "; charset=utf-8",
+ "; charset=UTF-8",
+ ""
+ };
+
+ bool found = false;
+ for (size_t i = 0; i < N_ELEMENTS (content_types); i++)
+ if ((found = try_advance (&type, content_types[i])))
+ break;
+ if (!found)
+ return false;
+
+ for (size_t i = 0; i < N_ELEMENTS (tails); i++)
+ if ((found = try_advance (&type, tails[i])))
+ break;
+ if (!found)
+ return false;
+
+ return !*type;
+}
+
// --- Requests ----------------------------------------------------------------
// TODO: something to read in the headers and decide what to do with the request
// e.g. whether to reject it with a 404, or do JSON-RPC, or ignore it with 200
-#if 0
-// This doesn't necessarily have to be an object by itself either; we can have
-// a function that does/returns something based on the headers
-
struct request
{
+ // TODO *ctx
+
+ void *user_data; ///< User data argument for callbacks
+
+ /// Callback to write some CGI response data to the output
+ void (*write_cb) (void *user_data, const void *data, size_t len);
+
+ /// Callback to close the connection
+ void (*close_cb) (void *user_data);
+
+ struct request_handler *handler; ///< Current request handler
+ void *handler_data; ///< User data for the handler
+};
+
+struct request_handler
+{
+ /// Install ourselves as the handler for the request if applicable
+ bool (*try_handle) (struct request *request, struct str_map *headers);
+
+ /// Handle incoming data
+ void (*push_cb) (struct request *request, const void *data, size_t len);
+
+ /// Destroy the handler
+ void (*destroy_cb) (struct request *request);
};
static void
request_init (struct request *self)
{
+ memset (self, 0, sizeof *self);
}
static void
request_free (struct request *self)
{
+ // TODO: destroy the handler?
+}
+
+static void
+request_start (struct request *self, struct str_map *headers)
+{
+ bool handled = false;
+ // TODO: try request handlers registered in self->ctx
+ if (handled)
+ return;
+
+ // Unable to serve the request
+ struct str response;
+ str_init (&response);
+ str_append (&response, "404 Not Found\r\n\r\n");
+ self->write_cb (self->user_data, response.str, response.len);
+ str_free (&response);
+
+ // XXX: how will the clients behave when this happens?
+ self->close_cb (self->user_data);
+}
+
+static void
+request_push (struct request *self, const void *data, size_t len)
+{
+ if (soft_assert (self->handler))
+ self->handler->push_cb (self, data, len);
+}
+
+// --- Requests handlers -------------------------------------------------------
+
+static bool
+request_handler_json_rpc_try_handle
+ (struct request *request, struct str_map *headers)
+{
+ const char *content_type = str_map_find (headers, "CONTENT_TYPE");
+ const char *method = str_map_find (headers, "REQUEST_METHOD");
+
+ if (strcmp (method, "POST")
+ || !validate_json_rpc_content_type (content_type))
+ return false;
+
+ // TODO: install the handler, perhaps construct an object
+ return true;
+}
+
+static void
+request_handler_json_rpc_push
+ (struct request *request, const void *data, size_t len)
+{
+ // TODO: append to a buffer
+ // TODO: len == 0: process the request
}
-#endif
+
+static void
+request_handler_json_rpc_destroy (struct request *request)
+{
+ // TODO
+}
+
+struct request_handler g_request_handler_json_rpc =
+{
+ .try_handle = request_handler_json_rpc_try_handle,
+ .push_cb = request_handler_json_rpc_push,
+ .destroy_cb = request_handler_json_rpc_destroy,
+};
+
+// TODO: another request handler to respond to all GETs with a message
// --- Client communication handlers -------------------------------------------
@@ -809,16 +957,59 @@ static struct client_impl g_client_fcgi =
struct client_scgi
{
struct scgi_parser parser; ///< SCGI stream parser
+ struct request request; ///< Request
};
static void
+client_scgi_write (void *user_data, const void *data, size_t len)
+{
+ struct client *client = user_data;
+ client_write (client, data, len);
+}
+
+static void
+client_scgi_close (void *user_data)
+{
+ struct client *client = user_data;
+ struct client_scgi *self = client->impl_data;
+
+ // TODO
+}
+
+static void
+client_scgi_on_headers_read (void *user_data)
+{
+ struct client *client = user_data;
+ struct client_scgi *self = client->impl_data;
+
+ request_start (&self->request, &self->parser.headers);
+}
+
+static void
+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;
+
+ // XXX: make sure this is understood as EOF
+ 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.write_cb = client_scgi_write;
+ self->request.close_cb = client_scgi_close;
+ self->request.user_data = client;
+
scgi_parser_init (&self->parser);
- // TODO: configure the 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
@@ -827,6 +1018,9 @@ client_scgi_destroy (struct client *client)
struct client_scgi *self = client->impl_data;
client->impl_data = NULL;
+ // TODO: do something more to abort the request?
+ request_free (&self->request);
+
scgi_parser_free (&self->parser);
free (self);
}
@@ -891,6 +1085,8 @@ on_client_ready (EV_P_ ev_io *watcher, int revents)
struct server_context *ctx = ev_userdata (loop);
struct client *client = watcher->data;
+ // FIXME: don't close the connection on EOF; we need to be able to keep
+ // the connection open and respond in an asynchronous manner
if (revents & EV_READ)
if (!read_loop (EV_A_ watcher, on_client_data))
goto error;