test/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 <dirent.h>
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <fnmatch.h>
  28 #include <limits.h>
  29 #include <locale.h>
  30 #include <signal.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33
  34 #include <sys/epoll.h>
  35 #include <linux/input.h>
  36
  37 #include "test.h"
  38
  39 struct keyboard {
  40     char *path;
  41     int fd;
  42     struct xkb_state *state;
  43     struct xkb_compose_state *compose_state;
  44     struct keyboard *next;
  45 };
  46
  47 static bool terminate;
  48 static int evdev_offset = 8;
  49 static bool report_state_changes;
  50 static bool with_compose;
  51 static enum xkb_consumed_mode consumed_mode = XKB_CONSUMED_MODE_XKB;
  52
  53 #define NLONGS(n) (((n) + LONG_BIT - 1) / LONG_BIT)
  54
  55 static bool
  56 evdev_bit_is_set(const unsigned long *array, int bit)
  57 {
  58     return array[bit / LONG_BIT] & (1LL << (bit % LONG_BIT));
  59 }
  60
  61 /* Some heuristics to see if the device is a keyboard. */
  62 static bool
  63 is_keyboard(int fd)
  64 {
  65     int i;
  66     unsigned long evbits[NLONGS(EV_CNT)] = { 0 };
  67     unsigned long keybits[NLONGS(KEY_CNT)] = { 0 };
  68
  69     errno = 0;
  70     ioctl(fd, EVIOCGBIT(0, sizeof(evbits)), evbits);
  71     if (errno)
  72         return false;
  73
  74     if (!evdev_bit_is_set(evbits, EV_KEY))
  75         return false;
  76
  77     errno = 0;
  78     ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
  79     if (errno)
  80         return false;
  81
  82     for (i = KEY_RESERVED; i <= KEY_MIN_INTERESTING; i++)
  83         if (evdev_bit_is_set(keybits, i))
  84             return true;
  85
  86     return false;
  87 }
  88
  89 static int
  90 keyboard_new(struct dirent *ent, struct xkb_keymap *keymap,
  91              struct xkb_compose_table *compose_table, struct keyboard **out)
  92 {
  93     int ret;
  94     char *path;
  95     int fd;
  96     struct xkb_state *state;
  97     struct xkb_compose_state *compose_state = NULL;
  98     struct keyboard *kbd;
  99
 100     ret = asprintf(&path, "/dev/input/%s", ent->d_name);
 101     if (ret < 0)
 102         return -ENOMEM;
 103
 104     fd = open(path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
 105     if (fd < 0) {
 106         ret = -errno;
 107         goto err_path;
 108     }
 109
 110     if (!is_keyboard(fd)) {
 111         /* Dummy "skip this device" value. */
 112         ret = -ENOTSUP;
 113         goto err_fd;
 114     }
 115
 116     state = xkb_state_new(keymap);
 117     if (!state) {
 118         fprintf(stderr, "Couldn't create xkb state for %s\n", path);
 119         ret = -EFAULT;
 120         goto err_fd;
 121     }
 122
 123     if (with_compose) {
 124         compose_state = xkb_compose_state_new(compose_table,
 125                                               XKB_COMPOSE_STATE_NO_FLAGS);
 126         if (!compose_state) {
 127             fprintf(stderr, "Couldn't create compose state for %s\n", path);
 128             ret = -EFAULT;
 129             goto err_state;
 130         }
 131     }
 132
 133     kbd = calloc(1, sizeof(*kbd));
 134     if (!kbd) {
 135         ret = -ENOMEM;
 136         goto err_compose_state;
 137     }
 138
 139     kbd->path = path;
 140     kbd->fd = fd;
 141     kbd->state = state;
 142     kbd->compose_state = compose_state;
 143     *out = kbd;
 144     return 0;
 145
 146 err_compose_state:
 147     xkb_compose_state_unref(compose_state);
 148 err_state:
 149     xkb_state_unref(state);
 150 err_fd:
 151     close(fd);
 152 err_path:
 153     free(path);
 154     return ret;
 155 }
 156
 157 static void
 158 keyboard_free(struct keyboard *kbd)
 159 {
 160     if (!kbd)
 161         return;
 162     if (kbd->fd >= 0)
 163         close(kbd->fd);
 164     free(kbd->path);
 165     xkb_state_unref(kbd->state);
 166     xkb_compose_state_unref(kbd->compose_state);
 167     free(kbd);
 168 }
 169
 170 static int
 171 filter_device_name(const struct dirent *ent)
 172 {
 173     return !fnmatch("event*", ent->d_name, 0);
 174 }
 175
 176 static struct keyboard *
 177 get_keyboards(struct xkb_keymap *keymap,
 178               struct xkb_compose_table *compose_table)
 179 {
 180     int ret, i, nents;
 181     struct dirent **ents;
 182     struct keyboard *kbds = NULL, *kbd = NULL;
 183
 184     nents = scandir("/dev/input", &ents, filter_device_name, alphasort);
 185     if (nents < 0) {
 186         fprintf(stderr, "Couldn't scan /dev/input: %s\n", strerror(errno));
 187         return NULL;
 188     }
 189
 190     for (i = 0; i < nents; i++) {
 191         ret = keyboard_new(ents[i], keymap, compose_table, &kbd);
 192         if (ret) {
 193             if (ret == -EACCES) {
 194                 fprintf(stderr, "Couldn't open /dev/input/%s: %s. "
 195                                 "You probably need root to run this.\n",
 196                         ents[i]->d_name, strerror(-ret));
 197                 break;
 198             }
 199             if (ret != -ENOTSUP) {
 200                 fprintf(stderr, "Couldn't open /dev/input/%s: %s. Skipping.\n",
 201                         ents[i]->d_name, strerror(-ret));
 202             }
 203             continue;
 204         }
 205
 206         assert(kbd != NULL);
 207         kbd->next = kbds;
 208         kbds = kbd;
 209     }
 210
 211     if (!kbds) {
 212         fprintf(stderr, "Couldn't find any keyboards I can use! Quitting.\n");
 213         goto err;
 214     }
 215
 216 err:
 217     for (i = 0; i < nents; i++)
 218         free(ents[i]);
 219     free(ents);
 220     return kbds;
 221 }
 222
 223 static void
 224 free_keyboards(struct keyboard *kbds)
 225 {
 226     struct keyboard *next;
 227
 228     while (kbds) {
 229         next = kbds->next;
 230         keyboard_free(kbds);
 231         kbds = next;
 232     }
 233 }
 234
 235 /* The meaning of the input_event 'value' field. */
 236 enum {
 237     KEY_STATE_RELEASE = 0,
 238     KEY_STATE_PRESS = 1,
 239     KEY_STATE_REPEAT = 2,
 240 };
 241
 242 static void
 243 process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
 244 {
 245     xkb_keycode_t keycode;
 246     struct xkb_keymap *keymap;
 247     enum xkb_state_component changed;
 248     enum xkb_compose_status status;
 249
 250     if (type != EV_KEY)
 251         return;
 252
 253     keycode = evdev_offset + code;
 254     keymap = xkb_state_get_keymap(kbd->state);
 255
 256     if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
 257         return;
 258
 259     if (with_compose && value != KEY_STATE_RELEASE) {
 260         xkb_keysym_t keysym = xkb_state_key_get_one_sym(kbd->state, keycode);
 261         xkb_compose_state_feed(kbd->compose_state, keysym);
 262     }
 263
 264     if (value != KEY_STATE_RELEASE)
 265         test_print_keycode_state(kbd->state, kbd->compose_state, keycode,
 266                                  consumed_mode);
 267
 268     if (with_compose) {
 269         status = xkb_compose_state_get_status(kbd->compose_state);
 270         if (status == XKB_COMPOSE_CANCELLED || status == XKB_COMPOSE_COMPOSED)
 271             xkb_compose_state_reset(kbd->compose_state);
 272     }
 273
 274     if (value == KEY_STATE_RELEASE)
 275         changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_UP);
 276     else
 277         changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
 278
 279     if (report_state_changes)
 280         test_print_state_changes(changed);
 281 }
 282
 283 static int
 284 read_keyboard(struct keyboard *kbd)
 285 {
 286     ssize_t len;
 287     struct input_event evs[16];
 288
 289     /* No fancy error checking here. */
 290     while ((len = read(kbd->fd, &evs, sizeof(evs))) > 0) {
 291         const size_t nevs = len / sizeof(struct input_event);
 292         for (size_t i = 0; i < nevs; i++)
 293             process_event(kbd, evs[i].type, evs[i].code, evs[i].value);
 294     }
 295
 296     if (len < 0 && errno != EWOULDBLOCK) {
 297         fprintf(stderr, "Couldn't read %s: %s\n", kbd->path, strerror(errno));
 298         return -errno;
 299     }
 300
 301     return 0;
 302 }
 303
 304 static int
 305 loop(struct keyboard *kbds)
 306 {
 307     int i, ret;
 308     int epfd;
 309     struct keyboard *kbd;
 310     struct epoll_event ev;
 311     struct epoll_event evs[16];
 312
 313     epfd = epoll_create1(0);
 314     if (epfd < 0) {
 315         fprintf(stderr, "Couldn't create epoll instance: %s\n",
 316                 strerror(errno));
 317         return -errno;
 318     }
 319
 320     for (kbd = kbds; kbd; kbd = kbd->next) {
 321         memset(&ev, 0, sizeof(ev));
 322         ev.events = EPOLLIN;
 323         ev.data.ptr = kbd;
 324         ret = epoll_ctl(epfd, EPOLL_CTL_ADD, kbd->fd, &ev);
 325         if (ret) {
 326             ret = -errno;
 327             fprintf(stderr, "Couldn't add %s to epoll: %s\n",
 328                     kbd->path, strerror(errno));
 329             goto err_epoll;
 330         }
 331     }
 332
 333     while (!terminate) {
 334         ret = epoll_wait(epfd, evs, 16, -1);
 335         if (ret < 0) {
 336             if (errno == EINTR)
 337                 continue;
 338             ret = -errno;
 339             fprintf(stderr, "Couldn't poll for events: %s\n",
 340                     strerror(errno));
 341             goto err_epoll;
 342         }
 343
 344         for (i = 0; i < ret; i++) {
 345             kbd = evs[i].data.ptr;
 346             ret = read_keyboard(kbd);
 347             if (ret) {
 348                 goto err_epoll;
 349             }
 350         }
 351     }
 352
 353     close(epfd);
 354     return 0;
 355
 356 err_epoll:
 357     close(epfd);
 358     return ret;
 359 }
 360
 361 static void
 362 sigintr_handler(int signum)
 363 {
 364     terminate = true;
 365 }
 366
 367 int
 368 main(int argc, char *argv[])
 369 {
 370     int ret;
 371     int opt;
 372     struct keyboard *kbds;
 373     struct xkb_context *ctx;
 374     struct xkb_keymap *keymap;
 375     struct xkb_compose_table *compose_table = NULL;
 376     const char *rules = NULL;
 377     const char *model = NULL;
 378     const char *layout = NULL;
 379     const char *variant = NULL;
 380     const char *options = NULL;
 381     const char *keymap_path = NULL;
 382     const char *locale;
 383     struct sigaction act;
 384
 385     setlocale(LC_ALL, "");
 386
 387     while ((opt = getopt(argc, argv, "r:m:l:v:o:k:n:cdg")) != -1) {
 388         switch (opt) {
 389         case 'r':
 390             rules = optarg;
 391             break;
 392         case 'm':
 393             model = optarg;
 394             break;
 395         case 'l':
 396             layout = optarg;
 397             break;
 398         case 'v':
 399             variant = optarg;
 400             break;
 401         case 'o':
 402             options = optarg;
 403             break;
 404         case 'k':
 405             keymap_path = optarg;
 406             break;
 407         case 'n':
 408             errno = 0;
 409             evdev_offset = strtol(optarg, NULL, 10);
 410             if (errno) {
 411                 fprintf(stderr, "error: -n option expects a number\n");
 412                 exit(EXIT_FAILURE);
 413             }
 414             break;
 415         case 'c':
 416             report_state_changes = true;
 417             break;
 418         case 'd':
 419             with_compose = true;
 420             break;
 421         case 'g':
 422             consumed_mode = XKB_CONSUMED_MODE_GTK;
 423             break;
 424         case '?':
 425             fprintf(stderr, "   Usage: %s [-r <rules>] [-m <model>] "
 426                     "[-l <layout>] [-v <variant>] [-o <options>]\n",
 427                     argv[0]);
 428             fprintf(stderr, "      or: %s -k <path to keymap file>\n",
 429                     argv[0]);
 430             fprintf(stderr, "For both: -n <evdev keycode offset>\n"
 431                             "          -c (to report changes to the state)\n"
 432                             "          -d (to enable compose)\n"
 433                             "          -g (to use GTK consumed mode)\n");
 434             exit(2);
 435         }
 436     }
 437
 438     ctx = test_get_context(0);
 439     if (!ctx) {
 440         ret = -1;
 441         fprintf(stderr, "Couldn't create xkb context\n");
 442         goto err_out;
 443     }
 444
 445     if (keymap_path) {
 446         FILE *file = fopen(keymap_path, "r");
 447         if (!file) {
 448             ret = EXIT_FAILURE;
 449             fprintf(stderr, "Couldn't open '%s': %s\n",
 450                     keymap_path, strerror(errno));
 451             goto err_ctx;
 452         }
 453         keymap = xkb_keymap_new_from_file(ctx, file,
 454                                           XKB_KEYMAP_FORMAT_TEXT_V1, 0);
 455         fclose(file);
 456     }
 457     else {
 458         keymap = test_compile_rules(ctx, rules, model, layout, variant,
 459                                     options);
 460     }
 461
 462     if (!keymap) {
 463         ret = -1;
 464         fprintf(stderr, "Couldn't create xkb keymap\n");
 465         goto err_ctx;
 466     }
 467
 468     if (with_compose) {
 469         locale = setlocale(LC_CTYPE, NULL);
 470         compose_table =
 471             xkb_compose_table_new_from_locale(ctx, locale,
 472                                               XKB_COMPOSE_COMPILE_NO_FLAGS);
 473         if (!compose_table) {
 474             ret = -1;
 475             fprintf(stderr, "Couldn't create compose from locale\n");
 476             goto err_xkb;
 477         }
 478     }
 479
 480     kbds = get_keyboards(keymap, compose_table);
 481     if (!kbds) {
 482         ret = -1;
 483         goto err_compose;
 484     }
 485
 486     act.sa_handler = sigintr_handler;
 487     sigemptyset(&act.sa_mask);
 488     act.sa_flags = 0;
 489     sigaction(SIGINT, &act, NULL);
 490     sigaction(SIGTERM, &act, NULL);
 491
 492     test_disable_stdin_echo();
 493     ret = loop(kbds);
 494     test_enable_stdin_echo();
 495
 496     free_keyboards(kbds);
 497 err_compose:
 498     xkb_compose_table_unref(compose_table);
 499 err_xkb:
 500     xkb_keymap_unref(keymap);
 501 err_ctx:
 502     xkb_context_unref(ctx);
 503 err_out:
 504     exit(ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 505 }