1 /*****************************************************************************
2 *
3 * evemu - Kernel device emulation
4 *
5 * Copyright (C) 2010-2012 Canonical Ltd.
6 * Copyright (C) 2013-2015 Red Hat, Inc.
7 *
8 * This library is free software: you can redistribute it and/or modify it
9 * under the terms of the GNU Lesser General Public License version 3
10 * as published by the Free Software Foundation.
11 *
12 * This library is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranties of
14 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library. If not, see <http://www.gnu.org/licenses/>.
19 *
20 * Copyright (C) 2010 Henrik Rydberg <rydberg@euromail.se>
21 *
22 * Permission is hereby granted, free of charge, to any person obtaining a
23 * copy of this software and associated documentation files (the "Software"),
24 * to deal in the Software without restriction, including without limitation
25 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
26 * and/or sell copies of the Software, and to permit persons to whom the
27 * Software is furnished to do so, subject to the following conditions:
28 *
29 * The above copyright notice and this permission notice (including the next
30 * paragraph) shall be included in all copies or substantial portions of the
31 * Software.
32 *
33 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
34 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
35 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
36 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
37 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
38 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
39 * DEALINGS IN THE SOFTWARE.
40 *
41 ****************************************************************************/
42
43 #define _GNU_SOURCE
44 #include "evemu-impl.h"
45 #include <stdint.h>
46 #include <stdarg.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <stdio.h>
50 #include <fcntl.h>
51 #include <errno.h>
52 #include <poll.h>
53 #include <ctype.h>
54 #include <unistd.h>
55 #include <sys/utsname.h>
56
57 #include "version.h"
58
59 /* File format version we write out
60 NOTE: if you bump the version number, make sure you update README */
61 #define EVEMU_FILE_MAJOR 1
62 #define EVEMU_FILE_MINOR 3
63
64 #define SYSCALL(call) while (((call) == -1) && (errno == EINTR))
65
66 enum error_level {
67 INFO,
68 WARNING,
69 FATAL,
70 };
71
72 static int error(enum error_level level, const char *format, ...)
73 __attribute__ ((format (printf, 2, 3)));
74
error(enum error_level level,const char * format,...)75 static int error(enum error_level level, const char *format, ...)
76 {
77 va_list args;
78 const char *strlevel = NULL;
79
80 switch (level) {
81 case INFO: strlevel = "INFO"; break;
82 case WARNING: strlevel = "WARNING"; break;
83 case FATAL: strlevel = "FATAL"; break;
84 }
85
86 fprintf(stderr, "%s: ", strlevel);
87 va_start(args, format);
88 vfprintf(stderr, format, args);
89 va_end(args);
90
91 return -1;
92 }
93
is_comment(char * line)94 static int is_comment(char *line)
95 {
96 return line && strlen(line) > 0 && line[0] == '#';
97 }
98
first_line(FILE * fp,char ** line,size_t * sz)99 static int first_line(FILE *fp, char **line, size_t *sz)
100 {
101 int rc = 1;
102 do {
103 if (getline(line, sz, fp) < 0) {
104 rc = 0;
105 break;
106 }
107 } while(*sz == 0 || strlen(*line) <= 1);
108
109 return rc;
110 }
111
next_line(FILE * fp,char ** line,size_t * sz)112 static int next_line(FILE *fp, char **line, size_t *sz)
113 {
114 while (first_line(fp, line, sz)) {
115 if (!is_comment(*line))
116 return 1;
117 }
118 return 0;
119 }
120
121
evemu_new(const char * name)122 struct evemu_device *evemu_new(const char *name)
123 {
124 struct evemu_device *dev = calloc(1, sizeof(struct evemu_device));
125
126 if (dev) {
127 dev->evdev = libevdev_new();
128 if (!dev->evdev) {
129 free(dev);
130 return NULL;
131 }
132 dev->version = EVEMU_VERSION;
133 evemu_set_name(dev, name);
134 }
135
136 return dev;
137 }
138
evemu_delete(struct evemu_device * dev)139 void evemu_delete(struct evemu_device *dev)
140 {
141 if (dev == NULL)
142 return;
143
144 if (dev->uidev)
145 evemu_destroy(dev);
146 libevdev_free(dev->evdev);
147 free(dev);
148 }
149
evemu_get_version(const struct evemu_device * dev)150 unsigned int evemu_get_version(const struct evemu_device *dev)
151 {
152 return dev->version;
153 }
154
evemu_get_name(const struct evemu_device * dev)155 const char *evemu_get_name(const struct evemu_device *dev)
156 {
157 return libevdev_get_name(dev->evdev);
158 }
159
evemu_set_name(struct evemu_device * dev,const char * name)160 void evemu_set_name(struct evemu_device *dev, const char *name)
161 {
162 if (name)
163 libevdev_set_name(dev->evdev, name);
164 }
165
166 #define ID_GETTER(field) \
167 unsigned int evemu_get_id_##field(const struct evemu_device *dev) { \
168 return libevdev_get_id_##field(dev->evdev); \
169 }
170
171 ID_GETTER(bustype)
ID_GETTER(version)172 ID_GETTER(version)
173 ID_GETTER(product)
174 ID_GETTER(vendor)
175
176 #define ID_SETTER(field) \
177 void evemu_set_id_##field(struct evemu_device *dev, unsigned int value) { \
178 libevdev_set_id_##field(dev->evdev, value); \
179 }
180
181 ID_SETTER(bustype)
182 ID_SETTER(version)
183 ID_SETTER(product)
184 ID_SETTER(vendor)
185
186 #define ABS_GETTER(field) \
187 int evemu_get_abs_##field(const struct evemu_device *dev, int code) { \
188 return libevdev_get_abs_##field(dev->evdev, code); \
189 }
190
191 ABS_GETTER(minimum)
192 ABS_GETTER(maximum)
193 ABS_GETTER(fuzz)
194 ABS_GETTER(flat)
195 ABS_GETTER(resolution)
196
197 #define ABS_SETTER(field) \
198 void evemu_set_abs_##field(struct evemu_device *dev, int code, int value) { \
199 libevdev_set_abs_##field(dev->evdev, code, value); \
200 }
201
202 ABS_SETTER(minimum)
203 ABS_SETTER(maximum)
204 ABS_SETTER(fuzz)
205 ABS_SETTER(flat)
206 ABS_SETTER(resolution)
207
208 int evemu_get_abs_current_value(const struct evemu_device *dev, int code)
209 {
210 return libevdev_get_event_value(dev->evdev, EV_ABS, code);
211 }
212
evemu_has_prop(const struct evemu_device * dev,int code)213 int evemu_has_prop(const struct evemu_device *dev, int code)
214 {
215 return libevdev_has_property(dev->evdev, code);
216 }
217
evemu_has_event(const struct evemu_device * dev,int type,int code)218 int evemu_has_event(const struct evemu_device *dev, int type, int code)
219 {
220 return libevdev_has_event_code(dev->evdev, type, code);
221 }
222
evemu_has_bit(const struct evemu_device * dev,int type)223 int evemu_has_bit(const struct evemu_device *dev, int type)
224 {
225 return libevdev_has_event_type(dev->evdev, type);
226 }
227
evemu_extract(struct evemu_device * dev,int fd)228 int evemu_extract(struct evemu_device *dev, int fd)
229 {
230 if (libevdev_get_fd(dev->evdev) != -1) {
231 libevdev_free(dev->evdev);
232 dev->evdev = libevdev_new();
233 if (!dev->evdev)
234 return -ENOMEM;
235 }
236 return libevdev_set_fd(dev->evdev, fd);
237 }
238
bit_is_set(unsigned char * mask,int bit)239 static inline int bit_is_set(unsigned char *mask, int bit)
240 {
241 return !!(mask[bit/8] & (1 << (bit & 0x7)));
242 }
243
set_bit(unsigned char * mask,int bit)244 static inline void set_bit(unsigned char *mask, int bit)
245 {
246 mask[bit/8] |= 1 << (bit & 0x7);
247 }
248
249 #define max(a, b) (a > b) ? a : b
250
write_prop(FILE * fp,const struct evemu_device * dev)251 static void write_prop(FILE * fp, const struct evemu_device *dev)
252 {
253 #ifdef INPUT_PROP_MAX
254 int i;
255 unsigned char mask[max(8, (INPUT_PROP_MAX + 7)/8)] = {0};
256
257 for (i = 0; i < INPUT_PROP_CNT; i ++) {
258 if (evemu_has_prop(dev, i))
259 set_bit(mask, i);
260 }
261
262 for (i = 0; i < (INPUT_PROP_CNT + 7)/8; i +=8) {
263 fprintf(fp, "P: %02x %02x %02x %02x %02x %02x %02x %02x\n",
264 mask[i], mask[i + 1], mask[i + 2], mask[i + 3],
265 mask[i + 4], mask[i + 5], mask[i + 6], mask[i + 7]);
266 }
267 #endif
268 }
269
write_mask(FILE * fp,const struct evemu_device * dev)270 static void write_mask(FILE * fp, const struct evemu_device *dev)
271 {
272 unsigned int type;
273
274 /* Write EV_SYN/SYN_REPORT only. Just because older versions
275 printed out exactly that */
276 fprintf(fp, "B: 00 0b 00 00 00 00 00 00 00\n");
277
278 for (type = 1 /* don't write EV_SYN */; type < EV_CNT; type++) {
279 int i;
280 int max = libevdev_event_type_get_max(type);
281 unsigned char mask[KEY_CNT] = {0};
282 unsigned int code;
283
284 if (max == -1)
285 continue;
286
287 for (code = 0; code <= (unsigned int)max; code++)
288 if (evemu_has_event(dev, type, code))
289 set_bit(mask, code);
290
291 for (i = 0; i < ((max + 1) + 7)/8; i += 8) {
292 fprintf(fp, "B: %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
293 type, mask[i], mask[i + 1], mask[i + 2], mask[i + 3],
294 mask[i + 4], mask[i + 5], mask[i + 6], mask[i + 7]);
295 }
296 }
297 }
298
write_abs(FILE * fp,int index,const struct input_absinfo * abs)299 static void write_abs(FILE *fp, int index, const struct input_absinfo *abs)
300 {
301 fprintf(fp, "A: %02x %d %d %d %d %d\n", index,
302 abs->minimum, abs->maximum, abs->fuzz, abs->flat, abs->resolution);
303 }
304
write_led(FILE * fp,int index,int state)305 static void write_led(FILE *fp, int index, int state)
306 {
307 fprintf(fp, "L: %02x %d\n", index, state);
308 }
309
write_sw(FILE * fp,int index,int state)310 static void write_sw(FILE *fp, int index, int state)
311 {
312 fprintf(fp, "S: %02x %d\n", index, state);
313 }
314
315 /* Print an evtest-like description */
write_desc(const struct evemu_device * dev,FILE * fp)316 static void write_desc(const struct evemu_device *dev, FILE *fp)
317 {
318 int i, j;
319 int state;
320 fprintf(fp, "# Input device name: \"%s\"\n", evemu_get_name(dev));
321 fprintf(fp, "# Input device ID: bus %#04x vendor %#04x product %#04x version %#04x\n",
322 evemu_get_id_bustype(dev), evemu_get_id_vendor(dev),
323 evemu_get_id_product(dev), evemu_get_id_version(dev));
324
325 if (evemu_has_event(dev, EV_ABS, ABS_X) &&
326 evemu_has_event(dev, EV_ABS, ABS_Y)) {
327 int min, max, res;
328 int w = 0, h = 0;
329
330 min = evemu_get_abs_minimum(dev, ABS_X);
331 max = evemu_get_abs_maximum(dev, ABS_X);
332 res = evemu_get_abs_resolution(dev, ABS_X);
333 if (res != 0)
334 w = (max - min)/res;
335
336 min = evemu_get_abs_minimum(dev, ABS_Y);
337 max = evemu_get_abs_maximum(dev, ABS_Y);
338 res = evemu_get_abs_resolution(dev, ABS_Y);
339 if (res != 0)
340 h = (max - min)/res;
341
342 if (w != 0 && h != 0)
343 fprintf(fp, "# Size in mm: %dx%d\n", w, h);
344 }
345
346 fprintf(fp, "# Supported events:\n");
347 for (i = 0; i < EV_CNT; i++) {
348 if (!evemu_has_bit(dev, i))
349 continue;
350
351 fprintf(fp, "# Event type %d (%s)\n", i, libevdev_event_type_get_name(i));
352 for (j = 0; j <= libevdev_event_type_get_max(i); j++) {
353 if (!evemu_has_event(dev, i, j))
354 continue;
355
356 fprintf(fp, "# Event code %d (%s)\n",
357 j, libevdev_event_code_get_name(i, j));
358 switch(i) {
359 case EV_ABS:
360 fprintf(fp,
361 "# Value %6d\n"
362 "# Min %6d\n"
363 "# Max %6d\n"
364 "# Fuzz %6d\n"
365 "# Flat %6d\n"
366 "# Resolution %3d\n",
367 evemu_get_abs_current_value(dev, j),
368 evemu_get_abs_minimum(dev, j),
369 evemu_get_abs_maximum(dev,j),
370 evemu_get_abs_fuzz(dev, j),
371 evemu_get_abs_flat(dev, j),
372 evemu_get_abs_resolution(dev, j));
373 break;
374 case EV_LED:
375 case EV_SW:
376 state = libevdev_get_event_value(dev->evdev, i, j);
377 fprintf(fp, "# State %d\n", state);
378 break;
379 default:
380 break;
381 }
382 }
383 }
384
385 #ifdef INPUT_PROP_MAX
386 fprintf(fp, "# Properties:\n");
387 for (i = 0; i < INPUT_PROP_CNT; i++) {
388 if (!evemu_has_prop(dev, i))
389 continue;
390 fprintf(fp, "# Property type %d (%s)\n", i,
391 libevdev_property_get_name(i));
392 }
393 #endif
394 }
395
396 static void
write_header(FILE * fp)397 write_header(FILE *fp)
398 {
399 struct utsname u;
400 char modalias[2048];
401 FILE *dmi;
402
403 fprintf(fp, "# EVEMU %d.%d\n", EVEMU_FILE_MAJOR, EVEMU_FILE_MINOR);
404
405 if (uname(&u) == -1)
406 return;
407
408 fprintf(fp, "# Kernel: %s\n", u.release);
409
410 dmi = fopen("/sys/class/dmi/id/modalias", "r");
411 if (dmi) {
412 if (fgets(modalias, sizeof(modalias), dmi)) {
413 fprintf(fp, "# DMI: %s", modalias);
414 }
415 fclose(dmi);
416 }
417 }
418
evemu_write(const struct evemu_device * dev,FILE * fp)419 int evemu_write(const struct evemu_device *dev, FILE *fp)
420 {
421 int i;
422 int state;
423
424 write_header(fp);
425
426 write_desc(dev, fp);
427
428 fprintf(fp, "N: %s\n", evemu_get_name(dev));
429
430 fprintf(fp, "I: %04x %04x %04x %04x\n",
431 evemu_get_id_bustype(dev),
432 evemu_get_id_vendor(dev),
433 evemu_get_id_product(dev),
434 evemu_get_id_version(dev));
435
436 write_prop(fp, dev);
437 write_mask(fp, dev);
438
439 for (i = 0; i < ABS_CNT; i++)
440 if (evemu_has_event(dev, EV_ABS, i))
441 write_abs(fp, i, libevdev_get_abs_info(dev->evdev, i));
442
443 for (i = 0; i < LED_CNT; i++)
444 if (evemu_has_event(dev, EV_LED, i) &&
445 (state = libevdev_get_event_value(dev->evdev, EV_LED, i)) != 0)
446 write_led(fp, i, state);
447
448 for (i = 0; i < SW_CNT; i++)
449 if (evemu_has_event(dev, EV_SW, i) &&
450 (state = libevdev_get_event_value(dev->evdev, EV_SW, i)) != 0)
451 write_sw(fp, i, state);
452
453 return 0;
454 }
455
parse_name(struct evemu_device * dev,const char * line)456 static int parse_name(struct evemu_device *dev, const char *line)
457 {
458 int matched;
459 char devname[UINPUT_MAX_NAME_SIZE];
460
461 if ((matched = sscanf(line, "N: %[^\n\r]\n", devname)) > 0) {
462 if (strlen(evemu_get_name(dev)) == 0)
463 evemu_set_name(dev, devname);
464 }
465
466 if (matched <= 0)
467 error(FATAL, "Expected device name, but got: %s", line);
468
469 return matched > 0;
470 }
471
parse_bus_vid_pid_ver(struct evemu_device * dev,const char * line)472 static int parse_bus_vid_pid_ver(struct evemu_device *dev, const char *line)
473 {
474 int matched;
475 unsigned bustype, vendor, product, version;
476
477 if ((matched = sscanf(line, "I: %04x %04x %04x %04x\n",
478 &bustype, &vendor, &product, &version)) > 0) {
479 evemu_set_id_bustype(dev, bustype);
480 evemu_set_id_vendor(dev, vendor);
481 evemu_set_id_product(dev, product);
482 evemu_set_id_version(dev, version);
483 }
484
485 if (matched != 4)
486 error(FATAL, "Expected bus/vendor/product/version, got: %s", line);
487
488 return matched == 4;
489 }
490
parse_prop(struct evemu_device * dev,const char * line)491 static int parse_prop(struct evemu_device *dev, const char *line)
492 {
493 int matched;
494 unsigned char mask[8];
495 size_t i;
496
497 if (strlen(line) <= 2 || strncmp(line, "P:", 2) != 0)
498 return 0;
499
500 matched = sscanf(line, "P: %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
501 mask + 0, mask + 1, mask + 2, mask + 3,
502 mask + 4, mask + 5, mask + 6, mask + 7);
503
504 if (matched != 8) {
505 error(WARNING, "Invalid INPUT_PROP line. Parsed %d numbers, expected 8: %s", matched, line);
506 return -1;
507 }
508
509 for (i = 0; i < sizeof(mask) * 8; i++) {
510 if (bit_is_set(mask, i))
511 libevdev_enable_property(dev->evdev, dev->pbytes * 8 + i);
512 }
513
514 dev->pbytes += 8;
515
516 return 1;
517 }
518
parse_mask(struct evemu_device * dev,const char * line)519 static int parse_mask(struct evemu_device *dev, const char *line)
520 {
521 int matched;
522 unsigned char mask[8];
523 unsigned int index, i;
524
525 if (strlen(line) <= 2 || strncmp(line, "B:", 2) != 0)
526 return 0;
527
528 matched = sscanf(line, "B: %02x %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx\n",
529 &index, mask + 0, mask + 1, mask + 2, mask + 3,
530 mask + 4, mask + 5, mask + 6, mask + 7);
531
532 if (matched != 9) {
533 error(FATAL, "Invalid EV_BIT line. Parsed %d numbers, expected 9: %s", matched, line);
534 return -1;
535 }
536
537 if (index >= EV_CNT) {
538 error(FATAL, "Invalid EV_* index %#x in line: %s", index, line);
539 return -1;
540 }
541
542 for (i = 0; i < sizeof(mask) * 8; i++) {
543 if (bit_is_set(mask, i)) {
544 struct input_absinfo abs = {0}; /* dummy */
545
546 abs.minimum = 0;
547 abs.maximum = 1;
548
549 unsigned int code = dev->mbytes[index] * 8 + i;
550 libevdev_enable_event_code(dev->evdev, index, code, (index == EV_ABS) ? &abs : NULL);
551 }
552 }
553
554 dev->mbytes[index] += 8;
555
556 return 1;
557 }
558
parse_abs(struct evemu_device * dev,const char * line,struct version * fversion)559 static int parse_abs(struct evemu_device *dev, const char *line, struct version *fversion)
560 {
561 int matched;
562 struct input_absinfo abs = {0};
563 unsigned int index;
564 int needed = 5;
565
566 if (version_cmp(*fversion, version(1, 1)) > 0)
567 needed = 6; /* resolution field */
568
569 if (strlen(line) <= 2 || strncmp(line, "A:", 2) != 0)
570 return 0;
571
572 matched = sscanf(line, "A: %02x %d %d %d %d %d\n",
573 &index, &abs.minimum, &abs.maximum,
574 &abs.fuzz, &abs.flat, &abs.resolution);
575
576 if (matched != needed) {
577 error(FATAL, "Invalid EV_ABS line. Parsed %d numbers, expected %d: %s", matched, needed, line);
578 return -1;
579 }
580
581 evemu_set_abs_minimum(dev, index, abs.minimum);
582 evemu_set_abs_maximum(dev, index, abs.maximum);
583 evemu_set_abs_fuzz(dev, index, abs.fuzz);
584 evemu_set_abs_flat(dev, index, abs.flat);
585 evemu_set_abs_resolution(dev, index, abs.resolution);
586
587 return 1;
588 }
589
parse_led(const char * line)590 static int parse_led(const char *line)
591 {
592 int matched;
593 unsigned int index;
594 int state;
595
596 if (strlen(line) <= 2 || strncmp(line, "L:", 2) != 0)
597 return 0;
598
599 matched = sscanf(line, "L: %02x %d\n", &index, &state);
600
601 if (matched != 2) {
602 error(FATAL, "Invalid EV_LED line. Parsed %d numbers, expected 2: %s", matched, line);
603 return -1;
604 }
605
606 /* We can't set the LEDs directly, we'd have to send an event
607 * through the device but that's potentially racy */
608
609 return 1;
610 }
611
parse_sw(const char * line)612 static int parse_sw(const char *line)
613 {
614 int matched;
615 unsigned int index;
616 int state;
617
618 if (strlen(line) <= 2 || strncmp(line, "S:", 2) != 0)
619 return 0;
620
621 matched = sscanf(line, "S: %02x %d\n", &index, &state);
622
623 if (matched != 2) {
624 error(FATAL, "Invalid EV_SW line. Parsed %d numbers, expected 2: %s", matched, line);
625 return -1;
626 }
627
628 /* We can't set the switches directly, we'd have to send an event
629 * through the device but that's potentially racy */
630
631 return 1;
632 }
633
parse_file_format_version(const char * line)634 static struct version parse_file_format_version(const char *line)
635 {
636 struct version v;
637 uint16_t major, minor;
638
639 if (sscanf(line, "# EVEMU %hd.%hd\n", &major, &minor) != 2) {
640 major = 1;
641 minor = 0;
642 }
643
644
645 v = version(major, minor);
646
647 if (version_cmp(v, version(EVEMU_FILE_MAJOR, EVEMU_FILE_MINOR)) > 0)
648 fprintf(stderr, "Warning: file format %d.%d is newer than "
649 "supported version %d.%d.\n",
650 major, minor, EVEMU_FILE_MAJOR, EVEMU_FILE_MINOR);
651
652 return v;
653 }
654
evemu_read(struct evemu_device * dev,FILE * fp)655 int evemu_read(struct evemu_device *dev, FILE *fp)
656 {
657 int rc = -1;
658 struct version file_version; /* file format version */
659 size_t size = 0;
660 char *line = NULL;
661
662 memset(dev->mbytes, 0, sizeof(*dev->mbytes));
663 dev->pbytes = 0;
664 dev->version = EVEMU_VERSION;
665
666 /* first line _may_ be version */
667 if (!first_line(fp, &line, &size)) {
668 error(WARNING, "This appears to be an empty file\n");
669 return -1;
670 }
671
672 file_version = parse_file_format_version(line);
673
674 if (is_comment(line) && !next_line(fp, &line, &size)) {
675 error(WARNING, "This appears to be an empty file\n");
676 goto out;
677 }
678
679 if (!parse_name(dev, line))
680 goto out;
681
682 if (!next_line(fp, &line, &size))
683 goto out;
684
685 if (!parse_bus_vid_pid_ver(dev, line))
686 goto out;
687
688 /* devices without prop/mask/abs bits are valid */
689 if (!next_line(fp, &line, &size)) {
690 rc = 1;
691 goto out;
692 }
693
694 while((rc = parse_prop(dev, line)) > 0)
695 if (!next_line(fp, &line, &size))
696 break;
697 if (rc == -1)
698 goto out;
699
700 while((rc = parse_mask(dev, line)) > 0)
701 if (!next_line(fp, &line, &size))
702 break;
703 if (rc == -1)
704 goto out;
705
706 while((rc = parse_abs(dev, line, &file_version)) > 0)
707 if (!next_line(fp, &line, &size))
708 break;
709 if (rc == -1)
710 goto out;
711
712 while((rc = parse_led(line)) > 0)
713 if (!next_line(fp, &line, &size))
714 break;
715 if (rc == -1)
716 goto out;
717
718 while((rc = parse_sw(line)) > 0)
719 if (!next_line(fp, &line, &size))
720 break;
721 if (rc == -1)
722 goto out;
723
724 rc = 1;
725
726 fseek(fp, -strlen(line), SEEK_CUR);
727
728 out:
729 free(line);
730 return rc;
731 }
732
millis(const struct timeval * tv)733 static inline unsigned long millis(const struct timeval *tv)
734 {
735 return tv->tv_sec * 1000 + tv->tv_usec/1000;
736 }
737
write_event_desc(FILE * fp,const struct input_event * ev)738 static int write_event_desc(FILE *fp, const struct input_event *ev)
739 {
740 int rc;
741 static unsigned long last_ms = 0;
742 unsigned long time, dt;
743
744 if (ev->type == EV_SYN) {
745 if (ev->code == SYN_MT_REPORT) {
746 rc = fprintf(fp, "# ++++++++++++ %s (%d) ++++++++++\n",
747 libevdev_event_code_get_name(ev->type, ev->code),
748 ev->value);
749 } else {
750 time = millis(&ev->time);
751 dt = time - last_ms;
752 last_ms = time;
753 rc = fprintf(fp, "# ------------ %s (%d) ---------- %+ldms\n",
754 libevdev_event_code_get_name(ev->type, ev->code),
755 ev->value,
756 dt);
757 }
758 } else {
759 rc = fprintf(fp, "# %s / %-20s %d\n",
760 libevdev_event_type_get_name(ev->type),
761 libevdev_event_code_get_name(ev->type, ev->code),
762 ev->value);
763 }
764 return rc;
765 }
766
evemu_write_event(FILE * fp,const struct input_event * ev)767 int evemu_write_event(FILE *fp, const struct input_event *ev)
768 {
769 int rc;
770 rc = fprintf(fp, "E: %lu.%06u %04x %04x %04d ",
771 ev->time.tv_sec, (unsigned)ev->time.tv_usec,
772 ev->type, ev->code, ev->value);
773 rc += write_event_desc(fp, ev);
774 return rc;
775 }
776
time_to_long(const struct timeval * tv)777 static inline long time_to_long(const struct timeval *tv) {
778 return tv->tv_sec * 1000000L + tv->tv_usec;
779 }
780
long_to_time(long time)781 static inline struct timeval long_to_time(long time) {
782 struct timeval tv;
783 tv.tv_sec = time/1000000L;
784 tv.tv_usec = time % 1000000L;
785 return tv;
786 }
787
evemu_record(FILE * fp,int fd,int ms)788 int evemu_record(FILE *fp, int fd, int ms)
789 {
790 struct pollfd fds = { fd, POLLIN, 0 };
791 struct input_event ev;
792 int ret;
793 long offset = 0;
794
795 while (poll(&fds, 1, ms) > 0) {
796 SYSCALL(ret = read(fd, &ev, sizeof(ev)));
797 if (ret < 0)
798 return ret;
799 if (ret == sizeof(ev)) {
800 long time;
801
802 if (offset == 0)
803 offset = time_to_long(&ev.time) - 1;
804
805 time = time_to_long(&ev.time);
806 ev.time = long_to_time(time - offset);
807 evemu_write_event(fp, &ev);
808 fflush(fp);
809 }
810 }
811
812 return 0;
813 }
814
evemu_read_event(FILE * fp,struct input_event * ev)815 int evemu_read_event(FILE *fp, struct input_event *ev)
816 {
817 unsigned long sec;
818 unsigned usec, type, code;
819 int value;
820 int matched = 0;
821 char *line = NULL;
822 size_t size = 0;
823
824 do {
825 if (!next_line(fp, &line, &size))
826 goto out;
827 } while(strlen(line) > 2 && strncmp(line, "E:", 2) != 0);
828
829 if (strlen(line) <= 2 || strncmp(line, "E:", 2) != 0)
830 goto out;
831
832 matched = sscanf(line, "E: %lu.%06u %04x %04x %d\n",
833 &sec, &usec, &type, &code, &value);
834 if (matched != 5) {
835 error(FATAL, "Invalid event format: %s\n", line);
836 return -1;
837 }
838
839 ev->time.tv_sec = sec;
840 ev->time.tv_usec = usec;
841 ev->type = type;
842 ev->code = code;
843 ev->value = value;
844
845 out:
846 free(line);
847 return matched > 0;
848 }
849
evemu_create_event(struct input_event * ev,int type,int code,int value)850 int evemu_create_event(struct input_event *ev, int type, int code, int value)
851 {
852 ev->time.tv_sec = 0;
853 ev->time.tv_usec = 0;
854 ev->type = type;
855 ev->code = code;
856 ev->value = value;
857 return 0;
858 }
859
s2us(unsigned long s)860 static inline unsigned long s2us(unsigned long s)
861 {
862 return s * 1000000L;
863 }
864
us2s(unsigned long us)865 static inline unsigned long us2s(unsigned long us)
866 {
867 return us / 1000000L;
868 }
869
evemu_read_event_realtime(FILE * fp,struct input_event * ev,struct timeval * evtime)870 int evemu_read_event_realtime(FILE *fp, struct input_event *ev,
871 struct timeval *evtime)
872 {
873 unsigned long usec;
874 const unsigned long ERROR_MARGIN = 150; /* µs */
875 int ret;
876
877 ret = evemu_read_event(fp, ev);
878 if (ret <= 0)
879 return ret;
880
881 if (evtime) {
882 if (evtime->tv_sec == 0 && evtime->tv_usec == 0)
883 *evtime = ev->time;
884 usec = time_to_long(&ev->time) - time_to_long(evtime);
885 if (usec > ERROR_MARGIN * 2) {
886 if (usec > s2us(10))
887 error(INFO, "Sleeping for %lds.\n", us2s(usec));
888 usleep(usec - ERROR_MARGIN);
889 *evtime = ev->time;
890 }
891 }
892
893 return ret;
894 }
895
evemu_play_one(int fd,const struct input_event * ev)896 int evemu_play_one(int fd, const struct input_event *ev)
897 {
898 int ret;
899 SYSCALL(ret = write(fd, ev, sizeof(*ev)));
900 return (ret == -1 || (size_t)ret < sizeof(*ev)) ? -1 : 0;
901 }
902
evemu_warn_about_incompatible_event(struct input_event * ev)903 static void evemu_warn_about_incompatible_event(struct input_event *ev)
904 {
905 const int max_warnings = 3;
906 static int warned = 0;
907
908 if (++warned <= max_warnings) {
909 if (warned == 1)
910 error(WARNING, "You are trying to play events incompatbile with this device. "
911 "Is this the right device/recordings file?\n");
912 error(WARNING, "%s %s is not supported by this device.\n",
913 libevdev_event_type_get_name(ev->type),
914 libevdev_event_code_get_name(ev->type, ev->code));
915 } else if (warned == max_warnings + 1) {
916 error(INFO, "warned about incompatible events %d times. Will be quiet now.\n",
917 warned - 1);
918 }
919 }
920
evemu_play(FILE * fp,int fd)921 int evemu_play(FILE *fp, int fd)
922 {
923 struct input_event ev;
924 struct timeval evtime;
925 int ret;
926 struct evemu_device *dev;
927
928 dev = evemu_new(NULL);
929 if (dev) {
930 if (evemu_extract(dev, fd) != 0) {
931 evemu_delete(dev);
932 dev = NULL;
933 }
934 }
935
936 memset(&evtime, 0, sizeof(evtime));
937 while (evemu_read_event_realtime(fp, &ev, &evtime) > 0) {
938 if (dev &&
939 (ev.type != EV_SYN || ev.code != SYN_MT_REPORT) &&
940 !evemu_has_event(dev, ev.type, ev.code))
941 evemu_warn_about_incompatible_event(&ev);
942 SYSCALL(ret = write(fd, &ev, sizeof(ev)));
943 }
944
945 if (dev)
946 evemu_delete(dev);
947 return 0;
948 }
949
evemu_create(struct evemu_device * dev,int fd)950 int evemu_create(struct evemu_device *dev, int fd)
951 {
952 return libevdev_uinput_create_from_device(dev->evdev, fd, &dev->uidev);
953 }
954
evemu_create_managed(struct evemu_device * dev)955 int evemu_create_managed(struct evemu_device *dev)
956 {
957 return libevdev_uinput_create_from_device(dev->evdev,
958 LIBEVDEV_UINPUT_OPEN_MANAGED, &dev->uidev);
959 }
960
evemu_get_devnode(struct evemu_device * dev)961 const char *evemu_get_devnode(struct evemu_device *dev)
962 {
963 return libevdev_uinput_get_devnode(dev->uidev);
964 }
965
evemu_destroy(struct evemu_device * dev)966 void evemu_destroy(struct evemu_device *dev)
967 {
968 if (dev->uidev) {
969 libevdev_uinput_destroy(dev->uidev);
970 dev->uidev = NULL;
971 }
972 }
973