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