diff options
Diffstat (limited to 'xC.c')
| -rw-r--r-- | xC.c | 785 |
1 files changed, 742 insertions, 43 deletions
@@ -50,6 +50,7 @@ enum #include "common.c" #include "xD-replies.c" +#include "xC-proto.c" #include <math.h> #include <langinfo.h> @@ -1526,6 +1527,7 @@ enum buffer_line_flags BUFFER_LINE_HIGHLIGHT = 1 << 2, ///< The user was highlighted by this }; +// NOTE: This sequence must match up with xC-proto, only one lower. enum buffer_line_rendition { BUFFER_LINE_BARE, ///< Unadorned @@ -1666,6 +1668,50 @@ buffer_destroy (struct buffer *self) REF_COUNTABLE_METHODS (buffer) #define buffer_ref do_not_use_dangerous +// ~~~ Relay ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +struct client +{ + LIST_HEADER (struct client) + struct app_context *ctx; ///< Application context + + // TODO: Convert this all to TLS, and only TLS, with required client cert. + // That means replacing plumbing functions with the /other/ set from xD. + + int socket_fd; ///< The TCP socket + struct str read_buffer; ///< Unprocessed input + struct str write_buffer; ///< Output yet to be sent out + + uint32_t event_seq; ///< Outgoing message counter + bool initialized; ///< Initial sync took place + + struct poller_fd socket_event; ///< The socket can be read/written to +}; + +static struct client * +client_new (void) +{ + struct client *self = xcalloc (1, sizeof *self); + self->socket_fd = -1; + self->read_buffer = str_make (); + self->write_buffer = str_make (); + return self; +} + +static void +client_destroy (struct client *self) +{ + if (!soft_assert (self->socket_fd == -1)) + xclose (self->socket_fd); + + str_free (&self->read_buffer); + str_free (&self->write_buffer); + free (self); +} + +static void client_kill (struct client *c); +static bool client_process_buffer (struct client *c); + // ~~~ Server ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // The only real purpose of this is to abstract away TLS @@ -2079,10 +2125,19 @@ struct app_context struct str_map servers; ///< Our servers + // Relay: + + int relay_fd; ///< Listening socket FD + struct client *clients; ///< Our relay clients + + /// A single message buffer to prepare all outcoming messages within + struct relay_event_message relay_message; + // Events: struct poller_fd tty_event; ///< Terminal input event struct poller_fd signal_event; ///< Signal FD event + struct poller_fd relay_event; ///< New relay connection available struct poller_timer flush_timer; ///< Flush all open files (e.g. logs) struct poller_timer date_chg_tmr; ///< Print a date change @@ -2129,6 +2184,8 @@ struct app_context char *editor_filename; ///< The file being edited by user int terminal_suspended; ///< Terminal suspension level + // Plugins: + struct plugin *plugins; ///< Loaded plugins struct hook *input_hooks; ///< Input hooks struct hook *irc_hooks; ///< IRC hooks @@ -2197,6 +2254,8 @@ app_context_init (struct app_context *self) self->config = config_make (); poller_init (&self->poller); + self->relay_fd = -1; + self->servers = str_map_make ((str_map_free_fn) server_unref); self->servers.key_xfrm = tolower_ascii_strxfrm; @@ -2223,6 +2282,17 @@ app_context_init (struct app_context *self) } static void +app_context_relay_stop (struct app_context *self) +{ + if (self->relay_fd != -1) + { + poller_fd_reset (&self->relay_event); + xclose (self->relay_fd); + self->relay_fd = -1; + } +} + +static void app_context_free (struct app_context *self) { // Plugins can try to use of the other fields when destroyed @@ -2247,6 +2317,11 @@ app_context_free (struct app_context *self) } str_map_free (&self->buffers_by_name); + app_context_relay_stop (self); + LIST_FOR_EACH (struct client, c, self->clients) + client_kill (c); + relay_event_message_free (&self->relay_message); + str_map_free (&self->servers); poller_free (&self->poller); @@ -2285,6 +2360,7 @@ on_config_show_all_prefixes_change (struct config_item *item) refresh_prompt (ctx); } +static void on_config_relay_bind_change (struct config_item *item); static void on_config_backlog_limit_change (struct config_item *item); static void on_config_attribute_change (struct config_item *item); static void on_config_logging_change (struct config_item *item); @@ -2479,6 +2555,11 @@ static struct config_schema g_config_general[] = .comment = "Plugins to automatically load on start", .type = CONFIG_ITEM_STRING_ARRAY, .validate = config_validate_nonjunk_string }, + { .name = "relay_bind", + .comment = "Address to bind to for a user interface relay point", + .type = CONFIG_ITEM_STRING, + .validate = config_validate_nonjunk_string, + .on_change = on_config_relay_bind_change }, // Buffer history: { .name = "backlog_limit", @@ -2681,6 +2762,418 @@ serialize_configuration (struct config_item *root, struct str *output) config_item_write (root, true, output); } +// --- Relay plumbing ---------------------------------------------------------- + +static void +client_kill (struct client *c) +{ + struct app_context *ctx = c->ctx; + poller_fd_reset (&c->socket_event); + xclose (c->socket_fd); + c->socket_fd = -1; + + LIST_UNLINK (ctx->clients, c); + client_destroy (c); +} + +static bool +client_try_read (struct client *c) +{ + struct str *buf = &c->read_buffer; + ssize_t n_read; + + while ((n_read = read (c->socket_fd, buf->str + buf->len, + buf->alloc - buf->len - 1 /* null byte */)) > 0) + { + buf->len += n_read; + if (!client_process_buffer (c)) + break; + str_reserve (buf, 512); + } + + if (n_read < 0) + { + if (errno == EAGAIN || errno == EINTR) + return true; + + print_debug ("%s: %s: %s", __func__, "read", strerror (errno)); + } + + client_kill (c); + return false; +} + +static bool +client_try_write (struct client *c) +{ + struct str *buf = &c->write_buffer; + ssize_t n_written; + + while (buf->len) + { + n_written = write (c->socket_fd, buf->str, buf->len); + if (n_written >= 0) + { + str_remove_slice (buf, 0, n_written); + continue; + } + if (errno == EAGAIN || errno == EINTR) + return true; + + print_debug ("%s: %s: %s", __func__, "write", strerror (errno)); + client_kill (c); + return false; + } + return true; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +client_update_poller (struct client *c, const struct pollfd *pfd) +{ + int new_events = POLLIN; + if (c->write_buffer.len) + new_events |= POLLOUT; + + hard_assert (new_events != 0); + if (!pfd || pfd->events != new_events) + poller_fd_set (&c->socket_event, new_events); +} + +static void +on_client_ready (const struct pollfd *pfd, void *user_data) +{ + struct client *c = user_data; + if (client_try_read (c) && client_try_write (c)) + client_update_poller (c, pfd); +} + +static bool +relay_try_fetch_client (struct app_context *ctx, int listen_fd) +{ + // XXX: `struct sockaddr_storage' is not the most portable thing + struct sockaddr_storage peer; + socklen_t peer_len = sizeof peer; + + int fd = accept (listen_fd, (struct sockaddr *) &peer, &peer_len); + if (fd == -1) + { + if (errno == EAGAIN || errno == EWOULDBLOCK) + return false; + if (errno == EINTR) + return true; + + if (accept_error_is_transient (errno)) + print_warning ("%s: %s", "accept", strerror (errno)); + else + print_fatal ("%s: %s", "accept", strerror (errno)); + return true; + } + + hard_assert (peer_len <= sizeof peer); + set_blocking (fd, false); + set_cloexec (fd); + + // We already buffer our output, so reduce latencies. + int yes = 1; + soft_assert (setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, + &yes, sizeof yes) != -1); + + struct client *c = client_new (); + c->ctx = ctx; + c->socket_fd = fd; + LIST_PREPEND (ctx->clients, c); + + c->socket_event = poller_fd_make (&c->ctx->poller, c->socket_fd); + c->socket_event.dispatcher = (poller_fd_fn) on_client_ready; + c->socket_event.user_data = c; + + client_update_poller (c, NULL); + return true; +} + +static void +on_relay_client_available (const struct pollfd *pfd, void *user_data) +{ + struct app_context *ctx = user_data; + while (relay_try_fetch_client (ctx, pfd->fd)) + ; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static int +relay_listen (struct addrinfo *ai, struct error **e) +{ + int fd = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol); + if (fd == -1) + { + error_set (e, "socket: %s", strerror (errno)); + 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); + + if (bind (fd, ai->ai_addr, ai->ai_addrlen)) + error_set (e, "bind: %s", strerror (errno)); + else if (listen (fd, 16 /* arbitrary number */)) + error_set (e, "listen: %s", strerror (errno)); + else + return fd; + + xclose (fd); + return -1; +} + +static int +relay_listen_with_context (struct addrinfo *ai, struct error **e) +{ + char *address = gai_reconstruct_address (ai); + print_debug ("binding to `%s'", address); + + struct error *error = NULL; + int fd = relay_listen (ai, &error); + if (fd == -1) + { + error_set (e, "binding to `%s' failed: %s", address, error->message); + error_free (error); + } + free (address); + return fd; +} + +static bool +relay_start (struct app_context *ctx, char *address, struct error **e) +{ + const char *port = NULL, *host = tokenize_host_port (address, &port); + if (!port || !*port) + return error_set (e, "missing port"); + + struct addrinfo hints = {}, *result = NULL; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + + int err = getaddrinfo (*host ? host : NULL, port, &hints, &result); + if (err) + { + return error_set (e, "failed to resolve `%s', port `%s': %s: %s", + host, port, "getaddrinfo", gai_strerror (err)); + } + + // Just try the first one, disregarding IPv4/IPv6 ordering. + int fd = relay_listen_with_context (result, e); + freeaddrinfo (result); + if (fd == -1) + return false; + + set_blocking (fd, false); + + struct poller_fd *event = &ctx->relay_event; + *event = poller_fd_make (&ctx->poller, fd); + event->dispatcher = (poller_fd_fn) on_relay_client_available; + event->user_data = ctx; + + ctx->relay_fd = fd; + poller_fd_set (event, POLLIN); + return true; +} + +static void +on_config_relay_bind_change (struct config_item *item) +{ + struct app_context *ctx = item->user_data; + char *value = item->value.string.str; + app_context_relay_stop (ctx); + if (!value) + return; + + struct error *e = NULL; + char *address = xstrdup (value); + if (!relay_start (ctx, address, &e)) + { + // TODO: Try to make sure this finds its way to the global buffer. + print_error ("%s: %s", item->schema->name, e->message); + error_free (e); + } + free (address); +} + +// --- Relay output ------------------------------------------------------------ + +static void +relay_send (struct client *c) +{ + struct relay_event_message *m = &c->ctx->relay_message; + m->event_seq = c->event_seq++; + + // TODO: Also don't try sending anything if half-closed. + if (!c->initialized || c->socket_fd == -1) + return; + + // liberty has msg_{reader,writer} already, but they use 8-byte lengths. + size_t frame_len_pos = c->write_buffer.len, frame_len = 0; + str_pack_u32 (&c->write_buffer, 0); + if (!relay_event_message_serialize (m, &c->write_buffer) + || (frame_len = c->write_buffer.len - frame_len_pos - 4) > UINT32_MAX) + { + print_error ("serialization failed, killing client"); + client_kill (c); + return; + } + + uint32_t len = htonl (frame_len); + memcpy (c->write_buffer.str + frame_len_pos, &len, sizeof len); + client_update_poller (c, NULL); +} + +static void +relay_broadcast (struct app_context *ctx) +{ + LIST_FOR_EACH (struct client, c, ctx->clients) + relay_send (c); +} + +static struct relay_event_message * +relay_prepare (struct app_context *ctx) +{ + struct relay_event_message *m = &ctx->relay_message; + relay_event_message_free (m); + memset (m, 0, sizeof *m); + return m; +} + +static void +relay_prepare_ping (struct app_context *ctx) +{ + relay_prepare (ctx)->data.event = RELAY_EVENT_PING; +} + +static void +relay_prepare_buffer_update (struct app_context *ctx, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_update *e = &m->data.buffer_update; + e->event = RELAY_EVENT_BUFFER_UPDATE; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_buffer_rename (struct app_context *ctx, struct buffer *buffer, + const char *new_name) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_rename *e = &m->data.buffer_rename; + e->event = RELAY_EVENT_BUFFER_RENAME; + e->buffer_name = str_from_cstr (buffer->name); + e->new = str_from_cstr (new_name); +} + +static void +relay_prepare_buffer_remove (struct app_context *ctx, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_remove *e = &m->data.buffer_remove; + e->event = RELAY_EVENT_BUFFER_REMOVE; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_buffer_activate (struct app_context *ctx, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_activate *e = &m->data.buffer_activate; + e->event = RELAY_EVENT_BUFFER_ACTIVATE; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_buffer_line (struct app_context *ctx, struct buffer *buffer, + struct buffer_line *line) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_line *e = &m->data.buffer_line; + e->event = RELAY_EVENT_BUFFER_LINE; + e->buffer_name = str_from_cstr (buffer->name); + e->is_unimportant = !!(line->flags & BUFFER_LINE_UNIMPORTANT); + e->is_highlight = !!(line->flags & BUFFER_LINE_HIGHLIGHT); + e->rendition = 1 + line->r; + e->when = line->when; + + size_t len = 0; + for (size_t i = 0; line->items[i].type; i++) + len++; + + // XXX: This way helps xP's JSON conversion, but is super annoying for us. + union relay_item_data *p = e->items = xcalloc (len * 6, sizeof *e->items); + for (struct formatter_item *i = line->items; len--; i++) + { + switch (i->type) + { + case FORMATTER_ITEM_TEXT: + p->text.text = str_from_cstr (i->text); + (p++)->kind = RELAY_ITEM_TEXT; + break; + case FORMATTER_ITEM_ATTR: + // For future consideration. + (p++)->kind = RELAY_ITEM_RESET; + break; + case FORMATTER_ITEM_FG_COLOR: + p->fg_color.color = i->color; + (p++)->kind = RELAY_ITEM_FG_COLOR; + break; + case FORMATTER_ITEM_BG_COLOR: + p->bg_color.color = i->color; + (p++)->kind = RELAY_ITEM_BG_COLOR; + break; + case FORMATTER_ITEM_SIMPLE: + if (i->attribute & TEXT_BOLD) + (p++)->kind = RELAY_ITEM_FLIP_BOLD; + if (i->attribute & TEXT_ITALIC) + (p++)->kind = RELAY_ITEM_FLIP_ITALIC; + if (i->attribute & TEXT_UNDERLINE) + (p++)->kind = RELAY_ITEM_FLIP_UNDERLINE; + if (i->attribute & TEXT_INVERSE) + (p++)->kind = RELAY_ITEM_FLIP_INVERSE; + if (i->attribute & TEXT_CROSSED_OUT) + (p++)->kind = RELAY_ITEM_FLIP_CROSSED_OUT; + if (i->attribute & TEXT_MONOSPACE) + (p++)->kind = RELAY_ITEM_FLIP_MONOSPACE; + break; + default: + break; + } + } + + e->items_len = p - e->items; +} + +static void +relay_prepare_buffer_clear (struct app_context *ctx, + struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_buffer_clear *e = &m->data.buffer_clear; + e->event = RELAY_EVENT_BUFFER_CLEAR; + e->buffer_name = str_from_cstr (buffer->name); +} + +static void +relay_prepare_error (struct app_context *ctx, uint32_t seq, const char *message) +{ + struct relay_event_message *m = relay_prepare (ctx); + struct relay_event_data_error *e = &m->data.error; + e->event = RELAY_EVENT_ERROR; + e->command_seq = seq; + e->error = str_from_cstr (message); +} + // --- Terminal output --------------------------------------------------------- /// Default colour pair @@ -4089,6 +4582,9 @@ log_formatter (struct app_context *ctx, struct buffer *buffer, if (buffer->log_file) buffer_line_write_to_log (ctx, line, buffer->log_file); + relay_prepare_buffer_line (ctx, buffer, line); + relay_broadcast (ctx); + bool unseen_pm = buffer->type == BUFFER_PM && buffer != ctx->current_buffer && !(flags & BUFFER_LINE_UNIMPORTANT); @@ -4302,6 +4798,9 @@ buffer_add (struct app_context *ctx, struct buffer *buffer) buffer_open_log_file (ctx, buffer); + relay_prepare_buffer_update (ctx, buffer); + relay_broadcast (ctx); + // Normally this doesn't cause changes in the prompt but a prompt hook // could decide to show some information for all buffers nonetheless refresh_prompt (ctx); @@ -4328,6 +4827,9 @@ buffer_remove (struct app_context *ctx, struct buffer *buffer) if (buffer->type == BUFFER_SERVER) buffer->server->buffer = NULL; + relay_prepare_buffer_remove (ctx, buffer); + relay_broadcast (ctx); + str_map_set (&ctx->buffers_by_name, buffer->name, NULL); LIST_UNLINK_WITH_TAIL (ctx->buffers, ctx->buffers_tail, buffer); buffer_unref (buffer); @@ -4457,6 +4959,9 @@ buffer_activate (struct app_context *ctx, struct buffer *buffer) ctx->last_buffer = ctx->current_buffer; ctx->current_buffer = buffer; + relay_prepare_buffer_activate (ctx, buffer); + relay_broadcast (ctx); + refresh_prompt (ctx); } @@ -4491,12 +4996,19 @@ buffer_merge (struct app_context *ctx, merged->lines_tail = start->prev; merged->lines_count -= n; - // And append them to current lines in the buffer + // Append them to current lines in the buffer buffer->lines_tail->next = start; start->prev = buffer->lines_tail; buffer->lines_tail = tail; buffer->lines_count += n; + // And since there is no log_*() call, send them to relays manually + LIST_FOR_EACH (struct buffer_line, line, start) + { + relay_prepare_buffer_line (ctx, buffer, line); + relay_broadcast (ctx); + } + log_full (ctx, NULL, buffer, BUFFER_LINE_SKIP_FILE, BUFFER_LINE_STATUS, "End of merged content"); } @@ -4511,6 +5023,9 @@ buffer_rename (struct app_context *ctx, hard_assert (!collision); + relay_prepare_buffer_rename (ctx, buffer, new_name); + relay_broadcast (ctx); + str_map_set (&ctx->buffers_by_name, buffer->name, NULL); str_map_set (&ctx->buffers_by_name, new_name, buffer); @@ -4524,13 +5039,16 @@ buffer_rename (struct app_context *ctx, } static void -buffer_clear (struct buffer *buffer) +buffer_clear (struct app_context *ctx, struct buffer *buffer) { LIST_FOR_EACH (struct buffer_line, iter, buffer->lines) buffer_line_destroy (iter); buffer->lines = buffer->lines_tail = NULL; buffer->lines_count = 0; + + relay_prepare_buffer_clear (ctx, buffer); + relay_broadcast (ctx); } static struct buffer * @@ -5947,29 +6465,6 @@ irc_finish_connection (struct server *s, int socket, const char *hostname) refresh_prompt (s->ctx); } -/// Unwrap IPv6 addresses in format_host_port_pair() format -static void -irc_split_host_port (char *s, char **host, char **port) -{ - *host = s; - *port = "6667"; - - char *right_bracket = strchr (s, ']'); - if (s[0] == '[' && right_bracket) - { - *right_bracket = '\0'; - *host = s + 1; - s = right_bracket + 1; - } - - char *colon = strchr (s, ':'); - if (colon) - { - *colon = '\0'; - *port = colon + 1; - } -} - // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void @@ -6019,8 +6514,8 @@ irc_setup_connector (struct server *s, const struct strv *addresses) for (size_t i = 0; i < addresses->len; i++) { - char *host, *port; - irc_split_host_port (addresses->vector[i], &host, &port); + const char *port = "6667", + *host = tokenize_host_port (addresses->vector[i], &port); connector_add_target (connector, host, port); } } @@ -6062,9 +6557,8 @@ irc_setup_connector_socks (struct server *s, const struct strv *addresses, for (size_t i = 0; i < addresses->len; i++) { - char *host, *port; - irc_split_host_port (addresses->vector[i], &host, &port); - + const char *port = "6667", + *host = tokenize_host_port (addresses->vector[i], &port); if (!socks_connector_add_target (connector, host, port, e)) return false; } @@ -7644,7 +8138,7 @@ irc_on_registered (struct server *s, const char *nickname) if (command) { log_server_debug (s, "Executing \"#s\"", command); - process_input_utf8 (s->ctx, s->buffer, command, 0); + (void) process_input_utf8 (s->ctx, s->buffer, command, 0); } int64_t command_delay = get_config_integer (s->config, "command_delay"); @@ -8230,6 +8724,24 @@ irc_handle_rpl_isupport (struct server *s, const struct irc_message *msg) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static void +irc_adjust_motd (char **motd) +{ + // Heuristic, force MOTD to be monospace in graphical frontends. + if (!strchr (*motd, '\x11')) + { + struct str s = str_make (); + str_append_c (&s, '\x11'); + for (const char *p = *motd; *p; p++) + { + str_append_c (&s, *p); + if (*p == '\x0f') + str_append_c (&s, '\x11'); + } + cstr_set (motd, str_steal (&s)); + } +} + +static void irc_process_numeric (struct server *s, const struct irc_message *msg, unsigned long numeric) { @@ -8251,6 +8763,10 @@ irc_process_numeric (struct server *s, if (msg->params.len == 2) irc_try_parse_welcome_for_userhost (s, msg->params.vector[1]); break; + case IRC_RPL_MOTD: + if (copy.len) + irc_adjust_motd (©.vector[0]); + break; case IRC_RPL_ISUPPORT: irc_handle_rpl_isupport (s, msg); break; @@ -9248,7 +9764,7 @@ lua_buffer_execute (lua_State *L) struct lua_weak *wrapper = lua_weak_deref (L, &lua_buffer_info); struct buffer *buffer = wrapper->object; const char *line = lua_plugin_check_utf8 (L, 2); - process_input_utf8 (wrapper->plugin->ctx, buffer, line, 0); + (void) process_input_utf8 (wrapper->plugin->ctx, buffer, line, 0); return 0; } @@ -11304,7 +11820,7 @@ handle_command_buffer (struct handler_args *a) show_buffers_list (ctx); else if (!strcasecmp_ascii (action, "clear")) { - buffer_clear (a->buffer); + buffer_clear (ctx, a->buffer); if (a->buffer == ctx->current_buffer) buffer_print_backlog (ctx, a->buffer); } @@ -12926,8 +13442,8 @@ complete_set_value_array (struct config_item *item, const char *word, cstr_split (item->value.string.str, ",", false, &items); for (size_t i = 0; i < items.len; i++) { - struct str wrapped = str_make (), serialized = str_make (); - str_append (&wrapped, items.vector[i]); + struct str wrapped = str_from_cstr (items.vector[i]); + struct str serialized = str_make (); config_item_write_string (&serialized, &wrapped); str_free (&wrapped); @@ -13546,6 +14062,25 @@ on_display_backlog_nowrap (int count, int key, void *user_data) return display_backlog (user_data, FLUSH_OPT_NOWRAP); } +static FILE * +open_log_path (struct app_context *ctx, struct buffer *buffer, const char *path) +{ + FILE *fp = fopen (path, "rb"); + if (!fp) + { + log_global_error (ctx, + "Failed to open `#l': #l", path, strerror (errno)); + return NULL; + } + + if (buffer->log_file) + // The regular flush will log any error eventually + (void) fflush (buffer->log_file); + + set_cloexec (fileno (fp)); + return fp; +} + static bool on_display_full_log (int count, int key, void *user_data) { @@ -13555,20 +14090,13 @@ on_display_full_log (int count, int key, void *user_data) struct buffer *buffer = ctx->current_buffer; char *path = buffer_get_log_path (buffer); - FILE *full_log = fopen (path, "rb"); + FILE *full_log = open_log_path (ctx, buffer, path); if (!full_log) { - log_global_error (ctx, "Failed to open log file for #s: #l", - ctx->current_buffer->name, strerror (errno)); free (path); return false; } - if (buffer->log_file) - // The regular flush will log any error eventually - (void) fflush (buffer->log_file); - - set_cloexec (fileno (full_log)); launch_pager (ctx, fileno (full_log), buffer->name, path); fclose (full_log); free (path); @@ -14601,6 +15129,177 @@ init_poller_events (struct app_context *ctx) ctx->input_event.user_data = ctx; } +// --- Relay processing -------------------------------------------------------- + +// XXX: This could be below completion code if reset_autoaway() was higher up. + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +client_resync (struct client *c) +{ + LIST_FOR_EACH (struct buffer, buffer, c->ctx->buffers) + { + relay_prepare_buffer_update (c->ctx, buffer); + relay_send (c); + + LIST_FOR_EACH (struct buffer_line, line, buffer->lines) + { + relay_prepare_buffer_line (c->ctx, buffer, line); + relay_send (c); + } + } + + relay_prepare_buffer_activate (c->ctx, c->ctx->current_buffer); + relay_send (c); +} + +static const char * +client_message_buffer_name (const struct relay_command_message *m) +{ + switch (m->data.command) + { + case RELAY_COMMAND_BUFFER_COMPLETE: + return m->data.buffer_input.buffer_name.str; + case RELAY_COMMAND_BUFFER_INPUT: + return m->data.buffer_input.buffer_name.str; + case RELAY_COMMAND_BUFFER_ACTIVATE: + return m->data.buffer_activate.buffer_name.str; + case RELAY_COMMAND_BUFFER_LOG: + return m->data.buffer_log.buffer_name.str; + default: + return NULL; + } +} + +static void +client_process_buffer_log + (struct client *c, uint32_t seq, struct buffer *buffer) +{ + struct relay_event_message *m = relay_prepare (c->ctx); + struct relay_event_data_response *e = &m->data.response; + e->event = RELAY_EVENT_RESPONSE; + e->command_seq = seq; + e->data.command = RELAY_COMMAND_BUFFER_LOG; + + char *path = buffer_get_log_path (buffer); + FILE *fp = open_log_path (c->ctx, buffer, path); + if (fp) + { + struct str log = str_make (); + char buf[BUFSIZ]; + size_t len; + while ((len = fread (buf, 1, sizeof buf, fp))) + str_append_data (&log, buf, len); + if (ferror (fp)) + log_global_error (c->ctx, "Failed to read `#l': #l", + path, strerror (errno)); + + // On overflow, it will later fail serialization. + e->data.buffer_log.log_len = MIN (UINT32_MAX, log.len); + e->data.buffer_log.log = (uint8_t *) str_steal (&log); + fclose (fp); + } + + // XXX: We log failures to the global buffer, + // so the client just receives nothing if there is no log file. + + free (path); + relay_send (c); +} + +static bool +client_process_message (struct client *c, + struct msg_unpacker *r, struct relay_command_message *m) +{ + if (!relay_command_message_deserialize (m, r) + || msg_unpacker_get_available (r)) + { + print_error ("deserialization failed, killing client"); + return false; + } + + const char *buffer_name = client_message_buffer_name (m); + struct buffer *buffer = NULL; + if (buffer_name && !(buffer = buffer_by_name (c->ctx, buffer_name))) + { + relay_prepare_error (c->ctx, m->command_seq, "Unknown buffer"); + relay_send (c); + return true; + } + + switch (m->data.command) + { + case RELAY_COMMAND_HELLO: + if (m->data.hello.version != RELAY_VERSION) + { + // TODO: This should send back an error message and shut down. + print_error ("protocol version mismatch, killing client"); + return false; + } + c->initialized = true; + client_resync (c); + break; + case RELAY_COMMAND_PING: + relay_prepare_ping (c->ctx); + relay_send (c); + break; + case RELAY_COMMAND_ACTIVE: + reset_autoaway (c->ctx); + break; + case RELAY_COMMAND_BUFFER_COMPLETE: + // TODO: Run the completion machinery. + relay_prepare_error (c->ctx, m->command_seq, "Not implemented"); + relay_send (c); + break; + case RELAY_COMMAND_BUFFER_INPUT: + (void) process_input_utf8 (c->ctx, + buffer, m->data.buffer_input.text.str, 0); + break; + case RELAY_COMMAND_BUFFER_ACTIVATE: + buffer_activate (c->ctx, buffer); + break; + case RELAY_COMMAND_BUFFER_LOG: + client_process_buffer_log (c, m->command_seq, buffer); + break; + default: + print_warning ("unhandled client command"); + relay_prepare_error (c->ctx, m->command_seq, "Unknown command"); + relay_send (c); + } + return true; +} + +static bool +client_process_buffer (struct client *c) +{ + struct str *buf = &c->read_buffer; + size_t offset = 0; + while (true) + { + uint32_t frame_len = 0; + struct msg_unpacker r = + msg_unpacker_make (buf->str + offset, buf->len - offset); + if (!msg_unpacker_u32 (&r, &frame_len)) + break; + + r.len = MIN (r.len, sizeof frame_len + frame_len); + if (msg_unpacker_get_available (&r) < frame_len) + break; + + struct relay_command_message m = {}; + bool ok = client_process_message (c, &r, &m); + relay_command_message_free (&m); + if (!ok) + return false; + + offset += r.offset; + } + + str_remove_slice (buf, 0, offset); + return true; +} + // --- Tests ------------------------------------------------------------------- // The application is quite monolithic and can only be partially unit-tested. |