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 r
= dup2(fd
, STDIN_FILENO
);
883 s
= dup2(fd
, STDOUT_FILENO
);
884 t
= dup2(fd
, STDERR_FILENO
);
889 if (r
< 0 || s
< 0 || t
< 0)
892 /* Explicitly unset O_CLOEXEC, since if fd was < 3, then
893 * dup2() was a NOP and the bit hence possibly set. */
894 stdio_unset_cloexec();
899 int make_null_stdio(void) {
902 null_fd
= open("/dev/null", O_RDWR
|O_NOCTTY
);
906 return make_stdio(null_fd
);
909 int getttyname_malloc(int fd
, char **ret
) {
919 r
= ttyname_r(fd
, path
, sizeof(path
));
923 c
= strdup(skip_dev_prefix(path
));
940 int getttyname_harder(int fd
, char **r
) {
944 k
= getttyname_malloc(fd
, &s
);
948 if (streq(s
, "tty")) {
950 return get_ctty(0, NULL
, r
);
957 int get_ctty_devnr(pid_t pid
, dev_t
*d
) {
959 _cleanup_free_
char *line
= NULL
;
965 p
= procfs_file_alloca(pid
, "stat");
966 r
= read_one_line_file(p
, &line
);
970 p
= strrchr(line
, ')');
985 if (major(ttynr
) == 0 && minor(ttynr
) == 0)
994 int get_ctty(pid_t pid
, dev_t
*_devnr
, char **r
) {
995 char fn
[sizeof("/dev/char/")-1 + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b
= NULL
;
996 _cleanup_free_
char *s
= NULL
;
1003 k
= get_ctty_devnr(pid
, &devnr
);
1007 sprintf(fn
, "/dev/char/%u:%u", major(devnr
), minor(devnr
));
1009 k
= readlink_malloc(fn
, &s
);
1015 /* This is an ugly hack */
1016 if (major(devnr
) == 136) {
1017 if (asprintf(&b
, "pts/%u", minor(devnr
)) < 0)
1020 /* Probably something like the ptys which have no
1021 * symlink in /dev/char. Let's return something
1022 * vaguely useful. */
1029 if (startswith(s
, "/dev/"))
1031 else if (startswith(s
, "../"))
1048 int ptsname_malloc(int fd
, char **ret
) {
1061 if (ptsname_r(fd
, c
, l
) == 0) {
1065 if (errno
!= ERANGE
) {
1075 int ptsname_namespace(int pty
, char **ret
) {
1078 /* Like ptsname(), but doesn't assume that the path is
1079 * accessible in the local namespace. */
1081 r
= ioctl(pty
, TIOCGPTN
, &no
);
1088 if (asprintf(ret
, "/dev/pts/%i", no
) < 0)
1094 int openpt_in_namespace(pid_t pid
, int flags
) {
1095 _cleanup_close_
int pidnsfd
= -1, mntnsfd
= -1, usernsfd
= -1, rootfd
= -1;
1096 _cleanup_close_pair_
int pair
[2] = { -1, -1 };
1103 r
= namespace_open(pid
, &pidnsfd
, &mntnsfd
, NULL
, &usernsfd
, &rootfd
);
1107 if (socketpair(AF_UNIX
, SOCK_DGRAM
, 0, pair
) < 0)
1117 pair
[0] = safe_close(pair
[0]);
1119 r
= namespace_enter(pidnsfd
, mntnsfd
, -1, usernsfd
, rootfd
);
1121 _exit(EXIT_FAILURE
);
1123 master
= posix_openpt(flags
|O_NOCTTY
|O_CLOEXEC
);
1125 _exit(EXIT_FAILURE
);
1127 if (unlockpt(master
) < 0)
1128 _exit(EXIT_FAILURE
);
1130 if (send_one_fd(pair
[1], master
, 0) < 0)
1131 _exit(EXIT_FAILURE
);
1133 _exit(EXIT_SUCCESS
);
1136 pair
[1] = safe_close(pair
[1]);
1138 r
= wait_for_terminate(child
, &si
);
1141 if (si
.si_code
!= CLD_EXITED
|| si
.si_status
!= EXIT_SUCCESS
)
1144 return receive_one_fd(pair
[0], 0);
1147 int open_terminal_in_namespace(pid_t pid
, const char *name
, int mode
) {
1148 _cleanup_close_
int pidnsfd
= -1, mntnsfd
= -1, usernsfd
= -1, rootfd
= -1;
1149 _cleanup_close_pair_
int pair
[2] = { -1, -1 };
1154 r
= namespace_open(pid
, &pidnsfd
, &mntnsfd
, NULL
, &usernsfd
, &rootfd
);
1158 if (socketpair(AF_UNIX
, SOCK_DGRAM
, 0, pair
) < 0)
1168 pair
[0] = safe_close(pair
[0]);
1170 r
= namespace_enter(pidnsfd
, mntnsfd
, -1, usernsfd
, rootfd
);
1172 _exit(EXIT_FAILURE
);
1174 master
= open_terminal(name
, mode
|O_NOCTTY
|O_CLOEXEC
);
1176 _exit(EXIT_FAILURE
);
1178 if (send_one_fd(pair
[1], master
, 0) < 0)
1179 _exit(EXIT_FAILURE
);
1181 _exit(EXIT_SUCCESS
);
1184 pair
[1] = safe_close(pair
[1]);
1186 r
= wait_for_terminate(child
, &si
);
1189 if (si
.si_code
!= CLD_EXITED
|| si
.si_status
!= EXIT_SUCCESS
)
1192 return receive_one_fd(pair
[0], 0);
1195 static bool getenv_terminal_is_dumb(void) {
1202 return streq(e
, "dumb");
1205 bool terminal_is_dumb(void) {
1209 return getenv_terminal_is_dumb();
1212 bool colors_enabled(void) {
1213 static int enabled
= -1;
1215 if (_unlikely_(enabled
< 0)) {
1218 val
= getenv_bool("SYSTEMD_COLORS");
1221 else if (getpid_cached() == 1)
1222 /* PID1 outputs to the console without holding it open all the time */
1223 enabled
= !getenv_terminal_is_dumb();
1225 enabled
= !terminal_is_dumb();
1231 bool underline_enabled(void) {
1232 static int enabled
= -1;
1236 /* The Linux console doesn't support underlining, turn it off, but only there. */
1238 if (!colors_enabled())
1241 enabled
= !streq_ptr(getenv("TERM"), "linux");
1247 int vt_default_utf8(void) {
1248 _cleanup_free_
char *b
= NULL
;
1251 /* Read the default VT UTF8 setting from the kernel */
1253 r
= read_one_line_file("/sys/module/vt/parameters/default_utf8", &b
);
1257 return parse_boolean(b
);
1260 int vt_reset_keyboard(int fd
) {
1263 /* If we can't read the default, then default to unicode. It's 2017 after all. */
1264 kb
= vt_default_utf8() != 0 ? K_UNICODE
: K_XLATE
;
1266 if (ioctl(fd
, KDSKBMODE
, kb
) < 0)