src/shared/ptyfwd.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <limits.h>
   6 #include <signal.h>
   7 #include <stddef.h>
   8 #include <stdint.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/epoll.h>
  12 #include <sys/ioctl.h>
  13 #include <sys/time.h>
  14 #include <termios.h>
  15 #include <unistd.h>
  16
  17 #include "sd-event.h"
  18
  19 #include "alloc-util.h"
  20 #include "errno-util.h"
  21 #include "fd-util.h"
  22 #include "log.h"
  23 #include "macro.h"
  24 #include "ptyfwd.h"
  25 #include "terminal-util.h"
  26 #include "time-util.h"
  27
  28 struct PTYForward {
  29         sd_event *event;
  30
  31         int input_fd;
  32         int output_fd;
  33         int master;
  34
  35         PTYForwardFlags flags;
  36
  37         sd_event_source *stdin_event_source;
  38         sd_event_source *stdout_event_source;
  39         sd_event_source *master_event_source;
  40
  41         sd_event_source *sigwinch_event_source;
  42
  43         struct termios saved_stdin_attr;
  44         struct termios saved_stdout_attr;
  45
  46         bool close_input_fd:1;
  47         bool close_output_fd:1;
  48
  49         bool saved_stdin:1;
  50         bool saved_stdout:1;
  51
  52         bool stdin_readable:1;
  53         bool stdin_hangup:1;
  54         bool stdout_writable:1;
  55         bool stdout_hangup:1;
  56         bool master_readable:1;
  57         bool master_writable:1;
  58         bool master_hangup:1;
  59
  60         bool read_from_master:1;
  61
  62         bool done:1;
  63         bool drain:1;
  64
  65         bool last_char_set:1;
  66         char last_char;
  67
  68         char in_buffer[LINE_MAX], out_buffer[LINE_MAX];
  69         size_t in_buffer_full, out_buffer_full;
  70
  71         usec_t escape_timestamp;
  72         unsigned escape_counter;
  73
  74         PTYForwardHandler handler;
  75         void *userdata;
  76 };
  77
  78 #define ESCAPE_USEC (1*USEC_PER_SEC)
  79
  80 static void pty_forward_disconnect(PTYForward *f) {
  81
  82         if (!f)
  83                 return;
  84
  85         f->stdin_event_source = sd_event_source_unref(f->stdin_event_source);
  86         f->stdout_event_source = sd_event_source_unref(f->stdout_event_source);
  87
  88         f->master_event_source = sd_event_source_unref(f->master_event_source);
  89         f->sigwinch_event_source = sd_event_source_unref(f->sigwinch_event_source);
  90         f->event = sd_event_unref(f->event);
  91
  92         if (f->output_fd >= 0) {
  93                 if (f->saved_stdout)
  94                         (void) tcsetattr(f->output_fd, TCSANOW, &f->saved_stdout_attr);
  95
  96                 /* STDIN/STDOUT should not be non-blocking normally, so let's reset it */
  97                 (void) fd_nonblock(f->output_fd, false);
  98                 if (f->close_output_fd)
  99                         f->output_fd = safe_close(f->output_fd);
 100         }
 101
 102         if (f->input_fd >= 0) {
 103                 if (f->saved_stdin)
 104                         (void) tcsetattr(f->input_fd, TCSANOW, &f->saved_stdin_attr);
 105
 106                 (void) fd_nonblock(f->input_fd, false);
 107                 if (f->close_input_fd)
 108                         f->input_fd = safe_close(f->input_fd);
 109         }
 110
 111         f->saved_stdout = f->saved_stdin = false;
 112 }
 113
 114 static int pty_forward_done(PTYForward *f, int rcode) {
 115         _cleanup_(sd_event_unrefp) sd_event *e = NULL;
 116         assert(f);
 117
 118         if (f->done)
 119                 return 0;
 120
 121         e = sd_event_ref(f->event);
 122
 123         f->done = true;
 124         pty_forward_disconnect(f);
 125
 126         if (f->handler)
 127                 return f->handler(f, rcode, f->userdata);
 128         else
 129                 return sd_event_exit(e, rcode < 0 ? EXIT_FAILURE : rcode);
 130 }
 131
 132 static bool look_for_escape(PTYForward *f, const char *buffer, size_t n) {
 133         const char *p;
 134
 135         assert(f);
 136         assert(buffer);
 137         assert(n > 0);
 138
 139         for (p = buffer; p < buffer + n; p++) {
 140
 141                 /* Check for ^] */
 142                 if (*p == 0x1D) {
 143                         usec_t nw = now(CLOCK_MONOTONIC);
 144
 145                         if (f->escape_counter == 0 || nw > f->escape_timestamp + ESCAPE_USEC)  {
 146                                 f->escape_timestamp = nw;
 147                                 f->escape_counter = 1;
 148                         } else {
 149                                 (f->escape_counter)++;
 150
 151                                 if (f->escape_counter >= 3)
 152                                         return true;
 153                         }
 154                 } else {
 155                         f->escape_timestamp = 0;
 156                         f->escape_counter = 0;
 157                 }
 158         }
 159
 160         return false;
 161 }
 162
 163 static bool ignore_vhangup(PTYForward *f) {
 164         assert(f);
 165
 166         if (f->flags & PTY_FORWARD_IGNORE_VHANGUP)
 167                 return true;
 168
 169         if ((f->flags & PTY_FORWARD_IGNORE_INITIAL_VHANGUP) && !f->read_from_master)
 170                 return true;
 171
 172         return false;
 173 }
 174
 175 static bool drained(PTYForward *f) {
 176         int q = 0;
 177
 178         assert(f);
 179
 180         if (f->out_buffer_full > 0)
 181                 return false;
 182
 183         if (f->master_readable)
 184                 return false;
 185
 186         if (ioctl(f->master, TIOCINQ, &q) < 0)
 187                 log_debug_errno(errno, "TIOCINQ failed on master: %m");
 188         else if (q > 0)
 189                 return false;
 190
 191         if (ioctl(f->master, TIOCOUTQ, &q) < 0)
 192                 log_debug_errno(errno, "TIOCOUTQ failed on master: %m");
 193         else if (q > 0)
 194                 return false;
 195
 196         return true;
 197 }
 198
 199 static int shovel(PTYForward *f) {
 200         ssize_t k;
 201
 202         assert(f);
 203
 204         while ((f->stdin_readable && f->in_buffer_full <= 0) ||
 205                (f->master_writable && f->in_buffer_full > 0) ||
 206                (f->master_readable && f->out_buffer_full <= 0) ||
 207                (f->stdout_writable && f->out_buffer_full > 0)) {
 208
 209                 if (f->stdin_readable && f->in_buffer_full < LINE_MAX) {
 210
 211                         k = read(f->input_fd, f->in_buffer + f->in_buffer_full, LINE_MAX - f->in_buffer_full);
 212                         if (k < 0) {
 213
 214                                 if (errno == EAGAIN)
 215                                         f->stdin_readable = false;
 216                                 else if (errno == EIO || ERRNO_IS_DISCONNECT(errno)) {
 217                                         f->stdin_readable = false;
 218                                         f->stdin_hangup = true;
 219
 220                                         f->stdin_event_source = sd_event_source_unref(f->stdin_event_source);
 221                                 } else {
 222                                         log_error_errno(errno, "read(): %m");
 223                                         return pty_forward_done(f, -errno);
 224                                 }
 225                         } else if (k == 0) {
 226                                 /* EOF on stdin */
 227                                 f->stdin_readable = false;
 228                                 f->stdin_hangup = true;
 229
 230                                 f->stdin_event_source = sd_event_source_unref(f->stdin_event_source);
 231                         } else  {
 232                                 /* Check if ^] has been pressed three times within one second. If we get this we quite
 233                                  * immediately. */
 234                                 if (look_for_escape(f, f->in_buffer + f->in_buffer_full, k))
 235                                         return pty_forward_done(f, -ECANCELED);
 236
 237                                 f->in_buffer_full += (size_t) k;
 238                         }
 239                 }
 240
 241                 if (f->master_writable && f->in_buffer_full > 0) {
 242
 243                         k = write(f->master, f->in_buffer, f->in_buffer_full);
 244                         if (k < 0) {
 245
 246                                 if (IN_SET(errno, EAGAIN, EIO))
 247                                         f->master_writable = false;
 248                                 else if (IN_SET(errno, EPIPE, ECONNRESET)) {
 249                                         f->master_writable = f->master_readable = false;
 250                                         f->master_hangup = true;
 251
 252                                         f->master_event_source = sd_event_source_unref(f->master_event_source);
 253                                 } else {
 254                                         log_error_errno(errno, "write(): %m");
 255                                         return pty_forward_done(f, -errno);
 256                                 }
 257                         } else {
 258                                 assert(f->in_buffer_full >= (size_t) k);
 259                                 memmove(f->in_buffer, f->in_buffer + k, f->in_buffer_full - k);
 260                                 f->in_buffer_full -= k;
 261                         }
 262                 }
 263
 264                 if (f->master_readable && f->out_buffer_full < LINE_MAX) {
 265
 266                         k = read(f->master, f->out_buffer + f->out_buffer_full, LINE_MAX - f->out_buffer_full);
 267                         if (k < 0) {
 268
 269                                 /* Note that EIO on the master device
 270                                  * might be caused by vhangup() or
 271                                  * temporary closing of everything on
 272                                  * the other side, we treat it like
 273                                  * EAGAIN here and try again, unless
 274                                  * ignore_vhangup is off. */
 275
 276                                 if (errno == EAGAIN || (errno == EIO && ignore_vhangup(f)))
 277                                         f->master_readable = false;
 278                                 else if (IN_SET(errno, EPIPE, ECONNRESET, EIO)) {
 279                                         f->master_readable = f->master_writable = false;
 280                                         f->master_hangup = true;
 281
 282                                         f->master_event_source = sd_event_source_unref(f->master_event_source);
 283                                 } else {
 284                                         log_error_errno(errno, "read(): %m");
 285                                         return pty_forward_done(f, -errno);
 286                                 }
 287                         }  else {
 288                                 f->read_from_master = true;
 289                                 f->out_buffer_full += (size_t) k;
 290                         }
 291                 }
 292
 293                 if (f->stdout_writable && f->out_buffer_full > 0) {
 294
 295                         k = write(f->output_fd, f->out_buffer, f->out_buffer_full);
 296                         if (k < 0) {
 297
 298                                 if (errno == EAGAIN)
 299                                         f->stdout_writable = false;
 300                                 else if (errno == EIO || ERRNO_IS_DISCONNECT(errno)) {
 301                                         f->stdout_writable = false;
 302                                         f->stdout_hangup = true;
 303                                         f->stdout_event_source = sd_event_source_unref(f->stdout_event_source);
 304                                 } else {
 305                                         log_error_errno(errno, "write(): %m");
 306                                         return pty_forward_done(f, -errno);
 307                                 }
 308
 309                         } else {
 310
 311                                 if (k > 0) {
 312                                         f->last_char = f->out_buffer[k-1];
 313                                         f->last_char_set = true;
 314                                 }
 315
 316                                 assert(f->out_buffer_full >= (size_t) k);
 317                                 memmove(f->out_buffer, f->out_buffer + k, f->out_buffer_full - k);
 318                                 f->out_buffer_full -= k;
 319                         }
 320                 }
 321         }
 322
 323         if (f->stdin_hangup || f->stdout_hangup || f->master_hangup) {
 324                 /* Exit the loop if any side hung up and if there's
 325                  * nothing more to write or nothing we could write. */
 326
 327                 if ((f->out_buffer_full <= 0 || f->stdout_hangup) &&
 328                     (f->in_buffer_full <= 0 || f->master_hangup))
 329                         return pty_forward_done(f, 0);
 330         }
 331
 332         /* If we were asked to drain, and there's nothing more to handle from the master, then call the callback
 333          * too. */
 334         if (f->drain && drained(f))
 335                 return pty_forward_done(f, 0);
 336
 337         return 0;
 338 }
 339
 340 static int on_master_event(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
 341         PTYForward *f = ASSERT_PTR(userdata);
 342
 343         assert(e);
 344         assert(e == f->master_event_source);
 345         assert(fd >= 0);
 346         assert(fd == f->master);
 347
 348         if (revents & (EPOLLIN|EPOLLHUP))
 349                 f->master_readable = true;
 350
 351         if (revents & (EPOLLOUT|EPOLLHUP))
 352                 f->master_writable = true;
 353
 354         return shovel(f);
 355 }
 356
 357 static int on_stdin_event(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
 358         PTYForward *f = ASSERT_PTR(userdata);
 359
 360         assert(e);
 361         assert(e == f->stdin_event_source);
 362         assert(fd >= 0);
 363         assert(fd == f->input_fd);
 364
 365         if (revents & (EPOLLIN|EPOLLHUP))
 366                 f->stdin_readable = true;
 367
 368         return shovel(f);
 369 }
 370
 371 static int on_stdout_event(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
 372         PTYForward *f = ASSERT_PTR(userdata);
 373
 374         assert(e);
 375         assert(e == f->stdout_event_source);
 376         assert(fd >= 0);
 377         assert(fd == f->output_fd);
 378
 379         if (revents & (EPOLLOUT|EPOLLHUP))
 380                 f->stdout_writable = true;
 381
 382         return shovel(f);
 383 }
 384
 385 static int on_sigwinch_event(sd_event_source *e, const struct signalfd_siginfo *si, void *userdata) {
 386         PTYForward *f = ASSERT_PTR(userdata);
 387         struct winsize ws;
 388
 389         assert(e);
 390         assert(e == f->sigwinch_event_source);
 391
 392         /* The window size changed, let's forward that. */
 393         if (ioctl(f->output_fd, TIOCGWINSZ, &ws) >= 0)
 394                 (void) ioctl(f->master, TIOCSWINSZ, &ws);
 395
 396         return 0;
 397 }
 398
 399 int pty_forward_new(
 400                 sd_event *event,
 401                 int master,
 402                 PTYForwardFlags flags,
 403                 PTYForward **ret) {
 404
 405         _cleanup_(pty_forward_freep) PTYForward *f = NULL;
 406         struct winsize ws;
 407         int r;
 408
 409         f = new(PTYForward, 1);
 410         if (!f)
 411                 return -ENOMEM;
 412
 413         *f = (struct PTYForward) {
 414                 .flags = flags,
 415                 .master = -1,
 416                 .input_fd = -1,
 417                 .output_fd = -1,
 418         };
 419
 420         if (event)
 421                 f->event = sd_event_ref(event);
 422         else {
 423                 r = sd_event_default(&f->event);
 424                 if (r < 0)
 425                         return r;
 426         }
 427
 428         if (FLAGS_SET(flags, PTY_FORWARD_READ_ONLY))
 429                 f->output_fd = STDOUT_FILENO;
 430         else {
 431                 /* If we shall be invoked in interactive mode, let's switch on non-blocking mode, so that we
 432                  * never end up staving one direction while we block on the other. However, let's be careful
 433                  * here and not turn on O_NONBLOCK for stdin/stdout directly, but of re-opened copies of
 434                  * them. This has two advantages: when we are killed abruptly the stdin/stdout fds won't be
 435                  * left in O_NONBLOCK state for the next process using them. In addition, if some process
 436                  * running in the background wants to continue writing to our stdout it can do so without
 437                  * being confused by O_NONBLOCK. */
 438
 439                 f->input_fd = fd_reopen(STDIN_FILENO, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
 440                 if (f->input_fd < 0) {
 441                         /* Handle failures gracefully, after all certain fd types cannot be reopened
 442                          * (sockets, …) */
 443                         log_debug_errno(f->input_fd, "Failed to reopen stdin, using original fd: %m");
 444
 445                         r = fd_nonblock(STDIN_FILENO, true);
 446                         if (r < 0)
 447                                 return r;
 448
 449                         f->input_fd = STDIN_FILENO;
 450                 } else
 451                         f->close_input_fd = true;
 452
 453                 f->output_fd = fd_reopen(STDOUT_FILENO, O_WRONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
 454                 if (f->output_fd < 0) {
 455                         log_debug_errno(f->output_fd, "Failed to reopen stdout, using original fd: %m");
 456
 457                         r = fd_nonblock(STDOUT_FILENO, true);
 458                         if (r < 0)
 459                                 return r;
 460
 461                         f->output_fd = STDOUT_FILENO;
 462                 } else
 463                         f->close_output_fd = true;
 464         }
 465
 466         r = fd_nonblock(master, true);
 467         if (r < 0)
 468                 return r;
 469
 470         f->master = master;
 471
 472         if (ioctl(f->output_fd, TIOCGWINSZ, &ws) < 0)
 473                 /* If we can't get the resolution from the output fd, then use our internal, regular width/height,
 474                  * i.e. something derived from $COLUMNS and $LINES if set. */
 475                 ws = (struct winsize) {
 476                         .ws_row = lines(),
 477                         .ws_col = columns(),
 478                 };
 479
 480         (void) ioctl(master, TIOCSWINSZ, &ws);
 481
 482         if (!(flags & PTY_FORWARD_READ_ONLY)) {
 483                 assert(f->input_fd >= 0);
 484
 485                 if (tcgetattr(f->input_fd, &f->saved_stdin_attr) >= 0) {
 486                         struct termios raw_stdin_attr;
 487
 488                         f->saved_stdin = true;
 489
 490                         raw_stdin_attr = f->saved_stdin_attr;
 491                         cfmakeraw(&raw_stdin_attr);
 492                         raw_stdin_attr.c_oflag = f->saved_stdin_attr.c_oflag;
 493                         tcsetattr(f->input_fd, TCSANOW, &raw_stdin_attr);
 494                 }
 495
 496                 if (tcgetattr(f->output_fd, &f->saved_stdout_attr) >= 0) {
 497                         struct termios raw_stdout_attr;
 498
 499                         f->saved_stdout = true;
 500
 501                         raw_stdout_attr = f->saved_stdout_attr;
 502                         cfmakeraw(&raw_stdout_attr);
 503                         raw_stdout_attr.c_iflag = f->saved_stdout_attr.c_iflag;
 504                         raw_stdout_attr.c_lflag = f->saved_stdout_attr.c_lflag;
 505                         tcsetattr(f->output_fd, TCSANOW, &raw_stdout_attr);
 506                 }
 507
 508                 r = sd_event_add_io(f->event, &f->stdin_event_source, f->input_fd, EPOLLIN|EPOLLET, on_stdin_event, f);
 509                 if (r < 0 && r != -EPERM)
 510                         return r;
 511
 512                 if (r >= 0)
 513                         (void) sd_event_source_set_description(f->stdin_event_source, "ptyfwd-stdin");
 514         }
 515
 516         r = sd_event_add_io(f->event, &f->stdout_event_source, f->output_fd, EPOLLOUT|EPOLLET, on_stdout_event, f);
 517         if (r == -EPERM)
 518                 /* stdout without epoll support. Likely redirected to regular file. */
 519                 f->stdout_writable = true;
 520         else if (r < 0)
 521                 return r;
 522         else
 523                 (void) sd_event_source_set_description(f->stdout_event_source, "ptyfwd-stdout");
 524
 525         r = sd_event_add_io(f->event, &f->master_event_source, master, EPOLLIN|EPOLLOUT|EPOLLET, on_master_event, f);
 526         if (r < 0)
 527                 return r;
 528
 529         (void) sd_event_source_set_description(f->master_event_source, "ptyfwd-master");
 530
 531         r = sd_event_add_signal(f->event, &f->sigwinch_event_source, SIGWINCH, on_sigwinch_event, f);
 532         if (r < 0)
 533                 return r;
 534
 535         (void) sd_event_source_set_description(f->sigwinch_event_source, "ptyfwd-sigwinch");
 536
 537         *ret = TAKE_PTR(f);
 538
 539         return 0;
 540 }
 541
 542 PTYForward *pty_forward_free(PTYForward *f) {
 543         pty_forward_disconnect(f);
 544         return mfree(f);
 545 }
 546
 547 int pty_forward_get_last_char(PTYForward *f, char *ch) {
 548         assert(f);
 549         assert(ch);
 550
 551         if (!f->last_char_set)
 552                 return -ENXIO;
 553
 554         *ch = f->last_char;
 555         return 0;
 556 }
 557
 558 int pty_forward_set_ignore_vhangup(PTYForward *f, bool b) {
 559         int r;
 560
 561         assert(f);
 562
 563         if (!!(f->flags & PTY_FORWARD_IGNORE_VHANGUP) == b)
 564                 return 0;
 565
 566         SET_FLAG(f->flags, PTY_FORWARD_IGNORE_VHANGUP, b);
 567
 568         if (!ignore_vhangup(f)) {
 569
 570                 /* We shall now react to vhangup()s? Let's check
 571                  * immediately if we might be in one */
 572
 573                 f->master_readable = true;
 574                 r = shovel(f);
 575                 if (r < 0)
 576                         return r;
 577         }
 578
 579         return 0;
 580 }
 581
 582 bool pty_forward_get_ignore_vhangup(PTYForward *f) {
 583         assert(f);
 584
 585         return !!(f->flags & PTY_FORWARD_IGNORE_VHANGUP);
 586 }
 587
 588 bool pty_forward_is_done(PTYForward *f) {
 589         assert(f);
 590
 591         return f->done;
 592 }
 593
 594 void pty_forward_set_handler(PTYForward *f, PTYForwardHandler cb, void *userdata) {
 595         assert(f);
 596
 597         f->handler = cb;
 598         f->userdata = userdata;
 599 }
 600
 601 bool pty_forward_drain(PTYForward *f) {
 602         assert(f);
 603
 604         /* Starts draining the forwarder. Specifically:
 605          *
 606          * - Returns true if there are no unprocessed bytes from the pty, false otherwise
 607          *
 608          * - Makes sure the handler function is called the next time the number of unprocessed bytes hits zero
 609          */
 610
 611         f->drain = true;
 612         return drained(f);
 613 }
 614
 615 int pty_forward_set_priority(PTYForward *f, int64_t priority) {
 616         int r;
 617         assert(f);
 618
 619         if (f->stdin_event_source) {
 620                 r = sd_event_source_set_priority(f->stdin_event_source, priority);
 621                 if (r < 0)
 622                         return r;
 623         }
 624
 625         r = sd_event_source_set_priority(f->stdout_event_source, priority);
 626         if (r < 0)
 627                 return r;
 628
 629         r = sd_event_source_set_priority(f->master_event_source, priority);
 630         if (r < 0)
 631                 return r;
 632
 633         r = sd_event_source_set_priority(f->sigwinch_event_source, priority);
 634         if (r < 0)
 635                 return r;
 636
 637         return 0;
 638 }
 639
 640 int pty_forward_set_width_height(PTYForward *f, unsigned width, unsigned height) {
 641         struct winsize ws;
 642
 643         assert(f);
 644
 645         if (width == UINT_MAX && height == UINT_MAX)
 646                 return 0; /* noop */
 647
 648         if (width != UINT_MAX &&
 649             (width == 0 || width > USHRT_MAX))
 650                 return -ERANGE;
 651
 652         if (height != UINT_MAX &&
 653             (height == 0 || height > USHRT_MAX))
 654                 return -ERANGE;
 655
 656         if (width == UINT_MAX || height == UINT_MAX) {
 657                 if (ioctl(f->master, TIOCGWINSZ, &ws) < 0)
 658                         return -errno;
 659
 660                 if (width != UINT_MAX)
 661                         ws.ws_col = width;
 662                 if (height != UINT_MAX)
 663                         ws.ws_row = height;
 664         } else
 665                 ws = (struct winsize) {
 666                         .ws_row = height,
 667                         .ws_col = width,
 668                 };
 669
 670         if (ioctl(f->master, TIOCSWINSZ, &ws) < 0)
 671                 return -errno;
 672
 673         /* Make sure we ignore SIGWINCH window size events from now on */
 674         f->sigwinch_event_source = sd_event_source_unref(f->sigwinch_event_source);
 675
 676         return 0;
 677 }