src/basic/terminal-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   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.
  11
  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.
  16
  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/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <limits.h>
  24 #include <stdarg.h>
  25 #include <stddef.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/inotify.h>
  29 #include <sys/socket.h>
  30 #include <sys/sysmacros.h>
  31 #include <sys/time.h>
  32 #include <linux/kd.h>
  33 #include <linux/tiocl.h>
  34 #include <linux/vt.h>
  35 #include <poll.h>
  36 #include <signal.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/types.h>
  39 #include <termios.h>
  40 #include <unistd.h>
  41
  42 #include "alloc-util.h"
  43 #include "env-util.h"
  44 #include "fd-util.h"
  45 #include "fileio.h"
  46 #include "fs-util.h"
  47 #include "io-util.h"
  48 #include "log.h"
  49 #include "macro.h"
  50 #include "parse-util.h"
  51 #include "path-util.h"
  52 #include "proc-cmdline.h"
  53 #include "process-util.h"
  54 #include "socket-util.h"
  55 #include "stat-util.h"
  56 #include "string-util.h"
  57 #include "strv.h"
  58 #include "terminal-util.h"
  59 #include "time-util.h"
  60 #include "util.h"
  61
  62 static volatile unsigned cached_columns = 0;
  63 static volatile unsigned cached_lines = 0;
  64
  65 static volatile int cached_on_tty = -1;
  66 static volatile int cached_colors_enabled = -1;
  67 static volatile int cached_underline_enabled = -1;
  68
  69 int chvt(int vt) {
  70         _cleanup_close_ int fd;
  71
  72         /* Switch to the specified vt number. If the VT is specified <= 0 switch to the VT the kernel log messages go,
  73          * if that's configured. */
  74
  75         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
  76         if (fd < 0)
  77                 return -errno;
  78
  79         if (vt <= 0) {
  80                 int tiocl[2] = {
  81                         TIOCL_GETKMSGREDIRECT,
  82                         0
  83                 };
  84
  85                 if (ioctl(fd, TIOCLINUX, tiocl) < 0)
  86                         return -errno;
  87
  88                 vt = tiocl[0] <= 0 ? 1 : tiocl[0];
  89         }
  90
  91         if (ioctl(fd, VT_ACTIVATE, vt) < 0)
  92                 return -errno;
  93
  94         return 0;
  95 }
  96
  97 int read_one_char(FILE *f, char *ret, usec_t t, bool *need_nl) {
  98         struct termios old_termios, new_termios;
  99         char c, line[LINE_MAX];
 100
 101         assert(f);
 102         assert(ret);
 103
 104         if (tcgetattr(fileno(f), &old_termios) >= 0) {
 105                 new_termios = old_termios;
 106
 107                 new_termios.c_lflag &= ~ICANON;
 108                 new_termios.c_cc[VMIN] = 1;
 109                 new_termios.c_cc[VTIME] = 0;
 110
 111                 if (tcsetattr(fileno(f), TCSADRAIN, &new_termios) >= 0) {
 112                         size_t k;
 113
 114                         if (t != USEC_INFINITY) {
 115                                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0) {
 116                                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
 117                                         return -ETIMEDOUT;
 118                                 }
 119                         }
 120
 121                         k = fread(&c, 1, 1, f);
 122
 123                         tcsetattr(fileno(f), TCSADRAIN, &old_termios);
 124
 125                         if (k <= 0)
 126                                 return -EIO;
 127
 128                         if (need_nl)
 129                                 *need_nl = c != '\n';
 130
 131                         *ret = c;
 132                         return 0;
 133                 }
 134         }
 135
 136         if (t != USEC_INFINITY) {
 137                 if (fd_wait_for_event(fileno(f), POLLIN, t) <= 0)
 138                         return -ETIMEDOUT;
 139         }
 140
 141         errno = 0;
 142         if (!fgets(line, sizeof(line), f))
 143                 return errno > 0 ? -errno : -EIO;
 144
 145         truncate_nl(line);
 146
 147         if (strlen(line) != 1)
 148                 return -EBADMSG;
 149
 150         if (need_nl)
 151                 *need_nl = false;
 152
 153         *ret = line[0];
 154         return 0;
 155 }
 156
 157 #define DEFAULT_ASK_REFRESH_USEC (2*USEC_PER_SEC)
 158
 159 int ask_char(char *ret, const char *replies, const char *fmt, ...) {
 160         int r;
 161
 162         assert(ret);
 163         assert(replies);
 164         assert(fmt);
 165
 166         for (;;) {
 167                 va_list ap;
 168                 char c;
 169                 bool need_nl = true;
 170
 171                 if (colors_enabled())
 172                         fputs(ANSI_HIGHLIGHT, stdout);
 173
 174                 putchar('\r');
 175
 176                 va_start(ap, fmt);
 177                 vprintf(fmt, ap);
 178                 va_end(ap);
 179
 180                 if (colors_enabled())
 181                         fputs(ANSI_NORMAL, stdout);
 182
 183                 fflush(stdout);
 184
 185                 r = read_one_char(stdin, &c, DEFAULT_ASK_REFRESH_USEC, &need_nl);
 186                 if (r < 0) {
 187
 188                         if (r == -ETIMEDOUT)
 189                                 continue;
 190
 191                         if (r == -EBADMSG) {
 192                                 puts("Bad input, please try again.");
 193                                 continue;
 194                         }
 195
 196                         putchar('\n');
 197                         return r;
 198                 }
 199
 200                 if (need_nl)
 201                         putchar('\n');
 202
 203                 if (strchr(replies, c)) {
 204                         *ret = c;
 205                         return 0;
 206                 }
 207
 208                 puts("Read unexpected character, please try again.");
 209         }
 210 }
 211
 212 int ask_string(char **ret, const char *text, ...) {
 213         assert(ret);
 214         assert(text);
 215
 216         for (;;) {
 217                 char line[LINE_MAX];
 218                 va_list ap;
 219
 220                 if (colors_enabled())
 221                         fputs(ANSI_HIGHLIGHT, stdout);
 222
 223                 va_start(ap, text);
 224                 vprintf(text, ap);
 225                 va_end(ap);
 226
 227                 if (colors_enabled())
 228                         fputs(ANSI_NORMAL, stdout);
 229
 230                 fflush(stdout);
 231
 232                 errno = 0;
 233                 if (!fgets(line, sizeof(line), stdin))
 234                         return errno > 0 ? -errno : -EIO;
 235
 236                 if (!endswith(line, "\n"))
 237                         putchar('\n');
 238                 else {
 239                         char *s;
 240
 241                         if (isempty(line))
 242                                 continue;
 243
 244                         truncate_nl(line);
 245                         s = strdup(line);
 246                         if (!s)
 247                                 return -ENOMEM;
 248
 249                         *ret = s;
 250                         return 0;
 251                 }
 252         }
 253 }
 254
 255 int reset_terminal_fd(int fd, bool switch_to_text) {
 256         struct termios termios;
 257         int r = 0;
 258
 259         /* Set terminal to some sane defaults */
 260
 261         assert(fd >= 0);
 262
 263         /* We leave locked terminal attributes untouched, so that
 264          * Plymouth may set whatever it wants to set, and we don't
 265          * interfere with that. */
 266
 267         /* Disable exclusive mode, just in case */
 268         (void) ioctl(fd, TIOCNXCL);
 269
 270         /* Switch to text mode */
 271         if (switch_to_text)
 272                 (void) ioctl(fd, KDSETMODE, KD_TEXT);
 273
 274         /* Set default keyboard mode */
 275         (void) vt_reset_keyboard(fd);
 276
 277         if (tcgetattr(fd, &termios) < 0) {
 278                 r = -errno;
 279                 goto finish;
 280         }
 281
 282         /* We only reset the stuff that matters to the software. How
 283          * hardware is set up we don't touch assuming that somebody
 284          * else will do that for us */
 285
 286         termios.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | IUCLC);
 287         termios.c_iflag |= ICRNL | IMAXBEL | IUTF8;
 288         termios.c_oflag |= ONLCR;
 289         termios.c_cflag |= CREAD;
 290         termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL | ECHOPRT | ECHOKE;
 291
 292         termios.c_cc[VINTR]    =   03;  /* ^C */
 293         termios.c_cc[VQUIT]    =  034;  /* ^\ */
 294         termios.c_cc[VERASE]   = 0177;
 295         termios.c_cc[VKILL]    =  025;  /* ^X */
 296         termios.c_cc[VEOF]     =   04;  /* ^D */
 297         termios.c_cc[VSTART]   =  021;  /* ^Q */
 298         termios.c_cc[VSTOP]    =  023;  /* ^S */
 299         termios.c_cc[VSUSP]    =  032;  /* ^Z */
 300         termios.c_cc[VLNEXT]   =  026;  /* ^V */
 301         termios.c_cc[VWERASE]  =  027;  /* ^W */
 302         termios.c_cc[VREPRINT] =  022;  /* ^R */
 303         termios.c_cc[VEOL]     =    0;
 304         termios.c_cc[VEOL2]    =    0;
 305
 306         termios.c_cc[VTIME]  = 0;
 307         termios.c_cc[VMIN]   = 1;
 308
 309         if (tcsetattr(fd, TCSANOW, &termios) < 0)
 310                 r = -errno;
 311
 312 finish:
 313         /* Just in case, flush all crap out */
 314         (void) tcflush(fd, TCIOFLUSH);
 315
 316         return r;
 317 }
 318
 319 int reset_terminal(const char *name) {
 320         _cleanup_close_ int fd = -1;
 321
 322         /* We open the terminal with O_NONBLOCK here, to ensure we
 323          * don't block on carrier if this is a terminal with carrier
 324          * configured. */
 325
 326         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
 327         if (fd < 0)
 328                 return fd;
 329
 330         return reset_terminal_fd(fd, true);
 331 }
 332
 333 int open_terminal(const char *name, int mode) {
 334         unsigned c = 0;
 335         int fd;
 336
 337         /*
 338          * If a TTY is in the process of being closed opening it might
 339          * cause EIO. This is horribly awful, but unlikely to be
 340          * changed in the kernel. Hence we work around this problem by
 341          * retrying a couple of times.
 342          *
 343          * https://bugs.launchpad.net/ubuntu/+source/linux/+bug/554172/comments/245
 344          */
 345
 346         if (mode & O_CREAT)
 347                 return -EINVAL;
 348
 349         for (;;) {
 350                 fd = open(name, mode, 0);
 351                 if (fd >= 0)
 352                         break;
 353
 354                 if (errno != EIO)
 355                         return -errno;
 356
 357                 /* Max 1s in total */
 358                 if (c >= 20)
 359                         return -errno;
 360
 361                 usleep(50 * USEC_PER_MSEC);
 362                 c++;
 363         }
 364
 365         if (isatty(fd) <= 0) {
 366                 safe_close(fd);
 367                 return -ENOTTY;
 368         }
 369
 370         return fd;
 371 }
 372
 373 int acquire_terminal(
 374                 const char *name,
 375                 AcquireTerminalFlags flags,
 376                 usec_t timeout) {
 377
 378         _cleanup_close_ int notify = -1, fd = -1;
 379         usec_t ts = USEC_INFINITY;
 380         int r, wd = -1;
 381
 382         assert(name);
 383         assert(IN_SET(flags & ~ACQUIRE_TERMINAL_PERMISSIVE, ACQUIRE_TERMINAL_TRY, ACQUIRE_TERMINAL_FORCE, ACQUIRE_TERMINAL_WAIT));
 384
 385         /* We use inotify to be notified when the tty is closed. We create the watch before checking if we can actually
 386          * acquire it, so that we don't lose any event.
 387          *
 388          * Note: strictly speaking this actually watches for the device being closed, it does *not* really watch
 389          * whether a tty loses its controlling process. However, unless some rogue process uses TIOCNOTTY on /dev/tty
 390          * *after* closing its tty otherwise this will not become a problem. As long as the administrator makes sure to
 391          * not configure any service on the same tty as an untrusted user this should not be a problem. (Which they
 392          * probably should not do anyway.) */
 393
 394         if ((flags & ~ACQUIRE_TERMINAL_PERMISSIVE) == ACQUIRE_TERMINAL_WAIT) {
 395                 notify = inotify_init1(IN_CLOEXEC | (timeout != USEC_INFINITY ? IN_NONBLOCK : 0));
 396                 if (notify < 0)
 397                         return -errno;
 398
 399                 wd = inotify_add_watch(notify, name, IN_CLOSE);
 400                 if (wd < 0)
 401                         return -errno;
 402
 403                 if (timeout != USEC_INFINITY)
 404                         ts = now(CLOCK_MONOTONIC);
 405         }
 406
 407         for (;;) {
 408                 struct sigaction sa_old, sa_new = {
 409                         .sa_handler = SIG_IGN,
 410                         .sa_flags = SA_RESTART,
 411                 };
 412
 413                 if (notify >= 0) {
 414                         r = flush_fd(notify);
 415                         if (r < 0)
 416                                 return r;
 417                 }
 418
 419                 /* We pass here O_NOCTTY only so that we can check the return value TIOCSCTTY and have a reliable way
 420                  * to figure out if we successfully became the controlling process of the tty */
 421                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
 422                 if (fd < 0)
 423                         return fd;
 424
 425                 /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed if we already own the tty. */
 426                 assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
 427
 428                 /* First, try to get the tty */
 429                 r = ioctl(fd, TIOCSCTTY,
 430                           (flags & ~ACQUIRE_TERMINAL_PERMISSIVE) == ACQUIRE_TERMINAL_FORCE) < 0 ? -errno : 0;
 431
 432                 /* Reset signal handler to old value */
 433                 assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
 434
 435                 /* Success? Exit the loop now! */
 436                 if (r >= 0)
 437                         break;
 438
 439                 /* Any failure besides -EPERM? Fail, regardless of the mode. */
 440                 if (r != -EPERM)
 441                         return r;
 442
 443                 if (flags & ACQUIRE_TERMINAL_PERMISSIVE) /* If we are in permissive mode, then EPERM is fine, turn this
 444                                                           * into a success. Note that EPERM is also returned if we
 445                                                           * already are the owner of the TTY. */
 446                         break;
 447
 448                 if (flags != ACQUIRE_TERMINAL_WAIT) /* If we are in TRY or FORCE mode, then propagate EPERM as EPERM */
 449                         return r;
 450
 451                 assert(notify >= 0);
 452                 assert(wd >= 0);
 453
 454                 for (;;) {
 455                         union inotify_event_buffer buffer;
 456                         struct inotify_event *e;
 457                         ssize_t l;
 458
 459                         if (timeout != USEC_INFINITY) {
 460                                 usec_t n;
 461
 462                                 assert(ts != USEC_INFINITY);
 463
 464                                 n = now(CLOCK_MONOTONIC);
 465                                 if (ts + timeout < n)
 466                                         return -ETIMEDOUT;
 467
 468                                 r = fd_wait_for_event(notify, POLLIN, ts + timeout - n);
 469                                 if (r < 0)
 470                                         return r;
 471                                 if (r == 0)
 472                                         return -ETIMEDOUT;
 473                         }
 474
 475                         l = read(notify, &buffer, sizeof(buffer));
 476                         if (l < 0) {
 477                                 if (IN_SET(errno, EINTR, EAGAIN))
 478                                         continue;
 479
 480                                 return -errno;
 481                         }
 482
 483                         FOREACH_INOTIFY_EVENT(e, buffer, l) {
 484                                 if (e->mask & IN_Q_OVERFLOW) /* If we hit an inotify queue overflow, simply check if the terminal is up for grabs now. */
 485                                         break;
 486
 487                                 if (e->wd != wd || !(e->mask & IN_CLOSE)) /* Safety checks */
 488                                         return -EIO;
 489                         }
 490
 491                         break;
 492                 }
 493
 494                 /* We close the tty fd here since if the old session ended our handle will be dead. It's important that
 495                  * we do this after sleeping, so that we don't enter an endless loop. */
 496                 fd = safe_close(fd);
 497         }
 498
 499         r = fd;
 500         fd = -1;
 501
 502         return r;
 503 }
 504
 505 int release_terminal(void) {
 506         static const struct sigaction sa_new = {
 507                 .sa_handler = SIG_IGN,
 508                 .sa_flags = SA_RESTART,
 509         };
 510
 511         _cleanup_close_ int fd = -1;
 512         struct sigaction sa_old;
 513         int r;
 514
 515         fd = open("/dev/tty", O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
 516         if (fd < 0)
 517                 return -errno;
 518
 519         /* Temporarily ignore SIGHUP, so that we don't get SIGHUP'ed
 520          * by our own TIOCNOTTY */
 521         assert_se(sigaction(SIGHUP, &sa_new, &sa_old) == 0);
 522
 523         r = ioctl(fd, TIOCNOTTY) < 0 ? -errno : 0;
 524
 525         assert_se(sigaction(SIGHUP, &sa_old, NULL) == 0);
 526
 527         return r;
 528 }
 529
 530 int terminal_vhangup_fd(int fd) {
 531         assert(fd >= 0);
 532
 533         if (ioctl(fd, TIOCVHANGUP) < 0)
 534                 return -errno;
 535
 536         return 0;
 537 }
 538
 539 int terminal_vhangup(const char *name) {
 540         _cleanup_close_ int fd;
 541
 542         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
 543         if (fd < 0)
 544                 return fd;
 545
 546         return terminal_vhangup_fd(fd);
 547 }
 548
 549 int vt_disallocate(const char *name) {
 550         _cleanup_close_ int fd = -1;
 551         const char *e, *n;
 552         unsigned u;
 553         int r;
 554
 555         /* Deallocate the VT if possible. If not possible
 556          * (i.e. because it is the active one), at least clear it
 557          * entirely (including the scrollback buffer) */
 558
 559         e = path_startswith(name, "/dev/");
 560         if (!e)
 561                 return -EINVAL;
 562
 563         if (!tty_is_vc(name)) {
 564                 /* So this is not a VT. I guess we cannot deallocate
 565                  * it then. But let's at least clear the screen */
 566
 567                 fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
 568                 if (fd < 0)
 569                         return fd;
 570
 571                 loop_write(fd,
 572                            "\033[r"    /* clear scrolling region */
 573                            "\033[H"    /* move home */
 574                            "\033[2J",  /* clear screen */
 575                            10, false);
 576                 return 0;
 577         }
 578
 579         n = startswith(e, "tty");
 580         if (!n)
 581                 return -EINVAL;
 582
 583         r = safe_atou(n, &u);
 584         if (r < 0)
 585                 return r;
 586
 587         if (u <= 0)
 588                 return -EINVAL;
 589
 590         /* Try to deallocate */
 591         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
 592         if (fd < 0)
 593                 return fd;
 594
 595         r = ioctl(fd, VT_DISALLOCATE, u);
 596         fd = safe_close(fd);
 597
 598         if (r >= 0)
 599                 return 0;
 600
 601         if (errno != EBUSY)
 602                 return -errno;
 603
 604         /* Couldn't deallocate, so let's clear it fully with
 605          * scrollback */
 606         fd = open_terminal(name, O_RDWR|O_NOCTTY|O_CLOEXEC);
 607         if (fd < 0)
 608                 return fd;
 609
 610         loop_write(fd,
 611                    "\033[r"   /* clear scrolling region */
 612                    "\033[H"   /* move home */
 613                    "\033[3J", /* clear screen including scrollback, requires Linux 2.6.40 */
 614                    10, false);
 615         return 0;
 616 }
 617
 618 int make_console_stdio(void) {
 619         int fd, r;
 620
 621         /* Make /dev/console the controlling terminal and stdin/stdout/stderr */
 622
 623         fd = acquire_terminal("/dev/console", ACQUIRE_TERMINAL_FORCE|ACQUIRE_TERMINAL_PERMISSIVE, USEC_INFINITY);
 624         if (fd < 0)
 625                 return log_error_errno(fd, "Failed to acquire terminal: %m");
 626
 627         r = reset_terminal_fd(fd, true);
 628         if (r < 0)
 629                 log_warning_errno(r, "Failed to reset terminal, ignoring: %m");
 630
 631         r = rearrange_stdio(fd, fd, fd); /* This invalidates 'fd' both on success and on failure. */
 632         if (r < 0)
 633                 return log_error_errno(r, "Failed to make terminal stdin/stdout/stderr: %m");
 634
 635         reset_terminal_feature_caches();
 636
 637         return 0;
 638 }
 639
 640 bool tty_is_vc(const char *tty) {
 641         assert(tty);
 642
 643         return vtnr_from_tty(tty) >= 0;
 644 }
 645
 646 bool tty_is_console(const char *tty) {
 647         assert(tty);
 648
 649         return streq(skip_dev_prefix(tty), "console");
 650 }
 651
 652 int vtnr_from_tty(const char *tty) {
 653         int i, r;
 654
 655         assert(tty);
 656
 657         tty = skip_dev_prefix(tty);
 658
 659         if (!startswith(tty, "tty") )
 660                 return -EINVAL;
 661
 662         if (tty[3] < '0' || tty[3] > '9')
 663                 return -EINVAL;
 664
 665         r = safe_atoi(tty+3, &i);
 666         if (r < 0)
 667                 return r;
 668
 669         if (i < 0 || i > 63)
 670                 return -EINVAL;
 671
 672         return i;
 673 }
 674
 675  int resolve_dev_console(char **ret) {
 676         _cleanup_free_ char *active = NULL;
 677         char *tty;
 678         int r;
 679
 680         assert(ret);
 681
 682         /* Resolve where /dev/console is pointing to, if /sys is actually ours (i.e. not read-only-mounted which is a
 683          * sign for container setups) */
 684
 685         if (path_is_read_only_fs("/sys") > 0)
 686                 return -ENOMEDIUM;
 687
 688         r = read_one_line_file("/sys/class/tty/console/active", &active);
 689         if (r < 0)
 690                 return r;
 691
 692         /* If multiple log outputs are configured the last one is what /dev/console points to */
 693         tty = strrchr(active, ' ');
 694         if (tty)
 695                 tty++;
 696         else
 697                 tty = active;
 698
 699         if (streq(tty, "tty0")) {
 700                 active = mfree(active);
 701
 702                 /* Get the active VC (e.g. tty1) */
 703                 r = read_one_line_file("/sys/class/tty/tty0/active", &active);
 704                 if (r < 0)
 705                         return r;
 706
 707                 tty = active;
 708         }
 709
 710         if (tty == active)
 711                 *ret = TAKE_PTR(active);
 712         else {
 713                 char *tmp;
 714
 715                 tmp = strdup(tty);
 716                 if (!tmp)
 717                         return -ENOMEM;
 718
 719                 *ret = tmp;
 720         }
 721
 722         return 0;
 723 }
 724
 725 int get_kernel_consoles(char ***ret) {
 726         _cleanup_strv_free_ char **l = NULL;
 727         _cleanup_free_ char *line = NULL;
 728         const char *p;
 729         int r;
 730
 731         assert(ret);
 732
 733         /* If /sys is mounted read-only this means we are running in some kind of container environment. In that
 734          * case /sys would reflect the host system, not us, hence ignore the data we can read from it. */
 735         if (path_is_read_only_fs("/sys") > 0)
 736                 goto fallback;
 737
 738         r = read_one_line_file("/sys/class/tty/console/active", &line);
 739         if (r < 0)
 740                 return r;
 741
 742         p = line;
 743         for (;;) {
 744                 _cleanup_free_ char *tty = NULL;
 745                 char *path;
 746
 747                 r = extract_first_word(&p, &tty, NULL, 0);
 748                 if (r < 0)
 749                         return r;
 750                 if (r == 0)
 751                         break;
 752
 753                 if (streq(tty, "tty0")) {
 754                         tty = mfree(tty);
 755                         r = read_one_line_file("/sys/class/tty/tty0/active", &tty);
 756                         if (r < 0)
 757                                 return r;
 758                 }
 759
 760                 path = strappend("/dev/", tty);
 761                 if (!path)
 762                         return -ENOMEM;
 763
 764                 if (access(path, F_OK) < 0) {
 765                         log_debug_errno(errno, "Console device %s is not accessible, skipping: %m", path);
 766                         free(path);
 767                         continue;
 768                 }
 769
 770                 r = strv_consume(&l, path);
 771                 if (r < 0)
 772                         return r;
 773         }
 774
 775         if (strv_isempty(l)) {
 776                 log_debug("No devices found for system console");
 777                 goto fallback;
 778         }
 779
 780         *ret = TAKE_PTR(l);
 781
 782         return 0;
 783
 784 fallback:
 785         r = strv_extend(&l, "/dev/console");
 786         if (r < 0)
 787                 return r;
 788
 789         *ret = TAKE_PTR(l);
 790
 791         return 0;
 792 }
 793
 794 bool tty_is_vc_resolve(const char *tty) {
 795         _cleanup_free_ char *resolved = NULL;
 796
 797         assert(tty);
 798
 799         tty = skip_dev_prefix(tty);
 800
 801         if (streq(tty, "console")) {
 802                 if (resolve_dev_console(&resolved) < 0)
 803                         return false;
 804
 805                 tty = resolved;
 806         }
 807
 808         return tty_is_vc(tty);
 809 }
 810
 811 const char *default_term_for_tty(const char *tty) {
 812         return tty && tty_is_vc_resolve(tty) ? "linux" : "vt220";
 813 }
 814
 815 int fd_columns(int fd) {
 816         struct winsize ws = {};
 817
 818         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
 819                 return -errno;
 820
 821         if (ws.ws_col <= 0)
 822                 return -EIO;
 823
 824         return ws.ws_col;
 825 }
 826
 827 unsigned columns(void) {
 828         const char *e;
 829         int c;
 830
 831         if (cached_columns > 0)
 832                 return cached_columns;
 833
 834         c = 0;
 835         e = getenv("COLUMNS");
 836         if (e)
 837                 (void) safe_atoi(e, &c);
 838
 839         if (c <= 0)
 840                 c = fd_columns(STDOUT_FILENO);
 841
 842         if (c <= 0)
 843                 c = 80;
 844
 845         cached_columns = c;
 846         return cached_columns;
 847 }
 848
 849 int fd_lines(int fd) {
 850         struct winsize ws = {};
 851
 852         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
 853                 return -errno;
 854
 855         if (ws.ws_row <= 0)
 856                 return -EIO;
 857
 858         return ws.ws_row;
 859 }
 860
 861 unsigned lines(void) {
 862         const char *e;
 863         int l;
 864
 865         if (cached_lines > 0)
 866                 return cached_lines;
 867
 868         l = 0;
 869         e = getenv("LINES");
 870         if (e)
 871                 (void) safe_atoi(e, &l);
 872
 873         if (l <= 0)
 874                 l = fd_lines(STDOUT_FILENO);
 875
 876         if (l <= 0)
 877                 l = 24;
 878
 879         cached_lines = l;
 880         return cached_lines;
 881 }
 882
 883 /* intended to be used as a SIGWINCH sighandler */
 884 void columns_lines_cache_reset(int signum) {
 885         cached_columns = 0;
 886         cached_lines = 0;
 887 }
 888
 889 void reset_terminal_feature_caches(void) {
 890         cached_columns = 0;
 891         cached_lines = 0;
 892
 893         cached_colors_enabled = -1;
 894         cached_underline_enabled = -1;
 895         cached_on_tty = -1;
 896 }
 897
 898 bool on_tty(void) {
 899         if (cached_on_tty < 0)
 900                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
 901
 902         return cached_on_tty;
 903 }
 904
 905 int getttyname_malloc(int fd, char **ret) {
 906         size_t l = 100;
 907         int r;
 908
 909         assert(fd >= 0);
 910         assert(ret);
 911
 912         for (;;) {
 913                 char path[l];
 914
 915                 r = ttyname_r(fd, path, sizeof(path));
 916                 if (r == 0) {
 917                         char *c;
 918
 919                         c = strdup(skip_dev_prefix(path));
 920                         if (!c)
 921                                 return -ENOMEM;
 922
 923                         *ret = c;
 924                         return 0;
 925                 }
 926
 927                 if (r != ERANGE)
 928                         return -r;
 929
 930                 l *= 2;
 931         }
 932
 933         return 0;
 934 }
 935
 936 int getttyname_harder(int fd, char **r) {
 937         int k;
 938         char *s = NULL;
 939
 940         k = getttyname_malloc(fd, &s);
 941         if (k < 0)
 942                 return k;
 943
 944         if (streq(s, "tty")) {
 945                 free(s);
 946                 return get_ctty(0, NULL, r);
 947         }
 948
 949         *r = s;
 950         return 0;
 951 }
 952
 953 int get_ctty_devnr(pid_t pid, dev_t *d) {
 954         int r;
 955         _cleanup_free_ char *line = NULL;
 956         const char *p;
 957         unsigned long ttynr;
 958
 959         assert(pid >= 0);
 960
 961         p = procfs_file_alloca(pid, "stat");
 962         r = read_one_line_file(p, &line);
 963         if (r < 0)
 964                 return r;
 965
 966         p = strrchr(line, ')');
 967         if (!p)
 968                 return -EIO;
 969
 970         p++;
 971
 972         if (sscanf(p, " "
 973                    "%*c "  /* state */
 974                    "%*d "  /* ppid */
 975                    "%*d "  /* pgrp */
 976                    "%*d "  /* session */
 977                    "%lu ", /* ttynr */
 978                    &ttynr) != 1)
 979                 return -EIO;
 980
 981         if (major(ttynr) == 0 && minor(ttynr) == 0)
 982                 return -ENXIO;
 983
 984         if (d)
 985                 *d = (dev_t) ttynr;
 986
 987         return 0;
 988 }
 989
 990 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
 991         char fn[STRLEN("/dev/char/") + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
 992         _cleanup_free_ char *s = NULL;
 993         const char *p;
 994         dev_t devnr;
 995         int k;
 996
 997         assert(r);
 998
 999         k = get_ctty_devnr(pid, &devnr);
1000         if (k < 0)
1001                 return k;
1002
1003         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
1004
1005         k = readlink_malloc(fn, &s);
1006         if (k < 0) {
1007
1008                 if (k != -ENOENT)
1009                         return k;
1010
1011                 /* This is an ugly hack */
1012                 if (major(devnr) == 136) {
1013                         if (asprintf(&b, "pts/%u", minor(devnr)) < 0)
1014                                 return -ENOMEM;
1015                 } else {
1016                         /* Probably something like the ptys which have no
1017                          * symlink in /dev/char. Let's return something
1018                          * vaguely useful. */
1019
1020                         b = strdup(fn + 5);
1021                         if (!b)
1022                                 return -ENOMEM;
1023                 }
1024         } else {
1025                 if (startswith(s, "/dev/"))
1026                         p = s + 5;
1027                 else if (startswith(s, "../"))
1028                         p = s + 3;
1029                 else
1030                         p = s;
1031
1032                 b = strdup(p);
1033                 if (!b)
1034                         return -ENOMEM;
1035         }
1036
1037         *r = b;
1038         if (_devnr)
1039                 *_devnr = devnr;
1040
1041         return 0;
1042 }
1043
1044 int ptsname_malloc(int fd, char **ret) {
1045         size_t l = 100;
1046
1047         assert(fd >= 0);
1048         assert(ret);
1049
1050         for (;;) {
1051                 char *c;
1052
1053                 c = new(char, l);
1054                 if (!c)
1055                         return -ENOMEM;
1056
1057                 if (ptsname_r(fd, c, l) == 0) {
1058                         *ret = c;
1059                         return 0;
1060                 }
1061                 if (errno != ERANGE) {
1062                         free(c);
1063                         return -errno;
1064                 }
1065
1066                 free(c);
1067                 l *= 2;
1068         }
1069 }
1070
1071 int ptsname_namespace(int pty, char **ret) {
1072         int no = -1, r;
1073
1074         /* Like ptsname(), but doesn't assume that the path is
1075          * accessible in the local namespace. */
1076
1077         r = ioctl(pty, TIOCGPTN, &no);
1078         if (r < 0)
1079                 return -errno;
1080
1081         if (no < 0)
1082                 return -EIO;
1083
1084         if (asprintf(ret, "/dev/pts/%i", no) < 0)
1085                 return -ENOMEM;
1086
1087         return 0;
1088 }
1089
1090 int openpt_in_namespace(pid_t pid, int flags) {
1091         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
1092         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1093         pid_t child;
1094         int r;
1095
1096         assert(pid > 0);
1097
1098         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
1099         if (r < 0)
1100                 return r;
1101
1102         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1103                 return -errno;
1104
1105         r = safe_fork("(sd-openpt)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &child);
1106         if (r < 0)
1107                 return r;
1108         if (r == 0) {
1109                 int master;
1110
1111                 pair[0] = safe_close(pair[0]);
1112
1113                 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
1114                 if (r < 0)
1115                         _exit(EXIT_FAILURE);
1116
1117                 master = posix_openpt(flags|O_NOCTTY|O_CLOEXEC);
1118                 if (master < 0)
1119                         _exit(EXIT_FAILURE);
1120
1121                 if (unlockpt(master) < 0)
1122                         _exit(EXIT_FAILURE);
1123
1124                 if (send_one_fd(pair[1], master, 0) < 0)
1125                         _exit(EXIT_FAILURE);
1126
1127                 _exit(EXIT_SUCCESS);
1128         }
1129
1130         pair[1] = safe_close(pair[1]);
1131
1132         r = wait_for_terminate_and_check("(sd-openpt)", child, 0);
1133         if (r < 0)
1134                 return r;
1135         if (r != EXIT_SUCCESS)
1136                 return -EIO;
1137
1138         return receive_one_fd(pair[0], 0);
1139 }
1140
1141 int open_terminal_in_namespace(pid_t pid, const char *name, int mode) {
1142         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
1143         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1144         pid_t child;
1145         int r;
1146
1147         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
1148         if (r < 0)
1149                 return r;
1150
1151         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1152                 return -errno;
1153
1154         r = safe_fork("(sd-terminal)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &child);
1155         if (r < 0)
1156                 return r;
1157         if (r == 0) {
1158                 int master;
1159
1160                 pair[0] = safe_close(pair[0]);
1161
1162                 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
1163                 if (r < 0)
1164                         _exit(EXIT_FAILURE);
1165
1166                 master = open_terminal(name, mode|O_NOCTTY|O_CLOEXEC);
1167                 if (master < 0)
1168                         _exit(EXIT_FAILURE);
1169
1170                 if (send_one_fd(pair[1], master, 0) < 0)
1171                         _exit(EXIT_FAILURE);
1172
1173                 _exit(EXIT_SUCCESS);
1174         }
1175
1176         pair[1] = safe_close(pair[1]);
1177
1178         r = wait_for_terminate_and_check("(sd-terminal)", child, 0);
1179         if (r < 0)
1180                 return r;
1181         if (r != EXIT_SUCCESS)
1182                 return -EIO;
1183
1184         return receive_one_fd(pair[0], 0);
1185 }
1186
1187 static bool getenv_terminal_is_dumb(void) {
1188         const char *e;
1189
1190         e = getenv("TERM");
1191         if (!e)
1192                 return true;
1193
1194         return streq(e, "dumb");
1195 }
1196
1197 bool terminal_is_dumb(void) {
1198         if (!on_tty())
1199                 return true;
1200
1201         return getenv_terminal_is_dumb();
1202 }
1203
1204 bool colors_enabled(void) {
1205
1206         /* Returns true if colors are considered supported on our stdout. For that we check $SYSTEMD_COLORS first
1207          * (which is the explicit way to turn colors on/off). If that didn't work we turn colors off unless we are on a
1208          * TTY. And if we are on a TTY we turn it off if $TERM is set to "dumb". There's one special tweak though: if
1209          * we are PID 1 then we do not check whether we are connected to a TTY, because we don't keep /dev/console open
1210          * continously due to fear of SAK, and hence things are a bit weird. */
1211
1212         if (cached_colors_enabled < 0) {
1213                 int val;
1214
1215                 val = getenv_bool("SYSTEMD_COLORS");
1216                 if (val >= 0)
1217                         cached_colors_enabled = val;
1218                 else if (getpid_cached() == 1)
1219                         /* PID1 outputs to the console without holding it open all the time */
1220                         cached_colors_enabled = !getenv_terminal_is_dumb();
1221                 else
1222                         cached_colors_enabled = !terminal_is_dumb();
1223         }
1224
1225         return cached_colors_enabled;
1226 }
1227
1228 bool dev_console_colors_enabled(void) {
1229         _cleanup_free_ char *s = NULL;
1230         int b;
1231
1232         /* Returns true if we assume that color is supported on /dev/console.
1233          *
1234          * For that we first check if we explicitly got told to use colors or not, by checking $SYSTEMD_COLORS. If that
1235          * isn't set we check whether PID 1 has $TERM set, and if not, whether TERM is set on the kernel command
1236          * line. If we find $TERM set we assume color if it's not set to "dumb", similarly to how regular
1237          * colors_enabled() operates. */
1238
1239         b = getenv_bool("SYSTEMD_COLORS");
1240         if (b >= 0)
1241                 return b;
1242
1243         if (getenv_for_pid(1, "TERM", &s) <= 0)
1244                 (void) proc_cmdline_get_key("TERM", 0, &s);
1245
1246         return !streq_ptr(s, "dumb");
1247 }
1248
1249 bool underline_enabled(void) {
1250
1251         if (cached_underline_enabled < 0) {
1252
1253                 /* The Linux console doesn't support underlining, turn it off, but only there. */
1254
1255                 if (colors_enabled())
1256                         cached_underline_enabled = !streq_ptr(getenv("TERM"), "linux");
1257                 else
1258                         cached_underline_enabled = false;
1259         }
1260
1261         return cached_underline_enabled;
1262 }
1263
1264 int vt_default_utf8(void) {
1265         _cleanup_free_ char *b = NULL;
1266         int r;
1267
1268         /* Read the default VT UTF8 setting from the kernel */
1269
1270         r = read_one_line_file("/sys/module/vt/parameters/default_utf8", &b);
1271         if (r < 0)
1272                 return r;
1273
1274         return parse_boolean(b);
1275 }
1276
1277 int vt_reset_keyboard(int fd) {
1278         int kb;
1279
1280         /* If we can't read the default, then default to unicode. It's 2017 after all. */
1281         kb = vt_default_utf8() != 0 ? K_UNICODE : K_XLATE;
1282
1283         if (ioctl(fd, KDSKBMODE, kb) < 0)
1284                 return -errno;
1285
1286         return 0;
1287 }