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

[Peter Hutterer]

version 3 of the evemu-event patches. sorry, couldn't push to v2 for some reason but there's only two patches on top of the last one. Changes to v2:
- check for device path to exist and only exist once
- error out for unknown options

[Chase Douglas (chasedouglas)]

Looks good to me :).

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-11-24 03:24:15 +0000
+++ .bzrignore	2012-06-07 22:25:25 +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-07 22:25:25 +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-07 22:25:25 +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-07 22:25:25 +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-07 22:25:25 +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-07 22:25:25 +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-07 22:25:25 +0000
@@ -0,0 +1,154 @@
+/*****************************************************************************
+ *
+ * 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 = NULL;
+
+	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;
+			default:
+				usage();
+				goto out;
+		}
+	}
+
+	/* if device wasn't specified as option, take the remaining arg */
+	if (optind < argc) {
+		if (argc - optind != 1 || path) {
+			usage();
+			goto out;
+		}
+		path = argv[optind];
+	}
+
+	if (!path) {
+		fprintf(stderr, "error: missing device path\n");
+		usage();
+		goto out;
+	}
+
+	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;
+}