1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
28 #include <sys/inotify.h>
29 #include <sys/socket.h>
30 #include <sys/sysmacros.h>
33 #include <linux/tiocl.h>
37 #include <sys/ioctl.h>
38 #include <sys/types.h>
42 #include "alloc-util.h"
50 #include "parse-util.h"
51 #include "process-util.h"
52 #include "socket-util.h"
53 #include "stat-util.h"
54 #include "string-util.h"
56 #include "terminal-util.h"
57 #include "time-util.h"
59 #include "path-util.h"
61 static volatile unsigned cached_columns
= 0;
62 static volatile unsigned cached_lines
= 0;
65 _cleanup_close_
int fd
;
67 fd
= open_terminal("/dev/tty0", O_RDWR
|O_NOCTTY
|O_CLOEXEC
|O_NONBLOCK
);
73 TIOCL_GETKMSGREDIRECT
,
77 if (ioctl(fd
, TIOCLINUX
, tiocl
) < 0)
80 vt
= tiocl
[0] <= 0 ? 1 : tiocl
[0];
83 if (ioctl(fd
, VT_ACTIVATE
, vt
) < 0)
89 int read_one_char(FILE *f
, char *ret
, usec_t t
, bool *need_nl
) {
90 struct termios old_termios
, new_termios
;
91 char c
, line
[LINE_MAX
];
96 if (tcgetattr(fileno(f
), &old_termios
) >= 0) {
97 new_termios
= old_termios
;
99 new_termios
.c_lflag
&= ~ICANON
;
100 new_termios
.c_cc
[VMIN
] = 1;
101 new_termios
.c_cc
[VTIME
] = 0;
103 if (tcsetattr(fileno(f
), TCSADRAIN
, &new_termios
) >= 0) {
106 if (t
!= USEC_INFINITY
) {
107 if (fd_wait_for_event(fileno(f
), POLLIN
, t
) <= 0) {
108 tcsetattr(fileno(f
), TCSADRAIN
, &old_termios
);
113 k
= fread(&c
, 1, 1, f
);
115 tcsetattr(fileno(f
), TCSADRAIN
, &old_termios
);
121 *need_nl
= c
!= '\n';
128 if (t
!= USEC_INFINITY
) {
129 if (fd_wait_for_event(fileno(f
), POLLIN
, t
) <= 0)
134 if (!fgets(line
, sizeof(line
), f
))
135 return errno
> 0 ? -errno
: -EIO
;
139 if (strlen(line
) != 1)
149 #define DEFAULT_ASK_REFRESH_USEC (2*USEC_PER_SEC)
151 int ask_char(char *ret
, const char *replies
, const char *fmt
, ...) {
163 if (colors_enabled())
164 fputs(ANSI_HIGHLIGHT
, stdout
);
172 if (colors_enabled())
173 fputs(ANSI_NORMAL
, stdout
);
177 r
= read_one_char(stdin
, &c
, DEFAULT_ASK_REFRESH_USEC
, &need_nl
);
184 puts("Bad input, please try again.");
195 if (strchr(replies
, c
)) {
200 puts("Read unexpected character, please try again.");
204 int ask_string(char **ret
, const char *text
, ...) {
212 if (colors_enabled())
213 fputs(ANSI_HIGHLIGHT
, stdout
);
219 if (colors_enabled())
220 fputs(ANSI_NORMAL
, stdout
);
225 if (!fgets(line
, sizeof(line
), stdin
))
226 return errno
> 0 ? -errno
: -EIO
;
228 if (!endswith(line
, "\n"))
247 int reset_terminal_fd(int fd
, bool switch_to_text
) {
248 struct termios termios
;
251 /* Set terminal to some sane defaults */
255 /* We leave locked terminal attributes untouched, so that
256 * Plymouth may set whatever it wants to set, and we don't
257 * interfere with that. */
259 /* Disable exclusive mode, just in case */
260 (void) ioctl(fd
, TIOCNXCL
);
262 /* Switch to text mode */
264 (void) ioctl(fd
, KDSETMODE
, KD_TEXT
);
266 /* Set default keyboard mode */
267 (void) vt_reset_keyboard(fd
);
269 if (tcgetattr(fd
, &termios
) < 0) {
274 /* We only reset the stuff that matters to the software. How
275 * hardware is set up we don't touch assuming that somebody
276 * else will do that for us */
278 termios
.c_iflag
&= ~(IGNBRK
| BRKINT
| ISTRIP
| INLCR
| IGNCR
| IUCLC
);
279 termios
.c_iflag
|= ICRNL
| IMAXBEL
| IUTF8
;
280 termios
.c_oflag
|= ONLCR
;
281 termios
.c_cflag
|= CREAD
;
282 termios
.c_lflag
= ISIG
| ICANON
| IEXTEN
| ECHO
| ECHOE
| ECHOK
| ECHOCTL
| ECHOPRT
| ECHOKE
;
284 termios
.c_cc
[VINTR
] = 03; /* ^C */
285 termios
.c_cc
[VQUIT
] = 034; /* ^\ */
286 termios
.c_cc
[VERASE
] = 0177;
287 termios
.c_cc
[VKILL
] = 025; /* ^X */
288 termios
.c_cc
[VEOF
] = 04; /* ^D */
289 termios
.c_cc
[VSTART
] = 021; /* ^Q */
290 termios
.c_cc
[VSTOP
] = 023; /* ^S */
291 termios
.c_cc
[VSUSP
] = 032; /* ^Z */
292 termios
.c_cc
[VLNEXT
] = 026; /* ^V */
293 termios
.c_cc
[VWERASE
] = 027; /* ^W */
294 termios
.c_cc
[VREPRINT
] = 022; /* ^R */
295 termios
.c_cc
[VEOL
] = 0;
296 termios
.c_cc
[VEOL2
] = 0;
298 termios
.c_cc
[VTIME
] = 0;
299 termios
.c_cc
[VMIN
] = 1;
301 if (tcsetattr(fd
, TCSANOW
, &termios
) < 0)
305 /* Just in case, flush all crap out */
306 (void) tcflush(fd
, TCIOFLUSH
);
311 int reset_terminal(const char *name
) {
312 _cleanup_close_
int fd
= -1;
314 /* We open the terminal with O_NONBLOCK here, to ensure we
315 * don't block on carrier if this is a terminal with carrier
318 fd
= open_terminal(name
, O_RDWR
|O_NOCTTY
|O_CLOEXEC
|O_NONBLOCK
);
322 return reset_terminal_fd(fd
, true);
325 int open_terminal(const char *name
, int mode
) {
330 * If a TTY is in the process of being closed opening it might
331 * cause EIO. This is horribly awful, but unlikely to be
332 * changed in the kernel. Hence we work around this problem by
333 * retrying a couple of times.
335 * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
342 fd
= open(name
, mode
, 0);
349 /* Max 1s in total */
353 usleep(50 * USEC_PER_MSEC
);
366 int acquire_terminal(
370 bool ignore_tiocstty_eperm
,
373 int fd
= -1, notify
= -1, r
= 0, wd
= -1;
378 /* We use inotify to be notified when the tty is closed. We
379 * create the watch before checking if we can actually acquire
380 * it, so that we don't lose any event.
382 * Note: strictly speaking this actually watches for the
383 * device being closed, it does *not* really watch whether a
384 * tty loses its controlling process. However, unless some
385 * rogue process uses TIOCNOTTY on /dev/tty *after* closing
386 * its tty otherwise this will not become a problem. As long
387 * as the administrator makes sure not configure any service
388 * on the same tty as an untrusted user this should not be a
389 * problem. (Which he probably should not do anyway.) */
391 if (timeout
!= USEC_INFINITY
)
392 ts
= now(CLOCK_MONOTONIC
);
394 if (!fail
&& !force
) {
395 notify
= inotify_init1(IN_CLOEXEC
| (timeout
!= USEC_INFINITY
? IN_NONBLOCK
: 0));
401 wd
= inotify_add_watch(notify
, name
, IN_CLOSE
);
409 struct sigaction sa_old
, sa_new
= {
410 .sa_handler
= SIG_IGN
,
411 .sa_flags
= SA_RESTART
,
415 r
= flush_fd(notify
);
420 /* We pass here O_NOCTTY only so that we can check the return
421 * value TIOCSCTTY and have a reliable way to figure out if we
422 * successfully became the controlling process of the tty */
423 fd
= open_terminal(name
, O_RDWR
|O_NOCTTY
|O_CLOEXEC
);
427 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
428 * if we already own the tty. */
429 assert_se(sigaction(SIGHUP
, &sa_new
, &sa_old
) == 0);
431 /* First, try to get the tty */
432 if (ioctl(fd
, TIOCSCTTY
, force
) < 0)
435 assert_se(sigaction(SIGHUP
, &sa_old
, NULL
) == 0);
437 /* Sometimes, it makes sense to ignore TIOCSCTTY
438 * returning EPERM, i.e. when very likely we already
439 * are have this controlling terminal. */
440 if (r
< 0 && r
== -EPERM
&& ignore_tiocstty_eperm
)
443 if (r
< 0 && (force
|| fail
|| r
!= -EPERM
))
454 union inotify_event_buffer buffer
;
455 struct inotify_event
*e
;
458 if (timeout
!= USEC_INFINITY
) {
461 n
= now(CLOCK_MONOTONIC
);
462 if (ts
+ timeout
< n
) {
467 r
= fd_wait_for_event(notify
, POLLIN
, ts
+ timeout
- n
);
477 l
= read(notify
, &buffer
, sizeof(buffer
));
479 if (IN_SET(errno
, EINTR
, EAGAIN
))
486 FOREACH_INOTIFY_EVENT(e
, buffer
, l
) {
487 if (e
->wd
!= wd
|| !(e
->mask
& IN_CLOSE
)) {
496 /* We close the tty fd here since if the old session
497 * ended our handle will be dead. It's important that
498 * we do this after sleeping, so that we don't enter
499 * an endless loop. */
514 int release_terminal(void) {
515 static const struct sigaction sa_new
= {
516 .sa_handler
= SIG_IGN
,
517 .sa_flags
= SA_RESTART
,
520 _cleanup_close_
int fd
= -1;
521 struct sigaction sa_old
;
524 fd
= open("/dev/tty", O_RDWR
|O_NOCTTY
|O_CLOEXEC
|O_NONBLOCK
);
528 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
529 * by our own TIOCNOTTY */
530 assert_se(sigaction(SIGHUP
, &sa_new
, &sa_old
) == 0);
532 if (ioctl(fd
, TIOCNOTTY
) < 0)
535 assert_se(sigaction(SIGHUP
, &sa_old
, NULL
) == 0);
540 int terminal_vhangup_fd(int fd
) {
543 if (ioctl(fd
, TIOCVHANGUP
) < 0)
549 int terminal_vhangup(const char *name
) {
550 _cleanup_close_
int fd
;
552 fd
= open_terminal(name
, O_RDWR
|O_NOCTTY
|O_CLOEXEC
|O_NONBLOCK
);
556 return terminal_vhangup_fd(fd
);
559 int vt_disallocate(const char *name
) {
560 _cleanup_close_
int fd
= -1;
565 /* Deallocate the VT if possible. If not possible
566 * (i.e. because it is the active one), at least clear it
567 * entirely (including the scrollback buffer) */
569 e
= path_startswith(name
, "/dev/");
573 if (!tty_is_vc(name
)) {
574 /* So this is not a VT. I guess we cannot deallocate
575 * it then. But let's at least clear the screen */
577 fd
= open_terminal(name
, O_RDWR
|O_NOCTTY
|O_CLOEXEC
);
582 "\033[r" /* clear scrolling region */
583 "\033[H" /* move home */
584 "\033[2J", /* clear screen */
589 n
= startswith(e
, "tty");
593 r
= safe_atou(n
, &u
);
600 /* Try to deallocate */
601 fd
= open_terminal("/dev/tty0", O_RDWR
|O_NOCTTY
|O_CLOEXEC
|O_NONBLOCK
);
605 r
= ioctl(fd
, VT_DISALLOCATE
, u
);
614 /* Couldn't deallocate, so let's clear it fully with
616 fd
= open_terminal(name
, O_RDWR
|O_NOCTTY
|O_CLOEXEC
);
621 "\033[r" /* clear scrolling region */
622 "\033[H" /* move home */
623 "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
628 int make_console_stdio(void) {
631 /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
633 fd
= acquire_terminal("/dev/console", false, true, true, USEC_INFINITY
);
635 return log_error_errno(fd
, "Failed to acquire terminal: %m");
637 r
= reset_terminal_fd(fd
, true);
639 log_warning_errno(r
, "Failed to reset terminal, ignoring: %m");
643 return log_error_errno(r
, "Failed to duplicate terminal fd: %m");
648 bool tty_is_vc(const char *tty
) {
651 return vtnr_from_tty(tty
) >= 0;
654 bool tty_is_console(const char *tty
) {
657 return streq(skip_dev_prefix(tty
), "console");
660 int vtnr_from_tty(const char *tty
) {
665 tty
= skip_dev_prefix(tty
);
667 if (!startswith(tty
, "tty") )
670 if (tty
[3] < '0' || tty
[3] > '9')
673 r
= safe_atoi(tty
+3, &i
);
683 char *resolve_dev_console(char **active
) {
686 /* Resolve where /dev/console is pointing to, if /sys is actually ours
687 * (i.e. not read-only-mounted which is a sign for container setups) */
689 if (path_is_read_only_fs("/sys") > 0)
692 if (read_one_line_file("/sys/class/tty/console/active", active
) < 0)
695 /* If multiple log outputs are configured the last one is what
696 * /dev/console points to */
697 tty
= strrchr(*active
, ' ');
703 if (streq(tty
, "tty0")) {
706 /* Get the active VC (e.g. tty1) */
707 if (read_one_line_file("/sys/class/tty/tty0/active", &tmp
) >= 0) {
716 int get_kernel_consoles(char ***consoles
) {
717 _cleanup_strv_free_
char **con
= NULL
;
718 _cleanup_free_
char *line
= NULL
;
724 r
= read_one_line_file("/sys/class/tty/console/active", &line
);
730 _cleanup_free_
char *tty
= NULL
;
733 r
= extract_first_word(&active
, &tty
, NULL
, 0);
739 if (streq(tty
, "tty0")) {
741 r
= read_one_line_file("/sys/class/tty/tty0/active", &tty
);
746 path
= strappend("/dev/", tty
);
750 if (access(path
, F_OK
) < 0) {
751 log_debug_errno(errno
, "Console device %s is not accessible, skipping: %m", path
);
756 r
= strv_consume(&con
, path
);
761 if (strv_isempty(con
)) {
762 log_debug("No devices found for system console");
764 r
= strv_extend(&con
, "/dev/console");
774 bool tty_is_vc_resolve(const char *tty
) {
775 _cleanup_free_
char *active
= NULL
;
779 tty
= skip_dev_prefix(tty
);
781 if (streq(tty
, "console")) {
782 tty
= resolve_dev_console(&active
);
787 return tty_is_vc(tty
);
790 const char *default_term_for_tty(const char *tty
) {
791 return tty
&& tty_is_vc_resolve(tty
) ? "linux" : "vt220";
794 int fd_columns(int fd
) {
795 struct winsize ws
= {};
797 if (ioctl(fd
, TIOCGWINSZ
, &ws
) < 0)
806 unsigned columns(void) {
810 if (_likely_(cached_columns
> 0))
811 return cached_columns
;
814 e
= getenv("COLUMNS");
816 (void) safe_atoi(e
, &c
);
819 c
= fd_columns(STDOUT_FILENO
);
825 return cached_columns
;
828 int fd_lines(int fd
) {
829 struct winsize ws
= {};
831 if (ioctl(fd
, TIOCGWINSZ
, &ws
) < 0)
840 unsigned lines(void) {
844 if (_likely_(cached_lines
> 0))
850 (void) safe_atoi(e
, &l
);
853 l
= fd_lines(STDOUT_FILENO
);
862 /* intended to be used as a SIGWINCH sighandler */
863 void columns_lines_cache_reset(int signum
) {
869 static int cached_on_tty
= -1;
871 if (_unlikely_(cached_on_tty
< 0))
872 cached_on_tty
= isatty(STDOUT_FILENO
) > 0;
874 return cached_on_tty
;
877 int make_stdio(int fd
) {
882 if (dup2(fd
, STDIN_FILENO
) < 0 && r
>= 0)
884 if (dup2(fd
, STDOUT_FILENO
) < 0 && r
>= 0)
886 if (dup2(fd
, STDERR_FILENO
) < 0 && r
>= 0)
892 /* Explicitly unset O_CLOEXEC, since if fd was < 3, then dup2() was a NOP and the bit hence possibly set. */
893 stdio_unset_cloexec();
898 int make_null_stdio(void) {
901 null_fd
= open("/dev/null", O_RDWR
|O_NOCTTY
|O_CLOEXEC
);
905 return make_stdio(null_fd
);
908 int getttyname_malloc(int fd
, char **ret
) {
918 r
= ttyname_r(fd
, path
, sizeof(path
));
922 c
= strdup(skip_dev_prefix(path
));
939 int getttyname_harder(int fd
, char **r
) {
943 k
= getttyname_malloc(fd
, &s
);
947 if (streq(s
, "tty")) {
949 return get_ctty(0, NULL
, r
);
956 int get_ctty_devnr(pid_t pid
, dev_t
*d
) {
958 _cleanup_free_
char *line
= NULL
;
964 p
= procfs_file_alloca(pid
, "stat");
965 r
= read_one_line_file(p
, &line
);
969 p
= strrchr(line
, ')');
984 if (major(ttynr
) == 0 && minor(ttynr
) == 0)
993 int get_ctty(pid_t pid
, dev_t
*_devnr
, char **r
) {
994 char fn
[STRLEN("/dev/char/") + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b
= NULL
;
995 _cleanup_free_
char *s
= NULL
;
1002 k
= get_ctty_devnr(pid
, &devnr
);
1006 sprintf(fn
, "/dev/char/%u:%u", major(devnr
), minor(devnr
));
1008 k
= readlink_malloc(fn
, &s
);
1014 /* This is an ugly hack */
1015 if (major(devnr
) == 136) {
1016 if (asprintf(&b
, "pts/%u", minor(devnr
)) < 0)
1019 /* Probably something like the ptys which have no
1020 * symlink in /dev/char. Let's return something
1021 * vaguely useful. */
1028 if (startswith(s
, "/dev/"))
1030 else if (startswith(s
, "../"))
1047 int ptsname_malloc(int fd
, char **ret
) {
1060 if (ptsname_r(fd
, c
, l
) == 0) {
1064 if (errno
!= ERANGE
) {
1074 int ptsname_namespace(int pty
, char **ret
) {
1077 /* Like ptsname(), but doesn't assume that the path is
1078 * accessible in the local namespace. */
1080 r
= ioctl(pty
, TIOCGPTN
, &no
);
1087 if (asprintf(ret
, "/dev/pts/%i", no
) < 0)
1093 int openpt_in_namespace(pid_t pid
, int flags
) {
1094 _cleanup_close_
int pidnsfd
= -1, mntnsfd
= -1, usernsfd
= -1, rootfd
= -1;
1095 _cleanup_close_pair_
int pair
[2] = { -1, -1 };
1101 r
= namespace_open(pid
, &pidnsfd
, &mntnsfd
, NULL
, &usernsfd
, &rootfd
);
1105 if (socketpair(AF_UNIX
, SOCK_DGRAM
, 0, pair
) < 0)
1108 r
= safe_fork("(sd-openpt)", FORK_RESET_SIGNALS
|FORK_DEATHSIG
, &child
);
1114 pair
[0] = safe_close(pair
[0]);
1116 r
= namespace_enter(pidnsfd
, mntnsfd
, -1, usernsfd
, rootfd
);
1118 _exit(EXIT_FAILURE
);
1120 master
= posix_openpt(flags
|O_NOCTTY
|O_CLOEXEC
);
1122 _exit(EXIT_FAILURE
);
1124 if (unlockpt(master
) < 0)
1125 _exit(EXIT_FAILURE
);
1127 if (send_one_fd(pair
[1], master
, 0) < 0)
1128 _exit(EXIT_FAILURE
);
1130 _exit(EXIT_SUCCESS
);
1133 pair
[1] = safe_close(pair
[1]);
1135 r
= wait_for_terminate_and_check("(sd-openpt)", child
, 0);
1138 if (r
!= EXIT_SUCCESS
)
1141 return receive_one_fd(pair
[0], 0);
1144 int open_terminal_in_namespace(pid_t pid
, const char *name
, int mode
) {
1145 _cleanup_close_
int pidnsfd
= -1, mntnsfd
= -1, usernsfd
= -1, rootfd
= -1;
1146 _cleanup_close_pair_
int pair
[2] = { -1, -1 };
1150 r
= namespace_open(pid
, &pidnsfd
, &mntnsfd
, NULL
, &usernsfd
, &rootfd
);
1154 if (socketpair(AF_UNIX
, SOCK_DGRAM
, 0, pair
) < 0)
1157 r
= safe_fork("(sd-terminal)", FORK_RESET_SIGNALS
|FORK_DEATHSIG
, &child
);
1163 pair
[0] = safe_close(pair
[0]);
1165 r
= namespace_enter(pidnsfd
, mntnsfd
, -1, usernsfd
, rootfd
);
1167 _exit(EXIT_FAILURE
);
1169 master
= open_terminal(name
, mode
|O_NOCTTY
|O_CLOEXEC
);
1171 _exit(EXIT_FAILURE
);
1173 if (send_one_fd(pair
[1], master
, 0) < 0)
1174 _exit(EXIT_FAILURE
);
1176 _exit(EXIT_SUCCESS
);
1179 pair
[1] = safe_close(pair
[1]);
1181 r
= wait_for_terminate_and_check("(sd-terminal)", child
, 0);
1184 if (r
!= EXIT_SUCCESS
)
1187 return receive_one_fd(pair
[0], 0);
1190 static bool getenv_terminal_is_dumb(void) {
1197 return streq(e
, "dumb");
1200 bool terminal_is_dumb(void) {
1204 return getenv_terminal_is_dumb();
1207 bool colors_enabled(void) {
1208 static int enabled
= -1;
1210 if (_unlikely_(enabled
< 0)) {
1213 val
= getenv_bool("SYSTEMD_COLORS");
1216 else if (getpid_cached() == 1)
1217 /* PID1 outputs to the console without holding it open all the time */
1218 enabled
= !getenv_terminal_is_dumb();
1220 enabled
= !terminal_is_dumb();
1226 bool underline_enabled(void) {
1227 static int enabled
= -1;
1231 /* The Linux console doesn't support underlining, turn it off, but only there. */
1233 if (!colors_enabled())
1236 enabled
= !streq_ptr(getenv("TERM"), "linux");
1242 int vt_default_utf8(void) {
1243 _cleanup_free_
char *b
= NULL
;
1246 /* Read the default VT UTF8 setting from the kernel */
1248 r
= read_one_line_file("/sys/module/vt/parameters/default_utf8", &b
);
1252 return parse_boolean(b
);
1255 int vt_reset_keyboard(int fd
) {
1258 /* If we can't read the default, then default to unicode. It's 2017 after all. */
1259 kb
= vt_default_utf8() != 0 ? K_UNICODE
: K_XLATE
;
1261 if (ioctl(fd
, KDSKBMODE
, kb
) < 0)