skel, configure_instance and channel for uinput

2 files changed, 204 insertions, 0 deletions

diff --git a/uinput.c b/uinput.c
new file mode 100644
index 0000000..e14ce59
--- /dev/null
+++ b/uinput.c
@@ -0,0 +1,180 @@
+#include <linux/input.h>
+
+#include "minimonster.h"
+#include "uinput.h"
+
+int init() {
+
+	backend uinput = {
+		.name = BACKEND_NAME,
+		.conf = backend_configure,
+		.create = backend_instance,
+		.conf_instance = backend_configure_instance,
+		.channel = backend_channel,
+		.handle = backend_set,
+		.process = backend_handle,
+		.start = backend_start,
+		.shutdown = backend_shutdown
+	};
+
+	if (mm_backend_register(uinput)) {
+		fprintf(stderr, "Failed to register uinput backend\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+static int backend_configure(char* option, char* value) {
+	fprintf(stderr, "Not implemented\n");
+	return 1;
+}
+
+static int backend_configure_instance(instance* inst, char* option, char* value) {
+	uinput_instance* data = (uinput_instance*) inst->impl;
+
+	if (!strcmp(option, "device")) {
+		if (data->device_path) {
+			free(data->device_path);
+		}
+		data->device_path = strdup(value);
+
+		if (!data->device_path) {
+			fprintf(stderr, "Failed to allocate memory\n");
+			return 1;
+		}
+	} else if (!strcmp(option, "name")) {
+		if (data->name) {
+			free(data->name);
+		}
+
+		data->name = strdup(option);
+
+		if (data->name) {
+			fprintf(stderr, "Failed to allocate memory\n");
+			return 1;
+		}
+	} else {
+		fprintf(stderr, "Unkown configuration parameter %s for uinput backend\n", option);
+		return 1;
+	}
+	return 0;
+}
+
+static channel* backend_channel(instance* inst, char* spec) {
+	uinput_instance* data = (uinput_instance*) inst->impl;
+	char* next = spec;
+	// type
+	unsigned long type = strtoul(spec, &next, 10);
+
+	if (spec == next) {
+		fprintf(stderr, "Cannot parse type\n");
+		return NULL;
+	}
+
+	if (type >= EV_MAX) {
+		fprintf(stderr, "Type is out of range\n");
+		return NULL;
+	}
+
+	if (next[0] != '.') {
+		fprintf(stderr, "Cannot parse code. Unknown character %c\n", next[0]);
+		return NULL;
+	}
+
+	spec = next + 1;
+
+	unsigned long code = strtoul(spec, &next, 10);
+
+	if (spec == next) {
+		fprintf(stderr, "Cannot parse code\n");
+		return NULL;
+	}
+
+	if (type == EV_SYN && code >= SYN_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for SYN is %d\n", SYN_MAX);
+	} else if (type == EV_KEY && code >= KEY_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for KEY is %d\n", KEY_MAX);
+		return NULL;
+	} else if (type == EV_REL && code >= REL_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for REL is %d\n", REL_MAX);
+		return NULL;
+	} else if (type == EV_ABS && code >= ABS_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for ABS is %d\n", ABS_MAX);
+		return NULL;
+	} else if (type == EV_SW && code >= SW_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for SW is %d\n", SW_MAX);
+		return NULL;
+	} else if (type == EV_MSC && code >= MSC_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for MSC is %d\n", MSC_MAX);
+		return NULL;
+	} else if (type == EV_LED && code >= LED_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for LED is %d\n", LED_MAX);
+		return NULL;
+	} else if (type == EV_REP && code >= REP_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for REP is %d\n", REP_MAX);
+		return NULL;
+	} else if (type == EV_SND && code >= SND_MAX) {
+		fprintf(stderr, "Code is out of range. Limit for SND is %d\n", SND_MAX);
+	}
+
+	if (next[0] != '.') {
+		fprintf(stderr, "Cannot parse value. Unknown character %c\n", next[0]);
+		return NULL;
+	}
+
+	spec = next + 1;
+
+	long value = strtol(spec, &next, 10);
+
+	if (spec == next) {
+		fprintf(stderr, "Cannot parse value\n");
+		return NULL;
+	}
+
+	if (type == EV_KEY && (value != 0 || value != 1)) {
+		fprintf(stderr, "Value of KEY is out of range. Only values 0 and 1 are supported for KEY.");
+		return NULL;
+	}
+
+	// find event
+	unsigned u;
+	for (u = 0; u < data.size_events) {
+		if (data->events[u].type == type
+				&& data->events[u].code == code
+				&& data->events[u].value == value) {
+			break;
+		}
+	}
+
+	if (u == data->size_events) {
+		data->events = realloc(data->channel, (u + 1) * sizeof(struct input_event));
+
+		if (!data->events) {
+			fprintf(stderr, "Failed to allocate memory\n");
+			return NULL;
+		}
+
+		data->events[u].type = (uint16_t) type;
+		data->events[u].code = (uint16_t) code;
+		data->events[u].value = (int32_t) value;
+		data->size_events++;
+	}
+	return mm_channel(inst, u, 1);
+}
+
+static instance* backend_instance() {
+	// TODO impl
+}
+
+static int backend_handle(size_t num, managed_fd* fds) {
+	//TODO impl
+}
+
+static int backend_start() {
+	//TODO impl
+}
+
+static int backend_shutdown() {
+	//TODO impl
+}
diff --git a/uinput.h b/uinput.h
new file mode 100644
index 0000000..8c4925a
--- /dev/null
+++ b/uinput.h
@@ -0,0 +1,24 @@
+#include <sys/types.h>
+#include <linux/input.h>
+
+#include "midimonster.h"
+
+int init();
+static int backend_configure(char* option, char* value);
+static int backend_configure_instance(instance* instance, char* option, char* value);
+static instance* backend_instance();
+static channel* backend_channel(instance* instance, char* spec);
+static int backend_set(instance* inst, size_t num, channel** c, channel_value* v);
+static int backend_handle(size_t num, managed_fd* fds);
+static int backend_start();
+static int backend_shutdown();
+
+/* uinput_instance */
+typedef struct {
+	char* device_path;
+	char* name;
+	int fd_in;
+	int fd_out;
+	size_t size_events;
+	struct input_event* events;
+} uinput_instance;