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 <locale.h>
  33 #include <langinfo.h>
  34 #include <sys/ioctl.h>
  35 #include <sys/wait.h>
  36 #include <linux/tiocl.h>
  37 #include <linux/kd.h>
  38
  39 #include "util.h"
  40 #include "log.h"
  41 #include "macro.h"
  42 #include "virt.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 bool is_locale_utf8(void) {
  52         const char *set;
  53
  54         if (!setlocale(LC_ALL, ""))
  55                 return true;
  56
  57         set = nl_langinfo(CODESET);
  58         if (!set)
  59                 return true;
  60
  61         return streq(set, "UTF-8");
  62 }
  63
  64 static int disable_utf8(int fd) {
  65         int r = 0, k;
  66
  67         if (ioctl(fd, KDSKBMODE, K_XLATE) < 0)
  68                 r = -errno;
  69
  70         if (loop_write(fd, "\033%@", 3, false) < 0)
  71                 r = -errno;
  72
  73         k = write_one_line_file("/sys/module/vt/parameters/default_utf8", "0");
  74         if (k < 0)
  75                 r = k;
  76
  77         if (r < 0)
  78                 log_warning("Failed to disable UTF-8: %s", strerror(-r));
  79
  80         return r;
  81 }
  82
  83 static int enable_utf8(int fd) {
  84         int r = 0, k;
  85
  86         if (ioctl(fd, KDSKBMODE, K_UNICODE) < 0)
  87                 r = -errno;
  88
  89         if (loop_write(fd, "\033%G", 3, false) < 0)
  90                 r = -errno;
  91
  92         k = write_one_line_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 load_keymap(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 load_font(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 int main(int argc, char **argv) {
 176         const char *vc;
 177         char *vc_keymap = NULL;
 178         char *vc_keymap_toggle = NULL;
 179         char *vc_font = NULL;
 180         char *vc_font_map = NULL;
 181         char *vc_font_unimap = NULL;
 182 #ifdef TARGET_GENTOO
 183         char *vc_unicode = NULL;
 184 #endif
 185 #if defined(TARGET_MANDRIVA) || defined(TARGET_MAGEIA)
 186         char *vc_keytable = NULL;
 187 #endif
 188         int fd = -1;
 189         bool utf8;
 190         int r = EXIT_FAILURE;
 191         pid_t font_pid = 0, keymap_pid = 0;
 192
 193         log_set_target(LOG_TARGET_AUTO);
 194         log_parse_environment();
 195         log_open();
 196
 197         umask(0022);
 198
 199         if (argv[1])
 200                 vc = argv[1];
 201         else
 202                 vc = "/dev/tty0";
 203
 204         fd = open_terminal(vc, O_RDWR|O_CLOEXEC);
 205         if (fd < 0) {
 206                 log_error("Failed to open %s: %m", vc);
 207                 goto finish;
 208         }
 209
 210         if (!is_vconsole(fd)) {
 211                 log_error("Device %s is not a virtual console.", vc);
 212                 goto finish;
 213         }
 214
 215         utf8 = is_locale_utf8();
 216
 217         r = 0;
 218
 219         if (detect_container(NULL) <= 0) {
 220                 r = parse_env_file("/proc/cmdline", WHITESPACE,
 221                                    "vconsole.keymap", &vc_keymap,
 222                                    "vconsole.keymap.toggle", &vc_keymap_toggle,
 223                                    "vconsole.font", &vc_font,
 224                                    "vconsole.font.map", &vc_font_map,
 225                                    "vconsole.font.unimap", &vc_font_unimap,
 226                                    NULL);
 227
 228                 if (r < 0 && r != -ENOENT)
 229                         log_warning("Failed to read /proc/cmdline: %s", strerror(-r));
 230         }
 231
 232         /* Hmm, nothing set on the kernel cmd line? Then let's
 233          * try /etc/vconsole.conf */
 234         if (r <= 0) {
 235                 r = parse_env_file("/etc/vconsole.conf", NEWLINE,
 236                                    "KEYMAP", &vc_keymap,
 237                                    "KEYMAP_TOGGLE", &vc_keymap_toggle,
 238                                    "FONT", &vc_font,
 239                                    "FONT_MAP", &vc_font_map,
 240                                    "FONT_UNIMAP", &vc_font_unimap,
 241                                    NULL);
 242
 243                 if (r < 0 && r != -ENOENT)
 244                         log_warning("Failed to read /etc/vconsole.conf: %s", strerror(-r));
 245         }
 246
 247         if (r <= 0) {
 248 #if defined(TARGET_SUSE)
 249                 r = parse_env_file("/etc/sysconfig/keyboard", NEWLINE,
 250                                    "KEYTABLE", &vc_keymap,
 251                                    NULL);
 252                 if (r < 0 && r != -ENOENT)
 253                         log_warning("Failed to read /etc/sysconfig/keyboard: %s", strerror(-r));
 254
 255                 r = parse_env_file("/etc/sysconfig/console", NEWLINE,
 256                                    "CONSOLE_FONT", &vc_font,
 257                                    "CONSOLE_SCREENMAP", &vc_font_map,
 258                                    "CONSOLE_UNICODEMAP", &vc_font_unimap,
 259                                    NULL);
 260                 if (r < 0 && r != -ENOENT)
 261                         log_warning("Failed to read /etc/sysconfig/console: %s", strerror(-r));
 262
 263 #elif defined(TARGET_ARCH)
 264                 r = parse_env_file("/etc/rc.conf", NEWLINE,
 265                                    "KEYMAP", &vc_keymap,
 266                                    "CONSOLEFONT", &vc_font,
 267                                    "CONSOLEMAP", &vc_font_map,
 268                                    NULL);
 269                 if (r < 0 && r != -ENOENT)
 270                         log_warning("Failed to read /etc/rc.conf: %s", strerror(-r));
 271
 272 #elif defined(TARGET_FRUGALWARE)
 273                 r = parse_env_file("/etc/sysconfig/keymap", NEWLINE,
 274                                    "keymap", &vc_keymap,
 275                                    NULL);
 276                 if (r < 0 && r != -ENOENT)
 277                         log_warning("Failed to read /etc/sysconfig/keymap: %s", strerror(-r));
 278
 279                 r = parse_env_file("/etc/sysconfig/font", NEWLINE,
 280                                    "font", &vc_font,
 281                                    NULL);
 282                 if (r < 0 && r != -ENOENT)
 283                         log_warning("Failed to read /etc/sysconfig/font: %s", strerror(-r));
 284
 285 #elif defined(TARGET_ALTLINUX)
 286                 r = parse_env_file("/etc/sysconfig/keyboard", NEWLINE,
 287                                    "KEYTABLE", &vc_keymap,
 288                                    NULL)
 289                 if (r < 0 && r != -ENOENT)
 290                         log_warning("Failed to read /etc/sysconfig/keyboard: %s", strerror(-r));
 291
 292                 r = parse_env_file("/etc/sysconfig/consolefont", NEWLINE,
 293                                    "SYSFONT", &vc_font,
 294                                    NULL);
 295                 if (r < 0 && r != -ENOENT)
 296                         log_warning("Failed to read /etc/sysconfig/consolefont: %s", strerror(-r));
 297
 298 #elif defined(TARGET_GENTOO)
 299                 r = parse_env_file("/etc/rc.conf", NEWLINE,
 300                                    "unicode", &vc_unicode,
 301                                    NULL);
 302                 if (r < 0 && r != -ENOENT)
 303                         log_warning("Failed to read /etc/rc.conf: %s", strerror(-r));
 304
 305                 if (vc_unicode) {
 306                         int rc_unicode;
 307
 308                         rc_unicode = parse_boolean(vc_unicode);
 309                         if (rc_unicode < 0)
 310                                 log_warning("Unknown value for /etc/rc.conf unicode=%s", vc_unicode);
 311                         else {
 312                                 if (rc_unicode && !utf8)
 313                                         log_warning("/etc/rc.conf wants unicode, but current locale is not UTF-8 capable!");
 314                                 else if (!rc_unicode && utf8) {
 315                                         log_debug("/etc/rc.conf does not want unicode, leave it on in kernel but does not apply to vconsole.");
 316                                         utf8 = false;
 317                                 }
 318                         }
 319                 }
 320
 321                 /* /etc/conf.d/consolefont comments and gentoo
 322                  * documentation mention uppercase, but the actual
 323                  * contents are lowercase.  the existing
 324                  * /etc/init.d/consolefont tries both
 325                  */
 326                 r = parse_env_file("/etc/conf.d/consolefont", NEWLINE,
 327                                    "CONSOLEFONT", &vc_font,
 328                                    "consolefont", &vc_font,
 329                                    "consoletranslation", &vc_font_map,
 330                                    "CONSOLETRANSLATION", &vc_font_map,
 331                                    "unicodemap", &vc_font_unimap,
 332                                    "UNICODEMAP", &vc_font_unimap,
 333                                    NULL);
 334                 if (r < 0 && r != -ENOENT)
 335                         log_warning("Failed to read /etc/conf.d/consolefont: %s", strerror(-r));
 336
 337                 r = parse_env_file("/etc/conf.d/keymaps", NEWLINE,
 338                                    "keymap", &vc_keymap,
 339                                    "KEYMAP", &vc_keymap,
 340                                    NULL);
 341                 if (r < 0 && r != -ENOENT)
 342                         log_warning("Failed to read /etc/conf.d/keymaps: %s", strerror(-r));
 343
 344 #elif defined(TARGET_MANDRIVA) || defined (TARGET_MAGEIA)
 345
 346                 r = parse_env_file("/etc/sysconfig/i18n", NEWLINE,
 347                                    "SYSFONT", &vc_font,
 348                                    "SYSFONTACM", &vc_font_map,
 349                                    "UNIMAP", &vc_font_unimap,
 350                                    NULL);
 351                 if (r < 0 && r != -ENOENT)
 352                         log_warning("Failed to read /etc/sysconfig/i18n: %s", strerror(-r));
 353
 354                 r = parse_env_file("/etc/sysconfig/keyboard", NEWLINE,
 355                                    "KEYTABLE", &vc_keytable,
 356                                    "KEYMAP", &vc_keymap,
 357                                    "UNIKEYTABLE", &vc_keymap,
 358                                    "GRP_TOGGLE", &vc_keymap_toggle,
 359                                    NULL);
 360                 if (r < 0 && r != -ENOENT)
 361                         log_warning("Failed to read /etc/sysconfig/keyboard: %s", strerror(-r));
 362
 363                 if (vc_keytable) {
 364                         free(vc_keymap);
 365                         if (utf8) {
 366                                 if (endswith(vc_keytable, ".uni") || strstr(vc_keytable, ".uni."))
 367                                         vc_keymap = strdup(vc_keytable);
 368                                 else {
 369                                         char *s;
 370                                         s = strstr(vc_keytable, ".map");
 371                                         if (s)
 372                                                 vc_keytable[s-vc_keytable+1] = '\0';
 373                                         vc_keymap = strappend(vc_keytable, ".uni");
 374                                 }
 375                         } else
 376                                 vc_keymap = strdup(vc_keytable);
 377
 378                         free(vc_keytable);
 379
 380                         if (!vc_keymap) {
 381                                 log_oom();
 382                                 goto finish;
 383                         }
 384                 }
 385
 386                 if (access("/etc/sysconfig/console/default.kmap", F_OK) >= 0) {
 387                         char *t;
 388
 389                         t = strdup("/etc/sysconfig/console/default.kmap");
 390                         if (!t) {
 391                                 log_oom();
 392                                 goto finish;
 393                         }
 394
 395                         free(vc_keymap);
 396                         vc_keymap = t;
 397                 }
 398 #endif
 399         }
 400
 401         r = EXIT_FAILURE;
 402
 403         if (utf8)
 404                 enable_utf8(fd);
 405         else
 406                 disable_utf8(fd);
 407
 408
 409         if (load_keymap(vc, vc_keymap, vc_keymap_toggle, utf8, &keymap_pid) >= 0 &&
 410             load_font(vc, vc_font, vc_font_map, vc_font_unimap, &font_pid) >= 0)
 411                 r = EXIT_SUCCESS;
 412
 413 finish:
 414         if (keymap_pid > 0)
 415                 wait_for_terminate_and_warn(KBD_LOADKEYS, keymap_pid);
 416
 417         if (font_pid > 0)
 418                 wait_for_terminate_and_warn(KBD_SETFONT, font_pid);
 419
 420         free(vc_keymap);
 421         free(vc_font);
 422         free(vc_font_map);
 423         free(vc_font_unimap);
 424
 425         if (fd >= 0)
 426                 close_nointr_nofail(fd);
 427
 428         return r;
 429 }