2 * Copyright © 2012 Ran Benita <ran234@gmail.com>
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:
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
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.
34 #include <sys/epoll.h>
35 #include <linux/input.h>
42 struct xkb_state *state;
43 struct keyboard *next;
46 static bool terminate;
47 static int evdev_offset = 8;
48 static bool report_state_changes;
50 #define NLONGS(n) (((n) + LONG_BIT - 1) / LONG_BIT)
53 evdev_bit_is_set(const unsigned long *array, int bit)
55 return array[bit / LONG_BIT] & (1LL << (bit % LONG_BIT));
58 /* Some heuristics to see if the device is a keyboard. */
63 unsigned long evbits[NLONGS(EV_CNT)] = { 0 };
64 unsigned long keybits[NLONGS(KEY_CNT)] = { 0 };
67 ioctl(fd, EVIOCGBIT(0, sizeof(evbits)), evbits);
71 if (!evdev_bit_is_set(evbits, EV_KEY))
75 ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
79 for (i = KEY_RESERVED; i <= KEY_MIN_INTERESTING; i++)
80 if (evdev_bit_is_set(keybits, i))
87 keyboard_new(struct dirent *ent, struct xkb_keymap *keymap,
88 struct keyboard **out)
93 struct xkb_state *state;
96 ret = asprintf(&path, "/dev/input/%s", ent->d_name);
100 fd = open(path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
106 if (!is_keyboard(fd)) {
107 /* Dummy "skip this device" value. */
112 state = xkb_state_new(keymap);
114 fprintf(stderr, "Couldn't create xkb state for %s\n", path);
119 kbd = calloc(1, sizeof(*kbd));
132 xkb_state_unref(state);
141 keyboard_free(struct keyboard *kbd)
148 xkb_state_unref(kbd->state);
153 filter_device_name(const struct dirent *ent)
155 return !fnmatch("event*", ent->d_name, 0);
158 static struct keyboard *
159 get_keyboards(struct xkb_keymap *keymap)
162 struct dirent **ents;
163 struct keyboard *kbds = NULL, *kbd = NULL;
165 nents = scandir("/dev/input", &ents, filter_device_name, alphasort);
167 fprintf(stderr, "Couldn't scan /dev/input: %s\n", strerror(errno));
171 for (i = 0; i < nents; i++) {
172 ret = keyboard_new(ents[i], keymap, &kbd);
174 if (ret == -EACCES) {
175 fprintf(stderr, "Couldn't open /dev/input/%s: %s. "
176 "You probably need root to run this.\n",
177 ents[i]->d_name, strerror(-ret));
180 if (ret != -ENOTSUP) {
181 fprintf(stderr, "Couldn't open /dev/input/%s: %s. Skipping.\n",
182 ents[i]->d_name, strerror(-ret));
192 fprintf(stderr, "Couldn't find any keyboards I can use! Quitting.\n");
197 for (i = 0; i < nents; i++)
204 free_keyboards(struct keyboard *kbds)
206 struct keyboard *next;
215 /* The meaning of the input_event 'value' field. */
217 KEY_STATE_RELEASE = 0,
219 KEY_STATE_REPEAT = 2,
223 process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
225 xkb_keycode_t keycode;
226 struct xkb_keymap *keymap;
227 enum xkb_state_component changed;
232 keycode = evdev_offset + code;
233 keymap = xkb_state_get_keymap(kbd->state);
235 if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
238 if (value != KEY_STATE_RELEASE)
239 test_print_keycode_state(kbd->state, keycode);
241 if (value == KEY_STATE_RELEASE)
242 changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_UP);
244 changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
246 if (report_state_changes)
247 test_print_state_changes(changed);
251 read_keyboard(struct keyboard *kbd)
254 struct input_event evs[16];
256 /* No fancy error checking here. */
257 while ((len = read(kbd->fd, &evs, sizeof(evs))) > 0) {
258 const size_t nevs = len / sizeof(struct input_event);
259 for (size_t i = 0; i < nevs; i++)
260 process_event(kbd, evs[i].type, evs[i].code, evs[i].value);
263 if (len < 0 && errno != EWOULDBLOCK) {
264 fprintf(stderr, "Couldn't read %s: %s\n", kbd->path, strerror(errno));
272 loop(struct keyboard *kbds)
276 struct keyboard *kbd;
277 struct epoll_event ev;
278 struct epoll_event evs[16];
280 epfd = epoll_create1(0);
282 fprintf(stderr, "Couldn't create epoll instance: %s\n",
287 for (kbd = kbds; kbd; kbd = kbd->next) {
288 memset(&ev, 0, sizeof(ev));
291 ret = epoll_ctl(epfd, EPOLL_CTL_ADD, kbd->fd, &ev);
294 fprintf(stderr, "Couldn't add %s to epoll: %s\n",
295 kbd->path, strerror(errno));
301 ret = epoll_wait(epfd, evs, 16, -1);
306 fprintf(stderr, "Couldn't poll for events: %s\n",
311 for (i = 0; i < ret; i++) {
312 kbd = evs[i].data.ptr;
313 ret = read_keyboard(kbd);
329 sigintr_handler(int signum)
335 main(int argc, char *argv[])
339 struct keyboard *kbds;
340 struct xkb_context *ctx;
341 struct xkb_keymap *keymap;
342 const char *rules = NULL;
343 const char *model = NULL;
344 const char *layout = NULL;
345 const char *variant = NULL;
346 const char *options = NULL;
347 const char *keymap_path = NULL;
348 struct sigaction act;
350 setlocale(LC_ALL, "");
352 while ((opt = getopt(argc, argv, "r:m:l:v:o:k:n:c")) != -1) {
370 keymap_path = optarg;
374 evdev_offset = strtol(optarg, NULL, 10);
376 fprintf(stderr, "error: -n option expects a number\n");
381 report_state_changes = true;
384 fprintf(stderr, " Usage: %s [-r <rules>] [-m <model>] "
385 "[-l <layout>] [-v <variant>] [-o <options>]\n",
387 fprintf(stderr, " or: %s -k <path to keymap file>\n",
389 fprintf(stderr, "For both: -n <evdev keycode offset>\n"
390 " -c (to report changes to the state)\n");
395 ctx = test_get_context(0);
398 fprintf(stderr, "Couldn't create xkb context\n");
403 FILE *file = fopen(keymap_path, "r");
406 fprintf(stderr, "Couldn't open '%s': %s\n",
407 keymap_path, strerror(errno));
410 keymap = xkb_keymap_new_from_file(ctx, file,
411 XKB_KEYMAP_FORMAT_TEXT_V1, 0);
415 keymap = test_compile_rules(ctx, rules, model, layout, variant,
421 fprintf(stderr, "Couldn't create xkb keymap\n");
425 kbds = get_keyboards(keymap);
431 act.sa_handler = sigintr_handler;
432 sigemptyset(&act.sa_mask);
434 sigaction(SIGINT, &act, NULL);
435 sigaction(SIGTERM, &act, NULL);
437 /* Instead of fiddling with termios.. */
438 system("stty -echo");
446 free_keyboards(kbds);
448 xkb_keymap_unref(keymap);
450 xkb_context_unref(ctx);
452 exit(ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);