src/shared/ptyfwd.c

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