Adding upstream version 3.3a.upstream/3.3a

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2796 insertions, 0 deletions

diff --git a/input.c b/input.c
new file mode 100644
index 0000000..693b6f3
--- /dev/null
+++ b/input.c
@@ -0,0 +1,2796 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * 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 MIND, 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.
+ */
+
+#include <sys/types.h>
+
+#include <netinet/in.h>
+
+#include <ctype.h>
+#include <resolv.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "tmux.h"
+
+/*
+ * Based on the description by Paul Williams at:
+ *
+ * https://vt100.net/emu/dec_ansi_parser
+ *
+ * With the following changes:
+ *
+ * - 7-bit only.
+ *
+ * - Support for UTF-8.
+ *
+ * - OSC (but not APC) may be terminated by \007 as well as ST.
+ *
+ * - A state for APC similar to OSC. Some terminals appear to use this to set
+ *   the title.
+ *
+ * - A state for the screen \033k...\033\\ sequence to rename a window. This is
+ *   pretty stupid but not supporting it is more trouble than it is worth.
+ *
+ * - Special handling for ESC inside a DCS to allow arbitrary byte sequences to
+ *   be passed to the underlying terminals.
+ */
+
+/* Input parser cell. */
+struct input_cell {
+	struct grid_cell	cell;
+	int			set;
+	int			g0set;	/* 1 if ACS */
+	int			g1set;	/* 1 if ACS */
+};
+
+/* Input parser argument. */
+struct input_param {
+	enum {
+		INPUT_MISSING,
+		INPUT_NUMBER,
+		INPUT_STRING
+	}			type;
+	union {
+		int		num;
+		char	       *str;
+	};
+};
+
+/* Input parser context. */
+struct input_ctx {
+	struct window_pane     *wp;
+	struct bufferevent     *event;
+	struct screen_write_ctx ctx;
+	struct colour_palette  *palette;
+
+	struct input_cell	cell;
+
+	struct input_cell	old_cell;
+	u_int			old_cx;
+	u_int			old_cy;
+	int			old_mode;
+
+	u_char			interm_buf[4];
+	size_t			interm_len;
+
+	u_char			param_buf[64];
+	size_t			param_len;
+
+#define INPUT_BUF_START 32
+#define INPUT_BUF_LIMIT 1048576
+	u_char		       *input_buf;
+	size_t			input_len;
+	size_t			input_space;
+	enum {
+		INPUT_END_ST,
+		INPUT_END_BEL
+	}			input_end;
+
+	struct input_param	param_list[24];
+	u_int			param_list_len;
+
+	struct utf8_data	utf8data;
+	int			utf8started;
+
+	int			ch;
+	int			last;
+
+	int			flags;
+#define INPUT_DISCARD 0x1
+
+	const struct input_state *state;
+
+	struct event		timer;
+
+	/*
+	 * All input received since we were last in the ground state. Sent to
+	 * control clients on connection.
+	 */
+	struct evbuffer		*since_ground;
+};
+
+/* Helper functions. */
+struct input_transition;
+static int	input_split(struct input_ctx *);
+static int	input_get(struct input_ctx *, u_int, int, int);
+static void printflike(2, 3) input_reply(struct input_ctx *, const char *, ...);
+static void	input_set_state(struct input_ctx *,
+		    const struct input_transition *);
+static void	input_reset_cell(struct input_ctx *);
+
+static void	input_osc_4(struct input_ctx *, const char *);
+static void	input_osc_10(struct input_ctx *, const char *);
+static void	input_osc_11(struct input_ctx *, const char *);
+static void	input_osc_12(struct input_ctx *, const char *);
+static void	input_osc_52(struct input_ctx *, const char *);
+static void	input_osc_104(struct input_ctx *, const char *);
+static void	input_osc_110(struct input_ctx *, const char *);
+static void	input_osc_111(struct input_ctx *, const char *);
+static void	input_osc_112(struct input_ctx *, const char *);
+
+/* Transition entry/exit handlers. */
+static void	input_clear(struct input_ctx *);
+static void	input_ground(struct input_ctx *);
+static void	input_enter_dcs(struct input_ctx *);
+static void	input_enter_osc(struct input_ctx *);
+static void	input_exit_osc(struct input_ctx *);
+static void	input_enter_apc(struct input_ctx *);
+static void	input_exit_apc(struct input_ctx *);
+static void	input_enter_rename(struct input_ctx *);
+static void	input_exit_rename(struct input_ctx *);
+
+/* Input state handlers. */
+static int	input_print(struct input_ctx *);
+static int	input_intermediate(struct input_ctx *);
+static int	input_parameter(struct input_ctx *);
+static int	input_input(struct input_ctx *);
+static int	input_c0_dispatch(struct input_ctx *);
+static int	input_esc_dispatch(struct input_ctx *);
+static int	input_csi_dispatch(struct input_ctx *);
+static void	input_csi_dispatch_rm(struct input_ctx *);
+static void	input_csi_dispatch_rm_private(struct input_ctx *);
+static void	input_csi_dispatch_sm(struct input_ctx *);
+static void	input_csi_dispatch_sm_private(struct input_ctx *);
+static void	input_csi_dispatch_winops(struct input_ctx *);
+static void	input_csi_dispatch_sgr_256(struct input_ctx *, int, u_int *);
+static void	input_csi_dispatch_sgr_rgb(struct input_ctx *, int, u_int *);
+static void	input_csi_dispatch_sgr(struct input_ctx *);
+static int	input_dcs_dispatch(struct input_ctx *);
+static int	input_top_bit_set(struct input_ctx *);
+static int	input_end_bel(struct input_ctx *);
+
+/* Command table comparison function. */
+static int	input_table_compare(const void *, const void *);
+
+/* Command table entry. */
+struct input_table_entry {
+	int		ch;
+	const char     *interm;
+	int		type;
+};
+
+/* Escape commands. */
+enum input_esc_type {
+	INPUT_ESC_DECALN,
+	INPUT_ESC_DECKPAM,
+	INPUT_ESC_DECKPNM,
+	INPUT_ESC_DECRC,
+	INPUT_ESC_DECSC,
+	INPUT_ESC_HTS,
+	INPUT_ESC_IND,
+	INPUT_ESC_NEL,
+	INPUT_ESC_RI,
+	INPUT_ESC_RIS,
+	INPUT_ESC_SCSG0_OFF,
+	INPUT_ESC_SCSG0_ON,
+	INPUT_ESC_SCSG1_OFF,
+	INPUT_ESC_SCSG1_ON,
+	INPUT_ESC_ST,
+};
+
+/* Escape command table. */
+static const struct input_table_entry input_esc_table[] = {
+	{ '0', "(", INPUT_ESC_SCSG0_ON },
+	{ '0', ")", INPUT_ESC_SCSG1_ON },
+	{ '7', "",  INPUT_ESC_DECSC },
+	{ '8', "",  INPUT_ESC_DECRC },
+	{ '8', "#", INPUT_ESC_DECALN },
+	{ '=', "",  INPUT_ESC_DECKPAM },
+	{ '>', "",  INPUT_ESC_DECKPNM },
+	{ 'B', "(", INPUT_ESC_SCSG0_OFF },
+	{ 'B', ")", INPUT_ESC_SCSG1_OFF },
+	{ 'D', "",  INPUT_ESC_IND },
+	{ 'E', "",  INPUT_ESC_NEL },
+	{ 'H', "",  INPUT_ESC_HTS },
+	{ 'M', "",  INPUT_ESC_RI },
+	{ '\\', "", INPUT_ESC_ST },
+	{ 'c', "",  INPUT_ESC_RIS },
+};
+
+/* Control (CSI) commands. */
+enum input_csi_type {
+	INPUT_CSI_CBT,
+	INPUT_CSI_CNL,
+	INPUT_CSI_CPL,
+	INPUT_CSI_CUB,
+	INPUT_CSI_CUD,
+	INPUT_CSI_CUF,
+	INPUT_CSI_CUP,
+	INPUT_CSI_CUU,
+	INPUT_CSI_DA,
+	INPUT_CSI_DA_TWO,
+	INPUT_CSI_DCH,
+	INPUT_CSI_DECSCUSR,
+	INPUT_CSI_DECSTBM,
+	INPUT_CSI_DL,
+	INPUT_CSI_DSR,
+	INPUT_CSI_ECH,
+	INPUT_CSI_ED,
+	INPUT_CSI_EL,
+	INPUT_CSI_HPA,
+	INPUT_CSI_ICH,
+	INPUT_CSI_IL,
+	INPUT_CSI_MODOFF,
+	INPUT_CSI_MODSET,
+	INPUT_CSI_RCP,
+	INPUT_CSI_REP,
+	INPUT_CSI_RM,
+	INPUT_CSI_RM_PRIVATE,
+	INPUT_CSI_SCP,
+	INPUT_CSI_SD,
+	INPUT_CSI_SGR,
+	INPUT_CSI_SM,
+	INPUT_CSI_SM_PRIVATE,
+	INPUT_CSI_SU,
+	INPUT_CSI_TBC,
+	INPUT_CSI_VPA,
+	INPUT_CSI_WINOPS,
+	INPUT_CSI_XDA,
+};
+
+/* Control (CSI) command table. */
+static const struct input_table_entry input_csi_table[] = {
+	{ '@', "",  INPUT_CSI_ICH },
+	{ 'A', "",  INPUT_CSI_CUU },
+	{ 'B', "",  INPUT_CSI_CUD },
+	{ 'C', "",  INPUT_CSI_CUF },
+	{ 'D', "",  INPUT_CSI_CUB },
+	{ 'E', "",  INPUT_CSI_CNL },
+	{ 'F', "",  INPUT_CSI_CPL },
+	{ 'G', "",  INPUT_CSI_HPA },
+	{ 'H', "",  INPUT_CSI_CUP },
+	{ 'J', "",  INPUT_CSI_ED },
+	{ 'K', "",  INPUT_CSI_EL },
+	{ 'L', "",  INPUT_CSI_IL },
+	{ 'M', "",  INPUT_CSI_DL },
+	{ 'P', "",  INPUT_CSI_DCH },
+	{ 'S', "",  INPUT_CSI_SU },
+	{ 'T', "",  INPUT_CSI_SD },
+	{ 'X', "",  INPUT_CSI_ECH },
+	{ 'Z', "",  INPUT_CSI_CBT },
+	{ '`', "",  INPUT_CSI_HPA },
+	{ 'b', "",  INPUT_CSI_REP },
+	{ 'c', "",  INPUT_CSI_DA },
+	{ 'c', ">", INPUT_CSI_DA_TWO },
+	{ 'd', "",  INPUT_CSI_VPA },
+	{ 'f', "",  INPUT_CSI_CUP },
+	{ 'g', "",  INPUT_CSI_TBC },
+	{ 'h', "",  INPUT_CSI_SM },
+	{ 'h', "?", INPUT_CSI_SM_PRIVATE },
+	{ 'l', "",  INPUT_CSI_RM },
+	{ 'l', "?", INPUT_CSI_RM_PRIVATE },
+	{ 'm', "",  INPUT_CSI_SGR },
+	{ 'm', ">", INPUT_CSI_MODSET },
+	{ 'n', "",  INPUT_CSI_DSR },
+	{ 'n', ">", INPUT_CSI_MODOFF },
+	{ 'q', " ", INPUT_CSI_DECSCUSR },
+	{ 'q', ">", INPUT_CSI_XDA },
+	{ 'r', "",  INPUT_CSI_DECSTBM },
+	{ 's', "",  INPUT_CSI_SCP },
+	{ 't', "",  INPUT_CSI_WINOPS },
+	{ 'u', "",  INPUT_CSI_RCP },
+};
+
+/* Input transition. */
+struct input_transition {
+	int				first;
+	int				last;
+
+	int				(*handler)(struct input_ctx *);
+	const struct input_state       *state;
+};
+
+/* Input state. */
+struct input_state {
+	const char			*name;
+	void				(*enter)(struct input_ctx *);
+	void				(*exit)(struct input_ctx *);
+	const struct input_transition	*transitions;
+};
+
+/* State transitions available from all states. */
+#define INPUT_STATE_ANYWHERE \
+	{ 0x18, 0x18, input_c0_dispatch, &input_state_ground }, \
+	{ 0x1a, 0x1a, input_c0_dispatch, &input_state_ground }, \
+	{ 0x1b, 0x1b, NULL,		 &input_state_esc_enter }
+
+/* Forward declarations of state tables. */
+static const struct input_transition input_state_ground_table[];
+static const struct input_transition input_state_esc_enter_table[];
+static const struct input_transition input_state_esc_intermediate_table[];
+static const struct input_transition input_state_csi_enter_table[];
+static const struct input_transition input_state_csi_parameter_table[];
+static const struct input_transition input_state_csi_intermediate_table[];
+static const struct input_transition input_state_csi_ignore_table[];
+static const struct input_transition input_state_dcs_enter_table[];
+static const struct input_transition input_state_dcs_parameter_table[];
+static const struct input_transition input_state_dcs_intermediate_table[];
+static const struct input_transition input_state_dcs_handler_table[];
+static const struct input_transition input_state_dcs_escape_table[];
+static const struct input_transition input_state_dcs_ignore_table[];
+static const struct input_transition input_state_osc_string_table[];
+static const struct input_transition input_state_apc_string_table[];
+static const struct input_transition input_state_rename_string_table[];
+static const struct input_transition input_state_consume_st_table[];
+
+/* ground state definition. */
+static const struct input_state input_state_ground = {
+	"ground",
+	input_ground, NULL,
+	input_state_ground_table
+};
+
+/* esc_enter state definition. */
+static const struct input_state input_state_esc_enter = {
+	"esc_enter",
+	input_clear, NULL,
+	input_state_esc_enter_table
+};
+
+/* esc_intermediate state definition. */
+static const struct input_state input_state_esc_intermediate = {
+	"esc_intermediate",
+	NULL, NULL,
+	input_state_esc_intermediate_table
+};
+
+/* csi_enter state definition. */
+static const struct input_state input_state_csi_enter = {
+	"csi_enter",
+	input_clear, NULL,
+	input_state_csi_enter_table
+};
+
+/* csi_parameter state definition. */
+static const struct input_state input_state_csi_parameter = {
+	"csi_parameter",
+	NULL, NULL,
+	input_state_csi_parameter_table
+};
+
+/* csi_intermediate state definition. */
+static const struct input_state input_state_csi_intermediate = {
+	"csi_intermediate",
+	NULL, NULL,
+	input_state_csi_intermediate_table
+};
+
+/* csi_ignore state definition. */
+static const struct input_state input_state_csi_ignore = {
+	"csi_ignore",
+	NULL, NULL,
+	input_state_csi_ignore_table
+};
+
+/* dcs_enter state definition. */
+static const struct input_state input_state_dcs_enter = {
+	"dcs_enter",
+	input_enter_dcs, NULL,
+	input_state_dcs_enter_table
+};
+
+/* dcs_parameter state definition. */
+static const struct input_state input_state_dcs_parameter = {
+	"dcs_parameter",
+	NULL, NULL,
+	input_state_dcs_parameter_table
+};
+
+/* dcs_intermediate state definition. */
+static const struct input_state input_state_dcs_intermediate = {
+	"dcs_intermediate",
+	NULL, NULL,
+	input_state_dcs_intermediate_table
+};
+
+/* dcs_handler state definition. */
+static const struct input_state input_state_dcs_handler = {
+	"dcs_handler",
+	NULL, NULL,
+	input_state_dcs_handler_table
+};
+
+/* dcs_escape state definition. */
+static const struct input_state input_state_dcs_escape = {
+	"dcs_escape",
+	NULL, NULL,
+	input_state_dcs_escape_table
+};
+
+/* dcs_ignore state definition. */
+static const struct input_state input_state_dcs_ignore = {
+	"dcs_ignore",
+	NULL, NULL,
+	input_state_dcs_ignore_table
+};
+
+/* osc_string state definition. */
+static const struct input_state input_state_osc_string = {
+	"osc_string",
+	input_enter_osc, input_exit_osc,
+	input_state_osc_string_table
+};
+
+/* apc_string state definition. */
+static const struct input_state input_state_apc_string = {
+	"apc_string",
+	input_enter_apc, input_exit_apc,
+	input_state_apc_string_table
+};
+
+/* rename_string state definition. */
+static const struct input_state input_state_rename_string = {
+	"rename_string",
+	input_enter_rename, input_exit_rename,
+	input_state_rename_string_table
+};
+
+/* consume_st state definition. */
+static const struct input_state input_state_consume_st = {
+	"consume_st",
+	input_enter_rename, NULL, /* rename also waits for ST */
+	input_state_consume_st_table
+};
+
+/* ground state table. */
+static const struct input_transition input_state_ground_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch, NULL },
+	{ 0x19, 0x19, input_c0_dispatch, NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch, NULL },
+	{ 0x20, 0x7e, input_print,	 NULL },
+	{ 0x7f, 0x7f, NULL,		 NULL },
+	{ 0x80, 0xff, input_top_bit_set, NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* esc_enter state table. */
+static const struct input_transition input_state_esc_enter_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch,  NULL },
+	{ 0x19, 0x19, input_c0_dispatch,  NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch,  NULL },
+	{ 0x20, 0x2f, input_intermediate, &input_state_esc_intermediate },
+	{ 0x30, 0x4f, input_esc_dispatch, &input_state_ground },
+	{ 0x50, 0x50, NULL,		  &input_state_dcs_enter },
+	{ 0x51, 0x57, input_esc_dispatch, &input_state_ground },
+	{ 0x58, 0x58, NULL,		  &input_state_consume_st },
+	{ 0x59, 0x59, input_esc_dispatch, &input_state_ground },
+	{ 0x5a, 0x5a, input_esc_dispatch, &input_state_ground },
+	{ 0x5b, 0x5b, NULL,		  &input_state_csi_enter },
+	{ 0x5c, 0x5c, input_esc_dispatch, &input_state_ground },
+	{ 0x5d, 0x5d, NULL,		  &input_state_osc_string },
+	{ 0x5e, 0x5e, NULL,		  &input_state_consume_st },
+	{ 0x5f, 0x5f, NULL,		  &input_state_apc_string },
+	{ 0x60, 0x6a, input_esc_dispatch, &input_state_ground },
+	{ 0x6b, 0x6b, NULL,		  &input_state_rename_string },
+	{ 0x6c, 0x7e, input_esc_dispatch, &input_state_ground },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* esc_intermediate state table. */
+static const struct input_transition input_state_esc_intermediate_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch,  NULL },
+	{ 0x19, 0x19, input_c0_dispatch,  NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch,  NULL },
+	{ 0x20, 0x2f, input_intermediate, NULL },
+	{ 0x30, 0x7e, input_esc_dispatch, &input_state_ground },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* csi_enter state table. */
+static const struct input_transition input_state_csi_enter_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch,  NULL },
+	{ 0x19, 0x19, input_c0_dispatch,  NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch,  NULL },
+	{ 0x20, 0x2f, input_intermediate, &input_state_csi_intermediate },
+	{ 0x30, 0x39, input_parameter,	  &input_state_csi_parameter },
+	{ 0x3a, 0x3a, input_parameter,	  &input_state_csi_parameter },
+	{ 0x3b, 0x3b, input_parameter,	  &input_state_csi_parameter },
+	{ 0x3c, 0x3f, input_intermediate, &input_state_csi_parameter },
+	{ 0x40, 0x7e, input_csi_dispatch, &input_state_ground },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* csi_parameter state table. */
+static const struct input_transition input_state_csi_parameter_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch,  NULL },
+	{ 0x19, 0x19, input_c0_dispatch,  NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch,  NULL },
+	{ 0x20, 0x2f, input_intermediate, &input_state_csi_intermediate },
+	{ 0x30, 0x39, input_parameter,	  NULL },
+	{ 0x3a, 0x3a, input_parameter,	  NULL },
+	{ 0x3b, 0x3b, input_parameter,	  NULL },
+	{ 0x3c, 0x3f, NULL,		  &input_state_csi_ignore },
+	{ 0x40, 0x7e, input_csi_dispatch, &input_state_ground },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* csi_intermediate state table. */
+static const struct input_transition input_state_csi_intermediate_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch,  NULL },
+	{ 0x19, 0x19, input_c0_dispatch,  NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch,  NULL },
+	{ 0x20, 0x2f, input_intermediate, NULL },
+	{ 0x30, 0x3f, NULL,		  &input_state_csi_ignore },
+	{ 0x40, 0x7e, input_csi_dispatch, &input_state_ground },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* csi_ignore state table. */
+static const struct input_transition input_state_csi_ignore_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, input_c0_dispatch, NULL },
+	{ 0x19, 0x19, input_c0_dispatch, NULL },
+	{ 0x1c, 0x1f, input_c0_dispatch, NULL },
+	{ 0x20, 0x3f, NULL,		 NULL },
+	{ 0x40, 0x7e, NULL,		 &input_state_ground },
+	{ 0x7f, 0xff, NULL,		 NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* dcs_enter state table. */
+static const struct input_transition input_state_dcs_enter_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,		  NULL },
+	{ 0x19, 0x19, NULL,		  NULL },
+	{ 0x1c, 0x1f, NULL,		  NULL },
+	{ 0x20, 0x2f, input_intermediate, &input_state_dcs_intermediate },
+	{ 0x30, 0x39, input_parameter,	  &input_state_dcs_parameter },
+	{ 0x3a, 0x3a, NULL,		  &input_state_dcs_ignore },
+	{ 0x3b, 0x3b, input_parameter,	  &input_state_dcs_parameter },
+	{ 0x3c, 0x3f, input_intermediate, &input_state_dcs_parameter },
+	{ 0x40, 0x7e, input_input,	  &input_state_dcs_handler },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* dcs_parameter state table. */
+static const struct input_transition input_state_dcs_parameter_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,		  NULL },
+	{ 0x19, 0x19, NULL,		  NULL },
+	{ 0x1c, 0x1f, NULL,		  NULL },
+	{ 0x20, 0x2f, input_intermediate, &input_state_dcs_intermediate },
+	{ 0x30, 0x39, input_parameter,	  NULL },
+	{ 0x3a, 0x3a, NULL,		  &input_state_dcs_ignore },
+	{ 0x3b, 0x3b, input_parameter,	  NULL },
+	{ 0x3c, 0x3f, NULL,		  &input_state_dcs_ignore },
+	{ 0x40, 0x7e, input_input,	  &input_state_dcs_handler },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* dcs_intermediate state table. */
+static const struct input_transition input_state_dcs_intermediate_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,		  NULL },
+	{ 0x19, 0x19, NULL,		  NULL },
+	{ 0x1c, 0x1f, NULL,		  NULL },
+	{ 0x20, 0x2f, input_intermediate, NULL },
+	{ 0x30, 0x3f, NULL,		  &input_state_dcs_ignore },
+	{ 0x40, 0x7e, input_input,	  &input_state_dcs_handler },
+	{ 0x7f, 0xff, NULL,		  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* dcs_handler state table. */
+static const struct input_transition input_state_dcs_handler_table[] = {
+	/* No INPUT_STATE_ANYWHERE */
+
+	{ 0x00, 0x1a, input_input,  NULL },
+	{ 0x1b, 0x1b, NULL,	    &input_state_dcs_escape },
+	{ 0x1c, 0xff, input_input,  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* dcs_escape state table. */
+static const struct input_transition input_state_dcs_escape_table[] = {
+	/* No INPUT_STATE_ANYWHERE */
+
+	{ 0x00, 0x5b, input_input,	  &input_state_dcs_handler },
+	{ 0x5c, 0x5c, input_dcs_dispatch, &input_state_ground },
+	{ 0x5d, 0xff, input_input,	  &input_state_dcs_handler },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* dcs_ignore state table. */
+static const struct input_transition input_state_dcs_ignore_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,	    NULL },
+	{ 0x19, 0x19, NULL,	    NULL },
+	{ 0x1c, 0x1f, NULL,	    NULL },
+	{ 0x20, 0xff, NULL,	    NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* osc_string state table. */
+static const struct input_transition input_state_osc_string_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x06, NULL,	     NULL },
+	{ 0x07, 0x07, input_end_bel, &input_state_ground },
+	{ 0x08, 0x17, NULL,	     NULL },
+	{ 0x19, 0x19, NULL,	     NULL },
+	{ 0x1c, 0x1f, NULL,	     NULL },
+	{ 0x20, 0xff, input_input,   NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* apc_string state table. */
+static const struct input_transition input_state_apc_string_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,	    NULL },
+	{ 0x19, 0x19, NULL,	    NULL },
+	{ 0x1c, 0x1f, NULL,	    NULL },
+	{ 0x20, 0xff, input_input,  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* rename_string state table. */
+static const struct input_transition input_state_rename_string_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,	    NULL },
+	{ 0x19, 0x19, NULL,	    NULL },
+	{ 0x1c, 0x1f, NULL,	    NULL },
+	{ 0x20, 0xff, input_input,  NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* consume_st state table. */
+static const struct input_transition input_state_consume_st_table[] = {
+	INPUT_STATE_ANYWHERE,
+
+	{ 0x00, 0x17, NULL,	    NULL },
+	{ 0x19, 0x19, NULL,	    NULL },
+	{ 0x1c, 0x1f, NULL,	    NULL },
+	{ 0x20, 0xff, NULL,	    NULL },
+
+	{ -1, -1, NULL, NULL }
+};
+
+/* Input table compare. */
+static int
+input_table_compare(const void *key, const void *value)
+{
+	const struct input_ctx		*ictx = key;
+	const struct input_table_entry	*entry = value;
+
+	if (ictx->ch != entry->ch)
+		return (ictx->ch - entry->ch);
+	return (strcmp(ictx->interm_buf, entry->interm));
+}
+
+/*
+ * Timer - if this expires then have been waiting for a terminator for too
+ * long, so reset to ground.
+ */
+static void
+input_timer_callback(__unused int fd, __unused short events, void *arg)
+{
+	struct input_ctx	*ictx = arg;
+
+	log_debug("%s: %s expired" , __func__, ictx->state->name);
+	input_reset(ictx, 0);
+}
+
+/* Start the timer. */
+static void
+input_start_timer(struct input_ctx *ictx)
+{
+	struct timeval	tv = { .tv_sec = 5, .tv_usec = 0 };
+
+	event_del(&ictx->timer);
+	event_add(&ictx->timer, &tv);
+}
+
+/* Reset cell state to default. */
+static void
+input_reset_cell(struct input_ctx *ictx)
+{
+	memcpy(&ictx->cell.cell, &grid_default_cell, sizeof ictx->cell.cell);
+	ictx->cell.set = 0;
+	ictx->cell.g0set = ictx->cell.g1set = 0;
+
+	memcpy(&ictx->old_cell, &ictx->cell, sizeof ictx->old_cell);
+	ictx->old_cx = 0;
+	ictx->old_cy = 0;
+}
+
+/* Save screen state. */
+static void
+input_save_state(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct screen		*s = sctx->s;
+
+	memcpy(&ictx->old_cell, &ictx->cell, sizeof ictx->old_cell);
+	ictx->old_cx = s->cx;
+	ictx->old_cy = s->cy;
+	ictx->old_mode = s->mode;
+}
+
+/* Restore screen state. */
+static void
+input_restore_state(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+
+	memcpy(&ictx->cell, &ictx->old_cell, sizeof ictx->cell);
+	if (ictx->old_mode & MODE_ORIGIN)
+		screen_write_mode_set(sctx, MODE_ORIGIN);
+	else
+		screen_write_mode_clear(sctx, MODE_ORIGIN);
+	screen_write_cursormove(sctx, ictx->old_cx, ictx->old_cy, 0);
+}
+
+/* Initialise input parser. */
+struct input_ctx *
+input_init(struct window_pane *wp, struct bufferevent *bev,
+    struct colour_palette *palette)
+{
+	struct input_ctx	*ictx;
+
+	ictx = xcalloc(1, sizeof *ictx);
+	ictx->wp = wp;
+	ictx->event = bev;
+	ictx->palette = palette;
+
+	ictx->input_space = INPUT_BUF_START;
+	ictx->input_buf = xmalloc(INPUT_BUF_START);
+
+	ictx->since_ground = evbuffer_new();
+	if (ictx->since_ground == NULL)
+		fatalx("out of memory");
+
+	evtimer_set(&ictx->timer, input_timer_callback, ictx);
+
+	input_reset(ictx, 0);
+	return (ictx);
+}
+
+/* Destroy input parser. */
+void
+input_free(struct input_ctx *ictx)
+{
+	u_int	i;
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		if (ictx->param_list[i].type == INPUT_STRING)
+			free(ictx->param_list[i].str);
+	}
+
+	event_del(&ictx->timer);
+
+	free(ictx->input_buf);
+	evbuffer_free(ictx->since_ground);
+
+	free(ictx);
+}
+
+/* Reset input state and clear screen. */
+void
+input_reset(struct input_ctx *ictx, int clear)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct window_pane	*wp = ictx->wp;
+
+	input_reset_cell(ictx);
+
+	if (clear && wp != NULL) {
+		if (TAILQ_EMPTY(&wp->modes))
+			screen_write_start_pane(sctx, wp, &wp->base);
+		else
+			screen_write_start(sctx, &wp->base);
+		screen_write_reset(sctx);
+		screen_write_stop(sctx);
+	}
+
+	input_clear(ictx);
+
+	ictx->last = -1;
+
+	ictx->state = &input_state_ground;
+	ictx->flags = 0;
+}
+
+/* Return pending data. */
+struct evbuffer *
+input_pending(struct input_ctx *ictx)
+{
+	return (ictx->since_ground);
+}
+
+/* Change input state. */
+static void
+input_set_state(struct input_ctx *ictx, const struct input_transition *itr)
+{
+	if (ictx->state->exit != NULL)
+		ictx->state->exit(ictx);
+	ictx->state = itr->state;
+	if (ictx->state->enter != NULL)
+		ictx->state->enter(ictx);
+}
+
+/* Parse data. */
+static void
+input_parse(struct input_ctx *ictx, u_char *buf, size_t len)
+{
+	struct screen_write_ctx		*sctx = &ictx->ctx;
+	const struct input_state	*state = NULL;
+	const struct input_transition	*itr = NULL;
+	size_t				 off = 0;
+
+	/* Parse the input. */
+	while (off < len) {
+		ictx->ch = buf[off++];
+
+		/* Find the transition. */
+		if (ictx->state != state ||
+		    itr == NULL ||
+		    ictx->ch < itr->first ||
+		    ictx->ch > itr->last) {
+			itr = ictx->state->transitions;
+			while (itr->first != -1 && itr->last != -1) {
+				if (ictx->ch >= itr->first &&
+				    ictx->ch <= itr->last)
+					break;
+				itr++;
+			}
+			if (itr->first == -1 || itr->last == -1) {
+				/* No transition? Eh? */
+				fatalx("no transition from state");
+			}
+		}
+		state = ictx->state;
+
+		/*
+		 * Any state except print stops the current collection. This is
+		 * an optimization to avoid checking if the attributes have
+		 * changed for every character. It will stop unnecessarily for
+		 * sequences that don't make a terminal change, but they should
+		 * be the minority.
+		 */
+		if (itr->handler != input_print)
+			screen_write_collect_end(sctx);
+
+		/*
+		 * Execute the handler, if any. Don't switch state if it
+		 * returns non-zero.
+		 */
+		if (itr->handler != NULL && itr->handler(ictx) != 0)
+			continue;
+
+		/* And switch state, if necessary. */
+		if (itr->state != NULL)
+			input_set_state(ictx, itr);
+
+		/* If not in ground state, save input. */
+		if (ictx->state != &input_state_ground)
+			evbuffer_add(ictx->since_ground, &ictx->ch, 1);
+	}
+}
+
+/* Parse input from pane. */
+void
+input_parse_pane(struct window_pane *wp)
+{
+	void	*new_data;
+	size_t	 new_size;
+
+	new_data = window_pane_get_new_data(wp, &wp->offset, &new_size);
+	input_parse_buffer(wp, new_data, new_size);
+	window_pane_update_used_data(wp, &wp->offset, new_size);
+}
+
+/* Parse given input. */
+void
+input_parse_buffer(struct window_pane *wp, u_char *buf, size_t len)
+{
+	struct input_ctx	*ictx = wp->ictx;
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+
+	if (len == 0)
+		return;
+
+	window_update_activity(wp->window);
+	wp->flags |= PANE_CHANGED;
+
+	/* NULL wp if there is a mode set as don't want to update the tty. */
+	if (TAILQ_EMPTY(&wp->modes))
+		screen_write_start_pane(sctx, wp, &wp->base);
+	else
+		screen_write_start(sctx, &wp->base);
+
+	log_debug("%s: %%%u %s, %zu bytes: %.*s", __func__, wp->id,
+	    ictx->state->name, len, (int)len, buf);
+
+	input_parse(ictx, buf, len);
+	screen_write_stop(sctx);
+}
+
+/* Parse given input for screen. */
+void
+input_parse_screen(struct input_ctx *ictx, struct screen *s,
+    screen_write_init_ctx_cb cb, void *arg, u_char *buf, size_t len)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+
+	if (len == 0)
+		return;
+
+	screen_write_start_callback(sctx, s, cb, arg);
+	input_parse(ictx, buf, len);
+	screen_write_stop(sctx);
+}
+
+/* Split the parameter list (if any). */
+static int
+input_split(struct input_ctx *ictx)
+{
+	const char		*errstr;
+	char			*ptr, *out;
+	struct input_param	*ip;
+	u_int			 i;
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		if (ictx->param_list[i].type == INPUT_STRING)
+			free(ictx->param_list[i].str);
+	}
+	ictx->param_list_len = 0;
+
+	if (ictx->param_len == 0)
+		return (0);
+	ip = &ictx->param_list[0];
+
+	ptr = ictx->param_buf;
+	while ((out = strsep(&ptr, ";")) != NULL) {
+		if (*out == '\0')
+			ip->type = INPUT_MISSING;
+		else {
+			if (strchr(out, ':') != NULL) {
+				ip->type = INPUT_STRING;
+				ip->str = xstrdup(out);
+			} else {
+				ip->type = INPUT_NUMBER;
+				ip->num = strtonum(out, 0, INT_MAX, &errstr);
+				if (errstr != NULL)
+					return (-1);
+			}
+		}
+		ip = &ictx->param_list[++ictx->param_list_len];
+		if (ictx->param_list_len == nitems(ictx->param_list))
+			return (-1);
+	}
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		ip = &ictx->param_list[i];
+		if (ip->type == INPUT_MISSING)
+			log_debug("parameter %u: missing", i);
+		else if (ip->type == INPUT_STRING)
+			log_debug("parameter %u: string %s", i, ip->str);
+		else if (ip->type == INPUT_NUMBER)
+			log_debug("parameter %u: number %d", i, ip->num);
+	}
+
+	return (0);
+}
+
+/* Get an argument or return default value. */
+static int
+input_get(struct input_ctx *ictx, u_int validx, int minval, int defval)
+{
+	struct input_param	*ip;
+	int			 retval;
+
+	if (validx >= ictx->param_list_len)
+	    return (defval);
+	ip = &ictx->param_list[validx];
+	if (ip->type == INPUT_MISSING)
+		return (defval);
+	if (ip->type == INPUT_STRING)
+		return (-1);
+	retval = ip->num;
+	if (retval < minval)
+		return (minval);
+	return (retval);
+}
+
+/* Reply to terminal query. */
+static void
+input_reply(struct input_ctx *ictx, const char *fmt, ...)
+{
+	struct bufferevent	*bev = ictx->event;
+	va_list			 ap;
+	char			*reply;
+
+	if (bev == NULL)
+		return;
+
+	va_start(ap, fmt);
+	xvasprintf(&reply, fmt, ap);
+	va_end(ap);
+
+	bufferevent_write(bev, reply, strlen(reply));
+	free(reply);
+}
+
+/* Clear saved state. */
+static void
+input_clear(struct input_ctx *ictx)
+{
+	event_del(&ictx->timer);
+
+	*ictx->interm_buf = '\0';
+	ictx->interm_len = 0;
+
+	*ictx->param_buf = '\0';
+	ictx->param_len = 0;
+
+	*ictx->input_buf = '\0';
+	ictx->input_len = 0;
+
+	ictx->input_end = INPUT_END_ST;
+
+	ictx->flags &= ~INPUT_DISCARD;
+}
+
+/* Reset for ground state. */
+static void
+input_ground(struct input_ctx *ictx)
+{
+	event_del(&ictx->timer);
+	evbuffer_drain(ictx->since_ground, EVBUFFER_LENGTH(ictx->since_ground));
+
+	if (ictx->input_space > INPUT_BUF_START) {
+		ictx->input_space = INPUT_BUF_START;
+		ictx->input_buf = xrealloc(ictx->input_buf, INPUT_BUF_START);
+	}
+}
+
+/* Output this character to the screen. */
+static int
+input_print(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	int			 set;
+
+	ictx->utf8started = 0; /* can't be valid UTF-8 */
+
+	set = ictx->cell.set == 0 ? ictx->cell.g0set : ictx->cell.g1set;
+	if (set == 1)
+		ictx->cell.cell.attr |= GRID_ATTR_CHARSET;
+	else
+		ictx->cell.cell.attr &= ~GRID_ATTR_CHARSET;
+
+	utf8_set(&ictx->cell.cell.data, ictx->ch);
+	screen_write_collect_add(sctx, &ictx->cell.cell);
+	ictx->last = ictx->ch;
+
+	ictx->cell.cell.attr &= ~GRID_ATTR_CHARSET;
+
+	return (0);
+}
+
+/* Collect intermediate string. */
+static int
+input_intermediate(struct input_ctx *ictx)
+{
+	if (ictx->interm_len == (sizeof ictx->interm_buf) - 1)
+		ictx->flags |= INPUT_DISCARD;
+	else {
+		ictx->interm_buf[ictx->interm_len++] = ictx->ch;
+		ictx->interm_buf[ictx->interm_len] = '\0';
+	}
+
+	return (0);
+}
+
+/* Collect parameter string. */
+static int
+input_parameter(struct input_ctx *ictx)
+{
+	if (ictx->param_len == (sizeof ictx->param_buf) - 1)
+		ictx->flags |= INPUT_DISCARD;
+	else {
+		ictx->param_buf[ictx->param_len++] = ictx->ch;
+		ictx->param_buf[ictx->param_len] = '\0';
+	}
+
+	return (0);
+}
+
+/* Collect input string. */
+static int
+input_input(struct input_ctx *ictx)
+{
+	size_t available;
+
+	available = ictx->input_space;
+	while (ictx->input_len + 1 >= available) {
+		available *= 2;
+		if (available > INPUT_BUF_LIMIT) {
+			ictx->flags |= INPUT_DISCARD;
+			return (0);
+		}
+		ictx->input_buf = xrealloc(ictx->input_buf, available);
+		ictx->input_space = available;
+	}
+	ictx->input_buf[ictx->input_len++] = ictx->ch;
+	ictx->input_buf[ictx->input_len] = '\0';
+
+	return (0);
+}
+
+/* Execute C0 control sequence. */
+static int
+input_c0_dispatch(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct window_pane	*wp = ictx->wp;
+	struct screen		*s = sctx->s;
+
+	ictx->utf8started = 0; /* can't be valid UTF-8 */
+
+	log_debug("%s: '%c'", __func__, ictx->ch);
+
+	switch (ictx->ch) {
+	case '\000':	/* NUL */
+		break;
+	case '\007':	/* BEL */
+		if (wp != NULL)
+			alerts_queue(wp->window, WINDOW_BELL);
+		break;
+	case '\010':	/* BS */
+		screen_write_backspace(sctx);
+		break;
+	case '\011':	/* HT */
+		/* Don't tab beyond the end of the line. */
+		if (s->cx >= screen_size_x(s) - 1)
+			break;
+
+		/* Find the next tab point, or use the last column if none. */
+		do {
+			s->cx++;
+			if (bit_test(s->tabs, s->cx))
+				break;
+		} while (s->cx < screen_size_x(s) - 1);
+		break;
+	case '\012':	/* LF */
+	case '\013':	/* VT */
+	case '\014':	/* FF */
+		screen_write_linefeed(sctx, 0, ictx->cell.cell.bg);
+		if (s->mode & MODE_CRLF)
+			screen_write_carriagereturn(sctx);
+		break;
+	case '\015':	/* CR */
+		screen_write_carriagereturn(sctx);
+		break;
+	case '\016':	/* SO */
+		ictx->cell.set = 1;
+		break;
+	case '\017':	/* SI */
+		ictx->cell.set = 0;
+		break;
+	default:
+		log_debug("%s: unknown '%c'", __func__, ictx->ch);
+		break;
+	}
+
+	ictx->last = -1;
+	return (0);
+}
+
+/* Execute escape sequence. */
+static int
+input_esc_dispatch(struct input_ctx *ictx)
+{
+	struct screen_write_ctx		*sctx = &ictx->ctx;
+	struct screen			*s = sctx->s;
+	struct input_table_entry	*entry;
+
+	if (ictx->flags & INPUT_DISCARD)
+		return (0);
+	log_debug("%s: '%c', %s", __func__, ictx->ch, ictx->interm_buf);
+
+	entry = bsearch(ictx, input_esc_table, nitems(input_esc_table),
+	    sizeof input_esc_table[0], input_table_compare);
+	if (entry == NULL) {
+		log_debug("%s: unknown '%c'", __func__, ictx->ch);
+		return (0);
+	}
+
+	switch (entry->type) {
+	case INPUT_ESC_RIS:
+		colour_palette_clear(ictx->palette);
+		input_reset_cell(ictx);
+		screen_write_reset(sctx);
+		screen_write_fullredraw(sctx);
+		break;
+	case INPUT_ESC_IND:
+		screen_write_linefeed(sctx, 0, ictx->cell.cell.bg);
+		break;
+	case INPUT_ESC_NEL:
+		screen_write_carriagereturn(sctx);
+		screen_write_linefeed(sctx, 0, ictx->cell.cell.bg);
+		break;
+	case INPUT_ESC_HTS:
+		if (s->cx < screen_size_x(s))
+			bit_set(s->tabs, s->cx);
+		break;
+	case INPUT_ESC_RI:
+		screen_write_reverseindex(sctx, ictx->cell.cell.bg);
+		break;
+	case INPUT_ESC_DECKPAM:
+		screen_write_mode_set(sctx, MODE_KKEYPAD);
+		break;
+	case INPUT_ESC_DECKPNM:
+		screen_write_mode_clear(sctx, MODE_KKEYPAD);
+		break;
+	case INPUT_ESC_DECSC:
+		input_save_state(ictx);
+		break;
+	case INPUT_ESC_DECRC:
+		input_restore_state(ictx);
+		break;
+	case INPUT_ESC_DECALN:
+		screen_write_alignmenttest(sctx);
+		break;
+	case INPUT_ESC_SCSG0_ON:
+		ictx->cell.g0set = 1;
+		break;
+	case INPUT_ESC_SCSG0_OFF:
+		ictx->cell.g0set = 0;
+		break;
+	case INPUT_ESC_SCSG1_ON:
+		ictx->cell.g1set = 1;
+		break;
+	case INPUT_ESC_SCSG1_OFF:
+		ictx->cell.g1set = 0;
+		break;
+	case INPUT_ESC_ST:
+		/* ST terminates OSC but the state transition already did it. */
+		break;
+	}
+
+	ictx->last = -1;
+	return (0);
+}
+
+/* Execute control sequence. */
+static int
+input_csi_dispatch(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	       *sctx = &ictx->ctx;
+	struct screen		       *s = sctx->s;
+	struct input_table_entry       *entry;
+	int				i, n, m;
+	u_int				cx, bg = ictx->cell.cell.bg;
+
+	if (ictx->flags & INPUT_DISCARD)
+		return (0);
+
+	log_debug("%s: '%c' \"%s\" \"%s\"",
+	    __func__, ictx->ch, ictx->interm_buf, ictx->param_buf);
+
+	if (input_split(ictx) != 0)
+		return (0);
+
+	entry = bsearch(ictx, input_csi_table, nitems(input_csi_table),
+	    sizeof input_csi_table[0], input_table_compare);
+	if (entry == NULL) {
+		log_debug("%s: unknown '%c'", __func__, ictx->ch);
+		return (0);
+	}
+
+	switch (entry->type) {
+	case INPUT_CSI_CBT:
+		/* Find the previous tab point, n times. */
+		cx = s->cx;
+		if (cx > screen_size_x(s) - 1)
+			cx = screen_size_x(s) - 1;
+		n = input_get(ictx, 0, 1, 1);
+		if (n == -1)
+			break;
+		while (cx > 0 && n-- > 0) {
+			do
+				cx--;
+			while (cx > 0 && !bit_test(s->tabs, cx));
+		}
+		s->cx = cx;
+		break;
+	case INPUT_CSI_CUB:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_cursorleft(sctx, n);
+		break;
+	case INPUT_CSI_CUD:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_cursordown(sctx, n);
+		break;
+	case INPUT_CSI_CUF:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_cursorright(sctx, n);
+		break;
+	case INPUT_CSI_CUP:
+		n = input_get(ictx, 0, 1, 1);
+		m = input_get(ictx, 1, 1, 1);
+		if (n != -1 && m != -1)
+			screen_write_cursormove(sctx, m - 1, n - 1, 1);
+		break;
+	case INPUT_CSI_MODSET:
+		n = input_get(ictx, 0, 0, 0);
+		m = input_get(ictx, 1, 0, 0);
+		if (options_get_number(global_options, "extended-keys") == 2)
+			break;
+		if (n == 0 || (n == 4 && m == 0))
+			screen_write_mode_clear(sctx, MODE_KEXTENDED);
+		else if (n == 4 && (m == 1 || m == 2))
+			screen_write_mode_set(sctx, MODE_KEXTENDED);
+		break;
+	case INPUT_CSI_MODOFF:
+		n = input_get(ictx, 0, 0, 0);
+		if (n == 4)
+			screen_write_mode_clear(sctx, MODE_KEXTENDED);
+		break;
+	case INPUT_CSI_WINOPS:
+		input_csi_dispatch_winops(ictx);
+		break;
+	case INPUT_CSI_CUU:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_cursorup(sctx, n);
+		break;
+	case INPUT_CSI_CNL:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1) {
+			screen_write_carriagereturn(sctx);
+			screen_write_cursordown(sctx, n);
+		}
+		break;
+	case INPUT_CSI_CPL:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1) {
+			screen_write_carriagereturn(sctx);
+			screen_write_cursorup(sctx, n);
+		}
+		break;
+	case INPUT_CSI_DA:
+		switch (input_get(ictx, 0, 0, 0)) {
+		case -1:
+			break;
+		case 0:
+			input_reply(ictx, "\033[?1;2c");
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		break;
+	case INPUT_CSI_DA_TWO:
+		switch (input_get(ictx, 0, 0, 0)) {
+		case -1:
+			break;
+		case 0:
+			input_reply(ictx, "\033[>84;0;0c");
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		break;
+	case INPUT_CSI_ECH:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_clearcharacter(sctx, n, bg);
+		break;
+	case INPUT_CSI_DCH:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_deletecharacter(sctx, n, bg);
+		break;
+	case INPUT_CSI_DECSTBM:
+		n = input_get(ictx, 0, 1, 1);
+		m = input_get(ictx, 1, 1, screen_size_y(s));
+		if (n != -1 && m != -1)
+			screen_write_scrollregion(sctx, n - 1, m - 1);
+		break;
+	case INPUT_CSI_DL:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_deleteline(sctx, n, bg);
+		break;
+	case INPUT_CSI_DSR:
+		switch (input_get(ictx, 0, 0, 0)) {
+		case -1:
+			break;
+		case 5:
+			input_reply(ictx, "\033[0n");
+			break;
+		case 6:
+			input_reply(ictx, "\033[%u;%uR", s->cy + 1, s->cx + 1);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		break;
+	case INPUT_CSI_ED:
+		switch (input_get(ictx, 0, 0, 0)) {
+		case -1:
+			break;
+		case 0:
+			screen_write_clearendofscreen(sctx, bg);
+			break;
+		case 1:
+			screen_write_clearstartofscreen(sctx, bg);
+			break;
+		case 2:
+			screen_write_clearscreen(sctx, bg);
+			break;
+		case 3:
+			if (input_get(ictx, 1, 0, 0) == 0) {
+				/*
+				 * Linux console extension to clear history
+				 * (for example before locking the screen).
+				 */
+				screen_write_clearhistory(sctx);
+			}
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		break;
+	case INPUT_CSI_EL:
+		switch (input_get(ictx, 0, 0, 0)) {
+		case -1:
+			break;
+		case 0:
+			screen_write_clearendofline(sctx, bg);
+			break;
+		case 1:
+			screen_write_clearstartofline(sctx, bg);
+			break;
+		case 2:
+			screen_write_clearline(sctx, bg);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		break;
+	case INPUT_CSI_HPA:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_cursormove(sctx, n - 1, -1, 1);
+		break;
+	case INPUT_CSI_ICH:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_insertcharacter(sctx, n, bg);
+		break;
+	case INPUT_CSI_IL:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_insertline(sctx, n, bg);
+		break;
+	case INPUT_CSI_REP:
+		n = input_get(ictx, 0, 1, 1);
+		if (n == -1)
+			break;
+
+		m = screen_size_x(s) - s->cx;
+		if (n > m)
+			n = m;
+
+		if (ictx->last == -1)
+			break;
+		ictx->ch = ictx->last;
+
+		for (i = 0; i < n; i++)
+			input_print(ictx);
+		break;
+	case INPUT_CSI_RCP:
+		input_restore_state(ictx);
+		break;
+	case INPUT_CSI_RM:
+		input_csi_dispatch_rm(ictx);
+		break;
+	case INPUT_CSI_RM_PRIVATE:
+		input_csi_dispatch_rm_private(ictx);
+		break;
+	case INPUT_CSI_SCP:
+		input_save_state(ictx);
+		break;
+	case INPUT_CSI_SGR:
+		input_csi_dispatch_sgr(ictx);
+		break;
+	case INPUT_CSI_SM:
+		input_csi_dispatch_sm(ictx);
+		break;
+	case INPUT_CSI_SM_PRIVATE:
+		input_csi_dispatch_sm_private(ictx);
+		break;
+	case INPUT_CSI_SU:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_scrollup(sctx, n, bg);
+		break;
+	case INPUT_CSI_SD:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_scrolldown(sctx, n, bg);
+		break;
+	case INPUT_CSI_TBC:
+		switch (input_get(ictx, 0, 0, 0)) {
+		case -1:
+			break;
+		case 0:
+			if (s->cx < screen_size_x(s))
+				bit_clear(s->tabs, s->cx);
+			break;
+		case 3:
+			bit_nclear(s->tabs, 0, screen_size_x(s) - 1);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		break;
+	case INPUT_CSI_VPA:
+		n = input_get(ictx, 0, 1, 1);
+		if (n != -1)
+			screen_write_cursormove(sctx, -1, n - 1, 1);
+		break;
+	case INPUT_CSI_DECSCUSR:
+		n = input_get(ictx, 0, 0, 0);
+		if (n != -1)
+			screen_set_cursor_style(n, &s->cstyle, &s->mode);
+		break;
+	case INPUT_CSI_XDA:
+		n = input_get(ictx, 0, 0, 0);
+		if (n == 0)
+			input_reply(ictx, "\033P>|tmux %s\033\\", getversion());
+		break;
+
+	}
+
+	ictx->last = -1;
+	return (0);
+}
+
+/* Handle CSI RM. */
+static void
+input_csi_dispatch_rm(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	u_int			 i;
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		switch (input_get(ictx, i, 0, -1)) {
+		case -1:
+			break;
+		case 4:		/* IRM */
+			screen_write_mode_clear(sctx, MODE_INSERT);
+			break;
+		case 34:
+			screen_write_mode_set(sctx, MODE_CURSOR_VERY_VISIBLE);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+	}
+}
+
+/* Handle CSI private RM. */
+static void
+input_csi_dispatch_rm_private(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct grid_cell	*gc = &ictx->cell.cell;
+	u_int			 i;
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		switch (input_get(ictx, i, 0, -1)) {
+		case -1:
+			break;
+		case 1:		/* DECCKM */
+			screen_write_mode_clear(sctx, MODE_KCURSOR);
+			break;
+		case 3:		/* DECCOLM */
+			screen_write_cursormove(sctx, 0, 0, 1);
+			screen_write_clearscreen(sctx, gc->bg);
+			break;
+		case 6:		/* DECOM */
+			screen_write_mode_clear(sctx, MODE_ORIGIN);
+			screen_write_cursormove(sctx, 0, 0, 1);
+			break;
+		case 7:		/* DECAWM */
+			screen_write_mode_clear(sctx, MODE_WRAP);
+			break;
+		case 12:
+			screen_write_mode_clear(sctx, MODE_CURSOR_BLINKING);
+			screen_write_mode_set(sctx, MODE_CURSOR_BLINKING_SET);
+			break;
+		case 25:	/* TCEM */
+			screen_write_mode_clear(sctx, MODE_CURSOR);
+			break;
+		case 1000:
+		case 1001:
+		case 1002:
+		case 1003:
+			screen_write_mode_clear(sctx, ALL_MOUSE_MODES);
+			break;
+		case 1004:
+			screen_write_mode_clear(sctx, MODE_FOCUSON);
+			break;
+		case 1005:
+			screen_write_mode_clear(sctx, MODE_MOUSE_UTF8);
+			break;
+		case 1006:
+			screen_write_mode_clear(sctx, MODE_MOUSE_SGR);
+			break;
+		case 47:
+		case 1047:
+			screen_write_alternateoff(sctx, gc, 0);
+			break;
+		case 1049:
+			screen_write_alternateoff(sctx, gc, 1);
+			break;
+		case 2004:
+			screen_write_mode_clear(sctx, MODE_BRACKETPASTE);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+	}
+}
+
+/* Handle CSI SM. */
+static void
+input_csi_dispatch_sm(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	u_int			 i;
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		switch (input_get(ictx, i, 0, -1)) {
+		case -1:
+			break;
+		case 4:		/* IRM */
+			screen_write_mode_set(sctx, MODE_INSERT);
+			break;
+		case 34:
+			screen_write_mode_clear(sctx, MODE_CURSOR_VERY_VISIBLE);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+	}
+}
+
+/* Handle CSI private SM. */
+static void
+input_csi_dispatch_sm_private(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct window_pane	*wp = ictx->wp;
+	struct grid_cell	*gc = &ictx->cell.cell;
+	u_int			 i;
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		switch (input_get(ictx, i, 0, -1)) {
+		case -1:
+			break;
+		case 1:		/* DECCKM */
+			screen_write_mode_set(sctx, MODE_KCURSOR);
+			break;
+		case 3:		/* DECCOLM */
+			screen_write_cursormove(sctx, 0, 0, 1);
+			screen_write_clearscreen(sctx, ictx->cell.cell.bg);
+			break;
+		case 6:		/* DECOM */
+			screen_write_mode_set(sctx, MODE_ORIGIN);
+			screen_write_cursormove(sctx, 0, 0, 1);
+			break;
+		case 7:		/* DECAWM */
+			screen_write_mode_set(sctx, MODE_WRAP);
+			break;
+		case 12:
+			screen_write_mode_set(sctx, MODE_CURSOR_BLINKING);
+			screen_write_mode_set(sctx, MODE_CURSOR_BLINKING_SET);
+			break;
+		case 25:	/* TCEM */
+			screen_write_mode_set(sctx, MODE_CURSOR);
+			break;
+		case 1000:
+			screen_write_mode_clear(sctx, ALL_MOUSE_MODES);
+			screen_write_mode_set(sctx, MODE_MOUSE_STANDARD);
+			break;
+		case 1002:
+			screen_write_mode_clear(sctx, ALL_MOUSE_MODES);
+			screen_write_mode_set(sctx, MODE_MOUSE_BUTTON);
+			break;
+		case 1003:
+			screen_write_mode_clear(sctx, ALL_MOUSE_MODES);
+			screen_write_mode_set(sctx, MODE_MOUSE_ALL);
+			break;
+		case 1004:
+			if (sctx->s->mode & MODE_FOCUSON)
+				break;
+			screen_write_mode_set(sctx, MODE_FOCUSON);
+			if (wp == NULL)
+				break;
+			if (!options_get_number(global_options, "focus-events"))
+				break;
+			if (wp->flags & PANE_FOCUSED)
+				bufferevent_write(wp->event, "\033[I", 3);
+			else
+				bufferevent_write(wp->event, "\033[O", 3);
+			break;
+		case 1005:
+			screen_write_mode_set(sctx, MODE_MOUSE_UTF8);
+			break;
+		case 1006:
+			screen_write_mode_set(sctx, MODE_MOUSE_SGR);
+			break;
+		case 47:
+		case 1047:
+			screen_write_alternateon(sctx, gc, 0);
+			break;
+		case 1049:
+			screen_write_alternateon(sctx, gc, 1);
+			break;
+		case 2004:
+			screen_write_mode_set(sctx, MODE_BRACKETPASTE);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+	}
+}
+
+/* Handle CSI window operations. */
+static void
+input_csi_dispatch_winops(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct screen		*s = sctx->s;
+	struct window_pane	*wp = ictx->wp;
+	u_int			 x = screen_size_x(s), y = screen_size_y(s);
+	int			 n, m;
+
+	m = 0;
+	while ((n = input_get(ictx, m, 0, -1)) != -1) {
+		switch (n) {
+		case 1:
+		case 2:
+		case 5:
+		case 6:
+		case 7:
+		case 11:
+		case 13:
+		case 14:
+		case 19:
+		case 20:
+		case 21:
+		case 24:
+			break;
+		case 3:
+		case 4:
+		case 8:
+			m++;
+			if (input_get(ictx, m, 0, -1) == -1)
+				return;
+			/* FALLTHROUGH */
+		case 9:
+		case 10:
+			m++;
+			if (input_get(ictx, m, 0, -1) == -1)
+				return;
+			break;
+		case 22:
+			m++;
+			switch (input_get(ictx, m, 0, -1)) {
+			case -1:
+				return;
+			case 0:
+			case 2:
+				screen_push_title(sctx->s);
+				break;
+			}
+			break;
+		case 23:
+			m++;
+			switch (input_get(ictx, m, 0, -1)) {
+			case -1:
+				return;
+			case 0:
+			case 2:
+				screen_pop_title(sctx->s);
+				if (wp == NULL)
+					break;
+				notify_pane("pane-title-changed", wp);
+				server_redraw_window_borders(wp->window);
+				server_status_window(wp->window);
+				break;
+			}
+			break;
+		case 18:
+			input_reply(ictx, "\033[8;%u;%ut", x, y);
+			break;
+		default:
+			log_debug("%s: unknown '%c'", __func__, ictx->ch);
+			break;
+		}
+		m++;
+	}
+}
+
+/* Helper for 256 colour SGR. */
+static int
+input_csi_dispatch_sgr_256_do(struct input_ctx *ictx, int fgbg, int c)
+{
+	struct grid_cell	*gc = &ictx->cell.cell;
+
+	if (c == -1 || c > 255) {
+		if (fgbg == 38)
+			gc->fg = 8;
+		else if (fgbg == 48)
+			gc->bg = 8;
+	} else {
+		if (fgbg == 38)
+			gc->fg = c | COLOUR_FLAG_256;
+		else if (fgbg == 48)
+			gc->bg = c | COLOUR_FLAG_256;
+		else if (fgbg == 58)
+			gc->us = c | COLOUR_FLAG_256;
+	}
+	return (1);
+}
+
+/* Handle CSI SGR for 256 colours. */
+static void
+input_csi_dispatch_sgr_256(struct input_ctx *ictx, int fgbg, u_int *i)
+{
+	int	c;
+
+	c = input_get(ictx, (*i) + 1, 0, -1);
+	if (input_csi_dispatch_sgr_256_do(ictx, fgbg, c))
+		(*i)++;
+}
+
+/* Helper for RGB colour SGR. */
+static int
+input_csi_dispatch_sgr_rgb_do(struct input_ctx *ictx, int fgbg, int r, int g,
+    int b)
+{
+	struct grid_cell	*gc = &ictx->cell.cell;
+
+	if (r == -1 || r > 255)
+		return (0);
+	if (g == -1 || g > 255)
+		return (0);
+	if (b == -1 || b > 255)
+		return (0);
+
+	if (fgbg == 38)
+		gc->fg = colour_join_rgb(r, g, b);
+	else if (fgbg == 48)
+		gc->bg = colour_join_rgb(r, g, b);
+	else if (fgbg == 58)
+		gc->us = colour_join_rgb(r, g, b);
+	return (1);
+}
+
+/* Handle CSI SGR for RGB colours. */
+static void
+input_csi_dispatch_sgr_rgb(struct input_ctx *ictx, int fgbg, u_int *i)
+{
+	int	r, g, b;
+
+	r = input_get(ictx, (*i) + 1, 0, -1);
+	g = input_get(ictx, (*i) + 2, 0, -1);
+	b = input_get(ictx, (*i) + 3, 0, -1);
+	if (input_csi_dispatch_sgr_rgb_do(ictx, fgbg, r, g, b))
+		(*i) += 3;
+}
+
+/* Handle CSI SGR with a ISO parameter. */
+static void
+input_csi_dispatch_sgr_colon(struct input_ctx *ictx, u_int i)
+{
+	struct grid_cell	*gc = &ictx->cell.cell;
+	char			*s = ictx->param_list[i].str, *copy, *ptr, *out;
+	int			 p[8];
+	u_int			 n;
+	const char		*errstr;
+
+	for (n = 0; n < nitems(p); n++)
+		p[n] = -1;
+	n = 0;
+
+	ptr = copy = xstrdup(s);
+	while ((out = strsep(&ptr, ":")) != NULL) {
+		if (*out != '\0') {
+			p[n++] = strtonum(out, 0, INT_MAX, &errstr);
+			if (errstr != NULL || n == nitems(p)) {
+				free(copy);
+				return;
+			}
+		} else {
+			n++;
+			if (n == nitems(p)) {
+				free(copy);
+				return;
+			}
+		}
+		log_debug("%s: %u = %d", __func__, n - 1, p[n - 1]);
+	}
+	free(copy);
+
+	if (n == 0)
+		return;
+	if (p[0] == 4) {
+		if (n != 2)
+			return;
+		switch (p[1]) {
+		case 0:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			break;
+		case 1:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE;
+			break;
+		case 2:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE_2;
+			break;
+		case 3:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE_3;
+			break;
+		case 4:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE_4;
+			break;
+		case 5:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE_5;
+			break;
+		}
+		return;
+	}
+	if (n < 2 || (p[0] != 38 && p[0] != 48 && p[0] != 58))
+		return;
+	switch (p[1]) {
+	case 2:
+		if (n < 3)
+			break;
+		if (n == 5)
+			i = 2;
+		else
+			i = 3;
+		if (n < i + 3)
+			break;
+		input_csi_dispatch_sgr_rgb_do(ictx, p[0], p[i], p[i + 1],
+		    p[i + 2]);
+		break;
+	case 5:
+		if (n < 3)
+			break;
+		input_csi_dispatch_sgr_256_do(ictx, p[0], p[2]);
+		break;
+	}
+}
+
+/* Handle CSI SGR. */
+static void
+input_csi_dispatch_sgr(struct input_ctx *ictx)
+{
+	struct grid_cell	*gc = &ictx->cell.cell;
+	u_int			 i;
+	int			 n;
+
+	if (ictx->param_list_len == 0) {
+		memcpy(gc, &grid_default_cell, sizeof *gc);
+		return;
+	}
+
+	for (i = 0; i < ictx->param_list_len; i++) {
+		if (ictx->param_list[i].type == INPUT_STRING) {
+			input_csi_dispatch_sgr_colon(ictx, i);
+			continue;
+		}
+		n = input_get(ictx, i, 0, 0);
+		if (n == -1)
+			continue;
+
+		if (n == 38 || n == 48 || n == 58) {
+			i++;
+			switch (input_get(ictx, i, 0, -1)) {
+			case 2:
+				input_csi_dispatch_sgr_rgb(ictx, n, &i);
+				break;
+			case 5:
+				input_csi_dispatch_sgr_256(ictx, n, &i);
+				break;
+			}
+			continue;
+		}
+
+		switch (n) {
+		case 0:
+			memcpy(gc, &grid_default_cell, sizeof *gc);
+			break;
+		case 1:
+			gc->attr |= GRID_ATTR_BRIGHT;
+			break;
+		case 2:
+			gc->attr |= GRID_ATTR_DIM;
+			break;
+		case 3:
+			gc->attr |= GRID_ATTR_ITALICS;
+			break;
+		case 4:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE;
+			break;
+		case 5:
+		case 6:
+			gc->attr |= GRID_ATTR_BLINK;
+			break;
+		case 7:
+			gc->attr |= GRID_ATTR_REVERSE;
+			break;
+		case 8:
+			gc->attr |= GRID_ATTR_HIDDEN;
+			break;
+		case 9:
+			gc->attr |= GRID_ATTR_STRIKETHROUGH;
+			break;
+		case 21:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			gc->attr |= GRID_ATTR_UNDERSCORE_2;
+			break;
+		case 22:
+			gc->attr &= ~(GRID_ATTR_BRIGHT|GRID_ATTR_DIM);
+			break;
+		case 23:
+			gc->attr &= ~GRID_ATTR_ITALICS;
+			break;
+		case 24:
+			gc->attr &= ~GRID_ATTR_ALL_UNDERSCORE;
+			break;
+		case 25:
+			gc->attr &= ~GRID_ATTR_BLINK;
+			break;
+		case 27:
+			gc->attr &= ~GRID_ATTR_REVERSE;
+			break;
+		case 28:
+			gc->attr &= ~GRID_ATTR_HIDDEN;
+			break;
+		case 29:
+			gc->attr &= ~GRID_ATTR_STRIKETHROUGH;
+			break;
+		case 30:
+		case 31:
+		case 32:
+		case 33:
+		case 34:
+		case 35:
+		case 36:
+		case 37:
+			gc->fg = n - 30;
+			break;
+		case 39:
+			gc->fg = 8;
+			break;
+		case 40:
+		case 41:
+		case 42:
+		case 43:
+		case 44:
+		case 45:
+		case 46:
+		case 47:
+			gc->bg = n - 40;
+			break;
+		case 49:
+			gc->bg = 8;
+			break;
+		case 53:
+			gc->attr |= GRID_ATTR_OVERLINE;
+			break;
+		case 55:
+			gc->attr &= ~GRID_ATTR_OVERLINE;
+			break;
+		case 59:
+			gc->us = 0;
+			break;
+		case 90:
+		case 91:
+		case 92:
+		case 93:
+		case 94:
+		case 95:
+		case 96:
+		case 97:
+			gc->fg = n;
+			break;
+		case 100:
+		case 101:
+		case 102:
+		case 103:
+		case 104:
+		case 105:
+		case 106:
+		case 107:
+			gc->bg = n - 10;
+			break;
+		}
+	}
+}
+
+/* End of input with BEL. */
+static int
+input_end_bel(struct input_ctx *ictx)
+{
+	log_debug("%s", __func__);
+
+	ictx->input_end = INPUT_END_BEL;
+
+	return (0);
+}
+
+/* DCS string started. */
+static void
+input_enter_dcs(struct input_ctx *ictx)
+{
+	log_debug("%s", __func__);
+
+	input_clear(ictx);
+	input_start_timer(ictx);
+	ictx->last = -1;
+}
+
+/* DCS terminator (ST) received. */
+static int
+input_dcs_dispatch(struct input_ctx *ictx)
+{
+	struct window_pane	*wp = ictx->wp;
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	u_char			*buf = ictx->input_buf;
+	size_t			 len = ictx->input_len;
+	const char		 prefix[] = "tmux;";
+	const u_int		 prefixlen = (sizeof prefix) - 1;
+
+	if (wp == NULL)
+		return (0);
+	if (ictx->flags & INPUT_DISCARD)
+		return (0);
+	if (!options_get_number(ictx->wp->options, "allow-passthrough"))
+		return (0);
+	log_debug("%s: \"%s\"", __func__, buf);
+
+	if (len >= prefixlen && strncmp(buf, prefix, prefixlen) == 0)
+		screen_write_rawstring(sctx, buf + prefixlen, len - prefixlen);
+
+	return (0);
+}
+
+/* OSC string started. */
+static void
+input_enter_osc(struct input_ctx *ictx)
+{
+	log_debug("%s", __func__);
+
+	input_clear(ictx);
+	input_start_timer(ictx);
+	ictx->last = -1;
+}
+
+/* OSC terminator (ST) received. */
+static void
+input_exit_osc(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct window_pane	*wp = ictx->wp;
+	u_char			*p = ictx->input_buf;
+	u_int			 option;
+
+	if (ictx->flags & INPUT_DISCARD)
+		return;
+	if (ictx->input_len < 1 || *p < '0' || *p > '9')
+		return;
+
+	log_debug("%s: \"%s\" (end %s)", __func__, p,
+	    ictx->input_end == INPUT_END_ST ? "ST" : "BEL");
+
+	option = 0;
+	while (*p >= '0' && *p <= '9')
+		option = option * 10 + *p++ - '0';
+	if (*p == ';')
+		p++;
+
+	switch (option) {
+	case 0:
+	case 2:
+		if (screen_set_title(sctx->s, p) && wp != NULL) {
+			notify_pane("pane-title-changed", wp);
+			server_redraw_window_borders(wp->window);
+			server_status_window(wp->window);
+		}
+		break;
+	case 4:
+		input_osc_4(ictx, p);
+		break;
+	case 7:
+		if (utf8_isvalid(p)) {
+			screen_set_path(sctx->s, p);
+			if (wp != NULL) {
+				server_redraw_window_borders(wp->window);
+				server_status_window(wp->window);
+			}
+		}
+		break;
+	case 10:
+		input_osc_10(ictx, p);
+		break;
+	case 11:
+		input_osc_11(ictx, p);
+		break;
+	case 12:
+		input_osc_12(ictx, p);
+		break;
+	case 52:
+		input_osc_52(ictx, p);
+		break;
+	case 104:
+		input_osc_104(ictx, p);
+		break;
+	case 110:
+		input_osc_110(ictx, p);
+		break;
+	case 111:
+		input_osc_111(ictx, p);
+		break;
+	case 112:
+		input_osc_112(ictx, p);
+		break;
+	default:
+		log_debug("%s: unknown '%u'", __func__, option);
+		break;
+	}
+}
+
+/* APC string started. */
+static void
+input_enter_apc(struct input_ctx *ictx)
+{
+	log_debug("%s", __func__);
+
+	input_clear(ictx);
+	input_start_timer(ictx);
+	ictx->last = -1;
+}
+
+/* APC terminator (ST) received. */
+static void
+input_exit_apc(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct window_pane	*wp = ictx->wp;
+
+	if (ictx->flags & INPUT_DISCARD)
+		return;
+	log_debug("%s: \"%s\"", __func__, ictx->input_buf);
+
+	if (screen_set_title(sctx->s, ictx->input_buf) && wp != NULL) {
+		notify_pane("pane-title-changed", wp);
+		server_redraw_window_borders(wp->window);
+		server_status_window(wp->window);
+	}
+}
+
+/* Rename string started. */
+static void
+input_enter_rename(struct input_ctx *ictx)
+{
+	log_debug("%s", __func__);
+
+	input_clear(ictx);
+	input_start_timer(ictx);
+	ictx->last = -1;
+}
+
+/* Rename terminator (ST) received. */
+static void
+input_exit_rename(struct input_ctx *ictx)
+{
+	struct window_pane	*wp = ictx->wp;
+	struct window		*w;
+	struct options_entry	*o;
+
+	if (wp == NULL)
+		return;
+	if (ictx->flags & INPUT_DISCARD)
+		return;
+	if (!options_get_number(ictx->wp->options, "allow-rename"))
+		return;
+	log_debug("%s: \"%s\"", __func__, ictx->input_buf);
+
+	if (!utf8_isvalid(ictx->input_buf))
+		return;
+	w = wp->window;
+
+	if (ictx->input_len == 0) {
+		o = options_get_only(w->options, "automatic-rename");
+		if (o != NULL)
+			options_remove_or_default(o, -1, NULL);
+		if (!options_get_number(w->options, "automatic-rename"))
+			window_set_name(w, "");
+	} else {
+		options_set_number(w->options, "automatic-rename", 0);
+		window_set_name(w, ictx->input_buf);
+	}
+	server_redraw_window_borders(w);
+	server_status_window(w);
+}
+
+/* Open UTF-8 character. */
+static int
+input_top_bit_set(struct input_ctx *ictx)
+{
+	struct screen_write_ctx	*sctx = &ictx->ctx;
+	struct utf8_data	*ud = &ictx->utf8data;
+
+	ictx->last = -1;
+
+	if (!ictx->utf8started) {
+		if (utf8_open(ud, ictx->ch) != UTF8_MORE)
+			return (0);
+		ictx->utf8started = 1;
+		return (0);
+	}
+
+	switch (utf8_append(ud, ictx->ch)) {
+	case UTF8_MORE:
+		return (0);
+	case UTF8_ERROR:
+		ictx->utf8started = 0;
+		return (0);
+	case UTF8_DONE:
+		break;
+	}
+	ictx->utf8started = 0;
+
+	log_debug("%s %hhu '%*s' (width %hhu)", __func__, ud->size,
+	    (int)ud->size, ud->data, ud->width);
+
+	utf8_copy(&ictx->cell.cell.data, ud);
+	screen_write_collect_add(sctx, &ictx->cell.cell);
+
+	return (0);
+}
+
+/* Parse colour from OSC. */
+static int
+input_osc_parse_colour(const char *p)
+{
+	double	 c, m, y, k = 0;
+	u_int	 r, g, b;
+	size_t	 len = strlen(p);
+	int	 colour = -1;
+	char	*copy;
+
+	if ((len == 12 && sscanf(p, "rgb:%02x/%02x/%02x", &r, &g, &b) == 3) ||
+	    (len == 7 && sscanf(p, "#%02x%02x%02x", &r, &g, &b) == 3) ||
+	    sscanf(p, "%d,%d,%d", &r, &g, &b) == 3)
+		colour = colour_join_rgb(r, g, b);
+	else if ((len == 18 &&
+	    sscanf(p, "rgb:%04x/%04x/%04x", &r, &g, &b) == 3) ||
+	    (len == 13 && sscanf(p, "#%04x%04x%04x", &r, &g, &b) == 3))
+		colour = colour_join_rgb(r >> 8, g >> 8, b >> 8);
+	else if ((sscanf(p, "cmyk:%lf/%lf/%lf/%lf", &c, &m, &y, &k) == 4 ||
+	    sscanf(p, "cmy:%lf/%lf/%lf", &c, &m, &y) == 3) &&
+	    c >= 0 && c <= 1 && m >= 0 && m <= 1 &&
+	    y >= 0 && y <= 1 && k >= 0 && k <= 1) {
+		colour = colour_join_rgb(
+		    (1 - c) * (1 - k) * 255,
+		    (1 - m) * (1 - k) * 255,
+		    (1 - y) * (1 - k) * 255);
+	} else {
+		while (len != 0 && *p == ' ') {
+			p++;
+			len--;
+		}
+		while (len != 0 && p[len - 1] == ' ')
+			len--;
+		copy = xstrndup(p, len);
+		colour = colour_byname(copy);
+		free(copy);
+	}
+	log_debug("%s: %s = %s", __func__, p, colour_tostring(colour));
+	return (colour);
+}
+
+/* Reply to a colour request. */
+static void
+input_osc_colour_reply(struct input_ctx *ictx, u_int n, int c)
+{
+    u_char	 r, g, b;
+    const char	*end;
+
+    if (c != -1)
+	    c = colour_force_rgb(c);
+    if (c == -1)
+	    return;
+    colour_split_rgb(c, &r, &g, &b);
+
+    if (ictx->input_end == INPUT_END_BEL)
+	    end = "\007";
+    else
+	    end = "\033\\";
+    input_reply(ictx, "\033]%u;rgb:%02hhx%02hhx/%02hhx%02hhx/%02hhx%02hhx%s",
+	n, r, r, g, g, b, b, end);
+}
+
+/* Handle the OSC 4 sequence for setting (multiple) palette entries. */
+static void
+input_osc_4(struct input_ctx *ictx, const char *p)
+{
+	char	*copy, *s, *next = NULL;
+	long	 idx;
+	int	 c, bad = 0, redraw = 0;
+
+	copy = s = xstrdup(p);
+	while (s != NULL && *s != '\0') {
+		idx = strtol(s, &next, 10);
+		if (*next++ != ';') {
+			bad = 1;
+			break;
+		}
+		if (idx < 0 || idx >= 256) {
+			bad = 1;
+			break;
+		}
+
+		s = strsep(&next, ";");
+		if (strcmp(s, "?") == 0) {
+			c = colour_palette_get(ictx->palette, idx);
+			if (c != -1)
+				input_osc_colour_reply(ictx, 4, c);
+			continue;
+		}
+		if ((c = input_osc_parse_colour(s)) == -1) {
+			s = next;
+			continue;
+		}
+		if (colour_palette_set(ictx->palette, idx, c))
+			redraw = 1;
+		s = next;
+	}
+	if (bad)
+		log_debug("bad OSC 4: %s", p);
+	if (redraw)
+		screen_write_fullredraw(&ictx->ctx);
+	free(copy);
+}
+
+/* Handle the OSC 10 sequence for setting and querying foreground colour. */
+static void
+input_osc_10(struct input_ctx *ictx, const char *p)
+{
+	struct window_pane	*wp = ictx->wp;
+	struct grid_cell	 defaults;
+	int			 c;
+
+	if (strcmp(p, "?") == 0) {
+		if (wp != NULL) {
+			tty_default_colours(&defaults, wp);
+			input_osc_colour_reply(ictx, 10, defaults.fg);
+		}
+		return;
+	}
+
+	if ((c = input_osc_parse_colour(p)) == -1) {
+		log_debug("bad OSC 10: %s", p);
+		return;
+	}
+	if (ictx->palette != NULL) {
+		ictx->palette->fg = c;
+		if (wp != NULL)
+			wp->flags |= PANE_STYLECHANGED;
+		screen_write_fullredraw(&ictx->ctx);
+	}
+}
+
+/* Handle the OSC 110 sequence for resetting foreground colour. */
+static void
+input_osc_110(struct input_ctx *ictx, const char *p)
+{
+	struct window_pane	*wp = ictx->wp;
+
+	if (*p != '\0')
+		return;
+	if (ictx->palette != NULL) {
+		ictx->palette->fg = 8;
+		if (wp != NULL)
+			wp->flags |= PANE_STYLECHANGED;
+		screen_write_fullredraw(&ictx->ctx);
+	}
+}
+
+/* Handle the OSC 11 sequence for setting and querying background colour. */
+static void
+input_osc_11(struct input_ctx *ictx, const char *p)
+{
+	struct window_pane	*wp = ictx->wp;
+	struct grid_cell	 defaults;
+	int			 c;
+
+	if (strcmp(p, "?") == 0) {
+		if (wp != NULL) {
+			tty_default_colours(&defaults, wp);
+			input_osc_colour_reply(ictx, 11, defaults.bg);
+		}
+		return;
+	}
+
+	if ((c = input_osc_parse_colour(p)) == -1) {
+		log_debug("bad OSC 11: %s", p);
+		return;
+	}
+	if (ictx->palette != NULL) {
+		ictx->palette->bg = c;
+		if (wp != NULL)
+			wp->flags |= PANE_STYLECHANGED;
+		screen_write_fullredraw(&ictx->ctx);
+	}
+}
+
+/* Handle the OSC 111 sequence for resetting background colour. */
+static void
+input_osc_111(struct input_ctx *ictx, const char *p)
+{
+	struct window_pane	*wp = ictx->wp;
+
+	if (*p != '\0')
+		return;
+	if (ictx->palette != NULL) {
+		ictx->palette->bg = 8;
+		if (wp != NULL)
+			wp->flags |= PANE_STYLECHANGED;
+		screen_write_fullredraw(&ictx->ctx);
+	}
+}
+
+/* Handle the OSC 12 sequence for setting and querying cursor colour. */
+static void
+input_osc_12(struct input_ctx *ictx, const char *p)
+{
+	struct window_pane	*wp = ictx->wp;
+	int			 c;
+
+	if (strcmp(p, "?") == 0) {
+		if (wp != NULL) {
+			c = ictx->ctx.s->ccolour;
+			if (c == -1)
+				c = ictx->ctx.s->default_ccolour;
+			input_osc_colour_reply(ictx, 12, c);
+		}
+		return;
+	}
+
+	if ((c = input_osc_parse_colour(p)) == -1) {
+		log_debug("bad OSC 12: %s", p);
+		return;
+	}
+	screen_set_cursor_colour(ictx->ctx.s, c);
+}
+
+/* Handle the OSC 112 sequence for resetting cursor colour. */
+static void
+input_osc_112(struct input_ctx *ictx, const char *p)
+{
+	if (*p == '\0') /* no arguments allowed */
+		screen_set_cursor_colour(ictx->ctx.s, -1);
+}
+
+
+/* Handle the OSC 52 sequence for setting the clipboard. */
+static void
+input_osc_52(struct input_ctx *ictx, const char *p)
+{
+	struct window_pane	*wp = ictx->wp;
+	char			*end;
+	const char		*buf = NULL;
+	size_t			 len = 0;
+	u_char			*out;
+	int			 outlen, state;
+	struct screen_write_ctx	 ctx;
+	struct paste_buffer	*pb;
+
+	if (wp == NULL)
+		return;
+	state = options_get_number(global_options, "set-clipboard");
+	if (state != 2)
+		return;
+
+	if ((end = strchr(p, ';')) == NULL)
+		return;
+	end++;
+	if (*end == '\0')
+		return;
+	log_debug("%s: %s", __func__, end);
+
+	if (strcmp(end, "?") == 0) {
+		if ((pb = paste_get_top(NULL)) != NULL)
+			buf = paste_buffer_data(pb, &len);
+		if (ictx->input_end == INPUT_END_BEL)
+			input_reply_clipboard(ictx->event, buf, len, "\007");
+		else
+			input_reply_clipboard(ictx->event, buf, len, "\033\\");
+		return;
+	}
+
+	len = (strlen(end) / 4) * 3;
+	if (len == 0)
+		return;
+
+	out = xmalloc(len);
+	if ((outlen = b64_pton(end, out, len)) == -1) {
+		free(out);
+		return;
+	}
+
+	screen_write_start_pane(&ctx, wp, NULL);
+	screen_write_setselection(&ctx, out, outlen);
+	screen_write_stop(&ctx);
+	notify_pane("pane-set-clipboard", wp);
+
+	paste_add(NULL, out, outlen);
+}
+
+/* Handle the OSC 104 sequence for unsetting (multiple) palette entries. */
+static void
+input_osc_104(struct input_ctx *ictx, const char *p)
+{
+	char	*copy, *s;
+	long	 idx;
+	int	 bad = 0, redraw = 0;
+
+	if (*p == '\0') {
+		colour_palette_clear(ictx->palette);
+		screen_write_fullredraw(&ictx->ctx);
+		return;
+	}
+
+	copy = s = xstrdup(p);
+	while (*s != '\0') {
+		idx = strtol(s, &s, 10);
+		if (*s != '\0' && *s != ';') {
+			bad = 1;
+			break;
+		}
+		if (idx < 0 || idx >= 256) {
+			bad = 1;
+			break;
+		}
+		if (colour_palette_set(ictx->palette, idx, -1))
+			redraw = 1;
+		if (*s == ';')
+			s++;
+	}
+	if (bad)
+		log_debug("bad OSC 104: %s", p);
+	if (redraw)
+		screen_write_fullredraw(&ictx->ctx);
+	free(copy);
+}
+
+void
+input_reply_clipboard(struct bufferevent *bev, const char *buf, size_t len,
+    const char *end)
+{
+	char	*out = NULL;
+	size_t	 outlen = 0;
+
+	if (buf != NULL && len != 0) {
+		outlen = 4 * ((len + 2) / 3) + 1;
+		out = xmalloc(outlen);
+		if ((outlen = b64_ntop(buf, len, out, outlen)) == -1) {
+			free(out);
+			return;
+		}
+	}
+
+	bufferevent_write(bev, "\033]52;;", 6);
+	if (outlen != 0)
+		bufferevent_write(bev, out, outlen);
+	bufferevent_write(bev, end, strlen(end));
+	free(out);
+}