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.
40 #include <sys/epoll.h>
41 #include <linux/input.h>
43 #include "xkbcommon/xkbcommon.h"
45 #include "tools-common.h"
50 struct xkb_state *state;
51 struct xkb_compose_state *compose_state;
52 struct keyboard *next;
55 static bool terminate;
56 static int evdev_offset = 8;
57 static bool report_state_changes;
58 static bool with_compose;
59 static enum xkb_consumed_mode consumed_mode = XKB_CONSUMED_MODE_XKB;
61 #define NLONGS(n) (((n) + LONG_BIT - 1) / LONG_BIT)
64 evdev_bit_is_set(const unsigned long *array, int bit)
66 return array[bit / LONG_BIT] & (1LL << (bit % LONG_BIT));
69 /* Some heuristics to see if the device is a keyboard. */
74 unsigned long evbits[NLONGS(EV_CNT)] = { 0 };
75 unsigned long keybits[NLONGS(KEY_CNT)] = { 0 };
78 ioctl(fd, EVIOCGBIT(0, sizeof(evbits)), evbits);
82 if (!evdev_bit_is_set(evbits, EV_KEY))
86 ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
90 for (i = KEY_RESERVED; i <= KEY_MIN_INTERESTING; i++)
91 if (evdev_bit_is_set(keybits, i))
98 keyboard_new(struct dirent *ent, struct xkb_keymap *keymap,
99 struct xkb_compose_table *compose_table, struct keyboard **out)
104 struct xkb_state *state;
105 struct xkb_compose_state *compose_state = NULL;
106 struct keyboard *kbd;
108 ret = asprintf(&path, "/dev/input/%s", ent->d_name);
112 fd = open(path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
118 if (!is_keyboard(fd)) {
119 /* Dummy "skip this device" value. */
124 state = xkb_state_new(keymap);
126 fprintf(stderr, "Couldn't create xkb state for %s\n", path);
132 compose_state = xkb_compose_state_new(compose_table,
133 XKB_COMPOSE_STATE_NO_FLAGS);
134 if (!compose_state) {
135 fprintf(stderr, "Couldn't create compose state for %s\n", path);
141 kbd = calloc(1, sizeof(*kbd));
144 goto err_compose_state;
150 kbd->compose_state = compose_state;
155 xkb_compose_state_unref(compose_state);
157 xkb_state_unref(state);
166 keyboard_free(struct keyboard *kbd)
173 xkb_state_unref(kbd->state);
174 xkb_compose_state_unref(kbd->compose_state);
179 filter_device_name(const struct dirent *ent)
181 return !fnmatch("event*", ent->d_name, 0);
184 static struct keyboard *
185 get_keyboards(struct xkb_keymap *keymap,
186 struct xkb_compose_table *compose_table)
189 struct dirent **ents;
190 struct keyboard *kbds = NULL, *kbd = NULL;
192 nents = scandir("/dev/input", &ents, filter_device_name, alphasort);
194 fprintf(stderr, "Couldn't scan /dev/input: %s\n", strerror(errno));
198 for (i = 0; i < nents; i++) {
199 ret = keyboard_new(ents[i], keymap, compose_table, &kbd);
201 if (ret == -EACCES) {
202 fprintf(stderr, "Couldn't open /dev/input/%s: %s. "
203 "You probably need root to run this.\n",
204 ents[i]->d_name, strerror(-ret));
207 if (ret != -ENOTSUP) {
208 fprintf(stderr, "Couldn't open /dev/input/%s: %s. Skipping.\n",
209 ents[i]->d_name, strerror(-ret));
220 fprintf(stderr, "Couldn't find any keyboards I can use! Quitting.\n");
225 for (i = 0; i < nents; i++)
232 free_keyboards(struct keyboard *kbds)
234 struct keyboard *next;
243 /* The meaning of the input_event 'value' field. */
245 KEY_STATE_RELEASE = 0,
247 KEY_STATE_REPEAT = 2,
251 process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
253 xkb_keycode_t keycode;
254 struct xkb_keymap *keymap;
255 enum xkb_state_component changed;
256 enum xkb_compose_status status;
261 keycode = evdev_offset + code;
262 keymap = xkb_state_get_keymap(kbd->state);
264 if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
267 if (with_compose && value != KEY_STATE_RELEASE) {
268 xkb_keysym_t keysym = xkb_state_key_get_one_sym(kbd->state, keycode);
269 xkb_compose_state_feed(kbd->compose_state, keysym);
272 if (value != KEY_STATE_RELEASE)
273 tools_print_keycode_state(kbd->state, kbd->compose_state, keycode,
277 status = xkb_compose_state_get_status(kbd->compose_state);
278 if (status == XKB_COMPOSE_CANCELLED || status == XKB_COMPOSE_COMPOSED)
279 xkb_compose_state_reset(kbd->compose_state);
282 if (value == KEY_STATE_RELEASE)
283 changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_UP);
285 changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
287 if (report_state_changes)
288 tools_print_state_changes(changed);
292 read_keyboard(struct keyboard *kbd)
295 struct input_event evs[16];
297 /* No fancy error checking here. */
298 while ((len = read(kbd->fd, &evs, sizeof(evs))) > 0) {
299 const size_t nevs = len / sizeof(struct input_event);
300 for (size_t i = 0; i < nevs; i++)
301 process_event(kbd, evs[i].type, evs[i].code, evs[i].value);
304 if (len < 0 && errno != EWOULDBLOCK) {
305 fprintf(stderr, "Couldn't read %s: %s\n", kbd->path, strerror(errno));
313 loop(struct keyboard *kbds)
317 struct keyboard *kbd;
318 struct epoll_event ev;
319 struct epoll_event evs[16];
321 epfd = epoll_create1(0);
323 fprintf(stderr, "Couldn't create epoll instance: %s\n",
328 for (kbd = kbds; kbd; kbd = kbd->next) {
329 memset(&ev, 0, sizeof(ev));
332 ret = epoll_ctl(epfd, EPOLL_CTL_ADD, kbd->fd, &ev);
334 fprintf(stderr, "Couldn't add %s to epoll: %s\n",
335 kbd->path, strerror(errno));
341 ret = epoll_wait(epfd, evs, 16, -1);
345 fprintf(stderr, "Couldn't poll for events: %s\n",
350 for (i = 0; i < ret; i++) {
351 kbd = evs[i].data.ptr;
352 ret = read_keyboard(kbd);
366 sigintr_handler(int signum)
372 main(int argc, char *argv[])
374 int ret = EXIT_FAILURE;
376 struct keyboard *kbds;
377 struct xkb_context *ctx = NULL;
378 struct xkb_keymap *keymap = NULL;
379 struct xkb_compose_table *compose_table = NULL;
380 const char *rules = NULL;
381 const char *model = NULL;
382 const char *layout = NULL;
383 const char *variant = NULL;
384 const char *options = NULL;
385 const char *keymap_path = NULL;
387 struct sigaction act;
389 setlocale(LC_ALL, "");
391 while ((opt = getopt(argc, argv, "r:m:l:v:o:k:n:cdg")) != -1) {
409 keymap_path = optarg;
413 evdev_offset = strtol(optarg, NULL, 10);
415 fprintf(stderr, "error: -n option expects a number\n");
420 report_state_changes = true;
426 consumed_mode = XKB_CONSUMED_MODE_GTK;
429 fprintf(stderr, " Usage: %s [-r <rules>] [-m <model>] "
430 "[-l <layout>] [-v <variant>] [-o <options>]\n",
432 fprintf(stderr, " or: %s -k <path to keymap file>\n",
434 fprintf(stderr, "For both: -n <evdev keycode offset>\n"
435 " -c (to report changes to the state)\n"
436 " -d (to enable compose)\n"
437 " -g (to use GTK consumed mode)\n");
442 ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
444 fprintf(stderr, "Couldn't create xkb context\n");
449 FILE *file = fopen(keymap_path, "rb");
451 fprintf(stderr, "Couldn't open '%s': %s\n",
452 keymap_path, strerror(errno));
455 keymap = xkb_keymap_new_from_file(ctx, file,
456 XKB_KEYMAP_FORMAT_TEXT_V1,
457 XKB_KEYMAP_COMPILE_NO_FLAGS);
461 struct xkb_rule_names rmlvo = {
462 .rules = isempty(rules) ? NULL : rules,
463 .model = isempty(model) ? NULL : model,
464 .layout = isempty(layout) ? NULL : layout,
465 .variant = isempty(variant) ? NULL : variant,
466 .options = isempty(options) ? NULL : options
469 if (!rules && !model && !layout && !variant && !options)
470 keymap = xkb_keymap_new_from_names(ctx, NULL, 0);
472 keymap = xkb_keymap_new_from_names(ctx, &rmlvo, 0);
476 "Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
477 rules, model, layout, variant, options);
483 fprintf(stderr, "Couldn't create xkb keymap\n");
488 locale = setlocale(LC_CTYPE, NULL);
490 xkb_compose_table_new_from_locale(ctx, locale,
491 XKB_COMPOSE_COMPILE_NO_FLAGS);
492 if (!compose_table) {
493 fprintf(stderr, "Couldn't create compose from locale\n");
498 kbds = get_keyboards(keymap, compose_table);
503 act.sa_handler = sigintr_handler;
504 sigemptyset(&act.sa_mask);
506 sigaction(SIGINT, &act, NULL);
507 sigaction(SIGTERM, &act, NULL);
509 tools_disable_stdin_echo();
511 tools_enable_stdin_echo();
513 free_keyboards(kbds);
515 xkb_compose_table_unref(compose_table);
516 xkb_keymap_unref(keymap);
517 xkb_context_unref(ctx);