[thirdparty/systemd.git] / src / vconsole / vconsole-setup.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Kay Sievers

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdarg.h>
#include <limits.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <linux/tiocl.h>
#include <linux/kd.h>
#include <linux/vt.h>

#include "util.h"
#include "log.h"
#include "macro.h"
#include "virt.h"
#include "fileio.h"

static bool is_vconsole(int fd) {
        unsigned char data[1];

        data[0] = TIOCL_GETFGCONSOLE;
        return ioctl(fd, TIOCLINUX, data) >= 0;
}

static int disable_utf8(int fd) {
        int r = 0, k;

        if (ioctl(fd, KDSKBMODE, K_XLATE) < 0)
                r = -errno;

        if (loop_write(fd, "\033%@", 3, false) < 0)
                r = -errno;

        k = write_one_line_file("/sys/module/vt/parameters/default_utf8", "0");
        if (k < 0)
                r = k;

        if (r < 0)
                log_warning("Failed to disable UTF-8: %s", strerror(-r));

        return r;
}

static int enable_utf8(int fd) {
        int r = 0, k;
        long current = 0;

        if (ioctl(fd, KDGKBMODE, &current) < 0 || current == K_XLATE) {
                /*
                 * Change the current keyboard to unicode, unless it
                 * is currently in raw or off mode anyway. We
                 * shouldn't interfere with X11's processing of the
                 * key events.
                 *
                 * http://lists.freedesktop.org/archives/systemd-devel/2013-February/008573.html
                 *
                 */

                if (ioctl(fd, KDSKBMODE, K_UNICODE) < 0)
                        r = -errno;
        }

        if (loop_write(fd, "\033%G", 3, false) < 0)
                r = -errno;

        k = write_one_line_file("/sys/module/vt/parameters/default_utf8", "1");
        if (k < 0)
                r = k;

        if (r < 0)
                log_warning("Failed to enable UTF-8: %s", strerror(-r));

        return r;
}

static int keymap_load(const char *vc, const char *map, const char *map_toggle, bool utf8, pid_t *_pid) {
        const char *args[8];
        int i = 0;
        pid_t pid;

        if (isempty(map)) {
                /* An empty map means kernel map */
                *_pid = 0;
                return 0;
        }

        args[i++] = KBD_LOADKEYS;
        args[i++] = "-q";
        args[i++] = "-C";
        args[i++] = vc;
        if (utf8)
                args[i++] = "-u";
        args[i++] = map;
        if (map_toggle)
                args[i++] = map_toggle;
        args[i++] = NULL;

        pid = fork();
        if (pid < 0) {
                log_error("Failed to fork: %m");
                return -errno;
        } else if (pid == 0) {
                execv(args[0], (char **) args);
                _exit(EXIT_FAILURE);
        }

        *_pid = pid;
        return 0;
}

static int font_load(const char *vc, const char *font, const char *map, const char *unimap, pid_t *_pid) {
        const char *args[9];
        int i = 0;
        pid_t pid;

        if (isempty(font)) {
                /* An empty font means kernel font */
                *_pid = 0;
                return 0;
        }

        args[i++] = KBD_SETFONT;
        args[i++] = "-C";
        args[i++] = vc;
        args[i++] = font;
        if (map) {
                args[i++] = "-m";
                args[i++] = map;
        }
        if (unimap) {
                args[i++] = "-u";
                args[i++] = unimap;
        }
        args[i++] = NULL;

        pid = fork();
        if (pid < 0) {
                log_error("Failed to fork: %m");
                return -errno;
        } else if (pid == 0) {
                execv(args[0], (char **) args);
                _exit(EXIT_FAILURE);
        }

        *_pid = pid;
        return 0;
}

/*
 * A newly allocated VT uses the font from the active VT. Here
 * we update all possibly already allocated VTs with the configured
 * font. It also allows to restart systemd-vconsole-setup.service,
 * to apply a new font to all VTs.
 */
static void font_copy_to_all_vcs(int fd) {
        struct vt_stat vcs;
        int i;
        int r;

        /* get active, and 16 bit mask of used VT numbers */
        zero(vcs);
        r = ioctl(fd, VT_GETSTATE, &vcs);
        if (r < 0)
                return;

        for (i = 1; i <= 15; i++) {
                char vcname[16];
                struct console_font_op cfo;
                int _cleanup_close_ vcfd = -1;

                if (i == vcs.v_active)
                        continue;

                /* skip non-allocated ttys */
                snprintf(vcname, sizeof(vcname), "/dev/vcs%i", i);
                if (access(vcname, F_OK) < 0)
                        continue;

                snprintf(vcname, sizeof(vcname), "/dev/tty%i", i);
                vcfd = open_terminal(vcname, O_RDWR|O_CLOEXEC);
                if (vcfd < 0)
                        continue;

                /* copy font from active VT, where the font was uploaded to */
                zero(cfo);
                cfo.op = KD_FONT_OP_COPY;
                cfo.height = vcs.v_active-1; /* tty1 == index 0 */
                ioctl(vcfd, KDFONTOP, &cfo);
        }
}

