src/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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU 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
  26 #include "log.h"
  27 #include "util.h"
  28 #include "mkdir.h"
  29 #include "unit-name.h"
  30 #include "virt.h"
  31
  32 static const char *arg_dest = "/tmp";
  33
  34 static int add_symlink(const char *fservice, const char *tservice) {
  35         char *from = NULL, *to = NULL;
  36         int r;
  37
  38         assert(fservice);
  39         assert(tservice);
  40
  41         asprintf(&from, SYSTEM_DATA_UNIT_PATH "/%s", fservice);
  42         asprintf(&to, "%s/getty.target.wants/%s", arg_dest, tservice);
  43
  44         if (!from || !to) {
  45                 log_error("Out of memory");
  46                 r = -ENOMEM;
  47                 goto finish;
  48         }
  49
  50         mkdir_parents(to, 0755);
  51
  52         r = symlink(from, to);
  53         if (r < 0) {
  54                 if (errno == EEXIST)
  55                         /* In case console=hvc0 is passed this will very likely result in EEXIST */
  56                         r = 0;
  57                 else {
  58                         log_error("Failed to create symlink from %s to %s: %m", from, to);
  59                         r = -errno;
  60                 }
  61         }
  62
  63 finish:
  64
  65         free(from);
  66         free(to);
  67
  68         return r;
  69 }
  70
  71 static int add_serial_getty(const char *tty) {
  72         char *n;
  73         int r;
  74
  75         assert(tty);
  76
  77         log_debug("Automatically adding serial getty for /dev/%s.", tty);
  78
  79         n = unit_name_replace_instance("serial-getty@.service", tty);
  80         if (!n) {
  81                 log_error("Out of memory");
  82                 return -ENOMEM;
  83         }
  84
  85         r = add_symlink("serial-getty@.service", n);
  86         free(n);
  87
  88         return r;
  89 }
  90
  91 int main(int argc, char *argv[]) {
  92
  93         static const char virtualization_consoles[] =
  94                 "hvc0\0"
  95                 "xvc0\0"
  96                 "hvsi0\0";
  97
  98         int r = EXIT_SUCCESS;
  99         char *active;
 100         const char *j;
 101
 102         if (argc > 2) {
 103                 log_error("This program takes one or no arguments.");
 104                 return EXIT_FAILURE;
 105         }
 106
 107         log_set_target(LOG_TARGET_AUTO);
 108         log_parse_environment();
 109         log_open();
 110
 111         umask(0022);
 112
 113         if (argc > 1)
 114             arg_dest = argv[1];
 115
 116         if (detect_container(NULL) > 0) {
 117                 log_debug("Automatically adding console shell.");
 118
 119                 if (add_symlink("console-shell.service", "console-shell.service") < 0)
 120                         r = EXIT_FAILURE;
 121
 122                 /* Don't add any further magic if we are in a container */
 123                 goto finish;
 124         }
 125
 126         if (read_one_line_file("/sys/class/tty/console/active", &active) >= 0) {
 127                 const char *tty;
 128
 129                 tty = strrchr(active, ' ');
 130                 if (tty)
 131                         tty ++;
 132                 else
 133                         tty = active;
 134
 135                 /* Automatically add in a serial getty on the kernel
 136                  * console */
 137                 if (tty_is_vc(tty))
 138                         free(active);
 139                 else {
 140                         int k;
 141
 142                         /* We assume that gettys on virtual terminals are
 143                          * started via manual configuration and do this magic
 144                          * only for non-VC terminals. */
 145
 146                         k = add_serial_getty(tty);
 147                         free(active);
 148
 149                         if (k < 0) {
 150                                 r = EXIT_FAILURE;
 151                                 goto finish;
 152                         }
 153                 }
 154         }
 155
 156         /* Automatically add in a serial getty on the first
 157          * virtualizer console */
 158         NULSTR_FOREACH(j, virtualization_consoles) {
 159                 char *p;
 160                 int k;
 161
 162                 if (asprintf(&p, "/sys/class/tty/%s", j) < 0) {
 163                         log_error("Out of memory");
 164                         r = EXIT_FAILURE;
 165                         goto finish;
 166                 }
 167
 168                 k = access(p, F_OK);
 169                 free(p);
 170
 171                 if (k < 0)
 172                         continue;
 173
 174                 k = add_serial_getty(j);
 175                 if (k < 0) {
 176                         r = EXIT_FAILURE;
 177                         goto finish;
 178                 }
 179         }
 180
 181 finish:
 182         return r;
 183 }