Merge lp:~peter-hutterer/evemu/evemu-event-v2 into lp:evemu

[Peter Hutterer]

Updated branch for evemu-event. Changes to v1:
- evemu_play_one_event fixed, used wrong return code before
- use getopt parsing (changes the user interface, but this is a new tool anyways)
- check for strtol failures
- check input ranges
- check EV_SYN event sending, use EV_SYN/SYN_REPORT as type/code instead of 0/0

[Chase Douglas (chasedouglas)]

* This comment doesn't make sense:

if (c == -1) /* we only do long options */

I would rather be able to support both short and long options, and the code does seem to support both if I am reading the getopt_long manpage correctly. I suggest we just remove the comment.

* The getopt switch needs a default: clause to catch bad options. Right now it looks like it would just skip over bad options. I suggest adding:

default:
    usage();
    goto out;

* I had never heard of program_invocation_short_name before. I learned something new today! It looks like we should be defining _GNU_SOURCE above the include of error.h.

* If the device is specified as an option, and then one non-option string is provided at the end, the non-option string will overwrite the device path. We need to add a check for if the device path has already been specified before assuming the last argument is the path.

* The usage string and man pages need to be updated so they note that you either provide the device path as an option or you provide the path as the last argument. I don't think the code will work otherwise.

review: Needs Fixing

[Peter Hutterer (peter-hutterer)]

> * This comment doesn't make sense:
>
> if (c == -1) /* we only do long options */
>
> I would rather be able to support both short and long options, and the code
> does seem to support both if I am reading the getopt_long manpage correctly. I
> suggest we just remove the comment.

The comment is a leftover from a earlier revision that had a more complex condition. It's not needed but it's still valid, we only do long options. the third arg to getopt_long specifies the short options and that's an empty string here. Intentionally, I want to leave short options for common ones if we ever need them. e.g. --value should not be -v, that is reserved for a future "verbose".

 > * The getopt switch needs a default: clause to catch bad options. Right now it
> looks like it would just skip over bad options. I suggest adding:
>
> default:
> usage();
> goto out;

Added, thanks.

> * I had never heard of program_invocation_short_name before. I learned
> something new today! It looks like we should be defining _GNU_SOURCE above the
> include of error.h.

it's hardcoded in configure.ac already (fwiw, _GNU_SOURCE is needed for getopt_long too)

> * If the device is specified as an option, and then one non-option string is
> provided at the end, the non-option string will overwrite the device path. We
> need to add a check for if the device path has already been specified before
> assuming the last argument is the path.

good catch, fixed. together with not actually checking if a path has been specified.

> * The usage string and man pages need to be updated so they note that you
> either provide the device path as an option or you provide the path as the
> last argument. I don't think the code will work otherwise.

getopt_long takes care of that, it doesn't matter where non-option arguments are given. I was testing with evemu-event /dev/input/event0 --value ... the whole time.

Unmerged revisions

60. By Peter Hutterer on 2012-06-06

Use getopt for option parsing

This is a change in the user interface, the arguments must now be specified
instead of just listed in the correct order.

59. By Peter Hutterer on 2012-06-06

Range-check argument values for evemu-event

type must be less than EV_MAX
code's maximum is effectively KEY_MAX but let's use USHRT_MAX to be safe for
future key additions
value is int value range

58. By Peter Hutterer on 2012-06-06

Don't open the device until we've parsed all arguments successfully

57. By Peter Hutterer on 2012-06-06

Check arguments' strtol conversion for errors

56. By Peter Hutterer on 2012-06-06

Always close the fd, even on errors.

55. By Peter Hutterer on 2012-06-06

Print errors if SYN event creation/playback failed

54. By Peter Hutterer on 2012-06-06

Use EV_SYN and SYN_REPORT instead of 0/0

53. By Peter Hutterer on 2012-06-06

Add evemu-event to play a single event from the commandline

Some testing scenarios require specific events to be generated that are hard
to create from a physical device (e.g. touchpad motion purely on the
positive X axis with no Y axis). For those scenarios, recording a device and
hacking the evemu event files is time consuming.

evemu-event simply allows this scenario to be scripted.

52. By Thomas Voß on 2012-06-06

Fixed failing tests for device creation.

51. By Stephen M. Webb on 2012-06-06

release 1.0.9