int main(int argc, char **argv) {
        const char *vc;
        char *vc_keymap = NULL;
        char *vc_keymap_toggle = NULL;
        char *vc_font = NULL;
        char *vc_font_map = NULL;
        char *vc_font_unimap = NULL;
        int fd = -1;
        bool utf8;
        pid_t font_pid = 0, keymap_pid = 0;
        bool font_copy = false;
        int r = EXIT_FAILURE;

        log_set_target(LOG_TARGET_AUTO);
        log_parse_environment();
        log_open();

        umask(0022);

        if (argv[1])
                vc = argv[1];
        else {
                vc = "/dev/tty0";
                font_copy = true;
        }

        fd = open_terminal(vc, O_RDWR|O_CLOEXEC);
        if (fd < 0) {
                log_error("Failed to open %s: %m", vc);
                goto finish;
        }

        if (!is_vconsole(fd)) {
                log_error("Device %s is not a virtual console.", vc);
                goto finish;
        }

        utf8 = is_locale_utf8();

        r = 0;

        if (detect_container(NULL) <= 0) {
                r = parse_env_file("/proc/cmdline", WHITESPACE,
                                   "vconsole.keymap", &vc_keymap,
                                   "vconsole.keymap.toggle", &vc_keymap_toggle,
                                   "vconsole.font", &vc_font,
                                   "vconsole.font.map", &vc_font_map,
                                   "vconsole.font.unimap", &vc_font_unimap,
                                   NULL);

                if (r < 0 && r != -ENOENT)
                        log_warning("Failed to read /proc/cmdline: %s", strerror(-r));
        }

        /* Hmm, nothing set on the kernel cmd line? Then let's
         * try /etc/vconsole.conf */
        if (r <= 0) {
                r = parse_env_file("/etc/vconsole.conf", NEWLINE,
                                   "KEYMAP", &vc_keymap,
                                   "KEYMAP_TOGGLE", &vc_keymap_toggle,
                                   "FONT", &vc_font,
                                   "FONT_MAP", &vc_font_map,
                                   "FONT_UNIMAP", &vc_font_unimap,
                                   NULL);

                if (r < 0 && r != -ENOENT)
                        log_warning("Failed to read /etc/vconsole.conf: %s", strerror(-r));
        }

        if (utf8)
                enable_utf8(fd);
        else
                disable_utf8(fd);

        r = EXIT_FAILURE;
        if (keymap_load(vc, vc_keymap, vc_keymap_toggle, utf8, &keymap_pid) >= 0 &&
            font_load(vc, vc_font, vc_font_map, vc_font_unimap, &font_pid) >= 0)
                r = EXIT_SUCCESS;

finish:
        if (keymap_pid > 0)
                wait_for_terminate_and_warn(KBD_LOADKEYS, keymap_pid);

        if (font_pid > 0) {
                wait_for_terminate_and_warn(KBD_SETFONT, font_pid);
                if (font_copy)
                        font_copy_to_all_vcs(fd);
        }

        free(vc_keymap);
        free(vc_font);
        free(vc_font_map);
        free(vc_font_unimap);

        if (fd >= 0)
                close_nointr_nofail(fd);

        return r;
}
Commit	Line	Data
97c4a07d LP	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
5430f7f2 LP	9	under the terms of the GNU Lesser General Public License as published by
5430f7f2 LP	10	the Free Software Foundation; either version 2.1 of the License, or
97c4a07d LP	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
5430f7f2	16	Lesser General Public License for more details.
97c4a07d	17
5430f7f2	18	You should have received a copy of the GNU Lesser General Public License
97c4a07d LP	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>
97c4a07d LP	32	#include <sys/ioctl.h>
	33	#include <sys/wait.h>
	34	#include <linux/tiocl.h>
	35	#include <linux/kd.h>
dd04aac9	36	#include <linux/vt.h>
97c4a07d LP	37
	38	#include "util.h"
	39	#include "log.h"
	40	#include "macro.h"
