1 /* Copyright © 2019 Raheman Vaiya.
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a
4 * copy of this software and associated documentation files (the "Software"),
5 * to deal in the Software without restriction, including without limitation
6 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
7 * and/or sell copies of the Software, and to permit persons to whom the
8 * Software is furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice (including the next
11 * paragraph) shall be included in all copies or substantial portions of the
12 * Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 * DEALINGS IN THE SOFTWARE.
21 */
22
23 #ifdef __FreeBSD_disabled__
24 #include <dev/evdev/input.h>
25 #include <dev/evdev/uinput.h>
26 #else
27 #include <linux/input.h>
28 #include <linux/uinput.h>
29 #endif
30
31 #include <stdio.h>
32 #include <sys/time.h>
33 #include <signal.h>
34 #include <sys/types.h>
35 #include <sys/file.h>
36 #include <dirent.h>
37 #include <assert.h>
38 #include <errno.h>
39 #include <string.h>
40 #include <sys/stat.h>
41 #include <signal.h>
42 #include <unistd.h>
43 #include <termios.h>
44 #include <libudev.h>
45 #include <stdint.h>
46 #include <stdarg.h>
47 #include <time.h>
48 #include <stdlib.h>
49 #include <fcntl.h>
50 #include "keys.h"
51 #include "config.h"
52
53 #define VIRTUAL_KEYBOARD_NAME "keyd virtual keyboard"
54 #define VIRTUAL_POINTER_NAME "keyd virtual pointer"
55 #define IS_MOUSE_BTN(code) (((code) >= BTN_LEFT && (code) <= BTN_TASK) ||\
56 ((code) >= BTN_0 && (code) <= BTN_9))
57 #define MAX_KEYBOARDS 256
58
59 #define dbg(fmt, ...) { if(debug) info("%s:%d: "fmt, __FILE__, __LINE__, ## __VA_ARGS__); }
60 #define dbg2(fmt, ...) { if(debug > 1) info("%s:%d: "fmt, __FILE__, __LINE__, ## __VA_ARGS__); }
61
62 static int debug = 0;
63 static int vkbd = -1;
64 static int vptr = -1;
65
66 static struct udev *udev;
67 static struct udev_monitor *udevmon;
68 static uint8_t keystate[KEY_CNT] = {0};
69
70 //Active keyboard state.
71 struct keyboard {
72 int fd;
73 char devnode[256];
74
75 struct layer **layers;
76 size_t nlayers;
77
78 //The layer to which modifiers are applied,
79 //this may be distinct from the main layout
80 struct layer *modlayout;
81 struct layer *layout;
82
83 struct key_descriptor *dcache[KEY_CNT];
84 uint16_t mcache[KEY_CNT];
85 uint64_t pressed_timestamps[KEY_CNT];
86
87 struct keyboard *next;
88 };
89
90 static struct keyboard *keyboards = NULL;
91
info(char * fmt,...)92 static void info(char *fmt, ...)
93 {
94 va_list args;
95 va_start(args, fmt);
96
97 vfprintf(stderr, fmt, args);
98 va_end(args);
99 fprintf(stderr, "\n");
100 }
101
_die(char * fmt,...)102 static void _die(char *fmt, ...)
103 {
104 va_list args;
105 va_start(args, fmt);
106
107 vfprintf(stderr, fmt, args);
108 va_end(args);
109 fprintf(stderr, "\n");
110 exit(-1);
111 }
112
113 #define die(fmt, ...) _die("%s:%d: "fmt, __FILE__, __LINE__, ## __VA_ARGS__)
114
get_time()115 static uint64_t get_time()
116 {
117 struct timespec tv;
118 clock_gettime(CLOCK_MONOTONIC, &tv);
119 return (tv.tv_sec*1E9)+tv.tv_nsec;
120 }
121
udev_type(struct udev_device * dev,int * iskbd,int * ismouse)122 static void udev_type(struct udev_device *dev, int *iskbd, int *ismouse)
123 {
124 if(iskbd)
125 *iskbd = 0;
126 if(ismouse)
127 *ismouse = 0;
128
129 const char *path = udev_device_get_devnode(dev);
130
131 if(!path || !strstr(path, "event")) //Filter out non evdev devices.
132 return;
133
134 struct udev_list_entry *prop;
135 udev_list_entry_foreach(prop, udev_device_get_properties_list_entry(dev)) {
136 if(!strcmp(udev_list_entry_get_name(prop), "ID_INPUT_KEYBOARD") &&
137 !strcmp(udev_list_entry_get_value(prop), "1")) {
138 if(iskbd)
139 *iskbd = 1;
140 }
141
142 if(!strcmp(udev_list_entry_get_name(prop), "ID_INPUT_MOUSE") &&
143 !strcmp(udev_list_entry_get_value(prop), "1")) {
144 if(ismouse)
145 *ismouse = 1;
146 }
147 }
148 }
149
evdev_device_name(const char * devnode)150 static const char *evdev_device_name(const char *devnode)
151 {
152 static char name[256];
153
154 int fd = open(devnode, O_RDONLY);
155 if(fd < 0) {
156 perror("open");
157 exit(-1);
158 }
159
160 if(ioctl(fd, EVIOCGNAME(sizeof(name)), &name) == -1)
161 return NULL;
162
163 close(fd);
164 return name;
165 }
166
get_keyboard_nodes(char * nodes[MAX_KEYBOARDS],int * sz)167 static void get_keyboard_nodes(char *nodes[MAX_KEYBOARDS], int *sz)
168 {
169 struct udev *udev;
170 struct udev_enumerate *enumerate;
171 struct udev_list_entry *devices, *ent;
172
173 udev = udev_new();
174 if (!udev)
175 die("Cannot create udev context.");
176
177 enumerate = udev_enumerate_new(udev);
178 if (!enumerate)
179 die("Cannot create enumerate context.");
180
181 udev_enumerate_add_match_subsystem(enumerate, "input");
182 udev_enumerate_scan_devices(enumerate);
183
184 devices = udev_enumerate_get_list_entry(enumerate);
185 if (!devices)
186 die("Failed to get device list.");
187
188 *sz = 0;
189 udev_list_entry_foreach(ent, devices) {
190 int iskbd, ismouse;
191 const char *name = udev_list_entry_get_name(ent);;
192 struct udev_device *dev = udev_device_new_from_syspath(udev, name);
193 const char *path = udev_device_get_devnode(dev);
194
195 udev_type(dev, &iskbd, &ismouse);
196
197 if(iskbd) {
198 dbg("Detected keyboard node %s (%s) ismouse: %d", name, evdev_device_name(path), ismouse);
199 nodes[*sz] = malloc(strlen(path)+1);
200 strcpy(nodes[*sz], path);
201 (*sz)++;
202 assert(*sz <= MAX_KEYBOARDS);
203 } else if(path) {
204 dbg("Ignoring %s (%s)", evdev_device_name(path), path);
205 }
206
207 udev_device_unref(dev);
208 }
209
210 udev_enumerate_unref(enumerate);
211 udev_unref(udev);
212 }
213
create_virtual_pointer()214 static int create_virtual_pointer()
215 {
216 uint16_t code;
217 struct uinput_setup usetup;
218
219 int fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
220 if(fd < 0) {
221 perror("open");
222 exit(-1);
223 }
224
225 ioctl(fd, UI_SET_EVBIT, EV_REL);
226 ioctl(fd, UI_SET_EVBIT, EV_KEY);
227 ioctl(fd, UI_SET_EVBIT, EV_SYN);
228
229 ioctl(fd, UI_SET_RELBIT, REL_X);
230 ioctl(fd, UI_SET_RELBIT, REL_WHEEL);
231 ioctl(fd, UI_SET_RELBIT, REL_HWHEEL);
232 ioctl(fd, UI_SET_RELBIT, REL_Y);
233 ioctl(fd, UI_SET_RELBIT, REL_Z);
234
235 for(code = BTN_LEFT;code <= BTN_TASK;code++)
236 ioctl(fd, UI_SET_KEYBIT, code);
237
238 for(code = BTN_0;code <= BTN_9;code++)
239 ioctl(fd, UI_SET_KEYBIT, code);
240
241 memset(&usetup, 0, sizeof(usetup));
242 usetup.id.bustype = BUS_USB;
243 usetup.id.product = 0x1FAC;
244 usetup.id.vendor = 0x0ADE;
245 strcpy(usetup.name, VIRTUAL_POINTER_NAME);
246
247 ioctl(fd, UI_DEV_SETUP, &usetup);
248 ioctl(fd, UI_DEV_CREATE);
249
250 return fd;
251 }
252
create_virtual_keyboard()253 static int create_virtual_keyboard()
254 {
255 size_t i;
256 struct uinput_setup usetup;
257
258 int fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
259 if(fd < 0) {
260 perror("open");
261 exit(-1);
262 }
263
264 ioctl(fd, UI_SET_EVBIT, EV_KEY);
265 ioctl(fd, UI_SET_EVBIT, EV_SYN);
266
267 for(i = 0;i < KEY_MAX;i++) {
268 if(keycode_table[i].name && !IS_MOUSE_BTN(i) )
269 ioctl(fd, UI_SET_KEYBIT, i);
270 }
271
272 memset(&usetup, 0, sizeof(usetup));
273 usetup.id.bustype = BUS_USB;
274 usetup.id.product = 0x0FAC;
275 usetup.id.vendor = 0x0ADE;
276 strcpy(usetup.name, VIRTUAL_KEYBOARD_NAME);
277
278 ioctl(fd, UI_DEV_SETUP, &usetup);
279 ioctl(fd, UI_DEV_CREATE);
280
281 return fd;
282 }
283
syn(int fd)284 static void syn(int fd)
285 {
286 static struct input_event ev = {
287 .type = EV_SYN,
288 .code = 0,
289 .value = 0,
290 };
291
292 write(fd, &ev, sizeof(ev));
293 }
294
send_repetitions()295 static void send_repetitions()
296 {
297 size_t i;
298 struct input_event ev = {
299 .type = EV_KEY,
300 .value = 2,
301 .time.tv_sec = 0,
302 .time.tv_usec = 0
303 };
304
305 //Inefficient, but still reasonably fast (<100us)
306 for(i = 0; i < sizeof keystate / sizeof keystate[0];i++) {
307 if(keystate[i]) {
308 ev.code = i;
309 write(vkbd, &ev, sizeof(ev));
310 syn(vkbd);
311 }
312 }
313 }
314
send_key(uint16_t code,int is_pressed)315 static void send_key(uint16_t code, int is_pressed)
316 {
317 if(code == KEY_NOOP)
318 return;
319
320 keystate[code] = is_pressed;
321 struct input_event ev;
322
323 ev.type = EV_KEY;
324 ev.code = code;
325 ev.value = is_pressed;
326 ev.time.tv_sec = 0;
327 ev.time.tv_usec = 0;
328
329 write(vkbd, &ev, sizeof(ev));
330
331 syn(vkbd);
332 }
333
setmods(uint16_t mods)334 static void setmods(uint16_t mods)
335 {
336 if(!!(mods & MOD_CTRL) != keystate[KEY_LEFTCTRL])
337 send_key(KEY_LEFTCTRL, !keystate[KEY_LEFTCTRL]);
338 if(!!(mods & MOD_SHIFT) != keystate[KEY_LEFTSHIFT])
339 send_key(KEY_LEFTSHIFT, !keystate[KEY_LEFTSHIFT]);
340 if(!!(mods & MOD_SUPER) != keystate[KEY_LEFTMETA])
341 send_key(KEY_LEFTMETA, !keystate[KEY_LEFTMETA]);
342 if(!!(mods & MOD_ALT) != keystate[KEY_LEFTALT])
343 send_key(KEY_LEFTALT, !keystate[KEY_LEFTALT]);
344 if(!!(mods & MOD_ALT_GR) != keystate[KEY_RIGHTALT])
345 send_key(KEY_RIGHTALT, !keystate[KEY_RIGHTALT]);
346 }
347
reify_layer_mods(struct keyboard * kbd)348 static void reify_layer_mods(struct keyboard *kbd)
349 {
350 uint16_t mods = 0;
351 size_t i;
352
353 for(i = 0;i < kbd->nlayers;i++) {
354 struct layer *layer = kbd->layers[i];
355
356 if(layer->active)
357 mods |= layer->mods;
358 }
359
360 setmods(mods);
361 }
362
kbd_panic_check(struct keyboard * kbd)363 static void kbd_panic_check(struct keyboard *kbd)
364 {
365 if(kbd->dcache[KEY_BACKSPACE] &&
366 kbd->dcache[KEY_BACKSLASH] &&
367 kbd->dcache[KEY_ENTER]) {
368 info("Termination key sequence triggered (backspace backslash enter), terminating.");
369 exit(1);
370 }
371 }
372
kbd_lookup_descriptor(struct keyboard * kbd,uint16_t code,int pressed,uint16_t * modsp)373 static struct key_descriptor *kbd_lookup_descriptor(struct keyboard *kbd, uint16_t code, int pressed, uint16_t *modsp)
374 {
375 size_t i;
376 struct key_descriptor *desc = NULL;
377 struct layer *layer = NULL;
378 uint16_t mods = 0;
379 size_t nactive = 0;
380
381 //Cache the descriptor to ensure consistency upon up/down event pairs since layers can change midkey.
382 if(!pressed) {
383 *modsp = kbd->mcache[code];
384 desc = kbd->dcache[code];
385
386 kbd->dcache[code] = NULL;
387 kbd->mcache[code] = 0;
388
389 return desc;
390 }
391
392 //Pick the most recently activated layer in which a mapping is defined.
393
394 for(i = 0;i < kbd->nlayers;i++) {
395 struct layer *l = kbd->layers[i];
396 struct key_descriptor *d = &l->keymap[code];
397
398 if(l->active) {
399 if(d->action && (!desc || (l->timestamp > layer->timestamp))) {
400 desc = d;
401 layer = l;
402 }
403
404 nactive++;
405 }
406 }
407
408 //Calculate the modifier union of active layers, excluding the mods for
409 //the layer in which the mapping is defined.
410
411 mods = 0;
412 for(i = 0;i < kbd->nlayers;i++) {
413 struct layer *l = kbd->layers[i];
414
415 if(l->active && l != layer)
416 mods |= l->mods;
417 }
418
419 if(!desc) {
420 //If any modifier layers are active and do not explicitly
421 //define a mapping, obtain the target from modlayout.
422
423 if(mods) {
424 if(mods == MOD_SHIFT || mods == MOD_ALT_GR)
425 desc = &kbd->layout->keymap[code];
426 else
427 desc = &kbd->modlayout->keymap[code];
428 } else if(!nactive) //If no layers are active use the default layout
429 desc = &kbd->layout->keymap[code];
430 else
431 return NULL;
432 }
433
434 kbd->pressed_timestamps[code] = get_time();
435 kbd->dcache[code] = desc;
436 kbd->mcache[code] = mods;
437
438 *modsp = mods;
439 return desc;
440 }
441
do_keyseq(uint32_t seq)442 static void do_keyseq( uint32_t seq) {
443 if(!seq) return;
444
445 uint16_t mods = seq >> 16;
446 uint16_t key = seq & 0xFFFF;
447
448 if(mods & MOD_TIMEOUT) {
449 usleep(GET_TIMEOUT(seq)*1000);
450 } else {
451 setmods(mods);
452 send_key(key, 1);
453 send_key(key, 0);
454 }
455 }
456
457 //Where the magic happens
process_key_event(struct keyboard * kbd,uint16_t code,int pressed)458 static void process_key_event(struct keyboard *kbd, uint16_t code, int pressed)
459 {
460 size_t i;
461
462 struct key_descriptor *d;
463
464 static struct key_descriptor *lastd = NULL;
465 static uint8_t oneshot_layers[MAX_LAYERS] = {0};
466 static uint64_t last_keyseq_timestamp = 0;
467 static uint16_t swapped_keycode = 0;
468
469 uint16_t mods = 0;
470
471 d = kbd_lookup_descriptor(kbd, code, pressed, &mods);
472 if(!d) goto keyseq_cleanup;
473
474 kbd_panic_check(kbd);
475
476 switch(d->action) {
477 struct layer *layer;
478 uint32_t keyseq;
479 uint16_t keycode;
480
481 case ACTION_OVERLOAD:
482 keyseq = d->arg.keyseq;
483 layer = kbd->layers[d->arg2.layer];
484
485 if(pressed) {
486 layer->active = 1;
487 layer->timestamp = get_time();
488 } else {
489 layer->active = 0;
490
491 if(lastd == d) { //If tapped
492 uint16_t key = keyseq & 0xFFFF;
493 mods |= keyseq >> 16;
494
495 setmods(mods);
496 send_key(key, 1);
497 send_key(key, 0);
498
499 last_keyseq_timestamp = get_time();
500 goto keyseq_cleanup;
501 }
502 }
503
504 reify_layer_mods(kbd);
505 break;
506 case ACTION_LAYOUT:
507 kbd->layout = kbd->layers[d->arg.layer];
508 kbd->modlayout = kbd->layers[d->arg2.layer];
509
510 dbg("layer: %d, modlayout: %d", kbd->layout, kbd->modlayout);
511 break;
512 case ACTION_ONESHOT:
513 layer = kbd->layers[d->arg.layer];
514
515 if(pressed) {
516 layer->active = 1;
517 oneshot_layers[d->arg.layer] = 0;
518 layer->timestamp = get_time();
519 } else if(kbd->pressed_timestamps[code] < last_keyseq_timestamp) {
520 layer->active = 0;
521 } else //Tapped
522 oneshot_layers[d->arg.layer] = 1;
523
524 reify_layer_mods(kbd);
525 break;
526 case ACTION_LAYER_TOGGLE:
527 if(!pressed) {
528 layer = kbd->layers[d->arg.layer];
529
530 if(oneshot_layers[d->arg.layer]) {
531 oneshot_layers[d->arg.layer] = 0;
532 } else {
533 layer->active = !layer->active;
534 }
535 reify_layer_mods(kbd);
536 goto keyseq_cleanup;
537 }
538 break;
539 case ACTION_LAYER:
540 layer = kbd->layers[d->arg.layer];
541
542 if(pressed) {
543 layer->active = 1;
544 layer->timestamp = get_time();
545 } else {
546 layer->active = 0;
547 }
548
549 reify_layer_mods(kbd);
550 break;
551 case ACTION_KEYSEQ:
552 mods |= d->arg.keyseq >> 16;
553 keycode = d->arg.keyseq & 0xFFFF;
554 if(pressed) {
555 setmods(mods);
556
557 //Account for the possibility that a version of the key
558 //with a different modifier set is already depressed (e.g [/{)
559 if(keystate[keycode])
560 send_key(keycode, 0);
561
562 send_key(keycode, 1);
563 } else {
564 reify_layer_mods(kbd);
565 send_key(keycode, 0);
566 }
567
568 goto keyseq_cleanup;
569 break;
570 case ACTION_MACRO:
571 if(pressed) {
572 uint32_t *macro = d->arg.macro;
573 size_t sz = d->arg2.sz;
574
575 for(i = 0; i < sz;i++)
576 do_keyseq(macro[i]);
577
578 reify_layer_mods(kbd);
579 goto keyseq_cleanup;
580
581 }
582 break;
583 case ACTION_SWAP:
584 layer = kbd->layers[d->arg.layer];
585
586 if(pressed && !swapped_keycode) { //For simplicity only allow one swapped layer at a time.
587 struct layer *old_layer;
588 uint16_t code = 0;
589 uint64_t maxts = 0;
590
591 //Find a currently depressed keycode corresponding to the last active
592 //layer.
593 for(i = 0;i < sizeof(kbd->dcache)/sizeof(kbd->dcache[0]);i++) {
594 struct key_descriptor *d = kbd->dcache[i];
595
596 if(d) {
597 struct layer *l;
598
599 switch(d->action) {
600 //If it is layer key.
601 case ACTION_ONESHOT:
602 case ACTION_LAYER:
603 l = kbd->layers[d->arg.layer];
604 break;
605 case ACTION_OVERLOAD:
606 l = kbd->layers[d->arg2.layer];
607 break;
608 default:
609 continue;
610 }
611
612 if(l->timestamp > maxts) {
613 code = i;
614 old_layer = l;
615 }
616 }
617 }
618
619 //If a layer activation key is being held...
620 if(code) {
621 old_layer->active = 0;
622
623 layer->active = 1;
624 layer->timestamp = get_time();
625
626 //Replace the keycode's descriptor with the present one so key up
627 //deactivates the appropriate layer.
628 kbd->dcache[code] = d;
629
630 swapped_keycode = code;
631
632 do_keyseq(d->arg2.keyseq);
633 reify_layer_mods(kbd);
634 }
635 }
636
637 //Key up corresponding to the swapped key.
638 if(!pressed && swapped_keycode == code) {
639 layer->active = 0;
640
641 swapped_keycode = 0;
642
643 reify_layer_mods(kbd);
644 }
645
646 break;
647 case ACTION_UNDEFINED:
648 goto keyseq_cleanup;
649 break;
650 }
651
652 lastd = d;
653 return;
654
655 keyseq_cleanup:
656 lastd = d;
657
658 if(pressed)
659 last_keyseq_timestamp = get_time();
660
661 //Clear active oneshot layers.
662 for(i = 0;i < kbd->nlayers;i++) {
663 if(oneshot_layers[i]) {
664 kbd->layers[i]->active = 0;
665 oneshot_layers[i] = 0;
666 }
667 }
668 }
669
670 //Block on the given keyboard nodes until no keys are depressed.
await_keyboard_neutrality(char ** devs,int n)671 static void await_keyboard_neutrality(char **devs, int n)
672 {
673 int fds[MAX_KEYBOARDS];
674 int maxfd = 0;
675 int i;
676
677 dbg("Awaiting keyboard neutrality.");
678 for(i = 0;i < n;i++) {
679 if((fds[i] = open(devs[i], O_RDONLY | O_NONBLOCK)) < 0)
680 die("open");
681
682 if(fds[i] > maxfd)
683 maxfd = fds[i];
684 }
685
686 //There is a race condition here since it is possible for a key down
687 //event to be generated before keyd is launched, in that case we hope a
688 //repeat event is generated within the first 300ms. If we miss the
689 //keydown event and the repeat event is not generated within the first
690 //300ms it is possible for this to yield a false positive. In practice
691 //this seems to work fine. Given the stateless nature of evdev I am not
692 //aware of a better way to achieve this.
693
694 while(1) {
695 struct timeval tv = {
696 .tv_usec = 300000
697 };
698
699 struct input_event ev;
700 int i;
701 fd_set fdset;
702
703 FD_ZERO(&fdset);
704 for(i = 0;i < n;i++)
705 FD_SET(fds[i], &fdset);
706
707 select(maxfd+1, &fdset, NULL, NULL, &tv);
708
709 for(i = 0;i < n;i++) {
710 if(FD_ISSET(fds[i], &fdset)) {
711 while(read(fds[i], &ev, sizeof ev) > 0) {
712 if(ev.type == EV_KEY) {
713 keystate[ev.code] = ev.value;
714 dbg("keystate[%d]: %d", ev.code, ev.value);
715 }
716 }
717 }
718 }
719
720 for(i = 0;i < KEY_CNT;i++)
721 if(keystate[i])
722 break;
723
724 if(i == KEY_CNT)
725 break;
726 }
727
728 for(i = 0;i < n;i++)
729 close(fds[i]);
730
731 dbg("Keyboard neutrality achieved");
732 }
733
manage_keyboard(const char * devnode)734 static int manage_keyboard(const char *devnode)
735 {
736 int fd;
737 const char *name = evdev_device_name(devnode);
738 struct keyboard *kbd;
739 struct keyboard_config *cfg = NULL;
740 struct keyboard_config *default_cfg = NULL;
741
742 if(!strcmp(name, VIRTUAL_KEYBOARD_NAME) ||
743 !strcmp(name, VIRTUAL_POINTER_NAME)) //Don't manage virtual devices.
744 return 0;
745
746 for(kbd = keyboards;kbd;kbd = kbd->next) {
747 if(!strcmp(kbd->devnode, devnode)) {
748 dbg("Already managing %s.", devnode);
749 return 0;
750 }
751 }
752
753 for(cfg = configs;cfg;cfg = cfg->next) {
754 if(!strcmp(cfg->name, "default"))
755 default_cfg = cfg;
756
757 if(!strcmp(cfg->name, name))
758 break;
759 }
760
761 if(!cfg) {
762 if(default_cfg) {
763 info("No config found for %s (%s), falling back to default.cfg", name, devnode);
764 cfg = default_cfg;
765 } else {
766 //Don't manage keyboards for which there is no configuration.
767 info("No config found for %s (%s), ignoring", name, devnode);
768 return 0;
769 }
770 }
771
772 if((fd = open(devnode, O_RDONLY | O_NONBLOCK)) < 0) {
773 perror("open");
774 exit(1);
775 }
776
777 kbd = calloc(1, sizeof(struct keyboard));
778 kbd->fd = fd;
779 kbd->layers = cfg->layers;
780 kbd->nlayers = cfg->nlayers;
781
782 kbd->modlayout = cfg->layers[cfg->default_modlayout];
783 kbd->layout = cfg->layers[cfg->default_layout];
784
785 strcpy(kbd->devnode, devnode);
786
787 //Grab the keyboard.
788 if(ioctl(fd, EVIOCGRAB, (void *)1) < 0) {
789 perror("EVIOCGRAB");
790 exit(-1);
791 }
792
793 kbd->next = keyboards;
794 keyboards = kbd;
795
796 info("Managing %s", evdev_device_name(devnode));
797 return 1;
798 }
799
destroy_keyboard(const char * devnode)800 static int destroy_keyboard(const char *devnode)
801 {
802 struct keyboard **ent = &keyboards;
803
804 while(*ent) {
805 if(!strcmp((*ent)->devnode, devnode)) {
806 dbg("Destroying %s", devnode);
807 struct keyboard *kbd = *ent;
808 *ent = kbd->next;
809
810 //Attempt to ungrab the the keyboard (assuming it still exists)
811 if(ioctl(kbd->fd, EVIOCGRAB, (void *)1) < 0) {
812 perror("EVIOCGRAB");
813 }
814
815 close(kbd->fd);
816 free(kbd);
817
818 return 1;
819 }
820
821 ent = &(*ent)->next;
822 }
823
824 return 0;
825 }
826
monitor_exit(int status)827 static void monitor_exit(int status)
828 {
829 struct termios tinfo;
830
831 tcgetattr(0, &tinfo);
832 tinfo.c_lflag |= ECHO;
833 tcsetattr(0, TCSANOW, &tinfo);
834
835 exit(0);
836 }
837
evdev_monitor_loop(int * fds,int sz)838 static void evdev_monitor_loop(int *fds, int sz)
839 {
840 struct input_event ev;
841 fd_set fdset;
842 int i;
843 struct stat finfo;
844 int ispiped;
845
846 struct {
847 char name[256];
848 uint16_t product_id;
849 uint16_t vendor_id;
850 } info_table[256];
851
852 fstat(1, &finfo);
853 ispiped = finfo.st_mode & S_IFIFO;
854
855 for(i = 0;i < sz;i++) {
856 struct input_id info;
857
858 int fd = fds[i];
859 if(ioctl(fd, EVIOCGID, &info) == -1) {
860 perror("ioctl");
861 exit(-1);
862 }
863
864 info_table[fd].product_id = info.product;
865 info_table[fd].vendor_id = info.vendor;
866
867 if(ioctl(fd, EVIOCGNAME(sizeof(info_table[0].name)), info_table[fd].name) == -1) {
868 perror("ioctl");
869 exit(-1);
870 }
871 }
872
873 while(1) {
874 int i;
875 int maxfd = 1;
876
877 FD_ZERO(&fdset);
878
879 //Proactively monitor stdout for pipe closures instead of waiting
880 //for a failed write to generate SIGPIPE.
881
882 if(ispiped)
883 FD_SET(1, &fdset);
884
885 for(i = 0;i < sz;i++) {
886 if(maxfd < fds[i]) maxfd = fds[i];
887 FD_SET(fds[i], &fdset);
888 }
889
890 select(maxfd+1, &fdset, NULL, NULL, NULL);
891
892 for(i = 0;i < sz;i++) {
893 int fd = fds[i];
894
895 if(FD_ISSET(1, &fdset) &&
896 read(1, NULL, 0) == -1) { //STDOUT closed.
897 //Re-enable echo.
898 monitor_exit(0);
899 }
900
901 if(FD_ISSET(fd, &fdset)) {
902 while(read(fd, &ev, sizeof(ev)) > 0) {
903 if(ev.type == EV_KEY && ev.value != 2) {
904 const char *name = keycode_table[ev.code].name;
905 if(name) {
906 printf("%s\t%04x:%04x\t%s %s\n",
907 info_table[fd].name,
908 info_table[fd].product_id,
909 info_table[fd].vendor_id,
910 name,
911 ev.value == 0 ? "up" : "down");
912 fflush(stdout);
913 }
914 else
915 info("Unrecognized keycode: %d", ev.code);
916 } else if (ev.type != EV_SYN) {
917 dbg("%s: Event: (%d, %d, %d)", info_table[fd].name, ev.type, ev.value, ev.code);
918 }
919 }
920 }
921 }
922 }
923 }
924
monitor_loop()925 static int monitor_loop()
926 {
927 char *devnodes[256];
928 int sz, i;
929 int fd = -1;
930 int fds[256];
931 int nfds = 0;
932
933 struct termios tinfo;
934
935 //Disable terminal echo so keys don't appear twice.
936 tcgetattr(0, &tinfo);
937 tinfo.c_lflag &= ~ECHO;
938 tcsetattr(0, TCSANOW, &tinfo);
939
940 signal(SIGINT, monitor_exit);
941
942 get_keyboard_nodes(devnodes, &sz);
943
944 for(i = 0;i < sz;i++) {
945 fd = open(devnodes[i], O_RDONLY | O_NONBLOCK);
946 if(fd < 0) {
947 perror("open");
948 exit(-1);
949 }
950 fds[nfds++] = fd;
951 }
952
953 evdev_monitor_loop(fds, nfds);
954
955 return 0;
956 }
957
main_loop()958 static void main_loop()
959 {
960 struct keyboard *kbd;
961 int monfd;
962
963 int i, n;
964 char *devs[MAX_KEYBOARDS];
965
966 get_keyboard_nodes(devs, &n);
967 await_keyboard_neutrality(devs, n);
968
969 for(i = 0;i < n;i++) {
970 manage_keyboard(devs[i]);
971 free(devs[i]);
972 }
973
974 udev = udev_new();
975 udevmon = udev_monitor_new_from_netlink(udev, "udev");
976
977 if (!udev)
978 die("Can't create udev.");
979
980 udev_monitor_filter_add_match_subsystem_devtype(udevmon, "input", NULL);
981 udev_monitor_enable_receiving(udevmon);
982
983 monfd = udev_monitor_get_fd(udevmon);
984
985 while(1) {
986 int maxfd;
987 fd_set fds;
988 struct udev_device *dev;
989
990 FD_ZERO(&fds);
991 FD_SET(monfd, &fds);
992
993 maxfd = monfd;
994
995 for(kbd = keyboards;kbd;kbd=kbd->next) {
996 int fd = kbd->fd;
997
998 maxfd = maxfd > fd ? maxfd : fd;
999 FD_SET(fd, &fds);
1000 }
1001
1002 if(select(maxfd+1, &fds, NULL, NULL, NULL) > 0) {
1003 if(FD_ISSET(monfd, &fds)) {
1004 int iskbd;
1005 dev = udev_monitor_receive_device(udevmon);
1006 const char *devnode = udev_device_get_devnode(dev);
1007 udev_type(dev, &iskbd, NULL);
1008
1009 if(devnode && iskbd) {
1010 const char *action = udev_device_get_action(dev);
1011
1012 if(!strcmp(action, "add"))
1013 manage_keyboard(devnode);
1014 else if(!strcmp(action, "remove"))
1015 destroy_keyboard(devnode);
1016 else
1017 dbg("udev: action %s %s", action, devnode);
1018 }
1019 udev_device_unref(dev);
1020 }
1021
1022
1023 for(kbd = keyboards;kbd;kbd=kbd->next) {
1024 int fd = kbd->fd;
1025
1026 if(FD_ISSET(fd, &fds)) {
1027 struct input_event ev;
1028
1029 while(read(fd, &ev, sizeof(ev)) > 0) {
1030 //Preprocess events.
1031 switch(ev.type) {
1032 case EV_KEY:
1033 if(IS_MOUSE_BTN(ev.code)) {
1034 write(vptr, &ev, sizeof(ev)); //Pass mouse buttons through the virtual pointer unimpeded.
1035 syn(vptr);
1036 } else if(ev.value == 2) {
1037 //Wayland and X both ignore repeat events but VTs seem to require them.
1038 send_repetitions();
1039 } else {
1040 process_key_event(kbd, ev.code, ev.value);
1041 }
1042 break;
1043 case EV_REL: //Pointer motion events
1044 write(vptr, &ev, sizeof(ev));
1045 syn(vptr);
1046 break;
1047 case EV_SYN:
1048 break;
1049 default:
1050 dbg("Unrecognized event: (type: %d, code: %d, value: %d)", ev.type, ev.code, ev.value);
1051 }
1052 }
1053 }
1054 }
1055 }
1056 }
1057 }
1058
1059
cleanup()1060 static void cleanup()
1061 {
1062 struct keyboard *kbd = keyboards;
1063 config_free();
1064
1065 while(kbd) {
1066 struct keyboard *tmp = kbd;
1067 kbd = kbd->next;
1068 free(tmp);
1069 }
1070
1071 udev_unref(udev);
1072 udev_monitor_unref(udevmon);
1073 }
1074
lock()1075 static void lock()
1076 {
1077 int fd;
1078
1079 if((fd=open(LOCK_FILE, O_CREAT | O_RDWR, 0600)) == -1) {
1080 perror("flock open");
1081 exit(1);
1082 }
1083
1084 if(flock(fd, LOCK_EX | LOCK_NB) == -1) {
1085 info("Another instance of keyd is already running.");
1086 exit(-1);
1087 }
1088 }
1089
1090
exit_signal_handler(int sig)1091 static void exit_signal_handler(int sig)
1092 {
1093 info("%s received, cleaning up and terminating...", sig == SIGINT ? "SIGINT" : "SIGTERM");
1094
1095 cleanup();
1096 exit(0);
1097 }
1098
daemonize()1099 static void daemonize()
1100 {
1101 int fd = open(LOG_FILE, O_APPEND|O_WRONLY);
1102
1103 info("Daemonizing.");
1104 info("Log output will be stored in %s", LOG_FILE);
1105
1106 if(fork()) exit(0);
1107 if(fork()) exit(0);
1108
1109 close(0);
1110 close(1);
1111 close(2);
1112
1113 dup2(fd, 1);
1114 dup2(fd, 2);
1115 }
1116
main(int argc,char * argv[])1117 int main(int argc, char *argv[])
1118 {
1119 if(getenv("KEYD_DEBUG"))
1120 debug = atoi(getenv("KEYD_DEBUG"));
1121
1122 dbg("Debug mode enabled.");
1123 dbg2("Verbose debugging enabled.");
1124
1125 if(argc > 1) {
1126 if(!strcmp(argv[1], "-v")) {
1127 fprintf(stderr, "keyd version: %s (%s)\n", VERSION, GIT_COMMIT_HASH);
1128 return 0;
1129 } else if(!strcmp(argv[1], "-m")) {
1130 return monitor_loop();
1131 } else if(!strcmp(argv[1], "-l")) {
1132 size_t i;
1133
1134 for(i = 0; i < KEY_MAX;i++)
1135 if(keycode_table[i].name) {
1136 const struct keycode_table_ent *ent = &keycode_table[i];
1137 printf("%s\n", ent->name);
1138 if(ent->alt_name)
1139 printf("%s\n", ent->alt_name);
1140 if(ent->shifted_name)
1141 printf("%s\n", ent->shifted_name);
1142 }
1143 return 0;
1144 } else {
1145 if(strcmp(argv[1], "-h") && strcmp(argv[1], "--help"))
1146 fprintf(stderr, "%s is not a valid option.\n", argv[1]);
1147
1148 fprintf(stderr, "Usage: %s [-m] [-l] [-d]\n\nOptions:\n"
1149 "\t-m monitor mode\n"
1150 "\t-l list keys\n"
1151 "\t-d fork and start as a daemon\n"
1152 "\t-v print version\n"
1153 "\t-h print this help message\n",
1154 argv[0]);
1155
1156 return 0;
1157 }
1158 }
1159
1160 lock();
1161
1162 signal(SIGINT, exit_signal_handler);
1163 signal(SIGTERM, exit_signal_handler);
1164
1165 if(argc > 1 && !strcmp(argv[1], "-d"))
1166 daemonize();
1167
1168 info("Starting keyd v%s (%s).", VERSION, GIT_COMMIT_HASH);
1169 config_generate();
1170 vkbd = create_virtual_keyboard();
1171 vptr = create_virtual_pointer();
1172
1173 main_loop();
1174 }
1175