279 lines
6.2 KiB
C
279 lines
6.2 KiB
C
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2010 Free Software Foundation, Inc.
|
|
*
|
|
* GRUB is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GRUB 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <grub/util/misc.h>
|
|
#include <grub/i18n.h>
|
|
#include <grub/term.h>
|
|
#include <grub/keyboard_layouts.h>
|
|
#include <grub/at_keyboard.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <getopt.h>
|
|
#include <unistd.h>
|
|
|
|
#include "progname.h"
|
|
|
|
#define CKBCOMP "ckbcomp"
|
|
|
|
static struct option options[] = {
|
|
{"output", required_argument, 0, 'o'},
|
|
{"help", no_argument, 0, 'h'},
|
|
{"version", no_argument, 0, 'V'},
|
|
{"verbose", no_argument, 0, 'v'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
struct console_grub_equivalence
|
|
{
|
|
char *layout;
|
|
grub_uint32_t grub;
|
|
};
|
|
|
|
static struct console_grub_equivalence console_grub_equivalences[] = {
|
|
{"KP_1", '1'},
|
|
{"KP_2", '2'},
|
|
{"KP_3", '3'},
|
|
{"KP_4", '4'},
|
|
{"KP_5", '5'},
|
|
{"KP_6", '6'},
|
|
{"KP_7", '7'},
|
|
{"KP_8", '8'},
|
|
{"KP_9", '9'},
|
|
|
|
{"KP_Multiply", '*'},
|
|
{"KP_Substract", '-'},
|
|
{"KP_Add", '+'},
|
|
{"KP_Divide", '/'},
|
|
|
|
{"KP_Enter", '\n'},
|
|
{"Return", '\n'},
|
|
{"", '\0'}
|
|
};
|
|
|
|
GRUB_AT_KEY_KEYBOARD_MAP (us_keyboard_map);
|
|
GRUB_AT_KEY_KEYBOARD_MAP_SHIFT (us_keyboard_map_shifted);
|
|
|
|
static void
|
|
usage (int status)
|
|
{
|
|
if (status)
|
|
fprintf (stderr, "Try `%s --help' for more information.\n", program_name);
|
|
else
|
|
printf ("\
|
|
Usage: %s [OPTIONS] LAYOUT\n\
|
|
-o, --output set output base name file. Default is LAYOUT.gkb\n\
|
|
-h, --help display this message and exit.\n\
|
|
-V, --version print version information and exit.\n\
|
|
-v, --verbose print verbose messages.\n\
|
|
\n\
|
|
Report bugs to <%s>.\n", program_name, PACKAGE_BUGREPORT);
|
|
|
|
exit (status);
|
|
}
|
|
|
|
char
|
|
lookup (char *code)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; console_grub_equivalences[i].grub != '\0'; i++)
|
|
if (strcmp (code, console_grub_equivalences[i].layout) == 0)
|
|
return console_grub_equivalences[i].grub;
|
|
|
|
return '\0';
|
|
}
|
|
|
|
unsigned int
|
|
get_grub_code (char *layout_code)
|
|
{
|
|
unsigned int code;
|
|
|
|
if (strncmp (layout_code, "U+", sizeof ("U+") - 1) == 0)
|
|
sscanf (layout_code, "U+%x", &code);
|
|
else if (strncmp (layout_code, "+U+", sizeof ("+U+") - 1) == 0)
|
|
sscanf (layout_code, "+U+%x", &code);
|
|
else
|
|
code = lookup (layout_code);
|
|
return code;
|
|
}
|
|
|
|
void
|
|
write_file (char* filename, grub_uint32_t *keyboard_map)
|
|
{
|
|
FILE *fp_output;
|
|
grub_uint32_t version;
|
|
unsigned i;
|
|
|
|
version = grub_cpu_to_le32 (GRUB_KEYBOARD_LAYOUTS_VERSION);
|
|
|
|
for (i = 0; i < GRUB_KEYBOARD_LAYOUTS_ARRAY_SIZE; i++)
|
|
keyboard_map[i] = grub_cpu_to_le32 (keyboard_map[i]);
|
|
|
|
fp_output = fopen (filename, "w");
|
|
|
|
if (!fp_output)
|
|
{
|
|
grub_util_error ("cannot open `%s'", filename);
|
|
exit (1);
|
|
}
|
|
|
|
fwrite (GRUB_KEYBOARD_LAYOUTS_FILEMAGIC, 1,
|
|
GRUB_KEYBOARD_LAYOUTS_FILEMAGIC_SIZE, fp_output);
|
|
fwrite (&version, sizeof (version), 1, fp_output);
|
|
fwrite (keyboard_map, sizeof (keyboard_map[0]),
|
|
GRUB_KEYBOARD_LAYOUTS_ARRAY_SIZE, fp_output);
|
|
fclose (fp_output);
|
|
}
|
|
|
|
void
|
|
write_keymaps (char *keymap, char *file_basename)
|
|
{
|
|
grub_uint32_t keyboard_map[GRUB_KEYBOARD_LAYOUTS_ARRAY_SIZE];
|
|
|
|
char line[2048];
|
|
pid_t pid;
|
|
int pipe_communication[2];
|
|
int ok;
|
|
|
|
FILE *fp_pipe;
|
|
|
|
if (pipe (pipe_communication) == -1)
|
|
{
|
|
grub_util_error ("cannot prepare the pipe");
|
|
exit (2);
|
|
}
|
|
|
|
pid = fork ();
|
|
if (pid < 0)
|
|
{
|
|
grub_util_error ("cannot fork");
|
|
exit (2);
|
|
}
|
|
else if (pid == 0)
|
|
{
|
|
close (1);
|
|
dup (pipe_communication[1]);
|
|
close (pipe_communication[0]);
|
|
execlp (CKBCOMP, CKBCOMP, keymap, NULL);
|
|
grub_util_error ("%s %s cannot be executed", CKBCOMP, keymap);
|
|
exit (3);
|
|
}
|
|
close (pipe_communication[1]);
|
|
fp_pipe = fdopen (pipe_communication[0], "r");
|
|
|
|
memset (keyboard_map, 0, sizeof (keyboard_map));
|
|
|
|
/* Process the ckbcomp output and prepare the layouts. */
|
|
ok = 0;
|
|
while (fgets (line, sizeof (line), fp_pipe))
|
|
{
|
|
if (strncmp (line, "keycode", sizeof ("keycode") - 1) == 0)
|
|
{
|
|
unsigned keycode;
|
|
char normal[64];
|
|
char shift[64];
|
|
sscanf (line, "keycode %u = %60s %60s", &keycode, normal, shift);
|
|
if (keycode < ARRAY_SIZE (us_keyboard_map)
|
|
&& us_keyboard_map[keycode] < ARRAY_SIZE (keyboard_map))
|
|
{
|
|
keyboard_map[us_keyboard_map[keycode]] = get_grub_code (normal);
|
|
ok = 1;
|
|
}
|
|
if (keycode < ARRAY_SIZE (us_keyboard_map_shifted)
|
|
&& us_keyboard_map_shifted[keycode] < ARRAY_SIZE (keyboard_map))
|
|
{
|
|
keyboard_map[us_keyboard_map_shifted[keycode]]
|
|
= get_grub_code (shift);
|
|
ok = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ok == 0)
|
|
{
|
|
fprintf (stderr, "ERROR: no keycodes found. Check output of %s %s.\n",
|
|
CKBCOMP, keymap);
|
|
exit (1);
|
|
}
|
|
|
|
write_file (file_basename, keyboard_map);
|
|
}
|
|
|
|
int
|
|
main (int argc, char *argv[])
|
|
{
|
|
int verbosity;
|
|
char *file_basename = NULL;
|
|
|
|
set_program_name (argv[0]);
|
|
|
|
verbosity = 0;
|
|
|
|
/* Check for options. */
|
|
while (1)
|
|
{
|
|
int c = getopt_long (argc, argv, "o:hVv", options, 0);
|
|
|
|
if (c == -1)
|
|
break;
|
|
else
|
|
switch (c)
|
|
{
|
|
case 'h':
|
|
usage (0);
|
|
break;
|
|
|
|
case 'o':
|
|
file_basename = optarg;
|
|
break;
|
|
|
|
case 'V':
|
|
printf ("%s (%s) %s\n", program_name, PACKAGE_NAME,
|
|
PACKAGE_VERSION);
|
|
return 0;
|
|
|
|
case 'v':
|
|
verbosity++;
|
|
break;
|
|
|
|
default:
|
|
usage (1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Obtain LAYOUT. */
|
|
if (optind >= argc)
|
|
{
|
|
fprintf (stderr, "No layout is specified.\n");
|
|
usage (1);
|
|
}
|
|
|
|
if (file_basename == NULL)
|
|
{
|
|
file_basename = xasprintf ("%s.gkb", argv[optind]);
|
|
write_keymaps (argv[optind], file_basename);
|
|
free (file_basename);
|
|
}
|
|
else
|
|
write_keymaps (argv[optind], file_basename);
|
|
|
|
return 0;
|
|
}
|