[RFC PATCH 1/1] Add a usbredir kernel module to remotely connect USB devices over IP.

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



This module uses the usbredir protocol and user space tools,
which are used by the SPICE project.

Signed-off-by: Jeremy White <jwhite@xxxxxxxxxxxxxxx>
---
 MAINTAINERS                                 |    6 +
 drivers/usb/Kconfig                         |    2 +
 drivers/usb/Makefile                        |    1 +
 drivers/usb/usbredir/Kconfig                |   25 +
 drivers/usb/usbredir/Makefile               |    4 +
 drivers/usb/usbredir/README                 |   20 +
 drivers/usb/usbredir/TODO                   |   12 +
 drivers/usb/usbredir/device.c               |  327 +++++
 drivers/usb/usbredir/hub.c                  |  489 ++++++++
 drivers/usb/usbredir/main.c                 |  100 ++
 drivers/usb/usbredir/redir.c                |  535 ++++++++
 drivers/usb/usbredir/rx.c                   |   40 +
 drivers/usb/usbredir/strtok_r.c             |   69 +
 drivers/usb/usbredir/strtok_r.h             |   26 +
 drivers/usb/usbredir/sysfs.c                |  145 +++
 drivers/usb/usbredir/tx.c                   |  151 +++
 drivers/usb/usbredir/urb.c                  |  266 ++++
 drivers/usb/usbredir/usbredir.h             |  225 ++++
 drivers/usb/usbredir/usbredirfilter.c       |  294 +++++
 drivers/usb/usbredir/usbredirfilter.h       |  144 +++
 drivers/usb/usbredir/usbredirparser.c       | 1795 +++++++++++++++++++++++++++
 drivers/usb/usbredir/usbredirparser.h       |  386 ++++++
 drivers/usb/usbredir/usbredirproto-compat.h |   88 ++
 drivers/usb/usbredir/usbredirproto.h        |  309 +++++
 24 files changed, 5459 insertions(+)
 create mode 100644 drivers/usb/usbredir/Kconfig
 create mode 100644 drivers/usb/usbredir/Makefile
 create mode 100644 drivers/usb/usbredir/README
 create mode 100644 drivers/usb/usbredir/TODO
 create mode 100644 drivers/usb/usbredir/device.c
 create mode 100644 drivers/usb/usbredir/hub.c
 create mode 100644 drivers/usb/usbredir/main.c
 create mode 100644 drivers/usb/usbredir/redir.c
 create mode 100644 drivers/usb/usbredir/rx.c
 create mode 100644 drivers/usb/usbredir/strtok_r.c
 create mode 100644 drivers/usb/usbredir/strtok_r.h
 create mode 100644 drivers/usb/usbredir/sysfs.c
 create mode 100644 drivers/usb/usbredir/tx.c
 create mode 100644 drivers/usb/usbredir/urb.c
 create mode 100644 drivers/usb/usbredir/usbredir.h
 create mode 100644 drivers/usb/usbredir/usbredirfilter.c
 create mode 100644 drivers/usb/usbredir/usbredirfilter.h
 create mode 100644 drivers/usb/usbredir/usbredirparser.c
 create mode 100644 drivers/usb/usbredir/usbredirparser.h
 create mode 100644 drivers/usb/usbredir/usbredirproto-compat.h
 create mode 100644 drivers/usb/usbredir/usbredirproto.h

diff --git a/MAINTAINERS b/MAINTAINERS
index d8afd29..738a80d 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -10363,6 +10363,12 @@ S:	Maintained
 F:	drivers/usb/usbip/
 F:	tools/usb/usbip/
 
+USBREDIR IP DRIVER
+M:	Jeremy White <jwhite@xxxxxxxxxxxxxxx>
+L:	linux-usb@xxxxxxxxxxxxxxx
+S:	Maintained
+F:	drivers/usb/usbredir/
+
 USB PEGASUS DRIVER
 M:	Petko Manolov <petkan@xxxxxxxxxxxxx>
 L:	linux-usb@xxxxxxxxxxxxxxx
diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 8ed451d..18940f5 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -94,6 +94,8 @@ source "drivers/usb/image/Kconfig"
 
 source "drivers/usb/usbip/Kconfig"
 
+source "drivers/usb/usbredir/Kconfig"
+
 endif
 
 source "drivers/usb/musb/Kconfig"
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index d8926c6..384fd9f 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -62,3 +62,4 @@ obj-$(CONFIG_USB_GADGET)	+= gadget/
 obj-$(CONFIG_USB_COMMON)	+= common/
 
 obj-$(CONFIG_USBIP_CORE)	+= usbip/
