1 /* SPDX-License-Identifier: LGPL-2.1+ */
10 #include <sys/epoll.h>
11 #include <sys/ioctl.h>
18 #include "alloc-util.h"
23 #include "terminal-util.h"
24 #include "time-util.h"
31 PTYForwardFlags flags
;
33 sd_event_source
*stdin_event_source
;
34 sd_event_source
*stdout_event_source
;
35 sd_event_source
*master_event_source
;
37 sd_event_source
*sigwinch_event_source
;
39 struct termios saved_stdin_attr
;
40 struct termios saved_stdout_attr
;
45 bool stdin_readable
:1;
47 bool stdout_writable
:1;
49 bool master_readable
:1;
50 bool master_writable
:1;
53 bool read_from_master
:1;
61 char in_buffer
[LINE_MAX
], out_buffer
[LINE_MAX
];
62 size_t in_buffer_full
, out_buffer_full
;
64 usec_t escape_timestamp
;
65 unsigned escape_counter
;
67 PTYForwardHandler handler
;
71 #define ESCAPE_USEC (1*USEC_PER_SEC)
73 static void pty_forward_disconnect(PTYForward
*f
) {
76 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
77 f
->stdout_event_source
= sd_event_source_unref(f
->stdout_event_source
);
79 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
80 f
->sigwinch_event_source
= sd_event_source_unref(f
->sigwinch_event_source
);
81 f
->event
= sd_event_unref(f
->event
);
84 tcsetattr(STDOUT_FILENO
, TCSANOW
, &f
->saved_stdout_attr
);
86 tcsetattr(STDIN_FILENO
, TCSANOW
, &f
->saved_stdin_attr
);
88 f
->saved_stdout
= f
->saved_stdin
= false;
91 /* STDIN/STDOUT should not be nonblocking normally, so let's unconditionally reset it */
92 (void) fd_nonblock(STDIN_FILENO
, false);
93 (void) fd_nonblock(STDOUT_FILENO
, false);
96 static int pty_forward_done(PTYForward
*f
, int rcode
) {
97 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
103 e
= sd_event_ref(f
->event
);
106 pty_forward_disconnect(f
);
109 return f
->handler(f
, rcode
, f
->userdata
);
111 return sd_event_exit(e
, rcode
< 0 ? EXIT_FAILURE
: rcode
);
114 static bool look_for_escape(PTYForward
*f
, const char *buffer
, size_t n
) {
121 for (p
= buffer
; p
< buffer
+ n
; p
++) {
125 usec_t nw
= now(CLOCK_MONOTONIC
);
127 if (f
->escape_counter
== 0 || nw
> f
->escape_timestamp
+ ESCAPE_USEC
) {
128 f
->escape_timestamp
= nw
;
129 f
->escape_counter
= 1;
131 (f
->escape_counter
)++;
133 if (f
->escape_counter
>= 3)
137 f
->escape_timestamp
= 0;
138 f
->escape_counter
= 0;
145 static bool ignore_vhangup(PTYForward
*f
) {
148 if (f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
)
151 if ((f
->flags
& PTY_FORWARD_IGNORE_INITIAL_VHANGUP
) && !f
->read_from_master
)
157 static bool drained(PTYForward
*f
) {
162 if (f
->out_buffer_full
> 0)
165 if (f
->master_readable
)
168 if (ioctl(f
->master
, TIOCINQ
, &q
) < 0)
169 log_debug_errno(errno
, "TIOCINQ failed on master: %m");
173 if (ioctl(f
->master
, TIOCOUTQ
, &q
) < 0)
174 log_debug_errno(errno
, "TIOCOUTQ failed on master: %m");
181 static int shovel(PTYForward
*f
) {
186 while ((f
->stdin_readable
&& f
->in_buffer_full
<= 0) ||
187 (f
->master_writable
&& f
->in_buffer_full
> 0) ||
188 (f
->master_readable
&& f
->out_buffer_full
<= 0) ||
189 (f
->stdout_writable
&& f
->out_buffer_full
> 0)) {
191 if (f
->stdin_readable
&& f
->in_buffer_full
< LINE_MAX
) {
193 k
= read(STDIN_FILENO
, f
->in_buffer
+ f
->in_buffer_full
, LINE_MAX
- f
->in_buffer_full
);
197 f
->stdin_readable
= false;
198 else if (IN_SET(errno
, EIO
, EPIPE
, ECONNRESET
)) {
199 f
->stdin_readable
= false;
200 f
->stdin_hangup
= true;
202 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
204 log_error_errno(errno
, "read(): %m");
205 return pty_forward_done(f
, -errno
);
209 f
->stdin_readable
= false;
210 f
->stdin_hangup
= true;
212 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
214 /* Check if ^] has been pressed three times within one second. If we get this we quite
216 if (look_for_escape(f
, f
->in_buffer
+ f
->in_buffer_full
, k
))
217 return pty_forward_done(f
, -ECANCELED
);
219 f
->in_buffer_full
+= (size_t) k
;
223 if (f
->master_writable
&& f
->in_buffer_full
> 0) {
225 k
= write(f
->master
, f
->in_buffer
, f
->in_buffer_full
);
228 if (IN_SET(errno
, EAGAIN
, EIO
))
229 f
->master_writable
= false;
230 else if (IN_SET(errno
, EPIPE
, ECONNRESET
)) {
231 f
->master_writable
= f
->master_readable
= false;
232 f
->master_hangup
= true;
234 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
236 log_error_errno(errno
, "write(): %m");
237 return pty_forward_done(f
, -errno
);
240 assert(f
->in_buffer_full
>= (size_t) k
);
241 memmove(f
->in_buffer
, f
->in_buffer
+ k
, f
->in_buffer_full
- k
);
242 f
->in_buffer_full
-= k
;
246 if (f
->master_readable
&& f
->out_buffer_full
< LINE_MAX
) {
248 k
= read(f
->master
, f
->out_buffer
+ f
->out_buffer_full
, LINE_MAX
- f
->out_buffer_full
);
251 /* Note that EIO on the master device
252 * might be caused by vhangup() or
253 * temporary closing of everything on
254 * the other side, we treat it like
255 * EAGAIN here and try again, unless
256 * ignore_vhangup is off. */
258 if (errno
== EAGAIN
|| (errno
== EIO
&& ignore_vhangup(f
)))
259 f
->master_readable
= false;
260 else if (IN_SET(errno
, EPIPE
, ECONNRESET
, EIO
)) {
261 f
->master_readable
= f
->master_writable
= false;
262 f
->master_hangup
= true;
264 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
266 log_error_errno(errno
, "read(): %m");
267 return pty_forward_done(f
, -errno
);
270 f
->read_from_master
= true;
271 f
->out_buffer_full
+= (size_t) k
;
275 if (f
->stdout_writable
&& f
->out_buffer_full
> 0) {
277 k
= write(STDOUT_FILENO
, f
->out_buffer
, f
->out_buffer_full
);
281 f
->stdout_writable
= false;
282 else if (IN_SET(errno
, EIO
, EPIPE
, ECONNRESET
)) {
283 f
->stdout_writable
= false;
284 f
->stdout_hangup
= true;
285 f
->stdout_event_source
= sd_event_source_unref(f
->stdout_event_source
);
287 log_error_errno(errno
, "write(): %m");
288 return pty_forward_done(f
, -errno
);
294 f
->last_char
= f
->out_buffer
[k
-1];
295 f
->last_char_set
= true;
298 assert(f
->out_buffer_full
>= (size_t) k
);
299 memmove(f
->out_buffer
, f
->out_buffer
+ k
, f
->out_buffer_full
- k
);
300 f
->out_buffer_full
-= k
;
305 if (f
->stdin_hangup
|| f
->stdout_hangup
|| f
->master_hangup
) {
306 /* Exit the loop if any side hung up and if there's
307 * nothing more to write or nothing we could write. */
309 if ((f
->out_buffer_full
<= 0 || f
->stdout_hangup
) &&
310 (f
->in_buffer_full
<= 0 || f
->master_hangup
))
311 return pty_forward_done(f
, 0);
314 /* If we were asked to drain, and there's nothing more to handle from the master, then call the callback
316 if (f
->drain
&& drained(f
))
317 return pty_forward_done(f
, 0);
322 static int on_master_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
323 PTYForward
*f
= userdata
;
327 assert(e
== f
->master_event_source
);
329 assert(fd
== f
->master
);
331 if (revents
& (EPOLLIN
|EPOLLHUP
))
332 f
->master_readable
= true;
334 if (revents
& (EPOLLOUT
|EPOLLHUP
))
335 f
->master_writable
= true;
340 static int on_stdin_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
341 PTYForward
*f
= userdata
;
345 assert(e
== f
->stdin_event_source
);
347 assert(fd
== STDIN_FILENO
);
349 if (revents
& (EPOLLIN
|EPOLLHUP
))
350 f
->stdin_readable
= true;
355 static int on_stdout_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
356 PTYForward
*f
= userdata
;
360 assert(e
== f
->stdout_event_source
);
362 assert(fd
== STDOUT_FILENO
);
364 if (revents
& (EPOLLOUT
|EPOLLHUP
))
365 f
->stdout_writable
= true;
370 static int on_sigwinch_event(sd_event_source
*e
, const struct signalfd_siginfo
*si
, void *userdata
) {
371 PTYForward
*f
= userdata
;
376 assert(e
== f
->sigwinch_event_source
);
378 /* The window size changed, let's forward that. */
379 if (ioctl(STDOUT_FILENO
, TIOCGWINSZ
, &ws
) >= 0)
380 (void) ioctl(f
->master
, TIOCSWINSZ
, &ws
);
388 PTYForwardFlags flags
,
391 _cleanup_(pty_forward_freep
) PTYForward
*f
= NULL
;
395 f
= new(PTYForward
, 1);
399 *f
= (struct PTYForward
) {
405 f
->event
= sd_event_ref(event
);
407 r
= sd_event_default(&f
->event
);
412 if (!(flags
& PTY_FORWARD_READ_ONLY
)) {
413 r
= fd_nonblock(STDIN_FILENO
, true);
417 r
= fd_nonblock(STDOUT_FILENO
, true);
422 r
= fd_nonblock(master
, true);
428 if (ioctl(STDOUT_FILENO
, TIOCGWINSZ
, &ws
) < 0) {
429 /* If we can't get the resolution from the output fd, then use our internal, regular width/height,
430 * i.e. something derived from $COLUMNS and $LINES if set. */
432 ws
= (struct winsize
) {
438 (void) ioctl(master
, TIOCSWINSZ
, &ws
);
440 if (!(flags
& PTY_FORWARD_READ_ONLY
)) {
441 if (tcgetattr(STDIN_FILENO
, &f
->saved_stdin_attr
) >= 0) {
442 struct termios raw_stdin_attr
;
444 f
->saved_stdin
= true;
446 raw_stdin_attr
= f
->saved_stdin_attr
;
447 cfmakeraw(&raw_stdin_attr
);
448 raw_stdin_attr
.c_oflag
= f
->saved_stdin_attr
.c_oflag
;
449 tcsetattr(STDIN_FILENO
, TCSANOW
, &raw_stdin_attr
);
452 if (tcgetattr(STDOUT_FILENO
, &f
->saved_stdout_attr
) >= 0) {
453 struct termios raw_stdout_attr
;
455 f
->saved_stdout
= true;
457 raw_stdout_attr
= f
->saved_stdout_attr
;
458 cfmakeraw(&raw_stdout_attr
);
459 raw_stdout_attr
.c_iflag
= f
->saved_stdout_attr
.c_iflag
;
460 raw_stdout_attr
.c_lflag
= f
->saved_stdout_attr
.c_lflag
;
461 tcsetattr(STDOUT_FILENO
, TCSANOW
, &raw_stdout_attr
);
464 r
= sd_event_add_io(f
->event
, &f
->stdin_event_source
, STDIN_FILENO
, EPOLLIN
|EPOLLET
, on_stdin_event
, f
);
465 if (r
< 0 && r
!= -EPERM
)
469 (void) sd_event_source_set_description(f
->stdin_event_source
, "ptyfwd-stdin");
472 r
= sd_event_add_io(f
->event
, &f
->stdout_event_source
, STDOUT_FILENO
, EPOLLOUT
|EPOLLET
, on_stdout_event
, f
);
474 /* stdout without epoll support. Likely redirected to regular file. */
475 f
->stdout_writable
= true;
479 (void) sd_event_source_set_description(f
->stdout_event_source
, "ptyfwd-stdout");
481 r
= sd_event_add_io(f
->event
, &f
->master_event_source
, master
, EPOLLIN
|EPOLLOUT
|EPOLLET
, on_master_event
, f
);
485 (void) sd_event_source_set_description(f
->master_event_source
, "ptyfwd-master");
487 r
= sd_event_add_signal(f
->event
, &f
->sigwinch_event_source
, SIGWINCH
, on_sigwinch_event
, f
);
491 (void) sd_event_source_set_description(f
->sigwinch_event_source
, "ptyfwd-sigwinch");
498 PTYForward
*pty_forward_free(PTYForward
*f
) {
499 pty_forward_disconnect(f
);
503 int pty_forward_get_last_char(PTYForward
*f
, char *ch
) {
507 if (!f
->last_char_set
)
514 int pty_forward_set_ignore_vhangup(PTYForward
*f
, bool b
) {
519 if (!!(f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
) == b
)
522 SET_FLAG(f
->flags
, PTY_FORWARD_IGNORE_VHANGUP
, b
);
524 if (!ignore_vhangup(f
)) {
526 /* We shall now react to vhangup()s? Let's check
527 * immediately if we might be in one */
529 f
->master_readable
= true;
538 bool pty_forward_get_ignore_vhangup(PTYForward
*f
) {
541 return !!(f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
);
544 bool pty_forward_is_done(PTYForward
*f
) {
550 void pty_forward_set_handler(PTYForward
*f
, PTYForwardHandler cb
, void *userdata
) {
554 f
->userdata
= userdata
;
557 bool pty_forward_drain(PTYForward
*f
) {
560 /* Starts draining the forwarder. Specifically:
562 * - Returns true if there are no unprocessed bytes from the pty, false otherwise
564 * - Makes sure the handler function is called the next time the number of unprocessed bytes hits zero
571 int pty_forward_set_priority(PTYForward
*f
, int64_t priority
) {
575 r
= sd_event_source_set_priority(f
->stdin_event_source
, priority
);
579 r
= sd_event_source_set_priority(f
->stdout_event_source
, priority
);
583 r
= sd_event_source_set_priority(f
->master_event_source
, priority
);
587 r
= sd_event_source_set_priority(f
->sigwinch_event_source
, priority
);
594 int pty_forward_set_width_height(PTYForward
*f
, unsigned width
, unsigned height
) {
599 if (width
== (unsigned) -1 && height
== (unsigned) -1)
602 if (width
!= (unsigned) -1 &&
603 (width
== 0 || width
> USHRT_MAX
))
606 if (height
!= (unsigned) -1 &&
607 (height
== 0 || height
> USHRT_MAX
))
610 if (width
== (unsigned) -1 || height
== (unsigned) -1) {
611 if (ioctl(f
->master
, TIOCGWINSZ
, &ws
) < 0)
614 if (width
!= (unsigned) -1)
616 if (height
!= (unsigned) -1)
619 ws
= (struct winsize
) {
624 if (ioctl(f
->master
, TIOCSWINSZ
, &ws
) < 0)
627 /* Make sure we ignore SIGWINCH window size events from now on */
628 f
->sigwinch_event_source
= sd_event_source_unref(f
->sigwinch_event_source
);