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 = make_stdio(fd);
 632         if (r < 0)
 633                 return log_error_errno(r, "Failed to duplicate terminal fd: %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 = active;
 712                 active = NULL;
 713         } else {
 714                 char *tmp;
 715
 716                 tmp = strdup(tty);
 717                 if (!tmp)
 718                         return -ENOMEM;
 719
 720                 *ret = tmp;
 721         }
 722
 723         return 0;
 724 }
 725
 726 int get_kernel_consoles(char ***ret) {
 727         _cleanup_strv_free_ char **l = NULL;
 728         _cleanup_free_ char *line = NULL;
 729         const char *p;
 730         int r;
 731
 732         assert(ret);
 733
 734         /* If /sys is mounted read-only this means we are running in some kind of container environment. In that
 735          * case /sys would reflect the host system, not us, hence ignore the data we can read from it. */
 736         if (path_is_read_only_fs("/sys") > 0)
 737                 goto fallback;
 738
 739         r = read_one_line_file("/sys/class/tty/console/active", &line);
 740         if (r < 0)
 741                 return r;
 742
 743         p = line;
 744         for (;;) {
 745                 _cleanup_free_ char *tty = NULL;
 746                 char *path;
 747
 748                 r = extract_first_word(&p, &tty, NULL, 0);
 749                 if (r < 0)
 750                         return r;
 751                 if (r == 0)
 752                         break;
 753
 754                 if (streq(tty, "tty0")) {
 755                         tty = mfree(tty);
 756                         r = read_one_line_file("/sys/class/tty/tty0/active", &tty);
 757                         if (r < 0)
 758                                 return r;
 759                 }
 760
 761                 path = strappend("/dev/", tty);
 762                 if (!path)
 763                         return -ENOMEM;
 764
 765                 if (access(path, F_OK) < 0) {
 766                         log_debug_errno(errno, "Console device %s is not accessible, skipping: %m", path);
 767                         free(path);
 768                         continue;
 769                 }
 770
 771                 r = strv_consume(&l, path);
 772                 if (r < 0)
 773                         return r;
 774         }
 775
 776         if (strv_isempty(l)) {
 777                 log_debug("No devices found for system console");
 778                 goto fallback;
 779         }
 780
 781         *ret = l;
 782         l = NULL;
 783
 784         return 0;
 785
 786 fallback:
 787         r = strv_extend(&l, "/dev/console");
 788         if (r < 0)
 789                 return r;
 790
 791         *ret = l;
 792         l = NULL;
 793
 794         return 0;
 795 }
 796
 797 bool tty_is_vc_resolve(const char *tty) {
 798         _cleanup_free_ char *resolved = NULL;
 799
 800         assert(tty);
 801
 802         tty = skip_dev_prefix(tty);
 803
 804         if (streq(tty, "console")) {
 805                 if (resolve_dev_console(&resolved) < 0)
 806                         return false;
 807
 808                 tty = resolved;
 809         }
 810
 811         return tty_is_vc(tty);
 812 }
 813
 814 const char *default_term_for_tty(const char *tty) {
 815         return tty && tty_is_vc_resolve(tty) ? "linux" : "vt220";
 816 }
 817
 818 int fd_columns(int fd) {
 819         struct winsize ws = {};
 820
 821         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
 822                 return -errno;
 823
 824         if (ws.ws_col <= 0)
 825                 return -EIO;
 826
 827         return ws.ws_col;
 828 }
 829
 830 unsigned columns(void) {
 831         const char *e;
 832         int c;
 833
 834         if (cached_columns > 0)
 835                 return cached_columns;
 836
 837         c = 0;
 838         e = getenv("COLUMNS");
 839         if (e)
 840                 (void) safe_atoi(e, &c);
 841
 842         if (c <= 0)
 843                 c = fd_columns(STDOUT_FILENO);
 844
 845         if (c <= 0)
 846                 c = 80;
 847
 848         cached_columns = c;
 849         return cached_columns;
 850 }
 851
 852 int fd_lines(int fd) {
 853         struct winsize ws = {};
 854
 855         if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
 856                 return -errno;
 857
 858         if (ws.ws_row <= 0)
 859                 return -EIO;
 860
 861         return ws.ws_row;
 862 }
 863
 864 unsigned lines(void) {
 865         const char *e;
 866         int l;
 867
 868         if (cached_lines > 0)
 869                 return cached_lines;
 870
 871         l = 0;
 872         e = getenv("LINES");
 873         if (e)
 874                 (void) safe_atoi(e, &l);
 875
 876         if (l <= 0)
 877                 l = fd_lines(STDOUT_FILENO);
 878
 879         if (l <= 0)
 880                 l = 24;
 881
 882         cached_lines = l;
 883         return cached_lines;
 884 }
 885
 886 /* intended to be used as a SIGWINCH sighandler */
 887 void columns_lines_cache_reset(int signum) {
 888         cached_columns = 0;
 889         cached_lines = 0;
 890 }
 891
 892 void reset_terminal_feature_caches(void) {
 893         cached_columns = 0;
 894         cached_lines = 0;
 895
 896         cached_colors_enabled = -1;
 897         cached_underline_enabled = -1;
 898         cached_on_tty = -1;
 899 }
 900
 901 bool on_tty(void) {
 902         if (cached_on_tty < 0)
 903                 cached_on_tty = isatty(STDOUT_FILENO) > 0;
 904
 905         return cached_on_tty;
 906 }
 907
 908 int make_stdio(int fd) {
 909         int r = 0;
 910
 911         assert(fd >= 0);
 912
 913         if (dup2(fd, STDIN_FILENO) < 0)
 914                 r = -errno;
 915         if (dup2(fd, STDOUT_FILENO) < 0 && r >= 0)
 916                 r = -errno;
 917         if (dup2(fd, STDERR_FILENO) < 0 && r >= 0)
 918                 r = -errno;
 919
 920         if (fd >= 3)
 921                 safe_close(fd);
 922
 923         /* Explicitly unset O_CLOEXEC, since if fd was < 3, then dup2() was a NOP and the bit hence possibly set. */
 924         stdio_unset_cloexec();
 925
 926         return r;
 927 }
 928
 929 int make_null_stdio(void) {
 930         int null_fd, r;
 931
 932         null_fd = open("/dev/null", O_RDWR|O_NOCTTY|O_CLOEXEC);
 933         if (null_fd < 0)
 934                 return -errno;
 935
 936         r = make_stdio(null_fd);
 937
 938         reset_terminal_feature_caches();
 939
 940         return r;
 941 }
 942
 943 int getttyname_malloc(int fd, char **ret) {
 944         size_t l = 100;
 945         int r;
 946
 947         assert(fd >= 0);
 948         assert(ret);
 949
 950         for (;;) {
 951                 char path[l];
 952
 953                 r = ttyname_r(fd, path, sizeof(path));
 954                 if (r == 0) {
 955                         char *c;
 956
 957                         c = strdup(skip_dev_prefix(path));
 958                         if (!c)
 959                                 return -ENOMEM;
 960
 961                         *ret = c;
 962                         return 0;
 963                 }
 964
 965                 if (r != ERANGE)
 966                         return -r;
 967
 968                 l *= 2;
 969         }
 970
 971         return 0;
 972 }
 973
 974 int getttyname_harder(int fd, char **r) {
 975         int k;
 976         char *s = NULL;
 977
 978         k = getttyname_malloc(fd, &s);
 979         if (k < 0)
 980                 return k;
 981
 982         if (streq(s, "tty")) {
 983                 free(s);
 984                 return get_ctty(0, NULL, r);
 985         }
 986
 987         *r = s;
 988         return 0;
 989 }
 990
 991 int get_ctty_devnr(pid_t pid, dev_t *d) {
 992         int r;
 993         _cleanup_free_ char *line = NULL;
 994         const char *p;
 995         unsigned long ttynr;
 996
 997         assert(pid >= 0);
 998
 999         p = procfs_file_alloca(pid, "stat");
1000         r = read_one_line_file(p, &line);
1001         if (r < 0)
1002                 return r;
1003
1004         p = strrchr(line, ')');
1005         if (!p)
1006                 return -EIO;
1007
1008         p++;
1009
1010         if (sscanf(p, " "
1011                    "%*c "  /* state */
1012                    "%*d "  /* ppid */
1013                    "%*d "  /* pgrp */
1014                    "%*d "  /* session */
1015                    "%lu ", /* ttynr */
1016                    &ttynr) != 1)
1017                 return -EIO;
1018
1019         if (major(ttynr) == 0 && minor(ttynr) == 0)
1020                 return -ENXIO;
1021
1022         if (d)
1023                 *d = (dev_t) ttynr;
1024
1025         return 0;
1026 }
1027
1028 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
1029         char fn[STRLEN("/dev/char/") + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
1030         _cleanup_free_ char *s = NULL;
1031         const char *p;
1032         dev_t devnr;
1033         int k;
1034
1035         assert(r);
1036
1037         k = get_ctty_devnr(pid, &devnr);
1038         if (k < 0)
1039                 return k;
1040
1041         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
1042
1043         k = readlink_malloc(fn, &s);
1044         if (k < 0) {
1045
1046                 if (k != -ENOENT)
1047                         return k;
1048
1049                 /* This is an ugly hack */
1050                 if (major(devnr) == 136) {
1051                         if (asprintf(&b, "pts/%u", minor(devnr)) < 0)
1052                                 return -ENOMEM;
1053                 } else {
1054                         /* Probably something like the ptys which have no
1055                          * symlink in /dev/char. Let's return something
1056                          * vaguely useful. */
1057
1058                         b = strdup(fn + 5);
1059                         if (!b)
1060                                 return -ENOMEM;
1061                 }
1062         } else {
1063                 if (startswith(s, "/dev/"))
1064                         p = s + 5;
1065                 else if (startswith(s, "../"))
1066                         p = s + 3;
1067                 else
1068                         p = s;
1069
1070                 b = strdup(p);
1071                 if (!b)
1072                         return -ENOMEM;
1073         }
1074
1075         *r = b;
1076         if (_devnr)
1077                 *_devnr = devnr;
1078
1079         return 0;
1080 }
1081
1082 int ptsname_malloc(int fd, char **ret) {
1083         size_t l = 100;
1084
1085         assert(fd >= 0);
1086         assert(ret);
1087
1088         for (;;) {
1089                 char *c;
1090
1091                 c = new(char, l);
1092                 if (!c)
1093                         return -ENOMEM;
1094
1095                 if (ptsname_r(fd, c, l) == 0) {
1096                         *ret = c;
1097                         return 0;
1098                 }
1099                 if (errno != ERANGE) {
1100                         free(c);
1101                         return -errno;
1102                 }
1103
1104                 free(c);
1105                 l *= 2;
1106         }
1107 }
1108
1109 int ptsname_namespace(int pty, char **ret) {
1110         int no = -1, r;
1111
1112         /* Like ptsname(), but doesn't assume that the path is
1113          * accessible in the local namespace. */
1114
1115         r = ioctl(pty, TIOCGPTN, &no);
1116         if (r < 0)
1117                 return -errno;
1118
1119         if (no < 0)
1120                 return -EIO;
1121
1122         if (asprintf(ret, "/dev/pts/%i", no) < 0)
1123                 return -ENOMEM;
1124
1125         return 0;
1126 }
1127
1128 int openpt_in_namespace(pid_t pid, int flags) {
1129         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
1130         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1131         pid_t child;
1132         int r;
1133
1134         assert(pid > 0);
1135
1136         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
1137         if (r < 0)
1138                 return r;
1139
1140         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1141                 return -errno;
1142
1143         r = safe_fork("(sd-openpt)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &child);
1144         if (r < 0)
1145                 return r;
1146         if (r == 0) {
1147                 int master;
1148
1149                 pair[0] = safe_close(pair[0]);
1150
1151                 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
1152                 if (r < 0)
1153                         _exit(EXIT_FAILURE);
1154
1155                 master = posix_openpt(flags|O_NOCTTY|O_CLOEXEC);
1156                 if (master < 0)
1157                         _exit(EXIT_FAILURE);
1158
1159                 if (unlockpt(master) < 0)
1160                         _exit(EXIT_FAILURE);
1161
1162                 if (send_one_fd(pair[1], master, 0) < 0)
1163                         _exit(EXIT_FAILURE);
1164
1165                 _exit(EXIT_SUCCESS);
1166         }
1167
1168         pair[1] = safe_close(pair[1]);
1169
1170         r = wait_for_terminate_and_check("(sd-openpt)", child, 0);
1171         if (r < 0)
1172                 return r;
1173         if (r != EXIT_SUCCESS)
1174                 return -EIO;
1175
1176         return receive_one_fd(pair[0], 0);
1177 }
1178
1179 int open_terminal_in_namespace(pid_t pid, const char *name, int mode) {
1180         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
1181         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1182         pid_t child;
1183         int r;
1184
1185         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
1186         if (r < 0)
1187                 return r;
1188
1189         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1190                 return -errno;
1191
1192         r = safe_fork("(sd-terminal)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &child);
1193         if (r < 0)
1194                 return r;
1195         if (r == 0) {
1196                 int master;
1197
1198                 pair[0] = safe_close(pair[0]);
1199
1200                 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
1201                 if (r < 0)
1202                         _exit(EXIT_FAILURE);
1203
1204                 master = open_terminal(name, mode|O_NOCTTY|O_CLOEXEC);
1205                 if (master < 0)
1206                         _exit(EXIT_FAILURE);
1207
1208                 if (send_one_fd(pair[1], master, 0) < 0)
1209                         _exit(EXIT_FAILURE);
1210
1211                 _exit(EXIT_SUCCESS);
1212         }
1213
1214         pair[1] = safe_close(pair[1]);
1215
1216         r = wait_for_terminate_and_check("(sd-terminal)", child, 0);
1217         if (r < 0)
1218                 return r;
1219         if (r != EXIT_SUCCESS)
1220                 return -EIO;
1221
1222         return receive_one_fd(pair[0], 0);
1223 }
1224
1225 static bool getenv_terminal_is_dumb(void) {
1226         const char *e;
1227
1228         e = getenv("TERM");
1229         if (!e)
1230                 return true;
1231
1232         return streq(e, "dumb");
1233 }
1234
1235 bool terminal_is_dumb(void) {
1236         if (!on_tty())
1237                 return true;
1238
1239         return getenv_terminal_is_dumb();
1240 }
1241
1242 bool colors_enabled(void) {
1243
1244         /* Returns true if colors are considered supported on our stdout. For that we check $SYSTEMD_COLORS first
1245          * (which is the explicit way to turn colors on/off). If that didn't work we turn colors off unless we are on a
1246          * 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
1247          * we are PID 1 then we do not check whether we are connected to a TTY, because we don't keep /dev/console open
1248          * continously due to fear of SAK, and hence things are a bit weird. */
1249
1250         if (cached_colors_enabled < 0) {
1251                 int val;
1252
1253                 val = getenv_bool("SYSTEMD_COLORS");
1254                 if (val >= 0)
1255                         cached_colors_enabled = val;
1256                 else if (getpid_cached() == 1)
1257                         /* PID1 outputs to the console without holding it open all the time */
1258                         cached_colors_enabled = !getenv_terminal_is_dumb();
1259                 else
1260                         cached_colors_enabled = !terminal_is_dumb();
1261         }
1262
1263         return cached_colors_enabled;
1264 }
1265
1266 bool dev_console_colors_enabled(void) {
1267         _cleanup_free_ char *s = NULL;
1268         int b;
1269
1270         /* Returns true if we assume that color is supported on /dev/console.
1271          *
1272          * For that we first check if we explicitly got told to use colors or not, by checking $SYSTEMD_COLORS. If that
1273          * isn't set we check whether PID 1 has $TERM set, and if not, whether TERM is set on the kernel command
1274          * line. If we find $TERM set we assume color if it's not set to "dumb", similarly to how regular
1275          * colors_enabled() operates. */
1276
1277         b = getenv_bool("SYSTEMD_COLORS");
1278         if (b >= 0)
1279                 return b;
1280
1281         if (getenv_for_pid(1, "TERM", &s) <= 0)
1282                 (void) proc_cmdline_get_key("TERM", 0, &s);
1283
1284         return !streq_ptr(s, "dumb");
1285 }
1286
1287 bool underline_enabled(void) {
1288
1289         if (cached_underline_enabled < 0) {
1290
1291                 /* The Linux console doesn't support underlining, turn it off, but only there. */
1292
1293                 if (colors_enabled())
1294                         cached_underline_enabled = !streq_ptr(getenv("TERM"), "linux");
1295                 else
1296                         cached_underline_enabled = false;
1297         }
1298
1299         return cached_underline_enabled;
1300 }
1301
1302 int vt_default_utf8(void) {
1303         _cleanup_free_ char *b = NULL;
1304         int r;
1305
1306         /* Read the default VT UTF8 setting from the kernel */
1307
1308         r = read_one_line_file("/sys/module/vt/parameters/default_utf8", &b);
1309         if (r < 0)
1310                 return r;
1311
1312         return parse_boolean(b);
1313 }
1314
1315 int vt_reset_keyboard(int fd) {
1316         int kb;
1317
1318         /* If we can't read the default, then default to unicode. It's 2017 after all. */
1319         kb = vt_default_utf8() != 0 ? K_UNICODE : K_XLATE;
1320
1321         if (ioctl(fd, KDSKBMODE, kb) < 0)
1322                 return -errno;
1323
1324         return 0;
1325 }