tools/interactive-evdev.c

   1 /*
   2  * Copyright © 2012 Ran Benita <ran234@gmail.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "config.h"
  25
  26 #include <assert.h>
  27 #include <dirent.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <fnmatch.h>
  31 #include <getopt.h>
  32 #include <limits.h>
  33 #include <locale.h>
  34 #include <signal.h>
  35 #include <stdbool.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40
  41 #include <sys/epoll.h>
  42 #include <linux/input.h>
  43
  44 #include "xkbcommon/xkbcommon.h"
  45
  46 #include "tools-common.h"
  47
  48 struct keyboard {
  49     char *path;
  50     int fd;
  51     struct xkb_state *state;
  52     struct xkb_compose_state *compose_state;
  53     struct keyboard *next;
  54 };
  55
  56 static bool terminate;
  57 static int evdev_offset = 8;
  58 static bool report_state_changes;
  59 static bool with_compose;
  60 static enum xkb_consumed_mode consumed_mode = XKB_CONSUMED_MODE_XKB;
  61
  62 #define NLONGS(n) (((n) + LONG_BIT - 1) / LONG_BIT)
  63
  64 static bool
  65 evdev_bit_is_set(const unsigned long *array, int bit)
  66 {
  67     return array[bit / LONG_BIT] & (1LL << (bit % LONG_BIT));
  68 }
  69
  70 /* Some heuristics to see if the device is a keyboard. */
  71 static bool
  72 is_keyboard(int fd)
  73 {
  74     int i;
  75     unsigned long evbits[NLONGS(EV_CNT)] = { 0 };
  76     unsigned long keybits[NLONGS(KEY_CNT)] = { 0 };
  77
  78     errno = 0;
  79     ioctl(fd, EVIOCGBIT(0, sizeof(evbits)), evbits);
  80     if (errno)
  81         return false;
  82
  83     if (!evdev_bit_is_set(evbits, EV_KEY))
  84         return false;
  85
  86     errno = 0;
  87     ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
  88     if (errno)
  89         return false;
  90
  91     for (i = KEY_RESERVED; i <= KEY_MIN_INTERESTING; i++)
  92         if (evdev_bit_is_set(keybits, i))
  93             return true;
  94
  95     return false;
  96 }
  97
  98 static int
  99 keyboard_new(struct dirent *ent, struct xkb_keymap *keymap,
 100              struct xkb_compose_table *compose_table, struct keyboard **out)
 101 {
 102     int ret;
 103     char *path;
 104     int fd;
 105     struct xkb_state *state;
 106     struct xkb_compose_state *compose_state = NULL;
 107     struct keyboard *kbd;
 108
 109     ret = asprintf(&path, "/dev/input/%s", ent->d_name);
 110     if (ret < 0)
 111         return -ENOMEM;
 112
 113     fd = open(path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
 114     if (fd < 0) {
 115         ret = -errno;
 116         goto err_path;
 117     }
 118
 119     if (!is_keyboard(fd)) {
 120         /* Dummy "skip this device" value. */
 121         ret = -ENOTSUP;
 122         goto err_fd;
 123     }
 124
 125     state = xkb_state_new(keymap);
 126     if (!state) {
 127         fprintf(stderr, "Couldn't create xkb state for %s\n", path);
 128         ret = -EFAULT;
 129         goto err_fd;
 130     }
 131
 132     if (with_compose) {
 133         compose_state = xkb_compose_state_new(compose_table,
 134                                               XKB_COMPOSE_STATE_NO_FLAGS);
 135         if (!compose_state) {
 136             fprintf(stderr, "Couldn't create compose state for %s\n", path);
 137             ret = -EFAULT;
 138             goto err_state;
 139         }
 140     }
 141
 142     kbd = calloc(1, sizeof(*kbd));
 143     if (!kbd) {
 144         ret = -ENOMEM;
 145         goto err_compose_state;
 146     }
 147
 148     kbd->path = path;
 149     kbd->fd = fd;
 150     kbd->state = state;
 151     kbd->compose_state = compose_state;
 152     *out = kbd;
 153     return 0;
 154
 155 err_compose_state:
 156     xkb_compose_state_unref(compose_state);
 157 err_state:
 158     xkb_state_unref(state);
 159 err_fd:
 160     close(fd);
 161 err_path:
 162     free(path);
 163     return ret;
 164 }
 165
 166 static void
 167 keyboard_free(struct keyboard *kbd)
 168 {
 169     if (!kbd)
 170         return;
 171     if (kbd->fd >= 0)
 172         close(kbd->fd);
 173     free(kbd->path);
 174     xkb_state_unref(kbd->state);
 175     xkb_compose_state_unref(kbd->compose_state);
 176     free(kbd);
 177 }
 178
 179 static int
 180 filter_device_name(const struct dirent *ent)
 181 {
 182     return !fnmatch("event*", ent->d_name, 0);
 183 }
 184
 185 static struct keyboard *
 186 get_keyboards(struct xkb_keymap *keymap,
 187               struct xkb_compose_table *compose_table)
 188 {
 189     int ret, i, nents;
 190     struct dirent **ents;
 191     struct keyboard *kbds = NULL, *kbd = NULL;
 192
 193     nents = scandir("/dev/input", &ents, filter_device_name, alphasort);
 194     if (nents < 0) {
 195         fprintf(stderr, "Couldn't scan /dev/input: %s\n", strerror(errno));
 196         return NULL;
 197     }
 198
 199     for (i = 0; i < nents; i++) {
 200         ret = keyboard_new(ents[i], keymap, compose_table, &kbd);
 201         if (ret) {
 202             if (ret == -EACCES) {
 203                 fprintf(stderr, "Couldn't open /dev/input/%s: %s. "
 204                                 "You probably need root to run this.\n",
 205                         ents[i]->d_name, strerror(-ret));
 206                 break;
 207             }
 208             if (ret != -ENOTSUP) {
 209                 fprintf(stderr, "Couldn't open /dev/input/%s: %s. Skipping.\n",
 210                         ents[i]->d_name, strerror(-ret));
 211             }
 212             continue;
 213         }
 214
 215         assert(kbd != NULL);
 216         kbd->next = kbds;
 217         kbds = kbd;
 218     }
 219
 220     if (!kbds) {
 221         fprintf(stderr, "Couldn't find any keyboards I can use! Quitting.\n");
 222         goto err;
 223     }
 224
 225 err:
 226     for (i = 0; i < nents; i++)
 227         free(ents[i]);
 228     free(ents);
 229     return kbds;
 230 }
 231
 232 static void
 233 free_keyboards(struct keyboard *kbds)
 234 {
 235     struct keyboard *next;
 236
 237     while (kbds) {
 238         next = kbds->next;
 239         keyboard_free(kbds);
 240         kbds = next;
 241     }
 242 }
 243
 244 /* The meaning of the input_event 'value' field. */
 245 enum {
 246     KEY_STATE_RELEASE = 0,
 247     KEY_STATE_PRESS = 1,
 248     KEY_STATE_REPEAT = 2,
 249 };
 250
 251 static void
 252 process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
 253 {
 254     xkb_keycode_t keycode;
 255     struct xkb_keymap *keymap;
 256     enum xkb_state_component changed;
 257     enum xkb_compose_status status;
 258
 259     if (type != EV_KEY)
 260         return;
 261
 262     keycode = evdev_offset + code;
 263     keymap = xkb_state_get_keymap(kbd->state);
 264
 265     if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
 266         return;
 267
 268     if (with_compose && value != KEY_STATE_RELEASE) {
 269         xkb_keysym_t keysym = xkb_state_key_get_one_sym(kbd->state, keycode);
 270         xkb_compose_state_feed(kbd->compose_state, keysym);
 271     }
 272
 273     if (value != KEY_STATE_RELEASE)
 274         tools_print_keycode_state(kbd->state, kbd->compose_state, keycode,
 275                                   consumed_mode);
 276
 277     if (with_compose) {
 278         status = xkb_compose_state_get_status(kbd->compose_state);
 279         if (status == XKB_COMPOSE_CANCELLED || status == XKB_COMPOSE_COMPOSED)
 280             xkb_compose_state_reset(kbd->compose_state);
 281     }
 282
 283     if (value == KEY_STATE_RELEASE)
 284         changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_UP);
 285     else
 286         changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
 287
 288     if (report_state_changes)
 289         tools_print_state_changes(changed);
 290 }
 291
 292 static int
 293 read_keyboard(struct keyboard *kbd)
 294 {
 295     ssize_t len;
 296     struct input_event evs[16];
 297
 298     /* No fancy error checking here. */
 299     while ((len = read(kbd->fd, &evs, sizeof(evs))) > 0) {
 300         const size_t nevs = len / sizeof(struct input_event);
 301         for (size_t i = 0; i < nevs; i++)
 302             process_event(kbd, evs[i].type, evs[i].code, evs[i].value);
 303     }
 304
 305     if (len < 0 && errno != EWOULDBLOCK) {
 306         fprintf(stderr, "Couldn't read %s: %s\n", kbd->path, strerror(errno));
 307         return 1;
 308     }
 309
 310     return 0;
 311 }
 312
 313 static int
 314 loop(struct keyboard *kbds)
 315 {
 316     int i, ret = 1;
 317     int epfd = -1;
 318     struct keyboard *kbd;
 319     struct epoll_event ev;
 320     struct epoll_event evs[16];
 321
 322     epfd = epoll_create1(0);
 323     if (epfd < 0) {
 324         fprintf(stderr, "Couldn't create epoll instance: %s\n",
 325                 strerror(errno));
 326         goto out;
 327     }
 328
 329     for (kbd = kbds; kbd; kbd = kbd->next) {
 330         memset(&ev, 0, sizeof(ev));
 331         ev.events = EPOLLIN;
 332         ev.data.ptr = kbd;
 333         ret = epoll_ctl(epfd, EPOLL_CTL_ADD, kbd->fd, &ev);
 334         if (ret) {
 335             fprintf(stderr, "Couldn't add %s to epoll: %s\n",
 336                     kbd->path, strerror(errno));
 337             goto out;
 338         }
 339     }
 340
 341     while (!terminate) {
 342         ret = epoll_wait(epfd, evs, 16, -1);
 343         if (ret < 0) {
 344             if (errno == EINTR)
 345                 continue;
 346             fprintf(stderr, "Couldn't poll for events: %s\n",
 347                     strerror(errno));
 348             goto out;
 349         }
 350
 351         for (i = 0; i < ret; i++) {
 352             kbd = evs[i].data.ptr;
 353             ret = read_keyboard(kbd);
 354             if (ret) {
 355                 goto out;
 356             }
 357         }
 358     }
 359
 360     ret = 0;
 361 out:
 362     close(epfd);
 363     return ret;
 364 }
 365
 366 static void
 367 sigintr_handler(int signum)
 368 {
 369     terminate = true;
 370 }
 371
 372 static void
 373 usage(FILE *fp, char *progname)
 374 {
 375         fprintf(fp, "Usage: %s [--rules=<rules>] [--model=<model>] "
 376                 "[--layout=<layout>] [--variant=<variant>] [--options=<options>]\n",
 377                 progname);
 378         fprintf(fp, "      or: %s --keymap <path to keymap file>\n",
 379                 progname);
 380         fprintf(fp, "For both:\n"
 381                         "          --report-state-changes (report changes to the state)\n"
 382                         "          --enable-compose (enable Compose)\n"
 383                         "          --consumed-mode={xkb|gtk} (select the consumed modifiers mode, default: xkb)\n"
 384                         "          --without-x11-offset (don't add X11 keycode offset)\n"
 385         );
 386 }
 387
 388 int
 389 main(int argc, char *argv[])
 390 {
 391     int ret = EXIT_FAILURE;
 392     struct keyboard *kbds;
 393     struct xkb_context *ctx = NULL;
 394     struct xkb_keymap *keymap = NULL;
 395     struct xkb_compose_table *compose_table = NULL;
 396     const char *rules = NULL;
 397     const char *model = NULL;
 398     const char *layout = NULL;
 399     const char *variant = NULL;
 400     const char *options = NULL;
 401     const char *keymap_path = NULL;
 402     const char *locale;
 403     struct sigaction act;
 404     enum options {
 405         OPT_RULES,
 406         OPT_MODEL,
 407         OPT_LAYOUT,
 408         OPT_VARIANT,
 409         OPT_OPTION,
 410         OPT_KEYMAP,
 411         OPT_WITHOUT_X11_OFFSET,
 412         OPT_CONSUMED_MODE,
 413         OPT_COMPOSE,
 414         OPT_REPORT_STATE,
 415     };
 416     static struct option opts[] = {
 417         {"help",                 no_argument,            0, 'h'},
 418         {"rules",                required_argument,      0, OPT_RULES},
 419         {"model",                required_argument,      0, OPT_MODEL},
 420         {"layout",               required_argument,      0, OPT_LAYOUT},
 421         {"variant",              required_argument,      0, OPT_VARIANT},
 422         {"options",              required_argument,      0, OPT_OPTION},
 423         {"keymap",               required_argument,      0, OPT_KEYMAP},
 424         {"consumed-mode",        required_argument,      0, OPT_CONSUMED_MODE},
 425         {"enable-compose",       no_argument,            0, OPT_COMPOSE},
 426         {"report-state-changes", no_argument,            0, OPT_REPORT_STATE},
 427         {"without-x11-offset",   no_argument,            0, OPT_WITHOUT_X11_OFFSET},
 428         {0, 0, 0, 0},
 429     };
 430
 431     setlocale(LC_ALL, "");
 432
 433     while (1) {
 434         int opt;
 435         int option_index = 0;
 436
 437         opt = getopt_long(argc, argv, "h", opts, &option_index);
 438         if (opt == -1)
 439             break;
 440
 441         switch (opt) {
 442         case OPT_RULES:
 443             rules = optarg;
 444             break;
 445         case OPT_MODEL:
 446             model = optarg;
 447             break;
 448         case OPT_LAYOUT:
 449             layout = optarg;
 450             break;
 451         case OPT_VARIANT:
 452             variant = optarg;
 453             break;
 454         case OPT_OPTION:
 455             options = optarg;
 456             break;
 457         case OPT_KEYMAP:
 458             keymap_path = optarg;
 459             break;
 460         case OPT_WITHOUT_X11_OFFSET:
 461             evdev_offset = 0;
 462             break;
 463         case OPT_REPORT_STATE:
 464             report_state_changes = true;
 465             break;
 466         case OPT_COMPOSE:
 467             with_compose = true;
 468             break;
 469         case OPT_CONSUMED_MODE:
 470             if (strcmp(optarg, "gtk") == 0) {
 471                 consumed_mode = XKB_CONSUMED_MODE_GTK;
 472             } else if (strcmp(optarg, "xkb") == 0) {
 473                 consumed_mode = XKB_CONSUMED_MODE_XKB;
 474             } else {
 475                 fprintf(stderr, "error: invalid --consumed-mode \"%s\"\n", optarg);
 476                 usage(stderr, argv[0]);
 477                 return EXIT_INVALID_USAGE;
 478             }
 479             break;
 480         case 'h':
 481             usage(stdout, argv[0]);
 482             return EXIT_SUCCESS;
 483         case '?':
 484             usage(stderr, argv[0]);
 485             return EXIT_INVALID_USAGE;
 486         }
 487     }
 488
 489     ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
 490     if (!ctx) {
 491         fprintf(stderr, "Couldn't create xkb context\n");
 492         goto out;
 493     }
 494
 495     if (keymap_path) {
 496         FILE *file = fopen(keymap_path, "rb");
 497         if (!file) {
 498             fprintf(stderr, "Couldn't open '%s': %s\n",
 499                     keymap_path, strerror(errno));
 500             goto out;
 501         }
 502         keymap = xkb_keymap_new_from_file(ctx, file,
 503                                           XKB_KEYMAP_FORMAT_TEXT_V1,
 504                                           XKB_KEYMAP_COMPILE_NO_FLAGS);
 505         fclose(file);
 506     }
 507     else {
 508         struct xkb_rule_names rmlvo = {
 509             .rules = (rules == NULL || rules[0] == '\0') ? NULL : rules,
 510             .model = (model == NULL || model[0] == '\0') ? NULL : model,
 511             .layout = (layout == NULL || layout[0] == '\0') ? NULL : layout,
 512             .variant = (variant == NULL || variant[0] == '\0') ? NULL : variant,
 513             .options = (options == NULL || options[0] == '\0') ? NULL : options
 514         };
 515
 516         if (!rules && !model && !layout && !variant && !options)
 517             keymap = xkb_keymap_new_from_names(ctx, NULL, 0);
 518         else
 519             keymap = xkb_keymap_new_from_names(ctx, &rmlvo, 0);
 520
 521         if (!keymap) {
 522             fprintf(stderr,
 523                     "Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
 524                     rules, model, layout, variant, options);
 525             goto out;
 526         }
 527     }
 528
 529     if (!keymap) {
 530         fprintf(stderr, "Couldn't create xkb keymap\n");
 531         goto out;
 532     }
 533
 534     if (with_compose) {
 535         locale = setlocale(LC_CTYPE, NULL);
 536         compose_table =
 537             xkb_compose_table_new_from_locale(ctx, locale,
 538                                               XKB_COMPOSE_COMPILE_NO_FLAGS);
 539         if (!compose_table) {
 540             fprintf(stderr, "Couldn't create compose from locale\n");
 541             goto out;
 542         }
 543     }
 544
 545     kbds = get_keyboards(keymap, compose_table);
 546     if (!kbds) {
 547         goto out;
 548     }
 549
 550     act.sa_handler = sigintr_handler;
 551     sigemptyset(&act.sa_mask);
 552     act.sa_flags = 0;
 553     sigaction(SIGINT, &act, NULL);
 554     sigaction(SIGTERM, &act, NULL);
 555
 556     tools_disable_stdin_echo();
 557     ret = loop(kbds);
 558     tools_enable_stdin_echo();
 559
 560     free_keyboards(kbds);
 561 out:
 562     xkb_compose_table_unref(compose_table);
 563     xkb_keymap_unref(keymap);
 564     xkb_context_unref(ctx);
 565
 566     return ret;
 567 }