src/getty-generator/getty-generator.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26
  27 #include "log.h"
  28 #include "util.h"
  29 #include "mkdir.h"
  30 #include "unit-name.h"
  31 #include "virt.h"
  32 #include "fileio.h"
  33 #include "path-util.h"
  34
  35 static const char *arg_dest = "/tmp";
  36
  37 static int add_symlink(const char *fservice, const char *tservice) {
  38         char *from, *to;
  39         int r;
  40
  41         assert(fservice);
  42         assert(tservice);
  43
  44         from = strappenda(SYSTEM_DATA_UNIT_PATH "/", fservice);
  45         to = strappenda(arg_dest, "/getty.target.wants/", tservice);
  46
  47         mkdir_parents_label(to, 0755);
  48
  49         r = symlink(from, to);
  50         if (r < 0) {
  51                 if (errno == EEXIST)
  52                         /* In case console=hvc0 is passed this will very likely result in EEXIST */
  53                         return 0;
  54                 else {
  55                         log_error_errno(errno, "Failed to create symlink %s: %m", to);
  56                         return -errno;
  57                 }
  58         }
  59
  60         return 0;
  61 }
  62
  63 static int add_serial_getty(const char *tty) {
  64         _cleanup_free_ char *n = NULL;
  65
  66         assert(tty);
  67
  68         log_debug("Automatically adding serial getty for /dev/%s.", tty);
  69
  70         n = unit_name_from_path_instance("serial-getty", tty, ".service");
  71         if (!n)
  72                 return log_oom();
  73
  74         return add_symlink("serial-getty@.service", n);
  75 }
  76
  77 static int add_container_getty(const char *tty) {
  78         _cleanup_free_ char *n = NULL;
  79
  80         assert(tty);
  81
  82         log_debug("Automatically adding container getty for /dev/pts/%s.", tty);
  83
  84         n = unit_name_from_path_instance("container-getty", tty, ".service");
  85         if (!n)
  86                 return log_oom();
  87
  88         return add_symlink("container-getty@.service", n);
  89 }
  90
  91 static int verify_tty(const char *name) {
  92         _cleanup_close_ int fd = -1;
  93         const char *p;
  94
  95         /* Some TTYs are weird and have been enumerated but don't work
  96          * when you try to use them, such as classic ttyS0 and
  97          * friends. Let's check that and open the device and run
  98          * isatty() on it. */
  99
 100         p = strappenda("/dev/", name);
 101
 102         /* O_NONBLOCK is essential here, to make sure we don't wait
 103          * for DCD */
 104         fd = open(p, O_RDWR|O_NONBLOCK|O_NOCTTY|O_CLOEXEC|O_NOFOLLOW);
 105         if (fd < 0)
 106                 return -errno;
 107
 108         errno = 0;
 109         if (isatty(fd) <= 0)
 110                 return errno ? -errno : -EIO;
 111
 112         return 0;
 113 }
 114
 115 int main(int argc, char *argv[]) {
 116
 117         static const char virtualization_consoles[] =
 118                 "hvc0\0"
 119                 "xvc0\0"
 120                 "hvsi0\0"
 121                 "sclp_line0\0"
 122                 "ttysclp0\0"
 123                 "3270!tty1\0";
 124
 125         _cleanup_free_ char *active = NULL;
 126         const char *j;
 127         int r;
 128
 129         if (argc > 1 && argc != 4) {
 130                 log_error("This program takes three or no arguments.");
 131                 return EXIT_FAILURE;
 132         }
 133
 134         if (argc > 1)
 135                 arg_dest = argv[1];
 136
 137         log_set_target(LOG_TARGET_SAFE);
 138         log_parse_environment();
 139         log_open();
 140
 141         umask(0022);
 142
 143         if (detect_container(NULL) > 0) {
 144                 _cleanup_free_ char *container_ttys = NULL;
 145
 146                 log_debug("Automatically adding console shell.");
 147
 148                 if (add_symlink("console-getty.service", "console-getty.service") < 0)
 149                         return EXIT_FAILURE;
 150
 151                 /* When $container_ttys is set for PID 1, spawn
 152                  * gettys on all ptys named therein. Note that despite
 153                  * the variable name we only support ptys here. */
 154
 155                 r = getenv_for_pid(1, "container_ttys", &container_ttys);
 156                 if (r > 0) {
 157                         const char *word, *state;
 158                         size_t l;
 159
 160                         FOREACH_WORD(word, l, container_ttys, state) {
 161                                 const char *t;
 162                                 char tty[l + 1];
 163
 164                                 memcpy(tty, word, l);
 165                                 tty[l] = 0;
 166
 167                                 /* First strip off /dev/ if it is specified */
 168                                 t = path_startswith(tty, "/dev/");
 169                                 if (!t)
 170                                         t = tty;
 171
 172                                 /* Then, make sure it's actually a pty */
 173                                 t = path_startswith(t, "pts/");
 174                                 if (!t)
 175                                         continue;
 176
 177                                 if (add_container_getty(t) < 0)
 178                                         return EXIT_FAILURE;
 179                         }
 180                 }
 181
 182                 /* Don't add any further magic if we are in a container */
 183                 return EXIT_SUCCESS;
 184         }
 185
 186         if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
 187                 const char *word, *state;
 188                 size_t l;
 189
 190                 /* Automatically add in a serial getty on all active
 191                  * kernel consoles */
 192                 FOREACH_WORD(word, l, active, state) {
 193                         _cleanup_free_ char *tty = NULL;
 194
 195                         tty = strndup(word, l);
 196                         if (!tty) {
 197                                 log_oom();
 198                                 return EXIT_FAILURE;
 199                         }
 200
 201                         if (isempty(tty) || tty_is_vc(tty))
 202                                 continue;
 203
 204                         if (verify_tty(tty) < 0)
 205                                 continue;
 206
 207                         /* We assume that gettys on virtual terminals are
 208                          * started via manual configuration and do this magic
 209                          * only for non-VC terminals. */
 210
 211                         if (add_serial_getty(tty) < 0)
 212                                 return EXIT_FAILURE;
 213                 }
 214         }
 215
 216         /* Automatically add in a serial getty on the first
 217          * virtualizer console */
 218         NULSTR_FOREACH(j, virtualization_consoles) {
 219                 char *p;
 220
 221                 p = strappenda("/sys/class/tty/", j);
 222                 if (access(p, F_OK) < 0)
 223                         continue;
 224
 225                 if (add_serial_getty(j) < 0)
 226                         return EXIT_FAILURE;
 227         }
 228
 229         return EXIT_SUCCESS;
 230 }