diff options
Diffstat (limited to 'json-rpc-shell.c')
| -rw-r--r-- | json-rpc-shell.c | 3493 |
1 files changed, 3493 insertions, 0 deletions
diff --git a/json-rpc-shell.c b/json-rpc-shell.c new file mode 100644 index 0000000..47ef3b8 --- /dev/null +++ b/json-rpc-shell.c @@ -0,0 +1,3493 @@ +/* + * json-rpc-shell.c: simple JSON-RPC 2.0 shell + * + * Copyright (c) 2014 - 2016, Přemysl Janouch <p@janouch.name> + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +/// Some arbitrary limit for the history file +#define HISTORY_LIMIT 10000 + +// A table of all attributes we use for output +#define ATTR_TABLE(XX) \ + XX( PROMPT, "prompt", "Terminal attrs for the prompt" ) \ + XX( RESET, "reset", "String to reset terminal attributes" ) \ + XX( WARNING, "warning", "Terminal attrs for warnings" ) \ + XX( ERROR, "error", "Terminal attrs for errors" ) \ + XX( INCOMING, "incoming", "Terminal attrs for incoming traffic" ) \ + XX( OUTGOING, "outgoing", "Terminal attrs for outgoing traffic" ) \ + XX( JSON_FIELD, "json_field", "Terminal attrs for JSON field names" ) \ + XX( JSON_NULL, "json_null", "Terminal attrs for JSON null values" ) \ + XX( JSON_BOOL, "json_bool", "Terminal attrs for JSON booleans" ) \ + XX( JSON_NUMBER, "json_number", "Terminal attrs for JSON numbers" ) \ + XX( JSON_STRING, "json_string", "Terminal attrs for JSON strings" ) + +enum +{ +#define XX(x, y, z) ATTR_ ## x, + ATTR_TABLE (XX) +#undef XX + ATTR_COUNT +}; + +// User data for logger functions to enable formatted logging +#define print_fatal_data ((void *) ATTR_ERROR) +#define print_error_data ((void *) ATTR_ERROR) +#define print_warning_data ((void *) ATTR_WARNING) + +#define LIBERTY_WANT_SSL +#define LIBERTY_WANT_PROTO_HTTP +#define LIBERTY_WANT_PROTO_WS + +#include "config.h" +#include "liberty/liberty.c" +#include "http-parser/http_parser.h" + +#include <langinfo.h> +#include <locale.h> +#include <arpa/inet.h> + +#include <ev.h> +#include <curl/curl.h> +#include <jansson.h> +#include <openssl/rand.h> + +#include <curses.h> +#include <term.h> + +/// Shorthand to set an error and return failure from the function +#define FAIL(...) \ + BLOCK_START \ + error_set (e, __VA_ARGS__); \ + return false; \ + BLOCK_END + +// --- Terminal ---------------------------------------------------------------- + +static struct +{ + bool initialized; ///< Terminal is available + bool stdout_is_tty; ///< `stdout' is a terminal + bool stderr_is_tty; ///< `stderr' is a terminal + + struct termios termios; ///< Terminal attributes + char *color_set[8]; ///< Codes to set the foreground colour +} +g_terminal; + +static bool +init_terminal (void) +{ + int tty_fd = -1; + if ((g_terminal.stderr_is_tty = isatty (STDERR_FILENO))) + tty_fd = STDERR_FILENO; + if ((g_terminal.stdout_is_tty = isatty (STDOUT_FILENO))) + tty_fd = STDOUT_FILENO; + + int err; + if (tty_fd == -1 || setupterm (NULL, tty_fd, &err) == ERR) + return false; + + if (tcgetattr (tty_fd, &g_terminal.termios)) + return false; + + // Make sure all terminal features used by us are supported + if (!set_a_foreground || !enter_bold_mode || !exit_attribute_mode) + { + del_curterm (cur_term); + return false; + } + + for (size_t i = 0; i < N_ELEMENTS (g_terminal.color_set); i++) + g_terminal.color_set[i] = xstrdup (tparm (set_a_foreground, + i, 0, 0, 0, 0, 0, 0, 0, 0)); + + return g_terminal.initialized = true; +} + +static void +free_terminal (void) +{ + if (!g_terminal.initialized) + return; + + for (size_t i = 0; i < N_ELEMENTS (g_terminal.color_set); i++) + free (g_terminal.color_set[i]); + del_curterm (cur_term); +} + +// --- User interface ---------------------------------------------------------- + +// Not trying to do anything crazy here like switchable buffers. +// Not trying to be too universal here either, it's not going to be reusable. + +struct input +{ + struct input_vtable *vtable; ///< Virtual methods + void *user_data; ///< User data for callbacks + + /// Process a single line input by the user + void (*on_input) (char *line, void *user_data); + /// User requested external line editing + void (*on_run_editor) (const char *line, void *user_data); +}; + +struct input_vtable +{ + /// Start the interface under the given program name + void (*start) (struct input *input, const char *program_name); + /// Stop the interface + void (*stop) (struct input *input); + /// Prepare or unprepare terminal for our needs + void (*prepare) (struct input *input, bool enabled); + /// Destroy the object + void (*destroy) (struct input *input); + + /// Hide the prompt if shown + void (*hide) (struct input *input); + /// Show the prompt if hidden + void (*show) (struct input *input); + /// Change the prompt string; takes ownership + void (*set_prompt) (struct input *input, char *prompt); + /// Change the current line input + bool (*replace_line) (struct input *input, const char *line); + /// Ring the terminal bell + void (*ding) (struct input *input); + + /// Load history from file + bool (*load_history) (struct input *input, const char *filename, + struct error **e); + /// Save history to file + bool (*save_history) (struct input *input, const char *filename, + struct error **e); + + /// Handle terminal resize + void (*on_terminal_resized) (struct input *input); + /// Handle terminal input + void (*on_tty_readable) (struct input *input); +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +#ifdef HAVE_READLINE + +#include <readline/readline.h> +#include <readline/history.h> + +#define INPUT_START_IGNORE RL_PROMPT_START_IGNORE +#define INPUT_END_IGNORE RL_PROMPT_END_IGNORE + +struct input_rl +{ + struct input super; ///< Parent class + + bool active; ///< Interface has been started + char *prompt; ///< The prompt we use + int prompt_shown; ///< Whether the prompt is shown now + + char *saved_line; ///< Saved line content + int saved_point; ///< Saved cursor position + int saved_mark; ///< Saved mark +}; + +/// Unfortunately Readline cannot pass us any pointer value in its callbacks +/// that would eliminate the need to use global variables ourselves +static struct input_rl *g_input_rl; + +static void +input_rl_erase (void) +{ + rl_set_prompt (""); + rl_replace_line ("", false); + rl_redisplay (); +} + +static void +input_rl_on_input (char *line) +{ + struct input_rl *self = g_input_rl; + + // The prompt should always be visible at the moment we process input keys; + // confirming it de facto hides it because we move onto a new line + if (line) + self->prompt_shown = 0; + if (line && *line) + add_history (line); + + self->super.on_input (line, self->super.user_data); + free (line); + + // Readline automatically redisplays the prompt after we're done here; + // we could have actually hidden it by now in preparation of a quit though + if (line) + self->prompt_shown++; +} + +static int +input_rl_on_run_editor (int count, int key) +{ + (void) count; + (void) key; + + struct input_rl *self = g_input_rl; + if (self->super.on_run_editor) + self->super.on_run_editor (rl_line_buffer, self->super.user_data); + return 0; +} + +static int +input_rl_on_startup (void) +{ + rl_add_defun ("run-editor", input_rl_on_run_editor, -1); + rl_bind_keyseq ("\\ee", rl_named_function ("run-editor")); + return 0; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_rl_start (struct input *input, const char *program_name) +{ + struct input_rl *self = (struct input_rl *) input; + using_history (); + // This can cause memory leaks, or maybe even a segfault. Funny, eh? + stifle_history (HISTORY_LIMIT); + + const char *slash = strrchr (program_name, '/'); + rl_readline_name = slash ? ++slash : program_name; + rl_startup_hook = input_rl_on_startup; + rl_catch_sigwinch = false; + + hard_assert (self->prompt != NULL); + rl_callback_handler_install (self->prompt, input_rl_on_input); + + self->active = true; + self->prompt_shown = 1; + g_input_rl = self; +} + +static void +input_rl_stop (struct input *input) +{ + struct input_rl *self = (struct input_rl *) input; + if (self->prompt_shown > 0) + input_rl_erase (); + + // This is okay so long as we're not called from within readline + rl_callback_handler_remove (); + + self->active = false; + self->prompt_shown = 0; + g_input_rl = NULL; +} + +static void +input_rl_prepare (struct input *input, bool enabled) +{ + (void) input; + + if (enabled) + rl_prep_terminal (true); + else + rl_deprep_terminal (); +} + +static void +input_rl_destroy (struct input *input) +{ + struct input_rl *self = (struct input_rl *) input; + + if (self->active) + input_rl_stop (input); + + free (self->saved_line); + free (self->prompt); + free (self); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_rl_hide (struct input *input) +{ + struct input_rl *self = (struct input_rl *) input; + if (!self->active || self->prompt_shown-- < 1) + return; + + hard_assert (!self->saved_line); + + self->saved_point = rl_point; + self->saved_mark = rl_mark; + self->saved_line = rl_copy_text (0, rl_end); + + input_rl_erase (); +} + +static void +input_rl_show (struct input *input) +{ + struct input_rl *self = (struct input_rl *) input; + if (!self->active || ++self->prompt_shown < 1) + return; + + hard_assert (self->saved_line); + + rl_set_prompt (self->prompt); + rl_replace_line (self->saved_line, false); + rl_point = self->saved_point; + rl_mark = self->saved_mark; + free (self->saved_line); + self->saved_line = NULL; + + rl_redisplay (); +} + +static void +input_rl_set_prompt (struct input *input, char *prompt) +{ + struct input_rl *self = (struct input_rl *) input; + free (self->prompt); + self->prompt = prompt; + + if (!self->active) + return; + + // First reset the prompt to work around a bug in readline + rl_set_prompt (""); + if (self->prompt_shown > 0) + rl_redisplay (); + + rl_set_prompt (self->prompt); + if (self->prompt_shown > 0) + rl_redisplay (); +} + +static bool +input_rl_replace_line (struct input *input, const char *line) +{ + struct input_rl *self = (struct input_rl *) input; + if (!self->active || self->prompt_shown < 1) + return false; + + rl_point = rl_mark = 0; + rl_replace_line (line, false); + rl_point = strlen (line); + rl_redisplay (); + return true; +} + +static void +input_rl_ding (struct input *input) +{ + (void) input; + rl_ding (); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static bool +input_rl_load_history (struct input *input, const char *filename, + struct error **e) +{ + (void) input; + + if (!(errno = read_history (filename))) + return true; + + error_set (e, "%s", strerror (errno)); + return false; +} + +static bool +input_rl_save_history (struct input *input, const char *filename, + struct error **e) +{ + (void) input; + + if (!(errno = write_history (filename))) + return true; + + error_set (e, "%s", strerror (errno)); + return false; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_rl_on_terminal_resized (struct input *input) +{ + // This fucks up big time on terminals with automatic wrapping such as + // rxvt-unicode or newer VTE when the current line overflows, however we + // can't do much about that + (void) input; + rl_resize_terminal (); +} + +static void +input_rl_on_tty_readable (struct input *input) +{ + (void) input; + rl_callback_read_char (); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct input_vtable input_rl_vtable = +{ + .start = input_rl_start, + .stop = input_rl_stop, + .prepare = input_rl_prepare, + .destroy = input_rl_destroy, + + .hide = input_rl_hide, + .show = input_rl_show, + .set_prompt = input_rl_set_prompt, + .replace_line = input_rl_replace_line, + .ding = input_rl_ding, + + .load_history = input_rl_load_history, + .save_history = input_rl_save_history, + + .on_terminal_resized = input_rl_on_terminal_resized, + .on_tty_readable = input_rl_on_tty_readable, +}; + +static struct input * +input_rl_new (void) +{ + struct input_rl *self = xcalloc (1, sizeof *self); + self->super.vtable = &input_rl_vtable; + return &self->super; +} + +#define input_new input_rl_new +#endif // HAVE_READLINE + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +#ifdef HAVE_EDITLINE + +#include <histedit.h> + +#define INPUT_START_IGNORE '\x01' +#define INPUT_END_IGNORE '\x01' + +struct input_el +{ + struct input super; ///< Parent class + + EditLine *editline; ///< The EditLine object + HistoryW *history; ///< The history object + char *entered_line; ///< Buffers the entered line + + bool active; ///< Interface has been started + char *prompt; ///< The prompt we use + int prompt_shown; ///< Whether the prompt is shown now + + wchar_t *saved_line; ///< Saved line content + int saved_point; ///< Saved cursor position + int saved_len; ///< Saved line length +}; + +static char * +input_el_wcstombs (const wchar_t *s) +{ + size_t len = wcstombs (NULL, s, 0); + if (len++ == (size_t) -1) + return NULL; + + char *mb = xmalloc (len); + mb[wcstombs (mb, s, len)] = 0; + return mb; +} + +static int +input_el_get_termios (int character, int fallback) +{ + if (!g_terminal.initialized) + return fallback; + + cc_t value = g_terminal.termios.c_cc[character]; + if (value == _POSIX_VDISABLE) + return fallback; + return value; +} + +static void +input_el_redisplay (struct input_el *self) +{ + char x[] = { input_el_get_termios (VREPRINT, 'R' - 0x40), 0 }; + el_push (self->editline, x); + + // We have to do this or it gets stuck and nothing is done + (void) el_gets (self->editline, NULL); +} + +static char * +input_el_make_prompt (EditLine *editline) +{ + struct input_el *self; + el_get (editline, EL_CLIENTDATA, &self); + return self->prompt ? self->prompt : ""; +} + +static char * +input_el_make_empty_prompt (EditLine *editline) +{ + (void) editline; + return ""; +} + +static void +input_el_erase (struct input_el *self) +{ + const LineInfoW *info = el_wline (self->editline); + int len = info->lastchar - info->buffer; + int point = info->cursor - info->buffer; + el_cursor (self->editline, len - point); + el_wdeletestr (self->editline, len); + + el_set (self->editline, EL_PROMPT, input_el_make_empty_prompt); + input_el_redisplay (self); +} + +static unsigned char +input_el_on_return (EditLine *editline, int key) +{ + (void) key; + + struct input_el *self; + el_get (editline, EL_CLIENTDATA, &self); + + const LineInfoW *info = el_wline (editline); + int len = info->lastchar - info->buffer; + int point = info->cursor - info->buffer; + + wchar_t *line = calloc (sizeof *info->buffer, len + 1); + memcpy (line, info->buffer, sizeof *info->buffer * len); + + if (*line) + { + HistEventW ev; + history_w (self->history, &ev, H_ENTER, line); + } + free (line); + + // Convert to a multibyte string and store it for later + const LineInfo *info_mb = el_line (editline); + self->entered_line = xstrndup + (info_mb->buffer, info_mb->lastchar - info_mb->buffer); + + // Now we need to force editline to actually print the newline + el_cursor (editline, len++ - point); + el_insertstr (editline, "\n"); + input_el_redisplay (self); + + // Finally we need to discard the old line's contents + el_wdeletestr (editline, len); + return CC_NEWLINE; +} + +static unsigned char +input_el_on_run_editor (EditLine *editline, int key) +{ + (void) key; + + struct input_el *self; + el_get (editline, EL_CLIENTDATA, &self); + + const LineInfo *info = el_line (editline); + char *line = xstrndup (info->buffer, info->lastchar - info->buffer); + if (self->super.on_run_editor) + self->super.on_run_editor (line, self->super.user_data); + free (line); + return CC_NORM; +} + +static void +input_el_install_prompt (struct input_el *self) +{ + // XXX: the ignore doesn't quite work, see https://gnats.netbsd.org/47539 + el_set (self->editline, EL_PROMPT_ESC, + input_el_make_prompt, INPUT_START_IGNORE); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_el_start (struct input *input, const char *program_name) +{ + struct input_el *self = (struct input_el *) input; + self->editline = el_init (program_name, stdin, stdout, stderr); + el_set (self->editline, EL_CLIENTDATA, self); + input_el_install_prompt (self); + el_set (self->editline, EL_SIGNAL, false); + el_set (self->editline, EL_UNBUFFERED, true); + el_set (self->editline, EL_EDITOR, "emacs"); + el_wset (self->editline, EL_HIST, history_w, self->history); + + // No, editline, it's not supposed to kill the entire line + el_set (self->editline, EL_BIND, "^w", "ed-delete-prev-word", NULL); + // Just what are you doing? + el_set (self->editline, EL_BIND, "^u", "vi-kill-line-prev", NULL); + + // It's probably better to handle this ourselves + el_set (self->editline, EL_ADDFN, + "send-line", "Send line", input_el_on_return); + el_set (self->editline, EL_BIND, "\n", "send-line", NULL); + + // It's probably better to handle this ourselves + el_set (self->editline, EL_ADDFN, + "run-editor", "Run editor to edit line", input_el_on_run_editor); + el_set (self->editline, EL_BIND, "M-e", "run-editor", NULL); + + // Source the user's defaults file + el_source (self->editline, NULL); + + self->active = true; + self->prompt_shown = 1; +} + +static void +input_el_stop (struct input *input) +{ + struct input_el *self = (struct input_el *) input; + if (self->prompt_shown > 0) + input_el_erase (self); + + el_end (self->editline); + self->editline = NULL; + + self->active = false; + self->prompt_shown = 0; +} + +static void +input_el_prepare (struct input *input, bool enabled) +{ + struct input_el *self = (struct input_el *) input; + el_set (self->editline, EL_PREP_TERM, enabled); +} + +static void +input_el_destroy (struct input *input) +{ + struct input_el *self = (struct input_el *) input; + + if (self->active) + input_el_stop (input); + + history_wend (self->history); + + free (self->saved_line); + free (self->prompt); + free (self); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_el_hide (struct input *input) +{ + struct input_el *self = (struct input_el *) input; + if (!self->active || self->prompt_shown-- < 1) + return; + + hard_assert (!self->saved_line); + + const LineInfoW *info = el_wline (self->editline); + int len = info->lastchar - info->buffer; + int point = info->cursor - info->buffer; + + wchar_t *line = calloc (sizeof *info->buffer, len + 1); + memcpy (line, info->buffer, sizeof *info->buffer * len); + el_cursor (self->editline, len - point); + el_wdeletestr (self->editline, len); + + self->saved_line = line; + self->saved_point = point; + self->saved_len = len; + + input_el_erase (self); +} + +static void +input_el_show (struct input *input) +{ + struct input_el *self = (struct input_el *) input; + if (!self->active || ++self->prompt_shown < 1) + return; + + hard_assert (self->saved_line); + + el_winsertstr (self->editline, self->saved_line); + el_cursor (self->editline, + -(self->saved_len - self->saved_point)); + free (self->saved_line); + self->saved_line = NULL; + + input_el_install_prompt (self); + input_el_redisplay (self); +} + +static void +input_el_set_prompt (struct input *input, char *prompt) +{ + struct input_el *self = (struct input_el *) input; + free (self->prompt); + self->prompt = prompt; + + if (self->prompt_shown > 0) + input_el_redisplay (self); +} + +static bool +input_el_replace_line (struct input *input, const char *line) +{ + struct input_el *self = (struct input_el *) input; + if (!self->active || self->prompt_shown < 1) + return false; + + const LineInfoW *info = el_wline (self->editline); + int len = info->lastchar - info->buffer; + int point = info->cursor - info->buffer; + el_cursor (self->editline, len - point); + el_wdeletestr (self->editline, len); + + bool success = !*line || !el_insertstr (self->editline, line); + input_el_redisplay (self); + return success; +} + +static void +input_el_ding (struct input *input) +{ + (void) input; + + const char *ding = bell ? bell : "\a"; + write (STDOUT_FILENO, ding, strlen (ding)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static bool +input_el_load_history (struct input *input, const char *filename, + struct error **e) +{ + struct input_el *self = (struct input_el *) input; + + HistEventW ev; + if (history_w (self->history, &ev, H_LOAD, filename) != -1) + return true; + + char *error = input_el_wcstombs (ev.str); + error_set (e, "%s", error); + free (error); + return false; +} + +static bool +input_el_save_history (struct input *input, const char *filename, + struct error **e) +{ + struct input_el *self = (struct input_el *) input; + + HistEventW ev; + if (history_w (self->history, &ev, H_SAVE, filename) != -1) + return true; + + char *error = input_el_wcstombs (ev.str); + error_set (e, "%s", error); + free (error); + return false; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +input_el_on_terminal_resized (struct input *input) +{ + struct input_el *self = (struct input_el *) input; + el_resize (self->editline); +} + +static void +input_el_on_tty_readable (struct input *input) +{ + // We bind the return key to process it how we need to + struct input_el *self = (struct input_el *) input; + + // el_gets() with EL_UNBUFFERED doesn't work with UTF-8, + // we must use the wide-character interface + int count = 0; + const wchar_t *buf = el_wgets (self->editline, &count); + + // Process data from our newline handler (async-friendly handling) + if (self->entered_line) + { + // We can't have anything try to hide the old prompt with the appended + // newline, it needs to stay where it is and as it is + self->prompt_shown = 0; + + self->super.on_input (self->entered_line, self->super.user_data); + free (self->entered_line); + self->entered_line = NULL; + + // Forbid editline from trying to erase the old prompt (or worse) + // and let it redisplay the prompt in its clean state + el_set (self->editline, EL_REFRESH); + self->prompt_shown = 1; + } + + if (count == 1 && buf[0] == ('D' - 0x40) /* hardcoded VEOF in editline */) + { + el_deletestr (self->editline, 1); + input_el_redisplay (self); + self->super.on_input (NULL, self->super.user_data); + } +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct input_vtable input_el_vtable = +{ + .start = input_el_start, + .stop = input_el_stop, + .prepare = input_el_prepare, + .destroy = input_el_destroy, + + .hide = input_el_hide, + .show = input_el_show, + .set_prompt = input_el_set_prompt, + .replace_line = input_el_replace_line, + .ding = input_el_ding, + + .load_history = input_el_load_history, + .save_history = input_el_save_history, + + .on_terminal_resized = input_el_on_terminal_resized, + .on_tty_readable = input_el_on_tty_readable, +}; + +static struct input * +input_el_new (void) +{ + struct input_el *self = xcalloc (1, sizeof *self); + self->super.vtable = &input_el_vtable; + + HistEventW ev; + self->history = history_winit (); + history_w (self->history, &ev, H_SETSIZE, HISTORY_LIMIT); + return &self->super; +} + +#define input_new input_el_new +#endif // HAVE_EDITLINE + +// --- Main program ------------------------------------------------------------ + +enum color_mode +{ + COLOR_AUTO, ///< Autodetect if colours are available + COLOR_ALWAYS, ///< Always use coloured output + COLOR_NEVER ///< Never use coloured output +}; + +static struct app_context +{ + ev_child child_watcher; ///< SIGCHLD watcher + ev_signal winch_watcher; ///< SIGWINCH watcher + ev_signal term_watcher; ///< SIGTERM watcher + ev_signal int_watcher; ///< SIGINT watcher + ev_io tty_watcher; ///< Terminal watcher + + struct input *input; ///< Input interface + char *attrs_defaults[ATTR_COUNT]; ///< Default terminal attributes + char *attrs[ATTR_COUNT]; ///< Terminal attributes + + struct backend *backend; ///< Our current backend + char *editor_filename; ///< File for input line editor + + struct config config; ///< Program configuration + enum color_mode color_mode; ///< Colour output mode + bool pretty_print; ///< Whether to pretty print + bool verbose; ///< Print requests + bool trust_all; ///< Don't verify peer certificates + + bool auto_id; ///< Use automatically generated ID's + int64_t next_id; ///< Next autogenerated ID + + iconv_t term_to_utf8; ///< Terminal encoding to UTF-8 + iconv_t term_from_utf8; ///< UTF-8 to terminal encoding +} +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); + +static struct config_schema g_config_connection[] = +{ + { .name = "tls_ca_file", + .comment = "OpenSSL CA bundle file", + .type = CONFIG_ITEM_STRING }, + { .name = "tls_ca_path", + .comment = "OpenSSL CA bundle path", + .type = CONFIG_ITEM_STRING }, + {} +}; + +static struct config_schema g_config_attributes[] = +{ +#define XX(x, y, z) { .name = y, .comment = z, .type = CONFIG_ITEM_STRING, \ + .on_change = on_config_attribute_change }, + ATTR_TABLE (XX) +#undef XX + {} +}; + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +load_config_connection (struct config_item *subtree, void *user_data) +{ + config_schema_apply_to_object (g_config_connection, subtree, user_data); +} + +static void +load_config_attributes (struct config_item *subtree, void *user_data) +{ + config_schema_apply_to_object (g_config_attributes, subtree, user_data); +} + +static void +register_config_modules (struct app_context *ctx) +{ + struct config *config = &ctx->config; + config_register_module (config, "connection", load_config_connection, ctx); + config_register_module (config, "attributes", load_config_attributes, ctx); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static const char * +get_config_string (struct config_item *root, const char *key) +{ + struct config_item *item = config_item_get (root, key, NULL); + hard_assert (item); + if (item->type == CONFIG_ITEM_NULL) + return NULL; + hard_assert (config_item_type_is_string (item->type)); + return item->value.string.str; +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +save_configuration (struct config_item *root, const char *path_hint) +{ + struct str data = str_make (); + str_append (&data, + "# " PROGRAM_NAME " " PROGRAM_VERSION " configuration file\n" + "#\n" + "# Relative paths are searched for in ${XDG_CONFIG_HOME:-~/.config}\n" + "# /" PROGRAM_NAME " as well as in $XDG_CONFIG_DIRS/" PROGRAM_NAME "\n" + "#\n" + "# All text must be in UTF-8.\n" + "\n"); + config_item_write (root, true, &data); + + struct error *e = NULL; + char *filename = write_configuration_file (path_hint, &data, &e); + str_free (&data); + + if (!filename) + { + print_error ("%s: %s", "saving configuration failed", e->message); + error_free (e); + } + else + print_status ("configuration written to `%s'", filename); + free (filename); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +load_configuration (struct app_context *ctx) +{ + char *filename = resolve_filename + (PROGRAM_NAME ".conf", resolve_relative_config_filename); + if (!filename) + return; + + struct error *e = NULL; + struct config_item *root = config_read_from_file (filename, &e); + free (filename); + + if (e) + { + print_error ("error loading configuration: %s", e->message); + error_free (e); + exit (EXIT_FAILURE); + } + if (root) + { + config_load (&ctx->config, root); + config_schema_call_changed (ctx->config.root); + } +} + +// --- Attributed output ------------------------------------------------------- + +typedef int (*terminal_printer_fn) (int); + +static int +putchar_stderr (int c) +{ + return fputc (c, stderr); +} + +static terminal_printer_fn +get_attribute_printer (FILE *stream) +{ + if (stream == stdout && g_terminal.stdout_is_tty) + return putchar; + if (stream == stderr && g_terminal.stderr_is_tty) + return putchar_stderr; + return NULL; +} + +static void +vprint_attributed (struct app_context *ctx, + FILE *stream, intptr_t attribute, const char *fmt, va_list ap) +{ + terminal_printer_fn printer = get_attribute_printer (stream); + if (!attribute) + printer = NULL; + + if (printer) + tputs (ctx->attrs[attribute], 1, printer); + + vfprintf (stream, fmt, ap); + + if (printer) + tputs (ctx->attrs[ATTR_RESET], 1, printer); +} + +static void +print_attributed (struct app_context *ctx, + FILE *stream, intptr_t attribute, const char *fmt, ...) +{ + va_list ap; + va_start (ap, fmt); + vprint_attributed (ctx, stream, attribute, fmt, ap); + va_end (ap); +} + +static void +log_message_attributed (void *user_data, const char *quote, const char *fmt, + va_list ap) +{ + FILE *stream = stderr; + g_ctx.input->vtable->hide (g_ctx.input); + + print_attributed (&g_ctx, stream, (intptr_t) user_data, "%s", quote); + vprint_attributed (&g_ctx, stream, (intptr_t) user_data, fmt, ap); + fputs ("\n", stream); + + g_ctx.input->vtable->show (g_ctx.input); +} + +static void +init_colors (struct app_context *ctx) +{ + char **defaults = ctx->attrs_defaults; +#define INIT_ATTR(id, ti) defaults[ATTR_ ## id] = xstrdup ((ti)) + + // Use escape sequences from terminfo if possible, and SGR as a fallback + if (init_terminal ()) + { + INIT_ATTR (PROMPT, enter_bold_mode); + INIT_ATTR (RESET, exit_attribute_mode); + INIT_ATTR (WARNING, g_terminal.color_set[COLOR_YELLOW]); + INIT_ATTR (ERROR, g_terminal.color_set[COLOR_RED]); + INIT_ATTR (INCOMING, ""); + INIT_ATTR (OUTGOING, ""); + INIT_ATTR (JSON_FIELD, enter_bold_mode); + INIT_ATTR (JSON_NULL, g_terminal.color_set[COLOR_CYAN]); + INIT_ATTR (JSON_BOOL, g_terminal.color_set[COLOR_RED]); + INIT_ATTR (JSON_NUMBER, g_terminal.color_set[COLOR_MAGENTA]); + INIT_ATTR (JSON_STRING, g_terminal.color_set[COLOR_BLUE]); + } + else + { + INIT_ATTR (PROMPT, "\x1b[1m"); + INIT_ATTR (RESET, "\x1b[0m"); + INIT_ATTR (WARNING, "\x1b[33m"); + INIT_ATTR (ERROR, "\x1b[31m"); + INIT_ATTR (INCOMING, ""); + INIT_ATTR (OUTGOING, ""); + INIT_ATTR (JSON_FIELD, "\x1b[1m"); + INIT_ATTR (JSON_NULL, "\x1b[36m"); + INIT_ATTR (JSON_BOOL, "\x1b[31m"); + INIT_ATTR (JSON_NUMBER, "\x1b[35m"); + INIT_ATTR (JSON_STRING, "\x1b[32m"); + } + +#undef INIT_ATTR + + switch (ctx->color_mode) + { + case COLOR_ALWAYS: + g_terminal.stdout_is_tty = true; + g_terminal.stderr_is_tty = true; + break; + case COLOR_AUTO: + if (!g_terminal.initialized) + { + case COLOR_NEVER: + g_terminal.stdout_is_tty = false; + g_terminal.stderr_is_tty = false; + } + } + + g_log_message_real = log_message_attributed; + + // Apply the default values so that we start with any formatting at all + config_schema_call_changed + (config_item_get (ctx->config.root, "attributes", NULL)); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static ssize_t +attr_by_name (const char *name) +{ + static const char *table[ATTR_COUNT] = + { +#define XX(x, y, z) [ATTR_ ## x] = y, + ATTR_TABLE (XX) +#undef XX + }; + + for (size_t i = 0; i < N_ELEMENTS (table); i++) + if (!strcmp (name, table[i])) + return i; + return -1; +} + +static void +on_config_attribute_change (struct config_item *item) +{ + struct app_context *ctx = item->user_data; + ssize_t id = attr_by_name (item->schema->name); + if (id != -1) + { + free (ctx->attrs[id]); + ctx->attrs[id] = xstrdup (item->type == CONFIG_ITEM_NULL + ? ctx->attrs_defaults[id] + : item->value.string.str); + } +} + +// --- WebSockets backend ------------------------------------------------------ + +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 +{ + struct backend super; ///< Parent class + struct app_context *ctx; ///< Application context + + // Configuration: + + char *endpoint; ///< Endpoint URL + struct http_parser_url url; ///< Parsed URL + struct strv 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 have_header_value; ///< Parsing header value or field? + struct str field; ///< Field part buffer + struct str value; ///< Value part buffer + struct str_map headers; ///< HTTP Headers + + struct 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 backend *backend, const char *header) +{ + struct ws_context *self = (struct ws_context *) backend; + strv_append (&self->extra_headers, header); +} + +enum ws_read_result +{ + WS_READ_OK, ///< Some data were read successfully + WS_READ_EOF, ///< The server has closed connection + WS_READ_AGAIN, ///< No more data at the moment + WS_READ_ERROR ///< General connection failure +}; + +static enum ws_read_result +backend_ws_fill_read_buffer_tls + (struct ws_context *self, void *buf, size_t *len) +{ + int n_read; +start: + n_read = SSL_read (self->ssl, buf, *len); + + const char *error_info = NULL; + switch (xssl_get_error (self->ssl, n_read, &error_info)) + { + case SSL_ERROR_NONE: + *len = n_read; + return WS_READ_OK; + case SSL_ERROR_ZERO_RETURN: + return WS_READ_EOF; + case SSL_ERROR_WANT_READ: + return WS_READ_AGAIN; + case SSL_ERROR_WANT_WRITE: + { + // Let it finish the handshake as we don't poll for writability; + // any errors are to be collected by SSL_read() in the next iteration + struct pollfd pfd = { .fd = self->server_fd, .events = POLLOUT }; + soft_assert (poll (&pfd, 1, 0) > 0); + goto start; + } + case XSSL_ERROR_TRY_AGAIN: + goto start; + default: + print_debug ("%s: %s: %s", __func__, "SSL_read", error_info); + return WS_READ_ERROR; + } +} + +static enum ws_read_result +backend_ws_fill_read_buffer + (struct ws_context *self, void *buf, size_t *len) +{ + ssize_t n_read; +start: + n_read = recv (self->server_fd, buf, *len, 0); + if (n_read > 0) + { + *len = n_read; + return WS_READ_OK; + } + if (n_read == 0) + return WS_READ_EOF; + + if (errno == EAGAIN) + return WS_READ_AGAIN; + if (errno == EINTR) + goto start; + + print_debug ("%s: %s: %s", __func__, "recv", strerror (errno)); + return WS_READ_ERROR; +} + +static bool +backend_ws_header_field_is_a_list (const char *name) +{ + // This must contain all header fields we use for anything + static const char *concatenable[] = + { SEC_WS_PROTOCOL, SEC_WS_EXTENSIONS, "Connection", "Upgrade" }; + + for (size_t i = 0; i < N_ELEMENTS (concatenable); i++) + if (!strcasecmp_ascii (name, concatenable[i])) + return true; + return false; +} + +static void +backend_ws_on_header_read (struct ws_context *self) +{ + // The HTTP parser unfolds values and removes preceding whitespace, but + // otherwise doesn't touch the values or the following whitespace. + + // RFC 7230 states that trailing whitespace is not part of a field value + char *value = self->field.str; + size_t len = self->field.len; + while (len--) + if (value[len] == '\t' || value[len] == ' ') + value[len] = '\0'; + else + break; + self->field.len = len; + + const char *field = self->field.str; + const char *current = str_map_find (&self->headers, field); + if (backend_ws_header_field_is_a_list (field) && current) + str_map_set (&self->headers, field, + xstrdup_printf ("%s, %s", current, self->value.str)); + else + // If the field cannot be concatenated, just overwrite the last value. + // Maybe we should issue a warning or something. + str_map_set (&self->headers, field, xstrdup (self->value.str)); +} + +static int +backend_ws_on_header_field (http_parser *parser, const char *at, size_t len) +{ + struct ws_context *self = parser->data; + if (self->have_header_value) + { + backend_ws_on_header_read (self); + str_reset (&self->field); + str_reset (&self->value); + } + str_append_data (&self->field, at, len); + self->have_header_value = false; + return 0; +} + +static int +backend_ws_on_header_value (http_parser *parser, const char *at, size_t len) +{ + struct ws_context *self = parser->data; + str_append_data (&self->value, at, len); + self->have_header_value = true; + return 0; +} + +static int +backend_ws_on_headers_complete (http_parser *parser) +{ + struct ws_context *self = parser->data; + if (self->have_header_value) + backend_ws_on_header_read (self); + + // We strictly require a protocol upgrade + if (!parser->upgrade) + return 2; + + return 0; +} + +static bool +backend_ws_finish_handshake (struct ws_context *self, struct error **e) +{ + 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); + + if (self->hp.status_code != 101) + // TODO: handle other codes? + FAIL ("unexpected status code: %d", self->hp.status_code); + + const char *upgrade = str_map_find (&self->headers, "Upgrade"); + if (!upgrade || strcasecmp_ascii (upgrade, "websocket")) + FAIL ("cannot upgrade connection to WebSocket"); + + const char *connection = str_map_find (&self->headers, "Connection"); + if (!connection || strcasecmp_ascii (connection, "Upgrade")) + // XXX: maybe we shouldn't be so strict and only check for presence + // of the "Upgrade" token in this list + FAIL ("cannot upgrade connection to WebSocket"); + + const char *accept = str_map_find (&self->headers, SEC_WS_ACCEPT); + char *accept_expected = ws_encode_response_key (self->key); + bool accept_ok = accept && !strcmp (accept, accept_expected); + free (accept_expected); + if (!accept_ok) + FAIL ("missing or invalid " SEC_WS_ACCEPT " header"); + + const char *extensions = str_map_find (&self->headers, SEC_WS_EXTENSIONS); + const char *protocol = str_map_find (&self->headers, SEC_WS_PROTOCOL); + if (extensions || protocol) + // TODO: actually parse these fields + FAIL ("unexpected WebSocket extension or protocol"); + + return true; +} + +static bool +backend_ws_on_data (struct ws_context *self, const void *data, size_t len) +{ + if (self->state != WS_HANDLER_CONNECTING) + return ws_parser_push (&self->parser, data, len); + + // The handshake hasn't been done yet, process HTTP headers + static const http_parser_settings http_settings = + { + .on_header_field = backend_ws_on_header_field, + .on_header_value = backend_ws_on_header_value, + .on_headers_complete = backend_ws_on_headers_complete, + }; + + size_t n_parsed = http_parser_execute (&self->hp, + &http_settings, data, len); + + if (self->hp.upgrade) + { + struct error *e = NULL; + if (!backend_ws_finish_handshake (self, &e)) + { + print_error ("WS handshake failed: %s", e->message); + error_free (e); + return false; + } + + // Finished the handshake, return to caller + // (we run a separate loop to wait for the handshake to finish) + self->state = WS_HANDLER_OPEN; + ev_break (EV_DEFAULT_ EVBREAK_ONE); + + if ((len -= n_parsed)) + return ws_parser_push (&self->parser, + (const uint8_t *) data + n_parsed, len); + + return true; + } + + enum http_errno err = HTTP_PARSER_ERRNO (&self->hp); + if (n_parsed != len || err != HPE_OK) + { + if (err == HPE_CB_headers_complete) + print_error ("WS handshake failed: %s", "missing `Upgrade' field"); + else + print_error ("WS handshake failed: %s", + http_errno_description (err)); + return false; + } + return true; +} + +static void +backend_ws_close_connection (struct ws_context *self) +{ + if (self->server_fd == -1) + return; + + ev_io_stop (EV_DEFAULT_ &self->read_watcher); + + if (self->ssl) + { + (void) SSL_shutdown (self->ssl); + SSL_free (self->ssl); + self->ssl = NULL; + } + + xclose (self->server_fd); + self->server_fd = -1; + + self->state = WS_HANDLER_CLOSED; + + // That would have no way of succeeding + // XXX: what if we're waiting for the close? + if (self->waiting_for_event) + { + if (!self->e) + error_set (&self->e, "unexpected connection close"); + + ev_break (EV_DEFAULT_ EVBREAK_ONE); + } +} + +static void +backend_ws_on_fd_ready (EV_P_ ev_io *handle, int revents) +{ + (void) loop; + (void) revents; + + struct ws_context *self = handle->data; + + 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; + bool close_connection = false; + + uint8_t buf[8192]; + while (true) + { + // 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 (self, buf, &n_read); + (void) set_blocking (self->server_fd, true); + + switch (result) + { + case WS_READ_AGAIN: + goto end; + case WS_READ_ERROR: + print_error ("reading from the server failed"); + close_connection = true; + goto end; + case WS_READ_EOF: + print_status ("the server closed the connection"); + close_connection = true; + goto end; + case WS_READ_OK: + if (backend_ws_on_data (self, buf, n_read)) + break; + + // XXX: maybe we should wait until we receive an EOF + close_connection = true; + goto end; + } + } + +end: + if (close_connection) + backend_ws_close_connection (self); +} + +static bool +backend_ws_write (struct ws_context *self, const void *data, size_t len) +{ + if (!soft_assert (self->server_fd != -1)) + return false; + + if (self->ssl) + { + // TODO: call SSL_get_error() to detect if a clean shutdown has occured + 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 (self->server_fd, data, len) != (ssize_t) len) + { + print_debug ("%s: %s: %s", __func__, "write", strerror (errno)); + return false; + } + return true; +} + +static bool +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; + memset (&gai_hints, 0, sizeof gai_hints); + gai_hints.ai_socktype = SOCK_STREAM; + + int err = getaddrinfo (host, port, &gai_hints, &gai_result); + if (err) + FAIL ("%s: %s: %s", + "connection failed", "getaddrinfo", gai_strerror (err)); + + int sockfd; + for (gai_iter = gai_result; gai_iter; gai_iter = gai_iter->ai_next) + { + sockfd = socket (gai_iter->ai_family, + gai_iter->ai_socktype, gai_iter->ai_protocol); + if (sockfd == -1) + continue; + set_cloexec (sockfd); + + int yes = 1; + soft_assert (setsockopt (sockfd, SOL_SOCKET, SO_KEEPALIVE, + &yes, sizeof yes) != -1); + + const char *real_host = host; + + // Let's try to resolve the address back into a real hostname; + // we don't really need this, so we can let it quietly fail + char buf[NI_MAXHOST]; + err = getnameinfo (gai_iter->ai_addr, gai_iter->ai_addrlen, + buf, sizeof buf, NULL, 0, NI_NUMERICHOST); + if (err) + print_debug ("%s: %s", "getnameinfo", gai_strerror (err)); + else + real_host = buf; + + if (self->ctx->verbose) + { + char *address = format_host_port_pair (real_host, port); + print_status ("connecting to %s...", address); + free (address); + } + + if (!connect (sockfd, gai_iter->ai_addr, gai_iter->ai_addrlen)) + break; + + xclose (sockfd); + } + + freeaddrinfo (gai_result); + + if (!gai_iter) + FAIL ("connection failed"); + + self->server_fd = sockfd; + return true; +} + +static bool +backend_ws_set_up_ssl_ctx (struct ws_context *self) +{ + if (self->ctx->trust_all) + { + SSL_CTX_set_verify (self->ssl_ctx, SSL_VERIFY_NONE, NULL); + return true; + } + + // 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 || ca_path) + { + if (SSL_CTX_load_verify_locations (self->ssl_ctx, ca_file, ca_path)) + return true; + print_warning ("%s: %s", + "failed to set locations for trusted CA certificates", + ERR_reason_error_string (ERR_get_error ())); + } + return SSL_CTX_set_default_verify_paths (self->ssl_ctx); +} + +static bool +backend_ws_initialize_tls (struct ws_context *self, + const char *server_name, struct error **e) +{ + 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 (self)) + goto error_ssl_2; + } + + self->ssl = SSL_new (self->ssl_ctx); + if (!self->ssl) + goto error_ssl_2; + + SSL_set_connect_state (self->ssl); + if (!SSL_set_fd (self->ssl, self->server_fd)) + goto error_ssl_3; + // Avoid SSL_write() returning SSL_ERROR_WANT_READ + SSL_set_mode (self->ssl, SSL_MODE_AUTO_RETRY); + + // Literal IP addresses aren't allowed in the SNI + struct in6_addr dummy; + if (!inet_pton (AF_INET, server_name, &dummy) + && !inet_pton (AF_INET6, server_name, &dummy)) + SSL_set_tlsext_host_name (self->ssl, server_name); + + switch (xssl_get_error (self->ssl, SSL_connect (self->ssl), &error_info)) + { + case SSL_ERROR_NONE: + return true; + case SSL_ERROR_ZERO_RETURN: + error_info = "server closed the connection"; + default: + break; + } + +error_ssl_3: + SSL_free (self->ssl); + self->ssl = NULL; +error_ssl_2: + SSL_CTX_free (self->ssl_ctx); + self->ssl_ctx = NULL; +error_ssl_1: + // XXX: these error strings are really nasty; also there could be + // multiple errors on the OpenSSL stack. + if (!error_info) + error_info = ERR_error_string (ERR_get_error (), NULL); + + FAIL ("%s: %s", "could not initialize SSL", error_info); +} + +static bool +backend_ws_send_message (struct ws_context *self, + enum ws_opcode opcode, const void *data, size_t len) +{ + struct str header = str_make (); + str_pack_u8 (&header, 0x80 | (opcode & 0x0F)); + + if (len > UINT16_MAX) + { + str_pack_u8 (&header, 0x80 | 127); + str_pack_u64 (&header, len); + } + else if (len > 125) + { + str_pack_u8 (&header, 0x80 | 126); + str_pack_u16 (&header, len); + } + else + str_pack_u8 (&header, 0x80 | len); + + uint32_t mask; + if (!RAND_bytes ((unsigned char *) &mask, sizeof mask)) + return false; + str_pack_u32 (&header, mask); + + bool result = backend_ws_write (self, header.str, header.len); + str_free (&header); + while (result && len) + { + size_t block_size = MIN (len, 1 << 16); + char masked[block_size]; + memcpy (masked, data, block_size); + ws_parser_unmask (masked, block_size, mask); + result = backend_ws_write (self, masked, block_size); + + len -= block_size; + data = (const uint8_t *) data + block_size; + } + return result; +} + +static bool +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) + { + print_debug ("truncating output control frame payload" + " from %zu to %zu bytes", len, (size_t) WS_MAX_CONTROL_PAYLOAD_LEN); + len = WS_MAX_CONTROL_PAYLOAD_LEN; + } + + return backend_ws_send_message (self, opcode, data, len); +} + +static bool +backend_ws_fail (struct ws_context *self, enum ws_status reason) +{ + uint8_t payload[2] = { reason >> 8, reason }; + (void) backend_ws_send_control (self, WS_OPCODE_CLOSE, + payload, sizeof payload); + + // The caller should immediately proceed to close the TCP connection, + // e.g. by returning false from a handler + self->state = WS_HANDLER_CLOSING; + return false; +} + +static bool +backend_ws_on_frame_header (void *user_data, const struct ws_parser *parser) +{ + 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 + + if (parser->reserved_1 || parser->reserved_2 || parser->reserved_3 + || parser->is_masked // server -> client payload must not be masked + || (ws_is_control_frame (parser->opcode) && + (!parser->is_fin || parser->payload_len > WS_MAX_CONTROL_PAYLOAD_LEN)) + || (!ws_is_control_frame (parser->opcode) && + (self->expecting_continuation && parser->opcode != WS_OPCODE_CONT)) + || parser->payload_len >= 0x8000000000000000ULL) + return backend_ws_fail (self, WS_STATUS_PROTOCOL_ERROR); + else if (parser->payload_len > BACKEND_WS_MAX_PAYLOAD_LEN) + return backend_ws_fail (self, WS_STATUS_MESSAGE_TOO_BIG); + return true; +} + +static bool +backend_ws_finish_closing_handshake + (struct ws_context *self, const struct ws_parser *parser) +{ + struct str reason = str_make (); + if (parser->payload_len >= 2) + { + struct msg_unpacker unpacker = + msg_unpacker_make (parser->input.str, parser->payload_len); + + uint16_t status_code; + msg_unpacker_u16 (&unpacker, &status_code); + print_debug ("close status code: %d", status_code); + + str_append_data (&reason, + parser->input.str + 2, parser->payload_len - 2); + } + + char *s = iconv_xstrdup (self->ctx->term_from_utf8, + reason.str, reason.len + 1 /* null byte */, NULL); + print_status ("server closed the connection (%s)", s); + str_free (&reason); + free (s); + + return backend_ws_send_control (self, WS_OPCODE_CLOSE, + parser->input.str, parser->payload_len); +} + +static bool +backend_ws_on_control_frame + (struct ws_context *self, const struct ws_parser *parser) +{ + 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 (self, parser); + return false; + case WS_OPCODE_PING: + if (!backend_ws_send_control (self, WS_OPCODE_PONG, + parser->input.str, parser->payload_len)) + return false; + break; + case WS_OPCODE_PONG: + // Not sending any pings but w/e + break; + default: + // Unknown control frame + return backend_ws_fail (self, WS_STATUS_PROTOCOL_ERROR); + } + return true; +} + +static int normalize_whitespace (int c) { return isspace_ascii (c) ? ' ' : c; } + +/// Caller guarantees that data[len] is a NUL byte (because of iconv_xstrdup()) +static bool +backend_ws_on_message (struct ws_context *self, + enum ws_opcode type, const void *data, size_t len) +{ + if (type != WS_OPCODE_TEXT) + return backend_ws_fail (self, WS_STATUS_UNSUPPORTED_DATA); + + if (!self->waiting_for_event || !self->response_buffer) + { + char *s = iconv_xstrdup (self->ctx->term_from_utf8, + (char *) data, len + 1 /* null byte */, NULL); + // Does not affect JSON and ensures the message is printed out okay + cstr_transform (s, normalize_whitespace); + print_warning ("unexpected message received: %s", s); + free (s); + return true; + } + + str_append_data (self->response_buffer, data, len); + ev_break (EV_DEFAULT_ EVBREAK_ONE); + return true; +} + +static bool +backend_ws_on_frame (void *user_data, const struct ws_parser *parser) +{ + struct ws_context *self = user_data; + if (ws_is_control_frame (parser->opcode)) + 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 (self, WS_STATUS_MESSAGE_TOO_BIG); + + if (!self->expecting_continuation) + self->message_opcode = parser->opcode; + + str_append_data (&self->message_data, + parser->input.str, parser->payload_len); + self->expecting_continuation = !parser->is_fin; + + if (!parser->is_fin) + return true; + + if (self->message_opcode == WS_OPCODE_TEXT + && !utf8_validate (self->message_data.str, self->message_data.len)) + return backend_ws_fail (self, WS_STATUS_INVALID_PAYLOAD_DATA); + + 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; +} + +static void +backend_ws_on_connection_timeout (EV_P_ ev_timer *handle, int revents) +{ + (void) loop; + (void) revents; + + struct ws_context *self = handle->data; + hard_assert (self->waiting_for_event); + error_set (&self->e, "connection timeout"); + backend_ws_close_connection (self); +} + +static bool +backend_ws_connect (struct ws_context *self, struct error **e) +{ + bool result = false; + + char *url_schema = xstrndup (self->endpoint + + self->url.field_data[UF_SCHEMA].off, + self->url.field_data[UF_SCHEMA].len); + bool use_tls = !strcasecmp_ascii (url_schema, "wss"); + free (url_schema); + + char *url_host = xstrndup (self->endpoint + + self->url.field_data[UF_HOST].off, + self->url.field_data[UF_HOST].len); + char *url_port = (self->url.field_set & (1 << UF_PORT)) + ? xstrndup (self->endpoint + + self->url.field_data[UF_PORT].off, + self->url.field_data[UF_PORT].len) + : xstrdup (use_tls ? "443" : "80"); + + struct str url_path = str_make (); + if (self->url.field_set & (1 << UF_PATH)) + str_append_data (&url_path, self->endpoint + + self->url.field_data[UF_PATH].off, + self->url.field_data[UF_PATH].len); + else + str_append_c (&url_path, '/'); + if (self->url.field_set & (1 << UF_QUERY)) + { + str_append_c (&url_path, '?'); + str_append_data (&url_path, self->endpoint + + self->url.field_data[UF_QUERY].off, + self->url.field_data[UF_QUERY].len); + } + + // TODO: I guess we should also reset it on error + self->state = WS_HANDLER_CONNECTING; + if (!backend_ws_establish_connection (self, url_host, url_port, e)) + goto fail_1; + + if (use_tls && !backend_ws_initialize_tls (self, url_host, e)) + goto fail_2; + + unsigned char key[16]; + if (!RAND_bytes (key, sizeof key)) + { + error_set (e, "failed to get random bytes"); + goto fail_2; + } + + struct str key_b64 = str_make (); + base64_encode (key, sizeof key, &key_b64); + + free (self->key); + char *key_b64_string = self->key = str_steal (&key_b64); + + struct str request = str_make (); + str_append_printf (&request, "GET %s HTTP/1.1\r\n", url_path.str); + // TODO: omit the port if it's the default (check RFC for "SHOULD" or ...) + str_append_printf (&request, "Host: %s:%s\r\n", url_host, url_port); + str_append_printf (&request, "Upgrade: websocket\r\n"); + str_append_printf (&request, "Connection: upgrade\r\n"); + str_append_printf (&request, SEC_WS_KEY ": %s\r\n", key_b64_string); + str_append_printf (&request, SEC_WS_VERSION ": %s\r\n", "13"); + for (size_t i = 0; i < self->extra_headers.len; i++) + str_append_printf (&request, "%s\r\n", self->extra_headers.vector[i]); + str_append_printf (&request, "\r\n"); + + bool written = backend_ws_write (self, request.str, request.len); + str_free (&request); + if (!written) + { + error_set (e, "connection failed"); + goto fail_2; + } + + http_parser_init (&self->hp, HTTP_RESPONSE); + self->hp.data = self; + str_reset (&self->field); + str_reset (&self->value); + str_map_clear (&self->headers); + ws_parser_free (&self->parser); + self->parser = ws_parser_make (); + self->parser.on_frame_header = backend_ws_on_frame_header; + self->parser.on_frame = backend_ws_on_frame; + 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 = self; + ev_io_start (EV_DEFAULT_ &self->read_watcher); + + // XXX: we should do everything non-blocking and include establishing + // the TCP connection in the timeout, but that requires a rewrite. + // As it is, this isn't really too useful. + ev_timer_init (&self->timeout_watcher, + backend_ws_on_connection_timeout, 30, 0); + self->timeout_watcher.data = self; + + // Run an event loop to process the handshake + ev_timer_start (EV_DEFAULT_ &self->timeout_watcher); + self->waiting_for_event = true; + + ev_run (EV_DEFAULT_ 0); + + self->waiting_for_event = false; + ev_timer_stop (EV_DEFAULT_ &self->timeout_watcher); + + if (self->e) + { + error_propagate (e, self->e); + self->e = NULL; + } + else + result = true; + +fail_2: + if (!result && self->server_fd != -1) + { + xclose (self->server_fd); + self->server_fd = -1; + } +fail_1: + free (url_host); + free (url_port); + str_free (&url_path); + return result; +} + +static bool +backend_ws_make_call (struct backend *backend, + const char *request, bool expect_content, struct str *buf, struct error **e) +{ + struct ws_context *self = (struct ws_context *) backend; + + if (self->server_fd == -1) + if (!backend_ws_connect (self, e)) + return false; + + while (true) + { + if (backend_ws_send_message (self, + WS_OPCODE_TEXT, request, strlen (request))) + break; + print_status ("connection failed, reconnecting"); + if (!backend_ws_connect (self, e)) + return false; + } + + if (expect_content) + { + // Run an event loop to retrieve the response + self->response_buffer = buf; + self->waiting_for_event = true; + + ev_run (EV_DEFAULT_ 0); + + self->waiting_for_event = false; + self->response_buffer = NULL; + + if (self->e) + { + error_propagate (e, self->e); + self->e = NULL; + return false; + } + } + return true; +} + +static void +backend_ws_on_quit (struct backend *backend) +{ + struct ws_context *self = (struct ws_context *) backend; + if (self->waiting_for_event && !self->e) + error_set (&self->e, "aborted by user"); + + // We also have to be careful not to change the ev_break status +} + +static void +backend_ws_destroy (struct backend *backend) +{ + 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 (self); + + free (self->endpoint); + strv_free (&self->extra_headers); + if (self->e) + error_free (self->e); + ev_timer_stop (EV_DEFAULT_ &self->timeout_watcher); + if (self->ssl_ctx) + SSL_CTX_free (self->ssl_ctx); + free (self->key); + str_free (&self->field); + str_free (&self->value); + str_map_free (&self->headers); + ws_parser_free (&self->parser); + str_free (&self->message_data); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct backend_vtable backend_ws_vtable = +{ + .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); + self->field = str_make (); + self->value = str_make (); + self->headers = str_map_make (free); + self->headers.key_xfrm = tolower_ascii_strxfrm; + self->parser = ws_parser_make (); + self->message_data = str_make (); + self->extra_headers = strv_make (); + + self->endpoint = xstrdup (endpoint); + self->url = *url; + +#if OPENSSL_VERSION_NUMBER < 0x10100000L || LIBRESSL_VERSION_NUMBER + SSL_library_init (); + atexit (EVP_cleanup); + SSL_load_error_strings (); + atexit (ERR_free_strings); +#else + // Cleanup is done automatically via atexit() + OPENSSL_init_ssl (0, NULL); +#endif + 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) +{ + struct str *buf = user_data; + str_append_data (buf, ptr, size * nmemb); + return size * nmemb; +} + +static bool +validate_json_rpc_content_type (const char *content_type) +{ + char *type = NULL; + char *subtype = NULL; + + struct str_map parameters = str_map_make (free); + parameters.key_xfrm = tolower_ascii_strxfrm; + + bool result = http_parse_media_type + (content_type, &type, &subtype, ¶meters); + if (!result) + goto end; + + if (strcasecmp_ascii (type, "application") + || (strcasecmp_ascii (subtype, "json") && + strcasecmp_ascii (subtype, "json-rpc" /* obsolete */))) + result = false; + + const char *charset = str_map_find (¶meters, "charset"); + if (charset && strcasecmp_ascii (charset, "UTF-8")) + result = false; + + // Currently ignoring all unknown parametrs + +end: + free (type); + free (subtype); + str_map_free (¶meters); + return result; +} + +static void +backend_curl_add_header (struct backend *backend, const char *header) +{ + 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 backend *backend, + const char *request, bool expect_content, struct str *buf, struct error **e) +{ + 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 (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 (self->curl))) + FAIL ("HTTP request failed: %s", self->curl_error); + + long code; + char *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) + FAIL ("unexpected HTTP response code: %ld", code); + + if (!expect_content) + ; // Let there be anything + else if (!type) + print_warning ("missing `Content-Type' header"); + else if (!validate_json_rpc_content_type (type)) + print_warning ("unexpected `Content-Type' header: %s", type); + return true; +} + +static void +backend_curl_destroy (struct backend *backend) +{ + struct curl_context *self = (struct curl_context *) backend; + curl_slist_free_all (self->headers); + curl_easy_cleanup (self->curl); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static struct backend_vtable backend_curl_vtable = +{ + .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; +} + +// --- JSON tokenizer ---------------------------------------------------------- + +// A dumb JSON tokenizer intended strictly just for syntax highlighting +// +// TODO: return also escape squences as a special token class (-> state) + +enum jtoken +{ + JTOKEN_EOF, ///< End of input + JTOKEN_ERROR, ///< EOF or error + + JTOKEN_WHITESPACE, ///< Whitespace + + JTOKEN_LBRACKET, ///< Left bracket + JTOKEN_RBRACKET, ///< Right bracket + JTOKEN_LBRACE, ///< Left curly bracket + JTOKEN_RBRACE, ///< Right curly bracket + JTOKEN_COLON, ///< Colon + JTOKEN_COMMA, ///< Comma + + JTOKEN_NULL, ///< null + JTOKEN_BOOLEAN, ///< true, false + JTOKEN_NUMBER, ///< Number + JTOKEN_STRING ///< String +}; + +struct jtokenizer +{ + const char *p; ///< Current position in input + size_t len; ///< How many bytes of input are left + struct str chunk; ///< Parsed chunk +}; + +static void +jtokenizer_init (struct jtokenizer *self, const char *p, size_t len) +{ + self->p = p; + self->len = len; + self->chunk = str_make (); +} + +static void +jtokenizer_free (struct jtokenizer *self) +{ + str_free (&self->chunk); +} + +static void +jtokenizer_advance (struct jtokenizer *self, size_t n) +{ + str_append_data (&self->chunk, self->p, n); + self->p += n; + self->len -= n; +} + +static int +jtokenizer_accept (struct jtokenizer *self, const char *chars) +{ + if (!self->len || !strchr (chars, *self->p)) + return false; + + jtokenizer_advance (self, 1); + return true; +} + +static bool +jtokenizer_ws (struct jtokenizer *self) +{ + size_t len = 0; + while (jtokenizer_accept (self, "\t\r\n ")) + len++; + return len != 0; +} + +static bool +jtokenizer_word (struct jtokenizer *self, const char *word) +{ + size_t len = strlen (word); + if (self->len < len || memcmp (self->p, word, len)) + return false; + + jtokenizer_advance (self, len); + return true; +} + +static bool +jtokenizer_escape_sequence (struct jtokenizer *self) +{ + if (!self->len) + return false; + + if (jtokenizer_accept (self, "u")) + { + for (int i = 0; i < 4; i++) + if (!jtokenizer_accept (self, "0123456789abcdefABCDEF")) + return false; + return true; + } + return jtokenizer_accept (self, "\"\\/bfnrt"); +} + +static bool +jtokenizer_string (struct jtokenizer *self) +{ + while (self->len) + { + unsigned char c = *self->p; + jtokenizer_advance (self, 1); + + if (c == '"') + return true; + if (c == '\\' && !jtokenizer_escape_sequence (self)) + return false; + } + return false; +} + +static bool +jtokenizer_integer (struct jtokenizer *self) +{ + size_t len = 0; + while (jtokenizer_accept (self, "0123456789")) + len++; + return len != 0; +} + +static bool +jtokenizer_number (struct jtokenizer *self) +{ + (void) jtokenizer_accept (self, "-"); + + if (!self->len) + return false; + if (!jtokenizer_accept (self, "0") + && !jtokenizer_integer (self)) + return false; + + if (jtokenizer_accept (self, ".") + && !jtokenizer_integer (self)) + return false; + if (jtokenizer_accept (self, "eE")) + { + (void) jtokenizer_accept (self, "+-"); + if (!jtokenizer_integer (self)) + return false; + } + return true; +} + +static enum jtoken +jtokenizer_next (struct jtokenizer *self) +{ + str_reset (&self->chunk); + + if (!self->len) return JTOKEN_EOF; + if (jtokenizer_ws (self)) return JTOKEN_WHITESPACE; + + if (jtokenizer_accept (self, "[")) return JTOKEN_LBRACKET; + if (jtokenizer_accept (self, "]")) return JTOKEN_RBRACKET; + if (jtokenizer_accept (self, "{")) return JTOKEN_LBRACE; + if (jtokenizer_accept (self, "}")) return JTOKEN_RBRACE; + + if (jtokenizer_accept (self, ":")) return JTOKEN_COLON; + if (jtokenizer_accept (self, ",")) return JTOKEN_COMMA; + + if (jtokenizer_word (self, "null")) return JTOKEN_NULL; + if (jtokenizer_word (self, "true") + || jtokenizer_word (self, "false")) return JTOKEN_BOOLEAN; + + if (jtokenizer_accept (self, "\"")) + { + if (jtokenizer_string (self)) return JTOKEN_STRING; + } + else if (jtokenizer_number (self)) return JTOKEN_NUMBER; + + jtokenizer_advance (self, self->len); + return JTOKEN_ERROR; +} + +// --- JSON highlighter -------------------------------------------------------- + +// Currently errors in parsing only mean that the rest doesn't get highlighted + +struct json_highlight +{ + struct app_context *ctx; ///< Application context + struct jtokenizer tokenizer; ///< Tokenizer + FILE *output; ///< Output handle +}; + +static void +json_highlight_print (struct json_highlight *self, int attr) +{ + print_attributed (self->ctx, self->output, attr, + "%s", self->tokenizer.chunk.str); +} + +static void json_highlight_value + (struct json_highlight *self, enum jtoken token); + +static void +json_highlight_object (struct json_highlight *self) +{ + // Distinguishing field names from regular string values in objects + bool in_field_name = true; + + enum jtoken token; + while ((token = jtokenizer_next (&self->tokenizer))) + switch (token) + { + case JTOKEN_COLON: + in_field_name = false; + json_highlight_value (self, token); + break; + case JTOKEN_COMMA: + in_field_name = true; + json_highlight_value (self, token); + break; + case JTOKEN_STRING: + if (in_field_name) + json_highlight_print (self, ATTR_JSON_FIELD); + else + json_highlight_print (self, ATTR_JSON_STRING); + break; + case JTOKEN_RBRACE: + json_highlight_value (self, token); + return; + default: + json_highlight_value (self, token); + } +} + +static void +json_highlight_array (struct json_highlight *self) +{ + enum jtoken token; + while ((token = jtokenizer_next (&self->tokenizer))) + switch (token) + { + case JTOKEN_RBRACKET: + json_highlight_value (self, token); + return; + default: + json_highlight_value (self, token); + } +} + +static void +json_highlight_value (struct json_highlight *self, enum jtoken token) +{ + switch (token) + { + case JTOKEN_LBRACE: + json_highlight_print (self, ATTR_INCOMING); + json_highlight_object (self); + break; + case JTOKEN_LBRACKET: + json_highlight_print (self, ATTR_INCOMING); + json_highlight_array (self); + break; + case JTOKEN_NULL: + json_highlight_print (self, ATTR_JSON_NULL); + break; + case JTOKEN_BOOLEAN: + json_highlight_print (self, ATTR_JSON_BOOL); + break; + case JTOKEN_NUMBER: + json_highlight_print (self, ATTR_JSON_NUMBER); + break; + case JTOKEN_STRING: + json_highlight_print (self, ATTR_JSON_STRING); + break; + default: + json_highlight_print (self, ATTR_INCOMING); + } +} + +static void +json_highlight (struct app_context *ctx, const char *s, FILE *output) +{ + struct json_highlight self = { .ctx = ctx, .output = output }; + jtokenizer_init (&self.tokenizer, s, strlen (s)); + + // There should be at maximum one value in the input however, + // but let's just keep on going and process it all + enum jtoken token; + while ((token = jtokenizer_next (&self.tokenizer))) + json_highlight_value (&self, token); + fflush (output); + + jtokenizer_free (&self.tokenizer); +} + +// --- Main program ------------------------------------------------------------ + +static void +quit (struct app_context *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); +} + +static void +suspend_terminal (struct app_context *ctx) +{ + ctx->input->vtable->hide (ctx->input); + ev_io_stop (EV_DEFAULT_ &ctx->tty_watcher); + ctx->input->vtable->prepare (ctx->input, false); +} + +static void +resume_terminal (struct app_context *ctx) +{ + ctx->input->vtable->prepare (ctx->input, true); + ev_io_start (EV_DEFAULT_ &ctx->tty_watcher); + ctx->input->vtable->show (ctx->input); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +#define PARSE_FAIL(...) \ + BLOCK_START \ + print_error (__VA_ARGS__); \ + goto fail; \ + BLOCK_END + +// XXX: should probably rather defer this action and use spawn_helper_child() +static void +display_via_pipeline (struct app_context *ctx, + const char *s, const char *pipeline) +{ + suspend_terminal (ctx); + + errno = 0; + FILE *fp = popen (pipeline, "w"); + if (fp) + { + fputs (s, fp); + pclose (fp); + } + if (errno) + print_error ("pipeline failed: %s", strerror (errno)); + + resume_terminal (ctx); +} + +static bool +parse_response (struct app_context *ctx, struct str *buf, const char *pipeline) +{ + json_error_t e; + json_t *response; + if (!(response = json_loadb (buf->str, buf->len, JSON_DECODE_ANY, &e))) + { + print_error ("failed to parse the response: %s", e.text); + return false; + } + + bool success = false; + if (!json_is_object (response)) + PARSE_FAIL ("the response is not a JSON object"); + + json_t *v; + if (!(v = json_object_get (response, "jsonrpc"))) + print_warning ("`%s' field not present in response", "jsonrpc"); + else if (!json_is_string (v) || strcmp (json_string_value (v), "2.0")) + print_warning ("invalid `%s' field in response", "jsonrpc"); + + json_t *result = json_object_get (response, "result"); + json_t *error = json_object_get (response, "error"); + json_t *data = NULL; + + if (!result && !error) + PARSE_FAIL ("neither `result' nor `error' present in response"); + if (result && error) + // Prohibited by the specification but happens in real life (null) + print_warning ("both `result' and `error' present in response"); + + if (error) + { + if (!json_is_object (error)) + PARSE_FAIL ("invalid `%s' field in response", "error"); + + json_t *code = json_object_get (error, "code"); + json_t *message = json_object_get (error, "message"); + + if (!code) + PARSE_FAIL ("missing `%s' field in error response", "code"); + if (!message) + PARSE_FAIL ("missing `%s' field in error response", "message"); + + if (!json_is_integer (code)) + PARSE_FAIL ("invalid `%s' field in error response", "code"); + if (!json_is_string (message)) + PARSE_FAIL ("invalid `%s' field in error response", "message"); + + json_int_t code_val = json_integer_value (code); + char *utf8 = xstrdup_printf ("error response: %" JSON_INTEGER_FORMAT + " (%s)", code_val, json_string_value (message)); + char *s = iconv_xstrdup (ctx->term_from_utf8, utf8, -1, NULL); + free (utf8); + + if (!s) + print_error ("character conversion failed for `%s'", "error"); + else + printf ("%s\n", s); + free (s); + + data = json_object_get (error, "data"); + } + + if (data) + { + char *utf8 = json_dumps (data, JSON_ENCODE_ANY); + char *s = iconv_xstrdup (ctx->term_from_utf8, utf8, -1, NULL); + free (utf8); + + if (!s) + print_error ("character conversion failed for `%s'", "error data"); + else + printf ("error data: %s\n", s); + free (s); + } + + if (result) + { + int flags = JSON_ENCODE_ANY; + if (ctx->pretty_print) + flags |= JSON_INDENT (2); + + char *utf8 = json_dumps (result, flags); + char *s = iconv_xstrdup (ctx->term_from_utf8, utf8, -1, NULL); + free (utf8); + + if (!s) + print_error ("character conversion failed for `%s'", "result"); + else if (pipeline) + display_via_pipeline (ctx, s, pipeline); + else + { + json_highlight (ctx, s, stdout); + fputc ('\n', stdout); + } + free (s); + } + + success = true; +fail: + json_decref (response); + return success; +} + +static bool +is_valid_json_rpc_id (json_t *v) +{ + return json_is_string (v) || json_is_integer (v) + || json_is_real (v) || json_is_null (v); // These two shouldn't be used +} + +static bool +is_valid_json_rpc_params (json_t *v) +{ + return json_is_array (v) || json_is_object (v); +} + +static void +make_json_rpc_call (struct app_context *ctx, + const char *method, json_t *id, json_t *params, const char *pipeline) +{ + json_t *request = json_object (); + json_object_set_new (request, "jsonrpc", json_string ("2.0")); + json_object_set_new (request, "method", json_string (method)); + + if (id) json_object_set (request, "id", id); + if (params) json_object_set (request, "params", params); + + char *req_utf8 = json_dumps (request, 0); + if (ctx->verbose) + { + char *req_term = iconv_xstrdup + (ctx->term_from_utf8, req_utf8, -1, NULL); + if (!req_term) + print_error ("%s: %s", "verbose", "character conversion failed"); + else + { + print_attributed (ctx, stdout, ATTR_OUTGOING, "%s", req_term); + fputs ("\n", stdout); + } + free (req_term); + } + + struct str buf = str_make (); + struct error *e = NULL; + if (!ctx->backend->vtable->make_call + (ctx->backend, req_utf8, id != NULL, &buf, &e)) + { + print_error ("%s", e->message); + error_free (e); + goto fail; + } + + bool success = false; + if (id) + success = parse_response (ctx, &buf, pipeline); + else + { + printf ("[Notification]\n"); + if (buf.len) + print_warning ("we have been sent data back for a notification"); + else + success = true; + } + + if (!success) + { + char *s = iconv_xstrdup (ctx->term_from_utf8, + buf.str, buf.len + 1 /* null byte */, NULL); + if (!s) + print_error ("character conversion failed for `%s'", + "raw response data"); + else + printf ("%s: %s\n", "raw response data", s); + free (s); + } +fail: + str_free (&buf); + free (req_utf8); + json_decref (request); +} + +static void +process_input (char *user_input, void *user_data) +{ + struct app_context *ctx = user_data; + if (!user_input) + { + quit (ctx); + return; + } + + char *input; + size_t len; + + if (!(input = iconv_xstrdup (ctx->term_to_utf8, user_input, -1, &len))) + { + print_error ("character conversion failed for `%s'", "user input"); + goto fail; + } + + // Cut out the method name first + char *p = input; + while (*p && isspace_ascii (*p)) + p++; + + // No input + if (!*p) + goto fail; + + char *method = p; + while (*p && !isspace_ascii (*p)) + p++; + if (*p) + *p++ = '\0'; + + // Now we go through this madness, just so that the order can be arbitrary + json_error_t e; + size_t args_len = 0; + json_t *args[2] = { NULL, NULL }, *id = NULL, *params = NULL; + + char *pipeline = NULL; + while (true) + { + // Jansson is too stupid to just tell us that there was nothing; + // still genius compared to the clusterfuck of json-c + while (*p && isspace_ascii (*p)) + p++; + if (!*p) + break; + + if (*p == '|') + { + pipeline = xstrdup (++p); + break; + } + + if (args_len == N_ELEMENTS (args)) + { + print_error ("too many arguments"); + goto fail_parse; + } + if (!(args[args_len] = json_loadb (p, len - (p - input), + JSON_DECODE_ANY | JSON_DISABLE_EOF_CHECK, &e))) + { + print_error ("failed to parse JSON value: %s", e.text); + goto fail_parse; + } + p += e.position; + args_len++; + } + + for (size_t i = 0; i < args_len; i++) + { + json_t **target; + if (is_valid_json_rpc_id (args[i])) + target = &id; + else if (is_valid_json_rpc_params (args[i])) + target = ¶ms; + else + { + print_error ("unexpected value at index %zu", i); + goto fail_parse; + } + + if (*target) + { + print_error ("cannot specify multiple `id' or `params'"); + goto fail_parse; + } + *target = json_incref (args[i]); + } + + if (!id && ctx->auto_id) + id = json_integer (ctx->next_id++); + + make_json_rpc_call (ctx, method, id, params, pipeline); + +fail_parse: + free (pipeline); + + if (id) json_decref (id); + if (params) json_decref (params); + + for (size_t i = 0; i < args_len; i++) + json_decref (args[i]); +fail: + free (input); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +// The ability to use an external editor on the input line has been shamelessly +// copypasted from degesch with minor changes only. + +/// This differs from the non-unique version in that we expect the filename +/// to be something like a pattern for mkstemp(), so the resulting path can +/// reside in a system-wide directory with no risk of a conflict. +static char * +resolve_relative_runtime_unique_filename (const char *filename) +{ + struct str path = str_make (); + + const char *runtime_dir = getenv ("XDG_RUNTIME_DIR"); + const char *tmpdir = getenv ("TMPDIR"); + if (runtime_dir && *runtime_dir == '/') + str_append (&path, runtime_dir); + else if (tmpdir && *tmpdir == '/') + str_append (&path, tmpdir); + else + str_append (&path, "/tmp"); + str_append_printf (&path, "/%s/%s", PROGRAM_NAME, filename); + + // Try to create the file's ancestors; + // typically the user will want to immediately create a file in there + const char *last_slash = strrchr (path.str, '/'); + if (last_slash && last_slash != path.str) + { + char *copy = xstrndup (path.str, last_slash - path.str); + (void) mkdir_with_parents (copy, NULL); + free (copy); + } + return str_steal (&path); +} + +static bool +xwrite (int fd, const char *data, size_t len, struct error **e) +{ + size_t written = 0; + while (written < len) + { + ssize_t res = write (fd, data + written, len - written); + if (res >= 0) + written += res; + else if (errno != EINTR) + FAIL ("%s", strerror (errno)); + } + return true; +} + +static bool +dump_line_to_file (const char *line, char *template, struct error **e) +{ + int fd = mkstemp (template); + if (fd < 0) + FAIL ("%s", strerror (errno)); + + bool success = xwrite (fd, line, strlen (line), e); + if (!success) + (void) unlink (template); + + xclose (fd); + return success; +} + +static char * +try_dump_line_to_file (const char *line) +{ + char *template = resolve_filename + ("input.XXXXXX", resolve_relative_runtime_unique_filename); + + struct error *e = NULL; + if (dump_line_to_file (line, template, &e)) + return template; + + print_error ("%s: %s", + "failed to create a temporary file for editing", e->message); + error_free (e); + free (template); + return NULL; +} + +static pid_t +spawn_helper_child (struct app_context *ctx) +{ + suspend_terminal (ctx); + pid_t child = fork (); + switch (child) + { + case -1: + { + int saved_errno = errno; + resume_terminal (ctx); + errno = saved_errno; + break; + } + case 0: + // Put the child in a new foreground process group + hard_assert (setpgid (0, 0) != -1); + hard_assert (tcsetpgrp (STDOUT_FILENO, getpgid (0)) != -1); + break; + default: + // Make sure of it in the parent as well before continuing + (void) setpgid (child, child); + } + return child; +} + +static void +run_editor (const char *line, void *user_data) +{ + struct app_context *ctx = user_data; + hard_assert (!ctx->editor_filename); + + char *filename; + if (!(filename = try_dump_line_to_file (line))) + return; + + const char *command; + if (!(command = getenv ("VISUAL")) + && !(command = getenv ("EDITOR"))) + command = "vi"; + + switch (spawn_helper_child (ctx)) + { + case 0: + execlp (command, command, filename, NULL); + print_error ("%s: %s", "failed to launch editor", strerror (errno)); + _exit (EXIT_FAILURE); + case -1: + print_error ("%s: %s", "failed to launch editor", strerror (errno)); + free (filename); + break; + default: + ctx->editor_filename = filename; + } +} + +static void +process_edited_input (struct app_context *ctx) +{ + struct str input = str_make (); + struct error *e = NULL; + if (!read_file (ctx->editor_filename, &input, &e)) + { + print_error ("%s: %s", "input editing failed", e->message); + error_free (e); + } + else if (!ctx->input->vtable->replace_line (ctx->input, input.str)) + print_error ("%s: %s", "input editing failed", + "could not re-insert modified text"); + + if (unlink (ctx->editor_filename)) + print_error ("could not unlink `%s': %s", + ctx->editor_filename, strerror (errno)); + + free (ctx->editor_filename); + ctx->editor_filename = NULL; + str_free (&input); +} + +static void +on_child (EV_P_ ev_child *handle, int revents) +{ + (void) revents; + struct app_context *ctx = ev_userdata (loop); + + // I am not a shell, stopping not allowed + int status = handle->rstatus; + if (WIFSTOPPED (status) + || WIFCONTINUED (status)) + { + kill (-handle->rpid, SIGKILL); + return; + } + // I don't recognize this child (we should also check PID) + if (!ctx->editor_filename) + return; + + hard_assert (tcsetpgrp (STDOUT_FILENO, getpgid (0)) != -1); + resume_terminal (ctx); + + if (WIFSIGNALED (status)) + print_error ("editor died from signal %d", WTERMSIG (status)); + else if (WIFEXITED (status) && WEXITSTATUS (status) != 0) + print_error ("editor returned status %d", WEXITSTATUS (status)); + else + process_edited_input (ctx); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +on_winch (EV_P_ ev_signal *handle, int revents) +{ + (void) handle; + (void) revents; + + struct app_context *ctx = ev_userdata (loop); + ctx->input->vtable->on_terminal_resized (ctx->input); +} + +static void +on_terminated (EV_P_ ev_signal *handle, int revents) +{ + (void) handle; + (void) revents; + + struct app_context *ctx = ev_userdata (loop); + quit (ctx); +} + +static void +on_tty_readable (EV_P_ ev_io *handle, int revents) +{ + (void) handle; + + struct app_context *ctx = ev_userdata (loop); + if (revents & EV_READ) + { + // rl_callback_read_char() is not reentrant, may happen on EOF + ev_io_stop (EV_DEFAULT_ &ctx->tty_watcher); + ctx->input->vtable->on_tty_readable (ctx->input); + ev_io_start (EV_DEFAULT_ &ctx->tty_watcher); + } +} + +static void +init_watchers (struct app_context *ctx) +{ + if (!EV_DEFAULT) + exit_fatal ("libev initialization failed"); + + // So that if the remote end closes the connection, attempts to write to + // the socket don't terminate the program + (void) signal (SIGPIPE, SIG_IGN); + + // So that we can write to the terminal while we're running a backlog + // helper. This is also inherited by the child so that it doesn't stop + // when it calls tcsetpgrp(). + (void) signal (SIGTTOU, SIG_IGN); + + ev_child_init (&ctx->child_watcher, on_child, 0, true); + ev_child_start (EV_DEFAULT_ &ctx->child_watcher); + + ev_signal_init (&ctx->winch_watcher, on_winch, SIGWINCH); + ev_signal_start (EV_DEFAULT_ &ctx->winch_watcher); + + ev_signal_init (&ctx->term_watcher, on_terminated, SIGTERM); + ev_signal_start (EV_DEFAULT_ &ctx->term_watcher); + + ev_signal_init (&ctx->int_watcher, on_terminated, SIGINT); + ev_signal_start (EV_DEFAULT_ &ctx->int_watcher); + + ev_io_init (&ctx->tty_watcher, on_tty_readable, STDIN_FILENO, EV_READ); + ev_io_start (EV_DEFAULT_ &ctx->tty_watcher); +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + +static void +parse_program_arguments (struct app_context *ctx, int argc, char **argv, + char **origin, char **endpoint) +{ + static const struct opt opts[] = + { + { 'd', "debug", NULL, 0, "run in debug mode" }, + { 'h', "help", NULL, 0, "display this help and exit" }, + { 'V', "version", NULL, 0, "output version information and exit" }, + { 'a', "auto-id", NULL, 0, "automatic `id' fields" }, + { 'o', "origin", "O", 0, "set the HTTP Origin header" }, + { 'p', "pretty", NULL, 0, "pretty-print the responses" }, + { 't', "trust-all", NULL, 0, "don't care about SSL/TLS certificates" }, + { 'v', "verbose", NULL, 0, "print the request before sending" }, + { 'c', "color", "WHEN", OPT_LONG_ONLY, + "colorize output: never, always, or auto" }, + { 'w', "write-default-cfg", "FILENAME", + OPT_OPTIONAL_ARG | OPT_LONG_ONLY, + "write a default configuration file and exit" }, + { 0, NULL, NULL, 0, NULL } + }; + + struct opt_handler oh = opt_handler_make (argc, argv, opts, + "ENDPOINT", "Simple JSON-RPC shell."); + + int c; + while ((c = opt_handler_get (&oh)) != -1) + switch (c) + { + case 'd': + g_debug_mode = true; + break; + case 'h': + opt_handler_usage (&oh, stdout); + exit (EXIT_SUCCESS); + case 'V': + printf (PROGRAM_NAME " " PROGRAM_VERSION "\n"); + exit (EXIT_SUCCESS); + + case 'o': *origin = optarg; break; + case 'a': ctx->auto_id = true; break; + case 'p': ctx->pretty_print = true; break; + case 't': ctx->trust_all = true; break; + case 'v': ctx->verbose = true; break; + + case 'c': + if (!strcasecmp (optarg, "never")) + ctx->color_mode = COLOR_NEVER; + else if (!strcasecmp (optarg, "always")) + ctx->color_mode = COLOR_ALWAYS; + else if (!strcasecmp (optarg, "auto")) + ctx->color_mode = COLOR_AUTO; + else + { + print_error ("`%s' is not a valid value for `%s'", optarg, "color"); + exit (EXIT_FAILURE); + } + break; + case 'w': + save_configuration (ctx->config.root, optarg); + exit (EXIT_SUCCESS); + + default: + print_error ("wrong options"); + opt_handler_usage (&oh, stderr); + exit (EXIT_FAILURE); + } + + argc -= optind; + argv += optind; + + if (argc != 1) + { + opt_handler_usage (&oh, stderr); + exit (EXIT_FAILURE); + } + + *endpoint = argv[0]; + opt_handler_free (&oh); +} + +int +main (int argc, char *argv[]) +{ + g_ctx.config = config_make (); + register_config_modules (&g_ctx); + config_load (&g_ctx.config, config_item_object ()); + + char *origin = NULL; + char *endpoint = NULL; + parse_program_arguments (&g_ctx, argc, argv, &origin, &endpoint); + + g_ctx.input = input_new (); + g_ctx.input->user_data = &g_ctx; + g_ctx.input->on_input = process_input; + g_ctx.input->on_run_editor = run_editor; + + init_colors (&g_ctx); + load_configuration (&g_ctx); + + struct http_parser_url url; + if (http_parser_parse_url (endpoint, strlen (endpoint), false, &url)) + exit_fatal ("invalid endpoint address"); + if (!(url.field_set & (1 << UF_SCHEMA))) + exit_fatal ("invalid endpoint address, must contain the schema"); + + char *url_schema = xstrndup (endpoint + + 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 = backend_curl_new (&g_ctx, endpoint); + else if (!strcasecmp_ascii (url_schema, "ws") + || !strcasecmp_ascii (url_schema, "wss")) + g_ctx.backend = backend_ws_new (&g_ctx, endpoint, &url); + else + exit_fatal ("unsupported protocol"); + free (url_schema); + + if (origin) + { + origin = xstrdup_printf ("Origin: %s", 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, ""); + + char *encoding = nl_langinfo (CODESET); +#ifdef __linux__ + // XXX: not quite sure if this is actually desirable + // TODO: instead retry with JSON_ENSURE_ASCII + encoding = xstrdup_printf ("%s//TRANSLIT", encoding); +#endif // __linux__ + + if ((g_ctx.term_from_utf8 = iconv_open (encoding, "UTF-8")) + == (iconv_t) -1 + || (g_ctx.term_to_utf8 = iconv_open ("UTF-8", nl_langinfo (CODESET))) + == (iconv_t) -1) + exit_fatal ("creating the UTF-8 conversion object failed: %s", + strerror (errno)); + + char *data_home = getenv ("XDG_DATA_HOME"), *home = getenv ("HOME"); + if (!data_home || *data_home != '/') + { + if (!home) + exit_fatal ("where is your $HOME, kid?"); + + data_home = xstrdup_printf ("%s/.local/share", home); + } + + char *history_path = + xstrdup_printf ("%s/" PROGRAM_NAME "/history", data_home); + (void) g_ctx.input->vtable->load_history (g_ctx.input, history_path, NULL); + + if (!get_attribute_printer (stdout)) + g_ctx.input->vtable->set_prompt (g_ctx.input, + xstrdup_printf ("json-rpc> ")); + else + { + // XXX: to be completely correct, we should use tputs, but we cannot + g_ctx.input->vtable->set_prompt (g_ctx.input, + xstrdup_printf ("%c%s%cjson-rpc> %c%s%c", + INPUT_START_IGNORE, g_ctx.attrs[ATTR_PROMPT], + INPUT_END_IGNORE, + INPUT_START_IGNORE, g_ctx.attrs[ATTR_RESET], + INPUT_END_IGNORE)); + } + + init_watchers (&g_ctx); + g_ctx.input->vtable->start (g_ctx.input, PROGRAM_NAME); + + ev_set_userdata (EV_DEFAULT_ &g_ctx); + ev_run (EV_DEFAULT_ 0); + + // User has terminated the program, let's save the history and clean up + struct error *e = NULL; + char *dir = xstrdup (history_path); + + if (!mkdir_with_parents (dirname (dir), &e) + || !g_ctx.input->vtable->save_history (g_ctx.input, history_path, &e)) + { + print_error ("writing the history file `%s' failed: %s", + history_path, e->message); + error_free (e); + } + + 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); + config_free (&g_ctx.config); + free_terminal (); + ev_loop_destroy (EV_DEFAULT); + return EXIT_SUCCESS; +} |