1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
11 #include <sys/epoll.h>
12 #include <sys/ioctl.h>
19 #include "alloc-util.h"
20 #include "errno-util.h"
25 #include "stat-util.h"
26 #include "terminal-util.h"
27 #include "time-util.h"
36 PTYForwardFlags flags
;
38 sd_event_source
*stdin_event_source
;
39 sd_event_source
*stdout_event_source
;
40 sd_event_source
*master_event_source
;
42 sd_event_source
*sigwinch_event_source
;
44 struct termios saved_stdin_attr
;
45 struct termios saved_stdout_attr
;
47 bool close_input_fd
:1;
48 bool close_output_fd
:1;
53 bool stdin_readable
:1;
55 bool stdout_writable
:1;
57 bool master_readable
:1;
58 bool master_writable
:1;
61 bool read_from_master
:1;
69 char in_buffer
[LINE_MAX
], out_buffer
[LINE_MAX
];
70 size_t in_buffer_full
, out_buffer_full
;
72 usec_t escape_timestamp
;
73 unsigned escape_counter
;
75 PTYForwardHandler handler
;
79 #define ESCAPE_USEC (1*USEC_PER_SEC)
81 static void pty_forward_disconnect(PTYForward
*f
) {
86 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
87 f
->stdout_event_source
= sd_event_source_unref(f
->stdout_event_source
);
89 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
90 f
->sigwinch_event_source
= sd_event_source_unref(f
->sigwinch_event_source
);
91 f
->event
= sd_event_unref(f
->event
);
93 if (f
->output_fd
>= 0) {
95 (void) tcsetattr(f
->output_fd
, TCSANOW
, &f
->saved_stdout_attr
);
97 /* STDIN/STDOUT should not be non-blocking normally, so let's reset it */
98 (void) fd_nonblock(f
->output_fd
, false);
99 if (f
->close_output_fd
)
100 f
->output_fd
= safe_close(f
->output_fd
);
103 if (f
->input_fd
>= 0) {
105 (void) tcsetattr(f
->input_fd
, TCSANOW
, &f
->saved_stdin_attr
);
107 (void) fd_nonblock(f
->input_fd
, false);
108 if (f
->close_input_fd
)
109 f
->input_fd
= safe_close(f
->input_fd
);
112 f
->saved_stdout
= f
->saved_stdin
= false;
115 static int pty_forward_done(PTYForward
*f
, int rcode
) {
116 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
122 e
= sd_event_ref(f
->event
);
125 pty_forward_disconnect(f
);
128 return f
->handler(f
, rcode
, f
->userdata
);
130 return sd_event_exit(e
, rcode
< 0 ? EXIT_FAILURE
: rcode
);
133 static bool look_for_escape(PTYForward
*f
, const char *buffer
, size_t n
) {
140 for (p
= buffer
; p
< buffer
+ n
; p
++) {
144 usec_t nw
= now(CLOCK_MONOTONIC
);
146 if (f
->escape_counter
== 0 || nw
> f
->escape_timestamp
+ ESCAPE_USEC
) {
147 f
->escape_timestamp
= nw
;
148 f
->escape_counter
= 1;
150 (f
->escape_counter
)++;
152 if (f
->escape_counter
>= 3)
156 f
->escape_timestamp
= 0;
157 f
->escape_counter
= 0;
164 static bool ignore_vhangup(PTYForward
*f
) {
167 if (f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
)
170 if ((f
->flags
& PTY_FORWARD_IGNORE_INITIAL_VHANGUP
) && !f
->read_from_master
)
176 static bool drained(PTYForward
*f
) {
181 if (f
->out_buffer_full
> 0)
184 if (f
->master_readable
)
187 if (ioctl(f
->master
, TIOCINQ
, &q
) < 0)
188 log_debug_errno(errno
, "TIOCINQ failed on master: %m");
192 if (ioctl(f
->master
, TIOCOUTQ
, &q
) < 0)
193 log_debug_errno(errno
, "TIOCOUTQ failed on master: %m");
200 static int shovel(PTYForward
*f
) {
205 while ((f
->stdin_readable
&& f
->in_buffer_full
<= 0) ||
206 (f
->master_writable
&& f
->in_buffer_full
> 0) ||
207 (f
->master_readable
&& f
->out_buffer_full
<= 0) ||
208 (f
->stdout_writable
&& f
->out_buffer_full
> 0)) {
210 if (f
->stdin_readable
&& f
->in_buffer_full
< LINE_MAX
) {
212 k
= read(f
->input_fd
, f
->in_buffer
+ f
->in_buffer_full
, LINE_MAX
- f
->in_buffer_full
);
216 f
->stdin_readable
= false;
217 else if (errno
== EIO
|| ERRNO_IS_DISCONNECT(errno
)) {
218 f
->stdin_readable
= false;
219 f
->stdin_hangup
= true;
221 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
223 log_error_errno(errno
, "read(): %m");
224 return pty_forward_done(f
, -errno
);
228 f
->stdin_readable
= false;
229 f
->stdin_hangup
= true;
231 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
233 /* Check if ^] has been pressed three times within one second. If we get this we quite
235 if (look_for_escape(f
, f
->in_buffer
+ f
->in_buffer_full
, k
))
236 return pty_forward_done(f
, -ECANCELED
);
238 f
->in_buffer_full
+= (size_t) k
;
242 if (f
->master_writable
&& f
->in_buffer_full
> 0) {
244 k
= write(f
->master
, f
->in_buffer
, f
->in_buffer_full
);
247 if (IN_SET(errno
, EAGAIN
, EIO
))
248 f
->master_writable
= false;
249 else if (IN_SET(errno
, EPIPE
, ECONNRESET
)) {
250 f
->master_writable
= f
->master_readable
= false;
251 f
->master_hangup
= true;
253 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
255 log_error_errno(errno
, "write(): %m");
256 return pty_forward_done(f
, -errno
);
259 assert(f
->in_buffer_full
>= (size_t) k
);
260 memmove(f
->in_buffer
, f
->in_buffer
+ k
, f
->in_buffer_full
- k
);
261 f
->in_buffer_full
-= k
;
265 if (f
->master_readable
&& f
->out_buffer_full
< LINE_MAX
) {
267 k
= read(f
->master
, f
->out_buffer
+ f
->out_buffer_full
, LINE_MAX
- f
->out_buffer_full
);
270 /* Note that EIO on the master device might be caused by vhangup() or
271 * temporary closing of everything on the other side, we treat it like EAGAIN
272 * here and try again, unless ignore_vhangup is off. */
274 if (errno
== EAGAIN
|| (errno
== EIO
&& ignore_vhangup(f
)))
275 f
->master_readable
= false;
276 else if (IN_SET(errno
, EPIPE
, ECONNRESET
, EIO
)) {
277 f
->master_readable
= f
->master_writable
= false;
278 f
->master_hangup
= true;
280 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
282 log_error_errno(errno
, "read(): %m");
283 return pty_forward_done(f
, -errno
);
286 f
->read_from_master
= true;
287 f
->out_buffer_full
+= (size_t) k
;
291 if (f
->stdout_writable
&& f
->out_buffer_full
> 0) {
293 k
= write(f
->output_fd
, f
->out_buffer
, f
->out_buffer_full
);
297 f
->stdout_writable
= false;
298 else if (errno
== EIO
|| ERRNO_IS_DISCONNECT(errno
)) {
299 f
->stdout_writable
= false;
300 f
->stdout_hangup
= true;
301 f
->stdout_event_source
= sd_event_source_unref(f
->stdout_event_source
);
303 log_error_errno(errno
, "write(): %m");
304 return pty_forward_done(f
, -errno
);
310 f
->last_char
= f
->out_buffer
[k
-1];
311 f
->last_char_set
= true;
314 assert(f
->out_buffer_full
>= (size_t) k
);
315 memmove(f
->out_buffer
, f
->out_buffer
+ k
, f
->out_buffer_full
- k
);
316 f
->out_buffer_full
-= k
;
321 if (f
->stdin_hangup
|| f
->stdout_hangup
|| f
->master_hangup
) {
322 /* Exit the loop if any side hung up and if there's
323 * nothing more to write or nothing we could write. */
325 if ((f
->out_buffer_full
<= 0 || f
->stdout_hangup
) &&
326 (f
->in_buffer_full
<= 0 || f
->master_hangup
))
327 return pty_forward_done(f
, 0);
330 /* If we were asked to drain, and there's nothing more to handle from the master, then call the callback
332 if (f
->drain
&& drained(f
))
333 return pty_forward_done(f
, 0);
338 static int on_master_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
339 PTYForward
*f
= ASSERT_PTR(userdata
);
342 assert(e
== f
->master_event_source
);
344 assert(fd
== f
->master
);
346 if (revents
& (EPOLLIN
|EPOLLHUP
))
347 f
->master_readable
= true;
349 if (revents
& (EPOLLOUT
|EPOLLHUP
))
350 f
->master_writable
= true;
355 static int on_stdin_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
356 PTYForward
*f
= ASSERT_PTR(userdata
);
359 assert(e
== f
->stdin_event_source
);
361 assert(fd
== f
->input_fd
);
363 if (revents
& (EPOLLIN
|EPOLLHUP
))
364 f
->stdin_readable
= true;
369 static int on_stdout_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
370 PTYForward
*f
= ASSERT_PTR(userdata
);
373 assert(e
== f
->stdout_event_source
);
375 assert(fd
== f
->output_fd
);
377 if (revents
& (EPOLLOUT
|EPOLLHUP
))
378 f
->stdout_writable
= true;
383 static int on_sigwinch_event(sd_event_source
*e
, const struct signalfd_siginfo
*si
, void *userdata
) {
384 PTYForward
*f
= ASSERT_PTR(userdata
);
388 assert(e
== f
->sigwinch_event_source
);
390 /* The window size changed, let's forward that. */
391 if (ioctl(f
->output_fd
, TIOCGWINSZ
, &ws
) >= 0)
392 (void) ioctl(f
->master
, TIOCSWINSZ
, &ws
);
400 PTYForwardFlags flags
,
403 _cleanup_(pty_forward_freep
) PTYForward
*f
= NULL
;
407 f
= new(PTYForward
, 1);
411 *f
= (struct PTYForward
) {
419 f
->event
= sd_event_ref(event
);
421 r
= sd_event_default(&f
->event
);
426 if (FLAGS_SET(flags
, PTY_FORWARD_READ_ONLY
))
427 f
->output_fd
= STDOUT_FILENO
;
429 /* If we shall be invoked in interactive mode, let's switch on non-blocking mode, so that we
430 * never end up staving one direction while we block on the other. However, let's be careful
431 * here and not turn on O_NONBLOCK for stdin/stdout directly, but of re-opened copies of
432 * them. This has two advantages: when we are killed abruptly the stdin/stdout fds won't be
433 * left in O_NONBLOCK state for the next process using them. In addition, if some process
434 * running in the background wants to continue writing to our stdout it can do so without
435 * being confused by O_NONBLOCK. */
437 f
->input_fd
= fd_reopen(STDIN_FILENO
, O_RDONLY
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
);
438 if (f
->input_fd
< 0) {
439 /* Handle failures gracefully, after all certain fd types cannot be reopened
441 log_debug_errno(f
->input_fd
, "Failed to reopen stdin, using original fd: %m");
443 r
= fd_nonblock(STDIN_FILENO
, true);
447 f
->input_fd
= STDIN_FILENO
;
449 f
->close_input_fd
= true;
451 f
->output_fd
= fd_reopen(STDOUT_FILENO
, O_WRONLY
|O_CLOEXEC
|O_NOCTTY
|O_NONBLOCK
);
452 if (f
->output_fd
< 0) {
453 log_debug_errno(f
->output_fd
, "Failed to reopen stdout, using original fd: %m");
455 r
= fd_nonblock(STDOUT_FILENO
, true);
459 f
->output_fd
= STDOUT_FILENO
;
461 f
->close_output_fd
= true;
464 r
= fd_nonblock(master
, true);
470 if (ioctl(f
->output_fd
, TIOCGWINSZ
, &ws
) < 0)
471 /* If we can't get the resolution from the output fd, then use our internal, regular width/height,
472 * i.e. something derived from $COLUMNS and $LINES if set. */
473 ws
= (struct winsize
) {
478 (void) ioctl(master
, TIOCSWINSZ
, &ws
);
480 if (!(flags
& PTY_FORWARD_READ_ONLY
)) {
483 assert(f
->input_fd
>= 0);
485 same
= inode_same_at(f
->input_fd
, NULL
, f
->output_fd
, NULL
, AT_EMPTY_PATH
);
489 if (tcgetattr(f
->input_fd
, &f
->saved_stdin_attr
) >= 0) {
490 struct termios raw_stdin_attr
;
492 f
->saved_stdin
= true;
494 raw_stdin_attr
= f
->saved_stdin_attr
;
495 cfmakeraw(&raw_stdin_attr
);
498 raw_stdin_attr
.c_oflag
= f
->saved_stdin_attr
.c_oflag
;
500 (void) tcsetattr(f
->input_fd
, TCSANOW
, &raw_stdin_attr
);
503 if (!same
&& tcgetattr(f
->output_fd
, &f
->saved_stdout_attr
) >= 0) {
504 struct termios raw_stdout_attr
;
506 f
->saved_stdout
= true;
508 raw_stdout_attr
= f
->saved_stdout_attr
;
509 cfmakeraw(&raw_stdout_attr
);
510 raw_stdout_attr
.c_iflag
= f
->saved_stdout_attr
.c_iflag
;
511 raw_stdout_attr
.c_lflag
= f
->saved_stdout_attr
.c_lflag
;
512 (void) tcsetattr(f
->output_fd
, TCSANOW
, &raw_stdout_attr
);
515 r
= sd_event_add_io(f
->event
, &f
->stdin_event_source
, f
->input_fd
, EPOLLIN
|EPOLLET
, on_stdin_event
, f
);
516 if (r
< 0 && r
!= -EPERM
)
520 (void) sd_event_source_set_description(f
->stdin_event_source
, "ptyfwd-stdin");
523 r
= sd_event_add_io(f
->event
, &f
->stdout_event_source
, f
->output_fd
, EPOLLOUT
|EPOLLET
, on_stdout_event
, f
);
525 /* stdout without epoll support. Likely redirected to regular file. */
526 f
->stdout_writable
= true;
530 (void) sd_event_source_set_description(f
->stdout_event_source
, "ptyfwd-stdout");
532 r
= sd_event_add_io(f
->event
, &f
->master_event_source
, master
, EPOLLIN
|EPOLLOUT
|EPOLLET
, on_master_event
, f
);
536 (void) sd_event_source_set_description(f
->master_event_source
, "ptyfwd-master");
538 r
= sd_event_add_signal(f
->event
, &f
->sigwinch_event_source
, SIGWINCH
, on_sigwinch_event
, f
);
542 (void) sd_event_source_set_description(f
->sigwinch_event_source
, "ptyfwd-sigwinch");
549 PTYForward
*pty_forward_free(PTYForward
*f
) {
550 pty_forward_disconnect(f
);
554 int pty_forward_get_last_char(PTYForward
*f
, char *ch
) {
558 if (!f
->last_char_set
)
565 int pty_forward_set_ignore_vhangup(PTYForward
*f
, bool b
) {
570 if (!!(f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
) == b
)
573 SET_FLAG(f
->flags
, PTY_FORWARD_IGNORE_VHANGUP
, b
);
575 if (!ignore_vhangup(f
)) {
577 /* We shall now react to vhangup()s? Let's check
578 * immediately if we might be in one */
580 f
->master_readable
= true;
589 bool pty_forward_get_ignore_vhangup(PTYForward
*f
) {
592 return !!(f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
);
595 bool pty_forward_is_done(PTYForward
*f
) {
601 void pty_forward_set_handler(PTYForward
*f
, PTYForwardHandler cb
, void *userdata
) {
605 f
->userdata
= userdata
;
608 bool pty_forward_drain(PTYForward
*f
) {
611 /* Starts draining the forwarder. Specifically:
613 * - Returns true if there are no unprocessed bytes from the pty, false otherwise
615 * - Makes sure the handler function is called the next time the number of unprocessed bytes hits zero
622 int pty_forward_set_priority(PTYForward
*f
, int64_t priority
) {
626 if (f
->stdin_event_source
) {
627 r
= sd_event_source_set_priority(f
->stdin_event_source
, priority
);
632 r
= sd_event_source_set_priority(f
->stdout_event_source
, priority
);
636 r
= sd_event_source_set_priority(f
->master_event_source
, priority
);
640 r
= sd_event_source_set_priority(f
->sigwinch_event_source
, priority
);
647 int pty_forward_set_width_height(PTYForward
*f
, unsigned width
, unsigned height
) {
652 if (width
== UINT_MAX
&& height
== UINT_MAX
)
655 if (width
!= UINT_MAX
&&
656 (width
== 0 || width
> USHRT_MAX
))
659 if (height
!= UINT_MAX
&&
660 (height
== 0 || height
> USHRT_MAX
))
663 if (width
== UINT_MAX
|| height
== UINT_MAX
) {
664 if (ioctl(f
->master
, TIOCGWINSZ
, &ws
) < 0)
667 if (width
!= UINT_MAX
)
669 if (height
!= UINT_MAX
)
672 ws
= (struct winsize
) {
677 if (ioctl(f
->master
, TIOCSWINSZ
, &ws
) < 0)
680 /* Make sure we ignore SIGWINCH window size events from now on */
681 f
->sigwinch_event_source
= sd_event_source_unref(f
->sigwinch_event_source
);