src/udev/keymap/keymap.c

   1 /*
   2  * keymap - dump keymap of an evdev device or set a new keymap from a file
   3  *
   4  * Based on keyfuzz by Lennart Poettering <mzqrovna@0pointer.net>
   5  * Adapted for udev-extras by Martin Pitt <martin.pitt@ubuntu.com>
   6  *
   7  * Copyright (C) 2006, Lennart Poettering
   8  * Copyright (C) 2009, Canonical Ltd.
   9  *
  10  * keymap is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * keymap is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with keymap; if not, write to the Free Software Foundation,
  22  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdint.h>
  29 #include <ctype.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <limits.h>
  33 #include <fcntl.h>
  34 #include <getopt.h>
  35 #include <sys/ioctl.h>
  36 #include <linux/limits.h>
  37 #include <linux/input.h>
  38
  39 const struct key* lookup_key (const char *str, unsigned int len);
  40
  41 #include "keys-from-name.h"
  42 #include "keys-to-name.h"
  43 #include "macro.h"
  44 #include "util.h"
  45
  46 #define MAX_SCANCODES 1024
  47
  48 static int evdev_open(const char *dev)
  49 {
  50         int fd;
  51         char fn[PATH_MAX];
  52
  53         if (!startswith(dev, "/dev")) {
  54                 snprintf(fn, sizeof(fn), "/dev/%s", dev);
  55                 dev = fn;
  56         }
  57
  58         if ((fd = open(dev, O_RDWR)) < 0) {
  59                 fprintf(stderr, "error open('%s'): %m\n", dev);
  60                 return -1;
  61         }
  62         return fd;
  63 }
  64
  65 static int evdev_get_keycode(int fd, int scancode, int e)
  66 {
  67         int codes[2];
  68
  69         codes[0] = scancode;
  70         if (ioctl(fd, EVIOCGKEYCODE, codes) < 0) {
  71                 if (e && errno == EINVAL) {
  72                         return -2;
  73                 } else {
  74                         fprintf(stderr, "EVIOCGKEYCODE: %m\n");
  75                         return -1;
  76                 }
  77         }
  78         return codes[1];
  79 }
  80
  81 static int evdev_set_keycode(int fd, int scancode, int keycode)
  82 {
  83         int codes[2];
  84
  85         codes[0] = scancode;
  86         codes[1] = keycode;
  87
  88         if (ioctl(fd, EVIOCSKEYCODE, codes) < 0) {
  89                 fprintf(stderr, "EVIOCSKEYCODE: %m\n");
  90                 return -1;
  91         }
  92         return 0;
  93 }
  94
  95 static int evdev_driver_version(int fd, char *v, size_t l)
  96 {
  97         int version;
  98
  99         if (ioctl(fd, EVIOCGVERSION, &version)) {
 100                 fprintf(stderr, "EVIOCGVERSION: %m\n");
 101                 return -1;
 102         }
 103
 104         snprintf(v, l, "%i.%i.%i.", version >> 16, (version >> 8) & 0xff, version & 0xff);
 105         return 0;
 106 }
 107
 108 static int evdev_device_name(int fd, char *n, size_t l)
 109 {
 110         if (ioctl(fd, EVIOCGNAME(l), n) < 0) {
 111                 fprintf(stderr, "EVIOCGNAME: %m\n");
 112                 return -1;
 113         }
 114         return 0;
 115 }
 116
 117 /* Return a lower-case string with KEY_ prefix removed */
 118 static const char* format_keyname(const char* key) {
 119         static char result[101];
 120         const char* s;
 121         int len;
 122
 123         for (s = key+4, len = 0; *s && len < 100; ++len, ++s)
 124                 result[len] = tolower(*s);
 125         result[len] = '\0';
 126         return result;
 127 }
 128
 129 static int dump_table(int fd) {
 130         char version[256], name[256];
 131         int scancode, r = -1;
 132
 133         if (evdev_driver_version(fd, version, sizeof(version)) < 0)
 134                 goto fail;
 135
 136         if (evdev_device_name(fd, name, sizeof(name)) < 0)
 137                 goto fail;
 138
 139         printf("### evdev %s, driver '%s'\n", version, name);
 140
 141         r = 0;
 142         for (scancode = 0; scancode < MAX_SCANCODES; scancode++) {
 143                 int keycode;
 144
 145                 if ((keycode = evdev_get_keycode(fd, scancode, 1)) < 0) {
 146                         if (keycode == -2)
 147                                 continue;
 148                         r = -1;
 149                         break;
 150                 }
 151
 152                 if (keycode < KEY_MAX && key_names[keycode])
 153                         printf("0x%03x %s\n", scancode, format_keyname(key_names[keycode]));
 154                 else
 155                         printf("0x%03x 0x%03x\n", scancode, keycode);
 156         }
 157 fail:
 158         return r;
 159 }
 160
 161 static void set_key(int fd, const char* scancode_str, const char* keyname)
 162 {
 163         unsigned scancode;
 164         char *endptr;
 165         char t[105] = "KEY_UNKNOWN";
 166         const struct key *k;
 167
 168         scancode = (unsigned) strtol(scancode_str, &endptr, 0);
 169         if (*endptr != '\0') {
 170                 fprintf(stderr, "ERROR: Invalid scancode\n");
 171                 exit(1);
 172         }
 173
 174         snprintf(t, sizeof(t), "KEY_%s", keyname);
 175
 176         if (!(k = lookup_key(t, strlen(t)))) {
 177                 fprintf(stderr, "ERROR: Unknown key name '%s'\n", keyname);
 178                 exit(1);
 179         }
 180
 181         if (evdev_set_keycode(fd, scancode, k->id) < 0)
 182                 fprintf(stderr, "setting scancode 0x%2X to key code %i failed\n",
 183                         scancode, k->id);
 184         else
 185                 printf("setting scancode 0x%2X to key code %i\n",
 186                         scancode, k->id);
 187 }
 188
 189 static int merge_table(int fd, FILE *f) {
 190         int r = 0;
 191         int line = 0;
 192
 193         while (!feof(f)) {
 194                 char s[256], *p;
 195                 int scancode, new_keycode, old_keycode;
 196
 197                 if (!fgets(s, sizeof(s), f))
 198                         break;
 199
 200                 line++;
 201                 p = s+strspn(s, "\t ");
 202                 if (*p == '#' || *p == '\n')
 203                         continue;
 204
 205                 if (sscanf(p, "%i %i", &scancode, &new_keycode) != 2) {
 206                         char t[105] = "KEY_UNKNOWN";
 207                         const struct key *k;
 208
 209                         if (sscanf(p, "%i %100s", &scancode, t+4) != 2) {
 210                                 fprintf(stderr, "WARNING: Parse failure at line %i, ignoring.\n", line);
 211                                 r = -1;
 212                                 continue;
 213                         }
 214
 215                         if (!(k = lookup_key(t, strlen(t)))) {
 216                                 fprintf(stderr, "WARNING: Unknown key '%s' at line %i, ignoring.\n", t, line);
 217                                 r = -1;
 218                                 continue;
 219                         }
 220
 221                         new_keycode = k->id;
 222                 }
 223
 224
 225                 if ((old_keycode = evdev_get_keycode(fd, scancode, 0)) < 0) {
 226                         r = -1;
 227                         goto fail;
 228                 }
 229
 230                 if (evdev_set_keycode(fd, scancode, new_keycode) < 0) {
 231                         r = -1;
 232                         goto fail;
 233                 }
 234
 235                 if (new_keycode != old_keycode)
 236                         fprintf(stderr, "Remapped scancode 0x%02x to 0x%02x (prior: 0x%02x)\n",
 237                                 scancode, new_keycode, old_keycode);
 238         }
 239 fail:
 240         fclose(f);
 241         return r;
 242 }
 243
 244
 245 /* read one event; return 1 if valid */
 246 static int read_event(int fd, struct input_event* ev)
 247 {
 248         int ret;
 249         ret = read(fd, ev, sizeof(struct input_event));
 250
 251         if (ret < 0) {
 252                 perror("read");
 253                 return 0;
 254         }
 255         if (ret != sizeof(struct input_event)) {
 256                 fprintf(stderr, "did not get enough data for event struct, aborting\n");
 257                 return 0;
 258         }
 259
 260         return 1;
 261 }
 262
 263 static void print_key(uint32_t scancode, uint16_t keycode, int has_scan, int has_key)
 264 {
 265         const char *keyname;
 266
 267         /* ignore key release events */
 268         if (has_key == 1)
 269                 return;
 270
 271         if (has_key == 0 && has_scan != 0) {
 272                 fprintf(stderr, "got scan code event 0x%02X without a key code event\n",
 273                         scancode);
 274                 return;
 275         }
 276
 277         if (has_scan != 0)
 278                 printf("scan code: 0x%02X   ", scancode);
 279         else
 280                 printf("(no scan code received)  ");
 281
 282         keyname = key_names[keycode];
 283         if (keyname != NULL)
 284                 printf("key code: %s\n", format_keyname(keyname));
 285         else
 286                 printf("key code: %03X\n", keycode);
 287 }
 288
 289 static void interactive(int fd)
 290 {
 291         struct input_event ev;
 292         uint32_t last_scan = 0;
 293         uint16_t last_key = 0;
 294         int has_scan; /* boolean */
 295         int has_key; /* 0: none, 1: release, 2: press */
 296
 297         /* grab input device */
 298         ioctl(fd, EVIOCGRAB, 1);
 299         puts("Press ESC to finish, or Control-C if this device is not your primary keyboard");
 300
 301         has_scan = has_key = 0;
 302         while (read_event(fd, &ev)) {
 303                 /* Drivers usually send the scan code first, then the key code,
 304                  * then a SYN. Some drivers (like thinkpad_acpi) send the key
 305                  * code first, and some drivers might not send SYN events, so
 306                  * keep a robust state machine which can deal with any of those
 307                  */
 308
 309                 if (ev.type == EV_MSC && ev.code == MSC_SCAN) {
 310                         if (has_scan) {
 311                                 fputs("driver did not send SYN event in between key events; previous event:\n",
 312                                       stderr);
 313                                 print_key(last_scan, last_key, has_scan, has_key);
 314                                 has_key = 0;
 315                         }
 316
 317                         last_scan = ev.value;
 318                         has_scan = 1;
 319                         /*printf("--- got scan %u; has scan %i key %i\n", last_scan, has_scan, has_key); */
 320                 }
 321                 else if (ev.type == EV_KEY) {
 322                         if (has_key) {
 323                                 fputs("driver did not send SYN event in between key events; previous event:\n",
 324                                       stderr);
 325                                 print_key(last_scan, last_key, has_scan, has_key);
 326                                 has_scan = 0;
 327                         }
 328
 329                         last_key = ev.code;
 330                         has_key = 1 + ev.value;
 331                         /*printf("--- got key %hu; has scan %i key %i\n", last_key, has_scan, has_key);*/
 332
 333                         /* Stop on ESC */
 334                         if (ev.code == KEY_ESC && ev.value == 0)
 335                                 break;
 336                 }
 337                 else if (ev.type == EV_SYN) {
 338                         /*printf("--- got SYN; has scan %i key %i\n", has_scan, has_key);*/
 339                         print_key(last_scan, last_key, has_scan, has_key);
 340
 341                         has_scan = has_key = 0;
 342                 }
 343
 344         }
 345
 346         /* release input device */
 347         ioctl(fd, EVIOCGRAB, 0);
 348 }
 349
 350 _noreturn_ static void help(int error)
 351 {
 352         const char* h = "Usage: keymap <event device> [<map file>]\n"
 353                         "       keymap <event device> scancode keyname [...]\n"
 354                         "       keymap -i <event device>\n";
 355         if (error) {
 356                 fputs(h, stderr);
 357                 exit(2);
 358         } else {
 359                 fputs(h, stdout);
 360                 exit(0);
 361         }
 362 }
 363
 364 int main(int argc, char **argv)
 365 {
 366         static const struct option options[] = {
 367                 { "help", no_argument, NULL, 'h' },
 368                 { "interactive", no_argument, NULL, 'i' },
 369                 {}
 370         };
 371         int fd = -1;
 372         int opt_interactive = 0;
 373         int i;
 374
 375         while (1) {
 376                 int option;
 377
 378                 option = getopt_long(argc, argv, "hi", options, NULL);
 379                 if (option == -1)
 380                         break;
 381
 382                 switch (option) {
 383                 case 'h':
 384                         help(0);
 385
 386                 case 'i':
 387                         opt_interactive = 1;
 388                         break;
 389                 default:
 390                         return 1;
 391                 }
 392         }
 393
 394         if (argc < optind+1)
 395                 help (1);
 396
 397         if ((fd = evdev_open(argv[optind])) < 0)
 398                 return 3;
 399
 400         /* one argument (device): dump or interactive */
 401         if (argc == optind+1) {
 402                 if (opt_interactive)
 403                         interactive(fd);
 404                 else
 405                         dump_table(fd);
 406                 return 0;
 407         }
 408
 409         /* two arguments (device, mapfile): set map file */
 410         if (argc == optind+2) {
 411                 const char *filearg = argv[optind+1];
 412                 if (strchr(filearg, '/')) {
 413                         /* Keymap file argument is a path */
 414                         FILE *f = fopen(filearg, "re");
 415                         if (f)
 416                                 merge_table(fd, f);
 417                         else
 418                                 perror(filearg);
 419                 } else {
 420                         /* Keymap file argument is a filename */
 421                         /* Open override file if present, otherwise default file */
 422                         char keymap_path[PATH_MAX];
 423                         FILE *f;
 424                         snprintf(keymap_path, sizeof(keymap_path), "%s%s", SYSCONFDIR "/udev/keymaps/", filearg);
 425                         f = fopen(keymap_path, "re");
 426                         if (f) {
 427                                 merge_table(fd, f);
 428                         } else {
 429                                 snprintf(keymap_path, sizeof(keymap_path), "%s%s", UDEVLIBEXECDIR "/keymaps/", filearg);
 430                                 f = fopen(keymap_path, "re");
 431                                 if (f)
 432                                         merge_table(fd, f);
 433                                 else
 434                                         perror(keymap_path);
 435                         }
 436                 }
 437                 return 0;
 438         }
 439
 440         /* more arguments (device, scancode/keyname pairs): set keys directly */
 441         if ((argc - optind - 1) % 2 == 0) {
 442                 for (i = optind+1; i < argc; i += 2)
 443                         set_key(fd, argv[i], argv[i+1]);
 444                 return 0;
 445         }
 446
 447         /* invalid number of arguments */
 448         help(1);
 449         return 1; /* not reached */
 450 }