/* $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 <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 screen_write_ctx ctx;

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 window_pane *,

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_52(struct input_ctx *, const char *);

static void input_osc_104(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_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,

};

/* 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 },

{ 'n', "", INPUT_CSI_DSR },

{ 'q', " ", INPUT_CSI_DECSCUSR },

{ '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;

struct window_pane *wp = ictx->wp;

log_debug("%s: %%%u %s expired" , __func__, wp->id, ictx->state->name);

input_reset(wp, 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;

}

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. */

void

input_init(struct window_pane *wp)

{

struct input_ctx *ictx;

ictx = wp->ictx = xcalloc(1, sizeof *ictx);

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(wp, 0);

}

/* Destroy input parser. */

void

input_free(struct window_pane *wp)

{

struct input_ctx *ictx = wp->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);

wp->ictx = NULL;

}

/* Reset input state and clear screen. */

void

input_reset(struct window_pane *wp, int clear)

{

struct input_ctx *ictx = wp->ictx;

struct screen_write_ctx *sctx = &ictx->ctx;

input_reset_cell(ictx);

if (clear) {

if (TAILQ_EMPTY(&wp->modes))

screen_write_start(sctx, wp, &wp->base);

else

screen_write_start(sctx, NULL, &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 window_pane *wp)

{

return (wp->ictx->since_ground);

}

/* Change input state. */

static void

input_set_state(struct window_pane *wp, const struct input_transition *itr)

{

struct input_ctx *ictx = wp->ictx;

if (ictx->state->exit != NULL)

ictx->state->exit(ictx);

ictx->state = itr->state;

if (ictx->state->enter != NULL)

ictx->state->enter(ictx);

}

/* Parse input. */

void

input_parse(struct window_pane *wp)

{

struct evbuffer *evb = wp->event->input;

input_parse_buffer(wp, EVBUFFER_DATA(evb), EVBUFFER_LENGTH(evb));

evbuffer_drain(evb, EVBUFFER_LENGTH(evb));

}

/* 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;

const struct input_state *state = NULL;

const struct input_transition *itr = NULL;

size_t off = 0;

if (len == 0)

return;

window_update_activity(wp->window);

wp->flags |= PANE_CHANGED;

notify_input(wp, buf, len);

/*

* Open the screen. Use NULL wp if there is a mode set as don't want to

* update the tty.

*/

if (TAILQ_EMPTY(&wp->modes))

screen_write_start(sctx, wp, &wp->base);

else

screen_write_start(sctx, NULL, &wp->base);

ictx->wp = wp;

log_debug("%s: %%%u %s, %zu bytes: %.*s", __func__, wp->id,

ictx->state->name, len, (int)len, buf);

/* 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(wp, itr);

/* If not in ground state, save input. */

if (ictx->state != &input_state_ground)

evbuffer_add(ictx->since_ground, &ictx->ch, 1);

}

/* Close the screen. */

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);

}