src/tsm_vte.c

   1 /*
   2  * libtsm - VT Emulator
   3  *
   4  * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files
   8  * (the "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  21  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /*
  27  * Virtual Terminal Emulator
  28  * This is the VT implementation. It is written from scratch. It uses the
  29  * screen state-machine as output and is tightly bound to it. It supports
  30  * functionality from vt100 up to vt500 series. It doesn't implement an
  31  * explicitly selected terminal but tries to support the most important commands
  32  * to be compatible with existing implementations. However, full vt102
  33  * compatibility is the least that is provided.
  34  *
  35  * The main parser in this file controls the parser-state and dispatches the
  36  * actions to the related handlers. The parser is based on the state-diagram
  37  * from Paul Williams: http://vt100.net/emu/
  38  * It is written from scratch, though.
  39  * This parser is fully compatible up to the vt500 series. It requires UTF-8 and
  40  * does not support any other input encoding. The G0 and G1 sets are therefore
  41  * defined as subsets of UTF-8. You may still map G0-G3 into GL, though.
  42  *
  43  * However, the CSI/DCS/etc handlers are not designed after a specific VT
  44  * series. We try to support all vt102 commands but implement several other
  45  * often used sequences, too. Feel free to add further.
  46  */
  47
  48 #include <errno.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include "libtsm.h"
  53 #include "shl_llog.h"
  54 #include "shl_misc.h"
  55
  56 #ifdef BUILD_HAVE_XKBCOMMON
  57 #  include <xkbcommon/xkbcommon-keysyms.h>
  58 #else
  59 #  include "external/xkbcommon-keysyms.h"
  60 #endif
  61
  62 #define LLOG_SUBSYSTEM "tsm_vte"
  63
  64 /* Input parser states */
  65 enum parser_state {
  66         STATE_NONE,             /* placeholder */
  67         STATE_GROUND,           /* initial state and ground */
  68         STATE_ESC,              /* ESC sequence was started */
  69         STATE_ESC_INT,          /* intermediate escape characters */
  70         STATE_CSI_ENTRY,        /* starting CSI sequence */
  71         STATE_CSI_PARAM,        /* CSI parameters */
  72         STATE_CSI_INT,          /* intermediate CSI characters */
  73         STATE_CSI_IGNORE,       /* CSI error; ignore this CSI sequence */
  74         STATE_DCS_ENTRY,        /* starting DCS sequence */
  75         STATE_DCS_PARAM,        /* DCS parameters */
  76         STATE_DCS_INT,          /* intermediate DCS characters */
  77         STATE_DCS_PASS,         /* DCS data passthrough */
  78         STATE_DCS_IGNORE,       /* DCS error; ignore this DCS sequence */
  79         STATE_OSC_STRING,       /* parsing OCS sequence */
  80         STATE_ST_IGNORE,        /* unimplemented seq; ignore until ST */
  81         STATE_NUM
  82 };
  83
  84 /* Input parser actions */
  85 enum parser_action {
  86         ACTION_NONE,            /* placeholder */
  87         ACTION_IGNORE,          /* ignore the character entirely */
  88         ACTION_PRINT,           /* print the character on the console */
  89         ACTION_EXECUTE,         /* execute single control character (C0/C1) */
  90         ACTION_CLEAR,           /* clear current parameter state */
  91         ACTION_COLLECT,         /* collect intermediate character */
  92         ACTION_PARAM,           /* collect parameter character */
  93         ACTION_ESC_DISPATCH,    /* dispatch escape sequence */
  94         ACTION_CSI_DISPATCH,    /* dispatch csi sequence */
  95         ACTION_DCS_START,       /* start of DCS data */
  96         ACTION_DCS_COLLECT,     /* collect DCS data */
  97         ACTION_DCS_END,         /* end of DCS data */
  98         ACTION_OSC_START,       /* start of OSC data */
  99         ACTION_OSC_COLLECT,     /* collect OSC data */
 100         ACTION_OSC_END,         /* end of OSC data */
 101         ACTION_NUM
 102 };
 103
 104 /* CSI flags */
 105 #define CSI_BANG        0x0001          /* CSI: ! */
 106 #define CSI_CASH        0x0002          /* CSI: $ */
 107 #define CSI_WHAT        0x0004          /* CSI: ? */
 108 #define CSI_GT          0x0008          /* CSI: > */
 109 #define CSI_SPACE       0x0010          /* CSI:   */
 110 #define CSI_SQUOTE      0x0020          /* CSI: ' */
 111 #define CSI_DQUOTE      0x0040          /* CSI: " */
 112 #define CSI_MULT        0x0080          /* CSI: * */
 113 #define CSI_PLUS        0x0100          /* CSI: + */
 114 #define CSI_POPEN       0x0200          /* CSI: ( */
 115 #define CSI_PCLOSE      0x0400          /* CSI: ) */
 116
 117 /* max CSI arguments */
 118 #define CSI_ARG_MAX 16
 119
 120 /* terminal flags */
 121 #define FLAG_CURSOR_KEY_MODE                    0x00000001 /* DEC cursor key mode */
 122 #define FLAG_KEYPAD_APPLICATION_MODE            0x00000002 /* DEC keypad application mode; TODO: toggle on numlock? */
 123 #define FLAG_LINE_FEED_NEW_LINE_MODE            0x00000004 /* DEC line-feed/new-line mode */
 124 #define FLAG_8BIT_MODE                          0x00000008 /* Disable UTF-8 mode and enable 8bit compatible mode */
 125 #define FLAG_7BIT_MODE                          0x00000010 /* Disable 8bit mode and use 7bit compatible mode */
 126 #define FLAG_USE_C1                             0x00000020 /* Explicitly use 8bit C1 codes; TODO: implement */
 127 #define FLAG_KEYBOARD_ACTION_MODE               0x00000040 /* Disable keyboard; TODO: implement? */
 128 #define FLAG_INSERT_REPLACE_MODE                0x00000080 /* Enable insert mode */
 129 #define FLAG_SEND_RECEIVE_MODE                  0x00000100 /* Disable local echo */
 130 #define FLAG_TEXT_CURSOR_MODE                   0x00000200 /* Show cursor */
 131 #define FLAG_INVERSE_SCREEN_MODE                0x00000400 /* Inverse colors */
 132 #define FLAG_ORIGIN_MODE                        0x00000800 /* Relative origin for cursor */
 133 #define FLAG_AUTO_WRAP_MODE                     0x00001000 /* Auto line wrap mode */
 134 #define FLAG_AUTO_REPEAT_MODE                   0x00002000 /* Auto repeat key press; TODO: implement */
 135 #define FLAG_NATIONAL_CHARSET_MODE              0x00004000 /* Send keys from nation charsets; TODO: implement */
 136 #define FLAG_BACKGROUND_COLOR_ERASE_MODE        0x00008000 /* Set background color on erase (bce) */
 137 #define FLAG_PREPEND_ESCAPE                     0x00010000 /* Prepend escape character to next output */
 138 #define FLAG_TITE_INHIBIT_MODE                  0x00020000 /* Prevent switching to alternate screen buffer */
 139
 140 struct vte_saved_state {
 141         unsigned int cursor_x;
 142         unsigned int cursor_y;
 143         struct tsm_screen_attr cattr;
 144         tsm_vte_charset **gl;
 145         tsm_vte_charset **gr;
 146         bool wrap_mode;
 147         bool origin_mode;
 148 };
 149
 150 struct tsm_vte {
 151         unsigned long ref;
 152         tsm_log_t llog;
 153         void *llog_data;
 154         struct tsm_screen *con;
 155         tsm_vte_write_cb write_cb;
 156         void *data;
 157         char *palette_name;
 158
 159         struct tsm_utf8_mach *mach;
 160         unsigned long parse_cnt;
 161
 162         unsigned int state;
 163         unsigned int csi_argc;
 164         int csi_argv[CSI_ARG_MAX];
 165         unsigned int csi_flags;
 166
 167         uint8_t (*palette)[3];
 168         struct tsm_screen_attr def_attr;
 169         struct tsm_screen_attr cattr;
 170         unsigned int flags;
 171
 172         tsm_vte_charset **gl;
 173         tsm_vte_charset **gr;
 174         tsm_vte_charset **glt;
 175         tsm_vte_charset **grt;
 176         tsm_vte_charset *g0;
 177         tsm_vte_charset *g1;
 178         tsm_vte_charset *g2;
 179         tsm_vte_charset *g3;
 180
 181         struct vte_saved_state saved_state;
 182         unsigned int alt_cursor_x;
 183         unsigned int alt_cursor_y;
 184 };
 185
 186 enum vte_color {
 187         COLOR_BLACK,
 188         COLOR_RED,
 189         COLOR_GREEN,
 190         COLOR_YELLOW,
 191         COLOR_BLUE,
 192         COLOR_MAGENTA,
 193         COLOR_CYAN,
 194         COLOR_LIGHT_GREY,
 195         COLOR_DARK_GREY,
 196         COLOR_LIGHT_RED,
 197         COLOR_LIGHT_GREEN,
 198         COLOR_LIGHT_YELLOW,
 199         COLOR_LIGHT_BLUE,
 200         COLOR_LIGHT_MAGENTA,
 201         COLOR_LIGHT_CYAN,
 202         COLOR_WHITE,
 203         COLOR_FOREGROUND,
 204         COLOR_BACKGROUND,
 205         COLOR_NUM
 206 };
 207
 208 static uint8_t color_palette[COLOR_NUM][3] = {
 209         [COLOR_BLACK]         = {   0,   0,   0 }, /* black */
 210         [COLOR_RED]           = { 205,   0,   0 }, /* red */
 211         [COLOR_GREEN]         = {   0, 205,   0 }, /* green */
 212         [COLOR_YELLOW]        = { 205, 205,   0 }, /* yellow */
 213         [COLOR_BLUE]          = {   0,   0, 238 }, /* blue */
 214         [COLOR_MAGENTA]       = { 205,   0, 205 }, /* magenta */
 215         [COLOR_CYAN]          = {   0, 205, 205 }, /* cyan */
 216         [COLOR_LIGHT_GREY]    = { 229, 229, 229 }, /* light grey */
 217         [COLOR_DARK_GREY]     = { 127, 127, 127 }, /* dark grey */
 218         [COLOR_LIGHT_RED]     = { 255,   0,   0 }, /* light red */
 219         [COLOR_LIGHT_GREEN]   = {   0, 255,   0 }, /* light green */
 220         [COLOR_LIGHT_YELLOW]  = { 255, 255,   0 }, /* light yellow */
 221         [COLOR_LIGHT_BLUE]    = {  92,  92, 255 }, /* light blue */
 222         [COLOR_LIGHT_MAGENTA] = { 255,   0, 255 }, /* light magenta */
 223         [COLOR_LIGHT_CYAN]    = {   0, 255, 255 }, /* light cyan */
 224         [COLOR_WHITE]         = { 255, 255, 255 }, /* white */
 225
 226         [COLOR_FOREGROUND]    = { 229, 229, 229 }, /* light grey */
 227         [COLOR_BACKGROUND]    = {   0,   0,   0 }, /* black */
 228 };
 229
 230 static uint8_t color_palette_solarized[COLOR_NUM][3] = {
 231         [COLOR_BLACK]         = {   7,  54,  66 }, /* black */
 232         [COLOR_RED]           = { 220,  50,  47 }, /* red */
 233         [COLOR_GREEN]         = { 133, 153,   0 }, /* green */
 234         [COLOR_YELLOW]        = { 181, 137,   0 }, /* yellow */
 235         [COLOR_BLUE]          = {  38, 139, 210 }, /* blue */
 236         [COLOR_MAGENTA]       = { 211,  54, 130 }, /* magenta */
 237         [COLOR_CYAN]          = {  42, 161, 152 }, /* cyan */
 238         [COLOR_LIGHT_GREY]    = { 238, 232, 213 }, /* light grey */
 239         [COLOR_DARK_GREY]     = {   0,  43,  54 }, /* dark grey */
 240         [COLOR_LIGHT_RED]     = { 203,  75,  22 }, /* light red */
 241         [COLOR_LIGHT_GREEN]   = {  88, 110, 117 }, /* light green */
 242         [COLOR_LIGHT_YELLOW]  = { 101, 123, 131 }, /* light yellow */
 243         [COLOR_LIGHT_BLUE]    = { 131, 148, 150 }, /* light blue */
 244         [COLOR_LIGHT_MAGENTA] = { 108, 113, 196 }, /* light magenta */
 245         [COLOR_LIGHT_CYAN]    = { 147, 161, 161 }, /* light cyan */
 246         [COLOR_WHITE]         = { 253, 246, 227 }, /* white */
 247
 248         [COLOR_FOREGROUND]    = { 238, 232, 213 }, /* light grey */
 249         [COLOR_BACKGROUND]    = {   7,  54,  66 }, /* black */
 250 };
 251
 252 static uint8_t color_palette_solarized_black[COLOR_NUM][3] = {
 253         [COLOR_BLACK]         = {   0,   0,   0 }, /* black */
 254         [COLOR_RED]           = { 220,  50,  47 }, /* red */
 255         [COLOR_GREEN]         = { 133, 153,   0 }, /* green */
 256         [COLOR_YELLOW]        = { 181, 137,   0 }, /* yellow */
 257         [COLOR_BLUE]          = {  38, 139, 210 }, /* blue */
 258         [COLOR_MAGENTA]       = { 211,  54, 130 }, /* magenta */
 259         [COLOR_CYAN]          = {  42, 161, 152 }, /* cyan */
 260         [COLOR_LIGHT_GREY]    = { 238, 232, 213 }, /* light grey */
 261         [COLOR_DARK_GREY]     = {   0,  43,  54 }, /* dark grey */
 262         [COLOR_LIGHT_RED]     = { 203,  75,  22 }, /* light red */
 263         [COLOR_LIGHT_GREEN]   = {  88, 110, 117 }, /* light green */
 264         [COLOR_LIGHT_YELLOW]  = { 101, 123, 131 }, /* light yellow */
 265         [COLOR_LIGHT_BLUE]    = { 131, 148, 150 }, /* light blue */
 266         [COLOR_LIGHT_MAGENTA] = { 108, 113, 196 }, /* light magenta */
 267         [COLOR_LIGHT_CYAN]    = { 147, 161, 161 }, /* light cyan */
 268         [COLOR_WHITE]         = { 253, 246, 227 }, /* white */
 269
 270         [COLOR_FOREGROUND]    = { 238, 232, 213 }, /* light grey */
 271         [COLOR_BACKGROUND]    = {   0,   0,   0 }, /* black */
 272 };
 273
 274 static uint8_t color_palette_solarized_white[COLOR_NUM][3] = {
 275         [COLOR_BLACK]         = {   7,  54,  66 }, /* black */
 276         [COLOR_RED]           = { 220,  50,  47 }, /* red */
 277         [COLOR_GREEN]         = { 133, 153,   0 }, /* green */
 278         [COLOR_YELLOW]        = { 181, 137,   0 }, /* yellow */
 279         [COLOR_BLUE]          = {  38, 139, 210 }, /* blue */
 280         [COLOR_MAGENTA]       = { 211,  54, 130 }, /* magenta */
 281         [COLOR_CYAN]          = {  42, 161, 152 }, /* cyan */
 282         [COLOR_LIGHT_GREY]    = { 238, 232, 213 }, /* light grey */
 283         [COLOR_DARK_GREY]     = {   0,  43,  54 }, /* dark grey */
 284         [COLOR_LIGHT_RED]     = { 203,  75,  22 }, /* light red */
 285         [COLOR_LIGHT_GREEN]   = {  88, 110, 117 }, /* light green */
 286         [COLOR_LIGHT_YELLOW]  = { 101, 123, 131 }, /* light yellow */
 287         [COLOR_LIGHT_BLUE]    = { 131, 148, 150 }, /* light blue */
 288         [COLOR_LIGHT_MAGENTA] = { 108, 113, 196 }, /* light magenta */
 289         [COLOR_LIGHT_CYAN]    = { 147, 161, 161 }, /* light cyan */
 290         [COLOR_WHITE]         = { 253, 246, 227 }, /* white */
 291
 292         [COLOR_FOREGROUND]    = {   7,  54,  66 }, /* black */
 293         [COLOR_BACKGROUND]    = { 238, 232, 213 }, /* light grey */
 294 };
 295
 296 static uint8_t (*get_palette(struct tsm_vte *vte))[3]
 297 {
 298         if (!vte->palette_name)
 299                 return color_palette;
 300
 301         if (!strcmp(vte->palette_name, "solarized"))
 302                 return color_palette_solarized;
 303         if (!strcmp(vte->palette_name, "solarized-black"))
 304                 return color_palette_solarized_black;
 305         if (!strcmp(vte->palette_name, "solarized-white"))
 306                 return color_palette_solarized_white;
 307
 308         return color_palette;
 309 }
 310
 311 /* Several effects may occur when non-RGB colors are used. For instance, if bold
 312  * is enabled, then a dark color code is always converted to a light color to
 313  * simulate bold (even though bold may actually be supported!). To support this,
 314  * we need to differentiate between a set color-code and a set rgb-color.
 315  * This function actually converts a set color-code into an RGB color. This must
 316  * be called before passing the attribute to the console layer so the console
 317  * layer can always work with RGB values and does not have to care for color
 318  * codes. */
 319 static void to_rgb(struct tsm_vte *vte, struct tsm_screen_attr *attr)
 320 {
 321         int8_t code;
 322
 323         code = attr->fccode;
 324         if (code >= 0) {
 325                 /* bold causes light colors */
 326                 if (attr->bold && code < 8)
 327                         code += 8;
 328                 if (code >= COLOR_NUM)
 329                         code = COLOR_FOREGROUND;
 330
 331                 attr->fr = vte->palette[code][0];
 332                 attr->fg = vte->palette[code][1];
 333                 attr->fb = vte->palette[code][2];
 334         }
 335
 336         code = attr->bccode;
 337         if (code >= 0) {
 338                 if (code >= COLOR_NUM)
 339                         code = COLOR_BACKGROUND;
 340
 341                 attr->br = vte->palette[code][0];
 342                 attr->bg = vte->palette[code][1];
 343                 attr->bb = vte->palette[code][2];
 344         }
 345 }
 346
 347 static void copy_fcolor(struct tsm_screen_attr *dest,
 348                         const struct tsm_screen_attr *src)
 349 {
 350         dest->fccode = src->fccode;
 351         dest->fr = src->fr;
 352         dest->fg = src->fg;
 353         dest->fb = src->fb;
 354 }
 355
 356 static void copy_bcolor(struct tsm_screen_attr *dest,
 357                         const struct tsm_screen_attr *src)
 358 {
 359         dest->bccode = src->bccode;
 360         dest->br = src->br;
 361         dest->bg = src->bg;
 362         dest->bb = src->bb;
 363 }
 364
 365 SHL_EXPORT
 366 int tsm_vte_new(struct tsm_vte **out, struct tsm_screen *con,
 367                 tsm_vte_write_cb write_cb, void *data,
 368                 tsm_log_t log, void *log_data)
 369 {
 370         struct tsm_vte *vte;
 371         int ret;
 372
 373         if (!out || !con || !write_cb)
 374                 return -EINVAL;
 375
 376         vte = malloc(sizeof(*vte));
 377         if (!vte)
 378                 return -ENOMEM;
 379
 380         memset(vte, 0, sizeof(*vte));
 381         vte->ref = 1;
 382         vte->llog = log;
 383         vte->llog_data = log_data;
 384         vte->con = con;
 385         vte->write_cb = write_cb;
 386         vte->data = data;
 387         vte->palette = get_palette(vte);
 388         vte->def_attr.fccode = COLOR_FOREGROUND;
 389         vte->def_attr.bccode = COLOR_BACKGROUND;
 390         to_rgb(vte, &vte->def_attr);
 391
 392         ret = tsm_utf8_mach_new(&vte->mach);
 393         if (ret)
 394                 goto err_free;
 395
 396         tsm_vte_reset(vte);
 397         tsm_screen_erase_screen(vte->con, false);
 398
 399         llog_debug(vte, "new vte object");
 400         tsm_screen_ref(vte->con);
 401         *out = vte;
 402         return 0;
 403
 404 err_free:
 405         free(vte);
 406         return ret;
 407 }
 408
 409 SHL_EXPORT
 410 void tsm_vte_ref(struct tsm_vte *vte)
 411 {
 412         if (!vte)
 413                 return;
 414
 415         vte->ref++;
 416 }
 417
 418 SHL_EXPORT
 419 void tsm_vte_unref(struct tsm_vte *vte)
 420 {
 421         if (!vte || !vte->ref)
 422                 return;
 423
 424         if (--vte->ref)
 425                 return;
 426
 427         llog_debug(vte, "destroying vte object");
 428         tsm_screen_unref(vte->con);
 429         tsm_utf8_mach_free(vte->mach);
 430         free(vte);
 431 }
 432
 433 SHL_EXPORT
 434 int tsm_vte_set_palette(struct tsm_vte *vte, const char *palette)
 435 {
 436         char *tmp = NULL;
 437
 438         if (!vte)
 439                 return -EINVAL;
 440
 441         if (palette) {
 442                 tmp = strdup(palette);
 443                 if (!tmp)
 444                         return -ENOMEM;
 445         }
 446
 447         free(vte->palette_name);
 448         vte->palette_name = tmp;
 449
 450         vte->palette = get_palette(vte);
 451         vte->def_attr.fccode = COLOR_FOREGROUND;
 452         vte->def_attr.bccode = COLOR_BACKGROUND;
 453
 454         to_rgb(vte, &vte->def_attr);
 455         memcpy(&vte->cattr, &vte->def_attr, sizeof(vte->cattr));
 456
 457         tsm_screen_set_def_attr(vte->con, &vte->def_attr);
 458         tsm_screen_erase_screen(vte->con, false);
 459
 460         return 0;
 461 }
 462
 463 /*
 464  * Write raw byte-stream to pty.
 465  * When writing data to the client we must make sure that we send the correct
 466  * encoding. For backwards-compatibility reasons we should always send 7bit
 467  * characters exclusively. However, when FLAG_7BIT_MODE is not set, then we can
 468  * also send raw 8bit characters. For instance, in FLAG_8BIT_MODE we can use the
 469  * GR characters as keyboard input and send them directly or even use the C1
 470  * escape characters. In unicode mode (default) we can send multi-byte utf-8
 471  * characters which are also 8bit. When sending these characters, set the \raw
 472  * flag to true so this function does not perform debug checks on data we send.
 473  * If debugging is disabled, these checks are also disabled and won't affect
 474  * performance.
 475  * For better debugging, we also use the __LINE__ and __FILE__ macros. Use the
 476  * vte_write() and vte_write_raw() macros below for more convenient use.
 477  *
 478  * As a rule of thumb do never send 8bit characters in escape sequences and also
 479  * avoid all 8bit escape codes including the C1 codes. This will guarantee that
 480  * all kind of clients are always compatible to us.
 481  *
 482  * If SEND_RECEIVE_MODE is off (that is, local echo is on) we have to send all
 483  * data directly to ourself again. However, we must avoid recursion when
 484  * tsm_vte_input() itself calls vte_write*(), therefore, we increase the
 485  * PARSER counter when entering tsm_vte_input() and reset it when leaving it
 486  * so we never echo data that origins from tsm_vte_input().
 487  * But note that SEND_RECEIVE_MODE is inherently broken for escape sequences
 488  * that request answers. That is, if we send a request to the client that awaits
 489  * a response and parse that request via local echo ourself, then we will also
 490  * send a response to the client even though he didn't request one. This
 491  * recursion fix does not avoid this but only prevents us from endless loops
 492  * here. Anyway, only few applications rely on local echo so we can safely
 493  * ignore this.
 494  */
 495 static void vte_write_debug(struct tsm_vte *vte, const char *u8, size_t len,
 496                             bool raw, const char *file, int line)
 497 {
 498 #ifdef BUILD_ENABLE_DEBUG
 499         /* in debug mode we check that escape sequences are always <0x7f so they
 500          * are correctly parsed by non-unicode and non-8bit-mode clients. */
 501         size_t i;
 502
 503         if (!raw) {
 504                 for (i = 0; i < len; ++i) {
 505                         if (u8[i] & 0x80)
 506                                 llog_warning(vte, "sending 8bit character inline to client in %s:%d",
 507                                              file, line);
 508                 }
 509         }
 510 #endif
 511
 512         /* in local echo mode, directly parse the data again */
 513         if (!vte->parse_cnt && !(vte->flags & FLAG_SEND_RECEIVE_MODE)) {
 514                 if (vte->flags & FLAG_PREPEND_ESCAPE)
 515                         tsm_vte_input(vte, "\e", 1);
 516                 tsm_vte_input(vte, u8, len);
 517         }
 518
 519         if (vte->flags & FLAG_PREPEND_ESCAPE)
 520                 vte->write_cb(vte, "\e", 1, vte->data);
 521         vte->write_cb(vte, u8, len, vte->data);
 522
 523         vte->flags &= ~FLAG_PREPEND_ESCAPE;
 524 }
 525
 526 #define vte_write(_vte, _u8, _len) \
 527         vte_write_debug((_vte), (_u8), (_len), false, __FILE__, __LINE__)
 528 #define vte_write_raw(_vte, _u8, _len) \
 529         vte_write_debug((_vte), (_u8), (_len), true, __FILE__, __LINE__)
 530
 531 /* write to console */
 532 static void write_console(struct tsm_vte *vte, tsm_symbol_t sym)
 533 {
 534         to_rgb(vte, &vte->cattr);
 535         tsm_screen_write(vte->con, sym, &vte->cattr);
 536 }
 537
 538 static void reset_state(struct tsm_vte *vte)
 539 {
 540         vte->saved_state.cursor_x = 0;
 541         vte->saved_state.cursor_y = 0;
 542         vte->saved_state.origin_mode = false;
 543         vte->saved_state.wrap_mode = true;
 544         vte->saved_state.gl = &vte->g0;
 545         vte->saved_state.gr = &vte->g1;
 546
 547         copy_fcolor(&vte->saved_state.cattr, &vte->def_attr);
 548         copy_bcolor(&vte->saved_state.cattr, &vte->def_attr);
 549         vte->saved_state.cattr.bold = 0;
 550         vte->saved_state.cattr.underline = 0;
 551         vte->saved_state.cattr.inverse = 0;
 552         vte->saved_state.cattr.protect = 0;
 553         vte->saved_state.cattr.blink = 0;
 554 }
 555
 556 static void save_state(struct tsm_vte *vte)
 557 {
 558         vte->saved_state.cursor_x = tsm_screen_get_cursor_x(vte->con);
 559         vte->saved_state.cursor_y = tsm_screen_get_cursor_y(vte->con);
 560         vte->saved_state.cattr = vte->cattr;
 561         vte->saved_state.gl = vte->gl;
 562         vte->saved_state.gr = vte->gr;
 563         vte->saved_state.wrap_mode = vte->flags & FLAG_AUTO_WRAP_MODE;
 564         vte->saved_state.origin_mode = vte->flags & FLAG_ORIGIN_MODE;
 565 }
 566
 567 static void restore_state(struct tsm_vte *vte)
 568 {
 569         tsm_screen_move_to(vte->con, vte->saved_state.cursor_x,
 570                                vte->saved_state.cursor_y);
 571         vte->cattr = vte->saved_state.cattr;
 572         to_rgb(vte, &vte->cattr);
 573         if (vte->flags & FLAG_BACKGROUND_COLOR_ERASE_MODE)
 574                 tsm_screen_set_def_attr(vte->con, &vte->cattr);
 575         vte->gl = vte->saved_state.gl;
 576         vte->gr = vte->saved_state.gr;
 577
 578         if (vte->saved_state.wrap_mode) {
 579                 vte->flags |= FLAG_AUTO_WRAP_MODE;
 580                 tsm_screen_set_flags(vte->con, TSM_SCREEN_AUTO_WRAP);
 581         } else {
 582                 vte->flags &= ~FLAG_AUTO_WRAP_MODE;
 583                 tsm_screen_reset_flags(vte->con, TSM_SCREEN_AUTO_WRAP);
 584         }
 585
 586         if (vte->saved_state.origin_mode) {
 587                 vte->flags |= FLAG_ORIGIN_MODE;
 588                 tsm_screen_set_flags(vte->con, TSM_SCREEN_REL_ORIGIN);
 589         } else {
 590                 vte->flags &= ~FLAG_ORIGIN_MODE;
 591                 tsm_screen_reset_flags(vte->con, TSM_SCREEN_REL_ORIGIN);
 592         }
 593 }
 594
 595 /*
 596  * Reset VTE state
 597  * This performs a soft reset of the VTE. That is, everything is reset to the
 598  * same state as when the VTE was created. This does not affect the console,
 599  * though.
 600  */
 601 SHL_EXPORT
 602 void tsm_vte_reset(struct tsm_vte *vte)
 603 {
 604         if (!vte)
 605                 return;
 606
 607         vte->flags = 0;
 608         vte->flags |= FLAG_TEXT_CURSOR_MODE;
 609         vte->flags |= FLAG_AUTO_REPEAT_MODE;
 610         vte->flags |= FLAG_SEND_RECEIVE_MODE;
 611         vte->flags |= FLAG_AUTO_WRAP_MODE;
 612         vte->flags |= FLAG_BACKGROUND_COLOR_ERASE_MODE;
 613         tsm_screen_reset(vte->con);
 614         tsm_screen_set_flags(vte->con, TSM_SCREEN_AUTO_WRAP);
 615
 616         tsm_utf8_mach_reset(vte->mach);
 617         vte->state = STATE_GROUND;
 618         vte->gl = &vte->g0;
 619         vte->gr = &vte->g1;
 620         vte->glt = NULL;
 621         vte->grt = NULL;
 622         vte->g0 = &tsm_vte_unicode_lower;
 623         vte->g1 = &tsm_vte_unicode_upper;
 624         vte->g2 = &tsm_vte_unicode_lower;
 625         vte->g3 = &tsm_vte_unicode_upper;
 626
 627         memcpy(&vte->cattr, &vte->def_attr, sizeof(vte->cattr));
 628         to_rgb(vte, &vte->cattr);
 629         tsm_screen_set_def_attr(vte->con, &vte->def_attr);
 630
 631         reset_state(vte);
 632 }
 633
 634 SHL_EXPORT
 635 void tsm_vte_hard_reset(struct tsm_vte *vte)
 636 {
 637         tsm_vte_reset(vte);
 638         tsm_screen_erase_screen(vte->con, false);
 639         tsm_screen_clear_sb(vte->con);
 640         tsm_screen_move_to(vte->con, 0, 0);
 641 }
 642
 643 static void send_primary_da(struct tsm_vte *vte)
 644 {
 645         vte_write(vte, "\e[?60;1;6;9;15c", 17);
 646 }
 647
 648 /* execute control character (C0 or C1) */
 649 static void do_execute(struct tsm_vte *vte, uint32_t ctrl)
 650 {
 651         switch (ctrl) {
 652         case 0x00: /* NUL */
 653                 /* Ignore on input */
 654                 break;
 655         case 0x05: /* ENQ */
 656                 /* Transmit answerback message */
 657                 /* TODO: is there a better answer than ACK?  */
 658                 vte_write(vte, "\x06", 1);
 659                 break;
 660         case 0x07: /* BEL */
 661                 /* Sound bell tone */
 662                 /* TODO: I always considered this annying, however, we
 663                  * should at least provide some way to enable it if the
 664                  * user *really* wants it.
 665                  */
 666                 break;
 667         case 0x08: /* BS */
 668                 /* Move cursor one position left */
 669                 tsm_screen_move_left(vte->con, 1);
 670                 break;
 671         case 0x09: /* HT */
 672                 /* Move to next tab stop or end of line */
 673                 tsm_screen_tab_right(vte->con, 1);
 674                 break;
 675         case 0x0a: /* LF */
 676         case 0x0b: /* VT */
 677         case 0x0c: /* FF */
 678                 /* Line feed or newline (CR/NL mode) */
 679                 if (vte->flags & FLAG_LINE_FEED_NEW_LINE_MODE)
 680                         tsm_screen_newline(vte->con);
 681                 else
 682                         tsm_screen_move_down(vte->con, 1, true);
 683                 break;
 684         case 0x0d: /* CR */
 685                 /* Move cursor to left margin */
 686                 tsm_screen_move_line_home(vte->con);
 687                 break;
 688         case 0x0e: /* SO */
 689                 /* Map G1 character set into GL */
 690                 vte->gl = &vte->g1;
 691                 break;
 692         case 0x0f: /* SI */
 693                 /* Map G0 character set into GL */
 694                 vte->gl = &vte->g0;
 695                 break;
 696         case 0x11: /* XON */
 697                 /* Resume transmission */
 698                 /* TODO */
 699                 break;
 700         case 0x13: /* XOFF */
 701                 /* Stop transmission */
 702                 /* TODO */
 703                 break;
 704         case 0x18: /* CAN */
 705                 /* Cancel escape sequence */
 706                 /* nothing to do here */
 707                 break;
 708         case 0x1a: /* SUB */
 709                 /* Discard current escape sequence and show err-sym */
 710                 write_console(vte, 0xbf);
 711                 break;
 712         case 0x1b: /* ESC */
 713                 /* Invokes an escape sequence */
 714                 /* nothing to do here */
 715                 break;
 716         case 0x1f: /* DEL */
 717                 /* Ignored */
 718                 break;
 719         case 0x84: /* IND */
 720                 /* Move down one row, perform scroll-up if needed */
 721                 tsm_screen_move_down(vte->con, 1, true);
 722                 break;
 723         case 0x85: /* NEL */
 724                 /* CR/NL with scroll-up if needed */
 725                 tsm_screen_newline(vte->con);
 726                 break;
 727         case 0x88: /* HTS */
 728                 /* Set tab stop at current position */
 729                 tsm_screen_set_tabstop(vte->con);
 730                 break;
 731         case 0x8d: /* RI */
 732                 /* Move up one row, perform scroll-down if needed */
 733                 tsm_screen_move_up(vte->con, 1, true);
 734                 break;
 735         case 0x8e: /* SS2 */
 736                 /* Temporarily map G2 into GL for next char only */
 737                 vte->glt = &vte->g2;
 738                 break;
 739         case 0x8f: /* SS3 */
 740                 /* Temporarily map G3 into GL for next char only */
 741                 vte->glt = &vte->g3;
 742                 break;
 743         case 0x9a: /* DECID */
 744                 /* Send device attributes response like ANSI DA */
 745                 send_primary_da(vte);
 746                 break;
 747         case 0x9c: /* ST */
 748                 /* End control string */
 749                 /* nothing to do here */
 750                 break;
 751         default:
 752                 llog_debug(vte, "unhandled control char %u", ctrl);
 753         }
 754 }
 755
 756 static void do_clear(struct tsm_vte *vte)
 757 {
 758         int i;
 759
 760         vte->csi_argc = 0;
 761         for (i = 0; i < CSI_ARG_MAX; ++i)
 762                 vte->csi_argv[i] = -1;
 763         vte->csi_flags = 0;
 764 }
 765
 766 static void do_collect(struct tsm_vte *vte, uint32_t data)
 767 {
 768         switch (data) {
 769         case '!':
 770                 vte->csi_flags |= CSI_BANG;
 771                 break;
 772         case '$':
 773                 vte->csi_flags |= CSI_CASH;
 774                 break;
 775         case '?':
 776                 vte->csi_flags |= CSI_WHAT;
 777                 break;
 778         case '>':
 779                 vte->csi_flags |= CSI_GT;
 780                 break;
 781         case ' ':
 782                 vte->csi_flags |= CSI_SPACE;
 783                 break;
 784         case '\'':
 785                 vte->csi_flags |= CSI_SQUOTE;
 786                 break;
 787         case '"':
 788                 vte->csi_flags |= CSI_DQUOTE;
 789                 break;
 790         case '*':
 791                 vte->csi_flags |= CSI_MULT;
 792                 break;
 793         case '+':
 794                 vte->csi_flags |= CSI_PLUS;
 795                 break;
 796         case '(':
 797                 vte->csi_flags |= CSI_POPEN;
 798                 break;
 799         case ')':
 800                 vte->csi_flags |= CSI_PCLOSE;
 801                 break;
 802         }
 803 }
 804
 805 static void do_param(struct tsm_vte *vte, uint32_t data)
 806 {
 807         int new;
 808
 809         if (data == ';') {
 810                 if (vte->csi_argc < CSI_ARG_MAX)
 811                         vte->csi_argc++;
 812                 return;
 813         }
 814
 815         if (vte->csi_argc >= CSI_ARG_MAX)
 816                 return;
 817
 818         /* avoid integer overflows; max allowed value is 16384 anyway */
 819         if (vte->csi_argv[vte->csi_argc] > 0xffff)
 820                 return;
 821
 822         if (data >= '0' && data <= '9') {
 823                 new = vte->csi_argv[vte->csi_argc];
 824                 if (new <= 0)
 825                         new = data - '0';
 826                 else
 827                         new = new * 10 + data - '0';
 828                 vte->csi_argv[vte->csi_argc] = new;
 829         }
 830 }
 831
 832 static bool set_charset(struct tsm_vte *vte, tsm_vte_charset *set)
 833 {
 834         if (vte->csi_flags & CSI_POPEN)
 835                 vte->g0 = set;
 836         else if (vte->csi_flags & CSI_PCLOSE)
 837                 vte->g1 = set;
 838         else if (vte->csi_flags & CSI_MULT)
 839                 vte->g2 = set;
 840         else if (vte->csi_flags & CSI_PLUS)
 841                 vte->g3 = set;
 842         else
 843                 return false;
 844
 845         return true;
 846 }
 847
 848 static void do_esc(struct tsm_vte *vte, uint32_t data)
 849 {
 850         switch (data) {
 851         case 'B': /* map ASCII into G0-G3 */
 852                 if (set_charset(vte, &tsm_vte_unicode_lower))
 853                         return;
 854                 break;
 855         case '<': /* map DEC supplemental into G0-G3 */
 856                 if (set_charset(vte, &tsm_vte_dec_supplemental_graphics))
 857                         return;
 858                 break;
 859         case '0': /* map DEC special into G0-G3 */
 860                 if (set_charset(vte, &tsm_vte_dec_special_graphics))
 861                         return;
 862                 break;
 863         case 'A': /* map British into G0-G3 */
 864                 /* TODO: create British charset from DEC */
 865                 if (set_charset(vte, &tsm_vte_unicode_upper))
 866                         return;
 867                 break;
 868         case '4': /* map Dutch into G0-G3 */
 869                 /* TODO: create Dutch charset from DEC */
 870                 if (set_charset(vte, &tsm_vte_unicode_upper))
 871                         return;
 872                 break;
 873         case 'C':
 874         case '5': /* map Finnish into G0-G3 */
 875                 /* TODO: create Finnish charset from DEC */
 876                 if (set_charset(vte, &tsm_vte_unicode_upper))
 877                         return;
 878                 break;
 879         case 'R': /* map French into G0-G3 */
 880                 /* TODO: create French charset from DEC */
 881                 if (set_charset(vte, &tsm_vte_unicode_upper))
 882                         return;
 883                 break;
 884         case 'Q': /* map French-Canadian into G0-G3 */
 885                 /* TODO: create French-Canadian charset from DEC */
 886                 if (set_charset(vte, &tsm_vte_unicode_upper))
 887                         return;
 888                 break;
 889         case 'K': /* map German into G0-G3 */
 890                 /* TODO: create German charset from DEC */
 891                 if (set_charset(vte, &tsm_vte_unicode_upper))
 892                         return;
 893                 break;
 894         case 'Y': /* map Italian into G0-G3 */
 895                 /* TODO: create Italian charset from DEC */
 896                 if (set_charset(vte, &tsm_vte_unicode_upper))
 897                         return;
 898                 break;
 899         case 'E':
 900         case '6': /* map Norwegian/Danish into G0-G3 */
 901                 /* TODO: create Norwegian/Danish charset from DEC */
 902                 if (set_charset(vte, &tsm_vte_unicode_upper))
 903                         return;
 904                 break;
 905         case 'Z': /* map Spanish into G0-G3 */
 906                 /* TODO: create Spanish charset from DEC */
 907                 if (set_charset(vte, &tsm_vte_unicode_upper))
 908                         return;
 909                 break;
 910         case 'H':
 911         case '7': /* map Swedish into G0-G3 */
 912                 /* TODO: create Swedish charset from DEC */
 913                 if (set_charset(vte, &tsm_vte_unicode_upper))
 914                         return;
 915                 break;
 916         case '=': /* map Swiss into G0-G3 */
 917                 /* TODO: create Swiss charset from DEC */
 918                 if (set_charset(vte, &tsm_vte_unicode_upper))
 919                         return;
 920                 break;
 921         case 'F':
 922                 if (vte->csi_flags & CSI_SPACE) {
 923                         /* S7C1T */
 924                         /* Disable 8bit C1 mode */
 925                         vte->flags &= ~FLAG_USE_C1;
 926                         return;
 927                 }
 928                 break;
 929         case 'G':
 930                 if (vte->csi_flags & CSI_SPACE) {
 931                         /* S8C1T */
 932                         /* Enable 8bit C1 mode */
 933                         vte->flags |= FLAG_USE_C1;
 934                         return;
 935                 }
 936                 break;
 937         }
 938
 939         /* everything below is only valid without CSI flags */
 940         if (vte->csi_flags) {
 941                 llog_debug(vte, "unhandled escape seq %u", data);
 942                 return;
 943         }
 944
 945         switch (data) {
 946         case 'D': /* IND */
 947                 /* Move down one row, perform scroll-up if needed */
 948                 tsm_screen_move_down(vte->con, 1, true);
 949                 break;
 950         case 'E': /* NEL */
 951                 /* CR/NL with scroll-up if needed */
 952                 tsm_screen_newline(vte->con);
 953                 break;
 954         case 'H': /* HTS */
 955                 /* Set tab stop at current position */
 956                 tsm_screen_set_tabstop(vte->con);
 957                 break;
 958         case 'M': /* RI */
 959                 /* Move up one row, perform scroll-down if needed */
 960                 tsm_screen_move_up(vte->con, 1, true);
 961                 break;
 962         case 'N': /* SS2 */
 963                 /* Temporarily map G2 into GL for next char only */
 964                 vte->glt = &vte->g2;
 965                 break;
 966         case 'O': /* SS3 */
 967                 /* Temporarily map G3 into GL for next char only */
 968                 vte->glt = &vte->g3;
 969                 break;
 970         case 'Z': /* DECID */
 971                 /* Send device attributes response like ANSI DA */
 972                 send_primary_da(vte);
 973                 break;
 974         case '\\': /* ST */
 975                 /* End control string */
 976                 /* nothing to do here */
 977                 break;
 978         case '~': /* LS1R */
 979                 /* Invoke G1 into GR */
 980                 vte->gr = &vte->g1;
 981                 break;
 982         case 'n': /* LS2 */
 983                 /* Invoke G2 into GL */
 984                 vte->gl = &vte->g2;
 985                 break;
 986         case '}': /* LS2R */
 987                 /* Invoke G2 into GR */
 988                 vte->gr = &vte->g2;
 989                 break;
 990         case 'o': /* LS3 */
 991                 /* Invoke G3 into GL */
 992                 vte->gl = &vte->g3;
 993                 break;
 994         case '|': /* LS3R */
 995                 /* Invoke G3 into GR */
 996                 vte->gr = &vte->g3;
 997                 break;
 998         case '=': /* DECKPAM */
 999                 /* Set application keypad mode */
1000                 vte->flags |= FLAG_KEYPAD_APPLICATION_MODE;
1001                 break;
1002         case '>': /* DECKPNM */
1003                 /* Set numeric keypad mode */
1004                 vte->flags &= ~FLAG_KEYPAD_APPLICATION_MODE;
1005                 break;
1006         case 'c': /* RIS */
1007                 /* hard reset */
1008                 tsm_vte_hard_reset(vte);
1009                 break;
1010         case '7': /* DECSC */
1011                 /* save console state */
1012                 save_state(vte);
1013                 break;
1014         case '8': /* DECRC */
1015                 /* restore console state */
1016                 restore_state(vte);
1017                 break;
1018         default:
1019                 llog_debug(vte, "unhandled escape seq %u", data);
1020         }
1021 }
1022
1023 static void csi_attribute(struct tsm_vte *vte)
1024 {
1025         static const uint8_t bval[6] = { 0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff };
1026         unsigned int i, code;
1027
1028         if (vte->csi_argc <= 1 && vte->csi_argv[0] == -1) {
1029                 vte->csi_argc = 1;
1030                 vte->csi_argv[0] = 0;
1031         }
1032
1033         for (i = 0; i < vte->csi_argc; ++i) {
1034                 switch (vte->csi_argv[i]) {
1035                 case -1:
1036                         break;
1037                 case 0:
1038                         copy_fcolor(&vte->cattr, &vte->def_attr);
1039                         copy_bcolor(&vte->cattr, &vte->def_attr);
1040                         vte->cattr.bold = 0;
1041                         vte->cattr.underline = 0;
1042                         vte->cattr.inverse = 0;
1043                         vte->cattr.blink = 0;
1044                         break;
1045                 case 1:
1046                         vte->cattr.bold = 1;
1047                         break;
1048                 case 4:
1049                         vte->cattr.underline = 1;
1050                         break;
1051                 case 5:
1052                         vte->cattr.blink = 1;
1053                         break;
1054                 case 7:
1055                         vte->cattr.inverse = 1;
1056                         break;
1057                 case 22:
1058                         vte->cattr.bold = 0;
1059                         break;
1060                 case 24:
1061                         vte->cattr.underline = 0;
1062                         break;
1063                 case 25:
1064                         vte->cattr.blink = 0;
1065                         break;
1066                 case 27:
1067                         vte->cattr.inverse = 0;
1068                         break;
1069                 case 30:
1070                         vte->cattr.fccode = COLOR_BLACK;
1071                         break;
1072                 case 31:
1073                         vte->cattr.fccode = COLOR_RED;
1074                         break;
1075                 case 32:
1076                         vte->cattr.fccode = COLOR_GREEN;
1077                         break;
1078                 case 33:
1079                         vte->cattr.fccode = COLOR_YELLOW;
1080                         break;
1081                 case 34:
1082                         vte->cattr.fccode = COLOR_BLUE;
1083                         break;
1084                 case 35:
1085                         vte->cattr.fccode = COLOR_MAGENTA;
1086                         break;
1087                 case 36:
1088                         vte->cattr.fccode = COLOR_CYAN;
1089                         break;
1090                 case 37:
1091                         vte->cattr.fccode = COLOR_LIGHT_GREY;
1092                         break;
1093                 case 39:
1094                         copy_fcolor(&vte->cattr, &vte->def_attr);
1095                         break;
1096                 case 40:
1097                         vte->cattr.bccode = COLOR_BLACK;
1098                         break;
1099                 case 41:
1100                         vte->cattr.bccode = COLOR_RED;
1101                         break;
1102                 case 42:
1103                         vte->cattr.bccode = COLOR_GREEN;
1104                         break;
1105                 case 43:
1106                         vte->cattr.bccode = COLOR_YELLOW;
1107                         break;
1108                 case 44:
1109                         vte->cattr.bccode = COLOR_BLUE;
1110                         break;
1111                 case 45:
1112                         vte->cattr.bccode = COLOR_MAGENTA;
1113                         break;
1114                 case 46:
1115                         vte->cattr.bccode = COLOR_CYAN;
1116                         break;
1117                 case 47:
1118                         vte->cattr.bccode = COLOR_LIGHT_GREY;
1119                         break;
1120                 case 49:
1121                         copy_bcolor(&vte->cattr, &vte->def_attr);
1122                         break;
1123                 case 90:
1124                         vte->cattr.fccode = COLOR_DARK_GREY;
1125                         break;
1126                 case 91:
1127                         vte->cattr.fccode = COLOR_LIGHT_RED;
1128                         break;
1129                 case 92:
1130                         vte->cattr.fccode = COLOR_LIGHT_GREEN;
1131                         break;
1132                 case 93:
1133                         vte->cattr.fccode = COLOR_LIGHT_YELLOW;
1134                         break;
1135                 case 94:
1136                         vte->cattr.fccode = COLOR_LIGHT_BLUE;
1137                         break;
1138                 case 95:
1139                         vte->cattr.fccode = COLOR_LIGHT_MAGENTA;
1140                         break;
1141                 case 96:
1142                         vte->cattr.fccode = COLOR_LIGHT_CYAN;
1143                         break;
1144                 case 97:
1145                         vte->cattr.fccode = COLOR_WHITE;
1146                         break;
1147                 case 100:
1148                         vte->cattr.bccode = COLOR_DARK_GREY;
1149                         break;
1150                 case 101:
1151                         vte->cattr.bccode = COLOR_LIGHT_RED;
1152                         break;
1153                 case 102:
1154                         vte->cattr.bccode = COLOR_LIGHT_GREEN;
1155                         break;
1156                 case 103:
1157                         vte->cattr.bccode = COLOR_LIGHT_YELLOW;
1158                         break;
1159                 case 104:
1160                         vte->cattr.bccode = COLOR_LIGHT_BLUE;
1161                         break;
1162                 case 105:
1163                         vte->cattr.bccode = COLOR_LIGHT_MAGENTA;
1164                         break;
1165                 case 106:
1166                         vte->cattr.bccode = COLOR_LIGHT_CYAN;
1167                         break;
1168                 case 107:
1169                         vte->cattr.bccode = COLOR_WHITE;
1170                         break;
1171                 case 38:
1172                         /* fallthrough */
1173                 case 48:
1174                         if (i + 2 >= vte->csi_argc ||
1175                             vte->csi_argv[i + 1] != 5 ||
1176                             vte->csi_argv[i + 2] < 0) {
1177                                 llog_debug(vte, "invalid 256color SGR");
1178                                 break;
1179                         }
1180
1181                         code = vte->csi_argv[i + 2];
1182                         if (vte->csi_argv[i] == 38) {
1183                                 if (code < 16) {
1184                                         vte->cattr.fccode = code;
1185                                 } else if (code < 232) {
1186                                         vte->cattr.fccode = -1;
1187                                         code -= 16;
1188                                         vte->cattr.fb = bval[code % 6];
1189                                         code /= 6;
1190                                         vte->cattr.fg = bval[code % 6];
1191                                         code /= 6;
1192                                         vte->cattr.fr = bval[code % 6];
1193                                 } else {
1194                                         vte->cattr.fccode = -1;
1195                                         code = (code - 232) * 10 + 8;
1196                                         vte->cattr.fr = code;
1197                                         vte->cattr.fg = code;
1198                                         vte->cattr.fb = code;
1199                                 }
1200                         } else {
1201                                 if (code < 16) {
1202                                         vte->cattr.bccode = code;
1203                                 } else if (code < 232) {
1204                                         vte->cattr.bccode = -1;
1205                                         code -= 16;
1206                                         vte->cattr.bb = bval[code % 6];
1207                                         code /= 6;
1208                                         vte->cattr.bg = bval[code % 6];
1209                                         code /= 6;
1210                                         vte->cattr.br = bval[code % 6];
1211                                 } else {
1212                                         vte->cattr.bccode = -1;
1213                                         code = (code - 232) * 10 + 8;
1214                                         vte->cattr.br = code;
1215                                         vte->cattr.bg = code;
1216                                         vte->cattr.bb = code;
1217                                 }
1218                         }
1219
1220                         i += 2;
1221                         break;
1222                 default:
1223                         llog_debug(vte, "unhandled SGR attr %i",
1224                                    vte->csi_argv[i]);
1225                 }
1226         }
1227
1228         to_rgb(vte, &vte->cattr);
1229         if (vte->flags & FLAG_BACKGROUND_COLOR_ERASE_MODE)
1230                 tsm_screen_set_def_attr(vte->con, &vte->cattr);
1231 }
1232
1233 static void csi_soft_reset(struct tsm_vte *vte)
1234 {
1235         tsm_vte_reset(vte);
1236 }
1237
1238 static void csi_compat_mode(struct tsm_vte *vte)
1239 {
1240         /* always perform soft reset */
1241         csi_soft_reset(vte);
1242
1243         if (vte->csi_argv[0] == 61) {
1244                 /* Switching to VT100 compatibility mode. We do
1245                  * not support this mode, so ignore it. In fact,
1246                  * we are almost compatible to it, anyway, so
1247                  * there is no need to explicitly select it.
1248                  * However, we enable 7bit mode to avoid
1249                  * character-table problems */
1250                 vte->flags |= FLAG_7BIT_MODE;
1251                 vte->g0 = &tsm_vte_unicode_lower;
1252                 vte->g1 = &tsm_vte_dec_supplemental_graphics;
1253         } else if (vte->csi_argv[0] == 62 ||
1254                    vte->csi_argv[0] == 63 ||
1255                    vte->csi_argv[0] == 64) {
1256                 /* Switching to VT2/3/4 compatibility mode. We
1257                  * are always compatible with this so ignore it.
1258                  * We always send 7bit controls so we also do
1259                  * not care for the parameter value here that
1260                  * select the control-mode.
1261                  * VT220 defines argument 2 as 7bit mode but
1262                  * VT3xx up to VT5xx use it as 8bit mode. We
1263                  * choose to conform with the latter here.
1264                  * We also enable 8bit mode when VT220
1265                  * compatibility is requested explicitly. */
1266                 if (vte->csi_argv[1] == 1 ||
1267                     vte->csi_argv[1] == 2)
1268                         vte->flags |= FLAG_USE_C1;
1269
1270                 vte->flags |= FLAG_8BIT_MODE;
1271                 vte->g0 = &tsm_vte_unicode_lower;
1272                 vte->g1 = &tsm_vte_dec_supplemental_graphics;
1273         } else {
1274                 llog_debug(vte, "unhandled DECSCL 'p' CSI %i, switching to utf-8 mode again",
1275                            vte->csi_argv[0]);
1276         }
1277 }
1278
1279 static inline void set_reset_flag(struct tsm_vte *vte, bool set,
1280                                   unsigned int flag)
1281 {
1282         if (set)
1283                 vte->flags |= flag;
1284         else
1285                 vte->flags &= ~flag;
1286 }
1287
1288 static void csi_mode(struct tsm_vte *vte, bool set)
1289 {
1290         unsigned int i;
1291
1292         for (i = 0; i < vte->csi_argc; ++i) {
1293                 if (!(vte->csi_flags & CSI_WHAT)) {
1294                         switch (vte->csi_argv[i]) {
1295                         case -1:
1296                                 continue;
1297                         case 2: /* KAM */
1298                                 set_reset_flag(vte, set,
1299                                                FLAG_KEYBOARD_ACTION_MODE);
1300                                 continue;
1301                         case 4: /* IRM */
1302                                 set_reset_flag(vte, set,
1303                                                FLAG_INSERT_REPLACE_MODE);
1304                                 if (set)
1305                                         tsm_screen_set_flags(vte->con,
1306                                                 TSM_SCREEN_INSERT_MODE);
1307                                 else
1308                                         tsm_screen_reset_flags(vte->con,
1309                                                 TSM_SCREEN_INSERT_MODE);
1310                                 continue;
1311                         case 12: /* SRM */
1312                                 set_reset_flag(vte, set,
1313                                                FLAG_SEND_RECEIVE_MODE);
1314                                 continue;
1315                         case 20: /* LNM */
1316                                 set_reset_flag(vte, set,
1317                                                FLAG_LINE_FEED_NEW_LINE_MODE);
1318                                 continue;
1319                         default:
1320                                 llog_debug(vte, "unknown non-DEC (Re)Set-Mode %d",
1321                                            vte->csi_argv[i]);
1322                                 continue;
1323                         }
1324                 }
1325
1326                 switch (vte->csi_argv[i]) {
1327                 case -1:
1328                         continue;
1329                 case 1: /* DECCKM */
1330                         set_reset_flag(vte, set, FLAG_CURSOR_KEY_MODE);
1331                         continue;
1332                 case 2: /* DECANM */
1333                         /* Select VT52 mode */
1334                         /* We do not support VT52 mode. Is there any reason why
1335                          * we should support it? We ignore it here and do not
1336                          * mark it as to-do item unless someone has strong
1337                          * arguments to support it. */
1338                         continue;
1339                 case 3: /* DECCOLM */
1340                         /* If set, select 132 column mode, otherwise use 80
1341                          * column mode. If neither is selected explicitly, we
1342                          * use dynamic mode, that is, we send SIGWCH when the
1343                          * size changes and we allow arbitrary buffer
1344                          * dimensions. On soft-reset, we automatically fall back
1345                          * to the default, that is, dynamic mode.
1346                          * Dynamic-mode can be forced to a static mode in the
1347                          * config. That is, every time dynamic-mode becomes
1348                          * active, the terminal will be set to the dimensions
1349                          * that were selected in the config. This allows setting
1350                          * a fixed size for the terminal regardless of the
1351                          * display size.
1352                          * TODO: Implement this */
1353                         continue;
1354                 case 4: /* DECSCLM */
1355                         /* Select smooth scrolling. We do not support the
1356                          * classic smooth scrolling because we have a scrollback
1357                          * buffer. There is no need to implement smooth
1358                          * scrolling so ignore this here. */
1359                         continue;
1360                 case 5: /* DECSCNM */
1361                         set_reset_flag(vte, set, FLAG_INVERSE_SCREEN_MODE);
1362                         if (set)
1363                                 tsm_screen_set_flags(vte->con,
1364                                                 TSM_SCREEN_INVERSE);
1365                         else
1366                                 tsm_screen_reset_flags(vte->con,
1367                                                 TSM_SCREEN_INVERSE);
1368                         continue;
1369                 case 6: /* DECOM */
1370                         set_reset_flag(vte, set, FLAG_ORIGIN_MODE);
1371                         if (set)
1372                                 tsm_screen_set_flags(vte->con,
1373                                                 TSM_SCREEN_REL_ORIGIN);
1374                         else
1375                                 tsm_screen_reset_flags(vte->con,
1376                                                 TSM_SCREEN_REL_ORIGIN);
1377                         continue;
1378                 case 7: /* DECAWN */
1379                         set_reset_flag(vte, set, FLAG_AUTO_WRAP_MODE);
1380                         if (set)
1381                                 tsm_screen_set_flags(vte->con,
1382                                                 TSM_SCREEN_AUTO_WRAP);
1383                         else
1384                                 tsm_screen_reset_flags(vte->con,
1385                                                 TSM_SCREEN_AUTO_WRAP);
1386                         continue;
1387                 case 8: /* DECARM */
1388                         set_reset_flag(vte, set, FLAG_AUTO_REPEAT_MODE);
1389                         continue;
1390                 case 12: /* blinking cursor */
1391                         /* TODO: implement */
1392                         continue;
1393                 case 18: /* DECPFF */
1394                         /* If set, a form feed (FF) is sent to the printer after
1395                          * every screen that is printed. We don't have printers
1396                          * these days directly attached to terminals so we
1397                          * ignore this here. */
1398                         continue;
1399                 case 19: /* DECPEX */
1400                         /* If set, the full screen is printed instead of
1401                          * scrolling region only. We have no printer so ignore
1402                          * this mode. */
1403                         continue;
1404                 case 25: /* DECTCEM */
1405                         set_reset_flag(vte, set, FLAG_TEXT_CURSOR_MODE);
1406                         if (set)
1407                                 tsm_screen_reset_flags(vte->con,
1408                                                 TSM_SCREEN_HIDE_CURSOR);
1409                         else
1410                                 tsm_screen_set_flags(vte->con,
1411                                                 TSM_SCREEN_HIDE_CURSOR);
1412                         continue;
1413                 case 42: /* DECNRCM */
1414                         set_reset_flag(vte, set, FLAG_NATIONAL_CHARSET_MODE);
1415                         continue;
1416                 case 47: /* Alternate screen buffer */
1417                         if (vte->flags & FLAG_TITE_INHIBIT_MODE)
1418                                 continue;
1419
1420                         if (set)
1421                                 tsm_screen_set_flags(vte->con,
1422                                                      TSM_SCREEN_ALTERNATE);
1423                         else
1424                                 tsm_screen_reset_flags(vte->con,
1425                                                        TSM_SCREEN_ALTERNATE);
1426                         continue;
1427                 case 1047: /* Alternate screen buffer with post-erase */
1428                         if (vte->flags & FLAG_TITE_INHIBIT_MODE)
1429                                 continue;
1430
1431                         if (set) {
1432                                 tsm_screen_set_flags(vte->con,
1433                                                      TSM_SCREEN_ALTERNATE);
1434                         } else {
1435                                 tsm_screen_erase_screen(vte->con, false);
1436                                 tsm_screen_reset_flags(vte->con,
1437                                                        TSM_SCREEN_ALTERNATE);
1438                         }
1439                         continue;
1440                 case 1048: /* Set/Reset alternate-screen buffer cursor */
1441                         if (vte->flags & FLAG_TITE_INHIBIT_MODE)
1442                                 continue;
1443
1444                         if (set) {
1445                                 vte->alt_cursor_x =
1446                                         tsm_screen_get_cursor_x(vte->con);
1447                                 vte->alt_cursor_y =
1448                                         tsm_screen_get_cursor_y(vte->con);
1449                         } else {
1450                                 tsm_screen_move_to(vte->con, vte->alt_cursor_x,
1451                                                    vte->alt_cursor_y);
1452                         }
1453                         continue;
1454                 case 1049: /* Alternate screen buffer with pre-erase+cursor */
1455                         if (vte->flags & FLAG_TITE_INHIBIT_MODE)
1456                                 continue;
1457
1458                         if (set) {
1459                                 vte->alt_cursor_x =
1460                                         tsm_screen_get_cursor_x(vte->con);
1461                                 vte->alt_cursor_y =
1462                                         tsm_screen_get_cursor_y(vte->con);
1463                                 tsm_screen_set_flags(vte->con,
1464                                                      TSM_SCREEN_ALTERNATE);
1465                                 tsm_screen_erase_screen(vte->con, false);
1466                         } else {
1467                                 tsm_screen_reset_flags(vte->con,
1468                                                        TSM_SCREEN_ALTERNATE);
1469                                 tsm_screen_move_to(vte->con, vte->alt_cursor_x,
1470                                                    vte->alt_cursor_y);
1471                         }
1472                         continue;
1473                 default:
1474                         llog_debug(vte, "unknown DEC %set-Mode %d",
1475                                    set?"S":"Res", vte->csi_argv[i]);
1476                         continue;
1477                 }
1478         }
1479 }
1480
1481 static void csi_dev_attr(struct tsm_vte *vte)
1482 {
1483         if (vte->csi_argc <= 1 && vte->csi_argv[0] <= 0) {
1484                 if (vte->csi_flags == 0) {
1485                         send_primary_da(vte);
1486                         return;
1487                 } else if (vte->csi_flags & CSI_GT) {
1488                         vte_write(vte, "\e[>1;1;0c", 9);
1489                         return;
1490                 }
1491         }
1492
1493         llog_debug(vte, "unhandled DA: %x %d %d %d...", vte->csi_flags,
1494                    vte->csi_argv[0], vte->csi_argv[1], vte->csi_argv[2]);
1495 }
1496
1497 static void csi_dsr(struct tsm_vte *vte)
1498 {
1499         char buf[64];
1500         unsigned int x, y, len;
1501
1502         if (vte->csi_argv[0] == 5) {
1503                 vte_write(vte, "\e[0n", 4);
1504         } else if (vte->csi_argv[0] == 6) {
1505                 x = tsm_screen_get_cursor_x(vte->con);
1506                 y = tsm_screen_get_cursor_y(vte->con);
1507                 len = snprintf(buf, sizeof(buf), "\e[%u;%uR", x, y);
1508                 if (len >= sizeof(buf))
1509                         vte_write(vte, "\e[0;0R", 6);
1510                 else
1511                         vte_write(vte, buf, len);
1512         }
1513 }
1514
1515 static void do_csi(struct tsm_vte *vte, uint32_t data)
1516 {
1517         int num, x, y, upper, lower;
1518         bool protect;
1519
1520         if (vte->csi_argc < CSI_ARG_MAX)
1521                 vte->csi_argc++;
1522
1523         switch (data) {
1524         case 'A': /* CUU */
1525                 /* move cursor up */
1526                 num = vte->csi_argv[0];
1527                 if (num <= 0)
1528                         num = 1;
1529                 tsm_screen_move_up(vte->con, num, false);
1530                 break;
1531         case 'B': /* CUD */
1532                 /* move cursor down */
1533                 num = vte->csi_argv[0];
1534                 if (num <= 0)
1535                         num = 1;
1536                 tsm_screen_move_down(vte->con, num, false);
1537                 break;
1538         case 'C': /* CUF */
1539                 /* move cursor forward */
1540                 num = vte->csi_argv[0];
1541                 if (num <= 0)
1542                         num = 1;
1543                 tsm_screen_move_right(vte->con, num);
1544                 break;
1545         case 'D': /* CUB */
1546                 /* move cursor backward */
1547                 num = vte->csi_argv[0];
1548                 if (num <= 0)
1549                         num = 1;
1550                 tsm_screen_move_left(vte->con, num);
1551                 break;
1552         case 'd': /* VPA */
1553                 /* Vertical Line Position Absolute */
1554                 num = vte->csi_argv[0];
1555                 if (num <= 0)
1556                         num = 1;
1557                 x = tsm_screen_get_cursor_x(vte->con);
1558                 tsm_screen_move_to(vte->con, x, num - 1);
1559                 break;
1560         case 'e': /* VPR */
1561                 /* Vertical Line Position Relative */
1562                 num = vte->csi_argv[0];
1563                 if (num <= 0)
1564                         num = 1;
1565                 x = tsm_screen_get_cursor_x(vte->con);
1566                 y = tsm_screen_get_cursor_y(vte->con);
1567                 tsm_screen_move_to(vte->con, x, y + num);
1568                 break;
1569         case 'H': /* CUP */
1570         case 'f': /* HVP */
1571                 /* position cursor */
1572                 x = vte->csi_argv[0];
1573                 if (x <= 0)
1574                         x = 1;
1575                 y = vte->csi_argv[1];
1576                 if (y <= 0)
1577                         y = 1;
1578                 tsm_screen_move_to(vte->con, y - 1, x - 1);
1579                 break;
1580         case 'G': /* CHA */
1581                 /* Cursor Character Absolute */
1582                 num = vte->csi_argv[0];
1583                 if (num <= 0)
1584                         num = 1;
1585                 y = tsm_screen_get_cursor_y(vte->con);
1586                 tsm_screen_move_to(vte->con, num - 1, y);
1587                 break;
1588         case 'J':
1589                 if (vte->csi_flags & CSI_WHAT)
1590                         protect = true;
1591                 else
1592                         protect = false;
1593
1594                 if (vte->csi_argv[0] <= 0)
1595                         tsm_screen_erase_cursor_to_screen(vte->con,
1596                                                               protect);
1597                 else if (vte->csi_argv[0] == 1)
1598                         tsm_screen_erase_screen_to_cursor(vte->con,
1599                                                               protect);
1600                 else if (vte->csi_argv[0] == 2)
1601                         tsm_screen_erase_screen(vte->con, protect);
1602                 else
1603                         llog_debug(vte, "unknown parameter to CSI-J: %d",
1604                                    vte->csi_argv[0]);
1605                 break;
1606         case 'K':
1607                 if (vte->csi_flags & CSI_WHAT)
1608                         protect = true;
1609                 else
1610                         protect = false;
1611
1612                 if (vte->csi_argv[0] <= 0)
1613                         tsm_screen_erase_cursor_to_end(vte->con, protect);
1614                 else if (vte->csi_argv[0] == 1)
1615                         tsm_screen_erase_home_to_cursor(vte->con, protect);
1616                 else if (vte->csi_argv[0] == 2)
1617                         tsm_screen_erase_current_line(vte->con, protect);
1618                 else
1619                         llog_debug(vte, "unknown parameter to CSI-K: %d",
1620                                    vte->csi_argv[0]);
1621                 break;
1622         case 'X': /* ECH */
1623                 /* erase characters */
1624                 num = vte->csi_argv[0];
1625                 if (num <= 0)
1626                         num = 1;
1627                 tsm_screen_erase_chars(vte->con, num);
1628                 break;
1629         case 'm':
1630                 csi_attribute(vte);
1631                 break;
1632         case 'p':
1633                 if (vte->csi_flags & CSI_GT) {
1634                         /* xterm: select X11 visual cursor mode */
1635                         csi_soft_reset(vte);
1636                 } else if (vte->csi_flags & CSI_BANG) {
1637                         /* DECSTR: Soft Reset */
1638                         csi_soft_reset(vte);
1639                 } else if (vte->csi_flags & CSI_CASH) {
1640                         /* DECRQM: Request DEC Private Mode */
1641                         /* If CSI_WHAT is set, then enable,
1642                          * otherwise disable */
1643                         csi_soft_reset(vte);
1644                 } else {
1645                         /* DECSCL: Compatibility Level */
1646                         /* Sometimes CSI_DQUOTE is set here, too */
1647                         csi_compat_mode(vte);
1648                 }
1649                 break;
1650         case 'h': /* SM: Set Mode */
1651                 csi_mode(vte, true);
1652                 break;
1653         case 'l': /* RM: Reset Mode */
1654                 csi_mode(vte, false);
1655                 break;
1656         case 'r': /* DECSTBM */
1657                 /* set margin size */
1658                 upper = vte->csi_argv[0];
1659                 if (upper < 0)
1660                         upper = 0;
1661                 lower = vte->csi_argv[1];
1662                 if (lower < 0)
1663                         lower = 0;
1664                 tsm_screen_set_margins(vte->con, upper, lower);
1665                 break;
1666         case 'c': /* DA */
1667                 /* device attributes */
1668                 csi_dev_attr(vte);
1669                 break;
1670         case 'L': /* IL */
1671                 /* insert lines */
1672                 num = vte->csi_argv[0];
1673                 if (num <= 0)
1674                         num = 1;
1675                 tsm_screen_insert_lines(vte->con, num);
1676                 break;
1677         case 'M': /* DL */
1678                 /* delete lines */
1679                 num = vte->csi_argv[0];
1680                 if (num <= 0)
1681                         num = 1;
1682                 tsm_screen_delete_lines(vte->con, num);
1683                 break;
1684         case 'g': /* TBC */
1685                 /* tabulation clear */
1686                 num = vte->csi_argv[0];
1687                 if (num <= 0)
1688                         tsm_screen_reset_tabstop(vte->con);
1689                 else if (num == 3)
1690                         tsm_screen_reset_all_tabstops(vte->con);
1691                 else
1692                         llog_debug(vte, "invalid parameter %d to TBC CSI", num);
1693                 break;
1694         case '@': /* ICH */
1695                 /* insert characters */
1696                 num = vte->csi_argv[0];
1697                 if (num <= 0)
1698                         num = 1;
1699                 tsm_screen_insert_chars(vte->con, num);
1700                 break;
1701         case 'P': /* DCH */
1702                 /* delete characters */
1703                 num = vte->csi_argv[0];
1704                 if (num <= 0)
1705                         num = 1;
1706                 tsm_screen_delete_chars(vte->con, num);
1707                 break;
1708         case 'Z': /* CBT */
1709                 /* cursor horizontal backwards tab */
1710                 num = vte->csi_argv[0];
1711                 if (num <= 0)
1712                         num = 1;
1713                 tsm_screen_tab_left(vte->con, num);
1714                 break;
1715         case 'I': /* CHT */
1716                 /* cursor horizontal forward tab */
1717                 num = vte->csi_argv[0];
1718                 if (num <= 0)
1719                         num = 1;
1720                 tsm_screen_tab_right(vte->con, num);
1721                 break;
1722         case 'n': /* DSR */
1723                 /* device status reports */
1724                 csi_dsr(vte);
1725                 break;
1726         case 'S': /* SU */
1727                 /* scroll up */
1728                 num = vte->csi_argv[0];
1729                 if (num <= 0)
1730                         num = 1;
1731                 tsm_screen_scroll_up(vte->con, num);
1732                 break;
1733         case 'T': /* SD */
1734                 /* scroll down */
1735                 num = vte->csi_argv[0];
1736                 if (num <= 0)
1737                         num = 1;
1738                 tsm_screen_scroll_down(vte->con, num);
1739                 break;
1740         default:
1741                 llog_debug(vte, "unhandled CSI sequence %c", data);
1742         }
1743 }
1744
1745 /* map a character according to current GL and GR maps */
1746 static uint32_t vte_map(struct tsm_vte *vte, uint32_t val)
1747 {
1748         /* 32, 127, 160 and 255 map to identity like all values >255 */
1749         switch (val) {
1750         case 33 ... 126:
1751                 if (vte->glt) {
1752                         val = (**vte->glt)[val - 32];
1753                         vte->glt = NULL;
1754                 } else {
1755                         val = (**vte->gl)[val - 32];
1756                 }
1757                 break;
1758         case 161 ... 254:
1759                 if (vte->grt) {
1760                         val = (**vte->grt)[val - 160];
1761                         vte->grt = NULL;
1762                 } else {
1763                         val = (**vte->gr)[val - 160];
1764                 }
1765                 break;
1766         }
1767
1768         return val;
1769 }
1770
1771 /* perform parser action */
1772 static void do_action(struct tsm_vte *vte, uint32_t data, int action)
1773 {
1774         tsm_symbol_t sym;
1775
1776         switch (action) {
1777                 case ACTION_NONE:
1778                         /* do nothing */
1779                         return;
1780                 case ACTION_IGNORE:
1781                         /* ignore character */
1782                         break;
1783                 case ACTION_PRINT:
1784                         sym = tsm_symbol_make(vte_map(vte, data));
1785                         write_console(vte, sym);
1786                         break;
1787                 case ACTION_EXECUTE:
1788                         do_execute(vte, data);
1789                         break;
1790                 case ACTION_CLEAR:
1791                         do_clear(vte);
1792                         break;
1793                 case ACTION_COLLECT:
1794                         do_collect(vte, data);
1795                         break;
1796                 case ACTION_PARAM:
1797                         do_param(vte, data);
1798                         break;
1799                 case ACTION_ESC_DISPATCH:
1800                         do_esc(vte, data);
1801                         break;
1802                 case ACTION_CSI_DISPATCH:
1803                         do_csi(vte, data);
1804                         break;
1805                 case ACTION_DCS_START:
1806                         break;
1807                 case ACTION_DCS_COLLECT:
1808                         break;
1809                 case ACTION_DCS_END:
1810                         break;
1811                 case ACTION_OSC_START:
1812                         break;
1813                 case ACTION_OSC_COLLECT:
1814                         break;
1815                 case ACTION_OSC_END:
1816                         break;
1817                 default:
1818                         llog_warn(vte, "invalid action %d", action);
1819         }
1820 }
1821
1822 /* entry actions to be performed when entering the selected state */
1823 static const int entry_action[] = {
1824         [STATE_CSI_ENTRY] = ACTION_CLEAR,
1825         [STATE_DCS_ENTRY] = ACTION_CLEAR,
1826         [STATE_DCS_PASS] = ACTION_DCS_START,
1827         [STATE_ESC] = ACTION_CLEAR,
1828         [STATE_OSC_STRING] = ACTION_OSC_START,
1829         [STATE_NUM] = ACTION_NONE,
1830 };
1831
1832 /* exit actions to be performed when leaving the selected state */
1833 static const int exit_action[] = {
1834         [STATE_DCS_PASS] = ACTION_DCS_END,
1835         [STATE_OSC_STRING] = ACTION_OSC_END,
1836         [STATE_NUM] = ACTION_NONE,
1837 };
1838
1839 /* perform state transition and dispatch related actions */
1840 static void do_trans(struct tsm_vte *vte, uint32_t data, int state, int act)
1841 {
1842         if (state != STATE_NONE) {
1843                 /* A state transition occurs. Perform exit-action,
1844                  * transition-action and entry-action. Even when performing a
1845                  * transition to the same state as the current state we do this.
1846                  * Use STATE_NONE if this is not the desired behavior.
1847                  */
1848                 do_action(vte, data, exit_action[vte->state]);
1849                 do_action(vte, data, act);
1850                 do_action(vte, data, entry_action[state]);
1851                 vte->state = state;
1852         } else {
1853                 do_action(vte, data, act);
1854         }
1855 }
1856
1857 /*
1858  * Escape sequence parser
1859  * This parses the new input character \data. It performs state transition and
1860  * calls the right callbacks for each action.
1861  */
1862 static void parse_data(struct tsm_vte *vte, uint32_t raw)
1863 {
1864         /* events that may occur in any state */
1865         switch (raw) {
1866                 case 0x18:
1867                 case 0x1a:
1868                 case 0x80 ... 0x8f:
1869                 case 0x91 ... 0x97:
1870                 case 0x99:
1871                 case 0x9a:
1872                 case 0x9c:
1873                         do_trans(vte, raw, STATE_GROUND, ACTION_EXECUTE);
1874                         return;
1875                 case 0x1b:
1876                         do_trans(vte, raw, STATE_ESC, ACTION_NONE);
1877                         return;
1878                 case 0x98:
1879                 case 0x9e:
1880                 case 0x9f:
1881                         do_trans(vte, raw, STATE_ST_IGNORE, ACTION_NONE);
1882                         return;
1883                 case 0x90:
1884                         do_trans(vte, raw, STATE_DCS_ENTRY, ACTION_NONE);
1885                         return;
1886                 case 0x9d:
1887                         do_trans(vte, raw, STATE_OSC_STRING, ACTION_NONE);
1888                         return;
1889                 case 0x9b:
1890                         do_trans(vte, raw, STATE_CSI_ENTRY, ACTION_NONE);
1891                         return;
1892         }
1893
1894         /* events that depend on the current state */
1895         switch (vte->state) {
1896         case STATE_GROUND:
1897                 switch (raw) {
1898                 case 0x00 ... 0x17:
1899                 case 0x19:
1900                 case 0x1c ... 0x1f:
1901                 case 0x80 ... 0x8f:
1902                 case 0x91 ... 0x9a:
1903                 case 0x9c:
1904                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
1905                         return;
1906                 case 0x20 ... 0x7f:
1907                         do_trans(vte, raw, STATE_NONE, ACTION_PRINT);
1908                         return;
1909                 }
1910                 do_trans(vte, raw, STATE_NONE, ACTION_PRINT);
1911                 return;
1912         case STATE_ESC:
1913                 switch (raw) {
1914                 case 0x00 ... 0x17:
1915                 case 0x19:
1916                 case 0x1c ... 0x1f:
1917                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
1918                         return;
1919                 case 0x7f:
1920                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
1921                         return;
1922                 case 0x20 ... 0x2f:
1923                         do_trans(vte, raw, STATE_ESC_INT, ACTION_COLLECT);
1924                         return;
1925                 case 0x30 ... 0x4f:
1926                 case 0x51 ... 0x57:
1927                 case 0x59:
1928                 case 0x5a:
1929                 case 0x5c:
1930                 case 0x60 ... 0x7e:
1931                         do_trans(vte, raw, STATE_GROUND, ACTION_ESC_DISPATCH);
1932                         return;
1933                 case 0x5b:
1934                         do_trans(vte, raw, STATE_CSI_ENTRY, ACTION_NONE);
1935                         return;
1936                 case 0x5d:
1937                         do_trans(vte, raw, STATE_OSC_STRING, ACTION_NONE);
1938                         return;
1939                 case 0x50:
1940                         do_trans(vte, raw, STATE_DCS_ENTRY, ACTION_NONE);
1941                         return;
1942                 case 0x58:
1943                 case 0x5e:
1944                 case 0x5f:
1945                         do_trans(vte, raw, STATE_ST_IGNORE, ACTION_NONE);
1946                         return;
1947                 }
1948                 do_trans(vte, raw, STATE_ESC_INT, ACTION_COLLECT);
1949                 return;
1950         case STATE_ESC_INT:
1951                 switch (raw) {
1952                 case 0x00 ... 0x17:
1953                 case 0x19:
1954                 case 0x1c ... 0x1f:
1955                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
1956                         return;
1957                 case 0x20 ... 0x2f:
1958                         do_trans(vte, raw, STATE_NONE, ACTION_COLLECT);
1959                         return;
1960                 case 0x7f:
1961                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
1962                         return;
1963                 case 0x30 ... 0x7e:
1964                         do_trans(vte, raw, STATE_GROUND, ACTION_ESC_DISPATCH);
1965                         return;
1966                 }
1967                 do_trans(vte, raw, STATE_NONE, ACTION_COLLECT);
1968                 return;
1969         case STATE_CSI_ENTRY:
1970                 switch (raw) {
1971                 case 0x00 ... 0x17:
1972                 case 0x19:
1973                 case 0x1c ... 0x1f:
1974                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
1975                         return;
1976                 case 0x7f:
1977                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
1978                         return;
1979                 case 0x20 ... 0x2f:
1980                         do_trans(vte, raw, STATE_CSI_INT, ACTION_COLLECT);
1981                         return;
1982                 case 0x3a:
1983                         do_trans(vte, raw, STATE_CSI_IGNORE, ACTION_NONE);
1984                         return;
1985                 case 0x30 ... 0x39:
1986                 case 0x3b:
1987                         do_trans(vte, raw, STATE_CSI_PARAM, ACTION_PARAM);
1988                         return;
1989                 case 0x3c ... 0x3f:
1990                         do_trans(vte, raw, STATE_CSI_PARAM, ACTION_COLLECT);
1991                         return;
1992                 case 0x40 ... 0x7e:
1993                         do_trans(vte, raw, STATE_GROUND, ACTION_CSI_DISPATCH);
1994                         return;
1995                 }
1996                 do_trans(vte, raw, STATE_CSI_IGNORE, ACTION_NONE);
1997                 return;
1998         case STATE_CSI_PARAM:
1999                 switch (raw) {
2000                 case 0x00 ... 0x17:
2001                 case 0x19:
2002                 case 0x1c ... 0x1f:
2003                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
2004                         return;
2005                 case 0x30 ... 0x39:
2006                 case 0x3b:
2007                         do_trans(vte, raw, STATE_NONE, ACTION_PARAM);
2008                         return;
2009                 case 0x7f:
2010                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2011                         return;
2012                 case 0x3a:
2013                 case 0x3c ... 0x3f:
2014                         do_trans(vte, raw, STATE_CSI_IGNORE, ACTION_NONE);
2015                         return;
2016                 case 0x20 ... 0x2f:
2017                         do_trans(vte, raw, STATE_CSI_INT, ACTION_COLLECT);
2018                         return;
2019                 case 0x40 ... 0x7e:
2020                         do_trans(vte, raw, STATE_GROUND, ACTION_CSI_DISPATCH);
2021                         return;
2022                 }
2023                 do_trans(vte, raw, STATE_CSI_IGNORE, ACTION_NONE);
2024                 return;
2025         case STATE_CSI_INT:
2026                 switch (raw) {
2027                 case 0x00 ... 0x17:
2028                 case 0x19:
2029                 case 0x1c ... 0x1f:
2030                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
2031                         return;
2032                 case 0x20 ... 0x2f:
2033                         do_trans(vte, raw, STATE_NONE, ACTION_COLLECT);
2034                         return;
2035                 case 0x7f:
2036                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2037                         return;
2038                 case 0x30 ... 0x3f:
2039                         do_trans(vte, raw, STATE_CSI_IGNORE, ACTION_NONE);
2040                         return;
2041                 case 0x40 ... 0x7e:
2042                         do_trans(vte, raw, STATE_GROUND, ACTION_CSI_DISPATCH);
2043                         return;
2044                 }
2045                 do_trans(vte, raw, STATE_CSI_IGNORE, ACTION_NONE);
2046                 return;
2047         case STATE_CSI_IGNORE:
2048                 switch (raw) {
2049                 case 0x00 ... 0x17:
2050                 case 0x19:
2051                 case 0x1c ... 0x1f:
2052                         do_trans(vte, raw, STATE_NONE, ACTION_EXECUTE);
2053                         return;
2054                 case 0x20 ... 0x3f:
2055                 case 0x7f:
2056                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2057                         return;
2058                 case 0x40 ... 0x7e:
2059                         do_trans(vte, raw, STATE_GROUND, ACTION_NONE);
2060                         return;
2061                 }
2062                 do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2063                 return;
2064         case STATE_DCS_ENTRY:
2065                 switch (raw) {
2066                 case 0x00 ... 0x17:
2067                 case 0x19:
2068                 case 0x1c ... 0x1f:
2069                 case 0x7f:
2070                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2071                         return;
2072                 case 0x3a:
2073                         do_trans(vte, raw, STATE_DCS_IGNORE, ACTION_NONE);
2074                         return;
2075                 case 0x20 ... 0x2f:
2076                         do_trans(vte, raw, STATE_DCS_INT, ACTION_COLLECT);
2077                         return;
2078                 case 0x30 ... 0x39:
2079                 case 0x3b:
2080                         do_trans(vte, raw, STATE_DCS_PARAM, ACTION_PARAM);
2081                         return;
2082                 case 0x3c ... 0x3f:
2083                         do_trans(vte, raw, STATE_DCS_PARAM, ACTION_COLLECT);
2084                         return;
2085                 case 0x40 ... 0x7e:
2086                         do_trans(vte, raw, STATE_DCS_PASS, ACTION_NONE);
2087                         return;
2088                 }
2089                 do_trans(vte, raw, STATE_DCS_PASS, ACTION_NONE);
2090                 return;
2091         case STATE_DCS_PARAM:
2092                 switch (raw) {
2093                 case 0x00 ... 0x17:
2094                 case 0x19:
2095                 case 0x1c ... 0x1f:
2096                 case 0x7f:
2097                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2098                         return;
2099                 case 0x30 ... 0x39:
2100                 case 0x3b:
2101                         do_trans(vte, raw, STATE_NONE, ACTION_PARAM);
2102                         return;
2103                 case 0x3a:
2104                 case 0x3c ... 0x3f:
2105                         do_trans(vte, raw, STATE_DCS_IGNORE, ACTION_NONE);
2106                         return;
2107                 case 0x20 ... 0x2f:
2108                         do_trans(vte, raw, STATE_DCS_INT, ACTION_COLLECT);
2109                         return;
2110                 case 0x40 ... 0x7e:
2111                         do_trans(vte, raw, STATE_DCS_PASS, ACTION_NONE);
2112                         return;
2113                 }
2114                 do_trans(vte, raw, STATE_DCS_PASS, ACTION_NONE);
2115                 return;
2116         case STATE_DCS_INT:
2117                 switch (raw) {
2118                 case 0x00 ... 0x17:
2119                 case 0x19:
2120                 case 0x1c ... 0x1f:
2121                 case 0x7f:
2122                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2123                         return;
2124                 case 0x20 ... 0x2f:
2125                         do_trans(vte, raw, STATE_NONE, ACTION_COLLECT);
2126                         return;
2127                 case 0x30 ... 0x3f:
2128                         do_trans(vte, raw, STATE_DCS_IGNORE, ACTION_NONE);
2129                         return;
2130                 case 0x40 ... 0x7e:
2131                         do_trans(vte, raw, STATE_DCS_PASS, ACTION_NONE);
2132                         return;
2133                 }
2134                 do_trans(vte, raw, STATE_DCS_PASS, ACTION_NONE);
2135                 return;
2136         case STATE_DCS_PASS:
2137                 switch (raw) {
2138                 case 0x00 ... 0x17:
2139                 case 0x19:
2140                 case 0x1c ... 0x1f:
2141                 case 0x20 ... 0x7e:
2142                         do_trans(vte, raw, STATE_NONE, ACTION_DCS_COLLECT);
2143                         return;
2144                 case 0x7f:
2145                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2146                         return;
2147                 case 0x9c:
2148                         do_trans(vte, raw, STATE_GROUND, ACTION_NONE);
2149                         return;
2150                 }
2151                 do_trans(vte, raw, STATE_NONE, ACTION_DCS_COLLECT);
2152                 return;
2153         case STATE_DCS_IGNORE:
2154                 switch (raw) {
2155                 case 0x00 ... 0x17:
2156                 case 0x19:
2157                 case 0x1c ... 0x1f:
2158                 case 0x20 ... 0x7f:
2159                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2160                         return;
2161                 case 0x9c:
2162                         do_trans(vte, raw, STATE_GROUND, ACTION_NONE);
2163                         return;
2164                 }
2165                 do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2166                 return;
2167         case STATE_OSC_STRING:
2168                 switch (raw) {
2169                 case 0x00 ... 0x06:
2170                 case 0x08 ... 0x17:
2171                 case 0x19:
2172                 case 0x1c ... 0x1f:
2173                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2174                         return;
2175                 case 0x20 ... 0x7f:
2176                         do_trans(vte, raw, STATE_NONE, ACTION_OSC_COLLECT);
2177                         return;
2178                 case 0x07:
2179                 case 0x9c:
2180                         do_trans(vte, raw, STATE_GROUND, ACTION_NONE);
2181                         return;
2182                 }
2183                 do_trans(vte, raw, STATE_NONE, ACTION_OSC_COLLECT);
2184                 return;
2185         case STATE_ST_IGNORE:
2186                 switch (raw) {
2187                 case 0x00 ... 0x17:
2188                 case 0x19:
2189                 case 0x1c ... 0x1f:
2190                 case 0x20 ... 0x7f:
2191                         do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2192                         return;
2193                 case 0x9c:
2194                         do_trans(vte, raw, STATE_GROUND, ACTION_NONE);
2195                         return;
2196                 }
2197                 do_trans(vte, raw, STATE_NONE, ACTION_IGNORE);
2198                 return;
2199         }
2200
2201         llog_warn(vte, "unhandled input %u in state %d", raw, vte->state);
2202 }
2203
2204 SHL_EXPORT
2205 void tsm_vte_input(struct tsm_vte *vte, const char *u8, size_t len)
2206 {
2207         int state;
2208         uint32_t ucs4;
2209         size_t i;
2210
2211         if (!vte || !vte->con)
2212                 return;
2213
2214         ++vte->parse_cnt;
2215         for (i = 0; i < len; ++i) {
2216                 if (vte->flags & FLAG_7BIT_MODE) {
2217                         if (u8[i] & 0x80)
2218                                 llog_debug(vte, "receiving 8bit character U+%d from pty while in 7bit mode",
2219                                            (int)u8[i]);
2220                         parse_data(vte, u8[i] & 0x7f);
2221                 } else if (vte->flags & FLAG_8BIT_MODE) {
2222                         parse_data(vte, u8[i]);
2223                 } else {
2224                         state = tsm_utf8_mach_feed(vte->mach, u8[i]);
2225                         if (state == TSM_UTF8_ACCEPT ||
2226                             state == TSM_UTF8_REJECT) {
2227                                 ucs4 = tsm_utf8_mach_get(vte->mach);
2228                                 parse_data(vte, ucs4);
2229                         }
2230                 }
2231         }
2232         --vte->parse_cnt;
2233 }
2234
2235 SHL_EXPORT
2236 bool tsm_vte_handle_keyboard(struct tsm_vte *vte, uint32_t keysym,
2237                              uint32_t ascii, unsigned int mods,
2238                              uint32_t unicode)
2239 {
2240         char val, u8[4];
2241         size_t len;
2242         uint32_t sym;
2243
2244         /* MOD1 (mostly labeled 'Alt') prepends an escape character to every
2245          * input that is sent by a key.
2246          * TODO: Transform this huge handler into a lookup table to save a lot
2247          * of code and make such modifiers easier to implement.
2248          * Also check whether altSendsEscape should be the default (xterm
2249          * disables this by default, why?) and whether we should implement the
2250          * fallback shifting that xterm does. */
2251         if (mods & TSM_ALT_MASK)
2252                 vte->flags |= FLAG_PREPEND_ESCAPE;
2253
2254         /* A user might actually use multiple layouts for keyboard input. The
2255          * @keysym variable contains the actual keysym that the user used. But
2256          * if this keysym is not in the ascii range, the input handler does
2257          * check all other layouts that the user specified whether one of them
2258          * maps the key to some ASCII keysym and provides this via @ascii.
2259          * We always use the real keysym except when handling CTRL+<XY>
2260          * shortcuts we use the ascii keysym. This is for compatibility to xterm
2261          * et. al. so ctrl+c always works regardless of the currently active
2262          * keyboard layout.
2263          * But if no ascii-sym is found, we still use the real keysym. */
2264         sym = ascii;
2265         if (sym == XKB_KEY_NoSymbol)
2266                 sym = keysym;
2267
2268         if (mods & TSM_CONTROL_MASK) {
2269                 switch (sym) {
2270                 case XKB_KEY_2:
2271                 case XKB_KEY_space:
2272                         vte_write(vte, "\x00", 1);
2273                         return true;
2274                 case XKB_KEY_a:
2275                 case XKB_KEY_A:
2276                         vte_write(vte, "\x01", 1);
2277                         return true;
2278                 case XKB_KEY_b:
2279                 case XKB_KEY_B:
2280                         vte_write(vte, "\x02", 1);
2281                         return true;
2282                 case XKB_KEY_c:
2283                 case XKB_KEY_C:
2284                         vte_write(vte, "\x03", 1);
2285                         return true;
2286                 case XKB_KEY_d:
2287                 case XKB_KEY_D:
2288                         vte_write(vte, "\x04", 1);
2289                         return true;
2290                 case XKB_KEY_e:
2291                 case XKB_KEY_E:
2292                         vte_write(vte, "\x05", 1);
2293                         return true;
2294                 case XKB_KEY_f:
2295                 case XKB_KEY_F:
2296                         vte_write(vte, "\x06", 1);
2297                         return true;
2298                 case XKB_KEY_g:
2299                 case XKB_KEY_G:
2300                         vte_write(vte, "\x07", 1);
2301                         return true;
2302                 case XKB_KEY_h:
2303                 case XKB_KEY_H:
2304                         vte_write(vte, "\x08", 1);
2305                         return true;
2306                 case XKB_KEY_i:
2307                 case XKB_KEY_I:
2308                         vte_write(vte, "\x09", 1);
2309                         return true;
2310                 case XKB_KEY_j:
2311                 case XKB_KEY_J:
2312                         vte_write(vte, "\x0a", 1);
2313                         return true;
2314                 case XKB_KEY_k:
2315                 case XKB_KEY_K:
2316                         vte_write(vte, "\x0b", 1);
2317                         return true;
2318                 case XKB_KEY_l:
2319                 case XKB_KEY_L:
2320                         vte_write(vte, "\x0c", 1);
2321                         return true;
2322                 case XKB_KEY_m:
2323                 case XKB_KEY_M:
2324                         vte_write(vte, "\x0d", 1);
2325                         return true;
2326                 case XKB_KEY_n:
2327                 case XKB_KEY_N:
2328                         vte_write(vte, "\x0e", 1);
2329                         return true;
2330                 case XKB_KEY_o:
2331                 case XKB_KEY_O:
2332                         vte_write(vte, "\x0f", 1);
2333                         return true;
2334                 case XKB_KEY_p:
2335                 case XKB_KEY_P:
2336                         vte_write(vte, "\x10", 1);
2337                         return true;
2338                 case XKB_KEY_q:
2339                 case XKB_KEY_Q:
2340                         vte_write(vte, "\x11", 1);
2341                         return true;
2342                 case XKB_KEY_r:
2343                 case XKB_KEY_R:
2344                         vte_write(vte, "\x12", 1);
2345                         return true;
2346                 case XKB_KEY_s:
2347                 case XKB_KEY_S:
2348                         vte_write(vte, "\x13", 1);
2349                         return true;
2350                 case XKB_KEY_t:
2351                 case XKB_KEY_T:
2352                         vte_write(vte, "\x14", 1);
2353                         return true;
2354                 case XKB_KEY_u:
2355                 case XKB_KEY_U:
2356                         vte_write(vte, "\x15", 1);
2357                         return true;
2358                 case XKB_KEY_v:
2359                 case XKB_KEY_V:
2360                         vte_write(vte, "\x16", 1);
2361                         return true;
2362                 case XKB_KEY_w:
2363                 case XKB_KEY_W:
2364                         vte_write(vte, "\x17", 1);
2365                         return true;
2366                 case XKB_KEY_x:
2367                 case XKB_KEY_X:
2368                         vte_write(vte, "\x18", 1);
2369                         return true;
2370                 case XKB_KEY_y:
2371                 case XKB_KEY_Y:
2372                         vte_write(vte, "\x19", 1);
2373                         return true;
2374                 case XKB_KEY_z:
2375                 case XKB_KEY_Z:
2376                         vte_write(vte, "\x1a", 1);
2377                         return true;
2378                 case XKB_KEY_3:
2379                 case XKB_KEY_bracketleft:
2380                 case XKB_KEY_braceleft:
2381                         vte_write(vte, "\x1b", 1);
2382                         return true;
2383                 case XKB_KEY_4:
2384                 case XKB_KEY_backslash:
2385                 case XKB_KEY_bar:
2386                         vte_write(vte, "\x1c", 1);
2387                         return true;
2388                 case XKB_KEY_5:
2389                 case XKB_KEY_bracketright:
2390                 case XKB_KEY_braceright:
2391                         vte_write(vte, "\x1d", 1);
2392                         return true;
2393                 case XKB_KEY_6:
2394                 case XKB_KEY_grave:
2395                 case XKB_KEY_asciitilde:
2396                         vte_write(vte, "\x1e", 1);
2397                         return true;
2398                 case XKB_KEY_7:
2399                 case XKB_KEY_slash:
2400                 case XKB_KEY_question:
2401                         vte_write(vte, "\x1f", 1);
2402                         return true;
2403                 case XKB_KEY_8:
2404                         vte_write(vte, "\x7f", 1);
2405                         return true;
2406                 }
2407         }
2408
2409         switch (keysym) {
2410                 case XKB_KEY_BackSpace:
2411                         vte_write(vte, "\x08", 1);
2412                         return true;
2413                 case XKB_KEY_Tab:
2414                 case XKB_KEY_KP_Tab:
2415                         vte_write(vte, "\x09", 1);
2416                         return true;
2417                 case XKB_KEY_ISO_Left_Tab:
2418                         vte_write(vte, "\e[Z", 3);
2419                         return true;
2420                 case XKB_KEY_Linefeed:
2421                         vte_write(vte, "\x0a", 1);
2422                         return true;
2423                 case XKB_KEY_Clear:
2424                         vte_write(vte, "\x0b", 1);
2425                         return true;
2426                 /*
2427                  TODO: What should we do with this key? Sending XOFF is awful as
2428                        there is no simple way on modern keyboards to send XON
2429                        again. If someone wants this, we can re-eanble it and set
2430                        some flag.
2431                 case XKB_KEY_Pause:
2432                         vte_write(vte, "\x13", 1);
2433                         return true;
2434                 */
2435                 /*
2436                  TODO: What should we do on scroll-lock? Sending 0x14 is what
2437                        the specs say but it is not used today the way most
2438                        users would expect so we disable it. If someone wants
2439                        this, we can re-enable it and set some flag.
2440                 case XKB_KEY_Scroll_Lock:
2441                         vte_write(vte, "\x14", 1);
2442                         return true;
2443                 */
2444                 case XKB_KEY_Sys_Req:
2445                         vte_write(vte, "\x15", 1);
2446                         return true;
2447                 case XKB_KEY_Escape:
2448                         vte_write(vte, "\x1b", 1);
2449                         return true;
2450                 case XKB_KEY_KP_Enter:
2451                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE) {
2452                                 vte_write(vte, "\eOM", 3);
2453                                 return true;
2454                         }
2455                         /* fallthrough */
2456                 case XKB_KEY_Return:
2457                         if (vte->flags & FLAG_LINE_FEED_NEW_LINE_MODE)
2458                                 vte_write(vte, "\x0d\x0a", 2);
2459                         else
2460                                 vte_write(vte, "\x0d", 1);
2461                         return true;
2462                 case XKB_KEY_Find:
2463                         vte_write(vte, "\e[1~", 4);
2464                         return true;
2465                 case XKB_KEY_Insert:
2466                         vte_write(vte, "\e[2~", 4);
2467                         return true;
2468                 case XKB_KEY_Delete:
2469                         vte_write(vte, "\e[3~", 4);
2470                         return true;
2471                 case XKB_KEY_Select:
2472                         vte_write(vte, "\e[4~", 4);
2473                         return true;
2474                 case XKB_KEY_Page_Up:
2475                 case XKB_KEY_KP_Page_Up:
2476                         vte_write(vte, "\e[5~", 4);
2477                         return true;
2478                 case XKB_KEY_KP_Page_Down:
2479                 case XKB_KEY_Page_Down:
2480                         vte_write(vte, "\e[6~", 4);
2481                         return true;
2482                 case XKB_KEY_Up:
2483                 case XKB_KEY_KP_Up:
2484                         if (vte->flags & FLAG_CURSOR_KEY_MODE)
2485                                 vte_write(vte, "\eOA", 3);
2486                         else
2487                                 vte_write(vte, "\e[A", 3);
2488                         return true;
2489                 case XKB_KEY_Down:
2490                 case XKB_KEY_KP_Down:
2491                         if (vte->flags & FLAG_CURSOR_KEY_MODE)
2492                                 vte_write(vte, "\eOB", 3);
2493                         else
2494                                 vte_write(vte, "\e[B", 3);
2495                         return true;
2496                 case XKB_KEY_Right:
2497                 case XKB_KEY_KP_Right:
2498                         if (vte->flags & FLAG_CURSOR_KEY_MODE)
2499                                 vte_write(vte, "\eOC", 3);
2500                         else
2501                                 vte_write(vte, "\e[C", 3);
2502                         return true;
2503                 case XKB_KEY_Left:
2504                 case XKB_KEY_KP_Left:
2505                         if (vte->flags & FLAG_CURSOR_KEY_MODE)
2506                                 vte_write(vte, "\eOD", 3);
2507                         else
2508                                 vte_write(vte, "\e[D", 3);
2509                         return true;
2510                 case XKB_KEY_KP_Insert:
2511                 case XKB_KEY_KP_0:
2512                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2513                                 vte_write(vte, "\eOp", 3);
2514                         else
2515                                 vte_write(vte, "0", 1);
2516                         return true;
2517                 case XKB_KEY_KP_1:
2518                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2519                                 vte_write(vte, "\eOq", 3);
2520                         else
2521                                 vte_write(vte, "1", 1);
2522                         return true;
2523                 case XKB_KEY_KP_2:
2524                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2525                                 vte_write(vte, "\eOr", 3);
2526                         else
2527                                 vte_write(vte, "2", 1);
2528                         return true;
2529                 case XKB_KEY_KP_3:
2530                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2531                                 vte_write(vte, "\eOs", 3);
2532                         else
2533                                 vte_write(vte, "3", 1);
2534                         return true;
2535                 case XKB_KEY_KP_4:
2536                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2537                                 vte_write(vte, "\eOt", 3);
2538                         else
2539                                 vte_write(vte, "4", 1);
2540                         return true;
2541                 case XKB_KEY_KP_5:
2542                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2543                                 vte_write(vte, "\eOu", 3);
2544                         else
2545                                 vte_write(vte, "5", 1);
2546                         return true;
2547                 case XKB_KEY_KP_6:
2548                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2549                                 vte_write(vte, "\eOv", 3);
2550                         else
2551                                 vte_write(vte, "6", 1);
2552                         return true;
2553                 case XKB_KEY_KP_7:
2554                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2555                                 vte_write(vte, "\eOw", 3);
2556                         else
2557                                 vte_write(vte, "7", 1);
2558                         return true;
2559                 case XKB_KEY_KP_8:
2560                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2561                                 vte_write(vte, "\eOx", 3);
2562                         else
2563                                 vte_write(vte, "8", 1);
2564                         return true;
2565                 case XKB_KEY_KP_9:
2566                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2567                                 vte_write(vte, "\eOy", 3);
2568                         else
2569                                 vte_write(vte, "9", 1);
2570                         return true;
2571                 case XKB_KEY_KP_Subtract:
2572                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2573                                 vte_write(vte, "\eOm", 3);
2574                         else
2575                                 vte_write(vte, "-", 1);
2576                         return true;
2577                 case XKB_KEY_KP_Separator:
2578                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2579                                 vte_write(vte, "\eOl", 3);
2580                         else
2581                                 vte_write(vte, ",", 1);
2582                         return true;
2583                 case XKB_KEY_KP_Delete:
2584                 case XKB_KEY_KP_Decimal:
2585                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2586                                 vte_write(vte, "\eOn", 3);
2587                         else
2588                                 vte_write(vte, ".", 1);
2589                         return true;
2590                 case XKB_KEY_KP_Equal:
2591                 case XKB_KEY_KP_Divide:
2592                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2593                                 vte_write(vte, "\eOj", 3);
2594                         else
2595                                 vte_write(vte, "/", 1);
2596                         return true;
2597                 case XKB_KEY_KP_Multiply:
2598                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2599                                 vte_write(vte, "\eOo", 3);
2600                         else
2601                                 vte_write(vte, "*", 1);
2602                         return true;
2603                 case XKB_KEY_KP_Add:
2604                         if (vte->flags & FLAG_KEYPAD_APPLICATION_MODE)
2605                                 vte_write(vte, "\eOk", 3);
2606                         else
2607                                 vte_write(vte, "+", 1);
2608                         return true;
2609                 case XKB_KEY_Home:
2610                 case XKB_KEY_KP_Home:
2611                         if (vte->flags & FLAG_CURSOR_KEY_MODE)
2612                                 vte_write(vte, "\eOH", 3);
2613                         else
2614                                 vte_write(vte, "\e[H", 3);
2615                         return true;
2616                 case XKB_KEY_End:
2617                 case XKB_KEY_KP_End:
2618                         if (vte->flags & FLAG_CURSOR_KEY_MODE)
2619                                 vte_write(vte, "\eOF", 3);
2620                         else
2621                                 vte_write(vte, "\e[F", 3);
2622                         return true;
2623                 case XKB_KEY_KP_Space:
2624                         vte_write(vte, " ", 1);
2625                         return true;
2626                 /* TODO: check what to transmit for functions keys when
2627                  * shift/ctrl etc. are pressed. Every terminal behaves
2628                  * differently here which is really weird.
2629                  * We now map F4 to F14 if shift is pressed and so on for all
2630                  * keys. However, such mappings should rather be done via
2631                  * xkb-configurations and we should instead add a flags argument
2632                  * to the CSIs as some of the keys here already do. */
2633                 case XKB_KEY_F1:
2634                 case XKB_KEY_KP_F1:
2635                         if (mods & TSM_SHIFT_MASK)
2636                                 vte_write(vte, "\e[23~", 5);
2637                         else
2638                                 vte_write(vte, "\eOP", 3);
2639                         return true;
2640                 case XKB_KEY_F2:
2641                 case XKB_KEY_KP_F2:
2642                         if (mods & TSM_SHIFT_MASK)
2643                                 vte_write(vte, "\e[24~", 5);
2644                         else
2645                                 vte_write(vte, "\eOQ", 3);
2646                         return true;
2647                 case XKB_KEY_F3:
2648                 case XKB_KEY_KP_F3:
2649                         if (mods & TSM_SHIFT_MASK)
2650                                 vte_write(vte, "\e[25~", 5);
2651                         else
2652                                 vte_write(vte, "\eOR", 3);
2653                         return true;
2654                 case XKB_KEY_F4:
2655                 case XKB_KEY_KP_F4:
2656                         if (mods & TSM_SHIFT_MASK)
2657                                 //vte_write(vte, "\e[1;2S", 6);
2658                                 vte_write(vte, "\e[26~", 5);
2659                         else
2660                                 vte_write(vte, "\eOS", 3);
2661                         return true;
2662                 case XKB_KEY_F5:
2663                         if (mods & TSM_SHIFT_MASK)
2664                                 //vte_write(vte, "\e[15;2~", 7);
2665                                 vte_write(vte, "\e[28~", 5);
2666                         else
2667                                 vte_write(vte, "\e[15~", 5);
2668                         return true;
2669                 case XKB_KEY_F6:
2670                         if (mods & TSM_SHIFT_MASK)
2671                                 //vte_write(vte, "\e[17;2~", 7);
2672                                 vte_write(vte, "\e[29~", 5);
2673                         else
2674                                 vte_write(vte, "\e[17~", 5);
2675                         return true;
2676                 case XKB_KEY_F7:
2677                         if (mods & TSM_SHIFT_MASK)
2678                                 //vte_write(vte, "\e[18;2~", 7);
2679                                 vte_write(vte, "\e[31~", 5);
2680                         else
2681                                 vte_write(vte, "\e[18~", 5);
2682                         return true;
2683                 case XKB_KEY_F8:
2684                         if (mods & TSM_SHIFT_MASK)
2685                                 //vte_write(vte, "\e[19;2~", 7);
2686                                 vte_write(vte, "\e[32~", 5);
2687                         else
2688                                 vte_write(vte, "\e[19~", 5);
2689                         return true;
2690                 case XKB_KEY_F9:
2691                         if (mods & TSM_SHIFT_MASK)
2692                                 //vte_write(vte, "\e[20;2~", 7);
2693                                 vte_write(vte, "\e[33~", 5);
2694                         else
2695                                 vte_write(vte, "\e[20~", 5);
2696                         return true;
2697                 case XKB_KEY_F10:
2698                         if (mods & TSM_SHIFT_MASK)
2699                                 //vte_write(vte, "\e[21;2~", 7);
2700                                 vte_write(vte, "\e[34~", 5);
2701                         else
2702                                 vte_write(vte, "\e[21~", 5);
2703                         return true;
2704                 case XKB_KEY_F11:
2705                         if (mods & TSM_SHIFT_MASK)
2706                                 vte_write(vte, "\e[23;2~", 7);
2707                         else
2708                                 vte_write(vte, "\e[23~", 5);
2709                         return true;
2710                 case XKB_KEY_F12:
2711                         if (mods & TSM_SHIFT_MASK)
2712                                 vte_write(vte, "\e[24;2~", 7);
2713                         else
2714                                 vte_write(vte, "\e[24~", 5);
2715                         return true;
2716                 case XKB_KEY_F13:
2717                         if (mods & TSM_SHIFT_MASK)
2718                                 vte_write(vte, "\e[25;2~", 7);
2719                         else
2720                                 vte_write(vte, "\e[25~", 5);
2721                         return true;
2722                 case XKB_KEY_F14:
2723                         if (mods & TSM_SHIFT_MASK)
2724                                 vte_write(vte, "\e[26;2~", 7);
2725                         else
2726                                 vte_write(vte, "\e[26~", 5);
2727                         return true;
2728                 case XKB_KEY_F15:
2729                         if (mods & TSM_SHIFT_MASK)
2730                                 vte_write(vte, "\e[28;2~", 7);
2731                         else
2732                                 vte_write(vte, "\e[28~", 5);
2733                         return true;
2734                 case XKB_KEY_F16:
2735                         if (mods & TSM_SHIFT_MASK)
2736                                 vte_write(vte, "\e[29;2~", 7);
2737                         else
2738                                 vte_write(vte, "\e[29~", 5);
2739                         return true;
2740                 case XKB_KEY_F17:
2741                         if (mods & TSM_SHIFT_MASK)
2742                                 vte_write(vte, "\e[31;2~", 7);
2743                         else
2744                                 vte_write(vte, "\e[31~", 5);
2745                         return true;
2746                 case XKB_KEY_F18:
2747                         if (mods & TSM_SHIFT_MASK)
2748                                 vte_write(vte, "\e[32;2~", 7);
2749                         else
2750                                 vte_write(vte, "\e[32~", 5);
2751                         return true;
2752                 case XKB_KEY_F19:
2753                         if (mods & TSM_SHIFT_MASK)
2754                                 vte_write(vte, "\e[33;2~", 7);
2755                         else
2756                                 vte_write(vte, "\e[33~", 5);
2757                         return true;
2758                 case XKB_KEY_F20:
2759                         if (mods & TSM_SHIFT_MASK)
2760                                 vte_write(vte, "\e[34;2~", 7);
2761                         else
2762                                 vte_write(vte, "\e[34~", 5);
2763                         return true;
2764         }
2765
2766         if (unicode != TSM_VTE_INVALID) {
2767                 if (vte->flags & FLAG_7BIT_MODE) {
2768                         val = unicode;
2769                         if (unicode & 0x80) {
2770                                 llog_debug(vte, "invalid keyboard input in 7bit mode U+%x; mapping to '?'",
2771                                            unicode);
2772                                 val = '?';
2773                         }
2774                         vte_write(vte, &val, 1);
2775                 } else if (vte->flags & FLAG_8BIT_MODE) {
2776                         val = unicode;
2777                         if (unicode > 0xff) {
2778                                 llog_debug(vte, "invalid keyboard input in 8bit mode U+%x; mapping to '?'",
2779                                            unicode);
2780                                 val = '?';
2781                         }
2782                         vte_write_raw(vte, &val, 1);
2783                 } else {
2784                         len = tsm_ucs4_to_utf8(tsm_symbol_make(unicode), u8);
2785                         vte_write_raw(vte, u8, len);
2786                 }
2787                 return true;
2788         }
2789
2790         vte->flags &= ~FLAG_PREPEND_ESCAPE;
2791         return false;
2792 }