+obj-$(CONFIG_USBREDIR)		+= usbredir/
diff --git a/drivers/usb/usbredir/Kconfig b/drivers/usb/usbredir/Kconfig
new file mode 100644
index 0000000..284fd02
--- /dev/null
+++ b/drivers/usb/usbredir/Kconfig
@@ -0,0 +1,25 @@
+config USBREDIR
+	tristate "USBREDIR support"
+	depends on USB && NET
+	---help---
+	  This enables connecting a remote USB device over IP using
+          the USBREDIR protocol.  This module provides a sysfs attach
+          interface which, if given a socket connected to a remote
+          usbredirserver, will enable the remote device to behave as
+          though it were connected to the system running this module.
+
+          For more information and user space tools, refer to the
+          USBREDIR project, which can be found at
+          http://www.spice-space.org/page/UsbRedir.
+
+	  To compile this as a module, choose M here: the module will
+	  be called usbredir.
+
+	  If unsure, say N.
+
+config USBREDIR_DEBUG
+	bool "Debug messages for USBREDIR"
+	depends on USBREDIR
+	---help---
+	  This enables the debug messages from the USBREDIR drivers.
+
diff --git a/drivers/usb/usbredir/Makefile b/drivers/usb/usbredir/Makefile
new file mode 100644
index 0000000..531ff31
--- /dev/null
+++ b/drivers/usb/usbredir/Makefile
@@ -0,0 +1,4 @@
+ccflags-$(CONFIG_USBREDIR_DEBUG) := -DDEBUG
+
+obj-$(CONFIG_USBREDIR) += usbredir.o
+usbredir-y := main.o sysfs.o hub.o device.o urb.o redir.o tx.o rx.o usbredirparser.o strtok_r.o usbredirfilter.o
diff --git a/drivers/usb/usbredir/README b/drivers/usb/usbredir/README
new file mode 100644
index 0000000..217a2e4
--- /dev/null
+++ b/drivers/usb/usbredir/README
@@ -0,0 +1,20 @@
+USB Redirection Kernel Module
+
+This module allows a Linux system to instatiate USB devices
+that are located on a remote device.  The USB data is transferred
+over a socket using the USBREDIR protocol, which is generally
+used in conjunction with the SPICE project.
+
+You will need the USBREDIR user space tools.  They can
+be found at http://www.spice-space.org/page/UsbRedir.
+
+To use, start the usbredirserver on a remote system.
+For example,
+ ./usbredirserver --port 4000 125f:db8a
+will export my ADATA thumb drive on the remote system.
+
+Next, on the local system, connect a socket and relay that to
+the kernel module.  The connectkernel utility will do this as follows:
+  ./connectkernel adata4000 my.remote.device.com 4000
+
+The device should attach and be usable on the local system.
diff --git a/drivers/usb/usbredir/TODO b/drivers/usb/usbredir/TODO
new file mode 100644
index 0000000..605551a
--- /dev/null
+++ b/drivers/usb/usbredir/TODO
@@ -0,0 +1,12 @@
+TODO:
+  *  Note - during testing, having a device die unexpectedly
+     could go on to cause fairly serious problems.  Need to
+     explore that.
+  *  Still getting sporadic failures
+     - One clue - got an unexpected rc from the write in redir.c
+  *  Hmm.  KFP_ATOMIC on our mallocs may be better than _KERNEL...
+  *  Read and deal with the many TODOs
+  *  Not just hacking the usbredirparser, but proper patches
+     - The filter needs love.  Use strsep, not strtok?
+  *  Expose a sysfs attribute and have udev use it
+  *  Turn on more capabilities and watch it go
diff --git a/drivers/usb/usbredir/device.c b/drivers/usb/usbredir/device.c
new file mode 100644
index 0000000..114bc48
--- /dev/null
+++ b/drivers/usb/usbredir/device.c
@@ -0,0 +1,327 @@
+/*
+ * Copyright (C) 2015 Jeremy White based on work by
+ * Copyright (C) 2003-2008 Takahiro Hirofuchi
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/kthread.h>
+#include <linux/slab.h>
+#include <linux/file.h>
+#include <linux/net.h>
+
+#include "usbredir.h"
+
+void usbredir_device_init(struct usbredir_device *udev, int port,
+			  struct usbredir_hub *hub)
+{
+	memset(udev, 0, sizeof(*udev));
+
+	udev->rhport = port;
+	udev->hub = hub;
+	atomic_set(&udev->active, 0);
+	spin_lock_init(&udev->lock);
+	spin_lock_init(&udev->lists_lock);
+
+	INIT_LIST_HEAD(&udev->urblist_rx);
+	INIT_LIST_HEAD(&udev->urblist_tx);
+	INIT_LIST_HEAD(&udev->unlink_tx);
+	INIT_LIST_HEAD(&udev->unlink_rx);
+
+	init_waitqueue_head(&udev->waitq_tx);
+}
+
+/* Presumes udev->lock is held on entry */
+void usbredir_device_allocate(struct usbredir_device *udev,
+			      const char *devid,
+			      struct socket *socket)
+{
+	char pname[32];
+
+	udev->parser = redir_parser_init(udev);
+	if (!udev->parser) {
+		pr_err("Unable to allocate USBREDIR parser.\n");
+		return;
+	}
+
+	udev->devid  = kstrdup(devid, GFP_ATOMIC);
+	atomic_set(&udev->active, 1);
+	udev->socket = socket;
+
+	udev->port_status = 0;
+
+	/* TODO - safe to hold udev lock through thread creation? */
+	sprintf(pname, "usbredir/rx:%d", udev->rhport);
+	udev->rx = kthread_run(usbredir_rx_loop, udev, pname);
+	sprintf(pname, "usbredir/tx:%d", udev->rhport);
+	udev->tx = kthread_run(usbredir_tx_loop, udev, pname);
+}
+
+void usbredir_device_cleanup_unlink(struct usbredir_device *udev)
+{
+	struct usbredir_unlink *unlink, *tmp;
+
+	spin_lock(&udev->lists_lock);
+	list_for_each_entry_safe(unlink, tmp, &udev->unlink_tx, list) {
+		list_del(&unlink->list);
+		kfree(unlink);
+	}
+
+	list_for_each_entry_safe(unlink, tmp, &udev->unlink_rx, list) {
+		list_del(&unlink->list);
+		kfree(unlink);
+	}
+	spin_unlock(&udev->lists_lock);
+}
+
+void usbredir_device_deallocate(struct usbredir_device *udev,
+				bool stoprx, bool stoptx)
+{
+	pr_debug("%s %d/%d (active %d)\n", __func__, udev->hub->id,
+		 udev->rhport, atomic_read(&udev->active));
+	if (atomic_dec_if_positive(&udev->active) < 0)
+		return;
+
+	/* Release the rx thread */
+	spin_lock(&udev->lock);
+	if (udev->socket)
+		kernel_sock_shutdown(udev->socket, SHUT_RDWR);
+	spin_unlock(&udev->lock);
+
+	/* Release the tx thread */
+	wake_up_interruptible(&udev->waitq_tx);
+
+	/* The key is that kthread_stop waits until that thread has exited,
+	 *   so we don't clean up resources still in use */
+	if (stoprx && udev->rx)
+		kthread_stop(udev->rx);
+
+	if (stoptx && udev->tx)
+		kthread_stop(udev->tx);
+
+	spin_lock(&udev->lock);
+
+	udev->rx = NULL;
+	udev->tx = NULL;
+
+	if (udev->socket) {
+		sockfd_put(udev->socket);
+		udev->socket = NULL;
+	}
+
+	usb_put_dev(udev->usb_dev);
+	udev->usb_dev = NULL;
+
+	kfree(udev->devid);
+	udev->devid = NULL;
+
+	if (udev->parser) {
+		usbredirparser_destroy(udev->parser);
+		udev->parser = NULL;
+	}
+
+	usbredir_device_cleanup_unlink(udev);
+	usbredir_urb_cleanup_urblists(udev);
+
+	spin_unlock(&udev->lock);
+}
+
+static u32 speed_to_portflag(enum usb_device_speed speed)
+{
+	switch (speed) {
+	case usb_redir_speed_low:   return USB_PORT_STAT_LOW_SPEED;
+	case usb_redir_speed_high:  return USB_PORT_STAT_HIGH_SPEED;
+
+	case usb_redir_speed_full:
+	case usb_redir_speed_super:
+	default:		    return 0;
+	}
+}
+
+/* TODO - no thought at all to Super speed stuff... */
+void usbredir_device_connect(struct usbredir_device *udev)
+{
+	spin_lock(&udev->lock);
+	pr_debug("%s %d/%d:%s\n", __func__,
+		 udev->hub->id, udev->rhport, udev->devid);
+	udev->port_status |= USB_PORT_STAT_CONNECTION |
+			    (1 << USB_PORT_FEAT_C_CONNECTION);
+	udev->port_status |= speed_to_portflag(udev->connect_header.speed);
+	spin_unlock(&udev->lock);
+
+	usb_hcd_poll_rh_status(udev->hub->hcd);
+}
+
+void usbredir_device_disconnect(struct usbredir_device *udev)
+{
+	spin_lock(&udev->lock);
+	pr_debug("%s %d/%d:%s\n", __func__,
+		 udev->hub->id, udev->rhport, udev->devid);
+	udev->port_status  &= ~USB_PORT_STAT_CONNECTION;
+	udev->port_status  |= (1 << USB_PORT_FEAT_C_CONNECTION);
+	spin_unlock(&udev->lock);
+
+	usb_hcd_poll_rh_status(udev->hub->hcd);
+}
+
+
+
+static struct usbredir_device *usbredir_device_get(struct usbredir_hub *hub,
+						 int rhport)
+{
+	struct usbredir_device *udev;
+
+	if (rhport < 0 || rhport >= hub->device_count) {
+		pr_err("invalid port number %d\n", rhport);
+		return NULL;
+	}
+	udev = hub->devices + rhport;
+
+	spin_lock(&hub->lock);
+	spin_lock(&udev->lock);
+	return udev;
+}
+
+static void usbredir_device_put(struct usbredir_device *udev)
+{
+	spin_unlock(&udev->lock);
+	spin_unlock(&udev->hub->lock);
+}
+
+int usbredir_device_clear_port_feature(struct usbredir_hub *hub,
+			       int rhport, u16 wValue)
+{
+	struct usbredir_device *udev = usbredir_device_get(hub, rhport);
+
+	if (!udev)
+		return -ENODEV;
+
+	switch (wValue) {
+	case USB_PORT_FEAT_SUSPEND:
+		pr_debug(" ClearPortFeature: USB_PORT_FEAT_SUSPEND\n");
+		if (udev->port_status & USB_PORT_STAT_SUSPEND) {
+			/* 20msec signaling */
+			/* TODO - see note on suspend/resume below */
+			hub->resuming = 1;
+			hub->re_timeout =
+				jiffies + msecs_to_jiffies(20);
+		}
+		break;
+	case USB_PORT_FEAT_POWER:
+		pr_debug(" ClearPortFeature: USB_PORT_FEAT_POWER\n");
+		udev->port_status = 0;
+		hub->resuming = 0;
+		break;
+	case USB_PORT_FEAT_C_RESET:
+		pr_debug(" ClearPortFeature: USB_PORT_FEAT_C_RESET\n");
+		/* TODO - USB 3.0 stuff as well? */
+		switch (udev->connect_header.speed) {
+		case usb_redir_speed_high:
+			udev->port_status |= USB_PORT_STAT_HIGH_SPEED;
+			break;
+		case usb_redir_speed_low:
+			udev->port_status |= USB_PORT_STAT_LOW_SPEED;
+			break;
+		default:
+			break;
+		}
+	default:
+		pr_debug(" ClearPortFeature: default %x\n", wValue);
+		udev->port_status &= ~(1 << wValue);
+		break;
+	}
+
+	usbredir_device_put(udev);
+
+	return 0;
+}
+
+int usbredir_device_port_status(struct usbredir_hub *hub, int rhport, char *buf)
+{
+	struct usbredir_device *udev = usbredir_device_get(hub, rhport);
+
+	if (!udev)
+		return -ENODEV;
+
+	pr_debug("%s %d/%d 0x%x\n", __func__,
+		 udev->hub->id, rhport, udev->port_status);
+
+	/* TODO - the logic on resume/reset etc is really
+	 *   just blindly copied from USBIP.  Make sure
+	 *   this eventually gets thoughtful review and testing. */
+
+	/* whoever resets or resumes must GetPortStatus to
+	 * complete it!!
+	 */
+	if (hub->resuming && time_after(jiffies, hub->re_timeout)) {
+		udev->port_status |= (1 << USB_PORT_FEAT_C_SUSPEND);
+		udev->port_status &= ~(1 << USB_PORT_FEAT_SUSPEND);
+		hub->resuming = 0;
+		hub->re_timeout = 0;
+	}
+
+	if ((udev->port_status & (1 << USB_PORT_FEAT_RESET)) &&
+	     time_after(jiffies, hub->re_timeout)) {
+		udev->port_status |= (1 << USB_PORT_FEAT_C_RESET);
+		udev->port_status &= ~(1 << USB_PORT_FEAT_RESET);
+		hub->re_timeout = 0;
+
+		if (atomic_read(&udev->active)) {
+			pr_debug(" enable rhport %d\n", rhport);
+			udev->port_status |= USB_PORT_STAT_ENABLE;
+		}
+	}
+
+	((__le16 *) buf)[0] = cpu_to_le16(udev->port_status);
+	((__le16 *) buf)[1] =
+		cpu_to_le16(udev->port_status >> 16);
+
+	pr_debug(" GetPortStatus bye %x %x\n", ((u16 *)buf)[0],
+			  ((u16 *)buf)[1]);
+
+	usbredir_device_put(udev);
+
+	return 0;
+}
+
+int usbredir_device_set_port_feature(struct usbredir_hub *hub,
+			       int rhport, u16 wValue)
+{
+	struct usbredir_device *udev = usbredir_device_get(hub, rhport);
+
+	if (!udev)
+		return -ENODEV;
+
+	switch (wValue) {
+	case USB_PORT_FEAT_SUSPEND:
+		pr_debug(" SetPortFeature: USB_PORT_FEAT_SUSPEND\n");
+		break;
+	case USB_PORT_FEAT_RESET:
+		pr_debug(" SetPortFeature: USB_PORT_FEAT_RESET\n");
+		udev->port_status &= ~USB_PORT_STAT_ENABLE;
+
+		/* 50msec reset signaling */
+		/* TODO - why?  Seems like matching core/hub.c
+		 *	SHORT_RESET_TIME would be better */
+		hub->re_timeout = jiffies + msecs_to_jiffies(50);
+
+		/* FALLTHROUGH */
+	default:
+		pr_debug(" SetPortFeature: default %d\n", wValue);
+		udev->port_status |= (1 << wValue);
+		break;
+	}
+
+	usbredir_device_put(udev);
+
+	return 0;
+}
diff --git a/drivers/usb/usbredir/hub.c b/drivers/usb/usbredir/hub.c
new file mode 100644
index 0000000..f6eeb20
--- /dev/null
+++ b/drivers/usb/usbredir/hub.c
@@ -0,0 +1,489 @@
+/*
+ * Copyright (C) 2015 Jeremy White based on work by
+ * Copyright (C) 2003-2008 Takahiro Hirofuchi
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+#include <linux/kthread.h>
+
+#include "usbredir.h"
+
+static spinlock_t hubs_lock;
+static struct list_head hubs;
+static atomic_t hub_count;
+
+static int usbredir_hcd_start(struct usb_hcd *hcd)
+{
+	struct usbredir_hub *hub = usbredir_hub_from_hcd(hcd);
+	int i;
+
+	spin_lock(&hub->lock);
+	pr_debug("%s %d\n", __func__, hub->id);
+
+	hub->device_count = devices_per_hub;
+	hub->devices = kcalloc(hub->device_count, sizeof(*hub->devices),
+			       GFP_ATOMIC);
+	if (!hub->devices) {
+		spin_unlock(&hub->lock);
+		return -ENOMEM;
+	}
+
+	for (i = 0; i < hub->device_count; i++)
+		usbredir_device_init(hub->devices + i, i, hub);
+
+	hcd->power_budget = 0; /* no limit */
+	hcd->uses_new_polling = 1;
+	atomic_set(&hub->aseqnum, 0);
+	spin_unlock(&hub->lock);
+
+	return 0;
+}
+
+static void usbredir_hub_stop(struct usbredir_hub *hub)
+{
+	int i;
+
+	pr_debug("%s %d\n", __func__, hub->id);
+
+	for (i = 0; i < hub->device_count && hub->devices; i++) {
+		usbredir_device_disconnect(hub->devices + i);
+		usbredir_device_deallocate(hub->devices + i, true, true);
+	}
+
+	spin_lock(&hub->lock);
+	kfree(hub->devices);
+	hub->devices = NULL;
+	hub->device_count = 0;
+	spin_unlock(&hub->lock);
+}
+
+static void usbredir_hcd_stop(struct usb_hcd *hcd)
+{
+	usbredir_hub_stop(usbredir_hub_from_hcd(hcd));
+}
+
+static int usbredir_get_frame_number(struct usb_hcd *hcd)
+{
+	pr_err("TODO: get_frame_number: not implemented\n");
+	return 0;
+}
+
+static int usbredir_hub_status(struct usb_hcd *hcd, char *buf)
+{
+	struct usbredir_hub *hub = usbredir_hub_from_hcd(hcd);
+	int		ret;
+	int		rhport;
+	int		changed = 0;
+
+	spin_lock(&hub->lock);
+
+	pr_debug("%s %d\n", __func__, hub->id);
+
+	ret = DIV_ROUND_UP(hub->device_count + 1, 8);
+	memset(buf, 0, ret);
+
+	if (!HCD_HW_ACCESSIBLE(hcd)) {
+		pr_debug("hw accessible flag not on?\n");
+		spin_unlock(&hub->lock);
+		return 0;
+	}
+
+	/* check pseudo status register for each port */
+	for (rhport = 0; rhport < hub->device_count; rhport++) {
+		struct usbredir_device *udev = hub->devices + rhport;
+
+		spin_lock(&udev->lock);
+		if (udev->port_status &
+			((USB_PORT_STAT_C_CONNECTION
+			  | USB_PORT_STAT_C_ENABLE
+			  | USB_PORT_STAT_C_SUSPEND
+			  | USB_PORT_STAT_C_OVERCURRENT
+			  | USB_PORT_STAT_C_RESET) << 16)) {
+
+			/* The status of a port has been changed, */
+			pr_debug("port %d status changed\n", rhport);
+
+			buf[(rhport + 1) / 8] |= 1 << (rhport + 1) % 8;
+			changed = 1;
+		}
+		spin_unlock(&udev->lock);
+	}
+
+	spin_unlock(&hub->lock);
+
+	if ((hcd->state == HC_STATE_SUSPENDED) && (changed == 1))
+		usb_hcd_resume_root_hub(hcd);
+
+	pr_debug("%s %schanged\n", __func__, changed ? "" : "un");
+
+	return changed ? ret : 0;
+}
+
+static inline void usbredir_hub_descriptor(struct usbredir_hub *hub,
+					   struct usb_hub_descriptor *desc)
+{
+	memset(desc, 0, sizeof(*desc));
+/* TODO - where do these magic numbers come from? */
+	desc->bDescriptorType = 0x29;
+	desc->bDescLength = 9;
+	desc->wHubCharacteristics = cpu_to_le16(
+		HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM);
+	desc->bNbrPorts = hub->device_count;
+	desc->u.hs.DeviceRemovable[0] = 0xff;
+	desc->u.hs.DeviceRemovable[1] = 0xff;
+}
+
+static int usbredir_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+			    u16 wIndex, char *buf, u16 wLength)
+{
+	struct usbredir_hub *hub;
+	int             ret = 0;
+	int		rhport;
+
+	if (!HCD_HW_ACCESSIBLE(hcd))
+		return -ETIMEDOUT;
+
+	hub = usbredir_hub_from_hcd(hcd);
+
+	pr_debug("%s hub %d: ", __func__, hub->id);
+	pr_debug("[wValue %x|wIndex%u|wLength %u]",
+		 wValue, wIndex, wLength);
+
+	/* wIndex is 1 based */
+	rhport = ((__u8)(wIndex & 0x00ff)) - 1;
+
+	switch (typeReq) {
+	case ClearHubFeature:
+		pr_debug(" ClearHubFeature\n");
+		break;
+	case SetHubFeature:
+		pr_debug(" SetHubFeature\n");
+		ret = -EPIPE;
+		break;
+	case GetHubDescriptor:
+		pr_debug(" GetHubDescriptor\n");
+		usbredir_hub_descriptor(hub, (struct usb_hub_descriptor *) buf);
+		break;
+	case GetHubStatus:
+		pr_debug(" GetHubStatus\n");
+		*(__le32 *) buf = cpu_to_le32(0);
+		break;
+	case ClearPortFeature:
+		pr_debug(" ClearPortFeature\n");
+		return usbredir_device_clear_port_feature(hub, rhport, wValue);
+	case SetPortFeature:
+		pr_debug(" SetPortFeature\n");
+		return usbredir_device_set_port_feature(hub, rhport, wValue);
+	case GetPortStatus:
+		pr_debug(" GetPortStatus\n");
+		return usbredir_device_port_status(hub, rhport, buf);
+	default:
+		pr_debug(" unknown type %x\n", typeReq);
+		pr_err("usbredir_hub_control: no handler for request %x\n",
+		       typeReq);
+
+		/* "protocol stall" on error */
+		ret = -EPIPE;
+	}
+	return ret;
+}
+
+#ifdef CONFIG_PM
+/* FIXME: suspend/resume */
+static int usbredir_bus_suspend(struct usb_hcd *hcd)
+{
+	dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
+
+	hcd->state = HC_STATE_SUSPENDED;
+
+	return 0;
+}
+
+static int usbredir_bus_resume(struct usb_hcd *hcd)
+{
+	int rc = 0;
+
+	dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
+
+	if (!HCD_HW_ACCESSIBLE(hcd))
+		rc = -ESHUTDOWN;
+	else
+		hcd->state = HC_STATE_RUNNING;
+	return rc;
+}
+#else
+
+#define usbredir_bus_suspend      NULL
+#define usbredir_bus_resume       NULL
+#endif
+
+
+static void usbredir_release_hub_dev(struct device *dev)
+{
+	/* TODO - what do we need to implement here? */
+	pr_err("%s: not implemented\n", __func__);
+}
+
+static int usbredir_register_hub(struct usbredir_hub *hub)
+{
+	int ret;
+
+	hub->pdev.name = driver_name;
+	hub->pdev.id = hub->id;
+	hub->pdev.dev.release = usbredir_release_hub_dev;
+
+	ret = platform_device_register(&hub->pdev);
+	if (ret) {
+		pr_err("Unable to register platform device %d\n", hub->id);
+		return ret;
+	}
+
+	return 0;
+}
+
+static void usbredir_unregister_hub(struct usbredir_hub *hub)
+{
+	platform_device_unregister(&hub->pdev);
+}
+
+
+static struct hc_driver usbredir_hc_driver = {
+	.description	= driver_name,
+	.product_desc	= driver_desc,
+	.hcd_priv_size	= sizeof(struct usbredir_hub *),
+
+	/* TODO = what other flags are available and what of USB3? */
+	.flags		= HCD_USB2,
+
+	.start		= usbredir_hcd_start,
+	.stop		= usbredir_hcd_stop,
+
+	.urb_enqueue	= usbredir_urb_enqueue,
+	.urb_dequeue	= usbredir_urb_dequeue,
+
+	.get_frame_number = usbredir_get_frame_number,
+
+	.hub_status_data = usbredir_hub_status,
+	.hub_control    = usbredir_hub_control,
+	.bus_suspend	= usbredir_bus_suspend,
+	.bus_resume	= usbredir_bus_resume,
+};
+
+
+static int usbredir_create_hcd(struct usbredir_hub *hub)
+{
+	int ret;
+
+	hub->hcd = usb_create_hcd(&usbredir_hc_driver, &hub->pdev.dev,
+			     dev_name(&hub->pdev.dev));
+	if (!hub->hcd) {
+		pr_err("usb_create_hcd failed\n");
+		return -ENOMEM;
+	}
+
+	/* TODO - review if we want to has_tt, and anything like it... */
+	hub->hcd->has_tt = 1;
+
+	/* TODO - no one else stores a pointer
+	*        may want to rethink the structure.
+	*        Question:  do we really need to create the pdev first? */
+	*((struct usbredir_hub **) hub->hcd->hcd_priv) = hub;
+
+	ret = usb_add_hcd(hub->hcd, 0, 0);
+	if (ret != 0) {
+		pr_err("usb_add_hcd failed %d\n", ret);
+		usb_put_hcd(hub->hcd);
+		return ret;
+	}
+
+	return 0;
+}
+
+static void usbredir_destroy_hcd(struct usbredir_hub *hub)
+{
+	if (hub->hcd) {
+		usb_remove_hcd(hub->hcd);
+		usb_put_hcd(hub->hcd);
+	}
+	hub->hcd = NULL;
+}
+
+struct usbredir_hub *usbredir_hub_create(void)
+{
+	struct usbredir_hub *hub;
+	int id = atomic_inc_return(&hub_count);
+
+	if (id > max_hubs)
+		goto dec_exit;
+
+	hub = kzalloc(sizeof(*hub), GFP_ATOMIC);
+	if (!hub)
+		goto dec_exit;
+	hub->id = id - 1;
+
+	if (usbredir_register_hub(hub)) {
+		kfree(hub);
+		goto dec_exit;
+	}
+
+	if (usbredir_create_hcd(hub)) {
+		usbredir_unregister_hub(hub);
+		kfree(hub);
+		goto dec_exit;
+	}
+
+	spin_lock(&hubs_lock);
+	list_add_tail(&hub->list, &hubs);
+	spin_unlock(&hubs_lock);
+	return hub;
+dec_exit:
+	atomic_dec(&hub_count);
+	return NULL;
+}
+
+void usbredir_hub_destroy(struct usbredir_hub *hub)
+{
+	usbredir_hub_stop(hub);
+	usbredir_destroy_hcd(hub);
+	usbredir_unregister_hub(hub);
+}
+
+struct usbredir_device *usbredir_hub_find_device(const char *devid)
+{
+	struct usbredir_device *ret = NULL;
+	struct usbredir_hub *hub;
+	int i;
+
+	spin_lock(&hubs_lock);
+	list_for_each_entry(hub, &hubs, list) {
+		spin_lock(&hub->lock);
+		for (i = 0; i < hub->device_count; i++) {
+			struct usbredir_device *udev = hub->devices + i;
+
+			spin_lock(&udev->lock);
+			if (atomic_read(&udev->active) &&
+			    udev->devid &&
+			    strcmp(udev->devid, devid) == 0)
+				ret = udev;
+			spin_unlock(&udev->lock);
+			if (ret)
+				break;
+		}
+		spin_unlock(&hub->lock);
+		if (ret)
+			break;
+	}
+	spin_unlock(&hubs_lock);
+	return ret;
+}
+
+struct usbredir_device *usbredir_hub_allocate_device(const char *devid,
+						     struct socket *socket)
+{
+	int found = 0;
+	struct usbredir_hub *hub;
+	struct usbredir_device *udev;
+	int i;
+
+	spin_lock(&hubs_lock);
+	list_for_each_entry(hub, &hubs, list) {
+		spin_lock(&hub->lock);
+		for (i = 0; i < hub->device_count; i++) {
+			udev = hub->devices + i;
+			spin_lock(&udev->lock);
+			if (!atomic_read(&udev->active)) {
+				found++;
+				/* Note: lock is *held* */
+				break;
+			}
+			spin_unlock(&udev->lock);
+		}
+		spin_unlock(&hub->lock);
+		if (found)
+			break;
+	}
+	spin_unlock(&hubs_lock);
+
+	if (!found) {
+		hub = usbredir_hub_create();
+		if (!hub)
+			return NULL;
+
+		return usbredir_hub_allocate_device(devid, socket);
+	}
+
+	usbredir_device_allocate(udev, devid, socket);
+
+	spin_unlock(&udev->lock);
+
+	return udev;
+}
+
+int usbredir_hub_show_global_status(char *out)
+{
+	int count = 0;
+	int active = 0;
+	int used = 0;
+
+	struct usbredir_hub *hub;
+	struct usbredir_device *udev;
+	int i;
+
+	spin_lock(&hubs_lock);
+	list_for_each_entry(hub, &hubs, list) {
+		spin_lock(&hub->lock);
+		for (i = 0; i < hub->device_count; count++, i++) {
+			udev = hub->devices + i;
+			spin_lock(&udev->lock);
+			active += atomic_read(&udev->active);
+			if (udev->usb_dev)
+				used++;
+			spin_unlock(&udev->lock);
+		}
+		spin_unlock(&hub->lock);
+	}
+	spin_unlock(&hubs_lock);
+
+	sprintf(out, "%d/%d hubs. %d/%d devices (%d active, %d used).\n",
+			atomic_read(&hub_count), max_hubs,
+			count, max_hubs * devices_per_hub, active, used);
+
+	return strlen(out);
+}
+
+
+int usbredir_hub_init(void)
+{
+	INIT_LIST_HEAD(&hubs);
+	atomic_set(&hub_count, 0);
+	spin_lock_init(&hubs_lock);
+
+	return 0;
+}
+
+void usbredir_hub_exit(void)
+{
+	struct usbredir_hub *hub, *tmp;
+
+	spin_lock(&hubs_lock);
+	list_for_each_entry_safe(hub, tmp, &hubs, list) {
+		usbredir_hub_destroy(hub);
+		list_del(&hub->list);
+		kfree(hub);
+	}
+	spin_unlock(&hubs_lock);
+}
diff --git a/drivers/usb/usbredir/main.c b/drivers/usb/usbredir/main.c
new file mode 100644
index 0000000..b63e6c6
--- /dev/null
+++ b/drivers/usb/usbredir/main.c
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2015 Jeremy White
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/usb.h>
+#include <linux/module.h>
+
+#include "usbredir.h"
+
+#define DRIVER_NAME	"usbredir"
+#define DRIVER_AUTHOR	"Jeremy White"
+#define DRIVER_DESC	"USBREDIR Host Controller Driver"
+#define DRIVER_VERSION	USBREDIR_MODULE_VERSION
+
+const char driver_name[] = DRIVER_NAME;
+const char driver_desc[] = DRIVER_DESC;
+
+
+static struct platform_driver usbredir_driver = {
+	.driver	= {
+		.name = driver_name,
+	},
+};
+
+static int __init usbredir_main_init(void)
+{
+	int ret;
+
+	pr_debug("usbredir loaded\n");
+
+	if (usb_disabled())
+		return -ENODEV;
+
+	if (devices_per_hub > USB_MAXCHILDREN) {
+		pr_err("Error:  cannot use %d devices per hub; max %d\n",
+		       devices_per_hub, USB_MAXCHILDREN);
+		return -ENODEV;
+	}
+
+
+	ret = platform_driver_register(&usbredir_driver);
+	if (ret) {
+		pr_err("Unable to register usbredir_driver.\n");
+		return ret;
+	}
+
+	ret = usbredir_hub_init();
+	if (ret) {
+		platform_driver_unregister(&usbredir_driver);
+		return ret;
+	}
+
+	ret = usbredir_sysfs_register(&usbredir_driver.driver);
+	if (ret) {
+		pr_err("Unable to create sysfs files for usbredir driver.\n");
+		usbredir_hub_exit();
+		platform_driver_unregister(&usbredir_driver);
+		return ret;
+	}
+
+	return ret;
+}
+
+static void __exit usbredir_main_exit(void)
+{
+	usbredir_sysfs_unregister(&usbredir_driver.driver);
+	usbredir_hub_exit();
+	platform_driver_unregister(&usbredir_driver);
+	pr_debug("usbredir exited\n");
+}
+
+unsigned int max_hubs = 64;
+module_param(max_hubs, uint, S_IRUSR|S_IWUSR);
+MODULE_PARM_DESC(max_hubs, "Maximum number of USB hubs to create; default 64");
+
+unsigned int devices_per_hub = 16;
+module_param(devices_per_hub, uint, S_IRUSR|S_IWUSR);
+MODULE_PARM_DESC(devices_per_hub,
+		"Maximum number of devices per hub; default 16");
+
+module_init(usbredir_main_init);
+module_exit(usbredir_main_exit);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRIVER_VERSION);
diff --git a/drivers/usb/usbredir/redir.c b/drivers/usb/usbredir/redir.c
new file mode 100644
index 0000000..33d9475
--- /dev/null
+++ b/drivers/usb/usbredir/redir.c
@@ -0,0 +1,535 @@
+/*
+ * Copyright (C) 2015 Jeremy White
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+
+#include <linux/net.h>
+#include <linux/kthread.h>
+#include <net/sock.h>
+#include <linux/semaphore.h>
+#include <linux/slab.h>
+#include <linux/printk.h>
+
+#include "usbredirparser.h"
+#include "usbredir.h"
+
+
+#define TODO_IMPLEMENT pr_err("Error: %s unimplemented.\n", __func__)
+
+static void redir_log(void *priv, int level, const char *msg)
+{
+	switch (level) {
+	case usbredirparser_error:
+		pr_err("%s", msg);
+		break;
+
+	case usbredirparser_warning:
+		pr_warn("%s", msg);
+		break;
+
+	case usbredirparser_info:
+		pr_info("%s", msg);
+		break;
+
+	default:
+		pr_debug("%s", msg);
+		break;
+	}
+}
+
+static int redir_read(void *priv, uint8_t *data, int count)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+	struct msghdr msg;
+	struct kvec iov;
+	struct socket *socket;
+	int rc;
+
+	if (kthread_should_stop() || !atomic_read(&udev->active))
+		return -ESRCH;
+
+	spin_lock(&udev->lock);
+	socket = udev->socket;
+	/* TODO - reference/dereference the socket? */
+	spin_unlock(&udev->lock);
+
+	socket->sk->sk_allocation = GFP_NOIO;
+	iov.iov_base    = data;
+	iov.iov_len     = count;
+	msg.msg_name    = NULL;
+	msg.msg_namelen = 0;
+	msg.msg_control = NULL;
+	msg.msg_controllen = 0;
+	msg.msg_flags = MSG_NOSIGNAL;
+
+	rc = kernel_recvmsg(socket, &msg, &iov, 1, count, MSG_WAITALL);
+
+	return rc;
+}
+
+static int redir_write(void *priv, uint8_t *data, int count)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+	struct msghdr msg;
+	struct kvec iov;
+	int rc;
+	struct socket *socket;
+
+	memset(&msg, 0, sizeof(msg));
+	memset(&iov, 0, sizeof(iov));
+	msg.msg_flags = MSG_NOSIGNAL | MSG_DONTWAIT;
+	iov.iov_base = data;
+	iov.iov_len  = count;
+
+	spin_lock(&udev->lock);
+	socket = udev->socket;
+	spin_unlock(&udev->lock);
+
+	rc = kernel_sendmsg(socket, &msg, &iov, 1, count);
+	/* TODO - In theory, a return of 0 should be okay,
+	 *        but, again, in theory, it will cause an error. */
+	if (rc <= 0)
+		pr_err("Error: TODO - unexpected write return code %d.\n", rc);
+
+	return rc;
+}
+
+
+/* Locking functions for use by multithread apps */
+static void *redir_alloc_lock(void)
+{
+	struct semaphore *s = kmalloc(sizeof(*s), GFP_KERNEL);
+
+	sema_init(s, 1);
+	return s;
+}
+
+static void redir_lock(void *lock)
+{
+	while (down_interruptible((struct semaphore *) lock))
+		;
+}
+
+static void redir_unlock(void *lock)
+{
+	up((struct semaphore *) lock);
+}
+
+static void redir_free_lock(void *lock)
+{
+	kfree(lock);
+}
+
+
+/* The below callbacks are called when a complete packet of the relevant
+   type has been received.
+
+   Note that the passed in packet-type-specific-header's lifetime is only
+   guarenteed to be that of the callback.
+
+*/
+static void redir_hello(void *priv, struct usb_redir_hello_header *hello)
+{
+	pr_debug("Hello!\n");
+}
+
+static void redir_device_connect(void *priv,
+	struct usb_redir_device_connect_header *device_connect)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+
+	pr_debug("  connect: class %2d subclass %2d protocol %2d",
+		device_connect->device_class, device_connect->device_subclass,
+		device_connect->device_protocol);
+	pr_debug("  vendor 0x%04x product %04x\n",
+		device_connect->vendor_id, device_connect->product_id);
+
+	spin_lock(&udev->lock);
+	udev->connect_header = *device_connect;
+	spin_unlock(&udev->lock);
+
+	usbredir_device_connect(udev);
+}
+
+static void redir_device_disconnect(void *priv)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_reset(void *priv)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_interface_info(void *priv,
+	struct usb_redir_interface_info_header *info)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+	int i;
+
+	for (i = 0; i < info->interface_count; i++) {
+		pr_debug("interface %d class %2d subclass %2d protocol %2d",
+			info->interface[i], info->interface_class[i],
+			info->interface_subclass[i],
+			info->interface_protocol[i]);
+	}
+
+	spin_lock(&udev->lock);
+	udev->info_header = *info;
+	spin_unlock(&udev->lock);
+}
+
+static void redir_ep_info(void *priv,
+	struct usb_redir_ep_info_header *ep_info)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+
+	spin_lock(&udev->lock);
+	udev->ep_info_header = *ep_info;
+	spin_unlock(&udev->lock);
+}
+
+static void redir_set_configuration(void *priv,
+	uint64_t id,
+	struct usb_redir_set_configuration_header *set_configuration)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_get_configuration(void *priv, uint64_t id)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_configuration_status(void *priv,
+	uint64_t id,
+	struct usb_redir_configuration_status_header *configuration_status)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_set_alt_setting(void *priv,
+	uint64_t id,
+	struct usb_redir_set_alt_setting_header *set_alt_setting)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_get_alt_setting(void *priv,
+	uint64_t id,
+	struct usb_redir_get_alt_setting_header *get_alt_setting)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_alt_setting_status(void *priv,
+	uint64_t id,
+	struct usb_redir_alt_setting_status_header *alt_setting_status)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_start_iso_stream(void *priv,
+	uint64_t id,
+	struct usb_redir_start_iso_stream_header *start_iso_stream)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_stop_iso_stream(void *priv,
+	uint64_t id,
+	struct usb_redir_stop_iso_stream_header *stop_iso_stream)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_iso_stream_status(void *priv,
+	uint64_t id,
+	struct usb_redir_iso_stream_status_header *iso_stream_status)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_start_interrupt_receiving(void *priv,
+	uint64_t id,
+	struct usb_redir_start_interrupt_receiving_header
+		*start_interrupt_receiving)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_stop_interrupt_receiving(void *priv,
+	uint64_t id,
+	struct usb_redir_stop_interrupt_receiving_header
+		*stop_interrupt_receiving)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_interrupt_receiving_status(void *priv,
+	uint64_t id,
+	struct usb_redir_interrupt_receiving_status_header
+		*interrupt_receiving_status)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_alloc_bulk_streams(void *priv,
+	uint64_t id,
+	struct usb_redir_alloc_bulk_streams_header *alloc_bulk_streams)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_free_bulk_streams(void *priv,
+	uint64_t id,
+	struct usb_redir_free_bulk_streams_header *free_bulk_streams)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_bulk_streams_status(void *priv,
+	uint64_t id,
+	struct usb_redir_bulk_streams_status_header *bulk_streams_status)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_cancel_data_packet(void *priv, uint64_t id)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_filter_reject(void *priv)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_filter_filter(void *priv,
+	struct usbredirfilter_rule *rules, int rules_count)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_device_disconnect_ack(void *priv)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_start_bulk_receiving(void *priv,
+	uint64_t id,
+	struct usb_redir_start_bulk_receiving_header *start_bulk_receiving)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_stop_bulk_receiving(void *priv,
+	uint64_t id,
+	struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_bulk_receiving_status(void *priv,
+	uint64_t id,
+	struct usb_redir_bulk_receiving_status_header *bulk_receiving_status)
+{
+	TODO_IMPLEMENT;
+}
+
+static int redir_map_status(int redir_status)
+{
+	switch (redir_status) {
+	case usb_redir_success:
+		return 0;
+	case usb_redir_cancelled:
+		return -ENOENT;
+	case usb_redir_inval:
+		return -EINVAL;
+	case usb_redir_stall:
+		return -EPIPE;
+	case usb_redir_timeout:
+		return -ETIMEDOUT;
+	case usb_redir_babble:
+		return -EOVERFLOW;
+		/* Catchall error condition */
+	case usb_redir_ioerror:
+	default:
+		return -ENODEV;
+	}
+}
+
+
+static void redir_control_packet(void *priv,
+	uint64_t id,
+	struct usb_redir_control_packet_header *control_header,
+	uint8_t *data, int data_len)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+	struct urb *urb;
+
+	urb = usbredir_pop_rx_urb(udev, id);
+	if (!urb) {
+		pr_err("Error: control id %lu with no matching entry.\n",
+		       (unsigned long) id);
+		return;
+	}
+
+	/* TODO - handle more than this flavor... */
+	urb->status = redir_map_status(control_header->status);
+	if (usb_pipein(urb->pipe)) {
+		urb->actual_length = min_t(u32, data_len,
+					 urb->transfer_buffer_length);
+		if (urb->transfer_buffer)
+			memcpy(urb->transfer_buffer, data, urb->actual_length);
+	} else {
+		urb->actual_length = control_header->length;
+	}
+
+	usb_hcd_unlink_urb_from_ep(udev->hub->hcd, urb);
+	usb_hcd_giveback_urb(udev->hub->hcd, urb, urb->status);
+}
+
+static void redir_bulk_packet(void *priv,
+	uint64_t id,
+	struct usb_redir_bulk_packet_header *bulk_header,
+	uint8_t *data, int data_len)
+{
+	struct usbredir_device *udev = (struct usbredir_device *) priv;
+	struct urb *urb;
+
+	urb = usbredir_pop_rx_urb(udev, id);
+	if (!urb) {
+		pr_err("Error: bulk id %lu with no matching entry.\n",
+		       (unsigned long) id);
+		return;
+	}
+
+	urb->status = redir_map_status(bulk_header->status);
+	if (usb_pipein(urb->pipe)) {
+		urb->actual_length = min_t(u32, data_len,
+					 urb->transfer_buffer_length);
+		if (urb->transfer_buffer)
+			memcpy(urb->transfer_buffer, data, urb->actual_length);
+	} else {
+		urb->actual_length = bulk_header->length;
+	}
+
+	/* TODO - what to do with stream_id */
+	/* TODO - handle more than this flavor... */
+
+	usb_hcd_unlink_urb_from_ep(udev->hub->hcd, urb);
+	usb_hcd_giveback_urb(udev->hub->hcd, urb, urb->status);
+}
+
+static void redir_iso_packet(void *priv,
+	uint64_t id,
+	struct usb_redir_iso_packet_header *iso_header,
+	uint8_t *data, int data_len)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_interrupt_packet(void *priv,
+	uint64_t id,
+	struct usb_redir_interrupt_packet_header *interrupt_header,
+	uint8_t *data, int data_len)
+{
+	TODO_IMPLEMENT;
+}
+
+static void redir_buffered_bulk_packet(void *priv, uint64_t id,
+	struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+	uint8_t *data, int data_len)
+{
+	TODO_IMPLEMENT;
+}
+
+
+struct usbredirparser *redir_parser_init(void *priv)
+{
+	struct usbredirparser *parser;
+	char version[40];
+
+	uint32_t caps[USB_REDIR_CAPS_SIZE];
+
+	parser = usbredirparser_create();
+
+	parser->priv = priv;
+
+	parser->log_func = redir_log;
+	parser->read_func = redir_read;
+	parser->write_func = redir_write;
+	parser->device_connect_func = redir_device_connect;
+	parser->device_disconnect_func = redir_device_disconnect;
+	parser->reset_func = redir_reset;
+	parser->interface_info_func = redir_interface_info;
+	parser->ep_info_func = redir_ep_info;
+	parser->set_configuration_func = redir_set_configuration;
+	parser->get_configuration_func = redir_get_configuration;
+	parser->configuration_status_func = redir_configuration_status;
+	parser->set_alt_setting_func = redir_set_alt_setting;
+	parser->get_alt_setting_func = redir_get_alt_setting;
+	parser->alt_setting_status_func = redir_alt_setting_status;
+	parser->start_iso_stream_func = redir_start_iso_stream;
+	parser->stop_iso_stream_func = redir_stop_iso_stream;
+	parser->iso_stream_status_func = redir_iso_stream_status;
+	parser->start_interrupt_receiving_func =
+		redir_start_interrupt_receiving;
+	parser->stop_interrupt_receiving_func = redir_stop_interrupt_receiving;
+	parser->interrupt_receiving_status_func =
+		redir_interrupt_receiving_status;
+	parser->alloc_bulk_streams_func = redir_alloc_bulk_streams;
+	parser->free_bulk_streams_func = redir_free_bulk_streams;
+	parser->bulk_streams_status_func = redir_bulk_streams_status;
+	parser->cancel_data_packet_func = redir_cancel_data_packet;
+	parser->control_packet_func = redir_control_packet;
+	parser->bulk_packet_func = redir_bulk_packet;
+	parser->iso_packet_func = redir_iso_packet;
+	parser->interrupt_packet_func = redir_interrupt_packet;
+	parser->alloc_lock_func = redir_alloc_lock;
+	parser->lock_func = redir_lock;
+	parser->unlock_func = redir_unlock;
+	parser->free_lock_func = redir_free_lock;
+	parser->hello_func = redir_hello;
+	parser->filter_reject_func = redir_filter_reject;
+	parser->filter_filter_func = redir_filter_filter;
+	parser->device_disconnect_ack_func = redir_device_disconnect_ack;
+	parser->start_bulk_receiving_func = redir_start_bulk_receiving;
+	parser->stop_bulk_receiving_func = redir_stop_bulk_receiving;
+	parser->bulk_receiving_status_func = redir_bulk_receiving_status;
+	parser->buffered_bulk_packet_func = redir_buffered_bulk_packet;
+
+	memset(caps, 0, sizeof(caps));
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_32bits_bulk_length);
+
+	/* TODO - figure out which of these we really can use */
+#if defined(USE_ALL_CAPS)
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_streams);
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_connect_device_version);
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_filter);
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_device_disconnect_ack);
+	usbredirparser_caps_set_cap(caps,
+				usb_redir_cap_ep_info_max_packet_size);
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_64bits_ids);
+	usbredirparser_caps_set_cap(caps, usb_redir_cap_bulk_receiving);
+#endif
+
+	sprintf(version, "kmodule v%s. Protocol %x",
+		USBREDIR_MODULE_VERSION, USBREDIR_VERSION);
+	usbredirparser_init(parser, version, caps, USB_REDIR_CAPS_SIZE, 0);
+
+	return parser;
+}
+
diff --git a/drivers/usb/usbredir/rx.c b/drivers/usb/usbredir/rx.c
new file mode 100644
index 0000000..92ffa97
--- /dev/null
+++ b/drivers/usb/usbredir/rx.c
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015 Jeremy White
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/kthread.h>
+
+#include "usbredir.h"
+
+int usbredir_rx_loop(void *data)
+{
+	struct usbredir_device *udev = data;
+	int rc;
+
+	while (!kthread_should_stop() && atomic_read(&udev->active)) {
+		rc = usbredirparser_do_read(udev->parser);
+		if (rc != -EAGAIN) {
+			pr_info("usbredir/rx:%d connection closed\n",
+				udev->rhport);
+			break;
+		}
+	}
+
+	pr_debug("%s exit\n", __func__);
+
+	usbredir_device_disconnect(udev);
+	usbredir_device_deallocate(udev, false, true);
+
+	return 0;
+}
diff --git a/drivers/usb/usbredir/strtok_r.c b/drivers/usb/usbredir/strtok_r.c
new file mode 100644
index 0000000..2c761e1
--- /dev/null
+++ b/drivers/usb/usbredir/strtok_r.c
@@ -0,0 +1,69 @@
+/* Reentrant string tokenizer.  Generic version.
+   Copyright (C) 1991,1996-1999,2001,2004 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if defined(__KERNEL__)
+#include <linux/string.h>
+#else
+#include <string.h>
+#endif
+
+/* Parse S into tokens separated by characters in DELIM.
+   If S is NULL, the saved pointer in SAVE_PTR is used as
+   the next starting point.  For example:
+	char s[] = "-abc-=-def";
+	char *sp;
+	x = strtok_r(s, "-", &sp);	// x = "abc", sp = "=-def"
+	x = strtok_r(NULL, "-=", &sp);	// x = "def", sp = NULL
+	x = strtok_r(NULL, "=", &sp);	// x = NULL
+		// s = "abc\0-def\0"
+*/
+char *
+glibc_strtok_r (char *s, const char *delim, char **save_ptr)
+{
+  char *token;
+
+  if (s == NULL)
+    s = *save_ptr;
+
+  /* Scan leading delimiters.  */
+  s += strspn (s, delim);
+  if (*s == '\0')
+    {
+      *save_ptr = s;
+      return NULL;
+    }
+
+  /* Find the end of the token.  */
+  token = s;
+  s = strpbrk (token, delim);
+  if (s == NULL)
+    /* This token finishes the string.  */
+    *save_ptr = strchr (token, '\0');
+  else
+    {
+      /* Terminate the token and make *SAVE_PTR point past it.  */
+      *s = '\0';
+      *save_ptr = s + 1;
+    }
+  return token;
+}
diff --git a/drivers/usb/usbredir/strtok_r.h b/drivers/usb/usbredir/strtok_r.h
new file mode 100644
index 0000000..50e6e0e
--- /dev/null
+++ b/drivers/usb/usbredir/strtok_r.h
@@ -0,0 +1,26 @@
+/* Reentrant string tokenizer.  Generic version.
+   Copyright (C) 1991,1996-1999,2001,2004 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _USBREDIRPARSER_STRTOK_H_
+#define _USBREDIRPARSER_STRTOK_H_
+
+char *
+glibc_strtok_r(char *s, const char *delim, char **save_ptr);
+
+#endif
diff --git a/drivers/usb/usbredir/sysfs.c b/drivers/usb/usbredir/sysfs.c
new file mode 100644
index 0000000..e8edef3
--- /dev/null
+++ b/drivers/usb/usbredir/sysfs.c
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2015 Jeremy White based on work by
+ * Copyright (C) 2003-2008 Takahiro Hirofuchi
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/file.h>
+#include <linux/net.h>
+
+#include "usbredir.h"
+
+
+static ssize_t status_show(struct device_driver *driver, char *out)
+{
+	return usbredir_hub_show_global_status(out);
+}
+static DRIVER_ATTR_RO(status);
+
+static ssize_t store_attach(struct device_driver *driver,
+			    const char *buf, size_t count)
+{
+	struct socket *socket;
+	int sockfd = 0;
+	char devid[256];
+	int err;
+
+	/*
+	 * usbredir sysfs attach file
+	 * @sockfd: socket descriptor of an established TCP connection
+	 * @devid: user supplied unique device identifier
+	 */
+	memset(devid, 0, sizeof(devid));
+	if (sscanf(buf, "%u %255s", &sockfd, devid) != 2)
+		return -EINVAL;
+
+	pr_debug("attach sockfd(%u) devid(%s)\n", sockfd, devid);
+
+	socket = sockfd_lookup(sockfd, &err);
+	if (!socket)
+		return -EINVAL;
+
+	if (usbredir_hub_find_device(devid)) {
+		pr_err("%s: already in use\n", devid);
+		sockfd_put(socket);
+		return -EINVAL;
+	}
+
+	if (!usbredir_hub_allocate_device(devid, socket)) {
+		pr_err("%s: unable to create\n", devid);
+		sockfd_put(socket);
+		return -EINVAL;
+	}
+
+	return count;
+}
+static DRIVER_ATTR(attach, S_IWUSR, NULL, store_attach);
+
+
+static ssize_t store_detach(struct device_driver *driver,
+			    const char *buf, size_t count)
+{
+	char devid[256];
+	struct usbredir_device *udev;
+
+	/*
+	 * usbredir sysfs detach file
+	 * @devid: user supplied unique device identifier
+	 */
+	memset(devid, 0, sizeof(devid));
+	if (sscanf(buf, "%255s", devid) != 1)
+		return -EINVAL;
+
+	pr_debug("detach devid(%s)\n", devid);
+
+	udev = usbredir_hub_find_device(devid);
+	if (!udev) {
+		pr_warn("USBREDIR device %s detach requested, but not found\n",
+			devid);
+		return count;
+	}
+
+	usbredir_device_disconnect(udev);
+	usbredir_device_deallocate(udev, true, true);
+
+	return count;
+}
+static DRIVER_ATTR(detach, S_IWUSR, NULL, store_detach);
+
+
+/**
+ * usbredir_sysfs_register()
+ * @driver	The platform driver associated with usbredir
+ *
+ * This function will register new sysfs files called 'attach', 'detach',
+ * and 'status'.
+ *
+ * To start a new connection, a user space program should establish
+ * a socket that is connected to a process that provides a USB device
+ * and that speaks the USBREDIR protocol.  The usbredirserver program
+ * is one such example.
+ *
+ * Next, the user space program should write that socket as well as a
+ * unique device id of no more than 255 characters to the 'attach' file.
+ * That should begin a connection.
+ *
+ * Writing the same id to the 'detach' file should end the connection,
+ * and examining the contents of the 'status' file should show the number
+ * of connections.
+ *
+ */
+int usbredir_sysfs_register(struct device_driver *driver)
+{
+	int ret;
+
+	ret = driver_create_file(driver, &driver_attr_status);
+	if (ret)
+		return ret;
+
+	ret = driver_create_file(driver, &driver_attr_detach);
+	if (ret)
+		return ret;
+
+	return driver_create_file(driver, &driver_attr_attach);
+}
+
+/**
+ * usbredir_sysfs_unregister()
+ * @dev The device driver associated with usbredir
+ */
+void usbredir_sysfs_unregister(struct device_driver *dev)
+{
+	driver_remove_file(dev, &driver_attr_status);
+	driver_remove_file(dev, &driver_attr_detach);
+	driver_remove_file(dev, &driver_attr_attach);
+}
diff --git a/drivers/usb/usbredir/tx.c b/drivers/usb/usbredir/tx.c
new file mode 100644
index 0000000..aae7a10
--- /dev/null
+++ b/drivers/usb/usbredir/tx.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2015 Jeremy White based on work by
+ * Copyright (C) 2003-2008 Takahiro Hirofuchi
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/kthread.h>
+#include <linux/slab.h>
+
+#include "usbredir.h"
+
+static struct usbredir_urb *get_next_urb(struct usbredir_device *udev)
+{
+	struct usbredir_urb *uurb, *tmp;
+
+	spin_lock(&udev->lists_lock);
+
+	list_for_each_entry_safe(uurb, tmp, &udev->urblist_tx, list) {
+		list_move_tail(&uurb->list, &udev->urblist_rx);
+		spin_unlock(&udev->lists_lock);
+		return uurb;
+	}
+
+	spin_unlock(&udev->lists_lock);
+
+	return NULL;
+}
+
+static void send_packet(struct usbredir_device *udev, struct usbredir_urb *uurb)
+{
+	struct urb *urb = uurb->urb;
+	__u8 type = usb_pipetype(urb->pipe);
+
+	if (type == PIPE_CONTROL && urb->setup_packet) {
+		struct usb_ctrlrequest *ctrlreq =
+			(struct usb_ctrlrequest *) urb->setup_packet;
+		struct usb_redir_control_packet_header ctrl;
+
+		ctrl.endpoint = usb_pipeendpoint(urb->pipe) |
+				usb_pipein(urb->pipe);
+		ctrl.request = ctrlreq->bRequest;
+		ctrl.requesttype = ctrlreq->bRequestType;
+		ctrl.status = 0;
+		ctrl.value = le16_to_cpu(ctrlreq->wValue);
+		ctrl.index = le16_to_cpu(ctrlreq->wIndex);
+		ctrl.length = le16_to_cpu(ctrlreq->wLength);
+
+		usbredirparser_send_control_packet(udev->parser,
+			uurb->seqnum, &ctrl,
+			usb_pipein(urb->pipe) ?
+				NULL : urb->transfer_buffer,
+			usb_pipein(urb->pipe) ?
+				0 : urb->transfer_buffer_length);
+
+	}
+
+	if (type == PIPE_BULK) {
+		struct usb_redir_bulk_packet_header bulk;
+
+		bulk.endpoint = usb_pipeendpoint(urb->pipe) |
+				usb_pipein(urb->pipe);
+		bulk.status = 0;
+		bulk.length = urb->transfer_buffer_length & 0xFFFF;
+		bulk.stream_id = urb->stream_id;
+		bulk.length_high = urb->transfer_buffer_length >> 16;
+
+		usbredirparser_send_bulk_packet(udev->parser,
+			uurb->seqnum, &bulk,
+			usb_pipein(urb->pipe) ?
+				NULL : urb->transfer_buffer,
+			usb_pipein(urb->pipe) ?
+				0 : urb->transfer_buffer_length);
+	}
+}
+
+static struct usbredir_unlink *get_next_unlink(struct usbredir_device *udev)
+{
+	struct usbredir_unlink *unlink, *tmp;
+
+	spin_lock(&udev->lists_lock);
+
+	list_for_each_entry_safe(unlink, tmp, &udev->unlink_tx, list) {
+		list_move_tail(&unlink->list, &udev->unlink_rx);
+		spin_unlock(&udev->lists_lock);
+		return unlink;
+	}
+
+	spin_unlock(&udev->lists_lock);
+
+	return NULL;
+}
+
+static void send_unlink(struct usbredir_device *udev,
+		       struct usbredir_unlink *unlink)
+{
+	while ((unlink = get_next_unlink(udev)) != NULL) {
+		/* This is a separate TODO; need to process unlink_rx... */
+		pr_debug("TODO partially unimplemented: unlink request of ");
+		pr_debug("seqnum %d, unlink seqnum %d\n",
+			unlink->seqnum, unlink->unlink_seqnum);
+
+		/* TODO - if the other side never responds, which it may
+			not do if the seqnum doesn't match, then we
+			never clear this entry.  That's probably not ideal */
+		usbredirparser_send_cancel_data_packet(udev->parser,
+						       unlink->unlink_seqnum);
+	}
+}
+
+int usbredir_tx_loop(void *data)
+{
+	struct usbredir_device *udev = data;
+	struct usbredir_urb *uurb;
+	struct usbredir_unlink *unlink;
+
+	while (!kthread_should_stop() && atomic_read(&udev->active)) {
+		if (usbredirparser_has_data_to_write(udev->parser))
+			if (usbredirparser_do_write(udev->parser))
+				break;
+
+		while ((uurb = get_next_urb(udev)) != NULL)
+			send_packet(udev, uurb);
+
+		while ((unlink = get_next_unlink(udev)) != NULL)
+			send_unlink(udev, unlink);
+
+		/* TODO - can I check list_empty without locking... */
+		wait_event_interruptible(udev->waitq_tx,
+			 (!list_empty(&udev->urblist_tx) ||
+			  !list_empty(&udev->unlink_tx) ||
+			  kthread_should_stop() ||
+			 usbredirparser_has_data_to_write(udev->parser) ||
+			 !atomic_read(&udev->active)));
+	}
+
+	pr_debug("%s exit\n", __func__);
+	usbredir_device_disconnect(udev);
+	usbredir_device_deallocate(udev, true, false);
+
+	return 0;
+}
diff --git a/drivers/usb/usbredir/urb.c b/drivers/usb/usbredir/urb.c
new file mode 100644
index 0000000..50bec2f
--- /dev/null
+++ b/drivers/usb/usbredir/urb.c
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2015 Jeremy White based on work by
+ * Copyright (C) 2003-2008 Takahiro Hirofuchi
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This 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.
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "usbredir.h"
+
+static void queue_urb(struct usbredir_device *udev, struct urb *urb)
+{
+	struct usbredir_urb *uurb;
+
+	uurb = kzalloc(sizeof(struct usbredir_urb), GFP_ATOMIC);
+	if (!uurb) {
+		usbredir_device_disconnect(udev);
+		usbredir_device_deallocate(udev, true, true);
+		return;
+	}
+
+	spin_lock(&udev->lists_lock);
+
+	uurb->seqnum = usbredir_hub_seqnum(udev->hub);
+
+	uurb->udev = udev;
+	uurb->urb = urb;
+
+	urb->hcpriv = (void *) uurb;
+
+	list_add_tail(&uurb->list, &udev->urblist_tx);
+	spin_unlock(&udev->lists_lock);
+}
+
+static bool intercept_urb_request(struct usbredir_device *udev,
+				  struct urb *urb, int *ret)
+{
+	struct device *dev = &urb->dev->dev;
+	__u8 type = usb_pipetype(urb->pipe);
+	struct usb_ctrlrequest *ctrlreq =
+		(struct usb_ctrlrequest *) urb->setup_packet;
+
+	if (usb_pipedevice(urb->pipe) != 0)
+		return false;
+
+	if (type != PIPE_CONTROL || !ctrlreq) {
+		dev_err(dev, "invalid request to devnum 0; type %x, req %p\n",
+			type, ctrlreq);
+		*ret = -EINVAL;
+		return true;
+	}
+
+	if (ctrlreq->bRequest == USB_REQ_GET_DESCRIPTOR) {
+		pr_debug("Requesting descriptor; wValue %x\n", ctrlreq->wValue);
+
+		usb_put_dev(udev->usb_dev);
+		udev->usb_dev = usb_get_dev(urb->dev);
+
+		if (ctrlreq->wValue == cpu_to_le16(USB_DT_DEVICE << 8))
+			pr_debug("TODO: GetDescriptor unexpected.\n");
+
+		return false;
+	}
+
+	if (ctrlreq->bRequest == USB_REQ_SET_ADDRESS) {
+		dev_info(dev, "SetAddress Request (%d) to port %d\n",
+			 ctrlreq->wValue, udev->rhport);
+
+		usb_put_dev(udev->usb_dev);
+		udev->usb_dev = usb_get_dev(urb->dev);
+
+		if (urb->status == -EINPROGRESS) {
+			/* This request is successfully completed. */
+			/* If not -EINPROGRESS, possibly unlinked. */
+			urb->status = 0;
+		}
+		return true;
+	}
+
+	dev_err(dev,
+		"invalid request to devnum 0 bRequest %u, wValue %u\n",
+		ctrlreq->bRequest,
+		ctrlreq->wValue);
+	*ret =  -EINVAL;
+
+	return true;
+}
+
+void usbredir_urb_cleanup_urblists(struct usbredir_device *udev)
+{
+	struct usbredir_urb *uurb, *tmp;
+
+	spin_lock(&udev->lists_lock);
+	list_for_each_entry_safe(uurb, tmp, &udev->urblist_rx, list) {
+		list_del(&uurb->list);
+		usb_hcd_unlink_urb_from_ep(udev->hub->hcd, uurb->urb);
+		usb_hcd_giveback_urb(udev->hub->hcd, uurb->urb, -ENODEV);
+		kfree(uurb);
+	}
+
+	list_for_each_entry_safe(uurb, tmp, &udev->urblist_tx, list) {
+		list_del(&uurb->list);
+		usb_hcd_unlink_urb_from_ep(udev->hub->hcd, uurb->urb);
+		usb_hcd_giveback_urb(udev->hub->hcd, uurb->urb, -ENODEV);
+		kfree(uurb);
+	}
+	spin_unlock(&udev->lists_lock);
+}
+
+
+
+int usbredir_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
+{
+	struct device *dev = &urb->dev->dev;
+	int ret = 0;
+	struct usbredir_hub *hub = usbredir_hub_from_hcd(hcd);
+	struct usbredir_device *udev;
+
+	pr_debug("%s: enter, usb_hcd %p urb %p mem_flags %d\n",
+			  __func__, hcd, urb, mem_flags);
+
+	if (urb->status != -EINPROGRESS) {
+		dev_err(dev, "URB already handled!, status %d\n", urb->status);
+		return urb->status;
+	}
+
+	udev = hub->devices + urb->dev->portnum - 1;
+
+	if (!atomic_read(&udev->active)) {
+		dev_err(dev, "enqueue for inactive port %d\n", udev->rhport);
+		return -ENODEV;
+	}
+
+	ret = usb_hcd_link_urb_to_ep(hcd, urb);
+	if (ret) {
+		usb_hcd_giveback_urb(hub->hcd, urb, urb->status);
+		return ret;
+	}
+
+	if (intercept_urb_request(udev, urb, &ret)) {
+		usb_hcd_unlink_urb_from_ep(hcd, urb);
+		usb_hcd_giveback_urb(hub->hcd, urb, urb->status);
+		return ret;
+	}
+
+	queue_urb(udev, urb);
+	wake_up_interruptible(&udev->waitq_tx);
+	return ret;
+}
+
+int usbredir_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
+{
+	struct usbredir_urb *uurb;
+	struct usbredir_device *udev;
+	struct usbredir_hub *hub = usbredir_hub_from_hcd(hcd);
+	int ret = 0;
+
+	pr_debug("%s %p\n", __func__, urb);
+
+	uurb = urb->hcpriv;
+	if (!uurb) {
+		/* URB was never linked! or will be soon given back by
+		 * rx_loop. */
+		return 0;
+	}
+
+	ret = usb_hcd_check_unlink_urb(hcd, urb, status);
+	if (ret) {
+		/* TODO - figure out if this is an unlink send case as well */
+		return ret;
+	}
+
+	udev = uurb->udev;
+	if (atomic_read(&udev->active)) {
+		struct usbredir_unlink *unlink;
+
+		spin_lock(&udev->lists_lock);
+
+		unlink = kzalloc(sizeof(struct usbredir_unlink), GFP_ATOMIC);
+		if (!unlink) {
+			spin_unlock(&udev->lists_lock);
+			/* TODO complain somehow... */
+			return -ENOMEM;
+		}
+
+		unlink->seqnum = usbredir_hub_seqnum(hub);
+		unlink->unlink_seqnum = uurb->seqnum;
+		list_add_tail(&unlink->list, &udev->unlink_tx);
+		/* TODO - are we failing to pass through the status here? */
+
+		spin_unlock(&udev->lists_lock);
+
+		wake_up(&udev->waitq_tx);
+	} else {
+		/* Connection is dead already */
+		spin_lock(&udev->lists_lock);
+
+		list_del(&uurb->list);
+		kfree(uurb);
+		urb->hcpriv = NULL;
+
+		spin_unlock(&udev->lists_lock);
+
+		pr_info("gives back urb %p\n", urb);
+
+		usb_hcd_unlink_urb_from_ep(hcd, urb);
+		usb_hcd_giveback_urb(hub->hcd, urb, urb->status);
+	}
+
+	return ret;
+}
+
+struct urb *usbredir_pop_rx_urb(struct usbredir_device *udev, int seqnum)
+{
+	struct usbredir_urb *uurb, *tmp;
+	struct urb *urb = NULL;
+	int status;
+
+	spin_lock(&udev->lists_lock);
+
+	list_for_each_entry_safe(uurb, tmp, &udev->urblist_rx, list) {
+		if (uurb->seqnum != seqnum)
+			continue;
+
+		urb = uurb->urb;
+		status = urb->status;
+
+		switch (status) {
+		case -ENOENT:
+			/* fall through */
+		case -ECONNRESET:
+			dev_info(&urb->dev->dev,
+				 "urb %p was unlinked %ssynchronuously.\n", urb,
+				 status == -ENOENT ? "" : "a");
+			break;
+		case -EINPROGRESS:
+			/* no info output */
+			break;
+		default:
+			dev_info(&urb->dev->dev,
+				 "urb %p may be in a error, status %d\n", urb,
+				 status);
+		}
+
+		list_del(&uurb->list);
+		kfree(uurb);
+		urb->hcpriv = NULL;
+
+		break;
+	}
+	spin_unlock(&udev->lists_lock);
+
+	return urb;
+}
diff --git a/drivers/usb/usbredir/usbredir.h b/drivers/usb/usbredir/usbredir.h
new file mode 100644
index 0000000..fd80059
--- /dev/null
+++ b/drivers/usb/usbredir/usbredir.h
@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2015 Jeremy White based on work by
+ * Copyright (C) 2003-2008 Takahiro Hirofuchi
+ *
+ * This 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ */
+
+#ifndef __USBREDIR_H
+#define __USBREDIR_H
+
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/platform_device.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "usbredirparser.h"
+
+#define USBREDIR_MODULE_VERSION	"1.0"
+
+
+/**
+ * struct usbredir_device - Describe a redirected usb device
+ * @lock		spinlock for port_status, usb_dev, and other misc fields
+ * @active		indicates whether the device is actively connected
+ * @usb_dev		The usb device actively in use; captured on our first
+ *			useful control urb.  We mostly use it to signal that
+ *			a device is in use.
+ * @hub			The root hub that is associated with this device.
+ * @port_status		A status variable to track usb/core.c style status;
+ *			e.g. USB_PORT_STAT_ENABLE et all
+ * @socket		The socket used to connect to the remote device
+ * @parser		A parser which drives the socket
+ * @rx			The task structure for the receive thread
+ * @tx			The task structure for the transmit thread
+ * @devid		A user space provided id for this device; must be unique
+ * @connect_header	Stored USBREDIR connection header information
+ * @info_header		Stored USBREDIR connection information
+ * @ep_info_header	Stored USBREDIR endpoint header info
+ * @rhport		0 based port number on our root hub
+ * @lists_lock		A spinlock just for the urb and unlink lists
+ * @urblist_tx		A list of urb's ready to be transmitted
+ * @urblist_rx		A list of urbs already transmitted, awaiting
+ *                      a response
+ * @unlink_tx		A list of urb's to be send to be unlinked
+ * @unlink_xx		A list of urb's we have requested cancellation of
+ * @waitq_tx		Wait queue the transmit thread sleeps on
+ */
+struct usbredir_device {
+	spinlock_t lock;
+
+	atomic_t active;
+
+	struct usb_device *usb_dev;
+	struct usbredir_hub *hub;
+
+	u32 port_status;
+
+	struct socket *socket;
+	struct usbredirparser *parser;
+
+	struct task_struct *rx;
+	struct task_struct *tx;
+
+	char *devid;
+
+	struct usb_redir_device_connect_header connect_header;
+	struct usb_redir_interface_info_header info_header;
+	struct usb_redir_ep_info_header ep_info_header;
+
+	__u32 rhport;
+
+	spinlock_t lists_lock;
+
+	struct list_head urblist_tx;
+	struct list_head urblist_rx;
+
+	struct list_head unlink_tx;
+	struct list_head unlink_rx;
+
+	wait_queue_head_t waitq_tx;
+};
+
+/**
+ * struct usbredir_hub - Describe a virtual usb hub, which can hold
+ *			 redirected usb devices
+ *
+ * @lock		Spinlock controlling access to variables,
+ *			mostly needed for timeout and resuming flags
+ * @list		Place holder for stashing inside a larger hub list
+ * @id			A numeric identifier for this hub
+ * @pdev		A registered platform device for this hub
+ * @hcd			The usb_hcd associated with this hub
+ * @device_count	The number of devices that can be connected to this hub
+ * @devices		An array of devices
+ * @aseqnum		Sequence number for transmissions
+ * @resuming		Flag to indicate we are resuming
+ * @re_timeout		General settle timeout for our hub
+ *
+ * The usbredir_hubs are allocated dynamically, as needed, but not freed.
+ * A new devices is assigned to the first hub with a free slot.
+ */
+struct usbredir_hub {
+	spinlock_t lock;
+	struct list_head	list;
+	int			id;
+	struct platform_device	pdev;
+	struct usb_hcd		*hcd;
+
+	int			device_count;
+	struct usbredir_device *devices;
+
+	atomic_t aseqnum;
+
+	unsigned resuming:1;
+	unsigned long re_timeout;
+};
+
+/**
+ * struct usbredir_urb - Hold our information regarding a URB
+ * @seqnum		Sequence number of the urb
+ * @list		Place holder to keep it in device/urblist_[rt]x
+ * @udev		A pointer to our associated device
+ * @urb			A pointer to the associated urb
+ */
+struct usbredir_urb {
+	int seqnum;
+	struct list_head list;
+
+	struct usbredir_device *udev;
+	struct urb *urb;
+};
+
+/**
+ * struct usbredir_unlink  - Hold unlink requests
+ * @seqnum		Sequence number of this request
+ * @list		Place holder to keep it in device/unlink_[rt]x
+ * @unlink_seqnum	Sequence number of the urb to unlink
+ */
+struct usbredir_unlink {
+	int seqnum;
+
+	struct list_head list;
+
+	int unlink_seqnum;
+};
+
+
+/* main.c */
+extern unsigned int max_hubs;
+extern unsigned int devices_per_hub;
+
+extern const char driver_name[];
+extern const char driver_desc[];
+
+/* sysfs.c */
+int usbredir_sysfs_register(struct device_driver *dev);
+void usbredir_sysfs_unregister(struct device_driver *dev);
+
+/* hub.c */
+int usbredir_hub_init(void);
+void usbredir_hub_exit(void);
+struct usbredir_hub *usbredir_hub_create(void);
+void usbredir_hub_destroy(struct usbredir_hub *hub);
+struct usbredir_device *usbredir_hub_allocate_device(const char *devid,
+						     struct socket *socket);
+struct usbredir_device *usbredir_hub_find_device(const char *devid);
+int usbredir_hub_show_global_status(char *out);
+
+
+/* device.c */
+void usbredir_device_init(struct usbredir_device *udev, int port,
+			  struct usbredir_hub *hub);
+void usbredir_device_allocate(struct usbredir_device *udev,
+			      const char *devid,
+			      struct socket *socket);
+void usbredir_device_deallocate(struct usbredir_device *udev,
+				bool stop, bool stoptx);
+void usbredir_device_connect(struct usbredir_device *udev);
+void usbredir_device_disconnect(struct usbredir_device *udev);
+int usbredir_device_clear_port_feature(struct usbredir_hub *hub,
+			       int rhport, u16 wValue);
+int usbredir_device_port_status(struct usbredir_hub *hub, int rhport,
+				char *buf);
+int usbredir_device_set_port_feature(struct usbredir_hub *hub,
+			       int rhport, u16 wValue);
+
+/* redir.c */
+struct usbredirparser *redir_parser_init(void *priv);
+
+/* rx.c */
+int usbredir_rx_loop(void *data);
+
+/* tx.c */
+int usbredir_tx_loop(void *data);
+
+/* urb.c */
+int usbredir_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
+			    gfp_t mem_flags);
+int usbredir_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
+struct urb *usbredir_pop_rx_urb(struct usbredir_device *udev, int seqnum);
+void usbredir_urb_cleanup_urblists(struct usbredir_device *udev);
+
+/* Fast lookup functions */
+static inline struct usbredir_hub *usbredir_hub_from_hcd(struct usb_hcd *hcd)
+{
+	return *(struct usbredir_hub **) hcd->hcd_priv;
+}
+
+static inline int usbredir_hub_seqnum(struct usbredir_hub *hub)
+{
+	int ret = atomic_inc_return(&hub->aseqnum);
+	/* Atomics are only guaranteed to 24 bits */
+	if (ret < 0 || ret > (1 << 23)) {
+		ret = 1;
+		atomic_set(&hub->aseqnum, 1);
+	}
+	return ret;
+}
+
+#endif /* __USBREDIR_H */
diff --git a/drivers/usb/usbredir/usbredirfilter.c b/drivers/usb/usbredir/usbredirfilter.c
new file mode 100644
index 0000000..4e3655a
--- /dev/null
+++ b/drivers/usb/usbredir/usbredirfilter.c
@@ -0,0 +1,294 @@
+/* usbredirfilter.h usb redirection filter header
+
+   Copyright 2012 Red Hat, Inc.
+
+   Red Hat Authors:
+   Hans de Goede <hdegoede@xxxxxxxxxx>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if defined(__KERNEL__)
+#include <linux/string.h>
+#include <linux/slab.h>
+#else
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#endif
+
+#if defined(WIN32) || defined(__KERNEL__)
+#include "strtok_r.h"
+#define strtok_r  glibc_strtok_r
+#endif
+
+#if defined(__KERNEL__)
+#define CALLOC(a, b)    kcalloc((a), (b), GFP_KERNEL)
+#define MALLOC(a)       kmalloc((a), GFP_KERNEL)
+#define STRDUP(a)       kstrdup((a), GFP_KERNEL)
+#define FREE kfree
+#else
+#define CALLOC          calloc
+#define MALLOC          malloc
+#define STRDUP          strdup
+#define FREE            free
+#endif
+#include "usbredirfilter.h"
+
+int filter_strtoi(char *str, int *res)
+{
+    long l;
+    int rc = 0;
+#if defined(__KERNEL__)
+    rc = kstrtol(str, 0, &l);
+#else
+    char *ep;
+
+    l = strtol(str, &ep, 0);
+    if (*ep)
+        rc = -1;
+#endif
+    if (rc == 0)
+        *res = (int) l;
+    return rc;
+}
+
+int usbredirfilter_string_to_rules(
+    const char *filter_str, const char *token_sep, const char *rule_sep,
+    struct usbredirfilter_rule **rules_ret, int *rules_count_ret)
+{
+    char *rule, *rule_saveptr, *token, *token_saveptr;
+    struct usbredirfilter_rule *rules = NULL;
+    int i, rules_count, *values, ret = 0;
+    char *buf = NULL;
+    const char *r;
+
+    *rules_ret = NULL;
+    *rules_count_ret = 0;
+
+    /* Figure out how much rules there are in the file, so we know how
+       much memory we must allocate for the rules array.
+       Note this will come up with a slightly too large number if there are
+       empty rule strings in the set. */
+    r = filter_str;
+    rules_count = 0;
+    while (r) {
+        r = strchr(r, rule_sep[0]);
+        if (r)
+            r++;
+        rules_count++;
+    }
+
+    rules = CALLOC(rules_count, sizeof(struct usbredirfilter_rule));
+    if (!rules)
+        return -ENOMEM;
+
+    /* Make a copy since strtok mangles the string */
+    buf = STRDUP(filter_str);
+    if (!buf) {
+        ret = -ENOMEM;
+        goto leave;
+    }
+
+    /* And actually parse the string */
+    rules_count = 0;
+    rule = strtok_r(buf, rule_sep, &rule_saveptr);
+    while (rule) {
+        /* We treat the filter rule as an array of ints for easier parsing */
+        values = (int *)&rules[rules_count];
+        token = strtok_r(rule, token_sep, &token_saveptr);
+        for (i = 0; i < 5 && token; i++) {
+	    if (filter_strtoi(token, &values[i]))
+	        break;
+            token = strtok_r(NULL, token_sep, &token_saveptr);
+        }
+        if (i != 5 || token != NULL ||
+                usbredirfilter_verify(&rules[rules_count], 1)) {
+            ret = -EINVAL;
+            goto leave;
+        }
+        rules_count++;
+        rule = strtok_r(NULL, rule_sep, &rule_saveptr);
+    }
+
+    *rules_ret = rules;
+    *rules_count_ret = rules_count;
+
+leave:
+    if (ret)
+        FREE(rules);
+    FREE(buf);
+    return ret;
+}
+
+char *usbredirfilter_rules_to_string(const struct usbredirfilter_rule *rules,
+    int rules_count, const char *token_sep, const char *rule_sep)
+{
+    int i;
+    char *str, *p;
+
+    if (usbredirfilter_verify(rules, rules_count))
+        return NULL;
+
+    /* We need 28 bytes per rule in the worst case */
+    str = MALLOC(28 * rules_count + 1);
+    if (!str)
+        return NULL;
+
+    p = str;
+    for (i = 0; i < rules_count; i++) {
+        if (rules[i].device_class != -1)
+            p += sprintf(p, "0x%02x%c", rules[i].device_class, *token_sep);
+        else
+            p += sprintf(p, "-1%c", *token_sep);
+
+        if (rules[i].vendor_id != -1)
+            p += sprintf(p, "0x%04x%c", rules[i].vendor_id, *token_sep);
+        else
+            p += sprintf(p, "-1%c", *token_sep);
+
+        if (rules[i].product_id != -1)
+            p += sprintf(p, "0x%04x%c", rules[i].product_id, *token_sep);
+        else
+            p += sprintf(p, "-1%c", *token_sep);
+
+        if (rules[i].device_version_bcd != -1)
+            p += sprintf(p, "0x%04x%c", rules[i].device_version_bcd, *token_sep);
+        else
+            p += sprintf(p, "-1%c", *token_sep);
+
+        p += sprintf(p, "%d%c", rules[i].allow ? 1:0, *rule_sep);
+    }
+
+    return str;
+}
+
+static int usbredirfilter_check1(const struct usbredirfilter_rule *rules,
+    int rules_count, uint8_t device_class, uint16_t vendor_id,
+    uint16_t product_id, uint16_t device_version_bcd, int default_allow)
+{
+    int i;
+
+    for (i = 0; i < rules_count; i++) {
+        if ((rules[i].device_class == -1 ||
+                rules[i].device_class == device_class) &&
+            (rules[i].vendor_id == -1 ||
+                rules[i].vendor_id == vendor_id) &&
+            (rules[i].product_id == -1 ||
+                rules[i].product_id == product_id) &&
+            (rules[i].device_version_bcd == -1 ||
+                rules[i].device_version_bcd == device_version_bcd)) {
+            /* Found a match ! */
+            return rules[i].allow ? 0 : -EPERM;
+        }
+    }
+
+    return default_allow ? 0 : -ENOENT;
+}
+
+int usbredirfilter_check(
+    const struct usbredirfilter_rule *rules, int rules_count,
+    uint8_t device_class, uint8_t device_subclass, uint8_t device_protocol,
+    uint8_t *interface_class, uint8_t *interface_subclass,
+    uint8_t *interface_protocol, int interface_count,
+    uint16_t vendor_id, uint16_t product_id, uint16_t device_version_bcd,
+    int flags)
+{
+    int i, rc;
+
+    if (usbredirfilter_verify(rules, rules_count))
+        return -EINVAL;
+
+    /* Check the device_class */
+    if (device_class != 0x00 && device_class != 0xef) {
+        rc = usbredirfilter_check1(rules, rules_count, device_class,
+                                   vendor_id, product_id, device_version_bcd,
+                                   flags & usbredirfilter_fl_default_allow);
+        if (rc)
+            return rc;
+    }
+
+    /* Check the interface classes */
+    for (i = 0; i < interface_count; i++) {
+        if (!(flags & usbredirfilter_fl_dont_skip_non_boot_hid) &&
+                interface_count > 1 && interface_class[i] == 0x03 &&
+                interface_subclass[i] == 0x00 && interface_protocol[i] == 0x00)
+            continue;
+
+        rc = usbredirfilter_check1(rules, rules_count, interface_class[i],
+                                   vendor_id, product_id, device_version_bcd,
+                                   flags & usbredirfilter_fl_default_allow);
+        if (rc)
+            return rc;
+    }
+
+    return 0;
+}
+
+int usbredirfilter_verify(
+    const struct usbredirfilter_rule *rules, int rules_count)
+{
+    int i;
+
+    for (i = 0; i < rules_count; i++) {
+        if (rules[i].device_class < -1 || rules[i].device_class > 255)
+            return -EINVAL;
+        if (rules[i].vendor_id < -1 || rules[i].vendor_id > 65535)
+            return -EINVAL;
+        if (rules[i].product_id < -1 || rules[i].product_id > 65535)
+            return -EINVAL;
+        if (rules[i].device_version_bcd < -1 ||
+                rules[i].device_version_bcd > 65535)
+            return -EINVAL;
+    }
+    return 0;
+}
+
+#if ! defined(__KERNEL__)
+void usbredirfilter_print(
+    const struct usbredirfilter_rule *rules, int rules_count, FILE *out)
+{
+    int i;
+    char device_class[16], vendor[16], product[16], version[16];
+
+    for (i = 0; i < rules_count; i++) {
+        if (rules[i].device_class != -1)
+            sprintf(device_class, " %02x", rules[i].device_class);
+        else
+            strcpy(device_class, "ANY");
+
+        if (rules[i].vendor_id != -1)
+            sprintf(vendor, "%04x", rules[i].vendor_id);
+        else
+            strcpy(vendor, " ANY");
+
+        if (rules[i].product_id != -1)
+            sprintf(product, "%04x", rules[i].product_id);
+        else
+            strcpy(product, " ANY");
+
+        if (rules[i].device_version_bcd != -1)
+            sprintf(version, "%2d.%02d",
+                    ((rules[i].device_version_bcd & 0xf000) >> 12) * 10 +
+                    ((rules[i].device_version_bcd & 0x0f00) >>  8),
+                    ((rules[i].device_version_bcd & 0x00f0) >>  4) * 10 +
+                    ((rules[i].device_version_bcd & 0x000f)));
+        else
+            strcpy(version, "  ANY");
+
+        fprintf(out, "Class %s ID %s:%s Version %s %s\n", device_class, vendor,
+                product, version, rules[i].allow ? "Allow":"Block");
+    }
+}
+#endif
diff --git a/drivers/usb/usbredir/usbredirfilter.h b/drivers/usb/usbredir/usbredirfilter.h
new file mode 100644
index 0000000..42773a8
--- /dev/null
+++ b/drivers/usb/usbredir/usbredirfilter.h
@@ -0,0 +1,144 @@
+/* usbredirfilter.h usb redirection filter header
+
+   Copyright 2012 Red Hat, Inc.
+
+   Red Hat Authors:
+   Hans de Goede <hdegoede@xxxxxxxxxx>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef __USBREDIRFILTER_H
+#define __USBREDIRFILTER_H
+
+#if ! defined(__KERNEL__)
+#include <stdio.h>
+#include <stdint.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct usbredirfilter_rule {
+    int device_class;       /* 0-255, -1 to match any class */
+    int vendor_id;          /* 0-65535, -1 to match any id */
+    int product_id;         /* 0-65535, -1 to match any id */
+    int device_version_bcd; /* 0-255, -1 to match any version */
+    int allow;              /* 0: deny redir for this device, non 0: allow */
+};
+
+/* Read a filter string and parse it into an array of usbredirfilter_rule-s.
+
+   Where each rule has the form of:
+   <class>,<vendor>,<product>,<version>,<allow>
+   Assuming "," as the specified token_sep character.
+
+   And the rules are themselves are separated by the rule_sep character, ie:
+   <rule1>|<rule2>|<rule3>
+
+   Assuming "|" as the rule_sep character. Note that with the seperator used
+   in this example the format matches the format as written by the RHEV-M USB
+   filter editor tool.
+
+   Note that the seperators must be single character strings!
+
+   On success the rules get returned in rules_ret and rules_count_ret, the
+   returned rules array should be freed with free() when the caller is done
+   with it.
+
+   Return value: 0 on success, -ENOMEM when allocating the rules array fails,
+       or -EINVAL when there is on parsing error.
+*/
+int usbredirfilter_string_to_rules(
+    const char *filter_str, const char *token_sep, const char *rule_sep,
+    struct usbredirfilter_rule **rules_ret, int *rules_count_ret);
+
+/* Convert a set of rules back to a string suitable for passing to
+   usbredirfilter_string_to_rules(); The returned string must be free()-ed
+   by the caller when it is done with it.
+
+   Return value: The string on sucess, or NULL if the rules fail verification,
+      or when allocating the string fails.
+*/
+char *usbredirfilter_rules_to_string(const struct usbredirfilter_rule *rules,
+    int rules_count, const char *token_sep, const char *rule_sep);
+
+/* Check if redirection of a device with the passed in device info is allowed
+   by the passed set of filter rules.
+
+   Since a device has class info at both the device level and the interface
+   level, this function does multiple passes.
+
+   First the rules are checked one by one against the given device info using
+   the device class info, if a matching rule is found, the result of the check
+   is that of that rule.
+
+   Then the same is done for each interface the device has, substituting the
+   device class info with the class info from the interfaces.
+
+   Note that under certain circumstances some passes are skipped:
+   - For devices with a device class of 0x00 or 0xef, the pass which checks the
+     device class is skipped.
+   - If the usbredirfilter_fl_dont_skip_non_boot_hid flag is not passed then
+     for devices with more then 1 interface and an interface with an interface
+     class of 0x03, an interface subclass of 0x00 and an interface protocol
+     of 0x00. the check is skipped for that interface. This allows to skip ie
+     checking the interface for volume buttons one some usbaudio class devices.
+
+   If the result of all (not skipped) passes is allow, then 0 will be returned,
+   which indicates that redirection should be allowed.
+
+   If the result of a matching rule is deny, then processing stops and
+   -EPERM will be returned.
+
+   If a given pass does not match any rules, then processing stops and
+   -ENOENT will be returned. This behavior can be changed with the
+   usbredirfilter_fl_default_allow flag, if this flag is set the result of a
+   pass with no matching rules will be allow.
+
+   Return value:
+    0        Redirection is allowed
+    -EINVAL  Invalid parameters
+    -EPERM   Redirection is blocked by the filter rules
+    -ENOENT  None of the rules matched the device (during one of the passes)
+*/
+enum {
+    usbredirfilter_fl_default_allow = 0x01,
+    usbredirfilter_fl_dont_skip_non_boot_hid = 0x02,
+};
+int usbredirfilter_check(
+    const struct usbredirfilter_rule *rules, int rules_count,
+    uint8_t device_class, uint8_t device_subclass, uint8_t device_protocol,
+    uint8_t *interface_class, uint8_t *interface_subclass,
+    uint8_t *interface_protocol, int interface_count,
+    uint16_t vendor_id, uint16_t product_id, uint16_t device_version_bcd,
+    int flags);
+
+/* Sanity check the passed in rules
+
+   Return value: 0 on success, -EINVAL when some values are out of bound. */
+int usbredirfilter_verify(
+    const struct usbredirfilter_rule *rules, int rules_count);
+
+#if ! defined(__KERNEL__)
+/* Print the passed in rules to FILE out in human readable format */
+void usbredirfilter_print(
+    const struct usbredirfilter_rule *rules, int rules_count, FILE *out);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/drivers/usb/usbredir/usbredirparser.c b/drivers/usb/usbredir/usbredirparser.c
new file mode 100644
index 0000000..154d95b
--- /dev/null
+++ b/drivers/usb/usbredir/usbredirparser.c
@@ -0,0 +1,1795 @@
+/* usbredirparser.c usb redirection protocol parser
+
+   Copyright 2010-2012 Red Hat, Inc.
+
+   Red Hat Authors:
+   Hans de Goede <hdegoede@xxxxxxxxxx>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#if defined(__KERNEL__)
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/slab.h>
+#else
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#endif
+
+#include "usbredirproto-compat.h"
+#include "usbredirparser.h"
+#include "usbredirfilter.h"
+
+#if defined(__KERNEL__)
+#define CALLOC(a, b)    kcalloc((a), (b), GFP_KERNEL)
+#define MALLOC(a)       kmalloc((a), GFP_KERNEL)
+#define REALLOC(a, b)   krealloc((a), (b), GFP_KERNEL)
+#define FREE kfree
+#else
+#define CALLOC          calloc
+#define MALLOC          malloc
+#define REALLOC         realloc
+#define FREE            free
+#endif
+
+/* Put *some* upper limit on bulk transfer sizes */
+#define MAX_BULK_TRANSFER_SIZE (128u * 1024u * 1024u)
+
+/* Locking convenience macros */
+#define LOCK(parser) \
+    do { \
+        if ((parser)->lock) \
+            (parser)->callb.lock_func((parser)->lock); \
+    } while (0)
+
+#define UNLOCK(parser) \
+    do { \
+        if ((parser)->lock) \
+            (parser)->callb.unlock_func((parser)->lock); \
+    } while (0)
+
+struct usbredirparser_buf {
+    uint8_t *buf;
+    int pos;
+    int len;
+
+    struct usbredirparser_buf *next;
+};
+
+struct usbredirparser_priv {
+    struct usbredirparser callb;
+    int flags;
+
+    int have_peer_caps;
+    uint32_t our_caps[USB_REDIR_CAPS_SIZE];
+    uint32_t peer_caps[USB_REDIR_CAPS_SIZE];
+
+    void *lock;
+
+    union {
+        struct usb_redir_header header;
+        struct usb_redir_header_32bit_id header_32bit_id;
+    };
+    uint8_t type_header[288];
+    int header_read;
+    int type_header_len;
+    int type_header_read;
+    uint8_t *data;
+    int data_len;
+    int data_read;
+    int to_skip;
+    struct usbredirparser_buf *write_buf;
+    int write_buf_count;
+};
+
+static void
+#if defined __GNUC__
+__attribute__((format(printf, 3, 4)))
+#endif
+va_log(struct usbredirparser_priv *parser, int verbose, const char *fmt, ...)
+{
+    char buf[512];
+    va_list ap;
+    int n;
+
+    n = sprintf(buf, "usbredirparser: ");
+    va_start(ap, fmt);
+    vsnprintf(buf + n, sizeof(buf) - n, fmt, ap);
+    va_end(ap);
+    
+    parser->callb.log_func(parser->callb.priv, verbose, buf);
+}
+
+#define ERROR(...)   va_log(parser, usbredirparser_error, __VA_ARGS__)
+#define WARNING(...) va_log(parser, usbredirparser_warning, __VA_ARGS__)
+#define INFO(...)    va_log(parser, usbredirparser_info, __VA_ARGS__)
+#define DEBUGP(...)    va_log(parser, usbredirparser_debug, __VA_ARGS__)
+
+#if 0 /* Can be enabled and called from random place to test serialization */
+static void serialize_test(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    struct usbredirparser_buf *wbuf, *next_wbuf;
+    uint8_t *data;
+    int len;
+
+    if (usbredirparser_serialize(parser_pub, &data, &len))
+        return;
+
+    wbuf = parser->write_buf;
+    while (wbuf) {
+        next_wbuf = wbuf->next;
+        FREE(wbuf->buf);
+        FREE(wbuf);
+        wbuf = next_wbuf;
+    }
+    parser->write_buf = NULL;
+    parser->write_buf_count = 0;
+
+    FREE(parser->data);
+    parser->data = NULL;
+
+    parser->type_header_len = parser->data_len = parser->have_peer_caps = 0;
+
+    usbredirparser_unserialize(parser_pub, data, len);
+    FREE(data);
+}
+#endif
+
+static void usbredirparser_queue(struct usbredirparser *parser, uint32_t type,
+    uint64_t id, void *type_header_in, uint8_t *data_in, int data_len);
+static int usbredirparser_caps_get_cap(struct usbredirparser_priv *parser,
+    uint32_t *caps, int cap);
+
+struct usbredirparser *usbredirparser_create(void)
+{
+    return CALLOC(1, sizeof(struct usbredirparser_priv));
+}
+
+static void usbredirparser_verify_caps(struct usbredirparser_priv *parser,
+    uint32_t *caps, const char *desc)
+{
+    if (usbredirparser_caps_get_cap(parser, caps,
+                                    usb_redir_cap_bulk_streams) &&
+        !usbredirparser_caps_get_cap(parser, caps,
+                                     usb_redir_cap_ep_info_max_packet_size)) {
+        ERROR("error %s caps contains cap_bulk_streams without"
+              "cap_ep_info_max_packet_size", desc);
+        caps[0] &= ~(1 << usb_redir_cap_bulk_streams);
+    }
+}
+
+void usbredirparser_init(struct usbredirparser *parser_pub,
+    const char *version, uint32_t *caps, int caps_len, int flags)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    struct usb_redir_hello_header hello = { { 0 }, };
+
+    parser->flags = (flags & ~usbredirparser_fl_no_hello);
+    if (parser->callb.alloc_lock_func) {
+        parser->lock = parser->callb.alloc_lock_func();
+    }
+
+    snprintf(hello.version, sizeof(hello.version), "%s", version);
+    if (caps_len > USB_REDIR_CAPS_SIZE) {
+        caps_len = USB_REDIR_CAPS_SIZE;
+    }
+    memcpy(parser->our_caps, caps, caps_len * sizeof(uint32_t));
+    /* libusbredirparser handles sending the ack internally */
+    if (!(flags & usbredirparser_fl_usb_host))
+        usbredirparser_caps_set_cap(parser->our_caps,
+                                    usb_redir_cap_device_disconnect_ack);
+    usbredirparser_verify_caps(parser, parser->our_caps, "our");
+    if (!(flags & usbredirparser_fl_no_hello))
+        usbredirparser_queue(parser_pub, usb_redir_hello, 0, &hello,
+                             (uint8_t *)parser->our_caps,
+                             USB_REDIR_CAPS_SIZE * sizeof(uint32_t));
+}
+
+void usbredirparser_destroy(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    struct usbredirparser_buf *wbuf, *next_wbuf;
+
+    wbuf = parser->write_buf;
+    while (wbuf) {
+        next_wbuf = wbuf->next;
+        FREE(wbuf->buf);
+        FREE(wbuf);
+        wbuf = next_wbuf;
+    }
+
+    if (parser->lock)
+        parser->callb.free_lock_func(parser->lock);
+
+    FREE(parser);
+}
+
+static int usbredirparser_caps_get_cap(struct usbredirparser_priv *parser,
+    uint32_t *caps, int cap)
+{
+    if (cap / 32 >= USB_REDIR_CAPS_SIZE) {
+        ERROR("error request for out of bounds cap: %d", cap);
+        return 0;
+    }
+    if (caps[cap / 32] & (1 << (cap % 32))) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+void usbredirparser_caps_set_cap(uint32_t *caps, int cap)
+{
+    caps[cap / 32] |= 1 << (cap % 32);
+}
+
+int usbredirparser_have_peer_caps(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+
+    return parser->have_peer_caps;
+}
+
+int usbredirparser_peer_has_cap(struct usbredirparser *parser_pub, int cap)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    return usbredirparser_caps_get_cap(parser, parser->peer_caps, cap);
+}
+
+int usbredirparser_have_cap(struct usbredirparser *parser_pub, int cap)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    return usbredirparser_caps_get_cap(parser, parser->our_caps, cap);
+}
+
+static int usbredirparser_using_32bits_ids(struct usbredirparser *parser_pub)
+{
+    return !usbredirparser_have_cap(parser_pub, usb_redir_cap_64bits_ids) ||
+           !usbredirparser_peer_has_cap(parser_pub, usb_redir_cap_64bits_ids);
+}
+
+static void usbredirparser_handle_hello(struct usbredirparser *parser_pub,
+    struct usb_redir_hello_header *hello, uint8_t *data, int data_len)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    uint32_t *peer_caps = (uint32_t *)data;
+    char buf[64];
+    int i;
+
+    if (parser->have_peer_caps) {
+        ERROR("Received second hello message, ignoring");
+        return;
+    }
+
+    /* In case hello->version is not 0 terminated (which would be a protocol
+       violation)_ */
+    snprintf(buf, sizeof(buf), "%s", hello->version);
+
+    memset(parser->peer_caps, 0, sizeof(parser->peer_caps));
+    if (data_len > sizeof(parser->peer_caps)) {
+        data_len = sizeof(parser->peer_caps);
+    }
+    for (i = 0; i < data_len / sizeof(uint32_t); i++) {
+        parser->peer_caps[i] = peer_caps[i];
+    }
+    usbredirparser_verify_caps(parser, parser->peer_caps, "peer");
+    parser->have_peer_caps = 1;
+    FREE(data);
+
+    INFO("Peer version: %s, using %d-bits ids", buf,
+         usbredirparser_using_32bits_ids(parser_pub) ? 32 : 64);
+
+    /* Added in 0.3.2, so no guarantee it is there */
+    if (parser->callb.hello_func)
+        parser->callb.hello_func(parser->callb.priv, hello);
+}
+
+static int usbredirparser_get_header_len(struct usbredirparser *parser_pub)
+{
+    if (usbredirparser_using_32bits_ids(parser_pub))
+        return sizeof(struct usb_redir_header_32bit_id);
+    else
+        return sizeof(struct usb_redir_header);
+}
+
+static int usbredirparser_get_type_header_len(
+    struct usbredirparser *parser_pub, int32_t type, int send)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    int command_for_host = 0;
+    
+    if (parser->flags & usbredirparser_fl_usb_host) {
+        command_for_host = 1;
+    }
+    if (send) {
+        command_for_host = !command_for_host;
+    }
+
+    switch (type) {
+    case usb_redir_hello:
+        return sizeof(struct usb_redir_hello_header);
+    case usb_redir_device_connect:
+        if (!command_for_host) {
+            if (usbredirparser_have_cap(parser_pub,
+                                    usb_redir_cap_connect_device_version) &&
+                usbredirparser_peer_has_cap(parser_pub,
+                                    usb_redir_cap_connect_device_version)) {
+                return sizeof(struct usb_redir_device_connect_header);
+            } else {
+                return sizeof(struct usb_redir_device_connect_header_no_device_version);
+            }
+        } else {
+            return -1;
+        }
+    case usb_redir_device_disconnect:
+        if (!command_for_host) {
+            return 0;
+        } else {
+            return -1;
+        }
+    case usb_redir_reset:
+        if (command_for_host) {
+            return 0; /* No packet type specific header */
+        } else {
+            return -1;
+        }
+    case usb_redir_interface_info:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_interface_info_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_ep_info:
+        if (!command_for_host) {
+            if (usbredirparser_have_cap(parser_pub,
+                                    usb_redir_cap_bulk_streams) &&
+                usbredirparser_peer_has_cap(parser_pub,
+                                    usb_redir_cap_bulk_streams)) {
+                return sizeof(struct usb_redir_ep_info_header);
+            } else if (usbredirparser_have_cap(parser_pub,
+                                    usb_redir_cap_ep_info_max_packet_size) &&
+                       usbredirparser_peer_has_cap(parser_pub,
+                                    usb_redir_cap_ep_info_max_packet_size)) {
+                return sizeof(struct usb_redir_ep_info_header_no_max_streams);
+            } else {
+                return sizeof(struct usb_redir_ep_info_header_no_max_pktsz);
+            }
+        } else {
+            return -1;
+        }
+    case usb_redir_set_configuration:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_set_configuration_header);
+        } else {
+            return -1; /* Should never be send to a guest */
+        }
+    case usb_redir_get_configuration:
+        if (command_for_host) {
+            return 0; /* No packet type specific header */
+        } else {
+            return -1;
+        }
+    case usb_redir_configuration_status:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_configuration_status_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_set_alt_setting:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_set_alt_setting_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_get_alt_setting:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_get_alt_setting_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_alt_setting_status:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_alt_setting_status_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_start_iso_stream:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_start_iso_stream_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_stop_iso_stream:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_stop_iso_stream_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_iso_stream_status:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_iso_stream_status_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_start_interrupt_receiving:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_start_interrupt_receiving_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_stop_interrupt_receiving:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_stop_interrupt_receiving_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_interrupt_receiving_status:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_interrupt_receiving_status_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_alloc_bulk_streams:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_alloc_bulk_streams_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_free_bulk_streams:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_free_bulk_streams_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_bulk_streams_status:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_bulk_streams_status_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_cancel_data_packet:
+        if (command_for_host) {
+            return 0; /* No packet type specific header */
+        } else {
+            return -1;
+        }
+    case usb_redir_filter_reject:
+        if (command_for_host) {
+            return 0;
+        } else {
+            return -1;
+        }
+    case usb_redir_filter_filter:
+        return 0;
+    case usb_redir_device_disconnect_ack:
+        if (command_for_host) {
+            return 0;
+        } else {
+            return -1;
+        }
+    case usb_redir_start_bulk_receiving:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_start_bulk_receiving_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_stop_bulk_receiving:
+        if (command_for_host) {
+            return sizeof(struct usb_redir_stop_bulk_receiving_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_bulk_receiving_status:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_bulk_receiving_status_header);
+        } else {
+            return -1;
+        }
+    case usb_redir_control_packet:
+        return sizeof(struct usb_redir_control_packet_header);
+    case usb_redir_bulk_packet:
+        if (usbredirparser_have_cap(parser_pub,
+                                usb_redir_cap_32bits_bulk_length) &&
+            usbredirparser_peer_has_cap(parser_pub,
+                                usb_redir_cap_32bits_bulk_length)) {
+            return sizeof(struct usb_redir_bulk_packet_header);
+        } else {
+            return sizeof(struct usb_redir_bulk_packet_header_16bit_length);
+        }
+    case usb_redir_iso_packet:
+        return sizeof(struct usb_redir_iso_packet_header);
+    case usb_redir_interrupt_packet:
+        return sizeof(struct usb_redir_interrupt_packet_header);
+    case usb_redir_buffered_bulk_packet:
+        if (!command_for_host) {
+            return sizeof(struct usb_redir_buffered_bulk_packet_header);
+        } else {
+            return -1;
+        }
+    default:
+        return -1;
+    }
+}
+
+/* Note this function only checks if extra data is allowed for the
+   packet type being read at all, a check if it is actually allowed
+   given the direction of the packet + ep is done in _erify_type_header */
+static int usbredirparser_expect_extra_data(struct usbredirparser_priv *parser)
+{
+    switch (parser->header.type) {
+    case usb_redir_hello: /* For the variable length capabilities array */
+    case usb_redir_filter_filter:
+    case usb_redir_control_packet:
+    case usb_redir_bulk_packet:
+    case usb_redir_iso_packet:
+    case usb_redir_interrupt_packet:
+    case usb_redir_buffered_bulk_packet:
+        return 1;
+    default:
+        return 0;
+    }
+}
+
+static int usbredirparser_verify_bulk_recv_cap(
+    struct usbredirparser *parser_pub, int send)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+
+    if ((send && !usbredirparser_peer_has_cap(parser_pub,
+                                              usb_redir_cap_bulk_receiving)) ||
+        (!send && !usbredirparser_have_cap(parser_pub,
+                                           usb_redir_cap_bulk_receiving))) {
+        ERROR("error bulk_receiving without cap_bulk_receiving");
+        return 0;
+    }
+    return 1; /* Verify ok */
+}
+
+static int usbredirparser_verify_type_header(
+    struct usbredirparser *parser_pub,
+    int32_t type, void *header, uint8_t *data, int data_len, int send)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    int command_for_host = 0, expect_extra_data = 0;
+    int length = 0, ep = -1;
+
+    if (parser->flags & usbredirparser_fl_usb_host) {
+        command_for_host = 1;
+    }
+    if (send) {
+        command_for_host = !command_for_host;
+    }
+
+    switch (type) {
+    case usb_redir_interface_info: {
+        struct usb_redir_interface_info_header *intf_info = header;
+
+        if (intf_info->interface_count > 32) {
+            ERROR("error interface_count > 32");
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_start_interrupt_receiving: {
+        struct usb_redir_start_interrupt_receiving_header *start_int = header;
+
+        if (!(start_int->endpoint & 0x80)) {
+            ERROR("start int receiving on non input ep %02x",
+                  start_int->endpoint);
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_stop_interrupt_receiving: {
+        struct usb_redir_stop_interrupt_receiving_header *stop_int = header;
+
+        if (!(stop_int->endpoint & 0x80)) {
+            ERROR("stop int receiving on non input ep %02x",
+                  stop_int->endpoint);
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_interrupt_receiving_status: {
+        struct usb_redir_interrupt_receiving_status_header *int_status = header;
+
+        if (!(int_status->endpoint & 0x80)) {
+            ERROR("int receiving status for non input ep %02x",
+                  int_status->endpoint);
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_filter_reject:
+        if ((send && !usbredirparser_peer_has_cap(parser_pub,
+                                             usb_redir_cap_filter)) ||
+            (!send && !usbredirparser_have_cap(parser_pub,
+                                             usb_redir_cap_filter))) {
+            ERROR("error filter_reject without cap_filter");
+            return 0;
+        }
+        break;
+    case usb_redir_filter_filter:
+        if ((send && !usbredirparser_peer_has_cap(parser_pub,
+                                             usb_redir_cap_filter)) ||
+            (!send && !usbredirparser_have_cap(parser_pub,
+                                             usb_redir_cap_filter))) {
+            ERROR("error filter_filter without cap_filter");
+            return 0;
+        }
+        if (data_len < 1) {
+            ERROR("error filter_filter without data");
+            return 0;
+        }
+        if (data[data_len - 1] != 0) {
+            ERROR("error non 0 terminated filter_filter data");
+            return 0;
+        }
+        break;
+    case usb_redir_device_disconnect_ack:
+        if ((send && !usbredirparser_peer_has_cap(parser_pub,
+                                     usb_redir_cap_device_disconnect_ack)) ||
+            (!send && !usbredirparser_have_cap(parser_pub,
+                                     usb_redir_cap_device_disconnect_ack))) {
+            ERROR("error device_disconnect_ack without cap_device_disconnect_ack");
+            return 0;
+        }
+        break;
+    case usb_redir_start_bulk_receiving: {
+        struct usb_redir_start_bulk_receiving_header *start_bulk = header;
+
+        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {
+            return 0;
+        }
+        if (start_bulk->bytes_per_transfer > MAX_BULK_TRANSFER_SIZE) {
+            ERROR("start bulk receiving length exceeds limits %u > %u",
+                  start_bulk->bytes_per_transfer, MAX_BULK_TRANSFER_SIZE);
+            return 0;
+        }
+        if (!(start_bulk->endpoint & 0x80)) {
+            ERROR("start bulk receiving on non input ep %02x",
+                  start_bulk->endpoint);
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_stop_bulk_receiving: {
+        struct usb_redir_stop_bulk_receiving_header *stop_bulk = header;
+
+        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {
+            return 0;
+        }
+        if (!(stop_bulk->endpoint & 0x80)) {
+            ERROR("stop bulk receiving on non input ep %02x",
+                  stop_bulk->endpoint);
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_bulk_receiving_status: {
+        struct usb_redir_bulk_receiving_status_header *bulk_status = header;
+
+        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {
+            return 0;
+        }
+        if (!(bulk_status->endpoint & 0x80)) {
+            ERROR("bulk receiving status for non input ep %02x",
+                  bulk_status->endpoint);
+            return 0;
+        }
+        break;
+    }
+    case usb_redir_control_packet:
+        length = ((struct usb_redir_control_packet_header *)header)->length;
+        ep = ((struct usb_redir_control_packet_header *)header)->endpoint;
+        break;
+    case usb_redir_bulk_packet: {
+        struct usb_redir_bulk_packet_header *bulk_packet = header;
+        if (usbredirparser_have_cap(parser_pub,
+                                usb_redir_cap_32bits_bulk_length) &&
+            usbredirparser_peer_has_cap(parser_pub,
+                                usb_redir_cap_32bits_bulk_length)) {
+            length = (bulk_packet->length_high << 16) | bulk_packet->length;
+        } else {
+            length = bulk_packet->length;
+            if (!send)
+                bulk_packet->length_high = 0;
+        }
+        if ((uint32_t)length > MAX_BULK_TRANSFER_SIZE) {
+            ERROR("bulk transfer length exceeds limits %u > %u",
+                  (uint32_t)length, MAX_BULK_TRANSFER_SIZE);
+            return 0;
+        }
+        ep = bulk_packet->endpoint;
+        break;
+    }
+    case usb_redir_iso_packet:
+        length = ((struct usb_redir_iso_packet_header *)header)->length;
+        ep = ((struct usb_redir_iso_packet_header *)header)->endpoint;
+        break;
+    case usb_redir_interrupt_packet:
+        length = ((struct usb_redir_interrupt_packet_header *)header)->length;
+        ep = ((struct usb_redir_interrupt_packet_header *)header)->endpoint;
+        break;
+    case usb_redir_buffered_bulk_packet: {
+        struct usb_redir_buffered_bulk_packet_header *buf_bulk_pkt = header;
+        length = buf_bulk_pkt->length;
+        if (!usbredirparser_verify_bulk_recv_cap(parser_pub, send)) {
+            return 0;
+        }
+        if ((uint32_t)length > MAX_BULK_TRANSFER_SIZE) {
+            ERROR("buffered bulk transfer length exceeds limits %u > %u",
+                  (uint32_t)length, MAX_BULK_TRANSFER_SIZE);
+            return 0;
+        }
+        ep = buf_bulk_pkt->endpoint;
+        break;
+    }
+    }
+
+    if (ep != -1) {
+        if (((ep & 0x80) && !command_for_host) ||
+            (!(ep & 0x80) && command_for_host)) {
+            expect_extra_data = 1;
+        }
+        if (expect_extra_data) {
+            if (data_len != length) {
+                ERROR("error data len %d != header len %d ep %02X",
+                      data_len, length, ep);
+                return 0;
+            }
+        } else {
+            if (data || data_len) {
+                ERROR("error unexpected extra data ep %02X", ep);
+                return 0;
+            }
+            switch (type) {
+            case usb_redir_iso_packet:
+                ERROR("error iso packet send in wrong direction");
+                return 0;
+            case usb_redir_interrupt_packet:
+                if (command_for_host) {
+                    ERROR("error interrupt packet send in wrong direction");
+                    return 0;
+                }
+                break;
+            case usb_redir_buffered_bulk_packet:
+                ERROR("error buffered bulk packet send in wrong direction");
+                return 0;
+            }
+        }
+    }
+
+    return 1; /* Verify ok */
+}
+
+static void usbredirparser_call_type_func(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    uint64_t id;
+
+    if (usbredirparser_using_32bits_ids(parser_pub))
+        id = parser->header_32bit_id.id;
+    else
+        id = parser->header.id;
+
+    switch (parser->header.type) {
+    case usb_redir_hello:
+        usbredirparser_handle_hello(parser_pub,
+            (struct usb_redir_hello_header *)parser->type_header,
+            parser->data, parser->data_len);
+        break;
+    case usb_redir_device_connect:
+        parser->callb.device_connect_func(parser->callb.priv,
+            (struct usb_redir_device_connect_header *)parser->type_header);
+        break;
+    case usb_redir_device_disconnect:
+        parser->callb.device_disconnect_func(parser->callb.priv);
+        if (usbredirparser_peer_has_cap(parser_pub,
+                                        usb_redir_cap_device_disconnect_ack))
+            usbredirparser_queue(parser_pub, usb_redir_device_disconnect_ack,
+                                 0, NULL, NULL, 0);
+        break;
+    case usb_redir_reset:
+        parser->callb.reset_func(parser->callb.priv);
+        break;
+    case usb_redir_interface_info:
+        parser->callb.interface_info_func(parser->callb.priv,
+            (struct usb_redir_interface_info_header *)parser->type_header);
+        break;
+    case usb_redir_ep_info:
+        parser->callb.ep_info_func(parser->callb.priv,
+            (struct usb_redir_ep_info_header *)parser->type_header);
+        break;
+    case usb_redir_set_configuration:
+        parser->callb.set_configuration_func(parser->callb.priv, id,
+            (struct usb_redir_set_configuration_header *)parser->type_header);
+        break;
+    case usb_redir_get_configuration:
+        parser->callb.get_configuration_func(parser->callb.priv, id);
+        break;
+    case usb_redir_configuration_status:
+        parser->callb.configuration_status_func(parser->callb.priv, id,
+          (struct usb_redir_configuration_status_header *)parser->type_header);
+        break;
+    case usb_redir_set_alt_setting:
+        parser->callb.set_alt_setting_func(parser->callb.priv, id,
+            (struct usb_redir_set_alt_setting_header *)parser->type_header);
+        break;
+    case usb_redir_get_alt_setting:
+        parser->callb.get_alt_setting_func(parser->callb.priv, id,
+            (struct usb_redir_get_alt_setting_header *)parser->type_header);
+        break;
+    case usb_redir_alt_setting_status:
+        parser->callb.alt_setting_status_func(parser->callb.priv, id,
+            (struct usb_redir_alt_setting_status_header *)parser->type_header);
+        break;
+    case usb_redir_start_iso_stream:
+        parser->callb.start_iso_stream_func(parser->callb.priv, id,
+            (struct usb_redir_start_iso_stream_header *)parser->type_header);
+        break;
+    case usb_redir_stop_iso_stream:
+        parser->callb.stop_iso_stream_func(parser->callb.priv, id,
+            (struct usb_redir_stop_iso_stream_header *)parser->type_header);
+        break;
+    case usb_redir_iso_stream_status:
+        parser->callb.iso_stream_status_func(parser->callb.priv, id,
+            (struct usb_redir_iso_stream_status_header *)parser->type_header);
+        break;
+    case usb_redir_start_interrupt_receiving:
+        parser->callb.start_interrupt_receiving_func(parser->callb.priv, id,
+            (struct usb_redir_start_interrupt_receiving_header *)
+            parser->type_header);
+        break;
+    case usb_redir_stop_interrupt_receiving:
+        parser->callb.stop_interrupt_receiving_func(parser->callb.priv, id,
+            (struct usb_redir_stop_interrupt_receiving_header *)
+            parser->type_header);
+        break;
+    case usb_redir_interrupt_receiving_status:
+        parser->callb.interrupt_receiving_status_func(parser->callb.priv, id,
+            (struct usb_redir_interrupt_receiving_status_header *)
+            parser->type_header);
+        break;
+    case usb_redir_alloc_bulk_streams:
+        parser->callb.alloc_bulk_streams_func(parser->callb.priv, id,
+            (struct usb_redir_alloc_bulk_streams_header *)parser->type_header);
+        break;
+    case usb_redir_free_bulk_streams:
+        parser->callb.free_bulk_streams_func(parser->callb.priv, id,
+            (struct usb_redir_free_bulk_streams_header *)parser->type_header);
+        break;
+    case usb_redir_bulk_streams_status:
+        parser->callb.bulk_streams_status_func(parser->callb.priv, id,
+          (struct usb_redir_bulk_streams_status_header *)parser->type_header);
+        break;
+    case usb_redir_cancel_data_packet:
+        parser->callb.cancel_data_packet_func(parser->callb.priv, id);
+        break;
+    case usb_redir_filter_reject:
+        parser->callb.filter_reject_func(parser->callb.priv);
+        break;
+    case usb_redir_filter_filter: {
+        struct usbredirfilter_rule *rules;
+        int r, count;
+
+        r = usbredirfilter_string_to_rules((char *)parser->data, ",", "|",
+                                           &rules, &count);
+        if (r) {
+            ERROR("error parsing filter (%d), ignoring filter message", r);
+            break;
+        }
+        parser->callb.filter_filter_func(parser->callb.priv, rules, count);
+        break;
+    }
+    case usb_redir_device_disconnect_ack:
+        parser->callb.device_disconnect_ack_func(parser->callb.priv);
+        break;
+    case usb_redir_start_bulk_receiving:
+        parser->callb.start_bulk_receiving_func(parser->callb.priv, id,
+            (struct usb_redir_start_bulk_receiving_header *)
+            parser->type_header);
+        break;
+    case usb_redir_stop_bulk_receiving:
+        parser->callb.stop_bulk_receiving_func(parser->callb.priv, id,
+            (struct usb_redir_stop_bulk_receiving_header *)
+            parser->type_header);
+        break;
+    case usb_redir_bulk_receiving_status:
+        parser->callb.bulk_receiving_status_func(parser->callb.priv, id,
+            (struct usb_redir_bulk_receiving_status_header *)
+            parser->type_header);
+        break;
+    case usb_redir_control_packet:
+        parser->callb.control_packet_func(parser->callb.priv, id,
+            (struct usb_redir_control_packet_header *)parser->type_header,
+            parser->data, parser->data_len);
+        break;
+    case usb_redir_bulk_packet:
+        parser->callb.bulk_packet_func(parser->callb.priv, id,
+            (struct usb_redir_bulk_packet_header *)parser->type_header,
+            parser->data, parser->data_len);
+        break;
+    case usb_redir_iso_packet:
+        parser->callb.iso_packet_func(parser->callb.priv, id,
+            (struct usb_redir_iso_packet_header *)parser->type_header,
+            parser->data, parser->data_len);
+        break;
+    case usb_redir_interrupt_packet:
+        parser->callb.interrupt_packet_func(parser->callb.priv, id,
+            (struct usb_redir_interrupt_packet_header *)parser->type_header,
+            parser->data, parser->data_len);
+        break;
+    case usb_redir_buffered_bulk_packet:
+        parser->callb.buffered_bulk_packet_func(parser->callb.priv, id,
+          (struct usb_redir_buffered_bulk_packet_header *)parser->type_header,
+          parser->data, parser->data_len);
+        break;
+    }
+}
+
+int usbredirparser_do_read(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    int r, header_len, type_header_len, data_len;
+    uint8_t *dest;
+
+    header_len = usbredirparser_get_header_len(parser_pub);
+
+    /* Skip forward to next packet (only used in error conditions) */
+    while (parser->to_skip > 0) {
+        uint8_t buf[1024];
+        r = (parser->to_skip > sizeof(buf)) ? sizeof(buf) : parser->to_skip;
+        r = parser->callb.read_func(parser->callb.priv, buf, r);
+        if (r <= 0)
+            return r;
+        parser->to_skip -= r;
+    }
+
+    /* Consume data until read would block or returns an error */
+    while (1) {
+        if (parser->header_read < header_len) {
+            r = header_len - parser->header_read;
+            dest = (uint8_t *)&parser->header + parser->header_read;
+        } else if (parser->type_header_read < parser->type_header_len) {
+            r = parser->type_header_len - parser->type_header_read;
+            dest = parser->type_header + parser->type_header_read;
+        } else {
+            r = parser->data_len - parser->data_read;
+            dest = parser->data + parser->data_read;
+        }
+
+        if (r > 0) {
+            r = parser->callb.read_func(parser->callb.priv, dest, r);
+            if (r <= 0) {
+                return r;
+            }
+        }
+
+        if (parser->header_read < header_len) {
+            parser->header_read += r;
+            if (parser->header_read == header_len) {
+                type_header_len =
+                    usbredirparser_get_type_header_len(parser_pub,
+                                                       parser->header.type, 0);
+                if (type_header_len < 0) {
+                    ERROR("error invalid usb-redir packet type: %u",
+                          parser->header.type);
+                    parser->to_skip = parser->header.length;
+                    parser->header_read = 0;
+                    return -2;
+                }
+                /* This should never happen */
+                if (type_header_len > sizeof(parser->type_header)) {
+                    ERROR("error type specific header buffer too small, please report!!");
+                    parser->to_skip = parser->header.length;
+                    parser->header_read = 0;
+                    return -2;
+                }
+                if ((int)parser->header.length < type_header_len ||
+                    ((int)parser->header.length > type_header_len &&
+                     !usbredirparser_expect_extra_data(parser))) {
+                    ERROR("error invalid packet type %u length: %u",
+                          parser->header.type, parser->header.length);
+                    parser->to_skip = parser->header.length;
+                    parser->header_read = 0;
+                    return -2;
+                }
+                data_len = parser->header.length - type_header_len;
+                if (data_len) {
+                    parser->data = MALLOC(data_len);
+                    if (!parser->data) {
+                        ERROR("Out of memory allocating data buffer");
+                        parser->to_skip = parser->header.length;
+                        parser->header_read = 0;
+                        return -2;
+                    }
+                }
+                parser->type_header_len = type_header_len;
+                parser->data_len = data_len;
+            }
+        } else if (parser->type_header_read < parser->type_header_len) {
+            parser->type_header_read += r;
+        } else {
+            parser->data_read += r;
+            if (parser->data_read == parser->data_len) {
+                r = usbredirparser_verify_type_header(parser_pub,
+                         parser->header.type, parser->type_header,
+                         parser->data, parser->data_len, 0);
+                if (r)
+                    usbredirparser_call_type_func(parser_pub);
+                parser->header_read = 0;
+                parser->type_header_len  = 0;
+                parser->type_header_read = 0;
+                parser->data_len  = 0;
+                parser->data_read = 0;
+                parser->data = NULL;
+                if (!r)
+                    return -2;
+                /* header len may change if this was an hello packet */
+                header_len = usbredirparser_get_header_len(parser_pub);
+            }
+        }
+    }
+}
+
+int usbredirparser_has_data_to_write(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    return parser->write_buf_count;
+}
+
+int usbredirparser_do_write(struct usbredirparser *parser_pub)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    struct usbredirparser_buf* wbuf;
+    int w, ret = 0;
+
+    LOCK(parser);
+    for (;;) {    
+        wbuf = parser->write_buf;
+        if (!wbuf)
+            break;
+
+        w = wbuf->len - wbuf->pos;
+        w = parser->callb.write_func(parser->callb.priv,
+                                     wbuf->buf + wbuf->pos, w);
+        if (w <= 0) {
+            ret = w;
+            break;
+        }
+
+        /* See usbredirparser_write documentation */
+        if ((parser->flags & usbredirparser_fl_write_cb_owns_buffer) &&
+                w != wbuf->len) {
+#if ! defined(__KERNEL__)
+            abort();
+#else
+            ret = -1;
+            break;
+#endif
+        }
+
+        wbuf->pos += w;
+        if (wbuf->pos == wbuf->len) {
+            parser->write_buf = wbuf->next;
+            if (!(parser->flags & usbredirparser_fl_write_cb_owns_buffer))
+                FREE(wbuf->buf);
+            FREE(wbuf);
+            parser->write_buf_count--;
+        }
+    }
+    UNLOCK(parser);
+    return ret;
+}
+
+void usbredirparser_free_write_buffer(struct usbredirparser *parser,
+    uint8_t *data)
+{
+    FREE(data);
+}
+
+void usbredirparser_free_packet_data(struct usbredirparser *parser,
+    uint8_t *data)
+{
+    FREE(data);
+}
+
+static void usbredirparser_queue(struct usbredirparser *parser_pub,
+    uint32_t type, uint64_t id, void *type_header_in,
+    uint8_t *data_in, int data_len)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    uint8_t *buf, *type_header_out, *data_out;
+    struct usb_redir_header *header;
+    struct usbredirparser_buf *wbuf, *new_wbuf;
+    int header_len, type_header_len;
+
+    header_len = usbredirparser_get_header_len(parser_pub);
+    type_header_len = usbredirparser_get_type_header_len(parser_pub, type, 1);
+    if (type_header_len < 0) { /* This should never happen */
+        ERROR("error packet type unknown with internal call, please report!!");
+        return;
+    }
+
+    if (!usbredirparser_verify_type_header(parser_pub, type, type_header_in,
+                                           data_in, data_len, 1)) {
+        ERROR("error usbredirparser_send_* call invalid params, please report!!");
+        return;
+    }
+
+    new_wbuf = CALLOC(1, sizeof(*new_wbuf));
+    buf = MALLOC(header_len + type_header_len + data_len);
+    if (!new_wbuf || !buf) {
+        ERROR("Out of memory allocating buffer to send packet, dropping!");
+        FREE(new_wbuf); FREE(buf);
+        return;
+    }
+
+    new_wbuf->buf = buf;
+    new_wbuf->len = header_len + type_header_len + data_len;
+
+    header = (struct usb_redir_header *)buf;
+    type_header_out = buf + header_len;
+    data_out = type_header_out + type_header_len;
+
+    header->type   = type;
+    header->length = type_header_len + data_len;
+    if (usbredirparser_using_32bits_ids(parser_pub))
+        ((struct usb_redir_header_32bit_id *)header)->id = id;
+    else
+        header->id = id;
+    memcpy(type_header_out, type_header_in, type_header_len);
+    memcpy(data_out, data_in, data_len);
+
+    LOCK(parser);
+    if (!parser->write_buf) {
+        parser->write_buf = new_wbuf;
+    } else {
+        /* limiting the write_buf's stack depth is our users responsibility */
+        wbuf = parser->write_buf;
+        while (wbuf->next)
+            wbuf = wbuf->next;
+
+        wbuf->next = new_wbuf;
+    }
+    parser->write_buf_count++;
+    UNLOCK(parser);
+}
+
+void usbredirparser_send_device_connect(struct usbredirparser *parser,
+    struct usb_redir_device_connect_header *device_connect)
+{
+    usbredirparser_queue(parser, usb_redir_device_connect, 0, device_connect,
+                         NULL, 0);
+}
+
+void usbredirparser_send_device_disconnect(struct usbredirparser *parser)
+{
+    usbredirparser_queue(parser, usb_redir_device_disconnect, 0, NULL,
+                         NULL, 0);
+}
+
+void usbredirparser_send_reset(struct usbredirparser *parser)
+{
+    usbredirparser_queue(parser, usb_redir_reset, 0, NULL, NULL, 0);
+}
+
+void usbredirparser_send_interface_info(struct usbredirparser *parser,
+    struct usb_redir_interface_info_header *interface_info)
+{
+    usbredirparser_queue(parser, usb_redir_interface_info, 0, interface_info,
+                         NULL, 0);
+}
+
+void usbredirparser_send_ep_info(struct usbredirparser *parser,
+    struct usb_redir_ep_info_header *ep_info)
+{
+    usbredirparser_queue(parser, usb_redir_ep_info, 0, ep_info, NULL, 0);
+}
+
+void usbredirparser_send_set_configuration(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_set_configuration_header *set_configuration)
+{
+    usbredirparser_queue(parser, usb_redir_set_configuration, id,
+                         set_configuration, NULL, 0);
+}
+
+void usbredirparser_send_get_configuration(struct usbredirparser *parser,
+    uint64_t id)
+{
+    usbredirparser_queue(parser, usb_redir_get_configuration, id,
+                         NULL, NULL, 0);
+}
+
+void usbredirparser_send_configuration_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_configuration_status_header *configuration_status)
+{
+    usbredirparser_queue(parser, usb_redir_configuration_status, id,
+                         configuration_status, NULL, 0);
+}
+
+void usbredirparser_send_set_alt_setting(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_set_alt_setting_header *set_alt_setting)
+{
+    usbredirparser_queue(parser, usb_redir_set_alt_setting, id,
+                         set_alt_setting, NULL, 0);
+}
+
+void usbredirparser_send_get_alt_setting(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_get_alt_setting_header *get_alt_setting)
+{
+    usbredirparser_queue(parser, usb_redir_get_alt_setting, id,
+                         get_alt_setting, NULL, 0);
+}
+
+void usbredirparser_send_alt_setting_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_alt_setting_status_header *alt_setting_status)
+{
+    usbredirparser_queue(parser, usb_redir_alt_setting_status, id,
+                         alt_setting_status, NULL, 0);
+}
+
+void usbredirparser_send_start_iso_stream(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_iso_stream_header *start_iso_stream)
+{
+    usbredirparser_queue(parser, usb_redir_start_iso_stream, id,
+                         start_iso_stream, NULL, 0);
+}
+
+void usbredirparser_send_stop_iso_stream(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_iso_stream_header *stop_iso_stream)
+{
+    usbredirparser_queue(parser, usb_redir_stop_iso_stream, id,
+                         stop_iso_stream, NULL, 0);
+}
+
+void usbredirparser_send_iso_stream_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_iso_stream_status_header *iso_stream_status)
+{
+    usbredirparser_queue(parser, usb_redir_iso_stream_status, id,
+                         iso_stream_status, NULL, 0);
+}
+
+void usbredirparser_send_start_interrupt_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_interrupt_receiving_header *start_interrupt_receiving)
+{
+    usbredirparser_queue(parser, usb_redir_start_interrupt_receiving, id,
+                         start_interrupt_receiving, NULL, 0);
+}
+
+void usbredirparser_send_stop_interrupt_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_interrupt_receiving_header *stop_interrupt_receiving)
+{
+    usbredirparser_queue(parser, usb_redir_stop_interrupt_receiving, id,
+                         stop_interrupt_receiving, NULL, 0);
+}
+
+void usbredirparser_send_interrupt_receiving_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_interrupt_receiving_status_header *interrupt_receiving_status)
+{
+    usbredirparser_queue(parser, usb_redir_interrupt_receiving_status, id,
+                         interrupt_receiving_status, NULL, 0);
+}
+
+void usbredirparser_send_alloc_bulk_streams(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_alloc_bulk_streams_header *alloc_bulk_streams)
+{
+    usbredirparser_queue(parser, usb_redir_alloc_bulk_streams, id,
+                         alloc_bulk_streams, NULL, 0);
+}
+
+void usbredirparser_send_free_bulk_streams(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_free_bulk_streams_header *free_bulk_streams)
+{
+    usbredirparser_queue(parser, usb_redir_free_bulk_streams, id,
+                         free_bulk_streams, NULL, 0);
+}
+
+void usbredirparser_send_bulk_streams_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_streams_status_header *bulk_streams_status)
+{
+    usbredirparser_queue(parser, usb_redir_bulk_streams_status, id,
+                         bulk_streams_status, NULL, 0);
+}
+
+void usbredirparser_send_cancel_data_packet(struct usbredirparser *parser,
+    uint64_t id)
+{
+    usbredirparser_queue(parser, usb_redir_cancel_data_packet, id,
+                         NULL, NULL, 0);
+}
+
+void usbredirparser_send_filter_reject(struct usbredirparser *parser)
+{
+    if (!usbredirparser_peer_has_cap(parser, usb_redir_cap_filter))
+        return;
+
+    usbredirparser_queue(parser, usb_redir_filter_reject, 0, NULL, NULL, 0);
+}
+
+void usbredirparser_send_filter_filter(struct usbredirparser *parser_pub,
+    const struct usbredirfilter_rule *rules, int rules_count)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    char *str;
+
+    if (!usbredirparser_peer_has_cap(parser_pub, usb_redir_cap_filter))
+        return;
+
+    str = usbredirfilter_rules_to_string(rules, rules_count, ",", "|");
+    if (!str) {
+        ERROR("error creating filter string, not sending filter");
+        return;
+    }
+    usbredirparser_queue(parser_pub, usb_redir_filter_filter, 0, NULL,
+                         (uint8_t *)str, strlen(str) + 1);
+    FREE(str);
+}
+
+void usbredirparser_send_start_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_bulk_receiving_header *start_bulk_receiving)
+{
+    usbredirparser_queue(parser, usb_redir_start_bulk_receiving, id,
+                         start_bulk_receiving, NULL, 0);
+}
+
+void usbredirparser_send_stop_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving)
+{
+    usbredirparser_queue(parser, usb_redir_stop_bulk_receiving, id,
+                         stop_bulk_receiving, NULL, 0);
+}
+
+void usbredirparser_send_bulk_receiving_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status)
+{
+    usbredirparser_queue(parser, usb_redir_bulk_receiving_status, id,
+                         bulk_receiving_status, NULL, 0);
+}
+
+/* Data packets: */
+void usbredirparser_send_control_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_control_packet_header *control_header,
+    uint8_t *data, int data_len)
+{
+    usbredirparser_queue(parser, usb_redir_control_packet, id, control_header,
+                         data, data_len);
+}
+
+void usbredirparser_send_bulk_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_packet_header *bulk_header,
+    uint8_t *data, int data_len)
+{
+    usbredirparser_queue(parser, usb_redir_bulk_packet, id, bulk_header,
+                         data, data_len);
+}
+
+void usbredirparser_send_iso_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_iso_packet_header *iso_header,
+    uint8_t *data, int data_len)
+{
+    usbredirparser_queue(parser, usb_redir_iso_packet, id, iso_header,
+                         data, data_len);
+}
+
+void usbredirparser_send_interrupt_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_interrupt_packet_header *interrupt_header,
+    uint8_t *data, int data_len)
+{
+    usbredirparser_queue(parser, usb_redir_interrupt_packet, id,
+                         interrupt_header, data, data_len);
+}
+
+void usbredirparser_send_buffered_bulk_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+    uint8_t *data, int data_len)
+{
+    usbredirparser_queue(parser, usb_redir_buffered_bulk_packet, id,
+                         buffered_bulk_header, data, data_len);
+}
+
+/****** Serialization support ******/
+
+#define USBREDIRPARSER_SERIALIZE_MAGIC        0x55525031
+#define USBREDIRPARSER_SERIALIZE_BUF_SIZE     65536
+
+/* Serialization format, send and receiving endian are expected to be the same!
+    uint32 MAGIC: 0x55525031 ascii: URP1 (UsbRedirParser version 1)
+    uint32 len: length of the entire serialized state, including MAGIC
+    uint32 our_caps_len
+    uint32 our_caps[our_caps_len]
+    uint32 peer_caps_len
+    uint32 peer_caps[peer_caps_len]
+    uint32 to_skip
+    uint32 header_read
+    uint8  header[header_read]
+    uint32 type_header_read
+    uint8  type_header[type_header_read]
+    uint32 data_read
+    uint8  data[data_read]
+    uint32 write_buf_count: followed by write_buf_count times:
+        uint32 write_buf_len
+        uint8  write_buf_data[write_buf_len]
+*/
+
+static int serialize_alloc(struct usbredirparser_priv *parser,
+                           uint8_t **state, uint8_t **pos,
+                           uint32_t *remain, uint32_t needed)
+{
+    uint8_t *old_state = *state;
+    uint32_t used, size;
+
+    if (*remain >= needed)
+        return 0;
+
+    used = *pos - *state;
+    size = (used + needed + USBREDIRPARSER_SERIALIZE_BUF_SIZE - 1) &
+           ~(USBREDIRPARSER_SERIALIZE_BUF_SIZE - 1);
+
+    *state = REALLOC(*state, size);
+    if (!*state) {
+        FREE(old_state);
+        ERROR("Out of memory allocating serialization buffer");
+        return -1;
+    }
+
+    *pos = *state + used;
+    *remain = size - used;
+
+    return 0;
+}
+
+static int serialize_int(struct usbredirparser_priv *parser,
+                         uint8_t **state, uint8_t **pos, uint32_t *remain,
+                         uint32_t val, const char *desc)
+{
+    DEBUGP("serializing int %08x : %s", val, desc);
+
+    if (serialize_alloc(parser, state, pos, remain, sizeof(uint32_t)))
+        return -1;
+
+    memcpy(*pos, &val, sizeof(uint32_t));
+    *pos += sizeof(uint32_t);
+    *remain -= sizeof(uint32_t);
+
+    return 0;
+}
+
+static int unserialize_int(struct usbredirparser_priv *parser,
+                           uint8_t **pos, uint32_t *remain, uint32_t *val,
+                           const char *desc)
+{
+    if (*remain < sizeof(uint32_t)) {
+        ERROR("error buffer underrun while unserializing state");
+        return -1;
+    }
+    memcpy(val, *pos, sizeof(uint32_t));
+    *pos += sizeof(uint32_t);
+    *remain -= sizeof(uint32_t);
+
+    DEBUGP("unserialized int %08x : %s", *val, desc);
+
+    return 0;
+}
+
+static int serialize_data(struct usbredirparser_priv *parser,
+                          uint8_t **state, uint8_t **pos, uint32_t *remain,
+                          uint8_t *data, uint32_t len, const char *desc)
+{
+    DEBUGP("serializing %d bytes of %s data", len, desc);
+    if (len >= 8)
+        DEBUGP("First 8 bytes of %s: %02x %02x %02x %02x %02x %02x %02x %02x",
+              desc, data[0], data[1], data[2], data[3],
+                    data[4], data[5], data[6], data[7]);
+
+    if (serialize_alloc(parser, state, pos, remain, sizeof(uint32_t) + len))
+        return -1;
+
+    memcpy(*pos, &len, sizeof(uint32_t));
+    *pos += sizeof(uint32_t);
+    *remain -= sizeof(uint32_t);
+
+    memcpy(*pos, data, len);
+    *pos += len;
+    *remain -= len;
+
+    return 0;
+}
+
+/* If *data == NULL, allocs buffer dynamically, else len_in_out must contain
+   the length of the passed in buffer. */
+static int unserialize_data(struct usbredirparser_priv *parser,
+                            uint8_t **pos, uint32_t *remain,
+                            uint8_t **data, uint32_t *len_in_out,
+                            const char *desc)
+{
+    uint32_t len;
+
+    if (*remain < sizeof(uint32_t)) {
+        ERROR("error buffer underrun while unserializing state");
+        return -1;
+    }
+    memcpy(&len, *pos, sizeof(uint32_t));
+    *pos += sizeof(uint32_t);
+    *remain -= sizeof(uint32_t);
+
+    if (*remain < len) {
+        ERROR("error buffer underrun while unserializing state");
+        return -1;
+    }
+    if (*data == NULL && len > 0) {
+        *data = MALLOC(len);
+        if (!*data) {
+            ERROR("Out of memory allocating unserialize buffer");
+            return -1;
+        }
+    } else {
+        if (*len_in_out < len) {
+            ERROR("error buffer overrun while unserializing state");
+            return -1;
+        }
+    }
+
+    memcpy(*data, *pos, len);
+    *pos += len;
+    *remain -= len;
+    *len_in_out = len;
+
+    DEBUGP("unserialized %d bytes of %s data", len, desc);
+    if (len >= 8)
+        DEBUGP("First 8 bytes of %s: %02x %02x %02x %02x %02x %02x %02x %02x",
+              desc, (*data)[0], (*data)[1], (*data)[2], (*data)[3],
+              (*data)[4], (*data)[5], (*data)[6], (*data)[7]);
+
+    return 0;
+}
+
+int usbredirparser_serialize(struct usbredirparser *parser_pub,
+                             uint8_t **state_dest, int *state_len)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    struct usbredirparser_buf *wbuf;
+    uint8_t *write_buf_count_pos, *state = NULL, *pos = NULL;
+    uint32_t write_buf_count = 0, len, remain = 0;
+
+    *state_dest = NULL;
+    *state_len = 0;
+
+    if (serialize_int(parser, &state, &pos, &remain,
+                                   USBREDIRPARSER_SERIALIZE_MAGIC, "magic"))
+        return -1;
+
+    /* To be replaced with length later */
+    if (serialize_int(parser, &state, &pos, &remain, 0, "length"))
+        return -1;
+
+    if (serialize_data(parser, &state, &pos, &remain,
+                       (uint8_t *)parser->our_caps,
+                       USB_REDIR_CAPS_SIZE * sizeof(int32_t), "our_caps"))
+        return -1;
+
+    if (parser->have_peer_caps) {
+        if (serialize_data(parser, &state, &pos, &remain,
+                           (uint8_t *)parser->peer_caps,
+                           USB_REDIR_CAPS_SIZE * sizeof(int32_t), "peer_caps"))
+            return -1;
+    } else {
+        if (serialize_int(parser, &state, &pos, &remain, 0, "peer_caps_len"))
+            return -1;
+    }
+
+    if (serialize_int(parser, &state, &pos, &remain, parser->to_skip, "skip"))
+        return -1;
+
+    if (serialize_data(parser, &state, &pos, &remain,
+                       (uint8_t *)&parser->header, parser->header_read,
+                       "header"))
+        return -1;
+
+    if (serialize_data(parser, &state, &pos, &remain,
+                       parser->type_header, parser->type_header_read,
+                       "type_header"))
+        return -1;
+
+    if (serialize_data(parser, &state, &pos, &remain,
+                       parser->data, parser->data_read, "packet-data"))
+        return -1;
+
+    write_buf_count_pos = pos;
+    /* To be replaced with write_buf_count later */
+    if (serialize_int(parser, &state, &pos, &remain, 0, "write_buf_count"))
+        return -1;
+
+    wbuf = parser->write_buf;
+    while (wbuf) {
+        if (serialize_data(parser, &state, &pos, &remain,
+                           wbuf->buf + wbuf->pos, wbuf->len - wbuf->pos,
+                           "write-buf"))
+            return -1;
+        write_buf_count++;
+        wbuf = wbuf->next;
+    }
+    /* Patch in write_buf_count */
+    memcpy(write_buf_count_pos, &write_buf_count, sizeof(int32_t));
+
+    /* Patch in length */
+    len = pos - state;
+    memcpy(state + sizeof(int32_t), &len, sizeof(int32_t));
+
+    *state_dest = state;
+    *state_len = len;
+
+    return 0;
+}
+
+int usbredirparser_unserialize(struct usbredirparser *parser_pub,
+                               uint8_t *state, int len)
+{
+    struct usbredirparser_priv *parser =
+        (struct usbredirparser_priv *)parser_pub;
+    struct usbredirparser_buf *wbuf, **next;
+    uint32_t orig_caps[USB_REDIR_CAPS_SIZE];
+    uint8_t *data;
+    uint32_t i, l, header_len, remain = len;
+
+    if (unserialize_int(parser, &state, &remain, &i, "magic"))
+        return -1;
+    if (i != USBREDIRPARSER_SERIALIZE_MAGIC) {
+        ERROR("error unserialize magic mismatch");
+        return -1;
+    }
+
+    if (unserialize_int(parser, &state, &remain, &i, "length"))
+        return -1;
+    if (i != len) {
+        ERROR("error unserialize length mismatch");
+        return -1;
+    }
+
+    data = (uint8_t *)parser->our_caps;
+    i = USB_REDIR_CAPS_SIZE * sizeof(int32_t);
+    memcpy(orig_caps, parser->our_caps, i);
+    if (unserialize_data(parser, &state, &remain, &data, &i, "our_caps"))
+        return -1;
+    if (memcmp(parser->our_caps, orig_caps,
+               USB_REDIR_CAPS_SIZE * sizeof(int32_t)) != 0) {
+        ERROR("error unserialize caps mismatch");
+        return -1;
+    }
+
+    data = (uint8_t *)parser->peer_caps;
+    i = USB_REDIR_CAPS_SIZE * sizeof(int32_t);
+    if (unserialize_data(parser, &state, &remain, &data, &i, "peer_caps"))
+        return -1;
+    if (i)
+        parser->have_peer_caps = 1;
+
+    if (unserialize_int(parser, &state, &remain, &i, "skip"))
+        return -1;
+    parser->to_skip = i;
+
+    header_len = usbredirparser_get_header_len(parser_pub);
+    data = (uint8_t *)&parser->header;
+    i = header_len;
+    if (unserialize_data(parser, &state, &remain, &data, &i, "header"))
+        return -1;
+    parser->header_read = i;
+
+    /* Set various length field froms the header (if we've a header) */
+    if (parser->header_read == header_len) {
+                int type_header_len =
+                    usbredirparser_get_type_header_len(parser_pub,
+                                                       parser->header.type, 0);
+                if (type_header_len < 0 || 
+                    type_header_len > sizeof(parser->type_header) || 
+                    parser->header.length < type_header_len ||
+                    (parser->header.length > type_header_len &&
+                     !usbredirparser_expect_extra_data(parser))) {
+                    ERROR("error unserialize packet header invalid");
+                    return -1;
+                }
+                parser->type_header_len = type_header_len;
+                parser->data_len = parser->header.length - type_header_len;
+    }
+
+    data = parser->type_header;
+    i = parser->type_header_len;
+    if (unserialize_data(parser, &state, &remain, &data, &i, "type_header"))
+        return -1;
+    parser->type_header_read = i;
+
+    if (parser->data_len) {
+        parser->data = MALLOC(parser->data_len);
+        if (!parser->data) {
+            ERROR("Out of memory allocating unserialize buffer");
+            return -1;
+        }
+    }
+    i = parser->data_len;
+    if (unserialize_data(parser, &state, &remain, &parser->data, &i, "data"))
+        return -1;
+    parser->data_read = i;
+
+    /* Get the write buffer count and the write buffers */
+    if (unserialize_int(parser, &state, &remain, &i, "write_buf_count"))
+        return -1;
+    next = &parser->write_buf;
+    while (i) {
+        wbuf = CALLOC(1, sizeof(*wbuf));
+        if (!wbuf) {
+            ERROR("Out of memory allocating unserialize buffer");
+            return -1;
+        }
+        *next = wbuf;
+        l = 0;
+        if (unserialize_data(parser, &state, &remain, &wbuf->buf, &l, "wbuf"))
+            return -1;
+        wbuf->len = l;
+        next = &wbuf->next;
+        i--;
+    }
+
+    if (remain) {
+        ERROR("error unserialize %d bytes of extraneous state data", remain);
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/drivers/usb/usbredir/usbredirparser.h b/drivers/usb/usbredir/usbredirparser.h
new file mode 100644
index 0000000..ffeb1d7
--- /dev/null
+++ b/drivers/usb/usbredir/usbredirparser.h
@@ -0,0 +1,386 @@
+/* usbredirparser.h usb redirection protocol parser header
+
+   Copyright 2010-2012 Red Hat, Inc.
+
+   Red Hat Authors:
+   Hans de Goede <hdegoede@xxxxxxxxxx>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef __USBREDIRPARSER_H
+#define __USBREDIRPARSER_H
+
+#include "usbredirproto.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct usbredirparser;
+struct usbredirfilter_rule;
+
+/* Called by a usbredirparser to log various messages */
+enum { usbredirparser_none, usbredirparser_error, usbredirparser_warning,
+       usbredirparser_info, usbredirparser_debug, usbredirparser_debug_data };
+typedef void (*usbredirparser_log)(void *priv, int level, const char *msg);
+
+/* Called by a usbredirparser to read/write data to its peer.
+   Must return the amount of bytes read/written, 0 when the read/write would
+   block (and this is undesirable) and -1 on error.
+
+   If the usbredirparser_fl_write_cb_owns_buffer flag is passed to
+   usbredirparser_init, then the usbredirparser_write callback becomes
+   the owner of the buffer pointed to by data and should call
+   usbredirparser_free_write_buffer() when it is done with the buffer.
+   In this case the callback is not allowed to return any amount of bytes
+   written, it must either accept the entire buffer (return count),
+   or signal blocking (return 0) or error (return -1). Returning any other
+   value will result in a call to abort().
+*/
+typedef int (*usbredirparser_read)(void *priv, uint8_t *data, int count);
+typedef int (*usbredirparser_write)(void *priv, uint8_t *data, int count);
+
+/* Locking functions for use by multithread apps */
+typedef void *(*usbredirparser_alloc_lock)(void);
+typedef void (*usbredirparser_lock)(void *lock);
+typedef void (*usbredirparser_unlock)(void *lock);
+typedef void (*usbredirparser_free_lock)(void *lock);
+
+/* The below callbacks are called when a complete packet of the relevant
+   type has been received.
+
+   Note that the passed in packet-type-specific-header's lifetime is only
+   guarenteed to be that of the callback.
+
+   Control packets: */
+typedef void (*usbredirparser_hello)(void *priv,
+    struct usb_redir_hello_header *hello);
+typedef void (*usbredirparser_device_connect)(void *priv,
+    struct usb_redir_device_connect_header *device_connect);
+typedef void (*usbredirparser_device_disconnect)(void *priv);
+typedef void (*usbredirparser_reset)(void *priv);
+typedef void (*usbredirparser_interface_info)(void *priv,
+    struct usb_redir_interface_info_header *interface_info);
+typedef void (*usbredirparser_ep_info)(void *priv,
+    struct usb_redir_ep_info_header *ep_info);
+typedef void (*usbredirparser_set_configuration)(void *priv,
+    uint64_t id, struct usb_redir_set_configuration_header *set_configuration);
+typedef void (*usbredirparser_get_configuration)(void *priv, uint64_t id);
+typedef void (*usbredirparser_configuration_status)(void *priv,
+    uint64_t id, struct usb_redir_configuration_status_header *configuration_status);
+typedef void (*usbredirparser_set_alt_setting)(void *priv,
+    uint64_t id, struct usb_redir_set_alt_setting_header *set_alt_setting);
+typedef void (*usbredirparser_get_alt_setting)(void *priv,
+    uint64_t id, struct usb_redir_get_alt_setting_header *get_alt_setting);
+typedef void (*usbredirparser_alt_setting_status)(void *priv,
+    uint64_t id, struct usb_redir_alt_setting_status_header *alt_setting_status);
+typedef void (*usbredirparser_start_iso_stream)(void *priv,
+    uint64_t id, struct usb_redir_start_iso_stream_header *start_iso_stream);
+typedef void (*usbredirparser_stop_iso_stream)(void *priv,
+    uint64_t id, struct usb_redir_stop_iso_stream_header *stop_iso_stream);
+typedef void (*usbredirparser_iso_stream_status)(void *priv,
+    uint64_t id, struct usb_redir_iso_stream_status_header *iso_stream_status);
+typedef void (*usbredirparser_start_interrupt_receiving)(void *priv,
+    uint64_t id, struct usb_redir_start_interrupt_receiving_header *start_interrupt_receiving);
+typedef void (*usbredirparser_stop_interrupt_receiving)(void *priv,
+    uint64_t id, struct usb_redir_stop_interrupt_receiving_header *stop_interrupt_receiving);
+typedef void (*usbredirparser_interrupt_receiving_status)(void *priv,
+    uint64_t id, struct usb_redir_interrupt_receiving_status_header *interrupt_receiving_status);
+typedef void (*usbredirparser_alloc_bulk_streams)(void *priv,
+    uint64_t id, struct usb_redir_alloc_bulk_streams_header *alloc_bulk_streams);
+typedef void (*usbredirparser_free_bulk_streams)(void *priv,
+    uint64_t id, struct usb_redir_free_bulk_streams_header *free_bulk_streams);
+typedef void (*usbredirparser_bulk_streams_status)(void *priv,
+    uint64_t id, struct usb_redir_bulk_streams_status_header *bulk_streams_status);
+typedef void (*usbredirparser_cancel_data_packet)(void *priv, uint64_t id);
+typedef void (*usbredirparser_filter_reject)(void *priv);
+/* Note that the ownership of the rules array is passed on to the callback. */
+typedef void (*usbredirparser_filter_filter)(void *priv,
+    struct usbredirfilter_rule *rules, int rules_count);
+typedef void (*usbredirparser_device_disconnect_ack)(void *priv);
+typedef void (*usbredirparser_start_bulk_receiving)(void *priv,
+    uint64_t id, struct usb_redir_start_bulk_receiving_header *start_bulk_receiving);
+typedef void (*usbredirparser_stop_bulk_receiving)(void *priv,
+    uint64_t id, struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving);
+typedef void (*usbredirparser_bulk_receiving_status)(void *priv,
+    uint64_t id, struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
+
+/* Data packets:
+
+   Note that ownership of the the data buffer (if not NULL) is passed on to
+   the callback. The callback should free it by calling
+   usbredirparser_free_packet_data when it is done with it. */
+typedef void (*usbredirparser_control_packet)(void *priv,
+    uint64_t id, struct usb_redir_control_packet_header *control_header,
+    uint8_t *data, int data_len);
+typedef void (*usbredirparser_bulk_packet)(void *priv,
+    uint64_t id, struct usb_redir_bulk_packet_header *bulk_header,
+    uint8_t *data, int data_len);
+typedef void (*usbredirparser_iso_packet)(void *priv,
+    uint64_t id, struct usb_redir_iso_packet_header *iso_header,
+    uint8_t *data, int data_len);
+typedef void (*usbredirparser_interrupt_packet)(void *priv,
+    uint64_t id, struct usb_redir_interrupt_packet_header *interrupt_header,
+    uint8_t *data, int data_len);
+typedef void (*usbredirparser_buffered_bulk_packet)(void *priv, uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+    uint8_t *data, int data_len);
+
+
+/* Public part of the data allocated by usbredirparser_alloc, *never* allocate
+   a usbredirparser struct yourself, it may be extended in the future to add
+   callbacks for new packet types (which will then get added at the end),
+   *and* usbredirparser_alloc will also alloc some space behind it for
+   private data */
+struct usbredirparser {
+    /* app private data passed into all callbacks as the priv argument */
+    void *priv;
+    /* non packet callbacks */
+    usbredirparser_log log_func;
+    usbredirparser_read read_func;
+    usbredirparser_write write_func;
+    /* usb-redir-protocol v0.3 control packet complete callbacks */
+    usbredirparser_device_connect device_connect_func;
+    usbredirparser_device_disconnect device_disconnect_func;
+    usbredirparser_reset reset_func;
+    usbredirparser_interface_info interface_info_func;
+    usbredirparser_ep_info ep_info_func;
+    usbredirparser_set_configuration set_configuration_func;
+    usbredirparser_get_configuration get_configuration_func;
+    usbredirparser_configuration_status configuration_status_func;
+    usbredirparser_set_alt_setting set_alt_setting_func;
+    usbredirparser_get_alt_setting get_alt_setting_func;
+    usbredirparser_alt_setting_status alt_setting_status_func;
+    usbredirparser_start_iso_stream start_iso_stream_func;
+    usbredirparser_stop_iso_stream stop_iso_stream_func;
+    usbredirparser_iso_stream_status iso_stream_status_func;
+    usbredirparser_start_interrupt_receiving start_interrupt_receiving_func;
+    usbredirparser_stop_interrupt_receiving stop_interrupt_receiving_func;
+    usbredirparser_interrupt_receiving_status interrupt_receiving_status_func;
+    usbredirparser_alloc_bulk_streams alloc_bulk_streams_func;
+    usbredirparser_free_bulk_streams free_bulk_streams_func;
+    usbredirparser_bulk_streams_status bulk_streams_status_func;
+    usbredirparser_cancel_data_packet cancel_data_packet_func;
+    /* usb-redir-protocol v0.3 data packet complete callbacks */
+    usbredirparser_control_packet control_packet_func;
+    usbredirparser_bulk_packet bulk_packet_func;
+    usbredirparser_iso_packet iso_packet_func;
+    usbredirparser_interrupt_packet interrupt_packet_func;
+    /* usbredir 0.3.2 new non packet callbacks (for multi-thread locking) */
+    usbredirparser_alloc_lock alloc_lock_func;
+    usbredirparser_lock lock_func;
+    usbredirparser_unlock unlock_func;
+    usbredirparser_free_lock free_lock_func;
+    /* usbredir 0.3.2 new control packet complete callbacks */
+    usbredirparser_hello hello_func;
+    /* usbredir 0.4 new control packet complete callbacks */
+    usbredirparser_filter_reject filter_reject_func;
+    usbredirparser_filter_filter filter_filter_func;
+    usbredirparser_device_disconnect_ack device_disconnect_ack_func;
+    /* usbredir 0.6 new control packet complete callbacks */
+    usbredirparser_start_bulk_receiving start_bulk_receiving_func;
+    usbredirparser_stop_bulk_receiving stop_bulk_receiving_func;
+    usbredirparser_bulk_receiving_status bulk_receiving_status_func;
+    /* usbredir 0.6 new data packet complete callbacks */
+    usbredirparser_buffered_bulk_packet buffered_bulk_packet_func;
+};
+
+/* Allocate a usbredirparser, after this the app should set the callback app
+   private data and all the callbacks it needs, before calling
+   usbredirparser_init */
+struct usbredirparser *usbredirparser_create(void);
+
+/* Set capability cap in the USB_REDIR_CAPS_SIZE sized caps array,
+   this is a helper function to set capabilities in the caps array
+   passed to usbredirparser_init(). */
+void usbredirparser_caps_set_cap(uint32_t *caps, int cap);
+
+/* Init the parser, this will queue an initial usb_redir_hello packet,
+   sending the version and caps to the peer, as well as configure the parsing
+   according to the passed in flags. */
+enum {
+    usbredirparser_fl_usb_host = 0x01,
+    usbredirparser_fl_write_cb_owns_buffer = 0x02,
+    usbredirparser_fl_no_hello = 0x04,
+};
+
+void usbredirparser_init(struct usbredirparser *parser,
+    const char *version, uint32_t *caps, int caps_len, int flags);
+
+void usbredirparser_destroy(struct usbredirparser *parser);
+
+/* See if our side has a certain cap (checks the caps passed into _init) */
+int usbredirparser_have_cap(struct usbredirparser *parser, int cap);
+
+/* Check if we've received the caps from the peer */
+int usbredirparser_have_peer_caps(struct usbredirparser *parser);
+
+/* Check if our peer has a certain capability. Note this function
+   should not be used before the hello_func callback has been called. */
+int usbredirparser_peer_has_cap(struct usbredirparser *parser, int cap);
+
+/* Call this whenever there is data ready from the otherside to parse
+   On an usbredirparser_read_io_error this function will continue where it
+   left of the last time on the next call. On an
+   usbredirparser_read_parse_error it will skip to the next packet (*).
+   *) As determined by the faulty's package headers length field */
+enum {
+    usbredirparser_read_io_error    = -1,
+    usbredirparser_read_parse_error = -2,
+};
+int usbredirparser_do_read(struct usbredirparser *parser);
+
+/* This returns the number of usbredir packets queued up for writing */
+int usbredirparser_has_data_to_write(struct usbredirparser *parser);
+
+/* Call this when usbredirparser_has_data_to_write returns > 0
+   returns 0 on success, -1 if a write error happened.
+   If a write error happened, this function will retry writing any queued data
+   on the next call, and will continue doing so until it has succeeded! */
+enum {
+    usbredirparser_write_io_error   = -1,
+};
+int usbredirparser_do_write(struct usbredirparser *parser);
+
+/* See usbredirparser_write documentation */
+void usbredirparser_free_write_buffer(struct usbredirparser *parser,
+    uint8_t *data);
+
+/* See the data packet callbacks documentation */
+void usbredirparser_free_packet_data(struct usbredirparser *parser,
+    uint8_t *data);
+
+/* Functions to marshall and queue a packet for sending to its peer. Note:
+   1) it will not be actually send until usbredirparser_do_write is called
+   2) if their is not enough memory for buffers the packet will be dropped
+      (and an error message will be logged */
+/* Control packets: */
+
+/* Note this function should not be used before the hello_func callback has
+   been called (as it checks the usb_redir_cap_connect_device_version cap). */
+void usbredirparser_send_device_connect(struct usbredirparser *parser,
+    struct usb_redir_device_connect_header *device_connect);
+void usbredirparser_send_device_disconnect(struct usbredirparser *parser);
+void usbredirparser_send_reset(struct usbredirparser *parser);
+void usbredirparser_send_interface_info(struct usbredirparser *parser,
+    struct usb_redir_interface_info_header *interface_info);
+void usbredirparser_send_ep_info(struct usbredirparser *parser,
+    struct usb_redir_ep_info_header *ep_info);
+void usbredirparser_send_set_configuration(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_set_configuration_header *set_configuration);
+void usbredirparser_send_get_configuration(struct usbredirparser *parser,
+    uint64_t id);
+void usbredirparser_send_configuration_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_configuration_status_header *configuration_status);
+void usbredirparser_send_set_alt_setting(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_set_alt_setting_header *set_alt_setting);
+void usbredirparser_send_get_alt_setting(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_get_alt_setting_header *get_alt_setting);
+void usbredirparser_send_alt_setting_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_alt_setting_status_header *alt_setting_status);
+void usbredirparser_send_start_iso_stream(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_iso_stream_header *start_iso_stream);
+void usbredirparser_send_stop_iso_stream(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_iso_stream_header *stop_iso_stream);
+void usbredirparser_send_iso_stream_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_iso_stream_status_header *iso_stream_status);
+void usbredirparser_send_start_interrupt_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_interrupt_receiving_header *start_interrupt_receiving);
+void usbredirparser_send_stop_interrupt_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_interrupt_receiving_header *stop_interrupt_receiving);
+void usbredirparser_send_interrupt_receiving_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_interrupt_receiving_status_header *interrupt_receiving_status);
+void usbredirparser_send_alloc_bulk_streams(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_alloc_bulk_streams_header *alloc_bulk_streams);
+void usbredirparser_send_free_bulk_streams(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_free_bulk_streams_header *free_bulk_streams);
+void usbredirparser_send_bulk_streams_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_streams_status_header *bulk_streams_status);
+void usbredirparser_send_cancel_data_packet(struct usbredirparser *parser,
+    uint64_t id);
+void usbredirparser_send_filter_reject(struct usbredirparser *parser);
+void usbredirparser_send_filter_filter(struct usbredirparser *parser,
+    const struct usbredirfilter_rule *rules, int rules_count);
+void usbredirparser_send_start_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_start_bulk_receiving_header *start_bulk_receiving);
+void usbredirparser_send_stop_bulk_receiving(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_stop_bulk_receiving_header *stop_bulk_receiving);
+void usbredirparser_send_bulk_receiving_status(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_receiving_status_header *bulk_receiving_status);
+/* Data packets: */
+void usbredirparser_send_control_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_control_packet_header *control_header,
+    uint8_t *data, int data_len);
+void usbredirparser_send_bulk_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_bulk_packet_header *bulk_header,
+    uint8_t *data, int data_len);
+void usbredirparser_send_iso_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_iso_packet_header *iso_header,
+    uint8_t *data, int data_len);
+void usbredirparser_send_interrupt_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_interrupt_packet_header *interrupt_header,
+    uint8_t *data, int data_len);
+void usbredirparser_send_buffered_bulk_packet(struct usbredirparser *parser,
+    uint64_t id,
+    struct usb_redir_buffered_bulk_packet_header *buffered_bulk_header,
+    uint8_t *data, int data_len);
+
+
+/* Serialization */
+
+/* This function serializes the current usbredirparser state. It will allocate
+   a large enough buffer for this itself and store this in state_dest, it will
+   store the size of this buffer in state_len.
+
+   Return value: 0 on success, -1 on error (out of memory).
+
+   The buffer should be free-ed by the caller using free(). */
+int usbredirparser_serialize(struct usbredirparser *parser,
+                             uint8_t **state_dest, int *state_len);
+
+/* This function sets the current usbredirparser state from a serialized state.
+   This function assumes that the parser has just been initialized with the
+   usbredirparser_fl_no_hello flag.
+
+   Return value: 0 on success, -1 on error (out of memory, or
+                                            invalid state data). */
+int usbredirparser_unserialize(struct usbredirparser *parser_pub,
+                               uint8_t *state, int len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/drivers/usb/usbredir/usbredirproto-compat.h b/drivers/usb/usbredir/usbredirproto-compat.h
new file mode 100644
index 0000000..55d2ccf
--- /dev/null
+++ b/drivers/usb/usbredir/usbredirproto-compat.h
@@ -0,0 +1,88 @@
+/* usbredirproto-compat.h usb redirection compatibility protocol definitions
+
+   Copyright 2011 Red Hat, Inc.
+
+   Red Hat Authors:
+   Hans de Goede <hdegoede@xxxxxxxxxx>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef __USBREDIRPROTO_COMPAT_H
+#define __USBREDIRPROTO_COMPAT_H
+
+/* PACK macros borrowed from spice-protocol */
+#ifdef __GNUC__
+
+#define ATTR_PACKED __attribute__ ((__packed__))
+
+#ifdef __MINGW32__
+#pragma pack(push,1)
+#endif
+
+#else
+
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#pragma warning(disable:4200)
+#pragma warning(disable:4103)
+
+#endif
+
+#if ! defined(__KERNEL__)
+#include <stdint.h>
+#endif
+
+struct usb_redir_device_connect_header_no_device_version {
+    uint8_t speed;
+    uint8_t device_class;
+    uint8_t device_subclass;
+    uint8_t device_protocol;
+    uint16_t vendor_id;
+    uint16_t product_id;
+} ATTR_PACKED;
+
+struct usb_redir_ep_info_header_no_max_pktsz {
+    uint8_t type[32];
+    uint8_t interval[32];
+    uint8_t interface[32];
+} ATTR_PACKED;
+
+struct usb_redir_ep_info_header_no_max_streams {
+    uint8_t type[32];
+    uint8_t interval[32];
+    uint8_t interface[32];
+    uint16_t max_packet_size[32];
+} ATTR_PACKED;
+
+struct usb_redir_header_32bit_id {
+    uint32_t type;
+    uint32_t length;
+    uint32_t id;
+} ATTR_PACKED;
+
+struct usb_redir_bulk_packet_header_16bit_length {
+    uint8_t endpoint;
+    uint8_t status;
+    uint16_t length;
+    uint32_t stream_id;
+} ATTR_PACKED;
+
+#undef ATTR_PACKED
+
+#if defined(__MINGW32__) || !defined(__GNUC__)
+#pragma pack(pop)
+#endif
+
+#endif
diff --git a/drivers/usb/usbredir/usbredirproto.h b/drivers/usb/usbredir/usbredirproto.h
new file mode 100644
index 0000000..46b82e5
--- /dev/null
+++ b/drivers/usb/usbredir/usbredirproto.h
@@ -0,0 +1,309 @@
+/* usbredirproto.h usb redirection protocol definitions
+
+   Copyright 2010-2011 Red Hat, Inc.
+
+   Red Hat Authors:
+   Hans de Goede <hdegoede@xxxxxxxxxx>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   This library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef __USBREDIRPROTO_H
+#define __USBREDIRPROTO_H
+
+/* PACK macros borrowed from spice-protocol */
+#ifdef __GNUC__
+
+#define ATTR_PACKED __attribute__ ((__packed__))
+
+#ifdef __MINGW32__
+#pragma pack(push,1)
+#endif
+
+#else
+
+#pragma pack(push)
+#pragma pack(1)
+#define ATTR_PACKED
+#pragma warning(disable:4200)
+#pragma warning(disable:4103)
+
+#endif
+
+#if ! defined(__KERNEL__)
+#include <stdint.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define USBREDIR_VERSION 0x000700 /* 0.7 [.0] */
+
+enum {
+    usb_redir_success,
+    usb_redir_cancelled,    /* The transfer was cancelled */
+    usb_redir_inval,        /* Invalid packet type / length / ep, etc. */
+    usb_redir_ioerror,      /* IO error */
+    usb_redir_stall,        /* Stalled */
+    usb_redir_timeout,      /* Request timed out */
+    usb_redir_babble,       /* The device has "babbled" (since 0.4.2) */
+};
+
+enum {
+    /* Note these 4 match the usb spec! */
+    usb_redir_type_control,
+    usb_redir_type_iso,
+    usb_redir_type_bulk,
+    usb_redir_type_interrupt,
+    usb_redir_type_invalid = 255
+};
+
+enum {
+    usb_redir_speed_low,
+    usb_redir_speed_full,
+    usb_redir_speed_high,
+    usb_redir_speed_super,
+    usb_redir_speed_unknown = 255
+};
+
+enum {
+    /* Control packets */
+    usb_redir_hello,
+    usb_redir_device_connect,
+    usb_redir_device_disconnect,
+    usb_redir_reset,
+    usb_redir_interface_info,
+    usb_redir_ep_info,
+    usb_redir_set_configuration,
+    usb_redir_get_configuration,
+    usb_redir_configuration_status,
+    usb_redir_set_alt_setting,
+    usb_redir_get_alt_setting,
+    usb_redir_alt_setting_status,
+    usb_redir_start_iso_stream,
+    usb_redir_stop_iso_stream,
+    usb_redir_iso_stream_status,
+    usb_redir_start_interrupt_receiving,
+    usb_redir_stop_interrupt_receiving,
+    usb_redir_interrupt_receiving_status,
+    usb_redir_alloc_bulk_streams,
+    usb_redir_free_bulk_streams,
+    usb_redir_bulk_streams_status,
+    usb_redir_cancel_data_packet,
+    usb_redir_filter_reject,
+    usb_redir_filter_filter,
+    usb_redir_device_disconnect_ack,
+    usb_redir_start_bulk_receiving,
+    usb_redir_stop_bulk_receiving,
+    usb_redir_bulk_receiving_status,
+
+    /* Data packets */
+    usb_redir_control_packet = 100,
+    usb_redir_bulk_packet,
+    usb_redir_iso_packet,
+    usb_redir_interrupt_packet,
+    usb_redir_buffered_bulk_packet,
+};
+
+enum {
+    /* Supports USB 3 bulk streams */
+    usb_redir_cap_bulk_streams, 
+    /* The device_connect packet has the device_version_bcd field */
+    usb_redir_cap_connect_device_version,
+    /* Supports usb_redir_filter_reject and usb_redir_filter_filter pkts */
+    usb_redir_cap_filter,
+    /* Supports the usb_redir_device_disconnect_ack packet */
+    usb_redir_cap_device_disconnect_ack,
+    /* The ep_info packet has the max_packet_size field */
+    usb_redir_cap_ep_info_max_packet_size,
+    /* Supports 64 bits ids in usb_redir_header */
+    usb_redir_cap_64bits_ids,
+    /* Supports 32 bits length in usb_redir_bulk_packet_header */
+    usb_redir_cap_32bits_bulk_length,
+    /* Supports bulk receiving / buffered bulk input */
+    usb_redir_cap_bulk_receiving,
+};
+/* Number of uint32_t-s needed to hold all (known) capabilities */
+#define USB_REDIR_CAPS_SIZE 1
+
+struct usb_redir_header {
+    uint32_t type;
+    uint32_t length;
+    uint64_t id;  
+} ATTR_PACKED;
+
+struct usb_redir_hello_header {
+    char     version[64];
+    uint32_t capabilities[0];
+} ATTR_PACKED;
+
+struct usb_redir_device_connect_header {
+    uint8_t speed;
+    uint8_t device_class;
+    uint8_t device_subclass;
+    uint8_t device_protocol;
+    uint16_t vendor_id;
+    uint16_t product_id;
+    uint16_t device_version_bcd;
+} ATTR_PACKED;
+
+struct usb_redir_interface_info_header {
+    uint32_t interface_count;
+    uint8_t interface[32];
+    uint8_t interface_class[32];
+    uint8_t interface_subclass[32];
+    uint8_t interface_protocol[32];
+} ATTR_PACKED;
+
+struct usb_redir_ep_info_header {
+    uint8_t type[32];
+    uint8_t interval[32];
+    uint8_t interface[32];
+    uint16_t max_packet_size[32];
+    uint32_t max_streams[32];
+} ATTR_PACKED;
+
+struct usb_redir_set_configuration_header {
+    uint8_t configuration;
+} ATTR_PACKED;
+
+struct usb_redir_configuration_status_header {
+    uint8_t status;
+    uint8_t configuration;
+} ATTR_PACKED;
+
+struct usb_redir_set_alt_setting_header {
+    uint8_t interface;
+    uint8_t alt;
+} ATTR_PACKED;
+
+struct usb_redir_get_alt_setting_header {
+    uint8_t interface;
+} ATTR_PACKED;
+
+struct usb_redir_alt_setting_status_header {
+    uint8_t status;
+    uint8_t interface;
+    uint8_t alt;
+} ATTR_PACKED;
+
+struct usb_redir_start_iso_stream_header {
+    uint8_t endpoint;
+    uint8_t pkts_per_urb;
+    uint8_t no_urbs;
+} ATTR_PACKED;
+
+struct usb_redir_stop_iso_stream_header {
+    uint8_t endpoint;
+} ATTR_PACKED;
+
+struct usb_redir_iso_stream_status_header {
+    uint8_t status;
+    uint8_t endpoint;
+} ATTR_PACKED;
+
+struct usb_redir_start_interrupt_receiving_header {
+    uint8_t endpoint;
+} ATTR_PACKED;
+
+struct usb_redir_stop_interrupt_receiving_header {
+    uint8_t endpoint;
+} ATTR_PACKED;
+
+struct usb_redir_interrupt_receiving_status_header {
+    uint8_t status;
+    uint8_t endpoint;
+} ATTR_PACKED;
+
+struct usb_redir_alloc_bulk_streams_header {
+    uint32_t endpoints; /* bitmask indicating on which eps to alloc streams */
+    uint32_t no_streams;
+} ATTR_PACKED;
+
+struct usb_redir_free_bulk_streams_header {
+    uint32_t endpoints; /* bitmask indicating on which eps to free streams */
+} ATTR_PACKED;
+
+struct usb_redir_bulk_streams_status_header {
+    uint32_t endpoints; /* bitmask indicating eps this status message is for */
+    uint32_t no_streams;
+    uint8_t status;
+} ATTR_PACKED;
+
+struct usb_redir_start_bulk_receiving_header {
+    uint32_t stream_id;
+    uint32_t bytes_per_transfer;
+    uint8_t endpoint;
+    uint8_t no_transfers;
+} ATTR_PACKED;
+
+struct usb_redir_stop_bulk_receiving_header {
+    uint32_t stream_id;
+    uint8_t endpoint;
+} ATTR_PACKED;
+
+struct usb_redir_bulk_receiving_status_header {
+    uint32_t stream_id;
+    uint8_t endpoint;
+    uint8_t status;
+} ATTR_PACKED;
+
+struct usb_redir_control_packet_header {
+    uint8_t endpoint;
+    uint8_t request;
+    uint8_t requesttype;
+    uint8_t status;
+    uint16_t value;
+    uint16_t index;
+    uint16_t length; 
+} ATTR_PACKED;
+
+struct usb_redir_bulk_packet_header {
+    uint8_t endpoint;
+    uint8_t status;
+    uint16_t length;
+    uint32_t stream_id;
+    uint16_t length_high; /* High 16 bits of the packet length */
+} ATTR_PACKED;
+
+struct usb_redir_iso_packet_header {
+    uint8_t endpoint;
+    uint8_t status;
+    uint16_t length;
+} ATTR_PACKED;
+
+struct usb_redir_interrupt_packet_header {
+    uint8_t endpoint;
+    uint8_t status;
+    uint16_t length;
+} ATTR_PACKED;
+
+struct usb_redir_buffered_bulk_packet_header {
+    uint32_t stream_id;
+    uint32_t length;
+    uint8_t endpoint;
+    uint8_t status;
+} ATTR_PACKED;
+
+#undef ATTR_PACKED
+
+#if defined(__MINGW32__) || !defined(__GNUC__)
+#pragma pack(pop)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
-- 
2.1.4

_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/spice-devel





[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]