src/libsystemd-terminal/subterm.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 /*
  22  * Stacked Terminal-Emulator
  23  * This is an interactive test of the term_screen implementation. It runs a
  24  * fully-fletched terminal-emulator inside of a parent TTY. That is, instead of
  25  * rendering the terminal as X11-window, it renders it as sub-window in the
  26  * parent TTY. Think of this like what "GNU-screen" does.
  27  */
  28
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <stdarg.h>
  32 #include <stdbool.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <sys/ioctl.h>
  37 #include <termios.h>
  38 #include "macro.h"
  39 #include "pty.h"
  40 #include "ring.h"
  41 #include "sd-event.h"
  42 #include "term-internal.h"
  43 #include "util.h"
  44
  45 typedef struct Output Output;
  46 typedef struct Terminal Terminal;
  47
  48 struct Output {
  49         int fd;
  50         unsigned int width;
  51         unsigned int height;
  52         unsigned int in_width;
  53         unsigned int in_height;
  54         unsigned int cursor_x;
  55         unsigned int cursor_y;
  56
  57         char obuf[4096];
  58         size_t n_obuf;
  59
  60         bool resized : 1;
  61         bool in_menu : 1;
  62 };
  63
  64 struct Terminal {
  65         sd_event *event;
  66         sd_event_source *frame_timer;
  67         Output *output;
  68         term_utf8 utf8;
  69         term_parser *parser;
  70         term_screen *screen;
  71
  72         int in_fd;
  73         int out_fd;
  74         struct termios saved_in_attr;
  75         struct termios saved_out_attr;
  76
  77         Pty *pty;
  78         Ring out_ring;
  79
  80         bool is_scheduled : 1;
  81         bool is_dirty : 1;
  82         bool is_menu : 1;
  83 };
  84
  85 /*
  86  * Output Handling
  87  */
  88
  89 #define BORDER_HORIZ            "\xe2\x94\x81"
  90 #define BORDER_VERT             "\xe2\x94\x83"
  91 #define BORDER_VERT_RIGHT       "\xe2\x94\xa3"
  92 #define BORDER_VERT_LEFT        "\xe2\x94\xab"
  93 #define BORDER_DOWN_RIGHT       "\xe2\x94\x8f"
  94 #define BORDER_DOWN_LEFT        "\xe2\x94\x93"
  95 #define BORDER_UP_RIGHT         "\xe2\x94\x97"
  96 #define BORDER_UP_LEFT          "\xe2\x94\x9b"
  97
  98 static int output_winch(Output *o) {
  99         struct winsize wsz = { };
 100         int r;
 101
 102         assert_return(o, -EINVAL);
 103
 104         r = ioctl(o->fd, TIOCGWINSZ, &wsz);
 105         if (r < 0) {
 106                 log_error("error: cannot read window-size: %m");
 107                 return -errno;
 108         }
 109
 110         if (wsz.ws_col != o->width || wsz.ws_row != o->height) {
 111                 o->width = wsz.ws_col;
 112                 o->height = wsz.ws_row;
 113                 o->in_width = MAX(o->width, 2U) - 2;
 114                 o->in_height = MAX(o->height, 6U) - 6;
 115                 o->resized = true;
 116         }
 117
 118         return 0;
 119 }
 120
 121 static int output_flush(Output *o) {
 122         ssize_t len;
 123
 124         if (o->n_obuf < 1)
 125                 return 0;
 126
 127         len = loop_write(o->fd, o->obuf, o->n_obuf, false);
 128         if (len < 0) {
 129                 log_error("error: cannot write to TTY (%zd): %s", len, strerror(-len));
 130                 return len;
 131         }
 132
 133         o->n_obuf = 0;
 134
 135         return 0;
 136 }
 137
 138 static int output_write(Output *o, const void *buf, size_t size) {
 139         ssize_t len;
 140         int r;
 141
 142         assert_return(o, -EINVAL);
 143         assert_return(buf || size < 1, -EINVAL);
 144
 145         if (size < 1)
 146                 return 0;
 147
 148         if (o->n_obuf + size > o->n_obuf && o->n_obuf + size <= sizeof(o->obuf)) {
 149                 memcpy(o->obuf + o->n_obuf, buf, size);
 150                 o->n_obuf += size;
 151                 return 0;
 152         }
 153
 154         r = output_flush(o);
 155         if (r < 0)
 156                 return r;
 157
 158         len = loop_write(o->fd, buf, size, false);
 159         if (len < 0) {
 160                 log_error("error: cannot write to TTY (%zd): %s", len, strerror(-len));
 161                 return len;
 162         }
 163
 164         return 0;
 165 }
 166
 167 _printf_(3,0)
 168 static int output_vnprintf(Output *o, size_t max, const char *format, va_list args) {
 169         char buf[4096];
 170         int r;
 171
 172         assert_return(o, -EINVAL);
 173         assert_return(format, -EINVAL);
 174         assert_return(max <= sizeof(buf), -EINVAL);
 175
 176         r = vsnprintf(buf, max, format, args);
 177         if (r > (ssize_t)max)
 178                 r = max;
 179
 180         return output_write(o, buf, r);
 181 }
 182
 183 _printf_(3,4)
 184 static int output_nprintf(Output *o, size_t max, const char *format, ...) {
 185         va_list args;
 186         int r;
 187
 188         va_start(args, format);
 189         r = output_vnprintf(o, max, format, args);
 190         va_end(args);
 191
 192         return r;
 193 }
 194
 195 _printf_(2,0)
 196 static int output_vprintf(Output *o, const char *format, va_list args) {
 197         char buf[4096];
 198         int r;
 199
 200         assert_return(o, -EINVAL);
 201         assert_return(format, -EINVAL);
 202
 203         r = vsnprintf(buf, sizeof(buf), format, args);
 204
 205         assert_return(r < (ssize_t)sizeof(buf), -ENOBUFS);
 206
 207         return output_write(o, buf, r);
 208 }
 209
 210 _printf_(2,3)
 211 static int output_printf(Output *o, const char *format, ...) {
 212         va_list args;
 213         int r;
 214
 215         va_start(args, format);
 216         r = output_vprintf(o, format, args);
 217         va_end(args);
 218
 219         return r;
 220 }
 221
 222 static int output_move_to(Output *o, unsigned int x, unsigned int y) {
 223         int r;
 224
 225         assert_return(o, -EINVAL);
 226
 227         /* force the \e[H code as o->cursor_x/y might be out-of-date */
 228
 229         r = output_printf(o, "\e[%u;%uH", y + 1, x + 1);
 230         if (r < 0)
 231                 return r;
 232
 233         o->cursor_x = x;
 234         o->cursor_y = y;
 235         return 0;
 236 }
 237
 238 static int output_print_line(Output *o, size_t len) {
 239         const char line[] =
 240                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ
 241                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ
 242                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ
 243                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ
 244                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ
 245                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ
 246                 BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ BORDER_HORIZ;
 247         const size_t max = (sizeof(line) - 1) / (sizeof(BORDER_HORIZ) - 1);
 248         size_t i;
 249         int r = 0;
 250
 251         assert_return(o, -EINVAL);
 252
 253         for ( ; len > 0; len -= i) {
 254                 i = (len > max) ? max : len;
 255                 r = output_write(o, line, i * (sizeof(BORDER_HORIZ) - 1));
 256                 if (r < 0)
 257                         break;
 258         }
 259
 260         return r;
 261 }
 262
 263 _printf_(2,3)
 264 static int output_frame_printl(Output *o, const char *format, ...) {
 265         va_list args;
 266         int r;
 267
 268         assert(o);
 269         assert(format);
 270
 271         /* out of frame? */
 272         if (o->cursor_y < 3 || o->cursor_y >= o->height - 3)
 273                 return 0;
 274
 275         va_start(args, format);
 276         r = output_vnprintf(o, o->width - 2, format, args);
 277         va_end(args);
 278
 279         if (r < 0)
 280                 return r;
 281
 282         return output_move_to(o, 1, o->cursor_y + 1);
 283 }
 284
 285 static Output *output_free(Output *o) {
 286         if (!o)
 287                 return NULL;
 288
 289         /* disable alternate screen buffer */
 290         output_printf(o, "\e[?1049l");
 291         output_flush(o);
 292
 293         /* o->fd is owned by the caller */
 294         free(o);
 295
 296         return NULL;
 297 }
 298
 299 static int output_new(Output **out, int fd) {
 300         Output *o;
 301         int r;
 302
 303         assert_return(out, -EINVAL);
 304
 305         o = new0(Output, 1);
 306         if (!o)
 307                 return log_oom();
 308
 309         o->fd = fd;
 310
 311         r = output_winch(o);
 312         if (r < 0)
 313                 goto error;
 314
 315         /* enable alternate screen buffer */
 316         r = output_printf(o, "\e[?1049h");
 317         if (r < 0)
 318                 goto error;
 319
 320         r = output_flush(o);
 321         if (r < 0)
 322                 goto error;
 323
 324         *out = o;
 325         return 0;
 326
 327 error:
 328         output_free(o);
 329         return r;
 330 }
 331
 332 static void output_draw_frame(Output *o) {
 333         unsigned int i;
 334
 335         assert(o);
 336
 337         /* print header-frame */
 338
 339         output_printf(o, BORDER_DOWN_RIGHT);
 340         output_print_line(o, o->width - 2);
 341         output_printf(o, BORDER_DOWN_LEFT
 342                          "\r\n"
 343                          BORDER_VERT
 344                          "\e[2;%uH"    /* cursor-position: 2/x */
 345                          BORDER_VERT
 346                          "\r\n"
 347                          BORDER_VERT_RIGHT,
 348                       o->width);
 349         output_print_line(o, o->width - 2);
 350         output_printf(o, BORDER_VERT_LEFT
 351                          "\r\n");
 352
 353         /* print body-frame */
 354
 355         for (i = 0; i < o->in_height; ++i) {
 356                 output_printf(o, BORDER_VERT
 357                                  "\e[%u;%uH"    /* cursor-position: 2/x */
 358                                  BORDER_VERT
 359                                  "\r\n",
 360                               i + 4, o->width);
 361         }
 362
 363         /* print footer-frame */
 364
 365         output_printf(o, BORDER_VERT_RIGHT);
 366         output_print_line(o, o->width - 2);
 367         output_printf(o, BORDER_VERT_LEFT
 368                          "\r\n"
 369                          BORDER_VERT
 370                          "\e[%u;%uH"    /* cursor-position: 2/x */
 371                          BORDER_VERT
 372                          "\r\n"
 373                          BORDER_UP_RIGHT,
 374                       o->height - 1, o->width);
 375         output_print_line(o, o->width - 2);
 376         output_printf(o, BORDER_UP_LEFT);
 377
 378         /* print header/footer text */
 379
 380         output_printf(o, "\e[2;3H");
 381         output_nprintf(o, o->width - 4, "systemd - embedded terminal emulator");
 382         output_printf(o, "\e[%u;3H", o->height - 1);
 383         output_nprintf(o, o->width - 4, "press ^C to enter menu");
 384 }
 385
 386 static void output_draw_menu(Output *o) {
 387         assert(o);
 388
 389         output_frame_printl(o, "%s", "");
 390         output_frame_printl(o, "    Menu: (the following keys are recognized)");
 391         output_frame_printl(o, "      q: quit");
 392         output_frame_printl(o, "     ^C: send ^C to the PTY");
 393 }
 394
 395 static void output_draw_screen(Output *o, term_screen *s) {
 396         unsigned int i, j;
 397         bool first = true;
 398
 399         assert(o);
 400         assert(s);
 401
 402         for (j = 0; j < s->page->height && j < o->in_height; ++j) {
 403                 if (!first)
 404                         output_printf(o, "\e[m\r\n" BORDER_VERT);
 405                 first = false;
 406
 407                 for (i = 0; i < s->page->width && i < o->in_width; ++i) {
 408                         term_charbuf_t buf;
 409                         term_cell *cell = &s->page->lines[j]->cells[i];
 410                         size_t k, len, ulen;
 411                         const uint32_t *str;
 412                         char utf8[4];
 413
 414                         switch (cell->attr.fg.ccode) {
 415                         case TERM_CCODE_DEFAULT:
 416                                 output_printf(o, "\e[39m");
 417                                 break;
 418                         case TERM_CCODE_256:
 419                                 output_printf(o, "\e[38;5;%um", cell->attr.fg.c256);
 420                                 break;
 421                         case TERM_CCODE_RGB:
 422                                 output_printf(o, "\e[38;2;%u;%u;%um", cell->attr.fg.red, cell->attr.fg.green, cell->attr.fg.blue);
 423                                 break;
 424                         case TERM_CCODE_BLACK ... TERM_CCODE_WHITE:
 425                                 if (cell->attr.bold)
 426                                         output_printf(o, "\e[%um", cell->attr.fg.ccode - TERM_CCODE_BLACK + 90);
 427                                 else
 428                                         output_printf(o, "\e[%um", cell->attr.fg.ccode - TERM_CCODE_BLACK + 30);
 429                                 break;
 430                         case TERM_CCODE_LIGHT_BLACK ... TERM_CCODE_LIGHT_WHITE:
 431                                 output_printf(o, "\e[%um", cell->attr.fg.ccode - TERM_CCODE_LIGHT_BLACK + 90);
 432                                 break;
 433                         }
 434
 435                         switch (cell->attr.bg.ccode) {
 436                         case TERM_CCODE_DEFAULT:
 437                                 output_printf(o, "\e[49m");
 438                                 break;
 439                         case TERM_CCODE_256:
 440                                 output_printf(o, "\e[48;5;%um", cell->attr.bg.c256);
 441                                 break;
 442                         case TERM_CCODE_RGB:
 443                                 output_printf(o, "\e[48;2;%u;%u;%um", cell->attr.bg.red, cell->attr.bg.green, cell->attr.bg.blue);
 444                                 break;
 445                         case TERM_CCODE_BLACK ... TERM_CCODE_WHITE:
 446                                 output_printf(o, "\e[%um", cell->attr.bg.ccode - TERM_CCODE_BLACK + 40);
 447                                 break;
 448                         case TERM_CCODE_LIGHT_BLACK ... TERM_CCODE_LIGHT_WHITE:
 449                                 output_printf(o, "\e[%um", cell->attr.bg.ccode - TERM_CCODE_LIGHT_BLACK + 100);
 450                                 break;
 451                         }
 452
 453                         output_printf(o, "\e[%u;%u;%u;%u;%u;%um",
 454                                       cell->attr.bold ? 1 : 22,
 455                                       cell->attr.italic ? 3 : 23,
 456                                       cell->attr.underline ? 4 : 24,
 457                                       cell->attr.inverse ? 7 : 27,
 458                                       cell->attr.blink ? 5 : 25,
 459                                       cell->attr.hidden ? 8 : 28);
 460
 461                         str = term_char_resolve(cell->ch, &len, &buf);
 462
 463                         if (len < 1) {
 464                                 output_printf(o, " ");
 465                         } else {
 466                                 for (k = 0; k < len; ++k) {
 467                                         ulen = term_utf8_encode(utf8, str[k]);
 468                                         output_write(o, utf8, ulen);
 469                                 }
 470                         }
 471                 }
 472         }
 473
 474         output_move_to(o, s->cursor_x + 1, s->cursor_y + 3);
 475         output_printf(o, "\e[m");
 476 }
 477
 478 static void output_draw(Output *o, bool menu, term_screen *screen) {
 479         assert(o);
 480
 481         /*
 482          * This renders the contenst of the terminal. The layout contains a
 483          * header, the main body and a footer. Around all areas we draw a
 484          * border. It looks something like this:
 485          *
 486          *     +----------------------------------------------------+
 487          *     |                      Header                        |
 488          *     +----------------------------------------------------+
 489          *     |                                                    |
 490          *     |                                                    |
 491          *     |                                                    |
 492          *     |                       Body                         |
 493          *     |                                                    |
 494          *     |                                                    |
 495          *     ~                                                    ~
 496          *     ~                                                    ~
 497          *     +----------------------------------------------------+
 498          *     |                      Footer                        |
 499          *     +----------------------------------------------------+
 500          *
 501          * The body is the part that grows vertically.
 502          *
 503          * We need at least 6 vertical lines to render the screen. This would
 504          * leave 0 lines for the body. Therefore, we require 7 lines so there's
 505          * at least one body line. Similarly, we need 2 horizontal cells for the
 506          * frame, so we require 3.
 507          * If the window is too small, we print an error message instead.
 508          */
 509
 510         if (o->in_width < 1 || o->in_height < 1) {
 511                 output_printf(o, "\e[2J"         /* erase-in-display: whole screen */
 512                                  "\e[H");        /* cursor-position: home */
 513                 output_printf(o, "error: screen too small, need at least 3x7 cells");
 514                 output_flush(o);
 515                 return;
 516         }
 517
 518         /* hide cursor */
 519         output_printf(o, "\e[?25l");
 520
 521         /* frame-content is contant; only resizes can change it */
 522         if (o->resized || o->in_menu != menu) {
 523                 output_printf(o, "\e[2J"         /* erase-in-display: whole screen */
 524                                  "\e[H");        /* cursor-position: home */
 525                 output_draw_frame(o);
 526                 o->resized = false;
 527                 o->in_menu = menu;
 528         }
 529
 530         /* move cursor to child's position */
 531         output_move_to(o, 1, 3);
 532
 533         if (menu)
 534                 output_draw_menu(o);
 535         else
 536                 output_draw_screen(o, screen);
 537
 538         /* show cursor */
 539         if (!(screen->flags & TERM_FLAG_HIDE_CURSOR))
 540                 output_printf(o, "\e[?25h");
 541
 542         /*
 543          * Hack: sd-term was not written to support TTY as output-objects, thus
 544          * expects callers to use term_screen_feed_keyboard(). However, we
 545          * forward TTY input directly. Hence, we're not notified about keypad
 546          * changes. Update the related modes djring redraw to keep them at least
 547          * in sync.
 548          */
 549         if (screen->flags & TERM_FLAG_CURSOR_KEYS)
 550                 output_printf(o, "\e[?1h");
 551         else
 552                 output_printf(o, "\e[?1l");
 553
 554         if (screen->flags & TERM_FLAG_KEYPAD_MODE)
 555                 output_printf(o, "\e=");
 556         else
 557                 output_printf(o, "\e>");
 558
 559         output_flush(o);
 560 }
 561
 562 /*
 563  * Terminal Handling
 564  */
 565
 566 static void terminal_dirty(Terminal *t) {
 567         usec_t usec;
 568         int r;
 569
 570         assert(t);
 571
 572         if (t->is_scheduled) {
 573                 t->is_dirty = true;
 574                 return;
 575         }
 576
 577         /* 16ms timer */
 578         r = sd_event_now(t->event, CLOCK_MONOTONIC, &usec);
 579         assert(r >= 0);
 580
 581         usec += 16 * USEC_PER_MSEC;
 582         r = sd_event_source_set_time(t->frame_timer, usec);
 583         if (r >= 0) {
 584                 r = sd_event_source_set_enabled(t->frame_timer, SD_EVENT_ONESHOT);
 585                 if (r >= 0)
 586                         t->is_scheduled = true;
 587         }
 588
 589         t->is_dirty = false;
 590         output_draw(t->output, t->is_menu, t->screen);
 591 }
 592
 593 static int terminal_frame_timer_fn(sd_event_source *source, uint64_t usec, void *userdata) {
 594         Terminal *t = userdata;
 595
 596         t->is_scheduled = false;
 597         if (t->is_dirty)
 598                 terminal_dirty(t);
 599
 600         return 0;
 601 }
 602
 603 static int terminal_winch_fn(sd_event_source *source, const struct signalfd_siginfo *ssi, void *userdata) {
 604         Terminal *t = userdata;
 605         int r;
 606
 607         output_winch(t->output);
 608
 609         if (t->pty) {
 610                 r = pty_resize(t->pty, t->output->in_width, t->output->in_height);
 611                 if (r < 0)
 612                         log_error("error: pty_resize() (%d): %s", r, strerror(-r));
 613         }
 614
 615         r = term_screen_resize(t->screen, t->output->in_width, t->output->in_height);
 616         if (r < 0)
 617                 log_error("error: term_screen_resize() (%d): %s", r, strerror(-r));
 618
 619         terminal_dirty(t);
 620
 621         return 0;
 622 }
 623
 624 static int terminal_push_tmp(Terminal *t, uint32_t ucs4) {
 625         char buf[4];
 626         size_t len;
 627         int r;
 628
 629         assert(t);
 630
 631         len = term_utf8_encode(buf, ucs4);
 632         if (len < 1)
 633                 return 0;
 634
 635         r = ring_push(&t->out_ring, buf, len);
 636         if (r < 0)
 637                 log_oom();
 638
 639         return r;
 640 }
 641
 642 static int terminal_write_tmp(Terminal *t) {
 643         struct iovec vec[2];
 644         size_t num, i;
 645         int r;
 646
 647         assert(t);
 648
 649         num = ring_peek(&t->out_ring, vec);
 650         if (num < 1)
 651                 return 0;
 652
 653         if (t->pty) {
 654                 for (i = 0; i < num; ++i) {
 655                         r = pty_write(t->pty, vec[i].iov_base, vec[i].iov_len);
 656                         if (r < 0) {
 657                                 log_error("error: cannot write to PTY (%d): %s", r, strerror(-r));
 658                                 return r;
 659                         }
 660                 }
 661         }
 662
 663         ring_flush(&t->out_ring);
 664         return 0;
 665 }
 666
 667 static void terminal_discard_tmp(Terminal *t) {
 668         assert(t);
 669
 670         ring_flush(&t->out_ring);
 671 }
 672
 673 static int terminal_menu(Terminal *t, const term_seq *seq) {
 674         switch (seq->type) {
 675         case TERM_SEQ_IGNORE:
 676                 break;
 677         case TERM_SEQ_GRAPHIC:
 678                 switch (seq->terminator) {
 679                 case 'q':
 680                         sd_event_exit(t->event, 0);
 681                         return 0;
 682                 }
 683
 684                 break;
 685         case TERM_SEQ_CONTROL:
 686                 switch (seq->terminator) {
 687                 case 0x03:
 688                         terminal_push_tmp(t, 0x03);
 689                         terminal_write_tmp(t);
 690                         break;
 691                 }
 692
 693                 break;
 694         }
 695
 696         t->is_menu = false;
 697         terminal_dirty(t);
 698
 699         return 0;
 700 }
 701
 702 static int terminal_io_fn(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 703         Terminal *t = userdata;
 704         char buf[4096];
 705         ssize_t len, i;
 706         int r, type;
 707
 708         len = read(fd, buf, sizeof(buf));
 709         if (len < 0) {
 710                 if (errno == EAGAIN || errno == EINTR)
 711                         return 0;
 712
 713                 log_error("error: cannot read from TTY (%d): %m", -errno);
 714                 return -errno;
 715         }
 716
 717         for (i = 0; i < len; ++i) {
 718                 const term_seq *seq;
 719                 const uint32_t *str;
 720                 size_t n_str, j;
 721
 722                 str = term_utf8_decode(&t->utf8, &n_str, buf[i]);
 723                 for (j = 0; j < n_str; ++j) {
 724                         type = term_parser_feed(t->parser, &seq, str[j]);
 725                         if (type < 0) {
 726                                 log_error("error: term_parser_feed() (%d): %s", type, strerror(-type));
 727                                 return type;
 728                         }
 729
 730                         if (!t->is_menu) {
 731                                 r = terminal_push_tmp(t, str[j]);
 732                                 if (r < 0)
 733                                         return r;
 734                         }
 735
 736                         if (type == TERM_SEQ_NONE) {
 737                                 /* We only intercept one-char sequences, so in
 738                                  * case term_parser_feed() couldn't parse a
 739                                  * sequence, it is waiting for more data. We
 740                                  * know it can never be a one-char sequence
 741                                  * then, so we can safely forward the data.
 742                                  * This avoids withholding ESC or other values
 743                                  * that may be one-shot depending on the
 744                                  * application. */
 745                                 r = terminal_write_tmp(t);
 746                                 if (r < 0)
 747                                         return r;
 748                         } else if (t->is_menu) {
 749                                 r = terminal_menu(t, seq);
 750                                 if (r < 0)
 751                                         return r;
 752                         } else if (seq->type == TERM_SEQ_CONTROL && seq->terminator == 0x03) { /* ^C opens the menu */
 753                                 terminal_discard_tmp(t);
 754                                 t->is_menu = true;
 755                                 terminal_dirty(t);
 756                         } else {
 757                                 r = terminal_write_tmp(t);
 758                                 if (r < 0)
 759                                         return r;
 760                         }
 761                 }
 762         }
 763
 764         return 0;
 765 }
 766
 767 static int terminal_pty_fn(Pty *pty, void *userdata, unsigned int event, const void *ptr, size_t size) {
 768         Terminal *t = userdata;
 769         int r;
 770
 771         switch (event) {
 772         case PTY_CHILD:
 773                 sd_event_exit(t->event, 0);
 774                 break;
 775         case PTY_DATA:
 776                 r = term_screen_feed_text(t->screen, ptr, size);
 777                 if (r < 0) {
 778                         log_error("error: term_screen_feed_text() (%d): %s", r, strerror(-r));
 779                         return r;
 780                 }
 781
 782                 terminal_dirty(t);
 783                 break;
 784         }
 785
 786         return 0;
 787 }
 788
 789 static int terminal_write_fn(term_screen *screen, void *userdata, const void *buf, size_t size) {
 790         Terminal *t = userdata;
 791         int r;
 792
 793         if (!t->pty)
 794                 return 0;
 795
 796         r = ring_push(&t->out_ring, buf, size);
 797         if (r < 0)
 798                 log_oom();
 799
 800         return r;
 801 }
 802
 803 static int terminal_cmd_fn(term_screen *screen, void *userdata, unsigned int cmd, const term_seq *seq) {
 804         return 0;
 805 }
 806
 807 static Terminal *terminal_free(Terminal *t) {
 808         if (!t)
 809                 return NULL;
 810
 811         ring_clear(&t->out_ring);
 812         term_screen_unref(t->screen);
 813         term_parser_free(t->parser);
 814         output_free(t->output);
 815         sd_event_source_unref(t->frame_timer);
 816         sd_event_unref(t->event);
 817         tcsetattr(t->in_fd, TCSANOW, &t->saved_in_attr);
 818         tcsetattr(t->out_fd, TCSANOW, &t->saved_out_attr);
 819         free(t);
 820
 821         return NULL;
 822 }
 823
 824 static int terminal_new(Terminal **out, int in_fd, int out_fd) {
 825         struct termios in_attr, out_attr;
 826         Terminal *t;
 827         int r;
 828
 829         assert_return(out, -EINVAL);
 830
 831         r = tcgetattr(in_fd, &in_attr);
 832         if (r < 0) {
 833                 log_error("error: tcgetattr() (%d): %m", -errno);
 834                 return -errno;
 835         }
 836
 837         r = tcgetattr(out_fd, &out_attr);
 838         if (r < 0) {
 839                 log_error("error: tcgetattr() (%d): %m", -errno);
 840                 return -errno;
 841         }
 842
 843         t = new0(Terminal, 1);
 844         if (!t)
 845                 return log_oom();
 846
 847         t->in_fd = in_fd;
 848         t->out_fd = out_fd;
 849         memcpy(&t->saved_in_attr, &in_attr, sizeof(in_attr));
 850         memcpy(&t->saved_out_attr, &out_attr, sizeof(out_attr));
 851
 852         cfmakeraw(&in_attr);
 853         cfmakeraw(&out_attr);
 854
 855         r = tcsetattr(t->in_fd, TCSANOW, &in_attr);
 856         if (r < 0) {
 857                 log_error("error: tcsetattr() (%d): %s", r, strerror(-r));
 858                 goto error;
 859         }
 860
 861         r = tcsetattr(t->out_fd, TCSANOW, &out_attr);
 862         if (r < 0) {
 863                 log_error("error: tcsetattr() (%d): %s", r, strerror(-r));
 864                 goto error;
 865         }
 866
 867         r = sd_event_default(&t->event);
 868         if (r < 0) {
 869                 log_error("error: sd_event_default() (%d): %s", r, strerror(-r));
 870                 goto error;
 871         }
 872
 873         r = sigprocmask_many(SIG_BLOCK, SIGINT, SIGQUIT, SIGTERM, SIGWINCH, SIGCHLD, -1);
 874         if (r < 0) {
 875                 log_error("error: sigprocmask_many() (%d): %s", r, strerror(-r));
 876                 goto error;
 877         }
 878
 879         r = sd_event_add_signal(t->event, NULL, SIGINT, NULL, NULL);
 880         if (r < 0) {
 881                 log_error("error: sd_event_add_signal() (%d): %s", r, strerror(-r));
 882                 goto error;
 883         }
 884
 885         r = sd_event_add_signal(t->event, NULL, SIGQUIT, NULL, NULL);
 886         if (r < 0) {
 887                 log_error("error: sd_event_add_signal() (%d): %s", r, strerror(-r));
 888                 goto error;
 889         }
 890
 891         r = sd_event_add_signal(t->event, NULL, SIGTERM, NULL, NULL);
 892         if (r < 0) {
 893                 log_error("error: sd_event_add_signal() (%d): %s", r, strerror(-r));
 894                 goto error;
 895         }
 896
 897         r = sd_event_add_signal(t->event, NULL, SIGWINCH, terminal_winch_fn, t);
 898         if (r < 0) {
 899                 log_error("error: sd_event_add_signal() (%d): %s", r, strerror(-r));
 900                 goto error;
 901         }
 902
 903         /* force initial redraw on event-loop enter */
 904         t->is_dirty = true;
 905         r = sd_event_add_time(t->event, &t->frame_timer, CLOCK_MONOTONIC, 0, 0, terminal_frame_timer_fn, t);
 906         if (r < 0) {
 907                 log_error("error: sd_event_add_time() (%d): %s", r, strerror(-r));
 908                 goto error;
 909         }
 910
 911         r = output_new(&t->output, out_fd);
 912         if (r < 0)
 913                 goto error;
 914
 915         r = term_parser_new(&t->parser, true);
 916         if (r < 0)
 917                 goto error;
 918
 919         r = term_screen_new(&t->screen, terminal_write_fn, t, terminal_cmd_fn, t);
 920         if (r < 0)
 921                 goto error;
 922
 923         r = term_screen_set_answerback(t->screen, "systemd-subterm");
 924         if (r < 0)
 925                 goto error;
 926
 927         r = term_screen_resize(t->screen, t->output->in_width, t->output->in_height);
 928         if (r < 0) {
 929                 log_error("error: term_screen_resize() (%d): %s", r, strerror(-r));
 930                 goto error;
 931         }
 932
 933         r = sd_event_add_io(t->event, NULL, in_fd, EPOLLIN, terminal_io_fn, t);
 934         if (r < 0)
 935                 goto error;
 936
 937         *out = t;
 938         return 0;
 939
 940 error:
 941         terminal_free(t);
 942         return r;
 943 }
 944
 945 static int terminal_run(Terminal *t) {
 946         pid_t pid;
 947
 948         assert_return(t, -EINVAL);
 949
 950         pid = pty_fork(&t->pty, t->event, terminal_pty_fn, t, t->output->in_width, t->output->in_height);
 951         if (pid < 0) {
 952                 log_error("error: cannot fork PTY (%d): %s", pid, strerror(-pid));
 953                 return pid;
 954         } else if (pid == 0) {
 955                 /* child */
 956
 957                 char **argv = (char*[]){
 958                         (char*)getenv("SHELL") ? : (char*)_PATH_BSHELL,
 959                         NULL
 960                 };
 961
 962                 setenv("TERM", "xterm-256color", 1);
 963                 setenv("COLORTERM", "systemd-subterm", 1);
 964
 965                 execve(argv[0], argv, environ);
 966                 log_error("error: cannot exec %s (%d): %m", argv[0], -errno);
 967                 _exit(1);
 968         }
 969
 970         /* parent */
 971
 972         return sd_event_loop(t->event);
 973 }
 974
 975 /*
 976  * Context Handling
 977  */
 978
 979 int main(int argc, char *argv[]) {
 980         Terminal *t = NULL;
 981         int r;
 982
 983         r = terminal_new(&t, 0, 1);
 984         if (r < 0)
 985                 goto out;
 986
 987         r = terminal_run(t);
 988         if (r < 0)
 989                 goto out;
 990
 991 out:
 992         if (r < 0)
 993                 log_error("error: terminal failed (%d): %s", r, strerror(-r));
 994         terminal_free(t);
 995         return -r;
 996 }