=== modified file '.bzrignore'
--- .bzrignore	2011-11-24 03:24:15 +0000
+++ .bzrignore	2012-06-06 03:28:21 +0000
@@ -19,6 +19,8 @@
 tools/evemu-device
 tools/evemu-device.1
 tools/evemu-echo
+tools/evemu-event
+tools/evemu-event.1
 tools/evemu-play
 tools/evemu-play.1
 tools/evemu-record

=== modified file 'include/evemu.h'
--- include/evemu.h	2012-06-05 16:09:52 +0000
+++ include/evemu.h	2012-06-06 03:28:21 +0000
@@ -328,6 +328,15 @@
 int evemu_write_event(FILE *fp, const struct input_event *ev);
 
 /**
+ * evemu_create_event() - Create a single event
+ * @ev: pointer to the kernel event to be filled
+ * @type: the event type to set
+ * @code: the event code to set
+ * @value: the event value to set
+ */
+int evemu_create_event(struct input_event *ev, int type, int code, int value);
+
+/**
  * evemu_read_event() - read kernel event from file
  * @fp: file pointer to read the event from
  * @ev: pointer to the kernel event to be filled
@@ -370,6 +379,14 @@
  */
 int evemu_record(FILE *fp, int fd, int ms);
 
+
+/**
+ * evemu_play_one() - play one event to kernel device
+ * @fd: file descriptor of kernel device to write to
+ * @ev: pointer to the kernel event to be played
+ */
+int evemu_play_one(int fd, const struct input_event *ev);
+
 /**
  * evemu_play() - replay events from file to kernel device in realtime
  * @fp: file pointer to read the events from

=== modified file 'src/evemu.c'
--- src/evemu.c	2012-06-05 16:13:31 +0000
+++ src/evemu.c	2012-06-06 03:28:21 +0000
@@ -425,6 +425,16 @@
 	return ret;
 }
 
+int evemu_create_event(struct input_event *ev, int type, int code, int value)
+{
+	ev->time.tv_sec = 0;
+	ev->time.tv_usec = 0;
+	ev->type = type;
+	ev->code = code;
+	ev->value = value;
+	return 0;
+}
+
 int evemu_read_event_realtime(FILE *fp, struct input_event *ev,
 			      struct timeval *evtime)
 {
@@ -449,6 +459,13 @@
 	return ret;
 }
 
+int evemu_play_one(int fd, const struct input_event *ev)
+{
+	int ret;
+	SYSCALL(ret = write(fd, ev, sizeof(*ev)));
+	return (ret < sizeof(*ev));
+}
+
 int evemu_play(FILE *fp, int fd)
 {
 	struct input_event ev;

=== modified file 'src/libutouch-evemu.ver'
--- src/libutouch-evemu.ver	2012-06-05 16:09:52 +0000
+++ src/libutouch-evemu.ver	2012-06-06 03:28:21 +0000
@@ -1,6 +1,7 @@
 UTOUCH_EVEMU_1.0 {
   global:
     evemu_create;
+    evemu_create_event;
     evemu_delete;
     evemu_destroy;
     evemu_extract;
@@ -19,6 +20,7 @@
     evemu_has_prop;
     evemu_new;
     evemu_play;
+    evemu_play_one;
     evemu_read;
     evemu_read_event;
     evemu_read_event_realtime;

=== modified file 'tools/Makefile.am'
--- tools/Makefile.am	2011-01-05 10:19:44 +0000
+++ tools/Makefile.am	2012-06-06 03:28:21 +0000
@@ -5,7 +5,8 @@
 	evemu-describe \
 	evemu-device \
 	evemu-record \
-	evemu-play
+	evemu-play \
+	evemu-event
 
 INCLUDES=-I$(top_srcdir)/include/
 

=== modified file 'tools/evemu-device.txt'
--- tools/evemu-device.txt	2011-01-05 10:19:44 +0000
+++ tools/evemu-device.txt	2012-06-06 03:28:21 +0000
@@ -4,8 +4,8 @@
 NAME
 ----
 
-     evemu-device, evemu-play  - create a virtual input device and replay an
-     event sequence
+     evemu-device, evemu-play, evemu-event  - create a virtual input device
+     and replay an event sequence
 
 SYNOPSIS
 --------
@@ -13,6 +13,8 @@
 
      evemu-play /dev/input/eventX < event-sequence
 
+     evemu-event /dev/input/eventX [--sync] --type <type> --code <code> --value <value>
+
 DESCRIPTION
 -----------
 evemu-device creates a virtual input device based on the description-file.
@@ -24,6 +26,9 @@
 evemu-play replays the event sequence given on stdin through the input
 device. The event sequence must be in the form created by evemu-record(1).
 
+evemu-event plays exactly one event with the current time. If *--sync* is
+given, evemu-event generates an *EV_SYN* event after the event.
+
 evemu-device must be able to write to the uinput device node, and evemu-play
 must be able to write to the device node specified; in most cases this means
 it must be run as root.

=== added file 'tools/evemu-event.c'
--- tools/evemu-event.c	1970-01-01 00:00:00 +0000
+++ tools/evemu-event.c	2012-06-06 03:28:21 +0000
@@ -0,0 +1,145 @@
+/*****************************************************************************
+ *
+ * evemu - Kernel device emulation
+ *
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ ****************************************************************************/
+#include "evemu.h"
+#include <getopt.h>
+#include <limits.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <linux/input.h>
+
+static struct option opts[] = {
+	{ "type", required_argument, 0, 't'},
+	{ "code", required_argument, 0, 'c'},
+	{ "value", required_argument, 0, 'v'},
+	{ "sync", no_argument, 0, 's'},
+	{ "device", required_argument, 0, 'd'}
+};
+
+int parse_arg(const char *arg, long int *value)
+{
+	char *endp;
+
+	*value = strtol(arg, &endp, 0);
+	if (*arg == '\0' || *endp != '\0')
+		return 1;
+	return 0;
+}
+
+void usage(void)
+{
+	fprintf(stderr, "Usage: %s [--sync] <device> --type <type> --code <code> --value <value>\n", program_invocation_short_name);
+}
+
+int main(int argc, char *argv[])
+{
+	int rc = -1;
+	int fd = -1;
+	long int type, code, value;
+	struct input_event ev;
+	int sync = 0;
+	const char *path;
+
+	if (argc < 5) {
+		usage();
+		goto out;
+	}
+
+	while(1) {
+		int option_index = 0;
+		int c;
+
+		c = getopt_long(argc, argv, "", opts, &option_index);
+		if (c == -1) /* we only do long options */
+			break;
+
+		switch(c) {
+			case 't': /* type */
+				if (parse_arg(optarg, &type) || type < 0 || type > EV_MAX) {
+					fprintf(stderr, "error: invalid type argument '%s'\n", optarg);
+					goto out;
+				}
+				break;
+			case 'c': /* code */
+				if (parse_arg(optarg, &code) || code < 0 || code > USHRT_MAX) {
+					fprintf(stderr, "error: invalid code argument '%s'\n", optarg);
+					goto out;
+				}
+				break;
+			case 'v': /* value */
+				if (parse_arg(optarg, &value) || value < INT_MIN || value > INT_MAX) {
+					fprintf(stderr, "error: invalid value argument '%s'\n", optarg);
+					goto out;
+				}
+				break;
+			case 'd': /* device */
+				path = optarg;
+				break;
+			case 's': /* sync */
+				sync = 1;
+				break;
+		}
+	}
+
+	/* if device wasn't specified as option, take the remaining arg */
+	if (optind < argc) {
+		if (argc - optind != 1) {
+			usage();
+			goto out;
+		}
+		path = argv[optind];
+	}
+
+	fd = open(path, O_WRONLY);
+	if (fd < 0) {
+		fprintf(stderr, "error: could not open device\n");
+		goto out;
+	}
+
+	if (evemu_create_event(&ev, type, code, value)) {
+		fprintf(stderr, "error: failed to create event\n");
+		goto out;
+	}
+
+	if (evemu_play_one(fd, &ev)) {
+		fprintf(stderr, "error: could not play event\n");
+		goto out;
+	}
+
+	if (sync) {
+		if (evemu_create_event(&ev, EV_SYN, SYN_REPORT, 0)) {
+			fprintf(stderr, "error: could not create SYN event\n");
+			goto out;
+		}
+		if (evemu_play_one(fd, &ev)) {
+			fprintf(stderr, "error: could not play SYN event\n");
+			goto out;
+		}
+	}
+
+	rc = 0;
+out:
+	if (fd > -1)
+		close(fd);
+	return rc;
+}