b52aae1d	41	#include "virt.h"
a5c32cff	42	#include "fileio.h"
97c4a07d	43
653ab83b	44	static bool is_vconsole(int fd) {
97c4a07d LP	45	unsigned char data[1];
	46
	47	data[0] = TIOCL_GETFGCONSOLE;
	48	return ioctl(fd, TIOCLINUX, data) >= 0;
97c4a07d LP	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
741f8cf6 LP	60	k = write_one_line_file("/sys/module/vt/parameters/default_utf8", "0");
741f8cf6 LP	61	if (k < 0)
97c4a07d LP	62	r = k;
	63
	64	if (r < 0)
741f8cf6	65	log_warning("Failed to disable UTF-8: %s", strerror(-r));
97c4a07d LP	66
	67	return r;
	68	}
	69
d305a67b TG	70	static int enable_utf8(int fd) {
d305a67b TG	71	int r = 0, k;
a25d4d0e LP	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	}
d305a67b TG	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
dd04aac9	102	static int keymap_load(const char vc, const char map, const char map_toggle, bool utf8, pid_t _pid) {
5b396b06	103	const char *args[8];
97c4a07d LP	104	int i = 0;
	105	pid_t pid;
	106
944d4c91 LP	107	if (isempty(map)) {
	108	/* An empty map means kernel map */
	109	*_pid = 0;
	110	return 0;
	111	}
	112
9841e8e3	113	args[i++] = KBD_LOADKEYS;
97c4a07d LP	114	args[i++] = "-q";
	115	args[i++] = "-C";
	116	args[i++] = vc;
	117	if (utf8)
	118	args[i++] = "-u";
	119	args[i++] = map;
5b396b06 AB	120	if (map_toggle)
5b396b06 AB	121	args[i++] = map_toggle;
97c4a07d LP	122	args[i++] = NULL;
97c4a07d LP	123
741f8cf6 LP	124	pid = fork();
741f8cf6 LP	125	if (pid < 0) {
97c4a07d LP	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
dd04aac9	137	static int font_load(const char vc, const char font, const char map, const char unimap, pid_t *_pid) {
97c4a07d LP	138	const char *args[9];
	139	int i = 0;
	140	pid_t pid;
	141
944d4c91 LP	142	if (isempty(font)) {
	143	/* An empty font means kernel font */
	144	*_pid = 0;
	145	return 0;
	146	}
	147
9841e8e3	148	args[i++] = KBD_SETFONT;
97c4a07d LP	149	args[i++] = "-C";
	150	args[i++] = vc;
	151	args[i++] = font;
dd36de4d	152	if (map) {
97c4a07d LP	153	args[i++] = "-m";
	154	args[i++] = map;
	155	}
dd36de4d	156	if (unimap) {
97c4a07d LP	157	args[i++] = "-u";
	158	args[i++] = unimap;
	159	}
	160	args[i++] = NULL;
	161
741f8cf6 LP	162	pid = fork();
741f8cf6 LP	163	if (pid < 0) {
97c4a07d LP	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
d3b37e84 KS	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;
dd04aac9 KS	183	int i;
	184	int r;
	185
d3b37e84 KS	186	/* get active, and 16 bit mask of used VT numbers */
	187	zero(vcs);
	188	r = ioctl(fd, VT_GETSTATE, &vcs);
dd04aac9 KS	189	if (r < 0)
	190	return;
	191
d3b37e84 KS	192	for (i = 1; i <= 15; i++) {
d3b37e84 KS	193	char vcname[16];
dd04aac9	194	struct console_font_op cfo;
e62d8c39	195	int _cleanup_close_ vcfd = -1;
dd04aac9	196
d3b37e84	197	if (i == vcs.v_active)
dd04aac9 KS	198	continue;
dd04aac9 KS	199
10ffbc99 KS	200	/* skip non-allocated ttys */
	201	snprintf(vcname, sizeof(vcname), "/dev/vcs%i", i);
	202	if (access(vcname, F_OK) < 0)
dd04aac9 KS	203	continue;
dd04aac9 KS	204
10ffbc99	205	snprintf(vcname, sizeof(vcname), "/dev/tty%i", i);
d3b37e84 KS	206	vcfd = open_terminal(vcname, O_RDWR\|O_CLOEXEC);
d3b37e84 KS	207	if (vcfd < 0)
dd04aac9 KS	208	continue;
dd04aac9 KS	209
d3b37e84	210	/* copy font from active VT, where the font was uploaded to */
dd04aac9 KS	211	zero(cfo);
dd04aac9 KS	212	cfo.op = KD_FONT_OP_COPY;
d3b37e84 KS	213	cfo.height = vcs.v_active-1; /* tty1 == index 0 */
d3b37e84 KS	214	ioctl(vcfd, KDFONTOP, &cfo);
dd04aac9 KS	215	}
	216	}
	217
97c4a07d LP	218	int main(int argc, char **argv) {
	219	const char *vc;
	220	char *vc_keymap = NULL;
5b396b06	221	char *vc_keymap_toggle = NULL;
97c4a07d LP	222	char *vc_font = NULL;
	223	char *vc_font_map = NULL;
	224	char *vc_font_unimap = NULL;
	225	int fd = -1;
	226	bool utf8;
97c4a07d	227	pid_t font_pid = 0, keymap_pid = 0;
d3b37e84	228	bool font_copy = false;
dd04aac9	229	int r = EXIT_FAILURE;
97c4a07d	230
944d4c91	231	log_set_target(LOG_TARGET_AUTO);
97c4a07d LP	232	log_parse_environment();
	233	log_open();
	234
4c12626c LP	235	umask(0022);
4c12626c LP	236
97c4a07d LP	237	if (argv[1])
97c4a07d LP	238	vc = argv[1];
dd04aac9	239	else {
d3b37e84 KS	240	vc = "/dev/tty0";
d3b37e84 KS	241	font_copy = true;
dd04aac9	242	}
97c4a07d	243
741f8cf6 LP	244	fd = open_terminal(vc, O_RDWR\|O_CLOEXEC);
741f8cf6 LP	245	if (fd < 0) {
97c4a07d LP	246	log_error("Failed to open %s: %m", vc);
	247	goto finish;
	248	}
	249
653ab83b	250	if (!is_vconsole(fd)) {
97c4a07d LP	251	log_error("Device %s is not a virtual console.", vc);
	252	goto finish;
	253	}
	254
653ab83b	255	utf8 = is_locale_utf8();
97c4a07d	256
944d4c91 LP	257	r = 0;
944d4c91 LP	258
741f8cf6 LP	259	if (detect_container(NULL) <= 0) {
	260	r = parse_env_file("/proc/cmdline", WHITESPACE,
	261	"vconsole.keymap", &vc_keymap,
	262	"vconsole.keymap.toggle", &vc_keymap_toggle,
	263	"vconsole.font", &vc_font,
	264	"vconsole.font.map", &vc_font_map,
	265	"vconsole.font.unimap", &vc_font_unimap,
	266	NULL);
	267
	268	if (r < 0 && r != -ENOENT)
	269	log_warning("Failed to read /proc/cmdline: %s", strerror(-r));
	270	}
1ebdf5b6	271
653ab83b	272	/* Hmm, nothing set on the kernel cmd line? Then let's
fd5bf055	273	* try /etc/vconsole.conf */
741f8cf6 LP	274	if (r <= 0) {
	275	r = parse_env_file("/etc/vconsole.conf", NEWLINE,
	276	"KEYMAP", &vc_keymap,
	277	"KEYMAP_TOGGLE", &vc_keymap_toggle,
	278	"FONT", &vc_font,
	279	"FONT_MAP", &vc_font_map,
	280	"FONT_UNIMAP", &vc_font_unimap,
	281	NULL);
	282
	283	if (r < 0 && r != -ENOENT)
fd5bf055	284	log_warning("Failed to read /etc/vconsole.conf: %s", strerror(-r));
1ebdf5b6	285	}
ae509abc	286
d305a67b TG	287	if (utf8)
	288	enable_utf8(fd);
	289	else
653ab83b LP	290	disable_utf8(fd);
653ab83b LP	291
dd04aac9 KS	292	r = EXIT_FAILURE;
	293	if (keymap_load(vc, vc_keymap, vc_keymap_toggle, utf8, &keymap_pid) >= 0 &&
	294	font_load(vc, vc_font, vc_font_map, vc_font_unimap, &font_pid) >= 0)
97c4a07d LP	295	r = EXIT_SUCCESS;
	296
	297	finish:
	298	if (keymap_pid > 0)
9841e8e3	299	wait_for_terminate_and_warn(KBD_LOADKEYS, keymap_pid);
97c4a07d	300
dd04aac9	301	if (font_pid > 0) {
9841e8e3	302	wait_for_terminate_and_warn(KBD_SETFONT, font_pid);
d3b37e84 KS	303	if (font_copy)
d3b37e84 KS	304	font_copy_to_all_vcs(fd);
dd04aac9	305	}
97c4a07d LP	306
	307	free(vc_keymap);
	308	free(vc_font);
	309	free(vc_font_map);
	310	free(vc_font_unimap);
	311
	312	if (fd >= 0)
	313	close_nointr_nofail(fd);
	314
	315	return r;
	316	}