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 = 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 getttyname_malloc(int fd, char **ret) {
 909         size_t l = 100;
 910         int r;
 911
 912         assert(fd >= 0);
 913         assert(ret);
 914
 915         for (;;) {
 916                 char path[l];
 917
 918                 r = ttyname_r(fd, path, sizeof(path));
 919                 if (r == 0) {
 920                         char *c;
 921
 922                         c = strdup(skip_dev_prefix(path));
 923                         if (!c)
 924                                 return -ENOMEM;
 925
 926                         *ret = c;
 927                         return 0;
 928                 }
 929
 930                 if (r != ERANGE)
 931                         return -r;
 932
 933                 l *= 2;
 934         }
 935
 936         return 0;
 937 }
 938
 939 int getttyname_harder(int fd, char **r) {
 940         int k;
 941         char *s = NULL;
 942
 943         k = getttyname_malloc(fd, &s);
 944         if (k < 0)
 945                 return k;
 946
 947         if (streq(s, "tty")) {
 948                 free(s);
 949                 return get_ctty(0, NULL, r);
 950         }
 951
 952         *r = s;
 953         return 0;
 954 }
 955
 956 int get_ctty_devnr(pid_t pid, dev_t *d) {
 957         int r;
 958         _cleanup_free_ char *line = NULL;
 959         const char *p;
 960         unsigned long ttynr;
 961
 962         assert(pid >= 0);
 963
 964         p = procfs_file_alloca(pid, "stat");
 965         r = read_one_line_file(p, &line);
 966         if (r < 0)
 967                 return r;
 968
 969         p = strrchr(line, ')');
 970         if (!p)
 971                 return -EIO;
 972
 973         p++;
 974
 975         if (sscanf(p, " "
 976                    "%*c "  /* state */
 977                    "%*d "  /* ppid */
 978                    "%*d "  /* pgrp */
 979                    "%*d "  /* session */
 980                    "%lu ", /* ttynr */
 981                    &ttynr) != 1)
 982                 return -EIO;
 983
 984         if (major(ttynr) == 0 && minor(ttynr) == 0)
 985                 return -ENXIO;
 986
 987         if (d)
 988                 *d = (dev_t) ttynr;
 989
 990         return 0;
 991 }
 992
 993 int get_ctty(pid_t pid, dev_t *_devnr, char **r) {
 994         char fn[STRLEN("/dev/char/") + 2*DECIMAL_STR_MAX(unsigned) + 1 + 1], *b = NULL;
 995         _cleanup_free_ char *s = NULL;
 996         const char *p;
 997         dev_t devnr;
 998         int k;
 999
1000         assert(r);
1001
1002         k = get_ctty_devnr(pid, &devnr);
1003         if (k < 0)
1004                 return k;
1005
1006         sprintf(fn, "/dev/char/%u:%u", major(devnr), minor(devnr));
1007
1008         k = readlink_malloc(fn, &s);
1009         if (k < 0) {
1010
1011                 if (k != -ENOENT)
1012                         return k;
1013
1014                 /* This is an ugly hack */
1015                 if (major(devnr) == 136) {
1016                         if (asprintf(&b, "pts/%u", minor(devnr)) < 0)
1017                                 return -ENOMEM;
1018                 } else {
1019                         /* Probably something like the ptys which have no
1020                          * symlink in /dev/char. Let's return something
1021                          * vaguely useful. */
1022
1023                         b = strdup(fn + 5);
1024                         if (!b)
1025                                 return -ENOMEM;
1026                 }
1027         } else {
1028                 if (startswith(s, "/dev/"))
1029                         p = s + 5;
1030                 else if (startswith(s, "../"))
1031                         p = s + 3;
1032                 else
1033                         p = s;
1034
1035                 b = strdup(p);
1036                 if (!b)
1037                         return -ENOMEM;
1038         }
1039
1040         *r = b;
1041         if (_devnr)
1042                 *_devnr = devnr;
1043
1044         return 0;
1045 }
1046
1047 int ptsname_malloc(int fd, char **ret) {
1048         size_t l = 100;
1049
1050         assert(fd >= 0);
1051         assert(ret);
1052
1053         for (;;) {
1054                 char *c;
1055
1056                 c = new(char, l);
1057                 if (!c)
1058                         return -ENOMEM;
1059
1060                 if (ptsname_r(fd, c, l) == 0) {
1061                         *ret = c;
1062                         return 0;
1063                 }
1064                 if (errno != ERANGE) {
1065                         free(c);
1066                         return -errno;
1067                 }
1068
1069                 free(c);
1070                 l *= 2;
1071         }
1072 }
1073
1074 int ptsname_namespace(int pty, char **ret) {
1075         int no = -1, r;
1076
1077         /* Like ptsname(), but doesn't assume that the path is
1078          * accessible in the local namespace. */
1079
1080         r = ioctl(pty, TIOCGPTN, &no);
1081         if (r < 0)
1082                 return -errno;
1083
1084         if (no < 0)
1085                 return -EIO;
1086
1087         if (asprintf(ret, "/dev/pts/%i", no) < 0)
1088                 return -ENOMEM;
1089
1090         return 0;
1091 }
1092
1093 int openpt_in_namespace(pid_t pid, int flags) {
1094         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
1095         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1096         pid_t child;
1097         int r;
1098
1099         assert(pid > 0);
1100
1101         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
1102         if (r < 0)
1103                 return r;
1104
1105         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1106                 return -errno;
1107
1108         r = safe_fork("(sd-openpt)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &child);
1109         if (r < 0)
1110                 return r;
1111         if (r == 0) {
1112                 int master;
1113
1114                 pair[0] = safe_close(pair[0]);
1115
1116                 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
1117                 if (r < 0)
1118                         _exit(EXIT_FAILURE);
1119
1120                 master = posix_openpt(flags|O_NOCTTY|O_CLOEXEC);
1121                 if (master < 0)
1122                         _exit(EXIT_FAILURE);
1123
1124                 if (unlockpt(master) < 0)
1125                         _exit(EXIT_FAILURE);
1126
1127                 if (send_one_fd(pair[1], master, 0) < 0)
1128                         _exit(EXIT_FAILURE);
1129
1130                 _exit(EXIT_SUCCESS);
1131         }
1132
1133         pair[1] = safe_close(pair[1]);
1134
1135         r = wait_for_terminate_and_check("(sd-openpt)", child, 0);
1136         if (r < 0)
1137                 return r;
1138         if (r != EXIT_SUCCESS)
1139                 return -EIO;
1140
1141         return receive_one_fd(pair[0], 0);
1142 }
1143
1144 int open_terminal_in_namespace(pid_t pid, const char *name, int mode) {
1145         _cleanup_close_ int pidnsfd = -1, mntnsfd = -1, usernsfd = -1, rootfd = -1;
1146         _cleanup_close_pair_ int pair[2] = { -1, -1 };
1147         pid_t child;
1148         int r;
1149
1150         r = namespace_open(pid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
1151         if (r < 0)
1152                 return r;
1153
1154         if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) < 0)
1155                 return -errno;
1156
1157         r = safe_fork("(sd-terminal)", FORK_RESET_SIGNALS|FORK_DEATHSIG, &child);
1158         if (r < 0)
1159                 return r;
1160         if (r == 0) {
1161                 int master;
1162
1163                 pair[0] = safe_close(pair[0]);
1164
1165                 r = namespace_enter(pidnsfd, mntnsfd, -1, usernsfd, rootfd);
1166                 if (r < 0)
1167                         _exit(EXIT_FAILURE);
1168
1169                 master = open_terminal(name, mode|O_NOCTTY|O_CLOEXEC);
1170                 if (master < 0)
1171                         _exit(EXIT_FAILURE);
1172
1173                 if (send_one_fd(pair[1], master, 0) < 0)
1174                         _exit(EXIT_FAILURE);
1175
1176                 _exit(EXIT_SUCCESS);
1177         }
1178
1179         pair[1] = safe_close(pair[1]);
1180
1181         r = wait_for_terminate_and_check("(sd-terminal)", child, 0);
1182         if (r < 0)
1183                 return r;
1184         if (r != EXIT_SUCCESS)
1185                 return -EIO;
1186
1187         return receive_one_fd(pair[0], 0);
1188 }
1189
1190 static bool getenv_terminal_is_dumb(void) {
1191         const char *e;
1192
1193         e = getenv("TERM");
1194         if (!e)
1195                 return true;
1196
1197         return streq(e, "dumb");
1198 }
1199
1200 bool terminal_is_dumb(void) {
1201         if (!on_tty())
1202                 return true;
1203
1204         return getenv_terminal_is_dumb();
1205 }
1206
1207 bool colors_enabled(void) {
1208
1209         /* Returns true if colors are considered supported on our stdout. For that we check $SYSTEMD_COLORS first
1210          * (which is the explicit way to turn colors on/off). If that didn't work we turn colors off unless we are on a
1211          * 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
1212          * we are PID 1 then we do not check whether we are connected to a TTY, because we don't keep /dev/console open
1213          * continously due to fear of SAK, and hence things are a bit weird. */
1214
1215         if (cached_colors_enabled < 0) {
1216                 int val;
1217
1218                 val = getenv_bool("SYSTEMD_COLORS");
1219                 if (val >= 0)
1220                         cached_colors_enabled = val;
1221                 else if (getpid_cached() == 1)
1222                         /* PID1 outputs to the console without holding it open all the time */
1223                         cached_colors_enabled = !getenv_terminal_is_dumb();
1224                 else
1225                         cached_colors_enabled = !terminal_is_dumb();
1226         }
1227
1228         return cached_colors_enabled;
1229 }
1230
1231 bool dev_console_colors_enabled(void) {
1232         _cleanup_free_ char *s = NULL;
1233         int b;
1234
1235         /* Returns true if we assume that color is supported on /dev/console.
1236          *
1237          * For that we first check if we explicitly got told to use colors or not, by checking $SYSTEMD_COLORS. If that
1238          * isn't set we check whether PID 1 has $TERM set, and if not, whether TERM is set on the kernel command
1239          * line. If we find $TERM set we assume color if it's not set to "dumb", similarly to how regular
1240          * colors_enabled() operates. */
1241
1242         b = getenv_bool("SYSTEMD_COLORS");
1243         if (b >= 0)
1244                 return b;
1245
1246         if (getenv_for_pid(1, "TERM", &s) <= 0)
1247                 (void) proc_cmdline_get_key("TERM", 0, &s);
1248
1249         return !streq_ptr(s, "dumb");
1250 }
1251
1252 bool underline_enabled(void) {
1253
1254         if (cached_underline_enabled < 0) {
1255
1256                 /* The Linux console doesn't support underlining, turn it off, but only there. */
1257
1258                 if (colors_enabled())
1259                         cached_underline_enabled = !streq_ptr(getenv("TERM"), "linux");
1260                 else
1261                         cached_underline_enabled = false;
1262         }
1263
1264         return cached_underline_enabled;
1265 }
1266
1267 int vt_default_utf8(void) {
1268         _cleanup_free_ char *b = NULL;
1269         int r;
1270
1271         /* Read the default VT UTF8 setting from the kernel */
1272
1273         r = read_one_line_file("/sys/module/vt/parameters/default_utf8", &b);
1274         if (r < 0)
1275                 return r;
1276
1277         return parse_boolean(b);
1278 }
1279
1280 int vt_reset_keyboard(int fd) {
1281         int kb;
1282
1283         /* If we can't read the default, then default to unicode. It's 2017 after all. */
1284         kb = vt_default_utf8() != 0 ? K_UNICODE : K_XLATE;
1285
1286         if (ioctl(fd, KDSKBMODE, kb) < 0)
1287                 return -errno;
1288
1289         return 0;
1290 }