diff options
| -rw-r--r-- | json-rpc-shell.c | 563 |
1 files changed, 270 insertions, 293 deletions
diff --git a/json-rpc-shell.c b/json-rpc-shell.c index 16bc31e..0e90e01 100644 --- a/json-rpc-shell.c +++ b/json-rpc-shell.c @@ -792,124 +792,6 @@ input_el_new (void) // --- Main program ------------------------------------------------------------ -// HTTP/S and WS/S require significantly different handling. While for HTTP we -// can just use the cURL easy interface, with WebSockets it gets a bit more -// complicated and we implement it all by ourselves. -// -// Luckily on a higher level the application doesn't need to bother itself with -// the details and the backend API can be very simple. - -struct app_context; - -struct backend_iface -{ - /// Prepare the backend for RPC calls - void (*init) (struct app_context *ctx, - const char *endpoint, struct http_parser_url *url); - - /// Add an HTTP header to send with requests - void (*add_header) (struct app_context *ctx, const char *header); - - /// Make an RPC call - bool (*make_call) (struct app_context *ctx, - const char *request, bool expect_content, - struct str *buf, struct error **e); - - /// Do everything necessary to deal with ev_break(EVBREAK_ALL) - void (*on_quit) (struct app_context *ctx); - - /// Free any resources - void (*destroy) (struct app_context *ctx); -}; - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -enum ws_handler_state -{ - WS_HANDLER_CONNECTING, ///< Parsing HTTP - WS_HANDLER_OPEN, ///< Parsing WebSockets frames - WS_HANDLER_CLOSING, ///< Closing the connection - WS_HANDLER_CLOSED ///< Dead -}; - -#define BACKEND_WS_MAX_PAYLOAD_LEN UINT32_MAX - -struct ws_context -{ - // Configuration: - - char *endpoint; ///< Endpoint URL - struct http_parser_url url; ///< Parsed URL - struct str_vector extra_headers; ///< Extra headers for the handshake - - // Events: - - bool waiting_for_event; ///< Running a separate loop to wait? - struct error *e; ///< Error while waiting for event - - ev_timer timeout_watcher; ///< Connection timeout watcher - struct str *response_buffer; ///< Buffer for the incoming messages - - // The TCP transport: - - int server_fd; ///< Socket FD of the server - ev_io read_watcher; ///< Server FD read watcher - SSL_CTX *ssl_ctx; ///< SSL context - SSL *ssl; ///< SSL connection - - // WebSockets protocol handling: - - enum ws_handler_state state; ///< State - char *key; ///< Key for the current handshake - - http_parser hp; ///< HTTP parser - bool parsing_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 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 -}; - -static void -ws_context_init (struct ws_context *self) -{ - memset (self, 0, sizeof *self); - ev_timer_init (&self->timeout_watcher, NULL, 0, 0); - self->server_fd = -1; - ev_io_init (&self->read_watcher, NULL, 0, 0); - http_parser_init (&self->hp, HTTP_RESPONSE); - str_init (&self->field); - str_init (&self->value); - str_map_init (&self->headers); - self->headers.key_xfrm = tolower_ascii_strxfrm; - self->headers.free = free; - ws_parser_init (&self->parser); - str_init (&self->message_data); - str_vector_init (&self->extra_headers); -} - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -struct curl_context -{ - CURL *curl; ///< cURL handle - char curl_error[CURL_ERROR_SIZE]; ///< cURL error info buffer - struct curl_slist *headers; ///< Headers -}; - -static void -curl_context_init (struct curl_context *self) -{ - memset (self, 0, sizeof *self); -} - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - enum color_mode { COLOR_AUTO, ///< Autodetect if colours are available @@ -923,10 +805,7 @@ static struct app_context char *attrs_defaults[ATTR_COUNT]; ///< Default terminal attributes char *attrs[ATTR_COUNT]; ///< Terminal attributes - struct backend_iface *backend; ///< Our current backend - - struct ws_context ws; ///< WebSockets backend data - struct curl_context curl; ///< cURL backend data + struct backend *backend; ///< Our current backend struct config config; ///< Program configuration enum color_mode color_mode; ///< Colour output mode @@ -942,6 +821,37 @@ static struct app_context } g_ctx; +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +// HTTP/S and WS/S require significantly different handling. While for HTTP we +// can just use the cURL easy interface, with WebSockets it gets a bit more +// complicated and we implement it all by ourselves. +// +// Luckily on a higher level the application doesn't need to bother itself with +// the details and the backend API can be very simple. + +struct backend +{ + struct backend_vtable *vtable; ///< Virtual methods +}; + +struct backend_vtable +{ + /// Add an HTTP header to send with requests + void (*add_header) (struct backend *backend, const char *header); + + /// Make an RPC call + bool (*make_call) (struct backend *backend, + const char *request, bool expect_content, + struct str *buf, struct error **e); + + /// Do everything necessary to deal with ev_break(EVBREAK_ALL) + void (*on_quit) (struct backend *backend); + + /// Free any resources + void (*destroy) (struct backend *backend); +}; + // --- Configuration ----------------------------------------------------------- static void on_config_attribute_change (struct config_item *item); @@ -1227,25 +1137,65 @@ on_config_attribute_change (struct config_item *item) // --- WebSockets backend ------------------------------------------------------ -static void -backend_ws_init (struct app_context *ctx, - const char *endpoint, struct http_parser_url *url) +enum ws_handler_state { - struct ws_context *self = &ctx->ws; - ws_context_init (self); - self->endpoint = xstrdup (endpoint); - self->url = *url; + WS_HANDLER_CONNECTING, ///< Parsing HTTP + WS_HANDLER_OPEN, ///< Parsing WebSockets frames + WS_HANDLER_CLOSING, ///< Closing the connection + WS_HANDLER_CLOSED ///< Dead +}; - SSL_library_init (); - atexit (EVP_cleanup); - SSL_load_error_strings (); - atexit (ERR_free_strings); -} +#define BACKEND_WS_MAX_PAYLOAD_LEN UINT32_MAX + +struct ws_context +{ + struct backend super; ///< Parent class + struct app_context *ctx; ///< Application context + + // Configuration: + + char *endpoint; ///< Endpoint URL + struct http_parser_url url; ///< Parsed URL + struct str_vector extra_headers; ///< Extra headers for the handshake + + // Events: + + bool waiting_for_event; ///< Running a separate loop to wait? + struct error *e; ///< Error while waiting for event + + ev_timer timeout_watcher; ///< Connection timeout watcher + struct str *response_buffer; ///< Buffer for the incoming messages + + // The TCP transport: + + int server_fd; ///< Socket FD of the server + ev_io read_watcher; ///< Server FD read watcher + SSL_CTX *ssl_ctx; ///< SSL context + SSL *ssl; ///< SSL connection + + // WebSockets protocol handling: + + enum ws_handler_state state; ///< State + char *key; ///< Key for the current handshake + + http_parser hp; ///< HTTP parser + bool parsing_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 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 +}; static void -backend_ws_add_header (struct app_context *ctx, const char *header) +backend_ws_add_header (struct backend *backend, const char *header) { - str_vector_add (&ctx->ws.extra_headers, header); + struct ws_context *self = (struct ws_context *) backend; + str_vector_add (&self->extra_headers, header); } enum ws_read_result @@ -1258,10 +1208,9 @@ enum ws_read_result static enum ws_read_result backend_ws_fill_read_buffer_tls - (struct app_context *ctx, void *buf, size_t *len) + (struct ws_context *self, void *buf, size_t *len) { int n_read; - struct ws_context *self = &ctx->ws; start: n_read = SSL_read (self->ssl, buf, *len); @@ -1293,10 +1242,9 @@ start: static enum ws_read_result backend_ws_fill_read_buffer - (struct app_context *ctx, void *buf, size_t *len) + (struct ws_context *self, void *buf, size_t *len) { ssize_t n_read; - struct ws_context *self = &ctx->ws; start: n_read = recv (self->server_fd, buf, *len, 0); if (n_read > 0) @@ -1391,9 +1339,8 @@ backend_ws_on_headers_complete (http_parser *parser) } static bool -backend_ws_finish_handshake (struct app_context *ctx, struct error **e) +backend_ws_finish_handshake (struct ws_context *self, struct error **e) { - struct ws_context *self = &ctx->ws; if (self->hp.http_major != 1 || self->hp.http_minor < 1) FAIL ("incompatible HTTP version: %d.%d", self->hp.http_major, self->hp.http_minor); @@ -1429,9 +1376,8 @@ backend_ws_finish_handshake (struct app_context *ctx, struct error **e) } static bool -backend_ws_on_data (struct app_context *ctx, const void *data, size_t len) +backend_ws_on_data (struct ws_context *self, const void *data, size_t len) { - struct ws_context *self = &ctx->ws; if (self->state != WS_HANDLER_CONNECTING) return ws_parser_push (&self->parser, data, len); @@ -1449,7 +1395,7 @@ backend_ws_on_data (struct app_context *ctx, const void *data, size_t len) if (self->hp.upgrade) { struct error *e = NULL; - if (!backend_ws_finish_handshake (ctx, &e)) + if (!backend_ws_finish_handshake (self, &e)) { print_error ("WS handshake failed: %s", e->message); error_free (e); @@ -1482,9 +1428,8 @@ backend_ws_on_data (struct app_context *ctx, const void *data, size_t len) } static void -backend_ws_close_connection (struct app_context *ctx) +backend_ws_close_connection (struct ws_context *self) { - struct ws_context *self = &ctx->ws; if (self->server_fd == -1) return; @@ -1519,10 +1464,9 @@ backend_ws_on_fd_ready (EV_P_ ev_io *handle, int revents) (void) loop; (void) revents; - struct app_context *ctx = handle->data; - struct ws_context *self = &ctx->ws; + struct ws_context *self = handle->data; - enum ws_read_result (*fill_buffer)(struct app_context *, void *, size_t *) + enum ws_read_result (*fill_buffer)(struct ws_context *, void *, size_t *) = self->ssl ? backend_ws_fill_read_buffer_tls : backend_ws_fill_read_buffer; @@ -1534,7 +1478,7 @@ backend_ws_on_fd_ready (EV_P_ ev_io *handle, int revents) // Try to read some data in a non-blocking manner size_t n_read = sizeof buf; (void) set_blocking (self->server_fd, false); - enum ws_read_result result = fill_buffer (ctx, buf, &n_read); + enum ws_read_result result = fill_buffer (self, buf, &n_read); (void) set_blocking (self->server_fd, true); switch (result) @@ -1550,7 +1494,7 @@ backend_ws_on_fd_ready (EV_P_ ev_io *handle, int revents) close_connection = true; goto end; case WS_READ_OK: - if (backend_ws_on_data (ctx, buf, n_read)) + if (backend_ws_on_data (self, buf, n_read)) break; // XXX: maybe we should wait until we receive an EOF @@ -1561,26 +1505,26 @@ backend_ws_on_fd_ready (EV_P_ ev_io *handle, int revents) end: if (close_connection) - backend_ws_close_connection (ctx); + backend_ws_close_connection (self); } static bool -backend_ws_write (struct app_context *ctx, const void *data, size_t len) +backend_ws_write (struct ws_context *self, const void *data, size_t len) { - if (!soft_assert (ctx->ws.server_fd != -1)) + if (!soft_assert (self->server_fd != -1)) return false; - if (ctx->ws.ssl) + if (self->ssl) { // TODO: call SSL_get_error() to detect if a clean shutdown has occured - if (SSL_write (ctx->ws.ssl, data, len) != (int) len) + if (SSL_write (self->ssl, data, len) != (int) len) { print_debug ("%s: %s: %s", __func__, "SSL_write", ERR_error_string (ERR_get_error (), NULL)); return false; } } - else if (write (ctx->ws.server_fd, data, len) != (ssize_t) len) + else if (write (self->server_fd, data, len) != (ssize_t) len) { print_debug ("%s: %s: %s", __func__, "write", strerror (errno)); return false; @@ -1589,7 +1533,7 @@ backend_ws_write (struct app_context *ctx, const void *data, size_t len) } static bool -backend_ws_establish_connection (struct app_context *ctx, +backend_ws_establish_connection (struct ws_context *self, const char *host, const char *port, struct error **e) { struct addrinfo gai_hints, *gai_result, *gai_iter; @@ -1626,7 +1570,7 @@ backend_ws_establish_connection (struct app_context *ctx, else real_host = buf; - if (ctx->verbose) + if (self->ctx->verbose) { char *address = format_host_port_pair (real_host, port); print_status ("connecting to %s...", address); @@ -1644,15 +1588,14 @@ backend_ws_establish_connection (struct app_context *ctx, if (!gai_iter) FAIL ("connection failed"); - ctx->ws.server_fd = sockfd; + self->server_fd = sockfd; return true; } static bool -backend_ws_set_up_ssl_ctx (struct app_context *ctx) +backend_ws_set_up_ssl_ctx (struct ws_context *self) { - struct ws_context *self = &ctx->ws; - if (ctx->trust_all) + if (self->ctx->trust_all) { SSL_CTX_set_verify (self->ssl_ctx, SSL_VERIFY_NONE, NULL); return true; @@ -1660,9 +1603,9 @@ backend_ws_set_up_ssl_ctx (struct app_context *ctx) // TODO: try to resolve filenames relative to configuration directories const char *ca_file = get_config_string - (ctx->config.root, "connection.tls_ca_file"); + (self->ctx->config.root, "connection.tls_ca_file"); const char *ca_path = get_config_string - (ctx->config.root, "connection.tls_ca_path"); + (self->ctx->config.root, "connection.tls_ca_path"); if (ca_file || ca_path) { if (SSL_CTX_load_verify_locations (self->ssl_ctx, ca_file, ca_path)) @@ -1675,16 +1618,15 @@ backend_ws_set_up_ssl_ctx (struct app_context *ctx) } static bool -backend_ws_initialize_tls (struct app_context *ctx, +backend_ws_initialize_tls (struct ws_context *self, const char *server_name, struct error **e) { - struct ws_context *self = &ctx->ws; const char *error_info = NULL; if (!self->ssl_ctx) { if (!(self->ssl_ctx = SSL_CTX_new (SSLv23_client_method ()))) goto error_ssl_1; - if (!backend_ws_set_up_ssl_ctx (ctx)) + if (!backend_ws_set_up_ssl_ctx (self)) goto error_ssl_2; } @@ -1730,7 +1672,7 @@ error_ssl_1: } static bool -backend_ws_send_message (struct app_context *ctx, +backend_ws_send_message (struct ws_context *self, enum ws_opcode opcode, const void *data, size_t len) { struct str header; @@ -1755,7 +1697,7 @@ backend_ws_send_message (struct app_context *ctx, return false; str_pack_u32 (&header, mask); - bool result = backend_ws_write (ctx, header.str, header.len); + bool result = backend_ws_write (self, header.str, header.len); str_free (&header); while (result && len) { @@ -1763,7 +1705,7 @@ backend_ws_send_message (struct app_context *ctx, char masked[block_size]; memcpy (masked, data, block_size); ws_parser_unmask (masked, block_size, mask); - result = backend_ws_write (ctx, masked, block_size); + result = backend_ws_write (self, masked, block_size); len -= block_size; data = (const uint8_t *) data + block_size; @@ -1772,7 +1714,7 @@ backend_ws_send_message (struct app_context *ctx, } static bool -backend_ws_send_control (struct app_context *ctx, +backend_ws_send_control (struct ws_context *self, enum ws_opcode opcode, const void *data, size_t len) { if (len > WS_MAX_CONTROL_PAYLOAD_LEN) @@ -1782,16 +1724,14 @@ backend_ws_send_control (struct app_context *ctx, len = WS_MAX_CONTROL_PAYLOAD_LEN; } - return backend_ws_send_message (ctx, opcode, data, len); + return backend_ws_send_message (self, opcode, data, len); } static bool -backend_ws_fail (struct app_context *ctx, enum ws_status reason) +backend_ws_fail (struct ws_context *self, enum ws_status reason) { - struct ws_context *self = &ctx->ws; - uint8_t payload[2] = { reason << 8, reason }; - (void) backend_ws_send_control (ctx, WS_OPCODE_CLOSE, + (void) backend_ws_send_control (self, WS_OPCODE_CLOSE, payload, sizeof payload); // The caller should immediately proceed to close the TCP connection, @@ -1803,8 +1743,7 @@ backend_ws_fail (struct app_context *ctx, enum ws_status reason) static bool backend_ws_on_frame_header (void *user_data, const struct ws_parser *parser) { - struct app_context *ctx = user_data; - struct ws_context *self = &ctx->ws; + struct ws_context *self = user_data; // Note that we aren't expected to send any close frame before closing the // connection when the frame is unmasked @@ -1816,15 +1755,15 @@ backend_ws_on_frame_header (void *user_data, const struct ws_parser *parser) || (!ws_is_control_frame (parser->opcode) && (self->expecting_continuation && parser->opcode != WS_OPCODE_CONT)) || parser->payload_len >= 0x8000000000000000ULL) - return backend_ws_fail (ctx, WS_STATUS_PROTOCOL_ERROR); + return backend_ws_fail (self, WS_STATUS_PROTOCOL_ERROR); else if (parser->payload_len > BACKEND_WS_MAX_PAYLOAD_LEN) - return backend_ws_fail (ctx, WS_STATUS_MESSAGE_TOO_BIG); + return backend_ws_fail (self, WS_STATUS_MESSAGE_TOO_BIG); return true; } static bool backend_ws_finish_closing_handshake - (struct app_context *ctx, const struct ws_parser *parser) + (struct ws_context *self, const struct ws_parser *parser) { struct str reason; str_init (&reason); @@ -1842,31 +1781,29 @@ backend_ws_finish_closing_handshake parser->input.str + 2, parser->payload_len - 2); } - char *s = iconv_xstrdup (ctx->term_from_utf8, + char *s = iconv_xstrdup (self->ctx->term_from_utf8, reason.str, reason.len, NULL); print_status ("server closed the connection (%s)", s); str_free (&reason); free (s); - return backend_ws_send_control (ctx, WS_OPCODE_CLOSE, + return backend_ws_send_control (self, WS_OPCODE_CLOSE, parser->input.str, parser->payload_len); } static bool backend_ws_on_control_frame - (struct app_context *ctx, const struct ws_parser *parser) + (struct ws_context *self, const struct ws_parser *parser) { - struct ws_context *self = &ctx->ws; switch (parser->opcode) { case WS_OPCODE_CLOSE: // We've received an unsolicited server close if (self->state != WS_HANDLER_CLOSING) - (void) backend_ws_finish_closing_handshake (ctx, parser); - + (void) backend_ws_finish_closing_handshake (self, parser); return false; case WS_OPCODE_PING: - if (!backend_ws_send_control (ctx, WS_OPCODE_PONG, + if (!backend_ws_send_control (self, WS_OPCODE_PONG, parser->input.str, parser->payload_len)) return false; break; @@ -1875,19 +1812,17 @@ backend_ws_on_control_frame break; default: // Unknown control frame - return backend_ws_fail (ctx, WS_STATUS_PROTOCOL_ERROR); + return backend_ws_fail (self, WS_STATUS_PROTOCOL_ERROR); } return true; } static bool -backend_ws_on_message (struct app_context *ctx, +backend_ws_on_message (struct ws_context *self, enum ws_opcode type, const void *data, size_t len) { - struct ws_context *self = &ctx->ws; - if (type != WS_OPCODE_TEXT) - return backend_ws_fail (ctx, WS_STATUS_UNSUPPORTED_DATA); + return backend_ws_fail (self, WS_STATUS_UNSUPPORTED_DATA); if (!self->waiting_for_event || !self->response_buffer) { @@ -1903,15 +1838,14 @@ backend_ws_on_message (struct app_context *ctx, static bool backend_ws_on_frame (void *user_data, const struct ws_parser *parser) { - struct app_context *ctx = user_data; - struct ws_context *self = &ctx->ws; + struct ws_context *self = user_data; if (ws_is_control_frame (parser->opcode)) - return backend_ws_on_control_frame (ctx, parser); + return backend_ws_on_control_frame (self, parser); // TODO: do this rather in "on_frame_header" if (self->message_data.len + parser->payload_len > BACKEND_WS_MAX_PAYLOAD_LEN) - return backend_ws_fail (ctx, WS_STATUS_MESSAGE_TOO_BIG); + return backend_ws_fail (self, WS_STATUS_MESSAGE_TOO_BIG); if (!self->expecting_continuation) self->message_opcode = parser->opcode; @@ -1925,9 +1859,9 @@ backend_ws_on_frame (void *user_data, const struct ws_parser *parser) if (self->message_opcode == WS_OPCODE_TEXT && !utf8_validate (self->parser.input.str, self->parser.input.len)) - return backend_ws_fail (ctx, WS_STATUS_INVALID_PAYLOAD_DATA); + return backend_ws_fail (self, WS_STATUS_INVALID_PAYLOAD_DATA); - bool result = backend_ws_on_message (ctx, self->message_opcode, + bool result = backend_ws_on_message (self, self->message_opcode, self->message_data.str, self->message_data.len); str_reset (&self->message_data); return result; @@ -1939,18 +1873,15 @@ backend_ws_on_connection_timeout (EV_P_ ev_timer *handle, int revents) (void) loop; (void) revents; - struct app_context *ctx = handle->data; - struct ws_context *self = &ctx->ws; - + struct ws_context *self = handle->data; hard_assert (self->waiting_for_event); error_set (&self->e, "connection timeout"); - backend_ws_close_connection (ctx); + backend_ws_close_connection (self); } static bool -backend_ws_connect (struct app_context *ctx, struct error **e) +backend_ws_connect (struct ws_context *self, struct error **e) { - struct ws_context *self = &ctx->ws; bool result = false; char *url_schema = xstrndup (self->endpoint + @@ -1984,10 +1915,10 @@ backend_ws_connect (struct app_context *ctx, struct error **e) self->url.field_data[UF_QUERY].len); } - if (!backend_ws_establish_connection (ctx, url_host, url_port, e)) + if (!backend_ws_establish_connection (self, url_host, url_port, e)) goto fail_1; - if (use_tls && !backend_ws_initialize_tls (ctx, url_host, e)) + if (use_tls && !backend_ws_initialize_tls (self, url_host, e)) goto fail_2; unsigned char key[16]; @@ -2017,7 +1948,7 @@ backend_ws_connect (struct app_context *ctx, struct error **e) str_append_printf (&request, "%s\r\n", self->extra_headers.vector[i]); str_append_printf (&request, "\r\n"); - bool written = backend_ws_write (ctx, request.str, request.len); + bool written = backend_ws_write (self, request.str, request.len); str_free (&request); if (!written) { @@ -2033,11 +1964,11 @@ backend_ws_connect (struct app_context *ctx, struct error **e) ws_parser_init (&self->parser); self->parser.on_frame_header = backend_ws_on_frame_header; self->parser.on_frame = backend_ws_on_frame; - self->parser.user_data = ctx; + self->parser.user_data = self; ev_io_init (&self->read_watcher, backend_ws_on_fd_ready, self->server_fd, EV_READ); - self->read_watcher.data = ctx; + self->read_watcher.data = self; ev_io_start (EV_DEFAULT_ &self->read_watcher); // XXX: we should do everything non-blocking and include establishing @@ -2077,22 +2008,22 @@ fail_1: } static bool -backend_ws_make_call (struct app_context *ctx, +backend_ws_make_call (struct backend *backend, const char *request, bool expect_content, struct str *buf, struct error **e) { - struct ws_context *self = &ctx->ws; + struct ws_context *self = (struct ws_context *) backend; if (self->server_fd == -1) - if (!backend_ws_connect (ctx, e)) + if (!backend_ws_connect (self, e)) return false; while (true) { - if (backend_ws_send_message (ctx, + if (backend_ws_send_message (self, WS_OPCODE_TEXT, request, strlen (request))) break; print_status ("connection failed, reconnecting"); - if (!backend_ws_connect (ctx, e)) + if (!backend_ws_connect (self, e)) return false; } @@ -2118,9 +2049,9 @@ backend_ws_make_call (struct app_context *ctx, } static void -backend_ws_on_quit (struct app_context *ctx) +backend_ws_on_quit (struct backend *backend) { - struct ws_context *self = &ctx->ws; + struct ws_context *self = (struct ws_context *) backend; if (self->waiting_for_event && !self->e) error_set (&self->e, "aborted by user"); @@ -2128,14 +2059,14 @@ backend_ws_on_quit (struct app_context *ctx) } static void -backend_ws_destroy (struct app_context *ctx) +backend_ws_destroy (struct backend *backend) { - struct ws_context *self = &ctx->ws; + struct ws_context *self = (struct ws_context *) backend; // TODO: maybe attempt a graceful shutdown, but for that there should // probably be another backend method that runs an event loop if (self->server_fd != -1) - backend_ws_close_connection (ctx); + backend_ws_close_connection (self); free (self->endpoint); str_vector_free (&self->extra_headers); @@ -2152,17 +2083,59 @@ backend_ws_destroy (struct app_context *ctx) str_free (&self->message_data); } -static struct backend_iface g_backend_ws = +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct backend_vtable backend_ws_vtable = { - .init = backend_ws_init, .add_header = backend_ws_add_header, .make_call = backend_ws_make_call, .on_quit = backend_ws_on_quit, .destroy = backend_ws_destroy, }; +static struct backend * +backend_ws_new (struct app_context *ctx, + const char *endpoint, struct http_parser_url *url) +{ + struct ws_context *self = xcalloc (1, sizeof *self); + self->super.vtable = &backend_ws_vtable; + self->ctx = ctx; + + ev_timer_init (&self->timeout_watcher, NULL, 0, 0); + self->server_fd = -1; + ev_io_init (&self->read_watcher, NULL, 0, 0); + http_parser_init (&self->hp, HTTP_RESPONSE); + str_init (&self->field); + str_init (&self->value); + str_map_init (&self->headers); + self->headers.key_xfrm = tolower_ascii_strxfrm; + self->headers.free = free; + ws_parser_init (&self->parser); + str_init (&self->message_data); + str_vector_init (&self->extra_headers); + + self->endpoint = xstrdup (endpoint); + self->url = *url; + + SSL_library_init (); + atexit (EVP_cleanup); + SSL_load_error_strings (); + atexit (ERR_free_strings); + return &self->super; +} + // --- cURL backend ------------------------------------------------------------ +struct curl_context +{ + struct backend super; ///< Parent class + struct app_context *ctx; ///< Application context + + CURL *curl; ///< cURL handle + char curl_error[CURL_ERROR_SIZE]; ///< cURL error info buffer + struct curl_slist *headers; ///< Headers +}; + static size_t write_callback (char *ptr, size_t size, size_t nmemb, void *user_data) { @@ -2206,73 +2179,34 @@ end: } static void -backend_curl_init (struct app_context *ctx, - const char *endpoint, struct http_parser_url *url) -{ - (void) url; - curl_context_init (&ctx->curl); - - CURL *curl; - if (!(ctx->curl.curl = curl = curl_easy_init ())) - exit_fatal ("cURL initialization failed"); - - ctx->curl.headers = NULL; - ctx->curl.headers = curl_slist_append - (ctx->curl.headers, "Content-Type: application/json"); - - if (curl_easy_setopt (curl, CURLOPT_POST, 1L) - || curl_easy_setopt (curl, CURLOPT_NOPROGRESS, 1L) - || curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, ctx->curl.curl_error) - || curl_easy_setopt (curl, CURLOPT_HTTPHEADER, ctx->curl.headers) - || curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, - ctx->trust_all ? 0L : 1L) - || curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, - ctx->trust_all ? 0L : 2L) - || curl_easy_setopt (curl, CURLOPT_URL, endpoint)) - exit_fatal ("cURL setup failed"); - - if (!ctx->trust_all) - { - // TODO: try to resolve filenames relative to configuration directories - const char *ca_file = get_config_string - (ctx->config.root, "connection.tls_ca_file"); - const char *ca_path = get_config_string - (ctx->config.root, "connection.tls_ca_path"); - if ((ca_file && curl_easy_setopt (curl, CURLOPT_CAINFO, ca_file)) - || (ca_path && curl_easy_setopt (curl, CURLOPT_CAPATH, ca_path))) - exit_fatal ("cURL setup failed"); - } -} - -static void -backend_curl_add_header (struct app_context *ctx, const char *header) +backend_curl_add_header (struct backend *backend, const char *header) { - ctx->curl.headers = curl_slist_append (ctx->curl.headers, header); - if (curl_easy_setopt (ctx->curl.curl, - CURLOPT_HTTPHEADER, ctx->curl.headers)) + struct curl_context *self = (struct curl_context *) backend; + self->headers = curl_slist_append (self->headers, header); + if (curl_easy_setopt (self->curl, CURLOPT_HTTPHEADER, self->headers)) exit_fatal ("cURL setup failed"); } static bool -backend_curl_make_call (struct app_context *ctx, +backend_curl_make_call (struct backend *backend, const char *request, bool expect_content, struct str *buf, struct error **e) { - CURL *curl = ctx->curl.curl; - if (curl_easy_setopt (curl, CURLOPT_POSTFIELDS, request) - || curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE_LARGE, + struct curl_context *self = (struct curl_context *) backend; + if (curl_easy_setopt (self->curl, CURLOPT_POSTFIELDS, request) + || curl_easy_setopt (self->curl, CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t) -1) - || curl_easy_setopt (curl, CURLOPT_WRITEDATA, buf) - || curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, write_callback)) + || curl_easy_setopt (self->curl, CURLOPT_WRITEDATA, buf) + || curl_easy_setopt (self->curl, CURLOPT_WRITEFUNCTION, write_callback)) FAIL ("cURL setup failed"); CURLcode ret; - if ((ret = curl_easy_perform (curl))) - FAIL ("HTTP request failed: %s", ctx->curl.curl_error); + if ((ret = curl_easy_perform (self->curl))) + FAIL ("HTTP request failed: %s", self->curl_error); long code; char *type; - if (curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &code) - || curl_easy_getinfo (curl, CURLINFO_CONTENT_TYPE, &type)) + if (curl_easy_getinfo (self->curl, CURLINFO_RESPONSE_CODE, &code) + || curl_easy_getinfo (self->curl, CURLINFO_CONTENT_TYPE, &type)) FAIL ("cURL info retrieval failed"); if (code != 200) @@ -2288,27 +2222,69 @@ backend_curl_make_call (struct app_context *ctx, } static void -backend_curl_destroy (struct app_context *ctx) +backend_curl_destroy (struct backend *backend) { - curl_slist_free_all (ctx->curl.headers); - curl_easy_cleanup (ctx->curl.curl); + struct curl_context *self = (struct curl_context *) backend; + curl_slist_free_all (self->headers); + curl_easy_cleanup (self->curl); } -static struct backend_iface g_backend_curl = +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct backend_vtable backend_curl_vtable = { - .init = backend_curl_init, .add_header = backend_curl_add_header, .make_call = backend_curl_make_call, .destroy = backend_curl_destroy, }; +static struct backend * +backend_curl_new (struct app_context *ctx, const char *endpoint) +{ + struct curl_context *self = xcalloc (1, sizeof *self); + self->super.vtable = &backend_curl_vtable; + self->ctx = ctx; + + CURL *curl; + if (!(self->curl = curl = curl_easy_init ())) + exit_fatal ("cURL initialization failed"); + + self->headers = NULL; + self->headers = curl_slist_append + (self->headers, "Content-Type: application/json"); + + if (curl_easy_setopt (curl, CURLOPT_POST, 1L) + || curl_easy_setopt (curl, CURLOPT_NOPROGRESS, 1L) + || curl_easy_setopt (curl, CURLOPT_ERRORBUFFER, self->curl_error) + || curl_easy_setopt (curl, CURLOPT_HTTPHEADER, self->headers) + || curl_easy_setopt (curl, CURLOPT_SSL_VERIFYPEER, + self->ctx->trust_all ? 0L : 1L) + || curl_easy_setopt (curl, CURLOPT_SSL_VERIFYHOST, + self->ctx->trust_all ? 0L : 2L) + || curl_easy_setopt (curl, CURLOPT_URL, endpoint)) + exit_fatal ("cURL setup failed"); + + if (!self->ctx->trust_all) + { + // TODO: try to resolve filenames relative to configuration directories + const char *ca_file = get_config_string + (self->ctx->config.root, "connection.tls_ca_file"); + const char *ca_path = get_config_string + (self->ctx->config.root, "connection.tls_ca_path"); + if ((ca_file && curl_easy_setopt (curl, CURLOPT_CAINFO, ca_file)) + || (ca_path && curl_easy_setopt (curl, CURLOPT_CAPATH, ca_path))) + exit_fatal ("cURL setup failed"); + } + return &self->super; +} + // --- Main program ------------------------------------------------------------ static void quit (struct app_context *ctx) { - if (ctx->backend->on_quit) - ctx->backend->on_quit (ctx); + if (ctx->backend->vtable->on_quit) + ctx->backend->vtable->on_quit (ctx->backend); ev_break (EV_DEFAULT_ EVBREAK_ALL); ctx->input->vtable->hide (ctx->input); @@ -2462,7 +2438,8 @@ make_json_rpc_call (struct app_context *ctx, str_init (&buf); struct error *e = NULL; - if (!ctx->backend->make_call (ctx, req_utf8, id != NULL, &buf, &e)) + if (!ctx->backend->vtable->make_call + (ctx->backend, req_utf8, id != NULL, &buf, &e)) { print_error ("%s", e->message); error_free (e); @@ -2734,27 +2711,27 @@ main (int argc, char *argv[]) url.field_data[UF_SCHEMA].off, url.field_data[UF_SCHEMA].len); + // TODO: try to avoid the need to pass application context to backends if (!strcasecmp_ascii (url_schema, "http") || !strcasecmp_ascii (url_schema, "https")) - g_ctx.backend = &g_backend_curl; + g_ctx.backend = backend_curl_new (&g_ctx, endpoint); else if (!strcasecmp_ascii (url_schema, "ws") || !strcasecmp_ascii (url_schema, "wss")) { print_warning ("WebSocket support is experimental" " and most likely completely broken"); - g_ctx.backend = &g_backend_ws; + g_ctx.backend = backend_ws_new (&g_ctx, endpoint, &url); } else exit_fatal ("unsupported protocol"); - free (url_schema); - g_ctx.backend->init (&g_ctx, endpoint, &url); if (origin) { origin = xstrdup_printf ("Origin: %s", origin); - g_ctx.backend->add_header (&g_ctx, origin); + g_ctx.backend->vtable->add_header (g_ctx.backend, origin); } + free (origin); // We only need to convert to and from the terminal encoding setlocale (LC_CTYPE, ""); @@ -2849,13 +2826,13 @@ main (int argc, char *argv[]) free (dir); free (history_path); + g_ctx.backend->vtable->destroy (g_ctx.backend); + g_ctx.input->vtable->destroy (g_ctx.input); + iconv_close (g_ctx.term_from_utf8); iconv_close (g_ctx.term_to_utf8); - g_ctx.backend->destroy (&g_ctx); - free (origin); config_free (&g_ctx.config); free_terminal (); - g_ctx.input->vtable->destroy (g_ctx.input); ev_loop_destroy (loop); return EXIT_SUCCESS; } |