2 This file is part of systemd.
4 Copyright 2010-2013 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
27 #include <sys/epoll.h>
28 #include <sys/ioctl.h>
35 #include "alloc-util.h"
40 #include "time-util.h"
47 PTYForwardFlags flags
;
49 sd_event_source
*stdin_event_source
;
50 sd_event_source
*stdout_event_source
;
51 sd_event_source
*master_event_source
;
53 sd_event_source
*sigwinch_event_source
;
55 struct termios saved_stdin_attr
;
56 struct termios saved_stdout_attr
;
61 bool stdin_readable
:1;
63 bool stdout_writable
:1;
65 bool master_readable
:1;
66 bool master_writable
:1;
69 bool read_from_master
:1;
77 char in_buffer
[LINE_MAX
], out_buffer
[LINE_MAX
];
78 size_t in_buffer_full
, out_buffer_full
;
80 usec_t escape_timestamp
;
81 unsigned escape_counter
;
83 PTYForwardHandler handler
;
87 #define ESCAPE_USEC (1*USEC_PER_SEC)
89 static void pty_forward_disconnect(PTYForward
*f
) {
92 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
93 f
->stdout_event_source
= sd_event_source_unref(f
->stdout_event_source
);
95 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
96 f
->sigwinch_event_source
= sd_event_source_unref(f
->sigwinch_event_source
);
97 f
->event
= sd_event_unref(f
->event
);
100 tcsetattr(STDOUT_FILENO
, TCSANOW
, &f
->saved_stdout_attr
);
102 tcsetattr(STDIN_FILENO
, TCSANOW
, &f
->saved_stdin_attr
);
104 f
->saved_stdout
= f
->saved_stdin
= false;
107 /* STDIN/STDOUT should not be nonblocking normally, so let's unconditionally reset it */
108 fd_nonblock(STDIN_FILENO
, false);
109 fd_nonblock(STDOUT_FILENO
, false);
112 static int pty_forward_done(PTYForward
*f
, int rcode
) {
113 _cleanup_(sd_event_unrefp
) sd_event
*e
= NULL
;
119 e
= sd_event_ref(f
->event
);
122 pty_forward_disconnect(f
);
125 return f
->handler(f
, rcode
, f
->userdata
);
127 return sd_event_exit(e
, rcode
< 0 ? EXIT_FAILURE
: rcode
);
130 static bool look_for_escape(PTYForward
*f
, const char *buffer
, size_t n
) {
137 for (p
= buffer
; p
< buffer
+ n
; p
++) {
141 usec_t nw
= now(CLOCK_MONOTONIC
);
143 if (f
->escape_counter
== 0 || nw
> f
->escape_timestamp
+ ESCAPE_USEC
) {
144 f
->escape_timestamp
= nw
;
145 f
->escape_counter
= 1;
147 (f
->escape_counter
)++;
149 if (f
->escape_counter
>= 3)
153 f
->escape_timestamp
= 0;
154 f
->escape_counter
= 0;
161 static bool ignore_vhangup(PTYForward
*f
) {
164 if (f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
)
167 if ((f
->flags
& PTY_FORWARD_IGNORE_INITIAL_VHANGUP
) && !f
->read_from_master
)
173 static int shovel(PTYForward
*f
) {
178 while ((f
->stdin_readable
&& f
->in_buffer_full
<= 0) ||
179 (f
->master_writable
&& f
->in_buffer_full
> 0) ||
180 (f
->master_readable
&& f
->out_buffer_full
<= 0) ||
181 (f
->stdout_writable
&& f
->out_buffer_full
> 0)) {
183 if (f
->stdin_readable
&& f
->in_buffer_full
< LINE_MAX
) {
185 k
= read(STDIN_FILENO
, f
->in_buffer
+ f
->in_buffer_full
, LINE_MAX
- f
->in_buffer_full
);
189 f
->stdin_readable
= false;
190 else if (IN_SET(errno
, EIO
, EPIPE
, ECONNRESET
)) {
191 f
->stdin_readable
= false;
192 f
->stdin_hangup
= true;
194 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
196 log_error_errno(errno
, "read(): %m");
197 return pty_forward_done(f
, -errno
);
201 f
->stdin_readable
= false;
202 f
->stdin_hangup
= true;
204 f
->stdin_event_source
= sd_event_source_unref(f
->stdin_event_source
);
206 /* Check if ^] has been pressed three times within one second. If we get this we quite
208 if (look_for_escape(f
, f
->in_buffer
+ f
->in_buffer_full
, k
))
209 return pty_forward_done(f
, -ECANCELED
);
211 f
->in_buffer_full
+= (size_t) k
;
215 if (f
->master_writable
&& f
->in_buffer_full
> 0) {
217 k
= write(f
->master
, f
->in_buffer
, f
->in_buffer_full
);
220 if (IN_SET(errno
, EAGAIN
, EIO
))
221 f
->master_writable
= false;
222 else if (IN_SET(errno
, EPIPE
, ECONNRESET
)) {
223 f
->master_writable
= f
->master_readable
= false;
224 f
->master_hangup
= true;
226 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
228 log_error_errno(errno
, "write(): %m");
229 return pty_forward_done(f
, -errno
);
232 assert(f
->in_buffer_full
>= (size_t) k
);
233 memmove(f
->in_buffer
, f
->in_buffer
+ k
, f
->in_buffer_full
- k
);
234 f
->in_buffer_full
-= k
;
238 if (f
->master_readable
&& f
->out_buffer_full
< LINE_MAX
) {
240 k
= read(f
->master
, f
->out_buffer
+ f
->out_buffer_full
, LINE_MAX
- f
->out_buffer_full
);
243 /* Note that EIO on the master device
244 * might be caused by vhangup() or
245 * temporary closing of everything on
246 * the other side, we treat it like
247 * EAGAIN here and try again, unless
248 * ignore_vhangup is off. */
250 if (errno
== EAGAIN
|| (errno
== EIO
&& ignore_vhangup(f
)))
251 f
->master_readable
= false;
252 else if (IN_SET(errno
, EPIPE
, ECONNRESET
, EIO
)) {
253 f
->master_readable
= f
->master_writable
= false;
254 f
->master_hangup
= true;
256 f
->master_event_source
= sd_event_source_unref(f
->master_event_source
);
258 log_error_errno(errno
, "read(): %m");
259 return pty_forward_done(f
, -errno
);
262 f
->read_from_master
= true;
263 f
->out_buffer_full
+= (size_t) k
;
267 if (f
->stdout_writable
&& f
->out_buffer_full
> 0) {
269 k
= write(STDOUT_FILENO
, f
->out_buffer
, f
->out_buffer_full
);
273 f
->stdout_writable
= false;
274 else if (IN_SET(errno
, EIO
, EPIPE
, ECONNRESET
)) {
275 f
->stdout_writable
= false;
276 f
->stdout_hangup
= true;
277 f
->stdout_event_source
= sd_event_source_unref(f
->stdout_event_source
);
279 log_error_errno(errno
, "write(): %m");
280 return pty_forward_done(f
, -errno
);
286 f
->last_char
= f
->out_buffer
[k
-1];
287 f
->last_char_set
= true;
290 assert(f
->out_buffer_full
>= (size_t) k
);
291 memmove(f
->out_buffer
, f
->out_buffer
+ k
, f
->out_buffer_full
- k
);
292 f
->out_buffer_full
-= k
;
297 if (f
->stdin_hangup
|| f
->stdout_hangup
|| f
->master_hangup
) {
298 /* Exit the loop if any side hung up and if there's
299 * nothing more to write or nothing we could write. */
301 if ((f
->out_buffer_full
<= 0 || f
->stdout_hangup
) &&
302 (f
->in_buffer_full
<= 0 || f
->master_hangup
))
303 return pty_forward_done(f
, 0);
306 /* If we were asked to drain, and there's nothing more to handle from the master, then call the callback
308 if (f
->drain
&& f
->out_buffer_full
== 0 && !f
->master_readable
)
309 return pty_forward_done(f
, 0);
314 static int on_master_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
315 PTYForward
*f
= userdata
;
319 assert(e
== f
->master_event_source
);
321 assert(fd
== f
->master
);
323 if (revents
& (EPOLLIN
|EPOLLHUP
))
324 f
->master_readable
= true;
326 if (revents
& (EPOLLOUT
|EPOLLHUP
))
327 f
->master_writable
= true;
332 static int on_stdin_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
333 PTYForward
*f
= userdata
;
337 assert(e
== f
->stdin_event_source
);
339 assert(fd
== STDIN_FILENO
);
341 if (revents
& (EPOLLIN
|EPOLLHUP
))
342 f
->stdin_readable
= true;
347 static int on_stdout_event(sd_event_source
*e
, int fd
, uint32_t revents
, void *userdata
) {
348 PTYForward
*f
= userdata
;
352 assert(e
== f
->stdout_event_source
);
354 assert(fd
== STDOUT_FILENO
);
356 if (revents
& (EPOLLOUT
|EPOLLHUP
))
357 f
->stdout_writable
= true;
362 static int on_sigwinch_event(sd_event_source
*e
, const struct signalfd_siginfo
*si
, void *userdata
) {
363 PTYForward
*f
= userdata
;
368 assert(e
== f
->sigwinch_event_source
);
370 /* The window size changed, let's forward that. */
371 if (ioctl(STDOUT_FILENO
, TIOCGWINSZ
, &ws
) >= 0)
372 (void) ioctl(f
->master
, TIOCSWINSZ
, &ws
);
380 PTYForwardFlags flags
,
383 _cleanup_(pty_forward_freep
) PTYForward
*f
= NULL
;
387 f
= new0(PTYForward
, 1);
394 f
->event
= sd_event_ref(event
);
396 r
= sd_event_default(&f
->event
);
401 if (!(flags
& PTY_FORWARD_READ_ONLY
)) {
402 r
= fd_nonblock(STDIN_FILENO
, true);
406 r
= fd_nonblock(STDOUT_FILENO
, true);
411 r
= fd_nonblock(master
, true);
417 if (ioctl(STDOUT_FILENO
, TIOCGWINSZ
, &ws
) >= 0)
418 (void) ioctl(master
, TIOCSWINSZ
, &ws
);
420 if (!(flags
& PTY_FORWARD_READ_ONLY
)) {
421 if (tcgetattr(STDIN_FILENO
, &f
->saved_stdin_attr
) >= 0) {
422 struct termios raw_stdin_attr
;
424 f
->saved_stdin
= true;
426 raw_stdin_attr
= f
->saved_stdin_attr
;
427 cfmakeraw(&raw_stdin_attr
);
428 raw_stdin_attr
.c_oflag
= f
->saved_stdin_attr
.c_oflag
;
429 tcsetattr(STDIN_FILENO
, TCSANOW
, &raw_stdin_attr
);
432 if (tcgetattr(STDOUT_FILENO
, &f
->saved_stdout_attr
) >= 0) {
433 struct termios raw_stdout_attr
;
435 f
->saved_stdout
= true;
437 raw_stdout_attr
= f
->saved_stdout_attr
;
438 cfmakeraw(&raw_stdout_attr
);
439 raw_stdout_attr
.c_iflag
= f
->saved_stdout_attr
.c_iflag
;
440 raw_stdout_attr
.c_lflag
= f
->saved_stdout_attr
.c_lflag
;
441 tcsetattr(STDOUT_FILENO
, TCSANOW
, &raw_stdout_attr
);
444 r
= sd_event_add_io(f
->event
, &f
->stdin_event_source
, STDIN_FILENO
, EPOLLIN
|EPOLLET
, on_stdin_event
, f
);
445 if (r
< 0 && r
!= -EPERM
)
449 (void) sd_event_source_set_description(f
->stdin_event_source
, "ptyfwd-stdin");
452 r
= sd_event_add_io(f
->event
, &f
->stdout_event_source
, STDOUT_FILENO
, EPOLLOUT
|EPOLLET
, on_stdout_event
, f
);
454 /* stdout without epoll support. Likely redirected to regular file. */
455 f
->stdout_writable
= true;
459 (void) sd_event_source_set_description(f
->stdout_event_source
, "ptyfwd-stdout");
461 r
= sd_event_add_io(f
->event
, &f
->master_event_source
, master
, EPOLLIN
|EPOLLOUT
|EPOLLET
, on_master_event
, f
);
465 (void) sd_event_source_set_description(f
->master_event_source
, "ptyfwd-master");
467 r
= sd_event_add_signal(f
->event
, &f
->sigwinch_event_source
, SIGWINCH
, on_sigwinch_event
, f
);
471 (void) sd_event_source_set_description(f
->sigwinch_event_source
, "ptyfwd-sigwinch");
479 PTYForward
*pty_forward_free(PTYForward
*f
) {
480 pty_forward_disconnect(f
);
484 int pty_forward_get_last_char(PTYForward
*f
, char *ch
) {
488 if (!f
->last_char_set
)
495 int pty_forward_set_ignore_vhangup(PTYForward
*f
, bool b
) {
500 if (!!(f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
) == b
)
503 SET_FLAG(f
->flags
, PTY_FORWARD_IGNORE_VHANGUP
, b
);
505 if (!ignore_vhangup(f
)) {
507 /* We shall now react to vhangup()s? Let's check
508 * immediately if we might be in one */
510 f
->master_readable
= true;
519 bool pty_forward_get_ignore_vhangup(PTYForward
*f
) {
522 return !!(f
->flags
& PTY_FORWARD_IGNORE_VHANGUP
);
525 bool pty_forward_is_done(PTYForward
*f
) {
531 void pty_forward_set_handler(PTYForward
*f
, PTYForwardHandler cb
, void *userdata
) {
535 f
->userdata
= userdata
;
538 bool pty_forward_drain(PTYForward
*f
) {
541 /* Starts draining the forwarder. Specifically:
543 * - Returns true if there are no unprocessed bytes from the pty, false otherwise
545 * - Makes sure the handler function is called the next time the number of unprocessed bytes hits zero
550 return f
->out_buffer_full
== 0 && !f
->master_readable
;