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.
42 #include <linux/input.h>
44 #include "xkbcommon/xkbcommon.h"
46 #include "tools-common.h"
51 struct xkb_state *state;
52 struct xkb_compose_state *compose_state;
53 struct keyboard *next;
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;
62 #ifdef ENABLE_PRIVATE_APIS
63 #define DEFAULT_PRINT_FIELDS (PRINT_ALL_FIELDS & ~PRINT_MODMAPS)
65 #define DEFAULT_PRINT_FIELDS PRINT_ALL_FIELDS
67 print_state_fields_mask_t print_fields = DEFAULT_PRINT_FIELDS;
69 #define DEFAULT_INCLUDE_PATH_PLACEHOLDER "__defaults__"
70 #define NLONGS(n) (((n) + LONG_BIT - 1) / LONG_BIT)
73 evdev_bit_is_set(const unsigned long *array, int bit)
75 return array[bit / LONG_BIT] & (1LL << (bit % LONG_BIT));
78 /* Some heuristics to see if the device is a keyboard. */
83 unsigned long evbits[NLONGS(EV_CNT)] = { 0 };
84 unsigned long keybits[NLONGS(KEY_CNT)] = { 0 };
87 ioctl(fd, EVIOCGBIT(0, sizeof(evbits)), evbits);
91 if (!evdev_bit_is_set(evbits, EV_KEY))
95 ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
99 for (i = KEY_RESERVED; i <= KEY_MIN_INTERESTING; i++)
100 if (evdev_bit_is_set(keybits, i))
107 keyboard_new(struct dirent *ent, struct xkb_keymap *keymap,
108 struct xkb_compose_table *compose_table, struct keyboard **out)
113 struct xkb_state *state;
114 struct xkb_compose_state *compose_state = NULL;
115 struct keyboard *kbd;
117 ret = asprintf(&path, "/dev/input/%s", ent->d_name);
121 fd = open(path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
127 if (!is_keyboard(fd)) {
128 /* Dummy "skip this device" value. */
133 state = xkb_state_new(keymap);
135 fprintf(stderr, "Couldn't create xkb state for %s\n", path);
141 compose_state = xkb_compose_state_new(compose_table,
142 XKB_COMPOSE_STATE_NO_FLAGS);
143 if (!compose_state) {
144 fprintf(stderr, "Couldn't create compose state for %s\n", path);
150 kbd = calloc(1, sizeof(*kbd));
153 goto err_compose_state;
159 kbd->compose_state = compose_state;
164 xkb_compose_state_unref(compose_state);
166 xkb_state_unref(state);
175 keyboard_free(struct keyboard *kbd)
182 xkb_state_unref(kbd->state);
183 xkb_compose_state_unref(kbd->compose_state);
188 filter_device_name(const struct dirent *ent)
190 return !fnmatch("event*", ent->d_name, 0);
193 static struct keyboard *
194 get_keyboards(struct xkb_keymap *keymap,
195 struct xkb_compose_table *compose_table)
198 struct dirent **ents;
199 struct keyboard *kbds = NULL, *kbd = NULL;
201 nents = scandir("/dev/input", &ents, filter_device_name, alphasort);
203 fprintf(stderr, "Couldn't scan /dev/input: %s\n", strerror(errno));
207 for (i = 0; i < nents; i++) {
208 ret = keyboard_new(ents[i], keymap, compose_table, &kbd);
210 if (ret == -EACCES) {
211 fprintf(stderr, "Couldn't open /dev/input/%s: %s. "
212 "You probably need root to run this.\n",
213 ents[i]->d_name, strerror(-ret));
216 if (ret != -ENOTSUP) {
217 fprintf(stderr, "Couldn't open /dev/input/%s: %s. Skipping.\n",
218 ents[i]->d_name, strerror(-ret));
229 fprintf(stderr, "Couldn't find any keyboards I can use! Quitting.\n");
234 for (i = 0; i < nents; i++)
241 free_keyboards(struct keyboard *kbds)
243 struct keyboard *next;
252 /* The meaning of the input_event 'value' field. */
254 KEY_STATE_RELEASE = 0,
256 KEY_STATE_REPEAT = 2,
260 process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
262 xkb_keycode_t keycode;
263 struct xkb_keymap *keymap;
264 enum xkb_state_component changed;
265 enum xkb_compose_status status;
270 keycode = evdev_offset + code;
271 keymap = xkb_state_get_keymap(kbd->state);
273 if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
276 if (with_compose && value != KEY_STATE_RELEASE) {
277 xkb_keysym_t keysym = xkb_state_key_get_one_sym(kbd->state, keycode);
278 xkb_compose_state_feed(kbd->compose_state, keysym);
281 if (value != KEY_STATE_RELEASE) {
282 tools_print_keycode_state(
283 kbd->state, kbd->compose_state, keycode,
284 consumed_mode, print_fields
289 status = xkb_compose_state_get_status(kbd->compose_state);
290 if (status == XKB_COMPOSE_CANCELLED || status == XKB_COMPOSE_COMPOSED)
291 xkb_compose_state_reset(kbd->compose_state);
294 if (value == KEY_STATE_RELEASE)
295 changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_UP);
297 changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
299 if (report_state_changes)
300 tools_print_state_changes(changed);
304 read_keyboard(struct keyboard *kbd)
307 struct input_event evs[16];
309 /* No fancy error checking here. */
310 while ((len = read(kbd->fd, &evs, sizeof(evs))) > 0) {
311 const size_t nevs = len / sizeof(struct input_event);
312 for (size_t i = 0; i < nevs; i++)
313 process_event(kbd, evs[i].type, evs[i].code, evs[i].value);
316 if (len < 0 && errno != EWOULDBLOCK) {
317 fprintf(stderr, "Couldn't read %s: %s\n", kbd->path, strerror(errno));
325 loop(struct keyboard *kbds)
328 struct keyboard *kbd;
330 struct pollfd *fds = NULL;
332 for (kbd = kbds, nfds = 0; kbd; kbd = kbd->next, nfds++) {}
333 fds = calloc(nfds, sizeof(*fds));
335 fprintf(stderr, "Out of memory");
339 for (i = 0, kbd = kbds; kbd; kbd = kbd->next, i++) {
341 fds[i].events = POLLIN;
345 ret = poll(fds, nfds, -1);
349 fprintf(stderr, "Couldn't poll for events: %s\n",
354 for (i = 0, kbd = kbds; kbd; kbd = kbd->next, i++) {
355 if (fds[i].revents != 0) {
356 ret = read_keyboard(kbd);
371 sigintr_handler(int signum)
377 usage(FILE *fp, char *progname)
379 fprintf(fp, "Usage: %s [--include=<path>] [--include-defaults] "
380 "[--rules=<rules>] [--model=<model>] [--layout=<layout>] "
381 "[--variant=<variant>] [--options=<options>]\n",
383 fprintf(fp, " or: %s --keymap <path to keymap file>\n",
385 fprintf(fp, "For both:\n"
386 #ifdef ENABLE_PRIVATE_APIS
387 " --print-modmaps (print real & virtual key modmaps)\n"
389 " --short (do not print layout nor Unicode keysym translation)\n"
390 " --report-state-changes (report changes to the state)\n"
391 " --enable-compose (enable Compose)\n"
392 " --consumed-mode={xkb|gtk} (select the consumed modifiers mode, default: xkb)\n"
393 " --without-x11-offset (don't add X11 keycode offset)\n"
395 " --help (display this help and exit)\n"
400 main(int argc, char *argv[])
402 int ret = EXIT_FAILURE;
403 struct keyboard *kbds;
404 struct xkb_context *ctx = NULL;
405 struct xkb_keymap *keymap = NULL;
406 struct xkb_compose_table *compose_table = NULL;
407 const char *includes[64];
408 size_t num_includes = 0;
409 const char *rules = NULL;
410 const char *model = NULL;
411 const char *layout = NULL;
412 const char *variant = NULL;
413 const char *options = NULL;
414 const char *keymap_path = NULL;
416 struct sigaction act;
419 OPT_INCLUDE_DEFAULTS,
426 OPT_WITHOUT_X11_OFFSET,
431 #ifdef ENABLE_PRIVATE_APIS
435 static struct option opts[] = {
436 {"help", no_argument, 0, 'h'},
437 {"include", required_argument, 0, OPT_INCLUDE},
438 {"include-defaults", no_argument, 0, OPT_INCLUDE_DEFAULTS},
439 {"rules", required_argument, 0, OPT_RULES},
440 {"model", required_argument, 0, OPT_MODEL},
441 {"layout", required_argument, 0, OPT_LAYOUT},
442 {"variant", required_argument, 0, OPT_VARIANT},
443 {"options", required_argument, 0, OPT_OPTION},
444 {"keymap", required_argument, 0, OPT_KEYMAP},
445 {"consumed-mode", required_argument, 0, OPT_CONSUMED_MODE},
446 {"enable-compose", no_argument, 0, OPT_COMPOSE},
447 {"short", no_argument, 0, OPT_SHORT},
448 {"report-state-changes", no_argument, 0, OPT_REPORT_STATE},
449 {"without-x11-offset", no_argument, 0, OPT_WITHOUT_X11_OFFSET},
450 #ifdef ENABLE_PRIVATE_APIS
451 {"print-modmaps", no_argument, 0, OPT_PRINT_MODMAPS},
456 setlocale(LC_ALL, "");
460 int option_index = 0;
462 opt = getopt_long(argc, argv, "h", opts, &option_index);
468 if (num_includes >= ARRAY_SIZE(includes)) {
469 fprintf(stderr, "error: too many includes\n");
470 exit(EXIT_INVALID_USAGE);
472 includes[num_includes++] = optarg;
474 case OPT_INCLUDE_DEFAULTS:
475 if (num_includes >= ARRAY_SIZE(includes)) {
476 fprintf(stderr, "error: too many includes\n");
477 exit(EXIT_INVALID_USAGE);
479 includes[num_includes++] = DEFAULT_INCLUDE_PATH_PLACEHOLDER;
497 keymap_path = optarg;
499 case OPT_WITHOUT_X11_OFFSET:
502 case OPT_REPORT_STATE:
503 report_state_changes = true;
509 print_fields &= ~PRINT_VERBOSE_FIELDS;
511 case OPT_CONSUMED_MODE:
512 if (strcmp(optarg, "gtk") == 0) {
513 consumed_mode = XKB_CONSUMED_MODE_GTK;
514 } else if (strcmp(optarg, "xkb") == 0) {
515 consumed_mode = XKB_CONSUMED_MODE_XKB;
517 fprintf(stderr, "error: invalid --consumed-mode \"%s\"\n", optarg);
518 usage(stderr, argv[0]);
519 return EXIT_INVALID_USAGE;
522 #ifdef ENABLE_PRIVATE_APIS
523 case OPT_PRINT_MODMAPS:
524 print_fields |= PRINT_MODMAPS;
528 usage(stdout, argv[0]);
531 usage(stderr, argv[0]);
532 return EXIT_INVALID_USAGE;
536 ctx = xkb_context_new(XKB_CONTEXT_NO_DEFAULT_INCLUDES);
538 fprintf(stderr, "Couldn't create xkb context\n");
542 if (num_includes == 0)
543 includes[num_includes++] = DEFAULT_INCLUDE_PATH_PLACEHOLDER;
545 for (size_t i = 0; i < num_includes; i++) {
546 const char *include = includes[i];
547 if (strcmp(include, DEFAULT_INCLUDE_PATH_PLACEHOLDER) == 0)
548 xkb_context_include_path_append_default(ctx);
550 xkb_context_include_path_append(ctx, include);
554 FILE *file = fopen(keymap_path, "rb");
556 fprintf(stderr, "Couldn't open '%s': %s\n",
557 keymap_path, strerror(errno));
560 keymap = xkb_keymap_new_from_file(ctx, file,
561 XKB_KEYMAP_FORMAT_TEXT_V1,
562 XKB_KEYMAP_COMPILE_NO_FLAGS);
566 struct xkb_rule_names rmlvo = {
567 .rules = (rules == NULL || rules[0] == '\0') ? NULL : rules,
568 .model = (model == NULL || model[0] == '\0') ? NULL : model,
569 .layout = (layout == NULL || layout[0] == '\0') ? NULL : layout,
570 .variant = (variant == NULL || variant[0] == '\0') ? NULL : variant,
571 .options = (options == NULL || options[0] == '\0') ? NULL : options
574 if (!rules && !model && !layout && !variant && !options)
575 keymap = xkb_keymap_new_from_names(ctx, NULL, 0);
577 keymap = xkb_keymap_new_from_names(ctx, &rmlvo, 0);
581 "Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
582 rules, model, layout, variant, options);
588 fprintf(stderr, "Couldn't create xkb keymap\n");
593 locale = setlocale(LC_CTYPE, NULL);
595 xkb_compose_table_new_from_locale(ctx, locale,
596 XKB_COMPOSE_COMPILE_NO_FLAGS);
597 if (!compose_table) {
598 fprintf(stderr, "Couldn't create compose from locale\n");
603 kbds = get_keyboards(keymap, compose_table);
608 #ifdef ENABLE_PRIVATE_APIS
609 if (print_fields & PRINT_MODMAPS) {
610 print_keys_modmaps(keymap);
612 print_keymap_modmaps(keymap);
617 act.sa_handler = sigintr_handler;
618 sigemptyset(&act.sa_mask);
620 sigaction(SIGINT, &act, NULL);
621 sigaction(SIGTERM, &act, NULL);
623 tools_disable_stdin_echo();
625 tools_enable_stdin_echo();
627 free_keyboards(kbds);
629 xkb_compose_table_unref(compose_table);
630 xkb_keymap_unref(keymap);
631 xkb_context_unref(ctx);