src/vconsole/vconsole-setup.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 Kay Sievers
   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 <stdio.h>
  23 #include <unistd.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <string.h>
  27 #include <fcntl.h>
  28 #include <ctype.h>
  29 #include <stdbool.h>
  30 #include <stdarg.h>
  31 #include <limits.h>
  32 #include <sys/ioctl.h>
  33 #include <sys/wait.h>
  34 #include <linux/tiocl.h>
  35 #include <linux/kd.h>
  36 #include <linux/vt.h>
  37
  38 #include "util.h"
  39 #include "log.h"
  40 #include "macro.h"
  41 #include "virt.h"
  42 #include "fileio.h"
  43
  44 static bool is_vconsole(int fd) {
  45         unsigned char data[1];
  46
  47         data[0] = TIOCL_GETFGCONSOLE;
  48         return ioctl(fd, TIOCLINUX, data) >= 0;
  49 }
  50
  51 static int disable_utf8(int fd) {
  52         int r = 0, k;
  53
  54         if (ioctl(fd, KDSKBMODE, K_XLATE) < 0)
  55                 r = -errno;
  56
  57         if (loop_write(fd, "\033%@", 3, false) < 0)
  58                 r = -errno;
  59
  60         k = write_string_file("/sys/module/vt/parameters/default_utf8", "0");
  61         if (k < 0)
  62                 r = k;
  63
  64         if (r < 0)
  65                 log_warning("Failed to disable UTF-8: %s", strerror(-r));
  66
  67         return r;
  68 }
  69
  70 static int enable_utf8(int fd) {
  71         int r = 0, k;
  72         long current = 0;
  73
  74         if (ioctl(fd, KDGKBMODE, &current) < 0 || current == K_XLATE) {
  75                 /*
  76                  * Change the current keyboard to unicode, unless it
  77                  * is currently in raw or off mode anyway. We
  78                  * shouldn't interfere with X11's processing of the
  79                  * key events.
  80                  *
  81                  * http://lists.freedesktop.org/archives/systemd-devel/2013-February/008573.html
  82                  *
  83                  */
  84
  85                 if (ioctl(fd, KDSKBMODE, K_UNICODE) < 0)
  86                         r = -errno;
  87         }
  88
  89         if (loop_write(fd, "\033%G", 3, false) < 0)
  90                 r = -errno;
  91
  92         k = write_string_file("/sys/module/vt/parameters/default_utf8", "1");
  93         if (k < 0)
  94                 r = k;
  95
  96         if (r < 0)
  97                 log_warning("Failed to enable UTF-8: %s", strerror(-r));
  98
  99         return r;
 100 }
 101
 102 static int keymap_load(const char *vc, const char *map, const char *map_toggle, bool utf8, pid_t *_pid) {
 103         const char *args[8];
 104         int i = 0;
 105         pid_t pid;
 106
 107         if (isempty(map)) {
 108                 /* An empty map means kernel map */
 109                 *_pid = 0;
 110                 return 0;
 111         }
 112
 113         args[i++] = KBD_LOADKEYS;
 114         args[i++] = "-q";
 115         args[i++] = "-C";
 116         args[i++] = vc;
 117         if (utf8)
 118                 args[i++] = "-u";
 119         args[i++] = map;
 120         if (map_toggle)
 121                 args[i++] = map_toggle;
 122         args[i++] = NULL;
 123
 124         pid = fork();
 125         if (pid < 0) {
 126                 log_error("Failed to fork: %m");
 127                 return -errno;
 128         } else if (pid == 0) {
 129                 execv(args[0], (char **) args);
 130                 _exit(EXIT_FAILURE);
 131         }
 132
 133         *_pid = pid;
 134         return 0;
 135 }
 136
 137 static int font_load(const char *vc, const char *font, const char *map, const char *unimap, pid_t *_pid) {
 138         const char *args[9];
 139         int i = 0;
 140         pid_t pid;
 141
 142         if (isempty(font)) {
 143                 /* An empty font means kernel font */
 144                 *_pid = 0;
 145                 return 0;
 146         }
 147
 148         args[i++] = KBD_SETFONT;
 149         args[i++] = "-C";
 150         args[i++] = vc;
 151         args[i++] = font;
 152         if (map) {
 153                 args[i++] = "-m";
 154                 args[i++] = map;
 155         }
 156         if (unimap) {
 157                 args[i++] = "-u";
 158                 args[i++] = unimap;
 159         }
 160         args[i++] = NULL;
 161
 162         pid = fork();
 163         if (pid < 0) {
 164                 log_error("Failed to fork: %m");
 165                 return -errno;
 166         } else if (pid == 0) {
 167                 execv(args[0], (char **) args);
 168                 _exit(EXIT_FAILURE);
 169         }
 170
 171         *_pid = pid;
 172         return 0;
 173 }
 174
 175 /*
 176  * A newly allocated VT uses the font from the active VT. Here
 177  * we update all possibly already allocated VTs with the configured
 178  * font. It also allows to restart systemd-vconsole-setup.service,
 179  * to apply a new font to all VTs.
 180  */
 181 static void font_copy_to_all_vcs(int fd) {
 182         struct vt_stat vcs = {};
 183         int i, r;
 184
 185         /* get active, and 16 bit mask of used VT numbers */
 186         r = ioctl(fd, VT_GETSTATE, &vcs);
 187         if (r < 0)
 188                 return;
 189
 190         for (i = 1; i <= 15; i++) {
 191                 char vcname[16];
 192                 _cleanup_close_ int vcfd = -1;
 193                 struct console_font_op cfo = {};
 194
 195                 if (i == vcs.v_active)
 196                         continue;
 197
 198                 /* skip non-allocated ttys */
 199                 snprintf(vcname, sizeof(vcname), "/dev/vcs%i", i);
 200                 if (access(vcname, F_OK) < 0)
 201                         continue;
 202
 203                 snprintf(vcname, sizeof(vcname), "/dev/tty%i", i);
 204                 vcfd = open_terminal(vcname, O_RDWR|O_CLOEXEC);
 205                 if (vcfd < 0)
 206                         continue;
 207
 208                 /* copy font from active VT, where the font was uploaded to */
 209                 cfo.op = KD_FONT_OP_COPY;
 210                 cfo.height = vcs.v_active-1; /* tty1 == index 0 */
 211                 ioctl(vcfd, KDFONTOP, &cfo);
 212         }
 213 }
 214
 215 int main(int argc, char **argv) {
 216         const char *vc;
 217         char *vc_keymap = NULL;
 218         char *vc_keymap_toggle = NULL;
 219         char *vc_font = NULL;
 220         char *vc_font_map = NULL;
 221         char *vc_font_unimap = NULL;
 222         int fd = -1;
 223         bool utf8;
 224         pid_t font_pid = 0, keymap_pid = 0;
 225         bool font_copy = false;
 226         int r = EXIT_FAILURE;
 227
 228         log_set_target(LOG_TARGET_AUTO);
 229         log_parse_environment();
 230         log_open();
 231
 232         umask(0022);
 233
 234         if (argv[1])
 235                 vc = argv[1];
 236         else {
 237                 vc = "/dev/tty0";
 238                 font_copy = true;
 239         }
 240
 241         fd = open_terminal(vc, O_RDWR|O_CLOEXEC);
 242         if (fd < 0) {
 243                 log_error("Failed to open %s: %m", vc);
 244                 goto finish;
 245         }
 246
 247         if (!is_vconsole(fd)) {
 248                 log_error("Device %s is not a virtual console.", vc);
 249                 goto finish;
 250         }
 251
 252         utf8 = is_locale_utf8();
 253
 254         r = parse_env_file("/etc/vconsole.conf", NEWLINE,
 255                            "KEYMAP", &vc_keymap,
 256                            "KEYMAP_TOGGLE", &vc_keymap_toggle,
 257                            "FONT", &vc_font,
 258                            "FONT_MAP", &vc_font_map,
 259                            "FONT_UNIMAP", &vc_font_unimap,
 260                            NULL);
 261
 262         if (r < 0 && r != -ENOENT)
 263                 log_warning("Failed to read /etc/vconsole.conf: %s", strerror(-r));
 264
 265         /* Let the kernel command line override /etc/vconsole.conf */
 266         if (detect_container(NULL) <= 0) {
 267                 r = parse_env_file("/proc/cmdline", WHITESPACE,
 268                                    "vconsole.keymap", &vc_keymap,
 269                                    "vconsole.keymap.toggle", &vc_keymap_toggle,
 270                                    "vconsole.font", &vc_font,
 271                                    "vconsole.font.map", &vc_font_map,
 272                                    "vconsole.font.unimap", &vc_font_unimap,
 273                                    NULL);
 274
 275                 if (r < 0 && r != -ENOENT)
 276                         log_warning("Failed to read /proc/cmdline: %s", strerror(-r));
 277         }
 278
 279         if (utf8)
 280                 enable_utf8(fd);
 281         else
 282                 disable_utf8(fd);
 283
 284         r = EXIT_FAILURE;
 285         if (keymap_load(vc, vc_keymap, vc_keymap_toggle, utf8, &keymap_pid) >= 0 &&
 286             font_load(vc, vc_font, vc_font_map, vc_font_unimap, &font_pid) >= 0)
 287                 r = EXIT_SUCCESS;
 288
 289 finish:
 290         if (keymap_pid > 0)
 291                 wait_for_terminate_and_warn(KBD_LOADKEYS, keymap_pid);
 292
 293         if (font_pid > 0) {
 294                 wait_for_terminate_and_warn(KBD_SETFONT, font_pid);
 295                 if (font_copy)
 296                         font_copy_to_all_vcs(fd);
 297         }
 298
 299         free(vc_keymap);
 300         free(vc_font);
 301         free(vc_font_map);
 302         free(vc_font_unimap);
 303
 304         safe_close(fd);
 305
 306         return r;
 307 }